{"text": "#!python\n# This file is subject to the terms and conditions defined in\n# file 'LICENCE', which is part of this source code package.\n# Author: Leo Guignard (guignardl...@AT@...janelia.hhmi.org)\n\nfrom scipy.spatial import cKDTree as KDTree\nimport os\nimport xml.etree.ElementTree as ET\nfrom copy import copy\nfrom scipy import spatial\nimport numpy as np\nfrom multiprocessing import Pool\nfrom scipy.spatial import Delaunay\nfrom itertools import combinations\nimport struct\nimport sys\n\nclass lineageTree(object):\n ''' lineageTree is a class container for lineage tree structures\n The main attributes are the following:\n self.nodes: [int, ], list of node/cell ids\n self.edges: [(int, int), ], a list of couple of cell/objects ids that represents the edges\n self.time_nodes: {int, [int, ]}, a dictionary that maps time points to\n a list of cell ids that belong to that time point\n self.time_edges: {int, [(int, int), ]}, a dictionary that maps time points to\n a list of edges couples that belong to that time point\n self.successor: {int, [int, ]}, a dictionary that maps a cell id to\n the list of its successors in time\n self.predecessor: {int, [int, ]}, a dictionary that maps a cell id to\n the list of its predecessors in time\n self.time: {int: int, }, a dictionary that maps a cell to the time\n it belongs to.\n '''\n\n def _dist_v(self, v1, v2):\n ''' Computes the L2 norm between two vectors v1 and v2\n Args:\n v1: [float, ], list of values for the first vector\n v2: [float, ], list of values for the second vector\n Return:\n float: L2 norm between v1 and v2\n '''\n v1 = np.array(v1)\n v2 = np.array(v2)\n return np.sum((v1-v2)**2)**(.5)\n\n def get_next_id(self):\n ''' Computes the next authorized id.\n Returns:\n int, next authorized id\n '''\n if self.next_id == []:\n self.max_id += 1\n return self.max_id\n else:\n return self.next_id.pop()\n\n def add_node(self, t, succ, pos, id = None, reverse = False):\n ''' Adds a node to the lineageTree and update it accordingly.\n Args:\n t: int, time to which to add the node\n succ: id of the node the new node is a successor to\n pos: [float, ], list of three floats representing the 3D spatial position of the node\n id: id value of the new node, to be used carefully, \n if None is provided the new id is automatically computed.\n reverse: bool, True if in this lineageTree the predecessors are the successors and reciprocally.\n This is there for bacward compatibility, should be left at False.\n Returns:\n C_next: int, id of the new node.\n '''\n if id is None:\n C_next = self.get_next_id()\n else:\n C_next = id\n self.time_nodes.setdefault(t, []).append(C_next)\n if not succ is None and not reverse:\n self.successor.setdefault(succ, []).append(C_next)\n self.predecessor.setdefault(C_next, []).append(succ)\n self.edges.append((succ, C_next))\n elif not succ is None:\n self.predecessor.setdefault(succ, []).append(C_next)\n self.successor.setdefault(C_next, []).append(succ)\n self.edges.append((C_next, succ))\n else:\n self.roots.append(C_next)\n self.nodes.append(C_next)\n self.pos[C_next] = pos\n self.progeny[C_next] = 0\n self.time[C_next] = t\n return C_next\n\n def remove_node(self, c):\n ''' Removes a node and update the lineageTree accordingly\n Args:\n c: int, id of the node to remove\n '''\n self.nodes.remove(c)\n self.time_nodes[self.time[c]].remove(c)\n # self.time_nodes.pop(c, 0)\n pos = self.pos.pop(c, 0)\n e_to_remove = [e for e in self.edges if c in e]\n for e in e_to_remove:\n self.edges.remove(e)\n if c in self.roots:\n self.roots.remove(c)\n succ = self.successor.pop(c, [])\n s_to_remove = [s for s, ci in self.successor.iteritems() if c in ci]\n for s in s_to_remove:\n self.successor[s].remove(c)\n\n pred = self.predecessor.pop(c, [])\n p_to_remove = [s for s, ci in self.predecessor.iteritems() if ci == c]\n for s in p_to_remove:\n self.predecessor[s].remove(c)\n\n self.time.pop(c, 0)\n self.spatial_density.pop(c, 0)\n\n self.next_id.append(c)\n return e_to_remove, succ, s_to_remove, pred, p_to_remove, pos\n\n def fuse_nodes(self, c1, c2):\n ''' Fuses together two nodes that belong to the same time point\n and update the lineageTree accordingly.\n Args:\n c1: int, id of the first node to fuse\n c2: int, id of the second node to fuse\n '''\n e_to_remove, succ, s_to_remove, pred, p_to_remove, c2_pos = self.remove_node(c2)\n for e in e_to_remove:\n new_e = [c1] + [other_c for other_c in e if e != c2]\n self.edges.append(new_e)\n\n self.successor.setdefault(c1, []).extend(succ)\n self.predecessor.setdefault(c1, []).extend(pred)\n\n for s in s_to_remove:\n self.successor[s].append(c1)\n\n for p in p_to_remove:\n self.predecessor[p].append(c1)\n\n\n self.pos[c1] = np.mean([self.pos[c1], c2_pos], axis = 0)\n self.progeny[c1] += 1\n\n def to_tlp(self, fname, t_min=-1, t_max=np.inf, temporal=True, spatial=False, VF=False):\n '''\n Write a lineage tree into an understable tulip file\n Args:\n fname: string, path to the tulip file to create\n t_min: int, minimum time to consider, default -1\n t_max: int, maximum time to consider, default np.inf\n temporal: boolean, True if the temporal links should be printed, default True\n spatial: boolean, True if the special links should be printed, default True\n VF: boolean, useless\n '''\n f=open(fname, \"w\")\n\n f.write(\"(tlp \\\"2.0\\\"\\n\")\n f.write(\"(nodes \")\n if t_max!=np.inf or t_min>-1:\n nodes_to_use = [n for n in self.nodes if t_mindist_max))\n cells_to_keep = closest_cells[:max_value]\n subset_dist = [np.mean([pos[cii] for cii in predecessor[ci]], axis=0) - pos[ci] for ci in cells_to_keep if not ci in R]\n if subset_dist != []:\n med_distance = spatial.distance.squareform(spatial.distance.pdist(subset_dist))\n med = subset_dist[np.argmin(np.sum(med_distance, axis=0))]\n else:\n med = [0, 0, 0]\n return C, med\n \n def read_from_xml(self, file_format, tb, te, z_mult=1., mask = None):\n ''' Reads a lineage tree from TGMM xml output.\n Args:\n file_format: string, path to the xmls location.\n it should be written as follow:\n path/to/xml/standard_name_t%06d.xml where (as an example)\n %06d means a series of 6 digits representing the time and\n if the time values is smaller that 6 digits, the missing\n digits are filed with 0s\n tb: int, first time point to read\n te: int, last time point to read\n z_mult: float, aspect ratio\n mask: SpatialImage, binary image that specify the region to read\n '''\n self.time_nodes = {}\n self.time_edges = {}\n unique_id = 0\n self.nodes = []\n self.edges = []\n self.roots = []\n self.successor = {}\n self.predecessor = {}\n self.pos = {}\n self.time_id = {}\n self.time = {}\n self.mother_not_found = []\n self.ind_cells = {}\n self.svIdx = {}\n self.is_root = {}\n self.lin = {}\n self.C_lin = {}\n self.coeffs = {}\n self.intensity = {}\n self.W = {}\n for t in range(tb, te+1):\n print t,\n if t%10==0:\n print\n tree = ET.parse(file_format%t)\n root = tree.getroot()\n self.time_nodes[t] = []\n self.time_edges[t] = []\n for it in root:\n if not '-1.#IND' in it.attrib['m']:\n M_id, pos, cell_id, svIdx, lin_id = (int(it.attrib['parent']), \n [float(v) for v in it.attrib['m'].split(' ') if v!=''], \n int(it.attrib['id']),\n [int(v) for v in it.attrib['svIdx'].split(' ') if v!=''],\n int(it.attrib['lineage']))\n try:\n alpha, W, nu, alphaPrior = (float(it.attrib['alpha']),\n [float(v) for v in it.attrib['W'].split(' ') if v!=''],\n float(it.attrib['nu']),\n float(it.attrib['alphaPrior']))\n pos = np.array(pos)\n pos_tmp = np.round(pos).astype(np.uint16)\n if mask is None or mask[pos_tmp[0], pos_tmp[1], pos_tmp[2]]:\n C = unique_id\n pos[-1] = pos[-1]*z_mult\n if (t-1, M_id) in self.time_id:\n M = self.time_id[(t-1, M_id)]\n self.successor.setdefault(M, []).append(C)\n self.predecessor.setdefault(C, []).append(M)\n self.edges.append((M, C))\n self.time_edges[t].append((M, C))\n self.is_root[C] = False\n else:\n if M_id != -1:\n self.mother_not_found.append(C)\n self.roots.append(C)\n self.is_root[C] = True\n self.pos[C] = pos\n self.nodes.append(C)\n self.time_nodes[t].append(C)\n self.time_id[(t, cell_id)] = C\n self.time[C] = t\n self.svIdx[C] = svIdx\n self.lin.setdefault(lin_id, []).append(C)\n self.C_lin[C] = lin_id\n self.intensity[C] = max(alpha - alphaPrior, 0)\n tmp = list(np.array(W) * nu)\n self.W[C] = np.array(W).reshape(3, 3)\n self.coeffs[C] = tmp[:3] + tmp[4:6] + tmp[8:9] + list(pos)\n unique_id += 1\n except Exception, e:\n pass\n else:\n if self.ind_cells.has_key(t):\n self.ind_cells[t] += 1\n else:\n self.ind_cells[t] = 1\n self.max_id = unique_id - 1\n\n def read_from_mamut_xml(self, path):\n ''' Read a lineage tree from a MaMuT xml.\n Args:\n path: string, path to the MaMut xml\n '''\n tree = ET.parse(path)\n Model = tree.getroot()[0]\n FeatureDeclarations, AllSpots, AllTracks, FilteredTracks = list(Model)\n\n self.time_nodes = {}\n self.time_edges = {}\n self.nodes = []\n self.pos = {}\n self.time = {}\n self.node_name = {}\n for frame in AllSpots:\n t = int(frame.attrib['frame'])\n self.time_nodes[t] = []\n for cell in frame:\n cell_id, n, x, y, z = (int(cell.attrib['ID']), cell.attrib['name'],\n float(cell.attrib['POSITION_X']),\n float(cell.attrib['POSITION_Y']),\n float(cell.attrib['POSITION_Z']))\n self.time_nodes[t].append(cell_id)\n self.nodes.append(cell_id)\n self.pos[cell_id] = np.array([x, y, z])\n self.time[cell_id] = t\n self.node_name[cell_id] = n\n\n self.edges = []\n self.roots = []\n tracks = {}\n self.successor = {}\n self.predecessor = {}\n for track in AllTracks:\n t_id, l = int(track.attrib['TRACK_ID']), float(track.attrib['TRACK_DURATION'])\n tracks[t_id] = []\n for edge in track:\n s, t = int(edge.attrib['SPOT_SOURCE_ID']), int(edge.attrib['SPOT_TARGET_ID'])\n if s in self.nodes and t in self.nodes:\n if self.time[s] > self.time[t]:\n s, t = t, s\n self.successor.setdefault(s, []).append(t)\n self.predecessor.setdefault(t, []).append(s)\n tracks[t_id].append((s, t))\n self.edges.append((s, t))\n self.t_b = min(self.time_nodes.keys())\n self.t_e = max(self.time_nodes.keys())\n \n def to_binary(self, fname, starting_points = None):\n ''' Writes the lineage tree (a forest) as a binary structure\n (assuming it is a binary tree, it would not work for *n*ary tree with 2 < *n*).\n The binary file is composed of 3 sequences of numbers and\n a header specifying the size of each of these sequences.\n The first sequence, *number_sequence*, represents the lineage tree\n as a DFT preporder transversal list. -1 signifying a leaf and -2 a branching\n The second sequence, *time_sequence*, represent the starting time of each tree.\n The third sequence, *pos_sequence*, reprensent the 3D coordinates of the objects.\n The header specify the size of each of these sequences.\n Each size is stored as a long long\n The *number_sequence* is stored as a list of long long (0 -> 2^(8*8)-1)\n The *time_sequence* is stored as a list of unsigned short (0 -> 2^(8*2)-1)\n The *pos_sequence* is stored as a list of double\n Args:\n fname: string, name of the binary file\n starting_points: [int, ], list of the roots to be written.\n If None, all roots are written\n Default: None\n '''\n if starting_points is None:\n starting_points = [c for c in self.successor.iterkeys() if self.predecessor.get(c, []) == []]\n number_sequence = [-1]\n pos_sequence = []\n time_sequence = []\n default_lin = -1\n for c in starting_points:\n time_sequence.append(self.time.get(c, 0))\n to_treat = [c]\n while to_treat != []:\n curr_c = to_treat.pop()\n number_sequence.append(curr_c)\n pos_sequence += list(self.pos[curr_c])\n if self.successor.get(curr_c, []) == []:\n number_sequence.append(-1)\n elif len(self.successor[curr_c]) == 1:\n to_treat += self.successor[curr_c]\n else:\n number_sequence.append(-2)\n to_treat += self.successor[curr_c]\n remaining_nodes = set(self.nodes) - set(number_sequence)\n\n for c in remaining_nodes:\n time_sequence.append(self.time.get(c, 0))\n number_sequence.append(c)\n pos_sequence += list(self.pos[c])\n number_sequence.append(-1)\n\n f = open(fname, 'wb')\n f.write(struct.pack('q', len(number_sequence)))\n f.write(struct.pack('q', len(time_sequence)))\n f.write(struct.pack('q', len(pos_sequence)))\n f.write(struct.pack('q'*len(number_sequence), *number_sequence))\n f.write(struct.pack('H'*len(time_sequence), *time_sequence))\n f.write(struct.pack('d'*len(pos_sequence), *pos_sequence))\n\n f.close()\n\n\n def read_from_binary(self, fname, reverse_time = False):\n ''' Reads a binary lineageTree file name.\n Format description:\n see self.to_binary\n Args:\n fname: string, path to the binary file\n reverse_time: bool, not used\n '''\n q_size = struct.calcsize('q')\n H_size = struct.calcsize('H')\n d_size = struct.calcsize('d')\n\n f = open(fname, 'rb')\n len_tree = struct.unpack('q', f.read(q_size))[0]\n len_time = struct.unpack('q', f.read(q_size))[0]\n len_pos = struct.unpack('q', f.read(q_size))[0]\n number_sequence = list(struct.unpack('q'*len_tree, f.read(q_size*len_tree)))\n time_sequence = list(struct.unpack('H'*len_time, f.read(H_size*len_time)))\n pos_sequence = np.array(struct.unpack('d'*len_pos, f.read(d_size*len_pos)))\n\n f.close()\n\n successor = {}\n predecessor = {}\n time = {}\n time_nodes = {}\n time_edges = {}\n pos = {}\n is_root = {}\n nodes = []\n edges = []\n waiting_list = []\n print number_sequence[0]\n i = 0\n done = False\n if max(number_sequence[::2]) == -1:\n # number_sequence = number_sequence[1::2]\n tmp = number_sequence[1::2]\n if len(tmp)*3 == len(pos_sequence) == len(time_sequence)*3:\n time = dict(zip(tmp, time_sequence))\n for c, t in time.iteritems():\n time_nodes.setdefault(t, []).append(c)\n pos = dict(zip(tmp, np.reshape(pos_sequence, (len_time, 3))))\n is_root = {c:True for c in tmp}\n nodes = tmp\n done = True\n shown = set()\n while i < len(number_sequence) and not done:#, c in enumerate(number_sequence[:-1]):\n c = number_sequence[i]\n # if (1000.*i)//len(number_sequence)%10==0 and not (1000.*i)//len(number_sequence) in shown:\n # shown.add((1000.*i)//len(number_sequence))\n # sys.stdout.write('\\b'*(4))\n # sys.stdout.flush()\n # sys.stdout.write(\"%03d\"%((100*i)//len(number_sequence))+\"%\")#(100*i)//len(number_sequence)\n # sys.stdout.flush()\n if c == -1:\n if waiting_list != []:\n prev_mother = waiting_list.pop()\n successor[prev_mother].insert(0, number_sequence[i+1])\n edges.append((prev_mother, number_sequence[i+1]))\n time_edges.setdefault(t, []).append((prev_mother, number_sequence[i+1]))\n is_root[number_sequence[i+1]] = False\n t = time[prev_mother] + 1\n else:\n t = time_sequence.pop(0)\n is_root[number_sequence[i+1]] = True\n\n elif c == -2:\n successor[waiting_list[-1]] = [number_sequence[i+1]]\n edges.append((waiting_list[-1], number_sequence[i+1]))\n time_edges.setdefault(t, []).append((waiting_list[-1], number_sequence[i+1]))\n is_root[number_sequence[i+1]] = False\n pos[waiting_list[-1]] = pos_sequence[:3]\n pos_sequence = pos_sequence[3:]\n nodes.append(waiting_list[-1])\n time[waiting_list[-1]] = t\n time_nodes.setdefault(t, []).append(waiting_list[-1])\n t += 1\n\n elif number_sequence[i+1] >= 0:\n successor[c] = [number_sequence[i+1]]\n edges.append((c, number_sequence[i+1]))\n time_edges.setdefault(t, []).append((c, number_sequence[i+1]))\n is_root[number_sequence[i+1]] = False\n pos[c] = pos_sequence[:3]\n pos_sequence = pos_sequence[3:]\n nodes.append(c)\n time[c] = t\n time_nodes.setdefault(t, []).append(c)\n t += 1\n\n elif number_sequence[i+1] == -2:\n waiting_list += [c]\n\n elif number_sequence[i+1] == -1:\n pos[c] = pos_sequence[:3]\n pos_sequence = pos_sequence[3:]\n nodes.append(c)\n time[c] = t\n time_nodes.setdefault(t, []).append(c)\n t += 1\n i += 1\n if waiting_list != []:\n prev_mother = waiting_list.pop()\n successor[prev_mother].insert(0, number_sequence[i+1])\n edges.append((prev_mother, number_sequence[i+1]))\n time_edges.setdefault(t, []).append((prev_mother, number_sequence[i+1]))\n if i+1 1)\n TMP = []\n for C_self in self_too_close:\n to_potentially_fuse, = np.where(equivalence == C_self)\n pos_tmp = [self.VF.pos[to_check_VF[c]] for c in to_potentially_fuse]\n dist_tmp = spatial.distance.squareform(spatial.distance.pdist(pos_tmp))\n dist_tmp[dist_tmp==0] = np.inf\n if (dist_tmp1)[0]]\n for C in to_add:\n self.VF.add_node(t-1, None, self.pos[C])\n\n print 'Addition done (%f s); '%(time() - tic),\n print '#cells: %d'%(len(self.VF.time_nodes[t-1]))\n\n self.VF.t_b = t_b\n self.VF.t_e = t_e\n\n return self.VF\n\n def compute_spatial_density(self, t_b=0, t_e=200, n_size=10):\n ''' Computes the average distance between the *n_size* closest object for a set of time points\n The results is stored in self.spatial_density\n Args:\n t_b: int, starting time to look at\n t_e: int, ending time to look at\n n_size: int, number of neighbors to look at\n '''\n time_range = [t for t in self.time_nodes.keys() if t_b <= t <= t_e]\n for t in time_range:\n Cs = self.time_nodes[t]\n data_corres = {}\n data = []\n for i, C in enumerate(Cs):\n data.append(tuple(self.pos[C]))\n data_corres[i] = C\n if not self.kdtrees.has_key(t):\n idx3d = KDTree(data)\n else:\n idx3d = self.kdtrees[t]\n distances, indices = idx3d.query(data, n_size)\n self.spatial_density.update(dict(zip(Cs, np.mean(distances[:, 1:], axis=1))))\n\n def compute_spatial_edges(self, th=50):\n ''' Innefitiently computes the connection between cells at a given distance\n Writes the output in self.spatial_edges\n Args:\n th: float, distance to consider neighbors\n '''\n self.spatial_edges=[]\n for t, Cs in self.time_nodes.iteritems():\n nodes_tmp, pos_tmp = zip(*[(C, C.pos) for C in Cs])\n nodes_tmp = np.array(nodes_tmp)\n distances = spatial.distance.squareform(spatial.distance.pdist(pos_tmp))\n nodes_to_match = np.where((0 float:\n # x = model['time (s)']\n # y = model['rsh (ohms cm^2)']\n # f = interpolate.interp1d(x, y)\n # y_pred = f(time_s)\n y = np.array(y)\n m = len(y)\n diff = np.log10(y / y[0]) - np.log10(rsh_norm_)\n r = 0.5 * np.dot(diff.T, diff) / m\n return r\n\n\ndef func(beta, **kwargs_):\n temp = kwargs_.get('temp', 85)\n rate_source_ = kwargs_.get('rate_source', 1E-4)\n DSIN_ = kwargs_.get('DSIN', 3.92E-16)\n stress_voltage = kwargs_.get('stress_voltage', 3.75)\n L1_ = kwargs_.get('L1', 0.075)\n N1_ = int(kwargs_.get('N1', 100))\n tsteps_ = int(kwargs_.get('tsteps', 360))\n time_s = kwargs_.get('time_s', np.array([0]))\n # h5_file = kwargs_.get('h5file', None)\n\n S0_ = float(beta[0])\n h_ = float(beta[1])\n DSF_ = float(beta[2])\n h5_file = beta[3]\n print('func, h5file: {0}'.format(h5_file))\n\n kw = dict(\n simulation_time=np.amax(time_s) * 1.1,\n temperature=temp, rate_source=rate_source_, DSIN=DSIN_,\n stress_voltage=stress_voltage, L1=L1_, m=1, time_steps=tsteps_,\n N1=N1_, h5file=h5_file\n )\n\n model = simulate_rsh(\n S0=S0_, h=h_, DSF=DSF_, **kw\n )\n\n f = interpolate.interp1d(model['time (s)'], model['rsh (ohms cm^2)'])\n y_pred = f(time_s)\n\n base_dir = os.path.dirname(h5_file)\n base_name = os.path.splitext(os.path.basename(h5_file))[0]\n csv_file = os.path.join(base_dir, base_name + '.csv')\n csv_df = pd.DataFrame(\n data={\n 'time (s)': time_s,\n 'Rsh (ohm cm^2)': y_pred,\n 'Rsh norm': y_pred / y_pred[0]\n }\n )\n csv_df.to_csv(path_or_buf=csv_file, index=False)\n\n return y_pred\n\n\ndef get_logger(output_path, file_tag, name):\n log_file_tag = '{0}_{1}.log'.format(file_tag, name)\n log_file = os.path.join(output_path, log_file_tag)\n\n # logging.basicConfig(filename=logFile, level=logging.INFO)\n # get pnp_logger\n fit_logger = logging.getLogger('simlog')\n fit_logger.setLevel(logging.DEBUG)\n # create file handler which logs even debug messages\n fh = logging.FileHandler(log_file)\n fh.setLevel(logging.DEBUG)\n # create console handler and set level to debug\n ch = logging.StreamHandler()\n ch.setLevel(logging.DEBUG)\n # create formatter and add it to the handlers\n # formatter \t= logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')\n # ch.setFormatter(formatter)\n # fh.setFormatter(formatter)\n\n # add the handlers to the logger\n fit_logger.addHandler(fh)\n fit_logger.addHandler(ch)\n\n return fit_logger\n\n\ndef simulate_rsh(S0: float, h: float, DSF: float, h5file: float, *args, **kwargs) -> np.ndarray:\n \"\"\"\n This function simulates the PID kinetics for a p-Si Al-BSF PV module using a trained RFR model.\n Na transport is simulated using FEniCS.\n\n Parameters\n ----------\n S0: float\n The initial Na surface concentration at the source in 1/cm^2\n h: float\n The surface mass transfer coefficient at the SiNx/Si interface\n DSF: float\n The diffusion coefficient of Na in the stacking fault\n args: list\n Positional arguments\n kwargs: dict\n Keyword arguments\n\n Returns\n -------\n np.ndarray:\n Rsh as a function of PID stress time\n \"\"\"\n # The total simulation time in seconds\n t_max = float(kwargs.get('simulation_time', 345600))\n # Temperature in celsius\n temp_c = float(kwargs.get('temperature', 85))\n # The bulk concentration (cm-3)\n c_bulk = float(kwargs.get('cb', 1E-20))\n # The number of time steps\n tsteps = int(kwargs.get('time_steps', 720))\n # The surface concentration of the sourceW\n surface_concentration = S0\n # The rate of ingress at the source in 1/s.\n rate_source = float(kwargs.get('rate_source', 1E-4))\n\n # The diffusion coefficient of layer 1 in cm2/s\n D1cms = float(kwargs.get('DSIN', 3.92E-16))\n # The diffusion coefficient of layer 1 in cm2/s\n D2cms = DSF\n # The dielectric constant of the dielectric\n er = float(kwargs.get('er', 7.0))\n # The electric fields\n voltage = float(kwargs.get('stress_voltage', 3.75)) # volts\n # The geometry\n L1 = float(kwargs.get('L1', 0.075)) # um\n # The number of points in the sinx layer\n x1points = int(kwargs.get('N1', 100))\n # The thickness of the simulated Si layer in um\n L2 = float(kwargs.get('L2', 1.0))\n # The number of points in the layer\n x2points = int(kwargs.get('N2', 100))\n # The segregation coefficient at the SiNx/Si interface\n m = float(kwargs.get('m', 1.0))\n\n e_field = voltage / L1 / 100\n\n # The configuration file\n # Logging\n\n try:\n out_path = os.path.dirname(h5file)\n file_tag = os.path.splitext(os.path.basename(h5file))[0]\n\n myLogger = get_logger(out_path, file_tag, name='pnp')\n _, _, _, _, _, _, _, _ = pnpfs.two_layers_constant_flux(\n D1cms=D1cms, D2cms=D2cms,\n h=h, m=m,\n thickness_sinx=L1,\n thickness_si=L2,\n tempC=temp_c,\n voltage=voltage,\n time_s=t_max,\n surface_concentration=surface_concentration,\n rate=rate_source,\n recovery_time_s=0,\n recovery_voltage=0,\n fcallLogger=myLogger,\n xpoints_sinx=x1points,\n xpoints_si=x2points,\n tsteps=tsteps,\n h5_storage=h5file,\n er=er,\n z=1.0,\n maxr_calls=2,\n trapping=False,\n c_fp=0.0,\n cbulk=c_bulk,\n debug=True\n )\n\n except Exception as e:\n traceback.print_exc()\n print('Error occured trying to simulate.')\n print(e)\n\n rfr_simulator = ml_kinetics.MLSim(h5_transport_file=h5file)\n time_s = rfr_simulator.time_s\n requested_indices = rfr_simulator.get_requested_time_indices(time_s)\n rsh = rfr_simulator.rsh_time_series(requested_indices=requested_indices)\n\n result = np.empty(len(rsh), dtype=np.dtype([('time (s)', 'd'), ('rsh (ohms cm^2)', 'd')]))\n for i, t, r in zip(range(len(time_s)), time_s, rsh):\n result[i] = (t, r)\n print(result)\n\n return result\n\n\nif __name__ == \"__main__\":\n root_dir = os.path.dirname(csv_file)\n file_tag = os.path.basename(csv_file)\n file_tag = os.path.splitext(file_tag)[0]\n\n exp_df = pd.read_csv(csv_file)\n exp_df = exp_df[exp_df['time (s)'] <= 345600]\n time = np.array(exp_df['time (s)'].values)\n rsh = np.array(exp_df['Rsh (ohm cm^2)'].values)\n rsh_norm = rsh / rsh[0]\n\n base_path = r'/home/fenics/shared/fenics/shared/pid_fit/combinations'\n\n if not os.path.exists(base_path):\n os.makedirs(base_path)\n now = datetime.now()\n time_stamp = now.strftime('%Y%m%d-%H%M%S_%f')\n out_path = os.path.join(base_path, time_stamp)\n if not os.path.exists(out_path):\n os.makedirs(out_path)\n\n # The total simulation time in seconds\n t_max = time.max()\n # Temperature in celsius\n temp_c = 85\n # The bulk concentration (cm-3)\n c_bulk = 1E-20\n # The number of time steps\n tsteps = 360\n\n # The rate of ingress at the source in 1/s.\n rate_source = 1E-4\n\n # The diffusion coefficient of layer 1 in cm2/s\n D1cms = 3.92E-16\n\n # The dielectric constant of the dielectric\n er = 7.0\n e_field = voltage / L1 / 100\n\n if not os.path.exists(out_path):\n os.makedirs(out_path)\n\n kw = dict(\n temperature=temperature,\n tsteps=tsteps,\n rate_source=rate_source,\n DSIN=DSIN,\n er=7.0,\n stress_voltage=voltage,\n L1=L1,\n N1=N1,\n L2=L1,\n N2=N2,\n time_s=time,\n rsh_norm=rsh_norm,\n out_path=out_path\n )\n\n now = datetime.now()\n time_stamp = now.strftime('%Y%m%d-%H%M%S')\n file_tag = '{0}_{1}'.format(file_tag, time_stamp)\n\n n_simulations = len(S0_s) * len(h_s) * len(DSF_s)\n\n pool = multiprocessing.Pool(70)\n\n sim_params = []\n\n for s in S0_s:\n for hi in h_s:\n for d in DSF_s:\n filetag = create_filetag(\n time_s=t_max,\n temp_c=temp_c,\n sigma_s=s,\n zeta=rate_source,\n d_sf=d,\n ef=e_field,\n m=1.0,\n h=hi\n )\n h5file = os.path.join(out_path, filetag + \".h5\")\n params = np.array([s, hi, d, h5file])\n sim_params.append(params)\n\n results = pool.map(partial(func, **kw), sim_params)\n permutations_df = pd.DataFrame(data=sim_params)\n permutations_df.columns = [\n 'S0 (1/cm^2)', 'h (cm/s)', 'D_SF (cm^2/s)', 'h5 file'\n ]\n pool.close()\n costs = np.empty(n_simulations, dtype=np.float)\n\n for i, r in permutations_df.iterrows():\n csv_file = os.path.splitext(r['h5 file'])[0] + '.csv'\n df = pd.read_csv(csv_file)\n y = df['Rsh norm'].values\n costs[i] = cost_function(y=y, rsh_norm_=rsh_norm)\n\n permutations_df['cost'] = costs\n csv_grid_file = os.path.join(root_dir, file_tag + \".h5\")\n permutations_df.to_csv(path_or_buf=csv_grid_file + '_grid.csv', index=False)\n\n idx_min = np.argmin(costs)\n opt_h5 = permutations_df.iloc[idx_min]['h5 file']\n rpath = os.path.dirname(opt_h5)\n opt_basename = os.path.splitext(os.path.basename(opt_h5))[0]\n opt_csv = os.path.join(rpath, opt_basename + '.csv')\n opt_df = pd.read_csv(opt_csv)\n\n # Load my style\n with open('plotstyle.json', 'r') as style_file:\n mpl.rcParams.update(json.load(style_file)['defaultPlotStyle'])\n\n # Plot PID data\n fig_pid = plt.figure(1)\n fig_pid.set_size_inches(4.0, 3.0, forward=True)\n fig_pid.subplots_adjust(hspace=0.1, wspace=0.1)\n gs_0 = gridspec.GridSpec(ncols=1, nrows=1, figure=fig_pid)\n gs_00 = gridspec.GridSpecFromSubplotSpec(\n nrows=1, ncols=1, subplot_spec=gs_0[0], hspace=0.1,\n )\n ax_pid = fig_pid.add_subplot(gs_00[0, 0])\n ax_pid.set_xlabel('Time (hr)')\n ax_pid.set_ylabel('Normalized $R_{\\mathrm{sh}}$')\n ax_pid.set_xlim(0, 96.)\n\n idx = time < 96. * 3600.\n\n ax_pid.plot(\n time / 3600, rsh_norm, marker='o', ls='none', fillstyle='none', label='Experiment',\n color='k'\n )\n ax_pid.plot(\n time / 3600, opt_df['Rsh norm'].values, ls='-', color='tab:red',\n label='Best fit'\n )\n\n xfmt = ScalarFormatter(useMathText=True)\n xfmt.set_powerlimits((-3, 3))\n\n ax_pid.xaxis.set_major_formatter(xfmt)\n ax_pid.xaxis.set_major_locator(mticker.MaxNLocator(12, prune=None))\n ax_pid.xaxis.set_minor_locator(mticker.AutoMinorLocator(2))\n\n ax_pid.set_yscale('log')\n\n leg = ax_pid.legend(loc='best', frameon=True)\n opt_fig_tag = os.path.join(root_dir, file_tag + '_optimized')\n\n fig_pid.tight_layout()\n\n fig_pid.savefig(opt_fig_tag + '.png', dpi=300)\n fig_pid.savefig(opt_fig_tag + '.svg', dpi=600)\n\n fig_pid.show()\n", "meta": {"hexsha": "aaa09d1c1c7fdb493f4bb9cf53077b85b83d93de", "size": 11858, "ext": "py", "lang": "Python", "max_stars_repo_path": "asu_fit_permutation.py", "max_stars_repo_name": "erickmartinez/pnptransport", "max_stars_repo_head_hexsha": "6ac9ae8930649abc880bf2d7fa0d9e19bee58b9e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "asu_fit_permutation.py", "max_issues_repo_name": "erickmartinez/pnptransport", "max_issues_repo_head_hexsha": "6ac9ae8930649abc880bf2d7fa0d9e19bee58b9e", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "asu_fit_permutation.py", "max_forks_repo_name": "erickmartinez/pnptransport", "max_forks_repo_head_hexsha": "6ac9ae8930649abc880bf2d7fa0d9e19bee58b9e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.3273657289, "max_line_length": 99, "alphanum_fraction": 0.6228706359, "include": true, "reason": "import numpy,from scipy", "num_tokens": 3432, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6039318337259583, "lm_q2_score": 0.33111973302838926, "lm_q1q2_score": 0.19997374755068487}} {"text": "\"\"\"Selective sampling algorithms for ALSA\"\"\"\n\nimport random\nimport math\nimport numpy as np\nimport torch\nfrom scipy.stats import mode\n\nfrom alsa.nets.alt_common import train as sep_train\nfrom alsa.nets.common import train\nfrom alsa.config import LONG_MILESTONES\nfrom alsa.adaptation.label_shift import label_shift\n\n\ndef general_sampling(network, net_cls, dataset, args=None): # pylint: disable=R0914,R0912,R0915\n \"\"\"Query-by-committee (pool): disagreement between random inits of net.\"\"\"\n # Batch-mode settings\n batch_size = int(dataset.online_len() / args.num_batches)\n label_batch_size = int(args.sample_prop * batch_size)\n labeled_ptrs = np.array([], dtype=np.int32)\n\n # Initialize committee\n committee = [network]\n if args.sampling_strategy in [\"qbc\"]:\n for i in range(args.vs_size - 1):\n this_network = net_cls(args.num_cls).to(args.device)\n this_network.train()\n train(this_network,\n dataset,\n epochs=args.initial_epochs,\n args=args,\n milestones=LONG_MILESTONES)\n this_network.eval()\n committee.append(this_network)\n\n # Map pointers to label\n if args.diversify == \"cheat\":\n ys = []\n for i in dataset.indices(split=\"online\"):\n y, _ = dataset.train_labels[i]\n ys.append(y)\n ys = np.array(ys, dtype=np.int32)\n\n # Begin batch-mode sampling\n for batch_i in range(1, args.num_batches + 1):\n stats = [] # Smaller stats means higher priority\n sep_stats = [] # Bigger value means more important\n with torch.no_grad():\n for image, y, _ in dataset.iterate(\n batch_size=args.infer_batch_size,\n shuffle=False,\n split=\"online\"):\n image = image.to(args.device)\n\n # Aggregate domain sep\n if args.domainsep:\n this_network = committee[0]\n this_network.eval()\n output = torch.exp(this_network(image))\n p = output.cpu().data.numpy()\n sep_stats.append(np.sum(-p * np.log(p + 1e-9), axis=1))\n\n # Produce stats depending on algorithm\n if args.sampling_strategy == \"qbc\":\n predictions = []\n for this_network in committee:\n this_network.eval()\n output = torch.exp(this_network(image))\n p = output.cpu().data.numpy()\n if not args.train_iw and not args.only_rlls_infer:\n p = p * dataset.label_weights\n p = p / np.sum(p, axis=1)[:, None]\n predictions.append(np.argmax(p, axis=1))\n predictions = np.stack(predictions)\n stats.append(mode(predictions, axis=0).count[0])\n if args.sampling_strategy == \"bald\":\n predictions = []\n this_network = committee[0]\n this_network.train()\n with torch.no_grad():\n for _ in range(args.bald_size):\n output = torch.exp(this_network(image))\n p = output.cpu().data.numpy()\n if not args.train_iw and not args.only_rlls_infer:\n p = p * dataset.label_weights\n p = p / np.sum(p, axis=1)[:, None]\n predictions.append(np.argmax(p, axis=1))\n predictions = np.stack(predictions)\n stats.append(mode(predictions, axis=0).count[0])\n if args.sampling_strategy == \"cheat\":\n this_network = committee[0]\n this_network.eval()\n output = torch.exp(this_network(image))\n p = output.cpu().data.numpy()\n if not args.train_iw and not args.only_rlls_infer:\n p = p * dataset.label_weights\n p = p / np.sum(p, axis=1)[:, None]\n stats.append(np.equal(np.argmax(p, axis=1), y))\n if args.sampling_strategy == \"margin\":\n margin = []\n this_network = committee[0]\n this_network.eval()\n output = torch.exp(this_network(image))\n p = output.cpu().data.numpy()\n if not args.train_iw and not args.only_rlls_infer:\n p = p * dataset.label_weights\n p = p / np.sum(p, axis=1)[:, None]\n sorted_p = np.sort(p)\n margin = sorted_p[:, -1] - sorted_p[:, -2]\n stats.append(margin)\n if args.sampling_strategy == \"maxent\":\n this_network = committee[0]\n this_network.eval()\n output = torch.exp(this_network(image))\n p = output.cpu().data.numpy()\n if not args.train_iw and not args.only_rlls_infer:\n p = p * dataset.label_weights\n p = p / np.sum(p, axis=1)[:, None]\n stats.append(-np.sum(-p * np.log(p + 1e-9), axis=1))\n if args.sampling_strategy == \"random\":\n stats.append(np.random.uniform(size=(len(image), )))\n\n if args.diversify in [\"guess\", \"overguess\"]:\n # Produce new ys\n ys = []\n network.eval()\n for image, _, _ in dataset.iterate(\n batch_size=args.infer_batch_size,\n shuffle=False,\n split=\"online\"):\n image = image.to(args.device)\n output = torch.exp(network(image))\n p = output.cpu().data.numpy()\n if not args.train_iw and not args.only_rlls_infer:\n p = p * dataset.label_weights\n p = p / np.sum(p, axis=1)[:, None]\n ys.append(np.argmax(p, axis=1))\n ys = np.concatenate(ys)\n\n # Concatenate stats\n stats = np.concatenate(stats)\n\n if args.domainsep:\n sep_stats = np.concatenate(sep_stats)\n sep_stats[sep_stats < 0.5] = 0\n sep_odds = np.uniform(size=sep_stats.shape)\n selection = np.greater(sep_odds, np.uniform(size=sep_stats.shape))\n stats[~selection] = np.infty\n\n # Stack stats\n new_ptrs = np.setdiff1d(np.arange(len(stats)), labeled_ptrs)\n sorted_ptrs = new_ptrs[np.argsort(stats[new_ptrs])]\n\n if args.diversify == \"none\":\n labeled_ptrs = np.concatenate(\n [labeled_ptrs, sorted_ptrs[:label_batch_size]])\n elif args.diversify == \"guess\":\n # Take top examples from each label\n sorted_ptrs_by_label = {y: [] for y in range(args.num_cls)}\n for ptr in sorted_ptrs:\n sorted_ptrs_by_label[ys[ptr]].append(ptr)\n\n # Of remaining ptrs per label, find most equal allocation\n label_lens = sorted(\n [len(x) for x in sorted_ptrs_by_label.values()])\n for i, l in enumerate(label_lens):\n size = math.ceil((label_batch_size - sum(label_lens[:i])) /\n len(label_lens[i:]))\n if size <= l:\n break\n size = -1\n if size == -1:\n raise ValueError()\n\n # Label pts per each\n for k, ptrs in sorted_ptrs_by_label.items():\n labeled_ptrs = np.concatenate([labeled_ptrs, ptrs[:size]])\n assert len(np.unique(labeled_ptrs)) == len(labeled_ptrs)\n elif args.diversify == \"overguess\":\n # Take top examples from each label\n sorted_ptrs_by_label = {y: [] for y in range(args.num_cls)}\n for ptr in sorted_ptrs:\n sorted_ptrs_by_label[ys[ptr]].append(ptr)\n\n # Label pts per each\n for k, ptrs in sorted_ptrs_by_label.items():\n size = math.ceil(dataset.label_weights[k] /\n sum(dataset.label_weights) * label_batch_size)\n labeled_ptrs = np.concatenate([labeled_ptrs, ptrs[:size]])\n assert len(np.unique(labeled_ptrs)) == len(labeled_ptrs)\n\n dataset.label_ptrs(labeled_ptrs)\n\n # Note sample proportion\n print(\"Sample proportion: \", len(labeled_ptrs) / dataset.online_len())\n\n # Train networks on current batch status\n if args.domainsep:\n committee[0].train()\n sep_train(committee[0],\n dataset,\n epochs=args.partial_epochs,\n lr=args.finetune_lr,\n args=args)\n committee[0].eval()\n\n for this_network in committee:\n this_network.train()\n train(this_network,\n dataset,\n epochs=args.partial_epochs,\n lr=args.finetune_lr,\n args=args)\n this_network.eval()\n\n # Handle reweighting procedure\n if args.iterative_iw:\n label_shift(committee[0], dataset, args)\n\n yield committee[0]\n\n\n######################################################################\ndef iwal_bootstrap_old(network, net_cls, dataset, args=None):\n \"\"\"Query-by-committee (pool): disagreement between random inits of net.\"\"\"\n # Batch-mode settings\n batch_size = int(dataset.online_len() / args.num_batches)\n label_batch_size = int(args.sample_prop * batch_size)\n labeled_ptrs = np.array([], dtype=np.int32)\n\n # Initialize committee\n committee = [\n network\n ]\n for i in range(args.vs_size - 1):\n this_network = net_cls(args.num_cls).to(args.device)\n this_network.train()\n train(this_network,\n dataset,\n epochs=args.initial_epochs,\n args=args,\n milestones=LONG_MILESTONES)\n this_network.eval()\n committee.append(this_network)\n\n last_ptr = 0\n\n # Begin batch-mode sampling\n for batch_i in range(1, args.num_batches + 1):\n # Process IWAL probabilities\n all_probs = np.zeros(\n (len(committee), args.num_cls, dataset.online_len()))\n with torch.no_grad():\n # Get committee probability predictions\n for model_i, model in enumerate(committee):\n model.eval()\n probs = [list() for i in range(args.num_cls)]\n for (data, _,\n _) in dataset.iterate(batch_size=args.infer_batch_size,\n shuffle=False,\n split=\"online\"):\n data = data.to(args.device)\n logits = model(data)\n output = torch.exp(logits) # p(y | x)\n output = output.cpu().data.numpy()\n if not args.train_iw and not args.only_rlls_infer:\n output = output * dataset.label_weights\n output = output / np.sum(output, axis=1)[:, None]\n for i in range(args.num_cls):\n probs[i].append(output[:, i])\n for i, x in enumerate(probs):\n all_probs[model_i, i] = np.concatenate(x)\n\n # Get ys for diversification\n if args.diversify in [\"guess\", \"overguess\"]:\n # Produce new ys\n ys = []\n network.eval()\n for image, _, _ in dataset.iterate(\n batch_size=args.infer_batch_size,\n shuffle=False,\n split=\"online\"):\n image = image.to(args.device)\n output = torch.exp(network(image))\n p = output.cpu().data.numpy()\n if not args.train_iw and not args.only_rlls_infer:\n p = p * dataset.label_weights\n p = p / np.sum(p, axis=1)[:, None]\n ys.append(np.argmax(p, axis=1))\n ys = np.concatenate(ys)\n\n all_probs = np.transpose(all_probs, [2, 0, 1])\n # For some datapoint and some label, this is largest disagreement in prob:\n probs_disagreement = np.max(all_probs, axis=1) - np.min(all_probs, axis=1)\n assert probs_disagreement.shape == (dataset.online_len(), args.num_cls)\n # For some datapoint, this is largest disagreement in prob:\n probs_disagreement = np.max(probs_disagreement, axis=1)\n sample_probs = args.iwal_normalizer + \\\n (1 - args.iwal_normalizer) * probs_disagreement\n\n if args.diversify == \"none\":\n sample_probs = sample_probs\n elif args.diversify == \"guess\":\n yunique, ycounts = np.unique(ys, return_counts=True)\n ycounts = np.array(ycounts, dtype=np.float32) / np.sum(ycounts)\n ycounts += 1e-4\n ycounts = 1 / ycounts\n ycounts = ycounts / np.sum(ycounts)\n dss = {}\n for y, c in zip(yunique, ycounts):\n dss[y] = c\n for i, y in enumerate(ys):\n all_probs[i] *= dss[y]\n\n # Labeled data\n labeled_ptrs = np.array([], dtype=np.int32)\n new_ptrs = []\n for i in range(last_ptr, dataset.online_len()):\n if len(labeled_ptrs) > label_batch_size:\n break\n sample_probs[i] = max(sample_probs[i], 0)\n sample_probs[i] = min(sample_probs[i], 1)\n if random.random() < sample_probs[i]:\n last_ptr = i\n new_ptrs.append(i)\n labeled_ptrs = np.concatenate(\n [labeled_ptrs, np.array(new_ptrs, dtype=np.int32)])\n dataset.label_ptrs(labeled_ptrs)\n\n # Note sample proportion\n print(\"Sample proportion: \", len(labeled_ptrs) / dataset.online_len())\n\n # Train networks on current batch status\n for this_network in committee:\n this_network.train()\n train(this_network,\n dataset,\n epochs=args.partial_epochs,\n lr=args.finetune_lr,\n args=args)\n this_network.eval()\n\n # Handle reweighting procedure\n if args.iterative_iw:\n label_shift(committee[0], dataset, args)\n\n yield committee[0]\n\n\ndef iwal_bootstrap(network, net_cls, dataset, args=None):\n \"\"\"Query-by-committee (pool): disagreement between random inits of net.\"\"\"\n # Batch-mode settings\n batch_size = int(dataset.online_len() / args.num_batches)\n label_batch_size = int(args.sample_prop * batch_size)\n labeled_ptrs = np.array([], dtype=np.int32)\n\n # Initialize committee\n committee = [\n network\n ]\n\n last_ptr = 0\n\n # Begin batch-mode sampling\n for batch_i in range(1, args.num_batches + 1):\n # Process IWAL probabilities\n all_probs = np.zeros(\n (args.bald_size, args.num_cls, dataset.online_len()))\n model = network\n model.train()\n with torch.no_grad():\n # Get committee probability predictions\n for model_i in range(args.bald_size):\n probs = [list() for i in range(args.num_cls)]\n for (data, _,\n _) in dataset.iterate(batch_size=args.infer_batch_size,\n shuffle=False,\n split=\"online\"):\n data = data.to(args.device)\n logits = model(data)\n output = torch.exp(logits) # p(y | x)\n output = output.cpu().data.numpy()\n if not args.train_iw and not args.only_rlls_infer:\n output = output * dataset.label_weights\n output = output / np.sum(output, axis=1)[:, None]\n for i in range(args.num_cls):\n probs[i].append(output[:, i])\n for i, x in enumerate(probs):\n all_probs[model_i, i] = np.concatenate(x)\n\n # Get ys for diversification\n model.eval()\n if args.diversify in [\"guess\", \"overguess\", \"subguess\"]:\n # Produce new ys\n ys = []\n network.eval()\n for image, _, _ in dataset.iterate(\n batch_size=args.infer_batch_size,\n shuffle=False,\n split=\"online\"):\n image = image.to(args.device)\n output = torch.exp(network(image))\n p = output.cpu().data.numpy()\n if not args.train_iw and not args.only_rlls_infer:\n p = p * dataset.label_weights\n p = p / np.sum(p, axis=1)[:, None]\n ys.append(np.argmax(p, axis=1))\n ys = np.concatenate(ys)\n\n all_probs = np.transpose(all_probs, [2, 0, 1])\n # For some datapoint and some label, this is largest disagreement in prob:\n probs_disagreement = np.max(all_probs, axis=1) - np.min(all_probs, axis=1)\n assert probs_disagreement.shape == (dataset.online_len(), args.num_cls)\n # For some datapoint, this is largest disagreement in prob:\n probs_disagreement = np.max(probs_disagreement, axis=1)\n sample_probs = args.iwal_normalizer + \\\n (1 - args.iwal_normalizer) * probs_disagreement\n\n print(\"Original sample_probs:\", sample_probs)\n\n if args.diversify == \"none\":\n sample_probs = sample_probs\n elif args.diversify == \"guess\":\n yunique, ycounts = np.unique(ys, return_counts=True)\n ycounts = np.array(ycounts, dtype=np.float32) / np.sum(ycounts)\n ycounts += 1e-4\n ycounts = 1 / ycounts\n ycounts = ycounts / np.sum(ycounts)\n dss = {}\n for y, c in zip(yunique, ycounts):\n dss[y] = c\n for i, y in enumerate(ys):\n all_probs[i] *= dss[y]\n elif args.diversify == \"subguess\":\n yunique = np.unique(ys)\n ycounts = np.sqrt(dataset.first_weight)\n ycounts += 1e-4\n ycounts = ycounts / np.sum(ycounts)\n dss = {}\n for y, c in zip(yunique, ycounts):\n dss[y] = c\n for i, y in enumerate(ys):\n all_probs[i] *= dss[y]\n\n # Labeled data\n new_ptrs = []\n for i in range(last_ptr, dataset.online_len()):\n if len(new_ptrs) > label_batch_size:\n break\n sample_probs[i] = max(sample_probs[i], 0)\n sample_probs[i] = min(sample_probs[i], 1)\n if random.random() < sample_probs[i]:\n last_ptr = i\n new_ptrs.append(i)\n labeled_ptrs = np.concatenate(\n [labeled_ptrs, np.array(new_ptrs, dtype=np.int32)])\n dataset.label_ptrs(labeled_ptrs)\n\n # Note sample proportion\n print(\"Sample proportion: \", len(labeled_ptrs) / dataset.online_len())\n\n # Train networks on current batch status\n for this_network in committee:\n this_network.train()\n train(this_network,\n dataset,\n epochs=args.partial_epochs,\n lr=args.finetune_lr,\n args=args)\n this_network.eval()\n\n # Handle reweighting procedure\n if args.iterative_iw:\n label_shift(committee[0], dataset, args)\n\n yield committee[0]\n", "meta": {"hexsha": "028ce4482efab3a700b700d899c6181a678bd627", "size": 19930, "ext": "py", "lang": "Python", "max_stars_repo_path": "alsa/sampling.py", "max_stars_repo_name": "ericzhao28/ALLS", "max_stars_repo_head_hexsha": "7d85650926857ea5497444c12f093832efc33ba1", "max_stars_repo_licenses": ["MIT", "Unlicense"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-08-10T20:20:38.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-01T14:40:19.000Z", "max_issues_repo_path": "alsa/sampling.py", "max_issues_repo_name": "ericzhao28/ALLS", "max_issues_repo_head_hexsha": "7d85650926857ea5497444c12f093832efc33ba1", "max_issues_repo_licenses": ["MIT", "Unlicense"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-05-03T09:53:05.000Z", "max_issues_repo_issues_event_max_datetime": "2021-08-20T00:36:23.000Z", "max_forks_repo_path": "alsa/sampling.py", "max_forks_repo_name": "ericzhao28/ALLS", "max_forks_repo_head_hexsha": "7d85650926857ea5497444c12f093832efc33ba1", "max_forks_repo_licenses": ["MIT", "Unlicense"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-12-14T02:16:27.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-25T23:08:49.000Z", "avg_line_length": 41.7819706499, "max_line_length": 96, "alphanum_fraction": 0.5189663823, "include": true, "reason": "import numpy,from scipy", "num_tokens": 4075, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6039318337259584, "lm_q2_score": 0.3311197264277872, "lm_q1q2_score": 0.1999737435643712}} {"text": "\"\"\"\nIonization Modeling for MCMC setup. This also contains stand-alone model\nprediction.\n\"\"\"\n\nimport numpy as np\n# interpolation on regular grid in arbitrary dimension\nfrom scipy.interpolate import RectBivariateSpline, interp1d\nfrom scipy.interpolate import RegularGridInterpolator\nfrom read_solarabund import SpecieMetalFraction, MetalFraction, NumberFraction\n\n################################################################################\n# utils\n################################################################################\n\n\ndef helper(ion):\n if ion == 'h1':\n return 'H'\n elif ion == 'c2' or ion == 'c3' or ion == 'c4':\n return 'C'\n elif ion == 'ne8':\n return 'Ne'\n elif ion == 'n5' or ion == 'n2' or ion == 'n3':\n return 'N'\n elif ion == 's2' or ion == 's3' or ion == 's4':\n return 'Si'\n elif ion == 'o1' or ion == 'o6':\n return 'O'\n elif ion == 'mg1' or ion == 'mg2':\n return 'Mg'\n elif ion == 'fe2':\n return 'Fe'\n\n\ndef ion_lists():\n ions = np.array(['h1', 'c2', 'c3', 'c4', 'n2', 'n3',\n 's2', 's3', 's4', 'o1',\n 'o6', 'ne8', 'n5', 'mg2', 'fe2'])\n return ions\n\n\ndef Cloudy_InputParamers():\n lognH = np.arange(-6.0, 0.2, 0.2)\n logNHI = np.arange(15, 19.2, 0.2)\n logT = np.arange(4.0, 7.2, 0.2)\n return lognH, logNHI, logT\n\n\ndef Cloudy_InputParamers_redshift(): \n low_redshift = np.arange(0, 3.0, 0.2)\n high_redshift = np.arange(3.0, 7.5, 0.5)\n redshift = np.sort(np.concatenate((low_redshift, high_redshift)))\n\n lognH = np.arange(-7.0, 0.2, 0.2)\n logT = np.arange(3.5, 7.1, 0.2)\n return lognH, logT, redshift\n\n\ndef GenericModelInterp(gal_z, ion_name, model_choice):\n\n input_path = '/Users/cameronliang/research/cloudy_models'\n if model_choice == 'photo_collision_thin':\n\n # load the CLOUDY input parameters\n clognH, clogT, redshift = Cloudy_InputParamers_redshift()\n\n # Load the ionization fraction grid\n path = input_path + '/photo_collision_thin/CombinedGrid/cubes/'\n ind = int(np.where(abs(redshift-gal_z) < 0.1)[0]) # Use the closest z\n ion = np.load(path + ion_name + '.npy')[ind, :, :]\n\n # Interpolate the function\n f = np.vectorize(RectBivariateSpline(clognH, clogT, ion))\n\n elif model_choice == 'photo_collision_noUVB':\n clognH, clogNHI, clogT = Cloudy_InputParamers()\n path = input_path + '/photo_collision_rahmati/f0.0/cubes/'\n ion = np.load(path + ion_name + '.npy')\n f = np.vectorize(RectBivariateSpline(clognH, clogT, ion))\n\n elif model_choice == 'photo_collision_rahmati':\n # will change name from optically_thick_rahmati\n # to photo_collision_rahmati after the models are finished\n clognH, clogNHI, clogT = Cloudy_InputParamers()\n path = input_path + '/' + model_choice + '/CombinedGrid/cubes/'\n cgamma_ratios = np.load(path + '/uvb_fraction.npy')\n ion = np.load(path + ion_name + '.npy')\n f = RegularGridInterpolator((clognH, clogT, cgamma_ratios), ion)\n\n elif model_choice == 'jv_model':\n path = input_path + '/' + model_choice + '/combined_grid/cubes/'\n amp_a = np.load(path+'a.npy')\n amp_b = np.load(path+'b.npy')\n clognH = np.load(path+'lognH.npy')\n clogNHI = np.load(path+'logNHI.npy')\n ion = np.load(path + ion_name + '.npy')\n\n f = RegularGridInterpolator((amp_a, amp_b, clognH, clogNHI), ion)\n\n elif model_choice == 'photo_collision_thick':\n clognH = np.arange(-6, 0.2, 0.2)\n clogNHI = np.arange(15, 19.2, 0.2)\n clogT = np.arange(3.8, 6.2, 0.2)\n path = input_path + '/' + model_choice + '/CombinedGrid/cubes/'\n ion = np.load(path + ion_name + '.npy')\n f = RegularGridInterpolator((clognH, clogNHI, clogT), ion)\n\n elif model_choice == 'photo_thick':\n credshift = np.arange(0, 0.4, 0.1)\n clogNHI = np.arange(14, 22.2, 0.2)\n clognH = np.arange(-4.2, 0.2, 0.2)\n path = input_path + '/' + model_choice + '/CombinedGrid/cubes/'\n\n #ind = int(np.where(abs(redshift-gal_z) < 0.1)[0]) # Use the closest z\n ion = np.load(path + ion_name + '.npy') # [ind,:,:]\n f_3D = RegularGridInterpolator((credshift, clognH, clogNHI), ion)\n\n new_ion = np.zeros((len(clognH), len(clogNHI)))\n for i in range(len(clognH)):\n for j in range(len(clogNHI)):\n new_ion[i][j] = f_3D((gal_z, clognH[i], clogNHI[j]))\n f = RectBivariateSpline(clognH, clogNHI, new_ion)\n\n elif model_choice == 'photo_thick_aUV':\n # c before aUV just means cloudy grid values\n credshift = np.arange(0, 0.4, 0.1)\n caUV = np.arange(-3, 2.0, 0.5)\n clogNHI = np.arange(14, 22, 0.3)\n clognH = np.linspace(-4.4, 0., 12)\n path = input_path + '/' + model_choice + '/grids/CombinedGrid/cubes/'\n\n ion = np.load(path + ion_name + '.npy') # 4D array\n f_4D = RegularGridInterpolator((credshift, caUV, clognH, clogNHI), ion)\n\n new_ion = np.zeros(( len(caUV), len(clognH), len(clogNHI) ))\n for i in range(len(caUV)):\n for j in range(len(clognH)):\n for k in range(len(clogNHI)):\n new_ion[i][j][k] = f_4D((gal_z, caUV[i], clognH[j], clogNHI[k]))\n\n f = RegularGridInterpolator((caUV, clognH, clogNHI), new_ion)\n\n return f\n\n\ndef GetAllIonFunctions(gal_z, model_choice):\n ions_names = ion_lists()\n f = []\n for ion_name in ions_names:\n f.append(GenericModelInterp(gal_z, ion_name, model_choice))\n f = np.array(f)\n\n # Make the dictionary between functions and ionization state\n dict_intepfunc = {}\n for i in range(len(ions_names)):\n dict_intepfunc[ions_names[i]] = f[i]\n return dict_intepfunc\n\n#############################################################################\n# Physics related Utils\n#############################################################################\n\n\ndef ComputeGammaRatio(lognH):\n \"\"\"\n ratio = Gamma/Gamma_UVB\n eqn 14. from Rahmati 2013.\n \"\"\"\n # value taken from table 2 Rahmati+ 2013\n nH_ssh = 5.1*1.0e-4\n nH = 10**lognH\n ratio = 0.98*(1+(nH/nH_ssh)**1.64)**-2.28 + 0.02*(1+nH/nH_ssh)**-0.84\n return ratio\n\n\ndef logZfrac(logZ, specie):\n # logZ is in solar units already\n logNx_NH = NumberFraction(specie) # number density ratio in the sun\n return logZ + logNx_NH\n\n###############################################################################\n\n\nclass DefineIonizationModel:\n def __init__(self, config_params):\n self.config_params = config_params\n self.logf_ion = GetAllIonFunctions(config_params.model_redshift,\n config_params.model)\n\n def model_prediction(self, alpha, ion_name):\n \"\"\"\n Calculate column density given a specific ion, and the model\n parameters in a photo-ionization model\n \"\"\"\n specie = helper(ion_name)\n if ion_name == 'h1':\n logNHI = alpha[-1]\n return logNHI\n else:\n if self.config_params.model == 'photo_collision_thin':\n lognH, logZ, logT, logNHI = alpha\n if -6 < lognH < 0 and 10 < logNHI <= 22 and 3.8 <= logT < 7:\n logN = (self.logf_ion[ion_name](lognH, logT) -\n self.logf_ion['h1'](lognH, logT) +\n logNHI)[0][0]\n else:\n logN = -np.inf\n\n elif self.config_params.model == 'photo_collision_noUVB':\n lognH, logZ, logT, logNHI = alpha\n logN = (self.logf_ion[ion_name](lognH, logT) -\n self.logf_ion['h1'](lognH, logT) +\n logZfrac(logZ, specie) + logNHI)[0][0]\n\n elif self.config_params.model == 'photo_collision_rahmati':\n lognH, logZ, logT, logNHI = alpha\n if lognH < -6:\n lognH = -6.0 # because the models were not run below -6\n elif lognH > 0:\n lognH = 0.\n\n gamma_ratio = ComputeGammaRatio(lognH)\n logN = (self.logf_ion[ion_name]((lognH, logT, gamma_ratio)) -\n self.logf_ion['h1']((lognH, logT, gamma_ratio)) +\n logZfrac(logZ, specie) + logNHI)[0][0]\n\n elif self.config_params.model == 'photo_collision_thick':\n lognH, logZ, logT, logNHI = alpha\n # ranges to protect out of range in interpolated function\n if -6. < lognH <= 0. and 10. < logNHI <= 19. and 3.8 <= logT < 6.:\n if logNHI <= 15:\n ifrac_alpha = np.array([lognH, 15.0, logT])\n else:\n ifrac_alpha = np.array([lognH, logNHI, logT])\n logN = (self.logf_ion[ion_name](ifrac_alpha) -\n self.logf_ion['h1'](ifrac_alpha) +\n logZfrac(logZ, specie) + logNHI)[0]\n else:\n logN = -np.inf\n\n elif self.config_params.model == 'jv_model':\n amp_a, amp_b, lognH, logZ, logNHI = alpha\n print 'enter'\n # ranges to protect out of range in interpolated function\n if (-5.0 < lognH <= 0. and 10. < logNHI <= 19. and -1 <\n amp_a <= 4 and -1 < amp_b <= 1):\n if logNHI <= 10:\n ifrac_alpha = np.array([amp_a, amp_b, lognH, 10.0])\n else:\n print 'here???'\n ifrac_alpha = np.array([amp_a, amp_b, lognH, logNHI])\n logN = (self.logf_ion[ion_name](ifrac_alpha) -\n self.logf_ion['h1'](ifrac_alpha) +\n logZfrac(logZ, specie) + logNHI)[0]\n else:\n print 'here!!'\n logN = -np.inf\n\n elif self.config_params.model == 'photo_fix_logT_thin':\n lognH, logZ, logNHI = alpha\n logT = 4.0 # one can fix this to whatever tempature\n logN = (self.logf_ion[ion_name](lognH, logT) -\n self.logf_ion['h1'](lognH, logT) +\n logZfrac(logZ, specie) + logNHI)\n\n elif self.config_params.model == 'photo_thick':\n lognH, logZ, logNHI = alpha\n if -4.2 < lognH < 0 and 0 < logNHI <= 22:\n if logNHI < 14:\n # if < 14, use optically thin for all values of NHI\n logN = (self.logf_ion[ion_name](lognH, 14.0) -\n self.logf_ion['h1'](lognH, logNHI) +\n logZfrac(logZ, specie) + logNHI)[0][0]\n else:\n logN = (self.logf_ion[ion_name](lognH, logNHI) -\n self.logf_ion['h1'](lognH, logNHI) +\n logZfrac(logZ, specie) + logNHI)[0][0]\n else:\n logN = -np.inf\n\n elif self.config_params.model == 'photo_thick_aUV':\n lognH, logZ, aUV, logNHI = alpha\n if -4.2 <= lognH < 0 and -3 <= aUV < 2 and 0 < logNHI <= 22:\n if logNHI <= 14:\n # if < 14 use optically thin for all values of NHI\n logN = (self.logf_ion[ion_name]((aUV, lognH, 14.0)) -\n self.logf_ion['h1']((aUV, lognH, 14.0)) +\n logZfrac(logZ, specie) + logNHI)\n else:\n logN = (self.logf_ion[ion_name]((aUV, lognH, logNHI)) -\n self.logf_ion['h1']((aUV, lognH, logNHI)) +\n logZfrac(logZ, specie) + logNHI)\n else:\n logN = -np.inf\n return logN\n\n####################################\n\n\nclass DefineIonizationModel_test:\n \"\"\"\n A Ionization model class\n \"\"\"\n def __init__(self, model, model_redshift):\n self.model = model\n self.logf_ion = GetAllIonFunctions(model_redshift, model)\n\n def produce_ion_logn(self, alpha, ion_name):\n if self.model == 'photo_collision_thin':\n # for this model ony.. for now\n lognH, logZ, logT = alpha\n specie = helper(ion_name)\n if ion_name == 'h1':\n logn_ion = self.logf_ion[ion_name](lognH, logT) + lognH\n else:\n logn_ion = self.logf_ion[ion_name](lognH, logT) + \\\n logZfrac(logZ, specie) + lognH\n return logn_ion[0][0]\n\n def model_prediction(self, alpha, ion_name):\n \"\"\"\n Calculate column density given a specific ion, and the model\n parameters in a photo-ionization model\n \"\"\"\n specie = helper(ion_name)\n if ion_name == 'h1':\n logNHI = alpha[-1]\n return logNHI\n else:\n if self.model == 'photo_collision_thin':\n lognH, logZ, logT, logNHI = alpha\n if -6 < lognH < 0 and 10 < logNHI <= 22 and 3.8 <= logT < 7:\n logN = (self.logf_ion[ion_name](lognH, logT) -\n self.logf_ion['h1'](lognH, logT) +\n logNHI)[0][0]\n else:\n logN = -np.inf\n\n elif self.model == 'photo_collision_noUVB':\n lognH, logZ, logT, logNHI = alpha\n logN = (self.logf_ion[ion_name](lognH, logT) -\n self.logf_ion['h1'](lognH, logT) +\n logZfrac(logZ, specie) + logNHI)[0][0]\n\n elif self.model == 'photo_collision_rahmati':\n lognH, logZ, logT, logNHI = alpha\n if lognH < -6:\n lognH = -6.0 # because the models were not run below -6\n elif lognH > 0:\n lognH = 0.\n gamma_ratio = ComputeGammaRatio(lognH)\n logN = (self.logf_ion[ion_name]((lognH, logT, gamma_ratio)) -\n self.logf_ion['h1']((lognH, logT, gamma_ratio)) +\n logZfrac(logZ, specie) + logNHI)[0][0]\n\n elif self.model == 'photo_collision_thick':\n lognH, logZ, logT, logNHI = alpha\n # ranges to protect out of range in interpolated function\n if -6. < lognH <= 0. and 10. < logNHI <= 19. and 3.8 <= logT < 6.:\n if logNHI <= 15:\n ifrac_alpha = np.array([lognH, 15.0, logT])\n else:\n ifrac_alpha = np.array([lognH, logNHI, logT])\n logN = (self.logf_ion[ion_name](ifrac_alpha) -\n self.logf_ion['h1'](ifrac_alpha) +\n logZfrac(logZ, specie) + logNHI)[0]\n else:\n logN = -np.inf\n\n elif self.model == 'jv_model':\n amp_a, amp_b, lognH, logZ, logNHI = alpha\n # ranges to protect out of range in interpolated function\n if (-6. < lognH <= 0. and 10. < logNHI <= 19. and -1 <\n amp_a <= 4 and -1 <= amp_b < 4):\n if logNHI <= 10:\n ifrac_alpha = np.array([amp_a, amp_b, lognH, 10.0])\n else:\n ifrac_alpha = np.array([amp_a, amp_b, lognH, logNHI])\n logN = (self.logf_ion[ion_name](ifrac_alpha) -\n self.logf_ion['h1'](ifrac_alpha) +\n logZfrac(logZ, specie) + logNHI)[0]\n else:\n logN = -np.inf\n\n elif self.model == 'photo_fix_logT_thin':\n lognH, logZ, logNHI = alpha\n logT = 4.0 # one can fix this to whatever tempature\n logN = (self.logf_ion[ion_name](lognH, logT) -\n self.logf_ion['h1'](lognH, logT) +\n logZfrac(logZ, specie) + logNHI)\n\n elif self.model == 'photo_thick':\n lognH, logZ, logNHI = alpha\n if -4.2 < lognH < 0 and 0 < logNHI <= 22:\n if logNHI < 14:\n # if < 14, use optically thin for all values of NHI\n logN = (self.logf_ion[ion_name](lognH, 14.0) -\n self.logf_ion['h1'](lognH, logNHI) +\n logZfrac(logZ, specie) + logNHI)[0][0]\n else:\n logN = (self.logf_ion[ion_name](lognH, logNHI) -\n self.logf_ion['h1'](lognH, logNHI) +\n logZfrac(logZ, specie) + logNHI)[0][0]\n else:\n logN = -np.inf\n\n elif self.model == 'photo_thick_aUV':\n lognH, logZ, aUV, logNHI = alpha\n if -4.2 <= lognH < 0 and -3 <= aUV < 2 and 0 < logNHI <= 22:\n if logNHI <= 14:\n # if < 14 use optically thin for all values of NHI\n logN = (self.logf_ion[ion_name]((aUV, lognH, 14.0)) -\n self.logf_ion['h1']((aUV, lognH, 14.0)) +\n logZfrac(logZ, specie) + logNHI)\n else:\n logN = (self.logf_ion[ion_name]((aUV, lognH, logNHI)) -\n self.logf_ion['h1']((aUV, lognH, logNHI)) +\n logZfrac(logZ, specie) + logNHI)\n else:\n logN = -np.inf\n return logN\n\n\ndef AskForParameters(model):\n lognH = float(raw_input(\"lognH = \"))\n logZ = float(raw_input(\"logZ/Zsun = \"))\n\n if model == 'photo_thick_aUV':\n aUV = float(raw_input(\"aUV = \"))\n logNHI = float(raw_input(\"logNHI = \"))\n alpha = np.array([lognH, logZ, aUV, logNHI])\n\n elif model == 'photo_thick':\n logNHI = float(raw_input(\"logNHI = \"))\n alpha = np.array([lognH, logZ, logNHI])\n\n elif model == 'jv_model':\n logNHI = float(raw_input(\"logNHI = \"))\n amp_a = float(raw_input(\"a = \"))\n amp_b = float(raw_input(\"b = \"))\n alpha = np.array([amp_a, amp_b, lognH, logZ, logNHI])\n\n elif (model == 'photo_collision_thick' or\n model == 'photo_collision_rahmati' or\n model == 'photo_collision_thin'):\n logT = float(raw_input(\"logT = \"))\n logNHI = float(raw_input(\"logNHI = \"))\n alpha = np.array([lognH, logZ, logT, logNHI])\n else:\n print(\"Your model does not exist. Did you have a typo?\")\n print(\"photo_collision_thin\")\n print(\"photo_collision_thick\")\n print(\"photo_collision_rahmati\")\n print(\"photo_thick\")\n print(\"photo_thick_aUV\")\n exit()\n return alpha\n\nif __name__ == '__main__':\n\n import sys\n model = sys.argv[1]\n if model == 'jv_model':\n model_redshift = 0.0\n else:\n model_redshift = float(sys.argv[2])\n alpha = AskForParameters(model)\n ion_model = DefineIonizationModel_test(model, model_redshift)\n\n ions = ion_lists()\n for ion in ions:\n logN = ion_model.model_prediction(alpha, ion)\n print(\"LogN: %s = %.2f\" % (ion, logN))\n", "meta": {"hexsha": "024df697b36968f7752e854ad9cbd5d750d48c20", "size": 19410, "ext": "py", "lang": "Python", "max_stars_repo_path": "ionfit/Model.py", "max_stars_repo_name": "cameronliang/ionfit", "max_stars_repo_head_hexsha": "137709e33a745da94442885c22fb2752ac5ae2d8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "ionfit/Model.py", "max_issues_repo_name": "cameronliang/ionfit", "max_issues_repo_head_hexsha": "137709e33a745da94442885c22fb2752ac5ae2d8", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ionfit/Model.py", "max_forks_repo_name": "cameronliang/ionfit", "max_forks_repo_head_hexsha": "137709e33a745da94442885c22fb2752ac5ae2d8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.8631578947, "max_line_length": 84, "alphanum_fraction": 0.5018547141, "include": true, "reason": "import numpy,from scipy", "num_tokens": 5534, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.603931819468636, "lm_q2_score": 0.3311197264277872, "lm_q1q2_score": 0.19997373884349054}} {"text": "import sys\nimport os\nimport re\nimport copy\nfrom warnings import warn\nfrom collections import OrderedDict\nimport logging\nimport numpy as np\n\nimport intermol.unit as units\nfrom collections import deque\nfrom intermol.atom import Atom\nfrom intermol.molecule import Molecule\nfrom intermol.system import System\nfrom intermol.types import *\nfrom intermol.forces import *\nfrom intermol.hashmap import *\nimport math\n\nlogger = logging.getLogger('InterMolLog')\n\nclass GromacsTopologyParser(object):\n \"\"\"\n A class containing methods required to read in a Gromacs(4.5.4) Topology File\n \"\"\"\n _GroTopParser = None\n\n def __init__(self, defines=None):\n \"\"\"\n Initializes a GromacsTopologyParse object which serves to read in a Gromacs\n topology into the abstract representation.\n\n Args:\n defines: Sets of default defines to use while parsing.\n \"\"\"\n self.includes = set() # set storing includes\n self.defines = dict() # list of defines\n self.comments = list() # list of comments\n\n self.atomtypes = HashMap()\n self.bondtypes = HashMap()\n self.pairtypes = HashMap()\n self.angletypes = HashMap()\n self.dihedraltypes = HashMap()\n self.constrainttypes = HashMap()\n\n if defines:\n self.defines.union(defines)\n self.defines[\"FLEX_SPC\"] = None\n self.defines[\"POSRE\"] = None\n\n def parse_topology(self, topfile, verbose=False):\n \"\"\"\n Parses a Gromacs topology reading into the abstract\n\n Args:\n topfile: filename of the file to be parsed\n verbose: verbose output\n \"\"\"\n lines = self.preprocess(topfile, verbose)\n if lines:\n self.read_topology(lines, verbose)\n\n def read_topology(self, expanded, verbose=False):\n \"\"\"\n Read in a previously preprocessed Gromacs topology file\n\n Args:\n expanded: lines from a preprocessed topology file\n verbose: verbose output\n \"\"\"\n sysDirective = re.compile(r\"\"\"\n \\[[ ]{1}\n ((?Pdefaults)\n |\n (?Patomtypes)\n |\n (?Pbondtypes)\n |\n (?Ppairtypes)\n |\n (?Pangletypes)\n |\n (?Pdihedraltypes)\n |\n (?Pconstrainttypes)\n |\n (?Pnonbond_params)\n |\n (?Psystem))\n [ ]{1} \\]\n \"\"\", re.VERBOSE)\n i = 0\n while i < len(expanded):\n match = sysDirective.match(expanded[i])\n if match:\n logger.debug(match.groups())\n if match.group('defaults'):\n logger.debug(\"Parsing [ defaults ]...\")\n expanded.pop(i)\n\n fields = expanded[i].split()\n System._sys.nonbonded_function = int(fields[0])\n System._sys.combination_rule = int(fields[1])\n System._sys.genpairs = fields[2]\n System._sys.lj_correction = float(fields[3])\n System._sys.coulomb_correction = float(fields[4])\n\n expanded.pop(i)\n\n elif match.group('atomtypes'):\n logger.debug(\"Parsing [ atomtypes ]...\")\n expanded.pop(i)\n\n while not (expanded[i].count('[')) and i < len(expanded)-1:\n split = expanded.pop(i).split()\n newAtomType = None\n\n # note -- we should be able to store either C6 and C12 parameters or sigma and epsilon: not both\n atomtype = split[0].strip()\n if len(split) == 7: # atom name and bond type are the same, or there is no z.\n d = 0 #offset\n if (split[1].isdigit()):\n atomic_number = int(split[1])\n bondtype = split[0].strip()\n else:\n atomic_number = -1\n bondtype = split[1].strip()\n elif len(split) == 8: #atom and bond name and atomic_number\n d = 1\n bondtype = split[1].strip() # bondtype\n atomic_number = split[2] # atomic_number\n else:\n raise Exception(\"Incorrect number of points in atomtype entry (%s)\" % split)\n\n mass = float(split[2+d]) * units.amu\n charge = float(split[3+d]) * units.elementary_charge\n ptype = split[4+d]\n if System._sys.combination_rule == 1:\n sigma = (float(split[6+d]) / float(split[5+d])) ** (1.0/6.0)\n epsilon = float(split[5+d]) / (4*sigma**6)\n\n newAtomType = AtomCR1Type(atomtype,\n bondtype,\n atomic_number,\n mass,\n charge,\n ptype,\n sigma * units.kilojoules_per_mole * units.nanometers**(6), # C6\n epsilon * units.kilojoules_per_mole * units.nanometers**(12)) # C12\n\n elif (System._sys.combination_rule == 2) or (System._sys.combination_rule == 3):\n newAtomType = AtomCR23Type(atomtype,\n bondtype,\n atomic_number,\n mass,\n charge,\n ptype,\n float(split[5+d]) * units.nanometers, # sigma\n float(split[6+d]) * units.kilojoules_per_mole) # epsilon\n System._sys._atomtypes.add(newAtomType)\n\n elif match.group('bondtypes'):\n logger.debug(\"Parsing [ bondtypes ]...\")\n expanded.pop(i)\n\n while not (expanded[i].count('[')) and i < len(expanded)-1:\n split = expanded.pop(i).split()\n newBondType = None\n\n # Bond\n if int(split[2]) == 1:\n newBondType = BondType(split[0],\n split[1],\n float(split[3]) * units.nanometers,\n float(split[4]) * units.kilojoules_per_mole * units.nanometers**(-2))\n\n # G96Bond\n elif int(split[2]) == 2:\n newBondType = G96BondType(split[0],\n split[1],\n float(split[3]) * units.nanometers,\n float(split[4]) * units.kilojoules_per_mole * units.nanometers**(-4))\n\n # Morse\n elif int(split[2]) == 3:\n newBondType = MorseBondType(split[0],\n split[1],\n float(split[3]) * units.nanometers,\n float(split[4]) * units.kilojoules_per_mole,\n float(split[5]) * units.nanometers**(-1))\n\n # Cubic\n elif int(split[2]) == 4:\n newBondType = CubicBondType(split[0],\n split[1],\n float(split[3]) * units.nanometers,\n float(split[4]) * units.kilojoules_per_mole * units.nanometers**(-2),\n float(split[5]) * units.kilojoules_per_mole * units.nanometers**(-3))\n\n # Harmonic\n elif int(split[2]) == 6:\n newBondType = HarmonicPotentialType(split[0],\n split[1],\n float(split[3]) * units.nanometers,\n float(split[4]) * units.kilojoules_per_mole * units.nanometers**(-2))\n else:\n raise Exception(\"%s is not a supported bond type\" % split[2])\n\n if newBondType:\n self.bondtypes.add(newBondType)\n\n elif match.group('pairtypes'):\n logger.debug(\"Parsing [ pairtypes ]...\")\n expanded.pop(i)\n\n while not (expanded[i].count('[')) and i < len(expanded)-1:\n\n split = expanded.pop(i).split()\n newPairType = None\n if int(split[2]) == 1:\n # LJ/Coul. 1-4 (Type 1)\n if len(split) == 5:\n if System._sys.combination_rule == 1:\n newPairType = LJ1PairCR1Type(split[0],\n split[1],\n split[2],\n float(split[3]) * units.kilojoules_per_mole * units.nanometers**(6),\n float(split[4]) * units.kilojoules_per_mole * units.nanometers**(12))\n\n elif System._sys.combination_rule == (2 or 3):\n newPairType = LJ1PairCR1Type(split[0],\n split[1],\n split[2],\n float(split[3]) * units.nanometers,\n float(split[4]) * units.kilojoules_per_mole)\n\n # LJ/C. pair NB\n elif len(split) == 7:\n if System._sys.combination_rule == 1:\n newPairType = LJ1PairCR1Type(split[0],\n split[1],\n split[2],\n float(split[3]) * units.elementary_charge,\n float(split[4]) * units.elementary_charge,\n float(split[5]) * units.kilojoules_per_mole * units.nanometers**(6),\n float(split[6]) * units.kilojoules_per_mole * units.nanometers**(12))\n\n elif System._sys.combination_rule == (2 or 3):\n newPairType = LJ1PairCR1Type(split[0],\n split[1],\n split[2],\n float(split[3]) * units.elementary_charge,\n float(split[4]) * units.elementary_charge,\n float(split[5]) * units.nanometers,\n float(split[6]) * units.kilojoules_per_mole)\n\n # LJ/Coul. 1-4 (Type 2)\n elif int(split[2]) == 2:\n if System._sys.combination_rule == 1:\n newPairType = LJ1PairCR1Type(split[0],\n split[1],\n split[2],\n split[3],\n float(split[4]) * units.elementary_charge,\n float(split[5]) * units.elementary_charge,\n float(split[6]) * units.kilojoules_per_mole * units.nanometers**(6),\n float(split[7]) * units.kilojoules_per_mole * units.nanometers**(12))\n\n elif System._sys.combination_rule == (2 or 3):\n newPairType = LJ1PairCR1Type(split[0],\n split[1],\n split[2],\n split[3],\n float(split[4]) * units.elementary_charge,\n float(split[5]) * units.elementary_charge,\n float(split[6]) * units.nanometers,\n float(split[7]) * units.kilojoules_per_mole)\n\n else:\n raise Exception(\"Could not find pair type\")\n\n if newPairType:\n self.pairtypes.add(newPairType)\n\n elif match.group('angletypes'):\n logger.debug(\"Parsing [ angletypes ]...\")\n expanded.pop(i)\n\n while not (expanded[i].count('[')) and i < len(expanded)-1:\n split = expanded.pop(i).split()\n newAngleType = None\n\n # Angle\n if int(split[3]) == 1:\n newAngleType = AngleType(split[0],\n split[1],\n split[2],\n float(split[4]) * units.degrees,\n float(split[5]) * units.kilojoules_per_mole * units.radians**(-2))\n\n # G96Angle\n elif int(split[3]) == 2:\n newAngleType = G96AngleType(split[0],\n split[1],\n split[2],\n float(split[4]) * units.degrees,\n float(split[5]) * units.kilojoules_per_mole)\n\n # Cross bond-bond\n elif int(split[3]) == 3:\n newAngleType = CrossBondBondAngleType(split[0],\n split[1],\n split[2],\n float(split[4]) * units.nanometers,\n float(split[5]) * units.nanometers,\n float(split[6]) * units.kilojoules_per_mole * units.nanometers**(-2))\n\n # Cross bond-angle\n elif int(split[3]) == 4:\n newAngleType = CrossBondAngleAngleType(split[0],\n split[1],\n split[2],\n float(split[4]) * units.nanometers,\n float(split[5]) * units.nanometers,\n float(split[6]) * units.nanometers,\n float(split[7]) * units.kilojoules_per_mole * units.nanometers**(-2))\n\n # Urey-Bradley\n elif int(split[3]) == 5:\n newAngleType = UreyBradleyAngleType(split[0],\n split[1],\n split[2],\n float(split[4]) * units.degrees,\n float(split[5]) * units.kilojoules_per_mole * units.radians**(-2),\n float(split[6]) * units.nanometers,\n float(split[7]) * units.kilojoules_per_mole * units.nanometers**(-2))\n\n # Quartic\n elif int(split[3]) == 6:\n newAngleType = QuarticAngleType(split[0],\n split[1],\n split[2],\n float(split[4]) * units.degrees,\n float(split[5]) * units.kilojoules_per_mole,\n float(split[6]) * units.kilojoules_per_mole * units.radians**(-1),\n float(split[7]) * units.kilojoules_per_mole * units.radians**(-2),\n float(split[8]) * units.kilojoules_per_mole * units.radians**(-3),\n float(split[9]) * units.kilojoules_per_mole * units.radians**(-4))\n\n else:\n raise Exception(\"Could not find angle type\")\n\n if newAngleType:\n self.angletypes.add(newAngleType)\n\n elif match.group('dihedraltypes'):\n logger.debug(\"Parsing [ dihedraltypes ]...\")\n expanded.pop(i)\n\n while not (expanded[i].count('[')) and i < len(expanded)-1:\n split = expanded.pop(i).split()\n newDihedralType = None\n # first, check whether they are using 2 or 4 atom types\n if split[2].isdigit():\n atom1 = 'X'\n atom2 = split[0]\n atom3 = split[1]\n atom4 = 'X'\n d = 0\n\n elif split[4].isdigit():\n atom1 = split[0]\n atom2 = split[1]\n atom3 = split[2]\n atom4 = split[3]\n d = 2\n\n # We can fit everything into two types of dihedrals - dihedral_trig, and improper harmonic\n # dihedral trig is of the form fc0 + sum_i=1^6 fci (cos(nx-phi)\n # proper dihedrals can be stored easily in this form, since they have only 1 n\n # improper dihedrals can as well (flag as improper)\n # RB can be stored as well, assuming phi = 0 or 180\n # Fourier can also be stored.\n # a full dihedral trig can be decomposied in to multiple proper dihedrals.\n\n # will need to handle this a little differently, in that we will need\n # to add multiple 9 dihedrals together into a single dihedral_trig, as long as they\n # have the same phi angle (seems to be always the case).\n\n dtype = int(split[2+d])\n nentries = len(split)\n\n if (dtype == 1 or dtype == 4 or dtype == 9) and nentries == 6+d:\n\n if dtype == 4:\n improper = True\n else:\n improper = False\n\n fc0,fc1,fc2,fc3,fc4,fc5,fc6 = ConvertDihedralFromProperDihedralToDihedralTrig(\n float(split[4+d])*units.kilojoules_per_mole,int(split[5+d]))\n newDihedralType = DihedralTrigType(\n atom1, atom2, atom3, atom4, float(split[3+d]) * units.degrees,\n fc0, fc1, fc2, fc3, fc4, fc5, fc6, improper = improper)\n\n # Improper Harmonic Dihedral: type 2. Can't be converted to any other type\n elif (dtype == 2) and nentries == 5+d:\n newDihedralType = ImproperHarmonicDihedralType(\n atom1,atom2,atom3,atom4,\n float(split[3+d]) * units.degrees,\n float(split[4+d]) * units.kilojoules_per_mole * units.radians**(-2))\n\n # RBDihedral: type 3\n elif (dtype == 3) and nentries == 9+d:\n fc0, fc1, fc2, fc3, fc4, fc5, fc6 = ConvertDihedralFromRBToDihedralTrig(\n float(split[3+d]) * units.kilojoules_per_mole,\n float(split[4+d]) * units.kilojoules_per_mole,\n float(split[5+d]) * units.kilojoules_per_mole,\n float(split[6+d]) * units.kilojoules_per_mole,\n float(split[7+d]) * units.kilojoules_per_mole,\n float(split[8+d]) * units.kilojoules_per_mole,\n 0 * units.kilojoules_per_mole)\n newDihedralType = DihedralTrigType(\n atom1, atom2, atom3, atom4, 0 * units.degrees,\n fc0, fc1, fc2, fc3, fc4, fc5, fc6) # need to look at the sign here\n\n # Fourier Dihedral 5\n elif dtype == 5 and nentries == 7+d:\n fc0, fc1, fc2, fc3, fc4, fc5, fc6 = ConvertDihedralFromFourierToDihedralTrig(\n float(split[3+d]) * units.kilojoules_per_mole,\n float(split[4+d]) * units.kilojoules_per_mole,\n float(split[5+d]) * units.kilojoules_per_mole,\n float(split[6+d]) * units.kilojoules_per_mole)\n\n newDihedralType = DihedralTrigType(\n atom1, atom2, atom3, atom4, 0 * units.degrees,\n fc0, fc1, fc2, fc3, fc4, fc5, fc6)\n\n elif dtype == 8:\n raise Exception(\"Tabulated dihedrals not supported\")\n else:\n raise Exception(\"Could not find dihedral type\")\n\n if newDihedralType:\n if dtype == 9:\n # we can't actually store multiple dihedral parameters in our\n # architecture, so we add up the types into a single DihedralTrigDihedral angle\n try:\n dihedralmatch = self.dihedraltypes.get(newDihedralType)\n dihedralmatch.sum_parameters(newDihedralType)\n except Exception as e:\n logger.exception(e) # EDZ: used to be pass, now recorded but supressed\n self.dihedraltypes.add(newDihedralType)\n\n elif match.group('constrainttypes'):\n logger.debug(\"Parsing [ constrainttypes ]...\")\n expanded.pop(i)\n\n while not (expanded[i].count('[')) and i < len(expanded)-1:\n #newPairType = PairType(expanded.pop(i).split())\n #self.pairtypes.add(newPairType)\n expanded.pop(i)\n\n elif match.group('nonbond_params'):\n logger.debug(\"Parsing [ nonbond_params ]...\")\n expanded.pop(i)\n\n while not (expanded[i].count('[')) and i < len(expanded)-1:\n split = expanded.pop(i).split()\n newNonbondedType = None\n if int(split[2]) == 1:\n if System._sys.combination_rule == 1:\n sigma = (float(split[4]) / float(split[3])) ** (1.0/6.0)\n sigma *= units.kilojoules_per_mole * units.nanometers**(6)\n epsilon = float(split[3]) / (4 * sigma**6)\n epsilon *= units.kilojoules_per_mole * units.nanometers**(12)\n newNonbondedType = NonbondedLJCR1Type(split[0], split[1], split[2],\n sigma, epsilon)\n elif System._sys.combination_rule in (2, 3):\n sigma = float(split[3]) * units.nanometers\n epsilon = float(split[4]) * units.kilojoules_per_mole\n newNonbondedType = NonbondedLJCR23Type(split[0], split[1], split[2],\n sigma, epsilon)\n\n elif int(split[2]) == 2:\n # TODO\n warn(\"Found Buckingham entry in [ nonbond_param ]. Not yet implemented!\")\n else:\n warn(\"Found unknown entry type in [ nonbond_param ]. Ignoring.\")\n System._sys._nonbonded.add(newNonbondedType)\n\n elif match.group('system'):\n logger.debug(\"Parsing [ system ]...\")\n expanded.pop(i)\n\n while not (expanded[i].count('[')) and i < len(expanded)-1:\n expanded.pop(i)\n else:\n i += 1\n else:\n i += 1\n\n molDirective = re.compile(r\"\"\"\n \\[[ ]{1}\n ((?Pmoleculetype)\n |\n (?Patoms)\n |\n (?Pbonds)\n |\n (?Ppairs)\n |\n (?Pangles)\n |\n (?Pdihedrals)\n |\n (?Pconstraints)\n |\n (?Psettles)\n |\n (?Pexclusions)\n |\n (?Pmolecules))\n [ ]{1} \\]\n \"\"\", re.VERBOSE)\n i = 0\n moleculeName = None\n currentMolecule = None\n while i < len(expanded):\n match = molDirective.match(expanded[i])\n if match:\n if match.group('moleculetype'):\n logger.debug(\"Parsing [ moleculetype ]...\")\n expanded.pop(i)\n split = expanded[i].split()\n\n moleculeName = split[0]\n currentMolecule = Molecule(moleculeName)\n System._sys.add_molecule(currentMolecule)\n currentMoleculeType = System._sys._molecules[moleculeName]\n currentMoleculeType.nrexcl = int(split[1])\n expanded.pop(i)\n\n elif match.group('atoms'):\n logger.debug(\"Parsing [ atoms ]...\")\n expanded.pop(i)\n\n while not (expanded[i].count('[')) and i < len(expanded)-1:\n split = expanded.pop(i).split()\n\n atom = Atom(int(split[0]), # AtomNum (index)\n split[4].strip(), # name\n int(split[2]), # resNum\n split[3].strip()) # resName\n atom.setAtomType(0, split[1].strip())\n atom.cgnr = int(split[5])\n atom.setCharge(0, float(split[6]) * units.elementary_charge)\n try:\n atom.setMass(0, float(split[7]) * units.amu)\n except:\n atom.setMass(0, -1 * units.amu)\n\n if len(split) == 11:\n atom.setAtomType(1, split[8].strip())\n atom.setCharge(1, float(split[9]) * units.elementary_charge)\n atom.setMass(1, float(split[10]) * units.amu)\n\n index = 0\n for atomType in atom._atomtype:\n # Searching for a matching atomType to pull values from\n tempType = AbstractAtomType(atom._atomtype[index])\n atomType = System._sys._atomtypes.get(tempType)\n if atomType:\n atom.atomic_number = atomType.atomic_number\n if not atom.bondtype:\n if atomType.bondtype:\n atom.bondtype = atomType.bondtype\n else:\n logger.warn(\"A suspicious parameter was found in atom/atomtypes. Visually inspect before using.\\n\")\n if atom._mass[index]._value < 0:\n if atomType.mass._value >= 0:\n atom.setMass(index, atomType.mass)\n else:\n logger.warn(\"A suspicious parameter was found in atom/atomtypes. Visually inspect before using.\\n\")\n # Assuming ptype = A\n #atom.ptype = atomType.ptype\n\n atom.setSigma(index, atomType.sigma)\n atom.setEpsilon(index, atomType.epsilon)\n\n else:\n logger.warn(\"A corresponding AtomType was not found. Insert missing values yourself.\\n\")\n index += 1\n\n currentMolecule.addAtom(atom)\n elif match.group('bonds'):\n logger.debug(\"Parsing [ bonds ]...\")\n expanded.pop(i)\n\n while not (expanded[i].count('[')) and i < len(expanded)-1:\n split = expanded.pop(i).split()\n newBondForce = None\n\n if len(split) == 3:\n atomtype1 = currentMolecule._atoms[int(split[0])-1].bondtype\n atomtype2 = currentMolecule._atoms[int(split[1])-1].bondtype\n tempType = AbstractBondType(atomtype1, atomtype2)\n bondType = self.bondtypes.get(tempType)\n if not bondType:\n # we only have the reversed bond order stored, flip the atoms\n tempType = AbstractBondType(atomtype2, atomtype1)\n bondType = self.bondtypes.get(tempType)\n if not bondType:\n raise Exception(\"Bondtype lookup failed for '{0}'\".format(\" \".join(split)))\n\n if isinstance(bondType, BondType):\n split.append(bondType.length)\n split.append(bondType.k)\n\n elif isinstance(bondType, G96BondType):\n split.append(bondType.length)\n split.append(bondType.k)\n\n elif isinstance(bondType, CubicBondType):\n split.append(bondType.length)\n split.append(bondType.C2)\n split.append(bondType.C3)\n\n elif isinstance(bondType, MorseBondType):\n split.append(bondType.length)\n split.append(bondType.D)\n split.append(bondType.beta)\n\n elif isinstance(bondType, HarmonicPotentialType):\n split.append(bondType.length)\n split.append(bondType.k)\n else:\n warn(\"Bondtype '{0}' is unsupported or something more complicated went wrong\".format(bondType.type))\n\n if int(split[2]) == 1:\n try:\n newBondForce = Bond(int(split[0]),\n int(split[1]),\n float(split[3]) * units.nanometers,\n float(split[4]) * units.kilojoules_per_mole * units.nanometers**(-2))\n except:\n newBondForce = Bond(int(split[0]),\n int(split[1]),\n split[3],\n split[4])\n\n if int(split[2]) == 2:\n try:\n newBondForce = G96Bond(int(split[0]),\n int(split[1]),\n float(split[3]) * units.nanometers,\n float(split[4]) * units.kilojoules_per_mole * units.nanometers**(-4))\n except:\n newBondForce = G96Bond(int(split[0]),\n int(split[1]),\n split[3],\n split[4])\n\n if int(split[2]) == 3:\n try:\n newBondForce = MorseBond(int(split[0]),\n int(split[1]),\n float(split[3]) * units.nanometers,\n float(split[4]) * units.kilojoules_per_mole,\n float(split[5]) * units.nanometers**(-1))\n except:\n newBondForce = MorseBond(int(split[0]),\n int(split[1]),\n split[3],\n split[4],\n split[5])\n\n if int(split[2]) == 4:\n try:\n newBondForce = CubicBond(int(split[0]),\n int(split[1]),\n float(split[3]) * units.nanometers,\n float(split[4]) * units.kilojoules_per_mole * units.nanometers**(-2),\n float(split[4]) * units.kilojoules_per_mole * units.nanometers**(-3))\n except:\n newBondForce = CubicBond(int(split[0]),\n int(split[1]),\n split[3],\n split[4],\n split[5])\n\n if int(split[2]) == 6:\n try:\n newBondForce = HarmonicPotential(int(split[0]),\n int(split[1]),\n float(split[3]) * units.nanometers,\n float(split[4]) * units.kilojoules_per_mole * units.nanometers**(-2))\n except:\n newBondForce = HarmonicPotential(int(split[0]),\n int(split[1]),\n split[3],\n split[4])\n\n currentMoleculeType.bondForceSet.add(newBondForce)\n\n elif match.group('pairs'):\n logger.debug(\"Parsing [ pairs ]...\")\n expanded.pop(i)\n\n while not (expanded[i].count('[')) and i < len(expanded)-1:\n split = expanded.pop(i).split()\n newPairForce = None\n\n if int(split[2]) == 1:\n if len(split) == 3:\n # this probably won't work due to units\n newPairForce = AbstractPair(int(split[0]), int(split[1]), \"Both\")\n\n currentMoleculeType.pairForceSet.add(newPairForce)\n\n elif match.group('angles'):\n logger.debug(\"Parsing [ angles ]...\")\n expanded.pop(i)\n\n while not (expanded[i].count('[')) and i < len(expanded)-1:\n split = expanded.pop(i).split()\n newAngleForce = None\n\n if len(split) == 4:\n atomtype1 = currentMolecule._atoms[int(split[0])-1].bondtype\n atomtype2 = currentMolecule._atoms[int(split[1])-1].bondtype\n atomtype3 = currentMolecule._atoms[int(split[2])-1].bondtype\n tempType = AbstractAngleType(atomtype1, atomtype2, atomtype3)\n angleType = self.angletypes.get(tempType)\n if not (angleType):\n #flip it around.\n tempType = AbstractAngleType(atomtype3, atomtype2, atomtype1)\n angleType = self.angletypes.get(tempType)\n\n if isinstance(angleType, AngleType):\n split.append(angleType.theta)\n split.append(angleType.k)\n\n if isinstance(angleType, G96AngleType):\n split.append(angleType.theta)\n split.append(angleType.k)\n\n if isinstance(angleType, CrossBondBondAngleType):\n split.append(angleType.r1)\n split.append(angleType.r2)\n split.append(angleType.k)\n\n if isinstance(angleType, CrossBondAngleAngleType):\n split.append(angleType.r1)\n split.append(angleType.r2)\n split.append(angleType.r3)\n split.append(angleType.k)\n\n if isinstance(angleType, UreyBradleyAngleType):\n split.append(angleType.theta)\n split.append(angleType.k)\n split.append(angleType.r)\n split.append(angleType.kUB)\n\n if isinstance(angleType, QuarticAngleType):\n split.append(angleType.theta)\n split.append(angleType.C0)\n split.append(angleType.C1)\n split.append(angleType.C2)\n split.append(angleType.C3)\n split.append(angleType.C4)\n\n # Angle\n if int(split[3]) == 1:\n try:\n newAngleForce = Angle(int(split[0]),\n int(split[1]),\n int(split[2]),\n float(split[4]) * units.degrees,\n float(split[5]) * units.kilojoules_per_mole * units.radians**(-2))\n except:\n newAngleForce = Angle(int(split[0]),\n int(split[1]),\n int(split[2]),\n split[4],\n split[5])\n\n # G96Angle\n elif int(split[3]) == 2:\n try:\n newAngleForce = G96Angle(int(split[0]),\n int(split[1]),\n int(split[2]),\n float(split[4]) * units.degrees,\n float(split[5]) * units.kilojoules_per_mole)\n except:\n newAngleForce = G96Angle(int(split[0]),\n int(split[1]),\n int(split[2]),\n split[4],\n split[5])\n\n # Cross Bond-Bond\n elif int(split[3]) == 3:\n try:\n newAngleForce = CrossBondBondAngle(int(split[0]),\n int(split[1]),\n int(split[2]),\n float(split[4]) * units.nanometers,\n float(split[5]) * units.nanometers,\n float(split[6]) * units.kilojoules_per_mole * units.nanometers**(-2))\n except:\n newAngleForce = CrossBondBondAngle(int(split[0]),\n int(split[1]),\n int(split[2]),\n split[4],\n split[5],\n split[6])\n\n # Cross Bond-Angle\n elif int(split[3]) == 4:\n try:\n newAngleForce = CrossBondAngleAngle(int(split[0]),\n int(split[1]),\n int(split[2]),\n float(split[4]) * units.nanometers,\n float(split[5]) * units.nanometers,\n float(split[6]) * units.nanometers,\n float(split[7]) * units.kilojoules_per_mole * units.nanometers**(-2))\n except:\n newAngleForce = CrossBondAngleAngle(int(split[0]),\n int(split[1]),\n int(split[2]),\n split[4],\n split[5],\n split[6],\n split[7])\n\n # Urey-Bradley\n elif int(split[3]) == 5:\n try:\n newAngleForce = UreyBradleyAngle(int(split[0]),\n int(split[1]),\n int(split[2]),\n float(split[4]) * units.degrees,\n float(split[5]) * units.kilojoules_per_mole * units.radians**(-2),\n float(split[6]) * units.nanometers,\n float(split[7]) * units.kilojoules_per_mole * units.nanometers**(-2))\n except:\n newAngleForce = UreyBradleyAngle(int(split[0]),\n int(split[1]),\n int(split[2]),\n split[4],\n split[5],\n split[6],\n split[7])\n\n # Quartic\n elif int(split[3]) == 6:\n try:\n newAngleForce = QuarticAngle(int(split[0]),\n int(split[1]),\n int(split[2]),\n float(split[4]) * units.degrees,\n float(split[5]) * units.kilojoules_per_mole,\n float(split[6]) * units.kilojoules_per_mole * units.radians**(-1),\n float(split[7]) * units.kilojoules_per_mole * units.radians**(-2),\n float(split[8]) * units.kilojoules_per_mole * units.radians**(-3),\n float(split[9]) * units.kilojoules_per_mole * units.radians**(-4))\n except:\n newAngleForce = QuarticAngle(int(split[0]),\n int(split[1]),\n int(split[2]),\n split[4],\n split[5],\n split[6],\n split[7],\n split[8],\n split[9])\n\n currentMoleculeType.angleForceSet.add(newAngleForce)\n\n elif match.group('dihedrals'):\n logger.debug(\"Parsing [ dihedrals ]...\")\n expanded.pop(i)\n while not (expanded[i].count('[')) and i < len(expanded)-1:\n split = expanded.pop(i).split()\n newDihedralForce = None\n dihedralType = None\n\n dtype = int(split[4])\n improper = (dtype == 4) or (dtype == 2)\n if len(split) == 5:\n\n atomtype1 = currentMolecule._atoms[int(split[0])-1].bondtype\n atomtype2 = currentMolecule._atoms[int(split[1])-1].bondtype\n atomtype3 = currentMolecule._atoms[int(split[2])-1].bondtype\n atomtype4 = currentMolecule._atoms[int(split[3])-1].bondtype\n\n # check the possible ways to match a dihedraltype\n atomtypelists = [[atomtype1, atomtype2, atomtype3, atomtype4], # original order\n [atomtype4, atomtype3, atomtype2, atomtype1], # flip it\n [atomtype1, atomtype2, atomtype3, 'X'], #single wildcard 1\n ['X', atomtype2, atomtype3, atomtype4], #single wildcard 2\n ['X', atomtype3, atomtype2, atomtype1], # flipped single wildcard 1\n [atomtype4, atomtype3, atomtype2, 'X'], # flipped single wildcard 2\n ['X', atomtype2, atomtype3, 'X'], # double wildcard\n ['X', atomtype3, atomtype2, 'X'], # flipped double wildcard\n ['X', 'X', atomtype3, atomtype4], # end double wildcard\n [atomtype1, atomtype2,'X', 'X'] # flipped end double wildcard\n ]\n\n for alist in atomtypelists:\n if not dihedralType:\n tempType = AbstractDihedralType(alist[0], alist[1], alist[2], alist[3], improper)\n dihedralType = self.dihedraltypes.get(tempType)\n else:\n break\n\n if isinstance(dihedralType, DihedralTrigType):\n phi = dihedralType.phi\n fc0 = dihedralType.fc0\n fc1 = dihedralType.fc1\n fc2 = dihedralType.fc2\n fc3 = dihedralType.fc3\n fc4 = dihedralType.fc4\n fc5 = dihedralType.fc5\n fc6 = dihedralType.fc6\n\n elif isinstance(dihedralType, ImproperHarmonicDihedralType):\n phi = dihedralType.xi\n k = dihedralType.k\n else:\n warn(\"Did not find matching dihedraltype!\")\n\n atom1 = int(split[0])\n atom2 = int(split[1])\n atom3 = int(split[2])\n atom4 = int(split[3])\n nentries = len(split)\n\n # Proper Dihedral 1\n if int(split[4]) == 1 or int(split[4]) == 9 or int(split[4]) == 4:\n\n if nentries > 5:\n fc0, fc1, fc2, fc3, fc4, fc5, fc6 = ConvertDihedralFromProperDihedralToDihedralTrig(\n float(split[6]) * units.kilojoules_per_mole, int(split[7]))\n phi = float(split[5]) * units.degrees\n newDihedralForce = DihedralTrigDihedral(\n atom1, atom2, atom3, atom4, phi,\n fc0, fc1, fc2, fc3, fc4, fc5, fc6, improper=improper)\n\n # for dihedral type 9, there can be multiple interactions\n\n # Improper Dihedral 2\n elif dtype == 2:\n if nentries > 5:\n phi = float(split[5]) * units.degrees\n k = float(split[6]) * units.kilojoules_per_mole * units.radians**(-2)\n\n newDihedralForce = ImproperHarmonicDihedral(\n atom1, atom2, atom3, atom4, phi, k)\n\n # RBDihedral\n elif dtype == 3:\n\n if nentries > 5:\n fc0, fc1, fc2, fc3, fc4, fc5, fc6 = ConvertDihedralFromRBToDihedralTrig(\n float(split[5]) * units.kilojoules_per_mole,\n float(split[6]) * units.kilojoules_per_mole,\n float(split[7]) * units.kilojoules_per_mole,\n float(split[8]) * units.kilojoules_per_mole,\n float(split[9]) * units.kilojoules_per_mole,\n float(split[10]) * units.kilojoules_per_mole,\n 0 * units.kilojoules_per_mole)\n\n newDihedralForce = DihedralTrigDihedral(\n atom1, atom2, atom3, atom4,\n 0 * units.degrees, fc0, fc1, fc2, fc3, fc4, fc5, fc6) # need to look at the use of sign here\n\n elif dtype == 5:\n\n if nentries > 5:\n fc0, fc1, fc2, fc3, fc4, fc5, fc6 = ConvertDihedralFromFourierToDihedralTrig(\n float(split[5])*units.kilojoules_per_mole,\n float(split[6])*units.kilojoules_per_mole,\n float(split[7])*units.kilojoules_per_mole,\n float(split[8])*units.kilojoules_per_mole,\n )\n\n newDihedralForce = DihedralTrigDihedral(\n atom1, atom2, atom3, atom4,\n 0 * units.degrees, fc0, fc1, fc2, fc3, fc4, fc5, fc6) # need to look at the use of sign here\n\n elif dtype == 8:\n raise Exception(\"Cannot support tabulated dihedrals\")\n else:\n raise Exception(\"Unsupported dihedral\")\n\n if dtype == 9:\n # we need to retrive the information add to the dihedral,\n # rather than overwrite it\n # warning: right now, I don't think we can have BOTH duplicate dihedrals and\n # duplicate dihedral types. Will have to investigate.\n try:\n # retrive a dihedral with the same atoms, add to it if it exists\n dihedralmatch = currentMoleculeType.dihedralForceSet.map[newDihedralForce]\n dihedralmatch.sum_parameters(newDihedralForce)\n except Exception as e:\n logger.exception(e) # used to be pass, now recorded but surpressed\n currentMoleculeType.dihedralForceSet.add(newDihedralForce)\n\n elif match.group('constraints'):\n logger.debug(\"Parsing [ constraints ]...\")\n expanded.pop(i)\n\n while not (expanded[i].count('[')) and i < len(expanded)-1:\n expanded.pop(i)\n\n elif match.group('settles'):\n logger.debug(\"Parsing [ settles ]...\")\n expanded.pop(i)\n\n while not (expanded[i].count('[')) and i < len(expanded)-1:\n split = expanded.pop(i).split()\n newSettlesForce = None\n\n if len(split) == 4:\n newSettlesForce = Settles(int(split[0]),\n float(split[2]) * units.nanometers,\n float(split[3]) * units.nanometers)\n\n currentMoleculeType.settles = newSettlesForce\n\n # we need to add a constrainted bonded forces as well between the atoms in these molecules.\n # we assume the gromacs default of 1. O, 2. H, 3. H\n # reference bond strength is 900 kj/mol, but doesn't really matter since constrainted.\n #waterbondrefk = 900*units.kilojoules_per_mole * units.nanometers**(-2)\n #wateranglerefk = 400*units.kilojoules_per_mole * units.degrees**(-2)\n \n # From oplsaa.ff/tip3p.itp - JPT\n waterbondrefk = 502416.0 * units.kilojoules_per_mole * units.nanometers**(-2)\n wateranglerefk = 628.02 * units.kilojoules_per_mole * units.radians**(-2)\n\n angle = 2.0 * math.asin(0.5 * float(split[3]) / float(split[2])) * units.radians\n dOH = float(split[2]) * units.nanometers\n\n newBondForce = Bond(1,2,dOH,waterbondrefk,c=True)\n currentMoleculeType.bondForceSet.add(newBondForce)\n\n newBondForce = Bond(1,3,dOH,waterbondrefk,c=True)\n currentMoleculeType.bondForceSet.add(newBondForce)\n\n newAngleForce = Angle(3,1,2,angle,wateranglerefk,c=True)\n currentMoleculeType.angleForceSet.add(newAngleForce)\n\n elif match.group('exclusions'):\n logger.debug(\"Parsing [ exclusions ]...\")\n expanded.pop(i)\n\n while not (expanded[i].count('[')) and i < len(expanded)-1:\n split = expanded.pop(i).split()\n for j in range(len(split)):\n if split[0] < split[j]:\n newExclusion = Exclusions([int(split[0]),int(split[j])])\n currentMoleculeType.exclusions.add(newExclusion)\n\n\n elif match.group('molecules'):\n logger.debug(\"Parsing [ molecules ]...\")\n expanded.pop(i)\n ordered_moleculetypes = OrderedDict()\n while i < len(expanded) and not (expanded[i].count('[')):\n split = expanded.pop(i).split()\n mol_name = split[0]\n mol_num = int(split[1])\n System._sys._components.append((mol_name, mol_num))\n\n ordered_moleculetypes[mol_name] = System._sys._molecules[mol_name]\n tempMolecule = System._sys._molecules[mol_name].moleculeSet[0]\n if len(System._sys._molecules[mol_name].moleculeSet) > 1:\n n = 0\n else:\n n = 1\n while n < mol_num:\n mol = copy.deepcopy(tempMolecule)\n System._sys.add_molecule(mol)\n n += 1\n System._sys._molecules = ordered_moleculetypes\n else:\n i += 1\n else:\n i += 1\n\n def preprocess(self, filename, verbose=False):\n \"\"\"\n Preprocess a topology file\n\n Preprocesses for #include, #define, #ifdef directives and handles them\n\n Args:\n filename: the filename to preprocess\n verbose: verbose output\n \"\"\"\n expanded = list()\n lineReg = re.compile(r\"\"\"\n [ ]* # omit spaces\n (?P[^\\\\;\\n]*) # search for directive section\n [ ]* # omit spaces\n (?P\\\\)? # look for the \\ for newline\n (?P;.*)? # look for a comment\n \"\"\", re.VERBOSE)\n preReg = re.compile(r\"\"\"\n (?:\\#include[ ]+)\n (?:\"|<)\n (?P.+\\.itp|.+\\.top)\n (?:\"|>)\n |\n (?:\\#define[ ]+)\n (?P[\\S]+)\n (?P[ ]+.+)?\n |\n (?:\\#undef[ ]+)\n (?P[\\S]+)\n |\n (?:\\#ifdef[ ]+)\n (?P[\\S]+)\n |\n (?:\\#ifndef[ ]+)\n (?P[\\S]+)\n |\n (?P\\#else)\n |\n (?P\\#endif)\n \"\"\", re.VERBOSE)\n condDepth = 0\n write = [True]\n fd = self.open(filename)\n if fd is not None:\n lines = deque(fd) # initial read of root file\n fd.close()\n while(lines): # while the queue isn't empty continue preprocessing\n line = lines.popleft()\n logger.debug(\"=========================\")\n logger.debug(\"Original line: %s\" % line)\n match = lineReg.match(line) # ensure that the line matches what we expect!\n if match:\n line = match.group('directive')\n comment = match.group('comment')\n logger.debug(\"Directive: %s\" % line)\n logger.debug(\"Comment: %s\" % comment)\n while True: # expand the lines\n if match.group('ignore_newline'):\n logger.debug(\"Ignore newline found\")\n if lines:\n temp = lines.popleft()\n match = lineReg.match(temp)\n line += match.group('directive')\n else:\n logger.warn(\"Previous line continues yet EOF encountered\")\n break # EOF so we can't loop again\n else:\n break # line terminates\n line = line.strip() # just in case theres whitespace we missed\n\n match = preReg.match(line)\n if match is not None:\n if match.group('ifdef') and write[condDepth]:\n logger.debug('Found an ifdef: %s' % match.group('ifdef'))\n condDepth += 1\n ifdef = match.group('ifdef')\n if ifdef in self.defines:\n write.append(True)\n else:\n write.append(False)\n elif match.group('ifndef') and write[condDepth]:\n logger.debug('Found an ifndef: %s' % match.group('ifndef'))\n condDepth += 1\n ifndef = match.group('ifndef')\n if ifndef not in self.defines:\n write.append(True)\n else:\n write.append(False)\n elif match.group('else'):\n logger.debug('Found an else')\n if condDepth > 0:\n write[condDepth] = not write[condDepth]\n else:\n logger.warn(\"Found an else not associated with a conditional\")\n elif match.group('endif'):\n logger.debug('Found an endif')\n if condDepth > 0:\n condDepth -= 1\n write.pop()\n else:\n raise Exception(\"Found an endif not associated with a conditional\")\n elif write[condDepth]:\n if match.group('include'):\n logger.debug(\"Found a include: %s\" % line)\n include = match.group('include')\n fd = self.open(include)\n if fd is not None:\n tempList = list(fd)\n tempList.reverse()\n lines.extendleft(tempList)\n elif match.group('defineLiteral'):\n logger.debug(\"Found a define: %s\" % line)\n define = match.group('defineLiteral')\n\n if define not in self.defines:\n self.defines[define] = match.group('defineData')\n else:\n logger.warn(\"WARNING: Overriding define: %s\" % define)\n self.define[define] = match.group('defineData')\n elif match.group('undef'):\n logger.debug(\"Found a undefine: %s\" % line)\n undef = match.group('undef')\n if undef in self.defines:\n self.defines.pop(undef)\n elif write[condDepth]:\n if line != '':\n for define in self.defines:\n if define in line:\n line = line.replace(define, self.defines[define])\n logger.debug(\"Writing: %s\" % line)\n expanded.append(line)\n if comment:\n self.comments.append(comment)\n else:\n raise Exception(\"Unreadable line!\")\n return expanded\n else:\n fd.close()\n\n def open(self, filename, parentfile=''):\n \"\"\"\n Open a file and add to includes list\n\n Checks if a file exists in the same directory as the top and gro files\n or in the GMXLIB environment; then opens if found or fails if not\n\n Args:\n filename: the name of the file to open\n\n Returns:\n file descriptor of the file to be openend\n\n Raises:\n IOError when the file cannot be opened for any reason\n \"\"\"\n if filename in self.includes:\n logger.warn(\"Omitting file %s. It has already been included!\" % filename)\n return None\n temp = filename\n\n if os.path.exists(filename):\n try:\n fd = open(filename)\n self.includes.add(temp)\n logger.info(\"Local instance of topology file '%s' used\\n\" % (filename))\n return fd\n except IOError, (errno, strerror):\n logger.exception(\"I/O error(%d): %s for local instance of '%s'\\n\" % (errno, strerror, filename))\n\n # if we can't include the file locally, let's look for it in\n # the directory of one of the previous files. \n\n # NOTE: could be\n # dangerous if multiple files with the same name are found in\n # different directories!\n found = False\n for parentfile in self.includes:\n parentdir, oldfile = os.path.split(parentfile)\n filename = os.path.join(parentdir, temp)\n if os.path.exists(filename):\n found = True\n break\n\n if found:\n try:\n fd = open(filename)\n self.includes.add(temp)\n logger.info(\"version in %s used for topology file '%s'\\n\" % (parentdir, filename))\n return fd\n except Exception as e:\n logger.exception(e) # EDZ: used to be pass, now recorded but supressed\n else:\n try:\n filename = os.path.join(os.environ['GMXLIB'], temp)\n fd = open(filename)\n self.includes.add(filename)\n logger.info(\"version in GMXLIB = %s used for topology file '%s'\\n\" % (os.environ['GMXLIB'], temp))\n return fd\n\n except IOError, (errno, strerror):\n logger.exception(\"Unrecoverable I/O error(%d): can'd find %s anywhere: '%s'\\n\" % (errno, strerror, filename))\n sys.exit()\n\n def write_topology(self, filename):\n \"\"\"Write this topology in GROMACS file format.\n\n Args:\n filename: the name of the file to write out to\n \"\"\"\n lines = list()\n\n # [ defaults ]\n lines.append('[ defaults ]\\n')\n lines.append('; nbfunc comb-rule gen-pairs fudgeLJ fudgeQQ\\n')\n lines.append('%d%16d%18s%20.4g%8.4g\\n'\n % (System._sys.nonbonded_function,\n System._sys.combination_rule,\n System._sys.genpairs,\n System._sys.lj_correction,\n System._sys.coulomb_correction))\n lines.append('\\n')\n\n # [ atomtypes ]\n lines.append('[ atomtypes ]\\n')\n lines.append(';type, bondtype, atomic_number, mass, charge, ptype, sigma, epsilon\\n')\n atomtypelist = sorted(System._sys._atomtypes.itervalues(), key=lambda x: x.atomtype)\n for atomtype in atomtypelist:\n# if atomtype.atomtype.isdigit():\n# atomtype.atomtype = \"LMP_\" + atomtype.atomtype\n# if atomtype.bondtype.isdigit():\n# atomtype.bondtype = \"LMP_\" + atomtype.bondtype\n if System._sys.combination_rule == 1:\n lines.append('%-11s%5s%6d%18.8f%18.8f%5s%18.8e%18.8e\\n'\n % (atomtype.atomtype,\n atomtype.bondtype,\n int(atomtype.atomic_number),\n atomtype.mass.in_units_of(units.atomic_mass_unit)._value,\n atomtype.charge.in_units_of(units.elementary_charge)._value,\n atomtype.ptype,\n atomtype.sigma.in_units_of(units.kilojoules_per_mole * units.nanometers**(6))._value,\n atomtype.epsilon.in_units_of(units.kilojoules_per_mole * units.nanometers**(12))._value))\n elif System._sys.combination_rule in (2, 3):\n lines.append('%-10s %-10s %4d %12.6f %9.3f %5s %16.6e %16.6e\\n'\n % (atomtype.atomtype,\n atomtype.bondtype,\n int(atomtype.atomic_number),\n atomtype.mass.in_units_of(units.atomic_mass_unit)._value,\n atomtype.charge.in_units_of(units.elementary_charge)._value,\n atomtype.ptype,\n atomtype.sigma.in_units_of(units.nanometers)._value,\n atomtype.epsilon.in_units_of(units.kilojoules_per_mole)._value))\n lines.append('\\n')\n\n if System._sys._nonbonded:\n # [ nonbond_params ]\n lines.append('[ nonbond_params ]\\n')\n nonbondedlist = sorted(moleculeType.bondForceSet.itervalues(), key=lambda x: (x.atom1, x.atom2))\n for nonbonded in nonbondedlist:\n if System._sys.combination_rule == 1:\n lines.append('{0:6s} {1:6s} {2:3d} {3:18.8e} {4:18.8e}\\n'.format(\n nonbonded.atom1, nonbonded.atom2, nonbonded.type,\n nonbonded.sigma.in_units_of(units.kilojoules_per_mole * units.nanometers**(6))._value,\n nonbonded.epsilon.in_units_of(units.kilojoules_per_mole * units.nanometers**(12))._value))\n elif System._sys.combination_rule in (2, 3):\n lines.append('{0:6s} {1:6s} {2:3s} {3:18.8e} {4:18.8e}\\n'.format(\n nonbonded.atom1, nonbonded.atom2, nonbonded.type,\n nonbonded.sigma.in_units_of(units.nanometers)._value,\n nonbonded.epsilon.in_units_of(units.kilojoules_per_mole)._value))\n lines.append('\\n')\n\n # [ moleculetype]\n moleculeTypelist = sorted(System._sys._molecules.itervalues(), key=lambda x: x.name) \n for moleculeType in moleculeTypelist:\n lines.append('[ moleculetype ]\\n')\n # gromacs can't handle spaces in the molecule name\n printname = moleculeType.name\n printname = printname.replace(' ','_')\n printname = printname.replace('\"','')\n lines.append('%s%10d\\n\\n'\n % (printname,\n moleculeType.nrexcl))\n\n # [ atoms ]\n lines.append('[ atoms ]\\n')\n lines.append(';num, type, resnum, resname, atomname, cgnr, q, m\\n')\n molecule = moleculeType.moleculeSet[0]\n count = 1\n for atom in molecule._atoms:\n# if atom.name.isdigit():\n# atom.name = \"LMP_\" + atom.name\n# if atom._atomtype[0].isdigit():\n# atom._atomtype[0] = \"LMP_\" + atom._atomtype[0]\n\n try:\n lines.append('%6d %10s %6d %8s %8s %6d %12.6f %12.6f %10s %12.6f %12.6f\\n'\n % (count,\n atom._atomtype[0],\n atom.residue_index,\n atom.residue_name,\n atom.name,\n atom.cgnr,\n atom._charge[0].in_units_of(units.elementary_charge)._value,\n atom._mass[0].in_units_of(units.atomic_mass_unit)._value,\n atom._atomtype[1],\n atom._charge[1].in_units_of(units.elementary_charge)._value,\n atom._mass[1].in_units_of(units.atomic_mass_unit)._value))\n except:\n lines.append('%6d %10s %6d %8s %8s %6d %12.6f %12.6f\\n'\n % (count,\n atom._atomtype[0],\n atom.residue_index,\n atom.residue_name,\n atom.name,\n atom.cgnr,\n atom._charge[0].in_units_of(units.elementary_charge)._value,\n atom._mass[0].in_units_of(units.atomic_mass_unit)._value))\n count += 1\n lines.append('\\n')\n\n if moleculeType.bondForceSet and not moleculeType.settles:\n # [ bonds ]\n lines.append('[ bonds ]\\n')\n lines.append('; ai aj funct r k\\n')\n bondlist = sorted(moleculeType.bondForceSet.itervalues(), key=lambda x: (x.atom1,x.atom2))\n for bond in bondlist:\n if isinstance(bond, Bond):\n b_type = 1\n lines.append('%6d %6d %3d %12.6f %16.6e\\n'\n % (bond.atom1,\n bond.atom2,\n b_type,\n bond.length.in_units_of(units.nanometers)._value,\n bond.k.in_units_of(units.kilojoules_per_mole*units.nanometers**(-2))._value))\n elif isinstance(bond, G96Bond):\n b_type = 2\n lines.append('%6d%7d%4d%5.8f%5.8f\\n'\n % (bond.atom1,\n bond.atom2,\n b_type,\n bond.length.in_units_of(units.nanometers)._value,\n bond.k.in_units_of(units.kilojoules_per_mole*units.nanometers**(-4))._value))\n elif isinstance(bond, MorseBond):\n b_type = 3\n lines.append('%6d%7d%4d%5.8f%5.8f%5.8f\\n'\n % (bond.atom1,\n bond.atom2,\n b_type,\n bond.length.in_units_of(units.nanometers)._value,\n bond.D.in_units_of(units.kilojoules_per_mole)._value,\n bond.beta.in_units_of(units.nanometers**(-1))._value))\n elif isinstance(bond, CubicBond):\n b_type = 4\n lines.append('%6d%7d%4d%5.8f%5.8f%5.8f\\n'\n % (bond.atom1,\n bond.atom2,\n b_type,\n bond.length.in_units_of(units.nanometers)._value,\n bond.C2.in_units_of(units.kilojoules_per_mole * units.nanometers**(-2))._value,\n bond.C3.in_units_of(units.kilojoules_per_mole * units.nanometers**(-3))._value))\n else:\n raise Exception(\"WriteError: found unsupported bond type\")\n lines.append('\\n')\n\n #MRS: why are there two pairs sections?\n if moleculeType.pairForceSet:\n # [ pair ]\n lines.append('[ pairs ]\\n')\n lines.append('; ai aj funct\\n')\n pairlist = sorted(moleculeType.pairForceSet.itervalues(), key=lambda x: (x.atom1, x.atom2))\n for pair in pairlist:\n\n if isinstance(pair, AbstractPair):\n p_type = 1\n lines.append('%6d %6d %3d\\n'\n % (pair.atom1,\n pair.atom2,\n p_type))\n\n else:\n raise Exception(\"WriteError: found unsupported pair type\")\n lines.append('\\n')\n\n if moleculeType.angleForceSet and not moleculeType.settles:\n # [ angles ]\n lines.append('[ angles ]\\n')\n lines.append('; ai aj ak funct theta cth\\n')\n\n anglelist = sorted(moleculeType.angleForceSet.itervalues(), key=lambda x: (x.atom1, x.atom2, x.atom3))\n for angle in anglelist:\n atomindex = \"%6d %6d %6d\" % (angle.atom1,angle.atom2,angle.atom3)\n if isinstance(angle, Angle):\n a_type = 1\n lines.append('%s %3d %12.3f %12.6f\\n'\n % (atomindex,\n a_type,\n angle.theta.in_units_of(units.degrees)._value,\n angle.k.in_units_of(units.kilojoules_per_mole*units.radians**(-2))._value))\n elif isinstance(angle, G96Angle):\n a_type = 2\n lines.append('%s%4d%18.8e%18.8e\\n'\n % (atomindex,\n a_type,\n angle.theta.in_units_of(units.degrees)._value,\n angle.k.in_units_of(units.kilojoules_per_mole)._value))\n elif isinstance(angle, UreyBradleyAngle):\n a_type = 5\n lines.append('%s%4d%18.8e%18.8e%18.8e%18.8e\\n'\n % (atomindex,\n a_type,\n angle.theta.in_units_of(units.degrees)._value,\n angle.k.in_units_of(units.kilojoules_per_mole*units.radians**(-2))._value,\n angle.r.in_units_of(units.nanometers)._value,\n angle.kUB.in_units_of(units.kilojoules_per_mole*units.nanometers**(-2))._value))\n else:\n raise Exception(\"WriteError: found unsupported angle type\")\n lines.append('\\n')\n\n \"\"\"\n # [ pairs]\n lines.append('[ pairs ]\\n')\n lines.append('; ai aj funct')\n\n pairlist = sorted(moleculeType.pairForceSet.itervalues(), key=lambda x: x.atom1)\n for pair in pairlist:\n if isinstance(pair, LJ1PairCR1) or isinstance(pair, LJ1PairCR23)\n type = 1\n lines.append('%6d%7d%4d%18.8e%18.8e\\n'%(pair.atom1, pair.atom2, type,\n pair.V.in_units_of(units.XXX)._value,\n pair.W.in_units_of(units.XXX)._value)\n\n elif isinstance(pair, LJ2PairCR1) or isinstance(pair, LJ2PairCR23):\n type = 2\n lines.append('%6d%7d%4d%18.8e%18.8e\\n'%(pair.atom1, pair.atom2, type,\n pair.V.in_units_of(units.XXX)._value,\n pair.W.in_units_of(units.XXX)._value))\n\n elif isinstance(pair, LJNBCR1) or isinstance( pair, LJNBCR23):\n type = 1\n lines.append('%6d%7d%4d%18.8f%18.8f%18.8f%18.8f\\n'%(pair.atom1, pair.atom2, type,\n pair.qi.in_units_of(units.XXX)._value,\n pair.qj.in_units_of(units.XXX)._value,\n pair.V.in_units_of(units.XXX)._value,\n pair.W.in_units_of(units.XXX)._value))\n else:\n print \"Could not identify pair!\"\n \"\"\"\n\n if moleculeType.dihedralForceSet:\n # [ dihedrals ]\n lines.append('[ dihedrals ]\\n')\n lines.append('; i j k l func\\n')\n dihedrallist = sorted(moleculeType.dihedralForceSet.itervalues(),\n key=lambda x: (x.atom1, x.atom2, x.atom3, x.atom4))\n for dihedral in dihedrallist:\n # this atom index will be the same for all of types.\n atomindex = \"%6d %6d %6d %6d\" % (dihedral.atom1, dihedral.atom2,\n dihedral.atom3, dihedral.atom4)\n if isinstance(dihedral, DihedralTrigDihedral):\n # convienience array\n coefficients = [dihedral.fc1, dihedral.fc2, dihedral.fc3,\n dihedral.fc4, dihedral.fc5, dihedral.fc6]\n if dihedral.improper:\n found_nonzero = False\n for n, coeff in enumerate(coefficients): # only one of these should be nonzero\n if coeff._value != 0.0:\n if found_nonzero == False:\n found_nonzero = True\n else:\n raise ValueError(\"Found more than one nonzero \"\n \"coefficient in improper trigonal dihedral!\")\n lines.append('%s %3d %7.1f %17.6f %5d\\n'\n % (atomindex, 4,\n dihedral.phi.in_units_of(units.degrees)._value,\n coeff.in_units_of(units.kilojoules_per_mole)._value,\n n + 1))\n else:\n rb_coeffs = ConvertDihedralFromDihedralTrigToRB(\n np.cos(dihedral.phi.in_units_of(units.radians)._value),\n dihedral.phi, dihedral.fc0, * coefficients)\n # there are some cases where some dihedrals will have c[6] values, which gromacs\n # can't yet handle. We need a workaround, and will go through the route of multiple 9s.\n if (dihedral.phi in [0*units.degrees, 180*units.degrees] and\n rb_coeffs[6]._value == 0):\n d_type = 3\n lines.append('%s %3d %12.6f %12.6f %12.6f %12.6f %12.6f %12.6f\\n'\n % (atomindex,\n d_type,\n rb_coeffs[0].in_units_of(units.kilojoules_per_mole)._value,\n rb_coeffs[1].in_units_of(units.kilojoules_per_mole)._value,\n rb_coeffs[2].in_units_of(units.kilojoules_per_mole)._value,\n rb_coeffs[3].in_units_of(units.kilojoules_per_mole)._value,\n rb_coeffs[4].in_units_of(units.kilojoules_per_mole)._value,\n rb_coeffs[5].in_units_of(units.kilojoules_per_mole)._value))\n else:\n ncount = sum(coeff._value != 0.0 for coeff in coefficients)\n if ncount > 1:\n dtype = 9\n else:\n dtype = 1\n # all of the terms should have consistent phi now\n for n, coeff in enumerate(coefficients):\n if coeff._value < 0:\n # kludge for different definitions of trigonometric\n # dihedral with multiplicity in the central representation\n # and in GROMACS\n coefficients[n] *= -1\n if dihedral.phi.value_in_unit(units.degrees)==180:\n printphi = 0*units.degrees\n else:\n printphi = 180*units.degrees\n else:\n printphi = dihedral.phi\n lines.append('%s%4d%18.8f%18.8f%6d\\n'\n % (atomindex,\n dtype,\n printphi.in_units_of(units.degrees)._value,\n coeff.in_units_of(units.kilojoules_per_mole)._value,\n n + 1))\n\n elif isinstance(dihedral, ImproperHarmonicDihedral):\n d_type = 2\n lines.append('%s%4d%18.8f%18.8f\\n'\n % (atomindex,\n d_type,\n dihedral.xi.in_units_of(units.degrees)._value,\n dihedral.k.in_units_of(units.kilojoules_per_mole*units.radians**(-2))._value))\n\n else:\n raise Exception(\"WriteError: found unsupported dihedral type\")\n lines.append('\\n')\n\n if moleculeType.settles:\n settles = moleculeType.settles\n # [ settles ]\n lines.append('[ settles ]\\n')\n lines.append('; i funct dOH dHH\\n')\n s_type = 1\n lines.append('%6d%6d%18.8f%18.8f\\n'\n % (settles.atom1,\n s_type,\n settles.dOH.in_units_of(units.nanometers)._value,\n settles.dHH.in_units_of(units.nanometers)._value))\n lines.append('\\n')\n\n if moleculeType.exclusions:\n # [ exclusions ]\n lines.append('[ exclusions ]\\n')\n exclusionlist = sorted(moleculeType.exclusions.itervalues(), key=lambda x: x.exclusions[0])\n for exclusion in exclusionlist:\n lines.append('%-6d' % exclusion.exclusions[0])\n for i in range(1, len(exclusion.exclusions)):\n lines.append(' %-6d' % exclusion.exclusions[i]),\n lines.append('\\n')\n\n # [ system ]\n lines.append('[ system ]\\n')\n lines.append('%s\\n' % (System._sys._name))\n lines.append('\\n')\n\n # [ molecules ]\n lines.append('[ molecules ]\\n')\n lines.append('; Compound nmols\\n')\n #for component in System._sys._components:\n # lines.append('%-15s%8d\\n'\n # % (component[0],\n # component[1]))\n #keeping this for now, since we don't know when it might be preferable.\n # The following lines are more 'chemical'\n for molType in System._sys._molecules:\n printname = molType\n printname = printname.replace(' ','_')\n printname = printname.replace('\"','') \n lines.append('%-15s%8d\\n'\n % (printname,\n len(System._sys._molecules[molType].moleculeSet)))\n\n fout = open(filename, 'w')\n for line in lines:\n fout.write(line)\n fout.close()\n\n", "meta": {"hexsha": "d802e6711a77b87f796134103579e9c0aed41c09", "size": 87339, "ext": "py", "lang": "Python", "max_stars_repo_path": "intermol/gromacs_extension/gromacs_topology_parser.py", "max_stars_repo_name": "jpthompson17/InterMol", "max_stars_repo_head_hexsha": "9289ea770bc2d069482bf5fa74dceea4c14d0e4b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "intermol/gromacs_extension/gromacs_topology_parser.py", "max_issues_repo_name": "jpthompson17/InterMol", "max_issues_repo_head_hexsha": "9289ea770bc2d069482bf5fa74dceea4c14d0e4b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "intermol/gromacs_extension/gromacs_topology_parser.py", "max_forks_repo_name": "jpthompson17/InterMol", "max_forks_repo_head_hexsha": "9289ea770bc2d069482bf5fa74dceea4c14d0e4b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 52.0494636472, "max_line_length": 139, "alphanum_fraction": 0.4116145136, "include": true, "reason": "import numpy", "num_tokens": 16497, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5195213368305399, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.19997007186460308}} {"text": "# functions to run velocyto and scvelo\nimport numpy as np\nimport pandas as pd\n\n# import velocyto as vcy\n# import scvelo as scv\nfrom scipy.sparse import csr_matrix\nimport matplotlib.pyplot as plt\nfrom .moments import *\nfrom anndata import AnnData\n\n\ndef vlm_to_adata(vlm, n_comps=30, basis=\"umap\", trans_mats=None, cells_ixs=None):\n \"\"\" Conversion function from the velocyto world to the dynamo world.\n Code original from scSLAM-seq repository\n\n Parameters\n ----------\n vlm: VelocytoLoom Object\n The VelocytoLoom object that will be converted into adata.\n n_comps: `int` (default: 30)\n The number of pc components that will be stored.\n basis: `str` (default: `umap`)\n The embedding that will be used to store the vlm.ts attribute. Note that velocyto doesn't usually use\n umap as embedding although `umap` as set as default for the convenience of dynamo itself.\n trans_mats: None or dict\n A dict of all relevant transition matrices\n cell_ixs: list of int\n These are the indices of the subsampled cells\n\n Returns\n -------\n adata: AnnData object\n\t\"\"\"\n\n from collections import OrderedDict\n\n # set obs, var\n obs, var = pd.DataFrame(vlm.ca), pd.DataFrame(vlm.ra)\n if \"CellID\" in obs.keys():\n obs[\"obs_names\"] = obs.pop(\"CellID\")\n if \"Gene\" in var.keys():\n var[\"var_names\"] = var.pop(\"Gene\")\n\n if hasattr(vlm, \"q\"):\n var[\"gamma_b\"] = vlm.q\n if hasattr(vlm, \"gammas\"):\n var[\"gamma\"] = vlm.gammas\n if hasattr(vlm, \"R2\"):\n var[\"gamma_r2\"] = vlm.R2\n\n # rename clusters to louvain\n try:\n ix = np.where(obs.columns == \"Clusters\")[0][0]\n obs_names = list(obs.columns)\n obs_names[ix] = \"louvain\"\n obs.columns = obs_names\n\n # make louvain a categorical field\n obs[\"louvain\"] = pd.Categorical(obs[\"louvain\"])\n except:\n print(\"Could not find a filed 'Clusters' in vlm.ca.\")\n\n # set layers basics\n layers = OrderedDict(\n unspliced=csr_matrix(vlm.U.T),\n spliced=csr_matrix(vlm.S.T),\n velocity_S=csr_matrix(vlm.velocity.T),\n )\n\n # set X_spliced / X_unspliced\n if hasattr(vlm, \"S_norm\"):\n layers[\"X_spliced\"] = csr_matrix(2**vlm.S_norm - 1).T\n if hasattr(vlm, \"U_norm\"):\n layers[\"X_unspliced\"] = csr_matrix(2**vlm.U_norm - 1).T\n if hasattr(vlm, \"S_sz\") and not hasattr(vlm, \"S_norm\"):\n layers[\"X_spliced\"] = csr_matrix(vlm.S_sz).T\n if hasattr(vlm, \"U_sz\") and hasattr(vlm, \"U_norm\"):\n layers[\"X_unspliced\"] = csr_matrix(vlm.U_sz).T\n\n # set M_s / M_u\n if hasattr(vlm, \"Sx\"):\n layers[\"M_s\"] = csr_matrix(vlm.Sx).T\n if hasattr(vlm, \"Ux\"):\n layers[\"M_u\"] = csr_matrix(vlm.Ux).T\n if hasattr(vlm, \"Sx_sz\") and not hasattr(vlm, \"Sx\"):\n layers[\"M_s\"] = csr_matrix(vlm.Sx_sz).T\n if hasattr(vlm, \"Ux_sz\") and hasattr(vlm, \"Ux\"):\n layers[\"M_u\"] = csr_matrix(vlm.Ux_sz).T\n\n # set obsm\n obsm = {}\n obsm[\"X\"] = vlm.pcs[:, : min(n_comps, vlm.pcs.shape[1])]\n # set basis and velocity on the basis\n if basis is not None:\n obsm[\"X_\" + basis] = vlm.ts\n obsm[\"velocity_\" + basis] = vlm.delta_embedding\n\n # set transition matrix:\n uns = {}\n if hasattr(vlm, \"corrcoef\"):\n uns[\"transition_matrix\"] = vlm.corrcoef\n if hasattr(vlm, \"colorandum\"):\n uns[\"louvain_colors\"] = list(np.unique(vlm.colorandum))\n\n # add uns annotations\n if trans_mats is not None:\n for key, value in trans_mats.items():\n uns[key] = trans_mats[key]\n if cells_ixs is not None:\n uns[\"cell_ixs\"] = cells_ixs\n if hasattr(vlm, \"embedding_knn\"):\n from .connectivity import adj_to_knn\n\n n_neighbors = np.unique((vlm.embedding_knn > 0).sum(1)).min()\n ind_mat, dist_mat = adj_to_knn(\n vlm.emedding_knn, n_neighbors\n )\n uns[\"neighbors\"] = {\"indices\": ind_mat}\n obsp = {'distances': dist_mat, \"connectivities\": vlm.emedding_knn}\n\n uns[\"dynamics\"] = {\n \"filter_gene_mode\": None,\n \"t\": None,\n \"group\": None,\n \"X_data\": None,\n \"X_fit_data\": None,\n \"asspt_mRNA\": \"ss\",\n \"experiment_type\": \"conventional\",\n \"normalized\": True,\n \"model\": \"deterministic\",\n \"est_method\": \"ols\",\n \"has_splicing\": True,\n \"has_labeling\": False,\n \"has_protein\": False,\n \"use_smoothed\": True,\n \"NTR_vel\": False,\n \"log_unnormalized\": True,\n }\n\n # set X\n if hasattr(vlm, \"S_norm\"):\n X = csr_matrix(vlm.S_norm.T)\n else:\n X = csr_matrix(vlm.S_sz.T) if hasattr(vlm, \"S_sz\") else csr_matrix(vlm.S.T)\n\n # create an anndata object with Dynamo characteristics.\n dyn_adata = AnnData(X=X, obs=obs, obsp=obsp, obsm=obsm, var=var, layers=layers, uns=uns)\n\n return dyn_adata\n\n\ndef converter(data_in, from_type=\"adata\", to_type=\"vlm\", dir=\".\"):\n \"\"\"\n\tconvert adata to loom object\n\t- we may save_fig to a temp directory automatically\n\t- we may write a on-the-fly converter which doesn't involve saving and reading files \n\t\"\"\"\n if from_type == \"adata\":\n if to_type == \"vlm\":\n file = dir + \"/data.loom\"\n data_in.write_loom(file)\n data_out = vcy.VelocytoLoom(file)\n elif from_type == \"vlm\":\n if to_type == \"adata\":\n data_out = vlm_to_adata(vlm)\n\n data_out.ra[\"Gene\"] = data_out.ra[\"var_names\"] # required by plot_phase_portraits\n colors20 = np.vstack(\n (\n plt.cm.tab20b(np.linspace(0.0, 1, 20))[::2],\n plt.cm.tab20c(np.linspace(0, 1, 20))[1::2],\n )\n )\n\n def colormap_fun(x: np.ndarray) -> np.ndarray:\n return colors20[np.mod(x, 20)]\n\n data_out.colorandum = colormap_fun([1] * data_out.S.shape[1])\n\n return data_out\n\n\ndef run_velocyto(adata):\n \"\"\"\n\t1. convert adata to vlm data\n\t2. set up PCA, UMAP, etc.\n\t3. estimate the gamma parameter\n\t\"\"\"\n vlm = converter(adata)\n\n # U_norm: log2(U_sz + pcount)\n # vlm.U_sz: norm_factor * U\n # S_norm: log2(S_sz + pcount)\n # vlm.S_sz norm_factor * S\n # vlm.Ux: smoothed unspliced\n # vlm.Sx: smoothed spliced\n # vlm.Ux_sz: smoothed unspliced -- old code\n # vlm.Sx_sz: smoothed spliced -- old code\n\n vlm.normalize() # add U_norm, U_sz, S_norm, S_sz\n vlm.perform_PCA()\n vlm.knn_imputation() # Ux, Sx, Ux_sz, Sx_sz\n vlm.pcs = adata.X # pcs: cell x npcs ndarray\n\n # vlm.Sx = vlm.S_sz\n # vlm.Ux = vlm.U_sz\n # vlm.Sx_sz = vlm.S_sz\n # vlm.Ux_sz = vlm.U_sz\n\n # gamma fit\n vlm.fit_gammas() # limit_gamma = False, fit_offset = True, use_imputed_data = False, use_size_norm = False\n\n # estimate velocity\n vlm.predict_U()\n vlm.calculate_velocity()\n\n # predict future state after dt\n vlm.calculate_shift() # assumption = 'constant_velocity'\n vlm.extrapolate_cell_at_t() # delta_t = 1.\n\n return vlm\n\n\ndef run_scvelo(adata):\n \"\"\"\n\t1. set up PCA, UMAP, etc. \n\t2. estimate gamma and all other parameters \n\t3. return results (adata.var['velocity_gamma'])\n\t\"\"\"\n # scv.pp.filter_and_normalize(adata, min_counts=2, min_counts_u=1, n_top_genes=3000)\n scv.pp.moments(adata) # , n_pcs = 12, n_neighbors = 15, mode = 'distances'\n scv.tl.velocity(adata)\n scv.tl.velocity_graph(adata)\n\n # how to fit other parameters, beta, etc.?\n\n return adata\n\n\ndef mean_var_by_time(X, Time):\n import pandas as pd\n\n exp_data = pd.DataFrame(X)\n exp_data[\"Time\"] = Time\n\n mean_val = exp_data.groupby([\"Time\"]).mean()\n var_val = exp_data.groupby([\"Time\"]).var()\n\n return mean_val.values, var_val.values\n\n\ndef run_dynamo(adata, normalize=True, init_num=1, sample_method=\"lhs\"):\n time = adata.obs[\"Step\"].values\n uniqe_time = list(set(time))\n gene_num = adata.X.shape[1]\n\n # prepare data\n import numpy as np\n\n x_data = np.zeros((8, len(uniqe_time), gene_num)) # use unique time\n uu, ul, su, sl = (\n adata.layers[\"uu\"].toarray(),\n adata.layers[\"ul\"].toarray(),\n adata.layers[\"su\"].toarray(),\n adata.layers[\"sl\"].toarray(),\n )\n uu = np.log2(uu + 1) if normalize else uu\n ul = np.log2(ul + 1) if normalize else ul\n su = np.log2(su + 1) if normalize else su\n sl = np.log2(sl + 1) if normalize else sl\n\n x_data[0], x_data[4] = mean_var_by_time(uu, time)\n x_data[1], x_data[5] = mean_var_by_time(ul, time)\n x_data[2], x_data[6] = mean_var_by_time(su, time)\n x_data[3], x_data[7] = mean_var_by_time(sl, time)\n\n # estimation all parameters\n p0_range = {\n \"a\": [0, 1],\n \"b\": [0, 1],\n \"la\": [0, 1],\n \"alpha_a\": [10, 1000],\n \"alpha_i\": [0, 10],\n \"sigma\": [0, 1],\n \"beta\": [0, 10],\n \"gamma\": [0, 10],\n }\n\n estm = estimation(list(p0_range.values()))\n param_out = pd.DataFrame(\n index=adata.var.index,\n columns=[\"a\", \"b\", \"la\", \"alpha_a\", \"alpha_i\", \"sigma\", \"beta\", \"gamma\"],\n )\n for i in range(gene_num):\n cur_x_data = x_data[:, :, i].squeeze()\n param_out.iloc[i, :], cost = estm.fit_lsq(\n uniqe_time, cur_x_data, p0=None, n_p0=init_num, sample_method=sample_method\n )\n\n # estimate only on the spliced and unspliced dataset\n\n # estimate on the labeled and unlabeled dataset\n\n # store the fitting result in adata.uns\n adata.uns.update({\"dynamo\": param_out})\n\n return adata\n\n\ndef run_dynamo_simple_fit(adata, log=True):\n ncells, gene_num = adata.X.shape\n\n # estimation all parameters\n param_out = pd.DataFrame(index=adata.var.index, columns=[\"alpha\", \"gamma\"])\n\n u, s = adata.layers[\"unspliced\"], adata.layers[\"spliced\"]\n velocity_u, velocity_s = u, s\n for i in range(gene_num):\n cur_u, cur_s = u[:, i], s[:, i]\n gamma = fit_gamma(cur_u.toarray().squeeze(), cur_s.toarray().squeeze())\n alpha = np.mean(cur_s)\n\n velocity_u[:, i] = cur_u - cur_s * gamma\n velocity_s[:, i] = cur_s / (1 - np.exp(-1)) - cur_u\n param_out.iloc[i, :] = [alpha, gamma]\n\n adata.layers[\"velocity_u\"] = velocity_u\n adata.layers[\"velocity_s\"] = velocity_s\n adata.uns.update({\"dynamo_simple_fit\": param_out})\n\n return adata\n\n\ndef run_dynamo_labelling(adata, log=True, group=False):\n ncells, gene_num = adata.X.shape\n\n # estimation all parameters\n T = adata.obs[\"Time\"]\n\n groups = [\"\"] if group == False else np.unique(adata.obs[group])\n\n param_out = pd.DataFrame(\n index=adata.var.index,\n columns=[i + \"_\" + j for j in groups for i in [\"alpha\", \"gamma\", \"u0\", \"l0\"]],\n )\n L, U = adata.layers[\"L\"], adata.layers[\"U\"]\n velocity_u, velocity_s = L, U\n\n for i in range(gene_num):\n all_parm = []\n for cur_grp in groups.tolist():\n cur_L, cur_U = (\n (L[:, i], U[:, i])\n if cur_grp == \"\"\n else (\n L[adata.obs[group] == cur_grp, i],\n U[adata.obs[group] == cur_grp, i],\n )\n )\n if log:\n cur_U, cur_L = (\n np.log(cur_U.toarray().squeeze() + 1),\n np.log(cur_L.toarray().squeeze() + 1),\n )\n else:\n cur_U, cur_L = cur_U.toarray().squeeze(), cur_L.toarray().squeeze()\n\n gamma, l0 = fit_gamma_labelling(T, cur_L, mode=None)\n alpha, u0 = fit_alpha_labelling(T, cur_U, gamma, mode=None)\n tmp = [alpha, gamma, u0, l0]\n all_parm.extend(tmp)\n\n velocity_u[:, i] = (cur_L - cur_U * gamma)[:, None]\n velocity_s[:, i] = (cur_U / (1 - np.exp(-1)) - cur_L)[:, None]\n adata.layers[cur_grp + \"velocity_u\"] = velocity_u\n adata.layers[cur_grp + \"velocity_s\"] = velocity_s\n\n param_out.iloc[i, :] = all_parm\n\n adata.uns.update({\"dynamo_labelling\": param_out})\n\n return adata\n\n\ndef compare_res(\n adata,\n velocyto_res,\n svelo_res,\n dynamo_res,\n a_val,\n b_val,\n la_val,\n alpha_a_val,\n alpha_i_val,\n sigma_val,\n beta_val,\n gamma_val,\n):\n \"\"\"\n\tfunction to compare results from velocyto and scvelo with our new method\n\t0. retrieve gamm or gamma with other parameters from velocyto result or scvelo\n\t1. plot the correlation between parameters estimated with different methods\n\t2. calculate the correltion between those parameters\n\t\"\"\"\n # self._offset, self._offset2, self._beta, self._gamma, self._r2, self._velocity_genes\n\n velocyto_gammas = velocyto_res.gammas\n scvelo_gammas = svelo_res.var[\"velocity_gamma\"]\n\n # scatter plot the true gammas with our result\n plt.subplots(figsize=(15, 5))\n plt.plot()\n plt.subplot(131)\n plt.plot(gamma_val, velocyto_gammas, \"o\")\n plt.xlabel(r\"True $\\gamma$\")\n plt.ylabel(r\"$\\gamma$ (velocyto)\")\n plt.subplot(132)\n plt.plot(gamma_val, scvelo_gammas, \"o\")\n plt.xlabel(r\"True $\\gamma$\")\n plt.ylabel(r\"$\\gamma$ (scvelo)\")\n plt.subplot(133)\n plt.plot(gamma_val, dynamo_res.uns[\"dynamo\"][\"gamma\"], \"o\")\n plt.xlabel(r\"True $\\gamma$\")\n plt.ylabel(r\"$\\gamma$ (dynamo)\")\n\n # what if we only have a small number of parameters?\n plt.subplots(figsize=(15, 5))\n plt.plot()\n plt.subplot(131)\n plt.plot(alpha_a_val, svelo_res.var[\"fit_alpha\"], \"o\")\n plt.xlabel(r\"True alpha\")\n plt.ylabel(r\"$\\alpha$ (scvelo)\")\n plt.subplot(132)\n plt.plot(beta_val, svelo_res.var[\"fit_beta\"], \"o\")\n plt.xlabel(r\"True $\\beta$\")\n plt.ylabel(r\"$\\beta$ (scvelo)\")\n plt.subplot(133)\n plt.plot(gamma_val, svelo_res.var[\"fit_gamma\"], \"o\")\n plt.xlabel(r\"True $\\gamma$\")\n plt.ylabel(r\"$\\gamma$ (scvelo)\")\n\n # param_out = pd.DataFrame(index=adata.var.index, columns=['a', 'b', 'la', 'alpha_a', 'alpha_i', 'sigma', 'beta', 'gamma'])\n # what if we only have a small number of parameters?\n plt.subplots(figsize=(15, 15))\n plt.subplot(331)\n plt.plot(a_val, adata.uns[\"dynamo\"][\"a\"], \"o\")\n plt.xlabel(r\"True $a$\")\n plt.ylabel(r\"$a$ (dynamo)\")\n plt.subplot(332)\n plt.plot(b_val, adata.uns[\"dynamo\"][\"b\"], \"o\")\n plt.xlabel(r\"True $b$\")\n plt.ylabel(r\"$b$ (dynamo)\")\n plt.subplot(333)\n plt.plot(la_val, adata.uns[\"dynamo\"][\"la\"], \"o\")\n plt.xlabel(r\"True $l_a$\")\n plt.ylabel(r\"$l_a$ (dynamo)\")\n plt.subplot(334)\n plt.plot(alpha_a_val, adata.uns[\"dynamo\"][\"alpha_a\"], \"o\")\n plt.xlabel(r\"True $\\alpha_a$\")\n plt.ylabel(r\"$\\alpha_a$ (dynamo)\")\n plt.subplot(335)\n plt.plot(alpha_i_val, adata.uns[\"dynamo\"][\"alpha_i\"], \"o\")\n plt.xlabel(r\"True $\\alpha_i$\")\n plt.ylabel(r\"$\\alpha_i$ (dynamo)\")\n plt.subplot(336)\n plt.plot(sigma_val, adata.uns[\"dynamo\"][\"sigma\"], \"o\")\n plt.xlabel(r\"True $\\sigma$\")\n plt.ylabel(r\"$\\sigma$ (dynamo)\")\n plt.subplot(337)\n plt.plot(beta_val, adata.uns[\"dynamo\"][\"beta\"], \"o\")\n plt.xlabel(r\"True $\\beta$\")\n plt.ylabel(r\"$\\beta$ (dynamo)\")\n plt.subplot(338)\n plt.plot(gamma_val, adata.uns[\"dynamo\"][\"gamma\"], \"o\")\n plt.xlabel(r\"True $\\gamma$\")\n plt.ylabel(r\"$\\gamma$ (dynamo)\")\n\n velocyto_coef = {\"gamma\": np.corrcoef(gamma_val, velocyto_gammas)[1, 0]}\n scvelo_coef = {\n \"alpha\": np.corrcoef(alpha_a_val, svelo_res.var[\"fit_alpha\"])[1, 0],\n \"beta\": np.corrcoef(beta_val, svelo_res.var[\"fit_beta\"])[1, 0],\n \"gamma\": np.corrcoef(gamma_val, svelo_res.var[\"fit_gamma\"])[1, 0],\n }\n\n dynamo_coef = {\n \"a\": np.corrcoef(a_val, list(dynamo_res.uns[\"dynamo\"][\"a\"]))[1, 0],\n \"b\": np.corrcoef(b_val, list(dynamo_res.uns[\"dynamo\"][\"b\"]))[1, 0],\n \"la\": np.corrcoef(la_val, list(dynamo_res.uns[\"dynamo\"][\"la\"]))[1, 0],\n \"alpha_a\": np.corrcoef(alpha_a_val, list(dynamo_res.uns[\"dynamo\"][\"alpha_a\"]))[\n 1, 0\n ],\n \"alpha_i\": np.corrcoef(alpha_i_val, list(dynamo_res.uns[\"dynamo\"][\"alpha_i\"]))[\n 1, 0\n ],\n \"sigma\": np.corrcoef(sigma_val, list(dynamo_res.uns[\"dynamo\"][\"sigma\"]))[1, 0],\n \"beta\": np.corrcoef(beta_val, list(dynamo_res.uns[\"dynamo\"][\"beta\"]))[1, 0],\n \"gamma\": np.corrcoef(gamma_val, list(dynamo_res.uns[\"dynamo\"][\"gamma\"]))[1, 0],\n }\n\n return {\n \"velocyto\": pd.DataFrame.from_dict(velocyto_coef, orient=\"index\").T,\n \"scvelo\": pd.DataFrame.from_dict(scvelo_coef, orient=\"index\").T,\n \"dynamo\": pd.DataFrame.from_dict(dynamo_coef, orient=\"index\").T,\n }\n", "meta": {"hexsha": "e80d69c83c74d94605fc2b90ef58d43683719f17", "size": 16396, "ext": "py", "lang": "Python", "max_stars_repo_path": "dynamo/tools/velocyto_scvelo.py", "max_stars_repo_name": "davisidarta/dynamo-release", "max_stars_repo_head_hexsha": "0dbd769f52ea07f3cdaa8fb31022ceb89938c382", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "dynamo/tools/velocyto_scvelo.py", "max_issues_repo_name": "davisidarta/dynamo-release", "max_issues_repo_head_hexsha": "0dbd769f52ea07f3cdaa8fb31022ceb89938c382", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "dynamo/tools/velocyto_scvelo.py", "max_forks_repo_name": "davisidarta/dynamo-release", "max_forks_repo_head_hexsha": "0dbd769f52ea07f3cdaa8fb31022ceb89938c382", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.4031620553, "max_line_length": 131, "alphanum_fraction": 0.5996584533, "include": true, "reason": "import numpy,from scipy", "num_tokens": 4900, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.519521321952093, "lm_q2_score": 0.38491214448393357, "lm_q1q2_score": 0.19997006613770818}} {"text": "__author__ = ['sibirrer', 'ajshajib', 'dgilman']\n\nimport time\n\nimport numpy as np\nfrom lenstronomy.Sampling.Samplers.pso import ParticleSwarmOptimizer\nfrom lenstronomy.Util import sampling_util\nimport emcee\nimport schwimmbad\nfrom scipy.optimize import minimize\n\n\ndef choose_pool(mpi=False, processes=1, **kwargs):\n \"\"\"\n Extends the capabilities of the schwimmbad.choose_pool method.\n \n It handles the `use_dill` parameters in kwargs, that would otherwise raise an error when processes > 1.\n Any thread in the returned multiprocessing pool (e.g. processes > 1) also default\n \n\n Docstring from schwimmbad:\n\n mpi : bool, optional\n Use the MPI processing pool, :class:`~schwimmbad.mpi.MPIPool`. By\n default, ``False``, will use the :class:`~schwimmbad.serial.SerialPool`.\n processes : int, optional\n Use the multiprocessing pool,\n :class:`~schwimmbad.multiprocessing.MultiPool`, with this number of\n processes. By default, ``processes=1``, will use the\n :class:`~schwimmbad.serial.SerialPool`.\n **kwargs\n Any additional kwargs are passed in to the pool class initializer selected by the arguments.\n \"\"\"\n if processes == 1 or mpi:\n pool = schwimmbad.choose_pool(mpi=mpi, processes=1, **kwargs)\n is_master = pool.is_master()\n else:\n if 'use_dill' in kwargs:\n # schwimmbad MultiPool does not support dill so we remove this option from the kwargs\n _ = kwargs.pop('use_dill')\n pool = schwimmbad.choose_pool(mpi=False, processes=processes, **kwargs)\n # this MultiPool has no is_master() attribute like the SerialPool and MpiPool\n # all threads will then be 'master'.\n is_master = True\n return pool, is_master\n\n\nclass Sampler(object):\n \"\"\"\n class which executes the different sampling methods\n Available are: MCMC with emcee and comsoHammer and a Particle Swarm Optimizer.\n This are examples and depending on your problem, you might find other/better solutions.\n Feel free to sample with your convenient sampler!\n\n \"\"\"\n def __init__(self, likelihoodModule):\n \"\"\"\n\n :param likelihoodModule: instance of LikelihoodModule class\n \"\"\"\n self.chain = likelihoodModule\n self.lower_limit, self.upper_limit = self.chain.param_limits\n\n def simplex(self, init_pos, n_iterations, method, print_key='SIMPLEX'):\n \"\"\"\n\n :param init_pos: starting point for the optimization\n :param n_iterations: maximum number of iterations\n :param method: the optimization method, default is 'Nelder-Mead'\n :return: the best fit for the lens model using the optimization routine specified by method\n \"\"\"\n print('Performing the optimization using algorithm:', method)\n time_start = time.time()\n\n #negativelogL = lambda x: -1 * self.chain.logL(x)\n\n result = minimize(self.chain.negativelogL, x0=init_pos, method=method,\n options={'maxiter': n_iterations, 'disp': True})\n logL = self.chain.logL(result['x'])\n kwargs_return = self.chain.param.args2kwargs(result['x'])\n print(-logL * 2 / (max(self.chain.effective_num_data_points(**kwargs_return), 1)),\n 'reduced X^2 of best position')\n print(logL, 'logL')\n print(self.chain.effective_num_data_points(**kwargs_return), 'effective number of data points')\n print(kwargs_return.get('kwargs_lens', None), 'lens result')\n print(kwargs_return.get('kwargs_source', None), 'source result')\n print(kwargs_return.get('kwargs_lens_light', None), 'lens light result')\n print(kwargs_return.get('kwargs_ps', None), 'point source result')\n print(kwargs_return.get('kwargs_special', None), 'special param result')\n time_end = time.time()\n print(time_end - time_start, 'time used for ', print_key)\n print('===================')\n\n return result['x']\n\n def pso(self, n_particles, n_iterations, lower_start=None, upper_start=None,\n threadCount=1, init_pos=None, mpi=False, print_key='PSO'):\n \"\"\"\n Return the best fit for the lens model on catalogue basis with\n particle swarm optimizer.\n\n :param n_particles: number of particles in the sampling process\n :param n_iterations: number of iterations of the swarm\n :param lower_start: numpy array, lower end parameter of the values of the starting particles\n :param upper_start: numpy array, upper end parameter of the values of the starting particles\n :param threadCount: number of threads in the computation (only applied if mpi=False)\n :param init_pos: numpy array, position of the initial best guess model\n :param mpi: bool, if True, makes instance of MPIPool to allow for MPI execution\n :param print_key: string, prints the process name in the progress bar (optional)\n :return: kwargs_result (of best fit), [lnlikelihood of samples, positions of samples, velocity of sampels)\n \"\"\"\n if lower_start is None or upper_start is None:\n lower_start, upper_start = np.array(self.lower_limit), np.array(self.upper_limit)\n print(\"PSO initialises its particles with default values\")\n else:\n lower_start = np.maximum(lower_start, self.lower_limit)\n upper_start = np.minimum(upper_start, self.upper_limit)\n\n pool, is_master = choose_pool(mpi=mpi, processes=threadCount, use_dill=True)\n \n if mpi is True and is_master:\n print('MPI option chosen for PSO.')\n\n pso = ParticleSwarmOptimizer(self.chain.logL,\n lower_start, upper_start, n_particles,\n pool=pool)\n\n if init_pos is None:\n init_pos = (upper_start - lower_start) / 2 + lower_start\n\n pso.set_global_best(init_pos, [0]*len(init_pos),\n self.chain.logL(init_pos))\n\n if is_master:\n print('Computing the %s ...' % print_key)\n\n time_start = time.time()\n\n result, [chi2_list, pos_list, vel_list] = pso.optimize(n_iterations)\n\n if is_master:\n kwargs_return = self.chain.param.args2kwargs(result)\n print(pso.global_best.fitness * 2 / (max(\n self.chain.effective_num_data_points(**kwargs_return), 1)), 'reduced X^2 of best position')\n print(pso.global_best.fitness, 'logL')\n print(self.chain.effective_num_data_points(**kwargs_return), 'effective number of data points')\n print(kwargs_return.get('kwargs_lens', None), 'lens result')\n print(kwargs_return.get('kwargs_source', None), 'source result')\n print(kwargs_return.get('kwargs_lens_light', None), 'lens light result')\n print(kwargs_return.get('kwargs_ps', None), 'point source result')\n print(kwargs_return.get('kwargs_special', None), 'special param result')\n time_end = time.time()\n print(time_end - time_start, 'time used for ', print_key)\n print('===================')\n return result, [chi2_list, pos_list, vel_list]\n\n def mcmc_emcee(self, n_walkers, n_run, n_burn, mean_start, sigma_start, mpi=False, progress=False, threadCount=1):\n \"\"\"\n Run MCMC with emcee.\n For details, please have a look at the documentation of the emcee packager.\n\n :param n_walkers: number of walkers in the emcee process\n :type n_walkers: integer\n :param n_run: number of sampling (after burn-in) of the emcee\n :type n_run: integer\n :param n_burn: number of burn-in iterations (those will not be saved in the output sample)\n :type n_burn: integer\n :param mean_start: mean of the parameter position of the initialising sample\n :type mean_start: numpy array of length the number of parameters\n :param sigma_start: spread of the parameter values (uncorrelated in each dimension) of the initialising sample\n :type sigma_start: numpy array of length the number of parameters\n :param mpi: if True, initializes an MPIPool to allow for MPI execution of the sampler\n :type mpi: bool\n :param progress: if True, prints the progress bar\n :type progress: bool\n :param threadCount: number of threats in multi-processing (not applicable for MPI)\n :type threadCount: integer\n :return: samples, ln likelihood value of samples\n :rtype: numpy 2d array, numpy 1d array\n \"\"\"\n num_param, _ = self.chain.param.num_param()\n p0 = sampling_util.sample_ball(mean_start, sigma_start, n_walkers)\n time_start = time.time()\n\n pool, is_master = choose_pool(mpi=mpi, processes=threadCount, use_dill=True)\n\n sampler = emcee.EnsembleSampler(n_walkers, num_param, self.chain.logL,\n pool=pool)\n\n sampler.run_mcmc(p0, n_burn + n_run, progress=progress)\n flat_samples = sampler.get_chain(discard=n_burn, thin=1, flat=True)\n dist = sampler.get_log_prob(flat=True, discard=n_burn, thin=1)\n if is_master:\n print('Computing the MCMC...')\n print('Number of walkers = ', n_walkers)\n print('Burn-in iterations: ', n_burn)\n print('Sampling iterations:', n_run)\n time_end = time.time()\n print(time_end - time_start, 'time taken for MCMC sampling')\n return flat_samples, dist\n", "meta": {"hexsha": "2aff7883bead0a96d3419b7d8eac9391927dd127", "size": 9508, "ext": "py", "lang": "Python", "max_stars_repo_path": "lenstronomy/Sampling/sampler.py", "max_stars_repo_name": "Thomas-01/lenstronomy", "max_stars_repo_head_hexsha": "36db4c7f43ba28d6bdecdab1f15c537043f4a286", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lenstronomy/Sampling/sampler.py", "max_issues_repo_name": "Thomas-01/lenstronomy", "max_issues_repo_head_hexsha": "36db4c7f43ba28d6bdecdab1f15c537043f4a286", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lenstronomy/Sampling/sampler.py", "max_forks_repo_name": "Thomas-01/lenstronomy", "max_forks_repo_head_hexsha": "36db4c7f43ba28d6bdecdab1f15c537043f4a286", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 47.3034825871, "max_line_length": 118, "alphanum_fraction": 0.6567101388, "include": true, "reason": "import numpy,from scipy", "num_tokens": 2152, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.519521321952093, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.19997006613770815}} {"text": "# This program is free software: you can redistribute it and/or modify\n# it under the terms of the GNU General Public License as published by\n# the Free Software Foundation, either version 3 of the License, or\n# (at your option) any later version.\n#\n# This program is distributed in the hope that it will be useful,\n# but WITHOUT ANY WARRANTY; without even the implied warranty of\n# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n# GNU General Public License for more details.\n#\n# You should have received a copy of the GNU General Public License\n# along with this program. If not, see .\n\n# This module was adapted from Scikit-Survival python package to\n# extract the adjusted TPR and FPR rates for all classification\n# thresholds for the censoring adjusted ROC curve. It depends on\n# Scikit-Survival. For the full package please check: \n# https://github.com/sebp/scikit-survival\n\nimport numpy\nfrom scipy.integrate import trapz\nfrom sklearn.utils import check_consistent_length, check_array\n\nfrom sksurv.nonparametric import CensoringDistributionEstimator, SurvivalFunctionEstimator\nfrom sksurv.util import check_y_survival\n\n__all__ = [\n 'brier_score',\n 'concordance_index_censored',\n 'concordance_index_ipcw',\n 'cumulative_dynamic_auc',\n 'integrated_brier_score',\n]\n\n\ndef _check_estimate(estimate, test_time):\n estimate = check_array(estimate, ensure_2d=False)\n if estimate.ndim != 1:\n raise ValueError(\n 'Expected 1D array, got {:d}D array instead:\\narray={}.\\n'.format(\n estimate.ndim, estimate))\n check_consistent_length(test_time, estimate)\n return estimate\n\n\ndef _check_inputs(event_indicator, event_time, estimate):\n check_consistent_length(event_indicator, event_time, estimate)\n event_indicator = check_array(event_indicator, ensure_2d=False)\n event_time = check_array(event_time, ensure_2d=False)\n estimate = _check_estimate(estimate, event_time)\n\n if not numpy.issubdtype(event_indicator.dtype, numpy.bool_):\n raise ValueError(\n 'only boolean arrays are supported as class labels for survival analysis, got {0}'.format(\n event_indicator.dtype))\n\n if len(event_time) < 2:\n raise ValueError(\"Need a minimum of two samples\")\n\n if not event_indicator.any():\n raise ValueError(\"All samples are censored\")\n\n return event_indicator, event_time, estimate\n\n\ndef _check_times(test_time, times):\n times = check_array(numpy.atleast_1d(times), ensure_2d=False, dtype=test_time.dtype)\n times = numpy.unique(times)\n\n if times.max() >= test_time.max() or times.min() < test_time.min():\n raise ValueError(\n 'all times must be within follow-up time of test data: [{}; {}['.format(\n test_time.min(), test_time.max()))\n\n return times\n\n\ndef _get_comparable(event_indicator, event_time, order):\n n_samples = len(event_time)\n tied_time = 0\n comparable = {}\n i = 0\n while i < n_samples - 1:\n time_i = event_time[order[i]]\n start = i + 1\n end = start\n while end < n_samples and event_time[order[end]] == time_i:\n end += 1\n\n # check for tied event times\n event_at_same_time = event_indicator[order[i:end]]\n censored_at_same_time = ~event_at_same_time\n for j in range(i, end):\n if event_indicator[order[j]]:\n mask = numpy.zeros(n_samples, dtype=bool)\n mask[end:] = True\n # an event is comparable to censored samples at same time point\n mask[i:end] = censored_at_same_time\n comparable[j] = mask\n tied_time += censored_at_same_time.sum()\n i = end\n\n return comparable, tied_time\n\n\ndef _estimate_concordance_index(event_indicator, event_time, estimate, weights, tied_tol=1e-8):\n order = numpy.argsort(event_time)\n\n comparable, tied_time = _get_comparable(event_indicator, event_time, order)\n\n concordant = 0\n discordant = 0\n tied_risk = 0\n numerator = 0.0\n denominator = 0.0\n for ind, mask in comparable.items():\n est_i = estimate[order[ind]]\n event_i = event_indicator[order[ind]]\n w_i = weights[order[ind]]\n\n est = estimate[order[mask]]\n\n assert event_i, 'got censored sample at index %d, but expected uncensored' % order[ind]\n\n ties = numpy.absolute(est - est_i) <= tied_tol\n n_ties = ties.sum()\n # an event should have a higher score\n con = est < est_i\n n_con = con[~ties].sum()\n\n numerator += w_i * n_con + 0.5 * w_i * n_ties\n denominator += w_i * mask.sum()\n\n tied_risk += n_ties\n concordant += n_con\n discordant += est.size - n_con - n_ties\n\n cindex = numerator / denominator\n return cindex, concordant, discordant, tied_risk, tied_time\n\n\ndef concordance_index_censored(event_indicator, event_time, estimate, tied_tol=1e-8):\n \"\"\"Concordance index for right-censored data\n\n The concordance index is defined as the proportion of all comparable pairs\n in which the predictions and outcomes are concordant.\n\n Two samples are comparable if (i) both of them experienced an event (at different times),\n or (ii) the one with a shorter observed survival time experienced an event, in which case\n the event-free subject \"outlived\" the other. A pair is not comparable if they experienced\n events at the same time.\n\n Concordance intuitively means that two samples were ordered correctly by the model.\n More specifically, two samples are concordant, if the one with a higher estimated\n risk score has a shorter actual survival time.\n When predicted risks are identical for a pair, 0.5 rather than 1 is added to the count\n of concordant pairs.\n\n See [1]_ for further description.\n\n Parameters\n ----------\n event_indicator : array-like, shape = (n_samples,)\n Boolean array denotes whether an event occurred\n\n event_time : array-like, shape = (n_samples,)\n Array containing the time of an event or time of censoring\n\n estimate : array-like, shape = (n_samples,)\n Estimated risk of experiencing an event\n\n tied_tol : float, optional, default: 1e-8\n The tolerance value for considering ties.\n If the absolute difference between risk scores is smaller\n or equal than `tied_tol`, risk scores are considered tied.\n\n Returns\n -------\n cindex : float\n Concordance index\n\n concordant : int\n Number of concordant pairs\n\n discordant : int\n Number of discordant pairs\n\n tied_risk : int\n Number of pairs having tied estimated risks\n\n tied_time : int\n Number of comparable pairs sharing the same time\n\n References\n ----------\n .. [1] Harrell, F.E., Califf, R.M., Pryor, D.B., Lee, K.L., Rosati, R.A,\n \"Multivariable prognostic models: issues in developing models,\n evaluating assumptions and adequacy, and measuring and reducing errors\",\n Statistics in Medicine, 15(4), 361-87, 1996.\n \"\"\"\n event_indicator, event_time, estimate = _check_inputs(\n event_indicator, event_time, estimate)\n\n w = numpy.ones_like(estimate)\n\n return _estimate_concordance_index(event_indicator, event_time, estimate, w, tied_tol)\n\n\ndef concordance_index_ipcw(survival_train, survival_test, estimate, tau=None, tied_tol=1e-8):\n \"\"\"Concordance index for right-censored data based on inverse probability of censoring weights.\n\n This is an alternative to the estimator in :func:`concordance_index_censored`\n that does not depend on the distribution of censoring times in the test data.\n Therefore, the estimate is unbiased and consistent for a population concordance\n measure that is free of censoring.\n\n It is based on inverse probability of censoring weights, thus requires\n access to survival times from the training data to estimate the censoring\n distribution. Note that this requires that survival times `survival_test`\n lie within the range of survival times `survival_train`. This can be\n achieved by specifying the truncation time `tau`.\n The resulting `cindex` tells how well the given prediction model works in\n predicting events that occur in the time range from 0 to `tau`.\n\n The estimator uses the Kaplan-Meier estimator to estimate the\n censoring survivor function. Therefore, it is restricted to\n situations where the random censoring assumption holds and\n censoring is independent of the features.\n\n See [1]_ for further description.\n\n Parameters\n ----------\n survival_train : structured array, shape = (n_train_samples,)\n Survival times for training data to estimate the censoring\n distribution from.\n A structured array containing the binary event indicator\n as first field, and time of event or time of censoring as\n second field.\n\n survival_test : structured array, shape = (n_samples,)\n Survival times of test data.\n A structured array containing the binary event indicator\n as first field, and time of event or time of censoring as\n second field.\n\n estimate : array-like, shape = (n_samples,)\n Estimated risk of experiencing an event of test data.\n\n tau : float, optional\n Truncation time. The survival function for the underlying\n censoring time distribution :math:`D` needs to be positive\n at `tau`, i.e., `tau` should be chosen such that the\n probability of being censored after time `tau` is non-zero:\n :math:`P(D > \\\\tau) > 0`. If `None`, no truncation is performed.\n\n tied_tol : float, optional, default: 1e-8\n The tolerance value for considering ties.\n If the absolute difference between risk scores is smaller\n or equal than `tied_tol`, risk scores are considered tied.\n\n Returns\n -------\n cindex : float\n Concordance index\n\n concordant : int\n Number of concordant pairs\n\n discordant : int\n Number of discordant pairs\n\n tied_risk : int\n Number of pairs having tied estimated risks\n\n tied_time : int\n Number of comparable pairs sharing the same time\n\n References\n ----------\n .. [1] Uno, H., Cai, T., Pencina, M. J., D’Agostino, R. B., & Wei, L. J. (2011).\n \"On the C-statistics for evaluating overall adequacy of risk prediction\n procedures with censored survival data\".\n Statistics in Medicine, 30(10), 1105–1117.\n \"\"\"\n test_event, test_time = check_y_survival(survival_test)\n\n if tau is not None:\n mask = test_time < tau\n survival_test = survival_test[mask]\n\n estimate = _check_estimate(estimate, test_time)\n\n cens = CensoringDistributionEstimator()\n cens.fit(survival_train)\n ipcw_test = cens.predict_ipcw(survival_test)\n if tau is None:\n ipcw = ipcw_test\n else:\n ipcw = numpy.empty(estimate.shape[0], dtype=ipcw_test.dtype)\n ipcw[mask] = ipcw_test\n ipcw[~mask] = 0\n\n w = numpy.square(ipcw)\n\n return _estimate_concordance_index(test_event, test_time, estimate, w, tied_tol)\n\n\ndef cumulative_dynamic_auc(survival_train, survival_test, estimate, times, tied_tol=1e-8):\n \"\"\"Estimator of cumulative/dynamic AUC for right-censored time-to-event data.\n\n The receiver operating characteristic (ROC) curve and the area under the\n ROC curve (AUC) can be extended to survival data by defining\n sensitivity (true positive rate) and specificity (true negative rate)\n as time-dependent measures. *Cumulative cases* are all individuals that\n experienced an event prior to or at time :math:`t` (:math:`t_i \\\\leq t`),\n whereas *dynamic controls* are those with :math:`t_i > t`.\n The associated cumulative/dynamic AUC quantifies how well a model can\n distinguish subjects who fail by a given time (:math:`t_i \\\\leq t`) from\n subjects who fail after this time (:math:`t_i > t`).\n\n Given an estimator of the :math:`i`-th individual's risk score\n :math:`\\\\hat{f}(\\\\mathbf{x}_i)`, the cumulative/dynamic AUC at time\n :math:`t` is defined as\n\n .. math::\n\n \\\\widehat{\\\\mathrm{AUC}}(t) =\n \\\\frac{\\\\sum_{i=1}^n \\\\sum_{j=1}^n I(y_j > t) I(y_i \\\\leq t) \\\\omega_i\n I(\\\\hat{f}(\\\\mathbf{x}_j) \\\\leq \\\\hat{f}(\\\\mathbf{x}_i))}\n {(\\\\sum_{i=1}^n I(y_i > t)) (\\\\sum_{i=1}^n I(y_i \\\\leq t) \\\\omega_i)}\n\n where :math:`\\\\omega_i` are inverse probability of censoring weights (IPCW).\n\n To estimate IPCW, access to survival times from the training data is required\n to estimate the censoring distribution. Note that this requires that survival\n times `survival_test` lie within the range of survival times `survival_train`.\n This can be achieved by specifying `times` accordingly, e.g. by setting\n `times[-1]` slightly below the maximum expected follow-up time.\n IPCW are computed using the Kaplan-Meier estimator, which is\n restricted to situations where the random censoring assumption holds and\n censoring is independent of the features.\n\n The function also provides a single summary measure that refers to the mean\n of the :math:`\\\\mathrm{AUC}(t)` over the time range :math:`(\\\\tau_1, \\\\tau_2)`.\n\n .. math::\n\n \\\\overline{\\\\mathrm{AUC}}(\\\\tau_1, \\\\tau_2) =\n \\\\frac{1}{\\\\hat{S}(\\\\tau_1) - \\\\hat{S}(\\\\tau_2)}\n \\\\int_{\\\\tau_1}^{\\\\tau_2} \\\\widehat{\\\\mathrm{AUC}}(t)\\\\,d \\\\hat{S}(t)\n\n where :math:`\\\\hat{S}(t)` is the Kaplan–Meier estimator of the survival function.\n\n See [1]_, [2]_, [3]_ for further description.\n\n Parameters\n ----------\n survival_train : structured array, shape = (n_train_samples,)\n Survival times for training data to estimate the censoring\n distribution from.\n A structured array containing the binary event indicator\n as first field, and time of event or time of censoring as\n second field.\n\n survival_test : structured array, shape = (n_samples,)\n Survival times of test data.\n A structured array containing the binary event indicator\n as first field, and time of event or time of censoring as\n second field.\n\n estimate : array-like, shape = (n_samples,)\n Estimated risk of experiencing an event of test data.\n\n times : array-like, shape = (n_times,)\n The time points for which the area under the\n time-dependent ROC curve is computed. Values must be\n within the range of follow-up times of the test data\n `survival_test`.\n\n tied_tol : float, optional, default: 1e-8\n The tolerance value for considering ties.\n If the absolute difference between risk scores is smaller\n or equal than `tied_tol`, risk scores are considered tied.\n\n Returns\n -------\n auc : array, shape = (n_times,)\n The cumulative/dynamic AUC estimates (evaluated at `times`).\n mean_auc : float\n Summary measure referring to the mean cumulative/dynamic AUC\n over the specified time range `(times[0], times[-1])`.\n\n References\n ----------\n .. [1] H. Uno, T. Cai, L. Tian, and L. J. Wei,\n \"Evaluating prediction rules for t-year survivors with censored regression models,\"\n Journal of the American Statistical Association, vol. 102, pp. 527–537, 2007.\n .. [2] H. Hung and C. T. Chiang,\n \"Estimation methods for time-dependent AUC models with survival data,\"\n Canadian Journal of Statistics, vol. 38, no. 1, pp. 8–26, 2010.\n .. [3] J. Lambert and S. Chevret,\n \"Summary measure of discrimination in survival models based on cumulative/dynamic time-dependent ROC curves,\"\n Statistical Methods in Medical Research, 2014.\n \"\"\"\n \n test_event, test_time = check_y_survival(survival_test)\n \n estimate = _check_estimate(estimate, test_time)\n\n times = _check_times(test_time, times)\n\n # sort by risk score (descending)\n o = numpy.argsort(-estimate)\n test_time = test_time[o]\n test_event = test_event[o]\n estimate = estimate[o]\n survival_test = survival_test[o]\n\n cens = CensoringDistributionEstimator()\n cens.fit(survival_train)\n ipcw = cens.predict_ipcw(survival_test)\n\n n_samples = test_time.shape[0]\n scores = numpy.empty(times.shape[0], dtype=float)\n rocs = []\n \n \n for k, t in enumerate(times):\n is_case = (test_time <= t) & test_event\n is_control = test_time > t\n n_controls = is_control.sum()\n\n true_pos = []\n false_pos = []\n tp_value = 0.0\n fp_value = 0.0\n est_prev = numpy.infty\n\n for i in range(n_samples):\n est = estimate[i]\n if numpy.absolute(est - est_prev) > tied_tol:\n true_pos.append(tp_value)\n false_pos.append(fp_value)\n est_prev = est\n if is_case[i]:\n tp_value += ipcw[i]\n elif is_control[i]:\n fp_value += 1\n true_pos.append(tp_value)\n false_pos.append(fp_value)\n\n sens = numpy.array(true_pos) / ipcw[is_case].sum()\n fpr = numpy.array(false_pos) / n_controls\n scores[k] = trapz(sens, fpr)\n \n rocs.append((sens, fpr))\n \n if times.shape[0] == 1:\n mean_auc = scores[0]\n else:\n surv = SurvivalFunctionEstimator()\n surv.fit(survival_test)\n s_times = surv.predict_proba(times)\n # compute integral of AUC over survival function\n d = -numpy.diff(numpy.concatenate(([1.0], s_times)))\n integral = (scores * d).sum()\n mean_auc = integral / (1.0 - s_times[-1])\n\n return rocs, scores, mean_auc\n\n\ndef brier_score(survival_train, survival_test, estimate, times):\n \"\"\"Estimate the time-dependent Brier score for right censored data.\n\n The time-dependent Brier score is the mean squared error at time point :math:`t`:\n\n .. math::\n\n \\\\mathrm{BS}^c(t) = \\\\frac{1}{n} \\\\sum_{i=1}^n I(y_i \\\\leq t \\\\land \\\\delta_i = 1)\n \\\\frac{(0 - \\\\hat{\\\\pi}(t | \\\\mathbf{x}_i))^2}{\\\\hat{G}(y_i)} + I(y_i > t)\n \\\\frac{(1 - \\\\hat{\\\\pi}(t | \\\\mathbf{x}_i))^2}{\\\\hat{G}(t)} ,\n\n where :math:`\\\\hat{\\\\pi}(t | \\\\mathbf{x})` is the predicted probability of\n remaining event-free up to time point :math:`t` for a feature vector :math:`\\\\mathbf{x}`,\n and :math:`1/\\\\hat{G}(t)` is a inverse probability of censoring weight, estimated by\n the Kaplan-Meier estimator.\n\n See [1]_ for details.\n\n Parameters\n ----------\n survival_train : structured array, shape = (n_train_samples,)\n Survival times for training data to estimate the censoring\n distribution from.\n A structured array containing the binary event indicator\n as first field, and time of event or time of censoring as\n second field.\n\n survival_test : structured array, shape = (n_samples,)\n Survival times of test data.\n A structured array containing the binary event indicator\n as first field, and time of event or time of censoring as\n second field.\n\n estimate : array-like, shape = (n_samples, n_times)\n Estimated risk of experiencing an event for test data at `times`.\n The i-th column must contain the estimated probability of\n remaining event-free up to the i-th time point.\n\n times : array-like, shape = (n_times,)\n The time points for which to estimate the Brier score.\n Values must be within the range of follow-up times of\n the test data `survival_test`.\n\n Returns\n -------\n times : array, shape = (n_times,)\n Unique time points at which the brier scores was estimated.\n\n brier_scores : array , shape = (n_times,)\n Values of the brier score.\n\n Examples\n --------\n >>> from sksurv.datasets import load_gbsg2\n >>> from sksurv.linear_model import CoxPHSurvivalAnalysis\n >>> from sksurv.metrics import brier_score\n >>> from sksurv.preprocessing import OneHotEncoder\n\n Load and prepare data.\n\n >>> X, y = load_gbsg2()\n >>> X.loc[:, \"tgrade\"] = X.loc[:, \"tgrade\"].map(len).astype(int)\n >>> Xt = OneHotEncoder().fit_transform(X)\n\n Fit a Cox model.\n\n >>> est = CoxPHSurvivalAnalysis(ties=\"efron\").fit(Xt, y)\n\n Retrieve individual survival functions and get probability\n of remaining event free up to 5 years (=1825 days).\n\n >>> survs = est.predict_survival_function(Xt)\n >>> preds = [fn(1825) for fn in survs]\n\n Compute the Brier score at 5 years.\n\n >>> times, score = brier_score(y, y, preds, 1825)\n >>> print(score)\n [0.20881843]\n\n See also\n --------\n integrated_brier_score\n\n References\n ----------\n .. [1] E. Graf, C. Schmoor, W. Sauerbrei, and M. Schumacher,\n \"Assessment and comparison of prognostic classification schemes for survival data,\"\n Statistics in Medicine, vol. 18, no. 17-18, pp. 2529–2545, 1999.\n \"\"\"\n test_event, test_time = check_y_survival(survival_test)\n times = _check_times(test_time, times)\n\n estimate = check_array(estimate, ensure_2d=False)\n if estimate.ndim == 1 and times.shape[0] == 1:\n estimate = estimate.reshape(-1, 1)\n\n if estimate.shape[0] != test_time.shape[0]:\n raise ValueError(\"expected estimate with {} samples, but got {}\".format(\n test_time.shape[0], estimate.shape[0]\n ))\n\n if estimate.shape[1] != times.shape[0]:\n raise ValueError(\"expected estimate with {} columns, but got {}\".format(\n times.shape[0], estimate.shape[1]))\n\n # fit IPCW estimator\n cens = CensoringDistributionEstimator().fit(survival_train)\n # calculate inverse probability of censoring weight at current time point t.\n prob_cens_t = cens.predict_proba(times)\n prob_cens_t[prob_cens_t == 0] = numpy.inf\n # calculate inverse probability of censoring weights at observed time point\n prob_cens_y = cens.predict_proba(test_time)\n prob_cens_y[prob_cens_y == 0] = numpy.inf\n\n # Calculating the brier scores at each time point\n brier_scores = numpy.empty(times.shape[0], dtype=float)\n for i, t in enumerate(times):\n est = estimate[:, i]\n is_case = (test_time <= t) & test_event\n is_control = test_time > t\n\n brier_scores[i] = numpy.mean(numpy.square(est) * is_case.astype(int) / prob_cens_y\n + numpy.square(1.0 - est) * is_control.astype(int) / prob_cens_t[i])\n\n return times, brier_scores\n\n\ndef integrated_brier_score(survival_train, survival_test, estimate, times):\n \"\"\"The Integrated Brier Score (IBS) provides an overall calculation of\n the model performance at all available times :math:`t_1 \\\\leq t \\\\leq t_\\\\text{max}`.\n\n The integrated time-dependent Brier score over the interval\n :math:`[t_1; t_\\\\text{max}]` is defined as\n\n .. math::\n\n \\\\mathrm{IBS} = \\\\int_{t_1}^{t_\\\\text{max}} \\\\mathrm{BS}^c(t) d w(t)\n\n where the weighting function is :math:`w(t) = t / t_\\\\text{max}`.\n The integral is estimated via the trapezoidal rule.\n\n See [1]_ for further details.\n\n Parameters\n ----------\n survival_train : structured array, shape = (n_train_samples,)\n Survival times for training data to estimate the censoring\n distribution from.\n A structured array containing the binary event indicator\n as first field, and time of event or time of censoring as\n second field.\n\n survival_test : structured array, shape = (n_samples,)\n Survival times of test data.\n A structured array containing the binary event indicator\n as first field, and time of event or time of censoring as\n second field.\n\n estimate : array-like, shape = (n_samples, n_times)\n Estimated risk of experiencing an event for test data at `times`.\n The i-th column must contain the estimated probability of\n remaining event-free up to the i-th time point.\n\n times : array-like, shape = (n_times,)\n The time points for which to estimate the Brier score.\n Values must be within the range of follow-up times of\n the test data `survival_test`.\n\n Returns\n -------\n ibs : float\n The integrated Brier score.\n\n Examples\n --------\n >>> import numpy\n >>> from sksurv.datasets import load_gbsg2\n >>> from sksurv.linear_model import CoxPHSurvivalAnalysis\n >>> from sksurv.metrics import integrated_brier_score\n >>> from sksurv.preprocessing import OneHotEncoder\n\n Load and prepare data.\n\n >>> X, y = load_gbsg2()\n >>> X.loc[:, \"tgrade\"] = X.loc[:, \"tgrade\"].map(len).astype(int)\n >>> Xt = OneHotEncoder().fit_transform(X)\n\n Fit a Cox model.\n\n >>> est = CoxPHSurvivalAnalysis(ties=\"efron\").fit(Xt, y)\n\n Retrieve individual survival functions and get probability\n of remaining event free from 1 year to 5 years (=1825 days).\n\n >>> survs = est.predict_survival_function(Xt)\n >>> times = numpy.arange(365, 1826)\n >>> preds = numpy.asarray([[fn(t) for t in times for fn in survs]])\n\n Compute the integrated Brier score from 1 to 5 years.\n\n >>> score = integrated_brier_score(y, y, preds, times)\n >>> print(score)\n 0.1815853064627424\n\n See also\n --------\n brier_score\n\n References\n ----------\n .. [1] E. Graf, C. Schmoor, W. Sauerbrei, and M. Schumacher,\n \"Assessment and comparison of prognostic classification schemes for survival data,\"\n Statistics in Medicine, vol. 18, no. 17-18, pp. 2529–2545, 1999.\n \"\"\"\n # Computing the brier scores\n times, brier_scores = brier_score(survival_train, survival_test, estimate, times)\n\n if times.shape[0] < 2:\n raise ValueError(\"At least two time points must be given\")\n\n # Computing the IBS\n ibs_value = trapz(brier_scores, times) / (times[-1] - times[0])\n\n return ibs_value\n", "meta": {"hexsha": "396abd8d3ac77f4549c60192039b173a7ff97ba0", "size": 25843, "ext": "py", "lang": "Python", "max_stars_repo_path": "deep_cox_mixtures/dcm/skmetrics.py", "max_stars_repo_name": "chiragnagpal/google-research", "max_stars_repo_head_hexsha": "b9225e1eb6d83a2b9a69cd9b4b319129d0c68fc7", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 21, "max_stars_repo_stars_event_min_datetime": "2021-01-19T15:38:45.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-03T09:25:15.000Z", "max_issues_repo_path": "deep_cox_mixtures/dcm/skmetrics.py", "max_issues_repo_name": "chiragnagpal/google-research", "max_issues_repo_head_hexsha": "b9225e1eb6d83a2b9a69cd9b4b319129d0c68fc7", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2021-04-09T12:00:52.000Z", "max_issues_repo_issues_event_max_datetime": "2021-11-10T15:23:02.000Z", "max_forks_repo_path": "deep_cox_mixtures/dcm/skmetrics.py", "max_forks_repo_name": "chiragnagpal/google-research", "max_forks_repo_head_hexsha": "b9225e1eb6d83a2b9a69cd9b4b319129d0c68fc7", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-12-09T06:41:25.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-17T18:01:52.000Z", "avg_line_length": 37.0243553009, "max_line_length": 120, "alphanum_fraction": 0.6627713501, "include": true, "reason": "import numpy,from scipy", "num_tokens": 6407, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.519521321952093, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.19997006613770815}} {"text": "from collections import OrderedDict\n\nimport numpy as np\nimport pinocchio\nfrom numpy.linalg import inv\nfrom pinocchio.utils import zero\n\nfrom .activation import ActivationModelQuad\nfrom .cost import CostDataPinocchio, CostModelPinocchio, CostModelSum\nfrom .state import StatePinocchio\nfrom .utils import a2m\n\n\n# --------------------------------------------------------------------------\n# --------------------------------------------------------------------------\n# --------------------------------------------------------------------------\nclass ImpulseModelPinocchio:\n def __init__(self, pinocchioModel, nimpulse):\n assert (hasattr(self, 'ImpulseDataType'))\n self.pinocchio = pinocchioModel\n self.nq, self.nv = pinocchioModel.nq, pinocchioModel.nv\n self.nx = self.nq + self.nv\n self.ndx = 2 * self.nv\n self.nimpulse = nimpulse\n\n def createData(self, pinocchioData):\n return self.ImpulseDataType(self, pinocchioData)\n\n def calc(self, data, x):\n assert (False and \"This should be defined in the derivative class.\")\n\n def calcDiff(self, data, x, recalc=True):\n assert (False and \"This should be defined in the derivative class.\")\n\n def setForces(self, data, forcesArr, forcesVec=None):\n '''\n Convert a numpy array of forces into a stdVector of spatial forces.\n If forcesVec is not none, sum the result in it. Otherwise, reset self.fs\n and put the result there.\n '''\n assert (False and \"This should be defined in the derivative class.\")\n return self.forces\n\n\nclass ImpulseDataPinocchio:\n def __init__(self, model, pinocchioData):\n nc, nv = model.nimpulse, model.nv\n self.pinocchio = pinocchioData\n self.J = np.zeros([nc, nv])\n self.Jq = np.zeros([nc, nv])\n self.f = np.nan # not set at construction type\n self.forces = pinocchio.StdVec_Force()\n for i in range(model.pinocchio.njoints):\n self.forces.append(pinocchio.Force.Zero())\n self.Vq = np.zeros([nc, nv])\n\n\n# --------------------------------------------------------------------------\n\n\nclass ImpulseModel6D(ImpulseModelPinocchio):\n def __init__(self, pinocchioModel, frame):\n self.ImpulseDataType = ImpulseData6D\n ImpulseModelPinocchio.__init__(self, pinocchioModel, nimpulse=6)\n self.frame = frame\n\n def calc(self, data, x):\n # We suppose forwardKinematics(q,v,a), computeJointJacobian and updateFramePlacement already\n # computed.\n data.J[:, :] = pinocchio.getFrameJacobian(self.pinocchio, data.pinocchio, self.frame,\n pinocchio.ReferenceFrame.LOCAL)\n\n def calcDiff(self, data, x, recalc=True):\n if recalc:\n self.calc(data, x)\n dv_dq, dv_dv = pinocchio.getJointVelocityDerivatives(self.pinocchio, data.pinocchio, data.joint,\n pinocchio.ReferenceFrame.LOCAL)\n data.Vq[:, :] = data.fXj * dv_dq\n\n def setForces(self, data, forcesArr, forcesVec=None):\n '''\n Convert a numpy array of forces into a stdVector of spatial forces.\n Side effect: keep the force values in data.\n '''\n # In the dynamic equation, we wrote M*a + J.T*fdyn, while in the ABA it would be\n # M*a + b = tau + J.T faba, so faba = -fdyn (note the minus operator before a2m).\n data.f = forcesArr\n if forcesVec is None:\n forcesVec = data.forces\n data.forces[data.joint] *= 0\n forcesVec[data.joint] += data.jMf * pinocchio.Force(a2m(forcesArr))\n return forcesVec\n\n\nclass ImpulseData6D(ImpulseDataPinocchio):\n def __init__(self, model, pinocchioData):\n ImpulseDataPinocchio.__init__(self, model, pinocchioData)\n frame = model.pinocchio.frames[model.frame]\n self.joint = frame.parent\n self.jMf = frame.placement\n self.fXj = self.jMf.inverse().action\n\n\n# --------------------------------------------------------------------------\n\n\nclass ImpulseModel3D(ImpulseModelPinocchio):\n def __init__(self, pinocchioModel, frame):\n self.ImpulseDataType = ImpulseData3D\n ImpulseModelPinocchio.__init__(self, pinocchioModel, nimpulse=3)\n self.frame = frame\n\n def calc(self, data, x):\n # We suppose forwardKinematics(q,v,a), computeJointJacobian and updateFramePlacement already\n # computed.\n data.J[:, :] = pinocchio.getFrameJacobian(self.pinocchio, data.pinocchio, self.frame,\n pinocchio.ReferenceFrame.LOCAL)[:3, :]\n\n def calcDiff(self, data, x, recalc=True):\n if recalc:\n self.calc(data, x)\n dv_dq, dv_dv = pinocchio.getJointVelocityDerivatives(self.pinocchio, data.pinocchio, data.joint,\n pinocchio.ReferenceFrame.LOCAL)\n data.Vq[:, :] = data.fXj[:3, :] * dv_dq\n\n def setForces(self, data, forcesArr, forcesVec=None):\n '''\n Convert a numpy array of forces into a stdVector of spatial forces.\n Side effect: keep the force values in data.\n '''\n # In the dynamic equation, we wrote M*a + J.T*fdyn, while in the ABA it would be\n # M*a + b = tau + J.T faba, so faba = -fdyn (note the minus operator before a2m).\n data.f = forcesArr\n if forcesVec is None:\n forcesVec = data.forces\n data.forces[data.joint] *= 0\n forcesVec[data.joint] += data.jMf * pinocchio.Force(a2m(forcesArr), np.zeros((3, 1)))\n return forcesVec\n\n\nclass ImpulseData3D(ImpulseDataPinocchio):\n def __init__(self, model, pinocchioData):\n ImpulseDataPinocchio.__init__(self, model, pinocchioData)\n frame = model.pinocchio.frames[model.frame]\n self.joint = frame.parent\n self.jMf = frame.placement\n self.fXj = self.jMf.inverse().action\n\n\n# --------------------------------------------------------------------------\n\n\nclass ImpulseModelMultiple(ImpulseModelPinocchio):\n def __init__(self, pinocchioModel, impulses={}):\n self.ImpulseDataType = ImpulseDataMultiple\n ImpulseModelPinocchio.__init__(self, pinocchioModel, nimpulse=0)\n self.impulses = OrderedDict()\n for n, i in impulses.items():\n self.addImpulse(name=n, impulse=i)\n\n def addImpulse(self, name, impulse):\n self.impulses.update([[name, impulse]])\n self.nimpulse += impulse.nimpulse\n\n def __getitem__(self, key):\n if isinstance(key, str):\n return self.impulses[key]\n elif isinstance(key, ImpulseModelPinocchio):\n filter = [v for k, v in self.impulses.items() if v.impulse == key]\n assert (len(filter) == 1 and \"The given key is not or not unique in the impulse dict. \")\n return filter[0]\n else:\n raise (KeyError(\"The key should be string or impulsemodel.\"))\n\n def calc(self, data, x):\n npast = 0\n for m, d in zip(self.impulses.values(), data.impulses.values()):\n m.calc(d, x)\n data.J[npast:npast + m.nimpulse, :] = d.J\n npast += m.nimpulse\n\n def calcDiff(self, data, x, recalc=True):\n if recalc:\n self.calc(data, x)\n npast = 0\n for m, d in zip(self.impulses.values(), data.impulses.values()):\n m.calcDiff(d, x, recalc=False)\n data.Vq[npast:npast + m.nimpulse, :] = d.Vq\n npast += m.nimpulse\n\n def setForces(self, data, fsArr):\n npast = 0\n for i, f in enumerate(data.forces):\n data.forces[i] *= 0\n for m, d in zip(self.impulses.values(), data.impulses.values()):\n m.setForces(d, fsArr[npast:npast + m.nimpulse], data.forces)\n npast += m.nimpulse\n return data.forces\n\n\nclass ImpulseDataMultiple(ImpulseDataPinocchio):\n def __init__(self, model, pinocchioData):\n ImpulseDataPinocchio.__init__(self, model, pinocchioData)\n self.model = model\n self.impulses = OrderedDict([[k, m.createData(pinocchioData)] for k, m in model.impulses.items()])\n\n def __getitem__(self, key):\n if isinstance(key, str):\n return self.impulses[key]\n elif isinstance(key, ImpulseModelPinocchio):\n filter = [k for k, v in self.model.impulses.items() if v == key]\n assert (len(filter) == 1 and \"The given key is not or not unique in the impulse dict. \")\n return self.impulses[filter[0]]\n else:\n raise (KeyError(\"The key should be string or impulsemodel.\"))\n\n\nclass CostModelImpactBase(CostModelPinocchio):\n def __init__(self, pinocchioModel, ncost):\n CostModelPinocchio.__init__(self, pinocchioModel, ncost=ncost, nu=0)\n\n def setImpactData(self, data, vnext):\n data.vnext = vnext\n\n def setImpactDiffData(self, data, dvnext_dx):\n data.dvnext_dx = dvnext_dx\n\n def assertImpactDataSet(self, data):\n assert (data.vnext is not None and \"vnext should be copied first from impact-data. Call setImpactData first\")\n\n def assertImpactDiffDataSet(self, data):\n assert (data.dvnext_dx is not None and \"\"\"\n dvnext_dx should be copied first from impact-data. Call setImpactData first\"\"\")\n\n\nclass CostDataImpactBase(CostDataPinocchio):\n def __init__(self, model, pinocchioData):\n CostDataPinocchio.__init__(self, model, pinocchioData)\n # These two fields must be informed by ImpactData.\n self.vnext = None\n self.dvnext_dx = None\n\n\n# --------------------------------------------------------------------------\nclass CostModelImpactWholeBody(CostModelImpactBase):\n '''\n Penalize the impact on the whole body, i.e. the sum-of-square of ||vnext-v||\n with vnext the velocity after impact and v the velocity before impact.\n '''\n def __init__(self, pinocchioModel, activation=None):\n self.CostDataType = CostDataImpactWholeBody\n CostModelImpactBase.__init__(self, pinocchioModel, ncost=pinocchioModel.nv)\n self.activation = activation if activation is not None else ActivationModelQuad()\n\n def calc(self, data, x, u=None):\n self.assertImpactDataSet(data)\n nv = self.pinocchio.nv\n data.residuals[:] = data.vnext - x[-nv:]\n data.cost = sum(self.activation.calc(data.activation, data.residuals))\n return data.cost\n\n def calcDiff(self, data, x, u=None, recalc=True):\n if recalc:\n self.calc(data, x, u)\n self.assertImpactDiffDataSet(data)\n nv = self.pinocchio.nv\n Ax, Axx = self.activation.calcDiff(data.activation, data.residuals)\n data.Rx[:, :] = data.dvnext_dx\n data.Rx[range(nv), range(nv, 2 * nv)] -= 1\n data.Lx[:] = np.dot(data.Rx.T, Ax)\n data.Lxx[:, :] = np.dot(data.Rx.T, Axx * data.Rx)\n\n\nclass CostDataImpactWholeBody(CostDataImpactBase):\n def __init__(self, model, pinocchioData):\n CostDataImpactBase.__init__(self, model, pinocchioData)\n self.activation = model.activation.createData()\n self.Lu = 0\n self.Lxu = 0\n self.Luu = 0\n self.Ru = 0\n\n\n# --------------------------------------------------------------------------\nclass CostModelImpactCoM(CostModelImpactBase):\n '''\n Penalize the impact on the com, i.e. the sum-of-square of ||Jcom*(vnext-v)||\n with vnext the velocity after impact and v the velocity before impact.\n '''\n def __init__(self, pinocchioModel, activation=None):\n self.CostDataType = CostDataImpactCoM\n CostModelImpactBase.__init__(self, pinocchioModel, ncost=3)\n self.activation = activation if activation is not None else ActivationModelQuad()\n\n def calc(self, data, x, u=None):\n self.assertImpactDataSet(data)\n nq, nv = self.pinocchio.nq, self.pinocchio.nv\n pinocchio.centerOfMass(self.pinocchio, data.pinocchio_dv, a2m(x[:nq]), a2m(data.vnext - x[-nv:]))\n data.residuals[:] = data.pinocchio_dv.vcom[0].flat\n data.cost = sum(self.activation.calc(data.activation, data.residuals))\n return data.cost\n\n def calcDiff(self, data, x, u=None, recalc=True):\n if recalc:\n self.calc(data, x, u)\n self.assertImpactDiffDataSet(data)\n nv = self.pinocchio.nv\n Ax, Axx = self.activation.calcDiff(data.activation, data.residuals)\n\n # TODO ???\n # r = Jcom(vnext-v)\n # dr/dv = Jcom*(dvnext/dv - I)\n # dr/dq = dJcom_dq*(vnext-v) + Jcom*dvnext_dq\n # = dvcom_dq(vq=vnext-v) + Jcom*dvnext_dq\n # Jcom*v = M[:3,:]/mass * v = RNEA(q,0,v)[:3]/mass\n # => dvcom/dq = dRNEA_dq(q,0,v)[:3,:]/mass\n\n dvc_dq = pinocchio.getCenterOfMassVelocityDerivatives(self.pinocchio, data.pinocchio_dv)\n dvc_dv = pinocchio.jacobianCenterOfMass(self.pinocchio, data.pinocchio_dv)\n\n # res = vcom(q,vnext-v)\n # dres/dq = dvcom_dq + dvcom_dv*dvnext_dq\n data.Rx[:, :nv] = dvc_dq + np.dot(dvc_dv, data.dvnext_dx[:, :nv])\n\n # dres/dv = dvcom_dv*(dvnext_dv-I)\n ddv_dv = data.dvnext_dx[:, nv:].copy()\n ddv_dv[range(nv), range(nv)] -= 1\n data.Rx[:, nv:] = np.dot(dvc_dv, ddv_dv)\n\n data.Lx[:] = np.dot(data.Rx.T, Ax)\n data.Lxx[:, :] = np.dot(data.Rx.T, Axx * data.Rx)\n\n\nclass CostDataImpactCoM(CostDataImpactBase):\n def __init__(self, model, pinocchioData):\n CostDataImpactBase.__init__(self, model, pinocchioData)\n self.activation = model.activation.createData()\n # Those data are ment to be evaluated at v=vnext-v\n self.pinocchio_dv = model.pinocchio.createData()\n self.Lu = 0\n self.Lxu = 0\n self.Luu = 0\n self.Ru = 0\n\n\n# --------------------------------------------------------------------------\n# --------------------------------------------------------------------------\n# --------------------------------------------------------------------------\n\n\nclass ActionModelImpact:\n def __init__(self, pinocchioModel, impulseModel, costModel):\n self.pinocchio = pinocchioModel\n self.State = StatePinocchio(self.pinocchio)\n self.impulse = impulseModel\n self.nq, self.nv = self.pinocchio.nq, self.pinocchio.nv\n self.nx = self.State.nx\n self.ndx = self.State.ndx\n self.nout = self.nx\n self.nu = 0\n self.unone = np.zeros(self.nu)\n self.costs = costModel\n self.impulseWeight = 100.\n\n @property\n def nimpulse(self):\n return self.impulse.nimpulse\n\n @property\n def ncost(self):\n return self.costs.ncost\n\n def createData(self):\n return ActionDataImpact(self)\n\n def calc(self, data, x, u=None):\n '''\n M(vnext-v) - J^T f = 0\n J vnext = 0\n\n [MJ^T][vnext] = [Mv]\n [J ][ -f ] [0 ]\n\n [vnext] = K^-1[Mv], with K = [MJ^T;J0]\n [ -f ] [0 ]\n '''\n nq, nv = self.nq, self.nv\n q = a2m(x[:nq])\n v = a2m(x[-nv:])\n\n pinocchio.computeAllTerms(self.pinocchio, data.pinocchio, q, v)\n pinocchio.updateFramePlacements(self.pinocchio, data.pinocchio)\n\n self.impulse.calc(data.impulse, x)\n\n data.K[:nv, :nv] = data.pinocchio.M\n if hasattr(self.pinocchio, 'armature'):\n data.K[range(nv), range(nv)] += self.pinocchio.armature.flat\n data.K[nv:, :nv] = data.impulse.J\n data.K.T[nv:, :nv] = data.impulse.J\n data.Kinv = inv(data.K)\n data.r[:nv] = (data.K[:nv, :nv] * v).flat\n data.r[nv:] = 0\n\n data.af[:] = np.dot(data.Kinv, data.r)\n data.f[:] *= -1.\n # Convert force array to vector of spatial forces.\n self.impulse.setForces(data.impulse, data.f)\n\n data.xnext[:nq] = q.flat\n data.xnext[nq:] = data.vnext\n\n if isinstance(self.costs, CostModelImpactBase):\n self.costs.setImpactData(data.costs, data.vnext)\n if isinstance(self.costs, CostModelSum):\n for cmodel, cdata in zip(self.costs.costs.values(), data.costs.costs.values()):\n if isinstance(cmodel.cost, CostModelImpactBase):\n cmodel.cost.setImpactData(cdata, data.vnext)\n\n data.cost = self.costs.calc(data.costs, x, u=None)\n return data.xnext, data.cost\n\n def calcDiff(self, data, x, u=None, recalc=True):\n '''\n k = [Mv;0]; K = [MJ^T;J0]\n r = [vnext;f] = K^-1 k\n dr/dv = K^-1 [M;0]\n dr/dq = -K^-1 K'K^-1 k + K^-1 k' = -K^-1 (K'r-k')\n = -K^-1 [ M'vnext + J'^T f- M'v ]\n [ J'vnext ]\n = -K^-1 [ M'(vnext-v) + J'^T f ]\n [ J' vnext ]\n '''\n if recalc:\n xout, cost = self.calc(data, x, u)\n nq, nv = self.nq, self.nv\n q = a2m(x[:nq])\n v = a2m(x[-nv:])\n vnext = a2m(data.vnext)\n fs = data.impulse.forces\n\n # Derivative M' dv + J'f + b'\n g6bak = self.pinocchio.gravity.copy()\n self.pinocchio.gravity = pinocchio.Motion.Zero()\n pinocchio.computeRNEADerivatives(self.pinocchio, data.pinocchio, q, zero(nv), vnext - v, fs)\n self.pinocchio.gravity = g6bak\n data.did_dq[:, :] = data.pinocchio.dtau_dq\n\n # Derivative of the impulse constraint\n pinocchio.computeForwardKinematicsDerivatives(self.pinocchio, data.pinocchio, q, vnext, zero(nv))\n # pinocchio.updateFramePlacements(self.pinocchio,data.pinocchio)\n self.impulse.calcDiff(data.impulse, x, recalc=False)\n data.dv_dq = data.impulse.Vq\n\n data.Fq[:nv, :] = 0\n np.fill_diagonal(data.Fq[:nv, :], 1) # dq/dq\n data.Fv[:nv, :] = 0 # dq/dv\n data.Fx[nv:, :nv] = -np.dot(data.Kinv[:nv, :], np.vstack([data.did_dq, data.dv_dq])) # dvnext/dq\n data.Fx[nv:, nv:] = np.dot(data.Kinv[:nv, :nv], data.K[:nv, :nv]) # dvnext/dv\n\n # data.Rx[:,:] = 0\n # np.fill_diagonal(data.Rv,-1)\n # data.Rx[:,:] += data.Fx[nv:,:]\n # data.Rx *= self.impulseWeight\n # data.Lx [:] = np.dot(data.Rx.T,data.costResiduals)\n # data.Lxx[:,:] = np.dot(data.Rx.T,data.Rx)\n\n if isinstance(self.costs, CostModelImpactBase):\n self.costs.setImpactDiffData(data.costs, data.Fx[nv:, :])\n if isinstance(self.costs, CostModelSum):\n for cmodel, cdata in zip(self.costs.costs.values(), data.costs.costs.values()):\n if isinstance(cmodel.cost, CostModelImpactBase):\n cmodel.cost.setImpactDiffData(cdata, data.Fx[nv:, :])\n\n self.costs.calcDiff(data.costs, x, u=None, recalc=recalc)\n\n return data.xnext, data.cost\n\n\nclass ActionDataImpact:\n def __init__(self, model):\n self.pinocchio = model.pinocchio.createData()\n self.impulse = model.impulse.createData(self.pinocchio)\n if model.costs is not None:\n self.costs = model.costs.createData(self.pinocchio)\n self.cost = np.nan\n nx, nu, ndx, nv, nc = model.nx, model.nu, model.State.ndx, model.nv, model.nimpulse\n self.F = np.zeros([ndx, ndx + nu])\n self.Fx = self.F[:, :ndx]\n self.Fu = self.F[:, ndx:]\n self.Fq = self.Fx[:, :nv]\n self.Fv = self.Fx[:, nv:]\n self.Fq[:, :] = 0\n np.fill_diagonal(self.Fq, 1)\n\n self.costResiduals = np.zeros(nv)\n self.Rx = np.zeros([nv, ndx])\n self.Rq = self.Rx[:, :nv]\n self.Rv = self.Rx[:, nv:]\n\n self.costResiduals = self.costs.residuals\n self.Lx = self.costs.Lx\n self.Lu = self.costs.Lu\n self.Lxx = self.costs.Lxx\n self.Lxu = self.costs.Lxu\n self.Luu = self.costs.Luu\n self.Rx = self.costs.Rx\n self.Ru = self.costs.Ru\n\n self.K = np.zeros([nv + nc, nv + nc]) # KKT matrix = [ MJ.T ; J0 ]\n self.r = np.zeros(nv + nc) # NLE effects = [ tau-b ; -gamma ]\n self.af = np.zeros(nv + nc) # acceleration&forces = [ a ; f ]\n self.vnext = self.af[:nv]\n self.f = self.af[nv:]\n self.did_dq = np.zeros([nv, nv])\n\n self.xnext = np.zeros(nx)\n", "meta": {"hexsha": "50950c32e80e56efdd5ab12c56934021ab9426fe", "size": 20088, "ext": "py", "lang": "Python", "max_stars_repo_path": "unittest/python/crocoddyl/impact.py", "max_stars_repo_name": "pFernbach/crocoddyl", "max_stars_repo_head_hexsha": "cbf81a329e3abaf4ce1b4a8fab1431f93cd9a5c8", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-09-23T12:57:29.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-30T16:27:14.000Z", "max_issues_repo_path": "unittest/python/crocoddyl/impact.py", "max_issues_repo_name": "pFernbach/crocoddyl", "max_issues_repo_head_hexsha": "cbf81a329e3abaf4ce1b4a8fab1431f93cd9a5c8", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "unittest/python/crocoddyl/impact.py", "max_forks_repo_name": "pFernbach/crocoddyl", "max_forks_repo_head_hexsha": "cbf81a329e3abaf4ce1b4a8fab1431f93cd9a5c8", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-03-26T14:31:17.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-26T14:31:17.000Z", "avg_line_length": 38.7799227799, "max_line_length": 117, "alphanum_fraction": 0.5803962565, "include": true, "reason": "import numpy,from numpy", "num_tokens": 5474, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.519521321952093, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.19997006613770815}} {"text": "# -*- coding: utf-8 -*-\n\"\"\"\nMulti-lib backend for POT\n\nThe goal is to write backend-agnostic code. Whether you're using Numpy, PyTorch,\nor Jax, POT code should work nonetheless.\nTo achieve that, POT provides backend classes which implements functions in their respective backend\nimitating Numpy API. As a convention, we use nx instead of np to refer to the backend.\n\nExamples\n--------\n\n>>> from ot.utils import list_to_array\n>>> from ot.backend import get_backend\n>>> def f(a, b): # the function does not know which backend to use\n... a, b = list_to_array(a, b) # if a list in given, make it an array\n... nx = get_backend(a, b) # infer the backend from the arguments\n... c = nx.dot(a, b) # now use the backend to do any calculation\n... return c\n\"\"\"\n\n# Author: Remi Flamary \n# Nicolas Courty \n#\n# License: MIT License\n\nimport numpy as np\nimport scipy.special as scipy\nfrom scipy.sparse import issparse, coo_matrix, csr_matrix\n\ntry:\n import torch\n torch_type = torch.Tensor\nexcept ImportError:\n torch = False\n torch_type = float\n\ntry:\n import jax\n import jax.numpy as jnp\n import jax.scipy.special as jscipy\n jax_type = jax.numpy.ndarray\nexcept ImportError:\n jax = False\n jax_type = float\n\nstr_type_error = \"All array should be from the same type/backend. Current types are : {}\"\n\n\ndef get_backend_list():\n \"\"\"Returns the list of available backends\"\"\"\n lst = [NumpyBackend(), ]\n\n if torch:\n lst.append(TorchBackend())\n\n if jax:\n lst.append(JaxBackend())\n\n return lst\n\n\ndef get_backend(*args):\n \"\"\"Returns the proper backend for a list of input arrays\n\n Also raises TypeError if all arrays are not from the same backend\n \"\"\"\n # check that some arrays given\n if not len(args) > 0:\n raise ValueError(\" The function takes at least one parameter\")\n # check all same type\n if not len(set(type(a) for a in args)) == 1:\n raise ValueError(str_type_error.format([type(a) for a in args]))\n\n if isinstance(args[0], np.ndarray):\n return NumpyBackend()\n elif isinstance(args[0], torch_type):\n return TorchBackend()\n elif isinstance(args[0], jax_type):\n return JaxBackend()\n else:\n raise ValueError(\"Unknown type of non implemented backend.\")\n\n\ndef to_numpy(*args):\n \"\"\"Returns numpy arrays from any compatible backend\"\"\"\n\n if len(args) == 1:\n return get_backend(args[0]).to_numpy(args[0])\n else:\n return [get_backend(a).to_numpy(a) for a in args]\n\n\nclass Backend():\n \"\"\"\n Backend abstract class.\n Implementations: :py:class:`JaxBackend`, :py:class:`NumpyBackend`, :py:class:`TorchBackend`\n\n - The `__name__` class attribute refers to the name of the backend.\n - The `__type__` class attribute refers to the data structure used by the backend.\n \"\"\"\n\n __name__ = None\n __type__ = None\n __type_list__ = None\n\n rng_ = None\n\n def __str__(self):\n return self.__name__\n\n # convert to numpy\n def to_numpy(self, a):\n \"\"\"Returns the numpy version of a tensor\"\"\"\n raise NotImplementedError()\n\n # convert from numpy\n def from_numpy(self, a, type_as=None):\n \"\"\"Creates a tensor cloning a numpy array, with the given precision (defaulting to input's precision) and the given device (in case of GPUs)\"\"\"\n raise NotImplementedError()\n\n def set_gradients(self, val, inputs, grads):\n \"\"\"Define the gradients for the value val wrt the inputs \"\"\"\n raise NotImplementedError()\n\n def zeros(self, shape, type_as=None):\n r\"\"\"\n Creates a tensor full of zeros.\n\n This function follows the api from :any:`numpy.zeros`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.zeros.html\n \"\"\"\n raise NotImplementedError()\n\n def ones(self, shape, type_as=None):\n r\"\"\"\n Creates a tensor full of ones.\n\n This function follows the api from :any:`numpy.ones`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.ones.html\n \"\"\"\n raise NotImplementedError()\n\n def arange(self, stop, start=0, step=1, type_as=None):\n r\"\"\"\n Returns evenly spaced values within a given interval.\n\n This function follows the api from :any:`numpy.arange`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.arange.html\n \"\"\"\n raise NotImplementedError()\n\n def full(self, shape, fill_value, type_as=None):\n r\"\"\"\n Creates a tensor with given shape, filled with given value.\n\n This function follows the api from :any:`numpy.full`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.full.html\n \"\"\"\n raise NotImplementedError()\n\n def eye(self, N, M=None, type_as=None):\n r\"\"\"\n Creates the identity matrix of given size.\n\n This function follows the api from :any:`numpy.eye`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.eye.html\n \"\"\"\n raise NotImplementedError()\n\n def sum(self, a, axis=None, keepdims=False):\n r\"\"\"\n Sums tensor elements over given dimensions.\n\n This function follows the api from :any:`numpy.sum`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.sum.html\n \"\"\"\n raise NotImplementedError()\n\n def cumsum(self, a, axis=None):\n r\"\"\"\n Returns the cumulative sum of tensor elements over given dimensions.\n\n This function follows the api from :any:`numpy.cumsum`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.cumsum.html\n \"\"\"\n raise NotImplementedError()\n\n def max(self, a, axis=None, keepdims=False):\n r\"\"\"\n Returns the maximum of an array or maximum along given dimensions.\n\n This function follows the api from :any:`numpy.amax`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.amax.html\n \"\"\"\n raise NotImplementedError()\n\n def min(self, a, axis=None, keepdims=False):\n r\"\"\"\n Returns the maximum of an array or maximum along given dimensions.\n\n This function follows the api from :any:`numpy.amin`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.amin.html\n \"\"\"\n raise NotImplementedError()\n\n def maximum(self, a, b):\n r\"\"\"\n Returns element-wise maximum of array elements.\n\n This function follows the api from :any:`numpy.maximum`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.maximum.html\n \"\"\"\n raise NotImplementedError()\n\n def minimum(self, a, b):\n r\"\"\"\n Returns element-wise minimum of array elements.\n\n This function follows the api from :any:`numpy.minimum`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.minimum.html\n \"\"\"\n raise NotImplementedError()\n\n def dot(self, a, b):\n r\"\"\"\n Returns the dot product of two tensors.\n\n This function follows the api from :any:`numpy.dot`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.dot.html\n \"\"\"\n raise NotImplementedError()\n\n def abs(self, a):\n r\"\"\"\n Computes the absolute value element-wise.\n\n This function follows the api from :any:`numpy.absolute`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.absolute.html\n \"\"\"\n raise NotImplementedError()\n\n def exp(self, a):\n r\"\"\"\n Computes the exponential value element-wise.\n\n This function follows the api from :any:`numpy.exp`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.exp.html\n \"\"\"\n raise NotImplementedError()\n\n def log(self, a):\n r\"\"\"\n Computes the natural logarithm, element-wise.\n\n This function follows the api from :any:`numpy.log`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.log.html\n \"\"\"\n raise NotImplementedError()\n\n def sqrt(self, a):\n r\"\"\"\n Returns the non-ngeative square root of a tensor, element-wise.\n\n This function follows the api from :any:`numpy.sqrt`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.sqrt.html\n \"\"\"\n raise NotImplementedError()\n\n def power(self, a, exponents):\n r\"\"\"\n First tensor elements raised to powers from second tensor, element-wise.\n\n This function follows the api from :any:`numpy.power`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.power.html\n \"\"\"\n raise NotImplementedError()\n\n def norm(self, a):\n r\"\"\"\n Computes the matrix frobenius norm.\n\n This function follows the api from :any:`numpy.linalg.norm`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.linalg.norm.html\n \"\"\"\n raise NotImplementedError()\n\n def any(self, a):\n r\"\"\"\n Tests whether any tensor element along given dimensions evaluates to True.\n\n This function follows the api from :any:`numpy.any`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.any.html\n \"\"\"\n raise NotImplementedError()\n\n def isnan(self, a):\n r\"\"\"\n Tests element-wise for NaN and returns result as a boolean tensor.\n\n This function follows the api from :any:`numpy.isnan`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.isnan.html\n \"\"\"\n raise NotImplementedError()\n\n def isinf(self, a):\n r\"\"\"\n Tests element-wise for positive or negative infinity and returns result as a boolean tensor.\n\n This function follows the api from :any:`numpy.isinf`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.isinf.html\n \"\"\"\n raise NotImplementedError()\n\n def einsum(self, subscripts, *operands):\n r\"\"\"\n Evaluates the Einstein summation convention on the operands.\n\n This function follows the api from :any:`numpy.einsum`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.einsum.html\n \"\"\"\n raise NotImplementedError()\n\n def sort(self, a, axis=-1):\n r\"\"\"\n Returns a sorted copy of a tensor.\n\n This function follows the api from :any:`numpy.sort`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.sort.html\n \"\"\"\n raise NotImplementedError()\n\n def argsort(self, a, axis=None):\n r\"\"\"\n Returns the indices that would sort a tensor.\n\n This function follows the api from :any:`numpy.argsort`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.argsort.html\n \"\"\"\n raise NotImplementedError()\n\n def searchsorted(self, a, v, side='left'):\n r\"\"\"\n Finds indices where elements should be inserted to maintain order in given tensor.\n\n This function follows the api from :any:`numpy.searchsorted`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.searchsorted.html\n \"\"\"\n raise NotImplementedError()\n\n def flip(self, a, axis=None):\n r\"\"\"\n Reverses the order of elements in a tensor along given dimensions.\n\n This function follows the api from :any:`numpy.flip`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.flip.html\n \"\"\"\n raise NotImplementedError()\n\n def clip(self, a, a_min, a_max):\n \"\"\"\n Limits the values in a tensor.\n\n This function follows the api from :any:`numpy.clip`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.clip.html\n \"\"\"\n raise NotImplementedError()\n\n def repeat(self, a, repeats, axis=None):\n r\"\"\"\n Repeats elements of a tensor.\n\n This function follows the api from :any:`numpy.repeat`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.repeat.html\n \"\"\"\n raise NotImplementedError()\n\n def take_along_axis(self, arr, indices, axis):\n r\"\"\"\n Gathers elements of a tensor along given dimensions.\n\n This function follows the api from :any:`numpy.take_along_axis`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.take_along_axis.html\n \"\"\"\n raise NotImplementedError()\n\n def concatenate(self, arrays, axis=0):\n r\"\"\"\n Joins a sequence of tensors along an existing dimension.\n\n This function follows the api from :any:`numpy.concatenate`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.concatenate.html\n \"\"\"\n raise NotImplementedError()\n\n def zero_pad(self, a, pad_width):\n r\"\"\"\n Pads a tensor.\n\n This function follows the api from :any:`numpy.pad`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.pad.html\n \"\"\"\n raise NotImplementedError()\n\n def argmax(self, a, axis=None):\n r\"\"\"\n Returns the indices of the maximum values of a tensor along given dimensions.\n\n This function follows the api from :any:`numpy.argmax`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.argmax.html\n \"\"\"\n raise NotImplementedError()\n\n def mean(self, a, axis=None):\n r\"\"\"\n Computes the arithmetic mean of a tensor along given dimensions.\n\n This function follows the api from :any:`numpy.mean`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.mean.html\n \"\"\"\n raise NotImplementedError()\n\n def std(self, a, axis=None):\n r\"\"\"\n Computes the standard deviation of a tensor along given dimensions.\n\n This function follows the api from :any:`numpy.std`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.std.html\n \"\"\"\n raise NotImplementedError()\n\n def linspace(self, start, stop, num):\n r\"\"\"\n Returns a specified number of evenly spaced values over a given interval.\n\n This function follows the api from :any:`numpy.linspace`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.linspace.html\n \"\"\"\n raise NotImplementedError()\n\n def meshgrid(self, a, b):\n r\"\"\"\n Returns coordinate matrices from coordinate vectors (Numpy convention).\n\n This function follows the api from :any:`numpy.meshgrid`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.meshgrid.html\n \"\"\"\n raise NotImplementedError()\n\n def diag(self, a, k=0):\n r\"\"\"\n Extracts or constructs a diagonal tensor.\n\n This function follows the api from :any:`numpy.diag`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.diag.html\n \"\"\"\n raise NotImplementedError()\n\n def unique(self, a):\n r\"\"\"\n Finds unique elements of given tensor.\n\n This function follows the api from :any:`numpy.unique`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.unique.html\n \"\"\"\n raise NotImplementedError()\n\n def logsumexp(self, a, axis=None):\n r\"\"\"\n Computes the log of the sum of exponentials of input elements.\n\n This function follows the api from :any:`scipy.special.logsumexp`\n\n See: https://docs.scipy.org/doc/scipy/reference/generated/scipy.special.logsumexp.html\n \"\"\"\n raise NotImplementedError()\n\n def stack(self, arrays, axis=0):\n r\"\"\"\n Joins a sequence of tensors along a new dimension.\n\n This function follows the api from :any:`numpy.stack`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.stack.html\n \"\"\"\n raise NotImplementedError()\n\n def outer(self, a, b):\n r\"\"\"\n Computes the outer product between two vectors.\n\n This function follows the api from :any:`numpy.outer`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.outer.html\n \"\"\"\n raise NotImplementedError()\n\n def reshape(self, a, shape):\n r\"\"\"\n Gives a new shape to a tensor without changing its data.\n\n This function follows the api from :any:`numpy.reshape`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.reshape.html\n \"\"\"\n raise NotImplementedError()\n\n def seed(self, seed=None):\n r\"\"\"\n Sets the seed for the random generator.\n\n This function follows the api from :any:`numpy.random.seed`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.random.seed.html\n \"\"\"\n raise NotImplementedError()\n\n def rand(self, *size, type_as=None):\n r\"\"\"\n Generate uniform random numbers.\n\n This function follows the api from :any:`numpy.random.rand`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.random.rand.html\n \"\"\"\n raise NotImplementedError()\n\n def randn(self, *size, type_as=None):\n r\"\"\"\n Generate normal Gaussian random numbers.\n\n This function follows the api from :any:`numpy.random.rand`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.random.rand.html\n \"\"\"\n raise NotImplementedError()\n\n def coo_matrix(self, data, rows, cols, shape=None, type_as=None):\n r\"\"\"\n Creates a sparse tensor in COOrdinate format.\n\n This function follows the api from :any:`scipy.sparse.coo_matrix`\n\n See: https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.coo_matrix.html\n \"\"\"\n raise NotImplementedError()\n\n def issparse(self, a):\n r\"\"\"\n Checks whether or not the input tensor is a sparse tensor.\n\n This function follows the api from :any:`scipy.sparse.issparse`\n\n See: https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.issparse.html\n \"\"\"\n raise NotImplementedError()\n\n def tocsr(self, a):\n r\"\"\"\n Converts this matrix to Compressed Sparse Row format.\n\n This function follows the api from :any:`scipy.sparse.coo_matrix.tocsr`\n\n See: https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.coo_matrix.tocsr.html\n \"\"\"\n raise NotImplementedError()\n\n def eliminate_zeros(self, a, threshold=0.):\n r\"\"\"\n Removes entries smaller than the given threshold from the sparse tensor.\n\n This function follows the api from :any:`scipy.sparse.csr_matrix.eliminate_zeros`\n\n See: https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.sparse.csr_matrix.eliminate_zeros.html\n \"\"\"\n raise NotImplementedError()\n\n def todense(self, a):\n r\"\"\"\n Converts a sparse tensor to a dense tensor.\n\n This function follows the api from :any:`scipy.sparse.csr_matrix.toarray`\n\n See: https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.csr_matrix.toarray.html\n \"\"\"\n raise NotImplementedError()\n\n def where(self, condition, x, y):\n r\"\"\"\n Returns elements chosen from x or y depending on condition.\n\n This function follows the api from :any:`numpy.where`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.where.html\n \"\"\"\n raise NotImplementedError()\n\n def copy(self, a):\n r\"\"\"\n Returns a copy of the given tensor.\n\n This function follows the api from :any:`numpy.copy`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.copy.html\n \"\"\"\n raise NotImplementedError()\n\n def allclose(self, a, b, rtol=1e-05, atol=1e-08, equal_nan=False):\n r\"\"\"\n Returns True if two arrays are element-wise equal within a tolerance.\n\n This function follows the api from :any:`numpy.allclose`\n\n See: https://numpy.org/doc/stable/reference/generated/numpy.allclose.html\n \"\"\"\n raise NotImplementedError()\n\n def dtype_device(self, a):\n r\"\"\"\n Returns the dtype and the device of the given tensor.\n \"\"\"\n raise NotImplementedError()\n\n def assert_same_dtype_device(self, a, b):\n r\"\"\"\n Checks whether or not the two given inputs have the same dtype as well as the same device\n \"\"\"\n raise NotImplementedError()\n\n\nclass NumpyBackend(Backend):\n \"\"\"\n NumPy implementation of the backend\n\n - `__name__` is \"numpy\"\n - `__type__` is np.ndarray\n \"\"\"\n\n __name__ = 'numpy'\n __type__ = np.ndarray\n __type_list__ = [np.array(1, dtype=np.float32),\n np.array(1, dtype=np.float64)]\n\n rng_ = np.random.RandomState()\n\n def to_numpy(self, a):\n return a\n\n def from_numpy(self, a, type_as=None):\n if type_as is None:\n return a\n elif isinstance(a, float):\n return a\n else:\n return a.astype(type_as.dtype)\n\n def set_gradients(self, val, inputs, grads):\n # No gradients for numpy\n return val\n\n def zeros(self, shape, type_as=None):\n if type_as is None:\n return np.zeros(shape)\n else:\n return np.zeros(shape, dtype=type_as.dtype)\n\n def ones(self, shape, type_as=None):\n if type_as is None:\n return np.ones(shape)\n else:\n return np.ones(shape, dtype=type_as.dtype)\n\n def arange(self, stop, start=0, step=1, type_as=None):\n return np.arange(start, stop, step)\n\n def full(self, shape, fill_value, type_as=None):\n if type_as is None:\n return np.full(shape, fill_value)\n else:\n return np.full(shape, fill_value, dtype=type_as.dtype)\n\n def eye(self, N, M=None, type_as=None):\n if type_as is None:\n return np.eye(N, M)\n else:\n return np.eye(N, M, dtype=type_as.dtype)\n\n def sum(self, a, axis=None, keepdims=False):\n return np.sum(a, axis, keepdims=keepdims)\n\n def cumsum(self, a, axis=None):\n return np.cumsum(a, axis)\n\n def max(self, a, axis=None, keepdims=False):\n return np.max(a, axis, keepdims=keepdims)\n\n def min(self, a, axis=None, keepdims=False):\n return np.min(a, axis, keepdims=keepdims)\n\n def maximum(self, a, b):\n return np.maximum(a, b)\n\n def minimum(self, a, b):\n return np.minimum(a, b)\n\n def dot(self, a, b):\n return np.dot(a, b)\n\n def abs(self, a):\n return np.abs(a)\n\n def exp(self, a):\n return np.exp(a)\n\n def log(self, a):\n return np.log(a)\n\n def sqrt(self, a):\n return np.sqrt(a)\n\n def power(self, a, exponents):\n return np.power(a, exponents)\n\n def norm(self, a):\n return np.sqrt(np.sum(np.square(a)))\n\n def any(self, a):\n return np.any(a)\n\n def isnan(self, a):\n return np.isnan(a)\n\n def isinf(self, a):\n return np.isinf(a)\n\n def einsum(self, subscripts, *operands):\n return np.einsum(subscripts, *operands)\n\n def sort(self, a, axis=-1):\n return np.sort(a, axis)\n\n def argsort(self, a, axis=-1):\n return np.argsort(a, axis)\n\n def searchsorted(self, a, v, side='left'):\n if a.ndim == 1:\n return np.searchsorted(a, v, side)\n else:\n # this is a not very efficient way to make numpy\n # searchsorted work on 2d arrays\n ret = np.empty(v.shape, dtype=int)\n for i in range(a.shape[0]):\n ret[i, :] = np.searchsorted(a[i, :], v[i, :], side)\n return ret\n\n def flip(self, a, axis=None):\n return np.flip(a, axis)\n\n def outer(self, a, b):\n return np.outer(a, b)\n\n def clip(self, a, a_min, a_max):\n return np.clip(a, a_min, a_max)\n\n def repeat(self, a, repeats, axis=None):\n return np.repeat(a, repeats, axis)\n\n def take_along_axis(self, arr, indices, axis):\n return np.take_along_axis(arr, indices, axis)\n\n def concatenate(self, arrays, axis=0):\n return np.concatenate(arrays, axis)\n\n def zero_pad(self, a, pad_width):\n return np.pad(a, pad_width)\n\n def argmax(self, a, axis=None):\n return np.argmax(a, axis=axis)\n\n def mean(self, a, axis=None):\n return np.mean(a, axis=axis)\n\n def std(self, a, axis=None):\n return np.std(a, axis=axis)\n\n def linspace(self, start, stop, num):\n return np.linspace(start, stop, num)\n\n def meshgrid(self, a, b):\n return np.meshgrid(a, b)\n\n def diag(self, a, k=0):\n return np.diag(a, k)\n\n def unique(self, a):\n return np.unique(a)\n\n def logsumexp(self, a, axis=None):\n return scipy.logsumexp(a, axis=axis)\n\n def stack(self, arrays, axis=0):\n return np.stack(arrays, axis)\n\n def reshape(self, a, shape):\n return np.reshape(a, shape)\n\n def seed(self, seed=None):\n if seed is not None:\n self.rng_.seed(seed)\n\n def rand(self, *size, type_as=None):\n return self.rng_.rand(*size)\n\n def randn(self, *size, type_as=None):\n return self.rng_.randn(*size)\n\n def coo_matrix(self, data, rows, cols, shape=None, type_as=None):\n if type_as is None:\n return coo_matrix((data, (rows, cols)), shape=shape)\n else:\n return coo_matrix((data, (rows, cols)), shape=shape, dtype=type_as.dtype)\n\n def issparse(self, a):\n return issparse(a)\n\n def tocsr(self, a):\n if self.issparse(a):\n return a.tocsr()\n else:\n return csr_matrix(a)\n\n def eliminate_zeros(self, a, threshold=0.):\n if threshold > 0:\n if self.issparse(a):\n a.data[self.abs(a.data) <= threshold] = 0\n else:\n a[self.abs(a) <= threshold] = 0\n if self.issparse(a):\n a.eliminate_zeros()\n return a\n\n def todense(self, a):\n if self.issparse(a):\n return a.toarray()\n else:\n return a\n\n def where(self, condition, x, y):\n return np.where(condition, x, y)\n\n def copy(self, a):\n return a.copy()\n\n def allclose(self, a, b, rtol=1e-05, atol=1e-08, equal_nan=False):\n return np.allclose(a, b, rtol=rtol, atol=atol, equal_nan=equal_nan)\n\n def dtype_device(self, a):\n if hasattr(a, \"dtype\"):\n return a.dtype, \"cpu\"\n else:\n return type(a), \"cpu\"\n\n def assert_same_dtype_device(self, a, b):\n # numpy has implicit type conversion so we automatically validate the test\n pass\n\n\nclass JaxBackend(Backend):\n \"\"\"\n JAX implementation of the backend\n\n - `__name__` is \"jax\"\n - `__type__` is jax.numpy.ndarray\n \"\"\"\n\n __name__ = 'jax'\n __type__ = jax_type\n __type_list__ = None\n\n rng_ = None\n\n def __init__(self):\n self.rng_ = jax.random.PRNGKey(42)\n\n for d in jax.devices():\n self.__type_list__ = [jax.device_put(jnp.array(1, dtype=jnp.float32), d),\n jax.device_put(jnp.array(1, dtype=jnp.float64), d)]\n\n def to_numpy(self, a):\n return np.array(a)\n\n def _change_device(self, a, type_as):\n return jax.device_put(a, type_as.device_buffer.device())\n\n def from_numpy(self, a, type_as=None):\n if type_as is None:\n return jnp.array(a)\n else:\n return self._change_device(jnp.array(a).astype(type_as.dtype), type_as)\n\n def set_gradients(self, val, inputs, grads):\n from jax.flatten_util import ravel_pytree\n val, = jax.lax.stop_gradient((val,))\n\n ravelled_inputs, _ = ravel_pytree(inputs)\n ravelled_grads, _ = ravel_pytree(grads)\n\n aux = jnp.sum(ravelled_inputs * ravelled_grads) / 2\n aux = aux - jax.lax.stop_gradient(aux)\n\n val, = jax.tree_map(lambda z: z + aux, (val,))\n return val\n\n def zeros(self, shape, type_as=None):\n if type_as is None:\n return jnp.zeros(shape)\n else:\n return self._change_device(jnp.zeros(shape, dtype=type_as.dtype), type_as)\n\n def ones(self, shape, type_as=None):\n if type_as is None:\n return jnp.ones(shape)\n else:\n return self._change_device(jnp.ones(shape, dtype=type_as.dtype), type_as)\n\n def arange(self, stop, start=0, step=1, type_as=None):\n return jnp.arange(start, stop, step)\n\n def full(self, shape, fill_value, type_as=None):\n if type_as is None:\n return jnp.full(shape, fill_value)\n else:\n return self._change_device(jnp.full(shape, fill_value, dtype=type_as.dtype), type_as)\n\n def eye(self, N, M=None, type_as=None):\n if type_as is None:\n return jnp.eye(N, M)\n else:\n return self._change_device(jnp.eye(N, M, dtype=type_as.dtype), type_as)\n\n def sum(self, a, axis=None, keepdims=False):\n return jnp.sum(a, axis, keepdims=keepdims)\n\n def cumsum(self, a, axis=None):\n return jnp.cumsum(a, axis)\n\n def max(self, a, axis=None, keepdims=False):\n return jnp.max(a, axis, keepdims=keepdims)\n\n def min(self, a, axis=None, keepdims=False):\n return jnp.min(a, axis, keepdims=keepdims)\n\n def maximum(self, a, b):\n return jnp.maximum(a, b)\n\n def minimum(self, a, b):\n return jnp.minimum(a, b)\n\n def dot(self, a, b):\n return jnp.dot(a, b)\n\n def abs(self, a):\n return jnp.abs(a)\n\n def exp(self, a):\n return jnp.exp(a)\n\n def log(self, a):\n return jnp.log(a)\n\n def sqrt(self, a):\n return jnp.sqrt(a)\n\n def power(self, a, exponents):\n return jnp.power(a, exponents)\n\n def norm(self, a):\n return jnp.sqrt(jnp.sum(jnp.square(a)))\n\n def any(self, a):\n return jnp.any(a)\n\n def isnan(self, a):\n return jnp.isnan(a)\n\n def isinf(self, a):\n return jnp.isinf(a)\n\n def einsum(self, subscripts, *operands):\n return jnp.einsum(subscripts, *operands)\n\n def sort(self, a, axis=-1):\n return jnp.sort(a, axis)\n\n def argsort(self, a, axis=-1):\n return jnp.argsort(a, axis)\n\n def searchsorted(self, a, v, side='left'):\n if a.ndim == 1:\n return jnp.searchsorted(a, v, side)\n else:\n # this is a not very efficient way to make jax numpy\n # searchsorted work on 2d arrays\n return jnp.array([jnp.searchsorted(a[i, :], v[i, :], side) for i in range(a.shape[0])])\n\n def flip(self, a, axis=None):\n return jnp.flip(a, axis)\n\n def outer(self, a, b):\n return jnp.outer(a, b)\n\n def clip(self, a, a_min, a_max):\n return jnp.clip(a, a_min, a_max)\n\n def repeat(self, a, repeats, axis=None):\n return jnp.repeat(a, repeats, axis)\n\n def take_along_axis(self, arr, indices, axis):\n return jnp.take_along_axis(arr, indices, axis)\n\n def concatenate(self, arrays, axis=0):\n return jnp.concatenate(arrays, axis)\n\n def zero_pad(self, a, pad_width):\n return jnp.pad(a, pad_width)\n\n def argmax(self, a, axis=None):\n return jnp.argmax(a, axis=axis)\n\n def mean(self, a, axis=None):\n return jnp.mean(a, axis=axis)\n\n def std(self, a, axis=None):\n return jnp.std(a, axis=axis)\n\n def linspace(self, start, stop, num):\n return jnp.linspace(start, stop, num)\n\n def meshgrid(self, a, b):\n return jnp.meshgrid(a, b)\n\n def diag(self, a, k=0):\n return jnp.diag(a, k)\n\n def unique(self, a):\n return jnp.unique(a)\n\n def logsumexp(self, a, axis=None):\n return jscipy.logsumexp(a, axis=axis)\n\n def stack(self, arrays, axis=0):\n return jnp.stack(arrays, axis)\n\n def reshape(self, a, shape):\n return jnp.reshape(a, shape)\n\n def seed(self, seed=None):\n if seed is not None:\n self.rng_ = jax.random.PRNGKey(seed)\n\n def rand(self, *size, type_as=None):\n self.rng_, subkey = jax.random.split(self.rng_)\n if type_as is not None:\n return jax.random.uniform(subkey, shape=size, dtype=type_as.dtype)\n else:\n return jax.random.uniform(subkey, shape=size)\n\n def randn(self, *size, type_as=None):\n self.rng_, subkey = jax.random.split(self.rng_)\n if type_as is not None:\n return jax.random.normal(subkey, shape=size, dtype=type_as.dtype)\n else:\n return jax.random.normal(subkey, shape=size)\n\n def coo_matrix(self, data, rows, cols, shape=None, type_as=None):\n # Currently, JAX does not support sparse matrices\n data = self.to_numpy(data)\n rows = self.to_numpy(rows)\n cols = self.to_numpy(cols)\n nx = NumpyBackend()\n coo_matrix = nx.coo_matrix(data, rows, cols, shape=shape, type_as=type_as)\n matrix = nx.todense(coo_matrix)\n return self.from_numpy(matrix)\n\n def issparse(self, a):\n # Currently, JAX does not support sparse matrices\n return False\n\n def tocsr(self, a):\n # Currently, JAX does not support sparse matrices\n return a\n\n def eliminate_zeros(self, a, threshold=0.):\n # Currently, JAX does not support sparse matrices\n if threshold > 0:\n return self.where(\n self.abs(a) <= threshold,\n self.zeros((1,), type_as=a),\n a\n )\n return a\n\n def todense(self, a):\n # Currently, JAX does not support sparse matrices\n return a\n\n def where(self, condition, x, y):\n return jnp.where(condition, x, y)\n\n def copy(self, a):\n # No need to copy, JAX arrays are immutable\n return a\n\n def allclose(self, a, b, rtol=1e-05, atol=1e-08, equal_nan=False):\n return jnp.allclose(a, b, rtol=rtol, atol=atol, equal_nan=equal_nan)\n\n def dtype_device(self, a):\n return a.dtype, a.device_buffer.device()\n\n def assert_same_dtype_device(self, a, b):\n a_dtype, a_device = self.dtype_device(a)\n b_dtype, b_device = self.dtype_device(b)\n\n assert a_dtype == b_dtype, \"Dtype discrepancy\"\n assert a_device == b_device, f\"Device discrepancy. First input is on {str(a_device)}, whereas second input is on {str(b_device)}\"\n\n\nclass TorchBackend(Backend):\n \"\"\"\n PyTorch implementation of the backend\n\n - `__name__` is \"torch\"\n - `__type__` is torch.Tensor\n \"\"\"\n\n __name__ = 'torch'\n __type__ = torch_type\n __type_list__ = None\n\n rng_ = None\n\n def __init__(self):\n\n self.rng_ = torch.Generator()\n self.rng_.seed()\n\n self.__type_list__ = [torch.tensor(1, dtype=torch.float32),\n torch.tensor(1, dtype=torch.float64)]\n\n if torch.cuda.is_available():\n self.__type_list__.append(torch.tensor(1, dtype=torch.float32, device='cuda'))\n self.__type_list__.append(torch.tensor(1, dtype=torch.float64, device='cuda'))\n\n from torch.autograd import Function\n\n # define a function that takes inputs val and grads\n # ad returns a val tensor with proper gradients\n class ValFunction(Function):\n\n @staticmethod\n def forward(ctx, val, grads, *inputs):\n ctx.grads = grads\n return val\n\n @staticmethod\n def backward(ctx, grad_output):\n # the gradients are grad\n return (None, None) + tuple(g * grad_output for g in ctx.grads)\n\n self.ValFunction = ValFunction\n\n def to_numpy(self, a):\n return a.cpu().detach().numpy()\n\n def from_numpy(self, a, type_as=None):\n if isinstance(a, float):\n a = np.array(a)\n if type_as is None:\n return torch.from_numpy(a)\n else:\n return torch.as_tensor(a, dtype=type_as.dtype, device=type_as.device)\n\n def set_gradients(self, val, inputs, grads):\n\n Func = self.ValFunction()\n\n res = Func.apply(val, grads, *inputs)\n\n return res\n\n def zeros(self, shape, type_as=None):\n if isinstance(shape, int):\n shape = (shape,)\n if type_as is None:\n return torch.zeros(shape)\n else:\n return torch.zeros(shape, dtype=type_as.dtype, device=type_as.device)\n\n def ones(self, shape, type_as=None):\n if isinstance(shape, int):\n shape = (shape,)\n if type_as is None:\n return torch.ones(shape)\n else:\n return torch.ones(shape, dtype=type_as.dtype, device=type_as.device)\n\n def arange(self, stop, start=0, step=1, type_as=None):\n if type_as is None:\n return torch.arange(start, stop, step)\n else:\n return torch.arange(start, stop, step, device=type_as.device)\n\n def full(self, shape, fill_value, type_as=None):\n if isinstance(shape, int):\n shape = (shape,)\n if type_as is None:\n return torch.full(shape, fill_value)\n else:\n return torch.full(shape, fill_value, dtype=type_as.dtype, device=type_as.device)\n\n def eye(self, N, M=None, type_as=None):\n if M is None:\n M = N\n if type_as is None:\n return torch.eye(N, m=M)\n else:\n return torch.eye(N, m=M, dtype=type_as.dtype, device=type_as.device)\n\n def sum(self, a, axis=None, keepdims=False):\n if axis is None:\n return torch.sum(a)\n else:\n return torch.sum(a, axis, keepdim=keepdims)\n\n def cumsum(self, a, axis=None):\n if axis is None:\n return torch.cumsum(a.flatten(), 0)\n else:\n return torch.cumsum(a, axis)\n\n def max(self, a, axis=None, keepdims=False):\n if axis is None:\n return torch.max(a)\n else:\n return torch.max(a, axis, keepdim=keepdims)[0]\n\n def min(self, a, axis=None, keepdims=False):\n if axis is None:\n return torch.min(a)\n else:\n return torch.min(a, axis, keepdim=keepdims)[0]\n\n def maximum(self, a, b):\n if isinstance(a, int) or isinstance(a, float):\n a = torch.tensor([float(a)], dtype=b.dtype, device=b.device)\n if isinstance(b, int) or isinstance(b, float):\n b = torch.tensor([float(b)], dtype=a.dtype, device=a.device)\n if hasattr(torch, \"maximum\"):\n return torch.maximum(a, b)\n else:\n return torch.max(torch.stack(torch.broadcast_tensors(a, b)), axis=0)[0]\n\n def minimum(self, a, b):\n if isinstance(a, int) or isinstance(a, float):\n a = torch.tensor([float(a)], dtype=b.dtype, device=b.device)\n if isinstance(b, int) or isinstance(b, float):\n b = torch.tensor([float(b)], dtype=a.dtype, device=a.device)\n if hasattr(torch, \"minimum\"):\n return torch.minimum(a, b)\n else:\n return torch.min(torch.stack(torch.broadcast_tensors(a, b)), axis=0)[0]\n\n def dot(self, a, b):\n return torch.matmul(a, b)\n\n def abs(self, a):\n return torch.abs(a)\n\n def exp(self, a):\n return torch.exp(a)\n\n def log(self, a):\n return torch.log(a)\n\n def sqrt(self, a):\n return torch.sqrt(a)\n\n def power(self, a, exponents):\n return torch.pow(a, exponents)\n\n def norm(self, a):\n return torch.sqrt(torch.sum(torch.square(a)))\n\n def any(self, a):\n return torch.any(a)\n\n def isnan(self, a):\n return torch.isnan(a)\n\n def isinf(self, a):\n return torch.isinf(a)\n\n def einsum(self, subscripts, *operands):\n return torch.einsum(subscripts, *operands)\n\n def sort(self, a, axis=-1):\n sorted0, indices = torch.sort(a, dim=axis)\n return sorted0\n\n def argsort(self, a, axis=-1):\n sorted, indices = torch.sort(a, dim=axis)\n return indices\n\n def searchsorted(self, a, v, side='left'):\n right = (side != 'left')\n return torch.searchsorted(a, v, right=right)\n\n def flip(self, a, axis=None):\n if axis is None:\n return torch.flip(a, tuple(i for i in range(len(a.shape))))\n if isinstance(axis, int):\n return torch.flip(a, (axis,))\n else:\n return torch.flip(a, dims=axis)\n\n def outer(self, a, b):\n return torch.outer(a, b)\n\n def clip(self, a, a_min, a_max):\n return torch.clamp(a, a_min, a_max)\n\n def repeat(self, a, repeats, axis=None):\n return torch.repeat_interleave(a, repeats, dim=axis)\n\n def take_along_axis(self, arr, indices, axis):\n return torch.gather(arr, axis, indices)\n\n def concatenate(self, arrays, axis=0):\n return torch.cat(arrays, dim=axis)\n\n def zero_pad(self, a, pad_width):\n from torch.nn.functional import pad\n # pad_width is an array of ndim tuples indicating how many 0 before and after\n # we need to add. We first need to make it compliant with torch syntax, that\n # starts with the last dim, then second last, etc.\n how_pad = tuple(element for tupl in pad_width[::-1] for element in tupl)\n return pad(a, how_pad)\n\n def argmax(self, a, axis=None):\n return torch.argmax(a, dim=axis)\n\n def mean(self, a, axis=None):\n if axis is not None:\n return torch.mean(a, dim=axis)\n else:\n return torch.mean(a)\n\n def std(self, a, axis=None):\n if axis is not None:\n return torch.std(a, dim=axis, unbiased=False)\n else:\n return torch.std(a, unbiased=False)\n\n def linspace(self, start, stop, num):\n return torch.linspace(start, stop, num, dtype=torch.float64)\n\n def meshgrid(self, a, b):\n X, Y = torch.meshgrid(a, b)\n return X.T, Y.T\n\n def diag(self, a, k=0):\n return torch.diag(a, diagonal=k)\n\n def unique(self, a):\n return torch.unique(a)\n\n def logsumexp(self, a, axis=None):\n if axis is not None:\n return torch.logsumexp(a, dim=axis)\n else:\n return torch.logsumexp(a, dim=tuple(range(len(a.shape))))\n\n def stack(self, arrays, axis=0):\n return torch.stack(arrays, dim=axis)\n\n def reshape(self, a, shape):\n return torch.reshape(a, shape)\n\n def seed(self, seed=None):\n if isinstance(seed, int):\n self.rng_.manual_seed(seed)\n elif isinstance(seed, torch.Generator):\n self.rng_ = seed\n else:\n raise ValueError(\"Non compatible seed : {}\".format(seed))\n\n def rand(self, *size, type_as=None):\n if type_as is not None:\n return torch.rand(size=size, generator=self.rng_, dtype=type_as.dtype, device=type_as.device)\n else:\n return torch.rand(size=size, generator=self.rng_)\n\n def randn(self, *size, type_as=None):\n if type_as is not None:\n return torch.randn(size=size, dtype=type_as.dtype, generator=self.rng_, device=type_as.device)\n else:\n return torch.randn(size=size, generator=self.rng_)\n\n def coo_matrix(self, data, rows, cols, shape=None, type_as=None):\n if type_as is None:\n return torch.sparse_coo_tensor(torch.stack([rows, cols]), data, size=shape)\n else:\n return torch.sparse_coo_tensor(\n torch.stack([rows, cols]), data, size=shape,\n dtype=type_as.dtype, device=type_as.device\n )\n\n def issparse(self, a):\n return getattr(a, \"is_sparse\", False) or getattr(a, \"is_sparse_csr\", False)\n\n def tocsr(self, a):\n # Versions older than 1.9 do not support CSR tensors. PyTorch 1.9 and 1.10 offer a very limited support\n return self.todense(a)\n\n def eliminate_zeros(self, a, threshold=0.):\n if self.issparse(a):\n if threshold > 0:\n mask = self.abs(a) <= threshold\n mask = ~mask\n mask = mask.nonzero()\n else:\n mask = a._values().nonzero()\n nv = a._values().index_select(0, mask.view(-1))\n ni = a._indices().index_select(1, mask.view(-1))\n return self.coo_matrix(nv, ni[0], ni[1], shape=a.shape, type_as=a)\n else:\n if threshold > 0:\n a[self.abs(a) <= threshold] = 0\n return a\n\n def todense(self, a):\n if self.issparse(a):\n return a.to_dense()\n else:\n return a\n\n def where(self, condition, x, y):\n return torch.where(condition, x, y)\n\n def copy(self, a):\n return torch.clone(a)\n\n def allclose(self, a, b, rtol=1e-05, atol=1e-08, equal_nan=False):\n return torch.allclose(a, b, rtol=rtol, atol=atol, equal_nan=equal_nan)\n\n def dtype_device(self, a):\n return a.dtype, a.device\n\n def assert_same_dtype_device(self, a, b):\n a_dtype, a_device = self.dtype_device(a)\n b_dtype, b_device = self.dtype_device(b)\n\n assert a_dtype == b_dtype, \"Dtype discrepancy\"\n assert a_device == b_device, f\"Device discrepancy. First input is on {str(a_device)}, whereas second input is on {str(b_device)}\"\n", "meta": {"hexsha": "fa164c39f36ab2fbe007dd31ac575770cb386acb", "size": 44930, "ext": "py", "lang": "Python", "max_stars_repo_path": "ot/backend.py", "max_stars_repo_name": "cedricvincentcuaz/POT", "max_stars_repo_head_hexsha": "cb510644b2fd65e4ce216a7799ce7401f71548b8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "ot/backend.py", "max_issues_repo_name": "cedricvincentcuaz/POT", "max_issues_repo_head_hexsha": "cb510644b2fd65e4ce216a7799ce7401f71548b8", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ot/backend.py", "max_forks_repo_name": "cedricvincentcuaz/POT", "max_forks_repo_head_hexsha": "cb510644b2fd65e4ce216a7799ce7401f71548b8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.8935462409, "max_line_length": 151, "alphanum_fraction": 0.6079679501, "include": true, "reason": "import numpy,from numpy,import scipy,from scipy,import jax,from jax", "num_tokens": 10553, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.519521321952093, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.19997006613770815}} {"text": "\"\"\"\nPart of code is from Kai Li \"kailigo\". The gitub website is https://github.com/kailigo/cvcZSL.\nWe add virtual classes and IAS in the code.\n\"\"\"\nfrom scipy import io\nimport numpy as np\nimport torch\nimport torch.nn as nn\nfrom torch.autograd import Variable\nfrom torch.nn import functional as F\nfrom torch.optim import lr_scheduler\nimport torch.utils.data as data\nfrom sklearn.metrics import accuracy_score\nfrom tensorboardX import SummaryWriter\n\nfrom utils import ReDirectSTD\nfrom unseen_data_loader import data_loader_virtualCls\nfrom unseen_option import Options\n\nimport os\nimport random\nimport pickle\n# from test_embeded import test_while_training_simple\n\nTMP = 10\n\nargs = Options().parse()\nmodel_file_name = './chk/' + args.model_file\nsummaryFolder = './summary/' + args.log_file\nif not os.path.exists(summaryFolder):\n os.mkdir(summaryFolder)\nwriter = SummaryWriter(summaryFolder)\nprint(args)\n\ndef init_seeds(seed=0):\n random.seed(seed)\n np.random.seed(seed)\n\n # torch cuda\n torch.cuda.empty_cache()\n torch.manual_seed(seed)\n torch.cuda.manual_seed(seed)\n torch.cuda.manual_seed_all(seed)\n\ninit_seeds(520)\ndef calc_accuracy(test_visual, test_label, attM, test_id, test_id_seen_unseen,cossim=False): \n outpred = [0] * test_visual.shape[0] \n end = 0\n outpred_list = []\n zslpred_list = []\n score_n_list = []\n for j in range(0,len(test_visual),64):\n if j+64>len(test_visual):\n end = len(test_visual)\n else:\n end = j+64\n all_cls_weights = forward(attM,test_visual[j:end],tmp=TMP) \n score,score_n=apply_classification_weights(test_visual[j:end].cuda(), \n all_cls_weights,norm=True)\n score = score.squeeze(0)\n score_n = score_n.squeeze(0)\n \n _, pred = score.max(dim=1)\n pred = pred.view(-1)\n select_test_label = test_label[j:end].view(-1)\n\n outpred_list.extend(test_id[pred.cpu().detach().numpy()])\n zslpred_list.extend([ i in test_id_seen_unseen for i in test_id[pred.cpu().detach().numpy()]])\n score_n_list.extend(score_n.cpu().detach().numpy())\n\n seen_unseen_acc = accuracy_score(np.ones(len(zslpred_list)),zslpred_list)\n \n outpred = np.array(outpred_list, dtype='int')\n score_n = np.array(score_n_list)\n test_label = test_label.numpy()\n unique_labels = np.unique(test_label)\n acc = 0\n acc_cls = {}\n preds_cls = {}\n cos_cls = {}\n for l in unique_labels:\n idx = np.nonzero(test_label == l)[0]\n acc_cls[l] = accuracy_score(test_label[idx],outpred[idx])\n try:\n preds_cls[l].extend(list(outpred[idx])) \n except(KeyError):\n preds_cls[l] = list(outpred[idx])\n\n acc += acc_cls[l]\n loc = test_label == l\n outpred_l = outpred[idx]\n score_n_l = score_n[idx]\n loc = outpred_l == l\n\n if cossim:\n cos_c = score_n_l[loc,l]\n try:\n cos_cls[l].extend(cos_c)\n except(KeyError):\n cos_cls[l] = [cos_c]\n acc = acc / unique_labels.shape[0]\n\n return acc,seen_unseen_acc,acc_cls,cos_cls,preds_cls\n\n\ndef compute_accuracy_all(test_att, att_all, test_visual_unseen, test_id_unseen, test_label_unseen,\n test_visual_seen, test_id_all, test_label_seen,train_id):\n\n acc_zsl,_,unseenacc_cls,_,unseenpred_cls = calc_accuracy(test_visual_unseen, test_label_unseen, test_att, test_id_unseen,test_id_unseen)\n acc_seenAcc,_,seenacc_cls,_,_ = calc_accuracy(test_visual_seen, test_label_seen, att_all, train_id, train_id)\n\n att_all_cls = torch.cat((att_all, test_att))\n \n acc_gzsl_unseen,Ru,unseengeneralAcc_cls,unseenCos_cls,_ = calc_accuracy(test_visual_unseen, test_label_unseen, att_all_cls, test_id_all,test_id_unseen,cossim=True)\n \n acc_gzsl_seen,Rs,seengeneralAcc_cls,seenCos_cls,_ = calc_accuracy(test_visual_seen, test_label_seen, att_all_cls, test_id_all,train_id,cossim=True) \n acc_cls = {**unseenacc_cls,**seenacc_cls}\n generalAcc_cls = {**unseengeneralAcc_cls,**seengeneralAcc_cls}\n H = 2 * acc_gzsl_seen * acc_gzsl_unseen / (acc_gzsl_seen + acc_gzsl_unseen)\n\n return acc_zsl, acc_seenAcc, acc_gzsl_unseen, acc_gzsl_seen, H, Rs, Ru, acc_cls, generalAcc_cls,unseenCos_cls,seenCos_cls,unseenpred_cls\n\n\ndef apply_classification_weights(features, cls_weights,norm=False):\n\n features = F.normalize(features,dim=-1)\n cls_weights = F.normalize(cls_weights, p=2, dim=-1, eps=1e-12) \n\n cls_scores = scale_cls * (torch.matmul(cls_weights,features.t()))\n cls_scores = cls_scores.permute(0,2,1)\n cls_scores = torch.diagonal(cls_scores,offset=0,dim1=0,dim2=1)\n cls_scores = cls_scores.t()\n if norm:\n return cls_scores,cls_scores/scale_cls\n else:\n return cls_scores\n\n\ndef IASatt(features,AttM,tmp):\n cls_num = len(AttM)\n attdims = AttM.shape[1]\n atten = torch.mm(features,w_IAS)+b_IAS\n atten = F.softmax(atten/tmp,dim=1).reshape(-1,1,attdims)\n atten = atten.reshape(-1,1,attdims)\n atten = atten + torch.ones_like(atten)\n atten = atten.repeat(1,cls_num,1)\n AttM = AttM.unsqueeze(0)\n AttM = AttM.repeat(len(features),1,1)\n AttM = atten*AttM\n return AttM\n\ndef forward(att,features,tmp):\n features = features.squeeze()\n att = IASatt(features,att,tmp)\n\n a1 = F.relu(torch.matmul(att, w1) + b1)\n a2 = F.relu(torch.matmul(a1, w2) + b2)\n\n return a2\n\ndataroot = './dataset/xlsa/'\nimage_embedding = 'res101' \nclass_embedding = 'att'\ndataset = args.dataset\nmatcontent = io.loadmat(dataroot + \"/\" + dataset + \"/\" + image_embedding + \".mat\")\n\nfeature = matcontent['features'].T\nlabel = matcontent['labels'].astype(int).squeeze() - 1\nmatcontent = io.loadmat(dataroot + \"/\" + dataset + \"/\" + class_embedding + \"_splits.mat\")\n\ntrainvalloc = matcontent['trainval_loc'].squeeze() - 1\ntest_seen_loc = matcontent['test_seen_loc'].squeeze() - 1\ntest_unseen_loc = matcontent['test_unseen_loc'].squeeze() - 1\n\natt_name = 'att'\nattribute = matcontent[att_name].T \n\nchkFile = './dataset/finetune/'+args.dataset+'/dvbeExtracted.pkl'\nwith open(chkFile,'rb') as f:\n Feature_target = pickle.load(f)\n\nclsname = [ matcontent['allclasses_names'][i][0][0] for i in range(len(matcontent['allclasses_names']))]\n\ntrain_x = Feature_target['train_seen']['features']\ntrain_label = Feature_target['train_seen']['labels']\ntrain_att = attribute[train_label]\ntrain_id, idx = np.unique(train_label, return_inverse=True)\ntrain_att_unique = attribute[train_id]\n\ntest_x_unseen = Feature_target['test_unseen']['features']\ntest_label_unseen = Feature_target['test_unseen']['labels']\ntest_id, idx = np.unique(test_label_unseen, return_inverse=True)\natt_pro = attribute[test_id]\ntrain_test_id = np.concatenate((train_id, test_id))\n\ntest_x_seen = Feature_target['test_seen']['features'] \ntest_label_seen = Feature_target['test_seen']['labels']\n_, idx = np.unique(test_label_seen, return_inverse=True)\n\natt_dim = train_att.shape[1]\nfeat_dim = train_x.shape[1]\n\natt_pro = torch.from_numpy(att_pro).float().cuda()\ntest_x_seen = torch.from_numpy(test_x_seen).float().cuda()\ntest_x_seen = F.normalize(test_x_seen, p=2, dim=test_x_seen.dim()-1, eps=1e-12)\ntest_x_unseen = torch.from_numpy(test_x_unseen).float().cuda()\ntest_x_unseen = F.normalize(test_x_unseen, p=2, dim=test_x_unseen.dim()-1, eps=1e-12)\ntest_label_seen = torch.tensor(test_label_seen)\ntest_label_unseen = torch.tensor(test_label_unseen)\n\natt_all = torch.from_numpy(train_att_unique).float().cuda()\n\nbias = nn.Parameter(torch.FloatTensor(1).fill_(0).cuda(), requires_grad=True)\nscale_cls = nn.Parameter(torch.FloatTensor(1).fill_(10).cuda(), requires_grad=True)\nw1 = Variable(torch.FloatTensor(att_dim, args.hidden_dim).cuda(), requires_grad=True)\nb1 = Variable(torch.FloatTensor(args.hidden_dim).cuda(), requires_grad=True)\nw2 = Variable(torch.FloatTensor(args.hidden_dim, 2048).cuda(), requires_grad=True)\nb2 = Variable(torch.FloatTensor(2048).cuda(), requires_grad=True)\nw_IAS = Variable(torch.FloatTensor(2048, att_dim).cuda(), requires_grad=True)\nb_IAS = Variable(torch.FloatTensor(att_dim).cuda(), requires_grad=True)\n\nw1.data.normal_(0, 0.02)\nw2.data.normal_(0, 0.02)\nb1.data.fill_(0)\nb2.data.fill_(0)\nw_IAS.data.normal_(0,0.02)\nb_IAS.data.fill_(0)\n\noptimizer = torch.optim.Adam([w_IAS,b_IAS,w1, b1, w2, b2, bias, scale_cls], lr=args.lr, weight_decay=args.opt_decay)\n\n# breakpoint()\nstep_size = args.step_size\ngamma = args.gamma\nlr_scheduler = lr_scheduler.StepLR(optimizer, step_size=step_size, gamma=gamma)\ncriterion = nn.CrossEntropyLoss()\n\nways = args.ways\nshots = args.shots\n\ndataset = data_loader_virtualCls(train_x, train_att, train_label, ways=ways, shots=shots)\n\n# breakpoint()\nbest_acc_zsl = 0.0\nbest_acc_gzsl_seen = 0.0\nbest_acc_gzsl_unseen = 0.0\nbest_H = 0.0\nbest_epoch = 0\nbest_unseenAcc = 0.0\n\n\nfor epoch in range(args.num_epochs): \n epoch_loss = 0\n lr_scheduler.step()\n\n for i in range(1000): \n batch_visual, batch_att, batch_label = dataset.__getitem__(i) \n batch_visual = batch_visual.cuda() \n batch_visual_norm = F.normalize(batch_visual, p=2, dim=batch_visual.dim()-1, eps=1e-12) \n\n indx = torch.tensor(list(range(0, ways*shots, shots))) \n unique_batch_att = torch.index_select(batch_att, 0, indx).float().cuda() \n\n batch_weights = forward(unique_batch_att,batch_visual_norm,tmp=TMP) \n all_cls_weights = batch_weights\n\n score = apply_classification_weights(batch_visual_norm, all_cls_weights)\n score = score.squeeze(0) \n loss = criterion(score, Variable(batch_label.cuda()))\n\n optimizer.zero_grad()\n loss.backward()\n torch.nn.utils.clip_grad_norm_([w_IAS,b_IAS,w1, b1, w2, b2, scale_cls, bias], 1)\n optimizer.step()\n epoch_loss = epoch_loss + loss\n\n epoch_loss = epoch_loss / 1000.0\n epoch_loss = epoch_loss.data.cpu().numpy()\n\n acc_zsl, seenAcc, acc_unseen_gzsl, acc_seen_gzsl, H, Rs,Ru,accs_cls,generalAccs_cls,unseenCos_cls,seenCos_cls,unseenpred_cls = compute_accuracy_all(att_pro, att_all, test_x_unseen, \n test_id, test_label_unseen, test_x_seen, train_test_id, test_label_seen, train_id)\n \n H = 2 * acc_seen_gzsl * acc_unseen_gzsl / (acc_seen_gzsl + acc_unseen_gzsl)\n writer.add_scalar('general/acc_seen_gzsl',acc_seen_gzsl,epoch)\n writer.add_scalar('general/acc_unseen_gzsl',acc_unseen_gzsl,epoch)\n writer.add_scalar('general/H',H,epoch)\n writer.add_scalar('split/unseenAcc',acc_zsl,epoch)\n writer.add_scalar('split/seenAcc',seenAcc,epoch)\n writer.add_scalar('split/Rs',Rs,epoch)\n writer.add_scalar('split/Ru',Ru,epoch)\n writer.add_scalar('loss/loss',epoch_loss,epoch)\n \n\n if acc_zsl > best_unseenAcc:\n print('save best acc')\n best_unseenAcc = acc_zsl\n best_epoch = epoch\n best_acc_zsl = acc_zsl \n best_seen_acc = seenAcc \n best_acc_gzsl_seen = acc_seen_gzsl\n best_acc_gzsl_unseen = acc_unseen_gzsl\n best_H = H\n best_Ru = Ru\n best_Rs = Rs\n\n best_w1 = w1.data.clone()\n best_b1 = b1.data.clone()\n best_w2 = w2.data.clone()\n best_b2 = b2.data.clone()\n best_scale_cls = scale_cls.data.clone()\n best_bias = bias.data.clone()\n\n torch.save({'w1': best_w1, 'b1': best_b1, 'w2': best_w2, 'b2': best_b2, \n 'scale_cls': best_scale_cls, 'bias': best_bias,'w_IAS':w_IAS,'b_IAS':b_IAS}, model_file_name.replace('.pt','bestunseenAcc.pt'))\n \n\n for param_group in optimizer.param_groups:\n print('ep: %d, lr: %lf, loss: %.4f, zsl: %.4f, seenAcc: %.4f gzsl: seen=%.4f, unseen=%.4f, h=%.4f, Rs=%.4f, Ru=%.4f ' % \n (epoch, param_group['lr'], epoch_loss, acc_zsl, seenAcc, acc_seen_gzsl, acc_unseen_gzsl, H, Rs, Ru,)) \nprint(model_file_name)\nprint('best_ep: %d, zsl: %.4f, seenAcc: %.4f gzsl: seen=%.4f, unseen=%.4f, h=%.4f, Rs=%.4f, Ru=%.4f' % \n (best_epoch, best_acc_zsl,best_seen_acc, best_acc_gzsl_seen, best_acc_gzsl_unseen, best_H, best_Rs, best_Ru)) \n\n", "meta": {"hexsha": "9ac6af783446a65220a6b2ec56660ba8825206a0", "size": 12959, "ext": "py", "lang": "Python", "max_stars_repo_path": "train_unseen.py", "max_stars_repo_name": "anonmous529/AGZSL", "max_stars_repo_head_hexsha": "1d916f9e950d1c21c1150a0f670833439c89abb3", "max_stars_repo_licenses": ["Apache-1.1"], "max_stars_count": 13, "max_stars_repo_stars_event_min_datetime": "2020-12-04T07:14:51.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-01T07:00:55.000Z", "max_issues_repo_path": "train_unseen.py", "max_issues_repo_name": "anonmous529/AGZSL", "max_issues_repo_head_hexsha": "1d916f9e950d1c21c1150a0f670833439c89abb3", "max_issues_repo_licenses": ["Apache-1.1"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-04-15T23:54:59.000Z", "max_issues_repo_issues_event_max_datetime": "2021-04-16T00:09:17.000Z", "max_forks_repo_path": "train_unseen.py", "max_forks_repo_name": "anonmous529/AGZSL", "max_forks_repo_head_hexsha": "1d916f9e950d1c21c1150a0f670833439c89abb3", "max_forks_repo_licenses": ["Apache-1.1"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2021-04-16T00:01:07.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-05T10:38:30.000Z", "avg_line_length": 40.1207430341, "max_line_length": 189, "alphanum_fraction": 0.650358824, "include": true, "reason": "import numpy,from scipy", "num_tokens": 3377, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5195213219520929, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.19997006613770812}} {"text": "import numpy as np\nimport array\nimport os, sys\nimport re\nimport time\nimport multiprocessing, logging\n# mpl = multiprocessing.log_to_stderr()\n# mpl.setLevel(logging.INFO)\n\nimport h5py\nimport logging\nfrom astropy.table import Table, Column\nfrom astropy import units as u\nfrom scipy.interpolate import griddata\n\n\nimport argparse\nparser = argparse.ArgumentParser()\nparser.add_argument(\"-p\",\"--params\", type=str,\n help = \"Parameter file\")\nparser.add_argument(\"-q\", \"--quiet\", help = \"Suppress extra outputs\",\n action = \"store_true\")\nargs = parser.parse_args()\nquiet = args.quiet\n\nparams_root = re.split(\".py\", args.params)[0]\nif os.path.isfile(params_root+\".pyc\"):\n os.remove(params_root+\".pyc\")\n\nimport importlib\ntry:\n params = importlib.import_module(params_root)\n print('Successfully loaded \"{}\" as params'.format(args.params))\n #reload(params)\nexcept:\n print('Failed to load \"{}\" as params'.format(args.params))\n raise\n\nif quiet:\n quietprint = lambda *a: None\nelse:\n def quietprint(*args):\n for arg in args:\n print (arg)\n\n# Fitting function definition for later use by Processess\n\ndef galaxyFit(inputQueue, printQueue, printlock):\n for gal in iter(inputQueue.get, 'STOP'):\n j = np.argmin(np.abs(z-zobs[gal])) # Find closest model redshift\n\n\n flux_obs = obs[gal,:]\n flux_err = obs_err[gal,:]\n\n #flux_obs[fo <= 0.] = 0. # Set negative fluxes to zero\n I = np.where(flux_err > 0.)[0] # Find bands with no observation\n\n if len(I) == 0:\n if include_rest:\n M_scaled = np.ones(len(fo)) * -99.\n restframe_output = ' '.join(M_scaled.astype('str'))\n output_string = '{} {} {} {} {} {} {} {}' \\\n ' {} {} {} {} {} {} {} {} {}'.format(gal+1,ID[gal],zobs[gal],-99,-99,-99,-99,-99,-99, -99, -99,-99,len(I),-99,z[j],restframe_output,'\\n')\n else:\n output_string = '{} {} {} {} {} {} {} {} {} {} {} {} {} {} {}'.format(gal+1,ID[gal],zobs[gal],-99,-99,-99,-99,-99,-99,-99, -99,-99,len(I),-99,'\\n')\n printQueue.put(output_string)\n continue\n\n flux_obs = flux_obs[I] # and exclude from fit\n flux_err = flux_err[I]\n flux_models = f[j,I,:]\n\n tot_err = np.sqrt(flux_err**2 + (0.1*flux_obs)**2)\n\n top = 0.\n bottom = 0.\n\n for i in range(len(flux_obs)):\n top += (flux_models[i,:]*flux_obs[i])/(tot_err[i]**2)\n bottom += (flux_models[i,:]**2)/(tot_err[i]**2)\n\n scale = top/bottom\n scale = np.reshape(scale, (n_metal, n_tg, n_tau, n_tauv, n_fesc))\n\n chisq = 0.\n for i in range(len(flux_obs)):\n chisq += ((np.abs(scale*flux_models[i,:]-flux_obs[i])**2)/(flux_err[i])**2)\n\n chimin, minind = np.nanmin(chisq), np.nanargmin(chisq)\n\n if np.isinf(chimin) or np.isnan(minind):\n if include_rest:\n M_scaled = np.ones(len(flux_obs)) * -99.\n restframe_output = ' '.join(M_scaled.astype('str'))\n output_string = '{} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}'.format(gal+1,ID[gal],zobs[gal],-99,-99,-99,-99,-99,-99, -99, -99,-99,len(I),-99,z[j],restframe_output,'\\n')\n else:\n output_string = '{} {} {} {} {} {} {} {} {} {} {} {} {} {} {}'.format(gal+1,ID[gal],zobs[gal],-99,-99,-99,-99,-99,-99,-99, -99,-99,len(I),-99,'\\n')\n printQueue.put(output_string)\n continue\n\n\n #Find the coordinate of the model with the bestfit mass\n mi, tgi, ti, tvi, fi = np.unravel_index(minind,\n (n_metal, n_tg,\n n_tau, n_tauv, n_fesc))\n\n Bestfit_Mass = np.log10(scale[mi, tgi, ti, tvi, fi]*flux_corr)\n Bestfit_SFR = (scale[mi, tgi, ti, tvi, fi] *\n SFR[mi, tgi, ti, tvi, fi]*flux_corr)\n #Bestfit_Beta = beta[tgi,tvi,ti,mi]\n Bestfit_Beta = -99.\n\n #Scale the observed tot_mag band of the template to be the same as the observed tot_mag band of the galaxy\n #Convert the templates so they are no longer units of per stellar mass\n\n F_rest = f[0,:]*scale[mi, tgi, ti, tvi, fi]*flux_corr\n restframeMags = 23.9 - 2.5*np.log10(F_rest)\n\n #UV_rest = UV_flux[0]*scale[tgi,tvi,ti,mi]*flux_corr\n #restframeMUV = 23.9 - 2.5*np.log10(UV_rest)\n\n M_scaled = restframeMags[:, mi, tgi, ti, tvi, fi]\n #MUV_scaled = restframeMUV[tgi,tvi,ti,mi]\n MUV_scaled = -99.\n\n if np.isnan(Bestfit_Mass) or np.isinf(chimin):\n Bestfit_Mass = -99\n #M_scaled[:] = -99\n tgs = -99\n tvs = -99\n taus = -99\n mis = -99\n escape_fraction = -99\n\n else:\n tgs = tg[tgi]/1e9\n tvs = tv[tvi]\n taus = tau[ti]\n mis = metallicities[mi]\n escape_fraction = fesc[fi]\n\n\n printlock.acquire()\n\n print('{:6d} {:8d} {:>5.2f} {:>7.2f} {:>8.1f} {:>8.3f} {:>5.1f} {:>8.2f} {:>4.2f} {:>5.2f}'.format(gal+1,ID[gal], zobs[gal],Bestfit_Mass,chimin,tgs,tvs,taus,mis,np.log10(Bestfit_SFR)))\n\n if include_rest:\n restframe_output = ' '.join(M_scaled.astype('str'))\n output_string = '{} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}'.format(gal+1,ID[gal],zobs[gal],Bestfit_Mass,chimin,tgs,tvs,taus,mis, MUV_scaled, minind,Bestfit_SFR,len(I),Bestfit_Beta,z[j],restframe_output,'\\n')\n else:\n output_string = '{} {} {} {} {} {} {} {} {} {} {} {} {} {} {}'.format(gal+1,ID[gal],zobs[gal],Bestfit_Mass,chimin,tgs,tvs,taus,mis, MUV_scaled, minind,Bestfit_SFR,len(I),Bestfit_Beta,'\\n')\n\n printlock.release()\n printQueue.put(output_string)\n\ndef galaxyFit2(inputQueue, printQueue, printlock):\n for gal in iter(inputQueue.get, 'STOP'):\n\n\n output_string = '{0[0]} {0[1]} {0[2]} {0[3]} {0[4]} {0[5]} ' + \\\n '{0[6]} {0[7]} {0[8]} {0[9]} {0[10]} {0[11]} ' + \\\n '{0[12]} {0[13]} {0[14]}'\n\n j = np.argmin(np.abs(z-zobs[gal])) # Find closest model redshift\n\n log_mass_min, log_mass_max = 7, 13\n log_sfr_min, log_sfr_max = -3, 4\n\n flux_obs = obs[gal,:]\n flux_err = obs_err[gal,:]\n\n #flux_obs[fo <= 0.] = 0. # Set negative fluxes to zero\n #I = np.where(flux_err > 0.)[0] # Find bands with no observation\n I = (flux_err > 0.) * ((filt_lambda / (1+z[j])) < 3e5)\n\n flux_obs = flux_obs[I] * zp_offsets[I] # and exclude from fit\n flux_err = flux_err[I] * zp_offsets[I]\n flux_models = f[j,I,:,j,:]\n\n if params.temp_err != None:\n terr = griddata(terr_wl, terr_sigma, filt_lambda[I] / (1+z[j]))\n tot_err = np.sqrt(flux_err**2 + (terr*flux_obs)**2 + (params.flux_err*flux_obs)**2)\n else:\n tot_err = np.sqrt(flux_err**2 + (params.flux_err*flux_obs)**2)\n\n top = 0.\n bottom = 0.\n\n for i in range(len(flux_obs)):\n top += (flux_models[i,:]*flux_obs[i])/(tot_err[i]**2)\n bottom += (flux_models[i,:]**2)/(tot_err[i]**2)\n\n scale = top/bottom\n scale = np.reshape(scale, (n_metal, n_tau, n_tauv, n_fesc))\n\n chisq = 0.\n for i in range(len(flux_obs)):\n chisq += ((np.abs(scale*flux_models[i,:]-flux_obs[i])**2)/(tot_err[i])**2)\n\n chimin, minind = np.nanmin(chisq), np.nanargmin(chisq)\n likelihood = np.reshape(np.exp(-0.5*chisq),\n (n_metal, n_tau, n_tauv, n_fesc))\n likelihood[np.isnan(likelihood)] = 0.\n likelihood = np.abs(likelihood/likelihood.sum())\n\n if np.isinf(chimin) or np.isnan(minind):\n output_string = '{n} {id} {zobs} {ztemp} {mass_best} {sfr_best} '+ \\\n '{chi_best} {tvs} {taus} {mis} {fesc} '+ \\\n '{mass_med} {mass_l68} {mass_u68} ' + \\\n '{sfr_med} {sfr_l68} {sfr_u68} ' + \\\n '{nfilts} '\n\n output_values = {'n': gal+1,\n 'id': ID[gal],\n 'zobs': zobs[gal], 'ztemp':z[j],\n 'mass_best': -99.,\n 'sfr_best': -99,\n 'chi_best': -99,\n 'tvs': -99, 'taus': -99,\n 'mis': -99, 'fesc': -99,\n 'mass_med': -99, 'mass_l68': -99, 'mass_u68': -99,\n 'sfr_med': -99, 'sfr_l68': -99, 'sfr_u68': -99,\n 'nfilts': np.sum(I)}\n\n output_array = [gal+1, ID[gal], zobs[gal],\n Bestfit_Mass, chimin, tvs, taus, mis,\n MUV_scaled, minind, Bestfit_SFR, np.sum(I), -99., '\\n']\n output = output_string.format(**output_values)\n\n printlock.acquire()\n print_string = \"{0[0]:6d} {0[1]:8d} {0[2]:>5.2f} \" + \\\n \"{0[3]:>7.2f} {0[4]:>8.3f} \" + \\\n \"{0[5]:>5.1f} {0[6]:>8.2f} {0[7]:>4.2f} \" + \\\n \"{0[8]:>5.2f}\"\n\n print_array = [gal+1, ID[gal], zobs[gal],\n -99, -99,\n -99, -99, -99,\n -99]\n print(print_string.format(print_array))\n printlock.release()\n\n else:\n #Find the coordinate of the model with the bestfit mass\n mi, ti, tvi, fi = np.unravel_index(minind,\n (n_metal,\n n_tau, n_tauv, n_fesc))\n\n\n Masses = np.abs(np.log10(scale*flux_corr))\n SFRs = np.log10(scale * SFR[:,j,:] * flux_corr)\n\n mass_hist = np.histogram(Masses.flatten(),\n range = (log_mass_min, log_mass_max),\n bins = 120,\n weights = likelihood.flatten(),\n density = True)\n\n sfr_hist = np.histogram(SFRs.flatten(),\n range = (log_sfr_min, log_sfr_max),\n bins = 140,\n weights = likelihood.flatten(),\n density = True)\n\n Bestfit_Mass = np.abs(np.log10(scale[mi, ti, tvi, fi]*flux_corr))\n Bestfit_SFR = np.abs(np.log10(scale[mi, ti, tvi, fi] *\n SFR[mi, j, ti, tvi, fi]*flux_corr))\n\n Bestfit_fluxes = (scale[mi, ti, tvi, fi] *\n f[j,:, mi, j, ti, tvi, fi] *\n flux_corr)\n\n tgs = tg[j]/1e9\n tvs = tv[tvi]\n taus = tau[ti]\n mis = metallicities[mi]\n escape_fraction = fesc[fi]\n\n m16, m50, m84 = weighted_quantile(Masses.flatten(),\n [0.16, 0.5, 0.84],\n sample_weight=likelihood.flatten(),\n values_sorted=False)\n s16, s50, s84 = weighted_quantile(SFRs.flatten(),\n [0.16, 0.5, 0.84],\n sample_weight=likelihood.flatten(),\n values_sorted=False)\n\n printlock.acquire()\n\n MUV_scaled = -99.\n Bestfit_Beta = -99.\n\n print_string = \"{0[0]:6d} {0[1]:8d} {0[2]:>5.2f} \" + \\\n \"{0[3]:>7.2f} {0[4]:>8.3f} \" + \\\n \"{0[5]:>5.1f} {0[6]:>8.2f} {0[7]:>4.2f} \" + \\\n \"{0[8]:>5.2f}\"\n\n print_array = [gal+1, ID[gal], zobs[gal],\n Bestfit_Mass, chimin,\n tvs, taus, mis,\n Bestfit_SFR]\n print(print_string.format(print_array))\n printlock.release()\n output_string = '{n} {id} {zobs} {ztemp} {mass_best} {sfr_best} '+ \\\n '{chi_best} {tvs} {taus} {mis} {fesc} '+ \\\n '{mass_med} {mass_l68} {mass_u68} ' + \\\n '{sfr_med} {sfr_l68} {sfr_u68} ' + \\\n '{nfilts} '\n\n output_values = {'n': gal+1,\n 'id': ID[gal],\n 'zobs': zobs[gal], 'ztemp':z[j],\n 'mass_best': Bestfit_Mass,\n 'sfr_best': Bestfit_SFR,\n 'chi_best': chimin,\n 'tvs': tvs, 'taus': taus,\n 'mis': mis, 'fesc': escape_fraction,\n 'mass_med': m50, 'mass_l68': m16, 'mass_u68': m84,\n 'sfr_med': s50, 'sfr_l68': s16, 'sfr_u68': s84,\n 'nfilts': np.sum(I)}\n\n output_array = [gal+1, ID[gal], zobs[gal],\n Bestfit_Mass, chimin, tvs, taus, mis,\n MUV_scaled, minind, Bestfit_SFR, np.sum(I), -99., '\\n']\n output = output_string.format(**output_values)\n\n if include_rest:\n if np.isinf(chimin) or np.isnan(minind):\n M_scaled = np.ones(len(flux_obs)) * -99.\n restframe_output = ' '.join(M_scaled.astype('str'))\n output = output + restframe_output + ' \\n'\n\n else:\n F_rest = np.array(f[0, :, mi, j, ti, tvi, fi] *\n scale[mi, ti, tvi, fi] * flux_corr)\n restframeMags = 23.9 - 2.5*np.log10(F_rest)\n restframe_output = ' '.join(restframeMags.astype('str'))\n output = output + restframe_output + ' \\n'\n else:\n output = output + ' \\n'\n\n printQueue.put([gal, output, mass_hist, sfr_hist, Bestfit_fluxes,\n [obs[gal, :], obs_err[gal, :]]])\n\ndef galaxyFitMz(inputQueue, printQueue, printlock):\n for gal in iter(inputQueue.get, 'STOP'):\n\n output_string = '{0[0]} {0[1]} {0[2]} {0[3]} {0[4]} {0[5]} ' + \\\n '{0[6]} {0[7]} {0[8]} {0[9]} {0[10]} {0[11]} ' + \\\n '{0[12]} {0[13]} {0[14]}'\n\n log_mass_min, log_mass_max = 7, 13\n log_sfr_min, log_sfr_max = -3, 4\n\n # Set up output arrays\n chi_z_best = np.zeros(len(z))\n\n m_z_best = np.zeros(len(z))\n m_z_median = np.zeros(len(z))\n m_z_u68 = np.zeros(len(z))\n m_z_l68 = np.zeros(len(z))\n\n sfr_z_best = np.zeros(len(z))\n sfr_z_median = np.zeros(len(z))\n sfr_z_u68 = np.zeros(len(z))\n sfr_z_l68 = np.zeros(len(z))\n\n #m_z_hist = np.zeros((len(z), 120))\n #sfr_z_hist = np.zeros((len(z), 140))\n\n flux_obs = obs[gal,:]\n flux_err = obs_err[gal,:]\n\n #flux_obs[fo <= 0.] = 0. # Set negative fluxes to zero\n I = np.where(flux_err > 0.)[0] # Find bands with no observation\n\n if len(I) == 0:\n output_array = [gal+1, ID[gal], zobs[gal], z[j],\n -99, -99, -99, -99, -99, -99, -99,\n -99,-99,len(I),-99,'\\n']\n output = output_string.format(output_array)\n\n if include_rest:\n M_scaled = np.ones(len(flux_obs)) * -99.\n restframe_output = ' '.join(M_scaled.astype('str'))\n output = output + restframe_output + ' \\n'\n\n else:\n output = output + ' \\n'\n printQueue.put(output_string)\n continue\n\n\n flux_obs = flux_obs[I] # and exclude from fit\n flux_err = flux_err[I]\n tot_err = np.sqrt(flux_err**2 + (params.flux_err*flux_obs)**2)\n\n for j, jz in enumerate(z):\n #j = np.argmin(np.abs(z-zobs[gal])) # Find closest model redshift\n flux_models = f[j,I,:,j]\n\n top = 0.\n bottom = 0.\n\n for i in range(len(flux_obs)):\n top += (flux_models[i,:]*flux_obs[i])/(tot_err[i]**2)\n bottom += (flux_models[i,:]**2)/(tot_err[i]**2)\n\n scale = top/bottom\n scale = np.reshape(scale, (n_metal, n_tau, n_tauv, n_fesc))\n\n chisq = 0.\n for i in range(len(flux_obs)):\n chisq += ((np.abs(scale*flux_models[i,:]-flux_obs[i])**2)/(tot_err[i])**2)\n\n chimin, minind = np.nanmin(chisq), np.nanargmin(chisq)\n likelihood = np.reshape(np.exp(-0.5*chisq),\n (n_metal, n_tau, n_tauv, n_fesc))\n likelihood[np.isnan(likelihood)] = 0.\n likelihood = np.abs(likelihood/likelihood.sum())\n\n\n if np.isinf(chimin) or np.isnan(minind):\n output_array = [gal+1, ID[gal], zobs[gal], z[j],\n -99, -99, -99, -99, -99, -99,\n -99,-99,len(I),-99,'\\n']\n output = output_string.format(output_array)\n\n else:\n #Find the coordinate of the model with the bestfit mass\n mi, ti, tvi, fi = np.unravel_index(minind,\n (n_metal,\n n_tau, n_tauv, n_fesc))\n\n Masses = np.log10(np.abs(scale * flux_corr))\n SFRs = np.log10(np.abs(scale * SFR[:,j] * flux_corr))\n\n \"\"\"\n mass_hist = np.histogram(Masses.flatten(),\n range = (log_mass_min, log_mass_max),\n bins = 120,\n weights = likelihood.flatten(),\n density = True)\n\n sfr_hist = np.histogram(SFRs.flatten(),\n range = (log_sfr_min, log_sfr_max),\n bins = 140,\n weights = likelihood.flatten(),\n density = True)\n \"\"\"\n\n Bestfit_Mass = np.log10(np.abs(scale[mi, ti, tvi, fi]*flux_corr))\n Bestfit_SFR = np.log10(np.abs(scale[mi, ti, tvi, fi]) *\n SFR[mi, j, ti, tvi, fi]*flux_corr)\n\n\n\n if np.isnan(Bestfit_Mass) or np.isinf(chimin):\n Bestfit_Mass = -99\n #M_scaled[:] = -99\n tvs = -99\n taus = -99\n mis = -99\n escape_fraction = -99\n\n else:\n tvs = tv[tvi]\n taus = tau[ti]\n mis = metallicities[mi]\n escape_fraction = fesc[fi]\n\n m16, m50, m84 = weighted_quantile(Masses.flatten(),\n [0.16, 0.5, 0.84],\n sample_weight=likelihood.flatten(),\n values_sorted=False)\n s16, s50, s84 = weighted_quantile(SFRs.flatten(),\n [0.16, 0.5, 0.84],\n sample_weight=likelihood.flatten(),\n values_sorted=False)\n\n chi_z_best[j] = chimin\n m_z_best[j] = Bestfit_Mass\n sfr_z_best[j] = Bestfit_SFR\n\n m_z_l68[j], m_z_median[j], m_z_u68[j] = m16, m50, m84\n sfr_z_l68[j], sfr_z_median[j], sfr_z_u68[j] = s16, s50, s84\n\n MUV_scaled = -99.\n Bestfit_Beta = -99.\n\n printlock.acquire()\n j = np.argmin(np.abs(z-zobs[gal])) # Find closest model redshift\n print_string = \"{0[0]:6d} {0[1]:8d} {0[2]:>5.2f} \" + \\\n \"{0[3]:>7.2f} {0[4]:>8.1f} {0[5]:>8.3f}\"\n\n print_array = [gal+1, ID[gal], zobs[gal],\n m_z_best[j], chi_z_best[j],\n sfr_z_best[j]]\n print(print_string.format(print_array))\n\n output_string = '{n} {id} {zobs} {ztemp} {mass_best} {sfr_best} '+ \\\n '{chi_best} ' + \\\n '{mass_med} {mass_l68} {mass_u68} ' + \\\n '{sfr_med} {sfr_l68} {sfr_u68} ' + \\\n '{nfilts} '\n\n output_values = {'n': gal+1,\n 'id': ID[gal],\n 'zobs': zobs[gal], 'ztemp':z[j],\n 'mass_best': Bestfit_Mass,\n 'sfr_best': Bestfit_SFR,\n 'chi_best': chimin,\n 'mass_med': m50, 'mass_l68': m16, 'mass_u68': m84,\n 'sfr_med': s50, 'sfr_l68': s16, 'sfr_u68': s84,\n 'nfilts': len(I)}\n\n output = output_string.format(**output_values) + ' \\n'\n\n printlock.release()\n printQueue.put([gal, output,\n [m_z_best, sfr_z_best, chi_z_best],\n [m_z_l68, m_z_median, m_z_u68]\n [sfr_z_l68, sfr_z_median, sfr_z_u68]])\n\n\ndef getObservations(inputpath):\n input_data = Table.read(inputpath,format=input_format).filled(-99.)\n\n column_names = list(input_data.columns.keys())\n\n ID = input_data[ID_col]\n zobs = input_data[z_col]\n\n filter_names = []\n\n k,l = 0,0\n for ii in range(len(column_names)):\n if column_names[ii].lower().endswith(flux_col_end.lower()):\n if k == 0:\n fluxes = input_data[column_names[ii]]\n else:\n fluxes = np.column_stack((fluxes,input_data[column_names[ii]]))\n k+=1\n filter_names.append(column_names[ii])\n\n if column_names[ii].lower().endswith(fluxerr_col_end.lower()):\n if l == 0:\n fluxerrs = input_data[column_names[ii]]\n else:\n fluxerrs = np.column_stack((fluxerrs,input_data[column_names[ii]]))\n l+=1\n \"\"\"\n if filts_used != None:\n try:\n fluxes = fluxes[:,filts_used]\n fluxerrs = fluxerrs[:,filts_used]\n except:r\n print('Filter mismatch 1')\n # Array slicing fail\n \"\"\"\n return ID, zobs, fluxes, fluxerrs, k, filter_names\n\nclass _function_wrapper:\n \"\"\"\n This is a hack to make the likelihood function pickleable when ``args``\n or ``kwargs`` are also included.\n\n Stolen from emcee\n \"\"\"\n def __init__(self, f, args, kwargs):\n self.f = f\n self.args = args\n self.kwargs = kwargs\n\n def __call__(self, x):\n try:\n return self.f(x, *self.args, **self.kwargs)\n except:\n import traceback\n print(\"emcee: Exception while calling your likelihood function:\")\n print(\" params:\", x)\n print(\" args:\", self.args)\n print(\" kwargs:\", self.kwargs)\n print(\" exception:\")\n traceback.print_exc()\n raise\n\ndef weighted_quantile(values, quantiles, sample_weight=None, values_sorted=False, old_style=False):\n \"\"\" Very close to np.percentile, but supports weights.\n NOTE: quantiles should be in [0, 1]!\n :param values: np.array with data\n :param quantiles: array-like with many quantiles needed\n :param sample_weight: array-like of the same length as `array`\n :param values_sorted: bool, if True, then will avoid sorting of initial array\n :param old_style: if True, will correct output to be consistent with np.percentile.\n :return: np.array with computed quantiles.\n \"\"\"\n values = np.array(values)\n quantiles = np.array(quantiles)\n if sample_weight is None:\n sample_weight = np.ones(len(values))\n sample_weight = np.array(sample_weight)\n assert np.all(quantiles >= 0) and np.all(quantiles <= 1), 'quantiles should be in [0, 1]'\n\n if not values_sorted:\n sorter = np.argsort(values)\n values = values[sorter]\n sample_weight = sample_weight[sorter]\n\n weighted_quantiles = np.cumsum(sample_weight) - 0.5 * sample_weight\n if old_style:\n # To be convenient with np.percentile\n weighted_quantiles -= weighted_quantiles[0]\n weighted_quantiles /= weighted_quantiles[-1]\n else:\n weighted_quantiles /= np.sum(sample_weight)\n return np.interp(quantiles, weighted_quantiles, values)\n\nif __name__ == '__main__':\n\n logfile = open(\"error.log\", \"w\")\n original_stderr = sys.stderr\n sys.stderr = logfile\n\n start = time.time()\n\n \"\"\"\n SECTION 1\n\n \"\"\"\n model_path = params.model_path\n\n input_catalog = params.input_catalog\n input_format = params.input_format\n z_col = params.z_col\n ID_col = params.ID_col\n flux_col_end = params.flux_col_end\n fluxerr_col_end = params.fluxerr_col_end\n\n ncpus = params.ncpus\n filts_used = params.filts_used\n include_rest = params.include_rest\n\n output_path = params.output_catalog_path\n output_format = params.output_format\n output_hdf_path = params.output_hdf_path\n\n calc_mode = params.fitting_mode\n flux_corr = params.flux_corr\n\n\n ID, zobs, obs, obs_err, filters_found, filter_names = getObservations(input_catalog)\n\n \"\"\"\n Section 2\n\n \"\"\"\n\n\n print(\"Loading synthetic mags and mass array:\")\n models = h5py.File(model_path, 'r')\n tg = models['ages'][()]\n tv = models['dust'][()]\n tau = models['sfh'][()]\n metallicities = models['metallicities'][()]\n fesc = models['fesc'][()]\n\n Mshape = models['fluxes'].shape\n z = models['z']\n nfilts = Mshape[1]\n n_metal = Mshape[2]\n n_tg = Mshape[3]\n n_tau = Mshape[4]\n n_tauv = Mshape[5]\n n_fesc = Mshape[6]\n\n filt_lambda = models['wl'][()]\n #UV_flux = synmags['UV_flux']\n SFR = models['SFR']\n Ms = models['Ms']\n\n if params.zp_offsets != None:\n zp_offsets = Table.read(params.zp_offsets, format='ascii.no_header')['col1']\n\n if params.temp_err != None:\n terr_wl, terr_sigma = np.loadtxt(params.temp_err).T\n\n\n if (nfilts == filters_found) and (filts_used == None):\n f = models['fluxes']\n\n elif (nfilts != filters_found) and (filts_used == None):\n raise Exception('Mis-match between model and observed filter numbers')\n\n elif filts_used != None:\n try:\n f = models['fluxes'][:,filts_used]\n obs = obs[:,filts_used]\n obs_err = obs_err[:,filts_used]\n filter_names = np.array(filter_names)[filts_used]\n except:\n print('Mis-match between model and observed filter numbers')\n raise\n # Slice fail\n\n\n print (\"Done.\")\n\n \"\"\"\n SECTION 3\n \"\"\"\n if os.path.isfile(output_path+\".temp_output.txt\"):\n os.remove(output_path+\".temp_output.txt\")\n temp_file = open(output_path+\".temp_output.txt\",\"w\")\n\n\n \"\"\"\n SECTION 4\n Chi-sq calculation\n\n \"\"\"\n out_string = '{0:6s} {1:8s} {2:>5s} {3:>7s} {4:>8s}' + \\\n '{5:>5s} {6:>8s} {7:>4s} {8:>5s}'\n\n print(out_string.format('N','ID','zobs','Best', 'chimin',\n 'tauv','tau','met', 'sfr'))\n\n loop_start = time.time()\n ncpus = np.clip(ncpus, 1, multiprocessing.cpu_count())\n\n inputQueue = multiprocessing.Queue()\n printQueue = multiprocessing.Queue()\n printlock = multiprocessing.Lock()\n\n if calc_mode == 'hist':\n output_hdf = h5py.File(output_hdf_path, 'w')\n output_hdf.create_dataset(\"mass_pdf\", (len(ID), 120), dtype=\"f\")\n output_hdf.create_dataset(\"sfr_pdf\", (len(ID), 140), dtype=\"f\")\n output_hdf.create_dataset(\"fit_flux\", (len(ID), f.shape[1]), dtype=\"f\")\n output_hdf.create_dataset(\"obs_flux\", (len(ID), f.shape[1]), dtype=\"f\")\n output_hdf.create_dataset(\"obs_fluxerr\", (len(ID), f.shape[1]),\n dtype=\"f\")\n output_hdf.create_dataset(\"lambda_filt\", data = models[\"wl\"])\n output_hdf.create_dataset(\"fwhm_filt\", data = models[\"fwhm\"])\n\n fitFunction = galaxyFit2\n\n elif calc_mode == 'Mz':\n output_hdf = h5py.File(output_hdf_path, 'w')\n\n output_hdf.create_dataset(\"m_z_best\", (len(ID), len(z)), dtype=\"f\")\n output_hdf.create_dataset(\"sfr_z_best\", (len(ID), len(z)), dtype=\"f\")\n output_hdf.create_dataset(\"chi_z_best\", (len(ID), len(z)), dtype=\"f\")\n\n output_hdf.create_dataset(\"m_z_median\", (len(ID), len(z)), dtype=\"f\")\n output_hdf.create_dataset(\"m_z_l68\", (len(ID), len(z)), dtype=\"f\")\n output_hdf.create_dataset(\"m_z_u68\", (len(ID), len(z)), dtype=\"f\")\n\n output_hdf.create_dataset(\"sfr_z_median\", (len(ID), len(z)), dtype=\"f\")\n output_hdf.create_dataset(\"sfr_z_u68\", (len(ID), len(z)), dtype=\"f\")\n output_hdf.create_dataset(\"sfr_z_l68\", (len(ID), len(z)), dtype=\"f\")\n\n output_hdf.create_dataset(\"z\", data=z)\n\n fitFunction = galaxyFitMz\n else:\n fitFunction = galaxyFit\n\n for i in range( ncpus ):\n multiprocessing.Process(target = fitFunction,\n args = (inputQueue, printQueue,\n printlock)).start()\n\n # Put elements in the send queue for processing\n for gal in range( len(ID) ):\n inputQueue.put( gal )\n\n if calc_mode == 'hist':\n for i, gal in enumerate(ID):\n j, out, mass_hist, sfr_hist, fit_flux, obs_flux = printQueue.get()\n\n if i == 0:\n mass_centers = 0.5*(mass_hist[1][1:] + mass_hist[1][:-1])\n sfr_centers = 0.5*(sfr_hist[1][1:] + sfr_hist[1][:-1])\n\n output_hdf.create_dataset(\"mass_bins\", data = mass_centers)\n output_hdf.create_dataset(\"sfr_bins\", data = sfr_centers)\n\n output_hdf[\"mass_pdf\"][j] = mass_hist[0]\n output_hdf[\"sfr_pdf\"][j] = sfr_hist[0]\n output_hdf[\"fit_flux\"][j] = fit_flux\n output_hdf[\"obs_flux\"][j] = obs_flux[0]\n output_hdf[\"obs_fluxerr\"][j] = obs_flux[1]\n\n temp_file.write( out )\n\n elif calc_mode == 'Mz':\n for i, gal in enumerate(ID):\n j, out, pz_best, mz_median, sfrz_median = printQueue.get()\n\n output_hdf[\"m_z_best\"][j,:] = pz_best[0]\n output_hdf[\"sfr_z_best\"][j,:] = pz_best[1]\n output_hdf[\"chi_z_best\"][j,:] = pz_best[2]\n\n output_hdf[\"m_z_l68\"][j,:] = mz_median[0]\n output_hdf[\"m_z_median\"][j,:] = mz_median[1]\n output_hdf[\"m_z_u68\"][j,:] = mz_median[2]\n\n output_hdf[\"sfr_z_l68\"][j,:] = sfrz_median[0]\n output_hdf[\"sfr_z_median\"][j,:] = sfrz_median[1]\n output_hdf[\"sfr_z_u68\"][j,:] = sfrz_median[2]\n\n temp_file.write( out )\n else:\n for i, gal in enumerate(ID):\n printout = printQueue.get()\n temp_file.write( printout )\n #print len(mass_array), len(muv_array), len(beta_array)\n\n\n # Stop all the running processes\n for i in range( ncpus ):\n inputQueue.put( 'STOP' )\n\n # Close both send and receive queues\n inputQueue.close()\n printQueue.close()\n\n temp_file.close()\n models.close()\n output_hdf.close()\n print(\"Fitting time taken: {:.2f} {}\".format(time.time()-loop_start,\n '\\n'))\n\n \"\"\"\n Section 3\n Reload, format and save output table\n \"\"\"\n while temp_file.closed == False:\n pause(0.1)\n\n data = np.loadtxt(output_path+\".temp_output.txt\")\n try:\n rows, cols = data.shape\n except:\n cols = len(data)\n\n output = Table()\n\n names = ['N', 'ID', 'z', 'zmodel',\n 'Mass_best', 'SFR_best', 'chi_best',\n 'Dust_best', 'SFH_best',\n 'Metallicity_best', 'fesc_best',\n 'Mass_median', 'Mass_l68', 'Mass_u68',\n 'SFR_median', 'SFR_l68', 'SFR_u68',\n 'Nfilts']\n\n units = [None, None, None, None,\n u.Msun, u.Msun/u.yr, None,\n None, None,\n None, None,\n u.Msun, u.Msun, u.Msun,\n u.Msun/u.yr, u.Msun/u.yr, u.Msun/u.yr,\n None]\n\n types = ['i4', 'i4', 'f4', 'f4',\n 'f4', 'f4', 'f4',\n 'f4', 'f4',\n 'f4', 'f4',\n 'f4', 'f4', 'f4',\n 'f4', 'f4', 'f4',\n 'i4']\n\n if include_rest:\n for name in filter_names:\n names.append(name[:-len(flux_col_end)]+'_rest')\n units.append(u.mag)\n types.append('f4')\n\n for col in range(cols):\n column = Column( data[:,col], name = names[col], unit=units[col], dtype=types[col])\n output.add_column(column)\n\n table_format = params.output_format\n output.sort('ID')\n if os.path.isfile(output_path):\n os.remove(output_path)\n output.write(output_path,format=table_format, overwrite=True)\n print('Catalog saved')\n\n os.remove(temp_file.name)\n\n print('\\n')\n print(\"Total time taken: \"+str(time.time()-start))\n\n sys.stderr = original_stderr\n logfile.close()\n", "meta": {"hexsha": "6b48c40c998b401f11b9c5fed2381fe149f1c4ac", "size": 33271, "ext": "py", "lang": "Python", "max_stars_repo_path": "scripts/fitting.py", "max_stars_repo_name": "dunkenj/smpy", "max_stars_repo_head_hexsha": "2c7ad73726e8fcfbbdf3667a918f60890c84673f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 12, "max_stars_repo_stars_event_min_datetime": "2015-04-09T13:51:38.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-25T00:25:05.000Z", "max_issues_repo_path": "scripts/fitting.py", "max_issues_repo_name": "bamford/smpy", "max_issues_repo_head_hexsha": "2c7ad73726e8fcfbbdf3667a918f60890c84673f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2015-04-29T13:00:12.000Z", "max_issues_repo_issues_event_max_datetime": "2021-02-17T13:50:16.000Z", "max_forks_repo_path": "scripts/fitting.py", "max_forks_repo_name": "dunkenj/smpy", "max_forks_repo_head_hexsha": "2c7ad73726e8fcfbbdf3667a918f60890c84673f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2015-08-12T13:15:10.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-07T14:05:43.000Z", "avg_line_length": 37.0088987764, "max_line_length": 228, "alphanum_fraction": 0.4974602507, "include": true, "reason": "import numpy,from scipy,from astropy", "num_tokens": 8858, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5195213219520929, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.19997006613770812}} {"text": "import numpy as np\nfrom numpy.random import uniform\nimport json\nimport math\nfrom utils.quaternion import Quaternion\nfrom utils.quaternion import computeAngVel, computeAngVelRel\n\nfrom Kinematic.py import KinematicCore\n\nclass JointType():\n BASE = 0\n FIXED = 1\n REVOLUTE = 2\n SPHERE = 3\n\n# pose dof for joints\nDof = {\n JointType.BASE: 4,\n JointType.FIXED: 0,\n JointType.REVOLUTE: 1,\n JointType.SPHERE: 4,\n}\n\n# exp dof for joints\nExpDof = {\n JointType.BASE: 0,\n JointType.FIXED: 0,\n JointType.REVOLUTE: 1,\n JointType.SPHERE: 3,\n}\n\nNAME2TYPE={\n \"none\": JointType.BASE,\n \"fixed\": JointType.FIXED,\n \"revolute\": JointType.REVOLUTE,\n \"spherical\": JointType.SPHERE,\n}\n\nPOSE2QUAT={\n JointType.BASE: lambda x: Quaternion(x[0], x[1], x[2], x[3]),\n JointType.FIXED: lambda x: Quaternion(1, 0, 0, 0),\n JointType.REVOLUTE: lambda x: Quaternion(math.cos(x/2), 0.0, 0.0, math.sin(x/2)),\n JointType.SPHERE: lambda x: Quaternion(x[0], x[1], x[2], x[3]),\n}\n\nVEL2OMG={\n JointType.BASE: lambda x: np.array([x[0], x[1], x[2]]),\n JointType.FIXED: lambda x: np.array([0, 0, 0]),\n JointType.REVOLUTE: lambda x: np.array([0, 0, x[0]]),\n JointType.SPHERE: lambda x: np.array([x[0], x[1], x[2]]),\n}\n\nclass Joint(object):\n def __init__(self, info):\n \"\"\"\n Inputs:\n info json item load from character file\n \"\"\"\n self._pos = np.array([info[\"AttachX\"], info[\"AttachY\"], info[\"AttachZ\"]])\n self._name = info[\"Name\"]\n self._parent_id = info[\"Parent\"]\n self._parent = None\n self._type_name = info['Type']\n self._type = NAME2TYPE[info['Type']]\n self._dof = Dof[self._type]\n self._expdof = ExpDof[self._type]\n self._w = info[\"DiffWeight\"]\n self._is_end_effector = info[\"IsEndEffector\"]\n\n if self._type is JointType.REVOLUTE:\n self._torque_lim = [info[\"TorqueLim\"]]\n elif self._type is JointType.SPHERE:\n if \"TorqueLimX\" not in info:\n self._torque_lim = [info[\"TorqueLim\"]]*4\n else:\n self._torque_lim = [info[\"TorqueLimX\"], info[\"TorqueLimY\"], info[\"TorqueLimZ\"], 0]\n else:\n self._torque_lim = [0]*4\n\n if self._type is JointType.REVOLUTE:\n self.limlow = np.array([info[\"LimLow0\"]])\n self.limhigh = np.array([info[\"LimHigh0\"]])\n elif self._type is JointType.SPHERE:\n self.limlow = -3.14 * np.ones(3)\n self.limhigh = 3.14 * np.ones(3)\n else:\n self.limlow = np.array([])\n self.limhigh = np.array([])\n\n self.pose = np.zeros(self._dof)\n self.pose2quat = POSE2QUAT[self._type]\n self.quat = Quaternion(1, 0, 0, 0)\n\n self.vel = np.zeros(self._dof)\n self.vel2omg = VEL2OMG[self._type]\n self.omg = np.zeros(3)\n\n def __unicode__(self):\n info = u\"Joint: name %s, pos %s, parent %d\" % (self._name, str(self._pos), self._parent_id)\n return info\n\n __str__ = __unicode__\n __repr__= __unicode__\n\n def dof(self):\n return self._dof\n\n def expdof(self):\n return self._expdof\n\n def local_pos(self):\n return self._pos\n\n def set_pose(self, pose):\n assert(pose.shape == self.pose.shape)\n self.pose = pose\n # calculate quat\n self.quat = self.pose2quat(pose)\n\n def set_vel(self, vel):\n assert(vel.shape == self.vel.shape)\n self.omg = self.vel2omg(vel)\n\n def get_quat(self):\n return self.quat\n\n def get_omg(self):\n return self.omg\n\n def get_parent(self):\n return self._parent_id\n\n def get_a_min(self):\n std = (self.limhigh - self.limlow) / 2\n mean = (self.limhigh + self.limlow) / 2\n a_min = mean - std*2\n return a_min\n\n def get_a_max(self):\n std = (self.limhigh - self.limlow) / 2\n mean = (self.limhigh + self.limlow) / 2\n a_max = mean + std*2\n return a_max\n\nclass Body:\n def __init__(self, info):\n self._info = info\n self._pos = np.array([info[\"AttachX\"], info[\"AttachY\"], info[\"AttachZ\"]])\n self._name = info[\"Name\"]\n self._joint_id = info[\"ID\"]\n\n def get_joint_id(self):\n return self._joint_id\n\n def get_local_pos(self):\n return self._pos\n \n def get_body_name(self):\n return self._name\n \n def get_body_shape(self):\n return self._info[\"Shape\"]\n \n def get_body_size(self):\n ar = np.array([self._info[\"Param0\"], self._info[\"Param1\"], self._info[\"Param2\"]])\n shape = self.get_body_shape()\n if shape == \"sphere\":\n ar /= 2.0\n if shape == \"capsule\":\n ar[0] /= 2.0\n ar[2] /= 2.0\n return ar\n\nclass HumanoidSkeleton(object):\n \"\"\" Store humanoid skeleton information, can perform following functions:\n\n 1) compute link positions and velocities when given character pose and vel\n 2) construct character state when given root position and orintaion\n 3) slerp between two character poses\n 4) transfer between action and target poses\n\n __init__()\n _calc_kin_info()\n _calc_ctrl_info()\n\n set_pose()\n\n set_vel()\n\n build_state()\n\n slerp()\n\n pose representation:\n - root pos (x, y, z)\n - root rot (w, x, y, z) in world frame\n - joint rots theta or (w, z, y, z) in local frame, VelRel\n\n vel w/ padding representation:\n - root vel (vx, vy, vz)\n - root angular vel (wx, wy, wz) in world frame\n - joint angular vel w or (wx, wy, wz, 0) in local frame, VelRel\n\n vel w/o padding representation\n - root vel (vx, vy, vz)\n - root angular vel (wx, wy, wz) in world frame\n - joint angular vel w or (wx, wy, wz) in local frame, VelRel\n\n state\n - Y coordinate of origin pos\n - Root link's pos (x, y, z) in xyz coordinate\n - Root link's quat (W, X, Y, Z) in XYZ coordinate\n - Other links' pos (x, y, z) and quat (w, x, y, z) in xyz coordinate\n - Root link's vel (Vx, Vy, Vz) in XYZ coordinate\n - Root link's omega (Wx, Wy, Wz) in XYZ coordinate\n - Other links' vel (vx, vy, vz) and omg (wx, wy, wz) in xyz coordinate\n\n xyz's origin is set by origin_pos, or character's root joint\n xyz's rotation is calculated by rotating Y-axis to make X-axis to heading\n direction calculated by origin_rot or root joint's rotation\n\n action\n - no root pose or joint\n - angle-axis (\\theta, nx, ny, nz) for spherical joints and \\theta for\n revolute joints\n\n action represented in exponential map\n - no root pose or joint\n - exponential map (\\Omega_x, \\Omega_y, \\Omega_z) for spherical joints and\n \\theta for revolute joints\n \"\"\"\n\n def __init__(self, char_file, ctrl_file):\n # NOTICE humanoid.txt and humanoid.urdf have different scales, urdf is 4x larger\n self._kin_core = KinematicCore.cKinematicCore(char_file)\n\n ### all private members\n self.joints = None\n self.bodys = None\n self.dof = None\n self.expdof = None\n\n # TODO move to function\n self.num_joints = None\n self.joint_types = None\n self.joint_dof = None\n self.pos_start = None # start position in pose/vel vec\n self.act_start = None # start position in action vec\n self.joint_w = None\n\n # control configuration\n self.kp = None\n self.kd = None\n self.a_max = None\n self.a_min = None\n\n ### all private members\n self._calc_kin_info(char_file)\n self._calc_ctrl_info(ctrl_file)\n\n def _calc_kin_info(self, char_file):\n # handle character skeleton information\n with open(char_file, 'r') as f:\n json_data = json.load(f)\n joints_data = json_data[\"Skeleton\"][\"Joints\"]\n bodys_data = json_data[\"BodyDefs\"]\n\n # build for pose/vel transfer\n self.joints = list(map(lambda x: Joint(x), joints_data))\n self.bodys = list(map(lambda x: Body(x), bodys_data))\n\n self.dof = sum(map(lambda x: x.dof(), self.joints)) + 3\n self.expdof = sum(map(lambda x: x.expdof(), self.joints))\n\n # build velocity padding - compressing\n self.comp2pad = [0, 1, 2] # root vel\n p_off = 3\n for j in self.joints:\n if j.dof() == 1:\n self.comp2pad += [p_off]\n p_off += 1\n if j.dof() == 4:\n self.comp2pad += [p_off, p_off+1, p_off+2]\n p_off += 4\n\n self.comp2pad = np.array(self.comp2pad, dtype=np.int)\n\n # build joint infomation mat\n self.num_joints = len(self.joints)\n self.joint_types = list(map(lambda x: x._type, self.joints))\n self.joint_w = list(map(lambda x: x._w, self.joints))\n self.joint_dof = list(map(lambda x: x.dof(), self.joints))\n self.joint_dof = np.array(self.joint_dof, dtype=np.int)\n self.joint_expdof = list(map(lambda x: x.expdof(),self.joints))\n self.joint_expdof = np.array(self.joint_expdof, dtype=np.int)\n self.end_effectors = list(filter(\n lambda x: self.joints[x]._is_end_effector,\n range(self.num_joints)))\n\n self.pos_start = np.zeros(self.num_joints, dtype=np.int) # start offset for each joint in pos vector\n for i in range(1, self.num_joints):\n self.pos_start[i] = self.pos_start[i-1] + self.joint_dof[i-1]\n\n self.exp_start = np.zeros(self.num_joints, dtype=np.int) # start offset for each joint in exp vector\n for i in range(1, self.num_joints):\n self.exp_start[i] = self.exp_start[i-1] + self.joint_expdof[i-1]\n\n self.pos_start += 3 # offset for root pos\n self.act_start = self.pos_start - 7 # 7 dim for root pos and root joint\n # so the act_start[0] is meaningless\n\n self.joint_mat = np.array([\n self.joint_types, self.joint_dof,\n self.pos_start, self.act_start,\n ], dtype=np.int)\n self.joint_mat = self.joint_mat.transpose()\n\n def _calc_ctrl_info(self, ctrl_file):\n \"\"\" Build Kp, Kd and torque_lim\n \"\"\"\n # handle controller information\n with open(ctrl_file, 'r') as f:\n data = json.load(f)\n controller = data[\"PDControllers\"]\n assert(len(data[\"PDControllers\"]) == self.num_joints)\n\n self.kp = [0,0,0] # for root pos\n self.kd = [0,0,0] # for root pos\n self.torque_lim = [0, 0, 0] # for root pos\n for i in range(self.num_joints):\n if self.joint_types[i] is not JointType.FIXED:\n self.kp += [controller[i][\"Kp\"]] * self.joint_dof[i]\n self.kd += [controller[i][\"Kd\"]] * self.joint_dof[i]\n self.torque_lim += self.joints[i]._torque_lim\n\n self.kp = np.array(self.kp)\n self.kd = np.array(self.kd)\n self.torque_lim = np.array(self.torque_lim)\n\n def build_a_min(self):\n a_mins = [j.get_a_min() for j in self.joints]\n a_min = np.concatenate(a_mins)\n assert(a_min.size == self.expdof)\n return a_min\n\n def build_a_max(self):\n a_maxs = [j.get_a_max() for j in self.joints]\n a_max = np.concatenate(a_maxs)\n assert(a_max.size == self.expdof)\n return a_max\n\n def get_link_ids(self):\n return list(range(len(self.bodys)))\n\n def get_link_names(self):\n return list(map(lambda body: body.get_body_name(), self.bodys))\n\n def get_link_shapes(self):\n return list(map(lambda body: body.get_body_shape(), self.bodys))\n\n def get_link_sizes(self):\n return list(map(lambda body: body.get_body_size().tolist(), self.bodys))\n\n def set_pose(self, pose):\n \"\"\" Set character's pose\n\n Inputs:\n pose np.array of float, should be equal to self.dof\n \"\"\"\n assert(pose.size == self.dof)\n self._kin_core.setPose(pose)\n\n def set_vel(self, vel):\n \"\"\" Set character's velocity\n\n *NOTICE* set_pose should be already called\n\n Inputs:\n vel numpy array of velocity, shoubld be equal to self.dof\n \"\"\"\n assert(vel.size == self.dof)\n self._kin_core.setVel(vel)\n\n def set_heading_vec(self, head):\n \"\"\" Set heading vector\n\n \"\"\"\n assert(len(head) == 3)\n self._kin_core.setHeadingVec(head)\n\n def build_state(self, origin_pos=None, origin_rot=None, root_global=True):\n \"\"\" Build character state\n\n Inputs:\n origin_pos new coordinate's origin (x, y, z)\n origin_rot reference rotation (w, x, y, z), then a heading direction\n is calculated as new coordinate's x-axis\n\n Outputs:\n state np.array of float\n \"\"\"\n if origin_pos is None and origin_rot is None:\n state = self._kin_core.buildState()\n state = np.array(state)\n elif origin_pos is not None and origin_rot is not None:\n state = self._kin_core.buildState(origin_pos, origin_rot, root_global)\n else:\n raise ValueError(\"not implemented yet\")\n return state\n\n def build_state2(self):\n state = self._kin_core.buildState2()\n return np.array(state)\n\n def get_com_pos(self):\n \"\"\" Return CoM position\n\n *NOTICE* set_pose should be already called\n \"\"\"\n return np.array(self._kin_core.getCoMPos())\n\n def get_com_vel(self):\n \"\"\" Return CoM velocity\n\n *NOTICE* set_pose and set_vel should be already called\n \"\"\"\n return np.array(self._kin_core.getCoMVel())\n\n def slerp(self, pose0, pose1, t):\n \"\"\" slerp between two poses\n\n Inputs:\n pose0 np.array of float, start pose\n pose1 np.array of float, end pose\n t float in [0, 1], interpolating parameter\n\n Outputs:\n pose_t np.array of float, interpolated pose\n \"\"\"\n\n assert(pose0.size == self.dof)\n assert(pose1.size == self.dof)\n\n pose_t = self._kin_core.slerp(pose0, pose1, t)\n pose_t = np.array(pose_t)\n\n return pose_t\n\n def computeVel(self, pose0, pose1, dt, padding=True):\n \"\"\" Compute velocity between two poses\n\n Inputs:\n pose0 np.array of float, start pose\n pose1 np.array of float, end pose\n dt float, duraction between two poses\n\n Outputs:\n avg_vel np.array of float, vel (w/ or w/o padding)\n \"\"\"\n assert(pose0.size == self.dof)\n assert(pose1.size == self.dof)\n\n avg_vel = np.zeros_like(pose0)\n\n root0 = pose0[:3]\n root1 = pose1[:3]\n avg_vel[:3] = (root1 - root0) / dt\n\n offset = 3\n\n # root angular velocity is in world coordinate\n dof = self.joint_dof[0]\n quat0 = Quaternion.fromWXYZ(pose0[offset:offset+dof])\n quat1 = Quaternion.fromWXYZ(pose1[offset:offset+dof])\n avg_vel[offset : offset+3] = computeAngVel(quat0, quat1, dt)\n offset += dof\n\n # other joints\n for i in range(1, self.num_joints):\n dof = self.joint_dof[i]\n if dof == 1: # revolute\n theta0 = pose0[offset]\n theta1 = pose1[offset]\n avg_vel[offset] = (theta1 - theta0) / dt\n elif dof == 4: # spherical\n quat0 = Quaternion.fromWXYZ(pose0[offset:offset+dof])\n quat1 = Quaternion.fromWXYZ(pose1[offset:offset+dof])\n avg_vel[offset : offset+3] = computeAngVelRel(quat0, quat1, dt)\n offset += dof\n\n if padding is False:\n avg_vel = avg_vel[self.comp2pad]\n\n return avg_vel\n\n def toLocalFrame(self, pose, vel, ori_pos=None, ori_rot=None):\n \"\"\" Convert pose and vel from world frame to local frame,\n the local frame heading direction is rotated x-axis\n\n Inputs:\n pose np.array of float, character pose\n vel np.array of float, character vel w/ padding\n ori_pos np.array of float, 3 dim, position of local coordinate origin\n ori_rot np.array of float, 4 dim, (w, x, y, z) quat of local coordinate orientation\n\n Outputs:\n local_pose\n local_vel\n \"\"\"\n if ori_pos is None:\n ori_pos = pose[:3]\n if ori_rot is None:\n ori_rot = pose[3:7]\n\n # heading theta\n inv_ori_rot = self.buildHeadingTrans(ori_rot)\n\n local_pos = pose.copy()\n local_vel = vel.copy()\n\n # ignore y difference, because local cooridnate shares xoz plane with world\n local_pos[0] -= ori_pos[0] # root x pos\n local_pos[2] -= ori_pos[2] # root y pos\n\n ori_rot = Quaternion.fromWXYZ(ori_rot)\n ori_rot = inv_ori_rot.mul(ori_rot)\n local_pos[3:7] = ori_rot.pos_wxyz() # root orientation\n\n local_vel[:3] = inv_ori_rot.rotate(vel[:3]) # root velocity\n local_vel[3:6] = inv_ori_rot.rotate(vel[3:6]) # root angular velocity\n\n return local_pos, local_vel\n\n def buildHeadingTrans(self, rot):\n \"\"\" Build the rotation that rotate to local coordinate\n rot np.array of float, 4 dim, (w, x, y, z) quat of coordinate orientation\n \"\"\"\n theta = self._kin_core.getHeadingTheta(rot)\n inv_rot = Quaternion.fromExpMap(np.array([0, -theta, 0]))\n return inv_rot\n\n def compressVel(self, vel):\n \"\"\" Squeeze velocity from padded to compressed\n\n Inputs:\n vel np.array of float, vel w/ padding\n\n Outputs:\n vel_cmp np.array of float, vel w/o padding\n \"\"\"\n vel_cmp = vel[self.comp2pad]\n return vel_cmp\n\n def padVel(self, vel):\n \"\"\" Pad velocity from compressed to padded\n\n Inputs:\n vel np.array of float, vel w/o padding\n\n Outputs:\n vel_pad np.array of float, vel w/ padding\n \"\"\"\n vel_pad = np.zeros(self.dof)\n vel_pad[self.comp2pad] = vel\n return vel_pad\n\n def action_to_targ_pose(self, action):\n \"\"\" Converte action to PD controller target pose\n\n Inputs:\n action np.array of float, action which DeepMimicSim can take in\n\n Outputs:\n pose np.array of float, pose of character\n \"\"\"\n assert(action.size == self.dof - 7)\n\n targ_pose = np.zeros(self.dof)\n targ_pose[3] = 1\n for i in range(1, self.num_joints):\n dof = self.joint_dof[i]\n p_off = self.pos_start[i]\n a_off = self.act_start[i]\n if dof == 1: # revolute\n targ_pose[p_off] = action[a_off]\n elif dof == 4: # spherical\n angle = action[a_off]\n axis = action[a_off+1:a_off+4]\n quata = Quaternion.fromAngleAxis(angle, axis)\n targ_pose[p_off : p_off+4] = quata.wxyz()\n\n assert(np.isfinite(sum(targ_pose))), embed() #(action, targ_pose)\n return targ_pose\n\n def targ_pose_to_action(self, pose):\n \"\"\" Convert desired pose to action\n\n Inputs:\n pose np.array of float, pose of character\n\n Outputs:\n action np.array of float, action which DeepMimicSim can take in\n \"\"\"\n assert(pose.size == self.dof)\n\n action = np.zeros(self.dof-7)\n for i in range(1, self.num_joints):\n dof = self.joint_dof[i]\n p_off = self.pos_start[i]\n a_off = self.act_start[i]\n if dof == 1: # revolute\n action[a_off] = pose[p_off]\n elif dof == 4: # spherical\n quata = Quaternion.fromWXYZ(pose[p_off:p_off+4])\n action[a_off : a_off+4] = quata.angaxis()\n\n assert(np.isfinite(sum(action))), embed() #(action, targ_pose)\n return action\n\n def action_as_offset(self, pose, action):\n \"\"\" Take action as offset of a given reference pose, return standard action\n\n Inputs:\n pose np.array of float, pose of character\n action np.array of float, offset action to the character\n\n Outputs:\n new_action np.array of float, standard action which DeepMimicSim can take in\n \"\"\"\n assert(pose.size == self.dof)\n assert(action.size == self.dof - 7)\n\n new_action = self._kin_core.actionAsOffset(pose, action.tolist())\n\n return new_action\n\n def exp_to_action(self, expmap):\n \"\"\" Convert action represented in exponential map to angle-axis action\n which deepmimic_sim can take in\n\n Inputs:\n expmap np.array of float, action represented in exponential map\n\n Outputs:\n action np.array of float, action for deepmimic environment\n \"\"\"\n assert(expmap.size == self.expdof)\n action = np.zeros(self.dof-7)\n\n for i in range(1, self.num_joints):\n dof = self.joint_dof[i]\n e_off = self.exp_start[i]\n a_off = self.act_start[i]\n if dof == 1: # revolute\n action[a_off] = expmap[e_off]\n elif dof == 4: # spherical\n quata = Quaternion.fromExpMap(expmap[e_off:e_off+3])\n action[a_off:a_off+4] = quata.angaxis()\n\n assert(np.isfinite(sum(action))), embed() #(action, targ_pose)\n return action\n\n\n def exp_to_targ_pose(self, expmap, padding=True):\n \"\"\" Convert action represented in exponential map to angle-axis action\n which deepmimic_sim can take in\n\n Inputs:\n expmap np.array of float, action represented in exponential map\n\n Outputs:\n pose np.array of float, pose of character\n \"\"\"\n assert(expmap.size == self.expdof)\n return self._kin_core.expMapToTargetPose(expmap.tolist(), padding)\n\n def exp_to_targ_pose_old(self, expmap):\n \"\"\" Convert action represented in exponential map to angle-axis action\n which deepmimic_sim can take in\n\n Inputs:\n expmap np.array of float, action represented in exponential map\n\n Outputs:\n pose np.array of float, pose of character\n \"\"\"\n assert(expmap.size == self.expdof)\n pose = np.zeros(self.dof)\n\n for i in range(1, self.num_joints):\n dof = self.joint_dof[i]\n e_off = self.exp_start[i]\n p_off = self.pos_start[i]\n if dof == 1: # revolute\n pose[p_off] = expmap[e_off]\n elif dof == 4: # spherical\n quata = Quaternion.fromExpMap(expmap[e_off:e_off+3])\n pose[p_off:p_off+4] = quata.wxyz()\n\n assert(np.isfinite(sum(pose))), embed() #(action, targ_pose)\n return pose\n\n def targ_pose_to_exp(self, pose):\n \"\"\" Convert target pose to exponential map, used as initialization of\n Actor_FDM reference memory\n\n Inputs:\n pose np.array of float, pose of character\n\n Outputs:\n exp np.array of float, action represented in exponential map\n \"\"\"\n assert(pose.size == self.dof)\n\n expmap = np.zeros(self.expdof)\n for i in range(1, self.num_joints):\n dof = self.joint_dof[i]\n p_off = self.pos_start[i]\n e_off = self.exp_start[i]\n if dof == 1: # revolute\n expmap[e_off] = pose[p_off]\n elif dof == 4: # spherical\n quata = Quaternion.fromWXYZ(pose[p_off:p_off+4])\n expmap[e_off : e_off+3] = quata.expmap()\n\n assert(np.isfinite(sum(expmap))), embed() #(action, targ_pose)\n return expmap\n\n def normalize_target_pose(self, pose):\n \"\"\"\n normalize given pose to make quaternions norm as 1\n \"\"\"\n assert(pose.size == self.dof)\n norm_pose = pose.copy()\n for i in range(self.num_joints):\n dof = self.joint_dof[i]\n p_off = self.pos_start[i]\n if dof == 4: # spherical\n quata = Quaternion.fromWXYZ(pose[p_off:p_off+4])\n norm_pose[p_off : p_off+4] = quata.pos_wxyz()\n\n assert(np.isfinite(sum(norm_pose))), embed() #(action, targ_pose)\n return norm_pose\n\n def pose_wxyz_to_xyzw(self, pose):\n pose_new = pose.copy()\n\n p_off = 3\n quat = pose[p_off:p_off+4]\n pose_new[p_off:p_off+3] = quat[1:]\n pose_new[p_off+3] = quat[0]\n\n for i in range(1, self.num_joints):\n dof = self.joint_dof[i]\n p_off = self.pos_start[i]\n if dof == 4:\n quat = pose[p_off:p_off+4]\n pose_new[p_off:p_off+3] = quat[1:]\n pose_new[p_off+3] = quat[0]\n\n return pose_new\n\n def get_reward(self, pose0, vel0, pose1, vel1):\n assert(len(pose0) == self.dof), \"pose 0 size missmatch\"\n assert(len(pose1) == self.dof), \"pose 1 size missmatch\"\n assert(len(vel0) == self.dof), \"vel 0 size missmatch\"\n assert(len(vel1) == self.dof), \"vel 1 size missmatch\"\n return self._kin_core.calcReward(pose0, vel0, pose1, vel1)\n\n def get_reward2(self, pose0, vel0, pose1, vel1):\n assert(len(pose0) == self.dof), \"pose 0 size missmatch\"\n assert(len(pose1) == self.dof), \"pose 1 size missmatch\"\n assert(len(vel0) == self.dof), \"vel 0 size missmatch\"\n assert(len(vel1) == self.dof), \"vel 1 size missmatch\"\n return self._kin_core.calcReward2(pose0, vel0, pose1, vel1)\n\n def get_err_vec(self, pose0, vel0, pose1, vel1):\n assert(len(pose0) == self.dof), \"pose 0 size missmatch\"\n assert(len(pose1) == self.dof), \"pose 1 size missmatch\"\n assert(len(vel0) == self.dof), \"vel 0 size missmatch\"\n assert(len(vel1) == self.dof), \"vel 1 size missmatch\"\n self._kin_core.calcReward(pose0, vel0, pose1, vel1)\n return np.array(self._kin_core.getErrorVec())\n\n def get_sub_rewards(self, pose0, vel0, pose1, vel1):\n err_vec = self.get_err_vec(pose0, vel0, pose1, vel1)\n scale = np.array([2, 0.1, 40, 5, 10])\n sub_rewards = np.exp(- scale * err_vec)\n return sub_rewards\n\n def lowest_height(self, pose):\n return self._kin_core.lowestHeight(pose)\n\n def disturb_pose(self, pose, noise):\n \"\"\" uniform disturb pose\n\n pose\n noise float, deviation angle in radius\n \"\"\"\n new_pose = pose.copy()\n\n noise3d = noise / np.sqrt(3)\n new_pose[:3] += uniform(-noise3d, noise3d, 3)\n\n for jstar, jdof in zip(self.pos_start, self.joint_dof):\n if jdof == 1:\n new_pose[jstar] += uniform(-noise, noise)\n elif jdof == 4:\n noise_quat = Quaternion.fromExpMap(uniform(-noise3d, noise3d, 3))\n ori_quat = Quaternion.fromWXYZ(pose[jstar:jstar+4])\n new_quat = noise_quat.mul(ori_quat)\n new_pose[jstar:jstar+4] = new_quat.wxyz()\n elif jdof == 0:\n pass\n else:\n assert(False and \"not support jdof other than 1 and 4\")\n\n return new_pose\n\n def disturb_vel(self, vel, noise):\n \"\"\" uniform disturb vel\n\n vel\n noise float, deviation angle in radius\n \"\"\"\n new_vel = vel.copy()\n\n noise3d = noise / np.sqrt(3)\n new_vel[:3] += uniform(-noise3d, noise3d, 3)\n\n for jstar, jdof in zip(self.pos_start, self.joint_dof):\n if jdof == 1:\n new_vel[jstar] += uniform(-noise, noise)\n elif jdof == 4:\n new_vel[jstar:jstar+3] += uniform(-noise3d, noise3d, 3)\n elif jdof == 0:\n pass\n else:\n assert(False and \"not support jdof other than 1 and 4\")\n\n return new_vel\n \n def get_joint_global_pos(self, id):\n return list(self._kin_core.getJointPos(id))\n \n def get_joint_global_quat(self, id):\n return list(self._kin_core.getJointQuat(id))\n \n def get_body_global_pos(self, id):\n return list(self._kin_core.getBodyPos(id))\n \n def get_feature(self):\n return self._kin_core.getFeature()\n \n def inv_feature(self, pos):\n return self._kin_core.invFeature(pos)\n", "meta": {"hexsha": "c58018d4b551c6eb0ceb9485fb5796db404eb713", "size": 29689, "ext": "py", "lang": "Python", "max_stars_repo_path": "utils/humanoid_kin.py", "max_stars_repo_name": "arpspoof/Jump", "max_stars_repo_head_hexsha": "1c9c1bd5c499e24bab25eb7decaa772b60798794", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 46, "max_stars_repo_stars_event_min_datetime": "2021-04-25T03:36:47.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-19T00:23:59.000Z", "max_issues_repo_path": "utils/humanoid_kin.py", "max_issues_repo_name": "squalidux/Jump", "max_issues_repo_head_hexsha": "1c9c1bd5c499e24bab25eb7decaa772b60798794", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2021-05-25T10:04:11.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-22T01:54:00.000Z", "max_forks_repo_path": "utils/humanoid_kin.py", "max_forks_repo_name": "squalidux/Jump", "max_forks_repo_head_hexsha": "1c9c1bd5c499e24bab25eb7decaa772b60798794", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2021-04-25T03:05:35.000Z", "max_forks_repo_forks_event_max_datetime": "2021-07-05T19:58:01.000Z", "avg_line_length": 34.6429404901, "max_line_length": 124, "alphanum_fraction": 0.5538414901, "include": true, "reason": "import numpy,from numpy", "num_tokens": 7485, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6297746074044134, "lm_q2_score": 0.3174262785020255, "lm_q1q2_score": 0.19990700992345709}} {"text": "# -*- coding: utf-8 -*-\nfrom os.path import dirname, exists, join\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom astropy.coordinates import AltAz, EarthLocation\nfrom exoorbit.orbit import Orbit\n\nfrom exoplanet_transit_snr.snr_estimate import (\n calculate_cohen_d_for_dataset,\n coadd_cross_correlation,\n load_data,\n run_cross_correlation,\n)\nfrom exoplanet_transit_snr.stats import gaussfit\nfrom exoplanet_transit_snr.stellardb import StellarDb\n\n# define the names of the star and planet\n# as well as the datasets within the datasets folder\nstar, planet = \"WASP-107\", \"b\"\ndatasets = {50: \"WASP-107b_SNR50\", 100: \"WASP-107b_SNR100\", 200: \"WASP-107b_SNR200\"}\n\n# Load the nominal data for this star and planet from simbad/nasa exoplanet archive\nsdb = StellarDb()\nstar = sdb.get(star)\nplanet = star.planets[planet]\norbit = Orbit(star, planet)\ntelescope = EarthLocation.of_site(\"Paranal\")\n\n# Define the +- range of the radial velocity points,\n# and the density of the sampling\nrv_range = 200\nrv_step = 0.25\n\nfor snr in [200]:\n # Where to find the data, might need to be adjusted\n data_dir = join(dirname(__file__), \"../datasets\", datasets[snr], \"Spectrum_00\")\n # load the data from the fits files, returns several objects\n data = load_data(data_dir, load=True)\n wave, flux, uncs, times, segments = data\n\n # Determine orbital parameters\n phi = (times - planet.time_of_transit) / planet.period\n phi = phi.to_value(1)\n phi = phi % 1\n ingress = (-planet.transit_duration / 2 / planet.period).to_value(1) % 1\n egress = (planet.transit_duration / 2 / planet.period).to_value(1) % 1\n in_transit = (phi >= ingress) | (phi <= egress)\n out_transit = ~in_transit\n\n altaz = star.coordinates.transform_to(AltAz(obstime=times, location=telescope))\n airmass = altaz.secz.value\n\n rv = orbit.radial_velocity_planet(times)\n rv_star = -star.coordinates.radial_velocity_correction(\n obstime=times, location=telescope\n )\n\n # TODO: Create initial stellar spectrum guess\n # sme = SME_Structure()\n # sme.wave = wave[low:upp].to_value(u.AA)\n # sme.spec = flux[low:upp]\n # # We need the specific intensities, not the combined spectrum\n # sme.vrad_flag = \"whole\"\n # sme.vrad = -11\n # sme.vrad_limit = 20\n # sme.cscale_flag = \"none\"\n # sme.cscale_type = \"match\"\n # # Set stellar parameters\n # sme.teff = star.teff.to_value(u.K)\n # sme.logg = star.logg.to_value(u.one)\n # sme.abund = Abund(star.monh.to_value(u.one), \"asplund2009\")\n # sme.vmic = 1\n # sme.vmac = 0\n # sme.vsini = 0\n # # Define atmosphere\n # sme.atmo.source = \"marcs2012.sav\"\n # sme.atmo.method = \"grid\"\n # # Set linelist\n # valdfile = join(dirname(__file__), \"ltt1445A.lin\")\n # sme.linelist = ValdFile(valdfile)\n # # sme.linelist = sme.linelist.trim(sme.wave[0, 0], sme.wave[0, -1], 1000)\n # # Set Mu to the specific positions we need\n # d = orbit.projected_radius(times)\n # r = orbit.planet.radius\n # R = orbit.star.radius\n # mu = np.sqrt(1 - (d / R) ** 2)\n\n # sme_fname = f\"sme_intensities_{star.name}_{planet.name}_snr{snr}.npz\"\n # try:\n # sme_data = np.load(sme_fname)\n # wave_int, flux_int, cont_int = sme_data[\"wave\"], sme_data[\"flux\"], sme_data[\"cont\"]\n # wave_sme, flux_sme = sme_data[\"wave_sme\"], sme_data[\"flux_sme\"]\n # sme.mu = mu[np.isfinite(mu)]\n # except (FileNotFoundError, KeyError):\n # sme = synthesize_spectrum(sme)\n # flux_sme = np.copy(sme.synth.ravel())\n # wave_sme = np.copy(sme.wave.ravel())\n\n # sme.specific_intensities_only = True\n # sme.mu = mu[np.isfinite(mu)]\n # wave_int, flux_int, cont_int = synthesize_spectrum(sme)\n # wave_int, flux_int, cont_int = wave_int[0], flux_int[0], cont_int[0]\n\n # np.savez(\n # sme_fname,\n # wave=wave_int,\n # flux=flux_int,\n # cont=cont_int,\n # wave_sme=wave_sme,\n # flux_sme=flux_sme,\n # )\n\n # str_wave, str_flux = wave_sme, flux_sme\n\n # Run the cross correlation to the next neighbour\n cc_data, rv_array = run_cross_correlation(\n data,\n nsysrem=1,\n rv_range=rv_range,\n rv_step=rv_step,\n load=False,\n data_dir=data_dir,\n rv_star=rv_star,\n rv_planet=rv,\n airmass=airmass,\n )\n\n cc_data = cc_data[\"10\"]\n cc_data_coadd, cc_it, cc_oot = coadd_cross_correlation(\n cc_data, rv, rv_array, times, planet, data_dir=data_dir, load=False\n )\n\n # Normalize by the oot signal\n cc_it /= cc_oot\n\n # Fit a gaussian\n p0 = [np.max(cc_data_coadd) - np.min(cc_data_coadd), 0, 10, np.min(cc_data_coadd)]\n gauss, pval = gaussfit(rv_array, cc_data_coadd, p0=p0)\n\n # Plot the results\n plt.plot(rv_array, cc_data_coadd, label=\"all observations\")\n plt.plot(rv_array, gauss, label=\"best fit gaussian\")\n plt.plot(rv_array, cc_it, label=\"in-transit\")\n plt.plot(rv_array, cc_oot, label=\"out-of-transit\")\n plt.legend()\n plt.title(f\"{star.name} {planet.name} SNR{snr}\")\n plt.xlabel(r\"$\\Delta$RV [km/s]\")\n plt.ylabel(\"CCF\")\n plt.show()\n", "meta": {"hexsha": "aeaf5fe76841ac3f7a7c959ffbd8291fac54ea4d", "size": 5163, "ext": "py", "lang": "Python", "max_stars_repo_path": "examples/wasp107b.py", "max_stars_repo_name": "AWehrhahn/exoplanet_transit_snr", "max_stars_repo_head_hexsha": "f1bdaddb89e1c8b819651bcd2d80ed95d2a1fc0f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "examples/wasp107b.py", "max_issues_repo_name": "AWehrhahn/exoplanet_transit_snr", "max_issues_repo_head_hexsha": "f1bdaddb89e1c8b819651bcd2d80ed95d2a1fc0f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "examples/wasp107b.py", "max_forks_repo_name": "AWehrhahn/exoplanet_transit_snr", "max_forks_repo_head_hexsha": "f1bdaddb89e1c8b819651bcd2d80ed95d2a1fc0f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.1920529801, "max_line_length": 93, "alphanum_fraction": 0.654077087, "include": true, "reason": "import numpy,from astropy", "num_tokens": 1538, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6297746074044134, "lm_q2_score": 0.31742627204485063, "lm_q1q2_score": 0.19990700585689233}} {"text": "#!/usr/bin/env python\n# Copyright 2014-2020 The PySCF Developers. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport ctypes\nimport time\nfrom functools import reduce\nimport numpy\nimport h5py\nfrom pyscf import lib\nfrom pyscf.lib import logger\nfrom pyscf import ao2mo\nfrom pyscf.ao2mo import _ao2mo\nfrom pyscf.ao2mo import outcore\n\n# least memory requirements:\n# nmo ncore ncas outcore incore\n# 200 40 16 0.8GB 3.7 GB (_eri 1.6GB intermediates 1.3G)\n# 250 50 16 1.7GB 8.2 GB (_eri 3.9GB intermediates 2.6G)\n# 300 60 16 3.1GB 16.8GB (_eri 8.1GB intermediates 5.6G)\n# 400 80 16 8.5GB 53 GB (_eri 25.6GB intermediates 19G)\n# 500 100 16 19 GB\n# 600 120 16 37 GB\n# 750 150 16 85 GB\n\nlibmcscf = lib.load_library('libmcscf')\n\ndef trans_e1_incore(eri_ao, mo, ncore, ncas):\n nmo = mo.shape[1]\n nocc = ncore + ncas\n eri1 = ao2mo.incore.half_e1(eri_ao, (mo,mo[:,:nocc]), compact=False)\n eri1 = eri1.reshape(nmo,nocc,-1)\n\n klppshape = (0, nmo, 0, nmo)\n klpashape = (0, nmo, ncore, nocc)\n aapp = numpy.empty((ncas,ncas,nmo,nmo))\n for i in range(ncas):\n _ao2mo.nr_e2(eri1[ncore+i,ncore:nocc], mo, klppshape,\n aosym='s4', mosym='s1', out=aapp[i])\n ppaa = lib.transpose(aapp.reshape(ncas*ncas,-1)).reshape(nmo,nmo,ncas,ncas)\n aapp = None\n\n papa = numpy.empty((nmo,ncas,nmo,ncas))\n for i in range(nmo):\n _ao2mo.nr_e2(eri1[i,ncore:nocc], mo, klpashape,\n aosym='s4', mosym='s1', out=papa[i])\n\n pp = numpy.empty((nmo,nmo))\n j_cp = numpy.zeros((ncore,nmo))\n k_pc = numpy.zeros((nmo,ncore))\n for i in range(ncore):\n _ao2mo.nr_e2(eri1[i,i:i+1], mo, klppshape, aosym='s4', mosym='s1', out=pp)\n j_cp[i] = pp.diagonal()\n j_pc = j_cp.T.copy()\n\n pp = numpy.empty((ncore,ncore))\n for i in range(nmo):\n klshape = (i, i+1, 0, ncore)\n _ao2mo.nr_e2(eri1[i,:ncore], mo, klshape, aosym='s4', mosym='s1', out=pp)\n k_pc[i] = pp.diagonal()\n return j_pc, k_pc, ppaa, papa\n\n\n# level = 1: ppaa, papa and jpc, kpc\n# level > 1: ppaa, papa only. It affects accuracy of hdiag\ndef trans_e1_outcore(mol, mo, ncore, ncas, erifile,\n max_memory=None, level=1, verbose=logger.WARN):\n time0 = (time.clock(), time.time())\n log = logger.new_logger(mol, verbose)\n log.debug1('trans_e1_outcore level %d max_memory %d', level, max_memory)\n nao, nmo = mo.shape\n nao_pair = nao*(nao+1)//2\n nocc = ncore + ncas\n\n faapp_buf = lib.H5TmpFile()\n if isinstance(erifile, h5py.Group):\n feri = erifile\n else:\n feri = lib.H5TmpFile(erifile, 'w')\n\n mo_c = numpy.asarray(mo, order='C')\n mo = numpy.asarray(mo, order='F')\n pashape = (0, nmo, ncore, nocc)\n papa_buf = numpy.zeros((nao,ncas,nmo*ncas))\n j_pc = numpy.zeros((nmo,ncore))\n k_pc = numpy.zeros((nmo,ncore))\n\n mem_words = int(max(2000,max_memory-papa_buf.nbytes/1e6)*1e6/8)\n aobuflen = mem_words//(nao_pair+nocc*nmo) + 1\n ao_loc = numpy.array(mol.ao_loc_nr(), dtype=numpy.int32)\n shranges = outcore.guess_shell_ranges(mol, True, aobuflen, None, ao_loc)\n intor = mol._add_suffix('int2e')\n ao2mopt = _ao2mo.AO2MOpt(mol, intor,\n 'CVHFnr_schwarz_cond', 'CVHFsetnr_direct_scf')\n nstep = len(shranges)\n maxbuflen = max([x[2] for x in shranges])\n log.debug('mem_words %.8g MB, maxbuflen = %d', mem_words*8/1e6, maxbuflen)\n bufs1 = numpy.empty((maxbuflen, nao_pair))\n bufs2 = numpy.empty((maxbuflen, nmo*ncas))\n if level == 1:\n bufs3 = numpy.empty((maxbuflen, nao*ncore))\n log.debug('mem cache %.8g MB',\n (bufs1.nbytes+bufs2.nbytes+bufs3.nbytes)/1e6)\n else:\n log.debug('mem cache %.8g MB', (bufs1.nbytes+bufs2.nbytes)/1e6)\n ti0 = log.timer('Initializing trans_e1_outcore', *time0)\n\n # fmmm, ftrans, fdrv for level 1\n fmmm = libmcscf.AO2MOmmm_ket_nr_s2\n ftrans = libmcscf.AO2MOtranse1_nr_s4\n fdrv = libmcscf.AO2MOnr_e2_drv\n for istep,sh_range in enumerate(shranges):\n log.debug('[%d/%d], AO [%d:%d], len(buf) = %d',\n istep+1, nstep, *sh_range)\n buf = bufs1[:sh_range[2]]\n _ao2mo.nr_e1fill(intor, sh_range,\n mol._atm, mol._bas, mol._env, 's4', 1, ao2mopt, buf)\n if log.verbose >= logger.DEBUG1:\n ti1 = log.timer('AO integrals buffer', *ti0)\n bufpa = bufs2[:sh_range[2]]\n _ao2mo.nr_e1(buf, mo, pashape, 's4', 's1', out=bufpa)\n# jc_pp, kc_pp\n if level == 1: # ppaa, papa and vhf, jcp, kcp\n if log.verbose >= logger.DEBUG1:\n ti1 = log.timer('buffer-pa', *ti1)\n buf1 = bufs3[:sh_range[2]]\n fdrv(ftrans, fmmm,\n buf1.ctypes.data_as(ctypes.c_void_p),\n buf.ctypes.data_as(ctypes.c_void_p),\n mo.ctypes.data_as(ctypes.c_void_p),\n ctypes.c_int(sh_range[2]), ctypes.c_int(nao),\n (ctypes.c_int*4)(0, nao, 0, ncore),\n ctypes.POINTER(ctypes.c_void_p)(), ctypes.c_int(0))\n p0 = 0\n for ij in range(sh_range[0], sh_range[1]):\n i,j = lib.index_tril_to_pair(ij)\n i0 = ao_loc[i]\n j0 = ao_loc[j]\n i1 = ao_loc[i+1]\n j1 = ao_loc[j+1]\n di = i1 - i0\n dj = j1 - j0\n if i == j:\n dij = di * (di+1) // 2\n buf = numpy.empty((di,di,nao*ncore))\n idx = numpy.tril_indices(di)\n buf[idx] = buf1[p0:p0+dij]\n buf[idx[1],idx[0]] = buf1[p0:p0+dij]\n buf = buf.reshape(di,di,nao,ncore)\n mo1 = mo_c[i0:i1]\n tmp = numpy.einsum('uvpc,pc->uvc', buf, mo[:,:ncore])\n tmp = lib.dot(mo1.T, tmp.reshape(di,-1))\n j_pc += numpy.einsum('vp,pvc->pc', mo1, tmp.reshape(nmo,di,ncore))\n tmp = numpy.einsum('uvpc,uc->vcp', buf, mo1[:,:ncore])\n tmp = lib.dot(tmp.reshape(-1,nmo), mo).reshape(di,ncore,nmo)\n k_pc += numpy.einsum('vp,vcp->pc', mo1, tmp)\n else:\n dij = di * dj\n buf = buf1[p0:p0+dij].reshape(di,dj,nao,ncore)\n mo1 = mo_c[i0:i1]\n mo2 = mo_c[j0:j1]\n tmp = numpy.einsum('uvpc,pc->uvc', buf, mo[:,:ncore])\n tmp = lib.dot(mo1.T, tmp.reshape(di,-1))\n j_pc += numpy.einsum('vp,pvc->pc',\n mo2, tmp.reshape(nmo,dj,ncore)) * 2\n tmp = numpy.einsum('uvpc,uc->vcp', buf, mo1[:,:ncore])\n tmp = lib.dot(tmp.reshape(-1,nmo), mo).reshape(dj,ncore,nmo)\n k_pc += numpy.einsum('vp,vcp->pc', mo2, tmp)\n tmp = numpy.einsum('uvpc,vc->ucp', buf, mo2[:,:ncore])\n tmp = lib.dot(tmp.reshape(-1,nmo), mo).reshape(di,ncore,nmo)\n k_pc += numpy.einsum('up,ucp->pc', mo1, tmp)\n p0 += dij\n if log.verbose >= logger.DEBUG1:\n ti1 = log.timer('j_cp and k_cp', *ti1)\n\n if log.verbose >= logger.DEBUG1:\n ti1 = log.timer('half transformation of the buffer', *ti1)\n\n# ppaa, papa\n faapp_buf[str(istep)] = \\\n bufpa.reshape(sh_range[2],nmo,ncas)[:,ncore:nocc].reshape(-1,ncas**2).T\n p0 = 0\n for ij in range(sh_range[0], sh_range[1]):\n i,j = lib.index_tril_to_pair(ij)\n i0 = ao_loc[i]\n j0 = ao_loc[j]\n i1 = ao_loc[i+1]\n j1 = ao_loc[j+1]\n di = i1 - i0\n dj = j1 - j0\n if i == j:\n dij = di * (di+1) // 2\n buf1 = numpy.empty((di,di,nmo*ncas))\n idx = numpy.tril_indices(di)\n buf1[idx] = bufpa[p0:p0+dij]\n buf1[idx[1],idx[0]] = bufpa[p0:p0+dij]\n else:\n dij = di * dj\n buf1 = bufpa[p0:p0+dij].reshape(di,dj,-1)\n mo1 = mo[j0:j1,ncore:nocc].copy()\n for i in range(di):\n lib.dot(mo1.T, buf1[i], 1, papa_buf[i0+i], 1)\n mo1 = mo[i0:i1,ncore:nocc].copy()\n buf1 = lib.dot(mo1.T, buf1.reshape(di,-1))\n papa_buf[j0:j1] += buf1.reshape(ncas,dj,-1).transpose(1,0,2)\n p0 += dij\n if log.verbose >= logger.DEBUG1:\n ti1 = log.timer('ppaa and papa buffer', *ti1)\n\n ti0 = log.timer('gen AO/transform MO [%d/%d]'%(istep+1,nstep), *ti0)\n buf = buf1 = bufpa = None\n bufs1 = bufs2 = bufs3 = None\n time1 = log.timer('mc_ao2mo pass 1', *time0)\n\n log.debug1('Half transformation done. Current memory %d',\n lib.current_memory()[0])\n\n nblk = int(max(8, min(nmo, (max_memory*1e6/8-papa_buf.size)/(ncas**2*nmo))))\n log.debug1('nblk for papa = %d', nblk)\n dset = feri.create_dataset('papa', (nmo,ncas,nmo,ncas), 'f8')\n for i0, i1 in prange(0, nmo, nblk):\n tmp = lib.dot(mo[:,i0:i1].T, papa_buf.reshape(nao,-1))\n dset[i0:i1] = tmp.reshape(i1-i0,ncas,nmo,ncas)\n papa_buf = tmp = None\n time1 = log.timer('papa pass 2', *time1)\n\n tmp = numpy.empty((ncas**2,nao_pair))\n p0 = 0\n for istep, sh_range in enumerate(shranges):\n tmp[:,p0:p0+sh_range[2]] = faapp_buf[str(istep)]\n p0 += sh_range[2]\n nblk = int(max(8, min(nmo, (max_memory*1e6/8-tmp.size)/(ncas**2*nmo)-1)))\n log.debug1('nblk for ppaa = %d', nblk)\n dset = feri.create_dataset('ppaa', (nmo,nmo,ncas,ncas), 'f8')\n for i0, i1 in prange(0, nmo, nblk):\n tmp1 = _ao2mo.nr_e2(tmp, mo, (i0,i1,0,nmo), 's4', 's1', ao_loc=ao_loc)\n tmp1 = tmp1.reshape(ncas,ncas,i1-i0,nmo)\n for j in range(i1-i0):\n dset[i0+j] = tmp1[:,:,j].transpose(2,0,1)\n tmp = tmp1 = None\n time1 = log.timer('ppaa pass 2', *time1)\n\n time0 = log.timer('mc_ao2mo', *time0)\n return j_pc, k_pc\n\n\n# level = 1: ppaa, papa and vhf, jpc, kpc\n# level = 2: ppaa, papa, vhf, jpc=0, kpc=0\nclass _ERIS(object):\n def __init__(self, casscf, mo, method='incore', level=1):\n mol = casscf.mol\n nao, nmo = mo.shape\n ncore = casscf.ncore\n ncas = casscf.ncas\n\n dm_core = numpy.dot(mo[:,:ncore], mo[:,:ncore].T)\n vj, vk = casscf._scf.get_jk(mol, dm_core)\n self.vhf_c = reduce(numpy.dot, (mo.T, vj*2-vk, mo))\n\n mem_incore, mem_outcore, mem_basic = _mem_usage(ncore, ncas, nmo)\n mem_now = lib.current_memory()[0]\n eri = casscf._scf._eri\n if (method == 'incore' and eri is not None and\n (mem_incore+mem_now < casscf.max_memory*.9) or\n mol.incore_anyway):\n if eri is None:\n eri = mol.intor('int2e', aosym='s8')\n self.j_pc, self.k_pc, self.ppaa, self.papa = \\\n trans_e1_incore(eri, mo, ncore, ncas)\n else:\n log = logger.Logger(casscf.stdout, casscf.verbose)\n self.feri = lib.H5TmpFile()\n max_memory = max(3000, casscf.max_memory*.9-mem_now)\n if max_memory < mem_basic:\n log.warn('Calculation needs %d MB memory, over CASSCF.max_memory (%d MB) limit',\n (mem_basic+mem_now)/.9, casscf.max_memory)\n self.j_pc, self.k_pc = \\\n trans_e1_outcore(mol, mo, ncore, ncas, self.feri,\n max_memory=max_memory,\n level=level, verbose=log)\n self.ppaa = self.feri['ppaa']\n self.papa = self.feri['papa']\n\ndef _mem_usage(ncore, ncas, nmo):\n outcore = basic = ncas**2*nmo**2*2 * 8/1e6\n incore = outcore + (ncore+ncas)*nmo**3*4/1e6\n return incore, outcore, basic\n\ndef prange(start, end, step):\n for i in range(start, end, step):\n yield i, min(i+step, end)\n\nif __name__ == '__main__':\n from pyscf import scf\n from pyscf import gto\n from pyscf.mcscf import mc1step\n\n mol = gto.Mole()\n mol.verbose = 0\n mol.output = None#\"out_h2o\"\n mol.atom = [\n ['O', ( 0., 0. , 0. )],\n ['H', ( 0., -0.757, 0.587)],\n ['H', ( 0., 0.757 , 0.587)],]\n mol.basis = {'H': 'cc-pvtz',\n 'O': 'cc-pvtz',}\n mol.build()\n\n m = scf.RHF(mol)\n ehf = m.scf()\n\n mc = mc1step.CASSCF(m, 6, 4)\n mc.verbose = 4\n mo = m.mo_coeff.copy()\n\n eris0 = _ERIS(mc, mo, 'incore')\n eris1 = _ERIS(mc, mo, 'outcore')\n eris2 = _ERIS(mc, mo, 'outcore', level=1)\n eris3 = _ERIS(mc, mo, 'outcore', level=2)\n print('vhf_c', numpy.allclose(eris0.vhf_c, eris1.vhf_c))\n print('j_pc ', numpy.allclose(eris0.j_pc , eris1.j_pc ))\n print('k_pc ', numpy.allclose(eris0.k_pc , eris1.k_pc ))\n print('ppaa ', numpy.allclose(eris0.ppaa , eris1.ppaa ))\n print('papa ', numpy.allclose(eris0.papa , eris1.papa ))\n\n print('vhf_c', numpy.allclose(eris0.vhf_c, eris2.vhf_c))\n print('j_pc ', numpy.allclose(eris0.j_pc , eris2.j_pc ))\n print('k_pc ', numpy.allclose(eris0.k_pc , eris2.k_pc ))\n print('ppaa ', numpy.allclose(eris0.ppaa , eris2.ppaa ))\n print('papa ', numpy.allclose(eris0.papa , eris2.papa ))\n\n print('vhf_c', numpy.allclose(eris0.vhf_c, eris3.vhf_c))\n print('ppaa ', numpy.allclose(eris0.ppaa , eris3.ppaa ))\n print('papa ', numpy.allclose(eris0.papa , eris3.papa ))\n\n ncore = mc.ncore\n ncas = mc.ncas\n nocc = ncore + ncas\n nmo = mo.shape[1]\n eri = ao2mo.incore.full(m._eri, mo, compact=False).reshape((nmo,)*4)\n aaap = numpy.array(eri[ncore:nocc,ncore:nocc,ncore:nocc,:])\n ppaa = numpy.array(eri[:,:,ncore:nocc,ncore:nocc])\n papa = numpy.array(eri[:,ncore:nocc,:,ncore:nocc])\n jc_pp = numpy.einsum('iipq->ipq', eri[:ncore,:ncore,:,:])\n kc_pp = numpy.einsum('ipqi->ipq', eri[:ncore,:,:,:ncore])\n vhf_c = numpy.einsum('cij->ij', jc_pp)*2 - numpy.einsum('cij->ij', kc_pp)\n j_pc = numpy.einsum('ijj->ji', jc_pp)\n k_pc = numpy.einsum('ijj->ji', kc_pp)\n\n print('vhf_c', numpy.allclose(vhf_c, eris1.vhf_c))\n print('j_pc ', numpy.allclose(j_pc, eris1.j_pc))\n print('k_pc ', numpy.allclose(k_pc, eris1.k_pc))\n print('ppaa ', numpy.allclose(ppaa , eris0.ppaa ))\n print('papa ', numpy.allclose(papa , eris0.papa ))\n\n", "meta": {"hexsha": "869fa5e80a5c8136c2ce204723b028e729cec47c", "size": 14872, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyscf/mcscf/mc_ao2mo.py", "max_stars_repo_name": "mfkasim1/pyscf", "max_stars_repo_head_hexsha": "7be5e015b2b40181755c71d888449db936604660", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-11-12T11:55:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-12T11:55:25.000Z", "max_issues_repo_path": "pyscf/mcscf/mc_ao2mo.py", "max_issues_repo_name": "mfkasim1/pyscf", "max_issues_repo_head_hexsha": "7be5e015b2b40181755c71d888449db936604660", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 36, "max_issues_repo_issues_event_min_datetime": "2018-08-22T19:44:03.000Z", "max_issues_repo_issues_event_max_datetime": "2020-05-09T10:02:36.000Z", "max_forks_repo_path": "pyscf/mcscf/mc_ao2mo.py", "max_forks_repo_name": "mfkasim1/pyscf", "max_forks_repo_head_hexsha": "7be5e015b2b40181755c71d888449db936604660", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2018-02-14T16:28:28.000Z", "max_forks_repo_forks_event_max_datetime": "2019-08-12T16:40:30.000Z", "avg_line_length": 40.5231607629, "max_line_length": 96, "alphanum_fraction": 0.5591043572, "include": true, "reason": "import numpy", "num_tokens": 5055, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5851011542032312, "lm_q2_score": 0.3415825128436339, "lm_q1q2_score": 0.19986032252045022}} {"text": "#!/usr/bin/env python\n# Computes the matrix of similarities between structures in a xyz file\n# by first getting SOAP descriptors for all environments, finding the best\n# match between environments using the Hungarian algorithm, and finally\n# summing up the environment distances.\n# Supports periodic systems, matching between structures with different\n# atom number and kinds, and sports the infrastructure for introducing an\n# alchemical similarity kernel to match different atomic species\n\n# import sys, os, pickle\nimport sys, os\nimport cPickle as pickle\nimport gc \nfrom lap.lap import best_pairs, best_cost, lcm_best_cost\nfrom lap.perm import xperm, mcperm, rematch\nimport numpy as np\nfrom environments import environ, alchemy, envk\nimport quippy\n__all__ = [ \"structk\", \"structure\" ]\n\n \nclass structure:\n def __init__(self, salchem=None):\n self.env={}\n self.species={}\n self.zspecies = []\n self.atz = []\n self.nenv=0 \n self.alchem=salchem\n if self.alchem is None: self.alchem=alchemy()\n self.globenv = None\n \n def getnz(self, sp):\n if sp in self.species:\n return self.species[sp]\n else: return 0\n \n def getatomenv(self, i):\n if i>=len(self.atz):\n raise IndexError(\"Trying to access atom past structure size\")\n k=0\n lsp = {}\n for z in self.atz:\n if z in lsp: lsp[z]+=1\n else: lsp[z] = 0\n if i==k: \n return self.env[z][lsp[z]] \n k+=1\n \n def getenv(self, sp, i):\n if sp in self.env and i0: at.remove_atoms(nol)\n \n \n self.nmax = nmax\n self.lmax = lmax\n self.atz = at.z.copy()\n self.species = {}\n for z in at.z: \n if z in self.species: self.species[z]+=1\n else: self.species[z] = 1\n \n self.zspecies = self.species.keys();\n self.zspecies.sort(); \n lspecies = 'n_species='+str(len(self.zspecies))+' species_Z={ '\n for z in self.zspecies: lspecies = lspecies + str(z) + ' '\n lspecies = lspecies + '}'\n \n at.set_cutoff(coff);\n at.calc_connect();\n \n self.nenv = 0\n if not soapdump is None:\n soapdump.write(\"####### SOAP VECTOR FRAME ######\\n\")\n for sp in self.species:\n \n if sp in nocenter: \n self.species[sp]=0\n continue # Option to skip some environments\n \n # first computes the descriptors of species that are present\n if not soapdump is None: sys.stderr.write(\"SOAP STRING: \"+\"soap central_reference_all_species=F central_weight=\"+str(cw)+\" covariance_sigma0=0.0 atom_sigma=\"+str(gs)+\" cutoff=\"+str(coff)+\" cutoff_transition_width=\"+str(cotw)+\" n_max=\"+str(nmax)+\" l_max=\"+str(lmax)+' '+lspecies+' Z='+str(sp)+\"\\n\")\n desc = quippy.descriptors.Descriptor(\"soap central_reference_all_species=F \"+(\"normalise=F\" if unsoap else \"\")+\" central_weight=\"+str(cw)+\" covariance_sigma0=0.0 atom_sigma=\"+str(gs)+\" cutoff=\"+str(coff)+\" cutoff_transition_width=\"+str(cotw)+\" n_max=\"+str(nmax)+\" l_max=\"+str(lmax)+' '+lspecies+' Z='+str(sp) ) \n try:\n psp = desc.calc(at)[\"descriptor\"]\n except TypeError:\n print(\"Interface change in QUIP/GAP. Update your code first.\")\n\n if not soapdump is None:\n soapdump.write(\"Specie %d - %d atoms\\n\"% (sp,len(psp)))\n for p in psp:\n np.savetxt(soapdump,[p])\n\n # now repartitions soaps in environment descriptors\n lenv = []\n for p in psp:\n nenv = environ(nmax, lmax, self.alchem)\n nenv.convert(sp, self.zspecies, p, unsoap)\n lenv.append(nenv)\n self.env[sp] = lenv\n self.nenv += self.species[sp]\n \n # adds kit data \n if kit is None: kit = {}\n \n for sp in kit: \n if not sp in self.species: \n self.species[sp]=0\n self.env[sp] = []\n for k in range(self.species[sp], kit[sp]): \n self.env[sp].append(environ(self.nmax,self.lmax,self.alchem,sp))\n self.nenv+=1\n self.species[sp] = kit[sp] \n \n self.zspecies = self.species.keys()\n self.zspecies.sort() \n \n # also compute the global (flattened) fingerprint\n self.globenv = environ(nmax, lmax, self.alchem)\n \n for k, se in self.env.items():\n for e in se:\n self.globenv.add(e)\n # divides by the number of atoms in the structure\n for sij in self.globenv.soaps: self.globenv.soaps[sij]*=1.0/self.nenv\n # self.globenv.normalize() #if needed, normalization will be done later on.....\n \n\ndef gcd(a,b):\n if (b>a): a,b = b, a\n \n while (b): a, b = b, a%b\n \n return a\n \ndef lcm(a,b):\n return a*b/gcd(b,a)\n\n#def gstructk(strucA, strucB, alchem=alchemy(), peratom=False):\n# \n# return envk(strucA.globenv, strucB.globenv, alchem) \n\ndef structk(strucA, strucB, alchem=alchemy(), peratom=False, mode=\"match\", fout=None, peps=0.0, gamma=1.0, zeta=1.0, xspecies=False):\n # computes the SOAP similarity KERNEL between two structures by combining atom-centered kernels\n # possible kernel modes include:\n # average : scalar product between averaged kernels\n # match: best-match hungarian kernel\n # permanent: average over all permutations\n \n # average kernel. quick & easy! \n if mode==\"fastavg\":\n genvA=strucA.globenv\n genvB=strucB.globenv \n return envk(genvA, genvB, alchem)**zeta, 0\n elif mode==\"fastspecies\": \n # for now, only implement standard Kronecker alchemy\n senvB = environ(strucB.nmax, strucB.lmax, strucB.alchem)\n kk = 0\n for za in strucA.zspecies: \n if not za in strucB.zspecies: continue \n senvA = environ(strucA.nmax, strucA.lmax, strucA.alchem)\n for ia in xrange(strucA.getnz(za)):\n senvA.add(strucA.getenv(za, ia))\n senvB = environ(strucB.nmax, strucB.lmax, strucB.alchem) \n for ib in xrange(strucB.getnz(za)):\n senvB.add(strucB.getenv(za, ib))\n kk += envk(senvA, senvB, alchem)**zeta\n \n kk/=strucA.nenv*strucB.nenv\n return kk,0\n \n # for zb, nzb in nspeciesB:\n # for ib in xrange(nzb):\n # return envk(genvA, genvB, alchem), 0\n\n nenv = 0\n \n if peratom: # replicate structures to match structures of different peratomity\n # we do not check for compatibility at this stage, just assume that the \n # matching will be done somehow (otherwise it would be exceedingly hard to manage in case of non-standard alchemy)\n nspeciesA = []\n nspeciesB = []\n for z in strucA.zspecies:\n nspeciesA.append( (z, strucA.getnz(z)) )\n for z in strucB.zspecies:\n nspeciesB.append( (z, strucB.getnz(z)) )\n nenv=nenvA = strucA.nenv\n nenvB = strucB.nenv \n else: \n # top up missing atoms with isolated environments\n # first checks which atoms are present\n zspecies = sorted(list(set(strucB.zspecies+strucA.zspecies)))\n nspecies = []\n for z in zspecies:\n nz = max(strucA.getnz(z),strucB.getnz(z))\n nspecies.append((z,nz)) \n nenv += nz\n nenvA = nenvB = nenv\n nspeciesA = nspeciesB = nspecies \n \n np.set_printoptions(linewidth=500,precision=4)\n\n kk = np.zeros((nenvA,nenvB),float)\n ika = 0\n ikb = 0 \n for za, nza in nspeciesA: \n for ia in xrange(nza):\n envA = strucA.getenv(za, ia) \n ikb = 0\n for zb, nzb in nspeciesB:\n for ib in xrange(nzb):\n envB = strucB.getenv(zb, ib)\n if alchem.mu > 0 and (strucA.ismissing(za, ia) ^ strucB.ismissing(zb, ib)):\n # includes a penalty dependent on \"mu\", in a way that is consistent with the definition of kernel distance\n kk[ika,ikb] = exp(-alchem.mu)\n else:\n if za == zb or not xspecies: #uncomment to zero out kernels between different species\n kk[ika,ikb] = envk(envA, envB, alchem)**zeta \n else: kk[ika,ikb] = 0\n ikb+=1\n ika+=1\n aidx = {}\n ika=0\n for za, nza in nspeciesA: \n aidx[za] = range(ika,ika+nza)\n ika+=nza\n ikb=0\n bidx = {}\n for zb, nzb in nspeciesB: \n bidx[zb] = range(ikb,ikb+nzb)\n ikb+=nzb\n\n if fout != None:\n # prints out similarity information for the environment pairs\n fout.write(\"# atomic species in the molecules (possibly topped up with dummy isolated atoms): \\n\") \n for za, nza in nspeciesA:\n for ia in xrange(nza): fout.write(\" %d \" % (za) )\n fout.write(\"\\n\");\n for zb, nzb in nspeciesB:\n for ib in xrange(nzb): fout.write(\" %d \" % (zb) )\n fout.write(\"\\n\");\n \n fout.write(\"# environment kernel matrix: \\n\") \n for r in kk:\n for e in r:\n fout.write(\"%20.14e \" % (e) )\n fout.write(\"\\n\")\n #fout.write(\"# environment kernel eigenvalues: \\n\") \n #ev = np.linalg.eigvals(kk)\n #for e in ev:\n # fout.write(\"(%8.4e,%8.4e) \" % (e.real,e.imag) )\n #fout.write(\"\\n\");\n \n \n\n \n # Now we have the matrix of scalar products. \n # We can first find the optimal scalar product kernel\n # we must find the maximum \"cost\"\n if mode == \"match\":\n if peratom and nenvA != nenvB:\n nenv = lcm(nenvA, nenvB)\n hun = lcm_best_cost(1-kk)\n else:\n hun=best_cost(1.0-kk) \n cost = 1-hun/nenv\n elif mode == \"permanent\":\n # there is no place to hide: cross-species environments are not necessarily zero \n if peps>0: cost = mcperm(kk, peps)\n else: cost = xperm(kk)\n \n cost = cost/np.math.factorial(nenv)/nenv \n elif mode == \"rematch\":\n cost=rematch(kk, gamma, 1e-6) # hard-coded residual error for regularized gamma\n # print cost, kk.sum()/(nenv*nenv), envk(strucA.globenv, strucB.globenv, alchem)\n elif mode == \"average\":\n cost = kk.sum()/(nenvA*nenvB)\n # print 'elem: {}'.format(kk.sum()) \n # print 'elem norm: {}'.format(cost) \n # print 'avg norm: {}'.format((nenvA*nenvB)) \n \n else: raise ValueError(\"Unknown global fingerprint mode \", mode)\n \n \n return cost,kk\n\n\nclass structurelist(list):\n def __init__(self, basedir=\"tmpstructures\"):\n self.basedir=basedir\n # create the folder if it is not there \n if not os.path.exists(basedir):os.makedirs(basedir)\n self.count=0\n \n def exists(self, index):\n # return true if the file associated with index exists, false otherwise\n f=self.basedir+'/sl_'+str(index)+'.dat'\n return os.path.isfile(f)\n # @profile\n def append(self, element):\n #pickle the element for later use\n ind=self.count\n f=self.basedir+'/sl_'+str(ind)+'.dat'\n file = open(f,\"wb\")\n gc.disable()\n pickle.dump(element, file,protocol=pickle.HIGHEST_PROTOCOL) # HIGHEST_PROTOCOL is 2 in py 2.7\n file.close()\n gc.enable()\n self.count+=1\n\n \n # @profile\n def __getitem__(self, index):\n f = self.basedir+'/sl_'+str(index)+'.dat'\n try:\n file = open(f,\"rb\")\n except IOError:\n raise IOError(\"Cannot load descriptors for index %d\" % (index) )\n gc.disable()\n l = pickle.load(file)\n file.close()\n gc.enable()\n return l\n", "meta": {"hexsha": "94e2e71a752727aabea9c7e84729fa89c66f474c", "size": 12376, "ext": "py", "lang": "Python", "max_stars_repo_path": "libmatch/structures.py", "max_stars_repo_name": "cosmo-epfl/glosim", "max_stars_repo_head_hexsha": "930998b7249adc0ac3e48308314233341de6e73f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 24, "max_stars_repo_stars_event_min_datetime": "2017-04-19T14:23:53.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-23T13:37:23.000Z", "max_issues_repo_path": "libmatch/structures.py", "max_issues_repo_name": "lab-cosmo/glosim", "max_issues_repo_head_hexsha": "930998b7249adc0ac3e48308314233341de6e73f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 9, "max_issues_repo_issues_event_min_datetime": "2017-05-23T10:30:08.000Z", "max_issues_repo_issues_event_max_datetime": "2019-02-05T06:43:04.000Z", "max_forks_repo_path": "libmatch/structures.py", "max_forks_repo_name": "lab-cosmo/glosim", "max_forks_repo_head_hexsha": "930998b7249adc0ac3e48308314233341de6e73f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 11, "max_forks_repo_forks_event_min_datetime": "2017-05-01T14:37:40.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-23T14:00:12.000Z", "avg_line_length": 36.1871345029, "max_line_length": 323, "alphanum_fraction": 0.5789431157, "include": true, "reason": "import numpy", "num_tokens": 3374, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.5851011542032313, "lm_q2_score": 0.3415825061409754, "lm_q1q2_score": 0.19986031859871706}} {"text": "\"\"\"Contains the classes that deal with the normal mode representation.\n\nCopyright (C) 2013, Joshua More and Michele Ceriotti\n\nThis program is free software: you can redistribute it and/or modify\nit under the terms of the GNU General Public License as published by\nthe Free Software Foundation, either version 3 of the License, or\n(at your option) any later version.\n\nThis program is distributed in the hope that it will be useful,\nbut WITHOUT ANY WARRANTY; without even the implied warranty of\nMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\nGNU General Public License for more details.\n\nYou should have received a copy of the GNU General Public License\nalong with this program. If not, see .\n\n\nDeals with the normal mode transformation, including the complications\nintroduced by PA-CMD when the bead masses are rescaled. Also deals with\nthe change in the dynamics introduced by this mass-scaling, and has its\nown functions to calculate the kinetic energy, and the exact propagator\nin the normal mode representation under the ring polymer Hamiltonian.\n\nClasses:\n NormalModes: Deals with the normal mode transformation in RPMD and PA-CMD.\n\"\"\"\n\nimport numpy as np\nfrom ipi.utils.depend import *\nfrom ipi.utils import units\nfrom ipi.utils import nmtransform\nfrom ipi.utils.messages import verbosity, warning, info\n\n__all__ = [ \"NormalModes\" ]\n\nclass NormalModes(dobject):\n \"\"\" A helper class to manipulate the path NM.\n\n Normal-modes transformation, determination of path frequencies,\n dynamical mass matrix change, etc.\n\n Attributes:\n natoms: The number of atoms.\n nbeads: The number of beads.\n beads: The beads object for which the normal mode transformation should\n be done.\n ensemble: The ensemble object, specifying the temperature to hold the\n system to.\n transform: A nm_trans object that contains the functions that are\n required for the normal mode transformation.\n\n Depend objects:\n mode: A string specifying how the bead masses are chosen.\n transform_method: A string specifying how to do the normal mode\n transformation.\n nm_freqs: An array that specifies how the normal mode frequencies\n of the ring polymers are to be calculated, and thus how the\n bead masses should be chosen.\n qnm: The bead positions in the normal mode representation. Depends on\n beads.q.\n pnm: The bead momenta in the normal mode representation. Depends on\n beads.p.\n omegan: The effective vibrational frequency for the interaction\n between the replicas. Depends on the simulation temperature.\n omegan2: omegan**2.\n omegak: The normal mode frequencies for the free ring polymer.\n Depends on omegan.\n prop_pq: An array holding the exact normal mode propagator for the\n free ring polymer, using mass scaled coordinates.\n See J. Chem. Phys. 133, 124101 (2010). Depends on the bead masses\n and the timestep.\n nm_factor: An array of dynamical mass factors associated with each of\n the normal modes. Depends on nm_freqs and mode.\n dynm3: An array that gives the dynamical masses of individual atoms in the\n normal modes representation. Depends on nm_factor and beads.m3.\n dynomegak: The scaled vibrational frequencies. Depends on nm_factor and\n omegak.\n kins: A list of the kinetic energy for each normal mode, as\n calculated in the normal mode representation, using the\n dynamical mass factors. Depends on beads.sm3, beads.p and nm_factor.\n kin: The total kinetic energy, as calculated in the normal mode\n representation, using the dynamical mass factors.\n kstress: The kinetic stress tensor, as calculated in the normal mode\n representation, using the dynamical mass factors. Depends on\n beads.sm3, beads.p and nm_factor.\n \"\"\"\n\n def __init__(self, mode=\"rpmd\", transform_method=\"fft\", freqs=None):\n \"\"\"Initializes NormalModes.\n\n Sets the options for the normal mode transform.\n\n Args:\n mode: A string specifying how to calculate the bead masses.\n transform_method: A string specifying how to do the normal mode\n transformation.\n freqs: A list of data used to calculate the dynamical mass factors.\n \"\"\"\n\n if freqs is None:\n freqs = []\n dset(self,\"mode\", depend_value(name='mode', value=mode))\n dset(self,\"transform_method\",\n depend_value(name='transform_method', value=transform_method))\n dset(self,\"nm_freqs\",\n depend_array(name=\"nm_freqs\",value=np.asarray(freqs, float) ) )\n\n def bind(self, beads, ensemble):\n \"\"\" Initializes the normal modes object and binds to beads and ensemble.\n\n Do all the work down here as we need a full-formed necklace and ensemble\n to know how this should be done.\n\n Args:\n beads: A beads object to be bound.\n ensemble: An ensemble object to be bound.\n \"\"\"\n\n self.nbeads = beads.nbeads\n self.natoms = beads.natoms\n\n # stores a reference to the bound beads and ensemble objects\n self.beads = beads\n self.ensemble = ensemble\n\n # sets up what's necessary to perform nm transformation.\n if self.transform_method == \"fft\":\n self.transform = nmtransform.nm_fft(nbeads=self.nbeads, natoms=self.natoms)\n elif self.transform_method == \"matrix\":\n self.transform = nmtransform.nm_trans(nbeads=self.nbeads)\n\n # creates arrays to store normal modes representation of the path.\n # must do a lot of piping to create \"ex post\" a synchronization between the beads and the nm\n sync_q = synchronizer()\n sync_p = synchronizer()\n dset(self,\"qnm\",\n depend_array(name=\"qnm\",\n value=np.zeros((self.nbeads,3*self.natoms), float),\n func={\"q\": (lambda : self.transform.b2nm(depstrip(self.beads.q)) ) },\n synchro=sync_q ) )\n dset(self,\"pnm\",\n depend_array(name=\"pnm\",\n value=np.zeros((self.nbeads,3*self.natoms), float),\n func={\"p\": (lambda : self.transform.b2nm(depstrip(self.beads.p)) ) },\n synchro=sync_p ) )\n\n # must overwrite the functions\n dget(self.beads, \"q\")._func = { \"qnm\": (lambda : self.transform.nm2b(depstrip(self.qnm)) ) }\n dget(self.beads, \"p\")._func = { \"pnm\": (lambda : self.transform.nm2b(depstrip(self.pnm)) ) }\n dget(self.beads, \"q\").add_synchro(sync_q)\n dget(self.beads, \"p\").add_synchro(sync_p)\n\n # also within the \"atomic\" interface to beads\n for b in range(self.nbeads):\n dget(self.beads._blist[b],\"q\")._func = { \"qnm\": (lambda : self.transform.nm2b(depstrip(self.qnm)) ) }\n dget(self.beads._blist[b],\"p\")._func = { \"pnm\": (lambda : self.transform.nm2b(depstrip(self.pnm)) ) }\n dget(self.beads._blist[b],\"q\").add_synchro(sync_q)\n dget(self.beads._blist[b],\"p\").add_synchro(sync_p)\n\n\n # finally, we mark the beads as those containing the set positions\n dget(self.beads, \"q\").update_man()\n dget(self.beads, \"p\").update_man()\n\n # create path-frequencies related properties\n dset(self,\"omegan\",\n depend_value(name='omegan', func=self.get_omegan,\n dependencies=[dget(self.ensemble,\"temp\")]) )\n dset(self,\"omegan2\", depend_value(name='omegan2',func=self.get_omegan2,\n dependencies=[dget(self,\"omegan\")]) )\n dset(self,\"omegak\", depend_array(name='omegak',\n value=np.zeros(self.beads.nbeads,float),\n func=self.get_omegak, dependencies=[dget(self,\"omegan\")]) )\n\n # sets up \"dynamical\" masses -- mass-scalings to give the correct RPMD/CMD dynamics\n dset(self,\"nm_factor\", depend_array(name=\"nmm\",\n value=np.zeros(self.nbeads, float), func=self.get_nmm,\n dependencies=[dget(self,\"nm_freqs\"), dget(self,\"mode\") ]) )\n dset(self,\"dynm3\", depend_array(name=\"dm3\",\n value=np.zeros((self.nbeads,3*self.natoms), float),func=self.get_dynm3,\n dependencies=[dget(self,\"nm_factor\"), dget(self.beads, \"m3\")] ) )\n dset(self,\"dynomegak\", depend_array(name=\"dynomegak\",\n value=np.zeros(self.nbeads, float), func=self.get_dynwk,\n dependencies=[dget(self,\"nm_factor\"), dget(self,\"omegak\") ]) )\n\n dset(self,\"prop_pq\",\n depend_array(name='prop_pq',value=np.zeros((self.beads.nbeads,2,2)),\n func=self.get_prop_pq,\n dependencies=[dget(self,\"omegak\"), dget(self,\"nm_factor\"), dget(self.ensemble,\"dt\")]) )\n\n # if the mass matrix is not the RPMD one, the MD kinetic energy can't be\n # obtained in the bead representation because the masses are all mixed up\n dset(self,\"kins\",\n depend_array(name=\"kins\",value=np.zeros(self.nbeads, float),\n func=self.get_kins,\n dependencies=[dget(self,\"pnm\"), dget(self.beads,\"sm3\"), dget(self, \"nm_factor\") ] ))\n dset(self,\"kin\",\n depend_value(name=\"kin\", func=self.get_kin,\n dependencies=[dget(self,\"kins\")] ))\n dset(self,\"kstress\",\n depend_array(name=\"kstress\",value=np.zeros((3,3), float),\n func=self.get_kstress,\n dependencies=[dget(self,\"pnm\"), dget(self.beads,\"sm3\"), dget(self, \"nm_factor\") ] ))\n\n def get_omegan(self):\n \"\"\"Returns the effective vibrational frequency for the interaction\n between replicas.\n \"\"\"\n\n return self.ensemble.temp*self.nbeads*units.Constants.kb/units.Constants.hbar\n\n def get_omegan2(self):\n \"\"\"Returns omegan**2.\"\"\"\n\n return self.omegan**2\n\n def get_omegak(self):\n \"\"\"Gets the normal mode frequencies.\n\n Returns:\n A list of the normal mode frequencies for the free ring polymer.\n The first element is the centroid frequency (0.0).\n \"\"\"\n\n return 2*self.omegan*np.array([np.sin(k*np.pi/self.nbeads) for k in range(self.nbeads)])\n\n def get_dynwk(self):\n \"\"\"Gets the dynamical normal mode frequencies.\n\n Returns:\n A list of the scaled normal mode frequencies for the free ring polymer.\n The first element is the centroid frequency (0.0).\n \"\"\"\n\n return self.omegak/np.sqrt(self.nm_factor)\n\n def get_prop_pq(self):\n \"\"\"Gets the normal mode propagator matrix.\n\n Note the special treatment for the centroid normal mode, which is\n propagated using the standard velocity Verlet algorithm as required.\n Note that both the normal mode positions and momenta are propagated\n using this matrix.\n\n Returns:\n An array of the form (nbeads, 2, 2). Each 2*2 array prop_pq[i,:,:]\n gives the exact propagator for the i-th normal mode of the\n ring polymer.\n \"\"\"\n\n dt = self.ensemble.dt\n pqk = np.zeros((self.nbeads,2,2), float)\n pqk[0] = np.array([[1,0], [dt,1]])\n\n for b in range(1, self.nbeads):\n sk = np.sqrt(self.nm_factor[b]) # NOTE THAT THE PROPAGATOR USES MASS-SCALED MOMENTA!\n\n dtomegak = self.omegak[b]*dt/sk\n c = np.cos(dtomegak)\n s = np.sin(dtomegak)\n pqk[b,0,0] = c\n pqk[b,1,1] = c\n pqk[b,0,1] = -s*self.omegak[b]*sk\n pqk[b,1,0] = s/(self.omegak[b]*sk)\n\n return pqk\n\n def get_nmm(self):\n \"\"\"Returns dynamical mass factors, i.e. the scaling of normal mode\n masses that determine the path dynamics (but not statics).\"\"\"\n\n # also checks that the frequencies and the mode given in init are\n # consistent with the beads and ensemble\n\n dmf = np.zeros(self.nbeads,float)\n dmf[:] = 1.0\n if self.mode == \"rpmd\":\n if len(self.nm_freqs) > 0:\n warning(\"nm.frequencies will be ignored for RPMD mode.\", verbosity.low)\n elif self.mode == \"manual\":\n if len(self.nm_freqs) != self.nbeads-1:\n raise ValueError(\"Manual path mode requires (nbeads-1) frequencies, one for each internal mode of the path.\")\n for b in range(1, self.nbeads):\n sk = self.omegak[b]/self.nm_freqs[b-1]\n dmf[b] = sk**2\n elif self.mode == \"pa-cmd\":\n if len(self.nm_freqs) > 1:\n warning(\"Only the first element in nm.frequencies will be considered for PA-CMD mode.\", verbosity.low)\n if len(self.nm_freqs) == 0:\n raise ValueError(\"PA-CMD mode requires the target frequency of all the internal modes.\")\n for b in range(1, self.nbeads):\n sk = self.omegak[b]/self.nm_freqs[0]\n info(\" \".join([\"NM FACTOR\", str(b), str(sk), str(self.omegak[b]), str(self.nm_freqs[0])]), verbosity.medium)\n dmf[b] = sk**2\n elif self.mode == \"wmax-cmd\":\n if len(self.nm_freqs) > 2:\n warning(\"Only the first two element in nm.frequencies will be considered for WMAX-CMD mode.\", verbosity.low)\n if len(self.nm_freqs) < 2:\n raise ValueError(\"WMAX-CMD mode requires [wmax, wtarget]. The normal modes will be scaled such that the first internal mode is at frequency wtarget and all the normal modes coincide at frequency wmax.\")\n wmax = self.nm_freqs[0]\n wt = self.nm_freqs[1]\n for b in range(1, self.nbeads):\n sk = 1.0/np.sqrt((wt)**2*(1+(wmax/self.omegak[1])**2)/(wmax**2+(self.omegak[b])**2))\n dmf[b] = sk**2\n\n return dmf\n\n def get_dynm3(self):\n \"\"\"Returns an array with the dynamical masses of individual atoms in the normal modes representation.\"\"\"\n\n dm3 = np.zeros(self.beads.m3.shape,float)\n for b in range(self.nbeads):\n dm3[b] = self.beads.m3[b]*self.nm_factor[b]\n\n return dm3\n\n def free_qstep(self):\n \"\"\"Exact normal mode propagator for the free ring polymer.\n\n Note that the propagator works in mass scaled coordinates, so that the\n propagator matrix can be determined independently from the particular\n atom masses, and so the same propagator will work for all the atoms in\n the system. All the ring polymers are propagated at the same time by a\n matrix multiplication.\n\n Also note that the centroid coordinate is propagated in qcstep, so is\n not altered here.\n \"\"\"\n\n if self.nbeads == 1:\n pass\n else:\n pq = np.zeros((2,self.natoms*3),float)\n sm = depstrip(self.beads.sm3)[0]\n prop_pq = depstrip(self.prop_pq)\n for k in range(1,self.nbeads):\n pq[0,:] = depstrip(self.pnm)[k]/sm\n pq[1,:] = depstrip(self.qnm)[k]*sm\n pq = np.dot(prop_pq[k],pq)\n self.qnm[k] = pq[1,:]/sm\n self.pnm[k] = pq[0,:]*sm\n\n def get_kins(self):\n \"\"\"Gets the MD kinetic energy for all the normal modes.\n\n Returns:\n A list of the kinetic energy for each NM.\n \"\"\"\n\n kmd = np.zeros(self.nbeads,float)\n sm = depstrip(self.beads.sm3[0])\n pnm = depstrip(self.pnm)\n nmf = depstrip(self.nm_factor)\n\n # computes the MD ke in the normal modes representation, to properly account for CMD mass scaling\n for b in range(self.nbeads):\n sp = pnm[b]/sm # mass-scaled momentum of b-th NM\n kmd[b] = np.dot(sp,sp)*0.5/nmf[b] # include the partially adiabatic CMD mass scaling\n\n return kmd\n\n def get_kin(self):\n \"\"\"Gets the total MD kinetic energy.\n\n Note that this does not correspond to the quantum kinetic energy estimate\n for the system.\n\n Returns:\n The sum of the kinetic energy of each NM in the path.\n \"\"\"\n\n return self.kins.sum()\n\n def get_kstress(self):\n \"\"\"Calculates the total MD kinetic stress tensor.\n\n Note that this does not correspond to the quantum kinetic stress tensor\n estimate for the system.\n\n Returns:\n The sum of the MD kinetic stress tensor contributions from each NM.\n \"\"\"\n\n kmd = np.zeros((3,3),float)\n sm = depstrip(self.beads.sm3[0])\n pnm = depstrip(self.pnm)\n nmf = depstrip(self.nm_factor)\n\n for b in range(self.nbeads):\n sp = pnm[b]/sm # mass-scaled momentum of b-th NM\n\n for i in range(3):\n for j in range(3):\n # computes the outer product of the p of various normal modes\n # singling out Cartesian components to build the tensor\n # also takes care of the possibility of having non-RPMD masses\n kmd[i,j] += np.dot(sp[i:3*self.natoms:3],sp[j:3*self.natoms:3])/nmf[b]\n\n return kmd\n", "meta": {"hexsha": "38566736f7e1e131e4e6f5d385fafbd8a15ab8b0", "size": 16476, "ext": "py", "lang": "Python", "max_stars_repo_path": "lammps-master/tools/i-pi/ipi/engine/normalmodes.py", "max_stars_repo_name": "rajkubp020/helloword", "max_stars_repo_head_hexsha": "4bd22691de24b30a0f5b73821c35a7ac0666b034", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lammps-master/tools/i-pi/ipi/engine/normalmodes.py", "max_issues_repo_name": "rajkubp020/helloword", "max_issues_repo_head_hexsha": "4bd22691de24b30a0f5b73821c35a7ac0666b034", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lammps-master/tools/i-pi/ipi/engine/normalmodes.py", "max_forks_repo_name": "rajkubp020/helloword", "max_forks_repo_head_hexsha": "4bd22691de24b30a0f5b73821c35a7ac0666b034", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.0872817955, "max_line_length": 214, "alphanum_fraction": 0.6460912843, "include": true, "reason": "import numpy", "num_tokens": 4155, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5851011542032312, "lm_q2_score": 0.34158249273565866, "lm_q1q2_score": 0.1998603107552507}} {"text": "import numpy as np\nimport matplotlib.pyplot as plt\nfrom astropy import units as u\nfrom astropy.io import fits\nfrom astropy.nddata import CCDData\nfrom astropy.nddata import Cutout2D\nfrom astropy.wcs import WCS\nfrom .utils import *\n\n\n__all__ = ['imgblock_standard', 'imgblock_subcomp']\n\nclass imgblock_standard(object):\n '''\n GALFIT standard output. E.g., output from\n `galfit -o2 (standard img. block)`\n '''\n def __init__(self, filename, zeromag=None, pixelscale=None, exptime=None,\n sigmasky=None, unit=None):\n '''\n Parameters\n ----------\n filename : string\n Path of the GALFIT output file.\n '''\n f = fits.open(filename)\n header = f[1].header\n self.model_info = get_model_from_header(header)\n self.zeromag = zeromag\n self.sigmasky = sigmasky\n\n if unit is None:\n unit = convert_unit_hst2astropy(header.get('BUNIT'))\n self.unit = unit\n\n self.extensions = {\n 'data': [CCDData.read(filename, hdu=1, unit=unit), None],\n 'model': [CCDData.read(filename, hdu=2, unit=unit), None],\n 'residual': [CCDData.read(filename, hdu=3, unit=unit), None]\n }\n if pixelscale is None:\n pixelscale = self.get_pixelscale_wcs(units='arcsec')\n self.pixelscale = pixelscale\n if exptime is None:\n exptime = header.get('EXPTIME', None)\n self.exptime = exptime\n self.isophotes = {}\n\n def cut_fov(self, position, size):\n '''\n Cut the field of view.\n\n Parameters\n ----------\n position : (x, y)\n Position of the image center, units: pixel.\n size : (dx, dy)\n Size of the new image, units: pixel.\n '''\n for loop, ext_name in enumerate(self.extensions):\n ext, tag = self.extensions[ext_name]\n img_cut = Cutout2D(ext.data, position=position, size=size)\n if ext.wcs is not None:\n header = ext.wcs.to_header()\n crpix_org = [header['CRPIX1'], header['CRPIX2']]\n crpix_new = img_cut.to_cutout_position(crpix_org)\n header['CRPIX1'] = crpix_new[0]\n header['CRPIX2'] = crpix_new[1]\n wcs = WCS(header)\n else:\n wcs = None\n\n if ext.mask is not None:\n mask = Cutout2D(ext.mask, position=position, size=size).data\n else:\n mask = None\n ccd_new = CCDData(img_cut.data, wcs=wcs, mask=mask, unit=ext.unit)\n self.extensions[ext_name] = [ccd_new, tag]\n\n def fit_ellipse(self, ext_name, x0=None, y0=None, sma=None, eps=0, pa=0,\n expand=False, **kwargs):\n '''\n Fit isophotes of an extension.\n\n Parameters\n ----------\n ext_name : string\n Name of the extenstion to be fitted.\n x0, y0 : float\n The center pixel coordinate of the ellipse.\n sma : float\n The semimajor axis of the ellipse in pixels.\n eps : ellipticity\n The ellipticity of the ellipse.\n pa : float\n The position angle (in radians) of the semimajor axis in\n relation to the postive x axis of the image array (rotating\n towards the positive y axis). Position angles are defined in the\n range :math:`0 < PA <= \\\\pi`. Avoid using as starting position\n angle of 0., since the fit algorithm may not work properly. When\n the ellipses are such that position angles are near either\n extreme of the range, noise can make the solution jump back and\n forth between successive isophotes, by amounts close to 180\n degrees.\n **kwargs : Additional parameters feed to ellipse.fit_image().\n\n Returns\n -------\n isolist : IsophoteList instance\n A list-like object of Isophote instances, sorted by increasing\n semimajor axis length.\n '''\n ext = self.get_extension(ext_name)\n if ext.mask is None:\n image = ext.data\n else:\n image = np.ma.array(ext.data, mask=ext.mask)\n\n if x0 is None:\n x0 = image.shape[1] / 2\n if y0 is None:\n y0 = image.shape[0] / 2\n if sma is None:\n ## Estimate the size of the source\n #xx, yy = np.meshgrid(np.arange(image.shape[1]), np.arange(image.shape[0]))\n #xx = xx.astype(np.float64) - x0\n #yy = yy.astype(np.float64) - y0\n #rr = np.sqrt(xx**2 + yy**2)\n #sma = np.sum(rr * image) / np.sum(image)\n sma = 10\n\n isolist = fit_ellipse(image, x0, y0, sma, eps, pa, **kwargs)\n\n if expand is True:\n step = kwargs.get('step', 0.1)\n fflag = kwargs.get('fflag', 0.7)\n maxsma = kwargs.get('maxsma', None)\n isolist_exp = grow_isophote(image, isolist[-1], step=step, fflag=fflag,\n maxsma=maxsma, maxsteps=np.inf)\n isolist = isolist + isolist_exp\n\n self.isophotes[ext_name] = isolist\n return isolist\n\n def fit_isophote(self, ext_name, isolist):\n '''\n Fit isophotes according to the input isolist.\n\n Parameters\n ----------\n ext_name : string\n Name of the extenstion to be fitted.\n isolist : IsophoteList\n Input isophotes.\n\n Returns\n -------\n isolist_out : IsophoteList\n New measurements.\n '''\n ext = self.get_extension(ext_name)\n if ext.mask is None:\n image = ext.data\n else:\n image = np.ma.array(ext.data, mask=ext.mask)\n isolist_out = fit_isophote(image, isolist)\n self.isophotes[ext_name] = isolist_out\n return isolist_out\n\n def get_CRPIX(self):\n '''\n Get the reference pixel.\n '''\n header = self.extensions['data'][0].wcs.to_header()\n return (header['CRPIX1'], header['CRPIX2'])\n\n def get_extension(self, ext_name):\n '''\n Get the extension data.\n '''\n return self.extensions[ext_name][0]\n\n def get_extent(self, units='arcsec'):\n '''\n Get the extent for imshow based on the data wcs.\n\n Parameters\n ----------\n units : string (default: 'arcsec')\n Units of the pixel scale.\n '''\n data = self.get_extension('data')\n nrow, ncol = data.shape\n x_len = ncol * self.get_pixelscale(units)\n y_len = nrow * self.get_pixelscale(units)\n extent = (-x_len/2, x_len/2, -y_len/2, y_len/2)\n return extent\n\n def get_ImageCenter(self):\n '''\n Get the central pixel of the image.\n\n BE CAREFUL:\n For values exactly halfway between rounded decimal values, NumPy\n rounds to the nearest even value. Thus 1.5 and 2.5 round to 2.0,\n -0.5 and 0.5 round to 0.0, etc.\n '''\n image = self.get_extension('data').data\n xcent = np.around(image.shape[1]/2.0, decimals=0)\n ycent = np.around(image.shape[0]/2.0, decimals=0)\n return (xcent, ycent)\n\n def get_isolist(self, ext_name):\n '''\n Get isolist of an extension.\n '''\n return self.isophotes[ext_name]\n\n def get_mu(self, ext_name, pixelscale=None, exptime=None, zeromag=None, sigmasky=None):\n '''\n Get the surface brightness.\n '''\n isolist = self.isophotes.get(ext_name, None)\n if isolist is None:\n raise KeyError('Cannot find isolist for {0}!'.format(ext_name))\n if pixelscale is None:\n assert self.pixelscale is not None\n pixelscale = self.pixelscale\n if exptime is None:\n assert self.exptime is not None\n exptime = self.exptime\n if zeromag is None:\n assert self.zeromag is not None\n zeromag = self.zeromag\n if sigmasky is None:\n if self.sigmasky is None:\n sigmasky = 0\n else:\n sigmasky = self.sigmasky\n\n x = isolist.sma * pixelscale\n y = isolist.intens / exptime / pixelscale**2\n e = np.sqrt(isolist.int_err**2 + sigmasky**2) / exptime / pixelscale**2\n y, e = flux2mag(y, e, zeromag)\n return x, y, e\n\n def get_tag(self, ext_name):\n '''\n Get the extension tag.\n '''\n return self.extensions[ext_name][1]\n\n def get_pixelscale(self, units='arcsec'):\n '''\n Get pixel scale of the data image.\n '''\n ps_arcsec = self.pixelscale * u.arcsec\n ps_out = ps_arcsec.to(units).value\n return ps_out\n\n def get_pixelscale_wcs(self, units='arcsec'):\n '''\n Get pixel scale of the data image from WCS.\n '''\n cdelt1, cdelt2 = wcs_pixel_scale(self.get_extension('data').wcs)\n cdelt1 = cdelt1.to(units).value\n cdelt2 = cdelt2.to(units).value\n if not np.isclose(cdelt1, cdelt2, rtol=0.001):\n raise ValueError('The pixel scale of two axes are not the same!')\n ps = (cdelt1 + cdelt2) / 2\n return ps\n\n def grow_isophote(self, ext_name, isophote, step=0.1, fflag=0.7, maxsma=None,\n maxsteps=1000):\n '''\n Fit the isophote of the extension starting from the input isophote and\n use its shape fixed.\n\n Parameters\n ----------\n ext_name : string\n The name of the extension.\n isophote : photutils.isophote.Isophote\n The isophote to be expanded.\n step : float (default: 0.1)\n The step value for growing/shrinking the semimajor axis.\n fflag : float (default: 0.7)\n The acceptable fraction of flagged data points in the\n sample. If the actual fraction of valid data points is\n smaller than this, the iterations will stop. Flagged\n data points are points that either lie outside the image\n frame, are masked, or were rejected by sigma-clipping.\n maxsma (optional) : float\n Maximum semimajor axis length, units: pixel.\n maxsteps : int (default: 1000)\n Maximum steps to grow the isophote.\n '''\n ext = self.get_extension(ext_name)\n if ext.mask is None:\n image = ext.data\n else:\n image = np.ma.array(ext.data, mask=ext.mask)\n isolist = grow_isophote(image, isophote, step=step, fflag=fflag,\n maxsma=maxsma, maxsteps=maxsteps)\n return isolist\n\n def plot_direction(self, ax, xy, len_E=None, len_N=None, color='k', fontsize=20,\n linewidth=2, frac_len=0.15, units='arcsec', backextend=0.05):\n '''\n Plot the direction arrow. Only applied to plots using WCS.\n\n Parameters\n ----------\n ax : Axis\n Axis to plot the direction.\n xy : (x, y)\n Coordinate of the origin of the arrows.\n length : float\n Length of the arrows, units: pixel.\n units: string (default: arcsec)\n Units of xy.\n '''\n xlim = ax.get_xlim()\n len_total = np.abs(xlim[1] - xlim[0])\n pixelscale = self.get_pixelscale(units)\n if len_E is None:\n len_E = len_total * frac_len / pixelscale\n if len_N is None:\n len_N = len_total * frac_len / pixelscale\n\n wcs = self.extensions['data'][0].wcs\n header = wcs.to_header()\n d_ra = len_E * self.get_pixelscale('degree')\n d_dec = len_N * self.get_pixelscale('degree')\n ra = [header['CRVAL1'], header['CRVAL1']+d_ra, header['CRVAL1']]\n dec = [header['CRVAL2'], header['CRVAL2'], header['CRVAL2']+d_dec]\n ra_pix, dec_pix = wcs.all_world2pix(ra, dec, 1)\n d_arrow1 = [ra_pix[1]-ra_pix[0], dec_pix[1]-dec_pix[0]]\n d_arrow2 = [ra_pix[2]-ra_pix[0], dec_pix[2]-dec_pix[0]]\n l_arrow1 = np.sqrt(d_arrow1[0]**2 + d_arrow1[1]**2)\n l_arrow2 = np.sqrt(d_arrow2[0]**2 + d_arrow2[1]**2)\n d_arrow1 = np.array(d_arrow1) / l_arrow1 * len_E * pixelscale\n d_arrow2 = np.array(d_arrow2) / l_arrow2 * len_N * pixelscale\n\n def sign_2_align(sign):\n '''\n Determine the alignment of the text.\n '''\n if sign[0] < 0:\n ha = 'right'\n else:\n ha = 'left'\n if sign[1] < 0:\n va = 'top'\n else:\n va = 'bottom'\n return ha, va\n ha1, va1 = sign_2_align(np.sign(d_arrow1))\n ha2, va2 = sign_2_align(np.sign(d_arrow2))\n\n xy_e = (xy[0] - d_arrow1[0] * backextend, xy[1] - d_arrow1[1] * backextend)\n ax.annotate('E', xy=xy_e, xycoords='data', fontsize=fontsize,\n xytext=(d_arrow1[0]+xy[0], d_arrow1[1]+xy[1]), color=color,\n arrowprops=dict(color=color, arrowstyle=\"<-\", lw=linewidth),\n ha=ha1, va=va1)\n xy_n = (xy[0] - d_arrow2[0] * backextend, xy[1] - d_arrow2[1] * backextend)\n ax.annotate('N', xy=xy_n, xycoords='data', fontsize=fontsize,\n xytext=(d_arrow2[0]+xy[0], d_arrow2[1]+xy[1]), color=color,\n arrowprops=dict(color=color, arrowstyle=\"<-\", lw=linewidth),\n ha=ha2, va=va2)\n\n def plot_extension(self, ext_name, stretch='asinh', units='arcsec',\n vmin=None, vmax=None, a=None, ax=None, plain=False,\n **kwargs):\n '''\n Plot one extenstion.\n\n Parameters\n ----------\n ext_name : string\n Extension name.\n stretch : string (default: 'asinh')\n Choice of stretch: asinh, linear, sqrt, log.\n units : string (default: 'arcsec')\n Units of pixel scale.\n vmin (optional) : float\n Minimal value of imshow.\n vmax (optional) : float\n Maximal value of imshow.\n a (optional) : float\n Scale factor of some stretch function.\n ax (optional) : matplotlib Axis\n Axis to plot the image.\n plain : bool (default: False)\n If False, tune the image.\n **kwargs : Additional parameters goes into plt.imshow()\n\n Returns\n -------\n ax : matplotlib Axis\n Axis to plot the image.\n '''\n ext = self.get_extension(ext_name)\n ax = plot_image(ext, ext.wcs, stretch, units, vmin, vmax, a, ax, plain, **kwargs)\n return ax\n\n def plot_ellipse(self, ext_name, ax=None, thin=1, **kwargs):\n '''\n Plot the ellipse isophotes.\n '''\n if ax is None:\n plt.figure(figsize=(7, 7))\n ax = plt.gca()\n\n isolist = self.isophotes.get(ext_name, None)\n if isolist is None:\n raise KeyError('Cannot find isolist for {0}!'.format(ext_name))\n\n if 'color' not in kwargs:\n kwargs['color'] = 'r'\n if 'lw' not in kwargs:\n kwargs['lw'] = 0.5\n for iso in isolist[::thin]:\n x, y, = iso.sampled_coordinates()\n ax.plot(x, y, **kwargs)\n return ax\n\n def plot_mu(self, ext_name, xscale='log', yscale='mag', pixelscale=None,\n zeromag=None, exptime=None, ax=None, plain=False, show_error=True,\n error_type='int_err', **kwargs):\n '''\n Plot surface brightness profile.\n '''\n if yscale == 'mag':\n x, y, e = self.get_mu(ext_name, pixelscale=pixelscale, exptime=exptime,\n zeromag=zeromag)\n else:\n isolist = self.isophotes.get(ext_name, None)\n if isolist is None:\n raise KeyError('Cannot find isolist for {0}!'.format(ext_name))\n x = isolist.sma\n y = isolist.intens\n e = isolist.int_err\n\n # Plot\n if ax is None:\n plt.figure(figsize=(7, 7))\n ax = plt.gca()\n if show_error is True:\n ax.errorbar(x, y, yerr=e, **kwargs)\n else:\n ax.plot(x, y, **kwargs)\n if plain is False:\n if yscale == 'mag':\n ax.set_xlabel(r'Radius (arcsec)', fontsize=24)\n ax.set_ylabel(r'$\\mu\\,(\\mathrm{mag\\,arcsec^{-2}})$', fontsize=24)\n else:\n ax.set_xlabel(r'Radius (pixel)', fontsize=24)\n ax.set_ylabel(r'Flux ({0} per pixel)'.format(self.unit), fontsize=24)\n ax.minorticks_on()\n ax.set_xscale(xscale)\n if yscale != 'mag':\n ax.set_yscale(yscale)\n else:\n ax.invert_yaxis()\n return ax\n\n def remove_mask(self, ext_name):\n '''\n Remove the mask of the extension.\n '''\n self.extensions[ext_name][0].mask = None\n\n def set_mask(self, ext_name, mask):\n '''\n Set mask for the extension.\n\n Parameters\n ----------\n ext_name : string\n The name of the extentsion.\n mask : 2D array\n The mask.\n '''\n if ext_name not in self.extensions:\n raise ValueError('Cannot find {0} in the extensions!'.format(ext_name))\n\n assert self.extensions[ext_name][0].shape == mask.shape, 'Mask shape incorrect!'\n self.extensions[ext_name][0].mask = mask\n\n def __getitem__(self, key):\n '''\n Get the extension and tag.\n\n Parameters\n ----------\n key : string\n Name of extention.\n '''\n return self.extensions[key]\n\n def __repr__(self):\n ext_names = list(self.extensions.keys())\n image = self.get_extension(self.get_ext_names()[0])\n info1 = 'Extensions: {0}'.format(', '.join(ext_names))\n info2 = 'Image size: {0}x{1}'.format(image.shape[1], image.shape[0])\n return '\\n'.join([info1, info2])\n\n\nclass imgblock_subcomp(object):\n '''\n GALFIT subcomponent output. E.g., output from\n `galfit -o3 (standard img. block)`\n '''\n def __init__(self, filename, zeromag=None, pixelscale=None, exptime=None, unit='adu'):\n '''\n Parameters\n ----------\n filename : string\n Path of the GALFIT output file.\n '''\n f = fits.open(filename)\n header = f[1].header\n self.model_info = get_model_from_header(header)\n self.unit = unit\n self.zeromag = zeromag\n self.pixelscale = pixelscale\n self.exptime = exptime\n\n self.extensions = {}\n for loop in range(self.model_info['N_components']):\n ext = CCDData.read(filename, hdu=loop+1, unit=unit)\n ext_obj = ext.header['OBJECT']\n counter = 0\n comp_name = '{0}_{1}'.format(ext_obj, counter)\n while True:\n if comp_name in self.extensions:\n counter += 1\n comp_name = '{0}_{1}'.format(ext_obj, counter)\n else:\n break\n self.extensions[comp_name] = [ext, None]\n self.isophotes = {}\n\n def combine_components(self, ext_list, ext_name=None, tag=None):\n '''\n Combine the components.\n\n Parameters\n ----------\n ext_list : list\n List of extension names.\n\n Returns\n -------\n ext : 2D array\n Image combining different components.\n '''\n extList = []\n for en in ext_list:\n extList.append(self.get_extension(en).data)\n ext = CCDData(np.sum(extList, axis=0), unit=self.unit)\n\n if ext_name is not None:\n assert ext_name not in self.extensions, 'The name has been used!'\n self.extensions[ext_name] = (ext, tag)\n return ext\n\n def cut_fov(self, position, size):\n '''\n Cut the field of view.\n\n Parameters\n ----------\n position : (x, y)\n Position of the image center, units: pixel.\n size : (dx, dy)\n Size of the new image, units: pixel.\n '''\n for loop, ext_name in enumerate(self.extensions):\n ext, tag = self.extensions[ext_name]\n img_cut = Cutout2D(ext.data, position=position, size=size).data\n if ext.mask is not None:\n mask = Cutout2D(ext.mask, position=position, size=size).data\n else:\n mask = None\n ccd_new = CCDData(img_cut, wcs=ext.wcs, mask=mask, unit=ext.unit)\n self.extensions[ext_name] = [ccd_new, tag]\n\n def fit_ellipse(self, ext_name, x0=None, y0=None, sma=None, eps=0, pa=0,\n expand=False, **kwargs):\n '''\n Fit isophotes of an extension.\n\n Parameters\n ----------\n ext_name : string\n Name of the extenstion to be fitted.\n x0, y0 : float\n The center pixel coordinate of the ellipse.\n sma : float\n The semimajor axis of the ellipse in pixels.\n eps : ellipticity\n The ellipticity of the ellipse.\n pa : float\n The position angle (in radians) of the semimajor axis in\n relation to the postive x axis of the image array (rotating\n towards the positive y axis). Position angles are defined in the\n range :math:`0 < PA <= \\\\pi`. Avoid using as starting position\n angle of 0., since the fit algorithm may not work properly. When\n the ellipses are such that position angles are near either\n extreme of the range, noise can make the solution jump back and\n forth between successive isophotes, by amounts close to 180\n degrees.\n **kwargs : Additional parameters feed to ellipse.fit_image().\n\n Returns\n -------\n isolist : IsophoteList instance\n A list-like object of Isophote instances, sorted by increasing\n semimajor axis length.\n '''\n ext = self.get_extension(ext_name)\n if ext.mask is None:\n image = ext.data\n else:\n image = np.ma.array(ext.data, mask=ext.mask)\n\n if x0 is None:\n x0 = image.shape[1] / 2\n if y0 is None:\n y0 = image.shape[0] / 2\n if sma is None:\n ## Estimate the size of the source\n #xx, yy = np.meshgrid(np.arange(image.shape[1]), np.arange(image.shape[0]))\n #xx = xx.astype(np.float64) - x0\n #yy = yy.astype(np.float64) - y0\n #rr = np.sqrt(xx**2 + yy**2)\n #sma = np.sum(rr * image) / np.sum(image)\n sma = 10\n\n isolist = fit_ellipse(image, x0, y0, sma, eps, pa, **kwargs)\n\n if expand is True:\n step = kwargs.get('step', 0.1)\n fflag = kwargs.get('fflag', 0.7)\n maxsma = kwargs.get('maxsma', None)\n isolist_exp = grow_isophote(image, isolist[-1], step=step, fflag=fflag,\n maxsma=maxsma, maxsteps=np.inf)\n isolist = isolist + isolist_exp\n\n self.isophotes[ext_name] = isolist\n return isolist\n\n def fit_isophote(self, ext_name, isolist):\n '''\n Fit isophotes according to the input isolist.\n\n Parameters\n ----------\n ext_name : string\n Name of the extenstion to be fitted.\n isolist : IsophoteList\n Input isophotes.\n\n Returns\n -------\n isolist_out : IsophoteList\n New measurements.\n '''\n ext = self.get_extension(ext_name)\n if ext.mask is None:\n image = ext.data\n else:\n image = np.ma.array(ext.data, mask=ext.mask)\n isolist_out = fit_isophote(image, isolist)\n self.isophotes[ext_name] = isolist_out\n return isolist_out\n\n def get_ext_names(self):\n '''\n Get list of extension names.\n '''\n return list(self.extensions.keys())\n\n def get_extension(self, ext_name):\n '''\n Get the extension data.\n '''\n return self.extensions[ext_name][0]\n\n def get_model_param(self, ext_name, parname):\n '''\n Get model parameter value.\n '''\n idx = list(self.extensions.keys()).index(ext_name) + 1\n info = self.model_info['COMP_{0}'.format(idx)]\n return info.get('{0}_{1}'.format(idx, parname))\n\n def get_mu(self, ext_name, pixelscale=None, exptime=None, zeromag=None):\n '''\n Get the surface brightness.\n '''\n isolist = self.isophotes.get(ext_name, None)\n if isolist is None:\n raise KeyError('Cannot find isolist for {0}!'.format(ext_name))\n if pixelscale is None:\n assert self.pixelscale is not None\n pixelscale = self.pixelscale\n if exptime is None:\n assert self.exptime is not None\n exptime = self.exptime\n if zeromag is None:\n assert self.zeromag is not None\n zeromag = self.zeromag\n\n x = isolist.sma * pixelscale\n y = isolist.intens / exptime / pixelscale**2\n e = isolist.int_err / exptime / pixelscale**2\n y, e = flux2mag(y, e, zeromag)\n return x, y, e\n\n def get_isolist(self, ext_name):\n '''\n Get isolist of an extension.\n '''\n return self.isophotes[ext_name]\n\n def get_tag(self, ext_name):\n '''\n Get the extension tag.\n '''\n return self.extensions[ext_name][1]\n\n def plot_extension(self, ext_name, stretch='asinh', units='arcsec',\n vmin=None, vmax=None, a=None, ax=None, plain=False,\n **kwargs):\n '''\n Plot one extenstion.\n\n Parameters\n ----------\n ext_name : string\n Extension name.\n stretch : string (default: 'asinh')\n Choice of stretch: asinh, linear, sqrt, log.\n units : string (default: 'arcsec')\n Units of pixel scale.\n vmin (optional) : float\n Minimal value of imshow.\n vmax (optional) : float\n Maximal value of imshow.\n a (optional) : float\n Scale factor of some stretch function.\n ax (optional) : matplotlib Axis\n Axis to plot the image.\n plain : bool (default: False)\n If False, tune the image.\n **kwargs : Additional parameters goes into plt.imshow()\n\n Returns\n -------\n ax : matplotlib Axis\n Axis to plot the image.\n '''\n ext = self.get_extension(ext_name)\n ax = plot_image(ext, ext.wcs, stretch, units, vmin, vmax, a, ax, plain, **kwargs)\n return ax\n\n def plot_extension_all(self, stretch='asinh', units='arcsec', vmin=None,\n vmax=None, a=None, axs=None, plain=False, **kwargs):\n '''\n Plot all of the extensions for quick look.\n '''\n next = len(self.extensions)\n if axs is None:\n fig, axs = plt.subplots(1, next, sharey=True, figsize=(5*next, 5))\n for loop, ext in enumerate(self.extensions):\n ax = axs[loop]\n self.plot_extension(ext, stretch, units, vmin, vmax, a, ax,\n True, **kwargs)\n if plain is False:\n fig.subplots_adjust(wspace=0)\n ax.text(0.05, 0.95, ext, fontsize=20, transform=ax.transAxes,\n ha='left', va='top')\n return axs\n\n def plot_ellipse(self, ext_name, ax=None, thin=1, **kwargs):\n '''\n Plot the ellipse isophotes.\n '''\n if ax is None:\n plt.figure(figsize=(7, 7))\n ax = plt.gca()\n\n isolist = self.isophotes.get(ext_name, None)\n if isolist is None:\n raise KeyError('Cannot find isolist for {0}!'.format(ext_name))\n\n if 'color' not in kwargs:\n kwargs['color'] = 'r'\n if 'lw' not in kwargs:\n kwargs['lw'] = 0.5\n for iso in isolist[::thin]:\n x, y, = iso.sampled_coordinates()\n ax.plot(x, y, **kwargs)\n return ax\n\n def plot_mu(self, ext_name, xscale='log', yscale='mag', pixelscale=None,\n zeromag=None, exptime=None, ax=None, plain=False, **kwargs):\n '''\n Plot surface brightness profile.\n '''\n if yscale == 'mag':\n x, y, e = self.get_mu(ext_name, pixelscale=pixelscale, exptime=exptime,\n zeromag=zeromag)\n else:\n isolist = self.isophotes.get(ext_name, None)\n if isolist is None:\n raise KeyError('Cannot find isolist for {0}!'.format(ext_name))\n x = isolist.sma\n y = isolist.intens\n e = isolist.int_err\n\n # Plot\n if ax is None:\n plt.figure(figsize=(7, 7))\n ax = plt.gca()\n ax.plot(x, y, **kwargs)\n if plain is False:\n if yscale == 'mag':\n ax.set_xlabel(r'Radius (arcsec)', fontsize=24)\n ax.set_ylabel(r'$\\mu\\,(\\mathrm{mag\\,arcsec^{-2}})$', fontsize=24)\n else:\n ax.set_xlabel(r'Radius (pixel)', fontsize=24)\n ax.set_ylabel(r'Flux ({0} per pixel)'.format(self.unit), fontsize=24)\n ax.minorticks_on()\n ax.set_xscale(xscale)\n if yscale != 'mag':\n ax.set_yscale(yscale)\n else:\n ax.invert_yaxis()\n return ax\n\n def remove_mask(self, ext_name):\n '''\n Remove the mask of the extension.\n '''\n self.extensions[ext_name][0].mask = None\n\n def set_mask(self, ext_name, mask):\n '''\n Set mask for the extension.\n\n Parameters\n ----------\n ext_name : string\n The name of the extentsion.\n mask : 2D array\n The mask.\n '''\n if ext_name not in self.extensions:\n raise ValueError('Cannot find {0} in the extensions!'.format(ext_name))\n\n assert self.extensions[ext_name][0].shape == mask.shape, 'Mask shape incorrect!'\n self.extensions[ext_name][0].mask = mask\n\n def set_tag(self, ext_name, tag):\n '''\n Set the tag.\n '''\n self.extensions[ext_name][1] = tag\n\n def __getitem__(self, key):\n '''\n Get the extension and tag.\n\n Parameters\n ----------\n key : string\n Name of extention.\n '''\n return self.extensions[key]\n\n def __repr__(self):\n ext_names = list(self.extensions.keys())\n image = self.get_extension(self.get_ext_names()[0])\n info1 = 'Extensions: {0}'.format(', '.join(ext_names))\n info2 = 'Image size: {0}x{1}'.format(image.shape[1], image.shape[0])\n return '\\n'.join([info1, info2])\n", "meta": {"hexsha": "f1d65d340c8976098730f1712f38f174e084c924", "size": 30915, "ext": "py", "lang": "Python", "max_stars_repo_path": "sgGALFIT/output_wrapper.py", "max_stars_repo_name": "jyshangguan/sgAstroTool", "max_stars_repo_head_hexsha": "05392b57848598655a1d2c52fd3b1f1392243575", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-02-01T04:49:16.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-01T04:49:16.000Z", "max_issues_repo_path": "sgGALFIT/output_wrapper.py", "max_issues_repo_name": "jyshangguan/sgAstroTool", "max_issues_repo_head_hexsha": "05392b57848598655a1d2c52fd3b1f1392243575", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2018-12-11T06:59:27.000Z", "max_issues_repo_issues_event_max_datetime": "2020-02-25T15:51:13.000Z", "max_forks_repo_path": "sgGALFIT/output_wrapper.py", "max_forks_repo_name": "jyshangguan/sgAstroTool", "max_forks_repo_head_hexsha": "05392b57848598655a1d2c52fd3b1f1392243575", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-02-25T15:29:06.000Z", "max_forks_repo_forks_event_max_datetime": "2020-02-25T15:29:06.000Z", "avg_line_length": 34.696969697, "max_line_length": 91, "alphanum_fraction": 0.5406760472, "include": true, "reason": "import numpy,from astropy", "num_tokens": 7542, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5851011542032312, "lm_q2_score": 0.34158248603300034, "lm_q1q2_score": 0.1998603068335176}} {"text": "# -*- coding: utf-8 -*-\n# vim: tabstop=4 shiftwidth=4 softtabstop=4\n#\n# Copyright (C) 2014-2018 GEM Foundation\n#\n# OpenQuake is free software: you can redistribute it and/or modify it\n# under the terms of the GNU Affero General Public License as published\n# by the Free Software Foundation, either version 3 of the License, or\n# (at your option) any later version.\n#\n# OpenQuake is distributed in the hope that it will be useful,\n# but WITHOUT ANY WARRANTY; without even the implied warranty of\n# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n# GNU Affero General Public License for more details.\n#\n# You should have received a copy of the GNU Affero General Public License\n# along with OpenQuake. If not, see .\n\n\"\"\"\nModule exports :class:`AbrahamsonEtAl2014`\n :class:`AbrahamsonEtAl2014RegCHN`\n :class:`AbrahamsonEtAl2014RegJPN`\n :class:`AbrahamsonEtAl2014RegTWN`\n\"\"\"\nimport copy\nimport numpy as np\n\nfrom scipy import interpolate\nfrom openquake.hazardlib.gsim.base import GMPE, CoeffsTable\nfrom openquake.hazardlib import const\nfrom openquake.hazardlib.imt import PGA, PGV, SA\n\nMETRES_PER_KM = 1000.0\n\n\nclass AbrahamsonEtAl2014(GMPE):\n \"\"\"\n Implements GMPE by Abrahamson, Silva and Kamai developed within the\n the PEER West 2 Project. This GMPE is described in a paper\n published in 2014 on Earthquake Spectra, Volume 30, Number 3 and\n titled 'Summary of the ASK14 Ground Motion Relation for Active Crustal\n Regions'.\n \"\"\"\n #: Supported tectonic region type is active shallow crust, see title!\n DEFINED_FOR_TECTONIC_REGION_TYPE = const.TRT.ACTIVE_SHALLOW_CRUST\n\n #: Supported intensity measure types are spectral acceleration, peak\n #: ground velocity and peak ground acceleration, see tables 4\n #: pages 1036\n DEFINED_FOR_INTENSITY_MEASURE_TYPES = set([\n PGA,\n PGV,\n SA\n ])\n\n #: Supported intensity measure component is orientation-independent\n #: average horizontal :attr:`~openquake.hazardlib.const.IMC.RotD50`,\n #: see page 1025.\n DEFINED_FOR_INTENSITY_MEASURE_COMPONENT = const.IMC.RotD50\n\n #: Supported standard deviation types are inter-event, intra-event\n #: and total, see paragraph \"Equations for standard deviations\", page\n #: 1046.\n DEFINED_FOR_STANDARD_DEVIATION_TYPES = set([\n const.StdDev.TOTAL,\n const.StdDev.INTER_EVENT,\n const.StdDev.INTRA_EVENT\n ])\n\n #: Required site parameters are Vs30 and Z1.0, see table 2, page 1031\n #: Unit of measure for Z1.0 is [m]\n REQUIRES_SITES_PARAMETERS = set(('vs30', 'z1pt0', 'vs30measured'))\n\n #: Required rupture parameters are magnitude, rake, dip, ztor, and width\n #: (see table 2, page 1031)\n REQUIRES_RUPTURE_PARAMETERS = set(('mag', 'rake', 'dip', 'ztor', 'width'))\n\n #: Required distance measures are Rrup, Rjb, Ry0 and Rx (see Table 2,\n #: page 1031).\n REQUIRES_DISTANCES = set(('rrup', 'rjb', 'rx', 'ry0'))\n\n def get_mean_and_stddevs(self, sites, rup, dists, imt, stddev_types):\n \"\"\"\n See :meth:`superclass method\n <.base.GroundShakingIntensityModel.get_mean_and_stddevs>`\n for spec of input and result values.\n \"\"\"\n # get the necessary set of coefficients\n C = self.COEFFS[imt]\n # compute median sa on rock (vs30=1180m/s). Used for site response\n # term calculation\n sa1180 = np.exp(self._get_sa_at_1180(C, imt, sites, rup, dists))\n\n # get the mean value\n mean = (self._get_basic_term(C, rup, dists) +\n self._get_faulting_style_term(C, rup) +\n self._get_site_response_term(C, imt, sites.vs30, sa1180) +\n self._get_hanging_wall_term(C, dists, rup) +\n self._get_top_of_rupture_depth_term(C, imt, rup) +\n self._get_soil_depth_term(C, sites.z1pt0 / METRES_PER_KM,\n sites.vs30)\n )\n mean += self._get_regional_term(C, imt, sites.vs30, dists.rrup)\n # get standard deviations\n stddevs = self._get_stddevs(C, imt, rup, sites, stddev_types, sa1180,\n dists)\n return mean, stddevs\n\n def _get_sa_at_1180(self, C, imt, sites, rup, dists):\n \"\"\"\n Compute and return mean imt value for rock conditions\n (vs30 = 1100 m/s)\n \"\"\"\n # reference vs30 = 1180 m/s\n vs30_1180 = np.ones_like(sites.vs30) * 1180.\n # reference shaking intensity = 0\n ref_iml = np.zeros_like(sites.vs30)\n # fake Z1.0 - Since negative it will be replaced by the default Z1.0\n # for the corresponding region\n fake_z1pt0 = np.ones_like(sites.vs30) * -1\n return (self._get_basic_term(C, rup, dists) +\n self._get_faulting_style_term(C, rup) +\n self._get_site_response_term(C, imt, vs30_1180, ref_iml) +\n self._get_hanging_wall_term(C, dists, rup) +\n self._get_top_of_rupture_depth_term(C, imt, rup) +\n self._get_soil_depth_term(C, fake_z1pt0, vs30_1180) +\n self._get_regional_term(C, imt, vs30_1180, dists.rrup)\n )\n\n def _get_basic_term(self, C, rup, dists):\n \"\"\"\n Compute and return basic form, see page 1030.\n \"\"\"\n # Fictitious depth calculation\n if rup.mag > 5.:\n c4m = C['c4']\n elif rup.mag > 4.:\n c4m = C['c4'] - (C['c4']-1.) * (5. - rup.mag)\n else:\n c4m = 1.\n R = np.sqrt(dists.rrup**2. + c4m**2.)\n # basic form\n base_term = C['a1'] * np.ones_like(dists.rrup) + C['a17'] * dists.rrup\n # equation 2 at page 1030\n if rup.mag >= C['m1']:\n base_term += (C['a5'] * (rup.mag - C['m1']) +\n C['a8'] * (8.5 - rup.mag)**2. +\n (C['a2'] + C['a3'] * (rup.mag - C['m1'])) *\n np.log(R))\n elif rup.mag >= self.CONSTS['m2']:\n base_term += (C['a4'] * (rup.mag - C['m1']) +\n C['a8'] * (8.5 - rup.mag)**2. +\n (C['a2'] + C['a3'] * (rup.mag - C['m1'])) *\n np.log(R))\n else:\n base_term += (C['a4'] * (self.CONSTS['m2'] - C['m1']) +\n C['a8'] * (8.5 - self.CONSTS['m2'])**2. +\n C['a6'] * (rup.mag - self.CONSTS['m2']) +\n C['a7'] * (rup.mag - self.CONSTS['m2'])**2. +\n (C['a2'] + C['a3'] * (self.CONSTS['m2'] - C['m1'])) *\n np.log(R))\n return base_term\n\n def _get_faulting_style_term(self, C, rup):\n \"\"\"\n Compute and return faulting style term, that is the sum of the second\n and third terms in equation 1, page 74.\n \"\"\"\n # this implements equations 5 and 6 at page 1032. f7 is the\n # coefficient for reverse mechanisms while f8 is the correction\n # factor for normal ruptures\n if rup.mag > 5.0:\n f7 = C['a11']\n f8 = C['a12']\n elif rup.mag >= 4:\n f7 = C['a11'] * (rup.mag - 4.)\n f8 = C['a12'] * (rup.mag - 4.)\n else:\n f7 = 0.0\n f8 = 0.0\n # ranges of rake values for each faulting mechanism are specified in\n # table 2, page 1031\n return (f7 * float(rup.rake > 30 and rup.rake < 150) +\n f8 * float(rup.rake > -150 and rup.rake < -30))\n\n def _get_vs30star(self, vs30, imt):\n \"\"\"\n This computes equations 8 and 9 at page 1034\n \"\"\"\n # compute the v1 value (see eq. 9, page 1034)\n if isinstance(imt, SA):\n t = imt.period\n if t <= 0.50:\n v1 = 1500.0\n elif t < 3.0:\n v1 = np.exp(-0.35 * np.log(t / 0.5) + np.log(1500.))\n else:\n v1 = 800.0\n elif isinstance(imt, PGA):\n v1 = 1500.0\n else:\n # This covers the PGV case\n v1 = 1500.0\n # set the vs30 star value (see eq. 8, page 1034)\n vs30_star = np.ones_like(vs30) * vs30\n vs30_star[vs30 >= v1] = v1\n return vs30_star\n\n def _get_site_response_term(self, C, imt, vs30, sa1180):\n \"\"\"\n Compute and return site response model term see page 1033\n \"\"\"\n # vs30 star\n vs30_star = self._get_vs30star(vs30, imt)\n # compute the site term\n site_resp_term = np.zeros_like(vs30)\n gt_vlin = vs30 >= C['vlin']\n lw_vlin = vs30 < C['vlin']\n # compute site response term for sites with vs30 greater than vlin\n vs30_rat = vs30_star / C['vlin']\n site_resp_term[gt_vlin] = ((C['a10'] + C['b'] * self.CONSTS['n']) *\n np.log(vs30_rat[gt_vlin]))\n # compute site response term for sites with vs30 lower than vlin\n site_resp_term[lw_vlin] = (C['a10'] * np.log(vs30_rat[lw_vlin]) -\n C['b'] * np.log(sa1180[lw_vlin] + C['c']) +\n C['b'] * np.log(sa1180[lw_vlin] + C['c'] *\n vs30_rat[lw_vlin] **\n self.CONSTS['n']))\n return site_resp_term\n\n def _get_hanging_wall_term(self, C, dists, rup):\n \"\"\"\n Compute and return hanging wall model term, see page 1038.\n \"\"\"\n if rup.dip == 90.0:\n return np.zeros_like(dists.rx)\n else:\n Fhw = np.zeros_like(dists.rx)\n Fhw[dists.rx > 0] = 1.\n # Compute taper t1\n T1 = np.ones_like(dists.rx)\n T1 *= 60./45. if rup.dip <= 30. else (90.-rup.dip)/45.0\n # Compute taper t2 (eq 12 at page 1039) - a2hw set to 0.2 as\n # indicated at page 1041\n T2 = np.zeros_like(dists.rx)\n a2hw = 0.2\n if rup.mag > 6.5:\n T2 += (1. + a2hw * (rup.mag - 6.5))\n elif rup.mag > 5.5:\n T2 += (1. + a2hw * (rup.mag - 6.5) - (1. - a2hw) *\n (rup.mag - 6.5)**2)\n else:\n T2 *= 0.\n # Compute taper t3 (eq. 13 at page 1039) - r1 and r2 specified at\n # page 1040\n T3 = np.zeros_like(dists.rx)\n r1 = rup.width * np.cos(np.radians(rup.dip))\n r2 = 3. * r1\n #\n idx = dists.rx < r1\n T3[idx] = (np.ones_like(dists.rx)[idx] * self.CONSTS['h1'] +\n self.CONSTS['h2'] * (dists.rx[idx] / r1) +\n self.CONSTS['h3'] * (dists.rx[idx] / r1)**2)\n #\n idx = ((dists.rx >= r1) & (dists.rx <= r2))\n T3[idx] = 1. - (dists.rx[idx] - r1) / (r2 - r1)\n # Compute taper t4 (eq. 14 at page 1040)\n T4 = np.zeros_like(dists.rx)\n #\n if rup.ztor <= 10.:\n T4 += (1. - rup.ztor**2. / 100.)\n # Compute T5 (eq 15a at page 1040) - ry1 computed according to\n # suggestions provided at page 1040\n T5 = np.zeros_like(dists.rx)\n ry1 = dists.rx * np.tan(np.radians(20.))\n #\n idx = (dists.ry0 - ry1) <= 0.0\n T5[idx] = 1.\n #\n idx = (((dists.ry0 - ry1) > 0.0) & ((dists.ry0 - ry1) < 5.0))\n T5[idx] = 1. - (dists.ry0[idx] - ry1[idx]) / 5.0\n # Finally, compute the hanging wall term\n return Fhw*C['a13']*T1*T2*T3*T4*T5\n\n def _get_top_of_rupture_depth_term(self, C, imt, rup):\n \"\"\"\n Compute and return top of rupture depth term. See paragraph\n 'Depth-to-Top of Rupture Model', page 1042.\n \"\"\"\n if rup.ztor >= 20.0:\n return C['a15']\n else:\n return C['a15'] * rup.ztor / 20.0\n\n def _get_z1pt0ref(self, vs30):\n \"\"\"\n This computes the reference depth to the 1.0 km/s interface using\n equation 18 at page 1042 of Abrahamson et al. (2014)\n \"\"\"\n return (1. / 1000.) * np.exp((-7.67 / 4.)*np.log((vs30**4 + 610.**4) /\n (1360.**4 + 610.**4)))\n\n def _get_soil_depth_term(self, C, z1pt0, vs30):\n \"\"\"\n Compute and return soil depth term. See page 1042.\n \"\"\"\n # Get reference z1pt0\n z1ref = self._get_z1pt0ref(vs30)\n # Get z1pt0\n z10 = copy.deepcopy(z1pt0)\n # This is used for the calculation of the motion on reference rock\n idx = z1pt0 < 0\n z10[idx] = z1ref[idx]\n factor = np.log((z10 + 0.01) / (z1ref + 0.01))\n # Here we use a linear interpolation as suggested in the 'Application\n # guidelines' at page 1044\n # Above 700 m/s the trend is flat, but we extend the Vs30 range to\n # 6,000 m/s (basically the upper limit for mantle shear wave velocity\n # on earth) to allow extrapolation without throwing an error.\n f2 = interpolate.interp1d(\n [0.0, 150, 250, 400, 700, 1000, 6000],\n [C['a43'], C['a43'], C['a44'], C['a45'], C['a46'], C['a46'],\n C['a46']],\n kind='linear')\n return f2(vs30) * factor\n\n def _get_regional_term(self, C, imt, vs30, rrup):\n \"\"\"\n In accordance with Abrahamson et al. (2014) we assume California\n as the default region hence here the regional term is assumed = 0.\n \"\"\"\n return 0.\n\n def _get_stddevs(self, C, imt, rup, sites, stddev_types, sa1180, dists):\n \"\"\"\n Return standard deviations as described in paragraph 'Equations for\n standard deviation', page 1046.\n \"\"\"\n std_intra = self._get_intra_event_std(C, rup.mag, sa1180, sites.vs30,\n sites.vs30measured, dists.rrup)\n std_inter = self._get_inter_event_std(C, rup.mag, sa1180, sites.vs30)\n stddevs = []\n for stddev_type in stddev_types:\n assert stddev_type in self.DEFINED_FOR_STANDARD_DEVIATION_TYPES\n if stddev_type == const.StdDev.TOTAL:\n stddevs.append(np.sqrt(std_intra ** 2 +\n std_inter ** 2))\n elif stddev_type == const.StdDev.INTRA_EVENT:\n stddevs.append(std_intra)\n elif stddev_type == const.StdDev.INTER_EVENT:\n stddevs.append(std_inter)\n return stddevs\n\n def _get_intra_event_std(self, C, mag, sa1180, vs30, vs30measured,\n rrup):\n \"\"\"\n Returns Phi as described at pages 1046 and 1047\n \"\"\"\n phi_al = self._get_phi_al_regional(C, mag, vs30measured, rrup)\n derAmp = self._get_derivative(C, sa1180, vs30)\n phi_amp = 0.4\n idx = phi_al < phi_amp\n if np.any(idx):\n # In the case of small magnitudes and long periods it is possible\n # for phi_al to take a value less than phi_amp, which would return\n # a complex value. According to the GMPE authors in this case\n # phi_amp should be reduced such that it is fractionally smaller\n # than phi_al\n phi_amp = 0.4 * np.ones_like(phi_al)\n phi_amp[idx] = 0.99 * phi_al[idx]\n phi_b = np.sqrt(phi_al**2 - phi_amp**2)\n phi = np.sqrt(phi_b**2 * (1 + derAmp)**2 + phi_amp**2)\n return phi\n\n def _get_derivative(self, C, sa1180, vs30):\n \"\"\"\n Returns equation 30 page 1047\n \"\"\"\n derAmp = np.zeros_like(vs30)\n n = self.CONSTS['n']\n c = C['c']\n b = C['b']\n idx = vs30 < C['vlin']\n derAmp[idx] = (b * sa1180[idx] * (-1./(sa1180[idx]+c) +\n 1./(sa1180[idx] + c*(vs30[idx]/C['vlin'])**n)))\n return derAmp\n\n def _get_phi_al_regional(self, C, mag, vs30measured, rrup):\n \"\"\"\n Returns intra-event (Phi) standard deviation (equation 24, page 1046)\n \"\"\"\n phi_al = np.ones((len(vs30measured)))\n s1 = np.ones_like(phi_al) * C['s1e']\n s2 = np.ones_like(phi_al) * C['s2e']\n s1[vs30measured] = C['s1m']\n s2[vs30measured] = C['s2m']\n if mag < 4:\n phi_al *= s1\n elif mag <= 6:\n phi_al *= s1 + (s2 - s1) / 2. * (mag - 4.)\n else:\n phi_al *= s2\n return phi_al\n\n def _get_inter_event_std(self, C, mag, sa1180, vs30):\n \"\"\"\n Returns inter event (tau) standard deviation (equation 25, page 1046)\n \"\"\"\n if mag < 5:\n tau_al = C['s3']\n elif mag <= 7:\n tau_al = C['s3'] + (C['s4'] - C['s3']) / 2. * (mag - 5.)\n else:\n tau_al = C['s4']\n tau_b = tau_al\n tau = tau_b * (1 + self._get_derivative(C, sa1180, vs30))\n return tau\n\n #: Coefficient tables as per annex B of Abrahamson et al. (2014)\n COEFFS = CoeffsTable(sa_damping=5, table=\"\"\"\\\nIMT m1 vlin b c c4 a1 a2 a3 a4 a5 a6 a7 a8 a10 a11 a12 a13 a14 a15 a17 a43 a44 a45 a46 a25 a28 a29 a31 a36 a37 a38 a39 a40 a41 a42 s1e s2e s3 s4 s1m s2m s5 s6\npga 6.75 660 -1.47 2.4 4.5 0.587 -0.79 0.275 -0.1 -0.41 2.154 0.0 -0.015 1.735 0 -0.1 0.6 -0.3 1.1 -0.0072 0.1 0.05 0 -0.05 -0.0015 0.0025 -0.0034 -0.1503 0.265 0.337 0.188 0 0.088 -0.196 0.044 0.754 0.52 0.47 0.36 0.741 0.501 0.54 0.6300\npgv 6.75 330 -2.02 2400 4.5 5.975 -0.919 0.275 -0.1 -0.41 2.366 0.0 -0.094 2.36 0 -0.1 0.25 0.22 0.3 -0.0005 0.28 0.15 0.09 0.07 -0.0001 0.0005 -0.0037 -0.1462 0.377 0.212 0.157 0 0.095 -0.038 0.065 0.662 0.51 0.38 0.38 0.66 0.51 0.58 0.5300\n0.01 6.75 660 -1.47 2.4 4.5 0.587 -0.790 0.275 -0.1 -0.41 2.154 0.0 -0.015 1.735 0 -0.1 0.6 -0.3 1.1 -0.0072 0.1 0.05 0 -0.05 -0.0015 0.0025 -0.0034 -0.1503 0.265 0.337 0.188 0 0.088 -0.196 0.044 0.754 0.52 0.47 0.36 0.741 0.501 0.54 0.6300\n0.02 6.75 680 -1.46 2.4 4.5 0.598 -0.790 0.275 -0.1 -0.41 2.146 0.0 -0.015 1.718 0 -0.1 0.6 -0.3 1.1 -0.0073 0.1 0.05 0 -0.05 -0.0015 0.0024 -0.0033 -0.1479 0.255 0.328 0.184 0 0.088 -0.194 0.061 0.76 0.52 0.47 0.36 0.747 0.501 0.54 0.6300\n0.03 6.75 770 -1.39 2.4 4.5 0.602 -0.790 0.275 -0.1 -0.41 2.157 0.0 -0.015 1.615 0 -0.1 0.6 -0.3 1.1 -0.0075 0.1 0.05 0 -0.05 -0.0016 0.0023 -0.0034 -0.1447 0.249 0.32 0.18 0 0.093 -0.175 0.162 0.781 0.52 0.47 0.36 0.769 0.501 0.55 0.6300\n0.05 6.75 915 -1.22 2.4 4.5 0.707 -0.790 0.275 -0.1 -0.41 2.085 0.0 -0.015 1.358 0 -0.1 0.6 -0.3 1.1 -0.008 0.1 0.05 0 -0.05 -0.002 0.0027 -0.0033 -0.1326 0.202 0.289 0.167 0 0.133 -0.09 0.451 0.81 0.53 0.47 0.36 0.798 0.512 0.56 0.6500\n0.075 6.75 960 -1.15 2.4 4.5 0.973 -0.790 0.275 -0.1 -0.41 2.029 0.0 -0.015 1.258 0 -0.1 0.6 -0.3 1.1 -0.0089 0.1 0.05 0 -0.05 -0.0027 0.0032 -0.0029 -0.1353 0.126 0.275 0.173 0 0.186 0.09 0.506 0.81 0.54 0.47 0.36 0.798 0.522 0.57 0.6900\n0.1 6.75 910 -1.23 2.4 4.5 1.169 -0.790 0.275 -0.1 -0.41 2.041 0.0 -0.015 1.31 0 -0.1 0.6 -0.3 1.1 -0.0095 0.1 0.05 0 -0.05 -0.0033 0.0036 -0.0025 -0.1128 0.022 0.256 0.189 0 0.16 0.006 0.335 0.81 0.55 0.47 0.36 0.795 0.527 0.57 0.7000\n0.15 6.75 740 -1.59 2.4 4.5 1.442 -0.790 0.275 -0.1 -0.41 2.121 0.0 -0.022 1.66 0 -0.1 0.6 -0.3 1.1 -0.0095 0.1 0.05 0 -0.05 -0.0035 0.0033 -0.0025 0.0383 -0.136 0.162 0.108 0 0.068 -0.156 -0.084 0.801 0.56 0.47 0.36 0.773 0.519 0.58 0.7000\n0.2 6.75 590 -2.01 2.4 4.5 1.637 -0.790 0.275 -0.1 -0.41 2.224 0.0 -0.03 2.22 0 -0.1 0.6 -0.3 1.1 -0.0086 0.1 0.05 0 -0.03 -0.0033 0.0027 -0.0031 0.0775 -0.078 0.224 0.115 0 0.048 -0.274 -0.178 0.789 0.565 0.47 0.36 0.753 0.514 0.59 0.7000\n0.25 6.75 495 -2.41 2.4 4.5 1.701 -0.790 0.275 -0.1 -0.41 2.312 0.0 -0.038 2.77 0 -0.1 0.6 -0.24 1.1 -0.0074 0.1 0.05 0 0 -0.0029 0.0024 -0.0036 0.0741 0.037 0.248 0.122 0 0.055 -0.248 -0.187 0.77 0.57 0.47 0.36 0.729 0.513 0.61 0.7000\n0.3 6.75 430 -2.76 2.4 4.5 1.712 -0.790 0.275 -0.1 -0.41 2.338 0.0 -0.045 3.25 0 -0.1 0.6 -0.19 1.03 -0.0064 0.1 0.05 0.03 0.03 -0.0027 0.002 -0.0039 0.2548 -0.091 0.203 0.096 0 0.073 -0.203 -0.159 0.74 0.58 0.47 0.36 0.693 0.519 0.63 0.7000\n0.4 6.75 360 -3.28 2.4 4.5 1.662 -0.790 0.275 -0.1 -0.41 2.469 0.0 -0.055 3.99 0 -0.1 0.58 -0.11 0.92 -0.0043 0.1 0.07 0.06 0.06 -0.0023 0.001 -0.0048 0.2136 0.129 0.232 0.123 0 0.143 -0.154 -0.023 0.699 0.59 0.47 0.36 0.644 0.524 0.66 0.7000\n0.5 6.75 340 -3.6 2.4 4.5 1.571 -0.790 0.275 -0.1 -0.41 2.559 0.0 -0.065 4.45 0 -0.1 0.56 -0.04 0.84 -0.0032 0.1 0.1 0.1 0.09 -0.002 0.0008 -0.005 0.1542 0.31 0.252 0.134 0 0.16 -0.159 -0.029 0.676 0.6 0.47 0.36 0.616 0.532 0.69 0.7000\n0.75 6.75 330 -3.8 2.4 4.5 1.299 -0.790 0.275 -0.1 -0.41 2.682 0.0 -0.095 4.75 0 -0.1 0.53 0.07 0.68 -0.0025 0.14 0.14 0.14 0.13 -0.001 0.0007 -0.0041 0.0787 0.505 0.208 0.129 0 0.158 -0.141 0.061 0.631 0.615 0.47 0.36 0.566 0.548 0.73 0.6900\n1 6.75 330 -3.5 2.4 4.5 1.043 -0.790 0.275 -0.1 -0.41 2.763 0.0 -0.11 4.3 0 -0.1 0.5 0.15 0.57 -0.0025 0.17 0.17 0.17 0.14 -0.0005 0.0007 -0.0032 0.0476 0.358 0.208 0.152 0 0.145 -0.144 0.062 0.609 0.63 0.47 0.36 0.541 0.565 0.77 0.6800\n1.5 6.75 330 -2.4 2.4 4.5 0.665 -0.790 0.275 -0.1 -0.41 2.836 0.0 -0.124 2.6 0 -0.1 0.42 0.27 0.42 -0.0022 0.22 0.21 0.2 0.16 -0.0004 0.0006 -0.002 -0.0163 0.131 0.108 0.118 0 0.131 -0.126 0.037 0.578 0.64 0.47 0.36 0.506 0.576 0.8 0.6600\n2 6.75 330 -1 2.4 4.5 0.329 -0.790 0.275 -0.1 -0.41 2.897 0.0 -0.138 0.55 0 -0.1 0.35 0.35 0.31 -0.0019 0.26 0.25 0.22 0.16 -0.0002 0.0003 -0.0017 -0.1203 0.123 0.068 0.119 0 0.083 -0.075 -0.143 0.555 0.65 0.47 0.36 0.48 0.587 0.8 0.6200\n3 6.82 330 0 2.4 4.5 -0.060 -0.790 0.275 -0.1 -0.41 2.906 0.0 -0.172 -0.95 0 -0.1 0.2 0.46 0.16 -0.0015 0.34 0.3 0.23 0.16 0 0 -0.002 -0.2719 0.109 -0.023 0.093 0 0.07 -0.021 -0.028 0.548 0.64 0.47 0.36 0.472 0.576 0.8 0.5500\n4 6.92 330 0 2.4 4.5 -0.299 -0.790 0.275 -0.1 -0.41 2.889 0.0 -0.197 -0.95 0 -0.1 0 0.54 0.05 -0.001 0.41 0.32 0.23 0.14 0 0 -0.002 -0.2958 0.135 0.028 0.084 0 0.101 0.072 -0.097 0.527 0.63 0.47 0.36 0.447 0.565 0.76 0.5200\n5 7 330 0 2.4 4.5 -0.562 -0.765 0.275 -0.1 -0.41 2.898 0.0 -0.218 -0.93 0 -0.1 0 0.61 -0.04 -0.001 0.51 0.32 0.22 0.13 0 0 -0.002 -0.2718 0.189 0.031 0.058 0 0.095 0.205 0.015 0.505 0.63 0.47 0.36 0.425 0.568 0.72 0.5000\n6 7.06 330 0 2.4 4.5 -0.875 -0.711 0.275 -0.1 -0.41 2.896 0.0 -0.235 -0.91 0 -0.2 0 0.65 -0.11 -0.001 0.55 0.32 0.2 0.1 0 0 -0.002 -0.2517 0.215 0.024 0.065 0 0.133 0.285 0.104 0.477 0.63 0.47 0.36 0.395 0.571 0.7 0.5000\n7.5 7.15 330 0 2.4 4.5 -1.303 -0.634 0.275 -0.1 -0.41 2.870 0.0 -0.255 -0.87 0 -0.2 0 0.72 -0.19 -0.001 0.49 0.28 0.17 0.09 0 0 -0.002 -0.14 0.15 -0.07 0 0 0.151 0.329 0.299 0.457 0.63 0.47 0.36 0.378 0.575 0.67 0.5000\n10 7.25 330 0 2.4 4.5 -1.928 -0.529 0.275 -0.1 -0.41 2.843 0.0 -0.285 -0.8 0 -0.2 0 0.8 -0.3 -0.001 0.42 0.22 0.14 0.08 0 0 -0.002 -0.0216 0.092 -0.159 -0.05 0 0.124 0.301 0.243 0.429 0.63 0.47 0.36 0.359 0.585 0.64 0.5000\n \"\"\")\n\n #: equation constants (that are IMT independent)\n CONSTS = {\n 'n': 1.5,\n # m2 specified at page 1032 (top)\n 'm2': 5.00,\n # h1, h2, h3 specified at page 1040 (top)\n 'h1': +0.25,\n 'h2': +1.50,\n 'h3': -0.75,\n }\n\n\nclass AbrahamsonEtAl2014RegTWN(AbrahamsonEtAl2014):\n \"\"\"\n Implements GMPE developed by Abrahamson, Silva and Kamai in 2014 as\n part of the PEER West 2 Project. The GMPE is described in a paper\n published in 2014 on Earthquake Spectra, Volume 30, Number 3.\n\n Regional corrections for Taiwan\n \"\"\"\n\n def _get_regional_term(self, C, imt, vs30, rrup):\n \"\"\"\n In accordance with Abrahamson et al. (2014) we assume as the default\n region California\n \"\"\"\n vs30star = self._get_vs30star(vs30, imt)\n return C['a31'] * np.log(vs30star/C['vlin']) + C['a25'] * rrup\n\n\nclass AbrahamsonEtAl2014RegCHN(AbrahamsonEtAl2014):\n \"\"\"\n Implements GMPE developed by Abrahamson, Silva and Kamai in 2014 as\n part of the PEER West 2 Project. The GMPE is described in a paper\n published in 2014 on Earthquake Spectra, Volume 30, Number 3.\n\n Regional corrections for China\n \"\"\"\n\n def _get_regional_term(self, C, imt, vs30, rrup):\n \"\"\"\n In accordance with Abrahamson et al. (2014) we assume as the default\n region California\n \"\"\"\n return C['a28'] * rrup\n\n\nclass AbrahamsonEtAl2014RegJPN(AbrahamsonEtAl2014):\n \"\"\"\n Implements GMPE developed by Abrahamson, Silva and Kamai in 2014 as\n part of the PEER West 2 Project. The GMPE is described in a paper\n published in 2014 on Earthquake Spectra, Volume 30, Number 3.\n\n Regional corrections for Japan\n \"\"\"\n\n def _get_z1pt0ref(self, vs30):\n \"\"\"\n This provides the default depth to the 1.0 km/s interface for Japan\n \"\"\"\n return 1./1000. * np.exp(-5.23/2.*np.log((vs30**2+412.**2.) /\n (1360.**2+412**2.)))\n\n def _get_regional_term(self, C, imt, vs30, rrup):\n \"\"\"\n Compute regional term for Japan. See page 1043\n \"\"\"\n f3 = interpolate.interp1d(\n [150, 250, 350, 450, 600, 850, 1150, 2000],\n [C['a36'], C['a37'], C['a38'], C['a39'], C['a40'], C['a41'],\n C['a42'], C['a42']],\n kind='linear')\n return f3(vs30) + C['a29'] * rrup\n\n def _get_phi_al_regional(self, C, mag, vs30measured, rrup):\n \"\"\"\n Returns intra-event (Tau) standard deviation (equation 26, page 1046)\n \"\"\"\n phi_al = np.ones((len(vs30measured)))\n\n idx = rrup < 30\n phi_al[idx] *= C['s5']\n\n idx = ((rrup <= 80) & (rrup >= 30.))\n phi_al[idx] *= C['s5'] + (C['s6'] - C['s5']) / 50. * (rrup[idx] - 30.)\n\n idx = rrup > 80\n phi_al[idx] *= C['s6']\n\n return phi_al\n", "meta": {"hexsha": "3d8e6846d0e6f19583d45891d0b1f50e22cdf3c4", "size": 28590, "ext": "py", "lang": "Python", "max_stars_repo_path": "openquake/hazardlib/gsim/abrahamson_2014.py", "max_stars_repo_name": "gfzriesgos/shakyground-lfs", "max_stars_repo_head_hexsha": "2caf67cc32e6800286eded2df1efb05973ccf41b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-08-01T00:28:24.000Z", "max_stars_repo_stars_event_max_datetime": "2019-08-01T00:28:24.000Z", "max_issues_repo_path": "openquake/hazardlib/gsim/abrahamson_2014.py", "max_issues_repo_name": "gfzriesgos/shakyground-lfs", "max_issues_repo_head_hexsha": "2caf67cc32e6800286eded2df1efb05973ccf41b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2018-08-31T14:14:35.000Z", "max_issues_repo_issues_event_max_datetime": "2021-10-11T12:53:13.000Z", "max_forks_repo_path": "openquake/hazardlib/gsim/abrahamson_2014.py", "max_forks_repo_name": "gfzriesgos/shakyground-lfs", "max_forks_repo_head_hexsha": "2caf67cc32e6800286eded2df1efb05973ccf41b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2018-08-31T14:11:00.000Z", "max_forks_repo_forks_event_max_datetime": "2019-07-17T10:06:02.000Z", "avg_line_length": 53.1412639405, "max_line_length": 347, "alphanum_fraction": 0.4981811822, "include": true, "reason": "import numpy,from scipy", "num_tokens": 11062, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073655352404, "lm_q2_score": 0.36296921930155557, "lm_q1q2_score": 0.19985352561001243}} {"text": "from amuse.community import *\n\nfrom amuse.community.interface.mhd import MagnetohydrodynamicsInterface\nfrom amuse.community.interface.common import CommonCode\n\nimport numpy\n\nfrom amuse.units.generic_unit_system import *\n\nclass AthenaInterface(CodeInterface, MagnetohydrodynamicsInterface, LiteratureReferencesMixIn, StoppingConditionInterface):\n \"\"\"\n Athena is a grid-based code for astrophysical hydrodynamics. Athena can solve \n magnetohydrodynamics (MHD) as well, but this is currently not supported from \n AMUSE. It was developed primarily for studies of the interstellar medium, \n star formation, and accretion flows.\n \n The current version (Athena v4.0) implements algorithms for the following physics:\n * compressible hydrodynamics and MHD in 1D, 2D, and 3D,\n * ideal gas equation of state with arbitrary gamma (including gamma = 1, an isothermal EOS),\n * an arbitrary number of passive scalars advected with the flow,\n * self-gravity, and/or a static gravitational potential,\n * Ohmic resistivity, ambipolar diffusion, and the Hall effect,\n * both Navier-Stokes and anisotropic (Braginskii) viscosity,\n * both isotropic and anisotropic thermal conduction,\n * optically-thin radiative cooling. \n \n In addition, Athena allows for the following grid and parallelization options:\n * Cartesian or cylindrical coordinates,\n * static (fixed) mesh refinement,\n * shearing-box source terms, and an orbital advection algorithm for MHD,\n * parallelization using domain decomposition and MPI. \n \n A variety of choices are also available for the numerical algorithms, such as \n different Riemann solvers and spatial reconstruction methods.\n \n The relevant references are:\n .. [#] Gardiner & Stone 2005, JCP, 205, 509 (2D JCP Method)\n .. [#] Gardiner & Stone 2007, JCP, 227, 4123 (3D JCP Method)\n .. [#] Stone et al. 2008, ApJS, 178, 137 (Method)\n .. [#] Stone & Gardiner 2009, NewA, 14, 139 (van Leer Integrator)\n .. [#] Skinner & Ostriker 2010, ApJ, 188, 290 (Cylindrical Integrator)\n .. [#] Stone & Gardiner 2010, ApJS, 189, 142 (Shearing Box Method)\n \"\"\"\n \n include_headers = ['worker_code.h', 'stopcond.h']\n \n MODE_NORMAL = 'normal'\n MODE_SELF_GRAVITY = 'self-gravity'\n MODE_MHD = 'mhd'\n MODE_SCALAR = 'scalar'\n \n def __init__(self, mode = MODE_NORMAL, **options):\n \n self.mode = mode\n CodeInterface.__init__(self, name_of_the_worker=self.name_of_the_worker(mode), **options)\n self.set_auto_decomposition(1)\n self.par_seti(\"domain1\", \"AutoWithNProc\", \"%d\", self.channel.number_of_workers, \"-\")\n LiteratureReferencesMixIn.__init__(self)\n self.number_of_grids = 1\n \n def name_of_the_worker(self, mode):\n if mode == self.MODE_NORMAL:\n return 'athena_worker'\n elif mode == self.MODE_SELF_GRAVITY:\n return 'athena_worker_selfgrav'\n elif mode == self.MODE_MHD:\n return 'athena_worker_mhd'\n elif mode == self.MODE_SCALAR:\n return 'athena_worker_scalar'\n else:\n return 'athena_worker'\n \n @legacy_function\n def par_seti():\n function = LegacyFunctionSpecification() \n function.addParameter('block', dtype='s', direction=function.IN) \n function.addParameter('name', dtype='s', direction=function.IN) \n function.addParameter('fmt', dtype='s', direction=function.IN) \n function.addParameter('ival', dtype='int32', direction=function.IN) \n function.addParameter('comment', dtype='s', direction=function.IN) \n function.result_type = None\n return function\n \n @legacy_function\n def par_geti():\n function = LegacyFunctionSpecification() \n function.addParameter('block', dtype='s', direction=function.IN) \n function.addParameter('name', dtype='s', direction=function.IN) \n function.result_type = 'int32'\n return function\n \n @legacy_function\n def par_setd():\n function = LegacyFunctionSpecification() \n function.addParameter('block', dtype='s', direction=function.IN) \n function.addParameter('name', dtype='s', direction=function.IN) \n function.addParameter('fmt', dtype='s', direction=function.IN) \n function.addParameter('dval', dtype='float64', direction=function.IN) \n function.addParameter('comment', dtype='s', direction=function.IN) \n function.result_type = None\n return function\n \n @legacy_function\n def par_getd():\n function = LegacyFunctionSpecification() \n function.addParameter('block', dtype='s', direction=function.IN) \n function.addParameter('name', dtype='s', direction=function.IN) \n function.result_type = 'float64'\n return function\n \n def setup_mesh(self, nmeshx, nmeshy, nmeshz, xlength, ylength, zlength):\n self.par_seti(\"job\",\"num_domains\", \"%d\", self.number_of_grids, \"-\")\n self.par_seti(\"domain1\", \"level\", \"%d\", 0, \"-\")\n \n self.par_seti(\"domain1\", \"Nx1\", \"%d\", nmeshx, \"-\")\n self.par_seti(\"domain1\", \"Nx2\", \"%d\", nmeshy, \"-\")\n self.par_seti(\"domain1\", \"Nx3\", \"%d\", nmeshz, \"-\")\n \n self.par_setd(\"domain1\", \"x1min\", \"%.15e\", 0.0, \"-\")\n self.par_setd(\"domain1\", \"x1max\", \"%.15e\", xlength, \"-\")\n self.par_setd(\"domain1\", \"x2min\", \"%.15e\", 0.0, \"-\")\n self.par_setd(\"domain1\", \"x2max\", \"%.15e\", ylength, \"-\")\n self.par_setd(\"domain1\", \"x3min\", \"%.15e\", 0.0, \"-\")\n self.par_setd(\"domain1\", \"x3max\", \"%.15e\", zlength, \"-\")\n self.par_seti(\"domain1\", \"iDisp\", \"%d\", 0, \"-\")\n self.par_seti(\"domain1\", \"jDisp\", \"%d\", 0, \"-\")\n self.par_seti(\"domain1\", \"kDisp\", \"%d\", 0, \"-\")\n \n return 0\n \n def define_subgrid(self, level, nmeshx, nmeshy, nmeshz, i, j, k):\n \"\"\"\n Define a new domain on the given level the number of cells in this \n domain is given by nmeshx, nmeshy, nmeshz. \n \n Each level is twice as dense as in every directory as \n the previous level (there are 8 cells per higher level cell).\n \"\"\"\n self.number_of_grids += 1\n \n domain = \"domain{0}\".format(self.number_of_grids)\n \n self.par_seti(\"job\",\"num_domains\", \"%d\", self.number_of_grids, \"-\")\n \n self.par_seti(domain, \"level\", \"%d\", level, \"-\")\n self.par_seti(domain, \"Nx1\", \"%d\", nmeshx, \"-\")\n self.par_seti(domain, \"Nx2\", \"%d\", nmeshy, \"-\")\n self.par_seti(domain, \"Nx3\", \"%d\", nmeshz, \"-\")\n self.par_seti(domain, \"iDisp\", \"%d\", i, \"-\")\n self.par_seti(domain, \"jDisp\", \"%d\", j, \"-\")\n self.par_seti(domain, \"kDisp\", \"%d\", k, \"-\")\n \n return self.number_of_grids\n\n @legacy_function \n def get_position_of_index():\n \"\"\"\n Retrieves the x, y and z position of the center of\n the cell with coordinates i, j, k in the grid specified\n by the index_of_grid\n \"\"\"\n function = LegacyFunctionSpecification() \n function.must_handle_array = True\n for x in ['i','j','k']:\n function.addParameter(x, dtype='i', direction=function.IN)\n function.addParameter('index_of_grid', dtype='i', direction=function.IN, default = 1)\n for x in ['x','y','z']:\n function.addParameter(x, dtype='d', direction=function.OUT)\n function.addParameter('number_of_points', 'i', function.LENGTH) \n function.result_type = 'i'\n return function\n \n '''\n @legacy_function \n def get_index_of_position():\n \"\"\"\n Retrieves the i,j and k index of the grid cell containing the\n given x, y and z position. The cell is looked up\n in the grid specified by index_of_grid.\n \"\"\"\n function = LegacyFunctionSpecification() \n function.must_handle_array = True\n for x in ['x','y','z']:\n function.addParameter(x, dtype='d', direction=function.IN)\n \n function.addParameter('index_of_grid', dtype='i', direction=function.IN, default = 1)\n \n for x in ['i','j','k']:\n function.addParameter(x, dtype='d', direction=function.OUT)\n function.addParameter('number_of_points', 'i', function.LENGTH)\n\n function.result_type = 'i'\n return function\n '''\n def get_index_range_inclusive(self, index_of_grid = 1):\n \"\"\"\n Returns the min and max values of indices in each\n direction. The range is inclusive, the min index\n and max index both exist and can be queried.\n The total number of cells in one direction\n is max - min + 1.\n \"\"\"\n domainid = \"domain{0}\".format(index_of_grid)\n \n ni = self.par_geti(domainid, \"Nx1\")\n nj = self.par_geti(domainid, \"Nx2\")\n nk = self.par_geti(domainid, \"Nx3\")\n idisp = self.par_geti(domainid, \"iDisp\")\n jdisp = self.par_geti(domainid, \"jDisp\")\n kdisp = self.par_geti(domainid, \"kDisp\")\n #print index_of_grid, \" === > \", (idisp, idisp+ni[0]-1, jdisp, jdisp + nj[0]-1, kdisp, kdisp + nk[0]-1)\n \n return (idisp, idisp+ni-1, jdisp, jdisp + nj-1, kdisp, kdisp + nk-1)\n \n \n\n def get_index_range_magnetic_field_inclusive(self, index_of_grid = 1):\n original = list(self.get_index_range_inclusive(index_of_grid))\n original[1] += 1\n original[3] += 1\n original[5] += 1\n return original\n \n def get_mesh_indices(self):\n \"\"\"\n Return 3 arrays, containing the indices for i, j and k\n \"\"\"\n si,ei,sj,ej,sk,ek = self.get_index_range_inclusive()\n indexgrid = numpy.mgrid[slice(si,ei+1),slice(sj,ej+1),slice(sk,ek+1)]\n return indexgrid.reshape(3, -1)\n \n \n \n def set_four_pi_G(self, value):\n self.par_setd(\"problem\", \"four_pi_G\", \"%.15e\", value, \"\")\n return 0 \n \n def set_grav_mean_rho(self, value):\n self.par_setd(\"problem\", \"grav_mean_rho\", \"%.15e\", value, \"\")\n return 0 \n\n def set_isocsound(self, value):\n self.par_setd(\"problem\", \"iso_csound\", \"%.15e\", value, \"\")\n return 0 \n \n def set_gamma(self, value):\n self.par_setd(\"problem\", \"gamma\", \"%.15e\", value, \"-\") \n return 0 \n \n def set_courant_friedrichs_lewy_number(self, value):\n self.par_setd(\"time\", \"cour_no\", \"%.15e\", value, \"-\")\n return 0 \n \n def set_boundary(self, xbound1, xbound2, ybound1, ybound2, zbound1, zbound2):\n map_from_string_to_flag = {\n \"reflective\": 1, \n \"outflow\":2, \n \"periodic\":4,\n \"interface\": 10,\n }\n \n self.par_seti(\"domain1\", \"bc_ix1\", \"%d\", map_from_string_to_flag[xbound1], \"-\")\n self.par_seti(\"domain1\", \"bc_ox1\", \"%d\", map_from_string_to_flag[xbound2], \"-\")\n self.par_seti(\"domain1\", \"bc_ix2\", \"%d\", map_from_string_to_flag[ybound1], \"-\")\n self.par_seti(\"domain1\", \"bc_ox2\", \"%d\", map_from_string_to_flag[ybound2], \"-\")\n self.par_seti(\"domain1\", \"bc_ix3\", \"%d\", map_from_string_to_flag[zbound1], \"-\")\n self.par_seti(\"domain1\", \"bc_ox3\", \"%d\", map_from_string_to_flag[zbound2], \"-\")\n \n return 0\n \n \n def set_parallel_decomposition(self, nx, ny, nz):\n if nx == 0 or ny == 0 or nz == 0:\n self.par_seti(\"domain1\", \"AutoWithNProc\", \"%d\", self.channel.number_of_workers, \"-\")\n else:\n self.par_seti(\"domain1\", \"AutoWithNProc\", \"%d\", 0, \"-\")\n self.par_seti(\"domain1\", \"NGrid_x1\", \"%d\", nx, \"-\")\n self.par_seti(\"domain1\", \"NGrid_x2\", \"%d\", ny, \"-\")\n self.par_seti(\"domain1\", \"NGrid_x3\", \"%d\", nz, \"-\")\n return 0\n \n def set_auto_decomposition(self, value):\n self.par_seti(\"parallel\", \"auto\", \"%d\", value, \"-\")\n return 0\n \n @legacy_function \n def initialize_grid():\n function = LegacyFunctionSpecification() \n function.result_type = 'i'\n return function\n \n @legacy_function\n def get_timestep():\n function = LegacyFunctionSpecification() \n function.addParameter('value', dtype='float64', direction=function.OUT) \n function.result_type = 'i'\n return function\n \n @legacy_function\n def set_timestep():\n function = LegacyFunctionSpecification() \n function.addParameter('value', dtype='float64', direction=function.IN) \n function.result_type = 'i'\n return function\n \n \n @legacy_function\n def get_evolve_to_exact_time():\n function = LegacyFunctionSpecification() \n function.addParameter('value', dtype='bool', direction=function.OUT) \n function.result_type = 'i'\n return function\n \n @legacy_function\n def set_evolve_to_exact_time():\n function = LegacyFunctionSpecification() \n function.addParameter('value', dtype='bool', direction=function.IN) \n function.result_type = 'i'\n return function\n \n @legacy_function\n def set_has_external_gravitational_potential():\n function = LegacyFunctionSpecification() \n function.addParameter('value', dtype='int32', direction=function.IN) \n function.result_type = 'i'\n return function\n \n @legacy_function\n def get_has_external_gravitational_potential():\n function = LegacyFunctionSpecification() \n function.addParameter('value', dtype='int32', direction=function.OUT) \n function.result_type = 'i'\n return function\n \n @legacy_function\n def get_nghost():\n function = LegacyFunctionSpecification() \n function.addParameter('value', dtype='int32', direction=function.OUT) \n function.result_type = 'i'\n return function\n \n @legacy_function\n def get_time():\n function = LegacyFunctionSpecification() \n function.addParameter('value', dtype='float64', direction=function.OUT) \n function.result_type = 'i'\n return function\n \n @legacy_function\n def esys_roe_adb_hydro():\n function = LegacyFunctionSpecification() \n function.addParameter('index', dtype='int32', direction=function.OUT) \n function.addParameter('u', dtype='float64', direction=function.OUT) \n function.addParameter('v', dtype='float64', direction=function.OUT) \n function.addParameter('w', dtype='float64', direction=function.OUT) \n function.addParameter('h', dtype='float64', direction=function.OUT) \n function.addParameter('ev', dtype='float64', direction=function.OUT) \n for i in range(5):\n function.addParameter('rem{0}'.format(i), dtype='float64', direction=function.OUT) \n for i in range(5):\n function.addParameter('lem{0}'.format(i), dtype='float64', direction=function.OUT) \n function.result_type = 'i'\n function.can_handle_array = True\n return function\n \n @legacy_function\n def fill_grid_linearwave_1d():\n function = LegacyFunctionSpecification() \n function.addParameter('wave_flag', dtype='int32', direction=function.IN) \n function.addParameter('amplitude', dtype='float64', direction=function.IN) \n function.addParameter('vflow', dtype='float64', direction=function.IN) \n function.addParameter('wave_dir', dtype='int32', direction=function.IN) \n function.result_type = 'i'\n function.can_handle_array = True\n return function\n \n def get_index_range_for_potential(self, index_of_grid = 1):\n \"\"\"\n Returns the min and max values of indices in each\n direction for the potential field, this\n range is 1 cell larger than the normal grid\n in all directions\"\"\"\n imin,imax,jmin,jmax,kmin,kmax = numpy.asarray(self.get_index_range_inclusive(index_of_grid = index_of_grid))\n imin -= 1\n imax += 1\n if jmin != jmax:\n jmin -= 1\n jmax += 1\n if kmin != kmax:\n kmin -= 1\n kmax += 1\n return imin,imax, jmin, jmax, kmin, kmax \n \n @legacy_function \n def set_potential():\n function = LegacyFunctionSpecification() \n function.must_handle_array = True\n for x in ['i','j','k']:\n function.addParameter(x, dtype='i', direction=function.IN)\n \n #function.addParameter('index_of_grid', dtype='i', direction=function.IN, default = 1)\n \n function.addParameter('potential', dtype='d', direction=function.IN)\n function.addParameter('number_of_points', 'i', function.LENGTH)\n function.result_type = 'i'\n return function\n \n @legacy_function \n def get_potential():\n function = LegacyFunctionSpecification() \n function.must_handle_array = True\n for x in ['i','j','k']:\n function.addParameter(x, dtype='i', direction=function.IN)\n #function.addParameter('index_of_grid', dtype='i', direction=function.IN, default = 1)\n function.addParameter('potential', dtype='d', direction=function.OUT)\n function.addParameter('number_of_points', 'i', function.LENGTH)\n function.result_type = 'i'\n return function\n \n @legacy_function \n def get_interpolated_gravitational_potential():\n \"\"\"\n Return the interpolated gravitational potential, can\n only interpolate over one axis at the time and\n only at half way points between the grid points.\n **For debugging purposes only**\n \"\"\"\n function = LegacyFunctionSpecification() \n function.can_handle_array = True\n for x in ['x','y','z']:\n function.addParameter(x, dtype='d', direction=function.IN)\n function.addParameter('potential', dtype='d', direction=function.OUT)\n function.result_type = 'i'\n return function\n\n def get_isocsound(self):\n return self.par_getd(\"problem\", \"iso_csound\"), 0\n\n def get_gamma(self):\n return self.par_getd(\"problem\", \"gamma\"), 0\n \n def get_four_pi_G(self):\n return self.par_getd(\"problem\", \"four_pi_G\"), 0\n \n def get_courant_friedrichs_lewy_number(self):\n return self.par_getd(\"time\", \"cour_no\"), 0\n \n def get_grav_mean_rho(self):\n return self.par_getd(\"problem\", \"grav_mean_rho\"), 0\n \n @legacy_function\n def get_grid_gravitational_potential():\n function = LegacyFunctionSpecification()\n function.must_handle_array = True\n for x in ['i','j','k']:\n function.addParameter(x, dtype='i', direction=function.IN)\n function.addParameter('index_of_grid', dtype='i', direction=function.IN, default = 1)\n for x in ['phi']:\n function.addParameter(x, dtype='d', direction=function.OUT)\n function.addParameter('number_of_points', 'i', function.LENGTH)\n function.result_type = 'i'\n \n return function\n \n \n \n\n @legacy_function\n def get_grid_acceleration():\n function = LegacyFunctionSpecification()\n function.must_handle_array = True\n for x in ['i','j','k']:\n function.addParameter(x, dtype='i', direction=function.IN)\n function.addParameter('index_of_grid', dtype='i', direction=function.IN, default = 1)\n for x in ['fx', 'fy', 'fz']:\n function.addParameter(x, dtype='d', direction=function.OUT)\n function.addParameter('number_of_points', 'i', function.LENGTH)\n function.result_type = 'i'\n \n return function\n \n @legacy_function\n def set_grid_acceleration():\n function = LegacyFunctionSpecification()\n function.must_handle_array = True\n for x in ['i','j','k']:\n function.addParameter(x, dtype='i', direction=function.IN)\n for x in ['fx', 'fy', 'fz']:\n function.addParameter(x, dtype='d', direction=function.IN)\n function.addParameter('index_of_grid', dtype='i', direction=function.IN, default = 1)\n function.addParameter('number_of_points', 'i', function.LENGTH)\n function.result_type = 'i'\n \n return function\n\n @legacy_function\n def get_grid_gravitational_acceleration():\n function = LegacyFunctionSpecification()\n function.must_handle_array = True\n for x in ['i','j','k']:\n function.addParameter(x, dtype='i', direction=function.IN)\n function.addParameter('index_of_grid', dtype='i', direction=function.IN, default = 1)\n for x in ['fx', 'fy', 'fz']:\n function.addParameter(x, dtype='d', direction=function.OUT)\n function.addParameter('number_of_points', 'i', function.LENGTH)\n function.result_type = 'i'\n \n return function\n \n @legacy_function\n def get_gravity_at_point():\n \"\"\"\n Determine the gravitational force on a given point\n \"\"\"\n function = LegacyFunctionSpecification()\n function.addParameter('eps', dtype='float64', direction=function.IN,\n description = \"The smoothing parameter\")\n function.addParameter('x', dtype='float64', direction=function.IN,\n description = \"The position vector of the point\")\n function.addParameter('y', dtype='float64', direction=function.IN,\n description = \"The position vector of the point\")\n function.addParameter('z', dtype='float64', direction=function.IN,\n description = \"The position vector of the point\")\n function.addParameter('forcex', dtype='float64', direction=function.OUT,\n description = \"Force created by the particles in the code at the given position\")\n function.addParameter('forcey', dtype='float64', direction=function.OUT,\n description = \"Force created by the particles in the code at the given position\")\n function.addParameter('forcez', dtype='float64', direction=function.OUT,\n description = \"Force created by the particles in the code at the given position\")\n function.result_type = 'int32'\n function.can_handle_array = True\n function.result_doc = \"\"\"\n 0 - OK\n Force could be calculated\n -1 - ERROR\n No force calculation supported\n \"\"\"\n return function\n\n\n @legacy_function\n def get_potential_at_point():\n \"\"\"\n Determine the potential on a given point\n \"\"\"\n function = LegacyFunctionSpecification()\n function.addParameter('eps', dtype='float64', direction=function.IN,\n description = \"The smoothing factor, may be ignored by the code\")\n function.addParameter('x', dtype='float64', direction=function.IN)\n function.addParameter('y', dtype='float64', direction=function.IN)\n function.addParameter('z', dtype='float64', direction=function.IN)\n function.addParameter('phi', dtype='float64', direction=function.OUT)\n function.can_handle_array = True\n function.result_type = 'int32'\n return function\n \n\n @legacy_function\n def get_grid_scalar():\n \"\"\"\n Retreives advected scalar property\n \"\"\"\n function = LegacyFunctionSpecification()\n function.must_handle_array = True\n for x in ['i','j','k']:\n function.addParameter(x, dtype='i', direction=function.IN)\n function.addParameter('index_of_grid', dtype='i', direction=function.IN, default = 1)\n for x in ['scalar',]:\n function.addParameter(x, dtype='d', direction=function.OUT)\n function.addParameter('number_of_points', 'i', function.LENGTH)\n function.result_type = 'i'\n return function\n \n @legacy_function\n def set_grid_scalar():\n \"\"\"\n Stores advected scalar property\n \"\"\"\n function = LegacyFunctionSpecification()\n function.must_handle_array = True\n for x in ['i','j','k']:\n function.addParameter(x, dtype='i', direction=function.IN)\n for x in ['scalar',]:\n function.addParameter(x, dtype='d', direction=function.IN)\n function.addParameter('index_of_grid', dtype='i', direction=function.IN, default = 1)\n function.addParameter('number_of_points', 'i', function.LENGTH)\n function.result_type = 'i'\n return function\n \n \n \n @legacy_function\n def get_boundary_index_range_inclusive():\n function = LegacyFunctionSpecification()\n function.addParameter('index_of_boundary', dtype='i', direction=function.IN)\n function.addParameter('index_of_grid', dtype='i', direction=function.IN, default = 1)\n function.addParameter('minx', dtype='i', direction=function.OUT)\n function.addParameter('maxx', dtype='i', direction=function.OUT)\n function.addParameter('miny', dtype='i', direction=function.OUT)\n function.addParameter('maxy', dtype='i', direction=function.OUT)\n function.addParameter('minz', dtype='i', direction=function.OUT)\n function.addParameter('maxz', dtype='i', direction=function.OUT)\n function.result_type = 'i'\n return function\n\n @legacy_function\n def set_boundary_state():\n function = LegacyFunctionSpecification()\n function.must_handle_array = True\n for x in ['i','j','k']:\n function.addParameter(x, dtype='i', direction=function.IN)\n for x in ['rho','rhovx','rhovy','rhovz','en']:\n function.addParameter(x, dtype='d', direction=function.IN)\n function.addParameter('index_of_boundary', dtype='i', direction=function.IN, default = 1)\n function.addParameter('index_of_grid', dtype='i', direction=function.IN, default = 1)\n function.addParameter('number_of_points', 'i', function.LENGTH)\n function.result_type = 'i'\n return function\n \n @legacy_function\n def get_boundary_state():\n function = LegacyFunctionSpecification()\n function.must_handle_array = True\n for x in ['i','j','k']:\n function.addParameter(x, dtype='i', direction=function.IN)\n function.addParameter('index_of_boundary', dtype='i', direction=function.IN, default = 1)\n function.addParameter('index_of_grid', dtype='i', direction=function.IN, default = 1)\n for x in ['rho','rhovx','rhovy','rhovz','en']:\n function.addParameter(x, dtype='d', direction=function.OUT)\n function.addParameter('number_of_points', 'i', function.LENGTH)\n function.result_type = 'i'\n return function\n \n \n @legacy_function \n def get_boundary_position_of_index():\n \"\"\"\n Retrieves the x, y and z position of the center of\n the cell with coordinates i, j, k in the grid specified\n by the index_of_grid\n \"\"\"\n function = LegacyFunctionSpecification() \n function.must_handle_array = True\n for x in ['i','j','k']:\n function.addParameter(x, dtype='i', direction=function.IN)\n function.addParameter('index_of_boundary', dtype='i', direction=function.IN, default = 1)\n function.addParameter('index_of_grid', dtype='i', direction=function.IN, default = 1)\n for x in ['x','y','z']:\n function.addParameter(x, dtype='d', direction=function.OUT)\n function.addParameter('number_of_points', 'i', function.LENGTH) \n function.result_type = 'i'\n return function\n \n @legacy_function \n def get_hydro_state_at_point():\n function = LegacyFunctionSpecification() \n for x in ['x','y','z']:\n function.addParameter(x, dtype='d', direction=function.IN)\n for x in ['vx','vy','vz']:\n function.addParameter(x, dtype='d', direction=function.IN, default = 0)\n for x in ['rho','rhovx','rhovy','rhovz','rhoe']:\n function.addParameter(x, dtype='d', direction=function.OUT)\n function.addParameter('npoints', dtype='i', direction=function.LENGTH)\n function.result_type = 'i' \n function.must_handle_array = True\n return function\n \n @legacy_function \n def get_hydro_state_for_cell():\n function = LegacyFunctionSpecification() \n for x in ['x','y','z']:\n function.addParameter(x, dtype='d', direction=function.IN)\n for x in ['dx','dy','dz']:\n function.addParameter(x, dtype='d', direction=function.IN)\n for x in ['vx','vy','vz']:\n function.addParameter(x, dtype='d', direction=function.IN, default = 0)\n for x in ['rho','rhovx','rhovy','rhovz','rhoe']:\n function.addParameter(x, dtype='d', direction=function.OUT)\n function.addParameter('npoints', dtype='i', direction=function.LENGTH)\n function.result_type = 'i' \n function.must_handle_array = True\n return function\n \nclass Athena(CommonCode):\n\n def __init__(self, unit_converter = None, **options):\n self.unit_converter = unit_converter\n \n self.stopping_conditions = StoppingConditions(self)\n CommonCode.__init__(self, AthenaInterface(**options), **options)\n \n def define_converter(self, handler):\n if self.unit_converter is None:\n return\n \n handler.set_converter(self.unit_converter.as_converter_from_si_to_generic())\n\n def define_properties(self, handler):\n handler.add_property('get_time', public_name = \"model_time\")\n \n def define_methods(self, handler):\n handler.add_method(\n 'evolve_model',\n (time,),\n (handler.ERROR_CODE,)\n )\n handler.add_method(\n 'get_position_of_index',\n (handler.INDEX, handler.INDEX, handler.INDEX, handler.INDEX),\n (length, length, length, handler.ERROR_CODE,)\n )\n \n density = mass / (length**3)\n momentum = mass / (time * (length**2))\n energy = mass / ((time**2) * length)\n potential_energy = length ** 2 / time ** 2\n magnetic_field = mass / current / time ** 2\n \n handler.add_method(\n 'set_grid_state',\n (handler.INDEX, handler.INDEX, handler.INDEX,\n density, momentum, momentum, momentum, energy,\n handler.INDEX),\n (handler.ERROR_CODE,)\n )\n \n handler.add_method(\n 'set_grid_magnetic_field',\n (handler.INDEX, handler.INDEX, handler.INDEX,\n magnetic_field, magnetic_field, magnetic_field,\n handler.INDEX),\n (handler.ERROR_CODE,)\n )\n\n handler.add_method(\n 'get_grid_state',\n (handler.INDEX, handler.INDEX, handler.INDEX, handler.INDEX),\n (density, momentum, momentum, momentum, energy,\n handler.ERROR_CODE,)\n )\n handler.add_method(\n 'set_grid_energy_density',\n (handler.INDEX, handler.INDEX, handler.INDEX,\n energy, handler.INDEX),\n (handler.ERROR_CODE,)\n )\n handler.add_method(\n 'get_grid_energy_density',\n (handler.INDEX, handler.INDEX, handler.INDEX, handler.INDEX),\n ( energy,\n handler.ERROR_CODE,)\n )\n handler.add_method(\n 'set_grid_density',\n (handler.INDEX, handler.INDEX, handler.INDEX,\n density, handler.INDEX),\n (handler.ERROR_CODE,)\n )\n handler.add_method(\n 'get_grid_density',\n (handler.INDEX, handler.INDEX, handler.INDEX, handler.INDEX),\n (density,\n handler.ERROR_CODE,)\n )\n handler.add_method(\n 'set_grid_scalar',\n (handler.INDEX, handler.INDEX, handler.INDEX,\n handler.NO_UNIT, handler.INDEX),\n (handler.ERROR_CODE,)\n )\n handler.add_method(\n 'get_grid_scalar',\n (handler.INDEX, handler.INDEX, handler.INDEX, handler.INDEX),\n (handler.NO_UNIT,\n handler.ERROR_CODE,)\n )\n handler.add_method(\n 'set_grid_momentum_density',\n (handler.INDEX, handler.INDEX, handler.INDEX,\n momentum, momentum, momentum, handler.INDEX),\n (handler.ERROR_CODE,)\n )\n handler.add_method(\n 'get_grid_momentum_density',\n (handler.INDEX, handler.INDEX, handler.INDEX, handler.INDEX),\n ( momentum, momentum, momentum, \n handler.ERROR_CODE,)\n )\n \n handler.add_method(\n 'get_grid_magnetic_field',\n (handler.INDEX, handler.INDEX, handler.INDEX, handler.INDEX),\n ( magnetic_field, magnetic_field, magnetic_field,\n handler.ERROR_CODE,)\n )\n\n handler.add_method(\n 'set_potential',\n (handler.INDEX, handler.INDEX, handler.INDEX,\n potential_energy),\n (handler.ERROR_CODE,)\n )\n handler.add_method(\n 'get_potential',\n (handler.INDEX, handler.INDEX, handler.INDEX,),\n (potential_energy,\n handler.ERROR_CODE,)\n )\n \n handler.add_method(\n 'get_grid_gravitational_potential',\n (handler.INDEX, handler.INDEX, handler.INDEX, handler.INDEX,),\n (potential_energy,\n handler.ERROR_CODE,)\n )\n \n handler.add_method(\n 'get_interpolated_gravitational_potential',\n (length, length, length),\n (potential_energy,\n handler.ERROR_CODE,)\n )\n \n handler.add_method(\n 'get_grid_gravitational_acceleration',\n (handler.INDEX, handler.INDEX, handler.INDEX, handler.INDEX,),\n (acceleration,acceleration,acceleration,\n handler.ERROR_CODE,)\n )\n \n handler.add_method(\n 'get_grid_acceleration',\n (handler.INDEX, handler.INDEX, handler.INDEX, handler.INDEX,),\n (acceleration,acceleration,acceleration,\n handler.ERROR_CODE,)\n )\n handler.add_method(\n 'set_grid_acceleration',\n (handler.INDEX, handler.INDEX, handler.INDEX,\n acceleration,acceleration,acceleration, handler.INDEX),\n (handler.ERROR_CODE,)\n )\n \n handler.add_method(\n 'get_gravity_at_point',\n (length, length, length, length),\n (acceleration, acceleration, acceleration, handler.ERROR_CODE)\n )\n\n handler.add_method(\n 'get_potential_at_point',\n (length, length, length, length),\n (potential, handler.ERROR_CODE)\n )\n \n handler.add_method(\n \"get_isocsound\",\n (),\n (length / time, handler.ERROR_CODE,)\n )\n \n handler.add_method(\n \"set_isocsound\",\n (length / time, ),\n (handler.ERROR_CODE,)\n )\n handler.add_method(\n \"get_timestep\",\n (),\n (time, handler.ERROR_CODE,)\n )\n \n handler.add_method(\n \"set_timestep\",\n (time, ),\n (handler.ERROR_CODE,)\n )\n \n handler.add_method(\n \"get_gamma\",\n (),\n (handler.NO_UNIT, handler.ERROR_CODE,)\n )\n \n handler.add_method(\n \"set_gamma\",\n (handler.NO_UNIT, ),\n (handler.ERROR_CODE,)\n )\n \n handler.add_method(\n \"get_courant_friedrichs_lewy_number\",\n (),\n (handler.NO_UNIT, handler.ERROR_CODE,)\n )\n \n handler.add_method(\n \"set_courant_friedrichs_lewy_number\",\n (handler.NO_UNIT, ),\n (handler.ERROR_CODE,)\n )\n \n handler.add_method(\n 'get_time',\n (),\n (time, handler.ERROR_CODE,)\n )\n \n handler.add_method(\n 'set_four_pi_G',\n ( length**3 / (mass * time**2)),\n (handler.ERROR_CODE,)\n )\n handler.add_method(\n 'get_four_pi_G',\n (),\n ( (length**3) / (mass * (time**2)), handler.ERROR_CODE,)\n )\n handler.add_method(\n 'set_grav_mean_rho',\n ( mass / length**3, ),\n (handler.ERROR_CODE,)\n )\n handler.add_method(\n 'get_grav_mean_rho',\n (),\n (mass / length**3, handler.ERROR_CODE,)\n )\n \n handler.add_method(\n 'setup_mesh',\n (handler.NO_UNIT, handler.NO_UNIT, handler.NO_UNIT, length, length, length,),\n (handler.ERROR_CODE,)\n )\n handler.add_method(\n 'set_boundary',\n (handler.NO_UNIT, handler.NO_UNIT, handler.NO_UNIT, handler.NO_UNIT, handler.NO_UNIT, handler.NO_UNIT,),\n (handler.ERROR_CODE,)\n )\n \n handler.add_method(\n 'set_boundary_state',\n (handler.INDEX, handler.INDEX, handler.INDEX,\n density, momentum, momentum, momentum, energy,\n handler.INDEX, handler.INDEX),\n (handler.ERROR_CODE,)\n )\n \n handler.add_method(\n 'get_boundary_state',\n (handler.INDEX, handler.INDEX, handler.INDEX, handler.INDEX, handler.INDEX),\n (density, momentum, momentum, momentum, energy,\n handler.ERROR_CODE,)\n )\n handler.add_method(\n 'get_boundary_position_of_index',\n (handler.INDEX, handler.INDEX, handler.INDEX, handler.INDEX, handler.INDEX),\n (length, length, length, handler.ERROR_CODE,)\n )\n handler.add_method(\n 'get_boundary_index_range_inclusive',\n (handler.INDEX, handler.INDEX),\n (handler.NO_UNIT, handler.NO_UNIT,handler.NO_UNIT, handler.NO_UNIT,handler.NO_UNIT, handler.NO_UNIT, handler.ERROR_CODE,)\n )\n handler.add_method(\n 'get_hydro_state_at_point',\n (generic_unit_system.length, generic_unit_system.length, generic_unit_system.length,\n generic_unit_system.speed, generic_unit_system.speed, generic_unit_system.speed),\n (generic_unit_system.density, generic_unit_system.momentum_density, generic_unit_system.momentum_density, \n generic_unit_system.momentum_density, generic_unit_system.energy_density, handler.ERROR_CODE)\n )\n handler.add_method(\n 'get_hydro_state_for_cell',\n (generic_unit_system.length, generic_unit_system.length, generic_unit_system.length,\n generic_unit_system.length, generic_unit_system.length, generic_unit_system.length,\n generic_unit_system.speed, generic_unit_system.speed, generic_unit_system.speed),\n (generic_unit_system.density, generic_unit_system.momentum_density, generic_unit_system.momentum_density, \n generic_unit_system.momentum_density, generic_unit_system.energy_density, handler.ERROR_CODE)\n )\n \n \n \n self.stopping_conditions.define_methods(handler)\n \n \n def specify_grid(self, definition, index_of_grid = 1):\n definition.set_grid_range('get_index_range_inclusive')\n \n definition.add_getter('get_position_of_index', names=('x','y','z'))\n \n definition.add_getter('get_grid_state', names=('rho', 'rhovx','rhovy','rhovz','energy'))\n definition.add_setter('set_grid_state', names=('rho', 'rhovx','rhovy','rhovz','energy'))\n \n definition.add_getter('get_grid_density', names=('rho',))\n definition.add_setter('set_grid_density', names=('rho',))\n \n if self.mode == self.MODE_SCALAR:\n definition.add_getter('get_grid_scalar', names=('scalar',))\n definition.add_setter('set_grid_scalar', names=('scalar',))\n \n definition.add_getter('get_grid_momentum_density', names=('rhovx','rhovy','rhovz'))\n definition.add_setter('set_grid_momentum_density', names=('rhovx','rhovy','rhovz'))\n definition.add_getter('get_grid_energy_density', names=('energy',))\n definition.add_setter('set_grid_energy_density', names=('energy',))\n \n \n definition.add_getter('get_grid_gravitational_potential', names=('gravitational_potential',))\n definition.add_getter('get_grid_gravitational_acceleration', names=('gravitational_acceleration_x','gravitational_acceleration_y','gravitational_acceleration_z',))\n \n definition.add_getter('get_grid_acceleration', names=('ax','ay','az'))\n definition.add_setter('set_grid_acceleration', names=('ax','ay','az'))\n \n definition.define_extra_keywords({'index_of_grid':index_of_grid})\n \n\n def specify_mangnetic_filed_grid(self, definition, index_of_grid = 1):\n definition.set_grid_range('get_index_range_magnetic_field_inclusive')\n \n definition.add_getter('get_position_of_index', names=('x','y','z'))\n \n definition.add_getter('get_grid_magnetic_field', names=('B1i','B2i','B3i')) \n definition.add_setter('set_grid_magnetic_field', names=('B1i','B2i','B3i'))\n \n definition.define_extra_keywords({'index_of_grid':index_of_grid})\n \n \n def specify_boundary_grid(self, definition, index_of_boundary, index_of_grid = 1):\n definition.set_grid_range('get_boundary_index_range_inclusive')\n \n definition.add_getter('get_boundary_position_of_index', names=('x','y','z'))\n \n definition.add_getter('get_boundary_state', names=('rho', 'rhovx','rhovy','rhovz','energy'))\n definition.add_setter('set_boundary_state', names=('rho', 'rhovx','rhovy','rhovz','energy'))\n \n definition.define_extra_keywords({'index_of_boundary': index_of_boundary, 'index_of_grid':index_of_grid})\n \n \n \n def sepecify_extended_grid(self, definition, index_of_grid = 1):\n self.specify_grid(definition, index_of_grid = index_of_grid)\n definition.set_grid_range('get_index_range_extended')\n \n \n @property\n def grid(self):\n return self._create_new_grid(self.specify_grid, index_of_grid = 1)\n \n BOUNDARY_NAME_TO_INDEX = {\n 'xbound1': 1,\n 'xbound2': 2,\n 'ybound1': 3,\n 'ybound2': 4,\n 'zbound1': 5,\n 'zbound2': 6,\n }\n def get_boundary_grid(self, name):\n if not name in self.BOUNDARY_NAME_TO_INDEX:\n raise Exception(\"boundary name is not known {0}\".format(name))\n index_of_boundary = self.BOUNDARY_NAME_TO_INDEX[name]\n \n return self._create_new_grid(self.specify_boundary_grid, index_of_boundary = index_of_boundary, index_of_grid = 1)\n \n\n def get_extended_grid(self, index_of_grid = 1):\n return self._create_new_grid(self.sepecify_extended_grid, index_of_grid = index_of_grid)\n \n def get_index_range_extended(self, index_of_grid = 1):\n i0,i1, j0,j1, k0,k1 = self.get_index_range_inclusive(index_of_grid = index_of_grid)\n dj = 2 if j1 > j0 else 0\n dk = 2 if k1 > k0 else 0\n return i0-2, i1+2, j0-dj, j0+dj, k0-dk, k1+dk\n \n def itergrids(self):\n n = self.get_number_of_grids()\n \n for x in range(1,n+1):\n yield self._create_new_grid(self.specify_grid, index_of_grid = x)\n\n def iter_magnetic_field_grids(self):\n n = self.get_number_of_grids()\n \n for x in range(1,n+1):\n yield self._create_new_grid(self.specify_mangnetic_filed_grid, index_of_grid = x)\n\n \n def iter_hydro_and_mhd_grids(self):\n n = self.get_number_of_grids()\n \n for x in range(1,n+1):\n yield (\n self._create_new_grid(self.specify_grid, index_of_grid = x),\n self._create_new_grid(self.specify_mangnetic_filed_grid, index_of_grid = x),\n )\n\n def define_particle_sets(self, handler):\n handler.define_grid('potential_grid')\n handler.set_grid_range('potential_grid', 'get_index_range_for_potential')\n handler.add_getter('potential_grid', 'get_position_of_index', names=('x','y','z'))\n handler.add_getter('potential_grid', 'get_potential', names=('potential',))\n handler.add_setter('potential_grid', 'set_potential', names=('potential', ))\n handler.define_extra_keywords('potential_grid', {'index_of_grid':1})\n \n \n def define_parameters(self, handler):\n handler.add_method_parameter(\n \"get_isocsound\", \n \"set_isocsound\",\n \"isothermal_sound_speed\", \n \"isothermal sound speed, only used for isothermal EOS\", \n default_value = 0.0 | length / time,\n must_set_before_get = True\n )\n \n handler.add_method_parameter(\n \"get_gamma\", \n \"set_gamma\",\n \"gamma\", \n \"ratio of specific heats used in equation of state\", \n default_value = 1.6666666666666667,\n must_set_before_get = True\n )\n \n handler.add_method_parameter(\n \"get_four_pi_G\", \n \"set_four_pi_G\",\n \"four_pi_G\", \n \"value of four times pi time G\", \n default_value = 4 * numpy.pi * (1| (length**3) / (mass * (time**2))),\n must_set_before_get = True\n )\n \n handler.add_method_parameter(\n \"get_grav_mean_rho\", \n \"set_grav_mean_rho\",\n \"gravity_mean_rho\", \n \"define the mean density in the field for self gravity calulations\", \n default_value = 0 | mass / length ** 3,\n must_set_before_get = True\n )\n \n \n handler.add_method_parameter(\n \"get_courant_friedrichs_lewy_number\", \n \"set_courant_friedrichs_lewy_number\",\n \"courant_number\", \n \"CFL number\", \n default_value = 0.3,\n must_set_before_get = True\n )\n \n \n handler.add_method_parameter(\n \"get_evolve_to_exact_time\", \n \"set_evolve_to_exact_time\",\n \"must_evolve_to_exact_time\", \n \"End the evolve model at the exact specified time\", \n default_value = True\n )\n \n handler.add_caching_parameter(\n \"setup_mesh\", \n \"nmeshx\",\n \"nx\", \n \"number of cells in the x direction\", \n 10,\n )\n \n \n handler.add_caching_parameter(\n \"setup_mesh\", \n \"nmeshy\",\n \"ny\", \n \"number of cells in the y direction\", \n 10,\n )\n \n \n handler.add_caching_parameter(\n \"setup_mesh\", \n \"nmeshz\",\n \"nz\", \n \"number of cells in the z direction\", \n 10,\n )\n \n handler.add_caching_parameter(\n \"setup_mesh\", \n \"xlength\",\n \"length_x\", \n \"length of model in the x direction\", \n 10 | length,\n )\n handler.add_caching_parameter(\n \"setup_mesh\", \n \"ylength\",\n \"length_y\", \n \"length of model in the x direction\", \n 10 | length,\n )\n handler.add_caching_parameter(\n \"setup_mesh\", \n \"zlength\",\n \"length_z\", \n \"length of model in the z direction\", \n 10 | length,\n )\n \n handler.add_vector_parameter(\n \"mesh_size\",\n \"number of cells in the x, y and z directions\",\n (\"nx\", \"ny\", \"nz\")\n )\n \n handler.add_vector_parameter(\n \"mesh_length\",\n \"length of the model in the x, y and z directions\",\n (\"length_x\", \"length_y\", \"length_z\")\n )\n \n handler.add_caching_parameter(\n \"set_parallel_decomposition\", \n \"nx\",\n \"nproc_x\", \n \"number of processors for the x direction\",\n 0,\n )\n handler.add_caching_parameter(\n \"set_parallel_decomposition\", \n \"ny\",\n \"nproc_y\", \n \"number of processors for the y direction\",\n 0,\n )\n handler.add_caching_parameter(\n \"set_parallel_decomposition\", \n \"nz\",\n \"nproc_z\", \n \"number of processors for the z direction\",\n 0,\n )\n \n handler.add_vector_parameter(\n \"parallel_decomposition\",\n \"number of processors for each dimensions\",\n (\"nproc_x\", \"nproc_y\", \"nproc_z\")\n )\n \n handler.add_caching_parameter(\n \"set_boundary\", \n \"xbound1\",\n \"xbound1\", \n \"boundary conditions on first (inner, left) X boundary\", \n \"reflective\",\n )\n \n \n handler.add_caching_parameter(\n \"set_boundary\", \n \"xbound2\",\n \"xbound2\", \n \"boundary conditions on second (outer, right) X boundary\",\n \"reflective\",\n )\n \n handler.add_caching_parameter(\n \"set_boundary\", \n \"ybound1\",\n \"ybound1\", \n \"boundary conditions on first (inner, front) Y boundary\", \n \"reflective\",\n )\n \n \n handler.add_caching_parameter(\n \"set_boundary\", \n \"ybound2\",\n \"ybound2\", \n \"boundary conditions on second (outer, back) Y boundary\",\n \"reflective\",\n )\n \n handler.add_caching_parameter(\n \"set_boundary\", \n \"zbound1\",\n \"zbound1\", \n \"boundary conditions on first (inner, bottom) Z boundary\", \n \"reflective\",\n )\n \n \n handler.add_caching_parameter(\n \"set_boundary\", \n \"zbound2\",\n \"zbound2\", \n \"boundary conditions on second (outer, top) Z boundary\", \n \"reflective\",\n )\n \n \n \n handler.add_vector_parameter(\n \"x_boundary_conditions\",\n \"boundary conditions for the X directorion\",\n (\"xbound1\", \"xbound2\")\n )\n \n \n handler.add_vector_parameter(\n \"y_boundary_conditions\",\n \"boundary conditions for the Y directorion\",\n (\"ybound1\", \"ybound2\")\n )\n \n \n handler.add_vector_parameter(\n \"z_boundary_conditions\",\n \"boundary conditions for the Z directorion\",\n (\"zbound1\", \"zbound2\")\n )\n \n self.stopping_conditions.define_parameters(handler)\n\n def commit_parameters(self):\n self.parameters.send_not_set_parameters_to_code()\n self.parameters.send_cached_parameters_to_code()\n self.overridden().commit_parameters()\n \n def define_state(self, handler): \n CommonCode.define_state(self, handler) \n #handler.add_transition('END', 'INITIALIZED', 'initialize_code', False)\n \n handler.add_transition('INITIALIZED','EDIT','commit_parameters')\n handler.add_transition('RUN','CHANGE_PARAMETERS_RUN','before_set_parameter', False)\n handler.add_transition('EDIT','CHANGE_PARAMETERS_EDIT','before_set_parameter', False)\n handler.add_transition('CHANGE_PARAMETERS_RUN','RUN','recommit_parameters')\n handler.add_transition('CHANGE_PARAMETERS_EDIT','EDIT','recommit_parameters')\n \n handler.add_method('CHANGE_PARAMETERS_RUN', 'before_set_parameter')\n handler.add_method('CHANGE_PARAMETERS_EDIT', 'before_set_parameter')\n \n handler.add_method('CHANGE_PARAMETERS_RUN', 'before_get_parameter')\n handler.add_method('CHANGE_PARAMETERS_EDIT', 'before_get_parameter')\n handler.add_method('RUN', 'before_get_parameter')\n handler.add_method('EDIT', 'before_get_parameter')\n \n handler.add_transition('EDIT', 'RUN', 'initialize_grid')\n handler.add_method('RUN', 'evolve_model')\n handler.add_method('RUN', 'get_hydro_state_at_point')\n \n for state in ['EDIT', 'RUN']:\n for methodname in [\n 'get_grid_state',\n 'set_grid_state',\n 'get_potential',\n 'set_potential',\n 'get_grid_density',\n 'set_grid_density',\n 'set_grid_energy_density',\n 'get_grid_energy_density',\n 'get_grid_momentum_density',\n 'set_grid_momentum_density', \n 'get_position_of_index',\n 'get_index_of_position',\n 'set_grid_scalar',\n 'get_grid_scalar',\n 'get_number_of_grids',\n 'get_index_range_inclusive',\n 'get_boundary_state',\n 'set_boundary_state',\n 'get_boundary_position_if_index',\n 'get_boundary_index_range_inclusive'\n ]:\n handler.add_method(state, methodname)\n \n self.stopping_conditions.define_state(handler)\n\n", "meta": {"hexsha": "78b8a94c66b2b479da3c75c4661e7c02e045db6f", "size": 53462, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/amuse/community/athena/interface.py", "max_stars_repo_name": "aatrani/amuse", "max_stars_repo_head_hexsha": "fd1abcfb1b118a9ab13031912abf6e65e9c60dde", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-04-09T09:06:08.000Z", "max_stars_repo_stars_event_max_datetime": "2019-04-09T09:06:08.000Z", "max_issues_repo_path": "src/amuse/community/athena/interface.py", "max_issues_repo_name": "aatrani/amuse", "max_issues_repo_head_hexsha": "fd1abcfb1b118a9ab13031912abf6e65e9c60dde", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-01-27T17:01:49.000Z", "max_issues_repo_issues_event_max_datetime": "2020-01-28T02:09:55.000Z", "max_forks_repo_path": "src/amuse/community/athena/interface.py", "max_forks_repo_name": "aatrani/amuse", "max_forks_repo_head_hexsha": "fd1abcfb1b118a9ab13031912abf6e65e9c60dde", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.8249818446, "max_line_length": 171, "alphanum_fraction": 0.5947027795, "include": true, "reason": "import numpy", "num_tokens": 11909, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073655352404, "lm_q2_score": 0.36296921930155557, "lm_q1q2_score": 0.19985352561001243}} {"text": "# AI for Business - Minimize cost with Deep Q-Learning\n# Building the Environment\n\n# Importing the libraries\nimport numpy as np\n\n# BUILDING THE ENVIRONMENT IN A CLASS\n\nclass Environment(object):\n \n # INTRODUCING AND INITIALIZING ALL THE PARAMETERS AND VARIABLES OF THE ENVIRONMENT\n \n def __init__(self, optimal_temperature = (18.0, 24.0), initial_month = 0, initial_number_users = 10, initial_rate_data = 60):\n self.monthly_atmospheric_temperatures = [1.0, 5.0, 7.0, 10.0, 11.0, 20.0, 23.0, 24.0, 22.0, 10.0, 5.0, 1.0]\n self.initial_month = initial_month\n self.atmospheric_temperature = self.monthly_atmospheric_temperatures[initial_month]\n self.optimal_temperature = optimal_temperature\n self.min_temperature = -20\n self.max_temperature = 80\n self.min_number_users = 10\n self.max_number_users = 100\n self.max_update_users = 5\n self.min_rate_data = 20\n self.max_rate_data = 300\n self.max_update_data = 10\n self.initial_number_users = initial_number_users\n self.current_number_users = initial_number_users\n self.initial_rate_data = initial_rate_data\n self.current_rate_data = initial_rate_data\n self.intrinsic_temperature = self.atmospheric_temperature + 1.25 * self.current_number_users + 1.25 * self.current_rate_data\n self.temperature_ai = self.intrinsic_temperature\n self.temperature_noai = (self.optimal_temperature[0] + self.optimal_temperature[1]) / 2.0\n self.total_energy_ai = 0.0\n self.total_energy_noai = 0.0\n self.reward = 0.0\n self.game_over = 0\n self.train = 1\n\n # MAKING A METHOD THAT UPDATES THE ENVIRONMENT RIGHT AFTER THE AI PLAYS AN ACTION\n \n def update_env(self, direction, energy_ai, month):\n \n # GETTING THE REWARD\n \n # Computing the energy spent by the server's cooling system when there is no AI\n energy_noai = 0\n if (self.temperature_noai < self.optimal_temperature[0]):\n energy_noai = self.optimal_temperature[0] - self.temperature_noai\n self.temperature_noai = self.optimal_temperature[0]\n elif (self.temperature_noai > self.optimal_temperature[1]):\n energy_noai = self.temperature_noai - self.optimal_temperature[1]\n self.temperature_noai = self.optimal_temperature[1]\n # Computing the Reward\n self.reward = energy_noai - energy_ai\n # Scaling the Reward\n self.reward = 1e-3 * self.reward\n \n # GETTING THE NEXT STATE\n \n # Updating the atmospheric temperature\n self.atmospheric_temperature = self.monthly_atmospheric_temperatures[month]\n # Updating the number of users\n self.current_number_users += np.random.randint(-self.max_update_users, self.max_update_users)\n if (self.current_number_users > self.max_number_users):\n self.current_number_users = self.max_number_users\n elif (self.current_number_users < self.min_number_users):\n self.current_number_users = self.min_number_users\n # Updating the rate of data\n self.current_rate_data += np.random.randint(-self.max_update_data, self.max_update_data)\n if (self.current_rate_data > self.max_rate_data):\n self.current_rate_data = self.max_rate_data\n elif (self.current_rate_data < self.min_rate_data):\n self.current_rate_data = self.min_rate_data\n # Computing the Delta of Intrinsic Temperature\n past_intrinsic_temperature = self.intrinsic_temperature\n self.intrinsic_temperature = self.atmospheric_temperature + 1.25 * self.current_number_users + 1.25 * self.current_rate_data\n delta_intrinsic_temperature = self.intrinsic_temperature - past_intrinsic_temperature\n # Computing the Delta of Temperature caused by the AI\n if (direction == -1):\n delta_temperature_ai = -energy_ai\n elif (direction == 1):\n delta_temperature_ai = energy_ai\n # Updating the new Server's Temperature when there is the AI\n self.temperature_ai += delta_intrinsic_temperature + delta_temperature_ai\n # Updating the new Server's Temperature when there is no AI\n self.temperature_noai += delta_intrinsic_temperature\n \n # GETTING GAME OVER\n \n if (self.temperature_ai < self.min_temperature):\n if (self.train == 1):\n self.game_over = 1\n else:\n self.total_energy_ai += self.optimal_temperature[0] - self.temperature_ai\n self.temperature_ai = self.optimal_temperature[0]\n elif (self.temperature_ai > self.max_temperature):\n if (self.train == 1):\n self.game_over = 1\n else:\n self.total_energy_ai += self.temperature_ai - self.optimal_temperature[1]\n self.temperature_ai = self.optimal_temperature[1]\n \n # UPDATING THE SCORES\n \n # Updating the Total Energy spent by the AI\n self.total_energy_ai += energy_ai\n # Updating the Total Energy spent by the server's cooling system when there is no AI\n self.total_energy_noai += energy_noai\n \n # SCALING THE NEXT STATE\n \n scaled_temperature_ai = (self.temperature_ai - self.min_temperature) / (self.max_temperature - self.min_temperature)\n scaled_number_users = (self.current_number_users - self.min_number_users) / (self.max_number_users - self.min_number_users)\n scaled_rate_data = (self.current_rate_data - self.min_rate_data) / (self.max_rate_data - self.min_rate_data)\n next_state = np.matrix([scaled_temperature_ai, scaled_number_users, scaled_rate_data])\n \n # RETURNING THE NEXT STATE, THE REWARD, AND GAME OVER\n \n return next_state, self.reward, self.game_over\n\n # MAKING A METHOD THAT RESETS THE ENVIRONMENT\n \n def reset(self, new_month):\n self.atmospheric_temperature = self.monthly_atmospheric_temperatures[new_month]\n self.initial_month = new_month\n self.current_number_users = self.initial_number_users\n self.current_rate_data = self.initial_rate_data\n self.intrinsic_temperature = self.atmospheric_temperature + 1.25 * self.current_number_users + 1.25 * self.current_rate_data\n self.temperature_ai = self.intrinsic_temperature\n self.temperature_noai = (self.optimal_temperature[0] + self.optimal_temperature[1]) / 2.0\n self.total_energy_ai = 0.0\n self.total_energy_noai = 0.0\n self.reward = 0.0\n self.game_over = 0\n self.train = 1\n\n # MAKING A METHOD THAT GIVES US AT ANY TIME THE CURRENT STATE, THE LAST REWARD AND WHETHER THE GAME IS OVER\n \n def observe(self):\n scaled_temperature_ai = (self.temperature_ai - self.min_temperature) / (self.max_temperature - self.min_temperature)\n scaled_number_users = (self.current_number_users - self.min_number_users) / (self.max_number_users - self.min_number_users)\n scaled_rate_data = (self.current_rate_data - self.min_rate_data) / (self.max_rate_data - self.min_rate_data)\n current_state = np.matrix([scaled_temperature_ai, scaled_number_users, scaled_rate_data])\n return current_state, self.reward, self.game_over\n", "meta": {"hexsha": "40f68d8cde0909c1f1cb3b374203afdb19b44f78", "size": 7328, "ext": "py", "lang": "Python", "max_stars_repo_path": "Chapter 11/environment.py", "max_stars_repo_name": "Bazzaware/AI-Crash-Course", "max_stars_repo_head_hexsha": "066e4bf62cf76c5ced7b08b249ac4f1379cb11dc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 147, "max_stars_repo_stars_event_min_datetime": "2019-04-15T18:38:47.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-22T11:08:11.000Z", "max_issues_repo_path": "Chapter 11/environment.py", "max_issues_repo_name": "Bazzaware/AI-Crash-Course", "max_issues_repo_head_hexsha": "066e4bf62cf76c5ced7b08b249ac4f1379cb11dc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chapter 11/environment.py", "max_forks_repo_name": "Bazzaware/AI-Crash-Course", "max_forks_repo_head_hexsha": "066e4bf62cf76c5ced7b08b249ac4f1379cb11dc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 120, "max_forks_repo_forks_event_min_datetime": "2019-04-19T08:01:24.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-26T05:19:04.000Z", "avg_line_length": 50.5379310345, "max_line_length": 132, "alphanum_fraction": 0.6883187773, "include": true, "reason": "import numpy", "num_tokens": 1646, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073655352404, "lm_q2_score": 0.3629692124105862, "lm_q1q2_score": 0.19985352181579394}} {"text": "# Copyright 2019 Google LLC\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\nimport functools\nimport operator\n\nimport numpy as np\n\nfrom jaxlib import xla_client\n\ntry:\n from jaxlib import cublas_kernels\n for _name, _value in cublas_kernels.registrations().items():\n xla_client.register_custom_call_target(_name, _value, platform=\"CUDA\")\nexcept ImportError:\n pass\n\ntry:\n from jaxlib import cusolver_kernels\n for _name, _value in cusolver_kernels.registrations().items():\n xla_client.register_custom_call_target(_name, _value, platform=\"CUDA\")\nexcept ImportError:\n pass\n\n_ops = xla_client.ops\n_Shape = xla_client.Shape\n\n# TODO(phawkins): remove after we no longer need to support old jax releases.\ndef _unpack_builder(c):\n # If `c` is a ComputationBuilder object, extracts the underlying XlaBuilder.\n return getattr(c, \"_builder\", c)\n\ndef _real_type(dtype):\n \"\"\"Returns the real equivalent of 'dtype'.\"\"\"\n if dtype == np.float32:\n return np.float32\n elif dtype == np.float64:\n return np.float64\n elif dtype == np.complex64:\n return np.float32\n elif dtype == np.complex128:\n return np.float64\n else:\n raise NotImplementedError(\"Unsupported dtype {}\".format(dtype))\n\n_prod = lambda xs: functools.reduce(operator.mul, xs, 1)\n\ndef trsm(c, a, b, left_side=False, lower=False, trans_a=False, conj_a=False,\n diag=False):\n \"\"\"Batched triangular solve.\n\n XLA implements unbatched triangular solve directly, so we need only implement\n the batched case.\"\"\"\n c = _unpack_builder(c)\n b_shape = c.get_shape(b)\n dtype = b_shape.element_type()\n dims = b_shape.dimensions()\n assert len(dims) >= 2\n m, n = dims[-2:]\n batch_dims = tuple(dims[:-2])\n num_bd = len(batch_dims)\n batch = _prod(batch_dims)\n k = m if left_side else n\n\n a_shape = c.get_shape(a)\n if (batch_dims + (k, k) != a_shape.dimensions() or\n a_shape.element_type() != dtype):\n raise ValueError(\"Argument mismatch for trsm, got {} and {}\".format(\n a_shape, b_shape))\n\n if conj_a and not trans_a:\n raise NotImplementedError(\"Conjugation without transposition not supported\")\n\n lwork, opaque = cublas_kernels.build_trsm_batched_descriptor(\n np.dtype(dtype), batch, m, n, left_side, lower, trans_a, conj_a, diag)\n layout = (num_bd, num_bd + 1) + tuple(range(num_bd - 1, -1, -1))\n out = _ops.CustomCallWithLayout(\n c, b\"cublas_trsm_batched\",\n operands=(a, b),\n shape_with_layout=_Shape.tuple_shape((\n _Shape.array_shape(dtype, b_shape.dimensions(), layout),\n _Shape.array_shape(np.dtype(np.int8), (lwork,), (0,)),\n _Shape.array_shape(np.dtype(np.int8), (lwork,), (0,)))),\n operand_shapes_with_layout=(\n _Shape.array_shape(dtype, a_shape.dimensions(), layout),\n _Shape.array_shape(dtype, b_shape.dimensions(), layout),\n ),\n opaque=opaque)\n return _ops.GetTupleElement(out, 0)\n\n\ndef potrf(c, a, lower):\n \"\"\"Cholesky decomposition.\"\"\"\n c = _unpack_builder(c)\n a_shape = c.get_shape(a)\n dtype = a_shape.element_type()\n dims = a_shape.dimensions()\n m, n = dims[-2:]\n assert m == n\n batch_dims = tuple(dims[:-2])\n num_bd = len(batch_dims)\n batch = _prod(batch_dims)\n\n lwork, opaque = cusolver_kernels.build_potrf_descriptor(\n np.dtype(dtype), lower, batch, n)\n kernel = b\"cusolver_potrf\"\n\n out = _ops.CustomCallWithLayout(\n c, kernel,\n operands=(a,),\n shape_with_layout=_Shape.tuple_shape((\n _Shape.array_shape(\n dtype, batch_dims + (n, n),\n (num_bd, num_bd + 1) + tuple(range(num_bd - 1, -1, -1))),\n _Shape.array_shape(\n np.dtype(np.int32), batch_dims, tuple(range(num_bd - 1, -1, -1))),\n _Shape.array_shape(np.dtype(np.int8), (lwork,), (0,)),\n )),\n operand_shapes_with_layout=(_Shape.array_shape(\n dtype, batch_dims + (n, n),\n (num_bd, num_bd + 1) + tuple(range(num_bd - 1, -1, -1))),),\n opaque=opaque)\n return _ops.GetTupleElement(out, 0), _ops.GetTupleElement(out, 1)\n\n\ndef getrf(c, a):\n \"\"\"LU decomposition.\"\"\"\n c = _unpack_builder(c)\n a_shape = c.get_shape(a)\n dtype = a_shape.element_type()\n dims = a_shape.dimensions()\n assert len(dims) >= 2\n m, n = dims[-2:]\n batch_dims = tuple(dims[:-2])\n num_bd = len(batch_dims)\n batch = _prod(batch_dims)\n\n if batch > 1 and m == n and m // batch <= 128:\n lwork, opaque = cublas_kernels.build_getrf_batched_descriptor(\n np.dtype(dtype), batch, m)\n workspace = _Shape.array_shape(np.dtype(np.int8), (lwork,), (0,))\n kernel = b\"cublas_getrf_batched\"\n else:\n lwork, opaque = cusolver_kernels.build_getrf_descriptor(\n np.dtype(dtype), batch, m, n)\n workspace = _Shape.array_shape(dtype, (lwork,), (0,))\n kernel = b\"cusolver_getrf\"\n\n out = _ops.CustomCallWithLayout(\n c, kernel,\n operands=(a,),\n shape_with_layout=_Shape.tuple_shape((\n _Shape.array_shape(\n dtype, batch_dims + (m, n),\n (num_bd, num_bd + 1) + tuple(range(num_bd - 1, -1, -1))),\n _Shape.array_shape(\n np.dtype(np.int32), batch_dims + (min(m, n),),\n tuple(range(num_bd, -1, -1))),\n _Shape.array_shape(\n np.dtype(np.int32), batch_dims, tuple(range(num_bd - 1, -1, -1))),\n workspace,\n )),\n operand_shapes_with_layout=(_Shape.array_shape(\n dtype, batch_dims + (m, n),\n (num_bd, num_bd + 1) + tuple(range(num_bd - 1, -1, -1))),),\n opaque=opaque)\n return (_ops.GetTupleElement(out, 0), _ops.GetTupleElement(out, 1),\n _ops.GetTupleElement(out, 2))\n\ndef geqrf(c, a):\n \"\"\"QR decomposition.\"\"\"\n c = _unpack_builder(c)\n a_shape = c.get_shape(a)\n dtype = a_shape.element_type()\n dims = a_shape.dimensions()\n assert len(dims) >= 2\n m, n = dims[-2:]\n batch_dims = tuple(dims[:-2])\n num_bd = len(batch_dims)\n batch = _prod(batch_dims)\n\n lwork, opaque = cusolver_kernels.build_geqrf_descriptor(\n np.dtype(dtype), batch, m, n)\n workspace = _Shape.array_shape(dtype, (lwork,), (0,))\n kernel = b\"cusolver_geqrf\"\n\n out = _ops.CustomCallWithLayout(\n c, kernel,\n operands=(a,),\n shape_with_layout=_Shape.tuple_shape((\n _Shape.array_shape(\n dtype, batch_dims + (m, n),\n (num_bd, num_bd + 1) + tuple(range(num_bd - 1, -1, -1))),\n _Shape.array_shape(\n dtype, batch_dims + (min(m, n),),\n tuple(range(num_bd, -1, -1))),\n _Shape.array_shape(\n np.dtype(np.int32), batch_dims, tuple(range(num_bd - 1, -1, -1))),\n workspace,\n )),\n operand_shapes_with_layout=(_Shape.array_shape(\n dtype, batch_dims + (m, n),\n (num_bd, num_bd + 1) + tuple(range(num_bd - 1, -1, -1))),),\n opaque=opaque)\n return (_ops.GetTupleElement(out, 0), _ops.GetTupleElement(out, 1),\n _ops.GetTupleElement(out, 2))\n\ndef orgqr(c, a, tau):\n \"\"\"Product of elementary Householder reflections.\"\"\"\n c = _unpack_builder(c)\n a_shape = c.get_shape(a)\n dtype = a_shape.element_type()\n dims = a_shape.dimensions()\n assert len(dims) >= 2\n m, n = dims[-2:]\n batch_dims = tuple(dims[:-2])\n num_bd = len(batch_dims)\n batch = _prod(batch_dims)\n\n tau_dims = c.get_shape(tau).dimensions()\n assert tau_dims[:-1] == dims[:-2]\n k = tau_dims[-1]\n\n lwork, opaque = cusolver_kernels.build_orgqr_descriptor(\n np.dtype(dtype), batch, m, n, k)\n workspace = _Shape.array_shape(dtype, (lwork,), (0,))\n kernel = b\"cusolver_orgqr\"\n\n out = _ops.CustomCallWithLayout(\n c, kernel,\n operands=(a, tau),\n shape_with_layout=_Shape.tuple_shape((\n _Shape.array_shape(\n dtype, batch_dims + (m, n),\n (num_bd, num_bd + 1) + tuple(range(num_bd - 1, -1, -1))),\n _Shape.array_shape(\n np.dtype(np.int32), batch_dims, tuple(range(num_bd - 1, -1, -1))),\n workspace,\n )),\n operand_shapes_with_layout=(\n _Shape.array_shape(\n dtype, batch_dims + (m, n),\n (num_bd, num_bd + 1) + tuple(range(num_bd - 1, -1, -1))),\n _Shape.array_shape(\n dtype, batch_dims + (k,),\n tuple(range(num_bd, -1, -1))),\n ),\n opaque=opaque)\n return (_ops.GetTupleElement(out, 0), _ops.GetTupleElement(out, 1))\n\n\ndef syevd(c, a, lower=False):\n \"\"\"Symmetric (Hermitian) eigendecomposition.\"\"\"\n c = _unpack_builder(c)\n\n a_shape = c.get_shape(a)\n dtype = a_shape.element_type()\n dims = a_shape.dimensions()\n assert len(dims) >= 2\n m, n = dims[-2:]\n assert m == n\n batch_dims = tuple(dims[:-2])\n num_bd = len(batch_dims)\n batch = _prod(batch_dims)\n layout = (num_bd, num_bd + 1) + tuple(range(num_bd - 1, -1, -1))\n\n if n <= 32:\n kernel = b\"cusolver_syevj\"\n lwork, opaque = cusolver_kernels.build_syevj_descriptor(\n np.dtype(dtype), lower, batch, n)\n else:\n kernel = b\"cusolver_syevd\"\n lwork, opaque = cusolver_kernels.build_syevd_descriptor(\n np.dtype(dtype), lower, batch, n)\n eigvals_type = _real_type(dtype)\n\n out = _ops.CustomCallWithLayout(\n c, kernel,\n operands=(a,),\n shape_with_layout=_Shape.tuple_shape((\n _Shape.array_shape(dtype, dims, layout),\n _Shape.array_shape(\n np.dtype(eigvals_type), batch_dims + (n,),\n tuple(range(num_bd, -1, -1))),\n _Shape.array_shape(\n np.dtype(np.int32), batch_dims,\n tuple(range(num_bd - 1, -1, -1))),\n _Shape.array_shape(dtype, (lwork,), (0,))\n )),\n operand_shapes_with_layout=(\n _Shape.array_shape(dtype, dims, layout),\n ),\n opaque=opaque)\n return (_ops.GetTupleElement(out, 0), _ops.GetTupleElement(out, 1),\n _ops.GetTupleElement(out, 2))\n\n\ndef gesvd(c, a, full_matrices=True, compute_uv=True):\n \"\"\"Singular value decomposition.\"\"\"\n c = _unpack_builder(c)\n\n a_shape = c.get_shape(a)\n dims = a_shape.dimensions()\n dtype = a_shape.element_type()\n assert len(dims) >= 2\n m, n = dims[-2:]\n batch_dims = tuple(dims[:-2])\n num_bd = len(batch_dims)\n b = _prod(batch_dims)\n singular_vals_dtype = np.dtype(_real_type(dtype))\n\n if m < 32 and n < 32:\n lwork, opaque = cusolver_kernels.build_gesvdj_descriptor(\n np.dtype(dtype), b, m, n, compute_uv)\n scalar_layout = tuple(range(num_bd - 1, -1, -1))\n vector_layout = (num_bd,) + scalar_layout\n matrix_layout = (num_bd, num_bd + 1) + scalar_layout\n out = _ops.CustomCallWithLayout(\n c, b\"cusolver_gesvdj\",\n operands=(a,),\n shape_with_layout=_Shape.tuple_shape((\n _Shape.array_shape(dtype, batch_dims + (m, n), matrix_layout),\n _Shape.array_shape(singular_vals_dtype, batch_dims + (min(m, n),),\n vector_layout),\n _Shape.array_shape(dtype, batch_dims + (m, m), matrix_layout),\n _Shape.array_shape(dtype, batch_dims + (n, n), matrix_layout),\n _Shape.array_shape(np.dtype(np.int32), batch_dims, scalar_layout),\n _Shape.array_shape(dtype, (lwork,), (0,)),\n )),\n operand_shapes_with_layout=(\n _Shape.array_shape(dtype, batch_dims + (m, n), matrix_layout),\n ),\n opaque=opaque)\n s = _ops.GetTupleElement(out, 1)\n u = _ops.GetTupleElement(out, 2)\n v = _ops.GetTupleElement(out, 3)\n info = _ops.GetTupleElement(out, 4)\n vt = _ops.Transpose(v, tuple(range(num_bd)) + (num_bd + 1, num_bd))\n if np.issubdtype(dtype, np.complexfloating):\n vt = _ops.Conj(vt)\n elif m < n:\n lwork, opaque = cusolver_kernels.build_gesvd_descriptor(\n np.dtype(dtype), b, n, m, compute_uv, full_matrices)\n scalar_layout = tuple(range(num_bd - 1, -1, -1))\n vector_layout = (num_bd,) + scalar_layout\n matrix_layout = (num_bd + 1, num_bd) + scalar_layout\n out = _ops.CustomCallWithLayout(\n c, b\"cusolver_gesvd\",\n operands=(a,),\n shape_with_layout=_Shape.tuple_shape((\n _Shape.array_shape(dtype, batch_dims + (m, n), matrix_layout),\n _Shape.array_shape(singular_vals_dtype, batch_dims + (min(m, n),),\n vector_layout),\n _Shape.array_shape(dtype, batch_dims + (n, n), matrix_layout),\n _Shape.array_shape(dtype, batch_dims + (m, m), matrix_layout),\n _Shape.array_shape(np.dtype(np.int32), batch_dims, scalar_layout),\n _Shape.array_shape(dtype, (lwork,), (0,)),\n )),\n operand_shapes_with_layout=(\n _Shape.array_shape(dtype, batch_dims + (m, n), matrix_layout),\n ),\n opaque=opaque)\n s = _ops.GetTupleElement(out, 1)\n vt = _ops.GetTupleElement(out, 2)\n u = _ops.GetTupleElement(out, 3)\n info = _ops.GetTupleElement(out, 4)\n else:\n lwork, opaque = cusolver_kernels.build_gesvd_descriptor(\n np.dtype(dtype), b, m, n, compute_uv, full_matrices)\n\n scalar_layout = tuple(range(num_bd - 1, -1, -1))\n vector_layout = (num_bd,) + scalar_layout\n matrix_layout = (num_bd, num_bd + 1) + scalar_layout\n out = _ops.CustomCallWithLayout(\n c, b\"cusolver_gesvd\",\n operands=(a,),\n shape_with_layout=_Shape.tuple_shape((\n _Shape.array_shape(dtype, batch_dims + (m, n), matrix_layout),\n _Shape.array_shape(singular_vals_dtype, batch_dims + (min(m, n),),\n vector_layout),\n _Shape.array_shape(dtype, batch_dims + (m, m), matrix_layout),\n _Shape.array_shape(dtype, batch_dims + (n, n), matrix_layout),\n _Shape.array_shape(np.dtype(np.int32), batch_dims, scalar_layout),\n _Shape.array_shape(dtype, (lwork,), (0,)),\n )),\n operand_shapes_with_layout=(\n _Shape.array_shape(dtype, batch_dims + (m, n), matrix_layout),\n ),\n opaque=opaque)\n s = _ops.GetTupleElement(out, 1)\n u = _ops.GetTupleElement(out, 2)\n vt = _ops.GetTupleElement(out, 3)\n info = _ops.GetTupleElement(out, 4)\n if not full_matrices:\n u = _ops.Slice(u, (0,) * len(dims), batch_dims + (m, min(m, n)),\n (1,) * len(dims))\n vt = _ops.Slice(vt, (0,) * len(dims), batch_dims + (min(m, n), n),\n (1,) * len(dims))\n return s, u, vt, info\n", "meta": {"hexsha": "1c50ceb006840ee7e1781e49c78c0aa844f03dc9", "size": 14689, "ext": "py", "lang": "Python", "max_stars_repo_path": "jaxlib/cusolver.py", "max_stars_repo_name": "tataudat/jax", "max_stars_repo_head_hexsha": "62862267e416ec4e053cca91a1376f1ac2ad7b72", "max_stars_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-12-05T15:35:59.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-05T15:35:59.000Z", "max_issues_repo_path": "jaxlib/cusolver.py", "max_issues_repo_name": "tataudat/jax", "max_issues_repo_head_hexsha": "62862267e416ec4e053cca91a1376f1ac2ad7b72", "max_issues_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "jaxlib/cusolver.py", "max_forks_repo_name": "tataudat/jax", "max_forks_repo_head_hexsha": "62862267e416ec4e053cca91a1376f1ac2ad7b72", "max_forks_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.6529126214, "max_line_length": 80, "alphanum_fraction": 0.6276805773, "include": true, "reason": "import numpy,from jax", "num_tokens": 4024, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.550607350786733, "lm_q2_score": 0.3629692193015555, "lm_q1q2_score": 0.19985352025675818}} {"text": "\"\"\"\nModule containing a container which can hold an arbitrary number of\n`distpy.distribution.Distribution.Distribution` objects, each of which can have\nany number of parameters which it describes (as long as the specific\n`distpy.distribution.Distribution.Distribution` supports that number of\nparameters). `distpy.distribution.Distribution.Distribution` objects can be\nadded through `DistributionList.add_distribution`. Once all the distributions\nare added, points can be drawn using the `DistributionList.draw` method and the\nlog value of the entire set of distributions can be evaluated at a point using\nthe `DistributionList.log_value` method. See documentation of individual\nmethods for further details. This class represents a list-like container of\n`distpy.distribution.Distribution.Distribution` objects; see\n`distpy.distribution.DistributionSet.DistributionSet` for a dictionary- or set-\nlike container of `distpy.distribution.Distribution.Distribution` objects.\nUnlike the `distpy.distribution.DistributionSet.DistributionSet` class,\n`DistributionList` is a subclass of\n`distpy.distribution.Distribution.Distribution` and implements all of its\nmethods and properties.\n\n**File**: $DISTPY/distpy/distribution/DistributionList.py \n**Author**: Keith Tauscher \n**Date**: 31 May 2021\n\"\"\"\nimport numpy as np\nimport numpy.random as rand\nimport scipy.linalg as scila\nfrom ..util import int_types, numerical_types, sequence_types\nfrom ..transform import TransformList, NullTransform\nfrom .Distribution import Distribution\n\nclass DistributionList(Distribution):\n \"\"\"\n An object which keeps track of many distributions which can be univariate\n or multivariate. It provides methods like log_value, which calls log_value\n on all of its constituent distributions, and draw, which draws from all of\n its constituent distributions.\n \"\"\"\n def __init__(self, distribution_tuples=[]):\n \"\"\"\n Creates a new `DistributionList` with the given distributions inside.\n \n Parameters\n ----------\n distribution_tuples : sequence\n a list of lists/tuples of the form `(distribution,)` or\n `(distribution, transforms)` where:\n \n - `distribution` is a\n `distpy.distribution.Distribution.Distribution` object\n - `transforms` is either a\n `distpy.transform.TransformList.TransformList` or something that\n can be cast to one (see the\n `distpy.transform.TransformList.TransformList.cast` method). It\n should describe the space in which the distribution applies. For\n example, to draw a variable from a normal distribution in log10\n space, `distribution` should be a\n `distpy.distribution.GaussianDistribution.GaussianDistribution` and\n `transforms` should be a\n `distpy.transform.Log10Transform.Log10Transform`. The result will\n contain only positive numbers.\n \"\"\"\n self._data = []\n if type(distribution_tuples) in sequence_types:\n for idistribution in range(len(distribution_tuples)):\n this_tup = distribution_tuples[idistribution]\n if (type(this_tup) in sequence_types):\n self.add_distribution(*this_tup)\n else:\n raise ValueError(\"One of the distribution tuples \" +\\\n \"provided to the initializer of a DistributionList \" +\\\n \"was not a sequence of length 2 like \" +\\\n \"(distribution, transforms).\")\n else:\n raise ValueError(\"The distribution_tuples argument given to \" +\\\n \"the initializer was not list-like. It should be a list of \" +\\\n \"tuples of the form (distribution, transformations) \" +\\\n \"where distribution is a Distribution object and \" +\\\n \"transformations are lists of strings.\")\n\n @property\n def empty(self):\n \"\"\"\n Boolean describing whether this `DistributionList` is empty.\n \"\"\"\n return (len(self._data) == 0)\n\n @property\n def numparams(self):\n \"\"\"\n The total number of parameters described by in this `DistributionList`.\n \"\"\"\n return len(self.transform_list)\n \n @property\n def mean(self):\n \"\"\"\n The approximate mean of this distribution. If the transform has a large\n second derivative at the mean, then this approximation is poor.\n \"\"\"\n if not hasattr(self, '_mean'):\n mean = []\n for (distribution, transforms) in self._data:\n if distribution.numparams == 1:\n mean.append(transforms[0].apply_inverse(distribution.mean))\n else:\n this_mean = distribution.mean\n for (itransform, transform) in enumerate(transforms):\n mean.append(\\\n transform.apply_inverse(this_mean[itransform]))\n self._mean = np.array(mean)\n return self._mean\n \n @property\n def variance(self):\n \"\"\"\n The covariance of this distribution.\n \"\"\"\n if not hasattr(self, '_variance'):\n variances = []\n for (distribution, transforms) in self._data:\n if distribution.numparams == 1:\n this_mean = np.array([distribution.mean])\n this_covariance = np.array([[distribution.variance]])\n variances.append(transforms.inverse.transform_covariance(\\\n this_covariance, this_mean))\n else:\n this_mean = distribution.mean\n this_covariance = distribution.variance\n variances.append(transforms.inverse.transform_covariance(\\\n this_covariance, this_mean))\n self._variance = scila.block_diag(*variances)\n return self._variance\n\n def add_distribution(self, distribution, transforms=None):\n \"\"\"\n Adds a `distpy.distribution.Distribution.Distribution` and the\n parameters it describes to the `DistributionList`.\n \n Parameters\n ----------\n distribution : `distpy.distribution.Distribution.Distribution`\n the distribution to add\n transforms : `distpy.transform.TransformList.TransformList` or\\\n `distpy.transform.Transform.Transform` or sequence or str or None\n a `distpy.transform.TransformList.TransformList` object (or\n something castable to one, see\n `distpy.transform.TransformList.TransformList.cast`) which apply to\n the parameters (can be a single\n `distpy.transform.Transform.Transform` or something castable to\n one, see `distpy.transform.CastTransform.cast_to_transform`, if the\n distribution is univariate). If `transforms` is None, then the\n transforms are assumed to be\n `distpy.transform.NullTransform.NullTransform`\n \"\"\"\n if isinstance(distribution, Distribution):\n transforms = TransformList.cast(transforms,\\\n num_transforms=distribution.numparams)\n self._data.append((distribution, transforms))\n else:\n raise ValueError(\"The distribution given to a DistributionList \" +\\\n \"was not recognized as a distribution.\")\n \n @property\n def num_distributions(self):\n \"\"\"\n The number of distributions stored in this `DistributionList` object.\n \"\"\"\n return len(self._data)\n \n def __add__(self, other):\n \"\"\"\n Adds this `DistributionList` to another to create a combined set.\n \n Parameters\n ----------\n other : `DistributionList`\n another `DistributionList` with parameters distinct from this one\n \n Returns\n -------\n sum : `DistributionList`\n the combination of the two `DistributionList` objects being added\n \"\"\"\n if isinstance(other, DistributionList):\n return DistributionList(distribution_tuples=self._data+other._data)\n else:\n raise TypeError(\"Can only add DistributionList objects to \" +\\\n \"other DistributionList objects.\")\n \n def __iadd__(self, other):\n \"\"\"\n Adds all distributions from `other` to this `DistributionList`.\n \n Parameters\n ----------\n other : `DistributionList`\n set of distributions to add into this one\n \n Returns\n -------\n enlarged : `DistributionList`\n this `DistributionList` after the distributions from `other` have\n been added in\n \"\"\"\n if isinstance(other, DistributionList):\n for distribution_tuple in other._data:\n self.add_distribution(*distribution_tuple)\n return self\n else:\n raise TypeError(\"DistributionList objects can only have other \" +\\\n \"DistributionList objects added to them.\")\n \n def modify_transforms(self, new_transform_list):\n \"\"\"\n Creates a `DistributionList` with the same distribution and parameters\n but different transforms. Draws from this `DistributionList` and the\n returned `DistributionList` will differ by the given transforms.\n \n Parameters\n ----------\n new_transform_list : `distpy.transform.TransformList.TransformList` or\\\n `distpy.transform.Transform.Transform` or str or None\n a `distpy.transform.TransformList.TransformList` containing the new\n transforms (or something that can be cast to one with a number of\n transforms equal to the `DistributionList.numparams`; see\n `distpy.transform.TransformList.TransformList.cast` for details on\n what can be cast successfully)\n \n Returns\n -------\n modified : `DistributionList`\n new `DistributionList` object with the same distribution and\n parameters but different transforms\n \"\"\"\n new_transform_list =\\\n TransformList.cast(transforms, num_transforms=self.numparams)\n (new_data, running_index) = ([], 0)\n for (distribution, transforms) in self._data:\n new_running_index = running_index + distribution.numparams\n new_transforms =\\\n new_transform_list[running_index:new_running_index]\n running_index = new_running_index\n new_data.append((distribution, new_transforms))\n return DistributionList(distribution_tuples=new_data)\n \n def draw(self, shape=None, random=rand):\n \"\"\"\n Draws a point from all distributions.\n \n Parameters\n ----------\n shape : int or tuple or None\n shape of arrays which are values of return value\n random : `numpy.random.RandomState`\n the random number generator to use (default: numpy.random)\n \n Returns\n -------\n drawn_points : `numpy.ndarray`\n random variates drawn from the distribution (in the following `p`\n is `DistributionList.numparams`):\n - if `shape` is None, then `drawn_points` is a 1D `numpy.ndarray`\n of length `p`\n - if `shape` is an integer, then `drawn_points` is a 2D\n `numpy.ndarray` of shape `(shape,p)`\n - if `shape` is a tuple, then drawn points is a `numpy.ndarray` of\n shape `shape + (p,)`\n \"\"\"\n none_shape = (type(shape) is type(None))\n if none_shape:\n shape = 1\n if type(shape) in int_types:\n shape = (shape,)\n point = np.ndarray(shape+(self.numparams,))\n params_included = 0\n for (distribution, transforms) in self._data:\n numparams = distribution.numparams\n if numparams == 1:\n transform = transforms[0]\n point[...,params_included] = transforms[0].apply_inverse(\\\n distribution.draw(shape=shape, random=random))\n else:\n this_draw = distribution.draw(shape=shape, random=random)\n for (itransform, transform) in enumerate(transforms):\n point[...,params_included+itransform] =\\\n transform.apply_inverse(this_draw[...,itransform])\n params_included += numparams\n if self.numparams == 1:\n point = point[...,0]\n if none_shape:\n return point[0]\n else:\n return point\n \n def log_value(self, point):\n \"\"\"\n Evaluates the log of the product of the values of the\n `distpy.distribution.Distribution.Distribution` objects contained in\n this `DistributionList`, which is the sum of their log values.\n \n Parameters\n ----------\n point : `numpy.ndarray`\n array of parameter values\n \n Returns\n -------\n total_log_value : float\n total log_value coming from contributions from all distributions\n \"\"\"\n if type(point) in numerical_types:\n point = [point]\n if type(point) in sequence_types:\n point = np.array(point)\n if point.shape == (self.numparams,):\n result = 0.\n params_included = 0\n for (distribution, transforms) in self._data:\n numparams = distribution.numparams\n if numparams == 1:\n subpoint = transforms[0].apply(point[params_included])\n else:\n subpoint = [\\\n transform.apply(point[params_included+itransform])\\\n for (itransform, transform) in\\\n enumerate(transforms)]\n result += distribution.log_value(subpoint)\n for (itransform, transform) in enumerate(transforms):\n result += transform.log_derivative(\\\n point[params_included+itransform])\n params_included += numparams\n if not np.isfinite(result):\n return -np.inf\n return result\n else:\n raise ValueError(\"point given to log_value function of a \" +\\\n \"DistributionList did not have the correct length.\")\n else:\n raise ValueError(\"point given to log_value function of a \" +\\\n \"DistributionList was not an array.\")\n \n def __getitem__(self, which):\n \"\"\"\n Gets a `DistributionList` with only the specified distributions.\n \n Parameters\n ----------\n which : int or slice or sequence\n the index or indices of the distributions to include in the\n returned value\n \n Returns\n -------\n sublist : `DistributionList`\n a `DistributionList` object with only the specified distribution(s)\n \"\"\"\n if type(which) in int_types:\n distribution_list =\\\n DistributionList(distribution_tuples=[self._data[which]])\n elif isinstance(which, slice):\n distribution_list =\\\n DistributionList(distribution_tuples=self._data[which])\n elif type(which) in sequence_types:\n distribution_list = DistributionList()\n for which_element in which:\n distribution_list.add_distribution(*self._data[which_element])\n else:\n raise ValueError(\"Only integers, sequences of integers, and \" +\\\n \"slices are allowed as arguments to __getitem__.\")\n return distribution_list\n \n def delete_distribution(self, index):\n \"\"\"\n Deletes a distribution from this `DistributionList`.\n \n Parameters\n ----------\n index : int\n the index of the distribution to delete\n \"\"\"\n self._data = self._data[:index] + self._data[index+1:]\n \n def __delitem__(self, which):\n \"\"\"\n Deletes a distribution from this `DistributionList`. Alias of\n `DistributionList.delete_distribution` that allows for usage of the\n `del` keyword.\n \n Parameters\n ----------\n index : int\n the index of the distribution to delete\n \"\"\"\n if type(which) in int_types:\n self.delete_distribution(which)\n elif isinstance(which, slice) or (type(which) in sequence_types):\n if isinstance(which, slice):\n which = list(range(*which.indices(self.num_distributions)))\n which = sorted(which)[-1::-1]\n for index in which:\n self.delete_distribution(index)\n else:\n raise ValueError(\"Only integers, sequences of integers, and \" +\\\n \"slices are allowed as arguments to __delitem__.\")\n \n @property\n def summary_string(self):\n \"\"\"\n A string with the dimenstionality of the distribution.\n \"\"\"\n return '{:d}D DistributionList'.format(self.numparams)\n \n @property\n def minimum(self):\n \"\"\"\n The minimum allowable value(s) in this distribution.\n \"\"\"\n if not hasattr(self, '_minimum'):\n self._minimum = []\n for (distribution, transforms) in self._data:\n if distribution.numparams == 1:\n self._minimum.append(transforms[0].untransform_minimum(\\\n distribution.minimum))\n else:\n self._minimum.extend([transform.untransform_minimum(\\\n minimum) for (minimum, transform) in\\\n zip(distribution.minimum, transforms)])\n return self._minimum\n \n @property\n def maximum(self):\n \"\"\"\n The maximum allowable value(s) in this distribution.\n \"\"\"\n if not hasattr(self, '_maximum'):\n self._maximum = []\n for (distribution, transforms) in self._data:\n if distribution.numparams == 1:\n self._maximum.append(transforms[0].untransform_maximum(\\\n distribution.maximum))\n else:\n self._maximum.extend([transform.untransform_maximum(\\\n maximum) for (maximum, transform) in\\\n zip(distribution.maximum, transforms)])\n return self._maximum\n \n @property\n def is_discrete(self):\n \"\"\"\n Boolean describing whether all of the distributions in this list are\n discrete.\n \"\"\"\n return all([distribution.is_discrete\\\n for (distribution, transforms) in self._data])\n \n @staticmethod\n def _distribution_tuples_equal(first, second):\n \"\"\"\n Checks whether two distribution tuples are equal.\n \n Parameters\n ----------\n first : tuple\n tuple of form `(distribution, parameters)` as internally\n represented in a `DistributionList`\n second : tuple\n tuple of form `(distribution, transforms)` as internally\n represented in a `DistributionList`\n \n Returns\n -------\n result : bool\n True if and only if the distribution and transformations stored in\n `first` are the same as those stored in `second`.\n \"\"\"\n (first_distribution, first_transforms) = first\n (second_distribution, second_transforms) = second\n numparams = first_distribution.numparams\n if second_distribution.numparams == numparams:\n for (first_transform, second_transform) in\\\n zip(first_transforms, second_transforms):\n if first_transform != second_transform:\n return False\n return (first_distribution == second_distribution)\n else:\n return False\n \n def __eq__(self, other):\n \"\"\"\n Checks for equality of this `DistributionList` with `other`.\n \n Parameters\n ----------\n other : object\n object to check for equality\n \n Returns\n -------\n result : bool\n True if and only if `other` is a `DistributionList` with the same\n distribution tuples (though they need not be internally stored in\n the same order).\n \"\"\"\n if isinstance(other, DistributionList):\n if len(self._data) == len(other._data):\n return all([DistributionList._distribution_tuples_equal(\\\n *tuples) for tuples in zip(self._data, other._data)])\n else:\n return False\n else:\n return False\n \n @property\n def transform_list(self):\n \"\"\"\n The `distpy.transform.TransformList.TransformList` object describing\n the transforms in this `DistributionList`.\n \"\"\"\n answer = TransformList()\n for (distribution, transforms) in self._data:\n answer += transforms\n return answer\n \n def discrete_sublist(self):\n \"\"\"\n Compiles the subset of the `Distribution` objects in this\n `DistributionList` that represent discrete variables.\n \n Returns\n -------\n subset : `DistributionList`\n a `DistributionList` object containing all\n `distpy.distribution.Distribution.Distribution` objects in this\n `DistributionList` which describe discrete variables\n \"\"\"\n answer = DistributionList()\n for (distribution, transforms) in self._data:\n if distribution.is_discrete:\n answer.add_distribution(distribution, transforms)\n return answer\n \n def continuous_sublist(self):\n \"\"\"\n Compiles the subset of the `Distribution` objects in this\n `DistributionList` that represent continuous variables.\n \n Returns\n -------\n subset : `DistributionList`\n a `DistributionList` object containing all\n `distpy.distribution.Distribution.Distribution` objects in this\n `DistributionList` which describe continuous variables\n \"\"\"\n answer = DistributionList()\n for (distribution, transforms) in self._data:\n if not distribution.is_discrete:\n answer.add_distribution(distribution, transforms)\n return answer\n \n def transformed_version(self):\n \"\"\"\n Compiles a version of this `DistributionList` where the parameters\n exist in transformed space (instead of transforms being carried through\n this object).\n \n Returns\n -------\n transformless : `DistributionList`\n a `DistributionList` with the same distributions and parameter\n names but without transforms\n \"\"\"\n answer = DistributionList()\n for (distribution, transforms) in self._data:\n answer.add_distribution(distribution)\n return answer\n \n def fill_hdf5_group(self, group, save_metadata=True):\n \"\"\"\n Fills the given hdf5 file group with data about this\n `DistributionList`.\n \n Parameters\n ----------\n group : h5py.Group\n the hdf5 file group to fill\n save_metadata : bool\n - if True, attempts to save metadata alongside distribution list\n and throws error if it fails\n - if False, metadata is ignored in saving process\n \"\"\"\n group.attrs['class'] = 'DistributionList'\n for (ituple, distribution_tuple) in enumerate(self._data):\n (distribution, transforms) = distribution_tuple\n subgroup = group.create_group('distribution_{}'.format(ituple))\n distribution.fill_hdf5_group(subgroup, save_metadata=save_metadata)\n transforms.fill_hdf5_group(subgroup)\n \n @staticmethod\n def load_from_hdf5_group(group, *distribution_classes):\n \"\"\"\n Loads a `DistributionList` object from the given group.\n \n Parameters\n ----------\n group : h5py.Group\n the hdf5 file group in which a `DistributionList` was saved\n distribution_classes : sequence\n sequence of Distribution subclasses with which to load\n subdistributions (if the sub-distributions are defined in `distpy`,\n then these are not necessary because all distributions save their\n class as an attribute when they run\n `distpy.distribution.Distribution.Distribution.fill_hdf5_group`)\n \n Returns\n -------\n loaded : `DistributionList`\n a `DistributionList` that was saved in `group`\n \"\"\"\n ituple = 0\n distribution_tuples = []\n while ('distribution_{}'.format(ituple)) in group:\n subgroup = group['distribution_{}'.format(ituple)]\n distribution_class_name = subgroup.attrs['class']\n if ituple >= len(distribution_classes):\n module = __import__('distpy')\n distribution_class = getattr(module, distribution_class_name)\n else:\n distribution_class = distribution_classes[ituple]\n distribution = distribution_class.load_from_hdf5_group(subgroup)\n transform_list = TransformList.load_from_hdf5_group(subgroup)\n distribution_tuples.append((distribution, transform_list))\n ituple += 1\n return DistributionList(distribution_tuples=distribution_tuples)\n \n @property\n def gradient_computable(self):\n \"\"\"\n Boolean describing whether the gradient of the distributions inside\n this `DistributionList` have been implemented.\n \"\"\"\n answer = True\n for (distribution, transforms) in self._data:\n answer = (answer and distribution.gradient_computable)\n return answer\n \n def gradient_of_log_value(self, point):\n \"\"\"\n Computes the derivatives of the log value with respect to the\n parameters.\n \n Parameters\n ----------\n point : `numpy.ndarray`\n array of parameter values\n \n Returns\n -------\n gradient : `numpy.ndarray`\n 1D array of length `DistributionSet.numparams` of derivative values\n corresponding to the parameters\n \"\"\"\n if type(point) in sequence_types:\n point = np.array(point)\n result = np.zeros((self.numparams,))\n params_included = 0\n for (idistribution, distribution_tuple) in enumerate(self._data):\n (distribution, transforms) = distribution_tuple\n numparams = distribution.numparams\n if numparams == 1:\n result[params_included] +=\\\n distribution.gradient_of_log_value(\\\n transforms[0].apply(point[params_included]))\n else:\n subpoint = np.array([\\\n transform.apply(point[params_included+itransform])\\\n for (itransform, transform) in enumerate(transforms)])\n result[params_included:params_included+numparams] +=\\\n distribution.gradient_of_log_value(subpoint)\n for index in range(numparams):\n result[params_included+index] +=\\\n transforms[index].derivative_of_log_derivative(\\\n point[params_included+index])\n params_included += numparams\n return result\n else:\n raise ValueError(\"point given to gradient_of_log_value \" +\\\n \"function of a DistributionList was not a sequence of values.\")\n \n @property\n def hessian_computable(self):\n \"\"\"\n Boolean describing whether the hessian of the distributions inside this\n `DistributionList` have been implemented.\n \"\"\"\n answer = True\n for (distribution, transforms) in self._data:\n answer = (answer and distribution.hessian_computable)\n return answer\n \n def hessian_of_log_value(self, point):\n \"\"\"\n Computes the second derivatives of the log value with respect to the\n parameters.\n \n Parameters\n ----------\n point : `numpy.ndarray`\n array of parameter values\n \n Returns\n -------\n gradient : `numpy.ndarray`\n 1D array of length `DistributionSet.numparams` of second derivative\n values corresponding to the parameters\n \"\"\"\n if type(point) in sequence_types:\n point = np.array(point)\n result = np.zeros((self.numparams,) * 2)\n params_included = 0\n for (idistribution, distribution_tuple) in enumerate(self._data):\n (distribution, transforms) = distribution_tuple\n numparams = distribution.numparams\n if numparams == 1:\n subpoint = transforms[0].apply(point[params_included])\n result[params_included,params_included] +=\\\n distribution.hessian_of_log_value(subpoint)\n else:\n subpoint = np.array([\\\n transform.apply(point[params_included+itransform])\\\n for (itransform, transform) in enumerate(transforms)])\n result_slice = 2 *\\\n (slice(params_included, params_included + numparams),)\n result[result_slice] +=\\\n distribution.hessian_of_log_value(subpoint)\n for i in range(numparams):\n result[params_included+index,params_included+index] +=\\\n transforms[index].second_derivative_of_log_derivative(\\\n point[params_included+index])\n params_included += numparams\n return result\n else:\n raise ValueError(\"point given to hessian_of_log_value \" +\\\n \"function of a DistributionList was not a sequence of values.\")\n \n def copy(self):\n \"\"\"\n Finds a deep copy of this `DistributionList`.\n \n Returns\n -------\n copied : `DistributionList`\n deep copy of this `DistributionList`\n \"\"\"\n copied = DistributionList()\n for (distribution, transforms) in self._data:\n copied_distribution = distribution.copy()\n copied_transforms = [transform for transform in transforms]\n copied.add_distribution(copied_distribution, copied_transforms)\n return copied\n \n def reset(self):\n \"\"\"\n Resets this distribution. This allows ideal distributions to live\n alongside samples as the same kind of object.\n \"\"\"\n for (distribution, transforms) in self._data:\n distribution.reset()\n\n", "meta": {"hexsha": "b271adbd0a5158b6748a83c9ed41e43bd17971c1", "size": 31309, "ext": "py", "lang": "Python", "max_stars_repo_path": "distpy/distribution/DistributionList.py", "max_stars_repo_name": "CU-NESS/distpy", "max_stars_repo_head_hexsha": "279ba7e46726a85246566401fca19b8739d18d08", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "distpy/distribution/DistributionList.py", "max_issues_repo_name": "CU-NESS/distpy", "max_issues_repo_head_hexsha": "279ba7e46726a85246566401fca19b8739d18d08", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "distpy/distribution/DistributionList.py", "max_forks_repo_name": "CU-NESS/distpy", "max_forks_repo_head_hexsha": "279ba7e46726a85246566401fca19b8739d18d08", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.7139141743, "max_line_length": 79, "alphanum_fraction": 0.5907885911, "include": true, "reason": "import numpy,import scipy", "num_tokens": 5840, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073655352404, "lm_q2_score": 0.3629692055196168, "lm_q1q2_score": 0.19985351802157544}} {"text": "# Copyright 2020 Google LLC\n\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"Wavefunction class for accessing and manipulation of the state of interest\n\"\"\"\n#zeros_like is incorrectly flagged by pylint\n#pylint: disable=unsupported-assignment-operation\n#there are many instances where access to protected members/methods simplify the\n#code structure. They are not exposed to the users, and therefore, harmless\n#pylint: disable=protected-access\n\nimport copy\nimport os\nimport math\nfrom typing import (Any, Callable, cast, Dict, KeysView, List, Optional, Tuple,\n Union)\n\nimport pickle\nimport numpy\nfrom scipy import linalg\nfrom scipy.special import factorial, jv\n\nfrom fqe.fqe_decorators import wrap_apply, wrap_apply_generated_unitary\nfrom fqe.fqe_decorators import wrap_time_evolve, wrap_rdm\nfrom fqe.fqe_data import FqeData\nfrom fqe.fqe_data_set import FqeDataSet\nfrom fqe.util import alpha_beta_electrons\nfrom fqe.util import map_broken_symmetry\nfrom fqe.util import sort_configuration_keys\nfrom fqe.util import vdot\nfrom fqe.hamiltonians import hamiltonian, sparse_hamiltonian, \\\n diagonal_hamiltonian, diagonal_coulomb, \\\n restricted_hamiltonian\nfrom fqe.bitstring import count_bits\nfrom fqe.fqe_ops import fqe_operator, fqe_ops_utils\nfrom fqe.wick import wick\n\n\nclass Wavefunction:\n \"\"\"Wavefunction is the central object for manipulaion in the\n OpenFermion-FQE.\n \"\"\"\n\n def __init__(self,\n param: Optional[List[List[int]]] = None,\n broken: Optional[Union[List[str], str]] = None) -> None:\n \"\"\"\n Args:\n param (list[list[n, ms, norb]]): the constructor accepts a list of \\\n parameter lists. The parameter lists are comprised of\n\n p[0] (integer) - number of particles;\n\n p[1] (integer) - z component of spin angular momentum;\n\n p[2] (integer) - number of spatial orbitals\n\n broken (str): pass in the symmetries that should be preserved by \\\n the wavefunction.\n\n Member Variables:\n _conserve_spin (bool): When this flag is true, the wavefunction \\\n will maintain a constant m_s\n\n _conserve_number (bool): When this flag is true, the wavefunction \\\n will maintain a constant nele\n\n _civec (dict[(int, int)] -> FqeData): This is a dictionary for \\\n FqeData objects. The key is a tuple defined by the number of \\\n electrons and the spin projection of the system.\n \"\"\"\n self._symmetry_map: Dict[Tuple[int, int], Tuple[int, int]] = {}\n self._conserved: Dict[str, int] = {}\n\n self._conserve_spin: bool = False\n if broken is None or 'spin' not in broken:\n self._conserve_spin = True\n\n self._conserve_number: bool = False\n if broken is None or 'number' not in broken:\n self._conserve_number = True\n\n self._norb: int = 0\n self._civec: Dict[Tuple[int, int], 'FqeData'] = {}\n\n if not self._conserve_spin and not self._conserve_number:\n raise TypeError('Number and spin non-conserving waveunfction is' \\\n ' the complete Fock space.')\n\n if param:\n user_input_norbs = set([x[2] for x in param])\n if len(user_input_norbs) != 1:\n raise ValueError('Number of orbitals is not consistent')\n\n self._norb = list(user_input_norbs)[0]\n for i in param:\n nalpha, nbeta = alpha_beta_electrons(i[0], i[1])\n self._civec[(i[0], i[1])] = FqeData(nalpha, nbeta, self._norb)\n\n if self._conserve_number:\n self._conserved['n'] = param[0][0]\n\n if self._conserve_spin:\n self._conserved['s_z'] = param[0][1]\n\n if not self._conserve_number:\n self._symmetry_map = map_broken_symmetry(\n param[0][1], param[0][2])\n\n def __add__(self, other: 'Wavefunction') -> 'Wavefunction':\n \"\"\"Intrinsic addition function to combine two wavefunctions. This acts \\\n to iterate through the wavefunctions, combine coefficients of \\\n configurations they have in common and add configurations that are \\\n unique to each one. The values are all combined into a new \\\n wavefunction object\n\n Args:\n other (wavefunction.Wavefunction): the second wavefunction to \\\n add with the local wavefunction\n\n Returns:\n wfn (wavefunction.Wavefunction): a new wavefunction with the \\\n values set by adding together values\n \"\"\"\n out = copy.deepcopy(self)\n out.ax_plus_y(1.0, other)\n return out\n\n def __iadd__(self, wfn: 'Wavefunction') -> 'Wavefunction':\n \"\"\"Same is __add___ but performed in-place\n\n Args:\n wfn (wavefunction.Wavefunction): the second wavefunction to \\\n add with the local wavefunction\n\n Returns:\n Wavefunction: self\n \"\"\"\n self.ax_plus_y(1.0, wfn)\n return self\n\n def __sub__(self, other: 'Wavefunction') -> 'Wavefunction':\n \"\"\"Intrinsic subtraction function to combine two wavefunctions. This\n acts to iterate through the wavefunctions, combine coefficients of\n configurations they have in common and include configurations that are\n unique to each one. The values are all combined into a new\n wavefunction object\n\n Args:\n other (wavefunction.Wavefunction): the second wavefunction that \\\n will be subtracted from the first wavefunction\n\n Returns:\n wfn (wavefunction.Wavefunction): a new wavefunction with the\n values set by subtracting the wfn from the first\n \"\"\"\n out = copy.deepcopy(self)\n out.ax_plus_y(-1.0, other)\n return out\n\n def __getitem__(self, key: Tuple[int, int]) -> complex:\n \"\"\"Element read access to the wave function.\n Args:\n key (Tuple[int, int]): a pair of strings for alpha and beta\n\n Returns:\n (complex): the value of the wave function\n \"\"\"\n astr, bstr = key[0], key[1]\n sector = (count_bits(astr) + count_bits(bstr),\n count_bits(astr) - count_bits(bstr))\n return self._civec[sector][key]\n\n def __setitem__(self, key: Tuple[int, int], value: complex) -> None:\n \"\"\"Element write access to the wave function.\n Args:\n key (Tuple[int, int]): a pair of strings for alpha and beta\n\n value (complex): the value to be set to the wave function\n \"\"\"\n astr, bstr = key[0], key[1]\n sector = (count_bits(astr) + count_bits(bstr),\n count_bits(astr) - count_bits(bstr))\n self._civec[sector][key] = value\n\n def empty_copy(self) -> 'Wavefunction':\n \"\"\"create a copy of self with zero coefficients\n\n Returns:\n Wavefunction: a new object with zero coefficients\n \"\"\"\n out = Wavefunction()\n out._norb = self._norb\n out._conserved = self._conserved\n out._symmetry_map = self._symmetry_map\n for key, civec in self._civec.items():\n out._civec[key] = civec.empty_copy()\n return out\n\n def _copy_beta_inversion(self) -> 'Wavefunction':\n \"\"\"Return a copy of the wavefunction with the beta particle and hole\n inverted.\n\n Returns:\n Wavefunction: wavefuction with beta particle/hole conjugation\n \"\"\"\n norb = self._norb\n m_s = self._conserved['s_z']\n\n nele = norb + m_s\n param = []\n maxb = min(norb, nele)\n minb = nele - maxb\n param = [\n [nele, nele - nbeta * 2, norb] for nbeta in range(minb, maxb + 1)\n ]\n\n inverted = Wavefunction(param, broken=['spin'])\n\n data = {}\n for key, sector in self._civec.items():\n work = ((key[0] + key[1]) // 2, (key[0] - key[1]) // 2)\n nkey = self._symmetry_map[work]\n data[(nkey[0] + nkey[1],\n nkey[0] - nkey[1])] = sector.beta_inversion()\n\n inverted.set_wfn(strategy='from_data', raw_data=data)\n\n return inverted\n\n def ax_plus_y(self, sval: complex, wfn: 'Wavefunction') -> None:\n \"\"\"Perform scale and add of the wavefunction. The result will be stored\n in self.\n\n Args:\n sval (complex): a factor to be multiplied to wfn\n\n wfn (Wavefunction): a wavefunction to be added to self\n \"\"\"\n if self._civec.keys() != wfn._civec.keys():\n raise ValueError('inconsistent sectors in Wavefunction.ax_plus_y')\n\n for sector in self._civec:\n self._civec[sector].ax_plus_y(sval, wfn._civec[sector])\n\n def sector(self, key: Tuple[int, int]) -> 'FqeData':\n \"\"\"Return a specific sector of the wavefunction using a key.\n\n Args:\n key (Tuple[int, int]): key for ci vector\n Returns:\n FqeData: corresponding sector as an FqeData object\n \"\"\"\n return self._civec[key]\n\n def sectors(self) -> KeysView[Tuple[int, int]]:\n \"\"\"\n Return:\n KeysView[Tuple[int, int]]: a list of the configuration keys \\\n in the wavefunction\n \"\"\"\n return self._civec.keys()\n\n def conserve_number(self) -> bool:\n \"\"\"\n Returns:\n (bool): True if this wave function conserves the number symmetry\n \"\"\"\n return self._conserve_number\n\n def conserve_spin(self) -> bool:\n \"\"\"\n Returns:\n (bool): True if this wave function conserves the spin (Sz) \\\n symmetry. Otherwise False\n \"\"\"\n return self._conserve_spin\n\n def norb(self) -> int:\n \"\"\"\n Returns:\n (int): the number of orbitals\n \"\"\"\n return self._norb\n\n def norm(self) -> float:\n \"\"\"Calculate the norm of the wavefuntion\n\n Returns:\n (float): the norm\n \"\"\"\n normall = 0.0\n for sector in self._civec.values():\n normall += sector.norm()**2\n normall = math.sqrt(normall)\n return normall\n\n def normalize(self) -> None:\n \"\"\"Generte the wavefunction norm and then scale each element by that\n value.\n \"\"\"\n self.scale(1.0 / self.norm())\n\n @wrap_apply\n def apply(self, hamil: 'hamiltonian.Hamiltonian') -> 'Wavefunction':\n \"\"\" Returns a wavefunction subject to application of the Hamiltonian\n (or more generally, the operator).\n\n Args:\n hamil (Hamiltonian): Hamiltonian to be applied\n\n Returns:\n (Wavefunction): resulting wave function array\n \"\"\"\n if not self._conserve_number or not hamil.conserve_number():\n if self._conserve_number:\n raise TypeError('Number non-conserving hamiltonian passed to'\n ' number conserving wavefunction')\n if hamil.conserve_number():\n raise TypeError('Number conserving hamiltonian passed to'\n ' number non-conserving wavefunction')\n\n if isinstance(hamil, sparse_hamiltonian.SparseHamiltonian):\n\n transformed = self._apply_few_nbody(hamil)\n\n else:\n if self._conserve_spin and not self._conserve_number:\n out = self._copy_beta_inversion()\n else:\n out = self\n\n if isinstance(hamil, diagonal_hamiltonian.Diagonal):\n transformed = out._apply_diagonal(hamil)\n elif isinstance(hamil, diagonal_coulomb.DiagonalCoulomb):\n transformed = out._apply_diagonal_coulomb(hamil)\n else:\n if isinstance(hamil,\n restricted_hamiltonian.RestrictedHamiltonian):\n expected = self._norb\n else:\n expected = self._norb * 2\n if hamil.dim() != expected:\n raise ValueError('Hamiltonian has incorrect size:' \\\n + ' expected {}'.format(expected) \\\n + ' provided {}'.format(hamil.dim()))\n\n transformed = out._apply_array(hamil.tensors(), hamil.e_0())\n\n if self._conserve_spin and not self._conserve_number:\n transformed = transformed._copy_beta_restore(\n self._conserved['s_z'], self._norb, self._symmetry_map)\n\n return transformed\n\n def _apply_array(self, array: Tuple[numpy.ndarray, ...],\n e_0: complex) -> 'Wavefunction':\n \"\"\"Return a wavefunction subject to application of the numpy array as\n\n .. math::\n h[i, j]a_i^+ a_j|Psi>\n h[i, j, k, l]a_i^+(rho) a_j^+(eta) a_k(rho) a_l(eta)|Psi>\n\n Arg:\n array (numpy.array): numpy array\n\n e_0 (complex): scalar part of the Hamiltonian\n\n Returns:\n newwfn (Wavefunction): a new intialized wavefunction object\n\n \"\"\"\n if self._conserve_spin:\n assert array[0].shape[0] == self._norb or array[0].shape[\n 0] == self._norb * 2\n out = copy.deepcopy(self)\n for _, sector in out._civec.items():\n sector.apply_inplace(array)\n else:\n assert array[0].shape[0] == self._norb * 2\n out = copy.deepcopy(self)\n nsectors = out._number_sectors()\n for _, nsector in nsectors.items():\n nsector.apply_inplace(array)\n\n if numpy.abs(e_0) > 1.e-15:\n out.ax_plus_y(e_0, self)\n\n return out\n\n def _apply_diagonal(self, hamil: 'diagonal_hamiltonian.Diagonal'\n ) -> 'Wavefunction':\n \"\"\"Applies the diagonal operator to the wavefunction\n\n Args:\n hamil (Diagonal): diagonal Hamiltonian to be applied\n\n Returns:\n (Wavefunction): resulting wave function\n \"\"\"\n out = copy.deepcopy(self)\n\n for _, sector in out._civec.items():\n sector.apply_diagonal_inplace(hamil.diag_values())\n\n if numpy.abs(hamil.e_0()) > 1.e-15:\n out.ax_plus_y(hamil.e_0(), self)\n\n return out\n\n def _apply_diagonal_coulomb(self, hamil: 'diagonal_coulomb.DiagonalCoulomb'\n ) -> 'Wavefunction':\n \"\"\"Applies the diagonal coulomb operator to the wavefunction\n\n Args:\n hamil (DiagonalCoulomb): diagonal coulomb Hamiltonian to be applied\n\n Returns:\n (Wavefunction): resulting wave function\n \"\"\"\n out = copy.deepcopy(self)\n\n for _, sector in out._civec.items():\n diag, array = hamil._tensor[1], hamil._tensor[2]\n sector.apply_diagonal_coulomb(diag, array, inplace=True)\n\n if numpy.abs(hamil.e_0()) > 1.e-15:\n out.ax_plus_y(hamil.e_0(), self)\n\n return out\n\n def _number_sectors(self) -> Dict[int, FqeDataSet]:\n \"\"\"An internal utility function that groups FqeData into a set of\n FqeDataSet that corresponds to the same number of electrons. It checks\n spin completeness and raises an exception if the wave function space is\n not spin complete\n\n Returns:\n Dict[int, FqeDataSet]: stores FqeDataSet for each number of\n particles. Keys are the number of particles.\n \"\"\"\n norb = self.norb()\n numbers = set(key[0] for key in self._civec)\n numbersectors = {}\n for nele in numbers:\n # generate all possible sz\n maxalpha = min(norb, nele)\n minalpha = nele - maxalpha\n sectors = {}\n sp_compl = set(((nele, 2 * nalpha - nele)\n for nalpha in range(minalpha, maxalpha + 1)))\n\n if set(self._civec.keys()).intersection(sp_compl) != sp_compl:\n raise ValueError('Wave function space is not spin complete.')\n\n for nalpha in range(minalpha, maxalpha + 1):\n nbeta = nele - nalpha\n sectors[(nalpha, nbeta)] = self._civec[(nele, nalpha - nbeta)]\n dataset = FqeDataSet(nele, norb, sectors)\n numbersectors[nele] = dataset\n return numbersectors\n\n def _copy_beta_restore(self, s_z: int, norb: int,\n map_symm: Dict[Tuple[int, int], Tuple[int, int]]\n ) -> 'Wavefunction':\n \"\"\"Return a copy of the wavefunction with beta restored back to number\n breaking/spin conserving.\n\n Args:\n s_z (int): the value of Sz\n\n norb (int): the number of orbitals in the system\n\n map_symm (Dict[Tuple[int,int], Tuple[int,int]]): dictionary that maps \\\n between number-conserved and spin-conserved wave function sectors\n\n Returns:\n Wavefunction: restored wavefunction\n \"\"\"\n max_alpha = min(norb, norb + s_z)\n min_alpha = max(s_z, 0)\n\n param = [[2 * nalpha - s_z, s_z, norb]\n for nalpha in range(min_alpha, max_alpha + 1)]\n\n restored = Wavefunction(param, broken=['number'])\n\n data = {}\n for key in param:\n work = ((key[0] + key[1]) // 2, (key[0] - key[1]) // 2)\n nkey = map_symm[work]\n other = (nkey[0] + nkey[1], nkey[0] - nkey[1])\n data[(key[0], key[1])] = self._civec[other].beta_inversion()\n\n restored.set_wfn(strategy='from_data', raw_data=data)\n\n return restored\n\n @wrap_apply_generated_unitary\n def apply_generated_unitary(self,\n time: float,\n algo: str,\n hamil: 'hamiltonian.Hamiltonian',\n accuracy: float = 1.0E-14,\n expansion: int = 30,\n spec_lim: Optional[List[float]] = None\n ) -> 'Wavefunction':\n \"\"\"Perform the exponentiation of fermionic algebras to the\n wavefunction according the method and accuracy.\n\n Args:\n time (float): the final time value to evolve to\n\n algo (string): polynomial expansion algorithm to be used\n\n hamil (Hamiltonian): the Hamiltonian used to generate the unitary\n\n accuracy (float): the accuracy to which the system should be evolved\n\n expansion (int): the maximum number of terms in the polynomial expansion\n\n spec_lim (List[float]): spectral range of the Hamiltonian, the length of \\\n the list should be 2. Optional.\n\n Returns:\n newwfn (Wavefunction): a new intialized wavefunction object\n \"\"\"\n\n assert isinstance(hamil, hamiltonian.Hamiltonian)\n\n algo_avail = ['taylor', 'chebyshev']\n\n assert algo in algo_avail\n\n if not isinstance(hamil, sparse_hamiltonian.SparseHamiltonian) \\\n and self._conserve_spin and not self._conserve_number:\n base = self._copy_beta_inversion()\n else:\n base = self\n\n max_expansion = max(30, expansion)\n\n if algo == 'taylor':\n ham_arrays = hamil.iht(time)\n\n time_evol = copy.deepcopy(base)\n work = copy.deepcopy(base)\n\n for order in range(1, max_expansion):\n work = work.apply(ham_arrays)\n coeff = 1.0 / factorial(order)\n time_evol.ax_plus_y(coeff, work)\n if work.norm() * numpy.abs(coeff) < accuracy:\n break\n\n elif algo == 'chebyshev':\n\n assert spec_lim, 'Spectral range was not provided.' + \\\n ' Provide upper and lower limits.'\n\n wprime = 0.9875\n ascale = (spec_lim[1] - spec_lim[0]) / (2.0 * wprime)\n eshift = -(spec_lim[0] + ascale * wprime)\n\n time_evol = copy.deepcopy(base)\n time_evol.scale(jv(0, ascale * time))\n minus = copy.deepcopy(base)\n\n current = minus.apply(hamil)\n current.ax_plus_y(eshift, minus)\n current.scale(1.0 / ascale)\n time_evol.ax_plus_y(2.0 * jv(1, ascale * time) * (-1.j), current)\n\n for order in range(2, max_expansion):\n minus.scale(-1.0)\n minus.ax_plus_y(2.0 / ascale, current.apply(hamil))\n minus.ax_plus_y(2.0 * eshift / ascale, current)\n current, minus = minus, current\n\n coeff = 2.0 * jv(order, ascale * time) * (-1.j)**order\n time_evol.ax_plus_y(coeff, current)\n\n if current.norm() * numpy.abs(coeff) < accuracy:\n break\n\n time_evol.scale(numpy.exp(eshift * time * 1.j))\n\n if numpy.abs(hamil.e_0() * time) > 1.e-15:\n time_evol.scale(numpy.exp(-1.j * time * hamil.e_0()))\n\n if self._conserve_spin and not self._conserve_number:\n time_evol = time_evol._copy_beta_restore(self._conserved['s_z'],\n self._norb,\n self._symmetry_map)\n return time_evol\n\n def get_coeff(self, key: Tuple[int, int]) -> numpy.ndarray:\n \"\"\"Retrieve a vector from a configuration in the wavefunction\n\n key indicates wavefunction sector by [num_alpha, num_beta]\n\n Args:\n key (Tuple[int, int]): a key identifying the configuration to access\n\n Returns:\n numpy.array(dtype=numpy.complex128): coeff that corresponds to key\n \"\"\"\n return self._civec[key].coeff\n\n def max_element(self) -> complex:\n \"\"\"\n Return:\n (complex): the largest magnitude value in the wavefunction\n \"\"\"\n maxval = 0.0\n for config in self._civec.values():\n configmax = max(config.coeff.max(),\n config.coeff.min(),\n key=numpy.abs)\n maxval = max(configmax, maxval)\n\n return maxval\n\n def print_wfn(self, threshold: float = 0.001, fmt: str = 'str') -> None:\n \"\"\"Print occupations and coefficients to the screen.\n\n Args:\n threshhold (float): only print CI vector values such that \\\n :math:`|c|` > threshold.\n\n fmt (string): formats print according to argument\n \"\"\"\n\n def _print_format(fmt: str) -> Callable[[int, int], str]:\n \"\"\" Select the function which will perform formatted printing\n \"\"\"\n if fmt == 'occ':\n\n def _occupation_format(iastring: int, ibstring: int):\n \"\"\"occ - Prints a string indicating occupation state of each spatial\n orbital. A doubly occupied orbital will be indicated with \"2\",\n a singly occupied orbital will get \"a\" or \"b\" depending on the\n spin state. An empy orbital will be \".\".\n \"\"\"\n astring = int(iastring)\n bstring = int(ibstring)\n occstr = [\n '.' for _ in range(\n max(astring.bit_length(), bstring.bit_length()))\n ]\n docc = astring & bstring\n\n def build_occ_value(bstr: int, char: str,\n occstr: List[str]):\n \"\"\"Fill a list with a character corresponding to the\n location of '1' bits in bitstring\n\n Args:\n bstr (int): a bitstring to examine\n\n char (str): a string to put into the list\n\n occstr (list): a list to store the value\n corresponding to flipped bits\n \"\"\"\n ind = 1\n while bstr:\n if bstr & 1:\n occstr[-ind] = char\n ind += 1\n bstr = bstr >> 1\n\n build_occ_value(astring, 'a', occstr)\n build_occ_value(bstring, 'b', occstr)\n build_occ_value(docc, '2', occstr)\n\n return ''.join(occstr).rjust(self._norb, '.')\n\n return _occupation_format\n\n def _string_format(iastring: int, ibstring: int) -> str:\n \"\"\"Prints a binary string indicating which orbital creation\n operators are acting on the vacuum with a 1. The position in\n the string indicates the index of the orbital. The beta string\n is shown acting on the vacuum first.\n\n Args:\n iastring (int): alpha string\n\n ibstring (int): alpha string\n\n Returns:\n str: representation of binary string\n \"\"\"\n astring = int(iastring)\n bstring = int(ibstring)\n fmt_a = bin(1 << self._norb | astring)\n fmt_b = bin(1 << self._norb | bstring)\n return \"a'{}'b'{}'\".format(fmt_a[3:], fmt_b[3:])\n\n return _string_format\n\n print_format = _print_format(fmt)\n\n config_in_order = sort_configuration_keys(self.sectors())\n for key in config_in_order:\n self._civec[key].print_sector(pformat=print_format,\n threshold=threshold)\n\n def read(self, filename: str, path: str = os.getcwd()) -> None:\n \"\"\"Initialize a wavefunction from a binary file.\n\n Args:\n filename (str): the name of the file to write the wavefunction to.\n\n path (str): the path to save the file. If no path is given then \\\n it is saved in the current working directory.\n \"\"\"\n with open(os.path.join(path, filename), 'r+b') as wfnfile:\n wfn_data = pickle.load(wfnfile)\n\n self._symmetry_map = wfn_data[0]\n self._conserved = wfn_data[1]\n self._conserve_spin = wfn_data[2]\n self._conserve_number = wfn_data[3]\n self._norb = wfn_data[4]\n\n for sector in wfn_data[5:]:\n self._civec[(sector[0][0], sector[0][1])] = sector[1]\n\n def save(self, filename: str, path: str = os.getcwd()) -> None:\n \"\"\"Save the wavefunction into path/filename.\n\n Args:\n filename (str): the name of the file to write the wavefunction to.\n\n path (str): the path to save the file. If no path is given, then \\\n it is saved in the current working directory.\n \"\"\"\n wfn_data = [\n self._symmetry_map, self._conserved, self._conserve_spin,\n self._conserve_number, self._norb\n ]\n\n for key in self._civec:\n wfn_data.append([key, self._civec[key]])\n\n with open(os.path.join(path, filename), 'w+b') as wfnfile:\n pickle.dump(wfn_data, wfnfile)\n\n def scale(self, sval: complex) -> None:\n \"\"\" Scale each configuration space by the value sval\n\n Args:\n sval (complex): value to scale by\n \"\"\"\n\n sval = complex(sval) # type: ignore\n\n for sector in self._civec.values():\n sector.scale(sval)\n\n def set_wfn(self,\n strategy: str = 'ones',\n raw_data: Optional[Dict[Tuple[int, int], numpy.ndarray]] = None\n ) -> None:\n \"\"\"Set the values of the wavefunction inplace based on a strategy.\n\n Args:\n strategy (string): The procedure to follow to set the wavefunction \\\n coefficients. One of 'random', 'hartree-fock', 'ones', 'zeros', \\\n or 'from_data'. If 'from_data', raw_data must be provided.\n\n raw_data (Dict[Tuple[int, int], numpy.ndarray]): The values to use \\\n if setting from data. Optional.\n \"\"\"\n if strategy == 'from_data' and not raw_data:\n raise ValueError('No data provided for set_wfn')\n\n if strategy == 'from_data':\n for key, data in raw_data.items(): # type: ignore\n self._civec[key].set_wfn(strategy='from_data', raw_data=data)\n elif strategy == 'hartree-fock':\n # make sure we only have 1 sector\n if len(self.sectors()) != 1:\n raise ValueError((\"Hartree-Fock wf initialization only works \"\n \"with single sector wavefunctions\"))\n for sector in self._civec.values():\n sector.set_wfn(strategy=strategy)\n else:\n for sector in self._civec.values():\n sector.set_wfn(strategy=strategy)\n\n if strategy == 'random':\n self.normalize()\n\n def transform(\n self,\n rotation: numpy.ndarray,\n low: Optional[numpy.ndarray] = None,\n upp: Optional[numpy.ndarray] = None\n ) -> Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, 'Wavefunction']:\n \"\"\"Transform the wavefunction using the orbtial rotation matrix and\n return the new wavefunction and the permutation matrix for the unitary\n transformation. This is an internal code, so performs minimal checking\n\n Args:\n rotation (numpy.ndarray): MO rotation matrix, which is unitary\n\n low (numpy.ndarray): L in the LU decomposition (optional)\n\n upp (numpy.ndarray): U in the LU decomposition (optional)\n\n Returns:\n (numpy.ndarray, numpy.ndarray, numpy.ndarray, 'Wavefunction'): \\\n permutation, L, U, and transformed wavefunction\n \"\"\"\n norb = self._norb\n external = low is not None\n assert external == (upp is not None)\n if external:\n assert numpy.allclose(rotation, low @ upp) # type: ignore\n\n def ludecomp(rotmat: numpy.ndarray\n ) -> Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray]:\n \"\"\"Returns permutation, lower triangular, and upper triangular\n matrices from the LU decomposition. Note that the rotation matrix\n is Hermitian conjugated.\n\n Args:\n rotmat (numpy.ndarray): MO rotation matrix, which is unitary\n\n (numpy.ndarray, numpy.ndarray, numpy.ndarray): permutation, \\\n L, and U from the LU decomposition.\n \"\"\"\n tmat = rotmat.transpose().conjugate()\n return linalg.lu(tmat)\n\n def transpose_matrix(low: numpy.ndarray, upp: numpy.ndarray\n ) -> Tuple[numpy.ndarray, numpy.ndarray]:\n \"\"\"Returns Hermitian conjugate of the L and U factors. The diagonal\n elements are in the upper triagular matrix. This transposition seeks to\n compensate the transposition in ludecomp above.\n\n Args:\n low (numpy.ndarray): L in the LU decomposition\n\n upp (numpy.ndarray): U in the LU decomposition\n\n Returns:\n (numpy.ndarray, numpy.ndarray): L and U after transposition \\\n where L and U are lower- and upper-triangular, respectively\n \"\"\"\n ndim = low.shape[0]\n assert low.shape[1] == ndim and upp.shape == (ndim, ndim)\n lowt = copy.deepcopy(low)\n uppt = copy.deepcopy(upp)\n for irow in range(ndim):\n for icol in range(irow + 1, ndim):\n uppt[irow, icol] /= uppt[irow, irow]\n lowt[irow, irow], uppt[irow, irow] = uppt[irow, irow], lowt[\n irow, irow]\n for icol in range(irow):\n lowt[irow, icol] *= lowt[icol, icol]\n return uppt.T.conj(), lowt.T.conj()\n\n def process_matrix(low: numpy.ndarray,\n upp: numpy.ndarray) -> numpy.ndarray:\n \"\"\"Returns an operator using which the wavefuction will be transformed.\n\n Args:\n low (numpy.ndarray): L in the LU decomposition\n\n upp (numpy.ndarray): U in the LU decomposition\n\n Returns:\n (numpy.ndarray): matrix elements of the transformation operator T\n \"\"\"\n ndim = low.shape[0]\n assert low.shape[1] == ndim and upp.shape == (ndim, ndim)\n unitmat = numpy.identity(ndim)\n output = linalg.solve_triangular(upp, unitmat)\n\n for icol in range(ndim):\n for irow in range(icol + 1, ndim):\n output[irow, icol] -= low[irow, icol]\n output[icol, icol] -= 1.0\n return output\n\n current = self\n perm = None\n\n if not self._conserve_spin:\n if not external:\n perm, low, upp = ludecomp(rotation)\n lowt, uppt = transpose_matrix(low, upp)\n else:\n lowt, uppt = low, upp\n output = process_matrix(lowt, uppt)\n for icol in range(norb * 2):\n work = numpy.zeros_like(rotation)\n work[:, icol] = output[:, icol]\n onefwfn = current.apply((work,))\n current.ax_plus_y(1.0, onefwfn)\n else:\n if rotation.shape[0] == norb:\n if not external:\n perm, low, upp = ludecomp(rotation)\n lowt, uppt = transpose_matrix(low, upp)\n else:\n lowt, uppt = low, upp\n output = process_matrix(lowt, uppt)\n for _, civec in current._civec.items():\n civec.apply_columns_recursive_inplace(output, output)\n elif rotation.shape[0] == norb * 2:\n assert numpy.std(rotation[:norb, norb:]) \\\n + numpy.std(rotation[norb:, :norb]) < 1.0e-8\n if not external:\n perm1, low1, upp1 = ludecomp(rotation[:norb, :norb])\n perm2, low2, upp2 = ludecomp(rotation[norb:, norb:])\n lowt1, uppt1 = transpose_matrix(low1, upp1)\n lowt2, uppt2 = transpose_matrix(low2, upp2)\n else:\n lowt1 = low[:norb, :norb] # type: ignore\n lowt2 = low[norb:, norb:] # type: ignore\n uppt1 = upp[:norb, :norb] # type: ignore\n uppt2 = upp[norb:, norb:] # type: ignore\n output1 = process_matrix(lowt1, uppt1)\n output2 = process_matrix(lowt2, uppt2)\n for _, civec in current._civec.items():\n civec.apply_columns_recursive_inplace(output1, output2)\n if not external:\n perm = numpy.zeros_like(rotation)\n perm[:norb, :norb] = perm1[:, :]\n perm[norb:, norb:] = perm2[:, :]\n upp = numpy.zeros_like(rotation)\n upp[:norb, :norb] = upp1[:, :]\n upp[norb:, norb:] = upp2[:, :]\n low = numpy.zeros_like(rotation)\n low[:norb, :norb] = low1[:, :]\n low[norb:, norb:] = low2[:, :]\n\n return perm, low, upp, current\n\n @wrap_time_evolve\n def time_evolve(\n self,\n time: float,\n hamil: Union['fqe_operator.FqeOperator', 'hamiltonian.Hamiltonian'],\n inplace: bool = False) -> 'Wavefunction':\n \"\"\"Perform time evolution of the wavefunction given Fermion Operators\n either as raw operations or wrapped up in a Hamiltonian.\n\n Args:\n time (float): the duration by which to evolve the operators\n\n hamil (Hamiltoninan or FermionOperator): Hamiltonian to be used for \\\n time evolution\n\n inplace (bool): whether the result will be stored in place\n\n Returns:\n (Wavefunction): a wavefunction object that has been time evolved.\n \"\"\"\n assert isinstance(hamil, hamiltonian.Hamiltonian)\n\n if not self._conserve_number or not hamil.conserve_number():\n if self._conserve_number:\n raise TypeError('Number non-conserving hamiltonian passed to'\n ' number conserving wavefunction')\n if hamil.conserve_number():\n raise TypeError('Number conserving hamiltonian passed to'\n ' number non-conserving wavefunction')\n\n if isinstance(\n hamil,\n sparse_hamiltonian.SparseHamiltonian) and hamil.is_individual():\n\n final_wfn = self._evolve_individual_nbody(time, hamil, inplace)\n\n else:\n is_diag = ((hamil.quadratic() and hamil.diagonal()) or\n hamil.diagonal_coulomb())\n if inplace and (not is_diag and not hamil.quadratic()):\n raise ValueError(\"Inplace is not implemented for this case\")\n\n if self._conserve_spin and not self._conserve_number:\n work_wfn = self._copy_beta_inversion()\n elif inplace:\n work_wfn = self\n else:\n work_wfn = copy.deepcopy(self)\n\n if hamil.quadratic():\n if hamil.diagonal():\n\n ihtdiag = -1.j * time * hamil.diag_values()\n final_wfn = work_wfn._evolve_diagonal(ihtdiag, inplace)\n\n else:\n transformation = hamil.calc_diag_transform()\n\n permu, low, upp, work_wfn = work_wfn.transform(\n transformation)\n\n ci_trans = transformation @ permu\n\n h1e = hamil.transform(ci_trans)\n\n ihtdiag = -1.j * time * h1e.diagonal()\n evolved_wfn = work_wfn._evolve_diagonal(ihtdiag,\n inplace=True)\n\n _, _, _, final_wfn = evolved_wfn.transform(\n ci_trans.T.conj(), low, upp)\n\n elif hamil.diagonal_coulomb():\n\n diag, vij = hamil.iht(time)\n\n final_wfn = work_wfn._evolve_diagonal_coulomb_inplace(diag, vij)\n\n else:\n\n final_wfn = work_wfn.apply_generated_unitary(\n time, 'taylor', hamil)\n\n if self._conserve_spin and not self._conserve_number:\n final_wfn = final_wfn._copy_beta_restore(\n self._conserved['s_z'], self._norb, self._symmetry_map)\n\n if numpy.abs(hamil.e_0()) > 1.0e-15:\n final_wfn.scale(numpy.exp(-1.j * time * hamil.e_0()))\n\n return final_wfn\n\n def _evolve_diagonal(self, ithdiag: numpy.ndarray,\n inplace: bool = False) -> 'Wavefunction':\n \"\"\"Evolve a diagonal Hamiltonian on the wavefunction\n\n Args:\n ithdiag (numpy.ndarray): preprocessed diagonal array\n\n inplace (bool): whether the result will be stored in-place\n\n Returns:\n (Wavefunction): resulting wave function. If in-place is True,\n self is returned.\n \"\"\"\n if inplace:\n wfn = self\n else:\n wfn = copy.deepcopy(self)\n\n for key, sector in self._civec.items():\n wfn._civec[key].coeff = sector.evolve_diagonal(ithdiag, inplace)\n\n return wfn\n\n def _evolve_diagonal_coulomb_inplace(self, diag: numpy.ndarray,\n vij: numpy.ndarray) -> 'Wavefunction':\n \"\"\"Evolve a diagonal coulomb Hamiltonian on the wavefunction and store the\n result inplace. (Not in-place version is no longer used and thus has been\n removed).\n\n Args:\n diag (numpy.ndarray): 1-body part of the Hamiltonian\n\n vij (numpy.ndarray): 2-body part of the Hamiltonian\n\n Returns:\n (Wavefunction): wavefunction after 1 time step of the time evolution.\n since this function is in-place, what is returned is always self.\n \"\"\"\n\n for key, sector in self._civec.items():\n self._civec[key].coeff = sector.evolve_diagonal_coulomb(\n diag, vij, inplace=True)\n return self\n\n def expectationValue(\n self,\n ops: Union['fqe_operator.FqeOperator', 'hamiltonian.Hamiltonian'],\n brawfn: 'Wavefunction' = None) -> Union[complex, numpy.ndarray]:\n \"\"\"Calculates expectation values given operators\n\n Args:\n ops (FqeOperator or Hamiltonian): operator for which the expectation value is \\\n computed\n\n brawfn (Wavefunction): bra-side wave function for transition quantity (optional)\n\n Returns:\n (complex or numpy.ndarray): resulting expectation value or RDM\n \"\"\"\n if isinstance(ops, fqe_operator.FqeOperator):\n if brawfn:\n return ops.contract(brawfn, self)\n return ops.contract(self, self)\n\n if isinstance(ops, str):\n if any(char.isdigit() for char in ops):\n ops = sparse_hamiltonian.SparseHamiltonian(ops)\n else:\n return self.rdm(ops, brawfn=brawfn)\n\n if not isinstance(ops, hamiltonian.Hamiltonian):\n raise TypeError('Expected an Fqe Hamiltonian or Operator' \\\n ' but recieved {}'.format(type(ops)))\n workwfn = self.apply(ops)\n\n if brawfn:\n return vdot(brawfn, workwfn)\n return vdot(self, workwfn)\n\n def _apply_individual_nbody(self,\n hamil: 'sparse_hamiltonian.SparseHamiltonian',\n base: 'Wavefunction' = None) -> 'Wavefunction':\n \"\"\"\n Applies an individual n-body operator to the wave function self.\n\n Args:\n hamil (SparseHamiltonian): Sparse Hamiltonian to be applied to the wavefunction\n`\n base (Wavefunction): the result will be accumulated to base\n\n Returns:\n (Wavefunction): resulting wavefunciton. When base is provided, base is returned\n \"\"\"\n assert isinstance(hamil, sparse_hamiltonian.SparseHamiltonian)\n\n if hamil.nterms() > 1:\n raise ValueError(\n 'Indivisual n-body code is called with multiple terms')\n\n [(coeff, alpha, beta)] = hamil.terms()\n daga = []\n dagb = []\n undaga = []\n undagb = []\n for oper in alpha:\n assert oper[0] < self._norb\n if oper[1] == 1:\n daga.append(oper[0])\n else:\n undaga.append(oper[0])\n for oper in beta:\n assert oper[0] < self._norb\n if oper[1] == 1:\n dagb.append(oper[0])\n else:\n undagb.append(oper[0])\n\n if len(daga) + len(dagb) != len(undaga) + len(undagb):\n raise ValueError('Number non-conserving operators specified')\n\n if base is None:\n out = self.empty_copy()\n else:\n out = base\n if len(daga) == len(undaga) and len(dagb) == len(undagb):\n for key in self._civec.keys():\n out._civec[key].apply_individual_nbody_accumulate(\n coeff, self._civec[key], daga, undaga, dagb, undagb)\n else:\n ssectors = self._number_sectors()\n nsectors = out._number_sectors()\n for skey, nsector in nsectors.items():\n nsector.apply_individual_nbody_accumulate(\n coeff, ssectors[skey], daga, undaga, dagb, undagb)\n return out\n\n def _evolve_individual_nbody(self,\n time: float,\n hamil: 'sparse_hamiltonian.SparseHamiltonian',\n inplace: bool = False) -> 'Wavefunction':\n \"\"\"Apply up to 4-body individual operator.\n\n This routine assumes the Hamiltonian is normal ordered.\n\n Args:\n time (float): time for evolution\n\n hamil (SparseHamiltonian): Sparse Hamiltonian using which \\\n the wavefunction is evolved\n\n inplace (bool): whether to store the results in-place\n\n Returns:\n (Wavefunction): resulting wavefunciton. If inplace is True, \\\n self is returned.\n \"\"\"\n if not isinstance(hamil, sparse_hamiltonian.SparseHamiltonian):\n raise TypeError('Expected a Hamiltonian Object but received' \\\n ' {}'.format(hamil))\n\n if hamil.nterms() > 2:\n raise ValueError(\n 'Individual n-body code is called with multiple terms')\n\n # check if everything is paired\n if hamil.nterms() == 2:\n [(coeff0, alpha0, beta0), (coeff1, alpha1, beta1)] = hamil.terms()\n check = True\n for aop in alpha0:\n check &= (aop[0], aop[1] ^ 1) in alpha1\n for bop in beta0:\n check &= (bop[0], bop[1] ^ 1) in beta1\n\n if self._conserve_number:\n if not check:\n raise ValueError(\n 'Operators in _evolve_individual_nbody is not Hermitian'\n )\n else:\n [\n (coeff0, alpha0, beta0),\n ] = hamil.terms()\n check = True\n for aop in alpha0:\n check &= (aop[0], aop[1] ^ 1) in alpha0\n for bop in beta0:\n check &= (bop[0], bop[1] ^ 1) in beta0\n\n if self._conserve_number:\n if not check:\n raise ValueError(\n 'Operators in _evolve_individual_nbody is not Hermitian'\n )\n coeff0 *= 0.5\n\n daga = []\n dagb = []\n undaga = []\n undagb = []\n\n for oper in alpha0:\n assert oper[0] < self._norb\n if oper[1] == 1:\n daga.append(oper[0])\n else:\n undaga.append(oper[0])\n\n for oper in beta0:\n assert oper[0] < self._norb\n if oper[1] == 1:\n dagb.append(oper[0])\n else:\n undagb.append(oper[0])\n\n if hamil.nterms() == 2:\n parity = (-1)**(len(alpha0) * len(beta0) + len(daga) * (len(daga)-1)//2 \\\n + len(dagb) * (len(dagb) - 1) // 2 \\\n + len(undaga) * (len(undaga) - 1) // 2 \\\n + len(undagb) * (len(undagb) - 1) // 2)\n if not numpy.abs(coeff0 - numpy.conj(coeff1) * parity) < 1.0e-8:\n raise ValueError(\n 'Coefficients in _evolve_individual_nbody is not Hermitian')\n\n\n if daga == undaga and dagb == undagb:\n out = self if inplace else copy.deepcopy(self)\n for _, sector in out._civec.items():\n sector.evolve_inplace_individual_nbody_trivial(\n time, coeff0, daga, dagb)\n else:\n out = Wavefunction()\n out._norb = self._norb\n out._conserved = self._conserved\n out._symmetry_map = self._symmetry_map\n if len(daga) == len(undaga) and len(dagb) == len(undagb):\n for label, isec in self._civec.items():\n osec = isec.evolve_individual_nbody_nontrivial(time, coeff0, daga, \\\n undaga, dagb, undagb)\n out._civec[label] = osec\n else:\n nsectors = self._number_sectors()\n for _, nsector in nsectors.items():\n osector = nsector.evolve_individual_nbody(time, coeff0, daga, \\\n undaga, dagb, undagb)\n for (nalpha, nbeta), osec in osector.sectors().items():\n out._civec[(nalpha + nbeta, nalpha - nbeta)] = osec\n return out\n\n def _apply_few_nbody(self, hamil: 'sparse_hamiltonian.SparseHamiltonian'\n ) -> 'Wavefunction':\n \"\"\" Applies SparseHamiltonian by looping over all of the operators.\n Useful when the operator is extremely sparse\n\n Args:\n hamil (SparseHamiltonian): Sparse Hamiltonian to be applied to the wavefunction\n\n Returns:\n (Wavefunction): resulting wavefunciton\n \"\"\"\n out = None\n for oper in hamil.terms_hamiltonian():\n if out is None:\n out = self._apply_individual_nbody(oper)\n else:\n out = self._apply_individual_nbody(oper, base=out)\n\n if out is None:\n out = copy.deepcopy(self)\n\n if numpy.abs(hamil.e_0()) > 1.e-15:\n out.ax_plus_y(hamil.e_0(), self)\n\n return out\n\n @wrap_rdm\n def rdm(self, string: str, brawfn: Optional['Wavefunction'] = None\n ) -> Union[complex, numpy.ndarray]:\n \"\"\" Returns rank-1 RDM. The operator order is specified by string.\n Note that, if the entire RDM is requested for N-broken wave function,\n this returns a packed format.\n\n Args:\n string (str): character strings that specify the quantity to be computed\n\n brawfn (Wavefunction): bra-side wave function for transition RDM (optional)\n\n Returns:\n Union[complex, numpy.ndarray]: Resulting RDM in numpy.ndarray or \\\n an RDM element in complex\n \"\"\"\n rank = len(string.split()) // 2\n if any(char.isdigit() for char in string):\n result = self.apply(sparse_hamiltonian.SparseHamiltonian(string))\n if brawfn is None:\n return vdot(self, result)\n return vdot(brawfn, result)\n\n fqe_ops_utils.validate_rdm_string(string)\n rdm = list(self._compute_rdm(rank, brawfn))\n return wick(string, rdm, self._conserve_spin)\n\n def _compute_rdm(self, rank: int, brawfn: 'Wavefunction' = None\n ) -> Tuple[numpy.ndarray, ...]:\n \"\"\"Internal function that computes RDM up to rank = rank\n\n Args:\n rank (int): the rank up to which RDMs are computed\n\n brawfn (Wavefunction): bra wavefunction for transition RDMs (optional)\n\n Returns:\n Tuple[numpy.ndarray, ...]: tuple of RDMs\n \"\"\"\n assert rank > 0\n assert rank < 5\n\n out: List[Any] = [None, None, None, None]\n tmp: List[Any] = [None, None, None, None]\n\n if self._conserve_spin:\n for key, sector in self._civec.items():\n assert brawfn is None or key in brawfn.sectors()\n bra = None if brawfn is None else brawfn._civec[key]\n if rank == 1:\n (tmp[0],) = sector.rdm1(bra)\n elif rank == 2:\n (tmp[0], tmp[1]) = sector.rdm12(bra)\n elif rank == 3:\n (tmp[0], tmp[1], tmp[2]) = sector.rdm123(bra)\n elif rank == 4:\n (tmp[0], tmp[1], tmp[2], tmp[3]) = sector.rdm1234(bra)\n for i in range(4):\n if tmp[i] is not None:\n out[i] = tmp[i] if out[i] is None else out[i] + tmp[i]\n out2: List[numpy.ndarray] = []\n for i in range(4):\n if out[i] is not None:\n out2.append(out[i])\n return tuple(out2)\n\n numbersectors = self._number_sectors()\n for nkey, dataset in numbersectors.items():\n assert brawfn is None or nkey in brawfn._number_sectors().keys()\n nbra = None if brawfn is None else brawfn._number_sectors()[nkey]\n if rank == 1:\n (tmp[0],) = dataset.rdm1(nbra)\n elif rank == 2:\n (tmp[0], tmp[1]) = dataset.rdm12(nbra)\n elif rank == 3:\n (tmp[0], tmp[1], tmp[2]) = dataset.rdm123(nbra)\n elif rank == 4:\n (tmp[0], tmp[1], tmp[2], tmp[3]) = dataset.rdm1234(nbra)\n for i in range(4):\n if tmp[i] is not None:\n out[i] = tmp[i] if out[i] is None else out[i] + tmp[i]\n out2 = []\n for i in range(4):\n if out[i] is not None:\n out2.append(out[i])\n return tuple(out2)\n", "meta": {"hexsha": "c4934823c184163bfdd9838fa5a370d484d3d9b8", "size": 53149, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/fqe/wavefunction.py", "max_stars_repo_name": "MichaelBroughton/OpenFermion-FQE", "max_stars_repo_head_hexsha": "b0c041d3284d9ce6523295b2a4cf17a8e6b37190", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/fqe/wavefunction.py", "max_issues_repo_name": "MichaelBroughton/OpenFermion-FQE", "max_issues_repo_head_hexsha": "b0c041d3284d9ce6523295b2a4cf17a8e6b37190", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/fqe/wavefunction.py", "max_forks_repo_name": "MichaelBroughton/OpenFermion-FQE", "max_forks_repo_head_hexsha": "b0c041d3284d9ce6523295b2a4cf17a8e6b37190", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.7746979389, "max_line_length": 92, "alphanum_fraction": 0.5465389753, "include": true, "reason": "import numpy,from scipy", "num_tokens": 12156, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073655352404, "lm_q2_score": 0.3629691986286475, "lm_q1q2_score": 0.19985351422735698}} {"text": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n#\n# Ed Mountjoy (March 2018)\n#\n\"\"\"\nWrapper for Verena Zuber's colocalisation method\n\nAssumptions:\n - GWAS and cov matrix are referring to the same strand\n\"\"\"\n\nimport sys\nimport argparse\nimport pandas as pd\nimport numpy as np\nimport Finemap\nimport pickle\n\ndef main():\n\n # Get args\n args = parse_args()\n chrom, start, end = parse_range(args.range)\n\n #\n # Load and run 1-D finemapping on left dataset -----------------------------\n #\n\n # Load left sumstats\n print(\"Loading left sumstats...\")\n left_z, left_efal, left_n = parse_sumstats(args.left_sumstats, chrom, start,\n end, args.left_rsidcol, args.left_chromcol, args.left_poscol,\n args.left_betacol, args.left_secol, args.left_effalcol, args.left_ncol,\n args.sep)\n print(\" {0} variants loaded...\".format(left_z.shape[0]))\n\n # Load left cov matrix\n print(\"Loading left cov matrix...\")\n left_cov, left_cov_efal = parse_cov_matrix(args.left_cov, args.left_covmeta)\n print(\" {0} variants loaded...\".format(left_cov.shape[0]))\n\n # Harmonise left z-scores and cov matrix\n print(\"Harmonising left sumstat and cov matrix...\")\n left_z, left_cov = harmonise_z_covmat(left_z, left_cov, left_efal,\n left_cov_efal)\n print(\" {0} overlapping variants...\".format(left_z.shape[0]))\n\n # Run finemap on left\n print(\"Running finemap on left...\")\n left_res = Finemap.finemap(left_z.as_matrix(),\n left_cov.as_matrix(),\n left_n,\n left_z.index.tolist(),\n kmax=args.left_kmax,\n kstart=args.left_kstart,\n max_iter=args.maxiter,\n prior=args.prior,\n v_scale=args.v_scale,\n g=args.g)\n # Write output as a pickled object and pandas df\n save_object(left_res, \"{0}.left_configurations.pkl\".format(args.outprefix))\n left_res_df = finemap_obj_to_df(left_res)\n left_res_df.to_csv(\"{0}.left_configurations.tsv\".format(args.outprefix),\n sep=\"\\t\", index=None)\n\n #\n # Load and run 1-D finemapping on 2nd (right) dataset ----------------------\n #\n\n # Skip if no 2nd dataset is provided\n if args.right_sumstats is None:\n print(\"No right dataset provided (--right_sumstats). Finishing here!\")\n return 0\n\n # Load right sumstats\n print(\"Loading right sumstats...\")\n right_z, right_efal, right_n = parse_sumstats(args.right_sumstats, chrom,\n start, end, args.right_rsidcol, args.right_chromcol, args.right_poscol,\n args.right_betacol, args.right_secol, args.right_effalcol,\n args.right_ncol, args.sep)\n print(\" {0} variants loaded...\".format(right_z.shape[0]))\n\n # Load right cov matrix\n print(\"Loading right cov matrix...\")\n right_cov, right_cov_efal = parse_cov_matrix(args.right_cov,\n args.right_covmeta)\n print(\" {0} variants loaded...\".format(right_cov.shape[0]))\n\n # Harmonise right z-scores and cov matrix\n print(\"Harmonising right sumstat and cov matrix...\")\n right_z, right_cov = harmonise_z_covmat(right_z, right_cov, right_efal,\n right_cov_efal)\n print(\" {0} overlapping variants...\".format(right_z.shape[0]))\n\n # Run finemap on right\n print(\"Running finemap on right...\")\n right_res = Finemap.finemap(right_z.as_matrix(),\n right_cov.as_matrix(),\n right_n,\n right_z.index.tolist(),\n kmax=args.right_kmax,\n kstart=args.right_kstart,\n max_iter=args.maxiter,\n prior=args.prior,\n v_scale=args.v_scale,\n g=args.g)\n # Write output as a pickled object and pandas df\n save_object(right_res, \"{0}.right_configurations.pkl\".format(args.outprefix))\n right_res_df = finemap_obj_to_df(right_res)\n right_res_df.to_csv(\"{0}.right_configurations.tsv\".format(args.outprefix),\n sep=\"\\t\", index=None)\n\n #\n # Caluclate 2D joint posteriors (colocalisation)\n #\n\n print(\"Running colocalisation between left and right...\")\n\n coloc_evidence, joint_res = left_res.joint_posterior(right_res)\n\n # Write table of joint posterior configurations\n joint_res_df = joint_posterior_to_df(joint_res)\n joint_res_df.to_csv(\"{0}.joint_configurations.tsv\".format(args.outprefix),\n sep=\"\\t\", index=None)\n save_object(joint_res, \"{0}.joint_configurations.pkl\".format(args.outprefix))\n # Write file containing single colocalisation evidence score\n outf = \"{0}.joint_evidence.tsv\".format(args.outprefix)\n with open(outf, \"wb\") as out_h:\n out_h.write(\"{0}\\n\".format(coloc_evidence).encode(\"utf8\"))\n\n print(\"Finished!\")\n\n return 0\n\ndef joint_posterior_to_df(obj):\n \"\"\" Converts POSTGAP joint posterior (colocalisation) in a pandas df\n Args:\n obj (TwoDConfigurationSample)\n Returns:\n Dataframe\n \"\"\"\n # Add each configuration as a row\n rows = []\n for configuration in obj.configurations:\n snp_labels = \";\".join([obj.labels[position] for position in configuration])\n index = obj.configurations[configuration]\n posterior = obj.posterior[index]\n posterior1 = obj.posterior1[index]\n posterior2 = obj.posterior2[index]\n rows.append([snp_labels, posterior1, posterior2, posterior])\n df = pd.DataFrame(rows, columns=[\"snps\", \"left_posterior\", \"right_posterior\", \"joint_posterior\"])\n df = df.sort_values(\"joint_posterior\", ascending=False)\n return df\n\ndef finemap_obj_to_df(obj):\n \"\"\" Converts POSTGAP finemap object to a pandas df\n Args:\n obj (OneDConfigurationSample)\n Returns:\n Dataframe\n \"\"\"\n # Add each configuration as a row\n rows = []\n for configuration in obj.configurations:\n index_of_configuration = obj.configurations[configuration]\n posterior = obj.posterior[index_of_configuration]\n prior = np.exp(obj.log_prior[index_of_configuration])\n logBF = obj.log_BF[index_of_configuration]\n snps = ';'.join([obj.labels[position] for position in configuration])\n rows.append([snps, prior, logBF, posterior])\n df = pd.DataFrame(rows, columns=[\"snps\", \"prior\", \"logBF\", \"posterior\"])\n df = df.sort_values(\"posterior\", ascending=False)\n\n return df\n\ndef save_object(obj, filename):\n \"\"\" Write object as a pickle\n Args:\n obj: any object\n filename: output file\n \"\"\"\n with open(filename, 'wb') as output:\n pickle.dump(obj, output, pickle.HIGHEST_PROTOCOL)\n return 0\n\ndef harmonise_z_covmat(z, cov, z_efal, cov_efal):\n \"\"\" Harmonise z-scores and covariance matrix. This includes:\n 1. Take intersection of rsids between the two\n 2. sort into the same orders\n 3. if effect alleles are not the same, flip in the cov matrix\n Args:\n z (Series)\n cov (Dataframe)\n z_efal (Series)\n cov_efal (Series)\n Returns:\n z (Series), cov (Dataframe)\n \"\"\"\n intersect = z.index[z.index.isin(cov.index)]\n z = z.loc[intersect]\n cov = cov.loc[intersect, intersect]\n\n # Make harmonisation vector to flip cov if effect alleles don't match\n vec = [1 if z_efal[snp] == cov_efal[snp] else -1 for snp in intersect]\n vec = pd.Series(vec, index=intersect)\n\n # Multiply the cov matrix by the harmonisation vector across both axes\n cov = cov.multiply(vec, axis=0)\n cov = cov.multiply(vec, axis=1)\n\n return z, cov\n\ndef parse_cov_matrix(in_cov, in_meta):\n \"\"\" Parses ldstore cov matrix and associated meta data file\n Args:\n in_cov (str): file containing matrix of correlations\n in_meta (str): file containing variant meta-data\n Returns:\n cov matrix (dataframe), effect alleles (dict)\n \"\"\"\n cov = pd.read_csv(in_cov, sep=\" \", header=None)\n meta = pd.read_csv(in_meta, sep=\" \", header=0)\n cov.index = meta.RSID\n meta.index = meta.RSID\n cov.columns = meta.RSID\n\n # Remove duplicates\n isdupe = meta.index.duplicated()\n cov = cov.loc[~isdupe, ~isdupe]\n meta = meta[~isdupe]\n\n return cov, meta[\"A_allele\"].to_dict()\n\ndef parse_sumstats(inf, chrom, start, end, rsid_col, chrom_col, pos_col,\n beta_col, se_col, effal_col, n_col, sep):\n \"\"\" Parse a summary stat file and return zscores\n Args:\n inf (str): input summary stat file\n chrom (str): chrom to extract\n start (int): position to extract from\n end (int): position to extract to\n ...column names\n Returns:\n zscores (Series), effect alleles (dict), n (int)\n \"\"\"\n # Load iteratively\n iter_csv = pd.read_csv(inf, sep=sep, header=0, iterator=True,\n chunksize=100000)\n iter_chunks = []\n for chunk in iter_csv:\n chunk[chrom_col] = chunk[chrom_col].astype(str)\n iter_chunks.append(chunk[((chunk[chrom_col] == chrom) &\n (chunk[pos_col] >= start) &\n (chunk[pos_col] <= end))])\n df = pd.concat(iter_chunks)\n # df.to_csv(\"temp/test_sumstat_slice.tsv\", index=None, sep=\"\\t\") # DEBUG\n\n # Only keep rows with a valid rsid\n df = df[df[rsid_col].str.startswith(\"rs\")]\n df.index = df[rsid_col]\n\n # Remove duplicates\n df = df.loc[~df.index.duplicated(), :]\n\n # Calculate z-scores\n zscores = df[beta_col] / df[se_col]\n\n # Get mean N\n n_mean = int(np.mean(df[n_col]))\n\n return zscores, df[effal_col].to_dict(), n_mean\n\ndef parse_range(range_str):\n \"\"\" Parse the chrom, start and end from the range string\n Args:\n range_str (str): In format chrom:start-end\n Returns:\n chrom (str), start (int), end (int)\n \"\"\"\n chrom, start_end = range_str.split(\":\")\n start, end = start_end.split(\"-\")\n return str(chrom), int(start), int(end)\n\ndef parse_args():\n \"\"\" Load command line args.\n \"\"\"\n parser = argparse.ArgumentParser()\n # Input args\n parser.add_argument('--left_sumstats', metavar=\"\", help=('Summary statistics file'), type=str, required=True)\n parser.add_argument('--left_cov', metavar=\"\", help=(\"Covariance matrix - correlation structure between variants\"), type=str, required=True)\n parser.add_argument('--left_covmeta', metavar=\"\", help=(\"Covariance matrix SNP info (from LDstore)\"), type=str, required=True)\n parser.add_argument('--range', metavar=\"\", help=(\"Genomic range in format chrom:start-end\"), type=str, required=True)\n parser.add_argument('--right_sumstats', metavar=\"\", help=('(Optional) Summary statistics file'), type=str, required=False)\n parser.add_argument('--right_cov', metavar=\"\", help=(\"Covariance matrix - leave blank if same as left_cov\"), type=str, required=False)\n parser.add_argument('--right_covmeta', metavar=\"\", help=(\"Covariance matrix SNP info (from LDstore)\"), type=str, required=False)\n # Output args\n parser.add_argument('--outprefix', metavar=\"\", help=(\"Output prefix\"), type=str, required=True)\n # Finemapping args\n parser.add_argument('--left_kmax', metavar=\"\", help=('Maximum number of causal variants (default: 5)'), default=5, type=int)\n parser.add_argument('--left_kstart', metavar=\"\", help=('Full exploration of sets with #kstart causal variants (default: 1)'), default=1, type=int)\n parser.add_argument('--right_kmax', metavar=\"\", help=('Maximum number of causal variants (default: left_kmax)'), type=int)\n parser.add_argument('--right_kstart', metavar=\"\", help=('Full exploration of sets with #kstart causal variants (default: left_kstart)'), type=int)\n parser.add_argument('--v_scale', metavar=\"\", help=('Prior variance of the independence prior (default: 0.0025)'), default=0.0025, type=float)\n parser.add_argument('--maxiter', metavar=\"\", help=('Max iterations of stochastic search (default: 100000)'), default=100000, type=int)\n parser.add_argument('--prior', metavar=\"\", help=('Choice of \"independence\" or \"gprior\" (default: independence)'), default=\"independence\", type=str, choices=[\"independence\", \"gprior\"])\n parser.add_argument('--g', metavar=\"\", help=('g-parameter of the g-prior (default: BRIC). see Mixtures of g Priors for Bayesian Variable Selection Liang et al 2008'), default=\"BRIC\", type=str, choices=[\"BRIC\", \"BIC\", \"RIC\"])\n # File parsing args\n parser.add_argument('--sep', metavar=\"\", help=('Column sep (default: tab)'), type=str, default=\"\\t\")\n parser.add_argument('--left_rsidcol', metavar=\"\", help=('RSID column (default: rsid)'), default=\"rsid\", type=str)\n parser.add_argument('--left_chromcol', metavar=\"\", help=('Chromosome column (default: chrom)'), default=\"chrom\", type=str)\n parser.add_argument('--left_poscol', metavar=\"\", help=('Position column (default: pos)'), default=\"pos\", type=str)\n parser.add_argument('--left_betacol', metavar=\"\", help=('Beta column (default: beta)'), default=\"beta\", type=str)\n parser.add_argument('--left_secol', metavar=\"\", help=('Standard error column (default: se)'), default=\"se\", type=str)\n parser.add_argument('--left_effalcol', metavar=\"\", help=('Effect allele column (default: effect_allele)'), default=\"effect_allele\", type=str)\n parser.add_argument('--left_ncol', metavar=\"\", help=('Sample size column (default: n)'), default=\"n\", type=str)\n parser.add_argument('--right_rsidcol', metavar=\"\", help=('RSID column (default: left_rsidcol)'), type=str)\n parser.add_argument('--right_chromcol', metavar=\"\", help=('Chromosome column (default: left_chromcol)'), type=str)\n parser.add_argument('--right_poscol', metavar=\"\", help=('Position column (default: left_poscol)'), type=str)\n parser.add_argument('--right_betacol', metavar=\"\", help=('Beta column (default: left_betacol)'), type=str)\n parser.add_argument('--right_secol', metavar=\"\", help=('Standard error column (default: left_secol)'), type=str)\n parser.add_argument('--right_effalcol', metavar=\"\", help=('Effect allele columns (default: left_effalcol)'), type=str)\n parser.add_argument('--right_ncol', metavar=\"\", help=('Sample size column (default: n)'), default=\"n\", type=str)\n\n args = parser.parse_args()\n\n # If right argument is not set, set to same as left argument\n for rarg in [\"right_cov\", \"right_covmeta\", \"right_kmax\", \"right_kstart\",\n \"right_rsidcol\", \"right_chromcol\", \"right_poscol\",\n \"right_betacol\", \"right_secol\", \"right_effalcol\",\n \"right_ncol\"]:\n if getattr(args, rarg) is None:\n larg_val = getattr(args, rarg.replace(\"right_\", \"left_\"))\n setattr(args, rarg, larg_val)\n\n return args\n\nif __name__ == '__main__':\n\n main()\n", "meta": {"hexsha": "ecb9f4d36f3e34f3b2330264640f200b63ce2584", "size": 15187, "ext": "py", "lang": "Python", "max_stars_repo_path": "scripts/vloc.py", "max_stars_repo_name": "edm1/verena_coloc_wrapper", "max_stars_repo_head_hexsha": "060dc05d3ad1231061b8fbaf27fae092fa9f0b69", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "scripts/vloc.py", "max_issues_repo_name": "edm1/verena_coloc_wrapper", "max_issues_repo_head_hexsha": "060dc05d3ad1231061b8fbaf27fae092fa9f0b69", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "scripts/vloc.py", "max_forks_repo_name": "edm1/verena_coloc_wrapper", "max_forks_repo_head_hexsha": "060dc05d3ad1231061b8fbaf27fae092fa9f0b69", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.5366568915, "max_line_length": 233, "alphanum_fraction": 0.6374530849, "include": true, "reason": "import numpy", "num_tokens": 3637, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073655352404, "lm_q2_score": 0.36296919173767833, "lm_q1q2_score": 0.1998535104331386}} {"text": "\nimport numpy as np\n\ndef provide_PSF_2D(x=None,y=None,PSF_version=None):\n \"\"\" Provides 2D PSF at any position in the detector plane\n This a version which takes a finite nubmer of pregenerated PSF and \\\n creates the interpolated version at required position\n (Future: version which takes interpolated values for Zernike \\\n coefficients and generates image on the fly?)\n \n To be used with the focused data taken on July 25 and 26\n (e.g., 21400 for HgAr, 21604 for Ne, 21808 for Kr)\n \n Example usage: ``provide_PSF_2D(10,2010)'' 10 is x-coordinate,\n and 2010 is y-coordinate \n\n @param[in] x x-coordinate\n @param[in] y y-coordinate\n @param[in] PSF_version version of the PSF input files\n @returns numpy array, 100x100, oversampled 5 times, \n corresponding to 20x20 physical pixels\n (300x300 microns)\n \"\"\" \n \n # on tiger the directory contaning array of PSFs is at:\n DATA_DIRECTORY='/tigress/ncaplar/PIPE2D-450/'\n \n if PSF_version is None:\n PSF_version='Sep12_v1'\n\n positions_of_simulation=np.load(DATA_DIRECTORY+\\\n 'positions_of_simulation_00_from_'+PSF_version+'.npy')\n array_of_simulation=np.load(DATA_DIRECTORY+\\\n 'array_of_simulation_00_from_'+PSF_version+'.npy')\n \n # x and y position with simulated PSFs\n x_positions_of_simulation=positions_of_simulation[:,1]\n y_positions_of_simulation=positions_of_simulation[:,2]\n \n # This is a simple code that finds the closest avaliable PSFs, given the x and y position\n # This will have to be improved in order when we get to work with the full populated dectector plane\n \n \n # how far in x-dimension are you willing to search for suitable simulated PSFs\n x_search_distance=20\n # positions of all simulated PSFs in that range\n positions_of_simulation_in_acceptable_x_range=\\\n positions_of_simulation[(x_positions_of_simulation<(x+x_search_distance))\\\n &(x_positions_of_simulation>(x-x_search_distance))]\n \n # if there are no simulated PSF avaliable in the specified x-range we are not able to provide the solution\n if len(positions_of_simulation_in_acceptable_x_range)<2:\n print('No simulated PSFs are avaliable in this x-area of the detector,')\n print('probably because this fiber has not been illuminated;')\n print('returning the closest avaliable PSFs, BUT that is probably not what you want')\n distances=np.sqrt(((x-x_positions_of_simulation)**2+\\\n (y-y_positions_of_simulation)**2).astype(float))\n index_of_closest_distance=np.where(distances[distances==\\\n np.min(distances)])[0][0]\n return array_of_simulation[index_of_closest_distance]\n \n # y-distance from the requested positions for all of the suitable simulated PSFs\n distances_of_y_requested_position_from_avaliable=\\\n y-positions_of_simulation_in_acceptable_x_range[:,2]\n # out of the suitable PSFs which 2 are the closest\n index_of_1st_closest_simulated_psf=\\\n np.where(np.abs(distances_of_y_requested_position_from_avaliable)==\\\n np.sort(np.abs(distances_of_y_requested_position_from_avaliable))[0])[0][0]\n index_of_2nd_closest_simulated_psf=\\\n np.where(np.abs(distances_of_y_requested_position_from_avaliable)==\\\n np.sort(np.abs(distances_of_y_requested_position_from_avaliable))[1])[0][0]\n # where are these 2 closest PSF in the initial table\n index_of_1st_closest_simulated_psf_in_positions_of_simulation=\\\n np.where(np.sum(positions_of_simulation,axis=1)==\\\n np.sum(positions_of_simulation_in_acceptable_x_range[index_of_1st_closest_simulated_psf]))[0][0]\n index_of_2nd_closest_simulated_psf_in_positions_of_simulation=\\\n np.where(np.sum(positions_of_simulation,axis=1)==\\\n np.sum(positions_of_simulation_in_acceptable_x_range[index_of_2nd_closest_simulated_psf]))[0][0]\n # extract the 2 simulated PSFs\n first_array_simulation=\\\n array_of_simulation[index_of_1st_closest_simulated_psf_in_positions_of_simulation]\n second_array_simulation=\\\n array_of_simulation[index_of_2nd_closest_simulated_psf_in_positions_of_simulation]\n # distance of each PSF from the proposed position\n y1_distance=\\\n y-positions_of_simulation[index_of_1st_closest_simulated_psf_in_positions_of_simulation][2]\n y2_distance=\\\n y-positions_of_simulation[index_of_2nd_closest_simulated_psf_in_positions_of_simulation][2]\n \n # if you requested psf at the exact position of existing PSF use that one\n if y1_distance==0:\n return first_array_simulation\n else: \n # create the predicted PSF as a linear interpolation of these two PSFs\n predicted_psf=(second_array_simulation-first_array_simulation*(y2_distance/y1_distance))/(1-y2_distance/y1_distance)\n return predicted_psf\n ", "meta": {"hexsha": "fef2daf4a0ac0128aa8faa54a5ca0dfef20ab933", "size": 5078, "ext": "py", "lang": "Python", "max_stars_repo_path": "2d_PSF_code/PIPE2D-347/Provide_PSF_2D.py", "max_stars_repo_name": "Subaru-PFS/dev_pfsmodel", "max_stars_repo_head_hexsha": "d01cf03a4c4eaa01ba5a9590ccf17744a33bdb05", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "2d_PSF_code/PIPE2D-347/Provide_PSF_2D.py", "max_issues_repo_name": "Subaru-PFS/dev_pfsmodel", "max_issues_repo_head_hexsha": "d01cf03a4c4eaa01ba5a9590ccf17744a33bdb05", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "2d_PSF_code/PIPE2D-347/Provide_PSF_2D.py", "max_forks_repo_name": "Subaru-PFS/dev_pfsmodel", "max_forks_repo_head_hexsha": "d01cf03a4c4eaa01ba5a9590ccf17744a33bdb05", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 52.3505154639, "max_line_length": 124, "alphanum_fraction": 0.7138637259, "include": true, "reason": "import numpy", "num_tokens": 1191, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6224593452091672, "lm_q2_score": 0.320821300824607, "lm_q1q2_score": 0.19969821684043815}} {"text": "\"\"\"\nClass for calculating IRC using Morokuma Algorithm\n\"\"\"\n\nimport sys\nimport os\nimport psi4\nimport json\nimport numpy as np\n\n\n\ndef JSON2XYZ(input_params):\n charge = input_params['molecule']['molecular_charge']\n mult = input_params['molecule']['molecular_multiplicity']\n geom = ''\n geom += '\\n%d %d\\n' %(charge, mult)\n symbols = input_params['molecule']['symbols']\n geometry = input_params['molecule']['geometry']\n for i in range(len(symbols)):\n geom += \"%s \" %symbols[i]\n for j in range(3):\n if(j==2):\n geom += \" %f \\n\" %geometry[(i + 2*i) + j]\n else:\n geom += \" %f \" %geometry[(i + 2*i) + j]\n #print(geom)\n return geom\n \nclass ToolKit():\n # Placeholder for Common Data\n def __init__(self,name):\n self.natoms=0\n self.basis = '3-21G'\n self.method = 'SCF'\n self.level_of_theory = \"%s/%s\" %(self.method,self.basis)\n self.alpha=0.1\n self.basename='.'.join(name.split('.')[:-1])\n self.out=open(\"%s.log\"%(self.basename),'a',1)\n self.delta=0.05\n self.direction=1\n self.energies=[]\n self.energy=0.00\n self.geos=[]\n self.restart=False\n self.geometry=[]\n self.guessfn=''\n self.damp=0.05\n self.algorithm=1\n self.autodamp=False\n self.prevgrad=0.0\n self.hessfn=''\n self.maxdispl=0.01\n self.mode=4\n self.dgrad=0.0\n self.npoints=25\n self.template=[]\n self.keywords={}\n self.tolerance=1.0e-04\n self.orcacmd='UNDEFINED'\n self.ReadInput(name)\n self.ComputeHessian()\n def printPars(self):\n stmp=\" %13s: %s\\n\"\n ftmp=\" %13s: %7.4f\\n\"\n itmp=\" %13s: %7d\\n\"\n self.out.write('')\n self.out.write(itmp%('Algorithm',self.algorithm))\n self.out.write(itmp%('N. Points',self.npoints))\n self.out.write(ftmp%('Grad. Tol.',self.tolerance))\n self.out.write('')\n self.out.write(stmp%('Hessian',self.hessfn))\n self.out.write(itmp%('Mode',self.mode))\n self.out.write(itmp%('Direction',self.direction))\n self.out.write('')\n self.out.write(ftmp%('Alpha',self.alpha))\n self.out.write(ftmp%('Delta',self.delta))\n self.out.write('')\n self.out.write(ftmp%('Damp Factor',self.damp))\n self.out.write(itmp%('Damp Update',self.autodamp))\n self.out.write('')\n self.out.write(ftmp%('Max. Displ.',self.maxdispl))\n self.out.write('')\n self.out.write(stmp%('Guess',self.guessfn))\n self.out.write(\"\\n------------------------------------------------\\n\")\n def ReadInput(self,json_input):\n # Read in input from JSON input file\n json_data=open(json_input).read()\n input_params = json.loads(json_data)\n if input_params['molecule']['geometry']:\n self.geometry = JSON2XYZ(input_params)\n if input_params['model']['basis']:\n self.basis = input_params['model']['basis']\n self.level_of_theory = \"%s/%s\" %(self.method,self.basis)\n #print(\"IN HERE\")\n if input_params['model']['method']:\n self.method = input_params['model']['method']\n self.level_of_theory = \"%s/%s\" %(self.method,self.basis)\n if input_params['molecule']['symbols']: \n self.natoms = len(input_params['molecule']['symbols'])\n if input_params['keywords']:\n self.keywords = input_params['keywords']\n if \"irc\" in input_params:\n if input_params['irc']['hessfile']:\n self.hessfn = input_params['irc']['hessfile']\n if input_params['irc']['guess']:\n self.guessfn = input_params['irc']['guess']\n if input_params['irc']['alpha']:\n self.alpha = input_params['irc']['alpha']\n if input_params['irc']['delta']:\n self.delta = input_params['irc']['delta']\n if input_params['irc']['damp']:\n self.damp = input_params['irc']['damp']\n if input_params['irc']['restart']:\n if(input_params['irc']['restart']==1):\n self.restart = True\n else:\n self.restart = False\n if input_params['irc']['autodamp']:\n if(input_params['irc']['autodamp']==1):\n self.autodamp=True\n else:\n self.autodamp=False\n if input_params['irc']['tol']:\n self.tolerance= input_params['irc']['tol']\n if input_params['irc']['alg']:\n self.algorithm = input_params['irc']['alg']\n if input_params['irc']['dir']:\n self.direction = input_params['irc']['dir']\n if input_params['irc']['mode']:\n self.mode = input_params['irc']['mode']\n if input_params['irc']['maxd']:\n self.maxdispl = input_params['irc']['maxd']\n if input_params['irc']['pts']:\n self.npoints = input_params['irc']['pts']\n else: \n pass\n # def JSON2XYZ(self, input_params):\n # geom = ''\n # geom += '%d ' %input_params['molecule']['molecular_charge']\n # geom += '%d \\n' %input_params['molecule']['molecular_multiplicity'] \n # symbols = input_params['molecule']['symbols']\n # geometry = input_params['molecule']['geometry']\n # for i in range(len(symbols)):\n # geom += \"%s \" %symbols[i]\n # for j in range(3):\n # if(j==2):\n # geom += \" %f \\n\" %geometry[(i + 2*i) + j]\n # else:\n # geom += \" %f \" %geometry[(i + 2*i) + j]\n # self.geom = geom\t\n\n def ComputeHessian(self):\n # Use PSI4 to calculate Hessian matrix\n psi4.core.set_output_file(\"hessian.out\", False)\n psi4.geometry(self.geometry)\n #print(self.keywords)\n psi4.set_options(self.keywords)\n H = psi4.hessian(self.method)\n Hess = np.array(H)\n print(Hess.shape)\n self.displacement = Hess[:,self.mode]\n print(self.displacement.shape)\n self.grad = np.zeros(3*self.natoms) \n\n\n##########################\n# Energies and Gradients #\n##########################\n\ndef doEnergy(geom,pars):\n psi4.geometry(geom)\n E = psi4.energy(pars.level_of_theory)\n return E\n\ndef doGrad(geom,pars):\n psi4.geometry(geom)\n Grad, wfn = psi4.gradient(pars.level_of_theory, return_wfn=True)\n e = wfn.energy()\n G = np.array(Grad)\n print(G.shape)\n pars.grad = G\n return G, e\n\n\n######################################\n# Geometry manipulation and printing #\n######################################\n\ndef geodisplace(geom, displace):\n new_geom = []\n displaced_geom = ''\n symbols = []\n #print(geom)\n lines = geom.split('\\n')\n lines.pop(0)\n del lines[-1]\n charge_mult_line = lines[0].split() #Extract the Charge and Multiplicity from top of string\n charge = int(charge_mult_line[0])\n mult = int(charge_mult_line[1])\n for line in lines[1:]: # Loop Over lines that actually contain atoms\n atom_line = line.split()\n #print(atom_line)\n symbols.append(atom_line[0])\n atom_line.pop(0) # Get rid of atom symbol temporarily\n new_geom.append(list(map(float,atom_line)))\n i=0\n for atom in new_geom:\n atom[0] += displace[i]\n atom[1] += displace[i+1]\n atom[2] += displace[i+2]\n i += 3\n#TODO (12/15/18) Finish this, all we have to do is transform the geometry from a list to a\n#string like the geometry given as an input to this function.\n displaced_geom += \"\\n%d %d\\n\" %(charge, mult)\n for i in range(len(symbols)):\n displaced_geom += \"%s \" %symbols[i]\n for j in range(3):\n if(j==2):\n #displaced_geom += \" %f \\n\" %new_geom[(i + 2*i) + j]\n displaced_geom += \" %f \\n\" %new_geom[i][j]\n else:\n #displaced_geom += \" %f \" %new_geom[(i + 2*i) + j]\n displaced_geom += \" %f \" %new_geom[i][j]\n print(displaced_geom)\n return displaced_geom\n\ndef printTrj(params, n):\n trajectory_file = open(params.basename+'.trj', 'a')\n trajectory_file.write(\"%d\\npyREX IRC point %d E=%14.7f\\n\"%(params.natoms,n,params.energy))\n trajectory_file.write(\"%s\\n\" %params.geometry)\n trajectory_file.close()\n\n###############\n#IRC Functions#\n###############\n\ndef Morokuma(pars,start=False):\n #Does a cycle in the Morokuma algorithm, returns the energy and MaxGrad of the\n # new point\n if (start):\n #apply the appropriate sign to the displacement and convert to angs.\n pars.displacement=float(pars.direction)*pars.displacement\n #for i in range(len(pars.mass)):\n # pars.displacement[(3*i)] /= np.sqrt(pars.mass[i])\n # pars.displacement[(3*i)+1] /= np.sqrt(pars.mass[i])\n # pars.displacement[(3*i)+2] /= np.sqrt(pars.mass[i])\n pars.displacement=pars.alpha*(pars.displacement/np.linalg.norm(pars.displacement))\n #Eo,MGo = doGrad(pars.geometry, pars)\n #tmpvec0=pars.grad\n #displace geometry following the normal mode\n geo1=geodisplace(pars.geometry,pars.displacement)\n E1,MG1=doGrad(geo1,pars)\n #generate vector D, adapting from eq 6 in J. Chem. Phys. 66, 2153\n tmpvec1=pars.grad\n D=-(tmpvec0/np.linalg.norm(tmpvec0))+(tmpvec1/np.linalg.norm(tmpvec1))\n #D=(pars.displacement/np.linalg.norm(pars.displacement))-(tmpvec/np.linalg.norm(tmpvec))\n else:\n #scale down gradients and calculate the displacement\n pars.displacement=(pars.damp*pars.displacement)-((1.0-pars.damp)*pars.grad)\n for i in range(len(pars.mass)):\n pars.displacement[(3*i)] /= np.sqrt(pars.mass[i])\n pars.displacement[(3*i)+1] /= np.sqrt(pars.mass[i])\n pars.displacement[(3*i)+2] /= np.sqrt(pars.mass[i])\n pars.displacement=pars.maxdispl*(pars.displacement/np.linalg.norm(pars.displacement))\n #displace geometry following the gradient\n geo1=geodisplace(pars.geometry,pars.displacement)\n E1,MG1=doGrad(geo1,pars)\n #generate vector D, adapting from eq 6 in J. Chem. Phys. 66, 2153\n tmpvec=pars.grad\n D=(pars.displacement/np.linalg.norm(pars.displacement))-(tmpvec/np.linalg.norm(tmpvec))\n # find the optimum delta that will assure the new point is at the\n # local minimum\n if (pars.algorithm==1):\n geo2=geodisplace(geo1,pars.delta*D)\n E2=doEnergy(geo2,pars)\n if (E2>E1):\n newdelta=0.5*pars.delta\n else:\n newdelta=2.0*pars.delta\n geo3=geodisplace(geo1,newdelta*D)\n E3=doEnergy(geo3,pars)\n Evals=np.array([E1, E2, E3])\n Deltavals=np.array([0.0,pars.delta,newdelta])\n else:\n geo2=geodisplace(geo1,pars.delta*D)\n E2=doEnergy(geo2,pars)\n delta3=0.5*pars.delta\n geo3=geodisplace(geo1,delta3*D)\n E3=doEnergy(geo3,pars)\n delta4=2.0*pars.delta\n geo4=geodisplace(geo1,delta4*D)\n E4=doEnergy(geo4,pars)\n delta5=-0.5*pars.delta\n geo5=geodisplace(geo1,delta5*D)\n E5=doEnergy(geo5,pars)\n Evals=np.array([E1, E2, E3, E4, E5])\n Deltavals=np.array([0.0,pars.delta,delta3, delta4, delta5])\n deltaFit=np.polyfit(Deltavals,Evals,deg=2)\n opdelta=-(deltaFit[1]/(2.0*deltaFit[0]))\n # update the geometry to the new point, update and return energy and gradients\n pars.geos.append(pars.geometry)\n pars.energies.append(pars.energy)\n pars.geometry=geodisplace(geo1,opdelta*D)\n newE, newMaxGrad = doGrad(pars.geometry,pars)\n pars.energy=newE\n #the following line is just for debugging purposes\n #print(Evals, Deltavals,np.linalg.norm(pars.displacement), opdelta)\n return (newE, newMaxGrad)\n\ndef ircdrv(inpname):\n params=ToolKit(inpname)\n params.out.write(\"\"\" IRC wrapper for Orca - version 2.0\n by Filipe Teixeira,\n REQUIMTE\n Faculdade de Ciencias da Universidade do Porto\n\n Using Orca from: %s\n\n Parameters for this run: \\n\"\"\"%(params.orcacmd))\n params.printPars()\n #print(params.geometry)\n keep=True\n n=0\n oldE=0.0\n params.out.write(\" Pt. %20s %9s %10s\\n\"%('Energy','RMS Grad.','Damp'))\n params.out.write(\"------------------------------------------------\\n\")\n while (keep):\n if (params.restart or (n>0)):\n E,MG=Morokuma(params,False)\n else:\n E,MG=Morokuma(params,True)\n n=n+1\n if(params.autodamp and (n>1)):\n params.damp = params.damp * (0.1/np.log(n))\n if (params.damp<1.0e-5):\n params.damp=0.0\n params.autodamp=False\n params.out.write('@ %3d %20.9f %9.5f %10.2e\\n'%(n, E, MG, params.damp))\n if (n>params.npoints):\n keep=False\n printTrj(params,n) #appends newGeo\n params.out.write(\"----------------------------------------------\\n\")\n params.out.write(\"-- IRC CALCULATION ENDED --\\n\")\n params.out.write(\"-- MAXPTS ACHIEVED! --\\n\")\n params.out.write(\"----------------------------------------------\\n\")\n elif (MGoldE):\n keep=False\n #printTrj(params,n) #appends newGeo\n params.out.write(\"----------------------------------------------\\n\")\n params.out.write(\"-- ENERGY INCREASED --\\n\")\n params.out.write(\"-- GEOMETRY MIGHT BE --\\n\")\n params.out.write(\"-- VERY CLOSE TO A MINIMUM --\\n\")\n params.out.write(\"-- --\\n\")\n params.out.write(\"-- IRC CALCULATION TERMINATED! --\\n\")\n params.out.write(\"----------------------------------------------\\n\")\n else:\n printTrj(params,n) #appends newGeo\n oldE=E\n params.out.close()\n\nif __name__=='__main__':\n if(len(sys.argv)!=2):\n print(\"\"\"IRC4Orca - Version 2.0\nAn Implementation of Morokuma's IRC method for the Orca ESS Software.\nby Filipe Teixeira\n\nUsage: %s file.inp\n\nPlease consult https://github.com/teixeirafilipe/irc4orca for more information.\n\n\"\"\"%(sys.argv[0]))\n sys.exit(1)\n ircdrv(sys.argv[1])\n \n", "meta": {"hexsha": "4c548a5461bcdd69651eb0c5fd39c4c5a7a12f9a", "size": 14832, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyrex/irc_class.py", "max_stars_repo_name": "derricottegroup/pyrex", "max_stars_repo_head_hexsha": "edc3b2bd73314b87212d9d4069c0b511f7cfb021", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2019-11-21T14:42:42.000Z", "max_stars_repo_stars_event_max_datetime": "2020-05-23T03:06:50.000Z", "max_issues_repo_path": "pyrex/irc_class.py", "max_issues_repo_name": "derricottegroup/pyrex", "max_issues_repo_head_hexsha": "edc3b2bd73314b87212d9d4069c0b511f7cfb021", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-11-26T11:19:58.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-31T13:11:30.000Z", "max_forks_repo_path": "pyrex/irc_class.py", "max_forks_repo_name": "WDerricotte/pyrex", "max_forks_repo_head_hexsha": "edc3b2bd73314b87212d9d4069c0b511f7cfb021", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-12-04T12:22:21.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-04T12:22:21.000Z", "avg_line_length": 38.725848564, "max_line_length": 96, "alphanum_fraction": 0.5453748652, "include": true, "reason": "import numpy", "num_tokens": 3853, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5039061705290805, "lm_q2_score": 0.3960681662740417, "lm_q1q2_score": 0.19958119293562745}} {"text": "import numbers\nimport logging\nfrom copy import deepcopy\nfrom collections import Counter\n\nimport scipy.stats\nimport kappy\nimport itertools\nimport numpy as np\nimport networkx as nx\nfrom pysb import WILD, export, Observable, ComponentSet, Annotation\nfrom pysb.core import as_complex_pattern, ComponentDuplicateNameError\nfrom pysb.pattern import RulePatternMatcher\nfrom indra.explanation.reporting import stmt_from_rule, agent_from_obs\nfrom indra.statements import *\nfrom indra.assemblers.pysb import assembler as pa\nfrom indra.assemblers.pysb.kappa_util import im_json_to_graph\nfrom indra.statements.agent import default_ns_order\nfrom indra.ontology.bio import bio_ontology\n\nfrom . import ModelChecker, PathResult, NodesContainer\nfrom .model_checker import signed_edges_to_signed_nodes\n\nlogger = logging.getLogger(__name__)\n\ntry:\n import paths_graph as pg\n has_pg = True\nexcept ImportError:\n pg = None\n has_pg = False\n logger.warning('PathsGraph is not available')\n\n\nclass PysbModelChecker(ModelChecker):\n \"\"\"Check a PySB model against a set of INDRA statements.\n\n Parameters\n ----------\n model : pysb.Model\n A PySB model to check.\n statements : Optional[list[indra.statements.Statement]]\n A list of INDRA Statements to check the model against.\n agent_obs: Optional[list[indra.statements.Agent]]\n A list of INDRA Agents in a given state to be observed.\n do_sampling : bool\n Whether to use breadth-first search or weighted sampling to\n generate paths. Default is False (breadth-first search).\n seed : int\n Random seed for sampling (optional, default is None).\n model_stmts : list[indra.statements.Statement]\n A list of INDRA statements used to assemble PySB model.\n nodes_to_agents : dict\n A dictionary mapping nodes of intermediate signed edges graph to INDRA\n agents.\n\n Attributes\n ----------\n graph : nx.Digraph\n A DiGraph with signed nodes to find paths in.\n \"\"\"\n\n def __init__(self, model, statements=None, agent_obs=None,\n do_sampling=False, seed=None, model_stmts=None,\n nodes_to_agents=None):\n super().__init__(model, statements, do_sampling, seed, nodes_to_agents)\n if agent_obs:\n self.agent_obs = agent_obs\n else:\n self.agent_obs = []\n mps_to_agents, rules_to_mps = pa.get_grounded_agents(model)\n self.mps_to_agents = mps_to_agents\n self.rules_to_mps = rules_to_mps\n self.model_agents = self.get_model_agents()\n self.model_stmts = model_stmts if model_stmts else []\n # Influence map\n self._im = None\n # Map from statements to associated observables\n self.stmt_to_obs = {}\n # Map from agents to associated observables\n self.agent_to_obs = {}\n # Map between rules and downstream observables\n self.rule_obs_dict = {}\n # Map from observables to agents\n self.obs_to_agents = {}\n\n def generate_im(self, model):\n \"\"\"Return a graph representing the influence map generated by Kappa\n\n Parameters\n ----------\n model : pysb.Model\n The PySB model whose influence map is to be generated\n\n Returns\n -------\n graph : networkx.MultiDiGraph\n A MultiDiGraph representing the influence map\n \"\"\"\n kappa = kappy.KappaStd()\n model_str = export.export(model, 'kappa')\n kappa.add_model_string(model_str)\n kappa.project_parse()\n imap = kappa.analyses_influence_map(accuracy='medium')\n graph = im_json_to_graph(imap)\n return graph\n\n def draw_im(self, fname):\n \"\"\"Draw and save the influence map in a file.\n\n Parameters\n ----------\n fname : str\n The name of the file to save the influence map in.\n The extension of the file will determine the file format,\n typically png or pdf.\n \"\"\"\n im = self.get_im()\n im_agraph = nx.nx_agraph.to_agraph(im)\n im_agraph.draw(fname, prog='dot')\n\n def get_im(self, force_update=False):\n \"\"\"Get the influence map for the model, generating it if necessary.\n\n Parameters\n ----------\n force_update : bool\n Whether to generate the influence map when the function is called.\n If False, returns the previously generated influence map if\n available. Defaults to True.\n\n Returns\n -------\n networkx MultiDiGraph object containing the influence map.\n The influence map can be rendered as a pdf using the dot layout\n program as follows::\n\n im_agraph = nx.nx_agraph.to_agraph(influence_map)\n im_agraph.draw('influence_map.pdf', prog='dot')\n \"\"\"\n if self._im and not force_update:\n return self._im\n if not self.model:\n raise Exception(\"Cannot get influence map if there is no model.\")\n\n def add_obs_for_agents(main_agent, ref_agents=None):\n if ref_agents:\n all_agents = [main_agent] + ref_agents\n else:\n all_agents = [main_agent]\n ag_to_obj_mps = self.get_all_mps(all_agents, mapping=True)\n if all([not v for v in ag_to_obj_mps.values()]):\n logger.debug('No monomer patterns found in model for agents %s'\n ', skipping' % all_agents)\n return\n obs_nodes = NodesContainer(main_agent, ref_agents)\n main_obs_set = set()\n ref_obs_set = set()\n for agent in ag_to_obj_mps:\n for obj_mp in ag_to_obj_mps[agent]:\n obs_name = _monomer_pattern_label(obj_mp) + '_obs'\n self.obs_to_agents[obs_name] = agent\n # Add the observable\n obj_obs = Observable(obs_name, obj_mp, _export=False)\n if agent.matches(main_agent):\n main_obs_set.add(obs_name)\n else:\n ref_obs_set.add(obs_name)\n try:\n self.model.add_component(obj_obs)\n self.model.add_annotation(\n Annotation(obs_name, agent.name,\n 'from_indra_agent'))\n except ComponentDuplicateNameError as e:\n pass\n obs_nodes.main_interm = main_obs_set\n obs_nodes.ref_interm = ref_obs_set\n return obs_nodes\n\n # Create observables for all statements to check, and add to model\n # Remove any existing observables in the model\n self.model.observables = ComponentSet([])\n for stmt in self.statements:\n # Generate observables for Modification statements\n if isinstance(stmt, Modification) or \\\n isinstance(stmt, SelfModification):\n # If the statement is a regular Mod, the target is stmt.sub\n if isinstance(stmt, Modification):\n sub = stmt.sub\n # If it's a SelfMod, the target is stmt.enz\n elif isinstance(stmt, SelfModification):\n sub = stmt.enz\n # Add the mod for the agent\n if sub is None:\n self.stmt_to_obs[stmt] = NodesContainer(None)\n else:\n mod_condition_name = modclass_to_modtype[stmt.__class__]\n if isinstance(stmt, RemoveModification):\n mod_condition_name = modtype_to_inverse[\n mod_condition_name]\n # Add modification to substrate agent\n modified_sub = _add_modification_to_agent(\n sub, mod_condition_name, stmt.residue,\n stmt.position)\n # Get all refinements of substrate agent\n ref_subs = self.get_refinements(modified_sub)\n obs_nodes = add_obs_for_agents(modified_sub, ref_subs)\n # Associate this statement with this observable\n self.stmt_to_obs[stmt] = obs_nodes\n # Generate observables for Activation/Inhibition statements\n elif isinstance(stmt, RegulateActivity):\n if stmt.obj is None:\n self.stmt_to_obs[stmt] = NodesContainer(None)\n else:\n # Add activity to object agent\n regulated_obj = _add_activity_to_agent(\n stmt.obj, stmt.obj_activity, stmt.is_activation)\n # Get all refinements of object agent\n ref_objs = self.get_refinements(stmt.obj)\n obs_nodes = add_obs_for_agents(regulated_obj, ref_objs)\n # Associate this statement with this observable\n self.stmt_to_obs[stmt] = obs_nodes\n elif isinstance(stmt, RegulateAmount):\n if stmt.obj is None:\n self.stmt_to_obs[stmt] = NodesContainer(None)\n else:\n # Get all refinements of object agent\n ref_objs = self.get_refinements(stmt.obj)\n obs_nodes = add_obs_for_agents(stmt.obj, ref_objs)\n self.stmt_to_obs[stmt] = obs_nodes\n elif isinstance(stmt, Influence):\n if stmt.obj is None:\n self.stmt_to_obs[stmt] = NodesContainer(None)\n else:\n # Get all refinements of object agent\n ref_objs = self.get_refinements(stmt.obj)\n concepts = [obj.concept for obj in ref_objs]\n obs_nodes = add_obs_for_agents(stmt.obj.concept, concepts)\n self.stmt_to_obs[stmt] = obs_nodes\n # Add observables for each agent\n for ag in self.agent_obs:\n obs_nodes = add_obs_for_agents(ag)\n self.agent_to_obs[ag] = obs_nodes\n\n logger.info(\"Generating influence map\")\n self._im = self.generate_im(self.model)\n # self._im.is_multigraph = lambda: False\n # Now, for every rule in the model, check if there are any observables\n # downstream; alternatively, for every observable in the model, get a\n # list of rules.\n # We'll need the dictionary to check if nodes are observables\n node_attributes = nx.get_node_attributes(self._im, 'node_type')\n for rule in self.model.rules:\n obs_list = []\n # Get successors of the rule node\n for neighb in self._im.neighbors(rule.name):\n # Check if the node is an observable\n if node_attributes[neighb] != 'variable':\n continue\n # Get the edge and check the polarity\n edge_sign = _get_edge_sign(self._im, (rule.name, neighb))\n obs_list.append((neighb, edge_sign))\n self.rule_obs_dict[rule.name] = obs_list\n return self._im\n\n def get_graph(self, prune_im=True, prune_im_degrade=True,\n prune_im_subj_obj=False, add_namespaces=False,\n edge_filter_func=None):\n \"\"\"Get influence map and convert it to a graph with signed nodes.\"\"\"\n if self.graph:\n return self.graph\n # NOTE edge_filter_func is not currently used in PySB\n im = self.get_im(force_update=True)\n if prune_im:\n self.prune_influence_map()\n if prune_im_degrade:\n self.prune_influence_map_degrade_bind_positive(self.model_stmts)\n if prune_im_subj_obj:\n self.prune_influence_map_subj_obj()\n self.get_nodes_to_agents(add_namespaces=add_namespaces)\n self.graph = signed_edges_to_signed_nodes(\n im, prune_nodes=False, edge_signs={'pos': 1, 'neg': -1})\n return self.graph\n\n def get_nodes_to_agents(self, add_namespaces=False):\n \"\"\"Return a dictionary mapping influence map nodes to INDRA agents.\n\n Parameters\n ----------\n add_namespaces : bool\n Whether to propagate namespaces to node data. Default: False.\n\n Returns\n -------\n nodes_to_agents : dict\n A dictionary mapping influence map nodes to INDRA agents.\n \"\"\"\n if self.nodes_to_agents:\n return self.nodes_to_agents\n\n logger.info('Mapping nodes to agents')\n im = self.get_im()\n nodes_to_agents = {}\n\n # First map rules to their subject agents\n for rule, mps in self.rules_to_mps.items():\n for mp in mps:\n for ann in self.model.annotations:\n if ann.subject == rule and ann.object == mp.monomer.name:\n # We usually want to map rule to subject agent\n if ann.predicate == 'rule_has_subject':\n nodes_to_agents[rule] = self.mps_to_agents[mp]\n\n # Add observables to agents stored earlier\n nodes_to_agents.update(self.obs_to_agents)\n\n # Optionally propagate namespaces to node data\n if add_namespaces:\n logger.info('Adding namespaces to influence map nodes')\n for n, data in im.nodes(data=True):\n ag = nodes_to_agents.get(n)\n if ag:\n ns, gr = ag.get_grounding()\n data['ns'] = ns\n self.nodes_to_agents = nodes_to_agents\n\n def process_statement(self, stmt):\n self.get_im()\n # Check if this is one of the statement types that we can check\n if not isinstance(stmt, (Modification, RegulateAmount,\n RegulateActivity, Influence)):\n logger.info('Statement type %s not handled' %\n stmt.__class__.__name__)\n return (None, None, 'STATEMENT_TYPE_NOT_HANDLED')\n # Get the polarity for the statement\n if isinstance(stmt, Modification):\n target_polarity = 1 if isinstance(stmt, RemoveModification) else 0\n elif isinstance(stmt, RegulateActivity):\n target_polarity = 0 if stmt.is_activation else 1\n elif isinstance(stmt, RegulateAmount):\n target_polarity = 1 if isinstance(stmt, DecreaseAmount) else 0\n elif isinstance(stmt, Influence):\n target_polarity = 1 if stmt.overall_polarity() == -1 else 0\n # Get the subject and object (works also for Modifications)\n subj, obj = stmt.agent_list()\n # Get a list of monomer patterns matching the subject FIXME Currently\n # this will match rules with the corresponding monomer pattern on it.\n # In future, this statement should (possibly) also match rules in which\n # 1) the agent is in its active form, or 2) the agent is tagged as the\n # enzyme in a rule of the appropriate activity (e.g., a phosphorylation\n # rule) FIXME\n if subj is not None:\n ref_agents = self.get_refinements(subj)\n subj_mps = self.get_all_mps([subj], ignore_activities=True)\n subj_ref_mps = self.get_all_mps(ref_agents, ignore_activities=True)\n if not subj_mps and not subj_ref_mps:\n return (None, None, 'SUBJECT_MONOMERS_NOT_FOUND')\n subj_nodes = NodesContainer(subj, ref_agents)\n meaningful_res_code = None\n # Each subject might produce a different input set and we need to\n # combine them\n for subj_mp in subj_mps:\n inp, res_code = self.process_subject(subj_mp)\n if res_code:\n meaningful_res_code = res_code\n continue\n subj_nodes.main_nodes += inp\n for subj_mp in subj_ref_mps:\n inp, res_code = self.process_subject(subj_mp)\n if res_code:\n meaningful_res_code = res_code\n continue\n subj_nodes.ref_nodes += inp\n subj_nodes.get_all_nodes()\n if not subj_nodes.all_nodes and meaningful_res_code:\n return (None, None, meaningful_res_code)\n else:\n subj_nodes = NodesContainer(None)\n subj_nodes.all_nodes = None\n # Observables may not be found for an activation since there may be no\n # rule in the model activating the object, and the object may not have\n # an \"active\" site of the appropriate type\n obs_nodes = self.stmt_to_obs[stmt]\n if obs_nodes is None:\n logger.info(\"No observables for stmt %s, returning False\" % stmt)\n return (None, None, 'OBSERVABLES_NOT_FOUND')\n # Statement object is None\n if obs_nodes.main_agent is None:\n # Cannot check modifications in this case\n if isinstance(stmt, Modification):\n return (None, None, 'STATEMENT_TYPE_NOT_HANDLED')\n obs_nodes.all_nodes = None\n else:\n obs_nodes.main_nodes = [\n (obs, target_polarity) for obs in obs_nodes.main_interm]\n obs_nodes.ref_nodes = [\n (obs, target_polarity) for obs in obs_nodes.ref_interm]\n obs_nodes.get_all_nodes()\n result_code = None\n return subj_nodes, obs_nodes, result_code\n\n def process_subject(self, subj_mp):\n if subj_mp is None:\n input_set_signed = None\n else:\n input_rule_set = self._get_input_rules(subj_mp)\n if not input_rule_set:\n logger.info('Input rules not found for %s' % subj_mp)\n return (None, 'INPUT_RULES_NOT_FOUND')\n input_set_signed = {(rule, 0) for rule in input_rule_set}\n return input_set_signed, None\n\n def get_model_agents(self):\n return set(self.mps_to_agents.values())\n\n def get_refinements(self, agent):\n \"\"\"Return a list of refinement agents that are part of the model.\"\"\"\n agents = set()\n for ag in self.model_agents:\n if not ag.matches(agent) and ag.refinement_of(agent, bio_ontology):\n agents.add(ag)\n return list(agents)\n\n def get_all_mps(self, agents, ignore_activities=False, mapping=False):\n \"\"\"Get a list of all monomer patterns for a list of agents.\"\"\"\n ag_to_mps = {}\n mps = []\n for ag in agents:\n ag_mps = list(pa.grounded_monomer_patterns(\n self.model, ag, ignore_activities=ignore_activities))\n if ag_mps:\n ag_to_mps[ag] = ag_mps\n mps += ag_mps\n if mapping:\n return ag_to_mps\n return set(mps)\n\n def _get_input_rules(self, subj_mp):\n if subj_mp is None:\n raise ValueError(\"Cannot take None as an argument for subj_mp.\")\n input_rules = _match_lhs(subj_mp, self.model.rules)\n logger.debug('Found %s input rules matching %s' %\n (len(input_rules), str(subj_mp)))\n # Filter to include only rules where the subj_mp is actually the\n # subject (i.e., don't pick up upstream rules where the subject\n # is itself a substrate/object)\n # FIXME: Note that this will eliminate rules where the subject\n # being checked is included on the left hand side as\n # a bound condition rather than as an enzyme.\n subj_rules = pa.rules_with_annotation(self.model,\n subj_mp.monomer.name,\n 'rule_has_subject')\n logger.debug('%d rules with %s as subject' %\n (len(subj_rules), subj_mp.monomer.name))\n input_rule_set = set([r.name for r in input_rules]).intersection(\n set([r.name for r in subj_rules]))\n logger.debug('Final input rule set contains %d rules' %\n len(input_rule_set))\n return input_rule_set\n\n def _sample_paths(self, input_rule_set, obs_name, target_polarity,\n max_paths=1, max_path_length=5):\n if max_paths == 0:\n raise ValueError(\"max_paths cannot be 0 for path sampling.\")\n if not has_pg:\n raise ImportError(\"Paths Graph is not imported\")\n # Convert path polarity representation from 0/1 to 1/-1\n\n def convert_polarities(path_list):\n return [tuple((n[0], 0 if n[1] > 0 else 1) for n in path)\n for path in path_list]\n\n pg_polarity = 0 if target_polarity > 0 else 1\n nx_graph = self._im_to_signed_digraph(self.get_im())\n # Add edges from dummy node to input rules\n source_node = 'SOURCE_NODE'\n for rule in input_rule_set:\n nx_graph.add_edge(source_node, rule, sign=0)\n # -------------------------------------------------\n # Create combined paths_graph\n f_level, b_level = pg.get_reachable_sets(nx_graph, source_node,\n obs_name, max_path_length,\n signed=True)\n pg_list = []\n for path_length in range(1, max_path_length+1):\n cfpg = pg.CFPG.from_graph(\n nx_graph, source_node, obs_name, path_length, f_level,\n b_level, signed=True, target_polarity=pg_polarity)\n pg_list.append(cfpg)\n combined_pg = pg.CombinedCFPG(pg_list)\n # Make sure the combined paths graph is not empty\n if not combined_pg.graph:\n pr = PathResult(\n False, 'NO_PATHS_FOUND', max_paths, max_path_length)\n pr.path_metrics = None\n pr.paths = []\n return pr\n\n # Get a dict of rule objects\n rule_obj_dict = {}\n for ann in self.model.annotations:\n if ann.predicate == 'rule_has_object':\n rule_obj_dict[ann.subject] = ann.object\n\n # Get monomer initial conditions\n ic_dict = {}\n for mon in self.model.monomers:\n # FIXME: A hack that depends on the _0 convention\n ic_name = '%s_0' % mon.name\n # TODO: Wrap this in try/except?\n ic_param = self.model.parameters[ic_name]\n ic_value = ic_param.value\n ic_dict[mon.name] = ic_value\n\n # Set weights in PG based on model initial conditions\n for cur_node in combined_pg.graph.nodes():\n edge_weights = {}\n rule_obj_list = []\n edge_weights_by_gene = {}\n for u, v in combined_pg.graph.out_edges(cur_node):\n v_rule = v[1][0]\n # Get the object of the rule (a monomer name)\n rule_obj = rule_obj_dict.get(v_rule)\n if rule_obj:\n # Add to list so we can count instances by gene\n rule_obj_list.append(rule_obj)\n # Get the abundance of rule object from the initial\n # conditions\n # TODO: Wrap in try/except?\n ic_value = ic_dict[rule_obj]\n else:\n ic_value = 1.0\n edge_weights[(u, v)] = ic_value\n edge_weights_by_gene[rule_obj] = ic_value\n # Get frequency of different rule objects\n rule_obj_ctr = Counter(rule_obj_list)\n # Normalize results by weight sum and gene frequency at this level\n edge_weight_sum = sum(edge_weights_by_gene.values())\n edge_weights_norm = {}\n for e, v in edge_weights.items():\n v_rule = e[1][1][0]\n rule_obj = rule_obj_dict.get(v_rule)\n if rule_obj:\n rule_obj_count = rule_obj_ctr[rule_obj]\n else:\n rule_obj_count = 1\n edge_weights_norm[e] = ((v / float(edge_weight_sum)) /\n float(rule_obj_count))\n # Add edge weights to paths graph\n nx.set_edge_attributes(combined_pg.graph, name='weight',\n values=edge_weights_norm)\n\n # Sample from the combined CFPG\n paths = combined_pg.sample_paths(max_paths)\n # -------------------------------------------------\n if paths:\n pr = PathResult(True, 'PATHS_FOUND', max_paths, max_path_length)\n pr.path_metrics = None\n # Convert path polarity representation from 0/1 to 1/-1\n pr.paths = convert_polarities(paths)\n # Strip off the SOURCE_NODE prefix\n pr.paths = [p[1:] for p in pr.paths]\n else:\n assert False\n pr = PathResult(\n False, 'NO_PATHS_FOUND', max_paths, max_path_length)\n pr.path_metrics = None\n pr.paths = []\n return pr\n\n def score_paths(self, paths, agents_values, loss_of_function=False,\n sigma=0.15, include_final_node=False):\n \"\"\"Return scores associated with a given set of paths.\n\n Parameters\n ----------\n paths : list[list[tuple[str, int]]]\n A list of paths obtained from path finding. Each path is a list\n of tuples (which are edges in the path), with the first element\n of the tuple the name of a rule, and the second element its\n polarity in the path.\n agents_values : dict[indra.statements.Agent, float]\n A dictionary of INDRA Agents and their corresponding measured\n value in a given experimental condition.\n loss_of_function : Optional[boolean]\n If True, flip the polarity of the path. For instance, if the effect\n of an inhibitory drug is explained, set this to True.\n Default: False\n sigma : Optional[float]\n The estimated standard deviation for the normally distributed\n measurement error in the observation model used to score paths\n with respect to data. Default: 0.15\n include_final_node : Optional[boolean]\n Determines whether the final node of the path is included in the\n score. Default: False\n \"\"\"\n obs_model = lambda x: scipy.stats.norm(x, sigma)\n # Build up dict mapping observables to values\n obs_dict = {}\n for ag, val in agents_values.items():\n obs_list = self.agent_to_obs[ag]\n if obs_list is not None:\n for obs in obs_list:\n obs_dict[obs] = val\n # For every path...\n path_scores = []\n for path in paths:\n logger.info('------')\n logger.info(\"Scoring path:\")\n logger.info(path)\n # Look at every node in the path, excluding the final\n # observable...\n path_score = 0\n last_path_node_index = -1 if include_final_node else -2\n for node, sign in path[:last_path_node_index]:\n # ...and for each node check the sign to see if it matches the\n # data. So the first thing is to look at what's downstream\n # of the rule\n # affected_obs is a list of observable names alogn\n for affected_obs, rule_obs_sign in self.rule_obs_dict[node]:\n flip_polarity = -1 if loss_of_function else 1\n pred_sign = sign * rule_obs_sign * flip_polarity\n # Check to see if this observable is in the data\n logger.info('%s %s: effect %s %s' %\n (node, sign, affected_obs, pred_sign))\n measured_val = obs_dict.get(affected_obs)\n if measured_val:\n # For negative predictions use CDF (prob that given\n # measured value, true value lies below 0)\n if pred_sign <= 0:\n prob_correct = obs_model(measured_val).logcdf(0)\n # For positive predictions, use log survival function\n # (SF = 1 - CDF, i.e., prob that true value is\n # above 0)\n else:\n prob_correct = obs_model(measured_val).logsf(0)\n logger.info('Actual: %s, Log Probability: %s' %\n (measured_val, prob_correct))\n path_score += prob_correct\n if not self.rule_obs_dict[node]:\n logger.info('%s %s' % (node, sign))\n prob_correct = obs_model(0).logcdf(0)\n logger.info('Unmeasured node, Log Probability: %s' %\n (prob_correct))\n path_score += prob_correct\n # Normalized path\n # path_score = path_score / len(path)\n logger.info(\"Path score: %s\" % path_score)\n path_scores.append(path_score)\n path_tuples = list(zip(paths, path_scores))\n # Sort first by path length\n sorted_by_length = sorted(path_tuples, key=lambda x: len(x[0]))\n # Sort by probability; sort in reverse order to large values\n # (higher probabilities) are ranked higher\n scored_paths = sorted(sorted_by_length, key=lambda x: x[1],\n reverse=True)\n return scored_paths\n\n def prune_influence_map(self):\n \"\"\"Remove edges between rules causing problematic non-transitivity.\n\n First, all self-loops are removed. After this initial step, edges are\n removed between rules when they share *all* child nodes except for each\n other; that is, they have a mutual relationship with each other and\n share all of the same children.\n\n Note that edges must be removed in batch at the end to prevent edge\n removal from affecting the lists of rule children during the comparison\n process.\n \"\"\"\n im = self.get_im()\n\n # First, remove all self-loops\n logger.info('Removing self loops')\n edges_to_remove = []\n for e in im.edges():\n if e[0] == e[1]:\n logger.info('Removing self loop: %s', e)\n edges_to_remove.append((e[0], e[1]))\n # Now remove all the edges to be removed with a single call\n im.remove_edges_from(edges_to_remove)\n\n # Remove parameter nodes from influence map\n remove_im_params(self.model, im)\n\n # Now compare nodes pairwise and look for overlap between child nodes\n logger.info('Get successors of each node')\n succ_dict = {}\n for node in im.nodes():\n succ_dict[node] = set(im.successors(node))\n # Sort and then group nodes by number of successors\n logger.info('Compare combinations of successors')\n group_key_fun = lambda x: len(succ_dict[x])\n nodes_sorted = sorted(im.nodes(), key=group_key_fun)\n groups = itertools.groupby(nodes_sorted, key=group_key_fun)\n # Now iterate over each group and then construct combinations\n # within the group to check for shared sucessors\n edges_to_remove = []\n for gix, group in groups:\n combos = itertools.combinations(group, 2)\n for ix, (p1, p2) in enumerate(combos):\n # Children are identical except for mutual relationship\n if succ_dict[p1].difference(succ_dict[p2]) == set([p2]) and \\\n succ_dict[p2].difference(succ_dict[p1]) == set([p1]):\n for u, v in ((p1, p2), (p2, p1)):\n edges_to_remove.append((u, v))\n logger.debug('Will remove edge (%s, %s)', u, v)\n logger.info('Removing %d edges from influence map' %\n len(edges_to_remove))\n # Now remove all the edges to be removed with a single call\n im.remove_edges_from(edges_to_remove)\n\n def prune_influence_map_subj_obj(self):\n \"\"\"Prune influence map to include only edges where the object of the\n upstream rule matches the subject of the downstream rule.\"\"\"\n def get_rule_info(r):\n result = {}\n for ann in self.model.annotations:\n if ann.subject == r:\n if ann.predicate == 'rule_has_subject':\n result['subject'] = ann.object\n elif ann.predicate == 'rule_has_object':\n result['object'] = ann.object\n return result\n im = self.get_im()\n rules = im.nodes()\n edges_to_prune = []\n for r1, r2 in itertools.permutations(rules, 2):\n if (r1, r2) not in im.edges():\n continue\n r1_info = get_rule_info(r1)\n r2_info = get_rule_info(r2)\n if 'object' not in r1_info or 'subject' not in r2_info:\n continue\n if r1_info['object'] != r2_info['subject']:\n logger.info(\"Removing edge %s --> %s\" % (r1, r2))\n edges_to_prune.append((r1, r2))\n logger.info('Removing %d edges from influence map' %\n len(edges_to_prune))\n im.remove_edges_from(edges_to_prune)\n\n def prune_influence_map_degrade_bind_positive(self, model_stmts):\n \"\"\"Prune positive edges between X degrading and X forming a\n complex with Y.\"\"\"\n im = self.get_im()\n edges_to_prune = []\n for r1, r2, data in im.edges(data=True):\n s1 = stmt_from_rule(r1, self.model, model_stmts)\n s2 = stmt_from_rule(r2, self.model, model_stmts)\n # Make sure this is a degradation/binding combo\n s1_is_degrad = (s1 and isinstance(s1, DecreaseAmount))\n s2_is_bind = (s2 and isinstance(s2, Complex) and 'bind' in r2)\n if not s1_is_degrad or not s2_is_bind:\n continue\n # Make sure what is degraded is part of the complex\n if s1.obj.name not in [m.name for m in s2.members]:\n continue\n # Make sure we're dealing with a positive influence\n if data['sign'] == 1:\n edges_to_prune.append((r1, r2))\n logger.info('Removing %d edges from influence map' %\n len(edges_to_prune))\n im.remove_edges_from(edges_to_prune)\n\n def _im_to_signed_digraph(self, im):\n edges = []\n for e in im.edges():\n edge_sign = _get_edge_sign(im, e)\n polarity = 0 if edge_sign > 0 else 1\n edges.append((e[0], e[1], {'sign': polarity}))\n dg = nx.DiGraph()\n dg.add_edges_from(edges)\n return dg\n\n\ndef _find_sources_sample(im, target, sources, polarity, rule_obs_dict,\n agent_to_obs, agents_values):\n # Build up dict mapping observables to values\n obs_dict = {}\n for ag, val in agents_values.items():\n obs_list = agent_to_obs[ag]\n for obs in obs_list:\n obs_dict[obs] = val\n\n sigma = 0.2\n\n def obs_model(x):\n return scipy.stats.norm(x, sigma)\n\n def _sample_pred(im, target, rule_obs_dict, obs_model):\n preds = list(_get_signed_predecessors(im, target, 1))\n if not preds:\n return None\n pred_scores = []\n for pred, sign in preds:\n pred_score = 0\n for affected_obs, rule_obs_sign in rule_obs_dict[pred]:\n pred_sign = sign * rule_obs_sign\n # Check to see if this observable is in the data\n logger.info('%s %s: effect %s %s' %\n (pred, sign, affected_obs, pred_sign))\n measured_val = obs_dict.get(affected_obs)\n if measured_val:\n logger.info('Actual: %s' % measured_val)\n # The tail probability of the real value being above 1\n tail_prob = obs_model(measured_val).cdf(1)\n pred_score += (tail_prob if pred_sign == 1 else\n 1-tail_prob)\n pred_scores.append(pred_score)\n # Normalize scores\n pred_scores = np.array(pred_scores) / np.sum(pred_scores)\n pred_idx = np.random.choice(range(len(preds)), p=pred_scores)\n pred = preds[pred_idx]\n return pred\n\n preds = []\n for i in range(100):\n pred = _sample_pred(im, target, rule_obs_dict, obs_model)\n preds.append(pred[0])\n\n\ndef remove_im_params(model, im):\n \"\"\"Remove parameter nodes from the influence map.\n\n Parameters\n ----------\n model : pysb.core.Model\n PySB model.\n im : networkx.MultiDiGraph\n Influence map.\n\n Returns\n -------\n networkx.MultiDiGraph\n Influence map with the parameter nodes removed.\n \"\"\"\n for param in model.parameters:\n # If the node doesn't exist e.g., it may have already been removed),\n # skip over the parameter without error\n try:\n im.remove_node(param.name)\n except:\n pass\n\n\ndef _get_signed_predecessors(im, node, polarity):\n \"\"\"Get upstream nodes in the influence map.\n Return the upstream nodes along with the overall polarity of the path\n to that node by account for the polarity of the path to the given node\n and the polarity of the edge between the given node and its immediate\n predecessors.\n Parameters\n ----------\n im : networkx.MultiDiGraph\n Graph containing the influence map.\n node : str\n The node (rule name) in the influence map to get predecessors (upstream\n nodes) for.\n polarity : int\n Polarity of the overall path to the given node.\n Returns\n -------\n generator of tuples, (node, polarity)\n Each tuple returned contains two elements, a node (string) and the\n polarity of the overall path (int) to that node.\n \"\"\"\n signed_pred_list = []\n for pred in im.predecessors(node):\n pred_edge = (pred, node)\n yield (pred, _get_edge_sign(im, pred_edge) * polarity)\n\n\ndef _get_edge_sign(im, edge):\n \"\"\"Get the polarity of the influence by examining the edge sign.\"\"\"\n edge_data = im[edge[0]][edge[1]]\n # Handle possible multiple edges between nodes\n signs = list(set([v['sign'] for v in edge_data.values()\n if v.get('sign')]))\n if len(signs) > 1:\n logger.warning(\"Edge %s has conflicting polarities; choosing \"\n \"positive polarity by default\" % str(edge))\n sign = 1\n else:\n sign = signs[0]\n if sign is None:\n raise Exception('No sign attribute for edge.')\n elif abs(sign) == 1:\n return sign\n else:\n raise Exception('Unexpected edge sign: %s' % edge.attr['sign'])\n\n\ndef _add_modification_to_agent(agent, mod_type, residue, position):\n \"\"\"Add a modification condition to an Agent.\"\"\"\n new_mod = ModCondition(mod_type, residue, position)\n # Check if this modification already exists\n for old_mod in agent.mods:\n if old_mod.equals(new_mod):\n return agent\n new_agent = deepcopy(agent)\n new_agent.mods.append(new_mod)\n return new_agent\n\n\ndef _add_activity_to_agent(agent, act_type, is_active):\n # Default to active, and return polarity if it's an inhibition\n new_act = ActivityCondition(act_type, True)\n # Check if this state already exists\n if agent.activity is not None and agent.activity.equals(new_act):\n return agent\n new_agent = deepcopy(agent)\n new_agent.activity = new_act\n polarity = 1 if is_active else -1\n return new_agent\n\n\ndef _match_lhs(cp, rules):\n \"\"\"Get rules with a left-hand side matching the given ComplexPattern.\"\"\"\n rule_matches = []\n for rule in rules:\n reactant_pattern = rule.rule_expression.reactant_pattern\n for rule_cp in reactant_pattern.complex_patterns:\n if _cp_embeds_into(rule_cp, cp):\n rule_matches.append(rule)\n break\n return rule_matches\n\n\ndef _cp_embeds_into(cp1, cp2):\n \"\"\"Check that any state in ComplexPattern2 is matched in ComplexPattern1.\n \"\"\"\n # Check that any state in cp2 is matched in cp1\n # If the thing we're matching to is just a monomer pattern, that makes\n # things easier--we just need to find the corresponding monomer pattern\n # in cp1\n if cp1 is None or cp2 is None:\n return False\n cp1 = as_complex_pattern(cp1)\n cp2 = as_complex_pattern(cp2)\n if len(cp2.monomer_patterns) == 1:\n mp2 = cp2.monomer_patterns[0]\n # Iterate over the monomer patterns in cp1 and see if there is one\n # that has the same name\n for mp1 in cp1.monomer_patterns:\n if _mp_embeds_into(mp1, mp2):\n return True\n return False\n\n\ndef _mp_embeds_into(mp1, mp2):\n \"\"\"Check that conditions in MonomerPattern2 are met in MonomerPattern1.\"\"\"\n sc_matches = []\n if mp1.monomer.name != mp2.monomer.name:\n return False\n # Check that all conditions in mp2 are met in mp1\n for site_name, site_state in mp2.site_conditions.items():\n if site_name not in mp1.site_conditions or \\\n site_state != mp1.site_conditions[site_name]:\n return False\n return True\n\n\ndef _monomer_pattern_label(mp):\n \"\"\"Return a string label for a MonomerPattern.\"\"\"\n site_strs = []\n for site, cond in mp.site_conditions.items():\n if isinstance(cond, tuple) or isinstance(cond, list):\n assert len(cond) == 2\n if cond[1] == WILD:\n site_str = '%s_%s' % (site, cond[0])\n else:\n site_str = '%s_%s%s' % (site, cond[0], cond[1])\n elif isinstance(cond, numbers.Real):\n continue\n else:\n site_str = '%s_%s' % (site, cond)\n site_strs.append(site_str)\n return '%s_%s' % (mp.monomer.name, '_'.join(site_strs))\n", "meta": {"hexsha": "135f3b06cf33f7c7416becdd4d59b97f98fa19d6", "size": 41892, "ext": "py", "lang": "Python", "max_stars_repo_path": "indra/explanation/model_checker/pysb.py", "max_stars_repo_name": "johnbachman/belpy", "max_stars_repo_head_hexsha": "1f8052c294fa05b3cd471c544b725f6f0adf9869", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 136, "max_stars_repo_stars_event_min_datetime": "2016-02-11T22:06:37.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T17:26:20.000Z", "max_issues_repo_path": "indra/explanation/model_checker/pysb.py", "max_issues_repo_name": "johnbachman/belpy", "max_issues_repo_head_hexsha": "1f8052c294fa05b3cd471c544b725f6f0adf9869", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 748, "max_issues_repo_issues_event_min_datetime": "2016-02-03T16:27:56.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-09T14:27:54.000Z", "max_forks_repo_path": "indra/explanation/model_checker/pysb.py", "max_forks_repo_name": "johnbachman/belpy", "max_forks_repo_head_hexsha": "1f8052c294fa05b3cd471c544b725f6f0adf9869", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 56, "max_forks_repo_forks_event_min_datetime": "2015-08-28T14:03:44.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-04T06:15:55.000Z", "avg_line_length": 42.7906026558, "max_line_length": 79, "alphanum_fraction": 0.5870571947, "include": true, "reason": "import numpy,import scipy,import networkx", "num_tokens": 8888, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5039061705290805, "lm_q2_score": 0.3960681662740417, "lm_q1q2_score": 0.19958119293562745}} {"text": "# Copyright 2020 Alibaba Group Holding Limited. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# =============================================================================\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport numpy as np\nimport tensorflow as tf\nfrom graphlearn.python.nn.tf.module import Module\nfrom graphlearn.python.nn.tf.layers.linear_layer import LinearLayer\n\nclass EgoSAGELayerGroup(Module):\n def __init__(self, layers):\n super(EgoSAGELayerGroup, self).__init__()\n self.layers = layers\n\n def append(self, layer):\n self.layers.append(layer)\n\n def forward(self, x_list, expands):\n \"\"\" Compute node embeddings based on GraphSAGE.\n\n x_list = [nodes, hop1, hop2, ... , hopK-1, hopK]\n | / | / | / | /\n | / | / | / | /\n | / | / | / | /\n output = [ret0, ret1, ret2, ... , retK-1]\n\n Args:\n x_list: A list of tensors, representing input nodes and their neighbors.\n If len(x_list) is K+1, that means x_list[0], x_list[1], ... , x_list[K]\n are the hidden embedding values at each hop. Tensors in x_list[i] are\n the neighbors of that in x_list[i-1]. In this layer, we will do\n convolution for each adjencent pair and return a list with length K.\n\n The shape of x_list[0] is `[n, input_dim_0]`, and the shape of x_list[i]\n is `[n * k_1 * ... * k_i, input_dim_i]`, where `k_i` means the neighbor\n count of each node at (i-1)th hop. Each `input_dim_i` must match with\n `input_dim` parameter when layer construction.\n\n expands: An integer list of neighbor count at each hop. For the above\n x_list, expands = [k_1, k_2, ... , k_K]\n\n Return:\n A list with K tensors, and the ith shape is\n `[n * k_1 * ... * k_i, output_dim]`.\n \"\"\"\n assert len(self.layers) == (len(x_list) - 1)\n assert len(self.layers) == len(expands)\n\n rets = []\n for i in range(1, len(x_list)):\n x = x_list[i - 1]\n neighbors = x_list[i]\n ret = self.layers[i - 1](x, neighbors, expands[i - 1])\n rets.append(ret)\n return rets\n\nclass EgoSAGELayer(Module):\n \"\"\" GraphSAGE. https://arxiv.org/abs/1706.02216.\n\n Args:\n name: A string, layer name.\n input_dim: An integer or a two elements tuple. Dimension of input features.\n If an integer, nodes and neighbors share the same dimension.\n If an tuple, the two elements represent the dimensions of node features\n and neighbor features.\n Usually, different dimensions happen in the heterogeneous graph.\n output_dim: An integer, dimension of the output embeddings. Both the node\n features and neighbor features will be encoded into the same dimension,\n and then do some combination.\n agg_type: A string, how to merge neighbor values. The optional values are\n 'mean', 'sum', 'max'.\n com_type: A string, how to combine neighbors to self. The optional values\n are 'add', 'concat'.\n use_bias: A boolean, whether add bias after computation.\n \"\"\"\n\n def __init__(self,\n name,\n input_dim,\n output_dim,\n agg_type=\"mean\",\n com_type=\"add\",\n use_bias=False,\n parameter_share=False,\n **kwargs):\n super(EgoSAGELayer, self).__init__()\n assert agg_type in {\"mean\", \"sum\", \"max\", \"gcn\"}\n assert com_type in {\"add\", \"concat\", \"gcn\"}\n\n self.agg_type = agg_type\n self.com_type = com_type\n self.out_dim = output_dim\n\n if isinstance(input_dim, list) or isinstance(input_dim, tuple):\n self.in_dim = input_dim\n assert len(self.in_dim) == 2\n else:\n self.in_dim = [input_dim, input_dim]\n\n with tf.variable_scope(\"ego_sage_layer_\" + name, reuse=tf.AUTO_REUSE):\n self.linears = self.add_transform_layers(parameter_share, use_bias)\n\n def add_transform_layers(self, parameter_share, use_bias):\n layers = []\n if self.com_type == \"concat\":\n dim = self.in_dim[0] + self.in_dim[1]\n layers.append(LinearLayer(\"trans_nodes\", dim, self.out_dim, use_bias))\n elif parameter_share and self.in_dim[0] == self.in_dim[1]:\n layer = LinearLayer(\"trans_nodes\", self.in_dim[0], self.out_dim, use_bias)\n layers.append(layer)\n layers.append(layer)\n else:\n layers.append(\n LinearLayer(\"trans_nodes\", self.in_dim[0], self.out_dim, use_bias))\n layers.append(\n LinearLayer(\"trans_nbrs\", self.in_dim[1], self.out_dim, use_bias))\n return layers\n\n def forward(self, x, neighbor, expand):\n \"\"\" Compute node embeddings based on GraphSAGE.\n Args:\n x: A float tensor with shape = [batch_size, input_dim].\n neighbor: A float tensor with shape = [batch_size * expand, input_dim].\n expand: An integer, the neighbor count.\n\n Return:\n A float tensor with shape=[batch_size, output_dim].\n \"\"\"\n # aggregate neighbors at each hop\n agg_func = self.aggregator()\n agg_info = agg_func(neighbor, expand, self.in_dim[1])\n\n # combine self info with aggregated neighbors\n comb_func = self.combiner()\n return comb_func(x, agg_info)\n\n def aggregator(self):\n func_name = self.agg_type + \"_agg\"\n if not hasattr(self, func_name):\n raise TypeError(\"Unsupported agg_type: \" + self.agg_type)\n return getattr(self, func_name)\n\n def sum_agg(self, x, expand, dim):\n t = tf.reshape(x, [-1, expand, dim])\n return tf.math.reduce_sum(t, axis=1)\n\n def mean_agg(self, x, expand, dim):\n t = tf.reshape(x, [-1, expand, dim])\n return tf.math.reduce_mean(t, axis=1)\n\n def gcn_agg(self, x, expand, dim):\n return tf.reshape(x, [-1, expand, dim])\n\n def max_agg(self, x, expand, dim):\n t = tf.reshape(x, [-1, expand, dim])\n return tf.math.reduce_max(t, axis=1)\n\n def combiner(self):\n func_name = self.com_type + \"_comb\"\n if not hasattr(self, func_name):\n raise TypeError(\"Unsupported com_type: \" + self.com_type)\n return getattr(self, func_name)\n\n def add_comb(self, x, neighbors):\n current = self.linears[0](x)\n nbr_info = self.linears[1](neighbors)\n return tf.add(current, nbr_info)\n\n def concat_comb(self, x, neighbors):\n tmp = tf.concat([x, neighbors], axis=1)\n ret = self.linears[0](tmp)\n return ret\n\n def gcn_comb(self, x, neighbors):\n x = tf.reduce_mean(tf.concat(\n [neighbors, tf.expand_dims(x, axis=1)], axis=1), axis=1)\n return self.linears[0](x)\n", "meta": {"hexsha": "7332aefdae3f427856489f1b4cdb443611dc2d59", "size": 7024, "ext": "py", "lang": "Python", "max_stars_repo_path": "graphlearn/python/nn/tf/layers/ego_sage_layer.py", "max_stars_repo_name": "gasdaf/graph-learn", "max_stars_repo_head_hexsha": "4a77b39be37bb7507f0e9fb5d4ed40ca623b2ceb", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-08-30T03:13:23.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-30T03:13:23.000Z", "max_issues_repo_path": "graphlearn/python/nn/tf/layers/ego_sage_layer.py", "max_issues_repo_name": "gasdaf/graph-learn", "max_issues_repo_head_hexsha": "4a77b39be37bb7507f0e9fb5d4ed40ca623b2ceb", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "graphlearn/python/nn/tf/layers/ego_sage_layer.py", "max_forks_repo_name": "gasdaf/graph-learn", "max_forks_repo_head_hexsha": "4a77b39be37bb7507f0e9fb5d4ed40ca623b2ceb", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.5833333333, "max_line_length": 80, "alphanum_fraction": 0.6445045558, "include": true, "reason": "import numpy", "num_tokens": 1798, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5039061705290805, "lm_q2_score": 0.3960681662740417, "lm_q1q2_score": 0.19958119293562745}} {"text": "# This file is part of QuTiP: Quantum Toolbox in Python.\n#\n# Copyright (c) 2011 and later, Paul D. Nation and Robert J. Johansson.\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or without\n# modification, are permitted provided that the following conditions are\n# met:\n#\n# 1. Redistributions of source code must retain the above copyright notice,\n# this list of conditions and the following disclaimer.\n#\n# 2. Redistributions in binary form must reproduce the above copyright\n# notice, this list of conditions and the following disclaimer in the\n# documentation and/or other materials provided with the distribution.\n#\n# 3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names\n# of its contributors may be used to endorse or promote products derived\n# from this software without specific prior written permission.\n#\n# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n# \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A\n# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n###############################################################################\n\"\"\"\nThis module contains a collection of routines for operating on sparse\nmatrices on the scipy.sparse formats, for use internally by other modules\nthroughout QuTiP.\n\"\"\"\n\n__all__ = ['sp_fro_norm', 'sp_inf_norm', 'sp_L2_norm', 'sp_max_norm',\n 'sp_one_norm', 'sp_reshape', 'sp_eigs', 'sp_expm', 'sp_permute',\n 'sp_reverse_permute', 'sp_bandwidth', 'sp_profile']\n\nimport scipy.sparse as sp\nimport scipy.sparse.linalg as spla\nimport numpy as np\nimport scipy.linalg as la\nfrom scipy.linalg.blas import get_blas_funcs\n_dznrm2 = get_blas_funcs(\"znrm2\")\nfrom qutip.cy.sparse_utils import (_sparse_profile, _sparse_permute,\n _sparse_reverse_permute, _sparse_bandwidth)\nfrom qutip.settings import debug\n\nimport qutip.logging\nlogger = qutip.logging.get_logger()\n\nif debug:\n import inspect\n\n\ndef sp_fro_norm(data):\n \"\"\"\n Frobius norm for sparse matrix\n \"\"\"\n out = np.sum(np.abs(data.data)**2)\n return np.sqrt(out)\n\n\ndef sp_inf_norm(data):\n \"\"\"\n Infinity norm for sparse matrix\n \"\"\"\n return np.max([np.sum(np.abs(data.getrow(k).data))\n for k in range(data.shape[0])])\n\n\ndef sp_L2_norm(data):\n \"\"\"\n L2 norm sparse vector\n \"\"\"\n if 1 not in data.shape:\n raise TypeError(\"Use L2-norm only for vectors.\")\n\n if len(data.data):\n return _dznrm2(data.data)\n else:\n return 0\n\n\ndef sp_max_norm(data):\n \"\"\"\n Max norm for sparse matrix\n \"\"\"\n return np.max(np.abs(data.data)) if any(data.data) else 0\n\n\ndef sp_one_norm(data):\n \"\"\"\n One norm for sparse matrix\n \"\"\"\n return np.max(np.array([np.sum(np.abs((data.getcol(k).data)))\n for k in range(data.shape[1])]))\n\n\ndef sp_reshape(A, shape, format='csr'):\n \"\"\"\n Reshapes a sparse matrix.\n\n Parameters\n ----------\n A : sparse_matrix\n Input matrix in any format\n shape : list/tuple\n Desired shape of new matrix\n format : string {'csr','coo','csc','lil'}\n Optional string indicating desired output format\n\n Returns\n -------\n B : csr_matrix\n Reshaped sparse matrix\n\n References\n ----------\n\n http://stackoverflow.com/questions/16511879/reshape-sparse-matrix-efficiently-python-scipy-0-12\n\n \"\"\"\n if not hasattr(shape, '__len__') or len(shape) != 2:\n raise ValueError('Shape must be a list of two integers')\n\n C = A.tocoo()\n nrows, ncols = C.shape\n size = nrows * ncols\n new_size = shape[0] * shape[1]\n\n if new_size != size:\n raise ValueError('Total size of new array must be unchanged.')\n\n flat_indices = ncols * C.row + C.col\n new_row, new_col = divmod(flat_indices, shape[1])\n B = sp.coo_matrix((C.data, (new_row, new_col)), shape=shape)\n\n if format == 'csr':\n return B.tocsr()\n elif format == 'coo':\n return B\n elif format == 'csc':\n return B.tocsc()\n elif format == 'lil':\n return B.tolil()\n else:\n raise ValueError('Return format not valid.')\n\n\ndef _dense_eigs(data, isherm, vecs, N, eigvals, num_large, num_small):\n \"\"\"\n Internal functions for computing eigenvalues and eigenstates for a dense\n matrix.\n \"\"\"\n if debug:\n logger.debug(inspect.stack()[0][3] + \": vectors = \" + str(vecs))\n\n evecs = None\n\n if vecs:\n if isherm:\n if eigvals == 0:\n evals, evecs = la.eigh(data)\n else:\n if num_small > 0:\n evals, evecs = la.eigh(\n data, eigvals=[0, num_small - 1])\n if num_large > 0:\n evals, evecs = la.eigh(\n data, eigvals=[N - num_large, N - 1])\n else:\n evals, evecs = la.eig(data)\n else:\n if isherm:\n if eigvals == 0:\n evals = la.eigvalsh(data)\n else:\n if num_small > 0:\n evals = la.eigvalsh(data, eigvals=[0, num_small - 1])\n if num_large > 0:\n evals = la.eigvalsh(data, eigvals=[N - num_large, N - 1])\n else:\n evals = la.eigvals(data)\n\n _zipped = list(zip(evals, range(len(evals))))\n _zipped.sort()\n evals, perm = list(zip(*_zipped))\n\n if vecs:\n evecs = np.array([evecs[:, k] for k in perm])\n\n if not isherm and eigvals > 0:\n if vecs:\n if num_small > 0:\n evals, evecs = evals[:num_small], evecs[:num_small]\n elif num_large > 0:\n evals, evecs = evals[(N - num_large):], evecs[(N - num_large):]\n else:\n if num_small > 0:\n evals = evals[:num_small]\n elif num_large > 0:\n evals = evals[(N - num_large):]\n\n return np.array(evals), np.array(evecs)\n\n\ndef _sp_eigs(data, isherm, vecs, N, eigvals, num_large, num_small, tol,\n maxiter):\n \"\"\"\n Internal functions for computing eigenvalues and eigenstates for a sparse\n matrix.\n \"\"\"\n if debug:\n print(inspect.stack()[0][3] + \": vectors = \" + str(vecs))\n\n big_vals = np.array([])\n small_vals = np.array([])\n evecs = None\n\n remove_one = False\n if eigvals == (N - 1):\n # calculate all eigenvalues and remove one at output if using sparse\n eigvals = 0\n num_small = int(np.ceil(N / 2.0))\n num_large = N - num_small\n remove_one = True\n\n if vecs:\n if isherm:\n if num_large > 0:\n big_vals, big_vecs = sp.linalg.eigsh(data, k=num_large,\n which='LA', tol=tol,\n maxiter=maxiter)\n big_vecs = sp.csr_matrix(big_vecs, dtype=complex)\n if num_small > 0:\n small_vals, small_vecs = sp.linalg.eigsh(\n data, k=num_small, which='SA',\n tol=tol, maxiter=maxiter)\n\n else:\n if num_large > 0:\n big_vals, big_vecs = sp.linalg.eigs(data, k=num_large,\n which='LR', tol=tol,\n maxiter=maxiter)\n big_vecs = sp.csr_matrix(big_vecs, dtype=complex)\n if num_small > 0:\n small_vals, small_vecs = sp.linalg.eigs(\n data, k=num_small, which='SR',\n tol=tol, maxiter=maxiter)\n\n if num_large != 0 and num_small != 0:\n evecs = sp.hstack([small_vecs, big_vecs], format='csr')\n elif num_large != 0 and num_small == 0:\n evecs = big_vecs\n elif num_large == 0 and num_small != 0:\n evecs = small_vecs\n else:\n if isherm:\n if num_large > 0:\n big_vals = sp.linalg.eigsh(\n data, k=num_large, which='LA',\n return_eigenvectors=False, tol=tol, maxiter=maxiter)\n if num_small > 0:\n small_vals = sp.linalg.eigsh(\n data, k=num_small, which='SA',\n return_eigenvectors=False, tol=tol, maxiter=maxiter)\n else:\n if num_large > 0:\n big_vals = sp.linalg.eigs(\n data, k=num_large, which='LR',\n return_eigenvectors=False, tol=tol, maxiter=maxiter)\n if num_small > 0:\n small_vals = sp.linalg.eigs(\n data, k=num_small, which='SR',\n return_eigenvectors=False, tol=tol, maxiter=maxiter)\n\n evals = np.hstack((small_vals, big_vals))\n if isherm:\n evals = np.real(evals)\n\n _zipped = list(zip(evals, range(len(evals))))\n _zipped.sort()\n evals, perm = list(zip(*_zipped))\n\n if vecs:\n evecs = np.array([evecs[:, k] for k in perm])\n\n # remove last element if requesting N-1 eigs and using sparse\n if remove_one:\n evals = np.delete(evals, -1)\n if vecs:\n evecs = np.delete(evecs, -1)\n\n return np.array(evals), np.array(evecs)\n\n\ndef sp_eigs(data, isherm, vecs=True, sparse=False, sort='low',\n eigvals=0, tol=0, maxiter=100000):\n \"\"\"Returns Eigenvalues and Eigenvectors for a sparse matrix.\n Uses dense eigen-solver unless user sets sparse=True.\n\n Parameters\n ----------\n data : csr_matrix\n Input matrix\n isherm : bool\n Indicate whether the matrix is hermitian or not\n vecs : bool {True , False}\n Flag for requesting eigenvectors\n sparse : bool {False , True}\n Flag to use sparse solver\n sort : str {'low' , 'high}\n Return lowest or highest eigenvals/vecs\n eigvals : int\n Number of eigenvals/vecs to return. Default = 0 (return all)\n tol : float\n Tolerance for sparse eigensolver. Default = 0 (Machine precision)\n maxiter : int\n Max. number of iterations used by sparse sigensolver.\n\n Returns\n -------\n Array of eigenvalues and (by default) array of corresponding Eigenvectors.\n\n \"\"\"\n\n if debug:\n print(inspect.stack()[0][3])\n\n if data.shape[0] != data.shape[1]:\n raise TypeError(\"Can only diagonalize square matrices\")\n\n N = data.shape[0]\n if eigvals == N:\n eigvals = 0\n\n if eigvals > N:\n raise ValueError(\"Number of requested eigen vals/vecs must be <= N.\")\n\n # set number of large and small eigenvals/vecs\n if eigvals == 0: # user wants all eigs (default)\n D = int(np.ceil(N / 2.0))\n num_large = N - D\n if not np.mod(N, 2):\n M = D\n else:\n M = D - 1\n num_small = N - M\n else: # if user wants only a few eigen vals/vecs\n if sort == 'low':\n num_small = eigvals\n num_large = 0\n elif sort == 'high':\n num_large = eigvals\n num_small = 0\n else:\n raise ValueError(\"Invalid option for 'sort'.\")\n\n # Dispatch to sparse/dense solvers\n if sparse:\n evals, evecs = _sp_eigs(data, isherm, vecs, N, eigvals, num_large,\n num_small, tol, maxiter)\n else:\n evals, evecs = _dense_eigs(data.todense(), isherm, vecs, N, eigvals,\n num_large, num_small)\n\n if sort == 'high': # flip arrays to largest values first\n if vecs:\n evecs = np.flipud(evecs)\n evals = np.flipud(evals)\n\n return (evals, evecs) if vecs else evals\n\n\ndef sp_expm(data, sparse=True):\n \"\"\"\n Sparse matrix exponential.\n \"\"\"\n A = data.tocsc() # extract Qobj data (sparse matrix)\n m_vals = np.array([3, 5, 7, 9, 13])\n theta = np.array([0.01495585217958292, 0.2539398330063230,\n 0.9504178996162932, 2.097847961257068,\n 5.371920351148152], dtype=float)\n normA = sp_one_norm(data)\n if normA <= theta[-1]:\n for ii in range(len(m_vals)):\n if normA <= theta[ii]:\n F = _pade(A, m_vals[ii], sparse)\n break\n else:\n t, s = np.frexp(normA / theta[-1])\n s = s - (t == 0.5)\n A = A / 2.0 ** s\n F = _pade(A, m_vals[-1], sparse)\n for i in range(s):\n F = F * F\n\n return F\n\n\ndef _pade(A, m, sparse):\n n = np.shape(A)[0]\n c = _padecoeff(m)\n\n if m != 13:\n apows = [[] for jj in range(int(np.ceil((m + 1) / 2)))]\n apows[0] = sp.eye(n, n, format='csc')\n apows[1] = A * A\n for jj in range(2, int(np.ceil((m + 1) / 2))):\n apows[jj] = apows[jj - 1] * apows[1]\n U = sp.lil_matrix((n, n)).tocsc()\n V = sp.lil_matrix((n, n)).tocsc()\n for jj in range(m, 0, -2):\n U = U + c[jj] * apows[jj // 2]\n U = A * U\n for jj in range(m - 1, -1, -2):\n V = V + c[jj] * apows[(jj + 1) // 2]\n\n if sparse:\n F = spla.spsolve((-U + V), (U + V))\n return F.tocsr()\n else:\n F = la.solve((-U + V).todense(), (U + V).todense())\n return sp.lil_matrix(F).tocsr()\n\n elif m == 13:\n A2 = A * A\n A4 = A2 * A2\n A6 = A2 * A4\n U = A * (A6 * (c[13] * A6 + c[11] * A4 + c[9] * A2) +\n c[7] * A6 + c[5] * A4 + c[3] * A2 +\n c[1] * sp.eye(n, n).tocsc())\n V = A6 * (c[12] * A6 + c[10] * A4 + c[8] * A2) + c[6] * A6 + c[4] * \\\n A4 + c[2] * A2 + c[0] * sp.eye(n, n).tocsc()\n\n if sparse:\n F = spla.spsolve((-U + V), (U + V))\n return F.tocsr()\n else:\n F = la.solve((-U + V).todense(), (U + V).todense())\n return sp.csr_matrix(F)\n\n\ndef _padecoeff(m):\n \"\"\"\n Private function returning coefficients for Pade approximation.\n \"\"\"\n if m == 3:\n return np.array([120, 60, 12, 1])\n elif m == 5:\n return np.array([30240, 15120, 3360, 420, 30, 1])\n elif m == 7:\n return np.array([17297280, 8648640, 1995840, 277200,\n 25200, 1512, 56, 1])\n elif m == 9:\n return np.array([17643225600, 8821612800, 2075673600,\n 302702400, 30270240, 2162160, 110880,\n 3960, 90, 1])\n elif m == 13:\n return np.array([64764752532480000, 32382376266240000,\n 7771770303897600, 1187353796428800,\n 129060195264000, 10559470521600, 670442572800,\n 33522128640, 1323241920, 40840800,\n 960960, 16380, 182, 1])\n\n\ndef sp_permute(A, rperm=(), cperm=(), safe=True):\n \"\"\"\n Permutes the rows and columns of a sparse CSR/CSC matrix\n according to the permutation arrays rperm and cperm, respectively.\n Here, the permutation arrays specify the new order of the rows and\n columns. i.e. [0,1,2,3,4] -> [3,0,4,1,2].\n\n Parameters\n ----------\n A : csr_matrix, csc_matrix\n Input matrix.\n rperm : array_like of integers\n Array of row permutations.\n cperm : array_like of integers\n Array of column permutations.\n safe : bool\n Check structure of permutation arrays.\n\n Returns\n -------\n perm_csr : csr_matrix, csc_matrix\n CSR or CSC matrix with permuted rows/columns.\n\n \"\"\"\n rperm = np.asarray(rperm, dtype=np.int32)\n cperm = np.asarray(cperm, dtype=np.int32)\n nrows = A.shape[0]\n ncols = A.shape[1]\n if len(rperm) == 0:\n rperm = np.arange(nrows, dtype=np.int32)\n if len(cperm) == 0:\n cperm = np.arange(ncols, dtype=np.int32)\n if safe:\n if len(np.setdiff1d(rperm, np.arange(nrows))) != 0:\n raise Exception('Invalid row permutation array.')\n if len(np.setdiff1d(cperm, np.arange(ncols))) != 0:\n raise Exception('Invalid column permutation array.')\n\n shp = A.shape\n kind = A.getformat()\n if kind == 'csr':\n flag = 0\n elif kind == 'csc':\n flag = 1\n else:\n raise Exception('Input must be Qobj, CSR, or CSC matrix.')\n\n data, ind, ptr = _sparse_permute(A.data, A.indices, A.indptr,\n nrows, ncols, rperm, cperm, flag)\n if kind == 'csr':\n return sp.csr_matrix((data, ind, ptr), shape=shp, dtype=data.dtype)\n elif kind == 'csc':\n return sp.csc_matrix((data, ind, ptr), shape=shp, dtype=data.dtype)\n\n\ndef sp_reverse_permute(A, rperm=(), cperm=(), safe=True):\n \"\"\"\n Performs a reverse permutations of the rows and columns of a sparse CSR/CSC\n matrix according to the permutation arrays rperm and cperm, respectively.\n Here, the permutation arrays specify the order of the rows and columns used\n to permute the original array.\n\n Parameters\n ----------\n A : csr_matrix, csc_matrix\n Input matrix.\n rperm : array_like of integers\n Array of row permutations.\n cperm : array_like of integers\n Array of column permutations.\n safe : bool\n Check structure of permutation arrays.\n\n Returns\n -------\n perm_csr : csr_matrix, csc_matrix\n CSR or CSC matrix with permuted rows/columns.\n\n \"\"\"\n rperm = np.asarray(rperm, dtype=np.int32)\n cperm = np.asarray(cperm, dtype=np.int32)\n nrows = A.shape[0]\n ncols = A.shape[1]\n if len(rperm) == 0:\n rperm = np.arange(nrows, dtype=np.int32)\n if len(cperm) == 0:\n cperm = np.arange(ncols, dtype=np.int32)\n if safe:\n if len(np.setdiff1d(rperm, np.arange(nrows))) != 0:\n raise Exception('Invalid row permutation array.')\n if len(np.setdiff1d(cperm, np.arange(ncols))) != 0:\n raise Exception('Invalid column permutation array.')\n\n shp = A.shape\n kind = A.getformat()\n if kind == 'csr':\n flag = 0\n elif kind == 'csc':\n flag = 1\n else:\n raise Exception('Input must be Qobj, CSR, or CSC matrix.')\n\n data, ind, ptr = _sparse_reverse_permute(A.data, A.indices, A.indptr,\n nrows, ncols, rperm, cperm, flag)\n\n if kind == 'csr':\n return sp.csr_matrix((data, ind, ptr), shape=shp, dtype=data.dtype)\n elif kind == 'csc':\n return sp.csc_matrix((data, ind, ptr), shape=shp, dtype=data.dtype)\n\n\ndef sp_bandwidth(A):\n \"\"\"\n Returns the max(mb), lower(lb), and upper(ub) bandwidths of a\n sparse CSR/CSC matrix.\n\n If the matrix is symmetric then the upper and lower bandwidths are\n identical. Diagonal matrices have a bandwidth equal to one.\n\n Parameters\n ----------\n A : csr_matrix, csc_matrix\n Input matrix\n\n Returns\n -------\n mb : int\n Maximum bandwidth of matrix.\n lb : int\n Lower bandwidth of matrix.\n ub : int\n Upper bandwidth of matrix.\n\n \"\"\"\n nrows = A.shape[0]\n ncols = A.shape[1]\n\n if A.getformat() == 'csr':\n return _sparse_bandwidth(A.indices, A.indptr, nrows)\n elif A.getformat() == 'csc':\n # Normal output is mb,lb,ub but since CSC\n # is transpose of CSR switch lb and ub\n mb, ub, lb = _sparse_bandwidth(A.indices, A.indptr, ncols)\n return mb, lb, ub\n else:\n raise Exception('Invalid sparse input format.')\n\n\ndef sp_profile(A):\n \"\"\"Returns the total, lower, and upper profiles of a sparse matrix.\n\n If the matrix is symmetric then the upper and lower profiles are\n identical. Diagonal matrices have zero profile.\n\n Parameters\n ----------\n A : csr_matrix, csc_matrix\n Input matrix\n \"\"\"\n if sp.isspmatrix_csr(A):\n up = _sparse_profile(A.indices, A.indptr, A.shape[0])\n A = A.tocsc()\n lp = _sparse_profile(A.indices, A.indptr, A.shape[0])\n\n elif sp.isspmatrix_csc(A):\n lp = _sparse_profile(A.indices, A.indptr, A.shape[0])\n A = A.tocsr()\n up = _sparse_profile(A.indices, A.indptr, A.shape[0])\n\n else:\n raise TypeError('Input sparse matrix must be in CSR or CSC format.')\n\n return up+lp, lp, up\n", "meta": {"hexsha": "fe7d6eb36f81f8f195d77a75541c635008688544", "size": 20675, "ext": "py", "lang": "Python", "max_stars_repo_path": "qutip/sparse.py", "max_stars_repo_name": "kiuthed/qutip", "max_stars_repo_head_hexsha": "b6fb8e5bbd9ffeae117b54e56313e8617038deab", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "qutip/sparse.py", "max_issues_repo_name": "kiuthed/qutip", "max_issues_repo_head_hexsha": "b6fb8e5bbd9ffeae117b54e56313e8617038deab", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "qutip/sparse.py", "max_forks_repo_name": "kiuthed/qutip", "max_forks_repo_head_hexsha": "b6fb8e5bbd9ffeae117b54e56313e8617038deab", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.0542635659, "max_line_length": 103, "alphanum_fraction": 0.5632889964, "include": true, "reason": "import numpy,import scipy,from scipy", "num_tokens": 5537, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5039061705290805, "lm_q2_score": 0.3960681662740417, "lm_q1q2_score": 0.19958119293562745}} {"text": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\n\n\"\"\"Identifies events of small particles crossing through an ion channel.\n\nThis script parses a trajectory and of an ion-channel-in-membrane simulation\nand identifies events of small target particles (e.g. ions, water molecules)\ncrossing the ion channel. A crossing event is defined as an ion moving from the\nbulk domain on one side of the membrane through the channel pore domain to the\nbulk domain on the opposite side of the membrane. Cases where the target\nparticle moves through the periodic boundary or through the membrane itself are\nnot classified as crossing events.\n\nParticles are assigned to the two bulk domains based on whether their\nz-coordinate is smaller or larger than the mean z-coordinate of the membrane.\nHowever, if a particle is located within a cylindrical region around the centre\nof geometry of the channel protein, it is assigned to the pore domain instead.\nCrossing events are then identified based on the particles moving between these\nthree domains.\n\nThe user can specify an MDAnalysis selection that defines which particles will\nbe considered. It should be noted that the script operates on a per-atom basis.\nTherefore, if the user selected e.g. water molecules on a per-residue bases, the\ncrossing of one water molecule will be recorded as the three individual\ncrossings of the constituent atoms.\n\nOutput is written to a JSON file and corresponds to a data frame structure in\nwhich each row represents one crossing event. The columns will contain the\n(res)ID, (res)name, charge, and mass of the particle that crossed the pore\nalongside the times at which the particle enters and exits the pore. A crossing\nnumber is given which indicates the direction in which the particle crossed\nthe pore (i.e. +1 for crossing in positive z-direction and -1 for crossing in\nnegative z-direction).\n\nThe overall number of particles that cross the pore can be readily calculated\nfrom this data as the cumulative sum over the crossing number. Similarly, the\ntotal amount of charge or mass transported can be evaluated as the cumulative\nsum over the product of the crossing number with charge and mass respectively.\n\"\"\"\n\n\nimport argparse\n\nimport numpy as np\nimport pandas as pd\n\nimport MDAnalysis as mda\n\n\ndef determine_domain_indices(\n topology_file,\n trajectory_file,\n sel_pore,\n sel_bilayer,\n sel_target,\n r_margin,\n z_margin,\n b,\n e,\n dt\n):\n \"\"\"Passes through trajectory and assigns domain indices.\n\n The return value is a data frame containing three columns for particle ID,\n time stamp, and the domain index of that particle at the given time. The\n domain index gives an indication of whether a particle is located below\n the membrane (-1), above the membrane (+1), or inside the channel pore (0).\n The user can set a start time, end time, and time step based on which frames\n will be analysed or skipped.\n\n Particles are assigned to the -1 and +1 domains based on whether their\n z-coordinate is larger or smaller than the mean z-coordinate of the\n membrane. If a particle is located within a cylindrical region around the\n center of geometry of the protein, it is assigned the domain index 0\n instead. Radius and z-extend of the cylindrical region are determined from\n the bounding box of the protein, but the user may add a margin to either\n of these parameters.\n \"\"\"\n\n # create MDA universe:\n u = mda.Universe(topology_file, trajectory_file)\n\n # determine atom groups for analysis:\n protein = u.select_atoms(sel_pore)\n membrane = u.select_atoms(sel_bilayer)\n target = u.select_atoms(sel_target)\n\n # find pore radius:\n prot_radius = max(np.diff(protein.bbox(), axis=0)[0][0:2]) / 2.0\n radius = prot_radius + r_margin\n\n # create data frame of target positions over time:\n dat = []\n for ts in u.trajectory:\n\n # skip unwanted frames:\n if ts.time < b or ts.time > e or ts.time % dt != 0.0:\n continue\n\n # inform user:\n print(\n \" ~> identifying domain indices in frame: \" + str(ts.frame)\n + \" at time: \" + str(ts.time)\n )\n\n # create data frame from target particle positions:\n tmp = pd.DataFrame(\n target.positions,\n columns=[\"x\", \"y\", \"z\"]\n )\n\n # add particle properties:\n tmp[\"particle_id\"] = target.ids\n tmp[\"name\"] = [str(x) for x in target.names]\n tmp[\"resname\"] = [str(x) for x in target.resnames]\n tmp[\"resid\"] = [int(x) for x in target.resids]\n tmp[\"charge\"] = target.charges\n tmp[\"mass\"] = target.masses\n\n # add time stamp:\n tmp[\"t\"] = ts.time\n\n # position of protein COG in x/y-plane:\n x_cen = protein.center_of_geometry()[0]\n y_cen = protein.center_of_geometry()[1]\n\n # z-extent of proteina nd middle of membrane:\n z_min = protein.bbox()[0, 2] - z_margin\n z_max = protein.bbox()[1, 2] + z_margin\n z_mid = np.mean(membrane.bbox(), axis=0)[2]\n\n # assign domain indices:\n tmp.loc[\n (tmp[\"z\"] < z_mid),\n \"domain_idx\"\n ] = int(-1)\n tmp.loc[\n (tmp[\"z\"] >= z_mid),\n \"domain_idx\"\n ] = int(1)\n tmp.loc[\n (tmp[\"z\"] >= z_min)\n & (tmp[\"z\"] <= z_max)\n & ((tmp[\"x\"] - x_cen)**2 + (tmp[\"y\"] - y_cen)**2 < radius**2),\n \"domain_idx\"\n ] = int(0)\n\n # sanity check:\n num_nan = np.sum(tmp[\"domain_idx\"].isna())\n if num_nan > 0:\n raise Exception(\"Could not unambiguously assign domain indices.\")\n\n # drop unneccessary columns:\n tmp = tmp.drop(columns=[\"x\", \"y\", \"z\"])\n\n # add to data frame list:\n dat.append(tmp)\n\n # combine into overall data frame:\n df = pd.concat(dat)\n\n # return the overall data frame of domain indices:\n return(df)\n\n\ndef aggregate_event_pairs(df):\n \"\"\"Aggregates pairs of subsequent events.\n\n The resulting data frame will contain as many rows as the number of\n crossing events (i.e. a particle going through the channel) occuring in the\n given data frame. This means that the output data frame will be empty if no\n crossing event occurs. Each row will contain the time at which the particle\n entered and left the pore region as well as the mean of those two times. In\n addition it will contain a crossing number, which indicates whether the\n particle crossed the pore in positive or negative z-direction (its absolute\n value is always one).\n\n The input data frame must contain the domain index difference for a single\n particle only and may not contain any jump events, i.e. events where the\n particle moved from domain +1 to domain -1 (or vice versa) without passing\n through domain 0 (the pore). This can happen if the particle jumps through\n the periodic boundary or if it moves through the membrane.\n\n The crossing number is calculated as the mean of two subsequent domain index\n differences. If they have opposite sign, the crossing number will be zero\n and the row will be dropped. If they have the same sign, this indicates that\n the particle moved either from domain -1 to domain 0 to domain +1 or from\n domain +1 to domain 0 to domain -1, corresponding to a true crossing event.\n The sign of the crossing number will reflect the direction of the crossing.\n \"\"\"\n\n # make copy of input data frame to avoid overwriting contents:\n df = df.copy()\n\n # make sure data frame has even number of rows:\n if df.shape[0] % 2 is not 0:\n df = df.iloc[:-1]\n\n # introduce pairing index:\n df[\"pairing\"] = np.repeat(range(0, int(df.shape[0]/2)), 2)\n\n # calculate summry statistics over pairings:\n df[\"crossing_number\"] = df.groupby(\"pairing\").domain_diff.transform(\"mean\")\n df[\"t_enter\"] = df.groupby(\"pairing\").t.transform(\"min\")\n df[\"t_mean\"] = df.groupby(\"pairing\").t.transform(\"mean\")\n df[\"t_exit\"] = df.groupby(\"pairing\").t.transform(\"max\")\n df = df.groupby([\"pairing\", \"name\"]).mean()\n\n # remove all rows not corresponding to a crossing event:\n df = df.loc[df.domain_diff != 0.0, ]\n\n # return data frame to caller:\n return(df)\n\n\ndef identify_crossing_events(df):\n \"\"\"Identifies pore crossing events in data frame of domain indices.\n\n Given a data frame of domain indices alongside time stamps and particle IDs,\n this function identifies crossing events, i.e. a particle moving from one\n side of the membrane to the other THROUGH THE PORE REGION. Cases where a\n particle moves through the periodic boundary or through the membrane itself\n (i.e. outside the cylindrical protein region) are not counted as crossing\n events.\n\n The return value is a data frame in which each row corresponds to a\n crossing event and the columns identify times at which the particle entered\n and exited the pore, the mean of these times, and the ID of the particle\n which crosses the pore. Note that the input data frame should contain only\n a single unique particle ID, i.e. this function should by run on the domain\n index data frame grouped by particle indices. In addition, a further column\n contains a crossing number indicating the direction in which the particle\n passed the pore.\n\n This is done by first calculating the difference between subsequent domain\n indices. Where this difference is zero, the particle stayed in the given\n domain and the corresponding row can be ignored. Where this difference is\n +1/-1, the particle moved into or out of the pore. Where the difference is\n +2/-2, the particle moved across the periodic boundary or through the\n membrane.\n\n The time series of domain index differences is then partitioned into\n individual series between periodic boundary jump events. In each such\n subdivision the target particle is known to start outside the pore domain.\n A crossing event can then be identified by averaging over the sum of\n pairs of subsequent domain index differences. Note that for a particle that\n starts out inside the pore domain at the beginning of the trajectory no\n clear crossing direction can be established (i.e. is it going back to the\n domain it came from or is it moving across the pore to the opposite domain).\n By convention, these events will therefore not be counted as pore crossing\n events.\n \"\"\"\n\n # make copy of input data frame to avoid overwriting contents:\n df = df.copy()\n\n # calculate difference between subsequent indices:\n df[\"domain_diff\"] = df[\"domain_idx\"].shift(0) - df[\"domain_idx\"].shift(1)\n df[\"t\"] = 0.5*(df[\"t\"].shift(0) + df[\"t\"].shift(1))\n df = df.dropna()\n df = df.drop(columns=[\"domain_idx\"])\n\n # drop cases where particle did not change domain at all:\n df = df.loc[np.abs(df[\"domain_diff\"]) != 0.0, ]\n\n # create index for number of jumps across period boundary (or through the\n # membrane)\n df[\"pbcjump\"] = 0\n df.pbcjump[(df.domain_diff == -2) | (df.domain_diff == 2)] = 1\n df.pbcjump = df.pbcjump.cumsum()\n\n # drop all pbcjump groupings with less then two non-pbcjump events:\n df = df.loc[(df.domain_diff != -2) & (df.domain_diff != 2), ]\n df[\"pbccount\"] = df.groupby(\"pbcjump\").domain_diff.transform(\"count\")\n df = df.loc[df.pbccount > 1, ]\n df = df.drop(columns=[\"pbccount\"])\n\n # handle special case of empty data frame:\n if df.empty is True:\n\n # manually add columns:\n df[\"crossing_number\"] = None\n df[\"t_enter\"] = None\n df[\"t_mean\"] = None\n df[\"t_exit\"] = None\n\n else:\n\n # aggregate pairwise domain index differences:\n df = df.groupby(\"pbcjump\").apply(aggregate_event_pairs)\n\n # remove unneccessary columns and indices:\n df = df.drop(columns=[\"t\", \"domain_diff\", \"pbcjump\"])\n df = df.reset_index(drop=True)\n\n # return data frame:\n return(df)\n\n\ndef main(argdict):\n \"\"\"Main function for entry point checking.\n\n Expects to be given a dictionary of command line arguments.\n \"\"\"\n\n # parse trajectory and assign domain indices:\n print(\"--> identifying domain indices...\")\n nm2ang = 10.0\n domain_indices = determine_domain_indices(\n argdict[\"s\"],\n argdict[\"f\"],\n argdict[\"sel_pore\"],\n argdict[\"sel_bilayer\"],\n argdict[\"sel_target\"],\n argdict[\"r_margin\"] * nm2ang,\n argdict[\"z_margin\"] * nm2ang,\n argdict[\"b\"],\n argdict[\"e\"],\n argdict[\"dt\"]\n )\n\n # find crossing events by particle:\n print(\"--> identifying crossing events...\")\n crossing_events = (\n domain_indices.groupby([\"particle_id\"]).apply(identify_crossing_events)\n )\n crossing_events = crossing_events.reset_index(drop=True)\n\n # restore atom and residue names:\n name = domain_indices.groupby(\"particle_id\").name.first()\n crossing_events[\"name\"] = np.array(name.loc[crossing_events.particle_id])\n crossing_events[\"resname\"] = np.array(name.loc[crossing_events.particle_id])\n\n # serialize results:\n crossing_events.to_json(argdict[\"o\"], orient=\"records\")\n with open(argdict[\"o\"], \"a\") as f:\n f.write(\"\\n\")\n\n\n# entry point check:\nif __name__ == \"__main__\":\n\n # turn off this warning:\n pd.options.mode.chained_assignment = None\n\n # parse command line arguments:\n parser = argparse.ArgumentParser(\n description=__doc__,\n formatter_class=argparse.ArgumentDefaultsHelpFormatter\n )\n parser.add_argument(\n \"-s\",\n type=str,\n nargs=None,\n default=\"production.tpr\",\n help=\"\"\"Topology file. Should contain charges and masses!\"\"\"\n )\n parser.add_argument(\n \"-f\",\n type=str,\n nargs=None,\n default=\"production.xtc\",\n help=\"\"\"Trajectory file name.\"\"\"\n )\n parser.add_argument(\n \"-o\",\n type=str,\n nargs=None,\n default=\"crossing_events.json\",\n help=\"\"\"Name of output JSON file containing all crossing events.\"\"\"\n )\n parser.add_argument(\n \"-sel_target\",\n type=str,\n nargs=None,\n default=\"resname NA CL\",\n help=\"\"\"MDAnalysis selection identifying the mobile particles\n crossing the pore.\"\"\"\n )\n parser.add_argument(\n \"-sel_pore\",\n type=str,\n nargs=None,\n default=\"protein\",\n help=\"\"\"MDAnalysis selection identifying the channel domain.\"\"\"\n )\n parser.add_argument(\n \"-sel_bilayer\",\n type=str,\n nargs=None,\n default=\"resname DOPC POPC\",\n help=\"\"\"MDAnalysis selection identifying the lipid bilayer.\"\"\"\n )\n parser.add_argument(\n \"-r_margin\",\n type=float,\n nargs=None,\n default=0.0,\n help=\"\"\"Radius margin around protein for identification of pore\n domain in nanometers. The pore domain is taken to be a cylinder whose\n radius is the radius of the protein (in the x/y-plane) plus this\n margin.\"\"\"\n )\n parser.add_argument(\n \"-z_margin\",\n type=float,\n nargs=None,\n default=-1.0,\n help=\"\"\"Margin for extension of pore domain around protein in\n nanometers. The pore domain is taken to be a cylinder whose the\n extension is determined from the z-extension of the protein plus this\n margin. Should never exceed half the length of the pore.\"\"\"\n )\n parser.add_argument(\n \"-b\",\n type=float,\n nargs=None,\n default=0.0,\n help=\"\"\"Start time for trajectory analysis in picoseconds. Frames\n before this time will be ignored.\"\"\"\n )\n parser.add_argument(\n \"-e\",\n type=float,\n nargs=None,\n default=float(\"inf\"),\n help=\"\"\"End time for trajectory analysis in picoseconds. Frames\n after this time will be ignored.\"\"\"\n )\n parser.add_argument(\n \"-dt\",\n type=float,\n nargs=None,\n default=100.0,\n help=\"\"\"Time step for trajectroy analysis. Frames not that are not\n an integer multiple of this time step will be ignored. A time step of\n 100 picoseconds seems to be sufficiently small for ions.\"\"\"\n )\n\n # parse arguments and convert to dictionary:\n args = parser.parse_args()\n argdict = vars(args)\n\n # pass arguments to main function:\n main(argdict)\n", "meta": {"hexsha": "fbd6d3a91a7cdb343f96d9505fc3aedf0cf9ab68", "size": 16379, "ext": "py", "lang": "Python", "max_stars_repo_path": "scripts/ion-transport/identify_crossing_events.py", "max_stars_repo_name": "Inniag/nanopore-electrowetting-scripts", "max_stars_repo_head_hexsha": "5539a2b6f7b06ae8b386cf3cb1d9b9bce2c5828f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-01-24T17:09:36.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-24T17:09:36.000Z", "max_issues_repo_path": "scripts/ion-transport/identify_crossing_events.py", "max_issues_repo_name": "Inniag/nanopore-electrowetting-scripts", "max_issues_repo_head_hexsha": "5539a2b6f7b06ae8b386cf3cb1d9b9bce2c5828f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "scripts/ion-transport/identify_crossing_events.py", "max_forks_repo_name": "Inniag/nanopore-electrowetting-scripts", "max_forks_repo_head_hexsha": "5539a2b6f7b06ae8b386cf3cb1d9b9bce2c5828f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-11-28T13:52:33.000Z", "max_forks_repo_forks_event_max_datetime": "2020-11-28T13:52:33.000Z", "avg_line_length": 36.6420581655, "max_line_length": 80, "alphanum_fraction": 0.666463154, "include": true, "reason": "import numpy", "num_tokens": 3757, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5039061705290805, "lm_q2_score": 0.3960681662740417, "lm_q1q2_score": 0.19958119293562745}} {"text": "import warnings\n\nimport numpy as np\nimport operator\n\nfrom .. import types, utils, config\nfrom .templates import (AttributeTemplate, AbstractTemplate, CallableTemplate,\n Registry, signature)\n\nfrom ..numpy_support import (ufunc_find_matching_loop,\n supported_ufunc_loop, as_dtype,\n from_dtype, as_dtype, resolve_output_type,\n carray, farray)\nfrom ..errors import TypingError, NumbaPerformanceWarning\nfrom numba import pndindex\n\nregistry = Registry()\ninfer = registry.register\ninfer_global = registry.register_global\ninfer_getattr = registry.register_attr\n\n\nclass Numpy_rules_ufunc(AbstractTemplate):\n @classmethod\n def _handle_inputs(cls, ufunc, args, kws):\n \"\"\"\n Process argument types to a given *ufunc*.\n Returns a (base types, explicit outputs, ndims, layout) tuple where:\n - `base types` is a tuple of scalar types for each input\n - `explicit outputs` is a tuple of explicit output types (arrays)\n - `ndims` is the number of dimensions of the loop and also of\n any outputs, explicit or implicit\n - `layout` is the layout for any implicit output to be allocated\n \"\"\"\n nin = ufunc.nin\n nout = ufunc.nout\n nargs = ufunc.nargs\n\n # preconditions\n assert nargs == nin + nout\n\n if nout > 1:\n msg = \"ufunc '{0}': not supported in this mode (more than 1 output)\"\n raise TypingError(msg=msg.format(ufunc.__name__))\n\n if len(args) < nin:\n msg = \"ufunc '{0}': not enough arguments ({1} found, {2} required)\"\n raise TypingError(msg=msg.format(ufunc.__name__, len(args), nin))\n\n if len(args) > nargs:\n msg = \"ufunc '{0}': too many arguments ({1} found, {2} maximum)\"\n raise TypingError(msg=msg.format(ufunc.__name__, len(args), nargs))\n\n args = [a.as_array if isinstance(a, types.ArrayCompatible) else a\n for a in args]\n arg_ndims = [a.ndim if isinstance(a, types.ArrayCompatible) else 0\n for a in args]\n ndims = max(arg_ndims)\n\n # explicit outputs must be arrays (no explicit scalar return values supported)\n explicit_outputs = args[nin:]\n\n # all the explicit outputs must match the number max number of dimensions\n if not all(d == ndims for d in arg_ndims[nin:]):\n msg = \"ufunc '{0}' called with unsuitable explicit output arrays.\"\n raise TypingError(msg=msg.format(ufunc.__name__))\n\n if not all(isinstance(output, types.ArrayCompatible)\n for output in explicit_outputs):\n msg = \"ufunc '{0}' called with an explicit output that is not an array\"\n raise TypingError(msg=msg.format(ufunc.__name__))\n\n if not all(output.mutable for output in explicit_outputs):\n msg = \"ufunc '{0}' called with an explicit output that is read-only\"\n raise TypingError(msg=msg.format(ufunc.__name__))\n\n # find the kernel to use, based only in the input types (as does NumPy)\n base_types = [x.dtype if isinstance(x, types.ArrayCompatible) else x\n for x in args]\n\n # Figure out the output array layout, if needed.\n layout = None\n if ndims > 0 and (len(explicit_outputs) < ufunc.nout):\n layout = 'C'\n layouts = [x.layout if isinstance(x, types.ArrayCompatible) else ''\n for x in args]\n\n # Prefer C contig if any array is C contig.\n # Next, prefer F contig.\n # Defaults to C contig if not layouts are C/F.\n if 'C' not in layouts and 'F' in layouts:\n layout = 'F'\n\n return base_types, explicit_outputs, ndims, layout\n\n @property\n def ufunc(self):\n return self.key\n\n def generic(self, args, kws):\n ufunc = self.ufunc\n base_types, explicit_outputs, ndims, layout = self._handle_inputs(\n ufunc, args, kws)\n ufunc_loop = ufunc_find_matching_loop(ufunc, base_types)\n if ufunc_loop is None:\n raise TypingError(\"can't resolve ufunc {0} for types {1}\".format(ufunc.__name__, args))\n\n # check if all the types involved in the ufunc loop are supported in this mode\n if not supported_ufunc_loop(ufunc, ufunc_loop):\n msg = \"ufunc '{0}' using the loop '{1}' not supported in this mode\"\n raise TypingError(msg=msg.format(ufunc.__name__, ufunc_loop.ufunc_sig))\n\n # if there is any explicit output type, check that it is valid\n explicit_outputs_np = [as_dtype(tp.dtype) for tp in explicit_outputs]\n\n # Numpy will happily use unsafe conversions (although it will actually warn)\n if not all (np.can_cast(fromty, toty, 'unsafe') for (fromty, toty) in\n zip(ufunc_loop.numpy_outputs, explicit_outputs_np)):\n msg = \"ufunc '{0}' can't cast result to explicit result type\"\n raise TypingError(msg=msg.format(ufunc.__name__))\n\n # A valid loop was found that is compatible. The result of type inference should\n # be based on the explicit output types, and when not available with the type given\n # by the selected NumPy loop\n out = list(explicit_outputs)\n implicit_output_count = ufunc.nout - len(explicit_outputs)\n if implicit_output_count > 0:\n # XXX this is currently wrong for datetime64 and timedelta64,\n # as ufunc_find_matching_loop() doesn't do any type inference.\n ret_tys = ufunc_loop.outputs[-implicit_output_count:]\n if ndims > 0:\n assert layout is not None\n ret_tys = [types.Array(dtype=ret_ty, ndim=ndims, layout=layout)\n for ret_ty in ret_tys]\n ret_tys = [resolve_output_type(self.context, args, ret_ty)\n for ret_ty in ret_tys]\n out.extend(ret_tys)\n\n # note: although the previous code should support multiple return values, only one\n # is supported as of now (signature may not support more than one).\n # there is an check enforcing only one output\n out.extend(args)\n return signature(*out)\n\n\n@infer_global(operator.pos)\nclass UnaryPositiveArray(AbstractTemplate):\n '''Typing template class for +(array) expressions. This operator is\n special because there is no Numpy ufunc associated with it; we\n include typing for it here (numba.typing.npydecl) because this is\n where the remaining array operators are defined.\n '''\n key = operator.pos\n\n def generic(self, args, kws):\n assert not kws\n if len(args) == 1 and isinstance(args[0], types.ArrayCompatible):\n arg_ty = args[0]\n return arg_ty.copy()(arg_ty)\n\n\nclass NumpyRulesArrayOperator(Numpy_rules_ufunc):\n _op_map = {\n operator.add: \"add\",\n operator.sub: \"subtract\",\n operator.mul: \"multiply\",\n operator.truediv: \"true_divide\",\n operator.floordiv: \"floor_divide\",\n operator.mod: \"remainder\",\n operator.pow: \"power\",\n operator.lshift: \"left_shift\",\n operator.rshift: \"right_shift\",\n operator.and_: \"bitwise_and\",\n operator.or_: \"bitwise_or\",\n operator.xor: \"bitwise_xor\",\n operator.eq: \"equal\",\n operator.gt: \"greater\",\n operator.ge: \"greater_equal\",\n operator.lt: \"less\",\n operator.le: \"less_equal\",\n operator.ne: \"not_equal\",\n }\n\n @property\n def ufunc(self):\n return getattr(np, self._op_map[self.key])\n\n @classmethod\n def install_operations(cls):\n for op, ufunc_name in cls._op_map.items():\n infer_global(op)(\n type(\"NumpyRulesArrayOperator_\" + ufunc_name, (cls,), dict(key=op))\n )\n\n def generic(self, args, kws):\n '''Overloads and calls base class generic() method, returning\n None if a TypingError occurred.\n\n Returning None for operators is important since operators are\n heavily overloaded, and by suppressing type errors, we allow\n type inference to check other possibilities before giving up\n (particularly user-defined operators).\n '''\n try:\n sig = super(NumpyRulesArrayOperator, self).generic(args, kws)\n except TypingError:\n return None\n if sig is None:\n return None\n args = sig.args\n # Only accept at least one array argument, otherwise the operator\n # doesn't involve Numpy's ufunc machinery.\n if not any(isinstance(arg, types.ArrayCompatible)\n for arg in args):\n return None\n return sig\n\n\n_binop_map = NumpyRulesArrayOperator._op_map\n\nclass NumpyRulesInplaceArrayOperator(NumpyRulesArrayOperator):\n _op_map = {\n operator.iadd: \"add\",\n operator.isub: \"subtract\",\n operator.imul: \"multiply\",\n operator.itruediv: \"true_divide\",\n operator.ifloordiv: \"floor_divide\",\n operator.imod: \"remainder\",\n operator.ipow: \"power\",\n operator.ilshift: \"left_shift\",\n operator.irshift: \"right_shift\",\n operator.iand: \"bitwise_and\",\n operator.ior: \"bitwise_or\",\n operator.ixor: \"bitwise_xor\",\n }\n\n def generic(self, args, kws):\n # Type the inplace operator as if an explicit output was passed,\n # to handle type resolution correctly.\n # (for example int8[:] += int16[:] should use an int8[:] output,\n # not int16[:])\n lhs, rhs = args\n if not isinstance(lhs, types.ArrayCompatible):\n return\n args = args + (lhs,)\n sig = super(NumpyRulesInplaceArrayOperator, self).generic(args, kws)\n # Strip off the fake explicit output\n assert len(sig.args) == 3\n real_sig = signature(sig.return_type, *sig.args[:2])\n return real_sig\n\n\nclass NumpyRulesUnaryArrayOperator(NumpyRulesArrayOperator):\n _op_map = {\n # Positive is a special case since there is no Numpy ufunc\n # corresponding to it (it's essentially an identity operator).\n # See UnaryPositiveArray, above.\n operator.neg: \"negative\",\n operator.invert: \"invert\",\n }\n\n def generic(self, args, kws):\n assert not kws\n if len(args) == 1 and isinstance(args[0], types.ArrayCompatible):\n return super(NumpyRulesUnaryArrayOperator, self).generic(args, kws)\n\n\n# list of unary ufuncs to register\n\n_math_operations = [ \"add\", \"subtract\", \"multiply\",\n \"logaddexp\", \"logaddexp2\", \"true_divide\",\n \"floor_divide\", \"negative\", \"power\",\n \"remainder\", \"fmod\", \"absolute\",\n \"rint\", \"sign\", \"conjugate\", \"exp\", \"exp2\",\n \"log\", \"log2\", \"log10\", \"expm1\", \"log1p\",\n \"sqrt\", \"square\", \"reciprocal\",\n \"divide\", \"mod\", \"abs\", \"fabs\" , \"gcd\", \"lcm\"]\n\n_trigonometric_functions = [ \"sin\", \"cos\", \"tan\", \"arcsin\",\n \"arccos\", \"arctan\", \"arctan2\",\n \"hypot\", \"sinh\", \"cosh\", \"tanh\",\n \"arcsinh\", \"arccosh\", \"arctanh\",\n \"deg2rad\", \"rad2deg\", \"degrees\",\n \"radians\" ]\n\n_bit_twiddling_functions = [\"bitwise_and\", \"bitwise_or\",\n \"bitwise_xor\", \"invert\",\n \"left_shift\", \"right_shift\",\n \"bitwise_not\" ]\n\n_comparison_functions = [ \"greater\", \"greater_equal\", \"less\",\n \"less_equal\", \"not_equal\", \"equal\",\n \"logical_and\", \"logical_or\",\n \"logical_xor\", \"logical_not\",\n \"maximum\", \"minimum\", \"fmax\", \"fmin\" ]\n\n_floating_functions = [ \"isfinite\", \"isinf\", \"isnan\", \"signbit\",\n \"copysign\", \"nextafter\", \"modf\", \"ldexp\",\n \"frexp\", \"floor\", \"ceil\", \"trunc\",\n \"spacing\" ]\n\n\n# This is a set of the ufuncs that are not yet supported by Lowering. In order\n# to trigger no-python mode we must not register them until their Lowering is\n# implemented.\n#\n# It also works as a nice TODO list for ufunc support :)\n_unsupported = set([ 'frexp', # this one is tricky, as it has 2 returns\n 'modf', # this one also has 2 returns\n ])\n\n# A list of ufuncs that are in fact aliases of other ufuncs. They need to insert the\n# resolve method, but not register the ufunc itself\n_aliases = set([\"bitwise_not\", \"mod\", \"abs\"])\n\n# In python3 np.divide is mapped to np.true_divide\nif np.divide == np.true_divide:\n _aliases.add(\"divide\")\n\ndef _numpy_ufunc(name):\n func = getattr(np, name)\n class typing_class(Numpy_rules_ufunc):\n key = func\n\n typing_class.__name__ = \"resolve_{0}\".format(name)\n\n if not name in _aliases:\n infer_global(func, types.Function(typing_class))\n\nall_ufuncs = sum([_math_operations, _trigonometric_functions,\n _bit_twiddling_functions, _comparison_functions,\n _floating_functions], [])\n\nsupported_ufuncs = [x for x in all_ufuncs if x not in _unsupported]\n\nfor func in supported_ufuncs:\n _numpy_ufunc(func)\n\nall_ufuncs = [getattr(np, name) for name in all_ufuncs]\nsupported_ufuncs = [getattr(np, name) for name in supported_ufuncs]\n\nNumpyRulesUnaryArrayOperator.install_operations()\nNumpyRulesArrayOperator.install_operations()\nNumpyRulesInplaceArrayOperator.install_operations()\n\nsupported_array_operators = set(\n NumpyRulesUnaryArrayOperator._op_map.keys()\n).union(\n NumpyRulesArrayOperator._op_map.keys()\n).union(\n NumpyRulesInplaceArrayOperator._op_map.keys()\n)\n\ndel _math_operations, _trigonometric_functions, _bit_twiddling_functions\ndel _comparison_functions, _floating_functions, _unsupported\ndel _aliases, _numpy_ufunc\n\n\n# -----------------------------------------------------------------------------\n# Install global helpers for array methods.\n\nclass Numpy_method_redirection(AbstractTemplate):\n \"\"\"\n A template redirecting a Numpy global function (e.g. np.sum) to an\n array method of the same name (e.g. ndarray.sum).\n \"\"\"\n\n def generic(self, args, kws):\n pysig = None\n if kws:\n if self.method_name == 'sum':\n if 'axis' in kws and 'dtype' not in kws:\n def sum_stub(arr, axis):\n pass\n pysig = utils.pysignature(sum_stub)\n elif 'dtype' in kws and 'axis' not in kws:\n def sum_stub(arr, dtype):\n pass\n pysig = utils.pysignature(sum_stub)\n elif 'dtype' in kws and 'axis' in kws:\n def sum_stub(arr, axis, dtype):\n pass\n pysig = utils.pysignature(sum_stub)\n elif self.method_name == 'argsort':\n def argsort_stub(arr, kind='quicksort'):\n pass\n pysig = utils.pysignature(argsort_stub)\n else:\n fmt = \"numba doesn't support kwarg for {}\"\n raise TypingError(fmt.format(self.method_name))\n\n arr = args[0]\n # This will return a BoundFunction\n meth_ty = self.context.resolve_getattr(arr, self.method_name)\n # Resolve arguments on the bound function\n meth_sig = self.context.resolve_function_type(meth_ty, args[1:], kws)\n if meth_sig is not None:\n return meth_sig.as_function().replace(pysig=pysig)\n\n\n# Function to glue attributes onto the numpy-esque object\ndef _numpy_redirect(fname):\n numpy_function = getattr(np, fname)\n cls = type(\"Numpy_redirect_{0}\".format(fname), (Numpy_method_redirection,),\n dict(key=numpy_function, method_name=fname))\n infer_global(numpy_function, types.Function(cls))\n\nfor func in ['min', 'max', 'sum', 'prod', 'mean', 'var', 'std',\n 'cumsum', 'cumprod', 'argmin', 'argmax', 'argsort',\n 'nonzero', 'ravel']:\n _numpy_redirect(func)\n\n\n# -----------------------------------------------------------------------------\n# Numpy scalar constructors\n\n# Register np.int8, etc. as converters to the equivalent Numba types\nnp_types = set(getattr(np, str(nb_type)) for nb_type in types.number_domain)\nnp_types.add(np.bool_)\n# Those may or may not be aliases (depending on the Numpy build / version)\nnp_types.add(np.intc)\nnp_types.add(np.intp)\nnp_types.add(np.uintc)\nnp_types.add(np.uintp)\n\n\ndef register_number_classes(register_global):\n for np_type in np_types:\n nb_type = getattr(types, np_type.__name__)\n\n register_global(np_type, types.NumberClass(nb_type))\n\n\nregister_number_classes(infer_global)\n\n\n# -----------------------------------------------------------------------------\n# Numpy array constructors\n\ndef _parse_shape(shape):\n ndim = None\n if isinstance(shape, types.Integer):\n ndim = 1\n elif isinstance(shape, (types.Tuple, types.UniTuple)):\n if all(isinstance(s, types.Integer) for s in shape):\n ndim = len(shape)\n return ndim\n\ndef _parse_dtype(dtype):\n if isinstance(dtype, types.DTypeSpec):\n return dtype.dtype\n\ndef _parse_nested_sequence(context, typ):\n \"\"\"\n Parse a (possibly 0d) nested sequence type.\n A (ndim, dtype) tuple is returned. Note the sequence may still be\n heterogeneous, as long as it converts to the given dtype.\n \"\"\"\n if isinstance(typ, (types.Buffer,)):\n raise TypingError(\"%r not allowed in a homogeneous sequence\" % typ)\n elif isinstance(typ, (types.Sequence,)):\n n, dtype = _parse_nested_sequence(context, typ.dtype)\n return n + 1, dtype\n elif isinstance(typ, (types.BaseTuple,)):\n if typ.count == 0:\n # Mimick Numpy's behaviour\n return 1, types.float64\n n, dtype = _parse_nested_sequence(context, typ[0])\n dtypes = [dtype]\n for i in range(1, typ.count):\n _n, dtype = _parse_nested_sequence(context, typ[i])\n if _n != n:\n raise TypingError(\"type %r does not have a regular shape\"\n % (typ,))\n dtypes.append(dtype)\n dtype = context.unify_types(*dtypes)\n if dtype is None:\n raise TypingError(\"cannot convert %r to a homogeneous type\" % typ)\n return n + 1, dtype\n else:\n # Scalar type => check it's valid as a Numpy array dtype\n as_dtype(typ)\n return 0, typ\n\n\n\n@infer_global(np.array)\nclass NpArray(CallableTemplate):\n \"\"\"\n Typing template for np.array().\n \"\"\"\n\n def generic(self):\n def typer(object, dtype=None):\n ndim, seq_dtype = _parse_nested_sequence(self.context, object)\n if dtype is None:\n dtype = seq_dtype\n else:\n dtype = _parse_dtype(dtype)\n if dtype is None:\n return\n return types.Array(dtype, ndim, 'C')\n\n return typer\n\n\n@infer_global(np.empty)\n@infer_global(np.zeros)\n@infer_global(np.ones)\nclass NdConstructor(CallableTemplate):\n \"\"\"\n Typing template for np.empty(), .zeros(), .ones().\n \"\"\"\n\n def generic(self):\n def typer(shape, dtype=None):\n if dtype is None:\n nb_dtype = types.double\n else:\n nb_dtype = _parse_dtype(dtype)\n\n ndim = _parse_shape(shape)\n if nb_dtype is not None and ndim is not None:\n return types.Array(dtype=nb_dtype, ndim=ndim, layout='C')\n\n return typer\n\n\n@infer_global(np.empty_like)\n@infer_global(np.zeros_like)\nclass NdConstructorLike(CallableTemplate):\n \"\"\"\n Typing template for np.empty_like(), .zeros_like(), .ones_like().\n \"\"\"\n\n def generic(self):\n \"\"\"\n np.empty_like(array) -> empty array of the same shape and layout\n np.empty_like(scalar) -> empty 0-d array of the scalar type\n \"\"\"\n def typer(arg, dtype=None):\n if dtype is not None:\n nb_dtype = _parse_dtype(dtype)\n elif isinstance(arg, types.Array):\n nb_dtype = arg.dtype\n else:\n nb_dtype = arg\n if nb_dtype is not None:\n if isinstance(arg, types.Array):\n layout = arg.layout if arg.layout != 'A' else 'C'\n return arg.copy(dtype=nb_dtype, layout=layout, readonly=False)\n else:\n return types.Array(nb_dtype, 0, 'C')\n\n return typer\n\n\ninfer_global(np.ones_like)(NdConstructorLike)\n\n\n@infer_global(np.full)\nclass NdFull(CallableTemplate):\n\n def generic(self):\n def typer(shape, fill_value, dtype=None):\n if dtype is None:\n nb_dtype = fill_value\n else:\n nb_dtype = _parse_dtype(dtype)\n\n ndim = _parse_shape(shape)\n if nb_dtype is not None and ndim is not None:\n return types.Array(dtype=nb_dtype, ndim=ndim, layout='C')\n\n return typer\n\n@infer_global(np.full_like)\nclass NdFullLike(CallableTemplate):\n\n def generic(self):\n \"\"\"\n np.full_like(array, val) -> array of the same shape and layout\n np.full_like(scalar, val) -> 0-d array of the scalar type\n \"\"\"\n def typer(arg, fill_value, dtype=None):\n if dtype is not None:\n nb_dtype = _parse_dtype(dtype)\n elif isinstance(arg, types.Array):\n nb_dtype = arg.dtype\n else:\n nb_dtype = arg\n if nb_dtype is not None:\n if isinstance(arg, types.Array):\n return arg.copy(dtype=nb_dtype, readonly=False)\n else:\n return types.Array(dtype=nb_dtype, ndim=0, layout='C')\n\n return typer\n\n\n@infer_global(np.identity)\nclass NdIdentity(AbstractTemplate):\n\n def generic(self, args, kws):\n assert not kws\n n = args[0]\n if not isinstance(n, types.Integer):\n return\n if len(args) >= 2:\n nb_dtype = _parse_dtype(args[1])\n else:\n nb_dtype = types.float64\n\n if nb_dtype is not None:\n return_type = types.Array(ndim=2, dtype=nb_dtype, layout='C')\n return signature(return_type, *args)\n\n\ndef _infer_dtype_from_inputs(inputs):\n return dtype\n\n\n@infer_global(np.linspace)\nclass NdLinspace(AbstractTemplate):\n\n def generic(self, args, kws):\n assert not kws\n bounds = args[:2]\n if not all(isinstance(arg, types.Number) for arg in bounds):\n return\n if len(args) >= 3:\n num = args[2]\n if not isinstance(num, types.Integer):\n return\n if len(args) >= 4:\n # Not supporting the other arguments as it would require\n # keyword arguments for reasonable use.\n return\n if any(isinstance(arg, types.Complex) for arg in bounds):\n dtype = types.complex128\n else:\n dtype = types.float64\n return_type = types.Array(ndim=1, dtype=dtype, layout='C')\n return signature(return_type, *args)\n\n\n@infer_global(np.frombuffer)\nclass NdFromBuffer(CallableTemplate):\n\n def generic(self):\n def typer(buffer, dtype=None):\n if not isinstance(buffer, types.Buffer) or buffer.layout != 'C':\n return\n if dtype is None:\n nb_dtype = types.float64\n else:\n nb_dtype = _parse_dtype(dtype)\n\n if nb_dtype is not None:\n return types.Array(dtype=nb_dtype, ndim=1, layout='C',\n readonly=not buffer.mutable)\n\n return typer\n\n\n@infer_global(np.sort)\nclass NdSort(CallableTemplate):\n\n def generic(self):\n def typer(a):\n if isinstance(a, types.Array) and a.ndim == 1:\n return a\n\n return typer\n\n\n@infer_global(np.asfortranarray)\nclass AsFortranArray(CallableTemplate):\n\n def generic(self):\n def typer(a):\n if isinstance(a, types.Array):\n return a.copy(layout='F', ndim=max(a.ndim, 1))\n\n return typer\n\n\n@infer_global(np.ascontiguousarray)\nclass AsContiguousArray(CallableTemplate):\n\n def generic(self):\n def typer(a):\n if isinstance(a, types.Array):\n return a.copy(layout='C', ndim=max(a.ndim, 1))\n\n return typer\n\n\n@infer_global(np.copy)\nclass NdCopy(CallableTemplate):\n\n def generic(self):\n def typer(a):\n if isinstance(a, types.Array):\n layout = 'F' if a.layout == 'F' else 'C'\n return a.copy(layout=layout, readonly=False)\n\n return typer\n\n\n@infer_global(np.expand_dims)\nclass NdExpandDims(CallableTemplate):\n\n def generic(self):\n def typer(a, axis):\n if (not isinstance(a, types.Array)\n or not isinstance(axis, types.Integer)):\n return\n\n layout = a.layout if a.ndim <= 1 else 'A'\n return a.copy(ndim=a.ndim + 1, layout=layout)\n\n return typer\n\n\nclass BaseAtLeastNdTemplate(AbstractTemplate):\n\n def generic(self, args, kws):\n assert not kws\n if not args or not all(isinstance(a, types.Array) for a in args):\n return\n\n rets = [self.convert_array(a) for a in args]\n if len(rets) > 1:\n retty = types.BaseTuple.from_types(rets)\n else:\n retty = rets[0]\n return signature(retty, *args)\n\n\n@infer_global(np.atleast_1d)\nclass NdAtLeast1d(BaseAtLeastNdTemplate):\n\n def convert_array(self, a):\n return a.copy(ndim=max(a.ndim, 1))\n\n\n@infer_global(np.atleast_2d)\nclass NdAtLeast2d(BaseAtLeastNdTemplate):\n\n def convert_array(self, a):\n return a.copy(ndim=max(a.ndim, 2))\n\n\n@infer_global(np.atleast_3d)\nclass NdAtLeast3d(BaseAtLeastNdTemplate):\n\n def convert_array(self, a):\n return a.copy(ndim=max(a.ndim, 3))\n\n\ndef _homogeneous_dims(context, func_name, arrays):\n ndim = arrays[0].ndim\n for a in arrays:\n if a.ndim != ndim:\n raise TypeError(\"%s(): all the input arrays \"\n \"must have same number of dimensions\"\n % func_name)\n return ndim\n\ndef _sequence_of_arrays(context, func_name, arrays,\n dim_chooser=_homogeneous_dims):\n if (not isinstance(arrays, types.BaseTuple)\n or not len(arrays)\n or not all(isinstance(a, types.Array) for a in arrays)):\n raise TypeError(\"%s(): expecting a non-empty tuple of arrays, \"\n \"got %s\" % (func_name, arrays))\n\n ndim = dim_chooser(context, func_name, arrays)\n\n dtype = context.unify_types(*(a.dtype for a in arrays))\n if dtype is None:\n raise TypeError(\"%s(): input arrays must have \"\n \"compatible dtypes\" % func_name)\n\n return dtype, ndim\n\ndef _choose_concatenation_layout(arrays):\n # Only create a F array if all input arrays have F layout.\n # This is a simplified version of Numpy's behaviour,\n # while Numpy's actually processes the input strides to\n # decide on optimal output strides\n # (see PyArray_CreateMultiSortedStridePerm()).\n return 'F' if all(a.layout == 'F' for a in arrays) else 'C'\n\n\n@infer_global(np.concatenate)\nclass NdConcatenate(CallableTemplate):\n\n def generic(self):\n def typer(arrays, axis=None):\n if axis is not None and not isinstance(axis, types.Integer):\n # Note Numpy allows axis=None, but it isn't documented:\n # https://github.com/numpy/numpy/issues/7968\n return\n\n dtype, ndim = _sequence_of_arrays(self.context,\n \"np.concatenate\", arrays)\n if ndim == 0:\n raise TypeError(\"zero-dimensional arrays cannot be concatenated\")\n\n layout = _choose_concatenation_layout(arrays)\n\n return types.Array(dtype, ndim, layout)\n\n return typer\n\n\n@infer_global(np.stack)\nclass NdStack(CallableTemplate):\n\n def generic(self):\n def typer(arrays, axis=None):\n if axis is not None and not isinstance(axis, types.Integer):\n # Note Numpy allows axis=None, but it isn't documented:\n # https://github.com/numpy/numpy/issues/7968\n return\n\n dtype, ndim = _sequence_of_arrays(self.context,\n \"np.stack\", arrays)\n\n # This diverges from Numpy's behaviour, which simply inserts\n # a new stride at the requested axis (therefore can return\n # a 'A' array).\n layout = 'F' if all(a.layout == 'F' for a in arrays) else 'C'\n\n return types.Array(dtype, ndim + 1, layout)\n\n return typer\n\n\nclass BaseStackTemplate(CallableTemplate):\n\n def generic(self):\n def typer(arrays):\n dtype, ndim = _sequence_of_arrays(self.context,\n self.func_name, arrays)\n\n ndim = max(ndim, self.ndim_min)\n layout = _choose_concatenation_layout(arrays)\n\n return types.Array(dtype, ndim, layout)\n\n return typer\n\n\n@infer_global(np.hstack)\nclass NdStack(BaseStackTemplate):\n func_name = \"np.hstack\"\n ndim_min = 1\n\n@infer_global(np.vstack)\nclass NdStack(BaseStackTemplate):\n func_name = \"np.vstack\"\n ndim_min = 2\n\n@infer_global(np.dstack)\nclass NdStack(BaseStackTemplate):\n func_name = \"np.dstack\"\n ndim_min = 3\n\n\n\ndef _column_stack_dims(context, func_name, arrays):\n # column_stack() allows stacking 1-d and 2-d arrays together\n for a in arrays:\n if a.ndim < 1 or a.ndim > 2:\n raise TypeError(\"np.column_stack() is only defined on \"\n \"1-d and 2-d arrays\")\n return 2\n\n\n@infer_global(np.column_stack)\nclass NdColumnStack(CallableTemplate):\n\n def generic(self):\n def typer(arrays):\n dtype, ndim = _sequence_of_arrays(self.context,\n \"np.column_stack\", arrays,\n dim_chooser=_column_stack_dims)\n\n layout = _choose_concatenation_layout(arrays)\n\n return types.Array(dtype, ndim, layout)\n\n return typer\n\n\n# -----------------------------------------------------------------------------\n# Linear algebra\n\n\nclass MatMulTyperMixin(object):\n\n def matmul_typer(self, a, b, out=None):\n \"\"\"\n Typer function for Numpy matrix multiplication.\n \"\"\"\n if not isinstance(a, types.Array) or not isinstance(b, types.Array):\n return\n if not all(x.ndim in (1, 2) for x in (a, b)):\n raise TypingError(\"%s only supported on 1-D and 2-D arrays\"\n % (self.func_name, ))\n # Output dimensionality\n ndims = set([a.ndim, b.ndim])\n if ndims == set([2]):\n # M * M\n out_ndim = 2\n elif ndims == set([1, 2]):\n # M* V and V * M\n out_ndim = 1\n elif ndims == set([1]):\n # V * V\n out_ndim = 0\n\n if out is not None:\n if out_ndim == 0:\n raise TypeError(\"explicit output unsupported for vector * vector\")\n elif out.ndim != out_ndim:\n raise TypeError(\"explicit output has incorrect dimensionality\")\n if not isinstance(out, types.Array) or out.layout != 'C':\n raise TypeError(\"output must be a C-contiguous array\")\n all_args = (a, b, out)\n else:\n all_args = (a, b)\n\n if not (config.DISABLE_PERFORMANCE_WARNINGS or\n all(x.layout in 'CF' for x in (a, b))):\n msg = (\"%s is faster on contiguous arrays, called on %s\" %\n (self.func_name, (a, b)))\n warnings.warn(NumbaPerformanceWarning(msg))\n if not all(x.dtype == a.dtype for x in all_args):\n raise TypingError(\"%s arguments must all have \"\n \"the same dtype\" % (self.func_name,))\n if not isinstance(a.dtype, (types.Float, types.Complex)):\n raise TypingError(\"%s only supported on \"\n \"float and complex arrays\"\n % (self.func_name,))\n if out:\n return out\n elif out_ndim > 0:\n return types.Array(a.dtype, out_ndim, 'C')\n else:\n return a.dtype\n\n\n@infer_global(np.dot)\nclass Dot(MatMulTyperMixin, CallableTemplate):\n func_name = \"np.dot()\"\n\n def generic(self):\n def typer(a, b, out=None):\n # NOTE: np.dot() and the '@' operator have distinct semantics\n # for >2-D arrays, but we don't support them.\n return self.matmul_typer(a, b, out)\n\n return typer\n\n\n@infer_global(np.vdot)\nclass VDot(CallableTemplate):\n\n def generic(self):\n def typer(a, b):\n if not isinstance(a, types.Array) or not isinstance(b, types.Array):\n return\n if not all(x.ndim == 1 for x in (a, b)):\n raise TypingError(\"np.vdot() only supported on 1-D arrays\")\n if not all(x.layout in 'CF' for x in (a, b)):\n warnings.warn(\"np.vdot() is faster on contiguous arrays, called on %s\"\n % ((a, b),), NumbaPerformanceWarning)\n if not all(x.dtype == a.dtype for x in (a, b)):\n raise TypingError(\"np.vdot() arguments must all have \"\n \"the same dtype\")\n if not isinstance(a.dtype, (types.Float, types.Complex)):\n raise TypingError(\"np.vdot() only supported on \"\n \"float and complex arrays\")\n return a.dtype\n\n return typer\n\n\n@infer_global(operator.matmul)\nclass MatMul(MatMulTyperMixin, AbstractTemplate):\n key = operator.matmul\n func_name = \"'@'\"\n\n def generic(self, args, kws):\n assert not kws\n restype = self.matmul_typer(*args)\n if restype is not None:\n return signature(restype, *args)\n\n\ndef _check_linalg_matrix(a, func_name):\n if not isinstance(a, types.Array):\n return\n if not a.ndim == 2:\n raise TypingError(\"np.linalg.%s() only supported on 2-D arrays\"\n % func_name)\n if not isinstance(a.dtype, (types.Float, types.Complex)):\n raise TypingError(\"np.linalg.%s() only supported on \"\n \"float and complex arrays\" % func_name)\n\n# -----------------------------------------------------------------------------\n# Miscellaneous functions\n\n@infer_global(np.ndenumerate)\nclass NdEnumerate(AbstractTemplate):\n\n def generic(self, args, kws):\n assert not kws\n arr, = args\n\n if isinstance(arr, types.Array):\n enumerate_type = types.NumpyNdEnumerateType(arr)\n return signature(enumerate_type, *args)\n\n\n@infer_global(np.nditer)\nclass NdIter(AbstractTemplate):\n\n def generic(self, args, kws):\n assert not kws\n if len(args) != 1:\n return\n arrays, = args\n\n if isinstance(arrays, types.BaseTuple):\n if not arrays:\n return\n arrays = list(arrays)\n else:\n arrays = [arrays]\n nditerty = types.NumpyNdIterType(arrays)\n return signature(nditerty, *args)\n\n\n@infer_global(pndindex)\n@infer_global(np.ndindex)\nclass NdIndex(AbstractTemplate):\n\n def generic(self, args, kws):\n assert not kws\n\n # Either ndindex(shape) or ndindex(*shape)\n if len(args) == 1 and isinstance(args[0], types.BaseTuple):\n tup = args[0]\n if tup.count > 0 and not isinstance(tup, types.UniTuple):\n # Heterogeneous tuple\n return\n shape = list(tup)\n else:\n shape = args\n\n if all(isinstance(x, types.Integer) for x in shape):\n iterator_type = types.NumpyNdIndexType(len(shape))\n return signature(iterator_type, *args)\n\n\n# We use the same typing key for np.round() and np.around() to\n# re-use the implementations automatically.\n@infer_global(np.round)\n@infer_global(np.around, typing_key=np.round)\nclass Round(AbstractTemplate):\n\n def generic(self, args, kws):\n assert not kws\n assert 1 <= len(args) <= 3\n\n arg = args[0]\n if len(args) == 1:\n decimals = types.intp\n out = None\n else:\n decimals = args[1]\n if len(args) == 2:\n out = None\n else:\n out = args[2]\n\n supported_scalars = (types.Integer, types.Float, types.Complex)\n if isinstance(arg, supported_scalars):\n assert out is None\n return signature(arg, *args)\n if (isinstance(arg, types.Array) and isinstance(arg.dtype, supported_scalars) and\n isinstance(out, types.Array) and isinstance(out.dtype, supported_scalars) and\n out.ndim == arg.ndim):\n # arg can only be complex if out is complex too\n if (not isinstance(arg.dtype, types.Complex)\n or isinstance(out.dtype, types.Complex)):\n return signature(out, *args)\n\n\n@infer_global(np.where)\nclass Where(AbstractTemplate):\n\n def generic(self, args, kws):\n assert not kws\n\n if len(args) == 1:\n # 0-dim arrays return one result array\n ary = args[0]\n ndim = max(ary.ndim, 1)\n retty = types.UniTuple(types.Array(types.intp, 1, 'C'), ndim)\n return signature(retty, ary)\n\n elif len(args) == 3:\n cond, x, y = args\n retdty = from_dtype(np.promote_types(\n as_dtype(getattr(args[1], 'dtype', args[1])),\n as_dtype(getattr(args[2], 'dtype', args[2]))))\n if isinstance(cond, types.Array):\n # array where()\n if isinstance(x, types.Array) and isinstance(y, types.Array):\n if (cond.ndim == x.ndim == y.ndim):\n if x.layout == y.layout == cond.layout:\n retty = types.Array(retdty, x.ndim, x.layout)\n else:\n retty = types.Array(retdty, x.ndim, 'C')\n return signature(retty, *args)\n else:\n # x and y both scalar\n retty = types.Array(retdty, cond.ndim, cond.layout)\n return signature(retty, *args)\n else:\n # scalar where()\n if not isinstance(x, types.Array):\n retty = types.Array(retdty, 0, 'C')\n return signature(retty, *args)\n\n\n@infer_global(np.sinc)\nclass Sinc(AbstractTemplate):\n\n def generic(self, args, kws):\n assert not kws\n assert len(args) == 1\n arg = args[0]\n supported_scalars = (types.Float, types.Complex)\n if (isinstance(arg, supported_scalars) or\n (isinstance(arg, types.Array) and\n isinstance(arg.dtype, supported_scalars))):\n return signature(arg, arg)\n\n\n@infer_global(np.angle)\nclass Angle(CallableTemplate):\n \"\"\"\n Typing template for np.angle()\n \"\"\"\n def generic(self):\n def typer(z, deg=False):\n if isinstance(z, types.Array):\n dtype = z.dtype\n else:\n dtype = z\n if isinstance(dtype, types.Complex):\n ret_dtype = dtype.underlying_float\n elif isinstance(dtype, types.Float):\n ret_dtype = dtype\n else:\n return\n if isinstance(z, types.Array):\n return z.copy(dtype=ret_dtype)\n else:\n return ret_dtype\n return typer\n\n\n@infer_global(np.diag)\nclass DiagCtor(CallableTemplate):\n \"\"\"\n Typing template for np.diag()\n \"\"\"\n def generic(self):\n def typer(ref, k=0):\n if isinstance(ref, types.Array):\n if ref.ndim == 1:\n rdim = 2\n elif ref.ndim == 2:\n rdim = 1\n else:\n return None\n if isinstance(k, (int, types.Integer)):\n return types.Array(ndim=rdim, dtype=ref.dtype, layout='C')\n return typer\n\n\n@infer_global(np.take)\nclass Take(AbstractTemplate):\n\n def generic(self, args, kws):\n assert not kws\n assert len(args) == 2\n arr, ind = args\n if isinstance(ind, types.Number):\n retty = arr.dtype\n elif isinstance(ind, types.Array):\n retty = types.Array(ndim=ind.ndim, dtype=arr.dtype, layout='C')\n elif isinstance(ind, types.List):\n retty = types.Array(ndim=1, dtype=arr.dtype, layout='C')\n elif isinstance(ind, types.BaseTuple):\n retty = types.Array(ndim=np.ndim(ind), dtype=arr.dtype, layout='C')\n else:\n return None\n\n return signature(retty, *args)\n\n# -----------------------------------------------------------------------------\n# Numba helpers\n\n@infer_global(carray)\nclass NumbaCArray(CallableTemplate):\n layout = 'C'\n\n def generic(self):\n func_name = self.key.__name__\n\n def typer(ptr, shape, dtype=types.none):\n if ptr is types.voidptr:\n ptr_dtype = None\n elif isinstance(ptr, types.CPointer):\n ptr_dtype = ptr.dtype\n else:\n raise TypeError(\"%s(): pointer argument expected, got '%s'\"\n % (func_name, ptr))\n\n if dtype is types.none:\n if ptr_dtype is None:\n raise TypeError(\"%s(): explicit dtype required for void* argument\"\n % (func_name,))\n dtype = ptr_dtype\n elif isinstance(dtype, types.DTypeSpec):\n dtype = dtype.dtype\n if ptr_dtype is not None and dtype != ptr_dtype:\n raise TypeError(\"%s(): mismatching dtype '%s' for pointer type '%s'\"\n % (func_name, dtype, ptr))\n else:\n raise TypeError(\"%s(): invalid dtype spec '%s'\"\n % (func_name, dtype))\n\n ndim = _parse_shape(shape)\n if ndim is None:\n raise TypeError(\"%s(): invalid shape '%s'\"\n % (func_name, shape))\n\n return types.Array(dtype, ndim, self.layout)\n\n return typer\n\n\n@infer_global(farray)\nclass NumbaFArray(NumbaCArray):\n layout = 'F'\n", "meta": {"hexsha": "6ad8e1489ad5010b5b59349e2010de7a78d91b79", "size": 42912, "ext": "py", "lang": "Python", "max_stars_repo_path": "numba/typing/npydecl.py", "max_stars_repo_name": "tolysz/numba", "max_stars_repo_head_hexsha": "d7953a18dbf5ea231dc16e967ce8e9b754578ea6", "max_stars_repo_licenses": ["Apache-2.0", "BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "numba/typing/npydecl.py", "max_issues_repo_name": "tolysz/numba", "max_issues_repo_head_hexsha": "d7953a18dbf5ea231dc16e967ce8e9b754578ea6", "max_issues_repo_licenses": ["Apache-2.0", "BSD-2-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-02-11T13:46:30.000Z", "max_issues_repo_issues_event_max_datetime": "2019-02-11T13:46:30.000Z", "max_forks_repo_path": "numba/typing/npydecl.py", "max_forks_repo_name": "asodeur/numba", "max_forks_repo_head_hexsha": "d7953a18dbf5ea231dc16e967ce8e9b754578ea6", "max_forks_repo_licenses": ["Apache-2.0", "BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.8957345972, "max_line_length": 99, "alphanum_fraction": 0.574408091, "include": true, "reason": "import numpy,from numba", "num_tokens": 9661, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5964331462646254, "lm_q2_score": 0.334589441253186, "lm_q1q2_score": 0.19956023315356078}} {"text": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n\"\"\"Implementation for Single Image Haze Removal Using Dark Channel Prior.\n\nReference:\nhttp://research.microsoft.com/en-us/um/people/kahe/cvpr09/\nhttp://research.microsoft.com/en-us/um/people/kahe/eccv10/\n\"\"\"\n\nimport numpy as np\nfrom PIL import Image\n\nfrom guidedfilter import guided_filter\n\nR, G, B = 0, 1, 2 # index for convenience\nL = 256 # color depth\n\n\ndef get_dark_channel(I, w):\n \"\"\"Get the dark channel prior in the (RGB) image data.\n\n Parameters\n -----------\n I: an M * N * 3 numpy array containing data ([0, L-1]) in the image where\n M is the height, N is the width, 3 represents R/G/B channels.\n w: window size\n\n Return\n -----------\n An M * N array for the dark channel prior ([0, L-1]).\n \"\"\"\n M, N, _ = I.shape\n padded = np.pad(I, ((w / 2, w / 2), (w / 2, w / 2), (0, 0)), 'edge')\n darkch = np.zeros((M, N))\n for i, j in np.ndindex(darkch.shape):\n darkch[i, j] = np.min(padded[i:i + w, j:j + w, :]) # CVPR09, eq.5\n return darkch\n\n\ndef get_atmosphere(I, darkch, p):\n \"\"\"Get the atmosphere light in the (RGB) image data.\n\n Parameters\n -----------\n I: the M * N * 3 RGB image data ([0, L-1]) as numpy array\n darkch: the dark channel prior of the image as an M * N numpy array\n p: percentage of pixels for estimating the atmosphere light\n\n Return\n -----------\n A 3-element array containing atmosphere light ([0, L-1]) for each channel\n \"\"\"\n # reference CVPR09, 4.4\n M, N = darkch.shape\n flatI = I.reshape(M * N, 3)\n flatdark = darkch.ravel()\n searchidx = (-flatdark).argsort()[:M * N * p] # find top M * N * p indexes\n print('atmosphere light region:', [(i / N, i % N) for i in searchidx])\n\n # return the highest intensity for each channel\n return np.max(flatI.take(searchidx, axis=0), axis=0)\n\n\ndef get_transmission(I, A, darkch, omega, w):\n \"\"\"Get the transmission esitmate in the (RGB) image data.\n\n Parameters\n -----------\n I: the M * N * 3 RGB image data ([0, L-1]) as numpy array\n A: a 3-element array containing atmosphere light\n ([0, L-1]) for each channel\n darkch: the dark channel prior of the image as an M * N numpy array\n omega: bias for the estimate\n w: window size for the estimate\n\n Return\n -----------\n An M * N array containing the transmission rate ([0.0, 1.0])\n \"\"\"\n return 1 - omega * get_dark_channel(I / A, w) # CVPR09, eq.12\n\n\ndef dehaze_raw(I, tmin=0.2, Amax=220, w=15, p=0.0001,\n omega=0.95, guided=True, r=40, eps=1e-3):\n \"\"\"Get the dark channel prior, atmosphere light, transmission rate\n and refined transmission rate for raw RGB image data.\n\n Parameters\n -----------\n I: M * N * 3 data as numpy array for the hazy image\n tmin: threshold of transmission rate\n Amax: threshold of atmosphere light\n w: window size of the dark channel prior\n p: percentage of pixels for estimating the atmosphere light\n omega: bias for the transmission estimate\n\n guided: whether to use the guided filter to fine the image\n r: the radius of the guidance\n eps: epsilon for the guided filter\n\n Return\n -----------\n (Idark, A, rawt, refinedt) if guided=False, then rawt == refinedt\n \"\"\"\n m, n, _ = I.shape\n Idark = get_dark_channel(I, w)\n\n A = get_atmosphere(I, Idark, p)\n A = np.minimum(A, Amax) # threshold A\n print('atmosphere', A)\n\n rawt = get_transmission(I, A, Idark, omega, w)\n print('raw transmission rate',)\n print('between [%.4f, %.4f]' % (rawt.min(), rawt.max()))\n\n rawt = refinedt = np.maximum(rawt, tmin) # threshold t\n if guided:\n normI = (I - I.min()) / (I.max() - I.min()) # normalize I\n refinedt = guided_filter(normI, refinedt, r, eps)\n\n print('refined transmission rate',)\n print('between [%.4f, %.4f]' % (refinedt.min(), refinedt.max()))\n\n return Idark, A, rawt, refinedt\n\n\ndef get_radiance(I, A, t):\n \"\"\"Recover the radiance from raw image data with atmosphere light\n and transmission rate estimate.\n\n Parameters\n ----------\n I: M * N * 3 data as numpy array for the hazy image\n A: a 3-element array containing atmosphere light\n ([0, L-1]) for each channel\n t: estimate fothe transmission rate\n\n Return\n ----------\n M * N * 3 numpy array for the recovered radiance\n \"\"\"\n tiledt = np.zeros_like(I) # tiled to M * N * 3\n tiledt[:, :, R] = tiledt[:, :, G] = tiledt[:, :, B] = t\n return (I - A) / tiledt + A # CVPR09, eq.16\n\n\ndef dehaze(im, tmin=0.2, Amax=220, w=15, p=0.0001,\n omega=0.95, guided=True, r=40, eps=1e-3):\n \"\"\"Dehaze the given RGB image.\n\n Parameters\n ----------\n im: the Image object of the RGB image\n guided: refine the dehazing with guided filter or not\n other parameters are the same as `dehaze_raw`\n\n Return\n ----------\n (dark, rawt, refinedt, rawrad, rerad)\n Images for dark channel prior, raw transmission estimate,\n refiend transmission estimate, recovered radiance with raw t,\n recovered radiance with refined t.\n \"\"\"\n I = np.asarray(im, dtype=np.float64)\n Idark, A, rawt, refinedt = dehaze_raw(I, tmin, Amax, w, p,\n omega, guided, r, eps)\n white = np.full_like(Idark, L - 1)\n\n def to_img(raw):\n # threshold to [0, L-1]\n cut = np.maximum(np.minimum(raw, L - 1), 0).astype(np.uint8)\n\n if len(raw.shape) == 3:\n print('Range for each channel:')\n for ch in range(3):\n print('[%.2f, %.2f]' % (raw[:, :, ch].max(), raw[:, :, ch].min()))\n return Image.fromarray(cut)\n else:\n return Image.fromarray(cut)\n\n return [to_img(raw) for raw in (Idark, white * rawt, white * refinedt,\n get_radiance(I, A, rawt),\n get_radiance(I, A, refinedt))]\n", "meta": {"hexsha": "331738b152b5ee3211162b591873fae812b1bfb5", "size": 6018, "ext": "py", "lang": "Python", "max_stars_repo_path": "code/iodh/combined/dark-channel-prior-dehazing/src/dehaze.py", "max_stars_repo_name": "guanlongzhao/dehaze", "max_stars_repo_head_hexsha": "c76346584f8d76502aa854ad9d7e06135ca77bcf", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 32, "max_stars_repo_stars_event_min_datetime": "2018-07-05T01:15:24.000Z", "max_stars_repo_stars_event_max_datetime": "2019-07-23T12:03:51.000Z", "max_issues_repo_path": "code/iodh/combined/dark-channel-prior-dehazing/src/dehaze.py", "max_issues_repo_name": "TAMU-VITA/dehaze", "max_issues_repo_head_hexsha": "c76346584f8d76502aa854ad9d7e06135ca77bcf", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2019-01-12T07:08:20.000Z", "max_issues_repo_issues_event_max_datetime": "2019-04-02T11:13:58.000Z", "max_forks_repo_path": "code/iodh/combined/dark-channel-prior-dehazing/src/dehaze.py", "max_forks_repo_name": "guanlongzhao/dehaze", "max_forks_repo_head_hexsha": "c76346584f8d76502aa854ad9d7e06135ca77bcf", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 9, "max_forks_repo_forks_event_min_datetime": "2018-07-06T02:19:31.000Z", "max_forks_repo_forks_event_max_datetime": "2019-08-02T15:21:43.000Z", "avg_line_length": 32.5297297297, "max_line_length": 82, "alphanum_fraction": 0.5837487537, "include": true, "reason": "import numpy", "num_tokens": 1751, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5964331462646254, "lm_q2_score": 0.33458944125318596, "lm_q1q2_score": 0.19956023315356075}} {"text": "\"\"\"\n\nSource.py\n\nAuthor: Jordan Mirocha\nAffiliation: University of Colorado at Boulder\nCreated on: Sun Jul 22 16:28:08 2012\n\nDescription: Initialize a radiation source.\n\n\"\"\"\n\nimport re, os\nimport numpy as np\nfrom scipy.integrate import quad\nfrom ..util import ParameterFile\nfrom ..physics.Hydrogen import Hydrogen\nfrom ..physics.Cosmology import Cosmology\nfrom ..physics.Constants import erg_per_ev, E_LL\nfrom ..static.IntegralTables import IntegralTable\nfrom ..static.InterpolationTables import LookupTable\nfrom ..util.SetDefaultParameterValues import SourceParameters, \\\n CosmologyParameters\nfrom ..physics.CrossSections import PhotoIonizationCrossSection as sigma_E\n\ntry:\n import h5py\nexcept ImportError:\n pass\n\nnp.seterr(all='ignore') # exp overflow occurs when integrating BB\n # will return 0 as it should for x large\n\ncosmo_pars = CosmologyParameters()\n\nclass Source(object):\n def __init__(self, grid=None, logN=None, init_tabs=True):\n \"\"\" \n Initialize a radiation source object. \n \n ..note:: This is inherited by all other ares.sources classes.\n \n Parameters\n ----------\n grid: rt1d.static.Grid.Grid instance\n logN: column densities over which to tabulate integral quantities\n \n \"\"\" \n \n # Update cosmological parameters\n # Why is this necessary? J.M.12.27.2015\n for par in cosmo_pars:\n if par in self.pf:\n continue\n \n self.pf[par] = cosmo_pars[par]\n \n # Modify parameter file if spectrum_file provided\n #self._load_spectrum() \n \n # Correct emission limits if none were provided\n self.Emin = self.pf['source_Emin']\n self.Emax = self.pf['source_Emax']\n self.logEmin = np.log10(self.Emin)\n self.logEmax = np.log10(self.Emax)\n \n if self.pf['source_EminNorm'] == None:\n self.pf['source_EminNorm'] = self.pf['source_Emin']\n if self.pf['source_EmaxNorm'] == None:\n self.pf['source_EmaxNorm'] = self.pf['source_Emax']\n \n self.EminNorm = self.pf['source_EminNorm']\n self.EmaxNorm = self.pf['source_EmaxNorm'] \n \n # Number of frequencies\n #if self.discrete:\n # self.E = np.array(self.pf['source_E'])\n # self.LE = np.array(self.pf['source_LE'])\n # self.Nfreq = len(self.E)\n # \n #if self.src._name == 'DiffuseSource':\n # self.ionization_rate = self.src.ionization_rate\n # self.secondary_ionization_rate = self.src.secondary_ionization_rate\n # self.heating_rate = self.src.heating_rate\n # \n #self.Lbol = self.Lbol0 = self.BolometricLuminosity(0.0)\n\n # Create lookup tables for integral quantities\n if init_tabs and grid is not None:\n self._create_integral_table(logN=logN)\n \n @property\n def cosm(self):\n if not hasattr(self, '_cosm'):\n if self.grid is None:\n self._cosm = Cosmology(\n omega_m_0=self.pf['omega_m_0'], \n omega_l_0=self.pf['omega_l_0'], \n omega_b_0=self.pf['omega_b_0'], \n hubble_0=self.pf['hubble_0'], \n helium_by_number=self.pf['helium_by_number'], \n cmb_temp_0=self.pf['cmb_temp_0'], \n approx_highz=self.pf['approx_highz'], \n sigma_8=self.pf['sigma_8'], \n primordial_index=self.pf['primordial_index'])\n else:\n self._cosm = self.grid.cosm\n \n return self._cosm\n \n @property\n def multi_freq(self):\n if not hasattr(self, '_multi_freq'):\n self._multi_freq = self.discrete and not self.pf['source_multigroup']\n \n return self._multi_freq \n \n @property \n def multi_group(self): \n if not hasattr(self, '_multi_group'):\n self._multi_group = self.discrete and self.pf['source_multigroup']\n \n return self._multi_group\n \n @property\n def ionizing(self):\n # See if source emits ionizing photons\n # Should also be function of absorbers\n if not hasattr(self, '_ionizing'):\n self._ionizing = self.pf['source_Emax'] > E_LL\n \n return self._ionizing\n \n @property\n def grid(self):\n if not hasattr(self, '_grid'):\n self._grid = None\n \n return self._grid\n \n @grid.setter\n def grid(self, value):\n self._grid = value\n \n @property \n def discrete(self):\n if not hasattr(self, '_discrete'):\n self._discrete = (self.pf['source_E'] != None) #\\\n #or self.pf['optically_thin']\n \n return self._discrete\n \n @property\n def continuous(self):\n if not hasattr(self, '_continuous'):\n self._continuous = not self.discrete\n \n return self._continuous\n\n @property\n def hydr(self):\n if not hasattr(self, '_hydr'):\n self._hydr = None\n \n return self._hydr\n\n @hydr.setter\n def hydr(self, value):\n self._hydr = value\n\n @property\n def frec(self):\n \"\"\"\n Compute average recycling fraction (i.e., spectrum-weighted frec).\n \"\"\" \n \n if self.hydr is None:\n return None\n \n n = np.arange(2, self.hydr.nmax)\n En = np.array(map(self.hydr.ELyn, n))\n In = np.array(map(self.Spectrum, En)) / En\n fr = np.array(map(self.hydr.frec, n))\n \n return np.sum(fr * In) / np.sum(In)\n\n @property\n def intrinsic_hardening(self):\n if not hasattr(self, '_intrinsic_hardening'): \n if 'source_hardening' in self.pf: \n self._intrinsic_hardening = \\\n self.pf['source_hardening'] == 'intrinsic'\n else:\n self._intrinsic_hardening = False\n \n return self._intrinsic_hardening \n \n def _hardening_factor(self, E):\n return np.exp(-10.**self.logN \\\n * (sigma_E(E, 0) + self.cosm.y * sigma_E(E, 1)))\n \n @property\n def logN(self):\n if not hasattr(self, '_logN'):\n if 'source_logN' in self.pf:\n self._logN = self.pf['source_logN']\n else:\n self._logN = -np.inf\n \n return self._logN\n \n @property\n def _normL(self):\n if not hasattr(self, '_normL_'):\n if self.intrinsic_hardening:\n self._normL_ = 1. / quad(self._Intensity,\n self.pf['source_EminNorm'], self.pf['source_EmaxNorm'])[0]\n else: \n integrand = lambda EE: self._Intensity(EE) / self._hardening_factor(EE)\n self._normL_ = 1. / quad(integrand,\n self.pf['source_EminNorm'], self.pf['source_EmaxNorm'])[0]\n \n return self._normL_ \n \n #def _load_spectrum(self):\n # \"\"\" Modify a few parameters if spectrum_file provided. \"\"\"\n # \n # fn = self.pf['spectrum_file']\n # \n # if fn is None:\n # return\n # \n # # Read spectrum - expect hdf5 with (at least) E, LE, and t datasets. \n # if re.search('.hdf5', fn): \n # f = h5py.File(fn)\n # try:\n # self.pf['tables_times'] = f['t'].value\n # except:\n # self.pf['tables_times'] = None\n # self.pf['spectrum_evolving'] = False\n # \n # self.pf['spectrum_E'] = f['E'].value\n # self.pf['spectrum_LE'] = f['LE'].value\n # f.close()\n # \n # if len(self.pf['spectrum_LE'].shape) > 1 \\\n # and not self.pf['spectrum_evolving']:\n # self.pf['spectrum_LE'] = self.pf['spectrum_LE'][0]\n # else: \n # spec = readtab(fn)\n # if len(spec) == 2:\n # self.pf['spectrum_E'], self.pf['spectrum_LE'] = spec\n # else:\n # self.pf['spectrum_E'], self.pf['spectrum_LE'], \\\n # self.pf['spectrum_t'] = spec\n \n @property\n def tables(self):\n if not hasattr(self, '_tables'):\n self._create_integral_table()\n return self._tables \n \n @property\n def tab(self):\n if not hasattr(self, '_tab'):\n self._create_integral_table()\n return self._tab \n \n @property\n def tabs(self):\n if not hasattr(self, '_tabs'):\n self._create_integral_table()\n return self._tabs\n \n def _create_integral_table(self, logN=None):\n \"\"\"\n Take tables and create interpolation functions.\n \"\"\"\n \n if self.discrete:\n return\n \n if self._name == 'diffuse':\n return\n \n if self.pf['source_table'] is None:\n # Overide defaults if supplied - this is dangerous\n if logN is not None:\n self.pf.update({'tables_dlogN': [np.diff(tmp) for tmp in logN]})\n self.pf.update({'tables_logNmin': [np.min(tmp) for tmp in logN]})\n self.pf.update({'tables_logNmax': [np.max(tmp) for tmp in logN]})\n\n # Tabulate away! \n self._tab = IntegralTable(self.pf, self, self.grid, logN)\n self._tabs = self.tab.TabulateRateIntegrals()\n else:\n self._tab = IntegralTable(self.pf, self, self.grid, logN)\n self._tabs = self.tab.load(self.pf['source_table'])\n \n self._setup_interp()\n \n def _setup_interp(self): \n self._tables = {}\n for tab in self.tabs:\n self._tables[tab] = \\\n LookupTable(self.pf, tab, self.tab.logN, self.tabs[tab], \n self.tab.logx, self.tab.t) \n \n @property\n def sigma(self):\n \"\"\"\n Compute bound-free absorption cross-section for all frequencies.\n \"\"\" \n if not self.discrete:\n return None\n if not hasattr(self, '_sigma_all'):\n self._sigma_all = np.array(map(sigma_E, self.E))\n \n return self._sigma_all\n \n @property\n def Qdot(self):\n \"\"\"\n Returns number of photons emitted (s^-1) at all frequencies.\n \"\"\" \n if not hasattr(self, '_Qdot_all'):\n self._Qdot_all = self.Lbol * self.LE / self.E / erg_per_ev\n \n return self._Qdot_all\n \n @property\n def hnu_bar(self):\n \"\"\"\n Average ionizing (per absorber) photon energy in eV.\n \"\"\"\n if not hasattr(self, '_hnu_bar_all'):\n self._hnu_bar_all = np.zeros_like(self.grid.zeros_absorbers)\n self._qdot_bar_all = np.zeros_like(self.grid.zeros_absorbers)\n for i, absorber in enumerate(self.grid.absorbers):\n self._hnu_bar_all[i], self._qdot_bar_all[i] = \\\n self._FrequencyAveragedBin(absorber=absorber)\n \n return self._hnu_bar_all\n \n def AveragePhotonEnergy(self, Emin, Emax):\n \"\"\"\n Return average photon energy in supplied band.\n \"\"\"\n \n integrand = lambda EE: self.Spectrum(EE) * EE\n norm = lambda EE: self.Spectrum(EE)\n \n return quad(integrand, Emin, Emax)[0] / quad(norm, Emin, Emax)[0]\n \n @property\n def qdot_bar(self):\n \"\"\"\n Average ionizing photon luminosity (per absorber) in s^-1.\n \"\"\"\n if not hasattr(self, '_qdot_bar_all'):\n hnu_bar = self.hnu_bar\n \n return self._qdot_bar_all \n \n @property\n def sigma_bar(self):\n \"\"\"\n Frequency averaged cross section (single bandpass).\n \"\"\"\n if not hasattr(self, '_sigma_bar_all'):\n self._sigma_bar_all = np.zeros_like(self.grid.zeros_absorbers)\n for i, absorber in enumerate(self.grid.absorbers):\n integrand = lambda x: self.Spectrum(x) \\\n * self.grid.bf_cross_sections[absorber](x) / x\n \n self._sigma_bar_all[i] = self.Lbol \\\n * quad(integrand, self.grid.ioniz_thresholds[absorber], \n self.Emax)[0] / self.qdot_bar[i] / erg_per_ev\n \n return self._sigma_bar_all\n \n @property\n def sigma_tilde(self):\n if not hasattr(self, '_sigma_tilde_all'):\n self._sigma_tilde_all = np.zeros_like(self.grid.zeros_absorbers)\n for i, absorber in enumerate(self.grid.absorbers):\n integrand = lambda x: self.Spectrum(x) \\\n * self.grid.bf_cross_sections[absorber](x)\n self._sigma_tilde_all[i] = quad(integrand, \n self.grid.ioniz_thresholds[absorber], self.Emax)[0] \\\n / self.fLbol_ionizing[i]\n \n return self._sigma_tilde_all\n \n @property\n def fLbol_ionizing(self):\n \"\"\"\n Fraction of bolometric luminosity emitted above all ionization\n thresholds.\n \"\"\"\n if not hasattr(self, '_fLbol_ioniz_all'):\n self._fLbol_ioniz_all = np.zeros_like(self.grid.zeros_absorbers)\n for i, absorber in enumerate(self.grid.absorbers):\n self._fLbol_ioniz_all[i] = quad(self.Spectrum, \n self.grid.ioniz_thresholds[absorber], self.Emax)[0]\n \n return self._fLbol_ioniz_all\n \n @property\n def Gamma_bar(self):\n \"\"\"\n Return ionization rate (as a function of radius) assuming optical \n depth to cells and of cells is small.\n \"\"\"\n if not hasattr(self, '_Gamma_bar_all'):\n self._Gamma_bar_all = \\\n np.zeros([self.grid.dims, self.grid.N_absorbers])\n for i, absorber in enumerate(self.grid.absorbers):\n self._Gamma_bar_all[..., i] = self.Lbol * self.sigma_bar[i] \\\n * self.fLbol_ionizing[i] / 4. / np.pi / self.grid.r_mid**2 \\\n / self.hnu_bar[i] / erg_per_ev\n \n return self._Gamma_bar_all\n \n @property\n def gamma_bar(self):\n \"\"\"\n Return ionization rate (as a function of radius) assuming optical \n depth to cells and of cells is small.\n \"\"\"\n if not hasattr(self, '_gamma_bar_all'):\n self._gamma_bar_all = \\\n np.zeros([self.grid.dims, self.grid.N_absorbers, \n self.grid.N_absorbers])\n \n if not self.pf['secondary_ionization']:\n return self._gamma_bar_all\n \n for i, absorber in enumerate(self.grid.absorbers):\n for j, otherabsorber in enumerate(self.grid.absorbers):\n self._gamma_bar_all[..., i, j] = self.Gamma_bar[j] \\\n * (self.hnu_bar[j] * self.sigma_tilde[j] \\\n / self.hnu_bar[i] / self.sigma_bar[j] \\\n - self.grid.ioniz_thresholds[otherabsorber] \\\n / self.grid.ioniz_thresholds[absorber])\n \n return self._gamma_bar_all\n \n @property\n def Heat_bar(self):\n \"\"\"\n Return ionization rate (as a function of radius) assuming optical \n depth to cells and of cells is small.\n \"\"\"\n if not hasattr(self, '_Heat_bar_all'):\n self._Heat_bar_all = \\\n np.zeros([self.grid.dims, self.grid.N_absorbers])\n for i, absorber in enumerate(self.grid.absorbers):\n self._Heat_bar_all[..., i] = self.Gamma_bar[..., i] \\\n * erg_per_ev * (self.hnu_bar[i] * self.sigma_tilde[i] \\\n / self.sigma_bar[i] - self.grid.ioniz_thresholds[absorber])\n \n return self._Heat_bar_all\n \n def IonizingPhotonLuminosity(self, t=0, bin=None):\n \"\"\"\n Return Qdot (photons / s) for this source at energy E.\n \"\"\"\n \n if self.pf['source_type'] in [0, 1, 2]:\n return self.Qdot[bin]\n else:\n # Currently only BHs have a time-varying bolometric luminosity\n return self.BolometricLuminosity(t) * self.LE[bin] / self.E[bin] / erg_per_ev \n \n #def _Intensity(self, E, i, Type, t=0, absorb=True):\n # \"\"\"\n # Return quantity *proportional* to fraction of bolometric luminosity emitted\n # at photon energy E. Normalization handled separately.\n # \"\"\"\n # \n # Lnu = self.src._Intensity(E, i, Type, t=t)\n # \n # # Apply absorbing column\n # if self.SpectrumPars['logN'][i] > 0 and absorb:\n # return Lnu * np.exp(-10.**self.SpectrumPars['logN'][i] \\\n # * (sigma_E(E, 0) + y * sigma_E(E, 1))) \n # else:\n # return Lnu \n # \n def Spectrum(self, E, t=0.0):\n r\"\"\"\n Return fraction of bolometric luminosity emitted at energy E.\n \n Elsewhere denoted as :math:`I_{\\nu}`, normalized such that\n :math:`\\int I_{\\nu} d\\nu = 1`\n \n Parameters\n ----------\n E: float\n Emission energy in eV\n t: float\n Time in seconds since source turned on. \n i: int\n Index of component to include. If None, includes contribution\n from all components.\n \n Returns\n -------\n Fraction of bolometric luminosity emitted at E in units of \n eV\\ :sup:`-1`\\.\n\n \"\"\" \n \n return self._normL * self._Intensity(E, t=t)\n \n def BolometricLuminosity(self, t=0.0, M=None):\n \"\"\"\n Returns the bolometric luminosity of a source in units of erg/s. \n For accreting black holes, the bolometric luminosity will increase \n with time, hence the optional 't' and 'M' arguments.\n \"\"\" \n \n if self._name == 'bh':\n return self.Luminosity(t, M)\n else:\n return self.Luminosity(t)\n \n def _FrequencyAveragedBin(self, absorber='h_1', Emin=None, Emax=None,\n energy_weighted=False):\n \"\"\"\n Bolometric luminosity / number of ionizing photons in spectrum in bandpass\n spanning interval (Emin, Emax). Returns mean photon energy and number of \n ionizing photons in band.\n \"\"\" \n \n if Emin is None:\n Emin = max(self.grid.ioniz_thresholds[absorber], self.Emin)\n if Emax is None:\n Emax = self.Emax\n \n if energy_weighted:\n f = lambda x: x\n else:\n f = lambda x: 1.0 \n \n L = self.Lbol * quad(lambda x: self.Spectrum(x) * f(x), Emin, Emax)[0] \n Q = self.Lbol * quad(lambda x: self.Spectrum(x) * f(x) / x, Emin, \n Emax)[0] / erg_per_ev\n \n return L / Q / erg_per_ev, Q \n\n def dump(self, fn, E, clobber=False):\n \"\"\"\n Write SED out to file.\n \n Parameters\n ----------\n fn : str\n Filename, suffix determines type. If 'hdf5' or 'h5' will write \n to HDF5 file, otherwise, to ASCII.\n E : np.ndarray\n Array of photon energies at which to sample SED. Units = eV.\n \n \"\"\"\n\n if os.path.exists(fn) and (clobber == False):\n raise OSError('%s exists!')\n\n if re.search('.hdf5', fn) or re.search('.h5', fn):\n out = 'hdf5'\n else:\n out = 'ascii'\n \n LE = map(self.Spectrum, E) \n \n if out == 'hdf5':\n f = h5py.File(fn, 'w') \n f.create_dataset('E', data=E)\n f.create_dataset('LE', data=LE)\n f.close()\n else:\n f = open(fn, 'w')\n print >> f, \"# E LE\"\n for i, nrg in enumerate(E):\n print >> f, \"%.8e %.8e\" % (nrg, LE[i])\n f.close() \n \n print \"Wrote %s.\" % fn \n \n def sed_name(self, i=0):\n \"\"\"\n Return name of output file based on SED properties.\n \"\"\"\n \n name = '%s_logM_%.2g_Gamma_%.3g_fsc_%.3g_logE_%.2g-%.2g' % \\\n (self.SpectrumPars['type'][i], np.log10(self.src.M0), \n self.src.spec_pars['alpha'][i], \n self.src.spec_pars['fsc'][i], self.logEmin, self.logEmax)\n\n return name\n \n \n \n \n ", "meta": {"hexsha": "b4049a25c4dea25e177e6ce069e34094942d55de", "size": 20836, "ext": "py", "lang": "Python", "max_stars_repo_path": "ares/sources/Source.py", "max_stars_repo_name": "astrojhgu/ares", "max_stars_repo_head_hexsha": "42008c8e4bf79f0b000cc833e02a86510bce7611", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-01-04T15:13:18.000Z", "max_stars_repo_stars_event_max_datetime": "2019-01-04T15:13:18.000Z", "max_issues_repo_path": "ares/sources/Source.py", "max_issues_repo_name": "astrojhgu/ares", "max_issues_repo_head_hexsha": "42008c8e4bf79f0b000cc833e02a86510bce7611", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ares/sources/Source.py", "max_forks_repo_name": "astrojhgu/ares", "max_forks_repo_head_hexsha": "42008c8e4bf79f0b000cc833e02a86510bce7611", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.3828382838, "max_line_length": 99, "alphanum_fraction": 0.5262046458, "include": true, "reason": "import numpy,from scipy", "num_tokens": 5019, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5964331462646254, "lm_q2_score": 0.3345894279828469, "lm_q1q2_score": 0.19956022523869069}} {"text": "# Copyright 2018-2020 Xanadu Quantum Technologies Inc.\n\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n\n# http://www.apache.org/licenses/LICENSE-2.0\n\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"This module contains functions to read the structure of molecules, build a Hartree-Fock state,\nbuild an active space and generate single and double excitations.\n\"\"\"\n# pylint: disable=too-many-locals\nimport os\nfrom shutil import copyfile\n\nfrom pennylane import numpy as np\n\n# Bohr-Angstrom correlation coefficient (https://physics.nist.gov/cgi-bin/cuu/Value?bohrrada0)\nbohr_angs = 0.529177210903\n\n\ndef read_structure(filepath, outpath=\".\"):\n r\"\"\"Read the structure of the polyatomic system from a file and returns\n a list with the symbols of the atoms in the molecule and a 1D array\n with their positions :math:`[x_1, y_1, z_1, x_2, y_2, z_2, \\dots]` in\n atomic units (Bohr radius = 1).\n\n The atomic coordinates in the file must be in Angstroms.\n The `xyz `_ format is supported. Additionally,\n the new file ``structure.xyz``, containing the input geometry, is created in a directory with\n path given by ``outpath``.\n\n Args:\n filepath (str): name of the molecular structure file in the working directory\n or the absolute path to the file if it is located in a different folder\n outpath (str): path to the output directory\n\n Returns:\n tuple[list, array]: symbols of the atoms in the molecule and a 1D array with their\n positions in atomic units.\n\n **Example**\n\n >>> symbols, coordinates = read_structure('h2.xyz')\n >>> print(symbols, coordinates)\n ['H', 'H'] [0. 0. -0.66140414 0. 0. 0.66140414]\n \"\"\"\n file_in = filepath.strip()\n file_out = os.path.join(outpath, \"structure.xyz\")\n\n copyfile(file_in, file_out)\n\n symbols = []\n coordinates = []\n with open(file_out, encoding=\"utf-8\") as f:\n for line in f.readlines()[2:]:\n symbol, x, y, z = line.split()\n symbols.append(symbol)\n coordinates.append(float(x))\n coordinates.append(float(y))\n coordinates.append(float(z))\n\n return symbols, np.array(coordinates) / bohr_angs\n\n\ndef active_space(electrons, orbitals, mult=1, active_electrons=None, active_orbitals=None):\n r\"\"\"Build the active space for a given number of active electrons and active orbitals.\n\n Post-Hartree-Fock (HF) electron correlation methods expand the many-body wave function\n as a linear combination of Slater determinants, commonly referred to as configurations.\n This configurations are generated by exciting electrons from the occupied to the\n unoccupied HF orbitals as sketched in the figure below. Since the number of configurations\n increases combinatorially with the number of electrons and orbitals this expansion can be\n truncated by defining an active space.\n\n The active space is created by classifying the HF orbitals as core, active and\n external orbitals:\n\n - Core orbitals are always occupied by two electrons\n - Active orbitals can be occupied by zero, one, or two electrons\n - The external orbitals are never occupied\n\n |\n\n .. figure:: ../../_static/qchem/sketch_active_space.png\n :align: center\n :width: 50%\n\n |\n\n .. note::\n The number of active *spin*-orbitals ``2*active_orbitals`` determines the number of\n qubits required to perform the quantum simulations of the electronic structure\n of the many-electron system.\n\n Args:\n electrons (int): total number of electrons\n orbitals (int): total number of orbitals\n mult (int): Spin multiplicity :math:`\\mathrm{mult}=N_\\mathrm{unpaired} + 1` for\n :math:`N_\\mathrm{unpaired}` unpaired electrons occupying the HF orbitals.\n Possible values for ``mult`` are :math:`1, 2, 3, \\ldots`. If not specified,\n a closed-shell HF state is assumed.\n active_electrons (int): Number of active electrons. If not specified, all electrons\n are treated as active.\n active_orbitals (int): Number of active orbitals. If not specified, all orbitals\n are treated as active.\n\n Returns:\n tuple: lists of indices for core and active orbitals\n\n **Example**\n\n >>> electrons = 4\n >>> orbitals = 4\n >>> core, active = active_space(electrons, orbitals, active_electrons=2, active_orbitals=2)\n >>> print(core) # core orbitals\n [0]\n >>> print(active) # active orbitals\n [1, 2]\n \"\"\"\n # pylint: disable=too-many-branches\n\n if active_electrons is None:\n ncore_orbs = 0\n core = []\n else:\n if active_electrons <= 0:\n raise ValueError(\n f\"The number of active electrons ({active_electrons}) \" f\"has to be greater than 0.\"\n )\n\n if active_electrons > electrons:\n raise ValueError(\n f\"The number of active electrons ({active_electrons}) \"\n f\"can not be greater than the total \"\n f\"number of electrons ({electrons}).\"\n )\n\n if active_electrons < mult - 1:\n raise ValueError(\n f\"For a reference state with multiplicity {mult}, \"\n f\"the number of active electrons ({active_electrons}) should be \"\n f\"greater than or equal to {mult - 1}.\"\n )\n\n if mult % 2 == 1:\n if active_electrons % 2 != 0:\n raise ValueError(\n f\"For a reference state with multiplicity {mult}, \"\n f\"the number of active electrons ({active_electrons}) should be even.\"\n )\n else:\n if active_electrons % 2 != 1:\n raise ValueError(\n f\"For a reference state with multiplicity {mult}, \"\n f\"the number of active electrons ({active_electrons}) should be odd.\"\n )\n\n ncore_orbs = (electrons - active_electrons) // 2\n core = list(range(ncore_orbs))\n\n if active_orbitals is None:\n active = list(range(ncore_orbs, orbitals))\n else:\n if active_orbitals <= 0:\n raise ValueError(\n f\"The number of active orbitals ({active_orbitals}) \" f\"has to be greater than 0.\"\n )\n\n if ncore_orbs + active_orbitals > orbitals:\n raise ValueError(\n f\"The number of core ({ncore_orbs}) + active orbitals ({active_orbitals}) cannot \"\n f\"be greater than the total number of orbitals ({orbitals})\"\n )\n\n homo = (electrons + mult - 1) / 2\n if ncore_orbs + active_orbitals <= homo:\n raise ValueError(\n f\"For n_active_orbitals={active_orbitals}, there are no virtual orbitals \"\n f\"in the active space.\"\n )\n\n active = list(range(ncore_orbs, ncore_orbs + active_orbitals))\n\n return core, active\n\n\ndef excitations(electrons, orbitals, delta_sz=0):\n r\"\"\"Generate single and double excitations from a Hartree-Fock reference state.\n\n Single and double excitations can be generated by acting with the operators\n :math:`\\hat T_1` and :math:`\\hat T_2` on the Hartree-Fock reference state:\n\n .. math::\n\n && \\hat{T}_1 = \\sum_{r \\in \\mathrm{occ} \\\\ p \\in \\mathrm{unocc}}\n \\hat{c}_p^\\dagger \\hat{c}_r \\\\\n && \\hat{T}_2 = \\sum_{r>s \\in \\mathrm{occ} \\\\ p>q \\in\n \\mathrm{unocc}} \\hat{c}_p^\\dagger \\hat{c}_q^\\dagger \\hat{c}_r \\hat{c}_s.\n\n\n In the equations above the indices :math:`r, s` and :math:`p, q` run over the\n occupied (occ) and unoccupied (unocc) *spin* orbitals and :math:`\\hat c` and\n :math:`\\hat c^\\dagger` are the electron annihilation and creation operators,\n respectively.\n\n |\n\n .. figure:: ../../_static/qchem/sd_excitations.png\n :align: center\n :width: 80%\n\n |\n\n Args:\n electrons (int): Number of electrons. If an active space is defined, this\n is the number of active electrons.\n orbitals (int): Number of *spin* orbitals. If an active space is defined,\n this is the number of active spin-orbitals.\n delta_sz (int): Specifies the selection rules ``sz[p] - sz[r] = delta_sz`` and\n ``sz[p] + sz[p] - sz[r] - sz[s] = delta_sz`` for the spin-projection ``sz`` of\n the orbitals involved in the single and double excitations, respectively.\n ``delta_sz`` can take the values :math:`0`, :math:`\\pm 1` and :math:`\\pm 2`.\n\n Returns:\n tuple(list, list): lists with the indices of the spin orbitals involved in the\n single and double excitations\n\n **Example**\n\n >>> electrons = 2\n >>> orbitals = 4\n >>> singles, doubles = excitations(electrons, orbitals)\n >>> print(singles)\n [[0, 2], [1, 3]]\n >>> print(doubles)\n [[0, 1, 2, 3]]\n \"\"\"\n\n if not electrons > 0:\n raise ValueError(\n f\"The number of active electrons has to be greater than 0 \\n\"\n f\"Got n_electrons = {electrons}\"\n )\n\n if orbitals <= electrons:\n raise ValueError(\n f\"The number of active spin-orbitals ({orbitals}) \"\n f\"has to be greater than the number of active electrons ({electrons}).\"\n )\n\n if delta_sz not in (0, 1, -1, 2, -2):\n raise ValueError(\n f\"Expected values for 'delta_sz' are 0, +/- 1 and +/- 2 but got ({delta_sz}).\"\n )\n\n # define the spin projection 'sz' of the single-particle states\n sz = np.array([0.5 if (i % 2 == 0) else -0.5 for i in range(orbitals)])\n\n singles = [\n [r, p]\n for r in range(electrons)\n for p in range(electrons, orbitals)\n if sz[p] - sz[r] == delta_sz\n ]\n\n doubles = [\n [s, r, q, p]\n for s in range(electrons - 1)\n for r in range(s + 1, electrons)\n for q in range(electrons, orbitals - 1)\n for p in range(q + 1, orbitals)\n if (sz[p] + sz[q] - sz[r] - sz[s]) == delta_sz\n ]\n\n return singles, doubles\n\n\ndef hf_state(electrons, orbitals):\n r\"\"\"Generate the occupation-number vector representing the Hartree-Fock state.\n\n The many-particle wave function in the Hartree-Fock (HF) approximation is a `Slater determinant\n `_. In Fock space, a Slater determinant\n for :math:`N` electrons is represented by the occupation-number vector:\n\n .. math::\n\n \\vert {\\bf n} \\rangle = \\vert n_1, n_2, \\dots, n_\\mathrm{orbs} \\rangle,\n n_i = \\left\\lbrace \\begin{array}{ll} 1 & i \\leq N \\\\ 0 & i > N \\end{array} \\right.,\n\n where :math:`n_i` indicates the occupation of the :math:`i`-th orbital.\n\n Args:\n electrons (int): Number of electrons. If an active space is defined, this\n is the number of active electrons.\n orbitals (int): Number of *spin* orbitals. If an active space is defined,\n this is the number of active spin-orbitals.\n\n Returns:\n array: NumPy array containing the vector :math:`\\vert {\\bf n} \\rangle`\n\n **Example**\n\n >>> state = hf_state(2, 6)\n >>> print(state)\n [1 1 0 0 0 0]\n \"\"\"\n\n if electrons <= 0:\n raise ValueError(\n f\"The number of active electrons has to be larger than zero; \"\n f\"got 'electrons' = {electrons}\"\n )\n\n if electrons > orbitals:\n raise ValueError(\n f\"The number of active orbitals cannot be smaller than the number of active electrons;\"\n f\" got 'orbitals'={orbitals} < 'electrons'={electrons}\"\n )\n\n state = np.where(np.arange(orbitals) < electrons, 1, 0)\n\n return np.array(state)\n\n\ndef excitations_to_wires(singles, doubles, wires=None):\n r\"\"\"Map the indices representing the single and double excitations\n generated with the function :func:`~.excitations` to the wires that\n the Unitary Coupled-Cluster (UCCSD) template will act on.\n\n Args:\n singles (list[list[int]]): list with the indices ``r``, ``p`` of the two qubits\n representing the single excitation\n :math:`\\vert r, p \\rangle = \\hat{c}_p^\\dagger \\hat{c}_r \\vert \\mathrm{HF}\\rangle`\n doubles (list[list[int]]): list with the indices ``s``, ``r``, ``q``, ``p`` of the four\n qubits representing the double excitation\n :math:`\\vert s, r, q, p \\rangle = \\hat{c}_p^\\dagger \\hat{c}_q^\\dagger\n \\hat{c}_r \\hat{c}_s \\vert \\mathrm{HF}\\rangle`\n wires (Iterable[Any]): Wires of the quantum device. If None, will use consecutive wires.\n\n The indices :math:`r, s` and :math:`p, q` in these lists correspond, respectively, to the\n occupied and virtual orbitals involved in the generated single and double excitations.\n\n Returns:\n tuple[list[list[Any]], list[list[list[Any]]]]: lists with the sequence of wires,\n resulting from the single and double excitations, that the Unitary Coupled-Cluster\n (UCCSD) template will act on.\n\n **Example**\n\n >>> singles = [[0, 2], [1, 3]]\n >>> doubles = [[0, 1, 2, 3]]\n >>> singles_wires, doubles_wires = excitations_to_wires(singles, doubles)\n >>> print(singles_wires)\n [[0, 1, 2], [1, 2, 3]]\n >>> print(doubles_wires)\n [[[0, 1], [2, 3]]]\n\n >>> wires=['a0', 'b1', 'c2', 'd3']\n >>> singles_wires, doubles_wires = excitations_to_wires(singles, doubles, wires=wires)\n >>> print(singles_wires)\n [['a0', 'b1', 'c2'], ['b1', 'c2', 'd3']]\n >>> print(doubles_wires)\n [[['a0', 'b1'], ['c2', 'd3']]]\n \"\"\"\n\n if (not singles) and (not doubles):\n raise ValueError(\n f\"'singles' and 'doubles' lists can not be both empty; \"\n f\"got singles = {singles}, doubles = {doubles}\"\n )\n\n expected_shape = (2,)\n for single_ in singles:\n if np.array(single_).shape != expected_shape:\n raise ValueError(\n f\"Expected entries of 'singles' to be of shape (2,); got {np.array(single_).shape}\"\n )\n\n expected_shape = (4,)\n for double_ in doubles:\n if np.array(double_).shape != expected_shape:\n raise ValueError(\n f\"Expected entries of 'doubles' to be of shape (4,); got {np.array(double_).shape}\"\n )\n\n max_idx = 0\n if singles:\n max_idx = np.max(singles)\n if doubles:\n max_idx = max(np.max(doubles), max_idx)\n\n if wires is None:\n wires = range(max_idx + 1)\n elif len(wires) != max_idx + 1:\n raise ValueError(f\"Expected number of wires is {max_idx + 1}; got {len(wires)}\")\n\n singles_wires = []\n for r, p in singles:\n s_wires = [wires[i] for i in range(r, p + 1)]\n singles_wires.append(s_wires)\n\n doubles_wires = []\n for s, r, q, p in doubles:\n d1_wires = [wires[i] for i in range(s, r + 1)]\n d2_wires = [wires[i] for i in range(q, p + 1)]\n doubles_wires.append([d1_wires, d2_wires])\n\n return singles_wires, doubles_wires\n", "meta": {"hexsha": "a06088af91fa98adb5e6702c8cfd52b638b71b0d", "size": 15382, "ext": "py", "lang": "Python", "max_stars_repo_path": "pennylane/qchem/structure.py", "max_stars_repo_name": "therooler/pennylane", "max_stars_repo_head_hexsha": "88a8a5960a2ffd218a12f85ace632021eef2abf5", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 539, "max_stars_repo_stars_event_min_datetime": "2018-11-13T08:45:42.000Z", "max_stars_repo_stars_event_max_datetime": "2020-07-27T18:17:16.000Z", "max_issues_repo_path": "pennylane/qchem/structure.py", "max_issues_repo_name": "therooler/pennylane", "max_issues_repo_head_hexsha": "88a8a5960a2ffd218a12f85ace632021eef2abf5", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 588, "max_issues_repo_issues_event_min_datetime": "2018-11-14T10:21:47.000Z", "max_issues_repo_issues_event_max_datetime": "2020-07-28T06:27:14.000Z", "max_forks_repo_path": "pennylane/qchem/structure.py", "max_forks_repo_name": "therooler/pennylane", "max_forks_repo_head_hexsha": "88a8a5960a2ffd218a12f85ace632021eef2abf5", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 165, "max_forks_repo_forks_event_min_datetime": "2018-11-13T18:58:56.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-27T17:18:17.000Z", "avg_line_length": 37.065060241, "max_line_length": 100, "alphanum_fraction": 0.6178650371, "include": true, "reason": "import numpy", "num_tokens": 4023, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5389832354982645, "lm_q2_score": 0.3702254064929193, "lm_q1q2_score": 0.19954528745521383}} {"text": "# -*- coding: utf-8 -*-\n\n\"\"\"Vector Field.\n\nThis is some documentation.\n\n\nAn example construction.\n\n.. todo::\n\n store VECTORFIELD_REPRESENTATIONS keys as str, not the BaseRepresentation\n class.\n\n\n\"\"\"\n\n__all__ = [\n \"BaseVectorField\",\n \"CartesianVectorField\",\n \"CylindricalVectorField\",\n \"SphericalVectorField\",\n \"PhysicsSphericalVectorField\",\n]\n\n\n##############################################################################\n# IMPORTS\n\n# BUILT-IN\nimport functools\nimport inspect\nimport operator\nimport typing as T\n\n# THIRD PARTY\nimport astropy.coordinates as coord\nimport astropy.units as u\nimport numpy as np\nfrom astropy.coordinates.representation import (\n REPRESENTATION_CLASSES as _REP_CLSs,\n)\nfrom astropy.coordinates.representation import (\n BaseRepresentationOrDifferential,\n _array2string,\n _make_getter,\n)\nfrom erfa import ufunc as erfa_ufunc\n\n# PROJECT-SPECIFIC\nfrom .coordinates import resolve_framelike\nfrom discO.type_hints import (\n FrameLikeType,\n FrameType,\n QuantityType,\n RepresentationType,\n)\n\n##############################################################################\n# PARAMETERS\n\n_VECTORFIELD_CLASSES: T.Dict[str, object] = {}\nVECTORFIELD_REPRESENTATIONS: T.Dict[coord.BaseRepresentation, object] = {}\n\n\ndef _invalidate_psp_cls_hash():\n global _PSP_HASH\n _PSP_HASH = None\n\n\n##############################################################################\n# CODE\n##############################################################################\n\n\nclass BaseVectorField(BaseRepresentationOrDifferential):\n \"\"\"Base Vector-Field.\n\n Parameters\n ----------\n points : |Representation|\n *args\n The components\n frame : frame-like or None (optional, keyword only)\n The frame of the vector-field. None (default), does not attach a frame.\n **kwargs\n passed along\n\n \"\"\"\n\n def __init_subclass__(cls, **kwargs) -> None:\n \"\"\"Set default ``attr_classes`` and component getters on a VectorField.\n class BaseVectorField(BaseRepresentationOrDifferential):\n For these, the components are those of the base representation prefixed\n by 'd_', and the class is `~astropy.units.Quantity`.\n\n \"\"\"\n if not hasattr(cls, \"base_representation\"):\n raise NotImplementedError(\n \"VectorField representations must have a\"\n '\"base_representation\" class attribute.',\n )\n\n # If not defined explicitly, create attr_classes.\n if not hasattr(cls, \"attr_classes\"):\n base_attr_classes = cls.base_representation.attr_classes\n cls.attr_classes = {\n \"vf_\" + c: u.Quantity for c in base_attr_classes\n }\n\n # Now check caches!\n repr_name = cls.get_name()\n if repr_name in _VECTORFIELD_CLASSES:\n raise ValueError(\n f\"VectorField class '{repr_name}' already exists.\",\n )\n elif cls.base_representation in VECTORFIELD_REPRESENTATIONS:\n raise ValueError(\n \"VectorField with representation \"\n f\"'{cls.base_representation}' already exists.\",\n )\n\n _VECTORFIELD_CLASSES[repr_name] = cls\n _invalidate_psp_cls_hash()\n\n # add to representations dict\n VECTORFIELD_REPRESENTATIONS[cls.base_representation] = cls\n\n # If not defined explicitly, create properties for the components.\n for component in cls.attr_classes:\n if not hasattr(cls, component):\n setattr(\n cls,\n component,\n property(\n _make_getter(component),\n doc=f\"Component '{component}' of the VectorField.\",\n ),\n )\n\n super().__init_subclass__(**kwargs)\n\n # /def\n\n def __init__(\n self,\n points: RepresentationType,\n *args,\n frame: T.Optional[FrameLikeType] = None,\n **kwargs,\n ) -> None:\n super().__init__(*args, **kwargs)\n self._frame = None if frame is None else resolve_framelike(frame)\n\n vf_q1 = getattr(self, \"_\" + self.components[0])\n vf_qs = [getattr(self, \"_\" + c) for c in self.components[1:]]\n\n if not all(vf_q1.unit.is_equivalent(vf_q.unit) for vf_q in vf_qs):\n raise u.UnitsError(\"components should have equivalent units.\")\n\n if not isinstance(points, coord.BaseRepresentation):\n raise TypeError(\"points is not .\")\n\n # TODO store in CoordinateFrame. If representation, use GenericFrame\n # \"points\" property and stuff links to the _points.data\n self._points = points.represent_as(self.base_representation)\n\n # /def\n\n @property\n def points(self):\n return self._points\n\n @property\n def frame(self) -> FrameType:\n return self._frame\n\n # /def\n\n #######################################################\n # Representation\n\n def to_cartesian(self):\n \"\"\"Convert the field to 3D rectangular cartesian coordinates.\n\n Returns\n -------\n `CartesianVectorField`\n This object, converted\n\n \"\"\"\n base_e = self.points.unit_vectors()\n c = functools.reduce(\n operator.add,\n (\n getattr(self, d_c) * base_e[c]\n for d_c, c in zip(self.components, self.points.components)\n ),\n )\n\n return CartesianVectorField(\n self.points.to_cartesian(),\n vf_x=c.x,\n vf_y=c.y,\n vf_z=c.z,\n frame=self.frame,\n )\n\n # /def\n\n @classmethod\n def from_cartesian(cls, other):\n \"\"\"Convert field from 3D Cartesian coordinates to the desired class.\n\n Parameters\n ----------\n other : `CartesianVectorField`\n The object to convert into this vector field.\n\n Returns\n -------\n BaseVectorField\n A new Vector Field object that is this class' type.\n\n \"\"\"\n points = cls.base_representation.from_cartesian(other.points)\n base_e = points.unit_vectors()\n\n return cls(\n points,\n *(other.dot(e) for e in base_e.values()),\n copy=False,\n frame=other.frame,\n )\n\n # /def\n\n def represent_as(self, other_class):\n \"\"\"Convert coordinates to another representation.\n\n If the instance is of the requested class, it is returned unmodified.\n By default, conversion is done via cartesian coordinates.\n\n Parameters\n ----------\n other_class : `~BaseVectorField` subclass\n The type of representation to turn the coordinates into.\n\n \"\"\"\n if other_class is self.__class__:\n return self\n\n # The default is to convert via cartesian coordinates.\n self_cartesian = self.to_cartesian()\n\n if inspect.isclass(other_class) and issubclass(\n other_class,\n BaseVectorField,\n ):\n pass\n elif inspect.isclass(other_class) and issubclass(\n other_class,\n coord.BaseRepresentation,\n ):\n # convert other_class to the corresponding VectorField\n other_class = VECTORFIELD_REPRESENTATIONS[other_class]\n elif isinstance(other_class, str):\n rep_cls = _REP_CLSs[other_class]\n # convert rep_cls to the corresponding VectorField\n other_class = VECTORFIELD_REPRESENTATIONS[rep_cls]\n else:\n raise TypeError\n\n return other_class.from_cartesian(self_cartesian)\n\n # /def\n\n @classmethod\n def from_field(cls, vectorfield):\n \"\"\"Create a new instance of this vectorfield from another one.\n\n Parameters\n ----------\n vectorfield : `~BaseVectorField` instance\n The presentation that should be converted to this class.\n\n \"\"\"\n if isinstance(vectorfield, BaseVectorField):\n cartesian = vectorfield.to_cartesian(\n # base.represent_as(vectorfield.base_representation)\n )\n else:\n raise TypeError\n\n return cls.from_cartesian(cartesian)\n\n # /def\n\n #######################################################\n # math\n\n def _scale_operation(self, op: T.Callable, *args):\n \"\"\"Scale all components.\n\n Parameters\n ----------\n op : `~operator` callable\n Operator to apply (e.g., `~operator.mul`, `~operator.neg`, etc.\n *args\n Any arguments required for the operator (typically, what is to\n be multiplied with, divided by).\n\n \"\"\"\n scaled_attrs = [op(getattr(self, c), *args) for c in self.components]\n scaled_points = self.points._scale_operation(op, *args)\n return self.__class__(\n scaled_points,\n *scaled_attrs,\n copy=False,\n frame=self.frame,\n )\n\n # /def\n\n def _combine_operation(self, op: T.Callable, other, reverse: bool = False):\n \"\"\"Combine two vector fields.\n\n If ``other`` is of the same phase space position type as ``self``, the\n components will simply be combined. If ``other`` is a representation,\n it will be used as a base for which to evaluate the phase space\n position, and the result is a new representation.\n\n Parameters\n ----------\n op : `~operator` callable\n Operator to apply (e.g., `~operator.add`, `~operator.sub`, etc.\n other : `BaseVectorField` instance\n The other phase space position or representation.\n reverse : bool\n Whether the operands should be reversed (e.g., as we got here via\n ``self.__rsub__`` because ``self`` is a subclass of ``other``).\n\n \"\"\"\n # ----------\n # make sure points are the same\n\n diff = (\n self.points.represent_as(\n coord.CartesianRepresentation,\n )\n - other.points.represent_as(coord.CartesianRepresentation)\n )\n\n if not np.allclose(diff.norm().value, 0):\n raise Exception(\"can't combine mismatching points.\")\n\n # ----------\n\n if isinstance(self, type(other)):\n\n first, second = (self, other) if not reverse else (other, self)\n return self.__class__(\n self.points,\n *[\n op(getattr(first, c), getattr(second, c))\n for c in self.components\n ],\n frame=self.frame,\n )\n else:\n try:\n self_cartesian = self.to_cartesian()\n except TypeError:\n return NotImplemented\n\n return other._combine_operation(op, self_cartesian, not reverse)\n\n # /def\n\n def norm(self) -> QuantityType:\n \"\"\"Vector norm.\n\n The norm is the standard Frobenius norm, i.e., the square root of the\n sum of the squares of all components with non-angular units.\n\n Note that any associated differentials will be dropped during this\n operation.\n\n Returns\n -------\n norm : `astropy.units.Quantity`\n Vector norm, with the same shape as the representation.\n\n \"\"\"\n return np.sqrt(\n functools.reduce(\n operator.add,\n (\n getattr(self, component) ** 2\n for component, cls in self.attr_classes.items()\n ),\n ),\n )\n\n # /def\n\n #######################################################\n # utils\n\n def unit_vectors(self) -> T.Dict[str, RepresentationType]:\n r\"\"\"Cartesian unit vectors in the direction of each component.\n\n Given unit vectors :math:`\\hat{e}_c` and scale factors :math:`f_c`,\n a change in one component of :math:`\\delta c` corresponds to a change\n in representation of :math:`\\delta c \\times f_c \\times \\hat{e}_c`.\n\n Returns\n -------\n unit_vectors : dict of `CartesianRepresentation`\n The keys are the component names.\n\n \"\"\"\n return self.points.unit_vectors()\n\n # /def\n\n def scale_factors(self) -> T.Dict[str, QuantityType]:\n r\"\"\"Scale factors for each component's direction.\n\n Given unit vectors :math:`\\hat{e}_c` and scale factors :math:`f_c`,\n a change in one component of :math:`\\delta c` corresponds to a change\n in representation of :math:`\\delta c \\times f_c \\times \\hat{e}_c`.\n\n Returns\n -------\n scale_factors : dict of `~astropy.units.Quantity`\n The keys are the component names.\n\n \"\"\"\n return self.points.scale_factors()\n\n # /def\n\n def __repr__(self) -> str:\n prefixstr = \" \"\n # TODO combine with points\n arrstr = _array2string(\n np.lib.recfunctions.merge_arrays(\n (self.points._values, self._values),\n ),\n prefix=prefixstr,\n )\n\n pointsunitstr = (\n (\"in \" + self.points._unitstr)\n if self.points._unitstr\n else \"[dimensionless]\"\n )\n unitstr = (\n (\"in \" + self._unitstr) if self._unitstr else \"[dimensionless]\"\n )\n return \"<{} ({}) {:s} | ({}) {:s}\\n{}{}>\".format(\n self.__class__.__name__,\n \", \".join(self.points.components),\n pointsunitstr,\n \", \".join(self.components),\n unitstr,\n prefixstr,\n arrstr,\n )\n\n # /def\n\n def _apply(self, method: T.Union[str, T.Callable], *args, **kwargs):\n \"\"\"Create a new representation or differential with ``method`` applied\n to the component data.\n\n In typical usage, the method is any of the shape-changing methods for\n `~numpy.ndarray` (``reshape``, ``swapaxes``, etc.), as well as those\n picking particular elements (``__getitem__``, ``take``, etc.), which\n are all defined in `~astropy.utils.shapes.ShapedLikeNDArray`. It will be\n applied to the underlying arrays (e.g., ``x``, ``y``, and ``z`` for\n `~astropy.coordinates.CartesianRepresentation`), with the results used\n to create a new instance.\n\n Internally, it is also used to apply functions to the components\n (in particular, `~numpy.broadcast_to`).\n\n Parameters\n ----------\n method : str or callable\n If str, it is the name of a method that is applied to the internal\n ``components``. If callable, the function is applied.\n args : tuple\n Any positional arguments for ``method``.\n kwargs : dict\n Any keyword arguments for ``method``.\n\n \"\"\"\n if callable(method):\n\n def apply_method(array):\n return method(array, *args, **kwargs)\n\n else:\n apply_method = operator.methodcaller(method, *args, **kwargs)\n\n new = super().__new__(self.__class__)\n new._points = self.points._apply(method, *args, **kwargs)\n for component in self.components:\n setattr(\n new,\n \"_\" + component,\n apply_method(getattr(self, component)),\n )\n\n # Copy other 'info' attr only if it has actually been defined.\n # See PR #3898 for further explanation and justification, along\n # with Quantity.__array_finalize__\n if \"info\" in self.__dict__:\n new.info = self.info\n\n return new\n\n # /def\n\n\n# /class\n\n\n# -------------------------------------------------------------------\n\n\nclass CartesianVectorField(BaseVectorField):\n \"\"\"Cartesian Vector Field.\"\"\"\n\n _xyz = None\n _vf_xyz = None\n\n base_representation = coord.CartesianRepresentation\n\n @property\n def x(self) -> QuantityType:\n return self.points.x\n\n @property\n def y(self) -> QuantityType:\n return self.points.y\n\n @property\n def z(self) -> QuantityType:\n return self.points.z\n\n def __init__(\n self,\n points: RepresentationType,\n vf_x,\n vf_y=None,\n vf_z=None,\n frame: T.Optional[FrameLikeType] = None,\n copy: bool = False,\n ) -> None:\n super().__init__(points, vf_x, vf_y, vf_z, frame=frame, copy=copy)\n\n # /def\n\n def get_xyz(self, xyz_axis: int = 0) -> QuantityType:\n \"\"\"Return a vector array of the x, y, and z coordinates.\n\n Parameters\n ----------\n xyz_axis : int, optional\n The axis in the final array along which the x, y, z components\n should be stored (default: 0).\n\n Returns\n -------\n xyz : `~astropy.units.Quantity`\n With dimension 3 along ``xyz_axis``. Note that, if possible,\n this will be a view.\n\n \"\"\"\n return self.points.get_xyz(xyz_axis=xyz_axis)\n\n xyz = property(get_xyz)\n # /def\n\n def get_vf_xyz(self, vf_xyz_axis: int = 0):\n \"\"\"Return a vector array of the vf_x, vf_y, and vf_z coordinates.\n\n Parameters\n ----------\n vf_xyz_axis : int, optional\n The axis in the final array along which the vf_x, vf_y, vf_z\n components should be stored (default: 0).\n\n Returns\n -------\n vf_xyz : `~astropy.units.Quantity`\n With dimension 3 along ``vf_xyz_axis``. Note that, if possible,\n this will be a view.\n\n \"\"\"\n if self._vf_xyz is not None:\n if self._vf_xyz_axis == vf_xyz_axis:\n return self._vf_xyz\n else:\n return np.moveaxis(\n self._vf_xyz,\n self._vf_xyz_axis,\n vf_xyz_axis,\n )\n\n # Create combined array. TO DO: keep it in _xyz for repeated use?\n # But then in-place changes have to cancel it. Likely best to\n # also update components.\n return np.stack([self._vf_x, self._vf_y, self._vf_z], axis=vf_xyz_axis)\n\n vf_xyz = property(get_vf_xyz)\n # /def\n\n def dot(self, other):\n \"\"\"Dot product of two vector fields.\n\n Note that any associated differentials will be dropped during this\n operation.\n\n Parameters\n ----------\n other : `BaseVectorField` or |Representation|\n If not already cartesian, it is converted.\n\n Returns\n -------\n dot_product : `~astropy.units.Quantity`\n The sum of the product of the x, y, and z components of ``self``\n and ``other``.\n\n \"\"\"\n try:\n other_c = other.to_cartesian()\n except Exception:\n raise TypeError(\n \"cannot only take dot product with another \"\n \"vector field, not a {} instance.\".format(type(other)),\n )\n\n if isinstance(other_c, BaseVectorField):\n other_vf_xyz = other_c.get_vf_xyz(vf_xyz_axis=-1)\n else:\n other_vf_xyz = other_c.get_xyz(xyz_axis=-1)\n\n # erfa pdp: p-vector inner (=scalar=dot) product.\n return erfa_ufunc.pdp(self.get_vf_xyz(vf_xyz_axis=-1), other_vf_xyz)\n\n # /def\n\n\n# /class\n\n# -------------------------------------------------------------------\n\n\nclass CylindricalVectorField(BaseVectorField):\n \"\"\"Cylindrical Vector Field.\"\"\"\n\n base_representation = coord.CylindricalRepresentation\n\n def __init__(\n self,\n points: RepresentationType,\n vf_rho,\n vf_phi=None,\n vf_z=None,\n frame: T.Optional[FrameLikeType] = None,\n copy: bool = False,\n ) -> None:\n super().__init__(points, vf_rho, vf_phi, vf_z, frame=frame, copy=copy)\n\n # /def\n\n @property\n def rho(self) -> QuantityType:\n return self.points.rho\n\n @property\n def phi(self) -> QuantityType:\n return self.points.phi\n\n @property\n def z(self) -> QuantityType:\n return self.points.z\n\n # /def\n\n\n# /class\n\n# -------------------------------------------------------------------\n\n\nclass SphericalVectorField(BaseVectorField):\n \"\"\"Spherical Vector Field.\"\"\"\n\n base_representation = coord.SphericalRepresentation\n\n def __init__(\n self,\n points: RepresentationType,\n vf_lon,\n vf_lat=None,\n vf_distance=None,\n frame: T.Optional[FrameLikeType] = None,\n copy: bool = False,\n ) -> None:\n super().__init__(\n points,\n vf_lon,\n vf_lat,\n vf_distance,\n frame=frame,\n copy=copy,\n )\n\n # /def\n\n @property\n def lon(self) -> QuantityType:\n return self.points.lon\n\n @property\n def lat(self) -> QuantityType:\n return self.points.lat\n\n @property\n def distance(self) -> QuantityType:\n return self.points.distance\n\n # /def\n\n\n# /class\n\n# -------------------------------------------------------------------\n\n\nclass PhysicsSphericalVectorField(BaseVectorField):\n \"\"\"PhysicsSpherical Vector Field.\"\"\"\n\n base_representation = coord.PhysicsSphericalRepresentation\n\n def __init__(\n self,\n points: RepresentationType,\n vf_phi,\n vf_theta=None,\n vf_r=None,\n frame: T.Optional[FrameLikeType] = None,\n copy: bool = False,\n ) -> None:\n super().__init__(\n points,\n vf_phi,\n vf_theta,\n vf_r,\n frame=frame,\n copy=copy,\n )\n\n # /def\n\n @property\n def phi(self) -> QuantityType:\n return self.points.phi\n\n @property\n def theta(self) -> QuantityType:\n return self.points.theta\n\n @property\n def r(self) -> QuantityType:\n return self.points.r\n\n # /def\n\n\n# /class\n\n##############################################################################\n# END\n", "meta": {"hexsha": "553ac51f62a88246d9736386c92de41b294ec146", "size": 21922, "ext": "py", "lang": "Python", "max_stars_repo_path": "discO/utils/vectorfield.py", "max_stars_repo_name": "GalOrrery/discO", "max_stars_repo_head_hexsha": "3b17b6ead65908c053b09a1a967e8a1819a06209", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-11-17T14:40:51.000Z", "max_stars_repo_stars_event_max_datetime": "2020-11-17T14:40:51.000Z", "max_issues_repo_path": "discO/utils/vectorfield.py", "max_issues_repo_name": "nstarman/discO", "max_issues_repo_head_hexsha": "3b17b6ead65908c053b09a1a967e8a1819a06209", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 45, "max_issues_repo_issues_event_min_datetime": "2020-11-17T14:30:13.000Z", "max_issues_repo_issues_event_max_datetime": "2021-02-26T18:47:37.000Z", "max_forks_repo_path": "discO/utils/vectorfield.py", "max_forks_repo_name": "nstarman/discO", "max_forks_repo_head_hexsha": "3b17b6ead65908c053b09a1a967e8a1819a06209", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.7142857143, "max_line_length": 80, "alphanum_fraction": 0.5528236475, "include": true, "reason": "import numpy,import astropy,from astropy", "num_tokens": 4577, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5389832206876841, "lm_q2_score": 0.37022540649291935, "lm_q1q2_score": 0.1995452819719607}} {"text": "# Third-party\nimport astropy.coordinates as coord\nimport astropy.units as u\nimport numpy as np\nfrom scipy.signal import argrelmax\n\n# Project\nfrom gala.logging import logger\nfrom .core import PhaseSpacePosition\nfrom .util import peak_to_peak_period\nfrom .plot import plot_projections\nfrom ..io import quantity_to_hdf5, quantity_from_hdf5\nfrom ..util import atleast_2d\nfrom ..units import dimensionless, UnitSystem, DimensionlessUnitSystem\n\n__all__ = ['Orbit']\n\n\nclass Orbit(PhaseSpacePosition):\n \"\"\"\n Represents an orbit: positions and velocities (conjugate momenta) as a\n function of time.\n\n The class can be instantiated with Astropy representation objects (e.g.,\n :class:`~astropy.coordinates.CartesianRepresentation`), Astropy\n :class:`~astropy.units.Quantity` objects, or plain Numpy arrays.\n\n If passing in Quantity or Numpy array instances for both position and\n velocity, they are assumed to be Cartesian. Array inputs are interpreted as\n dimensionless quantities. The input position and velocity objects can have\n an arbitrary number of (broadcastable) dimensions. For Quantity or array\n inputs, the first axes have special meaning:\n\n - ``axis=0`` is the coordinate dimension (e.g., x, y, z)\n - ``axis=1`` is the time dimension\n\n So if the input position array, ``pos``, has shape ``pos.shape = (3, 100)``,\n this would be a 3D orbit at 100 times (``pos[0]`` is ``x``, ``pos[1]``` is\n ``y``, etc.). For representing multiple orbits, the position array could\n have 3 axes, e.g., it might have shape `pos.shape = (3, 100, 8)`, where this\n is interpreted as a 3D position at 100 times for 8 different orbits. The\n same is true for velocity. The position and velocity arrays must have the\n same shape.\n\n If a time argument is specified, the position and velocity arrays must have\n the same number of timesteps as the length of the time object::\n\n len(t) == pos.shape[1]\n\n Parameters\n ----------\n pos : representation, quantity_like, or array_like\n Positions. If a numpy array (e.g., has no units), this will be\n stored as a dimensionless :class:`~astropy.units.Quantity`. See\n the note above about the assumed meaning of the axes of this object.\n vel : differential, quantity_like, or array_like\n Velocities. If a numpy array (e.g., has no units), this will be\n stored as a dimensionless :class:`~astropy.units.Quantity`. See\n the note above about the assumed meaning of the axes of this object.\n t : array_like, :class:`~astropy.units.Quantity` (optional)\n Array of times. If a numpy array (e.g., has no units), this will be\n stored as a dimensionless :class:`~astropy.units.Quantity`.\n hamiltonian : `~gala.potential.Hamiltonian` (optional)\n The Hamiltonian that the orbit was integrated in.\n\n \"\"\"\n def __init__(self, pos, vel, t=None,\n hamiltonian=None, potential=None, frame=None):\n\n super().__init__(pos=pos, vel=vel)\n\n if self.pos.ndim < 1:\n self.pos = self.pos.reshape(1)\n self.vel = self.vel.reshape(1)\n\n # TODO: check that Hamiltonian ndim is consistent with here\n\n if t is not None:\n t = np.atleast_1d(t)\n if self.pos.shape[0] != len(t):\n raise ValueError(\"Position and velocity must have the same \"\n \"length along axis=1 as the length of the \"\n \"time array {} vs {}\"\n .format(len(t), self.pos.shape[0]))\n\n if not hasattr(t, 'unit'):\n t = t * u.one\n\n self.t = t\n\n if hamiltonian is not None:\n self.potential = hamiltonian.potential\n self.frame = hamiltonian.frame\n\n else:\n self.potential = potential\n self.frame = frame\n\n def __getitem__(self, slice_):\n\n if isinstance(slice_, np.ndarray) or isinstance(slice_, list):\n slice_ = (slice_,)\n\n try:\n slice_ = tuple(slice_)\n except TypeError:\n slice_ = (slice_,)\n\n kw = dict()\n if self.t is not None:\n kw['t'] = self.t[slice_[0]]\n\n pos = self.pos[slice_]\n vel = self.vel[slice_]\n\n # if one time is sliced out, return a phasespaceposition\n try:\n int_tslice = int(slice_[0])\n except TypeError:\n int_tslice = None\n\n if int_tslice is not None:\n return PhaseSpacePosition(pos=pos, vel=vel, frame=self.frame)\n\n else:\n return self.__class__(pos=pos, vel=vel,\n potential=self.potential,\n frame=self.frame, **kw)\n\n @property\n def hamiltonian(self):\n if self.potential is None or self.frame is None:\n return None\n\n try:\n return self._hamiltonian\n except AttributeError:\n from gala.potential import Hamiltonian\n self._hamiltonian = Hamiltonian(potential=self.potential,\n frame=self.frame)\n\n return self._hamiltonian\n\n def w(self, units=None):\n \"\"\"\n This returns a single array containing the phase-space positions.\n\n Parameters\n ----------\n units : `~gala.units.UnitSystem` (optional)\n The unit system to represent the position and velocity in\n before combining into the full array.\n\n Returns\n -------\n w : `~numpy.ndarray`\n A numpy array of all positions and velocities, without units.\n Will have shape ``(2*ndim, ...)``.\n\n \"\"\"\n\n if units is None:\n if self.hamiltonian is None:\n units = dimensionless\n else:\n units = self.hamiltonian.units\n\n return super().w(units=units)\n\n # ------------------------------------------------------------------------\n # Convert from Cartesian to other representations\n #\n def represent_as(self, new_pos, new_vel=None):\n \"\"\"\n Represent the position and velocity of the orbit in an alternate\n coordinate system. Supports any of the Astropy coordinates\n representation classes.\n\n Parameters\n ----------\n new_pos : :class:`~astropy.coordinates.BaseRepresentation`\n The type of representation to generate. Must be a class (not an\n instance), or the string name of the representation class.\n new_vel : :class:`~astropy.coordinates.BaseDifferential` (optional)\n Class in which any velocities should be represented. Must be a class\n (not an instance), or the string name of the differential class. If\n None, uses the default differential for the new position class.\n\n Returns\n -------\n new_orbit : `gala.dynamics.Orbit`\n \"\"\"\n kw = dict()\n if self.t is not None:\n kw['t'] = self.t\n o = super().represent_as(new_pos=new_pos, new_vel=new_vel)\n return self.__class__(pos=o.pos,\n vel=o.vel,\n hamiltonian=self.hamiltonian,\n **kw)\n\n # ------------------------------------------------------------------------\n # Shape and size\n # ------------------------------------------------------------------------\n @property\n def ntimes(self):\n return self.shape[0]\n\n @property\n def norbits(self):\n if len(self.shape) < 2:\n return 1\n else:\n return self.shape[1]\n\n def reshape(self, new_shape):\n \"\"\"\n Reshape the underlying position and velocity arrays.\n \"\"\"\n kw = dict()\n if self.t is not None:\n kw['t'] = self.t\n return self.__class__(pos=self.pos.reshape(new_shape),\n vel=self.vel.reshape(new_shape),\n hamiltonian=self.hamiltonian,\n **kw)\n\n # ------------------------------------------------------------------------\n # Input / output\n #\n def to_hdf5(self, f):\n \"\"\"\n Serialize this object to an HDF5 file.\n\n Requires ``h5py``.\n\n Parameters\n ----------\n f : str, :class:`h5py.File`\n Either the filename or an open HDF5 file.\n \"\"\"\n\n f = super().to_hdf5(f)\n\n if self.potential is not None:\n import yaml\n from ..potential.potential.io import to_dict\n f['potential'] = yaml.dump(to_dict(self.potential)).encode('utf-8')\n\n if self.t:\n quantity_to_hdf5(f, 'time', self.t)\n\n return f\n\n @classmethod\n def from_hdf5(cls, f):\n \"\"\"\n Load an object from an HDF5 file.\n\n Requires ``h5py``.\n\n Parameters\n ----------\n f : str, :class:`h5py.File`\n Either the filename or an open HDF5 file.\n \"\"\"\n # TODO: this is duplicated code from PhaseSpacePosition\n if isinstance(f, str):\n import h5py\n f = h5py.File(f, mode='r')\n close = True\n else:\n close = False\n\n pos = quantity_from_hdf5(f['pos'])\n vel = quantity_from_hdf5(f['vel'])\n\n time = None\n if 'time' in f:\n time = quantity_from_hdf5(f['time'])\n\n frame = None\n if 'frame' in f:\n g = f['frame']\n\n frame_mod = g.attrs['module']\n frame_cls = g.attrs['class']\n frame_units = [u.Unit(x.decode('utf-8')) for x in g['units']]\n\n if u.dimensionless_unscaled in frame_units:\n units = DimensionlessUnitSystem()\n else:\n units = UnitSystem(*frame_units)\n\n pars = dict()\n for k in g['parameters']:\n pars[k] = quantity_from_hdf5(g['parameters/'+k])\n\n exec(\"from {0} import {1}\".format(frame_mod, frame_cls))\n frame_cls = eval(frame_cls)\n\n frame = frame_cls(units=units, **pars)\n\n potential = None\n if 'potential' in f:\n import yaml\n from ..potential.potential.io import from_dict\n _dict = yaml.load(f['potential'][()].decode('utf-8'),\n Loader=yaml.Loader)\n potential = from_dict(_dict)\n\n if close:\n f.close()\n\n return cls(pos=pos, vel=vel, t=time,\n frame=frame, potential=potential)\n\n def orbit_gen(self):\n \"\"\"\n Generator for iterating over each orbit.\n \"\"\"\n if self.norbits == 1:\n yield self\n\n else:\n for i in range(self.norbits):\n yield self[:, i]\n\n # ------------------------------------------------------------------------\n # Computed dynamical quantities\n #\n\n def potential_energy(self, potential=None):\n r\"\"\"\n The potential energy *per unit mass*:\n\n .. math::\n\n E_\\Phi = \\Phi(\\boldsymbol{q})\n\n Returns\n -------\n E : :class:`~astropy.units.Quantity`\n The potential energy.\n \"\"\"\n if self.hamiltonian is None and potential is None:\n raise ValueError(\"To compute the potential energy, a potential\"\n \" object must be provided!\")\n if potential is None:\n potential = self.hamiltonian.potential\n\n return super().potential_energy(potential)\n\n def energy(self, hamiltonian=None):\n r\"\"\"\n The total energy *per unit mass*:\n\n Parameters\n ----------\n hamiltonian : `gala.potential.Hamiltonian`, `gala.potential.PotentialBase` instance\n The Hamiltonian object to evaluate the energy. If a potential is\n passed in, this assumes a static reference frame.\n\n Returns\n -------\n E : :class:`~astropy.units.Quantity`\n The total energy.\n \"\"\"\n\n if self.hamiltonian is None and hamiltonian is None:\n raise ValueError(\"To compute the total energy, a hamiltonian\"\n \" object must be provided!\")\n\n if hamiltonian is None:\n hamiltonian = self.hamiltonian\n else:\n from gala.potential import Hamiltonian\n hamiltonian = Hamiltonian(hamiltonian)\n\n return hamiltonian(self)\n\n def _max_helper(self, arr, approximate=False):\n \"\"\"\n Helper function for computing extrema (apocenter, pericenter, z_height)\n and times of extrema.\n\n Parameters\n ----------\n arr : `numpy.ndarray`\n \"\"\"\n assert self.norbits == 1\n assert self.t[-1] > self.t[0] # time must increase\n\n _ix = argrelmax(arr.value, mode='wrap')[0]\n _ix = _ix[(_ix != 0) & (_ix != (len(arr)-1))] # remove edges\n t = self.t.value\n\n approx_arr = arr[_ix]\n approx_t = t[_ix]\n\n if approximate:\n return approx_arr, approx_t * self.t.unit\n\n better_times = np.zeros(_ix.shape, dtype=float)\n better_arr = np.zeros(_ix.shape, dtype=float)\n for i, j in enumerate(_ix):\n tvals = t[j-1:j+2]\n rvals = arr[j-1:j+2].value\n coeffs = np.polynomial.polynomial.polyfit(tvals, rvals, 2)\n better_times[i] = (-coeffs[1])/(2*coeffs[2])\n better_arr[i] = ((coeffs[2] * better_times[i]**2)\n + (coeffs[1] * better_times[i]) + coeffs[0])\n\n return better_arr * arr.unit, better_times * self.t.unit\n\n def _max_return_helper(self, vals, times, return_times, reduce):\n if return_times:\n if len(vals) == 1:\n return vals[0], times[0]\n else:\n return vals, times\n\n elif reduce:\n return u.Quantity(vals).reshape(self.shape[1:])\n\n else:\n return u.Quantity(vals)\n\n def pericenter(self, return_times=False, func=np.mean,\n approximate=False):\n \"\"\"\n Estimate the pericenter(s) of the orbit by identifying local minima in\n the spherical radius, fitting a parabola around these local minima and\n then solving this parabola to find the pericenter(s).\n\n By default, this returns the mean of all local minima (pericenters). To\n get, e.g., the minimum pericenter, pass in ``func=np.min``. To get\n all pericenters, pass in ``func=None``.\n\n Parameters\n ----------\n func : func (optional)\n A function to evaluate on all of the identified pericenter times.\n return_times : bool (optional)\n Also return the pericenter times.\n approximate : bool (optional)\n Compute an approximate pericenter by skipping interpolation.\n\n Returns\n -------\n peri : float, :class:`~numpy.ndarray`\n Either a single number or an array of pericenters.\n times : :class:`~numpy.ndarray` (optional, see ``return_times``)\n If ``return_times=True``, also returns an array of the pericenter\n times.\n\n \"\"\"\n\n if return_times and func is not None:\n raise ValueError(\"Cannot return times if reducing pericenters \"\n \"using an input function. Pass `func=None` if \"\n \"you want to return all individual pericenters \"\n \"and times.\")\n\n if func is None:\n reduce = False\n func = lambda x: x # noqa\n else:\n reduce = True\n\n # time must increase\n if self.t[-1] < self.t[0]:\n self = self[::-1]\n\n vals = []\n times = []\n for orbit in self.orbit_gen():\n v, t = orbit._max_helper(-orbit.physicsspherical.r, # pericenter\n approximate=approximate)\n vals.append(func(-v)) # negative for pericenter\n times.append(t)\n\n return self._max_return_helper(vals, times, return_times, reduce)\n\n def apocenter(self, return_times=False, func=np.mean,\n approximate=False):\n \"\"\"\n Estimate the apocenter(s) of the orbit by identifying local maxima in\n the spherical radius, fitting a parabola around these local maxima and\n then solving this parabola to find the apocenter(s).\n\n By default, this returns the mean of all local maxima (apocenters). To\n get, e.g., the largest apocenter, pass in ``func=np.max``. To get\n all apocenters, pass in ``func=None``.\n\n Parameters\n ----------\n func : func (optional)\n A function to evaluate on all of the identified apocenter times.\n return_times : bool (optional)\n Also return the apocenter times.\n approximate : bool (optional)\n Compute an approximate apocenter by skipping interpolation.\n\n Returns\n -------\n apo : float, :class:`~numpy.ndarray`\n Either a single number or an array of apocenters.\n times : :class:`~numpy.ndarray` (optional, see ``return_times``)\n If ``return_times=True``, also returns an array of the apocenter\n times.\n\n \"\"\"\n\n if return_times and func is not None:\n raise ValueError(\"Cannot return times if reducing apocenters \"\n \"using an input function. Pass `func=None` if \"\n \"you want to return all individual apocenters \"\n \"and times.\")\n\n if func is None:\n reduce = False\n func = lambda x: x # noqa\n else:\n reduce = True\n\n # time must increase\n if self.t[-1] < self.t[0]:\n self = self[::-1]\n\n vals = []\n times = []\n for orbit in self.orbit_gen():\n v, t = orbit._max_helper(orbit.physicsspherical.r, # apocenter\n approximate=approximate)\n vals.append(func(v))\n times.append(t)\n\n return self._max_return_helper(vals, times, return_times, reduce)\n\n def zmax(self, return_times=False, func=np.mean,\n approximate=False):\n \"\"\"\n Estimate the maximum ``z`` height of the orbit by identifying local\n maxima in the absolute value of the ``z`` position, fitting a parabola\n around these local maxima and then solving this parabola to find the\n maximum ``z`` height.\n\n By default, this returns the mean of all local maxima. To get, e.g., the\n largest ``z`` excursion, pass in ``func=np.max``. To get all ``z``\n maxima, pass in ``func=None``.\n\n Parameters\n ----------\n func : func (optional)\n A function to evaluate on all of the identified z maximum times.\n return_times : bool (optional)\n Also return the times of maximum.\n approximate : bool (optional)\n Compute approximate values by skipping interpolation.\n\n Returns\n -------\n zs : float, :class:`~numpy.ndarray`\n Either a single number or an array of maximum z heights.\n times : :class:`~numpy.ndarray` (optional, see ``return_times``)\n If ``return_times=True``, also returns an array of the apocenter\n times.\n\n \"\"\"\n\n if return_times and func is not None:\n raise ValueError(\"Cannot return times if reducing \"\n \"using an input function. Pass `func=None` if \"\n \"you want to return all individual values \"\n \"and times.\")\n\n if func is None:\n reduce = False\n func = lambda x: x # noqa\n else:\n reduce = True\n\n # time must increase\n if self.t[-1] < self.t[0]:\n self = self[::-1]\n\n vals = []\n times = []\n for orbit in self.orbit_gen():\n v, t = orbit._max_helper(np.abs(orbit.cylindrical.z),\n approximate=approximate)\n vals.append(func(v))\n times.append(t)\n\n return self._max_return_helper(vals, times, return_times, reduce)\n\n def eccentricity(self, **kw):\n r\"\"\"\n Returns the eccentricity computed from the mean apocenter and\n mean pericenter.\n\n .. math::\n\n e = \\frac{r_{\\rm apo} - r_{\\rm per}}{r_{\\rm apo} + r_{\\rm per}}\n\n Parameters\n ----------\n **kw\n Any keyword arguments passed to ``apocenter()`` and\n ``pericenter()``. For example, ``approximate=True``.\n\n Returns\n -------\n ecc : float\n The orbital eccentricity.\n\n \"\"\"\n ra = self.apocenter(**kw)\n rp = self.pericenter(**kw)\n return (ra - rp) / (ra + rp)\n\n def estimate_period(self, radial=True):\n \"\"\"\n Estimate the period of the orbit. By default, computes the radial\n period. If ``radial==False``, this returns period estimates for\n each dimension of the orbit.\n\n Parameters\n ----------\n radial : bool (optional)\n What period to estimate. If ``True``, estimates the radial\n period. If ``False``, estimates period in each dimension, e.g.,\n if the orbit is 3D, along x, y, and z.\n\n Returns\n -------\n T : `~astropy.units.Quantity`\n The period or periods.\n \"\"\"\n\n if self.t is None:\n raise ValueError(\"To compute the period, a time array is needed. \"\n \"Specify a time array when creating this object.\")\n\n if radial:\n r = self.physicsspherical.r.value\n if self.norbits == 1:\n T = u.Quantity(peak_to_peak_period(self.t, r))\n else:\n T = u.Quantity([peak_to_peak_period(self.t, r[:, n])\n for n in range(r.shape[1])])\n\n else:\n raise NotImplementedError(\"sorry 'bout that...\")\n\n return T\n\n # ------------------------------------------------------------------------\n # Misc. useful methods\n # ------------------------------------------------------------------------\n def circulation(self):\n \"\"\"\n Determine which axes the Orbit circulates around by checking\n whether there is a change of sign of the angular momentum\n about an axis. Returns a 2D array with ``ndim`` integers per orbit\n point. If a box orbit, all integers will be 0. A 1 indicates\n circulation about the corresponding axis.\n\n TODO: clockwise / counterclockwise?\n\n For example, for a single 3D orbit:\n\n - Box and boxlet = [0, 0, 0]\n - z-axis (short-axis) tube = [0, 0, 1]\n - x-axis (long-axis) tube = [1, 0, 0]\n\n Returns\n -------\n circulation : :class:`numpy.ndarray`\n An array that specifies whether there is circulation about any of\n the axes of the input orbit. For a single orbit, will return a\n 1D array, but for multiple orbits, the shape will be\n ``(3, norbits)``.\n\n \"\"\"\n L = self.angular_momentum()\n\n # if only 2D, add another empty axis\n if L.ndim == 2:\n single_orbit = True\n L = L[..., None]\n else:\n single_orbit = False\n\n ndim, ntimes, norbits = L.shape\n\n # initial angular momentum\n L0 = L[:, 0]\n\n # see if at any timestep the sign has changed\n circ = np.ones((ndim, norbits))\n for ii in range(ndim):\n cnd = (np.sign(L0[ii]) != np.sign(L[ii, 1:])) | \\\n (np.abs(L[ii, 1:]).value < 1E-13)\n ix = np.atleast_1d(np.any(cnd, axis=0))\n circ[ii, ix] = 0\n\n circ = circ.astype(int)\n if single_orbit:\n return circ.reshape((ndim,))\n else:\n return circ\n\n def align_circulation_with_z(self, circulation=None):\n \"\"\"\n If the input orbit is a tube orbit, this function aligns the circulation\n axis with the z axis and returns a copy.\n\n Parameters\n ----------\n circulation : array_like (optional)\n Array of bits that specify the axis about which the orbit\n circulates. If not provided, will compute this using\n :meth:`~gala.dynamics.Orbit.circulation`. See that method for more\n information.\n\n Returns\n -------\n orb : :class:`~gala.dynamics.Orbit`\n A copy of the original orbit object with circulation aligned with\n the z axis.\n \"\"\"\n\n if circulation is None:\n circulation = self.circulation()\n circulation = atleast_2d(circulation, insert_axis=1)\n\n cart = self.cartesian\n pos = cart.xyz\n vel = np.vstack((cart.v_x.value[None],\n cart.v_y.value[None],\n cart.v_z.value[None])) * cart.v_x.unit\n\n if pos.ndim < 3:\n pos = pos[..., np.newaxis]\n vel = vel[..., np.newaxis]\n\n if (circulation.shape[0] != self.ndim or\n circulation.shape[1] != pos.shape[2]):\n raise ValueError(\"Shape of 'circulation' array should match the \"\n \"shape of the position/velocity (minus the time \"\n \"axis).\")\n\n new_pos = pos.copy()\n new_vel = vel.copy()\n for n in range(pos.shape[2]):\n if circulation[2, n] == 1 or np.all(circulation[:, n] == 0):\n # already circulating about z or box orbit\n continue\n\n if sum(circulation[:, n]) > 1:\n logger.warning(\"Circulation about multiple axes - are you sure \"\n \"the orbit has been integrated for long enough?\")\n\n if circulation[0, n] == 1:\n circ = 0\n elif circulation[1, n] == 1:\n circ = 1\n else:\n raise RuntimeError(\"Should never get here...\")\n\n new_pos[circ, :, n] = pos[2, :, n]\n new_pos[2, :, n] = pos[circ, :, n]\n\n new_vel[circ, :, n] = vel[2, :, n]\n new_vel[2, :, n] = vel[circ, :, n]\n\n return self.__class__(pos=new_pos.reshape(cart.xyz.shape),\n vel=new_vel.reshape(cart.xyz.shape),\n t=self.t,\n hamiltonian=self.hamiltonian)\n\n def plot(self, components=None, units=None, auto_aspect=True, **kwargs):\n \"\"\"\n Plot the positions in all projections. This is a wrapper around\n `~gala.dynamics.plot_projections` for fast access and quick\n visualization. All extra keyword arguments are passed to that function\n (the docstring for this function is included here for convenience).\n\n Parameters\n ----------\n components : iterable (optional)\n A list of component names (strings) to plot. By default, this is the\n Cartesian positions ``['x', 'y', 'z']``. To plot Cartesian\n velocities, pass in the velocity component names\n ``['v_x', 'v_y', 'v_z']``. If the representation is different, the\n component names will be different. For example, for a Cylindrical\n representation, the components are ``['rho', 'phi', 'z']`` and\n ``['v_rho', 'pm_phi', 'v_z']``.\n units : `~astropy.units.UnitBase`, iterable (optional)\n A single unit or list of units to display the components in.\n auto_aspect : bool (optional)\n Automatically enforce an equal aspect ratio.\n relative_to : bool (optional)\n Plot the values relative to this value or values.\n autolim : bool (optional)\n Automatically set the plot limits to be something sensible.\n axes : array_like (optional)\n Array of matplotlib Axes objects.\n subplots_kwargs : dict (optional)\n Dictionary of kwargs passed to :func:`~matplotlib.pyplot.subplots`.\n labels : iterable (optional)\n List or iterable of axis labels as strings. They should correspond to\n the dimensions of the input orbit.\n plot_function : callable (optional)\n The ``matplotlib`` plot function to use. By default, this is\n :func:`~matplotlib.pyplot.scatter`, but can also be, e.g.,\n :func:`~matplotlib.pyplot.plot`.\n **kwargs\n All other keyword arguments are passed to the ``plot_function``.\n You can pass in any of the usual style kwargs like ``color=...``,\n ``marker=...``, etc.\n\n Returns\n -------\n fig : `~matplotlib.Figure`\n\n \"\"\"\n from gala.tests.optional_deps import HAS_MATPLOTLIB\n if not HAS_MATPLOTLIB:\n raise ImportError('matplotlib is required for visualization.')\n import matplotlib.pyplot as plt\n\n if components is None:\n if self.ndim == 1: # only a 1D orbit, so just plot time series\n components = ['t', self.pos.components[0]]\n else:\n components = self.pos.components\n\n x, labels = self._plot_prepare(components=components,\n units=units)\n\n kwargs.setdefault('marker', '')\n kwargs.setdefault('linestyle', '-')\n kwargs.setdefault('labels', labels)\n kwargs.setdefault('plot_function', plt.plot)\n\n fig = plot_projections(x, **kwargs)\n\n if self.pos.get_name() == 'cartesian' and \\\n all([not c.startswith('d_') for c in components]) and \\\n 't' not in components and \\\n auto_aspect:\n for ax in fig.axes:\n ax.set(aspect='equal', adjustable='datalim')\n\n return fig\n\n def plot_3d(self, components=None, units=None, auto_aspect=True,\n subplots_kwargs=None, **kwargs):\n \"\"\"\n Plot the specified 3D components.\n\n Parameters\n ----------\n components : iterable (optional)\n A list of component names (strings) to plot. By default, this is the\n Cartesian positions ``['x', 'y', 'z']``. To plot Cartesian\n velocities, pass in the velocity component names\n ``['v_x', 'v_y', 'v_z']``. If the representation is different, the\n component names will be different. For example, for a Cylindrical\n representation, the components are ``['rho', 'phi', 'z']`` and\n ``['v_rho', 'pm_phi', 'v_z']``.\n units : `~astropy.units.UnitBase`, iterable (optional)\n A single unit or list of units to display the components in.\n auto_aspect : bool (optional)\n Automatically enforce an equal aspect ratio.\n ax : `matplotlib.axes.Axes`\n The matplotlib Axes object to draw on.\n subplots_kwargs : dict (optional)\n Dictionary of kwargs passed to :func:`~matplotlib.pyplot.subplots`.\n labels : iterable (optional)\n List or iterable of axis labels as strings. They should correspond\n to the dimensions of the input orbit.\n plot_function : str (optional)\n The ``matplotlib`` plot function to use. By default, this is 'plot'\n but can also be, e.g., 'scatter'.\n **kwargs\n All other keyword arguments are passed to the ``plot_function``.\n You can pass in any of the usual style kwargs like ``color=...``,\n ``marker=...``, etc.\n\n Returns\n -------\n fig : `~matplotlib.Figure`\n\n \"\"\"\n from gala.tests.optional_deps import HAS_MATPLOTLIB\n if not HAS_MATPLOTLIB:\n raise ImportError('matplotlib is required for visualization.')\n import matplotlib.pyplot as plt\n from mpl_toolkits import mplot3d # noqa\n\n if components is None:\n components = self.pos.components\n\n if subplots_kwargs is None:\n subplots_kwargs = dict()\n\n if len(components) != 3:\n raise ValueError(\n f\"The number of components ({len(components)}) must be 3\")\n\n x, labels = self._plot_prepare(components=components,\n units=units)\n\n kwargs.setdefault('marker', '')\n kwargs.setdefault('linestyle', kwargs.pop('ls', '-'))\n plot_function_name = kwargs.pop('plot_function', 'plot')\n\n ax = kwargs.pop('ax', None)\n subplots_kwargs.setdefault('constrained_layout', True)\n if ax is None:\n fig, ax = plt.subplots(figsize=(6, 6),\n subplot_kw=dict(projection='3d'),\n **subplots_kwargs)\n else:\n fig = ax.figure\n\n plot_function = getattr(ax, plot_function_name)\n if x[0].ndim > 1:\n for n in range(x[0].shape[1]):\n plot_function(*[xx[:, n] for xx in x], **kwargs)\n else:\n plot_function(*x, **kwargs)\n ax.set_xlabel(labels[0])\n ax.set_ylabel(labels[1])\n ax.set_zlabel(labels[2])\n\n if self.pos.get_name() == 'cartesian' and \\\n all([not c.startswith('d_') for c in components]) and \\\n 't' not in components and \\\n auto_aspect:\n for ax in fig.axes:\n ax.set(aspect='auto', adjustable='datalim')\n\n return fig, ax\n\n def animate(self,\n components=None,\n units=None,\n stride=1,\n segment_nsteps=10,\n underplot_full_orbit=True,\n marker_style=None,\n segment_style=None,\n FuncAnimation_kwargs=None,\n orbit_plot_kwargs=None,\n axes=None):\n \"\"\"\n Animate an orbit or collection of orbits.\n\n Parameters\n ----------\n components : iterable (optional)\n A list of component names (strings) to plot. By default, this is the\n Cartesian positions ``['x', 'y', 'z']``. To plot Cartesian\n velocities, pass in the velocity component names\n ``['v_x', 'v_y', 'v_z']``. If the representation is different, the\n component names will be different. For example, for a Cylindrical\n representation, the components are ``['rho', 'phi', 'z']`` and\n ``['v_rho', 'pm_phi', 'v_z']``.\n units : `~astropy.units.UnitBase`, iterable (optional)\n A single unit or list of units to display the components in.\n stride : int (optional)\n How often to draw a new frame, in terms of orbit timesteps.\n segment_nsteps : int (optional)\n How many timesteps to draw in an orbit segment trailing\n the timestep marker. Set this to 0 or None to disable.\n underplot_full_orbit : bool (optional)\n Controls whether to under-plot the full orbit as a thin line.\n marker_style : dict (optional)\n Matplotlib style arguments passed to `matplotlib.pyplot.plot`\n that control the plot style of the timestep marker.\n segment_style : dict (optional)\n Matplotlib style arguments passed to `matplotlib.pyplot.plot`\n that control the plot style of the orbit segment.\n FuncAnimation_kwargs : dict (optional)\n Keyword arguments passed through to\n `matplotlib.animation.FuncAnimation`.\n orbit_plot_kwargs : dict (optional)\n Keyword arguments passed through to `gala.dynamics.Orbit.plot`.\n axes : `matplotlib.axes.Axes` (optional)\n Where to draw the orbit.\n\n Returns\n -------\n fig : `matplotlib.figure.Figure`\n anim : `matplotlib.animation.FuncAnimation`\n\n \"\"\"\n from gala.tests.optional_deps import HAS_MATPLOTLIB\n if not HAS_MATPLOTLIB:\n raise ImportError('matplotlib is required for visualization.')\n from matplotlib.animation import FuncAnimation\n\n if components is None:\n if self.ndim == 1: # only a 1D orbit, so just plot time series\n components = ['t', self.pos.components[0]]\n else:\n components = self.pos.components\n\n # Extract the relevant components, in the given unit system\n xs, _ = self._plot_prepare(components=components,\n units=units)\n xs = [atleast_2d(xx, insert_axis=1) for xx in xs]\n\n # Figure out which components to plot on which axes\n data_paired = []\n for i in range(len(xs)):\n for j in range(len(xs)):\n if i >= j:\n continue # skip diagonal, upper triangle\n data_paired.append((xs[i], xs[j]))\n\n if FuncAnimation_kwargs is None:\n FuncAnimation_kwargs = dict()\n\n if orbit_plot_kwargs is None:\n orbit_plot_kwargs = dict()\n orbit_plot_kwargs.setdefault('zorder', 1)\n orbit_plot_kwargs.setdefault('color', '#aaaaaa')\n orbit_plot_kwargs.setdefault('linewidth', '1')\n orbit_plot_kwargs.setdefault('axes', axes)\n\n if marker_style is None:\n marker_style = dict()\n marker_style.setdefault('marker', 'o')\n marker_style.setdefault('linestyle', marker_style.pop('ls', 'None'))\n marker_style.setdefault('markersize', marker_style.pop('ms', 4.))\n marker_style.setdefault('color', marker_style.pop('c', 'tab:red'))\n marker_style.setdefault('zorder', 100)\n\n if segment_style is None:\n segment_style = dict()\n segment_style.setdefault('marker', 'None')\n segment_style.setdefault('linestyle', segment_style.pop('ls', '-'))\n segment_style.setdefault('linewidth', segment_style.pop('lw', 2.))\n segment_style.setdefault('color', segment_style.pop('c', 'tab:blue'))\n segment_style.setdefault('zorder', 10)\n if segment_nsteps is None or segment_nsteps == 0: # HACK\n segment_style['alpha'] = 0\n\n # Use this to get a figure with axes with the right limits\n # Note: Labels are added by .plot()\n if not underplot_full_orbit:\n orbit_plot_kwargs['alpha'] = 0\n fig = self.plot(components=components, units=units,\n **orbit_plot_kwargs)\n\n # Set up all of the (data-less) markers and line segments\n markers = []\n segments = []\n for n in range(self.norbits):\n _m = []\n _s = []\n for i in range(len(data_paired)):\n _m.append(fig.axes[i].plot([], [], **marker_style)[0])\n _s.append(fig.axes[i].plot([], [], **segment_style)[0])\n markers.append(_m)\n segments.append(_s)\n\n def anim_func(n):\n i = max(0, n - segment_nsteps)\n\n for k in range(self.norbits):\n for j in range(len(data_paired)):\n markers[k][j].set_data(data_paired[j][0][n:n+1, k],\n data_paired[j][1][n:n+1, k])\n segments[k][j].set_data(data_paired[j][0][i:n+1, k],\n data_paired[j][1][i:n+1, k])\n\n return (*[m for m in markers for x in m],\n *[s for s in segments for x in s])\n\n anim = FuncAnimation(fig, anim_func,\n frames=np.arange(0, self.ntimes, stride),\n **FuncAnimation_kwargs)\n\n return fig, anim\n\n def to_frame(self, frame, current_frame=None, **kwargs):\n \"\"\"\n Transform to a different reference frame.\n\n Parameters\n ----------\n frame : `gala.potential.CFrameBase`\n The frame to transform to.\n current_frame : `gala.potential.CFrameBase` (optional)\n If the Orbit has no associated Hamiltonian, this specifies the\n current frame of the orbit.\n\n Returns\n -------\n orbit : `gala.dynamics.Orbit`\n The orbit in the new reference frame.\n\n \"\"\"\n\n kw = kwargs.copy()\n\n # TODO: this short-circuit sux\n if current_frame is None:\n current_frame = self.frame\n if frame == current_frame and not kwargs:\n return self\n\n # TODO: need a better way to do this!\n from ..potential.frame.builtin import ConstantRotatingFrame\n for fr in [frame, current_frame, self.frame]:\n if isinstance(fr, ConstantRotatingFrame):\n if 't' not in kw:\n kw['t'] = self.t\n\n # TODO: this needs a re-write...\n psp = super().to_frame(frame, current_frame, **kw)\n\n return Orbit(pos=psp.pos, vel=psp.vel, t=self.t,\n frame=frame, potential=self.potential)\n\n # ------------------------------------------------------------------------\n # Compatibility with other packages\n #\n\n def to_galpy_orbit(self, ro=None, vo=None):\n \"\"\"Convert this object to a ``galpy.Orbit`` instance.\n\n Parameters\n ----------\n ro : `astropy.units.Quantity` or `astropy.units.UnitBase`\n \"Natural\" length unit.\n vo : `astropy.units.Quantity` or `astropy.units.UnitBase`\n \"Natural\" velocity unit.\n\n Returns\n -------\n galpy_orbit : `galpy.orbit.Orbit`\n\n \"\"\"\n from galpy.orbit import Orbit\n from galpy.util.config import __config__ as galpy_config\n\n if self.frame is not None:\n from ..potential import StaticFrame\n w = self.to_frame(StaticFrame(self.frame.units))\n else:\n w = self\n\n if ro is None:\n ro = galpy_config.getfloat('normalization', 'ro')\n ro = ro * u.kpc\n\n if vo is None:\n vo = galpy_config.getfloat('normalization', 'vo')\n vo = vo * u.km/u.s\n\n # PhaseSpacePosition or Orbit:\n cyl = w.cylindrical\n\n R = cyl.rho.to_value(ro).T\n phi = cyl.phi.to_value(u.rad).T\n z = cyl.z.to_value(ro).T\n\n vR = cyl.v_rho.to_value(vo).T\n vT = (cyl.rho * cyl.pm_phi).to_value(vo, u.dimensionless_angles()).T\n vz = cyl.v_z.to_value(vo).T\n\n o = Orbit(np.array([R, vR, vT, z, vz, phi]).T, ro=ro, vo=vo)\n if w.t is not None:\n o.t = w.t.to_value(ro / vo)\n\n return o\n\n @classmethod\n def from_galpy_orbit(self, galpy_orbit):\n \"\"\"Create a Gala ``PhaseSpacePosition`` or ``Orbit`` instance from a\n ``galpy.Orbit`` instance.\n\n Parameters\n ----------\n galpy_orbit : :class:`galpy.orbit.Orbit`\n\n Returns\n -------\n orbit : :class:`~gala.dynamics.Orbit`\n\n \"\"\"\n ro = galpy_orbit._ro * u.kpc\n vo = galpy_orbit._vo * u.km/u.s\n ts = galpy_orbit.t\n\n rep = coord.CylindricalRepresentation(\n rho=galpy_orbit.R(ts) * ro,\n phi=galpy_orbit.phi(ts) * u.rad,\n z=galpy_orbit.z(ts) * ro\n )\n with u.set_enabled_equivalencies(u.dimensionless_angles()):\n dif = coord.CylindricalDifferential(\n d_rho=galpy_orbit.vR(ts) * vo,\n d_phi=galpy_orbit.vT(ts) * vo / rep.rho,\n d_z=galpy_orbit.vz(ts) * vo\n )\n\n t = galpy_orbit.t * ro / vo\n return Orbit(rep, dif, t=t)\n", "meta": {"hexsha": "131effdc453fe91d7c6237864a00b0e540452ca1", "size": 43561, "ext": "py", "lang": "Python", "max_stars_repo_path": "gala/dynamics/orbit.py", "max_stars_repo_name": "akeemlh/gala", "max_stars_repo_head_hexsha": "0fdaf9159bccc59af2a3525f2926e04501754f48", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 86, "max_stars_repo_stars_event_min_datetime": "2016-05-19T21:58:43.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-22T14:56:37.000Z", "max_issues_repo_path": "gala/dynamics/orbit.py", "max_issues_repo_name": "akeemlh/gala", "max_issues_repo_head_hexsha": "0fdaf9159bccc59af2a3525f2926e04501754f48", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 170, "max_issues_repo_issues_event_min_datetime": "2016-06-27T14:10:26.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-10T22:52:39.000Z", "max_forks_repo_path": "gala/dynamics/orbit.py", "max_forks_repo_name": "akeemlh/gala", "max_forks_repo_head_hexsha": "0fdaf9159bccc59af2a3525f2926e04501754f48", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 66, "max_forks_repo_forks_event_min_datetime": "2016-09-13T07:31:29.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-08T15:08:45.000Z", "avg_line_length": 35.7643678161, "max_line_length": 91, "alphanum_fraction": 0.5471407911, "include": true, "reason": "import numpy,from scipy,import astropy", "num_tokens": 9558, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5389832206876841, "lm_q2_score": 0.37022539259558657, "lm_q1q2_score": 0.19954527448153153}} {"text": "from os import path\nimport numpy as np\nfrom pvpy import PowerSpectrum\n\ntry:\n filename = 'ASTMG173.csv'\n with open(path.join(__path__[0], filename)) as file:\n pass\nexcept IOError as e:\n print(\"Unable to open file %s\" % filename) # Does not exist OR no read permissions\n# TODO: Maybe allow direct download of ASTM1.5G spectrum if it is missing? It shoudln't be missing.\n# import os\n# if not os.path.isfile('ASTMG173.csv'):\n# try:\n# import urllib2, StringIO, tarfile\n# data_url = 'http://rredc.nrel.gov/solar/spectra/am1.5/ASTMG173/compressed/ASTMG173.csv.tar'\n# download_as_string = urllib2.urlopen(data_url).read()\n# download_as_file = StringIO.StringIO(download_as_string)\n# download_as_tarfile_object = tarfile.open(fileobj=download_as_file)\n# download_as_tarfile_object.extractfile('ASTMG173.csv')\n# except:\n# print(\"Unable to open file\") # Does not exist OR no read permissions\n# raise\n\n\ndef jsc(*args, kind: str =\"linear\", spectra: str =\"AM1.5G\", **kwargs):\n \"\"\"\n Gives the absorbed photocurrent in mA/cm**2 of a normalized spectrum.\n :param args: (array like) ideally (N,2)D numpy array with spec_in[:,0] as the wavelengths in nm and spec_in[:,1] as\n the values, but can also be two lists/vectors\n :param kind: (str) interpolation kind. see scipy.interpolate.interp1d\n :param spectra:\n :return:\n \"\"\"\n if len(args) > 1:\n assert args[0].size == args[1].size, \\\n \"arg1 is %g, arg2 is %g. The inputs should be the same sizes.\" % (args[0].size, args[1].size)\n args = [np.asarray(arg) if type(arg) is list else arg for arg in args]\n spec_in = np.column_stack((args[0], args[1]))\n print(\"Hi\")\n print(np.shape(spec_in))\n assert np.shape(spec_in)[1] == 2, \"The input arguments could not be converted to a (N,2) dimensional array.\"\n elif len(args[0].shape) > 1 and args[0].shape[1] != 1:\n spec_in = args[0].transpose()\n else:\n spec_in = args[0]\n spec_in = np.squeeze(spec_in)\n spec = PowerSpectrum.PhotocurrentSpectrum(spec_in[0, 0], spec_in[-1, 0], spectra)\n spec.weight_spectrum(spec_in, kind=kind)\n return spec.integrate() * .1\n", "meta": {"hexsha": "610441415f016db93ea327011116be18aeafbe82", "size": 2265, "ext": "py", "lang": "Python", "max_stars_repo_path": "build/lib/solspec/__init__.py", "max_stars_repo_name": "soamaven/pvpy", "max_stars_repo_head_hexsha": "3f8aa318642c91f9585b5885e94a7a464a1208f1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-01-04T13:06:54.000Z", "max_stars_repo_stars_event_max_datetime": "2018-01-04T13:06:54.000Z", "max_issues_repo_path": "build/lib/solspec/__init__.py", "max_issues_repo_name": "soamaven/pvpy", "max_issues_repo_head_hexsha": "3f8aa318642c91f9585b5885e94a7a464a1208f1", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "build/lib/solspec/__init__.py", "max_forks_repo_name": "soamaven/pvpy", "max_forks_repo_head_hexsha": "3f8aa318642c91f9585b5885e94a7a464a1208f1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.4117647059, "max_line_length": 119, "alphanum_fraction": 0.6463576159, "include": true, "reason": "import numpy", "num_tokens": 627, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.538983220687684, "lm_q2_score": 0.3702253925955866, "lm_q1q2_score": 0.1995452744815315}} {"text": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\n\"\"\"\nWritten by Lucas Sinclair and Paul Rougieux.\n\nJRC Biomass Project.\nUnit D1 Bioeconomy.\n\nTypically you can use this submodule like this:\n\n >>> from forest_puller.conversion.bcef_by_country import country_bcef\n >>> print(country_bcef.by_country_year)\n\"\"\"\n\n# Built-in modules #\nimport itertools\n\n# Internal modules #\nfrom forest_puller.conversion.load_expansion_factor import bcef_coefs\nfrom forest_puller.common import country_codes\nfrom forest_puller import cache_dir\n\n# First party modules #\nfrom plumbing.cache import property_cached, property_pickled_at\n\n# Third party modules #\nimport numpy, pandas\n\n###############################################################################\nclass CountryBCEF:\n \"\"\"\n This class uses the stock of merchantable biomass in each country\n to choose 2 factors:\n\n * The biomass conversion and expansion factor BCEF.\n * The root to shoot ratio R.\n\n These factors come from table 4.5 and 4.4 respectively in the following\n IPCC guideline document:\n\n https://www.ipcc-nggip.iges.or.jp/public/2006gl/pdf/4_Volume4/V4_04_Ch4_Forest_Land.pd\n\n We first use the BCEF_R to expand the merchantable growing stock volume to\n above-ground biomass stock. The above ground biomass stock is then used as\n a threshold to choose the root to shoot ratio.\n\n Interesting intermediary tables for further analysis:\n\n * `all_stock_merch` contains the stock in merchantable volume per ha\n and per leaf type.\n * `all_stock_abg_biomass` contains the stock in above ground biomass weight\n expressed in tons per ha and per leaf type.\n \"\"\"\n\n min_year = 1990\n max_year = 2020\n\n @property_cached\n def country_climates(self):\n \"\"\"\n This dataframe looks like this:\n\n country climatic_zone climatic_coef\n 0 AT boreal 0.0\n 1 AT temperate 1.0\n 2 AT mediterranean 0.0\n 3 BE boreal 0.0\n 4 BE temperate 1.0\n \"\"\"\n # Load #\n df = country_codes\n # Keep only some columns #\n columns = ['iso2_code', 'boreal', 'temperate', 'mediterranean']\n df = df[columns].copy()\n # Rename column #\n df = df.rename(columns={'iso2_code': 'country'})\n # Unpivot #\n df = df.melt(id_vars = ['country'],\n var_name = 'climatic_zone',\n value_name = 'climatic_coef')\n # Sort #\n df = df.sort_values('country')\n # Reset index #\n df = df.reset_index(drop=True)\n # Return #\n return df\n\n @property\n def all_stock_merch(self):\n \"\"\"\n This data frame looks like this:\n\n country year forest_type area stock_per_ha\n 0 AT 1990 con ... ...\n 1 AT 1990 broad ... ...\n 2 AT 1990 mixed ... ...\n 3 AT 2000 con ... ...\n 4 AT 2000 broad ... ...\n .. ... ... ... ... ...\n\n All columns are:\n\n ['country', 'year', 'forest_type', 'area', 'stock_per_ha']\n\n \"\"\"\n # Import #\n import forest_puller.soef.concat\n # Load #\n area = forest_puller.soef.concat.tables['area_by_type'].copy()\n stock = forest_puller.soef.concat.tables['stock_by_type'].copy()\n # Remove null areas and make them NaNs #\n selector = area.area == 0\n area.loc[selector, 'area'] = numpy.NaN\n # Add the area to make one big dataframe #\n df = stock.left_join(area, on=['country', 'year', 'category'])\n # Rename category to forest_type #\n df = df.rename(columns={'category': 'forest_type'})\n # Compute stock by hectare #\n df['stock_per_ha'] = df['stock'] / df['area']\n # Drop lines with NaN #\n df = df.query(\"stock_per_ha == stock_per_ha\")\n # Now we don't need the stock column anymore #\n df = df.drop(columns=['stock'])\n # Return #\n return df\n\n @property\n def all_stock_merch_by_climate(self):\n \"\"\"\n This dataframe looks like this:\n\n country year forest_type area stock_per_ha climatic_zone climatic_coef\n 0 AT 1990 con ... ... boreal 0.0\n 1 AT 1990 con ... ... temperate 1.0\n 2 AT 1990 con ... ... mediterranean 0.0\n 3 AT 1990 broad ... ... boreal 0.0\n 4 AT 1990 broad ... ... temperate 1.0\n\n Warning: the stock per area values are duplicated for each country and forest type\n\n All columns are:\n\n ['country', 'year', 'forest_type', 'area', 'climatic_zone',\n 'climatic_coef', 'stock_per_ha']\n \"\"\"\n # Load #\n df = self.all_stock_merch.copy()\n # Drop mixed forest #\n df = df.query(\"forest_type != 'mixed'\")\n # Add country info #\n df = df.left_join(self.country_climates, on=\"country\")\n # Return #\n return df\n\n def get_one_bcef(self, row, kind):\n \"\"\"Function to be applied to each row of the previous dataframe.\"\"\"\n # If we get a NaN we return a NaN #\n if row['stock_per_ha'] != row['stock_per_ha']: return numpy.nan\n # Load #\n df = bcef_coefs\n # Select corresponding climatic zone #\n df = df.query(f\"climatic_zone == '{row['climatic_zone']}'\")\n # Select corresponding fores type#\n df = df.query(f\"forest_type == '{row['forest_type']}'\")\n # Select corresponding bounds on stock per hectare #\n df = df.query(f\"lower < {row['stock_per_ha']} <= upper\")\n # Make sure we have note more than one line #\n assert len(df) <= 1\n # Extract single float #\n result = df['bcef' + kind].iloc[0]\n # Return #\n return result\n\n @property\n def with_bcef_coefs(self):\n \"\"\"\n This dataframe is the same as above except we have added three\n columns. All columns are:\n\n ['country', 'year', 'forest_type', 'area', 'climatic_zone',\n 'climatic_coef', 'bcefi', 'bcefr', 'bcefs']\n \"\"\"\n # Load #\n df = self.all_stock_merch_by_climate.copy()\n # Add three columns #\n df['bcefi'] = df.apply(lambda row: self.get_one_bcef(row, 'i'), axis=1)\n df['bcefr'] = df.apply(lambda row: self.get_one_bcef(row, 'r'), axis=1)\n df['bcefs'] = df.apply(lambda row: self.get_one_bcef(row, 's'), axis=1)\n # Now we don't need the stock_per_ha column anymore #\n df = df.drop(columns=['stock_per_ha'])\n # Return #\n return df\n\n @property_pickled_at('cache_path')\n def by_country_year(self):\n \"\"\"\n This dataframe has three coefficients 'bcefi', 'bcefr', 'bcefs'\n for every country and for every SOEF year (except 2015).\n\n The dataframe looks like this:\n\n bcefi bcefr bcefs\n country year\n AT 1990 0.600000 0.843959 0.764714\n 2000 0.574885 0.795115 0.720929\n 2005 0.573515 0.796485 0.722071\n 2010 0.572161 0.797839 0.723199\n \"\"\"\n # Load #\n df = self.with_bcef_coefs.copy()\n # Multiply by the climatic situation #\n df['bcefi'] *= df['climatic_coef']\n df['bcefr'] *= df['climatic_coef']\n df['bcefs'] *= df['climatic_coef']\n # Now we don't need that column anymore #\n df = df.drop(columns=['climatic_coef'])\n # Group and sum each BCEF while keeping area #\n groups = df.groupby(['country', 'year', 'forest_type'])\n df = groups.agg({'bcefi': 'sum',\n 'bcefr': 'sum',\n 'bcefs': 'sum',\n 'area': 'first'})\n # Get the ratio of conifers against broadleaved #\n groups = df.groupby(['country', 'year'])\n df['area_total'] = groups['area'].transform('sum')\n df['tree_coef'] = df['area'] / df['area_total']\n # Multiply by the ratio of the given leaf type #\n df['bcefi'] *= df['tree_coef']\n df['bcefr'] *= df['tree_coef']\n df['bcefs'] *= df['tree_coef']\n # Group and sum each BCEF #\n groups = df.groupby(['country', 'year'])\n df = groups.agg({'bcefi': 'sum',\n 'bcefr': 'sum',\n 'bcefs': 'sum'})\n df = df.reset_index()\n # Return #\n return df\n\n #------------------------------- Interpolation ---------------------------#\n @property\n def by_country_year_intrpld(self):\n \"\"\"\n Same as above but interpolate the coefficients to get more years.\n \"\"\"\n # Create a small data frame with all country and years #\n countries = self.by_country_year['country'].drop_duplicates()\n years = range(self.min_year, self.max_year)\n expand_grid = list(itertools.product(countries, years))\n df = pandas.DataFrame(expand_grid, columns=('country', 'year'))\n # Join the BCEF data #\n df = df.left_join(self.by_country_year, on=['country','year'])\n # Interpolate #\n country_groups = df.groupby('country')\n df['bcefi'] = country_groups['bcefi'].transform(pandas.DataFrame.interpolate,\n limit_direction='both')\n df['bcefr'] = country_groups['bcefr'].transform(pandas.DataFrame.interpolate,\n limit_direction='both')\n df['bcefs'] = country_groups['bcefs'].transform(pandas.DataFrame.interpolate,\n limit_direction='both')\n # Return #\n return df\n\n #---------------------------- Special properties -------------------------#\n @property_cached\n def all_stock_abg_biomass(self):\n \"\"\"\n This data frame contains the above ground biomass stock per hectare\n expressed in tons of dry biomass. The method converts merchantable\n biomass volume (m3 of trunk) to above ground biomass weight (tons of\n dry biomass of trunk plus branches).\n\n The table looks like this:\n\n country year forest_type area stock_per_ha\n 1 AT 1990 con ... ...\n 1 AT 1990 broad ... ...\n 2 AT 1990 mixed ... ...\n 3 AT 2000 con ... ...\n \"\"\"\n # Load #\n stock_merch = self.all_stock_merch\n bcef_by_country_year = self.by_country_year\n # Join the biomass conversion factors (bcef) to the stock data\n index = ['country', 'year']\n df = stock_merch.left_join(bcef_by_country_year, on=index)\n # Compute the above ground biomass stock\n df['stock_per_ha'] *= df['bcefs']\n # Drop the coefficients columns #\n df = df.drop(columns=['bcefi', 'bcefr', 'bcefs'])\n # Return #\n return df\n\n # --------------------------------- Cache --------------------------------- #\n @property\n def cache_path(self):\n \"\"\"Specify where on the file system we will pickle the dataframe.\"\"\"\n path = cache_dir + 'conversion/bcef.pickle'\n return path\n\n###############################################################################\n# Create a singleton #\ncountry_bcef = CountryBCEF()\n", "meta": {"hexsha": "3b33959998de49a884526d5daf1533f725ea6d9a", "size": 11951, "ext": "py", "lang": "Python", "max_stars_repo_path": "forest_puller/conversion/bcef_by_country.py", "max_stars_repo_name": "xapple/forest_puller", "max_stars_repo_head_hexsha": "3bc9c35e2308e57b90e9210b30d68e67ee86f4d2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-11-10T14:52:34.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-10T14:52:34.000Z", "max_issues_repo_path": "forest_puller/conversion/bcef_by_country.py", "max_issues_repo_name": "xapple/forest_puller", "max_issues_repo_head_hexsha": "3bc9c35e2308e57b90e9210b30d68e67ee86f4d2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "forest_puller/conversion/bcef_by_country.py", "max_forks_repo_name": "xapple/forest_puller", "max_forks_repo_head_hexsha": "3bc9c35e2308e57b90e9210b30d68e67ee86f4d2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-09-16T08:07:28.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-16T08:07:28.000Z", "avg_line_length": 39.1836065574, "max_line_length": 91, "alphanum_fraction": 0.5237218643, "include": true, "reason": "import numpy", "num_tokens": 2819, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.538983220687684, "lm_q2_score": 0.3702253925955866, "lm_q1q2_score": 0.1995452744815315}} {"text": "\"\"\" Gravitational Wave Surrogate classes for text and hdf5 files\"\"\"\n\nfrom __future__ import division # for py2\n\n__copyright__ = \"Copyright (C) 2014 Scott Field and Chad Galley\"\n__email__ = \"sfield@astro.cornell.edu, crgalley@tapir.caltech.edu\"\n__status__ = \"testing\"\n__author__ = \"Jonathan Blackman, Scott Field, Chad Galley, Vijay Varma, Kevin Barkett\"\n\n__license__ = \"\"\"\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n\"\"\"\n\n# adding \"_\" prefix to potentially unfamiliar module names\n# so they won't show up in gws' tab completion\nimport numpy as np\nfrom scipy.interpolate import InterpolatedUnivariateSpline as _iuspline\nfrom gwtools.harmonics import sYlm as _sYlm\n\nif __package__ is \"\" or \"None\": # py2 and py3 compatible\n print(\"setting __package__ to gwsurrogate.new so relative imports work\")\n __package__=\"gwsurrogate.new\"\n\n# assumes unique global names\nfrom .saveH5Object import SimpleH5Object\nfrom .saveH5Object import H5ObjectList\nfrom .saveH5Object import H5ObjectDict\nfrom .nodeFunction import NodeFunction\nfrom .spline_evaluation import TensorSplineGrid, fast_complex_tensor_spline_eval\nfrom gwsurrogate import spline_interp_Cwrapper\nfrom .tidal_functions import UniversalRelationLambda2ToI, \\\n UniversalRelationLambda2ToOmega2, UniversalRelationLambda2ToLambda3, \\\n UniversalRelationLambda3ToOmega3, UniversalRelationLambda2ToAqm, \\\n EffectiveDeformabilityFromDynamicalTides, PNT2Tidal, \\\n EffectiveDissipativeDynamicalTides, StrainTidalEnhancementFactor\n\nPARAM_NUDGE_TOL = 1.e-12 # Default relative tolerance for nudging edge cases\n\n\ndef _identity(r1, r2):\n return r1, r2\ndef _amp_phase(r1, r2):\n return r1['amp']*np.exp(1.j*r1['phase'])\ndef _re_im(r1, r2):\n return r1['re'] + 1.j*r1['im']\n\nRECOMBINATION_FUNCS = {\n 'identity': _identity,\n 'amp_phase': _amp_phase,\n 're_im': _re_im,\n }\n\n\ndef _mode_sum(modes, theta, phi):\n h = 0.\n for (ell, m), h_mode in modes.items(): # inefficient in py2\n h += _sYlm(-2, ell, m, theta, phi) * h_mode\n return h\n\n\ndef _splinterp(xout, xin, yin, k=3, ext='const'):\n \"\"\"Uses InterpolatedUnivariateSpline to interpolate real or complex data\"\"\"\n if np.iscomplexobj(yin):\n re = _splinterp(xout, xin, np.real(yin), k=k, ext=ext)\n im = _splinterp(xout, xin, np.imag(yin), k=k, ext=ext)\n return re + 1.j*im\n else:\n return _iuspline(xin, yin, k=k, ext=ext)(xout)\n\ndef _splinterp_Cwrapper(xout, xin, yin):\n \"\"\"Uses gsl splines with a wrapper to interpolate real or complex data.\n Uses natural boundary conditions instead of not-a-knot boundary conditions\n like InterpolatedUnivariateSpline.\"\"\"\n if len(xin) != len(yin):\n raise Exception('Expected x and y input lengths to match.')\n if np.iscomplexobj(yin):\n re = _splinterp_Cwrapper(xout, xin, np.real(yin))\n im = _splinterp_Cwrapper(xout, xin, np.imag(yin))\n return re + 1.j*im\n else:\n return spline_interp_Cwrapper.interpolate(xout, xin, yin)\n\n\nclass ParamDim(SimpleH5Object):\n \"\"\"\n A helper class containing the information and functions for a single\n parameter space dimension\n \"\"\"\n\n def __init__(self, name='', min_val=0, max_val=1, rtol=PARAM_NUDGE_TOL):\n \"\"\"\n name: A descriptive name for this parameter dimension\n min_val: The minimum allowed value for this parameter\n max_val: The maximum allowed value for this parameter\n rtol: A relative tolerance for nudging parameters lying outside\n [min_val, max_val]. Scaled by (max_val - min_val) for an absolute\n tolerance. Useful to avoid machine precision issues.\n \"\"\"\n super(ParamDim, self).__init__()\n\n tol = rtol * (max_val - min_val)\n\n if min_val + 2*tol > max_val:\n raise Exception(\"tol %s is too large for %s with range [%s, %s]\"%(\n tol, name, min_val, max_val))\n\n self.name = name\n self.min_val = min_val\n self.max_val = max_val\n self.tol = tol\n self.tol_max = max_val - tol\n self.tol_min = min_val + tol\n\n def __str__(self):\n return self.name\n\n def __repr__(self):\n return '%s: [%s, %s] with tol %s'%(self.name, self.min_val,\n self.max_val, self.tol)\n\n def nudge(self, x):\n \"\"\"\n Returns a nudged version of x lying within [min_val+tol, max_val-tol].\n x can have any shape. Returns x if it already lies in the interval.\n x must already lie within [min_val - tol, max_val + tol].\n \"\"\"\n xmax = np.max(x)\n xmin = np.min(x)\n\n if xmax > self.tol_max:\n if xmax > self.max_val + self.tol:\n raise Exception(\"The maximum allowed %s is %s, got %s\"%(\n self.name, self.max_val, xmax))\n x = np.amin([x, np.ones(np.shape(x)) * self.tol_max], axis=0)\n\n if xmin < self.tol_min:\n if xmin < self.min_val - self.tol:\n raise Exception(\"The maximum allowed %s is %s, got %s\"%(\n self.name, self.min_val, xmin))\n x = np.amax([x, np.ones(np.shape(x)) * self.tol_min], axis=0)\n\n return x\n\n\nclass ParamSpace(SimpleH5Object):\n \"\"\"\n A helper class for all the parameter domain related information and\n functions.\n \"\"\"\n\n def __init__(self, name='', params=[]):\n \"\"\"\n name: A descriptive name for this parameter space\n params: A list of ParamDim instances, one per parameter dimension\n \"\"\"\n super(ParamSpace, self).__init__(['name', 'dim'], ['_params'])\n\n self.name = name\n self._params = H5ObjectList(params)\n self.dim = len(params)\n\n def __str__(self):\n return self.name\n\n def __repr__(self):\n return '%s: %s'%(self.name, [p.name for p in self._params])\n\n def param_names(self):\n \"\"\"Returns the list of names for each parameter space dimension\"\"\"\n return [p.name for p in self._params]\n\n def min_vals(self):\n \"\"\"Returns a list of minimum parameter space values\"\"\"\n return [p.min_val for p in self._params]\n\n def max_vals(self):\n \"\"\"Returns a list of maximum parameter space values\"\"\"\n return [p.max_val for p in self._params]\n\n def nudge_params(self, x):\n \"\"\"\n Nudges parameters lying slightly outside the valid domain to the\n boundary. x can be a single 1d parameter vector or a 2d vector with\n shape (n_params, self.dim).\n \"\"\"\n\n xshape = np.shape(x)\n\n # It's convenient to be able to accept a float instead of a length-1\n # array for 1d parameter spaces.\n if len(xshape) == 0:\n x = np.array([x])\n xshape = np.shape(x)\n\n if len(xshape) == 1:\n if len(x) != self.dim:\n raise Exception(\"Parameter space has dimension %s, got %s.\"%(\n self.dim, xshape))\n res = np.array([p.nudge(xi) for p, xi in zip(self._params, x)])\n\n elif len(xshape) == 2:\n if xshape[1] != self.dim:\n raise Exception(\"Expecting array with shape (n, %s), got %s\"%(\n self.dim, xshape))\n res = np.array([p.nudge(xi) for p, xi in zip(self._params, x.T)])\n\n else:\n raise Exception(\"x should be 1d or 2d, got shape {}\".format(xshape))\n\n return res\n\n def h5_prepare_subs(self):\n \"\"\"Setup dummy subordinates before loading them\"\"\"\n params = [ParamDim() for _ in range(self.dim)]\n self._params = H5ObjectList(params)\n\n\nclass _SingleFunctionSurrogate_NoChecks(SimpleH5Object):\n \"\"\"\n A surrogate model for a single (real or complex) function on a 1d domain.\n Skips sanity/validity checks, so should be called with sanitized inputs.\n Use SingleFunctionSurrogate for actual surrogates of single functions.\n \"\"\"\n\n def __init__(self, name=None, ei_basis=None, node_functions=[]):\n \"\"\"\n name: A descriptive name for the function this surrogate models\n ei_basis: A basis with shape (n_nodes, len(domain)).\n Interpolation is done via nodes.dot(ei_basis)\n node_functions: A list of evaluators for each node.\n Each one takes a parameter space vector x and returns\n the node evaluated at x.\n \"\"\"\n super(_SingleFunctionSurrogate_NoChecks, self).__init__(\n data_keys=['name', 'ei_basis', 'n_nodes'],\n sub_keys=['node_functions'])\n\n self.name = name\n self.ei_basis = ei_basis\n self.n_nodes = len(node_functions)\n self.node_functions = H5ObjectList(node_functions)\n\n def __str__(self):\n return self.name\n\n def __repr__(self):\n return self.name\n\n def __call__(self, x):\n \"\"\"\n Evaluates the surrogate at x, returning the result.\n \"\"\"\n nodes = np.array([nf(x) for nf in self.node_functions])\n return nodes.dot(self.ei_basis)\n\n def h5_prepare_subs(self):\n \"\"\"Setup NodeFunctions before loading them\"\"\"\n tmp_nodes = [NodeFunction() for _ in range(self.n_nodes)]\n self.node_functions = H5ObjectList(tmp_nodes)\n\n\nclass SingleFunctionSurrogate(_SingleFunctionSurrogate_NoChecks):\n \"\"\"\n A surrogate model for a single (real or complex) function on a 1d domain.\n \"\"\"\n\n def __init__(self, name=None, domain=None, param_space=None,\n ei_basis=None, node_functions=[]):\n \"\"\"\n name: A descriptive name for the function this surrogate models\n domain: A 1d array of the monotonically increasing domain\n (time/frequency) values\n param_space: A ParamSpace for this surrogate\n ei_basis: A basis with shape (n_nodes, len(domain)).\n Interpolation is done via nodes.dot(ei_basis)\n node_functions: A list of evaluators for each node.\n Each one takes a parameter space vector x and returns\n the node evaluated at x.\n \"\"\"\n super(SingleFunctionSurrogate, self).__init__(name=name,\n ei_basis=ei_basis, node_functions=node_functions)\n\n if domain is not None and np.min(np.diff(domain)) <= 0.0:\n raise Exception(\"domain should be monotonically increasing\")\n\n self.domain = domain\n self.param_space = param_space\n\n self._h5_data_keys.append('domain')\n self._h5_subordinate_keys.append('param_space')\n\n def h5_prepare_subs(self):\n super(SingleFunctionSurrogate, self).h5_prepare_subs()\n self.param_space = ParamSpace()\n\n def __repr__(self):\n return '%s (%s)'%(self.name, self.param_space.name)\n\n def __call__(self, x, domain=None):\n \"\"\"\n Evaluates the surrogate at x, returning the result.\n domain: An optional 1d array of domain values. If given, the result is\n evaluated at the domain values.\n \"\"\"\n # Verify valid parameters and domain\n x = self.param_space.nudge_params(x)\n if domain is not None:\n if domain[0] < self.domain[0] or domain[-1] > self.domain[-1]:\n raise Exception(\"Domain must lie in [%s, %s]\"%(\n self.domain[0], self.domain[-1]))\n\n res = super(SingleFunctionSurrogate, self).__call__(x)\n\n if domain is not None:\n res = _splinterp(domain, self.domain, res)\n\n return res\n\n\nclass _ManyFunctionSurrogate_NoChecks(SimpleH5Object):\n \"\"\"\n A container for surrogates sharing the same parameter space and domain.\n Skips checks, assuming they have already been performed.\n \"\"\"\n\n def __init__(self, name='', single_function_components={},\n many_function_components={}, combine_func='identity'):\n \"\"\"\n name: A descriptive name for this surrogate.\n single_function_components: A dictionary of components, where the\n values are (ei_basis, node_functions) tuples.\n many_function_components: A dictionary of _ManyFunctionSurrogate_NoCheck\n components, where the values are\n (combine_func, single_function_components,\n many_function_components) tuples.\n combine_func: A key of RECOMBINATION_FUNCS used to combine subordinate\n results into a single result.\n \"\"\"\n super(_ManyFunctionSurrogate_NoChecks, self).__init__(\n data_keys=['name', 'func_keys', 'sur_keys', 'combine_func'],\n sub_keys=['func_subs', 'sur_subs'])\n\n self.name = name\n self.combine_func = combine_func\n self.func_keys = list(single_function_components.keys())\n self.sur_keys = list(many_function_components.keys())\n if len(set(self.func_keys).intersection(self.sur_keys)) > 0:\n raise Exception(\"Component keys must be unique! Got %s, %s\"%(\n self.func_keys, self.sur_keys))\n\n func_sub_dict = {}\n for k, (ei, nf) in single_function_components.items(): # inefficient in py2\n func_sub_dict[k] = _SingleFunctionSurrogate_NoChecks(k, ei, nf)\n self.func_subs = H5ObjectDict(func_sub_dict)\n\n sur_sub_dict = {}\n for k, (cf, sfc, mfc) in many_function_components.items(): # inefficient in py2\n sur_sub_dict[k] = _ManyFunctionSurrogate_NoChecks(k, sfc, mfc, cf)\n self.sur_subs = H5ObjectDict(sur_sub_dict)\n\n def h5_prepare_subs(self):\n \"\"\"\n Initialize subordinate surrogate class instances so they can\n load their own data from h5 files.\n \"\"\"\n self.func_subs = H5ObjectDict({k: _SingleFunctionSurrogate_NoChecks()\n for k in self.func_keys})\n self.sur_subs = H5ObjectDict({k: _ManyFunctionSurrogate_NoChecks()\n for k in self.sur_keys})\n\n def __str__(self):\n return self.name\n\n def __call__(self, x):\n func_evals = {k: sur(x) for k, sur in self.func_subs.iteritems()} # inefficient in py2\n sur_evals = {k: sur(x) for k, sur in self.sur_subs.iteritems()} # inefficient in py2\n return RECOMBINATION_FUNCS[self.combine_func](func_evals, sur_evals)\n\n def _eval_func(self, x, key):\n return self.func_subs[key](x)\n\n def _eval_sur(self, x, key):\n return self.sur_subs[key](x)\n\n\nclass ManyFunctionSurrogate(_ManyFunctionSurrogate_NoChecks):\n \"\"\"\n A container for surrogates sharing the same parameter space and domain.\n \"\"\"\n\n def __init__(self, name='', domain=None, param_space=None,\n single_function_components={}, many_function_components={},\n combine_func='identity'):\n \"\"\"\n name: A descriptive name for this surrogate.\n param_space: A ParamSpace for this surrogate.\n single_function_components: A dictionary of components, where the\n values are (ei_basis, node_functions) tuples.\n many_function_components: A dictionary of _ManyFunctionSurrogate_NoCheck\n components, where the values are\n (combine_func, single_function_components,\n many_function_components) tuples.\n combine_func: A key of RECOMBINATION_FUNCS used to combine subordinate\n results into a single result.\n \"\"\"\n super(ManyFunctionSurrogate, self).__init__(\n name=name,\n single_function_components=single_function_components,\n many_function_components=many_function_components,\n combine_func=combine_func,\n )\n\n self.domain = domain\n self.param_space = param_space\n self._h5_data_keys.append('domain')\n self._h5_subordinate_keys.append('param_space')\n\n def h5_prepare_subs(self):\n super(ManyFunctionSurrogate, self).h5_prepare_subs()\n self.param_space = ParamSpace()\n\n def __call__(self, x):\n \"\"\"\n Evaluates the surrogate at x, returning the result.\n \"\"\"\n # Verify valid parameters\n x = self.param_space.nudge_params(x)\n return super(ManyFunctionSurrogate, self)(x)\n\nclass FastTensorSplineSurrogate(SimpleH5Object):\n \"\"\"\n A special case of having a complex empirical interpolant combined with\n tensor splines for the real and imaginary parts of each empirical node,\n for each waveform mode. All tensor splines must use the same grid.\n Written for speed, minimizing python operations\n between tensor spline interpolations, which are done simultaneously for\n each mode to keep numpy busy. Obtained ~25ms evaluation time per waveform\n for 12 waveform modes. This was ~66ms when using the python class\n hierarchy, and using a separate call to numpy for each tensor spline\n interpolation. Note that similar C code written with gsl splines takes\n ~50ms, but should have room for optimization.\n \"\"\"\n\n def __init__(self, name=None, domain=None, param_space=None,\n knot_vecs=[], mode_data={}, modes=None):\n\n super(FastTensorSplineSurrogate, self).__init__(\n sub_keys=['param_space', 'ts_grid'],\n data_keys=['name', 'domain', 'ei', 'cre', 'cim', 'mode_list',\n 'mode_indices'])\n\n self.name = name\n self.domain = domain\n self.param_space = param_space\n if param_space is None:\n self.param_space = ParamSpace()\n if modes is None:\n modes = list(mode_data.keys())\n self.mode_list = modes\n self.mode_indices = {str(k): i for i, k in enumerate(modes)}\n self.ei = [mode_data[k][0] for k in modes]\n self.cre = [mode_data[k][1] for k in modes]\n self.cim = [mode_data[k][2] for k in modes]\n self.ts_grid = TensorSplineGrid(knot_vecs)\n\n def __call__(self, x, theta=None, phi=None, modes=None):\n \"\"\"\n Return surrogate evaluation.\n Arguments:\n x : The intrinsic parameters (see self.param_space)\n theta/phi : polar and azimuthal angles of the direction of\n gravitational wave emission. If given, sums up modes\n and returns h_plus and h_cross (default returns modes)\n modes : A list of (ell, m) modes to be evaluated (default: all)\n Returns h:\n h : If theta and phi are None, h is a dictionary of waveform modes\n sampled at self.domain with (ell, m) keys.\n If theta and phi are given, h = h_plus - i * h_cross is a\n complex array given by the sum of the modes.\n \"\"\"\n if (theta is None) != (phi is None):\n raise Exception(\"Either give theta and phi or neither\")\n\n x = self.param_space.nudge_params(x)\n\n if modes is None:\n modes = self.mode_list\n\n h_modes = {}\n for k in modes:\n i = self.mode_indices[str(k)]\n\n h_eim = fast_complex_tensor_spline_eval(x,self.ts_grid,self.cre[i],self.cim[i])\n\n # Evaluate the empirical interpolant\n h_modes[k] = h_eim.dot(self.ei[i])\n\n if theta is not None:\n return _mode_sum(h_modes, theta, phi)\n\n return h_modes\n\n\nclass MultiModalSurrogate(ManyFunctionSurrogate):\n \"\"\"\n A surrogate for multimodal waveforms, where each waveform mode has\n its own surrogate. Contains added functionality for evaluating on\n sphere.\n \"\"\"\n\n def __init__(self, name=None, domain=None, param_space=None,\n mode_data={}, mode_type='complex', modes=None):\n \"\"\"\n name: A descriptive name for this surrogate.\n domain: A 1d array of the monotonically increasing domain\n (time/frequency) values\n param_space: A ParamSpace for this surrogate.\n mode_data: A dictionary of modes with (l, m) integer keys,\n where the values are (ei_basis, node_functions) tuples.\n mode_type: Can be 'amp_phase', 're_im', or 'complex' depending on\n how mode surrogates are built. If 'amp_phase' or 're_im',\n mode_data values should instead be dictionaries with keys\n ['amp', 'phase'] or ['re', 'im'] and\n (ei_basis, node_functions) values.\n modes: A list of (ell, m) modes giving an ordering to mode_data.keys().\n If None, uses mode_data.keys().\n \"\"\"\n\n if mode_type == 'complex':\n super(MultiModalSurrogate, self).__init__(name, domain, param_space,\n mode_data, {}, 'identity')\n elif mode_type in ['amp_phase', 're_im']:\n mode_data = {k: (mode_type, v, {})\n for k, v in mode_data.items()} # inefficient in py2\n super(MultiModalSurrogate, self).__init__(name, domain, param_space,\n {}, mode_data, mode_type)\n else:\n raise ValueError(\"Invalid mode_type: %s\"%(mode_type))\n\n self.mode_type = mode_type\n if modes is None:\n self.modes = list(mode_data.keys())\n else:\n self.modes = modes\n\n self._h5_data_keys.append('modes')\n self._h5_data_keys.append('mode_type')\n\n\n def __call__(self, x, theta=None, phi=None, modes=None):\n \"\"\"\n Return surrogate evaluation.\n Arguments:\n x : The intrinsic parameters (see self.param_space)\n theta/phi : polar and azimuthal angles of the direction of\n gravitational wave emission. If given, sums up modes\n and returns h_plus and h_cross (default returns modes)\n modes : A list of (ell, m) modes to be evaluated (default: all)\n Returns h:\n h : If theta and phi are None, h is a dictionary of waveform modes\n sampled at self.domain with (ell, m) keys.\n If theta and phi are given, h = h_plus - i * h_cross is a\n complex array given by the sum of the modes.\n \"\"\"\n if (theta is None) != (phi is None):\n raise Exception(\"Either give theta and phi or neither\")\n\n x = self.param_space.nudge_params(x)\n\n if modes is None:\n modes = self.modes\n\n if self.mode_type == 'complex':\n h_modes = {k: self._eval_func(x, k) for k in modes}\n else:\n h_modes = {k: self._eval_sur(x, k) for k in modes}\n\n if theta is not None:\n return _mode_sum(h_modes, theta, phi)\n\n return h_modes\n\n\nclass AlignedSpinCoOrbitalFrameSurrogate(ManyFunctionSurrogate):\n \"\"\"\n A surrogate for coorbital frame multimodal waveforms, where each waveform\n data piece has its own surrogate.\n\n The waveform data pieces are:\n Amplitude and phase of the (2,2) mode.\n Real and imaginary parts of coorbital frame waveform for other modes.\n \"\"\"\n\n def __init__(self, name=None, domain=None, param_space=None, \\\n phaseAlignIdx=None, TaylorT3_t_ref=None, \\\n coorb_mode_data={(2, 2): {}}\n ):\n \"\"\"\n name: A descriptive name for this surrogate.\n\n domain: A 1d array of the monotonically increasing time\n values.\n\n param_space: A ParamSpace for this surrogate.\n\n phaseAlignIdx: This value should be loaded directly from the\n surrogate's h5 file. Index of domain at which the orbital phase is\n aligned. This is used when putting back the TaylorT3 contribution\n that was subtracted before modeling the phase.\n\n TaylorT3_t_ref: This value should be loaded directly from the\n surrogate's h5 file. This is an arbitrary reference time used\n in the TaylorT3 contribution, but is fixed during the surrogate\n construction.\n\n coorb_mode_data: A dictionary of modes with (l, m) integer keys, where\n the values are themselves dictionaries containing the coorbital\n frame waveform for that mode. The coorbital frame is defined as:\n H_lm = h_lm*exp(i*m*phi_22/2), where h_lm is the inertial frame\n waveform and h_22 = A_22 * exp(-i phi_22). NOTE the minus sign.\n\n coorb_mode_data should be a dict with mode_key: mode_value pairs,\n where mode_value = AmpPhase_22 for mode_key = (2, 2)\n and mode_value = CoorbReIm_lm for other modes.\n\n Above, AmpPhase_22 and CoorbReIm_lm are themselved dictionaries:\n AmpPhase_22 = {'amp': Amp_22, 'phase': phi_22}\n CoorbReIm_lm = {'re': re_H_lm, 'im': im_H_lm}, where\n re_H_lm = Real(H_lm) and im_H_lm = Imag(H_lmc).\n Finally, all of Amp_22, phi_22, re_H_lm and im_H_lm should be\n (ei_basis, node_functions) tuples of that data piece.\n\n IMPORTANT NOTE: The phase of (2, 2) mode should be defined with\n a minus sign as shown above, this is opposite to what is done for\n MultiModalSurrogate.\n \"\"\"\n\n # get list of modes, but move (2,2) mode to start of the list.\n # This is important because we need the phase of the 22 mode to\n # transform the other modes from coorbital frame to inertial frame.\n self.mode_list = list(coorb_mode_data.keys())\n mode22_idx = [i for i in range(len(self.mode_list)) \\\n if self.mode_list[i] == tuple([2, 2])]\n if len(mode22_idx) != 1:\n raise Exception('Seems to have found multiple or no 22 mode!')\n mode22_idx = mode22_idx[0]\n\n # shift 22 mode to the first index\n self.mode_list.insert(0, self.mode_list.pop(mode22_idx))\n\n if self.mode_list[0] != tuple([2, 2]):\n raise Exception('Expected the first mode at this point to be the'\\\n ' 22 mode.')\n # make sure shifting the 22 mode index did not delete or add a\n # mode by mistake\n if len(self.mode_list) != len(coorb_mode_data.keys()):\n raise Exception('Number of modes do not agree')\n\n self.mode_type = 'identity'\n many_function_components = {}\n for mode in self.mode_list:\n many_function_components[mode] = ('identity', \\\n coorb_mode_data[mode], {})\n\n # required for TaylorT3\n self.phaseAlignIdx = phaseAlignIdx\n self.TaylorT3_t_ref = TaylorT3_t_ref\n self.TaylorT3_factor_without_eta = None\n\n super(AlignedSpinCoOrbitalFrameSurrogate, self).__init__(name,\n domain, param_space, {}, many_function_components,\n self.mode_type)\n\n self._h5_data_keys.append('mode_list')\n self._h5_data_keys.append('mode_type')\n self._h5_data_keys.append('phaseAlignIdx')\n self._h5_data_keys.append('TaylorT3_t_ref')\n\n def _search_omega(self, omega22, omega_val):\n \"\"\" Find closest index such taht omega22[index] = omega_val\n \"\"\"\n # find first index where omega22 > omega_val\n idx = np.where(omega22 > omega_val)[0][0]\n # if idx-1 is closer to omega_val, pick that instead\n if abs(omega22[idx-1] - omega_val) < abs(omega22[idx] - omega_val):\n idx -= 1\n return idx\n\n def _coorbital_to_inertial_frame(self, h_coorb, h_22, mode_list, dtM,\n timesM, fM_low, fM_ref, do_not_align):\n \"\"\" Transforms a dict from Coorbital frame to inertial frame.\n\n The surrogate data is sparsely sampled, so upsamples to time\n step dtM if given. This is done in the coorbital frame since\n the waveform is slowly varying in that frame.\n\n If fM_low is given, only part of the waveform where frequency of\n the (2, 2) mode is greater than fM_low is retained.\n\n if do_not_align = False:\n Aligns the 22 mode phase to be 0 at fM_ref. This means\n that at this reference frequency, the heavier BH is roughly on\n the +ve x axis and the lighter BH is on the -ve x axis.\n do_not_align should be True only when converting from pySurrogate\n format to gwsurrogate format as we may want to do some checks that\n the waveform has not been modified\n \"\"\"\n\n Amp_22 = h_22[0]['amp']\n phi_22 = h_22[0]['phase']\n domain = np.copy(self.domain)\n\n # Get omega22_sparse, the angular frequency of the 22 mode, from the\n # sparse surrogate domain.\n # Use np.diff instead of np.gradient to match the LAL version\n omega22_sparse = np.append(np.diff(phi_22)/np.diff(domain), 0)\n\n # t=0 is at the waveform peak for the surrogate\n peak22Idx = np.argmin(np.abs(domain))\n omega22_peak = omega22_sparse[peak22Idx]\n # We ignore the part after the peak. This way we avoid the noisy part\n # at late times, which can randomly be at frequency = fM_low.\n omega22_sparse = omega22_sparse[domain <= domain[peak22Idx]]\n\n # Get initIdx such that the initial (2, 2) mode frequency ~ fM_low.\n # We will make this more precise below.\n if fM_low != 0:\n omega_low = 2*np.pi*fM_low\n if omega_low < omega22_sparse[0]:\n raise ValueError('f_low is lower than the minimum allowed'\n ' frequency')\n if omega_low > omega22_peak:\n raise ValueError('f_low is higher than the peak frequency')\n\n # Choose 5 indices less, to ensure omega_low is included\n initIdx = self._search_omega(omega22_sparse, omega_low) - 5\n # But if initIdx < 0, we are at the start of the surrogate data\n # so just choose 0\n if initIdx < 0:\n initIdx = 0\n\n else:\n # If fM_low is 0, we use the entire waveform\n initIdx = 0\n\n # But, if fM_low = 0 and timesM is given, the output of the\n # interpolant depends very slightly on the length of the sparse\n # data used to construct the interpolant. So, to achieve machine\n # precision equivalence between using dtM and timesM options, we\n # need to do the following: truncate before interpolation to the\n # same index as the dtM option would have used above (initIdx).\n # Using 6 rather than 5 because of the greater than condition.\n if timesM is not None:\n initIdx = np.where(domain > timesM[0])[0][0] - 6\n\n Amp_22 = Amp_22[initIdx:]\n phi_22 = phi_22[initIdx:]\n domain = domain[initIdx:]\n\n if timesM is not None:\n if timesM[-1] > domain[-1]:\n raise Exception(\"'times' includes times larger than the\"\n \" maximum time value in domain.\")\n if timesM[0] < domain[0]:\n raise Exception(\"'times' starts before start of domain. Try\"\n \" increasing initial value of times or reducing f_low.\")\n\n if dtM is None and timesM is None:\n # Use the sparse domain\n timesM = domain\n omega22 = omega22_sparse[initIdx:]\n do_interp = False\n else:\n ## Interpolate onto uniform-domain/timesM if needed\n do_interp = True\n if dtM is not None:\n t0 = domain[0]\n tf = domain[-1]\n num_times = int(np.ceil((tf - t0)/dtM));\n timesM = t0 + dtM*np.arange(num_times)\n else:\n if timesM[0] < domain[0] or timesM[-1] > domain[-1]:\n raise Exception('Trying to evaluate at times outside the'\n ' domain.')\n\n Amp_22 = _splinterp_Cwrapper(timesM, domain, Amp_22)\n phi_22 = _splinterp_Cwrapper(timesM, domain, phi_22)\n\n # now recompute omega22 with the dense data, but retain only data\n # upto the peak to avoid the noisy part\n omega22 = np.append(np.diff(phi_22)/np.diff(timesM), 0)\n omega22 = omega22[timesM <= 0]\n\n # Truncate data so that only freqs above omega_low are retained\n # If timesM are already given, we don't need to truncate data\n if dtM is not None:\n if fM_low != 0:\n startIdx = self._search_omega(omega22, omega_low)\n else:\n # If fM_low is 0, we use the entire waveform\n startIdx = 0\n\n Amp_22 = Amp_22[startIdx:]\n phi_22 = phi_22[startIdx:]\n omega22 = omega22[startIdx:]\n timesM = timesM[startIdx:]\n\n\n # Get reference index where waveform needs to be aligned.\n if (abs(fM_ref-fM_low) < 1e-13) and (dtM is not None):\n # This means that the data is already truncated at fM_low,\n # so we just need the first index for fM_ref=fM_low\n refIdx = 0\n else:\n omega_ref = 2*np.pi*fM_ref\n if omega_ref > omega22_peak:\n raise ValueError('f_ref is higher than the peak frequency')\n\n refIdx = self._search_omega(omega22, omega_ref)\n\n\n # do_not_align should be True only when converting from pySurrogate\n # format to gwsurrogate format as we may want to do some checks that\n # the waveform has not been modified\n if not do_not_align:\n # Set orbital phase to 0 refIdx. Note that the Coorbital\n # frame data is not affected by this constant phase shift.\n\n # The orbital phase is obtained as phi_22/2, so this leaves a pi\n # ambiguity. But the surrogate data is already aligned such that\n # the heavier BH is on the +ve x-axis at t=-1000M. See Sec.VI.A.4\n # of arxiv:1812.07865, the resolves the pi ambiguity. This means\n # that the after the realignment, the orbital phase at reference\n # frequency is 0.\n phi_22 += -phi_22[refIdx]\n\n h_dict = {}\n for mode in mode_list:\n if mode == tuple([2, 2]):\n h_dict[mode] = Amp_22 * np.exp(-1j*phi_22)\n else:\n l,m = mode\n h_coorb_lm = 0\n if 're' in h_coorb[mode][0].keys():\n h_coorb_lm += h_coorb[mode][0]['re'] + 1j * 0\n if 'im' in h_coorb[mode][0].keys():\n h_coorb_lm += 1j*h_coorb[mode][0]['im']\n\n h_coorb_lm = h_coorb_lm[initIdx:]\n if do_interp:\n h_coorb_lm = _splinterp_Cwrapper(timesM,domain,h_coorb_lm)\n\n h_dict[mode] = h_coorb_lm * np.exp(-1j*m*phi_22/2.)\n\n return timesM, h_dict, None # None is for dynamics\n\n def _set_TaylorT3_factor(self):\n \"\"\" Sets a term used in the 0 PN TaylorT3 phase. See Eq.43 of\n arxiv.1812.07865.\n \"\"\"\n # Set only once\n if self.TaylorT3_factor_without_eta is None:\n # TaylorT3_t_ref is arbitrary. This is where the phase diverges,\n # so we choose it much after ringdown. This matches what was used\n # in the construction of the surrogate. See discussion near Eq.43\n # of arxiv.1812.07865\n theta_without_eta = ((self.TaylorT3_t_ref -self.domain)/5)**(-1./8)\n self.TaylorT3_factor_without_eta = -2./theta_without_eta**5\n\n def _TaylorT3_phase_22(self, x):\n \"\"\" 0 PN TaylorT3 phase. See Eq.43 of arxiv.1812.07865\n \"\"\"\n\n q, chi1z, chi2z = x\n eta = q/(1.+q)**2\n\n # 0PN TaylorT3 phase\n phi22_T3 = 1./eta**(3./8) * self.TaylorT3_factor_without_eta\n\n # Align at phaseAlignIdx\n phi22_T3 -= phi22_T3[self.phaseAlignIdx]\n\n return phi22_T3\n\n\n def __call__(self, x, fM_low=None, fM_ref=None, dtM=None,\n timesM=None, dfM=None, freqsM=None, mode_list=None, ellMax=None,\n precessing_opts=None, tidal_opts=None, par_dict=None,\n return_dynamics=False, do_not_align=False):\n \"\"\"\n Return dimensionless surrogate modes.\n Arguments:\n x : The intrinsic parameters EXCLUDING total Mass (see\n self.param_space)\n\n fM_low : Initial frequency of (2,2) mode in units of cycles/M.\n If 0, will use the entire data of the surrogate.\n Default None.\n\n fM_ref: Frequency used to set the reference epoch at which\n the reference frame is defined and the spins are specified.\n See below for definition of the reference frame.\n Default: None.\n\n For time domain models, f_ref is used to determine a t_ref,\n such that the frequency of the (2, 2) mode equals f_ref at\n t=t_ref.\n\n dtM : Uniform time step to use, in units of M. If None, the\n returned time array will be the array used in the\n construction of the surrogate, which can be nonuniformly\n sampled.\n Default None.\n\n timesM: Time samples to evaluate the waveform at. Use either dtM or\n timesM, not both.\n\n dfM : This should always be None as for now we are assuming\n a time domain model.\n\n freqsM: Frequency samples to evaluate the waveform at. Use either\n dfM or freqsM, not both.\n\n ellMax: Maximum ell index for modes to include. All available m\n indicies for each ell will be included automatically.\n Default: None, in which case all available modes wll be\n included.\n\n mode_list : A list of (ell, m) modes to be evaluated.\n Default None, which evaluates all avilable modes.\n Will deduce the m<0 modes from m>0 modes.\n\n par_dict: This should always be None for this model.\n\n do_not_align: Ignore fM_ref and do not align the waveform. This should be\n True only when converting from pySurrogate format to\n gwsurrogate format as we may want to do some checks that\n the waveform has not been modified.\n\n Returns\n timesM, h, dynamics:\n timesM : time array in units of M.\n h : A dictionary of waveform modes sampled at timesM with\n (ell, m) keys.\n dynamics: None, since this is a nonprecessing model.\n\n\n IMPORTANT NOTES:\n ===============\n\n The reference frame (or inertial frame) is defined as follows:\n The +ve z-axis is along the orbital angular momentum at the reference\n epoch. The separation vector from the lighter BH to the heavier BH at\n the reference epoch is along the +ve x-axis. The y-axis completes the\n right-handed triad. The reference epoch is set using f_ref.\n \"\"\"\n\n if dfM is not None:\n raise ValueError('Expected dfM to be None for a Time domain model')\n if freqsM is not None:\n raise ValueError('Expected freqsM to be None for a Time domain'\n ' model')\n\n if mode_list is None:\n mode_list = self.mode_list\n if ellMax is not None:\n if ellMax > np.max(np.array(self.mode_list).T[0]):\n raise ValueError('ellMax is greater than max allowed ell.')\n include_modes = np.array(self.mode_list).T[0] <= ellMax\n mode_list = [self.mode_list[idx]\n for idx in range(len(self.mode_list))\n if include_modes[idx]]\n\n if par_dict is not None:\n raise ValueError('par_dict should be None for this model')\n\n # always evaluate the (2,2) mode, the other modes neeed this\n # for transformation from coorbital to inertial frame\n\n # At this stage the phase of the (2,2) mode is the residual after\n # removing the TaylorT3 part (see. Eq.44 of arxiv.1812.07865)\n h_22 = self._eval_sur(x, tuple([2, 2]))\n\n # Get the TaylorT3 part and add to get the actual phase\n self._set_TaylorT3_factor()\n h_22[0]['phase'] += self._TaylorT3_phase_22(x)\n\n h_coorb = {k: self._eval_sur(x, k) for k in mode_list \\\n if k != tuple([2,2])}\n\n return self._coorbital_to_inertial_frame(h_coorb, h_22, \\\n mode_list, dtM, timesM, fM_low, fM_ref, do_not_align)\n\nclass AlignedSpinCoOrbitalFrameSurrogateTidal(AlignedSpinCoOrbitalFrameSurrogate):\n \"\"\"\n A surrogate for coorbital frame multimodal waveforms, where each waveform\n data piece has its own surrogate.\n\n The waveform data pieces are:\n Amplitude and phase of the (2,2) mode.\n Real and imaginary parts of coorbital frame waveform for other modes.\n\n This generates tidal inspiral waveforms by taking the surrogate output tuned\n to BBH results and incorporates the PN tidal corrections according to the\n tidal splicing method\n\n NOTE: This returns the waveform only during the inspiral portion of the\n binary's evolution, where the PN expansion is still valid; additional work\n will need to be done in order to complete the merger/ringdown portion of the\n waveform\n\n NOTE: The waveform is output with the time set so that t=0 corresponds to\n the peak of the waveform for the BBH waveform from the underlying surrogate,\n and NOT the peak of the tidally spliced waveform\n \"\"\"\n\n def _coorbital_to_inertial_frame(self, h_coorb, h_22, mode_list, dtM,\n timesM, fM_low, fM_ref, do_not_align, x):\n \"\"\" Transforms a dict from Coorbital frame to inertial frame.\n\n The surrogate data is sparsely sampled, so upsamples to time\n step dtM if given. This is done in the coorbital frame since\n the waveform is slowly varying in that frame.\n\n If fM_low must be specified. The option of fM_low == 0 has been\n turned off for this model because of its excessive computational\n cost to evaluate\n\n if do_not_align = False:\n Aligns the 22 mode phase to be 0 at fM_ref. This means\n that at this reference frequency, the heavier BH is roughly on\n the +ve x axis and the lighter BH is on the -ve x axis.\n do_not_align should be True only when converting from pySurrogate\n format to gwsurrogate format as we may want to do some checks that\n the waveform has not been modified\n \"\"\"\n\n Amp_22 = h_22[0]['amp']\n phi_22 = h_22[0]['phase']\n domain = np.copy(self.domain)\n\n # Get omega22_sparse, the angular frequency of the 22 mode, from the\n # sparse surrogate domain.\n # Use np.gradient\n omega22_sparse = np.gradient(phi_22, domain)\n\n # t=0 is at the waveform peak for the surrogate\n peak22Idx = np.argmin(np.abs(domain))\n omega22_peak = omega22_sparse[peak22Idx]\n # We ignore the part after the peak. This way we avoid the noisy part\n # at late times, which can randomly be at frequency = fM_low.\n omega22_sparse = omega22_sparse[domain <= domain[peak22Idx]]\n\n # Get initIdx such that the initial (2, 2) mode frequency ~ fM_low.\n # We will make this more precise below.\n if fM_low != 0:\n omega_low = 2*np.pi*fM_low\n if omega_low < omega22_sparse[0]:\n raise ValueError('f_low is lower than the minimum allowed'\n ' frequency')\n if omega_low > omega22_peak:\n raise ValueError('f_low is higher than the peak frequency')\n\n # Choose 5 indices less, to ensure omega_low is included\n initIdx = self._search_omega(omega22_sparse, omega_low) - 5\n # But if initIdx < 0, we are at the start of the surrogate data\n # so just choose 0\n if initIdx < 0:\n initIdx = 0\n else:\n raise ValueError(\"The option of setting 'fM_low' to 0 is turned off\"\n \" for this model; must specifiy a non-zero 'fM_low'\")\n ## If fM_low is 0, we use the entire waveform where frequency is\n ## monotonic, uncomment if want to allow this option\n #freq_orbital = np.gradient(phi_22[:peak22Idx], domain[:peak22Idx])\n #if np.min(np.diff(freq_orbital))<=0:\n # initIdx = len(freq_orbital)-np.argmin((np.diff(freq_orbital)>np.zeros(len(freq_orbital)-1))[::-1])-1\n #else:\n # initIdx = 0\n\n Amp_22 = Amp_22[initIdx:peak22Idx]\n phi_22 = phi_22[initIdx:peak22Idx]\n domain = domain[initIdx:peak22Idx]\n v_domain = np.power(np.abs(np.gradient(phi_22, domain))/2,1./3.)\n if(np.min(np.diff(v_domain))<0):\n raise ValueError('frequency is not monotonic over the entire'\n ' considered here')\n\n if timesM is not None:\n # This check is performed after the tidal terms computed\n #if timesM[-1] > domain[-1]:\n # raise Exception(\"'times' includes times larger than the\"\n # \" maximum time value in domain.\")\n if timesM[0] < domain[0]:\n raise Exception(\"'times' starts before start of domain. Try\"\n \" increasing initial value of times or reducing f_low.\")\n\n # For tidal splicing, always want to interpolate first to a dense domain\n # in order to compute an accurate orbital frequency for the PN equations\n # then interpolated to the desired times afterwards\n\n if dtM is None and timesM is None:\n raise ValueError(\"For this model, must specify either the 'dtM' or\"\n \" 'timesM' option\")\n else:\n ## Interpolate onto uniform domain\n ## WARNING -- if the the time points are not sampled densely enough\n ## here, there is a potential for error due to inaccurate orbital\n ## freq being used for the PN tidal equations\n if dtM is not None:\n t0 = domain[0]\n tf = domain[-1]\n num_times = int(np.ceil((tf - t0)/dtM));\n timesM_tmp = t0 + dtM*np.arange(num_times)\n else:\n # Because the spliced waveform is shifted so the final time\n # is the peak of the final waveform, we must ensure the check\n # here is performed similarly\n if timesM[0] < (domain[0]-domain[-1]) or timesM[-1] > 0:\n raise Exception('Trying to evaluate at times outside the'\n ' domain.')\n min_dt = np.min(np.diff(timesM))\n t0 = domain[0] #timesM[0] - min_dt\n tf = domain[-1]\n num_times = int(np.ceil((tf - t0)/min_dt));\n timesM_tmp = t0 + min_dt*np.arange(num_times)\n\n Amp_22 = _splinterp_Cwrapper(timesM_tmp, domain, Amp_22)\n phi_22 = _splinterp_Cwrapper(timesM_tmp, domain, phi_22)\n\n # now recompute omega22 with the dense data, but retain only data\n # upto the peak to avoid the noisy part\n omega22 = np.gradient(phi_22, timesM_tmp)\n\n #omega22 = omega22[timesM_tmp <= timesM_tmp[np.argmax(Amp_22)]]\n\n # Truncate data so that only freqs above omega_low are retained\n # If timesM are already given, we don't need to truncate data\n if dtM is not None:\n if fM_low != 0:\n startIdx = max(np.argmin(np.abs(omega22 - omega_low)) - 4,0)\n else:\n raise ValueError(\"The option of setting 'fM_low' to 0\"\n \" is turned off for this model; must specifiy a\"\n \" non-zero 'fM_low'\")\n ## If fM_low is 0, we use the entire waveform that is monotonic\n #startIdx = 0\n #if np.min(np.diff(omega22))<=0:\n # startIdx = len(omega22)-np.argmin((np.diff(omega22)>np.zeros(len(omega22)-1))[::-1])-1\n ## Because the splicing changes the frequencies slightly, to\n ## ensure we have wiggle room for interpolation later, buffer\n ## the altered initial frequency of the spliced waveform so\n ## it is not less than the initial frequency of v_domain\n #gap = int((domain[5]-domain[0])/(timesM_tmp[1]-timesM_tmp[0]))\n #if startIdx0):\n IbarA = UniversalRelationLambda2ToI(lambda2A)\n omegaSpinA = max(chiAz,0) / IbarA / XA\n omega2A = UniversalRelationLambda2ToOmega2(lambda2A)/XA\n lambda3A = UniversalRelationLambda2ToLambda3(lambda2A)\n omega3A = UniversalRelationLambda3ToOmega3(lambda3A)/XA\n AqmA = UniversalRelationLambda2ToAqm(lambda2A)\n ell2Adyn = EffectiveDeformabilityFromDynamicalTides \\\n (np.abs(freq_orbital-omegaSpinA),omega2A,2,qqq)\n ell3Adyn = EffectiveDeformabilityFromDynamicalTides \\\n (np.abs(freq_orbital-omegaSpinA),omega3A,3,qqq)\n if(lambda2B>0):\n IbarB = UniversalRelationLambda2ToI(lambda2B)\n omegaSpinB = max(chiBz,0) / IbarB / XB\n omega2B = UniversalRelationLambda2ToOmega2(lambda2B)/XB\n lambda3B = UniversalRelationLambda2ToLambda3(lambda2B)\n omega3B = UniversalRelationLambda3ToOmega3(lambda3B)/XB\n AqmB = UniversalRelationLambda2ToAqm(lambda2B)\n ell2Bdyn = EffectiveDeformabilityFromDynamicalTides \\\n (np.abs(freq_orbital-omegaSpinB),omega2B,2,qqq)\n ell3Bdyn = EffectiveDeformabilityFromDynamicalTides \\\n (np.abs(freq_orbital-omegaSpinB),omega3B,3,qqq)\n\n dt_tid, dp_tid = PNT2Tidal(v, qqq, lambda2A*ell2Adyn, \\\n lambda3A*ell3Adyn, AqmA, chiAz, lambda2B*ell2Bdyn, \\\n lambda3B*ell3Bdyn, AqmB, chiBz, order=5)\n\n timesM_tmp += dt_tid - dt_tid[0]\n\n # Limit the waveform to the last time in the array that is increasing\n find = np.argmin(np.diff(timesM_tmp)>0)\n if(find == 0):\n find = len(timesM_tmp)\n\n timesM_tmp = timesM_tmp[:find]\n\n # There is a small region of parameter space where the interpolation\n # behaves poorly at very late times due to oddly shaped steps, so we\n # need to check the final handful of steps for that and truncate as\n # needed to avoid interpolation failures\n numcheck = 500\n factorLimit = 2.\n tdiff = np.diff(timesM_tmp[-numcheck-1:])\n for i in range(len(tdiff)-1):\n if ((tdiff[i]>tdiff[i+1]*factorLimit) or (tdiff[i] timesM_tmp[-1]:\n raise Exception(\"'times' includes times larger than the\"\n \" maximum time value in domain after splicing. (Remember\"\n \" that tidal effects cause the binary to merger earlier)\")\n if timesM[0] < timesM_tmp[0]:\n raise Exception(\"'times' includes times smaller than the\"\n \" initial time value in domain after splicing. (Remember\"\n \" that tidal effects cause the binary to merger earlier)\")\n\n # Find the 'v' corresponding to the final time array, then perform the\n # interpolation in the 'v' domain as that is where most of the PN\n # quantities are defined\n v_uniform = _splinterp_Cwrapper(timesM, timesM_tmp, v[:find])\n\n Amp_22 = _splinterp_Cwrapper(v_uniform, v[:find], Amp_22[:find])\n phi_22 = _splinterp_Cwrapper(v_uniform, v[:find], phi_22)\n freq_orbital = np.power(v_uniform,3.)\n\n # Dynamical Tidal deformability stuff on final array for strain\n # amplitudes\n ell2Adyn = ell2Adiss = ell2Bdyn = ell2Bdiss = np.zeros(len(timesM))\n if(lambda2A>0):\n ell2Adyn = EffectiveDeformabilityFromDynamicalTides \\\n (np.abs(freq_orbital-omegaSpinA),omega2A,2,qqq)\n ell2Adiss = EffectiveDissipativeDynamicalTides \\\n (np.abs(freq_orbital-omegaSpinA),ell2Adyn,omega2A,XA)\n if(lambda2B>0):\n ell2Bdyn = EffectiveDeformabilityFromDynamicalTides \\\n (np.abs(freq_orbital-omegaSpinB),omega2B,2,qqq)\n ell2Bdiss = EffectiveDissipativeDynamicalTides \\\n (np.abs(freq_orbital-omegaSpinB),ell2Bdyn,omega2B,XB)\n\n # Get reference index where waveform needs to be aligned.\n if (abs(fM_ref-fM_low) < 1e-13) and (dtM is not None):\n # This means that the data is already truncated at fM_low,\n # so we just need the first index for fM_ref=fM_low\n refIdx = 0\n else:\n omega_ref = 2*np.pi*fM_ref\n if omega_ref > omega22_peak:\n raise ValueError('f_ref is higher than the peak frequency')\n\n refIdx = np.argmin(np.abs(2.*freq_orbital - omega_ref))\n\n\n # do_not_align should be True only when converting from pySurrogate\n # format to gwsurrogate format as we may want to do some checks that\n # the waveform has not been modified\n if not do_not_align:\n # Set orbital phase to 0 refIdx. Note that the Coorbital\n # frame data is not affected by this constant phase shift.\n\n # The orbital phase is obtained as phi_22/2, so this leaves a pi\n # ambiguity. But the surrogate data is already aligned such that\n # the heavier BH is on the +ve x-axis at t=-1000M. See Sec.VI.A.4\n # of arxiv:1812.07865, the resolves the pi ambiguity. This means\n # that the after the realignment, the orbital phase at reference\n # frequency is 0.\n phi_22 += -phi_22[refIdx]\n\n\n h_dict = {}\n for mode in mode_list:\n if mode == tuple([2, 2]):\n h_dict[mode] = (Amp_22+StrainTidalEnhancementFactor(2,2, \\\n qqq,(lambda2A*ell2Adiss),(lambda2B*ell2Bdiss),v_uniform)) \\\n * np.exp(-1j*phi_22)\n else:\n l,m = mode\n h_coorb_lm = 0\n if 're' in h_coorb[mode][0].keys():\n h_coorb_lm += h_coorb[mode][0]['re'] + 1j * 0\n if 'im' in h_coorb[mode][0].keys():\n h_coorb_lm += 1j*h_coorb[mode][0]['im']\n\n h_coorb_lm = h_coorb_lm[initIdx:peak22Idx]\n\n h_coorb_lm = _splinterp_Cwrapper(v_uniform,v_domain,h_coorb_lm)\n\n h_coorb_lm_amp = np.abs(h_coorb_lm)\n h_coorb_lm_phase = np.unwrap(np.angle(h_coorb_lm))\n h_coorb_lm_tid = StrainTidalEnhancementFactor(l,m,qqq, \\\n (lambda2A*ell2Adiss),(lambda2B*ell2Bdiss),v_uniform)\n h_dict[mode] = (h_coorb_lm_amp + h_coorb_lm_tid) \\\n * np.exp((-1j*m/2.)*phi_22+1j*h_coorb_lm_phase)\n\n return timesM, h_dict, None # None is for dynamics\n\n def __call__(self, x, fM_low=None, fM_ref=None, dtM=None,\n timesM=None, dfM=None, freqsM=None, mode_list=None, ellMax=None,\n precessing_opts=None, tidal_opts=None, par_dict=None,\n do_not_align=False):\n \"\"\"\n Return dimensionless surrogate modes.\n Arguments:\n x : The intrinsic parameters EXCLUDING total Mass (see\n self.param_space)\n\n fM_low : Initial frequency of (2,2) mode in units of cycles/M.\n If 0, will use the entire data of the surrogate.\n Default None.\n\n fM_ref: Frequency used to set the reference epoch at which\n the reference frame is defined and the spins are specified.\n See below for definition of the reference frame.\n Default: None.\n\n For time domain models, f_ref is used to determine a t_ref,\n such that the frequency of the (2, 2) mode equals f_ref at\n t=t_ref.\n\n dtM : Uniform time step to use, in units of M. If None, the\n returned time array will be the array used in the\n construction of the surrogate, which can be nonuniformly\n sampled.\n Default None.\n\n timesM: Time samples to evaluate the waveform at. Use either dtM or\n timesM, not both.\n\n dfM : This should always be None as for now we are assuming\n a time domain model.\n\n freqsM: Frequency samples to evaluate the waveform at. Use either\n dfM or freqsM, not both.\n\n ellMax: Maximum ell index for modes to include. All available m\n indicies for each ell will be included automatically.\n Default: None, in which case all available modes wll be\n included.\n\n mode_list : A list of (ell, m) modes to be evaluated.\n Default None, which evaluates all avilable modes.\n Will deduce the m<0 modes from m>0 modes.\n\n par_dict: This should always be None for this model.\n\n do_not_align: Ignore fM_ref and do not align the waveform. This should be\n True only when converting from pySurrogate format to\n gwsurrogate format as we may want to do some checks that\n the waveform has not been modified.\n\n Returns\n timesM, h, dynamics:\n timesM : time array in units of M.\n h : A dictionary of waveform modes sampled at timesM with\n (ell, m) keys.\n dynamics: None, since this is a nonprecessing model.\n\n\n IMPORTANT NOTES:\n ===============\n\n The reference frame (or inertial frame) is defined as follows:\n The +ve z-axis is along the orbital angular momentum at the reference\n epoch. The separation vector from the lighter BH to the heavier BH at\n the reference epoch is along the +ve x-axis. The y-axis completes the\n right-handed triad. The reference epoch is set using f_ref.\n \"\"\"\n\n if par_dict is not None:\n raise ValueError('Expected par_dict to be None.')\n if dfM is not None:\n raise ValueError('Expected dfM to be None for a Time domain model')\n if freqsM is not None:\n raise ValueError('Expected freqsM to be None for a Time domain'\n ' model')\n\n if mode_list is None:\n mode_list = self.mode_list\n if ellMax is not None:\n if ellMax > np.max(np.array(self.mode_list).T[0]):\n raise ValueError('ellMax is greater than max allowed ell.')\n include_modes = np.array(self.mode_list).T[0] <= ellMax\n mode_list = [self.mode_list[idx]\n for idx in range(len(self.mode_list))\n if include_modes[idx]]\n\n # The last to parameters are the tidal parameters and are not a part of\n # the base surrogate model\n x_sur = x[:-2]\n\n # always evaluate the (2,2) mode, the other modes neeed this\n # for transformation from coorbital to inertial frame\n\n # At this stage the phase of the (2,2) mode is the residual after\n # removing the TaylorT3 part (see. Eq.44 of arxiv.1812.07865)\n h_22 = self._eval_sur(x_sur, tuple([2, 2]))\n\n # Get the TaylorT3 part and add to get the actual phase\n self._set_TaylorT3_factor()\n h_22[0]['phase'] += self._TaylorT3_phase_22(x_sur)\n\n h_coorb = {k: self._eval_sur(x_sur, k) for k in mode_list \\\n if k != tuple([2,2])}\n\n return self._coorbital_to_inertial_frame(h_coorb, h_22, \\\n mode_list, dtM, timesM, fM_low, fM_ref, do_not_align, x)\n\n\n\nclass SpEC_nonspinning_q10_surrogate(MultiModalSurrogate):\n \"\"\"A special class for the SpEC nonspinning surrogate\"\"\"\n\n skip_2_0_mode = True\n\n def __call__(self, x, theta=None, phi=None, modes=None,\n fake_neg_modes=True):\n \"\"\"\n Return surrogate evaluation.\n Arguments:\n x : The intrinsic parameters (see self.param_space)\n theta/phi : polar and azimuthal angles of the direction of\n gravitational wave emission. If given, sums up modes\n and returns h_plus and h_cross (default returns modes)\n modes : A list of (ell, m) modes to be evaluated (default: all)\n fake_neg_modes: Deduce (ell, -m) modes from (ell, m) modes for m>0.\n Returns h:\n h : If theta and phi are None, h is a dictionary of waveform modes\n sampled at self.domain with (ell, m) keys.\n If theta and phi are given, h = h_plus - i * h_cross is a\n complex array given by the sum of the modes.\n \"\"\"\n if modes is None:\n modes = self.modes\n\n if self.skip_2_0_mode:\n # removed by 2to3 tool\n #modes = filter(lambda mode: mode != (2, 0), modes)\n modes = [mode for mode in modes if mode != (2, 0)]\n\n h_modes = super(SpEC_nonspinning_q10_surrogate, self).__call__(\n x, modes=modes)\n\n if fake_neg_modes:\n new_modes = {}\n for (ell, m), h in h_modes.items(): # inefficient in py2\n if m > 0:\n new_modes[(ell, -m)] = np.power(-1, ell) * h.conjugate()\n for k, v in new_modes.items(): # inefficient in py2\n h_modes[k] = v\n\n if theta is not None:\n return _mode_sum(h_modes, theta, phi)\n\n return h_modes\n", "meta": {"hexsha": "c037fb5d5a92a571ea14dd7076e571f0d57aaeb9", "size": 65447, "ext": "py", "lang": "Python", "max_stars_repo_path": "gwsurrogate/new/surrogate.py", "max_stars_repo_name": "thompsonphys/gwsurrogate", "max_stars_repo_head_hexsha": "d32fbd4506c664ab7b7c6048edbd51835b17b644", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 11, "max_stars_repo_stars_event_min_datetime": "2020-04-11T12:52:52.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-01T07:40:04.000Z", "max_issues_repo_path": "gwsurrogate/new/surrogate.py", "max_issues_repo_name": "jyoo1042/gwsurrogate", "max_issues_repo_head_hexsha": "1459f8e6a855d183a4a3b08e4fcd36d2d14f5285", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 23, "max_issues_repo_issues_event_min_datetime": "2019-11-24T07:39:21.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-02T09:35:08.000Z", "max_forks_repo_path": "gwsurrogate/new/surrogate.py", "max_forks_repo_name": "jyoo1042/gwsurrogate", "max_forks_repo_head_hexsha": "1459f8e6a855d183a4a3b08e4fcd36d2d14f5285", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 9, "max_forks_repo_forks_event_min_datetime": "2019-12-05T20:00:00.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-25T10:17:02.000Z", "avg_line_length": 43.2850529101, "max_line_length": 115, "alphanum_fraction": 0.6060934802, "include": true, "reason": "import numpy,from scipy", "num_tokens": 15757, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5389832206876841, "lm_q2_score": 0.37022537869825406, "lm_q1q2_score": 0.1995452669911025}} {"text": "from __future__ import print_function, division\n\nfrom sympy import Expr, sympify, Symbol, Matrix\nfrom sympy.printing.pretty.stringpict import prettyForm\nfrom sympy.core.containers import Tuple\nfrom sympy.core.compatibility import is_sequence, string_types\n\nfrom sympy.physics.quantum.dagger import Dagger\nfrom sympy.physics.quantum.matrixutils import (\n numpy_ndarray, scipy_sparse_matrix,\n to_sympy, to_numpy, to_scipy_sparse\n)\n\n__all__ = [\n 'QuantumError',\n 'QExpr'\n]\n\n\n#-----------------------------------------------------------------------------\n# Error handling\n#-----------------------------------------------------------------------------\n\nclass QuantumError(Exception):\n pass\n\n\ndef _qsympify_sequence(seq):\n \"\"\"Convert elements of a sequence to standard form.\n\n This is like sympify, but it performs special logic for arguments passed\n to QExpr. The following conversions are done:\n\n * (list, tuple, Tuple) => _qsympify_sequence each element and convert\n sequence to a Tuple.\n * basestring => Symbol\n * Matrix => Matrix\n * other => sympify\n\n Strings are passed to Symbol, not sympify to make sure that variables like\n 'pi' are kept as Symbols, not the SymPy built-in number subclasses.\n\n Examples\n ========\n\n >>> from sympy.physics.quantum.qexpr import _qsympify_sequence\n >>> _qsympify_sequence((1,2,[3,4,[1,]]))\n (1, 2, (3, 4, (1,)))\n\n \"\"\"\n\n return tuple(__qsympify_sequence_helper(seq))\n\n\ndef __qsympify_sequence_helper(seq):\n \"\"\"\n Helper function for _qsympify_sequence\n This function does the actual work.\n \"\"\"\n #base case. If not a list, do Sympification\n if not is_sequence(seq):\n if isinstance(seq, Matrix):\n return seq\n elif isinstance(seq, string_types):\n return Symbol(seq)\n else:\n return sympify(seq)\n\n # base condition, when seq is QExpr and also\n # is iterable.\n if isinstance(seq, QExpr):\n return seq\n\n #if list, recurse on each item in the list\n result = [__qsympify_sequence_helper(item) for item in seq]\n\n return Tuple(*result)\n\n\n#-----------------------------------------------------------------------------\n# Basic Quantum Expression from which all objects descend\n#-----------------------------------------------------------------------------\n\nclass QExpr(Expr):\n \"\"\"A base class for all quantum object like operators and states.\"\"\"\n\n # In sympy, slots are for instance attributes that are computed\n # dynamically by the __new__ method. They are not part of args, but they\n # derive from args.\n\n # The Hilbert space a quantum Object belongs to.\n __slots__ = ['hilbert_space']\n\n is_commutative = False\n\n # The separator used in printing the label.\n _label_separator = u''\n\n @property\n def free_symbols(self):\n return {self}\n\n def __new__(cls, *args, **old_assumptions):\n \"\"\"Construct a new quantum object.\n\n Parameters\n ==========\n\n args : tuple\n The list of numbers or parameters that uniquely specify the\n quantum object. For a state, this will be its symbol or its\n set of quantum numbers.\n\n Examples\n ========\n\n >>> from sympy.physics.quantum.qexpr import QExpr\n >>> q = QExpr(0)\n >>> q\n 0\n >>> q.label\n (0,)\n >>> q.hilbert_space\n H\n >>> q.args\n (0,)\n >>> q.is_commutative\n False\n \"\"\"\n\n # First compute args and call Expr.__new__ to create the instance\n args = cls._eval_args(args)\n if len(args) == 0:\n args = cls._eval_args(tuple(cls.default_args()))\n inst = Expr.__new__(cls, *args, **old_assumptions)\n # Now set the slots on the instance\n inst.hilbert_space = cls._eval_hilbert_space(args)\n return inst\n\n @classmethod\n def _new_rawargs(cls, hilbert_space, *args, **old_assumptions):\n \"\"\"Create new instance of this class with hilbert_space and args.\n\n This is used to bypass the more complex logic in the ``__new__``\n method in cases where you already have the exact ``hilbert_space``\n and ``args``. This should be used when you are positive these\n arguments are valid, in their final, proper form and want to optimize\n the creation of the object.\n \"\"\"\n\n obj = Expr.__new__(cls, *args, **old_assumptions)\n obj.hilbert_space = hilbert_space\n return obj\n\n #-------------------------------------------------------------------------\n # Properties\n #-------------------------------------------------------------------------\n\n @property\n def label(self):\n \"\"\"The label is the unique set of identifiers for the object.\n\n Usually, this will include all of the information about the state\n *except* the time (in the case of time-dependent objects).\n\n This must be a tuple, rather than a Tuple.\n \"\"\"\n if len(self.args) == 0: # If there is no label specified, return the default\n return self._eval_args(list(self.default_args()))\n else:\n return self.args\n\n @property\n def is_symbolic(self):\n return True\n\n @classmethod\n def default_args(self):\n \"\"\"If no arguments are specified, then this will return a default set\n of arguments to be run through the constructor.\n\n NOTE: Any classes that override this MUST return a tuple of arguments.\n Should be overridden by subclasses to specify the default arguments for kets and operators\n \"\"\"\n raise NotImplementedError(\"No default arguments for this class!\")\n\n #-------------------------------------------------------------------------\n # _eval_* methods\n #-------------------------------------------------------------------------\n\n def _eval_adjoint(self):\n obj = Expr._eval_adjoint(self)\n if obj is None:\n obj = Expr.__new__(Dagger, self)\n if isinstance(obj, QExpr):\n obj.hilbert_space = self.hilbert_space\n return obj\n\n @classmethod\n def _eval_args(cls, args):\n \"\"\"Process the args passed to the __new__ method.\n\n This simply runs args through _qsympify_sequence.\n \"\"\"\n return _qsympify_sequence(args)\n\n @classmethod\n def _eval_hilbert_space(cls, args):\n \"\"\"Compute the Hilbert space instance from the args.\n \"\"\"\n from sympy.physics.quantum.hilbert import HilbertSpace\n return HilbertSpace()\n\n #-------------------------------------------------------------------------\n # Printing\n #-------------------------------------------------------------------------\n\n # Utilities for printing: these operate on raw sympy objects\n\n def _print_sequence(self, seq, sep, printer, *args):\n result = []\n for item in seq:\n result.append(printer._print(item, *args))\n return sep.join(result)\n\n def _print_sequence_pretty(self, seq, sep, printer, *args):\n pform = printer._print(seq[0], *args)\n for item in seq[1:]:\n pform = prettyForm(*pform.right((sep)))\n pform = prettyForm(*pform.right((printer._print(item, *args))))\n return pform\n\n # Utilities for printing: these operate prettyForm objects\n\n def _print_subscript_pretty(self, a, b):\n top = prettyForm(*b.left(' '*a.width()))\n bot = prettyForm(*a.right(' '*b.width()))\n return prettyForm(binding=prettyForm.POW, *bot.below(top))\n\n def _print_superscript_pretty(self, a, b):\n return a**b\n\n def _print_parens_pretty(self, pform, left='(', right=')'):\n return prettyForm(*pform.parens(left=left, right=right))\n\n # Printing of labels (i.e. args)\n\n def _print_label(self, printer, *args):\n \"\"\"Prints the label of the QExpr\n\n This method prints self.label, using self._label_separator to separate\n the elements. This method should not be overridden, instead, override\n _print_contents to change printing behavior.\n \"\"\"\n return self._print_sequence(\n self.label, self._label_separator, printer, *args\n )\n\n def _print_label_repr(self, printer, *args):\n return self._print_sequence(\n self.label, ',', printer, *args\n )\n\n def _print_label_pretty(self, printer, *args):\n return self._print_sequence_pretty(\n self.label, self._label_separator, printer, *args\n )\n\n def _print_label_latex(self, printer, *args):\n return self._print_sequence(\n self.label, self._label_separator, printer, *args\n )\n\n # Printing of contents (default to label)\n\n def _print_contents(self, printer, *args):\n \"\"\"Printer for contents of QExpr\n\n Handles the printing of any unique identifying contents of a QExpr to\n print as its contents, such as any variables or quantum numbers. The\n default is to print the label, which is almost always the args. This\n should not include printing of any brackets or parenteses.\n \"\"\"\n return self._print_label(printer, *args)\n\n def _print_contents_pretty(self, printer, *args):\n return self._print_label_pretty(printer, *args)\n\n def _print_contents_latex(self, printer, *args):\n return self._print_label_latex(printer, *args)\n\n # Main printing methods\n\n def _sympystr(self, printer, *args):\n \"\"\"Default printing behavior of QExpr objects\n\n Handles the default printing of a QExpr. To add other things to the\n printing of the object, such as an operator name to operators or\n brackets to states, the class should override the _print/_pretty/_latex\n functions directly and make calls to _print_contents where appropriate.\n This allows things like InnerProduct to easily control its printing the\n printing of contents.\n \"\"\"\n return self._print_contents(printer, *args)\n\n def _sympyrepr(self, printer, *args):\n classname = self.__class__.__name__\n label = self._print_label_repr(printer, *args)\n return '%s(%s)' % (classname, label)\n\n def _pretty(self, printer, *args):\n pform = self._print_contents_pretty(printer, *args)\n return pform\n\n def _latex(self, printer, *args):\n return self._print_contents_latex(printer, *args)\n\n #-------------------------------------------------------------------------\n # Methods from Basic and Expr\n #-------------------------------------------------------------------------\n\n def doit(self, **kw_args):\n return self\n\n #-------------------------------------------------------------------------\n # Represent\n #-------------------------------------------------------------------------\n\n def _represent_default_basis(self, **options):\n raise NotImplementedError('This object does not have a default basis')\n\n def _represent(self, **options):\n \"\"\"Represent this object in a given basis.\n\n This method dispatches to the actual methods that perform the\n representation. Subclases of QExpr should define various methods to\n determine how the object will be represented in various bases. The\n format of these methods is::\n\n def _represent_BasisName(self, basis, **options):\n\n Thus to define how a quantum object is represented in the basis of\n the operator Position, you would define::\n\n def _represent_Position(self, basis, **options):\n\n Usually, basis object will be instances of Operator subclasses, but\n there is a chance we will relax this in the future to accommodate other\n types of basis sets that are not associated with an operator.\n\n If the ``format`` option is given it can be (\"sympy\", \"numpy\",\n \"scipy.sparse\"). This will ensure that any matrices that result from\n representing the object are returned in the appropriate matrix format.\n\n Parameters\n ==========\n\n basis : Operator\n The Operator whose basis functions will be used as the basis for\n representation.\n options : dict\n A dictionary of key/value pairs that give options and hints for\n the representation, such as the number of basis functions to\n be used.\n \"\"\"\n basis = options.pop('basis', None)\n if basis is None:\n result = self._represent_default_basis(**options)\n else:\n result = dispatch_method(self, '_represent', basis, **options)\n\n # If we get a matrix representation, convert it to the right format.\n format = options.get('format', 'sympy')\n result = self._format_represent(result, format)\n return result\n\n def _format_represent(self, result, format):\n if format == 'sympy' and not isinstance(result, Matrix):\n return to_sympy(result)\n elif format == 'numpy' and not isinstance(result, numpy_ndarray):\n return to_numpy(result)\n elif format == 'scipy.sparse' and \\\n not isinstance(result, scipy_sparse_matrix):\n return to_scipy_sparse(result)\n\n return result\n\n\ndef split_commutative_parts(e):\n \"\"\"Split into commutative and non-commutative parts.\"\"\"\n c_part, nc_part = e.args_cnc()\n c_part = list(c_part)\n return c_part, nc_part\n\n\ndef split_qexpr_parts(e):\n \"\"\"Split an expression into Expr and noncommutative QExpr parts.\"\"\"\n expr_part = []\n qexpr_part = []\n for arg in e.args:\n if not isinstance(arg, QExpr):\n expr_part.append(arg)\n else:\n qexpr_part.append(arg)\n return expr_part, qexpr_part\n\n\ndef dispatch_method(self, basename, arg, **options):\n \"\"\"Dispatch a method to the proper handlers.\"\"\"\n method_name = '%s_%s' % (basename, arg.__class__.__name__)\n if hasattr(self, method_name):\n f = getattr(self, method_name)\n # This can raise and we will allow it to propagate.\n result = f(arg, **options)\n if result is not None:\n return result\n raise NotImplementedError(\n \"%s.%s can't handle: %r\" %\n (self.__class__.__name__, basename, arg)\n )\n", "meta": {"hexsha": "6aa389f62fd3bf3626492749177568b577d9f65c", "size": 14257, "ext": "py", "lang": "Python", "max_stars_repo_path": "sympy/physics/quantum/qexpr.py", "max_stars_repo_name": "FabianBall/sympy", "max_stars_repo_head_hexsha": "9d849ddfc45427fe7f6733ce4d18fa397d0f43a9", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2015-01-17T23:15:04.000Z", "max_stars_repo_stars_event_max_datetime": "2015-05-26T14:11:44.000Z", "max_issues_repo_path": "sympy/physics/quantum/qexpr.py", "max_issues_repo_name": "FabianBall/sympy", "max_issues_repo_head_hexsha": "9d849ddfc45427fe7f6733ce4d18fa397d0f43a9", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2017-08-26T01:07:46.000Z", "max_issues_repo_issues_event_max_datetime": "2017-08-26T16:05:49.000Z", "max_forks_repo_path": "sympy/physics/quantum/qexpr.py", "max_forks_repo_name": "FabianBall/sympy", "max_forks_repo_head_hexsha": "9d849ddfc45427fe7f6733ce4d18fa397d0f43a9", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2018-10-21T06:32:46.000Z", "max_forks_repo_forks_event_max_datetime": "2018-10-21T06:32:46.000Z", "avg_line_length": 33.864608076, "max_line_length": 98, "alphanum_fraction": 0.5945149751, "include": true, "reason": "from sympy", "num_tokens": 3060, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.538983220687684, "lm_q2_score": 0.37022537869825406, "lm_q1q2_score": 0.19954526699110245}} {"text": "import numpy as np\nimport random\nimport statsmodels.api as sm\nimport itertools as it\nimport os\nfrom statsmodels.sandbox.stats.multicomp import multipletests\nfrom itertools import compress\nfrom sys import argv\n\ndef read_gems(directory, file_name):\n \"\"\"\n Read a GEM file of the form \"PlinePgem\".\n Args:\n directory (str): directory of the file location (ex: '/Users/kimm/')\n file_name (str): name of the file (ex: 'SHG0008H.Fragnum_PlinePgem')\n Returns:\n in_gems (list): tab-separated lists of lists\n \"\"\"\n with open(directory + file_name) as f:\n next(f)\n for line in f:\n entries = line.strip().split(\"\\t\")\n frags = entries[4]\n gem_id = entries[0]\n in_gems.append([frags+'|'+gem_id])\n return in_gems\n\ndef read_chroms(directory, genome_name):\n \"\"\"\n Read a tab-delimited text file with list of chromosomes and their sizes.\n Args:\n directory (str): directory of the file location (ex: '/Users/kimm/')\n genome_name (str): name of reference genome (ex: 'dm3', 'mm10', 'hg38', 'hg19', etc.)\n Note: must have a text file .chrom.sizes in the directory.\n Returns:\n chrom_dict (dictionary): tab-separated lists of lists\n \"\"\"\n chrom_dict = {}\n with open(directory + genome_name + '.chrom.sizes') as f:\n for line in f:\n tmp_list = line.strip().split(\"\\t\")\n chrom_dict[tmp_list[0]] = int(tmp_list[1])\n return chrom_dict\n\ndef extract_info(gem_list):\n \"\"\"\n Extract necessary information from input gem.\n Args:\n gem_list (list): list with 10 items as encoded in PlinePgem file\n Returns:\n gem_id (str): GEM ID (ex: SHG0008H-1000-10000799-AAACACCCACTAGTAC-K00384-FA-1-0)\n chrom (str): chromosome name (ex: chr2L)\n frags (list of list): [start,end] for each fragment \n (ex: [3251935, 3252561], [3413857, 3414485])\n span (int): start of leftmost fragment to end of rightmost fragment (ex: 162550)\n fraglen (list): length of each fragment (ex: [626, 628])\n f2fdist (list): distance between neighboring fragments (ex: [161296])\n fragnum (int): number of fragments\n fragstr (str): fragment coordinates string\n coord (str): gem coordinates\n \"\"\"\n raw_frags = gem_list[0].split(\"|\")[0].split(\";\")\n frags = []\n for j in range(len(raw_frags)):\n bedentry = raw_frags[j].split(\"(\")[0].replace(\"-\", \":\").split(\":\")\n frags.append([int(x) for x in bedentry[1:]])\n if '|' in gem_list[0]:\n gem_id = gem_list[0].split(\"|\")[1]\n else:\n gem_id = ''\n chrom = bedentry[0]\n span = frags[-1][1] - frags[0][0]\n fraglen = [x[1]-x[0] for x in frags]\n f2fdist = [frags[x][0]-frags[x-1][1] for x in range(1,len(frags))]\n fragnum = j + 1\n fragstr = ';'.join([chrom+':'+str(x[0])+'-'+str(x[1]) for x in frags])\n coord = chrom+':'+str(frags[0][0])+'-'+str(frags[-1][1])\n return gem_id, chrom, frags, span, fraglen, f2fdist, fragnum, fragstr, coord\n\ndef norm_shannon_ent(prob_list):\n \"\"\"\n Compute the normalized Shannon entropy of a list of probabilities.\n Args:\n prob_list (list): list of probabilities (ex: [0.1, 0.4, 0.5])\n Returns:\n entropy (float): tab-separated lists of lists (ex: 0.85867)\n \"\"\"\n if sum(prob_list) != 1: ## input is count or frequency instead of probability\n prob_list = [i/sum(prob_list) for i in prob_list]\n entropy = sum([x*np.log2(1/x) for x in prob_list])/np.log2(len(prob_list))\n return float(format(entropy, '.5f'))\n\ndef create_pseudo_gems(f2f_bucket, fragnum_bucket, samp_size, file_name):\n \"\"\"\n Create pseudoGEMs for each unique fragment number.\n Args:\n f2f_bucket (list): list of fragment-to-fragment distances, from which samples will be drawn\n fragnum_bucket (list): number of fragments in each GEM for all GEMs\n samp_size (int): number of pseudoGEMs to create\n file_name (str): file to write 1000 pseudoGEMs per frag_num\n Returns:\n pseudo_gem_tot_dist (dictionary): dictionary of a list of total distances for fragnum\n pseudo_gem_mean_ent (dictionary): dictionary of mean entropy for fragnum\n \"\"\"\n unique_frag_num = sorted(list(set(fragnum_bucket)))\n f2f_bucket_size = len(f2f_bucket)\n bucket_array = np.array(f2f_bucket)\n pseudo_gem_tot_dist = {}\n pseudo_gem_mean_ent = {}\n np.random.seed(12345)\n with open(file_name, 'a') as file1:\n for i in unique_frag_num:\n rand_ind = list(np.random.choice(range(f2f_bucket_size), (i-1)*samp_size))\n count = 0\n sum_ent = 0\n tmp_tot_dist = []\n for j in range(0,len(rand_ind), (i-1)):\n tmp_dist = bucket_array[rand_ind[j:(j+i-1)]].tolist()\n # get normalized Shannon entropy of first 1000 pseudoGEMs if a given GEM has > 2 fragments\n if (count < 1000): \n file1.write(str(i) + '\\t')\n file1.write(';'.join(map(str, tmp_dist)) + '\\t')\n if (i > 2):\n tmp_ent = norm_shannon_ent(tmp_dist)\n file1.write(str(tmp_ent) + '\\n')\n sum_ent = sum_ent + tmp_ent\n else:\n file1.write(\"NA\" + '\\n')\n count += 1\n tmp_tot_dist.append(sum(tmp_dist))\n pseudo_gem_tot_dist[str(i)] = np.sort(tmp_tot_dist)\n pseudo_gem_mean_ent[str(i)] = float(format(sum_ent/1000, '.5f'))\n pseudo_gem_tot_dist['1'] = [] # empty for singleton\n file1.close()\n return pseudo_gem_tot_dist, pseudo_gem_mean_ent\n\n\ndef get_raw_pval(f2f_dist, pseudo_gem_dist, samp_size):\n \"\"\"\n Get raw p-value by performing a distance test.\n Args:\n f2f_dist (list): fragment-to-fragment distances for a GEM (ex: [446,21231,249])\n pseudo_gem_dist (list): pseudo gem total distances of a given \n samp_size (int): number of pseudoGEMs to create (ex: 10000)\n Returns:\n raw_pval (float): raw p-value from a total distance test; '.' if singleton GEM\n \"\"\"\n if not f2f_dist:\n pval = '.'\n else:\n tot_dist = sum(f2f_dist)\n count = max(1, np.searchsorted(pseudo_gem_dist, tot_dist))\n pval = count/samp_size\n return pval\n\ndef get_adj_pval(raw_pval_list, fdr_thresh, method):\n \"\"\" \n Adjust raw pvalues by Benjamini Hochberg multiple testing adjustment. \n Args:\n raw_pval_list (list): list of raw p-values (ex: [0.1, 0.04, 0.1])\n fdr_thresh (float): false discovery rate (ex: 0.05)\n method (string): adjustment method (ex: 'fdr_bh')\n Returns:\n adj_pval_list (array): array of booleans and adjusted p-values (ex: [0.1, 0.1, 0.1])\n \"\"\"\n adj_pval_list = multipletests(raw_pval_list, alpha = fdr_thresh, method = method)\n return(adj_pval_list)\n\ndef entropy_filter(in_gem, pseudo_gem_ent, cutoff_ent_filter):\n \"\"\" \n Filter a GEM into subGEMs if potentially doublet or triplet (metric: norm shannon Entropy). \n Args:\n in_gem (string): input GEM with fragments and GEM ID (ex: 'chr2L:11-33;chr2L:44-55|tmp_gem_id')\n pseudo_gem_ent (float): mean of normalized Shannon entropies in 1000 pseudoGEM (ex: 0.12)\n cutoff_ent_filter (int): max_dist/sec_max_dist ratio cutoff threshold (ex: 2)\n Returns:\n num_cuts (int): number of cuts made in this filter (ex: 0,1, or 2)\n sub_gems (list of strings): [sub_gem1, sub_gem2, etc.]\n \"\"\"\n gem_id, chrom, frags, span, fraglen, f2fdist, fragnum, frag_str, coord = list(extract_info(in_gem))\n num_cuts = 0\n sub_gems = []\n obs_ent = norm_shannon_ent(f2fdist)\n if obs_ent < pseudo_gem_ent[str(fragnum)]: # cut once\n max_dist = max(f2fdist)\n max_dist_ind = f2fdist.index(max_dist)\n sec_max_dist = sorted(set(f2fdist))[-2]\n sec_max_dist_ind = f2fdist.index(sec_max_dist)\n sub_frags = [frags[:(max_dist_ind+1)], frags[(max_dist_ind+1):]]\n if max_dist/sec_max_dist < cutoff_ent_filter: # cut twice\n sorted_ind = sorted([max_dist_ind, sec_max_dist_ind])\n sub_frags = [frags[:(sorted_ind[0]+1)], frags[(sorted_ind[0]+1):(sorted_ind[1]+1)], frags[(sorted_ind[1]+1):]]\n num_cuts = len(sub_frags)-1\n for i in range(len(sub_frags)):\n sub_gems.append(';'.join([chrom+':'+str(x[0])+'-'+str(x[1]) for x in sub_frags[i]])+'|'+gem_id+'-sub-'+str(len(sub_frags))+'-'+str(i+1))\n else:\n sub_gems = [frag_str+'|'+gem_id]\n return sub_gems, num_cuts\n\ndef write_master_result(out_gem_list, out_name):\n \"\"\" \n Write out significance test results.\n Args: \n out_gem_list (list): list with 11 items including gem_id, frag_str, p-values, etc.\n out_name (string): output file name\n Returns:\n None\n \"\"\"\n with open(out_name, 'a') as file1:\n for i in range(len(out_gem_list)):\n file1.write('\\t'.join(map(str, out_gem_list[i])) + '\\n')\n file1.close()\n\nif __name__ == '__main__':\n \"\"\" \n Final results with following columns:\n 1) GEM ID 2) GEM coordinate 3) GEM span 4) fragnum 5) frag coord 6) orig/postEF 7) totdist \n 8) pval1 9) adj.pval1 10) status1 11) pval2 12) adj.pval2 13) status2\n \"\"\"\n ### Set parameters ###\n library_name = argv[1] ## Library name of our data ##\n genome_name = argv[2] ## Name of the reference genome ##\n fdr_thresh = float(argv[3]) ## Benjamini-Hochberg FDR; p-value cutoff ##\n cutoff_ent_filter = int(argv[4]) ## Ratio of largest to second largest F2F cutoff in our entropy filter ##\n samp_size = int(argv[5]) ## Number of pseudo-GEMs ##\n prefix = library_name + \"_FDR_\" + str(fdr_thresh) + \"_ratiothresh_\"+ str(cutoff_ent_filter) + \"_pseudoGEM_\"+str(samp_size)\n\n ### Set directory and input file name ###\n directory = argv[6]\n file_name = argv[7]\n chrom_dir = argv[8]\n out_directory = directory + library_name + \"_DistTest_FDR_\" + str(fdr_thresh) + '/'\n if not os.path.exists(out_directory):\n os.mkdir(out_directory)\n\n #### Log file ####\n out = open(out_directory + prefix + \"_distTest_logFile.txt\", \"a\")\n \n out.write(\"Software version: v0.2 (2019-10-08, Kim)\" + \"\\n\")\n out.write(\"Directory: \" + directory + \"\\n\")\n out.write(\"File name: \" + file_name + \"\\n\")\n out.write(\"Library name: \" + library_name + \"\\n\")\n out.write(\"Reference genome: \" + genome_name + \"\\n\")\n out.write(\"FDR threshold: \" + str(fdr_thresh) + \"\\n\")\n out.write(\"Ratio threshold in entropy filter: \" + str(cutoff_ent_filter) + \"\\n\")\n out.write(\"Number of pseudo-GEMs: \" + str(samp_size) + \"\\n\")\n out.write(\"Started processing domain-based distance test. \\n\")\n out.write(\"================================= \\n\")\n \n ### Read input GEM file ###\n in_gems = []\n in_gems = read_gems(directory, file_name)\n out.write(\"Finished reading the input GEM file. \\n\")\n out.write(str(len(in_gems)) + \" total GEMs. \\n\")\n out.write(\"================================= \\n\")\n \n ### Read chromosome names and sizes ###\n chrom_dict = read_chroms(chrom_dir, genome_name)\n\n header = ['GEM_ID', 'GEM_coord', 'GEM_span', 'Frag_number', 'List_of_frag_coord', 'category', 'dist', 'rawpval1', 'adjpval1', 'decis1', 'rawpval2', 'adjpval2', 'decis2']\n with open(out_directory+prefix+'_distTest_master.txt', 'a') as file1:\n file1.write('\\t'.join(map(str, header)) + '\\n')\n file1.close()\n\n tot_pass = 0\n for chr_name in chrom_dict.keys():\n ### Subset input GEM files by chromosome ###\n out.write(\"================================= \\n\")\n out.write(\"===== Chromosome is: \" + chr_name + \". ===== \\n\")\n out.write(\"================================= \\n\")\n subset_gems = [x for x in in_gems if chr_name == x[0].split(\":\")[0]]\n out.write(\"Finished subsetting GEMs. \\n\")\n out.write(str(len(subset_gems)) + \" GEMs in \" + chr_name + \" (of \" + str(len(in_gems)) + \" total GEMs). \\n\")\n if len(subset_gems) < 100:\n out.write(\"Skipped: less than 100 GEMs. \\n\")\n out.write(\"================================= \\n\")\n continue\n \n ### Initialize output GEM list ###\n out_gems = [] \n \n ### Create distance bucket ###\n f2f_bucket = []\n fragnum_bucket = []\n for i in range(len(subset_gems)):\n gem_id, chrom, frags, span, fraglen, f2fdist, fragnum, frag_str, coord = extract_info(subset_gems[i])\n f2f_bucket.extend(f2fdist)\n fragnum_bucket.append(fragnum)\n out.write(\"Maximum number of fragments in a GEM: \"+str(max(fragnum_bucket))+\"\\n\")\n \n ### Create pseudoGEMS ###i\n pseudo_file = out_directory + prefix + '_distTest_pseudo_' + chr_name + '.txt'\n pseudo_gem_tot_dist, pseudo_gem_mean_ent = create_pseudo_gems(f2f_bucket, fragnum_bucket, samp_size, pseudo_file)\n out.write(\"Finished creating \"+str(samp_size)+\" pseudoGEMs and total distance for each fragment number class. \\n\")\n del f2f_bucket\n \n ### Calculate raw p-values for subset_gems via distance test ###\n out.write(\"================================= \\n\")\n out.write(\" 1) Distance test. \\n\")\n out.write(\"================================= \\n\")\n for k in range(len(subset_gems)):\n gem_id, chrom, frags, span, fraglen, f2fdist, fragnum, frag_str, coord = list(extract_info(subset_gems[k]))\n raw_pval = get_raw_pval(f2fdist, pseudo_gem_tot_dist[str(fragnum)], samp_size)\n out_gems.append([gem_id, coord, span, fragnum, frag_str, 'Orig', sum(f2fdist), raw_pval])\n out.write(\"Finished computing raw p-values for \"+str(k+1)+\" GEMs. \\n\")\n \n ### Adjust p-values by fragment number classes in each chromosome ###\n deferred_gems = []\n for fn in sorted(list(set(fragnum_bucket))):\n indx = [i for i,val in enumerate(fragnum_bucket) if val==fn]\n pvals1 = [out_gems[k][7] for k in indx]\n adj_pval1 = get_adj_pval(pvals1, fdr_thresh, 'fdr_bh')\n for k in range(len(indx)):\n out_gems[indx[k]].append(round(adj_pval1[1][k], 4))\n # Subcategories from first distance test #\n if adj_pval1[0][k]==True:\n if fn < 101: # GEMs with <= 100 fragments pass; 20191008\n out_gems[indx[k]].extend(['PASS', '.', '.', '.'])\n else: # GEMs with > 100 fragments fail; 20191008\n out_gems[indx[k]].extend(['FAIL', '.', '.', '.'])\n elif adj_pval1[0][k]==False:\n if fn==2: # GEMs with 2 fragments fail\n out_gems[indx[k]].extend(['FAIL', '.', '.', '.'])\n else: # GEMs with > 2 fragments go to entropy filter\n out_gems[indx[k]].extend(['DEFER', '.', '.', '.'])\n deferred_gems.append(subset_gems[indx[k]])\n out.write(\"Finished adjusting p-values. \\n\")\n out.write(\"First test PASS: \"+str(len([x for x in out_gems if x[9] =='PASS']))+\"\\n\")\n out.write(\"First test FAIL: \"+str(len([x for x in out_gems if x[9] =='FAIL']))+\"\\n\")\n out.write(\"First test DEFER: \"+str(len([x for x in out_gems if x[9] =='DEFER']))+\"\\n\")\n pass1 = len([x for x in out_gems if x[9] =='PASS'])\n \n del pvals1\n del adj_pval1\n \n ### Entropy Filter for those in 'DEFER' category ###\n out.write(\"================================= \\n\")\n out.write(\" 2) Entropy filter. \\n\")\n out.write(\"================================= \\n\")\n ef_gems = []\n num_frag_list = []\n num_cut_list = []\n for k in range(len(deferred_gems)):\n sub_gems, num_cuts = entropy_filter(deferred_gems[k], pseudo_gem_mean_ent, cutoff_ent_filter)\n num_cut_list.append(num_cuts)\n for i in range(len(sub_gems)): \n gem_id, chrom, frags, span, fraglen, f2fdist, fragnum, fragstr, coord = list(extract_info([sub_gems[i]]))\n num_frag_list.append(fragnum)\n raw_pval = get_raw_pval(f2fdist, pseudo_gem_tot_dist[str(fragnum)], samp_size)\n ef_gems.append([gem_id, coord, span, fragnum, fragstr, 'EF-'+str(num_cuts), sum(f2fdist),'.','.', 'DEFER', raw_pval])\n out.write(\"Finished entropy filter for removing doublets. \\n\")\n out.write(\"Number of GEMs not split: \"+str(len([x for x in num_cut_list if x == 0]))+\"\\n\")\n out.write(\"Number of GEMs split once: \"+str(len([x for x in num_cut_list if x == 1]))+\"\\n\")\n out.write(\"Number of GEMs split twice: \"+str(len([x for x in num_cut_list if x == 2]))+\"\\n\")\n out.write(\"Number of non-singleton GEMs after cutting: \"+str(len([x for x in num_frag_list if x > 1]))+\"\\n\")\n out.write(\"Number of singleton GEMs after cutting: \"+str(len([x for x in num_frag_list if x == 1]))+\"\\n\")\n \n ### Adjust p-values by fragment number classes in each chromosome ###\n out.write(\"================================= \\n\")\n out.write(\" 3) Distance test. \\n\")\n out.write(\"================================= \\n\")\n sub_fragnum_bucket = [x[3] for x in ef_gems]\n for fn in sorted(list(set(sub_fragnum_bucket))):\n indx = [i for i,val in enumerate(sub_fragnum_bucket) if val==fn]\n if fn==1:\n for k in range(len(indx)):\n ef_gems[indx[k]].extend(['.','.'])\n else:\n pvals2 = [ef_gems[k][10] for k in indx]\n adj_pval2 = get_adj_pval(pvals2, fdr_thresh, 'fdr_bh')\n for k in range(len(indx)):\n ef_gems[indx[k]].append(round(adj_pval2[1][k], 4))\n if adj_pval2[0][k]==True:\n ef_gems[indx[k]].append('PASS')\n elif adj_pval2[0][k]==False:\n ef_gems[indx[k]].append('FAIL')\n out.write(\"Finished adjusting p-values. \\n\")\n out.write(\"Second test PASS: \"+str(len([x for x in ef_gems if x[12] =='PASS']))+\"\\n\")\n out.write(\"Second test FAIL: \"+str(len([x for x in ef_gems if x[12] =='FAIL']))+\"\\n\")\n pass2 = len([x for x in ef_gems if x[12] =='PASS'])\n out.write(\"================================= \\n\")\n \n del pvals2\n del adj_pval2\n \n ### Write results ###\n write_master_result(out_gems, out_directory+prefix+'_distTest_master.txt')\n write_master_result(ef_gems, out_directory+prefix+'_distTest_master.txt')\n out.write(\"Finished writing files. \\n\")\n \n tot_pass += pass1+pass2\n \n out.write(\"Total \" + str(pass1+pass2) + \" GEMs out of \" + str(len(subset_gems))+ \" GEMs passed. \\n\")\n out.write(\"i.e., \" + str(round((pass1+pass2)*100/len(subset_gems), 3)) + \"% passed in \" +chr_name+ \". \\n\")\n out.write(\"================================= \\n\")\n del out_gems\n del ef_gems\n del deferred_gems\n out.write(\"================================= \\n\")\n out.write(\"======= Summary Statistics ======= \\n\")\n out.write(\"Total \" + str(tot_pass) + \" GEMs out of \" + str(len(in_gems))+ \" GEMs passed. \\n\")\n out.write(\"i.e., \" + str(round((tot_pass)*100/len(in_gems), 3)) + \"% passed. \\n\")\n out.write(\"================================= \\n\")\n out.write(\"DONE. \\n\")\n \n out.close()\n", "meta": {"hexsha": "cfc5a570b7c16095f90e70c03bd45cc8fb855342", "size": 19537, "ext": "py", "lang": "Python", "max_stars_repo_path": "bin/domain_dist_sigtest.py", "max_stars_repo_name": "TheJacksonLaboratory/mia-sig", "max_stars_repo_head_hexsha": "a9a3b920c240c95cb589e77ae7e094036e6a0939", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-06-19T17:39:10.000Z", "max_stars_repo_stars_event_max_datetime": "2020-01-20T06:04:38.000Z", "max_issues_repo_path": "bin/domain_dist_sigtest.py", "max_issues_repo_name": "TheJacksonLaboratory/mia-sig", "max_issues_repo_head_hexsha": "a9a3b920c240c95cb589e77ae7e094036e6a0939", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-12-16T13:54:10.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-07T16:45:57.000Z", "max_forks_repo_path": "bin/domain_dist_sigtest.py", "max_forks_repo_name": "TheJacksonLaboratory/mia-sig", "max_forks_repo_head_hexsha": "a9a3b920c240c95cb589e77ae7e094036e6a0939", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-06-27T09:56:53.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-27T09:56:53.000Z", "avg_line_length": 48.0024570025, "max_line_length": 173, "alphanum_fraction": 0.5802835645, "include": true, "reason": "import numpy,import statsmodels,from statsmodels", "num_tokens": 5350, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.523420348936324, "lm_q2_score": 0.3812195803163617, "lm_q1q2_score": 0.19953808575054907}} {"text": "'''\n@Author: ConghaoWong\n@Date: 2019-12-20 09:39:34\nLastEditors: Conghao Wong\nLastEditTime: 2020-09-16 16:27:24\n@Description: classes and methods of training model\n'''\nimport os\nimport random\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport tensorflow as tf\nfrom tensorflow import keras\nfrom tqdm import tqdm\n\nfrom GridRefine import SocialRefine_one\nfrom helpmethods import calculate_ADE_FDE_numpy, dir_check, list2array\nfrom sceneFeature import TrajectoryMapManager\nfrom visual import TrajVisual\n\n\nclass Base_Model():\n \"\"\"\n Base model for prediction.\n\n Following items should be given when using this model:\n ```\n self.create_model(self), # create prediction model\n self.loss(self, model_output, gt, obs='null'), # loss function when training model\n self.loss_eval(self, model_output, gt, obs='null'), # loss function when test model\n self.forward_train(self, mode_inputs), # model result in training steps\n self.forward_test(self, test_tensor:list). # model result in test steps\n ```\n \"\"\"\n def __init__(self, train_info, args):\n self.args = args\n self.train_info = train_info\n \n def run_commands(self):\n self.get_data() # 获取与训练数据有关的信息\n\n if self.args.load == 'null':\n self.model, self.optimizer = self.create_model()\n self.model.summary()\n self.train()\n else:\n self.model, self.agents_test = self.load_from_checkpoint()\n self.model.summary()\n \n if self.args.test:\n self.test_batch(\n self.agents_test, \n test_on_neighbors=False,\n batch_size=0.2, # set 0.5 on toy exp\n social_refine=self.args.sr_enable,\n draw_results=self.args.draw_results,\n save_agents=False,\n )\n\n def get_data(self):\n self.obs_frames = self.args.obs_frames\n self.pred_frames = self.args.pred_frames\n self.total_frames = self.obs_frames + self.pred_frames\n self.log_dir = dir_check(self.args.log_dir)\n\n if not self.args.load == 'null':\n return\n\n self.agents_train = self.train_info['train_data']\n self.agents_test = self.train_info['test_data']\n self.train_number = self.train_info['train_number']\n self.sample_time = self.train_info['sample_time'] \n \n def load_from_checkpoint(self):\n base_path = self.args.load + '{}'\n if self.args.save_best:\n best_epoch = np.loadtxt(os.path.join(self.args.log_dir, 'best_ade_epoch.txt'))[1].astype(int)\n model = keras.models.load_model(base_path.format('_epoch{}.h5'.format(best_epoch)))\n else:\n model = keras.models.load_model(base_path.format('.h5'))\n\n agents_test = np.load(base_path.format('test.npy'), allow_pickle=True)\n return model, agents_test\n \n def create_model(self):\n raise 'MODEL is not defined!'\n return model, optimizer\n\n def loss(self, model_output, gt, obs='null'):\n \"\"\"\n Train loss, using ADE by default\n \"\"\"\n self.loss_namelist = ['ADE_t']\n loss_ADE = calculate_ADE(model_output[0], gt)\n loss_list = tf.stack([loss_ADE])\n return loss_ADE, loss_list\n\n def loss_eval(self, model_output, gt, obs='null'):\n \"\"\"\n Eval metrics, using ADE and FDE by default.\n return: `np.array`\n \"\"\"\n self.loss_eval_namelist = ['ADE', 'FDE']\n return calculate_ADE(model_output[0], gt).numpy(), calculate_FDE(model_output[0], gt).numpy()\n\n def prepare_model_inputs_all(self, input_agents):\n model_inputs = []\n gt = []\n agent_index = []\n for agent_index_current, agent in enumerate(tqdm(input_agents, desc='Prepare inputs...')):\n model_inputs.append(agent.get_train_traj())\n gt.append(agent.get_gt_traj())\n agent_index.append(agent_index_current)\n\n model_inputs = tf.cast(tf.stack(model_inputs), tf.float32)\n gt = tf.cast(tf.stack(gt), tf.float32)\n return [model_inputs, gt], agent_index\n\n def prepare_model_inputs_batch(self, train_tensor=0, batch_size=0, init=False):\n \"\"\"\n Get batch data from all data\n \"\"\"\n if init:\n self.batch_start = 0\n self.train_length = len(train_tensor[1])\n return self.train_length\n \n start = self.batch_start\n end = (self.batch_start + batch_size) % self.train_length\n # 每次最多取 1 epoch\n if end < start:\n if type(train_tensor[0]) == list:\n train_inputs = [\n tf.concat([\n train_input[start:],\n train_input[:end],\n ], axis=0) for train_input in train_tensor[0]\n ]\n else:\n train_inputs = tf.concat([\n train_tensor[0][start:],\n train_tensor[0][:end],\n ], axis=0)\n \n gt = tf.concat([\n train_tensor[1][start:],\n train_tensor[1][:end],\n ], axis=0)\n\n elif start + batch_size < self.train_length:\n if type(train_tensor[0]) == list:\n train_inputs = [train_input[start:end] for train_input in train_tensor[0]]\n else:\n train_inputs = train_tensor[0][start:end]\n gt = train_tensor[1][start:end]\n\n else:\n train_inputs = train_tensor[0]\n gt = train_tensor[1]\n\n self.batch_start = end\n return train_inputs, gt, len(gt)\n\n def forward_train(self, model_inputs):\n \"\"\"\n Run a training implement\n \"\"\"\n output = self.model(model_inputs)\n if not type(output) == list:\n output = [output]\n return output\n\n def forward_test(self, test_tensor:list):\n \"\"\"\n Run test once.\n `test_tensor` is a `list`. `test_tensor[0]` is the inputs of model and `test_tensor[1]` are their grount truths.\n \"\"\"\n model_inputs = test_tensor[0]\n gt = test_tensor[1]\n output = self.model(model_inputs)\n if not type(output) == list:\n output = [output]\n return output, gt, model_inputs\n\n def test_during_training(self, test_tensor, input_agents, test_index):\n \"\"\"\n Run test during training.\n Results will NOT be written to inputs.\n \"\"\"\n model_output, gt, obs = self.forward_test(test_tensor)\n loss_eval = self.loss_eval(model_output, gt, obs=obs)\n return model_output, loss_eval, gt, input_agents\n \n def train(self):\n \"\"\"\n Train the built model `self.model`\n \"\"\"\n batch_number = int(np.ceil(self.train_number / self.args.batch_size))\n summary_writer = tf.summary.create_file_writer(self.args.log_dir)\n\n print('\\n-----------------dataset options-----------------')\n if self.args.train_percent[0] and self.args.train_type == 'all':\n print('Sampling data from training sets. ({}x)'.format(self.args.train_percent))\n if self.args.reverse:\n print('Using reverse data to train. (2x)')\n if self.args.add_noise:\n print('Using noise data to train. ({}x)'.format(self.args.add_noise))\n if self.args.rotate:\n print('Using rotate data to train. ({}x)'.format(self.args.rotate))\n print('train_number = {}, total {}x train samples.'.format(self.train_number, self.sample_time))\n\n print('-----------------training options-----------------')\n print('model_name = {}, \\ndataset = {},\\nbatch_number = {},\\nbatch_size = {},\\nlr={}'.format(\n self.args.model_name,\n self.args.test_set, \n batch_number, \n self.args.batch_size,\n self.args.lr,\n ))\n\n print('\\nPrepare training data...')\n self.train_tensor, self.train_index = self.prepare_model_inputs_all(self.agents_train)\n self.test_tensor, self.test_index = self.prepare_model_inputs_all(self.agents_test)\n train_length = self.prepare_model_inputs_batch(self.train_tensor, init=True)\n\n if self.args.save_model:\n self.test_data_save_path = os.path.join(self.args.log_dir, '{}.npy'.format(self.args.model_name + '{}'))\n np.save(self.test_data_save_path.format('test'), self.agents_test) \n np.save(self.test_data_save_path.format('args'), self.args)\n \n test_results = []\n test_loss_dict = dict()\n test_loss_dict['-'] = 0\n\n batch_number = 1 + (train_length * self.args.epochs)// self.args.batch_size\n print(batch_number, train_length, self.args.epochs, self.args.batch_size)\n \n time_bar = tqdm(range(batch_number), desc='Training...')\n best_ade = 100.0\n best_epoch = 0\n for batch in time_bar:\n ADE = 0\n ADE_move_average = tf.cast(0.0, dtype=tf.float32) # 计算移动平均\n loss_list = []\n \n obs_current, gt_current, train_sample_number = self.prepare_model_inputs_batch(self.train_tensor, self.args.batch_size)\n\n if train_sample_number < 20:\n continue\n\n with tf.GradientTape() as tape:\n model_output_current = self.forward_train(obs_current)\n loss_ADE, loss_list_current = self.loss(model_output_current, gt_current, obs=obs_current)\n ADE_move_average = 0.7 * loss_ADE + 0.3 * ADE_move_average\n\n ADE += loss_ADE\n grads = tape.gradient(ADE_move_average, self.model.trainable_variables)\n self.optimizer.apply_gradients(zip(grads, self.model.trainable_variables))\n\n loss_list.append(loss_list_current)\n loss_list = tf.reduce_mean(tf.stack(loss_list), axis=0).numpy()\n\n epoch = (batch * self.args.batch_size) // train_length\n\n if (epoch >= self.args.start_test_percent * self.args.epochs) and (epoch % self.args.test_step == 0):\n model_output, loss_eval, _, _ = self.test_during_training(self.test_tensor, self.agents_test, self.test_index)\n test_results.append(loss_eval)\n test_loss_dict = create_loss_dict(loss_eval, self.loss_eval_namelist)\n ade_current = loss_eval[0]\n if ade_current <= best_ade:\n best_ade = ade_current\n best_epoch = epoch\n \n if self.args.save_best:\n self.model.save(os.path.join(self.args.log_dir, '{}_epoch{}.h5'.format(self.args.model_name, epoch)))\n np.savetxt(os.path.join(self.args.log_dir, 'best_ade_epoch.txt'), np.array([best_ade, best_epoch]))\n\n \n if epoch % 2 == 0:\n train_loss_dict = create_loss_dict(loss_list, self.loss_namelist)\n loss_dict = dict(train_loss_dict, **test_loss_dict) # 拼接字典\n time_bar.set_postfix(loss_dict)\n \n with summary_writer.as_default():\n for loss_name in loss_dict:\n value = loss_dict[loss_name]\n tf.summary.scalar(loss_name, value, step=epoch)\n\n print('Training done.')\n print('Tensorboard training log file is saved at \"{}\"'.format(self.args.log_dir))\n print('To open this log file, please use \"tensorboard --logdir {} --port 54393\"'.format(self.args.log_dir))\n \n latest_epochs = 10\n test_results = list2array(test_results)\n latest_results = np.mean(test_results[-latest_epochs-1:-1, :], axis=0)\n print('In latest {} test epochs, average test loss = {}'.format(\n latest_epochs,\n latest_results\n ))\n np.savetxt(os.path.join(self.args.log_dir, 'train_log.txt'), list2array(test_results))\n\n if self.args.save_model:\n self.model_save_path = os.path.join(self.args.log_dir, '{}.h5'.format(self.args.model_name))\n self.model.save(self.model_save_path)\n \n print('Trained model is saved at \"{}\".'.format(self.model_save_path.split('.h5')[0]))\n print('To re-test this model, please use \"python main.py --load {}\".'.format(self.model_save_path.split('.h5')[0]))\n \n model_name = self.model_save_path.split('.h5')[0].split('/')[-1]\n np.savetxt('./results/result-{}{}.txt'.format(model_name, self.args.test_set), latest_results)\n with open('./results/path-{}{}.txt'.format(model_name, self.args.test_set), 'w+') as f:\n f.write(self.model_save_path.split('.h5')[0])\n\n def test_batch(self, agents_test, test_on_neighbors=False, draw_results=True, batch_size=0.2, save_agents=False, social_refine=False):\n \"\"\"\n Eval model on test sets.\n Results WILL be written to inputs.\n 测试可以分段进行，并使用`batch_size`以百分比形式调节时间段长短;\n `test_on_neighbors`将会被自动打开当`social_refine == True`\n \"\"\"\n print('-----------------Test options-----------------')\n print('model_name = {},\\ndataset = {},\\ntest_length= {} * length of test video.\\n'.format(\n self.args.model_name,\n self.args.test_set, \n batch_size,\n ))\n \n start_frame = agents_test[0].obs_frame\n end_frame = agents_test[-1].obs_frame\n frame_length = end_frame - start_frame\n \n # sort by obs time\n agents_batch = dict()\n for agent in agents_test:\n batch_index = min(int((agent.obs_frame - start_frame)/(batch_size * frame_length)), int(1/batch_size)-1)\n if not batch_index in agents_batch:\n agents_batch[batch_index] = []\n else:\n agents_batch[batch_index].append(agent)\n \n if social_refine:\n test_on_neighbors = True\n\n agents_batch, test_index = self.prepare_test_agents_batch(agents_batch, test_on_neighbors)\n \n # run test\n all_loss = []\n all_loss_batch = []\n for batch_index in agents_batch:\n batch_loss = []\n [test_tensor, _], _ = self.prepare_model_inputs_all(agents_batch[batch_index], calculate_neighbor=test_on_neighbors)\n pred = self.forward_train(test_tensor)\n pred = pred[0].numpy()\n\n for agent_index, index in enumerate(test_index[batch_index]):\n current_pred = pred[index]\n agents_batch[batch_index][agent_index].write_pred(current_pred[0])\n if test_on_neighbors:\n agents_batch[batch_index][agent_index].write_pred_neighbor(current_pred[1:])\n \n if social_refine:\n agents_batch[batch_index][agent_index].write_pred_sr(SocialRefine_one(\n agent=agents_batch[batch_index][agent_index],\n args=self.args,\n epochs=10,\n save=False,\n ))\n \n loss = agents_batch[batch_index][agent_index].calculate_loss(SR=social_refine)\n all_loss.append(loss)\n batch_loss.append(loss)\n \n all_loss_batch.append(np.mean(np.stack(batch_loss), axis=0))\n \n average_loss = np.mean(np.stack(all_loss), axis=0)\n print('test_loss={}\\nTest done.'.format(create_loss_dict(average_loss, ['ADE', 'FDE'])))\n # print(all_loss_batch)\n\n if draw_results:\n result_agents = []\n for batch_index in agents_batch:\n result_agents += agents_batch[batch_index]\n\n # draw results only\n for index in range(len(result_agents)):\n result_agents[index].draw_results(self.log_dir, '{}.png'.format(index), draw_neighbors=False)\n \n # draw results on video frames\n # tv = TrajVisual(save_base_path=self.args.log_dir, verbose=True, draw_neighbors=False, social_refine=social_refine)\n # tv.visual(result_agents, dataset=self.args.test_set)\n\n if save_agents:\n result_agents = []\n for batch_index in agents_batch:\n result_agents += agents_batch[batch_index]\n np.save(os.path.join(self.log_dir, 'pred.npy'), result_agents)\n return result_agents\n \n def test(self, agents_test, test_on_neighbors=False, social_refine=True, draw_results=True, batch_size=0.2, save_agents=False):\n \"\"\"\n Eval model on test sets.\n Results WILL be written to inputs.\n \"\"\"\n all_loss = []\n loss_name_list = ['ADE', 'FDE']\n loss_function = calculate_ADE_FDE_numpy\n\n self.test_tensor, self.test_index = self.prepare_model_inputs_all(self.agents_test)\n pred = self.forward_train(self.test_tensor)\n\n for index in tqdm(range(len(agents_test)), desc='Testing...'):\n obs = agents_test[index].get_train_traj().reshape([1, agents_test[index].obs_length, 2])\n \n # if test_on_neighbors and agents_test[index].neighbor_number > 0:\n # obs_neighbor = (np.stack(agents_test[index].get_neighbor_traj())).reshape([agents_test[index].neighbor_number, agents_test[index].obs_length, 2])\n # obs = np.concatenate([obs, obs_neighbor], axis=0)\n\n \n agents_test[index].write_pred(pred[0].numpy()[index])\n # if test_on_neighbors:\n # agents_test[index].write_pred_neighbor(pred[1:].numpy()[index])\n\n # if social_refine:\n # agents_test[index].write_pred_sr(SocialRefine_one(agents_test[index], self.args_old))\n \n if draw_results:\n agents_test[index].draw_results(self.log_dir, '{}.png'.format(index), draw_neighbors=False # test_on_neighbors\n )\n\n all_loss.append(agents_test[index].calculate_loss())\n \n \n loss = np.mean(np.stack(all_loss), axis=0)\n \n print('test_loss={}'.format(create_loss_dict(loss, loss_name_list)))\n # for l in loss:\n # print(loss, end='\\t')\n print('\\nTest done.')\n\n if save_agents:\n np.save(os.path.join(self.log_dir, 'pred.npy'), agents_test)\n return agents_test\n \n def prepare_test_agents_batch(self, agents_batch:dict, test_on_neighbors=False):\n \"\"\"\n Prepare test agents and save test order. (When test on neighbors of current agent)\n returns: Test agents (in batch order) `agents_batch` and their order `test_index`.\n \"\"\"\n # save test order\n test_index = dict()\n for batch_index in agents_batch:\n total_count = 0\n if not batch_index in test_index:\n test_index[batch_index] = []\n\n for agent_index, _ in enumerate(agents_batch[batch_index]):\n start_count = total_count\n total_count += 1\n if test_on_neighbors:\n nei_len = agents_batch[batch_index][agent_index].neighbor_number\n total_count += nei_len\n test_index[batch_index].append([i for i in range(start_count, total_count)])\n \n return agents_batch, test_index\n\n\nclass BGM(Base_Model):\n \"\"\"\n `B`uilding a Dynamic `G`uidance `M`ap for Trajectory Prediction\n \"\"\"\n def __init__(self, train_info, args):\n super().__init__(train_info, args)\n self.given_maps_when_test=False\n\n def create_model(self):\n positions = keras.layers.Input(shape=[self.obs_frames, 2])\n traj_maps = keras.layers.Input(shape=[self.args.gridmapsize, self.args.gridmapsize])\n start_point = tf.reshape(positions[:, -1, :], [-1, 1, 2])\n \n # sequence feature\n positions_n = positions - start_point\n positions_embadding_lstm = keras.layers.Dense(64)(positions_n)\n traj_feature = keras.layers.LSTM(64, return_sequences=True)(positions_embadding_lstm)\n feature_flatten = tf.reshape(traj_feature, [-1, self.obs_frames * 64])\n sequence_feature = keras.layers.Dense(self.obs_frames * 32, activation=tf.nn.tanh)(feature_flatten)\n \n # context feature\n traj_maps_r = tf.reshape(traj_maps, [-1, self.args.gridmapsize, self.args.gridmapsize, 1])\n average_pooling = keras.layers.AveragePooling2D([2, 2], padding='same')(traj_maps_r)\n cnn1 = keras.layers.Conv2D(32, [8, 8], activation=tf.nn.relu)(average_pooling)\n cnn2 = keras.layers.Conv2D(32, [5, 5], activation=tf.nn.relu)(cnn1)\n pooling2 = keras.layers.AveragePooling2D([2, 2])(cnn2)\n flatten = keras.layers.Flatten()(pooling2)\n context_feature = keras.layers.Dense(self.obs_frames * 32, activation=tf.nn.tanh)(flatten)\n \n # joint feature\n concat_feature = tf.concat([sequence_feature, context_feature], axis=-1)\n feature_fc = keras.layers.Dense(self.pred_frames * 64)(concat_feature)\n feature_reshape = tf.reshape(feature_fc, [-1, self.pred_frames, 64])\n output5 = keras.layers.Dense(2)(feature_reshape)\n output5 = output5 + start_point\n \n lstm = keras.Model(inputs=[positions, traj_maps], outputs=[output5])\n lstm.build(input_shape=[None, self.obs_frames, 2])\n lstm_optimizer = keras.optimizers.Adam(lr=self.args.lr)\n \n return lstm, lstm_optimizer\n\n def get_feature(self, inputs, layer_name):\n submodel = keras.Model(inputs=self.model.input, outputs=self.model.get_layer(layer_name).output)\n return submodel(inputs)\n\n def prepare_model_inputs_all(self, input_agents, calculate_neighbor=False):\n input_trajs = []\n input_maps = []\n gt = []\n agent_index = []\n for agent_index_current, agent in enumerate(tqdm(input_agents, desc='Prepare inputs...')):\n input_trajs.append(agent.get_train_traj())\n input_maps.append(agent.get_traj_map())\n gt.append(agent.get_gt_traj())\n agent_index.append(agent_index_current)\n\n if calculate_neighbor and agent.neighbor_number:\n for traj, traj_map in zip(agent.get_neighbor_traj(), agent.get_traj_map_for_neighbors()):\n input_trajs.append(traj)\n input_maps.append(agent.get_traj_map())\n # No GT\n\n input_trajs = tf.cast(tf.stack(input_trajs), tf.float32)\n input_maps = tf.cast(tf.stack(input_maps), tf.float32)\n gt = tf.cast(tf.stack(gt), tf.float32)\n return [[input_trajs, input_maps], gt], agent_index\n\n def prepare_test_agents_batch(self, agents_batch:dict, test_on_neighbors=False):\n # create trajectory map for each batch\n if not type(self.given_maps_when_test) == np.ndarray:\n traj_maps = [TrajectoryMapManager(agents_batch[batch_index]) for batch_index in agents_batch]\n else:\n traj_maps = self.given_maps_when_test\n print('Using given maps')\n\n # write traj map and save batch order \n test_index = dict()\n for batch_index, traj_map in zip(agents_batch, traj_maps):\n total_count = 0\n if not batch_index in test_index:\n test_index[batch_index] = []\n \n for agent_index, _ in enumerate(agents_batch[batch_index]):\n agents_batch[batch_index][agent_index].write_traj_map(traj_map)\n start_count = total_count\n total_count += 1\n if test_on_neighbors:\n agents_batch[batch_index][agent_index].write_traj_map_for_neighbors(traj_map)\n nei_len = agents_batch[batch_index][agent_index].neighbor_number\n total_count += nei_len\n test_index[batch_index].append([i for i in range(start_count, total_count)])\n\n return agents_batch, test_index\n\n\nclass Linear(Base_Model):\n def __init__(self, train_info, args):\n super().__init__(train_info, args)\n self.args.batch_size = 1\n self.args.epochs = 1\n self.args.draw_results = False\n self.args.train_percent = 0.0\n \n def run_commands(self):\n self.get_data()\n self.model, self.optimizer = self.create_model()\n self.test_batch(\n self.agents_test,\n batch_size=1.0,\n test_on_neighbors=False,\n social_refine=False,\n draw_results=self.args.draw_results,\n save_agents=False\n )\n\n def predict_linear(self, x, y, x_p, diff_weights=0):\n if diff_weights == 0:\n P = np.diag(np.ones(shape=[x.shape[0]]))\n else:\n P = np.diag(softmax([(i+1)**diff_weights for i in range(x.shape[0])]))\n\n A = tf.transpose(tf.stack([np.ones_like(x), x]))\n A_p = tf.transpose(tf.stack([np.ones_like(x_p), x_p]))\n Y = tf.transpose(y)\n\n P = tf.cast(P, tf.float32)\n A = tf.cast(A, tf.float32)\n A_p = tf.cast(A_p, tf.float32)\n Y = tf.reshape(tf.cast(Y, tf.float32), [-1, 1])\n \n B = tf.matmul(tf.matmul(tf.matmul(tf.linalg.inv(tf.matmul(tf.matmul(tf.transpose(A), P), A)), tf.transpose(A)), P), Y)\n Y_p = np.matmul(A_p, B)\n return Y_p, B\n\n def predict_linear_for_person(self, positions, diff_weights):\n t = np.array([t for t in range(self.obs_frames)])\n t_p = np.array([t + self.obs_frames for t in range(self.pred_frames)])\n x = tf.transpose(positions)[0]\n y = tf.transpose(positions)[1]\n\n x_p, _ = self.predict_linear(t, x, t_p, diff_weights=diff_weights)\n y_p, _ = self.predict_linear(t, y, t_p, diff_weights=diff_weights)\n\n return tf.transpose(tf.reshape(tf.stack([x_p, y_p]), [2, self.pred_frames]))\n \n def create_model(self):\n return self.predict_linear_for_person, 0\n\n def forward_train(self, train_tensor, index):\n input_trajs = train_tensor[0][index[0]:index[1]]\n gt = train_tensor[1][index[0]:index[1]]\n\n results = []\n for inputs_current in input_trajs:\n results.append(self.model(inputs_current, diff_weights=self.args.diff_weights))\n \n return [tf.stack(results)], gt, input_trajs\n\n def forward_test(self, test_tensor):\n input_trajs = test_tensor[0]\n gt = test_tensor[1]\n \n results = []\n for inputs_current in input_trajs:\n results.append(self.model(inputs_current, diff_weights=self.args.diff_weights)) \n \n return output, gt, input_trajs\n\n\n\"\"\"\nhelpmethods\n\"\"\"\n\ndef create_loss_dict(loss, name_list):\n return dict(zip(name_list, loss))\n\n\ndef softmax(x):\n return np.exp(x)/np.sum(np.exp(x),axis=0)\n\n\ndef calculate_ADE(pred, GT):\n \"\"\"input_shape = [batch, pred_frames, 2]\"\"\"\n pred = tf.cast(pred, tf.float32)\n GT = tf.cast(GT, tf.float32)\n return tf.reduce_mean(tf.linalg.norm(pred - GT, ord=2, axis=2))\n \n\ndef calculate_FDE(pred, GT):\n pred = tf.cast(pred, tf.float32)\n GT = tf.cast(GT, tf.float32)\n return tf.reduce_mean(tf.linalg.norm(pred[:, -1, :] - GT[:, -1, :], ord=2, axis=1))\n", "meta": {"hexsha": "856170da65a1b3e71e3a0de6cfa95ab68384c583", "size": 27276, "ext": "py", "lang": "Python", "max_stars_repo_path": "models.py", "max_stars_repo_name": "conghaowoooong/Project-Erina", "max_stars_repo_head_hexsha": "e4e645a348d5df6d571d5334a0e2d5ecba8466bb", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "models.py", "max_issues_repo_name": "conghaowoooong/Project-Erina", "max_issues_repo_head_hexsha": "e4e645a348d5df6d571d5334a0e2d5ecba8466bb", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "models.py", "max_forks_repo_name": "conghaowoooong/Project-Erina", "max_forks_repo_head_hexsha": "e4e645a348d5df6d571d5334a0e2d5ecba8466bb", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.2647503782, "max_line_length": 163, "alphanum_fraction": 0.6036442294, "include": true, "reason": "import numpy", "num_tokens": 6053, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5234203489363239, "lm_q2_score": 0.3812195803163617, "lm_q1q2_score": 0.19953808575054902}} {"text": "import os\nimport pickle\n\nimport numpy as np\n\nfrom astropy.io import fits\nfrom astropy.table import Table\nfrom astropy.wcs import WCS\n\nfrom .config_file import get_values_from_config_file\nfrom .gausspy_py3.gp_plus import get_fully_blended_gaussians\nfrom .utils.fit_quality_checks import negative_residuals\nfrom .utils.gaussian_functions import gaussian, combined_gaussian, area_of_gaussian\nfrom .utils.output import say\nfrom .utils.spectral_cube_functions import correct_header, change_header, update_header, save_fits, return_hdu_options\nfrom .spatial_fitting import SpatialFitting\n\n\nclass Finalize(object):\n def __init__(self, path_to_pickle_file=None,\n path_to_decomp_file=None, fin_filename=None,\n config_file=''):\n \"\"\"Class containing methods to finalize the GaussPy+ results.\n\n Parameters\n ----------\n path_to_pickle_file : type\n Description of parameter `path_to_pickle_file`.\n path_to_decomp_file : type\n Description of parameter `path_to_decomp_file`.\n fin_filename : type\n Description of parameter `fin_filename`.\n config_file : type\n Description of parameter `config_file`.\n\n \"\"\"\n self.path_to_pickle_file = path_to_pickle_file\n self.path_to_decomp_file = path_to_decomp_file\n self.dirpath_gpy = None\n self.dirpath_table = None\n self.fin_filename = fin_filename\n\n self.dct_params = None\n self.config_file = config_file\n self.ncomps_max = None\n\n self.subcube_nr = None\n self.xpos_offset = 0\n self.ypos_offset = 0\n\n self.main_beam_efficiency = None\n\n self.initialized_state = False\n\n if config_file:\n get_values_from_config_file(\n self, config_file, config_key='DEFAULT')\n\n def check_settings(self):\n \"\"\"Check user settings and raise error messages or apply corrections.\"\"\"\n if self.path_to_pickle_file is None:\n raise Exception(\"Need to specify 'path_to_pickle_file'\")\n if self.path_to_decomp_file is None:\n raise Exception(\"Need to specify 'path_to_decomp_file'\")\n self.decomp_dirname = os.path.dirname(self.path_to_decomp_file)\n self.file = os.path.basename(self.path_to_decomp_file)\n self.filename, self.file_extension = os.path.splitext(self.file)\n\n if self.fin_filename is None:\n suffix = '_finalized'\n self.fin_filename = self.filename + suffix\n\n if self.dirpath_gpy is None:\n self.dirpath_gpy = os.path.dirname(self.decomp_dirname)\n\n if self.dirpath_table is None:\n self.dirpath_table = self.decomp_dirname\n\n def initialize(self):\n \"\"\"Read in data files and initialize parameters.\"\"\"\n with open(self.path_to_pickle_file, \"rb\") as pickle_file:\n self.pickled_data = pickle.load(pickle_file, encoding='latin1')\n\n with open(self.path_to_decomp_file, \"rb\") as pickle_file:\n self.decomposition = pickle.load(pickle_file, encoding='latin1')\n\n self.length = len(self.pickled_data['index'])\n\n if 'header' in self.pickled_data.keys():\n self.header = correct_header(self.pickled_data['header'])\n self.wcs = WCS(self.header)\n self.velocity_increment = (\n self.wcs.wcs.cdelt[2] * self.wcs.wcs.cunit[2]).to(\n self.vel_unit).value\n self.to_unit = (self.wcs.wcs.cunit[2]).to(self.vel_unit)\n if 'location' in self.pickled_data.keys():\n self.location = self.pickled_data['location']\n if 'nan_mask' in self.pickled_data.keys():\n self.nan_mask = self.pickled_data['nan_mask']\n\n self.channels = self.pickled_data['x_values']\n\n self.initialized_state = True\n\n def finalize_dct(self):\n self.check_settings()\n self.initialize()\n sp = SpatialFitting(config_file=self.config_file)\n if self.dct_params is not None:\n for key, value in self.dct_params.items():\n try:\n setattr(sp, key, value)\n except ValueError:\n raise Exception('Could not parse parameter {} from dct_params'.format(key))\n\n sp.log_output = False\n sp.path_to_pickle_file = self.path_to_pickle_file\n sp.path_to_decomp_file = self.path_to_decomp_file\n\n results_list = sp.finalize()\n\n list_means_interval, list_n_centroids = (\n [{} for _ in range(self.length)] for _ in range(2))\n\n for i, item in enumerate(results_list):\n if not isinstance(item, list):\n say(\"Error for index {}: {}\".format(i, item))\n continue\n\n index, means_interval, n_centroids = item\n list_means_interval[index] = means_interval\n list_n_centroids[index] = n_centroids\n\n self.decomposition['broad'] = sp.mask_broad_flagged\n self.decomposition['ncomps_wmedian'] = sp.ncomps_wmedian.astype('int')\n self.decomposition['ncomps_jumps'] = sp.ncomps_jumps.astype('int')\n self.decomposition['means_interval'] = list_means_interval\n self.decomposition['n_centroids'] = list_n_centroids\n\n def get_flag_blended(self, amps, fwhms, means):\n params_fit = amps + fwhms + means\n indices = get_fully_blended_gaussians(params_fit)\n flags = np.zeros(len(amps))\n flags[indices] = 1\n return flags.astype('int')\n\n def get_flag_broad(self, fwhms, broad):\n flags = np.zeros(len(fwhms))\n if broad:\n flags[np.argmax(fwhms)] = 1\n return flags.astype('int')\n\n def get_flag_centroid(self, means, means_interval, n_centroids):\n flag = 0\n for key in means_interval.keys():\n n_wanted = n_centroids[key]\n lower = means_interval[key][0]\n upper = means_interval[key][1]\n n_real = np.count_nonzero(\n np.logical_and(lower <= means, means <= upper))\n\n flag += abs(n_wanted - n_real)\n\n return flag\n\n def get_table_rows(self, idx, j):\n rows = []\n ncomps = self.decomposition['N_components'][idx]\n\n # do not continue if spectrum was masked out, was not fitted,\n # or was fitted by too many components\n if ncomps is None:\n return rows\n elif ncomps == 0:\n return rows\n elif self.ncomps_max is not None:\n if ncomps > self.ncomps_max:\n return rows\n\n yi, xi = self.pickled_data['location'][idx]\n spectrum = self.pickled_data['data_list'][idx]\n fit_amps = self.decomposition['amplitudes_fit'][idx]\n fit_fwhms = self.decomposition['fwhms_fit'][idx]\n fit_means = self.decomposition['means_fit'][idx]\n fit_e_amps = self.decomposition['amplitudes_fit_err'][idx]\n fit_e_fwhms = self.decomposition['fwhms_fit_err'][idx]\n fit_e_means = self.decomposition['means_fit_err'][idx]\n error = self.pickled_data['error'][idx][0]\n\n residual = spectrum - combined_gaussian(\n fit_amps, fit_fwhms, fit_means, self.pickled_data['x_values'])\n\n aicc = self.decomposition['best_fit_aicc'][idx]\n rchi2 = self.decomposition['best_fit_rchi2'][idx]\n pvalue = self.decomposition['pvalue'][idx]\n\n broad = self.decomposition['broad'][idx]\n\n ncomp_wmedian = self.decomposition['ncomps_wmedian'][idx]\n ncomp_jumps = self.decomposition['ncomps_jumps'][idx]\n\n means_interval = self.decomposition['means_interval'][idx]\n n_centroids = self.decomposition['n_centroids'][idx]\n\n flags_blended = self.get_flag_blended(fit_amps, fit_fwhms, fit_means)\n flags_neg_res_peak = negative_residuals(\n spectrum, residual, error, get_flags=True,\n fwhms=fit_fwhms, means=fit_means)\n flags_broad = self.get_flag_broad(fit_fwhms, broad)\n flag_centroid = self.get_flag_centroid(\n np.array(fit_means), means_interval, n_centroids)\n\n x_wcs, y_wcs, z_wcs = self.wcs.wcs_pix2world(\n xi, yi, np.array(fit_means), 0)\n\n velocities = z_wcs * self.to_unit\n e_velocities = np.array(fit_e_means) * self.velocity_increment\n vel_disps = (\n np.array(fit_fwhms) / 2.354820045) * self.velocity_increment\n e_vel_disps = (\n np.array(fit_e_fwhms) / 2.354820045) * self.velocity_increment\n\n amplitudes = np.array(fit_amps)\n e_amplitudes = np.array(fit_e_amps)\n\n if self.main_beam_efficiency is not None:\n amplitudes /= self.main_beam_efficiency\n e_amplitudes /= self.main_beam_efficiency\n error /= self.main_beam_efficiency\n\n integrated_intensity = area_of_gaussian(\n amplitudes, np.array(fit_fwhms) * self.velocity_increment)\n fit_fwhms_plus_error = np.array(fit_fwhms) + np.array(fit_e_fwhms)\n e_integrated_intensity = area_of_gaussian(\n amplitudes + e_amplitudes,\n fit_fwhms_plus_error * self.velocity_increment) -\\\n integrated_intensity\n\n for i in range(ncomps):\n row = [\n xi + self.xpos_offset, yi + self.ypos_offset,\n x_wcs[0], y_wcs[0],\n amplitudes[i], e_amplitudes[i],\n velocities[i], e_velocities[i],\n vel_disps[i], e_vel_disps[i],\n integrated_intensity[i], e_integrated_intensity[i],\n error, pvalue, aicc, rchi2,\n ncomps, ncomp_wmedian, ncomp_jumps,\n flags_blended[i], flags_neg_res_peak[i],\n flags_broad[i], flag_centroid]\n\n if self.subcube_nr is not None:\n row.append(self.subcube_nr)\n\n rows.append(row)\n\n return rows\n\n def make_table(self, save=True):\n \"\"\"Create table of the decomposition results.\n\n Parameters\n ----------\n save : bool\n Set to `True` if the table should be saved.\n\n Returns\n -------\n table_results : astropy.table.table.Table\n Table of the decomposition results.\n\n \"\"\"\n import gausspyplus.parallel_processing\n gausspyplus.parallel_processing.init([self.decomposition['index_fit'], [self]])\n\n results_list = gausspyplus.parallel_processing.func(\n use_ncpus=self.use_ncpus, function='make_table')\n\n for i, item in enumerate(results_list):\n if not isinstance(item, list):\n say(\"Error for spectrum with index {}: {}\".format(i, item))\n continue\n\n # results_list = [item for item in results_list if len(item) > 0]\n results_list = np.array([item for sublist in results_list\n for item in sublist])\n\n names = [\n 'x_pos', 'y_pos', self.wcs.wcs.lngtyp, self.wcs.wcs.lattyp,\n 'amp', 'e_amp', 'VLSR', 'e_VLSR', 'vel_disp', 'e_vel_disp',\n 'int_tot', 'e_int_tot', 'rms', 'pvalue', 'aicc', 'rchi2',\n 'ncomps', 'ncomp_wmedian', 'ncomp_jumps',\n 'flag_blended', 'flag_neg_res_peak', 'flag_broad', 'flag_centroid']\n\n dtype = ['i4']*2 + ['f4']*14 + ['i4']*7\n\n if self.subcube_nr is not None:\n names.append('subcube_nr')\n dtype.append('i4')\n\n table_results = Table(data=results_list, names=names, dtype=dtype)\n\n for key in names[2:16]:\n table_results[key].format = \"{0:.4f}\"\n\n if save:\n filename = self.fin_filename + '.dat'\n path_to_table = os.path.join(self.dirpath_table, filename)\n table_results.write(path_to_table, format='ascii', overwrite=True)\n say(\"\\033[92mSAVED FILE:\\033[0m '{}' in '{}'\".format(\n filename, self.decomp_dirname))\n\n return table_results\n\n def save_final_results(self):\n \"\"\"Save the results of the spatially coherent refitting iterations.\"\"\"\n filename = self.fin_filename + '.pickle'\n pathToFile = os.path.join(self.decomp_dirname, filename)\n pickle.dump(self.decomposition, open(pathToFile, 'wb'), protocol=2)\n say(\"\\033[92mSAVED FILE:\\033[0m '{}' in '{}'\".format(\n filename, self.decomp_dirname))\n\n def produce_map(self, keyword='error', comments=[], suffix='', save=True,\n dtype='float32'):\n \"\"\"Generate an array/FITS map of a GaussPy+ quantity.\n\n Parameters\n ----------\n keyword : str ['error', 'best_fit_rchi2', 'N_components']\n Keyword contained in GaussPy+ dictionary whose values should be made into an array.\n comments : list\n List of strings that are added to the FITS header of the map.\n suffix : str\n Suffix that is added to the filename.\n save : bool\n Set to `True` if the map should be saved.\n dtype : str\n Valid dtype for the resulting map.\n\n Returns\n -------\n astropy.io.fits.HDUList\n FITS HDU object of the map.\n\n \"\"\"\n # TODO: routine in case pickled_data is missing the header key\n shape = (self.header['NAXIS2'], self.header['NAXIS1'])\n array = np.ones((shape[0], shape[1])) * np.nan\n\n if keyword in self.pickled_data.keys():\n data = self.pickled_data[keyword]\n elif keyword in self.decomposition.keys():\n data = self.decomposition[keyword]\n\n for (y, x), value in zip(self.pickled_data['location'], data):\n if value is None:\n continue\n\n try:\n array[y, x] = value\n except ValueError:\n array[y, x] = value[0]\n\n header = change_header(self.header.copy(), format='pp',\n comments=comments)\n\n array = array.astype(dtype)\n\n if save:\n if keyword == 'error':\n filename, _ = os.path.splitext(\n os.path.basename(self.path_to_pickle_file))\n else:\n filename = self.filename\n\n filename = \"{}{}.fits\".format(filename, suffix)\n path_to_file = os.path.join(\n self.dirpath_gpy, 'gpy_maps', filename)\n\n save_fits(array, header, path_to_file,\n verbose=False)\n say(\"\\n\\033[92mSAVED FILE:\\033[0m '{}' in '{}'\".format(\n filename, os.path.dirname(path_to_file)), logger=self.logger)\n\n return fits.PrimaryHDU(array, header)\n\n def produce_noise_map(self, comments=['Rms noise values.'],\n suffix='_noise_map', save=True, dtype='float32',\n get_hdu=False, get_data=False, get_header=False):\n \"\"\"Produce a map of the rms noise values.\n\n Parameters\n ----------\n comments : list\n List of strings that are added to the FITS header of the map.\n suffix : str\n Suffix that is added to the filename.\n save : bool\n Set to `True` if the map should be saved.\n dtype : str\n Valid dtype for the resulting map.\n get_hdu : bool\n Default is `False`. If set to `True`, an astropy.io.fits.HDUList is returned. Overrides 'get_data' and 'get_header'.\n get_data : bool\n Default is `False`. Returns a numpy.ndarray of the FITS array.\n get_header : bool\n Default is `False`. Returns a astropy.io.fits.Header of the FITS array.\n\n Returns\n -------\n tuple or None\n Result from `return_hdu_options`.\n\n \"\"\"\n if not self.initialized_state:\n self.check_settings()\n self.initialize()\n hdu = self.produce_map(keyword='error', comments=comments,\n suffix=suffix, save=save, dtype=dtype)\n\n return return_hdu_options(\n hdu, get_hdu=get_hdu, get_data=get_data, get_header=get_header)\n\n def produce_rchi2_map(self, suffix='_rchi2_map', save=True, dtype='float32',\n get_hdu=False, get_data=False, get_header=False,\n comments=['Reduced chi-square values.']):\n \"\"\"Produce a map of the reduced chi-square values.\n\n Parameters\n ----------\n comments : list\n List of strings that are added to the FITS header of the map.\n suffix : str\n Suffix that is added to the filename.\n save : bool\n Set to `True` if the map should be saved.\n dtype : str\n Valid dtype for the resulting map.\n get_hdu : bool\n Default is `False`. If set to `True`, an astropy.io.fits.HDUList is returned. Overrides 'get_data' and 'get_header'.\n get_data : bool\n Default is `False`. Returns a numpy.ndarray of the FITS array.\n get_header : bool\n Default is `False`. Returns a astropy.io.fits.Header of the FITS array.\n\n Returns\n -------\n tuple or None\n Result from `return_hdu_options`.\n\n \"\"\"\n if not self.initialized_state:\n self.check_settings()\n self.initialize()\n hdu = self.produce_map(keyword='best_fit_rchi2', comments=comments,\n suffix=suffix, save=save, dtype=dtype)\n\n return return_hdu_options(\n hdu, get_hdu=get_hdu, get_data=get_data, get_header=get_header)\n\n def produce_component_map(self, suffix='_component_map', save=True,\n dtype='float32', get_hdu=False, get_data=False, get_header=False, comments=['Number of fitted Gaussian components.']):\n \"\"\"Produce a map of the number of fitted Gaussian components.\n\n Parameters\n ----------\n comments : list\n List of strings that are added to the FITS header of the map.\n suffix : str\n Suffix that is added to the filename.\n save : bool\n Set to `True` if the map should be saved.\n dtype : str\n Valid dtype for the resulting map.\n get_hdu : bool\n Default is `False`. If set to `True`, an astropy.io.fits.HDUList is returned. Overrides 'get_data' and 'get_header'.\n get_data : bool\n Default is `False`. Returns a numpy.ndarray of the FITS array.\n get_header : bool\n Default is `False`. Returns a astropy.io.fits.Header of the FITS array.\n\n Returns\n -------\n tuple or None\n Result from `return_hdu_options`.\n\n \"\"\"\n if not self.initialized_state:\n self.check_settings()\n self.initialize()\n hdu = self.produce_map(keyword='N_components', comments=comments,\n suffix=suffix, save=save, dtype=dtype)\n\n return return_hdu_options(\n hdu, get_hdu=get_hdu, get_data=get_data, get_header=get_header)\n\n def make_cube(self, mode='full_decomposition', save=True, get_hdu=False,\n get_data=False, get_header=False, dtype='float32'):\n \"\"\"Create FITS cube of the decomposition results.\n\n Parameters\n ----------\n mode : str\n 'full_decomposition' recreates the whole FITS cube, 'integrated_intensity' creates a cube with the integrated intensity values of the Gaussian components placed at their mean positions, 'main_component' only retains the fitted component with the largest amplitude value\n save : bool\n Set to `True` if the map should be saved.\n dtype : str\n Valid dtype for the resulting map.\n get_hdu : bool\n Default is `False`. If set to `True`, an astropy.io.fits.HDUList is returned. Overrides 'get_data' and 'get_header'.\n get_data : bool\n Default is `False`. Returns a numpy.ndarray of the FITS array.\n get_header : bool\n Default is `False`. Returns a astropy.io.fits.Header of the FITS array.\n\n Returns\n -------\n tuple or None\n Result from `return_hdu_options`.\n\n \"\"\"\n say('\\ncreate {} cube...'.format(mode))\n\n x = self.header['NAXIS1']\n y = self.header['NAXIS2']\n z = self.header['NAXIS3']\n\n array = np.zeros([z, y, x], dtype=np.float32)\n nSpectra = len(self.decomposition['N_components'])\n\n for idx in range(nSpectra):\n ncomps = self.decomposition['N_components'][idx]\n if ncomps is None:\n continue\n\n yi = self.location[idx][0]\n xi = self.location[idx][1]\n\n amps = self.decomposition['amplitudes_fit'][idx]\n fwhms = self.decomposition['fwhms_fit'][idx]\n means = self.decomposition['means_fit'][idx]\n\n if self.main_beam_efficiency is not None:\n amps = [amp / self.main_beam_efficiency for amp in amps]\n\n if mode == 'main_component' and ncomps > 0:\n j = amps.index(max(amps))\n array[:, yi, xi] = gaussian(\n amps[j], fwhms[j], means[j], self.channels)\n elif mode == 'integrated_intensity' and ncomps > 0:\n for j in range(ncomps):\n integrated_intensity = area_of_gaussian(\n amps[j], fwhms[j] * self.velocity_increment)\n channel = int(round(means[j]))\n if self.channels[0] <= channel <= self.channels[-1]:\n array[channel, yi, xi] += integrated_intensity\n elif mode == 'full_decomposition':\n array[:, yi, xi] = combined_gaussian(\n amps, fwhms, means, self.channels)\n\n nans = self.nan_mask[:, yi, xi]\n array[:, yi, xi][nans] = np.NAN\n\n array[self.nan_mask] = np.nan\n array = array.astype(dtype)\n\n if mode == 'main_component':\n comment = 'Fit component with highest amplitude per spectrum.'\n filename = \"{}_main.fits\".format(self.filename, self.suffix)\n elif mode == 'integrated_intensity':\n comment = 'Integrated intensity of fit component at VLSR position.'\n filename = \"{}_int_tot.fits\".format(self.filename, self.suffix)\n elif mode == 'full_decomposition':\n comment = 'Recreated dataset from fit components.'\n filename = \"{}_decomp.fits\".format(self.filename, self.suffix)\n\n comments = ['GaussPy+ decomposition results:']\n comments.append(comment)\n if self.main_beam_efficiency is not None:\n comments.append('Corrected for main beam efficiency of {}.'.format(\n self.main_beam_efficiency))\n\n header = update_header(\n self.header.copy(), comments=comments, write_meta=True)\n\n if save:\n pathToFile = os.path.join(self.decomp_dirname, 'FITS', filename)\n save_fits(array, header, pathToFile, verbose=False)\n say(\"\\033[92mSAVED FILE:\\033[0m '{}' in '{}'\".format(\n filename, os.path.dirname(pathToFile)))\n\n hdu = fits.PrimaryHDU(array, header)\n\n return return_hdu_options(\n hdu, get_hdu=get_hdu, get_data=get_data, get_header=get_header)\n", "meta": {"hexsha": "4cfa1271eb728817163587d4a1a45c73044515a2", "size": 23239, "ext": "py", "lang": "Python", "max_stars_repo_path": "gausspyplus/finalize.py", "max_stars_repo_name": "cmurray-astro/gausspyplus", "max_stars_repo_head_hexsha": "bb26e561da70b8b130c785fbc4324c95bc416766", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 34, "max_stars_repo_stars_event_min_datetime": "2019-06-03T14:03:28.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-02T16:25:23.000Z", "max_issues_repo_path": "gausspyplus/finalize.py", "max_issues_repo_name": "cmurray-astro/gausspyplus", "max_issues_repo_head_hexsha": "bb26e561da70b8b130c785fbc4324c95bc416766", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2020-03-13T06:35:58.000Z", "max_issues_repo_issues_event_max_datetime": "2021-04-06T07:06:23.000Z", "max_forks_repo_path": "gausspyplus/finalize.py", "max_forks_repo_name": "cmurray-astro/gausspyplus", "max_forks_repo_head_hexsha": "bb26e561da70b8b130c785fbc4324c95bc416766", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2019-06-26T01:48:28.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-20T23:54:07.000Z", "avg_line_length": 38.9916107383, "max_line_length": 281, "alphanum_fraction": 0.5993373209, "include": true, "reason": "import numpy,from astropy", "num_tokens": 5242, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5234203489363239, "lm_q2_score": 0.38121958031636166, "lm_q1q2_score": 0.199538085750549}} {"text": "#!/usr/bin/env python\n\"\"\"\n\nrunsim.py by John Swoboda 3/16/2015\nThis script will run the SimISR code. The user can run a number of different\naspects including making data, fitting applying matrix formulation of the\nspace-time ambuiguty operator and calling inversion methods.\n\n\nInputs\n -f These will be the possible functions that can be used\n spectrums :makespectrums,\n radardata :makeradardata,\n fitting :fitdata,'\n fittingmat :fitdata,\n fittinginv :fitdata,\n applymat applymat\n\"\"\"\nfrom __future__ import print_function\n\n#imported basic modules\nimport time\nimport sys\nfrom datetime import datetime\nimport traceback\nimport argparse\nimport ipdb\n\n# Imported scipy and matplotlib modules\nimport scipy as sp\n# My modules\nfrom SimISR import Path\nfrom SimISR.IonoContainer import IonoContainer\nfrom SimISR.radarData import RadarDataFile\nimport SimISR.specfunctions as specfuncs\nfrom SimISR.fitterMethodGen import Fitterionoconainer\nfrom SimISR.utilFunctions import readconfigfile, update_progress\nfrom SimISR.operators import RadarSpaceTimeOperator\n\n#%% Make spectrums\ndef makespectrums(basedir, configfile, printlines=True):\n \"\"\" This will make all of the spectra for a set of data and save it in a\n folder in basedir called Spectrums. It is assumed that the data in the Origparams\n is time tagged in the title with a string seperated by a white space and the\n rest of the file name. For example ~/DATA/Basedir/0 origdata.h5.\n Inputs:\n basedir: A string for the directory that will hold all of the data for the simulation.\n configfile: The configuration file for the simulation.\n \"\"\"\n basedir = Path(basedir).expanduser()\n dirio = ('Origparams', 'Spectrums')\n inputdir = basedir/dirio[0]\n outputdir = basedir/dirio[1]\n # determine the list of h5 files in Origparams directory\n dirlist = sorted(inputdir.glob('*.h5'))\n # Make the lists of numbers and file names for the dictionary\n (listorder, _, _, timebeg, _) = IonoContainer.gettimes(dirlist)\n slist = [dirlist[ikey] for ikey in listorder]\n (sensdict, simparams) = readconfigfile(configfile)\n # Delete data\n outfiles = outputdir.glob('*.h5')\n for ifile in outfiles:\n ifile.unlink()\n\n for inum, curfile in zip(timebeg, slist):\n\n outfile = outputdir / (str(inum)+' spectrum.h5')\n update_progress(float(inum)/float(len(slist)),\n 'Processing file {} starting at {}'.format(curfile.name, datetime.now()))\n curiono = IonoContainer.readh5(str(curfile))\n\n curiono.makespectruminstanceopen(specfuncs.ISRSspecmake, sensdict,\n int(simparams['numpoints']), float(inum),\n float(len(slist)), printlines).saveh5(str(outfile))\n update_progress(float(inum+1)/float(len(slist)),\n 'Finished file {} starting at {}'.format(curfile.name, datetime.now()))\n\n#%% Make Radar Data\ndef makeradardata(basedir,configfile,remakealldata):\n \"\"\" This function will make the radar data and create the acf estimates.\n Inputs:\n basedir: A string for the directory that will hold all of the data for the simulation.\n configfile: The configuration file for the simulation.\n remakealldata: A bool that determines if the radar data is remade. If false\n only the acfs will be estimated using the radar that is already made.\"\"\"\n\n dirio = ('Spectrums', 'Radardata', 'ACF')\n inputdir = basedir/dirio[0]\n outputdir = basedir/dirio[1]\n outputdir2 = basedir/dirio[2]\n\n # determine the list of h5 files in Origparams directory\n dirlist = [str(i) for i in inputdir.glob('*.h5')]\n # Make the lists of numbers and file names for the dictionary\n if len(dirlist) > 0:\n (listorder, _, _, timebeg, _) = IonoContainer.gettimes(dirlist)\n\n Ionodict = {timebeg[itn]:dirlist[it] for itn, it in enumerate(listorder)}\n else:\n Ionodict = {0.:str(inputdir.joinpath('00.h5'))}\n # Find all of the raw data files\n radardatalist = outputdir.glob('*RawData.h5')\n if radardatalist and (not remakealldata):\n # XXX need to work on time stuff\n outlist2 = radardatalist\n else:\n outlist2 = None\n\n # create the radar data file class\n rdata = RadarDataFile(Ionodict, configfile, outputdir, outfilelist=outlist2)\n # From the ACFs and uncertainties\n (ionoout, ionosig) = rdata.processdataiono()\n # save the acfs and uncertianties in ionocontainer h5 files.\n ionoout.saveh5(str(outputdir2.joinpath('00lags.h5')))\n ionosig.saveh5(str(outputdir2.joinpath('00sigs.h5')))\n return ()\n#%% Fit data\ndef fitdata(basedir,configfile,optinputs):\n \"\"\" This function will run the fitter on the estimated ACFs saved in h5 files.\n Inputs:\n basedir: A string for the directory that will hold all of the data for the simulation.\n configfile: The configuration file for the simulation.\n optinputs:A string that helps determine the what type of acfs will be fitted.\n \"\"\"\n # determine the input folders which can be ACFs from the full simulation\n dirdict = {'fitting':('ACF', 'Fitted'), 'fittingmat':('ACFMat', 'FittedMat'),\n 'fittinginv':('ACFInv', 'FittedInv'), 'fittingmatinv':('ACFMatInv', 'FittedMatInv')}\n dirio = dirdict[optinputs[0]]\n inputdir = basedir/dirio[0]\n outputdir = basedir/dirio[1]\n fitlist = optinputs[1]\n if len(optinputs) > 2:\n exstr = optinputs[2]\n printlines = optinputs[3]\n else:\n exstr = ''\n dirlist = [str(i) for i in inputdir.glob('*lags{0}.h5'.format(exstr))]\n dirlistsig = [str(i) for i in inputdir.glob('*sigs{0}.h5'.format(exstr))]\n\n Ionoin = IonoContainer.readh5(dirlist[0])\n if len(dirlistsig) == 0:\n Ionoinsig = None\n else:\n Ionoinsig = IonoContainer.readh5(dirlistsig[0])\n fitterone = Fitterionoconainer(Ionoin, Ionoinsig, configfile)\n\n fitoutput = fitterone.fitdata(specfuncs.ISRSfitfunction,\n fitterone.simparams['startfile'], fittimes=fitlist,\n printlines=printlines)\n\n #ipdb.set_trace()\n (fitteddata, fittederror, funcevals, fittedcov) = fitoutput\n if fitterone.simparams['Pulsetype'].lower() == 'barker':\n paramlist = fitteddata\n\n species = fitterone.simparams['species']\n paramnames = ['Ne']\n if not fittederror is None:\n fittederronly = sp.sqrt(fittederror)\n paramlist = sp.concatenate([fitteddata, fittederronly], axis=2)\n paramnamese = ['n'+ip for ip in paramnames]\n paranamsf = sp.array(paramnames+paramnamese)\n else:\n paranamsf = sp.array(paramnames)\n else:\n fittederronly = sp.sqrt(fittederror)\n paramnames = []\n species = fitterone.simparams['species']\n # Seperate Ti and put it in as an element of the ionocontainer.\n Ti = fitteddata[:, :, 1]\n\n nTi = fittederronly[:, :, 1]\n\n nTiTe = fittedcov[:, :, 0, 1]\n nTiNe = fittedcov[:, :, 0, 2]\n nTiVi = fittedcov[:, :, 0, 3]\n nTeNe = fittedcov[:, :, 1, 2]\n nTeVi = fittedcov[:, :, 1, 3]\n nNeVi = fittedcov[:, :, 2, 3]\n cov_list = [nTiTe[:, :, sp.newaxis], nTiNe[:, :, sp.newaxis],\n nTiVi[:, :, sp.newaxis], nTeNe[:, :, sp.newaxis],\n nTeVi[:, :, sp.newaxis], nNeVi[:, :, sp.newaxis]]\n cov_list_names = ['nTiTe', 'nTiNe', 'nTiVi', 'nTeNe', 'nTeVi','nNeVi']\n paramlist = sp.concatenate([fitteddata, Ti[:, :, sp.newaxis], fittederronly,\n nTi[:, :, sp.newaxis], funcevals[:, :, sp.newaxis]]\n + cov_list, axis=2)\n for isp in species[:-1]:\n paramnames.append('Ni_'+isp)\n paramnames.append('Ti_'+isp)\n paramnames = paramnames+['Ne', 'Te', 'Vi', 'Nepow', 'Ti']\n paramnamese = ['n'+ip for ip in paramnames]\n paranamsf = sp.array(paramnames+paramnamese+['FuncEvals']+cov_list_names)\n\n if fitlist is None:\n timevec = Ionoin.Time_Vector\n else:\n if len(fitlist) == 0:\n timevec = Ionoin.Time_Vector\n else:\n timevec = Ionoin.Time_Vector[fitlist]\n # This requires\n if set(Ionoin.Coord_Vecs) == {'x', 'y', 'z'}:\n newver = 0\n ionoout = IonoContainer(Ionoin.Cart_Coords, paramlist.real, timevec, ver=newver,\n coordvecs=Ionoin.Coord_Vecs, paramnames=paranamsf,\n species=species)\n elif set(Ionoin.Coord_Vecs) == {'r', 'theta', 'phi'}:\n newver = 1\n ionoout = IonoContainer(Ionoin.Sphere_Coords, paramlist.real, timevec, ver=newver,\n coordvecs=Ionoin.Coord_Vecs, paramnames=paranamsf,\n species=species)\n\n\n outfile = outputdir.joinpath('fitteddata{0}.h5'.format(exstr))\n ionoout.saveh5(str(outfile))\n#%% apply the matrix for the data\ndef applymat(basedir, configfile, optinputs):\n \"\"\"\n This function apply the matrix version of the space time ambiugty function\n to the ACFs and save the outcome in h5 files within the directory ACFMat.\n Inputs:\n basedir: A string for the directory that will hold all of the data for the simulation.\n configfile: The configuration file for the simulation.\n \"\"\"\n dirio = ('Spectrums', 'Mat', 'ACFMat')\n basedir = Path(basedir)\n inputdir = basedir.joinpath(dirio[0])\n outputdir2 = basedir.joinpath(dirio[2])\n\n dirlist = [str(i) for i in inputdir.glob('*.h5')]\n (listorder, timevector, _, _, _) = IonoContainer.gettimes(dirlist)\n ionolist = [dirlist[ikey] for ikey in listorder]\n rsto = RadarSpaceTimeOperator(ionolist, configfile, timevector, mattype='matrix')\n ionoout = rsto.mult_iono(ionolist)\n outfile = outputdir2.joinpath('00lags.h5')\n ionoout.saveh5(str(outfile))\n\n#%% For sorting\ndef ke(item):\n \"\"\"\n Used for sorting names of files.\n \"\"\"\n if item[0].isdigit():\n return int(item.partition(' ')[0])\n else:\n return float('inf')\n#%% Main function\ndef main(funcnamelist,basedir,configfile,remakealldata,fitlist=None,invtype='',printlines=True):\n \"\"\" Main function for this module. The function will set up the directory\n structure, create or update a diary file and run the simulation depending\n on the user input.\n Inputs\n funcnamelist: A list of strings that coorespond to specific functions.\n The stirng and function they correspond to, that will be shown.\n\n spectrums: makespectrums, This will create the ISR spectrums\n\n radardata :makeradardata, This will make the radar data and\n form the ACF estimates. If the raw radar data exists then\n the user must use the -r option on the command line and set\n it to y.\n\n fitting :fitdata, This will apply the fitter to the data in\n the ACF folder of the base directory.\n\n fittingmat :fitdata,This will apply the fitter to the data in\n the ACFMat folder of the base directory.\n\n fittinginv :fitdata,This will apply the fitter to the data in\n the ACFInv folder of the base directory.\n\n applymat :applymat, This wil create and apply a matrix\n formulation of thespace-time ambiguity function to ISR spectrums.\n basedir: The base directory that will contain all of the data. This directory\n must contain a directory called Origparams with h5 files to run\n the full simulation. The user can also start with a directory\n from a later stage of the simulation instead though.\n\n configfile: The configuration used for the simulation. Can be an ini file or\n a pickle file.\n\n remakealldata: A bool to determine if the raw radar data will be remade. If\n this is False the radar data will only be made if it does\n not exist in the file first.\n fitlist: A list of time entries that will be fit.\n\n invtype\n\n \"\"\"\n\n inputsep = '***************************************************************\\n'\n\n funcdict = {'spectrums':makespectrums, 'radardata':makeradardata, 'fitting':fitdata,'fittingmat':fitdata,\n 'fittinginv':fitdata,'applymat':applymat,'fittingmatinv':fitdata}\n #inout = {'spectrums':('Origparams','Spectrums'),'radardata':('Spectrums','Radardata'),'fitting':('ACF','Fitted')}\n #pdb.set_trace()\n\n # check for the directories\n dirnames = ['Origparams','Spectrums','Radardata','ACF','Fitted','ACFOrig','ACFMat','ACFInv','FittedMat','FittedInv','ACFMatInv','FittedMatInv']\n basedir=Path(basedir).expanduser()\n for idir in dirnames:\n curdir = basedir/idir\n curdir.mkdir(exist_ok=True,parents=True)\n\n if len(funcnamelist)==3:\n funcname='all'\n else:\n funcname=''.join(funcnamelist)\n\n dfilename = 'diary'+funcname+'.txt'\n dfullfilestr = basedir/dfilename\n\n with open(str(dfullfilestr),'a') as f:\n failure=False\n for curfuncn in funcnamelist:\n curfunc = funcdict[curfuncn]\n f.write(inputsep)\n f.write(curfunc.__name__+'\\n')\n f.write(time.asctime()+'\\n')\n if curfunc.__name__=='fitdata':\n ex_inputs=[curfuncn,fitlist,invtype,printlines]\n elif curfunc.__name__=='makeradardata':\n ex_inputs = remakealldata\n else:\n ex_inputs=printlines\n try:\n stime = datetime.now()\n curfunc(basedir,configfile,ex_inputs)\n ftime = datetime.now()\n ptime = ftime-stime\n f.write('Success!\\n')\n f.write('Duration: {}\\n'.format(ptime))\n f.write('Base directory: {}\\n'.format(basedir))\n\n except Exception as e:\n f.write('Failed!\\n')\n ftime = datetime.now()\n ptime = ftime-stime\n f.write('Duration: {}\\n'.format(ptime))\n f.write('Base directory: {}\\n'.format(basedir))\n traceback.print_exc(file=sys.stdout)\n traceback.print_exc(file=f)\n failure = True\n break\n\n f.write(inputsep)\n\n\n return failure\n\ndef parse_command_line(str_input=None):\n \"\"\"\n This will parse through the command line arguments\n \"\"\"\n # if str_input is None:\n parser = argparse.ArgumentParser()\n # else:\n # parser = argparse.ArgumentParser(str_input)\n fstr = ''' These will be the possible strings for the argument and the\n function they correspond to, that will be used ish shown.\n\n spectrums: makespectrums, This will create the ISR spectrums\n\n radardata :makeradardata, This will make the radar data and\n form the ACF estimates. If the raw radar data exists then\n the user must use the -r option on the command line and set\n it to y.\n\n fitting :fitdata, This will apply the fitter to the data in\n the ACF folder of the base directory.\n\n fittingmat :fitdata,This will apply the fitter to the data in\n the ACFMat folder of the base directory.\n\n fittinginv :fitdata,This will apply the fitter to the data in\n the ACFInv folder of the base directory.\n\n applymat :applymat, This wil create and apply a matrix\n formulation of thespace-time ambiguity function to ISR spectrums.\n\n\n all - This will run the commands from using the spectrums, radardata,\n and fitting\n '''\n parser.add_argument('-f', '--funclist', dest='funclist', default='all', help=fstr)\n\n parser.add_argument(\"-v\", \"--verbose\", action=\"store_true\",\n dest=\"verbose\", default=False,\n help=\"prints debug output and additional detail.\")\n parser.add_argument(\"-c\", \"--config\", dest=\"config\", default='default.ini',\n help=\" Config file used for the simulation, .ini or yaml file.\")\n parser.add_argument('-p', \"--path\", dest='path', default=None,\n help='Number of incoherent integrations in calculations.')\n parser.add_argument('-r', \"--remake\", action=\"store_true\", dest='remake', default=False,\n help='Remake data flag.')\n\n if str_input is None:\n return parser.parse_args()\n else:\n return parser.parse_args(str_input)\n\nif __name__ == \"__main__\":\n\n outstr = '''\n Usage: python runsim.py -f -i -c -r \n\n or\n\n python runsim.py -h\n\n This script will run the SimISR code. The user\n can run a number of different aspects including making data, fitting\n applying matrix formulation sof the space-time operator and calling\n inversion methods.\n\n\n Manditory Arguments to run code, for help just use the -h option.\n\n -f These will be the possible strings for the argument and the\n function they correspond to, that will be used ish shown.\n\n spectrums: makespectrums, This will create the ISR spectrums\n\n radardata :makeradardata, This will make the radar data and\n form the ACF estimates. If the raw radar data exists then\n the user must use the -r option on the command line and set\n it to y.\n\n fitting :fitdata, This will apply the fitter to the data in\n the ACF folder of the base directory.\n\n fittingmat :fitdata,This will apply the fitter to the data in\n the ACFMat folder of the base directory.\n\n fittinginv :fitdata,This will apply the fitter to the data in\n the ACFInv folder of the base directory.\n\n applymat :applymat, This wil create and apply a matrix\n formulation of thespace-time ambiguity function to ISR spectrums.\n\n\n all - This will run the commands from using the spectrums, radardata,\n and fitting\n\n -i The base directory that will contain all of the data. This directory\n must contain a directory called Origparams with h5 files to run\n the full simulation. The user can also start with a directory\n from a later stage of the simulation instead though.\n\n -c The configuration used for the simulation. Can be an ini file or\n a pickle file.\n\n Optional arguments\n\n -r If a y follows this then the raw radar data will be remade. If\n this is not used the radar data will only be made if it does\n not exist in the file first.\n\n Example:\n python runsim.py -f radardata -f fitting -i ~/DATA/ExampleLongPulse -c ~/DATA/Example -r y'''\n\n args_commd = parse_command_line()\n if args_commd.path is None:\n print(\"Please provide an input source with the -p option!\")\n sys.exit(1)\n basedir = str(Path(args_commd.path).expanduser())\n configfile = str(Path(args_commd.config).expanduser())\n funcname = args_commd.funclist\n remakealldata = args_commd.remake\n\n if funcname.lower() == 'all':\n funcnamelist = ['spectrums', 'radardata', 'fitting']\n else:\n funcnamelist = funcname.split()\n\n failflag = main(funcnamelist, basedir, configfile, remakealldata)\n", "meta": {"hexsha": "7c21df7ef12f621960cf6fe2434a7154b9786890", "size": 20100, "ext": "py", "lang": "Python", "max_stars_repo_path": "SimISR/runsim.py", "max_stars_repo_name": "jswoboda/RadarDataSim", "max_stars_repo_head_hexsha": "3eb6fcd8601e8ae25acc375e6d933169d14bb40f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2018-10-06T14:15:50.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-28T21:29:07.000Z", "max_issues_repo_path": "SimISR/runsim.py", "max_issues_repo_name": "jswoboda/SimISR", "max_issues_repo_head_hexsha": "3eb6fcd8601e8ae25acc375e6d933169d14bb40f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 8, "max_issues_repo_issues_event_min_datetime": "2016-12-03T23:27:19.000Z", "max_issues_repo_issues_event_max_datetime": "2018-06-06T03:04:06.000Z", "max_forks_repo_path": "SimISR/runsim.py", "max_forks_repo_name": "jswoboda/SimISR", "max_forks_repo_head_hexsha": "3eb6fcd8601e8ae25acc375e6d933169d14bb40f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2016-11-18T08:00:53.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-05T13:47:57.000Z", "avg_line_length": 42.1383647799, "max_line_length": 147, "alphanum_fraction": 0.6152238806, "include": true, "reason": "import scipy", "num_tokens": 4865, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.523420348936324, "lm_q2_score": 0.38121956625614994, "lm_q1q2_score": 0.19953807839114812}} {"text": "\"\"\" This module provides the basic classes for the pulse retrieval algorithms.\r\n\"\"\"\r\nimport numpy as np\r\nfrom types import SimpleNamespace\r\nfrom .. import io\r\nfrom ..mesh_data import MeshData\r\nfrom ..pulse_error import pulse_error\r\nfrom .. import lib\r\nfrom ..pnps import BasePNPS\r\nfrom math import isclose\r\n\r\n# global dictionary that contains all PNPS classes\r\n_RETRIEVER_CLASSES = {}\r\n\r\n\r\n# =============================================================================\r\n# Metaclass and factory\r\n# =============================================================================\r\nclass MetaRetriever(type):\r\n \"\"\" Metaclass that registers Retriever classes in a global dictionary.\r\n \"\"\"\r\n def __new__(cls, clsmethod, bases, attrs):\r\n global _RETRIEVER_CLASSES\r\n newclass = super().__new__(cls, clsmethod, bases, attrs)\r\n method = newclass.method\r\n if method is None:\r\n return newclass\r\n # register the Retriever method, e.g. 'copra'\r\n if method in _RETRIEVER_CLASSES:\r\n raise ValueError(\"Two retriever classes implement retriever '%s'.\"\r\n % method)\r\n _RETRIEVER_CLASSES[method] = newclass\r\n return newclass\r\n\r\n\r\nclass MetaIORetriever(io.MetaIO, MetaRetriever):\r\n # to fix metaclass conflicts\r\n pass\r\n\r\n\r\n# =============================================================================\r\n# Retriever Base class\r\n# =============================================================================\r\nclass BaseRetriever(io.IO, metaclass=MetaIORetriever):\r\n \"\"\" The abstract base class for pulse retrieval.\r\n\r\n This class implements common functionality for different retrieval\r\n algorithms.\r\n \"\"\"\r\n method = None\r\n supported_schemes = None\r\n _io_store = ['pnps', 'options', 'logging', 'log',\r\n '_retrieval_state', '_result']\r\n\r\n def __init__(self, pnps, logging=False, verbose=False, **kwargs):\r\n self.pnps = pnps\r\n self.ft = self.pnps.ft\r\n self.options = SimpleNamespace(**kwargs)\r\n self._result = None\r\n self.logging = logging\r\n self.verbose = verbose\r\n self.log = None\r\n rs = self._retrieval_state = SimpleNamespace()\r\n rs.running = False\r\n if (self.supported_schemes is not None and\r\n pnps.scheme not in self.supported_schemes):\r\n raise ValueError(\"Retriever '%s' does not support scheme '%s'. \"\r\n \"It only supports %s.\" %\r\n (self.method, pnps.scheme, self.supported_schemes)\r\n )\r\n\r\n def retrieve(self, measurement, initial_guess, weights=None,\r\n **kwargs):\r\n \"\"\" Retrieve pulse from ``measurement`` starting at ``initial_guess``.\r\n\r\n Parameters\r\n ----------\r\n measurement : MeshData\r\n A MeshData instance that contains the PNPS measurement. The first\r\n axis has to correspond to the PNPS parameter, the second to the\r\n frequency. The data has to be the measured _intensity_ over the\r\n frequency (not wavelength!). The second axis has to match exactly\r\n the frequency axis of the underlying PNPS instance. No\r\n interpolation is done.\r\n initial_guess : 1d-array\r\n The spectrum of the pulse that is used as initial guess in the\r\n iterative retrieval.\r\n weights : 1d-array\r\n Weights that are attributed to the measurement for retrieval.\r\n In the case of (assumed) Gaussian uncertainties with standard\r\n deviation sigma they should correspond to 1/sigma.\r\n Not all algorithms support using the weights.\r\n kwargs : dict\r\n Can override retrieval options specified in :func:`__init__`.\r\n\r\n Notes\r\n -----\r\n This function provides no interpolation or data processing. You have\r\n to write a retriever wrapper for that purpose.\r\n \"\"\"\r\n self.options.__dict__.update(**kwargs)\r\n if not isinstance(measurement, MeshData):\r\n raise ValueError(\"measurement has to be a MeshData instance!\")\r\n self._retrieve_begin(measurement, initial_guess, weights)\r\n self._retrieve()\r\n self._retrieve_end()\r\n\r\n def _retrieve_begin(self, measurement, initial_guess, weights):\r\n pnps = self.pnps\r\n if not np.allclose(pnps.process_w, measurement.axes[1], rtol=1e-6):\r\n raise ValueError(\"Measurement has to lie on simulation grid!\")\r\n # Store measurement\r\n self.measurement = measurement\r\n self.parameter = measurement.axes[0]\r\n self.Tmn_meas = measurement.data\r\n\r\n self.initial_guess = initial_guess\r\n # set the size\r\n self.M, self.N = self.Tmn_meas.shape\r\n # Setup the weights\r\n if weights is None:\r\n self._weights = np.ones((self.M, self.N))\r\n else:\r\n self._weights = weights.copy()\r\n # Retrieval state\r\n rs = self._retrieval_state\r\n rs.approximate_error = False\r\n rs.running = True\r\n rs.steps_since_improvement = 0\r\n # Initialize result\r\n res = self._result = SimpleNamespace()\r\n res.trace_error = self.trace_error(self.initial_guess)\r\n res.approximate_error = False\r\n res.spectrum = self.initial_guess.copy()\r\n # Setup the logger\r\n if self.logging:\r\n log = self.log = SimpleNamespace()\r\n log.trace_error = []\r\n log.initial_guess = self.initial_guess.copy()\r\n else:\r\n self.log = None\r\n if self.verbose:\r\n print(\"Started retriever '%s'\" % self.method)\r\n print(\"Options:\")\r\n print(self.options)\r\n print(\"Initial trace error R = {:.10e}\".format(res.trace_error))\r\n print(\"Starting retrieval...\")\r\n print()\r\n\r\n def _retrieve_end(self):\r\n rs = self._retrieval_state\r\n rs.running = False\r\n res = self._result\r\n if res.approximate_error:\r\n res.trace_error = self.trace_error(res.spectrum)\r\n res.approximate_error = False\r\n\r\n def _project(self, measured, Smk):\r\n \"\"\" Performs the projection on the measured intensity.\r\n \"\"\"\r\n # in frequency domain\r\n Smn = self.ft.forward(Smk)\r\n # project and specially handle values with zero amplitude\r\n absSmn = np.abs(Smn)\r\n f = (absSmn > 0.0)\r\n Smn[~f] = np.sqrt(measured[~f] + 0.0j)\r\n Smn[f] = Smn[f] / absSmn[f] * np.sqrt(measured[f] + 0.0j)\r\n # back in time domain\r\n Smk2 = self.ft.backward(Smn)\r\n return Smk2\r\n\r\n def _objective_function(self, spectrum):\r\n \"\"\" Calculates the minimization objective from the pulse spectrum.\r\n\r\n This is Eq. 11 in the paper:\r\n\r\n r = sum (Tmn^meas - mu * Tmn)\r\n \"\"\"\r\n # calculate the PNPS trace\r\n Tmn = self.pnps.calculate(spectrum, self.parameter)\r\n return self._r(Tmn)\r\n\r\n def trace_error(self, spectrum, store=True):\r\n \"\"\" Calculates the trace error from the pulse spectrum.\r\n \"\"\"\r\n Tmn = self.pnps.calculate(spectrum, self.parameter)\r\n return self._R(Tmn, store=store)\r\n\r\n def _r(self, Tmn, store=True):\r\n \"\"\" Calculates the minimization objective r from a simulated trace Tmn.\r\n \"\"\"\r\n diff = self._error_vector(Tmn, store=store)\r\n return np.sum(diff * diff)\r\n\r\n def _error_vector(self, Tmn, store=True):\r\n \"\"\" Calculates the residual vector from measured to simulated\r\n intensity.\r\n \"\"\"\r\n # rename\r\n rs = self._retrieval_state\r\n Tmn_meas = self.Tmn_meas\r\n # scaling factor\r\n w2 = self._weights * self._weights\r\n mu = np.sum(Tmn_meas * Tmn * w2) / np.sum(Tmn * Tmn * w2)\r\n # store intermediate results in current retrieval state\r\n if store:\r\n rs.mu = mu\r\n rs.Tmn = Tmn\r\n rs.Smk = self.pnps.Smk\r\n return np.ravel((Tmn_meas - mu * Tmn) * self._weights)\r\n\r\n def _R(self, Tmn, store=True):\r\n \"\"\" Calculates the trace error from a simulated trace Tmn.\r\n \"\"\"\r\n r = self._r(Tmn, store=store)\r\n return self._Rr(r)\r\n\r\n def _Rr(self, r):\r\n \"\"\" Calculates the trace error from the minimization objective r.\r\n \"\"\"\r\n return np.sqrt(r / (self.M * self.N *\r\n (self.Tmn_meas * self._weights).max()**2))\r\n\r\n def result(self, pulse_original=None, full=True):\r\n \"\"\" Analyzes the retrieval results in one retrieval instance\r\n and processes it for plotting or storage.\r\n \"\"\"\r\n rs = self._retrieval_state\r\n if self._result is None or self._retrieval_state.running:\r\n return None\r\n res = SimpleNamespace()\r\n # the meta data\r\n res.parameter = self.parameter\r\n res.options = self.options\r\n res.logging = self.logging\r\n res.measurement = self.measurement\r\n # store the retriever itself\r\n if full:\r\n res.pnps = self.pnps\r\n else:\r\n res.pnps = None\r\n\r\n # the pulse spectra\r\n # 1 - the retrieved pulse\r\n res.pulse_retrieved = self._result.spectrum\r\n # 2 - the original test pulse, optional\r\n res.pulse_original = pulse_original\r\n # 3 - the initial guess\r\n res.pulse_initial = self.initial_guess\r\n\r\n # the measurement traces\r\n # 1 - the original data used for retrieval\r\n res.trace_input = self.Tmn_meas\r\n # 2 - the trace error and the trace calculated from the retrieved pulse\r\n res.trace_error = self.trace_error(res.pulse_retrieved)\r\n res.trace_retrieved = rs.mu * rs.Tmn\r\n res.response_function = rs.mu\r\n # the weights\r\n res.weights = self._weights\r\n\r\n # this is set if the original spectrum is provided\r\n if res.pulse_original is not None:\r\n # the trace error of the test pulse (non-zero for noisy input)\r\n res.trace_error_optimal = self.trace_error(res.pulse_original)\r\n # 3 - the optimal trace calculated from the test pulse\r\n res.trace_original = rs.mu * rs.Tmn\r\n dot_ambiguity = False\r\n if self.pnps.method == \"ifrog\" or self.pnps.scheme == \"shg-frog\":\r\n dot_ambiguity = True\r\n # the pulse error to the test pulse\r\n res.pulse_error, res.pulse_retrieved = pulse_error(\r\n res.pulse_retrieved, res.pulse_original, self.ft,\r\n dot_ambiguity=dot_ambiguity)\r\n\r\n if res.logging:\r\n # the logged trace errors\r\n res.trace_errors = np.array(self.log.trace_error)\r\n # the running minimum of the trace errors (for plotting)\r\n res.rm_trace_errors = np.minimum.accumulate(res.trace_errors,\r\n axis=-1)\r\n if self.verbose:\r\n lib.retrieval_report(res)\r\n return res\r\n\r\n\r\ndef Retriever(pnps: BasePNPS, method: str = \"copra\", maxiter=300, maxfev=None,\r\n logging=False, verbose=False, **kwargs) -> BaseRetriever:\r\n \"\"\" Creates a retriever instance.\r\n\r\n Parameters\r\n ----------\r\n pnps : PNPS\r\n A PNPS instance that is used to simulate a PNPS measurement.\r\n method : str, optional\r\n Type of solver. Should be one of\r\n - 'copra' :class:`(see here) `\r\n - 'gpa' :class:`(see here) `\r\n - 'gp-dscan' :class:`(see here) `\r\n - 'pcgpa' :class:`(see here) `\r\n - 'pie' :class:`(see here) `\r\n - 'lm' :class:`(see here) `\r\n - 'bfgs' :class:`(see here) `\r\n - 'de' :class:`(see here) `\r\n - 'nelder-mead' :class:`(see here) `\r\n\r\n 'copra' is the default choice.\r\n maxiter : int, optional\r\n The maximum number of algorithm iterations. The default is 300.\r\n maxfev : int, optional\r\n The maximum number of function evaluations. If given, the algorithms\r\n stop before this number is reached. Not all algorithms support this\r\n feature. Default is ``None``, in which case it is ignored.\r\n logging : bool, optional\r\n Stores trace errors and pulses over the iterations if supported\r\n by the retriever class. Default is `False`.\r\n verbose : bool, optional\r\n Prints out trace errors during the iteration if supported by the\r\n retriever class. Default is `False`.\r\n \"\"\"\r\n method = method.lower()\r\n try:\r\n cls = _RETRIEVER_CLASSES[method]\r\n except KeyError:\r\n raise ValueError(\"Retriever '%s' is unknown!\" % (method))\r\n return cls(pnps, maxiter=maxiter, maxfev=maxfev,\r\n logging=logging, verbose=verbose, **kwargs)\r\n", "meta": {"hexsha": "d486804a554d435cc7821c231874793ca816080f", "size": 13072, "ext": "py", "lang": "Python", "max_stars_repo_path": "pypret/retrieval/retriever.py", "max_stars_repo_name": "liam-clink/pypret", "max_stars_repo_head_hexsha": "c84e954efc12137c6b5ade4fae920d60a15d4875", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pypret/retrieval/retriever.py", "max_issues_repo_name": "liam-clink/pypret", "max_issues_repo_head_hexsha": "c84e954efc12137c6b5ade4fae920d60a15d4875", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pypret/retrieval/retriever.py", "max_forks_repo_name": "liam-clink/pypret", "max_forks_repo_head_hexsha": "c84e954efc12137c6b5ade4fae920d60a15d4875", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.9755351682, "max_line_length": 80, "alphanum_fraction": 0.5738219094, "include": true, "reason": "import numpy", "num_tokens": 2906, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.523420348936324, "lm_q2_score": 0.38121956625614994, "lm_q1q2_score": 0.19953807839114812}} {"text": "\"\"\"\nPython Navigation Abstract Class\n@Author: Kristian Gibson\nTODO: Comments + Sphynx Docs Structured Text\nTODO: Bug-fix, testing\n\n\"\"\"\n\nfrom abc import ABC\nfrom scipy import integrate\nfrom scipy.ndimage import interpolation\nfrom spatialmath.base.transforms2d import *\nfrom spatialmath.base.vectors import *\nfrom spatialmath import SE2, SE3\nfrom matplotlib import cm\nfrom abc import ABC, abstractmethod\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\nimport copy\nfrom roboticstoolbox.mobile.OccGrid import BaseOccupancyGrid, BinaryOccupancyGrid\nfrom roboticstoolbox.mobile.Animations import VehiclePolygon\nfrom colored import fg, attr\n\ntry:\n from progress.bar import FillingCirclesBar\n _progress = True\nexcept:\n _progress = False\n\nclass PlannerBase(ABC):\n r\"\"\"\n Mobile robot motion planner (superclass)\n\n :param occgrid: occupancy grid, defaults to None\n :type occgrid: :class:`OccGrid` instance of ndarray(N,M), optional\n :param start: start position :math:`(x, y)` or configuration :math:`(x, y, \\theta)`, defaults to None\n :type start: array_like(2) or array_like(3), optional\n :param goal: goal position :math:`(x, y)` or configuration :math:`(x, y, \\theta)`, defaults to None\n :type goal: array_like(2) or array_like(3), optional\n :param inflate: obstacle inflation, defaults to 0\n :type inflate: float, optional\n :param ndims: dimensionality of the planning, either 2 for :math:`\\mathbb{R}^2` or \n 3 for :math:`\\SE{2}`\n :param ndims: int, optional\n :param verbose: verbosity, defaults to False\n :type verbose: bool, optional\n :param msgcolor: color for message channel printing\n :type msgcolor: str, defaults to yellow\n :param seed: seed provided to private random number generator, defaults to None\n :type seed: int, optional\n\n Superclass for all mobile robot motion planners. Key functionality\n includes:\n\n - encapsulates an occupancy grid and optionally inflates it\n - encapsulates a private random number generator with specifiable seed\n - encapsulates state such as start, goal, and the plan\n - provides a message channel for diagnostic output\n\n :seealso: :class:`OccGrid`\n \"\"\"\n\n def __init__(self, occgrid=None, inflate=0, ndims=None,\n verbose=False, msgcolor='yellow', \n progress=True, marker=None, seed=None, **unused):\n\n self._occgrid = None\n if ndims is None:\n raise ValueError('ndims must be specified')\n self._ndims = ndims\n self._verbose = verbose\n self._msgcolor = msgcolor\n self._seed = seed\n self._private_random = np.random.default_rng(seed=seed)\n self._inflate = inflate\n self._start = None\n self._goal = None\n\n self._progress = progress and _progress\n\n self.marker = marker\n\n if occgrid is not None:\n if not isinstance(occgrid, BaseOccupancyGrid):\n occgrid = BinaryOccupancyGrid(occgrid)\n self._occgrid0 = occgrid # original occgrid for reference\n\n if inflate > 0:\n self._occgrid = occgrid.copy()\n self._occgrid.inflate(inflate)\n else:\n self._occgrid = occgrid\n\n def __str__(self):\n \"\"\"\n Compact representation of the planner\n\n :return: pretty printed representation\n :rtype: str\n \"\"\"\n s = f\"{self.__class__.__name__}: \"\n if self._occgrid0 is not None:\n s += str(self.occgrid)\n if self._start is not None:\n s += f\"\\n Start: {self.start}\"\n if self._goal is not None:\n s += f\"\\n Goal: {self.goal}\"\n return s\n\n def __repr__(self):\n return str(self)\n\n @property\n def occgrid(self):\n \"\"\"\n Occupancy grid\n\n :return: occupancy grid used for planning\n :rtype: :class:`OccGrid` instance or None\n\n Returns the grid that was optionally inflated at constructor time.\n\n :seealso: :class:`OccGrid`\n \"\"\"\n return self._occgrid\n\n @property\n def start(self):\n r\"\"\"\n Start point or configuration used for planning\n\n :return: start point :math:`(x, y)` or configuration :math:`(x, y, \\theta)`\n :rtype: ndarray(2) or ndarray(3)\n \"\"\"\n return self._start\n\n @start.setter\n def start(self, start):\n r\"\"\"\n Set start point or configuration for planning\n\n :param start: Set start :math:`(x, y)` or configuration :math:`(x, y, \\theta)`\n :type start: array_like(2) or array_like(3)\n :raises ValueError: if start point is occupied\n \"\"\"\n if start is not None:\n if self.isoccupied(start):\n raise ValueError(\"Start location inside obstacle\")\n self._start = base.getvector(start)\n\n @property\n def goal(self):\n r\"\"\"\n Goal point or configuration used for planning\n\n :return: goal point :math:`(x, y)` or configuration :math:`(x, y, \\theta)`\n :rtype: ndarray(2) or ndarray(3)\n \"\"\"\n return self._goal\n\n @goal.setter\n def goal(self, goal):\n r\"\"\"\n Set goal point or configuration for planning\n\n :param goal: Set goal :math:`(x, y)` or configuration :math:`(x, y, \\theta)`\n :type goal: array_like(2) or array_like(3)\n :raises ValueError: if goal point is occupied\n \"\"\"\n if goal is not None:\n if self.isoccupied(goal):\n raise ValueError(\"Goal location inside obstacle\")\n self._goal = base.getvector(goal)\n\n def isoccupied(self, p):\n \"\"\"\n Test if point is occupied\n\n :param p: world coordinate (x, y)\n :type p: array_like(2)\n :return: occupancy status of corresponding grid cell\n :rtype: bool\n\n The world coordinate is transformed and the status of the occupancy\n grid cell is returned. If the point lies outside the bounds of\n the occupancy grid return True (obstacle)\n\n If there is no occupancy grid this function always returns False (free).\n\n :seealso: :meth:`OccGrid.isoccupied`\n \"\"\"\n if self.occgrid is None:\n return False\n else:\n return self.occgrid.isoccupied(p)\n\n @property\n def verbose(self):\n \"\"\"\n Get verbosity\n\n :return: verbosity\n :rtype: bool\n\n If ``verbosity`` print more diagnostic messages to the planner's\n message channel.\n \"\"\"\n return self._verbose\n\n @verbose.setter\n def verbose(self, v):\n \"\"\"\n Set verbosity\n\n :param v: verbosity\n :type v: bool\n\n If ``verbosity`` print more diagnostic messages to the planner's\n message channel.\n \"\"\"\n self._verbose = v\n\n @property\n def random(self):\n \"\"\"\n Private random number generator\n\n :return: random number generator\n :rtype: NumPy Generator\n\n For example::\n\n planner.random(size, dtype)\n planner.integers(low, high, size, dtype)\n planner.uniform(0, 5)\n \n :seealso: `Random Generator `_\n \"\"\"\n return self._private_random\n\n def randinit(self):\n if self._seed is not None:\n self._private_random = np.random.default_rng(seed=self._seed)\n\n # Define abstract classes to be implemented later\n def plan(self):\n r\"\"\"\n Plan path (abstract superclass)\n\n :param start: start position :math:`(x, y)` or configuration :math:`(x, y, \\theta)`, defaults to None\n :type start: array_like(2) or array_like(3), optional\n :param goal: goal position :math:`(x, y)` or configuration :math:`(x, y, \\theta)`, defaults to None\n :type goal: array_like(2) or array_like(3), optional\n\n The implementation depends on the particular planner. Some may have\n no planning phase. The plan may also depend on just the start or goal.\n \"\"\"\n pass\n\n def validate_endpoint(self, p, dtype=None):\n if p is not None:\n p = base.getvector(p, self._ndims, dtype=dtype)\n if self.isoccupied(p):\n raise ValueError(\"Point is inside obstacle\")\n return p\n\n def progress_start(self, n):\n self._bar = FillingCirclesBar(self.__class__.__name__, max=n, \n suffix = '%(percent).1f%% - %(eta)ds')\n\n def progress_next(self):\n self._bar.next()\n\n def progress_end(self):\n self._bar.finish()\n\n def query(self, start=None, goal=None, dtype=None, next=True, animate=False, movie=None):\n \"\"\"\n Find a path from start to goal using plan (superclass)\n\n :param start: start position :math:`(x, y)` or configuration :math:`(x, y, \\theta)`, defaults to None\n :type start: array_like(2) or array_like(3), optional\n :param goal: goal position :math:`(x, y)` or configuration :math:`(x, y, \\theta)`, defaults to None\n :type goal: array_like(2) or array_like(3), optional\n :param animate: show the vehicle path, defaults to False\n :type animate: bool, optional\n :return: path from start to goal, one point :math:`(x, y)` or configuration :math:`(x, y, \\theta)` per row\n :rtype: ndarray(N,2) or ndarray(N,3)\n\n Find a path from ``start`` to ``goal`` using a previously computed plan.\n \n The method performs the following steps:\n - Initialize navigation, invoke method N.navigate_init()\n - Visualize the environment, invoke method N.plot()\n - Iterate on the ``next()`` method of the subclass until the ``goal`` is\n achieved.\n \"\"\"\n # make sure start and goal are set and valid\n self.start = self.validate_endpoint(start, dtype=dtype)\n self.goal = self.validate_endpoint(goal, dtype=dtype)\n\n # if movie is not None:\n # animate = True\n\n if next:\n if animate:\n self.plot()\n\n # movie = MovieWriter(movie)\n\n robot = self._start\n path = [robot]\n\n while True:\n if animate:\n plt.plot(robot[0], robot[1], 'y.', 12)\n plt.pause(0.05)\n\n # get next point on the path\n robot = self.next(robot)\n\n # are we are done?\n if robot is None:\n path.append(self._goal)\n return np.array(path).astype(int)\n\n path.append(robot)\n\n def plot(self, path=None,\n style='striped', stripe=(('black', 4), ('yellow', 3)),\n stripe_r=(('black', 4), ('red', 3)),\n line=None, line_r=None,\n configspace=False, unwrap=True,\n direction=None, background=True,\n path_marker=None, path_marker_reverse=None,\n start_marker=None, goal_marker=None,\n start_vehicle=None, goal_vehicle=None,\n start=None, goal=None,\n ax=None, block=False, **kwargs):\n r\"\"\"\n Plot vehicle path\n\n :param path: path, defaults to None\n :type path: ndarray(N, 2) or ndarray(N, 3)\n :param style: line style: 'striped' [default] or 'line'\n :type style: str\n :param stripe: striped line style for forward motion\n :type stripe: tuple of (color, linewidth)\n :param stripe_r: striped line style for reverse motion\n :type stripe: tuple of (color, linewidth)\n :param line: plain line style for forward motion\n :type line: dict of arguments for ``plot``\n :param line_r: plain line style for forward motion\n :type line_r: dict of arguments for ``plot``\n :param direction: travel direction associated with each point on path, is either >0 or <0, defaults to None\n :type direction: ndarray(N,), optional\n :param configspace: plot the path in 3D configuration space, input must be 3xN. \n Start and goal style will be given by ``qstart_marker`` and ``qgoal_marker``, defaults to False\n :type configspace: bool, optional\n :param unwrap: for configuration space plot unwrap :math:`\\theta` so\n there are no discontinuities at :math:`\\pm \\pi`, defaults to True\n :type unwrap: bool, optional\n :param background: plot occupancy grid if present, default True\n :type background: bool, optional\n :param start_marker: style for marking start point\n :type start_marker: dict, optional\n :param goal_marker: style for marking goal point\n :type goal_marker: dict, optional\n :param start_vehicle: style for vehicle animation object at start configuration\n :type start_vehicle: dict\n :param goal_vehicle: style for vehicle animation object at goal configuration\n :type goal_vehicle: dict\n :param start: start position :math:`(x, y)` or configuration :math:`(x, y, \\theta)`, defaults to value used for ``plan/query``\n :type start: array_like(2) or array_like(3), optional\n :param goal: goal position :math:`(x, y)` or configuration :math:`(x, y, \\theta)`, defaults to value used for ``plan/query``\n :type goal: array_like(2) or array_like(3), optional\n :param ax: axes to plot into\n :type ax: matplotlib axes\n :param block: block after displaying the plot\n :type block: bool, optional\n\n The path has one column per point and either 2 or 3 rows:\n \n - 2 rows describes motion in the :math:`x-y` plane and a 2D plot is created\n - 3 rows describes motion in the :math:`x-y-\\theta` configuration space. By\n default only the :math:`x-y` plane is plotted unless ``configspace``\n is True in which case motion in :math:`x-y-\\theta` configuration space\n is shown.\n\n If the planner supports bi-directional motion then the ``direction``\n option gives the direction for each point on the path.\n\n The default line style is a ``'striped'`` line which comprises a wide first\n line with a slightly narrow dashed line plotted on top. For example::\n\n (('black', 4), ('yellow', 3))\n\n is a blackline of width 4 with a dashed yellow line of width 3 plotted\n on top, giving a line of alternating black and yellow dashes.\n\n The parameters ``stripe`` and ``stripe_r`` specify the colors and widths for\n forward and reverse motion respectively.\n\n The ``'line'`` style is a regular Matplotlib and the parameters \n ``line`` and ``line_r`` specify the line and marker styles for\n forward and reverse motion respectively.\n\n For 2D plots with an :math:`x-y` path or 3D plots, the start and goal markers are specified\n by the dicts ``start_marker`` and ``goal_marker`` respectively.\n\n For 2D plots with an :math:`x-y-\\theta` path the vehicle pose\n is indicated by a vehicle animation object passed to the constructor.\n\n Markers are specified as dicts using Matplotlib keywords, for example::\n\n planner.plot(path, path_marker=dict(marker='s', color='b'))\n\n Default values are provided for all markers:\n\n - the start point is a circle\n - the goal point is a star\n - the start vehicle style is a ``VehiclePolygon(shape='car')`` as\n an unfilled outline\n - the goal vehicle style is a ``VehiclePolygon(shape='car')`` as\n a transparent filled shape\n \n If ``configspace`` is True then direction-indicating markers are used to\n display start and goal configuration. These are also given as dicts but\n have two items: ``'shape'`` which is the shape of the polygonal marker\n and is either ``'triangle'`` or ``'car'``. The second item ``'args'`` is\n passed to :func:`base.plot_poly` and Matplotlib.\n\n If ``background`` is True then the background of the plot is either or\n both of:\n \n - the occupancy grid\n - the distance field of the planner\n\n Additional arguments are passed through to :meth:`plot_bg`\n\n :seealso: :meth:`plot_bg` :func:`base.plot_poly`\n \"\"\"\n # create default markers\n \n # passed to Matplotlib plot()\n if start_marker is None:\n start_marker = {'marker': 'o',\n 'markeredgecolor': 'w',\n 'markerfacecolor': 'y', \n 'markersize': 10,\n 'zorder': 10,\n }\n if goal_marker is None:\n goal_marker = { 'marker': '*',\n 'markeredgecolor': 'w',\n 'markerfacecolor': 'y',\n 'markersize': 16,\n 'zorder': 10,\n }\n\n # passed to VehiclePolygon\n if start_vehicle is None:\n start_vehicle = {'facecolor': 'none', 'edgecolor': 'k', 'linewidth': 2}\n\n if goal_vehicle is None:\n goal_vehicle = {'alpha': 0.5}\n\n ndims = self._ndims\n\n if ndims == 3 and not configspace:\n ndims = 2\n if path is not None:\n path = path[:, :2]\n \n\n if configspace and ndims < 3 and path is not None:\n raise ValueError(f\"path should have {ndims} rows\")\n \n ax = base.axes_logic(ax, ndims)\n\n # plot occupancy grid background\n if background:\n self.plot_bg(ax=ax, **kwargs)\n \n # mark the path\n if path is not None:\n if ndims == 2:\n # 2D case\n if direction is not None:\n direction = np.array(direction)\n if direction.shape[0] != path.shape[0]:\n raise ValueError('direction vector must have same length as path')\n\n while len(direction) > 0:\n dir = direction[0]\n change = np.argwhere(dir != direction)\n if len(change) == 0:\n k = -1\n else:\n k = change[0, 0]\n \n if style == 'striped':\n if dir > 0:\n xstripe = stripe\n else:\n xstripe = stripe_r\n ax.plot(path[:k, 0], path[:k, 1], color=xstripe[0][0], linewidth=xstripe[0][1])\n ax.plot(path[:k, 0], path[:k, 1], color=xstripe[1][0], linewidth=xstripe[1][1], dashes=(5,5))\n elif style == 'line':\n if dir > 0:\n ax.plot(path[:, 0], path[:, 1], **line)\n else:\n ax.plot(path[:, 0], path[:, 1], **line_r)\n\n if len(change) == 0:\n break\n direction = direction[k-1:]\n direction[0] = direction[1]\n path = path[k-1:, :]\n\n else:\n if style == 'striped':\n ax.plot(path[:, 0], path[:, 1], color=stripe[0][0], linewidth=stripe[0][1], zorder=9)\n ax.plot(path[:, 0], path[:, 1], color=stripe[1][0], linewidth=stripe[1][1], dashes=(5,5), zorder=9)\n elif style == 'line':\n ax.plot(path[:, 0], path[:, 1], **kwargs)\n elif ndims == 3:\n # 3D case\n if direction is not None:\n direction = np.array(direction)\n if direction.shape[0] != path.shape[0]:\n raise ValueError('direction vector must have same length as path')\n theta = path[:, 2]\n if unwrap:\n theta = np.unwrap(theta)\n\n while len(direction) > 0:\n dir = direction[0]\n change = np.argwhere(dir != direction)\n if len(change) == 0:\n k = -1\n else:\n k = change[0, 0]\n \n\n if style == 'striped':\n if dir > 0:\n xstripe = stripe\n else:\n xstripe = stripe_r\n ax.plot(path[:k, 0], path[:k, 1], theta[:k], color=xstripe[0][0], linewidth=xstripe[0][1])\n ax.plot(path[:k, 0], path[:k, 1], theta[:k], color=xstripe[1][0], linewidth=xstripe[1][1], dashes=(5,5))\n elif style == 'line':\n if dir > 0:\n ax.plot(path[:, 0], path[:, 1], **line)\n else:\n ax.plot(path[:, 0], path[:, 1], **line_r)\n\n if len(change) == 0:\n break\n direction = direction[k-1:]\n direction[0] = direction[1]\n path = path[k-1:, :]\n theta = theta[k-1:]\n \n else:\n theta = path[:, 2]\n if unwrap:\n theta = np.unwrap(theta)\n if style == 'striped':\n ax.plot(path[:, 0], path[:, 1], theta, color=stripe[0][0], linewidth=stripe[0][1])\n ax.plot(path[:, 0], path[:, 1], theta, color=stripe[1][0], linewidth=stripe[1][1], dashes=(5,5))\n elif style == 'line':\n ax.plot(path[:, 0], path[:, 1], **line)\n\n # mark start and goal if requested\n if start is not None:\n start = self.validate_endpoint(start)\n else:\n start = self.start\n if goal is not None:\n self.goal = self.validate_endpoint(goal)\n else:\n goal = self.goal\n\n if ndims == 2 and self._ndims == 2:\n # proper 2d plot\n if start is not None:\n ax.plot(start[0], start[1], **start_marker)\n if goal is not None:\n ax.plot(goal[0], goal[1], **goal_marker)\n \n elif ndims == 2 and self._ndims == 3:\n # 2d projection of 3d plot, show start/goal configuration\n scale = base.axes_get_scale(ax) / 10\n \n if self.marker is None:\n self.marker = VehiclePolygon(shape='car', scale=scale)\n\n if start is not None:\n self.marker.plot(start, **start_vehicle)\n if goal is not None:\n self.marker.plot(goal, **goal_vehicle)\n\n elif ndims == 3:\n # 3d plot\n\n if start is not None:\n ax.plot(start[0], start[1], start[2], **start_marker)\n if goal is not None:\n \n if path is not None and unwrap:\n theta = theta[-1]\n else:\n theta = goal[2]\n plt.plot(goal[0], goal[1], theta, **goal_marker)\n\n ax.set_xlabel('x')\n ax.set_ylabel('y')\n if ndims == 2:\n ax.set_aspect('equal')\n else:\n ax.set_zlabel(r'$\\theta$')\n\n plt.show(block=block)\n\n return ax\n\n def _qmarker(self, shape):\n h = 0.3\n t = 0.8 # start of head taper\n c = 0.5 # centre x coordinate\n w = 1 # width in x direction\n if shape == 'car':\n return np.array([\n [-c, h],\n [t - c, h],\n [w - c, 0],\n [t - c, -h],\n [-c, -h],\n ]).T\n elif shape == 'triangle':\n return np.array([\n [-c, h],\n [ w, 0],\n [-c, -h],\n [-c, h],\n ]).T\n\n def plot_bg(self, distance=None, cmap='gray',\n ax=None, inflated=True, **unused):\n \"\"\"\n Plot background\n\n :param distance: override distance field, defaults to None\n :type distance: ndarray(N,M), optional\n :param cmap: Specify a colormap for the distance field, defaults to 'gray'\n :type cmap: str or Colormap, optional\n\n Displays the background which is either the occupancy grid or a distance\n field. The distance field encodes the distance of a point from the goal, small\n distance is dark, a large distance is bright.\n\n If the planner has an occupancy grid then that will be displayed with:\n - free cells in white\n - occupied cells in red\n - inflated occupied cells in pink\n\n If distance is provided, or the planner has a distancemap attribute\n the the distance field will be used as the background and obstacle cells\n (actual or inflated) will be shown in red. A colorbar is added.\n \"\"\"\n if self._occgrid is None:\n return\n\n if isinstance(self._occgrid, BaseOccupancyGrid):\n ax = base.plotvol2(dim=self._occgrid.workspace, ax=ax)\n else:\n ax = base.axes_logic(ax, 2)\n\n # create color map for free space + obstacle:\n # free space, color index = 1, white, alpha=0 to allow background and grid lines to show\n # obstacle, color index = 2, red, alpha=1\n\n if self._inflate > 0 and inflated:\n # 0 background (white, transparent)\n # 1 inflated obstacle (pink)\n # 2 original obstacle (red)\n colors = [(1, 1, 1, 0), (1, 0.75, 0.8, 1), (1, 0, 0, 1)]\n image = self.occgrid.grid.astype(int) + self._occgrid0.grid.astype(int)\n else:\n # 0 background\n # 1 obstacle\n colors = [(1, 1, 1, 0), (1, 0, 0, 1)]\n image = self.occgrid.grid\n\n if distance is None and hasattr(self, 'distancemap'):\n distance = self.distancemap\n\n if distance is not None:\n # distance field with obstacles\n\n # find largest finite value\n\n v = distance.ravel()\n vmax = max(v[np.isfinite(v)])\n\n # create a copy of greyscale color map\n c_map = copy.copy(mpl.cm.get_cmap(cmap))\n # c_map.set_bad(color=(1,0,0,1)) # nan and inf are red\n\n # change all inf to large value, so they are not 'bad' ie. red\n distance[np.isinf(distance)] = 2 * vmax\n c_map.set_over(color=(0,0,1)) # ex-infs are now blue\n\n # display image\n norm = mpl.colors.Normalize(vmin=0, vmax=vmax, clip=False)\n ax.imshow(distance, origin='lower',\n interpolation=None,\n cmap=c_map,\n norm=norm,\n )\n ax.grid(True, alpha=0.1, color=(1,1,1))\n\n # add colorbar\n scalar_mappable_c_map = cm.ScalarMappable(cmap=c_map, norm=norm)\n plt.colorbar(scalar_mappable_c_map, label='Distance', shrink=0.7, aspect=20*0.7)\n\n # overlay obstacles\n c_map = mpl.colors.ListedColormap(colors)\n self.occgrid.plot(image, cmap=c_map, zorder=1)\n\n else:\n # occupancy grid only\n\n # overlay obstacles\n c_map = mpl.colors.ListedColormap(colors)\n self.occgrid.plot(image, cmap=c_map, zorder=1)\n \n ax.set_facecolor((1, 1, 1)) # create white background\n ax.set_xlabel('x (cells)')\n ax.set_ylabel('y (cells)')\n ax.grid(True, zorder=0)\n\n # lock axis limits to current value\n # ax.set_xlim(ax.get_xlim())\n # ax.set_ylim(ax.get_ylim())\n\n plt.draw()\n plt.show(block=False)\n\n\n def message(self, s, color=None):\n \"\"\"\n Print message to message channel\n\n :param s: message to print\n :type s: str\n :param color: color to print it, defaults to color specified at\n constructor time.\n :type color: str, optional\n\n \"\"\"\n if self.verbose:\n if color is None:\n color = self._msgcolor\n print(fg(color), \"Planner:: \" + s, attr(0))\n\n # @staticmethod\n # def show_distance(d):\n # d[np.isinf(d)] = None\n # ax = plt.gca()\n # c_map = plt.get_cmap(\"Greys\")\n # plt.clim(0, np.max(d[:]))\n # plt.figimage(d)\n # plt.xlabel('X')\n # plt.ylabel('Y')\n # plt.show()\n\nclass MovieWriter:\n\n def __init__(self, filename=None, interval=0.1, fig=None):\n \"\"\"\n Save animation as a movie file\n\n :param filename: name of movie file, or tuple containing filename and\n frame interval\n :type filename: str or tuple(str, float)\n :param interval: frame interval, defaults to 0.1\n :type interval: float, optional\n :param fig: figure to record for the movie\n :type fig: figure reference \n\n Example::\n\n movie = MovieWriter(filename)\n\n while ...\n movie.add()\n\n movie.done()\n\n To avoid extra user-logic, if ``MovieWriter`` is called with ``filename`` equal to None,\n then the writer will do nothing when the ``add`` and ``done`` methods are called.\n \"\"\"\n # Set up formatting for the movie files\n if filename is None:\n self.writer = None\n return\n\n if isinstance(filename, (tuple, list)):\n filename, interval = filename\n\n if os.path.exists(filename):\n print(\"overwriting movie\", filename)\n else:\n print(\"creating movie\", filename)\n self.writer = animation.FFMpegWriter(\n fps=round(1 / interval), extra_args=[\"-vcodec\", \"libx264\"]\n )\n if fig is None:\n fig = plt.gcf()\n self.writer.setup(fig, filename)\n self.filename = filename\n\n def add(self):\n \"\"\"\n Add frame to the movie\n \"\"\"\n if self.writer is not None:\n self.writer.grab_frame()\n\n def done(self):\n if self.writer is not None:\n self.writer.finish()\n self.writer = None\n", "meta": {"hexsha": "6fdacf1c399be934851893567210f462b64e77a7", "size": 30445, "ext": "py", "lang": "Python", "max_stars_repo_path": "roboticstoolbox/mobile/PlannerBase.py", "max_stars_repo_name": "tassos/robotics-toolbox-python", "max_stars_repo_head_hexsha": "51aa8bbb3663a7c815f9880d538d61e7c85bc470", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 749, "max_stars_repo_stars_event_min_datetime": "2015-04-28T03:02:30.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T06:55:12.000Z", "max_issues_repo_path": "roboticstoolbox/mobile/PlannerBase.py", "max_issues_repo_name": "tassos/robotics-toolbox-python", "max_issues_repo_head_hexsha": "51aa8bbb3663a7c815f9880d538d61e7c85bc470", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 226, "max_issues_repo_issues_event_min_datetime": "2015-04-16T22:22:55.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-24T16:42:28.000Z", "max_forks_repo_path": "roboticstoolbox/mobile/PlannerBase.py", "max_forks_repo_name": "tassos/robotics-toolbox-python", "max_forks_repo_head_hexsha": "51aa8bbb3663a7c815f9880d538d61e7c85bc470", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 251, "max_forks_repo_forks_event_min_datetime": "2015-04-30T23:52:35.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-27T13:32:16.000Z", "avg_line_length": 36.3739545998, "max_line_length": 134, "alphanum_fraction": 0.5435046806, "include": true, "reason": "from scipy", "num_tokens": 6978, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.523420348936324, "lm_q2_score": 0.3812195521959383, "lm_q1q2_score": 0.19953807103174723}} {"text": "\nimport numpy as np\nfrom scipy.interpolate import interp1d\n\nfrom .. import constants as c\nfrom . import scatmodels as sms\nfrom ..distlib.composition import cmindex as cmi\nfrom .. import distlib\n\n__all__ = ['ScatModel','DiffScat','SigmaExt','SigmaScat','KappaExt','KappaScat']\n\n#----------------------------------------------------------\n# evals( emin=1.0, emax=2.0, de=0.1 ) : np.array [keV]\n# angles( thmin=5.0, thmax=100.0, dth=5.0 ) : np.array [arcsec]\n#\n\ndef evals( emin=1.0, emax=2.0, de=0.1 ):\n \"\"\"\n FUNCTION evals( emin=1.0, emax=2.0, de=0.1 )\n RETURNS : np.array\n Distribution of energies [keV]\n \"\"\"\n return np.arange( emin, emax+de, de )\n\ndef angles( thmin=5.0, thmax=100.0, dth=5.0 ):\n \"\"\"\n FUNCTION angles( thmin=5.0, thmax=100.0, dth=5.0 )\n RETURNS : np.array\n Distribution of angles [arcsec]\n \"\"\"\n return np.arange( thmin, thmax+dth, dth )\n\n#-------------- Tie scattering mechanism to an index of refraction ------------------\n\nclass ScatModel(object):\n \"\"\"\n | **ATTRIBUTES**\n | smodel : scattering model object : RGscat(), Mie()\n | cmodel : cmindex object : CmDrude(), CmGraphite(), CmSilicate()\n | stype : string : 'RGscat', 'Mie'\n | cmtype : 'Drude', 'Silicate', 'Graphite'\n \"\"\"\n def __init__( self, smodel=sms.RGscat(), cmodel=cmi.CmDrude() ):\n self.smodel = smodel\n self.cmodel = cmodel\n self.stype = smodel.stype\n self.cmtype = cmodel.cmtype\n # cmtype choices : 'Drude' (requires rho term only)\n # 'Graphite' (Carbonaceous grains)\n # 'Silicate' (Astrosilicate)\n # --- Graphite and Silicate values come from Draine (2003)\n\n#-------------- Quickly make a common ScatModel object ---------------------------\n\ndef makeScatModel( model_name, material_name ):\n \"\"\"\n | **INPUTS**\n | model_name : string : 'RG' or 'Mie'\n | material_name : string : 'Drude', 'Silicate', 'Graphite', 'SmallGraphite'\n |\n | **RETURNS**\n | ScatModel object\n \"\"\"\n\n if model_name == 'RG':\n sm = sms.RGscat()\n elif model_name == 'Mie':\n sm = sms.Mie()\n else:\n print('Error: Model name not recognized')\n return\n\n if material_name == 'Drude':\n cm = cmi.CmDrude()\n elif material_name == 'Silicate':\n cm = cmi.CmSilicate()\n elif material_name == 'Graphite':\n cm = cmi.CmGraphite()\n elif material_name == 'SmallGraphite': # Small Graphite ~ 0.01 um\n cm = cmi.CmGraphite( size='small' )\n else:\n print('Error: CM name not recognized')\n return\n\n return ScatModel(sm, cm)\n\n\n#-------------- Various Types of Scattering Cross-sections -----------------------\n\nclass DiffScat(object):\n \"\"\"\n | A differential scattering cross-section [cm^2 ster^-1] integrated\n | over dust grain size distribution\n |\n | **ATTRIBUTES**\n | scatm : ScatModel\n | theta : np.array : arcsec\n | E : scalar or np.array : Note, must match number of theta values if size > 1\n | a : scalar : um\n | dsig : np.array : cm^2 ster^-1\n \"\"\"\n def __init__(self, scatm=ScatModel(), theta=angles(), E=1.0, a=1.0):\n self.scatm = scatm\n self.theta = theta\n self.E = E\n self.a = a\n\n cm = scatm.cmodel\n scat = scatm.smodel\n # Do not print citation here, because this function is called multiple times by other modules\n\n if cm.cmtype == 'Graphite':\n dsig_pe = scat.Diff(theta=theta, a=a, E=E, cm=cmi.CmGraphite(size=cm.size, orient='perp'))\n dsig_pa = scat.Diff(theta=theta, a=a, E=E, cm=cmi.CmGraphite(size=cm.size, orient='para'))\n self.dsig = (dsig_pa + 2.0 * dsig_pe) / 3.0\n else:\n self.dsig = scat.Diff(theta=theta, a=a, E=E, cm=cm)\n\nclass SigmaScat(object):\n \"\"\"\n | Total scattering cross-section [cm^2] integrated over a dust grain\n | size distribution\n |\n | **ATTRIBUTES**\n | scatm : ScatModel\n | E : scalar or np.array : keV\n | a : scalar : um\n | qsca : scalar or np.array : unitless scattering efficiency\n | sigma : scalar or np.array : cm^2\n \"\"\"\n def __init__(self, scatm=ScatModel(), E=1.0, a=1.0):\n self.scatm = scatm\n self.E = E\n self.a = a\n\n cm = scatm.cmodel\n scat = scatm.smodel\n print(cm.citation)\n\n cgeo = np.pi * np.power(a*c.micron2cm, 2)\n\n if cm.cmtype == 'Graphite':\n qsca_pe = scat.Qsca(a=a, E=E, cm=cmi.CmGraphite(size=cm.size, orient='perp'))\n qsca_pa = scat.Qsca(a=a, E=E, cm=cmi.CmGraphite(size=cm.size, orient='para'))\n self.qsca = (qsca_pa + 2.0*qsca_pe) / 3.0\n else:\n self.qsca = scat.Qsca(a=a, E=E, cm=cm)\n\n self.sigma = self.qsca * cgeo\n\nclass SigmaExt(object):\n \"\"\"\n | Total EXTINCTION cross-section [cm^2] integrated over a dust grain\n | size distribution\n |\n | **ATTRIBUTES**\n | scatm : ScatModel\n | E : scalar or np.array : keV\n | a : scalar : um\n | qext : scalar or np.array : unitless extinction efficiency\n | sigma : scalar or np.array : cm^2\n \"\"\"\n def __init__(self, scatm=ScatModel(), E=1.0, a=1.0):\n self.scatm = scatm\n self.E = E\n self.a = a\n\n if scatm.stype == 'RGscat':\n print('Rayleigh-Gans cross-section not currently supported for KappaExt')\n self.qext = None\n self.sigma = None\n return\n\n cm = scatm.cmodel\n scat = scatm.smodel\n print(cm.citation)\n\n cgeo = np.pi * np.power(a*c.micron2cm, 2)\n if cm.cmtype == 'Graphite':\n qext_pe = scat.Qext(a=a, E=E, cm=cmi.CmGraphite(size=cm.size, orient='perp'))\n qext_pa = scat.Qext(a=a, E=E, cm=cmi.CmGraphite(size=cm.size, orient='para'))\n self.qext = (qext_pa + 2.0*qext_pe) / 3.0\n else:\n self.qext = scat.Qext(a=a, E=E, cm=cm)\n self.sigma = self.qext * cgeo\n\nclass KappaScat(object):\n \"\"\"\n | Opacity to scattering [g^-1 cm^2] integrated over dust grain size distribution.\n |\n | **ATTRIBUTES**\n | scatm : ScatModel\n | E : scalar or np.array : keV\n | dist : distlib.DustSpectrum\n | kappa : scalar or np.array : cm^2 g^-1, typically\n \"\"\"\n def __init__(self, E=1.0, scatm=ScatModel(), dist=distlib.MRN_dist()):\n self.scatm = scatm\n self.E = E\n self.dist = dist\n\n cm = scatm.cmodel\n scat = scatm.smodel\n print(cm.citation)\n\n cgeo = np.pi * np.power(dist.a * c.micron2cm, 2)\n\n qsca = np.zeros(shape=(np.size(E),np.size(dist.a)))\n qsca_pe = np.zeros(shape=(np.size(E),np.size(dist.a)))\n qsca_pa = np.zeros(shape=(np.size(E),np.size(dist.a)))\n\n # Test for graphite case\n if cm.cmtype == 'Graphite':\n cmGraphitePerp = cmi.CmGraphite(size=cm.size, orient='perp')\n cmGraphitePara = cmi.CmGraphite(size=cm.size, orient='para')\n\n if np.size(dist.a) > 1:\n for i in range(np.size(dist.a)):\n qsca_pe[:,i] = scat.Qsca(E, a=dist.a[i], cm=cmGraphitePerp)\n qsca_pa[:,i] = scat.Qsca(E, a=dist.a[i], cm=cmGraphitePara)\n else:\n qsca_pe = scat.Qsca(E, a=dist.a, cm=cmGraphitePerp)\n qsca_pa = scat.Qsca(E, a=dist.a, cm=cmGraphitePara)\n\n qsca = (qsca_pa + 2.0 * qsca_pe) / 3.0\n\n else:\n if np.size(dist.a) > 1:\n for i in range(np.size(dist.a)):\n qsca[:,i] = scat.Qsca(E, a=dist.a[i], cm=cm)\n else:\n qsca = scat.Qsca(E, a=dist.a, cm=cm)\n\n if np.size(dist.a) == 1:\n kappa = dist.nd * qsca * cgeo / dist.md\n else:\n kappa = np.array([])\n for j in range(np.size(E)):\n kappa = np.append(kappa,\n c.intz(dist.a, dist.nd * qsca[j,:] * cgeo) / dist.md)\n\n self.kappa = kappa\n\n\nclass KappaExt(object):\n \"\"\"\n | Opacity to EXTINCTION [g^-1 cm^2] integrated over dust grain size\n | distribution\n |\n | **ATTRIBUTES**\n | scatm : ScatModel\n | E : scalar or np.array : keV\n | dist : distlib.DustSpectrum\n | kappa : scalar or np.array : cm^2 g^-1, typically\n \"\"\"\n def __init__(self, E=1.0, scatm=ScatModel(), dist=distlib.MRN_dist()):\n self.scatm = scatm\n self.E = E\n self.dist = dist\n\n if scatm.stype == 'RGscat':\n print 'Rayleigh-Gans cross-section not currently supported for KappaExt'\n self.kappa = None\n return\n\n cm = scatm.cmodel\n scat = scatm.smodel\n print(cm.citation)\n\n cgeo = np.pi * np.power(dist.a * c.micron2cm, 2)\n\n qext = np.zeros(shape=(np.size(E),np.size(dist.a)))\n qext_pe = np.zeros(shape=(np.size(E),np.size(dist.a)))\n qext_pa = np.zeros(shape=(np.size(E),np.size(dist.a)))\n\n # Test for graphite case\n if cm.cmtype == 'Graphite':\n cmGraphitePerp = cmi.CmGraphite(size=cm.size, orient='perp')\n cmGraphitePara = cmi.CmGraphite(size=cm.size, orient='para')\n\n if np.size(dist.a) > 1:\n for i in range(np.size(dist.a)):\n qext_pe[:,i] = scat.Qext(E, a=dist.a[i], cm=cmGraphitePerp)\n qext_pa[:,i] = scat.Qext(E, a=dist.a[i], cm=cmGraphitePara)\n else:\n qext_pe = scat.Qext(E, a=dist.a, cm=cmGraphitePerp)\n qext_pa = scat.Qext(E, a=dist.a, cm=cmGraphitePara)\n\n qext = (qext_pa + 2.0 * qext_pe) / 3.0\n\n else:\n if np.size(dist.a) > 1:\n for i in range(np.size(dist.a)):\n qext[:,i] = scat.Qext(E, a=dist.a[i], cm=cm)\n else:\n qext = scat.Qext(E, a=dist.a, cm=cm)\n\n if np.size(dist.a) == 1:\n kappa = dist.nd * qext * cgeo / dist.md\n else:\n kappa = np.array([])\n for j in range(np.size(E)):\n kappa = np.append(kappa,\n c.intz(dist.a, dist.nd * qext[j,:] * cgeo) / dist.md)\n\n self.kappa = kappa\n", "meta": {"hexsha": "cc030d530ed48030c421c124c2af03f8f4c8c1b7", "size": 10277, "ext": "py", "lang": "Python", "max_stars_repo_path": "astrodust/extinction/sigma_scat.py", "max_stars_repo_name": "eblur/dust", "max_stars_repo_head_hexsha": "babbee0d5b6625f431eaff11ef33e8a839c7d7ff", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2016-03-25T03:35:06.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-12T10:29:13.000Z", "max_issues_repo_path": "astrodust/extinction/sigma_scat.py", "max_issues_repo_name": "eblur/dust", "max_issues_repo_head_hexsha": "babbee0d5b6625f431eaff11ef33e8a839c7d7ff", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 22, "max_issues_repo_issues_event_min_datetime": "2016-03-21T15:57:18.000Z", "max_issues_repo_issues_event_max_datetime": "2016-06-03T04:28:07.000Z", "max_forks_repo_path": "astrodust/extinction/sigma_scat.py", "max_forks_repo_name": "eblur/dust", "max_forks_repo_head_hexsha": "babbee0d5b6625f431eaff11ef33e8a839c7d7ff", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2015-07-01T19:31:18.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-27T02:18:50.000Z", "avg_line_length": 33.4755700326, "max_line_length": 102, "alphanum_fraction": 0.5352729396, "include": true, "reason": "import numpy,from scipy", "num_tokens": 3139, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.709019146082187, "lm_q2_score": 0.2814055953761019, "lm_q1q2_score": 0.19952195493631317}} {"text": "# -*- coding: utf-8 -*-\n\"\"\"\nStationSim\nCreated on Tue Nov 20 15:25:27 2018\n@author: medkmin\n\"\"\"\n\n# sspmm.py\n'''\nStationSim (aka Mike's model) converted into python.\n'''\n# Note cm (classmethods): Class Methods seem to have caused an issue.. Is so we can take these methods outside the class (excluding __init__). This will reduce reproducing methods in the PF.\n\n\n#%% INIT\nimport numpy as np\nfrom scipy.spatial import cKDTree\nimport matplotlib.pyplot as plt\nsqrt2 = np.sqrt(2) # required for Agent.lerp()\n\ndef two_element_norm(arr):\n \"\"\"\n A helpful function to calculate the norm for an array of two elements.\n This simply takes the square root of the sum of the square of the elements.\n This appears to be faster than np.linalg.norm.\n No doubt the numpy implementation would be faster for large arrays.\n Fortunately, all of our norms are of two-element arrays.\n\n :param arr: A numpy array (or array-like DS) with length two.\n :return norm: The norm of the array.\n \"\"\"\n return np.sqrt(arr[0] * arr[0] + arr[1] * arr[1])\n\n#%% MODEL\nclass Agent:\n \"\"\"\n A class representing a generic agent for the StationSim ABM.\n \"\"\"\n def __init__(self, model, unique_id):\n \"\"\"\n Initialise a new agent.\n\n Creates a new agent and gives it a randomly chosen entrance, exit, and\n desired speed. All agents start with active state 0 ('not started').\n Their initial location (** HOW IS LOCATION REPRESENTED?? Answer: With (x,y) tuple-floats **) is set\n to the location of the entrance that they are assigned to.\n\n :param model: a pointer to the station sim model that is creating this agent\n \"\"\"\n # Required\n self.unique_id = unique_id\n self.active = 0 # 0 Not Started, 1 Active, 2 Finished\n model.pop_active += 1\n\n # Choose at random at which of the entrances the agent starts\n self.location = model.loc_entrances[np.random.randint(model.entrances)]\n self.location[1] += model.entrance_space * (np.random.uniform() - .5)\n self.loc_desire = model.loc_exits[np.random.randint(model.exits)]\n\n # Parameters\n # model.entrance_speed -> the rate at which agents enter\n # self.time_activate -> the time at which the agent should become active\n # time_activate is exponentially distributed based on entrance_speed\n self.time_activate = np.random.exponential(model.entrance_speed)\n # The maximum speed that this agent can travel at:\n # self.speed_desire = max(np.random.normal(model.speed_desire_mean, model.speed_desire_std), 2*model.speed_min) # this is not a truncated normal distribution\n self.speed_desire = model.speed_min - 1\n while self.speed_desire <= model.speed_min:\n self.speed_desire = np.random.normal(model.speed_desire_mean, model.speed_desire_std)\n self.wiggle = min(self.speed_desire, model.wiggle) # if they can wiggle faster than they can move they may beat the expected time\n # A few speeds to check; used if a step at the max speed would cause a collision\n self.speeds = np.arange(self.speed_desire, model.speed_min, -model.speed_step)\n if model.do_save:\n self.history_loc = []\n self.time_expected = None\n self.time_start = None\n\n def step(self, model):\n \"\"\"\n Iterate the agent. If they are inactive then it checks to see if they\n should become active. If they are active then then move (see\n self.move()) and, possibly, leave the model (see exit_query())).\n \"\"\"\n if self.active == 0:\n self.activate(model)\n elif self.active == 1:\n self.move(model)\n self.exit_query(model)\n self.save(model)\n\n def activate(self, model):\n \"\"\"\n Test whether an agent should become active. This happens when the model\n time is greater than the agent's activate time.\n \"\"\"\n if not self.active and model.time_id > self.time_activate:\n self.active = 1\n self.time_start = model.time_id\n self.time_expected = (np.linalg.norm(self.location - self.loc_desire) - model.exit_space) / self.speed_desire\n\n @staticmethod\n def is_within_bounds(boundaries, new_location):\n \"\"\"\n Check if new location is within the bounds of the model.\n :param boundaries The boundaries of the model\n :param new_location The proposed location for the agent\n :return Is new location within boundaries, boolean\n \"\"\"\n within0 = all(boundaries[0] <= new_location)\n within1 = all(boundaries[1] <= new_location)\n return within0 and within1\n\n def move(self, model):\n \"\"\"\n Move the agent towards their destination. If the way is clear then the\n agent moves the maximum distance they can given their maximum possible\n speed (self.speed_desire). If not, then they iteratively test smaller\n and smaller distances until they find one that they can travel to\n without causing a collision with another agent.\n \"\"\"\n for speed in self.speeds:\n # Direct\n new_location = Agent.lerp(self.loc_desire, self.location, speed)\n if not Agent.collision(model, new_location):\n break\n elif speed == self.speeds[-1]:\n # Wiggle\n # Why 1+1? Answer: randint(1)=0, randint(2)=0 or 1 - i think it is the standard pythonic idea of up to that number like array[0:2] is elements (array[0],array[1])\n # randint is upper-bound exclusive, so 2 instead of 1\n new_location = self.location + self.wiggle*np.random.randint(-1, 1+1, 2)\n # Rebound\n if not self.is_within_bounds(model.boundaries, new_location):\n new_location = np.clip(new_location, model.boundaries[0], model.boundaries[1])\n # Move\n self.location = new_location\n\n @classmethod\n def collision(cls, model, new_location):\n \"\"\"\n Detects whether a move to the new_location will cause a collision\n (either with the model boundary or another agent).\n \"\"\"\n within_bounds = all(model.boundaries[0] <= new_location) and all(new_location <= model.boundaries[1])\n if not within_bounds:\n collide = True\n elif Agent.neighbourhood(model, new_location):\n collide = True\n else:\n collide = False\n return collide\n\n @classmethod\n def neighbourhood(cls, model, new_location):\n \"\"\"\n XXXX WHAT DOES THIS DO?? Answer: This method finds whether or not nearby neighbours are a collision.\n\n :param model: the model that this agent is part of\n :param new_location: the proposed new location that the agent will move to\n (a XXXX - what kind of object/data is the location? Answer: the standard (x,y) floats-tuple)\n :param do_kd_tree whether to use a spatial index (kd_tree) (default true)\n \"\"\"\n neighbours = False\n neighbouring_agents = model.tree.query_ball_point(new_location, model.separation)\n for neighbouring_agent in neighbouring_agents:\n agent = model.agents[neighbouring_agent]\n if agent.active == 1 and new_location[0] <= agent.location[0]:\n neighbours = True\n break\n return neighbours\n\n @classmethod\n def lerp(cls, loc1, loc2, speed):\n \"\"\"\n lerp - linear extrapolation\n Find the new position of after moving 'speed' distance from loc2 towards loc1.\n :param loc1: desired location\n :param loc2: current location\n :param speed: distance that can be covered in an iteration\n :return: The new location\n lerp is a intensively used method hence profiling and adjustments have been made, see 'github dust/Projects/awest/code/experiments/lerp.py' for more understanding.\n \"\"\"\n #distance = np.linalg.norm(loc1 - loc2) # frobenius norm: profiled at 8.05μs\n #distance = np.sqrt(sum((loc1 - loc2)**2)) # euclidean norm: profiled at 7.82μs\n #distance = sum(abs(loc1 - loc2)) # manhattan norm: profiled at 6.19μs\n reciprocal_distance = sqrt2 / sum(abs(loc1 - loc2)) # lerp5: profiled at 6.41μs\n loc = loc2 + speed * (loc1 - loc2) * reciprocal_distance\n return loc\n\n def exit_query(self, model):\n \"\"\"\n Determine whether the agent should leave the model and, if so,\n remove them. Otherwise do nothing.\n \"\"\"\n if sum(abs(self.location - self.loc_desire)) / sqrt2 < model.exit_space:\n# if two_element_norm(self.location - self.loc_desire) < model.exit_space:\n self.active = 2\n model.pop_active -= 1\n model.pop_finished += 1\n if model.do_save:\n time_delta = model.time_id - self.time_start\n model.time_taken.append(time_delta)\n time_delta -= self.time_expected\n model.time_delay.append(time_delta)\n\n def save(self, model):\n \"\"\"\n Save agent location.\n \"\"\"\n if model.do_save:\n self.history_loc.append(self.location)\n\n\nclass Model:\n \"\"\"\n A class to represent the StationSim model.\n \"\"\"\n def __init__(self, params):\n \"\"\"\n Create a new model, reading parameters from a dictionary.\n XXXX Need to document the required parameters.\n \"\"\"\n self.params = params\n # There are a lot of required attributes here that we hope are in params\n # Perhaps we should have a way to ensure we get what we require?\n # Also, consider using **kwargs\n [setattr(self, key, value) for key, value in params.items()]\n # Average number of speeds to check\n self.speed_step = (self.speed_desire_mean - self.speed_min) / 3\n # Batch Details\n self.time_id = 0\n self.step_id = 0\n if self.do_save:\n self.time_taken = []\n self.time_delay = []\n # Model Parameters\n self.boundaries = np.array([[0, 0], [self.width, self.height]])\n self.pop_active = 0\n self.pop_finished = 0\n # Initialise\n self.initialise_gates()\n self.agents = [Agent(self, unique_id) for unique_id in range(self.pop_total)]\n\n def step(self):\n \"\"\"\n Iterate model forward one step.\n \"\"\"\n if self.pop_finished < self.pop_total and self.step:\n self.kdtree_build()\n [agent.step(self) for agent in self.agents]\n self.time_id += 1\n self.step_id += 1\n\n def initialise_gates(self):\n \"\"\"\n Initialise the locations of the entrances and exits.\n \"\"\"\n self.loc_entrances = self.initialise_gates_generic(self.entrances, 0)\n self.loc_exits = self.initialise_gates_generic(self.exits, self.width)\n\n def initialise_gates_generic(self, n_gates, x):\n \"\"\"\n General method for initialising gates.\n Note: This method relies on a lot of class attributes, many of which are\n not explicitly required in the init method - perhaps we should be\n careful of this? Answer: see note cm at top\n \"\"\"\n gates = np.zeros((n_gates, 2))\n gates[:, 0] = x\n if n_gates == 1:\n gates[0, 1] = self.height / 2\n else:\n gates[:, 1] = np.linspace(self.height / 4, 3 * self.height / 4,\n n_gates)\n return gates\n\n def kdtree_build(self):\n \"\"\"\n Build kdtree for the model.\n \"\"\"\n state = self.agents2state(do_ravel=False)\n self.tree = cKDTree(state)\n\n def agents2state(self, do_ravel=True):\n \"\"\"\n Convert list of agents in model to state vector.\n \"\"\"\n state = [agent.location for agent in self.agents]\n state = np.ravel(state) if do_ravel else np.array(state)\n return state\n\n def state2agents(self, state):\n \"\"\"\n Use state vector to set agent locations.\n \"\"\"\n for i in range(len(self.agents)):\n self.agents[i].location = state[2 * i:2 * i + 2]\n\n def batch(self):\n \"\"\"\n Run the model.\n \"\"\"\n print(\"Starting batch mode with following parameters:\")\n print('\\tParameter\\tValue')\n for k, v in self.params.items():\n print('\\t{0}:\\t{1}'.format(k, v))\n print('')\n for i in range(self.batch_iterations):\n self.step()\n if i % 100 == 0:\n print(\"\\tIterations: \", i)\n if self.do_ani:\n self.ani()\n if self.pop_finished == self.pop_total:\n print('Everyone made it!')\n break\n print(\"Finished at iteration\", i)\n if self.do_save:\n self.save_stats()\n if self.do_plot: self.save_plot()\n\n def ani(self, agents=None, colour='k', alpha=1, show_separation=True):\n # Design for use in PF\n wid = 8 # image size\n hei = wid * self.height / self.width\n if show_separation:\n # the magic formular for marksize scaling\n magic = 1.8 # dependant on the amount of figure space used\n markersizescale = magic*72*hei/self.height\n plt.figure(1, figsize=(wid, hei))\n plt.clf()\n plt.axis(np.ravel(self.boundaries, 'F'))\n plt.axes().set_aspect('equal')\n for agent in self.agents[:agents]:\n if agent.active == 1:\n if show_separation:\n plt.plot(*agent.location, marker='s', markersize=markersizescale*self.separation, color=colour, alpha=.05)\n plt.plot(*agent.location, marker='.', markersize=2, color=colour, alpha=alpha)\n plt.xlabel('Corridor Width')\n plt.ylabel('Corridor Height')\n plt.pause(1 / 30)\n return\n\n def save_ani(self):\n return\n\n def save_plot(self):\n \"\"\"\n Produce plots for model.\n \"\"\"\n self.plot_trails()\n self.plot_agent_times()\n\n def plot_trails(self):\n \"\"\"\n Produce a plot of the trails of each agent in the 2-d corridor.\n \"\"\"\n # Trails\n plt.figure()\n for agent in self.agents:\n if agent.active == 0:\n colour = 'r'\n elif agent.active == 1:\n colour = 'b'\n else:\n colour = 'm'\n locs = np.array(agent.history_loc).T\n plt.plot(locs[0], locs[1], color=colour, linewidth=.5)\n plt.axis(np.ravel(self.boundaries, 'F'))\n plt.xlabel('Corridor Width')\n plt.ylabel('Corridor Height')\n plt.legend(['Agent trails'])\n plt.show()\n\n def plot_agent_times(self):\n \"\"\"\n Produce a plot of the time taken by each agent, and the delay of each\n agent.\n \"\"\"\n # Time Taken, Delay Amount\n plt.figure()\n plt.hist(self.time_taken, alpha=.5, label='Time taken')\n plt.hist(self.time_delay, alpha=.5, label='Time delay')\n plt.xlabel('Time')\n plt.ylabel('Number of Agents')\n plt.legend()\n plt.show()\n\n def save_stats(self):\n \"\"\"\n Print model run stats to console.\n \"\"\"\n print()\n print('Stats:')\n print('Finish Time: ' + str(self.time_id))\n print('Active / Finished / Total agents: ' +\n str(self.pop_active) + '/' + str(self.pop_finished) +\n '/' + str(self.pop_total))\n print('Average time taken: {:.2f} steps'.format(np.mean(self.time_taken)))\n print('Average time delay: {:.2f} steps'.format(np.mean(self.time_delay)))\n\n def __repr__(self):\n \"\"\"Print this model's ID and its memory location\"\"\"\n return \"StationSim [{}]\".format(hex(id(self)))\n\n @classmethod\n def run_defaultmodel(cls):\n \"\"\"\n Run a model with some common parameters. Mostly used for testing.\n \"\"\"\n np.random.seed(42)\n model_params = {\n 'width': 200,\n 'height': 100,\n 'pop_total': 100,\n 'entrances': 3,\n 'entrance_space': 2,\n 'entrance_speed': 1,\n 'exits': 2,\n 'exit_space': 1,\n 'speed_min': .1,\n 'speed_desire_mean': 1,\n 'speed_desire_std': 1,\n 'separation': 4,\n 'wiggle': 1,\n 'batch_iterations': 10_000,\n 'do_save': True,\n 'do_plot': False,\n 'do_ani': True\n }\n # Run the model\n Model(model_params).batch()\n\n\n# If this is called from the command line then run a default model.\nif __name__ == '__main__':\n Model.run_defaultmodel()\n", "meta": {"hexsha": "302bfa20df7d78b1d10d3c35e0976763b2e5c5cc", "size": 16832, "ext": "py", "lang": "Python", "max_stars_repo_path": "Projects/ABM_DA/at_risk/StationSim_KM.py", "max_stars_repo_name": "RobertClay/DUST-RC", "max_stars_repo_head_hexsha": "09f7ec9d8d093021d068dff8a7a48c15ea318b86", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 15, "max_stars_repo_stars_event_min_datetime": "2018-11-21T14:57:24.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-04T15:42:09.000Z", "max_issues_repo_path": "Projects/ABM_DA/at_risk/StationSim_KM.py", "max_issues_repo_name": "RobertClay/DUST-RC", "max_issues_repo_head_hexsha": "09f7ec9d8d093021d068dff8a7a48c15ea318b86", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 125, "max_issues_repo_issues_event_min_datetime": "2019-11-06T13:03:35.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-07T13:38:33.000Z", "max_forks_repo_path": "Projects/ABM_DA/at_risk/StationSim_KM.py", "max_forks_repo_name": "RobertClay/DUST-RC", "max_forks_repo_head_hexsha": "09f7ec9d8d093021d068dff8a7a48c15ea318b86", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2018-11-20T15:56:49.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-08T10:21:06.000Z", "avg_line_length": 38.5171624714, "max_line_length": 191, "alphanum_fraction": 0.595769962, "include": true, "reason": "import numpy,from scipy", "num_tokens": 3866, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6150878555160665, "lm_q2_score": 0.3242354055108442, "lm_q1q2_score": 0.19943326025804736}} {"text": "# Copyright 2020 The PyMC Developers\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\nimport warnings\n\nfrom collections.abc import Mapping\nfrom functools import singledispatch\nfrom typing import Dict, Optional, Union\n\nimport aesara.tensor as at\nimport numpy as np\n\nfrom aeppl import factorized_joint_logprob\nfrom aeppl.transforms import TransformValuesOpt\nfrom aesara import config\nfrom aesara.graph.basic import graph_inputs, io_toposort\nfrom aesara.graph.op import Op, compute_test_value\nfrom aesara.tensor.random.op import RandomVariable\nfrom aesara.tensor.subtensor import (\n AdvancedIncSubtensor,\n AdvancedIncSubtensor1,\n AdvancedSubtensor,\n AdvancedSubtensor1,\n IncSubtensor,\n Subtensor,\n)\nfrom aesara.tensor.var import TensorVariable\n\nfrom pymc.aesaraf import extract_rv_and_value_vars, floatX, rvs_to_value_vars\n\n\n@singledispatch\ndef logp_transform(op: Op):\n return None\n\n\ndef _get_scaling(total_size, shape, ndim):\n \"\"\"\n Gets scaling constant for logp\n\n Parameters\n ----------\n total_size: int or list[int]\n shape: shape\n shape to scale\n ndim: int\n ndim hint\n\n Returns\n -------\n scalar\n \"\"\"\n if total_size is None:\n coef = floatX(1)\n elif isinstance(total_size, int):\n if ndim >= 1:\n denom = shape[0]\n else:\n denom = 1\n coef = floatX(total_size) / floatX(denom)\n elif isinstance(total_size, (list, tuple)):\n if not all(isinstance(i, int) for i in total_size if (i is not Ellipsis and i is not None)):\n raise TypeError(\n \"Unrecognized `total_size` type, expected \"\n \"int or list of ints, got %r\" % total_size\n )\n if Ellipsis in total_size:\n sep = total_size.index(Ellipsis)\n begin = total_size[:sep]\n end = total_size[sep + 1 :]\n if Ellipsis in end:\n raise ValueError(\n \"Double Ellipsis in `total_size` is restricted, got %r\" % total_size\n )\n else:\n begin = total_size\n end = []\n if (len(begin) + len(end)) > ndim:\n raise ValueError(\n \"Length of `total_size` is too big, \"\n \"number of scalings is bigger that ndim, got %r\" % total_size\n )\n elif (len(begin) + len(end)) == 0:\n return floatX(1)\n if len(end) > 0:\n shp_end = shape[-len(end) :]\n else:\n shp_end = np.asarray([])\n shp_begin = shape[: len(begin)]\n begin_coef = [floatX(t) / shp_begin[i] for i, t in enumerate(begin) if t is not None]\n end_coef = [floatX(t) / shp_end[i] for i, t in enumerate(end) if t is not None]\n coefs = begin_coef + end_coef\n coef = at.prod(coefs)\n else:\n raise TypeError(\n \"Unrecognized `total_size` type, expected int or list of ints, got %r\" % total_size\n )\n return at.as_tensor(floatX(coef))\n\n\nsubtensor_types = (\n AdvancedIncSubtensor,\n AdvancedIncSubtensor1,\n AdvancedSubtensor,\n AdvancedSubtensor1,\n IncSubtensor,\n Subtensor,\n)\n\n\ndef logpt(\n var: TensorVariable,\n rv_values: Optional[Union[TensorVariable, Dict[TensorVariable, TensorVariable]]] = None,\n *,\n jacobian: bool = True,\n scaling: bool = True,\n transformed: bool = True,\n sum: bool = True,\n **kwargs,\n) -> TensorVariable:\n \"\"\"Create a measure-space (i.e. log-likelihood) graph for a random variable\n or a list of random variables at a given point.\n\n The input `var` determines which log-likelihood graph is used and\n `rv_value` is that graph's input parameter. For example, if `var` is\n the output of a ``NormalRV`` ``Op``, then the output is a graph of the\n density function for `var` set to the value `rv_value`.\n\n Parameters\n ==========\n var\n The `RandomVariable` output that determines the log-likelihood graph.\n Can also be a list of variables. The final log-likelihood graph will\n be the sum total of all individual log-likelihood graphs of variables\n in the list.\n rv_values\n A variable, or ``dict`` of variables, that represents the value of\n `var` in its log-likelihood. If no `rv_value` is provided,\n ``var.tag.value_var`` will be checked and, when available, used.\n jacobian\n Whether or not to include the Jacobian term.\n scaling\n A scaling term to apply to the generated log-likelihood graph.\n transformed\n Apply transforms.\n sum\n Sum the log-likelihood.\n\n \"\"\"\n # TODO: In future when we drop support for tag.value_var most of the following\n # logic can be removed and logpt can just be a wrapper function that calls aeppl's\n # joint_logprob directly.\n\n # If var is not a list make it one.\n if not isinstance(var, list):\n var = [var]\n\n # If logpt isn't provided values and the variable (provided in var)\n # is an RV, it is assumed that the tagged value var or observation is\n # the value variable for that particular RV.\n if rv_values is None:\n rv_values = {}\n for _var in var:\n if isinstance(_var.owner.op, RandomVariable):\n rv_value_var = getattr(\n _var.tag, \"observations\", getattr(_var.tag, \"value_var\", _var)\n )\n rv_values = {_var: rv_value_var}\n elif not isinstance(rv_values, Mapping):\n # Else if we're given a single value and a single variable we assume a mapping among them.\n rv_values = (\n {var[0]: at.as_tensor_variable(rv_values).astype(var[0].type)} if len(var) == 1 else {}\n )\n\n # Since the filtering of logp graph is based on value variables\n # provided to this function\n if not rv_values:\n warnings.warn(\"No value variables provided the logp will be an empty graph\")\n\n if scaling:\n rv_scalings = {}\n for _var in var:\n rv_value_var = getattr(_var.tag, \"observations\", getattr(_var.tag, \"value_var\", _var))\n rv_scalings[rv_value_var] = _get_scaling(\n getattr(_var.tag, \"total_size\", None), rv_value_var.shape, rv_value_var.ndim\n )\n\n # Unlike aeppl, PyMC's logpt is expected to plug in the values variables to corresponding\n # RVs automatically unless the values are explicity set to None. Hence we iterate through\n # the graph to find RVs and construct a new RVs to values dictionary.\n tmp_rvs_to_values = rv_values.copy()\n transform_map = {}\n for node in io_toposort(graph_inputs(var), var):\n if isinstance(node.op, RandomVariable):\n curr_var = node.out\n rv_value_var = getattr(\n curr_var.tag, \"observations\", getattr(curr_var.tag, \"value_var\", curr_var)\n )\n rv_value = rv_values.get(curr_var, rv_value_var)\n tmp_rvs_to_values[curr_var] = rv_value\n # Along with value variables we also check for transforms if any.\n if hasattr(rv_value_var.tag, \"transform\") and transformed:\n transform_map[rv_value] = rv_value_var.tag.transform\n # The condition below is a hackish way of excluding the value variable for the\n # RV being indexed in case of Advanced Indexing of RVs. It gets added by the\n # logic above but aeppl does not expect us to include it in the dictionary of\n # {RV:values} given to it.\n if isinstance(node.op, subtensor_types):\n curr_var = node.out\n if (\n curr_var in tmp_rvs_to_values.keys()\n and curr_var.owner.inputs[0] in tmp_rvs_to_values.keys()\n ):\n tmp_rvs_to_values.pop(curr_var.owner.inputs[0])\n\n transform_opt = TransformValuesOpt(transform_map)\n temp_logp_var_dict = factorized_joint_logprob(\n tmp_rvs_to_values, extra_rewrites=transform_opt, use_jacobian=jacobian, **kwargs\n )\n\n # aeppl returns the logpt for every single value term we provided to it. This includes\n # the extra values we plugged in above so we need to filter those out.\n logp_var_dict = {}\n for value_var, _logp in temp_logp_var_dict.items():\n if value_var in rv_values.values():\n logp_var_dict[value_var] = _logp\n\n # If it's an empty dictionary the logp is None\n if not logp_var_dict:\n logp_var = None\n else:\n # Otherwise apply appropriate scalings and at.add and/or at.sum the\n # graphs accordingly.\n if scaling:\n for _value in logp_var_dict.keys():\n if _value in rv_scalings:\n logp_var_dict[_value] *= rv_scalings[_value]\n\n if len(logp_var_dict) == 1:\n logp_var_dict = tuple(logp_var_dict.values())[0]\n if sum:\n logp_var = at.sum(logp_var_dict)\n else:\n logp_var = logp_var_dict\n else:\n if sum:\n logp_var = at.sum([at.sum(factor) for factor in logp_var_dict.values()])\n else:\n logp_var = at.add(*logp_var_dict.values())\n\n # Recompute test values for the changes introduced by the replacements\n # above.\n if config.compute_test_value != \"off\":\n for node in io_toposort(graph_inputs((logp_var,)), (logp_var,)):\n compute_test_value(node)\n\n return logp_var\n\n\ndef logcdfpt(\n var: TensorVariable,\n rv_values: Optional[Union[TensorVariable, Dict[TensorVariable, TensorVariable]]] = None,\n *,\n scaling: bool = True,\n sum: bool = True,\n **kwargs,\n) -> TensorVariable:\n \"\"\"Create a measure-space (i.e. log-cdf) graph for a random variable at a given point.\n\n Parameters\n ==========\n var\n The `RandomVariable` output that determines the log-likelihood graph.\n rv_values\n A variable, or ``dict`` of variables, that represents the value of\n `var` in its log-likelihood. If no `rv_value` is provided,\n ``var.tag.value_var`` will be checked and, when available, used.\n jacobian\n Whether or not to include the Jacobian term.\n scaling\n A scaling term to apply to the generated log-likelihood graph.\n transformed\n Apply transforms.\n sum\n Sum the log-likelihood.\n\n \"\"\"\n if not isinstance(rv_values, Mapping):\n rv_values = {var: rv_values} if rv_values is not None else {}\n\n rv_var, rv_value_var = extract_rv_and_value_vars(var)\n\n rv_value = rv_values.get(rv_var, rv_value_var)\n\n if rv_var is not None and rv_value is None:\n raise ValueError(f\"No value variable specified or associated with {rv_var}\")\n\n if rv_value is not None:\n rv_value = at.as_tensor(rv_value)\n\n if rv_var is not None:\n # Make sure that the value is compatible with the random variable\n rv_value = rv_var.type.filter_variable(rv_value.astype(rv_var.dtype))\n\n if rv_value_var is None:\n rv_value_var = rv_value\n\n rv_node = rv_var.owner\n\n rng, size, dtype, *dist_params = rv_node.inputs\n\n # Here, we plug the actual random variable into the log-likelihood graph,\n # because we want a log-likelihood graph that only contains\n # random variables. This is important, because a random variable's\n # parameters can contain random variables themselves.\n # Ultimately, with a graph containing only random variables and\n # \"deterministics\", we can simply replace all the random variables with\n # their value variables and be done.\n tmp_rv_values = rv_values.copy()\n tmp_rv_values[rv_var] = rv_var\n\n logp_var = _logcdf(rv_node.op, rv_var, tmp_rv_values, *dist_params, **kwargs)\n\n transform = getattr(rv_value_var.tag, \"transform\", None) if rv_value_var else None\n\n # Replace random variables with their value variables\n replacements = rv_values.copy()\n replacements.update({rv_var: rv_value, rv_value_var: rv_value})\n\n (logp_var,), _ = rvs_to_value_vars(\n (logp_var,),\n apply_transforms=False,\n initial_replacements=replacements,\n )\n\n if sum:\n logp_var = at.sum(logp_var)\n\n if scaling:\n logp_var *= _get_scaling(\n getattr(rv_var.tag, \"total_size\", None), rv_value.shape, rv_value.ndim\n )\n\n # Recompute test values for the changes introduced by the replacements\n # above.\n if config.compute_test_value != \"off\":\n for node in io_toposort(graph_inputs((logp_var,)), (logp_var,)):\n compute_test_value(node)\n\n if rv_var.name is not None:\n logp_var.name = f\"__logp_{rv_var.name}\"\n\n return logp_var\n\n\ndef logp(var, rv_values, **kwargs):\n \"\"\"Create a log-probability graph.\"\"\"\n\n # Attach the value_var to the tag of var when it does not have one\n if not hasattr(var.tag, \"value_var\"):\n if isinstance(rv_values, Mapping):\n value_var = rv_values[var]\n else:\n value_var = rv_values\n var.tag.value_var = at.as_tensor_variable(value_var, dtype=var.dtype)\n\n return logpt(var, rv_values, **kwargs)\n\n\ndef logcdf(var, rv_values, **kwargs):\n \"\"\"Create a log-CDF graph.\"\"\"\n\n # Attach the value_var to the tag of var when it does not have one\n if not hasattr(var.tag, \"value_var\"):\n if isinstance(rv_values, Mapping):\n value_var = rv_values[var]\n else:\n value_var = rv_values\n var.tag.value_var = at.as_tensor_variable(value_var, dtype=var.dtype)\n\n return logcdfpt(var, rv_values, **kwargs)\n\n\n@singledispatch\ndef _logcdf(op, values, *args, **kwargs):\n \"\"\"Create a log-CDF graph.\n\n This function dispatches on the type of `op`, which should be a subclass\n of `RandomVariable`. If you want to implement new log-CDF graphs\n for a `RandomVariable`, register a new function on this dispatcher.\n\n \"\"\"\n raise NotImplementedError()\n\n\ndef logpt_sum(*args, **kwargs):\n \"\"\"Return the sum of the logp values for the given observations.\n\n Subclasses can use this to improve the speed of logp evaluations\n if only the sum of the logp values is needed.\n \"\"\"\n return logpt(*args, sum=True, **kwargs)\n", "meta": {"hexsha": "e8611c591e79420a6b4a473ef72d98a6f53313ff", "size": 14630, "ext": "py", "lang": "Python", "max_stars_repo_path": "pymc/distributions/logprob.py", "max_stars_repo_name": "michaeloriordan/pymc", "max_stars_repo_head_hexsha": "a099292f1de592447abc54f223ecd6e5d93a95dc", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1554, "max_stars_repo_stars_event_min_datetime": "2015-01-03T05:50:28.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T03:32:29.000Z", "max_issues_repo_path": "pymc/distributions/logprob.py", "max_issues_repo_name": "michaeloriordan/pymc", "max_issues_repo_head_hexsha": "a099292f1de592447abc54f223ecd6e5d93a95dc", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 922, "max_issues_repo_issues_event_min_datetime": "2015-01-03T17:51:09.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T22:49:44.000Z", "max_forks_repo_path": "pymc/distributions/logprob.py", "max_forks_repo_name": "michaeloriordan/pymc", "max_forks_repo_head_hexsha": "a099292f1de592447abc54f223ecd6e5d93a95dc", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 484, "max_forks_repo_forks_event_min_datetime": "2015-01-12T16:44:47.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T13:40:01.000Z", "avg_line_length": 35.4237288136, "max_line_length": 100, "alphanum_fraction": 0.6470266576, "include": true, "reason": "import numpy", "num_tokens": 3482, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6150878555160665, "lm_q2_score": 0.32423539245106087, "lm_q1q2_score": 0.19943325222513325}} {"text": "#!/usr/bin/env python\n# Copyright 2014-2018 The PySCF Developers. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n# Author: Timothy Berkelbach \n# Qiming Sun \n#\n\nimport sys\nimport ctypes\nimport numpy\nfrom pyscf import lib\nfrom pyscf.dft import numint\nfrom pyscf.dft.numint import eval_mat, _dot_ao_ao, _dot_ao_dm\nfrom pyscf.dft.numint import _scale_ao, _contract_rho\nfrom pyscf.dft.numint import _rks_gga_wv0, _rks_gga_wv1\nfrom pyscf.dft.numint import _uks_gga_wv0, _uks_gga_wv1\nfrom pyscf.dft.numint import OCCDROP\nfrom pyscf.pbc.dft.gen_grid import libpbc, make_mask, BLKSIZE\nfrom pyscf.pbc.lib.kpts_helper import is_zero, gamma_point, member\n\n#try:\n### Moderate speedup by caching eval_ao\n# from pyscf import pbc\n# from joblib import Memory\n# memory = Memory(cachedir='./tmp/', mmap_mode='r', verbose=0)\n# def memory_cache(f):\n# g = memory.cache(f)\n# def maybe_cache(*args, **kwargs):\n# if pbc.DEBUG:\n# return g(*args, **kwargs)\n# else:\n# return f(*args, **kwargs)\n# return maybe_cache\n#except:\n# memory_cache = lambda f: f\n\ndef eval_ao(cell, coords, kpt=numpy.zeros(3), deriv=0, relativity=0, shls_slice=None,\n non0tab=None, out=None, verbose=None):\n '''Collocate AO crystal orbitals (opt. gradients) on the real-space grid.\n\n Args:\n cell : instance of :class:`Cell`\n\n coords : (nx*ny*nz, 3) ndarray\n The real-space grid point coordinates.\n\n Kwargs:\n kpt : (3,) ndarray\n The k-point corresponding to the crystal AO.\n deriv : int\n AO derivative order. It affects the shape of the return array.\n If deriv=0, the returned AO values are stored in a (N,nao) array.\n Otherwise the AO values are stored in an array of shape (M,N,nao).\n Here N is the number of grids, nao is the number of AO functions,\n M is the size associated to the derivative deriv.\n\n Returns:\n aoR : ([4,] nx*ny*nz, nao=cell.nao_nr()) ndarray\n The value of the AO crystal orbitals on the real-space grid by default.\n If deriv=1, also contains the value of the orbitals gradient in the\n x, y, and z directions. It can be either complex or float array,\n depending on the kpt argument. If kpt is not given (gamma point),\n aoR is a float array.\n\n See Also:\n pyscf.dft.numint.eval_ao\n\n '''\n ao_kpts = eval_ao_kpts(cell, coords, numpy.reshape(kpt, (-1,3)), deriv,\n relativity, shls_slice, non0tab, out, verbose)\n return ao_kpts[0]\n\n\n#@memory_cache\ndef eval_ao_kpts(cell, coords, kpts=None, deriv=0, relativity=0,\n shls_slice=None, non0tab=None, out=None, verbose=None, **kwargs):\n '''\n Returns:\n ao_kpts: (nkpts, [comp], ngrids, nao) ndarray\n AO values at each k-point\n '''\n if kpts is None:\n if 'kpt' in kwargs:\n sys.stderr.write('WARN: KNumInt.eval_ao function finds keyword '\n 'argument \"kpt\" and converts it to \"kpts\"\\n')\n kpts = kwargs['kpt']\n else:\n kpts = numpy.zeros((1,3))\n kpts = numpy.reshape(kpts, (-1,3))\n\n comp = (deriv+1)*(deriv+2)*(deriv+3)//6\n if cell.cart:\n feval = 'GTOval_cart_deriv%d' % deriv\n else:\n feval = 'GTOval_sph_deriv%d' % deriv\n return cell.pbc_eval_gto(feval, coords, comp, kpts,\n shls_slice=shls_slice, non0tab=non0tab, out=out)\n\n\ndef eval_rho(cell, ao, dm, non0tab=None, xctype='LDA', hermi=0, verbose=None):\n '''Collocate the *real* density (opt. gradients) on the real-space grid.\n\n Args:\n cell : instance of :class:`Mole` or :class:`Cell`\n\n ao : ([4,] nx*ny*nz, nao=cell.nao_nr()) ndarray\n The value of the AO crystal orbitals on the real-space grid by default.\n If xctype='GGA', also contains the value of the gradient in the x, y,\n and z directions.\n\n Returns:\n rho : ([4,] nx*ny*nz) ndarray\n The value of the density on the real-space grid. If xctype='GGA',\n also contains the value of the gradient in the x, y, and z\n directions.\n\n See Also:\n pyscf.dft.numint.eval_rho\n\n '''\n\n if xctype == 'LDA' or xctype == 'HF':\n ngrids, nao = ao.shape\n else:\n ngrids, nao = ao[0].shape\n\n if non0tab is None:\n non0tab = numpy.empty(((ngrids+BLKSIZE-1)//BLKSIZE, cell.nbas),\n dtype=numpy.uint8)\n non0tab[:] = 0xff\n\n # complex orbitals or density matrix\n if numpy.iscomplexobj(ao) or numpy.iscomplexobj(dm):\n shls_slice = (0, cell.nbas)\n ao_loc = cell.ao_loc_nr()\n dm = dm.astype(numpy.complex128)\n# For GGA, function eval_rho returns real(|\\nabla i> D_ij D_ij <\\nabla j|)\n# = real(|\\nabla i> D_ij D_ij <\\nabla j|)\n# = real(|\\nabla i> D_ij conj(D_ij) < i|))\n# = real(|\\nabla i> D_ij conj(D_ij) < i|)\n# = real(|\\nabla i> [D_ij + (D^\\dagger)_ij] D_ij p', bra.real, aodm.real)\n #:rho += numpy.einsum('pi,pi->p', bra.imag, aodm.imag)\n #:return rho\n return _contract_rho(bra, aodm)\n\n if xctype == 'LDA' or xctype == 'HF':\n c0 = _dot_ao_dm(cell, ao, dm, non0tab, shls_slice, ao_loc)\n rho = dot_bra(ao, c0)\n\n elif xctype == 'GGA':\n rho = numpy.empty((4,ngrids))\n c0 = _dot_ao_dm(cell, ao[0], dm, non0tab, shls_slice, ao_loc)\n rho[0] = dot_bra(ao[0], c0)\n for i in range(1, 4):\n rho[i] = dot_bra(ao[i], c0) * 2\n\n else:\n # rho[4] = \\nabla^2 rho, rho[5] = 1/2 |nabla f|^2\n rho = numpy.empty((6,ngrids))\n c0 = _dot_ao_dm(cell, ao[0], dm, non0tab, shls_slice, ao_loc)\n rho[0] = dot_bra(ao[0], c0)\n rho[5] = 0\n for i in range(1, 4):\n rho[i] = dot_bra(ao[i], c0) * 2 # *2 for +c.c.\n c1 = _dot_ao_dm(cell, ao[i], dm, non0tab, shls_slice, ao_loc)\n rho[5] += dot_bra(ao[i], c1)\n XX, YY, ZZ = 4, 7, 9\n ao2 = ao[XX] + ao[YY] + ao[ZZ]\n rho[4] = dot_bra(ao2, c0)\n rho[4] += rho[5]\n rho[4] *= 2 # *2 for +c.c.\n rho[5] *= .5\n else:\n # real orbitals and real DM\n rho = numint.eval_rho(cell, ao, dm, non0tab, xctype, hermi, verbose)\n return rho\n\ndef eval_rho2(cell, ao, mo_coeff, mo_occ, non0tab=None, xctype='LDA',\n verbose=None):\n '''Refer to `pyscf.dft.numint.eval_rho2` for full documentation.\n '''\n xctype = xctype.upper()\n if xctype == 'LDA' or xctype == 'HF':\n ngrids, nao = ao.shape\n else:\n ngrids, nao = ao[0].shape\n\n if non0tab is None:\n non0tab = numpy.empty(((ngrids+BLKSIZE-1)//BLKSIZE,cell.nbas),\n dtype=numpy.uint8)\n non0tab[:] = 0xff\n\n # complex orbitals or density matrix\n if numpy.iscomplexobj(ao) or numpy.iscomplexobj(mo_coeff):\n def dot(bra, ket):\n #:rho = numpy.einsum('pi,pi->p', bra.real, ket.real)\n #:rho += numpy.einsum('pi,pi->p', bra.imag, ket.imag)\n #:return rho\n return _contract_rho(bra, ket)\n\n shls_slice = (0, cell.nbas)\n ao_loc = cell.ao_loc_nr()\n pos = mo_occ > OCCDROP\n cpos = numpy.einsum('ij,j->ij', mo_coeff[:,pos], numpy.sqrt(mo_occ[pos]))\n\n if pos.sum() > 0:\n if xctype == 'LDA' or xctype == 'HF':\n c0 = _dot_ao_dm(cell, ao, cpos, non0tab, shls_slice, ao_loc)\n rho = dot(c0, c0)\n elif xctype == 'GGA':\n rho = numpy.empty((4,ngrids))\n c0 = _dot_ao_dm(cell, ao[0], cpos, non0tab, shls_slice, ao_loc)\n rho[0] = dot(c0, c0)\n for i in range(1, 4):\n c1 = _dot_ao_dm(cell, ao[i], cpos, non0tab, shls_slice, ao_loc)\n rho[i] = dot(c0, c1) * 2 # *2 for +c.c.\n else: # meta-GGA\n # rho[4] = \\nabla^2 rho, rho[5] = 1/2 |nabla f|^2\n rho = numpy.empty((6,ngrids))\n c0 = _dot_ao_dm(cell, ao[0], cpos, non0tab, shls_slice, ao_loc)\n rho[0] = dot(c0, c0)\n rho[5] = 0\n for i in range(1, 4):\n c1 = _dot_ao_dm(cell, ao[i], cpos, non0tab, shls_slice, ao_loc)\n rho[i] = dot(c0, c1) * 2 # *2 for +c.c.\n rho[5]+= dot(c1, c1)\n XX, YY, ZZ = 4, 7, 9\n ao2 = ao[XX] + ao[YY] + ao[ZZ]\n c1 = _dot_ao_dm(cell, ao2, cpos, non0tab, shls_slice, ao_loc)\n rho[4] = dot(c0, c1)\n rho[4]+= rho[5]\n rho[4]*= 2\n rho[5]*= .5\n else:\n if xctype == 'LDA' or xctype == 'HF':\n rho = numpy.zeros(ngrids)\n elif xctype == 'GGA':\n rho = numpy.zeros((4,ngrids))\n else:\n rho = numpy.zeros((6,ngrids))\n\n neg = mo_occ < -OCCDROP\n if neg.sum() > 0:\n cneg = numpy.einsum('ij,j->ij', mo_coeff[:,neg], numpy.sqrt(-mo_occ[neg]))\n if xctype == 'LDA' or xctype == 'HF':\n c0 = _dot_ao_dm(cell, ao, cneg, non0tab, shls_slice, ao_loc)\n rho -= dot(c0, c0)\n elif xctype == 'GGA':\n c0 = _dot_ao_dm(cell, ao[0], cneg, non0tab, shls_slice, ao_loc)\n rho[0] -= dot(c0, c0)\n for i in range(1, 4):\n c1 = _dot_ao_dm(cell, ao[i], cneg, non0tab, shls_slice, ao_loc)\n rho[i] -= dot(c0, c1) * 2 # *2 for +c.c.\n else:\n c0 = _dot_ao_dm(cell, ao[0], cneg, non0tab, shls_slice, ao_loc)\n rho[0] -= dot(c0, c0)\n rho5 = 0\n for i in range(1, 4):\n c1 = _dot_ao_dm(cell, ao[i], cneg, non0tab, shls_slice, ao_loc)\n rho[i] -= dot(c0, c1) * 2 # *2 for +c.c.\n rho5 -= dot(c1, c1)\n XX, YY, ZZ = 4, 7, 9\n ao2 = ao[XX] + ao[YY] + ao[ZZ]\n c1 = _dot_ao_dm(cell, ao2, cneg, non0tab, shls_slice, ao_loc)\n rho[4] -= dot(c0, c1) * 2\n rho[4] -= rho5 * 2\n rho[5] -= rho5 * .5\n else:\n rho = numint.eval_rho2(cell, ao, mo_coeff, mo_occ, non0tab, xctype, verbose)\n return rho\n\n\ndef nr_rks(ni, cell, grids, xc_code, dms, spin=0, relativity=0, hermi=0,\n kpts=None, kpts_band=None, max_memory=2000, verbose=None):\n '''Calculate RKS XC functional and potential matrix for given meshgrids and density matrix\n\n Note: This is a replica of pyscf.dft.numint.nr_rks_vxc with kpts added.\n This implemented uses slow function in numint, which only calls eval_rho, eval_mat.\n Faster function uses eval_rho2 which is not yet implemented.\n\n Args:\n ni : an instance of :class:`NumInt` or :class:`KNumInt`\n\n cell : instance of :class:`Mole` or :class:`Cell`\n\n grids : an instance of :class:`Grids`\n grids.coords and grids.weights are needed for coordinates and weights of meshgrids.\n xc_code : str\n XC functional description.\n See :func:`parse_xc` of pyscf/dft/libxc.py for more details.\n dms : 2D/3D array or a list of 2D/3D arrays\n Density matrices (2D) / density matrices for k-points (3D)\n\n Kwargs:\n spin : int\n spin polarized if spin = 1\n relativity : int\n No effects.\n hermi : int\n No effects\n max_memory : int or float\n The maximum size of cache to use (in MB).\n verbose : int or object of :class:`Logger`\n No effects.\n kpts : (3,) ndarray or (nkpts,3) ndarray\n Single or multiple k-points sampled for the DM. Default is gamma point.\n kpts_band : (3,) ndarray or (*,3) ndarray\n A list of arbitrary \"band\" k-points at which to evaluate the XC matrix.\n\n Returns:\n nelec, excsum, vmat.\n nelec is the number of electrons generated by numerical integration.\n excsum is the XC functional value. vmat is the XC potential matrix in\n 2D array of shape (nao,nao) where nao is the number of AO functions.\n '''\n if kpts is None:\n kpts = numpy.zeros((1,3))\n\n xctype = ni._xc_type(xc_code)\n make_rho, nset, nao = ni._gen_rho_evaluator(cell, dms, hermi)\n\n nelec = numpy.zeros(nset)\n excsum = numpy.zeros(nset)\n vmat = [0]*nset\n if xctype == 'LDA':\n ao_deriv = 0\n for ao_k1, ao_k2, mask, weight, coords \\\n in ni.block_loop(cell, grids, nao, ao_deriv, kpts, kpts_band,\n max_memory):\n for i in range(nset):\n rho = make_rho(i, ao_k2, mask, xctype)\n exc, vxc = ni.eval_xc(xc_code, rho, 0, relativity, 1)[:2]\n vrho = vxc[0]\n den = rho*weight\n nelec[i] += den.sum()\n excsum[i] += (den*exc).sum()\n vmat[i] += ni.eval_mat(cell, ao_k1, weight, rho, vxc,\n mask, xctype, 0, verbose)\n elif xctype == 'GGA':\n ao_deriv = 1\n for ao_k1, ao_k2, mask, weight, coords \\\n in ni.block_loop(cell, grids, nao, ao_deriv, kpts, kpts_band,\n max_memory):\n for i in range(nset):\n rho = make_rho(i, ao_k2, mask, xctype)\n exc, vxc = ni.eval_xc(xc_code, rho, 0, relativity, 1)[:2]\n den = rho[0]*weight\n nelec[i] += den.sum()\n excsum[i] += (den*exc).sum()\n vmat[i] += ni.eval_mat(cell, ao_k1, weight, rho, vxc,\n mask, xctype, 0, verbose)\n elif xctype == 'MGGA':\n if (any(x in xc_code.upper() for x in ('CC06', 'CS', 'BR89', 'MK00'))):\n raise NotImplementedError('laplacian in meta-GGA method')\n ao_deriv = 2\n for ao_k1, ao_k2, mask, weight, coords \\\n in ni.block_loop(cell, grids, nao, ao_deriv, kpts, kpts_band,\n max_memory):\n for i in range(nset):\n rho = make_rho(i, ao_k2, mask, xctype)\n exc, vxc = ni.eval_xc(xc_code, rho, 0, relativity, 1)[:2]\n den = rho[0]*weight\n nelec[i] += den.sum()\n excsum[i] += (den*exc).sum()\n vmat[i] += ni.eval_mat(cell, ao_k1, weight, rho, vxc,\n mask, xctype, 0, verbose)\n if nset == 1:\n nelec = nelec[0]\n excsum = excsum[0]\n vmat = vmat[0]\n return nelec, excsum, vmat\n\ndef nr_uks(ni, cell, grids, xc_code, dms, spin=1, relativity=0, hermi=0,\n kpts=None, kpts_band=None, max_memory=2000, verbose=None):\n '''Calculate UKS XC functional and potential matrix for given meshgrids and density matrix\n\n Note: This is a replica of pyscf.dft.numint.nr_rks_vxc with kpts added.\n This implemented uses slow function in numint, which only calls eval_rho, eval_mat.\n Faster function uses eval_rho2 which is not yet implemented.\n\n Args:\n ni : an instance of :class:`NumInt` or :class:`KNumInt`\n\n cell : instance of :class:`Mole` or :class:`Cell`\n\n grids : an instance of :class:`Grids`\n grids.coords and grids.weights are needed for coordinates and weights of meshgrids.\n xc_code : str\n XC functional description.\n See :func:`parse_xc` of pyscf/dft/libxc.py for more details.\n dms :\n Density matrices\n\n Kwargs:\n spin : int\n spin polarized if spin = 1\n relativity : int\n No effects.\n hermi : int\n Input density matrices symmetric or not\n max_memory : int or float\n The maximum size of cache to use (in MB).\n verbose : int or object of :class:`Logger`\n No effects.\n kpts : (3,) ndarray or (nkpts,3) ndarray\n Single or multiple k-points sampled for the DM. Default is gamma point.\n kpts_band : (3,) ndarray or (*,3) ndarray\n A list of arbitrary \"band\" k-points at which to evaluate the XC matrix.\n\n Returns:\n nelec, excsum, vmat.\n nelec is the number of electrons generated by numerical integration.\n excsum is the XC functional value. vmat is the XC potential matrix in\n 2D array of shape (nao,nao) where nao is the number of AO functions.\n '''\n if kpts is None:\n kpts = numpy.zeros((1,3))\n\n xctype = ni._xc_type(xc_code)\n dma, dmb = _format_uks_dm(dms)\n nao = dma.shape[-1]\n make_rhoa, nset = ni._gen_rho_evaluator(cell, dma, hermi)[:2]\n make_rhob = ni._gen_rho_evaluator(cell, dmb, hermi)[0]\n\n nelec = numpy.zeros((2,nset))\n excsum = numpy.zeros(nset)\n vmata = [0]*nset\n vmatb = [0]*nset\n if xctype == 'LDA':\n ao_deriv = 0\n for ao_k1, ao_k2, mask, weight, coords \\\n in ni.block_loop(cell, grids, nao, ao_deriv, kpts, kpts_band,\n max_memory):\n for i in range(nset):\n rho_a = make_rhoa(i, ao_k2, mask, xctype)\n rho_b = make_rhob(i, ao_k2, mask, xctype)\n exc, vxc = ni.eval_xc(xc_code, (rho_a, rho_b),\n 1, relativity, 1, verbose)[:2]\n vrho = vxc[0]\n den = rho_a * weight\n nelec[0,i] += den.sum()\n excsum[i] += (den*exc).sum()\n den = rho_b * weight\n nelec[1,i] += den.sum()\n excsum[i] += (den*exc).sum()\n\n vmata[i] += ni.eval_mat(cell, ao_k1, weight, rho_a, vrho[:,0],\n mask, xctype, 1, verbose)\n vmatb[i] += ni.eval_mat(cell, ao_k1, weight, rho_b, vrho[:,1],\n mask, xctype, 1, verbose)\n elif xctype == 'GGA':\n ao_deriv = 1\n for ao_k1, ao_k2, mask, weight, coords \\\n in ni.block_loop(cell, grids, nao, ao_deriv, kpts,\n kpts_band, max_memory):\n for i in range(nset):\n rho_a = make_rhoa(i, ao_k2, mask, xctype)\n rho_b = make_rhob(i, ao_k2, mask, xctype)\n exc, vxc = ni.eval_xc(xc_code, (rho_a, rho_b),\n 1, relativity, 1, verbose)[:2]\n vrho, vsigma = vxc[:2]\n den = rho_a[0]*weight\n nelec[0,i] += den.sum()\n excsum[i] += (den*exc).sum()\n den = rho_b[0]*weight\n nelec[1,i] += den.sum()\n excsum[i] += (den*exc).sum()\n\n vmata[i] += ni.eval_mat(cell, ao_k1, weight, (rho_a,rho_b),\n (vrho[:,0], (vsigma[:,0],vsigma[:,1])),\n mask, xctype, 1, verbose)\n vmatb[i] += ni.eval_mat(cell, ao_k1, weight, (rho_b,rho_a),\n (vrho[:,1], (vsigma[:,2],vsigma[:,1])),\n mask, xctype, 1, verbose)\n elif xctype == 'MGGA':\n assert(all(x not in xc_code.upper() for x in ('CC06', 'CS', 'BR89', 'MK00')))\n ao_deriv = 2\n for ao_k1, ao_k2, mask, weight, coords \\\n in ni.block_loop(cell, grids, nao, ao_deriv, kpts, kpts_band,\n max_memory):\n for i in range(nset):\n rho_a = make_rhoa(i, ao_k2, mask, xctype)\n rho_b = make_rhob(i, ao_k2, mask, xctype)\n exc, vxc = ni.eval_xc(xc_code, (rho_a, rho_b),\n 1, relativity, 1, verbose)[:2]\n vrho, vsigma, vlapl, vtau = vxc\n den = rho_a[0]*weight\n nelec[0,i] += den.sum()\n excsum[i] += (den*exc).sum()\n den = rho_b[0]*weight\n nelec[1,i] += den.sum()\n excsum[i] += (den*exc).sum()\n\n v = (vrho[:,0], (vsigma[:,0],vsigma[:,1]), None, vtau[:,0])\n vmata[i] += ni.eval_mat(cell, ao_k1, weight, (rho_a,rho_b), v,\n mask, xctype, 1, verbose)\n v = (vrho[:,1], (vsigma[:,2],vsigma[:,1]), None, vtau[:,1])\n vmatb[i] += ni.eval_mat(cell, ao_k1, weight, (rho_b,rho_a), v,\n mask, xctype, 1, verbose)\n v = None\n\n if dma.ndim == vmata[0].ndim: # One set of DMs in the input\n nelec = nelec[:,0]\n excsum = excsum[0]\n vmata = vmata[0]\n vmatb = vmatb[0]\n return nelec, excsum, lib.asarray((vmata,vmatb))\n\ndef _format_uks_dm(dms):\n dma, dmb = dms\n if getattr(dms, 'mo_coeff', None) is not None:\n#TODO: test whether dm.mo_coeff matching dm\n mo_coeff = dms.mo_coeff\n mo_occ = dms.mo_occ\n if (isinstance(mo_coeff[0], numpy.ndarray) and\n mo_coeff[0].ndim < dma.ndim): # handle ROKS\n mo_occa = [numpy.array(occ> 0, dtype=numpy.double) for occ in mo_occ]\n mo_occb = [numpy.array(occ==2, dtype=numpy.double) for occ in mo_occ]\n dma = lib.tag_array(dma, mo_coeff=mo_coeff, mo_occ=mo_occa)\n dmb = lib.tag_array(dmb, mo_coeff=mo_coeff, mo_occ=mo_occb)\n else:\n dma = lib.tag_array(dma, mo_coeff=mo_coeff[0], mo_occ=mo_occ[0])\n dmb = lib.tag_array(dmb, mo_coeff=mo_coeff[1], mo_occ=mo_occ[1])\n return dma, dmb\n\nnr_rks_vxc = nr_rks\nnr_uks_vxc = nr_uks\n\ndef nr_rks_fxc(ni, cell, grids, xc_code, dm0, dms, relativity=0, hermi=0,\n rho0=None, vxc=None, fxc=None, kpts=None, max_memory=2000,\n verbose=None):\n '''Contract RKS XC kernel matrix with given density matrices\n\n Args:\n ni : an instance of :class:`NumInt` or :class:`KNumInt`\n\n cell : instance of :class:`Mole` or :class:`Cell`\n\n grids : an instance of :class:`Grids`\n grids.coords and grids.weights are needed for coordinates and weights of meshgrids.\n xc_code : str\n XC functional description.\n See :func:`parse_xc` of pyscf/dft/libxc.py for more details.\n dms : 2D/3D array or a list of 2D/3D arrays\n Density matrices (2D) / density matrices for k-points (3D)\n\n Kwargs:\n hermi : int\n Input density matrices symmetric or not\n max_memory : int or float\n The maximum size of cache to use (in MB).\n rho0 : float array\n Zero-order density (and density derivative for GGA). Giving kwargs rho0,\n vxc and fxc to improve better performance.\n vxc : float array\n First order XC derivatives\n fxc : float array\n Second order XC derivatives\n\n Examples:\n\n '''\n if kpts is None:\n kpts = numpy.zeros((1,3))\n xctype = ni._xc_type(xc_code)\n\n make_rho, nset, nao = ni._gen_rho_evaluator(cell, dms, hermi)\n if ((xctype == 'LDA' and fxc is None) or\n (xctype == 'GGA' and rho0 is None)):\n make_rho0 = ni._gen_rho_evaluator(cell, dm0, 1)[0]\n\n ao_loc = cell.ao_loc_nr()\n vmat = [0] * nset\n if xctype == 'LDA':\n ao_deriv = 0\n ip = 0\n for ao_k1, ao_k2, mask, weight, coords \\\n in ni.block_loop(cell, grids, nao, ao_deriv, kpts, None, max_memory):\n ngrid = weight.size\n if fxc is None:\n rho = make_rho0(0, ao_k1, mask, xctype)\n fxc0 = ni.eval_xc(xc_code, rho, 0, relativity, 2, verbose)[2]\n frr = fxc0[0]\n else:\n frr = fxc[0][ip:ip+ngrid]\n ip += ngrid\n\n for i in range(nset):\n rho1 = make_rho(i, ao_k1, mask, xctype)\n wv = weight * frr * rho1\n vmat[i] += ni._fxc_mat(cell, ao_k1, wv, mask, xctype, ao_loc)\n\n elif xctype == 'GGA':\n ao_deriv = 1\n ip = 0\n for ao_k1, ao_k2, mask, weight, coords \\\n in ni.block_loop(cell, grids, nao, ao_deriv, kpts, None, max_memory):\n ngrid = weight.size\n if rho0 is None:\n rho = make_rho0(0, ao_k1, mask, xctype)\n else:\n rho = numpy.asarray(rho0[:,ip:ip+ngrid], order='C')\n\n if vxc is None or fxc is None:\n vxc0, fxc0 = ni.eval_xc(xc_code, rho, 0, relativity, 2, verbose)[1:3]\n else:\n vxc0 = (None, vxc[1][ip:ip+ngrid])\n fxc0 = (fxc[0][ip:ip+ngrid], fxc[1][ip:ip+ngrid], fxc[2][ip:ip+ngrid])\n ip += ngrid\n\n for i in range(nset):\n rho1 = make_rho(i, ao_k1, mask, xctype)\n wv = _rks_gga_wv1(rho, rho1, vxc0, fxc0, weight)\n vmat[i] += ni._fxc_mat(cell, ao_k1, wv, mask, xctype, ao_loc)\n\n # call swapaxes method to swap last two indices because vmat may be a 3D\n # array (nset,nao,nao) in single k-point mode or a 4D array\n # (nset,nkpts,nao,nao) in k-points mode\n for i in range(nset): # for (\\nabla\\mu) \\nu + \\mu (\\nabla\\nu)\n vmat[i] = vmat[i] + vmat[i].swapaxes(-2,-1).conj()\n\n elif xctype == 'MGGA':\n raise NotImplementedError('meta-GGA')\n\n if isinstance(dms, numpy.ndarray) and dms.ndim == vmat[0].ndim:\n # One set of DMs in the input\n vmat = vmat[0]\n return lib.asarray(vmat)\n\ndef nr_rks_fxc_st(ni, cell, grids, xc_code, dm0, dms_alpha, relativity=0, singlet=True,\n rho0=None, vxc=None, fxc=None, kpts=None, max_memory=2000,\n verbose=None):\n '''Associated to singlet or triplet Hessian\n Note the difference to nr_rks_fxc, dms_alpha is the response density\n matrices of alpha spin, alpha+/-beta DM is applied due to singlet/triplet\n coupling\n\n Ref. CPL, 256, 454\n '''\n if kpts is None:\n kpts = numpy.zeros((1,3))\n xctype = ni._xc_type(xc_code)\n\n make_rho, nset, nao = ni._gen_rho_evaluator(cell, dms_alpha)\n if ((xctype == 'LDA' and fxc is None) or\n (xctype == 'GGA' and rho0 is None)):\n make_rho0 = ni._gen_rho_evaluator(cell, dm0, 1)[0]\n\n ao_loc = cell.ao_loc_nr()\n vmat = [0] * nset\n if xctype == 'LDA':\n ao_deriv = 0\n ip = 0\n for ao_k1, ao_k2, mask, weight, coords \\\n in ni.block_loop(cell, grids, nao, ao_deriv, kpts, None, max_memory):\n ngrid = weight.size\n if fxc is None:\n rho = make_rho0(0, ao_k1, mask, xctype)\n rho *= .5 # alpha density\n fxc0 = ni.eval_xc(xc_code, (rho,rho), 1, deriv=2)[2]\n u_u, u_d, d_d = fxc0[0].T\n else:\n u_u, u_d, d_d = fxc[0][ip:ip+ngrid].T\n ip += ngrid\n if singlet:\n frho = u_u + u_d\n else:\n frho = u_u - u_d\n\n for i in range(nset):\n rho1 = make_rho(i, ao_k1, mask, xctype)\n wv = weight * frho * rho1\n vmat[i] += ni._fxc_mat(cell, ao_k1, wv, mask, xctype, ao_loc)\n\n elif xctype == 'GGA':\n ao_deriv = 1\n ip = 0\n for ao_k1, ao_k2, mask, weight, coords \\\n in ni.block_loop(cell, grids, nao, ao_deriv, kpts, None, max_memory):\n ngrid = weight.size\n if vxc is None or fxc is None:\n rho = make_rho0(0, ao_k1, mask, xctype)\n rho *= .5 # alpha density\n vxc0, fxc0 = ni.eval_xc(xc_code, (rho,rho), 1, deriv=2)[1:3]\n\n vsigma = vxc0[1].T\n u_u, u_d, d_d = fxc0[0].T # v2rho2\n u_uu, u_ud, u_dd, d_uu, d_ud, d_dd = fxc0[1].T # v2rhosigma\n uu_uu, uu_ud, uu_dd, ud_ud, ud_dd, dd_dd = fxc0[2].T # v2sigma2\n else:\n rho = rho0[0][:,ip:ip+ngrid]\n vsigma = vxc[1][ip:ip+ngrid].T\n u_u, u_d, d_d = fxc[0][ip:ip+ngrid].T # v2rho2\n u_uu, u_ud, u_dd, d_uu, d_ud, d_dd = fxc[1][ip:ip+ngrid].T # v2rhosigma\n uu_uu, uu_ud, uu_dd, ud_ud, ud_dd, dd_dd = fxc[2][ip:ip+ngrid].T # v2sigma2\n\n if singlet:\n fgamma = vsigma[0] + vsigma[1] * .5\n frho = u_u + u_d\n fgg = uu_uu + .5*ud_ud + 2*uu_ud + uu_dd\n frhogamma = u_uu + u_dd + u_ud\n else:\n fgamma = vsigma[0] - vsigma[1] * .5\n frho = u_u - u_d\n fgg = uu_uu - uu_dd\n frhogamma = u_uu - u_dd\n\n for i in range(nset):\n # rho1[0 ] = |b>pi', ao, wv)\n aow = _scale_ao(ao, wv)\n mat = _dot_ao_ao(cell, ao, aow, non0tab, shls_slice, ao_loc)\n else:\n #:aow = numpy.einsum('npi,np->pi', ao, wv)\n aow = _scale_ao(ao, wv)\n mat = _dot_ao_ao(cell, ao[0], aow, non0tab, shls_slice, ao_loc)\n return mat\n\ndef cache_xc_kernel(ni, cell, grids, xc_code, mo_coeff, mo_occ, spin=0,\n kpts=None, max_memory=2000):\n '''Compute the 0th order density, Vxc and fxc. They can be used in TDDFT,\n DFT hessian module etc.\n '''\n if kpts is None:\n kpts = numpy.zeros((1,3))\n xctype = ni._xc_type(xc_code)\n ao_deriv = 0\n if xctype == 'GGA':\n ao_deriv = 1\n elif xctype == 'MGGA':\n raise NotImplementedError('meta-GGA')\n\n nao = cell.nao_nr()\n if spin == 0:\n rho = []\n for ao_k1, ao_k2, mask, weight, coords \\\n in ni.block_loop(cell, grids, nao, ao_deriv, kpts, None, max_memory):\n rho.append(ni.eval_rho2(cell, ao_k1, mo_coeff, mo_occ, mask, xctype))\n rho = numpy.hstack(rho)\n else:\n rhoa = []\n rhob = []\n for ao_k1, ao_k2, mask, weight, coords \\\n in ni.block_loop(cell, grids, nao, ao_deriv, kpts, None, max_memory):\n rhoa.append(ni.eval_rho2(cell, ao_k1, mo_coeff[0], mo_occ[0], mask, xctype))\n rhob.append(ni.eval_rho2(cell, ao_k1, mo_coeff[1], mo_occ[1], mask, xctype))\n rho = (numpy.hstack(rhoa), numpy.hstack(rhob))\n vxc, fxc = ni.eval_xc(xc_code, rho, spin, 0, 2, 0)[1:3]\n return rho, vxc, fxc\n\n\ndef get_rho(ni, cell, dm, grids, kpts=numpy.zeros((1,3)), max_memory=2000):\n '''Density in real space\n '''\n make_rho, nset, nao = ni._gen_rho_evaluator(cell, dm)\n assert(nset == 1)\n rho = numpy.empty(grids.weights.size)\n p1 = 0\n for ao_k1, ao_k2, mask, weight, coords \\\n in ni.block_loop(cell, grids, nao, 0, kpts, None, max_memory):\n p0, p1 = p1, p1 + weight.size\n rho[p0:p1] = make_rho(0, ao_k1, mask, 'LDA')\n return rho\n\n\nclass NumInt(numint.NumInt):\n '''Generalization of pyscf's NumInt class for a single k-point shift and\n periodic images.\n '''\n def eval_ao(self, cell, coords, kpt=numpy.zeros(3), deriv=0, relativity=0,\n shls_slice=None, non0tab=None, out=None, verbose=None):\n return eval_ao(cell, coords, kpt, deriv, relativity, shls_slice,\n non0tab, out, verbose)\n\n @lib.with_doc(make_mask.__doc__)\n def make_mask(self, cell, coords, relativity=0, shls_slice=None,\n verbose=None):\n return make_mask(cell, coords, relativity, shls_slice, verbose)\n\n @lib.with_doc(eval_rho.__doc__)\n def eval_rho(self, cell, ao, dm, non0tab=None, xctype='LDA', hermi=0, verbose=None):\n return eval_rho(cell, ao, dm, non0tab, xctype, hermi, verbose)\n\n def eval_rho2(self, cell, ao, mo_coeff, mo_occ, non0tab=None, xctype='LDA',\n verbose=None):\n return eval_rho2(cell, ao, mo_coeff, mo_occ, non0tab, xctype, verbose)\n\n def nr_vxc(self, cell, grids, xc_code, dms, spin=0, relativity=0, hermi=0,\n kpt=None, kpts_band=None, max_memory=2000, verbose=None):\n '''Evaluate RKS/UKS XC functional and potential matrix.\n See :func:`nr_rks` and :func:`nr_uks` for more details.\n '''\n if spin == 0:\n return self.nr_rks(cell, grids, xc_code, dms, hermi,\n kpt, kpts_band, max_memory, verbose)\n else:\n return self.nr_uks(cell, grids, xc_code, dms, hermi,\n kpt, kpts_band, max_memory, verbose)\n\n @lib.with_doc(nr_rks.__doc__)\n def nr_rks(self, cell, grids, xc_code, dms, hermi=0,\n kpt=numpy.zeros(3), kpts_band=None, max_memory=2000, verbose=None):\n if kpts_band is not None:\n# To compute Vxc on kpts_band, convert the NumInt object to KNumInt object.\n ni = KNumInt()\n ni.__dict__.update(self.__dict__)\n nao = dms.shape[-1]\n return ni.nr_rks(cell, grids, xc_code, dms.reshape(-1,1,nao,nao),\n hermi, kpt.reshape(1,3), kpts_band, max_memory,\n verbose)\n return nr_rks(self, cell, grids, xc_code, dms,\n 0, 0, hermi, kpt, kpts_band, max_memory, verbose)\n\n @lib.with_doc(nr_uks.__doc__)\n def nr_uks(self, cell, grids, xc_code, dms, hermi=0,\n kpt=numpy.zeros(3), kpts_band=None, max_memory=2000, verbose=None):\n if kpts_band is not None:\n# To compute Vxc on kpts_band, convert the NumInt object to KNumInt object.\n ni = KNumInt()\n ni.__dict__.update(self.__dict__)\n nao = dms[0].shape[-1]\n return ni.nr_uks(cell, grids, xc_code, dms.reshape(-1,1,nao,nao),\n hermi, kpt.reshape(1,3), kpts_band, max_memory,\n verbose)\n return nr_uks(self, cell, grids, xc_code, dms,\n 1, 0, hermi, kpt, kpts_band, max_memory, verbose)\n\n def eval_mat(self, cell, ao, weight, rho, vxc,\n non0tab=None, xctype='LDA', spin=0, verbose=None):\n# Guess whether ao is evaluated for kpts_band. When xctype is LDA, ao on grids\n# should be a 2D array. For other xc functional, ao should be a 3D array.\n if ao.ndim == 2 or (xctype != 'LDA' and ao.ndim == 3):\n mat = eval_mat(cell, ao, weight, rho, vxc, non0tab, xctype, spin, verbose)\n else:\n nkpts = len(ao)\n nao = ao[0].shape[-1]\n mat = numpy.empty((nkpts,nao,nao), dtype=numpy.complex128)\n for k in range(nkpts):\n mat[k] = eval_mat(cell, ao[k], weight, rho, vxc,\n non0tab, xctype, spin, verbose)\n return mat\n\n def _fxc_mat(self, cell, ao, wv, non0tab, xctype, ao_loc):\n return _fxc_mat(cell, ao, wv, non0tab, xctype, ao_loc)\n\n def block_loop(self, cell, grids, nao, deriv=0, kpt=numpy.zeros(3),\n kpts_band=None, max_memory=2000, non0tab=None, blksize=None):\n '''Define this macro to loop over grids by blocks.\n '''\n# For UniformGrids, grids.coords does not indicate whehter grids are initialized\n if grids.non0tab is None:\n grids.build(with_non0tab=True)\n grids_coords = grids.coords\n grids_weights = grids.weights\n ngrids = grids_coords.shape[0]\n comp = (deriv+1)*(deriv+2)*(deriv+3)//6\n# NOTE to index grids.non0tab, the blksize needs to be the integer multiplier of BLKSIZE\n if blksize is None:\n blksize = int(max_memory*1e6/(comp*2*nao*16*BLKSIZE))*BLKSIZE\n blksize = max(BLKSIZE, min(blksize, ngrids, BLKSIZE*1200))\n if non0tab is None:\n non0tab = grids.non0tab\n if non0tab is None:\n non0tab = numpy.empty(((ngrids+BLKSIZE-1)//BLKSIZE,cell.nbas),\n dtype=numpy.uint8)\n non0tab[:] = 0xff\n kpt = numpy.reshape(kpt, 3)\n if kpts_band is None:\n kpt1 = kpt2 = kpt\n else:\n kpt1 = kpts_band\n kpt2 = kpt\n\n for ip0 in range(0, ngrids, blksize):\n ip1 = min(ngrids, ip0+blksize)\n coords = grids_coords[ip0:ip1]\n weight = grids_weights[ip0:ip1]\n non0 = non0tab[ip0//BLKSIZE:]\n ao_k2 = self.eval_ao(cell, coords, kpt2, deriv=deriv, non0tab=non0)\n if abs(kpt1-kpt2).sum() < 1e-9:\n ao_k1 = ao_k2\n else:\n ao_k1 = self.eval_ao(cell, coords, kpt1, deriv=deriv)\n yield ao_k1, ao_k2, non0, weight, coords\n ao_k1 = ao_k2 = None\n\n def _gen_rho_evaluator(self, cell, dms, hermi=0):\n return numint.NumInt._gen_rho_evaluator(self, cell, dms, hermi)\n\n nr_rks_fxc = nr_rks_fxc\n nr_uks_fxc = nr_uks_fxc\n cache_xc_kernel = cache_xc_kernel\n get_rho = get_rho\n\n def rsh_and_hybrid_coeff(self, xc_code, spin=0):\n omega, alpha, hyb = numint.NumInt.rsh_and_hybrid_coeff(self, xc_code, spin)\n if abs(omega) > 1e-10:\n raise NotImplementedError\n return omega, alpha, hyb\n_NumInt = NumInt\n\n\nclass KNumInt(numint.NumInt):\n '''Generalization of pyscf's NumInt class for k-point sampling and\n periodic images.\n '''\n def __init__(self, kpts=numpy.zeros((1,3))):\n numint.NumInt.__init__(self)\n self.kpts = numpy.reshape(kpts, (-1,3))\n\n def eval_ao(self, cell, coords, kpts=numpy.zeros((1,3)), deriv=0, relativity=0,\n shls_slice=None, non0tab=None, out=None, verbose=None, **kwargs):\n return eval_ao_kpts(cell, coords, kpts, deriv,\n relativity, shls_slice, non0tab, out, verbose)\n\n @lib.with_doc(make_mask.__doc__)\n def make_mask(self, cell, coords, relativity=0, shls_slice=None,\n verbose=None):\n return make_mask(cell, coords, relativity, shls_slice, verbose)\n\n def eval_rho(self, cell, ao_kpts, dm_kpts, non0tab=None, xctype='LDA',\n hermi=0, verbose=None):\n '''Collocate the *real* density (opt. gradients) on the real-space grid.\n\n Args:\n cell : Mole or Cell object\n ao_kpts : (nkpts, ngrids, nao) ndarray\n AO values at each k-point\n dm_kpts: (nkpts, nao, nao) ndarray\n Density matrix at each k-point\n\n Returns:\n rhoR : (ngrids,) ndarray\n '''\n nkpts = len(ao_kpts)\n rhoR = 0\n for k in range(nkpts):\n rhoR += eval_rho(cell, ao_kpts[k], dm_kpts[k], non0tab, xctype,\n hermi, verbose)\n rhoR *= 1./nkpts\n return rhoR\n\n def eval_rho2(self, cell, ao_kpts, mo_coeff_kpts, mo_occ_kpts,\n non0tab=None, xctype='LDA', verbose=None):\n nkpts = len(ao_kpts)\n rhoR = 0\n for k in range(nkpts):\n rhoR += eval_rho2(cell, ao_kpts[k], mo_coeff_kpts[k],\n mo_occ_kpts[k], non0tab, xctype, verbose)\n rhoR *= 1./nkpts\n return rhoR\n\n def nr_vxc(self, cell, grids, xc_code, dms, spin=0, relativity=0, hermi=0,\n kpts=None, kpts_band=None, max_memory=2000, verbose=None):\n '''Evaluate RKS/UKS XC functional and potential matrix.\n See :func:`nr_rks` and :func:`nr_uks` for more details.\n '''\n if spin == 0:\n return self.nr_rks(cell, grids, xc_code, dms, hermi,\n kpts, kpts_band, max_memory, verbose)\n else:\n return self.nr_uks(cell, grids, xc_code, dms, hermi,\n kpts, kpts_band, max_memory, verbose)\n\n @lib.with_doc(nr_rks.__doc__)\n def nr_rks(self, cell, grids, xc_code, dms, hermi=0, kpts=None, kpts_band=None,\n max_memory=2000, verbose=None, **kwargs):\n if kpts is None:\n if 'kpt' in kwargs:\n sys.stderr.write('WARN: KNumInt.nr_rks function finds keyword '\n 'argument \"kpt\" and converts it to \"kpts\"\\n')\n kpts = kwargs['kpt']\n else:\n kpts = self.kpts\n kpts = kpts.reshape(-1,3)\n\n return nr_rks(self, cell, grids, xc_code, dms, 0, 0,\n hermi, kpts, kpts_band, max_memory, verbose)\n\n @lib.with_doc(nr_uks.__doc__)\n def nr_uks(self, cell, grids, xc_code, dms, hermi=0, kpts=None, kpts_band=None,\n max_memory=2000, verbose=None, **kwargs):\n if kpts is None:\n if 'kpt' in kwargs:\n sys.stderr.write('WARN: KNumInt.nr_uks function finds keyword '\n 'argument \"kpt\" and converts it to \"kpts\"\\n')\n kpts = kwargs['kpt']\n else:\n kpts = self.kpts\n kpts = kpts.reshape(-1,3)\n\n return nr_uks(self, cell, grids, xc_code, dms, 1, 0,\n hermi, kpts, kpts_band, max_memory, verbose)\n\n def eval_mat(self, cell, ao_kpts, weight, rho, vxc,\n non0tab=None, xctype='LDA', spin=0, verbose=None):\n nkpts = len(ao_kpts)\n nao = ao_kpts[0].shape[-1]\n dtype = numpy.result_type(*ao_kpts)\n mat = numpy.empty((nkpts,nao,nao), dtype=dtype)\n for k in range(nkpts):\n mat[k] = eval_mat(cell, ao_kpts[k], weight, rho, vxc,\n non0tab, xctype, spin, verbose)\n return mat\n\n def _fxc_mat(self, cell, ao_kpts, wv, non0tab, xctype, ao_loc):\n nkpts = len(ao_kpts)\n nao = ao_kpts[0].shape[-1]\n dtype = numpy.result_type(*ao_kpts)\n mat = numpy.empty((nkpts,nao,nao), dtype=dtype)\n for k in range(nkpts):\n mat[k] = _fxc_mat(cell, ao_kpts[k], wv, non0tab, xctype, ao_loc)\n return mat\n\n def block_loop(self, cell, grids, nao, deriv=0, kpts=numpy.zeros((1,3)),\n kpts_band=None, max_memory=2000, non0tab=None, blksize=None):\n '''Define this macro to loop over grids by blocks.\n '''\n if grids.coords is None:\n grids.build(with_non0tab=True)\n grids_coords = grids.coords\n grids_weights = grids.weights\n ngrids = grids_coords.shape[0]\n nkpts = len(kpts)\n comp = (deriv+1)*(deriv+2)*(deriv+3)//6\n# NOTE to index grids.non0tab, the blksize needs to be the integer multiplier of BLKSIZE\n if blksize is None:\n blksize = int(max_memory*1e6/(comp*2*nkpts*nao*16*BLKSIZE))*BLKSIZE\n blksize = max(BLKSIZE, min(blksize, ngrids, BLKSIZE*1200))\n if non0tab is None:\n non0tab = grids.non0tab\n if non0tab is None:\n non0tab = numpy.empty(((ngrids+BLKSIZE-1)//BLKSIZE,cell.nbas),\n dtype=numpy.uint8)\n non0tab[:] = 0xff\n if kpts_band is not None:\n kpts_band = numpy.reshape(kpts_band, (-1,3))\n where = [member(k, kpts) for k in kpts_band]\n where = [k_id[0] if len(k_id)>0 else None for k_id in where]\n\n for ip0 in range(0, ngrids, blksize):\n ip1 = min(ngrids, ip0+blksize)\n coords = grids_coords[ip0:ip1]\n weight = grids_weights[ip0:ip1]\n non0 = non0tab[ip0//BLKSIZE:]\n ao_k1 = ao_k2 = self.eval_ao(cell, coords, kpts, deriv=deriv, non0tab=non0)\n if kpts_band is not None:\n ao_k1 = self.eval_ao(cell, coords, kpts_band, deriv=deriv, non0tab=non0)\n yield ao_k1, ao_k2, non0, weight, coords\n ao_k1 = ao_k2 = None\n\n def _gen_rho_evaluator(self, cell, dms, hermi=0):\n if getattr(dms, 'mo_coeff', None) is not None:\n mo_coeff = dms.mo_coeff\n mo_occ = dms.mo_occ\n if isinstance(dms[0], numpy.ndarray) and dms[0].ndim == 2:\n mo_coeff = [mo_coeff]\n mo_occ = [mo_occ]\n nao = cell.nao_nr()\n ndms = len(mo_occ)\n def make_rho(idm, ao, non0tab, xctype):\n return self.eval_rho2(cell, ao, mo_coeff[idm], mo_occ[idm],\n non0tab, xctype)\n else:\n if isinstance(dms[0], numpy.ndarray) and dms[0].ndim == 2:\n dms = [numpy.stack(dms)]\n #if not hermi:\n # Density (or response of density) is always real for DFT.\n # Symmetrizing DM for gamma point should not change the value of\n # density. However, when k-point is considered, unless dm and\n # dm.conj().transpose produce the same real part of density, the\n # symmetrization code below may be incorrect (proof is needed).\n # # dm.shape = (nkpts, nao, nao)\n # dms = [(dm+dm.conj().transpose(0,2,1))*.5 for dm in dms]\n nao = dms[0].shape[-1]\n ndms = len(dms)\n def make_rho(idm, ao_kpts, non0tab, xctype):\n return self.eval_rho(cell, ao_kpts, dms[idm], non0tab, xctype,\n hermi=hermi)\n return make_rho, ndms, nao\n\n nr_rks_fxc = nr_rks_fxc\n nr_uks_fxc = nr_uks_fxc\n cache_xc_kernel = cache_xc_kernel\n get_rho = get_rho\n\n def rsh_and_hybrid_coeff(self, xc_code, spin=0):\n omega, alpha, hyb = numint.NumInt.rsh_and_hybrid_coeff(self, xc_code, spin)\n if abs(omega) > 1e-10:\n raise NotImplementedError\n return omega, alpha, hyb\n_KNumInt = KNumInt\n", "meta": {"hexsha": "9c267b8e26b6887484ca3e1c5f28fc8d09e2adb2", "size": 51943, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyscf/pbc/dft/numint.py", "max_stars_repo_name": "robert-anderson/pyscf", "max_stars_repo_head_hexsha": "cdc56e168cb15f47e8cdc791a92d689fa9b655af", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-05-28T05:25:56.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-09T02:16:43.000Z", "max_issues_repo_path": "pyscf/pbc/dft/numint.py", "max_issues_repo_name": "robert-anderson/pyscf", "max_issues_repo_head_hexsha": "cdc56e168cb15f47e8cdc791a92d689fa9b655af", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2019-09-16T17:58:31.000Z", "max_issues_repo_issues_event_max_datetime": "2019-09-22T17:26:01.000Z", "max_forks_repo_path": "pyscf/pbc/dft/numint.py", "max_forks_repo_name": "robert-anderson/pyscf", "max_forks_repo_head_hexsha": "cdc56e168cb15f47e8cdc791a92d689fa9b655af", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-11-09T02:13:16.000Z", "max_forks_repo_forks_event_max_datetime": "2019-11-09T02:13:16.000Z", "avg_line_length": 41.3558917197, "max_line_length": 95, "alphanum_fraction": 0.5456365632, "include": true, "reason": "import numpy", "num_tokens": 15472, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5660185498374789, "lm_q2_score": 0.35220179564702847, "lm_q1q2_score": 0.19935274962228713}} {"text": "# Copyright 2019-2021 Cambridge Quantum Computing\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\"\"\"Methods to allow tket circuits to be ran on ProjectQ simulator\n\"\"\"\n\nfrom typing import TYPE_CHECKING, Iterable, List, Optional\nfrom uuid import uuid4\nfrom logging import warning\n\nimport numpy as np\nimport projectq # type: ignore\nfrom projectq import MainEngine\nfrom projectq.backends import Simulator # type: ignore\nfrom projectq.cengines import ForwarderEngine # type: ignore\nfrom pytket.circuit import Circuit, OpType # type: ignore\nfrom pytket.circuit import Qubit # type: ignore\nfrom pytket.backends import (\n Backend,\n CircuitNotRunError,\n ResultHandle,\n CircuitStatus,\n StatusEnum,\n)\nfrom pytket.backends.resulthandle import _ResultIdTuple\nfrom pytket.backends.backendresult import BackendResult\nfrom pytket.passes import ( # type: ignore\n BasePass,\n RebaseProjectQ,\n SequencePass,\n SynthesiseIBM,\n FullPeepholeOptimise,\n DecomposeBoxes,\n FlattenRegisters,\n)\nfrom pytket.pauli import QubitPauliString # type: ignore\nfrom pytket.predicates import ( # type: ignore\n NoSymbolsPredicate,\n NoMidMeasurePredicate,\n GateSetPredicate,\n NoClassicalControlPredicate,\n NoFastFeedforwardPredicate,\n DefaultRegisterPredicate,\n Predicate,\n)\nfrom pytket.extensions.projectq.projectq_convert import tk_to_projectq\nfrom pytket.utils.operators import QubitPauliOperator\nfrom pytket.utils.results import KwargTypes\n\nif TYPE_CHECKING:\n from pytket.device import Device # type: ignore\n\n\ndef _default_q_index(q: Qubit) -> int:\n if q.reg_name != \"q\" or len(q.index) != 1:\n raise ValueError(\"Non-default qubit register\")\n return int(q.index[0])\n\n\nclass ProjectQBackend(Backend):\n \"\"\"Backend for running statevector simulations on the ProjectQ simulator.\"\"\"\n\n _supports_state = True\n _supports_expectation = True\n _expectation_allows_nonhermitian = False\n _persistent_handles = False\n\n @property\n def _result_id_type(self) -> _ResultIdTuple:\n return (str,)\n\n @property\n def device(self) -> \"Optional[Device]\":\n return None\n\n @property\n def required_predicates(self) -> List[Predicate]:\n return [\n NoClassicalControlPredicate(),\n NoFastFeedforwardPredicate(),\n NoSymbolsPredicate(),\n NoMidMeasurePredicate(),\n GateSetPredicate(\n {\n OpType.SWAP,\n OpType.CRz,\n OpType.CX,\n OpType.CZ,\n OpType.H,\n OpType.X,\n OpType.Y,\n OpType.Z,\n OpType.S,\n OpType.T,\n OpType.V,\n OpType.Rx,\n OpType.Ry,\n OpType.Rz,\n OpType.Barrier,\n }\n ),\n DefaultRegisterPredicate(),\n ]\n\n def default_compilation_pass(self, optimisation_level: int = 1) -> BasePass:\n assert optimisation_level in range(3)\n if optimisation_level == 0:\n return SequencePass(\n [DecomposeBoxes(), FlattenRegisters(), RebaseProjectQ()]\n )\n elif optimisation_level == 1:\n return SequencePass(\n [\n DecomposeBoxes(),\n FlattenRegisters(),\n SynthesiseIBM(),\n RebaseProjectQ(),\n ]\n )\n else:\n return SequencePass(\n [\n DecomposeBoxes(),\n FlattenRegisters(),\n FullPeepholeOptimise(),\n RebaseProjectQ(),\n ]\n )\n\n def process_circuits(\n self,\n circuits: Iterable[Circuit],\n n_shots: Optional[int] = None,\n valid_check: bool = True,\n **kwargs: KwargTypes,\n ) -> List[ResultHandle]:\n \"\"\"\n See :py:meth:`pytket.backends.Backend.process_circuits`.\n Supported kwargs: `seed`.\n \"\"\"\n circuit_list = list(circuits)\n if valid_check:\n self._check_all_circuits(circuit_list)\n\n handle_list = []\n for circuit in circuit_list:\n sim = Simulator(rnd_seed=kwargs.get(\"seed\"))\n fwd = ForwarderEngine(sim)\n eng = MainEngine(backend=sim, engine_list=[fwd])\n qureg = eng.allocate_qureg(circuit.n_qubits)\n tk_to_projectq(eng, qureg, circuit, True)\n eng.flush()\n state = np.array(\n eng.backend.cheat()[1], dtype=complex\n ) # `cheat()` returns tuple:(a dictionary of qubit indices, statevector)\n handle = ResultHandle(str(uuid4()))\n try:\n phase = float(circuit.phase)\n coeff = np.exp(phase * np.pi * 1j)\n state *= coeff\n except ValueError:\n warning(\n \"Global phase is dependent on a symbolic parameter, so cannot \"\n \"adjust for phase\"\n )\n implicit_perm = circuit.implicit_qubit_permutation()\n # reverse qubits as projectq state is dlo\n res_qubits = [\n implicit_perm[qb] for qb in sorted(circuit.qubits, reverse=True)\n ]\n measures = circuit.n_gates_of_type(OpType.Measure)\n if measures == 0 and n_shots is not None:\n backres = self.empty_result(circuit, n_shots=n_shots)\n else:\n backres = BackendResult(q_bits=res_qubits, state=state)\n self._cache[handle] = {\"result\": backres}\n handle_list.append(handle)\n return handle_list\n\n def circuit_status(self, handle: ResultHandle) -> CircuitStatus:\n if handle in self._cache:\n return CircuitStatus(StatusEnum.COMPLETED)\n raise CircuitNotRunError(handle)\n\n def _expectation_value(\n self,\n circuit: Circuit,\n hamiltonian: projectq.ops.QubitOperator,\n valid_check: bool = True,\n ) -> complex:\n if valid_check and not self.valid_circuit(circuit):\n raise ValueError(\n \"Circuits do not satisfy all required predicates for this backend\"\n )\n sim = Simulator()\n fwd = ForwarderEngine(sim)\n eng = MainEngine(backend=sim, engine_list=[fwd])\n qureg = eng.allocate_qureg(circuit.n_qubits)\n tk_to_projectq(eng, qureg, circuit)\n eng.flush()\n energy = eng.backend.get_expectation_value(hamiltonian, qureg)\n return complex(energy)\n\n def get_pauli_expectation_value(\n self,\n state_circuit: Circuit,\n pauli: QubitPauliString,\n valid_check: bool = True,\n ) -> complex:\n \"\"\"Calculates the expectation value of the given circuit using the built-in\n ProjectQ functionality\n\n :param state_circuit: Circuit that generates the desired state\n :math:`\\\\left|\\\\psi\\\\right>`.\n :type state_circuit: Circuit\n :param pauli: Pauli operator\n :type pauli: QubitPauliString\n :param valid_check: Explicitly check that the circuit satisfies all required\n predicates to run on the backend. Defaults to True\n :type valid_check: bool, optional\n :return: :math:`\\\\left<\\\\psi | P | \\\\psi \\\\right>`\n :rtype: complex\n \"\"\"\n pauli_tuple = tuple(\n (_default_q_index(q), p.name) for q, p in pauli.to_dict().items()\n )\n return self._expectation_value(\n state_circuit, projectq.ops.QubitOperator(pauli_tuple), valid_check\n )\n\n def get_operator_expectation_value(\n self,\n state_circuit: Circuit,\n operator: QubitPauliOperator,\n valid_check: bool = True,\n ) -> complex:\n \"\"\"Calculates the expectation value of the given circuit with respect to the\n operator using the built-in ProjectQ functionality\n\n :param state_circuit: Circuit that generates the desired state\n :math:`\\\\left|\\\\psi\\\\right>`.\n :type state_circuit: Circuit\n :param operator: Operator :math:`H`. Must be Hermitian.\n :type operator: QubitPauliOperator\n :param valid_check: Explicitly check that the circuit satisfies all required\n predicates to run on the backend. Defaults to True\n :type valid_check: bool, optional\n :return: :math:`\\\\left<\\\\psi | H | \\\\psi \\\\right>`\n :rtype: complex\n \"\"\"\n ham = projectq.ops.QubitOperator()\n for term, coeff in operator._dict.items():\n if type(coeff) is complex and abs(coeff.imag) > 1e-12:\n raise ValueError(\n \"Operator is not Hermitian and cannot be converted to \"\n \"`projectq.ops.QubitOperator`.\"\n )\n ham += projectq.ops.QubitOperator(\n tuple((_default_q_index(q), p.name) for q, p in term.to_dict().items()),\n float(coeff),\n )\n return self._expectation_value(state_circuit, ham, valid_check)\n", "meta": {"hexsha": "8261d352dd843f221fbe063b92b423b36f5a341c", "size": 9672, "ext": "py", "lang": "Python", "max_stars_repo_path": "modules/pytket-projectq/pytket/extensions/projectq/backends/projectq_backend.py", "max_stars_repo_name": "isobelhooper/pytket-extensions", "max_stars_repo_head_hexsha": "53e1f40844fff29814a599d70a61963c27f094f2", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "modules/pytket-projectq/pytket/extensions/projectq/backends/projectq_backend.py", "max_issues_repo_name": "isobelhooper/pytket-extensions", "max_issues_repo_head_hexsha": "53e1f40844fff29814a599d70a61963c27f094f2", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "modules/pytket-projectq/pytket/extensions/projectq/backends/projectq_backend.py", "max_forks_repo_name": "isobelhooper/pytket-extensions", "max_forks_repo_head_hexsha": "53e1f40844fff29814a599d70a61963c27f094f2", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.299270073, "max_line_length": 88, "alphanum_fraction": 0.6033912324, "include": true, "reason": "import numpy", "num_tokens": 2130, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.577495350642608, "lm_q2_score": 0.34510528442897664, "lm_q1q2_score": 0.19929669723992885}} {"text": "\"\"\"Define Logger class for logging information to stdout and disk.\"\"\"\nimport collections\nimport os\nimport json\nimport torch\nimport numpy as np\nimport time\nimport torchvision\nfrom os.path import join\n\n\ndef xywh2xyxy(x):\n y = x.new(x.shape)\n y[..., 0] = x[..., 0] - x[..., 2] / 2\n y[..., 1] = x[..., 1] - x[..., 3] / 2\n y[..., 2] = x[..., 0] + x[..., 2] / 2\n y[..., 3] = x[..., 1] + x[..., 3] / 2\n return y\n\n\ndef bbox_iou(box1, box2, x1y1x2y2=True):\n \"\"\"\n Returns the IoU of two bounding boxes\n \"\"\"\n if not x1y1x2y2:\n # Transform from center and width to exact coordinates\n b1_x1, b1_x2 = box1[:, 0] - box1[:, 2] / 2, box1[:, 0] + box1[:, 2] / 2\n b1_y1, b1_y2 = box1[:, 1] - box1[:, 3] / 2, box1[:, 1] + box1[:, 3] / 2\n b2_x1, b2_x2 = box2[:, 0] - box2[:, 2] / 2, box2[:, 0] + box2[:, 2] / 2\n b2_y1, b2_y2 = box2[:, 1] - box2[:, 3] / 2, box2[:, 1] + box2[:, 3] / 2\n else:\n # Get the coordinates of bounding boxes\n b1_x1, b1_y1, b1_x2, b1_y2 = (box1[:, 0], box1[:, 1],\n box1[:, 2], box1[:, 3])\n b2_x1, b2_y1, b2_x2, b2_y2 = (box2[:, 0], box2[:, 1],\n box2[:, 2], box2[:, 3])\n\n # get the corrdinates of the intersection rectangle\n inter_rect_x1 = torch.max(b1_x1, b2_x1)\n inter_rect_y1 = torch.max(b1_y1, b2_y1)\n inter_rect_x2 = torch.min(b1_x2, b2_x2)\n inter_rect_y2 = torch.min(b1_y2, b2_y2)\n # Intersection area\n inter_area = (torch.clamp(inter_rect_x2 - inter_rect_x1 + 1, min=0) *\n torch.clamp(inter_rect_y2 - inter_rect_y1 + 1, min=0))\n # Union Area\n b1_area = (b1_x2 - b1_x1 + 1) * (b1_y2 - b1_y1 + 1)\n b2_area = (b2_x2 - b2_x1 + 1) * (b2_y2 - b2_y1 + 1)\n\n iou = inter_area / (b1_area + b2_area - inter_area + 1e-16)\n\n return iou\n\n\ndef bbox_wh_iou(wh1, wh2):\n wh2 = wh2.t()\n w1, h1 = wh1[0], wh1[1]\n w2, h2 = wh2[0], wh2[1]\n inter_area = torch.min(w1, w2) * torch.min(h1, h2)\n union_area = (w1 * h1 + 1e-16) + w2 * h2 - inter_area\n return inter_area / union_area\n\n\ndef build_targets(pred_boxes, target, anchors, ignore_thres):\n\n ByteTensor = torch.cuda.ByteTensor if pred_boxes.is_cuda\\\n else torch.ByteTensor\n FloatTensor = torch.cuda.FloatTensor if pred_boxes.is_cuda\\\n else torch.FloatTensor\n\n nB = pred_boxes.size(0)\n nA = pred_boxes.size(1)\n nG = pred_boxes.size(2)\n\n # Output tensors\n obj_mask = ByteTensor(nB, nA, nG, nG).fill_(0)\n noobj_mask = ByteTensor(nB, nA, nG, nG).fill_(1)\n iou_scores = FloatTensor(nB, nA, nG, nG).fill_(0)\n tx = FloatTensor(nB, nA, nG, nG).fill_(0)\n ty = FloatTensor(nB, nA, nG, nG).fill_(0)\n tw = FloatTensor(nB, nA, nG, nG).fill_(0)\n th = FloatTensor(nB, nA, nG, nG).fill_(0)\n\n # Convert to position relative to box\n target_boxes = target[:, 2:6] * nG\n gxy = target_boxes[:, :2]\n gwh = target_boxes[:, 2:]\n # Get anchors with best iou\n ious = torch.stack([bbox_wh_iou(anchor, gwh) for anchor in anchors])\n best_ious, best_n = ious.max(0)\n # Separate target values\n b, target_labels = target[:, :2].long().t()\n gx, gy = gxy.t()\n gw, gh = gwh.t()\n gi, gj = gxy.long().t()\n # Set masks\n obj_mask[b, best_n, gj, gi] = 1\n noobj_mask[b, best_n, gj, gi] = 0\n\n # Set noobj mask to zero where iou exceeds ignore threshold\n for i, anchor_ious in enumerate(ious.t()):\n noobj_mask[b[i], anchor_ious > ignore_thres, gj[i], gi[i]] = 0\n\n # Coordinates\n tx[b, best_n, gj, gi] = gx - gx.floor()\n ty[b, best_n, gj, gi] = gy - gy.floor()\n # Width and height\n tw[b, best_n, gj, gi] = torch.log(gw / anchors[best_n][:, 0] + 1e-16)\n th[b, best_n, gj, gi] = torch.log(gh / anchors[best_n][:, 1] + 1e-16)\n\n iou_scores[b, best_n, gj, gi] = bbox_iou(\n pred_boxes[b, best_n, gj, gi], target_boxes, x1y1x2y2=False)\n\n tconf = obj_mask.float()\n return (iou_scores, obj_mask, noobj_mask,\n tx, ty, tw, th, tconf)\n\n\ndef slice_boundary(t, width):\n \"\"\"Assumes shape (B, C, W, H, ...).\"\"\"\n if not isinstance(width, int):\n raise ValueError(f\"ignore_width must be an integer. Got {width}.\")\n if width < 0:\n raise ValueError(f\"ignore_width must be positive. Got {width}.\")\n if width > t.shape[2] // 2:\n raise ValueError(\"ignore_width * 2 must be less than image dim. \" +\n f\"Got {width}.\")\n\n if width != 0:\n return t[:, :, width:-width, width:-width].contiguous()\n else:\n return t\n\n\ndef parse_model_config(path, num_classes=80):\n \"\"\"Parses the yolo-v3 layer configuration file and returns module definitions\"\"\"\n file = open(path, 'r')\n lines = file.read().split('\\n')\n lines = [x for x in lines if x and not x.startswith('#')]\n lines = [x.rstrip().lstrip()\n for x in lines] # get rid of fringe whitespaces\n module_defs = []\n for line in lines:\n if line.startswith('['): # This marks the start of a new block\n module_defs.append({})\n module_defs[-1]['type'] = line[1:-1].rstrip()\n if module_defs[-1]['type'] == 'convolutional':\n module_defs[-1]['batch_normalize'] = 0\n else:\n key, value = line.split(\"=\")\n value = value.strip()\n module_defs[-1][key.rstrip()] = value.strip()\n\n # Overwrite number of classes\n yolo_layers = []\n for i, module_def in enumerate(module_defs):\n if module_def['type'] == 'yolo':\n yolo_layers.append(i)\n module_defs[i]['classes'] = str(num_classes)\n\n for i in yolo_layers:\n module_defs[i - 1]['filters'] = str((num_classes + 5) * 3)\n\n return module_defs\n\n\ndef parse_data_config(path):\n \"\"\"Parses the data configuration file\"\"\"\n options = dict()\n options['gpus'] = '0,1,2,3'\n options['num_workers'] = '10'\n with open(path, 'r') as fp:\n lines = fp.readlines()\n for line in lines:\n line = line.strip()\n if line == '' or line.startswith('#'):\n continue\n key, value = line.split('=')\n options[key.strip()] = value.strip()\n return options\n\n\ndef to_cpu(tensor):\n return tensor.detach().cpu()\n\n\ndef xy_to_cxcy(xy, height, width):\n return [(xy[0] + xy[2]) / 2 / width,\n (xy[1] + xy[3]) / 2 / height,\n (xy[2] - xy[0]) / width,\n (xy[3] - xy[1]) / height]\n\n\ndef non_max_suppression(\n prediction,\n conf_thres=0.25,\n iou_thres=0.45,\n classes=None,\n agnostic=False,\n labels=()):\n \"\"\"Performs Non-Maximum Suppression (NMS) on inference results\n Returns:\n detections with shape: nx6 (x1, y1, x2, y2, conf, cls)\n \"\"\"\n\n nc = prediction.shape[2] - 5 # number of classes\n xc = prediction[..., 4] > conf_thres # candidates\n\n # Settings\n # (pixels) minimum and maximum box width and height\n min_wh, max_wh = 2, 4096\n max_det = 300 # maximum number of detections per image\n max_nms = 30000 # maximum number of boxes into torchvision.ops.nms()\n time_limit = 20.0 # seconds to quit after\n redundant = True # require redundant detections\n multi_label = nc > 1 # multiple labels per box (adds 0.5ms/img)\n merge = False # use merge-NMS\n\n t = time.time()\n output = [torch.zeros((0, 6), device=prediction.device)\n ] * prediction.shape[0]\n for xi, x in enumerate(prediction): # image index, image inference\n # Apply constraints\n # x[((x[..., 2:4] < min_wh) | (x[..., 2:4] > max_wh)).any(1), 4] = 0 #\n # width-height\n x = x[xc[xi]] # confidence\n\n # Cat apriori labels if autolabelling\n if labels and len(labels[xi]):\n l = labels[xi]\n v = torch.zeros((len(l), nc + 5), device=x.device)\n v[:, :4] = l[:, 1:5] # box\n v[:, 4] = 1.0 # conf\n v[range(len(l)), l[:, 0].long() + 5] = 1.0 # cls\n x = torch.cat((x, v), 0)\n\n # If none remain process next image\n if not x.shape[0]:\n continue\n\n # Compute conf\n x[:, 5:] *= x[:, 4:5] # conf = obj_conf * cls_conf\n\n # Box (center x, center y, width, height) to (x1, y1, x2, y2)\n box = xywh2xyxy(x[:, :4])\n\n # Detections matrix nx6 (xyxy, conf, cls)\n if multi_label:\n i, j = (x[:, 5:] > conf_thres).nonzero(as_tuple=False).T\n x = torch.cat((box[i], x[i, j + 5, None], j[:, None].float()), 1)\n else: # best class only\n conf, j = x[:, 5:].max(1, keepdim=True)\n x = torch.cat((box, conf, j.float()), 1)[conf.view(-1) > conf_thres]\n\n # Filter by class\n if classes is not None:\n x = x[(x[:, 5:6] == torch.tensor(classes, device=x.device)).any(1)]\n\n # Apply finite constraint\n # if not torch.isfinite(x).all():\n # x = x[torch.isfinite(x).all(1)]\n\n # Check shape\n n = x.shape[0] # number of boxes\n if not n: # no boxes\n continue\n elif n > max_nms: # excess boxes\n # sort by confidence\n x = x[x[:, 4].argsort(descending=True)[:max_nms]]\n\n # Batched NMS\n c = x[:, 5:6] * (0 if agnostic else max_wh) # classes\n boxes, scores = x[:, :4] + c, x[:, 4] # boxes (offset by class), scores\n i = torchvision.ops.nms(boxes, scores, iou_thres) # NMS\n if i.shape[0] > max_det: # limit detections\n i = i[:max_det]\n if merge and (\n 1 < n < 3E3): # Merge NMS (boxes merged using weighted mean)\n # update boxes as boxes(i,4) = weights(i,n) * boxes(n,4)\n iou = box_iou(boxes[i], boxes) > iou_thres # iou matrix\n weights = iou * scores[None] # box weights\n x[i, :4] = torch.mm(weights, x[:, :4]).float(\n ) / weights.sum(1, keepdim=True) # merged boxes\n if redundant:\n i = i[iou.sum(1) > 1] # require redundancy\n\n output[xi] = x[i]\n if (time.time() - t) > time_limit:\n print(f'WARNING: NMS time limit {time_limit}s exceeded')\n break # time limit exceeded\n\n return output\n", "meta": {"hexsha": "db71c12addb9a78b7cb0b03d2dc1424377b12cc7", "size": 10186, "ext": "py", "lang": "Python", "max_stars_repo_path": "detection/models/detection/yolo/utils.py", "max_stars_repo_name": "stanford-policylab/surveilling-surveillance", "max_stars_repo_head_hexsha": "bbb9a147927a6342eecfe07ffa756b3acdb63f35", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2021-05-21T03:38:52.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-21T08:32:41.000Z", "max_issues_repo_path": "detection/models/detection/yolo/utils.py", "max_issues_repo_name": "stanford-policylab/surveilling-surveillance", "max_issues_repo_head_hexsha": "bbb9a147927a6342eecfe07ffa756b3acdb63f35", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "detection/models/detection/yolo/utils.py", "max_forks_repo_name": "stanford-policylab/surveilling-surveillance", "max_forks_repo_head_hexsha": "bbb9a147927a6342eecfe07ffa756b3acdb63f35", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-06-13T21:49:14.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-13T21:49:14.000Z", "avg_line_length": 34.7645051195, "max_line_length": 84, "alphanum_fraction": 0.5511486354, "include": true, "reason": "import numpy", "num_tokens": 3263, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.577495350642608, "lm_q2_score": 0.34510528442897664, "lm_q1q2_score": 0.19929669723992885}} {"text": "from collections import OrderedDict\nfrom numpy import (int64, int32, int16, ndarray)\nfrom scipy.sparse import issparse\n\nfrom ..QuantumToolbox import operators as qOps #pylint: disable=relative-beyond-top-level\nfrom ..QuantumToolbox import linearAlgebra as linAlg #pylint: disable=relative-beyond-top-level\nfrom ..QuantumToolbox import states as qSta #pylint: disable=relative-beyond-top-level\n\nfrom .base import addDecorator, _recurseIfList\nfrom .baseClasses import qBaseSim, paramBoundBase, setAttr\n#from quanguru.classes.exceptions import qSystemInitErrors, qCouplingInitErrors\nfrom .QPro import freeEvolution\n\ndef _initStDec(_createAstate):\n def wrapper(obj, inp=None):\n if (issparse(inp) or isinstance(inp, ndarray)):\n if inp.shape[0] != obj.dimension:\n raise ValueError('Dimension mismatch')\n state = inp\n else:\n if inp is None:\n inp = obj.simulation._stateBase__initialStateInput.value\n\n if isinstance(obj.dimension, int):\n state = _createAstate(obj, inp)\n else:\n state = None\n return state\n return wrapper\n\ndef _computeDef(sys, state): # pylint: disable=unused-argument\n pass\n\ndef _calculateDef(sys): # pylint: disable=unused-argument\n pass\n\nclass genericQSys(qBaseSim):\n r\"\"\"\n Base class for both single (:class:`~qSystem`) and composite (:class:`~compQSystem`) quantum system classes.\n The ultimate goal is to make those two classes the same by combining them in here. Currently, a proxy\n :class:`~QuantumSystem` is introduced as a temporary solution.\n \"\"\"\n label = 'genericQSys'\n #: (**class attribute**) number of instances created internally by the library\n _internalInstances: int = 0\n #: (**class attribute**) number of instances created explicitly by the user\n _externalInstances: int = 0\n #: (**class attribute**) number of total instances = _internalInstances + _externalInstances\n _instances: int = 0\n\n __slots__ = ['__unitary', '__dimension', '__dimsBefore', '__dimsAfter', '_inpCoef']\n\n def __init__(self, **kwargs):\n super().__init__()\n #: an internal :class:`~freeEvolution` protocol, this is the default evolution when a simulation is run.\n self.__unitary = freeEvolution(_internal=True)\n self._genericQSys__unitary.superSys = self # pylint: disable=no-member\n self._qBaseSim__simulation.addQSystems(subS=self, Protocol=self._freeEvol) # pylint: disable=no-member\n #: dimension of Hilbert space of the quantum system\n self.__dimension = None\n #: boolean to determine whether initialState inputs contains complex coefficients (the probability amplitudes)\n #: or the populations\n self._inpCoef = False\n self.__dimsBefore = 1\n self.__dimsAfter = 1\n self._named__setKwargs(**kwargs) # pylint: disable=no-member\n\n def __add__(self, other):\n if isinstance(self, compQSystem) and isinstance(other, qSystem):\n self.addSubSys(other)\n newComp = self\n elif ((isinstance(self, qSystem) and isinstance(other, qSystem)) or # noqa: W504\n (isinstance(self, compQSystem) and isinstance(other, compQSystem))):\n newComp = compQSystem()\n # FIXME 'stepCount' getter creates problem with None defaults\n newComp.simulation._copyVals(self.simulation, ['totalTime', 'stepSize', 'delStates'])\n newComp.compute = _computeDef\n newComp.simulation.compute = _computeDef\n #newComp.calculate = _calculateDef\n #newComp.simulation.calculate = _calculateDef\n newComp.addSubSys(self)\n if other is self:\n newComp.addSubSys(other.copy())\n else:\n newComp.addSubSys(other)\n elif isinstance(self, qSystem) and isinstance(other, compQSystem):\n other.addSubSys(self)\n newComp = other\n elif isinstance(other, (float, int)):\n newComp = self\n return newComp\n\n def __sub__(self, other):\n self.removeSubSys(other, _exclude=[])\n return self\n\n def __rmul__(self, other):\n newComp = compQSystem()\n newComp.addSubSys(self)\n for _ in range(other - 1):\n newComp.addSubSys(self.copy())\n return newComp\n\n def copy(self, **kwargs): # pylint: disable=arguments-differ\n subSysList = []\n for sys in self.subSys.values():\n subSysList.append(sys.copy())\n\n if isinstance(self, qSystem):\n newSys = super().copy(dimension=self.dimension, terms=subSysList)\n elif isinstance(self, compQSystem):\n newSys = super().copy()\n for sys in subSysList:\n newSys.addSubSys(sys)\n\n if self.simulation._stateBase__initialStateInput._value is not None:\n newSys.initialState = self.simulation._stateBase__initialStateInput.value\n newSys._named__setKwargs(**kwargs)\n return newSys\n\n @property\n def ind(self):\n ind = 0\n if self.superSys is not None:\n ind += list(self.superSys.subSys.values()).index(self)\n if self.superSys.superSys is not None:\n ind += self.superSys.ind\n return ind\n\n @property\n def _dimsBefore(self):\n return self._genericQSys__dimsBefore if self._genericQSys__dimsBefore != 0 else 1\n\n @_dimsBefore.setter\n def _dimsBefore(self, val):\n if not isinstance(val, int):\n raise ValueError('?')\n oldVal = self._dimsBefore\n setAttr(self, '_genericQSys__dimsBefore', val)\n for sys in self.subSys.values():\n sys.delMatrices(_exclude=[]) # pylint: disable=protected-access\n if isinstance(sys, genericQSys):\n sys._dimsBefore = int((sys._dimsBefore*val)/oldVal)\n\n @property\n def _dimsAfter(self):\n return self._genericQSys__dimsAfter if self._genericQSys__dimsAfter != 0 else 1\n\n @_dimsAfter.setter\n def _dimsAfter(self, val):\n if not isinstance(val, int):\n raise ValueError('?')\n oldVal = self._dimsAfter\n setAttr(self, '_genericQSys__dimsAfter', val)\n for sys in self.subSys.values():\n sys.delMatrices(_exclude=[]) # pylint: disable=protected-access\n if isinstance(sys, genericQSys):\n sys._dimsAfter = int((sys._dimsAfter*val)/oldVal)\n\n @property\n def dimension(self):\n if self._genericQSys__dimension is None:\n try:\n dims = self.subSysDimensions\n self._genericQSys__dimension = 1 # pylint: disable=assigning-non-slot\n for val in dims:\n self._genericQSys__dimension *= val # pylint: disable=assigning-non-slot\n except AttributeError:\n print(f'dimension? {self.name}')\n return self._genericQSys__dimension\n\n @property\n def _totalDim(self):\n return self.dimension * self._dimsBefore * self._dimsAfter#pylint:disable=E1101\n\n @property\n def _freeEvol(self):\n return self._genericQSys__unitary\n\n @property\n def unitary(self):\n unitary = self._genericQSys__unitary.unitary\n self._paramBoundBase__paramUpdated = False # pylint: disable=assigning-non-slot\n return unitary\n\n @qBaseSim.initialState.setter # pylint: disable=no-member\n def initialState(self, inp):\n if self.superSys is not None:\n self.superSys.simulation._stateBase__initialState._value = None\n self.simulation.initialState = inp # pylint: disable=no-member, protected-access\n if (isinstance(self, compQSystem) and isinstance(inp, list)):\n for ind, it in enumerate(inp):\n list(self.qSystems.values())[ind].initialState = it # pylint: disable=no-member\n\n def _constructMatrices(self):\n for sys in self.subSys.values():\n sys._constructMatrices() # pylint: disable=protected-access\n\n def addProtocol(self, protocol=None, system=None, protocolRemove=None):\n if system is None:\n system = self\n self.simulation.addProtocol(protocol=protocol, system=system, protocolRemove=protocolRemove)\n\n def _timeDependency(self, time=None):\n if time is None:\n time = self.simulation._currentTime\n for sys in self.subSys.values():\n sys._timeDependency(time)\n return time\n\nclass QuantumSystem(genericQSys):\n #: (**class attribute**) number of instances created internally by the library\n _internalInstances: int = 0\n #: (**class attribute**) number of instances created explicitly by the user\n _externalInstances: int = 0\n #: (**class attribute**) number of total instances = _internalInstances + _externalInstances\n _instances: int = 0\n def __new__(cls, sysType='composite', **kwargs):\n singleKeys = ['frequency', 'operator', 'order', 'dimension']\n for key in singleKeys:\n if key in kwargs.keys():\n sysType = 'single'\n\n if sysType == 'composite':\n newCls = compQSystem\n elif sysType == 'single':\n newCls = qSystem\n elif sysType == 'system coupling':\n newCls = qCoupling\n\n if newCls != cls:\n instance = newCls(**kwargs)\n return instance\n\n __slots__ = []\n\nclass compQSystem(genericQSys):\n label = 'QuantumSystem'\n #: (**class attribute**) number of instances created internally by the library\n _internalInstances: int = 0\n #: (**class attribute**) number of instances created explicitly by the user\n _externalInstances: int = 0\n #: (**class attribute**) number of total instances = _internalInstances + _externalInstances\n _instances: int = 0\n\n __slots__ = ['__qCouplings', '__qSystems', 'couplingName']\n\n def __init__(self, **kwargs):\n if self.__class__.__name__ == 'compQSystem':\n compQSystem._externalInstances = qSystem._instances + compQSystem._instances\n super().__init__()\n self.__qCouplings = OrderedDict()\n self.__qSystems = OrderedDict()\n self.couplingName = None\n\n self._named__setKwargs(**kwargs) # pylint: disable=no-member\n\n def _timeDependency(self, time=None):\n time = super()._timeDependency(time=time)\n for coupling in self.qCouplings.values():\n coupling._timeDependency(time)\n\n @property\n def subSysDimensions(self):\n return [sys.dimension for sys in self.subSys.values()]\n\n @property\n def freeHam(self):\n ham = sum([val.totalHam for val in self.qSystems.values()])\n return ham\n\n @property\n def totalHam(self): # pylint: disable=invalid-overridden-method\n if ((self._paramUpdated) or (self._paramBoundBase__matrix is None)): # pylint: disable=no-member\n self._paramBoundBase__matrix = self.freeHam + self.couplingHam # pylint: disable=assigning-non-slot\n self._paramBoundBase__paramUpdated = False # pylint: disable=assigning-non-slot\n return self._paramBoundBase__matrix # pylint: disable=no-member\n\n @property\n def couplingHam(self):\n cham = sum([val.totalHam for val in self.qCouplings.values()])\n return cham\n\n @property\n def qSystems(self):\n return self._compQSystem__qSystems # pylint: disable=no-member\n\n @addDecorator\n def addSubSys(self, subSys, **kwargs): # pylint: disable=arguments-differ\n newSys = super().addSubSys(subSys, **kwargs)\n if isinstance(newSys, qCoupling):\n self._compQSystem__addCoupling(self._qBase__subSys.pop(newSys.name)) # pylint: disable=no-member\n elif isinstance(newSys, genericQSys):\n self._compQSystem__addSub(newSys)\n else:\n raise TypeError('?')\n newSys._paramBoundBase__paramBound[self.name] = self # pylint: disable=protected-access\n return newSys\n\n def createSubSys(self, subSysClass, **kwargs):\n return self.addSubSys(subSysClass, **kwargs)\n\n def __addSub(self, subSys):\n for subS in self._compQSystem__qSystems.values():\n subS._dimsAfter *= subSys.dimension\n subSys._dimsBefore *= subS.dimension\n\n if subSys._paramBoundBase__matrix is not None:\n for sys in subSys.subSys.values():\n sys._paramBoundBase__matrix = None\n # TODO big question here\n subSys.simulation._bound(self.simulation) # pylint: disable=protected-access\n self._compQSystem__qSystems[subSys.name] = subSys\n subSys.superSys = self\n return subSys\n\n @_recurseIfList\n def removeSubSys(self, subS, _exclude=[]):#pylint:disable=arguments-differ,dangerous-default-value,too-many-branches\n if isinstance(subS, str):\n subS = self.getByNameOrAlias(subS)\n couplings = list(self.qCouplings.values())\n for coupling in couplings:\n coupling.removeSubSys(subS, _exclude=_exclude)\n if len(coupling._qBase__subSys) == 0: # pylint: disable=protected-access\n self.qCouplings.pop(coupling.name)\n\n if subS in list(self.subSys.values()):\n for qS in self.subSys.values():\n qS.simulation._stateBase__initialState._value = None\n if qS.ind < subS.ind:\n qS._dimsAfter = int(qS._dimsAfter/subS.dimension)\n elif qS.ind > subS.ind:\n qS._dimsBefore = int(qS._dimsBefore/subS.dimension)\n self.qSystems.pop(subS.name)\n _exclude.append(self)\n super().removeSubSys(subS, _exclude=_exclude)\n elif subS in self.qCouplings.values():\n self.qCouplings.pop(subS.name)\n\n if self not in _exclude:\n _exclude.append(self)\n if ((self._dimsAfter != 1) or (self._dimsBefore != 1)):\n if self.ind < subS.superSys.ind:\n self._dimsAfter = int(self._dimsAfter/subS.dimension)\n elif self.ind > subS.superSys.ind:\n self._dimsBefore = int(self._dimsBefore/subS.dimension)\n\n for sys in self.subSys.values():\n sys.removeSubSys(subS, _exclude=_exclude)\n #_exclude.append(sys)\n\n if self.superSys is not None:\n self.superSys.removeSubSys(subS, _exclude=_exclude)\n _exclude.append(self.superSys)\n\n self.delMatrices(_exclude=[])\n self.simulation._stateBase__initialState._value = None\n self._genericQSys__dimension = None # pylint: disable=assigning-non-slot\n\n @property\n def qCouplings(self):\n return self._compQSystem__qCouplings\n\n def __addCoupling(self, couplingObj):\n self._compQSystem__qCouplings[couplingObj.name] = couplingObj\n couplingObj.superSys = self\n return couplingObj\n\n def createSysCoupling(self, *args, **kwargs):\n newCoupling = self.addSubSys(qCoupling, **kwargs)\n newCoupling.addTerm(*args)\n return newCoupling\n\n def addSysCoupling(self, couplingObj):\n self.addSubSys(couplingObj)\n\n @_initStDec\n def _createAstate(self, inp=None):\n if inp is None:\n inp = [qsys._createAstate() for qsys in self.subSys.values()]\n elif isinstance(inp, list):\n inp = [qsys._createAstate(inp[qsys.ind]) for qsys in self.subSys.values()]\n else:\n raise TypeError('?')\n return linAlg.tensorProd(*inp)\n\n def _constructMatrices(self):\n super()._constructMatrices()\n for sys in self.qCouplings.values():\n sys._constructMatrices() # pylint: disable=protected-access\n\n def updateDimension(self, qSys, newDimVal, oldDimVal=None, _exclude=[]):#pylint:disable=dangerous-default-value,too-many-branches\n # TODO can be combined with removeSubSys by a decorator or another method to simplfy both\n if oldDimVal is None:\n oldDimVal = qSys._genericQSys__dimension\n self._genericQSys__dimension = None # pylint: disable=assigning-non-slot\n if qSys in self.qSystems.values():\n _exclude.append(self)\n qSys._genericQSys__dimension = newDimVal\n ind = qSys.ind\n for qS in self.qSystems.values():\n if qS.ind < ind:\n qS._dimsAfter = int((qS._dimsAfter*newDimVal)/oldDimVal)\n elif qS.ind > ind:\n qS._dimsBefore = int((qS._dimsBefore*newDimVal)/oldDimVal)\n\n #if self.simulation._stateBase__initialStateInput.value is not None: # pylint: disable=no-member\n # self.initialState = self.simulation._stateBase__initialStateInput.value # pylint: disable=no-member\n self._paramUpdated = True\n #self._constructMatrices()\n #for sys in self.subSys.values():\n # if sys.simulation._stateBase__initialStateInput.value is not None:\n # sys.initialState = sys.simulation._stateBase__initialStateInput.value\n\n if self not in _exclude:\n _exclude.append(self)\n if ((self._dimsAfter != 1) or (self._dimsBefore != 1)):\n if self.ind < qSys.superSys.ind:\n self._dimsAfter = int((self._dimsAfter*newDimVal)/oldDimVal)\n elif self.ind > qSys.superSys.ind:\n self._dimsBefore = int((self._dimsBefore*newDimVal)/oldDimVal)\n else:\n for sys in self.subSys.values():\n if sys not in _exclude:\n _exclude.append(sys)\n if sys.ind < qSys.superSys.ind:\n sys._dimsAfter = int((sys._dimsAfter*newDimVal)/oldDimVal)\n elif sys.ind > qSys.superSys.ind:\n sys._dimsBefore = int((sys._dimsBefore*newDimVal)/oldDimVal)\n\n if self.superSys is not None:\n self.superSys.updateDimension(qSys=qSys, newDimVal=newDimVal, oldDimVal=oldDimVal, _exclude=_exclude)\n self.delMatrices(_exclude=[])\n for c in self.qCouplings.values():\n c.delMatrices(_exclude=[])\n return qSys\n\nclass termTimeDep(paramBoundBase):\n label = '_timeDep'\n #: (**class attribute**) number of instances created internally by the library\n _internalInstances: int = 0\n #: (**class attribute**) number of instances created explicitly by the user\n _externalInstances: int = 0\n #: (**class attribute**) number of total instances = _internalInstances + _externalInstances\n _instances: int = 0\n\n __slots__ = ['timeDependency', '__frequency', '__order', '__operator']\n\n def __init__(self, **kwargs):\n super().__init__()\n self.timeDependency = None\n self.__frequency = None\n self.__order = 1\n self.__operator = None\n self._named__setKwargs(**kwargs) # pylint: disable=no-member\n\n def copy(self, **kwargs): # pylint: disable=arguments-differ\n newSys = super().copy(frequency=self.frequency, operator=self.operator, order=self.order, **kwargs)\n return newSys\n\n @property\n def operator(self):\n return self._termTimeDep__operator\n\n @operator.setter\n def operator(self, op):\n self._paramBoundBase__matrix = None # pylint: disable=assigning-non-slot\n setAttr(self, '_termTimeDep__operator', op)\n\n @property\n def order(self):\n return self._termTimeDep__order\n\n @order.setter\n def order(self, ordVal):\n setAttr(self, '_termTimeDep__order', ordVal)\n if self._paramBoundBase__matrix is not None: # pylint: disable=no-member\n self.freeMat = None\n\n @property\n def frequency(self):\n return self._termTimeDep__frequency\n\n @frequency.setter\n def frequency(self, freq):\n freq = 0 if freq == 0.0 else freq\n setAttr(self, '_termTimeDep__frequency', freq)\n\n def _constructMatrices(self):\n pass\n\n @property\n def totalHam(self):\n return self.frequency*self.freeMat\n\n @property\n def freeMat(self):\n #if ((self._paramBoundBase__matrix is None) or (self._paramUpdated)): # pylint: disable=no-member\n if self._paramBoundBase__matrix is None: # pylint: disable=no-member\n self.freeMat = None\n self._paramBoundBase__paramUpdated = False # pylint: disable=assigning-non-slot\n return self._paramBoundBase__matrix # pylint: disable=no-member\n\n @freeMat.setter\n def freeMat(self, qMat):\n if qMat is not None:\n self._paramBoundBase__matrix = qMat # pylint: disable=no-member, assigning-non-slot\n else:\n #if len(self._qBase__subSys) == 0: # pylint: disable=no-member\n # raise ValueError('No operator is given for coupling Hamiltonian')\n #if self.operator is None:\n # raise ValueError('No operator is given for free Hamiltonian')\n self._constructMatrices()\n\n def _timeDependency(self, time=None):\n if time is None:\n time = self.superSys.simulation._currentTime\n\n if callable(self.timeDependency):\n if hasattr(self, 'frequency'):\n self.frequency = self.timeDependency(self, time) # pylint: disable=assigning-non-slot,not-callable\n elif hasattr(self, 'couplingStrength'):\n self.couplingStrength = self.timeDependency(self, time) #pylint:disable=assigning-non-slot,not-callable\n\nclass term(termTimeDep):\n label = 'term'\n #: (**class attribute**) number of instances created internally by the library\n _internalInstances: int = 0\n #: (**class attribute**) number of instances created explicitly by the user\n _externalInstances: int = 0\n #: (**class attribute**) number of total instances = _internalInstances + _externalInstances\n _instances: int = 0\n\n __slots__ = []\n\n @paramBoundBase.superSys.setter\n def superSys(self, supSys):\n r\"\"\"\n Extends superSys setter to also add aliases to self.\n New aliases are (any name/alias of superSys) + Term + (number of terms)\n TODO What if there is already a superSys, and also alias list contains user given aliases as well.\n \"\"\"\n paramBoundBase.superSys.fset(self, supSys) # pylint: disable=no-member\n termCount = len(self.superSys.subSys) if self in self.superSys.subSys.values() else len(self.superSys.subSys)+1 # pylint: disable=no-member,line-too-long # noqa: E501\n self.alias = [na+\"Term\"+str(termCount) for na in self.superSys.name._aliasClass__members()] # pylint: disable=no-member, protected-access,line-too-long # noqa: E501\n\n @property\n def _freeMatSimple(self):\n h = self._constructMatrices(dimsBefore=1, dimsAfter=1, setMat=False)\n return h\n\n def _constructMatrices(self, dimsBefore=None, dimsAfter=None, setMat=True): #pylint:disable=arguments-differ\n if dimsBefore is None:\n dimsBefore = self.superSys._dimsBefore # pylint: disable=no-member\n\n if dimsAfter is None:\n dimsAfter = self.superSys._dimsAfter # pylint: disable=no-member\n\n if not (isinstance(self.superSys.dimension, (int, int64, int32, int16)) and callable(self.operator)): # pylint: disable=no-member\n raise TypeError('?')\n\n dimension = self.superSys._genericQSys__dimension # pylint: disable=no-member\n if self.operator in [qOps.Jz, qOps.Jy, qOps.Jx, qOps.Jm, qOps.Jp, qOps.Js]:\n dimension = 0.5*(dimension-1)\n\n if self.operator not in [qOps.sigmam, qOps.sigmap, qOps.sigmax, qOps.sigmay, qOps.sigmaz]:\n mat = qOps.compositeOp(self.operator(dimension), #pylint:disable=assigning-non-slot\n dimsBefore, dimsAfter)**self.order\n else: # pylint: disable=bare-except\n mat = qOps.compositeOp( # pylint: disable=no-member, assigning-non-slot\n self.operator(), dimsBefore, dimsAfter)**self.order\n\n if setMat:\n self._paramBoundBase__matrix = mat #pylint:disable=assigning-non-slot\n return mat\n\nclass qSystem(genericQSys):\n label = 'QuantumSystem'\n #: (**class attribute**) number of instances created internally by the library\n _internalInstances: int = 0\n #: (**class attribute**) number of instances created explicitly by the user\n _externalInstances: int = 0\n #: (**class attribute**) number of total instances = _internalInstances + _externalInstances\n _instances: int = 0\n\n __slots__ = []\n #@qSystemInitErrors\n def __init__(self, **kwargs):\n if self.__class__.__name__ == 'qSystem':\n qSystem._externalInstances = qSystem._instances + compQSystem._instances\n super().__init__()\n qSysKwargs = ['terms', 'subSys', 'name', 'superSys', 'dimension']\n for key in qSysKwargs:\n val = kwargs.pop(key, None)\n if val is not None:\n setattr(self, key, val)\n self._named__setKwargs(**kwargs) # pylint: disable=no-member\n\n if len(self.subSys) == 0:\n self.addSubSys(term(superSys=self, **kwargs))\n\n # @genericQSys.name.setter #pylint: disable=no-member\n # def name(self, name):\n # oldName = self.name\n # genericQSys.name.fset(self, name) # pylint: disable=no-member\n # for ii, sys in enumerate(self.subSys.values()):\n # if sys.name == (oldName + 'term' + str(ii)):\n # sys.name = self.superSys.name + 'term' + str(ii+1) # pylint: disable=no-member\n\n @genericQSys.dimension.setter # pylint: disable=no-member\n def dimension(self, newDimVal):\n if not isinstance(newDimVal, (int, int64, int32, int16)):\n raise ValueError('Dimension is not int')\n\n oldDimVal = self._genericQSys__dimension # pylint: disable=no-member\n\n for sys in self.subSys.values():\n sys.delMatrices(_exclude=[]) # pylint: disable=protected-access\n\n setAttr(self, '_genericQSys__dimension', newDimVal)\n # FIXME these should be called only if oldDim != newDim\n #if self.simulation._stateBase__initialStateInput.value is not None: # pylint: disable=protected-access\n # self.initialState = self.simulation._stateBase__initialStateInput.value # pylint: disable=protected-access\n\n if isinstance(self.superSys, compQSystem):\n self.superSys.updateDimension(self, newDimVal, oldDimVal, _exclude=[]) # pylint: disable=no-member\n\n @property\n def totalHam(self): # pylint: disable=invalid-overridden-method\n if ((self._paramUpdated) or (self._paramBoundBase__matrix is None)): # pylint: disable=no-member\n h = sum([(obj.frequency * obj.freeMat) for obj in self.subSys.values()])\n self._paramBoundBase__matrix = h # pylint: disable=assigning-non-slot\n self._paramBoundBase__paramUpdated = False # pylint: disable=assigning-non-slot\n return self._paramBoundBase__matrix # pylint: disable=no-member\n\n @property\n def _totalHamSimple(self):\n return sum([(obj.frequency * obj._freeMatSimple) for obj in self.subSys.values()])#pylint:disable=protected-access\n\n @property\n def freeMat(self):\n return self.firstTerm.freeMat # pylint: disable=no-member\n\n @freeMat.setter\n def freeMat(self, qOpsFunc):\n if callable(qOpsFunc):\n self.firstTerm.operator = qOpsFunc\n self.firstTerm._constructMatrices() # pylint: disable=protected-access\n elif qOpsFunc is not None:\n self.firstTerm._paramBoundBase__matrix = qOpsFunc # pylint: disable=assigning-non-slot\n else:\n if self.firstTerm.operator is None:\n raise ValueError('No operator is given for free Hamiltonian')\n self.firstTerm._constructMatrices() # pylint: disable=protected-access\n\n @property\n def operator(self):\n operators = [obj._termTimeDep__operator for obj in list(self.subSys.values())] # pylint: disable=protected-access\n return operators if len(operators) > 1 else operators[0]\n\n @operator.setter\n def operator(self, op):\n self.firstTerm.operator = op\n\n @property\n def frequency(self):\n #frequencies = [obj._termTimeDep__frequency for obj in list(self.subSys.values())] # pylint: disable=protected-access\n #return frequencies if len(frequencies) > 1 else frequencies[0]\n return self.firstTerm.frequency\n\n @frequency.setter\n def frequency(self, freq):\n self.firstTerm.frequency = freq\n\n @property\n def order(self):\n orders = [obj._termTimeDep__order for obj in list(self.subSys.values())] # pylint: disable=protected-access\n return orders if len(orders) > 1 else orders[0]\n\n @order.setter\n def order(self, ordVal):\n self.firstTerm.order = ordVal\n\n @property\n def firstTerm(self):\n return list(self.subSys.values())[0]\n\n @property\n def terms(self):\n qSys = list(self.subSys.values())\n return qSys if len(qSys) > 1 else qSys[0]\n\n @addDecorator\n def addSubSys(self, subS, **kwargs):\n if not isinstance(subS, term):\n raise TypeError('?')\n kwargs['superSys'] = self\n newS = super().addSubSys(subS, **kwargs)\n # FIXME use setAttr, check also for operator\n self._paramUpdated = True\n newS._paramBoundBase__paramBound[self.name] = self # pylint: disable=protected-access\n return subS\n\n @_recurseIfList\n def removeSubSys(self, subS, _exclude=[]): # pylint: disable=arguments-differ, dangerous-default-value\n if self not in _exclude:\n _exclude.append(self)\n if self.superSys is not None:\n self.superSys.removeSubSys(subS, _exclude=_exclude)\n super().removeSubSys(subS, _exclude=_exclude)\n\n @terms.setter\n def terms(self, subS):\n genericQSys.subSys.fset(self, subS) # pylint: disable=no-member\n for sys in self.subSys.values():\n sys.superSys = self\n\n def addTerm(self, operator, frequency=0, order=1):\n newTerm = self.addSubSys(term(operator=operator, frequency=frequency, order=order, superSys=self))\n return newTerm\n\n @_recurseIfList\n def removeTerm(self, termObj):\n self.removeSubSys(termObj, _exclude=[])\n\n @_initStDec\n def _createAstate(self, inp=None):\n if inp is None:\n raise ValueError(self.name + ' is not given an initial state')\n return qSta.superPos(self.dimension, inp, not self._inpCoef)\n\nclass Spin(qSystem): # pylint: disable=too-many-ancestors\n label = 'Spin'\n #: (**class attribute**) number of instances created internally by the library\n _internalInstances: int = 0\n #: (**class attribute**) number of instances created explicitly by the user\n _externalInstances: int = 0\n #: (**class attribute**) number of total instances = _internalInstances + _externalInstances\n _instances: int = 0\n\n __slots__ = ['__jValue']\n def __init__(self, **kwargs):\n super().__init__(terms=kwargs.pop('terms', None), subSys=kwargs.pop('subSys', None))\n self.operator = qOps.Jz\n self.__jValue = None\n self._named__setKwargs(**kwargs) # pylint: disable=no-member\n\n @property\n def jValue(self):\n return (self._genericQSys__dimension-1)/2 # pylint: disable=no-member\n\n @jValue.setter\n def jValue(self, value):\n self._Spin__jValue = value # pylint: disable=assigning-non-slot\n self.dimension = int((2*value) + 1)\n\nclass Qubit(Spin): # pylint: disable=too-many-ancestors\n label = 'Qubit'\n #: (**class attribute**) number of instances created internally by the library\n _internalInstances: int = 0\n #: (**class attribute**) number of instances created explicitly by the user\n _externalInstances: int = 0\n #: (**class attribute**) number of total instances = _internalInstances + _externalInstances\n _instances: int = 0\n\n __slots__ = []\n def __init__(self, **kwargs):\n super().__init__(terms=kwargs.pop('terms', None), subSys=kwargs.pop('subSys', None))\n kwargs['dimension'] = 2\n self.operator = qOps.Jz\n self._named__setKwargs(**kwargs) # pylint: disable=no-member\n\nclass Cavity(qSystem): # pylint: disable=too-many-ancestors\n label = 'Cavity'\n #: (**class attribute**) number of instances created internally by the library\n _internalInstances: int = 0\n #: (**class attribute**) number of instances created explicitly by the user\n _externalInstances: int = 0\n #: (**class attribute**) number of total instances = _internalInstances + _externalInstances\n _instances: int = 0\n\n __slots__ = []\n def __init__(self, **kwargs):\n super().__init__(terms=kwargs.pop('terms', None), subSys=kwargs.pop('subSys', None))\n self.operator = qOps.number\n self._named__setKwargs(**kwargs) # pylint: disable=no-member\n\nclass qCoupling(termTimeDep):\n label = 'qCoupling'\n #: (**class attribute**) number of instances created internally by the library\n _internalInstances: int = 0\n #: (**class attribute**) number of instances created explicitly by the user\n _externalInstances: int = 0\n #: (**class attribute**) number of total instances = _internalInstances + _externalInstances\n _instances: int = 0\n\n __slots__ = []\n\n #@qCouplingInitErrors\n def __init__(self, *args, **kwargs):\n super().__init__()\n self._named__setKwargs(**kwargs) # pylint: disable=no-member\n self.addTerm(*args)\n\n # TODO might define setters\n @property\n def couplingOperators(self):\n ops = []\n for co in self._qBase__subSys.values(): # pylint: disable=no-member\n ops.append(co[1])\n return ops\n\n @property\n def coupledSystems(self):\n ops = []\n for co in self._qBase__subSys.values(): # pylint: disable=no-member\n ops.append(co[0])\n return ops\n\n @property\n def couplingStrength(self):\n return self.frequency\n\n @couplingStrength.setter\n def couplingStrength(self, strength):\n self.frequency = strength\n\n def __coupOrdering(self, qts): # pylint: disable=no-self-use\n qts = sorted(qts, key=lambda x: x[0], reverse=False)\n oper = qts[0][1]\n for ops in range(len(qts)-1):\n oper = oper @ qts[ops+1][1]\n return oper\n\n def _constructMatrices(self):\n cMats = []\n for ind in range(len(self._qBase__subSys)): # pylint: disable=no-member\n qts = []\n for indx in range(len(list(self._qBase__subSys.values())[ind])): # pylint: disable=no-member\n sys = list(self._qBase__subSys.values())[ind][0][indx] # pylint: disable=no-member\n order = sys.ind\n oper = list(self._qBase__subSys.values())[ind][1][indx] # pylint: disable=no-member\n if oper in [qOps.sigmam, qOps.sigmap, qOps.sigmax, qOps.sigmay, qOps.sigmaz]:\n cHam = qOps.compositeOp(oper(), sys._dimsBefore, sys._dimsAfter)\n else:\n dimension = sys._genericQSys__dimension\n if oper in [qOps.Jz, qOps.Jy, qOps.Jx, qOps.Jm, qOps.Jp, qOps.Js]:\n dimension = 0.5*(dimension-1)\n cHam = qOps.compositeOp(oper(dimension), sys._dimsBefore, sys._dimsAfter)\n ts = [order, cHam]\n qts.append(ts)\n cMats.append(self._qCoupling__coupOrdering(qts))\n #h = []\n #if ((self.couplingStrength != 0) or (self.couplingStrength is not None)):\n # h = [self.couplingStrength * sum(cMats)]\n self._paramBoundBase__matrix = sum(cMats) # pylint: disable=assigning-non-slot\n return self._paramBoundBase__matrix # pylint: disable=no-member\n\n def __addTerm(self, count, ind, sys, *args):\n if callable(args[count][ind]):\n lo = len(self.subSys)\n self._qBase__subSys[str(lo)] = (sys, tuple(args[count])) # pylint: disable=no-member\n count += 1\n if count < len(args):\n count = self.__addTerm(count, ind, sys, *args)\n return count\n\n def addTerm(self, *args):\n counter = 0\n while counter in range(len(args)):\n # TODO write a generalisation for this one\n if isinstance(args[counter][0], qSystem):\n qSystems = args[counter]\n if callable(args[counter+1][1]):\n #if tuple(args[counter + 1]) in self._qBase__subSys.keys(): # pylint: disable=no-member\n # print(tuple(args[counter + 1]), 'already exists')\n lo = len(self.subSys)\n self._qBase__subSys[str(lo)] = (qSystems, tuple(args[counter + 1])) # pylint: disable=no-member\n counter += 2\n # TODO does not have to pass qSystem around\n if counter < len(args):\n counter = self._qCoupling__addTerm(counter, 1, qSystems, *args)\n self._paramBoundBase__matrix = None # pylint: disable=assigning-non-slot\n return self\n\n @_recurseIfList\n def removeSysCoupling(self, sys):\n self.removeSubSys(sys, _exclude=[])\n\n @_recurseIfList\n def removeSubSys(self, subS, _exclude=[]): # pylint: disable=dangerous-default-value\n vals = self._qBase__subSys.values() # pylint: disable=no-member\n for ind, val in enumerate(vals):\n systs = val[0]\n if subS in systs:\n self._qBase__subSys.pop(str(ind)) # pylint: disable=no-member\n", "meta": {"hexsha": "c11757400259207e239c9b553af9aa2b6f7e5285", "size": 37448, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/quanguru/classes/QSys.py", "max_stars_repo_name": "Qfabiolous/QuanGuru", "max_stars_repo_head_hexsha": "285ca44ae857cc61337f73ea2eb600f485a09e32", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/quanguru/classes/QSys.py", "max_issues_repo_name": "Qfabiolous/QuanGuru", "max_issues_repo_head_hexsha": "285ca44ae857cc61337f73ea2eb600f485a09e32", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/quanguru/classes/QSys.py", "max_forks_repo_name": "Qfabiolous/QuanGuru", "max_forks_repo_head_hexsha": "285ca44ae857cc61337f73ea2eb600f485a09e32", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.7480490524, "max_line_length": 174, "alphanum_fraction": 0.6423574023, "include": true, "reason": "from numpy,from scipy", "num_tokens": 8998, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5544704796847396, "lm_q2_score": 0.35936414516010196, "lm_q1q2_score": 0.19925680994841813}} {"text": "'''\n------------------------------------------------------------------------\nLast updated 4/19/2018\n\nThis script produces the tables and figures for the Tax Function\nIntegration Paper\n\n------------------------------------------------------------------------\n'''\n\nimport pickle\nimport numpy as np\nimport scipy.optimize as opt\nimport matplotlib.pyplot as plt\nimport os\nimport xlsxwriter\nimport ogusa\nfrom ogusa.utils import REFORM_DIR, BASELINE_DIR\n\n# Read in tax function parameters\ntax_func_params = {}\ntax_func_list = ['DEP', 'DEP', 'DEP_totalinc', 'DEP_totalinc', 'GS',\n 'GS']\nage_specific_list = [True, False, True, False, True, False]\nguid_list = ['_DEP_TI_noAge', '_DEP_TI_Age', '_DEP_noAge', '_DEP_Age',\n '_GS_noAge', '_GS_Age']\ntax_func_params_base = {}\ntax_func_params_reform = {}\ntpi_base = {}\ntpi_reform = {}\nss_base = {}\nss_reform = {}\nfor guid in guid_list:\n # NOTE TAHT SWITHC BASELINE AND REFORM SINCE TCJA CURRENT LAW\n reform_path = os.path.join(BASELINE_DIR, guid,\n 'TxFuncEst_baseline' + guid + '.pkl')\n base_path = os.path.join(REFORM_DIR, guid,\n 'TxFuncEst_policy' + guid + '.pkl')\n tax_func_params_base[guid] = pickle.load(\n open(base_path, 'rb'), encoding='latin')\n tax_func_params_reform[guid] = pickle.load(\n open(reform_path, 'rb'), encoding='latin')\n tpi_reform_path = os.path.join(BASELINE_DIR, guid,\n 'TPI/TPI_vars.pkl')\n tpi_base_path = os.path.join(REFORM_DIR, guid,\n 'TPI/TPI_vars.pkl')\n tpi_base[guid] = pickle.load(\n open(tpi_base_path, 'rb'), encoding='latin')\n tpi_reform[guid] = pickle.load(\n open(tpi_reform_path, 'rb'), encoding='latin')\n ss_reform_path = os.path.join(BASELINE_DIR, guid,\n 'SS/SS_vars.pkl')\n ss_base_path = os.path.join(REFORM_DIR, guid,\n 'SS/SS_vars.pkl')\n ss_base[guid] = pickle.load(\n open(ss_base_path, 'rb'), encoding='latin')\n ss_reform[guid] = pickle.load(\n open(ss_reform_path, 'rb'), encoding='latin')\n\n'''\n------------------------------------------------------------------------\n Tables - all tables for paper saved to different worksheets in an\n Excel workbook\n------------------------------------------------------------------------\n'''\n# open Excel workbook\nworkbook = xlsxwriter.Workbook('TFI_Tables.xlsx',\n {'nan_inf_to_errors': True})\n\n# Table 2: variation in phi by age for DEP function\n# create list of list with table info\nrate_labels = ['$ETR$', '$MTRx$', '$MTRy$']\nrate_types = ['etr', 'mtrx', 'mtry']\ntable2 = []\ntable2.append([''])\ntable2[0].extend(('21 to 54', '55 to 65', '66 to 80', 'All ages'))\nfor i, label in enumerate(rate_labels):\n table2.append([label])\n table2[i + 1].extend((\n tax_func_params_base['_DEP_Age']['tfunc_' + rate_types[i] +\n '_params_S'][:34, 0, -1].mean(),\n tax_func_params_base['_DEP_Age']['tfunc_' + rate_types[i] +\n '_params_S'][34:45, 0, -1].mean(),\n tax_func_params_base['_DEP_Age']['tfunc_' + rate_types[i] +\n '_params_S'][45:60, 0, -1].mean(),\n tax_func_params_base['_DEP_Age']['tfunc_' + rate_types[i] +\n '_params_S'][:, 0, -1].mean()))\n# save table of info to Excel\nworksheet = workbook.add_worksheet('Table 2')\nworksheet.merge_range('B1:D1', 'Age ranges')\nfor i, val in enumerate(table2):\n for j, val2 in enumerate(table2[i]):\n worksheet.write(i + 1, j, val2)\n\n# Table 3: comparing std errors across tax functions\ntax_func_labels = ['Ratio of polynomials, ETR',\n 'Ratio of polynomials, vary by age, ETR',\n 'Ratio of polynomials, vary by income source ETR',\n 'Ratio of polynomials, vary by age and income source ETR',\n 'Gouveia and Strauss (1994), ETR',\n 'Gouveia and Strauss (1994), vary by age, ETR']\ntable3 = []\ntable3.append([''])\ntable3[0].extend(('All ages', '21 to 54', '55 to 65', '66 to 80'))\nfor i, label in enumerate(tax_func_labels):\n table3.append([label])\n table3[i + 1].extend((\n tax_func_params_base[guid_list[i]]['tfunc_etr_sumsq'][:, 0].sum()\n / tax_func_params_base[guid_list[i]]['tfunc_etr_obs'][:, 0].sum(),\n tax_func_params_base[guid_list[i]]['tfunc_etr_sumsq'][:34, 0].sum()\n / tax_func_params_base[guid_list[i]]['tfunc_etr_obs'][:34, 0].sum(),\n tax_func_params_base[guid_list[i]]['tfunc_etr_sumsq'][34:45, 0].sum()\n / tax_func_params_base[guid_list[i]]['tfunc_etr_obs'][34:45, 0].sum(),\n tax_func_params_base[guid_list[i]]['tfunc_etr_sumsq'][45:60, 0].sum()\n / tax_func_params_base[guid_list[i]]['tfunc_etr_obs'][45:60, 0].sum()))\n# save table of info to Excel\nworksheet = workbook.add_worksheet('Table 3')\nworksheet.merge_range('B1:E1', 'Age ranges')\nfor i, val in enumerate(table3):\n for j, val2 in enumerate(table3[i]):\n worksheet.write(i + 1, j, val2)\n\n# Table 4: comparing SSE across tax functions\ntable4 = []\ntable4.append([''])\ntable4[0].extend(('All ages', '21 to 54', '55 to 65', '66 to 80'))\nfor i, label in enumerate(tax_func_labels):\n table4.append([label])\n table4[i + 1].extend((\n tax_func_params_base[guid_list[i]]['tfunc_etr_sumsq'][:, 0].mean(),\n tax_func_params_base[guid_list[i]]['tfunc_etr_sumsq'][:34, 0].mean(),\n tax_func_params_base[guid_list[i]]['tfunc_etr_sumsq'][34:45, 0].mean(),\n tax_func_params_base[guid_list[i]]['tfunc_etr_sumsq'][45:60, 0].mean()))\n# save table of info to Excel\nworksheet = workbook.add_worksheet('Table 4')\nworksheet.merge_range('B1:E1', 'Age ranges')\nfor i, val in enumerate(table4):\n for j, val2 in enumerate(table4[i]):\n worksheet.write(i + 1, j, val2)\n\n# Table 5: comparing observations across tax functions\ntable5 = []\ntable5.append([''])\ntable5[0].extend(('All ages', '21 to 54', '55 to 65', '66 to 80'))\nfor i, label in enumerate(tax_func_labels):\n table5.append([label])\n table5[i + 1].extend((\n tax_func_params_base[guid_list[i]]['tfunc_etr_obs'][:, 0].sum(),\n tax_func_params_base[guid_list[i]]['tfunc_etr_obs'][:34, 0].sum(),\n tax_func_params_base[guid_list[i]]['tfunc_etr_obs'][34:45, 0].sum(),\n tax_func_params_base[guid_list[i]]['tfunc_etr_obs'][45:60, 0].sum()))\n# save table of info to Excel\nworksheet = workbook.add_worksheet('Table 5')\nworksheet.merge_range('B1:E1', 'Age ranges')\nfor i, val in enumerate(table5):\n for j, val2 in enumerate(table5[i]):\n worksheet.write(i + 1, j, val2)\n\n# Table 6: parameter estimates from baseline and reform for DEP funcs\n# report parameters from function for 42 year old in first year of window\nparam_names = ['$A$', '$B$', '$C$', '$D$', '$max_x$', '$min_x$',\n '$max_y$', '$min_y$', '$shift_x$', '$shift_y$',\n '$shift$', '$share$']\ntable6 = []\ntable6.append(['Parameter'])\ntable6[0].extend(tuple(rate_labels * 2))\nfor i, label in enumerate(param_names):\n table6.append([label])\n for j, rate in enumerate(rate_types): # for baseline results\n table6[i + 1].append(\n tax_func_params_base['_DEP_Age']['tfunc_' + rate +\n '_params_S'][21, 0, i])\n for j, rate in enumerate(rate_types): # for reform results\n table6[i + 1].append(\n tax_func_params_reform['_DEP_Age']['tfunc_' + rate +\n '_params_S'][21, 0, i])\ntable6.append(['Obs (N)'])\ntable6.append(['SSE'])\nfor j, rate in enumerate(rate_types):\n table6[-2].append(\n tax_func_params_base['_DEP_Age']['tfunc_' + rate +\n '_obs'][21, 0])\n table6[-1].append(\n tax_func_params_base['_DEP_Age']['tfunc_' + rate +\n '_sumsq'][21, 0])\nfor j, rate in enumerate(rate_types):\n table6[-2].append(\n tax_func_params_reform['_DEP_Age']['tfunc_' + rate +\n '_obs'][21, 0])\n table6[-1].append(\n tax_func_params_reform['_DEP_Age']['tfunc_' + rate +\n '_sumsq'][21, 0])\n# save table of info to Excel\nworksheet = workbook.add_worksheet('Table 6')\nworksheet.merge_range('B1:D1', '2017 Law')\nworksheet.merge_range('E1:G1', 'TCJA')\nfor i, val in enumerate(table6):\n for j, val2 in enumerate(table6[i]):\n worksheet.write(i + 1, j, val2)\n\n\n# Table 8: GDP changes across tax functions\ntax_func_labels = ['Ratio of polynomials, ETR',\n 'Ratio of polynomials, vary by age, ETR',\n 'Ratio of polynomials, vary by income source ETR',\n 'Ratio of polynomials, vary by age and income source ETR',\n 'Gouveia and Strauss (1994), ETR',\n 'Gouveia and Strauss (1994), vary by age, ETR']\ntable8 = []\nfor i, label in enumerate(tax_func_labels):\n table8.append([label])\n for y in range(10):\n table8[i].append(((tpi_reform[guid_list[i]]['Y'][y] -\n tpi_base[guid_list[i]]['Y'][y])\n / tpi_base[guid_list[i]]['Y'][y]))\n table8[i].extend((\n ((tpi_reform[guid_list[i]]['Y'][:11].sum() -\n tpi_base[guid_list[i]]['Y'][:11].sum())\n / tpi_base[guid_list[i]]['Y'][:11].sum()),\n ((ss_reform[guid_list[i]]['Yss'] -\n ss_base[guid_list[i]]['Yss'])\n / ss_base[guid_list[i]]['Yss'])))\n# save table of info to Excel\nworksheet = workbook.add_worksheet('Table 8')\nworksheet.write(0, 0, 'Tax Function')\nfor y in range(2018, 2028):\n worksheet.write(0, y - 2017, str(y))\nworksheet.write(0, 11, '2018-2027')\nworksheet.write(0, 12, 'SS')\nfor i, val in enumerate(table8):\n for j, val2 in enumerate(table8[i]):\n worksheet.write(i + 1, j, val2)\n\n# Table 9: Changes in all macro aggregates for DEP only\nresults_labels = ['GDP', 'Conusmption', 'Investment', 'Hours Worked',\n 'Avg. Wage', 'Interest Rate', 'Total Taxes']\nvar_names = ['Y', 'C', 'I', 'L', 'w', 'r', 'REVENUE']\nss_var_names = ['Yss', 'Css', 'Iss', 'Lss', 'wss', 'rss', 'revenue_ss']\ntable9 = []\nfor i, label in enumerate(results_labels):\n table9.append([label])\n for y in range(10):\n table9[i].append(((tpi_reform['_DEP_Age'][var_names[i]][y] -\n tpi_base['_DEP_Age'][var_names[i]][y])\n / tpi_base['_DEP_Age'][var_names[i]][y]))\n table9[i].extend((\n ((tpi_reform['_DEP_Age'][var_names[i]][:11].sum() -\n tpi_base['_DEP_Age'][var_names[i]][:11].sum())\n / tpi_base['_DEP_Age'][var_names[i]][:11].sum()),\n ((ss_reform['_DEP_Age'][ss_var_names[i]] -\n ss_base['_DEP_Age'][ss_var_names[i]])\n / ss_base['_DEP_Age'][ss_var_names[i]])))\n# save table of info to Excel\nworksheet = workbook.add_worksheet('Table 9')\nworksheet.write(0, 0, 'Macroeconomic Variables')\nfor y in range(2018, 2028):\n worksheet.write(0, y - 2017, str(y))\nworksheet.write(0, 11, '2018-2027')\nworksheet.write(0, 12, 'SS')\nfor i, val in enumerate(table9):\n for j, val2 in enumerate(table9[i]):\n worksheet.write(i + 1, j, val2)\n\nworkbook.close()\n\n'''\nFIGURES\n'''\n\n\"\"\"\nThis version: 12 May 2018\nWritten by Kerk Phillips\n\nThis program fits tax functions for \"Integrating Microsimulation Models of Tax\nPolicy into a DGE Macroeconomic Model: A Canonical Example,\" by DeBaker, Evans\nand Phillips.\n\nThis file fits data from Tax Calc to three different functions, compares the\ngoodness-of-fit, and plots the functions against the data. The data sample\ncan be restricted by the age and the capital income of the individuals.\n\"\"\"\n\n\n\ndef GS(coeffs, *args):\n '''\n This is the functional from from Gouveia and Strass (1994) with an\n additional free parameter\n '''\n # unpack coefficients\n phi0, phi1, phi2 = coeffs\n # unpack data\n I, taxes, wgts = args\n # I = x+y\n errors = (taxes/I) - ((phi0*(I - (I**(-phi1) + phi2)**(-1/phi1)))/I)\n wsse = (wgts * (errors ** 2)).sum()\n print('GS SSE: ', wsse)\n print('coeffs = ', phi0, phi1, phi2)\n return wsse\n\n\n'''\nThe functions below call those above and return the square-root of the sum of\nsquared errors (SSE) for each model\n'''\n# load data from pkl file then clean it up (like in txfunc.py)\nmicro_data = pickle.load(open(\"micro_data_2017Law.pkl\", \"rb\"),\n encoding='latin1')\ndata_orig = micro_data['2018']\ndata_orig['Total Labor Income'] = \\\n (data_orig['Wage income'] +\n data_orig['SE income'])\ndata_orig['Effective Tax Rate'] = \\\n (data_orig['Total tax liability'] /\n data_orig[\"Adjusted total income\"])\ndata_orig[\"Total Capital Income\"] = \\\n (data_orig['Adjusted total income'] -\n data_orig['Total Labor Income'])\n# use weighted avg for MTR labor - abs value because\n# SE income may be negative\ndata_orig['MTR Labor'] = \\\n (data_orig['MTR wage income'] * (data_orig['Wage income'] /\n (data_orig['Wage income'].abs() +\n data_orig['SE income'].abs())) +\n data_orig['MTR SE income'] *\n (data_orig['SE income'].abs() /\n (data_orig['Wage income'].abs() +\n data_orig['SE income'].abs())))\ndata = data_orig[['Age', 'MTR Labor', 'MTR capital income',\n 'Total Labor Income', 'Total Capital Income',\n 'Adjusted total income', 'Effective Tax Rate',\n 'Weights']]\n# Clean up the data by dropping outliers\n# drop all obs with ETR > 0.65\ndata_trnc = \\\n data.drop(data[data['Effective Tax Rate'] > 0.65].index)\n# drop all obs with ETR < -0.15\ndata_trnc = \\\n data_trnc.drop(data_trnc[data_trnc['Effective Tax Rate']\n < -0.15].index)\n# drop all obs with ATI, TLI, TCI < $5\ndata_trnc = data_trnc[(data_trnc['Adjusted total income'] >= 5)\n & (data_trnc['Total Labor Income'] >= 5) &\n (data_trnc['Total Capital Income'] >= 5)]\n\n# drop all obs with MTR on capital income > 10.99\ndata_trnc = \\\n data_trnc.drop(data_trnc[data_trnc['MTR capital income']\n > 0.99].index)\n# drop all obs with MTR on capital income < -0.45\ndata_trnc = \\\n data_trnc.drop(data_trnc[data_trnc['MTR capital income']\n < -0.45].index)\n# drop all obs with MTR on labor income > 10.99\ndata_trnc = data_trnc.drop(data_trnc[data_trnc['MTR Labor']\n > 0.99].index)\n# drop all obs with MTR on labor income < -0.45\ndata_trnc = data_trnc.drop(data_trnc[data_trnc['MTR Labor']\n < -0.45].index)\ndata_baseline = data_trnc\n\n# calculate total taxes\ndata_baseline['Taxes'] = (data_baseline['Effective Tax Rate'] *\n data_baseline['Adjusted total income'])\n\n# get time-series of interest - for 43 year old in 2017\ndata_to_use = data_baseline[data_baseline['Age'] == 42].copy()\ny = data_to_use['Total Capital Income'].values\nx = data_to_use['Total Labor Income'].values\nI = data_to_use['Adjusted total income'].values\ntaxes = data_to_use['Taxes'].values\nwgts = data_to_use['Weights'].values\netr_data = data_to_use['Effective Tax Rate'].values\ntx_objs = (I, taxes, wgts)\n\n# # set bounds on coefficients\n# Gbounds = ((0, None), (0, None), (0, None))\n#\n# # set starting guesses for coefficients\n# Gguess = np.array([0.3745, 0.7525, 0.7368])\n#\n# # use minimizer to solve for coefficients\n# # Gouveia and Strauss\n# Gout = opt.minimize(GS, Gguess,\n# args=(tx_objs), method=\"L-BFGS-B\", bounds=Gbounds, tol=1e-15)\n# Gcoeffs = Gout.x\n# G_SSE = Gout.fun\n# print 'GS coeffs, Obs, SSE: ', Gcoeffs, len(taxes), G_SSE\n\n\n# Plot tax function curves in 2D\n# plot GS vs alt function against data for a given year/age\nnpts = len(I) # points in grid\nmaxinc = 300000. # upper end of grid\nmininc = 0. # lower end of grid\nygrid = np.zeros(npts) # this is just a place holder to pass\nxgrid = np.linspace(mininc, maxinc, npts)\ndatagrid = (ygrid, xgrid) # tuple to pass to functions\nGcoeffs = np.zeros((3,))\nGcoeffs[0] = (tax_func_params_base['_GS_Age']['tfunc_etr_params_S'][21, 0, 0])\nGcoeffs[1] = (tax_func_params_base['_GS_Age']['tfunc_etr_params_S'][21, 0, 1])\nGcoeffs[2] = (tax_func_params_base['_GS_Age']['tfunc_etr_params_S'][21, 0, 2])\n# put in terms of ETR by dividing by xgrid\nGyfit = ((Gcoeffs[0] * (xgrid - (xgrid ** (-Gcoeffs[1]) + Gcoeffs[2]) **\n (-1 / Gcoeffs[1]))) / xgrid)\n\nA = (tax_func_params_base['_DEP_Age']['tfunc_etr_params_S'][21, 0, 0])\nB = (tax_func_params_base['_DEP_Age']['tfunc_etr_params_S'][21, 0, 1])\nC = (tax_func_params_base['_DEP_Age']['tfunc_etr_params_S'][21, 0, 2])\nD = (tax_func_params_base['_DEP_Age']['tfunc_etr_params_S'][21, 0, 3])\nmax_x = (tax_func_params_base['_DEP_Age']['tfunc_etr_params_S'][21, 0, 4])\nmin_x = (tax_func_params_base['_DEP_Age']['tfunc_etr_params_S'][21, 0, 5])\nmax_y = (tax_func_params_base['_DEP_Age']['tfunc_etr_params_S'][21, 0, 6])\nmin_y = (tax_func_params_base['_DEP_Age']['tfunc_etr_params_S'][21, 0, 7])\nshift_x = (tax_func_params_base['_DEP_Age']['tfunc_etr_params_S'][21, 0, 8])\nshift_y = (tax_func_params_base['_DEP_Age']['tfunc_etr_params_S'][21, 0, 9])\nshift = (tax_func_params_base['_DEP_Age']['tfunc_etr_params_S'][21, 0, 10])\nshare = (tax_func_params_base['_DEP_Age']['tfunc_etr_params_S'][21, 0, 11])\nprint('Main spec params = ',\n tax_func_params_base['_DEP_Age']['tfunc_etr_params_S'][21, 0, :])\n\nX = xgrid.copy()\nY = xgrid.copy()*0.0\nX2 = X ** 2\nY2 = Y ** 2\ntau_x = (((max_x - min_x) * (A * X2 + B * X) / (A * X2 + B * X + 1))\n + min_x)\ntau_y = (((max_y - min_y) * (C * Y2 + D * Y) / (C * Y2 + D * Y + 1))\n + min_y)\nDEP_fit_nocapital = ((((tau_x + shift_x) ** share) * ((tau_y + shift_y)\n ** (1 - share))) +\n shift)\n\nX = xgrid.copy() * 0.7\nY = xgrid.copy() * 0.3\nX2 = X ** 2\nY2 = Y ** 2\ntau_x = (((max_x - min_x) * (A * X2 + B * X) / (A * X2 + B * X + 1))\n + min_x)\ntau_y = (((max_y - min_y) * (C * Y2 + D * Y) / (C * Y2 + D * Y + 1))\n + min_y)\nDEP_fit_nolabor = (((tau_x + shift_x) ** share) * ((tau_y + shift_y) **\n (1 - share))) + shift\n\n# plot data\n# plt.plot(I, etr_data, '.b', ms = 1, label='data')\nplt.plot(I, etr_data, '.b', label='data')\nplt.plot(xgrid, Gyfit, 'm-', lw=1, label='GS')\nplt.plot(xgrid, DEP_fit_nocapital, '-', color='orange', lw=1,\n label='DEP, no y')\nplt.plot(xgrid, DEP_fit_nolabor, '-', color='green', lw=1,\n label='DEP, mixed')\nplt.xlabel('Total Income')\nplt.ylabel('Effective Tax Rate')\n# set axes range\nplt.xlim(0, 100000)\nplt.ylim(-0.2, 0.32)\nplt.legend(loc='lower right')\nplt.suptitle('Age = 43, Year = 2018')\n# save high quality version to external file\nplt.savefig('Compare_ETR_functions.png')\nplt.show()\n\nplt.plot(I, etr_data, '.b', label='data')\nplt.plot(xgrid, DEP_fit_nocapital, '-', color='orange', lw=1,\n label='DEP, no y')\nplt.plot(xgrid, DEP_fit_nolabor, '-', color='green', lw=1,\n label='DEP, mixed')\nplt.xlabel('Total Income')\nplt.ylabel('Effective Tax Rate')\n# set axes range\nplt.xlim(0, 100000)\nplt.ylim(-0.2, 0.32)\nplt.legend(loc='lower right')\nplt.suptitle('Age = 43, Year = 2018')\n# save high quality version to external file\nplt.savefig('Compare_DEP_ETR_functions.png')\nplt.show()\n", "meta": {"hexsha": "a22964165eb8810072fd3ce7134faaec553b196d", "size": 19634, "ext": "py", "lang": "Python", "max_stars_repo_path": "TFI_tables_figures.py", "max_stars_repo_name": "rickecon/TaxFuncIntegr", "max_stars_repo_head_hexsha": "715cc76e3305c00dd64d79521c504bb388c6d87d", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "TFI_tables_figures.py", "max_issues_repo_name": "rickecon/TaxFuncIntegr", "max_issues_repo_head_hexsha": "715cc76e3305c00dd64d79521c504bb388c6d87d", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2018-07-02T18:24:17.000Z", "max_issues_repo_issues_event_max_datetime": "2018-07-02T18:24:17.000Z", "max_forks_repo_path": "TFI_tables_figures.py", "max_forks_repo_name": "rickecon/TaxFuncIntegr", "max_forks_repo_head_hexsha": "715cc76e3305c00dd64d79521c504bb388c6d87d", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2016-09-18T01:39:54.000Z", "max_forks_repo_forks_event_max_datetime": "2020-09-02T12:54:55.000Z", "avg_line_length": 40.9895615866, "max_line_length": 80, "alphanum_fraction": 0.5987572578, "include": true, "reason": "import numpy,import scipy", "num_tokens": 5729, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.5544704649604273, "lm_q2_score": 0.35936413143782797, "lm_q1q2_score": 0.19925679704843258}} {"text": "#!/usr/bin/env python\n\n\"\"\"capture_stats.py: Sensitivity test experiments python program for Doppler shift\"\"\"\n\n__author__ = \"Chakraborty, S.\"\n__copyright__ = \"Copyright 2021, SuperDARN@VT\"\n__credits__ = []\n__license__ = \"MIT\"\n__version__ = \"1.0.\"\n__maintainer__ = \"Chakraborty, S.\"\n__email__ = \"shibaji7@vt.edu\"\n__status__ = \"Research\"\n\nimport os\nimport sys\nsys.path.append(\"../sd/\")\nimport datetime as dt\nimport pandas as pd\nimport argparse\nfrom dateutil import parser as dparser\nimport numpy as np\nfrom netCDF4 import Dataset\nimport time\nimport glob\nfrom scipy.integrate import trapz\nfrom scipy import signal\nfrom scipy.io import loadmat\n\nfrom pysolar.solar import get_altitude\nimport plotlib\n\ndef calculate_sza(d, lats, lons, alt=300):\n d = d.replace(tzinfo=dt.timezone.utc)\n szas = []\n for la, lo in zip(lats, lons):\n szas.append(90. - get_altitude(la, lo, d))\n return szas\n\nINT_F = 300\ndef get_freq(dn, rad):\n f = 12.\n fname = \"../data/op/{dn}/waccmx/sd_{rad}_data.csv.gz\".format(dn=dn.strftime(\"%Y.%m.%d.%H.%M\"),rad=rad)\n if os.path.exists(fname):\n os.system(\"gzip -d \" + fname)\n du = pd.read_csv(fname.replace(\".gz\", \"\"))\n os.system(\"gzip \" + fname.replace(\".gz\", \"\"))\n if len(du) > 0: f = np.median(du.tfreq)/1e3\n return f\n\ndef get_vdeta(d, rlim, freq):\n d = d[(d.height>=rlim[0]) & (d.height= 0:\n events = events.iloc[[args.number]]\n T, kind = 0, events.rad.tolist()[0] + \"_\" + events.date.tolist()[0].strftime(\"%Y-%m-%d-%H-%M\")\n if not args.plot: \n ix = 0\n for d, r in zip(events.date.tolist(), events.rad.tolist()):\n print(\"Events - \", r, d)\n if ix >= T: \n freq = get_freq(d, r)\n for bm in range(24):\n bearing_file = \"../data/op/%s/waccmx/%s/bm.%02d/bearing.mat\"%(d.strftime(\"%Y.%m.%d.%H.%M\"), r, bm)\n print(bearing_file)\n obj = loadmat(bearing_file)\n lat, lon = obj[\"lat\"], obj[\"lon\"]\n sza = np.mean(calculate_sza(d, lat, lon))\n dic = \"../data/op/{dn}/waccmx/{r}/bm.{bm}/\".format(r=r,bm=\"%02d\"%bm,dn=d.strftime(\"%Y.%m.%d.%H.%M\"))\n for i in range(18,19):\n i_start, i_end = 16, 30\n for elv in np.linspace(i_start, i_end, (i_end-i_start)*2 + 1):\n if elv.is_integer(): fname = dic + \"ti(%02d)_elv(%d)_f.csv\"%(i,elv)\n else: fname = dic + \"ti(%02d)_elv(%.1f)_f.csv\"%(i,elv)\n files = glob.glob(fname)\n for f in files:\n try:\n T = False\n ff = pd.read_csv(f)\n vd = np.abs(get_vdeta(ff, d_reg, freq))\n ve = np.abs(get_vdeta(ff, e_reg, freq))\n vf = np.abs(get_vdeta(ff, f_reg, freq))\n bf = pd.read_csv(f.replace(\"_f.\",\"_d.\"))\n vfh = np.abs(_estimate_dop_delh_(ff,bf,freq))\n vD.append(vd)\n vE.append(ve)\n vF.append(vf)\n vFh.append(vfh)\n vT.append(vd+ve+vf+vfh)\n SZA.append(sza)\n E.append(elv)\n F.append(freq)\n except: pass\n #if t and T: break\n ix += 1\n x = pd.DataFrame()\n x[\"vD\"], x[\"vE\"], x[\"vF\"], x[\"vFh\"], x[\"vT\"], x[\"sza\"], x[\"elv\"], x[\"freq\"] = vD, vE, vF, vFh, vT, SZA, E, F\n x = x.round(3)\n x.to_csv(\"op/\" + sim_fname.format(kind=kind), index=False)\n else:\n print(\" Compile plots...\")\n print(\"op/\"+sim_fname.format(kind=kind))\n x0 = pd.read_csv(\"op/\"+sim_fname.format(kind=kind))\n x0 = x0[(np.abs(x0.vT)>30) & (np.abs(x0.vT)<300)]\n vd0, ve0, vf0 = np.array(x0.vD/x0.vT), np.array(x0.vE/x0.vT), np.array((x0.vF + x0.vFh)/x0.vT)\n vdn0, vdh0 = np.array((x0.vD + x0.vE + x0.vF)/x0.vT), np.array(x0.vFh/x0.vT)\n x = pd.read_csv(\"op/finescale_simulate.csv\")\n x = x[(np.abs(x.vT)>30) & (np.abs(x.vT)<300)]\n vd, ve, vf = np.array(x.vD/x.vT), np.array(x.vE/x.vT), np.array((x.vF + x.vFh)/x.vT)\n vdn, vdh = np.array((x.vD + x.vE + x.vF)/x.vT), np.array(x.vFh/x.vT)\n plotlib.plot_mastogram(vd, ve, vf, vdn, vdh, vd0, ve0, vf0, vdn0, vdh0)\n if os.path.exists(\"__pycache__/\"):\n os.system(\"rm -rf __pycache__/\")\n os.system(\"rm -rf py*.log\")\n", "meta": {"hexsha": "28dc7e1f47c74bcc9de3bf5304ce60fce5ee6eb8", "size": 6080, "ext": "py", "lang": "Python", "max_stars_repo_path": "code_rt_sd/stats/capture_stats.py", "max_stars_repo_name": "shibaji7/Collaboration_NCAR", "max_stars_repo_head_hexsha": "c27e0ad8a1f0c6b2e66fa07e6cf57f98c4389899", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-11-12T14:40:49.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-12T14:40:49.000Z", "max_issues_repo_path": "code_rt_sd/stats/capture_stats.py", "max_issues_repo_name": "shibaji7/Collaboration_NCAR", "max_issues_repo_head_hexsha": "c27e0ad8a1f0c6b2e66fa07e6cf57f98c4389899", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "code_rt_sd/stats/capture_stats.py", "max_forks_repo_name": "shibaji7/Collaboration_NCAR", "max_forks_repo_head_hexsha": "c27e0ad8a1f0c6b2e66fa07e6cf57f98c4389899", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.4285714286, "max_line_length": 120, "alphanum_fraction": 0.5106907895, "include": true, "reason": "import numpy,from scipy", "num_tokens": 1821, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.5544704649604273, "lm_q2_score": 0.35936413143782797, "lm_q1q2_score": 0.19925679704843258}} {"text": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n'''\nvslab2d\n=======\n\nA script for displaying and saving density distribution generated by\nscft_confined/SlabXX2d, where XX stands for the polymer model. For A-B diblock\ncopolymer, XX=AB.\n\nCopyright (C) 2013 Yi-Xin Liu (lyx@fudan.edu.cn)\n\n'''\n\nimport argparse\nimport os\nimport glob\nimport json\nfrom ConfigParser import SafeConfigParser\n\nimport numpy as np\nfrom scipy.io import loadmat, savemat\nimport matplotlib.pylab as plt\n\nfrom chebpy import cheb_barycentric_matrix\n\nfrom scftpy import scft_contourf, SCFTConfig\n\nparser = argparse.ArgumentParser(description='vis_slab2d options')\n\nparser.add_argument('-b', '--batch',\n action='store_true',\n help='If present or True, perform batch mode.')\nparser.add_argument('-r', '--path',\n default='.',\n help='Path to be processed, for batch mode use.')\nparser.add_argument('-p', '--param_file',\n default='param.ini',\n help='SCFT configuration file, *.ini')\nparser.add_argument('-d', '--data_file',\n default='scft_out',\n help='SCFT generated data file, *.mat')\nparser.add_argument('-s', '--save',\n action='store_true',\n help='If present or True, save figure.')\nargs = parser.parse_args()\n\n\ndef batch_vis_slab2d(path='.', param='param.ini', data='scft_out'):\n '''\n Batch mode vis_slab2d, for all directory in the .\n Note: ONLY directories in the path will be processed.\n The input var is the main part of the whole data file name. The\n suffix is in the form '_XXXX', where XXXX is the max number of time steps.\n Then the full data file name is 'scft_out_XXXX.mat', the '.mat' can be\n ignored.\n Generated figures are stored in the same directory as its data file.\n Other data, such as H, are stored in the parent path as 'data.mat'.\n '''\n is_save = True # Do not show figure in the batch mode\n\n var = []\n F = []\n\n for f in os.listdir(path):\n p = os.path.join(path, f) # path\n if os.path.isdir(p):\n pt = os.path.join(p, data+'_*.mat') # path to be globbed\n datafiles = glob.glob(pt)\n fnames = [os.path.basename(x) for x in datafiles]\n data_name = get_final_datafile(fnames)\n if data_name == '':\n print p, ' data file missing.'\n continue\n pfile = os.path.join(p, param)\n if not os.path.exists(pfile):\n print p, ' configuration file missing.'\n continue\n dfile = os.path.join(p, data_name)\n vis_slab2d(pfile, dfile, is_save)\n print pfile, dfile\n v = get_var(pfile)\n var.append(v)\n mat = loadmat(dfile)\n F.append(mat['F'][-1, 0])\n print v, mat['F'][-1, 0]\n\n savemat(os.path.join(path, 'data'), {'v': var, 'F': F})\n\n\ndef get_var(param_file):\n '''\n Get the main batch variable and its current value.\n '''\n cfg = SafeConfigParser(allow_no_value=True)\n cfg.optionxform = str\n cfg.read(param_file)\n section = cfg.get('Batch', 'section')\n # name list of the batch variable\n batch_var = json.loads(cfg.get('Batch', 'var'))\n var_name = batch_var[0] # the main batch variable is the first one\n if (var_name == 'BC_coefficients_left'\n or var_name == 'BC_coefficients_right'):\n bc = json.loads(cfg.get(section, var_name))\n var = bc[1]\n else:\n var = cfg.getfloat(section, var_name)\n return var\n\n\ndef get_final_datafile(namelist):\n '''\n Each name has the form 'scft_out_XXXX.mat', where XXXX is a number.\n '''\n data = ''\n num = 0 # a number to be compared\n for f in namelist:\n name, ext = os.path.splitext(f) # split into 'scft_out_XXXX', '.mat'\n fragments = name.split('_') # split into 'scft', 'out', 'XXXX'\n n = int(fragments[-1])\n if n > num:\n num = n\n data = name\n return data\n\n\ndef vis_slab2d(param='param.ini', data='scft_out', is_save=False):\n '''\n Visualize 2D data generated by DiskXX, here XX represents the polymer model, e.g. XX = AB stands for A-B diblock copolymers.\n '''\n is_show = not is_save\n path = os.path.dirname(data)\n\n config = SCFTConfig.from_file(param)\n Nx, Ny = config.grid.Lx, config.grid.Ly\n Lx = config.uc.a\n Ly = config.uc.b\n print Nx, Ny, Lx, Ly\n Nxp = Nx + 1\n Nyp = 2 * Ny\n\n mat = loadmat(data)\n phiA = mat['phiA']\n phiB = mat['phiB']\n #phiAB = phiA - phiB\n\n if not (Nx, Ny) == phiA.shape:\n raise 'Data file does not match param file.'\n\n # Periodic in x direction, Fourier\n xxp = np.linspace(0, Lx, Nxp)\n # Non-periodic in y direction, Chebyshev\n #ii = np.arange(Ny)\n #yy = np.cos(np.pi * ii / (Ny-1)) # rr [-1, 1]\n yyp = np.linspace(0, Ly, Nyp)\n yp, xp = np.meshgrid(yyp, xxp)\n\n phiAp = np.zeros([Nxp, Ny])\n phiBp = np.zeros([Nxp, Ny])\n phiAp[:-1, :] = phiA\n phiAp[-1, :] = phiA[0, :]\n phiBp[:-1, :] = phiB\n phiBp[-1, :] = phiB[0, :]\n phiAp = cheb_interp2d_y(phiAp, yyp)\n phiBp = cheb_interp2d_y(phiBp, yyp)\n phiABp = phiBp - phiAp\n if is_show:\n plt.plot(yyp, phiAp[Nxp/2, :])\n plt.plot(yyp, phiBp[Nxp/2, :])\n plt.plot(yyp, phiABp[Nxp/2, :])\n #scft_contourf(xp, yp, phiAp, show_cbar=True)\n #scft_contourf(xp, yp, phiBp, show_cbar=True)\n #scft_contourf(xp, yp, phiABp, show_cbar=True)\n scft_contourf(xp, yp, phiAp)\n scft_contourf(xp, yp, phiBp)\n scft_contourf(xp, yp, phiABp)\n plt.show()\n if is_save:\n figA = os.path.join(path, 'phiA.png')\n figB = os.path.join(path, 'phiB.png')\n figAB = os.path.join(path, 'phiAB.png')\n scft_contourf(xp, yp, phiAp)\n plt.savefig(figA)\n scft_contourf(xp, yp, phiBp)\n plt.savefig(figB)\n scft_contourf(xp, yp, phiABp)\n plt.savefig(figAB)\n\n\ndef cheb_interp2d_y(u, vy):\n '''\n Use chebyshev interpolation for the last dimension of Cartesian coordinates\n (x, y).\n u(x, y): source data\n vy: vector to be interpolated, size is Nyp.\n '''\n Nx, Ny = u.shape\n Nyp = vy.size\n uout = np.zeros([Nx, Nyp])\n vyp = np.linspace(-1, 1, Nyp)\n T = cheb_barycentric_matrix(vyp, Ny-1)\n for i in xrange(Nx):\n uout[i] = np.dot(T, u[i])\n return uout\n\n\nif __name__ == '__main__':\n if args.batch:\n batch_vis_slab2d(args.path, args.param_file, args.data_file)\n else:\n vis_slab2d(args.param_file, args.data_file, args.save)\n", "meta": {"hexsha": "930ea05321f333616ac64fc379e97f3e48e19959", "size": 6675, "ext": "py", "lang": "Python", "max_stars_repo_path": "scripts/vis_slab2d.py", "max_stars_repo_name": "liuyxpp/scftpy", "max_stars_repo_head_hexsha": "c203412b96f679d52759a935a2500705afd827a5", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-03-18T14:04:22.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-02T17:19:52.000Z", "max_issues_repo_path": "scripts/vis_slab2d.py", "max_issues_repo_name": "liuyxpp/scftpy", "max_issues_repo_head_hexsha": "c203412b96f679d52759a935a2500705afd827a5", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "scripts/vis_slab2d.py", "max_forks_repo_name": "liuyxpp/scftpy", "max_forks_repo_head_hexsha": "c203412b96f679d52759a935a2500705afd827a5", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-08-12T12:15:52.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-12T12:15:52.000Z", "avg_line_length": 31.4858490566, "max_line_length": 128, "alphanum_fraction": 0.5907116105, "include": true, "reason": "import numpy,from scipy", "num_tokens": 1918, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.5078118642792044, "lm_q2_score": 0.3923368301671084, "lm_q1q2_score": 0.19923329715255295}} {"text": "#!/usr/bin/env python\n\nimport os\nimport argparse\nimport numpy as np\nimport uproot\nfrom coffea import hist\nimport awkward as ak\n\nfrom sklearn.metrics import roc_curve, auc\nimport matplotlib.pyplot as plt\nimport mplhep as hep\n\nplt.style.use(hep.style.ROOT)\n\nmass_branch = \"fj_genRes_mass\"\n# mass_branch = 'fj_genH_mass'\n\n\ndef plot_loss(args, name, indir=None):\n if indir:\n # save the loss in a numpy file\n loss_vals_training = np.load(\"%s/loss_vals_training.npy\" % indir)\n loss_vals_validation = np.load(\"%s/loss_vals_validation.npy\" % indir)\n else:\n # or load the loss array manually\n loss_vals_training = np.array([0.001, 0.0002])\n loss_vals_validation = np.array([0.001, 0.0002])\n epochs = np.array(range(len(loss_vals_training)))\n\n f, ax = plt.subplots(figsize=(10, 10))\n ax.plot(epochs, loss_vals_training, label=\"Training\")\n ax.plot(epochs, loss_vals_validation, label=\"Validation\", color=\"green\")\n leg = ax.legend(loc=\"upper right\", title=name, borderpad=1, frameon=False, fontsize=16)\n leg._legend_box.align = \"right\"\n ax.set_ylabel(\"Loss\")\n ax.set_xlabel(\"Epoch\")\n ax.set_xlim(0, np.max(epochs))\n f.savefig(\"%s/Loss_%s.pdf\" % (args.odir, indir.replace(\"/\", \"\")))\n plt.clf()\n\n\ndef plot_accuracy(args, name, indir=None):\n if indir:\n acc_vals_validation = np.load(\"%s/acc_vals_validation.npy\" % indir)\n else:\n acc_vals_validation = np.array([0.001, 0.0002])\n epochs = np.array(range(len(acc_vals_validation)))\n\n f, ax = plt.subplots(figsize=(10, 10))\n ax.plot(epochs, acc_vals_validation, label=\"Validation\", color=\"green\")\n leg = ax.legend(loc=\"upper right\", title=name, borderpad=1, frameon=False, fontsize=16)\n leg._legend_box.align = \"right\"\n ax.set_ylabel(\"Accuracy\")\n ax.set_xlabel(\"Epoch\")\n ax.set_xlim(0, np.max(epochs))\n ax.set_ylim(0.8, 0.95)\n f.savefig(\"%s/Acc_%s.pdf\" % (args.odir, indir.replace(\"/\", \"\")))\n plt.clf()\n\n\n# return input by classes (signal and background)\ndef roc_input(\n events, var, label_sig, label_bkg, weight_hist=None, bins=None, sig_mask=None, bkg_mask=None\n):\n mask_sig = events[label_sig] == 1\n mask_bkg = events[label_bkg] == 1\n if sig_mask is not None:\n mask_sig = (mask_sig) & (sig_mask)\n if bkg_mask is not None:\n mask_bkg = (mask_bkg) & (bkg_mask)\n scores_sig = events[var][mask_sig].to_numpy()\n scores_bkg = events[var][mask_bkg].to_numpy()\n predict = np.concatenate((scores_sig, scores_bkg), axis=None)\n siglabels = np.ones(scores_sig.shape)\n bkglabels = np.zeros(scores_bkg.shape)\n truth = np.concatenate((siglabels, bkglabels), axis=None)\n\n weight = None\n if weight_hist is not None:\n weight_sig = weight_hist[np.digitize(events[\"fj_pt\"][mask_sig].to_numpy(), bins) - 1]\n weight_bkg = np.ones(scores_bkg.shape)\n weight = np.concatenate((weight_sig, weight_bkg), axis=None)\n\n return truth, predict, weight\n\n\n# get roc for a table with given scores, a label for signal, and one for background\ndef get_roc(\n events,\n score_name,\n label_sig,\n label_bkg,\n weight_hist=None,\n bins=None,\n sig_mask=None,\n bkg_mask=None,\n):\n truth, predict, weight = roc_input(\n events, score_name, label_sig, label_bkg, weight_hist, bins, sig_mask, bkg_mask\n )\n fprs, tprs, threshold = roc_curve(truth, predict, sample_weight=weight)\n return fprs, tprs\n\n\n# plot roc\ndef plot_roc(args, label_sig, label_bkg, fprs, tprs, label):\n fig, axs = plt.subplots(1, 1, figsize=(16, 16))\n\n def get_round(x_effs, y_effs, to_get=[0.01, 0.02, 0.03]):\n effs = []\n for eff in to_get:\n for i, f in enumerate(x_effs):\n if round(f, 2) == eff:\n effs.append(y_effs[i])\n break\n return effs\n\n def get_intersections(x_effs, y_effs, to_get=0.01):\n x_eff = 0\n for i, f in enumerate(y_effs):\n if f >= to_get:\n x_eff = x_effs[i]\n break\n return x_eff\n\n ik = 0\n markers = [\"v\", \"^\", \"o\", \"s\", \"p\", \"P\", \"h\"]\n for k, it in fprs.items():\n leg = k.replace(\"_score\", \"\")\n axs.plot(\n tprs[k],\n fprs[k],\n lw=2.5,\n label=r\"{}, AUC = {:.1f}%\".format(leg, auc(fprs[k], tprs[k]) * 100),\n )\n y_eff = 0.01\n x_eff = get_intersections(tprs[k], fprs[k], y_eff)\n axs.hlines(\n y=y_eff, xmin=0.00001, xmax=0.99999, linewidth=1, color=\"dimgrey\", linestyle=\"dashed\"\n )\n axs.vlines(\n x=x_eff, ymin=0.00001, ymax=y_eff, linewidth=1, color=\"dimgrey\", linestyle=\"dashed\"\n )\n # y_effs = [0.01,0.02,0.03]\n # x_effs = get_round(fprs[k],tprs[k],y_effs)\n # print(tprs[k],k)\n # print(y_effs)\n # axs.scatter(x_effs,y_effs,s=75,marker=markers[ik],label=leg)\n ik += 1\n\n axs.legend(loc=\"upper left\")\n axs.grid(which=\"minor\", alpha=0.2)\n axs.grid(which=\"major\", alpha=0.5)\n axs.set_xlabel(r\"Tagging efficiency %s\" % label_sig[\"legend\"])\n axs.set_ylabel(r\"Mistagging rate %s\" % label_bkg[\"legend\"])\n axs.set_ylim(0.0001, 1)\n axs.set_xlim(0.0001, 1)\n axs.set_yscale(\"log\")\n fig.savefig(\"%s/roc_%s_ylog.pdf\" % (args.odir, label))\n axs.set_yscale(\"linear\")\n plt.close()\n\n\n# plot rocs for different cuts on mH and pt\ndef plot_roc_by_var(\n args, vars_to_corr, bin_ranges, bin_widths, events, score_name, sig, bkg, mh=False\n):\n i = 0\n fig, axs = plt.subplots(1, len(vars_to_corr.keys()), figsize=(8 * len(vars_to_corr.keys()), 8))\n for var, varname in vars_to_corr.items():\n fprs = {}\n tprs = {}\n legends = []\n for j, b in enumerate(bin_ranges[i]):\n bi = b\n bf = b + bin_widths[i]\n tag = \"%i\" % bi\n if not mh:\n output = events[\n (events[bkg[\"label\"]] == 1)\n | (\n (events[varname] >= bi)\n & (events[varname] <= bf)\n & (events[mass_branch] != 125)\n )\n ]\n # mask_sig = (events[varname]>=bi) & (events[varname]<=bf) & (events[mass_branch]!=125)\n else:\n # mask_sig = (events[mass_branch]==125)\n output = events[\n (events[bkg[\"label\"]] == 1)\n | (\n (events[varname] >= bi)\n & (events[varname] <= bf)\n & (events[mass_branch] == 125)\n )\n ]\n fprs[tag], tprs[tag] = get_roc(output, score_name, sig[\"label\"], bkg[\"label\"])\n legends.append(\"%s %i-%i GeV\" % (var, bi, bf))\n\n # now plot\n if len(vars_to_corr.keys()) == 1:\n axs_1 = axs\n else:\n axs_1 = axs[i]\n\n ik = 0\n for k, it in fprs.items():\n axs_1.plot(\n tprs[k],\n fprs[k],\n lw=2.5,\n label=r\"{}, AUC = {:.1f}%\".format(legends[ik], auc(fprs[k], tprs[k]) * 100),\n )\n ik += 1\n axs_1.legend(loc=\"upper left\")\n axs_1.grid(which=\"minor\", alpha=0.2)\n axs_1.grid(which=\"major\", alpha=0.5)\n axs_1.set_xlabel(r\"Tagging efficiency %s\" % sig[\"legend\"])\n axs_1.set_ylabel(r\"Mistagging rate %s\" % bkg[\"legend\"])\n axs_1.set_ylim(0.0001, 1)\n axs_1.set_yscale(\"log\")\n\n i += 1\n\n if not mh:\n fig.savefig(\"%s/rocs_by_var_%s_ylog.pdf\" % (args.odir, sig[\"label\"]))\n else:\n fig.savefig(\"%s/rocs_by_var_%s_mh125_ylog.pdf\" % (args.odir, sig[\"label\"]))\n\n plt.close()\n\n\n# plot validation\ndef plot_validation(args, hist_val, vars_to_plot, label):\n for density in [True, False]:\n fig, axs = plt.subplots(1, len(vars_to_plot), figsize=(len(vars_to_plot) * 8, 8))\n for i, m in enumerate(vars_to_plot):\n if len(vars_to_plot) == 1:\n axs_1 = axs\n else:\n axs_1 = axs[i]\n x = hist_val.sum(*[ax for ax in hist_val.axes() if ax.name not in {\"process\", m}])\n # print hist values for debugging (in case hist is empty)\n # print(x.values())\n hist.plot1d(x, ax=axs_1, overlay=\"process\", density=density)\n axs_1.set_ylabel(\"Jets\")\n fig.tight_layout()\n if density:\n fig.savefig(\"%s/%s_density.pdf\" % (args.odir, label))\n else:\n fig.savefig(\"%s/%s.pdf\" % (args.odir, label))\n plt.close()\n\n\n# plot score after selection on variables\n# i.e. how does the score look when cutting on e.g. pt, gmass\ndef plot_score_aftercut(args, hist_val, vars_to_corr, bin_ranges, bin_widths, processes, label):\n print(\"plot_score_aftercut\")\n density = True\n for proc in processes:\n fig, axs = plt.subplots(1, len(vars_to_corr), figsize=(len(vars_to_corr) * 8, 8))\n for i, m in enumerate(vars_to_corr):\n if len(vars_to_corr) == 1:\n axs_1 = axs\n else:\n axs_1 = axs[i]\n x = hist_val.sum(\n *[ax for ax in hist_val.axes() if ax.name not in {\"process\", \"score\", m}]\n ).integrate(\"process\", proc)\n legends = []\n for j, b in enumerate(bin_ranges[i]):\n # print histogram identifiers for debugging\n # print(x.identifiers(m, overflow='all'))\n y = x.integrate(m, slice(b, b + bin_widths[i]))\n legends.append(\"%s %i-%i GeV\" % (m, b, b + bin_widths[i]))\n # print(b,b+bin_widths[i])\n # print(y.values())\n # print(x.values())\n if j == 0:\n hist.plot1d(y, ax=axs_1, density=True)\n else:\n hist.plot1d(y, ax=axs_1, density=True, clear=False)\n axs_1.set_ylabel(\"Jets\")\n axs_1.legend(legends, title=m)\n fig.tight_layout()\n fig.savefig(\"%s/%s_scores_%s_density.pdf\" % (args.odir, proc, label))\n plt.close()\n\n\n# compute percentiles\n\"\"\"\ni.e. the cuts that we should make on the tagger score so that we obtain this efficiency in our process after the cut\nuses np.quantile function\n\"\"\"\n\n\ndef computePercentiles(data, percentiles):\n mincut = 0.0\n tmp = np.quantile(data, np.array(percentiles))\n tmpl = [mincut]\n for x in tmp:\n tmpl.append(x)\n perc = [0.0]\n for x in percentiles:\n perc.append(x)\n return perc, tmpl\n\n\n# plot how variables look after a cut on the scores\ndef plot_var_aftercut(args, hist_val, vars_to_plot, processes, label, cuts, percentiles):\n print(\"plot variable after cut\")\n for density in [True, False]:\n for proc in processes:\n fig, axs = plt.subplots(1, len(vars_to_plot), figsize=(len(vars_to_plot) * 8, 8))\n for var in vars_to_plot:\n if len(vars_to_plot) == 1:\n axs_1 = axs\n else:\n axs_1 = axs[i]\n x = hist_val.sum(\n *[ax for ax in hist_val.axes() if ax.name not in {\"process\", var, \"score\"}]\n )\n x = x.integrate(\"process\", proc)\n legends = []\n # now cut on the score\n if not density:\n cuts.pop(0)\n percentiles.pop(0)\n # print('cuts on score ',cuts)\n for i, cut in enumerate(cuts):\n cut = round(cut, 2)\n # if i==len(cuts)-1:\n # print(slice(cut,1))\n y = x.integrate(\"score\", slice(cut, 1))\n legends.append(\"%s \" % (percentiles[i]))\n if i == 0:\n hist.plot1d(y, ax=axs_1, density=density)\n else:\n hist.plot1d(y, ax=axs_1, density=density, clear=False)\n axs_1.set_ylabel(\"Jets\")\n axs_1.legend(legends, title=\"Bkg quantile\")\n fig.tight_layout()\n if density:\n fig.savefig(\"%s/%s_scoresculpting_density.pdf\" % (args.odir, label))\n else:\n fig.savefig(\"%s/%s_scoresculpting.pdf\" % (args.odir, label))\n plt.close()\n\n\ndef main(args):\n\n # label dictionary\n label_dict = {\n \"qcd_old\": {\"legend\": \"QCD\", \"label\": \"fj_isQCD\"},\n \"qcd\": {\"legend\": \"QCD\", \"label\": \"fj_QCD_label\"},\n \"qcd_b\": {\"legend\": \"QCDb\", \"label\": \"fj_isQCDb\"},\n \"qcd_bb\": {\"legend\": \"QCDbb\", \"label\": \"fj_isQCDbb\"},\n \"qcd_c\": {\"legend\": \"QCDc\", \"label\": \"fj_isQCDc\"},\n \"qcd_cc\": {\"legend\": \"QCDcc\", \"label\": \"fj_isQCDcc\"},\n \"qcd_lep\": {\"legend\": \"QCDlep\", \"label\": \"fj_isQCDlep\"},\n \"qcd_lep\": {\"legend\": \"QCDlep\", \"label\": \"fj_isQCDlep\"},\n \"top\": {\"legend\": \"Top\", \"label\": \"fj_isTop_label\"},\n \"top_lep\": {\"legend\": \"Top lep\", \"label\": \"fj_isToplep\"},\n \"top_merged\": {\"legend\": \"Top merged\", \"label\": \"fj_isTop_merged\"},\n \"top_semimerged\": {\"legend\": \"Top semi-merged\", \"label\": \"fj_isTop_semimerged\"},\n \"top_lepmerged\": {\"legend\": \"Top merged lepton\", \"label\": \"fj_isToplep_merged\"},\n \"hww_4q\": {\"legend\": \"H(WW) all-had\", \"label\": \"fj_H_WW_4q\"},\n \"hww_4q_merged\": {\"legend\": \"H(WW) 4q\", \"label\": \"fj_H_WW_4q_4q\"},\n \"hww_3q_merged\": {\"legend\": \"H(WW) 3q\", \"label\": \"fj_H_WW_4q_3q\"},\n \"hbb\": {\"legend\": \"H(bb)\", \"label\": \"fj_H_bb\"},\n \"hww_elenuqq\": {\"legend\": \"H(WW) ele\", \"label\": \"fj_H_WW_elenuqq\"},\n \"hww_munuqq\": {\"legend\": \"H(WW) mu\", \"label\": \"fj_H_WW_munuqq\"},\n \"hww_taunuqq\": {\"legend\": \"H(WW) tau merged\", \"label\": \"fj_isHWW_taunuqq_merged\"},\n \"hww_munuqq_merged\": {\"legend\": \"H(WW) mu merged\", \"label\": \"fj_isHWW_munuqq_merged\"},\n \"hww_munuqq_semimerged\": {\n \"legend\": \"H(WW) mu semi-merged\",\n \"label\": \"fj_isHWW_munuqq_semimerged\",\n },\n \"hww_elenuqq_merged\": {\"legend\": \"H(WW) ele merged\", \"label\": \"fj_isHWW_elenuqq_merged\"},\n \"hww_elenuqq_semimerged\": {\n \"legend\": \"H(WW) ele semi-merged\",\n \"label\": \"fj_isHWW_elenuqq_semimerged\",\n },\n \"hww_taunuqq_merged\": {\"legend\": \"H(WW) tau merged\", \"label\": \"fj_isHWW_taunuqq_merged\"},\n \"hww_taunuqq_semimerged\": {\n \"legend\": \"H(WW) tau semi-merged\",\n \"label\": \"fj_isHWW_taunuqq_semimerged\",\n },\n }\n\n # get signals and backgrounds\n signals = args.signals.split(\",\")\n backgrounds = args.bkgs.split(\",\")\n if len(signals) != len(backgrounds):\n print(\"Number of signals should be the same as backgrounds!\")\n exit\n\n for i, signal in enumerate(signals):\n bkg = backgrounds[i]\n bkglabel = label_dict[bkg][\"label\"]\n siglabel = label_dict[signal][\"label\"]\n\n # default branches\n branches = [\"fj_pt\", \"fj_msoftdrop\"]\n branches += [mass_branch]\n branches += [siglabel]\n branches += [\"score_%s\" % siglabel, \"score_%s\" % bkglabel]\n # add older taggers\n if signal == \"hww_4q\" or signal == \"hww_4q_merged\" or signal == \"hww_3q_merged\":\n # branches += [\"fj_deepTagMD_H4qvsQCD\",\"fj_deepTag_HvsQCD\"] # values are always -1000?\n branches += [\"fj_PN_H4qvsQCD\"] # when included in observers?\n\n # add this only if nProngs is saved\n add_nProngs = False\n # add_nProngs = True\n if add_nProngs:\n branches += [\"fj_nProngs\"]\n\n # add selection (add selection such that QCD only has gen resonance mass < 0)\n mask = (\n \"(fj_pt<1200) &\"\n \"(fj_pt>300) &\"\n \"((((fj_isQCDb==1) | (fj_isQCDbb==1) | (fj_isQCDc==1) | (fj_isQCDcc==1) | (fj_isQCDlep==1) | (fj_isQCDothers==1)) & (fj_genRes_mass<0)) |\"\n \"((%s==1) & (fj_genRes_mass>0) ) )\" % siglabel\n )\n if bkg == \"qcd_old\":\n mask = (\n \"(fj_pt<1200) & (fj_pt>300) & (((fj_isQCD==1) & (%s<0)) | ((%s==1) & (%s>0) ) )\"\n % (mass_branch, siglabel, mass_branch)\n )\n\n ifile = uproot.open(args.ifile)[\"Events\"]\n isqcd_separate = False\n if \"qcd\" in bkg:\n if bkg == \"qcd\":\n ibranches = branches + [\n \"fj_isQCDb\",\n \"fj_isQCDbb\",\n \"fj_isQCDc\",\n \"fj_isQCDcc\",\n \"fj_isQCDlep\",\n \"fj_isQCDothers\",\n ]\n ibranches.remove(\"score_%s\" % bkglabel)\n ibranches.extend(\n [\n \"score_fj_isQCDb\",\n \"score_fj_isQCDbb\",\n \"score_fj_isQCDc\",\n \"score_fj_isQCDcc\",\n \"score_fj_isQCDlep\",\n \"score_fj_isQCDothers\",\n ]\n )\n # print(ibranches)\n events = ifile.arrays(ibranches, mask)\n events_fj_QCD_label_TrueFalse = (\n (events[\"fj_isQCDb\"] == 1)\n | (events[\"fj_isQCDbb\"] == 1)\n | (events[\"fj_isQCDc\"] == 1)\n | (events[\"fj_isQCDcc\"] == 1)\n | (events[\"fj_isQCDlep\"] == 1)\n | (events[\"fj_isQCDothers\"] == 1)\n )\n events[\"fj_QCD_label\"] = ak.values_astype(events_fj_QCD_label_TrueFalse, int)\n isqcd_separate = True\n print(\"Added fj_QCD_label to ttree\")\n else:\n # ibranches = branches + [\"fj_QCD_label\"]\n print(branches)\n ibranches = branches + [\"fj_isQCD\"]\n events = ifile.arrays(ibranches, mask)\n elif \"top\" in bkg:\n ibranches = branches + [\"fj_Top_label\"]\n events = ifile.arrays(ibranches)\n else:\n print(\"not known background\")\n print(\"List of branches read \", ibranches)\n\n # compute scores:\n \"\"\"\n we expect all scores to sum up to 1, e.g. given two signals in the event (signal 1 and 2) and one background process (background 1):\n score_signal_1 + score_signal_2 + score_background_1 = 1\n then nn_signal_1 = score_signal_1 / (score_signal_1 + score_background_1) = score_signal_1 / (1 - score_signal_2)\n \"\"\"\n score_name = \"%s_score\" % args.name\n if isqcd_separate:\n events[score_name] = events[\"score_%s\" % siglabel] / (\n events[\"score_%s\" % siglabel]\n + events[\"score_fj_isQCDb\"]\n + events[\"score_fj_isQCDbb\"]\n + events[\"score_fj_isQCDc\"]\n + events[\"score_fj_isQCDcc\"]\n + events[\"score_fj_isQCDlep\"]\n + events[\"score_fj_isQCDothers\"]\n )\n else:\n events[score_name] = events[\"score_%s\" % siglabel] / (\n events[\"score_%s\" % siglabel] + events[\"score_%s\" % bkglabel]\n )\n\n # define and fill coffea histograms\n hist_features = hist.Hist(\n \"Jets\",\n hist.Cat(\"process\", \"Process\"),\n hist.Bin(\"msd\", r\"fj msoftdrop [GeV]\", 60, 30, 420),\n hist.Bin(\"pt\", r\"fj $p_T$ [GeV]\", 50, 200, 1200), # bins of 20\n hist.Bin(\"score\", r\"Tagger score\", 100, 0, 1),\n )\n hist_gmass = hist.Hist(\n \"genmass\",\n hist.Cat(\"process\", \"Process\"),\n hist.Bin(\"score\", r\"Tagger score\", 70, 0, 1),\n hist.Bin(\"pt\", r\"fj $p_T$ [GeV]\", 50, 200, 1200), # bins of 20\n hist.Bin(\"mH\", r\"gen Res mass [GeV]\", 42, 50, 260), # bins of 5\n )\n\n # define processes\n # add mh125 and mh!=125 as different processes so that we can see dependence\n processes = [bkg]\n if \"hww\" in signal or \"hbb\" in signal:\n processes.append(\"%s-mh125\" % signal)\n processes.append(\"%s-mhflat\" % signal)\n\n # loop over processes\n legends = {}\n for proc in processes:\n p = proc.split(\"-\")[0]\n legend = label_dict[p][\"legend\"]\n if \"mh125\" in proc:\n mask_proc = (events[label_dict[p][\"label\"]] == 1) & (events[mass_branch] == 125)\n legend += \" mh125\"\n elif \"mhflat\" in proc:\n # beware of mRes = 175....\n mask_proc = (events[label_dict[p][\"label\"]] == 1) & (events[mass_branch] != 125)\n legend += \" mhflat\"\n else:\n mask_proc = events[label_dict[p][\"label\"]] == 1\n legends[proc] = legend\n # check if events with that mask are not zero\n if len(events[\"fj_msoftdrop\"][mask_proc]) == 0:\n processes.remove(proc)\n continue\n\n # print legends\n # print('legend ',legend)\n\n # fill the features histogram\n hist_features.fill(\n process=proc,\n msd=events[\"fj_msoftdrop\"][mask_proc],\n pt=events[\"fj_pt\"][mask_proc],\n score=events[score_name][mask_proc],\n )\n\n # only fill the gen mass histogram for signal\n if signal in proc:\n hist_gmass.fill(\n process=proc,\n mH=events[mass_branch][mask_proc],\n score=events[score_name][mask_proc],\n pt=events[\"fj_pt\"][mask_proc],\n )\n\n # get pt histograms\n # define log bins as: np.round(np.exp(np.linspace(np.log(MIN), np.log(MAX), NUM_BINS))).astype('int').tolist()\n # ptbins = [200, 239, 286, 342, 409, 489, 585, 699, 836, 1000, 2500]\n ptbins = [200, 251, 316, 398, 501, 630, 793, 997, 1255, 1579, 1987, 2500]\n mask_proc_sigmh125 = (events[label_dict[signal][\"label\"]] == 1) & (\n events[mass_branch] == 125\n )\n mask_proc_sig = (events[label_dict[signal][\"label\"]] == 1) & (events[mass_branch] != 125)\n pthistsigmh, bin_edges = np.histogram(\n events[\"fj_pt\"][mask_proc_sigmh125].to_numpy(), bins=ptbins\n )\n pthistsig, bin_edges = np.histogram(events[\"fj_pt\"][mask_proc_sig].to_numpy(), bins=ptbins)\n pthist = pthistsigmh / pthistsig\n\n # plot weight histogram\n weight_sig = pthist[np.digitize(events[\"fj_pt\"][mask_proc_sig].to_numpy(), ptbins) - 1]\n fig, axs = plt.subplots(1, 1)\n axs.hist(events[\"fj_pt\"][mask_proc_sig], bins=ptbins, histtype=\"step\")\n axs.hist(events[\"fj_pt\"][mask_proc_sig], bins=ptbins, weights=weight_sig, histtype=\"step\")\n axs.set_xlabel(\"pT (GeV)\")\n axs.legend([\"Unweighted\", \"Weighted\"])\n fig.savefig(\"%s/ptweights_%s.pdf\" % (args.odir, label_dict[signal][\"label\"]))\n fig, axs = plt.subplots(1, 1)\n axs.hist(events[\"fj_pt\"][mask_proc_sig], bins=ptbins, histtype=\"step\", density=True)\n axs.hist(\n events[\"fj_pt\"][mask_proc_sig],\n bins=ptbins,\n weights=weight_sig,\n histtype=\"step\",\n density=True,\n )\n axs.set_xlabel(\"pT (GeV)\")\n axs.legend([\"Unweighted\", \"Weighted\"])\n fig.savefig(\"%s/ptweights_%s_density.pdf\" % (args.odir, label_dict[signal][\"label\"]))\n plt.close()\n\n # masks\n mask_flat = events[mass_branch] != 125\n mask_mh125 = events[mass_branch] == 125\n mask_proc_mh120130 = (\n (events[mass_branch] >= 120)\n & (events[mass_branch] <= 130)\n & (events[\"fj_pt\"] <= 600)\n & mask_flat\n )\n\n # get ROC\n fprs = {}\n tprs = {}\n fprs[score_name], tprs[score_name] = get_roc(events, score_name, siglabel, bkglabel)\n\n # get ROC for flat sample with pt weights\n fprs[score_name + \"flat_weight\"], tprs[score_name + \"flat_weight\"] = get_roc(\n events,\n score_name,\n siglabel,\n bkglabel,\n weight_hist=pthist,\n bins=ptbins,\n sig_mask=mask_flat,\n )\n fprs[score_name + \"flat\"], tprs[score_name + \"flat\"] = get_roc(\n events, score_name, siglabel, bkglabel, weight_hist=None, bins=None, sig_mask=mask_flat\n )\n\n # get ROC for flat sample with mass around mass of higgs\n (\n fprs[score_name + \"flat_mh120130-pt200600\"],\n tprs[score_name + \"flat_mh120130-pt200600\"],\n ) = get_roc(\n events,\n score_name,\n siglabel,\n bkglabel,\n weight_hist=None,\n bins=None,\n sig_mask=mask_proc_mh120130,\n )\n (\n fprs[score_name + \"flat_mh120130-pt200600-weight\"],\n tprs[score_name + \"flat_mh120130-pt200600-weight\"],\n ) = get_roc(\n events,\n score_name,\n siglabel,\n bkglabel,\n weight_hist=pthist,\n bins=ptbins,\n sig_mask=mask_proc_mh120130,\n )\n\n # get ROC for Particle Net if 3q/4q\n if signal == \"hww_4q\" or signal == \"hww_4q_merged\" or signal == \"hww_3q_merged\":\n # fprs['DeepAK8_H4q_MD_flat'], tprs['DeepAK8_H4q_MD_flat'] = get_roc(events, \"fj_deepTagMD_H4qvsQCD\", siglabel, bkglabel,sig_mask=mask_flat)\n # fprs['DeepAK8_H_flat'], tprs['DeepAK8_H_flat'] = get_roc(events, \"fj_deepTag_HvsQCD\", siglabel, bkglabel,sig_mask=mask_flat)\n fprs[\"PN_H4q_flat\"], tprs[\"PN_H4q_flat\"] = get_roc(\n events, \"fj_PN_H4qvsQCD\", siglabel, bkglabel, sig_mask=mask_flat\n )\n\n # get ROCs for score but for 3q/4q independently\n if add_nProngs:\n mask_proc_3q = (events[\"fj_nProngs\"] == 3) & mask_flat\n mask_proc_4q = (events[\"fj_nProngs\"] == 4) & mask_flat\n fprs[score_name + \"_flat_3q\"], tprs[score_name + \"_flat_3q\"] = get_roc(\n events,\n score_name,\n siglabel,\n bkglabel,\n weight_hist=None,\n bins=None,\n sig_mask=mask_proc_3q,\n )\n fprs[score_name + \"_flat_4q\"], tprs[score_name + \"_flat_4q\"] = get_roc(\n events,\n score_name,\n siglabel,\n bkglabel,\n weight_hist=None,\n bins=None,\n sig_mask=mask_proc_4q,\n )\n\n # plot ROCs\n plot_roc(\n args, label_dict[signal], label_dict[bkg], fprs, tprs, label=label_dict[signal][\"label\"]\n )\n\n # plot features for this signal and background combination (i.e. all the processes)\n vars_to_plot = [\"pt\", \"msd\", \"score\"]\n plt_label = \"validation_%svs%s\" % (siglabel, bkglabel)\n plot_validation(args, hist_features, vars_to_plot, plt_label)\n\n # plot how the score looks after cuts on variables\n vars_to_corr = [\"mH\", \"pt\"]\n bin_ranges = [list(range(60, 240, 20)), list(range(200, 1200, 200))]\n bin_widths = [10, 200]\n proc_to_corr = [\"%s-mhflat\" % signal]\n plt_label = \"%svs%s\" % (siglabel, bkglabel)\n # plot_score_aftercut(args,hist_gmass,vars_to_corr,bin_ranges,bin_widths,proc_to_corr,plt_label)\n\n # plot roc for different cuts on mH and pt\n vars_to_corr = {\"mH\": mass_branch, \"pt\": \"fj_pt\"}\n plot_roc_by_var(\n args,\n vars_to_corr,\n bin_ranges,\n bin_widths,\n events,\n score_name,\n label_dict[signal],\n label_dict[bkg],\n )\n\n # accumulate rocs for summary\n fprs_summary = {}\n tprs_summary = {}\n fprs_summary[\"flat\"] = fprs[score_name + \"flat\"]\n tprs_summary[\"flat\"] = tprs[score_name + \"flat\"]\n fprs_summary[\"flat-mhptSM\"] = fprs[score_name + \"flat_mh120130-pt200600-weight\"]\n tprs_summary[\"flat-mhptSM\"] = tprs[score_name + \"flat_mh120130-pt200600-weight\"]\n if signal == \"hww_4q\" or signal == \"hww_4q_merged\" or signal == \"hww_3q_merged\":\n fprs_summary[\"flat-PN4q\"] = fprs[\"PN_H4q_flat\"]\n tprs_summary[\"flat-PN4q\"] = tprs[\"PN_H4q_flat\"]\n\n # plot roc for mh=125\n fprs = {} # reset fprs\n mask_mh125_100150 = (\n mask_mh125 & (events[\"fj_msoftdrop\"] >= 100) & (events[\"fj_msoftdrop\"] <= 150)\n )\n mask_100150 = (events[\"fj_msoftdrop\"] >= 100) & (events[\"fj_msoftdrop\"] <= 150)\n fprs[score_name + \"_mh125\"], tprs[score_name + \"_mh125\"] = get_roc(\n events, score_name, siglabel, bkglabel, weight_hist=None, bins=None, sig_mask=mask_mh125\n )\n # fprs[score_name+'_mh125_msd100-150'], tprs[score_name+'_mh125_msd100-150'] = get_roc(events, score_name, siglabel, bkglabel, weight_hist=None, bins=None, sig_mask=mask_mh125_100150, bkg_mask=mask_100150)\n if signal == \"hww_4q\" or signal == \"hww_4q_merged\" or signal == \"hww_3q_merged\":\n fprs[\"PN_H4q_mh125-nonMD\"], tprs[\"PN_H4q_mh125-nonMD\"] = get_roc(\n events, \"fj_PN_H4qvsQCD\", siglabel, bkglabel, sig_mask=mask_mh125\n )\n fprs[\"PN_H4q_mh125_msd100-150\"], tprs[\"PN_H4q_mh125_msd100-150\"] = get_roc(\n events,\n \"fj_PN_H4qvsQCD\",\n siglabel,\n bkglabel,\n sig_mask=mask_mh125_100150,\n bkg_mask=mask_100150,\n )\n if add_nProngs:\n mask_proc_3q = (events[\"fj_nProngs\"] == 3) & mask_mh125\n mask_proc_4q = (events[\"fj_nProngs\"] == 4) & mask_mh125\n fprs[score_name + \"_mh125_4q\"], tprs[score_name + \"_mh125_4q\"] = get_roc(\n events,\n score_name,\n siglabel,\n bkglabel,\n weight_hist=None,\n bins=None,\n sig_mask=mask_proc_4q,\n )\n fprs[score_name + \"_mh125_3q\"], tprs[score_name + \"_mh125_3q\"] = get_roc(\n events,\n score_name,\n siglabel,\n bkglabel,\n weight_hist=None,\n bins=None,\n sig_mask=mask_proc_3q,\n )\n fprs[\"PN_H4q_mh125-nonMD_4q\"], tprs[\"PN_H4q_mh125-nonMD_4q\"] = get_roc(\n events, \"fj_PN_H4qvsQCD\", siglabel, bkglabel, sig_mask=mask_proc_4q\n )\n fprs[\"PN_H4q_mh125-nonMD_3q\"], tprs[\"PN_H4q_mh125-nonMD_3q\"] = get_roc(\n events, \"fj_PN_H4qvsQCD\", siglabel, bkglabel, sig_mask=mask_proc_3q\n )\n plot_roc(\n args,\n label_dict[signal],\n label_dict[bkg],\n fprs,\n tprs,\n label=label_dict[signal][\"label\"] + \"_mh125_all\",\n )\n\n # more rocs for summary\n fprs_summary[\"SM\"] = fprs[score_name + \"_mh125\"]\n tprs_summary[\"SM\"] = tprs[score_name + \"_mh125\"]\n if signal == \"hww_4q\" or signal == \"hww_4q_merged\" or signal == \"hww_3q_merged\":\n fprs_summary[\"SM-PN4q-msd100-150\"] = fprs[\"PN_H4q_mh125_msd100-150\"]\n tprs_summary[\"SM-PN4q-msd100-150\"] = tprs[\"PN_H4q_mh125_msd100-150\"]\n\n # plot roc summary\n plot_roc(\n args,\n label_dict[signal],\n label_dict[bkg],\n fprs_summary,\n tprs_summary,\n label=label_dict[signal][\"label\"] + \"_summary\",\n )\n\n # xcheck plot for mh=125\n vars_to_corr = {\"mH\": mass_branch, \"pt\": \"fj_pt\"}\n bin_ranges = [[125, 125], list(range(200, 1200, 200))]\n bin_widths = [4, 200]\n plot_roc_by_var(\n args,\n vars_to_corr,\n bin_ranges,\n bin_widths,\n events,\n score_name,\n label_dict[signal],\n label_dict[bkg],\n True,\n )\n\n # plot how variables look after cut on classifier (tagger score)\n vars_to_corr = [\"msd\"]\n proc_to_corr = [bkg]\n plt_label = \"aftercuts_%svs%s\" % (siglabel, bkglabel)\n # first compute percentiles on bkg (or maybe other process?)\n percentiles, cuts = computePercentiles(\n events[score_name][(events[bkglabel] == 1)].to_numpy(), [0.97, 0.99, 0.995]\n )\n plot_var_aftercut(\n args, hist_features, vars_to_corr, proc_to_corr, plt_label, cuts, percentiles\n )\n\n\nif __name__ == \"__main__\":\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--ifile\", help=\"input file(s)\")\n parser.add_argument(\"--odir\", required=True, help=\"output dir\")\n parser.add_argument(\"--name\", required=True, help=\"name of the model(s)\")\n parser.add_argument(\"--signals\", default=\"hww_4q_merged\", help=\"signals\")\n parser.add_argument(\n \"--bkgs\",\n default=\"qcd\",\n help=\"backgrounds (if qcd_label then assume that you only have one qcd label)\",\n )\n args = parser.parse_args()\n\n import os\n\n os.system(\"mkdir -p %s\" % args.odir)\n\n main(args)\n", "meta": {"hexsha": "3563c9a963db5ecc96ca8fbe9c5771172e5edad5", "size": 33319, "ext": "py", "lang": "Python", "max_stars_repo_path": "plot_classification_fromoutput.py", "max_stars_repo_name": "rkansal47/weaver", "max_stars_repo_head_hexsha": "7e9d3d8c9ee43acb2a95f2d3f76c384822e04699", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-06-25T19:19:39.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-28T20:31:56.000Z", "max_issues_repo_path": "plot_classification_fromoutput.py", "max_issues_repo_name": "rkansal47/weaver", "max_issues_repo_head_hexsha": "7e9d3d8c9ee43acb2a95f2d3f76c384822e04699", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2021-07-02T03:56:02.000Z", "max_issues_repo_issues_event_max_datetime": "2021-11-04T07:40:41.000Z", "max_forks_repo_path": "plot_classification_fromoutput.py", "max_forks_repo_name": "rkansal47/weaver", "max_forks_repo_head_hexsha": "7e9d3d8c9ee43acb2a95f2d3f76c384822e04699", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 11, "max_forks_repo_forks_event_min_datetime": "2020-08-26T21:14:08.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-07T14:58:01.000Z", "avg_line_length": 39.060961313, "max_line_length": 214, "alphanum_fraction": 0.537981332, "include": true, "reason": "import numpy", "num_tokens": 9313, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792044, "lm_q2_score": 0.3923368301671084, "lm_q1q2_score": 0.19923329715255295}} {"text": "# Copyright 2019 The Cirq Developers\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom typing import Any, Iterable, Iterator, List, Optional, Sequence, Tuple, Union\n\nimport numpy as np\n\nimport cirq\nfrom cirq import ops, linalg, value\nfrom cirq.interop.quirk.cells.cell import Cell, CellMaker\n\n\n@value.value_equality\nclass InputRotationCell(Cell):\n \"\"\"Applies an operation that depends on an input gate.\"\"\"\n\n def __init__(\n self,\n identifier: str,\n register: Optional[Sequence['cirq.Qid']],\n base_operation: 'cirq.Operation',\n exponent_sign: int,\n ):\n self.identifier = identifier\n self.register = None if register is None else tuple(register)\n self.base_operation = base_operation\n self.exponent_sign = exponent_sign\n\n def _value_equality_values_(self) -> Any:\n return (\n self.identifier,\n self.register,\n self.base_operation,\n self.exponent_sign,\n )\n\n def __repr__(self) -> str:\n return (\n f'cirq.interop.quirk.cells.input_rotation_cells.InputRotationCell('\n f'\\n {self.identifier!r},'\n f'\\n {self.register!r},'\n f'\\n {self.base_operation!r},'\n f'\\n {self.exponent_sign!r})'\n )\n\n def gate_count(self) -> int:\n return 1\n\n def with_line_qubits_mapped_to(self, qubits: List['cirq.Qid']) -> 'Cell':\n return InputRotationCell(\n self.identifier,\n None if self.register is None else Cell._replace_qubits(self.register, qubits),\n self.base_operation.with_qubits(\n *Cell._replace_qubits(self.base_operation.qubits, qubits)\n ),\n exponent_sign=self.exponent_sign,\n )\n\n def with_input(self, letter: str, register: Union[Sequence['cirq.Qid'], int]) -> 'Cell':\n # Parameterized rotations use input A as their parameter.\n if self.register is None and letter == 'a':\n if isinstance(register, int):\n raise ValueError(\n 'Dependent operation requires known length '\n 'input; classical constant not allowed.'\n )\n return InputRotationCell(\n self.identifier, register, self.base_operation, self.exponent_sign\n )\n return self\n\n def controlled_by(self, qubit: 'cirq.Qid'):\n return InputRotationCell(\n self.identifier,\n self.register,\n self.base_operation.controlled_by(qubit),\n self.exponent_sign,\n )\n\n def operations(self) -> 'cirq.OP_TREE':\n if self.register is None:\n raise ValueError(f\"Missing input 'a'\")\n return QuirkInputRotationOperation(\n self.identifier, self.register, self.base_operation, self.exponent_sign\n )\n\n\n@value.value_equality\nclass QuirkInputRotationOperation(ops.Operation):\n \"\"\"Operates on target qubits in a way that varies based on an input qureg.\"\"\"\n\n def __init__(\n self,\n identifier: str,\n register: Iterable['cirq.Qid'],\n base_operation: 'cirq.Operation',\n exponent_sign: int,\n ):\n if exponent_sign not in [-1, +1]:\n raise ValueError('exponent_sign not in [-1, +1]')\n self.identifier = identifier\n self.register = tuple(register)\n self.base_operation = base_operation\n self.exponent_sign = exponent_sign\n\n def _value_equality_values_(self) -> Any:\n return (\n self.identifier,\n self.register,\n self.base_operation,\n self.exponent_sign,\n )\n\n @property\n def qubits(self) -> Tuple['cirq.Qid', ...]:\n return tuple(self.base_operation.qubits) + self.register\n\n def with_qubits(self, *new_qubits):\n k = len(self.base_operation.qubits)\n new_op_qubits = new_qubits[:k]\n new_register = new_qubits[k:]\n return QuirkInputRotationOperation(\n self.identifier,\n new_register,\n self.base_operation.with_qubits(*new_op_qubits),\n self.exponent_sign,\n )\n\n def _circuit_diagram_info_(self, args: 'cirq.CircuitDiagramInfoArgs'):\n sub_result = cirq.circuit_diagram_info(self.base_operation)\n sign_char = '-' if self.exponent_sign == -1 else ''\n symbols = list(sub_result.wire_symbols)\n symbols.extend(f'A{i}' for i in range(len(self.register)))\n return cirq.CircuitDiagramInfo(\n tuple(symbols),\n exponent=f'({sign_char}A/2^{len(self.register)})',\n exponent_qubit_index=sub_result.exponent_qubit_index or 0,\n auto_exponent_parens=False,\n )\n\n def _has_unitary_(self) -> bool:\n return True\n\n def _apply_unitary_(self, args: 'cirq.ApplyUnitaryArgs'):\n transposed_args = args.with_axes_transposed_to_start()\n\n target_axes = transposed_args.axes[: len(self.base_operation.qubits)]\n control_axes = transposed_args.axes[len(self.base_operation.qubits) :]\n control_max = np.prod([q.dimension for q in self.register], dtype=np.int64).item()\n\n for i in range(control_max):\n operation = self.base_operation ** (self.exponent_sign * i / control_max)\n control_index = linalg.slice_for_qubits_equal_to(control_axes, big_endian_qureg_value=i)\n sub_args = cirq.ApplyUnitaryArgs(\n transposed_args.target_tensor[control_index],\n transposed_args.available_buffer[control_index],\n target_axes,\n )\n sub_result = cirq.apply_unitary(operation, sub_args)\n\n if sub_result is not sub_args.target_tensor:\n sub_args.target_tensor[...] = sub_result\n\n return args.target_tensor\n\n def __repr__(self) -> str:\n return (\n f'cirq.interop.quirk.QuirkInputRotationOperation('\n f'identifier={self.identifier!r}, '\n f'register={self.register!r}, '\n f'base_operation={self.base_operation!r}, '\n f'exponent_sign={self.exponent_sign!r})'\n )\n\n\ndef generate_all_input_rotation_cell_makers() -> Iterator[CellMaker]:\n yield _input_rotation_gate(\"X^(A/2^n)\", ops.X, +1)\n yield _input_rotation_gate(\"Y^(A/2^n)\", ops.Y, +1)\n yield _input_rotation_gate(\"Z^(A/2^n)\", ops.Z, +1)\n yield _input_rotation_gate(\"X^(-A/2^n)\", ops.X, -1)\n yield _input_rotation_gate(\"Y^(-A/2^n)\", ops.Y, -1)\n yield _input_rotation_gate(\"Z^(-A/2^n)\", ops.Z, -1)\n\n\ndef _input_rotation_gate(identifier: str, gate: 'cirq.Gate', exponent_sign: int) -> CellMaker:\n return CellMaker(\n identifier,\n gate.num_qubits(),\n lambda args: InputRotationCell(\n identifier=identifier,\n register=None,\n base_operation=gate.on(args.qubits[0]),\n exponent_sign=exponent_sign,\n ),\n )\n", "meta": {"hexsha": "53a8c2bd41dd92240d4d4717fba773f1840495ea", "size": 7417, "ext": "py", "lang": "Python", "max_stars_repo_path": "cirq-core/cirq/interop/quirk/cells/input_rotation_cells.py", "max_stars_repo_name": "peterse/Cirq", "max_stars_repo_head_hexsha": "31daa9410a0e1e1ac3da38109aa8ce3a15aed17b", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 3326, "max_stars_repo_stars_event_min_datetime": "2018-07-18T23:17:21.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T22:28:24.000Z", "max_issues_repo_path": "cirq-core/cirq/interop/quirk/cells/input_rotation_cells.py", "max_issues_repo_name": "peterse/Cirq", "max_issues_repo_head_hexsha": "31daa9410a0e1e1ac3da38109aa8ce3a15aed17b", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 3443, "max_issues_repo_issues_event_min_datetime": "2018-07-18T21:07:28.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T20:23:21.000Z", "max_forks_repo_path": "cirq-core/cirq/interop/quirk/cells/input_rotation_cells.py", "max_forks_repo_name": "peterse/Cirq", "max_forks_repo_head_hexsha": "31daa9410a0e1e1ac3da38109aa8ce3a15aed17b", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 865, "max_forks_repo_forks_event_min_datetime": "2018-07-18T23:30:24.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-30T11:43:23.000Z", "avg_line_length": 35.8309178744, "max_line_length": 100, "alphanum_fraction": 0.629904274, "include": true, "reason": "import numpy", "num_tokens": 1672, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792044, "lm_q2_score": 0.3923368301671084, "lm_q1q2_score": 0.19923329715255295}} {"text": "import copy\nimport os\nimport sys\nimport subprocess\nimport argparse\nimport time\nimport random\nimport numpy as np\n\nimport torch\nfrom torch.utils.data import DataLoader\n\nimport log\nfrom models import MLP_300_100, VGG11, PreActResNet18\nfrom utils import (train_loop, eval_loop, kaiming_init, get_cifar10_loader,\n get_cifar10_loader_gpu, get_mnist_sets)\nfrom pruning import get_mask_iteratively, mask_net\n\n\nDATA_PATH = os.path.join(os.environ['SLURM_TMPDIR'], 'data')\nXP_PATH = os.path.join(os.environ['SLURM_TMPDIR'], 'results')\n\n\ndef get_model(args):\n # Build network\n log.log_comment('Building Model')\n if args.arch == 'MLP':\n net = MLP_300_100()\n elif args.arch == 'VGG11':\n net = VGG11()\n elif args.arch == 'PreActResNet18':\n net = PreActResNet18()\n else:\n raise NotImplementedError\n net.to('cuda')\n # Initialize it\n kaiming_init(net)\n # Print it\n log.log_comment('Network:')\n for s in str(net).split('\\n'):\n log.log_comment(s)\n n = sum(p.numel() for p in net.parameters() if p.requires_grad)\n log.log_comment(' - Number of parameters: %i' % n)\n return net\n\n\ndef main():\n # -------------------------------------------------------------------------\n # Argumet Parser\n\n parser = argparse.ArgumentParser(description='SNIP on CIFAR10')\n\n # Lottery Ticket\n parser.add_argument('--pr', type=float, default=0.956,\n help='Pruning ratio')\n parser.add_argument('--pm', type=str, default='MP',\n choices=['MP', 'LM', 'QM', 'OBD'],\n help='Pruning method')\n parser.add_argument('--pi', type=int, default=1,\n help='Number of iterations of pruning.')\n parser.add_argument('--pe', type=int, default=0,\n help='Iteration before which we prune.')\n parser.add_argument('--reg', type=float, default=0.0,\n help='Regularization parameter for snip and obsn.')\n parser.add_argument('--nex', type=int, default=1000,\n help='Number of examples for pruning algorithms')\n parser.add_argument('--exp', action='store_true',\n help='Use eponential pruning steps')\n\n # Model\n parser.add_argument('--arch', default='VGG11', type=str,\n choices=['MLP', 'VGG11', 'PreActResNet18'],\n help='Model achitecture.')\n parser.add_argument('--model_0', type=str, default=None,\n help='Path to a saved network.')\n\n # Optimizer\n parser.add_argument('--lr', default=0.01, type=float,\n help='Learning rate.')\n parser.add_argument('--dec', default=1., type=float,\n help='Learning rate decay (exponential).')\n parser.add_argument('--dec_every', default=1, type=int,\n help='Number of epochs between decay.')\n parser.add_argument('--l2', default=0.0005, type=float,\n help='L2 regularization.')\n\n # Experiment Management\n parser.add_argument('--path', type=str, default=XP_PATH,\n help='Path for experiment')\n parser.add_argument('--data_path', default=DATA_PATH, type=str,\n help='Path for the data')\n parser.add_argument('--num_workers', default=4, type=int,\n help='Number of workers to prepare data.')\n parser.add_argument('--nepochs', default=200, type=int,\n help='Number of epochs to run.')\n parser.add_argument('--seed', default=1111, type=int,\n help='Seed of the random number generators.')\n args = parser.parse_args()\n\n assert torch.cuda.is_available() # Only train on GPU\n torch.manual_seed(args.seed)\n torch.cuda.manual_seed_all(args.seed)\n random.seed(args.seed)\n torch.backends.cudnn.deterministic = True\n torch.backends.cudnn.benchmark = False\n\n # -------------------------------------------------------------------------\n # Preparing Paths and Log\n\n name = ''\n for k, v in sorted(args.__dict__.items(), key=lambda a: a[0]):\n if k not in ['path', 'data_path', 'num_workers']:\n if k == 'model_0' and v is not None:\n v = True\n name += '%s=%s,' % (k, str(v))\n name = name[:-1]\n\n if args.path is not None:\n xp_path = os.path.join(args.path, name)\n if not os.path.isdir(xp_path):\n os.makedirs(xp_path)\n else:\n sys.exit('Experiment already exists!')\n log_path = os.path.join(xp_path, 'log.txt')\n else:\n log_path = None\n log.prepare_log(log_path)\n log.log_comment('Pruning Experiment')\n try:\n repo = subprocess.check_output(['git', 'rev-parse', 'HEAD'],\n encoding='utf-8').strip()\n except:\n repo = 'None'\n log.log_comment('Git commit: ' + repo)\n log.log_comment('Arguments:')\n for k in sorted(args.__dict__.keys()):\n log.log_comment(' - %s %s' % (k, str(args.__dict__[k])))\n\n # -------------------------------------------------------------------------\n # Preparing Data Streams\n\n log.log_comment('Preparing data')\n if args.arch == 'MLP':\n train_set, valid_set, test_set = get_mnist_sets(args.seed,\n args.data_path)\n train_loader = DataLoader(train_set, batch_size=100, shuffle=True)\n valid_loader = (valid_set.tensors,)\n test_loader = (test_set.tensors,)\n fisher_loader = DataLoader(train_set, batch_size=args.nex,\n shuffle=True)\n else:\n train_loader = get_cifar10_loader('train', 100, args.num_workers, True,\n args.data_path)\n valid_loader = get_cifar10_loader_gpu('valid', 5000, args.num_workers,\n False, args.data_path)\n test_loader = get_cifar10_loader_gpu('test', 5000, args.num_workers,\n False, args.data_path)\n fisher_loader = get_cifar10_loader_gpu('train', 100, args.num_workers,\n True, args.data_path,\n which_transform='valid')\n\n # -------------------------------------------------------------------------\n # Preparing Model and Optimizer\n\n if args.model_0 is not None:\n net = torch.load(args.model_0)\n else:\n net = get_model(args)\n mask = None\n optimizer = torch.optim.SGD(net.parameters(), lr=args.lr, momentum=0.9,\n weight_decay=args.l2)\n scheduler = torch.optim.lr_scheduler.StepLR(optimizer,\n step_size=args.dec_every,\n gamma=args.dec,\n last_epoch=-1)\n\n # -------------------------------------------------------------------------\n # Main Loop\n\n form = ['%i', '%.5f', '%.5f', '%.5f', '%.5f', '%.5f', '%.5f', '%.2f']\n head = ['n', 'train_l', 'train_m', 'valid_l', 'valid_m', 'test_l',\n 'test_m', 'time']\n log.log_head(head, form)\n best_err = float('inf')\n best_net = copy.deepcopy(net)\n\n for epoch in range(0, args.nepochs):\n torch.manual_seed(args.seed + epoch)\n torch.cuda.manual_seed_all(args.seed + epoch)\n random.seed(args.seed + epoch)\n\n if epoch == args.pe:\n net = best_net\n\n log.log_comment('Performances before pruning')\n timer = time.time()\n train_l, train_m = eval_loop(net, fisher_loader)\n valid_l, valid_m = eval_loop(net, valid_loader)\n test_l, test_m = eval_loop(net, test_loader)\n log.log_comment('\\t'.join(form) % (epoch, train_l, train_m,\n valid_l, valid_m, test_l,\n test_m, time.time() - timer))\n\n log.log_comment('Pruning network!')\n timer = time.time()\n\n # Compute pruning ratios\n if args.exp:\n\n def get_prs(pr, pi, p0=0):\n r = 1 - (1 - (pr - p0)) ** (1 / pi)\n p = [0]\n for i in range(pi):\n p.append(p[-1] + (1 - p[-1]) * r)\n return [p0 + pp for pp in p[1:]]\n\n prunings = get_prs(args.pr, args.pi)\n log.log_comment('Final pruning: ' + str(prunings[-1]))\n else:\n prunings = [args.pr / args.pi * (i + 1) for i in range(args.pi)] \n\n mask = get_mask_iteratively(args.pm, net, prunings,\n loader=fisher_loader, n=args.nex,\n reg=args.reg)\n mask_net(net, mask, False)\n\n log.log_comment('Performances after pruning')\n train_l, train_m = eval_loop(net, fisher_loader)\n valid_l, valid_m = eval_loop(net, valid_loader)\n test_l, test_m = eval_loop(net, test_loader)\n log.log_comment('\\t'.join(form) % (epoch, train_l, train_m,\n valid_l, valid_m, test_l,\n test_m, time.time() - timer))\n\n optimizer = torch.optim.SGD(net.parameters(), lr=args.lr, momentum=0.9,\n weight_decay=args.l2)\n scheduler = torch.optim.lr_scheduler.StepLR(optimizer,\n step_size=args.dec_every,\n gamma=args.dec,\n last_epoch=-1)\n\n # Actual training and validation loops\n timer = time.time()\n train_l, train_m = train_loop(net, optimizer, train_loader, mask)\n valid_l, valid_m = eval_loop(net, valid_loader)\n test_l, test_m = eval_loop(net, test_loader)\n\n to_log = [epoch, train_l, train_m, valid_l, valid_m, test_l, test_m,\n time.time() - timer]\n log.log_values(to_log)\n\n # Early stopping if not working properly\n if np.isnan(train_l):\n sys.exit()\n\n # Learning Rate Decay\n scheduler.step()\n\n # Saving net\n if valid_m < best_err:\n log.log_comment('Best model so far.')\n best_err = valid_m\n net.zero_grad()\n best_net = copy.deepcopy(net)\n torch.save(net, os.path.join(xp_path, 'best_model.pt'))\n net.zero_grad()\n torch.save(net, os.path.join(xp_path, 'last_model.pt'))\n\n\nif __name__ == '__main__':\n main()\n", "meta": {"hexsha": "a1e308c101a6f9e30085cd2f73caf9c6f19a662f", "size": 10797, "ext": "py", "lang": "Python", "max_stars_repo_path": "experiments.py", "max_stars_repo_name": "Thrandis/loss-models-pruning", "max_stars_repo_head_hexsha": "b784b84cd2494e59673849dfd3b3e45e996a7e7a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "experiments.py", "max_issues_repo_name": "Thrandis/loss-models-pruning", "max_issues_repo_head_hexsha": "b784b84cd2494e59673849dfd3b3e45e996a7e7a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "experiments.py", "max_forks_repo_name": "Thrandis/loss-models-pruning", "max_forks_repo_head_hexsha": "b784b84cd2494e59673849dfd3b3e45e996a7e7a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.6948529412, "max_line_length": 83, "alphanum_fraction": 0.5187552098, "include": true, "reason": "import numpy", "num_tokens": 2318, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792044, "lm_q2_score": 0.39233683016710835, "lm_q1q2_score": 0.19923329715255292}} {"text": "#!/usr/bin/env python\nfrom string import *\nimport os, commands, getopt, sys, exceptions\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nclass search_failed(exceptions.Exception):\n def __init__(self,args=None):\n self.args=args\nclass eof(exceptions.Exception):\n def __init__(self,args=None):\n self.args=args\n\n\n\n#\n# look for key1. if we find key2 instead, raise error\n#\ndef lookfor1(fid,key1,key2=\"\",allow_eof=0):\n line=fid.readline()\n while line:\n pos=find(line,key1)\n if (-1 <> pos ):\n sline = line[pos+len(key1):-1]\n return sline\n if (len(key2)>0):\n pos=find(line,key2)\n if (-1 <> pos ):\n print \"error looking for: \"+key1\n raise search_failed,\"run not complete, found: \"+key2\n line=fid.readline()\n\n if (allow_eof==1):\n raise eof,\"EOF\"\n# raise search_failed,\"Search failed string='\"+key1+\"'\"\n raise search_failed,\"Search failed string=\"+key1\n return 0\n\n \n\nmumin=[]\nmumax=[]\nKE=[]\nIE=[]\nPE=[]\nKEdiss=[]\nIEdiss=[]\nPEdiss=[]\nIPEdiss=[]\nDELE=[]\ntime=[]\ntry:\n startstr=\"number of MPI processes:\"\n str = lookfor1(sys.stdin,startstr,\"\",0)\n str=split(str)\n ncpu=atoi(str[0])\n\n str = lookfor1(sys.stdin,\"theta_hydrostatic_mode \",\"\",0)\n str=split(str)\n hydrostatic_mode = (str[1]==\"T\")\n\n str = lookfor1(sys.stdin,\"tstep \",\"\",0)\n str=split(str)\n tstep=atof(str[1])\n print 'NCPU = %i tstep=%f' % (ncpu, tstep)\n while 1:\n # nstep= 3 time= 1.041666666666667E-002 [day]\n str = lookfor1(sys.stdin,\"nstep=\",\"\",1)\n str=split(str)\n n=atoi(str[0])\n \n time.extend([n*tstep/(24*3600)])\n\n if ( ~hydrostatic_mode ):\n str = lookfor1(sys.stdin,\"mu =\",\"\",0)\n str=split(str)\n mumin.extend([atof(str[0])])\n mumax.extend([atof(str[3])])\n\n # KE,d/dt,diss:\n # IE,d/dt,diss:\n # PE,d/dt,diss:\n str = lookfor1(sys.stdin,\"KE,d/dt\",\"\",0)\n str=split(str)\n KE.extend([atof(str[1])])\n if (len(str) >= 4):\n KEdiss.extend([atof(str[3])])\n\n str = lookfor1(sys.stdin,\"IE,d/dt\",\"\",0)\n str=split(str)\n IE.extend([atof(str[1])])\n if (len(str) >= 4):\n IEdiss.extend([atof(str[3])])\n\n str = lookfor1(sys.stdin,\"PE,d/dt\",\"\",0)\n str=split(str)\n PE.extend([atof(str[1])])\n if (len(str) >= 4):\n PEdiss.extend([atof(str[3])])\n\n if ( hydrostatic_mode ):\n str = lookfor1(sys.stdin,\"I+P,d/dt\",\"\",0)\n str=split(str)\n IPEdiss.extend([atof(str[3])])\n\n str = lookfor1(sys.stdin,\" E,d/dt\",\"\",0)\n str=split(str)\n DELE.extend([atof(str[2])])\n\n #print 'parsed nstep=%i' % ( n)\n\n \nexcept search_failed,e:\n print \"search failed\"\n print \"\".join(e)\n sys.exit(1)\n \nexcept eof,e:\n print 'plotting energy...'\n KE2= np.array(KE)\n nlen=KE2.size\n print 'data parsed size=%i' % (nlen)\n time=time[0:nlen]\n KE2=KE2*1e3\n PE2= np.array(PE)\n IE2= np.array(IE)\n plt.figure()\n plt.plot(time,KE2,label='KE*1e3')\n plt.plot(time,PE2,label='PE')\n plt.plot(time,IE2,label='IE')\n #plt.axis([0, 500, 0, 2.5e9])\n plt.grid(True)\n plt.legend()\n plt.savefig(\"HS-E.png\")\n\n print 'plotting dissipation rates...' \n print 'data parsed size=%i' % (len(IPEdiss))\n plt.figure()\n if (len(IPEdiss)>0):\n print 'plotting Hydrostatic I+P,d/dt,diss data'\n plt.plot(time,IPEdiss,label='IE+PE dissipation')\n\n if (len(IEdiss)>0):\n print 'plotting NH data, sum of IEdiss and PEdiss'\n IPEdiss = np.array(PEdiss) + np.array(IEdiss) \n plt.plot(time,IPEdiss,label='IE+PE dissipation')\n\n if (len(KEdiss)>0): \n plt.plot(time,KEdiss,label='KE dissipation')\n\n plt.plot(time,DELE,label='TOT E dissipation')\n\n plt.axis([0, 500, -.5, .1])\n #plt.axis([0, 500, -.1, .1])\n #plt.axis([1600, 1700, -.4, .2])\n plt.grid(True)\n plt.legend()\n plt.savefig(\"HS-diss.png\")\n\n if ( ~hydrostatic_mode ):\n plt.figure()\n print ('plotting mu...std min,max=%f %f' % (np.std(mumin),np.std(mumax)))\n legend1=(\"min avg: %.3f std: %.4f\" % (sum(mumin)/len(mumin),np.std(mumin)) )\n plt.plot(time,mumin,label=legend1)\n legend1=(\"min avg: %.3f std: %.4f\" % (sum(mumax)/len(mumax),np.std(mumax)) )\n plt.plot(time,mumax,label=legend1)\n plt.axis([min(time), max(min(time)+200,max(time)), -0.,2.0])\n plt.grid(True)\n plt.legend()\n plt.savefig(\"mu.png\")\n \n\n plt.show()\n sys.exit(0)\n\n", "meta": {"hexsha": "fd4a0c8edf69edf205cd6eb8c1ee9bf3ece9a3af", "size": 4656, "ext": "py", "lang": "Python", "max_stars_repo_path": "components/homme/test/held_suarez0/parseE.py", "max_stars_repo_name": "jingxianwen/E3SM", "max_stars_repo_head_hexsha": "bced6ba5e9247d6db6c8445b5fb828772a929b1b", "max_stars_repo_licenses": ["zlib-acknowledgement", "RSA-MD", "FTL"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-02-24T21:58:57.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-29T23:06:45.000Z", "max_issues_repo_path": "components/homme/test/held_suarez0/parseE.py", "max_issues_repo_name": "jingxianwen/E3SM", "max_issues_repo_head_hexsha": "bced6ba5e9247d6db6c8445b5fb828772a929b1b", "max_issues_repo_licenses": ["zlib-acknowledgement", "RSA-MD", "FTL"], "max_issues_count": 16, "max_issues_repo_issues_event_min_datetime": "2019-09-27T02:16:37.000Z", "max_issues_repo_issues_event_max_datetime": "2020-08-01T17:51:12.000Z", "max_forks_repo_path": "components/homme/test/held_suarez0/parseE.py", "max_forks_repo_name": "jingxianwen/E3SM", "max_forks_repo_head_hexsha": "bced6ba5e9247d6db6c8445b5fb828772a929b1b", "max_forks_repo_licenses": ["zlib-acknowledgement", "RSA-MD", "FTL"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-05-24T15:09:14.000Z", "max_forks_repo_forks_event_max_datetime": "2019-05-24T15:17:27.000Z", "avg_line_length": 26.4545454545, "max_line_length": 84, "alphanum_fraction": 0.5487542955, "include": true, "reason": "import numpy", "num_tokens": 1438, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792044, "lm_q2_score": 0.39233683016710835, "lm_q1q2_score": 0.19923329715255292}} {"text": "from __future__ import absolute_import\nfrom __future__ import print_function\nimport os\nimport glob\nimport logging\nimport copy\nimport pickle\nimport math\nimport time\nimport numpy as np\nfrom scipy.stats import norm\nimport getdist\nfrom getdist import chains, types, covmat, ParamInfo, IniFile, ParamNames\nfrom getdist.densities import Density1D, Density2D, DensityND\nfrom getdist.densities import getContourLevels as getOtherContourLevels\nfrom getdist.chains import Chains, chainFiles, lastModified\nfrom getdist.convolve import convolve1D, convolve2D\nimport getdist.kde_bandwidth as kde\nfrom getdist.parampriors import ParamBounds\nimport six\n\npickle_version = 21\n\n\nclass MCSamplesError(Exception):\n \"\"\"\n An Exception that is raised when there is an error inside the MCSamples class.\n \"\"\"\n pass\n\n\nclass SettingError(MCSamplesError):\n \"\"\"\n An Exception that indicates bad settings.\n \"\"\"\n pass\n\n\nclass ParamError(MCSamplesError):\n \"\"\"\n An Exception that indicates a bad parameter.\n \"\"\"\n pass\n\n\ndef loadMCSamples(file_root, ini=None, jobItem=None, no_cache=False, settings={}, dist_settings={}):\n \"\"\"\n Loads a set of samples from a file or files.\n\n Sample files are plain text (*file_root.txt*) or a set of files (*file_root_1.txt*, *file_root_2.txt*, etc.).\n\n Auxiliary files **file_root.paramnames** gives the parameter names\n and (optionally) **file_root.ranges** gives hard prior parameter ranges.\n\n For a description of the various analysis settings and default values see\n `analysis_defaults.ini `_.\n\n :param file_root: The root name of the files to read (no extension)\n :param ini: The name of a .ini file with analysis settings to use\n :param jobItem: an optional grid jobItem instance for a CosmoMC grid output\n :param no_cache: Indicates whether or not we should cache loaded samples in a pickle\n :param settings: dictionary of analysis settings to override defaults\n :param dist_settings: (old) alias for settings\n :return: The :class:`MCSamples` instance\n \"\"\"\n if settings and dist_settings: raise ValueError('Use settings or dist_settings')\n if dist_settings: settings = dist_settings\n files = chainFiles(file_root)\n path, name = os.path.split(file_root)\n path = getdist.cache_dir or path\n if not os.path.exists(path): os.mkdir(path)\n cachefile = os.path.join(path, name) + '.py_mcsamples'\n samples = MCSamples(file_root, jobItem=jobItem, ini=ini, settings=settings)\n if os.path.isfile(file_root + '.paramnames'):\n allfiles = files + [file_root + '.ranges', file_root + '.paramnames', file_root + '.properties.ini']\n else: # new format (txt+yaml)\n mid = \"\" if file_root.endswith(\"/\") else \"__\"\n allfiles = files + [file_root + mid + ending for ending in ['input.yaml', 'full.yaml']]\n if not no_cache and os.path.exists(cachefile) and lastModified(allfiles) < os.path.getmtime(cachefile):\n try:\n with open(cachefile, 'rb') as inp:\n cache = pickle.load(inp)\n if cache.version == pickle_version and samples.ignore_rows == cache.ignore_rows \\\n and samples.min_weight_ratio == cache.min_weight_ratio:\n changed = len(samples.contours) != len(cache.contours) or \\\n np.any(np.array(samples.contours) != np.array(cache.contours))\n cache.updateSettings(ini=ini, settings=settings, doUpdate=changed)\n return cache\n except Exception as e:\n pass\n if not len(files):\n raise IOError('No chains found: ' + file_root)\n samples.readChains(files)\n samples.savePickle(cachefile)\n return samples\n\n\ndef loadCobayaSamples(info, collections, name_tag=None,\n ignore_rows=0, ini=None, settings={}):\n \"\"\"\n Loads a set of samples from Cobaya's output.\n Parameter names, ranges and labels are taken from the \"info\" dictionary\n (always use the \"full\", updated one generated by `cobaya.run`).\n\n For a description of the various analysis settings and default values see\n `analysis_defaults.ini `_.\n\n :param collections: collection(s) of samples from Cobaya\n :param info: info dictionary, common to all collections\n (use the \"updated\" one, returned by `cobaya.run`)\n :param name_tag: name for this sample to be shown in the plots' legend\n :param ignore_rows: initial samples to skip, number (`int>=1`) or fraction (`float<1`)\n :param ini: The name of a .ini file with analysis settings to use\n :param settings: dictionary of analysis settings to override defaults\n :return: The :class:`MCSamples` instance\n \"\"\"\n if not hasattr(info, \"keys\"):\n raise TypeError(\"Cannot regonise arguments. Are you sure you are calling \"\n \"with (info, collections, ...) in that order?\")\n if hasattr(collections, \"data\"):\n collections = [collections]\n # Check consistency between collections\n columns = list(collections[0].data)\n if not all([list(c.data) == columns for c in collections[1:]]):\n raise ValueError(\"The given collections don't have the same columns.\")\n from getdist.yaml_format_tools import _p_label, _p_renames, _weight, _minuslogpost\n from getdist.yaml_format_tools import get_info_params, get_range, is_derived_param\n # Check consistency with info\n info_params = get_info_params(info)\n assert set(columns[2:]) == set(info_params.keys()), (\n \"Info and collection(s) are not compatible, because their parameters differ: \"\n \"the collection(s) have %r and the info has %r. \" % (\n columns[2:], list(info_params.keys())) +\n \"Are you sure that you are using an *updated* info dictionary \"\n \"(i.e. the output of `cobaya.run`)?\")\n # We need to use *collection* sorting, not info sorting!\n names = [p + (\"*\" if is_derived_param(info_params[p]) else \"\")\n for p in columns[2:]]\n labels = [(info_params[p] or {}).get(_p_label, p) for p in columns[2:]]\n ranges = {p: get_range(info_params[p]) for p in columns[2:]}\n renames = {p: info_params.get(p, {}).get(_p_renames, []) for p in columns[2:]}\n samples = [c[c.data.columns[2:]].values for c in collections]\n weights = [c[_weight].values for c in collections]\n loglikes = [-c[_minuslogpost].values for c in collections]\n return MCSamples(samples=samples, weights=weights, loglikes=loglikes,\n names=names, labels=labels, ranges=ranges, renames=renames,\n ignore_rows=ignore_rows, name_tag=name_tag, ini=ini,\n settings=settings)\n\n\nclass Kernel1D(object):\n def __init__(self, winw, h):\n self.winw = winw\n self.h = h\n self.x = np.arange(-winw, winw + 1)\n Win = np.exp(-(self.x / h) ** 2 / 2.)\n self.Win = Win / np.sum(Win)\n\n\n# =============================================================================\n\nclass MCSamples(Chains):\n \"\"\"\n The main high-level class for a collection of parameter samples.\n\n Derives from :class:`.chains.Chains`, adding high-level functions including Kernel Density estimates, parameter ranges and custom settings.\n \"\"\"\n\n def __init__(self, root=None, jobItem=None, ini=None, settings=None, ranges=None,\n samples=None, weights=None, loglikes=None, **kwargs):\n \"\"\"\n For a description of the various analysis settings and default values see\n `analysis_defaults.ini `_.\n\n\n :param root: A root file name when loading from file\n :param jobItem: Optional paramgrid.batchjob.jobItem instance if a member of a parameter grid\n :param ini: a .ini file to use for custom analysis settings\n :param settings: a dictionary of custom analysis settings\n :param ranges: a dictionary giving any additional hard prior bounds for parameters, eg. {'x':[0, 1], 'y':[None,2]}\n :param samples: if not loading from file, array of parameter values for each sample, passed to :meth:`setSamples`,\n or list of arrays if more than one chain\n :param weights: array of weights for samples, or list of arrays if more than one chain\n :param loglikes: array of -log(Likelihood) for samples, or list of arrays if more than one chain\n\n :param kwargs: keyword arguments passed to inherited classes, e.g. to manually make a samples object from sample arrays in memory:\n\n - **paramNamesFile**: optional name of .paramnames file with parameter names\n - **names**: list of names for the parameters,\n or list of arrays if more than one chain\n - **labels**: list of latex labels for the parameters\n - **renames**: dictionary of parameter aliases\n - **ignore_rows**:\n\n - if int >=1: The number of rows to skip at the file in the beginning of the file\n - if float <1: The fraction of rows to skip at the beginning of the file\n - **name_tag**: a name tag for this instance\n \"\"\"\n Chains.__init__(self, root, jobItem=jobItem, **kwargs)\n\n self.version = pickle_version\n\n self.markers = {}\n\n self.ini = ini\n if self.jobItem:\n self.batch_path = self.jobItem.batchPath\n else:\n self.batch_path = ''\n\n self._readRanges()\n if ranges:\n self.setRanges(ranges)\n\n # Other variables\n self.range_ND_contour = 1\n self.range_confidence = 0.001\n self.num_bins = 128\n self.fine_bins = 1024\n self.num_bins_2D = 40\n self.fine_bins_2D = 256\n self.smooth_scale_1D = -1.\n self.smooth_scale_2D = -1.\n self.num_bins_ND = 12\n self.boundary_correction_order = 1\n self.mult_bias_correction_order = 1\n self.max_corr_2D = 0.95\n self.contours = np.array([0.68, 0.95])\n self.max_scatter_points = 2000\n self.credible_interval_threshold = 0.05\n\n self.shade_likes_is_mean_loglikes = False\n\n self.likeStats = None\n self.max_mult = 0\n self.mean_mult = 0\n self.plot_data_dir = \"\"\n if root:\n self.rootname = os.path.basename(root)\n else:\n self.rootname = \"\"\n\n self.rootdirname = \"\"\n self.indep_thin = 0\n if 'ignore_rows' in kwargs:\n if settings is None: settings = {}\n settings['ignore_rows'] = kwargs['ignore_rows']\n self.ignore_rows = float(kwargs.get('ignore_rows', 0))\n self.subplot_size_inch = 4.0\n self.subplot_size_inch2 = self.subplot_size_inch\n self.subplot_size_inch3 = 6.0\n self.plot_output = getdist.default_plot_output\n self.out_dir = \"\"\n self.no_warning_params = []\n self.no_warning_chi2_params = True\n\n self.max_split_tests = 4\n self.force_twotail = False\n\n self.corr_length_thin = 0\n self.corr_length_steps = 15\n self.converge_test_limit = 0.95\n\n self.done_1Dbins = False\n self.density1D = dict()\n\n self.updateSettings(ini=ini, settings=settings)\n\n if root and os.path.exists(root + '.properties.ini'):\n # any settings in properties.ini override settings for this specific chain\n self.properties = IniFile(root + '.properties.ini')\n self._setBurnOptions(self.properties)\n if self.properties.bool('burn_removed', False):\n self.ignore_frac = 0.\n self.ignore_lines = 0\n else:\n self.properties = None\n\n if samples is not None:\n self.readChains(samples, weights, loglikes)\n\n def setRanges(self, ranges):\n \"\"\"\n Sets the ranges parameters, e.g. hard priors on positivity etc.\n If a min or max value is None, then it is assumed to be unbounded.\n\n :param ranges: A list or a tuple of [min,max] values for each parameter,\n or a dictionary giving [min,max] values for specific parameter names\n \"\"\"\n if isinstance(ranges, (list, tuple)):\n for i, minmax in enumerate(ranges):\n self.ranges.setRange(self.parName(i), minmax)\n elif isinstance(ranges, dict):\n for key, value in six.iteritems(ranges):\n self.ranges.setRange(key, value)\n elif isinstance(ranges, ParamBounds):\n self.ranges = copy.deepcopy(ranges)\n else:\n raise ValueError('MCSamples ranges parameter must be list or dict')\n self.needs_update = True\n\n def parName(self, i, starDerived=False):\n \"\"\"\n Gets the name of i'th parameter\n\n :param i: The index of the parameter\n :param starDerived: add a star at the end of the name if the parameter is derived\n :return: The name of the parameter (string)\n \"\"\"\n return self.paramNames.name(i, starDerived)\n\n def parLabel(self, i):\n \"\"\"\n Gets the latex label of the parameter\n\n :param i: The index or name of a parameter.\n :return: The parameter's label.\n \"\"\"\n if isinstance(i, six.string_types):\n return self.paramNames.parWithName(i).label\n else:\n return self.paramNames.names[i].label\n\n def _setBurnOptions(self, ini):\n \"\"\"\n Sets the ignore_rows value from configuration.\n\n :param ini: The :class:`.inifile.IniFile` to be used\n \"\"\"\n ini.setAttr('ignore_rows', self)\n self.ignore_lines = int(self.ignore_rows)\n if not self.ignore_lines:\n self.ignore_frac = self.ignore_rows\n else:\n self.ignore_frac = 0\n ini.setAttr('min_weight_ratio', self)\n\n def initParameters(self, ini):\n \"\"\"\n Initializes settings.\n Gets parameters from :class:`~.inifile.IniFile`.\n\n :param ini: The :class:`~.inifile.IniFile` to be used\n \"\"\"\n self._setBurnOptions(ini)\n\n ini.setAttr('range_ND_contour', self)\n ini.setAttr('range_confidence', self)\n ini.setAttr('num_bins', self)\n ini.setAttr('fine_bins', self)\n\n ini.setAttr('num_bins_2D', self)\n ini.setAttr('fine_bins_2D', self)\n\n ini.setAttr('smooth_scale_1D', self)\n ini.setAttr('smooth_scale_2D', self)\n\n ini.setAttr('boundary_correction_order', self, 1)\n ini.setAttr('mult_bias_correction_order', self, 1)\n\n ini.setAttr('num_bins_ND', self)\n\n ini.setAttr('max_scatter_points', self)\n ini.setAttr('credible_interval_threshold', self)\n\n ini.setAttr('subplot_size_inch', self)\n ini.setAttr('subplot_size_inch2', self)\n ini.setAttr('subplot_size_inch3', self)\n ini.setAttr('plot_output', self)\n\n ini.setAttr('force_twotail', self)\n if self.force_twotail: logging.warning('Computing two tail limits')\n ini.setAttr('max_corr_2D', self)\n\n if ini.hasKey('contours'):\n ini.setAttr('contours', self)\n elif ini.hasKey('num_contours'):\n num_contours = ini.int('num_contours', 2)\n self.contours = np.array([ini.float('contour' + str(i + 1)) for i in range(num_contours)])\n # how small the end bin must be relative to max to use two tail\n self.max_frac_twotail = []\n for i, contour in enumerate(self.contours):\n max_frac = np.exp(-1.0 * math.pow(norm.ppf((1 - contour) / 2), 2) / 2)\n if ini:\n max_frac = ini.float('max_frac_twotail' + str(i + 1), max_frac)\n self.max_frac_twotail.append(max_frac)\n\n ini.setAttr('converge_test_limit', self, self.contours[-1])\n ini.setAttr('corr_length_thin', self)\n ini.setAttr('corr_length_steps', self)\n ini.setAttr('no_warning_params', self, [])\n ini.setAttr('no_warning_chi2_params', self, True)\n self.batch_path = ini.string('batch_path', self.batch_path, allowEmpty=False)\n\n def _initLimits(self, ini=None):\n bin_limits = \"\"\n if ini: bin_limits = ini.string('all_limits', '')\n\n self.markers = {}\n\n for par in self.paramNames.names:\n if bin_limits:\n line = bin_limits\n else:\n line = ''\n if ini and 'limits[%s]' % par.name in ini.params:\n line = ini.string('limits[%s]' % par.name)\n if line:\n limits = line.split()\n if len(limits) == 2:\n self.ranges.setRange(par.name, limits)\n\n par.limmin = self.ranges.getLower(par.name)\n par.limmax = self.ranges.getUpper(par.name)\n par.has_limits_bot = par.limmin is not None\n par.has_limits_top = par.limmax is not None\n\n if ini and 'marker[%s]' % par.name in ini.params:\n line = ini.string('marker[%s]' % par.name)\n if line:\n self.markers[par.name] = float(line)\n\n def updateSettings(self, settings=None, ini=None, doUpdate=True):\n \"\"\"\n Updates settings from a .ini file or dictionary\n\n :param settings: The a dict containing settings to set, taking preference over any values in ini\n :param ini: The name of .ini file to get settings from, or an :class:`~.inifile.IniFile` instance; by default uses current settings\n :param doUpdate: True if should update internal computed values, False otherwise (e.g. if want to make other changes first)\n \"\"\"\n assert (settings is None or isinstance(settings, dict))\n if not ini:\n ini = self.ini\n elif isinstance(ini, six.string_types):\n ini = IniFile(ini)\n else:\n ini = copy.deepcopy(ini)\n if not ini: ini = IniFile(getdist.default_getdist_settings)\n if settings:\n ini.params.update(settings)\n self.ini = ini\n if ini: self.initParameters(ini)\n if doUpdate and self.samples is not None: self.updateBaseStatistics()\n\n def readChains(self, files_or_samples, weights=None, loglikes=None):\n \"\"\"\n Loads samples from a list of files or array(s), removing burn in,\n deleting fixed parameters, and combining into one self.samples array\n\n :param files_or_samples: The list of file names to read, samples or list of samples\n :param weights: array of weights if setting from arrays\n :param loglikes: array of -2 log(likelihood) if setting from arrays\n :return: self.\n \"\"\"\n self.loadChains(self.root, files_or_samples, weights=weights, loglikes=loglikes)\n\n if self.ignore_frac and (\n not self.jobItem or (not self.jobItem.isImportanceJob and not self.jobItem.isBurnRemoved())):\n self.removeBurnFraction(self.ignore_frac)\n if chains.print_load_details: print('Removed %s as burn in' % self.ignore_frac)\n elif not int(self.ignore_rows):\n if chains.print_load_details: print('Removed no burn in')\n\n self.deleteFixedParams()\n\n # Make a single array for chains\n if self.chains is not None: self.makeSingle()\n\n self.updateBaseStatistics()\n\n return self\n\n def updateBaseStatistics(self):\n \"\"\"\n Updates basic computed statistics (means, covariance etc), e.g. after a change in samples or weights\n\n :return: self\n \"\"\"\n super(MCSamples, self).updateBaseStatistics()\n mult_max = (self.mean_mult * self.numrows) / min(self.numrows // 2, 500)\n outliers = np.sum(self.weights > mult_max)\n if outliers != 0:\n logging.warning('outlier fraction %s ', float(outliers) / self.numrows)\n\n self.indep_thin = 0\n self._setCov()\n self.done_1Dbins = False\n self.density1D = dict()\n\n self._initLimits(self.ini)\n\n # Get ND confidence region\n self._setLikeStats()\n return self\n\n def makeSingleSamples(self, filename=\"\", single_thin=None):\n \"\"\"\n Make file of weight-1 samples by choosing samples\n with probability given by their weight.\n\n :param filename: The filename to write to, leave empty if no output file is needed\n :param single_thin: factor to thin by; if not set generates as many samples as it can up to self.max_scatter_points\n :return: numpy array of selected weight-1 samples\n \"\"\"\n if single_thin is None:\n single_thin = max(1, self.norm / self.max_mult / self.max_scatter_points)\n rand = np.random.random_sample(self.numrows)\n\n if filename:\n with open(filename, 'w') as f:\n for i, r in enumerate(rand):\n if r <= self.weights[i] / self.max_mult / single_thin:\n f.write(\"%16.7E\" % 1.0)\n f.write(\"%16.7E\" % (self.loglikes[i]))\n for j in range(self.n):\n f.write(\"%16.7E\" % (self.samples[i][j]))\n f.write(\"\\n\")\n else:\n # return data\n return self.samples[rand <= self.weights / (self.max_mult * single_thin)]\n\n def writeThinData(self, fname, thin_ix, cool=1):\n \"\"\"\n Writes samples at thin_ix to file\n\n :param fname: The filename to write to.\n :param thin_ix: Indices of the samples to write\n :param cool: if not 1, cools the samples by this factor\n \"\"\"\n nparams = self.samples.shape[1]\n if cool != 1: logging.info('Cooled thinned output with temp: %s', cool)\n MaxL = np.max(self.loglikes)\n with open(fname, 'w') as f:\n i = 0\n for thin in thin_ix:\n if cool != 1:\n newL = self.loglikes[thin] * cool\n f.write(\"%16.7E\" % (\n np.exp(-(newL - self.loglikes[thin]) - MaxL * (1 - cool))))\n f.write(\"%16.7E\" % newL)\n for j in range(nparams):\n f.write(\"%16.7E\" % (self.samples[i][j]))\n else:\n f.write(\"%f\" % 1.)\n f.write(\"%f\" % (self.loglikes[thin]))\n for j in range(nparams):\n f.write(\"%16.7E\" % (self.samples[i][j]))\n i += 1\n print('Wrote ', len(thin_ix), ' thinned samples')\n\n def getCovMat(self):\n \"\"\"\n Gets the CovMat instance containing covariance matrix for all the non-derived parameters\n (for example useful for subsequent MCMC runs to orthogonalize the parameters)\n\n :return: A :class:`~.covmat.CovMat` object holding the covariance\n \"\"\"\n nparamNonDerived = self.paramNames.numNonDerived()\n return covmat.CovMat(matrix=self.fullcov[:nparamNonDerived, :nparamNonDerived],\n paramNames=self.paramNames.list()[:nparamNonDerived])\n\n def writeCovMatrix(self, filename=None):\n \"\"\"\n Writes the covrariance matrix of non-derived parameters to a file.\n\n :param filename: The filename to write to; default is file_root.covmat\n \"\"\"\n filename = filename or self.rootdirname + \".covmat\"\n self.getCovMat().saveToFile(filename)\n\n def writeCorrelationMatrix(self, filename=None):\n \"\"\"\n Write the correlation matrix to a file\n\n :param filename: The file to write to, If none writes to file_root.corr\n \"\"\"\n filename = filename or self.rootdirname + \".corr\"\n np.savetxt(filename, self.getCorrelationMatrix(), fmt=\"%15.7E\")\n\n def getFractionIndices(self, weights, n):\n \"\"\"\n Calculates the indices of weights that split the weights into sets of equal 1/n fraction of the total weight\n\n :param weights: array of weights\n :param n: number of groups to split in to\n :return: array of indices of the boundary rows in the weights array\n \"\"\"\n cumsum = np.cumsum(weights)\n fraction_indices = np.append(np.searchsorted(cumsum, np.linspace(0, 1, n, endpoint=False) * self.norm),\n self.weights.shape[0])\n return fraction_indices\n\n def PCA(self, params, param_map=None, normparam=None, writeDataToFile=False, filename=None,\n conditional_params=[], n_best_only=None):\n \"\"\"\n Perform principle component analysis (PCA). In other words,\n get eigenvectors and eigenvalues for normalized variables\n with optional (log modulus) mapping to find power law fits.\n\n :param params: List of names of the parameters to use\n :param param_map: A transformation to apply to parameter values;\n A list or string containing either N (no transformation) or L (for log transform) for each parameter.\n By default uses log if no parameter values cross zero\n\n :param normparam: optional name of parameter to normalize result (i.e. this parameter will have unit power)\n :param writeDataToFile: True if should write the output to file.\n :param filename: The filename to write, by default root_name.PCA.\n :param conditional_params: optional list of parameters to treat as fixed, i.e. for PCA conditional on fixed values of these parameters\n :param n_best_only: return just the short summary constraint for the tightest n_best_only constraints\n :return: a string description of the output of the PCA\n \"\"\"\n logging.info('Doing PCA for %s parameters', len(params))\n if len(conditional_params): logging.info('conditional %u fixed parameters', len(conditional_params))\n\n PCAtext = 'PCA for parameters:\\n'\n\n params = [name for name in params if self.paramNames.parWithName(name)]\n nparams = len(params)\n indices = [self.index[param] for param in params]\n conditional_params = [self.index[param] for param in conditional_params]\n indices += conditional_params\n\n if normparam:\n if normparam in params:\n normparam = params.index(normparam)\n else:\n normparam = -1\n else:\n normparam = -1\n\n n = len(indices)\n PCdata = self.samples[:, indices].copy()\n PClabs = []\n\n PCmean = np.zeros(n)\n sd = np.zeros(n)\n newmean = np.zeros(n)\n newsd = np.zeros(n)\n if param_map is None:\n param_map = ''\n for par in self.paramNames.parsWithNames(params):\n self._initParamRanges(par.name)\n if par.param_max < 0 or par.param_min < (par.param_max - par.param_min) / 10:\n param_map += 'N'\n else:\n param_map += 'L'\n\n doexp = False\n for i, parix in enumerate(indices):\n if i < nparams:\n label = self.parLabel(parix)\n if param_map[i] == 'L':\n doexp = True\n PCdata[:, i] = np.log(PCdata[:, i])\n PClabs.append(\"ln(\" + label + \")\")\n elif param_map[i] == 'M':\n doexp = True\n PCdata[:, i] = np.log(-1.0 * PCdata[:, i])\n PClabs.append(\"ln(-\" + label + \")\")\n else:\n PClabs.append(label)\n PCAtext += \"%10s :%s\\n\" % (str(parix + 1), str(PClabs[i]))\n\n PCmean[i] = np.dot(self.weights, PCdata[:, i]) / self.norm\n PCdata[:, i] -= PCmean[i]\n sd[i] = np.sqrt(np.dot(self.weights, PCdata[:, i] ** 2) / self.norm)\n if sd[i] != 0: PCdata[:, i] /= sd[i]\n\n PCAtext += \"\\n\"\n PCAtext += 'Correlation matrix for reduced parameters\\n'\n correlationMatrix = np.ones((n, n))\n for i in range(n):\n for j in range(i):\n correlationMatrix[j][i] = np.dot(self.weights, PCdata[:, i] * PCdata[:, j]) / self.norm\n correlationMatrix[i][j] = correlationMatrix[j][i]\n for i in range(nparams):\n PCAtext += '%12s :' % params[i]\n for j in range(n):\n PCAtext += '%8.4f' % correlationMatrix[j][i]\n PCAtext += '\\n'\n\n if len(conditional_params):\n u = np.linalg.inv(correlationMatrix)\n u = u[np.ix_(list(range(len(params))), list(range(len(params))))]\n u = np.linalg.inv(u)\n n = nparams\n PCdata = PCdata[:, :nparams]\n else:\n u = correlationMatrix\n evals, evects = np.linalg.eig(u)\n isorted = evals.argsort()\n u = np.transpose(evects[:, isorted]) # redefining u\n\n PCAtext += '\\n'\n PCAtext += 'e-values of correlation matrix\\n'\n for i in range(n):\n isort = isorted[i]\n PCAtext += 'PC%2i: %8.4f\\n' % (i + 1, evals[isort])\n\n PCAtext += '\\n'\n PCAtext += 'e-vectors\\n'\n for j in range(n):\n PCAtext += '%3i:' % (indices[j] + 1)\n for i in range(n):\n isort = isorted[i]\n PCAtext += '%8.4f' % (evects[j][isort])\n PCAtext += '\\n'\n\n if normparam != -1:\n # Set so parameter normparam has exponent 1\n for i in range(n):\n u[i, :] = u[i, :] / u[i, normparam] * sd[normparam]\n else:\n # Normalize so main component has exponent 1\n for i in range(n):\n maxi = np.abs(u[i, :]).argmax()\n u[i, :] = u[i, :] / u[i, maxi] * sd[maxi]\n\n nrows = PCdata.shape[0]\n for i in range(nrows):\n PCdata[i, :] = np.dot(u, PCdata[i, :])\n if doexp: PCdata[i, :] = np.exp(PCdata[i, :])\n\n PCAtext += '\\n'\n PCAtext += 'Principle components\\n'\n PCAmodeTexts = []\n for i in range(n):\n isort = isorted[i]\n summary = 'PC%i (e-value: %f)\\n' % (i + 1, evals[isort])\n for j in range(n):\n label = self.parLabel(indices[j])\n if param_map[j] in ['L', 'M']:\n expo = \"%f\" % (1.0 / sd[j] * u[i][j])\n if param_map[j] == \"M\":\n div = \"%f\" % (-np.exp(PCmean[j]))\n else:\n div = \"%f\" % (np.exp(PCmean[j]))\n summary += '[%f] (%s/%s)^{%s}\\n' % (u[i][j], label, div, expo)\n else:\n expo = \"%f\" % (sd[j] / u[i][j])\n if doexp:\n summary += '[%f] exp((%s-%f)/%s)\\n' % (u[i][j], label, PCmean[j], expo)\n else:\n summary += '[%f] (%s-%f)/%s)\\n' % (u[i][j], label, PCmean[j], expo)\n newmean[i] = self.mean(PCdata[:, i])\n newsd[i] = np.sqrt(self.mean((PCdata[:, i] - newmean[i]) ** 2))\n summary += ' = %f +- %f\\n' % (newmean[i], newsd[i])\n summary += '\\n'\n PCAmodeTexts += [summary]\n PCAtext += summary\n\n # Find out how correlated these components are with other parameters\n PCAtext += 'Correlations of principle components\\n'\n l = [\"%8i\" % i for i in range(1, n + 1)]\n PCAtext += '%s\\n' % (\"\".join(l))\n\n for i in range(n):\n PCdata[:, i] = (PCdata[:, i] - newmean[i]) / newsd[i]\n\n for j in range(n):\n PCAtext += 'PC%2i' % (j + 1)\n for i in range(n):\n PCAtext += '%8.3f' % (self.mean(PCdata[:, i] * PCdata[:, j]))\n PCAtext += '\\n'\n\n for j in range(self.n):\n PCAtext += '%4i' % (j + 1)\n for i in range(n):\n PCAtext += '%8.3f' % (\n np.sum(self.weights * PCdata[:, i]\n * (self.samples[:, j] - self.means[j]) / self.sddev[j]) / self.norm)\n\n PCAtext += ' (%s)\\n' % (self.parLabel(j))\n\n if writeDataToFile:\n with open(filename or self.rootdirname + \".PCA\", \"w\") as f:\n f.write(PCAtext)\n if n_best_only:\n if n_best_only == 1:\n return PCAmodeTexts[0]\n return PCAmodeTexts[:n_best_only]\n else:\n return PCAtext\n\n def getNumSampleSummaryText(self):\n \"\"\"\n Returns a summary text describing numbers of parameters and samples,\n and various measures of the effective numbers of samples.\n\n :return: The summary text as a string.\n \"\"\"\n lines = 'using %s rows, %s parameters; mean weight %s, tot weight %s\\n' % (\n self.numrows, self.paramNames.numParams(), self.mean_mult, self.norm)\n if self.indep_thin != 0:\n lines += 'Approx indep samples (N/corr length): %s\\n' % (round(self.norm / self.indep_thin))\n lines += 'Equiv number of single samples (sum w)/max(w): %s\\n' % (round(self.norm / self.max_mult))\n lines += 'Effective number of weighted samples (sum w)^2/sum(w^2): %s\\n' % (\n int(self.norm ** 2 / np.dot(self.weights, self.weights)))\n return lines\n\n def getConvergeTests(self, test_confidence=0.95, writeDataToFile=False,\n what=['MeanVar', 'GelmanRubin', 'SplitTest', 'RafteryLewis', 'CorrLengths'],\n filename=None, feedback=False):\n \"\"\"\n Do convergence tests.\n\n :param test_confidence: confidence limit to test for convergence (two-tail, only applies to some tests)\n :param writeDataToFile: True if should write output to a file\n :param what: The tests to run. Should be a list of any of the following:\n\n - 'MeanVar': Gelman-Rubin sqrt(var(chain mean)/mean(chain var)) test in individual parameters (multiple chains only)\n - 'GelmanRubin': Gelman-Rubin test for the worst orthogonalized parameter (multiple chains only)\n - 'SplitTest': Crude test for variation in confidence limits when samples are split up into subsets\n - 'RafteryLewis': `Raftery-Lewis test `_ (integer weight samples only)\n - 'CorrLengths': Sample correlation lengths\n :param filename: The filename to write to, default is file_root.converge\n :param feedback: If set to True, Prints the output as well as returning it.\n :return: text giving the output of the tests\n \"\"\"\n lines = ''\n nparam = self.n\n\n chainlist = self.getSeparateChains()\n num_chains_used = len(chainlist)\n if num_chains_used > 1 and feedback:\n print('Number of chains used = ', num_chains_used)\n for chain in chainlist: chain.setDiffs()\n parForm = self.paramNames.parFormat()\n parNames = [parForm % self.parName(j) for j in range(nparam)]\n limits = np.array([1 - (1 - test_confidence) / 2, (1 - test_confidence) / 2])\n\n if 'CorrLengths' in what:\n lines += \"Parameter autocorrelation lengths (effective number of samples N_eff = tot weight/weight length)\\n\"\n lines += \"\\n\"\n lines += parForm % \"\" + '%15s %15s %15s\\n' % ('Weight Length', 'Sample length', 'N_eff')\n maxoff = np.min([chain.weights.size // 10 for chain in chainlist])\n maxN = 0\n for j in range(nparam):\n corr = np.zeros(maxoff + 1)\n for chain in chainlist:\n corr += chain.getAutocorrelation(j, maxoff, normalized=False) * chain.norm\n corr /= self.norm * self.vars[j]\n ix = np.argmin(corr > 0.05 * corr[0])\n N = corr[0] + 2 * np.sum(corr[1:ix])\n maxN = max(N, maxN)\n form = '%15.2E'\n if self.mean_mult > 1: form = '%15.2f'\n lines += parNames[j] + form % N + ' %15.2f %15i\\n' % (N / self.mean_mult, self.norm / N)\n self.indep_thin = maxN\n lines += \"\\n\"\n\n if num_chains_used > 1 and 'MeanVar' in what:\n lines += \"\\n\"\n lines += \"mean convergence stats using remaining chains\\n\"\n lines += \"param sqrt(var(chain mean)/mean(chain var))\\n\"\n lines += \"\\n\"\n\n between_chain_var = np.zeros(nparam)\n in_chain_var = np.zeros(nparam)\n for chain in chainlist:\n between_chain_var += (chain.means - self.means) ** 2\n between_chain_var /= (num_chains_used - 1)\n\n for j in range(nparam):\n # Get stats for individual chains - the variance of the means over the mean of the variances\n for chain in chainlist:\n in_chain_var[j] += np.dot(chain.weights, chain.diffs[j] ** 2)\n\n in_chain_var[j] /= self.norm\n lines += parNames[j] + \"%10.4f %s\\n\" % (\n math.sqrt(between_chain_var[j] / in_chain_var[j]), self.parLabel(j))\n lines += \"\\n\"\n\n nparamMC = self.paramNames.numNonDerived()\n if num_chains_used > 1 and nparamMC > 0 and 'GelmanRubin' in what:\n\n D = self.getGelmanRubinEigenvalues(chainlist=chainlist)\n if D is not None:\n self.GelmanRubin = np.max(D)\n lines += \"var(mean)/mean(var) for eigenvalues of covariance of means of orthonormalized parameters\\n\"\n for jj, Di in enumerate(D):\n lines += \"%3i%13.5f\\n\" % (jj + 1, Di)\n GRSummary = \" var(mean)/mean(var), remaining chains, worst e-value: R-1 = %13.5F\" % self.GelmanRubin\n else:\n self.GelmanRubin = None\n GRSummary = logging.warning('Gelman-Rubin covariance not invertible (parameter not moved?)')\n if feedback: print(GRSummary)\n lines += \"\\n\"\n\n if 'SplitTest' in what:\n # Do tests for robustness under using splits of the samples\n # Return the rms ([change in upper/lower quantile]/[standard deviation])\n # when data split into 2, 3,.. sets\n lines += \"Split tests: rms_n([delta(upper/lower quantile)]/sd) n={2,3,4}, limit=%.0f%%:\\n\" % (\n 100 * self.converge_test_limit)\n lines += \"i.e. mean sample splitting change in the quantiles in units of the st. dev.\\n\"\n lines += \"\\n\"\n\n frac_indices = []\n for i in range(self.max_split_tests - 1):\n frac_indices.append(self.getFractionIndices(self.weights, i + 2))\n for j in range(nparam):\n split_tests = np.zeros((self.max_split_tests - 1, 2))\n confids = self.confidence(self.samples[:, j], limits)\n for ix, frac in enumerate(frac_indices):\n split_n = 2 + ix\n for f1, f2 in zip(frac[:-1], frac[1:]):\n split_tests[ix, :] += (self.confidence(self.samples[:, j], limits, start=f1,\n end=f2) - confids) ** 2\n\n split_tests[ix, :] = np.sqrt(split_tests[ix, :] / split_n) / self.sddev[j]\n for endb, typestr in enumerate(['upper', 'lower']):\n lines += parNames[j]\n for ix in range(self.max_split_tests - 1):\n lines += \"%9.4f\" % (split_tests[ix, endb])\n lines += \" %s\\n\" % typestr\n lines += \"\\n\"\n\n class LoopException(Exception):\n pass\n\n if np.all(np.abs(self.weights - self.weights.astype(np.int)) < 1e-4 / self.max_mult):\n if 'RafteryLewis' in what:\n # Raftery and Lewis method\n # See http://www.stat.washington.edu/tech.reports/raftery-lewis2.ps\n # Raw non-importance sampled chains only\n thin_fac = np.empty(num_chains_used, dtype=np.int)\n epsilon = 0.001\n\n nburn = np.zeros(num_chains_used, dtype=np.int)\n markov_thin = np.zeros(num_chains_used, dtype=np.int)\n hardest = -1\n hardestend = 0\n for ix, chain in enumerate(chainlist):\n thin_fac[ix] = int(round(np.max(chain.weights)))\n try:\n for j in range(nparamMC):\n # Get binary chain depending on whether above or below confidence value\n confids = self.confidence(chain.samples[:, j], limits, weights=chain.weights)\n for endb in [0, 1]:\n u = confids[endb]\n while True:\n thin_ix = self.thin_indices(thin_fac[ix], chain.weights)\n thin_rows = len(thin_ix)\n if thin_rows < 2: break\n binchain = np.ones(thin_rows, dtype=np.int)\n binchain[chain.samples[thin_ix, j] >= u] = 0\n indexes = binchain[:-2] * 4 + binchain[1:-1] * 2 + binchain[2:]\n # Estimate transitions probabilities for 2nd order process\n tran = np.bincount(indexes, minlength=8).reshape((2, 2, 2))\n # tran[:, :, :] = 0\n # for i in range(2, thin_rows):\n # tran[binchain[i - 2]][binchain[i - 1]][binchain[i]] += 1\n\n # Test whether 2nd order is better than Markov using BIC statistic\n g2 = 0\n for i1 in [0, 1]:\n for i2 in [0, 1]:\n for i3 in [0, 1]:\n if tran[i1][i2][i3] != 0:\n fitted = float(\n (tran[i1][i2][0] + tran[i1][i2][1]) *\n (tran[0][i2][i3] + tran[1][i2][i3])) \\\n / float(tran[0][i2][0] + tran[0][i2][1] +\n tran[1][i2][0] + tran[1][i2][1])\n focus = float(tran[i1][i2][i3])\n g2 += math.log(focus / fitted) * focus\n g2 *= 2\n\n if g2 - math.log(float(thin_rows - 2)) * 2 < 0: break\n thin_fac[ix] += 1\n\n # Get Markov transition probabilities for binary processes\n if np.sum(tran[:, 0, 1]) == 0 or np.sum(tran[:, 1, 0]) == 0:\n thin_fac[ix] = 0\n raise LoopException()\n\n alpha = np.sum(tran[:, 0, 1]) / float(np.sum(tran[:, 0, 0]) + np.sum(tran[:, 0, 1]))\n beta = np.sum(tran[:, 1, 0]) / float(np.sum(tran[:, 1, 0]) + np.sum(tran[:, 1, 1]))\n probsum = alpha + beta\n tmp1 = math.log(probsum * epsilon / max(alpha, beta)) / math.log(abs(1.0 - probsum))\n if int(tmp1 + 1) * thin_fac[ix] > nburn[ix]:\n nburn[ix] = int(tmp1 + 1) * thin_fac[ix]\n hardest = j\n hardestend = endb\n\n markov_thin[ix] = thin_fac[ix]\n\n # Get thin factor to have independent samples rather than Markov\n hardest = max(hardest, 0)\n u = self.confidence(self.samples[:, hardest], (1 - test_confidence) / 2, hardestend == 0)\n\n while True:\n thin_ix = self.thin_indices(thin_fac[ix], chain.weights)\n thin_rows = len(thin_ix)\n if thin_rows < 2: break\n binchain = np.ones(thin_rows, dtype=np.int)\n binchain[chain.samples[thin_ix, hardest] >= u] = 0\n indexes = binchain[:-1] * 2 + binchain[1:]\n # Estimate transitions probabilities for 2nd order process\n tran2 = np.bincount(indexes, minlength=4).reshape(2, 2)\n # tran2[:, :] = 0\n # for i in range(1, thin_rows):\n # tran2[binchain[i - 1]][binchain[i]] += 1\n\n # Test whether independence is better than Markov using BIC statistic\n g2 = 0\n for i1 in [0, 1]:\n for i2 in [0, 1]:\n if tran2[i1][i2] != 0:\n fitted = float(\n (tran2[i1][0] + tran2[i1][1]) *\n (tran2[0][i2] + tran2[1][i2])) / float(thin_rows - 1)\n focus = float(tran2[i1][i2])\n if fitted <= 0 or focus <= 0:\n print('Raftery and Lewis estimator had problems')\n return\n g2 += np.log(focus / fitted) * focus\n g2 *= 2\n\n if g2 - np.log(float(thin_rows - 1)) < 0: break\n\n thin_fac[ix] += 1\n except LoopException:\n pass\n except:\n thin_fac[ix] = 0\n if thin_fac[ix] and thin_rows < 2: thin_fac[ix] = 0\n\n lines += \"Raftery&Lewis statistics\\n\"\n lines += \"\\n\"\n lines += \"chain markov_thin indep_thin nburn\\n\"\n\n for ix in range(num_chains_used):\n if thin_fac[ix] == 0:\n lines += \"%4i Failed/not enough samples\\n\" % ix\n else:\n lines += \"%4i%12i%12i%12i\\n\" % (\n ix, markov_thin[ix], thin_fac[ix], nburn[ix])\n\n self.RL_indep_thin = np.max(thin_fac)\n\n if feedback:\n if not np.all(thin_fac != 0):\n print('RL: Not enough samples to estimate convergence stats')\n else:\n print('RL: Thin for Markov: ', np.max(markov_thin))\n print('RL: Thin for indep samples: ', str(self.RL_indep_thin))\n print('RL: Estimated burn in steps: ', np.max(nburn), ' (',\n int(round(np.max(nburn) / self.mean_mult)), ' rows)')\n lines += \"\\n\"\n\n if 'CorrSteps' in what:\n # Get correlation lengths. We ignore the fact that there are jumps between chains, so slight underestimate\n lines += \"Parameter auto-correlations as function of step separation\\n\"\n lines += \"\\n\"\n if self.corr_length_thin != 0:\n autocorr_thin = self.corr_length_thin\n else:\n if self.indep_thin == 0:\n autocorr_thin = 20\n elif self.indep_thin <= 30:\n autocorr_thin = 5\n else:\n autocorr_thin = int(5 * (self.indep_thin / 30))\n\n thin_ix = self.thin_indices(autocorr_thin)\n thin_rows = len(thin_ix)\n maxoff = int(min(self.corr_length_steps, thin_rows // (2 * num_chains_used)))\n\n if maxoff > 0:\n if False:\n # ignore ends of chains\n corrs = np.zeros([maxoff, nparam])\n for j in range(nparam):\n diff = self.samples[thin_ix, j] - self.means[j]\n for off in range(1, maxoff + 1):\n corrs[off - 1][j] = np.dot(diff[off:], diff[:-off]) / (thin_rows - off) / self.vars[j]\n lines += parForm % \"\"\n for i in range(maxoff):\n lines += \"%8i\" % ((i + 1) * autocorr_thin)\n lines += \"\\n\"\n for j in range(nparam):\n label = self.parLabel(j)\n lines += parNames[j]\n for i in range(maxoff):\n lines += \"%8.3f\" % corrs[i][j]\n lines += \" %s\\n\" % label\n else:\n corrs = np.zeros([maxoff, nparam])\n for chain in chainlist:\n thin_ix = chain.thin_indices(autocorr_thin)\n thin_rows = len(thin_ix)\n maxoff = min(maxoff, thin_rows // autocorr_thin)\n for j in range(nparam):\n diff = chain.diffs[j][thin_ix]\n for off in range(1, maxoff + 1):\n corrs[off - 1][j] += np.dot(diff[off:], diff[:-off]) / (thin_rows - off) / \\\n self.vars[j]\n corrs /= len(chainlist)\n\n lines += parForm % \"\"\n for i in range(maxoff):\n lines += \"%8i\" % ((i + 1) * autocorr_thin)\n lines += \"\\n\"\n for j in range(nparam):\n label = self.parLabel(j)\n lines += parNames[j]\n for i in range(maxoff):\n lines += \"%8.3f\" % corrs[i][j]\n lines += \" %s\\n\" % label\n\n if writeDataToFile:\n with open(filename or (self.rootdirname + '.converge'), 'w') as f:\n f.write(lines)\n return lines\n\n def _get1DNeff(self, par, param):\n N_eff = getattr(par, 'N_eff_kde', None)\n if N_eff is None:\n par.N_eff_kde = self.getEffectiveSamplesGaussianKDE(param, scale=par.sigma_range)\n N_eff = par.N_eff_kde\n return N_eff\n\n def getAutoBandwidth1D(self, bins, par, param, mult_bias_correction_order=None, kernel_order=1, N_eff=None):\n \"\"\"\n Get optimized kernel density bandwidth (in units of the range of the bins)\n Based on optimal Improved Sheather-Jones bandwidth for basic Parzen kernel, then scaled if higher-order method being used.\n For details see the `notes `_.\n\n :param bins: numpy array of binned weights for the samples\n :param par: A :class:`~.paramnames.ParamInfo` instance for the parameter to analyse\n :param param: index of the parameter to use\n :param mult_bias_correction_order: order of multiplicative bias correction (0 is basic Parzen kernel); by default taken from instance settings.\n :param kernel_order: order of the kernel (0 is Parzen, 1 does linear boundary correction, 2 is a higher-order kernel)\n :param N_eff: effective number of samples. If not specified estimated using weights, autocorrelations, and fiducial bandwidth\n :return: kernel density bandwidth (in units the range of the bins)\n \"\"\"\n if N_eff is None:\n N_eff = self._get1DNeff(par, param)\n h = kde.gaussian_kde_bandwidth_binned(bins, Neff=N_eff)\n bin_range = max(par.param_max, par.range_max) - min(par.param_min, par.range_min)\n if h is None or h < 0.01 * N_eff ** (-1. / 5) * (par.range_max - par.range_min) / bin_range:\n hnew = 1.06 * par.sigma_range * N_eff ** (-1. / 5) / bin_range\n if par.name not in self.no_warning_params \\\n and (not self.no_warning_chi2_params or 'chi2_' not in par.name):\n logging.warning(\n 'auto bandwidth for %s very small or failed (h=%s,N_eff=%s). Using fallback (h=%s)' % (\n par.name, h, N_eff, hnew))\n h = hnew\n\n par.kde_h = h\n m = mult_bias_correction_order\n if m is None: m = self.mult_bias_correction_order\n if kernel_order > 1: m = max(m, 1)\n if m:\n # higher order method\n # e.g. http://biomet.oxfordjournals.org/content/82/2/327.full.pdf+html\n # some prefactors given in http://eprints.whiterose.ac.uk/42950/6/taylorcc2%5D.pdf\n # Here we just take unit prefactor relative to Gaussian\n # and rescale the optimal h for standard KDE to accounts for higher order scaling\n # Should be about 1.3 x larger for Gaussian, but smaller in some other cases\n return h * N_eff ** (1. / 5 - 1. / (4 * m + 5))\n else:\n return h\n\n def getAutoBandwidth2D(self, bins, parx, pary, paramx, paramy, corr, rangex, rangey, base_fine_bins_2D,\n mult_bias_correction_order=None, min_corr=0.2, N_eff=None):\n \"\"\"\n Get optimized kernel density bandwidth matrix in parameter units, using Improved Sheather Jones method in sheared parameters.\n For details see the `notes `_.\n\n :param bins: 2D numpy array of binned weights\n :param parx: A :class:`~.paramnames.ParamInfo` instance for the x parameter\n :param pary: A :class:`~.paramnames.ParamInfo` instance for the y parameter\n :param paramx: index of the x parameter\n :param paramy: index of the y parameter\n :param corr: correlation of the samples\n :param rangex: scale in the x parameter\n :param rangey: scale in the y parameter\n :param base_fine_bins_2D: number of bins to use for re-binning in rotated parameter space\n :param mult_bias_correction_order: multiplicative bias correction order (0 is Parzen kernel); by default taken from instance settings\n :param min_corr: minimum correlation value at which to bother de-correlating the parameters\n :param N_eff: effective number of samples. If not specified, currently uses crude estimate from effective numbers in x and y separately\n :return: kernel density bandwidth matrix in parameter units\n \"\"\"\n if N_eff is None:\n N_eff = max(self._get1DNeff(parx, paramx), self._get1DNeff(pary, paramy)) # todo: write _get2DNeff\n logging.debug('%s %s AutoBandwidth2D: N_eff=%s, corr=%s', parx.name, pary.name, N_eff, corr)\n has_limits = parx.has_limits or pary.has_limits\n do_correlated = not parx.has_limits or not pary.has_limits\n\n def fallback_widths():\n logging.warning('2D kernel density bandwidth optimizer failed for %s, %s. Using fallback width.' % (\n parx.name, pary.name))\n c = max(min(corr, self.max_corr_2D), -self.max_corr_2D)\n hx = parx.sigma_range / N_eff ** (1. / 6)\n hy = pary.sigma_range / N_eff ** (1. / 6)\n return hx, hy, c\n\n if min_corr < abs(corr) <= self.max_corr_2D and do_correlated:\n # 'shear' the data so fairly uncorrelated, making sure shear keeps any bounds on one parameter unchanged\n # the binning step will rescale to make roughly isotropic as assumed by the 2D kernel optimizer psi_{ab} derivatives\n i, j = paramx, paramy\n imax, imin = None, None\n if parx.has_limits_bot:\n imin = parx.range_min\n if parx.has_limits_top:\n imax = parx.range_max\n if pary.has_limits:\n i, j = j, i\n if pary.has_limits_bot:\n imin = pary.range_min\n if pary.has_limits_top:\n imax = pary.range_max\n\n cov = self.getCov(pars=[i, j])\n S = np.linalg.cholesky(cov)\n ichol = np.linalg.inv(S)\n S *= ichol[0, 0]\n r = ichol[1, :] / ichol[0, 0]\n p1 = self.samples[:, i]\n p2 = r[0] * self.samples[:, i] + r[1] * self.samples[:, j]\n\n bin1, R1 = kde.bin_samples(p1, nbins=base_fine_bins_2D, range_min=imin, range_max=imax)\n bin2, R2 = kde.bin_samples(p2, nbins=base_fine_bins_2D)\n rotbins, _ = self._make2Dhist(bin1, bin2, base_fine_bins_2D, base_fine_bins_2D)\n try:\n opt = kde.KernelOptimizer2D(rotbins, N_eff, 0, do_correlation=not has_limits)\n hx, hy, c = opt.get_h()\n hx *= R1\n hy *= R2\n kernelC = S.dot(np.array([[hx ** 2, hx * hy * c], [hx * hy * c, hy ** 2]])).dot(S.T)\n hx, hy, c = np.sqrt(kernelC[0, 0]), np.sqrt(kernelC[1, 1]), kernelC[0, 1] / np.sqrt(\n kernelC[0, 0] * kernelC[1, 1])\n if pary.has_limits:\n hx, hy = hy, hx\n # print 'derotated pars', hx, hy, c\n except ValueError:\n hx, hy, c = fallback_widths()\n elif abs(corr) > self.max_corr_2D or not do_correlated and corr > 0.8:\n c = max(min(corr, self.max_corr_2D), -self.max_corr_2D)\n hx = parx.sigma_range / N_eff ** (1. / 6)\n hy = pary.sigma_range / N_eff ** (1. / 6)\n else:\n try:\n opt = kde.KernelOptimizer2D(bins, N_eff, corr, do_correlation=not has_limits)\n hx, hy, c = opt.get_h()\n hx *= rangex\n hy *= rangey\n except ValueError:\n hx, hy, c = fallback_widths()\n\n if mult_bias_correction_order is None: mult_bias_correction_order = self.mult_bias_correction_order\n logging.debug('hx/sig, hy/sig, corr =%s, %s, %s', hx / parx.err, hy / pary.err, c)\n if mult_bias_correction_order:\n scale = 1.1 * N_eff ** (1. / 6 - 1. / (2 + 4 * (1 + mult_bias_correction_order)))\n hx *= scale\n hy *= scale\n logging.debug('hx/sig, hy/sig, corr, scale =%s, %s, %s, %s', hx / parx.err, hy / pary.err, c, scale)\n return hx, hy, c\n\n def _initParamRanges(self, j, paramConfid=None):\n if isinstance(j, six.string_types): j = self.index[j]\n paramVec = self.samples[:, j]\n return self._initParam(self.paramNames.names[j], paramVec, self.means[j], self.sddev[j], paramConfid)\n\n def _initParam(self, par, paramVec, mean=None, sddev=None, paramConfid=None):\n if mean is None: mean = paramVec.mean()\n if sddev is None: sddev = paramVec.std()\n par.err = sddev\n par.mean = mean\n par.param_min = np.min(paramVec)\n par.param_max = np.max(paramVec)\n paramConfid = paramConfid or self.initParamConfidenceData(paramVec)\n # sigma_range is estimate related to shape of structure in the distribution = std dev for Gaussian\n # search for peaks using quantiles, e.g. like simplified version of Janssen 95 (http://dx.doi.org/10.1080/10485259508832654)\n confid_points = np.linspace(0.1, 0.9, 9)\n confids = self.confidence(paramConfid,\n np.array([self.range_confidence, 1 - self.range_confidence] + list(confid_points)))\n par.range_min, par.range_max = confids[0:2]\n confids[1:-1] = confids[2:]\n confids[0] = par.param_min\n confids[-1] = par.param_max\n diffs = confids[4:] - confids[:-4]\n scale = np.min(diffs) / 1.049\n if np.all(diffs > par.err * 1.049) and np.all(diffs < scale * 1.5):\n # very flat, can use bigger\n par.sigma_range = scale\n else:\n par.sigma_range = min(par.err, scale)\n if self.range_ND_contour >= 0 and self.likeStats:\n if self.range_ND_contour >= par.ND_limit_bot.size:\n raise SettingError(\"range_ND_contour should be -1 (off), or 0, 1 for first or second contour level\")\n par.range_min = min(max(par.range_min - par.err, par.ND_limit_bot[self.range_ND_contour]), par.range_min)\n par.range_max = max(max(par.range_max + par.err, par.ND_limit_top[self.range_ND_contour]), par.range_max)\n\n smooth_1D = par.sigma_range * 0.4\n\n if par.has_limits_bot:\n if par.range_min - par.limmin > 2 * smooth_1D and par.param_min - par.limmin > smooth_1D:\n # long way from limit\n par.has_limits_bot = False\n else:\n par.range_min = par.limmin\n\n if par.has_limits_top:\n if par.limmax - par.range_max > 2 * smooth_1D and par.limmax - par.param_max > smooth_1D:\n par.has_limits_top = False\n else:\n par.range_max = par.limmax\n\n if not par.has_limits_bot:\n par.range_min -= smooth_1D * 2\n\n if not par.has_limits_top:\n par.range_max += smooth_1D * 2\n\n par.has_limits = par.has_limits_top or par.has_limits_bot\n\n return par\n\n def _binSamples(self, paramVec, par, num_fine_bins, borderfrac=0.1):\n\n # High resolution density (sampled many times per smoothing scale). First and last bins are half width\n\n border = (par.range_max - par.range_min) * borderfrac\n binmin = min(par.param_min, par.range_min)\n if not par.has_limits_bot:\n binmin -= border\n binmax = max(par.param_max, par.range_max)\n if not par.has_limits_top:\n binmax += border\n fine_width = (binmax - binmin) / (num_fine_bins - 1)\n ix = ((paramVec - binmin) / fine_width + 0.5).astype(np.int)\n return ix, fine_width, binmin, binmax\n\n def get1DDensity(self, name, **kwargs):\n \"\"\"\n Returns a :class:`~.densities.Density1D` instance for parameter with given name. Result is cached.\n\n :param name: name of the parameter\n :param kwargs: arguments for :func:`~MCSamples.get1DDensityGridData`\n :return: A :class:`~.densities.Density1D` instance for parameter with given name\n \"\"\"\n if self.needs_update: self.updateBaseStatistics()\n if not kwargs:\n density = self.density1D.get(name, None)\n if density is not None: return density\n return self.get1DDensityGridData(name, get_density=True, **kwargs)\n\n def get1DDensityGridData(self, j, writeDataToFile=False, get_density=False, paramConfid=None, meanlikes=False,\n **kwargs):\n \"\"\"\n Low-level function to get a :class:`~.densities.Density1D` instance for the marginalized 1D density of a parameter. Result is not cached.\n\n :param j: a name or index of the parameter\n :param writeDataToFile: True if should write to text file.\n :param get_density: return a :class:`~.densities.Density1D` instance only, does not write out or calculate mean likelihoods for plots\n :param paramConfid: optional cached :class:`ParamConfidenceData` instance\n :param meanlikes: include mean likelihoods\n :param kwargs: optional settings to override instance settings of the same name (see `analysis_settings`):\n\n - **smooth_scale_1D**\n - **boundary_correction_order**\n - **mult_bias_correction_order**\n - **fine_bins**\n - **num_bins**\n :return: A :class:`~.densities.Density1D` instance\n \"\"\"\n\n if self.needs_update: self.updateBaseStatistics()\n j = self._parAndNumber(j)[0]\n if j is None: return None\n\n par = self._initParamRanges(j, paramConfid)\n num_bins = kwargs.get('num_bins', self.num_bins)\n smooth_scale_1D = kwargs.get('smooth_scale_1D', self.smooth_scale_1D)\n boundary_correction_order = kwargs.get('boundary_correction_order', self.boundary_correction_order)\n mult_bias_correction_order = kwargs.get('mult_bias_correction_order', self.mult_bias_correction_order)\n fine_bins = kwargs.get('fine_bins', self.fine_bins)\n\n paramrange = par.range_max - par.range_min\n if paramrange <= 0: raise MCSamplesError('Parameter range is <= 0: ' + par.name)\n width = paramrange / (num_bins - 1)\n\n bin_indices, fine_width, binmin, binmax = self._binSamples(self.samples[:, j], par, fine_bins)\n bins = np.bincount(bin_indices, weights=self.weights, minlength=fine_bins)\n\n if meanlikes:\n if self.shade_likes_is_mean_loglikes:\n w = self.weights * self.loglikes\n else:\n w = self.weights * np.exp((self.mean_loglike - self.loglikes))\n finebinlikes = np.bincount(bin_indices, weights=w, minlength=fine_bins)\n\n if smooth_scale_1D <= 0:\n # Set automatically.\n smooth_1D = self.getAutoBandwidth1D(bins, par, j, mult_bias_correction_order, boundary_correction_order) \\\n * (binmax - binmin) * abs(smooth_scale_1D) / fine_width\n\n elif smooth_scale_1D < 1.0:\n smooth_1D = smooth_scale_1D * par.err / fine_width\n else:\n smooth_1D = smooth_scale_1D * width / fine_width\n\n if smooth_1D < 2:\n logging.warning('fine_bins not large enough to well sample smoothing scale - ' + par.name)\n\n smooth_1D = min(max(1., smooth_1D), fine_bins // 2)\n\n logging.debug(\"%s 1D sigma_range, std: %s, %s; smooth_1D_bins: %s \", par.name, par.sigma_range, par.err,\n smooth_1D)\n\n winw = min(int(round(2.5 * smooth_1D)), fine_bins // 2 - 2)\n Kernel = Kernel1D(winw, smooth_1D)\n\n cache = {}\n conv = convolve1D(bins, Kernel.Win, 'same', cache=cache)\n fine_x = np.linspace(binmin, binmax, fine_bins)\n density1D = Density1D(fine_x, P=conv, view_ranges=[par.range_min, par.range_max])\n\n if meanlikes: rawbins = conv.copy()\n\n if par.has_limits and boundary_correction_order >= 0:\n # correct for cuts allowing for normalization over window\n prior_mask = np.ones(fine_bins + 2 * winw)\n if par.has_limits_bot:\n prior_mask[winw] = 0.5\n prior_mask[: winw] = 0\n if par.has_limits_top:\n prior_mask[-(winw + 1)] = 0.5\n prior_mask[-winw:] = 0\n a0 = convolve1D(prior_mask, Kernel.Win, 'valid', cache=cache)\n ix = np.nonzero(a0 * density1D.P)\n a0 = a0[ix]\n normed = density1D.P[ix] / a0\n if boundary_correction_order == 0:\n density1D.P[ix] = normed\n elif boundary_correction_order <= 2:\n # linear boundary kernel, e.g. Jones 1993, Jones and Foster 1996\n # www3.stat.sinica.edu.tw/statistica/oldpdf/A6n414.pdf after Eq 1b, expressed for general prior mask\n # cf arXiv:1411.5528\n xWin = Kernel.Win * Kernel.x\n a1 = convolve1D(prior_mask, xWin, 'valid', cache=cache)[ix]\n a2 = convolve1D(prior_mask, xWin * Kernel.x, 'valid', cache=cache, cache_args=[1])[ix]\n xP = convolve1D(bins, xWin, 'same', cache=cache)[ix]\n if boundary_correction_order == 1:\n corrected = (density1D.P[ix] * a2 - xP * a1) / (a0 * a2 - a1 ** 2)\n else:\n # quadratic correction\n a3 = convolve1D(prior_mask, xWin * Kernel.x ** 2, 'valid', cache=cache, cache_args=[1])[ix]\n a4 = convolve1D(prior_mask, xWin * Kernel.x ** 3, 'valid', cache=cache, cache_args=[1])[ix]\n x2P = convolve1D(bins, xWin * Kernel.x, 'same', cache=cache, cache_args=[1])[ix]\n denom = a4 * a2 * a0 - a4 * a1 ** 2 - a2 ** 3 - a3 ** 2 * a0 + 2 * a1 * a2 * a3\n A = a4 * a2 - a3 ** 2\n B = a2 * a3 - a4 * a1\n C = a3 * a1 - a2 ** 2\n corrected = (density1D.P[ix] * A + xP * B + x2P * C) / denom\n density1D.P[ix] = normed * np.exp(np.minimum(corrected / normed, 4) - 1)\n else:\n raise SettingError('Unknown boundary_correction_order (expected 0, 1, 2)')\n elif boundary_correction_order == 2:\n # higher order kernel\n # eg. see http://www.jstor.org/stable/2965571\n xWin2 = Kernel.Win * Kernel.x ** 2\n x2P = convolve1D(bins, xWin2, 'same', cache=cache)\n a2 = np.sum(xWin2)\n a4 = np.dot(xWin2, Kernel.x ** 2)\n corrected = (density1D.P * a4 - a2 * x2P) / (a4 - a2 ** 2)\n ix = density1D.P > 0\n density1D.P[ix] *= np.exp(np.minimum(corrected[ix] / density1D.P[ix], 2) - 1)\n\n if mult_bias_correction_order:\n prior_mask = np.ones(fine_bins)\n if par.has_limits_bot:\n prior_mask[0] *= 0.5\n if par.has_limits_top:\n prior_mask[-1] *= 0.5\n a0 = convolve1D(prior_mask, Kernel.Win, 'same', cache=cache, cache_args=[2])\n for _ in range(mult_bias_correction_order):\n # estimate using flattened samples to remove second order biases\n # mostly good performance, see http://www.jstor.org/stable/2965571 method 3,1 for first order\n prob1 = density1D.P.copy()\n prob1[prob1 == 0] = 1\n fine = bins / prob1\n conv = convolve1D(fine, Kernel.Win, 'same', cache=cache, cache_args=[2])\n density1D.setP(density1D.P * conv)\n density1D.P /= a0\n\n density1D.normalize('max', in_place=True)\n if not kwargs: self.density1D[par.name] = density1D\n\n if get_density: return density1D\n\n if meanlikes:\n ix = density1D.P > 0\n finebinlikes[ix] /= density1D.P[ix]\n binlikes = convolve1D(finebinlikes, Kernel.Win, 'same', cache=cache, cache_args=[2])\n binlikes[ix] *= density1D.P[ix] / rawbins[ix]\n if self.shade_likes_is_mean_loglikes:\n maxbin = np.min(binlikes)\n binlikes = np.where((binlikes - maxbin) < 30, np.exp(-(binlikes - maxbin)), 0)\n binlikes[rawbins == 0] = 0\n binlikes /= np.max(binlikes)\n density1D.likes = binlikes\n else:\n density1D.likes = None\n\n if writeDataToFile:\n # get thinner grid over restricted range for plotting\n x = par.range_min + np.arange(num_bins) * width\n bincounts = density1D.Prob(x)\n\n if meanlikes:\n likeDensity = Density1D(fine_x, P=binlikes)\n likes = likeDensity.Prob(x)\n else:\n likes = None\n\n fname = self.rootname + \"_p_\" + par.name\n filename = os.path.join(self.plot_data_dir, fname + \".dat\")\n with open(filename, 'w') as f:\n for xval, binval in zip(x, bincounts):\n f.write(\"%16.7E%16.7E\\n\" % (xval, binval))\n\n if meanlikes:\n filename_like = os.path.join(self.plot_data_dir, fname + \".likes\")\n with open(filename_like, 'w') as f:\n for xval, binval in zip(x, likes):\n f.write(\"%16.7E%16.7E\\n\" % (xval, binval))\n\n density = Density1D(x, bincounts)\n density.likes = likes\n return density\n else:\n return density1D\n\n def _setEdgeMask2D(self, parx, pary, prior_mask, winw, alledge=False):\n if parx.has_limits_bot:\n prior_mask[:, winw] /= 2\n prior_mask[:, :winw] = 0\n if parx.has_limits_top:\n prior_mask[:, -(winw + 1)] /= 2\n prior_mask[:, -winw:] = 0\n if pary.has_limits_bot:\n prior_mask[winw, :] /= 2\n prior_mask[:winw:] = 0\n if pary.has_limits_top:\n prior_mask[-(winw + 1), :] /= 2\n prior_mask[-winw:, :] = 0\n if alledge:\n prior_mask[:, :winw] = 0\n prior_mask[:, -winw:] = 0\n prior_mask[:winw:] = 0\n prior_mask[-winw:, :] = 0\n\n def _getScaleForParam(self, par):\n # Also ensures that the 1D limits are initialized\n density = self.get1DDensity(par)\n mn, mx, lim_bot, lim_top = density.getLimits(0.5, accuracy_factor=1)\n if lim_bot or lim_top:\n scale = (mx - mn) / 0.675\n else:\n scale = (mx - mn) / (2 * 0.675)\n return scale\n\n def _parAndNumber(self, name):\n if isinstance(name, ParamInfo): name = name.name\n if isinstance(name, six.string_types):\n name = self.index.get(name, None)\n if name is None: return None, None\n if isinstance(name, six.integer_types):\n return name, self.paramNames.names[name]\n raise ParamError(\"Unknown parameter type %s\" % name)\n\n def _make2Dhist(self, ixs, iys, xsize, ysize):\n flatix = ixs + iys * xsize\n # note arrays are indexed y,x\n\n return np.bincount(flatix, weights=self.weights,\n minlength=xsize * ysize).reshape((ysize, xsize)), flatix\n\n def get2DDensity(self, x, y, normalized=False, **kwargs):\n \"\"\"\n Returns a :class:`~.densities.Density2D` instance with marginalized 2D density.\n\n :param x: index or name of x parameter\n :param y: index or name of y parameter\n :param kwargs: keyword arguments for the :func:`get2DDensityGridData` function\n :param normalized: if False, is normalized so the maximum is 1, if True, density is normalized\n :return: :class:`~.densities.Density2D` instance\n \"\"\"\n if self.needs_update: self.updateBaseStatistics()\n density = self.get2DDensityGridData(x, y, get_density=True, **kwargs)\n if normalized:\n density.normalize(in_place=True)\n return density\n\n def get2DDensityGridData(self, j, j2, writeDataToFile=False,\n num_plot_contours=None, get_density=False, meanlikes=False, **kwargs):\n \"\"\"\n Low-level function to get 2D plot marginalized density and optional additional plot data.\n\n :param j: name or index of the x parameter\n :param j2: name or index of the y parameter.\n :param writeDataToFile: True if should write data to file\n :param num_plot_contours: number of contours to calculate and return in density.contours\n :param get_density: only get the 2D marginalized density, no additional plot data\n :param meanlikes: calculate mean likelihoods as well as marginalized density (returned as array in density.likes)\n :param kwargs: optional settings to override instance settings of the same name (see `analysis_settings`):\n\n - **fine_bins_2D**\n - **boundary_correction_order**\n - **mult_bias_correction_order**\n - **smooth_scale_2D**\n :return: a :class:`~.densities.Density2D` instance\n \"\"\"\n if self.needs_update: self.updateBaseStatistics()\n start = time.time()\n j, parx = self._parAndNumber(j)\n j2, pary = self._parAndNumber(j2)\n if j is None or j2 is None: return None\n\n self._initParamRanges(j)\n self._initParamRanges(j2)\n\n base_fine_bins_2D = kwargs.get('fine_bins_2D', self.fine_bins_2D)\n boundary_correction_order = kwargs.get('boundary_correction_order', self.boundary_correction_order)\n mult_bias_correction_order = kwargs.get('mult_bias_correction_order', self.mult_bias_correction_order)\n smooth_scale_2D = float(kwargs.get('smooth_scale_2D', self.smooth_scale_2D))\n\n has_prior = parx.has_limits or pary.has_limits\n\n corr = self.getCorrelationMatrix()[j2][j]\n if corr == 1: logging.warning('Parameters are 100%% correlated: %s, %s', parx.name, pary.name)\n\n logging.debug('Doing 2D: %s - %s', parx.name, pary.name)\n logging.debug('sample x_err, y_err, correlation: %s, %s, %s', parx.err, pary.err, corr)\n\n # keep things simple unless obvious degeneracy\n if abs(self.max_corr_2D) > 1: raise SettingError('max_corr_2D cannot be >=1')\n if abs(corr) < 0.1: corr = 0.\n\n # for tight degeneracies increase bin density\n angle_scale = max(0.2, np.sqrt(1 - min(self.max_corr_2D, abs(corr)) ** 2))\n\n nbin2D = int(round(self.num_bins_2D / angle_scale))\n fine_bins_2D = base_fine_bins_2D\n if corr:\n scaled = 192 * int(3 / angle_scale) // 3\n if base_fine_bins_2D < scaled and int(1 / angle_scale) > 1:\n fine_bins_2D = scaled\n\n ixs, finewidthx, xbinmin, xbinmax = self._binSamples(self.samples[:, j], parx, fine_bins_2D)\n iys, finewidthy, ybinmin, ybinmax = self._binSamples(self.samples[:, j2], pary, fine_bins_2D)\n\n xsize = fine_bins_2D\n ysize = fine_bins_2D\n\n histbins, flatix = self._make2Dhist(ixs, iys, xsize, ysize)\n\n if meanlikes:\n likeweights = self.weights * np.exp(self.mean_loglike - self.loglikes)\n finebinlikes = np.bincount(flatix, weights=likeweights,\n minlength=xsize * ysize).reshape((ysize, xsize))\n\n # smooth_x and smooth_y should be in rotated bin units\n if smooth_scale_2D < 0:\n\n rx, ry, corr = self.getAutoBandwidth2D(histbins, parx, pary, j, j2, corr, xbinmax - xbinmin,\n ybinmax - ybinmin,\n base_fine_bins_2D,\n mult_bias_correction_order=mult_bias_correction_order)\n\n rx = rx * abs(smooth_scale_2D) / finewidthx\n ry = ry * abs(smooth_scale_2D) / finewidthy\n elif smooth_scale_2D < 1.0:\n rx = smooth_scale_2D * parx.err / finewidthx\n ry = smooth_scale_2D * pary.err / finewidthy\n else:\n rx = smooth_scale_2D * fine_bins_2D / nbin2D\n ry = smooth_scale_2D * fine_bins_2D / nbin2D\n\n smooth_scale = float(max(rx, ry))\n logging.debug('corr, rx, ry: %s, %s, %s', corr, rx, ry)\n\n if smooth_scale < 2:\n logging.warning('fine_bins_2D not large enough for optimal density')\n\n winw = int(round(2.5 * smooth_scale))\n\n Cinv = np.linalg.inv(np.array([[ry ** 2, rx * ry * corr], [rx * ry * corr, rx ** 2]]))\n ix1, ix2 = np.mgrid[-winw:winw + 1, -winw:winw + 1]\n Win = np.exp(-(ix1 ** 2 * Cinv[0, 0] + ix2 ** 2 * Cinv[1, 1] + 2 * Cinv[1, 0] * ix1 * ix2) / 2)\n Win /= np.sum(Win)\n\n logging.debug('time 2D binning and bandwidth: %s ; bins: %s', time.time() - start, fine_bins_2D)\n start = time.time()\n cache = {}\n convolvesize = xsize + 2 * winw + Win.shape[0]\n bins2D = convolve2D(histbins, Win, 'same', largest_size=convolvesize, cache=cache)\n\n if meanlikes:\n bin2Dlikes = convolve2D(finebinlikes, Win, 'same', largest_size=convolvesize, cache=cache, cache_args=[2])\n if mult_bias_correction_order:\n ix = bin2Dlikes > 0\n finebinlikes[ix] /= bin2Dlikes[ix]\n likes2 = convolve2D(finebinlikes, Win, 'same', largest_size=convolvesize, cache=cache, cache_args=[2])\n likes2[ix] *= bin2Dlikes[ix]\n bin2Dlikes = likes2\n del finebinlikes\n mx = 1e-4 * np.max(bins2D)\n bin2Dlikes[bins2D > mx] /= bins2D[bins2D > mx]\n bin2Dlikes[bins2D <= mx] = 0\n else:\n bin2Dlikes = None\n\n if has_prior and boundary_correction_order >= 0:\n # Correct for edge effects\n prior_mask = np.ones((ysize + 2 * winw, xsize + 2 * winw))\n self._setEdgeMask2D(parx, pary, prior_mask, winw)\n a00 = convolve2D(prior_mask, Win, 'valid', largest_size=convolvesize, cache=cache)\n ix = a00 * bins2D > np.max(bins2D) * 1e-8\n a00 = a00[ix]\n normed = bins2D[ix] / a00\n if boundary_correction_order == 1:\n # linear boundary correction\n indexes = np.arange(-winw, winw + 1)\n y = np.empty(Win.shape)\n for i in range(Win.shape[0]):\n y[:, i] = indexes\n winx = Win * indexes\n winy = Win * y\n a10 = convolve2D(prior_mask, winx, 'valid', largest_size=convolvesize, cache=cache)[ix]\n a01 = convolve2D(prior_mask, winy, 'valid', largest_size=convolvesize, cache=cache)[ix]\n a20 = \\\n convolve2D(prior_mask, winx * indexes, 'valid', largest_size=convolvesize, cache=cache,\n cache_args=[1])[\n ix]\n a02 = convolve2D(prior_mask, winy * y, 'valid', largest_size=convolvesize, cache=cache, cache_args=[1])[\n ix]\n a11 = \\\n convolve2D(prior_mask, winy * indexes, 'valid', largest_size=convolvesize, cache=cache,\n cache_args=[1])[\n ix]\n xP = convolve2D(histbins, winx, 'same', largest_size=convolvesize, cache=cache)[ix]\n yP = convolve2D(histbins, winy, 'same', largest_size=convolvesize, cache=cache)[ix]\n denom = (a20 * a01 ** 2 + a10 ** 2 * a02 - a00 * a02 * a20 + a11 ** 2 * a00 - 2 * a01 * a10 * a11)\n A = a11 ** 2 - a02 * a20\n Ax = a10 * a02 - a01 * a11\n Ay = a01 * a20 - a10 * a11\n corrected = (bins2D[ix] * A + xP * Ax + yP * Ay) / denom\n bins2D[ix] = normed * np.exp(np.minimum(corrected / normed, 4) - 1)\n elif boundary_correction_order == 0:\n # simple boundary correction by normalization\n bins2D[ix] = normed\n else:\n raise SettingError('unknown boundary_correction_order (expected 0 or 1)')\n\n if mult_bias_correction_order:\n prior_mask = np.ones((ysize + 2 * winw, xsize + 2 * winw))\n self._setEdgeMask2D(parx, pary, prior_mask, winw, alledge=True)\n a00 = convolve2D(prior_mask, Win, 'valid', largest_size=convolvesize, cache=cache, cache_args=[2])\n for _ in range(mult_bias_correction_order):\n box = histbins.copy()\n ix2 = bins2D > np.max(bins2D) * 1e-8\n box[ix2] /= bins2D[ix2]\n bins2D *= convolve2D(box, Win, 'same', largest_size=convolvesize, cache=cache, cache_args=[2])\n bins2D /= a00\n\n x = np.linspace(xbinmin, xbinmax, xsize)\n y = np.linspace(ybinmin, ybinmax, ysize)\n density = Density2D(x, y, bins2D,\n view_ranges=[(parx.range_min, parx.range_max), (pary.range_min, pary.range_max)])\n density.normalize('max', in_place=True)\n if get_density: return density\n\n ncontours = len(self.contours)\n if num_plot_contours: ncontours = min(num_plot_contours, ncontours)\n contours = self.contours[:ncontours]\n\n logging.debug('time 2D convolutions: %s', time.time() - start)\n\n # Get contour containing contours(:) of the probability\n density.contours = density.getContourLevels(contours)\n\n # now make smaller num_bins grid between ranges for plotting\n # x = parx.range_min + np.arange(nbin2D + 1) * widthx\n # y = pary.range_min + np.arange(nbin2D + 1) * widthy\n # bins2D = density.Prob(x, y)\n # bins2D[bins2D < 1e-30] = 0\n\n if meanlikes:\n bin2Dlikes /= np.max(bin2Dlikes)\n density.likes = bin2Dlikes\n else:\n density.likes = None\n\n if writeDataToFile:\n # note store things in confusing transpose form\n # if meanlikes:\n # filedensity = Density2D(x, y, bin2Dlikes)\n # bin2Dlikes = filedensity.Prob(x, y)\n\n plotfile = self.rootname + \"_2D_%s_%s\" % (parx.name, pary.name)\n filename = os.path.join(self.plot_data_dir, plotfile)\n np.savetxt(filename, bins2D.T, \"%16.7E\")\n np.savetxt(filename + \"_y\", x, \"%16.7E\")\n np.savetxt(filename + \"_x\", y, \"%16.7E\")\n np.savetxt(filename + \"_cont\", np.atleast_2d(density.contours), \"%16.7E\")\n if meanlikes:\n np.savetxt(filename + \"_likes\", bin2Dlikes.T, \"%16.7E\")\n # res = Density2D(x, y, bins2D)\n # res.contours = density.contours\n # res.likes = bin2Dlikes\n return density\n\n def _setRawEdgeMaskND(self, parv, prior_mask):\n ndim = len(parv)\n vrap = parv[::-1]\n mskShape = prior_mask.shape\n\n if len(mskShape) != ndim:\n raise ValueError(\"parv and prior_mask or different sizes!\")\n\n # create a slice object iterating over everything\n mskSlices = [slice(None) for _ in range(ndim)]\n\n for i in range(ndim):\n if vrap[i].has_limits_bot:\n mskSlices[i] = 0\n prior_mask[mskSlices] /= 2\n mskSlices[i] = slice(None)\n\n if vrap[i].has_limits_top:\n mskSlices[i] = mskShape[i] - 1\n prior_mask[mskSlices] /= 2\n mskSlices[i] = slice(None)\n\n def _flattenValues(self, ixs, xsizes):\n ndim = len(ixs)\n\n q = ixs[0]\n for i in range(1, ndim):\n q = q + np.prod(xsizes[0:i]) * ixs[i]\n return q\n\n def _unflattenValues(self, q, xsizes):\n ndim = len(xsizes)\n\n ixs = list([np.array(q) for _ in range(ndim)])\n\n if ndim == 1:\n ixs[0] = q\n return ixs\n\n ixs[ndim - 1] = q / np.prod(xsizes[0:ndim - 1])\n\n acc = 0\n for k in range(ndim - 2, -1, -1):\n acc = acc + ixs[k + 1] * np.prod(xsizes[0:k + 1])\n if k > 0:\n ixs[k] = (q - acc) / np.prod(xsizes[0:k])\n else:\n ixs[k] = q - acc\n\n return ixs\n\n def _makeNDhist(self, ixs, xsizes):\n\n if len(ixs) != len(xsizes):\n raise ValueError('index and size arrays are of unequal length')\n\n flatixv = self._flattenValues(ixs, xsizes)\n\n # to be removed debugging only\n if np.count_nonzero(np.asarray(ixs) - self._unflattenValues(flatixv, xsizes)) != 0:\n raise ValueError('ARG!!! flatten/unflatten screwed')\n\n # note arrays are indexed y,x\n return np.bincount(flatixv, weights=self.weights,\n minlength=np.prod(xsizes)).reshape(xsizes[::-1], order='C'), flatixv\n\n def getRawNDDensity(self, xs, normalized=False, **kwargs):\n \"\"\"\n Returns a :class:`~.densities.DensityND` instance with marginalized ND density.\n\n :param xs: indices or names of x_i parameters\n :param kwargs: keyword arguments for the :func:`getNDDensityGridData` function\n :param normalized: if False, is normalized so the maximum is 1, if True, density is normalized\n :return: :class:`~.densities.DensityND` instance\n \"\"\"\n if self.needs_update: self.updateBaseStatistics()\n density = self.getRawNDDensityGridData(xs, get_density=True, **kwargs)\n if normalized:\n density.normalize(in_place=True)\n return density\n\n def getRawNDDensityGridData(self, js, writeDataToFile=False,\n num_plot_contours=None, get_density=False,\n meanlikes=False, maxlikes=False, **kwargs):\n \"\"\"\n Low-level function to get unsmooth ND plot marginalized\n density and optional additional plot data.\n\n :param js: vector of names or indices of the x_i parameters\n :param writeDataToFile: True if should write data to file\n :param num_plot_contours: number of contours to calculate and return in density.contours\n :param get_density: only get the ND marginalized density, no additional plot data, no contours.\n :param meanlikes: calculate mean likelihoods as well as marginalized density (returned as array in density.likes)\n :param maxlikes: calculate the profile likelihoods in addition to the others (returned as array in density.maxlikes)\n :param kwargs: optional settings to override instance settings of the same name (see `analysis_settings`):\n\n :return: a :class:`~.densities.DensityND` instance\n \"\"\"\n\n if self.needs_update: self.updateBaseStatistics()\n\n ndim = len(js)\n\n jv, parv = zip(*[self._parAndNumber(j) for j in js])\n\n if None in jv: return None\n\n [self._initParamRanges(j) for j in jv]\n\n boundary_correction_order = kwargs.get('boundary_correction_order', self.boundary_correction_order)\n has_prior = np.any([parv[i].has_limits for i in range(ndim)])\n\n nbinsND = kwargs.get('num_bins_ND', self.num_bins_ND)\n ixv, widthv, xminv, xmaxv = zip(*[self._binSamples(self.samples[:, jv[i]],\n parv[i], nbinsND) for i in range(ndim)])\n\n # could also be non-equals over the dimensions\n xsizev = nbinsND * np.ones(ndim, dtype=np.int)\n\n binsND, flatixv = self._makeNDhist(ixv, xsizev)\n\n if has_prior and boundary_correction_order >= 0:\n # Correct for edge effects\n prior_mask = np.ones(xsizev[::-1])\n self._setRawEdgeMaskND(parv, prior_mask)\n binsND /= prior_mask\n\n if meanlikes:\n likeweights = self.weights * np.exp(self.mean_loglike - self.loglikes)\n binNDlikes = np.bincount(flatixv, weights=likeweights,\n minlength=np.prod(xsizev)).reshape(xsizev[::-1], order='C')\n else:\n binNDlikes = None\n\n if maxlikes:\n binNDmaxlikes = np.zeros(binsND.shape)\n ndindex = zip(*[ixv[i] for i in range(ndim)[::-1]])\n bestfit = np.max(-self.loglikes)\n\n for irec in range(len(self.loglikes)):\n binNDmaxlikes[ndindex[irec]] = max(binNDmaxlikes[ndindex[irec]],\n np.exp(-bestfit - self.loglikes[irec]))\n else:\n binNDmaxlikes = None\n\n xv = [np.linspace(xminv[i], xmaxv[i], xsizev[i]) for i in range(ndim)]\n views = [(parv[i].range_min, parv[i].range_max) for i in range(ndim)]\n\n density = DensityND(xv, binsND, view_ranges=views)\n\n # density.normalize('integral', in_place=True)\n density.normalize('max', in_place=True)\n if get_density: return density\n\n ncontours = len(self.contours)\n if num_plot_contours: ncontours = min(num_plot_contours, ncontours)\n contours = self.contours[:ncontours]\n\n # Get contour containing contours(:) of the probability\n density.contours = density.getContourLevels(contours)\n\n if meanlikes:\n binNDlikes /= np.max(binNDlikes)\n density.likes = binNDlikes\n else:\n density.likes = None\n\n if maxlikes:\n density.maxlikes = binNDmaxlikes\n density.maxcontours = getOtherContourLevels(binNDmaxlikes, contours, half_edge=False)\n else:\n density.maxlikes = None\n\n if writeDataToFile:\n # note store things in confusing transpose form\n\n postfile = self.rootname + \"_posterior\" + \"_%sD.dat\" % ndim\n contfile = self.rootname + \"_posterior\" + \"_%sD_cont.dat\" % ndim\n\n allND = [np.array(binsND) for _ in range(ndim + 1)]\n allND[0] = np.ravel(binsND, order='C')\n for i in range(ndim):\n # [index[::-1] for column-major order\n allND[i + 1] = [xv[i][index[::-1][i]] for index in np.ndindex(binsND.shape)]\n\n filename = os.path.join(self.plot_data_dir, postfile)\n np.savetxt(filename, np.transpose(allND), \"%16.7E\")\n\n filename = os.path.join(self.plot_data_dir, contfile)\n np.savetxt(filename, np.atleast_2d(density.contours), \"%16.7E\")\n\n if meanlikes:\n allND[0] = np.ravel(binNDlikes, order='C')\n likefile = self.rootname + \"_meanlike\" + \"_%sD.dat\" % ndim\n filename = os.path.join(self.plot_data_dir, likefile)\n np.savetxt(filename, np.transpose(allND), \"%16.7E\")\n\n if maxlikes:\n allND[0] = np.ravel(binNDmaxlikes, order='C')\n likefile = self.rootname + \"_maxlike\" + \"_%sD.dat\" % ndim\n filename = os.path.join(self.plot_data_dir, likefile)\n np.savetxt(filename, np.transpose(allND), \"%16.7E\")\n\n return density\n\n def _setLikeStats(self):\n \"\"\"\n Get and store LikeStats (see :func:`MCSamples.getLikeStats`)\n \"\"\"\n if self.loglikes is None:\n self.likeStats = None\n return None\n m = types.LikeStats()\n bestfit_ix = np.argmin(self.loglikes)\n maxlike = self.loglikes[bestfit_ix]\n m.logLike_sample = maxlike\n if np.max(self.loglikes) - maxlike < 30:\n m.logMeanInvLike = np.log(self.mean(np.exp(self.loglikes - maxlike))) + maxlike\n else:\n m.logMeanInvLike = None\n\n m.meanLogLike = self.mean_loglike\n m.logMeanLike = -np.log(self.mean(np.exp(-(self.loglikes - maxlike)))) + maxlike\n # assuming maxlike is well determined\n m.complexity = 2 * (self.mean_loglike - maxlike)\n\n m.names = self.paramNames.names\n\n # get N-dimensional confidence region\n indexes = self.loglikes.argsort()\n cumsum = np.cumsum(self.weights[indexes])\n m.ND_cont1, m.ND_cont2 = np.searchsorted(cumsum, self.norm * self.contours[0:2])\n\n for j, par in enumerate(self.paramNames.names):\n region1 = self.samples[indexes[:m.ND_cont1], j]\n region2 = self.samples[indexes[:m.ND_cont2], j]\n par.ND_limit_bot = np.array([np.min(region1), np.min(region2)])\n par.ND_limit_top = np.array([np.max(region1), np.max(region2)])\n par.bestfit_sample = self.samples[bestfit_ix][j]\n\n self.likeStats = m\n return m\n\n def _readRanges(self):\n if self.root:\n ranges_file_classic = self.root + '.ranges'\n ranges_file_new = (\n self.root + ('' if self.root.endswith('/') else '__') + 'full.yaml')\n for ranges_file in [ranges_file_classic, ranges_file_new]:\n if os.path.isfile(ranges_file):\n self.ranges = ParamBounds(ranges_file)\n return\n self.ranges = ParamBounds()\n\n def getBounds(self):\n \"\"\"\n Returns the bounds in the form of a :class:`~.parampriors.ParamBounds` instance, for example for determining plot ranges\n\n Bounds are not the same as self.ranges, as if samples are not near the range boundary, the bound is set to None\n\n :return: a :class:`~.parampriors.ParamBounds` instance\n \"\"\"\n bounds = ParamBounds()\n bounds.names = self.paramNames.list()\n for par in self.paramNames.names:\n if par.has_limits_bot:\n bounds.lower[par.name] = par.limmin\n if par.has_limits_top:\n bounds.upper[par.name] = par.limmax\n return bounds\n\n def getUpper(self, name):\n \"\"\"\n Return the upper limit of the parameter with the given name.\n\n :param name: parameter name\n :return: The upper limit if name exists, None otherwise.\n \"\"\"\n par = self.paramNames.parWithName(name)\n if par:\n return getattr(par, 'limmax', None)\n return None\n\n def getLower(self, name):\n \"\"\"\n Return the lower limit of the parameter with the given name.\n\n :param name: parameter name\n :return: The lower limit if name exists, None otherwise.\n \"\"\"\n par = self.paramNames.parWithName(name)\n if par:\n return getattr(par, 'limmin', None)\n return None\n\n def getBestFit(self):\n bf_file = self.root + '.minimum'\n if os.path.exists(bf_file):\n return types.BestFit(bf_file)\n else:\n raise MCSamplesError(\n 'Best fit can only be included if loaded from file and file_root.minimum exists (cannot be calculated from samples)')\n\n def getMargeStats(self, include_bestfit=False):\n \"\"\"\n Returns a :class:`~.types.MargeStats` object with marginalized 1D parameter constraints\n\n :param include_bestfit: if True, set best fit values by loading from root_name.minimum file (assuming it exists)\n :return: A :class:`~.types.MargeStats` instance\n \"\"\"\n self._setDensitiesandMarge1D()\n m = types.MargeStats()\n m.hasBestFit = False\n m.limits = self.contours\n m.names = self.paramNames.names\n if include_bestfit:\n m.addBestFit(self.getBestFit())\n return m\n\n def getLikeStats(self):\n \"\"\"\n Get best fit sample and n-D confidence limits, and various likelihood based statistics\n\n :return: a :class:`~.types.LikeStats` instance storing N-D limits for parameter i in result.names[i].ND_limit_top,\n result.names[i].ND_limit_bot, and best-fit sample value in result.names[i].bestfit_sample\n \"\"\"\n return self.likeStats or self._setLikeStats()\n\n def getTable(self, columns=1, include_bestfit=False, **kwargs):\n \"\"\"\n Creates and returns a :class:`~.types.ResultTable` instance. See also :func:`~MCSamples.getInlineLatex`.\n\n :param columns: number of columns in the table\n :param include_bestfit: True if should include the bestfit parameter values (assuming set)\n :param kwargs: arguments for :class:`~.types.ResultTable` constructor.\n :return: A :class:`~.types.ResultTable` instance\n \"\"\"\n return types.ResultTable(columns, [self.getMargeStats(include_bestfit)], **kwargs)\n\n def getLatex(self, params=None, limit=1, err_sig_figs=None):\n \"\"\"\n Get tex snippet for constraints on a list of parameters\n\n :param params: list of parameter names, or a single parameter name\n :param limit: which limit to get, 1 is the first (default 68%), 2 is the second (limits array specified by self.contours)\n :param err_sig_figs: significant figures in the error\n :return: labels, texs: a list of parameter labels, and a list of tex snippets, or for a single parameter, the latex snippet.\n \"\"\"\n if isinstance(params, six.string_types):\n return self.getInlineLatex(params, limit, err_sig_figs)\n\n marge = self.getMargeStats()\n if params is None: params = marge.list()\n\n formatter = types.NoLineTableFormatter()\n if err_sig_figs: formatter.numberFormatter.err_sf = err_sig_figs\n texs = []\n labels = []\n for par in params:\n tex = marge.texValues(formatter, par, limit=limit)\n if tex is not None:\n texs.append(tex[0])\n labels.append(marge.parWithName(par).getLabel())\n else:\n texs.append(None)\n labels.append(None)\n\n return labels, texs\n\n def getInlineLatex(self, param, limit=1, err_sig_figs=None):\n r\"\"\"\n Get snippet like: A=x\\\\pm y. Will adjust appropriately for one and two tail limits.\n\n :param param: The name of the parameter\n :param limit: which limit to get, 1 is the first (default 68%), 2 is the second (limits array specified by self.contours)\n :param err_sig_figs: significant figures in the error\n :return: The tex snippet.\n \"\"\"\n labels, texs = self.getLatex([param], limit, err_sig_figs)\n if texs[0] is None: raise ValueError('parameter %s not found' % param)\n if not texs[0][0] in ['<', '>']:\n return labels[0] + ' = ' + texs[0]\n else:\n return labels[0] + ' ' + texs[0]\n\n def _setDensitiesandMarge1D(self, max_frac_twotail=None, writeDataToFile=False, meanlikes=False):\n \"\"\"\n Get all the 1D densities; result is cached.\n\n :param max_frac_twotail: optional override for self.max_frac_twotail\n :param writeDataToFile: True if should write to file\n :param meanlikes: include mean likelihoods\n \"\"\"\n if self.done_1Dbins: return\n\n for j in range(self.n):\n paramConfid = self.initParamConfidenceData(self.samples[:, j])\n self.get1DDensityGridData(j, writeDataToFile, get_density=not writeDataToFile, paramConfid=paramConfid,\n meanlikes=meanlikes)\n self._setMargeLimits(self.paramNames.names[j], paramConfid, max_frac_twotail)\n\n self.done_1Dbins = True\n\n def _setMargeLimits(self, par, paramConfid, max_frac_twotail=None, density1D=None):\n \"\"\"\n Get limits, one or two tail depending on whether posterior\n goes to zero at the limits or not\n\n :param par: The :class:`~.paramnames.ParamInfo` to set limits for\n :param paramConfid: :class:`~.chains.ParamConfidenceData` instance\n :param max_frac_twotail: optional override for self.max_frac_twotail\n :param density1D: any existing density 1D instance to use\n \"\"\"\n if max_frac_twotail is None:\n max_frac_twotail = self.max_frac_twotail\n par.limits = []\n density1D = density1D or self.get1DDensity(par.name)\n interpGrid = None\n for ix1, contour in enumerate(self.contours):\n\n marge_limits_bot = par.has_limits_bot and \\\n not self.force_twotail and density1D.P[0] > max_frac_twotail[ix1]\n marge_limits_top = par.has_limits_top and \\\n not self.force_twotail and density1D.P[-1] > max_frac_twotail[ix1]\n\n if not marge_limits_bot or not marge_limits_top:\n # give limit\n if not interpGrid: interpGrid = density1D.initLimitGrids()\n tail_limit_bot, tail_limit_top, marge_limits_bot, marge_limits_top = density1D.getLimits(contour,\n interpGrid)\n limfrac = 1 - contour\n\n if marge_limits_bot:\n # fix to end of prior range\n tail_limit_bot = par.range_min\n elif marge_limits_top:\n # 1 tail limit\n tail_limit_bot = self.confidence(paramConfid, limfrac, upper=False)\n else:\n # 2 tail limit\n tail_confid_bot = self.confidence(paramConfid, limfrac / 2, upper=False)\n\n if marge_limits_top:\n tail_limit_top = par.range_max\n elif marge_limits_bot:\n tail_limit_top = self.confidence(paramConfid, limfrac, upper=True)\n else:\n tail_confid_top = self.confidence(paramConfid, limfrac / 2, upper=True)\n\n if not marge_limits_bot and not marge_limits_top:\n # Two tail, check if limits are at very different density\n if (math.fabs(density1D.Prob(tail_confid_top) -\n density1D.Prob(tail_confid_bot)) < self.credible_interval_threshold):\n tail_limit_top = tail_confid_top\n tail_limit_bot = tail_confid_bot\n\n lim = [tail_limit_bot, tail_limit_top]\n else:\n # no limit\n lim = [par.range_min, par.range_max]\n\n if marge_limits_bot and marge_limits_top:\n tag = 'none'\n elif marge_limits_bot:\n tag = '>'\n elif marge_limits_top:\n tag = '<'\n else:\n tag = 'two'\n par.limits.append(types.ParamLimit(lim, tag))\n\n def getCorrelatedVariable2DPlots(self, num_plots=12, nparam=None):\n \"\"\"\n Gets a list of most correlated variable pair names.\n\n :param num_plots: The number of plots\n :param nparam: maximum number of pairs to get\n :return: list of [x,y] pair names\n \"\"\"\n nparam = nparam or self.paramNames.numNonDerived()\n try_t = 1e5\n x, y = 0, 0\n cust2DPlots = []\n correlationMatrix = self.correlationMatrix\n for _ in range(num_plots):\n try_b = -1e5\n for ix1 in range(nparam):\n for ix2 in range(ix1 + 1, nparam):\n if try_b < abs(correlationMatrix[ix1][ix2]) < try_t:\n try_b = abs(correlationMatrix[ix1][ix2])\n x, y = ix1, ix2\n if try_b == -1e5:\n break\n try_t = try_b\n cust2DPlots.append([self.parName(x), self.parName(y)])\n\n return cust2DPlots\n\n def addDerived(self, paramVec, name, label='', comment='', range=None):\n \"\"\"\n Adds a new derived parameter\n\n :param paramVec: The vector of parameter values to add. For example a combination of parameter arrays from MCSamples.getParams()\n :param name: The name for the new parameter\n :param label: optional latex label for the parameter\n :param comment: optional comment describing the parameter\n :param range: if specified, a tuple of min, max values for the new parameter hard prior bounds (either can be None for one-side bound)\n :return: The added parameter's :class:`~.paramnames.ParamInfo` object\n \"\"\"\n\n if range is not None:\n self.ranges.setRange(name, range)\n return super(MCSamples, self).addDerived(paramVec, name, label=label, comment=comment)\n\n def getParamBestFitDict(self):\n \"\"\"\n Gets a dictionary of parameter values for the best fit point, assuming .minimum best fit file exists\n :return: dictionary of parameter values\n \"\"\"\n res = self.getBestFit().getParamDict()\n res.update(self.ranges.fixedValueDict())\n return res\n\n def getParamSampleDict(self, ix):\n \"\"\"\n Gets a dictionary of parameter values for sample number ix\n :return: dictionary of parameter values\n \"\"\"\n res = super(MCSamples, self).getParamSampleDict(ix)\n res.update(self.ranges.fixedValueDict())\n return res\n\n def getCombinedSamplesWithSamples(self, samps2, sample_weights=[1, 1]):\n \"\"\"\n Make a new :class:`MCSamples` instance by appending samples from samps2 for parameters which are in common.\n By default they are weighted so that the probability mass of each set of samples is the same,\n independent of tha actual sample sizes. The Weights parameter can be adjusted to change the\n relative weighting.\n :param samps2: :class:`MCSamples` instance to merge\n :param sample_weights: relative weights for combining the samples. Set to None to just directly append samples.\n :return: a new :class:`MCSamples` instance with the combined samples\n \"\"\"\n\n params = ParamNames()\n params.names = [ParamInfo(name=p.name, label=p.label, derived=p.isDerived) for p in samps2.paramNames.names if\n p.name in self.paramNames.list()]\n if self.loglikes is not None and samps2.loglikes is not None:\n loglikes = np.concatenate([self.loglikes, samps2.loglikes])\n else:\n loglikes = None\n if sample_weights is None:\n fac = 1\n sample_weights = [1, 1]\n else:\n fac = np.sum(self.weights) / np.sum(samps2.weights)\n weights = np.concatenate([self.weights * sample_weights[0], samps2.weights * sample_weights[1] * fac])\n p1 = self.getParams()\n p2 = samps2.getParams()\n samples = np.array([np.concatenate([getattr(p1, name), getattr(p2, name)]) for name in params.list()]).T\n samps = MCSamples(samples=samples, weights=weights, loglikes=loglikes, paramNamesFile=params, ignore_rows=0,\n ranges=self.ranges, settings=copy.deepcopy(self.ini.params))\n return samps\n\n def saveAsText(self, root, chain_index=None, make_dirs=False):\n \"\"\"\n Saves samples as text file, including .ranges and .paramnames.\n\n :param root: The root file name to use.\n :param chain_index: optional index to be used for the filename.\n :param make_dirs: True if should create the directories\n \"\"\"\n super(MCSamples, self).saveAsText(root, chain_index, make_dirs)\n if not chain_index:\n self.ranges.saveToFile(root + '.ranges')\n\n def saveChainsAsText(self, root, make_dirs=False, properties={}):\n if self.chains is None:\n chains = self.getSeparateChains()\n else:\n chains = self.chains\n for i, chain in enumerate(chains):\n chain.saveAsText(root, i, make_dirs)\n self.ranges.saveToFile(root + '.ranges')\n self.paramNames.saveAsText(root + '.paramnames')\n if properties:\n ini_name = root + '.properties.ini'\n if os.path.exists(ini_name):\n ini = IniFile(ini_name)\n else:\n ini = IniFile()\n ini.params.update(properties)\n ini.saveFile(ini_name)\n\n # Write functions for GetDist.py\n def writeScriptPlots1D(self, filename, plotparams=None, ext=None):\n \"\"\"\n Write a script that generates a 1D plot. Only intended for use by GetDist.py script.\n\n :param filename: The filename to write to.\n :param plotparams: The list of parameters to plot (default: all)\n :param ext: The extension for the filename, Default if None\n \"\"\"\n text = 'markers = ' + (str(self.markers) if self.markers else 'None') + '\\n'\n if plotparams:\n text += 'g.plots_1d(roots,[' + \",\".join(['\\'' + par + '\\'' for par in plotparams]) + '], markers=markers)'\n else:\n text += 'g.plots_1d(roots, markers=markers)'\n self._WritePlotFile(filename, self.subplot_size_inch, text, '', ext)\n\n def writeScriptPlots2D(self, filename, plot_2D_param=None, cust2DPlots=[], writeDataToFile=False, ext=None,\n shade_meanlikes=False):\n \"\"\"\n Write script that generates a 2 dimensional plot. Only intended for use by GetDist.py script.\n\n :param filename: The filename to write to.\n :param plot_2D_param: parameter to plot other variables against\n :param cust2DPlots: list of parts of parameter names to plot\n :param writeDataToFile: True if should write to file\n :param ext: The extension for the filename, Default if None\n :param shade_meanlikes: shade by mean likelihoods\n :return: A dictionary indexed by pairs of parameters where 2D densities have been calculated\n \"\"\"\n done2D = {}\n text = 'pairs=[]\\n'\n plot_num = 0\n if len(cust2DPlots):\n cuts = [par1 + '__' + par2 for par1, par2 in cust2DPlots]\n for j, par1 in enumerate(self.paramNames.list()):\n if plot_2D_param or cust2DPlots:\n if par1 == plot_2D_param: continue\n j2min = 0\n else:\n j2min = j + 1\n\n for j2 in range(j2min, self.n):\n par2 = self.parName(j2)\n if plot_2D_param and par2 != plot_2D_param: continue\n if len(cust2DPlots) and (par1 + '__' + par2) not in cuts: continue\n if (par1, par2) not in done2D:\n plot_num += 1\n done2D[(par1, par2)] = True\n if writeDataToFile:\n self.get2DDensityGridData(j, j2, writeDataToFile=True, meanlikes=shade_meanlikes)\n text += \"pairs.append(['%s','%s'])\\n\" % (par1, par2)\n if shade_meanlikes:\n text += 'g.plots_2d(roots,param_pairs=pairs,shaded=True)'\n else:\n text += 'g.plots_2d(roots,param_pairs=pairs,filled=True)'\n self._WritePlotFile(filename, self.subplot_size_inch2, text, '_2D', ext)\n return done2D\n\n def writeScriptPlotsTri(self, filename, triangle_params, ext=None):\n \"\"\"\n Write a script that generates a triangle plot. Only intended for use by GetDist.py script.\n\n :param filename: The filename to write to.\n :param triangle_params: list of parameter names to plot\n :param ext: The extension for the filename, Default if None\n \"\"\"\n text = 'g.triangle_plot(roots, %s)' % triangle_params\n self._WritePlotFile(filename, self.subplot_size_inch, text, '_tri', ext)\n\n def writeScriptPlots3D(self, filename, plot_3D, ext=None):\n \"\"\"\n Writes a script that generates a 3D (coloured-scatter) plot. Only intended for use by GetDist.py script.\n\n :param filename: The filename to write to\n :param plot_3D: list of [x,y,z] parameters for the 3 Dimensional plots\n :param ext: The extension for the filename, Default if None\n \"\"\"\n text = 'sets=[]\\n'\n for pars in plot_3D:\n text += \"sets.append(['%s','%s','%s'])\\n\" % tuple(pars)\n text += 'g.plots_3d(roots,sets)'\n self._WritePlotFile(filename, self.subplot_size_inch3, text, '_3D', ext)\n\n def _WritePlotFile(self, filename, subplot_size, text, tag, ext=None):\n \"\"\"\n Write plot file.\n Used by other functions\n\n :param filename: The filename to write to\n :param subplot_size: The size of the subplot.\n :param text: The text to write after the headers.\n :param tag: Tag used for the filename the created file will export to.\n :param ext: The extension for the filename, Default if None\n \"\"\"\n with open(filename, 'w') as f:\n f.write(\"import getdist.plots as plots, os\\n\")\n if self.plot_data_dir:\n f.write(\"g=plots.GetDistPlotter(plot_data=r'%s')\\n\" % self.plot_data_dir)\n else:\n f.write(\"g=plots.GetDistPlotter(chain_dir=r'%s')\\n\" % (self.batch_path or os.path.dirname(self.root)))\n\n f.write(\"g.settings.setWithSubplotSize(%s)\\n\" % subplot_size)\n f.write(\"roots = ['%s']\\n\" % self.rootname)\n f.write(text + '\\n')\n ext = ext or self.plot_output\n fname = self.rootname + tag + '.' + ext\n f.write(\"g.export(os.path.join(r'%s',r'%s'))\\n\" % (self.out_dir, fname))\n\n\n# ==============================================================================\n\n# Useful functions\n\ndef GetChainRootFiles(rootdir):\n \"\"\"\n Gets the root names of all chain files in a directory.\n\n :param rootdir: The root directory to check\n :return: The root names\n \"\"\"\n pattern = os.path.join(rootdir, '*.paramnames')\n files = [os.path.splitext(f)[0] for f in glob.glob(pattern)]\n ending = 'full.yaml'\n pattern = os.path.join(rootdir, \"*\" + ending)\n files += [f[:-len(ending)].rstrip(\"_\") for f in glob.glob(pattern)]\n files.sort()\n return files\n\n\ndef GetRootFileName(rootdir):\n \"\"\"\n Gets the root name of chains in given directory (assuming only one set of chain files).\n\n :param rootdir: The directory to check\n :return: The root file name.\n \"\"\"\n rootFileName = \"\"\n pattern = os.path.join(rootdir, '*_*.txt')\n chain_files = glob.glob(pattern)\n chain_files.sort()\n if chain_files:\n chain_file0 = chain_files[0]\n rindex = chain_file0.rindex('_')\n rootFileName = chain_file0[:rindex]\n return rootFileName\n\n# ==============================================================================\n", "meta": {"hexsha": "8a144464c2d3826e221c104310c9f13129341cec", "size": 116386, "ext": "py", "lang": "Python", "max_stars_repo_path": "python/getdist/mcsamples.py", "max_stars_repo_name": "sfu-cosmo/MagCosmoMC", "max_stars_repo_head_hexsha": "11031bf16fa42b26e16e4caf1ed04b566a2ca436", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "python/getdist/mcsamples.py", "max_issues_repo_name": "sfu-cosmo/MagCosmoMC", "max_issues_repo_head_hexsha": "11031bf16fa42b26e16e4caf1ed04b566a2ca436", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "python/getdist/mcsamples.py", "max_forks_repo_name": "sfu-cosmo/MagCosmoMC", "max_forks_repo_head_hexsha": "11031bf16fa42b26e16e4caf1ed04b566a2ca436", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 45.4810472841, "max_line_length": 151, "alphanum_fraction": 0.5673878302, "include": true, "reason": "import numpy,from scipy", "num_tokens": 28391, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792044, "lm_q2_score": 0.39233683016710835, "lm_q1q2_score": 0.19923329715255292}} {"text": "\"\"\"\nBase classes\n \n.. codeauthor:: David Zwicker \n\"\"\"\n\nfrom abc import ABCMeta, abstractmethod\nimport logging\nfrom typing import Callable, Dict, Optional, TYPE_CHECKING # @UnusedImport\n\nimport numpy as np\n\nfrom ..fields.base import FieldBase\nfrom ..trackers.base import TrackerCollectionDataType\nfrom ..tools.numba import jit\n\n\nif TYPE_CHECKING:\n from ..solvers.controller import TRangeType # @UnusedImport\n\n\n\nclass PDEBase(metaclass=ABCMeta):\n \"\"\" base class for solving partial differential equations \"\"\"\n\n explicit_time_dependence: Optional[bool] = None\n\n\n def __init__(self, noise: float = 0):\n \"\"\"\n Args:\n noise (float):\n Magnitude of the additive Gaussian white noise that is supported\n by default. If set to zero, a determinitics partial differential\n equation will be solved. If another noise structure is required\n the respective methods need to be overwritten.\n \"\"\"\n self._logger = logging.getLogger(self.__class__.__name__)\n self.noise = noise\n\n\n @property\n def is_sde(self) -> bool:\n \"\"\" flag indicating whether this is a stochastic differential equation\n \n The :class:`BasePDF` class supports additive Gaussian white noise, whose\n magnitude is controlled by the `noise` property. In this case, `is_sde`\n is `True` if `self.noise != 0`.\n \"\"\"\n # check for self.noise, in case __init__ is not called in a subclass\n return hasattr(self, 'noise') and self.noise != 0\n\n\n @abstractmethod\n def evolution_rate(self, field: FieldBase, t: float = 0) \\\n -> FieldBase: pass\n\n\n def _make_pde_rhs_numba(self, state: FieldBase) -> Callable:\n \"\"\" create a compiled function for evaluating the right hand side \"\"\"\n raise NotImplementedError\n\n\n def make_pde_rhs(self, state: FieldBase, backend: str = 'auto') -> Callable:\n \"\"\" return a function for evaluating the right hand side of the PDE\n \n Args:\n state (:class:`~pde.fields.FieldBase`):\n An example for the state from which the grid and other\n information can be extracted\n backend (str): Determines how the function is created. Accepted \n values are 'python` and 'numba'. Alternatively, 'auto' lets the\n code decide for the most optimal backend.\n \n Returns:\n Function determining the right hand side of the PDE\n \"\"\"\n if backend == 'auto':\n try:\n result = self._make_pde_rhs_numba(state)\n except NotImplementedError:\n backend = 'numpy'\n else:\n result._backend = 'numba' # type: ignore\n return result\n \n if backend == 'numba':\n result = self._make_pde_rhs_numba(state)\n result._backend = 'numba' # type: ignore\n \n elif backend == 'numpy':\n state = state.copy()\n \n def evolution_rate_numpy(state_data, t: float):\n \"\"\" evaluate the rhs given only a state without the grid \"\"\"\n state.data = state_data\n return self.evolution_rate(state, t).data\n \n result = evolution_rate_numpy\n result._backend = 'numpy' # type: ignore\n \n else:\n raise ValueError(f'Unknown backend `{backend}`')\n \n return result\n \n \n def noise_realization(self, state: FieldBase, t: float = 0) -> FieldBase:\n \"\"\" returns a realization for the noise\n \n Args:\n state (:class:`~pde.fields.ScalarField`):\n The scalar field describing the concentration distribution\n t (float): The current time point\n \n Returns:\n :class:`~pde.fields.ScalarField`:\n Scalar field describing the evolution rate of the PDE \n \"\"\"\n if self.noise:\n data = np.random.normal(scale=self.noise, size=state.data.shape)\n return state.copy(data=data, label='Noise realization')\n else:\n return state.copy(data=0, label='Noise realization')\n\n \n def _make_noise_realization_numba(self, state: FieldBase) -> Callable: \n \"\"\" return a function for evaluating the noise term of the PDE\n \n Args:\n state (:class:`~pde.fields.FieldBase`):\n An example for the state from which the grid and other\n information can be extracted\n \n Returns:\n Function determining the right hand side of the PDE\n \"\"\"\n if self.noise: \n noise_strength = float(self.noise)\n data_shape = state.data.shape\n \n @jit\n def noise_realization(state_data: np.ndarray, t: float):\n \"\"\" compiled helper function returning a noise realization \"\"\" \n return noise_strength * np.random.randn(*data_shape)\n \n else:\n @jit\n def noise_realization(state_data: np.ndarray, t: float):\n \"\"\" compiled helper function returning a noise realization \"\"\" \n return None\n \n return noise_realization # type: ignore \n \n \n def _make_sde_rhs_numba(self, state: FieldBase) -> Callable: \n \"\"\" return a function for evaluating the noise term of the PDE\n \n Args:\n state (:class:`~pde.fields.FieldBase`):\n An example for the state from which the grid and other\n information can be extracted\n \n Returns:\n Function determining the right hand side of the PDE\n \"\"\"\n evolution_rate = self._make_pde_rhs_numba(state)\n noise_realization = self._make_noise_realization_numba(state)\n \n @jit\n def sde_rhs(state_data: np.ndarray, t: float):\n \"\"\" compiled helper function returning a noise realization \"\"\" \n return (evolution_rate(state_data, t),\n noise_realization(state_data, t))\n \n return sde_rhs # type: ignore \n \n \n def make_sde_rhs(self, state: FieldBase, backend: str = 'auto') \\\n -> Callable:\n \"\"\" return a function for evaluating the right hand side of the SDE\n \n Args:\n state (:class:`~pde.fields.FieldBase`):\n An example for the state from which the grid and other\n information can be extracted\n backend (str): Determines how the function is created. Accepted \n values are 'python` and 'numba'. Alternatively, 'auto' lets the\n code decide for the most optimal backend.\n \n Returns:\n Function determining the deterministic part of the right hand side\n of the PDE together with a noise realization.\n \"\"\"\n if backend == 'auto':\n try:\n sde_rhs = self._make_sde_rhs_numba(state)\n except NotImplementedError:\n backend = 'numpy'\n else:\n sde_rhs._backend = 'numba' # type: ignore\n return sde_rhs\n \n if backend == 'numba':\n sde_rhs = self._make_sde_rhs_numba(state)\n sde_rhs._backend = 'numba' # type: ignore\n \n elif backend == 'numpy':\n state = state.copy()\n \n def sde_rhs(state_data, t: float):\n \"\"\" evaluate the rhs given only a state without the grid \"\"\"\n state.data = state_data\n return (self.evolution_rate(state, t).data,\n self.noise_realization(state, t).data)\n \n sde_rhs._backend = 'numpy' # type: ignore\n \n else:\n raise ValueError(f'Unknown backend `{backend}`')\n \n return sde_rhs\n \n\n def solve(self, state: FieldBase,\n t_range: \"TRangeType\",\n dt: float = None,\n tracker: TrackerCollectionDataType = ['progress', 'consistency'],\n method: str = 'auto',\n **kwargs):\n \"\"\" convenience method for solving the partial differential equation \n \n The method constructs a suitable solver\n (:class:`~pde.solvers.base.SolverBase`) and controller\n (:class:`~pde.controller.Controller`) to advance the state over the\n temporal range specified by `t_range`. To obtain full flexibility, it is\n advisable to construct these classes explicitly. \n\n Args:\n state (:class:`~pde.fields.base.FieldBase`):\n The initial state (which also defines the grid)\n t_range (float or tuple):\n Sets the time range for which the PDE is solved. If only a\n single value `t_end` is given, the time range is assumed to be \n `[0, t_end]`.\n dt (float):\n Time step of the chosen stepping scheme. If `None`, a default\n value based on the stepper will be chosen.\n tracker:\n Defines a tracker that process the state of the simulation at\n fixed time intervals. Multiple trackers can be specified as a\n list. The default value is ['progress', 'consistency'], which\n displays a progress bar and checks the state for consistency,\n aborting the simulation when not-a-number values appear.\n method (:class:`~pde.solvers.base.SolverBase` or str):\n Specifies a method for solving the differential equation. This\n can either be an instance of\n :class:`~pde.solvers.base.SolverBase` or a descriptive name\n like 'explicit' or 'scipy'. The valid names are given by\n :meth:`pde.solvers.base.SolverBase.registered_solvers`.\n **kwargs:\n Additional keyword arguments are forwarded to the solver class\n \n Returns:\n :class:`~pde.fields.base.FieldBase`:\n The state at the final time point.\n \"\"\"\n from ..solvers.base import SolverBase\n \n if method == 'auto':\n method = 'scipy' if dt is None else 'explicit'\n \n # create solver\n if callable(method):\n solver = method(pde=self, **kwargs)\n if not isinstance(solver, SolverBase):\n self._logger.warn('Solver is not an instance of `SolverBase`. '\n 'Specified wrong method?')\n else:\n solver = SolverBase.from_name(method, pde=self, **kwargs)\n \n # create controller\n from ..solvers import Controller\n controller = Controller(solver, t_range=t_range, tracker=tracker)\n \n # run the simulation\n return controller.run(state, dt)\n ", "meta": {"hexsha": "9cf1ac5b1fae6171c9a2c5dc4a00496021f9c523", "size": 11150, "ext": "py", "lang": "Python", "max_stars_repo_path": "pde/pdes/base.py", "max_stars_repo_name": "xuanxu/py-pde", "max_stars_repo_head_hexsha": "de33d938aea8680eff872ae1b64569895662a248", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pde/pdes/base.py", "max_issues_repo_name": "xuanxu/py-pde", "max_issues_repo_head_hexsha": "de33d938aea8680eff872ae1b64569895662a248", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pde/pdes/base.py", "max_forks_repo_name": "xuanxu/py-pde", "max_forks_repo_head_hexsha": "de33d938aea8680eff872ae1b64569895662a248", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.7152777778, "max_line_length": 86, "alphanum_fraction": 0.5658295964, "include": true, "reason": "import numpy", "num_tokens": 2222, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792043, "lm_q2_score": 0.39233683016710835, "lm_q1q2_score": 0.19923329715255286}} {"text": "##############################################################################\n# Copyright 2016-2017 Rigetti Computing\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n##############################################################################\n\nimport pyquil.api as api\nimport pyquil.quil as pq\nimport numpy as np\nfrom collections import Counter\nfrom pyquil.gates import STANDARD_GATES, RX, RY\nfrom pyquil.paulis import PauliTerm, PauliSum\nimport funcsigs\n\n\nclass OptResults(dict):\n \"\"\"\n Object for holding optimization results from VQE.\n \"\"\"\n def __getattr__(self, name):\n try:\n return self[name]\n except KeyError:\n raise AttributeError(name)\n\n __setattr__ = dict.__setitem__\n __delattr__ = dict.__delitem__\n\n\nclass VQE(object):\n \"\"\"\n The Variational-Quantum-Eigensolver algorithm\n\n VQE is an object that encapsulates the VQE algorithm (functional\n minimization). The main components of the VQE algorithm are a minimizer\n function for performing the functional minimization, a function that takes a\n vector of parameters and returns a pyQuil program, and a\n Hamiltonian of which to calculate the expectation value.\n\n Using this object:\n\n 1) initialize with `inst = VQE(minimizer)` where `minimizer` is a\n function that performs a gradient free minization--i.e\n scipy.optimize.minimize(. , ., method='Nelder-Mead')\n\n 2) call `inst.vqe_run(variational_state_evolve, hamiltonian,\n initial_parameters)`. Returns the optimal parameters and minimum\n expecation\n\n :param minimizer: function that minimizes objective f(obj, param). For\n example the function scipy.optimize.minimize() needs\n at least two parameters, the objective and an initial\n point for the optimization. The args for minimizer\n are the cost function (provided by this class),\n initial parameters (passed to vqe_run() method, and\n jacobian (defaulted to None). kwargs can be passed\n in below.\n :param minimizer_args: (list) arguments for minimizer function. Default=None\n :param minimizer_kwargs: (dict) arguments for keyword args.\n Default=None\n\n \"\"\"\n\n def __init__(self, minimizer, minimizer_args=[], minimizer_kwargs={}):\n self.minimizer = minimizer\n self.minimizer_args = minimizer_args\n self.minimizer_kwargs = minimizer_kwargs\n self.n_qubits = None\n\n def vqe_run(self, variational_state_evolve, hamiltonian, initial_params,\n gate_noise=None, measurement_noise=None,\n jacobian=None, qvm=None, disp=None, samples=None, return_all=False):\n \"\"\"\n functional minimization loop.\n\n :param variational_state_evolve: function that takes a set of parameters\n and returns a pyQuil program.\n :param hamiltonian: (PauliSum) object representing the hamiltonian of\n which to take the expectation value.\n :param initial_params: (ndarray) vector of initial parameters for the\n optimization\n :param gate_noise: list of Px, Py, Pz probabilities of gate being\n applied to every gate after each get application\n :param measurement_noise: list of Px', Py', Pz' probabilities of a X, Y\n or Z being applied before a measurement.\n :param jacobian: (optional) method of generating jacobian for parameters\n (Default=None).\n :param qvm: (optional, QVM) forest connection object.\n :param disp: (optional, bool) display level. If True then each iteration\n expectation and parameters are printed at each\n optimization iteration.\n :param samples: (int) Number of samples for calculating the expectation\n value of the operators. If `None` then faster method\n ,dotting the wave function with the operator, is used.\n Default=None.\n :param return_all: (optional, bool) request to return all intermediate\n parameters determined during the optimization.\n :return: (vqe.OptResult()) object :func:`OptResult `.\n The following fields are initialized in OptResult:\n -x: set of w.f. ansatz parameters\n -fun: scalar value of the objective function\n\n -iteration_params: a list of all intermediate parameter vectors. Only\n returned if 'return_all=True' is set as a vqe_run()\n option.\n\n -expectation_vals: a list of all intermediate expectation values. Only\n returned if 'return_all=True' is set as a\n vqe_run() option.\n \"\"\"\n self._disp_fun = disp if disp is not None else lambda x: None\n iteration_params = []\n expectation_vals = []\n self._current_expectation = None\n if samples is None:\n print(\"\"\"WARNING: Fast method for expectation will be used. Noise\n models will be ineffective\"\"\")\n\n if qvm is None:\n qvm = api.QVMConnection(\n gate_noise=gate_noise,\n measurement_noise=measurement_noise)\n else:\n self.qvm = qvm\n\n def objective_function(params):\n \"\"\"\n closure representing the functional\n\n :param params: (ndarray) vector of parameters for generating the\n the function of the functional.\n :return: (float) expectation value\n \"\"\"\n pyquil_prog = variational_state_evolve(params)\n mean_value = self.expectation(pyquil_prog, hamiltonian, samples, qvm)\n self._current_expectation = mean_value # store for printing\n return mean_value\n\n def print_current_iter(iter_vars):\n self._disp_fun(\"\\tParameters: {} \".format(iter_vars))\n if jacobian is not None:\n grad = jacobian(iter_vars)\n self._disp_fun(\"\\tGrad-L1-Norm: {}\".format(np.max(np.abs(grad))))\n self._disp_fun(\"\\tGrad-L2-Norm: {} \".format(np.linalg.norm(grad)))\n\n self._disp_fun(\"\\tE => {}\".format(self._current_expectation))\n if return_all:\n iteration_params.append(iter_vars)\n expectation_vals.append(self._current_expectation)\n\n # using self.minimizer\n arguments = funcsigs.signature(self.minimizer).parameters.keys()\n\n if disp is not None and 'callback' in arguments:\n self.minimizer_kwargs['callback'] = print_current_iter\n\n args = [objective_function, initial_params]\n args.extend(self.minimizer_args)\n if 'jac' in arguments:\n self.minimizer_kwargs['jac'] = jacobian\n\n result = self.minimizer(*args, **self.minimizer_kwargs)\n\n if hasattr(result, 'status'):\n if result.status != 0:\n self._disp_fun(\"Classical optimization exited with an error index: %i\"\n % result.status)\n\n results = OptResults()\n if hasattr(result, 'x'):\n results.x = result.x\n results.fun = result.fun\n else:\n results.x = result\n\n if return_all:\n results.iteration_params = iteration_params\n results.expectation_vals = expectation_vals\n return results\n\n @staticmethod\n def expectation(pyquil_prog, pauli_sum, samples, qvm):\n \"\"\"\n Computes the expectation value of pauli_sum over the distribution\n generated from pyquil_prog.\n\n :param pyquil_prog: (pyQuil program)\n :param pauli_sum: (PauliSum, ndarray) PauliSum representing the\n operator of which to calculate the expectation value\n or a numpy matrix representing the Hamiltonian\n tensored up to the appropriate size.\n :param samples: (int) number of samples used to calculate the\n expectation value. If samples is None then the expectation\n value is calculated by calculating on the\n QVM. Error models will not work if samples is None.\n\n :param qvm: (qvm connection)\n\n :returns: (float) representing the expectation value of pauli_sum given\n given the distribution generated from quil_prog.\n \"\"\"\n if isinstance(pauli_sum, np.ndarray):\n # debug mode by passing an array\n wf = qvm.wavefunction(pyquil_prog)\n wf = np.reshape(wf.amplitudes, (-1, 1))\n average_exp = np.conj(wf).T.dot(pauli_sum.dot(wf)).real\n return average_exp\n else:\n if not isinstance(pauli_sum, (PauliTerm, PauliSum)):\n raise TypeError(\"pauli_sum variable must be a PauliTerm or\"\n \"PauliSum object\")\n\n if isinstance(pauli_sum, PauliTerm):\n pauli_sum = PauliSum([pauli_sum])\n\n if samples is None:\n operator_progs = []\n operator_coeffs = []\n for p_term in pauli_sum.terms:\n op_prog = pq.Program()\n for qindex, op in p_term:\n op_prog.inst(STANDARD_GATES[op](qindex))\n operator_progs.append(op_prog)\n operator_coeffs.append(p_term.coefficient)\n\n result_overlaps = qvm.expectation(pyquil_prog,\n operator_programs=operator_progs)\n result_overlaps = list(result_overlaps)\n assert len(result_overlaps) == len(operator_progs), \"\"\"Somehow we\n didn't get the correct number of results back from the QVM\"\"\"\n expectation = sum(list(map(lambda x: x[0]*x[1],\n zip(result_overlaps, operator_coeffs))))\n return expectation.real\n else:\n if not isinstance(samples, int):\n raise TypeError(\"samples variable must be an integer\")\n if samples <= 0:\n raise ValueError(\"samples variable must be a postive integer\")\n\n # normal execution via fake sampling\n # stores the sum of contributions to the energy from each operator term\n expectation = 0.0\n for j, term in enumerate(pauli_sum.terms):\n meas_basis_change = pq.Program()\n qubits_to_measure = []\n if term.id() == \"\":\n meas_outcome = 1.0\n else:\n for index, gate in term:\n qubits_to_measure.append(index)\n if gate == 'X':\n meas_basis_change.inst(RY(-np.pi / 2, index))\n elif gate == 'Y':\n meas_basis_change.inst(RX(np.pi / 2, index))\n\n meas_outcome = \\\n expectation_from_sampling(pyquil_prog + meas_basis_change,\n qubits_to_measure,\n qvm,\n samples)\n\n expectation += term.coefficient * meas_outcome\n\n return expectation.real\n\n\ndef parity_even_p(state, marked_qubits):\n \"\"\"\n Calculates the parity of elements at indexes in marked_qubits\n\n Parity is relative to the binary representation of the integer state.\n\n :param state: The wavefunction index that corresponds to this state.\n :param marked_qubits: The indexes to be considered in the parity sum.\n :returns: A boolean corresponding to the parity.\n \"\"\"\n assert isinstance(state, int), \"{} is not an integer. Must call \" \\\n \"parity_even_p with an integer \" \\\n \"state.\".format(state)\n mask = 0\n for q in marked_qubits:\n mask |= 1 << q\n return bin(mask & state).count(\"1\") % 2 == 0\n\n\ndef expectation_from_sampling(pyquil_program, marked_qubits, qvm, samples):\n \"\"\"\n Calculation of Z_{i} at marked_qubits\n\n Given a wavefunctions, this calculates the expectation value of the Zi\n operator where i ranges over all the qubits given in marked_qubits.\n\n :param pyquil_program: pyQuil program generating some state\n :param marked_qubits: The qubits within the support of the Z pauli\n operator whose expectation value is being calculated\n :param qvm: A QVM connection.\n :param samples: Number of bitstrings collected to calculate expectation\n from sampling.\n :returns: The expectation value as a float.\n \"\"\"\n # construct program to measure\n for qindex in marked_qubits:\n pyquil_program.measure(qindex, qindex)\n\n bitstring_samples = qvm.run(pyquil_program, range(max(marked_qubits) + 1), trials=samples)\n bitstring_tuples = list(map(tuple, bitstring_samples))\n\n freq = Counter(bitstring_tuples)\n\n # perform weighted average\n expectation = 0\n for bitstring, count in freq.items():\n bitstring_int = int(\"\".join([str(x) for x in bitstring[::-1]]), 2)\n if parity_even_p(bitstring_int, marked_qubits):\n expectation += float(count)/samples\n else:\n expectation -= float(count)/samples\n return expectation\n", "meta": {"hexsha": "c490beca5d9b530d7502b987dabd095a2cad32a2", "size": 14455, "ext": "py", "lang": "Python", "max_stars_repo_path": "grove/pyvqe/vqe.py", "max_stars_repo_name": "msohaibalam/grove", "max_stars_repo_head_hexsha": "8c27a5d12923d6ace57956db6a249e8d01e33f35", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-07-15T15:40:49.000Z", "max_stars_repo_stars_event_max_datetime": "2020-07-15T15:40:49.000Z", "max_issues_repo_path": "grove/pyvqe/vqe.py", "max_issues_repo_name": "msohaibalam/grove", "max_issues_repo_head_hexsha": "8c27a5d12923d6ace57956db6a249e8d01e33f35", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "grove/pyvqe/vqe.py", "max_forks_repo_name": "msohaibalam/grove", "max_forks_repo_head_hexsha": "8c27a5d12923d6ace57956db6a249e8d01e33f35", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-11-27T16:20:00.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-27T16:20:00.000Z", "avg_line_length": 43.9361702128, "max_line_length": 94, "alphanum_fraction": 0.5834659287, "include": true, "reason": "import numpy", "num_tokens": 2858, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792043, "lm_q2_score": 0.39233683016710835, "lm_q1q2_score": 0.19923329715255286}} {"text": "import collections\nimport logging\nimport random\nfrom dataclasses import dataclass\nfrom typing import Any, List, Tuple, cast\n\nimport numpy as np\nimport tensorflow as tf\nimport tensorflow.keras as keras\nfrom srl.base.define import RLObservationType\nfrom srl.base.env.base import EnvRun\nfrom srl.base.rl.algorithms.discrete_action import DiscreteActionConfig, DiscreteActionWorker\nfrom srl.base.rl.base import RLParameter, RLTrainer\nfrom srl.base.rl.registration import register\nfrom srl.base.rl.remote_memory import PriorityExperienceReplay\nfrom srl.rl.functions.common import (\n create_beta_list,\n create_epsilon_list,\n create_gamma_list,\n inverse_rescaling,\n render_discrete_action,\n rescaling,\n)\nfrom srl.rl.functions.dueling_network import create_dueling_network_layers\nfrom srl.rl.functions.model import ImageLayerType, create_input_layers\nfrom tensorflow.keras import layers as kl\n\nlogger = logging.getLogger(__name__)\n\n\"\"\"\nDQN\n window_length : o (config selection)\n Target Network : o\n Huber loss function : o\n Delay update Target Network: o\n Experience Replay : o\n Frame skip : -\n Annealing e-greedy : x\n Reward clip : x\n Image preprocessor : -\nRainbow\n Double DQN : o (config selection)\n Priority Experience Reply: o (config selection)\n Dueling Network : o (config selection)\n Multi-Step learning : x\n Noisy Network : x\n Categorical DQN : x\nRecurrent Replay Distributed DQN(R2D2)\n LSTM : x\n Value function rescaling : o\nNever Give Up(NGU)\n Intrinsic Reward : o\n UVFA : TODO\n Retrace : x\nAgent57\n Meta controller(sliding-window UCB) : o\n Intrinsic Reward split : o\nOther\n invalid_actions : TODO\n\"\"\"\n\n\n# ------------------------------------------------------\n# config\n# ------------------------------------------------------\n@dataclass\nclass Config(DiscreteActionConfig):\n\n # test\n test_epsilon: float = 0\n test_beta: float = 0\n\n # model\n window_length: int = 1\n hidden_layer_sizes: Tuple[int, ...] = (512,)\n activation: str = \"relu\"\n image_layer_type: ImageLayerType = ImageLayerType.DQN\n batch_size: int = 32\n q_ext_lr: float = 0.001\n q_int_lr: float = 0.001\n target_model_update_interval: int = 100\n\n # double dqn\n enable_double_dqn: bool = True\n\n # DuelingNetwork\n enable_dueling_network: bool = True\n dueling_network_type: str = \"average\"\n\n # Priority Experience Replay\n capacity: int = 100_000\n memory_name: str = \"RankBaseMemory\"\n memory_warmup_size: int = 1000\n memory_alpha: float = 0.6\n memory_beta_initial: float = 0.4\n memory_beta_steps: int = 1_000_000\n\n # ucb(160,0.5 or 3600,0.01)\n actor_num: int = 32\n ucb_window_size: int = 160 # UCB上限\n ucb_epsilon: float = 0.5 # UCBを使う確率\n ucb_beta: float = 1 # UCBのβ\n\n # episodic\n episodic_lr: float = 0.0005\n episodic_count_max: int = 10 # k\n episodic_epsilon: float = 0.001\n episodic_cluster_distance: float = 0.008\n episodic_memory_capacity: int = 30000\n episodic_pseudo_counts: float = 0.1 # 疑似カウント定数\n\n # lifelong\n lifelong_lr: float = 0.00001\n lifelong_max: float = 5.0 # L\n\n dummy_state_val: float = 0.0\n\n def __post_init__(self):\n super().__init__()\n\n @property\n def observation_type(self) -> RLObservationType:\n return RLObservationType.CONTINUOUS\n\n @staticmethod\n def getName() -> str:\n return \"Agent57_light\"\n\n def assert_params(self) -> None:\n super().assert_params()\n assert self.window_length > 0\n assert self.memory_warmup_size < self.capacity\n assert self.batch_size < self.memory_warmup_size\n assert len(self.hidden_layer_sizes) > 0\n\n\nregister(\n Config,\n __name__ + \":RemoteMemory\",\n __name__ + \":Parameter\",\n __name__ + \":Trainer\",\n __name__ + \":Worker\",\n)\n\n\n# ------------------------------------------------------\n# RemoteMemory\n# ------------------------------------------------------\nclass RemoteMemory(PriorityExperienceReplay):\n def __init__(self, *args):\n super().__init__(*args)\n self.config = cast(Config, self.config)\n\n self.init(\n self.config.memory_name,\n self.config.capacity,\n self.config.memory_alpha,\n self.config.memory_beta_initial,\n self.config.memory_beta_steps,\n )\n\n\n# ------------------------------------------------------\n# network\n# ------------------------------------------------------\nclass _QNetwork(keras.Model):\n def __init__(self, config: Config):\n super().__init__()\n\n in_state, c = create_input_layers(\n config.window_length,\n config.observation_shape,\n config.env_observation_type,\n config.image_layer_type,\n )\n\n for i in range(len(config.hidden_layer_sizes) - 1):\n c = kl.Dense(\n config.hidden_layer_sizes[i],\n activation=config.activation,\n kernel_initializer=\"he_normal\",\n )(c)\n\n if config.enable_dueling_network:\n c = create_dueling_network_layers(\n c,\n config.nb_actions,\n config.hidden_layer_sizes[-1],\n config.dueling_network_type,\n activation=config.activation,\n )\n else:\n c = kl.Dense(config.hidden_layer_sizes[-1], activation=config.activation, kernel_initializer=\"he_normal\")(\n c\n )\n c = kl.Dense(\n config.nb_actions, kernel_initializer=\"truncated_normal\", bias_initializer=\"truncated_normal\"\n )(c)\n\n self.model = keras.Model(in_state, c)\n\n # 重みを初期化\n dummy_state = np.zeros(shape=(1, config.window_length) + config.observation_shape, dtype=np.float32)\n val = self(dummy_state)\n assert val.shape == (1, config.nb_actions)\n\n def call(self, state):\n return self.model(state)\n\n\n# ------------------------------------------------------\n# エピソード記憶部(episodic_reward)\n# ------------------------------------------------------\nclass _EmbeddingNetwork(keras.Model):\n def __init__(self, config: Config):\n super().__init__()\n\n in_state, c = create_input_layers(\n config.window_length,\n config.observation_shape,\n config.env_observation_type,\n config.image_layer_type,\n )\n\n c = kl.Dense(\n 32, activation=\"relu\", kernel_initializer=\"he_normal\", bias_initializer=keras.initializers.constant(0.001)\n )(c)\n self.model = keras.Model(in_state, c)\n\n # out layer\n self.concatenate = kl.Concatenate()\n self.d1 = kl.Dense(128, activation=\"relu\", kernel_initializer=\"he_normal\")\n c = kl.LayerNormalization()(c)\n self.out = kl.Dense(config.nb_actions, activation=\"softmax\")\n\n # 重みを初期化\n dummy_state = np.zeros(shape=(1, config.window_length) + config.observation_shape, dtype=np.float32)\n val = self(dummy_state, dummy_state)\n assert val.shape == (1, config.nb_actions)\n\n def call(self, state1, state2):\n c1 = self.model(state1)\n c2 = self.model(state2)\n c = self.concatenate([c1, c2])\n c = self.d1(c)\n c = self.out(c)\n return c\n\n def predict(self, state):\n return self.model(state)\n\n\n# ------------------------------------------------------\n# 生涯記憶部(life long novelty module)\n# ------------------------------------------------------\nclass _LifelongNetwork(keras.Model):\n def __init__(self, config: Config):\n super().__init__()\n\n in_state, c = create_input_layers(\n config.window_length,\n config.observation_shape,\n config.env_observation_type,\n config.image_layer_type,\n )\n\n c = kl.Dense(\n 128,\n activation=\"relu\",\n kernel_initializer=\"he_normal\",\n bias_initializer=\"he_normal\",\n )(c)\n c = kl.LayerNormalization()(c)\n self.model = keras.Model(in_state, c)\n\n # 重みを初期化\n dummy_state = np.zeros(shape=(1, config.window_length) + config.observation_shape, dtype=np.float32)\n val = self(dummy_state)\n assert val.shape == (1, 128)\n\n def call(self, state):\n return self.model(state)\n\n\n# ------------------------------------------------------\n# Parameter\n# ------------------------------------------------------\nclass Parameter(RLParameter):\n def __init__(self, *args):\n super().__init__(*args)\n self.config = cast(Config, self.config)\n\n self.q_ext_online = _QNetwork(self.config)\n self.q_ext_target = _QNetwork(self.config)\n self.q_int_online = _QNetwork(self.config)\n self.q_int_target = _QNetwork(self.config)\n self.emb_network = _EmbeddingNetwork(self.config)\n self.lifelong_target = _LifelongNetwork(self.config)\n self.lifelong_train = _LifelongNetwork(self.config)\n\n def restore(self, data: Any) -> None:\n self.q_ext_online.set_weights(data[0])\n self.q_ext_target.set_weights(data[0])\n self.q_int_online.set_weights(data[1])\n self.q_int_target.set_weights(data[1])\n self.emb_network.set_weights(data[2])\n self.lifelong_target.set_weights(data[3])\n self.lifelong_train.set_weights(data[4])\n\n def backup(self):\n d = [\n self.q_ext_online.get_weights(),\n self.q_int_online.get_weights(),\n self.emb_network.get_weights(),\n self.lifelong_target.get_weights(),\n self.lifelong_train.get_weights(),\n ]\n return d\n\n def summary(self):\n self.q_ext_online.model.summary()\n self.emb_network.summary()\n self.lifelong_target.model.summary()\n\n # ---------------------------------\n\n def calc_target_q(\n self,\n q_online,\n q_target,\n rewards,\n n_states,\n done_list,\n gamma_list,\n ):\n n_q = q_online(n_states).numpy()\n n_q_target = q_target(n_states).numpy()\n\n target_q = np.zeros(len(rewards))\n for i in range(len(rewards)):\n if done_list[i]:\n gain = rewards[i]\n else:\n # DoubleDQN: indexはonlineQから選び、値はtargetQを選ぶ\n if self.config.enable_double_dqn:\n n_act_idx = np.argmax(n_q[i])\n else:\n n_act_idx = np.argmax(n_q_target[i])\n maxq = n_q_target[i][n_act_idx]\n gain = rewards[i] + gamma_list[i] * inverse_rescaling(maxq)\n gain = rescaling(gain)\n target_q[i] = gain\n\n return target_q\n\n\n# ------------------------------------------------------\n# Trainer\n# ------------------------------------------------------\nclass Trainer(RLTrainer):\n def __init__(self, *args):\n super().__init__(*args)\n self.config = cast(Config, self.config)\n self.parameter = cast(Parameter, self.parameter)\n self.remote_memory = cast(RemoteMemory, self.remote_memory)\n\n self.q_ext_optimizer = keras.optimizers.Adam(learning_rate=self.config.q_ext_lr)\n self.q_int_optimizer = keras.optimizers.Adam(learning_rate=self.config.q_int_lr)\n self.q_loss = keras.losses.Huber()\n\n self.emb_optimizer = keras.optimizers.Adam(learning_rate=self.config.episodic_lr)\n self.emb_loss = keras.losses.MeanSquaredError()\n\n self.lifelong_optimizer = keras.optimizers.Adam(learning_rate=self.config.lifelong_lr)\n self.lifelong_loss = keras.losses.MeanSquaredError()\n\n self.beta_list = create_beta_list(self.config.actor_num)\n self.gamma_list = create_gamma_list(self.config.actor_num)\n self.epsilon_list = create_epsilon_list(self.config.actor_num)\n\n self.train_count = 0\n\n def get_train_count(self):\n return self.train_count\n\n def train(self):\n\n if self.remote_memory.length() < self.config.memory_warmup_size:\n return {}\n\n indices, batchs, weights = self.remote_memory.sample(self.train_count, self.config.batch_size)\n td_error, info = self._train_on_batchs(batchs, weights)\n priorities = abs(td_error) + 0.0001\n self.remote_memory.update(indices, batchs, priorities)\n\n # targetと同期\n if self.train_count % self.config.target_model_update_interval == 0:\n self.parameter.q_ext_target.set_weights(self.parameter.q_ext_online.get_weights())\n self.parameter.q_int_target.set_weights(self.parameter.q_int_online.get_weights())\n\n self.train_count += 1\n info[\"priority\"] = np.mean(priorities)\n return info\n\n def _train_on_batchs(self, batchs, weights):\n\n # データ形式を変形\n states = []\n actions = []\n n_states = []\n rewards_ext = []\n rewards_int = []\n done_list = []\n gamma_list = []\n beta_list = []\n for b in batchs:\n states.append(b[\"states\"][:-1])\n actions.append(b[\"action\"])\n n_states.append(b[\"states\"][1:])\n rewards_ext.append(b[\"reward_ext\"])\n rewards_int.append(b[\"reward_int\"])\n done_list.append(b[\"done\"])\n gamma_list.append(self.gamma_list[b[\"actor\"]])\n beta_list.append(self.beta_list[b[\"actor\"]])\n\n states = np.asarray(states)\n n_states = np.asarray(n_states)\n rewards_ext = np.asarray(rewards_ext)\n rewards_int = np.asarray(rewards_int)\n\n actions_onehot = tf.one_hot(actions, self.config.nb_actions)\n\n # ----------------------------------------\n # Q network\n # ----------------------------------------\n _params = [\n states,\n n_states,\n actions_onehot,\n done_list,\n weights,\n gamma_list,\n ]\n td_error_ext, loss_ext = self._update_q(\n self.parameter.q_ext_online,\n self.parameter.q_ext_target,\n self.q_ext_optimizer,\n rewards_ext,\n *_params,\n )\n td_error_int, loss_int = self._update_q(\n self.parameter.q_int_online,\n self.parameter.q_int_target,\n self.q_int_optimizer,\n rewards_int,\n *_params,\n )\n td_errors = td_error_ext\n # td_errors = td_error_ext + beta_list * td_error_int\n\n # ----------------------------------------\n # embedding network\n # ----------------------------------------\n with tf.GradientTape() as tape:\n actions_probs = self.parameter.emb_network(states, n_states)\n emb_loss = self.emb_loss(actions_probs, actions_onehot)\n\n grads = tape.gradient(emb_loss, self.parameter.emb_network.trainable_variables)\n self.emb_optimizer.apply_gradients(zip(grads, self.parameter.emb_network.trainable_variables))\n\n # ----------------------------------------\n # lifelong network\n # ----------------------------------------\n lifelong_target_val = self.parameter.lifelong_target(states)\n with tf.GradientTape() as tape:\n lifelong_train_val = self.parameter.lifelong_train(states)\n lifelong_loss = self.lifelong_loss(lifelong_target_val, lifelong_train_val)\n\n grads = tape.gradient(lifelong_loss, self.parameter.lifelong_train.trainable_variables)\n self.lifelong_optimizer.apply_gradients(zip(grads, self.parameter.lifelong_train.trainable_variables))\n\n return td_errors, {\n \"loss_ext\": loss_ext,\n \"loss_int\": loss_int,\n \"emb_loss\": emb_loss.numpy(),\n \"lifelong_loss\": lifelong_loss.numpy(),\n }\n\n def _update_q(\n self,\n q_online,\n q_target,\n optimizer,\n rewards,\n #\n states,\n n_states,\n actions_onehot,\n done_list,\n weights,\n gamma_list,\n ):\n target_q = self.parameter.calc_target_q(\n q_online,\n q_target,\n rewards,\n n_states,\n done_list,\n gamma_list,\n )\n\n with tf.GradientTape() as tape:\n q = q_online(states)\n q = tf.reduce_sum(q * actions_onehot, axis=1)\n loss = self.q_loss(target_q * weights, q * weights)\n\n grads = tape.gradient(loss, q_online.trainable_variables)\n optimizer.apply_gradients(zip(grads, q_online.trainable_variables))\n\n td_error = (target_q - q).numpy()\n loss = loss.numpy()\n\n return td_error, loss\n\n\n# ------------------------------------------------------\n# Worker\n# ------------------------------------------------------\nclass Worker(DiscreteActionWorker):\n def __init__(self, *args):\n super().__init__(*args)\n self.config = cast(Config, self.config)\n self.parameter = cast(Parameter, self.parameter)\n self.remote_memory = cast(RemoteMemory, self.remote_memory)\n\n self.dummy_state = np.full(self.config.observation_shape, self.config.dummy_state_val, dtype=np.float32)\n\n # actor\n self.beta_list = create_beta_list(self.config.actor_num)\n self.epsilon_list = create_epsilon_list(self.config.actor_num)\n self.gamma_list = create_gamma_list(self.config.actor_num)\n\n # ucb\n self.actor_index = -1\n self.ucb_recent = []\n self.ucb_actors_count = [1 for _ in range(self.config.actor_num)] # 1回は保証\n self.ucb_actors_reward = [0.0 for _ in range(self.config.actor_num)]\n\n def call_on_reset(self, state: np.ndarray, invalid_actions: List[int]) -> None:\n if self.training:\n # エピソード毎に actor を決める\n self.actor_index = self._calc_actor_index()\n self.beta = self.beta_list[self.actor_index]\n self.epsilon = self.epsilon_list[self.actor_index]\n self.gamma = self.gamma_list[self.actor_index]\n\n else:\n self.epsilon = self.config.test_epsilon\n self.beta = self.config.test_beta\n\n self.recent_states = [self.dummy_state for _ in range(self.config.window_length + 1)]\n self.recent_states.pop(0)\n self.recent_states.append(state)\n self.invalid_actions = invalid_actions\n\n # Q値取得用\n self.onehot_actor_idx = tf.one_hot(np.array(self.actor_index), self.config.actor_num)[np.newaxis, ...]\n\n # sliding-window UCB 用に報酬を保存\n self.episode_reward = 0.0\n\n # エピソードメモリ(エピソード毎に初期化)\n self.episodic_memory = collections.deque(maxlen=self.config.episodic_memory_capacity)\n\n # (sliding-window UCB)\n def _calc_actor_index(self) -> int:\n\n # UCB計算用に保存\n if self.actor_index != -1:\n self.ucb_recent.append(\n (\n self.actor_index,\n self.episode_reward,\n )\n )\n self.ucb_actors_count[self.actor_index] += 1\n self.ucb_actors_reward[self.actor_index] += self.episode_reward\n if len(self.ucb_recent) >= self.config.ucb_window_size:\n d = self.ucb_recent.pop(0)\n self.ucb_actors_count[d[0]] -= 1\n self.ucb_actors_reward[d[0]] -= d[1]\n\n N = len(self.ucb_recent)\n\n # 全て１回は実行\n if N < self.config.actor_num:\n return N\n\n # ランダムでactorを決定\n if random.random() < self.config.ucb_epsilon:\n return random.randint(0, self.config.actor_num - 1)\n\n # UCB値を計算\n ucbs = []\n for i in range(self.config.actor_num):\n n = self.ucb_actors_count[i]\n u = self.ucb_actors_reward[i] / n\n ucb = u + self.config.ucb_beta * np.sqrt(np.log(N) / n)\n ucbs.append(ucb)\n\n # UCB値最大のポリシー（複数あればランダム）\n return random.choice(np.where(ucbs == np.max(ucbs))[0])\n\n def call_policy(self, _state: np.ndarray, invalid_actions: List[int]) -> int:\n state = np.asarray([self.recent_states[1:]])\n\n q_ext = self.parameter.q_ext_online(state)[0].numpy()\n q_int = self.parameter.q_int_online(state)[0].numpy()\n q = q_ext + self.beta * q_int\n\n if random.random() < self.epsilon:\n self.action = random.choice([a for a in range(self.config.nb_actions) if a not in invalid_actions])\n else:\n # valid actions以外は -inf にする\n q = [(-np.inf if a in invalid_actions else v) for a, v in enumerate(q)]\n\n # 最大値を選ぶ（複数はほぼないので無視）\n self.action = int(np.argmax(q))\n\n self.q_ext = q_ext[self.action]\n self.q = q[self.action]\n return self.action\n\n def call_on_step(\n self,\n next_state: np.ndarray,\n reward_ext: float,\n done: bool,\n next_invalid_actions: List[int],\n ):\n self.episode_reward += reward_ext\n\n self.recent_states.pop(0)\n self.recent_states.append(next_state)\n self.invalid_actions = next_invalid_actions\n\n # 内部報酬\n n_s = np.asarray([self.recent_states[1:]])\n episodic_reward = self._calc_episodic_reward(n_s)\n lifelong_reward = self._calc_lifelong_reward(n_s)\n reward_int = episodic_reward * lifelong_reward\n\n _info = {\n \"episodic\": episodic_reward,\n \"lifelong\": lifelong_reward,\n \"reward_int\": reward_int,\n }\n if not self.training:\n return _info\n\n batch = {\n \"states\": self.recent_states[:],\n \"action\": self.action,\n \"reward_ext\": reward_ext,\n \"reward_int\": reward_int,\n \"done\": done,\n \"actor\": self.actor_index,\n \"next_invalid_actions\": next_invalid_actions,\n }\n\n # priority\n if self.config.memory_name == \"ReplayMemory\":\n priority = 0\n elif not self.distributed:\n priority = 0\n else:\n _params = [\n n_s,\n [done],\n [self.gamma],\n ]\n target_q_ext = self.parameter.calc_target_q(\n self.parameter.q_ext_online,\n self.parameter.q_ext_target,\n [reward_ext],\n *_params,\n )\n if True:\n priority = abs(target_q_ext - self.q_ext) + 0.0001\n else:\n target_q_int = self.parameter.calc_target_q(\n self.parameter.q_int_online,\n self.parameter.q_int_target,\n [reward_int],\n *_params,\n )\n priority = abs((target_q_ext + self.beta * target_q_int) - self.q) + 0.0001\n\n self.remote_memory.add(batch, priority)\n\n _info[\"priority\"] = priority\n return _info\n\n def _calc_episodic_reward(self, state):\n k = self.config.episodic_count_max\n epsilon = self.config.episodic_epsilon\n cluster_distance = self.config.episodic_cluster_distance\n c = self.config.episodic_pseudo_counts\n\n # 埋め込み関数から制御可能状態を取得\n cont_state = self.parameter.emb_network.predict(state)[0].numpy()\n\n # 初回\n if len(self.episodic_memory) == 0:\n self.episodic_memory.append(cont_state)\n return 1 / c\n\n # エピソードメモリ内の全要素とユークリッド距離を求める\n euclidean_list = [np.linalg.norm(m - cont_state, ord=2) for m in self.episodic_memory]\n\n # エピソードメモリに制御可能状態を追加\n self.episodic_memory.append(cont_state)\n\n # 近いk個を対象\n euclidean_list = np.sort(euclidean_list)[:k]\n\n # 上位k個の移動平均を出す\n mode_ave = np.mean(euclidean_list)\n if mode_ave == 0.0:\n # ユークリッド距離は正なので平均0は全要素0のみ\n dn = euclidean_list\n else:\n dn = euclidean_list / mode_ave # 正規化\n\n # 一定距離以下を同じ状態とする\n dn = np.maximum(dn - cluster_distance, 0)\n\n # 訪問回数を計算(Dirac delta function の近似)\n dn = epsilon / (dn + epsilon)\n N = np.sum(dn)\n\n # 報酬の計算\n reward = 1 / (np.sqrt(N) + c)\n return reward\n\n def _calc_lifelong_reward(self, state):\n # RND取得\n rnd_target_val = self.parameter.lifelong_target(state)[0]\n rnd_train_val = self.parameter.lifelong_train(state)[0]\n\n # MSE\n error = np.square(rnd_target_val - rnd_train_val).mean()\n reward = 1 + error\n\n if reward < 1:\n reward = 1\n if reward > self.config.lifelong_max:\n reward = self.config.lifelong_max\n\n return reward\n\n def call_render(self, env: EnvRun) -> None:\n state = np.asarray([self.recent_states[1:]])\n q_ext = self.parameter.q_ext_online(state)[0].numpy()\n q_int = self.parameter.q_int_online(state)[0].numpy()\n q = q_ext + self.beta * q_int\n invalid_actions = self.get_invalid_actions(env)\n\n maxa = np.argmax(q)\n\n def _render_sub(a: int) -> str:\n return f\"{q[a]:5.3f} = {q_ext[a]:5.3f} + {self.beta} * {q_int[a]:5.3f}\"\n\n render_discrete_action(invalid_actions, maxa, env, _render_sub)\n", "meta": {"hexsha": "f014cfcd5d40e79af7426edcf87e88a7a0709041", "size": 25155, "ext": "py", "lang": "Python", "max_stars_repo_path": "srl/rl/agent57_light.py", "max_stars_repo_name": "pocokhc/simple_rl", "max_stars_repo_head_hexsha": "765f12f392f87e6897027905d74f1bced6a2b7bf", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-03-01T09:16:57.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-01T09:16:57.000Z", "max_issues_repo_path": "srl/rl/agent57_light.py", "max_issues_repo_name": "pocokhc/simple_rl", "max_issues_repo_head_hexsha": "765f12f392f87e6897027905d74f1bced6a2b7bf", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "srl/rl/agent57_light.py", "max_forks_repo_name": "pocokhc/simple_rl", "max_forks_repo_head_hexsha": "765f12f392f87e6897027905d74f1bced6a2b7bf", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.4580645161, "max_line_length": 118, "alphanum_fraction": 0.5783740807, "include": true, "reason": "import numpy", "num_tokens": 5898, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792043, "lm_q2_score": 0.39233683016710835, "lm_q1q2_score": 0.19923329715255286}} {"text": "#!/usr/bin/env python\n\n__author__ = \"Geoffroy Hautier, Bharat Medasani, Danny Broberg\"\n__copyright__ = \"Copyright 2014, The Materials Project\"\n__version__ = \"1.0\"\n__maintainer__ = \"Geoffroy Hautier, Bharat Medasani\"\n__email__ = \"geoffroy@uclouvain.be, mbkumar@gmail.com\"\n__status__ = \"Development\"\n__date__ = \"November 4, 2012\"\n\nfrom math import sqrt, pi, exp\nfrom collections import defaultdict \nfrom itertools import combinations\n\nimport os\nimport numpy as np\n\nfrom pymatgen.core import Element\nfrom pymatgen.core.structure import PeriodicSite, Structure\nfrom pymatgen.entries.computed_entries import ComputedStructureEntry\nfrom pymatgen.symmetry.analyzer import SpacegroupAnalyzer\n\nfrom pycdt.corrections.finite_size_charge_correction import get_correction_freysoldt, get_correction_kumagai\nfrom pycdt.utils.parse_calculations import SingleDefectParser\nfrom pycdt.utils.units import kb, conv, hbar\n\nimport warnings\nwarnings.simplefilter('default')\n\n\ndef freysoldt_correction_from_paths( defect_file_path, bulk_file_path, dielectric,\n defect_charge, plot=False):\n \"\"\"\n A function for performing the Freysoldt correction with a set of file paths.\n If this correction is used, please reference Freysoldt's original paper.\n doi: 10.1103/PhysRevLett.102.016402\n\n Does not require transformation.json file to exist in file path.\n\n :param defect_file_path (str): file path to defect folder of interest\n :param bulk_file_path (str): file path to bulk folder of interest\n :param dielectric (float or 3x3 matrix): Dielectric constant (or tensor) for the structure\n :param defect_charge (int): charge of defect structure of interest\n :param plot (bool): allow for plotting electrostatic potential\n :return:\n Dictionary of Freysoldt Correction for defect\n \"\"\"\n sdp = SingleDefectParser.from_paths( defect_file_path, bulk_file_path, dielectric, defect_charge)\n _ = sdp.freysoldt_loader()\n plt_title = os.path.join( defect_file_path,\n \"{}_chg_{}\".format(sdp.defect_entry.name, defect_charge)) if plot else None\n correction = get_correction_freysoldt(sdp.defect_entry,\n dielectric,\n title=plt_title)\n\n return correction\n\ndef kumagai_correction_from_paths( defect_file_path, bulk_file_path, dielectric,\n defect_charge, plot=False):\n \"\"\"\n A function for performing the Kumagai correction with a set of file paths.\n If this correction is used, please reference Kumagai and Oba's original paper\n (doi: 10.1103/PhysRevB.89.195205) as well as Freysoldt's original\n paper (doi: 10.1103/PhysRevLett.102.016402\n\n Does not require transformation.json file to exist in file path.\n\n :param defect_file_path (str): file path to defect folder of interest\n :param bulk_file_path (str): file path to bulk folder of interest\n :param dielectric (float or 3x3 matrix): Dielectric constant (or tensor) for the structure\n :param defect_charge (int): charge of defect structure of interest\n :param plot (bool): allow for plotting electrostatic potential\n :return:\n Dictionary of Kumagai Correction for defect\n \"\"\"\n sdp = SingleDefectParser.from_paths( defect_file_path, bulk_file_path, dielectric, defect_charge)\n _ = sdp.kumagai_loader()\n plt_title = os.path.join( defect_file_path,\n \"{}_chg_{}\".format(sdp.defect_entry.name, defect_charge)) if plot else None\n correction = get_correction_kumagai(sdp.defect_entry,\n dielectric,\n title=plt_title)\n\n return correction\n\n\n\nwarnings.warn(\"Replaced PyCDT usage of ComputedDefect objects with \"\n \"DefectEntry objects from pymatgen.analysis.defects.core\\n\"\n \"Will remove ComputedDefect with Version 2.5 of PyCDT.\",\n DeprecationWarning)\nclass ComputedDefect(object):\n \"\"\"\n Holds all the info concerning a defect computation: \n composition+structure, energy, correction on energy and name\n \"\"\"\n def __init__(self, entry_defect, site_in_bulk, multiplicity=None,\n supercell_size=(1, 1, 1), charge=0.0,\n charge_correction=0.0, other_correction=0.0, name=None):\n \"\"\"\n Args:\n entry_defect: \n An ComputedStructureEntry object corresponding to the \n defect supercell\n site_in_bulk: \n Site of the defect in bulk supercell. Defect positions\n are often required to perform posteriori corrections\n multiplicity:\n Multiplicity of defect site in a cell. Useful to \n evaluate defect concentrations\n supercell_size: \n Size of the defect supercell in terms of unit cell\n charge: \n The charge of the defect\n charge_correction: \n Correction to the energy due to charge\n other_correction:\n Correction to the energy due to other factors\n name: \n The name of the defect\n \"\"\"\n\n self.entry = entry_defect\n self.site = site_in_bulk\n self.multiplicity = multiplicity\n self.supercell_size = supercell_size\n self.charge = charge\n self.charge_correction = charge_correction # Can be added after initialization\n self.other_correction = other_correction\n self.name = name\n if self.name:\n self.full_name = self.name + \"_\" + str(charge)\n else:\n self.full_name = \"defect_\" + str(charge)\n\n def as_dict(self):\n return {'entry': self.entry.as_dict(),\n 'site': self.site.as_dict(),\n 'multiplicity': self.multiplicity,\n 'supercell_size': self.supercell_size,\n 'charge': self.charge,\n 'charge_correction': self.charge_correction,\n 'other_correction': self.other_correction,\n 'name': self.name,\n 'full_name': self.full_name,\n '@module': self.__class__.__module__,\n '@class': self.__class__.__name__}\n\n @classmethod\n def from_dict(cls, d):\n return cls(\n ComputedStructureEntry.from_dict(d['entry']), \n PeriodicSite.from_dict(d['site']),\n multiplicity=d.get('multiplicity', None),\n supercell_size=d.get('supercell_size', [1,1,1]),\n charge=d.get('charge', 0.0),\n charge_correction=d.get('charge_correction', 0.0),\n other_correction=d.get('other_correction', 0.0),\n name=d.get('name', None))\n\n\nwarnings.warn(\"Replaced PyCDT usage of DefectsAnalyzer objects with \"\n \"DefectPhaseDiagram objects from pymatgen.analysis.defects.thermodynamics\\n\"\n \"Will remove DefectsAnalyzer with Version 2.5 of PyCDT.\",\n DeprecationWarning)\nclass DefectsAnalyzer(object):\n \"\"\"\n a class aimed at performing standard analysis of defects\n \"\"\"\n def __init__(self, entry_bulk, e_vbm, mu_elts, band_gap):\n \"\"\"\n Args:\n entry_bulk:\n the bulk data as an Entry\n e_vbm:\n the energy of the vbm (in eV)\n mu_elts:\n a dictionnary of {Element:value} giving the chemical\n potential of each element\n band_gap:\n the band gap (in eV)\n \"\"\"\n self._entry_bulk = entry_bulk\n self._e_vbm = e_vbm\n self._mu_elts = mu_elts\n self._band_gap = band_gap\n self._defects = []\n self._formation_energies = []\n\n def as_dict(self):\n d = {'entry_bulk': self._entry_bulk.as_dict(),\n 'e_vbm': self._e_vbm,\n 'mu_elts': {k.symbol:v for k,v in self._mu_elts.items()},\n 'band_gap': self._band_gap,\n 'defects': [d.as_dict() for d in self._defects],\n 'formation_energies': self._formation_energies,\n \"@module\": self.__class__.__module__,\n \"@class\": self.__class__.__name__}\n return d\n\n @classmethod\n def from_dict(cls, d):\n struct = d['entry_bulk']['structure']\n struct = struct if isinstance(struct, Structure) \\\n else Structure.from_dict(struct)\n entry_bulk = ComputedStructureEntry(struct, d['entry_bulk']['energy'])\n analyzer = DefectsAnalyzer(\n entry_bulk, d['e_vbm'], \n {Element(el): d['mu_elts'][el] for el in d['mu_elts']}, d['band_gap'])\n for ddict in d['defects']:\n analyzer.add_computed_defect(ComputedDefect.from_dict(ddict))\n return analyzer\n\n def add_computed_defect(self, defect):\n \"\"\"\n add a parsed defect to the analyzer\n Args:\n defect:\n a ComputedDefect object\n \"\"\"\n self._defects.append(defect)\n self._compute_form_en()\n\n def change_charge_correction(self, i, correction):\n \"\"\"\n Change the charge correction for defect at index i\n Args:\n i:\n Index of defects\n correction:\n New correction to be applied for defect\n \"\"\"\n self._defects[i].charge_correction = correction\n self._compute_form_en()\n\n def change_other_correction(self, i, correction):\n \"\"\"\n Change the charge correction for defect at index i\n Args:\n i:\n Index of defects\n correction:\n New correction to be applied for defect\n \"\"\"\n self._defects[i].other_correction = correction\n self._compute_form_en()\n\n def _get_all_defect_types(self):\n to_return = []\n for d in self._defects:\n if d.name not in to_return: to_return.append(d.name)\n return to_return\n\n def _compute_form_en(self):\n \"\"\"\n compute the formation energies for all defects in the analyzer\n \"\"\"\n self._formation_energies = []\n for d in self._defects:\n #compensate each element in defect with the chemical potential\n mu_needed_coeffs = {}\n for elt in d.entry.composition.elements:\n el_def_comp = d.entry.composition[elt] \n el_blk_comp = self._entry_bulk.composition[elt]\n mu_needed_coeffs[Element(elt)] = el_blk_comp - el_def_comp\n\n sum_mus = 0.0\n for elt in mu_needed_coeffs:\n sum_mus += mu_needed_coeffs[elt] * self._mu_elts[elt]\n\n self._formation_energies.append(\n d.entry.energy - self._entry_bulk.energy + \\\n sum_mus + d.charge*self._e_vbm + \\\n d.charge_correction + d.other_correction)\n\n def correct_bg_simple(self, vbm_correct, cbm_correct):\n \"\"\"\n correct the band gap in the analyzer.\n We assume the defects level remain the same when moving the \n band edges\n Args:\n vbm_correct:\n The correction on the vbm as a positive number. e.g., \n if the VBM goes 0.1 eV down vbm_correct=0.1\n cbm_correct:\n The correction on the cbm as a positive number. e.g., \n if the CBM goes 0.1 eV up cbm_correct=0.1\n\n \"\"\"\n self._band_gap = self._band_gap + cbm_correct + vbm_correct\n self._e_vbm = self._e_vbm - vbm_correct\n self._compute_form_en()\n\n def get_transition_levels(self):\n \"\"\"\n Charge transition levels are computed\n :return: Transition levels for each pair of the defects.\n If any pair is missing, the transition level for that pair is\n not within the band gap.\n \"\"\"\n xlim = (-0.5, self._band_gap+1.5)\n nb_steps = 1000\n x = np.arange(xlim[0], xlim[1], (xlim[1]-xlim[0])/nb_steps)\n \n y = defaultdict(defaultdict)\n for i, dfct in enumerate(self._defects):\n yval = self._formation_energies[i] + dfct.charge*x\n y[dfct.name][dfct.charge] = yval\n\n transit_levels = defaultdict(defaultdict)\n for dfct_name in y:\n q_ys = y[dfct_name]\n for qpair in combinations(q_ys.keys(), 2):\n qpair_s = tuple(sorted(list(qpair)))\n y_absdiff = abs(q_ys[qpair_s[1]] - q_ys[qpair_s[0]])\n if y_absdiff.min() < 0.4:\n transit_levels[dfct_name][qpair_s] = x[np.argmin(y_absdiff)]\n return transit_levels\n\n def _get_form_energy(self, ef, i):\n return self._formation_energies[i] + self._defects[i].charge*ef\n\n def get_formation_energies(self, ef=0.0):\n \"\"\"\n Get the defect formation energies for a given Fermi level\n Args:\n ef:\n the fermi level in eV (with respect to the VBM)\n Returns:\n a list of dict of {'name': defect name, 'charge': defect charge\n 'energy': defect formation energy in eV}\n \"\"\"\n energies = []\n i = 0\n for i, d in enumerate(self._defects):\n energies.append({\n 'name': d.name,\n 'charge': d.charge,\n 'energy': self._get_form_energy(ef, i)\n })\n return energies\n\n def get_defects_concentration(self, temp=300, ef=0.0):\n \"\"\"\n Get the defect concentration for a temperature and Fermi level.\n Note: This method has an approximation and can fail\n [Ref: PRB 86, 144109 (2012)]\n Args:\n temp:\n the temperature in K\n Ef:\n the fermi level in eV (with respect to the VBM)\n Returns:\n A list of dict of {'name': defect name, 'charge': defect charge\n 'conc': defects concentration in m-3}\n \"\"\"\n conc = []\n struct = self._entry_bulk.structure\n for i, d in enumerate(self._defects):\n cell_multiplier = np.prod(d.supercell_size)\n n = d.multiplicity * cell_multiplier * 1e30 / struct.volume\n conc.append({'name': d.name, 'charge': d.charge,\n 'conc': n*exp(\n -self._get_form_energy(ef, i)/(kb*temp))})\n\n return conc\n\n def get_defects_concentration_old(self, temp=300, ef=0.0):\n \"\"\"\n get the defect concentration for a temperature and Fermi level\n Written when the site multiplicity is not supplied with ComputedDefect\n Args:\n temp:\n the temperature in K\n Ef:\n the fermi level in eV (with respect to the VBM)\n Returns:\n a list of dict of {'name': defect name, 'charge': defect charge\n 'conc': defects concentration in m-3}\n \"\"\"\n conc=[]\n spga = SpacegroupAnalyzer(self._entry_bulk.structure, symprec=1e-1)\n struct = spga.get_symmetrized_structure()\n i = 0\n for d in self._defects:\n df_coords = d.site.frac_coords\n target_site=None\n for s in struct.sites:\n sf_coords = s.frac_coords\n if abs(s.frac_coords[0]-df_coords[0]) < 0.1 \\\n and abs(s.frac_coords[1]-df_coords[1]) < 0.1 \\\n and abs(s.frac_coords[2]-df_coords[2]) < 0.1:\n target_site=s\n break\n equiv_site_no = len(struct.find_equivalent_sites(target_site))\n n = equiv_site_no * 1e30 / struct.volume\n conc.append({'name': d.name, 'charge': d.charge,\n 'conc': n*exp(\n -self._get_form_energy(ef, i)/(kb*temp))})\n i += 1\n return conc\n\n def _get_dos(self, e, m1, m2, m3, e_ext):\n return sqrt(2) / (pi**2*hbar**3) * sqrt(m1*m2*m3) * sqrt(e-e_ext)\n\n def _get_dos_fd_elec(self, e, ef, t, m1, m2, m3):\n return conv * (2.0/(exp((e-ef)/(kb*t))+1)) * \\\n (sqrt(2)/(pi**2)) * sqrt(m1*m2*m3) * \\\n sqrt(e-self._band_gap)\n\n def _get_dos_fd_hole(self, e, ef, t, m1, m2, m3):\n return conv * (exp((e-ef)/(kb*t))/(exp((e-ef)/(kb*t))+1)) * \\\n (2.0 * sqrt(2)/(pi**2)) * sqrt(m1*m2*m3) * \\\n sqrt(-e)\n\n def _get_qd(self, ef, t):\n summation = 0.0\n for d in self.get_defects_concentration(t, ef):\n summation += d['charge'] * d['conc']\n return summation\n\n def get_qi(self, ef, t, m_elec, m_hole):\n from scipy import integrate as intgrl\n\n elec_den_fn = lambda e: self._get_dos_fd_elec(\n e, ef, t, m_elec[0], m_elec[1], m_elec[2])\n hole_den_fn = lambda e: self._get_dos_fd_hole(\n e, ef, t, m_hole[0], m_hole[1], m_hole[2])\n\n bg = self._band_gap\n elec_count = -intgrl.quad(elec_den_fn, bg, bg+5)[0]\n hole_count = intgrl.quad(hole_den_fn, -5, 0.0)[0]\n\n return elec_count + hole_count\n\n def _get_qtot(self, ef, t, m_elec, m_hole):\n return self._get_qd(ef, t) + self.get_qi(ef, t, m_elec, m_hole)\n\n def get_eq_ef(self, t, m_elec, m_hole):\n \"\"\"\n access to equilibrium values of Fermi level and concentrations \n in defects and carriers obtained by self-consistent solution of \n charge balance + defect and carriers concentrations\n Args:\n t: temperature in K\n m_elec: electron effective mass as a 3 value list \n (3 eigenvalues for the tensor)\n m_hole:: hole effective mass as a 3 value list \n (3 eigenvalues for the tensor)\n Returns:\n a dict with {\n 'ef':eq fermi level,\n 'Qi': the concentration of carriers\n (positive for holes, negative for e-) in m^-3,\n 'conc': the concentration of defects as a list of dicts\n }\n \"\"\"\n from scipy.optimize import bisect\n e_vbm = self._e_vbm\n e_cbm = self._e_vbm+self._band_gap\n ef = bisect(lambda e:self._get_qtot(e,t,m_elec,m_hole), 0, \n self._band_gap)\n return {'ef': ef, 'Qi': self.get_qi(ef, t, m_elec, m_hole),\n 'QD': self._get_qd(ef,t), \n 'conc': self.get_defects_concentration(t, ef)}\n\n def get_non_eq_ef(self, tsyn, teq, m_elec, m_hole):\n \"\"\"\n access to the non-equilibrium values of Fermi level and \n concentrations in defects and carriers obtained by \n self-consistent solution of charge balance + defect and \n carriers concentrations\n\n Implemented following Sun, R., Chan, M. K. Y., Kang, S., \n and Ceder, G. (2011). doi:10.1103/PhysRevB.84.035212\n\n Args:\n tsyn: the synthesis temperature in K\n teq: the temperature of use in K\n m_elec: electron effective mass as a 3 value list \n (3 eigenvalues for the tensor)\n m_hole: hole effective mass as a 3 value list \n (3 eigenvalues for the tensor)\n Returns:\n a dict with {\n 'ef':eq fermi level,\n 'Qi': the concentration of carriers\n (positive for holes, negative for e-) in m^-3,\n 'conc': the concentration of defects as a list of dict\n }\n \"\"\"\n from scipy.optimize import bisect\n eqsyn = self.get_eq_ef(tsyn, m_elec, m_hole)\n cd = {}\n for c in eqsyn['conc']:\n if c['name'] in cd:\n cd[c['name']] += c['conc']\n else:\n cd[c['name']] = c['conc']\n ef = bisect(lambda e:self._get_non_eq_qtot(cd, e, teq, m_elec, m_hole),\n -1.0, self._band_gap+1.0)\n return {'ef':ef, 'Qi':self.get_qi(ef, teq, m_elec, m_hole),\n 'conc_syn':eqsyn['conc'],\n 'conc':self._get_non_eq_conc(cd, ef, teq)}\n\n def _get_non_eq_qd(self, cd, ef, t):\n sum_tot = 0.0\n for n in cd:\n sum_d = 0.0\n sum_q = 0.0\n i = 0\n for d in self._defects:\n if d.name == n:\n sum_d += exp(-self._get_form_energy(ef, i)/(kb*t))\n sum_q += d.charge * exp(\n -self._get_form_energy(ef, i)/(kb*t))\n i += 1\n sum_tot += cd[n]*sum_q/sum_d\n return sum_tot\n\n def _get_non_eq_conc(self, cd, ef, t):\n sum_tot = 0.0\n res=[]\n for n in cd:\n sum_tot = 0\n i = 0\n for d in self._defects:\n if d.name == n:\n sum_tot += exp(-self._get_form_energy(ef,i)/(kb*t))\n i += 1\n i=0\n for d in self._defects:\n if d.name == n:\n res.append({'name':d.name,'charge':d.charge,\n 'conc':cd[n]*exp(-self._get_form_energy(\n ef,i)/(kb*t))/sum_tot})\n i += 1\n return res\n\n def _get_non_eq_qtot(self, cd, ef, t, m_elec, m_hole):\n return self._get_non_eq_qd(cd, ef, t) + \\\n self.get_qi(ef, t, m_elec, m_hole)\n\n def correct_bg(self, dict_levels, vbm_correct, cbm_correct):\n \"\"\"\n NOTE from developers: This code uses deprecated concepts and\n will not be used or maintained going forward (as of 12/15/2017).\n However, we are keeping function here to allow for\n current users to make use of it...\n\n correct the band gap in the analyzer and make sure the levels move\n accordingly.\n There are two types of defects vbm_like and cbm_like and we need\n to provide a formal oxidation state\n The vbm-like will follow the vbm and the cbm_like the cbm. If nothing\n is specified the defect transition level does not move\n Args:\n dict_levels: a dictionary of type {defect_name:\n {'type':type_of_defect,'q*':formal_ox_state}}\n Where type_of_defect is a string: 'vbm_like' or 'cbm_like'\n \"\"\"\n self._band_gap = self._band_gap + cbm_correct + vbm_correct\n self._e_vbm = self._e_vbm - vbm_correct\n self._compute_form_en()\n for i in range(len(self._defects)):\n name = self._defects[i].name\n if not name in dict_levels:\n continue\n\n if dict_levels[name]['type'] == 'vbm_like':\n z = self._defects[i].charge - dict_levels[name]['q*']\n self._formation_energies[i] += z * vbm_correct\n if dict_levels[name]['type'] == 'cbm_like':\n z = dict_levels[name]['q*'] - self._defects[i].charge\n self._formation_energies[i] += z * cbm_correct\n\n def get_defect_occupancies(self):\n \"\"\"\n NOTE from developers: This code uses deprecated concepts and\n will not be used or maintained going forward (as of 12/15/2017).\n However, we are keeping function here to allow for\n current users to make use of it...\n\n Defect occupancies with respect to defect chargest.\n The assumption is that the highest charge of defect numerically\n has zero occupancy:\n Ex: In Cr2O3, V_O has 0 occupancy for +2 q and 2 occupancy for 0 q.\n V_{Cr} has 0 occupancy for 0 q and 3 occupancy for -3 q\n Caution: Didn't check for semiconductor with large # of defect q's.\n Returns:\n Defect occupancies as a nested dict\n \"\"\"\n charges = defaultdict(list)\n for dfct in self._defects:\n charges[dfct.name].append(dfct.charge)\n\n occupancies = defaultdict(lambda: defaultdict(int))\n for dfct_name in charges:\n for i, q in enumerate(sorted(charges[dfct_name], reverse=True)):\n occupancies[dfct_name][q] = i\n occupancies[dfct_name]['0_occupancy'] = \\\n sorted(charges[dfct_name], reverse=True)[0]\n return occupancies\n", "meta": {"hexsha": "775c5ab0b3655311a7fbb59199654a007e4e92d1", "size": 24259, "ext": "py", "lang": "Python", "max_stars_repo_path": "pycdt/core/defects_analyzer.py", "max_stars_repo_name": "hitarth64/pycdt", "max_stars_repo_head_hexsha": "0b07915e9e1e78c1a5206fa8bc7b4399813f22f8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 28, "max_stars_repo_stars_event_min_datetime": "2019-05-10T21:09:02.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-02T15:40:55.000Z", "max_issues_repo_path": "pycdt/core/defects_analyzer.py", "max_issues_repo_name": "hitarth64/pycdt", "max_issues_repo_head_hexsha": "0b07915e9e1e78c1a5206fa8bc7b4399813f22f8", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 10, "max_issues_repo_issues_event_min_datetime": "2019-05-10T21:22:10.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-26T13:40:35.000Z", "max_forks_repo_path": "pycdt/core/defects_analyzer.py", "max_forks_repo_name": "hitarth64/pycdt", "max_forks_repo_head_hexsha": "0b07915e9e1e78c1a5206fa8bc7b4399813f22f8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 15, "max_forks_repo_forks_event_min_datetime": "2019-05-11T21:23:08.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-21T16:43:02.000Z", "avg_line_length": 40.1639072848, "max_line_length": 108, "alphanum_fraction": 0.5781771714, "include": true, "reason": "import numpy,from scipy", "num_tokens": 5887, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.607663184043154, "lm_q2_score": 0.32766830082071396, "lm_q1q2_score": 0.19911196298672507}} {"text": "# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Tue Mar 29 12:31:30 2022\n\n@author: LENOVO\n\"\"\"\n\nimport biosteam as bst\nimport thermosteam as tmo\nimport numpy as np\nfrom chaospy import distributions as shape\nimport biosteam as bst\nimport numpy as np\n# All units are explicitly defined here for transparency and easy reference\n# Naming conventions:\n# D = Distillation column\n# M = Mixer\n# E = Multi effect evaporator\n# C = Crystalliser\n# H = Heat exchange\n# L = Liquid-liquid extraction unit (Multi stage Mixer settlers)\n# P = Pump (including conveying belt)\n# R = Reactor\n# S = Splitter (including solid/liquid separator)\n# T = Tank or bin for storage\n# U = Other units\n# PS = Process specificiation, not physical units, but for adjusting streams\n# MT = Mixing Tank\n \n# Processes:\n# 100: Conversion\n# 200: PrimarySeparation\n# 300: SecondarySeparation\n# 400: Wastewater\n# 500: Facilities\n\n#Defining chemicals\n#ref:lactic acid code\n#Chemicals used\nWater = tmo.Chemical('Water')\n#New chemical\n#FFA = C18H34O2\n#C18H34O2 + CH3OH → C19H36O2 + H2O\n#FAME (C19H36O2)\n#WCO\n#C27H54O2 + 3CH3OH → C3H8O3 ​+ ​FAME\n#Triglyceride considered is triolein\n\n#all_chemicals.set_synonym('Tripalmitin' ,'Oil1')\n# Oil2 = tmo.Chemical()\nOil2 = tmo.Chemical('TAG', search_ID='122-32-7', phase = 'l')\n\nOil2.copy_models_from(tmo.Chemical('Water'), ['mu'])\nOil2.Hf = -1607.83*1000\n\nGlycerol = tmo.Chemical('Glycerol', search_ID='56-81-5')\nGlycerol_missing_properties = Glycerol.get_missing_properties()\nFurfural = tmo.Chemical('Furfural')\nFurfural_missing_properties = Furfural.get_missing_properties()\nfor i in Glycerol_missing_properties:\n try:\n Glycerol.copy_models_from(Furfural,[i])\n except: pass\n\nCaO = tmo.Chemical('Calcium_oxide', phase = 's')\nCalcium_Sulphate = tmo.Chemical('Calcium_Sulphate', phase = 's')\n\nall_chemicals = tmo.Chemicals(['Water',\n 'Sulphuric_acid',\n 'Sodium_Hydroxide',\n 'Oleic_acid',\n #'Tripalmitin',\n 'Methyl_oleate',\n 'Methanol',\n Oil2,\n CaO,\n Calcium_Sulphate,\n #'Methyl_palmitate',\n '112-62-9',\n Glycerol,\n ])\n\n\nall_chemicals.compile()\nall_chemicals.show()\nall_chemicals.set_synonym('Oleic_acid' ,'FFA') \nall_chemicals.set_synonym('56-81-5' ,'Glycerol') \nall_chemicals.set_synonym('122-32-7' ,'Oil2') \n#all_chemicals.set_synonym('Methyl_palmitate' ,'fame1')\nall_chemicals.set_synonym('112-62-9' ,'fame2') \n\n\n##############################Settings#########################################3\nbst.settings.set_thermo(all_chemicals)\nbst.Stream.display_units.flow = 'kg/hr'\nbst.Stream.display_units.composition = True\nGWP = 'GWP 100yr'\nbst.settings.define_impact_indicator(key=GWP, units='kg*CO2e')\nCalcium_oxide = bst.Chemical('Calcium_oxide')\nCalcium_oxide.at_state('s')\n### TODO.xxx\nCalcium_oxide.V.add_model(1e-6)\n#############################UNITS#############################################\nclass PReactor(bst.BatchBioreactor):\n _N_ins = 1\n _N_outs = 1\n \n @property\n def effluent(self):\n return self.outs[0] \n @effluent.setter\n def effluent(self,effluent):\n self.outs[0]=effluent \n \n def __init__(self, ID='', ins=None, outs=(), thermo=None,\n tau=None, N=None, V=None, T= 65 + 275, P=101325,\n Nmin=2, Nmax=36):\n \n bst.BatchBioreactor.__init__(self, ID, ins, outs, thermo,\n tau = tau , N = N, V = V, T = T, \n P = P ,Nmin = Nmin , Nmax = Nmax) \n self.PR_conversion = 0.999\n \n def _setup(self):\n self.reactions = tmo.SeriesReaction([\n tmo.Rxn('Oleic_acid + Methanol -> Methyl_oleate + Water ',\n 'Oleic_acid', X = self.PR_conversion )\n ])\n # def _cost(self):\n # density_in_kg_per_m3 = 913 \n # batch_vol = self.design_results['Reactor volume'] * self.V_wf\n # R = (batch_vol/(0.002))**0.33 #here 2 is 2L\n # N2 = 600*((1/R)**(2/3))\n # D2 = 0.4*((batch_vol*4/3.14)**0.33)\n # Np = 1.27\n # power = Np * density_in_kg_per_m3*(N2**3)*(D2**5)\n # self.power_utility(power)\n \n def _run(self):\n feed = self.ins[0]\n effluent = self.outs[0] \n effluent.copy_like(feed) \n self.reactions(effluent) \n effluent.T = self.T\n effluent.P = self.P\n \n# Calcium oxide addition for Glycerol recovery\nclass Glycerol_recovery(bst.BatchBioreactor):\n _N_ins = 1\n _N_outs = 1\n \n @property\n def effluent(self):\n return self.outs[0] \n @effluent.setter\n def effluent(self,effluent):\n self.outs[0]=effluent \n \n def __init__(self, ID='', ins=None, outs=(), thermo=None,\n tau=None, N=None, V=None, T= 60 + 275, P=101325,\n Nmin=2, Nmax=36):\n \n bst.BatchBioreactor.__init__(self, ID, ins, outs, thermo,\n tau = tau , N = N, V = V, T = T, \n P = P ,Nmin = Nmin , Nmax = Nmax) \n \n def _setup(self):\n self.reactions = tmo.SeriesReaction([\n tmo.Rxn('Calcium_oxide + Sulphuric_acid -> Calcium_Sulphate + Water',\n 'Sulphuric_acid', X = 0.999)])\n # def _cost(self):\n # density_in_kg_per_m3 = 873.9 \n # batch_vol = self.design_results['Reactor volume'] * self.V_wf\n # R = (batch_vol/(0.002))**0.33 #here 2 is 2L\n # N2 = 600*((1/R)**(2/3))\n # D2 = 0.4*((batch_vol*4/3.14)**0.33)\n # Np = 1.27\n # power = Np * density_in_kg_per_m3*(N2**3)*(D2**5)\n # self.power_utility(power)\n \n \n def _run(self):\n feed = self.ins[0]\n effluent = self.outs[0] \n effluent.copy_like(feed) \n self.reactions(effluent) \n effluent.T = self.T\n effluent.P = self.P\n \n# Transesterification reactor\nclass TReactor(bst.BatchBioreactor):\n _N_ins = 1\n _N_outs = 1\n \n @property\n def effluent(self):\n return self.outs[0] \n @effluent.setter\n def effluent(self,effluent):\n self.outs[0]=effluent \n \n def __init__(self, ID='', ins=None, outs=(), thermo=None,\n tau=None, N=None, V=None, T= 60 + 275, P=101325,\n Nmin=2, Nmax=36):\n \n bst.BatchBioreactor.__init__(self, ID, ins, outs, thermo,\n tau = tau , N = N, V = V, T = T, \n P = P ,Nmin = Nmin , Nmax = Nmax) \n self.TR_conversion = 0.999 \n def _setup(self):\n self.reactions = tmo.ParallelReaction([\n # tmo.Rxn('Tripalmitin + 3Methanol -> Methyl_palmitate + Glycerol',\n # 'Tripalmitin', \n # X = 0.9),\n tmo.Rxn('Oil2 + 3Methanol -> Methyl_oleate + Glycerol',\n 'Oil2', X = self.TR_conversion)\n ])\n \n # def _cost(self):\n # density_in_kg_per_m3 = 913 \n # batch_vol = self.design_results['Reactor volume'] * self.V_wf\n # R = (batch_vol/(0.002))**0.33 #here 2 is 2L\n # N2 = 600*((1/R)**(2/3))\n # D2 = 0.4*((batch_vol*4/3.14)**0.33)\n # Np = 1.27\n # power = Np * density_in_kg_per_m3*(N2**3)*(D2**5)\n # self.power_utility(power)\n \n def _run(self):\n feed = self.ins[0]\n effluent = self.outs[0] \n effluent.copy_like(feed) \n self.reactions(effluent) \n effluent.T = self.T\n effluent.P = self.P \n############################ STREAMS ########################################## \nWCO_range = [4947,5038,5128,\n 5219,5310,5400,\n 5491,5581,5672,\n 5763,5853,5944,\n 6035,6125,6216,\n 6307,6397,6488,\n 6579,6669]\nGWP_obtained = [68.03354950443708, -18.60145643725397,]\nTotal_Collected_WCO = 6669\n#Three values 4800,5525,6475\nFFA = tmo.Chemical('Oleic_acid')\n# Oil1 = tmo.Chemical('Tripalmitin')\nOil2 = all_chemicals['Oil2']\n# FFA content is 6% of the total Oil\nCollected_WCO = bst.Stream('Collected_WCO',\n #Oil1 = 940/2 ,\n Oil2 = 940,\n FFA = 60, \n units = 'kg/hr')\n# http://dx.doi.org/10.17576/jkukm-2018-si1(2)-10\n\nCollected_WCO.set_total_flow(Total_Collected_WCO,\n units='kg/hr')\nFresh_water = bst.Stream('Fresh_water')\nWashed_WCO = bst.Stream('Washed_WCO') \n#TODO.xxx change this depending on the scale up ratios\nFresh_Methanol_1 = bst.Stream('Methanol1') \nFresh_Methanol_2 = bst.Stream('Methanol2') \nFresh_Sulacid = bst.Stream('Sulphuric_acid')\nFresh_Glycerol = bst.Stream('Glycerol') \nRecycled_Methanol = bst.Stream('Recycled_Methanol')\nFresh_CaO = bst.Stream('Fresh_CaO')\n \n# Calcium_Sulphate = bst.Chemical('Calcium_Sulphate')\nCalcium_Sulphate.at_state('s')\nCalcium_Sulphate.V.add_model(1e-6)\nReuse_Calcium_Sulphate = bst.Stream('Reuse_Calcium_Sulphate')\n\n\n############################# SYSTEMS ##########################################\n#Tank to store Collected WCO and Water\nT101 = bst.StorageTank('T101_WCO',\n ins = (Collected_WCO),\n outs = 'WCO_to_pump')\n# P101 = bst.Pump('P101_WCO', \n# ins = T101-0, \n# outs = 'WCO_for_waterwash')\n\nT102 = bst.StorageTank('T102_Water',\n ins = Fresh_water,\n outs = 'Washing_water_to_pump')\nP102 = bst.Pump('P102_Water',\n ins = T102-0,\n outs = 'water_for_wash')\n\n# T103 = bst.MixTank('T103_Methanol',\n# ins = (Fresh_Methanol),\n# outs = 'Methanol_to_pump')\n# #TODO.xxx Check \n# P103 = bst.Pump('P103_Methanol', \n# ins = T103-0,\n# outs ='Methanol_to_reactor')\n\n# M103_Methanol = bst.Mixer('M103_Methanol_mixing',\n# ins = (Fresh_Methanol_1,Fresh_Methanol_2),\n# outs = ('Methanol_to_splitter'))\n \n# S1031 = bst.Splitter('S1031',\n# ins = M103_Methanol-0,\n# outs = ('Methanol_for_pretreatment',\n# 'Methanol_for_transesterification'),\n# split = 0.5)\n\nT104 = bst.StorageTank('T104_Sulacid',\n ins = Fresh_Sulacid,\n outs='Sulacid_to_pump')\n\nP104 = bst.Pump('P104_Sulacid',\n ins = T104-0, \n outs='Sulacid_to_reactor')\n\nT105 = bst.StorageTank('T105_Glycerol',\n ins = Fresh_Glycerol,\n outs = 'Glycerol_to_pump')\n\nP105 = bst.Pump('P105_Glycerol',\n P = 110300,\n ins = T105-0, \n outs = 'Glycerol_to_scrubber')\n\n# T106 = bst.StorageTank('T106_CaO',\n# ins = Fresh_CaO, \n# vessel_type='Field erected',\n# outs = 'CaO_to_pump')\n\n# P106 = bst.Pump('P106_CaO',\n# ins = Fresh_CaO,\n# outs = 'CaO_for_deacidification')\n\n#############################SYTEMS AND UNITS########################\n#Mixtank to mix WCO and water\nM101 = bst.MixTank('M101', ins = (T101-0,P102-0),\n outs = 'Mixedfeed_for_waterwashing' )\n\n@M101.add_specification(run=True)\ndef adjust_Washing_water_flow(): \n Fresh_water.imass['Water'] = 10 * Collected_WCO.F_mass\n\n#Splitter to seperate the water slurry from the effluent\n#Considers 2% loss of oil\nS101 = bst.units.Splitter('S101', ins=M101-0,\n outs=('Water_slurry',\n 'WCO_pretreatment', \n ),\n split={'Water': 1,\n 'Oleic_acid': 0,\n #'Oil1': 0.01,\n 'Oil2': 0.02, \n }) \n\n#Mixer to mix all the streams before adding the stream to the reactor \nM102 = bst.Mixer('M102',\n ins = (S101-1,Fresh_Methanol_1,P104-0),\n outs = 'mixedfeed_to_pretreatment') \nSul_acid_ratio = 0.0015\n#######################################################################\n@M102.add_specification(run=True)\ndef adjust_methanol():\n b = S101.ins[0].imass['Oleic_acid'] \n Fresh_Methanol_1.imass['Methanol'] = 3*b\n Fresh_Sulacid.imass['Sulphuric_acid'] = Sul_acid_ratio * S101.outs[1].F_mass\n \n#Reactor for the first esterification to reduce FFA content\n#Assumes 90% conversion \n\nR101 = PReactor('R101',\n ins = M102.outs[0],\n outs = 'feed_to_Glycerol_scrubber', \n N = 4,\n T = 48.5 + 273.15,\n P = 400000,\n tau = 2\n )\n\n#Glycerol scrubber to scrub Sulacid, Methanol and Water \nL101_H = bst.units.HXutility('L101_H',\n ins = R101-0,\n outs ='feed_to_Glycerol_scrubber',\n T = 65+273) \n\nL101 = bst.MultiStageMixerSettlers('L101_Glycerol_scrubber',\n ins = (L101_H-0,P105-0),\n outs=('Methanol_extract',\n 'raffinate_with_pretreated_WCO',\n ), \n N_stages = 2, \n )\n@L101.add_specification(run=True)\ndef adjust_glycerol():\n b = M102.outs[0].imass['Methanol'] \n Fresh_Glycerol.imass['Glycerol'] = 0.547*b\n\n#Methanol recovery\nD101 = bst.units.ShortcutColumn('D101',\n ins = L101-0,\n outs = ('Recycled_methanol',\n 'Glycerol_for_recovery'),\n LHK = ('Methanol','Water'),\n k = 2,\n P = 90000,\n #P = 101325./20,\n Lr = 0.99, \n Hr = 0.99,\n partial_condenser= False,\n )\n\n@D101.add_specification\ndef D101_spec():\n oil_mol = D101.ins[0].imol['122-32-7']\n D101.ins[0].imol['122-32-7'] = 0\n D101._run()\n # D101.ins[0].imol['122-32-7'] = oil_mol\n # D101.outs[1].imol['122-32-7'] = oil_mol\n \nM103 = bst.Mixer('M103',\n ins = (D101-1,\n Fresh_CaO),\n outs = 'mixedfeed_for_deacidification'\n ) \n\n@M103.add_specification(run = True)\ndef adjust_CaO():\n c = D101.outs[1].imass['Sulphuric_acid']\n print(c)\n # P106.outs[0].imass['Calcium_oxide'] = 5.4*c\n Fresh_CaO.imass['Calcium_oxide'] = 5.4*c\n \nv_for_Calcium_sulphate_prod = 1.2* M103.outs[0].F_vol\n#5.4 Kg of CaO/Kg of Sul acid\n\nR102 = Glycerol_recovery('R102',\n ins = M103-0,\n outs='effluent_to_splitter', \n T = 50 + 273.15,\n tau = 3,\n N = 3\n )\n# Splitter to remove Calcium sulphate\nS103 = bst.units.Splitter('S103',\n R102-0,\n ['Reuse_Calcium_Sulphate',\n 'Glycerol_for_recovery'],\n split={'Calcium_Sulphate': 1,\n 'Methanol': 0,\n 'Glycerol': 0,\n 'Sulphuric_acid': 0,\n 'Calcium_oxide': 0,\n 'Water': 0,}\n )\n\nT107 = bst.StorageTank('T107_Calcium_Sulphate',\n ins = S103-0, \n outs ='co_product_CaSO4')\n\n#Reactor for transesterification\n\nM104 = bst.Mixer('M104',\n ins = (L101-1,D101-0,Fresh_Methanol_2), \n outs = 'feed_to_transesterification')\n \n\nR103 = TReactor('R103',\n ins = M104.outs[0],\n outs = 'mixedfeed_to_biodiesel_rectification', \n T = 50 + 273.15,\n tau = 4,\n N = 3\n )\n \n@M104.add_specification(run = True)\ndef adjust_methanol_for_transesterification():\n b = M104.ins[0].imass['Oil2'] + M104.ins[1].imass['Oil2'] #M104.ins[0].imass['Tripalmitin'] + M104.ins[1].imass['Tripalmitin'] + \n a = M104.ins[0].imass['Methanol'] / b\n if a < 1.25: \n c = 1.25/a\n Fresh_Methanol_2.imass['Methanol'] = c*b\n \n#Methanol recovery after transesterification\n#TODO.xxx check how to recycle\nD102 = bst.units.ShortcutColumn('D102',\n ins = R103-0,\n outs = ('Recycled_methanol',\n 'Biodiesel_for_rectification'),\n LHK = ('Methanol','Water'),\n k = 4.6,\n # P = 80000,\n P = 101325/20,\n Lr = 0.99999, \n Hr = 0.99999,\n partial_condenser= False,\n )\n\n#Splitter to remove glycerol from the biodisel\nS104 = bst.units.Splitter('S104',\n D102-1,\n ['FAME_for_recovery',\n 'Glycerol_for_recovery'],\n split={'Water':0,\n 'Sulphuric_acid':0,\n 'Oleic_acid':1,\n #'Tripalmitin':1,\n 'Methyl_oleate':1,\n #'Methyl_palmitate':1,\n 'Methanol':0,\n '122-32-7':1,\n 'Glycerol':1})\n\nD103_H = bst.units.HXutility('Heat_exchanger_for_biodiesel_rectification',\n ins = S104-0, T = 460\n )\n\nD103 = bst.units.ShortcutColumn('D103',\n ins = D103_H-0,\n outs = ('Glycerol_for_recovery',\n 'BIODIESEL',\n ),\n LHK = ('Glycerol',\n 'Methyl_oleate'),\n k = 2, \n # P = 80000,\n P=101325/20,\n Lr = 0.95, \n Hr = 0.9,\n partial_condenser= False\n )\n# Splitter_Final = bst.units.Splitter('S_final',\n# D103-1,\n# ['Biodiesel',\n# 'Waste_oil'],\n# split={'Water':0,\n# 'Sulphuric_acid':0,\n# 'Oleic_acid':0,\n# #'Tripalmitin':1,\n# 'Methyl_oleate':1,\n# #'Methyl_palmitate':1,\n# 'Methanol':0,\n# '122-32-7':0,\n# 'Glycerol':0})\n\n##################################STORAGE TANKS ###############################\nT108 = bst.MixTank('Waste_Glycerol',ins=(D103-0,S103-1))\nT109 = bst.MixTank('Waste_Methanol',ins= (D102-0,S104-1))\nT110 = bst.units.StorageTank('Biodiesel',ins=D103-1)\n#################################System simulation ############################\nWCO_sys = bst.main_flowsheet.create_system('WCO_sys')\nWCO_sys.operating_hours = 345 * 24\nWCO_sys.diagram(number=True)\nWCO_sys.simulate()\n\n#############################Characterisation_factors###########################\n#Collected waste cooking oil impact\n#https://v36.ecoquery.ecoinvent.org/Details/LCIA/d1f82144-4856-44f2-a56a-f01a40cc4d51/290c1f85-4cc4-4fa1-b0c8-2cb7f4276dce\nCollected_WCO.set_CF(GWP, 0.26797)\n#Sulphuric_acid impact\nFresh_Sulacid.set_CF(GWP,0.084321)\n#Water\n#https://v36.ecoquery.ecoinvent.org/Details/LCIA/979d50d1-eca2-4399-9805-e9fb36c9e463/290c1f85-4cc4-4fa1-b0c8-2cb7f4276dce\nFresh_water.set_CF(GWP, 0.00079796)\n#Methanol_GWP\nFresh_Methanol_1.set_CF(GWP,0.65534)\n##above is an assump\nFresh_Methanol_2.set_CF(GWP,0.65534)\n#Electricity impact from biosteam\nbst.PowerUtility.set_CF(GWP,0.38) \n#STEAM: https://v36.ecoquery.ecoinvent.org/Details/LCIA/50cb253a-839c-494a-b98e-5ac2f3dc8e07/290c1f85-4cc4-4fa1-b0c8-2cb7f4276dce\nbst.HeatUtility.set_CF('low_pressure_steam', GWP, 88.44, basis='MMBtu')\n# NaOH GWP\n#NaOH.set_CF(GWP,1.3106)\n#CaO GWO\n#below is an assum\nFresh_CaO.set_CF(GWP,0.1396)\n#Waste_gypsum CF = 0.0091162\n#Wastewater_CF = 11.432\n#Glycerol GWP\t\nFresh_Glycerol.set_CF(GWP, 0.2588)\n\nwaste_methanol_value = 0.65534*WCO_sys.get_mass_flow(T109.outs[0])\n\nwaste_Glycerol_value = 0.2588*WCO_sys.get_mass_flow(T108.outs[0])\n\n#https://v36.ecoquery.ecoinvent.org/Details/LCIA/f38b101d-77d0-4940-b775-5a3cd38f9f6d/290c1f85-4cc4-4fa1-b0c8-2cb7f4276dce\n#https://v36.ecoquery.ecoinvent.org/Details/LCIA/ddf1244d-1051-47b3-96a3-5404d1036524/290c1f85-4cc4-4fa1-b0c8-2cb7f4276dce\nwaste_Water_value = 4.186* WCO_sys.get_mass_flow(S101.outs[0])\nwaste_CaSO4_value = 0.1396*WCO_sys.get_mass_flow(T107.outs[0])\ntotal_out_mass = WCO_sys.get_mass_flow(D103.outs[1])\nnet_waste_GWP = waste_methanol_value + waste_Glycerol_value + waste_Water_value #+ waste_CaSO4_value\nWCO_sys_net = WCO_sys.get_net_electricity_impact(GWP) + WCO_sys.get_total_feeds_impact(GWP)+WCO_sys.get_net_heat_utility_impact('low_pressure_steam', GWP)\nGWP_total_displacement = WCO_sys_net - net_waste_GWP\nGWP_total_transport = 127*4\na = GWP_total_displacement + GWP_total_transport\nb = a/total_out_mass\nprint(b)\n \n#b = 0.035435\n# print(GWP_total_displacement/total_out_mass)\n# print('GWP/mmBTU:',a/b)\n\n#Biodiesel from WCO 37.3 (MJ/Kg)\n#1 MJ equals 947.82 BTU\n#Calorific value of 1 Kg WCO based biodiesel is 35448.36 BTU\n#Biodiesel calorific value is 0.035435 mmBTU/Kg\n#\n#B100: 119,550 Btu/ga\n#1 gal is 3.31Kg\n#119550/3.31\n\n#Residential #6 Oil; 166.7 lb/mmBtu \n#166.7*0.45360.4536/mmBtu \n# # # ####################################UNCERTAINITY ANALYSIS ########################################3\n\n# model = bst.Model(WCO_sys)\n \n# # @model.parameter(name='Total_input_WCO',\n# # distribution=shape.Uniform(5000, 6000))\n# # def set_value(X):\n# # Total_Collected_WCO = X\n# @model.parameter(name='Pretreatment_conversion',\n# distribution=shape.Uniform(0.9997, 0.9999))\n# def set_conversion(X):\n# R101.PR_conversion = X\n# @model.parameter(name='Transesterification_conversion',\n# distribution=shape.Uniform(0.9997, 0.9999))\n# def set_conversion(X):\n# R103.TR_conversion = X\n# # reactor is the object, reactant conversion is not defined\n \n# @model.parameter(name='Sulphuric_acid_ratio',\n# distribution=shape.Uniform(0.0015, 0.003))\n# def set_SULACID_VALUE(X):\n# Sul_acid_ratio = X\n\n# @model.metric(name = 'total_GWP_value')\n# def LCA():\n# waste_Water_value = 4.186* WCO_sys.get_mass_flow(S101.outs[0])\n# waste_CaSO4_value = 0.1396*WCO_sys.get_mass_flow(T107.outs[0])\n# total_out_mass = WCO_sys.get_mass_flow(D103.outs[1])\n# net_waste_GWP = waste_methanol_value + waste_Glycerol_value + waste_Water_value #+ waste_CaSO4_value\n# WCO_sys_net = WCO_sys.get_net_electricity_impact(GWP) + WCO_sys.get_total_feeds_impact(GWP)+WCO_sys.get_net_heat_utility_impact('low_pressure_steam', GWP)\n# GWP_total_displacement = WCO_sys_net - net_waste_GWP\n# GWP_total_transport = 127*2\n# a = GWP_total_displacement + GWP_total_transport\n# b = a/total_out_mass\n# return(b)\n \n\n# np.random.seed(1234) # For consistent results\n# N_samples = 50\n# rule = 'L' # For Latin-Hypercube sampling\n# samples = model.sample(N_samples, rule)\n# model.load_samples(samples)\n# model.evaluate()\n# model.table # All evaluations are stored as a pandas DataFrame\n# print(model.table)\n\n# df_rho, df_p = model.spearman_r()\n# bst.plots.plot_spearman_1d(df_rho['Biorefinery', 'total_GWP_value'],\n# index=[i.describe() for i in model.parameters],\n# name= 'total_GWP_value') \n# =============================================================================\n#Residential fuel oil GWP 100: 0.44\n# https://v36.ecoquery.ecoinvent.org/Details/LCIA/ed9b5526-d54a-4129-bbe0-52a36f02ae99/290c1f85-4cc4-4fa1-b0c8-2cb7f4276dce\n\n\n#Calculating yield\n#MW of AA = Actual yield/Theoritical yield(188 * 3.54)\n#Density of WCO\n#1 kilogram / cubic meter = 0.001 kilograms / liter\n", "meta": {"hexsha": "b14aa20f866794af0c969fca0dbec3ac8849906a", "size": 25665, "ext": "py", "lang": "Python", "max_stars_repo_path": "BioSTEAM 2.x.x/biorefineries/ozonolysis/SUD_project.py", "max_stars_repo_name": "yoelcortes/Bioindustrial-Complex", "max_stars_repo_head_hexsha": "d39edfec88e443ef7a62218ca0215e3b105f4b96", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-01-03T21:04:41.000Z", "max_stars_repo_stars_event_max_datetime": "2020-01-09T01:15:48.000Z", "max_issues_repo_path": "BioSTEAM 2.x.x/biorefineries/ozonolysis/SUD_project.py", "max_issues_repo_name": "yoelcortes/Bioindustrial-Complex", "max_issues_repo_head_hexsha": "d39edfec88e443ef7a62218ca0215e3b105f4b96", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 6, "max_issues_repo_issues_event_min_datetime": "2020-01-03T21:31:27.000Z", "max_issues_repo_issues_event_max_datetime": "2020-02-28T13:53:56.000Z", "max_forks_repo_path": "BioSTEAM 2.x.x/biorefineries/ozonolysis/SUD_project.py", "max_forks_repo_name": "yoelcortes/Bioindustrial-Complex", "max_forks_repo_head_hexsha": "d39edfec88e443ef7a62218ca0215e3b105f4b96", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-01-07T14:04:06.000Z", "max_forks_repo_forks_event_max_datetime": "2020-01-08T23:05:25.000Z", "avg_line_length": 38.0786350148, "max_line_length": 160, "alphanum_fraction": 0.5157218001, "include": true, "reason": "import numpy", "num_tokens": 7228, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6477982179521102, "lm_q2_score": 0.3073580105206753, "lm_q1q2_score": 0.1991059714885994}} {"text": "##############################################################################\n#\n# Copyright (c) 2003-2018 by The University of Queensland\n# http://www.uq.edu.au\n#\n# Primary Business: Queensland, Australia\n# Licensed under the Apache License, version 2.0\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Development until 2012 by Earth Systems Science Computational Center (ESSCC)\n# Development 2012-2013 by School of Earth Sciences\n# Development from 2014 by Centre for Geoscience Computing (GeoComp)\n#\n##############################################################################\n\n\"\"\"Base classes for forward models\"\"\"\n\nfrom __future__ import division, print_function\n\n__copyright__=\"\"\"Copyright (c) 2003-2018 by The University of Queensland\nhttp://www.uq.edu.au\nPrimary Business: Queensland, Australia\"\"\"\n__license__=\"\"\"Licensed under the Apache License, version 2.0\nhttp://www.apache.org/licenses/LICENSE-2.0\"\"\"\n__url__=\"https://launchpad.net/escript-finley\"\n\n__all__ = ['ForwardModel','ForwardModelWithPotential']\n\nfrom esys.downunder.coordinates import makeTransformation\nfrom esys.escript.linearPDEs import LinearSinglePDE\nfrom esys.escript.util import *\nimport numpy as np\n\nclass ForwardModel(object):\n \"\"\"\n An abstract forward model that can be plugged into a cost function.\n Subclasses need to implement `getDefect()`, `getGradient()`, and possibly\n `getArguments()` and 'getCoordinateTransformation'.\n \"\"\"\n def __init__(self):\n pass\n\n def getArguments(self, x):\n return ()\n\n def getCoordinateTransformation(self):\n return None\n\n def getDefect(self, x, *args):\n raise NotImplementedError\n\n def getGradient(self, x, *args):\n raise NotImplementedError\n\n\nclass ForwardModelWithPotential(ForwardModel):\n \"\"\"\n Base class for a forward model using a potential such as magnetic or\n gravity. It defines a cost function:\n\n defect = 1/2 sum_s integrate( ( weight_i[s] * ( r_i - data_i[s] ) )**2 )\n\n where s runs over the survey, weight_i are weighting factors, data_i are\n the data, and r_i are the results produced by the forward model.\n It is assumed that the forward model is produced through postprocessing\n of the solution of a potential PDE.\n \"\"\"\n def __init__(self, domain, w, data, coordinates=None,\n fixPotentialAtBottom=False,\n tol=1e-8):\n \"\"\"\n initializes a new forward model with potential.\n\n :param domain: domain of the model\n :type domain: `Domain`\n :param w: data weighting factors\n :type w: ``Vector`` or list of ``Vector``\n :param data: data\n :type data: ``Vector`` or list of ``Vector``\n :param coordinates: defines coordinate system to be used\n :type coordinates: `ReferenceSystem` or `SpatialCoordinateTransformation`\n :param fixPotentialAtBottom: if true potential is fixed to zero at the bottom of the domain\n in addition to the top.\n :type fixPotentialAtBottom: ``bool``\n :param tol: tolerance of underlying PDE\n :type tol: positive ``float``\n \"\"\"\n super(ForwardModelWithPotential, self).__init__()\n self.__domain = domain\n self.__trafo = makeTransformation(domain, coordinates)\n\n try:\n n=len(w)\n m=len(data)\n if not m == n:\n raise ValueError(\"Length of weight and data must be the same.\")\n self.__weight = w\n self.__data = data\n except TypeError:\n self.__weight = [w]\n self.__data = [data]\n\n BX = boundingBox(domain)\n DIM = domain.getDim()\n x = domain.getX()\n self.__pde=LinearSinglePDE(domain)\n self.__pde.getSolverOptions().setTolerance(tol)\n self.__pde.setSymmetryOn()\n z=x[DIM-1]\n q0=whereZero(z-BX[DIM-1][1])\n if fixPotentialAtBottom: q0+=whereZero(z-BX[DIM-1][0])\n self.__pde.setValue(q=q0)\n\n self.edge_lengths=np.asarray(boundingBoxEdgeLengths(domain))\n self.diameter=1./sqrt(sum(1./self.edge_lengths**2))\n\n self.__origweight=[]\n for s in range(len(self.__weight)):\n # save a copy of the original weights in case of rescaling\n self.__origweight.append(1.*self.__weight[s])\n\n if not self.__trafo.isCartesian():\n fd=1./self.__trafo.getScalingFactors()\n fw=self.__trafo.getScalingFactors()*sqrt(self.__trafo.getVolumeFactor())\n for s in range(len(self.__weight)):\n self.__weight[s] = fw * self.__weight[s]\n self.__data[s] = fd * self.__data[s]\n\n def _rescaleWeights(self, scale=1., fetch_factor=1.):\n \"\"\"\n rescales the weights such that\n\n *sum_s integrate( ( weight_i[s] *data_i[s]) (weight_j[s]*1/L_j) * L**2 * fetch_factor )=scale*\n \"\"\"\n if not scale > 0:\n raise ValueError(\"Value for scale must be positive.\")\n A=0\n # copy back original weights before rescaling\n self.__weight=[1.*ow for ow in self.__origweight]\n\n for s in range(len(self.__weight)):\n if self.__data[s].getShape() == ():\n ff=self.__weight[s]**2*self.__data[s]/length(self.edge_lengths)\n else:\n ff=inner(self.__weight[s], self.__data[s]) * inner(self.__weight[s], 1/self.edge_lengths)\n A += integrate(abs(ff * fetch_factor))\n if A > 0:\n A=sqrt(scale/A)/self.diameter\n if not self.__trafo.isCartesian():\n A*=self.__trafo.getScalingFactors()*sqrt(self.__trafo.getVolumeFactor())\n for s in range(len(self.__weight)):\n self.__weight[s]*=A\n else:\n raise ValueError(\"Rescaling of weights failed.\")\n\n def getDomain(self):\n \"\"\"\n Returns the domain of the forward model.\n\n :rtype: `Domain`\n \"\"\"\n return self.__domain\n\n def getMisfitWeights(self):\n \"\"\"\n Returns the weights of the misfit function\n \n :rtype: ``list`` of ``Data``\n \"\"\"\n return self.__weight\n\n def getData(self):\n \"\"\"\n Returns the data\n\n :rtype: ``list`` of ``Data``\n \"\"\"\n return self.__data\n def getDataFunctionSpace(self):\n \"\"\"\n Returns the ``FunctionSpace`` of the data\n\n :rtype: ``FunctionSpace``\n \"\"\"\n return self.getData()[0].getFunctionSpace()\n \n def getCoordinateTransformation(self):\n \"\"\"\n returns the coordinate transformation being used\n\n :rtype: ``CoordinateTransformation``\n \"\"\"\n return self.__trafo\n\n def getPDE(self):\n \"\"\"\n Return the underlying PDE.\n\n :rtype: `LinearPDE`\n \"\"\"\n return self.__pde\n\n def _getDefect(self, result):\n \"\"\"\n Returns the defect value.\n\n :param result: a result vector\n :type result: `Vector`\n :rtype: ``float``\n \"\"\"\n A=0.\n for s in range(len(self.__weight)):\n A += integrate( inner(self.__weight[s], self.__data[s]-result)**2 )\n return A/2\n\n def getDefectGradient(self, result):\n Y=0.\n for s in range(len(self.__weight)):\n Y = inner(self.__weight[s], self.__data[s]-result) * self.__weight[s] + Y\n return Y\n\n def getSurvey(self, index=None):\n \"\"\"\n Returns the pair (data_index, weight_index), where data_i is the data\n of survey i, weight_i is the weighting factor for survey i.\n If index is None, all surveys will be returned in a pair of lists.\n \"\"\"\n if index is None:\n return self.__data, self.__weight\n if index>=len(self.__data):\n raise IndexError(\"Forward model only has %d surveys\"%len(self.__data))\n return self.__data[index], self.__weight[index]\n\n", "meta": {"hexsha": "f67f8f89abc5023bf794a2501036b0ecab7f3b47", "size": 7939, "ext": "py", "lang": "Python", "max_stars_repo_path": "downunder/py_src/forwardmodels/base.py", "max_stars_repo_name": "markendr/esys-escript.github.io", "max_stars_repo_head_hexsha": "0023eab09cd71f830ab098cb3a468e6139191e8d", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "downunder/py_src/forwardmodels/base.py", "max_issues_repo_name": "markendr/esys-escript.github.io", "max_issues_repo_head_hexsha": "0023eab09cd71f830ab098cb3a468e6139191e8d", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-01-14T03:07:43.000Z", "max_issues_repo_issues_event_max_datetime": "2019-01-14T03:07:43.000Z", "max_forks_repo_path": "downunder/py_src/forwardmodels/base.py", "max_forks_repo_name": "markendr/esys-escript.github.io", "max_forks_repo_head_hexsha": "0023eab09cd71f830ab098cb3a468e6139191e8d", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.9273504274, "max_line_length": 104, "alphanum_fraction": 0.5969265651, "include": true, "reason": "import numpy", "num_tokens": 1810, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.5888891451980403, "lm_q2_score": 0.3380771374883919, "lm_q1q2_score": 0.19908995650653943}} {"text": "import numpy as np\nimport pymc3 as pm\nimport pandas as pd\n#import pickle\n#import wandb\n#import yaml\nimport warnings\nfrom sklearn.cluster import k_means\nfrom scipy.special import softmax, logsumexp, loggamma\nfrom sklearn.metrics.pairwise import cosine_similarity\nfrom .constants import * \nimport pkg_resources\n\n# constants\n#C=32\n#M=3\n#P=2\n\ndef dirichlet(node_name, a, shape, scale=1, testval = None):\n # dirichlet reparameterized here because of stickbreaking bug\n # https://github.com/pymc-devs/pymc3/issues/4733\n X = pm.Gamma(f'gamma_{node_name}', mu = a, sigma = scale, shape = shape, testval = testval)\n Y = pm.Deterministic(node_name, (X/X.sum(axis = (X.ndim-1))[...,None]))\n return Y\n\n\ndef load_config(config_fp):\n\n # load the yaml file \n with open(config_fp, 'r') as f:\n config = yaml.safe_load(f)\n print(f\"Loaded configuration file {config_fp}\")\n\n # remove any parameters not applicable to selected data source\n ds = config.pop('dataset')\n ds[ds['dataset_sel']].update({'dataset_sel': ds['dataset_sel']})\n\n # update dataset args to subsetted list\n config.update({'dataset': ds[ds['dataset_sel']]})\n \n ## handle seeding\n #config['dataset'].update({'data_rng': np.random.default_rng(config['dataset']['data_seed'])})\n #config['model'].update({'model_rng': np.random.default_rng(config['model']['model_seed'])})\n \n return config['dataset'], config['model'], config['pymc3']\n \ndef detect_naming_style(fp):\n\n # first column must have type at minimum\n df = pd.read_csv(fp, index_col=0, sep = None, engine = 'python')\n naming_style = 'unrecognized'\n \n # check if index is type style\n if df.index.isin(mut96).any(): naming_style = 'type'\n\n # check if index is type/subtype style\n else:\n df = df.reset_index()\n df = df.set_index(list(df.columns[0:2]))\n if df.index.isin(idx96).any(): naming_style = 'type/subtype'\n\n assert naming_style == 'type' or naming_style == 'type/subtype', \\\n 'Mutation type naming style could not be identified.\\n'\\\n '\\tExpected either two column type/subtype (ex. C>A,ACA) or\\n'\\\n '\\tsingle column type (ex A[C>A]A). See examples at COSMIC database.'\n \n return naming_style\n\ndef load_sigs(fp):\n warnings.warn(\"load_sigs is deprecated, see Damuta class\", DeprecationWarning)\n\n naming_style = detect_naming_style(fp)\n\n if naming_style == 'type':\n # read in sigs\n sigs = pd.read_csv(fp, index_col = 0, sep = None, engine = 'python').reindex(mut96)\n # sanity check for matching mut96, should have no NA \n sel = (~sigs.isnull()).all(axis = 1)\n assert sel.all(), f'invalid signature definitions: null entry for types {list(sigs.index[~sel])}' \n # convert to pcawg convention\n sigs = sigs.set_index(idx96)\n \n elif naming_style == 'type/subtype':\n # read in sigs\n sigs = pd.read_csv(fp, index_col = (0,1), header=0).reindex(idx96)\n # sanity check for idx, should have no NA\n sel = (~sigs.isnull()).all(axis = 1)\n assert sel.all(), f'invalid signature definitions: null entry for types {list(sigs.index[~sel])}' \n \n # check colsums are 1\n sel = np.isclose(sigs.sum(axis=0), 1)\n assert sel.all(), f'invalid signature definitions: does not sum to 1 in columns {list(sigs.columns[~sel])}' \n\n assert all(sigs.index == idx96) or all(sigs.index == mut96), 'signature defintions failed to be read correctly'\n \n # force Jx96 and mut96 convention\n sigs = sigs.T\n sigs.columns = mut96\n \n return sigs\n\ndef load_counts(counts_fp):\n warnings.warn(\"load_counts is deprecated, see Damuta class\", DeprecationWarning)\n counts = pd.read_csv(counts_fp, index_col = 0, header = 0)[mut96]\n assert counts.ndim == 2, 'Mutation counts failed to load. Check column names are mutation type (ex. A[C>A]A). See COSMIC database for more.'\n assert counts.shape[1] == 96, f'Expected 96 mutation types, got {counts.shape[1]}'\n return counts\n\ndef subset_samples(dataset, annotation, annotation_subset, sel_idx = 0):\n # subset sample ids by matching to annotation_subset\n # expect annotation_subset to be pd dataframe with ids as index\n\n if annotation_subset is None:\n return dataset, annotation\n\n # stop string being auto cast to list\n if type(annotation_subset) == str:\n annotation_subset = [annotation_subset]\n \n if annotation.ndim > 2:\n warnings.warn(f\"More than one annotation is available per sample, selection index {sel_idx}\", UserWarning)\n \n # annotation ids should match sample ids\n assert dataset.index.isin(annotation.index).any(), 'No sample ID matches found in dataset for the provided annotation'\n\n # reoder annotation (with gaps) to match dataset\n annotation = annotation.reindex(dataset.index)\n\n # partial matches allowed\n sel = np.fromiter((map(any, zip(*[annotation[annotation.columns[sel_idx]].str.contains(x) for x in annotation_subset] ))), dtype = bool)\n \n # type should appear in the type column of the lookup \n assert sel.any(), 'Cancer type subsetting yielded no selection. Check keywords?'\n\n dataset = dataset.loc[annotation.index[sel]]\n annotation = annotation.loc[annotation.index[sel]]\n return dataset, annotation\n\ndef save_checkpoint(fp, model, trace, dataset_args, model_args, pymc3_args, run_id): \n with open(f'{fp}', 'wb') as buff:\n pickle.dump({'model': model, 'trace': trace, 'dataset_args': dataset_args, \n 'model_args': model_args, 'pymc3_args': pymc3_args, 'run_id': run_id}, buff)\n print(f'checkpoint saved to {fp}') \n \ndef load_checkpoint(fn):\n with open(fn, 'rb') as buff:\n data = pickle.load(buff)\n print(f'checkpoint loaded from {fn}') \n wandb.init(id=data['run_id'], resume='allow')\n return data['model'], data['trace'], data['dataset_args'], data['model_args'], data['pymc3_args'], data['run_id'] \n\ndef load_dataset(dataset_sel, counts_fp=None, annotation_fp=None, annotation_subset=None, seed=None,\n data_seed = None, sig_defs_fp=None, sim_S=None, sim_N=None, sim_I=None, sim_tau_hyperprior=None,\n sim_J=None, sim_K=None, sim_alpha_bias=None, sim_psi_bias=None, sim_gamma_bias=None, sim_beta_bias=None):\n # load counts, or simulated data - as specified by dataset_sel\n # seed -> rng as per https://albertcthomas.github.io/good-practices-random-number-generators/\n \n if dataset_sel == 'load_counts':\n dataset = load_counts(counts_fp)\n annotation = pd.read_csv(annotation_fp, index_col = 0, header = 0)\n dataset, annotation = subset_samples(dataset, annotation, annotation_subset)\n return dataset, annotation\n \n elif dataset_sel == 'sim_from_sigs':\n sig_defs = load_sigs(sig_defs_fp)\n dataset, sim_params = sim_from_sigs(sig_defs, sim_tau_hyperprior, sim_S, sim_N, sim_I, seed)\n return dataset, sim_params\n \n elif dataset_sel == 'sim_parametric':\n dataset, sim_params = sim_parametric(sim_J,sim_K,sim_S,sim_N,sim_alpha_bias,sim_psi_bias,sim_gamma_bias,sim_beta_bias,seed)\n return dataset, sim_params\n \n else:\n assert False, 'dataset selection not recognized'\n \ndef load_datasets(dataset_args):\n yargs = dataset_args.copy()\n ca = [load_dataset(counts_fp = j[0], annotation_fp = j[1], **yargs) for j in zip(yargs.pop('counts_fp'), yargs.pop('annotation_fp'))]\n counts = pd.concat([c[0] for c in ca ])\n annotation = pd.concat([a[1] for a in ca])\n return counts, annotation\n\ndef split_by_count(data, fraction, rng):\n # assumes data is a pandas df\n\n frac1 = data.apply(lambda r: rng.choice( np.repeat(np.arange(96), r), int(fraction*r.sum()), replace = False) , axis = 1)\n frac1 = pd.DataFrame(frac1.apply(lambda r: np.histogram(r, bins=96, range=(0, 96))[0]).to_list(), \n index = data.index, columns = data.columns)\n #frac1 = (data * fraction).astype(int)\n #frac1 = frac1.apply(lambda r: np.histogram(r, bins=96, range=(0, 96))[0], axis = 1, result_type='expand')\n #frac1.columns = data.columns\n frac2 = data - frac1\n assert all(frac2 >= 0) and all(frac1 >= 0)\n assert np.all(data == frac1 + frac2), 'Splitting failed'\n return frac1, frac2\n\ndef split_by_S(data, fraction, rng):\n # assumes data is a pandas df with an index\n frac1 = data.sample(frac=fraction, random_state=np.random.RandomState(rng.bit_generator))\n frac2 = data.drop(frac1.index)\n return frac1, frac2\n\ndef split_data(counts, S_frac = 0.9, c_frac = 0.8, rng=np.random.default_rng()):\n # get train/val/test split\n trn, tst = split_by_S(counts, S_frac, rng)\n trn, val = split_by_count(trn, c_frac, rng)\n tst1, tst2 = split_by_count(tst, c_frac, rng)\n return trn, val, tst1, tst2\n\ndef get_tau(phi, eta):\n assert len(phi.shape) == 2 and len(eta.shape) == 3\n tau = np.einsum('jpc,kpm->jkpmc', phi.reshape((-1,2,16)), eta).reshape((-1,96))\n return tau\n\ndef get_phi(sigs):\n # for each signature in sigs, get the corresponding phi\n wrapped = sigs.reshape(-1, 2, 3, 16)\n phi = wrapped.sum(2).reshape(-1,32)\n return phi\n\ndef get_eta(sigs):\n # for each signature in sigs, get the corresponding eta \n wrapped = sigs.reshape(-1, 6, 16)\n eta = wrapped.sum(2).reshape(-1,3)\n # notrmalize such that etaC and etaT sum to 1 respectively.\n eta = (eta/eta.sum(1)[:,None]).reshape(-1,6)\n return eta\n\ndef flatten_eta(eta): # eta pkm -> kc\n warnings.warn('Eta no longer constructed as pkm - use reshape instead', DeprecationWarning)\n return np.moveaxis(eta,0,1).reshape(-1, 6)\n\ndef alr(x, e=1e-12):\n '''\n additive log ratio\n x is a NxD matrix\n >>> x = np.array([.1, .3, .4, .2])\n >>> alr(x)\n array([ 1.09861229, 1.38629436, 0.69314718])\n '''\n # add small value for stability in log\n x = x + e\n return (np.log(x) - np.log(x[...,-1]).reshape(-1,1))[:,0:-1]\n\ndef alr_inv(y):\n '''\n inverse alr transform\n y is a Nx(D-1) matrix\n >>> x = np.array([.1, .3, .4, .2])\n >>> alr_inv(alr(x))\n array([ 0.1, 0.3, 0.4, 0.2])\n '''\n if y.ndim == 1: y = y.reshape(1,-1)\n return softmax(np.hstack([y, np.zeros((y.shape[0], 1)) ]), axis = 1)\n\ndef kmeans_alr(data, nsig, rng=np.random.default_rng()):\n #https://github.com/scikit-learn/scikit-learn/issues/16988#issuecomment-817375063\n km = k_means(alr(data), nsig, random_state=np.random.RandomState(rng.bit_generator))\n return alr_inv(km[0])\n\ndef alp_B(data, B):\n return (data * np.log(B)).sum() / data.sum()\n\ndef mult_ll(x, p):\n # x and p should both be same dimensions; Sx96\n return loggamma(x.sum(1) + 1) - loggamma(x+1).sum(1) + (x * np.log(p)).sum(1)\n\ndef lap_B(data, Bs):\n # Bs should be shape DxSx96 where D is the number of posterior samples\n # use logsumexp for stability\n assert Bs.ndim == 3, 'expected multiple trials for B'\n return logsumexp(np.vstack([mult_ll(data, B) for B in Bs]).sum(1)) - np.log(Bs.shape[0])\n\ndef profile_sigs(sigs, refsigs, thresh = 0.9, refidx = None):\n # return mapping of sigs to similar refsigs\n \n if isinstance(refsigs, pd.core.frame.DataFrame) and refsigs.index is not None:\n refidx = refsigs.index\n elif refidx is None:\n refidx = pd.Index([f'refsig_{i}' for i in range(0,refsigs.shape[0])])\n \n sim = cosine_similarity(sigs, refsigs)\n closest_dist = np.max(sim, axis=1)\n closest = refidx[np.argmax(sim, axis=1)]\n above_thresh = [str(refidx[x].to_numpy()) for x in sim > thresh]\n \n df=pd.DataFrame.from_dict({'inferred signature': [f'sig_{i}' for i in range(0,sigs.shape[0])],\n 'closest reference signature':closest, \n 'dist to closest': closest_dist,\n f'reference signatures with >{thresh} similarity': above_thresh\n })\n df.index = [f'sig_{i}' for i in range(0,sigs.shape[0])]\n return df\n\ndef load_cosmic_V3():\n \"\"\"Return a dataframe of COSMIC V3 signature definitions\n\n Contains:\n 96 mutation type columns of non-null float64\n 78 rows of signature definitions, rows sum to 1\n\n \"\"\"\n # This is a stream-like object. If you want the actual info, call\n # stream.read()\n f = pkg_resources.resource_filename(__name__, 'data/COSMIC_v3.2_SBS_GRCh37.txt')\n return load_sigs(f)\n\ndef load_default_config():\n \"\"\"Return a default configuration dict\n\n Contains:\n 96 mutation type columns of non-null float64\n 78 rows of signature definitions, rows sum to 1\n\n \"\"\"\n # This is a stream-like object. If you want the actual info, call\n # stream.read()\n f = pkg_resources.resource_filename(__name__, 'config/default.yaml')\n return load_config(f)\n\n", "meta": {"hexsha": "2224b5c934b53e1210212e23dce166a567667d23", "size": 12846, "ext": "py", "lang": "Python", "max_stars_repo_path": "damuta/utils.py", "max_stars_repo_name": "morrislab/damuta", "max_stars_repo_head_hexsha": "48e3146b610397e1c3020b26f0d010b38901452b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-11-02T19:56:02.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-20T19:15:48.000Z", "max_issues_repo_path": "damuta/utils.py", "max_issues_repo_name": "morrislab/damuta", "max_issues_repo_head_hexsha": "48e3146b610397e1c3020b26f0d010b38901452b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "damuta/utils.py", "max_forks_repo_name": "morrislab/damuta", "max_forks_repo_head_hexsha": "48e3146b610397e1c3020b26f0d010b38901452b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-29T01:13:51.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-29T01:13:51.000Z", "avg_line_length": 40.0186915888, "max_line_length": 144, "alphanum_fraction": 0.6574809279, "include": true, "reason": "import numpy,from scipy,import pymc3", "num_tokens": 3505, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5888891451980403, "lm_q2_score": 0.3380771241500058, "lm_q1q2_score": 0.19908994865170865}} {"text": "import errno # handle errors\nimport logging # log errors\nimport os\nimport sys\nfrom pathlib import Path # filesystem related stuff\nimport re # regular expression to find resolution from\n\nimport numpy as np\nfrom astropy.wcs import WCS # handle astronomic coordinates\nfrom astropy.io import fits # read data from .fits files.\nfrom astropy.io import ascii\nfrom astropy.coordinates import SkyCoord, match_coordinates_sky, Angle\nfrom reproject import reproject_interp\n\nfrom astropy.visualization import simple_norm\nimport matplotlib.pyplot as plt\n\nfrom .constants import two_column, arcsec_to_pixel\n\n\nlogger = logging.getLogger(__name__)\n\nclass ParameterClass:\n def __init__(self,name,**kwargs):\n self.name = name\n for k,v in kwargs.items():\n setattr(self,k,v)\n\nclass ReadLineMaps:\n '''load a fits file from the PHANGS--MUSE DAP (the line maps)\n \n Read the linemaps from the PHANGS-MUSE DAP. You only need to specify\n the folder and the name of the galaxy. The function will pick the \n correct file and read all the specified extensions. If the file is \n from the copt, it will detect the resolution from the filename and\n save it. \n\n It will also try to read some auxiliary files that should be in \n folder named `AUXILIARY` (next to `folder`). This folder should \n contain star masks, PSF maps (FWHM of each pointing) and an alternative\n [OIII]5007 map (not measured from a fit).\n '''\n \n def __init__(self,folder,name,extensions=[],**kwargs):\n '''\n Parameters\n ----------\n \n folder : string\n name of the folder with the data for one object. This folder\n must contain a file with name \"FolderName_MAPS.fits\" and \n possibly some additional files\n\n extensions : list\n list of extensions that are read. Each element must be a valid \n extension in the previously defined fits file (the actual name\n of the extension is `ExtensionName_FLUX` and \n `ExtensionName_FLUX_ERR` but they are automaticly completed).\n\n **kwargs : \n any additional properties of the galaxy (like E(B-V) or \n parameters used during the analysis). They are saved as an \n attribute under the given name.\n '''\n \n # we simply use the first file in the folder that starts with name\n self.name = name\n self.filename = next(folder.glob(f'{name}*.fits'))\n self.copt_res = np.float(next(iter(re.findall('-(.*)asec',self.filename.stem)), 'nan'))\n\n logger.info(f'loading {self.filename.name}')\n\n\n self.lines = []\n \n # we save the additional parameters\n for k,v in kwargs.items():\n setattr(self,k,v)\n\n if not self.filename.is_file():\n raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), self.filename)\n \n # make sure lines is a list\n lines = [extensions] if not isinstance(extensions, list) else extensions\n \n #==============================================================\n # load the main DAP products\n #==============================================================\n with fits.open(self.filename) as hdul:\n \n # if no lines are given, we read in all lines\n if len(lines)==0:\n lst = hdul.info(output=False)\n lines = [x[1].split('_')[0] for x in lst if x[1].endswith('_FLUX')]\n\n # save the white-light image\n header = hdul[f'FLUX'].header\n setattr(self,'header',header)\n setattr(self,'wcs',WCS(header))\n setattr(self,'shape',(header['NAXIS2'],header['NAXIS1']))\n setattr(self,'V_STARS',hdul['V_STARS'].data)\n setattr(self,'stellar_mass',hdul['STELLAR_MASS_DENSITY'].data)\n setattr(self,'stellar_mass_err',hdul['STELLAR_MASS_DENSITY_err'].data)\n setattr(self,'Ebv_stars',hdul['EBV_STARS'].data)\n setattr(self,'whitelight',hdul['FLUX'].data)\n setattr(self,'whitelight_err',hdul['SNR'].data)\n\n for line in lines:\n # save the main data and the associated error\n setattr(self,line,hdul[f'{line}_FLUX'].data)\n setattr(self,f'{line}_err',hdul[f'{line}_FLUX_ERR'].data) \n setattr(self,f'{line}_SIGMA',np.sqrt(hdul[f'{line}_SIGMA'].data**2 - hdul[f'{line}_SIGMA_CORR'].data**2))\n setattr(self,f'{line}_SIGMA_ERR',hdul[f'{line}_SIGMA_ERR'])\n\n # append to list of available lines\n self.lines.append(line)\n\n #==============================================================\n # load auxiliary maps\n #==============================================================\n \n # and one where OIII is not measured by fitting\n OIII_map_file = folder.parent / 'AUXILIARY' / 'oiii_from_cubes' / f'{self.name}_oiii_flux.fits'\n if OIII_map_file.is_file():\n logger.info(f'replacing OIII5006 map')\n # replace the old line maps with the new one\n setattr(self,'OIII5006_DAP',getattr(self,'OIII5006'))\n setattr(self,'OIII5006_DAP_err',getattr(self,'OIII5006_err'))\n data = fits.getdata(OIII_map_file,0)\n setattr(self,'OIII5006',data)\n else:\n logger.warn(f'\"{self.name}_oiii_flux.fits\" does not exists.')\n\n # star mask and seeing map (for PSF)\n star_mask_file = folder.parent / 'AUXILIARY' / 'starmasks' / f'{self.name}_starmask.fits'\n seeing_map_file = folder.parent / 'AUXILIARY' / 'seeing_maps' / f'{self.name}_seeing.fits'\n\n for filename, description in zip([star_mask_file,seeing_map_file],[\"star_mask\",\"PSF\"]):\n\n if filename.is_file():\n with fits.open(filename) as hdul:\n data = hdul[0].data\n \n if self.shape != data.shape: \n logger.warning(f'{description} map has different shape. Reprojecting')\n data,_ = reproject_interp(hdul,self.header)\n\n # star_mask ist 0 or 1 (even for interpolated pixels)\n if description=='star_mask':\n data = np.round(data,0)\n elif description=='PSF':\n data = np.round(data,2)\n\n setattr(self,description,data)\n\n else:\n logger.warning(f'no {description} available')\n\n if not hasattr(self,'star_mask'):\n self.star_mask = np.zeros_like(self.OIII5006)\n\n if not hasattr(self,'PSF'):\n # for DR2 galaxies where no PSF data exists we assume FWHM=1\" for all pointings\n logger.warning('creating 1\" seeing map')\n self.PSF = np.ones_like(self.OIII5006)\n self.PSF[np.isnan(self.OIII5006)] = np.nan\n self.PSF *= arcsec_to_pixel \n logger.info(f'galaxy has {len(np.unique(self.PSF[~np.isnan(self.PSF)]))} pointings')\n\n logger.info(f'file loaded with {len(self.lines)} extensions')\n\n def __repr__(self):\n '''create an overview of the available attributes'''\n \n string = ''\n for k,v in self.__dict__.items():\n if type(v) in [str,int,float]:\n string += f'{k}: {v}\\n'\n else:\n string += k + '\\n'\n \n return string\n\n def plot(self,line):\n '''plot a single emission line'''\n\n if not hasattr(self,line):\n raise AttributeError(f'Object has no map {line}')\n \n data = getattr(self,line)\n\n fig = plt.figure(figsize=(two_column,two_column/1.618))\n ax = fig.add_subplot(projection=self.wcs)\n\n norm = simple_norm(data,clip=False,percent=99)\n ax.imshow(data,norm=norm)\n plt.show()\n \n #return fig \n\n# save lines to individual .fits file\ndef split_fits(filename,extensions):\n '''\n \n Parameters\n ----------\n filename: \n a fits file containing lines in multiple extensions\n\n extensions: \n the extensions to save as single files\n '''\n \n # make sure lines is a list\n extensions = [extensions] if not isinstance(extensions, list) else extensions\n \n if not os.path.isfile(filename):\n raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), filename)\n print(f'splitting {filename} into seperate files')\n \n with fits.open(filename) as hdul:\n for ext in extensions:\n data = hdul[f'{ext}']\n data.writeto(f'{ext}.fits',overwrite=True)\n \n print(f'{len(extensions)} extension(s) saved to seperate file(s)')\n\n\nclass ReadMosaicFiles:\n\n def __init__(self,filename):\n '''open the large MOSAIC files in python\n\n the MOSAIC files contain the full spectral information \n '''\n\n logger.warning('not yet implemented')\n sys.exit()\n\n with fits.open(filename,memmap=True,mode='denywrite') as hdul:\n wcs = WCS(hdul[1].header)\n data = hdul[1].data\n \n print(data.shape)\n print(hdul[1].header)\n #data = hdul[f'{line}_FLUX']\n #data.writeto(f'{line}.fits',overwrite=True)\n\n\ndef write_table(table,name,filename):\n '''write the table to a file\n\n this will create a `.tex` file and a machine readable file\n\n to read this file use\n f = basedir / 'data' / 'catalogues' / f'{galaxy.name}_{typ}_candidates.txt'\n ascii.read(f,format='fixed_width_two_line',position_char='=')\n '''\n\n threshold = '0.7\"'\n\n table['RA'],table['DEC'] = zip(*[x.split(' ') for x in table['SkyCoord'].to_string(style='hmsdms',precision=2)])\n table['Galaxy'] = name\n\n if name =='NGC0628':\n logging.info('comparing to existing studies')\n from .load_references import NGC628\n cat = {'Kreckel PN':'K17;','Herrmann PN':'H08;','Kreckel SNR':'K17s;'}\n ID, angle, Quantity = match_coordinates_sky(NGC628['SkyCoord'],table['SkyCoord'])\n table['match'] = np.empty(len(table),dtype='U12')\n for i,a,row in zip(ID,angle,NGC628):\n if a.__lt__(Angle('0.8\"')):\n table['match'][i] += cat[row['source']]\n\n if name =='NGC3351':\n logging.info('comparing to existing studies')\n from .load_references import pn_NGC3351_ciardullo\n ID, angle, Quantity = match_coordinates_sky(pn_NGC3351_ciardullo['SkyCoord'],table['SkyCoord'])\n table['match'] = np.empty(len(table),dtype='U12')\n for i,a,row in zip(ID,angle,pn_NGC3351_ciardullo):\n if a.__lt__(Angle('0.8\"')):\n table['match'][i] += 'C02;'\n\n if name =='NGC3627':\n logging.info('comparing to existing studies')\n from .load_references import pn_NGC3627_ciardullo\n ID, angle, Quantity = match_coordinates_sky(pn_NGC3627_ciardullo['SkyCoord'],table['SkyCoord'])\n table['match'] = np.empty(len(table),dtype='U12')\n for i,a,row in zip(ID,angle,pn_NGC3627_ciardullo):\n if a.__lt__(Angle('0.8\"')):\n table['match'][i] += 'C02;'\n\n if name =='NGC5068':\n logging.info('comparing to existing studies')\n from .load_references import pn_NGC5068_herrmann\n ID, angle, Quantity = match_coordinates_sky(pn_NGC5068_herrmann['SkyCoord'],table['SkyCoord'])\n table['match'] = np.empty(len(table),dtype='U12')\n for i,a,row in zip(ID,angle,pn_NGC5068_herrmann):\n if a.__lt__(Angle('0.8\"')):\n table['match'][i] += 'H08;'\n\n for col in ['OIII5006','HA6562','NII6583','SII']:\n table[col][np.where(table[col] sign)\n for i,row in enumerate(tbl_out):\n if not row['HA6562_detection']:\n row['OIII/Ha'] += '>'\n row['OIII/Ha'] += f\"{row['OIII5006'] / row['HA6562']:.2f}\"\n row['d(OIII/Ha)'] = f\"{row['OIII5006'] / row['HA6562'] * np.sqrt( (row['HA6562_err'] / row['HA6562'])**2 + (row['OIII5006_err'] / row['OIII5006'])**2):.2f}\"\n\n if not row['HA6562_detection'] and not row['NII6583_detection']:\n row['Ha/NII'] = '...'\n row['d(Ha/NII)'] = '...'\n elif not row['HA6562_detection']:\n row['Ha/NII'] = '<'\n row['Ha/NII'] += f\"{row['HA6562'] / row['NII6583']:.2f}\"\n row['d(Ha/NII)'] = f\"{row['HA6562'] / row['NII6583'] * np.sqrt( (row['NII6583_err'] / row['NII6583'])**2 + (row['HA6562_err'] / row['HA6562'])**2):.2f}\"\n elif not row['NII6583_detection']:\n row['Ha/NII'] = '>'\n row['Ha/NII'] += f\"{row['HA6562'] / row['NII6583']:.2f}\"\n row['d(Ha/NII)'] = f\"{row['HA6562'] / row['NII6583'] * np.sqrt( (row['NII6583_err'] / row['NII6583'])**2 + (row['HA6562_err'] / row['HA6562'])**2):.2f}\"\n else:\n row['Ha/NII'] += f\"{row['HA6562'] / row['NII6583']:.2f}\"\n row['d(Ha/NII)'] = f\"{row['HA6562'] / row['NII6583'] * np.sqrt( (row['NII6583_err'] / row['NII6583'])**2 + (row['HA6562_err'] / row['HA6562'])**2):.2f}\"\n\n if not row['HA6562_detection'] and not row['SII_detection']:\n row['Ha/SII'] = '...'\n row['d(Ha/SII)'] = '...'\n elif not row['HA6562_detection']:\n row['Ha/SII'] += '<'\n row['Ha/SII'] += f\"{row['HA6562'] / row['SII']:.2f}\"\n row['d(Ha/SII)'] = f\"{row['HA6562'] / row['SII'] * np.sqrt( (row['HA6562_err'] / row['HA6562'])**2 + (row['SII_err'] / row['SII'])**2):.2f}\"\n elif not row['SII_detection']:\n row['Ha/SII'] += '>'\n row['Ha/SII'] += f\"{row['HA6562'] / row['SII']:.2f}\"\n row['d(Ha/SII)'] = f\"{row['HA6562'] / row['SII'] * np.sqrt( (row['HA6562_err'] / row['HA6562'])**2 + (row['SII_err'] / row['SII'])**2):.2f}\"\n else:\n row['Ha/SII'] += f\"{row['HA6562'] / row['SII']:.2f}\"\n row['d(Ha/SII)'] = f\"{row['HA6562'] / row['SII'] * np.sqrt( (row['HA6562_err'] / row['HA6562'])**2 + (row['SII_err'] / row['SII'])**2):.2f}\"\n\n\n tbl_out['mOIII'].info.format = '%.2f' \n tbl_out['dmOIII'].info.format = '%.2f' \n tbl_out['v_SIGMA'].info.format = '%.2f' \n\n tbl_out.rename_columns(['name','RA','DEC','v_SIGMA'],['ID','R.A.','Dec.','sigmaV'])\n tbl_out = tbl_out[['Galaxy','ID','R.A.','Dec.','mOIII','dmOIII','OIII/Ha','d(OIII/Ha)',\n 'Ha/NII','d(Ha/NII)','Ha/SII','d(Ha/SII)','sigmaV']]\n\n with open((filename / f'{galaxy.name}_{typ}_candidates').with_suffix('.txt'),'w',newline='\\n') as f:\n ascii.write(tbl_out,f,format='fixed_width_two_line',overwrite=True,delimiter_pad=' ',position_char='=')\n\n \n mOIII = []\n OIIIHA = []\n HANII = []\n HASII = []\n for row in tbl_out:\n if row[\"mOIII\"] == '...':\n mOIII.append('...')\n else:\n mOIII.append(f'{row[\"mOIII\"]:.2f} $\\pm$ {row[\"dmOIII\"]:.2f}')\n if row[\"OIII/Ha\"] == '...':\n OIIIHA.append('...')\n else:\n OIIIHA.append(f'{row[\"OIII/Ha\"]} $\\pm$ {row[\"d(OIII/Ha)\"]}')\n if row[\"Ha/NII\"] == '...':\n HANII.append('...')\n else:\n HANII.append(f'{row[\"Ha/NII\"]} $\\pm$ {row[\"d(Ha/NII)\"]}')\n if row[\"Ha/SII\"] == '...':\n HASII.append('...')\n else:\n HASII.append(f'{row[\"Ha/SII\"]} $\\pm$ {row[\"d(Ha/SII)\"]}')\n \n tbl_out['$m_\\\\OIII$'] = mOIII\n tbl_out['$\\\\OIII/\\\\HA$'] = OIIIHA\n tbl_out['$\\\\HA/\\\\NII$'] = HANII\n tbl_out['$\\\\HA/\\\\SII$'] = HASII\n tbl_out.rename_column('sigmaV',f'$\\sigma_V$')\n tbl_out = tbl_out[['ID','R.A.','Dec.','$m_\\\\OIII$','$\\\\OIII/\\\\HA$',\n '$\\\\HA/\\\\NII$','$\\\\HA/\\\\SII$',f'$\\sigma_V$']]\n\n with open((filename / f'{galaxy.name}_{typ}_candidates').with_suffix('.tex'),'w',newline='\\n') as f:\n ascii.write(tbl_out,f,Writer=ascii.Latex, latexdict=latexdict,overwrite=True)\n\n\n # shorten column names for machine readable table\n #for col in tbl_out.colnames:\n # tbl_out.rename_column(col,col.translate({ord(s): None for s in '$\\_'}))\n\n\n \n logger.info(f'table saved to files (for {galaxy.name})')\n\n\ndef read_catalogue(filename):\n\n catalogue = ascii.read(filename,format='fixed_width_two_line',delimiter_pad=' ',position_char='=')\n catalogue['SkyCoord'] = SkyCoord(catalogue['R.A.'],catalogue['Dec.'])\n\n return catalogue", "meta": {"hexsha": "d818b650506c0904451588e0d448e21ad3b277ac", "size": 23333, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/pnlf/io.py", "max_stars_repo_name": "fschmnn/pymuse", "max_stars_repo_head_hexsha": "91e97d03a3eb1ccc02131f4e731e6bb5df66772c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-05-09T21:24:29.000Z", "max_stars_repo_stars_event_max_datetime": "2020-05-27T15:11:31.000Z", "max_issues_repo_path": "src/pnlf/io.py", "max_issues_repo_name": "fschmnn/pymuse", "max_issues_repo_head_hexsha": "91e97d03a3eb1ccc02131f4e731e6bb5df66772c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/pnlf/io.py", "max_forks_repo_name": "fschmnn/pymuse", "max_forks_repo_head_hexsha": "91e97d03a3eb1ccc02131f4e731e6bb5df66772c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.8904847397, "max_line_length": 168, "alphanum_fraction": 0.5515364505, "include": true, "reason": "import numpy,from astropy", "num_tokens": 6385, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5273165382362518, "lm_q2_score": 0.37754066879814546, "lm_q1q2_score": 0.19908343851403734}} {"text": "# -*- coding: utf-8 -*-\n# @Author : Daniel Ordonez\n# @email : daniels.ordonez@gmail.com\n\nfrom typing import Optional\n\nimport numpy as np\nfrom numpy import ndarray\n\nfrom .slip_model import SlipModel, THETA, X\n\n\nclass SlipGaitCycle(object):\n\n def __init__(self, slip_model: SlipModel, t_flight: ndarray, flight_cartesian_traj: ndarray, t_stance: ndarray,\n stance_polar_traj: ndarray, target_to_state: Optional[ndarray] = None,\n optimization_cost: Optional[float] = np.NaN):\n \"\"\"\n Class representing a Slip gait cycle composed of:\n - a flight phase: starting with the take-off (TO) event of a previous gait cycle and ending at the present cycle\n touch-down (TD) event. And,\n - a stance phase: starting at the present cycle TD event and ending with the cycle's TO event.\n It is assumed the gait cycle starts with a flight phase and ends with the stance phase.\n :param slip_model: SLIP model providing the `m`, `k` and `r0` parameters.\n :param t_flight: (F,) Discrete time array during flight phase\n :param flight_cartesian_traj: (6, F) Cartesian state [x, x', x'', z, z', z''] of the SLIP CoM at each time\n during the flight phase\n :param t_stance: (S,) Discrete time array during flight phase\n :param stance_polar_traj: (4, S) Polar state [theta,theta',r,r'] of the SLIP CoM at each time during\n the stance phase, in a reference frame centered at the foot contact point with the ground.\n :param target_to_state: (6,) Optional cartesian target take-off state, used for control. Use np.NaN in the\n dimensions of the cartesian state that are irrelevant for control (e.g. z''=np.NaN)\n :param optimization_cost: Optional scalar indicating the optimization cost of the gait cycle. By default is set \n to be the euclidean norm of the error between the real TO state and the target TO state (ignoring np.NaNs dims) \n \"\"\"\n self.slip_model = slip_model\n if not flight_cartesian_traj.shape[0] == 6:\n raise AssertionError(\"Expected cartesian trajectory [x, x', x'', z, z', z'']\")\n else:\n if not len(t_flight) == flight_cartesian_traj.shape[1]:\n raise AssertionError('Invalid flight trajectory')\n else:\n self.t_flight = t_flight\n self.flight_cartesian_traj = flight_cartesian_traj\n assert stance_polar_traj.shape[0] == 4, \"Expected stance polar trajectory [theta, theta', r, r']\"\n assert len(t_stance) == stance_polar_traj.shape[1], 'Invalid flight trajectory'\n self.t_stance = t_stance\n self.stance_polar_traj = stance_polar_traj\n self._stance_cartesian_traj = None\n self.touch_down_angle = self.stance_polar_traj[(THETA, 0)]\n self.take_off_angle = self.stance_polar_traj[(THETA, -1)]\n self.foot_contact_pos = self.flight_cartesian_traj[(X, -1)] - self.slip_model.r0 * np.cos(\n self.touch_down_angle)\n assert self.t_flight[(-1)] == self.t_stance[\n 0], 'Touch down state should be in flight and stance trajectories'\n self.target_to_state = np.array(target_to_state) if target_to_state is not None else np.ones((6,)) * np.NaN\n self.optimization_cost = optimization_cost\n if not np.all(np.isnan(self.target_to_state)):\n self.target_to_state = np.ma.array((self.target_to_state), mask=(np.isnan(self.target_to_state)))\n if np.isnan(optimization_cost):\n self.optimization_cost = np.linalg.norm(self.take_off_state - target_to_state)\n\n @property\n def stance_cartesian_traj(self) -> ndarray:\n if self._stance_cartesian_traj is None:\n self._stance_cartesian_traj = self.slip_model.polar_to_cartesian(trajectory=(self.stance_polar_traj),\n foot_contact_pos=(self.foot_contact_pos))\n return self._stance_cartesian_traj\n\n @property\n def take_off_state(self) -> ndarray:\n if self._stance_cartesian_traj is None:\n return self.slip_model.polar_to_cartesian((self.stance_polar_traj[:, -1]),\n foot_contact_pos=(self.foot_contact_pos))\n else:\n return np.array(self.stance_cartesian_traj[:, -1])\n\n @property\n def take_off_state_polar(self):\n return np.array(self.stance_polar_traj[:, -1])\n\n @property\n def touch_down_state(self):\n if self._stance_cartesian_traj is None:\n return self.slip_model.polar_to_cartesian((self.stance_polar_traj[:, 0]),\n foot_contact_pos=(self.foot_contact_pos))\n else:\n return np.array(self.stance_cartesian_traj[:, 0])\n\n @property\n def touch_down_state_polar(self):\n return np.array(self.stance_polar_traj[:, 0])\n\n @property\n def prev_take_off_state(self):\n return np.array(self.flight_cartesian_traj[:, 0])\n\n @property\n def start_time(self):\n return float(self.t_flight[0])\n\n @property\n def end_time(self):\n return float(self.t_stance[(-1)])\n\n def offset_initial_time(self, time_offset):\n self.t_flight += time_offset\n self.t_stance += time_offset\n\n def __str__(self):\n return 'Cost:%.2f TD:%.1f[deg] TO:%.1f[deg] time:[%.2f, %.2f]' % (\n self.optimization_cost, np.rad2deg(self.touch_down_angle), np.rad2deg(self.take_off_angle),\n self.start_time, self.end_time)\n\n def __repr__(self):\n return str(self)\n\n\nclass SlipGaitCycleCtrl(SlipGaitCycle):\n\n def __init__(self, slip_model, t_flight, flight_cartesian_traj, t_stance, stance_passive_polar_traj=None,\n stance_ctrl_polar_traj=None, control_signal=None, target_to_state=None, optimization_cost=np.NaN,\n ctrl_kwargs=None):\n \"\"\"\n Class representing a Controlled Slip gait Cycle. This assumes the SLIP model is an actuated extended version\n (see \"Learning to run naturally: Guiding policies with the Spring-Loaded Inverted Pendulum\" Chap 4.1) where the\n control inputs are a resting leg length displacement `r_delta` (axial force control) and a hip torque `tau_hip`.\n The main difference with the parent class it that `SlipGaitCycleCtrl` stores also a `control_signal` and if\n provided an additional `SlipGaitCycle` instance representing the passive dynamical response of SLIP (useful for\n plotting animation and intuition).\n :param slip_model: SLIP model providing the `m`, `k` and `r0` parameters.\n :param t_flight: (F,) Discrete time array during flight phase\n :param flight_cartesian_traj: (6, F) Cartesian state [x,x',x'',z,z',z''] of the SLIP CoM at each time during\n the flight phase\n :param t_stance: (S,) Discrete time array during flight phase\n :param stance_passive_polar_traj: (4, S) Passive Polar state [theta,theta',r,r'] of the SLIP CoM at each time \n during the stance phase, in a reference frame centered at the foot contact point with the ground.\n :param stance_ctrl_polar_traj: (4, S) Controlled Polar state [theta,theta',r,r'] of the SLIP CoM at each time \n during the stance phase, in a reference frame centered at the foot contact point with the ground.\n :param control_signal: (2, S) Control input signal assumed to hold ()\n :param target_to_state: (6,) Optional cartesian target take-off state, used for control. Use np.NaN in the\n dimensions of the cartesian state that are irrelevant for control (e.g. z''=np.NaN)\n :param optimization_cost: Optional scalar indicating the optimization cost of the gait cycle. By default is set\n to be the euclidean norm of the error between the real TO state and the target TO state (ignoring np.NaNs dims)\n :param ctrl_kwargs: Dictionary holding controller-related keyword arguments.\n \"\"\"\n self.control_signal = control_signal\n self.optimization_cost = optimization_cost\n self.control_signal = control_signal\n self.ctrl_kwargs = ctrl_kwargs\n super(SlipGaitCycleCtrl, self).__init__(slip_model, t_flight, flight_cartesian_traj, t_stance,\n stance_polar_traj=stance_ctrl_polar_traj,\n target_to_state=target_to_state)\n if stance_passive_polar_traj is not None:\n self.passive_gait_cycle = SlipGaitCycle(slip_model, t_flight, flight_cartesian_traj, t_stance,\n stance_polar_traj=stance_passive_polar_traj)\n else:\n self.passive_gait_cycle = None\n\n @property\n def stance_cartesian_traj(self) -> ndarray:\n if self._stance_cartesian_traj is None:\n self._stance_cartesian_traj = self.slip_model.polar_to_cartesian(trajectory=self.stance_polar_traj,\n control_signal=self.control_signal,\n foot_contact_pos=self.foot_contact_pos)\n return self._stance_cartesian_traj\n\n @property\n def take_off_state(self) -> ndarray:\n if self._stance_cartesian_traj is None:\n return self.slip_model.polar_to_cartesian(self.stance_polar_traj[:, -1],\n control_signal=self.control_signal[:, -1],\n foot_contact_pos=self.foot_contact_pos)\n else:\n return np.array(self.stance_cartesian_traj[:, -1])\n\n @property\n def touch_down_state(self):\n if self._stance_cartesian_traj is None:\n return self.slip_model.polar_to_cartesian(self.stance_polar_traj[:, 0],\n control_signal=self.control_signal[:, 0],\n foot_contact_pos=self.foot_contact_pos)\n else:\n return np.array(self.stance_cartesian_traj[:, 0])\n", "meta": {"hexsha": "b46c22be194037c776296cf2f12f02000bf41c98", "size": 10233, "ext": "py", "lang": "Python", "max_stars_repo_path": "slip_control/slip/slip_gait_cycle.py", "max_stars_repo_name": "Danfoa/slip_control", "max_stars_repo_head_hexsha": "66dd4f33fefc51548a9461cdda75be95fb76c7b5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-01-26T16:04:15.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-26T16:04:15.000Z", "max_issues_repo_path": "slip_control/slip/slip_gait_cycle.py", "max_issues_repo_name": "Danfoa/slip_control", "max_issues_repo_head_hexsha": "66dd4f33fefc51548a9461cdda75be95fb76c7b5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "slip_control/slip/slip_gait_cycle.py", "max_forks_repo_name": "Danfoa/slip_control", "max_forks_repo_head_hexsha": "66dd4f33fefc51548a9461cdda75be95fb76c7b5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-01-19T12:48:36.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-19T12:48:36.000Z", "avg_line_length": 55.3135135135, "max_line_length": 121, "alphanum_fraction": 0.6442880876, "include": true, "reason": "import numpy,from numpy", "num_tokens": 2273, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5273165382362518, "lm_q2_score": 0.37754066879814546, "lm_q1q2_score": 0.19908343851403734}} {"text": "# -*- coding: utf-8 -*-\nimport theano\nimport theano.tensor as T\nimport numpy as np\nimport pandas as pd\nfrom collections import OrderedDict\n\nINIT_RANGE = 0.01\n\n\ndef uniform(lb, ub, size):\n \"\"\"\n\n :param lb: lower bound\n :param ub: upper bound\n :param size: tensor shape\n :return:\n \"\"\"\n return np.array(np.random.uniform(low=lb, high=ub, size=size), dtype='float32')\n\n\ndef glorot_uniform(size):\n \"\"\"\n glorot uniform initializer\n \"\"\"\n if len(size) == 1:\n values = np.zeros_like(size)\n else:\n scale = np.sqrt(6.0 / np.sum(size))\n values = np.random.uniform(low=-scale, high=scale, size=size)\n return values.astype('float32')\n\n\ndef orthogonal(size):\n \"\"\"\n equivalent to orthogonal_init but return numpy array\n \"\"\"\n if len(size) == 1:\n values = np.zeros_like(size)\n else:\n a = np.random.normal(loc=0.0, scale=1.0, size=size)\n # reconstruction based on reduced SVD\n u, _, v = np.linalg.svd(a, full_matrices=False)\n q = u if u.shape == size else v\n q = q.reshape(size)\n values = q\n return values.astype(\"float32\")\n\n\ndef zeros(size):\n \"\"\"\n generate zero vector / tensor\n :param size: size\n :return:\n \"\"\"\n return np.array(np.zeros(shape=size), dtype='float32')\n\n\ndef ones(size):\n \"\"\"\n generate one vector / tensor\n :param size:\n :return:\n \"\"\"\n return np.array(np.zeros(shape=size), dtype='float32')\n\n\ndef lstm_init(n_in, n_out, component=\"LSTM\"):\n \"\"\"\n\n :param n_in: input size\n :param n_out: hidden size\n :param component: component name\n :return:\n \"\"\"\n if True:\n print(\"Initialize LSTM weights from uniform distribution...\")\n W_values = np.concatenate([uniform(lb=-INIT_RANGE, ub=INIT_RANGE, size=(n_in, n_out)),\n uniform(lb=-INIT_RANGE, ub=INIT_RANGE, size=(n_in, n_out)),\n uniform(lb=-INIT_RANGE, ub=INIT_RANGE, size=(n_in, n_out)),\n uniform(lb=-INIT_RANGE, ub=INIT_RANGE, size=(n_in, n_out))], axis=1)\n\n U_values = np.concatenate([uniform(lb=-INIT_RANGE, ub=INIT_RANGE, size=(n_out, n_out)),\n uniform(lb=-INIT_RANGE, ub=INIT_RANGE, size=(n_out, n_out)),\n uniform(lb=-INIT_RANGE, ub=INIT_RANGE, size=(n_out, n_out)),\n uniform(lb=-INIT_RANGE, ub=INIT_RANGE, size=(n_out, n_out))], axis=1)\n b_values = np.concatenate([zeros(n_out),\n zeros(n_out),\n zeros(n_out),\n zeros(n_out)])\n else:\n print(\"Initialize LSTM weights from glorot uniform + glorot uniform...\")\n W_values = np.concatenate([glorot_uniform(size=(n_in, n_out)),\n glorot_uniform(size=(n_in, n_out)),\n glorot_uniform(size=(n_in, n_out)),\n glorot_uniform(size=(n_in, n_out))], axis=1)\n\n U_values = np.concatenate([glorot_uniform(size=(n_out, n_out)),\n glorot_uniform(size=(n_out, n_out)),\n glorot_uniform(size=(n_out, n_out)),\n glorot_uniform(size=(n_out, n_out))], axis=1)\n b_values = np.concatenate([zeros(n_out),\n ones(n_out), # set forget gate to 1.0\n zeros(n_out),\n zeros(n_out)])\n W = theano.shared(value=W_values, name='%s_W' % component)\n U = theano.shared(value=U_values, name='%s_U' % component)\n b = theano.shared(value=b_values, name='%s_b' % component)\n return W, U, b\n\n\ndef reverse_tensor(tensor):\n \"\"\"\n\n :param tensor: input tensor, shape: (bs, seq_len, n_in)\n :return:\n \"\"\"\n new_tensor = tensor.dimshuffle(1, 0, 2)\n return new_tensor[::-1].dimshuffle(1, 0, 2)\n\n\ndef adam(cost, params, max_norm=3.0, lr=0.001, beta1=0.9, beta2=0.999, epsilon=1e-8):\n \"\"\"\n adam optimizer, default learning rate is 0.001\n \"\"\"\n\n grads = T.grad(cost, params)\n t_prev = theano.shared(value=np.float32(0.0))\n updates = OrderedDict()\n\n t = t_prev + 1\n one = T.constant(1, dtype='float32')\n\n a_t = lr * T.sqrt(one - beta2 ** t) / (one - beta1 ** t)\n\n for p, g in zip(params, grads):\n value = p.get_value(borrow=True)\n m_prev = theano.shared(np.zeros(value.shape, dtype=value.dtype),\n broadcastable=p.broadcastable)\n v_prev = theano.shared(np.zeros(value.shape, dtype=value.dtype),\n broadcastable=p.broadcastable)\n\n m_t = beta1 * m_prev + (one - beta1) * g\n v_t = beta2 * v_prev + (one - beta2) * g ** 2\n\n step = a_t * m_t / (T.sqrt(v_t) + epsilon)\n\n stepped_p = p - step\n updates[m_prev] = m_t\n updates[v_prev] = v_t\n # add max norm constraint on the W_hidden\n # if p.name == 'W_hidden':\n #\tcol_norms = T.sqrt(T.sum(T.sqr(stepped_p), axis=0))\n #\tdesired_norms = T.clip(col_norms, 0, max_norm)\n #\tscale = desired_norms / (1e-7 + col_norms)\n #\tupdates[p] = stepped_p * scale\n # else:\n #\tupdates[p] = stepped_p\n updates[p] = stepped_p\n updates[t_prev] = t\n return updates\n\n\ndef sgd_momentum(cost, params, lr=0.01, momentum=0.9):\n \"\"\"\n sgd with momentum\n :param cost: training loss\n :param params: parameters\n :param lr: learning rate\n :param momentum: amount of momentum to apply\n :return:\n \"\"\"\n grads = T.grad(cost, params)\n updates = OrderedDict()\n for p, g in zip(params, grads):\n updates[p] = p - lr * g\n for p in params:\n value = p.get_value(borrow=True)\n velocity = theano.shared(np.zeros(value.shape, dtype=value.dtype), broadcastable=p.broadcastable)\n x = momentum * velocity + updates[p]\n updates[velocity] = x - p\n updates[p] = x\n return updates\n\ndef get_batch_input(max_sequence_length, dataset, bs, idx):\n \"\"\"\n\n :param dataset: dataset\n :param bs: batch size\n :param idx: batch index\n :return:\n \"\"\"\n batch_input = dataset[idx*bs:(idx+1)*bs]\n #print(batch_input)\n batch_data = pd.DataFrame.from_dict(batch_input)\n #print(batch_data)\n #print(batch_data)\n target_fields = ['wids', 'tids', 'y', 'pw']\n batch_input_var = []\n for key in target_fields:\n #print(\"for %s data\" % key)\n data = list(batch_data[key].values)\n #print(data[0])\n #print(data[5])\n if key == 'pw':\n # for position weights\n #batch_input_var.append(theano.shared(value=np.array(data, dtype='float32')))\n batch_input_var.append(np.array(data, dtype='float32'))\n else:\n #batch_input_var.append(theano.shared(value=np.array(data, dtype='int32')))\n batch_input_var.append(np.array(data, dtype='int32'))\n batch_input_var.append(list(batch_data['sent'].values))\n\n graph_data = list(batch_data['graphsage_embedding'].values)\n graph_data = np.array(graph_data, dtype='float32')\n graphsage_embedding = []\n\n for s in range(len(batch_input_var[0])):\n graph_embedding = []\n for i in range(max_sequence_length):\n graph_embedding.append(graph_data[s]) \n graphsage_embedding.append(graph_embedding)\n\n graphsage_embedding = np.array(graphsage_embedding, dtype=np.float32)\n batch_input_var.append(graphsage_embedding)\n\n return batch_input_var\n", "meta": {"hexsha": "937b9c8cf7a9fb5fc1ccb38c644aaacedd91598e", "size": 7618, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/alsc/ar-tnet/nn_utils_sentence_GraphSAGE.py", "max_stars_repo_name": "mainuliitkgp/AR-BERT", "max_stars_repo_head_hexsha": "d6d5e8542a3a1c76edac49cec9e99ebda6395725", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2022-03-06T17:41:57.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-22T08:42:58.000Z", "max_issues_repo_path": "src/alsc/ar-tnet/nn_utils_sentence_GraphSAGE.py", "max_issues_repo_name": "mainuliitkgp/AR-BERT", "max_issues_repo_head_hexsha": "d6d5e8542a3a1c76edac49cec9e99ebda6395725", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/alsc/ar-tnet/nn_utils_sentence_GraphSAGE.py", "max_forks_repo_name": "mainuliitkgp/AR-BERT", "max_forks_repo_head_hexsha": "d6d5e8542a3a1c76edac49cec9e99ebda6395725", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-19T14:04:42.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-19T14:04:42.000Z", "avg_line_length": 33.4122807018, "max_line_length": 105, "alphanum_fraction": 0.5741664479, "include": true, "reason": "import numpy,import theano", "num_tokens": 1893, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5273165233795671, "lm_q2_score": 0.37754066879814546, "lm_q1q2_score": 0.1990834329050347}} {"text": "#!/usr/bin/env python\n\"\"\"Pre-calculate a grid of 5-sigma limiting mags for all times, filters, and DDF fields\n\"\"\"\n\n# imports\nimport sys\nimport warnings\nimport logging\nfrom argparse import ArgumentParser\n\nimport yaml\nimport numpy as np\nimport pandas as pd\nfrom astropy.coordinates import SkyCoord\nimport astropy.coordinates\nfrom astropy.time import Time\n\nimport lsst.sims.utils\nfrom lsst.sims.downtimeModel import ScheduledDowntimeData\nfrom lsst.sims.skybrightness_pre import SkyModelPre\nfrom lsst.sims.seeingModel import SeeingModel\n\n# constants\n\nDEFAULT_CONFIG = {\n \"start_time\": \"2022-11-01T16:00:00Z\",\n \"end_time\": \"2033-11-01T16:00:00Z\",\n \"time_freq\": \"10min\",\n \"site_name\": \"LSST\",\n \"fields\": {\n \"Elias S1\": SkyCoord(\"00h37m48s\", \"-44d00m00s\"),\n \"XMM-LSS\": SkyCoord(\"02h22m50s\", \"-04d45m00s\"),\n \"ECDFS\": SkyCoord(\"03h32m30s\", \"-28d06m00s\"),\n \"COSMOS\": SkyCoord(\"10h00m24s\", \"+02d10m55s\"),\n \"Euclid 1\": SkyCoord(\"03h55m52.8s\", \"-49d16m48s\"),\n \"Euclid 2\": SkyCoord(\"04h14m24s\", \"-47d36m00s\"),\n },\n \"max_sun_alt_deg\": -18.0,\n \"max_field_airmass\": 2.6,\n}\n\nSKY_MODEL = SkyModelPre()\n\n# exception classes\n\n# interface functions\n\n\ndef calc_m5(config=None):\n \"\"\"Calculate the 5-sigma limiting magnitudes for a set of fields\n\n Parameters\n ----------\n config : `dict'\n Configuration parameters, with the following contents:\n start_time : `str` or period-like, default None\n Start of time range\n end_time : `str` or period-like, default None\n End of time range\n time_freq : `str`\n Time frequency, designated by a pandas frequency string\n fields : `dict` [`str`, ~astropy.coordinates.SkyCoord`]\n The pointings for which to calculate limiting mags.\n site_name : `str`\n The name of the observatory site.\n max_sun_alt_deg: `float`\n Maximum altitude of sun for observing time, in degrees\n max_field_airmass: `float`\n Maximum airmass at which to observe\n\n Returns\n -------\n m5limits : `pandas.DataFrame`\n A `pandas.Series` of the 5 sigma limiting magnitudes, indexed by the `mjd` and field name.\n\n Notes\n -----\n\n For more on pandas frequency strings, see `the pandas documentation\n`__.\n\n \"\"\"\n\n config = DEFAULT_CONFIG if config is None else config\n\n # Work around bug in lsst.sims.utils.Site, which compares by reference\n # rather than equivilence\n site_name = \"LSST\" if config[\"site_name\"] == \"LSST\" else config[\"site_name\"]\n site = lsst.sims.utils.Site(site_name)\n location = astropy.coordinates.EarthLocation(\n lat=site.latitude, lon=site.longitude, height=site.height\n )\n\n periods = _init_periods(config, location)\n\n field_coords = _init_field_coords(config)\n\n logger.debug(\"Building the sampled_fields DataFrame\")\n # Cross join using the hacky pandas method\n periods[\"dummy\"] = True\n field_coords[\"dummy\"] = True\n sampled_fields = (\n periods.merge(field_coords, on=\"dummy\", how=\"outer\")\n .drop(columns=[\"dummy\"])\n .set_index([\"field_name\", \"period\"], drop=False)\n )\n sampled_fields.query(\"observing\", inplace=True)\n\n logger.debug(\"Calculating field airmass and filtering\")\n field_zd_rad = np.pi / 2 - (\n SkyCoord(\n ra=sampled_fields.field_ra,\n dec=sampled_fields.field_decl,\n frame=\"icrs\",\n unit=\"deg\",\n )\n .transform_to(\n astropy.coordinates.AltAz(\n location=location, obstime=Time(sampled_fields[\"mjd\"], format=\"mjd\")\n )\n )\n .alt.rad\n )\n sampled_fields[\"field_airmass\"] = 1.0 / np.cos(field_zd_rad)\n max_field_airmass = config[\"max_field_airmass\"]\n sampled_fields.query(f\"field_airmass < {max_field_airmass}\", inplace=True)\n\n logger.debug(\"Calculating field angle with the moon\")\n sampled_fields[\"moon_angle\"] = (\n SkyCoord(\n ra=sampled_fields[\"field_ra\"],\n dec=sampled_fields[\"field_decl\"],\n frame=\"icrs\",\n unit=\"deg\",\n ).separation(\n SkyCoord(\n ra=sampled_fields[\"moon_ra\"],\n dec=sampled_fields[\"moon_decl\"],\n frame=\"icrs\",\n unit=\"deg\",\n )\n )\n ).deg\n\n logger.debug(\"Calculating sky brightness\")\n sampled_fields = sampled_fields.groupby(\"mjd\").apply(_get_sky_mags)\n\n sampled_fields = sampled_fields.groupby(\"band\").apply(_compute_band_fwhms)\n\n sampled_fields = sampled_fields.groupby(\"band\").apply(_compute_band_m5)\n\n sampled_fields.set_index([\"field_name\", \"period\"], drop=False, inplace=True)\n\n logger.debug(\"Finished constructing the m5 DataFrame\")\n return sampled_fields\n\n\n# classes\n\n# internal functions & classes\n\n\ndef _init_periods(config, location):\n\n logger.debug(\"Laying down time period boundries\")\n period_index = pd.period_range(\n config[\"start_time\"],\n config[\"end_time\"],\n freq=config[\"time_freq\"],\n name=\"period\",\n )\n times = Time(\n pd.to_datetime(period_index.to_timestamp()), # pylint: disable=no-member\n location=location,\n )\n\n logger.debug(\"Calculating solar ephemeris\")\n sun_coords = astropy.coordinates.get_sun(times)\n\n logger.debug(\"Calculating lunar ephemeris\")\n moon_coords = astropy.coordinates.get_moon(times)\n moon_elongation = moon_coords.separation(sun_coords)\n\n logger.debug(\"Converting solar and lunar coordinates to horizon system\")\n horizon_coordinate_system = astropy.coordinates.AltAz(location=location)\n sun_hzn = sun_coords.transform_to(horizon_coordinate_system)\n moon_hzn = moon_coords.transform_to(horizon_coordinate_system)\n\n logger.debug(\"Building the period DataFrame\")\n periods = pd.DataFrame(\n {\n \"mjd\": times.mjd,\n \"time\": times,\n \"lst\": times.sidereal_time(\"mean\"),\n \"sun_ra\": sun_coords.ra.deg,\n \"sun_decl\": sun_coords.dec.deg,\n \"sun_alt\": sun_hzn.alt.deg,\n \"moon_ra\": moon_coords.ra.deg,\n \"moon_decl\": moon_coords.dec.deg,\n \"moon_alt\": moon_hzn.alt.deg,\n \"moon_elongation\": moon_elongation.deg,\n },\n index=period_index,\n )\n\n periods[\"moon_waxing\"] = (\n periods[\"moon_elongation\"].shift(-1) > periods[\"moon_elongation\"]\n )\n\n previous_waxing = periods[\"moon_waxing\"].shift(\n 1, fill_value=periods.iloc[0][\"moon_waxing\"]\n )\n periods[\"new_moon\"] = periods[\"moon_waxing\"] & ~previous_waxing\n periods[\"lunation\"] = periods[\"new_moon\"].cumsum()\n\n mean_local_solar_jd = 2400000.5 + periods[\"mjd\"] + (location.lon.deg / 360.0)\n night_local_solar_jd = np.floor(mean_local_solar_jd).astype(int)\n periods[\"night\"] = night_local_solar_jd - np.min(night_local_solar_jd) + 1\n\n # Mark daytime periods\n periods[\"observing\"] = periods.sun_alt <= config[\"max_sun_alt_deg\"]\n\n # Mark scheduled downtime\n periods.reset_index(inplace=True)\n periods.set_index(\"mjd\", inplace=True)\n for down_time in ScheduledDowntimeData(times.min())():\n periods.loc[down_time[\"start\"].mjd : down_time[\"end\"].mjd, \"observing\"] = False\n periods.reset_index(inplace=True)\n periods.set_index(\"period\", drop=False, inplace=True)\n return periods\n\n\ndef _init_field_coords(config):\n fields = config[\"fields\"]\n\n logger.debug(\"Building the fields DataFrame\")\n field_coords = (\n pd.DataFrame(\n {\n fld: {\n \"field_name\": fld,\n \"field_ra\": fields[fld].ra.deg,\n \"field_decl\": fields[fld].dec.deg,\n }\n for fld in fields\n }\n )\n .T.set_index(\"field_name\")\n .apply(pd.to_numeric)\n .reset_index()\n )\n\n logger.debug(\"Adding healpix to field coordinates\")\n field_coords[\"field_hpix32\"] = lsst.sims.utils.raDec2Hpid(\n 32, field_coords.field_ra, field_coords.field_decl\n )\n\n return field_coords\n\n\ndef _get_sky_mags(sampled_fields_mjd):\n mjd = sampled_fields_mjd.mjd[0]\n assert np.all(mjd == sampled_fields_mjd[\"mjd\"])\n\n mags = SKY_MODEL.returnMags(mjd, sampled_fields_mjd.field_hpix32, badval=-np.inf)\n sampled_fields_band_mjds = []\n for band in mags:\n sampled_fields_band_mjd = sampled_fields_mjd.copy()\n sampled_fields_band_mjd[\"band\"] = band\n sampled_fields_band_mjd[\"sky_mag\"] = mags[band]\n sampled_fields_band_mjds.append(sampled_fields_band_mjd)\n out_sampled_fields_mjd = pd.concat(sampled_fields_band_mjds)\n return out_sampled_fields_mjd\n\n\ndef _compute_band_fwhms(sampled_fields_band):\n band = sampled_fields_band[\"band\"][0]\n assert np.all(band == sampled_fields_band[\"band\"])\n\n logger.debug(\"Calculating the model seeing in %s\", band)\n seeing_model = SeeingModel()\n\n band_idx = [\"u\", \"g\", \"r\", \"i\", \"z\", \"y\"].index(band)\n sampled_fields_band = sampled_fields_band.copy()\n sampled_fields_band[\"fwhm\"] = seeing_model(\n 0.7, sampled_fields_band[\"field_airmass\"].values\n )[\"fwhmEff\"][band_idx]\n return sampled_fields_band\n\n\ndef _compute_band_m5(sampled_fields_band):\n band = sampled_fields_band[\"band\"][0]\n assert np.all(band == sampled_fields_band[\"band\"])\n\n logger.debug(\"Calculating the 5-sigma magnitude limit in %s\", band)\n sampled_fields_band = sampled_fields_band.copy()\n sampled_fields_band[\"m5\"] = lsst.sims.utils.m5_flat_sed(\n band,\n sampled_fields_band[\"sky_mag\"],\n sampled_fields_band[\"fwhm\"],\n 30.0,\n sampled_fields_band[\"field_airmass\"],\n nexp=1.0,\n )\n return sampled_fields_band\n\n\ndef read_config(fname):\n \"\"\"Read m5 configuration file\n\n Parameters\n ----------\n fname: `str`\n The name of the file to read configuration from.\n\n Return\n ------\n config: `dict`\n Dictionary of configuration values\n \"\"\"\n logger.debug(\"Reading configuration from %s\", fname)\n\n with open(fname, \"r\") as config_file:\n config = yaml.load(config_file.read(), Loader=yaml.FullLoader)\n\n # Convert field coordinates into astroy.SkyCoord objects\n for field in config[\"fields\"]:\n config[\"fields\"][field] = SkyCoord(**config[\"fields\"][field])\n\n return config\n\n\ndef main():\n \"\"\"Parse command line arguments and config file, and run\"\"\"\n parser = ArgumentParser()\n parser.add_argument(\"config\", help=\"configuration file\")\n parser.add_argument(\"output\", help=\"file in which to write results\")\n\n args = parser.parse_args()\n config_fname = args.config\n output_fname = args.output\n\n warnings.filterwarnings(\n \"ignore\",\n message=\".*Tried to .* for times after IERS data is valid.*\",\n category=astropy.utils.exceptions.AstropyWarning,\n )\n warnings.filterwarnings(\n \"ignore\",\n message=\".*dubious year.*\",\n category=astropy.utils.exceptions.AstropyWarning,\n )\n\n config = read_config(config_fname)\n\n m5_limits = calc_m5(config)\n\n (\n m5_limits.set_index([\"field_name\", \"mjd\"])\n .drop(columns=[\"period\"])\n .to_hdf(output_fname, \"m5\")\n )\n\n return 0\n\n\ndef _init_logger(log_level=logging.DEBUG):\n \"\"\"Create the ddfpresched logger and set initial configuration\"\"\"\n ddfpresched_logger = logging.getLogger(\"ddfpresched\")\n ddfpresched_logger.setLevel(log_level)\n handler = logging.StreamHandler()\n handler.setLevel(log_level)\n formatter = logging.Formatter(\"%(asctime)s\\t%(name)s\\t%(levelname)s\\t%(message)s\")\n handler.setFormatter(formatter)\n ddfpresched_logger.addHandler(handler)\n return ddfpresched_logger\n\n\nif __name__ == \"__main__\":\n logger = _init_logger()\n status = main() # pylint: disable=invalid-name\n sys.exit(status)\n", "meta": {"hexsha": "8eae7cb028974bb6ce27e791a6d71814acb871cb", "size": 11943, "ext": "py", "lang": "Python", "max_stars_repo_path": "python/m5.py", "max_stars_repo_name": "lsst/rtn-014", "max_stars_repo_head_hexsha": "773e470c06371fffb3c9844923065a9f0e0e70bf", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "python/m5.py", "max_issues_repo_name": "lsst/rtn-014", "max_issues_repo_head_hexsha": "773e470c06371fffb3c9844923065a9f0e0e70bf", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "python/m5.py", "max_forks_repo_name": "lsst/rtn-014", "max_forks_repo_head_hexsha": "773e470c06371fffb3c9844923065a9f0e0e70bf", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.182767624, "max_line_length": 98, "alphanum_fraction": 0.6546931257, "include": true, "reason": "import numpy,import astropy,from astropy", "num_tokens": 2965, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5273165233795671, "lm_q2_score": 0.37754066879814546, "lm_q1q2_score": 0.1990834329050347}} {"text": "from typing import ClassVar, Dict, List, Optional, Sequence, Union, Tuple, Any, Type\nfrom dataclasses import dataclass, field\nimport numpy as np\nfrom pygmsh.common import bspline\nfrom ..common import Pointer\nfrom pygmsh.geo import Geometry\nfrom math import ceil, floor, sqrt\nfrom geomdl import BSpline\nimport gmsh # To do some low level creation\n\n\"\"\"\nNM: Abbreviation for 'not mine'. Used to denote codes that are took from pyiges\n\"\"\"\n\n\"\"\"\nOmitted entity type list\n202: Angular Dimension Entity, \n210: General Label Entity, 212: General Note Entity, 214: Leader Arrow Entity, \n216: Linear Dimension Entity, 218: Ordimate Dimension Entity, \n\"\"\"\n\nParameter = Union[str, float]\n\n\n@dataclass\nclass Entity:\n type_number: int\n # parameter data pointer\n pd_pointer: int\n structure: int\n line_font_pattern: int\n level: int\n view: int\n transformation_pointer: int\n label_display_associativity: int\n\n status_number: int\n # instead of using the sequence number, use the index of entity\n # sequence_number: int\n line_weight: int\n color: int\n parameter_line_count: int\n form: int\n entity_label: str\n subscript: int\n # instead of just [], below is required\n # because mutable default is not allowed\n parameters: List[Parameter] = field(default_factory=list)\n\n _geometry: Optional[Any] = None\n _render: ClassVar[bool] = True\n\n @staticmethod\n def parse_status_number(x: str) -> int:\n \"\"\"\n inputs\n x: A candidate status number in string\n output\n status number in integer\n \"\"\"\n numbers = x.split(\" \")\n numbers = [n.zfill(2) for n in numbers]\n return int(\"\".join(numbers))\n\n def add_parameters(self, *args: List[Parameter]):\n self.parameters += args\n\n def to_vtk(self, entities: Dict[Pointer, \"Entity\"], geometry: Geometry, lcar: float = 0.1):\n \"\"\"Transforms this entity into a vtk object\"\"\"\n raise NotImplementedError\n\n def to_vtk_operator(self) -> Any:\n \"\"\"\n Transforms this entity into a vtk operator.\n Not an actual object itself, but used to manipulate other vtk objects.\n \"\"\"\n raise NotImplementedError\n\n\n@dataclass\nclass Point(Entity): # 116\n\n def add_parameters(self, *args: Tuple[float]):\n self.pos = np.array(args[:3])\n\n def to_vtk(self, entities: Dict[Pointer, \"Entity\"], geometry: Geometry, lcar: float = 0.1):\n if not self._render:\n return\n _point = self.pos\n\n if self.transformation_pointer:\n T = entities[self.transformation_pointer]\n point = T.transform(_point.T)\n else:\n point = _point\n\n geometry.add_point(point)\n\n\n@dataclass\nclass Line(Entity): # 110\n\n def add_parameters(self, *args: Tuple[float]):\n self.start = args[:3]\n self.end = args[3:6]\n\n def to_vtk(self, entities: Dict[Pointer, \"Entity\"], geometry: Geometry, lcar: float = 0.1):\n if not self._render:\n return\n\n point1 = np.array(self.start)\n point2 = np.array(self.end)\n\n if self.transformation_pointer:\n transformation = entities[self.transformation_pointer]\n point1 = transformation.transform(point1)\n point2 = transformation.transform(point2)\n\n point1 = geometry.add_point(point1, lcar)\n point2 = geometry.add_point(point2, lcar)\n\n self._geometry = geometry.add_line(point1, point2)\n\n\n@dataclass\nclass CopiousData(Entity): # 106\n \"\"\"\n Definition of set of points. Type specifies 1: couples, 2: triples, 3: sextuplets\n\n if type is 1, then 2nd parameter is the common z value for all the other\n xy pairs\n \"\"\"\n\n TYPE2PARSE_LENGTH = {1: 2, 2: 3, 3: 6}\n\n def add_parameters(self, *args: List[Parameter]):\n self.tuple_type: int = int(args[0])\n\n if self.tuple_type == 1: # couples\n self.common_z = args[1]\n coordinates = args[2:]\n else:\n self.common_z = None\n coordinates = args[1:]\n\n length = self.TYPE2PARSE_LENGTH[self.tuple_type]\n self.point_list: List[List] = self.parse_tuple(coordinates, length)\n\n def parse_tuple(self, args: List[Parameter], length: int) -> List[Tuple]:\n tuple_list: List[List] = []\n\n # /2 because 2 floats in a couple\n if self.common_z:\n for tuple_idx in range(int(len(args)/length)):\n start = tuple_idx*length\n end = (tuple_idx+1)*length\n tuple_list.append(\n [*args[start: end], self.common_z])\n\n else:\n for tuple_idx in range(int(len(args)/length)):\n start = tuple_idx*length\n end = (tuple_idx+1)*length\n tuple_list.append(args[start: end])\n\n return tuple_list\n\n def to_vtk(self, entities: Dict[Pointer, \"Entity\"], geometry: Geometry, lcar: float = 0.1):\n if not self._render:\n return\n \"\"\"\n Not a mesh, so this can be discarded\n \"\"\"\n for tuple_point in self.point_list:\n geometry.add_point(tuple_point)\n\n\n@dataclass\nclass CircularArc(Entity): # 100\n \"\"\"\n Simple circular arc of constant radius. Usually defined with a Transformation Matrix Entity (Type 124).\n \"\"\"\n\n def add_parameters(self, *args: List[Parameter]):\n self.z, self.x, self.y, self.x1, self.y1, self.x2, self.y2 = args[:7]\n\n def to_vtk(self, entities: Dict[Pointer, \"Entity\"], geometry: Geometry, lcar: float = 0.1):\n if not self._render:\n return\n\n start = np.array([self.x1, self.y1, self.z])\n end = np.array([self.x2, self.y2, self.z])\n center = np.array([self.x, self.y, self.z])\n\n if self.transformation_pointer:\n transfomation = entities[self.transformation_pointer]\n\n start = transfomation.transform(start)[0]\n end = transfomation.transform(end)[0]\n center = transfomation.transform(center)[0]\n\n start = geometry.add_point(start, lcar)\n end = geometry.add_point(end, lcar)\n center = geometry.add_point(center, lcar)\n\n geometry.add_circle_arc(start, center, end)\n\n\n@dataclass\nclass ConicArc(Entity): # 124\n \"\"\"\n Arc defined by the equation: Axt^2 + Bxtyt + Cyt^2 + Dxt + Eyt + F = 0, with a Transformation Matrix (Entity 124). Can define an ellipse, parabola, or hyperbola.\n\n The definitions of the terms ellipse, parabola, and hyperbola are given in terms of the quantities Q1,Q2, andQ3. These quantities are:\n\n | A B/2 D/2 | | A B/2 | \n Q1= | B/2 C E/2 | Q2 = | B/2 C | Q3 = A + C \n | D/2 E/2 F | \n A parent conic curve is:\n\n An ellipse if Q2 > 0 and Q1Q3 < 0.\n A hyperbola if Q2 < 0 and Q1 != 0.\n A parabola if Q2 = 0 and Q1 != 0.\n\n +@ from https://en.wikipedia.org/wiki/Matrix_representation_of_conic_sections\n center: \n |xc| = | (BE - 2CD)/(4AC - B^2) |\n |yc| = | (DB - 2AE)/(4AC - B^2) |\n \"\"\"\n\n def add_parameters(self, *args: List[Parameter]):\n self.a, self.b, self.c, self.d, self.e, self.f, \\\n self.x1, self.y1, self.z1, self.x2, self.y2, self.z2 = args[:12]\n\n def to_vtk(self, entities: Dict[Pointer, \"Entity\"], geometry: Geometry, lcar: float = 0.1):\n if not self._render:\n return\n\n start = np.array([self.x1, self.y1, self.z1])\n end = np.array([self.x2, self.y2, self.z2])\n center = np.array([0, 0, 0])\n\n a = self.get_major_raidus(\n self.a, self.b, self.c, self.d, self.e, self.f)\n point_on_major = np.array([a, 0, 0])\n\n if self.transformation_pointer:\n t = entities[self.transformation_pointer]\n\n start = t.transform(start)[0]\n end = t.transform(end)[0]\n center = t.transform(center)[0]\n point_on_major = t.transform(point_on_major)[0]\n\n start = geometry.add_point(start, lcar)\n end = geometry.add_point(end, lcar)\n center = geometry.add_point(center, lcar)\n point_on_major = geometry.add_point(point_on_major, lcar)\n\n geometry.add_ellipse_arc(start, center, point_on_major, end)\n\n @staticmethod\n def get_x_range(start_pos: np.ndarray, end_pos: np.ndarray, step: float) -> np.ndarray:\n\n pos = np.arange(start=start_pos[0], stop=end_pos[0]+step, step=step)\n neg = np.array([x * -1 for x in np.flip(pos)])\n return np.hstack((neg, pos))\n\n @staticmethod\n def get_major_raidus(a, b, c, d, e, f) -> np.float:\n \"\"\"\n For an ellipse or hyperbola, you can find the canonical form \n from the general form. \n We only need `a`, the major radius so `b` is not calculated\n Reference: https://en.wikipedia.org/wiki/Conic_section#Matrix_notation \n \"\"\"\n sol = np.array([[a, b/2], [b/2, c]])\n conic_matrix = np.array([[a, b/2, d/2], [b/2, c, e/2], [d/2, e/2, f]])\n\n eig = np.linalg.eigvals(sol)\n l1, l2 = eig # lambda 1 and lambda 2\n S = np.linalg.det(conic_matrix)\n\n canonical_a = -S/(l1**2 * l2)\n return canonical_a\n\n @staticmethod\n def get_y_positive(a, b, c, d, e, f, x) -> Tuple[float, float]:\n \"\"\"\n Solve general form for `x`. Given x calculate y the positive version.\n Equations found using `sympy solve`.\n \"\"\"\n y_positive = (-b*x - d + sqrt(-4*a*c*x**2 - 4*a*e*x -\n 4*a*f + b**2*x**2 + 2*b*d*x + d**2))/(2*a)\n\n return y_positive\n\n @staticmethod\n def get_y_negative(a, b, c, d, e, f, x) -> Tuple[float, float]:\n y_negative = -(b*x + d + sqrt(-4*a*c*x**2 - 4*a*e*x -\n 4*a*f + b**2*x**2 + 2*b*d*x + d**2))/(2*a)\n\n return y_negative\n\n\n@dataclass\nclass Transformation(Entity): # 124\n \"\"\"\n new E = RE + T (E: Entity coordinate)\n\n | r11 r12 r13 | | T1 |\n R = | r21 r22 r23 | T = | T2 |\n | r31 r32 r33 | | T3 |\n\n \"\"\"\n\n def add_parameters(self, *args: List[float]):\n r11, r12, r13, t1, \\\n r21, r22, r23, t2, \\\n r31, r32, r33, t3 = (args[:12])\n\n self.r = np.array([[r11, r12, r13],\n [r21, r22, r23],\n [r31, r32, r33]])\n self.t = np.array([[t1, t2, t3]])\n\n def transform(self, coordinate: np.array) -> np.array:\n\n return self.r.dot(coordinate) + self.t\n\n def to_vtk(self, entities: Dict[Pointer, \"Entity\"], geometry: Geometry, lcar: float = 0.1):\n if not self._render:\n return\n # does nothing by itself\n pass\n\n\n@dataclass\nclass SubfigureDefinition(Entity): # 308\n\n def add_parameters(self, *args: List[Parameter]):\n self.depth = int(args[0])\n self.name = args[1]\n self.length = int(args[2])\n self.figures = [int(pointer) for pointer in args[3:]]\n\n def to_vtk(self, entities: Dict[Pointer, \"Entity\"], geometry: Geometry, lcar: float = 0.1):\n if not self._render:\n return\n\n if self.transformation_pointer:\n raise NotImplementedError\n pass\n\n\n@dataclass\nclass SingularSubfigureInstance(Entity): # 408\n\n def add_parameters(self, *args: List[Parameter]):\n self.pointer = int(args[0])\n self.translation = np.array(args[1:4])\n self.scale_factor = args[4]\n\n\n@dataclass\nclass RationalBSplineCurve(Entity):\n \"\"\"\n Composes analytic curves.\n Form: 0=Determined by data 1=Line 2=Circular arc 3=Eliptic arc 4=Parabolic arc 5=Hyperbolic arc\n \"\"\"\n\n def add_parameters(self, *args: List[Parameter]):\n self.K, self.degree, self.flag1, self.flag2, self.flag3, self.flag4 \\\n = map(lambda x: int(x), args[:6])\n\n weight_start_idx = 8 + self.K + self.degree\n control_start_idx = weight_start_idx + self.K + 1\n etc_start_idx = control_start_idx + 3 * self.K + 3\n knot_range = range(6, weight_start_idx)\n weight_range = range(weight_start_idx, control_start_idx)\n\n self.v0, self.v1, self.xn, self.yn, self.zn = args[etc_start_idx:]\n\n self.knots = [args[i] for i in knot_range]\n self.weights = [args[i] for i in weight_range]\n temp_control_points = args[control_start_idx:etc_start_idx]\n self.control_points = [temp_control_points[i:i + 3] for i in range(0, len(temp_control_points), 3)]\n\n def to_vtk(self, entities: Dict[Pointer, \"Entity\"], geometry: Geometry, lcar: float = 0.1):\n if not self._render:\n return\n\n curve = BSpline.Curve()\n curve.degree = self.degree\n curve.ctrlpts = self.control_points\n curve.knotvector = self.knots\n curve.delta = lcar\n\n _points = curve.evalpts\n\n points = []\n for point in _points:\n\n if self.transformation_pointer:\n transfomation = entities[self.transformation_pointer]\n\n point = transfomation.transform(point)[0]\n\n point = geometry.add_point(point, lcar)\n points.append(point)\n\n spline = geometry.add_bspline(points)\n\n\n@dataclass\nclass RationalBSplineSurface(Entity):\n \"\"\"\n This is a surface entity defined by multiple surfaces. The form number describes the general type: 0=determined from data, 1=Plane, 2=Right circular cylinder, 3=Cone, 4=Sphere, 5=Torus, 6=Surface of revolution, 7=Tabulated cylinder, 8=Ruled surface, 9=General quadratic surface.\n\n Takes up most of the time saving.\n \"\"\"\n\n def add_parameters(self, *args: List[Parameter]):\n start_idx = 9\n self.k1, self.k2, self.m1, self.m2, \\\n self.flag1, self.flag2, self.flag3, self.flag4, self.flag5 \\\n = map(lambda x: int(x), args[:start_idx])\n\n knot2_start = start_idx + self.k2 + self.m1 + 2\n weight_start = knot2_start + self.k1 + self.m2 + 2\n self.knot1 = args[start_idx: knot2_start]\n self.knot2 = args[knot2_start: weight_start]\n\n weight_count = (self.k2 + 1) * (self.k1 + 1)\n control_start = weight_start + weight_count\n self.weights = args[weight_start: control_start]\n\n etc_start = control_start + 3 * weight_count\n\n self.control_points: List[List] = []\n\n i = control_start\n while i < etc_start:\n self.control_points.append(np.array(args[i: i+3]))\n i += 3\n\n self.control_points = np.array(\n self.control_points).reshape(self.k2+1, self.k1 + 1, 3)\n\n self.U0, self.U1, self.V0, self.V1 = args[etc_start:]\n\n assert len(self.knot1) == (2 + self.k2 + self.m1)\n assert len(self.knot2) == (2 + self.k1 + self.m2)\n assert len(self.weights) == weight_count\n assert self.control_points.size == (weight_count * 3)\n\n def to_vtk(self, entities: Dict[Pointer, \"Entity\"], geometry: Geometry, lcar: float = 0.1):\n if not self._render:\n return\n\n rows, cols, z = self.control_points.shape\n # The id have to match, not just coordinates\n top = []\n for i in range(0, cols):\n point = self.control_points[0, i]\n top.append(geometry.add_point(point, lcar))\n top_spline = geometry.add_bspline(top)\n\n right = [top[-1]]\n for i in range(1, rows):\n point = self.control_points[i, cols-1]\n right.append(geometry.add_point(point, lcar))\n right_spline = geometry.add_bspline(right)\n\n bottom = [right[-1]]\n for i in range(cols-2, -1, -1):\n point = self.control_points[rows-1, i]\n bottom.append(geometry.add_point(point, lcar))\n bottom_spline = geometry.add_bspline(bottom)\n\n left = [bottom[-1]]\n for i in range(rows-2, 0, -1):\n point = self.control_points[i, 0]\n left.append(geometry.add_point(point, lcar))\n left.append(top[0])\n left_spline = geometry.add_bspline(left)\n\n loop = geometry.add_curve_loop(\n [top_spline, right_spline, bottom_spline, left_spline])\n surface = geometry.add_surface(loop)\n\n\n@dataclass\nclass Face(Entity):\n \"\"\"\n Defines a bound portion of three dimensional space (R^3) which has a finite area. Used to construct B-Rep Geometries\n \"\"\"\n\n def add_parameters(self, *args: List[Parameter]):\n self.pointer = int(args[0])\n self.loop_count = int(args[1])\n self.loop_flag = int(args[2])\n\n self.loops = [args[i] for i in range(3, 2 + self.loop_count)]\n\n\n@dataclass\nclass LoopEdge:\n \"\"\"Represents edge in a loop. NOT AN ENTITY\"\"\"\n\n type: int\n pointer: int\n index: int\n flag: bool\n curves: List[Tuple[bool, int]]\n\n\n@dataclass\nclass Loop(Entity):\n \"\"\"Defines a loop, specifying a bounded face, for B-Rep Geometries.\"\"\"\n\n def add_parameters(self, *args: List[Parameter]):\n self.edge_count = int(args[0])\n self.edges: List[LoopEdge] = []\n\n edge_idx = 0\n arg_idx = 1\n while edge_idx < self.edge_count:\n edge_type = int(args[arg_idx])\n edge_list_pointer = int(args[arg_idx + 1])\n edge_index = int(args[arg_idx + 2])\n flag = bool(args[arg_idx + 3])\n curve_count = int(args[arg_idx + 4])\n arg_idx += 5\n\n curves = []\n for i in range(curve_count):\n iso = bool(args[arg_idx])\n psc = int(args[arg_idx + 1])\n curves.append((iso, psc))\n arg_idx += 2\n\n edge = LoopEdge(edge_type, edge_list_pointer,\n edge_index, flag, curves)\n self.edges.append(edge)\n\n edge_idx += 1\n\n\n@dataclass\nclass Edge:\n curve: int\n start_vertex_list: int\n start_vertex_index: int\n end_vertex_list: int\n end_vertex_index: int\n\n\n@dataclass\nclass EdgeList(Entity):\n\n def add_parameters(self, *args: List[Parameter]):\n edge_count = int(args[0])\n\n edge_index = 0\n arg_index = 1\n self.edges: List[Edge] = []\n\n while edge_index < edge_count:\n e = Edge(*map(lambda x: int(x), args[arg_index:arg_index+5]))\n self.edges.append(e)\n\n arg_index += 5\n edge_index += 1\n\n\n@dataclass\nclass Vertex:\n x: float\n y: float\n z: float\n\n\n@dataclass\nclass VertexList(Entity):\n\n def add_parameters(self, *args: List[Parameter]):\n vertex_count = int(args[0])\n\n vertex_index = 0\n arg_index = 1\n self.vertices: List[Vertex] = []\n\n while vertex_index < vertex_count:\n v = Vertex(*args[arg_index: arg_index + 3])\n self.vertices.append(v)\n arg_index += 3\n vertex_index += 1\n\n\n@dataclass\nclass SurfaceOfRevolution(Entity): # 120\n\n def add_parameters(self, *args: List[Parameter]):\n self.axis_line = Pointer(args[0])\n self.target = Pointer(args[1])\n self.start_angle, self.end_angle = args[2:4] # radian\n\n def to_vtk(self, entities: Dict[Pointer, \"Entity\"], geometry: Geometry, lcar: float = 0.1):\n if not self._render:\n return\n line = entities[self.axis_line]\n target = entities[self.target]\n if not target._geometry:\n # this entity is dependent on another entity,\n # if the other entity is not rendered, this will not work\n # so enable it for this\n old_render = target._render\n target._render = True\n target.to_vtk(entities, geometry, lcar)\n target._render = old_render\n target_geometry = target._geometry\n\n geometry.revolve(target_geometry, line.start, line.end, 3.14)\n\n\n@dataclass\nclass CompositeCurve(Entity): # 102\n\n def add_parameters(self, *args: List[Parameter]):\n curve_count = int(args[0])\n self.curves: List[Pointer] = list(map(Pointer, args[1:]))\n\n def to_vtk(self, entities: Dict[Pointer, \"Entity\"], geometry: Geometry, lcar: float = 0.1):\n if not self._render:\n return\n\n\n# todo\n# Surface Revolution Type 120\n# Composite Curve 102\n# Trimmed Surface 144\n# Curve on Parametric Surface 142\n", "meta": {"hexsha": "550a3e80b94c249496955d8f4e93f236d3fed15e", "size": 20141, "ext": "py", "lang": "Python", "max_stars_repo_path": "iges2vtk/iges/entity.py", "max_stars_repo_name": "bullgom/igs2vtk", "max_stars_repo_head_hexsha": "6f6d8e443430217309e18a9ec766dcb7b72f4942", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-12-27T08:58:02.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-15T02:52:08.000Z", "max_issues_repo_path": "iges2vtk/iges/entity.py", "max_issues_repo_name": "bullgom/igs2vtk", "max_issues_repo_head_hexsha": "6f6d8e443430217309e18a9ec766dcb7b72f4942", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "iges2vtk/iges/entity.py", "max_forks_repo_name": "bullgom/igs2vtk", "max_forks_repo_head_hexsha": "6f6d8e443430217309e18a9ec766dcb7b72f4942", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.2748447205, "max_line_length": 282, "alphanum_fraction": 0.5981331612, "include": true, "reason": "import numpy", "num_tokens": 5278, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5273165085228825, "lm_q2_score": 0.3775406687981454, "lm_q1q2_score": 0.19908342729603198}} {"text": "# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Sat Aug 5 19:48:34 2017\n\n@author: max\n\"\"\"\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom math import pi, sqrt\nfrom collections import namedtuple\nfrom .Functions.CalcIOLMaxwellian import calc_iol_maxwellian\nfrom .Functions.CalcIOLMonoEn import calc_iol_mono_en\nfrom .Functions.CalcIOLBeams import calc_iol_beams\nfrom GT3.utilities.PlotBase import PlotBase\nimport sys\nimport GT3.constants as constants\nfrom GT3 import Core\n\nm_d = constants.deuteron_mass\nm_t = constants.triton_mass\nm_c = constants.carbon_mass\nm_a = constants.alpha_mass\n\n\nclass IOL(PlotBase):\n \"\"\"\n \"\"\"\n\n def __init__(self, inp, core: Core):\n super().__init__()\n sys.dont_write_bytecode = True\n np.warnings.filterwarnings('ignore')\n\n numcos = inp.numcos # TODO: Clean this up\n angles = np.linspace(-1, 1, inp.numcos + 1)\n self.coslist = ((angles + np.roll(angles, -1)) / 2)[:-1]\n self.rho = core.rho\n self.set_plot_rho1d(self.rho[:, 0])\n self.calc_iol_beams = calc_iol_beams\n polpts = len(core.rho[-1])\n radpts = len(core.rho.T[-1])\n\n # THE FOLLOWING ARRAYS ARE 4-DIMENSIONAL ARRAYS\n # [ LAUNCH THETA POSITION , LAUNCH ANGLE COSINE, LAUNCH r , EXIT THETA POSITION ]\n\n # NOTE TO FUTURE DEVELOPERS: IF YOU TRY TO LOOP OVER THE PLASMA POINTS, LAUNCH ANGLES, AND\n # EXIT LOCATIONS IN PYTHON THE WAY YOU WOULD IN C OR FORTRAN, IT'S GOING TO TAKE FOREVER.\n # ALTHOUGH THESE ARRAYS TAKE MORE MEMORY THAT I'D LIKE, IT'S CURRENTLY NECESSARY TO DO IT THIS WAY.\n # MAYBE SOMETHING TO IMPROVE ON IN THE FUTURE.\n\n # CREATE ARRAYS FOR LAUNCH POINTS IN THE PLASMA\n r0 = np.broadcast_arrays(np.ones(polpts)[:, None, None, None],\n np.ones(inp.numcos)[:, None, None],\n core.rho)[-1]\n\n B0 = np.broadcast_arrays(np.ones(polpts)[:, None, None, None],\n np.ones(inp.numcos)[:, None, None],\n core.B.tot.val)[-1]\n\n f0 = np.broadcast_arrays(np.ones(polpts)[:, None, None, None],\n np.ones(inp.numcos)[:, None, None],\n core.f_phi)[-1]\n\n psi0 = np.broadcast_arrays(np.ones(polpts)[:, None, None, None],\n np.ones(inp.numcos)[:, None, None],\n core.psi.psi)[-1]\n\n phi0 = np.broadcast_arrays(np.ones(polpts)[:, None, None, None],\n np.ones(inp.numcos)[:, None, None],\n core.E_pot.val)[-1] # * 1E3 # now in volts\n\n zeta0 = np.broadcast_arrays(np.ones(polpts)[:, None, None, None],\n self.coslist[:, None, None],\n np.ones(core.R.shape))[1]\n\n # CREATE ARRAYS FOR DESTINATION POINTS ALONG THE SEPERATRIX\n R1 = np.broadcast_arrays(np.ones(polpts)[:, None, None, None],\n np.ones(inp.numcos)[:, None, None],\n np.ones(radpts)[:, None],\n np.ones(polpts)[:],\n core.R[-1][:, None, None, None])[-1]\n\n f1 = np.broadcast_arrays(np.ones(polpts)[:, None, None, None],\n np.ones(inp.numcos)[:, None, None],\n np.ones(radpts)[:, None], np.ones(polpts)[:],\n core.f_phi[-1][:, None, None, None])[-1]\n\n B1 = np.broadcast_arrays(np.ones(polpts)[:, None, None, None],\n np.ones(inp.numcos)[:, None, None],\n np.ones(radpts)[:, None],\n np.ones(polpts)[:],\n core.B.tot.val[-1][:, None, None, None])[-1]\n\n psi1 = np.broadcast_arrays(np.ones(polpts)[:, None, None, None],\n np.ones(inp.numcos)[:, None, None],\n np.ones(radpts)[:, None],\n np.ones(polpts)[:],\n core.psi.psi[-1][:, None, None, None])[-1]\n\n phi1 = np.broadcast_arrays(np.ones(polpts)[:, None, None, None],\n np.ones(inp.numcos)[:, None, None],\n np.ones(radpts)[:, None],\n np.ones(polpts)[:],\n core.E_pot.val[-1][:, None, None, None])[-1] # * 1E3 # now in volts\n\n Tprofile = namedtuple('Tprofile', 'i C')(\n core.T.i.kev.val.T[0],\n core.T.C.kev.val.T[0]\n )\n\n # iol_params = {}\n # iol_params['r0'] = r0\n # iol_params['B0'] = B0\n # iol_params['f0'] = f0\n # iol_params['psi0'] = psi0\n # iol_params['phi0'] = phi0\n # iol_params['zeta0'] = zeta0\n # iol_params['R1'] = R1\n # iol_params['f1'] = f1\n # iol_params['B1'] = B1\n # iol_params['psi1'] = psi1\n # iol_params['phi1'] = phi1\n # iol_params['Tprofile'] = Tprofile\n\n # convert iol_params to namedtuple so individual parameters can be accessed as normal attributes\n self.iol_p = namedtuple('iol_p', 'r0 B0 f0 psi0 phi0 zeta0 R1 f1 B1 psi1 phi1')(\n r0,\n B0,\n f0,\n psi0,\n phi0,\n zeta0,\n R1,\n f1,\n B1,\n psi1,\n phi1\n )\n\n # Calculate IOL for thermal deuterium\n forb_d_therm, morb_d_therm, eorb_d_therm = calc_iol_maxwellian(1,\n m_d,\n self.iol_p,\n core.thetapts,\n Tprofile.i,\n self.coslist,\n numcos)\n self.forb_d_therm = inp.R_loss * forb_d_therm\n self.morb_d_therm = inp.R_loss * morb_d_therm\n self.eorb_d_therm = inp.R_loss * eorb_d_therm\n self.forb_d_therm_1D = self.forb_d_therm[:, 0]\n self.morb_d_therm_1D = self.morb_d_therm[:, 0]\n self.eorb_d_therm_1D = self.eorb_d_therm[:, 0]\n\n # Calculate IOL for thermal tritium\n forb_t_therm, morb_t_therm, eorb_t_therm = calc_iol_maxwellian(1,\n m_t,\n self.iol_p,\n core.thetapts,\n Tprofile.i,\n self.coslist,\n numcos)\n self.forb_t_therm = inp.R_loss * forb_t_therm\n self.morb_t_therm = inp.R_loss * morb_t_therm\n self.eorb_t_therm = inp.R_loss * eorb_t_therm\n self.forb_t_therm_1D = self.forb_t_therm[:, 0]\n self.morb_t_therm_1D = self.morb_t_therm[:, 0]\n self.eorb_t_therm_1D = self.eorb_t_therm[:, 0]\n\n # Calculate IOL for thermal carbon\n forb_c_therm, morb_c_therm, eorb_c_therm = calc_iol_maxwellian(6,\n m_c,\n self.iol_p,\n core.thetapts,\n Tprofile.C,\n self.coslist,\n numcos)\n self.forb_c_therm = inp.R_loss * forb_c_therm\n self.morb_c_therm = inp.R_loss * morb_c_therm\n self.eorb_c_therm = inp.R_loss * eorb_c_therm\n self.forb_c_therm_1D = self.forb_c_therm[:, 0]\n self.morb_c_therm_1D = self.morb_c_therm[:, 0]\n self.eorb_c_therm_1D = self.eorb_c_therm[:, 0]\n\n # Calculate IOL for thermal alphas\n forb_a_therm, morb_a_therm, eorb_a_therm = calc_iol_maxwellian(2,\n m_a,\n self.iol_p,\n core.thetapts,\n Tprofile.i,\n self.coslist,\n numcos)\n self.forb_a_therm = inp.R_loss * forb_a_therm\n self.morb_a_therm = inp.R_loss * morb_a_therm\n self.eorb_a_therm = inp.R_loss * eorb_a_therm\n self.forb_a_therm_1D = self.forb_a_therm[:, 0]\n self.morb_a_therm_1D = self.morb_a_therm[:, 0]\n self.eorb_a_therm_1D = self.eorb_a_therm[:, 0]\n\n # Calculate IOL for fast, monoenergetic alphas\n v_alpha = sqrt(2 * 3.5E6 * 1.6021E-19 / m_a)\n forb_a_fast, morb_a_fast, eorb_a_fast = calc_iol_mono_en(2,\n m_a,\n self.iol_p,\n core.thetapts,\n v_alpha,\n self.coslist,\n numcos)\n\n # currently applying R_loss to fast alphas as well as thermal, although I'm skeptical of this. -MH\n self.forb_a_fast = inp.R_loss * forb_a_fast\n self.morb_a_fast = inp.R_loss * morb_a_fast\n self.eorb_a_fast = inp.R_loss * eorb_a_fast\n self.forb_a_fast_1D = self.forb_a_fast[:, 0]\n self.morb_a_fast_1D = self.morb_a_fast[:, 0]\n self.eorb_a_fast_1D = self.eorb_a_fast[:, 0]\n\n # Calculate IOL for neutral deuterium beams\n v_beam = sqrt(2 * 80.0E3 * 1.6021E-19 / m_d)\n zeta_beam = -0.96\n forb_d_nbi, morb_d_nbi, eorb_d_nbi = self.calc_iol_beams(1,\n m_d,\n self.iol_p,\n core.thetapts,\n v_beam,\n zeta_beam,\n self.coslist)\n # currently applying R_loss to fast alphas as well as thermal, although I'm skeptical of this. -MH\n self.forb_d_nbi = inp.R_loss * forb_d_nbi\n self.morb_d_nbi = inp.R_loss * morb_d_nbi\n self.eorb_d_nbi = inp.R_loss * eorb_d_nbi\n self.forb_d_nbi_1D = self.forb_d_nbi[:, 0]\n self.morb_d_nbi_1D = self.morb_d_nbi[:, 0]\n self.eorb_d_nbi_1D = self.eorb_d_nbi[:, 0]\n\n def plot_F_i(self, edge=True):\n \"\"\"\n Plots the 1D GT3.IOL differential ion number loss fraction\n \"\"\"\n fig = self._plot_base(self.forb_d_therm_1D, yLabel=r'$F(\\rho)$',\n title=\"GT3.IOL differential ion number loss fraction\", edge=edge, color='blue')\n return fig\n\n def plot_M_i(self, edge=True):\n \"\"\"\n Plots the 1D GT3.IOL differential ion momentum loss fraction\n \"\"\"\n fig = self._plot_base(self.morb_d_therm_1D, yLabel=r'$M(\\rho)$',\n title=\"GT3.IOL differential ion momentum loss fraction\", edge=edge, color='green')\n return fig\n\n def plot_E_i(self, edge=True):\n \"\"\"\n Plots the 1D GT3.IOL differential ion energy loss fraction\n \"\"\"\n fig = self._plot_base(self.eorb_d_therm_1D, yLabel=r'$E(\\rho)$',\n title=\"GT3.IOL differential ion energy loss fraction\", edge=edge, color='red')\n return fig\n\n def plot_all_i(self):\n plot = plt.figure()\n fig1 = plot.add_subplot(111)\n fig1.set_xlabel(r'$\\rho$', fontsize=20)\n fig1.set_ylabel(r'$\\frac{\\partial F}{\\partial r}$', fontsize=25)\n fig1.set_title('Ion number loss fraction')\n fig1.scatter(self.rho, self.forb_d_therm_1D, marker='o', color='blue')\n\n fig2 = plot.add_subplot(121)\n fig2.set_xlabel(r'$\\rho$', fontsize=20)\n fig2.set_ylabel(r'$\\frac{\\partial E}{\\partial r}$', fontsize=25)\n fig2.set_title('Ion energy loss fraction')\n fig2.scatter(self.rho, self.eorb_d_therm_1D, marker='o', color='red')\n\n fig3 = plot.add_subplot(131)\n fig3.set_xlabel(r'$\\rho$', fontsize=20)\n fig3.set_ylabel(r'$\\frac{\\partial M}{\\partial r}$', fontsize=25)\n fig3.set_title('Ion momentum loss fraction')\n fig3.scatter(self.rho, self.morb_d_therm_1D, marker='o', color='green')\n\n return plot\n\n def plot_F_C(self, edge=True):\n \"\"\"\n Plots the 1D GT3.IOL differential carbon number loss fraction\n \"\"\"\n fig = self._plot_base(self.forb_c_therm_1D, yLabel=r'$\\frac{\\partial F}{\\partial r}$',\n title=\"GT3.IOL differential carbon number loss fraction\", edge=edge, color='blue')\n return fig\n\n def plot_M_C(self, edge=True):\n \"\"\"\n Plots the 1D GT3.IOL differential carbon momentum loss fraction\n \"\"\"\n fig = self._plot_base(self.morb_c_therm_1D, yLabel=r'$\\frac{\\partial M}{\\partial r}$',\n title=\"GT3.IOL differential carbon momentum loss fraction\", edge=edge, color='green')\n return fig\n\n def plot_E_C(self, edge=True):\n \"\"\"\n Plots the 1D GT3.IOL differential carbon energy loss fraction\n \"\"\"\n fig = self._plot_base(self.eorb_c_therm_1D, yLabel=r'$\\frac{\\partial E}{\\partial r}$',\n title=\"GT3.IOL differential carbon energy loss fraction\", edge=edge, color='green')\n return fig\n\n\n def plot_all_C(self):\n plot = plt.figure()\n fig1 = plot.add_subplot(111)\n fig1.set_xlabel(r'$\\rho$', fontsize=20)\n fig1.set_ylabel(r'$\\frac{\\partial F}{\\partial r}$', fontsize=25)\n fig1.set_title('Carbon number loss fraction')\n fig1.scatter(self.rho, self.forb_c_therm_1D, marker='o', color='blue')\n\n fig2 = plot.add_subplot(121)\n fig2.set_xlabel(r'$\\rho$', fontsize=20)\n fig2.set_ylabel(r'$\\frac{\\partial E}{\\partial r}$', fontsize=25)\n fig2.set_title('Carbon energy loss fraction')\n fig2.scatter(self.rho, self.eorb_c_therm_1D, marker='o', color='red')\n\n fig3 = plot.add_subplot(131)\n fig3.set_xlabel(r'$\\rho$', fontsize=20)\n fig3.set_ylabel(r'$\\frac{\\partial M}{\\partial r}$', fontsize=25)\n fig3.set_title('Carbon momentum loss fraction')\n fig3.scatter(self.rho, self.morb_c_therm_1D, marker='o', color='green')\n\n return plot\n\n def plot_F_i_fast(self, edge=True):\n \"\"\"\n Plots the 1D GT3.IOL differential fast ion number loss fraction\n \"\"\"\n fig = self._plot_base(self.forb_d_nbi_1D, yLabel=r'$\\frac{\\partial F}{\\partial r}$',\n title=\"GT3.IOL differential fast ion number loss fraction\", edge=edge, color='blue')\n return fig\n\n def plot_M_i_fast(self,edge=True):\n \"\"\"\n Plots the 1D GT3.IOL differential fast ion momentum loss fraction\n \"\"\"\n fig = self._plot_base(self.morb_d_nbi_1D, yLabel=r'$\\frac{\\partial M}{\\partial r}$',\n title=\"GT3.IOL differential fast ion momentum loss fraction\", edge=edge, color='green')\n return fig\n\n def plot_E_i_fast(self, edge=True):\n \"\"\"\n Plots the 1D GT3.IOL differential fast ion energy loss fraction\n \"\"\"\n fig = self._plot_base(self.eorb_d_nbi_1D, yLabel=r'$\\frac{\\partial E}{\\partial r}$',\n title=\"GT3.IOL differential fast ion energy loss fraction\", edge=edge, color='red')\n return fig\n\n\n def plot_all_i_fast(self):\n plot = plt.figure()\n fig1 = plot.add_subplot(111)\n fig1.set_xlabel(r'$\\rho$', fontsize=20)\n fig1.set_ylabel(r'$\\frac{\\partial F}{\\partial r}$', fontsize=25)\n fig1.set_title('Fast ion number loss fraction')\n fig1.scatter(self.rho, self.forb_d_nbi_1D, marker='o', color='blue')\n\n fig2 = plot.add_subplot(121)\n fig2.set_xlabel(r'$\\rho$', fontsize=20)\n fig2.set_ylabel(r'$\\frac{\\partial E}{\\partial r}$', fontsize=25)\n fig2.set_title('Fast ion energy loss fraction')\n fig2.scatter(self.rho, self.eorb_d_nbi_1D, marker='o', color='red')\n\n fig3 = plot.add_subplot(131)\n fig3.set_xlabel(r'$\\rho$', fontsize=20)\n fig3.set_ylabel(r'$\\frac{\\partial M}{\\partial r}$', fontsize=25)\n fig3.set_title('Fast ion momentum loss fraction')\n fig3.scatter(self.rho, self.morb_d_nbi_1D, marker='o', color='green')\n\n return plot", "meta": {"hexsha": "bfb53a6781bcaffa1d8b0e8214269fd65fe9aca0", "size": 17474, "ext": "py", "lang": "Python", "max_stars_repo_path": "GT3/IOL/iol.py", "max_stars_repo_name": "gt-frc/gt3", "max_stars_repo_head_hexsha": "1b27d6ca68b182413be23efeb0282f4a9075212f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2018-10-10T00:11:19.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-08T20:15:16.000Z", "max_issues_repo_path": "GT3/IOL/iol.py", "max_issues_repo_name": "gt-frc/gt3", "max_issues_repo_head_hexsha": "1b27d6ca68b182413be23efeb0282f4a9075212f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 25, "max_issues_repo_issues_event_min_datetime": "2018-05-02T22:16:37.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-13T20:53:38.000Z", "max_forks_repo_path": "GT3/IOL/iol.py", "max_forks_repo_name": "gt-frc/gt3", "max_forks_repo_head_hexsha": "1b27d6ca68b182413be23efeb0282f4a9075212f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2018-06-06T16:07:20.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-03T11:46:23.000Z", "avg_line_length": 46.5973333333, "max_line_length": 117, "alphanum_fraction": 0.4985120751, "include": true, "reason": "import numpy", "num_tokens": 4234, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7154240079185319, "lm_q2_score": 0.2782567877172032, "lm_q1q2_score": 0.19907158629917762}} {"text": "import time\nimport torch\nimport math\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torch.autograd import Variable\nimport utils\nimport numpy as np\n\ndef build_targets(pred_boxes, target, anchors, num_anchors, num_classes, nH, nW, noobject_scale, object_scale, sil_thresh, seen):\n nB = target.size(0)\n nA = num_anchors\n nC = num_classes\n anchor_step = len(anchors)//num_anchors\n conf_mask = torch.ones(nB, nA, nH, nW) * noobject_scale\n conf_mask = conf_mask.view(nB, -1)\n coord_mask = torch.zeros(nB, nA, nH, nW)\n cls_mask = torch.zeros(nB, nA, nH, nW)\n tx = torch.zeros(nB, nA, nH, nW)\n ty = torch.zeros(nB, nA, nH, nW)\n tw = torch.zeros(nB, nA, nH, nW)\n th = torch.zeros(nB, nA, nH, nW)\n tconf = torch.zeros(nB, nA, nH, nW)\n tcls = torch.zeros(nB, nA, nH, nW)\n\n nAnchors = nA*nH*nW\n nPixels = nH*nW\n for b in range(nB):\n cur_pred_boxes = pred_boxes[b*nAnchors:(b+1)*nAnchors].t()\n cur_ious = torch.zeros(nAnchors)\n for t in range(50):\n if target[b][t*5+1] == 0:\n break\n gx = target[b][t*5+1]*nW\n gy = target[b][t*5+2]*nH\n gw = target[b][t*5+3]*nW\n gh = target[b][t*5+4]*nH\n cur_gt_boxes = torch.FloatTensor([gx,gy,gw,gh]).repeat(nAnchors,1).t()\n cur_ious = torch.max(cur_ious, utils.bbox_ious(cur_pred_boxes, cur_gt_boxes, x1y1x2y2=False))\n conf_mask[b][cur_ious>sil_thresh] = 0\n if seen < 12800:\n if anchor_step == 4:\n tx = torch.FloatTensor(anchors).view(nA, anchor_step).index_select(1, torch.LongTensor([2])).view(1,nA,1,1).repeat(nB,1,nH,nW)\n ty = torch.FloatTensor(anchors).view(num_anchors, anchor_step).index_select(1, torch.LongTensor([2])).view(1,nA,1,1).repeat(nB,1,nH,nW)\n else:\n tx.fill_(0.5)\n ty.fill_(0.5)\n tw.zero_()\n th.zero_()\n coord_mask.fill_(1)\n\n conf_mask = conf_mask.view(nB, nA, nH, nW)\n\n nGT = 0\n nCorrect = 0\n for b in range(nB):\n for t in range(50):\n if target[b][t*5+1] == 0:\n break\n nGT = nGT + 1\n best_iou = 0.0\n best_n = -1\n min_dist = 10000\n gx = target[b][t*5+1] * nW\n gy = target[b][t*5+2] * nH\n gi = int(gx)\n gj = int(gy)\n gw = target[b][t*5+3]*nW\n gh = target[b][t*5+4]*nH\n gt_box = [0, 0, gw, gh]\n for n in range(nA):\n aw = anchors[anchor_step*n]\n ah = anchors[anchor_step*n+1]\n anchor_box = [0, 0, aw, ah]\n iou = utils.bbox_iou(anchor_box, gt_box, x1y1x2y2=False)\n if anchor_step == 4:\n ax = anchors[anchor_step*n+2]\n ay = anchors[anchor_step*n+3]\n dist = pow(((gi+ax) - gx), 2) + pow(((gj+ay) - gy), 2)\n if iou > best_iou:\n best_iou = iou\n best_n = n\n elif anchor_step==4 and iou == best_iou and dist < min_dist:\n best_iou = iou\n best_n = n\n min_dist = dist\n\n gt_box = [gx.cuda(), gy.cuda(), gw.cuda(), gh.cuda()]\n pred_box = pred_boxes[b*nAnchors+best_n*nPixels+gj*nW+gi].cuda()\n\n coord_mask[b][best_n][gj][gi] = 1\n cls_mask[b][best_n][gj][gi] = 1\n conf_mask[b][best_n][gj][gi] = object_scale\n tx[b][best_n][gj][gi] = target[b][t*5+1] * nW - gi\n ty[b][best_n][gj][gi] = target[b][t*5+2] * nH - gj\n tw[b][best_n][gj][gi] = math.log(gw/anchors[anchor_step*best_n])\n th[b][best_n][gj][gi] = math.log(gh/anchors[anchor_step*best_n+1])\n iou = utils.bbox_ious(gt_box, pred_box, x1y1x2y2=False) # best_iou\n tconf[b][best_n][gj][gi] = iou\n tcls[b][best_n][gj][gi] = target[b][t*5]\n if iou > 0.5:\n nCorrect = nCorrect + 1\n\n return nGT, nCorrect, coord_mask, conf_mask, cls_mask, tx, ty, tw, th, tconf, tcls\n \nclass YoloLayer(nn.Module):\n def __init__(self, anchor_mask=[], num_classes=0, anchors=[], num_anchors=1):\n super(YoloLayer, self).__init__()\n self.anchor_mask = anchor_mask\n self.num_classes = num_classes\n self.anchors = anchors\n self.num_anchors = num_anchors\n self.anchor_step = len(anchors)/num_anchors\n self.coord_scale = 1\n self.noobject_scale = 1\n self.object_scale = 5\n self.class_scale = 1\n self.thresh = 0.6\n self.stride = 32\n self.seen = 0\n\n def forward(self, output, target=None):\n if self.training:\n #output : BxAs*(4+1+num_classes)*H*W\n losses = []\n# for o_ind, output in enumerate(outputs):\n t0 = time.time()\n nB = output.size(0)\n# nA = self.num_anchors//3\n #nA = self.num_anchors\n nA = len(self.anchor_mask)\n nC = self.num_classes\n nH = output.size(2)\n nW = output.size(3)\n anchors = []\n for am in self.anchor_mask:\n anchors.append(self.anchors[2*am])\n anchors.append(self.anchors[2*am + 1])\n\n output = output.view(nB, nA, (5+nC), nH, nW)\n x = output.index_select(2, Variable(torch.cuda.LongTensor([0]))).view(nB, nA, nH, nW)\n x = F.sigmoid(x)\n y = output.index_select(2, Variable(torch.cuda.LongTensor([1]))).view(nB, nA, nH, nW)\n y = F.sigmoid(y)\n width= output.index_select(2, Variable(torch.cuda.LongTensor([2]))).view(nB, nA, nH, nW) / 416\n height= output.index_select(2, Variable(torch.cuda.LongTensor([3]))).view(nB, nA, nH, nW) / 416\n conf = output.index_select(2, Variable(torch.cuda.LongTensor([4]))).view(nB, nA, nH, nW)\n conf = F.sigmoid(conf)\n cls = output.index_select(2, Variable(torch.linspace(5,5+nC-1,nC)).long().cuda())\n cls = cls.view(nB*nA, nC, nH*nW).transpose(1,2).contiguous().view(nB*nA*nH*nW, nC)\n t1 = time.time()\n\n pred_boxes = torch.cuda.FloatTensor(4, nB*nA*nH*nW)\n grid_x = torch.linspace(0, nW-1, nW).repeat(nH,1).repeat(nB*nA, 1, 1).view(nB*nA*nH*nW).cuda()\n grid_y = torch.linspace(0, nH-1, nH).repeat(nW,1).t().repeat(nB*nA, 1, 1).view(nB*nA*nH*nW).cuda()\n# anchor_w = torch.Tensor(self.anchors[o_ind*nA*2:(o_ind+1)*nA*2]).view(nA, self.anchor_step).index_select(1, torch.LongTensor([0])).cuda()\n# anchor_h = torch.Tensor(self.anchors[o_ind*nA*2:(o_ind+1)*nA*2]).view(nA, self.anchor_step).index_select(1, torch.LongTensor([1])).cuda()\n# anchor_w = torch.Tensor(self.anchors).view(nA, self.anchor_step).index_select(1, torch.LongTensor([0])).cuda()\n# anchor_h = torch.Tensor(self.anchors).view(nA, self.anchor_step).index_select(1, torch.LongTensor([1])).cuda()\n anchor_w = torch.Tensor(anchors).view(nA, self.anchor_step).index_select(1, torch.LongTensor([0])).cuda()\n anchor_h = torch.Tensor(anchors).view(nA, self.anchor_step).index_select(1, torch.LongTensor([1])).cuda()\n\n anchor_w = anchor_w.repeat(nB, 1).repeat(1, 1, nH*nW).view(nB*nA*nH*nW)\n anchor_h = anchor_h.repeat(nB, 1).repeat(1, 1, nH*nW).view(nB*nA*nH*nW)\n pred_boxes[0] = x.view(-1) + grid_x\n pred_boxes[1] = y.view(-1) + grid_y\n pred_boxes[2] = torch.exp(width).view(-1) * anchor_w\n pred_boxes[3] = torch.exp(height).view(-1) * anchor_h\n pred_boxes = utils.convert2cpu(pred_boxes.transpose(0,1).contiguous().view(-1,4))\n t2 = time.time()\n\n nGT, nCorrect, coord_mask, conf_mask, cls_mask,\\\n tx, ty, tw, th, tconf, tcls = \\\n build_targets(pred_boxes, target, anchors, # self.anchors\n nA, nC, nH, nW,\n self.noobject_scale, self.object_scale,\n self.thresh, self.seen)\n cls_mask = (cls_mask == 1)\n nProposals = int((conf > 0.25).sum())\n\n tx = Variable(tx.cuda())\n ty = Variable(ty.cuda())\n tw = Variable(tw.cuda())\n th = Variable(th.cuda())\n tconf = Variable(tconf.cuda())\n tcls = Variable(tcls[cls_mask].long().cuda())\n\n coord_mask = Variable(coord_mask.cuda())\n conf_mask = Variable(conf_mask.cuda().sqrt())\n cls_mask = Variable(cls_mask.view(-1, 1).repeat(1,nC).cuda())\n cls = cls[cls_mask].view(-1, nC)\n\n t3 = time.time()\n\n loss_x = self.coord_scale * nn.MSELoss(size_average=True)(x*coord_mask, tx*coord_mask)/2.0\n loss_y = self.coord_scale * nn.MSELoss(size_average=True)(y*coord_mask, ty*coord_mask)/2.0\n loss_w = self.coord_scale * nn.MSELoss(size_average=True)(width*coord_mask, tw*coord_mask)/2.0\n loss_h = self.coord_scale * nn.MSELoss(size_average=True)(height*coord_mask, th*coord_mask)/2.0\n loss_conf = nn.MSELoss(size_average=True)(conf*conf_mask, tconf*conf_mask)/2.0\n loss_cls = self.class_scale * nn.CrossEntropyLoss(size_average=True)(cls, tcls)\n loss = loss_x + loss_y + loss_w + loss_h + loss_conf + loss_cls\n t4 = time.time()\n if False:\n print('-----------------------------------')\n print(' activation : %f' % (t1 - t0))\n print(' create pred_boxes : %f' % (t2 - t1))\n print(' build targets : %f' % (t3 - t2))\n print(' create loss : %f' % (t4 - t3))\n print(' total : %f' % (t4 - t0))\n print('%d: nGT %d, recall %d, proposals %d, loss: x %f, y %f, w %f, h %f, conf %f, cls %f, total %f' % (self.seen, nGT, nCorrect, nProposals, loss_x.item(), loss_y.item(), loss_w.item(), loss_h.item(), loss_conf.item(), loss_cls.item(), loss.item()))\n return loss\n# losses.append(loss)\n# return sum(losses).cuda()\n else:\n masked_anchors = []\n for m in self.anchor_mask:\n masked_anchors += self.anchors[m*self.anchor_step:(m+1)*self.anchor_step]\n masked_anchors = [anchor/self.stride for anchor in masked_anchors]\n boxes = utils.get_region_boxes(output.data, self.thresh, self.num_classes, masked_anchors, len(self.anchor_mask))\n return boxes\n\n\nclass YoloLayer2(nn.Module):\n def __init__(self, num_classes, anchors, masked_anchors, max_boxes,\n net_width, net_height):\n super(YoloLayer2, self).__init__()\n \n self.num_classes = num_classes\n self.bbox_attribs = 5 + num_classes\n self.net_width = net_width\n self.net_height = net_height\n self.ignore_thresh = 0.5\n # anchors and masked anchors\n self.num_anchors = int(len(anchors)/2)\n self.anchors = anchors\n\n self.masked_anchor_inds = masked_anchors\n masked_anchors = []\n for i in self.masked_anchor_inds:\n masked_anchors.append(self.anchors[2*i])\n masked_anchors.append(self.anchors[2*i+1])\n self.masked_anchors = masked_anchors\n self.mask_size = int(len(masked_anchors)/2)\n \n self.max_boxes = max_boxes\n #self.truths = max_boxes * (4 + 1) probably dont need it\n #self.all_losses = self.batch_size * self.lwidth * self.lheight * self.lfilters # maximum number of losses to pay attention to, for a detection layer\n self.cls_loss = nn.BCELoss(size_average=False, reduce=False)\n self.l1_loss = nn.L1Loss(size_average=False, reduce=False)\n \n \n \n def forward(self, input, targets=None):\n # layer sizes\n batch_size = input.size(0)\n lwidth = input.size(3)\n lheight = input.size(2)\n lfilters = input.size(1)\n \n # reshape predictions to batch * 3 * 25 (for voc) * grid_x * grid_y\n prediction = input.view(batch_size, self.mask_size, self.bbox_attribs,\n lheight, lwidth)\n # permute to have information on the last dimension\n prediction = prediction.permute(0,1,3,4,2).contiguous()\n \n x = torch.sigmoid(prediction[...,0])\n y = torch.sigmoid(prediction[...,1])\n width = prediction[...,2]\n height = prediction[...,3]\n conf = torch.sigmoid(prediction[..., 4])\n pred_cls = torch.sigmoid(prediction[..., 5:])\n \n if targets is not None:\n yolo_boxes = self.get_yolo_boxes(x, y, width, height, self.masked_anchors)\n targets = targets.view(batch_size, -1, 5) \n \n loss_objectness = torch.zeros(batch_size, self.mask_size, lheight, lwidth).cuda()\n for b in range(batch_size):\n preds = yolo_boxes[b]\n best_ious = torch.zeros(batch_size, self.mask_size, lheight, lwidth).cuda()\n for t in targets[b]:\n if t.sum() == 0:\n continue\n ious = utils.bbox_ious(preds.permute(3,0,1,2), t[1:], False)\n best_ious = torch.max(best_ious, ious)\n loss_objectness[b] = -conf[b] # we want loss to be 1 when a box is not with 100% confidence and 0 \n \n loss_x = torch.zeros(1).cuda()\n loss_y = torch.zeros(1).cuda()\n loss_width = torch.zeros(1).cuda()\n loss_height = torch.zeros(1).cuda()\n loss_cls = torch.zeros(1).cuda()\n \n num_truths = 0\n for b in range(batch_size):\n for t in targets[b]:\n if t.sum() == 0:\n continue\n num_truths += 1\n \n gt_i = int(t[1] * lwidth)\n gt_j = int(t[2] * lheight)\n \n truth = torch.tensor([0, 0, t[3], t[4]]).cuda()\n best_anchor = -1\n best_iou = 0\n for anc in range(len(self.anchors)//2):\n anchor_box = torch.tensor([0,0,\n self.anchors[2*anc]/self.net_width,\n self.anchors[2*anc+1]/self.net_height]).cuda()\n iou = utils.bbox_ious(truth, anchor_box, False)\n if iou > best_iou:\n best_iou = iou\n best_anchor = anc\n if best_anchor in self.masked_anchor_inds:\n best_anchor_norm = best_anchor % self.mask_size\n target_pred = yolo_boxes[b][best_anchor_norm][gt_j][gt_i]\n iou = utils.bbox_ious(t[1:], target_pred, False)\n \n tx = t[1]*lwidth - gt_i\n ty = t[2]*lheight - gt_j\n tw = torch.log(t[3]*self.net_width/self.anchors[2*best_anchor_norm])\n th = torch.log(t[4]*self.net_height/self.anchors[2*best_anchor_norm+1])\n scale = 2 * t[2] * t[3]\n \n# loss_x += scale * (tx - x[b][best_anchor_norm][gt_j][gt_i])\n# loss_y += scale * (ty - y[b][best_anchor_norm][gt_j][gt_i])\n# loss_width += scale * (tw - width[b][best_anchor_norm][gt_j][gt_i])\n# loss_height += scale * (th - height[b][best_anchor_norm][gt_j][gt_i])\n loss_x += scale * self.l1_loss(x[b][best_anchor_norm][gt_j][gt_i], tx)\n loss_y += scale * self.l1_loss(y[b][best_anchor_norm][gt_j][gt_i], ty)\n loss_width += scale * self.l1_loss(width[b][best_anchor_norm][gt_j][gt_i], tw)\n loss_height += scale * self.l1_loss(height[b][best_anchor_norm][gt_j][gt_i], th)\n \n loss_objectness[b][best_anchor_norm][gt_j][gt_i] = 1 - conf[b][best_anchor_norm][gt_j][gt_i]\n \n one_hot = torch.zeros(self.num_classes).cuda()\n one_hot[int(t[0])] = 1.\n for c in range(self.num_classes):\n loss_cls += self.cls_loss(pred_cls[b][best_anchor_norm][gt_j][gt_i][c], one_hot[c])\n \n print(\"Loss x {}, loss y {}, loss w {}, loss h {}, loss_cls {}\".format(loss_x/num_truths, loss_y/num_truths, loss_width/num_truths, loss_height/num_truths, loss_cls))\n return torch.sum(-loss_objectness) + loss_x/num_truths + loss_y/num_truths + loss_width/num_truths + loss_height/num_truths + loss_cls\n else:\n yolo_boxes = self.get_yolo_boxes(x, y, width, height, self.masked_anchors)\n \n output = torch.cat(\n (\n yolo_boxes.view(batch_size, -1, 4),\n conf.view(batch_size, -1, 1),\n pred_cls.view(batch_size, -1, self.num_classes),\n ),\n -1,\n )\n return output\n \n# FloatTensor = torch.cuda.FloatTensor if x.is_cuda else torch.FloatTensor\n# LongTensor = torch.cuda.LongTensor if x.is_cuda else torch.LongTensor\n# \n# stride_w = self.net_width/lwidth\n# stride_h = self.net_height/lheight\n# \n# # Calculate offsets for each grid\n# grid_x = torch.linspace(0, lwidth-1, lwidth).repeat(lwidth, 1).repeat(\n# batch_size * self.mask_size, 1, 1).view(x.shape).type(FloatTensor)\n# grid_y = torch.linspace(0, lheight-1, lheight).repeat(lheight, 1).t().repeat(\n# batch_size * self.mask_size, 1, 1).view(y.shape).type(FloatTensor)\n#\n# scaled_anchors = FloatTensor([(a_w / stride_w, a_h / stride_h) for a_w, a_h in np.array(self.masked_anchors).reshape(-1,2)])\n#\n# # Calculate anchor w, h\n# anchor_w = FloatTensor(scaled_anchors).index_select(1, LongTensor([0]))\n# anchor_h = FloatTensor(scaled_anchors).index_select(1, LongTensor([1]))\n# anchor_w = anchor_w.repeat(batch_size, 1).repeat(1, 1, lheight * lwidth).view(width.shape)\n# anchor_h = anchor_h.repeat(batch_size, 1).repeat(1, 1, lheight * lwidth).view(height.shape)\n# # Add offset and scale with anchors\n# pred_boxes = FloatTensor(prediction[..., :4].shape)\n# pred_boxes[..., 0] = x.data + grid_x\n# pred_boxes[..., 1] = y.data + grid_y\n# pred_boxes[..., 2] = torch.exp(width.data) * anchor_w\n# pred_boxes[..., 3] = torch.exp(height.data) * anchor_h\n# # Results\n# _scale = torch.Tensor([stride_w, stride_h] * 2).type(FloatTensor)\n# output = torch.cat((pred_boxes.view(batch_size, -1, 4) * _scale,\n# conf.view(batch_size, -1, 1), pred_cls.view(batch_size, -1, self.num_classes)), -1)\n# \n# return output.data\n \n \n \n def get_yolo_box(self, i, j, x, y, width, height, grid_width, grid_height, net_width, net_height, anchor_x, anchor_y):\n yolo_x = (i + x)/grid_width\n yolo_y = (j + y)/grid_height\n yolo_width = torch.exp(width) * anchor_x / net_width\n yolo_height = torch.exp(height) * anchor_y / net_height\n return torch.tensor([yolo_x, yolo_y, yolo_width, yolo_height]).cuda()\n \n def get_yolo_boxes(self, x, y, width, height, masked_anchors):\n assert x.shape == y.shape == width.shape == height.shape\n net_width = self.net_width\n net_height = self.net_height\n \n batches, num_anchors, grid_w, grid_h = x.shape\n boxes = []\n for b in range(batches):\n for a in range(num_anchors):\n for j in range(grid_h):\n for i in range(grid_w):\n new_x = (i + x[b][a][j][i])/grid_w\n new_y = (j + y[b][a][j][i])/grid_h\n new_width = torch.exp(width[b][a][j][i]) * masked_anchors[a] / net_width\n new_height = torch.exp(height[b][a][j][i]) * masked_anchors[a+1] / net_height\n boxes.append([new_x, new_y, new_width, new_height])\n return torch.tensor(boxes).view(batches, num_anchors, grid_w, grid_h, 4).cuda()", "meta": {"hexsha": "9169891a6e60f8a6951319e6091b6c4ea23f0e63", "size": 20780, "ext": "py", "lang": "Python", "max_stars_repo_path": "yolo_layer.py", "max_stars_repo_name": "georkap/yolo3.pytorch", "max_stars_repo_head_hexsha": "c19b8677b7fe5024244f8ed56d6f41736c08b509", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "yolo_layer.py", "max_issues_repo_name": "georkap/yolo3.pytorch", "max_issues_repo_head_hexsha": "c19b8677b7fe5024244f8ed56d6f41736c08b509", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "yolo_layer.py", "max_forks_repo_name": "georkap/yolo3.pytorch", "max_forks_repo_head_hexsha": "c19b8677b7fe5024244f8ed56d6f41736c08b509", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-01-02T10:19:25.000Z", "max_forks_repo_forks_event_max_datetime": "2019-01-02T10:19:25.000Z", "avg_line_length": 50.193236715, "max_line_length": 262, "alphanum_fraction": 0.5362848893, "include": true, "reason": "import numpy", "num_tokens": 5607, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.640635854839898, "lm_q2_score": 0.3106943704494217, "lm_q1q2_score": 0.19904195360680924}} {"text": "# -*- coding: utf-8 -*-\n\"\"\"\nName: Open source Intelligent Dasymetric Mapping (IDM) script\n\nAuthor: Anam Khan\n\nDate: 5/1/19\n\nDescription: Intelligent Dasymetric Mapping (IDM) disaggregates population \ncounts enumerated by vector source units to the spatial resolution of a \ncategorical ancillary raster containing classes that are indicative of the \nspatial distribution of population within the source units. This script is \nan open source version of the EnviroAtlas IDM toolbox developed by \nTorrin Hultgren for ArcMap: https://www.epa.gov/enviroatlas/dasymetric-toolbox.\nThis version follows the publication by Mennis and Hultgren (2006) with the\nexception that class densities for unsampled ancillary classes are calculated\nusing census polygons where the population estimated for sampled/preset \nancillary classes did not exceed the census population.\n\"\"\"\n\nimport os, sys, json\nfrom osgeo import gdal, ogr\nimport numpy as np\nimport pandas as pd\nimport geopandas as gp\nimport argparse as ap\n\n\n#IDM function\ndef dasy_map (popFeat_path, popCountField, popKeyField, ancRaster_path, \n out_dir, popAreaMin = 1, sampleMin = 3, percent = 0.95, \n uninhab_path = False, anc_nd = 0, pop_nd = 0):\n '''\n Prepare population density rasters given population and ancillary data \n through intelligent dasymetric mapping. -popFeat_path: The path to the \\\n census polygons with unique identifiers and a count of the population for \\\n each polygon. - popCountField: The field in the population_features that \\\n stores the polygon's populations.- popKeyField: The unique identifier \\\n field for each polygon in population_features. -ancRaster_path: The path \\\n to the land cover raster that is used for dasymetric population mapping. \\\n -out_dir: The directory where all outputs will be saved. \\\n -popAreaMin: The minimum number of raster cells in a source polygon for \\\n it to be considered representative of a class (default = 1). -sampleMin: \\\n The minimum number of source units to ensure a representative sample for \\\n a land cover class (default = 3). -percent: The minimum percent of a \\\n source polygon's area that an ancillary class must cover in order for the \\\n source polygon to be considered representative of that class. Enter as a \\\n decimal (default = 0.95). -uninhab_path: An optional shapefile containing \\\n uninhabited areas. -anc_nd: The NoData value for the ancillary raster \\\n (default = 0). -pop_nd: The NoData value for the population \\\n raster (default = 0) \n '''\n #Set config.json file in the script's directory to presetTable\n if __name__ == '__main__':\n presetTable = os.path.join(sys.path[0], \"config.json\")\n else:\n presetTable = os.path.join(sys.path[-1], \"config.json\")\n \n print ('population_features path: {0}'.format(popFeat_path))\n print ('population_count_field: {0}'.format(popCountField))\n print ('population_key_field: {0}'.format(popKeyField))\n print ('ancillary_raster: {0}'.format(ancRaster_path))\n print ('uninhabited_file: {0}'.format(uninhab_path))\n print ('The minimum populated area of a representative unit is ' + str(popAreaMin))\n print ('The minimum sample size is ' + str(sampleMin))\n print ('The percent is ' + str(percent))\n print ('The NoData value for the population raster is ' + str(pop_nd))\n print ('The NoData value for the ancillary raster is ' + str(anc_nd))\n\n #Set file names for outputs\n popRaster = os.path.join(out_dir, \"PopRaster.tif\")\n popWorkTable = os.path.join(out_dir, \"PopTable.csv\")\n dasyRaster = os.path.join(out_dir, \"DasyRaster.tif\")\n dasyWorkTable = os.path.join(out_dir, \"DasyWorkTable.csv\")\n densityRaster = os.path.join(out_dir, \"DensityRaster.tif\")\n \n \"\"\"\n Set driver for raster creation and read in census population features and \n ancillary raster\n \"\"\"\n rast_driver = gdal.GetDriverByName('GTiff')\n ancRaster = gdal.Open(ancRaster_path)\n popFeatures = ogr.Open(popFeat_path)\n popLayer = popFeatures.GetLayer()\n \n '''\n Get GeoTransform from ancillary raster: rows, columns, \n coordinates of upperleft corner for north up images, and projection.\n '''\n rows = ancRaster.RasterYSize\n cols = ancRaster.RasterXSize\n ulx = ancRaster.GetGeoTransform()[0]\n uly = ancRaster.GetGeoTransform()[3]\n anc_proj = ancRaster.GetProjection()\n \n \"\"\"\n Create population raster from census population features using the \n GeoTransform from the ancillary raster. Set pop_nd as the NoData value \n for the population raster. \n \"\"\"\n print (\"Creating population raster...\")\n popRast = rast_driver.Create(popRaster, cols, rows, 1, \n gdal.GDT_Float32, options=[\"COMPRESS=LZW\"])\n popRast.SetGeoTransform((ulx, ancRaster.GetGeoTransform()[1], 0, \n uly, 0, ancRaster.GetGeoTransform()[5]))\n popRast.SetProjection(anc_proj)\n popRast.GetRasterBand(1).SetNoDataValue(pop_nd)\n gdal.RasterizeLayer(popRast, [1], popLayer, \n options = [\"ATTRIBUTE=\" + popKeyField])\n popRast = None\n \n \"\"\"\n Burn the NoData value from the ancillary raster into the pixels that \n overlap uninhabited areas\n \"\"\"\n if uninhab_path:\n uninhab_ds = ogr.Open(uninhab_path)\n uninhabLayer = uninhab_ds.GetLayer()\n uninhab_anc = os.path.join(out_dir, \"uninhab_landcover.tif\")\n uninhab_rast = rast_driver.CreateCopy(uninhab_anc, \n gdal.Open(ancRaster_path), \n options=['COMPRESS=LZW'])\n gdal.RasterizeLayer(uninhab_rast, [1], uninhabLayer, \n burn_values = [anc_nd])\n uninhab_rast = None\n uninhab_ds = None\n ancRaster = gdal.Open(uninhab_anc)\n \n print (\"Creating dasymetric units...\")\n #Read ancillary raster and population raster as array\n anc_arr = ancRaster.GetRasterBand(1).ReadAsArray().astype(np.uint64)\n popRast = gdal.Open(popRaster)\n pop_arr = popRast.GetRasterBand(1).ReadAsArray().astype(np.uint64)\n \n \"\"\"\n Convert pixel values of ancillary raster that do not overlap with census \n polygons to NoData.\n \"\"\"\n anc_arr[pop_arr == pop_nd] = anc_nd\n \n \"\"\"\n Combine the ancillary raster and the population raster using Cantor's \n pairing function to return a unique integer value for a pair(x,y)\n \"\"\"\n comb_arr = 0.5 * (pop_arr + anc_arr) * (pop_arr + anc_arr + 1) + anc_arr \n \n \"\"\"\n Write the combine array to the dasymetric raster using the GeoTransform \n from the ancillary raster\n \"\"\"\n dasyRast = rast_driver.Create(dasyRaster, cols, rows, 1, \n gdal.GDT_Float64, options=['COMPRESS=LZW'])\n dasyRast.SetGeoTransform((ulx, ancRaster.GetGeoTransform()[1], 0, \n uly, 0, ancRaster.GetGeoTransform()[5]))\n dasyRast.SetProjection(anc_proj)\n dasyRast_b1 =dasyRast.GetRasterBand(1)\n dasyRast_b1.WriteArray(comb_arr)\n \n \"\"\"\n Set the NoData value for the dasymetric raster band by running the same \n Cantor's pairing function on the NoData values from the population raster \n and ancillary raster.\n \"\"\"\n dasy_nd = 0.5 * (pop_nd + anc_nd) * (pop_nd + anc_nd + 1) + anc_nd\n dasyRast_b1.SetNoDataValue(dasy_nd)\n dasyRast = None\n \n \"\"\"\n Make the population DataFrame and the dasymetric DataFrame: collect the \n unique values and counts, rearrange the array via transpose, convert to \n DataFrame, and rename columns.\n \"\"\"\n dasy_ar_un = np.array(np.unique(comb_arr, return_counts = True)).T\n dasy_df = pd.DataFrame(dasy_ar_un, columns = (\"Value\", \"Count\"))\n \n pop_ar_un = np.array(np.unique(pop_arr, return_counts = True)).T\n pop_df = pd.DataFrame(pop_ar_un, columns = (\"Value\", \"Count\"))\n \n '''\n Inverse of Cantor's pairing to get the polygon ID and ancillary class \n associated with each dasy unit.\n w = (sqrt(8 * dasy_df['Value'] + 1) - 1) // 2\n '''\n num = 8*dasy_df['Value'] + 1\n dasy_df['w'] = (num.pow(1./2) - 1) // 2\n dasy_df['t'] = (dasy_df['w'].pow(2) + dasy_df['w']) / 2\n dasy_df['ancID'] = dasy_df['Value'] - dasy_df['t'] \n dasy_df['polyID'] = dasy_df['w'] - dasy_df['ancID']\n\n #get rid of unnecessary columns and NoData values\n dasy_df = dasy_df[dasy_df['Value'] != dasy_nd].drop(columns = ['w','t'])\n pop_df = pop_df[pop_df['Value'] != pop_nd]\n\n #Set variables for DataFrame columns\n popIDField = 'polyID'\n ancCatName = 'ancID'\n dasyAreaField = 'Count'\n\n #Make lists to use later\n #All ancillary categories in study area\n inAncCatList = list(np.unique(dasy_df[ancCatName]).astype(int))\n \n ''' \n This list will be populated with ancillary categories that are not sampled \n and do not have preset class densities.\n '''\n unSampledList = []\n \n #Preset class densities from config.json file\n presetData = json.load(open(presetTable))\n \n '''\n Uninhabited classes: ancially classes where people do not live. Classes with\n a preset class density of 0\n '''\n unInhabList = [int(presetCat) for presetCat,presetVal in presetData.items()\n if float(presetVal) == 0]\n \n #Ancillary classes where people can live\n InhabList = [cat for cat in inAncCatList if cat not in unInhabList]\n \n '''\n Join the census population counts to the dasymetric DataFrame and calculate \n population density for the polygon. \n '''\n print (\"Calculating populated area...\")\n #Read the source population shapefile with the population count field.\n popfeat_df = gp.read_file(popFeat_path)\n\n '''\n Set the polygon ID field provided by the user as an index for the \n population features DataFrame and the population DataFrame for joining and \n transfering the population count field.\n '''\n popfeat_df.index = popfeat_df[popKeyField]\n pop_df.index = pop_df[\"Value\"]\n \n '''\n Join population counts from popfeat_df to the dasymetric DataFrame and the \n population DataFrame. Rename the field to \"POP_COUNT\" in the dasymetric \n DataFrame.\n '''\n dasy_df = dasy_df.join(popfeat_df[popCountField], \n on = popIDField).rename(\n columns = {popCountField: \"POP_COUNT\"}\n )\n pop_df = pop_df.join(popfeat_df[popCountField])\n\n '''\n Group the dasymetric units that are associated with inhabitable classes by \n the census polygon ID and take the sum of the dasymetric area in each \n group. Rename the column as \"POP_AREA\".\n POP_AREA = sum(pixels) for inhabitable classes\n '''\n popAreaSum = dasy_df[\n dasy_df[ancCatName].isin(InhabList)\n ].groupby(popIDField)[dasyAreaField].sum().rename(\"POP_AREA\")\n\n '''\n Transfer \"POP_AREA\" from popAreaSum to the dasymetric DataFrame and the \n population DataFrame.\n ''' \n dasy_df[\"POP_AREA\"] = dasy_df.join(popAreaSum, on = popIDField)[\"POP_AREA\"]\n pop_df = pop_df.join(popAreaSum).fillna(0)\n\n '''\n Calculate population density for census polygons where poulated area is \n greater than 0.\n '''\n print (\"Calculating population density...\") \n pop_densMask = pop_df[\"POP_AREA\"] > 0\n pop_df.loc[pop_densMask, \"POP_DENS\"] = pop_df.loc[\n pop_densMask, popCountField] / pop_df.loc[pop_densMask, \"POP_AREA\"]\n #replace NaN with 0\n pop_df = pop_df.fillna(0)\n \n '''\n Calculate representative population density for ancillary classes that have \n enough representative samples in the study area.\n '''\n print (\"Selecting representative units...\")\n #Create column for the ancillary class that a polygon is representative of \n pop_df[\"REP_CAT\"] = 0\n\n '''\n For each inhabitable ancillary class, collect polygon IDs of census \n polygons that meet the user-define criteria for being representative of an \n ancillary class.\n ''' \n for inAncCat in InhabList:\n repUnits_mask = (\n dasy_df[\"POP_AREA\"] > float(popAreaMin)\n ) & (\n dasy_df[ancCatName] == inAncCat\n )\n repUnits = dasy_df.loc[\n repUnits_mask, [\n dasyAreaField, popIDField, ancCatName, \"POP_AREA\"\n ]\n ]\n repUnits[\"PERCENT\"] = repUnits[dasyAreaField] / repUnits[\"POP_AREA\"] \n repUnits = list(\n repUnits[repUnits[\"PERCENT\"] >= float(percent)][popIDField]\n )\n \n if len(repUnits) >= float(sampleMin):\n pop_df.loc[pop_df['Value'].isin(repUnits), \"REP_CAT\"] = inAncCat\n print (\"Class \" \n + str(inAncCat) \n + \" was sufficiently sampled with \" \n + str(len(repUnits)) \n + \" representative source units.\")\n \n '''\n #If ancillary category has no representative polygons and it does \n not have a preset class density, then add it to the list of \n unsampled classes.\n '''\n elif str(inAncCat) not in list(presetData):\n unSampledList.append(int(inAncCat))\n print (\"Class \" \n + str(inAncCat) \n + \" was not sufficiently sampled with only \" \n + str(len(repUnits)) \n + \" representative source units.\")\n \n #Calculate statistics and make sampling summary table\n print (\n \"Calculating representative population density for selected\" \\\n \" classes...\"\n )\n \n '''\n Create a mask for rows in the dasymetric DataFrame where REP_CAT =! 0. \n We only want to create summaries for these dasymetric rows because they are \n associated with representative polygons.\n '''\n rep_mask = pop_df[\"REP_CAT\"] != 0\n\n '''\n Calculate sum of census population counts and sum of populated area for \n each sampled ancillary class.\n '''\n classDens_df = pop_df[rep_mask].groupby(\"REP_CAT\")[\n [popCountField, 'POP_AREA']\n ].sum().rename(\n columns = {popCountField: \"SUM_\" + popCountField, \n \"POP_AREA\": \"SUM_POP_AREA\"}\n )\n \n #Calculate sample density for sampled classes\n classDens_df[\"SAMPLEDENS\"] = classDens_df[\n \"SUM_\" + popCountField\n ] / classDens_df[\"SUM_POP_AREA\"]\n classDens_df[\"METHOD\"] = \"Sampled\"\n classDens_df[\"CLASSDENS\"] = classDens_df[\"SAMPLEDENS\"]\n \n #Add preset densities to summary table\n if presetTable:\n print (\"Adding preset values to the summary table...\")\n for preset_cat in list(presetData):\n classDens_df.loc[int(preset_cat), \"CLASSDENS\"] = presetData[\n preset_cat\n ]\n classDens_df.loc[int(preset_cat), \"METHOD\"] = 'Preset'\n \n # For all sampled and preset classes, calculate a population estimate.\n print (\n \"Calculating population estimate for sampled and preset classes...\"\n ) \n #Get representative population densities from class density DataFrame.\n dasy_df = dasy_df.join(classDens_df['CLASSDENS'], on = ancCatName).fillna(0)\n \n '''\n #Set mask for dasy_df that will limit ancillary categories to those in the \n class density DataFrame.\n '''\n popEst_mask = dasy_df[ancCatName].isin(classDens_df.index)\n \n '''\n POP_EST = area of the dasymetric unit \n * the representative population density of the ancillary class associated \n with the dasymetric unit\n '''\n dasy_df[\"POP_EST\"] = 0\n dasy_df.loc[popEst_mask, \"POP_EST\"] = dasy_df.loc[\n popEst_mask, dasyAreaField\n ] * dasy_df.loc[\n popEst_mask, 'CLASSDENS'\n ]\n \n # Intelligent areal weighting for unsampled classes \n print (\"Performing intelligent areal weighting for unsampled classes...\")\n if unSampledList:\n '''\n Calculate representative population densities for unsampled ancillary \n classes using IAW\n '''\n unsampled_mask = dasy_df[ancCatName].isin(unSampledList)\n \n '''\n Populate remainining area of each dasymetric unit as the area of \n dasymetric units associated with unsampled classes and 0 everywhere \n else.\n '''\n dasy_df[\"REM_AREA\"] = 0\n dasy_df.loc[unsampled_mask, \"REM_AREA\"] = dasy_df.loc[\n unsampled_mask, dasyAreaField\n ]\n \n ''' \n For each polygon, sum the remaining area and sum the population that \n has already been estimated for sampled/preset classes.\n '''\n popEstSum = dasy_df.groupby(popIDField)[\n [\"POP_EST\", \"REM_AREA\"]\n ].sum()\n \n '''\n Join popEstSum to dasy_df to transfer the sum of population estimates \n and the sum of remaining area to the dasymetric DataFrame.\n '''\n dasy_df = dasy_df.join(popEstSum[\"POP_EST\"], on = popIDField, \n rsuffix = \"poly\")\n dasy_df = dasy_df.join(popEstSum[\"REM_AREA\"], on = popIDField, \n rsuffix = \"poly\")\n \n '''\n Calcualte a population difference between the census population and the \n population estimated for sampled/preset ancillary classes.\n '''\n dasy_df[\"POP_DIFF\"] = dasy_df[\"POP_COUNT\"] - dasy_df[\"POP_ESTpoly\"]\n \n '''\n Calculate an initial population estimate for dasymetric units \n associated with unsampled ancillary classes and polygons where the \n sampled/preset population estimates did not exceed the census \n population count. \n '''\n diff_mask = (dasy_df[ancCatName].isin(unSampledList) &\n dasy_df['REM_AREApoly'] !=0 )\n dasy_df.loc[diff_mask, \"POP_EST\"] = (\n dasy_df.loc[diff_mask, \"POP_DIFF\"].clip(0) * \n dasy_df.loc[diff_mask, \"REM_AREA\"] / \n dasy_df.loc[diff_mask, \"REM_AREApoly\"])\n '''\n Sum total initial population estimates and remaining area for \n dasymetric units used to calculate initial population estimates for \n unsampled ancillary classes.\n '''\n ancCat_sum = dasy_df[diff_mask].groupby(ancCatName)[\n [\"POP_EST\" , \"REM_AREA\"]\n ].sum()\n \n '''\n Calculate the representative population density for unsampled classes \n using ancCat_sum and update the class density DataFrame.\n '''\n for cat in ancCat_sum.index:\n classDens_df.loc[cat, \"CLASSDENS\"] = ancCat_sum.loc[cat, \n \"POP_EST\"] / ancCat_sum.loc[cat, \n \"REM_AREA\"]\n classDens_df.loc[cat, \"METHOD\"] = \"IAW\" \n \n '''\n Add representative population densities for unsampled classes in the \n dasymetric DataFrame.\n '''\n dasy_df.loc[unsampled_mask, 'CLASSDENS'] = dasy_df.loc[\n unsampled_mask\n ].join(classDens_df.loc[\n ancCat_sum.index, 'CLASSDENS'\n ], \n on = ancCatName, rsuffix = \"_classDens\")['CLASSDENS_classDens']\n \n '''\n Calculate new population estimates using representative population \n densities for unsampled classes.\n POP_EST = dasymetric area * class density\n '''\n dasy_df.loc[unsampled_mask, \"POP_EST\"] = dasy_df.loc[unsampled_mask, \n dasyAreaField] * dasy_df.loc[unsampled_mask, \n 'CLASSDENS']\n \n # End of intelligent areal weighting\n \n # Perform final calculations to ensure pycnophylactic integrity\n print (\n \"Performing final calculations to ensure pycnophylactic\" \\\n \" integrity...\"\n )\n '''\n For each dasymetric unit, use the ratio of the estimated population to the \n total population estimated for the polygon associated with the dasymetric \n unit to redistribute the census population.\n '''\n\n '''\n if the sum of population densities within the source unit is equal to 0\n set the POP_EST for those to 1 (i.e., area weighting (equation 5))\n '''\n\n idx = (dasy_df\n .groupby(popIDField)\n .filter(\n lambda s: s['POP_EST'].sum() == 0 and\n s['POP_COUNT'].sum() > 0\n ).index\n )\n\n dasy_df.loc[idx, 'POP_EST'] = 1\n \n #Sum population estimates by polygon.\n popEstsum = dasy_df.groupby(popIDField)[\"POP_EST\"].sum()\n \n dasy_df[\"TOTALFRACT\"] = dasy_df[\"POP_EST\"] / dasy_df.join(popEstsum, \n on = popIDField, rsuffix = \"SUM\")[\"POP_ESTSUM\"]\n dasy_df[\"NEW_POP\"] = dasy_df[\"TOTALFRACT\"] * dasy_df[\"POP_COUNT\"]\n dasy_df[\"NEWDENSITY\"] = dasy_df[\"NEW_POP\"] / dasy_df[dasyAreaField]\n \n #Replace nan with 0\n dasy_df = dasy_df.fillna(0)\n \n #export dasy table to .csv\n dasy_df.to_csv(dasyWorkTable, header = True)\n \n #export pop_df to .csv\n pop_df.fillna(0).to_csv(popWorkTable, header = True)\n \n #export classDens_df to sampling summary table\n classDens_df.to_csv(os.path.join(out_dir, \"SamplingSummaryTable.csv\"), \n header = True)\n \n #Create final population density raster.\n print (\"Creating population density raster...\")\n #Create population density array.\n dasy_lut = dasy_df[['Value', 'NEWDENSITY']].set_index('Value')\n dasy_lut.loc[dasy_nd, 'NEWDENSITY'] = -999 #NoData value from comb_arr\n dens_df = pd.DataFrame(np.ravel(comb_arr)).join(dasy_lut, on = 0)\n dens_ar = np.array(\n dens_df['NEWDENSITY']\n ).reshape(\n (comb_arr.shape[0], comb_arr.shape[1])\n )\n \n #Write array to population density raster.\n densRast = rast_driver.Create(densityRaster, cols, rows, 1, \n gdal.GDT_Float32, options=['COMPRESS=LZW'])\n densRast.SetGeoTransform((ulx, ancRaster.GetGeoTransform()[1], 0, \n uly, 0, ancRaster.GetGeoTransform()[5]))\n densRast.SetProjection(anc_proj)\n densRast_b1 =densRast.GetRasterBand(1)\n densRast_b1.WriteArray(dens_ar)\n densRast_b1.SetNoDataValue(-999)\n densRast = None\n \n print (\"All outputs from this tool can be found in \" + out_dir)\n\n#------------------------------------------------------------------------------\n#Get arguments to run dasy_pop from command line\nif __name__ == '__main__':\n #create ArgumentParser\n parser = ap.ArgumentParser(description='This script accepts population \\\n and ancillary datasets for preparing \\\n population density rasters using intelligent \\\n dasymetric mapping.')\n \n #add arguments\n parser.add_argument('population_features', type = str, \n help = 'The census polygons with unique identifiers \\\n and a count of the population for each polygon')\n parser.add_argument('population_count_field', type = str, \n help = \"The field in the population_features that \\\n stores the polygon's populations\")\n parser.add_argument('population_key_field', type = str, \n help = \"The unique identifier field for each polygon \\\n in population_features\")\n parser.add_argument('ancillary_raster', type = str, \n help = \"The land cover raster that is used for \\\n dasymetric population mapping\")\n parser.add_argument('output_directory', type = str, \n help = \"The directory where all outputs from the \\\n script will be saved.\")\n parser.add_argument('--uninhabited_file', type = str, nargs='?', \n help = \"An optional feature class containing \\\n uninhabited areas\")\n parser.add_argument('--minimum_sampling_area', type = int, \n nargs='?',default = 1, \n help = \"The minimum number of raster cells in a \\\n source polygon for it to be considered representative \\\n of a class - default = 1\")\n parser.add_argument('--minimum_sample', type = int, nargs='?', default = 3, \n help = \"The minimum number of source units to ensure \\\n a representative sample for a land cover class \\\n - default = 3\")\n parser.add_argument('--percent', type = float, nargs='?', default = 0.95, \n help = \"The minimum percent of a source polygon's \\\n area that an ancillary class must cover in order for \\\n the source polygon to be considered representative of \\\n that class. Please enter as a decimal \\\n - default = 0.95\")\n parser.add_argument('--pop_nodata', type = int, nargs='?', default = 0, \n help = \"The population_features will be converted to \\\n raster and this will be the NoData value \\\n - default = 0\")\n parser.add_argument('--anc_nodata', type = int, nargs='?', default = 0, \n help = \"The NoData value for the ancillary raster \\\n - default = 0\") \n\n #get args\n args = parser.parse_args()\n \n #run function\n dasy_map(\n popFeat_path = args.population_features, \n popCountField = args.population_count_field, \n popKeyField = args.population_key_field, \n ancRaster_path = args.ancillary_raster, \n popAreaMin = args.minimum_sampling_area, \n sampleMin = args.minimum_sample,\n percent = args.percent, \n uninhab_path = args.uninhabited_file,\n out_dir = args.output_directory,\n anc_nd = args.pop_nodata,\n pop_nd = args.anc_nodata\n )\n", "meta": {"hexsha": "19a33ab0b517ebb338137ffedfbf338ef1dad059", "size": 26586, "ext": "py", "lang": "Python", "max_stars_repo_path": "idm.py", "max_stars_repo_name": "USEPA/Dasymetric-Toolbox-OpenSource", "max_stars_repo_head_hexsha": "d57c6c06b265b85eb3c4c62140d917405e37d161", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 9, "max_stars_repo_stars_event_min_datetime": "2019-12-17T16:34:50.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-16T02:31:30.000Z", "max_issues_repo_path": "idm.py", "max_issues_repo_name": "USEPA/Dasymetric-Toolbox-OpenSource", "max_issues_repo_head_hexsha": "d57c6c06b265b85eb3c4c62140d917405e37d161", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "idm.py", "max_forks_repo_name": "USEPA/Dasymetric-Toolbox-OpenSource", "max_forks_repo_head_hexsha": "d57c6c06b265b85eb3c4c62140d917405e37d161", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-10-28T07:35:08.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-28T07:35:08.000Z", "avg_line_length": 42.4019138756, "max_line_length": 92, "alphanum_fraction": 0.6103964493, "include": true, "reason": "import numpy", "num_tokens": 6194, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.542863297964157, "lm_q2_score": 0.36658975016245987, "lm_q1q2_score": 0.19900812077304933}} {"text": "# -*- coding: utf-8 -*-\n\"\"\"Randk-Order-Based clustering algorithm.\n\nI combine Approximate-Rank-Order algorithm and Chinese-Whispers algorithm\n in ROCWClustering class.\n\"\"\"\n# Author: Soroush Moazed \n\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport itertools\n\nimport numpy as np\nfrom sklearn.neighbors import NearestNeighbors\n\n\nclass BaseClustering:\n\n def __init__(self):\n pass\n\n def fit_predict(self, X):\n pass\n\n def score(self, X, y_true):\n y_pred = self.fit_predict(X)\n pairwise_precision = self._calc_pw_precision(y_pred, y_true)\n pairwise_recall = self._calc_pw_recall(y_pred, y_true)\n pairwise_f_measure = 2 * (pairwise_precision * pairwise_recall)\\\n / (pairwise_precision + pairwise_recall)\n return pairwise_f_measure, pairwise_precision, pairwise_recall\n\n @staticmethod\n def _calc_pw_precision(y_pred, y_true):\n unique_clusters = np.unique(y_pred)\n n_pairs = 0\n n_same_class_pairs = 0\n for cluster in unique_clusters:\n sample_indices = np.where(y_pred == cluster)[0]\n combs = np.array(list(itertools.combinations(sample_indices, 2)), dtype=np.int64)\n if not np.any(combs):\n continue\n combs_classes = y_true[combs]\n same_class_pairs = np.where(combs_classes[:, 0] == combs_classes[:, 1])[0]\n n_pairs += len(combs)\n n_same_class_pairs += len(same_class_pairs)\n pw_precision = n_same_class_pairs / n_pairs\n return pw_precision\n\n @staticmethod\n def _calc_pw_recall(y_pred, y_true):\n unique_classes = np.unique(y_true)\n n_pairs = 0\n n_same_cluster_pairs = 0\n for clss in unique_classes:\n sample_indices = np.where(y_true == clss)[0]\n combs = np.array(list(itertools.combinations(sample_indices, 2)), dtype=np.int64)\n if not np.any(combs):\n continue\n combs_clusters = y_pred[combs]\n same_cluster_pairs = np.where(combs_clusters[:, 0] == combs_clusters[:, 1])[0]\n n_pairs += len(combs)\n n_same_cluster_pairs += len(same_cluster_pairs)\n pw_recall = n_same_cluster_pairs / n_pairs\n return pw_recall\n\n\nclass ROCWClustering(BaseClustering):\n\n \"\"\"Approximated rank-order clustering implemented using Chinese Whispers algorithm.\n\n Using rank-order distances generate a graph, and feed this graph to ChineseWhispers\n algorithm for clustering.\n \"\"\"\n\n def __init__(self, k, metric, n_iteration, algorithm):\n super().__init__()\n self.k = k\n self.metric = metric\n self.n_iteration = n_iteration\n self.knn_algorithm = algorithm\n\n def fit_predict(self, X):\n if len(X) > self.k:\n graph = ROGraph(self.k, self.metric, algorithm=self.knn_algorithm)\n else:\n graph = ROGraph(len(X), self.metric, algorithm=self.knn_algorithm)\n adjacency_mat = graph.generate_graph(X)\n clusterer = ChineseWhispersClustering(self.n_iteration)\n labels = clusterer.fit_predict(adjacency_mat)\n return labels\n\n\nclass ChineseWhispersClustering:\n\n def __init__(self, n_iteration=5):\n self.n_iteration = n_iteration\n self.adjacency_mat_ = None\n self.labels_ = None\n\n def fit_predict(self, adjacency_mat):\n\n \"\"\"Fits and returns labels for samples\"\"\"\n\n n_nodes = adjacency_mat.shape[0]\n indices = np.arange(n_nodes)\n labels_mat = np.arange(n_nodes)\n for _ in range(self.n_iteration):\n np.random.shuffle(indices)\n for ind in indices:\n weights = adjacency_mat[ind]\n winner_label = self._find_winner_label(weights, labels_mat)\n labels_mat[ind] = winner_label\n self.adjacency_mat_ = adjacency_mat\n self.labels_ = labels_mat\n return labels_mat\n\n @staticmethod\n def _find_winner_label(node_weights, labels_mat):\n adjacent_nodes_indices = np.where(node_weights > 0)[0]\n adjacent_nodes_labels = labels_mat[adjacent_nodes_indices]\n unique_labels = np.unique(adjacent_nodes_labels)\n label_weights = np.zeros(len(unique_labels))\n for ind, label in enumerate(unique_labels):\n indices = np.where(adjacent_nodes_labels == label)\n weight = np.sum(node_weights[adjacent_nodes_indices[indices]])\n label_weights[ind] = weight\n winner_label = unique_labels[np.argmax(label_weights)]\n return winner_label\n\n\nclass ROGraph:\n\n def __init__(self, k, metric, algorithm):\n\n self.k = k\n self.metric = metric\n self.knn_algorithm = algorithm\n self.adjacency_mat_ = None\n\n @property\n def adjacency_mat(self):\n return self.adjacency_mat_\n\n def generate_graph(self, X):\n order_lists = self._get_knns(X)\n pw_distances = self._generate_normalized_pw_distances(order_lists)\n adjacency_mat = self._generate_adjacency_mat(pw_distances)\n return adjacency_mat\n\n def _get_knns(self, X):\n\n \"\"\"Generates order lists and absolute distances of k-nearest-neighbors\n for each data point.\n \"\"\"\n\n nbrs = NearestNeighbors(n_neighbors=self.k,\n algorithm=self.knn_algorithm,\n metric=self.metric).fit(X)\n _, order_lists = nbrs.kneighbors(X)\n return order_lists\n\n def _generate_normalized_pw_distances(self, order_lists):\n n_samples = len(order_lists)\n combs = itertools.combinations([i for i in range(n_samples)], 2)\n pw_distances = np.zeros((n_samples, n_samples))\n for ind1, ind2 in combs:\n order_list_1, order_list_2 = order_lists[ind1], order_lists[ind2]\n pw_dist = self._calc_pw_dist(ind1, ind2, order_list_1, order_list_2)\n pw_distances[ind1, ind2] = pw_dist\n pw_distances = pw_distances / pw_distances.max()\n pw_distances = pw_distances + pw_distances.T\n return pw_distances\n\n def _generate_adjacency_mat(self, pw_distances):\n adjacency_mat = self._dist2adjacency(pw_distances)\n self.adjacency_mat_ = adjacency_mat\n return adjacency_mat\n\n @staticmethod\n def _dist2adjacency(distances):\n mask_mat = np.zeros(distances.shape)\n mask_mat[np.where(distances > 0)] = 1\n adjacency_mat = (1 - distances) * mask_mat\n return adjacency_mat\n\n def _calc_pw_dist(self, ind_a, ind_b, order_list_a, order_list_b):\n pw_dist = 0.0\n if np.any(np.intersect1d(order_list_a, order_list_b)):\n order_b_in_a, order_a_in_b = self._calc_orders(ind_a, ind_b, order_list_a, order_list_b)\n d_m_ab = self._calc_dm(order_list_a, order_list_b, order_b_in_a)\n d_m_ba = self._calc_dm(order_list_b, order_list_a, order_a_in_b)\n min_of_two = min(order_a_in_b, order_b_in_a)\n pw_dist = (d_m_ab + d_m_ba) / min_of_two\n return pw_dist\n\n def _calc_orders(self, ind_a, ind_b, order_list_a, order_list_b):\n order_b_in_a = np.where(order_list_a == ind_b)[0]\n if not np.any(order_b_in_a):\n order_b_in_a = self.k\n else:\n order_b_in_a = order_b_in_a[0]\n order_a_in_b = np.where(order_list_b == ind_a)[0]\n if not np.any(order_a_in_b):\n order_a_in_b = self.k\n else:\n order_a_in_b = order_a_in_b[0]\n return order_b_in_a, order_a_in_b\n\n def _calc_dm(self, order_list_a, order_list_b, order_b_in_a):\n dist = 0\n for i in range(min(self.k, order_b_in_a)):\n sample_index = order_list_a[i]\n if np.any(order_list_b == sample_index):\n dist += 1 / self.k\n else:\n dist += 1\n return dist\n", "meta": {"hexsha": "22d26fbce1e7aeed0b6a50da449c9753f965bb4c", "size": 7887, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/clustering.py", "max_stars_repo_name": "iamsoroush/facekoo", "max_stars_repo_head_hexsha": "d8569fe188628d35e8b2f39e1e753fa91141144d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/clustering.py", "max_issues_repo_name": "iamsoroush/facekoo", "max_issues_repo_head_hexsha": "d8569fe188628d35e8b2f39e1e753fa91141144d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/clustering.py", "max_forks_repo_name": "iamsoroush/facekoo", "max_forks_repo_head_hexsha": "d8569fe188628d35e8b2f39e1e753fa91141144d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.85, "max_line_length": 100, "alphanum_fraction": 0.6480284012, "include": true, "reason": "import numpy", "num_tokens": 1834, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5428632831725053, "lm_q2_score": 0.3665897501624599, "lm_q1q2_score": 0.19900811535058147}} {"text": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n##############\n# GPathFinder: Identification of ligand pathways by a multi-objective\n# genetic algorithm\n# \n# https://github.com/insilichem/gpathfinder\n#\n# Copyright 2019 José-Emilio Sánchez Aparicio, Giuseppe Sciortino,\n# Daniel Villadrich Herrmannsdoerfer, Pablo Orenes Chueca, \n# Jaime Rodríguez-Guerra Pedregal and Jean-Didier Maréchal\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n# \n# http://www.apache.org/licenses/LICENSE-2.0\n# \n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n##############\n\n\"\"\"\nThis script complements the Gpath gene by generating a refined pathway from the \nframes it provides. The new interpolated frames avoid high clashscore conformations\nthrough a RRT path planning algorithm.\n\"\"\"\n\nimport time\nimport random\nimport math\nimport copy\nimport heapq\nimport shutil\nimport yaml\nimport zipfile\nfrom argparse import ArgumentParser\n\nimport pychimera\npychimera.patch_environ()\npychimera.enable_chimera()\n\nfrom Combine import combine\nimport chimera\nimport mdtraj\nimport numpy as np\nimport Matrix as M\nimport itertools, operator\nimport os\n\nfrom FitMap.search import random_rotation\nfrom Molecule import atom_positions\n\nimport pprint\npp = pprint.PrettyPrinter(4)\n\nimport gpath\nfrom gpath import base\nfrom gpath.genes import path_normalmodes\nfrom gpath.genes import molecule\nfrom gpath.genes import path_torsion as torsion\nfrom gpath.genes import path_rotamers as rotamers\nfrom gpath.objectives import contacts\n\n\ndef parse_rotamers(chi_groups,node):\n\t\"\"\"\n\tSlices rotamer angles into a list of lists for all chi angles in a given rotamer.\n\n\tParameters\n\t----------\n\tchi_groups : \n\t unparsed list of rotmaer angles\n\tnode : TYPE\n\t Description\n\t\n\tReturns\n\t-------\n\tTYPE\n\t Description\n\t\"\"\"\n\tparsed_chi_groups=[]\n\tchi_groups = sorted(chi_groups, key=operator.itemgetter(2))\n\tfor residue, group in itertools.groupby(chi_groups, operator.itemgetter(2)):\n\t\tg_list=list(group)\n\t\tchis=[item[3] for item in g_list]\n\t\tparsed_chi_groups.append([residue,chis])\n\n\tchi_num=[len(chi_item[1]) for chi_item in parsed_chi_groups]\n\tit = iter(node['rotamers'])\n\tsliced =[list(itertools.islice(it, 0, i)) for i in chi_num]\n\n\tparsed_chi_groups=[ [residue,node_chis] for (residue,__), node_chis in zip(parsed_chi_groups,sliced) ]\n\treturn parsed_chi_groups\n\ndef merge_two_dicts(residue_dict_start, residue_dict_end):\n\t\"\"\"Merge two dictionaries into one.\n\t\n\tParameters\n\t----------\n\tresidue_dict_start : dict\n\tresidue_dict_end : dict\n\t\n\tReturns\n\t-------\n\tresidue_dict_merged: dict\n\t\"\"\"\n\tresidue_dict_merged = residue_dict_start.copy()\n\tresidue_dict_merged.update(residue_dict_end)\n\treturn residue_dict_merged\n\ndef slerp(p0, p1, t):\n\t\"\"\"\n\tComputes slerp interpolation of the quaternions associated with the rotation matrices of the ligand.\n\t\n\tParameters\n\t----------\n\tp0 : list\n\t\tInitial quaternion\n\tp1 : list\n\t\tEnd quaternion\n\tt : float\n\t\tinterpolation fraction\n\t\n\tReturns\n\t-------\n\tlist\n\t\tinterpolated quaternion as list of floats\n\t\"\"\"\n\tdot = np.dot(p0 / np.linalg.norm(p0), p1 / np.linalg.norm(p1))\n\n\tdot_threshold = 0.9995\n\tif dot > dot_threshold:\n\t\tresult = p0 + t * (p1 - p0)\n\t\tresult = result / np.linalg.norm(result)\n\t\tresult = result / np.linalg.norm(result)\n\t\treturn result\n\n\tomega = np.arccos(dot)\n\tso = np.sin(omega)\n\tresult = np.sin((1.0 - t) * omega) / so * p0 + np.sin(t * omega) / so * p1\n\tresult = result / np.linalg.norm(result)\n\treturn result\n\ndef correct_geometry(v):\n\t\"\"\"\n\n\tIf needed, identifies expanded angles with a corresponding one in the range (-180,180)\n\t\n\tParameters\n\t----------\n\tv : list\n\t\ttorsion or rotamer angle list that needs to be corrected to the range (-180,180)\n\t\n\tReturns\n\t-------\n\tlist\n\t\tcorrected list of rotamer angles\n\t\"\"\"\n\n\tfor v_comp in v:\n\t\tif v_comp > 180.0:\n\t\t\tv_comp = v_comp - 360.0\n\t\tif v_comp < -180.0:\n\t\t\tv_comp = v_comp + 360.0\n\treturn v\n\n\ndef correct_quaternion_geometry(node1, node2):\n\t\"\"\"\n\tEnsure that the dot product of two quaterions is always positive as required by the slerp method\n\t\n\tParameters\n\t----------\n\tnode1 : dict\n\tnode2 : dict\n\t\"\"\"\n\tif sum([node1_comp * node2_comp for node1_comp, node2_comp in zip(node1['rotation'], node2['rotation'])]) < 0:\n\t\tnode2['rotation'] = [-node2_comp for node2_comp in node2['rotation']]\n\n\ndef diff_node(node1, node2):\n\t\"\"\"\n\tCompute the difference of two nodes. Used to obtain the direction of expansion towards the nearest node\n\tand to compute the distance between two nodes. Also applies the required geometric corrections\n\tcorrect_geometry and correct_quaternion_geometry\n\t\n\tParameters\n\t----------\n\tnode1 : dict\n\tnode2 : dict\n\t\n\tReturns\n\t-------\n\tdiff_dict : dict\n\t\tdictionary of node attributes, with values equal to the difference of the attributes of the two nodes\n\t\"\"\"\n\tdiff_dict = {}\n\n\tfor key in node1.keys():\n\t\tif key == 'mode':\n\t\t\tdiff_dict[key] = [node2_comp - node1_comp for node2_comp, node1_comp in\n\t\t\t\t\t\t\t\t\t\t zip(node2[key],node1[key])]\n\t\tif key == 'torsions':\n\t\t\tdiff_dict[key] = [node2_comp - node1_comp for node2_comp,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t node1_comp in\n\t\t\t\t\t\t\t\t\t\t zip(node2[key],node1[key])]\n\t\t\tcorrect_geometry(diff_dict[key])\n\t\tif key == 'rotamers':\n\t\t\tdiff_dict[key] = [node2_comp - node1_comp for node2_comp,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t node1_comp in\n\t\t\t\t\t\t\t\t\t\t zip(node2[key],node1[key])]\n\t\t\tcorrect_geometry(diff_dict[key])\n\t\tif key == 'rotation':\n\t\t\tcorrect_quaternion_geometry(node1, node2)\n\t\t\tdiff_dict[key] = [node2_comp - node1_comp for node2_comp,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t node1_comp in\n\t\t\t\t\t\t\t\t\t\t zip(node2[key],node1[key])]\n\t\tif key == 'translation':\n\t\t\tdiff_dict[key] = [node2_comp - node1_comp for node2_comp,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t node1_comp in\n\t\t\t\t\t\t\t\t\t\t zip(node2[key],node1[key])]\n\treturn diff_dict\n\ndef make_norm_dict(node1, node2):\n\t\"\"\"\n\tCreates a dictionary of the distance of each attribute of two nodes\n\tUsed in order to normalize the expansion vector created in expand()\n\t\n\tParameters\n\t----------\n\tnode1 : dict\n\tnode2 : dict\n\t\n\tReturns\n\t-------\n\tnorm_dict : dict\n\t\tdictionary of distances\n\t\"\"\"\n\tdiff_dict = diff_node(node1, node2)\n\tnorm_dict = {}\n\tfor key in diff_dict.keys():\n\t\tif key == 'mode':\n\t\t\tnorm_dict[key] = math.sqrt(\n\t\t\t\tsum([dx_comp * dx_comp for dx_comp in diff_dict[key]]))\n\t\tif key == 'torsions':\n\t\t\tnorm_dict[key] = math.sqrt(\n\t\t\t\tsum([dx_comp * dx_comp for dx_comp in diff_dict[key]]))\n\t\tif key == 'rotamers':\n\t\t\tnorm_dict[key] = math.sqrt(\n\t\t\t\tsum([dx_comp * dx_comp for dx_comp in diff_dict[key]]))\n\t\tif key == 'rotation':\n\t\t\tnorm_dict[key] = math.sqrt(\n\t\t\t\tsum([dx_comp * dx_comp for dx_comp in diff_dict[key]]))\n\t\tif key == 'translation':\n\t\t\tnorm_dict[key] = math.sqrt(\n\t\t\t\tsum([dx_comp * dx_comp for dx_comp in diff_dict[key]]))\n\treturn norm_dict\n\n\ndef weighted_norm(node1, node2):\n\t\"\"\"\n\tApply weights to the norm dictionary from norm_dict to give equal\n\tweight to all attributes of the node\n\t\n\tParameters\n\t----------\n\tnode1 : dict\n\tnode2 : dict\n\t\n\tReturns\n\t-------\n\tfloat\n\t\tweighted norm between two nodes\n\t\"\"\"\n\n\tnorm_dict = make_norm_dict(node1, node2)\n\tweight_norm_dict={}\n\tfor key in norm_dict.keys():\n\t\tif key == 'mode':\n\t\t\tweight_norm_dict[key] = norm_dict[key] / 1.0\n\t\tif key == 'torsions':\n\t\t\tweight_norm_dict[key] = norm_dict[key] / 360.0\n\t\tif key == 'rotamers':\n\t\t\tweight_norm_dict[key] = norm_dict[key] / 360.0\n\t\tif key == 'rotation':\n\t\t\tweight_norm_dict[key] = norm_dict[key] / 1.0\n\t\tif key == 'translation':\n\t\t\tweight_norm_dict[key] = norm_dict[key] / 1.0\n\n\tnorm=sum(norm_dict.values())\n\treturn norm\n\n\ndef get_nearest_list_index(node_list, guide_node):\n\t\"\"\"\n\tFinds nearest nodes among node_list, using the metric given by weighted_norm\n\tand chooses one of them at random.\n\t\n\tParameters\n\t----------\n\tnode_list : list\n\t\tlist of nodes corresponding to one of the two search trees growing towards each other.\n\tguide_node : dict\n\t\tnode that has been randomly chosen to expand towards\n\t\n\tReturns\n\t-------\n\tmin_ind : int\n\t\tindex of the chosen node\n\tmin_dist_choice : float\n\t\tdistance between the chosen node and the guide_node\n\t\"\"\"\n\tk_nearest = int(len(node_list) / 100) + 1\n\tdlist = [weighted_norm(node, guide_node) for node in node_list]\n\tk_min_dist_list = heapq.nsmallest(k_nearest, dlist)\n\tmin_dist_choice = random.choice(k_min_dist_list)\n\tmin_ind = dlist.index(min_dist_choice)\n\n\treturn min_ind, min_dist_choice\n\n\nclass RRT:\n\t\"\"\"\n\tContains the express algorithm to generate the path and all the objects needed for it\n\t(the self.protein, the ligand, etc.)\n\t_start configurations correspond to the state at the frame frame_num, _end at frame frame_num+1\n\t\n\t\"\"\"\n\tdef __init__(self, input_path, output_path, path_num, frame_num, greed=10, max_iter=10000,\n\t\t\t\t relax_clashscore=True, max_clashscore=100.0,step_num=10):#74.96\n\t\t\"\"\"Summary\n\t\t\n\t\tParameters\n\t\t----------\n\t\tinput_path : str\n\t\t\tdirectory path from which to gather the input files\n\t\toutput_path : str\n\t\t\tpath to the directory in which the result files will be placed\n\t\tpath_num : int\n\t\t path number of the .zip file in the directory\n\t\tframe_num : int\n\t\t\tframe number used as the starting frame. the end frame is taken as frame_num+1\n\t\tgreed : int, optional\n\t\t\tgreed parameter of the RRT-algorithm\n\t\tmax_iter : int, optional\n\t\t\tmaximum number of iterations\n\t\trelax_clashscore : bool, optional\n\t\t\tOptional argument to allow steadily increasing clashscore values or use the maximum permitted value from the start\n\t\tmax_clashscore : float, optional\n\t\t\tvalue of the maximal permitted clashscore\n\t\tstep_num : int, optional\n\t\t\texpected number of interpolation steps between the start and end configuration.\n\t\t\"\"\"\n\t\tself.input_path = input_path\n\t\tself.output_path = output_path\n\t\tself.frame_num = frame_num\n\t\tself.greed = greed\n\t\tself.max_iter = max_iter\n\t\tself.relax_clashscore = relax_clashscore\n\t\tself.max_clashscore = max_clashscore\n\t\tself.step_num = step_num\n\t\tself.path_num=path_num\n\n\tdef ready(self):\n\t\t\"\"\"\n\t\t\n\t\tAttributes\n\t\t----------\n\t\tclash_diff : float\n\t\t Difference between the clashscore of the start node as measured by the refinement script and the one saved from the Gpath results\n\t\t refinement clashscore can be higher since it may include more rotamers from frame_num and frame_num+1 as part of the interpolation \n\t\tconfig_end : dict\n\t\t start node configuration corresponding to the state at frame frame_num+1\n\t\tconfig_start : dict\n\t\t start node configuration corresponding to the state at frame frame_num\n\t\tcontacts_objective : gpath objective\n\t\t \n\t\tframe_vdw_volume : float\n\t\t total Van der Wals volume of the ligand and active rotamers \n\t\tgoal: bool\n\t\t\trecords whether the algorithm has been able to connect the initial and final configurations\n\t\tind : gpath individual\n\t\t \n\t\titeration_counter : int\n\t\t counter that will keep track of the total number of iterations of the RRT-algorithm\n\t\tligand : chimera molecule\n\n\t\tligand_gene : gpath gene\n\n\t\tnext_normal_mode_sample : numpy array\n\t\t atom coordiantes corresponding to the normal mode deformation of the frame framenum+1\n\t\tnext_sample_number : int\n\t\t normal modes sample number for the frame frame_number+1\n\t\tnm_gene : gpath gene\n\t\t Description\n\t\tnormal_mode_sample : numpy array\n\t\t atom coordinates corresponding to the normal mode deformation of the frame framenum\n\t\tpath : list\n\t\t list of nodes connecting the start and end configuration\n\t\tprotein : chimera molecule\n\t\t \n\t\tprotein_gene : gpath gene\n\t\t \n\t\trotamer_gene : gpath gene\n\t\t \n\t\trotamer_start : list\n\t\t list of rotamer angles with values corresponding to their start configuration\n\t\tsample_number : int\n\t\t normal modes sample number for the frame frame_number\n\t\tto_zero : tuple\n\t\t matrix that centers the ligand to the origin before applying the second transformation to set it in the right location\n\t\ttorsion_gene : gpath gene\n\n\n\n\t\t\"\"\"\n\t\tself.config_end = {}\n\t\tself.config_start = {}\n\n\t\tmodes_path = os.path.join(self.input_path, 'modes.nmd')\n\t\tsamples_path = os.path.join(self.input_path, 'samples.samples')\n\n\t\tfor file in os.listdir(self.input_path):\n\t\t\tif str(self.path_num).zfill(3)+'.zip' in file:\n\t\t\t\tgpathzip = file\n\n\t\tzip_path = os.path.join(self.input_path, gpathzip)\n\n\t\twith zipfile.ZipFile(zip_path) as myzip:\n\t\t\tfor file_name in myzip.namelist():\n\t\t\t\tif 'Protein' in file_name:\n\t\t\t\t\tprotein_path = myzip.extract(\n\t\t\t\t\t\tfile_name, path=self.output_path)\n\n\t\t\t\tif 'Ligand' in file_name:\n\t\t\t\t\tligand_path = myzip.extract(\n\t\t\t\t\t\tfile_name, path=self.output_path)\n\n\t\t\t\tif '.zip' in file_name:\n\t\t\t\t\tpathway_zip_path = myzip.extract(\n\t\t\t\t\t\tfile_name, path=self.output_path)\n\n\t\twith zipfile.ZipFile(pathway_zip_path) as myzip:\n\t\t\tallele_path = myzip.extract('allele.txt', self.output_path)\n\t\t\tscores_path = myzip.extract('scores.txt', self.output_path)\n\t\t\tyaml_path=os.path.join(self.input_path,os.path.basename(self.input_path)+'.yaml')\n\t\t\tframe_path = myzip.extract('frame_{:03d}.pdb'.format(self.frame_num), self.output_path)\n\t\t\tframep1_path = myzip.extract('frame_{:03d}.pdb'.format(self.frame_num + 1), self.output_path)\n\n\t\twith open(allele_path, 'r') as allele_file:\n\t\t\ttry:\n\t\t\t\tpoints=eval(allele_file.read())\n\t\t\texcept:\n\t\t\t\tprint('allele_file load error')\n\n\t\twith open(scores_path, 'r') as scores_file:\n\t\t\ttry:\n\t\t\t\tscores=eval(scores_file.read())\n\t\t\texcept:\n\t\t\t\tprint('scores_file load error')\n\n\t\twith open(yaml_path, 'r') as yaml_file:\n\t\t\ttry:\n\t\t\t\tsettings_dict=yaml.load(yaml_file)\n\t\t\t\tgene_settings={}\n\t\t\t\tfor gene in settings_dict['genes']:\n\t\t\t\t\tif 'torsion' in gene['module']:\n\t\t\t\t\t\tgene_settings['torsions']=gene\n\t\t\t\t\t\tgene_settings['torsions'].pop('module')\n\t\t\t\t\t\tgene_settings['torsions'].pop('name')\n\t\t\t\t\t\tgene_settings['torsions'].pop('target')\n\t\t\t\t\t\tgene_settings['torsions'].pop('anchor')\n\t\t\t\t\t\tcontinue\n\t\t\t\t\tif 'rotamers' in gene['module']:\n\t\t\t\t\t\tgene_settings['rotamers']=gene\n\t\t\t\t\t\tgene_settings['rotamers'].pop('module')\n\t\t\t\t\t\tgene_settings['rotamers'].pop('name')\n\t\t\t\t\t\tcontinue\n\t\t\t\t\tif 'normalmodes' in gene['module']:\n\t\t\t\t\t\tgene_settings['normalmodes']=gene\n\t\t\t\t\t\tgene_settings['normalmodes'].pop('module')\n\t\t\t\t\t\tgene_settings['normalmodes'].pop('name')\n\t\t\t\t\t\tgene_settings['normalmodes'].pop('target')\n\t\t\t\t\t\tcontinue\n\t\t\texcept yaml.YAMLError as exc:\n\t\t\t\tprint(exc)\n\n\t\tif 'torsions' in points:\n\t\t\ttorsion_list = points['torsions']\n\t\t\ttorsion_anchor = points['torsion_anchor']\n\n\t\txf_list = zip(points['positions'], points['rotations'])\n\n\t\tself.ind = base.MolecularIndividual()\n\n\t\tself.ligand_gene = molecule.Molecule(path=ligand_path, parent=self.ind)\n\t\tself.ind.genes['Ligand'] = self.ligand_gene\n\t\tself.ligand_gene.express()\n\t\tself.ligand = self.ligand_gene.compound.mol\n\n\t\tor_x, or_y, or_z = np.average(atom_positions(self.ligand.atoms), axis=0)\n\t\tself.to_zero = ((1.0, 0.0, 0.0, -or_x),\n\t\t\t\t\t\t(0.0, 1.0, 0.0, -or_y),\n\t\t\t\t\t\t(0.0, 0.0, 1.0, -or_z))\n\n\t\tself.protein_gene = molecule.Molecule(path=protein_path, parent=self.ind)\n\t\tself.ind.genes['Protein'] = self.protein_gene\n\t\tself.protein_gene.express()\n\t\tself.protein = self.protein_gene.compound.mol\n\n\t\tif 'torsions' in points:\n\t\t\tself.torsion_gene = torsion.Torsion('Ligand', parent=self.ligand_gene.parent, anchor=torsion_anchor,**gene_settings['torsions'])\n\n\t\tif 'normal_modes' in points:\n\t\t\tself.nm_gene = path_normalmodes.NormalModes(target='Protein', parent=self.ind, path=modes_path, samples_path=samples_path,**gene_settings['torsions'])\n\t\t\tself.ind.genes['NM'] = self.nm_gene\n\t\telse:\n\t\t\tprint('No normal modes in allele.txt')\n\n\t\t# parse rotamer information from allele.txt and frame_00x.pdb, if allele.txt used rotamers\n\t\tif 'rotamers' in points:\n\t\t\tif points['rotamers'][0] is not []:\n\t\t\t\tframe = chimera.openModels.open(frame_path)\n\t\t\t\tframe_protein = frame[0]\n\t\t\t\tframep1 = chimera.openModels.open(framep1_path)\n\t\t\t\tframep1_protein = framep1[0]\n\t\t\t\tresidues = points['rotamers']\n\t\t\t\tchi_init, residue_init = residues[self.frame_num][0], residues[self.frame_num][1]\n\t\t\t\tchi_end, residue_end = residues[self.frame_num + 1][0], residues[self.frame_num + 1][1]\n\t\t\t\tresidue_dict_start = dict(zip(chi_init, residue_init))\n\t\t\t\tresidue_dict_end = dict(zip(chi_end, residue_end))\n\t\t\t\tresidue_dict_zero = merge_two_dicts(residue_dict_start, residue_dict_end)\n\t\t\t\tresidue_dict_zero = residue_dict_zero.fromkeys(residue_dict_zero, 0.0)\n\n\t\t\t\tresidue_dict_start = merge_two_dicts(\n\t\t\t\t\tresidue_dict_zero, residue_dict_start)\n\t\t\t\tresidue_dict_end = merge_two_dicts(\n\t\t\t\t\tresidue_dict_zero, residue_dict_end)\n\n\t\t\t\tresidues=[residue.split('/') for residue in residue_dict_start.keys()]\n\t\t\t\tresidues=[[residue[0],int(residue[1])] for residue in residues]\n\t\t\t\tself.rotamer_gene= rotamers.Rotamers(residues=residues,parent=self.protein_gene.parent,**gene_settings['rotamers'])\n\t\t\t\tself.ind.genes['Rotamers'] = self.rotamer_gene\n\t\t\t\tself.ind.__ready__()\n\t\t\t\tself.rotamer_gene.__ready__()\n\t\t\t\tself.rotamer_start = []\n\t\t\t\trotamer_end = []\n\t\t\t\tfor rot in residue_dict_start.keys():\n\t\t\t\t\tres_num = int(rot.split('/')[1])\n\n\t\t\t\t\tresidue_dict_start[res_num] = residue_dict_start[rot]\n\t\t\t\t\tresidue_dict_end[res_num] = residue_dict_end[rot]\n\t\t\t\t\tdel residue_dict_end[rot]\n\t\t\t\t\tdel residue_dict_start[rot]\n\n\t\t\t\t\tfor rotamer,protein in zip([self.rotamer_start,rotamer_end],[frame_protein,framep1_protein]):\t\t\n\t\t\t\t\t\tresidue = protein.findResidue(res_num - 1)\n\t\t\t\t\t\tfor chi_num in range(1, 5):\n\t\t\t\t\t\t\tchi_value = getattr(residue, 'chi' + str(chi_num))\n\t\t\t\t\t\t\tif chi_value is not None:\n\t\t\t\t\t\t\t\trotamer.append([res_num, chi_num, self.protein.findResidue(res_num - 1), chi_value])\n\n\t\t\t\tchimera.openModels.close(frame)\n\t\t\t\tchimera.openModels.close(framep1)\n\t\t\t\tself.rotamer_start.sort()\n\t\t\t\trotamer_end.sort()\n\n\t\t\t\trotamer_start_values = [item[3] for item in self.rotamer_start]\n\t\t\t\trotamer_end_values = [item[3] for item in rotamer_end]\n\t\t\t\tself.config_start['rotamers'] = rotamer_start_values\n\t\t\t\tself.config_end['rotamers'] = rotamer_end_values\n\t\t\telse:\n\t\t\t\tprint('No rotamers in frame %s' % self.frame_num)\n\t\telse:\n\t\t\tprint('No rotamers in allele.txt')\n\n\t\t# initialize self.protein normal modes\n\t\tif 'normal_modes' in points:\n\t\t\tself.sample_number = points['normal_modes'][self.frame_num]\n\t\t\tself.next_sample_number = points['normal_modes'][self.frame_num + 1]\n\t\t\tif self.frame_num == 0:\n\t\t\t\tself.normal_mode_sample = np.asarray(\n\t\t\t\t\tself.nm_gene._original_coords)\n\t\t\telse:\n\t\t\t\tself.normal_mode_sample = np.asarray(\n\t\t\t\t\tself.nm_gene.NORMAL_MODES_SAMPLES[self.sample_number])\n\n\t\t\tself.next_normal_mode_sample = np.asarray(\n\t\t\t\tself.nm_gene.NORMAL_MODES_SAMPLES[self.next_sample_number])\n\t\t\t\n\t\t\tself.config_start['mode'] = [0.0]\n\t\t\tself.config_end['mode'] = [1.0]\n\n\t\trotamer_residues = [item[2] for item in self.rotamer_start]\n\t\tself.contacts_objective = contacts.Contacts(['Ligand'], which='clashes', rotamer_residues=rotamer_residues)\n\n\t\tself.config_start['rotation'] = list(M.chimera_xform(xf_list[self.frame_num][1]).getQuaternion())\n\t\tself.config_end['rotation'] = list(M.chimera_xform(xf_list[self.frame_num + 1][1]).getQuaternion())\n\t\tself.config_start['translation'] = [xf_list[self.frame_num][0][i][3] for i in range(3)]\n\t\tself.config_end['translation'] = [xf_list[self.frame_num+1][0][i][3] for i in range(3)]\n\t\t\n\t\tif 'torsions' in points:\n\t\t\ttorsion_list[0] = [0.0 for i in range(\n\t\t\t\tlen(self.torsion_gene.rotatable_bonds))]\n\t\t\tself.config_start['torsions'] = torsion_list[self.frame_num]\n\t\t\tself.config_end['torsions'] = torsion_list[self.frame_num + 1]\n\n\n\t\tself.config_start['clashscore'] = None\n\t\tself.config_end['clashscore'] = None\n\n\t\tself.config_start['iteration_counter'] = None\n\t\tself.config_end['iteration_counter'] = None\n\n\t\tself.config_start['parent'] = None\n\t\tself.config_end['parent'] = None\n\n\t\tself.iteration_counter = -2\n\t\tself.collision_check(self.config_start)\n\n\t\tself.iteration_counter = -3\n\t\tself.collision_check(self.config_end)\n\n\t\tself.max_clashscore=max(self.max_clashscore,self.config_start['clashscore'],self.config_end['clashscore'])\n\n\t\tself.path=[]\n\n\t\tlig_vdw=[4/3*np.pi*lig_atom.defaultRadius**3 for lig_atom in self.ligand.atoms]\n\t\tres_atoms=[]\n\t\tfor item in self.rotamer_start:\n\t\t\tres_atoms.extend(item[2].atoms)\n\t\tres_vdw=[4/3*np.pi*res_atom.defaultRadius**3 for res_atom in res_atoms]\n\t\tself.frame_vdw_volume=sum(lig_vdw+res_vdw)\n\n\tdef save_connect_nodes(self,iteration, node_list, guide_node):\n\t\t\"\"\"\n\n\t\tSaves the nodes from each RRT-tree nearest to each other\n\t\t\n\t\tParameters\n\t\t----------\n\t\titeration : int\n\t\t\tcurrent iteration of the RRT-method\n\t\tnode_list : list\n\t\t\tlist of nodes to be expanded on\n\t\tguide_node : dict\n\t\t\t\n\t\tReturns\n\t\t-------\n\t\tconnect_node_start : dict\n\t\t\tnode of the start tree\n\t\tconnect_node_end : dict\n\t\t\tnode of the end tree\n\t\t Description\n\t\t\"\"\"\n\t\tif iteration % 2 == 1:\n\t\t\tconnect_node_start = node_list[-1]\n\t\t\tconnect_node_end = guide_node\n\t\telse:\n\t\t\tconnect_node_start = guide_node\n\t\t\tconnect_node_end = node_list[-1]\n\n\t\treturn \tconnect_node_start,connect_node_end\n\n\tdef expand(self, new_node, guide_node,step_size_dict):\n\t\t\"\"\"\n\t\texpand towards guide_node from nearest_node\n\t\t\n\t\tParameters\n\t\t----------\n\t\tnew_node : dict\n\t\t\tnew node to be added to the current tree being expanded\n\t\tguide_node : dict\n\t\t\tnode from the opposite tree that gives the guiding direction\n\t\tstep_size_dict : dict\n\t\t dictionary of step size values vor each component of the coordinate vector\n\t\t\"\"\"\n\t\tnorm_dict = make_norm_dict(new_node, guide_node)\n\t\tdiff_dict=diff_node(new_node,guide_node)\n\t\tnew_node_dict=new_node\n\n\t\tfor key in new_node_dict.keys():\n\t\t\tif key == 'mode':\n\t\t\t\tif norm_dict[key] != 0:\n\t\t\t\t\tnew_node_dict[key] = [new_comp + step_size_dict[key] * diff_comp / norm_dict[key]\n\t\t\t\t\t\tfor new_comp, diff_comp in zip(new_node_dict[key], diff_dict[key])]\n\t\t\tif key == 'torsions':\n\t\t\t\tif norm_dict[key] != 0:\n\t\t\t\t\tnew_node_dict[key] = [new_comp + step_size_dict[key] * diff_comp / norm_dict[key]\n\t\t\t\t\t\tfor new_comp, diff_comp in zip(new_node_dict[key], diff_dict[key])]\n\t\t\t\t\tcorrect_geometry(new_node_dict[key])\n\t\t\tif key == 'rotamers':\n\t\t\t\tif norm_dict[key] != 0:\n\t\t\t\t\tnew_node_dict[key] = [new_comp + step_size_dict[key] * diff_comp / norm_dict[key]\n\t\t\t\t\t\tfor new_comp, diff_comp in zip(new_node_dict[key], diff_dict[key])]\n\t\t\t\t\tcorrect_geometry(new_node_dict[key])\n\t\t\tif key == 'rotation':\n\t\t\t\tif norm_dict[key] != 0:\n\t\t\t\t\tnew_node_dict[key] = list(slerp(np.asarray(new_node_dict[key]), np.asarray(\n\t\t\t\t\t\tguide_node['rotation']), step_size_dict[key] / (norm_dict[key])))\n\t\t\tif key == 'translation':\n\t\t\t\tif norm_dict[key] != 0:\n\t\t\t\t\tnew_node_dict[key] = [new_comp + step_size_dict[key] * diff_comp / norm_dict[key]\n\t\t\t\t\t\tfor new_comp, diff_comp in zip(new_node_dict[key], diff_dict[key])]\n\n\t\tnew_node=new_node_dict\n\n\tdef apply_node_config(self, node):\n\t\t\"\"\"\n\t\tApply the rotamers, torsions, normal modes and rotations of the given node to the ligand\n\t\tand the protein\n\t\t\n\t\tParameters\n\t\t----------\n\t\tnode : dict\n\t\t\n\t\t\"\"\"\n\t\tquaternion_vector = node['rotation']\n\t\ttranslation = node['translation']\n\n\t\tif 'torsions' in self.config_start:\n\t\t\tself.torsion_gene.allele = node['torsions']\n\t\t\tself.torsion_gene.express()\n\n\t\tif 'mode' in self.config_start:\n\t\t\tif self.frame_num == 0:\n\t\t\t\tself.normal_mode_sample = self.nm_gene._original_coords\n\t\t\telse:\n\t\t\t\tself.normal_mode_sample = np.asarray(\n\t\t\t\t\tself.nm_gene.NORMAL_MODES_SAMPLES[self.sample_number])\n\t\t\tself.next_normal_mode_sample = np.asarray(\n\t\t\t\tself.nm_gene.NORMAL_MODES_SAMPLES[self.next_sample_number])\n\t\t\tinterpol_mode = (1.0 - node['mode'][0]) * self.normal_mode_sample + node['mode'][0] * self.next_normal_mode_sample\n\t\t\tself.nm_gene.allele = interpol_mode\n\t\t\tself.nm_gene._need_express = True\n\t\t\tself.nm_gene.express()\n\n\t\tif 'rotamers' in self.config_start:\n\t\t\tparsed_rotamers=parse_rotamers(self.rotamer_start,node)\n\t\t\tfor residue,chis in parsed_rotamers:\n\t\t\t\tif residue.type not in self.rotamer_gene._residues_without_rotamers:\n\t\t\t\t\ttry:\n\t\t\t\t\t\tself.rotamer_gene.update_rotamer(residue,chis)\n\t\t\t\t\texcept NoResidueRotamersError: # ALA, GLY...\n\t\t\t\t\t\tprint('no rotamers')\n\t\t\t\t\t\tself.rotamer_gene._residues_without_rotamers.add(residue.type)\n\n\t\t#apply rotation and translation matrix onto the ligand\n\t\trotation_matrix = M.xform_matrix(chimera.Xform().quaternion(*quaternion_vector))\n\t\ttranslation_matrix = M.translation_matrix(translation)\n\t\tmatrices = (translation_matrix,) + (rotation_matrix,) + (self.to_zero,)\n\t\tmatrices = M.multiply_matrices(*matrices)\n\t\tself.ligand.openState.xform = M.chimera_xform(matrices)\n\n\tdef collision_check(self, node):\n\t\t\"\"\"\n\t\tChecks if the node surpasses the maximum clashscore value,\n\t\tif it doesn't it adds the clashscore value as an attribute of the node\n\t\t\n\t\tParameters\n\t\t----------\n\t\tnode : dict\n\t\t\tNode to be checked for collision state\n\t\t\n\t\tReturns\n\t\t-------\n\t\tBoolean\n\t\t\tReturns True in case the clashscore value exceeds the the maximum clashscore\n\t\t\tvalue, False otherwise.\n\t\t\"\"\"\n\t\tself.iteration_counter += 1\n\t\tself.apply_node_config(node)\n\t\tclashscore = self.contacts_objective.evaluate_clashes(self.ind)\n\t\tif self.iteration_counter>0 and clashscore > self.max_clashscore:\n\t\t\t\n\t\t\treturn True # collision\n\t\telse:\n\t\t\tnode['clashscore'] = clashscore\n\t\t\tnode['iteration_counter'] = self.iteration_counter\n\n\t\t\treturn False # no collision, safe\n\n\tdef write_refinement(self):\n\t\t\"\"\"\n\t\tApplies the transformation specified for each node in the generated path and writes\n\t\tthe protein and ligand molecule objects as a trajectoryxxx.pdb file, that will be later\n\t\tconverted to an MD Traj .pdb file\n\t\t\"\"\"\n\t\tos.chdir(self.output_path)\n\t\tfor node_num, node in enumerate(self.path):\n\t\t\tself.apply_node_config(node)\n\t\t\tclashscore_written = self.contacts_objective.evaluate_clashes(self.ind)\n\n\n\t\t\ttotalnum = str(self.frame_num).zfill(3) + str(node_num).zfill(3)\n\t\t\tif node_num==0:\n\t\t\t\tchimera.pdbWrite([self.ligand, self.protein], chimera.Xform(),'check%s.pdb' % totalnum)\n\t\t\t\tself.clash_diff=clashscore_written-node['clashscore']\n\n\t\t\tprint(clashscore_written, 'Clashscore of interpol%s.pdb' % totalnum, 'vs stored:',\n\t\t\t\t node['clashscore'], node['iteration_counter'])\n\n\t\t\tcombination = combine([self.ligand, self.protein], self.protein)\n\t\t\tchimera.pdbWrite([combination], chimera.Xform(),\n\t\t\t\t\t\t\t 'trajectory%s.pdb' % totalnum)\n\n\t\t\tcombination.destroy()\n\t\tif 'normal_modes' in self.config_start:\n\t\t\tself.nm_gene.unexpress()\n\t\tif 'torsions' in self.config_start:\n\t\t\tself.torsion_gene.unexpress()\n\n\t\tself.ligand_gene.unexpress()\n\t\tself.protein_gene.unexpress()\n\n\tdef nodeadder(self):\n\t\t\"\"\"\n\t\tAlternatively expands one of the two RRT trees For a number of max_iter iterations\n\t\t\n\t\tReturns\n\t\t-------\n\t\tgoal : bool\n\t\t\twhether the algorithm has been able to connect the initial and final node or not\n\t\t\"\"\"\n\t\tminimal_distance = 1000\n\t\tself.iteration_counter=0\n\t\tconnect_node_start = self.config_start\n\t\tconnect_node_end = self.config_end\n\t\tnode_list_start = [self.config_start]\n\t\tnode_list_end = [self.config_end]\n\t\tnorm_start_end_dict = make_norm_dict(self.config_start, self.config_end)\n\t\tnorm_start_end_nearest = weighted_norm(self.config_start, self.config_end)\n\t\thalt_step = norm_start_end_nearest / self.step_num\n\t\tmin_clashscore = max(self.config_start['clashscore'],self.config_end['clashscore'])\n\t\trelax_stepsize = (self.max_clashscore - min_clashscore) / self.max_iter\n\t\tstep_size_dict = {}\n\t\tfor key in norm_start_end_dict.keys():\n\t\t\tstep_size_dict[key] = norm_start_end_dict[key] / self.step_num\n\n\t\tcenter_trans = [np.mean((config_start_comp,config_end_comp)) for config_start_comp, config_end_comp\n\t\t\t\t\t\tin zip(self.config_start['translation'], self.config_end['translation'])]\n\n\t\tnode_list = node_list_start\n\t\tother_node_list = node_list_end\n\n\t\tfor iteration in range(self.max_iter):\n\n\t\t\tnode_list,other_node_list = other_node_list,node_list\n\n\t\t\tif self.relax_clashscore:\n\t\t\t\tself.max_clashscore = relax_stepsize * iteration + min_clashscore\n\n\t\t\tguide_dict = {}\n\t\t\tfor key in self.config_start.keys():\n\n\t\t\t\tif key == 'mode':\n\t\t\t\t\tguide_dict[key] = [random.uniform(-1, 2)]\n\t\t\t\tif key == 'torsions':\n\t\t\t\t\tguide_dict[key] = [\n\t\t\t\t\t\trandom.uniform(-180, 180) for i in range(0, len(self.config_end['torsions']))]\n\t\t\t\tif key == 'rotamers':\n\t\t\t\t\tguide_dict[key] = [\n\t\t\t\t\t\trandom.uniform(-180, 180) for i in range(0, len(self.config_end['rotamers']))]\n\t\t\t\tif key == 'rotation':\n\t\t\t\t\tguide_dict[key] = list(M.chimera_xform(\n\t\t\t\t\t\trandom_rotation()).getQuaternion())\n\t\t\t\tif key == 'translation':\n\n\t\t\t\t\tguide_dict[key] = [random.uniform(trans_comp - 2 * norm_start_end_dict['translation'],\n\t\t\t\t\t\t\t\t\t\t\t\t\t trans_comp + 2 * norm_start_end_dict['translation']) for\n\t\t\t\t\t\t\t\t\t trans_comp in center_trans]\n\t\t\tguide_node = guide_dict\n\n\t\t\t[min_ind, node_distance] = get_nearest_list_index(node_list, guide_node)\n\t\t\tnearest_node = node_list[min_ind]\n\n\t\t\tnew_node = copy.deepcopy(nearest_node)\n\n\t\t\tself.expand(new_node, guide_node,step_size_dict)\n\t\t\tif not self.collision_check(new_node):\n\t\t\t\tnew_node['parent'] = min_ind\n\t\t\t\tnode_list.append(copy.deepcopy(new_node))\n\t\t\t\tprint(node_distance,minimal_distance,halt_step,'node distance')\n\t\t\t\tif random.randint(0, 100) < self.greed:\n\t\t\t\t\tmin_ind, min_dist = get_nearest_list_index(other_node_list, new_node)\n\t\t\t\t\tguide_node = other_node_list[min_ind]\n\n\t\t\t\t\tself.expand(new_node, guide_node,step_size_dict)\n\t\t\t\t\twhile not self.collision_check(new_node):\n\n\t\t\t\t\t\tnew_node['parent'] = len(node_list) - 1\n\t\t\t\t\t\tnode_list.append(copy.deepcopy(new_node))\n\n\t\t\t\t\t\tnode_distance = weighted_norm(new_node, guide_node)\n\t\t\t\t\t\tprint(node_distance,minimal_distance,halt_step,'node distance')\n\t\t\t\t\t\tif weighted_norm(new_node, guide_node) < minimal_distance:\n\t\t\t\t\t\t\tminimal_distance = node_distance\n\t\t\t\t\t\t\tprint(minimal_distance,halt_step, 'min norm VS reached')\n\t\t\t\t\t\t\tconnect_node_start,connect_node_end=self.save_connect_nodes(iteration, node_list, guide_node)\n\n\t\t\t\t\t\tif weighted_norm(new_node, guide_node) < halt_step:\n\t\t\t\t\t\t\tprint('goal reached!')\n\t\t\t\t\t\t\tconnect_node_start,connect_node_end=self.save_connect_nodes(iteration, node_list, guide_node)\n\n\t\t\t\t\t\t\treturn True,connect_node_start,connect_node_end,node_list_start,node_list_end\n\t\t\t\t\t\tself.expand(new_node, guide_node,step_size_dict)\n\n\t\tprint('not reached... ')\n\t\treturn False,connect_node_start,connect_node_end,node_list_start,node_list_end\n\n\tdef express(self):\n\t\t\"\"\"\n\t\tFunction that will construct the random tree and when finished return the found path between two frames\n\t\t\"\"\"\n\t\tself.ready()\n\t\tself.goal,connect_node_start,connect_node_end,node_list_start,node_list_end = self.nodeadder()\n\n\t\tpath_start = [connect_node_start]\n\t\tpath_end = [connect_node_end]\n\n\t\tfor path,node_list in zip([path_start,path_end],[node_list_start,node_list_end]):\n\t\t\tlast_index = path[0]['parent']\n\t\t\twhile last_index is not None:\n\t\t\t\tnode = node_list[last_index]\n\t\t\t\tpath.append(node)\n\t\t\t\tlast_index = node['parent']\n\n\t\tpath_start.reverse()\n\t\tself.path = path_start + path_end\n\t\tself.write_refinement()\n\ndef Refinement(directory, path_num, frame_start, frame_end):\n\t\"\"\"\n\tCreates the output path, runs the RRT-algorithm and saves the resulting path .pdb\n\tfiles as a MDtraj file\n\t\n\tParameters\n\t----------\n\tdirectory : str\n\t\tdirectory from which the files are \n\tpath_num : TYPE\n\t Description\n\tframe_start : int\n\n\tframe_end : int\n\t\"\"\"\n\n\tinit_path = os.getcwd()\n\tinput_path = os.path.join(os.getcwd(), 'refinement_input_files', directory)\n\toutput_path = os.path.join(os.getcwd(), 'refinement_output_files', directory,\n\t\t\t\t\t\t\t 'refinement' + '_' + str(frame_start).zfill(3) + '_' + str(frame_end).zfill(3) + '_' + str(time.time()))\n\n\tif os.path.exists(output_path):\n\t\tshutil.rmtree(output_path)\n\t\tos.makedirs(output_path)\n\telse:\n\t\tos.makedirs(output_path)\n\n\tframerange = range(frame_start, frame_end)\n\tlogfile = open(os.path.join(output_path, 'logfile' + '.txt'), 'w+')\n\tlog_dict_list = []\n\trefined_frame_num=1\n\tfor frame_num in framerange:\n\t\tstart_time = time.time()\n\t\trrt = RRT(input_path, output_path,path_num, frame_num)\n\t\trrt.express()\n\t\tend_time = time.time()\n\n\t\tlog_dict = {}\n\t\tlog_dict['1_frame_num'] = rrt.frame_num\n\t\tlog_dict['2_goal_reached'] = rrt.goal\n\t\tlog_dict['3_iterations'] = rrt.iteration_counter\n\t\tlog_dict['4_time'] = end_time - start_time\n\t\tlog_dict['5_clash_diff'] = rrt.clash_diff\n\t\tlog_dict['6_clashscore_iteration'] = [(node,refined_frame_num+i) for i,node in enumerate(rrt.path)]\n\t\tlog_dict['7_frame_vdw_volume'] = rrt.frame_vdw_volume\n\t\tlog_dict_list.append(log_dict)\n\t\trefined_frame_num+=len(rrt.path)\n\tlogfile.write(pp.pformat(log_dict_list))\n\n\tos.chdir(output_path)\n\tfile_list = []\n\ttrajectory_list = [output_file for output_file in os.listdir(\n\t\toutput_path) if 'trajectory' in output_file]\n\ttrajectory_list.sort(key=lambda f: int(filter(str.isdigit, f)))\n\n\tfor the_file in trajectory_list:\n\t\tfile_path = os.path.join(output_path, the_file)\n\t\tfile_list.append(file_path)\n\tmd_trajectory = mdtraj.load(file_list)\n\tmd_trajectory.save(os.path.join(output_path, 'refinement.pdb'))\n\n\tfor the_file in trajectory_list:\n\t\tfile_path = os.path.join(output_path, the_file)\n\t\ttry:\n\t\t\tif os.path.isfile(file_path):\n\t\t\t\tos.unlink(file_path)\n\t\texcept Exception as e:\n\t\t\tprint(e)\n\tos.chdir(init_path)\n\tchimera.closeSession()\n\ndef parse_cli():\n\t\"\"\"\n\tCli input parser\n\t\"\"\"\n\tp = ArgumentParser()\n\tp.add_argument('directory', type=str,\n\t\t\t\t help='directory containing the results from the Gpath inside refinement_test_input_files')\n\tp.add_argument('path_num', type=int,\n\t\t\t\t help='path number of the .zip file in the directory')\n\tp.add_argument('frame_start', type=int,\n\t\t\t\t help='frame number from which the interpolation has to be done')\n\tp.add_argument('frame_end', type=int,\n\t\t\t\t help='frame number until which the interpolation has to be done')\n\treturn p.parse_args()\n\nif __name__ == '__main__':\n\n\targs = parse_cli()\n\tdirectory=args.directory\n\tframe_start=args.frame_start\n\tframe_end=args.frame_end\n\tpath_num=args.path_num\n\n\toutput_path=os.path.join(os.getcwd(),'examples','refinement_output_files',directory)\n\tRefinement(directory,path_num,frame_start,frame_end)\n", "meta": {"hexsha": "ef1f8efc641b7ffad64e61202e7713fa6e814fbf", "size": 34005, "ext": "py", "lang": "Python", "max_stars_repo_path": "refinement.py", "max_stars_repo_name": "insilichem/gpathfinder", "max_stars_repo_head_hexsha": "e6c7df14d473857acb007efbae3cc7b4fee1b330", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2020-03-22T20:21:47.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-08T07:50:25.000Z", "max_issues_repo_path": "refinement.py", "max_issues_repo_name": "insilichem/gpathfinder", "max_issues_repo_head_hexsha": "e6c7df14d473857acb007efbae3cc7b4fee1b330", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2020-04-09T10:49:26.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-08T04:37:27.000Z", "max_forks_repo_path": "refinement.py", "max_forks_repo_name": "insilichem/gpathfinder", "max_forks_repo_head_hexsha": "e6c7df14d473857acb007efbae3cc7b4fee1b330", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.9186834463, "max_line_length": 153, "alphanum_fraction": 0.7223055433, "include": true, "reason": "import numpy", "num_tokens": 8953, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5428632831725052, "lm_q2_score": 0.36658975016245987, "lm_q1q2_score": 0.19900811535058138}} {"text": "#!/usr/bin/env python\n\"\"\"\nVariational Bayes method to solve phylgoenetic HMM for histone modifications\n\nNeed to:\n* Preprocess\n** load each dataset\n** call significant sites for each dataset (vs. one control dataset)\n** save out resulting histogrammed data\n\n* Learn\n** Init parameters randomly\n** E step: optimize each q_{ij} for fixed \\Theta\n** M step: optimize \\Theta for fixed Q\n\n\nfor a complete hg19, we have:\n T = 15,478,482\n I = 9\n K = 15\n L = 9\n \\Theta is:\n e = K * 2**L\n \\theta = K**2 * K\n \\alpha = K * K\n \\beta = K * K\n \\gamma = K\n X = I * T * L * 1 byte for bool => 2050 MB RAM\n\n for mf:\n Q = I * T * K * 4 bytes for float64 =>\n 15181614 * 9 * 15 * (4 bytes) / 1e6 = 8198 MB RAM\n \\therefore should be okay for 12GB RAM\n\n for poc:\n \\Theta = T * K * K * 4 bytes => 30 GB RAM\n Q = I * T * K * 4 bytes => 24 GB RAM\n Q_pairs = I * T * K * K * 4 bytes => :(\n\n Chromosome 1:\n T = 1246254\n => Q = .9 GB\n => Q_pairs = 8.9 GB\n => X = .1 GB\n\n\"\"\"\nimport argparse\nimport sys\nimport operator\nimport glob\nimport urllib\nimport os\nimport hashlib\nimport multiprocessing\nimport time\nimport cPickle as pickle\nimport copy\nimport re\nimport tarfile\nfrom cStringIO import StringIO\nimport time\nimport random\n\ntry:\n import pysam\nexcept ImportError:\n print 'pysam not installed. Cannot convert data'\nimport scipy as sp\nfrom scipy.stats import poisson\nimport scipy.io\nimport scipy.signal\ntry:\n import matplotlib\n matplotlib.use('Agg', warn=False)\n #matplotlib.rc('text', usetex=True)\n #matplotlib.rc('ps', usedistiller='xpdf')\n from matplotlib import pyplot\n allow_plots = True\nexcept ImportError:\n allow_plots = False\n print 'matplotlib not installed. Cannot plot!'\n\nsp.seterr(all='raise')\nsp.seterr(under='print')\n#sp.random.seed([5])\n\n\nfrom treehmm.static import valid_species, valid_marks, mark_avail, phylogeny, inference_types, float_type\n\nfrom treehmm import vb_mf\nfrom treehmm import vb_prodc\n#import loopy_bp\nfrom treehmm import loopy_bp\nfrom treehmm import clique_hmm\n#import concatenate_hmm\nfrom treehmm import vb_gmtkExact_continuous as vb_gmtkExact\nfrom treehmm import vb_independent\nfrom treehmm.plot import plot_params, plot_data, plot_Q, plot_energy, plot_energy_comparison\n\nfrom treehmm.do_parallel import do_parallel_inference\n\n\n\n\ndef main(argv=sys.argv[1:]):\n \"\"\"run a variational EM algorithm\"\"\"\n # parse arguments, then call convert_data or do_inference\n parser = make_parser()\n args = parser.parse_args(argv)\n if not hasattr(args, 'mark_avail'):\n args.mark_avail = mark_avail\n elif isinstance(args.mark_avail, basestring):\n args.mark_avail = sp.load(args.mark_avail)\n if args.func == do_inference:\n # allow patterns on the command line\n global phylogeny\n args.phylogeny = eval(args.phylogeny)\n phylogeny = args.phylogeny\n\n all_obs = []\n for obs_pattern in args.observe_matrix:\n obs_files = glob.glob(obs_pattern)\n if len(obs_files) == 0:\n parser.error('No files matched the pattern %s' % obs_pattern)\n all_obs.extend(obs_files)\n args.observe_matrix = all_obs\n\n if args.approx == 'gmtk':\n args.subtask = False\n obs_mat = args.observe_matrix\n args.observe_matrix = args.observe_matrix[0]\n init_args_for_inference(args)\n args.observe_matrix = obs_mat\n del args.func\n vb_gmtkExact.mark_avail = args.mark_avail\n vb_gmtkExact.run_gmtk_lineagehmm(args)\n return\n\n if len(args.observe_matrix) > 1:\n print 'parallel inference on %s jobs' % len(args.observe_matrix)\n args.func = do_parallel_inference\n else:\n args.subtask = False\n args.observe_matrix = args.observe_matrix[0]\n args.observe = os.path.split(args.observe_matrix)[1]\n args.func = do_inference\n if args.range_k is not None:\n out_template = args.out_dir + \"_rangeK\"\n for args.K in eval(args.range_k):\n print 'trying K=', args.K\n args.out_dir = out_template\n args.func(args)\n return\n\n args.func(args) # do inference, downloading, or data conversion\n\ndef do_inference(args):\n \"\"\"Perform the type of inference specified in args\"\"\"\n # set up\n if args.quiet_mode:\n sys.stdout = open('log_%s.log' , 'a')\n init_args_for_inference(args)\n print 'done making args'\n args.out_dir = args.out_dir.format(timestamp=time.strftime('%x_%X').replace('/','-'), **args.__dict__)\n\n try:\n print 'making', args.out_dir\n os.makedirs(args.out_dir)\n except OSError:\n pass\n\n if not args.subtask:\n args.iteration = '0_initial'\n plot_params(args)\n if args.plot_iter >= 2:\n plot_data(args)\n\n for i in xrange(1, args.max_iterations+1):\n if not args.subtask:\n args.iteration = i\n print 'iteration', i\n\n # run a few times rather than checking free energy\n for j in xrange(1, args.max_E_iter+1 if args.approx != 'clique' else 2):\n args.update_q_func(args)\n if args.approx !='loopy':\n f = args.free_energy_func(args)\n print 'free energy after %s E steps' % j, f\n try:\n print abs(args.last_free_energy - f) / args.last_free_energy\n if abs(abs(args.last_free_energy - f) / args.last_free_energy) < args.epsilon_e:\n args.last_free_energy = f\n break\n args.last_free_energy = f\n except: # no previous free energy\n args.last_free_energy = f\n else:\n print 'loopy %s E steps' %j\n if loopy_bp.bp_check_convergence(args):\n args.last_free_energy = f = abs(args.free_energy_func(args))\n break\n print '# saving Q distribution'\n if args.continuous_observations:\n for k in range(args.K):\n print 'means[%s,:] = ' % k, args.means[k,:]\n print 'stdev[%s,:] = ' % k, sp.sqrt(args.variances[k,:])\n if args.save_Q >= 2:\n for p in args.Q_to_save:\n sp.save(os.path.join(args.out_dir,\n args.out_params.format(param=p, **args.__dict__)),\n args.__dict__[p])\n\n\n if args.subtask:\n # save the weights without renormalizing\n print 'saving weights for parameters'\n args.update_param_func(args, renormalize=False)\n #plot_Q(args)\n args.free_energy.append(args.last_free_energy)\n for p in args.params_to_save:\n sp.save(os.path.join(args.out_dir, args.out_params.format(param=p, **args.__dict__)),\n args.__dict__[p])\n break\n else:\n # optimize parameters with new Q\n args.update_param_func(args)\n f = args.free_energy_func(args)\n try:\n if args.approx != 'clique':\n print abs(args.last_free_energy - f) / args.last_free_energy\n if abs(abs(args.last_free_energy - f) / args.last_free_energy) < args.epsilon:\n args.last_free_energy = f\n break\n args.last_free_energy = f\n except: # no previous free energy\n args.last_free_energy = f\n #args.last_free_energy = args.free_energy_func(args)\n args.free_energy.append(args.last_free_energy)\n print 'free energy after M-step', args.free_energy[-1]\n # save current parameter state\n for p in args.params_to_save:\n sp.save(os.path.join(args.out_dir,\n args.out_params.format(param=p, **args.__dict__)),\n args.__dict__[p])\n\n if args.plot_iter != 0 and i % args.plot_iter == 0:\n plot_params(args)\n plot_energy(args)\n if args.plot_iter >= 2:\n plot_Q(args)\n #import ipdb; ipdb.set_trace()\n if args.compare_inf is not None:\n args.log_obs_mat = sp.zeros((args.I,args.T,args.K), dtype=float_type)\n vb_mf.make_log_obs_matrix(args)\n if 'mf' in args.compare_inf:\n tmpargs = copy.deepcopy(args)\n tmpargs.Q = vb_mf.mf_random_q(args.I,args.T,args.K)\n print 'comparing '\n for j in xrange(1, args.max_E_iter+1):\n vb_mf.mf_update_q(tmpargs)\n if vb_mf.mf_check_convergence(tmpargs):\n break\n print 'mf convergence after %s iterations' % j\n e = vb_mf.mf_free_energy(tmpargs)\n args.cmp_energy['mf'].append(e)\n if 'poc' in args.compare_inf:\n tmpargs = copy.deepcopy(args)\n if args.approx != 'poc':\n tmpargs.Q, tmpargs.Q_pairs = vb_prodc.prodc_initialize_qs(args.theta, args.alpha, args.beta,\n args.gamma, args.emit_probs, args.X, args.log_obs_mat)\n for j in xrange(1, args.max_E_iter+1):\n vb_prodc.prodc_update_q(tmpargs)\n if vb_mf.mf_check_convergence(tmpargs):\n break\n print 'poc convergence after %s iterations' % j\n e = vb_prodc.prodc_free_energy(tmpargs)\n args.cmp_energy['poc'].append(e)\n #sp.io.savemat(os.path.join(args.out_dir, 'Artfdata_poc_inferred_params_K{K}_{T}.mat'.format(K=args.K, T=args.max_bins)), dict(alpha = args.alpha, theta=args.theta, beta=args.beta, gamma=args.gamma, emit_probs=args.emit_probs))\n if 'pot' in args.compare_inf:\n #del args.cmp_energy['pot']\n pass\n if 'concat' in args.compare_inf:\n #del args.cmp_energy['concat']\n pass\n if 'clique' in args.compare_inf:\n tmpargs = copy.deepcopy(args)\n if args.approx != 'clique':\n clique_hmm.clique_init_args(tmpargs)\n for j in xrange(1):\n clique_hmm.clique_update_q(tmpargs)\n e = clique_hmm.clique_likelihood(tmpargs)\n args.cmp_energy['clique'].append(-e)\n if 'loopy' in args.compare_inf:\n tmpargs = copy.deepcopy(args)\n if args.approx != 'loopy':\n tmpargs.lmds, tmpargs.pis = loopy_bp.bp_initialize_msg(args.I, args.T, args.K, args.vert_children)\n for j in xrange(1, args.max_E_iter+1):\n loopy_bp.bp_update_msg_new(tmpargs)\n if loopy_bp.bp_check_convergence(tmpargs):\n break\n print 'loopy convergence after %s iterations' % j\n #e = loopy_bp.bp_bethe_free_energy(tmpargs)\n e = loopy_bp.bp_mf_free_energy(tmpargs)\n args.cmp_energy['loopy'].append(e)\n if args.plot_iter != 0:\n plot_energy_comparison(args)\n\n # save the final parameters and free energy to disk\n print 'done iteration'\n if args.save_Q >= 1:\n for p in args.Q_to_save:\n sp.save(os.path.join(args.out_dir,\n args.out_params.format(param=p, **args.__dict__)),\n args.__dict__[p])\n for p in args.params_to_save:\n sp.save(os.path.join(args.out_dir, args.out_params.format(param=p, **args.__dict__)),\n args.__dict__[p])\n\n #pickle.dump(args, os.path.join(args.out_dir, args.out_params.format(param='args', **args.__dict__)))\n print 'done savin'\n if not args.subtask and args.plot_iter != 0:\n plot_energy(args)\n plot_params(args)\n plot_Q(args)\n #scipy.io.savemat('poc_inferred_params_K{K}_{T}.mat'.format(K=args.K, T=args.max_bins), dict(alpha = args.alpha, theta=args.theta, beta=args.beta, gamma=args.gamma, emit_probs=args.emit_probs))\n\n\ndef init_args_for_inference(args):\n \"\"\"Initialize args with inference variables according to learning method\"\"\"\n # read in the datafiles to X array\n print '# loading observations'\n X = sp.load(args.observe_matrix)\n if args.max_bins is not None:\n X = X[:, :args.max_bins, :]\n if args.max_species is not None:\n X = X[:args.max_species, :, :]\n args.X = X\n args.I, args.T, args.L = X.shape\n if args.X.dtype != scipy.int8:\n args.continuous_observations = True\n print 'Inference for continuous observations'\n args.X = X.astype(float_type)\n #args.means = sp.rand(args.K, args.L)\n #args.variances = sp.rand(args.K, args.L)\n args.means, args.variances = initialize_mean_variance(args)\n else:\n args.continuous_observations = False\n print 'Inference for discrete observations'\n match = re.search(r'\\.i(\\d+)\\.', args.observe_matrix)\n args.real_species_i = int(match.groups()[0]) if match and args.I == 1 else None\n args.free_energy = []\n\n make_tree(args)\n args.Q_to_save = ['Q']\n #if args.approx == 'poc':\n # args.Q_to_save += ['Q_pairs']\n #elif args.approx == 'clique':\n # args.Q_to_save += ['clq_Q', 'clq_Q_pairs']\n\n args.params_to_save = ['free_energy', 'alpha', 'gamma', 'last_free_energy']\n if True: #args.approx not in ['clique', 'concat']:\n args.params_to_save += ['theta', 'beta']\n if args.continuous_observations:\n args.params_to_save += ['means', 'variances']\n else:\n args.params_to_save += ['emit_probs', 'emit_sum']\n\n if args.compare_inf is not None:\n if 'all' in args.compare_inf:\n args.compare_inf = inference_types\n args.cmp_energy = dict((inf, []) for inf in args.compare_inf if inf not in ['pot', 'concat'])\n args.params_to_save += ['cmp_energy']\n\n if args.warm_start: # need to load params\n print '# loading previous params for warm start from %s' % args.warm_start\n tmpargs = copy.deepcopy(args)\n tmpargs.out_dir = args.warm_start\n #tmpargs.observe = 'all.npy'\n args.free_energy, args.theta, args.alpha, args.beta, args.gamma, args.emit_probs, args.emit_sum = load_params(tmpargs)\n try:\n args.free_energy = list(args.free_energy)\n except TypeError: # no previous free energy\n args.free_energy = []\n print 'done'\n elif args.subtask: # params in args already\n print '# using previous params from parallel driver'\n else:\n print '# generating random parameters'\n (args.theta, args.alpha, args.beta, args.gamma, args.emit_probs) = \\\n random_params(args.I, args.K, args.L, args.separate_theta)\n if args.continuous_observations:\n del args.emit_probs\n\n\n if args.approx == 'mf': # mean-field approximation\n if not args.subtask or args.iteration == 0:\n args.Q = vb_mf.mf_random_q(args.I,args.T,args.K)\n #else:\n # q_path = os.path.join(args.out_dir, args.out_params.format(param='Q', **args.__dict__))\n # print 'loading previous Q from %s' % q_path\n # args.Q = sp.load(q_path)\n args.log_obs_mat = sp.zeros((args.I,args.T,args.K), dtype=float_type)\n vb_mf.make_log_obs_matrix(args)\n\n args.update_q_func = vb_mf.mf_update_q\n args.update_param_func = vb_mf.mf_update_params\n args.free_energy_func = vb_mf.mf_free_energy\n args.converged_func = vb_mf.mf_check_convergence\n elif args.approx == 'poc': # product-of-chains approximation\n if not args.separate_theta:\n import vb_prodc\n else:\n import vb_prodc_sepTheta as vb_prodc\n args.log_obs_mat = sp.zeros((args.I,args.T,args.K), dtype=float_type)\n if args.continuous_observations:\n vb_mf.make_log_obs_matrix_gaussian(args)\n else:\n vb_mf.make_log_obs_matrix(args)\n\n if not args.subtask or args.iteration == 0:\n print '# generating Qs'\n args.Q, args.Q_pairs = vb_prodc.prodc_initialize_qs(args.theta, args.alpha, args.beta,\n args.gamma, args.X, args.log_obs_mat)\n #else:\n # q_path = os.path.join(args.out_dir, args.out_params.format(param='Q', **args.__dict__))\n # print 'loading previous Q from %s' % q_path\n # args.Q = sp.load(q_path)\n # args.Q_pairs = sp.load(os.path.join(args.out_dir, args.out_params.format(param='Q_pairs', **args.__dict__)))\n\n args.update_q_func = vb_prodc.prodc_update_q\n args.update_param_func = vb_prodc.prodc_update_params\n args.free_energy_func = vb_prodc.prodc_free_energy\n args.converged_func = vb_mf.mf_check_convergence\n elif args.approx == 'indep': # completely independent chains\n args.log_obs_mat = sp.zeros((args.I, args.T, args.K), dtype=float_type)\n if args.continuous_observations:\n vb_mf.make_log_obs_matrix_gaussian(args)\n else:\n vb_mf.make_log_obs_matrix(args)\n\n if not args.subtask or args.iteration == 0:\n print '# generating Qs'\n args.Q = sp.zeros((args.I, args.T, args.K), dtype=float_type)\n args.Q_pairs = sp.zeros((args.I, args.T, args.K, args.K), dtype=float_type)\n vb_independent.independent_update_qs(args)\n #else:\n # q_path = os.path.join(args.out_dir, args.out_params.format(param='Q', **args.__dict__))\n # print 'loading previous Q from %s' % q_path\n # args.Q = sp.load(q_path)\n # args.Q_pairs = sp.load(os.path.join(args.out_dir, args.out_params.format(param='Q_pairs', **args.__dict__)))\n\n args.update_q_func = vb_independent.independent_update_qs\n args.update_param_func = vb_independent.independent_update_params\n args.free_energy_func = vb_independent.independent_free_energy\n args.converged_func = vb_mf.mf_check_convergence\n elif args.approx == 'pot': # product-of-trees approximation\n raise NotImplementedError(\"Product of Trees is not implemented yet!\")\n elif args.approx == 'clique':\n if args.separate_theta:\n raise RuntimeError('separate_theta not implemented yet for clique')\n print 'making cliqued Q'\n args.Q = sp.zeros((args.I, args.T, args.K), dtype=float_type)\n clique_hmm.clique_init_args(args)\n args.update_q_func = clique_hmm.clique_update_q\n args.update_param_func = clique_hmm.clique_update_params\n args.free_energy_func = clique_hmm.clique_likelihood\n args.converged_func = vb_mf.mf_check_convergence\n elif args.approx == 'concat':\n raise NotImplementedError(\"Concatenated HMM is not implemented yet!\")\n elif args.approx == 'loopy':\n if args.separate_theta:\n raise RuntimeError('separate_theta not implemented yet for clique')\n if not args.subtask or args.iteration == 0:\n args.Q = vb_mf.mf_random_q(args.I, args.T, args.K)\n #else:\n # q_path = os.path.join(args.out_dir, args.out_params.format(param='Q', **args.__dict__))\n # print 'loading previous Q from %s' % q_path\n # args.Q = sp.load(q_path)\n args.lmds, args.pis = loopy_bp.bp_initialize_msg(args)\n args.log_obs_mat = sp.zeros((args.I,args.T,args.K), dtype=float_type)\n vb_mf.make_log_obs_matrix(args)\n\n args.update_q_func = loopy_bp.bp_update_msg_new\n args.update_param_func = loopy_bp.bp_update_params_new\n #args.free_energy_func = loopy_bp.bp_bethe_free_energy\n args.free_energy_func = loopy_bp.bp_mf_free_energy\n args.converged_func = loopy_bp.bp_check_convergence\n elif args.approx == 'gmtk':\n pass\n else:\n raise RuntimeError('%s not recognized as valid inference method!' % args.approx)\n\ndef distance(x1, x2):\n return scipy.sqrt((x1 - x2) * (x1 - x2)).sum()\n\ndef initialize_mean_variance(args):\n \"\"\"Initialize the current mean and variance values semi-intelligently.\n\n Inspired by the kmeans++ algorithm: iteratively choose new centers from the data\n by weighted sampling, favoring points that are distant from those already chosen\n \"\"\"\n X = args.X.reshape(args.X.shape[0] * args.X.shape[1], args.X.shape[2])\n\n # kmeans++ inspired choice\n centers = [random.choice(X)]\n min_dists = scipy.array([distance(centers[-1], x) for x in X])\n for l in range(1, args.K):\n weights = min_dists * min_dists\n new_center = weighted_sample(zip(weights, X), 1).next()\n centers.append(new_center)\n\n min_dists = scipy.fmin(min_dists, scipy.array([distance(centers[-1], x) for x in X]))\n\n means = scipy.array(centers)\n\n # for the variance, get the variance of the data in this cluster\n variances = []\n for c in centers:\n idxs = tuple(i for i, (x, m) in enumerate(zip(X, min_dists)) if distance(c, x) == m)\n v = scipy.var(X[idxs, :], axis=0)\n variances.append(v)\n variances = scipy.array(variances) + args.pseudocount\n\n #import pdb; pdb.set_trace()\n #for k in range(args.K):\n # print sp.sqrt(variances[k,:])\n variances[variances < .1] = .1\n\n return means, variances\n\n\ndef weighted_sample(items, n):\n total = float(sum(w for w, v in items))\n i = 0\n w, v = items[0]\n while n:\n x = total * (1 - random.random() ** (1.0 / n))\n total -= x\n while x > w:\n x -= w\n i += 1\n w, v = items[i]\n w -= x\n yield v\n n -= 1\n\n\ndef make_parser():\n \"\"\"Make a parser for variational inference\"\"\"\n parser = argparse.ArgumentParser()\n tasks_parser = parser.add_subparsers()\n\n # parameters for converting datasets from BAM to observation matrix\n convert_parser = tasks_parser.add_parser('convert', help='Convert BAM reads'\n ' into a matrix of observations')\n convert_parser.add_argument('--download_first', action='store_true',\n help='Download the raw sequence data from UCSC,'\n ' then convert it.')\n convert_parser.add_argument('--base_url', default='http://hgdownload.cse.ucsc.edu/goldenPath/hg19/encodeDCC/wgEncodeBroadHistone/%s',\n help='When downloading, string-format the template into this url.')\n convert_parser.add_argument('--species', nargs='+', default=valid_species,\n help='The set of species with observations. By '\n 'default, use all species: %(default)s')\n convert_parser.add_argument('--marks', nargs='+', default=valid_marks,\n help='The set of marks with observations. By '\n 'default, use all histone marks: %(default)s')\n convert_parser.add_argument('--windowsize', type=int, default=200,\n help='histogram bin size used in conversion')\n convert_parser.add_argument('--chromosomes', nargs='+', default='all',\n help='which chromosomes to convert. By default,'\n ' convert all autosomes')\n convert_parser.add_argument('--min_reads', type=float, default=.5,\n help='The minimum number of reads for a region to be included. default: %(default)s')\n convert_parser.add_argument('--min_size', type=int, default=25,\n help='The minimum length (in bins) to include a chunk. default: %(default)s')\n convert_parser.add_argument('--max_pvalue', type=float, default=1e-4,\n help='p-value threshold to consider the read count'\n ' significant, using a local poisson rate defined by'\n ' the control data')\n convert_parser.add_argument('--outfile', default='observations.{chrom}.npy',\n help='Where to save the binarized reads')\n #convert_parser.add_argument('--bam_template', help='bam file template.',\n # default='wgEncodeBroadHistone{species}{mark}StdAlnRep*.bam')\n convert_parser.add_argument('--bam_template', help='bam file template. default: %(default)s',\n default='wgEncode*{species}{mark}StdAlnRep{repnum}.bam')\n convert_parser.set_defaults(func=convert_data)\n\n # # to trim off telomeric regions\n # trim_parser = tasks_parser.add_parser('trim', help='trim off regions without'\n # 'any observations in them')\n # trim_parser.add_argument('observe_matrix', nargs='+',\n # help='Files to be trimmed (converted from bam'\n # ' using \"%(prog)s convert\" command).')\n # trim_parser.set_defaults(func=trim_data)\n\n # to split a converted dataset into pieces\n split_parser = tasks_parser.add_parser('split', help='split observations '\n 'into smaller pieces, retaining only regions with '\n 'a smoothed minimum read count.')\n split_parser.add_argument('observe_matrix', nargs='+',\n help='Files containing observed data (converted from bam'\n ' using \"%(prog)s convert\" command). If multiple files '\n 'are specified, each is treated as its own chain but '\n 'the parameters are shared across all chains')\n split_parser.add_argument('start_positions', help='start_positions.pkl file generated during `convert` step.')\n #split_parser.add_argument('--chunksize', type=int, default=100000,\n # help='the number of bins per chunk. default: %(default)s')\n split_parser.add_argument('--min_reads', type=float, default=.5,\n help='The minimum number of reads for a region to be included. default: %(default)s')\n split_parser.add_argument('--gauss_window_size', type=int, default=200,\n help='The size of the gaussian smoothing window. default: %(default)s')\n split_parser.add_argument('--min_size', type=int, default=25,\n help='The minimum length (in bins) to include a chunk. default: %(default)s')\n split_parser.set_defaults(func=split_data)\n\n # parameters for learning and inference with converted observations\n infer_parser = tasks_parser.add_parser('infer')\n infer_parser.add_argument('K', type=int, help='The number of hidden states'\n ' to infer')\n infer_parser.add_argument('observe_matrix', nargs='+',\n help='Files containing observed data (converted from bam'\n ' using \"%(prog)s convert\" command). If multiple files '\n 'are specified, each is treated as its own chain but '\n 'the parameters are shared across all chains')\n infer_parser.add_argument('--approx', choices=inference_types,\n default='mf',\n help='Which approximation to make in inference')\n infer_parser.add_argument('--out_params', default='{approx}_{param}_{observe}',\n help='Where to save final parameters')\n infer_parser.add_argument('--epsilon', type=float, default=1e-4,\n help='Convergence criteria: change in Free energy'\n ' during M step must be < epsilon')\n infer_parser.add_argument('--epsilon_e', type=float, default=1e-3,\n help='Convergence criteria: change in Free energy'\n ' during E step must be < epsilon')\n infer_parser.add_argument('--max_iterations', type=int, default=50,\n help='Maximum number of EM steps before stopping')\n infer_parser.add_argument('--max_E_iter', type=int, default=10,\n help='Maximum number of E steps per M step')\n infer_parser.add_argument('--max_bins', default=None, type=int,\n help='Restrict the total number of bins (T)')\n infer_parser.add_argument('--max_species', default=None, type=int,\n help='Restrict the total number of species (I)')\n infer_parser.add_argument('--pseudocount', type=float_type, default=1e-6,\n help='pseudocount to add to each parameter matrix')\n infer_parser.add_argument('--plot_iter', type=int, default=1,\n help='draw a plot per *plot_iter* iterations.'\n '0 => plot only at the end. Default is %(default)s')\n infer_parser.add_argument('--out_dir', type=str, default='{run_name}_out/{approx}/I{I}_K{K}_T{T}_{timestamp}',\n help='Output parameters and plots in this directory'\n ' (default: %(default)s')\n infer_parser.add_argument('--run_name', type=str, default='infer',\n help='name of current run type (default: %(default)s')\n infer_parser.add_argument('--num_processes', type=int, default=None,\n help='Maximum number of processes to use '\n 'simultaneously (default: all)')\n infer_parser.add_argument('--warm_start', type=str, default=None,\n help=\"Resume iterations using parameters and Q's \"\n \"from a previous run. Q's that are not found are \"\n \"regenerated\")\n infer_parser.add_argument('--compare_inf', nargs='+', type=str, default=None, choices=inference_types + ['all'],\n help=\"While learning using --approx method, \"\n \"compare the inferred hidden states and energies \"\n \"from these inference methods.\")\n infer_parser.add_argument('--range_k', type=str, default=None,\n help=\"perform inference over a range of K values. Argument is passed as range(*arg*)\")\n infer_parser.add_argument('--save_Q', type=int, choices=[0,1,2,3], default=1,\n help=\"Whether to save the inferred marginals for hidden variables. 0 => no saving, 1 => save at end, 2 => save at each iteration. 3 => for parallel jobs, reconstruct the chromsomal Q distribution at each iteration. Default: %(default)s\")\n infer_parser.add_argument('--quiet_mode', action='store_true', help=\"Turn off printing for this run\")\n infer_parser.add_argument('--run_local', action='store_true', help=\"Force parallel jobs to run on the local computer, even when SGE is available\")\n infer_parser.add_argument('--separate_theta', action='store_true', help='use a separate theta matrix for each node of the tree (only works for GMTK)')\n infer_parser.add_argument('--mark_avail', help='npy matrix of available marks',\n default=mark_avail)\n infer_parser.add_argument('--phylogeny', help='the phylogeny connecting each species, as a python dictionary with children for keys and parents for values. Note: this does not have to be a singly-rooted or even a bifurcating phylogeny! You may specify multiple trees, chains, stars, etc, but should not have loops in the phylogeny.',\n default=str(phylogeny))\n infer_parser.add_argument('--chunksize', help='The number of chunks (for convert+split data) or chromosomes (for convert only) to submit to each runner. When running on SGE, you should set this number relatively high (in 100s?) since each job has a very slow startup time. When running locally, this is the number of chunks each subprocess will handle at a time.',\n default=1)\n infer_parser.set_defaults(func=do_inference)\n\n\n bed_parser = tasks_parser.add_parser('q_to_bed')\n bed_parser.add_argument('q_root_dir', help='Root directory for the Q outputs to convert. '\n 'Should look something like: infer_out/mf//')\n bed_parser.add_argument('start_positions', help='the pickled offsets generated by `tree-hmm convert` or `tree-hmm split`.',)\n bed_parser.add_argument('--bed_template', help='template for bed output files. Default: %(default)s',\n default='treehmm_states.{species}.state{state}.bed')\n bed_parser.add_argument('--save_probs', action='store_true', help='Instead of saving the most likely state for each bin, record the probability of being in that state at each position. NOTE: this will greatly increase the BED file size!')\n bed_parser.set_defaults(func=q_to_bed)\n return parser\n\n\ndef q_to_bed(args):\n attrs = pickle.load(open(args.start_positions))\n windowsize = attrs['windowsize']\n start_positions = attrs['start_positions']\n valid_species = attrs['valid_species']\n valid_marks = attrs['valid_marks']\n \n outfiles = {}\n for f in glob.glob(os.path.join(args.q_root_dir, '*_Q_*.npy')):\n Q = scipy.load(f)\n if not args.save_probs:\n best_states = Q.argmax(axis=2)\n obs = f.split('_Q_')[1]\n I, T, K = Q.shape\n chrom, bin_offset = start_positions[obs]\n for i in range(I):\n for t in range(T):\n if args.save_probs:\n for k in range(K):\n bedline = '\\t'.join([chrom, str((bin_offset + t) * windowsize),\n str((bin_offset + t + 1) * windowsize),\n '{species}.state{k}'.format(species=valid_species[i], k=k), \n str(Q[i,t,k]), '+']) + '\\n'\n if (i,k) not in outfiles:\n outfiles[(i,k)] = open(args.bed_template.format(species=valid_species[i], state=k), 'w')\n outfiles[(i,k)].write(bedline)\n else:\n k = best_states[i,t]\n bedline = '\\t'.join([chrom, str((bin_offset + t) * windowsize),\n str((bin_offset + t + 1) * windowsize),\n '{species}.state{k}'.format(species=valid_species[i], k=k), \n str(Q[i,t,k]), '+']) + '\\n'\n if (i,k) not in outfiles:\n outfiles[(i,k)] = open(args.bed_template.format(species=valid_species[i], state=k), 'w')\n outfiles[(i,k)].write(bedline)\n\n\ndef load_params(args):\n #print args.out_params\n #print args.__dict__.keys()\n #print 'loading from', os.path.join(args.out_dir, args.out_params.format(param='last_free_energy', **args.__dict__))\n free_energy = sp.load(os.path.join(args.out_dir, args.out_params.format(param='free_energy', **args.__dict__)))\n\n #print 'loading from', os.path.join(args.out_dir, args.out_params.format(param='theta', **args.__dict__))\n theta = sp.load(os.path.join(args.out_dir, args.out_params.format(param='theta', **args.__dict__)))\n if len(theta.shape)==3 and args.separate_theta:\n tmp = sp.zeros((args.I-1, args.K, args.K, args.K), dtype=float_type)\n for i in range(args.I-1):\n tmp[i,:,:,:] = theta\n theta = tmp\n #print 'loading from', os.path.join(args.out_dir, args.out_params.format(param='alpha', **args.__dict__))\n alpha = sp.load(os.path.join(args.out_dir, args.out_params.format(param='alpha', **args.__dict__)))\n\n #print 'loading from', os.path.join(args.out_dir, args.out_params.format(param='beta', **args.__dict__))\n beta = sp.load(os.path.join(args.out_dir, args.out_params.format(param='beta', **args.__dict__)))\n\n #print 'loading from', os.path.join(args.out_dir, args.out_params.format(param='gamma', **args.__dict__))\n gamma = sp.load(os.path.join(args.out_dir, args.out_params.format(param='gamma', **args.__dict__)))\n\n #print 'loading from', os.path.join(args.out_dir, args.out_params.format(param='emit_probs', **args.__dict__))\n emit_probs = sp.load(os.path.join(args.out_dir, args.out_params.format(param='emit_probs', **args.__dict__)))\n\n #print 'loading from', os.path.join(args.out_dir, args.out_params.format(param='emit_sum', **args.__dict__))\n emit_sum = sp.load(os.path.join(args.out_dir, args.out_params.format(param='emit_sum', **args.__dict__)))\n\n return free_energy, theta, alpha, beta, gamma, emit_probs, emit_sum\n\n\n\ndef make_tree(args):\n \"\"\"build a tree from the vertical parents specified in args\"\"\"\n I = args.I\n # define the tree structure\n #tree_by_parents = {0:sp.inf, 1:0, 2:0} # 3 species, 2 with one parent\n #tree_by_parents = {0:sp.inf, 1:0} # 3 species, 2 with one parent\n #tree_by_parents = dict((args.species.index(k), args.species.index(v)) for k, v in phylogeny.items())\n tree_by_parents = dict((valid_species.index(k), valid_species.index(v)) \n for k, v in args.phylogeny.items() if \n valid_species.index(k) in xrange(I) and \n valid_species.index(v) in xrange(I))\n tree_by_parents[0] = sp.inf #'Null'\n print tree_by_parents.keys()\n # [inf, parent(1), parent(2), ...]\n global vert_parent\n #I = max(tree_by_parents) + 1\n\n vert_parent = sp.array([tree_by_parents[c] if c > 0 else I for c in\n xrange(I)], dtype=sp.int8) # error if 0's parent is accessed\n args.vert_parent = vert_parent\n\n print 'vert_parent', vert_parent\n# args.vert_parent = tree_by_parents\n # {inf:0, 0:[1,2], 1:[children(1)], ...}\n global vert_children\n vert_children = dict((pa, []) for pa in\n tree_by_parents.keys())# + tree_by_parents.values())\n for pa in tree_by_parents.values():\n for ch in tree_by_parents.keys():\n if tree_by_parents[ch] == pa:\n if pa not in vert_children:\n vert_children[pa] = []\n if ch not in vert_children[pa]:\n vert_children[pa].append(ch)\n del vert_children[sp.inf]\n for pa in vert_children:\n vert_children[pa] = sp.array(vert_children[pa], dtype=sp.int32)\n args.vert_children = vert_children\n\n# vert_children = sp.ones(I, dtype = 'object')\n# for pa in range(I):\n# vert_children[pa] = []\n# for child, parent in tree_by_parents.items():\n# if pa == parent:\n# vert_children[pa].append(child)\n# print vert_children\n# args.vert_children = vert_children\n\ndef random_params(I, K, L, separate_theta):\n \"\"\"Create and normalize random parameters for inference\"\"\"\n #sp.random.seed([5])\n if separate_theta:\n theta = sp.rand(I-1, K, K, K).astype(float_type)\n else:\n theta = sp.rand(K, K, K).astype(float_type)\n alpha = sp.rand(K, K).astype(float_type)\n beta = sp.rand(K, K).astype(float_type)\n gamma = sp.rand(K).astype(float_type)\n emit_probs = sp.rand(K, L).astype(float_type)\n vb_mf.normalize_trans(theta, alpha, beta, gamma)\n return theta, alpha, beta, gamma, emit_probs\n\n# def trim_data(args):\n# \"\"\"Trim regions without any observations from the start and end of the\n# obervation matrices\n# \"\"\"\n# for f in args.observe_matrix:\n# print '# trimming ', f, 'start is ',\n# X = sp.load(f).astype(sp.int8)\n# S = X.cumsum(axis=0).cumsum(axis=2) # any species has any observation\n# for start_t in xrange(X.shape[1]):\n# if S[-1, start_t, -1] > 0:\n# break\n# for end_t in xrange(X.shape[1] - 1, -1, -1):\n# if S[-1, end_t, -1] > 0:\n# break\n# tmpX = X[:, start_t:end_t, :]\n# print start_t\n# sp.save(os.path.splitext(f)[0] + '.trimmed', tmpX)\n\ndef split_data(args):\n \"\"\"Split the given observation matrices into smaller chunks\"\"\"\n sizes = []\n total_size = 0\n covered_size = 0\n attrs = pickle.load(open(args.start_positions))\n valid_species = attrs['valid_species']\n valid_marks = attrs['valid_marks']\n windowsize = attrs['windowsize']\n old_starts = attrs['start_positions']\n start_positions = {}\n for f in args.observe_matrix:\n print '# splitting ', f\n chrom = old_starts[os.path.split(f)[1]][0]\n\n X = sp.load(f).astype(sp.int8)\n total_size += X.shape[1]\n #start_ts = xrange(0, X.shape[1], args.chunksize)\n #end_ts = xrange(args.chunksize, X.shape[1] + args.chunksize, args.chunksize)\n\n density = X.sum(axis=0).sum(axis=1) # sumation over I, then L\n #from ipdb import set_trace; set_trace()\n gk = _gauss_kernel(args.gauss_window_size)\n smoothed_density = scipy.signal.convolve(density, gk, mode='same')\n regions_to_keep = smoothed_density >= args.min_reads\n\n # find the regions where a transition is made from no reads to reads, and reads to no reads\n start_ts = sp.where(sp.diff(regions_to_keep.astype(sp.int8)) > 0)[0]\n end_ts = sp.where(sp.diff(regions_to_keep.astype(sp.int8)) < 0)[0]\n\n cur_regions = [r for r in zip(start_ts, end_ts) if r[1] - r[0] >= args.min_size]\n sizes.extend([end_t - start_t for start_t, end_t in cur_regions])\n\n print 'saving %s regions' % len(sizes)\n for chunknum, (start_t, end_t) in enumerate(cur_regions):\n covered_size += end_t - start_t\n tmpX = X[:, start_t:end_t, :]\n name = os.path.splitext(f)[0] + '.chunk%s.npy' % chunknum\n sp.save(name, tmpX)\n fname = os.path.split(name)[1]\n start_positions[fname] = (chrom, start_t)\n print '# plotting size distribution'\n pyplot.figure()\n pyplot.figtext(.5,.01,'%s regions; %s bins total; %s bins covered; coverage = %.3f' % (len(sizes),total_size, covered_size, covered_size / float(total_size)), ha='center')\n pyplot.hist(sizes, bins=100)\n pyplot.title('chunk sizes for all chroms, min_reads %s, min_size %s, gauss_window_size %s' % (args.min_reads, args.min_size, args.gauss_window_size))\n pyplot.savefig('chunk_sizes.minreads%s.minsize%s.windowsize%s.png' % (args.min_reads, args.min_size, args.gauss_window_size))\n\n with open('start_positions_split.pkl', 'w') as outfile:\n attrs = dict(windowsize=windowsize, start_positions=start_positions, \n valid_species=valid_species, valid_marks=valid_marks)\n pickle.dump(attrs, outfile, -1)\n # --min_reads .5 --min_size 25 --window_size 200;\n\n\n\n# def extract_local_features(args):\n# \"\"\"extract some local features from the given data, saving an X array with extra dimensions\"\"\"\n# sizes = []\n# total_size = 0\n# covered_size = 0\n# start_positions = {}\n# for f in args.observe_matrix:\n# print '# features on ', f\n# X = sp.load(f).astype(sp.int8)\n# total_size += X.shape[1]\n# #start_ts = xrange(0, X.shape[1], args.chunksize)\n# #end_ts = xrange(args.chunksize, X.shape[1] + args.chunksize, args.chunksize)\n\n# density = X.sum(axis=0).sum(axis=1) # summation over I, then L\n# #from ipdb import set_trace; set_trace()\n# gk = _gauss_kernel(args.window_size)\n# smoothed_density = scipy.signal.convolve(density, gk, mode='same')\n# regions_to_keep = smoothed_density >= args.min_reads\n\n# # find the regions where a transition is made from no reads to reads, and reads to no reads\n# start_ts = sp.where(sp.diff(regions_to_keep.astype(sp.int8)) > 0)[0]\n# end_ts = sp.where(sp.diff(regions_to_keep.astype(sp.int8)) < 0)[0]\n\n# cur_regions = [r for r in zip(start_ts, end_ts) if r[1] - r[0] >= args.min_size]\n# sizes.extend([end_t - start_t for start_t, end_t in cur_regions])\n\n# print 'saving %s regions' % len(sizes)\n# for chunknum, (start_t, end_t) in enumerate(cur_regions):\n# covered_size += end_t - start_t\n# tmpX = X[:, start_t:end_t, :]\n# name = os.path.splitext(f)[0] + '.chunk%s.npy' % chunknum\n# sp.save(name, tmpX)\n# start_positions[name] = start_t\n# print '# plotting size distribution'\n# pyplot.figure()\n# pyplot.figtext(.5,.01,'%s regions; %s bins total; %s bins covered; coverage = %.3f' % (len(sizes),total_size, covered_size, covered_size / float(total_size)), ha='center')\n# pyplot.hist(sizes, bins=100)\n# pyplot.title('chunk sizes for all chroms, min_reads %s, min_size %s, window_size %s' % (args.min_reads, args.min_size, args.window_size))\n# pyplot.savefig('chunk_sizes.minreads%s.minsize%s.windowsize%s.png' % (args.min_reads, args.min_size, args.window_size))\n\n# pickle.dump(start_positions, open('start_positions.pkl', 'w'))\n# # --min_reads .5 --min_size 25 --window_size 200;\n\n\n\n# def convert_data_continuous_features_and_split(args):\n# \"\"\"histogram both treatment and control data as specified by args\n# This saves the complete X matrix\n\n# This version doesn't binarize the data, smooths out the read signal (gaussian convolution)\n# and adds derivative information\n# \"\"\"\n# if args.download_first:\n# download_data(args)\n# I = len(args.species)\n# L = len(args.marks)\n# final_data = None\n# total_size = 0\n# covered_size = 0\n# start_positions = {}\n# # make sure all the data is present...\n# for species in args.species:\n# for mark in args.marks:\n# d_files = [f for f in glob.glob(args.bam_template.format(\n# species=species, mark=mark))]\n# if len(d_files) == 0:\n# print(\"No histone data for species %s mark %s Expected: %s\" %\n# (species, mark, args.bam_template.format(\n# species=species, mark=mark)))\n\n# for i, species in enumerate(args.species):\n# for l, mark in enumerate(args.marks):\n# d_obs = {}\n# d_files = [f for f in glob.glob(args.bam_template.format(\n# species=species, mark=mark))]\n# if len(d_files) == 0:\n# args.mark_avail[i, l] = 0\n# else:\n# args.mark_avail[i, l] = 1\n# for mark_file in d_files:\n# read_counts = histogram_reads(mark_file, args.windowsize, args.chromosomes)\n\n# # d_obs.append(histogram_reads(mark_file, args.windowsize,\n# # args.chromosomes))\n# for \n# d_obs = reduce(operator.add, d_obs) # add all replicants together\n# #print 'before per million:', d_obs.sum()\n# #d_obs /= (d_obs.sum() / 1e7) # convert to reads mapping per ten million\n# # convert to a binary array with global poisson\n# #genome_rate = d_obs / (d_obs.sum() / 1e6)\n\n# if final_data is None:\n# final_data = sp.zeros((I, len(d_obs), L), dtype=sp.float32)\n# final_data[i, :, l] = d_obs\n# total_size = final_data.shape[1]\n\n\n# regions_to_keep = (final_data[:, :, tuple(range(L))].sum(axis=0).sum(axis=1) >= args.min_reads).astype(sp.int8)\n# # find the regions where a transition is made from no reads to reads, and reads to no reads\n# start_ts = sp.where(sp.diff(regions_to_keep) > 0)[0]\n# end_ts = sp.where(sp.diff(regions_to_keep) < 0)[0]\n\n# cur_regions = [r for r in zip(start_ts, end_ts) if r[1] - r[0] >= args.min_size]\n# sizes = [end_t - start_t for start_t, end_t in cur_regions]\n\n# print 'saving %s regions' % len(sizes)\n# tarout = tarfile.open(args.outfile + '.tar.gz', 'w:gz')\n# for chunknum, (start_t, end_t) in enumerate(cur_regions):\n# covered_size += end_t - start_t\n# tmpX = final_data[:, start_t:end_t, :]\n\n# print 'adding chunk', chunknum, 'of', len(cur_regions)\n# s = StringIO()\n# sp.save(s, tmpX)\n# name = args.outfile + '.chunk%s.npy' % chunknum\n# info = tarfile.TarInfo(name)\n# info.size = s.tell(); info.mtime = time.time()\n# s.seek(0)\n# tarout.addfile(info, s)\n# start_positions[name] = start_t\n\n# print '# plotting size distribution'\n# pyplot.figure()\n# pyplot.figtext(.5,.01,'%s regions; %s bins total; %s bins covered; coverage = %.3f' % (len(sizes),total_size, covered_size, covered_size / float(total_size)), ha='center')\n# pyplot.hist(sizes, bins=100)\n# pyplot.title('chunk sizes for all chroms, min_reads %s, min_size %s, windowsize %s' % (args.min_reads, args.min_size, args.windowsize))\n# pyplot.savefig('chunk_sizes.minreads%s.minsize%s.windowsize%s.png' % (args.min_reads, args.min_size, args.windowsize))\n\n# s = StringIO()\n# pyplot.savefig(s)\n# info = tarfile.TarInfo('chunk_sizes.minreads%s.minsize%s.windowsize%s.png' % (args.min_reads, args.min_size, args.windowsize))\n# info.size = s.tell(); info.mtime = time.time()\n# s.seek(0)\n# tarout.addfile(info, s)\n\n# s = StringIO()\n# pickle.dump(start_positions, s)\n# info = tarfile.TarInfo('start_positions.pkl')\n# info.size = s.tell(); info.mtime = time.time()\n# s.seek(0)\n# tarout.addfile(info, s)\n# pickle.dump(start_positions, open('start_positions.pkl', 'w'))\n# # --min_reads .5 --min_size 25 --window_size 200;\n\n\n# s = StringIO()\n# sp.save(s, args.mark_avail)\n# info = tarfile.TarInfo('available_marks.npy')\n# info.size = s.tell(); info.mtime = time.time()\n# s.seek(0)\n# tarout.addfile(info, s)\n# pickle.dump(start_positions, open('start_positions.pkl', 'w'))\n# # --min_reads .5 --min_size 25 --window_size 200;\n\n# tarout.close()\n\n\n# print \"output file:\", args.outfile\n# print 'available marks:', args.mark_avail\n# #with open(args.outfile, 'wb') as outfile:\n# # sp.save(outfile, final_data)\n# with open(args.outfile + '.available_marks', 'wb') as outfile:\n# sp.save(outfile, args.mark_avail)\n\n\n\n\n# def convert_data_continuous_features_and_split_old(args):\n# \"\"\"histogram both treatment and control data as specified by args\n# This saves the complete X matrix\n\n# This version doesn't binarize the data, smooths out the read signal (gaussian convolution)\n# and adds derivative information\n# \"\"\"\n# if args.download_first:\n# download_data(args)\n# I = len(args.species)\n# L = len(args.marks)\n# final_data = None\n# total_size = 0\n# covered_size = 0\n# start_positions = {}\n# # make sure all the data is present...\n# for species in args.species:\n# for mark in args.marks:\n# d_files = [f for f in glob.glob(args.bam_template.format(\n# species=species, mark=mark))]\n# if len(d_files) == 0:\n# print(\"No histone data for species %s mark %s Expected: %s\" %\n# (species, mark, args.bam_template.format(\n# species=species, mark=mark)))\n\n# for i, species in enumerate(args.species):\n# for l, mark in enumerate(args.marks):\n# l = l * 3\n# d_obs = []\n# d_files = [f for f in glob.glob(args.bam_template.format(\n# species=species, mark=mark))]\n# if len(d_files) == 0:\n# args.mark_avail[i, l] = 0\n# args.mark_avail[i, l+1] = 0\n# args.mark_avail[i, l+2] = 0\n# else:\n# args.mark_avail[i, l] = 1\n# args.mark_avail[i, l+1] = 1\n# args.mark_avail[i, l+2] = 1\n# for mark_file in d_files:\n# try:\n# d_obs.append(histogram_reads(mark_file, args.windowsize,\n# args.chromosomes))\n# except ValueError as e:\n# print e.message\n# print d_obs[-1].sum()\n# print d_obs[-1].shape\n# d_obs = reduce(operator.add, d_obs) # add all replicants together\n# #print 'before per million:', d_obs.sum()\n# #d_obs /= (d_obs.sum() / 1e7) # convert to reads mapping per ten million\n# # convert to a binary array with global poisson\n# genome_rate = d_obs / (d_obs.sum() / 1e6)\n\n# if final_data is None:\n# final_data = sp.zeros((I, len(d_obs), L * 3), dtype=sp.float32)\n# asinh_obs = sp.log(genome_rate + sp.sqrt(genome_rate * genome_rate + 1))\n# gk = _gauss_kernel(3)\n# smoothed_obs = scipy.signal.convolve(asinh_obs, gk, mode='same')\n# smooth_deriv = sp.gradient(smoothed_obs)\n# smooth_deriv2 = sp.gradient(smooth_deriv)\n# final_data[i, :, l] = smoothed_obs\n# final_data[i, :, l + 1] = smooth_deriv\n# final_data[i, :, l + 2] = smooth_deriv2\n# total_size = final_data.shape[1]\n\n\n# regions_to_keep = (final_data[:, :, tuple(range(0, L * 3, 3))].sum(axis=0).sum(axis=1) >= args.min_reads).astype(sp.int8)\n# # find the regions where a transition is made from no reads to reads, and reads to no reads\n# start_ts = sp.where(sp.diff(regions_to_keep) > 0)[0]\n# end_ts = sp.where(sp.diff(regions_to_keep) < 0)[0]\n\n# cur_regions = [r for r in zip(start_ts, end_ts) if r[1] - r[0] >= args.min_size]\n# sizes = [end_t - start_t for start_t, end_t in cur_regions]\n\n# print 'saving %s regions' % len(sizes)\n# tarout = tarfile.open(args.outfile + '.tar.gz', 'w:gz')\n# for chunknum, (start_t, end_t) in enumerate(cur_regions):\n# covered_size += end_t - start_t\n# tmpX = final_data[:, start_t:end_t, :]\n\n# print 'adding chunk', chunknum, 'of', len(cur_regions)\n# s = StringIO()\n# sp.save(s, tmpX)\n# name = args.outfile + '.chunk%s.npy' % chunknum\n# info = tarfile.TarInfo(name)\n# info.size = s.tell(); info.mtime = time.time()\n# s.seek(0)\n# tarout.addfile(info, s)\n# start_positions[name] = start_t\n\n# print '# plotting size distribution'\n# pyplot.figure()\n# pyplot.figtext(.5,.01,'%s regions; %s bins total; %s bins covered; coverage = %.3f' % (len(sizes),total_size, covered_size, covered_size / float(total_size)), ha='center')\n# pyplot.hist(sizes, bins=100)\n# pyplot.title('chunk sizes for all chroms, min_reads %s, min_size %s, windowsize %s' % (args.min_reads, args.min_size, args.windowsize))\n# pyplot.savefig('chunk_sizes.minreads%s.minsize%s.windowsize%s.png' % (args.min_reads, args.min_size, args.windowsize))\n\n# s = StringIO()\n# pyplot.savefig(s)\n# info = tarfile.TarInfo('chunk_sizes.minreads%s.minsize%s.windowsize%s.png' % (args.min_reads, args.min_size, args.windowsize))\n# info.size = s.tell(); info.mtime = time.time()\n# s.seek(0)\n# tarout.addfile(info, s)\n\n# s = StringIO()\n# pickle.dump(start_positions, s)\n# info = tarfile.TarInfo('start_positions.pkl')\n# info.size = s.tell(); info.mtime = time.time()\n# s.seek(0)\n# tarout.addfile(info, s)\n# pickle.dump(start_positions, open('start_positions.pkl', 'w'))\n# # --min_reads .5 --min_size 25 --window_size 200;\n\n\n# s = StringIO()\n# sp.save(s, args.mark_avail)\n# info = tarfile.TarInfo('available_marks.npy')\n# info.size = s.tell(); info.mtime = time.time()\n# s.seek(0)\n# tarout.addfile(info, s)\n# pickle.dump(start_positions, open('start_positions.pkl', 'w'))\n# # --min_reads .5 --min_size 25 --window_size 200;\n\n# tarout.close()\n\n\n# print \"output file:\", args.outfile\n# print 'available marks:', args.mark_avail\n# #with open(args.outfile, 'wb') as outfile:\n# # sp.save(outfile, final_data)\n# with open(args.outfile + '.available_marks', 'wb') as outfile:\n# sp.save(outfile, args.mark_avail)\n\n\ndef _gauss_kernel(winsize):\n x = sp.mgrid[-int(winsize):int(winsize)+1]\n g = sp.exp(-(x**2/float(winsize)))\n return g / g.sum()\n\ndef convert_data(args):\n \"\"\"histogram both treatment and control data as specified by args\n This saves the complete X matrix\n \"\"\"\n if args.download_first:\n download_data(args)\n I = len(args.species)\n L = len(args.marks)\n final_data = None\n start_positions = {}\n # make sure all the data is present...\n for species in args.species:\n for mark in args.marks:\n d_files = [f for f in glob.glob(args.bam_template.format(\n species=species, mark=mark, repnum='*'))]\n if len(d_files) == 0:\n raise RuntimeError(\"No histone data for species %s mark %s Expected: %s\" %\n (species, mark, args.bam_template.format(\n species=species, mark=mark, repnum='*')))\n\n for i, species in enumerate(args.species):\n for l, mark in enumerate(args.marks):\n\n d_obs = {}\n d_files = [f for f in glob.glob(args.bam_template.format(\n species=species, mark=mark, repnum='*'))]\n if len(d_files) == 0:\n pass\n else:\n for mark_file in d_files:\n read_counts = histogram_reads(mark_file, args.windowsize, args.chromosomes) \n # d_obs.append(histogram_reads(mark_file, args.windowsize,\n # args.chromosomes))\n for chrom in read_counts:\n d_obs.setdefault(chrom, []).append(read_counts[chrom])\n for chrom in d_obs:\n d_obs[chrom] = reduce(operator.add, d_obs[chrom]) # add all replicants together\n #print 'before per million:', d_obs.sum()\n #d_obs /= (d_obs.sum() / 1e7) # convert to reads mapping per ten million\n # convert to a binary array with global poisson\n num_reads = sum(x.sum() for x in d_obs.values())\n num_bins = float(sum(len(x) for x in d_obs.values()))\n genome_rate = num_reads / num_bins\n print 'after per million', num_reads, num_bins, genome_rate\n if final_data is None:\n final_data = {}\n for chrom in d_obs:\n d_obs[chrom] = call_significant_sites(d_obs[chrom], genome_rate, args.max_pvalue)\n if chrom not in final_data:\n final_data[chrom] = sp.zeros((I, len(d_obs[chrom]), L), dtype=sp.int8)\n final_data[chrom][i, :, l] = d_obs[chrom]\n for chrom in final_data:\n start_positions[os.path.split(args.outfile.format(chrom=chrom))[1]] = (chrom, 0)\n print \"output file:\", args.outfile.format(chrom=chrom)\n with open(args.outfile.format(chrom=chrom), 'wb') as outfile:\n sp.save(outfile, final_data[chrom])\n with open('start_positions.pkl', 'w') as outfile:\n pickle.dump(dict(windowsize=args.windowsize, valid_species=valid_species,\n valid_marks=valid_marks, start_positions=start_positions),\n outfile, -1)\n\ndef download_data(args):\n \"\"\"Download any missing histone modification data from UCSC and check md5s.\n \"\"\"\n md5s = urllib.urlopen(args.base_url % 'md5sum.txt').read().strip().split('\\n')\n md5s = dict(reversed(l.strip().split()) for l in md5s)\n for species in args.species:\n for mark in args.marks:\n for rep in range(10):\n fname = args.bam_template.format(species=species,\n mark=mark, repnum=rep)\n if fname not in md5s:\n continue\n if os.path.exists(fname):\n #m = hashlib.md5(open(fname, 'rb').read()).hexdigest()\n #if m != md5s[fname]: # destroy if md5 doesn't match\n # print 'removing incomplete file: %s' % fname\n # print m, md5s[fname]\n # os.unlink(fname)\n #else:\n print 'skipping already downloaded %s' % fname\n continue\n with open(fname, 'wb') as outfile:\n try:\n print 'downloading %s' % fname\n page = urllib.urlopen(args.base_url % fname)\n while True:\n data = page.read(81920)\n if not data:\n break\n outfile.write(data)\n except RuntimeError as e:\n print 'Skipping...', e.message\n\n\n\ndef histogram_reads(bam_file, windowsize, chromosomes='all', exclude_chroms=['chrM', 'chrY', 'chrX'],\n skip_qc_fail=True):\n \"\"\"Histogram the counts along bam_file, resulting in a vector.\n\n This will concatenate all chromosomes, together, so to get the\n counts for a particular chromosome, pass it as a list, a la\n >>> histogram_reads(my_bam_file, chromosomes=['chr1'])\n \"\"\"\n print 'histogramming', bam_file\n reads_bam = pysam.Samfile(bam_file, 'rb')\n # get the chromosome name and lengths for our subset\n if chromosomes == 'all':\n chromosomes = filter(lambda c: c not in exclude_chroms,\n reads_bam.references)\n chrom_set = set(chromosomes)\n chrom_lengths = {c : reads_bam.lengths[reads_bam.references.index(c)]\n for c in chromosomes}\n else:\n chromosomes = filter(lambda c: c not in exclude_chroms,\n chromosomes)\n chrom_lengths = {c : reads_bam.lengths[reads_bam.references.index(c)]\n for c in chromosomes if c not in\n exclude_chroms}\n chrom_set = set(chromosomes)\n # # offset of each chromosome into concatenated chrom bins\n # chrom_ends = list(((sp.array(chrom_lengths) // windowsize) + 1).cumsum())\n # chrom_starts = dict(zip(chromosomes, [0] + chrom_ends[:-1]))\n\n read_counts = {}\n # create the histogram: 1 x sum(lengths) array\n # read_counts = sp.zeros(chrom_ends[-1], dtype=float_type)\n\n # count the reads in the input\n for read in reads_bam:\n if skip_qc_fail and (read.is_qcfail or read.is_unmapped or read.is_secondary or\n read.is_duplicate or read.mapq == 0):\n continue # filter out non-mapping reads\n chrom = reads_bam.references[read.tid]\n if chrom in chrom_set: # chrom requested?\n # offset = chrom_starts[chrom]\n offset = 0\n if read.is_paired:\n if read.is_proper_pair:\n # add at the middle of the mates\n bin = offset + ((read.pos + read.mpos +\n read.rlen) / 2) // windowsize\n # read_counts[min(chrom_ends[-1] - 1, bin)] += 1.\n if chrom not in read_counts:\n read_counts[chrom] = sp.zeros(chrom_lengths[chrom] // windowsize, dtype=float_type)\n read_counts[chrom][min(chrom_lengths[chrom] // windowsize - 1, bin)] += 1.\n else:\n # add at the middle of the fragment\n bin = offset + (read.pos + 100) // windowsize\n if chrom not in read_counts:\n read_counts[chrom] = sp.zeros(chrom_lengths[chrom] // windowsize, dtype=float_type)\n read_counts[chrom][min(chrom_lengths[chrom] // windowsize - 1, bin)] += 1.\n return read_counts\n\n\ndef call_significant_sites(fg_counts, bg_counts, max_pvalue):\n \"\"\"binarize fg_counts (significant=1) using bg_counts as a local poisson\n rate. the poisson survival must be < sig_level.\n \"\"\"\n print 'most reads in a bin:', fg_counts.max(), 'poisson expected rate:', bg_counts\n print 'read count vs binary present:' , {i: poisson.sf(i, bg_counts) < max_pvalue for i in range(20)}\n return poisson.sf(fg_counts, bg_counts) < max_pvalue\n\n\nif __name__ == '__main__':\n main()\n", "meta": {"hexsha": "6a5058a8af999853fe6ff14d7f5ba63915bfba25", "size": 65101, "ext": "py", "lang": "Python", "max_stars_repo_path": "treehmm/__init__.py", "max_stars_repo_name": "uci-cbcl/tree-hmm", "max_stars_repo_head_hexsha": "e401f5f0fc107d89c03638695db79319db411d48", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 21, "max_stars_repo_stars_event_min_datetime": "2015-04-22T19:04:14.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-17T13:52:56.000Z", "max_issues_repo_path": "treehmm/__init__.py", "max_issues_repo_name": "uci-cbcl/tree-hmm", "max_issues_repo_head_hexsha": "e401f5f0fc107d89c03638695db79319db411d48", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2015-05-16T01:37:46.000Z", "max_issues_repo_issues_event_max_datetime": "2016-11-04T15:09:46.000Z", "max_forks_repo_path": "treehmm/__init__.py", "max_forks_repo_name": "uci-cbcl/tree-hmm", "max_forks_repo_head_hexsha": "e401f5f0fc107d89c03638695db79319db411d48", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2015-04-23T13:42:30.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-03T16:06:24.000Z", "avg_line_length": 47.553688824, "max_line_length": 369, "alphanum_fraction": 0.5905439241, "include": true, "reason": "import scipy,from scipy", "num_tokens": 15377, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5428632831725052, "lm_q2_score": 0.36658972248186, "lm_q1q2_score": 0.19900810032380006}} {"text": "from __future__ import print_function\nimport argparse\nimport wandb\nimport os\nimport random\nimport numpy as np\nimport torch\nimport torch.nn as nn\nimport torch.nn.parallel\nimport torch.backends.cudnn as cudnn\nimport torch.optim as optim\nimport torch.utils.data\nimport torchvision.datasets as dset\nimport torchvision.transforms as transforms\nimport torchvision.utils as vutils\n\n\nparser = argparse.ArgumentParser()\nparser.add_argument('--dataset', required=True, help='cifar10 | lsun | mnist |imagenet | folder | lfw | fake')\nparser.add_argument('--model', required=True, help='gramnet | gan')\nparser.add_argument('--dataroot', required=True, help='path to dataset')\nparser.add_argument('--workers', type=int, help='number of data loading workers', default=2)\nparser.add_argument('--batchSize', type=int, default=100, help='input batch size')\nparser.add_argument('--showSize', type=int, default=100, help='size of display batch')\nparser.add_argument('--imageSize', type=int, default=64, help='the height / width of the input image to network')\nparser.add_argument('--nz', type=int, default=100, help='size of the latent z vector')\nparser.add_argument('--nk', type=int, default=200, help='size of the projected k vector')\nparser.add_argument('--ngf', type=int, default=64)\nparser.add_argument('--ncf', type=int, default=64)\nparser.add_argument('--n_epochs', type=int, default=25, help='number of epochs to train for')\nparser.add_argument('--lr', type=float, default=0.0002, help='learning rate, default=0.0002')\nparser.add_argument('--beta1', type=float, default=0.5, help='beta1 for adam. default=0.5')\nparser.add_argument('--clip_ratio', action='store_true', help='apply ratio clipping (suggested by reviewer 1)')\nparser.add_argument('--eps_ratio', type=float, default=0.001, help='add eps to the diagonal before solving')\nparser.add_argument('--cuda', action='store_true', help='enables cuda')\nparser.add_argument('--gpu_id', type=int, default=0, help='default GPU ID to use')\nparser.add_argument('--ngpu', type=int, default=1, help='number of GPUs to use')\nparser.add_argument('--netG', default='', help=\"path to netG (to continue training)\")\nparser.add_argument('--netD', default='', help=\"path to netD (to continue training)\")\nparser.add_argument('--netF', default='', help=\"path to netF (to continue training)\")\nparser.add_argument('--outf', default='.', help='folder to output images and model checkpoints')\nparser.add_argument('--monitor_heuristic', action='store_true', help='monitor heuristic σ')\nparser.add_argument('--manualSeed', type=int, help='manual seed')\nparser.add_argument('--nowandb', action='store_true', help='disables wandb')\nparser.add_argument('--classes', default='bedroom', help='comma separated list of classes for the lsun data set')\n\nopt = parser.parse_args()\nprint(opt)\nif not opt.nowandb:\n wandb.init(project=\"gramtorch\", config=opt)\n\ntry:\n os.makedirs(opt.outf)\nexcept OSError:\n pass\n\nif opt.manualSeed is None:\n opt.manualSeed = random.randint(1, 10000)\nprint(\"Random Seed: \", opt.manualSeed)\nrandom.seed(opt.manualSeed)\ntorch.manual_seed(opt.manualSeed)\n\ncudnn.benchmark = True\n\nif torch.cuda.is_available() and not opt.cuda:\n print(\"WARNING: You have a CUDA device, so you should probably run with --cuda\")\n\nif opt.dataset in ['imagenet', 'folder', 'lfw']:\n # folder dataset\n dataset = dset.ImageFolder(root=opt.dataroot,\n transform=transforms.Compose([\n transforms.Resize(opt.imageSize),\n transforms.CenterCrop(opt.imageSize),\n transforms.ToTensor(),\n transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),\n ]))\n nc=3\nelif opt.dataset == 'lsun':\n classes = [ c + '_train' for c in opt.classes.split(',')]\n dataset = dset.LSUN(root=opt.dataroot, classes=classes,\n transform=transforms.Compose([\n transforms.Resize(opt.imageSize),\n transforms.CenterCrop(opt.imageSize),\n transforms.ToTensor(),\n transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),\n ]))\n nc=3\nelif opt.dataset == 'cifar10':\n dataset = dset.CIFAR10(root=opt.dataroot, download=True,\n transform=transforms.Compose([\n transforms.Resize(opt.imageSize),\n transforms.ToTensor(),\n transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),\n ]))\n nc=3\n\nelif opt.dataset == 'mnist':\n dataset = dset.MNIST(root=opt.dataroot, download=True,\n transform=transforms.Compose([\n transforms.Resize(opt.imageSize),\n transforms.ToTensor(),\n transforms.Normalize((0.5,), (0.5,)),\n ]))\n nc=1\n\nelif opt.dataset == 'fake':\n dataset = dset.FakeData(image_size=(3, opt.imageSize, opt.imageSize),\n transform=transforms.ToTensor())\n nc=3\n\nassert dataset\ndataloader = torch.utils.data.DataLoader(dataset, batch_size=opt.batchSize,\n shuffle=True, num_workers=int(opt.workers))\n\ndevice = torch.device(f\"cuda:{opt.gpu_id}\" if opt.cuda else \"cpu\")\nngpu = int(opt.ngpu)\nnz = int(opt.nz)\nnk = int(opt.nk)\nngf = int(opt.ngf)\nncf = int(opt.ncf)\n\n\n# custom weights initialization called on netG and netD\ndef weights_init(m):\n classname = m.__class__.__name__\n if classname.find('Conv') != -1:\n m.weight.data.normal_(0.0, 0.02)\n elif classname.find('BatchNorm') != -1:\n m.weight.data.normal_(1.0, 0.02)\n m.bias.data.fill_(0)\n\ndef save_img(x_data, x_gen, epoch):\n vutils.save_image(\n x_data[0:opt.showSize],\n f'{opt.outf}/{opt.dataset}-{opt.model}-data.png',\n normalize=True\n )\n vutils.save_image(\n x_gen[0:opt.showSize],\n f'{opt.outf}/{opt.dataset}-{opt.model}-samples-epoch={epoch:03d}.png',\n normalize=True\n )\n if not opt.nowandb:\n wandb.log({\"samples\" : [wandb.Image(i) for i in x_gen[0:opt.showSize]]}, commit=False)\n\nclass Generator(nn.Module):\n def __init__(self, ngpu):\n super(Generator, self).__init__()\n self.ngpu = ngpu\n self.main = nn.Sequential(\n # input is Z, going into a convolution\n nn.ConvTranspose2d( nz, ngf * 8, 4, 1, 0, bias=False),\n nn.BatchNorm2d(ngf * 8),\n nn.ReLU(True),\n # state size. (ngf*8) x 4 x 4\n nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),\n nn.BatchNorm2d(ngf * 4),\n nn.ReLU(True),\n # state size. (ngf*4) x 8 x 8\n nn.ConvTranspose2d(ngf * 4, ngf * 2, 4, 2, 1, bias=False),\n nn.BatchNorm2d(ngf * 2),\n nn.ReLU(True),\n # state size. (ngf*2) x 16 x 16\n nn.ConvTranspose2d(ngf * 2, ngf, 4, 2, 1, bias=False),\n nn.BatchNorm2d(ngf),\n nn.ReLU(True),\n # state size. (ngf) x 32 x 32\n nn.ConvTranspose2d( ngf, nc, 4, 2, 1, bias=False),\n nn.Tanh()\n # state size. (nc) x 64 x 64\n )\n\n def forward(self, input):\n if input.is_cuda and self.ngpu > 1:\n output = nn.parallel.data_parallel(self.main, input, range(self.ngpu))\n else:\n output = self.main(input)\n return output\n\n\nclass Critic(nn.Module):\n def __init__(self, ngpu, nout):\n super(Critic, self).__init__()\n self.ngpu = ngpu\n self.nout = nout\n self.main = nn.Sequential(\n # input is (nc) x 64 x 64\n nn.Conv2d(nc, ncf, 4, 2, 1, bias=False),\n nn.LeakyReLU(0.2, inplace=True),\n # state size. (ncf) x 32 x 32\n nn.Conv2d(ncf, ncf * 2, 4, 2, 1, bias=False),\n nn.BatchNorm2d(ncf * 2),\n nn.LeakyReLU(0.2, inplace=True),\n # state size. (ncf*2) x 16 x 16\n nn.Conv2d(ncf * 2, ncf * 4, 4, 2, 1, bias=False),\n nn.BatchNorm2d(ncf * 4),\n nn.LeakyReLU(0.2, inplace=True),\n # state size. (ncf*4) x 8 x 8\n nn.Conv2d(ncf * 4, ncf * 8, 4, 2, 1, bias=False),\n nn.BatchNorm2d(ncf * 8),\n nn.LeakyReLU(0.2, inplace=True),\n # state size. (ncf*8) x 4 x 4\n )\n final = nn.Linear(ncf * 8 * 4 * 4, nout)\n if nout == 1:\n final = nn.Sequential(final, nn.Sigmoid())\n self.final = final\n\n def forward(self, input):\n if input.is_cuda and self.ngpu > 1:\n output = nn.parallel.data_parallel(self.main, input, range(self.ngpu))\n output = output.view(-1, ncf * 8 * 4 * 4)\n output = nn.parallel.data_parallel(self.final, output, range(self.ngpu))\n else:\n output = self.main(input)\n output = output.view(-1, ncf * 8 * 4 * 4)\n output = self.final(output)\n if self.nout == 1:\n output = output.view(-1, 1).squeeze(1)\n return output\n\n\nclass GAN:\n def __init__(self, ngpu):\n netG = Generator(ngpu).to(device)\n netG.apply(weights_init)\n if opt.netG != '':\n netG.load_state_dict(torch.load(opt.netG))\n print(netG)\n \n netD = Critic(ngpu, 1).to(device)\n netD.apply(weights_init)\n if opt.netD != '':\n netD.load_state_dict(torch.load(opt.netD))\n print(netD)\n\n self.netG = netG\n self.netD = netD\n\n def train(self):\n netG = self.netG\n netD = self.netD\n\n criterion = nn.BCELoss()\n\n fixed_noise = torch.randn(opt.showSize, nz, 1, 1, device=device)\n real_label = 1\n fake_label = 0\n\n # setup optimizer\n optimizerD = optim.Adam(netD.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999))\n optimizerG = optim.Adam(netG.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999))\n\n for epoch in range(opt.n_epochs):\n for i, data in enumerate(dataloader, 0):\n ############################\n # (1) Update D network: maximize log(D(x)) + log(1 - D(G(z)))\n ###########################\n # train with real\n netD.zero_grad()\n real_cpu = data[0].to(device)\n batch_size = real_cpu.size(0)\n label = torch.full((batch_size,), real_label, device=device)\n\n output = netD(real_cpu)\n errD_real = criterion(output, label)\n errD_real.backward()\n D_x = output.mean().item()\n\n # train with fake\n noise = torch.randn(batch_size, nz, 1, 1, device=device)\n fake = netG(noise)\n label.fill_(fake_label)\n output = netD(fake.detach())\n errD_fake = criterion(output, label)\n errD_fake.backward()\n D_G_z1 = output.mean().item()\n errD = errD_real + errD_fake\n optimizerD.step()\n\n ############################\n # (2) Update G network: maximize log(D(G(z)))\n ###########################\n netG.zero_grad()\n label.fill_(real_label) # fake labels are real for generator cost\n output = netD(fake)\n errG = criterion(output, label)\n errG.backward()\n D_G_z2 = output.mean().item()\n optimizerG.step()\n\n print('[%d/%d][%d/%d] Loss_D: %.4f Loss_G: %.4f D(x): %.4f D(G(z)): %.4f / %.4f'\n % (epoch, opt.n_epochs, i, len(dataloader),\n errD.item(), errG.item(), D_x, D_G_z1, D_G_z2))\n if i % 100 == 0:\n netG.train(False)\n save_img(real_cpu, netG(fixed_noise).detach(), epoch)\n netG.train(True)\n if not opt.nowandb:\n wandb.log({\n \"lossG\" : errG, \"lossF\" : errD, \n \"D(x)\" : D_G_z1, \"D(G(z))\" : D_G_z2,\n })\n\n # do checkpointing\n torch.save(netG.state_dict(), f'{opt.outf}/{opt.model}-netG-epoch={epoch}.pth')\n torch.save(netD.state_dict(), f'{opt.outf}/{opt.model}-netD-epoch={epoch}.pth')\n\n\n### MMD utilities\n\ndef euclidsq(x, y):\n return torch.pow(torch.cdist(x, y), 2)\n\ndef gaussian_gramian(esq, σ):\n return torch.exp(torch.div(-esq, 2 * σ**2))\n\ndef prepare(x_de, x_nu):\n return euclidsq(x_de, x_de), euclidsq(x_de, x_nu), euclidsq(x_nu, x_nu)\n\nUSE_SOLVE = True\n\ndef kmm_ratios(Kdede, Kdenu, λ):\n n_de, n_nu = Kdenu.shape\n if λ > 0:\n A = Kdede + λ * torch.eye(n_de).to(device)\n else:\n A = Kdede\n # Equivalent implement based on 1) solver and 2) matrix inversion\n if USE_SOLVE:\n B = torch.sum(Kdenu, 1, keepdim=True)\n return (n_de / n_nu) * torch.solve(B, A).solution\n else:\n B = Kdenu\n return torch.matmul(torch.matmul(torch.inverse(A), B), torch.ones(n_nu, 1).to(device))\n\ndef mmdsq_of(Kdede, Kdenu, Knunu):\n return torch.mean(Kdede) - 2 * torch.mean(Kdenu) + torch.mean(Knunu)\n\ndef estimate_ratio_compute_mmd(x_de, x_nu, σs):\n dsq_dede, dsq_denu, dsq_nunu = prepare(x_de, x_nu)\n if len(σs) == 0:\n # A heuristic is to use the median of pairwise distances as σ, suggested by Sugiyama's book\n sigma = torch.sqrt(\n torch.median(\n torch.cat([dsq_dede.squeeze(), dsq_denu.squeeze(), dsq_nunu.squeeze()], 1)\n )\n ).item()\n if not opt.nowandb:\n wandb.log({\"heuristic_sigma\" : sigma})\n elif opt.monitor_heuristic:\n print(\"heuristic sigma: \", sigma)\n # Use [sigma / 5, sigma / 3, sigma, sigma * 3, sigma * 5] if nothing provided\n if len(σs) == 0:\n σs.append(sigma)\n σs.append(sigma * 0.333)\n σs.append(sigma * 0.2)\n σs.append(sigma / 0.2)\n σs.append(sigma / 0.333)\n \n is_first = True\n ratio = None\n mmdsq = None\n for σ in σs:\n Kdede = gaussian_gramian(dsq_dede, σ)\n Kdenu = gaussian_gramian(dsq_denu, σ)\n Knunu = gaussian_gramian(dsq_nunu, σ)\n if is_first:\n ratio = kmm_ratios(Kdede, Kdenu, opt.eps_ratio)\n mmdsq = mmdsq_of(Kdede, Kdenu, Knunu)\n is_first = False\n else:\n ratio += kmm_ratios(Kdede, Kdenu, opt.eps_ratio)\n mmdsq += mmdsq_of(Kdede, Kdenu, Knunu)\n \n ratio = ratio / len(σs)\n ratio = torch.relu(ratio) if opt.clip_ratio else ratio\n mmd = torch.sqrt(torch.relu(mmdsq))\n \n return ratio, mmd\n\ndef extract_grad(m):\n gs = []\n for p in m.parameters():\n gs.append(p.grad.clone())\n return gs\n\ndef assign_grad(m, gs):\n for p, g in zip(m.parameters(), gs):\n p.grad = g\n\ndef sim_step(optimizer1, optimizer2, m1, m2, loss1, loss2):\n loss1.backward(retain_graph=True)\n gs1 = extract_grad(m1)\n m1.zero_grad()\n m2.zero_grad()\n loss2.backward()\n optimizer2.step()\n assign_grad(m1, gs1)\n optimizer1.step()\n\nclass GRAMnet:\n def __init__(self, ngpu):\n netG = Generator(ngpu).to(device)\n netG.apply(weights_init)\n if opt.netG != '':\n netG.load_state_dict(torch.load(opt.netG))\n print(netG)\n \n netF = Critic(ngpu, nk).to(device)\n netF.apply(weights_init)\n if opt.netF != '':\n netF.load_state_dict(torch.load(opt.netF))\n print(netF)\n\n self.netG = netG\n self.netF = netF\n\n if opt.dataset == \"mnist\":\n sigma_list = np.sqrt([0.01, 1, 100, 10000])\n elif opt.dataset == \"cifar10\":\n sigma_list = [1, 10, 100, 1000]\n else:\n sigma_list = [] # this will trigger automatic choice of sigma\n self.sigma_list = sigma_list\n\n def train(self):\n\n netG = self.netG\n netF = self.netF\n\n fixed_noise = torch.rand(opt.showSize, nz, 1, 1, device=device)\n\n # setup optimizer\n optimizerF = optim.Adam(netF.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999))\n optimizerG = optim.Adam(netG.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999))\n\n for epoch in range(opt.n_epochs):\n for i, data in enumerate(dataloader, 0):\n x_data = data[0].to(device)\n batch_size = x_data.size(0)\n\n netF.zero_grad()\n netG.zero_grad()\n # Generate samples\n noise = torch.rand(batch_size, nz, 1, 1, device=device)\n x_gen = netG(noise)\n # Project to low-dimensional space\n fx_data = netF(x_data)\n fx_gen = netF(x_gen)\n # Compute ratio and mmd\n ratio, mmd = estimate_ratio_compute_mmd(\n fx_gen, fx_data, list(self.sigma_list) # `list` is need to make a copy of sigmas\n )\n pearson_divergence = torch.mean(torch.pow(ratio - 1, 2))\n lossG = mmd\n lossF = -pearson_divergence\n # Add positivity regularizer if not clipping\n if not opt.clip_ratio: \n lossF -= torch.sum(ratio)\n # Update G and F simultaneously\n sim_step(optimizerG, optimizerF, netG, netF, lossG, lossF)\n\n print('[%d/%d][%d/%d] Loss_F: %.4f Loss_G: %.4f'\n % (epoch, opt.n_epochs, i, len(dataloader), lossF.item(), lossG.item()))\n if i % 100 == 0:\n netG.train(False)\n save_img(x_data, netG(fixed_noise).detach(), epoch)\n netG.train(True)\n if not opt.nowandb:\n wandb.log({\n \"lossG\" : lossG, \"lossF\" : lossF, \"mmd\" : mmd,\n \"pearson_divergence\" : pearson_divergence,\n })\n\n # do checkpointing\n torch.save(netG.state_dict(), f'{opt.outf}/{opt.model}-netG-epoch={epoch}.pth')\n torch.save(netF.state_dict(), f'{opt.outf}/{opt.model}-netF-epoch={epoch}.pth')\n\n\nif opt.model == \"gan\":\n model = GAN(ngpu)\nelif opt.model == \"gramnet\":\n model = GRAMnet(ngpu)\n\nmodel.train()\n", "meta": {"hexsha": "e6cac3de9d065ac696025795ca69b9e94902498c", "size": 18547, "ext": "py", "lang": "Python", "max_stars_repo_path": "main.py", "max_stars_repo_name": "GRAM-nets/GRAMTorch", "max_stars_repo_head_hexsha": "c790f19f0ebb37098871c5c204ee39a277781f4c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2020-04-08T08:27:41.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-03T09:43:55.000Z", "max_issues_repo_path": "main.py", "max_issues_repo_name": "GRAM-nets/PyGRAM", "max_issues_repo_head_hexsha": "c790f19f0ebb37098871c5c204ee39a277781f4c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "main.py", "max_forks_repo_name": "GRAM-nets/PyGRAM", "max_forks_repo_head_hexsha": "c790f19f0ebb37098871c5c204ee39a277781f4c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-04-30T11:19:43.000Z", "max_forks_repo_forks_event_max_datetime": "2020-11-28T17:24:15.000Z", "avg_line_length": 38.0841889117, "max_line_length": 113, "alphanum_fraction": 0.5561546342, "include": true, "reason": "import numpy", "num_tokens": 4876, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5428632831725052, "lm_q2_score": 0.36658972248186, "lm_q1q2_score": 0.19900810032380006}} {"text": "# -*- coding: utf-8 -*-\n# -----------------------------------------------------------------------------\n# (C) British Crown Copyright 2017-2021 Met Office.\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or without\n# modification, are permitted provided that the following conditions are met:\n#\n# * Redistributions of source code must retain the above copyright notice, this\n# list of conditions and the following disclaimer.\n#\n# * Redistributions in binary form must reproduce the above copyright notice,\n# this list of conditions and the following disclaimer in the documentation\n# and/or other materials provided with the distribution.\n#\n# * Neither the name of the copyright holder nor the names of its\n# contributors may be used to endorse or promote products derived from\n# this software without specific prior written permission.\n#\n# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n# POSSIBILITY OF SUCH DAMAGE.\n\"\"\"Reliability calibration plugins.\"\"\"\n\nimport operator\nimport warnings\n\nimport iris\nimport numpy as np\nimport scipy\n\nfrom improver import BasePlugin, PostProcessingPlugin\nfrom improver.calibration.utilities import (\n check_forecast_consistency,\n create_unified_frt_coord,\n filter_non_matching_cubes,\n)\nfrom improver.metadata.probabilistic import (\n find_threshold_coordinate,\n probability_is_above_or_below,\n)\nfrom improver.metadata.utilities import generate_mandatory_attributes\nfrom improver.utilities.cube_manipulation import MergeCubes, collapsed\n\n\nclass ConstructReliabilityCalibrationTables(BasePlugin):\n\n \"\"\"A plugin for creating and populating reliability calibration tables.\"\"\"\n\n def __init__(\n self,\n n_probability_bins=5,\n single_value_lower_limit=False,\n single_value_upper_limit=False,\n ):\n \"\"\"\n Initialise class for creating reliability calibration tables. These\n tables include data columns entitled observation_count,\n sum_of_forecast_probabilities, and forecast_count, defined below.\n\n n_probability_bins (int):\n The total number of probability bins required in the reliability\n tables. If single value limits are turned on, these are included in\n this total.\n single_value_lower_limit (bool):\n Mandates that the lowest bin should be single valued,\n with a small precision tolerance, defined as 1.0E-6.\n The bin is thus 0 to 1.0E-6.\n single_value_upper_limit (bool):\n Mandates that the highest bin should be single valued,\n with a small precision tolerance, defined as 1.0E-6.\n The bin is thus (1 - 1.0E-6) to 1.\n \"\"\"\n self.single_value_tolerance = 1.0e-6\n self.probability_bins = self._define_probability_bins(\n n_probability_bins, single_value_lower_limit, single_value_upper_limit\n )\n self.table_columns = np.array(\n [\"observation_count\", \"sum_of_forecast_probabilities\", \"forecast_count\"]\n )\n self.expected_table_shape = (len(self.table_columns), n_probability_bins)\n\n def __repr__(self):\n \"\"\"Represent the configured plugin instance as a string.\"\"\"\n bin_values = \", \".join(\n [\"[{:1.2f} --> {:1.2f}]\".format(*item) for item in self.probability_bins]\n )\n result = \"\"\n return result.format(bin_values)\n\n def _define_probability_bins(\n self, n_probability_bins, single_value_lower_limit, single_value_upper_limit\n ):\n \"\"\"\n Define equally sized probability bins for use in a reliability table.\n The range 0 to 1 is divided into ranges to give n_probability bins.\n If single_value_lower_limit and / or single_value_upper_limit are True,\n additional bins corresponding to values of 0 and / or 1 will be created,\n each with a width defined by self.single_value_tolerance.\n\n Args:\n n_probability_bins (int):\n The total number of probability bins desired in the\n reliability tables. This number includes the extrema bins\n (equals 0 and equals 1) if single value limits are turned on,\n in which case the minimum number of bins is 3.\n single_value_lower_limit (bool):\n Mandates that the lowest bin should be single valued,\n with a small precision tolerance, defined as 1.0E-6.\n The bin is thus 0 to 1.0E-6.\n single_value_upper_limit (bool):\n Mandates that the highest bin should be single valued,\n with a small precision tolerance, defined as 1.0E-6.\n The bin is thus (1 - 1.0E-6) to 1.\n Returns:\n numpy.ndarray:\n An array of 2-element arrays that contain the bounds of the\n probability bins. These bounds are non-overlapping, with\n adjacent bin boundaries spaced at the smallest representable\n interval.\n Raises:\n ValueError: If trying to use both single_value_lower_limit and\n single_value_upper_limit with 2 or fewer probability bins.\n \"\"\"\n if single_value_lower_limit and single_value_upper_limit:\n if n_probability_bins <= 2:\n msg = (\n \"Cannot use both single_value_lower_limit and \"\n \"single_value_upper_limit with 2 or fewer \"\n \"probability bins.\"\n )\n raise ValueError(msg)\n n_probability_bins = n_probability_bins - 2\n elif single_value_lower_limit or single_value_upper_limit:\n n_probability_bins = n_probability_bins - 1\n\n bin_lower = np.linspace(0, 1, n_probability_bins + 1, dtype=np.float32)\n bin_upper = np.nextafter(bin_lower, 0, dtype=np.float32)\n bin_upper[-1] = 1.0\n bins = np.stack([bin_lower[:-1], bin_upper[1:]], 1).astype(np.float32)\n\n if single_value_lower_limit:\n bins[0, 0] = np.nextafter(self.single_value_tolerance, 1, dtype=np.float32)\n lowest_bin = np.array([0, self.single_value_tolerance], dtype=np.float32)\n bins = np.vstack([lowest_bin, bins]).astype(np.float32)\n\n if single_value_upper_limit:\n bins[-1, 1] = np.nextafter(\n 1.0 - self.single_value_tolerance, 0, dtype=np.float32\n )\n highest_bin = np.array(\n [1.0 - self.single_value_tolerance, 1], dtype=np.float32\n )\n bins = np.vstack([bins, highest_bin]).astype(np.float32)\n\n return bins\n\n def _create_probability_bins_coord(self):\n \"\"\"\n Construct a dimension coordinate describing the probability bins\n of the reliability table.\n\n Returns:\n iris.coords.DimCoord:\n A dimension coordinate describing probability bins.\n \"\"\"\n values = np.mean(self.probability_bins, axis=1, dtype=np.float32)\n probability_bins_coord = iris.coords.DimCoord(\n values, long_name=\"probability_bin\", units=1, bounds=self.probability_bins\n )\n return probability_bins_coord\n\n def _create_reliability_table_coords(self):\n \"\"\"\n Construct coordinates that describe the reliability table rows. These\n are observation_count, sum_of_forecast_probabilities, and\n forecast_count. The order used here is the order in which the table\n data is populated, so these must remain consistent with the\n _populate_reliability_bins function.\n\n Returns:\n (tuple): tuple containing:\n **index_coord** (iris.coords.DimCoord):\n A numerical index dimension coordinate.\n **name_coord** (iris.coords.AuxCoord):\n An auxiliary coordinate that assigns names to the index\n coordinates, where these names correspond to the\n reliability table rows.\n \"\"\"\n index_coord = iris.coords.DimCoord(\n np.arange(len(self.table_columns), dtype=np.int32),\n long_name=\"table_row_index\",\n units=1,\n )\n name_coord = iris.coords.AuxCoord(\n self.table_columns, long_name=\"table_row_name\", units=1\n )\n return index_coord, name_coord\n\n @staticmethod\n def _define_metadata(forecast_slice):\n \"\"\"\n Define metadata that is specifically required for reliability table\n cubes, whilst ensuring any mandatory attributes are also populated.\n\n Args:\n forecast_slice (iris.cube.Cube):\n The source cube from which to get pre-existing metadata of use.\n Returns:\n dict:\n A dictionary of attributes that are appropriate for the\n reliability table cube.\n \"\"\"\n attributes = generate_mandatory_attributes([forecast_slice])\n attributes[\"title\"] = \"Reliability calibration data table\"\n return attributes\n\n def _create_reliability_table_cube(self, forecast, threshold_coord):\n \"\"\"\n Construct a reliability table cube and populate it with the provided\n data. The returned cube will include a cycle hour coordinate, which\n describes the model cycle hour at which the forecast data was produced.\n It will further include the forecast period, threshold coordinate,\n and spatial coordinates from the forecast cube.\n\n Args:\n forecast (iris.cube.Cube):\n A cube slice across the spatial dimensions of the forecast\n data. This slice provides the time and threshold values that\n relate to the reliability_table_data.\n threshold_coord (iris.coords.DimCoord):\n The threshold coordinate.\n Returns:\n iris.cube.Cube:\n A reliability table cube.\n \"\"\"\n\n def _get_coords_and_dims(coord_names):\n \"\"\"Obtain the requested coordinates and their dimension index from\n the forecast slice cube.\"\"\"\n coords_and_dims = []\n leading_coords = [probability_bins_coord, reliability_index_coord]\n for coord_name in coord_names:\n crd = forecast_slice.coord(coord_name)\n crd_dim = forecast_slice.coord_dims(crd)\n crd_dim = crd_dim[0] + len(leading_coords) if crd_dim else ()\n coords_and_dims.append((crd, crd_dim))\n return coords_and_dims\n\n forecast_slice = next(forecast.slices_over([\"time\", threshold_coord]))\n expected_shape = self.expected_table_shape + forecast_slice.shape\n dummy_data = np.zeros((expected_shape))\n\n diagnostic = find_threshold_coordinate(forecast).name()\n attributes = self._define_metadata(forecast)\n\n # Define reliability table specific coordinates\n probability_bins_coord = self._create_probability_bins_coord()\n (\n reliability_index_coord,\n reliability_name_coord,\n ) = self._create_reliability_table_coords()\n frt_coord = create_unified_frt_coord(forecast.coord(\"forecast_reference_time\"))\n\n # List of required non-spatial coordinates from the forecast\n non_spatial_coords = [\"forecast_period\", diagnostic]\n\n # Construct a list of coordinates in the desired order\n dim_coords = [forecast.coord(axis=dim).name() for dim in [\"x\", \"y\"]]\n dim_coords_and_dims = _get_coords_and_dims(dim_coords)\n aux_coords_and_dims = _get_coords_and_dims(non_spatial_coords)\n dim_coords_and_dims.append((reliability_index_coord, 0))\n aux_coords_and_dims.append((reliability_name_coord, 0))\n dim_coords_and_dims.append((probability_bins_coord, 1))\n\n reliability_cube = iris.cube.Cube(\n dummy_data,\n units=1,\n attributes=attributes,\n dim_coords_and_dims=dim_coords_and_dims,\n aux_coords_and_dims=aux_coords_and_dims,\n )\n reliability_cube.add_aux_coord(frt_coord)\n reliability_cube.rename(\"reliability_calibration_table\")\n\n return reliability_cube\n\n def _populate_reliability_bins(self, forecast, truth):\n \"\"\"\n For an x-y slice at a single validity time and threshold, populate\n a reliability table using the provided truth.\n\n Args:\n forecast (numpy.ndarray or numpy.ma.MaskedArray):\n An array containing data over an xy slice for a single validity\n time and threshold.\n truth (numpy.ndarray or numpy.ma.MaskedArray):\n An array containing a thresholded gridded truth at an\n equivalent validity time to the forecast array.\n Returns:\n numpy.ma.MaskedArray:\n An array containing reliability table data for a single time\n and threshold. The leading dimension corresponds to the rows\n of a calibration table, the second dimension to the number of\n probability bins, and the trailing dimensions are the spatial\n dimensions of the forecast and truth cubes (which are\n equivalent).\n \"\"\"\n observation_counts = []\n forecast_probabilities = []\n forecast_counts = []\n\n for bin_min, bin_max in self.probability_bins:\n observation_mask = (\n ((forecast >= bin_min) & (forecast <= bin_max)) & (np.isclose(truth, 1))\n ).astype(int)\n forecast_mask = ((forecast >= bin_min) & (forecast <= bin_max)).astype(int)\n forecasts_probability_values = forecast * forecast_mask\n\n observation_counts.append(observation_mask)\n forecast_probabilities.append(forecasts_probability_values)\n forecast_counts.append(forecast_mask)\n\n reliability_table = np.ma.stack(\n [\n np.ma.stack(observation_counts),\n np.ma.stack(forecast_probabilities),\n np.ma.stack(forecast_counts),\n ]\n )\n\n return reliability_table.astype(np.float32)\n\n def _populate_masked_reliability_bins(self, forecast, truth):\n \"\"\"\n Support populating the reliability table bins with a masked truth. If a\n masked truth is provided, a masked reliability table is returned.\n\n Args:\n forecast (numpy.ndarray):\n An array containing data over an xy slice for a single validity\n time and threshold.\n truth (numpy.ma.MaskedArray):\n An array containing a thresholded gridded truth at an\n equivalent validity time to the forecast array.\n Returns:\n numpy.ma.MaskedArray:\n An array containing reliability table data for a single time\n and threshold. The leading dimension corresponds to the rows\n of a calibration table, the second dimension to the number of\n probability bins, and the trailing dimensions are the spatial\n dimensions of the forecast and truth cubes (which are\n equivalent).\n \"\"\"\n forecast = np.ma.masked_where(np.ma.getmask(truth), forecast)\n table = self._populate_reliability_bins(forecast, truth)\n # Zero data underneath mask to support bitwise addition of masks.\n table.data[table.mask] = 0\n return table\n\n def _add_reliability_tables(self, forecast, truth, threshold_reliability):\n \"\"\"\n Add reliability tables. The presence of a masked truth is handled\n separately to ensure support for a mask that changes with validity time.\n\n Args:\n forecast (numpy.ndarray):\n An array containing data over an xy slice for a single validity\n time and threshold.\n truth (numpy.ndarray or numpy.ma.MaskedArray):\n An array containing a thresholded gridded truth at an\n equivalent validity time to the forecast array.\n threshold_reliability (numpy.ndarray or numpy.ma.MaskedArray):\n The current reliability table that will be added to.\n Returns:\n numpy.ndarray or numpy.ma.MaskedArray:\n An array containing reliability table data for a single time\n and threshold. The leading dimension corresponds to the rows\n of a calibration table, the second dimension to the number of\n probability bins, and the trailing dimensions are the spatial\n dimensions of the forecast and truth cubes (which are\n equivalent).\n \"\"\"\n if np.ma.is_masked(truth.data):\n table = self._populate_masked_reliability_bins(forecast.data, truth.data)\n # Bitwise addition of masks. This ensures that only points that are\n # masked in both the existing and new reliability tables are kept\n # as being masked within the resulting reliability table.\n mask = threshold_reliability.mask & table.mask\n threshold_reliability = np.ma.array(\n threshold_reliability.data + table.data, mask=mask, dtype=np.float32,\n )\n else:\n np.add(\n threshold_reliability,\n self._populate_reliability_bins(forecast.data, truth.data),\n out=threshold_reliability,\n dtype=np.float32,\n )\n return threshold_reliability\n\n def process(self, historic_forecasts, truths):\n \"\"\"\n Slice data over threshold and time coordinates to construct reliability\n tables. These are summed over time to give a single table for each\n threshold, constructed from all the provided historic forecasts and\n truths. If a masked truth is provided, a masked reliability table is\n returned. If the mask within the truth varies at different timesteps,\n any point that is unmasked for at least one timestep will have\n unmasked values within the reliability table. Therefore historic\n forecast points will only be used if they have a corresponding valid\n truth point for each timestep.\n\n .. See the documentation for an example of the resulting reliability\n table cube.\n .. include:: extended_documentation/calibration/\n reliability_calibration/reliability_calibration_examples.rst\n\n Note that the forecast and truth data used is probabilistic, i.e. has\n already been thresholded relative to the thresholds of interest, using\n the equality operator required. As such this plugin is agnostic as to\n whether the data is thresholded below or above a given diagnostic\n threshold.\n\n Args:\n historic_forecasts (iris.cube.Cube):\n A cube containing the historical forecasts used in calibration.\n These are expected to all have a consistent cycle hour, that is\n the hour in the forecast reference time.\n truths (iris.cube.Cube):\n A cube containing the thresholded gridded truths used in\n calibration.\n Returns:\n iris.cube.CubeList:\n A cubelist of reliability table cubes, one for each threshold\n in the historic forecast cubes.\n Raises:\n ValueError: If the forecast and truth cubes have differing\n threshold coordinates.\n \"\"\"\n historic_forecasts, truths = filter_non_matching_cubes(\n historic_forecasts, truths\n )\n\n threshold_coord = find_threshold_coordinate(historic_forecasts)\n truth_threshold_coord = find_threshold_coordinate(truths)\n if not threshold_coord == truth_threshold_coord:\n msg = \"Threshold coordinates differ between forecasts and truths.\"\n raise ValueError(msg)\n\n time_coord = historic_forecasts.coord(\"time\")\n\n check_forecast_consistency(historic_forecasts)\n reliability_cube = self._create_reliability_table_cube(\n historic_forecasts, threshold_coord\n )\n\n populate_bins_func = self._populate_reliability_bins\n if np.ma.is_masked(truths.data):\n populate_bins_func = self._populate_masked_reliability_bins\n\n reliability_tables = iris.cube.CubeList()\n threshold_slices = zip(\n historic_forecasts.slices_over(threshold_coord),\n truths.slices_over(threshold_coord),\n )\n for forecast_slice, truth_slice in threshold_slices:\n\n time_slices = zip(\n forecast_slice.slices_over(time_coord),\n truth_slice.slices_over(time_coord),\n )\n forecast, truth = next(time_slices)\n threshold_reliability = populate_bins_func(forecast.data, truth.data)\n\n for forecast, truth in time_slices:\n threshold_reliability = self._add_reliability_tables(\n forecast, truth, threshold_reliability\n )\n\n reliability_entry = reliability_cube.copy(data=threshold_reliability)\n reliability_entry.replace_coord(forecast_slice.coord(threshold_coord))\n reliability_tables.append(reliability_entry)\n\n return MergeCubes()(reliability_tables, copy=False)\n\n\nclass AggregateReliabilityCalibrationTables(BasePlugin):\n\n \"\"\"This plugin enables the aggregation of multiple reliability calibration\n tables, and/or the aggregation over coordinates in the tables.\"\"\"\n\n def __repr__(self):\n \"\"\"Represent the configured plugin instance as a string.\"\"\"\n return \"\"\n\n @staticmethod\n def _check_frt_coord(cubes):\n \"\"\"\n Check that the reliability calibration tables do not have overlapping\n forecast reference time bounds. If these coordinates overlap in time it\n indicates that some of the same forecast data has contributed to more\n than one table, thus aggregating them would double count these\n contributions.\n\n Args:\n cubes (iris.cube.CubeList):\n The list of reliability calibration tables for which the\n forecast reference time coordinates should be checked.\n Raises:\n ValueError: If the bounds overlap.\n \"\"\"\n lower_bounds = []\n upper_bounds = []\n for cube in cubes:\n lower_bounds.append(cube.coord(\"forecast_reference_time\").bounds[0][0])\n upper_bounds.append(cube.coord(\"forecast_reference_time\").bounds[0][1])\n if not all(x < y for x, y in zip(upper_bounds, lower_bounds[1:])):\n raise ValueError(\n \"Reliability calibration tables have overlapping \"\n \"forecast reference time bounds, indicating that \"\n \"the same forecast data has contributed to the \"\n \"construction of both tables. Cannot aggregate.\"\n )\n\n def process(self, cubes, coordinates=None):\n \"\"\"\n Aggregate the input reliability calibration table cubes and return the\n result.\n\n Args:\n cubes (list or iris.cube.CubeList):\n The cube or cubes containing the reliability calibration tables\n to aggregate.\n coordinates (list or None):\n A list of coordinates over which to aggregate the reliability\n calibration table using summation. If the argument is None and\n a single cube is provided, this cube will be returned\n unchanged.\n \"\"\"\n coordinates = [] if coordinates is None else coordinates\n\n try:\n (cube,) = cubes\n except ValueError:\n cubes = iris.cube.CubeList(cubes)\n self._check_frt_coord(cubes)\n cube = cubes.merge_cube()\n coordinates.append(\"forecast_reference_time\")\n else:\n if not coordinates:\n return cube\n\n result = collapsed(cube, coordinates, iris.analysis.SUM)\n frt = create_unified_frt_coord(cube.coord(\"forecast_reference_time\"))\n result.replace_coord(frt)\n return result\n\n\nclass ManipulateReliabilityTable(BasePlugin):\n \"\"\"\n A plugin to manipulate the reliability tables before they are used to\n calibrate a forecast. x and y coordinates on the reliability table must be\n collapsed.\n The result is a reliability diagram with monotonic observation frequency.\n\n Steps taken are:\n\n 1. If any bin contains less than the minimum forecast count then try\n combining this bin with whichever neighbour has the lowest sample count.\n This process is repeated for all bins that are below the minimum forecast\n count criterion.\n\n 2. If non-monotonicity of the observation frequency is detected, try\n combining a pair of bins that appear non-monotonic. Only a single pair of\n bins are combined.\n\n 3. If non-monotonicity of the observation frequency remains after trying\n to combine a single pair of bins, replace non-monotonic bins by assuming a\n constant observation frequency.\n \"\"\"\n\n def __init__(self, minimum_forecast_count=200):\n \"\"\"\n Initialise class for manipulating a reliability table.\n\n Args:\n minimum_forecast_count (int):\n The minimum number of forecast counts in a forecast probability\n bin for it to be used in calibration.\n The default value of 200 is that used in Flowerdew 2014.\n Raises:\n ValueError: If minimum_forecast_count is less than 1.\n References:\n Flowerdew J. 2014. Calibrating ensemble reliability whilst\n preserving spatial structure. Tellus, Ser. A Dyn. Meteorol.\n Oceanogr. 66.\n \"\"\"\n if minimum_forecast_count < 1:\n raise ValueError(\n \"The minimum_forecast_count must be at least 1 as empty \"\n \"bins in the reliability table are not handled.\"\n )\n\n self.minimum_forecast_count = minimum_forecast_count\n\n @staticmethod\n def _extract_reliability_table_components(reliability_table):\n \"\"\"Extract reliability table components from cube\n\n Args:\n reliability_table (iris.cube.Cube):\n A reliability table to be manipulated.\n\n Returns:\n Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, iris.coords.DimCoord]:\n Tuple containing the updated observation count,\n forecast probability sum, forecast count and probability bin\n coordinate.\n \"\"\"\n observation_count = reliability_table.extract(\n iris.Constraint(table_row_name=\"observation_count\")\n ).data\n forecast_probability_sum = reliability_table.extract(\n iris.Constraint(table_row_name=\"sum_of_forecast_probabilities\")\n ).data\n forecast_count = reliability_table.extract(\n iris.Constraint(table_row_name=\"forecast_count\")\n ).data\n probability_bin_coord = reliability_table.coord(\"probability_bin\")\n return (\n observation_count,\n forecast_probability_sum,\n forecast_count,\n probability_bin_coord,\n )\n\n @staticmethod\n def _sum_pairs(array, upper):\n \"\"\"\n Returns a new array where a pair of values in the original array have\n been replaced by their sum. Combines the value in the upper index with\n the value in the upper-1 index.\n\n Args:\n array (numpy.ndarray):\n Array to be modified.\n upper (int):\n Upper index of pair.\n\n Returns:\n numpy.ndarray:\n Array where a pair of values has been replaced by their sum.\n \"\"\"\n result = array.copy()\n result[upper - 1] = np.sum(array[upper - 1 : upper + 1])\n return np.delete(result, upper)\n\n @staticmethod\n def _create_new_bin_coord(probability_bin_coord, upper):\n \"\"\"\n Create a new probability_bin coordinate by combining two adjacent\n points on the probability_bin coordinate. This matches the combination\n of the data for the two bins.\n\n Args:\n probability_bin_coord (iris.coords.DimCoord):\n Original probability bin coordinate.\n upper (int):\n Upper index of pair.\n\n Returns:\n iris.coords.DimCoord:\n Probability bin coordinate with updated points and bounds where\n a pair of bins have been combined to create a single bin.\n \"\"\"\n old_bounds = probability_bin_coord.bounds\n new_bounds = np.concatenate(\n (\n old_bounds[0 : upper - 1],\n np.array([[old_bounds[upper - 1, 0], old_bounds[upper, 1]]]),\n old_bounds[upper + 1 :],\n )\n )\n new_points = np.mean(new_bounds, axis=1, dtype=np.float32)\n new_bin_coord = iris.coords.DimCoord(\n new_points, long_name=\"probability_bin\", units=1, bounds=new_bounds\n )\n return new_bin_coord\n\n def _combine_undersampled_bins(\n self,\n observation_count,\n forecast_probability_sum,\n forecast_count,\n probability_bin_coord,\n ):\n \"\"\"\n Combine bins that are under-sampled i.e. that have a lower forecast\n count than the minimum_forecast_count, so that information from these\n poorly-sampled bins can contribute to the calibration. If multiple\n bins are below the minimum forecast count, the bin closest to\n meeting the minimum_forecast_count criterion is combined with whichever\n neighbour has the lowest sample count. A new bin is then created by\n summing the neighbouring pair of bins. This process is repeated for all\n bins that are below the minimum forecast count criterion.\n\n Args:\n observation_count (numpy.ndarray):\n Observation count extracted from reliability table.\n forecast_probability_sum (numpy.ndarray):\n Forecast probability sum extracted from reliability table.\n forecast_count (numpy.ndarray):\n Forecast count extracted from reliability table.\n probability_bin_coord (iris.coords.DimCoord):\n Original probability bin coordinate.\n Returns:\n Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, iris.coords.DimCoord]\n Tuple containing the updated observation count,\n forecast probability sum, forecast count and probability bin\n coordinate.\n\n \"\"\"\n while (\n any(x < self.minimum_forecast_count for x in forecast_count)\n and len(forecast_count) > 1\n ):\n forecast_count_copy = forecast_count.copy()\n\n # Find index of the bin with the highest forecast count that is\n # below the minimum_forecast_count by setting forecast counts\n # greater than the minimum_forecast_count to NaN.\n forecast_count_copy[forecast_count >= self.minimum_forecast_count] = np.nan\n # Note for multiple occurrences of the maximum,\n # the index of the first occurrence is returned.\n index = np.int32(np.nanargmax(forecast_count_copy))\n\n # Determine the upper index of the pair of bins to be combined.\n if index == 0:\n # Must use higher bin\n upper = index + 1\n elif index + 1 == len(forecast_count):\n # Index already defines the upper bin\n upper = index\n else:\n # Define upper index to include bin with lowest sample count.\n if forecast_count[index + 1] > forecast_count[index - 1]:\n upper = index\n else:\n upper = index + 1\n\n forecast_count = self._sum_pairs(forecast_count, upper)\n observation_count = self._sum_pairs(observation_count, upper)\n forecast_probability_sum = self._sum_pairs(forecast_probability_sum, upper)\n probability_bin_coord = self._create_new_bin_coord(\n probability_bin_coord, upper\n )\n\n return (\n observation_count,\n forecast_probability_sum,\n forecast_count,\n probability_bin_coord,\n )\n\n def _combine_bin_pair(\n self,\n observation_count,\n forecast_probability_sum,\n forecast_count,\n probability_bin_coord,\n ):\n \"\"\"\n Combine a pair of bins when non-monotonicity of the observation\n frequency is detected. Iterate top-down from the highest forecast\n probability bin to the lowest probability bin when combining the bins.\n Only allow a single pair of bins to be combined.\n\n Args:\n observation_count (numpy.ndarray):\n Observation count extracted from reliability table.\n forecast_probability_sum (numpy.ndarray):\n Forecast probability sum extracted from reliability table.\n forecast_count (numpy.ndarray):\n Forecast count extracted from reliability table.\n probability_bin_coord (iris.coords.DimCoord):\n Original probability bin coordinate.\n\n Returns:\n Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, iris.coords.DimCoord]\n Tuple containing the updated observation count,\n forecast probability sum, forecast count and probability bin\n coordinate.\n \"\"\"\n observation_frequency = np.array(observation_count / forecast_count)\n for upper in np.arange(len(observation_frequency) - 1, 0, -1):\n (diff,) = np.diff(\n [observation_frequency[upper - 1], observation_frequency[upper]]\n )\n if diff < 0:\n forecast_count = self._sum_pairs(forecast_count, upper)\n observation_count = self._sum_pairs(observation_count, upper)\n forecast_probability_sum = self._sum_pairs(\n forecast_probability_sum, upper\n )\n probability_bin_coord = self._create_new_bin_coord(\n probability_bin_coord, upper\n )\n break\n return (\n observation_count,\n forecast_probability_sum,\n forecast_count,\n probability_bin_coord,\n )\n\n @staticmethod\n def _assume_constant_observation_frequency(observation_count, forecast_count):\n \"\"\"\n Decide which end bin (highest probability bin or lowest probability\n bin) has the highest sample count. Iterate through the observation\n frequency from the end bin with the highest sample count to the end bin\n with the lowest sample count. Whilst iterating, compare each pair of\n bins and, if a pair is non-monotonic, replace the value of the bin\n closer to the lowest sample count end bin with the value of the\n bin that is closer to the higher sample count end bin. Then calculate\n the new observation count required to give a monotonic observation\n frequency.\n\n Args:\n observation_count (numpy.ndarray):\n Observation count extracted from reliability table.\n forecast_count (numpy.ndarray):\n Forecast count extracted from reliability table.\n\n Returns:\n numpy.ndarray:\n Observation count computed from a monotonic observation frequency.\n\n \"\"\"\n observation_frequency = np.array(observation_count / forecast_count)\n\n iterator = observation_frequency\n operation = operator.lt\n # Top down if forecast count is lower for lowest probability bin,\n # than for highest probability bin.\n if forecast_count[0] < forecast_count[-1]:\n # Reverse array to iterate from top to bottom.\n iterator = observation_frequency[::-1]\n operation = operator.gt\n\n for index, lower_bin in enumerate(iterator[:-1]):\n (diff,) = np.diff([lower_bin, iterator[index + 1]])\n if operation(diff, 0):\n iterator[index + 1] = lower_bin\n\n observation_frequency = iterator\n if forecast_count[0] < forecast_count[-1]:\n # Re-reverse array from bottom to top to ensure original ordering.\n observation_frequency = iterator[::-1]\n\n observation_count = observation_frequency * forecast_count\n return observation_count\n\n @staticmethod\n def _update_reliability_table(\n reliability_table,\n observation_count,\n forecast_probability_sum,\n forecast_count,\n probability_bin_coord,\n ):\n \"\"\"\n Update the reliability table data and the probability bin coordinate.\n\n Args:\n reliability_table (iris.cube.Cube):\n A reliability table to be manipulated.\n observation_count (numpy.ndarray):\n Observation count extracted from reliability table.\n forecast_probability_sum (numpy.ndarray):\n Forecast probability sum extracted from reliability table.\n forecast_count (numpy.ndarray):\n Forecast count extracted from reliability table.\n probability_bin_coord (iris.coords.DimCoord):\n Original probability bin coordinate.\n\n Returns:\n iris.cube.Cube:\n Updated reliability table.\n \"\"\"\n final_data = np.stack(\n [observation_count, forecast_probability_sum, forecast_count]\n )\n nrows, ncols = final_data.shape\n reliability_table = reliability_table[0:nrows, 0:ncols].copy(data=final_data)\n reliability_table.replace_coord(probability_bin_coord)\n return reliability_table\n\n def process(self, reliability_table):\n \"\"\"\n Apply the steps needed to produce a reliability diagram with a\n monotonic observation frequency.\n\n Args:\n reliability_table (iris.cube.Cube):\n A reliability table to be manipulated. The only coordinates\n expected on this cube are a threshold coordinate,\n a table_row_index coordinate and corresponding table_row_name\n coordinate and a probability_bin coordinate.\n\n Returns:\n iris.cube.CubeList:\n Containing a reliability table cube for each threshold in the\n input reliablity table. For tables where monotonicity has been\n enforced the probability_bin coordinate will have one less\n bin than the tables that were already monotonic. If\n under-sampled bins have been combined, then the probability_bin\n coordinate will have been reduced until all bins have more than\n the minimum_forecast_count if possible; a single under-sampled\n bin will be returned if combining all bins is still insufficient\n to reach the minimum_forecast_count.\n \"\"\"\n threshold_coord = find_threshold_coordinate(reliability_table)\n reliability_table_cubelist = iris.cube.CubeList()\n for rel_table_slice in reliability_table.slices_over(threshold_coord):\n (\n observation_count,\n forecast_probability_sum,\n forecast_count,\n probability_bin_coord,\n ) = self._extract_reliability_table_components(rel_table_slice)\n\n if np.any(forecast_count < self.minimum_forecast_count):\n (\n observation_count,\n forecast_probability_sum,\n forecast_count,\n probability_bin_coord,\n ) = self._combine_undersampled_bins(\n observation_count,\n forecast_probability_sum,\n forecast_count,\n probability_bin_coord,\n )\n rel_table_slice = self._update_reliability_table(\n rel_table_slice,\n observation_count,\n forecast_probability_sum,\n forecast_count,\n probability_bin_coord,\n )\n\n # If the observation frequency is non-monotonic adjust the\n # reliability table\n observation_frequency = np.array(observation_count / forecast_count)\n if not np.all(np.diff(observation_frequency) >= 0):\n (\n observation_count,\n forecast_probability_sum,\n forecast_count,\n probability_bin_coord,\n ) = self._combine_bin_pair(\n observation_count,\n forecast_probability_sum,\n forecast_count,\n probability_bin_coord,\n )\n observation_count = self._assume_constant_observation_frequency(\n observation_count, forecast_count\n )\n rel_table_slice = self._update_reliability_table(\n rel_table_slice,\n observation_count,\n forecast_probability_sum,\n forecast_count,\n probability_bin_coord,\n )\n reliability_table_cubelist.append(rel_table_slice)\n return reliability_table_cubelist\n\n\nclass ApplyReliabilityCalibration(PostProcessingPlugin):\n\n \"\"\"\n A plugin for the application of reliability calibration to probability\n forecasts. This calibration is designed to improve the reliability of\n probability forecasts without significantly degrading their resolution.\n\n The method implemented here is described in Flowerdew J. 2014. Calibration\n is always applied as long as there are at least two bins within the input\n reliability table.\n\n References:\n Flowerdew J. 2014. Calibrating ensemble reliability whilst\n preserving spatial structure. Tellus, Ser. A Dyn. Meteorol.\n Oceanogr. 66.\n \"\"\"\n\n def __init__(self):\n \"\"\"\n Initialise class for applying reliability calibration.\n\n \"\"\"\n self.threshold_coord = None\n\n @staticmethod\n def _extract_matching_reliability_table(forecast, reliability_table):\n \"\"\"\n Extract the reliability table with a threshold coordinate\n matching the forecast cube.\n If no matching reliability table is found raise an exception.\n\n Args:\n forecast (iris.cube.Cube):\n The forecast to be calibrated.\n reliability_table (iris.cube.CubeList):\n The reliability table to use for applying calibration.\n Returns:\n iris.cube.Cube:\n A reliability table who's threshold coordinate matches\n the forecast cube.\n Raises:\n ValueError: If no matching reliability table is found.\n \"\"\"\n threshold_coord = find_threshold_coordinate(forecast)\n coord_values = {threshold_coord.name(): threshold_coord.points}\n constr = iris.Constraint(coord_values=coord_values)\n if isinstance(reliability_table, iris.cube.Cube):\n extracted = reliability_table.extract(constr)\n else:\n extracted = reliability_table.extract(constr, strict=True)\n if not extracted:\n raise ValueError(\n \"No reliability table found to match threshold \"\n f\"{find_threshold_coordinate(forecast).points[0]}.\"\n )\n return extracted\n\n def _ensure_monotonicity_across_thresholds(self, cube):\n \"\"\"\n Ensures that probabilities change monotonically relative to thresholds\n in the expected order, e.g. exceedance probabilities always remain the\n same or decrease as the threshold values increase, below threshold\n probabilities always remain the same or increase as the threshold\n values increase.\n\n Args:\n cube (iris.cube.Cube):\n The probability cube for which monotonicity is to be checked\n and enforced. This cube is modified in place.\n Raises:\n ValueError: Threshold coordinate lacks the\n spp__relative_to_threshold attribute.\n Warns:\n UserWarning: If the probabilities must be sorted to reinstate\n expected monotonicity following calibration.\n \"\"\"\n (threshold_dim,) = cube.coord_dims(self.threshold_coord)\n thresholding = probability_is_above_or_below(cube)\n if thresholding is None:\n msg = (\n \"Cube threshold coordinate does not define whether \"\n \"thresholding is above or below the defined thresholds.\"\n )\n raise ValueError(msg)\n\n if (\n thresholding == \"above\"\n and not (np.diff(cube.data, axis=threshold_dim) <= 0).all()\n ):\n msg = (\n \"Exceedance probabilities are not decreasing monotonically \"\n \"as the threshold values increase. Forced back into order.\"\n )\n warnings.warn(msg)\n cube.data = np.sort(cube.data, axis=threshold_dim)[::-1]\n\n if (\n thresholding == \"below\"\n and not (np.diff(cube.data, axis=threshold_dim) >= 0).all()\n ):\n msg = (\n \"Below threshold probabilities are not increasing \"\n \"monotonically as the threshold values increase. Forced \"\n \"back into order.\"\n )\n warnings.warn(msg)\n cube.data = np.sort(cube.data, axis=threshold_dim)\n\n def _calculate_reliability_probabilities(self, reliability_table):\n \"\"\"\n Calculates forecast probabilities and observation frequencies from the\n reliability table. If fewer than two bins are provided, Nones are\n returned as no calibration can be applied. Fewer than two bins can occur\n due to repeated combination of undersampled probability bins,\n please see :class:`.ManipulateReliabilityTable`.\n\n Args:\n reliability_table (iris.cube.Cube):\n A reliability table for a single threshold from which to\n calculate the forecast probabilities and observation\n frequencies.\n Returns:\n Optional[Tuple[numpy.ndarray, numpy.ndarray]]:\n Tuple containing forecast probabilities calculated by dividing\n the sum of forecast probabilities by the forecast count and\n observation frequency calculated by dividing the observation\n count by the forecast count.\n \"\"\"\n observation_count = reliability_table.extract(\n iris.Constraint(table_row_name=\"observation_count\")\n ).data\n forecast_count = reliability_table.extract(\n iris.Constraint(table_row_name=\"forecast_count\")\n ).data\n forecast_probability_sum = reliability_table.extract(\n iris.Constraint(table_row_name=\"sum_of_forecast_probabilities\")\n ).data\n\n # If there are fewer than two bins, no calibration can be applied.\n if len(np.atleast_1d(forecast_count)) < 2:\n return None, None\n\n forecast_probability = np.array(forecast_probability_sum / forecast_count)\n observation_frequency = np.array(observation_count / forecast_count)\n\n return forecast_probability, observation_frequency\n\n @staticmethod\n def _interpolate(\n forecast_threshold, reliability_probabilities, observation_frequencies\n ):\n \"\"\"\n Perform interpolation of the forecast probabilities using the\n reliability table data to produce the calibrated forecast. Where\n necessary linear extrapolation will be applied. Any mask in place on\n the forecast_threshold data is removed and reapplied after calibration.\n\n Args:\n forecast_threshold (numpy.ndarray):\n The forecast probabilities to be calibrated.\n reliability_probabilities (numpy.ndarray):\n Probabilities taken from the reliability tables.\n observation_frequencies (numpy.ndarray):\n Observation frequencies that relate to the reliability\n probabilities, taken from the reliability tables.\n\n Returns:\n numpy.ndarray:\n The calibrated forecast probabilities. The final results are\n clipped to ensure any extrapolation has not yielded\n probabilities outside the range 0 to 1.\n \"\"\"\n shape = forecast_threshold.shape\n mask = forecast_threshold.mask if np.ma.is_masked(forecast_threshold) else None\n\n forecast_probabilities = np.ma.getdata(forecast_threshold).flatten()\n\n interpolation_function = scipy.interpolate.interp1d(\n reliability_probabilities, observation_frequencies, fill_value=\"extrapolate\"\n )\n interpolated = interpolation_function(forecast_probabilities.data)\n\n interpolated = interpolated.reshape(shape).astype(np.float32)\n\n if mask is not None:\n interpolated = np.ma.masked_array(interpolated, mask=mask)\n\n return np.clip(interpolated, 0, 1)\n\n def process(self, forecast, reliability_table):\n \"\"\"\n Apply reliability calibration to a forecast. The reliability table\n and the forecast cube must share an identical threshold coordinate.\n\n Args:\n forecast (iris.cube.Cube):\n The forecast to be calibrated.\n reliability_table (iris.cube.Cube or iris.cube.CubeList):\n The reliability table to use for applying calibration.\n x and y dimensions must be collapsed.\n Returns:\n iris.cube.Cube:\n The forecast cube following calibration.\n \"\"\"\n self.threshold_coord = find_threshold_coordinate(forecast)\n\n forecast_thresholds = forecast.slices_over(self.threshold_coord)\n\n uncalibrated_thresholds = []\n calibrated_cubes = iris.cube.CubeList()\n for forecast_threshold in forecast_thresholds:\n reliability_threshold = self._extract_matching_reliability_table(\n forecast_threshold, reliability_table\n )\n (\n reliability_probabilities,\n observation_frequencies,\n ) = self._calculate_reliability_probabilities(reliability_threshold)\n\n if reliability_probabilities is None:\n calibrated_cubes.append(forecast_threshold)\n uncalibrated_thresholds.append(\n forecast_threshold.coord(self.threshold_coord).points[0]\n )\n continue\n\n interpolated = self._interpolate(\n forecast_threshold.data,\n reliability_probabilities,\n observation_frequencies,\n )\n\n calibrated_cubes.append(forecast_threshold.copy(data=interpolated))\n\n calibrated_forecast = calibrated_cubes.merge_cube()\n self._ensure_monotonicity_across_thresholds(calibrated_forecast)\n\n if uncalibrated_thresholds:\n msg = (\n \"The following thresholds were not calibrated due to \"\n \"insufficient forecast counts in reliability table bins: \"\n \"{}\".format(uncalibrated_thresholds)\n )\n warnings.warn(msg)\n\n return calibrated_forecast\n", "meta": {"hexsha": "fe25dc30488839283891e2160c5358e1a154ecf4", "size": 52804, "ext": "py", "lang": "Python", "max_stars_repo_path": "improver/calibration/reliability_calibration.py", "max_stars_repo_name": "cgsandford/improver", "max_stars_repo_head_hexsha": "3cfbf3323d3a693a9c61fec13350295b85d03676", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-08-02T21:17:18.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-02T21:17:18.000Z", "max_issues_repo_path": "improver/calibration/reliability_calibration.py", "max_issues_repo_name": "NMC-DAVE/improver", "max_issues_repo_head_hexsha": "b56379f8bd236ddf2bab31ef64af8345de856cc1", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2018-01-24T11:29:15.000Z", "max_issues_repo_issues_event_max_datetime": "2021-01-11T15:16:21.000Z", "max_forks_repo_path": "improver/calibration/reliability_calibration.py", "max_forks_repo_name": "cgsandford/improver", "max_forks_repo_head_hexsha": "3cfbf3323d3a693a9c61fec13350295b85d03676", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-08-02T21:17:19.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-02T21:17:19.000Z", "avg_line_length": 42.6871463217, "max_line_length": 88, "alphanum_fraction": 0.6368646315, "include": true, "reason": "import numpy,import scipy", "num_tokens": 9753, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.38861802670584894, "lm_q1q2_score": 0.19886229715274967}} {"text": "\"\"\"\nOperation representation classes for the `statevec_slow` evolution type.\n\"\"\"\n#***************************************************************************************************\n# Copyright 2015, 2019 National Technology & Engineering Solutions of Sandia, LLC (NTESS).\n# Under the terms of Contract DE-NA0003525 with NTESS, the U.S. Government retains certain rights\n# in this software.\n# Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except\n# in compliance with the License. You may obtain a copy of the License at\n# http://www.apache.org/licenses/LICENSE-2.0 or in the LICENSE file in the root pyGSTi directory.\n#***************************************************************************************************\n\nimport itertools as _itertools\nimport copy as _copy\n\nimport numpy as _np\nfrom scipy.sparse.linalg import LinearOperator\n\nfrom .statereps import StateRepDensePure as _StateRepDensePure\nfrom .. import basereps as _basereps\nfrom pygsti.baseobjs.statespace import StateSpace as _StateSpace\nfrom ...tools import basistools as _bt\nfrom ...tools import internalgates as _itgs\nfrom ...tools import optools as _ot\n\n\nclass OpRep(_basereps.OpRep):\n def __init__(self, state_space):\n self.state_space = state_space\n\n @property\n def dim(self):\n return self.state_space.udim\n\n def acton(self, state):\n raise NotImplementedError()\n\n def adjoint_acton(self, state):\n raise NotImplementedError()\n\n def aslinearoperator(self):\n def mv(v):\n if v.ndim == 2 and v.shape[1] == 1: v = v[:, 0]\n in_state = _StateRepDensePure(_np.ascontiguousarray(v, complex), self.state_space, basis=None)\n return self.acton(in_state).to_dense('Hilbert')\n\n def rmv(v):\n if v.ndim == 2 and v.shape[1] == 1: v = v[:, 0]\n in_state = _StateRepDensePure(_np.ascontiguousarray(v, complex), self.state_space, basis=None)\n return self.adjoint_acton(in_state).to_dense('Hilbert')\n return LinearOperator((self.dim, self.dim), matvec=mv, rmatvec=rmv) # transpose, adjoint, dot, matmat?\n\n def copy(self):\n return _copy.deepcopy(self)\n\n\nclass OpRepDenseUnitary(OpRep):\n def __init__(self, mx, basis, state_space):\n state_space = _StateSpace.cast(state_space)\n if mx is None:\n mx = _np.identity(state_space.udim, complex)\n assert(mx.ndim == 2 and mx.shape[0] == state_space.udim)\n self.basis = basis\n self.base = _np.require(mx, requirements=['OWNDATA', 'C_CONTIGUOUS'])\n super(OpRepDenseUnitary, self).__init__(state_space)\n\n def base_has_changed(self):\n pass\n\n def to_dense(self, on_space):\n if on_space in ('minimal', 'Hilbert'):\n return self.base\n elif on_space == 'HilbertSchmidt':\n return _ot.unitary_to_superop(self.base, self.basis)\n else:\n raise ValueError(\"Invalid `on_space` argument: %s\" % str(on_space))\n\n def acton(self, state):\n return _StateRepDensePure(_np.dot(self.base, state.data), state.state_space, state.basis)\n\n def adjoint_acton(self, state):\n return _StateRepDensePure(_np.dot(_np.conjugate(self.base.T), state.data),\n state.state_space, state.basis)\n\n def __str__(self):\n return \"OpRepDenseUnitary:\\n\" + str(self.base)\n\n\nclass OpRepStandard(OpRepDenseUnitary):\n def __init__(self, name, basis, state_space):\n std_unitaries = _itgs.standard_gatename_unitaries()\n self.name = name\n if self.name not in std_unitaries:\n raise ValueError(\"Name '%s' not in standard unitaries\" % self.name)\n\n U = std_unitaries[self.name]\n state_space = _StateSpace.cast(state_space)\n assert(U.shape[0] == state_space.udim)\n\n super(OpRepStandard, self).__init__(U, basis, state_space)\n\n\n#class OpRepStochastic(OpRepDense):\n# - maybe we could add this, but it wouldn't be a \"dense\" op here,\n# perhaps we need to change API?\n\n\nclass OpRepComposed(OpRep):\n # exactly the same as densitymx case\n def __init__(self, factor_op_reps, state_space):\n #assert(len(factor_op_reps) > 0), \"Composed gates must contain at least one factor gate!\"\n self.factors_reps = factor_op_reps\n super(OpRepComposed, self).__init__(state_space)\n\n def acton(self, state):\n \"\"\" Act this gate map on an input state \"\"\"\n for gate in self.factor_reps:\n state = gate.acton(state)\n return state\n\n def adjoint_acton(self, state):\n \"\"\" Act the adjoint of this operation matrix on an input state \"\"\"\n for gate in reversed(self.factor_reps):\n state = gate.adjoint_acton(state)\n return state\n\n def reinit_factor_op_reps(self, new_factor_op_reps):\n self.factors_reps = new_factor_op_reps\n\n\nclass OpRepSum(OpRep):\n # exactly the same as densitymx case\n def __init__(self, factor_reps, state_space):\n #assert(len(factor_reps) > 0), \"Composed gates must contain at least one factor gate!\"\n self.factor_reps = factor_reps\n super(OpRepSum, self).__init__(state_space)\n\n def acton(self, state):\n \"\"\" Act this gate map on an input state \"\"\"\n output_state = _StateRepDensePure(_np.zeros(state.data.shape, complex), state.state_space, state.basis)\n for f in self.factor_reps:\n output_state.data += f.acton(state).data\n return output_state\n\n def adjoint_acton(self, state):\n \"\"\" Act the adjoint of this operation matrix on an input state \"\"\"\n output_state = _StateRepDensePure(_np.zeros(state.data.shape, complex), state.state_space, state.basis)\n for f in self.factor_reps:\n output_state.data += f.adjoint_acton(state).data\n return output_state\n\n\nclass OpRepEmbedded(OpRep):\n\n def __init__(self, state_space, target_labels, embedded_rep):\n\n state_space = _StateSpace.cast(state_space)\n iTensorProdBlks = [state_space.label_tensor_product_block_index(label) for label in target_labels]\n # index of tensor product block (of state space) a bit label is part of\n if len(set(iTensorProdBlks)) != 1:\n raise ValueError(\"All qubit labels of a multi-qubit operation must correspond to the\"\n \" same tensor-product-block of the state space -- checked previously\") # pragma: no cover # noqa\n\n iTensorProdBlk = iTensorProdBlks[0] # because they're all the same (tested above) - this is \"active\" block\n tensorProdBlkLabels = state_space.tensor_product_block_labels(iTensorProdBlk)\n # count possible *state-vector-space* indices of each component of the tensor product block\n numBasisEls = _np.array([state_space.label_udimension(l) for l in tensorProdBlkLabels], _np.int64)\n\n # Separate the components of the tensor product that are not operated on, i.e. that our\n # final map just acts as identity w.r.t.\n labelIndices = [tensorProdBlkLabels.index(label) for label in target_labels]\n actionInds = _np.array(labelIndices, _np.int64)\n assert(_np.product([numBasisEls[i] for i in actionInds]) == embedded_rep.dim), \\\n \"Embedded operation has dimension (%d) inconsistent with the given target labels (%s)\" % (\n embedded_rep.dim, str(target_labels))\n\n #dim = state_space.udim\n nBlocks = state_space.num_tensor_product_blocks\n iActiveBlock = iTensorProdBlk\n nComponents = len(state_space.tensor_product_block_labels(iActiveBlock))\n embeddedDim = embedded_rep.dim # a *unitary* dim - see .dim property above\n blocksizes = _np.array([_np.product(state_space.tensor_product_block_udimensions(k))\n for k in range(nBlocks)], _np.int64)\n\n self.target_labels = target_labels\n self.embedded_rep = embedded_rep\n self.num_basis_els = numBasisEls\n self.action_inds = actionInds\n self.blocksizes = blocksizes\n\n num_basis_els_noop_blankaction = self.num_basis_els.copy()\n for i in self.action_inds: num_basis_els_noop_blankaction[i] = 1\n self.basisInds_noop_blankaction = [list(range(n)) for n in num_basis_els_noop_blankaction]\n\n # multipliers to go from per-label indices to tensor-product-block index\n # e.g. if map(len,basisInds) == [1,4,4] then multipliers == [ 16 4 1 ]\n self.multipliers = _np.array(_np.flipud(_np.cumprod([1] + list(\n reversed(list(self.num_basis_els[1:]))))), _np.int64)\n self.basisInds_action = [list(range(self.num_basis_els[i])) for i in self.action_inds]\n\n self.embeddedDim = embeddedDim\n self.ncomponents = nComponents # number of components in \"active\" block\n self.active_block_index = iActiveBlock\n self.nblocks = nBlocks\n self.offset = sum(blocksizes[0:self.active_block_index])\n super(OpRepEmbedded, self).__init__(state_space)\n\n def _acton_other_blocks_trivially(self, output_state, state):\n offset = 0\n for iBlk, blockSize in enumerate(self.blocksizes):\n if iBlk != self.active_block_index:\n output_state.data[offset:offset + blockSize] = state.data[offset:offset + blockSize] # identity op\n offset += blockSize\n\n def acton(self, state):\n output_state = _StateRepDensePure(_np.zeros(state.data.shape, complex), state.state_space, state.basis)\n offset = self.offset # if rel_to_block else self.offset (rel_to_block == False here)\n\n for b in _itertools.product(*self.basisInds_noop_blankaction): # zeros in all action-index locations\n vec_index_noop = _np.dot(self.multipliers, tuple(b))\n inds = []\n for op_b in _itertools.product(*self.basisInds_action):\n vec_index = vec_index_noop\n for i, bInd in zip(self.action_inds, op_b):\n #b[i] = bInd #don't need to do this; just update vec_index:\n vec_index += self.multipliers[i] * bInd\n inds.append(offset + vec_index)\n embedded_instate = _StateRepDensePure(state.data[inds],\n state.state_space.create_subspace(self.target_labels), basis=None)\n embedded_outstate = self.embedded_rep.acton(embedded_instate)\n output_state.data[inds] += embedded_outstate.data\n\n #act on other blocks trivially:\n self._acton_other_blocks_trivially(output_state, state)\n return output_state\n\n def adjoint_acton(self, state):\n \"\"\" Act the adjoint of this gate map on an input state \"\"\"\n #NOTE: Same as acton except uses 'adjoint_acton(...)' below\n output_state = _StateRepDensePure(_np.zeros(state.data.shape, complex), state.state_space, state.basis)\n offset = self.offset # if rel_to_block else self.offset (rel_to_block == False here)\n\n for b in _itertools.product(*self.basisInds_noop_blankaction): # zeros in all action-index locations\n vec_index_noop = _np.dot(self.multipliers, tuple(b))\n inds = []\n for op_b in _itertools.product(*self.basisInds_action):\n vec_index = vec_index_noop\n for i, bInd in zip(self.action_inds, op_b):\n #b[i] = bInd #don't need to do this; just update vec_index:\n vec_index += self.multipliers[i] * bInd\n inds.append(offset + vec_index)\n embedded_instate = _StateRepDensePure(state.data[inds],\n state.state_space.create_subspace(self.target_labels), basis=None)\n embedded_outstate = self.embedded_rep.adjoint_acton(embedded_instate)\n output_state.data[inds] += embedded_outstate.data\n\n #act on other blocks trivially:\n self._acton_other_blocks_trivially(output_state, state)\n return output_state\n\n\nclass OpRepExpErrorgen(OpRep):\n\n def __init__(self, errorgen_rep):\n state_space = errorgen_rep.state_space\n self.errorgen_rep = errorgen_rep\n super(OpRepExpErrorgen, self).__init__(state_space)\n\n def errgenrep_has_changed(self, onenorm_upperbound):\n pass\n\n def acton(self, state):\n raise AttributeError(\"Cannot currently act with statevec.OpRepExpErrorgen - for terms only!\")\n\n def adjoint_acton(self, state):\n raise AttributeError(\"Cannot currently act with statevec.OpRepExpErrorgen - for terms only!\")\n\n\nclass OpRepRepeated(OpRep):\n def __init__(self, rep_to_repeat, num_repetitions, state_space):\n state_space = _StateSpace.cast(state_space)\n self.repeated_rep = rep_to_repeat\n self.num_repetitions = num_repetitions\n super(OpRepRepeated, self).__init__(state_space)\n\n def acton(self, state):\n \"\"\" Act this gate map on an input state \"\"\"\n for i in range(self.num_repetitions):\n state = self.repeated_rep.acton(state)\n return state\n\n def adjoint_acton(self, state):\n \"\"\" Act the adjoint of this operation matrix on an input state \"\"\"\n for i in range(self.num_repetitions):\n state = self.repeated_rep.adjoint_acton(state)\n return state\n\n\nclass OpRepLindbladErrorgen(OpRep):\n def __init__(self, lindblad_coefficient_blocks, state_space):\n super(OpRepLindbladErrorgen, self).__init__(state_space)\n self.Lterms = None\n self.Lterm_coeffs = None\n self.lindblad_coefficient_blocks = lindblad_coefficient_blocks\n", "meta": {"hexsha": "87e939e0d06c16868eef6b3ffbd30d7266dd7636", "size": 13560, "ext": "py", "lang": "Python", "max_stars_repo_path": "pygsti/evotypes/statevec_slow/opreps.py", "max_stars_repo_name": "pyGSTi-Developers/pyGSTi", "max_stars_repo_head_hexsha": "bfedc1de4d604f14b0f958615776fb80ddb59e33", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pygsti/evotypes/statevec_slow/opreps.py", "max_issues_repo_name": "pyGSTi-Developers/pyGSTi", "max_issues_repo_head_hexsha": "bfedc1de4d604f14b0f958615776fb80ddb59e33", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pygsti/evotypes/statevec_slow/opreps.py", "max_forks_repo_name": "pyGSTi-Developers/pyGSTi", "max_forks_repo_head_hexsha": "bfedc1de4d604f14b0f958615776fb80ddb59e33", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.4590163934, "max_line_length": 126, "alphanum_fraction": 0.6619469027, "include": true, "reason": "import numpy,from scipy", "num_tokens": 3233, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.3886180267058489, "lm_q1q2_score": 0.19886229715274964}} {"text": "# This File is for all encoder models\r\nfrom torch import nn\r\nfrom torch.nn import functional as F\r\nimport torch\r\nimport numpy as np\r\n\r\n\r\n# Encoder for AutoEncoder\r\nclass Encoder_AE(nn.Module):\r\n def __init__(self, M, P):\r\n super(Encoder_AE, self).__init__()\r\n self.M = M # The number of RF nodes\r\n self.N = int(M*(M-1)) # The number of links\r\n self.P = P # Each node has P measurement positions\r\n # input size (CxWxH) = (NxPxP)\r\n self.conv1 = self.conv_layer(self.N, 32, 3, padding='same')\r\n self.conv2 = self.conv_layer(32, 64, 3, padding='same')\r\n self.conv3 = self.conv_layer(64, 128, 3, padding='same') # shape: [batch_size, 128, P, P]\r\n self.conv4 = self.conv_layer(128, 128, 3, padding='valid') # shape: [batch_size, 128, P-2, P-2]\r\n self.conv5 = self.conv_layer(128, self.N, 1, padding='valid', activation='Linear',\r\n batch_norm=False) # shape: [batch_size, N, P-2, P-2]\r\n\r\n def conv_layer(self, in_channels, out_channels, kernel_size, stride=1, padding=0, activation='LeakyReLU',\r\n batch_norm=True):\r\n layer_out = []\r\n bias = True\r\n if batch_norm:\r\n bias = False\r\n layer_out.append(nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding, bias=bias))\r\n if batch_norm:\r\n layer_out.append(nn.BatchNorm2d(out_channels, eps=0.001, momentum=0.01))\r\n if activation == 'LeakyReLU':\r\n layer_out.append(nn.LeakyReLU(0.3))\r\n elif activation == 'ReLU':\r\n layer_out.append(nn.ReLU())\r\n elif activation == 'Linear':\r\n pass\r\n elif activation == 'Sigmoid':\r\n layer_out.append(nn.Sigmoid())\r\n else:\r\n raise NotImplementedError('Activation Function {} not understood.'.format(activation))\r\n return nn.Sequential(*layer_out)\r\n\r\n def forward(self, x):\r\n out = self.conv1(x)\r\n out = self.conv2(out)\r\n out = self.conv3(out)\r\n out = self.conv4(out)\r\n out = self.conv5(out)\r\n return out\r\n\r\n\r\n# Encoder for Gaussian VAE\r\nclass Encoder_GVAE(nn.Module):\r\n def __init__(self, M, P):\r\n super(Encoder_GVAE, self).__init__()\r\n self.M = M # The number of RF nodes\r\n self.N = int(M*(M-1)) # The number of links\r\n self.P = P # Each node has P measurement positions\r\n # input size (CxWxH) = (NxPxP)\r\n self.conv1 = self.conv_layer(self.N, 32, 3, padding='same')\r\n self.conv2 = self.conv_layer(32, 64, 3, padding='same')\r\n self.conv3 = self.conv_layer(64, 128, 3, padding='same') # shape: [batch_size, 128, P, P]\r\n self.conv4 = self.conv_layer(128, 128, 3, padding='valid') # shape: [batch_size, 128, P-2, P-2]\r\n self.conv5_mu = self.conv_layer(128, self.N, 1, padding='valid', activation='Linear',\r\n batch_norm=False) # shape: [batch_size, N, P-2, P-2]\r\n self.conv5_logvar = self.conv_layer(128, self.N, 1, padding='valid', activation='Linear',\r\n batch_norm=False) # shape: [batch_size, N, P-2, P-2]\r\n\r\n def conv_layer(self, in_channels, out_channels, kernel_size, stride=1, padding=0, activation='LeakyReLU',\r\n batch_norm=True):\r\n layer_out = []\r\n bias = True\r\n if batch_norm:\r\n bias = False\r\n layer_out.append(nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding, bias=bias))\r\n if batch_norm:\r\n layer_out.append(nn.BatchNorm2d(out_channels, eps=0.001, momentum=0.01))\r\n if activation == 'LeakyReLU':\r\n layer_out.append(nn.LeakyReLU(0.3))\r\n elif activation == 'ReLU':\r\n layer_out.append(nn.ReLU())\r\n elif activation == 'Linear':\r\n pass\r\n elif activation == 'Sigmoid':\r\n layer_out.append(nn.Sigmoid())\r\n else:\r\n raise NotImplementedError('Activation Function {} not understood.'.format(activation))\r\n return nn.Sequential(*layer_out)\r\n\r\n def encode(self, x):\r\n out = self.conv1(x)\r\n out = self.conv2(out)\r\n out = self.conv3(out)\r\n out = self.conv4(out)\r\n mu = self.conv5_mu(out)\r\n logvar = self.conv5_logvar(out)\r\n return mu, logvar\r\n\r\n def reparameterize(self, mu, logvar):\r\n std = torch.exp(0.5 * logvar)\r\n eps = torch.randn_like(std)\r\n return mu + eps * std\r\n\r\n def kl_div(self, mu, logvar):\r\n # KL = 1/2(- logvar + var + m^2 - 1 )\r\n kld = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())\r\n kld = kld/(self.N * (self.P - 2) * (self.P - 2))\r\n return kld\r\n\r\n def forward(self, x):\r\n mu, logvar = self.encode(x)\r\n z = self.reparameterize(mu, logvar)\r\n kld = self.kl_div(mu, logvar)\r\n return z, kld, mu, logvar\r\n\r\n\r\n# Encoder for Laplacian VAE\r\nclass Encoder_LVAE(nn.Module):\r\n def __init__(self, M, P):\r\n super(Encoder_LVAE, self).__init__()\r\n self.M = M # The number of RF nodes\r\n self.N = int(M*(M-1)) # The number of links\r\n self.P = P # Each node has P measurement positions\r\n # input size (CxWxH) = (NxPxP)\r\n self.conv1 = self.conv_layer(self.N, 32, 3, padding='same')\r\n self.conv2 = self.conv_layer(32, 64, 3, padding='same')\r\n self.conv3 = self.conv_layer(64, 128, 3, padding='same') # shape: [batch_size, 128, P, P]\r\n self.conv4 = self.conv_layer(128, 128, 3, padding='valid') # shape: [batch_size, 128, P-2, P-2]\r\n self.conv5_mu = self.conv_layer(128, self.N, 1, padding='valid', activation='Linear',\r\n batch_norm=False) # shape: [batch_size, N, P-2, P-2]\r\n self.conv5_logb = self.conv_layer(128, self.N, 1, padding='valid', activation='Linear',\r\n batch_norm=False) # shape: [batch_size, N, P-2, P-2]\r\n\r\n def conv_layer(self, in_channels, out_channels, kernel_size, stride=1, padding=0, activation='LeakyReLU',\r\n batch_norm=True):\r\n layer_out = []\r\n bias = True\r\n if batch_norm:\r\n bias = False\r\n layer_out.append(nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding, bias=bias))\r\n if batch_norm:\r\n layer_out.append(nn.BatchNorm2d(out_channels, eps=0.001, momentum=0.01))\r\n if activation == 'LeakyReLU':\r\n layer_out.append(nn.LeakyReLU(0.3))\r\n elif activation == 'ReLU':\r\n layer_out.append(nn.ReLU())\r\n elif activation == 'Linear':\r\n pass\r\n elif activation == 'Sigmoid':\r\n layer_out.append(nn.Sigmoid())\r\n else:\r\n raise NotImplementedError('Activation Function {} not understood.'.format(activation))\r\n return nn.Sequential(*layer_out)\r\n\r\n def encode(self, x):\r\n out = self.conv1(x)\r\n out = self.conv2(out)\r\n out = self.conv3(out)\r\n out = self.conv4(out)\r\n mu = self.conv5_mu(out)\r\n logb = self.conv5_logb(out)\r\n return mu, logb\r\n\r\n def reparameterize(self, mu, logb):\r\n eps1 = torch.rand_like(mu)\r\n eps2 = torch.rand_like(mu)\r\n eps = -torch.log(eps1 + 1e-10) - (-torch.log(eps2 + 1e-10))\r\n sample = mu + eps * logb.exp() # Laplace(mu, b)\r\n return sample\r\n\r\n def kl_div(self, mu, logb):\r\n b = logb.exp()\r\n # KL: sqrt(2)*b*exp(-|mu|/b) + sqrt(2)*|mu| - log(b) - log(2)/2 - 1\r\n kld = torch.sum(2 ** 0.5 * b * torch.exp(-mu.abs() / b) + 2 ** 0.5 * mu.abs() - logb - 0.5 * np.log(2) - 1.0)\r\n kld = kld / (self.N * (self.P - 2) * (self.P - 2))\r\n return kld\r\n\r\n def forward(self, x):\r\n mu, logb = self.encode(x)\r\n z = self.reparameterize(mu, logb)\r\n kld = self.kl_div(mu, logb)\r\n return z, kld, mu, logb\r\n\r\n\r\n# Encoder for Gaussian Mixture VAE\r\nclass Encoder_GMVAE(nn.Module):\r\n def __init__(self, M, P):\r\n super(Encoder_GMVAE, self).__init__()\r\n self.M = M # The number of RF nodes\r\n self.N = int(M*(M-1)) # The number of links\r\n self.P = P # Each node has P measurement positions\r\n self.n_classes = 3 # Number of noise levels\r\n # input size (CxWxH) = (NxPxP)\r\n # encode input RSS\r\n self.conv1 = self.conv_layer(self.N, 32, 3, padding='same')\r\n self.conv2 = self.conv_layer(32, 64, 3, padding='same')\r\n self.conv3 = self.conv_layer(64, 128, 3, padding='same') # shape: [batch_size, 128, P, P]\r\n self.conv4 = self.conv_layer(128, 128, 3, padding='valid') # shape: [batch_size, 128, P-2, P-2]\r\n # Generate h, w and c\r\n self.conv5_h_mu = self.conv_layer(128, self.N, 1, padding='valid', activation='Linear',\r\n batch_norm=False) # shape: [batch_size, N, P-2, P-2]\r\n self.conv5_h_logvar = self.conv_layer(128, self.N, 1, padding='valid', activation='Linear',\r\n batch_norm=False) # shape: [batch_size, N, P-2, P-2]\r\n self.conv5_w_mu = self.conv_layer(128, 32, 3, padding='valid', activation='Linear',\r\n batch_norm=False) # shape: [batch_size, 32, P-4, P-4]\r\n self.conv5_w_logvar = self.conv_layer(128, 32, 3, padding='valid', activation='Linear',\r\n batch_norm=False) # shape: [batch_size, 32, P-4, P-4]\r\n self.qc = nn.Linear(128*(self.P-2)*(self.P-2), self.n_classes) # [batch_size, n_classes]\r\n # prior generator\r\n self.deconv1 = self.deconv_layer(32, 16, 3, padding=0) # shape: [batch_size, 16, P-2, P-2]\r\n # prior h for each cluster\r\n self.conv_ph_mu = nn.ModuleList(\r\n [nn.Conv2d(16, self.N, 1, padding='valid', bias=True) for i in range(self.n_classes)]) # shape: [batch_size, N, P-2, P-2]\r\n self.conv_ph_logvar = nn.ModuleList(\r\n [nn.Conv2d(16, self.N, 1, padding='valid', bias=True) for i in range(self.n_classes)]) # shape: [batch_size, N, P-2, P-2]\r\n\r\n def conv_layer(self, in_channels, out_channels, kernel_size, stride=1, padding=0, activation='LeakyReLU',\r\n batch_norm=True):\r\n layer_out = []\r\n bias = True\r\n if batch_norm:\r\n bias = False\r\n layer_out.append(nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding, bias=bias))\r\n if batch_norm:\r\n layer_out.append(nn.BatchNorm2d(out_channels, eps=0.001, momentum=0.01))\r\n if activation == 'LeakyReLU':\r\n layer_out.append(nn.LeakyReLU(0.3))\r\n elif activation == 'ReLU':\r\n layer_out.append(nn.ReLU())\r\n elif activation == 'Linear':\r\n pass\r\n elif activation == 'Sigmoid':\r\n layer_out.append(nn.Sigmoid())\r\n else:\r\n raise NotImplementedError('Activation Function {} not understood.'.format(activation))\r\n return nn.Sequential(*layer_out)\r\n\r\n def deconv_layer(self, in_channels, out_channels, kernel_size, stride=1, padding=0, activation='LeakyReLU',\r\n batch_norm=True):\r\n layer_out = []\r\n bias = True\r\n if batch_norm:\r\n bias = False\r\n layer_out.append(nn.ConvTranspose2d(in_channels, out_channels, kernel_size, stride, padding, bias=bias))\r\n if batch_norm:\r\n layer_out.append(nn.BatchNorm2d(out_channels, eps=0.001, momentum=0.01))\r\n if activation == 'LeakyReLU':\r\n layer_out.append(nn.LeakyReLU(0.3))\r\n elif activation == 'ReLU':\r\n layer_out.append(nn.ReLU())\r\n elif activation == 'Linear':\r\n pass\r\n elif activation == 'Sigmoid':\r\n layer_out.append(nn.Sigmoid())\r\n else:\r\n raise NotImplementedError('Activation Function {} not understood.'.format(activation))\r\n return nn.Sequential(*layer_out)\r\n\r\n def encode1(self, x):\r\n out = self.conv1(x)\r\n out = self.conv2(out)\r\n out = self.conv3(out)\r\n out = self.conv4(out)\r\n return out\r\n\r\n def infer_h(self, x):\r\n h_mu = self.conv5_h_mu(x)\r\n h_logvar = self.conv5_h_logvar(x)\r\n return h_mu, h_logvar\r\n\r\n def infer_w(self, x):\r\n w_mu = self.conv5_w_mu(x)\r\n w_logvar = self.conv5_w_logvar(x)\r\n return w_mu, w_logvar\r\n\r\n def infer_c(self, x):\r\n x = torch.flatten(x, start_dim=1)\r\n qc = F.softmax(self.qc(x), dim=-1)\r\n return qc\r\n\r\n def q_net(self, x):\r\n out = self.encode1(x)\r\n h_mu, h_logvar = self.infer_h(out)\r\n w_mu, w_logvar = self.infer_w(out)\r\n qc = self.infer_c(out)\r\n return h_mu, h_logvar, w_mu, w_logvar, qc\r\n\r\n def reparameterize(self, mu, logvar):\r\n std = torch.exp(0.5 * logvar)\r\n eps = torch.randn_like(std)\r\n return mu + eps * std\r\n\r\n def priorGenerator(self, w_sample):\r\n # w_sample: [batch_size, 32, P-4, P-4]\r\n batchSize = w_sample.size(0)\r\n h = self.deconv1(w_sample)\r\n ph_mu = torch.empty((batchSize, self.N, self.P-2, self.P-2, self.n_classes), device=w_sample.get_device(), requires_grad=False)\r\n ph_logvar = torch.empty((batchSize, self.N, self.P-2, self.P-2, self.n_classes), device=w_sample.get_device(), requires_grad=False)\r\n for i in range(self.n_classes):\r\n ph_mu[:, :, :, :, i] = self.conv_ph_mu[i](h)\r\n ph_logvar[:, :, :, :, i] = self.conv_ph_logvar[i](h)\r\n return ph_mu, ph_logvar\r\n\r\n def kl_w_loss(self, w_mu, w_logvar):\r\n # w_mu, w_logvar: [batch_size, 32, P-4, P-4]\r\n # KL = 1/2(- logvar + var + m^2 - 1 )\r\n kl = -0.5 * torch.sum(1 + w_logvar - w_mu.pow(2) - w_logvar.exp())/(32 * (self.P-4) * (self.P-4))\r\n return kl\r\n\r\n def kl_c_loss(self, prob_c):\r\n # prob_c [batch_size, n_classes]\r\n kl = torch.sum(prob_c * (torch.log(self.n_classes * prob_c + 1e-10)))\r\n kl = torch.max(kl, torch.as_tensor(0.5, device=prob_c.get_device()))\r\n return kl\r\n\r\n def kl_h_loss(self, h_mu, h_logvar, ph_mu, ph_logvar, prob_c):\r\n # h_mu, h_logvar: [batch_size, N, P-2, P-2]\r\n # ph_mu, ph_logvar: [batch_size, N, P-2, P-2, n_classes]\r\n # prob_c: [batch_size, n_classes]\r\n h_mu = h_mu.unsqueeze(-1)\r\n h_mu = h_mu.expand(-1, self.N, self.P-2, self.P-2, self.n_classes)\r\n h_logvar = h_logvar.unsqueeze(-1)\r\n h_logvar = h_logvar.expand(-1, self.N, self.P-2, self.P-2, self.n_classes)\r\n # KL = 1/2 * (logvar2 - logvar1 + (var1 + (m1-m2)^2)/var2 - 1)\r\n # KL(h||ph)\r\n # shape: [batch_size, N, P-2, P-2, n_classes]\r\n KLD_QX_PX = 0.5 * (ph_logvar - h_logvar + (h_logvar.exp() + (h_mu - ph_mu).pow(2)) / ph_logvar.exp() - 1)\r\n # shape: [batch_size, n_classes]\r\n KLD_QX_PX = torch.sum(KLD_QX_PX, dim=(1, 2, 3))\r\n kl = torch.sum(KLD_QX_PX * prob_c)/(self.N * (self.P-2) * (self.P-2))\r\n return kl\r\n\r\n def forward(self, x):\r\n h_mu, h_logvar, w_mu, w_logvar, prob_c = self.q_net(x)\r\n h_sample = self.reparameterize(h_mu, h_logvar) # h_sample: [batch_size, N, P-2, P-2]\r\n w_sample = self.reparameterize(w_mu, w_logvar) # w_sample: [batch_size, 32, P-4, P-4]\r\n ph_mu, ph_logvar = self.priorGenerator(w_sample) # ph_mu, ph_logvar: [batch_size, N, P-2, P-2, n_classes]\r\n kl_loss_w = self.kl_w_loss(w_mu, w_logvar)\r\n kl_loss_c = self.kl_c_loss(prob_c)\r\n kl_loss_h = self.kl_h_loss(h_mu, h_logvar, ph_mu, ph_logvar, prob_c)\r\n kld = kl_loss_w + kl_loss_c + kl_loss_h\r\n return h_sample, kld, kl_loss_w, kl_loss_h, kl_loss_c\r\n\r\n\r\n# Encoder for Laplacian Mixture VAE\r\nclass Encoder_LMVAE(nn.Module):\r\n def __init__(self, M, P):\r\n super(Encoder_LMVAE, self).__init__()\r\n self.M = M # The number of RF nodes\r\n self.N = int(M*(M-1)) # The number of links\r\n self.P = P # Each node has P measurement positions\r\n self.n_classes = 3 # Number of noise levels\r\n # input size (CxWxH) = (NxPxP)\r\n # encode input RSS\r\n self.conv1 = self.conv_layer(self.N, 32, 3, padding='same')\r\n self.conv2 = self.conv_layer(32, 64, 3, padding='same')\r\n self.conv3 = self.conv_layer(64, 128, 3, padding='same') # shape: [batch_size, 128, P, P]\r\n self.conv4 = self.conv_layer(128, 128, 3, padding='valid') # shape: [batch_size, 128, P-2, P-2]\r\n # Generate h, w and c\r\n self.conv5_h_mu = self.conv_layer(128, self.N, 1, padding='valid', activation='Linear',\r\n batch_norm=False) # shape: [batch_size, N, P-2, P-2]\r\n self.conv5_h_logb = self.conv_layer(128, self.N, 1, padding='valid', activation='Linear',\r\n batch_norm=False) # shape: [batch_size, N, P-2, P-2]\r\n self.conv5_w_mu = self.conv_layer(128, 32, 3, padding='valid', activation='Linear',\r\n batch_norm=False) # shape: [batch_size, 32, P-4, P-4]\r\n self.conv5_w_logb = self.conv_layer(128, 32, 3, padding='valid', activation='Linear',\r\n batch_norm=False) # shape: [batch_size, 32, P-4, P-4]\r\n self.qc = nn.Linear(128*(self.P-2)*(self.P-2), self.n_classes) # [batch_size, n_classes]\r\n # prior generator\r\n self.deconv1 = self.deconv_layer(32, 16, 3, padding=0) # shape: [batch_size, 16, P-2, P-2]\r\n # prior h for each cluster\r\n self.conv_ph_mu = nn.ModuleList(\r\n [nn.Conv2d(16, self.N, 1, padding='valid', bias=True) for i in range(self.n_classes)]) # shape: [batch_size, N, P-2, P-2]\r\n self.conv_ph_logb = nn.ModuleList(\r\n [nn.Conv2d(16, self.N, 1, padding='valid', bias=True) for i in range(self.n_classes)]) # shape: [batch_size, N, P-2, P-2]\r\n\r\n def conv_layer(self, in_channels, out_channels, kernel_size, stride=1, padding=0, activation='LeakyReLU',\r\n batch_norm=True):\r\n layer_out = []\r\n bias = True\r\n if batch_norm:\r\n bias = False\r\n layer_out.append(nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding, bias=bias))\r\n if batch_norm:\r\n layer_out.append(nn.BatchNorm2d(out_channels, eps=0.001, momentum=0.01))\r\n if activation == 'LeakyReLU':\r\n layer_out.append(nn.LeakyReLU(0.3))\r\n elif activation == 'ReLU':\r\n layer_out.append(nn.ReLU())\r\n elif activation == 'Linear':\r\n pass\r\n elif activation == 'Sigmoid':\r\n layer_out.append(nn.Sigmoid())\r\n else:\r\n raise NotImplementedError('Activation Function {} not understood.'.format(activation))\r\n return nn.Sequential(*layer_out)\r\n\r\n def deconv_layer(self, in_channels, out_channels, kernel_size, stride=1, padding=0, activation='LeakyReLU',\r\n batch_norm=True):\r\n layer_out = []\r\n bias = True\r\n if batch_norm:\r\n bias = False\r\n layer_out.append(nn.ConvTranspose2d(in_channels, out_channels, kernel_size, stride, padding, bias=bias))\r\n if batch_norm:\r\n layer_out.append(nn.BatchNorm2d(out_channels, eps=0.001, momentum=0.01))\r\n if activation == 'LeakyReLU':\r\n layer_out.append(nn.LeakyReLU(0.3))\r\n elif activation == 'ReLU':\r\n layer_out.append(nn.ReLU())\r\n elif activation == 'Linear':\r\n pass\r\n elif activation == 'Sigmoid':\r\n layer_out.append(nn.Sigmoid())\r\n else:\r\n raise NotImplementedError('Activation Function {} not understood.'.format(activation))\r\n return nn.Sequential(*layer_out)\r\n\r\n def encode1(self, x):\r\n out = self.conv1(x)\r\n out = self.conv2(out)\r\n out = self.conv3(out)\r\n out = self.conv4(out)\r\n return out\r\n\r\n def infer_h(self, x):\r\n h_mu = self.conv5_h_mu(x)\r\n h_logb = self.conv5_h_logb(x)\r\n return h_mu, h_logb\r\n\r\n def infer_w(self, x):\r\n w_mu = self.conv5_w_mu(x)\r\n w_logb = self.conv5_w_logb(x)\r\n return w_mu, w_logb\r\n\r\n def infer_c(self, x):\r\n x = torch.flatten(x, start_dim=1)\r\n qc = F.softmax(self.qc(x), dim=-1)\r\n return qc\r\n\r\n def q_net(self, x):\r\n out = self.encode1(x)\r\n h_mu, h_logb = self.infer_h(out)\r\n w_mu, w_logb = self.infer_w(out)\r\n qc = self.infer_c(out)\r\n return h_mu, h_logb, w_mu, w_logb, qc\r\n\r\n def reparameterize(self, mu, logb):\r\n eps1 = torch.rand_like(mu)\r\n eps2 = torch.rand_like(mu)\r\n eps = -torch.log(eps1 + 1e-10) - (-torch.log(eps2 + 1e-10))\r\n sample = mu + eps * logb.exp() # Laplace(mu, b)\r\n return sample\r\n\r\n def priorGenerator(self, w_sample):\r\n # w_sample: [batch_size, 32, P-4, P-4]\r\n batchSize = w_sample.size(0)\r\n h = self.deconv1(w_sample)\r\n ph_mu = torch.empty((batchSize, self.N, self.P-2, self.P-2, self.n_classes), device=w_sample.get_device(), requires_grad=False)\r\n ph_logb = torch.empty((batchSize, self.N, self.P-2, self.P-2, self.n_classes), device=w_sample.get_device(), requires_grad=False)\r\n for i in range(self.n_classes):\r\n ph_mu[:, :, :, :, i] = self.conv_ph_mu[i](h)\r\n ph_logb[:, :, :, :, i] = self.conv_ph_logb[i](h)\r\n return ph_mu, ph_logb\r\n\r\n def kl_w_loss(self, w_mu, w_logb):\r\n b = w_logb.exp()\r\n logb = w_logb\r\n mu = w_mu\r\n # KL: sqrt(2)*b*exp(-|mu|/b) + sqrt(2)*|mu| - log(b) - log(2)/2 - 1\r\n kl = torch.sum(2 ** 0.5 * b * torch.exp(-mu.abs() / b) + 2 ** 0.5 * mu.abs() - logb - 0.5 * np.log(2) - 1.0)/(32 * (self.P-4) * (self.P-4))\r\n return kl\r\n\r\n def kl_c_loss(self, prob_c):\r\n # prob_c [batch_size, n_classes]\r\n kl = torch.sum(prob_c * (torch.log(self.n_classes * prob_c + 1e-10)))\r\n kl = torch.max(kl, torch.as_tensor(0.5, device=prob_c.get_device()))\r\n return kl\r\n\r\n def kl_h_loss(self, h_mu, h_logb, ph_mu, ph_logb, prob_c):\r\n # h_mu, h_logb: [batch_size, N, P-2, P-2]\r\n # ph_mu, ph_logb: [batch_size, N, P-2, P-2, n_classes]\r\n # prob_c: [batch_size, n_classes]\r\n h_mu = h_mu.unsqueeze(-1)\r\n h_mu = h_mu.expand(-1, self.N, self.P-2, self.P-2, self.n_classes)\r\n h_logb = h_logb.unsqueeze(-1)\r\n h_logb = h_logb.expand(-1, self.N, self.P-2, self.P-2, self.n_classes)\r\n mu1 = h_mu\r\n mu2 = ph_mu\r\n b1 = h_logb.exp()\r\n b2 = ph_logb.exp()\r\n logb1 = h_logb\r\n logb2 = ph_logb\r\n # KL: (b1*exp(-|mu1-mu2|/b1)+|mu1-mu2|)/b2 + log(b2/b1) - 1\r\n # KL(h||ph)\r\n # shape: [batch_size, N, P-2, P-2, n_classes]\r\n KLD_QX_PX = (b1 * torch.exp(-torch.abs(mu1 - mu2) / b1) + torch.abs(mu1 - mu2)) / b2 + logb2 - logb1 - 1.0\r\n KLD_QX_PX = torch.sum(KLD_QX_PX, dim=(1, 2, 3))\r\n kl = torch.sum(KLD_QX_PX * prob_c)/(self.N * (self.P-2) * (self.P-2))\r\n return kl\r\n\r\n def forward(self, x):\r\n h_mu, h_logb, w_mu, w_logb, prob_c = self.q_net(x)\r\n h_sample = self.reparameterize(h_mu, h_logb) # h_sample: [batch_size, N, P-2, P-2]\r\n w_sample = self.reparameterize(w_mu, w_logb) # w_sample: [batch_size, 32, P-4, P-4]\r\n ph_mu, ph_logb = self.priorGenerator(w_sample) # ph_mu, ph_logb: [batch_size, N, P-2, P-2, n_classes]\r\n kl_loss_w = self.kl_w_loss(w_mu, w_logb)\r\n kl_loss_c = self.kl_c_loss(prob_c)\r\n kl_loss_h = self.kl_h_loss(h_mu, h_logb, ph_mu, ph_logb, prob_c)\r\n kld = kl_loss_w + kl_loss_c + kl_loss_h\r\n return h_sample, kld, kl_loss_w, kl_loss_h, kl_loss_c\r\n", "meta": {"hexsha": "68b9fd1e8ac07f0d9692ff11d85caecde7025412", "size": 23817, "ext": "py", "lang": "Python", "max_stars_repo_path": "Multi-task AE/model/Encoder.py", "max_stars_repo_name": "ZiyHe/SLF_Estimate", "max_stars_repo_head_hexsha": "9ff2ed6d7de2ca63455e31db0adf0b8daf68606a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Multi-task AE/model/Encoder.py", "max_issues_repo_name": "ZiyHe/SLF_Estimate", "max_issues_repo_head_hexsha": "9ff2ed6d7de2ca63455e31db0adf0b8daf68606a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Multi-task AE/model/Encoder.py", "max_forks_repo_name": "ZiyHe/SLF_Estimate", "max_forks_repo_head_hexsha": "9ff2ed6d7de2ca63455e31db0adf0b8daf68606a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 46.4269005848, "max_line_length": 148, "alphanum_fraction": 0.567031952, "include": true, "reason": "import numpy", "num_tokens": 6838, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041652, "lm_q2_score": 0.38861802670584894, "lm_q1q2_score": 0.19886229715274964}} {"text": "#This software is a free software. Thus, it is licensed under GNU General Public License.\n#Python implementation to Smith-Waterman Algorithm for Homework 1 of Bioinformatics class.\n#Forrest Bao, Sept. 26 \n\nimport sys, string\nfrom numpy import *\n\ndef readFasta(infile):\n saved = None\n while 1:\n if saved is not None:\n line = saved\n saved = None\n else:\n line = infile.readline()\n if not line:\n return\n if line.isspace():\n continue\n if not line.startswith(\">\"):\n raise TypeError(\n \"The title line must start with a '>': %r\" % line) \n title = line.rstrip()\n sequences = []\n while 1:\n line = infile.readline()\n if not line or line.isspace():\n break\n if line.startswith(\">\"):\n saved = line\n break\n sequences.append(line.rstrip(\"\\n\")) \n yield \"\".join(sequences) \n infile.close()\n \n \n \ndef getFmax(score,m,n):\n Fmax = 0\n position = (0,0)\n m = m -1\n n = n -1 \n for i in xrange(1,n):\n if(score[i][m] > Fmax):\n Fmax = score[i][m] \n position = (i,m)\n for j in xrange(1,m):\n if(score[n][j] > Fmax):\n Fmax = score[n][j]\n position = (n,j)\n return position\n\n#read the first sequence\nf1=open(sys.argv[1], 'r')\nseq1=readFasta(f1).next()\n\n#read the second sequence\nf2=open(sys.argv[2], 'r')\nseq2=readFasta(f2).next()\n\n\nm,n = len(seq1)+1,len(seq2)+1 #length of two sequences\n\npenalty=-4; #define the gap penalty\n\n#generate DP table and traceback path pointer matrix\nscore=zeros((m+1,n+1)) #the DP table\npointer=zeros((m+1,n+1)) #to store the traceback path\n\n#score = [0]*m\n#for i in range(n):\n# score[i] = [0] * n\n#pointer = [0]*m\n#for i in range(n):\n# pointer[i] = [0] * n\n \nP=0;\n\ndef match_score(alpha,beta): #the function to find match/dismatch score from BLOSUM62 by letters of AAs\n if(alpha==beta):\n return 2\n else:\n return -1\n\nmax_score=P; #initial maximum score in DP table\n\n#calculate DP table and mark pointers\nfor i in range(1,m):\n for j in range(1,n):\n score_up=score[i-1][j]+penalty;\n score_down=score[i][j-1]+penalty;\n score_diagonal=score[i-1][j-1]+match_score(seq1[i-1],seq2[j-1]);\n #score[i][j]=max(0,score_up,score_down,score_diagonal);\n score[i][j]=max(score_up,score_down,score_diagonal);\n if score[i][j]==0:\n pointer[i][j]=0; #0 means end of the path\n if score[i][j]==score_up:\n pointer[i][j]=1; #1 means trace up\n if score[i][j]==score_down:\n pointer[i][j]=2; #2 means trace left\n if score[i][j]==score_diagonal:\n pointer[i][j]=3; #3 means trace diagonal\n if score[i][j]>=max_score:\n max_i=i;\n max_j=j;\n max_score=score[i][j];\n#END of DP table\n\n\nalign1,align2='',''; #initial sequences\n\ni,j=max_i,max_j; #indices of path starting point\n\n#traceback, follow pointers\nwhile pointer[i][j]!=0:\n\n if pointer[i][j]==3:\n align1=align1+seq1[i-1];\n align2=align2+seq2[j-1];\n i=i-1;\n j=j-1;\n elif pointer[i][j]==2:\n align1=align1+'-';\n align2=align2+seq2[j-1];\n j=j-1;\n elif pointer[i][j]==1:\n align1=align1+seq1[i-1];\n align2=align2+'-';\n i=i-1;\n#END of traceback\n\nalign1=align1[::-1]; #reverse sequence 1\nalign2=align2[::-1]; #reverse sequence 2\n\n\nprint \"Length1: \" + str(len(align1)) + \" Length2: \" + str(len(align2)) \nprint align1\nprint align2 \n\n\n\n", "meta": {"hexsha": "8e1098fc368bb4dd65c4a9b748faddfd489f38d9", "size": 3776, "ext": "py", "lang": "Python", "max_stars_repo_path": "AB1/src/pp.py", "max_stars_repo_name": "jfnavarro/old_python_courses", "max_stars_repo_head_hexsha": "fb500e8eeae6c5d10bf77e1ff52725627527222a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-02-20T03:26:35.000Z", "max_stars_repo_stars_event_max_datetime": "2018-02-20T03:26:35.000Z", "max_issues_repo_path": "AB1/src/pp.py", "max_issues_repo_name": "jfnavarro/BioInfo_ML_courses", "max_issues_repo_head_hexsha": "fb500e8eeae6c5d10bf77e1ff52725627527222a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "AB1/src/pp.py", "max_forks_repo_name": "jfnavarro/BioInfo_ML_courses", "max_forks_repo_head_hexsha": "fb500e8eeae6c5d10bf77e1ff52725627527222a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.5915492958, "max_line_length": 106, "alphanum_fraction": 0.5487288136, "include": true, "reason": "from numpy", "num_tokens": 1079, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6261241632752915, "lm_q2_score": 0.31742625913050115, "lm_q1q2_score": 0.1987482508996909}} {"text": "# Licensed to the Apache Software Foundation (ASF) under one\n# or more contributor license agreements. See the NOTICE file\n# distributed with this work for additional information\n# regarding copyright ownership. The ASF licenses this file\n# to you under the Apache License, Version 2.0 (the\n# \"License\"); you may not use this file except in compliance\n# with the License. You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing,\n# software distributed under the License is distributed on an\n# \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n# KIND, either express or implied. See the License for the\n# specific language governing permissions and limitations\n# under the License.\n\"\"\"Quantization module for generating quantized (INT8) models from FP32 models.\"\"\"\n\nimport abc\nimport ctypes\nimport logging\nimport os\nimport warnings\nimport numpy as np\nimport mxnet as mx\nfrom ..base import _LIB, check_call, py_str\nfrom ..base import c_array, c_str, mx_uint, mx_real_t, c_str_array\nfrom ..base import SymbolHandle\nfrom ..symbol import Symbol\nfrom .. import ndarray\nfrom ..io import DataDesc\nfrom ..device import cpu, Device\nfrom ..util import is_np_array, wrap_ctx_to_device_func\n\n\ndef _quantize_params(qsym, params, min_max_dict):\n \"\"\"Given a quantized symbol and a dict of params that have not been quantized,\n generate quantized params. Currently only supports quantizing the arg_params\n with names of `weight` or `bias`, not aux_params. If `qsym` contains symbols\n that are excluded from being quantized, their corresponding params will\n not be quantized, but saved together with quantized params of the symbols that\n have been quantized.\n\n Parameters\n ----------\n qsym : Symbol\n Quantized symbol from FP32 symbol.\n params : dict of str->NDArray\n min_max_dict: dict of min/max pairs of layers' output\n \"\"\"\n inputs_name = qsym.list_arguments()\n quantized_params = {}\n if is_np_array():\n quantize_fn = mx.npx.contrib_quantize\n min_fn = lambda arr: mx.np.array([mx.np.min(arr)])\n max_fn = lambda arr: mx.np.array([mx.np.max(arr)])\n array_cls = mx.np\n else:\n quantize_fn = mx.nd.contrib.quantize\n min_fn = mx.nd.min\n max_fn = mx.nd.max\n array_cls = mx.nd\n\n for name in inputs_name:\n if name.endswith(('weight_quantize', 'bias_quantize')):\n original_name = name[:-len('_quantize')]\n param = params[original_name]\n # pylint: disable=unbalanced-tuple-unpacking\n param_min = min_fn(param)\n param_max = max_fn(param)\n val, vmin, vmax = quantize_fn(data=param,\n min_range=param_min,\n max_range=param_max,\n out_type='int8')\n quantized_params[name] = val\n quantized_params[name+'_min'] = vmin\n quantized_params[name+'_max'] = vmax\n elif name in params:\n quantized_params[name] = params[name]\n elif name.endswith(('_min')):\n output = name[: - len('_min')]\n if output in min_max_dict:\n quantized_params[name] = array_cls.array([min_max_dict[output][0]])\n elif name.endswith(('_max')):\n output = name[: - len('_min')]\n if output in min_max_dict:\n quantized_params[name] = array_cls.array([min_max_dict[output][1]])\n return quantized_params\n\n\ndef _quantize_symbol(sym, device, excluded_symbols=None, excluded_operators=None,\n offline_params=None, quantized_dtype='int8', quantize_mode='smart',\n quantize_granularity='tensor-wise'):\n \"\"\"Given a symbol object representing a neural network of data type FP32,\n quantize it into a INT8 network.\n\n Parameters\n ----------\n sym : Symbol\n FP32 neural network symbol.\n device : Device\n Defines the device that users want to run quantized symbol.\n excluded_symbols : list of strings\n A list of strings representing the names of the symbols that users want to excluding\n from being quantized.\n excluded_operators : list of strings\n A list of strings representing the names of the operators that users want to excluding\n from being quantized.\n offline_params : list of strs\n Names of the parameters that users want to quantize offline. It's always recommended to\n quantize parameters offline so that quantizing parameters during the inference can be\n avoided.\n quantized_dtype: str\n The quantized destination type for input data.\n quantize_mode: str\n The mode that quantization pass to apply.\n quantize_granularity: str\n The granularity of quantization, currently supports 'tensor-wise' and 'channel-wise'\n quantization. The default value is 'tensor-wise'.\n \"\"\"\n num_excluded_symbols = 0\n if excluded_symbols is not None:\n assert isinstance(excluded_symbols, list)\n num_excluded_symbols = len(excluded_symbols)\n else:\n excluded_symbols = []\n\n num_excluded_ops = 0\n if excluded_operators is not None:\n assert isinstance(excluded_operators, list)\n num_excluded_ops = len(excluded_operators)\n else:\n excluded_operators = []\n\n num_offline = 0\n offline = []\n if offline_params is not None:\n num_offline = len(offline_params)\n for k in offline_params:\n offline.append(c_str(k))\n\n out = SymbolHandle()\n size = mx_uint()\n calib_str = ctypes.POINTER(ctypes.c_char_p)()\n check_call(_LIB.MXQuantizeSymbol(sym.handle,\n ctypes.byref(out),\n ctypes.byref(ctypes.c_int(device.device_typeid)),\n mx_uint(num_excluded_symbols),\n c_str_array(excluded_symbols),\n mx_uint(num_excluded_ops),\n c_str_array(excluded_operators),\n mx_uint(num_offline),\n c_array(ctypes.c_char_p, offline),\n c_str(quantized_dtype),\n ctypes.c_bool(True),\n c_str(quantize_mode),\n c_str(quantize_granularity),\n ctypes.byref(size),\n ctypes.byref(calib_str)))\n calib_layers = []\n calib_layers = [py_str(calib_str[i]) for i in range(size.value)]\n return Symbol(out), calib_layers\n\n\nclass CalibrationCollector(object):\n \"\"\"Base class for all other collectors used with quantization\"\"\"\n __metaclass__ = abc.ABCMeta\n\n def __init__(self):\n self.include_layers = None\n self.min_max_dict = {}\n\n @abc.abstractmethod\n def collect(self, name, op_name, arr):\n \"\"\"Function which is registered to Block as monitor callback. Names of layers\n requiring calibration are stored in `self.include_layers` variable.\n Parameters\n ----------\n name : str\n Node name from which collected data comes from\n op_name : str\n Operator name from which collected data comes from. Single operator\n can have multiple inputs/ouputs nodes - each should have different name\n arr : NDArray\n NDArray containing data of monitored node\n \"\"\"\n\n def post_collect(self):\n \"\"\" Function called after collecting parameters. Returns dictionary of min and max values\n for each calibrated layer. If not overriden, returns content of `self.min_max_dict`.\n \"\"\"\n return self.min_max_dict\n\n\nclass _LayerHistogramCollector(CalibrationCollector):\n \"\"\"Saves layer histogram in a dict with layer names as keys and lists of NDArrays as\n values. The collected histogram will be used for calculating the optimal thresholds for\n quantization using KL divergence.\n \"\"\"\n def __init__(self, quantized_dtype, num_bins=8001, include_layers=None, logger=None):\n super(_LayerHistogramCollector, self).__init__()\n self.hist_dict = {}\n self.num_bins = num_bins\n self.include_layers = include_layers\n self.logger = logger\n self.quantized_dtype = quantized_dtype\n\n def collect(self, name, op_name, arr):\n \"\"\"Callback function for collecting layer output NDArrays.\"\"\"\n if name not in self.include_layers:\n return\n arr = arr.copyto(cpu()).asnumpy()\n if self.logger:\n self.logger.debug(\"Collecting layer %s histogram of shape %s\" % (name, arr.shape))\n min_range = np.min(arr)\n max_range = np.max(arr)\n th = max(abs(min_range), abs(max_range))\n if name in self.hist_dict:\n self.hist_dict[name] = self.combine_histogram(self.hist_dict[name], arr, min_range, max_range, th)\n else:\n hist, hist_edges = np.histogram(arr, bins=self.num_bins, range=(-th, th))\n self.hist_dict[name] = (hist, hist_edges, min_range, max_range, th)\n\n def post_collect(self):\n min_max_dict = self.get_optimal_thresholds(self.hist_dict, self.quantized_dtype, logger=self.logger)\n return min_max_dict\n\n @staticmethod\n def combine_histogram(old_hist, arr, new_min, new_max, new_th):\n \"\"\" Collect layer histogram for arr and combine it with old histogram.\n \"\"\"\n (old_hist, old_hist_edges, old_min, old_max, old_th) = old_hist\n if new_th <= old_th:\n hist, _ = np.histogram(arr, bins=len(old_hist), range=(-old_th, old_th))\n return (old_hist + hist, old_hist_edges, min(old_min, new_min), max(old_max, new_max), old_th)\n else:\n # Need to generate new histogram with new_th\n old_num_bins = len(old_hist)\n old_step = 2 * old_th / old_num_bins\n half_increased_bins = int((new_th - old_th) // old_step + 1)\n new_num_bins = half_increased_bins * 2 + old_num_bins\n new_th = half_increased_bins * old_step + old_th\n hist, hist_edges = np.histogram(arr, bins=new_num_bins, range=(-new_th, new_th))\n hist[half_increased_bins:new_num_bins - half_increased_bins] += old_hist\n return (hist, hist_edges, min(old_min, new_min), max(old_max, new_max), new_th)\n\n # pylint: disable=line-too-long\n @staticmethod\n def get_optimal_threshold(hist_data, quantized_dtype, num_quantized_bins=255):\n \"\"\"Given a dataset, find the optimal threshold for quantizing it.\n The reference distribution is `q`, and the candidate distribution is `p`.\n `q` is a truncated version of the original distribution.\n\n Ref: http://on-demand.gputechconf.com/gtc/2017/presentation/s7310-8-bit-inference-with-tensorrt.pdf\n \"\"\"\n (hist, hist_edges, min_val, max_val, _) = hist_data\n num_bins = len(hist)\n assert (num_bins % 2 == 1)\n if min_val >= 0 and quantized_dtype in ['auto', 'uint8']:\n # We need to move negative bins to positive bins to fit uint8 range.\n num_quantized_bins = num_quantized_bins * 2 + 1\n hist = ndarray.array(hist, ctx=cpu())\n hist_edges = ndarray.array(hist_edges, ctx=cpu())\n threshold, divergence = ndarray.contrib.calibrate_entropy(hist=hist,\n hist_edges=hist_edges,\n num_quantized_bins=num_quantized_bins)\n threshold = threshold.asnumpy()\n divergence = divergence.asnumpy()\n return min_val, max_val, threshold, divergence\n # pylint: enable=line-too-long\n\n @staticmethod\n def get_optimal_thresholds(hist_dict, quantized_dtype, num_quantized_bins=255, logger=None):\n \"\"\"Given a ndarray dict, find the optimal threshold for quantizing each value of the key.\"\"\"\n assert isinstance(hist_dict, dict)\n if logger is not None:\n logger.info('Calculating optimal thresholds for quantization using KL divergence'\n ' with num_quantized_bins=%d' % num_quantized_bins)\n th_dict = {}\n # copy hist_dict keys since the keys() only returns a view in python3\n layer_names = list(hist_dict.keys())\n for name in layer_names:\n assert name in hist_dict\n min_val, max_val, th, divergence = \\\n _LayerHistogramCollector.get_optimal_threshold(hist_dict[name], quantized_dtype,\n num_quantized_bins=num_quantized_bins)\n if min_val >= 0 and quantized_dtype in ['auto', 'uint8']:\n th_dict[name] = (0, th)\n else:\n th_dict[name] = (-th, th)\n del hist_dict[name] # release the memory\n if logger:\n logger.debug(f\"layer={name}, min_val={min_val}, max_val={max_val}, th={th}, divergence={divergence}\")\n return th_dict\n\n\nclass _LayerOutputMinMaxCollector(CalibrationCollector):\n \"\"\"Saves layer output min and max values in a dict with layer names as keys.\n The collected min and max values will be directly used as thresholds for quantization.\n \"\"\"\n def __init__(self, quantized_dtype, include_layers=None, logger=None):\n super(_LayerOutputMinMaxCollector, self).__init__()\n self.min_max_dict = {}\n self.quantized_dtype = quantized_dtype\n self.include_layers = include_layers\n self.logger = logger\n\n def collect(self, name, op_name, arr):\n \"\"\"Callback function for collecting min and max values from an NDArray.\"\"\"\n if name not in self.include_layers:\n return\n arr = arr.copyto(cpu()).asnumpy()\n min_range = np.min(arr)\n max_range = np.max(arr)\n if name in self.min_max_dict:\n cur_min_max = self.min_max_dict[name]\n self.min_max_dict[name] = (min(cur_min_max[0], min_range),\n max(cur_min_max[1], max_range))\n else:\n self.min_max_dict[name] = (min_range, max_range)\n if self.logger:\n self.logger.debug(\"Collecting layer %s min_range=%f, max_range=%f\"\n % (name, min_range, max_range))\n\n\ndef _calibrate_quantized_sym(qsym, min_max_dict):\n \"\"\"Given a dictionary containing the thresholds for quantizing the layers,\n set the thresholds into the quantized symbol as the params of requantize operators.\n \"\"\"\n if min_max_dict is None or len(min_max_dict) == 0:\n return qsym\n num_layer_outputs = len(min_max_dict)\n layer_output_names = []\n min_vals = []\n max_vals = []\n for k, v in min_max_dict.items():\n layer_output_names.append(k)\n min_vals.append(v[0])\n max_vals.append(v[1])\n\n calibrated_sym = SymbolHandle()\n check_call(_LIB.MXSetCalibTableToQuantizedSymbol(qsym.handle,\n mx_uint(num_layer_outputs),\n c_str_array(layer_output_names),\n c_array(ctypes.c_float, min_vals),\n c_array(ctypes.c_float, max_vals),\n ctypes.byref(calibrated_sym)))\n return Symbol(calibrated_sym)\n\n\ndef _collect_layer_statistics(sym_block, data, collector, num_inputs, num_calib_batches=None, logger=None):\n if not isinstance(data, mx.gluon.data.DataLoader):\n raise ValueError('Only supports data as a type of DataLoader, while received type %s'\n % str(type(data)))\n sym_block.register_op_hook(collector.collect, monitor_all=True)\n num_batches = 0\n for batch in data:\n if not isinstance(batch, list):\n batch = [batch]\n batch = [b.as_in_context(mx.cpu()) for b in batch]\n sym_block(*batch[:num_inputs])\n num_batches += 1\n if num_calib_batches is not None and num_batches >= num_calib_batches:\n break\n if logger is not None:\n logger.info(\"Collected statistics from %d batches\" % (num_batches))\n return num_batches\n\n\ndef _generate_list_of_data_desc(data_shapes, data_types):\n \"\"\"\"Convert list ot tuples to list of DataDesc.\"\"\"\n if isinstance(data_shapes, list):\n if all(isinstance(x, DataDesc) for x in data_shapes):\n return data_shapes\n if all(isinstance(x, tuple) for x in data_shapes):\n if len(data_shapes) == 1:\n data_shapes = [DataDesc(name='data', shape=data_shapes[0], dtype=data_types[0])]\n else:\n data_shapes = [DataDesc(name='data' + str(i), shape=data_shapes[i],\n dtype=data_types[i]) for i in range(len(data_shapes))]\n return data_shapes\n raise ValueError('data_shapes must be either a list of DataDesc or a list of Tuple')\n\n\n@wrap_ctx_to_device_func\ndef quantize_model(sym, arg_params, aux_params, data_names=('data',),\n device=cpu(), excluded_sym_names=None, excluded_op_names=None, calib_mode='entropy',\n calib_data=None, num_calib_batches=None,\n quantized_dtype='int8', quantize_mode='smart',\n quantize_granularity='tensor-wise', logger=None):\n \"\"\"User-level API for generating a quantized model from a FP32 model w/ or w/o calibration.\n The backend quantized operators are only enabled for Linux systems. Please do not run\n inference using the quantized models on Windows for now.\n The quantization implementation adopts the TensorFlow's approach:\n https://www.tensorflow.org/performance/quantization.\n The calibration implementation borrows the idea of Nvidia's 8-bit Inference with TensorRT:\n http://on-demand.gputechconf.com/gtc/2017/presentation/s7310-8-bit-inference-with-tensorrt.pdf\n and adapts the method to MXNet.\n\n .. _`quantize_model_params`:\n Parameters\n ----------\n sym : str or Symbol\n Defines the structure of a neural network for FP32 data types.\n arg_params : dict\n Dictionary of name to `NDArray`.\n aux_params : dict\n Dictionary of name to `NDArray`.\n data_names : a list of strs\n Data names required for creating a Module object to run forward propagation on the\n calibration dataset.\n device : Device\n Defines the device that users want to run forward propagation on the calibration\n dataset for collecting layer output statistics. Currently, only supports single device.\n excluded_sym_names : list of strings\n A list of strings representing the names of the symbols that users want to excluding\n from being quantized.\n excluded_op_names : list of strings\n A list of strings representing the names of the operators that users want to excluding\n from being quantized.\n calib_mode : str\n If calib_mode='none', no calibration will be used and the thresholds for\n requantization after the corresponding layers will be calculated at runtime by\n calling min and max operators. The quantized models generated in this\n mode are normally 10-20% slower than those with calibrations during inference.\n If calib_mode='naive', the min and max values of the layer outputs from a calibration\n dataset will be directly taken as the thresholds for quantization.\n If calib_mode='entropy' (default mode), the thresholds for quantization will be\n derived such that the KL divergence between the distributions of FP32 layer outputs and\n quantized layer outputs is minimized based upon the calibration dataset.\n calib_data : DataLoader\n A DataLoader initialized by the calibration dataset.\n num_calib_batches : int or None\n The maximum number of batches that user would like to use for calibration. If not provided,\n the whole calibration dataset will be used.\n quantized_dtype : str\n The quantized destination type for input data. Currently support 'int8', 'uint8' and 'auto'.\n 'auto' means automatically select output type according to calibration result.\n Default value is 'int8'.\n quantize_mode : str\n The mode that quantization pass to apply. Support 'full' and 'smart'.\n 'full' means quantize all operator if possible.\n 'smart' means quantization pass will smartly choice which operator should be quantized.\n quantize_granularity: str\n The granularity of quantization, currently supports 'tensor-wise' and 'channel-wise'\n quantization. The default value is 'tensor-wise'.\n logger : Object\n A logging object for printing information during the process of quantization.\n\n Returns\n -------\n quantized_model: tuple\n A tuple of quantized symbol, quantized arg_params, and aux_params.\n \"\"\"\n warnings.warn('WARNING: This will be deprecated please use quantize_net with Gluon models')\n if excluded_sym_names is None:\n excluded_sym_names = []\n if not isinstance(excluded_sym_names, list):\n raise ValueError('excluded_sym_names must be a list of strings representing'\n ' the names of the symbols that will not be quantized,'\n ' while received type %s' % str(type(excluded_sym_names)))\n\n if excluded_op_names is None:\n excluded_op_names = []\n if not isinstance(excluded_op_names, list):\n raise ValueError('excluded_op_names must be a list of strings representing'\n ' the names of the operators that will not be quantized,'\n ' while received type %s' % str(type(excluded_op_names)))\n\n if logger:\n os.environ['MXNET_QUANTIZATION_VERBOSE'] = '1'\n logger.info('Quantizing symbol')\n if quantized_dtype not in ('int8', 'uint8', 'auto'):\n raise ValueError('unknown quantized_dtype %s received,'\n ' expected `int8`, `uint8` or `auto`' % quantized_dtype)\n if quantize_granularity not in ('tensor-wise', 'channel-wise'):\n raise ValueError('unkonwn quantize_granularity %s received,'\n ' expected `tensor-wise` or `channel-wise`.' % quantize_granularity)\n qsym, calib_layers = _quantize_symbol(sym, device, excluded_symbols=excluded_sym_names,\n excluded_operators=excluded_op_names,\n offline_params=list(arg_params.keys()),\n quantized_dtype=quantized_dtype,\n quantize_mode=quantize_mode,\n quantize_granularity=quantize_granularity)\n min_max_dict = {}\n if calib_mode is not None and calib_mode != 'none':\n if not isinstance(device, Device):\n raise ValueError('currently only supports single device, while received %s' % str(device))\n if calib_data is None:\n raise ValueError('calib_data must be provided when calib_mode=%s' % calib_mode)\n if not isinstance(calib_data, mx.gluon.data.DataLoader):\n raise ValueError('calib_data must be of DataLoader type when calib_mode=%s,'\n ' while received type %s' % (calib_mode, str(type(calib_data))))\n\n inputs = [mx.sym.var(dname) for dname in data_names]\n param_dict = arg_params\n param_dict.update(aux_params)\n sym_block = mx.gluon.SymbolBlock(sym, inputs)\n sym_block.load_dict(param_dict)\n\n if calib_mode == 'entropy':\n collector = _LayerHistogramCollector(quantized_dtype=quantized_dtype,\n include_layers=calib_layers,\n logger=logger)\n elif calib_mode == 'naive':\n collector = _LayerOutputMinMaxCollector(quantized_dtype=quantized_dtype,\n include_layers=calib_layers,\n logger=logger)\n\n else:\n raise ValueError('unknown calibration mode %s received,'\n ' expected `none`, `naive`, or `entropy`' % calib_mode)\n\n num_batches = _collect_layer_statistics(sym_block, calib_data, collector,\n len(inputs), num_calib_batches, logger)\n if logger:\n logger.info('Collected layer output min/max values from FP32 model using %d batches'\n % num_batches)\n logger.info('Performing calibration post collecting operations')\n\n min_max_dict = collector.post_collect()\n qsym = _calibrate_quantized_sym(qsym, min_max_dict)\n\n if logger:\n logger.info('Quantizing parameters')\n qarg_params = _quantize_params(qsym, arg_params, min_max_dict)\n\n if is_np_array():\n qsym = qsym.as_np_ndarray()\n\n return qsym, qarg_params, aux_params\n\n@wrap_ctx_to_device_func\ndef quantize_model_onednn(sym, arg_params, aux_params, data_names=('data',),\n device=cpu(), excluded_sym_names=None, excluded_op_names=None,\n calib_mode='entropy', calib_data=None, num_calib_batches=None,\n quantized_dtype='int8', quantize_mode='smart',\n quantize_granularity='tensor-wise', logger=None):\n \"\"\"User-level API for generating a fusion + quantized model from a FP32 model\n w/ or w/o calibration with oneDNN.\n The backend quantized operators are only enabled for Linux systems. Please do not run\n inference using the quantized models on Windows for now.\n\n Parameters\n ----------\n all\n :ref:`As in quantize_model`\n\n\n Returns\n -------\n quantized_model: tuple\n A tuple of quantized symbol, quantized arg_params, and aux_params.\n \"\"\"\n if not isinstance(device, Device):\n raise ValueError('currently only supports single device, while received %s' % str(device))\n if device.device_type != 'cpu':\n raise ValueError(\n 'quantize_model_onednn only support Intel cpu platform with oneDNN Backend')\n\n sym = sym.optimize_for(backend='ONEDNN_QUANTIZE')\n\n qsym, qarg_params, aux_params = quantize_model(sym=sym, arg_params=arg_params, aux_params=aux_params,\n data_names=data_names, device=device,\n excluded_sym_names=excluded_sym_names,\n excluded_op_names=excluded_op_names,\n calib_mode=calib_mode, calib_data=calib_data,\n num_calib_batches=num_calib_batches,\n quantized_dtype=quantized_dtype, quantize_mode=quantize_mode,\n quantize_granularity=quantize_granularity, logger=logger)\n\n qsym = qsym.optimize_for(backend='ONEDNN_QUANTIZE')\n\n return qsym, qarg_params, aux_params\n\ndef quantize_graph(sym, arg_params, aux_params, device=cpu(),\n excluded_sym_names=None, excluded_op_names=None,\n calib_mode='entropy', quantized_dtype='int8',\n quantize_mode='full', quantize_granularity='tensor-wise',\n LayerOutputCollector=None, logger=None):\n \"\"\"User-level API for generating a quantized model from a FP32 model w/o calibration\n and a collector for naive or entropy calibration.\n The backend quantized operators are only enabled for Linux systems. Please do not run\n inference using the quantized models on Windows for now.\n Parameters\n ----------\n sym : str or Symbol\n Defines the structure of a neural network for FP32 data types.\n device : Device\n Defines the device that users want to run forward propagation on the calibration\n dataset for collecting layer output statistics. Currently, only supports single device.\n arg_params : dict\n Dictionary of name to `NDArray`.\n aux_params : dict\n Dictionary of name to `NDArray`.\n excluded_sym_names : list of strings\n A list of strings representing the names of the symbols that users want to excluding\n from being quantized.\n excluded_op_names : list of strings\n A list of strings representing the names of the operators that users want to excluding\n calib_mode : str\n If calib_mode='none', no calibration will be used and the thresholds for\n requantization after the corresponding layers will be calculated at runtime by\n calling min and max operators. The quantized models generated in this\n mode are normally 10-20% slower than those with calibrations during inference.\n If calib_mode='naive', the min and max values of the layer outputs from a calibration\n dataset will be directly taken as the thresholds for quantization.\n If calib_mode='entropy' (default mode), the thresholds for quantization will be\n derived such that the KL divergence between the distributions of FP32 layer outputs and\n quantized layer outputs is minimized based upon the calibration dataset.\n quantized_dtype : str\n The quantized destination type for input data. Currently support 'int8'\n , 'uint8' and 'auto'. 'auto' means automatically select output type according to calibration result.\n Default value is 'int8'.\n quantize_mode : str\n The mode that quantization pass to apply. Support 'full' and 'smart'.\n 'full' means quantize all operator if possible.\n 'smart' means quantization pass will smartly choice which operator should be quantized.\n quantize_granularity: str\n The granularity of quantization, currently supports 'tensor-wise' and 'channel-wise'\n quantization. The default value is 'tensor-wise'.\n LayerOutputCollector : subclass of CalibrationCollector\n For custom calibration method usage.\n Passed object's include_layers attribute will be feed with names of layers which needs calibration\n logger : Object\n A logging object for printing information during the process of quantization.\n Returns\n -------\n quantized_model : tuple\n A tuple of quantized symbol, quantized arg_params, aux_params and collector.\n \"\"\"\n if excluded_sym_names is None:\n excluded_sym_names = []\n if not isinstance(excluded_sym_names, list):\n raise ValueError('excluded_sym_names must be a list of strings representing'\n ' the names of the symbols that will not be quantized,'\n ' while received type %s' % str(type(excluded_sym_names)))\n if not isinstance(device, Device):\n raise ValueError('currently only supports single device, while received %s' % str(device))\n if logger:\n os.environ['MXNET_QUANTIZATION_VERBOSE'] = '1'\n logger.info('Quantizing graph')\n if quantized_dtype not in ('int8', 'uint8', 'auto'):\n raise ValueError('unknown quantized_dtype %s received,'\n ' expected `int8`, `uint8` or `auto`' % quantized_dtype)\n if quantize_granularity not in ('tensor-wise', 'channel-wise'):\n raise ValueError('unkonwn quantize_granularity %s received,'\n ' expected `tensor-wise` or `channel-wise`.' % quantize_granularity)\n qsym, calib_layers = _quantize_symbol(sym, device, excluded_symbols=excluded_sym_names,\n excluded_operators=excluded_op_names,\n offline_params=list(arg_params.keys()),\n quantized_dtype=quantized_dtype,\n quantize_mode=quantize_mode,\n quantize_granularity=quantize_granularity)\n\n collector = None\n if calib_mode is not None and calib_mode != 'none':\n if calib_mode == 'entropy':\n collector = _LayerHistogramCollector(quantized_dtype=quantized_dtype,\n include_layers=calib_layers, logger=logger)\n if logger:\n logger.info(\n 'Create a layer output collector for entropy calibration.')\n elif calib_mode == 'naive':\n collector = _LayerOutputMinMaxCollector(quantized_dtype=quantized_dtype,\n include_layers=calib_layers, logger=logger)\n if logger:\n logger.info(\n 'Create a layer output minmax collector for naive calibration')\n elif calib_mode == 'custom' and LayerOutputCollector is not None:\n if not isinstance(LayerOutputCollector, CalibrationCollector):\n raise ValueError('LayerOutputCollecotr must be a subclass of a CalibrationCollector class,'\n ' but it is %s' % LayerOutputCollector.__class__)\n collector = LayerOutputCollector\n\n # Inject layer names that need calibration to collector\n if hasattr(collector, \"include_layers\"):\n if collector.include_layers is not None:\n logger.info('Custom collector has set include_layers attribute. '\n 'Calibration layers not passed')\n else:\n collector.include_layers = calib_layers\n if logger:\n logger.info(\n 'Create a custom layer output minmax collector for calibration')\n else:\n raise ValueError('unknown calibration mode %s received,'\n ' expected `none`, `naive`, `entropy` or `custom`' % calib_mode)\n if logger:\n logger.info('Collector created, please use set_monitor_callback'\n ' to collect calibration information.')\n\n if logger:\n logger.info('Quantizing parameters')\n qarg_params = _quantize_params(qsym, arg_params, min_max_dict={})\n\n if is_np_array():\n qsym = qsym.as_np_ndarray()\n\n return qsym, qarg_params, aux_params, collector, calib_layers\n\ndef calib_graph(qsym, arg_params, aux_params, collector,\n calib_mode='entropy', logger=logging):\n \"\"\"User-level API for calibrating a quantized model using a filled collector.\n The backend quantized operators are only enabled for Linux systems. Please do not run\n inference using the quantized models on Windows for now.\n Parameters\n ----------\n qsym : str or Symbol\n Defines the structure of a neural network for INT8 data types.\n arg_params : dict\n Dictionary of name to `NDArray`.\n aux_params : dict\n Dictionary of name to `NDArray`.\n collector : function\n layer collector for naive or entropy calibration.\n calib_mode : str\n If calib_mode='none', no calibration will be used and the thresholds for\n requantization after the corresponding layers will be calculated at runtime by\n calling min and max operators. The quantized models generated in this\n mode are normally 10-20% slower than those with calibrations during inference.\n If calib_mode='naive', the min and max values of the layer outputs from a calibration\n dataset will be directly taken as the thresholds for quantization.\n If calib_mode='entropy' (default mode), the thresholds for quantization will be\n derived such that the KL divergence between the distributions of FP32 layer outputs and\n quantized layer outputs is minimized based upon the calibration dataset.\n quantized_dtype : str\n The quantized destination type for input data. Currently support 'int8'\n , 'uint8' and 'auto'. 'auto' means automatically select output type according to calibration result.\n Default value is 'int8'.\n logger : Object\n A logging object for printing information during the process of quantization.\n Returns\n -------\n quantized_model : tuple\n A tuple of calibrated symbol, quantized arg_params, aux_params.\n \"\"\"\n min_max_dict = {}\n if calib_mode is not None and calib_mode != 'none':\n if calib_mode in ('entropy', 'naive', 'custom'):\n min_max_dict = collector.post_collect()\n\n else:\n raise ValueError('unknown calibration mode %s received,'\n ' expected `none`, `naive`, `entropy` or `custom`' % calib_mode)\n qsym = _calibrate_quantized_sym(qsym, min_max_dict)\n else:\n raise ValueError('Please set calibration mode to naive, entropy or custom (with custom CalibrationCollector)')\n\n if logger:\n logger.info('Quantizing parameters')\n qarg_params = _quantize_params(qsym, arg_params, min_max_dict)\n\n if is_np_array():\n qsym = qsym.as_np_ndarray()\n\n return qsym, qarg_params, aux_params\n\n@wrap_ctx_to_device_func\ndef quantize_net(network, quantized_dtype='auto', quantize_mode='full', quantize_granularity='tensor-wise',\n exclude_layers=None, exclude_layers_match=None, exclude_operators=None,\n calib_data=None, data_shapes=None, calib_mode='none',\n num_calib_batches=None, device=cpu(), LayerOutputCollector=None, logger=None):\n \"\"\"User-level API for Gluon users to generate a quantized SymbolBlock from a FP32 HybridBlock w/ or w/o calibration.\n The backend quantized operators are only enabled for Linux systems. Please do not run\n inference using the quantized models on Windows for now.\n\n Parameters\n ----------\n network : Gluon HybridBlock\n Defines the structure of a neural network for FP32 data types.\n quantized_dtype : str\n The quantized destination type for input data. Currently support 'int8'\n , 'uint8' and 'auto'. 'auto' means automatically select output type according to calibration result.\n Default value is 'int8'.\n quantize_mode : str\n The mode that quantization pass to apply. Support 'full' and 'smart'.\n 'full' means quantize all operator if possible.\n 'smart' means quantization pass will smartly choice which operator should be quantized.\n quantize_granularity: str\n The granularity of quantization, currently supports 'tensor-wise' and 'channel-wise'\n quantization. The default value is 'tensor-wise'.\n exclude_layers : list of strings\n A list of strings representing the names of the symbols that users want to excluding\n exclude_layers_match : list of strings\n A list of strings wildcard matching the names of the symbols that users want to excluding\n from being quantized.\n exclude_operators : list of strings\n A list of strings representing the names of the operators that users want to excluding\n calib_data : gluon.DataLoader\n A iterable data loading object.\n data_shapes : list of DataDesc or list of tuple\n A list of data shapes. Required if calib_data is not provided. In case of tuples,\n the names of inputs are generated.\n calib_mode : str\n If calib_mode='none', no calibration will be used and the thresholds for\n requantization after the corresponding layers will be calculated at runtime by\n calling min and max operators. The quantized models generated in this\n mode are normally 10-20% slower than those with calibrations during inference.\n If calib_mode='naive', the min and max values of the layer outputs from a calibration\n dataset will be directly taken as the thresholds for quantization.\n If calib_mode='entropy' (default mode), the thresholds for quantization will be\n derived such that the KL divergence between the distributions of FP32 layer outputs and\n quantized layer outputs is minimized based upon the calibration dataset.\n If calib_mode='custom', the provided LayerOutputCollector will be used to determine\n the thresholds for quantization. For more information refer to CalibrationCollector\n documentation.\n num_calib_batches : int or None\n The maximum number of batches that user would like to use for calibration. If not provided,\n the whole calibration dataset will be used.\n device : Device\n Defines the device that users want to run forward propagation on the calibration\n dataset for collecting layer output statistics. Currently, only supports single device.\n LayerOutputCollector : subclass of CalibrationCollector\n For `custom` calibration method usage.\n Passed object's include_layers attribute will be feed with names of layers which needs calibration\n logger : Object\n A logging object for printing information during the process of quantization.\n\n Returns\n -------\n network : Gluon SymbolBlock\n Defines the structure of a neural network for INT8 data types.\n \"\"\"\n from ..gluon import SymbolBlock\n\n if device != mx.cpu():\n raise ValueError('Quantization currently supports only CPU device')\n backend = 'ONEDNN_QUANTIZE'\n\n network.hybridize(static_alloc=False, static_shape=False)\n data_types = None\n if data_shapes is None:\n if calib_data is None:\n raise ValueError('At least one of data_shapes or calib_data has to be provided.')\n\n if isinstance(calib_data, mx.gluon.data.DataLoader):\n x = iter(calib_data)\n batch = next(x)\n if isinstance(batch, list):\n data_shapes = [b.shape for b in batch]\n data_types = [b.dtype for b in batch]\n else:\n data_shapes = [batch.shape]\n data_types = [batch.dtype]\n else:\n raise ValueError('calib_data expects mx.gluon.data.DataLoader')\n\n if data_types is None:\n data_types = [mx_real_t] * len(data_shapes)\n data_descs = _generate_list_of_data_desc(data_shapes, data_types)\n\n num_inputs = len(data_descs)\n data_nd = []\n for desc in data_descs:\n if is_np_array():\n data_nd.append(mx.np.zeros(shape=desc.shape, dtype=desc.dtype))\n else:\n data_nd.append(mx.nd.zeros(shape=desc.shape, dtype=desc.dtype))\n while True:\n try:\n network(*data_nd)\n except (ValueError, TypeError) as err:\n if logger:\n logger.warning(err)\n logger.warning(\"Deduced input data descriptors failed to run forward pass.\"\n \" Trying again with one less input.\")\n del data_nd[-1]\n num_inputs -= 1\n data_shapes = [b.shape for b in data_nd]\n data_types = [b.dtype for b in data_nd]\n data_descs = _generate_list_of_data_desc(data_shapes, data_types)\n continue\n else:\n break\n\n symnet, params = network.export(None)\n symnet = symnet.optimize_for(backend=backend)\n\n if is_np_array():\n symnet = symnet.as_np_ndarray()\n\n args, auxs = dict(), dict()\n for k, v in params.items():\n ptype, pname = k[:3], k[4:]\n if ptype == \"arg\":\n args[pname] = v\n else:\n auxs[pname] = v\n\n if exclude_layers is None:\n exclude_layers = []\n if exclude_layers_match is None:\n exclude_layers_match = []\n if exclude_operators is None:\n exclude_operators = []\n for name_match in exclude_layers_match:\n for layers in list(symnet.get_internals()):\n if layers.name.find(name_match) != -1:\n exclude_layers.append(layers.name)\n if logger:\n logger.info('These layers have been excluded %s' % exclude_layers)\n\n qsym, qarg_params, aux_params, collector, _ = quantize_graph(\n sym=symnet, arg_params=args, aux_params=auxs, device=device,\n excluded_sym_names=exclude_layers, excluded_op_names=exclude_operators,\n calib_mode=calib_mode, quantized_dtype=quantized_dtype, quantize_mode=quantize_mode,\n quantize_granularity=quantize_granularity, LayerOutputCollector=LayerOutputCollector,\n logger=logger)\n\n if calib_mode is not None and calib_mode != 'none':\n if not isinstance(device, Device):\n raise ValueError(\n 'currently only supports single device, while received %s' % str(device))\n if calib_data is None:\n raise ValueError(\n 'calib_data must be provided when calib_mode=%s' % calib_mode)\n if calib_mode in ['naive', 'entropy', 'custom']:\n inputs = [mx.sym.var(desc.name) for desc in data_descs]\n calib_net = SymbolBlock(symnet, inputs)\n calib_net.load_dict(params, cast_dtype=True, dtype_source='saved')\n calib_net.hybridize(static_alloc=False, static_shape=False)\n num_batches = _collect_layer_statistics(calib_net, calib_data, collector, num_inputs,\n num_calib_batches, logger)\n\n if logger:\n logger.info('Collected layer output values from FP32 model using %d batches'\n % num_batches)\n\n qsym, qarg_params, aux_params = calib_graph(\n qsym=qsym, arg_params=args, aux_params=auxs, collector=collector,\n calib_mode=calib_mode, logger=logger)\n else:\n raise ValueError('calib_mode has to be one of: naive, entropy, custom')\n elif calib_mode is not None and calib_mode == 'none':\n inputs = [mx.sym.var(desc.name) for desc in data_descs]\n\n net = SymbolBlock(qsym, inputs)\n all_params = {('arg:%s' % k): v.as_in_context(cpu()) for k, v in qarg_params.items()}\n all_params.update({('aux:%s' % k): v.as_in_context(cpu()) for k, v in aux_params.items()})\n net.load_dict(all_params, cast_dtype=True, dtype_source='saved')\n net.optimize_for(data_nd, backend=backend, skip_infer=True)\n return net\n", "meta": {"hexsha": "be0282fe8a81eb40f7ff06700cd7a13194b9dc9b", "size": 46392, "ext": "py", "lang": "Python", "max_stars_repo_path": "python/mxnet/contrib/quantization.py", "max_stars_repo_name": "Hunter-Zolomon/incubator-mxnet", "max_stars_repo_head_hexsha": "3b5a1f901872958971dca4cd3358a6418826cb04", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-11-09T01:40:17.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-09T01:40:17.000Z", "max_issues_repo_path": "python/mxnet/contrib/quantization.py", "max_issues_repo_name": "Hunter-Zolomon/incubator-mxnet", "max_issues_repo_head_hexsha": "3b5a1f901872958971dca4cd3358a6418826cb04", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "python/mxnet/contrib/quantization.py", "max_forks_repo_name": "Hunter-Zolomon/incubator-mxnet", "max_forks_repo_head_hexsha": "3b5a1f901872958971dca4cd3358a6418826cb04", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2018-07-19T00:43:30.000Z", "max_forks_repo_forks_event_max_datetime": "2018-07-19T00:43:30.000Z", "avg_line_length": 49.1440677966, "max_line_length": 120, "alphanum_fraction": 0.6437101224, "include": true, "reason": "import numpy", "num_tokens": 9716, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6001883449573376, "lm_q2_score": 0.331119752830196, "lm_q1q2_score": 0.19873421643383807}} {"text": "from abc import ABCMeta, abstractmethod\nfrom collections import Iterable\nfrom numbers import Integral, Real\nfrom warnings import warn\n\nfrom six import add_metaclass\nimport numpy as np\n\nfrom .function import Tabulated1D, INTERPOLATION_SCHEME\nfrom openmc.stats.univariate import Univariate, Tabular, Discrete, Mixture\nimport openmc.checkvalue as cv\nfrom openmc.mixin import EqualityMixin\nfrom .data import EV_PER_MEV\nfrom .endf import get_tab1_record, get_tab2_record\n\n\n@add_metaclass(ABCMeta)\nclass EnergyDistribution(EqualityMixin):\n \"\"\"Abstract superclass for all energy distributions.\"\"\"\n def __init__(self):\n pass\n\n @abstractmethod\n def to_hdf5(self, group):\n pass\n\n @staticmethod\n def from_hdf5(group):\n \"\"\"Generate energy distribution from HDF5 data\n\n Parameters\n ----------\n group : h5py.Group\n HDF5 group to read from\n\n Returns\n -------\n openmc.data.EnergyDistribution\n Energy distribution\n\n \"\"\"\n energy_type = group.attrs['type'].decode()\n if energy_type == 'maxwell':\n return MaxwellEnergy.from_hdf5(group)\n elif energy_type == 'evaporation':\n return Evaporation.from_hdf5(group)\n elif energy_type == 'watt':\n return WattEnergy.from_hdf5(group)\n elif energy_type == 'madland-nix':\n return MadlandNix.from_hdf5(group)\n elif energy_type == 'discrete_photon':\n return DiscretePhoton.from_hdf5(group)\n elif energy_type == 'level':\n return LevelInelastic.from_hdf5(group)\n elif energy_type == 'continuous':\n return ContinuousTabular.from_hdf5(group)\n else:\n raise ValueError(\"Unknown energy distribution type: {}\"\n .format(energy_type))\n\n @staticmethod\n def from_endf(file_obj, params):\n \"\"\"Generate energy distribution from an ENDF evaluation\n\n Parameters\n ----------\n file_obj : file-like object\n ENDF file positioned at the start of a section for an energy\n distribution.\n params : list\n List of parameters at the start of the energy distribution that\n includes the LF value indicating what type of energy distribution is\n present.\n\n Returns\n -------\n openmc.data.EnergyDistribution\n A sub-class of :class:`openmc.data.EnergyDistribution`\n\n \"\"\"\n lf = params[3]\n if lf == 1:\n return ArbitraryTabulated.from_endf(file_obj, params)\n elif lf == 5:\n return GeneralEvaporation.from_endf(file_obj, params)\n elif lf == 7:\n return MaxwellEnergy.from_endf(file_obj, params)\n elif lf == 9:\n return Evaporation.from_endf(file_obj, params)\n elif lf == 11:\n return WattEnergy.from_endf(file_obj, params)\n elif lf == 12:\n return MadlandNix.from_endf(file_obj, params)\n\n\nclass ArbitraryTabulated(EnergyDistribution):\n r\"\"\"Arbitrary tabulated function given in ENDF MF=5, LF=1 represented as\n\n .. math::\n f(E \\rightarrow E') = g(E \\rightarrow E')\n\n Parameters\n ----------\n energy : numpy.ndarray\n Array of incident neutron energies\n pdf : list of openmc.data.Tabulated1D\n Tabulated outgoing energy distribution probability density functions\n\n Attributes\n ----------\n energy : numpy.ndarray\n Array of incident neutron energies\n pdf : list of openmc.data.Tabulated1D\n Tabulated outgoing energy distribution probability density functions\n\n \"\"\"\n\n def __init__(self, energy, pdf):\n super(ArbitraryTabulated, self).__init__()\n self.energy = energy\n self.pdf = pdf\n\n def to_hdf5(self, group):\n raise NotImplementedError\n\n @classmethod\n def from_endf(cls, file_obj, params):\n \"\"\"Generate arbitrary tabulated distribution from an ENDF evaluation\n\n Parameters\n ----------\n file_obj : file-like object\n ENDF file positioned at the start of a section for an energy\n distribution.\n params : list\n List of parameters at the start of the energy distribution that\n includes the LF value indicating what type of energy distribution is\n present.\n\n Returns\n -------\n openmc.data.ArbitraryTabulated\n Arbitrary tabulated distribution\n\n \"\"\"\n params, tab2 = get_tab2_record(file_obj)\n n_energies = params[5]\n\n energy = np.zeros(n_energies)\n pdf = []\n for j in range(n_energies):\n params, func = get_tab1_record(file_obj)\n energy[j] = params[1]\n pdf.append(func)\n return cls(energy, pdf)\n\n\nclass GeneralEvaporation(EnergyDistribution):\n r\"\"\"General evaporation spectrum given in ENDF MF=5, LF=5 represented as\n\n .. math::\n f(E \\rightarrow E') = g(E'/\\theta(E))\n\n Parameters\n ----------\n theta : openmc.data.Tabulated1D\n Tabulated function of incident neutron energy :math:`E`\n g : openmc.data.Tabulated1D\n Tabulated function of :math:`x = E'/\\theta(E)`\n u : float\n Constant introduced to define the proper upper limit for the final\n particle energy such that :math:`0 \\le E' \\le E - U`\n\n Attributes\n ----------\n theta : openmc.data.Tabulated1D\n Tabulated function of incident neutron energy :math:`E`\n g : openmc.data.Tabulated1D\n Tabulated function of :math:`x = E'/\\theta(E)`\n u : float\n Constant introduced to define the proper upper limit for the final\n particle energy such that :math:`0 \\le E' \\le E - U`\n\n \"\"\"\n\n def __init__(self, theta, g, u):\n super(GeneralEvaporation, self).__init__()\n self.theta = theta\n self.g = g\n self.u = u\n\n def to_hdf5(self, group):\n raise NotImplementedError\n\n @classmethod\n def from_ace(cls, ace, idx=0):\n raise NotImplementedError\n\n @classmethod\n def from_endf(cls, file_obj, params):\n \"\"\"Generate general evaporation spectrum from an ENDF evaluation\n\n Parameters\n ----------\n file_obj : file-like object\n ENDF file positioned at the start of a section for an energy\n distribution.\n params : list\n List of parameters at the start of the energy distribution that\n includes the LF value indicating what type of energy distribution is\n present.\n\n Returns\n -------\n openmc.data.GeneralEvaporation\n General evaporation spectrum\n\n \"\"\"\n u = params[0]\n params, theta = get_tab1_record(file_obj)\n params, g = get_tab1_record(file_obj)\n return cls(theta, g, u)\n\n\nclass MaxwellEnergy(EnergyDistribution):\n r\"\"\"Simple Maxwellian fission spectrum represented as\n\n .. math::\n f(E \\rightarrow E') = \\frac{\\sqrt{E'}}{I} e^{-E'/\\theta(E)}\n\n Parameters\n ----------\n theta : openmc.data.Tabulated1D\n Tabulated function of incident neutron energy\n u : float\n Constant introduced to define the proper upper limit for the final\n particle energy such that :math:`0 \\le E' \\le E - U`\n\n Attributes\n ----------\n theta : openmc.data.Tabulated1D\n Tabulated function of incident neutron energy\n u : float\n Constant introduced to define the proper upper limit for the final\n particle energy such that :math:`0 \\le E' \\le E - U`\n\n \"\"\"\n\n def __init__(self, theta, u):\n super(MaxwellEnergy, self).__init__()\n self.theta = theta\n self.u = u\n\n @property\n def theta(self):\n return self._theta\n\n @property\n def u(self):\n return self._u\n\n @theta.setter\n def theta(self, theta):\n cv.check_type('Maxwell theta', theta, Tabulated1D)\n self._theta = theta\n\n @u.setter\n def u(self, u):\n cv.check_type('Maxwell restriction energy', u, Real)\n self._u = u\n\n def to_hdf5(self, group):\n \"\"\"Write distribution to an HDF5 group\n\n Parameters\n ----------\n group : h5py.Group\n HDF5 group to write to\n\n \"\"\"\n\n group.attrs['type'] = np.string_('maxwell')\n group.attrs['u'] = self.u\n self.theta.to_hdf5(group, 'theta')\n\n @classmethod\n def from_hdf5(cls, group):\n \"\"\"Generate Maxwell distribution from HDF5 data\n\n Parameters\n ----------\n group : h5py.Group\n HDF5 group to read from\n\n Returns\n -------\n openmc.data.MaxwellEnergy\n Maxwell distribution\n\n \"\"\"\n theta = Tabulated1D.from_hdf5(group['theta'])\n u = group.attrs['u']\n return cls(theta, u)\n\n @classmethod\n def from_ace(cls, ace, idx=0):\n \"\"\"Create a Maxwell distribution from an ACE table\n\n Parameters\n ----------\n ace : openmc.data.ace.Table\n An ACE table\n idx : int\n Offset to read from in XSS array (default of zero)\n\n Returns\n -------\n openmc.data.MaxwellEnergy\n Maxwell distribution\n\n \"\"\"\n # Read nuclear temperature -- since units are MeV, convert to eV\n theta = Tabulated1D.from_ace(ace, idx)\n theta.y *= EV_PER_MEV\n\n # Restriction energy\n nr = int(ace.xss[idx])\n ne = int(ace.xss[idx + 1 + 2*nr])\n u = ace.xss[idx + 2 + 2*nr + 2*ne]*EV_PER_MEV\n\n return cls(theta, u)\n\n @classmethod\n def from_endf(cls, file_obj, params):\n \"\"\"Generate Maxwell distribution from an ENDF evaluation\n\n Parameters\n ----------\n file_obj : file-like object\n ENDF file positioned at the start of a section for an energy\n distribution.\n params : list\n List of parameters at the start of the energy distribution that\n includes the LF value indicating what type of energy distribution is\n present.\n\n Returns\n -------\n openmc.data.MaxwellEnergy\n Maxwell distribution\n\n \"\"\"\n u = params[0]\n params, theta = get_tab1_record(file_obj)\n return cls(theta, u)\n\n\nclass Evaporation(EnergyDistribution):\n r\"\"\"Evaporation spectrum represented as\n\n .. math::\n f(E \\rightarrow E') = \\frac{E'}{I} e^{-E'/\\theta(E)}\n\n Parameters\n ----------\n theta : openmc.data.Tabulated1D\n Tabulated function of incident neutron energy\n u : float\n Constant introduced to define the proper upper limit for the final\n particle energy such that :math:`0 \\le E' \\le E - U`\n\n Attributes\n ----------\n theta : openmc.data.Tabulated1D\n Tabulated function of incident neutron energy\n u : float\n Constant introduced to define the proper upper limit for the final\n particle energy such that :math:`0 \\le E' \\le E - U`\n\n \"\"\"\n\n def __init__(self, theta, u):\n super(Evaporation, self).__init__()\n self.theta = theta\n self.u = u\n\n @property\n def theta(self):\n return self._theta\n\n @property\n def u(self):\n return self._u\n\n @theta.setter\n def theta(self, theta):\n cv.check_type('Evaporation theta', theta, Tabulated1D)\n self._theta = theta\n\n @u.setter\n def u(self, u):\n cv.check_type('Evaporation restriction energy', u, Real)\n self._u = u\n\n def to_hdf5(self, group):\n \"\"\"Write distribution to an HDF5 group\n\n Parameters\n ----------\n group : h5py.Group\n HDF5 group to write to\n\n \"\"\"\n\n group.attrs['type'] = np.string_('evaporation')\n group.attrs['u'] = self.u\n self.theta.to_hdf5(group, 'theta')\n\n @classmethod\n def from_hdf5(cls, group):\n \"\"\"Generate evaporation spectrum from HDF5 data\n\n Parameters\n ----------\n group : h5py.Group\n HDF5 group to read from\n\n Returns\n -------\n openmc.data.Evaporation\n Evaporation spectrum\n\n \"\"\"\n theta = Tabulated1D.from_hdf5(group['theta'])\n u = group.attrs['u']\n return cls(theta, u)\n\n @classmethod\n def from_ace(cls, ace, idx=0):\n \"\"\"Create an evaporation spectrum from an ACE table\n\n Parameters\n ----------\n ace : openmc.data.ace.Table\n An ACE table\n idx : int\n Offset to read from in XSS array (default of zero)\n\n Returns\n -------\n openmc.data.Evaporation\n Evaporation spectrum\n\n \"\"\"\n # Read nuclear temperature -- since units are MeV, convert to eV\n theta = Tabulated1D.from_ace(ace, idx)\n theta.y *= EV_PER_MEV\n\n # Restriction energy\n nr = int(ace.xss[idx])\n ne = int(ace.xss[idx + 1 + 2*nr])\n u = ace.xss[idx + 2 + 2*nr + 2*ne]*EV_PER_MEV\n\n return cls(theta, u)\n\n @classmethod\n def from_endf(cls, file_obj, params):\n \"\"\"Generate evaporation spectrum from an ENDF evaluation\n\n Parameters\n ----------\n file_obj : file-like object\n ENDF file positioned at the start of a section for an energy\n distribution.\n params : list\n List of parameters at the start of the energy distribution that\n includes the LF value indicating what type of energy distribution is\n present.\n\n Returns\n -------\n openmc.data.Evaporation\n Evaporation spectrum\n\n \"\"\"\n u = params[0]\n params, theta = get_tab1_record(file_obj)\n return cls(theta, u)\n\n\nclass WattEnergy(EnergyDistribution):\n r\"\"\"Energy-dependent Watt spectrum represented as\n\n .. math::\n f(E \\rightarrow E') = \\frac{e^{-E'/a}}{I} \\sinh \\left ( \\sqrt{bE'}\n \\right )\n\n Parameters\n ----------\n a, b : openmc.data.Tabulated1D\n Energy-dependent parameters tabulated as function of incident neutron\n energy\n u : float\n Constant introduced to define the proper upper limit for the final\n particle energy such that :math:`0 \\le E' \\le E - U`\n\n Attributes\n ----------\n a, b : openmc.data.Tabulated1D\n Energy-dependent parameters tabulated as function of incident neutron\n energy\n u : float\n Constant introduced to define the proper upper limit for the final\n particle energy such that :math:`0 \\le E' \\le E - U`\n\n \"\"\"\n\n def __init__(self, a, b, u):\n super(WattEnergy, self).__init__()\n self.a = a\n self.b = b\n self.u = u\n\n @property\n def a(self):\n return self._a\n\n @property\n def b(self):\n return self._b\n\n @property\n def u(self):\n return self._u\n\n @a.setter\n def a(self, a):\n cv.check_type('Watt a', a, Tabulated1D)\n self._a = a\n\n @b.setter\n def b(self, b):\n cv.check_type('Watt b', b, Tabulated1D)\n self._b = b\n\n @u.setter\n def u(self, u):\n cv.check_type('Watt restriction energy', u, Real)\n self._u = u\n\n def to_hdf5(self, group):\n \"\"\"Write distribution to an HDF5 group\n\n Parameters\n ----------\n group : h5py.Group\n HDF5 group to write to\n\n \"\"\"\n\n group.attrs['type'] = np.string_('watt')\n group.attrs['u'] = self.u\n self.a.to_hdf5(group, 'a')\n self.b.to_hdf5(group, 'b')\n\n @classmethod\n def from_hdf5(cls, group):\n \"\"\"Generate Watt fission spectrum from HDF5 data\n\n Parameters\n ----------\n group : h5py.Group\n HDF5 group to read from\n\n Returns\n -------\n openmc.data.WattEnergy\n Watt fission spectrum\n\n \"\"\"\n a = Tabulated1D.from_hdf5(group['a'])\n b = Tabulated1D.from_hdf5(group['b'])\n u = group.attrs['u']\n return cls(a, b, u)\n\n @classmethod\n def from_ace(cls, ace, idx):\n \"\"\"Create a Watt fission spectrum from an ACE table\n\n Parameters\n ----------\n ace : openmc.data.ace.Table\n An ACE table\n idx : int\n Offset to read from in XSS array (default of zero)\n\n Returns\n -------\n openmc.data.WattEnergy\n Watt fission spectrum\n\n \"\"\"\n # Energy-dependent a parameter -- units are MeV, convert to eV\n a = Tabulated1D.from_ace(ace, idx)\n a.y *= EV_PER_MEV\n\n # Advance index\n nr = int(ace.xss[idx])\n ne = int(ace.xss[idx + 1 + 2*nr])\n idx += 2 + 2*nr + 2*ne\n\n # Energy-dependent b parameter -- units are MeV^-1\n b = Tabulated1D.from_ace(ace, idx)\n b.y /= EV_PER_MEV\n\n # Advance index\n nr = int(ace.xss[idx])\n ne = int(ace.xss[idx + 1 + 2*nr])\n idx += 2 + 2*nr + 2*ne\n\n # Restriction energy\n u = ace.xss[idx]*EV_PER_MEV\n\n return cls(a, b, u)\n\n @classmethod\n def from_endf(cls, file_obj, params):\n \"\"\"Generate Watt fission spectrum from an ENDF evaluation\n\n Parameters\n ----------\n file_obj : file-like object\n ENDF file positioned at the start of a section for an energy\n distribution.\n params : list\n List of parameters at the start of the energy distribution that\n includes the LF value indicating what type of energy distribution is\n present.\n\n Returns\n -------\n openmc.data.WattEnergy\n Watt fission spectrum\n\n \"\"\"\n u = params[0]\n params, a = get_tab1_record(file_obj)\n params, b = get_tab1_record(file_obj)\n return cls(a, b, u)\n\n\nclass MadlandNix(EnergyDistribution):\n r\"\"\"Energy-dependent fission neutron spectrum (Madland and Nix) given in\n ENDF MF=5, LF=12 represented as\n\n .. math::\n f(E \\rightarrow E') = \\frac{1}{2} [ g(E', E_F(L)) + g(E', E_F(H))]\n\n where\n\n .. math::\n g(E',E_F) = \\frac{1}{3\\sqrt{E_F T_M}} \\left [ u_2^{3/2} E_1 (u_2) -\n u_1^{3/2} E_1 (u_1) + \\gamma \\left ( \\frac{3}{2}, u_2 \\right ) - \\gamma\n \\left ( \\frac{3}{2}, u_1 \\right ) \\right ] \\\\ u_1 = \\left ( \\sqrt{E'} -\n \\sqrt{E_F} \\right )^2 / T_M \\\\ u_2 = \\left ( \\sqrt{E'} + \\sqrt{E_F}\n \\right )^2 / T_M.\n\n Parameters\n ----------\n efl, efh : float\n Constants which represent the average kinetic energy per nucleon of the\n fission fragment (efl = light, efh = heavy)\n tm : openmc.data.Tabulated1D\n Parameter tabulated as a function of incident neutron energy\n\n Attributes\n ----------\n efl, efh : float\n Constants which represent the average kinetic energy per nucleon of the\n fission fragment (efl = light, efh = heavy)\n tm : openmc.data.Tabulated1D\n Parameter tabulated as a function of incident neutron energy\n\n \"\"\"\n\n def __init__(self, efl, efh, tm):\n super(MadlandNix, self).__init__()\n self.efl = efl\n self.efh = efh\n self.tm = tm\n\n @property\n def efl(self):\n return self._efl\n\n @property\n def efh(self):\n return self._efh\n\n @property\n def tm(self):\n return self._tm\n\n @efl.setter\n def efl(self, efl):\n name = 'Madland-Nix light fragment energy'\n cv.check_type(name, efl, Real)\n cv.check_greater_than(name, efl, 0.)\n self._efl = efl\n\n @efh.setter\n def efh(self, efh):\n name = 'Madland-Nix heavy fragment energy'\n cv.check_type(name, efh, Real)\n cv.check_greater_than(name, efh, 0.)\n self._efh = efh\n\n @tm.setter\n def tm(self, tm):\n cv.check_type('Madland-Nix maximum temperature', tm, Tabulated1D)\n self._tm = tm\n\n def to_hdf5(self, group):\n \"\"\"Write distribution to an HDF5 group\n\n Parameters\n ----------\n group : h5py.Group\n HDF5 group to write to\n\n \"\"\"\n\n group.attrs['type'] = np.string_('madland-nix')\n group.attrs['efl'] = self.efl\n group.attrs['efh'] = self.efh\n self.tm.to_hdf5(group)\n\n @classmethod\n def from_hdf5(cls, group):\n \"\"\"Generate Madland-Nix fission spectrum from HDF5 data\n\n Parameters\n ----------\n group : h5py.Group\n HDF5 group to read from\n\n Returns\n -------\n openmc.data.MadlandNix\n Madland-Nix fission spectrum\n\n \"\"\"\n efl = group.attrs['efl']\n efh = group.attrs['efh']\n tm = Tabulated1D.from_hdf5(group['tm'])\n return cls(efl, efh, tm)\n\n @classmethod\n def from_endf(cls, file_obj, params):\n \"\"\"Generate Madland-Nix fission spectrum from an ENDF evaluation\n\n Parameters\n ----------\n file_obj : file-like object\n ENDF file positioned at the start of a section for an energy\n distribution.\n params : list\n List of parameters at the start of the energy distribution that\n includes the LF value indicating what type of energy distribution is\n present.\n\n Returns\n -------\n openmc.data.MadlandNix\n Madland-Nix fission spectrum\n\n \"\"\"\n params, tm = get_tab1_record(file_obj)\n efl, efh = params[0:2]\n return cls(efl, efh, tm)\n\n\n\nclass DiscretePhoton(EnergyDistribution):\n \"\"\"Discrete photon energy distribution\n\n Parameters\n ----------\n primary_flag : int\n Indicator of whether the photon is a primary or non-primary photon.\n energy : float\n Photon energy (if lp==0 or lp==1) or binding energy (if lp==2).\n atomic_weight_ratio : float\n Atomic weight ratio of the target nuclide responsible for the emitted\n particle\n\n Attributes\n ----------\n primary_flag : int\n Indicator of whether the photon is a primary or non-primary photon.\n energy : float\n Photon energy (if lp==0 or lp==1) or binding energy (if lp==2).\n atomic_weight_ratio : float\n Atomic weight ratio of the target nuclide responsible for the emitted\n particle\n\n \"\"\"\n\n def __init__(self, primary_flag, energy, atomic_weight_ratio):\n super(DiscretePhoton, self).__init__()\n self.primary_flag = primary_flag\n self.energy = energy\n self.atomic_weight_ratio = atomic_weight_ratio\n\n @property\n def primary_flag(self):\n return self._primary_flag\n\n @property\n def energy(self):\n return self._energy\n\n @property\n def atomic_weight_ratio(self):\n return self._atomic_weight_ratio\n\n @primary_flag.setter\n def primary_flag(self, primary_flag):\n cv.check_type('discrete photon primary_flag', primary_flag, Integral)\n self._primary_flag = primary_flag\n\n @energy.setter\n def energy(self, energy):\n cv.check_type('discrete photon energy', energy, Real)\n self._energy = energy\n\n @atomic_weight_ratio.setter\n def atomic_weight_ratio(self, atomic_weight_ratio):\n cv.check_type('atomic weight ratio', atomic_weight_ratio, Real)\n self._atomic_weight_ratio = atomic_weight_ratio\n\n def to_hdf5(self, group):\n \"\"\"Write distribution to an HDF5 group\n\n Parameters\n ----------\n group : h5py.Group\n HDF5 group to write to\n\n \"\"\"\n\n group.attrs['type'] = np.string_('discrete_photon')\n group.attrs['primary_flag'] = self.primary_flag\n group.attrs['energy'] = self.energy\n group.attrs['atomic_weight_ratio'] = self.atomic_weight_ratio\n\n @classmethod\n def from_hdf5(cls, group):\n \"\"\"Generate discrete photon energy distribution from HDF5 data\n\n Parameters\n ----------\n group : h5py.Group\n HDF5 group to read from\n\n Returns\n -------\n openmc.data.DiscretePhoton\n Discrete photon energy distribution\n\n \"\"\"\n primary_flag = group.attrs['primary_flag']\n energy = group.attrs['energy']\n awr = group.attrs['atomic_weight_ratio']\n return cls(primary_flag, energy, awr)\n\n @classmethod\n def from_ace(cls, ace, idx):\n \"\"\"Generate discrete photon energy distribution from an ACE table\n\n Parameters\n ----------\n ace : openmc.data.ace.Table\n An ACE table\n idx : int\n Offset to read from in XSS array (default of zero)\n\n Returns\n -------\n openmc.data.DiscretePhoton\n Discrete photon energy distribution\n\n \"\"\"\n primary_flag = int(ace.xss[idx])\n energy = ace.xss[idx + 1]*EV_PER_MEV\n return cls(primary_flag, energy, ace.atomic_weight_ratio)\n\n\nclass LevelInelastic(EnergyDistribution):\n r\"\"\"Level inelastic scattering\n\n Parameters\n ----------\n threshold : float\n Energy threshold in the laboratory system, :math:`(A + 1)/A * |Q|`\n mass_ratio : float\n :math:`(A/(A + 1))^2`\n\n Attributes\n ----------\n threshold : float\n Energy threshold in the laboratory system, :math:`(A + 1)/A * |Q|`\n mass_ratio : float\n :math:`(A/(A + 1))^2`\n\n \"\"\"\n\n def __init__(self, threshold, mass_ratio):\n super(LevelInelastic, self).__init__()\n self.threshold = threshold\n self.mass_ratio = mass_ratio\n\n @property\n def threshold(self):\n return self._threshold\n\n @property\n def mass_ratio(self):\n return self._mass_ratio\n\n @threshold.setter\n def threshold(self, threshold):\n cv.check_type('level inelastic threhsold', threshold, Real)\n self._threshold = threshold\n\n @mass_ratio.setter\n def mass_ratio(self, mass_ratio):\n cv.check_type('level inelastic mass ratio', mass_ratio, Real)\n self._mass_ratio = mass_ratio\n\n def to_hdf5(self, group):\n \"\"\"Write distribution to an HDF5 group\n\n Parameters\n ----------\n group : h5py.Group\n HDF5 group to write to\n\n \"\"\"\n\n group.attrs['type'] = np.string_('level')\n group.attrs['threshold'] = self.threshold\n group.attrs['mass_ratio'] = self.mass_ratio\n\n @classmethod\n def from_hdf5(cls, group):\n \"\"\"Generate level inelastic distribution from HDF5 data\n\n Parameters\n ----------\n group : h5py.Group\n HDF5 group to read from\n\n Returns\n -------\n openmc.data.LevelInelastic\n Level inelastic scattering distribution\n\n \"\"\"\n threshold = group.attrs['threshold']\n mass_ratio = group.attrs['mass_ratio']\n return cls(threshold, mass_ratio)\n\n @classmethod\n def from_ace(cls, ace, idx):\n \"\"\"Generate level inelastic distribution from an ACE table\n\n Parameters\n ----------\n ace : openmc.data.ace.Table\n An ACE table\n idx : int\n Offset to read from in XSS array (default of zero)\n\n Returns\n -------\n openmc.data.LevelInelastic\n Level inelastic scattering distribution\n\n \"\"\"\n threshold = ace.xss[idx]*EV_PER_MEV\n mass_ratio = ace.xss[idx + 1]\n return cls(threshold, mass_ratio)\n\n\nclass ContinuousTabular(EnergyDistribution):\n \"\"\"Continuous tabular distribution\n\n Parameters\n ----------\n breakpoints : Iterable of int\n Breakpoints defining interpolation regions\n interpolation : Iterable of int\n Interpolation codes\n energy : Iterable of float\n Incoming energies at which distributions exist\n energy_out : Iterable of openmc.stats.Univariate\n Distribution of outgoing energies corresponding to each incoming energy\n\n Attributes\n ----------\n breakpoints : Iterable of int\n Breakpoints defining interpolation regions\n interpolation : Iterable of int\n Interpolation codes\n energy : Iterable of float\n Incoming energies at which distributions exist\n energy_out : Iterable of openmc.stats.Univariate\n Distribution of outgoing energies corresponding to each incoming energy\n\n \"\"\"\n\n def __init__(self, breakpoints, interpolation, energy, energy_out):\n super(ContinuousTabular, self).__init__()\n self.breakpoints = breakpoints\n self.interpolation = interpolation\n self.energy = energy\n self.energy_out = energy_out\n\n @property\n def breakpoints(self):\n return self._breakpoints\n\n @property\n def interpolation(self):\n return self._interpolation\n\n @property\n def energy(self):\n return self._energy\n\n @property\n def energy_out(self):\n return self._energy_out\n\n @breakpoints.setter\n def breakpoints(self, breakpoints):\n cv.check_type('continuous tabular breakpoints', breakpoints,\n Iterable, Integral)\n self._breakpoints = breakpoints\n\n @interpolation.setter\n def interpolation(self, interpolation):\n cv.check_type('continuous tabular interpolation', interpolation,\n Iterable, Integral)\n self._interpolation = interpolation\n\n @energy.setter\n def energy(self, energy):\n cv.check_type('continuous tabular incoming energy', energy,\n Iterable, Real)\n self._energy = energy\n\n @energy_out.setter\n def energy_out(self, energy_out):\n cv.check_type('continuous tabular outgoing energy', energy_out,\n Iterable, Univariate)\n self._energy_out = energy_out\n\n def to_hdf5(self, group):\n \"\"\"Write distribution to an HDF5 group\n\n Parameters\n ----------\n group : h5py.Group\n HDF5 group to write to\n\n \"\"\"\n\n group.attrs['type'] = np.string_('continuous')\n\n dset = group.create_dataset('energy', data=self.energy)\n dset.attrs['interpolation'] = np.vstack((self.breakpoints,\n self.interpolation))\n\n # Determine total number of (E,p) pairs and create array\n n_pairs = sum(len(d) for d in self.energy_out)\n pairs = np.empty((3, n_pairs))\n\n # Create array for offsets\n offsets = np.empty(len(self.energy_out), dtype=int)\n interpolation = np.empty(len(self.energy_out), dtype=int)\n n_discrete_lines = np.empty(len(self.energy_out), dtype=int)\n j = 0\n\n # Populate offsets and pairs array\n for i, eout in enumerate(self.energy_out):\n n = len(eout)\n offsets[i] = j\n\n if isinstance(eout, Mixture):\n discrete, continuous = eout.distribution\n n_discrete_lines[i] = m = len(discrete)\n interpolation[i] = 1 if continuous.interpolation == 'histogram' else 2\n pairs[0, j:j+m] = discrete.x\n pairs[1, j:j+m] = discrete.p\n pairs[2, j:j+m] = discrete.c\n pairs[0, j+m:j+n] = continuous.x\n pairs[1, j+m:j+n] = continuous.p\n pairs[2, j+m:j+n] = continuous.c\n else:\n if isinstance(eout, Tabular):\n n_discrete_lines[i] = 0\n interpolation[i] = 1 if eout.interpolation == 'histogram' else 2\n elif isinstance(eout, Discrete):\n n_discrete_lines[i] = n\n interpolation[i] = 1\n pairs[0, j:j+n] = eout.x\n pairs[1, j:j+n] = eout.p\n pairs[2, j:j+n] = eout.c\n j += n\n\n # Create dataset for distributions\n dset = group.create_dataset('distribution', data=pairs)\n\n # Write interpolation as attribute\n dset.attrs['offsets'] = offsets\n dset.attrs['interpolation'] = interpolation\n dset.attrs['n_discrete_lines'] = n_discrete_lines\n\n @classmethod\n def from_hdf5(cls, group):\n \"\"\"Generate continuous tabular distribution from HDF5 data\n\n Parameters\n ----------\n group : h5py.Group\n HDF5 group to read from\n\n Returns\n -------\n openmc.data.ContinuousTabular\n Continuous tabular energy distribution\n\n \"\"\"\n interp_data = group['energy'].attrs['interpolation']\n energy_breakpoints = interp_data[0, :]\n energy_interpolation = interp_data[1, :]\n energy = group['energy'].value\n\n data = group['distribution']\n offsets = data.attrs['offsets']\n interpolation = data.attrs['interpolation']\n n_discrete_lines = data.attrs['n_discrete_lines']\n\n energy_out = []\n n_energy = len(energy)\n for i in range(n_energy):\n # Determine length of outgoing energy distribution and number of\n # discrete lines\n j = offsets[i]\n if i < n_energy - 1:\n n = offsets[i+1] - j\n else:\n n = data.shape[1] - j\n m = n_discrete_lines[i]\n\n # Create discrete distribution if lines are present\n if m > 0:\n eout_discrete = Discrete(data[0, j:j+m], data[1, j:j+m])\n eout_discrete.c = data[2, j:j+m]\n p_discrete = eout_discrete.c[-1]\n\n # Create continuous distribution\n if m < n:\n interp = INTERPOLATION_SCHEME[interpolation[i]]\n eout_continuous = Tabular(data[0, j+m:j+n], data[1, j+m:j+n], interp)\n eout_continuous.c = data[2, j+m:j+n]\n\n # If both continuous and discrete are present, create a mixture\n # distribution\n if m == 0:\n eout_i = eout_continuous\n elif m == n:\n eout_i = eout_discrete\n else:\n eout_i = Mixture([p_discrete, 1. - p_discrete],\n [eout_discrete, eout_continuous])\n energy_out.append(eout_i)\n\n return cls(energy_breakpoints, energy_interpolation,\n energy, energy_out)\n\n @classmethod\n def from_ace(cls, ace, idx, ldis):\n \"\"\"Generate continuous tabular energy distribution from ACE data\n\n Parameters\n ----------\n ace : openmc.data.ace.Table\n ACE table to read from\n idx : int\n Index in XSS array of the start of the energy distribution data\n (LDIS + LOCC - 1)\n ldis : int\n Index in XSS array of the start of the energy distribution block\n (e.g. JXS[11])\n\n Returns\n -------\n openmc.data.ContinuousTabular\n Continuous tabular energy distribution\n\n \"\"\"\n # Read number of interpolation regions and incoming energies\n n_regions = int(ace.xss[idx])\n n_energy_in = int(ace.xss[idx + 1 + 2*n_regions])\n\n # Get interpolation information\n idx += 1\n if n_regions > 0:\n breakpoints = ace.xss[idx:idx + n_regions].astype(int)\n interpolation = ace.xss[idx + n_regions:idx + 2*n_regions].astype(int)\n else:\n breakpoints = np.array([n_energy_in])\n interpolation = np.array([2])\n\n # Incoming energies at which distributions exist\n idx += 2*n_regions + 1\n energy = ace.xss[idx:idx + n_energy_in]*EV_PER_MEV\n\n # Location of distributions\n idx += n_energy_in\n loc_dist = ace.xss[idx:idx + n_energy_in].astype(int)\n\n # Initialize variables\n energy_out = []\n\n # Read each outgoing energy distribution\n for i in range(n_energy_in):\n idx = ldis + loc_dist[i] - 1\n\n # intt = interpolation scheme (1=hist, 2=lin-lin)\n INTTp = int(ace.xss[idx])\n intt = INTTp % 10\n n_discrete_lines = (INTTp - intt)//10\n if intt not in (1, 2):\n warn(\"Interpolation scheme for continuous tabular distribution \"\n \"is not histogram or linear-linear.\")\n intt = 2\n\n n_energy_out = int(ace.xss[idx + 1])\n data = ace.xss[idx + 2:idx + 2 + 3*n_energy_out].copy()\n data.shape = (3, n_energy_out)\n data[0,:] *= EV_PER_MEV\n\n # Create continuous distribution\n eout_continuous = Tabular(data[0][n_discrete_lines:],\n data[1][n_discrete_lines:]/EV_PER_MEV,\n INTERPOLATION_SCHEME[intt])\n eout_continuous.c = data[2][n_discrete_lines:]\n\n # If discrete lines are present, create a mixture distribution\n if n_discrete_lines > 0:\n eout_discrete = Discrete(data[0][:n_discrete_lines],\n data[1][:n_discrete_lines])\n eout_discrete.c = data[2][:n_discrete_lines]\n if n_discrete_lines == n_energy_out:\n eout_i = eout_discrete\n else:\n p_discrete = min(sum(eout_discrete.p), 1.0)\n eout_i = Mixture([p_discrete, 1. - p_discrete],\n [eout_discrete, eout_continuous])\n else:\n eout_i = eout_continuous\n\n energy_out.append(eout_i)\n\n return cls(breakpoints, interpolation, energy, energy_out)\n", "meta": {"hexsha": "c3740beaf0c9e9bbd8bafab8e3891433190617f3", "size": 37230, "ext": "py", "lang": "Python", "max_stars_repo_path": "openmc/data/energy_distribution.py", "max_stars_repo_name": "ethanio12345/OpenMC", "max_stars_repo_head_hexsha": "3b0c044974c59773dac4e3ce261a87e18fc53de5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "openmc/data/energy_distribution.py", "max_issues_repo_name": "ethanio12345/OpenMC", "max_issues_repo_head_hexsha": "3b0c044974c59773dac4e3ce261a87e18fc53de5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "openmc/data/energy_distribution.py", "max_forks_repo_name": "ethanio12345/OpenMC", "max_forks_repo_head_hexsha": "3b0c044974c59773dac4e3ce261a87e18fc53de5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.0859375, "max_line_length": 86, "alphanum_fraction": 0.5788611335, "include": true, "reason": "import numpy", "num_tokens": 8648, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.600188359260205, "lm_q2_score": 0.33111973962899144, "lm_q1q2_score": 0.19873421324659063}} {"text": "# -*- coding: utf-8 -*-\n\"\"\"\nThis module allows the analysis of surface-based molecular cavities in various\nvolumes. To do so, a volume and a list of atom positions and their cutoff radii\nis required. The following example shows reading the first frame of a ``xyz``\nfile (using the ``pybel`` module), defining a hexagonal volume and moving all\natoms into this volume.\n\n.. code-block:: python\n :emphasize-lines: 7,10\n\n import pybel\n\n atoms = pybel.readfile(\"xyz\", \"hexagonal.xyz\").next().atoms\n num_atoms = len(atoms)\n atom_positions = [atom.coords for atom in atoms]\n\n volume = volumes.HexagonalVolume(17.68943, 22.61158)\n for atom_index in range(num_atoms):\n atom_positions[atom_index] = volume.get_equivalent_point(atom_positions[atom_index])\n atoms = Atoms(atom_positions, [2.8]*num_atoms)\n\nAfter this, a discretization of the volume is needed. This module supports\ncaching of these with the ``DiscretizationCache`` class.\n\n.. code-block:: python\n\n discretization_cache = DiscretizationCache('cache.hdf5')\n discretization = discretization_cache.get_discretization(volume, 192)\n\nUsing this ``discretization`` and the ``Atoms`` object created above, the atom\npositions and their cutoff radii are also discretized.\n\n.. code-block:: python\n\n atom_discretization = AtomDiscretization(atoms, discretization)\n\nWith these objects created, all preparations are complete and the domain and\ncavity calculation can be done:\n\n.. code-block:: python\n\n domain_calculation = DomainCalculation(discretization, atom_discretization)\n cavity_calculation = CavityCalculation(domain_calculation)\n\nAdditionally, calculation of center-based cavities is possible by passing an\nadditional parameter to the CavityCalculation:\n\n.. code-block:: python\n\n cavity_calculation = CavityCalculation(domain_calculation,\n use_surface_points=False)\n\nThe FakeDomainCalculation class provides a drop-in replacement for the\ndomain_calculation object in case the results of a previous calculation need to\nbe used (this is possible as only those attributes which are stored are\nactually used during center-based cavity calculation, which is not the case for\nsurface-based cavity calculations, which at least require the surface point\nlists).\n\nThe CalculationResults class provides a container for the results and allows\nstorage to and retrieval from HDF5 files. These files have several groups which\ncontain the relevant information.\n\nAuthor: Florian Rhiem \n\"\"\"\nfrom math import pi as PI\nimport sys\nimport numpy as np\n\nfrom computation.split_and_merge.pipeline import start_split_and_merge_pipeline\nfrom computation.split_and_merge.algorithm import ObjectType\nfrom core.calculation.gyrationtensor import calculate_gyration_tensor_parameters\nfrom util.message import print_message\nfrom extension import atomstogrid, mark_cavities, cavity_triangles, cavity_intersections\n\n\ndimension = 3\ndimensions = range(dimension)\n\n\nclass DomainCalculation:\n \"\"\"\n Cavity domain calulation is performed by the following steps:\n 1. A grid is created with the resolution defined in the volume\n discretization and filled with zeros.\n 2. For each atom, all points in the grid closer to this atom than the\n discrete cavity cutoff radius are set to a point indicating the atom\n index (atom_index+1).\n 3. At this point, every point in the grid which is inside of the volume\n and still has a value of zero is part of a cavity domain. To find these\n domains, an optimized split and merge algorithm is applied to the whole\n grid. It returns the center and surface points of each cavity domain\n (points with a neighbor outside of the cavity domain) stored in lists.\n Points inside of a domain are marked with a negative value indicating\n which domain they are part of.\n \"\"\"\n\n def __init__(self, discretization, atom_discretization):\n # step 1\n self.discretization = discretization\n self.atom_discretization = atom_discretization\n self.grid = np.zeros(self.discretization.d, dtype=np.int64)\n\n # step 2\n atomstogrid(self.grid,\n self.atom_discretization.discrete_positions,\n self.atom_discretization.atoms.radii_as_indices,\n self.atom_discretization.sorted_discrete_radii,\n [(0, 0, 0)] + self.discretization.combined_translation_vectors,\n self.discretization.grid)\n # step 3\n result = start_split_and_merge_pipeline(self.grid,\n self.discretization.grid,\n self.atom_discretization.discrete_positions,\n self.discretization.combined_translation_vectors,\n self.discretization.get_translation_vector,\n ObjectType.DOMAIN)\n self.centers, translated_areas, non_translated_areas, self.surface_point_list, self.cyclic_area_indices = result\n print_message(\"Number of domains:\", len(self.centers))\n\n self.domain_volumes = []\n self.critical_domains = [] # count of very small domains -> domains that can disappear on cutoff radius changes\n for domain_index in range(len(self.centers)):\n current_cell_sum = (self.grid == -(domain_index + 1)).sum()\n if current_cell_sum == 1:\n self.critical_domains.append(domain_index)\n domain_volume = current_cell_sum * (self.discretization.s_step ** 3)\n self.domain_volumes.append(domain_volume)\n\n self.characteristic_radii = [(0.75 * volume / PI)**(1.0/3.0) for volume in self.domain_volumes]\n\n if translated_areas:\n gyration_tensor_parameters = tuple(calculate_gyration_tensor_parameters(area) for area in translated_areas)\n (self.mass_centers, self.squared_gyration_radii, self.asphericities,\n self.acylindricities, self.anisotropies) = zip(*gyration_tensor_parameters)\n self.mass_centers = [self.discretization.discrete_to_continuous(point, result_inside_volume=True)\n for point in self.mass_centers]\n self.squared_gyration_radii = [self.discretization.discrete_to_continuous(value, unit_exponent=2)\n for value in self.squared_gyration_radii]\n else:\n (self.mass_centers, self.squared_gyration_radii, self.asphericities,\n self.acylindricities, self.anisotropies) = 5*([], )\n\n self.triangles()\n\n def triangles(self):\n if hasattr(self, \"domain_triangles\"):\n return self.domain_triangles\n number_of_domains = len(self.centers)\n print_message(\"Number of domains:\", number_of_domains)\n triangles = []\n surface_areas = []\n step = (self.discretization.s_step,) * 3\n offset = self.discretization.discrete_to_continuous((0, 0, 0))\n for domain_index in range(number_of_domains):\n print_message(\"Calculating triangles for domain\", domain_index)\n vertices, normals, surface_area = cavity_triangles(\n self.grid,\n [domain_index],\n 1, step, offset,\n self.discretization.grid)\n triangles.append((vertices, normals))\n surface_areas.append(surface_area)\n\n self.domain_triangles = triangles\n self.domain_surface_areas = surface_areas\n return triangles\n\n\nclass CavityCalculation:\n \"\"\"\n Cavity domain calulation is performed by the following steps:\n 1. The discrete volume grid is divided into subgrid cells with a side\n length based on the maximum discrete cavity cutoff radius. For each\n subgrid, a tuple of three lists is stored (in self.sg).\n 2. The first list for each subgrid cell is filled with the atoms inside\n the cell (their 'real' positions, which might be outside of the\n volume).\n 3. The second and third lists are filled with surface points and their\n domain index. (These might also be moved with the translation vectors\n and might thereby also be outside of the volume.)\n 4. A new grid is created (grid3) and each point in this grid is set to\n zero if it is outside of the volume or part inside of the cavity cutoff\n radius of an atom, or a negative value if it is part of a cavity domain\n (see the domain calculation step 2 for this).\n 5. For each point which is inside the cavity cutoff radius of an\n atom, the nearest atom and the nearest domain surface point are found\n by using the neighbor subgrid cells. If a domain surface point is\n nearer than the nearest atom, than the point belongs to the cavity\n which this surface point belonged to and is marked with a negative\n value.\n 6. At this point, two cavities constructed from two cavity domains might\n actually be one multicavity. In this step, these are found and a list\n of multicavities is created.\n\n About the subgrid cells:\n If a point inside a subgrid cell was marked as 'near an atom' during the\n domain calculation, then the position of this atom must be either in the\n same cell or in one of the cell's neighbors. This is guaranteed, because\n the atom must be at most its on cavity cutoff radius away, and the subgrid\n cell size is the maximum cavity cutoff radius.\n\n\n To calculate center-based cavities, use a grid filled with zeros instead of\n resuing some values from the domain calculation grid and then iterate over\n the domain centers instead of the domain surface points.\n \"\"\"\n\n def __init__(self, domain_calculation, use_surface_points=True, gyration_tensor_parameters=False):\n self.domain_calculation = domain_calculation\n if use_surface_points:\n self.grid = self.domain_calculation.grid\n num_surface_points = sum(map(len, self.domain_calculation.surface_point_list))\n print_message(\"Number of surface points:\", num_surface_points)\n else:\n self.grid = None\n\n self.sg_cube_size = self.domain_calculation.atom_discretization.sorted_discrete_radii[0]\n if use_surface_points:\n domain_seed_point_lists = self.domain_calculation.surface_point_list\n else:\n domain_seed_point_lists = [[center] for center in self.domain_calculation.centers]\n\n discretization = self.domain_calculation.discretization\n atom_discretization = self.domain_calculation.atom_discretization\n\n # steps 1 to 5\n self.grid3 = mark_cavities(self.grid,\n discretization.grid,\n discretization.d,\n self.sg_cube_size,\n atom_discretization.discrete_positions,\n [(0, 0, 0)] + discretization.combined_translation_vectors,\n domain_seed_point_lists,\n use_surface_points)\n\n if gyration_tensor_parameters:\n result = start_split_and_merge_pipeline(self.grid3,\n discretization.grid,\n atom_discretization.discrete_positions,\n discretization.combined_translation_vectors,\n discretization.get_translation_vector,\n ObjectType.CAVITY)\n translated_areas, non_translated_areas, cyclic_area_indices = result\n\n num_domains = len(self.domain_calculation.centers)\n grid_volume = (discretization.grid == 0).sum()\n self.cavity_volumes = []\n for domain_index in range(num_domains):\n self.cavity_volumes.append(1.0 * (self.grid3 == -(domain_index + 1)).sum() * (discretization.s_step ** 3))\n self.characteristic_radii = [(0.75 * volume / PI)**(1.0/3.0) for volume in self.cavity_volumes]\n\n # step 6\n intersection_table = cavity_intersections(self.grid3, num_domains)\n multicavities = []\n cavity_to_neighbors = num_domains * [None]\n for domain in range(num_domains):\n current_neighbors = set([domain])\n for neighbor in range(num_domains):\n if intersection_table[domain][neighbor] == 1:\n current_neighbors.add(neighbor)\n for multicavity in multicavities[:]:\n if any([neighbor in multicavity for neighbor in current_neighbors]):\n current_neighbors = current_neighbors | multicavity\n multicavities.remove(multicavity)\n multicavities.append(current_neighbors)\n for neighbor in current_neighbors:\n cavity_to_neighbors[neighbor] = current_neighbors\n self.multicavities = multicavities\n self.multicavity_volumes = []\n for multicavity in multicavities:\n self.multicavity_volumes.append(sum(self.cavity_volumes[cavity_index] for cavity_index in multicavity))\n print_message(\"Multicavity volumes:\", self.multicavity_volumes)\n\n if gyration_tensor_parameters:\n def key_func(cavity_index):\n cavity_area = non_translated_areas[cavity_index]\n a_single_cavity_index = -self.grid3[cavity_area[0]] - 1\n max_neighbor_index = max(cavity_to_neighbors[a_single_cavity_index])\n return max_neighbor_index\n sorted_area_indices = sorted(range(len(self.multicavities)), key=key_func)\n sorted_translated_areas = [translated_areas[i] for i in sorted_area_indices]\n sorted_cyclic_area_indices = [i for i, index in enumerate(sorted_area_indices)\n if index in cyclic_area_indices]\n self.cyclic_area_indices = sorted_cyclic_area_indices\n\n if sorted_translated_areas:\n gyration_tensor_parameters = tuple(calculate_gyration_tensor_parameters(area)\n for area in sorted_translated_areas)\n (self.mass_centers, self.squared_gyration_radii, self.asphericities,\n self.acylindricities, self.anisotropies) = zip(*gyration_tensor_parameters)\n self.mass_centers = [discretization.discrete_to_continuous(point, result_inside_volume=True)\n for point in self.mass_centers]\n self.squared_gyration_radii = [discretization.discrete_to_continuous(value, unit_exponent=2)\n for value in self.squared_gyration_radii]\n else:\n (self.mass_centers, self.squared_gyration_radii, self.asphericities,\n self.acylindricities, self.anisotropies) = 5*([], )\n\n self.triangles()\n\n def squared_distance(self, a, b):\n '''\n Calculates the squared distance between two points while taking the\n translation vectors into account.\n '''\n sqd = sys.maxint\n for v in self.domain_calculation.discretization.combined_translation_vectors + [(0, 0, 0)]:\n sqd = min(sqd, sum([(a[i] - b[i] + v[i]) * (a[i] - b[i] + v[i]) for i in dimensions]))\n return sqd\n\n def triangles(self):\n if hasattr(self, \"cavity_triangles\"):\n return self.cavity_triangles\n step = (self.domain_calculation.discretization.s_step,) * 3\n offset = self.domain_calculation.discretization.discrete_to_continuous((0, 0, 0))\n triangles = []\n surface_areas = []\n for i, multicavity in enumerate(self.multicavities):\n print_message(\"Generating triangles for multicavity:\", i+1)\n vertices, normals, surface_area = cavity_triangles(\n self.grid3,\n multicavity,\n 4, step, offset,\n self.domain_calculation.discretization.grid)\n triangles.append((vertices, normals))\n surface_areas.append(surface_area)\n\n self.cavity_triangles = triangles\n self.cavity_surface_areas = surface_areas\n return cavity_triangles\n\n def __getattr__(self, attr):\n optional_attributes = ('mass_centers', 'squared_gyration_radii', 'asphericities', 'acylindricities',\n 'anisotropies', 'characteristic_radii', 'cyclic_area_indices')\n if attr in optional_attributes:\n return None\n else:\n return super(CavityCalculation, self).__getattr__(attr)\n\n\nclass FakeDomainCalculation(object):\n '''\n When calculating center-based cavities, a DomainCalculation object is\n required. This has to provide the domain central points, but not the surface\n points (as those are only needed for surface-based cavity calculation).\n Objects of this class can be used as a drop-in for 'real'\n DomainCalculations, e.g. when the required data is loaded from a file.\n '''\n\n def __init__(self, discretization, atom_discretization, results):\n self.centers = results.domains.centers\n self.discretization = discretization\n self.atom_discretization = atom_discretization\n", "meta": {"hexsha": "40f6e2e43bb045ad79a01e4c52916c17f32459c6", "size": 17511, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/core/calculation/algorithm.py", "max_stars_repo_name": "sciapp/pyMolDyn", "max_stars_repo_head_hexsha": "fba6ea91cb185f916b930cd25b4b1d28a22fb4c5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 11, "max_stars_repo_stars_event_min_datetime": "2016-10-25T09:48:36.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-30T18:59:50.000Z", "max_issues_repo_path": "src/core/calculation/algorithm.py", "max_issues_repo_name": "sciapp/pyMolDyn", "max_issues_repo_head_hexsha": "fba6ea91cb185f916b930cd25b4b1d28a22fb4c5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2017-09-19T06:03:36.000Z", "max_issues_repo_issues_event_max_datetime": "2017-09-28T11:29:23.000Z", "max_forks_repo_path": "src/core/calculation/algorithm.py", "max_forks_repo_name": "sciapp/pyMolDyn", "max_forks_repo_head_hexsha": "fba6ea91cb185f916b930cd25b4b1d28a22fb4c5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 49.1882022472, "max_line_length": 121, "alphanum_fraction": 0.6639826395, "include": true, "reason": "import numpy", "num_tokens": 3595, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.600188359260205, "lm_q2_score": 0.3311197330283893, "lm_q1q2_score": 0.19873420928498609}} {"text": "#!/usr/bin/env python\n\nimport datetime\nimport json\nimport math\nimport random\nimport sys\nfrom ipaddress import ip_address, ip_network\n\nimport numpy as np\nimport pytricia\nimport yaml\n\nimport networkx\n\nip_prefixes = pytricia.PyTricia()\n\nseed = hash(datetime.datetime.now())\nglobal_policy = {}\n\n\ndef read_topo(filename, local_policy=None):\n data = yaml.load(open(filename))\n G = networkx.Graph()\n nodes = data[\"nodes\"]\n links = data[\"links\"]\n for n in nodes:\n nid = nodes[n]['id']\n G.add_node(nid, name=n, **nodes[n])\n G.node[nid]['type'] = nodes[n]['type']\n G.node[nid]['ip-prefix'] = nodes[n].get('ip-prefix', [])\n G.node[nid]['routing'] = pytricia.PyTricia()\n G.node[nid]['fine_grained'] = pytricia.PyTricia()\n for prefix in nodes[n].get('ip-prefix', []):\n ip_prefixes[prefix] = nid\n for l in links:\n G.add_edge(*l)\n return G\n\n\nbgp_general_policy = networkx.shortest_path\n\n\n# FIXME: The generation algorithm does not make sense\n# Refer to the evaluation part of SDX and SIDR\ndef generate_local_policy(G, **args):\n \"\"\"\n Generate the local policy for each node in G.\n\n Args:\n G: graph.\n args: additional arguments to config the generation algorithm.\n\n Returns:\n The mapping from node id to a local_policy table.\n local_policy_table ::= Trie>\n \"\"\"\n global global_policy\n random.seed(seed)\n policies = dict()\n max_ports = 30\n for node in G.nodes():\n if node not in policies:\n policies[node] = pytricia.PyTricia()\n # FIXME: select prefix by following a distribution\n for prefix in G.node[node][\"ip-prefix\"]:\n # FIXME: select ports by following a distribution\n ports = set([\n random.randint(10000, 60000)\n for _ in range(random.randint(1, max_ports))\n ])\n for port in ports:\n policies[node][port] = random.choice(\n [i for i in G.neighbors(node)] + [None])\n global_policy = policies\n\n\nDEFAULT_SERVICE_TYPES = {21: 0.1, 80: 0.1, 2801: 0.2, 8444: 0.3, 8445: 0.3}\n\n\n# TODO: Some key points\n# - What's the distribution for policy type (blackhole/deflection) selection\n# - What's the distribution for node selection\n# - How many network we need to fwd\n# - What's the distribution for the tcp port selection\ndef generate_random_policy(G,\n service_types=DEFAULT_SERVICE_TYPES,\n network_ratio=0.5,\n prefix_ratio=0.2,\n policy_place='transit',\n policy_type='both',\n **args):\n \"\"\"\n Randomly setup black-hole or deflection policies in transit network\n\n Args:\n G: Topology\n service_types: supported service port distribution.\n network_ratio: how many networks is selected. default 0.5\n prefix_ratio: how many prefix is seleted. default: 0.2\n policy_place: transit, edge or both. default: 'transit'\n policy_type: blackhole, deflection or both. default: 'both'\n args: additional arguments.\n\n Returns:\n global local policy table.\n \"\"\"\n edge_networks = [\n n for n in G.nodes() if G.node[n].get('type', '') == 'edge'\n ]\n transit_networks = [\n n for n in G.nodes() if G.node[n].get('type', '') == 'transit'\n ]\n policies = {}\n if policy_place == 'transit':\n policy_networks = transit_networks\n elif policy_place == 'edge':\n policy_networks = edge_networks\n else:\n policy_networks = G.nodes()\n for d in policy_networks:\n if d not in policies:\n policies[d] = pytricia.PyTricia()\n for dest in random.sample([n for n in edge_networks if n != d],\n math.ceil(\n len(edge_networks) * float(network_ratio))):\n node_prefixes = G.node[dest]['ip-prefix']\n for prefix in random.sample(\n node_prefixes, math.ceil(\n len(node_prefixes) * float(prefix_ratio))):\n policies[d][prefix] = {\n port: gen_single_policy(G, d, dest, policy_type)\n for port in random.sample(service_types.keys(),\n random.randint(1, 4))\n }\n return policies\n\n\ndef gen_single_policy(G, d, dest, policy_type):\n if policy_type == 'both':\n return random.choice([None, random_deflection(G, d, dest)])\n elif policy_type == 'deflection':\n return random_deflection(G, d, dest)\n return None\n\n\ndef random_deflection(G, d, dest):\n next_hop = networkx.shortest_path(G, d, dest)[1]\n subG = G.copy()\n subG.remove_edge(d, next_hop)\n if dest not in networkx.descendants(subG, d):\n return None\n else:\n return networkx.shortest_path(subG, d, dest)[1]\n\n\ndef get_local_policy(node):\n \"\"\"\n local_policy is not a simple prefix based routing.\n\n For simplicity, assume the format of local_policy for each node is:\n\n local_policy ::= Trie>\n \"\"\"\n global global_policy\n return global_policy.get(node, pytricia.PyTricia())\n\n\ndef default_routing_policy(node,\n dst_ip,\n dst_port=None,\n src_ip=None,\n src_port=None,\n protocol='tcp',\n **args):\n \"\"\"\n Default routing policy for networks.\n\n Args:\n node: node id for the network.\n dst_ip: destination ip address.\n dst_port: optional.\n src_ip: optional.\n src_port: optional.\n protocol: optional.\n args: additional flow spec.\n\n Returns:\n The next hop of the give flow spec from this node.\n \"\"\"\n for prefix in node.get('ip-prefix', []):\n if ip_address(dst_ip) in ip_network(prefix):\n return None\n local_policy = get_local_policy(node['id'])\n if dst_ip in local_policy:\n local_policy_for_ip = local_policy[dst_ip]\n if dst_port in local_policy_for_ip:\n return local_policy_for_ip[dst_port]\n fg_routing = node['fine_grained']\n if dst_ip in fg_routing:\n fg_routing_for_ip = fg_routing[dst_ip]\n if dst_port in fg_routing_for_ip:\n return fg_routing_for_ip[dst_port]\n if dst_ip in node['routing']:\n return node['routing'][dst_ip]\n\n\ndef fp_bgp_convergence(G):\n \"\"\"\n False-positive BGP Convergence. node[\"routing\"] is the table of {ip-prefix -> next hop node}\n \"\"\"\n paths = networkx.shortest_path(G)\n for src in G.nodes:\n for dst in G.nodes:\n if src != dst:\n try:\n path = paths[src].get(dst)\n except KeyError:\n path = None\n if path:\n prefixes = G.node[dst]['ip-prefix']\n for hop, next_hop in zip(path[:-1], path[1:]):\n for prefix in prefixes:\n G.node[hop][\"routing\"][prefix] = next_hop\n\n\ndef all_fg_nodes(G, prefix):\n \"\"\"\n Let's assume the local_policy is generated from the prefixes of nodes first.\n \"\"\"\n # FIXME: If the granularity of prefixes in local_policy is different from ones in node, it will conduct error.\n fg_nodes = []\n for node in G.nodes:\n local = get_local_policy(node)\n if local.get(prefix):\n fg_nodes.append(node)\n return fg_nodes\n\n\ndef correct_bgp_convergence(G):\n \"\"\"\n Correct BGP Convergence\n \"\"\"\n for dst in G.nodes:\n prefixes = G.node[dst]['ip-prefix']\n for prefix in prefixes:\n H = G.copy()\n for node in all_fg_nodes(G, prefix):\n H.remove_node(node)\n paths = networkx.shortest_path(H)\n for src in H.nodes:\n if src != dst:\n # path = paths[src][dst]\n path = paths[src].get(dst, [])\n for hop, next_hop in zip(path[:-1], path[1:]):\n G.node[hop][\"routing\"][prefix] = next_hop\n\n\ndef find_fine_grained_routes(G, prefix_port):\n for prefix, ports in prefix_port.items():\n for port in ports:\n delete_nodes = set()\n delete_links = set()\n H = G.copy() # A copy of directed graph to modify links and nodes\n # Step 1: Remove unused links for \n for node in H.nodes:\n action = get_local_policy(node).get(prefix)\n if action and (port in action):\n action = action[port]\n if action:\n for neig in H.neighbors(node):\n if action != neig:\n delete_links.add((node, neig))\n else:\n delete_nodes.add(node)\n for edge in delete_links:\n H.remove_edge(*edge)\n for node in delete_nodes:\n H.remove_node(node)\n # Step 2: Find shortest path (Is it possible to be not found?)\n dst = ip_prefixes[prefix]\n paths = networkx.shortest_path(H, target=dst)\n # Step 3: Traverse the shortest path\n for src in H.nodes:\n if src != dst:\n path = paths.get(src)\n if path:\n for hop, next_hop in zip(path[:-1], path[1:]):\n if prefix not in G.node[hop][\"fine_grained\"]:\n G.node[hop][\"fine_grained\"][prefix] = dict()\n G.node[hop][\"fine_grained\"][prefix][port] = next_hop\n\n # Step 4: BGP shortest path in all nodes\n fp_bgp_convergence(G)\n return G\n\n\ndef fine_grained_announcement(G):\n for node in G.nodes:\n del G.node[node][\"routing\"]\n del G.node[node][\"fine_grained\"]\n G = G.to_directed()\n for node in G.nodes:\n G.node[node][\"routing\"] = pytricia.PyTricia()\n G.node[node][\"fine_grained\"] = pytricia.PyTricia()\n prefix_port = dict() # type: dict{str, set{int}}\n for node in G.nodes:\n local = get_local_policy(node)\n for prefix in local:\n ports_actions = local[prefix]\n if prefix not in prefix_port:\n prefix_port[prefix] = set()\n for port in ports_actions:\n prefix_port[prefix].add(port)\n return find_fine_grained_routes(G, prefix_port)\n\n\ndef read_flows(filename, port_dist=DEFAULT_SERVICE_TYPES):\n \"\"\"\n Examples:\n [{\n \"src_ip\": \"10.0.0.1\",\n \"src_port\": 22,\n \"dst_ip\": \"10.0.10.1\",\n \"dst_port\": 80,\n \"protocol\": \"tcp\",\n \"start_time\": 1516292713,\n \"end_time\": 1516313885,\n \"volume\": 4089456904\n }]\n\n required: src_ip, dst_ip, start_time, end_time, volume\n optional: src_port, dst_port, protocol\n \"\"\"\n data = json.load(open(filename))\n for d in data:\n if not d.get('dst_port', None):\n d['dst_port'] = int(np.random.choice(\n list(port_dist.keys()), p=list(port_dist.values())))\n # (d['src_ip'], d['dst_ip']) = (d['dst_ip'], d['src_ip'])\n return data\n\n\nstatistic_as_length = {}\n\n\ndef coarse_grained_correct_bgp(G, F):\n \"\"\"\n The principle of Correct BGP is very simple:\n\n For a specific IP p, compute the subgraph G' of G in which every node with local_policy covering p will not show.\n The final path of p is the shortest_path of subgraph G'.\n\n The Correct BGP MUST guarantee the local_policy NEVER be triggered.\n \"\"\"\n for flow in F:\n node = G.node[ip_prefixes[flow[\"src_ip\"]]]\n if node is not None:\n as_length = [node]\n prefixes = [ip_network(p) for p in node['ip-prefix']]\n while ip_address(flow[\"dst_ip\"]) not in prefixes:\n if len(node[\"fine_grained\"]) > 0:\n try:\n next_hop = node[\"fine_grained\"][flow[\"dst_ip\"]][\n \"dst_port\"]\n in_fg = True # In fine grained policy\n except KeyError:\n in_fg = False\n if not in_fg:\n next_hop = node[\"routing\"][flow[\"dst_ip\"]]\n as_length.append(next_hop)\n print(\"AS Length: %d\" % len(as_length))\n if len(as_length) not in statistic_as_length:\n statistic_as_length[len(as_length)] = 0\n statistic_as_length[len(as_length)] += 1\n\n\n# def match(ip, prefix):\n# return ip in prefix\n\n# TODO: No need, merge it with routing_policy\n# def compute_next_hop(flow, rib):\n# \"\"\"\n# Compute the next hop of the flow from RIB.\n#\n# Args:\n# flow: flow spec.\n# rib: the RIB table from the Graph node.\n#\n# Returns:\n# the next hop. (None if no route.)\n# \"\"\"\n# for rule in rib:\n# if match(flow['dst-ip'], rule):\n# return rib[rule]\n# return None\n\n\ndef check_path(flow, G, routing_policy=default_routing_policy, debug=False):\n \"\"\"\n Check the path of a given flow in the topology.\n\n Args:\n flow: The flow spec to check.\n G: The topology object.\n\n Returns:\n the AS-PATH length of the route.\n nan - no route\n inf - there is a loop\n \"\"\"\n if debug:\n path = []\n loop_remover = {}\n src = ip_prefixes[flow['src_ip']]\n dst = ip_prefixes[flow['dst_ip']]\n if src == dst:\n if debug:\n return 1, [src]\n return 1\n d = src\n if debug:\n path = [src]\n dn = routing_policy(G.node[src], **flow)\n path_len = 1\n while dn:\n loop_remover[d] = loop_remover.get(d, 0) + 1\n # print d, p, loop_remover\n if loop_remover[d] > 1:\n if debug:\n return math.inf, []\n return math.inf\n d = dn\n if debug:\n path.append(dn)\n dn = routing_policy(G.node[d], **flow)\n path_len += 1\n if d != dst:\n if debug:\n return math.nan, []\n return math.nan\n if debug:\n return path_len, path\n return path_len\n\n\ndebug_dict = {}\n\n\ndef check_reachability(G, F, max_len=10, debug=False, debug_num=None):\n as_length_dist = {}\n success_volume = 0\n unsuccess_volume = 0\n R_F = []\n for f in F:\n if debug:\n global debug_dict\n result, path = check_path(f, G, debug=True)\n if debug_num not in debug_dict:\n debug_dict[debug_num] = dict()\n debug_dict[debug_num][(f[\"src_ip\"], f[\"dst_ip\"], f[\"start_time\"],\n f[\"end_time\"], f[\"volume\"])] = (result, path)\n else:\n result = check_path(f, G)\n as_length_dist[result] = as_length_dist.get(result, 0) + 1\n if type(result) == float:\n unsuccess_volume += f['volume']\n elif result > 1:\n success_volume += f['volume']\n R_F.append(f)\n # print 'block_policies', 'deflection_policies'\n # print '%d\\t%d' % policy_summary(G)\n if debug:\n as_len_nan = as_length_dist.pop(math.nan) if math.nan in as_length_dist else 0\n as_lens = sorted(as_length_dist.keys())\n as_lens.append(math.nan)\n as_length_dist[math.nan] = as_len_nan\n print('\\t'.join([str(l) for l in as_lens]))\n print('\\t'.join([str(as_length_dist[l]) for l in as_lens]))\n as_len_pdf = []\n for al in range(max_len - 1):\n as_len_pdf.append(as_length_dist.get(al + 2, 0))\n as_len_pdf.append(as_length_dist.get(math.inf, 0))\n as_len_pdf.append(as_length_dist.get(math.nan, 0))\n as_len_pdf.append(success_volume)\n as_len_pdf.append(unsuccess_volume)\n # Format: flow_num from 2 to max_len, inf, nan, success_volume, unsuccess_volume\n print('\\t'.join([str(a) for a in as_len_pdf]))\n return R_F\n\n\nif __name__ == '__main__':\n if len(sys.argv) < 2:\n print(\"%s topo-filename flow-filename mode\" % sys.argv[0])\n topo_filename = sys.argv[1]\n flow_filename = sys.argv[2]\n mode = sys.argv[3]\n args = dict([tuple(k.split('=')) for k in sys.argv[4:]])\n\n G = read_topo(topo_filename)\n F = read_flows(flow_filename)\n # generate_local_policy(G)\n # global_policy = generate_random_policy(G, network_ratio=0.1, prefix_ratio=0.1, policy_type='blackhole')\n global_policy = generate_random_policy(G, **args)\n\n if '1' in mode:\n H = G.copy()\n fp_bgp_convergence(H)\n # print(\"FP_BGP:\")\n check_reachability(H, F)\n if '2' in mode:\n H = G.copy()\n correct_bgp_convergence(H)\n # print(\"C_BGP:\")\n R_F = check_reachability(H, F, debug=False, debug_num=2)\n if '3' in mode:\n H = G.copy()\n H = fine_grained_announcement(H)\n # print(\"SFP:\")\n check_reachability(H, F, debug=False, debug_num=3)\n if '4' in mode:\n H = G.copy()\n H = fine_grained_announcement(H)\n # print(\"Reachable-SFP:\")\n check_reachability(H, R_F, debug=False, debug_num=4)\n\n if len(debug_dict) > 0:\n flow_diff = list()\n for flow in debug_dict[3]:\n if debug_dict[3][flow][0] == math.nan and debug_dict[2][flow][0] != math.nan:\n print(str(flow))\n with open(\"debug.json\", 'w') as f:\n f.write(debug_dict.__str__())\n\n # coarse_grained_correct_bgp(G, F)\n # print(\"AS Length statistics: %d\" % statistic_as_length)\n", "meta": {"hexsha": "52cd8bc2905b88f6273e86ea5a908bc020e636a3", "size": 17666, "ext": "py", "lang": "Python", "max_stars_repo_path": "sfp_eval/bin/announcement_sim.py", "max_stars_repo_name": "openalto/network-simulator-data", "max_stars_repo_head_hexsha": "09706e5ab6e266ee5ef5b71cd32f10eea5a1975e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "sfp_eval/bin/announcement_sim.py", "max_issues_repo_name": "openalto/network-simulator-data", "max_issues_repo_head_hexsha": "09706e5ab6e266ee5ef5b71cd32f10eea5a1975e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "sfp_eval/bin/announcement_sim.py", "max_forks_repo_name": "openalto/network-simulator-data", "max_forks_repo_head_hexsha": "09706e5ab6e266ee5ef5b71cd32f10eea5a1975e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.8975791434, "max_line_length": 117, "alphanum_fraction": 0.5618702593, "include": true, "reason": "import numpy,import networkx", "num_tokens": 4223, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.600188359260205, "lm_q2_score": 0.33111972642778714, "lm_q1q2_score": 0.19873420532338149}} {"text": "#!/usr/bin/env python3\n# coding: utf-8\n\n__author__ = 'cleardusk'\n\n\"\"\"\nThe pipeline of 3DDFA prediction: given one image, predict the 3d face vertices, 68 landmarks and visualization.\n\n[todo]\n1. CPU optimization: https://pmchojnacki.wordpress.com/2018/10/07/slow-pytorch-cpu-performance\n\"\"\"\n\nimport torch\nimport torchvision.transforms as transforms\nimport mobilenet_v1\nimport numpy as np\nimport cv2\nimport os\nimport math\nfrom tqdm import tqdm\nimport time\n# import face_alignment\n# import single_align\nfrom utils.ddfa import ToTensorGjz, NormalizeGjz, str2bool\nimport scipy.io as sio\nfrom utils.inference import get_suffix, parse_roi_box_from_landmark, crop_img, predict_68pts, dump_to_ply, dump_vertex, \\\n draw_landmarks, predict_dense, parse_roi_box_from_bbox, get_colors, write_obj_with_colors, get_aligned_param, parse_quality_list_part\nfrom utils.cv_plot import plot_pose_box\nfrom utils.estimate_pose import parse_pose\nfrom utils.params import param_mean, param_std\nfrom utils.render import get_depths_image, cget_depths_image, cpncc, crender_colors\nfrom utils.paf import gen_img_paf\nimport argparse\nimport torch.backends.cudnn as cudnn\nfrom simple_dataset import McDataset\nfrom torch.utils.data import DataLoader\n\nSTD_SIZE = 120\n\n\ndef main(args):\n # 1. load pre-tained model\n checkpoint_fp = 'models/phase1_wpdc_vdc.pth.tar'\n arch = 'mobilenet_1'\n\n checkpoint = torch.load(checkpoint_fp, map_location=lambda storage, loc: storage)['state_dict']\n model = getattr(mobilenet_v1, arch)(num_classes=62) # 62 = 12(pose) + 40(shape) +10(expression)\n\n model_dict = model.state_dict()\n # because the model is trained by multiple gpus, prefix module should be removed\n for k in checkpoint.keys():\n model_dict[k.replace('module.', '')] = checkpoint[k]\n model.load_state_dict(model_dict)\n if args.mode == 'gpu':\n cudnn.benchmark = True\n model = model.cuda()\n model.eval()\n\n tri = sio.loadmat('visualize/tri.mat')['tri']\n transform = transforms.Compose([ToTensorGjz(), NormalizeGjz(mean=127.5, std=128)])\n\n if not os.path.exists(args.save_dir):\n os.mkdir(args.save_dir)\n\n # 2. parse images list and landmark\n lmk_file = args.lmk_file\n ts = time.time()\n rank_land, rank_img_list, start, end = parse_quality_list_part(lmk_file, args.world_size, args.rank, args.resume_idx)\n print('parse land file in {:.3f} seconds'.format(time.time() - ts))\n\n # for batch processing\n print('World size {}, rank {}, start from {}, end with {}'.format(args.world_size, args.rank, start, end))\n dataset = McDataset(rank_img_list, rank_land, transform=transform, std_size=STD_SIZE)\n dataloader = DataLoader(dataset, batch_size=args.batch_size, shuffle=False, num_workers=2, pin_memory=True)\n\n for img_idx, (inputs, ori_imgs, img_fps, roi_boxes) in enumerate(tqdm(dataloader)):\n\n # forward: one step\n with torch.no_grad():\n if args.mode == 'gpu':\n inputs = inputs.cuda()\n params = model(inputs)\n params = params.cpu().numpy()\n\n roi_boxes = roi_boxes.numpy()\n outputs_roi_boxes = roi_boxes\n if args.bbox_init == 'two':\n step_two_ori_imgs = []\n step_two_roi_boxes = []\n ori_imgs = ori_imgs.numpy()\n for ii in range(params.shape[0]):\n # 68 pts\n pts68 = predict_68pts(params[ii], roi_boxes[ii])\n\n # two-step for more accurate bbox to crop face\n roi_box = parse_roi_box_from_landmark(pts68)\n img_step2 = crop_img(ori_imgs[ii], roi_box)\n img_step2 = cv2.resize(img_step2, dsize=(STD_SIZE, STD_SIZE), interpolation=cv2.INTER_LINEAR)\n # input = transform(img_step2).unsqueeze(0)\n step_two_ori_imgs.append(transform(img_step2))\n step_two_roi_boxes.append(roi_box)\n with torch.no_grad():\n step_two_ori_imgs = torch.stack(step_two_ori_imgs, dim=0)\n inputs = step_two_ori_imgs\n if args.mode == 'gpu':\n inputs = inputs.cuda()\n params = model(inputs)\n params = params.cpu().numpy()\n outputs_roi_boxes = step_two_roi_boxes\n\n # dump results\n if args.dump_param:\n for img_fp, param, roi_box in zip(img_fps, params, outputs_roi_boxes):\n split = img_fp.split('/')\n save_name = os.path.join(args.save_dir, '{}.txt'.format(os.path.splitext(split[-1])[0]))\n this_param = param * param_std + param_mean\n this_param = np.concatenate((this_param, roi_box))\n this_param.tofile(save_name, sep=' ')\n\n\nif __name__ == '__main__':\n parser = argparse.ArgumentParser(description='3DDFA inference pipeline')\n parser.add_argument('-m', '--mode', default='gpu', type=str, help='gpu or cpu mode')\n parser.add_argument('--bbox_init', default='two', type=str,\n help='one|two: one-step bbox initialization or two-step')\n parser.add_argument('--dump_2d_img', default='false', type=str2bool, help='whether to save 3d rendered image')\n parser.add_argument('--dump_param', default='true', type=str2bool, help='whether to save param')\n parser.add_argument('--save_dir', default='results', type=str, help='dir to save result')\n parser.add_argument('--lmk_file', default='quality_list', type=str, help='landmarks file')\n parser.add_argument('--rank', default=0, type=int, help='used when parallel run')\n parser.add_argument('--world_size', default=1, type=int, help='used when parallel run')\n parser.add_argument('--resume_idx', default=0, type=int)\n parser.add_argument('--batch_size', default=80, type=int, help='batch size')\n\n args = parser.parse_args()\n main(args)\n\n", "meta": {"hexsha": "bbd297447fe0ebcb64071769bfca425f51a4a104", "size": 5835, "ext": "py", "lang": "Python", "max_stars_repo_path": "3ddfa/test.py", "max_stars_repo_name": "bruinxiong/Rotate-and-Render", "max_stars_repo_head_hexsha": "135d2b7b02ca4b3bdf7961b260466ff8b64bdb59", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 397, "max_stars_repo_stars_event_min_datetime": "2020-03-18T06:45:04.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-28T12:43:25.000Z", "max_issues_repo_path": "3ddfa/test.py", "max_issues_repo_name": "bruinxiong/Rotate-and-Render", "max_issues_repo_head_hexsha": "135d2b7b02ca4b3bdf7961b260466ff8b64bdb59", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 39, "max_issues_repo_issues_event_min_datetime": "2020-03-18T17:11:45.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-29T08:55:55.000Z", "max_forks_repo_path": "3ddfa/test.py", "max_forks_repo_name": "bruinxiong/Rotate-and-Render", "max_forks_repo_head_hexsha": "135d2b7b02ca4b3bdf7961b260466ff8b64bdb59", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 104, "max_forks_repo_forks_event_min_datetime": "2020-03-18T11:54:26.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-18T10:22:54.000Z", "avg_line_length": 42.2826086957, "max_line_length": 137, "alphanum_fraction": 0.6742073693, "include": true, "reason": "import numpy,import scipy", "num_tokens": 1395, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6001883449573377, "lm_q2_score": 0.3311197264277872, "lm_q1q2_score": 0.19873420058742006}} {"text": "#!/usr/bin/env python\n# coding: utf-8\n\nimport os\nimport sys\nimport subprocess\n\nfrom pathlib import Path\n\nimport csv\n\nimport numpy as np\n\nimport itk\nfrom itk import TubeTK as tube\n\n\ndef scv_is_bundled():\n return getattr(sys, 'frozen', False) and hasattr(sys, '_MEIPASS')\n\ndef scv_get_perfusion_toolbox_path():\n if scv_is_bundled():\n return os.path.join(sys._MEIPASS, 'StroCoVess', 'perfusion_toolbox')\n return os.path.join(os.path.dirname(os.path.realpath(__file__)),\n 'perfusion_toolbox')\n\n#################\n#################\n#################\n#################\n#################\ndef scv_convert_ctp_to_cta(filenames,\n report_progress=print,\n debug=False,\n output_dirname=\".\"):\n\n filenames.sort()\n num_images = len(filenames)\n\n base_im = itk.imread(filenames[num_images//2],itk.F)\n base_spacing = base_im.GetSpacing()\n\n progress_percent = 10\n report_progress(\"Reading images\",progress_percent)\n\n Dimension = 3\n PixelType = itk.ctype('float')\n ImageType = itk.Image[PixelType,Dimension]\n\n imdatamax = itk.GetArrayFromImage(base_im)\n imdatamin = imdatamax\n\n if output_dirname!=None and not os.path.exists(output_dirname):\n os.mkdir(output_dirname)\n\n progress_percent = 20\n progress_per_file = 70/num_images\n for imNum in range(num_images):\n imMoving = itk.imread(filenames[imNum],itk.F)\n if imMoving.shape != base_im.shape:\n resample = tube.ResampleImage.New(Input=imMoving)\n resample.SetMatchImage(base_im)\n resample.Update()\n imMovingIso = resample.GetOutput()\n progress_label = \"Resampling \"+str(imNum)+\" of \"+str(num_images)\n report_progress(progress_label,progress_percent)\n else:\n imMovingIso = imMoving\n imdataTmp = itk.GetArrayFromImage(imMovingIso)\n imdatamax = np.maximum(imdatamax,imdataTmp)\n imdataTmp = np.where(imdataTmp==-1024,imdatamin,imdataTmp)\n imdatamin = np.minimum(imdatamin,imdataTmp)\n progress_percent += progress_per_file\n progress_label = \"Integrating \"+str(imNum)+\" of \"+str(num_images)\n report_progress(progress_label,progress_percent)\n \n report_progress(\"Generating CT, CTA, and CTP\",90)\n\n ct = itk.GetImageFromArray(imdatamin)\n ct.CopyInformation(base_im)\n\n cta = itk.GetImageFromArray(imdatamax)\n cta.CopyInformation(base_im)\n\n diff = imdatamax-imdatamin\n diff[:4,:,:] = 0\n diff[-4:,:,:] = 0\n diff[:,:4,:] = 0\n diff[:,-4:,:] = 0\n diff[:,:,:4] = 0\n diff[:,:,-4:] = 0\n dsa = itk.GetImageFromArray(diff)\n dsa.CopyInformation(base_im)\n\n report_progress(\"Done\",100)\n return ct,cta,dsa\n\n\n#################\n#################\n#################\n#################\n#################\ndef scv_segment_brain_from_ct(ct_image,\n report_progress=print,\n debug=False):\n\n ImageType = itk.Image[itk.F,3]\n LabelMapType = itk.Image[itk.UC,3]\n\n report_progress(\"Threshold\",5)\n thresh = tube.ImageMath.New(Input=ct_image)\n thresh.IntensityWindow(-50,6000,0,6000)\n imgt = thresh.GetOutput()\n thresh.ReplaceValuesOutsideMaskRange(imgt,1,6000,0)\n thresh.ReplaceValuesOutsideMaskRange(imgt,0,700,1)\n tmpimg = thresh.GetOutput()\n thresh.ReplaceValuesOutsideMaskRange(tmpimg,0,1,2)\n ct_tmp = thresh.GetOutput()\n\n report_progress(\"Initial Mask\",10)\n maskMath = tube.ImageMath.New(Input=ct_tmp)\n # remove skin\n maskMath.Dilate(15,0,1)\n # shrink brain\n maskMath.Erode(6,2,0)\n # restore skull\n maskMath.ReplaceValueWithinMaskRange(ct_tmp,1,1,0,1)\n # shrink skull\n maskMath.Dilate(3,1,0)\n maskMath.Erode(1,1,0)\n comboSeed = maskMath.GetOutputUChar()\n \n report_progress(\"Connected Component\",20)\n segmenter = tube.SegmentConnectedComponentsUsingParzenPDFs[ImageType,\n LabelMapType].New()\n segmenter.SetFeatureImage( ct_image )\n segmenter.SetInputLabelMap( comboSeed )\n segmenter.SetObjectId( 2 )\n segmenter.AddObjectId( 1 )\n segmenter.SetVoidId( 0 )\n segmenter.SetErodeDilateRadius( 20 )\n segmenter.SetHoleFillIterations( 40 )\n segmenter.Update()\n segmenter.ClassifyImages()\n brainMaskRaw = segmenter.GetOutputLabelMap()\n\n report_progress(\"Masking\",60)\n\n maskMath = itk.CastImageFilter[LabelMapType, ImageType].New()\n maskMath.SetInput(brainMaskRaw)\n maskMath.Update()\n brainMaskF = maskMath.GetOutput()\n maskMath = tube.ImageMath.New(Input = brainMaskF)\n maskMath.Threshold(2,2,1,0)\n maskMath.Dilate(2,1,0)\n maskMath.Erode(3,1,0)\n brainMaskRaw2 = maskMath.GetOutputUChar()\n\n connComp = tube.SegmentConnectedComponents.New(Input=brainMaskRaw2)\n connComp.SetKeepOnlyLargestComponent(True)\n connComp.Update()\n brainMask = connComp.GetOutput()\n\n report_progress(\"Finishing\",90)\n cast = itk.CastImageFilter[LabelMapType,ImageType].New()\n cast.SetInput(brainMask)\n cast.Update()\n brainMaskF = cast.GetOutput()\n\n brainMath = tube.ImageMath[ImageType].New(Input=ct_image)\n brainMath.ReplaceValuesOutsideMaskRange( brainMaskF,1,1,-1024)\n ct_brain_image = brainMath.GetOutput()\n\n report_progress(\"Done\",100)\n return ct_brain_image, brainMask\n\n\n#################\n#################\n#################\n#################\n#################\ndef scv_enhance_vessels_in_cta(cta_image,\n cta_roi_image,\n report_progress=print,\n debug=False ):\n\n ImageType = itk.Image[itk.F,3]\n LabelMapType = itk.Image[itk.UC,3]\n\n report_progress(\"Masking\",5)\n imMath = tube.ImageMath.New(Input=cta_roi_image)\n imMath.Threshold( 0.00001,4000,1,0)\n imMath.Erode(10,1,0)\n imBrainMaskErode = imMath.GetOutput()\n imMath.SetInput(cta_roi_image)\n imMath.IntensityWindow(0,300,0,300)\n imMath.ReplaceValuesOutsideMaskRange(imBrainMaskErode,0.5,1.5,0)\n imBrainErode = imMath.GetOutput()\n\n spacing = cta_image.GetSpacing()[0]\n\n report_progress(\"Blurring\",10)\n imMath = tube.ImageMath[ImageType].New()\n imMath.SetInput(imBrainErode)\n imMath.Blur(1.5*spacing)\n imBlur = imMath.GetOutput()\n imBlurArray = itk.GetArrayViewFromImage(imBlur)\n\n report_progress(\"Generating Seeds\",20)\n numSeeds = 15\n seedCoverage = 20\n seedCoord = np.zeros([numSeeds,3])\n for i in range(numSeeds):\n seedCoord[i] = np.unravel_index(np.argmax(imBlurArray,\n axis=None),imBlurArray.shape)\n indx = [int(seedCoord[i][0]),int(seedCoord[i][1]),\n int(seedCoord[i][2])]\n minX = max(indx[0]-seedCoverage,0)\n maxX = max(indx[0]+seedCoverage,imBlurArray.shape[0])\n minY = max(indx[1]-seedCoverage,0)\n maxY = max(indx[1]+seedCoverage,imBlurArray.shape[1])\n minZ = max(indx[2]-seedCoverage,0)\n maxZ = max(indx[2]+seedCoverage,imBlurArray.shape[2])\n imBlurArray[minX:maxX,minY:maxY,minZ:maxZ]=0\n indx.reverse()\n seedCoord[:][i] = cta_roi_image.TransformIndexToPhysicalPoint(indx)\n\n report_progress(\"Segmenting Initial Vessels\",30)\n vSeg = tube.SegmentTubes.New(Input=cta_roi_image)\n vSeg.SetVerbose(debug)\n vSeg.SetMinRoundness(0.4)\n vSeg.SetMinCurvature(0.002)\n vSeg.SetRadiusInObjectSpace( 1 )\n for i in range(numSeeds):\n progress_label = \"Vessel \"+str(i)+\" of \"+str(numSeeds)\n progress_percent = i/numSeeds*20+30\n report_progress(progress_label,progress_percent)\n vSeg.ExtractTubeInObjectSpace( seedCoord[i],i )\n tubeMaskImage = vSeg.GetTubeMaskImage()\n\n imMath.SetInput(tubeMaskImage)\n imMath.AddImages(cta_roi_image,200,1)\n blendIm = imMath.GetOutput()\n\n report_progress(\"Computing Training Mask\",50)\n trMask = tube.ComputeTrainingMask[ImageType,LabelMapType].New()\n trMask.SetInput( tubeMaskImage )\n trMask.SetGap( 4 )\n trMask.SetObjectWidth( 1 )\n trMask.SetNotObjectWidth( 1 )\n trMask.Update()\n fgMask = trMask.GetOutput()\n\n report_progress(\"Enhancing Image\",70)\n enhancer = tube.EnhanceTubesUsingDiscriminantAnalysis[ImageType,\n LabelMapType].New()\n enhancer.AddInput( cta_image )\n enhancer.SetLabelMap( fgMask )\n enhancer.SetRidgeId( 255 )\n enhancer.SetBackgroundId( 128 )\n enhancer.SetUnknownId( 0 )\n enhancer.SetTrainClassifier(True)\n enhancer.SetUseIntensityOnly(True)\n enhancer.SetScales([0.75*spacing,2*spacing,6*spacing])\n enhancer.Update()\n enhancer.ClassifyImages()\n\n report_progress(\"Finalizing\",90)\n imMath = tube.ImageMath[ImageType].New()\n imMath.SetInput(enhancer.GetClassProbabilityImage(0))\n imMath.Blur(0.5*spacing)\n prob0 = imMath.GetOutput()\n imMath.SetInput(enhancer.GetClassProbabilityImage(1))\n imMath.Blur(0.5*spacing)\n prob1 = imMath.GetOutput()\n cta_vess = itk.SubtractImageFilter(Input1=prob0, Input2=prob1)\n\n imMath.SetInput(cta_roi_image)\n imMath.Threshold(0.0000001,2000,1,0)\n imMath.Erode(2,1,0)\n imBrainE = imMath.GetOutput()\n\n imMath.SetInput(cta_vess)\n imMath.ReplaceValuesOutsideMaskRange(imBrainE,1,1,-0.001)\n cta_roi_vess = imMath.GetOutput()\n\n report_progress(\"Done\",100)\n return cta_vess,cta_roi_vess\n\n\n#################\n#################\n#################\n#################\n#################\ndef scv_extract_vessels_from_cta(cta_image,\n cta_roi_vessels_image,\n report_progress=print,\n debug=False,\n output_dirname=\".\"):\n\n if output_dirname!=None and not os.path.exists(output_dirname):\n os.mkdir(output_dirname)\n\n spacing = cta_image.GetSpacing()[0]\n\n report_progress(\"Thresholding\",5)\n imMath = tube.ImageMath.New(cta_roi_vessels_image)\n imMath.MedianFilter(1)\n imMath.Threshold(0.00000001,9999,1,0)\n vess_mask_im = imMath.GetOutputShort()\n\n if debug and output_dirname!=None:\n itk.imwrite(vess_mask_im,\n output_dirname+\"/extract_vessels_mask.mha\",\n compression=True)\n\n report_progress(\"Connecting\",10)\n ccSeg = tube.SegmentConnectedComponents.New(vess_mask_im)\n ccSeg.SetMinimumVolume(50)\n ccSeg.Update()\n vess_mask_cc_im = ccSeg.GetOutput()\n\n if debug and output_dirname!=None:\n itk.imwrite(vess_mask_cc_im,\n output_dirname+\"/extract_vessels_mask_cc.mha\",\n compression=True)\n\n imMathSS = tube.ImageMath.New(vess_mask_cc_im)\n imMathSS.Threshold(0,0,1,0)\n vess_mask_inv_im = imMathSS.GetOutputFloat()\n \n report_progress(\"Filling in\",20)\n distFilter = itk.DanielssonDistanceMapImageFilter.New(vess_mask_inv_im)\n distFilter.Update()\n dist_map_im = distFilter.GetOutput()\n\n report_progress(\"Generating seeds\",30)\n imMath.SetInput(dist_map_im)\n imMath.Blur(0.5*spacing)\n tmp = imMath.GetOutput()\n # Distance map's distances are in index units, not spacing\n imMath.ReplaceValuesOutsideMaskRange(tmp,0.333,10,0)\n initial_radius_im = imMath.GetOutput()\n \n if debug and output_dirname!=None:\n itk.imwrite(initial_radius_im,\n output_dirname+\"/vessel_extraction_initial_radius.mha\",\n compression=True)\n\n report_progress(\"Generating input\",30)\n imMath.SetInput(cta_image)\n imMath.ReplaceValuesOutsideMaskRange(cta_roi_vessels_image,0,1000,0)\n imMath.Blur(0.4*spacing)\n imMath.NormalizeMeanStdDev()\n imMath.IntensityWindow(-4,4,0,1000)\n input_im = imMath.GetOutput()\n\n if debug and output_dirname!=None:\n itk.imwrite(input_im,\n output_dirname+\"/vessel_extraction_input.mha\",\n compression=True)\n\n report_progress(\"Extracting vessels\",40)\n vSeg = tube.SegmentTubes.New(Input=input_im)\n vSeg.SetVerbose(debug)\n vSeg.SetMinCurvature(0.0001) #0\n vSeg.SetMinRoundness(0.02)\n vSeg.SetMinRidgeness(0.5)\n vSeg.SetMinLevelness(0.0)\n vSeg.SetRadiusInObjectSpace( 0.8*spacing )\n vSeg.SetBorderInIndexSpace(3)\n vSeg.SetSeedMask( initial_radius_im )\n #vSeg.SetSeedRadiusMask( initial_radius_im )\n vSeg.SetOptimizeRadius(True)\n vSeg.SetUseSeedMaskAsProbabilities(True)\n vSeg.SetSeedExtractionMinimumProbability(0.95) #0.99\n vSeg.ProcessSeeds()\n\n report_progress(\"Finalizing\",90)\n tubeMaskImage = vSeg.GetTubeMaskImage()\n\n if debug and output_dirname!=None:\n itk.imwrite(tubeMaskImage,\n output_dirname+\"/vessel_extraction_output.mha\",\n compression=True)\n\n report_progress(\"Done\",100)\n return tubeMaskImage,vSeg.GetTubeGroup()\n\n#################\n#################\n#################\n#################\n#################\ndef scv_register_ctp_images(fixed_image_filename,\n moving_image_filenames,\n output_dirname,\n report_progress=print,\n debug=False):\n ImageType = itk.Image[itk.F,3]\n\n num_images = len(moving_image_filenames)\n progress_percent = 10\n progress_per_file = 70/num_images\n\n fixed_im = itk.imread(fixed_image_filename,itk.F)\n fixed_im_spacing = fixed_im.GetSpacing()\n if fixed_im_spacing[0] != fixed_im_spacing[1] or \\\n fixed_im_spacing[1] != fixed_im_spacing[2]:\n report_progress(\"Resampling\",progress_percent)\n resample = tube.ResampleImage.New(Input=fixed_im)\n resample.SetMakeIsotropic(True)\n resample.Update()\n fixed_im = resample.GetOutput()\n if debug:\n progress_label = \"DEBUG: Resampling to \"+str(\n fixed_im.GetSpacing())\n report_progress(progress_label,progress_percent)\n\n imMath = tube.ImageMath.New(fixed_im)\n imMath.Threshold(150,800,1,0)\n imMath.Dilate(10,1,0)\n mask_im = imMath.GetOutputUChar()\n mask_array = itk.GetArrayViewFromImage(mask_im)\n mask_array[:4,:,:] = 0\n mask_array[-4:,:,:] = 0\n mask_obj = itk.ImageMaskSpatialObject[3].New()\n mask_obj.SetImage(mask_im)\n mask_obj.Update()\n\n for imNum in range(num_images):\n progress_percent += progress_per_file\n progress_label = \"Registering \"+str(imNum)+\" of \"+str(num_images)\n report_progress(progress_label,progress_percent)\n \n if moving_image_filenames[imNum] != fixed_image_filename:\n moving_im = itk.imread(moving_image_filenames[imNum],itk.F)\n \n imreg = tube.RegisterImages[ImageType].New()\n imreg.SetFixedImage(fixed_im)\n imreg.SetMovingImage(moving_im)\n imreg.SetRigidMaxIterations(100)\n imreg.SetRegistration(\"RIGID\")\n imreg.SetExpectedOffsetMagnitude(5)\n imreg.SetExpectedRotationMagnitude(0.05)\n imreg.SetFixedImageMaskObject(mask_obj)\n imreg.SetUseEvolutionaryOptimization(False)\n if debug:\n imreg.SetReportProgress(True)\n imreg.Update()\n \n tfm = imreg.GetCurrentMatrixTransform()\n moving_reg_im = imreg.ResampleImage(\"SINC_INTERPOLATION\",\n moving_im,tfm,-1024)\n if output_dirname!=None:\n pname,fname = os.path.split(moving_image_filenames[imNum])\n rename_file_fname = os.path.splitext(fname)\n new_fname = str(rename_file_fname[0])+\"_reg.nii\"\n new_filename = os.path.join(output_dirname,new_fname)\n itk.imwrite(moving_reg_im,new_filename,compression=True)\n elif output_dirname!=None:\n pname,fname = os.path.split(moving_image_filenames[imNum])\n rename_file_fname = os.path.splitext(fname)\n new_fname = str(rename_file_fname[0])+\"_reg.nii\"\n new_filename = os.path.join(output_dirname,new_fname)\n itk.imwrite(moving_reg_im,new_filename,compression=True)\n report_progress(\"Done\",100)\n\n#################\n#################\n#################\n#################\n#################\ndef scv_register_atlas_to_image(atlas_im, atlas_mask_im, in_im):\n ImageType = itk.Image[itk.F,3]\n\n regAtlasToIn = tube.RegisterImages[ImageType].New(FixedImage=in_im,\n MovingImage=atlas_im)\n regAtlasToIn.SetReportProgress(True)\n regAtlasToIn.SetRegistration(\"PIPELINE_AFFINE\")\n regAtlasToIn.SetMetric(\"MATTES_MI_METRIC\")\n regAtlasToIn.SetInitialMethodEnum(\"INIT_WITH_IMAGE_CENTERS\")\n regAtlasToIn.Update()\n atlas_reg_im = regAtlasToIn.ResampleImage()\n atlas_mask_reg_im = regAtlasToIn.ResampleImage(\"NEAREST_NEIGHBOR\",\n atlas_mask_im)\n\n return atlas_reg_im,atlas_mask_reg_im\n\n#################\n#################\n#################\n#################\n#################\ndef scv_compute_atlas_region_stats(atlas_im,\n time_im,\n vess_im,\n number_of_time_bins=100,\n report_progress=print,\n debug=False):\n\n atlas_arr = itk.GetArrayFromImage(atlas_im)\n time_arr = itk.GetArrayFromImage(time_im)\n vess_arr = itk.GetArrayFromImage(vess_im)\n\n num_regions = int(atlas_arr.max())\n time_max = float(time_arr.max())\n time_min = float(time_arr.min())\n nbins = int(number_of_time_bins)\n time_factor = (time_max-time_min)/(nbins+1)\n print(\"Time range =\",time_min,\"-\",time_max)\n\n bin_value = np.zeros([num_regions,nbins])\n bin_count = np.zeros([num_regions,nbins])\n\n for atlas_region in range(num_regions):\n report_progress(\"Masking\",(atlas_region+1)*(100/num_regions))\n indx_arr = np.where(atlas_arr==atlas_region)\n indx_list = list(zip(indx_arr[0],indx_arr[1],indx_arr[2]))\n for indx in indx_list:\n time_bin = int((time_arr[indx]-time_min)/time_factor)\n time_bin = min(max(0,time_bin),nbins-1)\n if np.isnan(vess_arr[indx]) == False:\n bin_count[atlas_region,time_bin] += 1\n bin_value[atlas_region,time_bin] += vess_arr[indx]\n\n bin_label = np.arange(nbins) * time_factor - time_min\n bin_value = np.divide(bin_value,bin_count,where=bin_count!=0)\n\n report_progress(\"Done\",100)\n return bin_label,bin_value,bin_count\n\n#################\n#################\n#################\n#################\n#################\ndef scv_convert_3d_files_to_4d_file(in_filenames,out_filename):\n num_3d_files = len(in_filenames)\n\n ImageType = itk.Image[itk.F, 3]\n Write4D = tube.Write4DImageFrom3DImages[ImageType].New()\n Write4D.SetNumberOfInputImages(num_3d_files)\n Write4D.SetFileName(out_filename)\n for i,file in enumerate(in_filenames):\n img = itk.imread(file,itk.F)\n Write4D.SetNthInputImage(i, img)\n Write4D.Update()\n\n#################\n#################\n#################\n#################\n#################\ndef scv_prepare_3d_for_perfusion_toolbox(prep_3d_in_filenames,\n prep_3d_out_dirname,\n report_progress=print,\n report_subprogress=print,\n debug=False):\n num_3d_files = len(prep_3d_in_filenames)\n\n reg_fixed_image = prep_3d_in_filenames[num_3d_files//2]\n reg_in_filenames = prep_3d_in_filenames\n report_progress(\"Registering CTP\",40)\n scv_register_ctp_images(reg_fixed_image,\n reg_in_filenames,\n output_dirname=prep_3d_out_dirname,\n report_progress=report_subprogress,\n debug=debug)\n\n # update filenames to registered ctp\n report_progress(\"Saving 4D CTP\",60)\n new_ctp_3d_filenames = []\n for i in range(num_3d_files):\n file_path,file_name = os.path.split(prep_3d_in_filenames[i])\n rename_file_name = os.path.splitext(str(file_name))\n new_ctp_3d_filenames.append( os.path.realpath(os.path.join(\n prep_3d_out_dirname, str(rename_file_name[0]) + \"_reg.nii\")))\n\n # Write 4D ctp registered\n file_path,file_name = os.path.split(prep_3d_in_filenames[0])\n rename_file_name = os.path.splitext(str(file_name))\n ctp_base_filename = str(rename_file_name[0])\n\n ctp_filename = ctp_base_filename + \"-4D_reg.nii\"\n ctp_4d_out_filename = os.path.realpath(os.path.join(\n prep_3d_out_dirname, ctp_filename))\n scv_convert_3d_files_to_4d_file(new_ctp_3d_filenames,\n ctp_4d_out_filename)\n \n # Compute CT, CTA, DSA\n report_progress(\"Computing CT, CTA, DSA\",70)\n ct_im,cta_im,dsa_im = scv_convert_ctp_to_cta(new_ctp_3d_filenames,\n report_progress = report_subprogress,\n debug=debug,\n output_dirname=prep_3d_out_dirname)\n ct_filename = ctp_base_filename + \"_ct.nii\"\n ct_out_filename = os.path.realpath(os.path.join(\n prep_3d_out_dirname, ct_filename))\n itk.imwrite(ct_im, ct_out_filename,compression=True)\n cta_filename = ctp_base_filename + \"_cta.nii\"\n cta_out_filename = os.path.realpath(os.path.join(\n prep_3d_out_dirname, cta_filename))\n itk.imwrite(cta_im, cta_out_filename,compression=True)\n dsa_filename = ctp_base_filename + \"_dsa.nii\"\n dsa_out_filename = os.path.realpath(os.path.join(\n prep_3d_out_dirname, dsa_filename))\n itk.imwrite(dsa_im, dsa_out_filename,compression=True)\n\n # Segment brain from CT\n report_progress(\"Segmenting Brain\",80)\n ct_brain,mask_brain = scv_segment_brain_from_ct(ct_im,\n report_progress = report_subprogress,\n debug=debug)\n rename_file_ct = str(ct_filename)\n rename_file_ct = os.path.splitext(rename_file_ct)\n mask_brain_filename = str(rename_file_ct[0]) + \"_brain_mask.nii\"\n mask_brain_out_filename = os.path.realpath(os.path.join(\n prep_3d_out_dirname, mask_brain_filename))\n itk.imwrite(mask_brain, mask_brain_out_filename)\n\n report_progress(\"Done\",100)\n\n return ctp_4d_out_filename, ct_out_filename, \\\n cta_out_filename, dsa_out_filename, \\\n mask_brain_out_filename\n\n#################\n#################\n#################\n#################\n#################\ndef scv_prepare_4d_for_perfusion_toolbox(prep_4d_in_filename,\n prep_4d_out_dirname,\n report_progress=print,\n report_subprogress=print,\n debug=False):\n # convert 4D ctp to 3D images\n ctp_dirname,ctp_filename = os.path.split(prep_4d_in_filename)\n\n rename_file_ctp = os.path.splitext(str(ctp_filename))\n\n report_progress(\"Reading image\",10)\n\n img4d_im = itk.imread(prep_4d_in_filename, itk.F)\n img4d_array = itk.GetArrayFromImage(img4d_im)\n img4d_shape = img4d_array.shape\n img4d_spacing = np.array(img4d_im.GetSpacing())\n img4d_direction = np.array(img4d_im.GetDirection())\n img4d_origin = np.array(img4d_im.GetOrigin())\n img3d_spacing = img4d_spacing[0:3]\n img3d_origin = img4d_origin[0:3]\n img3d_direction = img4d_direction[0:3, 0:3]\n num_3d_files = img4d_shape[0]\n new_filenames = [] \n report_progress(\"Creating CTP\",15)\n subprogress = 15\n subprogress_per_file = 100 / num_3d_files\n for i in range(num_3d_files):\n report_subprogress(\"Writing\",\n subprogress+subprogress_per_file*i)\n tmp_filename = f'CTP_{i:03}.mha'\n new_filename = os.path.join(prep_4d_out_dirname,tmp_filename)\n img3d_array = img4d_im[i,:,:,:]\n img3d_im = itk.GetImageFromArray(img3d_array)\n img3d_im.SetSpacing(img3d_spacing)\n img3d_im.SetOrigin(img3d_origin)\n img3d_im.SetDirection(img3d_direction)\n itk.imwrite(img3d_im,new_filename,compression=True)\n new_filenames.append(new_filename)\n\n results = [new_filenames]\n results += scv_prepare_3d_for_perfusion_toolbox( new_filenames, \\\n prep_4d_out_dirname, report_progress, report_subprogress, debug)\n\n return results\n\n#################\n#################\n#################\n#################\n#################\ndef scv_fix_image_info(filename, match_image):\n im = itk.imread(filename,itk.F)\n im.SetSpacing(match_image.GetSpacing())\n im.SetOrigin(match_image.GetOrigin())\n im.SetDirection(match_image.GetDirection())\n itk.imwrite(im,filename,compression=True) \n \n#################\n#################\n#################\n#################\n#################\n#matlab -r \"addpath('./perfusion_toolbox');DSC_report('/data/UNC-Stroke/UNC/CTP/CTAT-001-PTO/CTAT-001-Perf-4D_reg.nii','/data/UNC-Stroke/UNC/CTP/CTAT-001-PTO/CTAT-001-Perf-4D_reg_ct_brain_mask.nii','./test');quit\"\ndef scv_run_perfusion_toolbox(ctp_4d_in_filename,\n ctp_mask_filename,\n perfusion_out_dirname):\n cmd = \"addpath('\"+scv_get_perfusion_toolbox_path()+\"');DSC_report('\"+ \\\n ctp_4d_in_filename+\"','\"+ctp_mask_filename+\"','\"+ \\\n perfusion_out_dirname+\"');quit\"\n subprocess.run([\"matlab\", \"-wait\", \"-r\", cmd])\n\n mask_image = itk.imread(ctp_mask_filename,itk.F)\n cbf_filename = os.path.join(perfusion_out_dirname,\"CBF_SVD.nii\")\n scv_fix_image_info(cbf_filename,mask_image)\n\n cbv_filename = os.path.join(perfusion_out_dirname, \"CBV.nii\")\n scv_fix_image_info(cbv_filename,mask_image)\n\n cbv_lc_filename = os.path.join(perfusion_out_dirname, \"CBV_LC.nii\")\n scv_fix_image_info(cbv_lc_filename,mask_image)\n\n mtt_filename = os.path.join(perfusion_out_dirname, \"MTT_SVD.nii\")\n scv_fix_image_info(mtt_filename,mask_image)\n\n tmax_filename = os.path.join(perfusion_out_dirname, \"Tmax_SVD.nii\")\n scv_fix_image_info(tmax_filename,mask_image)\n\n ttp_filename = os.path.join(perfusion_out_dirname, \"TTP.nii\")\n scv_fix_image_info(ttp_filename,mask_image)\n \n return cbf_filename,cbv_filename,mtt_filename,tmax_filename,ttp_filename\n\n \n#################\n#################\n#################\n#################\n#################\ndef scv_generate_vessel_report(ctp_3d_filenames,\n ctp_4d_filename,\n ct_filename,\n cta_fielname,\n dsa_filename,\n mask_brain_filename,\n atlas_path,\n report_out_dirname,\n report_progress=print,\n report_subprogress=print,\n debug=False):\n new_ctp_filenames = []\n base_3d_image = itk.imread(ctp_3d_filenames[0], itk.F)\n ImageMath = tube.ImageMath.New(base_3d_image)\n for filename in ctp_3d_filenames:\n img = itk.imread(filename, itk.F)\n ImageMath.SetInput(img)\n ImageMath.Blur(0.5)\n ImageMath.BlurOrder(2.0,0,2)\n new_img = ImageMath.GetOutput()\n Resample = tube.ResampleImage.New(Input=new_img)\n Resample.SetSpacing([1.5,1.5,5])\n Resample.SetInterpolator(\"Sinc\")\n Resample.Update()\n img = Resample.GetOutput()\n filename_path,filename_name = os.path.split(filename)\n org_filename = os.path.splitext(filename_name)\n base_filename = os.path.join(report_out_dirname,org_filename[0])\n new_filename = str(base_filename)+'_15x15x5.nii'\n itk.imwrite(img,new_filename,compression=True)\n new_ctp_filenames.append(new_filename)\n \n filename_path,filename_name = os.path.split(ctp_4d_filename)\n org_filename = os.path.splitext(filename_name)\n base_filename = os.path.join(report_out_dirname,org_filename[0])\n new_ctp_4d_filename = str(base_filename)+'_15x15x5.nii'\n scv_convert_3d_files_to_4d_file(new_ctp_filenames,\n new_ctp_4d_filename)\n\n match_image = itk.imread(new_ctp_filenames[0], itk.UC)\n mask = itk.imread(mask_brain_filename,itk.UC)\n ResampleMask = tube.ResampleImage.New(Input=mask)\n ResampleMask.SetMatchImage(match_image)\n ResampleMask.SetInterpolator(\"NearestNeighbor\")\n ResampleMask.Update()\n new_mask = ResampleMask.GetOutput()\n filename_path,filename_name = os.path.split(mask_brain_filename)\n org_filename = os.path.splitext(filename_name)\n base_filename = os.path.join(report_out_dirname,org_filename[0])\n new_mask_filename = str(base_filename)+'_15x15x5.nii'\n itk.imwrite(new_mask,new_mask_filename,compression=True)\n\n # Call matlab and pass it the 4D ctp filename and the output directory\n cbf_filename,cbv_filename,mtt_filename,tmax_filename,ttp_filename = \\\n scv_run_perfusion_toolbox(new_ctp_4d_filename, \\\n new_mask_filename, report_out_dirname)\n\n # Vessel enhancement and extraction\n in_im = itk.imread(dsa_filename, itk.F)\n\n in_filename_base = str(os.path.splitext(dsa_filename)[0])\n\n brain_mask_im = itk.imread(mask_brain_filename, itk.F)\n ImageMath.SetInput(in_im)\n ImageMath.ReplaceValuesOutsideMaskRange(brain_mask_im,0.9,1.1,0)\n in_brain_im = ImageMath.GetOutput()\n\n report_progress(\"Enhancing vessels\",40)\n # Enhancing vessels creates an image in which intensity is\n # related to \"vesselness\" instead of being related to the\n # amount of contrast agent in the vessel. This simplifies\n # subsequent vessel seeding and traversal stopping criteria.\n in_vess_im,in_brain_vess_im = scv_enhance_vessels_in_cta(\n in_im,\n in_brain_im,\n report_progress=report_subprogress,\n debug=debug)\n itk.imwrite(in_vess_im,\n os.path.join(report_out_dirname,\n in_filename_base+\"_vessels_enhanced.mha\"),\n compression=True)\n itk.imwrite(in_brain_vess_im,\n os.path.join(report_out_dirname,\n in_filename_base+\"_brain_vessels_enhanced.mha\"),\n compression=True)\n\n report_progress(\"Extracting vessels\",60)\n vess_mask_im,vess_so = scv_extract_vessels_from_cta(\n in_vess_im,\n in_brain_vess_im,\n report_progress=report_subprogress,\n debug=debug,\n output_dirname=report_out_dirname)\n\n itk.imwrite(in_brain_vess_im,\n os.path.join(report_out_dirname,\n in_filename_base+\"_vessels_extracted.mha\"),\n compression=True)\n\n SOWriter = itk.SpatialObjectWriter[3].New()\n SOWriter.SetInput(vess_so)\n SOWriter.SetBinaryPoints(True)\n SOWriter.SetFileName(os.path.join(report_out_dirname,\n in_filename_base+\"_vessels_extracted.tre\"))\n SOWriter.Update()\n\n VTPWriter = itk.WriteTubesAsPolyData.New()\n VTPWriter.SetInput(vess_so)\n VTPWriter.SetFileName(os.path.join(report_out_dirname,\n in_filename_base+\"_vessels_extracted.vtp\"))\n VTPWriter.Update()\n \n report_progress(\"Generating Perfusion Stats\",80)\n\n script_dirname = os.path.dirname(os.path.realpath(__file__))\n atlas_im = itk.imread(\n os.path.join(atlas_path,'atlas_brainweb.mha'), itk.F)\n atlas_mask_im = itk.imread(\n os.path.join(atlas_path,'atlas_brainweb_mask.mha'), itk.F)\n atlas_reg_im,atlas_mask_reg_im = scv_register_atlas_to_image(\n atlas_im,\n atlas_mask_im,\n in_brain_im)\n ImageMath = tube.ImageMath.New(Input=atlas_mask_reg_im)\n ImageMath.ReplaceValuesOutsideMaskRange(vess_mask_im,\n 0.000001,9999,4)\n ImageMath.ReplaceValuesOutsideMaskRange(in_brain_im,\n 0.000001,9999,0)\n vess_atlas_mask_im = ImageMath.GetOutput()\n itk.imwrite(vess_atlas_mask_im,\n os.path.join(report_out_dirname,\n in_filename_base+\"_vessels_atlas_mask.mha\"),\n compression=True)\n\n TubeMath = tube.TubeMath[3,itk.F].New()\n TubeMath.SetInputTubeGroup(vess_so)\n TubeMath.SetUseAllTubes()\n TubeMath.ComputeTubeRegions(vess_atlas_mask_im)\n \n graph_label = None\n graph_data = None\n ttp_im = None\n if len(ttp_filename) > 0:\n report_progress(\"Generating TTP Graphs\",92)\n ttp_im = itk.imread(ttp_filename, itk.F)\n Resample = tube.ResampleImage.New(Input=ttp_im)\n Resample.SetMatchImage(vess_atlas_mask_im)\n Resample.Update()\n fit_ttp_im = Resample.GetOutput()\n TubeMath.SetPointValuesFromImage(fit_ttp_im, \"TTP\")\n TubeMath.SetPointValuesFromTubeRegions(fit_ttp_im,\n \"TTP_Tissue\",\n 1.5,\n 4)\n TubeMath.SmoothTubeProperty(\"TTP\",4)\n TubeMath.SmoothTubeProperty(\"TTP_Tissue\",16)\n time_bin,ttp_bin,ttp_count = scv_compute_atlas_region_stats(\n vess_atlas_mask_im,\n fit_ttp_im,\n fit_ttp_im,\n 100,\n report_subprogress)\n graph_label = [\"Bin_Num\"]\n graph_data = np.arange(len(time_bin))\n graph_label = np.append(graph_label,\"TPP\")\n graph_data = np.stack((graph_data,time_bin))\n for r in range(1,ttp_bin.shape[0]):\n graph_label = np.append(graph_label,\n \"Count_Region_\"+str(r))\n graph_data = np.concatenate((graph_data,\n [ttp_count[r,:]]))\n\n if len(cbf_filename) > 0:\n report_progress(\"Generating CBF Graphs\",94)\n cbf_im = itk.imread(cbf_filename, itk.F)\n Resample = tube.ResampleImage.New(Input=cbf_im)\n Resample.SetMatchImage(vess_atlas_mask_im)\n Resample.Update()\n fit_cbf_im = Resample.GetOutput()\n TubeMath.SetPointValuesFromImage(fit_cbf_im, \"CBF\")\n TubeMath.SetPointValuesFromTubeRegions(fit_cbf_im,\n \"CBF_Tissue\",\n 1.5,\n 4)\n TubeMath.SmoothTubeProperty(\"CBF\",4)\n TubeMath.SmoothTubeProperty(\"CBF_Tissue\",16)\n if ttp_im!=None:\n time_bin,cbf_bin,cbf_count = scv_compute_atlas_region_stats(\n vess_atlas_mask_im,\n fit_ttp_im,\n fit_cbf_im,\n 100,\n report_subprogress)\n for r in range(1,cbf_bin.shape[0]):\n graph_label = np.append(graph_label,\n \"CBF_Region\"+str(r))\n graph_data = np.concatenate((graph_data,\n [cbf_bin[r,:]]))\n\n if len(cbv_filename) > 0:\n report_progress(\"Generating CBV Graphs\",96)\n cbv_im = itk.imread(cbv_filename, itk.F)\n Resample = tube.ResampleImage.New(Input=cbv_im)\n Resample.SetMatchImage(vess_atlas_mask_im)\n Resample.Update()\n fit_cbv_im = Resample.GetOutput()\n TubeMath.SetPointValuesFromImage(fit_cbv_im, \"CBV\")\n TubeMath.SetPointValuesFromTubeRegions(fit_cbv_im,\n \"CBV_Tissue\",\n 1.5,\n 4)\n TubeMath.SmoothTubeProperty(\"CBV\",4)\n TubeMath.SmoothTubeProperty(\"CBV_Tissue\",16)\n if ttp_im!=None:\n time_bin,cbv_bin,cbv_count = scv_compute_atlas_region_stats(\n vess_atlas_mask_im,\n fit_ttp_im,\n fit_cbv_im,\n 100,\n report_subprogress)\n for r in range(1,cbv_bin.shape[0]):\n graph_label = np.append(graph_label,\n \"CBV_Region\"+str(r))\n graph_data = np.concatenate((graph_data,\n [cbv_bin[r,:]]))\n if len(tmax_filename) > 0:\n report_progress(\"Generating TMax Graphs\",98)\n tmax_im = itk.imread(tmax_filename, itk.F)\n Resample = tube.ResampleImage.New(Input=tmax_im)\n Resample.SetMatchImage(vess_atlas_mask_im)\n Resample.Update()\n fit_tmax_im = Resample.GetOutput()\n TubeMath.SetPointValuesFromImage(fit_tmax_im, \"TMax\")\n TubeMath.SetPointValuesFromTubeRegions(fit_tmax_im,\n \"TMax_Tissue\",\n 1.5,\n 4)\n TubeMath.SmoothTubeProperty(\"TMax\",4)\n TubeMath.SmoothTubeProperty(\"TMax_Tissue\",16)\n if ttp_im!=None:\n time_bin,tmax_bin,tmax_count = scv_compute_atlas_region_stats(\n vess_atlas_mask_im,\n fit_ttp_im,\n fit_tmax_im,\n 100,\n report_subprogress)\n for r in range(1,tmax_bin.shape[0]):\n graph_label = np.append(graph_label,\n \"TMax_Region\"+str(r))\n graph_data = np.concatenate((graph_data,\n [tmax_bin[r,:]]))\n\n report_progress(\"Saving results\",99)\n SOWriter = itk.SpatialObjectWriter[3].New()\n SOWriter.SetInput(vess_so)\n SOWriter.SetBinaryPoints(True)\n SOWriter.SetFileName(os.path.join(report_out_dirname,\n in_filename_base+\"_vessels_extracted_perf.tre\"))\n SOWriter.Update()\n\n VTPWriter = itk.WriteTubesAsPolyData.New()\n VTPWriter.SetInput(vess_so)\n VTPWriter.SetFileName(os.path.join(report_out_dirname,\n in_filename_base+\"_vessels_extracted_perf.vtp\"))\n VTPWriter.Update()\n\n csvfilename = os.path.join(report_out_dirname,\n in_filename_base+\"_vessels_extracted_perf.csv\")\n csvfile = open(csvfilename,'w',newline='')\n csvwriter = csv.writer(csvfile, dialect='excel',\n quoting=csv.QUOTE_NONE)\n csvwriter.writerow(graph_label)\n for r in range(graph_data.shape[1]):\n csvwriter.writerow(['{:f}'.format(x) for x in graph_data[:,r]])\n csvfile.close()\n report_progress(\"Done\",100)\n\n\n#################\n#################\n#################\n#################\n#################\ndef scv_generate_4d_ctp_vessel_report(ctp_4d_filename,\n atlas_path,\n report_out_dirname,\n report_progress=print,\n report_subprogress=print,\n debug=False):\n\n ctp_3d_filenames,ctp_4d_filename,ct_filename, \\\n cta_filename,dsa_filename,mask_brain_filename \\\n = scv_prepare_4d_for_perfusion_toolbox( \\\n ctp_4d_filename, report_out_dirname, \\\n report_progress, report_subprogress, debug)\n\n\n scv_generate_vessel_report(ctp_3d_filenames, \\\n ctp_4d_filename,ct_filename, \\\n cta_filename,dsa_filename, \\\n mask_brain_filename,atlas_path,report_out_dirname, \\\n report_progress,report_subprogress,debug)\n\n\n#################\n#################\n#################\n#################\n#################\ndef scv_generate_3d_ctp_vessel_report(ctp_3d_filenames,\n atlas_path,\n report_out_dirname,\n report_progress=print,\n report_subprogress=print,\n debug=False):\n ctp_4d_filename,ct_filename, \\\n cta_filename,dsa_filename,mask_brain_filename \\\n = scv_prepare_3d_for_perfusion_toolbox( \\\n ctp_3d_filenames, report_out_dirname, \\\n report_progress, report_subprogress, debug)\n\n scv_generate_vessel_report(ctp_3d_filenames, \\\n ctp_4d_filename,ct_filename, \\\n cta_filename,dsa_filename, \\\n mask_brain_filename,atlas_path,report_out_dirname, \\\n report_progress,report_subprogress,debug)\n\n", "meta": {"hexsha": "016174205817146f177b9a3ccf351927971c965e", "size": 38951, "ext": "py", "lang": "Python", "max_stars_repo_path": "lib/StroCoVess_Lib.py", "max_stars_repo_name": "aylward/ITKTubeTK-StrokeCollateralVessels", "max_stars_repo_head_hexsha": "70379e65127b8a065e07d8a1ccb3cac8a7e6192e", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/StroCoVess_Lib.py", "max_issues_repo_name": "aylward/ITKTubeTK-StrokeCollateralVessels", "max_issues_repo_head_hexsha": "70379e65127b8a065e07d8a1ccb3cac8a7e6192e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2022-01-11T16:49:43.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-26T12:38:06.000Z", "max_forks_repo_path": "lib/StroCoVess_Lib.py", "max_forks_repo_name": "aylward/ITKTubeTK-StrokeCollateralVessels", "max_forks_repo_head_hexsha": "70379e65127b8a065e07d8a1ccb3cac8a7e6192e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2022-02-22T17:28:05.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-25T13:55:36.000Z", "avg_line_length": 36.7115928369, "max_line_length": 213, "alphanum_fraction": 0.6422684912, "include": true, "reason": "import numpy", "num_tokens": 9738, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5698526660244838, "lm_q2_score": 0.3486451488696663, "lm_q1q2_score": 0.19867636757988238}} {"text": "\"\"\"\nModule containing customized antenna classes for ARA.\n\nMany of the methods here mirror methods used in the antennas in AraSim, to\nensure that AraSim results can be matched.\n\n\"\"\"\n\nimport logging\nimport os.path\nimport pickle\nimport numpy as np\nimport scipy.constants\nimport scipy.signal\nfrom pyrex.internal_functions import (normalize, complex_bilinear_interp,\n complex_interp)\nfrom pyrex.signals import Signal, FunctionSignal\nfrom pyrex.antenna import Antenna\nfrom pyrex.detector import AntennaSystem\n\nlogger = logging.getLogger(__name__)\n\n\ndef _read_arasim_antenna_data(filename):\n \"\"\"\n Gather antenna directionality data from an AraSim-formatted data file.\n\n The data file should have columns for theta, phi, dB gain, non-dB gain, and\n phase (in degrees). This should be divided into sections for each frequency\n with a header line \"freq : X MHz\", optionally followed by a second line\n \"SWR : Y\".\n\n Parameters\n ----------\n filename : str\n Name of the data file.\n\n Returns\n -------\n response : ndarray\n 3-D array of complex-valued voltage gains as a function of frequency\n along axis 0, zenith along axis 1, and azimuth along axis 2.\n frequencies : ndarray\n Frequencies (Hz) corresponding to axis 0 of `response`.\n thetas : ndarray\n Zenith angles (degrees) corresponding to axis 1 of `response`.\n phis : ndarray\n Azimuth angles (degrees) corresponding to axis 2 of `response`.\n\n \"\"\"\n data = {}\n freqs = set()\n thetas = set()\n phis = set()\n freq = 0\n with open(filename) as f:\n for line in f:\n words = line.split()\n if line.startswith('freq'):\n freq = 1\n if words[-1]==\"Hz\":\n pass\n elif words[-1]==\"kHz\":\n freq *= 1e3\n elif words[-1]==\"MHz\":\n freq *= 1e6\n elif words[-1]==\"GHz\":\n freq *= 1e9\n else:\n raise ValueError(\"Cannot parse line: '\"+line+\"'\")\n freq *= float(words[-2])\n freqs.add(freq)\n elif line.startswith('SWR'):\n swr = float(words[-1])\n elif len(words)==5 and words[0]!=\"Theta\":\n theta = int(words[0])\n thetas.add(theta)\n phi = int(words[1])\n phis.add(phi)\n db_gain = float(words[2])\n # AraSim actually only seems to use the sqrt of the gain\n # (must be gain in power, not voltage)\n # gain = np.sqrt(float(words[3]))\n gain = np.sqrt(10**(db_gain/10))\n phase = np.radians(float(words[4]))\n data[(freq, theta, phi)] = (gain, phase)\n\n # Convert data dictionary into 3-D array of responses\n response = np.empty((len(freqs), len(thetas), len(phis)),\n dtype=np.complex_)\n for i, freq in enumerate(sorted(freqs)):\n for j, theta in enumerate(sorted(thetas)):\n for k, phi in enumerate(sorted(phis)):\n gain, phase = data[(freq, theta, phi)]\n response[i, j, k] = gain * np.exp(1j*phase)\n\n response_data = (response, np.array(sorted(freqs)),\n np.array(sorted(thetas)), np.array(sorted(phis)))\n return _fix_response_wrapping(response_data)\n\n\n# If the antenna responses don't go all the way to phi=360, add the extra\n# column for the sake of the interpolators\ndef _fix_response_wrapping(response_data):\n \"\"\"\n Add phi=360 degrees column to antenna response data.\n\n The interpolators require that the full azimuth range of the antennas is\n described, so this function duplicates the phi=0 column of the antenna\n response into a phi=360 column, as long as it matches with the rest of\n the phi spacings.\n\n Parameters\n ----------\n response_data : tuple of ndarray\n Tuple containing the response data for the antenna. The first element\n should contain a 3-D array of the antenna response model as a function\n of frequency (axis 0), zenith (axis 1), and azimuth (axis 2). The\n remaining elements should be the values of the frequency, zenith, and\n azimuth axes, respectively.\n\n Returns\n -------\n response : ndarray\n Corrected 3-D array of antenna response values, including the phi=360\n degree column if possible.\n frequencies : ndarray\n Frequencies (Hz) corresponding to axis 0 of `response`.\n thetas : ndarray\n Zenith angles (degrees) corresponding to axis 1 of `response`.\n phis : ndarray\n Azimuth angles (degrees) corresponding to axis 2 of `response`.\n\n \"\"\"\n response, freqs, thetas, phis = response_data\n if phis[-1]==360:\n return response_data\n if phis[0]==0 and phis[-1]==360-phis[1]:\n phis = np.concatenate((phis, [360]))\n response = np.concatenate((response, response[:, :, 0:1]), axis=2)\n return response, freqs, thetas, phis\n\n\ndef _read_arasim_antenna_pickle(filename):\n \"\"\"\n Gather antenna directional response data from a pickled data file.\n\n The data file should be a pickled file containing the antenna directional\n response data from an AraSim-formatted data file as returned by the\n `_read_arasim_antenna_data` function.\n\n Parameters\n ----------\n filename : str\n Name of the data file without the ``.pkl`` extension.\n\n Returns\n -------\n response : ndarray\n 3-D array of complex-valued voltage gains as a function of frequency\n along axis 0, zenith along axis 1, and azimuth along axis 2.\n frequencies : ndarray\n Frequencies (Hz) corresponding to axis 0 of `response`.\n thetas : ndarray\n Zenith angles (degrees) corresponding to axis 1 of `response`.\n phis : ndarray\n Azimuth angles (degrees) corresponding to axis 2 of `response`.\n\n See Also\n --------\n _read_arasim_antenna_data : Gather antenna directionality data from an\n AraSim-formatted data file.\n\n \"\"\"\n # Quick fix for filenames with one of the approved extensions already\n # (just strip it)\n if filename.endswith(\".txt\") or filename.endswith(\".pkl\"):\n filename = filename[:-4]\n\n # If there is no pickle file, read the response data using the\n # _read_arasim_antenna_data function, and then make a pickle file\n if not os.path.isfile(filename+\".pkl\"):\n logger.warning(\"Antenna model file %s.pkl not found. \"+\n \"Generating a new file now\", filename)\n response_data = _read_arasim_antenna_data(filename+\".txt\")\n with open(filename+\".pkl\", 'wb') as f:\n pickle.dump(response_data, f)\n return response_data\n\n # Otherwise, read from the pickle file\n else:\n with open(filename+\".pkl\", 'rb') as f:\n return pickle.load(f)\n\n\ndef _read_filter_data(filename):\n \"\"\"\n Gather frequency-dependent filtering data from a data file.\n\n The data file should have columns for frequency, non-dB gain, and phase\n (in radians).\n\n Parameters\n ----------\n filename : str\n Name of the data file.\n\n Returns\n -------\n gains : ndarray\n Complex-valued voltage gains as a function of frequency.\n frequencies : ndarray\n Frequencies (Hz) corresponding to the values of `gains`.\n\n \"\"\"\n gains = []\n freqs = []\n freq_scale = 0\n with open(filename) as f:\n for line in f:\n words = line.split()\n if line.startswith('Freq'):\n _, scale = words[0].split(\"(\")\n scale = scale.rstrip(\")\")\n if scale==\"Hz\":\n freq_scale = 1\n elif scale==\"kHz\":\n freq_scale = 1e3\n elif scale==\"MHz\":\n freq_scale = 1e6\n elif scale==\"GHz\":\n freq_scale = 1e9\n else:\n raise ValueError(\"Cannot parse line: '\"+line+\"'\")\n elif len(words)==3 and words[0]!=\"Total\":\n f, g, p = line.split(\",\")\n freq = float(f) * freq_scale\n gain = float(g)\n phase = float(p)\n freqs.append(freq)\n gains.append(gain * np.exp(1j*phase))\n\n return np.array(gains), np.array(freqs)\n\n\nARA_DATA_DIR = os.path.join(os.path.dirname(__file__), \"data\")\nVPOL_DATA_FILE = os.path.join(ARA_DATA_DIR,\n \"Vpol_original_CrossFeed_150mmHole_Ice_ARASim.txt\")\nHPOL_DATA_FILE = os.path.join(ARA_DATA_DIR,\n \"Hpol_original_150mmHole_Ice_ARASim.txt\")\nFILT_DATA_FILE = os.path.join(ARA_DATA_DIR,\n \"ARA_Electronics_TotalGain_TwoFilters.txt\")\n# Vpol data file contains only the theta responses\nVPOL_THETA_RESPONSE_DATA = _read_arasim_antenna_pickle(VPOL_DATA_FILE)\nVPOL_RESPONSE_DATA = (\n VPOL_THETA_RESPONSE_DATA[0],\n np.zeros(VPOL_THETA_RESPONSE_DATA[0].shape),\n *VPOL_THETA_RESPONSE_DATA[1:]\n)\n# Hpol data file contains only the phi responses\nHPOL_PHI_RESPONSE_DATA = _read_arasim_antenna_pickle(HPOL_DATA_FILE)\nHPOL_RESPONSE_DATA = (\n np.zeros(HPOL_PHI_RESPONSE_DATA[0].shape),\n *HPOL_PHI_RESPONSE_DATA\n)\nALL_FILTERS_DATA = _read_filter_data(FILT_DATA_FILE)\n\n\n\nclass ARAAntenna(Antenna):\n \"\"\"\n Antenna class to be used for ARA antennas.\n\n Stores the attributes of an antenna as well as handling receiving,\n processing, and storing signals and adding noise. Antenna response based on\n provided models.\n\n Parameters\n ----------\n response_data : tuple of array_like\n Tuple containing the response data for the antenna along the theta\n and phi polarization directions. The first and second elements should\n contain 3-D arrays of the antenna response model in the theta and phi\n polarizations, respectively, as a function of frequency (axis 0),\n zenith (axis 1), and azimuth (axis 2). The remaining elements should be\n the values of the frequency, zenith, and azimuth axes, respectively.\n position : array_like\n Vector position of the antenna.\n center_frequency : float\n Frequency (Hz) at the center of the antenna's frequency range.\n bandwidth : float\n Bandwidth (Hz) of the antenna.\n temperature : float\n The noise temperature (K) of the antenna. Used in combination with\n `resistance` to calculate the RMS voltage of the antenna noise.\n resistance : float\n The noise resistance (ohm) of the antenna. Used in combination with\n `temperature` to calculate the RMS voltage of the antenna noise.\n orientation : array_like, optional\n Vector direction of the z-axis of the antenna.\n efficiency : float, optional\n Antenna efficiency applied to incoming signal values.\n noisy : boolean, optional\n Whether or not the antenna should add noise to incoming signals.\n unique_noise_waveforms : int, optional\n The number of expected noise waveforms needed for each received signal\n to have its own noise.\n\n Attributes\n ----------\n position : array_like\n Vector position of the antenna.\n z_axis : ndarray\n Vector direction of the z-axis of the antenna.\n x_axis : ndarray\n Vector direction of the x-axis of the antenna.\n antenna_factor : float\n Antenna factor used for converting fields to voltages.\n efficiency : float\n Antenna efficiency applied to incoming signal values.\n noisy : boolean\n Whether or not the antenna should add noise to incoming signals.\n unique_noises : int\n The number of expected noise waveforms needed for each received signal\n to have its own noise.\n freq_range : array_like\n The frequency band in which the antenna operates (used for noise\n production).\n temperature : float or None\n The noise temperature (K) of the antenna. Used in combination with\n `resistance` to calculate the RMS voltage of the antenna noise.\n resistance : float or None\n The noise resistance (ohm) of the antenna. Used in combination with\n `temperature` to calculate the RMS voltage of the antenna noise.\n noise_rms : float or None\n The RMS voltage (V) of the antenna noise. If not ``None``, this value\n will be used instead of the RMS voltage calculated from the values of\n `temperature` and `resistance`.\n signals : list of Signal\n The signals which have been received by the antenna.\n is_hit\n is_hit_mc_truth\n waveforms\n all_waveforms\n\n See Also\n --------\n pyrex.Antenna : Base class for antennas.\n\n \"\"\"\n def __init__(self, response_data, position, center_frequency, bandwidth,\n temperature, resistance, orientation=(0,0,1), efficiency=1,\n noisy=True, unique_noise_waveforms=10):\n # Parse the response data\n self._theta_response = response_data[0]\n self._phi_response = response_data[1]\n self._response_freqs = response_data[2]\n self._response_zens = response_data[3]\n self._response_azis = response_data[4]\n\n # Get the critical frequencies in Hz\n f_low = center_frequency - bandwidth/2\n f_high = center_frequency + bandwidth/2\n\n # Get arbitrary x-axis orthogonal to orientation\n tmp_vector = np.zeros(3)\n while np.array_equal(np.cross(orientation, tmp_vector), (0,0,0)):\n tmp_vector = np.random.rand(3)\n ortho = np.cross(orientation, tmp_vector)\n # Note: ortho is not normalized, but will be normalized by Antenna's init\n\n super().__init__(position=position, z_axis=orientation, x_axis=ortho,\n efficiency=efficiency, freq_range=(f_low, f_high),\n temperature=temperature, resistance=resistance,\n noisy=noisy,\n unique_noise_waveforms=unique_noise_waveforms)\n\n def directional_gain(self, theta, phi):\n raise NotImplementedError(\"Directional gain is not defined for \"+\n self.__class__.__name__+\". Use the \"+\n \"directional_response method instead.\")\n\n def polarization_gain(self, polarization):\n raise NotImplementedError(\"Polarization gain is not defined for \"+\n self.__class__.__name__+\". Use the \"+\n \"directional_response method instead.\")\n\n def directional_response(self, theta, phi, polarization):\n \"\"\"\n Generate the (complex) frequency-dependent directional response.\n\n For given angles and polarization direction, use the model of the\n directional and polarization gains of the antenna to generate a\n function for the interpolated response of the antenna with respect to\n frequency. Used with the `frequency_response` method to calculate\n effective heights.\n\n Parameters\n ----------\n theta : float\n Polar angle (radians) from which a signal is arriving.\n phi : float\n Azimuthal angle (radians) from which a signal is arriving.\n polarization : array_like\n Normalized polarization vector in the antenna coordinate system.\n\n Returns\n -------\n function\n A function which returns complex-valued voltage gains for given\n frequencies, using the values of incoming angle and polarization.\n\n See Also\n --------\n ARAAntenna.frequency_response : Calculate the (complex) frequency\n response of the antenna.\n\n \"\"\"\n e_theta = [np.cos(theta) * np.cos(phi),\n np.cos(theta) * np.sin(phi),\n -np.sin(theta)]\n e_phi = [-np.sin(phi), np.cos(phi), 0]\n theta_factor = np.dot(polarization, e_theta)\n phi_factor = np.dot(polarization, e_phi)\n theta_gains = complex_bilinear_interp(\n x=np.degrees(theta), y=np.degrees(phi),\n xp=self._response_zens,\n yp=self._response_azis,\n fp=self._theta_response,\n method='cartesian'\n )\n phi_gains = complex_bilinear_interp(\n x=np.degrees(theta), y=np.degrees(phi),\n xp=self._response_zens,\n yp=self._response_azis,\n fp=self._phi_response,\n method='cartesian'\n )\n freq_interpolator = lambda frequencies: complex_interp(\n x=frequencies, xp=self._response_freqs,\n fp=theta_factor*theta_gains + phi_factor*phi_gains,\n method='euler', outer=0\n )\n return freq_interpolator\n\n def frequency_response(self, frequencies):\n \"\"\"\n Calculate the (complex) frequency response of the antenna.\n\n Rather than handling the entire frequency response of the antenna, this\n method is being used to convert the frequency-dependent gains from the\n `directional_response` method into effective heights.\n\n Parameters\n ----------\n frequencies : array_like\n 1D array of frequencies (Hz) at which to calculate gains.\n\n Returns\n -------\n array_like\n Complex gains in voltage for the given `frequencies`.\n\n See Also\n --------\n ARAAntenna.directional_response : Generate the (complex) frequency\n dependent directional response.\n\n \"\"\"\n # From AraSim GaintoHeight function, with gain calculation moved to\n # the directional_response method.\n # gain=4*pi*A_eff/lambda^2 and h_eff=2*sqrt(A_eff*Z_rx/Z_air)\n # Then 0.5 to calculate power with heff (cancels 2 above)\n heff = np.zeros(len(frequencies))\n # The index of refraction in this calculation should be the index of\n # the ice used in the production of the antenna model.\n n = 1.78\n heff[frequencies!=0] = np.sqrt((scipy.constants.c\n /frequencies[frequencies!=0]/n)**2\n * n*50/377 /(4*np.pi))\n return heff\n\n\n def apply_response(self, signal, direction=None, polarization=None,\n force_real=True):\n \"\"\"\n Process the complete antenna response for an incoming signal.\n\n Processes the incoming signal according to the frequency response of\n the antenna, the efficiency, and the antenna factor. May also apply the\n directionality and the polarization gain depending on the provided\n parameters. Subclasses may wish to overwrite this function if the\n full antenna response cannot be divided nicely into the described\n pieces.\n\n Parameters\n ----------\n signal : Signal\n Incoming ``Signal`` object to process.\n direction : array_like, optional\n Vector denoting the direction of travel of the signal as it reaches\n the antenna (in the global coordinate frame). If ``None`` no\n directional response will be applied.\n polarization : array_like, optional\n Vector denoting the signal's polarization direction (in the global\n coordinate frame). If ``None`` no polarization gain will be applied.\n force_real : boolean, optional\n Whether or not the frequency response should be redefined in the\n negative-frequency domain to keep the values of the filtered signal\n real.\n\n Returns\n -------\n Signal\n Processed ``Signal`` object after the complete antenna response has\n been applied. Should have a ``value_type`` of ``voltage``.\n\n Raises\n ------\n ValueError\n If the given `signal` does not have a ``value_type`` of ``voltage``\n or ``field``.\n\n See Also\n --------\n pyrex.Signal : Base class for time-domain signals.\n\n \"\"\"\n new_signal = signal.copy()\n new_signal.value_type = Signal.Type.voltage\n freq_response = self.frequency_response\n\n if direction is not None and polarization is not None:\n # Calculate theta and phi relative to the orientation\n origin = self.position - normalize(direction)\n r, theta, phi = self._convert_to_antenna_coordinates(origin)\n # Calculate polarization vector in the antenna coordinates\n y_axis = np.cross(self.z_axis, self.x_axis)\n transformation = np.array([self.x_axis, y_axis, self.z_axis])\n ant_pol = np.dot(transformation, normalize(polarization))\n # Calculate directional response as a function of frequency\n directive_response = self.directional_response(theta, phi, ant_pol)\n freq_response = lambda f: (self.frequency_response(f)\n * directive_response(f))\n\n elif (direction is not None and polarization is None\n or direction is None and polarization is not None):\n raise ValueError(\"Direction and polarization must be specified together\")\n\n # Apply (combined) frequency response\n new_signal.filter_frequencies(freq_response, force_real=force_real)\n\n signal_factor = self.efficiency\n\n if signal.value_type==Signal.Type.voltage:\n pass\n elif signal.value_type==Signal.Type.field:\n signal_factor /= self.antenna_factor\n else:\n raise ValueError(\"Signal's value type must be either \"\n +\"voltage or field. Given \"+str(signal.value_type))\n\n new_signal *= signal_factor\n\n return new_signal\n\n # Redefine receive method to use force_real as True by default\n def receive(self, signal, direction=None, polarization=None,\n force_real=True):\n \"\"\"\n Process and store one or more incoming (polarized) signals.\n\n Processes the incoming signal(s) according to the ``apply_response``\n method, then stores the total processed signal to the signals list. If\n more than one signal is given, they should be logically connected as\n separately polarized portions of the same signal.\n\n Parameters\n ----------\n signal : Signal or array_like\n Incoming ``Signal`` object(s) to process and store. May be separate\n polarization representations, but therefore should have the same\n times.\n direction : array_like, optional\n Vector denoting the direction of travel of the signal(s) as they\n reach the antenna (in the global coordinate frame). If ``None`` no\n directional gain will be applied.\n polarization : array_like, optional\n Vector(s) denoting the signal's polarization direction (in the\n global coordinate frame). Number of vectors should match the number\n of elements in `signal` argument. If ``None`` no polarization gain\n will be applied.\n force_real : boolean, optional\n Whether or not the frequency response should be redefined in the\n negative-frequency domain to keep the values of the filtered signal\n real.\n\n Raises\n ------\n ValueError\n If the number of polarizations does not match the number of signals.\n Or if the signals do not have the same `times` array.\n\n See Also\n --------\n pyrex.Signal : Base class for time-domain signals.\n\n \"\"\"\n super().receive(signal=signal, direction=direction,\n polarization=polarization,\n force_real=force_real)\n\n\n\nclass ARAAntennaSystem(AntennaSystem):\n \"\"\"\n Antenna system extending base ARA antenna with front-end processing.\n\n Applies as the front end a filter representing the full ARA electronics\n chain (including amplification) and signal clipping. Additionally provides\n a method for passing a signal through the tunnel diode.\n\n Parameters\n ----------\n response_data : tuple of array_like\n Tuple containing the response data for the antenna along the theta\n and phi polarization directions. The first and second elements should\n contain 3-D arrays of the antenna response model in the theta and phi\n polarizations, respectively, as a function of frequency (axis 0),\n zenith (axis 1), and azimuth (axis 2). The remaining elements should be\n the values of the frequency, zenith, and azimuth axes, respectively.\n name : str\n Name of the antenna.\n position : array_like\n Vector position of the antenna.\n power_threshold : float\n Power threshold for trigger condition. Antenna triggers if a signal\n passed through the tunnel diode exceeds this threshold times the noise\n RMS of the tunnel diode.\n orientation : array_like, optional\n Vector direction of the z-axis of the antenna.\n amplification : float, optional\n Amplification to be applied to the signal pre-clipping. Note that the\n usual ARA electronics amplification is already applied without this.\n amplifier_clipping : float, optional\n Voltage (V) above which the amplified signal is clipped (in positive\n and negative values).\n noisy : boolean, optional\n Whether or not the antenna should add noise to incoming signals.\n unique_noise_waveforms : int, optional\n The number of expected noise waveforms needed for each received signal\n to have its own noise.\n\n Attributes\n ----------\n antenna : Antenna\n ``Antenna`` object extended by the front end.\n name : str\n Name of the antenna.\n position : array_like\n Vector position of the antenna.\n power_threshold : float\n Power threshold for trigger condition. Antenna triggers if a signal\n passed through the tunnel diode exceeds this threshold times the noise\n RMS of the tunnel diode.\n amplification : float\n Amplification to be applied to the signal pre-clipping. Note that the\n usual ARA electronics amplification is already applied without this.\n amplifier_clipping : float\n Voltage (V) above which the amplified signal is clipped (in positive\n and negative values).\n lead_in_time : float\n Lead-in time (s) required for the front end to equilibrate.\n Automatically added in before calculation of signals and waveforms.\n is_hit\n is_hit_mc_truth\n signals\n waveforms\n all_waveforms\n\n See Also\n --------\n pyrex.AntennaSystem : Base class for antenna system with front-end\n processing.\n ARAAntenna : Antenna class to be used for ARA antennas.\n\n \"\"\"\n lead_in_time = 5e-9\n\n def __init__(self, response_data, name, position, power_threshold,\n orientation=(0,0,1), amplification=1, amplifier_clipping=1,\n noisy=True, unique_noise_waveforms=10,\n **kwargs):\n super().__init__(ARAAntenna)\n\n self.name = str(name)\n self.position = position\n\n self.amplification = amplification\n self.amplifier_clipping = amplifier_clipping\n\n self.setup_antenna(response_data=response_data,\n orientation=orientation, noisy=noisy,\n unique_noise_waveforms=unique_noise_waveforms,\n **kwargs)\n\n self.power_threshold = power_threshold\n self._power_mean = None\n self._power_std = None\n\n self._filter_response = ALL_FILTERS_DATA[0]\n self._filter_freqs = ALL_FILTERS_DATA[1]\n\n @property\n def _metadata(self):\n \"\"\"Metadata dictionary for writing `ARAAntennaSystem` information.\"\"\"\n meta = super()._metadata\n meta.update({\n \"name\": self.name,\n \"lead_in_time\": self.lead_in_time,\n \"amplification\": self.amplification,\n \"amplifier_clipping\": self.amplifier_clipping,\n \"power_threshold\": self.power_threshold,\n })\n return meta\n\n def setup_antenna(self, response_data, center_frequency=500e6,\n bandwidth=800e6, temperature=325, resistance=50,\n orientation=(0,0,1), efficiency=1, noisy=True,\n unique_noise_waveforms=10, **kwargs):\n \"\"\"\n Setup the antenna by passing along its init arguments.\n\n Any arguments passed to this method are directly passed to the\n ``__init__`` methods of the ``antenna``'s class.\n\n Parameters\n ----------\n response_data : tuple of array_like\n Tuple containing the response data for the antenna along the theta\n and phi polarization directions. The first and second elements\n should contain 3-D arrays of the antenna response model in the\n theta and phi polarizations, respectively, as a function of\n frequency (axis 0), zenith (axis 1), and azimuth (axis 2). The\n remaining elements should be the values of the frequency, zenith,\n and azimuth axes, respectively.\n center_frequency : float, optional\n Frequency (Hz) at the center of the antenna's frequency range.\n bandwidth : float, optional\n Bandwidth (Hz) of the antenna.\n temperature : float, optional\n The noise temperature (K) of the antenna. Used in combination with\n `resistance` to calculate the RMS voltage of the antenna noise.\n resistance : float, optional\n The noise resistance (ohm) of the antenna. Used in combination with\n `temperature` to calculate the RMS voltage of the antenna noise.\n orientation : array_like, optional\n Vector direction of the z-axis of the antenna.\n efficiency : float, optional\n Antenna efficiency applied to incoming signal values.\n noisy : boolean, optional\n Whether or not the antenna should add noise to incoming signals.\n unique_noise_waveforms : int, optional\n The number of expected noise waveforms needed for each received\n signal to have its own noise.\n\n \"\"\"\n # Noise rms should be about 40 mV (after filtering with gain of ~5000).\n # This is mostly satisfied by using the default noise temperature from\n # AraSim, 325 K, along with a 50 ohm resistance\n # Additionally, the bandwidth of the antenna is set slightly larger\n # than the nominal bandwidth of the true ARA antenna system (700 MHz),\n # but the extra frequencies should be killed by the front-end filter\n super().setup_antenna(response_data=response_data,\n position=self.position,\n center_frequency=center_frequency,\n bandwidth=bandwidth,\n temperature=temperature,\n resistance=resistance,\n orientation=orientation,\n efficiency=efficiency,\n noisy=noisy,\n unique_noise_waveforms=unique_noise_waveforms,\n **kwargs)\n\n # Tunnel diode response functions pulled from arasim\n _td_args = {\n 'down1': (-0.8, 15e-9, 2.3e-9, 0),\n 'down2': (-0.2, 15e-9, 4e-9, 0),\n 'up': (1, 18e-9, 7e-9, 1e9)\n }\n # Set td_args['up'][0] based on the other args, like in arasim\n _td_args['up'] = (-np.sqrt(2*np.pi) *\n (_td_args['down1'][0]*_td_args['down1'][2] +\n _td_args['down2'][0]*_td_args['down2'][2]) /\n (2e18*_td_args['up'][2]**3),) + _td_args['up'][1:]\n\n # Set \"down\" and \"up\" functions as in arasim\n @classmethod\n def _td_fdown1(cls, x):\n return (cls._td_args['down1'][3] + cls._td_args['down1'][0] *\n np.exp(-(x-cls._td_args['down1'][1])**2 /\n (2*cls._td_args['down1'][2]**2)))\n\n @classmethod\n def _td_fdown2(cls, x):\n return (cls._td_args['down2'][3] + cls._td_args['down2'][0] *\n np.exp(-(x-cls._td_args['down2'][1])**2 /\n (2*cls._td_args['down2'][2]**2)))\n\n @classmethod\n def _td_fup(cls, x):\n return (cls._td_args['up'][0] *\n (cls._td_args['up'][3] * (x-cls._td_args['up'][1]))**2 *\n np.exp(-(x-cls._td_args['up'][1])/cls._td_args['up'][2]))\n\n def tunnel_diode(self, signal):\n \"\"\"\n Calculate a signal as processed by the tunnel diode.\n\n The given signal is convolved with the tunnel diode response as in\n AraSim.\n\n Parameters\n ----------\n signal : Signal\n Signal to be processed by the tunnel diode.\n\n Returns\n -------\n Signal\n Signal output of the tunnel diode for the input `signal`.\n\n Raises\n ------\n ValueError\n If the input `signal` doesn't have a ``value_type`` of ``voltage``.\n\n Notes\n -----\n The tunnel diode response is based on the response parameterized in\n AraSim, as developed by ANITA [1]_.\n\n References\n ----------\n .. [1] A. Connolly & R. Nichol, ANITA Note #411, \"A Power-Based Time\n Domain Trigger Simulation.\"\n https://elog.phys.hawaii.edu/elog/anita_notes/080827_041639/powertrigger.pdf\n\n \"\"\"\n if signal.value_type!=Signal.Type.voltage:\n raise ValueError(\"Tunnel diode only accepts voltage signals\")\n t_max = 1e-7\n n_pts = int(t_max/signal.dt)\n times = np.linspace(0, t_max, n_pts+1)\n diode_resp = self._td_fdown1(times) + self._td_fdown2(times)\n t_slice = times>self._td_args['up'][1]\n diode_resp[t_slice] += self._td_fup(times[t_slice])\n conv = scipy.signal.convolve(signal.values**2 / self.antenna.resistance,\n diode_resp, mode='full')\n # Signal class will automatically only take the first part of conv,\n # which is what we want.\n # conv multiplied by dt so that the amplitude stays constant for\n # varying dts (determined empirically, see ARZAskaryanSignal comments)\n output = Signal(signal.times, conv*signal.dt,\n value_type=Signal.Type.power)\n return output\n\n def interpolate_filter(self, frequencies):\n \"\"\"\n Generate interpolated filter values for given frequencies.\n\n Calculate the interpolated values of the antenna system's filter gain\n data for some frequencies.\n\n Parameters\n ----------\n frequencies : array_like\n 1D array of frequencies (Hz) at which to calculate gains.\n\n Returns\n -------\n array_like\n Complex filter gain in voltage for the given `frequencies`.\n\n \"\"\"\n return complex_interp(\n x=frequencies, xp=self._filter_freqs, fp=self._filter_response,\n method='euler', outer=0\n )\n\n def front_end(self, signal):\n \"\"\"\n Apply front-end processes to a signal and return the output.\n\n The front-end consists of the full ARA electronics chain (including\n amplification) and signal clipping.\n\n Parameters\n ----------\n signal : Signal\n ``Signal`` object on which to apply the front-end processes.\n\n Returns\n -------\n Signal\n Signal processed by the antenna front end.\n\n \"\"\"\n base_signal = signal.copy()\n base_signal.filter_frequencies(self.interpolate_filter,\n force_real=True)\n # Apply sqrt(2) for 3dB splitter for TURF, SURF\n base_signal *= self.amplification / np.sqrt(2)\n clip_values = lambda times: np.clip(\n base_signal.with_times(times).values,\n a_min=-self.amplifier_clipping,\n a_max=self.amplifier_clipping\n )\n return FunctionSignal(signal.times, clip_values,\n value_type=signal.value_type)\n\n def trigger(self, signal):\n \"\"\"\n Check if the antenna system triggers on a given signal.\n\n Passes the signal through the tunnel diode. Then compares the maximum\n and minimum values to a tunnel diode noise signal. Triggers if one of\n the maximum or minimum values exceed the noise mean +/- the noise rms\n times the power threshold.\n\n Parameters\n ----------\n signal : Signal\n ``Signal`` object on which to test the trigger condition.\n\n Returns\n -------\n boolean\n Whether or not the antenna triggers on `signal`.\n\n \"\"\"\n if self._power_mean is None or self._power_std is None:\n # Prepare for antenna trigger by finding mean and standard\n # deviation of the full noise waveform convolved with the tunnel\n # diode response\n if len(self.antenna.signals)>0:\n times = self.antenna.signals[0].times\n else:\n times = signal.times\n n = len(times)\n dt = times[1]-times[0]\n duration = times[-1]-times[0] + dt\n full_times = np.linspace(0, duration*self.antenna.unique_noises,\n n*self.antenna.unique_noises)\n if self.antenna._noise_master is None:\n # Make sure the noise_master has the appropriate length\n # (automatically gets set to N*len(times) the first time it is\n # called, so make sure the first `times` is not the expanded\n # array but the single-signal array)\n self.antenna.make_noise(times)\n long_noise = self.antenna.make_noise(full_times)\n power_noise = self.tunnel_diode(self.front_end(long_noise))\n self._power_mean = np.mean(power_noise.values)\n self._power_std = np.std(power_noise.values)\n\n power_signal = self.tunnel_diode(signal)\n # Use the absolute value of the power_threshold value so that the value\n # can be specified as positive or negative (compatible with AraSim\n # which only works with negative values, resulting in some confusion)\n low_trigger = (self._power_mean -\n self._power_std*np.abs(self.power_threshold))\n return np.min(power_signal.values)= 51:\n return 'large'\n else:\n return \"small\"\n\n\ndef cca_img_bin(h, t, u, uth, metric):\n t = remove_tiny_les(t, nvox=2)\n h0 = h.copy()\n h = ndimage.binary_dilation(h, structure=ndimage.generate_binary_structure(3, 2))\n t_unc_labels = get_unc_labels(t, u, metric, 'y')\n h_unc_labels = get_unc_labels(h0, u, metric, 'x')\n\n labels = {}\n nles = {}\n labels['h'], nles['h'] = ndimage.label(h)\n labels['t'], nles['t'] = ndimage.label(t)\n found_h = np.ones(nles['h'], np.int16)\n ntp = {'all': 0, 'small': 0, 'med': 0, 'large': 0}\n nfp = {'all': 0, 'small': 0, 'med': 0, 'large': 0}\n nfn = {'all': 0, 'small': 0, 'med': 0, 'large': 0}\n nb_les = {'all': 0, 'small': 0, 'med': 0, 'large': 0}\n nles_gt = {'all': nles['t'], 'small': 0, 'med': 0, 'large': 0}\n for i in range(1, nles['t'] + 1):\n t_unc = np.max(t_unc_labels[labels['t'] == i])\n lesion_size = np.sum(t[labels['t'] == i])\n nles_gt[get_lesion_bin(lesion_size)] += 1\n if t_unc < uth:\n # list of detected lesions in this area\n h_lesions = np.unique(labels['h'][labels['t'] == i])\n # all the voxels in this area contribute to detecting the lesion\n nb_overlap = h[labels['t'] == i].sum()\n nb_les[get_lesion_bin(lesion_size)] += 1\n if nb_overlap >= 3 or nb_overlap >= 0.5 * lesion_size:\n ntp[get_lesion_bin(lesion_size)] += 1\n for h_lesion in h_lesions:\n if h_lesion != 0:\n found_h[h_lesion - 1] = 0\n else:\n nfn[get_lesion_bin(lesion_size)] += 1\n\n for i in range(1, nles['h'] + 1):\n if found_h[i - 1] == 1:\n h_unc = np.max(h_unc_labels[labels['h'] == i])\n if h_unc < uth:\n nb_vox = np.sum(h0[labels['h'] == i])\n nfp[get_lesion_bin(nb_vox)] += 1\n\n nb_les['all'] = nb_les['small'] + nb_les['med'] + nb_les['large']\n ntp['all'] = ntp['small'] + ntp['med'] + ntp['large']\n nfp['all'] = nfp['small'] + nfp['med'] + nfp['large']\n nfn['all'] = nfn['small'] + nfn['med'] + nfn['large']\n\n tpr = {}\n fdr = {}\n for s in ntp.keys():\n # tpr (sensitivity)\n if nb_les[s] != 0:\n tpr[s] = ntp[s] / nb_les[s]\n elif nb_les[s] == 0 and ntp[s] == 0:\n tpr[s] = 1\n else:\n tpr[s] = 0\n # ppv (1-fdr)\n if ntp[s] + nfp[s] != 0:\n ppv = ntp[s] / (ntp[s] + nfp[s])\n else:\n ppv = 1\n fdr[s] = 1 - ppv\n\n return {'ntp': ntp, 'nfp': nfp, 'nfn': nfn, 'fdr': fdr, 'tpr': tpr, 'nles': nb_les, 'nles_gt': nles_gt}\n\n\ndef cca_img(h, t, u, uth, metric):\n t = remove_tiny_les(t, nvox=2)\n h0 = h.copy()\n h = ndimage.binary_dilation(h, structure=ndimage.generate_binary_structure(3, 2))\n t_unc_labels = get_unc_labels(t, u, metric, 'y')\n h_unc_labels = get_unc_labels(h0, u, metric, 'x')\n\n labels = {}\n nles = {}\n labels['h'], nles['h'] = ndimage.label(h)\n labels['t'], nles['t'] = ndimage.label(t)\n found_h = np.ones(nles['h'], np.int16)\n ntp = {'all': 0, 'small': 0, 'med': 0, 'large': 0}\n nfp = {'all': 0, 'small': 0, 'med': 0, 'large': 0}\n nfn = {'all': 0, 'small': 0, 'med': 0, 'large': 0}\n nb_les = {'all': 0, 'small': 0, 'med': 0, 'large': 0}\n nles_gt = {'all': nles['t'], 'small': 0, 'med': 0, 'large': 0}\n for i in range(1, nles['t'] + 1):\n t_unc = np.max(t_unc_labels[labels['t'] == i])\n lesion_size = np.sum(t[labels['t'] == i])\n nles_gt[get_lesion_bin(lesion_size)] += 1\n if t_unc < uth:\n # list of detected lesions in this area\n h_lesions = np.unique(labels['h'][labels['t'] == i])\n # all the voxels in this area contribute to detecting the lesion\n nb_overlap = h[labels['t'] == i].sum()\n nb_les[get_lesion_bin(lesion_size)] += 1\n if nb_overlap >= 3 or nb_overlap >= 0.5 * lesion_size:\n ntp[get_lesion_bin(lesion_size)] += 1\n for h_lesion in h_lesions:\n if h_lesion != 0:\n found_h[h_lesion - 1] = 0\n else:\n nfn[get_lesion_bin(lesion_size)] += 1\n\n for i in range(1, nles['h'] + 1):\n if found_h[i - 1] == 1:\n h_unc = np.max(h_unc_labels[labels['h'] == i])\n if h_unc < uth:\n nb_vox = np.sum(h0[labels['h'] == i])\n nfp[get_lesion_bin(nb_vox)] += 1\n\n nb_les['all'] = nb_les['small'] + nb_les['med'] + nb_les['large']\n ntp['all'] = ntp['small'] + ntp['med'] + ntp['large']\n nfp['all'] = nfp['small'] + nfp['med'] + nfp['large']\n nfn['all'] = nfn['small'] + nfn['med'] + nfn['large']\n\n tpr = {}\n fdr = {}\n for s in ntp.keys():\n # tpr (sensitivity)\n if nb_les[s] != 0:\n tpr[s] = ntp[s] / nb_les[s]\n elif nb_les[s] == 0 and ntp[s] == 0:\n tpr[s] = 1\n else:\n tpr[s] = 0\n # ppv (1-fdr)\n if ntp[s] + nfp[s] != 0:\n ppv = ntp[s] / (ntp[s] + nfp[s])\n else:\n ppv = 1\n fdr[s] = 1 - ppv\n\n return {'ntp': ntp, 'nfp': nfp, 'nfn': nfn, 'fdr': fdr, 'tpr': tpr, 'nles': nb_les, 'nles_gt': nles_gt}\n\n\ndef cca_img_no_unc(bbox, t, th):\n \"\"\"\n Connected component analysis of between prediction `h` and ground truth `t` across lesion bin sizes.\n :param h: network output on range [0,1], shape=(NxMxO)\n :type h: float16, float32, float64\n :param t: ground truth labels, shape=(NxMxO)\n :type t: int16\n :param th: threshold to binarize prediction `h`\n :type th: float16, float32, float64\n :return: dict\n \"\"\"\n h[h >= th] = 1\n h[h < th] = 0\n h = h.astype(np.int16)\n\n t = remove_tiny_les(t, nvox=2)\n h = ndimage.binary_dilation(h, structure=ndimage.generate_binary_structure(3, 2))\n\n labels = {}\n nles = {}\n labels['h'], nles['h'] = ndimage.label(h)\n labels['t'], nles['t'] = ndimage.label(t)\n found_h = np.ones(nles['h'], np.int16)\n ntp = {'all': 0, 'small': 0, 'med': 0, 'large': 0}\n nfp = {'all': 0, 'small': 0, 'med': 0, 'large': 0}\n nfn = {'all': 0, 'small': 0, 'med': 0, 'large': 0}\n nb_les = {'all': 0, 'small': 0, 'med': 0, 'large': 0}\n nles_gt = {'all': nles['t'], 'small': 0, 'med': 0, 'large': 0}\n for i in range(1, nles['t'] + 1):\n lesion_size = np.sum(t[labels['t'] == i])\n nles_gt[get_lesion_bin(lesion_size)] += 1\n # list of detected lesions in this area\n h_lesions = np.unique(labels['h'][labels['t'] == i])\n # all the voxels in this area contribute to detecting the lesion\n nb_overlap = h[labels['t'] == i].sum()\n nb_les[get_lesion_bin(lesion_size)] += 1\n if nb_overlap >= 3 or nb_overlap >= 0.5 * lesion_size:\n ntp[get_lesion_bin(lesion_size)] += 1\n for h_lesion in h_lesions:\n if h_lesion != 0:\n found_h[h_lesion - 1] = 0\n else:\n nfn[get_lesion_bin(lesion_size)] += 1\n\n for i in range(1, nles['h'] + 1):\n if found_h[i - 1] == 1:\n nb_vox = np.sum(h[labels['h'] == i])\n nfp[get_lesion_bin(nb_vox)] += 1\n\n nb_les['all'] = nb_les['small'] + nb_les['med'] + nb_les['large']\n ntp['all'] = ntp['small'] + ntp['med'] + ntp['large']\n nfp['all'] = nfp['small'] + nfp['med'] + nfp['large']\n nfn['all'] = nfn['small'] + nfn['med'] + nfn['large']\n\n tpr = {}\n fdr = {}\n for s in ntp.keys():\n # tpr (sensitivity)\n if nb_les[s] != 0:\n tpr[s] = ntp[s] / nb_les[s]\n elif nb_les[s] == 0 and ntp[s] == 0:\n tpr[s] = 1\n else:\n tpr[s] = 0\n # ppv (1-fdr)\n if ntp[s] + nfp[s] != 0:\n ppv = ntp[s] / (ntp[s] + nfp[s])\n else:\n ppv = 1\n fdr[s] = 1 - ppv\n\n return {'ntp': ntp, 'nfp': nfp, 'nfn': nfn, 'fdr': fdr, 'tpr': tpr, 'nles': nb_les, 'nles_gt': nles_gt}\n\n\ndef get_unc_labels(x, unc, metric, xy):\n x_big = ndimage.binary_dilation(x, structure=ndimage.generate_binary_structure(3, 2))\n labels, nles = ndimage.label(x_big)\n unc_labels = np.zeros_like(unc)\n for i in range(1, nles + 1):\n unc_labels[labels == i] = np.sum(np.log(unc[labels == i] + 1e-5))\n\n unc_labels[unc_labels != 0] = (unc_labels[unc_labels != 0] - _LESION_UNC_VA[metric][xy + 'min']) / (\n _LESION_UNC_VA[metric][xy + 'max'] - _LESION_UNC_VA[metric][xy + 'min'])\n return unc_labels\n\n \n \ndef paint_cca_img(h, t):\n TP_COLOUR=1\n FP_COLOUR=2\n FN_COLOUR=3\n\n h_paint = h.copy() # this should be the un-connected labels\n\n t = remove_tiny_les(t)\n\n # get the 18 neighbourhood of the hypothesis\n neighbourhood18 = ndimage.generate_binary_structure(3, 2)\n h = ndimage.binary_dilation(h, structure=neighbourhood18)\n\n labels = {}\n nles = {}\n labels['h'], nles['h'] = ndimage.label(h)\n labels['t'], nles['t'] = ndimage.label(t)\n ntp = 0; nfp = 0; nfn = 0\n found_h = np.ones(nles['h'], np.int16)\n\n for i in range(1,nles['t']+1):\n got_les = False\n h_lesions = np.unique(labels['h'][labels['t']==i])\n for h_lesion in h_lesions:\n if h_lesion != 0:\n nb_overlap = h[labels['h']==h_lesion].sum()\n if nb_overlap >= 3 or nb_overlap >= 0.5*np.sum(t[labels['t']==i]):\n # this is a a true positive\n h_paint[labels['h']==h_lesion] *= TP_COLOUR\n found_h[h_lesion-1] = 0\n got_les = True\n # if we didn't get it --> false negative\n if not got_les:\n h_paint[labels['t']==i] = FN_COLOUR\n\n # any remaining that we found are false positivse\n for i, fp in enumerate(found_h):\n if fp:\n h_paint[labels['h']==(i+1)] *= FP_COLOUR\n\n labels_hpaint, nles = ndimage.label(h_paint)\n for i in range(1,nles+1):\n nb_vox = np.size(labels_hpaint[labels_hpaint==i])\n if nb_vox < 3:\n h_paint[labels_hpaint==i] = 0\n return h_paint \n\n\ndef ohe(x):\n ohe = np.zeros_like(x)\n ohe = np.repeat(np.expand_dims(x,-1),3,-1)\n ohe[:,:,:,0][x!=2] = 0 # red --> FP(2)\n ohe[:,:,:,1][x!=1] = 0 # gre --> TP(1)\n ohe[:,:,:,2][x!=3] = 0 # blu --> FN(3)\n ohe[ohe>0]=1\n return ohe\n \n# def cca_img(h, t, thresh, read_img=True):\n# \"\"\"\n# 1. binarize segmentation 'h' based on sigmoid 0.5 thresh\n# 2. generate blob (18 neighbourhood) of the 'h'\n# 3. remove tiny lesions in truth 't' (<=2 voxels in size)\n# 4. count true positives:\n# for lesion in t:\n# overlap = _get_overlap(h, t)\n# if overap >= voxels:\n# tp ++\n# else if ( overlap > 0.5 * size(lesion))\n# tp ++\n# else:\n# fn ++\n\n# 5. count false positives:\n# for lesion in h:\n# overlap = _get_overlap(h, t)\n# if overlap == 0:\n# fp ++\n# \"\"\"\n# if read_img:\n# h, header = nrrd.read(h)\n# t, header = nrrd.read(t)\n\n# h[h < thresh] = 0\n# h[h >= thresh] = 1\n# t = t.astype(np.int16)\n# h = h.astype(np.int16)\n\n# t = remove_tiny_les(t)\n\n# # get the 18 neighbourhood of the hypothesis\n# neighbourhood18 = ndimage.generate_binary_structure(3, 2)\n# h = ndimage.binary_dilation(h, structure=neighbourhood18)\n\n# labels = {}\n# nles = {}\n# labels['h'], nles['h'] = ndimage.label(h)\n# labels['t'], nles['t'] = ndimage.label(t)\n\n# ntp = 0; nfp = 0; nfn = 0\n# found_h = np.ones(nles['h'], np.int16)\n\n# for i in range(1,nles['t']):\n# got_les = False\n# h_lesions = np.unique(labels['h'][labels['t']==i])\n# for h_lesion in h_lesions:\n# if h_lesion != 0:\n# nb_overlap = np.size(labels['h']==h_lesion)\n# if nb_overlap >= 3 or nb_overlap >= 0.5*np.sum(t[labels['t']==i]):\n# got_les = True\n# found_h[h_lesion-1] = 0\n# if got_les:\n# ntp += 1\n# else:\n# nfn += 1\n\n# nfp = np.sum(found_h)\n\n# # tpr\n# if nles['t']!= 0:\n# tpr = ntp / nles['t']\n# elif nles['t']==0 and ntp ==0:\n# tpr = 1\n# else:\n# tpr = 0\n\n# # ppv, fdr\n# if ntp+nfp != 0:\n# ppv = ntp / (ntp+nfp)\n# else:\n# ppv = 1\n\n# # fdr\n# # if ntp+nfp != 0:\n# # fdr = nfp / (ntp+nfp)\n# # else:\n# # fdr = 0 \n\n# # f1 score\n# # denom = (2*ntp + nfp + nfn)\n# # if denom != 0:\n# # f1_score = 2*ntp / denom\n# # else:\n# # f1_score = 1\n\n# return {'ntp':ntp, 'nfp':nfp, 'nfn':nfn, 'ppv':ppv, 'tpr':tpr, 'fdr':1-ppv}\n", "meta": {"hexsha": "c1cc08af778309f1185821b0ecfe91b1a0bd2f91", "size": 13980, "ext": "py", "lang": "Python", "max_stars_repo_path": "tools/cca.py", "max_stars_repo_name": "thomaschristinck/detection_net", "max_stars_repo_head_hexsha": "c199abf9bd53b115a67e9e2c8da3da9894789f3e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-02-15T17:15:06.000Z", "max_stars_repo_stars_event_max_datetime": "2020-08-26T06:11:48.000Z", "max_issues_repo_path": "tools/cca.py", "max_issues_repo_name": "thomaschristinck/detection_net", "max_issues_repo_head_hexsha": "c199abf9bd53b115a67e9e2c8da3da9894789f3e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2020-03-24T16:11:54.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-11T23:30:39.000Z", "max_forks_repo_path": "tools/cca.py", "max_forks_repo_name": "thomaschristinck/lesion-detection-net", "max_forks_repo_head_hexsha": "c199abf9bd53b115a67e9e2c8da3da9894789f3e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.0975609756, "max_line_length": 110, "alphanum_fraction": 0.5108726753, "include": true, "reason": "import numpy,from scipy", "num_tokens": 4909, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5698526660244838, "lm_q2_score": 0.34864513533394575, "lm_q1q2_score": 0.19867635986651594}} {"text": "#\n# Copyright 2020 Antoine Sanner\n# 2020 Lars Pastewka\n#\n# ### MIT license\n#\n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# in the Software without restriction, including without limitation the rights\n# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n# copies of the Software, and to permit persons to whom the Software is\n# furnished to do so, subject to the following conditions:\n#\n# The above copyright notice and this permission notice shall be included in\n# all copies or substantial portions of the Software.\n#\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n# SOFTWARE.\n#\n\n\"\"\"\nDefines the interface for Adhesion systems\n\"\"\"\n\nimport numpy as np\n\nimport Adhesion\nimport ContactMechanics\nimport SurfaceTopography\nfrom ContactMechanics.Tools import compare_containers\nfrom ContactMechanics.Systems import IncompatibleResolutionError, SystemBase\n\n\nclass SmoothContactSystem(SystemBase):\n \"\"\"\n For smooth contact mechanics (i.e. the ones for which optimization is only\n kinda-hell\n \"\"\"\n\n def __init__(self, substrate, interaction, surface):\n \"\"\" Represents a contact problem\n Parameters\n ----------\n substrate: An instance of HalfSpace.\n Defines the solid mechanics in the substrate\n interaction: Adhesion.Interactions.SoftWall\n Defines the contact formulation.\n If this computes interaction energies, forces etc,\n these are supposed to be expressed per unit area in whatever units\n you use. The conversion is performed by the system\n surface: SurfaceTopography.Topography\n Defines the profile.\n \"\"\"\n if surface.has_undefined_data:\n raise ValueError(\"The topography you provided contains undefined \"\n \"data\")\n super().__init__(substrate=substrate, surface=surface)\n self.interaction = interaction\n if not compare_containers(surface.nb_grid_pts, substrate.nb_grid_pts):\n raise IncompatibleResolutionError(\n (\"the substrate ({}) and the surface ({}) have incompatible \"\n \"nb_grid_ptss.\").format(\n substrate.nb_grid_pts, surface.nb_grid_pts)) # nopep8\n self.dim = len(self.substrate.nb_grid_pts)\n self.energy = None\n self.force = None\n self.force_h = None\n self.interaction_energy = None\n self.interaction_force = None\n self.heights_k = None\n self.engine = self.substrate.fftengine\n\n if hasattr(substrate.fftengine, \"register_halfcomplex_field\") and self.engine.communicator.size == 1:\n # avoids the initialization to fail if we use an fftengine without these hcffts implemnented\n # preconditionning is not parallelized yet, this we have no parallelized wrapper for hcfft in muFFT yet\n self.real_buffer = self.engine.register_halfcomplex_field(\"hc-real-space\", 1)\n self.fourier_buffer = self.engine.register_halfcomplex_field(\"hc-fourier-space\", 1)\n\n self.stiffness_k = self._compute_stiffness_k()\n\n @property\n def nb_grid_pts(self):\n return self.surface.nb_grid_pts\n\n @staticmethod\n def handles(substrate_type, interaction_type, surface_type, comm):\n is_ok = True\n # any periodic type of substrate formulation should do\n is_ok &= issubclass(substrate_type,\n ContactMechanics.Substrate)\n\n # only soft interactions allowed\n is_ok &= issubclass(interaction_type,\n Adhesion.SoftWall)\n\n # any surface should do\n is_ok &= issubclass(surface_type,\n SurfaceTopography.UniformTopographyInterface)\n return is_ok\n\n def compute_repulsive_force(self):\n \"computes and returns the sum of all repulsive forces\"\n return self.reduction.sum(np.where(\n self.interaction_force > 0, self.interaction_force, 0\n ))\n\n def compute_attractive_force(self):\n \"computes and returns the sum of all attractive forces\"\n return self.reduction.sum(np.where(\n self.interaction_force < 0, self.interaction_force, 0\n ))\n\n def _compute_stiffness_k(self):\n \"\"\"\n computes and returns the wavevectors q that exist for the surfaces\n physical_sizes and nb_grid_pts as one vector of components per\n dimension\n \"\"\"\n\n vectors = []\n q = []\n nb_dims = len(self.substrate.nb_grid_pts)\n # if nb_dims == 1:\n # nb_grid_pts = [self.substrate.nb_grid_pts]\n # physical_sizes = [self.substrate.physical_sizes]\n for dim in range(nb_dims):\n vectors.append(2 * np.pi * np.fft.fftfreq(\n self.substrate.nb_grid_pts[dim],\n self.substrate.physical_sizes[dim] /\n self.substrate.nb_grid_pts[dim]))\n if nb_dims == 1:\n q = vectors[0]\n q[0] = q[1]\n elif nb_dims == 2:\n qx = vectors[0]\n qy = vectors[1]\n q = np.sqrt(\n (qx * qx).reshape((-1, 1)) + (qy * qy).reshape((1, -1)))\n q[0, 0] = (q[0, 1] + q[1, 0]) / 2\n\n return 0.5 * self.substrate.contact_modulus * abs(q)\n\n def compute_normal_force(self):\n \"computes and returns the sum of all forces\"\n return self.reduction.sum(self.interaction_force)\n\n def compute_repulsive_contact_area(self):\n \"computes and returns the area where contact pressure is repulsive\"\n return self.compute_nb_repulsive_pts() * self.area_per_pt\n\n def compute_attractive_contact_area(self):\n \"computes and returns the are where contact pressure is attractive\"\n return self.compute_nb_attractive_pts() * self.area_per_pt\n\n def compute_nb_contact_pts(self):\n \"\"\"\n compute and return the number of contact points. Note that this is of\n no physical interest, as it is a purely numerical artefact\n \"\"\"\n return self.reduction.sum(\n np.where(self.interaction_force != 0., 1., 0.))\n\n def compute_nb_repulsive_pts(self):\n \"\"\"\n compute and return the number of contact points under repulsive\n pressure. Note that this is of no physical interest, as it is a\n purely numerical artefact\n \"\"\"\n return self.reduction.sum(\n np.where(self.interaction_force > 0., 1., 0.))\n\n def compute_nb_attractive_pts(self):\n \"\"\"\n compute and return the number of contact points under attractive\n pressure. Note that this is of no physical interest, as it is a\n purely numerical artefact\n \"\"\"\n return self.reduction.sum(\n np.where(self.interaction_force < 0., 1., 0.))\n\n def compute_repulsive_coordinates(self):\n \"\"\"\n returns an array of all coordinates, where contact pressure is\n repulsive. Useful for evaluating the number of contact islands etc.\n \"\"\"\n return np.argwhere(self.interaction_force > 0.)\n\n def compute_attractive_coordinates(self):\n \"\"\"\n returns an array of all coordinates, where contact pressure is\n attractive. Useful for evaluating the number of contact islands etc.\n \"\"\"\n return np.argwhere(self.interaction_force < 0.)\n\n def compute_mean_gap(self):\n \"\"\"\n mean of the gap in the the physical domain (means excluding padding\n region for the FreeFFTElasticHalfspace)\n \"\"\"\n return self.reduction.sum(self.gap) / np.prod(self.nb_grid_pts)\n\n def logger_input(self):\n \"\"\"\n\n Returns\n -------\n headers: list of strings\n values: list\n \"\"\"\n tot_nb_grid_pts = np.prod(self.nb_grid_pts)\n rel_rep_area = self.compute_nb_repulsive_pts() / tot_nb_grid_pts\n rel_att_area = self.compute_nb_attractive_pts() / tot_nb_grid_pts\n # TODO: eventually put a flag to turn\n # reductions off since this is an additional communication.\n return (['energy',\n 'max. abs. grad.',\n 'mean gap',\n 'frac. rep. area',\n 'frac. att. area',\n 'frac. int. area', 'substrate force', 'interaction force'],\n [self.energy,\n self.reduction.max(np.abs(self.force)),\n self.compute_mean_gap(),\n rel_rep_area,\n rel_att_area,\n rel_rep_area + rel_att_area,\n -self.reduction.sum(self.substrate.force),\n self.reduction.sum(self.interaction_force)])\n\n def evaluate(self, disp, offset, pot=True, forces=False, logger=None):\n \"\"\"\n Compute the energies and forces in the system for a given displacement\n field\n\n Parameters:\n -----------\n disp: ndarray\n displacement field, in the shape of\n system.substrate.nb_subdomain_grid_pts\n offset: float\n determines indentation depth,\n constant value added to the heights (system.topography)\n pot: bool, optional\n Wether to evaluate the energy, default True\n forces: bool, optional\n Wether to evaluate the forces, default False\n logger: ContactMechanics.Tools.Logger\n informations of current state of the system will be passed to\n logger at every evaluation\n \"\"\"\n # attention: the substrate may have a higher nb_grid_pts than the gap\n # and the interaction (e.g. FreeElasticHalfSpace)\n self.gap = self.compute_gap(disp, offset)\n interaction_energies, self.interaction_force, _ = \\\n self.interaction.evaluate(self.gap,\n potential=pot,\n gradient=forces,\n curvature=False)\n\n self.interaction_energy = \\\n self.reduction.sum(interaction_energies) * self.area_per_pt\n\n self.substrate.compute(disp, pot, forces)\n self.energy = (self.interaction_energy +\n self.substrate.energy\n if pot else None)\n if forces:\n self.interaction_force *= -self.area_per_pt\n # ^ gradient to force per pixel\n self.force = self.substrate.force.copy()\n self.force[self.comp_slice] += \\\n self.interaction_force\n else:\n self.force = None\n\n if logger is not None:\n logger.st(*self.logger_input())\n return (self.energy, self.force)\n\n def objective(self, offset, disp0=None, gradient=False, disp_scale=1.,\n logger=None):\n r\"\"\"\n This helper method exposes a scipy.optimize-friendly interface to the\n evaluate() method. Use this for optimization purposes, it makes sure\n that the shape of disp is maintained and lets you set the offset and\n 'forces' flag without using scipy's cumbersome argument passing\n interface. Returns a function of only disp\n\n Parameters:\n -----------\n disp0: ndarray\n unused variable, present only for interface compatibility\n with inheriting classes\n offset: float\n determines indentation depth,\n constant value added to the heights (system.topography)\n gradient: bool, optional\n Wether to evaluate the gradient, default False\n disp_scale : float, optional\n (default 1.) allows to specify a scaling of the\n dislacement before evaluation. This can be necessary when\n using dumb minimizers with hardcoded convergence criteria\n such as scipy's L-BFGS-B.\n logger: ContactMechanics.Tools.Logger\n informations of current state of the system will be passed to\n logger at every evaluation\n\n Returns:\n function(disp)\n Parameters:\n disp: an ndarray of shape\n `system.substrate.nb_subdomain_grid_pts`\n displacements\n Returns:\n energy or energy, gradient\n \"\"\"\n res = self.substrate.nb_subdomain_grid_pts\n if gradient:\n def fun(disp):\n # pylint: disable=missing-docstring\n try:\n self.evaluate(\n disp_scale * disp.reshape(res), offset, forces=True,\n logger=logger)\n except ValueError as err:\n raise ValueError(\n \"{}: disp.shape: {}, res: {}\".format(\n err, disp.shape, res))\n return (self.energy, -self.force.reshape(-1) * disp_scale)\n else:\n def fun(disp):\n # pylint: disable=missing-docstring\n return self.evaluate(\n disp_scale * disp.reshape(res), offset, forces=False,\n logger=logger)[0]\n\n return fun\n\n def primal_evaluate(self, disp, gap, pot=True, forces=False, logger=None):\n \"\"\"\n Compute the energies and forces in the system for a given\n displacement and gap..\n\n Parameters:\n -----------\n disp: ndarray\n displacement field, in the shape of\n system.substrate.nb_subdomain_grid_pts\n gap: ndarray\n gap , in the shape of\n system.substrate.nb_subdomain_grid_pts\n pot: bool, optional\n Whether to evaluate the energy, default True\n forces: bool, optional\n Whether to evaluate the forces, default False\n logger: ContactMechanics.Tools.Logger\n information of current state of the system will be\n passed to\n logger at every evaluation\n \"\"\"\n # attention: the substrate may have a higher nb_grid_pts than the gap\n # and the interaction (e.g. FreeElasticHalfSpace)\n\n self.gap = gap\n interaction_energies, self.interaction_force, _ = \\\n self.interaction.evaluate(self.gap,\n potential=pot,\n gradient=forces,\n curvature=False)\n\n self.interaction_energy = \\\n self.reduction.sum(interaction_energies) * self.area_per_pt\n\n self.substrate.compute(disp, pot, forces)\n self.energy = (self.interaction_energy +\n self.substrate.energy\n if pot else None)\n if forces:\n self.interaction_force *= -self.area_per_pt\n # ^ gradient to force per pixel\n self.force = self.substrate.force.copy()\n\n self.force[self.comp_slice] += self.interaction_force\n else:\n self.force = None\n\n if logger is not None:\n logger.st(*self.logger_input())\n\n return (self.energy, self.force)\n\n def primal_objective(self, offset, disp0=None, gradient=False,\n logger=None):\n r\"\"\"To solve the primal objective using gap as the variable.\n Can be fed directly to standard solvers ex: scipy solvers etc\n and returns the elastic energy and it's gradient (negative of\n the forces) as a function of the gap.\n\n Parameters\n __________\n\n gap : float\n gap between the contact surfaces.\n offset : float\n constant value to add to the surface heights\n pot : (default False)\n\n gradient : (default True)\n\n Returns\n _______\n energy : float\n value of energy(scalar value).\n force : float,array\n value of force(array).\n\n Notes\n _____\n\n Objective:\n\n .. math ::\n\n \\min_u f = \\frac{1}{2} u_i K_{ij} u_j + \\phi (u_{ij})\\\\\n \\\\\n \\nabla f = K_{ij} u_j + \\phi^{\\prime} \\text{ which is the force} \\\\\n\n \"\"\"\n\n res = self.substrate.nb_subdomain_grid_pts\n if gradient:\n def fun(gap):\n disp = gap.reshape(res) + self.surface.heights() + offset\n try:\n self.primal_evaluate(\n disp, gap.reshape(res), forces=True, logger=logger)\n except ValueError as err:\n raise ValueError(\n \"{}: gap.shape: {}, res: {}\".format(\n err, gap.shape, res))\n return (self.energy, -self.force.reshape(-1))\n else:\n def fun(gap):\n disp = gap.reshape(res) + self.surface.heights() + offset\n return self.primal_evaluate(\n disp, gap.reshape(res), forces=False, logger=logger)[0]\n\n return fun\n\n def primal_hessian_product(self, gap, des_dir):\n \"\"\"Returns the hessian product of the primal_objective function.\n \"\"\"\n _, _, adh_curv = self.interaction.evaluate(gap, curvature=True)\n\n hessp_val = - self.substrate.evaluate_force(\n des_dir.reshape(self.substrate.nb_subdomain_grid_pts)\n ).reshape(np.shape(des_dir)) \\\n + adh_curv * des_dir * self.substrate.area_per_pt\n\n return hessp_val.reshape(des_dir.shape)\n\n def hessian_product_function(self, offset):\n def hessp(disp, des_dir):\n gap = disp.reshape(self.substrate.nb_subdomain_grid_pts\n )[self.comp_slice] \\\n - (self.surface.heights() + offset)\n _, _, adh_curv = self.interaction.evaluate(gap, curvature=True)\n hessp_val = - self.substrate.evaluate_force(\n des_dir.reshape(self.substrate.nb_subdomain_grid_pts)\n )\n\n hessp_val[self.comp_slice] += adh_curv \\\n * des_dir.reshape(\n self.substrate.nb_subdomain_grid_pts)[self.comp_slice] * \\\n self.substrate.area_per_pt\n return hessp_val.reshape(des_dir.shape)\n\n return hessp\n\n def _fourier_coefficients(self):\n \"\"\"\n Returns the coefficients for elasticity matrix when working in fourier\n space for both 1D and 2D system.\n \"\"\"\n\n nx = self.substrate.nb_grid_pts[0]\n nb_dims = len(self.substrate.nb_grid_pts)\n\n if nb_dims == 2:\n ny = self.substrate.nb_grid_pts[1]\n coeffs = np.zeros(self.substrate.nb_grid_pts)\n if np.logical_and((nx % 2 == 0), (ny % 2 == 0)):\n coeffs[0, 0] = 1 / (nx * ny)\n coeffs[0, 1:ny // 2] = 2 / (nx * ny)\n coeffs[0, ny // 2 + 1:] = 2 / (nx * ny)\n coeffs[1:nx // 2, 0] = 2 / (nx * ny)\n coeffs[nx // 2 + 1:, 0] = 2 / (nx * ny)\n coeffs[:nx // 2, ny // 2] = 2 / (nx * ny)\n coeffs[nx // 2 + 1:, ny // 2] = 2 / (nx * ny)\n coeffs[nx // 2, :ny // 2] = 2 / (nx * ny)\n coeffs[nx // 2, ny // 2 + 1:] = 2 / (nx * ny)\n coeffs[1:nx // 2, 1:ny // 2] = 4 / (nx * ny)\n coeffs[nx // 2 + 1:, 1:ny // 2] = 4 / (nx * ny)\n coeffs[1:nx // 2, ny // 2 + 1:] = 4 / (nx * ny)\n coeffs[nx // 2 + 1:, ny // 2 + 1:] = 4 / (nx * ny)\n coeffs[nx // 2, ny // 2] = 1 / (nx * ny)\n coeffs[nx // 2, 0] = 1 / (nx * ny)\n coeffs[0, ny // 2] = 1 / (nx * ny)\n else:\n coeffs[0, 0] = 1 / (nx * ny)\n coeffs[0, 1:] = 2 / (nx * ny)\n coeffs[1:, 0] = 2 / (nx * ny)\n coeffs[1:, 1:] = 4 / (nx * ny)\n elif nb_dims == 1:\n coeffs = np.zeros(self.substrate.nb_grid_pts)\n if (nx % 2 == 0):\n coeffs[0] = 1 / nx\n coeffs[1:nx // 2] = 2 / nx\n coeffs[nx // 2 + 1:] = 2 / nx\n coeffs[nx // 2] = 1 / nx\n else:\n coeffs[0] = 1 / nx\n coeffs[1:] = 2 / nx\n\n return coeffs\n\n def evaluate_k(self, disp_k, gap, offset, mw=False, pot=True, forces=False,\n logger=None):\n\n \"\"\"\n Compute the energies and forces in the system for a given displacement\n field in fourier space.\n\n Parameters\n -----------\n\n disp_k: ndarray\n displacement field in fourier space.\n gap: ndarray\n displacement field in real space, in the shape of\n system.substrate.nb_subdomain_grid_pts\n offset: float\n determines indentation depth,\n constant value added to the heights (system.topography)\n mw: bool, optional\n when mass weighting is required then set this to TRUE.\n pot: bool, optional\n Wether to evaluate the energy, default True\n forces: bool, optional\n Wether to evaluate the forces, default False\n logger: ContactMechanics.Tools.Logger\n informations of current state of the system will be passed to\n logger at every evaluation.\n \"\"\"\n\n # self.gap = self.compute_gap(disp, offset)\n self.gap = gap\n interaction_energies, self.interaction_force, _ = \\\n self.interaction.evaluate(self.gap,\n potential=pot,\n gradient=forces,\n curvature=False)\n self.interaction_energy = \\\n self.reduction.sum(interaction_energies) * self.area_per_pt\n\n self.grad_k = np.zeros(self.substrate.nb_grid_pts)\n\n coeff = self._fourier_coefficients()\n\n if mw:\n self.grad_k = disp_k * coeff\n else:\n self.grad_k = disp_k * coeff * self.stiffness_k\n\n self.grad_k *= self.area_per_pt\n\n # ENERGY FROM SUBSTRATE\n self.energy = 0.5 * (np.sum(self.grad_k * disp_k))\n\n self.substrate.energy = self.energy\n\n self.force_h = -self.grad_k\n\n # TOTAL ENERGY\n self.energy += self.interaction_energy\n\n if forces:\n self.interaction_force *= -self.area_per_pt\n # ^ gradient to force per pixel\n\n self.real_buffer.array()[...] = self.interaction_force\n self.engine.hcfft(self.real_buffer, self.fourier_buffer)\n interaction_force_float_k = self.fourier_buffer.array()[...].copy()\n\n adh_coeffs = self._fourier_coefficients()\n interaction_force_float_k *= adh_coeffs\n\n if mw:\n k = np.sqrt(self.stiffness_k.copy() * self.area_per_pt)\n interaction_force_float_k = interaction_force_float_k * (1 / k)\n\n self.force_h += interaction_force_float_k\n else:\n self.force_h = None\n\n if logger is not None:\n disp_real = self.gap + self.surface.heights().copy() + offset\n force_real = self.substrate.evaluate_force(disp_real)\n force_real = force_real + self.interaction_force\n logger.st(*(['energy',\n 'max. abs. grad.',\n 'max. abs. grad. real'],\n [self.energy,\n self.reduction.max(np.abs(self.force_h)),\n self.reduction.max(np.abs(force_real))\n ]))\n\n return (self.energy, self.force_h)\n\n # def hessian_product_k(self, dispk, des_dir_k):\n # \"\"\"Returns the hessian product of the fourier space\n # objective_k function.\n # \"\"\"\n # self.substrate.fourier_buffer.array()[...] = dispk.copy()\n # self.substrate.fftengine.ifft(self.substrate.fourier_buffer,\n # self.substrate.real_buffer)\n # disp = self.substrate.real_buffer.array()[...].copy() \\\n # * self.substrate.fftengine.normalisation\n #\n # gap = self.compute_gap(disp)\n # _, _, adh_curv = self.interaction.evaluate(gap, curvature=True)\n #\n # self.substrate.real_buffer.array()[...] = adh_curv.reshape(\n # self.substrate.nb_grid_pts).copy()\n # self.substrate.fftengine.fft(self.substrate.real_buffer,\n # self.substrate.fourier_buffer)\n # adh_curv_k = self.substrate.fourier_buffer.array()[...].copy()\n #\n # hessp_val_k = -self.substrate.evaluate_k_force_k(des_dir_k) + \\\n # adh_curv_k * des_dir_k * self.substrate.area_per_pt\n #\n # return hessp_val_k\n\n # def hessian_product_preconditioned(self, offset):\n\n # def hessp_precond(disp_h, des_dir):\n #\n # self.real_buffer.array()[...] = offset\n # self.engine.hcfft(self.real_buffer, self.fourier_buffer)\n # offset_k = self.fourier_buffer.array()[...].copy()\n #\n # self.real_buffer.array()[...] = self.surface.heights().copy()\n # self.engine.hcfft(self.real_buffer, self.fourier_buffer)\n # self.heights_k_float = self.fourier_buffer.array()[...].copy()\n #\n # disp_float_k = disp_h.copy()\n # disp_float_k = disp_float_k.reshape(self.substrate.nb_grid_pts)\n # gap_float_k = (disp_float_k / np.sqrt(self.stiffness_k *\n # self.area_per_pt)) - \\\n # self.heights_k_float - offset_k\n #\n # self.fourier_buffer.array()[...] = gap_float_k.copy()\n # self.engine.ihcfft(self.fourier_buffer, self.real_buffer)\n # gap = self.real_buffer.array()[...].copy() * \\\n # self.engine.normalisation\n #\n # _, _, adh_curv = \\\n # self.interaction.evaluate(gap,\n # curvature=True)\n #\n # coeff = self._fourier_coefficients()\n #\n # el_hess_k = coeff @ coeff\n # el_hess_k *= self.area_per_pt\n #\n # orig_shape = np.shape(des_dir)\n #\n # el_hess_k *= des_dir #.reshape(el_hess_k)\n #\n # adh_curv *= self.area_per_pt\n #\n # self.real_buffer.array()[...] = adh_curv\n # self.engine.hcfft(self.real_buffer, self.fourier_buffer)\n # adh_curv_float_k = self.fourier_buffer.array()[...].copy()\n #\n # adh_curv_float_k *= coeff @ coeff\n #\n # k = np.sqrt(self.stiffness_k.copy() * self.area_per_pt)\n #\n # adh_hess_k = adh_curv_float_k * des_dir * (1 / k) * (1 / k)\n #\n # hess_k = el_hess_k.reshape(orig_shape) + \\\n # adh_hess_k.reshape(orig_shape)\n #\n # return hess_k\n #\n # return hessp_precond\n\n def preconditioned_objective(self, offset, gradient=False, logger=None):\n r\"\"\"\n This helper method interface to the evaluate_k() method with\n preconditioning active. That is, it tries to solve a simpler problem\n formulated using,\n\n original problem:\n\n .. math ::\n\n \\frac{1}{2(n_x n_y)} \\tilde{u}\\tilde{K} \\bar{\\tilde{u}} +\n \\phi(F^{-1}(\\tilde{u} - \\tilde{h}))\n\n preconditioned problem:\n\n .. math ::\n \\tilde{v} = \\tilde{k}^{\\frac{1}{2}} \\tilde{u} \\\\\n\n \\frac{1}{2(n_x n_y)} \\tilde{v}\\bar{\\tilde{v}} +\n \\phi(F^{-1}(\\frac{\\tilde{v}}{\\tilde{k}^{\\frac{1}{2}}} - \\tilde{h}))\n\n we solve for variable :math:`\\tilde{v}`.\n\n Parameters:\n -----------\n\n offset: float\n determines indentation depth,\n constant value added to the heights (system.topography)\n gradient: bool, optional\n Whether to evaluate the gradient, default False\n logger: ContactMechanics.Tools.Logger\n information of current state of the system will be passed to\n logger at every evaluation\n\n Returns\n _______\n\n function(disp_k)\n\n Parameters\n __________\n\n disp_k: an ndarray in fourier halfcomplex space\n\n Returns\n _______\n\n energy: scalar\n energy of the system\n\n force_h: an halfcomplex array of shape(disp_k)\n force of the system\n \"\"\"\n\n # TODO: fourier transforming the offset is useless\n self.real_buffer.array()[...] = offset\n self.engine.hcfft(self.real_buffer, self.fourier_buffer)\n offset_k = self.fourier_buffer.array()[...].copy()\n\n self.real_buffer.array()[...] = self.surface.heights().copy()\n self.engine.hcfft(self.real_buffer, self.fourier_buffer)\n self.heights_k_float = self.fourier_buffer.array()[...].copy()\n\n if gradient:\n def fun(disp_):\n disp_float_k = disp_.copy()\n orig_shape = np.shape(disp_float_k)\n disp_float_k = disp_float_k.reshape(self.substrate.nb_grid_pts)\n gap_float_k = (disp_float_k / np.sqrt(self.stiffness_k *\n self.area_per_pt)) - \\\n self.heights_k_float - offset_k\n\n self.fourier_buffer.array()[...] = gap_float_k.copy()\n self.engine.ihcfft(self.fourier_buffer, self.real_buffer)\n gap = self.real_buffer.array()[...].copy() * self.engine.normalisation\n\n self.energy, self.force_h = self.evaluate_k(disp_float_k,\n gap, offset,\n mw=True,\n forces=True,\n logger=logger\n )\n\n return (self.energy, -self.force_h.reshape(orig_shape))\n else:\n raise NotImplementedError\n\n return fun\n\n def objective_k_float(self, offset, gradient=False, logger=None):\n r\"\"\"\n\n Returns callable objective as needed by scipy minimizers.\n\n The optimisation varialbe is the halfcomplex fourier transform of the gap.\n\n This helper method interface to the evaluate_k() method without\n preconditioning active.\n\n .. math ::\n\n \\frac{1}{2(n_x n_y)} \\tilde{u}\\tilde{K} \\bar{\\tilde{u}} +\n \\phi(F^{-1}(\\tilde{u} - \\tilde{h})) \\\\\n\n preconditioned problem:\n\n .. math ::\n\n \\tilde{v} = \\tilde{k}^{\\frac{1}{2}} \\tilde{u} \\\\\n\n \\frac{1}{2(n_x n_y)} \\tilde{v} \\bar{\\tilde{v}} +\n \\phi(F^{-1}(\\frac{\\tilde{v}}{\\tilde{k}^{\\frac{1}{2}}} - \\tilde{h}))\n \\\\\n we solve for variable :math:`\\tilde{v}`.\n\n Parameters:\n -----------\n\n offset: float\n determines indentation depth,\n constant value added to the heights (system.topography)\n gradient: bool, optional\n Whether to evaluate the gradient, default False\n logger: ContactMechanics.Tools.Logger\n information of current state of the system will be passed to\n logger at every evaluation\n\n Returns\n _______\n\n function(disp_k)\n\n Parameters\n __________\n\n disp_k: an ndarray in fourier space\n\n Returns\n _______\n\n energy, gradient_k_float\n \"\"\"\n\n self.real_buffer.array()[...] = offset\n self.engine.hcfft(self.real_buffer, self.fourier_buffer)\n offset_k = self.fourier_buffer.array()[...].copy()\n\n self.real_buffer.array()[...] = self.surface.heights().copy()\n self.engine.hcfft(self.real_buffer, self.fourier_buffer)\n self.heights_k_float = self.fourier_buffer.array()[...].copy()\n\n if gradient:\n def fun(disp_k):\n disp_float_k = disp_k.copy()\n orig_shape = np.shape(disp_float_k)\n disp_float_k = disp_float_k.reshape(self.substrate.nb_grid_pts)\n gap_float_k = disp_float_k - self.heights_k_float - offset_k\n self.fourier_buffer.array()[...] = gap_float_k.copy()\n self.engine.ihcfft(self.fourier_buffer, self.real_buffer)\n gap = self.real_buffer.array()[...].copy() \\\n * self.engine.normalisation\n\n self.energy, self.force_h = self.evaluate_k(disp_float_k,\n gap, offset,\n forces=True,\n logger=logger\n )\n return (self.energy, -self.force_h.reshape(orig_shape))\n else:\n def fun(disp_k):\n # pylint: disable=missing-docstring\n disp_float_k = disp_k.copy()\n disp_float_k = disp_float_k.reshape(self.substrate.nb_grid_pts)\n gap_float_k = disp_float_k - self.heights_k_float - offset_k\n self.fourier_buffer.array()[...] = gap_float_k.copy()\n self.engine.ihcfft(self.fourier_buffer, self.real_buffer)\n gap = self.real_buffer.array()[...].copy() \\\n * self.engine.normalisation\n\n return self.evaluate_k(disp_float_k, gap, offset, forces=True,\n logger=logger)[0]\n\n return fun\n\n def callback(self, force=False):\n \"\"\"\n Simple callback function that can be handed over to scipy's minimize to\n get updates during minimisation\n Parameters:\n ----------\n force: bool, optional\n whether to include the norm of the force\n vector in the update message\n (default False)\n \"\"\"\n counter = 0\n if force:\n def fun(dummy):\n \"includes the force norm in its output\"\n nonlocal counter\n counter += 1\n print(\"at it {}, e = {}, |f| = {}\".format(\n counter, self.energy,\n np.linalg.norm(np.ravel(self.force))))\n else:\n def fun(dummy):\n \"prints messages without force information\"\n nonlocal counter\n counter += 1\n print(\"at it {}, e = {}\".format(\n counter, self.energy))\n return fun\n\n\nclass BoundedSmoothContactSystem(SmoothContactSystem):\n @staticmethod\n def handles(*args, **kwargs): # FIXME work around, see issue #208\n return False\n\n def compute_nb_contact_pts(self):\n \"\"\"\n compute and return the number of contact points.\n \"\"\"\n return self.reduction.sum(np.where(self.gap == 0., 1., 0.))\n\n def logger_input(self):\n \"\"\"\n\n Returns\n -------\n headers: list of strings\n values: list\n \"\"\"\n tot_nb_grid_pts = np.prod(self.nb_grid_pts)\n rel_rep_area = self.compute_nb_repulsive_pts() / tot_nb_grid_pts\n rel_att_area = self.compute_nb_attractive_pts() / tot_nb_grid_pts\n # TODO: eventually put a flag to turn\n # reductions off since this is an additional communication.\n\n contacting_points = self.gap == 0.\n mask = np.ones(self.substrate.nb_subdomain_grid_pts)\n mask[self.substrate.local_topography_subdomain_slices][\n contacting_points] = 0\n max_proj_grad = self.reduction.max(abs(mask * self.force))\n\n return (['energy',\n 'max. proj. grad.',\n 'mean gap',\n 'frac. cont. area',\n 'frac. rep. area',\n 'frac. att. area',\n 'frac. int. area',\n 'substrate force',\n 'interaction force'],\n [self.energy,\n max_proj_grad,\n self.compute_mean_gap(),\n self.compute_nb_contact_pts() / np.prod(self.nb_grid_pts),\n rel_rep_area,\n rel_att_area,\n rel_rep_area + rel_att_area,\n -self.reduction.sum(self.substrate.force),\n self.reduction.sum(self.interaction_force)])\n\n def compute_normal_force(self):\n \"computes and returns the sum of all forces\"\n\n # sum of the jacobian in the contact area (Lagrange multiplier)\n # and the ineraction forces.\n # can also be computed easily from the substrate forces,\n # what we do here\n return self.reduction.sum(\n - self.substrate.force[self.substrate.local_topography_subdomain_slices])\n\n def compute_repulsive_force(self):\n \"\"\"computes and returns the sum of all repulsive forces\n\n Assumptions: there\n \"\"\"\n return self.reduction.sum(\n np.where(\n - self.substrate.force[\n self.substrate.local_topography_subdomain_slices] > 0,\n - self.substrate.force[\n self.substrate.local_topography_subdomain_slices], 0.))\n\n def compute_attractive_force(self):\n \"computes and returns the sum of all attractive forces\"\n return self.reduction.sum(\n np.where(\n - self.substrate.force[\n self.substrate.local_topography_subdomain_slices] < 0,\n - self.substrate.force[\n self.substrate.local_topography_subdomain_slices],\n 0.))\n\n def compute_nb_repulsive_pts(self):\n \"\"\"\n compute and return the number of contact points under repulsive\n pressure.\n\n \"\"\"\n return self.reduction.sum(\n np.where(\n np.logical_and(\n self.gap == 0.,\n - self.substrate.force[\n self.substrate.local_topography_subdomain_slices] > 0),\n 1., 0.))\n\n def compute_nb_attractive_pts(self):\n \"\"\"\n compute and return the number of contact points under attractive\n pressure.\n \"\"\"\n\n # Compute points where substrate force is negative\n # or there is no contact\n pts = np.logical_or(- self.substrate.force[\n self.substrate.local_topography_subdomain_slices] < 0,\n self.gap > 0.)\n\n # exclude points where there is no contact\n # and the interaction force is 0.\n pts[np.logical_and(self.gap > 0.,\n self.interaction_force == 0.)] = 0.\n\n return self.reduction.sum(pts)\n\n def compute_repulsive_coordinates(self):\n \"\"\"\n returns an array of all coordinates, where contact pressure is\n repulsive. Useful for evaluating the number of contact islands etc.\n \"\"\"\n return np.argwhere(\n np.logical_and(\n self.gap == 0.,\n - self.substrate.force[\n self.substrate.local_topography_subdomain_slices]\n > 0))\n\n def compute_attractive_coordinates(self):\n \"\"\"\n returns an array of all coordinates, where contact pressure is\n attractive. Useful for evaluating the number of contact islands etc.\n \"\"\"\n\n # Compute points where substrate force is negative\n # or there is no contact\n pts = np.logical_or(\n - self.substrate.force[self.substrate.local_topography_subdomain_slices]\n < 0,\n self.gap > 0.)\n\n # exclude points where there is no contact\n # and the interaction force is 0.\n pts[np.logical_and(self.gap > 0.,\n self.interaction_force == 0.)] = 0.\n\n return np.argwhere(pts)\n", "meta": {"hexsha": "aaae22364375859e9852d098d2a426159f9912b6", "size": 40460, "ext": "py", "lang": "Python", "max_stars_repo_path": "Adhesion/System/Systems.py", "max_stars_repo_name": "ContactEngineering/Adhesion", "max_stars_repo_head_hexsha": "acc46ad9bfe49fec667cb9a116ebde426faa38c4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Adhesion/System/Systems.py", "max_issues_repo_name": "ContactEngineering/Adhesion", "max_issues_repo_head_hexsha": "acc46ad9bfe49fec667cb9a116ebde426faa38c4", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2021-08-18T07:30:57.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-05T11:05:09.000Z", "max_forks_repo_path": "Adhesion/System/Systems.py", "max_forks_repo_name": "ContactEngineering/Adhesion", "max_forks_repo_head_hexsha": "acc46ad9bfe49fec667cb9a116ebde426faa38c4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.9906103286, "max_line_length": 115, "alphanum_fraction": 0.5575135937, "include": true, "reason": "import numpy", "num_tokens": 8708, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5698526660244838, "lm_q2_score": 0.34864512856608565, "lm_q1q2_score": 0.19867635600983283}} {"text": "\"\"\"\nCode to export from yt to Sunrise\n\n\n\n\"\"\"\nfrom __future__ import print_function\n\n#-----------------------------------------------------------------------------\n# Copyright (c) 2013, yt Development Team.\n#\n# Distributed under the terms of the Modified BSD License.\n#\n# The full license is in the file COPYING.txt, distributed with this software.\n#-----------------------------------------------------------------------------\n\ntry:\n import pyfits\nexcept ImportError: \n pass\n\nimport time\nimport numpy as np\nfrom yt.funcs import *\nimport yt.utilities.lib.api as amr_utils\nfrom yt.utilities.physical_constants import \\\n kpc_per_cm, \\\n sec_per_year\nfrom yt.mods import *\n\ndef export_to_sunrise(ds, fn, star_particle_type, fc, fwidth, ncells_wide=None,\n debug=False,dd=None,**kwargs):\n r\"\"\"Convert the contents of a dataset to a FITS file format that Sunrise\n understands.\n\n This function will accept a dataset, and from that dataset\n construct a depth-first octree containing all of the data in the parameter\n file. This octree will be written to a FITS file. It will probably be\n quite big, so use this function with caution! Sunrise is a tool for\n generating synthetic spectra, available at\n http://sunrise.googlecode.com/ .\n\n Parameters\n ----------\n ds : `Dataset`\n The dataset to convert.\n fn : string\n The filename of the output FITS file.\n fc : array\n The center of the extraction region\n fwidth : array \n Ensure this radius around the center is enclosed\n Array format is (nx,ny,nz) where each element is floating point\n in unitary position units where 0 is leftmost edge and 1\n the rightmost. \n\n Notes\n -----\n\n Note that the process of generating simulated images from Sunrise will\n require substantial user input; see the Sunrise wiki at\n http://sunrise.googlecode.com/ for more information.\n\n \"\"\"\n fc = np.array(fc)\n fwidth = np.array(fwidth)\n \n #we must round the dle,dre to the nearest root grid cells\n ile,ire,super_level,ncells_wide= \\\n round_ncells_wide(ds.domain_dimensions,fc-fwidth,fc+fwidth,nwide=ncells_wide)\n\n assert np.all((ile-ire)==(ile-ire)[0])\n mylog.info(\"rounding specified region:\")\n mylog.info(\"from [%1.5f %1.5f %1.5f]-[%1.5f %1.5f %1.5f]\"%(tuple(fc-fwidth)+tuple(fc+fwidth)))\n mylog.info(\"to [%07i %07i %07i]-[%07i %07i %07i]\"%(tuple(ile)+tuple(ire)))\n fle,fre = ile*1.0/ds.domain_dimensions, ire*1.0/ds.domain_dimensions\n mylog.info(\"to [%1.5f %1.5f %1.5f]-[%1.5f %1.5f %1.5f]\"%(tuple(fle)+tuple(fre)))\n\n #Create a list of the star particle properties in PARTICLE_DATA\n #Include ID, parent-ID, position, velocity, creation_mass, \n #formation_time, mass, age_m, age_l, metallicity, L_bol\n particle_data,nstars = prepare_star_particles(ds,star_particle_type,fle=fle,fre=fre,\n dd=dd,**kwargs)\n\n #Create the refinement hilbert octree in GRIDSTRUCTURE\n #For every leaf (not-refined) cell we have a column n GRIDDATA\n #Include mass_gas, mass_metals, gas_temp_m, gas_teff_m, cell_volume, SFR\n #since the octree always starts with one cell, an our 0-level mesh\n #may have many cells, we must create the octree region sitting \n #ontop of the first mesh by providing a negative level\n output, refinement,dd,nleaf = prepare_octree(ds,ile,start_level=super_level,\n debug=debug,dd=dd,center=fc)\n\n create_fits_file(ds,fn, refinement,output,particle_data,fle,fre)\n\n return fle,fre,ile,ire,dd,nleaf,nstars\n\ndef export_to_sunrise_from_halolist(ds,fni,star_particle_type,\n halo_list,domains_list=None,**kwargs):\n \"\"\"\n Using the center of mass and the virial radius\n for a halo, calculate the regions to extract for sunrise.\n The regions are defined on the root grid, and so individual\n octs may span a large range encompassing many halos\n and subhalos. Instead of repeating the oct extraction for each\n halo, arrange halos such that we only calculate what we need to.\n\n Parameters\n ----------\n ds : `Dataset`\n The dataset to convert. We use the root grid to specify the domain.\n fni : string\n The filename of the output FITS file, but depends on the domain. The\n dle and dre are appended to the name.\n particle_type : int\n The particle index for stars\n halo_list : list of halo objects\n The halo list objects must have halo.CoM and halo.Rvir,\n both of which are assumed to be in unitary length units.\n frvir (optional) : float\n Ensure that CoM +/- frvir*Rvir is contained within each domain\n domains_list (optiona): dict of halos\n Organize halos into a dict of domains. Keys are DLE/DRE tuple\n values are a list of halos\n \"\"\"\n dn = ds.domain_dimensions\n if domains_list is None:\n domains_list = domains_from_halos(ds,halo_list,**kwargs)\n if fni.endswith('.fits'):\n fni = fni.replace('.fits','')\n\n for (num_halos, domain, halos) in domains_list:\n dle,dre = domain\n print('exporting: ')\n print(\"[%03i %03i %03i] -\"%tuple(dle), end=' ')\n print(\"[%03i %03i %03i] \"%tuple(dre), end=' ')\n print(\" with %i halos\"%num_halos)\n dle,dre = domain\n dle, dre = np.array(dle),np.array(dre)\n fn = fni \n fn += \"%03i_%03i_%03i-\"%tuple(dle)\n fn += \"%03i_%03i_%03i\"%tuple(dre)\n fnf = fn + '.fits'\n fnt = fn + '.halos'\n if os.path.exists(fnt):\n os.remove(fnt)\n fh = open(fnt,'w')\n for halo in halos:\n fh.write(\"%i \"%halo.ID)\n fh.write(\"%6.6e \"%(halo.CoM[0]*ds['kpc']))\n fh.write(\"%6.6e \"%(halo.CoM[1]*ds['kpc']))\n fh.write(\"%6.6e \"%(halo.CoM[2]*ds['kpc']))\n fh.write(\"%6.6e \"%(halo.Mvir))\n fh.write(\"%6.6e \\n\"%(halo.Rvir*ds['kpc']))\n fh.close()\n export_to_sunrise(ds, fnf, star_particle_type, dle*1.0/dn, dre*1.0/dn)\n\ndef domains_from_halos(ds,halo_list,frvir=0.15):\n domains = {}\n dn = ds.domain_dimensions\n for halo in halo_list:\n fle, fre = halo.CoM-frvir*halo.Rvir,halo.CoM+frvir*halo.Rvir\n dle,dre = np.floor(fle*dn), np.ceil(fre*dn)\n dle,dre = tuple(dle.astype('int')),tuple(dre.astype('int'))\n if (dle,dre) in domains.keys():\n domains[(dle,dre)] += halo,\n else:\n domains[(dle,dre)] = [halo,]\n #for niceness, let's process the domains in order of \n #the one with the most halos\n domains_list = [(len(v),k,v) for k,v in domains.iteritems()]\n domains_list.sort() \n domains_list.reverse() #we want the most populated domains first\n return domains_list\n\ndef prepare_octree(ds,ile,start_level=0,debug=True,dd=None,center=None):\n if dd is None:\n #we keep passing dd around to not regenerate the data all the time\n dd = ds.all_data()\n try:\n dd['MetalMass']\n except KeyError:\n add_fields() #add the metal mass field that sunrise wants\n def _temp_times_mass(field, data):\n return data[\"Temperature\"]*data[\"CellMassMsun\"]\n add_field(\"TemperatureTimesCellMassMsun\", function=_temp_times_mass)\n fields = [\"CellMassMsun\",\"TemperatureTimesCellMassMsun\", \n \"MetalMass\",\"CellVolumeCode\"]\n \n #gather the field data from octs\n pbar = get_pbar(\"Retrieving field data\",len(fields))\n field_data = [] \n for fi,f in enumerate(fields):\n field_data += dd[f],\n pbar.update(fi)\n pbar.finish()\n del field_data\n\n #first we cast every cell as an oct\n #ngrids = np.max([g.id for g in ds._grids])\n grids = {}\n levels_all = {} \n levels_finest = {}\n for l in range(100): \n levels_finest[l]=0\n levels_all[l]=0\n pbar = get_pbar(\"Initializing octs \",len(ds.index.grids))\n for gi,g in enumerate(ds.index.grids):\n ff = np.array([g[f] for f in fields])\n og = amr_utils.OctreeGrid(\n g.child_index_mask.astype('int32'),\n ff.astype(\"float64\"),\n g.LeftEdge.astype(\"float64\"),\n g.ActiveDimensions.astype(\"int32\"),\n np.ones(1,dtype=\"float64\")*g.dds[0],\n g.Level,\n g.id)\n grids[g.id] = og\n #how many refinement cells will we have?\n #measure the 'volume' of each mesh, but many\n #cells do not exist. an overstimate\n levels_all[g.Level] += g.ActiveDimensions.prod()\n #how many leaves do we have?\n #this overestimates. a child of -1 means no child,\n #but that cell may still be expanded on a submesh because\n #(at least in ART) the meshes are inefficient.\n g.clear_data()\n pbar.update(gi)\n pbar.finish()\n \n #create the octree grid list\n #oct_list = amr_utils.OctreeGridList(grids)\n \n #initialize arrays to be passed to the recursion algo\n o_length = np.sum(levels_all.values())\n r_length = np.sum(levels_all.values())\n output = np.zeros((o_length,len(fields)), dtype='float64')\n refined = np.zeros(r_length, dtype='int32')\n levels = np.zeros(r_length, dtype='int32')\n ids = np.zeros(r_length, dtype='int32')\n pos = position()\n hs = hilbert_state()\n start_time = time.time()\n if debug:\n printing = lambda x: print_oct(x)\n else:\n printing = None\n pbar = get_pbar(\"Building Hilbert DFO octree\",len(refined))\n RecurseOctreeDepthFirstHilbert(\n ile,\n pos,\n grids[0], #we always start on the root grid\n hs, \n output,refined,levels,\n grids,\n start_level,\n ids,\n debug=printing,\n tracker=pbar)\n pbar.finish()\n #by time we get it here the 'current' position is actually \n #for the next spot, so we're off by 1\n print('took %1.2e seconds'%(time.time()-start_time))\n print('refinement tree # of cells %i, # of leaves %i'%(pos.refined_pos,pos.output_pos)) \n print('first few entries :',refined[:12])\n output = output[:pos.output_pos]\n refined = refined[:pos.refined_pos] \n levels = levels[:pos.refined_pos] \n return output,refined,dd,pos.refined_pos\n\ndef print_oct(data,nd=None,nc=None):\n ci = data['cell_index']\n l = data['level']\n g = data['grid']\n o = g.offset\n fle = g.left_edges+g.dx*ci\n fre = g.left_edges+g.dx*(ci+1)\n if nd is not None:\n fle *= nd\n fre *= nd\n if nc is not None:\n fle -= nc\n fre -= nc\n txt = '%+1i '\n txt += '%+1i '\n txt += '%+1.3f '*3+'- '\n txt += '%+1.3f '*3\n if l<2:\n print(txt%((l,)+(o,)+tuple(fle)+tuple(fre)))\n\ndef RecurseOctreeDepthFirstHilbert(cell_index, #integer (rep as a float) on the [grid_index]\n pos, #the output hydro data position and refinement position\n grid, #grid that this oct lives on (not its children)\n hilbert, #the hilbert state\n output, #holds the hydro data\n refined, #holds the refinement status of Octs, 0s and 1s\n levels, #For a given Oct, what is the level\n grids, #list of all patch grids available to us\n level, #starting level of the oct (not the children)\n ids, #record the oct ID\n debug=None,tracker=True):\n if tracker is not None:\n if pos.refined_pos%1000 == 500 : tracker.update(pos.refined_pos)\n if debug is not None: \n debug(vars())\n child_grid_index = grid.child_indices[cell_index[0],cell_index[1],cell_index[2]]\n #record the refinement state\n levels[pos.refined_pos] = level\n is_leaf = (child_grid_index==-1) and (level>0)\n refined[pos.refined_pos] = not is_leaf #True is oct, False is leaf\n ids[pos.refined_pos] = child_grid_index #True is oct, False is leaf\n pos.refined_pos+= 1 \n if is_leaf: #never subdivide if we are on a superlevel\n #then we have hit a leaf cell; write it out\n for field_index in range(grid.fields.shape[0]):\n output[pos.output_pos,field_index] = \\\n grid.fields[field_index,cell_index[0],cell_index[1],cell_index[2]]\n pos.output_pos+= 1 \n else:\n assert child_grid_index>-1\n #find the grid we descend into\n #then find the eight cells we break up into\n subgrid = grids[child_grid_index]\n #calculate the floating point LE of the children\n #then translate onto the subgrid integer index \n parent_fle = grid.left_edges + cell_index*grid.dx\n subgrid_ile = np.floor((parent_fle - subgrid.left_edges)/subgrid.dx)\n for (vertex, hilbert_child) in hilbert:\n #vertex is a combination of three 0s and 1s to \n #denote each of the 8 octs\n if level < 0:\n subgrid = grid #we don't actually descend if we're a superlevel\n #child_ile = cell_index + np.array(vertex)*2**(-level)\n child_ile = cell_index + np.array(vertex)*2**(-(level+1))\n child_ile = child_ile.astype('int')\n else:\n child_ile = subgrid_ile+np.array(vertex)\n child_ile = child_ile.astype('int')\n\n RecurseOctreeDepthFirstHilbert(child_ile,pos,\n subgrid,hilbert_child,output,refined,levels,grids,\n level+1,ids = ids,\n debug=debug,tracker=tracker)\n\n\n\ndef create_fits_file(ds,fn, refined,output,particle_data,fle,fre):\n #first create the grid structure\n structure = pyfits.Column(\"structure\", format=\"B\", array=refined.astype(\"bool\"))\n cols = pyfits.ColDefs([structure])\n st_table = pyfits.new_table(cols)\n st_table.name = \"GRIDSTRUCTURE\"\n st_table.header.update(\"hierarch lengthunit\", \"kpc\", comment=\"Length unit for grid\")\n fdx = fre-fle\n for i,a in enumerate('xyz'):\n st_table.header.update(\"min%s\" % a, fle[i] * ds['kpc'])\n st_table.header.update(\"max%s\" % a, fre[i] * ds['kpc'])\n st_table.header.update(\"n%s\" % a, fdx[i])\n st_table.header.update(\"subdiv%s\" % a, 2)\n st_table.header.update(\"subdivtp\", \"OCTREE\", \"Type of grid subdivision\")\n\n #not the hydro grid data\n fields = [\"CellMassMsun\",\"TemperatureTimesCellMassMsun\", \n \"MetalMass\",\"CellVolumeCode\"]\n fd = {}\n for i,f in enumerate(fields): \n fd[f]=output[:,i]\n del output\n col_list = []\n size = fd[\"CellMassMsun\"].size\n tm = fd[\"CellMassMsun\"].sum()\n col_list.append(pyfits.Column(\"mass_gas\", format='D',\n array=fd['CellMassMsun'], unit=\"Msun\"))\n col_list.append(pyfits.Column(\"mass_metals\", format='D',\n array=fd['MetalMass'], unit=\"Msun\"))\n # col_list.append(pyfits.Column(\"mass_stars\", format='D',\n # array=np.zeros(size,dtype='D'),unit=\"Msun\"))\n # col_list.append(pyfits.Column(\"mass_stellar_metals\", format='D',\n # array=np.zeros(size,dtype='D'),unit=\"Msun\"))\n # col_list.append(pyfits.Column(\"age_m\", format='D',\n # array=np.zeros(size,dtype='D'),unit=\"yr*Msun\"))\n # col_list.append(pyfits.Column(\"age_l\", format='D',\n # array=np.zeros(size,dtype='D'),unit=\"yr*Msun\"))\n # col_list.append(pyfits.Column(\"L_bol\", format='D',\n # array=np.zeros(size,dtype='D')))\n # col_list.append(pyfits.Column(\"L_lambda\", format='D',\n # array=np.zeros(size,dtype='D')))\n # The units for gas_temp are really K*Msun. For older Sunrise versions\n # you must set the unit to just K \n col_list.append(pyfits.Column(\"gas_temp_m\", format='D',\n array=fd['TemperatureTimesCellMassMsun'], unit=\"K*Msun\"))\n col_list.append(pyfits.Column(\"gas_teff_m\", format='D',\n array=fd['TemperatureTimesCellMassMsun'], unit=\"K*Msun\"))\n col_list.append(pyfits.Column(\"cell_volume\", format='D',\n array=fd['CellVolumeCode'].astype('float64')*ds['kpc']**3.0,\n unit=\"kpc^3\"))\n col_list.append(pyfits.Column(\"SFR\", format='D',\n array=np.zeros(size, dtype='D')))\n cols = pyfits.ColDefs(col_list)\n mg_table = pyfits.new_table(cols)\n mg_table.header.update(\"M_g_tot\", tm)\n mg_table.header.update(\"timeunit\", \"yr\")\n mg_table.header.update(\"tempunit\", \"K\")\n mg_table.name = \"GRIDDATA\"\n\n # Add a dummy Primary; might be a better way to do this!\n col_list = [pyfits.Column(\"dummy\", format=\"F\", array=np.zeros(1, dtype='float32'))]\n cols = pyfits.ColDefs(col_list)\n md_table = pyfits.new_table(cols)\n md_table.header.update(\"snaptime\", ds.current_time*ds['years'])\n md_table.name = \"YT\"\n\n phdu = pyfits.PrimaryHDU()\n phdu.header.update('nbodycod','yt')\n hls = [phdu, st_table, mg_table,md_table]\n hls.append(particle_data)\n hdus = pyfits.HDUList(hls)\n hdus.writeto(fn, clobber=True)\n\ndef nearest_power(x):\n #round to the nearest power of 2\n x-=1\n x |= x >> 1\n x |= x >> 2 \n x |= x >> 4\n x |= x >> 8\n x |= x >> 16\n x+=1 \n return x\n\ndef round_ncells_wide(dds,fle,fre,nwide=None):\n fc = (fle+fre)/2.0\n assert np.all(fle < fc)\n assert np.all(fre > fc)\n ic = np.rint(fc*dds) #nearest vertex to the center\n ile,ire = ic.astype('int'),ic.astype('int')\n cfle,cfre = fc.copy(),fc.copy()\n idx = np.array([0,0,0]) #just a random non-equal array\n width = 0.0\n if nwide is None:\n #expand until borders are included and\n #we have an equaly-sized, non-zero box\n idxq,out=False,True\n while not out or not idxq:\n cfle,cfre = fc-width, fc+width\n ile = np.rint(cfle*dds).astype('int')\n ire = np.rint(cfre*dds).astype('int')\n idx = ire-ile\n width += 0.1/dds\n #quit if idxq is true:\n idxq = idx[0]>0 and np.all(idx==idx[0])\n out = np.all(fle>cfle) and np.all(fre0\n maxlevel = -np.rint(np.log2(nwide)).astype('int')\n assert abs(np.log2(nwide)-np.rint(np.log2(nwide)))<1e-5 #nwide should be a power of 2\n return ile,ire,maxlevel,nwide\n\ndef round_nearest_edge(ds,fle,fre):\n dds = ds.domain_dimensions\n ile = np.floor(fle*dds).astype('int')\n ire = np.ceil(fre*dds).astype('int') \n \n #this is the number of cells the super octree needs to expand to\n #must round to the nearest power of 2\n width = np.max(ire-ile)\n width = nearest_power(width)\n \n maxlevel = -np.rint(np.log2(width)).astype('int')\n return ile,ire,maxlevel\n\ndef prepare_star_particles(ds,star_type,pos=None,vel=None, age=None,\n creation_time=None,initial_mass=None,\n current_mass=None,metallicity=None,\n radius = None,\n fle=[0.,0.,0.],fre=[1.,1.,1.],\n dd=None):\n if dd is None:\n dd = ds.all_data()\n idxst = dd[\"particle_type\"] == star_type\n\n #make sure we select more than a single particle\n assert na.sum(idxst)>0\n if pos is None:\n pos = np.array([dd[\"particle_position_%s\" % ax]\n for ax in 'xyz']).transpose()\n idx = idxst & np.all(pos>fle,axis=1) & np.all(pos0\n pos = pos[idx]*ds['kpc'] #unitary units -> kpc\n if age is None:\n age = dd[\"particle_age\"][idx]*ds['years'] # seconds->years\n if vel is None:\n vel = np.array([dd[\"particle_velocity_%s\" % ax][idx]\n for ax in 'xyz']).transpose()\n # Velocity is cm/s, we want it to be kpc/yr\n #vel *= (ds[\"kpc\"]/ds[\"cm\"]) / (365*24*3600.)\n vel *= kpc_per_cm * sec_per_year\n if initial_mass is None:\n #in solar masses\n initial_mass = dd[\"particle_mass_initial\"][idx]*ds['Msun']\n if current_mass is None:\n #in solar masses\n current_mass = dd[\"particle_mass\"][idx]*ds['Msun']\n if metallicity is None:\n #this should be in dimensionless units, metals mass / particle mass\n metallicity = dd[\"particle_metallicity\"][idx]\n assert np.all(metallicity>0.0)\n if radius is None:\n radius = initial_mass*0.0+10.0/1000.0 #10pc radius\n formation_time = ds.current_time*ds['years']-age\n #create every column\n col_list = []\n col_list.append(pyfits.Column(\"ID\", format=\"J\", array=np.arange(current_mass.size).astype('int32')))\n col_list.append(pyfits.Column(\"parent_ID\", format=\"J\", array=np.arange(current_mass.size).astype('int32')))\n col_list.append(pyfits.Column(\"position\", format=\"3D\", array=pos, unit=\"kpc\"))\n col_list.append(pyfits.Column(\"velocity\", format=\"3D\", array=vel, unit=\"kpc/yr\"))\n col_list.append(pyfits.Column(\"creation_mass\", format=\"D\", array=initial_mass, unit=\"Msun\"))\n col_list.append(pyfits.Column(\"formation_time\", format=\"D\", array=formation_time, unit=\"yr\"))\n col_list.append(pyfits.Column(\"radius\", format=\"D\", array=radius, unit=\"kpc\"))\n col_list.append(pyfits.Column(\"mass\", format=\"D\", array=current_mass, unit=\"Msun\"))\n col_list.append(pyfits.Column(\"age\", format=\"D\", array=age,unit='yr'))\n #For particles, Sunrise takes \n #the dimensionless metallicity, not the mass of the metals\n col_list.append(pyfits.Column(\"metallicity\", format=\"D\",\n array=metallicity,unit=\"Msun\")) \n \n #make the table\n cols = pyfits.ColDefs(col_list)\n pd_table = pyfits.new_table(cols)\n pd_table.name = \"PARTICLEDATA\"\n \n #make sure we have nonzero particle number\n assert pd_table.data.shape[0]>0\n return pd_table,na.sum(idx)\n\n\ndef add_fields():\n \"\"\"Add three Eulerian fields Sunrise uses\"\"\"\n def _MetalMass(field, data):\n return data[\"Metallicity\"] * data[\"CellMassMsun\"]\n \n def _convMetalMass(data):\n return 1.0\n add_field(\"MetalMass\", function=_MetalMass,\n convert_function=_convMetalMass)\n def _initial_mass_cen_ostriker(field, data):\n # SFR in a cell. This assumes stars were created by the Cen & Ostriker algorithm\n # Check Grid_AddToDiskProfile.C and star_maker7.src\n star_mass_ejection_fraction = data.ds.get_parameter(\"StarMassEjectionFraction\",float)\n star_maker_minimum_dynamical_time = 3e6 # years, which will get divided out\n dtForSFR = star_maker_minimum_dynamical_time / data.ds[\"years\"]\n xv1 = ((data.ds[\"InitialTime\"] - data[\"creation_time\"])\n / data[\"dynamical_time\"])\n xv2 = ((data.ds[\"InitialTime\"] + dtForSFR - data[\"creation_time\"])\n / data[\"dynamical_time\"])\n denom = (1.0 - star_mass_ejection_fraction * (1.0 - (1.0 + xv1)*np.exp(-xv1)))\n minitial = data[\"ParticleMassMsun\"] / denom\n return minitial\n\n add_field(\"InitialMassCenOstriker\", function=_initial_mass_cen_ostriker)\n\n\nclass position:\n def __init__(self):\n self.output_pos = 0\n self.refined_pos = 0\n\nclass hilbert_state():\n def __init__(self,dim=None,sgn=None,octant=None):\n if dim is None: dim = [0,1,2]\n if sgn is None: sgn = [1,1,1]\n if octant is None: octant = 5\n self.dim = dim\n self.sgn = sgn\n self.octant = octant\n def flip(self,i):\n self.sgn[i]*=-1\n def swap(self,i,j):\n temp = self.dim[i]\n self.dim[i]=self.dim[j]\n self.dim[j]=temp\n axis = self.sgn[i]\n self.sgn[i] = self.sgn[j]\n self.sgn[j] = axis\n def reorder(self,i,j,k):\n ndim = [self.dim[i],self.dim[j],self.dim[k]] \n nsgn = [self.sgn[i],self.sgn[j],self.sgn[k]]\n self.dim = ndim\n self.sgn = nsgn\n def copy(self):\n return hilbert_state([self.dim[0],self.dim[1],self.dim[2]],\n [self.sgn[0],self.sgn[1],self.sgn[2]],\n self.octant)\n def descend(self,o):\n child = self.copy()\n child.octant = o\n if o==0:\n child.swap(0,2)\n elif o==1:\n child.swap(1,2)\n elif o==2:\n pass\n elif o==3:\n child.flip(0)\n child.flip(2)\n child.reorder(2,0,1)\n elif o==4:\n child.flip(0)\n child.flip(1)\n child.reorder(2,0,1)\n elif o==5:\n pass\n elif o==6:\n child.flip(1)\n child.flip(2)\n child.swap(1,2)\n elif o==7:\n child.flip(0)\n child.flip(2)\n child.swap(0,2)\n return child\n\n def __iter__(self):\n vertex = [0,0,0]\n j=0\n for i in range(3):\n vertex[self.dim[i]] = 0 if self.sgn[i]>0 else 1\n yield vertex, self.descend(j)\n vertex[self.dim[0]] += self.sgn[0]\n j+=1\n yield vertex, self.descend(j)\n vertex[self.dim[1]] += self.sgn[1] \n j+=1\n yield vertex, self.descend(j)\n vertex[self.dim[0]] -= self.sgn[0] \n j+=1\n yield vertex, self.descend(j)\n vertex[self.dim[2]] += self.sgn[2] \n j+=1\n yield vertex, self.descend(j)\n vertex[self.dim[0]] += self.sgn[0] \n j+=1\n yield vertex, self.descend(j)\n vertex[self.dim[1]] -= self.sgn[1] \n j+=1\n yield vertex, self.descend(j)\n vertex[self.dim[0]] -= self.sgn[0] \n j+=1\n yield vertex, self.descend(j)\n\n", "meta": {"hexsha": "3f2de4defd15d4e47404349602332f549a256bc8", "size": 26090, "ext": "py", "lang": "Python", "max_stars_repo_path": "yt/analysis_modules/sunrise_export/sunrise_exporter.py", "max_stars_repo_name": "danielgrassinger/yt_new_frontend", "max_stars_repo_head_hexsha": "5f91d2fb8721c4c5da0af543a6256ed979cd9fc9", "max_stars_repo_licenses": ["BSD-3-Clause-Clear"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "yt/analysis_modules/sunrise_export/sunrise_exporter.py", "max_issues_repo_name": "danielgrassinger/yt_new_frontend", "max_issues_repo_head_hexsha": "5f91d2fb8721c4c5da0af543a6256ed979cd9fc9", "max_issues_repo_licenses": ["BSD-3-Clause-Clear"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2016-04-05T22:30:14.000Z", "max_issues_repo_issues_event_max_datetime": "2016-04-05T22:30:14.000Z", "max_forks_repo_path": "yt/analysis_modules/sunrise_export/sunrise_exporter.py", "max_forks_repo_name": "danielgrassinger/yt_new_frontend", "max_forks_repo_head_hexsha": "5f91d2fb8721c4c5da0af543a6256ed979cd9fc9", "max_forks_repo_licenses": ["BSD-3-Clause-Clear"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-12-05T05:51:09.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-05T05:51:09.000Z", "avg_line_length": 39.3514328808, "max_line_length": 111, "alphanum_fraction": 0.5972019931, "include": true, "reason": "import numpy", "num_tokens": 7106, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5698526514141571, "lm_q2_score": 0.34864512179822543, "lm_q1q2_score": 0.1986763470593305}} {"text": "# -*- coding: utf-8 -*-\n\n# Max-Planck-Gesellschaft zur Förderung der Wissenschaften e.V. (MPG) is\n# holder of all proprietary rights on this computer program.\n# You can only use this computer program if you have closed\n# a license agreement with MPG or you get the right to use the computer\n# program from someone who is authorized to grant you that right.\n# Any use of the computer program without a valid license is prohibited and\n# liable to prosecution.\n#\n# Copyright©2019 Max-Planck-Gesellschaft zur Förderung\n# der Wissenschaften e.V. (MPG). acting on behalf of its Max Planck Institute\n# for Intelligent Systems. All rights reserved.\n#\n# Contact: ps-license@tuebingen.mpg.de\n\nfrom __future__ import absolute_import\nfrom __future__ import print_function\nfrom __future__ import division\n\nimport numpy as np\n\nimport torch\nimport torch.nn.functional as F\n\n\ndef rot_mat_to_euler(rot_mats):\n # Calculates rotation matrix to euler angles\n # Careful for extreme cases of eular angles like [0.0, pi, 0.0]\n\n sy = torch.sqrt(rot_mats[:, 0, 0] * rot_mats[:, 0, 0] +\n rot_mats[:, 1, 0] * rot_mats[:, 1, 0])\n return torch.atan2(-rot_mats[:, 2, 0], sy)\n\n\ndef find_dynamic_lmk_idx_and_bcoords(vertices, pose, dynamic_lmk_faces_idx,\n dynamic_lmk_b_coords,\n neck_kin_chain, dtype=torch.float32):\n ''' Compute the faces, barycentric coordinates for the dynamic landmarks\n\n\n To do so, we first compute the rotation of the neck around the y-axis\n and then use a pre-computed look-up table to find the faces and the\n barycentric coordinates that will be used.\n\n Special thanks to Soubhik Sanyal (soubhik.sanyal@tuebingen.mpg.de)\n for providing the original TensorFlow implementation and for the LUT.\n\n Parameters\n ----------\n vertices: torch.tensor BxVx3, dtype = torch.float32\n The tensor of input vertices\n pose: torch.tensor Bx(Jx3), dtype = torch.float32\n The current pose of the body model\n dynamic_lmk_faces_idx: torch.tensor L, dtype = torch.long\n The look-up table from neck rotation to faces\n dynamic_lmk_b_coords: torch.tensor Lx3, dtype = torch.float32\n The look-up table from neck rotation to barycentric coordinates\n neck_kin_chain: list\n A python list that contains the indices of the joints that form the\n kinematic chain of the neck.\n dtype: torch.dtype, optional\n\n Returns\n -------\n dyn_lmk_faces_idx: torch.tensor, dtype = torch.long\n A tensor of size BxL that contains the indices of the faces that\n will be used to compute the current dynamic landmarks.\n dyn_lmk_b_coords: torch.tensor, dtype = torch.float32\n A tensor of size BxL that contains the indices of the faces that\n will be used to compute the current dynamic landmarks.\n '''\n\n batch_size = vertices.shape[0]\n\n aa_pose = torch.index_select(pose.view(batch_size, -1, 3), 1,\n neck_kin_chain)\n rot_mats = batch_rodrigues(\n aa_pose.view(-1, 3), dtype=dtype).view(batch_size, -1, 3, 3)\n\n rel_rot_mat = torch.eye(\n 3, device=vertices.device, dtype=dtype).unsqueeze_(dim=0).repeat(\n batch_size, 1, 1)\n for idx in range(len(neck_kin_chain)):\n rel_rot_mat = torch.bmm(rot_mats[:, idx], rel_rot_mat)\n\n y_rot_angle = torch.round(\n torch.clamp(-rot_mat_to_euler(rel_rot_mat) * 180.0 / np.pi,\n max=39)).to(dtype=torch.long)\n neg_mask = y_rot_angle.lt(0).to(dtype=torch.long)\n mask = y_rot_angle.lt(-39).to(dtype=torch.long)\n neg_vals = mask * 78 + (1 - mask) * (39 - y_rot_angle)\n y_rot_angle = (neg_mask * neg_vals +\n (1 - neg_mask) * y_rot_angle)\n\n dyn_lmk_faces_idx = torch.index_select(dynamic_lmk_faces_idx,\n 0, y_rot_angle)\n dyn_lmk_b_coords = torch.index_select(dynamic_lmk_b_coords,\n 0, y_rot_angle)\n\n return dyn_lmk_faces_idx, dyn_lmk_b_coords\n\n\ndef vertices2landmarks(vertices, faces, lmk_faces_idx, lmk_bary_coords):\n ''' Calculates landmarks by barycentric interpolation\n\n Parameters\n ----------\n vertices: torch.tensor BxVx3, dtype = torch.float32\n The tensor of input vertices\n faces: torch.tensor Fx3, dtype = torch.long\n The faces of the mesh\n lmk_faces_idx: torch.tensor L, dtype = torch.long\n The tensor with the indices of the faces used to calculate the\n landmarks.\n lmk_bary_coords: torch.tensor Lx3, dtype = torch.float32\n The tensor of barycentric coordinates that are used to interpolate\n the landmarks\n\n Returns\n -------\n landmarks: torch.tensor BxLx3, dtype = torch.float32\n The coordinates of the landmarks for each mesh in the batch\n '''\n # Extract the indices of the vertices for each face\n # BxLx3\n batch_size, num_verts = vertices.shape[:2]\n device = vertices.device\n\n lmk_faces = torch.index_select(faces, 0, lmk_faces_idx.view(-1)).view(\n batch_size, -1, 3)\n\n lmk_faces += torch.arange(\n batch_size, dtype=torch.long, device=device).view(-1, 1, 1) * num_verts\n\n lmk_vertices = vertices.view(-1, 3)[lmk_faces].view(\n batch_size, -1, 3, 3)\n\n landmarks = torch.einsum('blfi,blf->bli', [lmk_vertices, lmk_bary_coords])\n return landmarks\n\n\ndef joints2bones(joints, parents):\n ''' Decompose joints location to bone length and direction.\n\n Parameters\n ----------\n joints: torch.tensor Bx24x3\n '''\n assert joints.shape[1] == parents.shape[0]\n bone_dirs = torch.zeros_like(joints)\n bone_lens = torch.zeros_like(joints[:, :, :1])\n\n for c_id in range(parents.shape[0]):\n p_id = parents[c_id]\n if p_id == -1:\n # Parent node\n bone_dirs[:, c_id] = joints[:, c_id]\n else:\n # Child node\n # (B, 3)\n diff = joints[:, c_id] - joints[:, p_id]\n length = torch.norm(diff, dim=1, keepdim=True) + 1e-8\n direct = diff / length\n\n bone_dirs[:, c_id] = direct\n bone_lens[:, c_id] = length\n\n return bone_dirs, bone_lens\n\n\ndef bones2joints(bone_dirs, bone_lens, parents):\n ''' Recover bone length and direction to joints location.\n\n Parameters\n ----------\n bone_dirs: torch.tensor 1x24x3\n bone_lens: torch.tensor Bx24x1\n '''\n batch_size = bone_lens.shape[0]\n joints = torch.zeros_like(bone_dirs).expand(batch_size, 24, 3)\n\n for c_id in range(parents.shape[0]):\n p_id = parents[c_id]\n if p_id == -1:\n # Parent node\n joints[:, c_id] = bone_dirs[:, c_id]\n else:\n # Child node\n joints[:, c_id] = joints[:, p_id] + bone_dirs[:, c_id] * bone_lens[:, c_id]\n\n return joints\n\n\ndef lbs(betas, pose, v_template, shapedirs, posedirs, J_regressor, J_regressor_h36m, parents,\n lbs_weights, pose2rot=True, dtype=torch.float32):\n ''' Performs Linear Blend Skinning with the given shape and pose parameters\n\n Parameters\n ----------\n betas : torch.tensor BxNB\n The tensor of shape parameters\n pose : torch.tensor Bx(J + 1) * 3\n The pose parameters in axis-angle format\n v_template torch.tensor BxVx3\n The template mesh that will be deformed\n shapedirs : torch.tensor 1xNB\n The tensor of PCA shape displacements\n posedirs : torch.tensor Px(V * 3)\n The pose PCA coefficients\n J_regressor : torch.tensor JxV\n The regressor array that is used to calculate the joints from\n the position of the vertices\n parents: torch.tensor J\n The array that describes the kinematic tree for the model\n lbs_weights: torch.tensor N x V x (J + 1)\n The linear blend skinning weights that represent how much the\n rotation matrix of each part affects each vertex\n pose2rot: bool, optional\n Flag on whether to convert the input pose tensor to rotation\n matrices. The default value is True. If False, then the pose tensor\n should already contain rotation matrices and have a size of\n Bx(J + 1)x9\n dtype: torch.dtype, optional\n\n Returns\n -------\n verts: torch.tensor BxVx3\n The vertices of the mesh after applying the shape and pose\n displacements.\n joints: torch.tensor BxJx3\n The joints of the model\n rot_mats: torch.tensor BxJx3x3\n The rotation matrics of each joints\n '''\n batch_size = max(betas.shape[0], pose.shape[0])\n device = betas.device\n\n # Add shape contribution\n v_shaped = v_template + blend_shapes(betas, shapedirs)\n\n # Get the joints\n # NxJx3 array\n J = vertices2joints(J_regressor, v_shaped)\n\n # 3. Add pose blend shapes\n # N x J x 3 x 3\n ident = torch.eye(3, dtype=dtype, device=device)\n if pose2rot:\n if pose.numel() == batch_size * 24 * 4:\n rot_mats = quat_to_rotmat(pose.reshape(batch_size * 24, 4)).reshape(batch_size, 24, 3, 3)\n else:\n rot_mats = batch_rodrigues(\n pose.view(-1, 3), dtype=dtype).view([batch_size, -1, 3, 3])\n\n pose_feature = (rot_mats[:, 1:, :, :] - ident).view([batch_size, -1])\n # (N x P) x (P, V * 3) -> N x V x 3\n pose_offsets = torch.matmul(pose_feature, posedirs) \\\n .view(batch_size, -1, 3)\n else:\n pose_feature = pose[:, 1:].view(batch_size, -1, 3, 3) - ident\n rot_mats = pose.view(batch_size, -1, 3, 3)\n\n pose_offsets = torch.matmul(pose_feature.view(batch_size, -1),\n posedirs).view(batch_size, -1, 3)\n\n v_posed = pose_offsets + v_shaped\n # 4. Get the global joint location\n J_transformed, A = batch_rigid_transform(rot_mats, J, parents[:24], dtype=dtype)\n\n # 5. Do skinning:\n # W is N x V x (J + 1)\n W = lbs_weights.unsqueeze(dim=0).expand([batch_size, -1, -1])\n # (N x V x (J + 1)) x (N x (J + 1) x 16)\n num_joints = J_regressor.shape[0]\n T = torch.matmul(W, A.view(batch_size, num_joints, 16)) \\\n .view(batch_size, -1, 4, 4)\n\n homogen_coord = torch.ones([batch_size, v_posed.shape[1], 1],\n dtype=dtype, device=device)\n v_posed_homo = torch.cat([v_posed, homogen_coord], dim=2)\n v_homo = torch.matmul(T, torch.unsqueeze(v_posed_homo, dim=-1))\n\n verts = v_homo[:, :, :3, 0]\n\n J_from_verts = vertices2joints(J_regressor_h36m, verts)\n\n return verts, J_transformed, rot_mats, J_from_verts\n\n\ndef hybrik(betas, global_orient, pose_skeleton, phis,\n v_template, shapedirs, posedirs, J_regressor, J_regressor_h36m, parents, children,\n lbs_weights, dtype=torch.float32, train=False, leaf_thetas=None):\n ''' Performs Linear Blend Skinning with the given shape and skeleton joints\n\n Parameters\n ----------\n betas : torch.tensor BxNB\n The tensor of shape parameters\n global_orient : torch.tensor Bx3\n The tensor of global orientation\n pose_skeleton : torch.tensor BxJ*3\n The pose skeleton in (X, Y, Z) format\n phis : torch.tensor BxJx2\n The rotation on bone axis parameters\n v_template torch.tensor BxVx3\n The template mesh that will be deformed\n shapedirs : torch.tensor 1xNB\n The tensor of PCA shape displacements\n posedirs : torch.tensor Px(V * 3)\n The pose PCA coefficients\n J_regressor : torch.tensor JxV\n The regressor array that is used to calculate the joints from\n the position of the vertices\n J_regressor_h36m : torch.tensor 17xV\n The regressor array that is used to calculate the 17 Human3.6M joints from\n the position of the vertices\n parents: torch.tensor J\n The array that describes the kinematic parents for the model\n children: dict\n The dictionary that describes the kinematic chidrens for the model\n lbs_weights: torch.tensor N x V x (J + 1)\n The linear blend skinning weights that represent how much the\n rotation matrix of each part affects each vertex\n dtype: torch.dtype, optional\n\n Returns\n -------\n verts: torch.tensor BxVx3\n The vertices of the mesh after applying the shape and pose\n displacements.\n joints: torch.tensor BxJx3\n The joints of the model\n rot_mats: torch.tensor BxJx3x3\n The rotation matrics of each joints\n '''\n batch_size = max(betas.shape[0], pose_skeleton.shape[0])\n device = betas.device\n\n # 1. Add shape contribution\n v_shaped = v_template + blend_shapes(betas, shapedirs)\n\n # 2. Get the rest joints\n # NxJx3 array\n if leaf_thetas is not None:\n rest_J = vertices2joints(J_regressor, v_shaped)\n else:\n rest_J = torch.zeros((v_shaped.shape[0], 29, 3), dtype=dtype, device=device)\n rest_J[:, :24] = vertices2joints(J_regressor, v_shaped)\n\n leaf_number = [411, 2445, 5905, 3216, 6617]\n leaf_vertices = v_shaped[:, leaf_number].clone()\n rest_J[:, 24:] = leaf_vertices\n\n # 3. Get the rotation matrics\n rot_mats, rotate_rest_pose = batch_inverse_kinematics_transform(\n pose_skeleton, global_orient, phis,\n rest_J.clone(), children, parents, dtype=dtype, train=train,\n leaf_thetas=leaf_thetas)\n\n test_joints = True\n if test_joints:\n J_transformed, A = batch_rigid_transform(rot_mats, rest_J[:, :24].clone(), parents[:24], dtype=dtype)\n else:\n J_transformed = None\n\n # assert torch.mean(torch.abs(rotate_rest_pose - J_transformed)) < 1e-5\n # 4. Add pose blend shapes\n # rot_mats: N x (J + 1) x 3 x 3\n ident = torch.eye(3, dtype=dtype, device=device)\n pose_feature = (rot_mats[:, 1:] - ident).view([batch_size, -1])\n pose_offsets = torch.matmul(pose_feature, posedirs) \\\n .view(batch_size, -1, 3)\n\n v_posed = pose_offsets + v_shaped\n\n # 5. Do skinning:\n # W is N x V x (J + 1)\n W = lbs_weights.unsqueeze(dim=0).expand([batch_size, -1, -1])\n # (N x V x (J + 1)) x (N x (J + 1) x 16)\n num_joints = J_regressor.shape[0]\n T = torch.matmul(W, A.view(batch_size, num_joints, 16)) \\\n .view(batch_size, -1, 4, 4)\n\n homogen_coord = torch.ones([batch_size, v_posed.shape[1], 1],\n dtype=dtype, device=device)\n v_posed_homo = torch.cat([v_posed, homogen_coord], dim=2)\n v_homo = torch.matmul(T, torch.unsqueeze(v_posed_homo, dim=-1))\n\n verts = v_homo[:, :, :3, 0]\n J_from_verts_h36m = vertices2joints(J_regressor_h36m, verts)\n\n return verts, J_transformed, rot_mats, J_from_verts_h36m\n\n\ndef vertices2joints(J_regressor, vertices):\n ''' Calculates the 3D joint locations from the vertices\n\n Parameters\n ----------\n J_regressor : torch.tensor JxV\n The regressor array that is used to calculate the joints from the\n position of the vertices\n vertices : torch.tensor BxVx3\n The tensor of mesh vertices\n\n Returns\n -------\n torch.tensor BxJx3\n The location of the joints\n '''\n\n return torch.einsum('bik,ji->bjk', [vertices, J_regressor])\n\n\ndef blend_shapes(betas, shape_disps):\n ''' Calculates the per vertex displacement due to the blend shapes\n\n\n Parameters\n ----------\n betas : torch.tensor Bx(num_betas)\n Blend shape coefficients\n shape_disps: torch.tensor Vx3x(num_betas)\n Blend shapes\n\n Returns\n -------\n torch.tensor BxVx3\n The per-vertex displacement due to shape deformation\n '''\n\n # Displacement[b, m, k] = sum_{l} betas[b, l] * shape_disps[m, k, l]\n # i.e. Multiply each shape displacement by its corresponding beta and\n # then sum them.\n blend_shape = torch.einsum('bl,mkl->bmk', [betas, shape_disps])\n return blend_shape\n\n\ndef batch_rodrigues(rot_vecs, epsilon=1e-8, dtype=torch.float32):\n ''' Calculates the rotation matrices for a batch of rotation vectors\n Parameters\n ----------\n rot_vecs: torch.tensor Nx3\n array of N axis-angle vectors\n Returns\n -------\n R: torch.tensor Nx3x3\n The rotation matrices for the given axis-angle parameters\n '''\n\n batch_size = rot_vecs.shape[0]\n device = rot_vecs.device\n\n angle = torch.norm(rot_vecs + 1e-8, dim=1, keepdim=True)\n rot_dir = rot_vecs / angle\n\n cos = torch.unsqueeze(torch.cos(angle), dim=1)\n sin = torch.unsqueeze(torch.sin(angle), dim=1)\n\n # Bx1 arrays\n rx, ry, rz = torch.split(rot_dir, 1, dim=1)\n K = torch.zeros((batch_size, 3, 3), dtype=dtype, device=device)\n\n zeros = torch.zeros((batch_size, 1), dtype=dtype, device=device)\n K = torch.cat([zeros, -rz, ry, rz, zeros, -rx, -ry, rx, zeros], dim=1) \\\n .view((batch_size, 3, 3))\n\n ident = torch.eye(3, dtype=dtype, device=device).unsqueeze(dim=0)\n rot_mat = ident + sin * K + (1 - cos) * torch.bmm(K, K)\n return rot_mat\n\n\ndef transform_mat(R, t):\n ''' Creates a batch of transformation matrices\n Args:\n - R: Bx3x3 array of a batch of rotation matrices\n - t: Bx3x1 array of a batch of translation vectors\n Returns:\n - T: Bx4x4 Transformation matrix\n '''\n # No padding left or right, only add an extra row\n return torch.cat([F.pad(R, [0, 0, 0, 1]),\n F.pad(t, [0, 0, 0, 1], value=1)], dim=2)\n\n\ndef batch_rigid_transform(rot_mats, joints, parents, dtype=torch.float32):\n \"\"\"\n Applies a batch of rigid transformations to the joints\n\n Parameters\n ----------\n rot_mats : torch.tensor BxNx3x3\n Tensor of rotation matrices\n joints : torch.tensor BxNx3\n Locations of joints. (Template Pose)\n parents : torch.tensor BxN\n The kinematic tree of each object\n dtype : torch.dtype, optional:\n The data type of the created tensors, the default is torch.float32\n\n Returns\n -------\n posed_joints : torch.tensor BxNx3\n The locations of the joints after applying the pose rotations\n rel_transforms : torch.tensor BxNx4x4\n The relative (with respect to the root joint) rigid transformations\n for all the joints\n \"\"\"\n joints = torch.unsqueeze(joints, dim=-1)\n rel_joints = joints.clone()\n rel_joints[:, 1:] -= joints[:, parents[1:]].clone()\n\n # (B, K + 1, 4, 4)\n transforms_mat = transform_mat(\n rot_mats.reshape(-1, 3, 3),\n rel_joints.reshape(-1, 3, 1)).reshape(-1, joints.shape[1], 4, 4)\n\n transform_chain = [transforms_mat[:, 0]]\n for i in range(1, parents.shape[0]):\n # Subtract the joint location at the rest pose\n # No need for rotation, since it's identity when at rest\n # (B, 4, 4) x (B, 4, 4)\n curr_res = torch.matmul(transform_chain[parents[i]],\n transforms_mat[:, i])\n transform_chain.append(curr_res)\n\n # (B, K + 1, 4, 4)\n transforms = torch.stack(transform_chain, dim=1)\n\n # The last column of the transformations contains the posed joints\n posed_joints = transforms[:, :, :3, 3]\n\n # The last column of the transformations contains the posed joints\n posed_joints = transforms[:, :, :3, 3]\n\n joints_homogen = F.pad(joints, [0, 0, 0, 1])\n\n rel_transforms = transforms - F.pad(\n torch.matmul(transforms, joints_homogen), [3, 0, 0, 0, 0, 0, 0, 0])\n\n return posed_joints, rel_transforms\n\n\ndef batch_inverse_kinematics_transform(\n pose_skeleton, global_orient,\n phis,\n rest_pose,\n children, parents, dtype=torch.float32, train=False,\n leaf_thetas=None):\n \"\"\"\n Applies a batch of inverse kinematics transfoirm to the joints\n\n Parameters\n ----------\n pose_skeleton : torch.tensor BxNx3\n Locations of estimated pose skeleton.\n global_orient : torch.tensor Bx1x3x3\n Tensor of global rotation matrices\n phis : torch.tensor BxNx2\n The rotation on bone axis parameters\n rest_pose : torch.tensor Bx(N+1)x3\n Locations of rest_pose. (Template Pose)\n children: dict\n The dictionary that describes the kinematic chidrens for the model\n parents : torch.tensor Bx(N+1)\n The kinematic tree of each object\n dtype : torch.dtype, optional:\n The data type of the created tensors, the default is torch.float32\n\n Returns\n -------\n rot_mats: torch.tensor Bx(N+1)x3x3\n The rotation matrics of each joints\n rel_transforms : torch.tensor Bx(N+1)x4x4\n The relative (with respect to the root joint) rigid transformations\n for all the joints\n \"\"\"\n batch_size = pose_skeleton.shape[0]\n device = pose_skeleton.device\n\n rel_rest_pose = rest_pose.clone()\n rel_rest_pose[:, 1:] -= rest_pose[:, parents[1:]].clone()\n rel_rest_pose = torch.unsqueeze(rel_rest_pose, dim=-1)\n\n # rotate the T pose\n rotate_rest_pose = torch.zeros_like(rel_rest_pose)\n # set up the root\n rotate_rest_pose[:, 0] = rel_rest_pose[:, 0]\n\n rel_pose_skeleton = torch.unsqueeze(pose_skeleton.clone(), dim=-1).detach()\n rel_pose_skeleton[:, 1:] = rel_pose_skeleton[:, 1:] - rel_pose_skeleton[:, parents[1:]].clone()\n rel_pose_skeleton[:, 0] = rel_rest_pose[:, 0]\n\n # the predicted final pose\n final_pose_skeleton = torch.unsqueeze(pose_skeleton.clone(), dim=-1)\n final_pose_skeleton = final_pose_skeleton - final_pose_skeleton[:, 0:1] + rel_rest_pose[:, 0:1]\n\n rel_rest_pose = rel_rest_pose\n rel_pose_skeleton = rel_pose_skeleton\n final_pose_skeleton = final_pose_skeleton\n rotate_rest_pose = rotate_rest_pose\n\n assert phis.dim() == 3\n phis = phis / (torch.norm(phis, dim=2, keepdim=True) + 1e-8)\n\n # TODO\n if train:\n global_orient_mat = batch_get_pelvis_orient(\n rel_pose_skeleton.clone(), rel_rest_pose.clone(), parents, children, dtype)\n else:\n global_orient_mat = batch_get_pelvis_orient_svd(\n rel_pose_skeleton.clone(), rel_rest_pose.clone(), parents, children, dtype)\n\n rot_mat_chain = [global_orient_mat]\n rot_mat_local = [global_orient_mat]\n # leaf nodes rot_mats\n if leaf_thetas is not None:\n leaf_cnt = 0\n leaf_rot_mats = leaf_thetas.view([batch_size, 5, 3, 3])\n\n for i in range(1, parents.shape[0]):\n if children[i] == -1:\n # leaf nodes\n if leaf_thetas is not None:\n rot_mat = leaf_rot_mats[:, leaf_cnt, :, :]\n leaf_cnt += 1\n\n rotate_rest_pose[:, i] = rotate_rest_pose[:, parents[i]] + torch.matmul(\n rot_mat_chain[parents[i]],\n rel_rest_pose[:, i]\n )\n\n rot_mat_chain.append(torch.matmul(\n rot_mat_chain[parents[i]],\n rot_mat))\n rot_mat_local.append(rot_mat)\n elif children[i] == -3:\n # three children\n rotate_rest_pose[:, i] = rotate_rest_pose[:, parents[i]] + torch.matmul(\n rot_mat_chain[parents[i]],\n rel_rest_pose[:, i]\n )\n\n spine_child = []\n for c in range(1, parents.shape[0]):\n if parents[c] == i and c not in spine_child:\n spine_child.append(c)\n\n # original\n spine_child = []\n for c in range(1, parents.shape[0]):\n if parents[c] == i and c not in spine_child:\n spine_child.append(c)\n\n children_final_loc = []\n children_rest_loc = []\n for c in spine_child:\n temp = final_pose_skeleton[:, c] - rotate_rest_pose[:, i]\n children_final_loc.append(temp)\n\n children_rest_loc.append(rel_rest_pose[:, c].clone())\n\n rot_mat = batch_get_3children_orient_svd(\n children_final_loc, children_rest_loc,\n rot_mat_chain[parents[i]], spine_child, dtype)\n\n rot_mat_chain.append(\n torch.matmul(\n rot_mat_chain[parents[i]],\n rot_mat)\n )\n rot_mat_local.append(rot_mat)\n else:\n # (B, 3, 1)\n rotate_rest_pose[:, i] = rotate_rest_pose[:, parents[i]] + torch.matmul(\n rot_mat_chain[parents[i]],\n rel_rest_pose[:, i]\n )\n # (B, 3, 1)\n child_final_loc = final_pose_skeleton[:, children[i]] - rotate_rest_pose[:, i]\n\n if not train:\n orig_vec = rel_pose_skeleton[:, children[i]]\n template_vec = rel_rest_pose[:, children[i]]\n norm_t = torch.norm(template_vec, dim=1, keepdim=True)\n orig_vec = orig_vec * norm_t / torch.norm(orig_vec, dim=1, keepdim=True)\n\n diff = torch.norm(child_final_loc - orig_vec, dim=1, keepdim=True)\n big_diff_idx = torch.where(diff > 15 / 1000)[0]\n\n child_final_loc[big_diff_idx] = orig_vec[big_diff_idx]\n\n child_final_loc = torch.matmul(\n rot_mat_chain[parents[i]].transpose(1, 2),\n child_final_loc)\n\n child_rest_loc = rel_rest_pose[:, children[i]]\n # (B, 1, 1)\n child_final_norm = torch.norm(child_final_loc, dim=1, keepdim=True)\n child_rest_norm = torch.norm(child_rest_loc, dim=1, keepdim=True)\n\n child_final_norm = torch.norm(child_final_loc, dim=1, keepdim=True)\n\n # (B, 3, 1)\n axis = torch.cross(child_rest_loc, child_final_loc, dim=1)\n axis_norm = torch.norm(axis, dim=1, keepdim=True)\n\n # (B, 1, 1)\n cos = torch.sum(child_rest_loc * child_final_loc, dim=1, keepdim=True) / (child_rest_norm * child_final_norm + 1e-8)\n sin = axis_norm / (child_rest_norm * child_final_norm + 1e-8)\n\n # (B, 3, 1)\n axis = axis / (axis_norm + 1e-8)\n\n # Convert location revolve to rot_mat by rodrigues\n # (B, 1, 1)\n rx, ry, rz = torch.split(axis, 1, dim=1)\n zeros = torch.zeros((batch_size, 1, 1), dtype=dtype, device=device)\n\n K = torch.cat([zeros, -rz, ry, rz, zeros, -rx, -ry, rx, zeros], dim=1) \\\n .view((batch_size, 3, 3))\n ident = torch.eye(3, dtype=dtype, device=device).unsqueeze(dim=0)\n rot_mat_loc = ident + sin * K + (1 - cos) * torch.bmm(K, K)\n\n # Convert spin to rot_mat\n # (B, 3, 1)\n spin_axis = child_rest_loc / child_rest_norm\n # (B, 1, 1)\n rx, ry, rz = torch.split(spin_axis, 1, dim=1)\n zeros = torch.zeros((batch_size, 1, 1), dtype=dtype, device=device)\n K = torch.cat([zeros, -rz, ry, rz, zeros, -rx, -ry, rx, zeros], dim=1) \\\n .view((batch_size, 3, 3))\n ident = torch.eye(3, dtype=dtype, device=device).unsqueeze(dim=0)\n # (B, 1, 1)\n cos, sin = torch.split(phis[:, i - 1], 1, dim=1)\n cos = torch.unsqueeze(cos, dim=2)\n sin = torch.unsqueeze(sin, dim=2)\n rot_mat_spin = ident + sin * K + (1 - cos) * torch.bmm(K, K)\n rot_mat = torch.matmul(rot_mat_loc, rot_mat_spin)\n\n rot_mat_chain.append(torch.matmul(\n rot_mat_chain[parents[i]],\n rot_mat))\n rot_mat_local.append(rot_mat)\n\n # (B, K + 1, 3, 3)\n rot_mats = torch.stack(rot_mat_local, dim=1)\n\n return rot_mats, rotate_rest_pose.squeeze(-1)\n\n\ndef batch_get_pelvis_orient_svd(rel_pose_skeleton, rel_rest_pose, parents, children, dtype):\n pelvis_child = [int(children[0])]\n for i in range(1, parents.shape[0]):\n if parents[i] == 0 and i not in pelvis_child:\n pelvis_child.append(i)\n\n rest_mat = []\n target_mat = []\n for child in pelvis_child:\n rest_mat.append(rel_rest_pose[:, child].clone())\n target_mat.append(rel_pose_skeleton[:, child].clone())\n\n rest_mat = torch.cat(rest_mat, dim=2)\n target_mat = torch.cat(target_mat, dim=2)\n S = rest_mat.bmm(target_mat.transpose(1, 2))\n\n mask_zero = S.sum(dim=(1, 2))\n\n S_non_zero = S[mask_zero != 0].reshape(-1, 3, 3)\n\n U, _, V = torch.svd(S_non_zero)\n\n rot_mat = torch.zeros_like(S)\n rot_mat[mask_zero == 0] = torch.eye(3, device=S.device)\n\n rot_mat_non_zero = torch.bmm(V, U.transpose(1, 2))\n rot_mat[mask_zero != 0] = rot_mat_non_zero\n\n assert torch.sum(torch.isnan(rot_mat)) == 0, ('rot_mat', rot_mat)\n\n return rot_mat\n\n\ndef batch_get_pelvis_orient(rel_pose_skeleton, rel_rest_pose, parents, children, dtype):\n batch_size = rel_pose_skeleton.shape[0]\n device = rel_pose_skeleton.device\n\n assert children[0] == 3\n pelvis_child = [int(children[0])]\n for i in range(1, parents.shape[0]):\n if parents[i] == 0 and i not in pelvis_child:\n pelvis_child.append(i)\n\n spine_final_loc = rel_pose_skeleton[:, int(children[0])].clone()\n spine_rest_loc = rel_rest_pose[:, int(children[0])].clone()\n spine_norm = torch.norm(spine_final_loc, dim=1, keepdim=True)\n spine_norm = spine_final_loc / (spine_norm + 1e-8)\n\n rot_mat_spine = vectors2rotmat(spine_rest_loc, spine_final_loc, dtype)\n\n assert torch.sum(torch.isnan(rot_mat_spine)\n ) == 0, ('rot_mat_spine', rot_mat_spine)\n center_final_loc = 0\n center_rest_loc = 0\n for child in pelvis_child:\n if child == int(children[0]):\n continue\n center_final_loc = center_final_loc + rel_pose_skeleton[:, child].clone()\n center_rest_loc = center_rest_loc + rel_rest_pose[:, child].clone()\n center_final_loc = center_final_loc / (len(pelvis_child) - 1)\n center_rest_loc = center_rest_loc / (len(pelvis_child) - 1)\n\n center_rest_loc = torch.matmul(rot_mat_spine, center_rest_loc)\n\n center_final_loc = center_final_loc - torch.sum(center_final_loc * spine_norm, dim=1, keepdim=True) * spine_norm\n center_rest_loc = center_rest_loc - torch.sum(center_rest_loc * spine_norm, dim=1, keepdim=True) * spine_norm\n\n center_final_loc_norm = torch.norm(center_final_loc, dim=1, keepdim=True)\n center_rest_loc_norm = torch.norm(center_rest_loc, dim=1, keepdim=True)\n\n # (B, 3, 1)\n axis = torch.cross(center_rest_loc, center_final_loc, dim=1)\n axis_norm = torch.norm(axis, dim=1, keepdim=True)\n\n # (B, 1, 1)\n cos = torch.sum(center_rest_loc * center_final_loc, dim=1, keepdim=True) / (center_rest_loc_norm * center_final_loc_norm + 1e-8)\n sin = axis_norm / (center_rest_loc_norm * center_final_loc_norm + 1e-8)\n\n assert torch.sum(torch.isnan(cos)\n ) == 0, ('cos', cos)\n assert torch.sum(torch.isnan(sin)\n ) == 0, ('sin', sin)\n # (B, 3, 1)\n axis = axis / (axis_norm + 1e-8)\n\n # Convert location revolve to rot_mat by rodrigues\n # (B, 1, 1)\n rx, ry, rz = torch.split(axis, 1, dim=1)\n zeros = torch.zeros((batch_size, 1, 1), dtype=dtype, device=device)\n\n K = torch.cat([zeros, -rz, ry, rz, zeros, -rx, -ry, rx, zeros], dim=1) \\\n .view((batch_size, 3, 3))\n ident = torch.eye(3, dtype=dtype, device=device).unsqueeze(dim=0)\n rot_mat_center = ident + sin * K + (1 - cos) * torch.bmm(K, K)\n\n rot_mat = torch.matmul(rot_mat_center, rot_mat_spine)\n\n return rot_mat\n\n\ndef batch_get_3children_orient_svd(rel_pose_skeleton, rel_rest_pose, rot_mat_chain_parent, children_list, dtype):\n rest_mat = []\n target_mat = []\n for c, child in enumerate(children_list):\n if isinstance(rel_pose_skeleton, list):\n target = rel_pose_skeleton[c].clone()\n template = rel_rest_pose[c].clone()\n else:\n target = rel_pose_skeleton[:, child].clone()\n template = rel_rest_pose[:, child].clone()\n\n target = torch.matmul(\n rot_mat_chain_parent.transpose(1, 2),\n target)\n\n target_mat.append(target)\n rest_mat.append(template)\n\n rest_mat = torch.cat(rest_mat, dim=2)\n target_mat = torch.cat(target_mat, dim=2)\n S = rest_mat.bmm(target_mat.transpose(1, 2))\n\n U, _, V = torch.svd(S)\n\n rot_mat = torch.bmm(V, U.transpose(1, 2))\n assert torch.sum(torch.isnan(rot_mat)) == 0, ('3children rot_mat', rot_mat)\n return rot_mat\n\n\ndef vectors2rotmat(vec_rest, vec_final, dtype):\n batch_size = vec_final.shape[0]\n device = vec_final.device\n\n # (B, 1, 1)\n vec_final_norm = torch.norm(vec_final, dim=1, keepdim=True)\n vec_rest_norm = torch.norm(vec_rest, dim=1, keepdim=True)\n\n # (B, 3, 1)\n axis = torch.cross(vec_rest, vec_final, dim=1)\n axis_norm = torch.norm(axis, dim=1, keepdim=True)\n\n # (B, 1, 1)\n cos = torch.sum(vec_rest * vec_final, dim=1, keepdim=True) / (vec_rest_norm * vec_final_norm + 1e-8)\n sin = axis_norm / (vec_rest_norm * vec_final_norm + 1e-8)\n\n # (B, 3, 1)\n axis = axis / (axis_norm + 1e-8)\n\n # Convert location revolve to rot_mat by rodrigues\n # (B, 1, 1)\n rx, ry, rz = torch.split(axis, 1, dim=1)\n zeros = torch.zeros((batch_size, 1, 1), dtype=dtype, device=device)\n\n K = torch.cat([zeros, -rz, ry, rz, zeros, -rx, -ry, rx, zeros], dim=1) \\\n .view((batch_size, 3, 3))\n ident = torch.eye(3, dtype=dtype, device=device).unsqueeze(dim=0)\n rot_mat_loc = ident + sin * K + (1 - cos) * torch.bmm(K, K)\n\n return rot_mat_loc\n\n\ndef rotmat_to_quat(rotmat):\n \"\"\"Convert rotation matrix to quaternion coefficients.\n Args:\n rotmat: size is [B, 3, 3]\n Returns:\n Quaternion: size is [B, 4] <===> (w, x, y, z)\n \"\"\"\n quaternion = torch.zeros([rotmat.size(0), 4], device=rotmat.device)\n trace = rotmat[:, 0, 0] + rotmat[:, 1, 1] + rotmat[:, 2, 2]\n flag = 1 + trace > 0\n s = torch.zeros_like(trace)\n\n # pos\n s[flag] = 2 * torch.sqrt(1 + trace[flag]) + 1e-16\n s_pos = s[flag]\n quaternion[flag, 0] = s_pos / 4\n quaternion[flag, 1] = (rotmat[flag, 2, 1] - rotmat[flag, 1, 2]) / s_pos\n quaternion[flag, 2] = (rotmat[flag, 0, 2] - rotmat[flag, 2, 0]) / s_pos\n quaternion[flag, 3] = (rotmat[flag, 1, 0] - rotmat[flag, 0, 1]) / s_pos\n\n # neg\n diag = torch.stack([rotmat[:, 0, 0], rotmat[:, 1, 1], rotmat[:, 2, 2]])\n max_val, max_ind = torch.max(diag, dim=0)\n\n s[~flag] = 2 * torch.sqrt(1 - trace[~flag] + 2 * max_val[~flag]) + 1e-16\n\n f0 = ~flag * (max_ind == 0)\n s0 = s[f0]\n quaternion[f0, 0] = (rotmat[f0, 2, 1] - rotmat[f0, 1, 2]) / s0\n quaternion[f0, 1] = s0 / 4\n quaternion[f0, 2] = (rotmat[f0, 0, 1] + rotmat[f0, 1, 0]) / s0\n quaternion[f0, 3] = (rotmat[f0, 0, 2] + rotmat[f0, 2, 0]) / s0\n\n f1 = ~flag * (max_ind == 1)\n s1 = s[f1]\n quaternion[f1, 0] = (rotmat[f1, 0, 2] - rotmat[f1, 2, 0]) / s1\n quaternion[f1, 1] = (rotmat[f1, 0, 1] + rotmat[f1, 1, 0]) / s1\n quaternion[f1, 2] = s1 / 4\n quaternion[f1, 3] = (rotmat[f1, 1, 2] + rotmat[f1, 2, 1]) / s1\n\n f2 = ~flag * (max_ind == 2)\n s2 = s[f2]\n quaternion[f2, 0] = (rotmat[f2, 1, 0] - rotmat[f2, 0, 1]) / s2\n quaternion[f2, 1] = (rotmat[f2, 0, 2] + rotmat[f2, 2, 0]) / s2\n quaternion[f2, 2] = (rotmat[f2, 1, 2] + rotmat[f2, 2, 1]) / s2\n quaternion[f2, 3] = s2 / 4\n\n return quaternion\n\n\ndef quat_to_rotmat(quat):\n \"\"\"Convert quaternion coefficients to rotation matrix.\n Args:\n quat: size = [B, 4] 4 <===>(w, x, y, z)\n Returns:\n Rotation matrix corresponding to the quaternion -- size = [B, 3, 3]\n \"\"\"\n norm_quat = quat\n norm_quat = norm_quat / (norm_quat.norm(p=2, dim=1, keepdim=True) + 1e-8)\n w, x, y, z = norm_quat[:, 0], norm_quat[:, 1], norm_quat[:, 2], norm_quat[:, 3]\n\n B = quat.size(0)\n\n w2, x2, y2, z2 = w.pow(2), x.pow(2), y.pow(2), z.pow(2)\n wx, wy, wz = w * x, w * y, w * z\n xy, xz, yz = x * y, x * z, y * z\n\n rotMat = torch.stack([w2 + x2 - y2 - z2, 2 * xy - 2 * wz, 2 * wy + 2 * xz,\n 2 * wz + 2 * xy, w2 - x2 + y2 - z2, 2 * yz - 2 * wx,\n 2 * xz - 2 * wy, 2 * wx + 2 * yz, w2 - x2 - y2 + z2], dim=1).view(B, 3, 3)\n return rotMat\n", "meta": {"hexsha": "3c6fbfec7934efec5e325a9d3596e4af10e43093", "size": 36374, "ext": "py", "lang": "Python", "max_stars_repo_path": "hybrik/models/layers/smpl/lbs.py", "max_stars_repo_name": "uyoung-jeong/HybrIK", "max_stars_repo_head_hexsha": "aff6aeda06e627fc48f7d7c2bffb2245393d7584", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 287, "max_stars_repo_stars_event_min_datetime": "2020-11-30T12:45:20.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T16:03:45.000Z", "max_issues_repo_path": "hybrik/models/layers/smpl/lbs.py", "max_issues_repo_name": "pengyun1314123/HybrIK", "max_issues_repo_head_hexsha": "ae1bc3cea0cc5aa98fb512eeb295c3478b0c598f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 62, "max_issues_repo_issues_event_min_datetime": "2021-01-08T02:06:47.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-15T11:55:58.000Z", "max_forks_repo_path": "hybrik/models/layers/smpl/lbs.py", "max_forks_repo_name": "pengyun1314123/HybrIK", "max_forks_repo_head_hexsha": "ae1bc3cea0cc5aa98fb512eeb295c3478b0c598f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 30, "max_forks_repo_forks_event_min_datetime": "2021-03-04T07:18:03.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-09T06:06:28.000Z", "avg_line_length": 36.9279187817, "max_line_length": 132, "alphanum_fraction": 0.6111783142, "include": true, "reason": "import numpy", "num_tokens": 10158, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5698526368038304, "lm_q2_score": 0.3486451217982255, "lm_q1q2_score": 0.1986763419655114}} {"text": "#!/usr/bin/python\n\"\"\"\nDo MCMC runs to fit FG models to simulated data, over a grid of \n(nu_min, nu_max) values.\n\"\"\"\nimport numpy as np\nimport models\nimport model_list\nimport fitting\nfrom utils import rj2cmb, bands_log\nimport sys, time, os, copy\n#from multiprocessing import Pool\nfrom mpi4py import MPI\n\n# Set-up MPI\ncomm = MPI.COMM_WORLD\nmyid = comm.Get_rank()\nnproc = comm.Get_size()\n\n# Prefix for output files\nPREFIX = \"paper01\"\nNBURN = 500\nNSTEPS = 10000\nNWALKERS = 100\n\n# Reference noise curve (assumes noise file contains sigma_P=sigma_Q=sigma_U \n# in uK_CMB.deg for a given experiment)\nNOISE_FILE = \"data/noise_coreplus_extended.dat\"\n#NOISE_FILE = \"data/core_plus_extended_noise.dat\"\n\n# Band parameter definitions\nnbands = 7\nnthreads = 2\n\n# Set random seed\nSEED = 10\nif len(sys.argv) > 1:\n SEED = int(sys.argv[1])\nprint \"SEED =\", SEED\nnp.random.seed(SEED)\n\n# Lists of input and output models\nin_list = ['cmb', ]; fit_list = ['cmb', ]\n\n# Define input models and their amplitudes/parameters\nallowed_comps = model_list.model_dict\ncmb_model = model_list.cmb_model\n\n# Parse args to define input and output models\nif len(sys.argv) > 2:\n in_list += sys.argv[2].split(\",\")\n fit_list += sys.argv[3].split(\",\")\nelse:\n in_list = ['cmb', 'synch', 'mbb']\n fit_list = ['cmb', 'synch', 'mbb']\n\n# Make sure models are of known types\nfor item in in_list:\n if item not in allowed_comps.keys():\n raise ValueError(\"Unknown component type '%s'\" % item)\nfor item in fit_list:\n if item not in allowed_comps.keys():\n raise ValueError(\"Unknown component type '%s'\" % item)\n\n# Print recognised models and specify name\nprint \"Input components:\", in_list\nprint \"Fitting components:\", fit_list\nname_in = \"-\".join(in_list)\nname_fit = \"-\".join(fit_list)\n\n# Frequency ranges\nnumin_vals = [20., 30., 40.]\nnumax_vals = [300., 400., 500., 600., 700., 800.]\n#numin_vals = [20., ]\n#numax_vals = [300., 700.]\n\n# Temperature/polarisation noise rms for all bands, as a fraction of T_cmb\nfsigma_T = 1e4 #1. / np.sqrt(2.)\nfsigma_P = 1.\n\n# Collect components into lists and set input amplitudes\nmods_in = [allowed_comps[comp] for comp in in_list]\nmods_fit = [allowed_comps[comp] for comp in fit_list]\namps_in = np.array([m.amps() for m in mods_in])\nparams_in = np.array([m.params() for m in mods_in])\n\n# Expand into all combinations of nu_min,max\nnu_min, nu_max = np.meshgrid(numin_vals, numax_vals)\nnu_params = np.column_stack((nu_min.flatten(), nu_max.flatten()))\n\n# Prepare output files for writing\nfilename = \"output/%s_summary_%s.%s_nb%d_seed%d\" \\\n % (PREFIX, name_in, name_fit, nbands, SEED)\ncut_range = np.arange(NSTEPS, step=200)\nfor cut in cut_range:\n fname = filename + \"_cut%d.dat\" % cut\n f = open(fname, 'w')\n f.close()\n\n\ndef model_test(nu, D_vec, Ninv, models_fit, initial_vals=None, burn=500, \n steps=1000, nwalkers=100, cmb_amp_in=None, sample_file=None):\n \"\"\"\n Generate simulated data given an input model, and perform MCMC fit using \n another model.\n \"\"\"\n # Collect together data and noise/instrument model\n beam_mat = np.identity(3*len(nu)) # Beam model\n data_spec = (nu, D_vec, Ninv, beam_mat)\n \n # Get a list of amplitude/parameter names and initial values\n amp_names = []; amp_vals = []; param_names = []; param_vals = []\n amp_parent_model = []; param_parent_model = []\n for mod in models_fit:\n # Parameter names\n amp_names += [\"%s_%s\" % (mod.model, pol) for pol in \"IQU\"]\n param_names += mod.param_names\n \n # Parameter values\n amp_vals = np.concatenate( (amp_vals, mod.amps()) )\n param_vals = np.concatenate( (param_vals, mod.params()) )\n \n # Parent model list\n amp_parent_model.append(mod)\n param_parent_model.append(mod)\n \n # Concatenate parameter lists\n pnames = amp_names + param_names\n pvals = np.concatenate((amp_vals, param_vals))\n parent_model = amp_parent_model + param_parent_model\n \n # Use 'guess' as the initial point for the MCMC if specified \n if initial_vals is None: initial_vals = pvals\n \n # Collect names, initial values, and parent components for the parameters\n param_spec = (pnames, initial_vals, parent_model)\n \n # Run MCMC sampler on this model\n t0 = time.time()\n pnames, samples, logp = fitting.joint_mcmc(data_spec, models_fit, param_spec, \n burn=burn, steps=steps, \n nwalkers=nwalkers, \n nthreads=nthreads,\n sample_file=sample_file)\n print \"MCMC run in %d sec.\" % (time.time() - t0)\n \n # Return parameter names and samples\n return pnames, samples, logp, initial_vals\n\n\ndef run_model(nu_params):\n # Get band definition\n nu_min, nu_max = nu_params\n print \"nu_min = %d GHz, nu_max = %d GHz\" % (nu_min, nu_max)\n nu = bands_log(nu_min, nu_max, nbands)\n label = str(nu_min) + '_' + str(nu_max)\n \n # Make copies of models\n my_mods_in = mods_in\n my_mods_fit = mods_fit\n \n # Name of sample file\n #fname_samples = \"output/%s_samples_%s.%s_nb%d_seed%d_%s.dat\" \\\n # % (PREFIX, name_in, name_fit, nbands, SEED, label)\n fname_samples = None\n \n # Simulate data and run MCMC fit\n D_vec, Ninv = fitting.generate_data(nu, fsigma_T, fsigma_P, \n components=my_mods_in, \n noise_file=NOISE_FILE)\n \n pnames, samples, logp, ini = model_test(nu, D_vec, Ninv, my_mods_fit, \n burn=NBURN, steps=NSTEPS, \n nwalkers=NWALKERS,\n cmb_amp_in=cmb_model.amps(),\n sample_file=fname_samples)\n # Calculate best-fit chisq.\n chisq = -2.*logp\n dof = D_vec.size - len(pnames)\n \n # Get best-fit (max. prob.) parameter values\n maxl_idx = np.argmax(logp)\n bf_params = samples[:, maxl_idx]\n \n \n # Reshape sample array into (Nparams, Nwalkers, Nsamples)\n samples = samples.reshape((samples.shape[0], \n NWALKERS, \n samples.shape[1]/NWALKERS))\n \n # Loop over different burn-in cuts to produce summary stats\n for n, cut in enumerate(cut_range):\n \n # Set output filename\n fname = filename + \"_cut%d.dat\" % cut\n \n # Output mean and bias\n summary_data = [nu_min, nu_max, np.min(chisq), maxl_idx]\n header = \"nu_min nu_max chi2_min maxlike_idx \"\n \n # Loop over parameter names\n for i in range(len(pnames)):\n \n # Mean, std. dev., and fractional shift from true value \n # (for mean, median, and max. likelihood param values)\n _mean = np.mean(samples[i,:,cut:])\n _std = np.std(samples[i,:,cut:])\n _fracbias = (np.mean(samples[i,:,cut:]) - ini[i]) \\\n / np.std(samples[i,:,cut:])\n _med_fracbias = (np.median(samples[i,:,cut:]) - ini[i]) \\\n / np.std(samples[i,:,cut:])\n _ml_fracbias = (bf_params[i] - ini[i]) / np.std(samples[i,:,cut:])\n \n stats = [_mean, _std, _fracbias, _med_fracbias, _ml_fracbias]\n \n # Keep summary stats, to be written to file\n summary_data += stats\n header += \"mean_%s std_%s Delta_%s MedDelta_%s MLDelta_%s \" \\\n % (pnames[i], pnames[i], pnames[i], pnames[i], pnames[i])\n \n # Only output summary stats once\n if n == 0:\n print \"%14s: %+3.3e +/- %3.3e [Delta = %+3.3f, MLDelta = %+3.3f]\" \\\n % (pnames[i], stats[0], stats[1], stats[2], stats[3])\n \n # If file is empty, set flag to write header when saving output\n has_header = False if os.stat(fname).st_size == 0 else True\n \n # Append summary statistics to file\n f = open(fname, 'a')\n if has_header:\n np.savetxt(f, np.atleast_2d(summary_data))\n else:\n np.savetxt(f, np.atleast_2d(summary_data), header=header[:-1])\n f.close()\n\n# Run pool of processes\n#pool = Pool(NPROC)\n#pool.map(run_model, nu_params)\n\nfor i in range(len(nu_params)):\n if i % nproc != myid: continue\n \n # Run the model for this set of params\n run_model(nu_params[i])\n\n", "meta": {"hexsha": "247e8f29eb9ecd6f3e060188ad8b302c0d6294fb", "size": 8600, "ext": "py", "lang": "Python", "max_stars_repo_path": "run_joint_mcmc.py", "max_stars_repo_name": "philbull/SinglePixel", "max_stars_repo_head_hexsha": "0cd3dba84a0a36ab672707154d3cf8dde903872b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "run_joint_mcmc.py", "max_issues_repo_name": "philbull/SinglePixel", "max_issues_repo_head_hexsha": "0cd3dba84a0a36ab672707154d3cf8dde903872b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "run_joint_mcmc.py", "max_forks_repo_name": "philbull/SinglePixel", "max_forks_repo_head_hexsha": "0cd3dba84a0a36ab672707154d3cf8dde903872b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.8178137652, "max_line_length": 83, "alphanum_fraction": 0.5979069767, "include": true, "reason": "import numpy", "num_tokens": 2231, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583269943353745, "lm_q2_score": 0.3557749071749625, "lm_q1q2_score": 0.19863873458294368}} {"text": "from typing import List, Tuple, Optional, Any\nimport time\nimport numba\nimport numpy as np\nimport cv2\nimport reeds_shepp\nfrom .debugger import Debugger\n\n\nclass RRTStar(object):\n def __init__(self):\n self.debug = False\n self.vertices = None # type: Optional[List[RRTStar.StateNode]]\n self.root = None # type: Optional[RRTStar.StateNode]\n self.gain = None # type: Optional[RRTStar.StateNode]\n self.x_best = None # type: Optional[RRTStar.StateNode]\n self.epsilon = 1e-6\n\n self.check_res = 0.3 # type: Optional[float]\n self.check_poly = None # type: Optional[np.ndarray]\n self.exist_res = 0.1\n self.maximum_curvature = 0.2 # type: Optional[float]\n\n self.start = None # type: Optional[RRTStar.StateNode]\n self.goal = None # type: Optional[RRTStar.StateNode]\n self.grid_map = None # type: Optional[np.ndarray]\n self.grid_res = None # type: Optional[float]\n self.grid_ori = None # type: Optional[RRTStar.StateNode]\n self.obstacle = None # type: Optional[int]\n self.heuristic = None # type: Optional[List[(Tuple[float], Tuple[float], Tuple[float])]]\n\n def set_vehicle(self, check_poly, check_res, maximum_curvature):\n # type: (np.ndarray, float, float) -> RRTStar\n \"\"\"\n set parameter of the vehicle\n :param check_poly: contour of the vehicle for collision check. cv2.contour.\n :param check_res: the resolution of curve interpolation.\n :param maximum_curvature: equal to 1/minimum_turning_radius of the vehicle.\n \"\"\"\n self.check_poly, self.check_res, self.maximum_curvature = check_poly, check_res, maximum_curvature\n return self\n\n def preset(self, start, goal, grid_map, grid_res, grid_ori, obstacle, heuristic):\n # type: (StateNode, StateNode, np.ndarray, float, StateNode, int, Any) -> RRTStar\n \"\"\"\n initialize the parameters for planning: Start State, Goal State and other needs.\n :param start: the start state.\n :param goal: the goal state.\n :param grid_map: occupancy grid map.\n :param grid_res: resolution of grid map.\n :param grid_ori: the center point of the occupancy grid map.\n :param obstacle: the value of pixels of the obstacles region.\n :param heuristic: [(state, biasing)], sampling heuristic path.\n state: state (x_o, y_o, a_o) of the point of the path.\n biasing = (x_mu, x_sigma), (y_mu, y_sigma), (a_mu, a_sigma).\n :return: RRTStar object\n \"\"\"\n self.grid_map, self.grid_res, self.grid_ori, self.obstacle = grid_map, grid_res, grid_ori, obstacle\n self.heuristic = heuristic\n self.start, self.goal = start, goal\n self.start.g, self.start.hl = 0, self.cost(start, goal)\n self.start.hu = self.start.hl if self.collision_free(start, goal) else np.inf\n self.start.fl, self.start.fu = self.start.g + self.start.hl, self.start.g + self.start.hu\n self.root, self.gain = self.start, self.goal\n self.vertices, self.x_best = [self.root], self.root\n return self\n\n def planning(self, times, repeat=10, optimize=False, debug=False):\n \"\"\"main flow.\"\"\"\n self.debug = debug\n past = time.time()\n for i in range(times):\n x_new = self.sample_free(i, repeat)\n x_nearest = self.nearest(x_new) if not optimize else self.least(x_new)\n if x_nearest and self.benefit(x_new) and self.collision_free(x_nearest, x_new):\n self.attach(x_nearest, x_new)\n self.rewire(x_new)\n self.x_best = self.best()\n self.branch_and_bound()\n Debugger().debug_planned_path(self, i, switch=self.debug)\n Debugger().debug_planning_hist(self, i, (time.time() - past), switch=True)\n\n def branch_and_bound(self, space=None):\n def out(x):\n vertices.remove(x)\n x.remove()\n vertices = space if space else self.vertices\n vs = filter(lambda x: x.fl > self.x_best.fu + self.epsilon, vertices)\n map(out, vs)\n Debugger().debug_branch_and_bound(vs, switch=self.debug)\n\n def sample_free(self, n, repeat=10, default=((2., .5), (0., np.pi / 4.), (0, np.pi / 6.))):\n \"\"\"sample a state from free configuration space.\"\"\"\n\n def is_free(state):\n contour = self.transform(self.check_poly, state[0], state[1], state[2])\n contour = np.floor(contour / self.grid_res + self.grid_map.shape[0] / 2.).astype(int)\n mask = np.zeros_like(self.grid_map, dtype=np.uint8)\n cv2.fillPoly(mask, [contour], 255)\n result = np.bitwise_and(mask, self.grid_map)\n Debugger().breaker('sample free: {}'.format(np.all(result < self.obstacle)), self.debug)\n return np.all(result < self.obstacle)\n\n def exist(state):\n def key(y):\n dxy = np.fabs(y.state[:-1] - s[:-1])\n da = ((y.state[-1] + np.pi) % (2 * np.pi) - np.pi) - ((s[-1] + np.pi) % (2 * np.pi) - np.pi)\n return dxy[0] < self.exist_res and dxy[1] < self.exist_res and da < self.exist_res\n s = np.array(state)\n result = filter(key, self.vertices)\n Debugger.breaker('sample exclusive: {}'.format(result == []), switch=self.debug)\n return result\n\n def emerge():\n if self.heuristic:\n i = n % len(self.heuristic)\n state, biasing = self.heuristic[i]\n rand = [state[0], state[1], state[2]] # [x_o, y_o, a_o]\n (x_mu, x_sigma), (y_mu, y_sigma), (a_mu, a_sigma) = biasing\n rand[0] += np.random.normal(x_mu, x_sigma)\n rand[1] += np.random.normal(y_mu, y_sigma)\n rand[2] += np.random.normal(a_mu, a_sigma)\n return rand\n else:\n Debugger().debug_no_heuristic(vertex.state, default, self.debug)\n rand = [vertex.state[0], vertex.state[1], vertex.state[2]]\n (r_mu, r_sigma), (t_mu, t_sigma), (a_mu, a_sigma) = default\n r, theta = np.random.normal(r_mu, r_sigma), np.random.normal(t_mu, t_sigma) + rand[2]\n rand[0] += r * np.cos(theta)\n rand[1] += r * np.sin(theta)\n rand[2] += np.random.normal(a_mu, a_sigma)\n return rand\n\n vertex = np.random.choice(self.vertices)\n for i in range(repeat):\n x_rand = emerge()\n Debugger().debug_sampling(x_rand, self.check_poly, switch=self.debug)\n if is_free(x_rand):\n if not exist(x_rand):\n return self.StateNode(tuple(x_rand))\n return self.StateNode(tuple(x_rand))\n\n def nearest(self, x_rand): # type: (StateNode) -> StateNode\n \"\"\"find the state in the tree which is nearest to the sampled state.\n And fill the g, hl and fl properties of the sampled state.\n \"\"\"\n\n def replenish(x_n, x_r):\n x_r.g, x_r.hl = x_n.g + self.cost(x_n, x_r), self.cost(x_r, self.gain)\n x_r.fl = x_r.g + x_r.hl\n\n # quick shot\n if self.collision_free(self.root, x_rand):\n x_nearest = self.root\n else:\n costs = list(map(lambda x: self.cost(x, x_rand), self.vertices))\n x_nearest = self.vertices[int(np.argmin(costs))]\n replenish(x_nearest, x_rand)\n Debugger().debug_nearest_searching(x_nearest.state, switch=self.debug)\n return x_nearest\n\n def least(self, x_rand): # type: (StateNode) -> StateNode\n def replenish(x_n, x_r):\n x_r.g, x_r.hl = x_n.g + self.cost(x_n, x_r), self.cost(x_r, self.gain)\n x_r.fl = x_r.g + x_r.hl\n\n # quick shot\n if self.collision_free(self.root, x_rand):\n x_least = self.root\n else:\n nodes = filter(lambda x: self.collision_free(x, x_rand), self.vertices)\n if nodes:\n costs = list(map(lambda x: x.g + self.cost(x, x_rand), nodes))\n x_least = nodes[int(np.argmin(costs))]\n else:\n x_least = None\n if x_least:\n replenish(x_least, x_rand)\n Debugger().debug_nearest_searching(x_least.state, switch=self.debug)\n return x_least\n\n def benefit(self, x_new):\n words = 'Benefit: {}/ ({}, {})'.format(x_new.fl <= self.x_best.fu, x_new.fl, self.x_best.fu)\n Debugger.breaker(words, switch=self.debug)\n return x_new.fl < self.x_best.fu\n\n def collision_free(self, x_from, x_to): # type: (StateNode, StateNode) -> bool\n \"\"\"check if the path from one state to another state collides with any obstacles or not.\"\"\"\n # making contours of the curve\n states = reeds_shepp.path_sample(x_from.state, x_to.state, 1. / self.maximum_curvature, 0.3)\n # states.append(tuple(x_to.state)) # include the end point\n contours = [self.transform(self.check_poly, s[0], s[1], s[2]) for s in states]\n contours = [np.floor(con / self.grid_res + self.grid_map.shape[0] / 2.).astype(int) for con in contours]\n # making mask\n mask = np.zeros_like(self.grid_map, dtype=np.uint8)\n [cv2.fillPoly(mask, [con], 255) for con in contours]\n # checking\n result = np.bitwise_and(mask, self.grid_map)\n Debugger().debug_collision_checking(states, self.check_poly, np.all(result < self.obstacle), switch=self.debug)\n return np.all(result < self.obstacle)\n\n @staticmethod\n @numba.njit\n def transform(poly, x, y, a):\n pts = poly.transpose()\n xyo = np.array([[x], [y]])\n rot = np.array([[np.cos(a), -np.sin(a)], [np.sin(a), np.cos(a)]])\n return (np.dot(rot, pts) + xyo).transpose()\n\n def attach(self, x_nearest, x_new): # type: (StateNode, StateNode) -> None\n \"\"\"add the new state to the tree and complement other values.\n And fill the hu and fu properties of x_new.\n \"\"\"\n x_new.match(x_nearest)\n available = self.collision_free(x_new, self.gain)\n x_new.hu = x_new.hl if available else np.inf\n x_new.fu = x_new.g + x_new.hu\n x_new.status = 0 if available else 1\n self.vertices.append(x_new)\n Debugger().debug_attaching(x_nearest, x_new, 1. / self.maximum_curvature, switch=self.debug)\n\n def rewire(self, x_new, gamma=0.2): # type: (StateNode, float) -> None\n \"\"\"rewiring tree by the new state.\"\"\"\n\n def recheck(x):\n available, cost = self.collision_free(x_new, x), self.cost(x_new, x)\n if available and x.g > x_new.g + cost:\n Debugger().debug_rewiring(x, x_new.g + cost, switch=self.debug)\n x.g = x_new.g + cost\n x.fu, x.fl = x.g + x.hu, x.g + x.hl\n x.rematch(x_new)\n\n xs = filter(lambda x: x.g > x_new.g + gamma, self.vertices)\n Debugger().debug_rewiring_check(xs, x_new, switch=self.debug)\n map(recheck, xs)\n\n def cost(self, x_from, x_to): # type: (StateNode, StateNode) -> float\n \"\"\"calculate the cost from one state to another state\"\"\"\n return reeds_shepp.path_length(x_from.state, x_to.state, 1. / self.maximum_curvature)\n\n def best(self):\n return sorted(self.vertices, key=lambda x: x.fu)[0]\n\n def spare(self, space=None):\n return sorted(self.vertices if not space else space, key=lambda x: x.hl)[0]\n\n def path(self): # type: () -> List[RRTStar.StateNode]\n \"\"\"extract the planning result. including the goal state if the the goal is available\"\"\"\n x_best = self.best()\n if x_best.fu < np.inf:\n p = x_best.trace()\n self.gain.g = self.gain.fu = x_best.fu\n p.append(self.gain)\n return p\n else:\n x_spare = self.spare()\n return x_spare.trace()\n\n def trajectory(self, a_cc=4, v_max=10, res=0.1):\n \"\"\"\n planning velocity for a path to generate a trajectory.\n \"\"\"\n\n def interpolate(q_ori, segment_type, length, radius):\n x0, y0, a0 = q_ori[0], q_ori[1], q_ori[2]\n transfer = np.array([[np.cos(a0), -np.sin(a0), 0., x0], [np.sin(a0), np.cos(a0), 0., y0], [0., 0., 1., a0]])\n sign, phi = np.sign(length), np.fabs(length) / radius\n if segment_type == 1:\n r = 2 * radius * np.sin(phi / 2.)\n x_lcs = np.array([[r * sign * np.cos(phi / 2.)], [r * np.sin(phi / 2.)], [sign * phi], [1]])\n elif segment_type == 3:\n r = 2 * radius * np.sin(phi / 2.)\n x_lcs = np.array([[r * sign * np.cos(phi / 2.)], [- r * np.sin(phi / 2.)], [- sign * phi], [1]])\n else:\n x_lcs = np.array([[length], [0], [0], [1]])\n x_tar = np.dot(transfer, x_lcs)\n return x_tar[0, 0], x_tar[1, 0], x_tar[2, 0]\n\n def extract_segments(q_from, q_to):\n segments.extend(reeds_shepp.path_type(q_from, q_to, 1. / self.maximum_curvature))\n return q_to\n\n def extract_discontinuities(q0, sgs):\n sg0, sg1 = sgs[0], sgs[1]\n q1 = interpolate(q0, sg0[0], sg0[1], 1. / self.maximum_curvature)\n if sg0[1] * sg1[1] < 0:\n discontinuities2.append(self.Configuration(q1, v=0))\n else:\n discontinuities2.append(self.Configuration(q1))\n return q1\n\n def plan_motions(index_sec):\n motion = []\n v0, v1 = 0, 0\n seg = discontinuities2[index_sec[0]:index_sec[1]+1]\n seg = list(zip(seg[:-1], seg[1:]))\n extent = 0\n for sec in seg:\n s0, s1 = sec[0].state, sec[1].state\n extent += np.abs(reeds_shepp.path_length(s0, s1, 1. / self.maximum_curvature))\n samples = []\n for sec in seg:\n s0, s1 = sec[0].state, sec[1].state\n samples.extend(reeds_shepp.path_sample(s0, s1, 1. / self.maximum_curvature, res))\n\n acc = min([(v_max ** 2 - v1 ** 2) / extent, a_cc])\n vcc = np.sqrt(v1 ** 2 + acc * extent)\n for i, sample in enumerate(samples):\n if i * res < extent / 2.:\n vt = min([np.sqrt(v0 ** 2 + 2 * acc * (i * res)), vcc])\n else:\n vt = min([np.sqrt(v1 ** 2 + 2 * acc * np.abs(extent - i * res)), vcc])\n motion.append(self.Configuration(sample[:3], k=sample[3], v=np.sign(sample[4]) * vt))\n return motion\n\n segments = [] # type: List[(float, float)]\n path = [tuple(node.state) for node in self.path()]\n reduce(extract_segments, path)\n segments = list(zip(segments[:-1], segments[1:])) # type: List[(Tuple[float], Tuple[float])]\n\n discontinuities2 = [] # type: List[(Tuple[float], float)]\n segments.insert(0, tuple(self.root.state))\n reduce(extract_discontinuities, segments)\n\n discontinuities2.append(self.Configuration().from_state_node(self.gain))\n discontinuities2.insert(0, self.Configuration().from_state_node(self.root))\n discontinuity_indexes = []\n for j, dis in enumerate(discontinuities2):\n if dis.v == 0:\n discontinuity_indexes.append(j)\n\n motions = []\n sector_indexes = list(zip(discontinuity_indexes[:-1], discontinuity_indexes[1:]))\n for sector_index in sector_indexes:\n motions.extend(plan_motions(sector_index))\n motions.append(self.Configuration(state=self.gain.state, v=self.gain.v, k=motions[-1].k))\n return motions\n\n class Configuration(object):\n def __init__(self, state=(), v=None, k=None):\n self.state = np.array(state)\n self.v, self.k = v, k\n\n def from_state_node(self, state_node):\n # type: (RRTStar.StateNode) -> RRTStar.Configuration\n self.state = state_node.state\n self.v, self.k = state_node.v, state_node.k\n return self\n\n class StateNode(object):\n def __init__(self, state=()):\n # type: (tuple) -> None\n self.state = np.array(state) # state of the Node, a tuple (x, y, orientation)\n self.g = np.inf # cost from root to here.\n self.hu = np.inf # cost from here to goal if available.\n self.hl = np.inf # cost from here to goal if not available.\n self.fu = self.g + self.hu\n self.fl = self.g + self.hl\n self.parent = None # type: Optional[RRTStar.StateNode]\n self.children = [] # type: List[RRTStar.StateNode]\n self.status = 0 # 0 for safe, 1 for dangerous.\n self.v, self.k = 0, None # velocity of the state, curvature of the state (related to the steering angle)\n\n def match(self, x_parent):\n # type: (RRTStar.StateNode) -> None\n \"\"\"\n add a state as parent.\n \"\"\"\n self.parent = x_parent\n x_parent.children.append(self)\n\n def remove(self):\n if self.parent:\n self.parent.children.remove(self)\n self.parent = None\n\n def rematch(self, x_new_parent):\n if self.parent:\n self.parent.children.remove(self)\n self.match(x_new_parent)\n\n def trace(self): # type: ()->List[RRTStar.StateNode]\n p, ptr = [self], self.parent\n while ptr:\n p.append(ptr)\n ptr = ptr.parent\n p.reverse()\n return p\n\n def lcs2gcs(self, origin):\n # type: (RRTStar.StateNode) -> RRTStar.StateNode\n \"\"\"\n transform self's coordinate from local coordinate system (LCS) to global coordinate system (GCS)\n :param origin: the tuple the coordinate (in GCS) of the origin of LCS.\n \"\"\"\n xo, yo, ao = origin[0], origin[1], origin[2]\n x = self.state[0] * np.cos(ao) - self.state[1] * np.sin(ao) + xo\n y = self.state[0] * np.sin(ao) + self.state[1] * np.cos(ao) + yo\n a = self.state[2] + ao\n self.state = np.array((x, y, a))\n return self\n\n def gcs2lcs(self, origin):\n # type: (RRTStar.StateNode) -> RRTStar.StateNode\n \"\"\"\n transform self's coordinate from global coordinate system (LCS) to local coordinate system (GCS)\n :param origin: the circle-node contains the coordinate (in GCS) of the origin of LCS.\n \"\"\"\n xo, yo, ao = origin[0], origin[1], origin[2]\n x = (self.state[0] - xo) * np.cos(ao) + (self.state[1] - yo) * np.sin(ao)\n y = -(self.state[0] - xo) * np.sin(ao) + (self.state[1] - yo) * np.cos(ao)\n a = self.state[2] - ao\n self.state = np.array((x, y, a))\n return self\n\n\nclass BiRRTStar(RRTStar):\n def __init__(self):\n super(BiRRTStar, self).__init__()\n self.s_vertices = None\n self.g_vertices = None\n\n def preset(self, start, goal, grid_map, grid_res, grid_ori, obstacle, heuristic):\n self.grid_map, self.grid_res, self.grid_ori, self.obstacle = grid_map, grid_res, grid_ori, obstacle\n self.heuristic = heuristic\n self.start, self.goal = start, goal\n\n self.start.g, self.start.hl = 0, self.cost(start, goal)\n self.start.hu = self.start.hl if self.collision_free(start, goal) else np.inf\n self.start.fl, self.start.fu = self.start.g + self.start.hl, self.start.g + self.start.hu\n\n self.goal.g, self.goal.hl = 0, self.cost(goal, start)\n self.goal.hu = self.goal.hl if self.collision_free(goal, start) else np.inf\n self.goal.fl, self.goal.fu = self.goal.g + self.goal.hl, self.goal.g + self.goal.hu\n\n self.root, self.gain = self.start, self.goal\n self.s_vertices = [self.start]\n self.g_vertices = [self.goal]\n self.x_best = self.root\n return self\n\n def swap(self, i):\n self.branch_and_bound(self.g_vertices)\n self.branch_and_bound(self.s_vertices)\n if self.root is self.start:\n self.root = self.goal\n self.gain = self.start\n self.vertices = self.g_vertices\n n = -((i/2) % len(self.heuristic)) - 1 if self.heuristic else i\n Debugger.breaker('swap: goal -> start, {}, {}'.format(i, n), self.debug)\n return n\n else:\n self.root = self.start\n self.gain = self.goal\n self.vertices = self.s_vertices\n n = (i/2) % len(self.heuristic) if self.heuristic else i\n Debugger.breaker('swap: start -> goal, {}, {}'.format(i, n), self.debug)\n return n\n\n def planning(self, times, repeat=10, optimize=True, debug=False):\n \"\"\"main flow.\"\"\"\n self.debug = debug\n past = time.time()\n for i in range(times):\n n = self.swap(i)\n x_new = self.sample_free(n, repeat)\n x_nearest = self.nearest(x_new) if not optimize else self.least(x_new)\n if x_nearest and self.benefit(x_new) and self.collision_free(x_nearest, x_new):\n self.attach(x_nearest, x_new)\n self.rewire(x_new)\n self.x_best = self.best_of_all()\n self.connect_graphs(x_new)\n Debugger().debug_planned_path(self, i, switch=self.debug)\n Debugger().debug_planning_hist(self, i, (time.time() - past), switch=True)\n\n def best_of_all(self):\n x_new_best = self.best()\n return x_new_best if x_new_best.fu < self.x_best.fu else self.x_best\n\n def connect_graphs(self, x_new):\n if self.root is self.start:\n vs = self.g_vertices\n else:\n vs = self.s_vertices\n costs = map(lambda x: self.cost(x_new, x), vs)\n x_nearest, cost = vs[int(np.argmin(costs))], np.min(costs)\n Debugger().debug_connect_graphs(x_nearest.state, x_new.g+cost+x_nearest.g, self.x_best.fu, switch=self.debug)\n if x_new.g + cost + x_nearest.g < self.x_best.fu:\n if self.collision_free(x_new, x_nearest):\n x_nearest.fu = x_new.fu = x_new.g + cost + x_nearest.g\n x_new.hu = x_new.fu - x_new.g\n x_nearest.hu = x_nearest.fu - x_nearest.g\n x_new.neighbor = x_nearest\n x_nearest.neighbor = x_new\n self.x_best = x_new\n\n def path(self):\n x_best = self.x_best\n if x_best.fu < np.inf:\n p = x_best.trace()\n if hasattr(x_best, 'neighbor') and x_best.neighbor:\n p1 = x_best.neighbor.trace()\n p1.reverse()\n p.extend(p1)\n if p[-1] is self.start:\n p.reverse()\n return p\n else:\n if p[0] is self.start:\n p.append(self.gain)\n else:\n p.append(self.start)\n p.reverse()\n return p\n else:\n x_spare = self.spare(space=self.s_vertices)\n return x_spare.trace()\n", "meta": {"hexsha": "0189d6f5efa3678b3557715b1622255ae7812795", "size": 23160, "ext": "py", "lang": "Python", "max_stars_repo_path": "rrts/planner.py", "max_stars_repo_name": "liespace/pyRRTs", "max_stars_repo_head_hexsha": "11bfefad99218bc9eccd97040355c61d34a1181d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-01-22T09:12:49.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-06T14:22:05.000Z", "max_issues_repo_path": "rrts/planner.py", "max_issues_repo_name": "liespace/pyRRTs", "max_issues_repo_head_hexsha": "11bfefad99218bc9eccd97040355c61d34a1181d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "rrts/planner.py", "max_forks_repo_name": "liespace/pyRRTs", "max_forks_repo_head_hexsha": "11bfefad99218bc9eccd97040355c61d34a1181d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.7104247104, "max_line_length": 120, "alphanum_fraction": 0.5687392055, "include": true, "reason": "import numpy,import numba", "num_tokens": 5893, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583269943353745, "lm_q2_score": 0.3557749071749625, "lm_q1q2_score": 0.19863873458294368}} {"text": "r\"\"\":mod:`mirgecom.inviscid` provides helper functions for inviscid flow.\n\nInviscid Flux Calculation\n^^^^^^^^^^^^^^^^^^^^^^^^^\n\n.. autofunction:: inviscid_flux\n.. autofunction:: inviscid_facial_flux\n\nInviscid Time Step Computation\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\n.. autofunction:: get_inviscid_timestep\n.. autofunction:: get_inviscid_cfl\n\"\"\"\n\n__copyright__ = \"\"\"\nCopyright (C) 2020 University of Illinois Board of Trustees\n\"\"\"\n\n__license__ = \"\"\"\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n\"\"\"\n\nimport numpy as np\nfrom meshmode.dof_array import thaw\nfrom grudge.trace_pair import TracePair\nfrom mirgecom.flux import divergence_flux_lfr\nfrom mirgecom.fluid import make_conserved\n\n\ndef inviscid_flux(state):\n r\"\"\"Compute the inviscid flux vectors from fluid conserved vars *cv*.\n\n The inviscid fluxes are\n $(\\rho\\vec{V},(\\rho{E}+p)\\vec{V},\\rho(\\vec{V}\\otimes\\vec{V})\n +p\\mathbf{I}, \\rho{Y_s}\\vec{V})$\n\n .. note::\n\n The fluxes are returned as a :class:`mirgecom.fluid.ConservedVars`\n object with a *dim-vector* for each conservation equation. See\n :class:`mirgecom.fluid.ConservedVars` for more information about\n how the fluxes are represented.\n\n Parameters\n ----------\n state: :class:`~mirgecom.gas_model.FluidState`\n\n Full fluid conserved and thermal state.\n\n Returns\n -------\n :class:`~mirgecom.fluid.ConservedVars`\n\n A CV object containing the inviscid flux vector for each\n conservation equation.\n \"\"\"\n mass_flux = state.momentum_density\n energy_flux = state.velocity * (state.energy_density + state.pressure)\n mom_flux = (\n state.mass_density * np.outer(state.velocity, state.velocity)\n + np.eye(state.dim)*state.pressure\n )\n species_mass_flux = \\\n state.velocity*state.species_mass_density.reshape(-1, 1)\n\n return make_conserved(state.dim, mass=mass_flux, energy=energy_flux,\n momentum=mom_flux, species_mass=species_mass_flux)\n\n\ndef inviscid_facial_flux(discr, state_tpair, local=False):\n r\"\"\"Return the flux across a face given the solution on both sides *q_tpair*.\n\n This flux is currently hard-coded to use a Rusanov-type local Lax-Friedrichs\n (LFR) numerical flux at element boundaries. The numerical inviscid flux $F^*$ is\n calculated as:\n\n .. math::\n\n \\mathbf{F}^{*}_{\\mathtt{LFR}} = \\frac{1}{2}(\\mathbf{F}(q^-)\n +\\mathbf{F}(q^+)) \\cdot \\hat{n} + \\frac{\\lambda}{2}(q^{-} - q^{+}),\n\n where $q^-, q^+$ are the fluid solution state on the interior and the\n exterior of the face on which the LFR flux is to be calculated, $\\mathbf{F}$ is\n the inviscid fluid flux, $\\hat{n}$ is the face normal, and $\\lambda$ is the\n *local* maximum fluid wavespeed.\n\n Parameters\n ----------\n discr: :class:`~grudge.eager.EagerDGDiscretization`\n\n The discretization collection to use\n\n state_tpair: :class:`~grudge.trace_pair.TracePair`\n\n Trace pair of :class:`~mirgecom.gas_model.FluidState` for the face upon\n which the flux calculation is to be performed\n\n local: bool\n\n Indicates whether to skip projection of fluxes to \"all_faces\" or not. If\n set to *False* (the default), the returned fluxes are projected to\n \"all_faces.\" If set to *True*, the returned fluxes are not projected to\n \"all_faces\"; remaining instead on the boundary restriction.\n\n Returns\n -------\n :class:`~mirgecom.fluid.ConservedVars`\n\n A CV object containing the scalar numerical fluxes at the input faces.\n The returned fluxes are scalar because they've already been dotted with\n the face normals as required by the divergence operator for which they\n are being computed.\n \"\"\"\n actx = state_tpair.int.array_context\n dd = state_tpair.dd\n dd_all_faces = dd.with_dtag(\"all_faces\")\n\n flux_tpair = TracePair(dd,\n interior=inviscid_flux(state_tpair.int),\n exterior=inviscid_flux(state_tpair.ext))\n\n # This calculates the local maximum eigenvalue of the flux Jacobian\n # for a single component gas, i.e. the element-local max wavespeed |v| + c.\n w_int = state_tpair.int.speed_of_sound + state_tpair.int.speed\n w_ext = state_tpair.ext.speed_of_sound + state_tpair.ext.speed\n lam = actx.np.maximum(w_int, w_ext)\n\n normal = thaw(actx, discr.normal(dd))\n cv_tpair = TracePair(dd,\n interior=state_tpair.int.cv,\n exterior=state_tpair.ext.cv)\n\n # todo: user-supplied flux routine\n flux_weak = divergence_flux_lfr(cv_tpair, flux_tpair, normal=normal, lam=lam)\n\n if local is False:\n return discr.project(dd, dd_all_faces, flux_weak)\n\n return flux_weak\n\n\ndef get_inviscid_timestep(discr, state):\n \"\"\"Return node-local stable timestep estimate for an inviscid fluid.\n\n The maximum stable timestep is computed from the acoustic wavespeed.\n\n Parameters\n ----------\n discr: grudge.eager.EagerDGDiscretization\n\n the discretization to use\n\n state: :class:`~mirgecom.gas_model.FluidState`\n\n Full fluid conserved and thermal state\n\n Returns\n -------\n class:`~meshmode.dof_array.DOFArray`\n\n The maximum stable timestep at each node.\n \"\"\"\n from grudge.dt_utils import characteristic_lengthscales\n return (\n characteristic_lengthscales(state.array_context, discr)\n / state.wavespeed\n )\n\n\ndef get_inviscid_cfl(discr, state, dt):\n \"\"\"Return node-local CFL based on current state and timestep.\n\n Parameters\n ----------\n discr: :class:`~grudge.eager.EagerDGDiscretization`\n\n the discretization to use\n\n dt: float or :class:`~meshmode.dof_array.DOFArray`\n\n A constant scalar dt or node-local dt\n\n state: :class:`~mirgecom.gas_model.FluidState`\n\n The full fluid conserved and thermal state\n\n Returns\n -------\n :class:`~meshmode.dof_array.DOFArray`\n\n The CFL at each node.\n \"\"\"\n return dt / get_inviscid_timestep(discr, state=state)\n", "meta": {"hexsha": "a60cddd9521a5783014b20dc855e0080557f1f4d", "size": 7025, "ext": "py", "lang": "Python", "max_stars_repo_path": "mirgecom/inviscid.py", "max_stars_repo_name": "dreamer2368/mirgecom", "max_stars_repo_head_hexsha": "dc79645af040510a7e2b11d3f93db4c34ad39228", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "mirgecom/inviscid.py", "max_issues_repo_name": "dreamer2368/mirgecom", "max_issues_repo_head_hexsha": "dc79645af040510a7e2b11d3f93db4c34ad39228", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "mirgecom/inviscid.py", "max_forks_repo_name": "dreamer2368/mirgecom", "max_forks_repo_head_hexsha": "dc79645af040510a7e2b11d3f93db4c34ad39228", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.2938388626, "max_line_length": 84, "alphanum_fraction": 0.689252669, "include": true, "reason": "import numpy", "num_tokens": 1725, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583270090337583, "lm_q2_score": 0.35577489351363034, "lm_q1q2_score": 0.1986387321847691}} {"text": "# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Thu Nov 1 14:27:54 2018\n\n@author: dkorff\n\"\"\"\n\nimport numpy as np\nimport cantera as ct\n\nfrom li_ion_battery_p2d_inputs import Inputs\n\n# Import Cantera objects:\nanode_obj = ct.Solution(Inputs.ctifile,Inputs.anode_phase)\nelyte_obj = ct.Solution(Inputs.ctifile,Inputs.elyte_phase)\ncathode_obj = ct.Solution(Inputs.ctifile,Inputs.cathode_phase)\nconductor_obj = ct.Solution(Inputs.ctifile,Inputs.metal_phase)\n\nanode_surf_obj = ct.Interface(Inputs.ctifile,Inputs.anode_surf_phase,\n [anode_obj,elyte_obj,conductor_obj])\ncathode_surf_obj = ct.Interface(Inputs.ctifile,Inputs.cathode_surf_phase,\n [cathode_obj,elyte_obj,conductor_obj])\n\n\n# Anode initial conditions:\nLiC6_0 = Inputs.SOC_0; C6_0 = 1 - LiC6_0\nX_an_init = '{}:{}, {}:{}'.format(Inputs.Li_species_anode, LiC6_0,\n Inputs.Vac_species_anode, C6_0)\n\n# Set Cantera object states\nanode_obj.X = X_an_init\nanode_obj.TP = Inputs.T, ct.one_atm\nelyte_obj.TP = Inputs.T, ct.one_atm\nanode_surf_obj.TP = Inputs.T, ct.one_atm\n\nX_an_0 = anode_obj.X\n\nif hasattr(Inputs, 'X_elyte_init'):\n elyte_obj.X = X_elyte_init\n\n\n\n# Initial conditions: UPDATE TO GENERALIZE FOR MULT. SPECIES - DK 8/31/18\nLiCoO2_0 = 1- Inputs.SOC_0; CoO2_0 = 1 - LiCoO2_0\nX_ca_init = '{}:{}, {}:{}'.format(Inputs.Li_species_cathode, LiCoO2_0,\n Inputs.Vac_species_cathode, CoO2_0)\n\ncathode_obj.X = X_ca_init\ncathode_obj.TP = Inputs.T, ct.one_atm\ncathode_surf_obj.TP = Inputs.T, ct.one_atm\n\nX_ca_0 = cathode_obj.X\nX_elyte_0 = elyte_obj.X\n\n\n\"\"\"=========================================================================\"\"\"\n\"\"\"=========================================================================\"\"\"\n\"\"\"=========================================================================\"\"\"\n\nclass anode():\n\n # Set flag so solver knows whether to implement the anode:\n flag = Inputs.flag_anode\n\n # Number of nodes in the y-direction:\n npoints = Inputs.npoints_anode\n\n # Number of \"shells\" in anode particle:\n nshells = Inputs.nshells_anode\n\n # Initial conditions: UPDATE TO GENERALIZE FOR MULT. SPEC - DK 8/31/18\n\n # Anode variables for a given volume include X_Li for each shell, Phi_an,\n # Phi_elyte, and rho_k_elyte for all elyte species.\n nVars = nshells + 2 + elyte_obj.n_species\n\n # Pointers\n ptr = {}\n ptr['iFar'] = 1\n ptr['X_ed'] = np.arange(0, Inputs.nshells_anode)\n ptr['rho_k_elyte'] = nshells + np.arange(0,elyte_obj.n_species)\n ptr['Phi_ed'] = nshells + elyte_obj.n_species\n ptr['Phi_dl'] = nshells + elyte_obj.n_species + 1\n\n # Anode/elyte interface area per unit volume\n # [m^2 interface / m_3 total electrode volume]\n # For spherical particles, the total surface area per unit volume can be\n # calculated from the geometry. Since some particles will overlap, we\n # multiply by an 'overlap' input parameter.\n A_surf = (1-Inputs.overlap_an)*6*Inputs.eps_solid_an/Inputs.d_part_an\n\n # Set up solution vector\n nSV = npoints*nVars\n\n # Array of offsets to point to each node's variable:\n offsets = np.arange(0,int(nSV),int(nVars))\n\n # Store parameters as class object attributes:\n T = Inputs.T\n C_dl = Inputs.C_dl_an\n X_Li_max = Inputs.SOC_max\n X_Li_min = Inputs.SOC_min\n D_Li_ed = Inputs.D_Li_an\n\n # Geometric parameters:\n eps_ed = Inputs.eps_solid_an\n eps_elyte = 1 - Inputs.eps_solid_an\n tau_ed = Inputs.tau_an\n r_pore = Inputs.r_p_an\n d_part = Inputs.d_part_an\n dyInv = npoints/Inputs.H_an\n dr = d_part*0.5/nshells\n\n # Calculate the current density [A/m^2] corresponding to a C_rate of 1:\n oneC = eps_ed*anode_obj.density_mole*Inputs.H_an*ct.faraday/3600\n\n # Calculate the percent volume of a single graphite particle that exists in\n # each 'shell'. I.e. for shell j, what is the volume of that shell,\n # relative to the total particle volume? The radius of the volume is\n # currently discretized evenly (i.e. 'dr' the differential radius is\n # constant). Certainly other discretizations (such as constant\n # differential volume) are possible (and perhaps better).\n #\n # Because the volume is 4/3 pi*r^3, the volume of the shell relative to\n # the total volume is (r_shell/r_particle)^3, and the differential volume\n # relative to the total, for shell 'j' is:\n # (r_shell(j+1)^3 - r_shell(j)^3)/r_particle^3\n # Because the radius is discretized evenly, the radius of shell j, r_j,\n # relative to the total radius r_particle, is:\n # r_j/r_particle = j/nshells\n\n V_shell = np.zeros([nshells])\n nsr3 = 1/nshells/nshells/nshells\n for j in np.arange(0, nshells, 1):\n V_shell[j] = ((j+1)**3 - (j)**3)*nsr3\n\n # Electronic conductivity of the electrode phase:\n sigma_eff_ed = Inputs.sigma_an*eps_ed/tau_ed**3\n # Species mobilities of the electrolyte phase. Converted from user input\n # diffusion coefficients:\n u_Li_elyte = (Inputs.D_Li_elyte*eps_elyte/ct.gas_constant\n /Inputs.T/tau_ed**3)\n\n t_flag = []\n\n\n \"\"\"=========================================================================\"\"\"\n \"\"\"=========================================================================\"\"\"\n \"\"\"=========================================================================\"\"\"\n\nclass separator():\n # Set a flag to let the solver know whether to implement this class:\n flag = Inputs.flag_sep\n\n # Number of nodes in the y-direction\n npoints = Inputs.npoints_elyte\n\n # Number of variables per node:\n nVars = 1 + elyte_obj.n_species\n\n H = Inputs.H_elyte # Separator thickness [m]\n\n tau_sep = Inputs.tau_sep # Tortuosity of separator\n\n # Geometric parameters:\n eps_elyte = Inputs.eps_elyte_sep\n dyInv = npoints/H\n tau_sep = tau_sep\n\n ptr = {}\n ptr['rho_k_elyte'] = np.arange(0,elyte_obj.n_species)\n ptr['Phi'] = elyte_obj.n_species\n\n # Set up the solution vector\n nSV = npoints*nVars\n\n # Array of offsets to point to each node's variable:\n offsets = np.arange(int(anode.nSV),int(anode.nSV)+int(nSV),int(nVars))\n\n\n\"\"\"=========================================================================\"\"\"\n\"\"\"=========================================================================\"\"\"\n\"\"\"=========================================================================\"\"\"\n\nclass cathode():\n # Set flag so solver knows it's looking at the anode class\n flag = Inputs.flag_cathode\n\n # Number of nodes in the y-direction:\n npoints = Inputs.npoints_cathode\n\n # Number of \"shells\" in the cathode particle\n nshells = Inputs.n_shells_cathode\n\n # Number of state variables per node:\n nVars = nshells + 2 + elyte_obj.n_species\n\n # Pointers\n ptr = {}\n ptr['iFar'] = 0\n ptr['X_ed'] = np.arange(0, nshells)\n ptr['rho_k_elyte'] = nshells + np.arange(0,elyte_obj.n_species)\n ptr['Phi_ed'] = nshells + elyte_obj.n_species\n ptr['Phi_dl'] = nshells + elyte_obj.n_species + 1\n\n # Cathode/elyte interface area per unit volume\n # [m^2 interface / m_3 total electrode volume]\n # For spherical particles, the total surface area per unit volume can be\n # calculated from the geometry. Since some particles will overlap, we\n # multiply by an 'overlap' input parameter.\n A_surf = (1-Inputs.overlap_ca)*6*Inputs.eps_solid_ca/Inputs.d_part_ca\n\n # Set up the solution vector\n nSV = npoints*nVars\n\n # Array of offsets to point to each node's variable:\n offsets = np.arange(int(anode.nSV + separator.nSV), \\\n int(anode.nSV + separator.nSV)+int(nSV),int(nVars))\n\n # Store Parameters in the Class object:\n T = Inputs.T\n C_dl = Inputs.C_dl_ca\n X_Li_max = Inputs.SOC_max\n X_Li_min = Inputs.SOC_min\n D_Li_ed = Inputs.D_Li_ca\n\n # Geometric parameters:\n eps_ed = Inputs.eps_solid_ca\n eps_elyte = 1 - Inputs.eps_solid_ca\n tau_ed = Inputs.tau_ca\n r_p = Inputs.r_p_ca\n d_part = Inputs.d_part_ca\n dyInv = npoints/Inputs.H_ca\n dr = d_part*0.5/nshells\n\n # Calculate the current density [A/m^2] corresponding to a C_rate of 1:\n oneC = eps_ed*cathode_obj.density_mole*Inputs.H_ca*ct.faraday/3600\n\n # Calculate the percent volume of a single graphite particle that exists in\n # each 'shell'. I.e. for shell j, what is the volume of that shell,\n # relative to the total particle volume? The radius of the volume is\n # currently discretized evenly (i.e. 'dr' the differential radius is\n # constant). Certainly other discretizations (such as constant\n # differential volume) are possible (and perhaps better).\n #\n # Because the volume is 4/3 pi*r^3, the volume of the shell relative to\n # the total volume is (r_shell/r_particle)^3, and the differential volume\n # relative to the total, for shell 'j' is:\n # (r_shell(j+1)^3 - r_shell(j)^3)/r_particle^3\n # Because the radius is discretized evenly, the radius of shell j, r_j,\n # relative to the total radius r_particle, is:\n # r_j/r_particle = j/nshells\n\n V_shell = np.zeros([nshells])\n nsr3 = 1/nshells/nshells/nshells\n for j in np.arange(0, nshells, 1):\n V_shell[j] = ((j+1)**3 - (j)**3)*nsr3\n\n sigma_eff_ed = Inputs.sigma_ca*eps_ed/tau_ed**3\n u_Li_elyte = (Inputs.D_Li_elyte*eps_elyte/ct.gas_constant\n /Inputs.T/tau_ed**3)\n\n t_flag = []\n\n\"\"\"=========================================================================\"\"\"\n\"\"\"=========================================================================\"\"\"\n\"\"\"=========================================================================\"\"\"\n\n\n\n# Calculate the actual current density:\n# The minus sign is because we begin with the charging reaction, which\n# delivers negative charge to the anode:\ni_ext = -Inputs.C_rate*min(anode.oneC,cathode.oneC)\n\nSV_0 = np.zeros([anode.nSV+separator.nSV+cathode.nSV])\n\n# Set up algebraic variable vector:\nalgvar = np.zeros_like(SV_0)\n\noffsets = anode.offsets\nptr = anode.ptr\nfor j in range(anode.npoints):\n SV_0[offsets[j] + ptr['X_ed']] = \\\n np.ones([anode.nshells])*X_an_0[0]\n algvar[offsets[j] + ptr['X_ed']] = 1\n\n SV_0[offsets[j] + ptr['rho_k_elyte']] = \\\n elyte_obj.Y*elyte_obj.density_mass\n algvar[offsets[j] + ptr['rho_k_elyte']] = 1\n\n SV_0[offsets[j] + ptr['Phi_ed']] = \\\n Inputs.Phi_anode_init\n\n SV_0[offsets[j] + ptr['Phi_dl']] = \\\n Inputs.Phi_elyte_init - Inputs.Phi_anode_init\n algvar[offsets[j] + ptr['Phi_dl']] = 1\n\noffsets = separator.offsets\nptr = separator.ptr\nfor j in np.arange(0, separator.npoints):\n SV_0[offsets[j] + ptr['rho_k_elyte']] = \\\n elyte_obj.Y*elyte_obj.density_mass\n algvar[offsets[j] + ptr['rho_k_elyte']] = 1\n\n SV_0[offsets[j] + ptr['Phi']] = \\\n Inputs.Phi_elyte_init\n\noffsets = cathode.offsets\nptr = cathode.ptr\nfor j in range(cathode.npoints):\n SV_0[offsets[j] + ptr['X_ed']] = \\\n np.ones([cathode.nshells])*X_ca_0[0]\n algvar[offsets[j] + ptr['X_ed']] = 1\n\n SV_0[offsets[j] + ptr['rho_k_elyte']] = \\\n elyte_obj.Y*elyte_obj.density_mass\n algvar[offsets[j] + ptr['rho_k_elyte']] = 1\n\n SV_0[offsets[j] + ptr['Phi_ed']] = \\\n Inputs.Phi_anode_init + Inputs.Delta_Phi_init\n\n SV_0[offsets[j] + ptr['Phi_dl']] = \\\n Inputs.Phi_elyte_init - (Inputs.Phi_anode_init + Inputs.Delta_Phi_init)\n algvar[offsets[j] + ptr['Phi_dl']] = 1\n", "meta": {"hexsha": "8e0dc3533bfe076a774c615993b166a49a69ba46", "size": 11347, "ext": "py", "lang": "Python", "max_stars_repo_path": "li_ion_battery_p2d_init.py", "max_stars_repo_name": "coresresearch/p2d_li_ion_battery", "max_stars_repo_head_hexsha": "7ea1a2332eb885bea65e47e82ea231f80d28ca18", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 9, "max_stars_repo_stars_event_min_datetime": "2020-02-05T04:53:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-11T01:50:51.000Z", "max_issues_repo_path": "li_ion_battery_p2d_init.py", "max_issues_repo_name": "coresresearch/p2d_li_ion_battery", "max_issues_repo_head_hexsha": "7ea1a2332eb885bea65e47e82ea231f80d28ca18", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "li_ion_battery_p2d_init.py", "max_forks_repo_name": "coresresearch/p2d_li_ion_battery", "max_forks_repo_head_hexsha": "7ea1a2332eb885bea65e47e82ea231f80d28ca18", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2019-03-21T21:06:42.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-05T09:06:15.000Z", "avg_line_length": 34.8067484663, "max_line_length": 83, "alphanum_fraction": 0.6232484357, "include": true, "reason": "import numpy", "num_tokens": 3293, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583269943353745, "lm_q2_score": 0.3557749003442964, "lm_q1q2_score": 0.19863873076919839}} {"text": "import numpy as np\r\nfrom argparse import ArgumentParser\r\nfrom collections import defaultdict\r\n\r\nimport torch\r\nimport torch.nn as nn\r\nimport torch.nn.functional as F\r\n\r\nfrom utils import CEVAE_mod, load_data\r\n\r\nparser = ArgumentParser()\r\nparser.add_argument('-lr', type=float, default=0.0005)\r\nparser.add_argument('-hDim', type=int, default=50)\r\nparser.add_argument('-nTest', type=int, default=1000)\r\nparser.add_argument('-nTrain', type=int, default=1000)\r\nparser.add_argument('-zDim', type=int, default=5)\r\nparser.add_argument('-rep', type=int, default=20)\r\nparser.add_argument('-nIter', type=int, default=10001)\r\nparser.add_argument('-batchSize', type=int, default=512)\r\nparser.add_argument('-nSamplesZ', type=int, default=1)\r\nparser.add_argument('-evalIter', type=int, default=500)\r\nparser.add_argument('-device', type=str, default='cpu')\r\nparser.add_argument('-comment', type=str, default='')\r\nargs = parser.parse_args()\r\n\r\n\r\n# Model class for auxiliary model\r\nclass aux_m(nn.Module):\r\n def __init__(self, input_dim=20, h_dim_f=100, out_dim=1):\r\n super().__init__()\r\n # init network\r\n self.lin1 = nn.Linear(input_dim, h_dim_f)\r\n self.lin2 = nn.Linear(h_dim_f, out_dim)\r\n\r\n def forward(self, z_in):\r\n h1 = F.elu(self.lin1(z_in))\r\n out = torch.sigmoid(self.lin2(h1))\r\n return out\r\n\r\n\r\nif __name__ == \"__main__\":\r\n\r\n acc_list = defaultdict(list)\r\n stat_par_y1a0 = defaultdict(list)\r\n stat_par_y1a1 = defaultdict(list)\r\n\r\n # repeat whole training process to observe stability\r\n for rep_i in range(args.rep):\r\n print('rep: %i' % rep_i)\r\n # data loader:\r\n # order of packed data: data = [y, x_con, x_bin, r, b, a]\r\n train_data, test_data, cat_bin_dict = load_data(n_test=args.nTest)\r\n\r\n # unpack train x in order to init in right shapes\r\n train_data = [data[:args.nTrain] for data in train_data]\r\n y_tr, x_tr_con, x_tr_bin, r_tr, b_tr, a_tr = train_data\r\n x_tr = np.hstack((x_tr_bin, x_tr_con))\r\n\r\n CEVAE = CEVAE_mod(args=args, dim_x=x_tr.shape[1], dim_b=b_tr.shape[1], dim_a=1, dim_x_con=x_tr_con.shape[1],\r\n dim_x_bin=cat_bin_dict, dim_z=args.zDim, dim_r=r_tr.shape[1], dim_q_h=args.hDim,\r\n dim_p_h=args.hDim).to(args.device)\r\n\r\n model = './model_path.pt'\r\n CEVAE.load_state_dict(torch.load(model))\r\n\r\n # init Causal Path Enabler (auxiliary -fair- models)\r\n path_combinations = ['z', 'zb', 'zbr', 'zbrx', 'zbrxa']\r\n AUX = dict()\r\n AUX['z'] = aux_m(input_dim=args.zDim, h_dim_f=100)\r\n AUX['zb'] = aux_m(input_dim=args.zDim + b_tr.shape[1], h_dim_f=100)\r\n AUX['zbr'] = aux_m(input_dim=args.zDim + b_tr.shape[1] + r_tr.shape[1], h_dim_f=100)\r\n AUX['zbrx'] = aux_m(input_dim=args.zDim + b_tr.shape[1] + r_tr.shape[1] + x_tr.shape[1], h_dim_f=100)\r\n AUX['zbrxa'] = aux_m(input_dim=args.zDim + b_tr.shape[1] + r_tr.shape[1] + x_tr.shape[1] + a_tr.shape[1],\r\n h_dim_f=100)\r\n\r\n # init optimizer\r\n optimizer = dict()\r\n for combination in path_combinations:\r\n optimizer[combination] = torch.optim.RMSprop(AUX[combination].parameters(), lr=args.lr)\r\n\r\n # Maintain loss development for monitoring\r\n loss_dict = defaultdict(list)\r\n\r\n # training loop\r\n for i in range(args.nIter):\r\n # select random batch\r\n batch_idx = np.random.choice(a=range(x_tr.shape[0]), size=args.batchSize, replace=False)\r\n batch_data = [torch.Tensor(g[batch_idx]).to(args.device) for g in train_data]\r\n\r\n y_batch, x_batch_con, x_batch_bin, r_batch, b_batch, a_batch = batch_data\r\n # INFER distribution over z, using inference network of CEVAE\r\n z_infer = CEVAE.q_z.forward(\r\n observations=torch.cat((x_batch_con, x_batch_bin, r_batch, b_batch, a_batch), 1))\r\n # No need to store derivative to CEVAE\r\n z_sample = z_infer.sample().detach()\r\n\r\n aux_output = dict()\r\n aux_output['z'] = AUX['z'].forward(z_sample)\r\n aux_output['zb'] = AUX['zb'].forward(torch.cat((z_sample, b_batch), 1))\r\n # use R(x,Z,B,A) below instead in order to exclude A->X->R->Y\r\n aux_output['zbr'] = AUX['zbr'].forward(torch.cat((z_sample, b_batch, r_batch), 1))\r\n aux_output['zbrx'] = AUX['zbrx'].forward(\r\n torch.cat((z_sample, b_batch, r_batch, x_batch_con, x_batch_bin), 1))\r\n aux_output['zbrxa'] = AUX['zbrxa'].forward(\r\n torch.cat((z_sample, b_batch, r_batch, x_batch_con, x_batch_bin, a_batch), 1))\r\n\r\n # calculate loss and update step\r\n objective = dict()\r\n for combination in path_combinations:\r\n objective[combination] = torch.mean((aux_output[combination] - y_batch) ** 2)\r\n optimizer[combination].zero_grad()\r\n objective[combination].backward()\r\n optimizer[combination].step()\r\n\r\n loss_dict[combination].append(float(objective[combination].cpu().detach().numpy()))\r\n\r\n # test on test set\r\n batch_data = [torch.Tensor(g).to(args.device) for g in test_data]\r\n\r\n y_batch, x_batch_con, x_batch_bin, r_batch, b_batch, a_batch = batch_data\r\n # INFER distribution over z, using inference network of CEVAE\r\n z_infer = CEVAE.q_z.forward(observations=torch.cat((x_batch_con, x_batch_bin, r_batch, b_batch, a_batch), 1))\r\n # No need to store derivative to CEVAE\r\n z_sample = z_infer.sample().detach()\r\n\r\n aux_output = dict()\r\n aux_output['z'] = AUX['z'].forward(z_sample)\r\n aux_output['zb'] = AUX['zb'].forward(torch.cat((z_sample, b_batch), 1))\r\n aux_output['zbr'] = AUX['zbr'].forward(torch.cat((z_sample, b_batch, r_batch), 1))\r\n aux_output['zbrx'] = AUX['zbrx'].forward(torch.cat((z_sample, b_batch, r_batch, x_batch_con, x_batch_bin), 1))\r\n aux_output['zbrxa'] = AUX['zbrxa'].forward(\r\n torch.cat((z_sample, b_batch, r_batch, x_batch_con, x_batch_bin, a_batch), 1))\r\n\r\n # ------ Test Statistical parity -----\r\n mask_a0 = (a_batch == 0).squeeze()\r\n mask_a1 = (a_batch == 1).squeeze()\r\n\r\n for combination in path_combinations:\r\n y_predict = torch.round(aux_output[combination])\r\n accuracy = torch.sum(y_predict == y_batch).cpu().detach().numpy() / y_batch.shape[0]\r\n acc_list[combination].append(accuracy)\r\n p_y1_a0 = y_predict[mask_a0].sum() / mask_a0.sum()\r\n p_y1_a1 = y_predict[mask_a1].sum() / mask_a1.sum()\r\n stat_par_y1a0[combination].append(p_y1_a0.cpu().detach().numpy())\r\n stat_par_y1a1[combination].append(p_y1_a1.cpu().detach().numpy())\r\n\r\n np.save('accuracy_dict.npy', acc_list)\r\n np.save('stat_par_y1a0_dict.npy', stat_par_y1a0)\r\n np.save('stat_par_y1a1_dict.npy', stat_par_y1a1)\r\n", "meta": {"hexsha": "de2cff90ae8eada520b1132dca0cb5a4aa287557", "size": 7002, "ext": "py", "lang": "Python", "max_stars_repo_path": "social_welfare_experiment/train_aux.py", "max_stars_repo_name": "rik-helwegen/FairTrade", "max_stars_repo_head_hexsha": "649506d9e46b9fd7faaa08dc44b01229ffa4d066", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2020-09-06T08:14:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-25T09:17:39.000Z", "max_issues_repo_path": "social_welfare_experiment/train_aux.py", "max_issues_repo_name": "rik-helwegen/FairTrade", "max_issues_repo_head_hexsha": "649506d9e46b9fd7faaa08dc44b01229ffa4d066", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "social_welfare_experiment/train_aux.py", "max_forks_repo_name": "rik-helwegen/FairTrade", "max_forks_repo_head_hexsha": "649506d9e46b9fd7faaa08dc44b01229ffa4d066", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 46.68, "max_line_length": 119, "alphanum_fraction": 0.6226792345, "include": true, "reason": "import numpy", "num_tokens": 1840, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583269943353745, "lm_q2_score": 0.3557748935136303, "lm_q1q2_score": 0.19863872695545312}} {"text": "#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\"\"\"\n==================================================================================\n Compute Interference caused by a grant for all the incumbent types\n APIs in this file are used by IAP and Aggregate Interference Reference Models\n\n The main routines are:\n\n computeInterference\n computeInterferencePpaGwpzPoint\n computeInterferenceEsc\n computeInterferenceFssCochannel\n computeInterferenceFssBlocking\n getEffectiveSystemEirp\n\n The common utility APIs are:\n\n findOverlappingGrantsInsideNeighborhood\n getProtectedChannels\n\n The routines return a interference caused by a grant in the neighborhood of\n FSS/GWPZ/PPA/ESC incumbent types\n==================================================================================\n\"\"\"\nfrom collections import namedtuple\nimport numpy as np\n\nfrom reference_models.common import data\nfrom reference_models.antenna import antenna\nfrom reference_models.geo import vincenty\nfrom reference_models.propagation import wf_itm\nfrom reference_models.propagation import wf_hybrid\n\n# Set constant parameters based on requirements in the WINNF-TS-0112\n# [R2-SGN-16]\nGWPZ_NEIGHBORHOOD_DIST = 40 # neighborhood distance from a CBSD to a given protection\n# point (in km) in GWPZ protection area\nPPA_NEIGHBORHOOD_DIST = 40 # neighborhood distance from a CBSD to a given protection\n# point (in km) in PPA protection area\n\nFSS_CO_CHANNEL_NEIGHBORHOOD_DIST = 150 # neighborhood distance from a CBSD to FSS for\n# co-channel protection\n\nFSS_BLOCKING_NEIGHBORHOOD_DIST = 40 # neighborhood distance from a CBSD to FSS\n# blocking protection\n\nESC_NEIGHBORHOOD_DIST_A = 40 # neighborhood distance from a ESC to category A CBSD\n\nESC_NEIGHBORHOOD_DIST_B = 80 # neighborhood distance from a ESC to category B CBSD\n\n# Frequency used in propagation model (in MHz) [R2-SGN-04]\nFREQ_PROP_MODEL_MHZ = 3625.0\n\n# CBRS Band Frequency Range (Hz)\nCBRS_LOW_FREQ_HZ = 3550.e6\nCBRS_HIGH_FREQ_HZ = 3700.e6\n\n# FSS Passband low frequency range (Hz)\nFSS_LOW_FREQ_HZ = 3600.e6\n\n# FSS Passband for TT&C (Hz)\nFSS_TTC_LOW_FREQ_HZ = 3700.e6\nFSS_TTC_HIGH_FREQ_HZ = 4200.e6\n\n# ESC IAP for Out-of-Band Category A CBSDs in Frequency Range (Hz)\nESC_CAT_A_LOW_FREQ_HZ = 3550.e6\nESC_CAT_A_HIGH_FREQ_HZ = 3660.e6\n\n# ESC Passband Frequency Range (Hz)\nESC_LOW_FREQ_HZ = 3550.e6\nESC_HIGH_FREQ_HZ = 3680.e6\n\n# ESC Channel 21 Centre Frequency\nESC_CH21_CF_HZ = 3652.5e6\n\n# One Mega Hertz\nMHZ = 1.e6\n\n# Channel bandwidth over which SASs execute the aggregate interference and\n# IAP process\nRBW_HZ = 5.e6\n\n# GWPZ and PPA height (m)\nGWPZ_PPA_HEIGHT = 1.5\n\n# In-band insertion loss\nIN_BAND_INSERTION_LOSS = 0.5\n\n# Global container to store neighborhood distance type of all the protection\n_DISTANCE_PER_PROTECTION_TYPE = {\n data.ProtectedEntityType.GWPZ_AREA : (GWPZ_NEIGHBORHOOD_DIST, GWPZ_NEIGHBORHOOD_DIST),\n data.ProtectedEntityType.PPA_AREA : ( PPA_NEIGHBORHOOD_DIST, PPA_NEIGHBORHOOD_DIST),\n data.ProtectedEntityType.FSS_CO_CHANNEL : ( FSS_CO_CHANNEL_NEIGHBORHOOD_DIST, FSS_CO_CHANNEL_NEIGHBORHOOD_DIST),\n data.ProtectedEntityType.FSS_BLOCKING : ( FSS_BLOCKING_NEIGHBORHOOD_DIST, FSS_BLOCKING_NEIGHBORHOOD_DIST),\n data.ProtectedEntityType.ESC: (ESC_NEIGHBORHOOD_DIST_A, ESC_NEIGHBORHOOD_DIST_B)\n}\n\n\ndef dbToLinear(x):\n \"\"\"This function returns dBm to mW converted value\"\"\"\n return 10**(x / 10.)\n\n\ndef linearToDb(x):\n \"\"\"This function returns mW to dBm converted value\"\"\"\n return 10 * np.log10(x)\n\n\ndef getProtectedChannels(low_freq_hz, high_freq_hz):\n \"\"\"Gets protected channels list.\n\n Performs 5MHz IAP channelization and returns a list of tuple containing\n (low_freq,high_freq)\n\n Args:\n low_freq_hz: Low frequency of the protected entity(Hz).\n high_freq_hz: High frequency of the protected entity(Hz)\n Returns:\n An array of protected channel frequency range tuple\n (low_freq_hz,high_freq_hz).\n \"\"\"\n if low_freq_hz >= high_freq_hz:\n raise ValueError('Low frequency is greater than high frequency')\n # Align the low_freq to multiple of 5MHZ\n low_freq_hz = int(low_freq_hz / (5*MHZ)) * (5*MHZ)\n channels = np.arange( max(low_freq_hz, 3550*MHZ), min(high_freq_hz, 3700*MHZ), 5*MHZ)\n return [(low, high) for low, high in zip(channels, channels+5*MHZ)]\n\n\ndef findGrantsInsideNeighborhood(grants, protection_point, entity_type):\n \"\"\"Finds grants inside protection entity neighborhood.\n\n Args:\n grants: An iterable of CBSD grants of type |data.CbsdGrantInfo|.\n protection_point: The location of a protected entity as (longitude, latitude) tuple.\n entity_type: The entity type (|data.ProtectedEntityType|).\n Returns:\n grants_inside: a list of grants, each one being a namedtuple of type\n |data.CbsdGrantInfo|, of all CBSDs inside the neighborhood\n of the protection constraint.\n \"\"\"\n # Initialize an empty list\n grants_inside = []\n\n # Loop over each CBSD grant\n for grant in grants:\n # Compute distance from CBSD location to protection constraint location\n dist_km, _, _ = vincenty.GeodesicDistanceBearing(grant.latitude,\n grant.longitude, protection_point[1], protection_point[0])\n\n # Check if CBSD is inside the neighborhood of protection constraint\n if dist_km <= _DISTANCE_PER_PROTECTION_TYPE[entity_type][grant.cbsd_category == 'B']:\n grants_inside.append(grant)\n\n return grants_inside\n\n\ndef grantFrequencyOverlapCheck(grant, ch_low_freq, ch_high_freq, protection_ent_type):\n \"\"\"Checks if grant frequency overlaps with protection constraint frequency range.\n\n Args:\n grant: A CBSD grant of type |data.CbsdGrantInfo|.\n ch_low_freq: The low frequency of protection channel.\n ch_high_freq: The high frequency of protection channel.\n protection_ent_type: An enum of type |data.ProtectedEntityType|.\n Returns:\n True if grant frequency overlaps with protection constraint frequency range,\n False otherwise.\n \"\"\"\n # Special case of ESC: ESC Passband is 3550-3680MHz\n # Category A CBSD grants are considered in the neighborhood only for\n # constraint frequency range 3550-3660MHz\n if (protection_ent_type == data.ProtectedEntityType.ESC and\n grant.cbsd_category == 'A' and\n (grant.low_frequency >= ESC_CAT_A_HIGH_FREQ_HZ or\n ch_low_freq >= ESC_CAT_A_HIGH_FREQ_HZ)):\n return False\n\n # Check frequency range overlap\n overlapping_bw = (min(grant.high_frequency, ch_high_freq)\n - max(grant.low_frequency, ch_low_freq))\n return (overlapping_bw > 0)\n\n\ndef findOverlappingGrants(grants, constraint):\n \"\"\"Finds grants overlapping with protection entity.\n\n Grants overlapping with frequency range of the protection entity are\n considered as overlapping grants.\n\n Args:\n grants: An iterable of CBSD grants of type |data.CbsdGrantInfo|.\n constraint: A protection constraint of type |data.ProtectionConstraint|.\n Returns:\n grants_overlap: a list of |data.CbsdGrantInfo| grants of all CBSDs inside\n the neighborhood of the protection constraint.\n \"\"\"\n grants_overlap = [grant for grant in grants\n if grantFrequencyOverlapCheck(\n grant, constraint.low_frequency ,\n constraint.high_frequency, constraint.entity_type)]\n return grants_overlap\n\n\ndef computeInterferencePpaGwpzPoint(cbsd_grant, constraint, h_inc_ant,\n max_eirp, region_type='SUBURBAN'):\n \"\"\"Computes interference that a grant causes to GWPZ or PPA protection area.\n\n Routine to compute interference neighborhood grant causes to protection\n point within GWPZ or PPA protection area.\n\n Args:\n cbsd_grant: A CBSD grant of type |data.CbsdGrantInfo|.\n constraint: The protection constraint of type |data.ProtectionConstraint|.\n h_inc_ant: The reference incumbent antenna height (in meters).\n max_eirp: The maximum EIRP allocated to the grant during IAP procedure\n region_type: Region type of the GWPZ or PPA area:\n 'URBAN', 'SUBURBAN' or 'RURAL'.\n Returns:\n The interference contribution (dBm).\n \"\"\"\n # Get the propagation loss and incident angles for area entity\n db_loss, incidence_angles, _ = wf_hybrid.CalcHybridPropagationLoss(\n cbsd_grant.latitude, cbsd_grant.longitude,\n cbsd_grant.height_agl, constraint.latitude,\n constraint.longitude, h_inc_ant,\n cbsd_grant.indoor_deployment,\n reliability=-1,\n freq_mhz=FREQ_PROP_MODEL_MHZ,\n region=region_type)\n\n # Compute CBSD antenna gain in the direction of protection point\n ant_gain = antenna.GetStandardAntennaGains(incidence_angles.hor_cbsd,\n cbsd_grant.antenna_azimuth, cbsd_grant.antenna_beamwidth,\n cbsd_grant.antenna_gain)\n\n # Get the exact overlap of the grant over the GWPZ area channels\n if constraint.entity_type == data.ProtectedEntityType.GWPZ_AREA:\n grant_overlap_bandwidth = min(cbsd_grant.high_frequency, constraint.high_frequency) \\\n - max(cbsd_grant.low_frequency, constraint.low_frequency)\n else:\n grant_overlap_bandwidth = RBW_HZ\n\n # Get the interference value for area entity\n eirp = getEffectiveSystemEirp(max_eirp, cbsd_grant.antenna_gain,\n ant_gain, grant_overlap_bandwidth)\n\n interference = eirp - db_loss\n return interference\n\n\ndef getEscMaskLoss(constraint):\n \"\"\"Returns the ESC mask loss (in dB).\n\n Note: This routine assumes that the constraint bandwidth is 5MHz-aligned and\n fully contained in the CBSD grant so there is no partial overlap across the\n 3650MHz ESC pass-band edge. This condition is realized in current framework.\n\n Args:\n constraint: The protection constraint of type |data.ProtectionConstraint|.\n \"\"\"\n if constraint.high_frequency <= 3650*MHZ:\n return IN_BAND_INSERTION_LOSS\n if constraint.low_frequency < 3650*MHZ:\n raise ValueError('ESC mask loss: inconsistent protection channel %r' % constraint)\n freqs = np.arange(constraint.low_frequency + 0.5*MHZ, constraint.high_frequency, MHZ)\n attens = freqs/MHZ - 3650. + IN_BAND_INSERTION_LOSS\n atten = -linearToDb(np.mean(dbToLinear(-attens)))\n return atten\n\n\ndef computeInterferenceEsc(cbsd_grant, constraint, esc_antenna_info, max_eirp):\n \"\"\"Computes interference that a grant causes to a ESC protection point.\n\n Routine to compute interference neighborhood grant causes to ESC protection\n point.\n\n Args:\n cbsd_grant: A CBSD grant of type |data.CbsdGrantInfo|.\n constraint: The protection constraint of type |data.ProtectionConstraint|.\n esc_antenna_info: ESC antenna information of type |data.EscInformation|.\n max_eirp: The maximum EIRP allocated to the grant during IAP procedure\n Returns:\n The interference contribution(dBm).\n \"\"\"\n # Get the propagation loss and incident angles for ESC entity\n db_loss, incidence_angles, _ = wf_itm.CalcItmPropagationLoss(\n cbsd_grant.latitude, cbsd_grant.longitude, cbsd_grant.height_agl,\n constraint.latitude, constraint.longitude, esc_antenna_info.antenna_height,\n cbsd_grant.indoor_deployment, reliability=-1,\n freq_mhz=FREQ_PROP_MODEL_MHZ)\n\n # Compute CBSD antenna gain in the direction of protection point\n ant_gain = antenna.GetStandardAntennaGains(\n incidence_angles.hor_cbsd, cbsd_grant.antenna_azimuth,\n cbsd_grant.antenna_beamwidth, cbsd_grant.antenna_gain)\n\n # Compute ESC antenna gain in the direction of CBSD\n esc_ant_gain = antenna.GetAntennaPatternGains(\n incidence_angles.hor_rx,\n esc_antenna_info.antenna_azimuth,\n esc_antenna_info.antenna_gain_pattern)\n\n # Get the total antenna gain by summing the antenna gains from CBSD to ESC\n # and ESC to CBSD\n effective_ant_gain = ant_gain + esc_ant_gain\n\n # Compute the interference value for ESC entity\n eirp = getEffectiveSystemEirp(max_eirp, cbsd_grant.antenna_gain,\n effective_ant_gain)\n interference = eirp - db_loss - getEscMaskLoss(constraint)\n return interference\n\n\ndef computeInterferenceFssCochannel(cbsd_grant, constraint, fss_info, max_eirp):\n \"\"\"Computes interference that a grant causes to a FSS protection point.\n\n Routine to compute interference neighborhood grant causes to FSS protection\n point for co-channel passband.\n\n Args:\n cbsd_grant: A CBSD grant of type |data.CbsdGrantInfo|.\n constraint: The protection constraint of type |data.ProtectionConstraint|.\n fss_info: The FSS information of type |data.FssInformation|.\n max_eirp: The maximum EIRP allocated to the grant during IAP procedure.\n Returns:\n The interference contribution(dBm).\n \"\"\"\n # Get the propagation loss and incident angles for FSS entity_type\n db_loss, incidence_angles, _ = wf_itm.CalcItmPropagationLoss(cbsd_grant.latitude,\n cbsd_grant.longitude, cbsd_grant.height_agl,\n constraint.latitude, constraint.longitude,\n fss_info.height_agl, cbsd_grant.indoor_deployment,\n reliability=-1, freq_mhz=FREQ_PROP_MODEL_MHZ)\n\n # Compute CBSD antenna gain in the direction of protection point\n ant_gain = antenna.GetStandardAntennaGains(incidence_angles.hor_cbsd,\n cbsd_grant.antenna_azimuth, cbsd_grant.antenna_beamwidth,\n cbsd_grant.antenna_gain)\n\n # Compute FSS antenna gain in the direction of CBSD\n fss_ant_gain = antenna.GetFssAntennaGains(incidence_angles.hor_rx,\n incidence_angles.ver_rx, fss_info.pointing_azimuth,\n fss_info.pointing_elevation, fss_info.max_gain_dbi)\n\n # Get the total antenna gain by summing the antenna gains from CBSD to FSS\n # and FSS to CBSD\n effective_ant_gain = ant_gain + fss_ant_gain\n\n # Compute the interference value for Fss co-channel entity\n eff_bandwidth = (min(cbsd_grant.high_frequency, constraint.high_frequency)\n - max(cbsd_grant.low_frequency, constraint.low_frequency))\n if eff_bandwidth <= 0:\n raise ValueError('Computing FSS co-channel on grant fully outside FSS passband')\n\n eirp = getEffectiveSystemEirp(max_eirp, cbsd_grant.antenna_gain,\n effective_ant_gain, eff_bandwidth)\n interference = eirp - db_loss - IN_BAND_INSERTION_LOSS\n return interference\n\n\ndef getFssMaskLoss(cbsd_grant, constraint):\n \"\"\"Gets the FSS mask loss for a FSS blocking protection constraint.\n\n Args:\n cbsd_grant: A CBSD grant of type |data.CbsdGrantInfo|.\n constraint: The protection constraint of type |data.ProtectionConstraint|.\n The constraint defines the FSS out of band left part, so typically\n [3550, min_passband_freq] or [3550, 3700].\n \"\"\"\n # Sanity checks\n if (cbsd_grant.low_frequency >= cbsd_grant.high_frequency or\n cbsd_grant.low_frequency >= constraint.high_frequency):\n raise ValueError('CBSD grant frequencies incorrect')\n\n # Find the 50MHz edge and its rounded version\n edge_freq = constraint.high_frequency - 50*MHZ\n edge_freq_round = int(edge_freq/MHZ +0.5)*MHZ\n # Part of grant in closest mask segment\n seg1 = (max(cbsd_grant.low_frequency, edge_freq_round),\n min(cbsd_grant.high_frequency, constraint.high_frequency))\n # Part of grant in farther mask segment\n seg2 = (cbsd_grant.low_frequency,\n min(cbsd_grant.high_frequency, edge_freq_round))\n\n # Now compute the attenuation\n freqs1 = np.arange(seg1[0] + 0.5*MHZ, seg1[1], MHZ)\n freqs2 = np.arange(seg2[0] + 0.5*MHZ, seg2[1], MHZ)\n attens1 = (constraint.high_frequency - freqs1)/MHZ * 0.6 + 0.5\n attens2 = (edge_freq - freqs2)/MHZ * 0.25 + 30.5\n attens = np.concatenate((attens1, attens2))\n fss_mask_attenuation = -linearToDb(np.mean(dbToLinear(-attens)))\n return fss_mask_attenuation\n\n\ndef computeInterferenceFssBlocking(cbsd_grant, constraint, fss_info, max_eirp):\n \"\"\"Computes interference that a grant causes to a FSS protection point.\n\n Routine to compute interference neighborhood grant causes to FSS protection\n point for blocking passband\n\n Args:\n cbsd_grant: A CBSD grant of type |data.CbsdGrantInfo|.\n constraint: The protection constraint of type |data.ProtectionConstraint|.\n fss_info: The FSS information of type |data.FssInformation|.\n max_eirp: The maximum EIRP allocated to the grant during IAP procedure.\n\n Returns:\n The interference contribution(dBm).\n \"\"\"\n # Get the propagation loss and incident angles for FSS entity\n # blocking channels\n db_loss, incidence_angles, _ = wf_itm.CalcItmPropagationLoss(\n cbsd_grant.latitude, cbsd_grant.longitude,\n cbsd_grant.height_agl, constraint.latitude,\n constraint.longitude, fss_info.height_agl,\n cbsd_grant.indoor_deployment, reliability=-1,\n freq_mhz=FREQ_PROP_MODEL_MHZ)\n\n # Compute CBSD antenna gain in the direction of protection point\n ant_gain = antenna.GetStandardAntennaGains(incidence_angles.hor_cbsd,\n cbsd_grant.antenna_azimuth, cbsd_grant.antenna_beamwidth,\n cbsd_grant.antenna_gain)\n\n # Compute FSS antenna gain in the direction of CBSD\n fss_ant_gain = antenna.GetFssAntennaGains(incidence_angles.hor_rx,\n incidence_angles.ver_rx, fss_info.pointing_azimuth,\n fss_info.pointing_elevation, fss_info.max_gain_dbi)\n\n # Get the total antenna gain by summing the antenna gains from CBSD to FSS\n # and FSS to CBSD\n effective_ant_gain = ant_gain + fss_ant_gain\n\n # Compute EIRP of CBSD grant inside the frequency range of\n # protection constraint\n eff_bandwidth = (min(cbsd_grant.high_frequency, constraint.high_frequency)\n - cbsd_grant.low_frequency)\n if eff_bandwidth <= 0:\n raise ValueError('Computing FSS blocking on grant fully inside FSS passband')\n eirp = getEffectiveSystemEirp(max_eirp, cbsd_grant.antenna_gain,\n effective_ant_gain, eff_bandwidth)\n # Calculate the interference contribution\n interference = eirp - getFssMaskLoss(cbsd_grant, constraint) - db_loss\n\n return interference\n\n\ndef getEffectiveSystemEirp(max_eirp, cbsd_max_ant_gain, effective_ant_gain,\n reference_bandwidth=RBW_HZ):\n \"\"\"Calculates effective EIRP caused by a grant.\n\n Utility API to get effective EIRP caused by a grant in the\n neighborhood of the protected entity FSS/ESC/PPA/GWPZ.\n\n Args:\n max_eirp: The maximum EIRP allocated to the grant during IAP procedure.\n cbsd_max_ant_gain: The nominal antenna gain of the CBSD.\n effective_ant_gain: The actual total antenna gains at the CBSD and protected\n entity. This takes into account the actual antenna patterns.\n reference_bandwidth: Reference bandwidth over which effective EIRP is calculated.\n Returns:\n The effective EIRP of the CBSD(dBm)\n \"\"\"\n\n eirp_cbsd = ((max_eirp - cbsd_max_ant_gain) + effective_ant_gain +\n linearToDb(reference_bandwidth / MHZ))\n\n return eirp_cbsd\n\n\ndef computeInterference(grant, eirp, constraint,\n fss_info=None, esc_antenna_info=None, region_type=None):\n \"\"\"Calculates interference caused by a grant.\n\n Utility API to get interference caused by a grant in the\n neighborhood of the protected entity FSS/ESC/PPA/GWPZ.\n\n Args:\n grant: A CBSD grant of type |data.CbsdGrantInfo|.\n eirp: The EIRP of the grant.\n constraint: A protection constraint of type |data.ProtectionConstraint|.\n fss_info: The FSS information of type |data.FssInformation|.\n esc_antenna_info: ESC antenna information of type |data.EscInformation|.\n region_type: Region type of the GWPZ or PPA area:\n 'URBAN', 'SUBURBAN' or 'RURAL'.\n Returns:\n interference: Interference caused by a grant(dBm)\n \"\"\"\n # Compute interference to FSS Co-channel protection constraint\n if constraint.entity_type is data.ProtectedEntityType.FSS_CO_CHANNEL:\n interference = computeInterferenceFssCochannel(\n grant, constraint, fss_info, eirp)\n\n # Compute interference to FSS Blocking protection constraint\n elif constraint.entity_type is data.ProtectedEntityType.FSS_BLOCKING:\n interference = computeInterferenceFssBlocking(\n grant, constraint, fss_info, eirp)\n\n # Compute interference to ESC protection constraint\n elif constraint.entity_type is data.ProtectedEntityType.ESC:\n interference = computeInterferenceEsc(\n grant, constraint, esc_antenna_info, eirp)\n\n # Compute interference to GWPZ or PPA protection constraint\n else:\n interference = computeInterferencePpaGwpzPoint(\n grant, constraint, GWPZ_PPA_HEIGHT,\n eirp, region_type)\n\n return interference\n", "meta": {"hexsha": "ad6e8c556690923208f25c0deef9664dd2b447ec", "size": 21426, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/harness/reference_models/interference/interference.py", "max_stars_repo_name": "nirajankeybridge/Spectrum-Access-System", "max_stars_repo_head_hexsha": "e4e157f3b8fc9f29cb6fbb283acc3a7cbb1212e1", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/harness/reference_models/interference/interference.py", "max_issues_repo_name": "nirajankeybridge/Spectrum-Access-System", "max_issues_repo_head_hexsha": "e4e157f3b8fc9f29cb6fbb283acc3a7cbb1212e1", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/harness/reference_models/interference/interference.py", "max_forks_repo_name": "nirajankeybridge/Spectrum-Access-System", "max_forks_repo_head_hexsha": "e4e157f3b8fc9f29cb6fbb283acc3a7cbb1212e1", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.9674952199, "max_line_length": 117, "alphanum_fraction": 0.726080463, "include": true, "reason": "import numpy", "num_tokens": 5254, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583269943353745, "lm_q2_score": 0.3557748935136303, "lm_q1q2_score": 0.19863872695545312}} {"text": "\"\"\"\nTodo's\n\"\"\"\nimport matplotlib.pyplot as plt\nimport matplotlib.cm as cm\nimport copy\nimport numpy as np\nimport uncertainties as uct\nfrom uncertainties import unumpy as unp\nfrom ..etc import isuncertainties\n\nc_map = cm.jet # mpl.cm.inferno #mpl.cm.CMRmap_r # mpl.cm.brg #mpl.cm.gray_r #\n\n\ndef thermal_data(data, figsize=(12, 4), ms_data=50,\n v_label='Unit-cell volume $(\\mathrm{\\AA}^3)$',\n pdf_filen=None, title='P-V-T data'):\n \"\"\"\n plot P-V-T data before fitting\n\n :param data: {'p': unumpy array, 'v': unumpy array, 'temp': unumpy array}\n :param eoscurves: {'v': unumpy array, '300': unumpy array\n at the temperature ....}\n :param v_label: label for volume axis\n :param figsize: figure size\n :param ms_data: marker size for data points\n :param pdf_filen: name of pdf output file\n :param title: title of the figure\n :return: None\n \"\"\"\n # basic figure setup\n f, ax = plt.subplots(1, 2, figsize=figsize, sharex=True)\n\n # read data to plot\n if isuncertainties([data['p'], data['v'], data['temp']]):\n p = unp.nominal_values(data['p'])\n v = unp.nominal_values(data['v'])\n temp = unp.nominal_values(data['temp'])\n sp = unp.std_devs(data['p'])\n sv = unp.std_devs(data['v'])\n stemp = unp.std_devs(data['temp'])\n ax[0].errorbar(p, v, xerr=sp, yerr=sv, marker=' ',\n c='k', ms=0, mew=0, linestyle='None',\n capsize=0, lw=0.5, zorder=1)\n ax[1].errorbar(p, temp, xerr=sp, yerr=stemp, marker=' ',\n c='k', ms=0, mew=0, linestyle='None',\n capsize=0, lw=0.5, zorder=1)\n else:\n p = data['p']\n v = data['v']\n temp = data['temp']\n points = ax[0].scatter(p, v, marker='o', s=ms_data, c=temp,\n cmap=c_map, vmin=300., vmax=temp.max(), zorder=2)\n points = ax[1].scatter(p, temp, marker='o', s=ms_data, c=temp,\n cmap=c_map, vmin=300., vmax=temp.max(), zorder=2)\n\n ax[0].set_xlabel('Pressure (GPa)')\n ax[1].set_xlabel('Pressure (GPa)')\n ax[0].set_ylabel(v_label)\n ax[1].set_ylabel('Temperature (K)')\n f.suptitle(title)\n # the parameters are the specified position you set\n position = f.add_axes([0.92, 0.11, .01, 0.75])\n f.colorbar(points, orientation=\"vertical\", cax=position)\n # position.text(150., 0.5, 'Temperature (K)', fontsize=10,\n # rotation=270, va='center')\n if pdf_filen is not None:\n f.savefig(pdf_filen)\n\n\nc_map = cm.jet\n\n\ndef thermal_fit_result(fit_result, v_residual=None,\n v_label='Unit-cell volume $(\\mathrm{\\AA}^3)$',\n temp_fitline=np.asarray(\n [300., 1000., 1500., 2000., 2500., 3000.]),\n figsize=(5, 5), height_ratios=(3, 1), ms_data=50,\n p_err=None, v_err=None, cbar_loc=(0.99, 0.1, .01, 0.82),\n pdf_filen=None, title='Fit result'):\n \"\"\"\n plot P-V-T EOS curve fitting result\n\n :param fit_result: lmfit result object, see example jnb file for detail\n :param v_label: label for volume axis\n :param temp_fitline: temperatures to calculate isothermal compression\n curves, default = [300., 1000., 1500., 2000., 2500., 3000.]\n :param figsize: figure size, default = (7,7)\n :param height_ratios: height ratio between the main and residue plots,\n default = (3,1)\n :param ms_data: marker size for data points\n :param p_err: pressure error bar\n :param v_err: volume error bar\n :param cbar_loc: location of color bar\n :param pdf_filen: name of pdf output file\n :param title: title of the figure\n :return: None\n \"\"\"\n # basic figure setup\n f, ax = plt.subplots(2, 1, sharex=True, figsize=figsize,\n gridspec_kw={'height_ratios': height_ratios})\n for ax_i in ax:\n ax_i.tick_params(direction='in')\n # read data to plot\n v_data = fit_result.userkws['v']\n temp_data = fit_result.userkws['temp']\n p_data = fit_result.data\n p_datafit = fit_result.best_fit\n v0 = uct.ufloat(fit_result.params['st_v0'].value,\n fit_result.params['st_v0'].stderr)\n sm = plt.cm.ScalarMappable(cmap=c_map,\n norm=plt.Normalize(\n vmin=300., vmax=temp_data.max()))\n a = sm.to_rgba(temp_fitline)\n v_fitline = np.linspace(v0.n, min(v_data), 1000)\n fitmodel_copy = copy.deepcopy(fit_result)\n for a_i, temp_i in zip(a, temp_fitline):\n p_fitline = fitmodel_copy.eval(v=v_fitline,\n temp=np.ones_like(v_fitline) * temp_i)\n ax[0].plot(p_fitline, v_fitline, c=a_i)\n # error range here does not make a lot sense, so not supported\n # if (p_err is not None) and (v_err is not None):\n ax[0].errorbar(p_data, v_data, xerr=p_err, yerr=v_err, fmt=' ', c='k',\n capsize=0, elinewidth=0.5, label='Data', zorder=0)\n points = ax[0].scatter(p_data, v_data, marker='o', s=ms_data, c=temp_data,\n cmap=c_map, vmin=300., vmax=temp_data.max(),\n zorder=1)\n if v_residual is None:\n ax[1].scatter(p_data, p_data - p_datafit, marker='o', s=ms_data,\n c=temp_data, cmap=c_map, vmin=300.,\n vmax=temp_data.max(), zorder=1)\n ax[1].errorbar(p_data, p_data - p_datafit, yerr=p_err, fmt=' ', c='k',\n capsize=0, elinewidth=0.5, label='Data', zorder=0)\n ax[1].set_ylabel('$P_{obs} - P_{fit}$')\n else:\n ax[1].scatter(p_data, v_residual, marker='o', s=ms_data, c=temp_data,\n cmap=c_map, vmin=300., vmax=temp_data.max(), zorder=1)\n ax[1].errorbar(p_data, v_residual, yerr=p_err, fmt=' ', c='k',\n capsize=0, elinewidth=0.5, label='Data', zorder=0)\n ax[1].set_ylabel('$V_{obs} - V_{fit}$')\n # ax[0].legend()\n position = f.add_axes(cbar_loc)\n f.colorbar(points, orientation=\"vertical\", cax=position,\n ticks=temp_fitline)\n ax[1].axhline(0, c='k', ls='--')\n ax[1].set_xlabel('Pressure (GPa)')\n ax[0].set_ylabel(v_label)\n ax[0].set_title(title)\n plt.tight_layout()\n if pdf_filen is not None:\n f.savefig(pdf_filen)\n", "meta": {"hexsha": "d6f7b7d3fb0f3dcebeef6d82aebb459dc1616bcd", "size": 6356, "ext": "py", "lang": "Python", "max_stars_repo_path": "pytheos/plot/thermal_fit.py", "max_stars_repo_name": "SHDShim/pytheos", "max_stars_repo_head_hexsha": "be079624405e92fbec60c5ead253eb5917e55237", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2017-06-23T03:28:51.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-02T01:06:50.000Z", "max_issues_repo_path": "pytheos/plot/thermal_fit.py", "max_issues_repo_name": "SHDShim/pytheos", "max_issues_repo_head_hexsha": "be079624405e92fbec60c5ead253eb5917e55237", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2018-03-06T00:07:51.000Z", "max_issues_repo_issues_event_max_datetime": "2018-07-18T17:42:26.000Z", "max_forks_repo_path": "pytheos/plot/thermal_fit.py", "max_forks_repo_name": "SHDShim/pytheos", "max_forks_repo_head_hexsha": "be079624405e92fbec60c5ead253eb5917e55237", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2017-07-11T19:40:12.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-12T02:20:39.000Z", "avg_line_length": 41.8157894737, "max_line_length": 79, "alphanum_fraction": 0.5797671492, "include": true, "reason": "import numpy", "num_tokens": 1829, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583269943353744, "lm_q2_score": 0.35577489351363034, "lm_q1q2_score": 0.1986387269554531}} {"text": "\"\"\"\nThis class implements simple policy gradient algorithm for\nbiasing the generation of molecules towards desired values of\nproperties aka Reinforcement Learninf for Structural Evolution (ReLeaSE)\nas described in \nPopova, M., Isayev, O., & Tropsha, A. (2018). \nDeep reinforcement learning for de novo drug design. \nScience advances, 4(7), eaap7885.\n\"\"\"\n\nimport torch\nimport torch.nn.functional as F\nimport numpy as np\nfrom rdkit import Chem\n\n\nclass Reinforcement(object):\n #def __init__(self, generator, predictor, get_reward):\n def __init__(self, generator, get_reward):\n \"\"\"\n Constructor for the Reinforcement object.\n\n Parameters\n ----------\n generator: object of type StackAugmentedRNN\n generative model that produces string of characters (trajectories)\n\n predictor: object of any predictive model type\n predictor accepts a trajectory and returns a numerical\n prediction of desired property for the given trajectory\n\n get_reward: function\n custom reward function that accepts a trajectory, predictor and\n any number of positional arguments and returns a single value of\n the reward for the given trajectory\n Example:\n reward = get_reward(trajectory=my_traj, predictor=my_predictor,\n custom_parameter=0.97)\n\n Returns\n -------\n object of type Reinforcement used for biasing the properties estimated\n by the predictor of trajectories produced by the generator to maximize\n the custom reward function get_reward.\n \"\"\"\n\n super(Reinforcement, self).__init__()\n self.generator = generator\n #self.predictor = predictor\n self.get_reward = get_reward\n\n def policy_gradient(self, data, n_batch=10, gamma=0.97,\n std_smiles=False, grad_clipping=None, **kwargs):\n \"\"\"\n Implementation of the policy gradient algorithm.\n\n Parameters:\n -----------\n\n data: object of type GeneratorData\n stores information about the generator data format such alphabet, etc\n\n n_batch: int (default 10)\n number of trajectories to sample per batch. When training on GPU\n setting this parameter to to some relatively big numbers can result\n in out of memory error. If you encountered such an error, reduce\n n_batch.\n\n gamma: float (default 0.97)\n factor by which rewards will be discounted within one trajectory.\n Usually this number will be somewhat close to 1.0.\n\n\n std_smiles: bool (default False)\n boolean parameter defining whether the generated trajectories will\n be converted to standardized SMILES before running policy gradient.\n Leave this parameter to the default value if your trajectories are\n not SMILES.\n\n grad_clipping: float (default None)\n value of the maximum norm of the gradients. If not specified,\n the gradients will not be clipped.\n\n kwargs: any number of other positional arguments required by the\n get_reward function.\n\n Returns\n -------\n total_reward: float\n value of the reward averaged through n_batch sampled trajectories\n\n rl_loss: float\n value for the policy_gradient loss averaged through n_batch sampled\n trajectories\n\n \"\"\"\n rl_loss = 0\n self.generator.optimizer.zero_grad()\n total_reward = 0\n \n for _ in range(n_batch):\n\n # Sampling new trajectory\n reward = 0\n trajectory = '<>'\n while reward == 0:\n trajectory = self.generator.evaluate(data)\n if std_smiles:\n try:\n mol = Chem.MolFromSmiles(trajectory[1:-1])\n trajectory = '<' + Chem.MolToSmiles(mol) + '>'\n #reward = self.get_reward(trajectory[1:-1], \n # self.predictor, \n # **kwargs)\n reward = self.get_reward(trajectory[1:-1])\n except:\n reward = 0\n else:\n #reward = self.get_reward(trajectory[1:-1],\n # self.predictor, \n # **kwargs)\n reward = self.get_reward(trajectory[1:-1])\n\n # Converting string of characters into tensor\n trajectory_input = data.char_tensor(trajectory)\n discounted_reward = reward\n total_reward += reward\n\n # Initializing the generator's hidden state\n hidden = self.generator.init_hidden()\n if self.generator.has_cell:\n cell = self.generator.init_cell()\n hidden = (hidden, cell)\n if self.generator.has_stack:\n stack = self.generator.init_stack()\n else:\n stack = None\n\n # \"Following\" the trajectory and accumulating the loss\n for p in range(len(trajectory)-1):\n output, hidden, stack = self.generator(trajectory_input[p], \n hidden, \n stack)\n log_probs = F.log_softmax(output, dim=1)\n top_i = trajectory_input[p+1]\n rl_loss -= (log_probs[0, top_i]*discounted_reward)\n discounted_reward = discounted_reward * gamma\n\n # Doing backward pass and parameters update\n rl_loss = rl_loss / n_batch\n total_reward = total_reward / n_batch\n rl_loss.backward()\n if grad_clipping is not None:\n torch.nn.utils.clip_grad_norm_(self.generator.parameters(), \n grad_clipping)\n\n self.generator.optimizer.step()\n \n return total_reward, rl_loss.item()\n", "meta": {"hexsha": "4ad3230cca928e3ee576d783d9b1370b0596baf1", "size": 6134, "ext": "py", "lang": "Python", "max_stars_repo_path": "release/reinforcement.py", "max_stars_repo_name": "flyyufelix/ReLeaSE", "max_stars_repo_head_hexsha": "a13e50072193eb3c2f931fb968d68f71a4c636ac", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "release/reinforcement.py", "max_issues_repo_name": "flyyufelix/ReLeaSE", "max_issues_repo_head_hexsha": "a13e50072193eb3c2f931fb968d68f71a4c636ac", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "release/reinforcement.py", "max_forks_repo_name": "flyyufelix/ReLeaSE", "max_forks_repo_head_hexsha": "a13e50072193eb3c2f931fb968d68f71a4c636ac", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.3375, "max_line_length": 81, "alphanum_fraction": 0.5743397457, "include": true, "reason": "import numpy", "num_tokens": 1128, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583269796369904, "lm_q2_score": 0.3557748935136304, "lm_q1q2_score": 0.19863872172613714}} {"text": "\"\"\"Implements a factored random geometric graph\n\nA factored random geometric graph is special representation of a random\ngeometric graph, for the case when the configuration space is the\nCartesian product of a numbor of component manifolds. The particular\ncase of interest is the manifold of configurations of K objects, which\nis the Cartesian product of K copies SE(2) (in two dimensions) or SE(3)\nin three dimensions.\n\nThe vertices can be represented by length-K tuples, where each element\nis an index into a sequence of configurations in one of the component\nmanifolds. The precise form of edges required to ensure probabilistic\ncompleteness and asymptotic optimality is an object of ongoing research.\n\nThe classes in this module take objects parameterizing dynamics and\ngeometry, and do the bookkeeping necessary to maintain a factored random\ngeometric graph.\n\"\"\"\nimport math\nimport itertools\n\nimport numpy\nfrom scipy.spatial import cKDTree\n\nimport metis\nfrom metis.abstract_graphs import UndirectedGraph\n\nclass NoObjectContactBlacklist(object):\n def __init__(self, robot='robot'):\n super(NoObjectContactBlacklist, self).__init__()\n self.robot = robot\n\n def __contains__(self, pair):\n return pair[0] != self.robot and pair[1] is not None\n\ndef apply_transform(tfA, tfB):\n \"\"\"Return the result of applying tfA to tfB\n\n Args:\n tfA (tuple): a transform, represented as an (x, y, theta) tuple\n tfB (tuple): a transform, represented as an (x, y, theta) tuple\n\n Returns:\n tuple: (x, y, theta) representing a transform with the same\n effect as first applying 'tfB' and then applying 'tfA'. If\n the transforms were represented as matrices, this would be\n tfA * tfB.\n \"\"\"\n return (tfA[0] + numpy.cos(tfA[2]) * tfB[0] - numpy.sin(tfA[2]) * tfB[1],\n tfA[1] + numpy.sin(tfA[2]) * tfB[0] + numpy.cos(tfA[2]) * tfB[1],\n tfA[2] + tfB[2])\n\ndef apply_inverse_transform(tfA, tfB):\n \"\"\"Return the result of applying tfA to the inverse of tfB\n\n Args:\n tfA (tuple): a transform, represented as an (x, y, theta) tuple\n tfB (tuple): a transform, represented as an (x, y, theta) tuple\n\n Returns:\n tuple: (x, y, theta) representing a transform with the same\n effect as first applying the inverse of 'tfB' and then\n applying 'tfA'. If the transforms were represented as\n matrices, this would be tfA / tfB.\n \"\"\"\n dtf = tfA - tfB\n return (numpy.cos(tfB[2]) * dtf[0] + numpy.sin(tfB[2]) * dtf[1],\n -numpy.sin(tfB[2]) * dtf[0] + numpy.cos(tfB[2]) * dtf[1],\n dtf[2])\n\nclass Manifold(object):\n def __init__(self, samples):\n self.samples = numpy.array(samples)\n assert self.samples.ndim == 2, \"Data must be a sequence of samples\"\n\n def __len__(self):\n return len(self.samples)\n\n def __iter__(self):\n return iter(xrange(len(self.samples)))\n\n def __contains__(self, index):\n return 0 <= index < len(self.samples)\n\n def __getitem__(self, index):\n return self.samples[index]\n\n def nearest_samples(self, point, k):\n \"\"\"Return then indices of the samples near the query pose\"\"\"\n pass\n\n def nearby_samples(self, point, r):\n \"\"\"Return then indices of the samples near the query pose\"\"\"\n pass\n\n\n def neighbors(self, index):\n \"\"\"Return the neighbors of the specified sample index\"\"\"\n pass\n\n\nclass SE2Manifold(Manifold):\n \"\"\"Random disc graph on a manifold\n\n A random disc graph has vertices sampled from an n dimensional\n manifold, and an edge between all vertices with minimal geodesic\n distance less than a fixed constant. We take that constant to be the\n critical distance derived in Karaman and Frazzoli (2011), which is\n minimal distance required to ensure the resulting graph includes an\n optimal path.\n\n Vertex labels are just indices of an array of points, so any integer\n between 0 and `count-1`.\n\n Args:\n samples (array-like): if supplied, include these\n configurations as vertices in the graph, in addition to\n `count` random configurations.\n epsilon (float): positive scalar multiplier by which to\n approximate nearest neighbor search (larger is faster but\n less accurate)\n eta (float): positive scalar multiplier by which to inflate the\n distance threshhold defining the graph (larger is slower but\n more accurate; graph is asymptotically optimal iff eta>=1)\n\n Attributes:\n geometry (metis.geometry.Geometry): object describing problem geometry\n configurations (numpy.array): array of samples corresponding to\n vertices. Each row is a sample from the configuration space\n defined by geometry.\n epsilon (float): positive scalar multiplier by which to\n approximate nearest neighbor search (larger is faster but\n less accurate)\n eta (float): positive scalar multiplier by which to inflate the\n distance threshhold defining the graph (larger is slower but\n more accurate; graph is asymptotically optimal iff eta>=1)\n mu_free (float); positive scalar approximating the Lebesgue\n measure of free space in the configuration\n search_radius (float): positive scalar defining maximum distance\n between vertices for which an edge may exist\n nearby_configurations (list(list)): list of lists of neighboring\n vertices for each vertex in the graph. Precomputed for speed\n \"\"\"\n def __init__(self, samples, scale=1., epsilon=0., search_radius=None, eta=1.):\n super(SE2Manifold, self).__init__(samples)\n assert self.samples.shape[1] == 3, \\\n \"Data must be 'x, y, theta' sequences\"\n\n self.scale = scale\n self.epsilon = epsilon\n self.eta = eta\n\n if search_radius is None:\n count, dim = self.samples.shape\n d_inv = 1. / float(dim)\n zeta_d = math.pi**(dim/2) / math.gamma(dim/2 + 1)\n\n mu_free = (numpy.prod(numpy.ptp(self.samples[:,:-1], axis=0))\n * 2 * numpy.pi * scale)\n self.search_radius = 2 * self.eta * (\n d_inv * (mu_free / zeta_d) * (math.log(count) / float(count))\n )**d_inv\n else:\n self.search_radius = search_radius\n\n self._search = cKDTree(numpy.concatenate(\n (self.samples[:, :-1],\n self.scale * numpy.cos(self.samples[:, -1:]),\n self.scale * numpy.sin(self.samples[:, -1:])), axis=1))\n self._neighbors = self._search.query_ball_tree(\n self._search, (1 + epsilon) * self.search_radius, eps=epsilon)\n\n def nearest_samples(self, point, k):\n \"\"\"Return the indices of the k samples nearest the query point\n\n Args:\n point: query location, represented as an (x, y, theta) tuple\n\n Returns:\n list: list of tuples (d, i), where d is the distance between\n sample i and the query point\n \"\"\"\n query = (point[0], point[1],\n self.scale * numpy.cos(point[2]),\n self.scale * numpy.sin(point[2]))\n return zip(*self._search.query(query, k))\n\n def nearby_samples(self, point, r):\n \"\"\"Return the indices of the samples near the query point\n\n Args:\n point: query location, represented as an (x, y, theta) tuple\n r: search radius\n\n Returns:\n list: list of indices of samples within distance r of the\n query point\n \"\"\"\n query = (point[0], point[1],\n self.scale * numpy.cos(point[2]),\n self.scale * numpy.sin(point[2]))\n return self._search.query_ball_point(\n query, (1+self.epsilon)*r, eps=self.epsilon)\n\n def neighbors(self, vertex):\n \"\"\"Generate all vertices less than threshhold from vertex\n\n This is computationally inexpensive due to precomputation.\n Note:\n Does not perform collision detection; some edges returned\n here may not be collision free. Collision detection is\n performed when the cost of an edge is evaluated.\n\n Args:\n vertex (int): index of a vertex in the graph\n\n Returns:\n generator(int): generates all neighbors of vertex\n \"\"\"\n return (n for n in self._neighbors[vertex] if n != vertex)\n\n def distance(self, pose1, pose2):\n point1 = numpy.array((pose1[0], pose1[1],\n self.scale * numpy.cos(pose1[2]),\n self.scale * numpy.sin(pose1[2])))\n point2 = numpy.array((pose2[0], pose2[1],\n self.scale * numpy.cos(pose2[2]),\n self.scale * numpy.sin(pose2[2])))\n return numpy.sqrt(numpy.sum((point1-point2)**2))\n\nclass FactoredRandomGeometricGraph(UndirectedGraph):\n \"\"\"Factored random geometric graph for manipulation\n\n The vertices of this graph are hashable dict-like structures mapping\n object names to tuples of (parent name, transform index), where\n parent_name is the name of the object relative to which the\n transform of the object name is computed. A vertex can be unpacked into\n configurations using the notation graph[vertex]. The graph is\n immutable after construction; vertex data cannot be changed or\n deleted.\n\n Args:\n geometry (ManyShapeGeometry): object describing problem geometry\n dynamics: used to determine how each object can move\n robot (str): the identifier of the object to consider the\n robot for planning purposes\n geometry (metis.geometry.ManyShapeGeometry): object describing\n problem geometry\n counts (dict): maps manifolds, specified as (object, object)\n 2-tuples, to the number of random samples to draw from that\n manifold\n default_count (int): number of poses of each object to sample.\n This value is used for any manifold not specified in counts,\n and is overridden by any manifold specified in counts.\n configurations (dict): if supplied, include these\n configurations in the component set for the supplied\n objects, in addition to `count` random configurations.\n epsilon (float): positive scalar multiplier by which to\n approximate nearest neighbor search (larger is faster but\n less accurate)\n eta (float): positive scalar multiplier by which to inflate the\n distance threshhold defining the graph (larger is slower but\n more accurate; graph is asymptotically optimal iff eta>=1)\n\n Attributes:\n geometry (ManyShapeGeometry): object describing problem geometry\n dynamics: used to determine how each object can move\n robot (str): the identifier of the object to consider the\n robot for planning purposes\n manifolds (dict): maps manifold names to structures defining the\n manifolds themselves\n epsilon (float): positive scalar multiplier by which to\n approximate nearest neighbor search (larger is faster but\n less accurate)\n eta (float): positive scalar multiplier by which to inflate the\n distance threshhold defining the graph (larger is slower but\n more accurate; graph is asymptotically optimal iff eta>=1)\n \"\"\"\n def __init__(self, geometry, dynamics, counts=None, default_count=0,\n configurations=None, blacklist=(), robot='robot',\n epsilon=0., eta=1.):\n # pylint: disable=too-many-arguments\n assert robot in geometry.bodies\n\n # Rebind default mutable arguments\n if counts is None:\n counts = {}\n if configurations is None:\n configurations = {}\n\n # Declare members\n self.geometry = geometry\n self.dynamics = dynamics\n self.names = [name for name in geometry.bodies]\n self.samples = {}\n self.robot = robot\n self.epsilon = epsilon\n self.eta = eta\n\n for name in self.names:\n transforms = configurations.get((name, None), [])\n count = counts.get((name, None), default_count)\n transforms += [geometry.sample_object_configuration(name)\n for _ in xrange(count)]\n self.samples[(name, None)] = SE2Manifold(transforms, epsilon=epsilon, eta=eta)\n\n # Sample poses relative to other objects\n for other in self.names:\n if name != other and (name, other) not in blacklist:\n count = counts.get((name, other), default_count)\n poses = list(dynamics.sample_from_manifold((name, other), count))\n self.samples[(name, other)] = SE2Manifold(\n [pose for pose in poses])\n else:\n self.samples[(name, other)] = Manifold([[]])\n\n @staticmethod\n def is_acyclic(vertex):\n \"\"\"Determine if a directed chain graph is acyclic\n\n An acyclic chain is one name for a directed graph where each\n vertex is the source of at most one outward edge, and there are\n no cycles of directed edges. So for vertices (A, B, C), A=>B=>C\n would be an acyclic chain, while A=>B=>C=>A would not.\n\n Args:\n vertex (dict): maps vertex labels to a tuple (parent, None),\n describing the unique edge beginning at the vertex. A\n missing edge is denoted as an edge back to the vertex,\n so `{name: (name, None)}` describes a vertex with label\n `name` and no outgoing edge. The choice to represent an\n edge as a tuple with second value None was made for\n uniformity with the vertex representation, which uses\n the second argument to specify an index.\n\n Yields:\n bool: true if the graph has no cycles\n \"\"\"\n todo = set(vertex.iterkeys())\n while todo:\n name = todo.pop()\n chain = set()\n while True:\n parent, _ = vertex[name]\n chain.add(name)\n if parent is None:\n # We've found a root node.\n break\n elif parent in chain:\n return False\n elif parent in todo:\n # If we haven't already confirmed this node is not\n # part of a cycle, continue searching this chain\n name = parent\n else:\n # If we haven't already confirmed this node is not\n # part of a cycle, continue searching this chain\n break\n todo -= chain\n return True\n\n @staticmethod\n def acyclic_chains(names):\n \"\"\"Generate the acyclic chains with labels drawn from names\n\n An acyclic chain is one name for a directed graph where each\n vertex is the source of at most one outward edge, and there are\n no cycles of directed edges. So for vertices (A, B, C), A=>B=>C\n would be an acyclic chain, while A=>B=>C=>A would not.\n\n Note there are very many acyclic chains: if there are $n$ names,\n there are at least $n!$ acyclic chains, and at most $n^n$. This\n function computes the acyclic chains by sequentially generating\n all directed graphs with maximal outdegree 1, then rejecting\n those graphs with cycles. The running time of this function is\n thus `O(len(names)^len(names))`, also known as really really\n slow.\n\n Args:\n names (list): list of vertex labels\n\n Yields:\n dict: maps each name to a tuple (parent, None), where parent\n is the sink of its unique edge. A missing edge is\n denoted as an edge back to the vertex, so `{name: (name,\n None)}` describes a vertex with label `name` and no\n outgoing edge. The choice to represent an edge as a\n tuple with second value None was made for uniformity\n with the vertex representation, which uses the second\n argument to specify an index..\n \"\"\"\n for combination in itertools.product(*(\n [(a, b if b != a else None) for b in names]\n for a in names)):\n vertex = {name: (parent, None) for name, parent in combination}\n if FactoredRandomGeometricGraph.is_acyclic(vertex):\n yield vertex\n\n def __contains__(self, vertex):\n \"\"\"Check if the graph contains a vertex\n\n The graph contains a vertex if the keys are all the object\n names, the values are tuples (parent, index), the index is a key\n for the (object, parent) sample set, and the directed graph\n formed with edges between each object and its parent is acyclic.\n \"\"\"\n for name in self.names:\n if name not in vertex:\n return False\n (parent, index) = vertex[name]\n if (name, parent) not in self.samples:\n return False\n if index not in self.samples[(name, parent)]:\n return False\n if not self.is_acyclic(vertex):\n return False\n return True\n\n def __len__(self):\n \"\"\"Check if the graph contains a vertex\n\n The graph contains a vertex if the keys are all the object\n names, the values are tuples (parent, index), the index is a key\n for the (object, parent) sample set, and the directed graph\n formed with edges between each object and its parent is acyclic.\n \"\"\"\n total = 0\n for vertex in self.acyclic_chains(self.names):\n prod = 1\n for name, (parent, _) in vertex.iteritems():\n prod *= len(self.samples[(name, parent)])\n total += prod\n return total\n\n def __iter__(self):\n \"\"\"Iterate over all vertices in the graph\n\n Vertices are generated by sequentially generating acyclic\n chains, then generating all combinations of vertex indices for\n those acyclic chains. Note that the size of the graph is\n superexponential in the number of objects, so it can take a very\n long time to iterate over all vertices, even for small,\n low-resolution graphs.\n \"\"\"\n for vertex in self.acyclic_chains(self.names):\n for indices in itertools.product(*(\n iter(self.samples[(name, parent)])\n for name, (parent, _) in vertex.iteritems())):\n yield {name: (parent, index)\n for (name, (parent, _)), index\n in zip(vertex.iteritems(), indices)}\n\n def get_pose_of(self, vertex, name):\n \"\"\"Recursively compute the pose of an object at a vertex\"\"\"\n parent, index = vertex[name]\n transform = self.samples[(name, parent)][index]\n if parent is None:\n return transform\n else:\n return apply_transform(self.get_pose_of(vertex, parent), transform)\n\n def __getitem__(self, vertex):\n \"\"\"Compute the configuration associated with a vertex\n\n Because vertices represent the pose of each object relative to\n the pose of another object, computing the absolute pose of each\n object requires first computing a topological ordering on the\n chain, then propagating an absolute pose down the ordering. This\n could be done by maintaining the vertex structure in a way that\n makes it easy to identify root poses; however, that would\n increase the size and complexity of the vertex representation.\n Instead, we compute the topological ordering implicity by\n iterating over the objects in an arbitrary order and keeping a\n 'to-do list' of objects discovered whose parents had not yet\n been grounded.\n\n Args:\n vertex (dict)\n\n Returns:\n dict: maps object names to (x, y, theta) tuples\n \"\"\"\n todo = {}\n result = {}\n for name in vertex:\n parent, index = vertex[name]\n if parent is None:\n result[name] = self.samples[(name, parent)][index]\n elif parent in result:\n transform = self.samples[(name, parent)][index]\n result[name] = apply_transform(result[parent], transform)\n else:\n todo.setdefault(parent, set()).add(name)\n\n if name in todo:\n for child in todo[name]:\n expected_name, index = vertex[child]\n assert expected_name == name\n transform = self.samples[(child, name)][index]\n result[child] = apply_transform(result[name], transform)\n return result\n\n def __getstate__(self):\n state = self.__dict__.copy()\n del state['geometry']\n del state['dynamics']\n return state\n\n def __setstate__(self, state):\n self.__dict__.update(state)\n self.geometry = None\n self.dynamics = None\n\n def nearest(self, configuration):\n \"\"\"Return the closest collision-free vertex to configuration\n\n Distance is the sum of the Euclidean distances between the pose\n of each object in the configuration and in the vertex. This is\n computed in a reasonably efficient way using dynamic programming.\n\n Args:\n configuration (dict): maps object names to poses\n\n Returns:\n dict: a dictionary representing the closest collision-free\n vertex to configuration\n \"\"\"\n def expand_queue(name, k):\n \"\"\"Return a sorted list of (distance, index) tuples\"\"\"\n return sorted(self.samples[(name, None)].nearest_samples(\n configuration[name], k))\n\n initial_k = 8\n sample_queues = {}\n for name in configuration:\n sample_queues[name] = expand_queue(name, initial_k)\n\n distance = lambda v: sum(sample_queues[name][v[name]][0]\n for name in configuration)\n start = metis.hashdict.hashdict({name: 0 for name in configuration})\n queue = metis.queue.PriorityQueue([(start, distance(start))])\n\n searched = 0\n while searched < len(self):\n current = queue.pop()\n current_vertex = metis.hashdict.hashdict({\n name: (None, sample_queues[name][index][1])\n for name, index in current.iteritems()})\n searched += 1\n if self.geometry.configuration_is_free(\n self[current_vertex], skip_static=True):\n return current_vertex\n else:\n for name in current:\n child = current + {name: current[name] + 1}\n k = len(sample_queues[name])\n if child[name] == k:\n k = min(len(self.samples[(name, None)]), k * 2)\n sample_queues[name] = expand_queue(name, k)\n if child not in queue:\n queue[child] = distance(child)\n\n def neighbors(self, vertex):\n \"\"\"Generate neighbors of vertex\n\n We can construct the adjacent vertices by considering all\n reachable acyclic chains, then identifying within each chain all\n configurations within a distance of search_radius from the\n current vertex.\n\n Args:\n vertex (dict): maps object names to tuples (parent, i), with\n i an index in the sample set (name, parent)\n\n Yields:\n hashdict: neighboring vertices on the factored graph\n \"\"\"\n # Check if the configuration encoded in the vertex dict is free\n if not self.geometry.configuration_is_free(\n self[vertex], skip_static=True):\n raise StopIteration\n\n result = metis.hashdict.hashdict(vertex)\n\n # TODO: Many things in this function should be in the dynamics.\n # Instead they are hard-coded for convenience\n\n # Identify the parent and the root of the current vertex (the\n # root is the ancestor of 'robot' whose parent is None)\n parent, _ = vertex[self.robot]\n root_parent = root = self.robot\n while root_parent is not None:\n root = root_parent\n root_parent, root_index = vertex[root]\n\n # Generate neighbors on the current manifold [D]\n for sample in self.samples[(root, None)].neighbors(root_index):\n neighbor = result + {root: (None, sample)}\n if self.geometry.configuration_is_free(\n self[neighbor], skip_static=True):\n yield neighbor\n\n # Generate neighbors on adjacent manifolds. The adjacent\n # acyclic chains are hard-coded as the chains for which only the\n # robot changes its parent relative to the chain described in\n # vertex.\n\n # We always move through free space to change parents, so use\n # the search radius for free space\n radius = self.samples[(self.robot, None)].search_radius\n if self.robot != root:\n # The robot is not a root pose: it is currently in contact\n # with something. Look for poses not in contact with\n # anything\n pose = self.get_pose_of(vertex, self.robot)\n manifold = self.samples[(self.robot, None)]\n for sample in manifold.nearby_samples(pose, radius):\n neighbor = result + {self.robot: (None, sample)}\n if self.geometry.configuration_is_free(\n self[neighbor], skip_static=True):\n yield neighbor\n\n for new_parent in self.names:\n # Consider changing parent to non-root poses\n if new_parent == self.robot or new_parent == parent:\n continue\n else:\n # Now we find nearby poses in this cycle. Translate the\n # current pose to a pose relative to the new parent\n pose = self.get_pose_of(vertex, self.robot)\n parent_pose = self.get_pose_of(vertex, new_parent)\n relative_pose = apply_inverse_transform(pose, parent_pose)\n\n # Search for neighbors near the absolute pose\n manifold = self.samples[(self.robot, new_parent)]\n for sample in manifold.nearby_samples(relative_pose, radius):\n neighbor = result + {self.robot: (new_parent, sample)}\n if self.geometry.configuration_is_free(\n self[neighbor], skip_static=True):\n yield neighbor\n\n def cost(self, parent, child):\n parent_configuration = self[parent]\n child_configuration = {self.robot: self.get_pose_of(child, self.robot)}\n holding = child[self.robot][0]\n if holding is not None:\n child_configuration[holding] = self.get_pose_of(child, holding)\n was_holding = parent[self.robot][0]\n if was_holding is not None:\n child_configuration[was_holding] = self.get_pose_of(child, was_holding)\n # child_configuration = {\n # name: self.get_pose_of(child, name)\n # for name in child if parent[name] != child[name]}\n\n # TODO: this does not check for collision between objects. I\n # *think* what we want is for any object that doesn't move to be\n # treated as part of the background, and any object that does\n # move to be ignored for collision detection. Not sure how to\n # accomplish that.\n if self.geometry.path_is_free(parent_configuration,\n child_configuration,\n skip_configuration=True):\n return self.dynamics.cost(parent_configuration, child_configuration)\n else:\n return float('inf')\n\n\n", "meta": {"hexsha": "64ae7df43fba45d938a58c4e45c57866d301e411", "size": 28257, "ext": "py", "lang": "Python", "max_stars_repo_path": "metis/factored_random_geometric_graphs.py", "max_stars_repo_name": "robustrobotics/forgg", "max_stars_repo_head_hexsha": "97fc0896dfe4522156a42b8eddb641216149c5ff", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2016-12-06T19:23:09.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-14T07:06:24.000Z", "max_issues_repo_path": "metis/factored_random_geometric_graphs.py", "max_issues_repo_name": "robustrobotics/forgg", "max_issues_repo_head_hexsha": "97fc0896dfe4522156a42b8eddb641216149c5ff", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "metis/factored_random_geometric_graphs.py", "max_forks_repo_name": "robustrobotics/forgg", "max_forks_repo_head_hexsha": "97fc0896dfe4522156a42b8eddb641216149c5ff", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.3008982036, "max_line_length": 90, "alphanum_fraction": 0.6078847719, "include": true, "reason": "import numpy,from scipy", "num_tokens": 5875, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583269943353745, "lm_q2_score": 0.35577487985229844, "lm_q1q2_score": 0.19863871932796276}} {"text": "\"\"\"\nSimplex optimization.\n\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\n\nimport copy\nimport collections\nimport logging\nimport logging.config\nimport numpy as np\nimport re\nimport sqlite3\nimport textwrap\n\nimport calculate\nimport compare\nimport constants as co\nimport datatypes\nimport opt\nimport parameters\n\nlogger = logging.getLogger(__name__)\n\nclass Simplex(opt.Optimizer):\n \"\"\"\n Optimizes force field parameters using an in-house version of the simplex\n method. See `Optimizer` for repeated documentation.\n\n Attributes\n ----------\n _max_cycles_wo_change : int\n End the simplex optimization early if there have\n been this many consecutive simplex steps without\n improvement in the objective function.\n do_massive_contraction : bool\n If True, allows massive contractions to be\n performed, contracting all parameters at once.\n do_weighted_reflection : bool\n If True, weights parameter sets based on their\n objective function score when determining the\n reflection point.\n max_cycles : int\n Maximum number of simplex cycles.\n\n max_params : int\n Maximum number of parameters used in a single simplex cycle.\n \"\"\"\n def __init__(self,\n direc=None,\n ff=None,\n ff_lines=None,\n args_ff=None,\n args_ref=None):\n super(Simplex, self).__init__(\n direc, ff, ff_lines, args_ff, args_ref)\n self._max_cycles_wo_change = None\n self.do_massive_contraction = True\n self.do_weighted_reflection = True\n self.max_cycles = 100\n self.max_params = 3\n @property\n def best_ff(self):\n # Typically, self.new_ffs would include the original FF, self.ff,\n # but this can be changed by massive contractions.\n if self.new_ffs:\n self.new_ffs = sorted(self.new_ffs, key=lambda x: x.score)\n # I think this is necessary after massive contraction.\n # Massive contraction can potentially make eveything worse.\n # No, it can't!!! The best FF is always retained! /Per-Ola\n # Yep, he's right. /Eric\n if self.new_ffs[0].score < self.ff.score:\n best_ff = self.new_ffs[0]\n best_ff = restore_simp_ff(best_ff, self.ff)\n return best_ff\n else:\n return self.ff\n else:\n return self.ff\n @opt.catch_run_errors\n def run(self, r_data=None):\n \"\"\"\n Once all attributes are setup as you so desire, run this method to\n optimize the parameters.\n\n Returns\n -------\n `datatypes.FF` (or subclass)\n Contains the best parameters.\n \"\"\"\n if r_data is None:\n r_data = opt.return_ref_data(self.args_ref)\n\n if self.ff.score is None:\n logger.log(20, '~~ CALCULATING INITIAL FF SCORE ~~'.rjust(79, '~'))\n self.ff.export_ff()\n # Could store data on self.ff.data if we wanted. Not necessary for\n # simplex. If simplex yielded no improvements, it would return this\n # FF, and then we might want the data such taht we don't have to\n # recalculate it in gradient. Let's hope simplex generally yields\n # improvements.\n data = calculate.main(self.args_ff)\n #deprecated\n #self.ff.score = compare.compare_data(r_data, data)\n r_dict = compare.data_by_type(r_data)\n c_dict = compare.data_by_type(data)\n r_dict, c_dict = compare.trim_data(r_dict,c_dict)\n self.ff.score = compare.compare_data(r_dict, c_dict)\n else:\n logger.log(20, ' -- Reused existing score and data for initial FF.')\n\n logger.log(20, '~~ SIMPLEX OPTIMIZATION ~~'.rjust(79, '~'))\n logger.log(20, 'INIT FF SCORE: {}'.format(self.ff.score))\n opt.pretty_ff_results(self.ff, level=20)\n\n # Here's what we do if there are too many parameters.\n if self.max_params and len(self.ff.params) > self.max_params:\n logger.log(20, ' -- More parameters than the maximum allowed.')\n logger.log(5, 'CURRENT PARAMS: {}'.format(len(self.ff.params)))\n logger.log(5, 'MAX PARAMS: {}'.format(self.max_params))\n # Here we select the parameters that have the lowest 2nd\n # derivatives.\n\n # Could fail when simplex finds improvements but restores other\n # parameters.\n # if self.ff.params[0].d1:\n\n if None in [x.d1 for x in self.ff.params]:\n logger.log(15, ' -- Calculating new parameter derivatives.')\n # Do central differentiation so we can calculate derivatives.\n # Another option would be to write code to determine\n # derivatives only from forward differentiation.\n ffs = opt.differentiate_ff(self.ff, central=True)\n # We have to score to get the derivatives.\n for ff in ffs:\n ff.export_ff(path=self.ff.path, lines=self.ff_lines)\n logger.log(20, ' -- Calculating {}.'.format(ff))\n data = calculate.main(self.args_ff)\n #deprecated\n #ff.score = compare.compare_data(r_data, data)\n r_dict = compare.data_by_type(r_data)\n c_dict = compare.data_by_type(data)\n r_dict, c_dict = compare.trim_data(r_dict,c_dict)\n ff.score = compare.compare_data(r_dict, c_dict)\n opt.pretty_ff_results(ff)\n # Add the derivatives to your original FF.\n opt.param_derivs(self.ff, ffs)\n # Only keep the forward differentiated FFs.\n ffs = opt.extract_forward(ffs)\n logger.log(5, ' -- Keeping {} forward differentiated '\n 'FFs.'.format(len(ffs)))\n else:\n logger.log(15, ' -- Reusing existing parameter derivatives.')\n # Differentiate all parameters forward. Yes, I know this is\n # counter-intuitive because we are going to only use subset of\n # the forward differentiated FFs. However, this is very\n # computationally inexpensive because we're not scoring them\n # now. We will remove the forward differentiated FFs we don't\n # want before scoring.\n ffs = opt.differentiate_ff(self.ff, central=False)\n\n # This sorts the parameters based upon their 2nd derivative.\n # It keeps the ones with lowest 2nd derivatives.\n\n # SCHEDULED FOR CHANGES. NOT A GOOD SORTING CRITERION.\n params = select_simp_params_on_derivs(\n self.ff.params, max_params=self.max_params)\n # From the entire list of forward differentiated FFs, pick\n # out the ones that have the lowest 2nd derivatives.\n self.new_ffs = opt.extract_ff_by_params(ffs, params)\n logger.log(1, '>>> len(self.new_ffs): {}'.format(len(self.new_ffs)))\n\n # Reduce number of parameters.\n # Will need an option that's not MM3* specific in the future.\n ff_rows = [x.mm3_row for x in params]\n ff_cols = [x.mm3_col for x in params]\n for ff in self.new_ffs:\n new_params = []\n for param in ff.params:\n if param.mm3_row in ff_rows and param.mm3_col in ff_cols:\n new_params.append(param)\n ff.params = new_params\n # Make a copy of your original FF that has less parameters.\n ff_copy = copy.deepcopy(self.ff)\n new_params = []\n for param in ff.params:\n if param.mm3_row in ff_rows and param.mm3_col in ff_cols:\n new_params.append(param)\n ff_copy.params = new_params\n else:\n # In this case it's simple. Just forward differentiate each\n # parameter.\n self.new_ffs = opt.differentiate_ff(self.ff, central=False)\n logger.log(1, '>>> len(self.new_ffs): {}'.format(len(self.new_ffs)))\n # Still make that FF copy.\n ff_copy = copy.deepcopy(self.ff)\n # Double check and make sure they're all scored.\n for ff in self.new_ffs:\n if ff.score is None:\n ff.export_ff(path=self.ff.path, lines=self.ff_lines)\n logger.log(20, ' -- Calculating {}.'.format(ff))\n data = calculate.main(self.args_ff)\n #deprecated\n #ff.score = compare.compare_data(r_data, data)\n r_dict = compare.data_by_type(r_data)\n c_dict = compare.data_by_type(data)\n r_dict, c_dict = compare.trim_data(r_dict,c_dict)\n ff.score = compare.compare_data(r_dict, c_dict)\n opt.pretty_ff_results(ff)\n\n # Add your copy of the orignal to FF to the forward differentiated FFs.\n self.new_ffs = sorted(self.new_ffs + [ff_copy], key=lambda x: x.score)\n # Allow 3 cycles w/o change for each parameter present. Remember that\n # the initial FF was added here, hence the minus one.\n self._max_cycles_wo_change = 3 * (len(self.new_ffs) - 1)\n wrapper = textwrap.TextWrapper(width=79)\n # Shows all FFs parameters.\n opt.pretty_ff_params(self.new_ffs)\n\n # Start the simplex cycles.\n current_cycle = 0\n cycles_wo_change = 0\n while current_cycle < self.max_cycles \\\n and cycles_wo_change < self._max_cycles_wo_change:\n current_cycle += 1\n\n # Save the last best in case some accidental sort goes on.\n # Plus it makes reading the code a litle easier.\n last_best_ff = copy.deepcopy(self.new_ffs[0])\n logger.log(20, '~~ START SIMPLEX CYCLE {} ~~'.format(\n current_cycle).rjust(79, '~'))\n logger.log(20, 'ORDERED FF SCORES:')\n logger.log(20, wrapper.fill('{}'.format(\n ' '.join('{:15.4f}'.format(x.score) for x in self.new_ffs))))\n\n inv_ff = self.ff.__class__()\n if self.do_weighted_reflection:\n inv_ff.method = 'WEIGHTED INVERSION'\n else:\n inv_ff.method = 'INVERSION'\n inv_ff.params = copy.deepcopy(last_best_ff.params)\n ref_ff = self.ff.__class__()\n ref_ff.method = 'REFLECTION'\n ref_ff.params = copy.deepcopy(last_best_ff.params)\n # Need score difference sum for weighted inversion.\n # Calculate this value before going into loop.\n if self.do_weighted_reflection:\n # If zero, should break.\n score_diff_sum = sum([x.score - self.new_ffs[-1].score\n for x in self.new_ffs[:-1]])\n if score_diff_sum == 0.:\n logger.warning(\n 'No difference between force field scores. '\n 'Exiting simplex.')\n # We want to raise opt.OptError such that\n # opt.catch_run_errors will write the best FF obtained thus\n # far.\n raise opt.OptError(\n 'No difference between force field scores. '\n 'Exiting simplex.')\n for i in range(0, len(last_best_ff.params)):\n if self.do_weighted_reflection:\n inv_val = (\n sum([x.params[i].value *\n (x.score - self.new_ffs[-1].score)\n for x in self.new_ffs[:-1]])\n / score_diff_sum)\n else:\n inv_val = (\n sum([x.params[i].value for x in self.new_ffs[:-1]])\n /\n len(self.new_ffs[:-1]))\n inv_ff.params[i].value = inv_val\n ref_ff.params[i].value = (\n 2 * inv_val - self.new_ffs[-1].params[i].value)\n # The inversion point does not need to be scored.\n # Calculate score for reflected parameters.\n ref_ff.export_ff(path=self.ff.path, lines=self.ff.lines)\n data = calculate.main(self.args_ff)\n #deprecated\n #ref_ff.score = compare.compare_data(r_data, data)\n r_dict = compare.data_by_type(r_data)\n c_dict = compare.data_by_type(data)\n r_dict, c_dict = compare.trim_data(r_dict,c_dict)\n ref_ff.score = compare.compare_data(r_dict, c_dict)\n opt.pretty_ff_results(ref_ff)\n if ref_ff.score < last_best_ff.score:\n logger.log(20, '~~ ATTEMPTING EXPANSION ~~'.rjust(79, '~'))\n exp_ff = self.ff.__class__()\n exp_ff.method = 'EXPANSION'\n exp_ff.params = copy.deepcopy(last_best_ff.params)\n for i in range(0, len(last_best_ff.params)):\n exp_ff.params[i].value = (\n 3 * inv_ff.params[i].value -\n 2 * self.new_ffs[-1].params[i].value)\n exp_ff.export_ff(path=self.ff.path, lines=self.ff.lines)\n data = calculate.main(self.args_ff)\n #deprecated\n #exp_ff.score = compare.compare_data(r_data, data)\n r_dict = compare.data_by_type(r_data)\n c_dict = compare.data_by_type(data)\n r_dict, c_dict = compare.trim_data(r_dict,c_dict)\n exp_ff.score = compare.compare_data(r_dict, c_dict)\n opt.pretty_ff_results(exp_ff)\n if exp_ff.score < ref_ff.score:\n self.new_ffs[-1] = exp_ff\n logger.log(\n 20, ' -- Expansion succeeded. Keeping expanded '\n 'parameters.')\n else:\n self.new_ffs[-1] = ref_ff\n logger.log(\n 20, ' -- Expansion failed. Keeping reflected parameters.')\n elif ref_ff.score < self.new_ffs[-2].score:\n logger.log(20, ' -- Keeping reflected parameters.')\n self.new_ffs[-1] = ref_ff\n else:\n logger.log(20, '~~ ATTEMPTING CONTRACTION ~~'.rjust(79, '~'))\n con_ff = self.ff.__class__()\n con_ff.method = 'CONTRACTION'\n con_ff.params = copy.deepcopy(last_best_ff.params)\n for i in range(0, len(last_best_ff.params)):\n if ref_ff.score > self.new_ffs[-1].score:\n con_val = (\n (inv_ff.params[i].value +\n self.new_ffs[-1].params[i].value) / 2)\n else:\n con_val = (\n (3 * inv_ff.params[i].value -\n self.new_ffs[-1].params[i].value) / 2)\n con_ff.params[i].value = con_val\n self.ff.export_ff(params=con_ff.params)\n data = calculate.main(self.args_ff)\n #deprecated\n #con_ff.score = compare.compare_data(r_data, data)\n r_dict = compare.data_by_type(r_data)\n c_dict = compare.data_by_type(data)\n r_dict, c_dict = compare.trim_data(r_dict,c_dict)\n con_ff.score = compare.compare_data(r_dict, c_dict)\n opt.pretty_ff_results(con_ff)\n # This change was made to reflect the 1998 Q2MM publication.\n # if con_ff.score < self.new_ffs[-1].score:\n if con_ff.score < self.new_ffs[-2].score:\n logger.log(20, ' -- Contraction succeeded.')\n self.new_ffs[-1] = con_ff\n elif self.do_massive_contraction:\n logger.log(\n 20, '~~ DOING MASSIVE CONTRACTION ~~'.rjust(79, '~'))\n for ff_num, ff in enumerate(self.new_ffs[1:]):\n for i in range(0, len(last_best_ff.params)):\n ff.params[i].value = (\n (ff.params[i].value +\n self.new_ffs[0].params[i].value) / 2)\n self.ff.export_ff(params=ff.params)\n data = calculate.main(self.args_ff)\n #deprecated\n #ff.score = compare.compare_data(r_data, data)\n r_dict = compare.data_by_type(r_data)\n c_dict = compare.data_by_type(data)\n r_dict, c_dict = compare.trim_data(r_dict,c_dict)\n ff.score = compare.compare_data(r_dict, c_dict)\n ff.method += ' MC'\n opt.pretty_ff_results(ff)\n else:\n logger.log(\n 20, ' -- Contraction failed. Keeping parmaeters '\n 'anyway.')\n self.new_ffs[-1] = con_ff\n self.new_ffs = sorted(self.new_ffs, key=lambda x: x.score)\n # Keep track of the number of cycles without change. If there's\n # improvement, reset the counter.\n if self.new_ffs[0].score < last_best_ff.score:\n cycles_wo_change = 0\n else:\n cycles_wo_change += 1\n logger.log(20, ' -- {} cycles without improvement out of {} '\n 'allowed.'.format(\n cycles_wo_change, self._max_cycles_wo_change))\n logger.log(20, 'BEST:')\n opt.pretty_ff_results(self.new_ffs[0], level=20)\n logger.log(20, '~~ END SIMPLEX CYCLE {} ~~'.format(\n current_cycle).rjust(79, '~'))\n\n # This sort is likely unnecessary because it should be done at the end\n # of the last loop cycle, but I put it here just in case.\n self.new_ffs = sorted(self.new_ffs, key=lambda x: x.score)\n best_ff = self.new_ffs[0]\n if best_ff.score < self.ff.score:\n logger.log(20, '~~ SIMPLEX FINISHED WITH IMPROVEMENTS ~~'.rjust(\n 79, '~'))\n best_ff = restore_simp_ff(best_ff, self.ff)\n else:\n logger.log(20, '~~ SIMPLEX FINISHED WITHOUT IMPROVEMENTS ~~'.rjust(\n 79, '~'))\n # This restores the inital parameters, so no need to use\n # restore_simp_ff here.\n best_ff = self.ff\n opt.pretty_ff_results(self.ff, level=20)\n opt.pretty_ff_results(best_ff, level=20)\n logger.log(20, ' -- Writing best force field from simplex.')\n best_ff.export_ff(best_ff.path)\n return best_ff\n\ndef calc_simp_var(params):\n \"\"\"\n Simplex variable is calculated: (2nd der.) / (1st der.)**2\n \"\"\"\n logger.log(1, '>>> params: {}'.format(params))\n logger.log(1, '>>> 1st ders.: {}'.format([x.d1 for x in params]))\n logger.log(1, '>>> 2nd ders.: {}'.format([x.d2 for x in params]))\n for param in params:\n param.simp_var = param.d2 / param.d1**2.\n\n# Sorting based upon the 2nd derivative isn't such a good criterion. This should\n# be updated soon.\ndef select_simp_params_on_derivs(params, max_params=10):\n \"\"\"\n Sorts parameter sets from lowest to highest second\n derivatives of their score in the objective function.\n\n Parameters\n ----------\n params : list of subclasses of `datatypes.Param`\n \"\"\"\n calc_simp_var(params)\n keep = sorted(params, key=lambda x: x.simp_var)\n logger.log(1, '>>> x.simp_var: {}'.format([x.simp_var for x in keep]))\n\n # Eliminate all where simp_var is greater than 1. This means that the\n # correct value is bracketed by the differentiation, so gradient\n # optimization should work.\n # keep = [x for x in keep if x.simp_var < 1.]\n\n # Old sorting method.\n # keep = sorted(params, key=lambda x: x.d2)\n\n keep = keep[:max_params]\n logger.log(1, '>>> x.simp_var: {}'.format([x.simp_var for x in keep]))\n logger.log(20, 'KEEPING PARAMS FOR SIMPLEX:\\n{}'.format(\n ' '.join([str(x) for x in keep])))\n return keep\n\ndef restore_simp_ff(new_ff, old_ff):\n \"\"\"\n The old FF has properties that we need to copy to the new FF. We also need\n to grab all the extra parameters included in old FF and add them to the new\n FF.\n \"\"\"\n old_ff.copy_attributes(new_ff)\n if len(old_ff.params) > len(new_ff.params):\n logger.log(15, ' -- Restoring {} parameters to new FF.'.format(\n len(old_ff.params) - len(new_ff.params)))\n\n logger.log(1, '>>> old_ff.params:')\n logger.log(1, old_ff.params)\n logger.log(1, [x.d1 for x in old_ff.params])\n logger.log(1, [x.d2 for x in old_ff.params])\n opt.pretty_derivs(old_ff.params, level=1)\n logger.log(1, '>>> new_ff.params:')\n logger.log(1, new_ff.params)\n logger.log(1, [x.d1 for x in new_ff.params])\n logger.log(1, [x.d2 for x in new_ff.params])\n opt.pretty_derivs(new_ff.params, level=1)\n\n # Backup new parameters.\n new_params = copy.deepcopy(new_ff.params)\n # Copy over all old parameters.\n new_ff.params = copy.deepcopy(old_ff.params)\n # Replace the old with the new.\n for i, param_o in enumerate(old_ff.params):\n for param_n in new_params:\n # Should replace this with a general index scheme.\n if param_o.mm3_row == param_n.mm3_row and \\\n param_o.mm3_col == param_n.mm3_col:\n new_ff.params[i] = copy.deepcopy(param_n)\n return new_ff\n", "meta": {"hexsha": "67c4f38f4a3ab791e1f68bc503238fa42d8613d7", "size": 22084, "ext": "py", "lang": "Python", "max_stars_repo_path": "q2mm/simplex.py", "max_stars_repo_name": "jesswahlers/q2mm", "max_stars_repo_head_hexsha": "71247cd4e7ba644edbe9f55eacd5c88da2e77183", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 19, "max_stars_repo_stars_event_min_datetime": "2015-02-26T20:59:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-11T21:33:32.000Z", "max_issues_repo_path": "q2mm/simplex.py", "max_issues_repo_name": "jesswahlers/q2mm", "max_issues_repo_head_hexsha": "71247cd4e7ba644edbe9f55eacd5c88da2e77183", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 44, "max_issues_repo_issues_event_min_datetime": "2016-06-03T07:34:13.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-13T19:24:00.000Z", "max_forks_repo_path": "q2mm/simplex.py", "max_forks_repo_name": "jesswahlers/q2mm", "max_forks_repo_head_hexsha": "71247cd4e7ba644edbe9f55eacd5c88da2e77183", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 18, "max_forks_repo_forks_event_min_datetime": "2015-03-24T19:52:02.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-23T18:57:23.000Z", "avg_line_length": 46.2976939203, "max_line_length": 83, "alphanum_fraction": 0.5519833364, "include": true, "reason": "import numpy", "num_tokens": 4750, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583269943353745, "lm_q2_score": 0.3557748798522984, "lm_q1q2_score": 0.19863871932796273}} {"text": "import os\nimport numpy\nfrom operator import itemgetter\n\nfrom amuse.community import *\nfrom amuse.community.interface.se import StellarEvolution, StellarEvolutionInterface, \\\n InternalStellarStructure, InternalStellarStructureInterface\n\nfrom amuse.units.quantities import VectorQuantity\nfrom amuse.support.interface import InCodeComponentImplementation\nfrom amuse.support.options import option\n\nclass MESAInterface(CodeInterface, LiteratureReferencesMixIn, StellarEvolutionInterface, \n InternalStellarStructureInterface, CodeWithDataDirectories): \n \"\"\"\n The software project MESA (Modules for Experiments in Stellar Astrophysics, \n http://mesa.sourceforge.net/), aims to provide state-of-the-art, robust, \n and efficient open source modules, usable singly or in combination for a \n wide range of applications in stellar astrophysics. The AMUSE interface to \n MESA can create and evolve stars using the MESA/STAR module. If you order a \n metallicity you haven't used before, starting models will be computed \n automatically and saved in the `mesa/src/data/star_data/starting_models` \n directory (please be patient...). All metallicities are supported, even the \n interesting case of Z=0. The supported stellar mass range is from \n about 0.1 to 100 Msun.\n \n References:\n .. [#] Paxton, Bildsten, Dotter, Herwig, Lesaffre & Timmes 2011, ApJS, arXiv:1009.1622 [2011ApJS..192....3P]\n .. [#] http://mesa.sourceforge.net/\n \"\"\"\n def __init__(self, **options):\n CodeInterface.__init__(self, name_of_the_worker=\"mesa_worker\", **options)\n LiteratureReferencesMixIn.__init__(self)\n CodeWithDataDirectories.__init__(self)\n \n @property\n def default_path_to_inlist(self):\n return os.path.join(self.get_data_directory(), 'AMUSE_inlist')\n\n @option(type=\"string\", sections=('data'))\n def default_path_to_MESA_data(self):\n return os.path.join(self.amuse_root_directory, 'src', 'amuse', 'community', 'mesa', 'src', 'mesa', 'data')\n \n @legacy_function\n def set_MESA_paths():\n \"\"\"\n Set the paths to the MESA inlist and data directories.\n \"\"\"\n function = LegacyFunctionSpecification() \n function.addParameter('inlist_path', dtype='string', direction=function.IN,\n description = \"Path to the inlist file.\")\n function.addParameter('MESA_data_path', dtype='string', direction=function.IN,\n description = \"Path to the data directory.\")\n function.addParameter('local_data_path', dtype='string', direction=function.IN,\n description = \"Path to the data directory.\")\n function.result_type = 'int32'\n function.result_doc = \"\"\"\n 0 - OK\n Current value was set\n -1 - ERROR\n Directory does not exist\n \"\"\"\n return function\n \n @legacy_function\n def get_maximum_number_of_stars():\n \"\"\"\n Retrieve the maximum number of stars that can be\n handled by this instance.\n \"\"\"\n function = LegacyFunctionSpecification() \n function.addParameter('maximum_number_of_stars', dtype='int32', direction=function.OUT,\n description = \"The current value of the maximum number of stars\")\n function.result_type = 'int32'\n function.result_doc = \"\"\"\n 0 - OK\n Current value of was retrieved\n \"\"\"\n return function\n \n @legacy_function\n def new_zams_model():\n function = LegacyFunctionSpecification() \n function.addParameter('status', dtype='int32', direction=function.OUT)\n return function\n \n @legacy_function \n def new_pre_ms_particle():\n \"\"\"\n Define a new pre-main-sequence star in the code. The star will start with the given mass.\n \"\"\"\n function = LegacyFunctionSpecification() \n function.can_handle_array = True\n function.addParameter('index_of_the_star', dtype='int32', direction=function.OUT\n , description=\"The new index for the star. This index can be used to refer to this star in other functions\")\n function.addParameter('mass', dtype='float64', direction=function.IN\n , description=\"The initial mass of the star\")\n function.result_type = 'int32'\n return function\n \n @legacy_function\n def set_time_step():\n function = LegacyFunctionSpecification() \n function.can_handle_array = True\n function.addParameter('index_of_the_star', dtype='int32', direction=function.IN\n , description=\"The index of the star to get the value of\")\n function.addParameter('time_step', dtype='float64', direction=function.IN\n , description=\"The next timestep for the star.\")\n function.result_type = 'int32'\n function.result_doc = \"\"\"\n 0 - OK\n The value has been set.\n -1 - ERROR\n A star with the given index was not found.\n \"\"\"\n return function\n \n \n @legacy_function \n def get_core_mass():\n \"\"\"\n Retrieve the current core mass of the star, where hydrogen abundance is <= h1_boundary_limit\n \"\"\"\n function = LegacyFunctionSpecification() \n function.can_handle_array = True \n function.addParameter('index_of_the_star', dtype='int32', direction=function.IN\n , description=\"The index of the star to get the value of\")\n function.addParameter('core_mass', dtype='float64', direction=function.OUT\n , description=\"The current core mass of the star, where hydrogen abundance is <= h1_boundary_limit\")\n function.result_type = 'int32'\n return function\n \n @legacy_function \n def get_mass_loss_rate():\n \"\"\"\n Retrieve the current mass loss rate of the star. (positive for winds, negative for accretion)\n \"\"\"\n function = LegacyFunctionSpecification() \n function.can_handle_array = True \n function.addParameter('index_of_the_star', dtype='int32', direction=function.IN\n , description=\"The index of the star to get the value of\")\n function.addParameter('mass_loss_rate', dtype='float64', direction=function.OUT\n , description=\"The current mass loss rate of the star. (positive for winds, negative for accretion)\")\n function.result_type = 'int32'\n return function\n \n @legacy_function \n def get_manual_mass_transfer_rate():\n \"\"\"\n Retrieve the current user-specified mass transfer rate of the star. (negative for winds, positive for accretion)\n \"\"\"\n function = LegacyFunctionSpecification() \n function.can_handle_array = True \n function.addParameter('index_of_the_star', dtype='int32', direction=function.IN\n , description=\"The index of the star to get the value of\")\n function.addParameter('mass_change', dtype='float64', direction=function.OUT\n , description=\"The current user-specified mass transfer rate of the star. (negative for winds, positive for accretion)\")\n function.result_type = 'int32'\n return function\n \n @legacy_function \n def set_manual_mass_transfer_rate():\n \"\"\"\n Set a new user-specified mass transfer rate of the star. (negative for winds, positive for accretion)\n \"\"\"\n function = LegacyFunctionSpecification() \n function.can_handle_array = True \n function.addParameter('index_of_the_star', dtype='int32', direction=function.IN\n , description=\"The index of the star to get the value of\")\n function.addParameter('mass_change', dtype='float64', direction=function.IN\n , description=\"The new user-specified mass transfer rate of the star. (negative for winds, positive for accretion)\")\n function.result_type = 'int32'\n return function\n \n @legacy_function\n def get_accrete_same_as_surface():\n function = LegacyFunctionSpecification()\n function.can_handle_array = True\n function.addParameter('index_of_the_star', dtype='int32', direction=function.IN)\n function.addParameter('accrete_same_as_surface_flag', dtype='int32', direction=function.OUT)\n function.result_type = 'int32'\n return function\n @legacy_function\n def set_accrete_same_as_surface():\n function = LegacyFunctionSpecification()\n function.can_handle_array = True\n function.addParameter('index_of_the_star', dtype='int32', direction=function.IN)\n function.addParameter('accrete_same_as_surface_flag', dtype='int32', direction=function.IN)\n function.result_type = 'int32'\n return function\n @legacy_function\n def get_accrete_composition_non_metals():\n function = LegacyFunctionSpecification()\n function.can_handle_array = True\n function.addParameter('index_of_the_star', dtype='int32', direction=function.IN)\n function.addParameter('h1', dtype='float64', direction=function.OUT)\n function.addParameter('h2', dtype='float64', direction=function.OUT)\n function.addParameter('he3', dtype='float64', direction=function.OUT)\n function.addParameter('he4', dtype='float64', direction=function.OUT)\n function.result_type = 'int32'\n return function\n @legacy_function\n def set_accrete_composition_non_metals():\n function = LegacyFunctionSpecification()\n function.can_handle_array = True\n function.addParameter('index_of_the_star', dtype='int32', direction=function.IN)\n function.addParameter('h1', dtype='float64', direction=function.IN)\n function.addParameter('h2', dtype='float64', direction=function.IN)\n function.addParameter('he3', dtype='float64', direction=function.IN)\n function.addParameter('he4', dtype='float64', direction=function.IN)\n function.result_type = 'int32'\n return function\n @legacy_function\n def get_accrete_composition_metals_identifier():\n function = LegacyFunctionSpecification()\n function.can_handle_array = True\n function.addParameter('index_of_the_star', dtype='int32', direction=function.IN)\n function.addParameter('accrete_composition_metals_identifier', dtype='int32', direction=function.OUT)\n function.result_type = 'int32'\n return function\n @legacy_function\n def set_accrete_composition_metals_identifier():\n function = LegacyFunctionSpecification()\n function.can_handle_array = True\n function.addParameter('index_of_the_star', dtype='int32', direction=function.IN)\n function.addParameter('accrete_composition_metals_identifier', dtype='int32', direction=function.IN)\n function.result_type = 'int32'\n return function\n @legacy_function\n def get_accrete_composition_metals():\n function = LegacyFunctionSpecification()\n function.can_handle_array = True\n function.addParameter('index_of_the_star', dtype='int32', direction=function.IN)\n function.addParameter('li', dtype='float64', direction=function.OUT)\n function.addParameter('be', dtype='float64', direction=function.OUT)\n function.addParameter('b', dtype='float64', direction=function.OUT)\n function.addParameter('c', dtype='float64', direction=function.OUT)\n function.addParameter('n', dtype='float64', direction=function.OUT)\n function.addParameter('o', dtype='float64', direction=function.OUT)\n function.addParameter('f', dtype='float64', direction=function.OUT)\n function.addParameter('ne', dtype='float64', direction=function.OUT)\n function.addParameter('na', dtype='float64', direction=function.OUT)\n function.addParameter('mg', dtype='float64', direction=function.OUT)\n function.addParameter('al', dtype='float64', direction=function.OUT)\n function.addParameter('si', dtype='float64', direction=function.OUT)\n function.addParameter('p', dtype='float64', direction=function.OUT)\n function.addParameter('s', dtype='float64', direction=function.OUT)\n function.addParameter('cl', dtype='float64', direction=function.OUT)\n function.addParameter('ar', dtype='float64', direction=function.OUT)\n function.addParameter('k', dtype='float64', direction=function.OUT)\n function.addParameter('ca', dtype='float64', direction=function.OUT)\n function.addParameter('sc', dtype='float64', direction=function.OUT)\n function.addParameter('ti', dtype='float64', direction=function.OUT)\n function.addParameter('v', dtype='float64', direction=function.OUT)\n function.addParameter('cr', dtype='float64', direction=function.OUT)\n function.addParameter('mn', dtype='float64', direction=function.OUT)\n function.addParameter('fe', dtype='float64', direction=function.OUT)\n function.addParameter('co', dtype='float64', direction=function.OUT)\n function.addParameter('ni', dtype='float64', direction=function.OUT)\n function.addParameter('cu', dtype='float64', direction=function.OUT)\n function.addParameter('zn', dtype='float64', direction=function.OUT)\n function.result_type = 'int32'\n return function\n @legacy_function\n def set_accrete_composition_metals():\n function = LegacyFunctionSpecification()\n function.can_handle_array = True\n function.addParameter('index_of_the_star', dtype='int32', direction=function.IN)\n function.addParameter('li', dtype='float64', direction=function.IN)\n function.addParameter('be', dtype='float64', direction=function.IN)\n function.addParameter('b', dtype='float64', direction=function.IN)\n function.addParameter('c', dtype='float64', direction=function.IN)\n function.addParameter('n', dtype='float64', direction=function.IN)\n function.addParameter('o', dtype='float64', direction=function.IN)\n function.addParameter('f', dtype='float64', direction=function.IN)\n function.addParameter('ne', dtype='float64', direction=function.IN)\n function.addParameter('na', dtype='float64', direction=function.IN)\n function.addParameter('mg', dtype='float64', direction=function.IN)\n function.addParameter('al', dtype='float64', direction=function.IN)\n function.addParameter('si', dtype='float64', direction=function.IN)\n function.addParameter('p', dtype='float64', direction=function.IN)\n function.addParameter('s', dtype='float64', direction=function.IN)\n function.addParameter('cl', dtype='float64', direction=function.IN)\n function.addParameter('ar', dtype='float64', direction=function.IN)\n function.addParameter('k', dtype='float64', direction=function.IN)\n function.addParameter('ca', dtype='float64', direction=function.IN)\n function.addParameter('sc', dtype='float64', direction=function.IN)\n function.addParameter('ti', dtype='float64', direction=function.IN)\n function.addParameter('v', dtype='float64', direction=function.IN)\n function.addParameter('cr', dtype='float64', direction=function.IN)\n function.addParameter('mn', dtype='float64', direction=function.IN)\n function.addParameter('fe', dtype='float64', direction=function.IN)\n function.addParameter('co', dtype='float64', direction=function.IN)\n function.addParameter('ni', dtype='float64', direction=function.IN)\n function.addParameter('cu', dtype='float64', direction=function.IN)\n function.addParameter('zn', dtype='float64', direction=function.IN)\n function.result_type = 'int32'\n return function\n \n @legacy_function\n def get_number_of_backups_in_a_row():\n \"\"\"\n Retrieve the number_of_backups_in_a_row of the star.\n \"\"\"\n function = LegacyFunctionSpecification() \n function.can_handle_array = True \n function.addParameter('index_of_the_star', dtype='int32', direction=function.IN\n , description=\"The index of the star to get the value of number_of_backups_in_a_row\")\n function.addParameter('n_backup', dtype='int32', direction=function.OUT\n , description=\"The current number_of_backups_in_a_row of the star.\")\n function.result_type = 'int32'\n function.result_doc = \"\"\"\n 0 - OK\n The number_of_backups_in_a_row was retrieved.\n -1 - ERROR\n A star with the given index was not found.\n \"\"\"\n return function\n \n @legacy_function\n def reset_number_of_backups_in_a_row():\n \"\"\"\n Reset number_of_backups_in_a_row of the star.\n \"\"\"\n function = LegacyFunctionSpecification() \n function.can_handle_array = True \n function.addParameter('index_of_the_star', dtype='int32', direction=function.IN\n , description=\"The index of the star to reset the value of number_of_backups_in_a_row\")\n function.result_type = 'int32'\n function.result_doc = \"\"\"\n 0 - OK\n The number_of_backups_in_a_row was reset.\n -1 - ERROR\n A star with the given index was not found.\n \"\"\"\n return function\n \n @legacy_function\n def get_mass_fraction_at_zone():\n \"\"\"\n Retrieve the mass fraction at the specified zone/mesh-cell of the star.\n \"\"\"\n function = LegacyFunctionSpecification() \n function.can_handle_array = True \n function.addParameter('index_of_the_star', dtype='int32', direction=function.IN\n , description=\"The index of the star to get the value of\")\n function.addParameter('zone', dtype='int32', direction=function.IN\n , description=\"The zone/mesh-cell of the star to get the value of\")\n function.addParameter('dq_i', dtype='float64', direction=function.OUT\n , description=\"The mass fraction at the specified zone/mesh-cell of the star.\")\n function.result_type = 'int32'\n function.result_doc = \"\"\"\n 0 - OK\n The value was retrieved.\n -1 - ERROR\n A star with the given index was not found.\n -2 - ERROR\n A zone with the given index was not found.\n \"\"\"\n return function\n \n @legacy_function\n def set_mass_fraction_at_zone():\n \"\"\"\n Set the mass fraction at the specified zone/mesh-cell of the star.\n \"\"\"\n function = LegacyFunctionSpecification() \n function.can_handle_array = True \n function.addParameter('index_of_the_star', dtype='int32', direction=function.IN\n , description=\"The index of the star to set the value of\")\n function.addParameter('zone', dtype='int32', direction=function.IN\n , description=\"The zone/mesh-cell of the star to set the value of\")\n function.addParameter('dq_i', dtype='float64', direction=function.IN\n , description=\"The mass fraction at the specified zone/mesh-cell of the star.\")\n function.result_type = 'int32'\n function.result_doc = \"\"\"\n 0 - OK\n The value was set.\n -1 - ERROR\n A star with the given index was not found.\n -2 - ERROR\n A zone with the given index was not found.\n \"\"\"\n return function\n \n @legacy_function\n def get_luminosity_at_zone():\n \"\"\"\n Retrieve the luminosity at the specified zone/mesh-cell of the star.\n \"\"\"\n function = LegacyFunctionSpecification() \n function.can_handle_array = True \n function.addParameter('index_of_the_star', dtype='int32', direction=function.IN\n , description=\"The index of the star to get the value of\")\n function.addParameter('zone', dtype='int32', direction=function.IN\n , description=\"The zone/mesh-cell of the star to get the value of\")\n function.addParameter('lum_i', dtype='float64', direction=function.OUT\n , description=\"The luminosity at the specified zone/mesh-cell of the star.\")\n function.result_type = 'int32'\n function.result_doc = \"\"\"\n 0 - OK\n The value was retrieved.\n -1 - ERROR\n A star with the given index was not found.\n -2 - ERROR\n A zone with the given index was not found.\n \"\"\"\n return function\n \n @legacy_function\n def set_luminosity_at_zone():\n \"\"\"\n Set the luminosity at the specified zone/mesh-cell of the star.\n \"\"\"\n function = LegacyFunctionSpecification() \n function.can_handle_array = True \n function.addParameter('index_of_the_star', dtype='int32', direction=function.IN\n , description=\"The index of the star to set the value of\")\n function.addParameter('zone', dtype='int32', direction=function.IN\n , description=\"The zone/mesh-cell of the star to set the value of\")\n function.addParameter('lum_i', dtype='float64', direction=function.IN\n , description=\"The luminosity at the specified zone/mesh-cell of the star.\")\n function.result_type = 'int32'\n function.result_doc = \"\"\"\n 0 - OK\n The value was set.\n -1 - ERROR\n A star with the given index was not found.\n -2 - ERROR\n A zone with the given index was not found.\n \"\"\"\n return function\n \n @legacy_function\n def get_entropy_at_zone():\n \"\"\"\n Retrieve the entropy at the specified zone/mesh-cell of the star.\n \"\"\"\n function = LegacyFunctionSpecification() \n function.can_handle_array = True \n function.addParameter('index_of_the_star', dtype='int32', direction=function.IN\n , description=\"The index of the star to get the value of\")\n function.addParameter('zone', dtype='int32', direction=function.IN\n , description=\"The zone/mesh-cell of the star to get the value of\")\n function.addParameter('S_i', dtype='float64', direction=function.OUT\n , description=\"The specific entropy at the specified zone/mesh-cell of the star.\")\n function.result_type = 'int32'\n function.result_doc = \"\"\"\n 0 - OK\n The value was retrieved.\n -1 - ERROR\n A star with the given index was not found.\n -2 - ERROR\n A zone with the given index was not found.\n \"\"\"\n return function \n\n @legacy_function\n def get_thermal_energy_at_zone():\n \"\"\"\n Retrieve the entropy at the specified zone/mesh-cell of the star.\n \"\"\"\n function = LegacyFunctionSpecification() \n function.can_handle_array = True \n function.addParameter('index_of_the_star', dtype='int32', direction=function.IN\n , description=\"The index of the star to get the value of\")\n function.addParameter('zone', dtype='int32', direction=function.IN\n , description=\"The zone/mesh-cell of the star to get the value of\")\n function.addParameter('E_i', dtype='float64', direction=function.OUT\n , description=\"The specific thermal energy at the specified zone/mesh-cell of the star.\")\n function.result_type = 'int32'\n function.result_doc = \"\"\"\n 0 - OK\n The value was retrieved.\n -1 - ERROR\n A star with the given index was not found.\n -2 - ERROR\n A zone with the given index was not found.\n \"\"\"\n return function \n \n @legacy_function\n def get_brunt_vaisala_frequency_squared_at_zone():\n \"\"\"\n Retrieve the Brunt-Vaisala frequency squared at the specified zone/mesh-cell of the star.\n \"\"\"\n function = LegacyFunctionSpecification() \n function.can_handle_array = True \n function.addParameter('index_of_the_star', dtype='int32', direction=function.IN, unit=INDEX)\n function.addParameter('zone', dtype='int32', direction=function.IN, unit=NO_UNIT)\n function.addParameter('brunt_N2', dtype='float64', direction=function.OUT, unit=units.s**-2)\n function.result_type = 'int32'\n return function\n \n @legacy_function\n def get_id_of_species():\n \"\"\"\n Retrieve the chem_ID of the chemical abundance variable of the star.\n \"\"\"\n function = LegacyFunctionSpecification() \n function.can_handle_array = True \n function.addParameter('index_of_the_star', dtype='int32', direction=function.IN\n , description=\"The index of the star to get the value of\")\n function.addParameter('species', dtype='int32', direction=function.IN\n , description=\"The species of the star to get the name of\")\n function.addParameter('species_id', dtype='int32', direction=function.OUT\n , description=\"The chem_ID of the chemical abundance variable of the star.\")\n function.result_type = 'int32'\n function.result_doc = \"\"\"\n 0 - OK\n The value was retrieved.\n -1 - ERROR\n A star with the given index was not found.\n \"\"\"\n return function\n \n @legacy_function\n def get_mass_of_species():\n \"\"\"\n Retrieve the mass number of the chemical abundance variable of the star.\n \"\"\"\n function = LegacyFunctionSpecification() \n function.can_handle_array = True \n function.addParameter('index_of_the_star', dtype='int32', direction=function.IN\n , description=\"The index of the star to get the value of\")\n function.addParameter('species', dtype='int32', direction=function.IN\n , description=\"The species of the star to get the mass number of\")\n function.addParameter('species_mass', dtype='float64', direction=function.OUT\n , description=\"The mass number of the chemical abundance variable of the star.\")\n function.result_type = 'int32'\n function.result_doc = \"\"\"\n 0 - OK\n The value was retrieved.\n -1 - ERROR\n A star with the given index was not found.\n \"\"\"\n return function\n \n @legacy_function\n def erase_memory():\n \"\"\"\n Erase memory of the star, i.e. copy the current structure over the memory of \n the structure of the previous steps. Useful after setting the stucture of \n the star, to prevent backup steps to undo changes\n \"\"\"\n function = LegacyFunctionSpecification() \n function.can_handle_array = True\n function.addParameter('index_of_the_star', dtype='int32', direction=function.IN\n , description=\"The index of the star to get the value of\")\n function.result_type = 'int32'\n return function\n \n @legacy_function\n def get_max_age_stop_condition():\n \"\"\"\n Retrieve the current maximum age stop condition of this instance (in years).\n Evolution will stop once the star has reached this maximum age.\n \"\"\"\n function = LegacyFunctionSpecification() \n function.addParameter('max_age_stop_condition', dtype='float64', direction=function.OUT\n , description=\"The current maximum age stop condition of this instance (in years).\")\n function.result_type = 'int32'\n function.result_doc = \"\"\"\n 0 - OK\n Current value was retrieved\n -1 - ERROR\n The code could not retrieve the value.\n \"\"\"\n return function\n \n @legacy_function\n def set_max_age_stop_condition():\n \"\"\"\n Set the new maximum age stop condition of this instance (in years).\n Evolution will stop once the star has reached this maximum age.\n \"\"\"\n function = LegacyFunctionSpecification() \n function.addParameter('max_age_stop_condition', dtype='float64', direction=function.IN\n , description=\"The new maximum age stop condition of this instance (in years).\")\n function.result_type = 'int32'\n function.result_doc = \"\"\"\n 0 - OK\n The value has been set.\n -1 - ERROR\n The code could not set the value.\n \"\"\"\n return function\n \n @legacy_function\n def get_min_timestep_stop_condition():\n \"\"\"\n Retrieve the current minimum timestep stop condition of this instance (in years).\n Evolution will stop if the timestep required by the solver in order to converge\n has decreased below this minimum timestep.\n \"\"\"\n function = LegacyFunctionSpecification() \n function.addParameter('min_timestep_stop_condition', dtype='float64', direction=function.OUT\n , description=\"The current minimum timestep stop condition of this instance (in years).\")\n function.result_type = 'int32'\n function.result_doc = \"\"\"\n 0 - OK\n Current value was retrieved\n -1 - ERROR\n The code could not retrieve the value.\n \"\"\"\n return function\n \n @legacy_function\n def set_min_timestep_stop_condition():\n \"\"\"\n Set the new minimum timestep stop condition of this instance (in years).\n Evolution will stop if the timestep required by the solver in order to converge\n has decreased below this minimum timestep.\n \"\"\"\n function = LegacyFunctionSpecification() \n function.addParameter('min_timestep_stop_condition', dtype='float64', direction=function.IN\n , description=\"The new minimum timestep stop condition of this instance (in years).\")\n function.result_type = 'int32'\n function.result_doc = \"\"\"\n 0 - OK\n The value has been set.\n -1 - ERROR\n The code could not set the value.\n \"\"\"\n return function\n \n @legacy_function\n def get_max_iter_stop_condition():\n \"\"\"\n Retrieve the current maximum number of iterations of this instance. (Negative means no maximum)\n Evolution will stop after this number of iterations.\n \"\"\"\n function = LegacyFunctionSpecification() \n function.addParameter('max_iter_stop_condition', dtype='int32', direction=function.OUT\n , description=\"The current maximum number of iterations of this instance.\")\n function.result_type = 'int32'\n function.result_doc = \"\"\"\n 0 - OK\n Current value was retrieved\n -1 - ERROR\n The code could not retrieve the value.\n \"\"\"\n return function\n \n @legacy_function\n def set_max_iter_stop_condition():\n \"\"\"\n Set the new maximum number of iterations of this instance. (Negative means no maximum)\n Evolution will stop after this number of iterations.\n \"\"\"\n function = LegacyFunctionSpecification() \n function.addParameter('max_iter_stop_condition', dtype='int32', direction=function.IN\n , description=\"The new maximum number of iterations of this instance.\")\n function.result_type = 'int32'\n function.result_doc = \"\"\"\n 0 - OK\n The value has been set.\n -1 - ERROR\n The code could not set the value.\n \"\"\"\n return function\n \n @legacy_function\n def get_convective_overshoot_parameter():\n function = LegacyFunctionSpecification() \n function.addParameter('convective_overshoot_parameter', dtype='float64', direction=function.OUT,\n description=\"The current value of the convective overshoot parameter.\")\n function.result_type = 'int32'\n return function\n \n @legacy_function\n def set_convective_overshoot_parameter():\n function = LegacyFunctionSpecification() \n function.addParameter('convective_overshoot_parameter', dtype='float64', direction=function.IN,\n description=\"The new value of the convective overshoot parameter.\")\n function.result_type = 'int32'\n return function\n \n @legacy_function\n def get_mixing_length_ratio():\n \"\"\"\n Retrieve the current value of the mixing length ratio.\n \"\"\"\n function = LegacyFunctionSpecification() \n function.addParameter('mixing_length_ratio', dtype='float64', direction=function.OUT\n , description=\"The current value of the mixing length ratio.\")\n function.result_type = 'int32'\n function.result_doc = \"\"\"\n 0 - OK\n Current value was retrieved\n -1 - ERROR\n The code could not retrieve the value.\n \"\"\"\n return function\n \n @legacy_function\n def set_mixing_length_ratio():\n \"\"\"\n Set the value of the mixing length ratio.\n \"\"\"\n function = LegacyFunctionSpecification() \n function.addParameter('mixing_length_ratio', dtype='float64', direction=function.IN\n , description=\"The new value of the mixing length ratio.\")\n function.result_type = 'int32'\n function.result_doc = \"\"\"\n 0 - OK\n The value has been set.\n -1 - ERROR\n The code could not set the value.\n \"\"\"\n return function\n \n @legacy_function\n def get_semi_convection_efficiency():\n \"\"\"\n Retrieve the current value of the efficiency of semi-convection,\n after Heger, Langer, & Woosley 2000 (ApJ), which goes back to \n Langer, Sugimoto & Fricke 1983 (A&A).\n \"\"\"\n function = LegacyFunctionSpecification() \n function.addParameter('semi_convection_efficiency', dtype='float64', direction=function.OUT\n , description=\"The current value of the efficiency of semi-convection.\")\n function.result_type = 'int32'\n function.result_doc = \"\"\"\n 0 - OK\n Current value was retrieved\n -1 - ERROR\n The code could not retrieve the value.\n \"\"\"\n return function\n \n @legacy_function\n def set_semi_convection_efficiency():\n \"\"\"\n Set the value of the efficiency of semi-convection,\n after Heger, Langer, & Woosley 2000 (ApJ), which goes back to \n Langer, Sugimoto & Fricke 1983 (A&A).\n \"\"\"\n function = LegacyFunctionSpecification() \n function.addParameter('semi_convection_efficiency', dtype='float64', direction=function.IN\n , description=\"The new value of the efficiency of semi-convection.\")\n function.result_type = 'int32'\n function.result_doc = \"\"\"\n 0 - OK\n The value has been set.\n -1 - ERROR\n The code could not set the value.\n \"\"\"\n return function\n \n @legacy_function\n def get_RGB_wind_scheme():\n \"\"\"\n Retrieve the current wind (mass loss) scheme for RGB stars:\n No automatic wind (0)\n Reimers (1): e.g. see: Baschek, Kegel, Traving (eds), Springer, Berlin, 1975, p. 229.\n Blocker (2): T. Blocker, A&A 297, 727-738 (1995)\n de Jager (3): de Jager, C., Nieuwenhuijzen, H., & van der Hucht, K. A. 1988, A&AS, 72, 259\n Dutch (4): Glebbeek et al 2009, Vink et al 2001, Nugis & Lamers 2000, de Jager 1990\n Mattsson (5)\n \"\"\"\n function = LegacyFunctionSpecification() \n function.addParameter('RGB_wind_scheme', dtype='int32', direction=function.OUT\n , description=\"The current wind (mass loss) scheme for RGB stars of this instance.\")\n function.result_type = 'int32'\n function.result_doc = \"\"\"\n 0 - OK\n Current value was retrieved\n -1 - ERROR\n The code could not retrieve the value.\n \"\"\"\n return function\n \n @legacy_function\n def set_RGB_wind_scheme():\n \"\"\"\n Set the new wind (mass loss) scheme for RGB stars:\n No automatic wind (0)\n Reimers (1): e.g. see: Baschek, Kegel, Traving (eds), Springer, Berlin, 1975, p. 229.\n Blocker (2): T. Blocker, A&A 297, 727-738 (1995)\n de Jager (3): de Jager, C., Nieuwenhuijzen, H., & van der Hucht, K. A. 1988, A&AS, 72, 259\n Dutch (4): Glebbeek et al 2009, Vink et al 2001, Nugis & Lamers 2000, de Jager 1990\n Mattsson (5)\n \"\"\"\n function = LegacyFunctionSpecification() \n function.addParameter('RGB_wind_scheme', dtype='int32', direction=function.IN\n , description=\"The new wind (mass loss) scheme for RGB stars of this instance.\")\n function.result_type = 'int32'\n function.result_doc = \"\"\"\n 0 - OK\n The value has been set.\n -1 - ERROR\n The code could not set the value.\n \"\"\"\n return function\n \n @legacy_function\n def get_AGB_wind_scheme():\n \"\"\"\n Retrieve the current wind (mass loss) scheme for AGB stars:\n No automatic wind (0)\n Reimers (1): e.g. see: Baschek, Kegel, Traving (eds), Springer, Berlin, 1975, p. 229.\n Blocker (2): T. Blocker, A&A 297, 727-738 (1995)\n de Jager (3): de Jager, C., Nieuwenhuijzen, H., & van der Hucht, K. A. 1988, A&AS, 72, 259\n Dutch (4): Glebbeek et al 2009, Vink et al 2001, Nugis & Lamers 2000, de Jager 1990\n Mattsson (5)\n \"\"\"\n function = LegacyFunctionSpecification() \n function.addParameter('AGB_wind_scheme', dtype='int32', direction=function.OUT\n , description=\"The current wind (mass loss) scheme for AGB stars of this instance.\")\n function.result_type = 'int32'\n function.result_doc = \"\"\"\n 0 - OK\n Current value was retrieved\n -1 - ERROR\n The code could not retrieve the value.\n \"\"\"\n return function\n \n @legacy_function\n def set_AGB_wind_scheme():\n \"\"\"\n Set the new wind (mass loss) scheme for AGB stars:\n No automatic wind (0)\n Reimers (1): e.g. see: Baschek, Kegel, Traving (eds), Springer, Berlin, 1975, p. 229.\n Blocker (2): T. Blocker, A&A 297, 727-738 (1995)\n de Jager (3): de Jager, C., Nieuwenhuijzen, H., & van der Hucht, K. A. 1988, A&AS, 72, 259\n Dutch (4): Glebbeek et al 2009, Vink et al 2001, Nugis & Lamers 2000, de Jager 1990\n Mattsson (5)\n \"\"\"\n function = LegacyFunctionSpecification() \n function.addParameter('AGB_wind_scheme', dtype='int32', direction=function.IN\n , description=\"The new wind (mass loss) scheme for AGB stars of this instance.\")\n function.result_type = 'int32'\n function.result_doc = \"\"\"\n 0 - OK\n The value has been set.\n -1 - ERROR\n The code could not set the value.\n \"\"\"\n return function\n \n @legacy_function\n def get_reimers_wind_efficiency():\n function = LegacyFunctionSpecification() \n function.addParameter('reimers_wind_efficiency', dtype='float64', direction=function.OUT)\n function.result_type = 'int32'\n return function\n \n @legacy_function\n def set_reimers_wind_efficiency():\n function = LegacyFunctionSpecification() \n function.addParameter('reimers_wind_efficiency', dtype='float64', direction=function.IN)\n function.result_type = 'int32'\n return function\n \n @legacy_function\n def get_blocker_wind_efficiency():\n function = LegacyFunctionSpecification() \n function.addParameter('blocker_wind_efficiency', dtype='float64', direction=function.OUT)\n function.result_type = 'int32'\n return function\n \n @legacy_function\n def set_blocker_wind_efficiency():\n function = LegacyFunctionSpecification() \n function.addParameter('blocker_wind_efficiency', dtype='float64', direction=function.IN)\n function.result_type = 'int32'\n return function\n \n @legacy_function\n def get_de_jager_wind_efficiency():\n function = LegacyFunctionSpecification() \n function.addParameter('de_jager_wind_efficiency', dtype='float64', direction=function.OUT)\n function.result_type = 'int32'\n return function\n \n @legacy_function\n def set_de_jager_wind_efficiency():\n function = LegacyFunctionSpecification() \n function.addParameter('de_jager_wind_efficiency', dtype='float64', direction=function.IN)\n function.result_type = 'int32'\n return function\n \n @legacy_function\n def get_dutch_wind_efficiency():\n function = LegacyFunctionSpecification() \n function.addParameter('dutch_wind_efficiency', dtype='float64', direction=function.OUT)\n function.result_type = 'int32'\n return function\n \n @legacy_function\n def set_dutch_wind_efficiency():\n function = LegacyFunctionSpecification() \n function.addParameter('dutch_wind_efficiency', dtype='float64', direction=function.IN)\n function.result_type = 'int32'\n return function\n \n @legacy_function\n def get_stabilize_new_stellar_model_flag():\n function = LegacyFunctionSpecification() \n function.addParameter('stabilize_new_stellar_model_flag', dtype='int32', direction=function.OUT)\n function.result_type = 'int32'\n return function\n \n @legacy_function\n def set_stabilize_new_stellar_model_flag():\n function = LegacyFunctionSpecification() \n function.addParameter('stabilize_new_stellar_model_flag', dtype='int32', direction=function.IN)\n function.result_type = 'int32'\n return function\n \n @legacy_function \n def new_stellar_model():\n \"\"\"\n Define a new star model in the code. The star needs to be finalized \n before it can evolve, see 'finalize_stellar_model'.\n \"\"\"\n function = LegacyFunctionSpecification() \n function.must_handle_array = True\n for par in ['d_mass', 'radius', 'rho', 'temperature', 'luminosity', \n 'X_H', 'X_He', 'X_C', 'X_N', 'X_O', 'X_Ne', 'X_Mg', 'X_Si', 'X_Fe']:\n function.addParameter(par, dtype='float64', direction=function.IN)\n function.addParameter('n', 'int32', function.LENGTH)\n function.result_type = 'int32'\n return function\n \n @legacy_function \n def finalize_stellar_model():\n \"\"\"\n Finalize the new star model defined by 'new_stellar_model'.\n \"\"\"\n function = LegacyFunctionSpecification() \n function.addParameter('index_of_the_star', dtype='int32', \n direction=function.OUT, description = \"The new index for the star. \"\n \"This index can be used to refer to this star in other functions\")\n function.addParameter('age_tag', dtype='float64', direction=function.IN, \n description = \"The initial age of the star\")\n function.result_type = 'int32'\n return function\n\nclass MESA(StellarEvolution, InternalStellarStructure):\n \n def __init__(self, **options):\n InCodeComponentImplementation.__init__(self, MESAInterface(**options), **options)\n \n output_dir = self.get_output_directory()\n if not self.channel_type == 'distributed':\n self.ensure_data_directory_exists(os.path.join(output_dir, 'star_data', 'starting_models'))\n \n self.set_MESA_paths(\n self.default_path_to_inlist, \n self.default_path_to_MESA_data, \n output_dir\n )\n self.model_time = 0.0 | units.yr\n \n \n def define_parameters(self, handler):\n \n handler.add_method_parameter(\n \"get_metallicity\",\n \"set_metallicity\",\n \"metallicity\", \n \"Metallicity of all stars\", \n default_value = 0.02\n )\n \n handler.add_method_parameter(\n \"get_max_age_stop_condition\",\n \"set_max_age_stop_condition\",\n \"max_age_stop_condition\", \n \"The maximum age stop condition of this instance.\",\n default_value = 1.0e36 | units.yr\n )\n \n handler.add_method_parameter(\n \"get_min_timestep_stop_condition\",\n \"set_min_timestep_stop_condition\",\n \"min_timestep_stop_condition\", \n \"The minimum timestep stop condition of this instance.\",\n default_value = 1.0e-6 | units.s\n )\n \n handler.add_method_parameter(\n \"get_max_iter_stop_condition\",\n \"set_max_iter_stop_condition\",\n \"max_iter_stop_condition\", \n \"The maximum number of iterations of this instance. (Negative means no maximum)\",\n default_value = -1111\n )\n \n handler.add_method_parameter(\n \"get_convective_overshoot_parameter\",\n \"set_convective_overshoot_parameter\",\n \"herwig_convective_overshoot_parameter\", \n \"The convective overshoot parameter (Herwig 2000), f=0.016 is argued to be a reasonable value.\",\n default_value = 0.0\n )\n \n handler.add_method_parameter(\n \"get_mixing_length_ratio\",\n \"set_mixing_length_ratio\",\n \"mixing_length_ratio\", \n \"The mixing-length ratio (alpha).\",\n default_value = 2.0\n )\n \n handler.add_method_parameter(\n \"get_semi_convection_efficiency\",\n \"set_semi_convection_efficiency\",\n \"semi_convection_efficiency\", \n \"The efficiency of semi-convection, after Heger, Langer, & Woosley 2000 (ApJ), \"\n \"which goes back to Langer, Sugimoto & Fricke 1983 (A&A).\",\n default_value = 0.0\n )\n \n handler.add_method_parameter(\n \"get_RGB_wind_scheme\",\n \"set_RGB_wind_scheme\",\n \"RGB_wind_scheme\", \n \"The mass loss scheme for RGB stars: none (0), Reimers (1), \"\n \"Blocker (2), de Jager (3), Dutch (4), Mattsson (5)\",\n default_value = 1\n )\n \n handler.add_method_parameter(\n \"get_AGB_wind_scheme\",\n \"set_AGB_wind_scheme\",\n \"AGB_wind_scheme\", \n \"The mass loss scheme for AGB stars: none (0), Reimers (1), \"\n \"Blocker (2), de Jager (3), Dutch (4), Mattsson (5)\",\n default_value = 1\n )\n \n handler.add_method_parameter(\n \"get_reimers_wind_efficiency\",\n \"set_reimers_wind_efficiency\",\n \"reimers_wind_efficiency\", \n \"The Reimers mass loss efficiency. Only used if (RGB/AGB_wind_scheme == 1).\",\n default_value = 0.5\n )\n handler.add_method_parameter(\n \"get_blocker_wind_efficiency\",\n \"set_blocker_wind_efficiency\",\n \"blocker_wind_efficiency\", \n \"The Blocker mass loss efficiency. Only used if (RGB/AGB_wind_scheme == 2).\",\n default_value = 0.1\n )\n handler.add_method_parameter(\n \"get_de_jager_wind_efficiency\",\n \"set_de_jager_wind_efficiency\",\n \"de_jager_wind_efficiency\", \n \"The de Jager mass loss efficiency. Only used if (RGB/AGB_wind_scheme == 3).\",\n default_value = 0.8\n )\n handler.add_method_parameter(\n \"get_dutch_wind_efficiency\",\n \"set_dutch_wind_efficiency\",\n \"dutch_wind_efficiency\", \n \"The Dutch mass loss efficiency. Only used if (RGB/AGB_wind_scheme == 4).\",\n default_value = 0.8\n )\n handler.add_boolean_parameter(\n \"get_stabilize_new_stellar_model_flag\",\n \"set_stabilize_new_stellar_model_flag\",\n \"stabilize_new_stellar_model_flag\",\n \"Flag specifying whether to stabilize any loaded stellar models first.\",\n default_value = True\n )\n \n \n \n def define_particle_sets(self, handler):\n handler.define_super_set('particles', ['native_stars', 'imported_stars', 'pre_ms_stars'], \n index_to_default_set = 0)\n \n handler.define_set('imported_stars', 'index_of_the_star')\n handler.set_new('imported_stars', 'finalize_stellar_model')\n handler.set_delete('imported_stars', 'delete_star')\n \n handler.define_set('native_stars', 'index_of_the_star')\n handler.set_new('native_stars', 'new_particle')\n handler.set_delete('native_stars', 'delete_star')\n \n handler.define_set('pre_ms_stars', 'index_of_the_star')\n handler.set_new('pre_ms_stars', 'new_pre_ms_particle')\n handler.set_delete('pre_ms_stars', 'delete_star')\n \n for particle_set_name in ['native_stars', 'imported_stars', 'pre_ms_stars']:\n handler.add_getter(particle_set_name, 'get_radius', names = ('radius',))\n handler.add_getter(particle_set_name, 'get_stellar_type', names = ('stellar_type',))\n handler.add_getter(particle_set_name, 'get_mass', names = ('mass',))\n handler.add_setter(particle_set_name, 'set_mass', names = ('mass',))\n handler.add_getter(particle_set_name, 'get_core_mass', names = ('core_mass',))\n handler.add_getter(particle_set_name, 'get_mass_loss_rate', names = ('wind',))\n handler.add_getter(particle_set_name, 'get_age', names = ('age',))\n handler.add_getter(particle_set_name, 'get_time_step', names = ('time_step',))\n handler.add_setter(particle_set_name, 'set_time_step', names = ('time_step',))\n handler.add_getter(particle_set_name, 'get_luminosity', names = ('luminosity',))\n handler.add_getter(particle_set_name, 'get_temperature', names = ('temperature',))\n \n handler.add_getter(particle_set_name, 'get_manual_mass_transfer_rate', names = ('mass_change',))\n handler.add_setter(particle_set_name, 'set_manual_mass_transfer_rate', names = ('mass_change',))\n \n handler.add_method(particle_set_name, 'get_accrete_same_as_surface')\n handler.add_method(particle_set_name, 'set_accrete_same_as_surface')\n handler.add_method(particle_set_name, 'get_accrete_composition_non_metals')\n handler.add_method(particle_set_name, 'set_accrete_composition_non_metals')\n handler.add_method(particle_set_name, 'get_accrete_composition_metals_identifier')\n handler.add_method(particle_set_name, 'set_accrete_composition_metals_identifier')\n handler.add_method(particle_set_name, 'get_accrete_composition_metals')\n handler.add_method(particle_set_name, 'set_accrete_composition_metals')\n \n handler.add_method(particle_set_name, 'evolve_one_step')\n handler.add_method(particle_set_name, 'evolve_for')\n InternalStellarStructure.define_particle_sets(\n self, \n handler, \n set_name = particle_set_name\n )\n handler.add_method(particle_set_name, 'get_mass_profile')\n handler.add_method(particle_set_name, 'set_mass_profile')\n handler.add_method(particle_set_name, 'get_cumulative_mass_profile')\n handler.add_method(particle_set_name, 'get_luminosity_profile')\n handler.add_method(particle_set_name, 'set_luminosity_profile')\n handler.add_method(particle_set_name, 'get_entropy_profile')\n handler.add_method(particle_set_name, 'get_thermal_energy_profile')\n handler.add_method(particle_set_name, 'get_brunt_vaisala_frequency_squared_profile')\n handler.add_method(particle_set_name, 'get_IDs_of_species')\n handler.add_method(particle_set_name, 'get_masses_of_species')\n handler.add_method(particle_set_name, 'get_number_of_backups_in_a_row')\n handler.add_method(particle_set_name, 'reset_number_of_backups_in_a_row')\n \n def define_state(self, handler):\n StellarEvolution.define_state(self, handler)\n handler.add_method('EDIT', 'new_pre_ms_particle')\n handler.add_method('UPDATE', 'new_pre_ms_particle')\n handler.add_transition('RUN', 'UPDATE', 'new_pre_ms_particle', False)\n handler.add_method('EDIT', 'finalize_stellar_model')\n handler.add_method('UPDATE', 'finalize_stellar_model')\n handler.add_transition('RUN', 'UPDATE', 'finalize_stellar_model', False)\n \n def define_errorcodes(self, handler):\n InternalStellarStructure.define_errorcodes(self, handler)\n handler.add_errorcode(-1, 'Something went wrong...')\n handler.add_errorcode(-4, 'Not implemented.')\n handler.add_errorcode(-11, 'Evolve terminated: Unspecified stop condition reached.')\n handler.add_errorcode(-12, 'Evolve terminated: Maximum age reached.')\n handler.add_errorcode(-13, 'Evolve terminated: Maximum number of iterations reached.')\n handler.add_errorcode(-14, 'Evolve terminated: Maximum number of backups reached.')\n handler.add_errorcode(-15, 'Evolve terminated: Minimum timestep limit reached.')\n \n def define_methods(self, handler):\n InternalStellarStructure.define_methods(self, handler)\n StellarEvolution.define_methods(self, handler)\n handler.add_method(\n \"new_pre_ms_particle\",\n (units.MSun),\n (handler.INDEX, handler.ERROR_CODE)\n )\n handler.add_method(\n \"set_time_step\", \n (handler.INDEX, units.yr), \n (handler.ERROR_CODE,)\n )\n handler.add_method(\n \"get_core_mass\",\n (handler.INDEX,),\n (units.MSun, handler.ERROR_CODE,)\n )\n handler.add_method(\n \"get_mass_loss_rate\",\n (handler.INDEX,),\n (units.g / units.s, handler.ERROR_CODE,)\n )\n handler.add_method(\n \"get_manual_mass_transfer_rate\",\n (handler.INDEX,),\n (units.MSun / units.yr, handler.ERROR_CODE,)\n )\n handler.add_method(\n \"set_manual_mass_transfer_rate\",\n (handler.INDEX, units.MSun / units.yr),\n (handler.ERROR_CODE,)\n )\n handler.add_method(\n \"get_number_of_backups_in_a_row\", \n (handler.INDEX,), \n (handler.NO_UNIT, handler.ERROR_CODE,)\n )\n handler.add_method(\n \"reset_number_of_backups_in_a_row\", \n (handler.INDEX,), \n (handler.ERROR_CODE,)\n )\n handler.add_method(\n \"get_mass_fraction_at_zone\", \n (handler.INDEX,handler.NO_UNIT,), \n (handler.NO_UNIT, handler.ERROR_CODE,)\n )\n handler.add_method(\n \"set_mass_fraction_at_zone\", \n (handler.INDEX, handler.NO_UNIT, handler.NO_UNIT,), \n (handler.ERROR_CODE,)\n )\n handler.add_method(\n \"get_luminosity_at_zone\", \n (handler.INDEX,handler.NO_UNIT,), \n (units.erg/units.s, handler.ERROR_CODE,)\n )\n handler.add_method(\n \"set_luminosity_at_zone\", \n (handler.INDEX, handler.NO_UNIT, units.erg/units.s,), \n (handler.ERROR_CODE,)\n )\n handler.add_method(\n \"get_entropy_at_zone\", \n (handler.INDEX,handler.NO_UNIT,), \n (units.erg/units.K, handler.ERROR_CODE,)\n ) \n handler.add_method(\n \"get_thermal_energy_at_zone\", \n (handler.INDEX,handler.NO_UNIT,), \n (units.erg/units.g, handler.ERROR_CODE,)\n ) \n handler.add_method(\n \"get_id_of_species\", \n (handler.INDEX,handler.NO_UNIT,), \n (handler.NO_UNIT, handler.ERROR_CODE,)\n )\n handler.add_method(\n \"get_mass_of_species\", \n (handler.INDEX,handler.NO_UNIT,), \n (units.amu, handler.ERROR_CODE,)\n )\n handler.add_method(\n \"erase_memory\", \n (handler.INDEX,), \n (handler.ERROR_CODE,),\n public_name = \"_erase_memory\"\n )\n handler.add_method(\n \"new_stellar_model\", \n (units.MSun, units.cm, units.g / units.cm**3, units.K, units.erg / units.s, \n handler.NO_UNIT, handler.NO_UNIT, handler.NO_UNIT, handler.NO_UNIT, handler.NO_UNIT, \n handler.NO_UNIT, handler.NO_UNIT, handler.NO_UNIT, handler.NO_UNIT,), \n (handler.ERROR_CODE,)\n )\n handler.add_method(\n \"finalize_stellar_model\", \n (units.yr,), \n (handler.INDEX, handler.ERROR_CODE,)\n )\n \n handler.add_method(\n \"get_max_age_stop_condition\", \n (), \n (units.yr, handler.ERROR_CODE,)\n )\n \n \n handler.add_method(\n \"set_max_age_stop_condition\", \n (units.yr, ), \n (handler.ERROR_CODE,)\n )\n \n \n handler.add_method(\n \"get_min_timestep_stop_condition\", \n (), \n (units.s, handler.ERROR_CODE,)\n )\n \n \n handler.add_method(\n \"set_min_timestep_stop_condition\", \n (units.s, ), \n (handler.ERROR_CODE,)\n )\n \n \n handler.add_method(\n \"get_max_iter_stop_condition\", \n (), \n (handler.NO_UNIT, handler.ERROR_CODE,)\n )\n \n \n handler.add_method(\n \"set_max_iter_stop_condition\", \n (handler.NO_UNIT, ), \n (handler.ERROR_CODE,)\n )\n \n \n handler.add_method(\n \"get_mixing_length_ratio\", \n (), \n (handler.NO_UNIT, handler.ERROR_CODE,)\n )\n \n \n handler.add_method(\n \"set_mixing_length_ratio\", \n (handler.NO_UNIT, ), \n (handler.ERROR_CODE,)\n )\n \n \n handler.add_method(\n \"get_semi_convection_efficiency\", \n (), \n (handler.NO_UNIT, handler.ERROR_CODE,)\n )\n \n \n handler.add_method(\n \"set_semi_convection_efficiency\", \n (handler.NO_UNIT, ), \n (handler.ERROR_CODE,)\n )\n \n \n handler.add_method(\n \"get_RGB_wind_scheme\", \n (), \n (handler.NO_UNIT, handler.ERROR_CODE,)\n )\n \n \n handler.add_method(\n \"set_RGB_wind_scheme\", \n (handler.NO_UNIT, ), \n (handler.ERROR_CODE,)\n )\n \n \n handler.add_method(\n \"get_AGB_wind_scheme\", \n (), \n (handler.NO_UNIT, handler.ERROR_CODE,)\n )\n \n \n handler.add_method(\n \"set_AGB_wind_scheme\", \n (handler.NO_UNIT, ), \n (handler.ERROR_CODE,)\n )\n \n \n handler.add_method(\n \"get_reimers_wind_efficiency\", \n (), \n (handler.NO_UNIT, handler.ERROR_CODE,)\n )\n \n \n handler.add_method(\n \"set_reimers_wind_efficiency\", \n (handler.NO_UNIT, ), \n (handler.ERROR_CODE,)\n )\n \n \n handler.add_method(\n \"get_blocker_wind_efficiency\", \n (), \n (handler.NO_UNIT, handler.ERROR_CODE,)\n )\n \n \n handler.add_method(\n \"set_blocker_wind_efficiency\", \n (handler.NO_UNIT, ), \n (handler.ERROR_CODE,)\n )\n \n \n handler.add_method(\n \"get_de_jager_wind_efficiency\", \n (), \n (handler.NO_UNIT, handler.ERROR_CODE,)\n )\n \n \n handler.add_method(\n \"set_de_jager_wind_efficiency\", \n (handler.NO_UNIT, ), \n (handler.ERROR_CODE,)\n )\n \n \n handler.add_method(\n \"get_dutch_wind_efficiency\", \n (), \n (handler.NO_UNIT, handler.ERROR_CODE,)\n )\n \n \n handler.add_method(\n \"set_dutch_wind_efficiency\", \n (handler.NO_UNIT, ), \n (handler.ERROR_CODE,)\n )\n \n \n def initialize_module_with_default_parameters(self):\n self.parameters.set_defaults()\n self.initialize_code()\n \n def initialize_module_with_current_parameters(self):\n self.initialize_code()\n \n def commit_parameters(self):\n self.parameters.send_not_set_parameters_to_code()\n self.parameters.send_cached_parameters_to_code()\n self.overridden().commit_parameters()\n \n def get_mass_profile(self, indices_of_the_stars, number_of_zones = None):\n indices_of_the_stars = self._check_number_of_indices(indices_of_the_stars, action_string = \"Querying mass profiles\")\n if number_of_zones is None:\n number_of_zones = self.get_number_of_zones(indices_of_the_stars)\n return self.get_mass_fraction_at_zone([indices_of_the_stars]*number_of_zones, list(range(number_of_zones)) | units.none)\n \n def get_cumulative_mass_profile(self, indices_of_the_stars, number_of_zones = None):\n frac_profile = self.get_mass_profile(indices_of_the_stars, number_of_zones = number_of_zones)\n return frac_profile.cumsum()\n \n def set_mass_profile(self, indices_of_the_stars, values, number_of_zones = None):\n indices_of_the_stars = self._check_number_of_indices(indices_of_the_stars, action_string = \"Setting mass profiles\")\n if number_of_zones is None:\n number_of_zones = self.get_number_of_zones(indices_of_the_stars)\n self._check_supplied_values(len(values), number_of_zones)\n self.set_mass_fraction_at_zone([indices_of_the_stars]*number_of_zones, list(range(number_of_zones)) | units.none, values)\n if hasattr(self, \"_erase_memory\"):\n self._erase_memory(indices_of_the_stars)\n \n def get_luminosity_profile(self, indices_of_the_stars, number_of_zones = None):\n indices_of_the_stars = self._check_number_of_indices(indices_of_the_stars, action_string = \"Querying luminosity profiles\")\n if number_of_zones is None:\n number_of_zones = self.get_number_of_zones(indices_of_the_stars)\n return self.get_luminosity_at_zone([indices_of_the_stars]*number_of_zones, list(range(number_of_zones)) | units.none)\n \n def set_luminosity_profile(self, indices_of_the_stars, values, number_of_zones = None):\n indices_of_the_stars = self._check_number_of_indices(indices_of_the_stars, action_string = \"Setting luminosity profiles\")\n if number_of_zones is None:\n number_of_zones = self.get_number_of_zones(indices_of_the_stars)\n self._check_supplied_values(len(values), number_of_zones)\n self.set_luminosity_at_zone([indices_of_the_stars]*number_of_zones, list(range(number_of_zones)) | units.none, values)\n if hasattr(self, \"_erase_memory\"):\n self._erase_memory(indices_of_the_stars)\n\n def get_entropy_profile(self, indices_of_the_stars, number_of_zones = None):\n indices_of_the_stars = self._check_number_of_indices(indices_of_the_stars, action_string = \"Querying entropy profiles\")\n if number_of_zones is None:\n number_of_zones = self.get_number_of_zones(indices_of_the_stars)\n return self.get_entropy_at_zone([indices_of_the_stars]*number_of_zones, list(range(number_of_zones)) | units.none)\n \n def get_thermal_energy_profile(self, indices_of_the_stars, number_of_zones = None):\n indices_of_the_stars = self._check_number_of_indices(indices_of_the_stars, action_string = \"Querying thermal energy profiles\")\n if number_of_zones is None:\n number_of_zones = self.get_number_of_zones(indices_of_the_stars)\n return self.get_thermal_energy_at_zone([indices_of_the_stars]*number_of_zones, list(range(number_of_zones)) | units.none)\n\n def get_brunt_vaisala_frequency_squared_profile(self, indices_of_the_stars, number_of_zones = None):\n indices_of_the_stars = self._check_number_of_indices(indices_of_the_stars, action_string = \"Querying brunt-vaisala-frequency-squared profiles\") \n if number_of_zones is None:\n number_of_zones = self.get_number_of_zones(indices_of_the_stars)\n return self.get_brunt_vaisala_frequency_squared_at_zone([indices_of_the_stars]*number_of_zones, list(range(number_of_zones)) | units.none)\n \n def get_IDs_of_species(self, indices_of_the_stars, number_of_species = None):\n indices_of_the_stars = self._check_number_of_indices(indices_of_the_stars, action_string = \"Querying chemical abundance IDs\")\n if number_of_species is None:\n number_of_species = self.get_number_of_species(indices_of_the_stars)\n return list(self.get_id_of_species(\n [indices_of_the_stars]*number_of_species, \n list(range(1,number_of_species+1)) \n ))\n \n def get_masses_of_species(self, indices_of_the_stars, number_of_species = None):\n indices_of_the_stars = self._check_number_of_indices(indices_of_the_stars, action_string = \"Querying chemical abundance mass numbers\")\n if number_of_species is None:\n number_of_species = self.get_number_of_species(indices_of_the_stars)\n return self.get_mass_of_species(\n [indices_of_the_stars]*number_of_species, \n list(range(1,number_of_species+1))\n )\n \n def new_particle_from_model(self, internal_structure, current_age=0|units.Myr, key=None):\n if isinstance(internal_structure, dict):\n if \"dmass\" in internal_structure:\n mass_profile = internal_structure['dmass'][::-1]\n else:\n cumulative_mass_profile = [0.0] | units.MSun\n cumulative_mass_profile.extend(internal_structure['mass'])\n mass_profile = (cumulative_mass_profile[1:] - cumulative_mass_profile[:-1])[::-1]\n self.new_stellar_model(\n mass_profile,\n internal_structure['radius'][::-1],\n internal_structure['rho'][::-1],\n internal_structure['temperature'][::-1],\n internal_structure['luminosity'][::-1],\n internal_structure['X_H'][::-1],\n internal_structure['X_He'][::-1],\n internal_structure['X_C'][::-1],\n internal_structure['X_N'][::-1],\n internal_structure['X_O'][::-1],\n internal_structure['X_Ne'][::-1],\n internal_structure['X_Mg'][::-1],\n internal_structure['X_Si'][::-1],\n internal_structure['X_Fe'][::-1]\n )\n else:\n if hasattr(internal_structure, \"dmass\"):\n mass_profile = internal_structure.dmass[::-1]\n else:\n cumulative_mass_profile = [0.0] | units.MSun\n cumulative_mass_profile.extend(internal_structure.mass)\n mass_profile = (cumulative_mass_profile[1:] - cumulative_mass_profile[:-1])[::-1]\n self.new_stellar_model(\n mass_profile,\n internal_structure.radius[::-1],\n internal_structure.rho[::-1],\n internal_structure.temperature[::-1],\n internal_structure.luminosity[::-1],\n internal_structure.X_H[::-1],\n internal_structure.X_He[::-1],\n internal_structure.X_C[::-1],\n internal_structure.X_N[::-1],\n internal_structure.X_O[::-1],\n internal_structure.X_Ne[::-1],\n internal_structure.X_Mg[::-1],\n internal_structure.X_Si[::-1],\n internal_structure.X_Fe[::-1]\n )\n tmp_star = datamodel.Particle(key=key)\n tmp_star.age_tag = current_age\n return self.imported_stars.add_particle(tmp_star)\n\n\n\nMesa = MESA\n", "meta": {"hexsha": "f7fb8f7c89b788e21fd08b45e00aa759617eaa13", "size": 67639, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/amuse/community/mesa/interface.py", "max_stars_repo_name": "rknop/amuse", "max_stars_repo_head_hexsha": "85d5bdcc29cfc87dc69d91c264101fafd6658aec", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 131, "max_stars_repo_stars_event_min_datetime": "2015-06-04T09:06:57.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-01T12:11:29.000Z", "max_issues_repo_path": "src/amuse/community/mesa/interface.py", "max_issues_repo_name": "rknop/amuse", "max_issues_repo_head_hexsha": "85d5bdcc29cfc87dc69d91c264101fafd6658aec", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 690, "max_issues_repo_issues_event_min_datetime": "2015-10-17T12:18:08.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T16:15:58.000Z", "max_forks_repo_path": "src/amuse/community/mesa/interface.py", "max_forks_repo_name": "rieder/amuse", "max_forks_repo_head_hexsha": "3ac3b6b8f922643657279ddee5c8ab3fc0440d5e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 102, "max_forks_repo_forks_event_min_datetime": "2015-01-22T10:00:29.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-09T13:29:43.000Z", "avg_line_length": 43.7509702458, "max_line_length": 152, "alphanum_fraction": 0.6351217493, "include": true, "reason": "import numpy", "num_tokens": 14421, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5312093733737563, "lm_q2_score": 0.3738758367247085, "lm_q1q2_score": 0.1986063489461212}} {"text": "# -*- coding: utf-8 -*-\n\"\"\"\nSignal processing functions for RtMemory objects.\n\nFor sequential packet processing that requires memory (which includes recursive\nfiltering), each processing function (e.g., :mod:`obspy.realtime.signal`)\nneeds to manage the initialization and update of\n:class:`~obspy.realtime.rtmemory.RtMemory` object(s), and needs to know when\nand how to get values from this memory.\n\nFor example: Boxcar smoothing: For each new data point available past the end\nof the boxcar, the original, un-smoothed data point value at the beginning of\nthe boxcar has to be subtracted from the running boxcar sum, this value may be\nin a previous packet, so has to be retrieved from memory see\n:func:`obspy.realtime.signal.boxcar`.\n\n:copyright:\n The ObsPy Development Team (devs@obspy.org), Anthony Lomax & Alessia Maggi\n:license:\n GNU Lesser General Public License, Version 3\n (https://www.gnu.org/copyleft/lesser.html)\n\"\"\"\nfrom __future__ import (absolute_import, division, print_function,\n unicode_literals)\nfrom future.builtins import * # NOQA\n\nimport math\nimport sys\n\nimport numpy as np\n\nfrom obspy.core.trace import Trace, UTCDateTime\nfrom obspy.realtime.rtmemory import RtMemory\n\n\n_PI = math.pi\n_TWO_PI = 2.0 * math.pi\n_MIN_FLOAT_VAL = 1.0e-20\n\n\ndef offset(trace, offset=0.0, rtmemory_list=None): # @UnusedVariable\n \"\"\"\n Add the specified offset to the data.\n\n :type trace: :class:`~obspy.core.trace.Trace`\n :param trace: :class:`~obspy.core.trace.Trace` object to append to this\n RtTrace\n :type offset: float, optional\n :param offset: offset (default is 0.0)\n :type rtmemory_list: list of :class:`~obspy.realtime.rtmemory.RtMemory`,\n optional\n :param rtmemory_list: Persistent memory used by this process for specified\n trace\n :rtype: NumPy :class:`numpy.ndarray`\n :return: Processed trace data from appended Trace object\n \"\"\"\n\n if not isinstance(trace, Trace):\n msg = \"Trace parameter must be an obspy.core.trace.Trace object.\"\n raise ValueError(msg)\n\n trace.data += offset\n return trace.data\n\n\ndef scale(trace, factor=1.0, rtmemory_list=None): # @UnusedVariable\n \"\"\"\n Scale array data samples by specified factor.\n\n :type trace: :class:`~obspy.core.trace.Trace`\n :param trace: :class:`~obspy.core.trace.Trace` object to append to this\n RtTrace\n :type factor: float, optional\n :param factor: Scale factor (default is 1.0).\n :type rtmemory_list: list of :class:`~obspy.realtime.rtmemory.RtMemory`,\n optional\n :param rtmemory_list: Persistent memory used by this process for specified\n trace.\n :rtype: NumPy :class:`numpy.ndarray`\n :return: Processed trace data from appended Trace object.\n \"\"\"\n if not isinstance(trace, Trace):\n msg = \"trace parameter must be an obspy.core.trace.Trace object.\"\n raise ValueError(msg)\n # XXX not sure how this should be for realtime analysis, here\n # I assume, we do not want to change the underlying dtype\n trace.data *= np.array(factor, dtype=trace.data.dtype)\n return trace.data\n\n\ndef integrate(trace, rtmemory_list=None):\n \"\"\"\n Apply simple rectangular integration to array data.\n\n :type trace: :class:`~obspy.core.trace.Trace`\n :param trace: :class:`~obspy.core.trace.Trace` object to append to this\n RtTrace\n :type rtmemory_list: list of :class:`~obspy.realtime.rtmemory.RtMemory`,\n optional\n :param rtmemory_list: Persistent memory used by this process for specified\n trace.\n :rtype: NumPy :class:`numpy.ndarray`\n :return: Processed trace data from appended Trace object.\n \"\"\"\n if not isinstance(trace, Trace):\n msg = \"trace parameter must be an obspy.core.trace.Trace object.\"\n raise ValueError(msg)\n\n if not rtmemory_list:\n rtmemory_list = [RtMemory()]\n\n sample = trace.data\n if np.size(sample) < 1:\n return sample\n\n delta_time = trace.stats.delta\n\n rtmemory = rtmemory_list[0]\n\n # initialize memory object\n if not rtmemory.initialized:\n memory_size_input = 0\n memory_size_output = 1\n rtmemory.initialize(sample.dtype, memory_size_input,\n memory_size_output, 0, 0)\n\n sum_ = rtmemory.output[0]\n\n for i in range(np.size(sample)):\n sum_ += sample[i] * delta_time\n sample[i] = sum_\n\n rtmemory.output[0] = sum_\n\n return sample\n\n\ndef differentiate(trace, rtmemory_list=None):\n \"\"\"\n Apply simple differentiation to array data.\n\n :type trace: :class:`~obspy.core.trace.Trace`\n :param trace: :class:`~obspy.core.trace.Trace` object to append to this\n RtTrace\n :type rtmemory_list: list of :class:`~obspy.realtime.rtmemory.RtMemory`,\n optional\n :param rtmemory_list: Persistent memory used by this process for specified\n trace.\n :rtype: NumPy :class:`numpy.ndarray`\n :return: Processed trace data from appended Trace object.\n \"\"\"\n if not isinstance(trace, Trace):\n msg = \"trace parameter must be an obspy.core.trace.Trace object.\"\n raise ValueError(msg)\n\n if not rtmemory_list:\n rtmemory_list = [RtMemory()]\n\n sample = trace.data\n if np.size(sample) < 1:\n return(sample)\n\n delta_time = trace.stats.delta\n\n rtmemory = rtmemory_list[0]\n\n # initialize memory object\n if not rtmemory.initialized:\n memory_size_input = 1\n memory_size_output = 0\n rtmemory.initialize(sample.dtype, memory_size_input,\n memory_size_output, 0, 0)\n # avoid large diff value for first output sample\n rtmemory.input[0] = sample[0]\n\n previous_sample = rtmemory.input[0]\n\n for i in range(np.size(sample)):\n diff = (sample[i] - previous_sample) / delta_time\n previous_sample = sample[i]\n sample[i] = diff\n\n rtmemory.input[0] = previous_sample\n\n return sample\n\n\ndef boxcar(trace, width, rtmemory_list=None):\n \"\"\"\n Apply boxcar smoothing to data in array sample.\n\n :type trace: :class:`~obspy.core.trace.Trace`\n :param trace: :class:`~obspy.core.trace.Trace` object to append to this\n RtTrace\n :type width: int\n :param width: Width in number of sample points for filter.\n :type rtmemory_list: list of :class:`~obspy.realtime.rtmemory.RtMemory`,\n optional\n :param rtmemory_list: Persistent memory used by this process for specified\n trace.\n :rtype: NumPy :class:`numpy.ndarray`\n :return: Processed trace data from appended Trace object.\n \"\"\"\n if not isinstance(trace, Trace):\n msg = \"trace parameter must be an obspy.core.trace.Trace object.\"\n raise ValueError(msg)\n\n if not width > 0:\n msg = \"width parameter not specified or < 1.\"\n raise ValueError(msg)\n\n if not rtmemory_list:\n rtmemory_list = [RtMemory()]\n\n sample = trace.data\n\n rtmemory = rtmemory_list[0]\n\n # initialize memory object\n if not rtmemory.initialized:\n memory_size_input = width\n memory_size_output = 0\n rtmemory.initialize(sample.dtype, memory_size_input,\n memory_size_output, 0, 0)\n\n # initialize array for time-series results\n new_sample = np.zeros(np.size(sample), sample.dtype)\n\n i = 0\n i1 = i - width\n i2 = i # causal boxcar of width width\n sum_ = 0.0\n icount = 0\n for i in range(np.size(sample)):\n value = 0.0\n if (icount == 0): # first pass, accumulate sum\n for n in range(i1, i2 + 1):\n if (n < 0):\n value = rtmemory.input[width + n]\n else:\n value = sample[n]\n sum_ += value\n icount = icount + 1\n else: # later passes, update sum\n if ((i1 - 1) < 0):\n value = rtmemory.input[width + (i1 - 1)]\n else:\n value = sample[(i1 - 1)]\n sum_ -= value\n if (i2 < 0):\n value = rtmemory.input[width + i2]\n else:\n value = sample[i2]\n sum_ += value\n if (icount > 0):\n new_sample[i] = (float)(sum_ / float(icount))\n else:\n new_sample[i] = 0.0\n i1 = i1 + 1\n i2 = i2 + 1\n\n rtmemory.update_input(sample)\n\n return new_sample\n\n\ndef tauc(trace, width, rtmemory_list=None):\n \"\"\"\n Calculate instantaneous period in a fixed window (Tau_c).\n\n .. seealso::\n\n Implements equations 1-3 in [Allen2003]_ except use a fixed width\n window instead of decay function.\n\n :type trace: :class:`~obspy.core.trace.Trace`\n :param trace: :class:`~obspy.core.trace.Trace` object to append to this\n RtTrace\n :type width: int\n :param width: Width in number of sample points for tauc window.\n :type rtmemory_list: list of :class:`~obspy.realtime.rtmemory.RtMemory`,\n optional\n :param rtmemory_list: Persistent memory used by this process for specified\n trace.\n :rtype: NumPy :class:`numpy.ndarray`\n :return: Processed trace data from appended Trace object.\n \"\"\"\n if not isinstance(trace, Trace):\n msg = \"trace parameter must be an obspy.core.trace.Trace object.\"\n raise ValueError(msg)\n\n if not width > 0:\n msg = \"tauc: width parameter not specified or < 1.\"\n raise ValueError(msg)\n\n if not rtmemory_list:\n rtmemory_list = [RtMemory(), RtMemory()]\n\n sample = trace.data\n delta_time = trace.stats.delta\n\n rtmemory = rtmemory_list[0]\n rtmemory_dval = rtmemory_list[1]\n\n sample_last = 0.0\n\n # initialize memory object\n if not rtmemory.initialized:\n memory_size_input = width\n memory_size_output = 1\n rtmemory.initialize(sample.dtype, memory_size_input,\n memory_size_output, 0, 0)\n sample_last = sample[0]\n else:\n sample_last = rtmemory.input[width - 1]\n\n # initialize memory object\n if not rtmemory_dval.initialized:\n memory_size_input = width\n memory_size_output = 1\n rtmemory_dval.initialize(sample.dtype, memory_size_input,\n memory_size_output, 0, 0)\n\n new_sample = np.zeros(np.size(sample), sample.dtype)\n deriv = np.zeros(np.size(sample), sample.dtype)\n\n # sample_last = rtmemory.input[width - 1]\n sample_d = 0.0\n deriv_d = 0.0\n xval = rtmemory.output[0]\n dval = rtmemory_dval.output[0]\n\n for i in range(np.size(sample)):\n\n sample_d = sample[i]\n deriv_d = (sample_d - sample_last) / delta_time\n index_begin = i - width\n if (index_begin >= 0):\n xval = xval - (sample[index_begin]) * (sample[index_begin]) \\\n + sample_d * sample_d\n dval = dval - deriv[index_begin] * deriv[index_begin] \\\n + deriv_d * deriv_d\n else:\n index = i\n xval = xval - rtmemory.input[index] * rtmemory.input[index] \\\n + sample_d * sample_d\n dval = dval \\\n - rtmemory_dval.input[index] * rtmemory_dval.input[index] \\\n + deriv_d * deriv_d\n deriv[i] = deriv_d\n sample_last = sample_d\n # if (xval > _MIN_FLOAT_VAL & & dval > _MIN_FLOAT_VAL) {\n if (dval > _MIN_FLOAT_VAL):\n new_sample[i] = _TWO_PI * math.sqrt(xval / dval)\n else:\n new_sample[i] = 0.0\n\n # update memory\n rtmemory.output[0] = xval\n rtmemory.update_input(sample)\n rtmemory_dval.output[0] = dval\n rtmemory_dval.update_input(deriv)\n\n return new_sample\n\n\n# memory object indices for storing specific values\n_AMP_AT_PICK = 0\n_HAVE_USED_MEMORY = 1\n_FLAG_COMPETE_MWP = 2\n_INT_INT_SUM = 3\n_POLARITY = 4\n_MEMORY_SIZE_OUTPUT = 5\n\n\ndef mwpintegral(trace, max_time, ref_time, mem_time=1.0, gain=1.0,\n rtmemory_list=None):\n \"\"\"\n Calculate Mwp integral on a displacement trace.\n\n .. seealso:: [Tsuboi1999]_ and [Tsuboi1995]_\n\n :type trace: :class:`~obspy.core.trace.Trace`\n :param trace: :class:`~obspy.core.trace.Trace` object to append to this\n RtTrace\n :type max_time: float\n :param max_time: Maximum time in seconds after ref_time to apply Mwp\n integration.\n :type ref_time: :class:`~obspy.core.utcdatetime.UTCDateTime`\n :param ref_time: Reference date and time of the data sample\n (e.g. P pick time) at which to begin Mwp integration.\n :type mem_time: float, optional\n :param mem_time: Length in seconds of data memory (must be much larger\n than maximum delay between pick declaration and pick time). Defaults\n to ``1.0``.\n :type gain: float, optional\n :param gain: Nominal gain to convert input displacement trace to meters\n of ground displacement. Defaults to ``1.0``.\n :type rtmemory_list: list of :class:`~obspy.realtime.rtmemory.RtMemory`,\n optional\n :param rtmemory_list: Persistent memory used by this process for specified\n trace.\n :rtype: NumPy :class:`numpy.ndarray`\n :return: Processed trace data from appended Trace object.\n \"\"\"\n if not isinstance(trace, Trace):\n msg = \"trace parameter must be an obspy.core.trace.Trace object.\"\n raise ValueError(msg)\n\n if not isinstance(ref_time, UTCDateTime):\n msg = \"ref_time must be an obspy.core.utcdatetime.UTCDateTime object.\"\n raise ValueError(msg)\n\n if not max_time >= 0:\n msg = \"max_time parameter not specified or < 0.\"\n raise ValueError(msg)\n\n if not rtmemory_list:\n rtmemory_list = [RtMemory()]\n\n sample = trace.data\n delta_time = trace.stats.delta\n\n rtmemory = rtmemory_list[0]\n\n # initialize memory object\n if not rtmemory.initialized:\n memory_size_input = int(0.5 + mem_time * trace.stats.sampling_rate)\n memory_size_output = _MEMORY_SIZE_OUTPUT\n rtmemory.initialize(sample.dtype, memory_size_input,\n memory_size_output, 0, 0)\n\n new_sample = np.zeros(np.size(sample), sample.dtype)\n\n ioffset_pick = int(round(\n (ref_time - trace.stats.starttime) *\n trace.stats.sampling_rate))\n ioffset_mwp_min = ioffset_pick\n\n # set reference amplitude\n if ioffset_mwp_min >= 0 and ioffset_mwp_min < trace.data.size:\n # value in trace data array\n rtmemory.output[_AMP_AT_PICK] = trace.data[ioffset_mwp_min]\n elif ioffset_mwp_min >= -(np.size(rtmemory.input)) and ioffset_mwp_min < 0:\n # value in memory array\n index = ioffset_mwp_min + np.size(rtmemory.input)\n rtmemory.output[_AMP_AT_PICK] = rtmemory.input[index]\n elif ioffset_mwp_min < -(np.size(rtmemory.input)) \\\n and not rtmemory.output[_HAVE_USED_MEMORY]:\n msg = \"mem_time not large enough to buffer required input data.\"\n raise ValueError(msg)\n if ioffset_mwp_min < 0 and rtmemory.output[_HAVE_USED_MEMORY]:\n ioffset_mwp_min = 0\n else:\n rtmemory.output[_HAVE_USED_MEMORY] = 1\n # set Mwp end index corresponding to maximum duration\n mwp_end_index = int(round(max_time / delta_time))\n ioffset_mwp_max = mwp_end_index + ioffset_pick\n if ioffset_mwp_max < trace.data.size:\n rtmemory.output[_FLAG_COMPETE_MWP] = 1 # will complete\n if ioffset_mwp_max > trace.data.size:\n ioffset_mwp_max = trace.data.size\n # apply double integration, check for extrema\n mwp_amp_at_pick = rtmemory.output[_AMP_AT_PICK]\n mwp_int_int_sum = rtmemory.output[_INT_INT_SUM]\n polarity = rtmemory.output[_POLARITY]\n amplitude = 0.0\n for n in range(ioffset_mwp_min, ioffset_mwp_max):\n if n >= 0:\n amplitude = trace.data[n]\n elif n >= -(np.size(rtmemory.input)):\n # value in memory array\n index = n + np.size(rtmemory.input)\n amplitude = rtmemory.input[index]\n else:\n msg = \"Error: Mwp: attempt to access rtmemory.input array of \" + \\\n \"size=%d at invalid index=%d: this should not happen!\" % \\\n (np.size(rtmemory.input), n + np.size(rtmemory.input))\n print(msg)\n continue # should never reach here\n disp_amp = amplitude - mwp_amp_at_pick\n # check displacement polarity\n if disp_amp >= 0.0: # pos\n # check if past extremum\n if polarity < 0: # passed from neg to pos displacement\n mwp_int_int_sum *= -1.0\n mwp_int_int_sum = 0\n polarity = 1\n elif disp_amp < 0.0: # neg\n # check if past extremum\n if polarity > 0: # passed from pos to neg displacement\n mwp_int_int_sum = 0\n polarity = -1\n mwp_int_int_sum += (amplitude - mwp_amp_at_pick) * delta_time / gain\n new_sample[n] = mwp_int_int_sum\n\n rtmemory.output[_INT_INT_SUM] = mwp_int_int_sum\n rtmemory.output[_POLARITY] = polarity\n\n # update memory\n rtmemory.update_input(sample)\n\n return new_sample\n\n\nMWP_INVALID = -9.9\n# 4.213e19 - Tsuboi 1995, 1999\nMWP_CONST = 4.0 * _PI # 4 PI\nMWP_CONST *= 3400.0 # rho\nMWP_CONST *= 7900.0 * 7900.0 * 7900.0 # Pvel**3\nMWP_CONST *= 2.0 # FP average radiation pattern\nMWP_CONST *= (10000.0 / 90.0) # distance deg -> km\nMWP_CONST *= 1000.0 # distance km -> meters\n# https://mail.python.org/pipermail/python-list/2010-February/567089.html, ff.\ntry:\n FLOAT_MIN = sys.float_info.min\nexcept AttributeError:\n FLOAT_MIN = 1.1e-37\n\n\ndef calculate_mwp_mag(peak, epicentral_distance):\n \"\"\"\n Calculate Mwp magnitude.\n\n .. seealso:: [Tsuboi1999]_ and [Tsuboi1995]_\n\n :type peak: float\n :param peak: Peak value of integral of displacement seismogram.\n :type epicentral_distance: float\n :param epicentral_distance: Great-circle epicentral distance from station\n in degrees.\n :rtype: float\n :returns: Calculated Mwp magnitude.\n \"\"\"\n moment = MWP_CONST * peak * epicentral_distance\n mwp_mag = MWP_INVALID\n if moment > FLOAT_MIN:\n mwp_mag = (2.0 / 3.0) * (math.log10(moment) - 9.1)\n return mwp_mag\n\n\ndef kurtosis(trace, win=3.0, rtmemory_list=None):\n \"\"\"\n Apply recursive kurtosis calculation on data.\n\n Recursive kurtosis is computed using the [ChassandeMottin2002]_\n formulation adjusted to give the kurtosis of a Gaussian distribution = 0.0.\n\n :type trace: :class:`~obspy.core.trace.Trace`\n :param trace: :class:`~obspy.core.trace.Trace` object to append to this\n RtTrace\n :type win: float, optional\n :param win: window length in seconds for the kurtosis (default is 3.0 s)\n :type rtmemory_list: list of :class:`~obspy.realtime.rtmemory.RtMemory`,\n optional\n :param rtmemory_list: Persistent memory used by this process for specified\n trace\n :rtype: NumPy :class:`numpy.ndarray`\n :return: Processed trace data from appended Trace object\n \"\"\"\n if not isinstance(trace, Trace):\n msg = \"Trace parameter must be an obspy.core.trace.Trace object.\"\n raise ValueError(msg)\n\n # if this is the first appended trace, the rtmemory_list will be None\n if not rtmemory_list:\n rtmemory_list = [RtMemory(), RtMemory(), RtMemory()]\n\n # deal with case of empty trace\n sample = trace.data\n if np.size(sample) < 1:\n return sample\n\n # get simple info from trace\n npts = len(sample)\n dt = trace.stats.delta\n\n # set some constants for the kurtosis calculation\n c_1 = dt / float(win)\n a1 = 1.0 - c_1\n c_2 = (1.0 - a1 * a1) / 2.0\n bias = -3 * c_1 - 3.0\n\n # prepare the output array\n kappa4 = np.empty(npts, sample.dtype)\n\n # initialize the real-time memory needed to store\n # the recursive kurtosis coefficients until the\n # next bloc of data is added\n rtmemory_mu1 = rtmemory_list[0]\n rtmemory_mu2 = rtmemory_list[1]\n rtmemory_k4_bar = rtmemory_list[2]\n\n # there are three memory objects, one for each \"last\" coefficient\n # that needs carrying over\n # initialize mu1_last to 0\n if not rtmemory_mu1.initialized:\n memory_size_input = 1\n memory_size_output = 0\n rtmemory_mu1.initialize(sample.dtype, memory_size_input,\n memory_size_output, 0, 0)\n\n # initialize mu2_last (sigma) to 1\n if not rtmemory_mu2.initialized:\n memory_size_input = 1\n memory_size_output = 0\n rtmemory_mu2.initialize(sample.dtype, memory_size_input,\n memory_size_output, 1, 0)\n\n # initialize k4_bar_last to 0\n if not rtmemory_k4_bar.initialized:\n memory_size_input = 1\n memory_size_output = 0\n rtmemory_k4_bar.initialize(sample.dtype, memory_size_input,\n memory_size_output, 0, 0)\n\n mu1_last = rtmemory_mu1.input[0]\n mu2_last = rtmemory_mu2.input[0]\n k4_bar_last = rtmemory_k4_bar.input[0]\n\n # do recursive kurtosis\n for i in range(npts):\n mu1 = a1 * mu1_last + c_1 * sample[i]\n dx2 = (sample[i] - mu1_last) * (sample[i] - mu1_last)\n mu2 = a1 * mu2_last + c_2 * dx2\n dx2 = dx2 / mu2_last\n k4_bar = (1 + c_1 - 2 * c_1 * dx2) * k4_bar_last + c_1 * dx2 * dx2\n kappa4[i] = k4_bar + bias\n mu1_last = mu1\n mu2_last = mu2\n k4_bar_last = k4_bar\n\n rtmemory_mu1.input[0] = mu1_last\n rtmemory_mu2.input[0] = mu2_last\n rtmemory_k4_bar.input[0] = k4_bar_last\n\n return kappa4\n", "meta": {"hexsha": "5c52eb8b2334fc94e8da12fb82b6ef5b1a82e7ef", "size": 21435, "ext": "py", "lang": "Python", "max_stars_repo_path": "IRIS_data_download/IRIS_download_support/obspy/realtime/signal.py", "max_stars_repo_name": "earthinversion/Fnet_IRIS_data_automated_download", "max_stars_repo_head_hexsha": "09a6e0c992662feac95744935e038d1c68539fa1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-03-05T01:03:01.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-17T05:04:07.000Z", "max_issues_repo_path": "IRIS_data_download/IRIS_download_support/obspy/realtime/signal.py", "max_issues_repo_name": "earthinversion/Fnet_IRIS_data_automated_download", "max_issues_repo_head_hexsha": "09a6e0c992662feac95744935e038d1c68539fa1", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2021-03-31T19:25:55.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-13T20:32:46.000Z", "max_forks_repo_path": "IRIS_data_download/IRIS_download_support/obspy/realtime/signal.py", "max_forks_repo_name": "earthinversion/Fnet_IRIS_data_automated_download", "max_forks_repo_head_hexsha": "09a6e0c992662feac95744935e038d1c68539fa1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-09-08T19:33:40.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-05T09:47:50.000Z", "avg_line_length": 33.5971786834, "max_line_length": 79, "alphanum_fraction": 0.6428271519, "include": true, "reason": "import numpy", "num_tokens": 5685, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5312093733737563, "lm_q2_score": 0.3738758367247085, "lm_q1q2_score": 0.1986063489461212}} {"text": "\"\"\"\nThe default unit symbol lookup table.\n\n\n\"\"\"\n\n#-----------------------------------------------------------------------------\n# Copyright (c) 2013, yt Development Team.\n#\n# Distributed under the terms of the Modified BSD License.\n#\n# The full license is in the file COPYING.txt, distributed with this software.\n#-----------------------------------------------------------------------------\n\nfrom yt.units import dimensions\nfrom yt.utilities.physical_ratios import \\\n cm_per_pc, cm_per_ly, cm_per_au, cm_per_rsun, cm_per_m, \\\n mass_sun_grams, sec_per_year, sec_per_day, sec_per_hr, \\\n sec_per_min, temp_sun_kelvin, luminosity_sun_ergs_per_sec, \\\n metallicity_sun, erg_per_eV, amu_grams, mass_electron_grams, \\\n cm_per_ang, jansky_cgs, mass_jupiter_grams, mass_earth_grams, \\\n kelvin_per_rankine, speed_of_light_cm_per_s, planck_length_cm, \\\n planck_charge_esu, planck_energy_erg, planck_mass_grams, \\\n planck_temperature_K, planck_time_s, mass_hydrogen_grams, \\\n grams_per_pound, standard_gravity_cm_per_s2, pascal_per_atm, \\\n newton_cgs, cm_per_rearth, cm_per_rjup\nimport numpy as np\n\n# Lookup a unit symbol with the symbol string, and provide a tuple with the\n# conversion factor to cgs and dimensionality.\n\ndefault_unit_symbol_lut = {\n # base\n \"g\": (1.0, dimensions.mass, 0.0, r\"\\rm{g}\"),\n \"s\": (1.0, dimensions.time, 0.0, r\"\\rm{s}\"),\n \"K\": (1.0, dimensions.temperature, 0.0, r\"\\rm{K}\"),\n \"radian\": (1.0, dimensions.angle, 0.0, r\"\\rm{radian}\"),\n\n # other cgs\n \"dyne\": (1.0, dimensions.force, 0.0, r\"\\rm{dyn}\"),\n \"erg\": (1.0, dimensions.energy, 0.0, r\"\\rm{erg}\"),\n \"esu\": (1.0, dimensions.charge_cgs, 0.0, r\"\\rm{esu}\"),\n \"gauss\": (1.0, dimensions.magnetic_field_cgs, 0.0, r\"\\rm{G}\"),\n \"degC\": (1.0, dimensions.temperature, -273.15, r\"^\\circ\\rm{C}\"),\n \"statA\": (1.0, dimensions.current_cgs, 0.0, r\"\\rm{statA}\"),\n \"statV\": (1.0, dimensions.electric_potential_cgs, 0.0, r\"\\rm{statV}\"),\n \"statohm\": (1.0, dimensions.resistance_cgs, 0.0, r\"\\rm{statohm}\"),\n\n # some SI\n \"m\": (1.0e2, dimensions.length, 0.0, r\"\\rm{m}\"),\n \"J\": (1.0e7, dimensions.energy, 0.0, r\"\\rm{J}\"),\n \"W\": (1.0e7, dimensions.power, 0.0, r\"\\rm{W}\"),\n \"Hz\": (1.0, dimensions.rate, 0.0, r\"\\rm{Hz}\"),\n \"N\": (1.0e5, dimensions.force, 0.0, r\"\\rm{N}\"),\n \"C\": (1.0, dimensions.charge_mks, 0.0, r\"\\rm{C}\"),\n \"A\": (1.0, dimensions.current_mks, 0.0, r\"\\rm{A}\"),\n \"T\": (1000.0, dimensions.magnetic_field_mks, 0.0, r\"\\rm{T}\"),\n \"Pa\": (10.0, dimensions.pressure, 0.0, r\"\\rm{Pa}\"),\n \"V\": (1.0e7, dimensions.electric_potential_mks, 0.0, r\"\\rm{V}\"),\n \"ohm\": (1.0e7, dimensions.resistance_mks, 0.0, r\"\\Omega\"),\n\n # Imperial and other non-metric units\n \"ft\": (30.48, dimensions.length, 0.0, r\"\\rm{ft}\"),\n \"mile\": (160934, dimensions.length, 0.0, r\"\\rm{mile}\"),\n \"degF\": (kelvin_per_rankine, dimensions.temperature, -459.67,\n \"^\\circ\\rm{F}\"),\n \"R\": (kelvin_per_rankine, dimensions.temperature, 0.0, r\"^\\circ\\rm{R}\"),\n \"lbf\": (grams_per_pound*standard_gravity_cm_per_s2, dimensions.force, 0.0, r\"\\rm{lbf}\"),\n \"lbm\": (grams_per_pound, dimensions.mass, 0.0, r\"\\rm{lbm}\"),\n \"atm\": (pascal_per_atm*10., dimensions.pressure, 0.0, r\"\\rm{atm}\"),\n\n # dimensionless stuff\n \"h\": (1.0, dimensions.dimensionless, 0.0, r\"h\"), # needs to be added for rho_crit_now\n \"dimensionless\": (1.0, dimensions.dimensionless, 0.0, r\"\"),\n\n # times\n \"min\": (sec_per_min, dimensions.time, 0.0, r\"\\rm{min}\"),\n \"hr\": (sec_per_hr, dimensions.time, 0.0, r\"\\rm{hr}\"),\n \"day\": (sec_per_day, dimensions.time, 0.0, r\"\\rm{d}\"),\n \"d\": (sec_per_day, dimensions.time, 0.0, r\"\\rm{d}\"),\n \"yr\": (sec_per_year, dimensions.time, 0.0, r\"\\rm{yr}\"),\n\n # Velocities\n \"c\": (speed_of_light_cm_per_s, dimensions.velocity, 0.0, r\"\\rm{c}\"),\n\n # Solar units\n \"Msun\": (mass_sun_grams, dimensions.mass, 0.0, r\"M_\\odot\"),\n \"msun\": (mass_sun_grams, dimensions.mass, 0.0, r\"M_\\odot\"),\n \"Rsun\": (cm_per_rsun, dimensions.length, 0.0, r\"R_\\odot\"),\n \"rsun\": (cm_per_rsun, dimensions.length, 0.0, r\"R_\\odot\"),\n \"R_sun\": (cm_per_rsun, dimensions.length, 0.0, r\"R_\\odot\"),\n \"r_sun\": (cm_per_rsun, dimensions.length, 0.0, r\"R_\\odot\"),\n \"Lsun\": (luminosity_sun_ergs_per_sec, dimensions.power, 0.0, r\"L_\\odot\"),\n \"Tsun\": (temp_sun_kelvin, dimensions.temperature, 0.0, r\"T_\\odot\"),\n \"Zsun\": (metallicity_sun, dimensions.dimensionless, 0.0, r\"Z_\\odot\"),\n \"Mjup\": (mass_jupiter_grams, dimensions.mass, 0.0, r\"M_{\\rm{Jup}}\"),\n \"Mearth\": (mass_earth_grams, dimensions.mass, 0.0, r\"M_\\oplus\"),\n\n # astro distances\n \"AU\": (cm_per_au, dimensions.length, 0.0, r\"\\rm{AU}\"),\n \"au\": (cm_per_au, dimensions.length, 0.0, r\"\\rm{AU}\"),\n \"ly\": (cm_per_ly, dimensions.length, 0.0, r\"\\rm{ly}\"),\n \"pc\": (cm_per_pc, dimensions.length, 0.0, r\"\\rm{pc}\"),\n\n # angles\n \"degree\": (np.pi/180., dimensions.angle, 0.0, r\"\\rm{deg}\"), # degrees\n \"arcmin\": (np.pi/10800., dimensions.angle, 0.0,\n r\"\\rm{arcmin}\"), # arcminutes\n \"arcsec\": (np.pi/648000., dimensions.angle, 0.0,\n r\"\\rm{arcsec}\"), # arcseconds\n \"mas\": (np.pi/648000000., dimensions.angle, 0.0,\n r\"\\rm{mas}\"), # milliarcseconds\n \"hourangle\": (np.pi/12., dimensions.angle, 0.0, r\"\\rm{HA}\"), # hour angle\n \"steradian\": (1.0, dimensions.solid_angle, 0.0, r\"\\rm{sr}\"),\n \"lat\": (-np.pi/180.0, dimensions.angle, 90.0, r\"\\rm{Latitude}\"),\n \"lon\": (np.pi/180.0, dimensions.angle, -180.0, r\"\\rm{Longitude}\"),\n\n # misc\n \"eV\": (erg_per_eV, dimensions.energy, 0.0, r\"\\rm{eV}\"),\n \"amu\": (amu_grams, dimensions.mass, 0.0, r\"\\rm{amu}\"),\n \"angstrom\": (cm_per_ang, dimensions.length, 0.0, r\"\\AA\"),\n \"Jy\": (jansky_cgs, dimensions.specific_flux, 0.0, r\"\\rm{Jy}\"),\n \"counts\": (1.0, dimensions.dimensionless, 0.0, r\"\\rm{counts}\"),\n \"photons\": (1.0, dimensions.dimensionless, 0.0, r\"\\rm{photons}\"),\n \"me\": (mass_electron_grams, dimensions.mass, 0.0, r\"m_e\"),\n \"mp\": (mass_hydrogen_grams, dimensions.mass, 0.0, r\"m_p\"),\n \"mol\": (1.0/amu_grams, dimensions.dimensionless, 0.0, r\"\\rm{mol}\"),\n 'Sv': (cm_per_m**2, dimensions.specific_energy, 0.0, r\"\\rm{Sv}\"),\n \"rayleigh\": (0.25e6/np.pi, dimensions.count_intensity, 0.0, r\"\\rm{R}\"),\n\n # for AstroPy compatibility\n \"solMass\": (mass_sun_grams, dimensions.mass, 0.0, r\"M_\\odot\"),\n \"solRad\": (cm_per_rsun, dimensions.length, 0.0, r\"R_\\odot\"),\n \"solLum\": (luminosity_sun_ergs_per_sec, dimensions.power, 0.0, r\"L_\\odot\"),\n \"dyn\": (1.0, dimensions.force, 0.0, r\"\\rm{dyn}\"),\n \"sr\": (1.0, dimensions.solid_angle, 0.0, r\"\\rm{sr}\"),\n \"rad\": (1.0, dimensions.angle, 0.0, r\"\\rm{rad}\"),\n \"deg\": (np.pi/180., dimensions.angle, 0.0, r\"\\rm{deg}\"),\n \"Fr\": (1.0, dimensions.charge_cgs, 0.0, r\"\\rm{Fr}\"),\n \"G\": (1.0, dimensions.magnetic_field_cgs, 0.0, r\"\\rm{G}\"),\n \"Angstrom\": (cm_per_ang, dimensions.length, 0.0, r\"\\AA\"),\n \"statC\": (1.0, dimensions.charge_cgs, 0.0, r\"\\rm{statC}\"),\n\n # Planck units\n \"m_pl\": (planck_mass_grams, dimensions.mass, 0.0, r\"m_{\\rm{P}}\"),\n \"l_pl\": (planck_length_cm, dimensions.length, 0.0, r\"\\ell_\\rm{P}\"),\n \"t_pl\": (planck_time_s, dimensions.time, 0.0, r\"t_{\\rm{P}}\"),\n \"T_pl\": (planck_temperature_K, dimensions.temperature, 0.0, r\"T_{\\rm{P}}\"),\n \"q_pl\": (planck_charge_esu, dimensions.charge_cgs, 0.0, r\"q_{\\rm{P}}\"),\n \"E_pl\": (planck_energy_erg, dimensions.energy, 0.0, r\"E_{\\rm{P}}\"),\n\n # Geometrized units\n \"m_geom\": (mass_sun_grams, dimensions.mass, 0.0, r\"M_\\odot\"),\n \"l_geom\": (newton_cgs*mass_sun_grams/speed_of_light_cm_per_s**2, dimensions.length, 0.0, r\"M_\\odot\"),\n \"t_geom\": (newton_cgs*mass_sun_grams/speed_of_light_cm_per_s**3, dimensions.time, 0.0, r\"M_\\odot\"),\n\n # Some Solar System units\n \"R_earth\": (cm_per_rearth, dimensions.length, 0.0, r\"R_\\oplus\"),\n \"r_earth\": (cm_per_rearth, dimensions.length, 0.0, r\"R_\\oplus\"),\n \"R_jup\": (cm_per_rjup, dimensions.length, 0.0, r\"R_\\mathrm{Jup}\"),\n \"r_jup\": (cm_per_rjup, dimensions.length, 0.0, r\"R_\\mathrm{Jup}\"),\n}\n\n# This dictionary formatting from magnitude package, credit to Juan Reyero.\nunit_prefixes = {\n 'Y': 1e24, # yotta\n 'Z': 1e21, # zetta\n 'E': 1e18, # exa\n 'P': 1e15, # peta\n 'T': 1e12, # tera\n 'G': 1e9, # giga\n 'M': 1e6, # mega\n 'k': 1e3, # kilo\n 'd': 1e1, # deci\n 'c': 1e-2, # centi\n 'm': 1e-3, # mili\n 'u': 1e-6, # micro\n 'n': 1e-9, # nano\n 'p': 1e-12, # pico\n 'f': 1e-15, # femto\n 'a': 1e-18, # atto\n 'z': 1e-21, # zepto\n 'y': 1e-24, # yocto\n}\n\nlatex_prefixes = {\n \"u\": r\"\\mu\",\n }\n\nprefixable_units = [\n \"m\",\n \"pc\",\n \"mcm\",\n \"pccm\",\n \"g\",\n \"eV\",\n \"s\",\n \"yr\",\n \"K\",\n \"dyne\",\n \"erg\",\n \"esu\",\n \"J\",\n \"Hz\",\n \"W\",\n \"gauss\",\n \"G\",\n \"Jy\",\n \"N\",\n \"T\",\n \"A\",\n \"C\",\n \"statA\",\n \"Pa\",\n \"V\",\n \"statV\",\n \"ohm\",\n \"statohm\",\n \"Sv\",\n]\n\ndefault_base_units = {\n dimensions.mass: 'g',\n dimensions.length: 'cm',\n dimensions.time: 's',\n dimensions.temperature: 'K',\n dimensions.angle: 'radian',\n dimensions.current_mks: 'A',\n}\n", "meta": {"hexsha": "e091e8e29602bdf49399c3926a79a62978cef790", "size": 9149, "ext": "py", "lang": "Python", "max_stars_repo_path": "yt/units/unit_lookup_table.py", "max_stars_repo_name": "kastalpes/yt", "max_stars_repo_head_hexsha": "b1e197ca84433fbd61eaf44b28ff5cdb37981d4c", "max_stars_repo_licenses": ["BSD-3-Clause-Clear"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-03-02T18:59:49.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-02T18:59:50.000Z", "max_issues_repo_path": "yt/units/unit_lookup_table.py", "max_issues_repo_name": "kastalpes/yt", "max_issues_repo_head_hexsha": "b1e197ca84433fbd61eaf44b28ff5cdb37981d4c", "max_issues_repo_licenses": ["BSD-3-Clause-Clear"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2018-04-13T23:03:42.000Z", "max_issues_repo_issues_event_max_datetime": "2018-05-08T17:50:43.000Z", "max_forks_repo_path": "yt/units/unit_lookup_table.py", "max_forks_repo_name": "kastalpes/yt", "max_forks_repo_head_hexsha": "b1e197ca84433fbd61eaf44b28ff5cdb37981d4c", "max_forks_repo_licenses": ["BSD-3-Clause-Clear"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-05-16T15:29:37.000Z", "max_forks_repo_forks_event_max_datetime": "2020-06-22T10:17:08.000Z", "avg_line_length": 39.7782608696, "max_line_length": 105, "alphanum_fraction": 0.5938353918, "include": true, "reason": "import numpy", "num_tokens": 3515, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5312093733737563, "lm_q2_score": 0.3738758227716966, "lm_q1q2_score": 0.19860634153415052}} {"text": "\"\"\"!\nAdopted from https://github.com/ujscjj/DPTNet\nModified by Yi Luo {yl3364@columbia.edu}\n\"\"\"\n\nimport numpy as np\nimport os\nimport copy\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torch.autograd import Variable\nfrom torch.nn.modules.module import Module\nfrom torch.nn.modules.activation import MultiheadAttention\nfrom torch.nn.modules.container import ModuleList\nfrom torch.nn.init import xavier_uniform_\nfrom torch.nn.modules.dropout import Dropout\nfrom torch.nn.modules.linear import Linear\nfrom torch.nn.modules.rnn import LSTM\nfrom torch.nn.modules.normalization import LayerNorm\n\nclass TransformerOptimizer(object):\n \"\"\"A simple wrapper class for learning rate scheduling\"\"\"\n\n def __init__(self, optimizer, k, d_model, warmup_steps=4000):\n self.optimizer = optimizer\n self.k = k\n self.init_lr = d_model ** (-0.5)\n self.warmup_steps = warmup_steps\n self.step_num = 0\n self.epoch = 0\n self.visdom_lr = None\n\n def zero_grad(self):\n self.optimizer.zero_grad()\n\n def step(self, epoch):\n self._update_lr(epoch)\n # self._visdom()\n self.optimizer.step()\n\n def _update_lr(self, epoch):\n self.step_num += 1\n if self.step_num <= self.warmup_steps:\n lr = self.k * self.init_lr * min(self.step_num ** (-0.5),\n self.step_num * (self.warmup_steps ** (-1.5)))\n else:\n lr = 0.0004 * (0.98 ** ((epoch-1)//2))\n\n for param_group in self.optimizer.param_groups:\n param_group['lr'] = lr\n\n def load_state_dict(self, state_dict):\n self.optimizer.load_state_dict(state_dict)\n\n def state_dict(self):\n return self.optimizer.state_dict()\n\n def set_k(self, k):\n self.k = k\n\n def set_visdom(self, visdom_lr, vis):\n self.visdom_lr = visdom_lr # Turn on/off visdom of learning rate\n self.vis = vis # visdom enviroment\n self.vis_opts = dict(title='Learning Rate',\n ylabel='Leanring Rate', xlabel='step')\n self.vis_window = None\n self.x_axis = torch.LongTensor()\n self.y_axis = torch.FloatTensor()\n\n def _visdom(self):\n if self.visdom_lr is not None:\n self.x_axis = torch.cat(\n [self.x_axis, torch.LongTensor([self.step_num])])\n self.y_axis = torch.cat(\n [self.y_axis, torch.FloatTensor([self.optimizer.param_groups[0]['lr']])])\n if self.vis_window is None:\n self.vis_window = self.vis.line(X=self.x_axis, Y=self.y_axis,\n opts=self.vis_opts)\n else:\n self.vis.line(X=self.x_axis, Y=self.y_axis, win=self.vis_window,\n update='replace')\n\nclass TransformerEncoderLayer(nn.Module):\n r\"\"\"TransformerEncoderLayer is made up of self-attn and feedforward network.\n This standard encoder layer is based on the paper \"Attention Is All You Need\".\n Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez,\n Lukasz Kaiser, and Illia Polosukhin. 2017. Attention is all you need. In Advances in\n Neural Information Processing Systems, pages 6000-6010. Users may modify or implement\n in a different way during application.\n Args:\n d_model: the number of expected features in the input (required).\n nhead: the number of heads in the multiheadattention models (required).\n dim_feedforward: the dimension of the feedforward network model (default=2048).\n dropout: the dropout value (default=0.1).\n activation: the activation function of intermediate layer, relu or gelu (default=relu).\n Examples::\n >>> encoder_layer = nn.TransformerEncoderLayer(d_model=512, nhead=8)\n >>> src = torch.rand(10, 32, 512)\n >>> out = encoder_layer(src)\n \"\"\"\n\n def __init__(self, d_model, nhead, dim_feedforward=256, dropout=0, activation=\"relu\"):\n super(TransformerEncoderLayer, self).__init__()\n self.self_attn = MultiheadAttention(d_model, nhead, dropout=dropout)\n # Implementation of Feedforward model\n # self.linear1 = Linear(d_model, dim_feedforward)\n self.linear1 = LSTM(d_model, d_model*2, 1, bidirectional=True)\n self.dropout = Dropout(dropout)\n # self.linear2 = Linear(dim_feedforward, d_model)\n self.linear2 = Linear(d_model*2*2, d_model)\n\n self.norm1 = LayerNorm(d_model)\n self.norm2 = LayerNorm(d_model)\n self.dropout1 = Dropout(dropout)\n self.dropout2 = Dropout(dropout)\n\n self.activation = _get_activation_fn(activation)\n\n def __setstate__(self, state):\n if 'activation' not in state:\n state['activation'] = F.relu\n super(TransformerEncoderLayer, self).__setstate__(state)\n\n def forward(self, src, src_mask=None, src_key_padding_mask=None):\n # type: (Tensor, Optional[Tensor], Optional[Tensor]) -> Tensor\n r\"\"\"Pass the input through the encoder layer.\n Args:\n src: the sequnce to the encoder layer (required).\n src_mask: the mask for the src sequence (optional).\n src_key_padding_mask: the mask for the src keys per batch (optional).\n Shape:\n see the docs in Transformer class.\n \"\"\"\n src2 = self.self_attn(src, src, src, attn_mask=src_mask,\n key_padding_mask=src_key_padding_mask)[0]\n src = src + self.dropout1(src2)\n src = self.norm1(src)\n # src2 = self.linear2(self.dropout(self.activation(self.linear1(src))))\n src2 = self.linear2(self.dropout(self.activation(self.linear1(src)[0])))\n src = src + self.dropout2(src2)\n src = self.norm2(src)\n return src\n\n\ndef _get_clones(module, N):\n return ModuleList([copy.deepcopy(module) for i in range(N)])\n\n\ndef _get_activation_fn(activation):\n if activation == \"relu\":\n return F.relu\n elif activation == \"gelu\":\n return F.gelu\n\n raise RuntimeError(\"activation should be relu/gelu, not {}\".format(activation))\n \nclass SingleTransformer(nn.Module):\n\n def __init__(self, input_size, dim_feedforward):\n super(SingleTransformer, self).__init__()\n\n self.transformer = TransformerEncoderLayer(d_model=input_size, nhead=4, dim_feedforward=dim_feedforward, dropout=0)\n\n def forward(self, input):\n # input shape: batch, seq, dim\n output = input\n output = self.transformer(output.permute(1, 0, 2).contiguous()).permute(1, 0, 2).contiguous()\n return output\n \n# dual-path Transformer\nclass DPTNet(nn.Module):\n def __init__(self, input_size, hidden_size, output_size, \n dropout=0, num_layers=1):\n super(DPTNet, self).__init__()\n \n self.input_size = input_size\n self.output_size = output_size\n self.hidden_size = hidden_size\n \n # dual-path Transformer\n self.row_xfmr = nn.ModuleList([])\n self.col_xfmr = nn.ModuleList([])\n for i in range(num_layers):\n self.row_xfmr.append(SingleTransformer(input_size=input_size, dim_feedforward=hidden_size))\n self.col_xfmr.append(SingleTransformer(input_size=input_size, dim_feedforward=hidden_size))\n \n self.output = nn.Conv2d(input_size, output_size, 1)\n \n def forward(self, input):\n # input shape: batch, N, dim1, dim2\n # apply RNN on dim1 first and then dim2\n \n batch_size, _, dim1, dim2 = input.shape\n output = input\n for i in range(len(self.row_xfmr)):\n row_input = output.permute(0,3,2,1).contiguous().view(batch_size*dim2, dim1, -1) # B*dim2, dim1, N\n row_output = self.row_xfmr[i](row_input) # B*dim2, dim1, H\n row_output = row_output.view(batch_size, dim2, dim1, -1).permute(0,3,2,1).contiguous() # B, N, dim1, dim2\n output = output + row_output\n \n col_input = output.permute(0,2,3,1).contiguous().view(batch_size*dim1, dim2, -1) # B*dim1, dim2, N\n col_output = self.col_xfmr[i](col_input) # B*dim1, dim2, H\n col_output = col_output.view(batch_size, dim1, dim2, -1).permute(0,3,1,2).contiguous() # B, N, dim1, dim2\n output = output + col_output\n \n output = self.output(output)\n \n return output", "meta": {"hexsha": "96be258db69da3ce5652b05580c0e8766bdf15d2", "size": 8442, "ext": "py", "lang": "Python", "max_stars_repo_path": "utility/DPTNet.py", "max_stars_repo_name": "yluo42/GC3", "max_stars_repo_head_hexsha": "3ae841395be99d0378852092c0b6e885a7bff9a2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 41, "max_stars_repo_stars_event_min_datetime": "2020-12-15T07:29:33.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-09T04:09:55.000Z", "max_issues_repo_path": "utility/DPTNet.py", "max_issues_repo_name": "yluo42/GC3", "max_issues_repo_head_hexsha": "3ae841395be99d0378852092c0b6e885a7bff9a2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-11-06T11:59:57.000Z", "max_issues_repo_issues_event_max_datetime": "2021-11-06T11:59:57.000Z", "max_forks_repo_path": "utility/DPTNet.py", "max_forks_repo_name": "yluo42/GC3", "max_forks_repo_head_hexsha": "3ae841395be99d0378852092c0b6e885a7bff9a2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2021-01-28T11:36:05.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-09T13:06:53.000Z", "avg_line_length": 40.3923444976, "max_line_length": 123, "alphanum_fraction": 0.635631367, "include": true, "reason": "import numpy", "num_tokens": 2047, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5312093733737563, "lm_q2_score": 0.3738758227716966, "lm_q1q2_score": 0.19860634153415052}} {"text": "'''\nSome tools to conveniently transform lmfit.Parameters into GalSim.Image's.\n'''\n\nimport copy\n\nimport numpy as np\nfrom scipy.optimize import newton\nimport galsim\nimport lmfit\n\nimport chroma\n\nclass GalTool(object):\n ''' Some generic utilities for drawing ringtest images using GalSim and measuring second moment\n radii.\n '''\n def __init__(self):\n # Subclasses of GalTool must initialize the following:\n #\n # attributes\n # ----------\n # stamp_size - Integer number of pixels in which to draw images\n # pixel_scale - arcsec / pixel\n # PSF - either a ChromaticObject or an effective PSF as a GSObject.\n # offset - tuple defining subpixel offset of image origin from center\n # gsparams - galsim.GSParams instance defining parameters for GalSim.\n #\n # methods\n # -------\n # _gparam_to_galsim - turn lmfit.Parameters into a galsim.GSObject or\n # galsim.ChromaticObject\n raise NotImplementedError(\"ABC GalTool must be instatiated through a subclass.\")\n\n def get_image(self, gparam, ring_beta=None, ring_shear=None, oversample=1):\n ''' Draw a galaxy image using GalSim. Potentially rotate and shear the galaxy as part of a\n ring test. Optionally draw a high-resolution image.\n\n @param gparam An lmfit.Parameters object that will be used to initialize a GalSim\n object.\n @param ring_beta Angle around ellipticity ring in ring test.\n @param ring_shear galsim.Shear to apply after rotation as part of ring test.\n @param oversample Integer factor by which to scale output image resolution and size.\n @returns galsim.Image\n '''\n # Setup image\n stamp_size = self.stamp_size * oversample\n pixel_scale = self.pixel_scale / float(oversample)\n im = galsim.ImageD(stamp_size, stamp_size, scale=pixel_scale)\n # Get GalSim parameterization of the galaxy.\n gal = self._gparam_to_galsim(gparam)\n # Rotate and shear the galaxy as per the ring test specifications.\n if ring_beta is not None:\n gal = gal.rotate(ring_beta / 2.0 * galsim.radians)\n if ring_shear is not None:\n gal = gal.shear(ring_shear)\n # Convolve with the (chromatic, or effective) PSF. This will need to be different for the\n # double Sersic case.\n final = galsim.Convolve(gal, self.PSF)\n # And draw the image.\n if isinstance(final, galsim.ChromaticObject):\n final.drawImage(self.bandpass, image=im, offset=self.offset)\n elif isinstance(final, galsim.GSObject):\n final.drawImage(image=im, offset=self.offset)\n else:\n raise ValueError(\"Don't recognize galaxy object type in GalTool.\")\n return im\n\n def get_PSF_image(self, oversample=1, method='auto'):\n ''' Draw an image of the effective PSF. Note that the returned PSF includes convolution\n by the pixel response function by default, though this can be overriden using the method\n keywords (e.g., method='fft').\n\n @param oversample Integer factor by which to scale output image resolution and size.\n @param method Method string to pass to galsim drawImage command.\n @returns galsim.Image\n '''\n stamp_size = self.stamp_size * oversample\n pixel_scale = self.pixel_scale / float(oversample)\n im = galsim.ImageD(stamp_size, stamp_size, scale=pixel_scale)\n if isinstance(self.PSF, galsim.ChromaticObject):\n star = galsim.Gaussian(fwhm=1.e-8) * self.SED\n final = galsim.Convolve(star, self.PSF)\n final.drawImage(self.bandpass, image=im, method=method)\n elif isinstance(self.PSF, galsim.GSObject):\n self.PSF.drawImage(image=im, method=method)\n else:\n raise ValueError(\"Don't recognize galaxy object type.\")\n return im\n\n def get_r2(self, gparam, oversample=1):\n ''' Compute object second moment radius sqrt(r^2) directly from image. This may be biased\n if the object wings are significant or the postage stamp size is too small.\n\n @param gparam An lmfit.Parameters object that will be used to initialize a GalSim object.\n @returns Second moment radius (in arcsec)\n '''\n im = self.get_image(gparam, oversample=oversample)\n mx, my, mxx, myy, mxy = chroma.moments(im)\n return np.sqrt(mxx + myy)\n\n def get_uncvl_image(self, gparam, ring_beta=None, ring_shear=None, oversample=1, center=False):\n ''' Draw a galaxy image, not convolved with a PSF, using GalSim. Potentially rotate and\n shear the galaxy as part of a ring test. Optionally draw a high-resolution image.\n\n @param gparam An lmfit.Paramters object that will be used to initialize a GalSim object.\n @param ring_beta Angle around ellipticity ring in ring test.\n @param ring_shear Shear to apply after rotation as part of ring test. (type=?)\n @param oversample Integer factor by which to scale output image resolution and size.\n @param center Force center of profile to (0,0).\n @returns galsim.Image\n '''\n stamp_size = self.stamp_size * oversample\n pixel_scale = self.pixel_scale / float(oversample)\n im = galsim.ImageD(stamp_size, stamp_size, scale=pixel_scale)\n gal = self._gparam_to_galsim(gparam)\n if center:\n centroid = gal.centroid(self.bandpass)\n gal = gal.shift(-centroid)\n if ring_beta is not None:\n gal = gal.rotate(ring_beta / 2.0 * galsim.radians)\n if ring_shear is not None:\n gal = gal.shear(ring_shear)\n if isinstance(gal, galsim.ChromaticObject):\n gal.drawImage(self.bandpass, image=im, offset=self.offset)\n elif isinstance(gal, galsim.GSObject):\n gal.drawImage(image=im, offset=self.offset)\n else:\n raise ValueError(\"Don't recognize galaxy object type in GalTool.\")\n return im\n\n def get_uncvl_r2(self, gparam, oversample=1):\n ''' Compute object second moment radius directly from image. This may be biased if the\n object wings are significant or the postage stamp size is too small.\n\n @param gparam An lmfit.Parameters object that will be used to initialize a GalSim object.\n @returns Second moment radius (in arcsec)\n '''\n im = self.get_uncvl_image(gparam, oversample=oversample)\n mx, my, mxx, myy, mxy = chroma.moments(im)\n return np.sqrt(mxx + myy)\n\n def compute_AHM(self, gparam, oversample=4):\n ''' Compute the area above half maximum of the convolved image.\n '''\n original_offset = self.offset\n original_scale = self.pixel_scale\n ahms = []\n for i in range(10):\n itry = 0\n while itry < 10:\n xdither = np.random.uniform(-0.5, 0.5, 1)[0]\n ydither = np.random.uniform(-0.5, 0.5, 1)[0]\n rescale = np.random.uniform(0.9, 1.1, 1)[0]\n self.offset = (xdither, ydither)\n self.pixel_scale = original_scale * rescale\n try:\n im = self.get_image(gparam, oversample=oversample)\n except RuntimeError:\n itry += 1\n else:\n break\n if itry >= 10:\n raise RuntimeError(\"Unable to create image to estimate AHM\")\n mx = im.array.max()\n ahms.append(self.pixel_scale**2 * (im.array > mx/2.0).sum() / oversample**2)\n self.offset = original_offset\n self.pixel_scale = original_scale\n return np.mean(ahms), np.std(ahms)/np.sqrt(len(ahms))\n\n def compute_FWHM(self, gparam, oversample=4):\n ''' Compute FWHM of the convolved galaxy image.\n '''\n ahm, err = self.compute_AHM(gparam, oversample=oversample)\n fwhm = np.sqrt(4.0/np.pi * ahm)\n return fwhm, fwhm * err/ahm * 0.5\n\n def compute_PSF_AHM(self, oversample=4):\n ''' Compute the area above half maximum of the PSF.\n '''\n original_offset = self.offset\n original_scale = self.pixel_scale\n ahms = []\n for i in range(10):\n itry = 0\n while itry < 10:\n xdither = np.random.uniform(-0.5, 0.5, 1)[0]\n ydither = np.random.uniform(-0.5, 0.5, 1)[0]\n rescale = np.random.uniform(0.9, 1.1, 1)[0]\n self.offset = (xdither, ydither)\n self.pixel_scale = original_scale * rescale\n try:\n im = self.get_PSF_image(oversample=oversample)\n except RuntimeError:\n itry += 1\n else:\n break\n if itry >= 10:\n raise RuntimeError(\"Unable to create image to estimate AHM\")\n if isinstance(im, list):\n im = sum(im)\n mx = im.array.max()\n ahms.append(self.pixel_scale**2 * (im.array > mx/2.0).sum() / oversample**2)\n self.offset = original_offset\n self.pixel_scale = original_scale\n return np.mean(ahms), np.std(ahms)/np.sqrt(len(ahms))\n\n def compute_PSF_FWHM(self, oversample=4):\n ''' Compute FWHM of the PSF.\n '''\n ahm, err = self.compute_PSF_AHM(oversample=oversample)\n fwhm = np.sqrt(4.0/np.pi * ahm)\n return fwhm, fwhm * err/ahm * 0.5\n\n def compute_HLA(self, gparam, oversample=4, flux=None):\n ''' Compute the half-light-area of the PSF-convolved galaxy image.\n I.e., the area of the contour containing half the image light.\n '''\n im = self.get_image(gparam, oversample=oversample)\n if flux is None:\n flux = im.array.sum()\n pixel_values = im.array.ravel()\n pixel_values.sort()\n cumulative_sum = np.cumsum(pixel_values[::-1])\n npix = np.interp(0.5, cumulative_sum, np.arange(len(cumulative_sum)))\n return npix * self.pixel_scale**2 / oversample**2\n\n def compute_HLR(self, gparam, oversample=4, flux=None):\n ''' Compute the half-light-radius of the PSF-convolved galaxy image.\n '''\n return np.sqrt(1.0/np.pi * self.compute_HLA(gparam, oversample, flux))\n\n def compute_uncvl_HLA(self, gparam, oversample=4, flux=None):\n ''' Compute the half-light-area of the unconvolved galaxy image.\n I.e., the area of the contour containing half the image light.\n '''\n im = self.get_uncvl_image(gparam, oversample=oversample)\n if flux is None:\n flux = im.array.sum()\n pixel_values = im.array.ravel()\n pixel_values.sort()\n cumulative_sum = np.cumsum(pixel_values[::-1])\n npix = np.interp(0.5, cumulative_sum, np.arange(len(cumulative_sum)))\n return npix * self.pixel_scale**2 / oversample**2\n\n def compute_uncvl_HLR(self, gparam, oversample=4, flux=None):\n ''' Compute the half-light-radius of the unconvolved galaxy image.\n '''\n return np.sqrt(1.0/np.pi * self.compute_uncvl_HLA(gparam, oversample, flux))\n\n\nclass SersicTool(GalTool):\n def __init__(self, PSF, stamp_size, pixel_scale, offset=(0,0),\n SED=1.0, bandpass=None, gsparams=None):\n self.PSF = PSF\n self.stamp_size = stamp_size\n self.pixel_scale = pixel_scale\n self.offset = offset\n self.gsparams = gsparams\n self.SED = SED\n self.bandpass = bandpass\n\n def _gparam_to_galsim(self, gparam):\n # Turn lmfit.Parameters into a galsim.ChromaticObject\n gal = galsim.Sersic(n=gparam['n'].value,\n half_light_radius=gparam['hlr'].value,\n gsparams=self.gsparams)\n gal = gal.shear(g=gparam['g'].value, beta=gparam['phi'].value * galsim.radians)\n gal = gal.shift(gparam['x0'].value, gparam['y0'].value)\n gal = gal.withFlux(gparam['flux'].value) * self.SED\n return gal\n\n def set_FWHM(self, gparam, FWHM, oversample=4):\n ''' Set the galaxy PSF-convolved FWHM.\n '''\n def FWHM_resid(scale):\n g1 = copy.deepcopy(gparam)\n g1['hlr'].value *= scale\n current_FWHM = self.compute_FWHM(g1, oversample=oversample)\n return current_FWHM[0] - FWHM\n scale = newton(FWHM_resid, 1.0, tol=0.001)\n gparam['hlr'].value *= scale\n return gparam\n\n def set_r2(self, gparam, r2, oversample=4):\n ''' Set the second moment radius sqrt(r^2).\n\n @param gparam lmfit.Parameters object describing galaxy.\n @param r2 Target second moment radius sqrt(r^2)\n @param oversample Factor by which to oversample drawn image for computation.\n @returns New lmfit.Parameters object.\n '''\n def r2_resid(scale):\n g1 = copy.deepcopy(gparam)\n g1['hlr'].value *= scale\n current_r2 = self.get_r2(g1, oversample=oversample)\n return current_r2 - r2\n scale = newton(r2_resid, 1.0)\n gparam['hlr'].value *= scale\n return gparam\n\n def get_uncvl_r2(self, gparam):\n ''' Get second moment radius sqrt(r^2) of pre-PSF-convolved profile using polynomial\n approximation.\n @gparam lmfit.Parameters\n '''\n return gparam['hlr'].value * chroma.Sersic_r2_over_hlr(gparam['n'].value)\n\n def set_uncvl_r2(self, gparam, r2):\n ''' Set the second moment radius sqrt(r^2) of the pre-PSF-convolved profile using\n polynomial approximation.\n\n @param gparam lmfit.Parameters object describing galaxy.\n @param r2 Target second moment square radius\n @param oversample Factor by which to oversample drawn image for r2 computation.\n @returns New lmfit.Parameters object.\n '''\n gparam1 = copy.deepcopy(gparam)\n r2_now = self.get_uncvl_r2(gparam)\n scale = r2 / r2_now\n gparam1['hlr'].value = gparam['hlr'].value * scale\n return gparam1\n\n def get_ring_params(self, gparam, ring_beta, ring_shear):\n ''' Compute initial guess parameters for given angle around ellipticity ring during a ring\n test.\n\n @param gparam lmfit.Parameters object describing galaxy.\n @param ring_beta Angle around ellipticity ring in ring test.\n @param ring_shear Shear to apply after rotation as part of ring test. (type=?)\n @returns New lmfit.Parameters object.\n '''\n gparam1 = copy.deepcopy(gparam)\n rot_phi = gparam['phi'].value + ring_beta/2.0\n # complex ellipticity\n c_ellip = gparam['g'].value * complex(np.cos(2.0 * rot_phi), np.sin(2.0 * rot_phi))\n c_gamma = ring_shear.g1 + 1j * ring_shear.g2\n # sheared complex ellipticity\n s_c_ellip = chroma.apply_shear(c_ellip, c_gamma)\n s_g = abs(s_c_ellip)\n s_phi = np.angle(s_c_ellip) / 2.0\n\n gparam1['x0'].value \\\n = gparam['x0'].value * np.cos(ring_beta / 2.0) \\\n - gparam['y0'].value * np.sin(ring_beta / 2.0)\n gparam1['y0'].value \\\n = gparam['x0'].value * np.sin(ring_beta / 2.0) \\\n + gparam['y0'].value * np.cos(ring_beta / 2.0)\n gparam1['g'].value = s_g\n gparam1['phi'].value = s_phi\n return gparam1\n\n @staticmethod\n def default_galaxy():\n '''Setup lmfit.Parameters to represent a single Sersic galaxy. Pick some default\n parameter values. Parameters defining the single Sersic galaxy are:\n x0 - the x-coordinate of the galaxy center\n y0 - the y-coordinate of the galaxy center\n n - the Sersic index. 0.5 gives a Gaussian profile, 1.0 gives an exponential profile,\n 4.0 gives a de Vaucouleurs profile.\n hlr - the galaxy half-light-radius. This is strictly speaking the half light radius of\n a circularly symmetric profile of the given Sersic index `n`.\n g - the magnitude of the galaxy ellipticity given in `g` units as used by GalSim. In\n this convention, the major/minor axis ratio is given by: b/a = (1 - g) / (1 + g)\n phi - the position angle of the galaxy major axis in radians. 0 indicates that the major\n axis is along the x-axis.\n '''\n gparam = lmfit.Parameters()\n gparam.add('x0', value=0.0)\n gparam.add('y0', value=0.0)\n gparam.add('n', value=4.0, vary=False)\n gparam.add('hlr', value=0.27)\n gparam.add('flux', value=1.0, vary=False)\n gparam.add('g', value=0.2, min=0.0, max=1.0)\n gparam.add('phi', value=0.0)\n return gparam\n\n def use_effective_PSF(self):\n ''' Integrate a chromatic PSF over wavelength to yield an effective PSF. Galsim is doing\n this internally anyway, but we do this explicitly here so that it happens only once, instead\n of every time a .drawImage command is executed.\n '''\n star = galsim.Gaussian(fwhm=1.e-8) * self.SED\n prof = galsim.Convolve(star, self.PSF)\n prof0 = prof.evaluateAtWavelength(self.bandpass.effective_wavelength)\n scale = prof0.nyquistScale()\n N = prof0.SBProfile.getGoodImageSize(scale, 1.0)\n im = galsim.ImageD(N, N, scale=scale)\n # careful, don't want to convolve by pixel twice!\n prof.drawImage(self.bandpass, image=im, method='no_pixel')\n self.PSF = galsim.InterpolatedImage(im) # remember the effective PSF\n\n def apply_perturbative_correction(self, r2byr2=1.0, Vstar=1.e-8, Vgal=1.e-8,\n parang=0.0*galsim.degrees):\n if isinstance(self.PSF, galsim.ChromaticObject):\n star = galsim.Gaussian(fwhm=1.e-8) * self.SED\n prof = galsim.Convolve(star, self.PSF)\n elif isinstance(self.PSF, galsim.GSObject):\n prof = self.PSF\n else:\n raise ValueError(\"Don't recognize galaxy object type.\")\n\n #-----------------------\n # Stellar DCR correction\n\n # `q` is the axis ratio of a 2D Gaussian representing the 1D DCR kernel. In principle, this\n # should be 0.0, but we need to set it to some small value for computability.\n q = 1.e-4\n sigma = (q * Vstar)**0.5\n kernel = galsim.Gaussian(sigma=sigma)\n kernel = kernel.shear(g1=-(1-q)/(1+q))\n kernel = kernel.rotate(parang)\n prof = galsim.Convolve(galsim.Deconvolve(kernel), prof)\n\n #----------------------------\n # Chromatic Seeing correction\n prof = prof.dilate(np.sqrt(r2byr2))\n\n #------------------------\n # Galactic DCR correction\n sigma = (q * Vgal)**0.5\n kernel = galsim.Gaussian(sigma=sigma)\n kernel = kernel.shear(g1=-(1-q)/(1+q))\n kernel = kernel.rotate(parang)\n prof = galsim.Convolve(kernel, prof)\n\n # and draw into an InterpolatedImage\n prof0 = prof.evaluateAtWavelength(self.bandpass.effective_wavelength)\n scale = prof0.nyquistScale()\n N = prof0.SBProfile.getGoodImageSize(scale, 1.0)\n im = galsim.ImageD(N*9, N*9, scale=scale*0.3)\n if isinstance(prof, galsim.ChromaticObject):\n prof.drawImage(self.bandpass, image=im, method='no_pixel')\n else:\n prof.drawImage(image=im, method='no_pixel')\n self.PSF = galsim.InterpolatedImage(im)\n\n\n# Note that DoubleSersicTool and FastDoubleSersicTool are both currently untested.\nclass DoubleSersicTool(GalTool):\n ''' A GalTool to represent a sum of two chroma Sersic profiles.\n '''\n def __init__(self, PSF, stamp_size, pixel_scale, offset=(0,0), SED1=1.0, SED2=1.0,\n bandpass=None, gsparams=None):\n ''' Initialize a single Sersic profile chromatic galaxy.\n\n @param PSF galsim.ChromaticObject representing chromatic PSF\n @param stamp_size Draw images this many pixels square\n @param pixel_scale Pixels are this wide in arcsec.\n @param offset Offset the center of the profile by this amount\n @param SED1 Optional galsim.SED galaxy spectrum for first component\n @param SED2 Optional galsim.SED galaxy spectrum for second component\n @param bandpass Optional galsim.Bandpass to represent filter being imaged through.\n '''\n self.SED1 = SED1\n self.SED2 = SED2\n self.bandpass = bandpass\n self.PSF = PSF\n self.stamp_size = stamp_size\n self.pixel_scale = pixel_scale\n self.offset = offset\n self.gsparams = gsparams\n self.sersictools = [SersicTool(PSF, stamp_size, pixel_scale, offset=offset,\n SED=SED1, bandpass=bandpass, gsparams=gsparams),\n SersicTool(PSF, stamp_size, pixel_scale, offset=offset,\n SED=SED2, bandpass=bandpass, gsparams=gsparams)]\n\n def indiv_gparam(self, gparam, icomp):\n out = lmfit.Parameters()\n search_string = \"_{}\".format(icomp+1)\n for p in gparam:\n if p.endswith(search_string):\n out.add(p.replace(search_string, ''), value=gparam[p].value)\n return out\n\n def get_image(self, gparam, ring_beta=None, ring_shear=None, oversample=1, icomp=None):\n ''' Draw a galaxy image using GalSim. Potentially rotate and shear the galaxy as part of a\n ring test. Optionally draw a high-resolution image.\n\n @param gparam An lmfit.Parameters object that will be used to initialize a GalSim\n object.\n @param ring_beta Angle around ellipticity ring in ring test.\n @param ring_shear galsim.Shear to apply after rotation as part of ring test.\n @param oversample Integer factor by which to scale output image resolution and size.\n @param icomp Which component to return the image of.\n @returns galsim.Image\n '''\n if icomp is not None:\n return self.sersictools[icomp].get_image(\n self.indiv_gparam(gparam, icomp), ring_beta, ring_shear, oversample)\n else:\n im1 = self.sersictools[0].get_image(self.indiv_gparam(gparam, 0), ring_beta, ring_shear,\n oversample)\n im2 = self.sersictools[1].get_image(self.indiv_gparam(gparam, 1), ring_beta, ring_shear,\n oversample)\n return im1+im2\n\n def use_effective_PSF(self):\n ''' Integrate chromatic PSF over wavelength to yield effective PSFs. GalSim is doing\n this internally anyway, but we do this explicitly here so that it happens only once, instead\n of every time a .drawImage() command is executed.\n '''\n for s in self.sersictools:\n s.use_effective_PSF()\n self.PSF = [s.PSF for s in self.sersictools]\n\n def get_PSF_image(self, oversample=1, method='auto', icomp=None):\n ''' Draw an image of both effective PSFs. Note that the returned PSFs include convolution\n by the pixel response function, by default, though this can be overriden using the method\n keyword (e.g., method='fft').\n\n @param oversample Integer factor by which to scale output image resolution and size.\n @returns (im1, im2) Both effective PSFs corresponding to both component SEDs.\n '''\n if icomp is not None:\n return self.sersictools[icomp].get_PSF_image(oversample, method)\n else:\n return [s.get_PSF_image(oversample, method) for s in self.sersictools]\n\n def set_FWHM(self, gparam, FWHM, oversample=4, icomp=None):\n ''' Set the galaxy PSF-convolved FWHM.\n '''\n if icomp is not None:\n igparam = self.sersictools[icomp].set_FWHM(indiv_gparam(gparam, icomp), FWHM,\n oversample)\n gparam = self.set_indiv_gparam('hlr', icomp, igparam['hlr'].value)\n return gparam\n else:\n def FWHM_resid(scale):\n g1 = copy.deepcopy(gparam)\n g1['hlr_1'].value *= scale\n g1['hlr_2'].value *= scale\n current_FWHM = self.compute_FWHM(g1, oversample=oversample)\n return current_FWHM[0] - FWHM\n scale = newton(FWHM_resid, 1.0, tol=0.01)\n gparam['hlr_1'].value *= scale\n gparam['hlr_2'].value *= scale\n return gparam\n\n def set_r2(self, gparam, r2, oversample=4):\n ''' Set the second moment radius sqrt(r^2).\n\n @param gparam lmfit.Parameters object describing galaxy.\n @param r2 Target second moment radius sqrt(r^2)\n @param oversample Factor by which to oversample drawn image for r2 computation.\n @returns New lmfit.Parameters object.\n '''\n def r2_resid(scale):\n g1 = copy.deepcopy(gparam)\n g1['hlr_1'].value *= scale\n g1['hlr_2'].value *= scale\n current_r2 = self.get_r2(g1, oversample=oversample)\n return current_r2 - r2\n scale = newton(r2_resid, 1.0)\n gparam['hlr_1'].value *= scale\n gparam['hlr_2'].value *= scale\n return gparam\n\n def get_uncvl_r2(self, gparam):\n ''' Get second moment radius of pre-PSF-convolved profile using polynomial approximation.\n @gparam lmfit.Parameters\n '''\n return chroma.component_Sersic_r2([gparam['n_1'].value, gparam['n_2'].value],\n [gparam['flux_1'].value, gparam['flux_2'].value],\n [gparam['hlr_1'].value, gparam['hlr_2'].value])\n\n def set_uncvl_r2(self, gparam, r2):\n ''' Set the second moment square radius of the pre-PSF-convolved profile using polynomial\n approximation.\n\n @param gparam lmfit.Parameters object describing galaxy.\n @param r2 Target second moment radius sqrt(r^2)\n @param oversample Factor by which to oversample drawn image for computation.\n @returns New lmfit.Parameters object.\n '''\n gparam1 = copy.deepcopy(gparam)\n r2_now = self.get_uncvl_r2(gparam)\n scale = r2 / r2_now\n gparam1['hlr_1'].value *= scale\n gparam1['hlr_2'].value *= scale\n return gparam1\n\n def get_ring_params(self, gparam, ring_beta, ring_shear):\n ''' Compute initial guess parameters for given angle around ellipticity ring during a ring\n test.\n\n @param gparam lmfit.Parameters object describing galaxy.\n @param ring_beta Angle around ellipticity ring in ring test.\n @param ring_shear Shear to apply after rotation as part of ring test. (type=?)\n @returns New lmfit.Parameters object.\n '''\n gparam1 = copy.deepcopy(gparam)\n\n rot_phi1 = gparam['phi_1'].value + ring_beta/2.0\n # complex ellipticity\n c_ellip1 = gparam['g_1'].value * complex(np.cos(2.0 * rot_phi1), np.sin(2.0 * rot_phi1))\n c_gamma1 = ring_shear.g1 + 1j * ring_shear.g2\n # sheared complex ellipticity\n s_c_ellip1 = chroma.apply_shear(c_ellip1, c_gamma1)\n s_g1 = abs(s_c_ellip1)\n s_phi1 = np.angle(s_c_ellip1) / 2.0\n\n gparam1['x0_1'].value \\\n = gparam['x0_1'].value * np.cos(ring_beta / 2.0) \\\n - gparam['y0_1'].value * np.sin(ring_beta / 2.0)\n gparam1['y0_1'].value \\\n = gparam['x0_1'].value * np.sin(ring_beta / 2.0) \\\n + gparam['y0_1'].value * np.cos(ring_beta / 2.0)\n gparam1['g_1'].value = s_g1\n gparam1['phi_1'].value = s_phi1\n\n rot_phi2 = gparam['phi_2'].value + ring_beta/2.0\n # complex ellipticity\n c_ellip2 = gparam['g_2'].value * \\\n complex(np.cos(2.0 * rot_phi2), np.sin(2.0 * rot_phi2))\n c_gamma2 = ring_shear.g2 + 1j * ring_shear.g2\n # sheared complex ellipticity\n s_c_ellip2 = chroma.apply_shear(c_ellip2, c_gamma2)\n s_g2 = abs(s_c_ellip2)\n s_phi2 = np.angle(s_c_ellip2) / 2.0\n\n gparam1['x0_2'].value \\\n = gparam['x0_2'].value * np.cos(ring_beta / 2.0) \\\n - gparam['y0_2'].value * np.sin(ring_beta / 2.0)\n gparam1['y0_2'].value \\\n = gparam['x0_2'].value * np.sin(ring_beta / 2.0) \\\n + gparam['y0_2'].value * np.cos(ring_beta / 2.0)\n gparam1['g_2'].value = s_g2\n gparam1['phi_2'].value = s_phi2\n\n return gparam1\n\n @staticmethod\n def default_galaxy():\n '''Setup lmfit.Parameters to represent a double Sersic galaxy. Pick some default\n parameter values. Parameters for each Sersic galaxy component are:\n x0 - the x-coordinate of the galaxy center\n y0 - the y-coordinate of the galaxy center\n n - the Sersic index. 0.5 gives a Gaussian profile, 1.0 gives an exponential profile,\n 4.0 gives a de Vaucouleurs profile.\n hlr - the galaxy half-light-radius. This is strictly speaking the half light radius of\n a circularly symmetric profile of the given Sersic index `n`.\n g - the magnitude of the galaxy ellipticity given in `g` units as used by GalSim. In\n this convention, the major/minor axis ratio is given by: b/a = (1 - g) / (1 + g)\n phi - the position angle of the galaxy major axis in radians. 0 indicates that the major\n axis is along the x-axis.\n Parameters for the first component will have suffix _1, parameters for the second component\n will have suffix _2. By default, the two components are constrained to by concentric and\n coelliptical. Similar to the single Sersic case, the total flux and both Sersic indices are\n fixed by default.\n '''\n gparam = lmfit.Parameters()\n # bulge first\n gparam.add('x0_1', value=0.0)\n gparam.add('y0_1', value=0.0)\n gparam.add('n_1', value=4.0, vary=False)\n gparam.add('hlr_1', value=0.3, min=0.0)\n gparam.add('flux_1', value=0.25, min=0.0, max=1.0)\n gparam.add('g_1', value=0.2, min=0.0, max=1.0)\n gparam.add('phi_1', value=0.0)\n # then disk\n gparam.add('x0_2', expr='x0_1')\n gparam.add('y0_2', expr='y0_1')\n gparam.add('n_2', value=1.0, vary=False)\n gparam.add('hlr_2', value=0.4, min=0.0)\n gparam.add('flux_2', expr='1.0 - flux_1')\n gparam.add('g_2', expr='g_1')\n gparam.add('phi_2', expr='phi_1')\n #initialize constrained variables\n dummyfit = lmfit.Minimizer(lambda x: 0, gparam)\n dummyfit.prepare_fit()\n return gparam\n", "meta": {"hexsha": "bd7064e576274114972b84bf8a105fb07e2242a1", "size": 30855, "ext": "py", "lang": "Python", "max_stars_repo_path": "chroma/galtool.py", "max_stars_repo_name": "DarkEnergyScienceCollaboration/chroma", "max_stars_repo_head_hexsha": "64fc123a065334b307654f29b3bea52885b46ec8", "max_stars_repo_licenses": ["BSD-2-Clause", "BSD-3-Clause"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2015-10-22T14:57:27.000Z", "max_stars_repo_stars_event_max_datetime": "2016-08-25T08:16:02.000Z", "max_issues_repo_path": "chroma/galtool.py", "max_issues_repo_name": "DarkEnergyScienceCollaboration/chroma", "max_issues_repo_head_hexsha": "64fc123a065334b307654f29b3bea52885b46ec8", "max_issues_repo_licenses": ["BSD-2-Clause", "BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2017-08-28T14:42:46.000Z", "max_issues_repo_issues_event_max_datetime": "2017-08-28T16:08:37.000Z", "max_forks_repo_path": "chroma/galtool.py", "max_forks_repo_name": "DarkEnergyScienceCollaboration/chroma", "max_forks_repo_head_hexsha": "64fc123a065334b307654f29b3bea52885b46ec8", "max_forks_repo_licenses": ["BSD-2-Clause", "BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 45.8469539376, "max_line_length": 101, "alphanum_fraction": 0.6080700049, "include": true, "reason": "import numpy,from scipy", "num_tokens": 8098, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5813031051514762, "lm_q2_score": 0.3415825061409754, "lm_q1q2_score": 0.19856297148517218}} {"text": "'''\nSoft Actor-Critic version 2\nusing target Q instead of V net: 2 Q net, 2 target Q net, 1 policy net\nadd alpha loss compared with version 1\npaper: https://arxiv.org/pdf/1812.05905.pdf\n'''\n\n\nimport math\nimport random\n\n# import gym\nimport numpy as np\n\nimport torch\nimport torch.nn as nn\nimport torch.optim as optim\nimport torch.nn.functional as F\nfrom torch.distributions import Normal\nfrom torch.utils.tensorboard import SummaryWriter\n\n# from IPython.display import clear_output\n# import matplotlib.pyplot as plt\n# from matplotlib import animation\n# from IPython.display import display\n# from reacher import Reacher\n\nimport argparse\nimport time\n\nimport simulation as sim\nfrom Environment import Environment\n\nimport actuator_array as act\nfrom init import action_dim,state_dim\n\n\nGPU = True\ndevice_idx = 2\nif GPU:\n device = torch.device(\"cuda:\" + str(device_idx) if torch.cuda.is_available() else \"cpu\")\nelse:\n device = torch.device(\"cpu\")\nprint(device)\n\n\nparser = argparse.ArgumentParser(description='Train or test neural net motor controller.')\nparser.add_argument('--train', dest='train', action='store_true', default=False)\nparser.add_argument('--test', dest='test', action='store_true', default=False)\n\nargs = parser.parse_args()\n\n\nclass ReplayBuffer:\n def __init__(self, capacity):\n self.capacity = capacity\n self.buffer = []\n self.position = 0\n \n def push(self, state, action, reward, next_state, done):\n if len(self.buffer) < self.capacity:\n self.buffer.append(None)\n self.buffer[self.position] = (state, action, reward, next_state, done)\n self.position = int((self.position + 1) % self.capacity) # as a ring buffer\n \n def sample(self, batch_size):\n batch = random.sample(self.buffer, batch_size)\n state, action, reward, next_state, done = map(np.stack, zip(*batch)) # stack for each element\n ''' \n the * serves as unpack: sum(a,b) <=> batch=(a,b), sum(*batch) ;\n zip: a=[1,2], b=[2,3], zip(a,b) => [(1, 2), (2, 3)] ;\n the map serves as mapping the function on each list element: map(square, [2,3]) => [4,9] ;\n np.stack((1,2)) => array([1, 2])\n '''\n return state, action, reward, next_state, done\n \n def __len__(self):\n return len(self.buffer)\n\n\nclass SoftQNetwork(nn.Module):\n def __init__(self, num_inputs, num_actions, hidden_size, init_w=3e-3):\n super(SoftQNetwork, self).__init__()\n \n self.linear1 = nn.Linear(num_inputs + num_actions, hidden_size)\n self.linear2 = nn.Linear(hidden_size, hidden_size)\n self.linear3 = nn.Linear(hidden_size, hidden_size)\n self.linear4 = nn.Linear(hidden_size, 1)\n \n self.linear4.weight.data.uniform_(-init_w, init_w)\n self.linear4.bias.data.uniform_(-init_w, init_w)\n \n def forward(self, state, action):\n x = torch.cat([state, action], 1) # the dim 0 is number of samples\n x = F.relu(self.linear1(x))\n x = F.relu(self.linear2(x))\n x = F.relu(self.linear3(x))\n x = self.linear4(x)\n return x\n \n \nclass PolicyNetwork(nn.Module):\n def __init__(self, num_inputs, num_actions, hidden_size, action_range=1., init_w=3e-3, log_std_min=-20, log_std_max=2):\n super(PolicyNetwork, self).__init__()\n \n self.log_std_min = log_std_min\n self.log_std_max = log_std_max\n \n self.linear1 = nn.Linear(num_inputs, hidden_size)\n self.linear2 = nn.Linear(hidden_size, hidden_size)\n self.linear3 = nn.Linear(hidden_size, hidden_size)\n self.linear4 = nn.Linear(hidden_size, hidden_size)\n\n self.mean_linear = nn.Linear(hidden_size, num_actions)\n self.mean_linear.weight.data.uniform_(-init_w, init_w)\n self.mean_linear.bias.data.uniform_(-init_w, init_w)\n \n self.log_std_linear = nn.Linear(hidden_size, num_actions)\n self.log_std_linear.weight.data.uniform_(-init_w, init_w)\n self.log_std_linear.bias.data.uniform_(-init_w, init_w)\n\n self.action_range = action_range\n self.num_actions = num_actions\n\n \n def forward(self, state):\n x = F.relu(self.linear1(state))\n x = F.relu(self.linear2(x))\n x = F.relu(self.linear3(x))\n x = F.relu(self.linear4(x))\n\n mean = (self.mean_linear(x))\n # mean = F.leaky_relu(self.mean_linear(x))\n log_std = self.log_std_linear(x)\n log_std = torch.clamp(log_std, self.log_std_min, self.log_std_max)\n \n return mean, log_std\n \n def evaluate(self, state, epsilon=1e-6):\n '''\n generate sampled action with state as input wrt the policy network;\n '''\n mean, log_std = self.forward(state)\n std = log_std.exp() # no clip in evaluation, clip affects gradients flow\n \n normal = Normal(0, 1)\n z = normal.sample(mean.shape) \n action_0 = torch.tanh(mean + std*z.to(device)) # TanhNormal distribution as actions; reparameterization trick\n action = self.action_range*action_0 + 30 ### 加偏置\n # The log-likelihood here is for the TanhNorm distribution instead of only Gaussian distribution. \\\n # The TanhNorm forces the Gaussian with infinite action range to be finite. \\\n # For the three terms in this log-likelihood estimation: \\\n # (1). the first term is the log probability of action as in common \\\n # stochastic Gaussian action policy (without Tanh); \\\n # (2). the second term is the caused by the Tanh(), \\\n # as shown in appendix C. Enforcing Action Bounds of https://arxiv.org/pdf/1801.01290.pdf, \\\n # the epsilon is for preventing the negative cases in log; \\\n # (3). the third term is caused by the action range I used in this code is not (-1, 1) but with \\\n # an arbitrary action range, which is slightly different from original paper.\n log_prob = Normal(mean, std).log_prob(mean+ std*z.to(device)) - torch.log((1. - action_0.pow(2))/2 + epsilon)\n # both dims of normal.log_prob and -log(1-a**2) are (N,dim_of_action); \n # the Normal.log_prob outputs the same dim of input features instead of 1 dim probability, \n # needs sum up across the features dim to get 1 dim prob; or else use Multivariate Normal.\n log_prob = log_prob.sum(dim=1, keepdim=True)\n return action, log_prob, z, mean, log_std\n \n \n def get_action(self, state, deterministic):\n state = torch.FloatTensor(state).unsqueeze(0).to(device)\n mean, log_std = self.forward(state)\n std = log_std.exp()\n \n normal = Normal(0, 1)\n z = normal.sample(mean.shape).to(device)\n action = self.action_range* torch.tanh(mean + std*z)\n \n action = self.action_range* torch.tanh(mean).detach().cpu().numpy()[0] if deterministic else action.detach().cpu().numpy()[0]\n action = action + 30\n return action\n\n\n def sample_action(self,):\n a=torch.FloatTensor(self.num_actions).uniform_(-1, 1)\n return self.action_range*a.numpy()\n\n\nclass SAC_Trainer():\n def __init__(self, replay_buffer, hidden_dim, action_range):\n self.replay_buffer = replay_buffer\n\n self.soft_q_net1 = SoftQNetwork(state_dim, action_dim, hidden_dim).to(device)\n self.soft_q_net2 = SoftQNetwork(state_dim, action_dim, hidden_dim).to(device)\n self.target_soft_q_net1 = SoftQNetwork(state_dim, action_dim, hidden_dim).to(device)\n self.target_soft_q_net2 = SoftQNetwork(state_dim, action_dim, hidden_dim).to(device)\n self.policy_net = PolicyNetwork(state_dim, action_dim, hidden_dim, action_range).to(device)\n self.log_alpha = torch.zeros(1, dtype=torch.float32, requires_grad=True, device=device)\n print('Soft Q Network (1,2): ', self.soft_q_net1)\n print('Policy Network: ', self.policy_net)\n\n for target_param, param in zip(self.target_soft_q_net1.parameters(), self.soft_q_net1.parameters()):\n target_param.data.copy_(param.data)\n for target_param, param in zip(self.target_soft_q_net2.parameters(), self.soft_q_net2.parameters()):\n target_param.data.copy_(param.data)\n\n self.soft_q_criterion1 = nn.MSELoss()\n self.soft_q_criterion2 = nn.MSELoss()\n\n soft_q_lr = 3e-4\n policy_lr = 3e-4\n alpha_lr = 3e-4\n\n self.soft_q_optimizer1 = optim.Adam(self.soft_q_net1.parameters(), lr=soft_q_lr)\n self.soft_q_optimizer2 = optim.Adam(self.soft_q_net2.parameters(), lr=soft_q_lr)\n self.policy_optimizer = optim.Adam(self.policy_net.parameters(), lr=policy_lr)\n self.alpha_optimizer = optim.Adam([self.log_alpha], lr=alpha_lr)\n\n \n def update(self, batch_size, reward_scale=10., auto_entropy=True, target_entropy=-2, gamma=0.99,soft_tau=1e-2):\n state, action, reward, next_state, done = self.replay_buffer.sample(batch_size)\n # print('sample:', state, action, reward, done)\n\n state = torch.FloatTensor(state).to(device)\n next_state = torch.FloatTensor(next_state).to(device)\n action = torch.FloatTensor(action).to(device)\n reward = torch.FloatTensor(reward).unsqueeze(1).to(device) # reward is single value, unsqueeze() to add one dim to be [reward] at the sample dim;\n done = torch.FloatTensor(np.float32(done)).unsqueeze(1).to(device)\n\n action = action / 60\n reward = reward / 20\n\n predicted_q_value1 = self.soft_q_net1(state, action)\n predicted_q_value2 = self.soft_q_net2(state, action)\n new_action, log_prob, z, mean, log_std = self.policy_net.evaluate(state)\n new_next_action, next_log_prob, _, _, _ = self.policy_net.evaluate(next_state)\n\n new_action = new_action / 60\n new_next_action = new_next_action / 60\n\n # reward = reward_scale * (reward - reward.mean(dim=0)) / (reward.std(dim=0) + 1e-6) # normalize with batch mean and std; plus a small number to prevent numerical problem\n # Updating alpha wrt entropy\n # alpha = 0.0 # trade-off between exploration (max entropy) and exploitation (max Q) \n if auto_entropy is True:\n alpha_loss = -(self.log_alpha * (log_prob + target_entropy).detach()).mean()\n # print('alpha loss: ',alpha_loss)\n self.alpha_optimizer.zero_grad()\n alpha_loss.backward()\n self.alpha_optimizer.step()\n self.alpha = self.log_alpha.exp()\n else:\n self.alpha = 1.\n alpha_loss = 0\n\n # Training Q Function\n target_q_min = torch.min(self.target_soft_q_net1(next_state, new_next_action),self.target_soft_q_net2(next_state, new_next_action)) - self.alpha * next_log_prob\n target_q_value = reward + (1 - done) * gamma * target_q_min # if done==1, only reward\n q_value_loss1 = self.soft_q_criterion1(predicted_q_value1, target_q_value.detach()) # detach: no gradients for the variable\n q_value_loss2 = self.soft_q_criterion2(predicted_q_value2, target_q_value.detach())\n\n\n self.soft_q_optimizer1.zero_grad()\n q_value_loss1.backward()\n self.soft_q_optimizer1.step()\n\n self.soft_q_optimizer2.zero_grad()\n q_value_loss2.backward()\n self.soft_q_optimizer2.step() \n\n # Training Policy Function\n predicted_new_q_value = torch.min(self.soft_q_net1(state, new_action),self.soft_q_net2(state, new_action))\n policy_loss = (self.alpha * log_prob - predicted_new_q_value).mean()\n\n self.policy_optimizer.zero_grad()\n policy_loss.backward()\n self.policy_optimizer.step()\n \n # print('q loss: ', q_value_loss1, q_value_loss2)\n # print('policy loss: ', policy_loss )\n\n\n # Soft update the target value net\n for target_param, param in zip(self.target_soft_q_net1.parameters(), self.soft_q_net1.parameters()):\n target_param.data.copy_( # copy data value into target parameters\n target_param.data * (1.0 - soft_tau) + param.data * soft_tau\n )\n for target_param, param in zip(self.target_soft_q_net2.parameters(), self.soft_q_net2.parameters()):\n target_param.data.copy_( # copy data value into target parameters\n target_param.data * (1.0 - soft_tau) + param.data * soft_tau\n )\n return predicted_new_q_value.mean().item(),q_value_loss1.item(),q_value_loss2.item(),policy_loss.item(),self.alpha.item()\n\n def save_model(self, path):\n torch.save(self.soft_q_net1.state_dict(), path+'_q1')\n torch.save(self.soft_q_net2.state_dict(), path+'_q2')\n torch.save(self.policy_net.state_dict(), path+'_policy')\n\n def load_model(self, path):\n self.soft_q_net1.load_state_dict(torch.load(path+'_q1'))\n self.soft_q_net2.load_state_dict(torch.load(path+'_q2'))\n self.policy_net.load_state_dict(torch.load(path+'_policy'))\n\n self.soft_q_net1.eval()\n self.soft_q_net2.eval()\n self.policy_net.eval()\n\n\n\n\nreplay_buffer_size = 1e6\nreplay_buffer = ReplayBuffer(replay_buffer_size)\n\n# choose env\nENV = ['Reacher', 'Pendulum-v0', 'HalfCheetah-v2'][2]\n\nact_array = act.Actuator_array() \nenv = Environment()\naction_space = [action_dim]\nstate_space = [state_dim]\naction_range = 30\n\n# hyper-parameters for RL training\nmax_episodes = 5e6\nmax_steps = 1e3 # Pendulum needs 150 steps per episode to learn well, cannot handle 20\nframe_idx = 0\nbatch_size = 64 \nexplore_steps = -1 # for random action sampling in the beginning of training\nupdate_itr = 1\nAUTO_ENTROPY=True\nDETERMINISTIC=False\nhidden_dim = 512\nrewards = []\nmodel_path = './model/SAC_1_28_3'\n\n\nq_value_episode = np.array([])\nq_value_loss1_episode = np.array([])\nq_value_loss2_episode = np.array([])\npolicy_loss_episode = np.array([])\nalpha_log_episode = np.array([])\nwriter = SummaryWriter('./logs/SAC_1_28_3')\ntmp_avg_reward = 0\n\nsac_trainer=SAC_Trainer(replay_buffer, hidden_dim=hidden_dim, action_range=action_range )\n\n\nif __name__ == '__main__':\n if 1:\n # training loop\n for eps in range(int(max_episodes)):\n if ENV == 'Reacher':\n state = env.reset(SCREEN_SHOT)\n else:\n state = env.reset()\n episode_reward = 0\n \n\n for step in range(int(max_steps)):\n if frame_idx > explore_steps:\n action = sac_trainer.policy_net.get_action(state, deterministic = DETERMINISTIC)\n else:\n action = sac_trainer.policy_net.sample_action()\n if ENV == 'Reacher':\n next_state, reward, done, _ = env.step(action, SPARSE_REWARD, SCREEN_SHOT)\n else:\n next_state, reward, done = env.step(action)\n # env.render() \n \n done = 0\n replay_buffer.push(state, action, reward, next_state, done)\n \n state = next_state\n episode_reward += reward\n frame_idx += 1\n \n \n if len(replay_buffer) > batch_size:\n for i in range(update_itr):\n q_value,q_value_loss1,q_value_loss2,policy_loss,alpha_log = sac_trainer.update(batch_size, reward_scale=10., auto_entropy=AUTO_ENTROPY, target_entropy=-1.*action_dim)\n q_value_episode = np.append(q_value_episode,q_value)\n q_value_loss1_episode = np.append(q_value_loss1_episode,q_value_loss1)\n q_value_loss2_episode = np.append(q_value_loss2_episode,q_value_loss2)\n policy_loss_episode = np.append(policy_loss_episode,policy_loss)\n alpha_log_episode = np.append(alpha_log_episode,alpha_log)\n # if done:\n # break\n\n writer.add_scalar('train/reward', episode_reward, eps)\n writer.add_scalar('train/q_value', q_value_episode.mean(), eps)\n writer.add_scalar('loss/critic_1', q_value_loss1_episode.mean(), eps)\n writer.add_scalar('loss/critic_2', q_value_loss2_episode.mean(), eps)\n writer.add_scalar('loss/policy', policy_loss_episode.mean(), eps)\n writer.add_scalar('train/alpha', alpha_log_episode.mean(), eps)\n\n print('Episode: ', eps, '| Episode Reward: ', episode_reward)\n # rewards.append(episode_reward)\n\n if eps % 100 == 0 and eps>0: # 100个episode测试一次如果大于上一次的测试结果，储存下来\n avg_reward = 0.\n episodes = 3\n cal_dist_set = []\n state = env.reset()\n\n for _ in range(episodes):\n episode_reward = 0\n done = False\n for i in range(1000):\n action = sac_trainer.policy_net.get_action(state, deterministic = DETERMINISTIC)\n\n next_state, reward, done = env.step(action)\n episode_reward += reward\n \n state = next_state\n if done: ## 实际中不可能reset包裹 \n # state = env.reset()\n pass\n \n if env.evl_flag == 1: ## 有包裹过线\n cal_dist_set.append(env.cal_dist)\n env.evl_flag = 0\n\n avg_reward += episode_reward\n episode_reward = 0\n avg_reward /= episodes\n state = env.reset() ### 每个episode前都要reset,reset后需要加mask 之前忘记在测试完成后加reset了\n cal_dist_set = np.array(cal_dist_set)\n dist_success = cal_dist_set[cal_dist_set>=150]\n dist_fail = cal_dist_set[cal_dist_set<150]\n\n writer.add_scalar('avg_reward/test', avg_reward, eps)\n try:\n writer.add_histogram('delta_dist_success', dist_success, eps, bins = 500) # 看delta T是否收敛到设定值\n except:\n pass\n try:\n writer.add_histogram('delta_dist_fail', dist_fail, eps, bins = 500) # 看delta T是否收敛到设定值\n except:\n pass\n print(\"----------------------------------------\")\n print(\"Test Episodes: {}, Avg. Reward: {}, Avg. delta_dist: {}\".format(eps, round(avg_reward, 2),np.mean(cal_dist_set)))\n print(\"----------------------------------------\")\n if avg_reward > tmp_avg_reward: # 变大后保存模型\n tmp_avg_reward = avg_reward\n sac_trainer.save_model(model_path) ## 每次test完成后修改mode，及时测试避免错误\n print(\"saving model and highest average reward: {}\".format(tmp_avg_reward))\n \n\n # if args.test:\n # sac_trainer.load_model(model_path)\n # for eps in range(10):\n # if ENV == 'Reacher':\n # state = env.reset(SCREEN_SHOT)\n # else:\n # state = env.reset()\n # episode_reward = 0\n\n # for step in range(max_steps):\n # action = sac_trainer.policy_net.get_action(state, deterministic = DETERMINISTIC)\n # if ENV == 'Reacher':\n # next_state, reward, done, _ = env.step(action, SPARSE_REWARD, SCREEN_SHOT)\n # else:\n # next_state, reward, done, _ = env.step(action)\n # env.render() \n\n\n # episode_reward += reward\n # state=next_state\n\n # print('Episode: ', eps, '| Episode Reward: ', episode_reward)\n", "meta": {"hexsha": "fc09eedc72dd52bbb25ff2f4efabaea4368b7216", "size": 19814, "ext": "py", "lang": "Python", "max_stars_repo_path": "baseline/Deepset-SAC/SAC.py", "max_stars_repo_name": "rxlqn/Reinforcement-Learning-Based-Parcel-Singulation-with-Variable-State-Space-Dimension", "max_stars_repo_head_hexsha": "22b0ded9807dbc50d2da9852e80cda55fdc1d04c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-04-02T10:54:00.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-07T07:59:33.000Z", "max_issues_repo_path": "S3-SAC/SAC.py", "max_issues_repo_name": "rxlqn/Reinforcement-Learning-Based-Parcel-Singulation-with-Variable-State-Space-Dimension", "max_issues_repo_head_hexsha": "22b0ded9807dbc50d2da9852e80cda55fdc1d04c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-07-15T06:03:00.000Z", "max_issues_repo_issues_event_max_datetime": "2021-07-15T12:12:47.000Z", "max_forks_repo_path": "baseline/Deepset-SAC/SAC.py", "max_forks_repo_name": "rxlqn/Reinforcement-Learning-Based-Parcel-Singulation-with-Variable-State-Space-Dimension", "max_forks_repo_head_hexsha": "22b0ded9807dbc50d2da9852e80cda55fdc1d04c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.3376068376, "max_line_length": 190, "alphanum_fraction": 0.6165842334, "include": true, "reason": "import numpy", "num_tokens": 4613, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5813030906443133, "lm_q2_score": 0.3415825128436339, "lm_q1q2_score": 0.19856297042605522}} {"text": "#!/usr/bin/env python\nimport warnings\nwarnings.filterwarnings(\"ignore\")\nimport numpy as np\nfrom astropy.io import fits, ascii\nimport matplotlib.pyplot as plt\nfrom matplotlib.ticker import AutoMinorLocator\nimport smart\n#import splat\n#import splat.model as spmd\n\n#def _constructModelName(teff, logg, metal, en, order, path=None):\n# \"\"\"\n# Return the full name of the BT-Settl model.\n# \"\"\"\n# if path is None:\n# path = '/Users/dinohsu/projects/Models/models/btsettl08/' + \\\n# 'NIRSPEC-O' + str(order) + '-RAW/'\n# else:\n# path = path + '/NIRSPEC-O' + str(order) + '-RAW/'\n# full_name = path + 'btsettl08_t'+ str(teff) + '_g' + \\\n# '{0:.2f}'.format(float(logg)) + '_z-' + '{0:.2f}'.format(float(metal)) + \\\n# '_en' + '{0:.2f}'.format(float(en)) + '_NIRSPEC-O' + str(order) + '-RAW.txt'\n# \n# return full_name\n\nclass Model():\n \"\"\"\n The Model class reads in the BT-SETTL or PHOENIXACES models. \n The unit of wavelength is in Angstrom and the unit of the model flux is in erg/s/cm^2/Angstrom.\n (The models in the libraries have the unit of micron, which differed by 10^4 in flux)\n\n Parameters\n ----------\n 1. Read in a BT-Settl model or PHOENIXACES model.\n teff : float \n The effective temperature in Kelvins.\n logg : float\n The log(gravity), given in two decimal digits. \n Ex: logg=4.50\n metal : float\n The metalicity, given in two decimal digits. \n Ex. metal=0.00\n en : float\n alpha enhancement. given in two decimal digits. \n Ex. en=0.00\n\n modelset: str\n available models are \n NIRSPEC: 'btsettl08', 'SONORA_2018'\n APOGEE: 'btsettl08', 'marcs-apogee-dr15', 'phoenix-aces-agss-cond-2011', 'phoenix-btsettl-cifist2011-2015'\n\n order: int\n This is only for the Keck/NIRSPEC. The order of the model, given from 29 to 80\n\n path : str\n The path to the model\n\n 2. Creat a model instance with given wavelengths and fluxes\n flux : astropy.table.column.Column\n The input flux.\n wave : astropy.table.column.Column\n The input wavelength.\n\n Returns\n -------\n flux : astropy.table.column.Column\n The flux retrieved from the model. Our default unit is erg/s/cm^2/Angstrom.\n wave : astropy.table.column.Column\n The wavelength retrieved from the model. Our default unit is Angstrom.\n\n Examples\n --------\n >>> import smart\n >>> model = smart.Model(teff=2300, logg=5.5, order=33, path='/path/to/models')\n >>> model.plot()\n \"\"\"\n def __init__(self, **kwargs):\n self.path = kwargs.get('path')\n self.order = kwargs.get('order')\n self.instrument = kwargs.get('instrument','nirspec')\n\n if self.order != None and self.instrument == 'nirspec':\n self.teff = kwargs.get('teff', 2500)\n self.logg = kwargs.get('logg', 5.00)\n self.metal = kwargs.get('metal', 0.00)\n self.en = kwargs.get('en', 0.00)\n self.modelset = kwargs.get('modelset', 'btsettl08')\n\n wave, flux = smart.forward_model.InterpolateModel.InterpModel(self.teff, self.logg, self.metal, self.en,\n modelset=self.modelset, order=self.order, instrument=self.instrument)\n #elif self.metal != 0.0:\n # wave, flux = smart.forward_model.InterpolateModel.InterpModel(Teff=self.teff, Logg=self.logg, Metal=self.metal,\n # modelset=self.modelset, order=self.order, instrument=self.instrument)\n \n if self.modelset == 'btsettl08':\n self.wave = wave * 10000 #convert to Angstrom\n self.flux = flux / 10000 #convert from erg/s/cm^2/micron to erg/s/cm^2/Angstrom\n else:\n self.wave = wave\n self.flux = flux\n\n elif self.instrument == 'apogee':\n self.teff = kwargs.get('teff', 2500)\n self.logg = kwargs.get('logg', 5.00)\n self.metal = kwargs.get('metal', 0.00)\n self.en = kwargs.get('en', 0.00)\n self.modelset = kwargs.get('modelset', 'btsettl08')\n\n #wave, flux = smart.forward_model.InterpolateModel.InterpModel(self.teff, self.logg,\n # modelset=self.modelset, order=self.order, instrument=self.instrument)\n\n wave, flux = smart.forward_model.InterpolateModel.InterpModel(self.teff, self.logg, self.metal, self.en,\n modelset=self.modelset, order=self.order, instrument=self.instrument)\n\n if self.modelset == 'btsettl08':\n self.wave = wave * 10000 #convert to Angstrom\n self.flux = flux / 10000 #convert from erg/s/cm^2/micron to erg/s/cm^2/Angstrom \n\n else:\n self.wave = wave # Angstrom\n self.flux = flux # erg/s/cm^2/Angstrom\n\n else:\n self.wave = kwargs.get('wave', [])\n self.flux = kwargs.get('flux', [])\n \n\n def plot(self, **kwargs):\n \"\"\"\n Plot the model spectrum.\n \"\"\"\n if self.order != None:\n name = str(_constructModelName(self.teff, self.logg, \n self.metal, self.en, self.order, self.path))\n output = kwargs.get('output', str(name) + '.pdf')\n ylim = kwargs.get('yrange', [min(self.flux)-.2, max(self.flux)+.2])\n title = kwargs.get('title')\n save = kwargs.get('save', False)\n \n plt.figure(figsize=(16,6))\n plt.plot(self.wave, self.flux, color='k', \n alpha=.8, linewidth=1, label=name)\n plt.legend(loc='upper right', fontsize=12)\n plt.ylim(ylim) \n \n minor_locator = AutoMinorLocator(5)\n #ax.xaxis.set_minor_locator(minor_locator)\n # plt.grid(which='minor') \n \n plt.xlabel(r'$\\lambda$ [$\\mathring{A}$]', fontsize=18)\n plt.ylabel(r'$Flux$', fontsize=18)\n #plt.ylabel(r'$F_{\\lambda}$ [$erg/s \\cdot cm^{2}$]', fontsize=18)\n if title != None:\n plt.title(title, fontsize=20)\n plt.tight_layout()\n\n if save == True:\n plt.savefig(output)\n plt.show()\n plt.close()\n\n else:\n output = kwargs.get('output'+ '.pdf')\n ylim = kwargs.get('yrange', [min(self.flux)-.2, max(self.flux)+.2])\n title = kwargs.get('title')\n save = kwargs.get('save', False)\n \n plt.figure(figsize=(16,6))\n plt.plot(self.wave, self.flux, color='k', alpha=.8, linewidth=1)\n plt.legend(loc='upper right', fontsize=12)\n plt.ylim(ylim)\n \n minor_locator = AutoMinorLocator(5)\n #ax.xaxis.set_minor_locator(minor_locator)\n # plt.grid(which='minor') \n \n plt.xlabel(r'$\\lambda$ [$\\mathring{A}$]', fontsize=18)\n plt.ylabel(r'$Flux$', fontsize=18)\n #plt.ylabel(r'$F_{\\lambda}$ [$erg/s \\cdot cm^{2}$]', fontsize=18)\n if title != None:\n plt.title(title, fontsize=20)\n plt.tight_layout()\n\n if save == True:\n plt.savefig(output)\n plt.show()\n plt.close()\n\n\n", "meta": {"hexsha": "9d4e9e5be670b11d464ac4a610308ada1e6f72ae", "size": 7425, "ext": "py", "lang": "Python", "max_stars_repo_path": "smart/forward_model/classModel.py", "max_stars_repo_name": "Lingfeng-Wei/smart", "max_stars_repo_head_hexsha": "2316e50bfb6f050d5dcdd0ee1e5eab6831e8a669", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 10, "max_stars_repo_stars_event_min_datetime": "2020-01-21T09:09:54.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-12T18:24:02.000Z", "max_issues_repo_path": "smart/forward_model/classModel.py", "max_issues_repo_name": "Lingfeng-Wei/smart", "max_issues_repo_head_hexsha": "2316e50bfb6f050d5dcdd0ee1e5eab6831e8a669", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 9, "max_issues_repo_issues_event_min_datetime": "2020-02-07T19:03:11.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-07T01:21:56.000Z", "max_forks_repo_path": "smart/forward_model/classModel.py", "max_forks_repo_name": "Lingfeng-Wei/smart", "max_forks_repo_head_hexsha": "2316e50bfb6f050d5dcdd0ee1e5eab6831e8a669", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-07-22T21:54:39.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-11T05:16:53.000Z", "avg_line_length": 38.8743455497, "max_line_length": 143, "alphanum_fraction": 0.5511111111, "include": true, "reason": "import numpy,from astropy", "num_tokens": 1880, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5813031051514763, "lm_q2_score": 0.34158249943831703, "lm_q1q2_score": 0.1985629675888961}} {"text": "\"\"\"\nThe crux of ``coronagraph`` noise modeling is to determine the photon count rate\nincident upon the detector due to both the target planet and an assortment of\ndifferent telescope, instrumental, and astrophysical noise sources.\nThe following classes and functions serve as your interface to the photon count\nrate calculations. The core function for these calculations is\n:func:`count_rates`, but it may be accessed using the :class:`CoronagraphNoise`\nobject.\n\"\"\"\n\nfrom __future__ import (division as _, print_function as _,\n absolute_import as _, unicode_literals as _)\n\n# Import dependent modules\nimport numpy as np\nimport sys, os\nimport matplotlib.pyplot as plt\n\nfrom .degrade_spec import downbin_spec\nfrom .convolve_spec import convolve_spec\nfrom .noise_routines import Fstar, Fplan, FpFs, cplan, czodi, cezodi, cspeck, \\\n cdark, cread, ctherm, ccic, f_airy, ctherm_earth, construct_lam, \\\n set_quantum_efficiency, set_read_noise, set_dark_current, set_lenslet, \\\n set_throughput, set_atmos_throughput, \\\n exptime_element, get_sky_flux\nfrom .teleplanstar import Telescope, Planet, Star\n\n__all__ = ['count_rates', 'CoronagraphNoise']\n\nclass CoronagraphNoise(object):\n \"\"\"\n The primary interface for ``coronagraph`` noise modeling. This object wraps\n around the functionality of :func:`count_rates`. Simply instantiate a\n `CoronagraphNoise` object by passing it :class:`telescope`, :class:`planet`,\n and :class:`star` objects, and then call\n :func:`CoronagraphNoise.run_count_rates` to perform the photon count rate\n calculation.\n\n Parameters\n ----------\n telescope : Telescope\n Initialized object containing ``Telescope`` parameters\n planet : Planet\n Initialized object containing ``Planet`` parameters\n star : Star\n Initialized object containing ``Star`` parameters\n texp : float\n Exposure time for which to generate synthetic data [hours]\n wantsnr : float, optional\n Desired signal-to-noise ratio in each pixel\n FIX_OWA : bool, optional\n Set to fix OWA at ``OWA*lammin/D``, as would occur if lenslet array is\n limiting the OWA\n COMPUTE_LAM : bool, optional\n Set to compute lo-res wavelength grid, otherwise the grid input as\n variable ``lam`` is used\n SILENT : bool, optional\n Set to suppress print statements\n NIR : bool, optional\n Re-adjusts pixel size in NIR, as would occur if a second instrument\n was designed to handle the NIR\n THERMAL : bool, optional\n Set to compute thermal photon counts due to telescope temperature\n GROUND : bool, optional\n Set to simulate ground-based observations through atmosphere\n vod : bool, optional\n \"Valley of Death\" red QE parameterization from Robinson et al. (2016)\n set_fpa : float, optional\n Specify the fraction of planetary signal in Airy pattern, default will\n calculate it from the photometric aperture size `X`\n roll_maneuver : bool, optional\n This assumes an extra factor of 2 hit to the background noise due to a\n telescope roll maneuver needed to subtract out the background. See\n Brown (2005) for more details.\n\n Note\n ----\n The results of the coronagraph noise calculation will become available as\n attributes of the :class:`CoronagraphNoise` object after\n :func:`CoronagraphNoise.run_count_rates` is called.\n \"\"\"\n def __init__(self, telescope = Telescope(), planet = Planet(),\n star = Star(), texp = 10.0, wantsnr=10.0, FIX_OWA = False,\n COMPUTE_LAM = False, SILENT = False, NIR = False,\n THERMAL = True, GROUND = False, vod=False, set_fpa=None,\n roll_maneuver = True):\n \"\"\"\n \"\"\"\n self.telescope = telescope\n self.planet = planet\n self.star = star\n self.texp = texp\n self.wantsnr = wantsnr\n self.FIX_OWA = FIX_OWA\n self.COMOUTE_LAM = COMPUTE_LAM\n self.SILENT = SILENT\n self.NIR = NIR\n self.THERMAL = THERMAL\n self.GROUND = GROUND\n self.vod = vod\n self.set_fpa = set_fpa\n self.roll_maneuver = roll_maneuver\n\n self._computed = False\n\n return\n\n def run_count_rates(self, Ahr, lamhr, solhr):\n \"\"\"\n Calculate the photon count rates and signal to noise on a\n coronagraph observation given a wavelength-dependent planetary\n geometric albedo and stellar flux density.\n\n Parameters\n ----------\n Ahr : array\n High-res, wavelength-dependent planetary geometric albedo\n lamhr : array\n High-res wavelength grid [um]\n solhr : array\n High-res TOA solar spectrum [W/m**2/um]\n\n\n Calling ``run_count_rates()`` creates the following attributes for\n the ``CoronagraphNoise`` instance:\n\n Attributes\n ----------\n Ahr : array\n High-res, wavelength-dependent planetary geometric albedo\n lamhr : array\n High-res wavelength grid [um]\n solhr : array\n High-res TOA solar spectrum [W/m**2/um]\n lam : array\n Observed wavelength grid [$\\mu$m]\n dlam : array\n Observed wavelength grid widths [$\\mu$m]\n A : array\n Planetary geometric albedo at observed resolution\n Cratio : array\n Planet-to-star flux contrast ratio\n cp : array\n Planetary photon count rate [photons/s]\n csp : array\n Speckle count rate [photons/s]\n cz : array\n Zodi photon count rate [photons/s]\n cez : array\n Exo-zodi photon count rate [photons/s]\n cth : array\n Thermal photon count rate [photons/s]\n cD : array\n Dark current photon count rate [photons/s]\n cR : array\n Read noise photon count rate [photons/s]\n cc : array\n Clock induced charge photon count rate [photons/s]\n cb : array\n Total background photon noise count rate [photons/s]\n DtSNR : array\n Integration time to ``wantsnr`` [hours]\n SNRt : array\n S/N in a ``texp`` hour exposure\n Aobs : array\n Observed albedo with noise\n Asig : array\n Observed uncertainties on albedo\n Cobs : array\n Observed Fp/Fs with noise\n Csig : array\n Observed uncertainties on Fp/Fs\n \"\"\"\n\n # Save input arrays\n self.Ahr = Ahr\n self.lamhr = lamhr\n self.solhr = solhr\n\n # Aperture logic\n accepted_circular = [\"circular\", \"circ\", \"c\"]\n accepted_square = [\"square\", \"s\"]\n if self.telescope.aperture.lower() in accepted_circular:\n CIRC = True\n elif self.telescope.aperture.lower() in accepted_square:\n CIRC = False\n else:\n assert False, \"telescope.aperture is invalid\"\n\n # Call count_rates\n lam, dlam, A, q, Cratio, cp, csp, cz, cez, cD, cR, cth, cc, DtSNR = \\\n count_rates(Ahr, lamhr, solhr,\n alpha = self.planet.alpha,\n Phi = self.planet.Phi,\n Rp = self.planet.Rp,\n Teff = self.star.Teff,\n Rs = self.star.Rs,\n r = self.planet.a,\n d = self.planet.distance,\n Nez = self.planet.Nez,\n mode = self.telescope.mode,\n filter_wheel = self.telescope.filter_wheel,\n lammin = self.telescope.lammin,\n lammax = self.telescope.lammax,\n Res = self.telescope.resolution,\n diam = self.telescope.diameter,\n Tput = self.telescope.throughput,\n C = self.telescope.contrast,\n IWA = self.telescope.IWA,\n OWA = self.telescope.OWA,\n Tsys = self.telescope.Tsys,\n Tdet = self.telescope.Tdet,\n emis = self.telescope.emissivity,\n De = self.telescope.darkcurrent,\n DNHpix = self.telescope.DNHpix,\n Re = self.telescope.readnoise,\n Rc = self.telescope.Rc,\n Dtmax = self.telescope.Dtmax,\n X = self.telescope.X,\n qe = self.telescope.qe,\n MzV = self.planet.MzV,\n MezV = self.planet.MezV,\n A_collect = self.telescope.A_collect,\n diam_circumscribed = self.telescope.diam_circumscribed,\n diam_inscribed = self.telescope.diam_inscribed,\n lam = self.telescope.lam,\n dlam = self.telescope.dlam,\n Tput_lam = self.telescope.Tput_lam,\n qe_lam = self.telescope.qe_lam,\n lammin_lenslet = self.telescope.lammin_lenslet,\n NIR = self.NIR,\n GROUND = self.GROUND,\n THERMAL = self.THERMAL,\n CIRC = CIRC,\n roll_maneuver = self.roll_maneuver,\n SILENT = self.SILENT,\n wantsnr = self.wantsnr\n )\n\n # Save output arrays\n self.lam = lam\n self.dlam = dlam\n self.A = A\n self.Cratio = Cratio\n self.cp = cp\n self.csp = csp\n self.cz = cz\n self.cez = cez\n self.cD = cD\n self.cR = cR\n self.cth = cth\n self.cc = cc\n self.cb = cz + cez + csp + cD + cR + cth + cc\n self.DtSNR = DtSNR\n\n # Flip the switch\n self._computed = True\n\n # Make an initial set of fake data\n self.make_fake_data()\n\n return\n\n def make_fake_data(self, texp = None):\n \"\"\"\n Make a fake/synthetic dataset by sampling from a Gaussian.\n\n Parameters\n ----------\n texp : float, optional\n Exposure time [hours]. If not provided, the ``CoronagraphNoise.texp``\n will be used by default.\n\n\n Calling ``make_fake_data()`` creates the following attributes for\n the ``CoronagraphNoise`` instance:\n\n Attributes\n ----------\n SNRt : array\n S/N in a ``texp`` hour exposure\n Aobs : array\n Observed albedo with noise\n Asig : array\n Observed uncertainties on albedo\n Cobs : array\n Observed Fp/Fs with noise\n Csig : array\n Observed uncertainties on Fp/Fs\n \"\"\"\n\n # Ensure that simulation has been run\n assert self._computed\n\n # Allow new exposure time\n if texp is not None:\n self.texp = texp\n\n # Convert exposure time to seconds\n Dt = 3600. * self.texp\n\n # Use telescope roll maneuver\n if self.roll_maneuver:\n # assuming background subtraction (the \"2\")\n roll_factor = 2.0\n else:\n # standard background noise\n roll_factor = 1.0\n\n # Calculate signal-to-noise\n SNRt = self.cp * Dt / np.sqrt((self.cp + roll_factor*self.cb) * Dt)\n\n # Calculate 1-sigma errors on contrast ratio and albedo\n Csig = self.Cratio/SNRt\n Asig = self.A/SNRt\n\n # Calculate Gaussian noise\n gaus = np.random.randn(len(self.Cratio))\n\n # Add gaussian noise to observed data\n Cobs = self.Cratio + Csig * gaus\n Aobs = self.A + Asig * gaus\n\n # Save attributes\n self.SNRt = SNRt\n self.Asig = Asig\n self.Aobs = Aobs\n self.Csig = Csig\n self.Cobs = Cobs\n\n return\n\n def plot_spectrum(self, SNR_threshold = 1.0, Nsig = 6.0, ax0 = None,\n err_kws = {\"fmt\" : \".\", \"c\" : \"k\", \"alpha\" : 1},\n plot_kws = {\"lw\" : 1.0, \"c\" : \"C4\", \"alpha\" : 0.5},\n draw_box = True):\n \"\"\"\n Plot noised direct-imaging spectrum.\n\n Parameters\n ----------\n SNR_threshold : float\n Threshold SNR below which do not plot\n Nsig : float\n Number of standard deviations about median observed points to set\n yaxis limits\n ax0 : `matplotlib.axes`\n Optional axis to provide\n err_kws : dic\n Keyword arguments for `errorbar`\n plot_kws : dic\n Keyword arguments for `plot`\n draw_box : bool\n Draw important quantities in a box?\n\n Returns\n -------\n fig : `matplotlib.figure.Figure`\n Returns a figure if `ax0` is `None`\n ax : `matplotlib.axes`\n Returns an axis if `ax0` is `None`\n\n Note\n ----\n Only returns `fig` and `ax` is ``ax0 is None``\n \"\"\"\n\n m = [self.SNRt > SNR_threshold]\n\n scale = 1\n\n if ax0 is None:\n # Create Plot\n fig, ax = plt.subplots(figsize = (10,8))\n ax.set_xlabel(r\"Wavelength [$\\mu$m]\")\n ax.set_ylabel(\"Geometic Albedo\")\n else:\n ax = ax0\n\n #ax.plot(lam, scale*RpRs2, alpha = 1.0, ls = \"steps-mid\")\n ax.errorbar(self.lam[m], scale*self.Aobs[m], yerr=scale*self.Asig[m], zorder = 100, **err_kws)\n #ax.set_yscale(\"log\")\n\n # Set ylim\n mederr = scale*np.median(self.Asig)\n medy = scale*np.median(self.Aobs)\n ax.set_ylim([medy - Nsig*mederr, medy + Nsig*mederr])\n\n ylims = ax.get_ylim()\n xlims = ax.get_xlim()\n\n ax.plot(self.lamhr, scale*self.Ahr, **plot_kws)\n\n ax.set_ylim(ylims)\n ax.set_xlim(xlims)\n\n\n if draw_box:\n # Set string for plot text\n if self.texp > 2.0:\n timestr = \"{:.0f}\".format(self.texp)+' hours'\n else:\n timestr = \"{:.0f}\".format(self.texp*60)+' mins'\n plot_text = r'Distance = '+\"{:.1f}\".format(self.planet.distance)+' pc'+\\\n '\\n Integration time = '+timestr\n ax.text(0.02, 0.975, plot_text, transform=ax.transAxes, ha = \"left\", va = \"top\",\n bbox=dict(boxstyle=\"square\", fc=\"w\", ec=\"k\", alpha=0.9), zorder=101)\n\n #ax.legend()\n\n if ax0 is None:\n return fig, ax\n else:\n return\n\n def plot_SNR(self, ax0 = None, plot_kws = {\"ls\" : \"steps-mid\"}):\n \"\"\"\n Plot the S/N on the planet as a function of wavelength.\n\n Parameters\n ----------\n ax0 : `matplotlib.axes`\n Optional axis to provide\n plot_kws : dic\n Keyword arguments for `plot`\n\n Returns\n -------\n fig : `matplotlib.figure.Figure`\n Returns a figure if `ax0` is `None`\n ax : `matplotlib.axes`\n Returns an axis if `ax0` is `None`\n\n Note\n ----\n Only returns `fig` and `ax` is ``ax0 is None``\n \"\"\"\n if ax0 is None:\n # Create Plot\n fig, ax = plt.subplots(figsize = (10,8))\n else:\n ax = ax0\n\n ax.plot(self.lam, self.SNRt, **plot_kws)\n #ax.set_yscale(\"log\")\n ax.set_xlabel(r\"Wavelength [$\\mu$m]\")\n ax.set_ylabel(\"S/N on Planet Spectrum in %.1f hrs\" %self.texp)\n #ax.legend()\n\n if ax0 is None:\n return fig, ax\n else:\n return\n\n def plot_time_to_wantsnr(self, ax0 = None, plot_kws = {\"ls\" : \"steps-mid\", \"alpha\" : 1.0}):\n \"\"\"\n Plot the exposure time to get a SNR on the planet spectrum.\n\n Parameters\n ----------\n ax0 : `matplotlib.axes`\n Optional axis to provide\n plot_kws : dic\n Keyword arguments for `plot`\n\n Returns\n -------\n fig : `matplotlib.figure.Figure`\n Returns a figure if `ax0` is `None`\n ax : `matplotlib.axes`\n Returns an axis if `ax0` is `None`\n\n Note\n ----\n Only returns `fig` and `ax` is ``ax0 is None``\n \"\"\"\n\n if ax0 is None:\n # Create Plot\n fig, ax = plt.subplots(figsize = (10,8))\n ax.set_xlabel(r\"Wavelength [$\\mu$m]\")\n ax.set_ylabel(\"Hours to S/N = %i on Planet Spectrum\" %self.wantsnr)\n ax.set_yscale(\"log\")\n else:\n ax = ax0\n\n ax.plot(self.lam, self.DtSNR, **plot_kws)\n\n if ax0 is None:\n return fig, ax\n else:\n return\n\ndef count_rates(Ahr, lamhr, solhr,\n alpha, Phi, Rp, Teff, Rs, r, d, Nez,\n mode = \"IFS\",\n filter_wheel = None,\n lammin = 0.4,\n lammax = 2.5,\n Res = 70.0,\n diam = 10.0,\n Tput = 0.20,\n C = 1e-10,\n IWA = 3.0,\n OWA = 20.0,\n Tsys = 260.0,\n Tdet = 50.0,\n emis = 0.9,\n De = 1e-4,\n DNHpix = 3.0,\n Re = 0.1,\n Rc = 0.0,\n Dtmax = 1.0,\n X = 1.5,\n qe = 0.9,\n MzV = 23.0,\n MezV = 22.0,\n A_collect = None,\n diam_circumscribed = None,\n diam_inscribed = None,\n lam = None,\n dlam = None,\n Tput_lam = None,\n qe_lam = None,\n lammin_lenslet = None,\n wantsnr=10.0, FIX_OWA = False, COMPUTE_LAM = False,\n SILENT = False, NIR = False, THERMAL = False, GROUND = False,\n vod=False, set_fpa=None, CIRC = True, roll_maneuver = True):\n \"\"\"\n Runs coronagraph model (Robinson et al., 2016) to calculate planet and noise\n photon count rates for specified telescope and system parameters.\n\n Parameters\n ----------\n Ahr : array\n High-res, wavelength-dependent planetary geometric albedo\n lamhr : array\n High-res wavelength grid [um]\n solhr : array\n High-res TOA solar spectrum [W/m**2/um]\n alpha : float\n Planet phase angle [deg]\n Phi : float\n Planet phase function\n Rp : float\n Planet radius [R_earth]\n Teff : float\n Stellar effective temperature [K]\n Rs : float\n Stellar radius [R_sun]\n r : float\n Planet semi-major axis [AU]\n d : float\n Distance to observed star-planet system [pc]\n Nez : float\n Number of exozodis in exoplanetary disk\n mode : str, optional\n Telescope observing mode: \"IFS\" or \"Imaging\"\n filter_wheel : Wheel, optional\n Wheel object containing imaging filters\n lammin : float, optional\n Minimum wavelength [um]\n lammax : float, optional\n Maximum wavelength [um]\n Res : float, optional\n Instrument spectral resolution (``lam / dlam``)\n diam : float, optional\n Telescope diameter [m]\n Tput : float, optional\n Telescope and instrument throughput\n C : float, optional\n Coronagraph design contrast\n IWA : float, optional\n Coronagraph Inner Working Angle (``lam / diam``)\n OWA : float, optional\n Coronagraph Outer Working Angle (``lam / diam``)\n Tsys : float, optional\n Telescope mirror temperature [K]\n Tdet : float, optional\n Telescope detector temperature [K]\n emis : float, optional\n Effective emissivity for the observing system (of order unity)\n De : float, optional\n Dark current [counts/s]\n DNHpix : float, optional\n Number of horizontal/spatial pixels for dispersed spectrum\n Re : float, optional\n Read noise counts per pixel\n Rc : float, optional\n Clock induced charge [counts/pixel/photon]\n Dtmax : float, optional\n Detector maximum exposure time [hours]\n X : float, optional\n Width of photometric aperture (``lam / diam``)\n qe : float, optional\n Detector quantum efficiency\n MzV : float, optional\n V-band zodiacal light surface brightness [mag/arcsec**2]\n MezV : float, optional\n V-band exozodiacal light surface brightness [mag/arcsec**2]\n A_collect : float, optional\n Mirror collecting area (m**2) (uses :math:`\\pi(D/2)^2` by default)\n diam_circumscribed : float, optional\n Circumscribed telescope diameter [m] used for IWA and OWA (uses `diam`\n if `None` provided)\n diam_inscribed : float, optional\n Inscribed telescope diameter [m] used for lenslet calculations\n (uses `diam` if `None` provided)\n lam : array-like, optional\n Wavelength grid for spectrograph [microns] (uses ``lammin``, ``lammax``,\n and ``resolution`` to determine if ``None`` provided)\n dlam : array-like, optional\n Wavelength grid `widths` for spectrograph [microns] (uses ``lammin``, ``lammax``,\n and ``resolution`` to determine if ``None`` provided)\n Tput_lam : tuple of arrays\n Wavelength-dependent throughput e.g. ``(wls, tputs)``\n qe_lam : tuple of arrays\n Wavelength-dependent throughput e.g. ``(wls, qe)``\n lammin_lenslet : float, optional\n Minimum wavelength to use for lenslet calculation (default is ``lammin``)\n wantsnr : float, optional\n Desired signal-to-noise ratio in each pixel\n FIX_OWA : bool, optional\n Set to fix OWA at ``OWA*lammin/D``, as would occur if lenslet array is\n limiting the OWA\n COMPUTE_LAM : bool, optional\n Set to compute lo-res wavelength grid, otherwise the grid input as\n variable ``lam`` is used\n SILENT : bool, optional\n Set to suppress print statements\n NIR : bool, optional\n Re-adjusts pixel size in NIR, as would occur if a second instrument\n was designed to handle the NIR\n THERMAL : bool, optional\n Set to compute thermal photon counts due to telescope temperature\n GROUND : bool, optional\n Set to simulate ground-based observations through atmosphere\n vod : bool, optional\n \"Valley of Death\" red QE parameterization from Robinson et al. (2016)\n set_fpa : float, optional\n Specify the fraction of planetary signal in Airy pattern, default will\n calculate it from the photometric aperture size `X`\n CIRC : bool, optional\n Set to use a circular aperture\n roll_maneuver : bool, optional\n This assumes an extra factor of 2 hit to the background noise due to a\n telescope roll maneuver needed to subtract out the background. See\n Brown (2005) for more details.\n\n Returns\n -------\n lam : ndarray\n Observational wavelength grid [um]\n dlam : ndarray\n Observational spectral element width [um]\n A : ndarray\n Planetary geometric albedo on lam grid\n q : ndarray\n Quantum efficiency grid\n Cratio : ndarray\n Planet-star contrast ratio\n cp : ndarray\n Planetary photon count rate on detector [1/s]\n csp : ndarray\n Speckle photon count rate on detector [1/s]\n cz : ndarray\n Zodiacal photon count rate on detector [1/s]\n cez : ndarray\n Exozodiacal photon count rate on detector [1/s]\n cD : ndarray\n Dark current photon count rate on detector [1/s]\n cR : ndarray\n Read noise photon count rate on detector [1/s]\n cth : ndarray\n Instrument thermal photon count rate on detector [1/s]\n cc : ndarray\n Clock induced charge photon count rate [1/s]\n DtSNR : ndarray\n Exposure time required to get desired S/N (wantsnr) [hours]\n \"\"\"\n\n convolution_function = downbin_spec\n #convolution_function = degrade_spec\n\n # Define a diameter for IWA (circumscribed),\n # collecting area, and lenslet (inscribed)\n if diam_inscribed is None:\n # Defaults to diam\n diam_inscribed = diam\n if A_collect is None:\n # Defaults to diam\n diam_collect = diam\n else:\n # Calculated from provided collecting area\n diam_collect = 2. * (A_collect / np.pi)**0.5\n if diam_circumscribed is None:\n # Defaults to diam\n diam_circumscribed = diam\n\n # Configure for different telescope observing modes\n if mode == 'Imaging':\n filters = filter_wheel\n IMAGE = True\n COMPUTE_LAM = False\n # sorted filter dict by bandcenters\n tdict = sorted(filters.__dict__.items(), key=lambda x: x[1].bandcenter)\n # Construct array of wavelengths\n lam = np.array([x[1].bandcenter for x in tdict])\n # Construct array of wavelength bin widths (FWHM)\n dlam = np.array([x[1].FWHM for x in tdict])\n Nlam = len(lam)\n elif mode == 'IFS':\n IMAGE = False\n COMPUTE_LAM = True\n else:\n print(\"Invalid telescope observing mode. Select 'IFS', or 'Imaging'.\")\n sys.exit()\n\n # fraction of planetary signal in Airy pattern\n if set_fpa is None:\n fpa = f_airy(X)\n else:\n fpa = set_fpa * f_airy(X)\n\n # Set wavelength grid\n # GENERALIZE THIS:\n if COMPUTE_LAM:\n if (lam is None) or (dlam is None):\n lam, dlam = construct_lam(lammin, lammax, Res)\n elif IMAGE:\n pass\n else:\n # Throw error\n print(\"Error in make_noise: Not computing wavelength grid or providing filters!\")\n return None\n\n # Set Quantum Efficiency\n q = set_quantum_efficiency(lam, qe, NIR=NIR, vod=vod)\n\n # Set Dark current and Read noise\n De = set_dark_current(lam, De, lammax, Tdet, NIR=NIR)\n Re = set_read_noise(lam, Re, NIR=NIR)\n\n # Set Angular size of lenslet\n if lammin_lenslet is None: lammin_lenslet = lammin\n theta = set_lenslet(lam, lammin_lenslet, diam_inscribed, X, NIR=True)\n\n # Set throughput (for inner and outer working angle cutoffs)\n sep = r/d*np.sin(alpha*np.pi/180.)*np.pi/180./3600. # separation in radians\n T = set_throughput(lam, Tput, diam_circumscribed, sep, IWA, OWA, lammin, FIX_OWA=FIX_OWA, SILENT=SILENT)\n\n # Apply wavelength-dependent throuput, if needed\n if Tput_lam is not None:\n # Bin input throughput curve to native res\n Tlam = np.interp(lam, Tput_lam[0], Tput_lam[1])\n # Multiply into regular throughput\n T = T * Tlam\n\n # Apply wavelength-dependent quantum efficiency, if needed\n if qe_lam is not None:\n # Bin input QE curve to native res\n qlam = np.interp(lam, qe_lam[0], qe_lam[1])\n # Multiply into regular QE\n q = q * qlam\n\n # Modify throughput by atmospheric transmission if GROUND-based\n if GROUND:\n #if GROUND == \"ESO\":\n # Use ESO SKYCALC\n # pass\n #else:\n # Use SMART calc\n Tatmos = set_atmos_throughput(lam, dlam, convolution_function)\n # Multiply telescope throughput by atmospheric throughput\n T = T * Tatmos\n\n # Degrade albedo and stellar spectrum\n if COMPUTE_LAM:\n A = convolution_function(Ahr, lamhr, lam, dlam=dlam)\n Fs = convolution_function(solhr, lamhr, lam, dlam=dlam)\n elif IMAGE:\n # Convolve with filter response\n A = convolve_spec(Ahr, lamhr, filters)\n Fs = convolve_spec(solhr, lamhr, filters)\n else:\n A = Ahr\n Fs = solhr\n\n # Compute fluxes\n #Fs = Fstar(lam, Teff, Rs, r, AU=True) # stellar flux on planet\n Fp = Fplan(A, Phi, Fs, Rp, d) # planet flux at telescope\n Cratio = FpFs(A, Phi, Rp, r)\n\n ##### Compute count rates #####\n cp = cplan(q, fpa, T, lam, dlam, Fp, diam_collect) # planet count rate\n cz = czodi(q, X, T, lam, dlam, diam_collect, MzV) # solar system zodi count rate\n cez = cezodi(q, X, T, lam, dlam, diam_collect, r, \\\n Fstar(lam, Teff, Rs,1. , AU=True), Nez, MezV) # exo-zodi count rate\n csp = cspeck(q, T, C, lam, dlam, Fstar(lam,Teff,Rs,d), diam_collect) # speckle count rate\n cD = cdark(De, X, lam, diam_collect, theta, DNHpix, IMAGE=IMAGE) # dark current count rate\n cR = cread(Re, X, lam, diam_collect, theta, DNHpix, Dtmax, IMAGE=IMAGE) # readnoise count rate\n if THERMAL:\n cth = ctherm(q, X, T, lam, dlam, diam_collect, Tsys, emis) # internal thermal count rate\n else:\n cth = np.zeros_like(cp)\n\n # Add earth thermal photons if GROUND\n if GROUND:\n # Use ESO SKCALC\n wl_sky, Isky = get_sky_flux()\n # Convolve to instrument resolution\n Itherm = convolution_function(Isky, wl_sky, lam, dlam=dlam)\n # Compute Earth thermal photon count rate\n cthe = ctherm_earth(q, X, T, lam, dlam, diam_collect, Itherm)\n # Add earth thermal photon counts to telescope thermal counts\n cth = cth + cthe\n '''\n if True:\n import matplotlib.pyplot as plt;\n fig2, ax1 = plt.subplots(figsize=(8,6))\n ax1.plot(lam, cthe, c=\"blue\", ls=\"steps-mid\", label=\"Earth Thermal\")\n ax1.plot(lam, cth, c=\"red\", ls=\"steps-mid\", label=\"Telescope Thermal\")\n ax1.plot(lam, cp, c=\"k\", ls=\"steps-mid\", label=\"Planet\")\n ax1.set_ylabel(\"Photon Count Rate [1/s]\")\n ax1.set_xlabel(\"Wavelength [um]\")\n ax1.legend()\n plt.show()\n '''\n\n # Clock induced charge photon count rate\n # Calculate photon count rate in the scene (everything except read noise)\n cscene = cp + cz + cez + csp + cD + cth\n # Calculate the clock induced charge photon count rate\n cc = ccic(Rc, cscene, X, lam, diam_collect, theta, DNHpix, Dtmax,\n IMAGE=IMAGE, CIRC=CIRC)\n\n # Calculate total background counts\n cb = (cz + cez + csp + cD + cR + cth + cc)\n\n # Use telescope roll maneuver\n if roll_maneuver:\n # assuming background subtraction (the \"2\")\n roll_factor = 2.0\n else:\n # standard background noise\n roll_factor = 1.0\n\n # Calculate total noise\n cnoise = cp + roll_factor*cb\n\n # Calculate total counts\n ctot = cp + cz + cez + csp + cD + cR + cth + cc\n\n '''\n Giada: where does the factor of 2 come from [above]?\n\n Ty (Via email): That's due to \"background subtraction\".\n If you were to take a single exposure, and had the ability\n to post-process the image to the Poisson noise limit, you\n wouldn't have the factor of two. However, it's not yet\n clear that we'll be able to reach the Poisson, single observation limit.\n Instead, the current idea is that you take two observations (with\n exposure time Delta t/2), with the telescope rotated by a\n small amount between exposures, and then subtract the two images.\n So, for a fixed exoplanet count (cp), the roll technique would\n give you 2x as many noise counts due to background sources as\n would the single-observation technique.\n See also the top of page 4 of Brown (2005).\n '''\n\n # Exposure time to SNR\n DtSNR = exptime_element(lam, cp, cnoise, wantsnr)\n\n return lam, dlam, A, q, Cratio, cp, csp, cz, cez, cD, cR, cth, cc, DtSNR\n", "meta": {"hexsha": "533df616aaa809b534acf6c73cec28de44f13b49", "size": 31441, "ext": "py", "lang": "Python", "max_stars_repo_path": "coronagraph/count_rates.py", "max_stars_repo_name": "jlustigy/coronagraph", "max_stars_repo_head_hexsha": "b321693512422343b08ada7e246413e1f4bae4cc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2020-05-25T07:48:31.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-04T00:40:57.000Z", "max_issues_repo_path": "coronagraph/count_rates.py", "max_issues_repo_name": "jlustigy/coronagraph", "max_issues_repo_head_hexsha": "b321693512422343b08ada7e246413e1f4bae4cc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 8, "max_issues_repo_issues_event_min_datetime": "2019-04-12T22:17:07.000Z", "max_issues_repo_issues_event_max_datetime": "2020-05-07T00:01:11.000Z", "max_forks_repo_path": "coronagraph/count_rates.py", "max_forks_repo_name": "jlustigy/coronagraph", "max_forks_repo_head_hexsha": "b321693512422343b08ada7e246413e1f4bae4cc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2016-11-14T06:46:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-31T06:50:55.000Z", "avg_line_length": 35.9325714286, "max_line_length": 115, "alphanum_fraction": 0.5720237906, "include": true, "reason": "import numpy", "num_tokens": 7945, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5813030906443133, "lm_q2_score": 0.341582499438317, "lm_q1q2_score": 0.19856296263350307}} {"text": "\"\"\"\nDetector class\n\n----\n\n.. include license and copyright\n.. include:: ../include/copy.rst\n\n----\n\n.. include common links, assuming primary doc root is up one directory\n.. include:: ../include/links.rst\n\n\"\"\"\n\nimport os\nimport numpy\n\nfrom .efficiency import Efficiency\n\nclass Detector(Efficiency):\n \"\"\"\n Define the detector statistics.\n\n Args:\n shape (:obj:`tuple`, optional):\n Dimensions of the detector in number of pixels along the\n spectral axis and number of pixels along the spatial\n axis. Can be None, but limits use if it is.\n pixelsize (:obj:`float`, optional):\n The size of the (square) detector pixels in *micron*.\n rn (:obj:`float`, optional):\n Read-noise in electrons.\n dark (:obj:`float`, optional):\n Dark current in electrons per second.\n gain (:obj:`float`, optional):\n Gain of detector amplifier in e- per ADU.\n fullwell (:obj:`float`, optional):\n The full well of the pixels in e-.\n nonlinear (:obj:`float`, optional):\n The fraction of the fullwell above which the detector\n response is nonlinear.\n qe (:obj:`float`, :class:`Efficiency`, optional):\n Detector quantum efficiency.\n \"\"\"\n # TODO: Allow for multiple amplifiers per detector? Would also need\n # to define amplifier section.\n # TODO: Define overscan and data sections\n def __init__(self, shape=None, pixelsize=15., rn=1., dark=0., gain=1., fullwell=1e4,\n nonlinear=1., qe=0.9):\n if shape is not None and len(shape) != 2:\n raise ValueError('Shape must contain two integers.')\n self.shape = shape\n self.pixelsize = pixelsize\n self.rn = rn\n self.dark = dark\n self.gain = gain\n self.fullwell = fullwell\n self.nonlinear = nonlinear\n if not isinstance(qe, (Efficiency, float)):\n raise TypeError('Provided quantum efficiency must be type `float` or `Efficiency`.')\n if isinstance(qe, float):\n super(Detector, self).__init__(qe)\n else:\n super(Detector, self).__init__(qe.eta, wave=qe.wave)\n", "meta": {"hexsha": "d006f4f188d56dc1e59e6e40e197982d5fd55357", "size": 2198, "ext": "py", "lang": "Python", "max_stars_repo_path": "enyo/etc/detector.py", "max_stars_repo_name": "Keck-FOBOS/enyo", "max_stars_repo_head_hexsha": "82dd4324083d456c78bcbafdd081bee53f0c7ba9", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "enyo/etc/detector.py", "max_issues_repo_name": "Keck-FOBOS/enyo", "max_issues_repo_head_hexsha": "82dd4324083d456c78bcbafdd081bee53f0c7ba9", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "enyo/etc/detector.py", "max_forks_repo_name": "Keck-FOBOS/enyo", "max_forks_repo_head_hexsha": "82dd4324083d456c78bcbafdd081bee53f0c7ba9", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.303030303, "max_line_length": 96, "alphanum_fraction": 0.6087352138, "include": true, "reason": "import numpy", "num_tokens": 503, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.5813030906443133, "lm_q2_score": 0.34158249273565866, "lm_q1q2_score": 0.19856295873722707}} {"text": "# !/usr/bin/env python\n# -*- coding: utf-8 -*-\n#\n# Project: Azimuthal integration\n# https://github.com/silx-kit/pyFAI\n#\n# Copyright (C) 2013-2020 European Synchrotron Radiation Facility, Grenoble, France\n#\n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# in the Software without restriction, including without limitation the rights\n# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n# copies of the Software, and to permit persons to whom the Software is\n# furnished to do so, subject to the following conditions:\n# .\n# The above copyright notice and this permission notice shall be included in\n# all copies or substantial portions of the Software.\n# .\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n# THE SOFTWARE.\n\n__author__ = \"Jérôme Kieffer\"\n__contact__ = \"Jerome.Kieffer@ESRF.eu\"\n__license__ = \"MIT\"\n__copyright__ = \"European Synchrotron Radiation Facility, Grenoble, France\"\n__date__ = \"06/07/2020\"\n__status__ = \"development\"\n\nimport logging\nimport threading\nimport os\nimport numpy\nlogger = logging.getLogger(__name__)\nfrom math import ceil, floor\nfrom . import detectors\nfrom .opencl import ocl\nif ocl:\n from .opencl import azim_lut as ocl_azim_lut\n from .opencl import azim_csr as ocl_azim_csr\nelse:\n ocl_azim_lut = ocl_azim_csr = None\nfrom .third_party import six\n\ntry:\n from .ext import _distortion\n from .ext import sparse_utils\nexcept ImportError:\n logger.debug(\"Backtrace\", exc_info=True)\n logger.warning(\"Import _distortion cython implementation failed ... pure python version is terribly slow !!!\")\n _distortion = None\n\ntry:\n from scipy.sparse import linalg, csr_matrix, identity\nexcept IOError:\n logger.warning(\"Scipy is missing ... uncorrection will be handled the old way\")\n linalg = None\nelse:\n import scipy\n v = tuple(int(i) for i in scipy.version.short_version.split(\".\") if i.isdigit())\n if v < (0, 11):\n logger.warning(\"Scipy is too old ... uncorrection will be handled the old way\")\n linalg = None\n\n\ndef resize_image_2D_numpy(image, shape_in):\n \"numpy implementation of resize_image_2D\"\n new_img = numpy.zeros(shape_in, dtype=image.dtype)\n common_shape = [min(i, j) for i, j in zip(image.shape, shape_in)]\n new_img[:common_shape[0], :common_shape[1]] = image[:common_shape[0], :common_shape[1]]\n return new_img\n\nif _distortion is None:\n resize_image_2D = resize_image_2D_numpy\nelse:\n from .ext._distortion import resize_image_2D\n\n\nclass Distortion(object):\n \"\"\"\n This class applies a distortion correction on an image.\n\n New version compatible both with CSR and LUT...\n \"\"\"\n def __init__(self, detector=\"detector\", shape=None, resize=False, empty=0,\n mask=None, method=\"CSR\", device=None, workgroup=32):\n \"\"\"\n :param detector: detector instance or detector name\n :param shape: shape of the output image\n :param resize: allow the output shape to be different from the input shape\n :param empty: value to be given for empty bins\n :param method: \"lut\" or \"csr\", the former is faster\n :param device: Name of the device: None for OpenMP, \"cpu\" or \"gpu\" or the id of the OpenCL device a 2-tuple of integer\n :param workgroup: workgroup size for CSR on OpenCL\n \"\"\"\n self._shape_out = None\n if isinstance(detector, six.string_types):\n self.detector = detectors.detector_factory(detector)\n else: # we assume it is a Detector instance\n self.detector = detector\n self.shape_in = self.detector.shape\n if mask is None:\n self.mask = numpy.ascontiguousarray(self.detector.mask, numpy.int8)\n elif mask is False:\n self.mask = numpy.zeros(self.detector.mask.shape, numpy.int8)\n else:\n self.mask = numpy.ascontiguousarray(mask, numpy.int8)\n self.resize = resize\n if shape is not None:\n self._shape_out = tuple([int(i) for i in shape])\n elif not self.resize:\n if self.detector.shape is not None:\n self._shape_out = self.detector.shape\n else:\n raise RuntimeError(\"You need to provide either the detector or its shape\")\n\n self._sem = threading.Semaphore()\n self.bin_size = None\n self.max_size = None\n self.pos = None\n if not method:\n self.method = \"lut\"\n else:\n self.method = method.lower()\n if (self.detector.uniform_pixel and self.detector.IS_FLAT):\n csr = identity(numpy.prod(self.detector.shape),\n dtype=numpy.float32,\n format=\"csr\")\n if self.detector.mask is not None:\n masked = numpy.where(self.detector.mask)\n csr[masked] = 0.0\n if self.method == \"lut\":\n self.lut = sparse_utils.CSR_to_LUT(csr.data, csr.indices, csr.indptr)\n else:\n self.lut = csr.data, csr.indices, csr.indptr\n else:\n #initialize the LUT later\n self.lut = None\n self.delta1 = self.delta2 = None # max size of an pixel on a regular grid ...\n self.offset1 = self.offset2 = 0 # position of the first bin\n self.integrator = None\n self.empty = empty # \"dummy\" value for empty bins\n self.device = device\n if not workgroup:\n self.workgroup = 1\n else:\n self.workgroup = int(workgroup)\n\n def __repr__(self):\n return os.linesep.join([\"Distortion correction %s on device %s for detector shape %s:\" % (self.method, self.device, self._shape_out),\n self.detector.__repr__()])\n\n def reset(self, method=None, device=None, workgroup=None, prepare=True):\n \"\"\"\n reset the distortion correction and re-calculate the look-up table\n\n :param method: can be \"lut\" or \"csr\", \"lut\" looks faster\n :param device: can be None, \"cpu\" or \"gpu\" or the id as a 2-tuple of integer\n :param worgroup: enforce the workgroup size for CSR.\n :param prepare: set to false to only reset and not re-initialize\n \"\"\"\n with self._sem:\n self.max_size = None\n self.pos = None\n self.lut = None\n self.delta1 = self.delta2 = None\n self.offset1 = self.offset2 = 0\n self.integrator = None\n if method is not None:\n self.method = method.lower()\n if device is not None:\n self.device = device\n if workgroup is not None:\n self.workgroup = int(workgroup)\n if prepare:\n self.calc_init()\n\n @property\n def shape_out(self):\n \"\"\"\n Calculate/cache the output shape\n\n :return: output shape\n \"\"\"\n if self._shape_out is None:\n self.calc_pos()\n return self._shape_out\n\n def calc_pos(self, use_cython=True):\n \"\"\"Calculate the pixel boundary position on the regular grid\n\n :return: pixel corner positions (in pixel units) on the regular grid\n :rtype: ndarray of shape (nrow, ncol, 4, 2)\n \"\"\"\n if self.delta1 is None:\n with self._sem:\n if self.delta1 is None:\n # TODO: implement equivalent in Cython\n if _distortion and use_cython:\n self.pos, self.delta1, self.delta2, shape_out, offset = _distortion.calc_pos(self.detector.get_pixel_corners(), self.detector.pixel1, self.detector.pixel2, self._shape_out)\n if self._shape_out is None:\n self.offset1, self.offset2 = offset\n self._shape_out = shape_out\n else:\n pixel_size = numpy.array([self.detector.pixel1, self.detector.pixel2], dtype=numpy.float32)\n # make it a 4D array\n pixel_size.shape = 1, 1, 1, 2\n pixel_size.strides = 0, 0, 0, pixel_size.strides[-1]\n self.pos = self.detector.get_pixel_corners()[..., 1:] / pixel_size\n if self._shape_out is None:\n # if defined, it is probably because resize=False\n corner_pos = self.pos.view()\n corner_pos.shape = -1, 2\n pos1_min, pos2_min = corner_pos.min(axis=0)\n pos1_max, pos2_max = corner_pos.max(axis=0)\n self._shape_out = (int(ceil(pos1_max - pos1_min)),\n int(ceil(pos2_max - pos2_min)))\n self.offset1, self.offset2 = pos1_min, pos2_min\n pixel_delta = self.pos.view()\n pixel_delta.shape = -1, 4, 2\n self.delta1, self.delta2 = ((numpy.ceil(pixel_delta.max(axis=1)) - numpy.floor(pixel_delta.min(axis=1))).max(axis=0)).astype(int)\n return self.pos\n\n def calc_size(self, use_cython=True):\n \"\"\"Calculate the number of pixels falling into every single bin and\n\n :return: max of pixel falling into a single bin\n\n Considering the \"half-CCD\" spline from ID11 which describes a (1025,2048) detector,\n the physical location of pixels should go from:\n [-17.48634 : 1027.0543, -22.768829 : 2028.3689]\n We chose to discard pixels falling outside the [0:1025,0:2048] range with a lose of intensity\n \"\"\"\n if self.pos is None:\n pos = self.calc_pos()\n else:\n pos = self.pos\n if self.max_size is None:\n with self._sem:\n if self.max_size is None:\n if _distortion and use_cython:\n self.bin_size = _distortion.calc_size(self.pos, self._shape_out, self.mask, (self.offset1, self.offset2))\n else:\n mask = self.mask\n pos0min = (numpy.floor(pos[:, :, :, 0].min(axis=-1) - self.offset1).astype(numpy.int32)).clip(0, self._shape_out[0])\n pos1min = (numpy.floor(pos[:, :, :, 1].min(axis=-1) - self.offset2).astype(numpy.int32)).clip(0, self._shape_out[1])\n pos0max = (numpy.ceil(pos[:, :, :, 0].max(axis=-1) - self.offset1 + 1).astype(numpy.int32)).clip(0, self._shape_out[0])\n pos1max = (numpy.ceil(pos[:, :, :, 1].max(axis=-1) - self.offset2 + 1).astype(numpy.int32)).clip(0, self._shape_out[1])\n self.bin_size = numpy.zeros(self._shape_out, dtype=numpy.int32)\n for i in range(self.shape_in[0]):\n for j in range(self.shape_in[1]):\n if (mask is not None) and mask[i, j]:\n continue\n self.bin_size[pos0min[i, j]:pos0max[i, j], pos1min[i, j]:pos1max[i, j]] += 1\n self.max_size = self.bin_size.max()\n return self.bin_size\n\n def calc_init(self):\n \"\"\"Initialize all arrays\n \"\"\"\n self.calc_pos()\n self.calc_size()\n self.calc_LUT()\n if ocl and self.device is not None:\n if \"lower\" in dir(self.device):\n self.device = self.device.lower()\n if self.method == \"lut\":\n self.integrator = ocl_azim_lut.OCL_LUT_Integrator(self.lut,\n self._shape_out[0] * self._shape_out[1],\n devicetype=self.device)\n else:\n self.integrator = ocl_azim_csr.OCL_CSR_Integrator(self.lut,\n self._shape_out[0] * self._shape_out[1],\n devicetype=self.device,\n block_size=self.workgroup)\n self.integrator.workgroup_size[\"csr_integrate4\"] = 1,\n else:\n if self.method == \"lut\":\n self.integrator = ocl_azim_lut.OCL_LUT_Integrator(self.lut,\n self._shape_out[0] * self._shape_out[1],\n platformid=self.device[0],\n deviceid=self.device[1])\n else:\n self.integrator = ocl_azim_csr.OCL_CSR_Integrator(self.lut,\n self._shape_out[0] * self._shape_out[1],\n platformid=self.device[0], deviceid=self.device[1],\n block_size=self.workgroup)\n self.integrator.workgroup_size[\"csr_integrate4\"] = 1,\n\n def calc_LUT(self, use_common=True):\n \"\"\"Calculate the Look-up table\n\n :return: look up table either in CSR or LUT format depending on serl.method\n \"\"\"\n if self.pos is None:\n self.calc_pos()\n\n if self.max_size is None and not use_common:\n self.calc_size()\n if self.lut is None:\n with self._sem:\n if self.lut is None:\n mask = self.mask\n if _distortion:\n if use_common:\n self.lut = _distortion.calc_sparse(self.pos, self._shape_out, max_pixel_size=(self.delta1, self.delta2), format=self.method)\n else:\n if self.method == \"lut\":\n self.lut = _distortion.calc_LUT(self.pos, self._shape_out, self.bin_size, max_pixel_size=(self.delta1, self.delta2))\n else:\n self.lut = _distortion.calc_CSR(self.pos, self._shape_out, self.bin_size, max_pixel_size=(self.delta1, self.delta2))\n else:\n lut = numpy.recarray(shape=(self._shape_out[0], self._shape_out[1], self.max_size), dtype=[(\"idx\", numpy.uint32), (\"coef\", numpy.float32)])\n lut[:, :, :].idx = 0\n lut[:, :, :].coef = 0.0\n outMax = numpy.zeros(self._shape_out, dtype=numpy.uint32)\n idx = 0\n buffer_ = numpy.empty((self.delta1, self.delta2))\n quad = Quad(buffer_)\n for i in range(self._shape_out[0]):\n for j in range(self._shape_out[1]):\n if (mask is not None) and mask[i, j]:\n continue\n # i,j, idx are indexes of the raw image uncorrected\n quad.reinit(*list(self.pos[i, j, :, :].ravel()))\n # print(self.pos[i, j, 0, :], self.pos[i, j, 1, :], self.pos[i, j, 2, :], self.pos[i, j, 3, :]\n try:\n quad.populate_box()\n except Exception as error:\n print(\"error in quad.populate_box of pixel %i, %i: %s\" % (i, j, error))\n print(\"calc_area_vectorial\", quad.calc_area_vectorial())\n print(self.pos[i, j, 0, :], self.pos[i, j, 1, :], self.pos[i, j, 2, :], self.pos[i, j, 3, :])\n print(quad)\n raise\n # box = quad.get_box()\n for ms in range(quad.get_box_size0()):\n ml = ms + quad.get_offset0()\n if ml < 0 or ml >= self._shape_out[0]:\n continue\n for ns in range(quad.get_box_size1()):\n # ms,ns are indexes of the corrected image in short form, ml & nl are the same\n nl = ns + quad.get_offset1()\n if nl < 0 or nl >= self._shape_out[1]:\n continue\n val = quad.get_box(ms, ns)\n if val <= 0:\n continue\n k = outMax[ml, nl]\n lut[ml, nl, k].idx = idx\n lut[ml, nl, k].coef = val\n outMax[ml, nl] = k + 1\n idx += 1\n lut.shape = (self._shape_out[0] * self._shape_out[1]), self.max_size\n self.lut = lut\n return self.lut\n\n def correct(self, image, dummy=None, delta_dummy=None):\n \"\"\"\n Correct an image based on the look-up table calculated ...\n\n :param image: 2D-array with the image\n :param dummy: value suggested for bad pixels\n :param delta_dummy: precision of the dummy value\n :return: corrected 2D image\n \"\"\"\n if image.ndim == 2:\n image = resize_image_2D(image, self.shape_in)\n else: # assume 2d+nchanel\n if _distortion:\n image = _distortion.resize_image_3D(image, self.shape_in)\n else:\n assert image.ndim == 3, \"image is 3D\"\n shape_in0, shape_in1 = self.shape_in\n shape_img0, shape_img1, nchan = image.shape\n if not ((shape_img0 == shape_in0) and (shape_img1 == shape_in1)):\n new_image = numpy.zeros((shape_in0, shape_in1, nchan), dtype=numpy.float32)\n if shape_img0 < shape_in0:\n if shape_img1 < shape_in1:\n new_image[:shape_img0, :shape_img1, :] = image\n else:\n new_image[:shape_img0, :, :] = image[:, :shape_in1, :]\n else:\n if shape_img1 < shape_in1:\n new_image[:, :shape_img1, :] = image[:shape_in0, :, :]\n else:\n new_image[:, :, :] = image[:shape_in0, :shape_in1, :]\n logger.warning(\"Patching image of shape %ix%i on expected size of %ix%i\",\n shape_img1, shape_img0, shape_in1, shape_in0)\n image = new_image\n if self.device:\n if self.integrator is None:\n self.calc_init()\n out = self.integrator.integrate(image)[1]\n else:\n if self.lut is None:\n self.calc_LUT()\n if _distortion is not None:\n out = _distortion.correct(image, self.shape_in, self._shape_out, self.lut,\n dummy=dummy or self.empty, delta_dummy=delta_dummy)\n else:\n if self.method == \"lut\":\n big = image.ravel().take(self.lut.idx) * self.lut.coef\n out = big.sum(axis=-1)\n elif self.method == \"csr\":\n big = self.lut[0] * image.ravel().take(self.lut[1])\n indptr = self.lut[2]\n out = numpy.zeros(indptr.size - 1)\n for i in range(indptr.size - 1):\n out[i] = big[indptr[i]:indptr[i + 1]].sum()\n try:\n if image.ndim == 2:\n out.shape = self._shape_out\n else:\n for ds in out:\n if ds.ndim == 2:\n ds.shape = self._shape_out\n else:\n ds.shape = self._shape_out + ds.shape[2:]\n\n except ValueError as _err:\n logger.error(\"Requested in_shape=%s out_shape=%s and \", self.shape_in, self.shape_out)\n raise\n return out\n\n def correct_ng(self, image,\n variance=None,\n dark=None,\n flat=None,\n solidangle=None,\n polarization=None,\n dummy=None,\n delta_dummy=None,\n normalization_factor=1.0):\n \"\"\"\n Correct an image based on the look-up table calculated ...\n Like the integrate_ng it provides\n * Dark current correction\n * Normalisation with flatfield (or solid angle, polarization, absorption, ...)\n * Error propagation\n\n :param image: 2D-array with the image\n :param variance: 2D-array with the associated image\n :param dark: array with dark-current values\n :param flat: array with values for a flat image\n :param solidangle: solid-angle array\n :param polarization: numpy array with 2D polarization corrections\n :param dummy: value suggested for bad pixels\n :param delta_dummy: precision of the dummy value\n :param normalization_factor: multiply all normalization with this value\n :return: corrected 2D image\n \"\"\"\n assert image.ndim == 2\n if variance is not None:\n assert variance.shape == image.shape\n\n if image.shape != self.shape_in:\n logger.warning(\"The image shape %s is not the same as the detector %s\", image.shape, self.shape_in)\n image = resize_image_2D(image, self.shape_in)\n if variance is not None:\n variance = resize_image_2D(variance, self.shape_in)\n if dark is not None:\n dark = resize_image_2D(dark, self.shape_in)\n\n if self.device:\n if self.integrator is None:\n self.calc_init()\n res = self.integrator.integrate_ng(image,\n variance=variance,\n flat=flat,\n dark=dark,\n solidangle=solidangle,\n polarization=polarization,\n dummy=dummy,\n delta_dummy=delta_dummy,\n normalization_factor=normalization_factor,\n out_merged=False\n )\n if variance is not None:\n if image.ndim == 2:\n out = res.intensity.reshape(self._shape_out)\n else:\n out = res.intensity\n else:\n if image.ndim == 2:\n out = (res.intensity.reshape(self._shape_out), res.error.reshape(self._shape_out))\n else:\n out = (res.intensity, res.error)\n else:\n if self.lut is None:\n self.calc_LUT()\n if _distortion is not None:\n out = _distortion.correct(image, self.shape_in, self._shape_out, self.lut,\n dummy=dummy or self.empty, delta_dummy=delta_dummy)\n else:\n if self.method == \"lut\":\n big = image.ravel().take(self.lut.idx) * self.lut.coef\n out = big.sum(axis=-1)\n elif self.method == \"csr\":\n big = self.lut[0] * image.ravel().take(self.lut[1])\n indptr = self.lut[2]\n out = numpy.zeros(indptr.size - 1)\n for i in range(indptr.size - 1):\n out[i] = big[indptr[i]:indptr[i + 1]].sum()\n try:\n if image.ndim == 2:\n out.shape = self._shape_out\n else:\n for ds in out:\n if ds.ndim == 2:\n ds.shape = self._shape_out\n else:\n ds.shape = self._shape_out + ds.shape[2:]\n\n except ValueError as _err:\n logger.error(\"Requested in_shape=%s out_shape=%s and \", self.shape_in, self.shape_out)\n raise\n return out\n\n\n def uncorrect(self, image, use_cython=False):\n \"\"\"\n Take an image which has been corrected and transform it into it's raw (with loss of information)\n\n :param image: 2D-array with the image\n :return: uncorrected 2D image\n\n Nota: to retrieve the input mask on can do:\n\n >>> msk = dis.uncorrect(numpy.ones(dis._shape_out)) <= 0\n \"\"\"\n assert image.shape == self._shape_out\n if self.lut is None:\n self.calc_LUT()\n if (linalg is not None) and (use_cython is False):\n if self.method == \"lut\":\n csr = csr_matrix(sparse_utils.LUT_to_CSR(self.lut))\n else:\n csr = csr_matrix(self.lut)\n res = linalg.lsmr(csr, image.ravel())\n out = res[0].reshape(self.shape_in)\n else: # This is deprecated and does not work with resise=True\n if self.method == \"lut\":\n if _distortion is not None:\n out, _mask = _distortion.uncorrect_LUT(image, self.shape_in, self.lut)\n else:\n out = numpy.zeros(self.shape_in, dtype=numpy.float32)\n lout = out.ravel()\n lin = image.ravel()\n tot = self.lut.coef.sum(axis=-1)\n for idx in range(self.lut.shape[0]):\n t = tot[idx]\n if t <= 0:\n continue\n val = lin[idx] / t\n lout[self.lut[idx].idx] += val * self.lut[idx].coef\n elif self.method == \"csr\":\n if _distortion is not None:\n out, _mask = _distortion.uncorrect_CSR(image, self.shape_in, self.lut)\n else:\n raise NotImplementedError()\n return out\n\n\nclass Quad(object):\n \"\"\"\n Quad modelisation.\n\n .. image:: ../img/quad_model.svg\n :alt: Modelization of the quad\n \"\"\"\n def __init__(self, buffer):\n self.box = buffer\n self.A0 = self.A1 = None\n self.B0 = self.B1 = None\n self.C0 = self.C1 = None\n self.D0 = self.D1 = None\n self.offset0 = self.offset1 = None\n self.box_size0 = self.box_size1 = None\n self.pAB = self.pBC = self.pCD = self.pDA = None\n self.cAB = self.cBC = self.cCD = self.cDA = None\n self.area = None\n\n def get_idx(self, i, j):\n pass\n\n def get_box(self, i, j):\n return self.box[i, j]\n\n def get_offset0(self):\n return self.offset0\n\n def get_offset1(self):\n return self.offset1\n\n def get_box_size0(self):\n return self.box_size0\n\n def get_box_size1(self):\n return self.box_size1\n\n def reinit(self, A0, A1, B0, B1, C0, C1, D0, D1):\n self.box[:, :] = 0.0\n self.A0 = A0\n self.A1 = A1\n self.B0 = B0\n self.B1 = B1\n self.C0 = C0\n self.C1 = C1\n self.D0 = D0\n self.D1 = D1\n self.offset0 = int(floor(min(self.A0, self.B0, self.C0, self.D0)))\n self.offset1 = int(floor(min(self.A1, self.B1, self.C1, self.D1)))\n self.box_size0 = int(ceil(max(self.A0, self.B0, self.C0, self.D0))) - self.offset0\n self.box_size1 = int(ceil(max(self.A1, self.B1, self.C1, self.D1))) - self.offset1\n self.A0 -= self.offset0\n self.A1 -= self.offset1\n self.B0 -= self.offset0\n self.B1 -= self.offset1\n self.C0 -= self.offset0\n self.C1 -= self.offset1\n self.D0 -= self.offset0\n self.D1 -= self.offset1\n self.pAB = self.pBC = self.pCD = self.pDA = None\n self.cAB = self.cBC = self.cCD = self.cDA = None\n self.area = None\n\n def __repr__(self):\n return os.linesep.join([\"offset %i,%i size %i, %i\" % (self.offset0, self.offset1, self.box_size0, self.box_size1), \"box: %s\" % self.box[:self.box_size0, :self.box_size1]])\n\n def init_slope(self):\n if self.pAB is None:\n if self.B0 == self.A0:\n self.pAB = numpy.inf\n else:\n self.pAB = (self.B1 - self.A1) / (self.B0 - self.A0)\n if self.C0 == self.B0:\n self.pBC = numpy.inf\n else:\n self.pBC = (self.C1 - self.B1) / (self.C0 - self.B0)\n if self.D0 == self.C0:\n self.pCD = numpy.inf\n else:\n self.pCD = (self.D1 - self.C1) / (self.D0 - self.C0)\n if self.A0 == self.D0:\n self.pDA = numpy.inf\n else:\n self.pDA = (self.A1 - self.D1) / (self.A0 - self.D0)\n self.cAB = self.A1 - self.pAB * self.A0\n self.cBC = self.B1 - self.pBC * self.B0\n self.cCD = self.C1 - self.pCD * self.C0\n self.cDA = self.D1 - self.pDA * self.D0\n\n def calc_area_AB(self, I1, I2):\n if numpy.isfinite(self.pAB):\n return 0.5 * (I2 - I1) * (self.pAB * (I2 + I1) + 2 * self.cAB)\n else:\n return 0\n\n def calc_area_BC(self, J1, J2):\n if numpy.isfinite(self.pBC):\n return 0.5 * (J2 - J1) * (self.pBC * (J1 + J2) + 2 * self.cBC)\n else:\n return 0\n\n def calc_area_CD(self, K1, K2):\n if numpy.isfinite(self.pCD):\n return 0.5 * (K2 - K1) * (self.pCD * (K2 + K1) + 2 * self.cCD)\n else:\n return 0\n\n def calc_area_DA(self, L1, L2):\n\n if numpy.isfinite(self.pDA):\n return 0.5 * (L2 - L1) * (self.pDA * (L1 + L2) + 2 * self.cDA)\n else:\n return 0\n\n def calc_area_old(self):\n if self.area is None:\n if self.pAB is None:\n self.init_slope()\n self.area = -(self.calc_area_AB(self.A0, self.B0) +\n self.calc_area_BC(self.B0, self.C0) +\n self.calc_area_CD(self.C0, self.D0) +\n self.calc_area_DA(self.D0, self.A0))\n return self.area\n\n def calc_area_vectorial(self):\n if self.area is None:\n self.area = numpy.cross([self.C0 - self.A0, self.C1 - self.A1], [self.D0 - self.B0, self.D1 - self.B1]) / 2.0\n return self.area\n calc_area = calc_area_vectorial\n\n def populate_box(self):\n if self.pAB is None:\n self.init_slope()\n self.integrateAB(self.B0, self.A0, self.calc_area_AB)\n self.integrateAB(self.A0, self.D0, self.calc_area_DA)\n self.integrateAB(self.D0, self.C0, self.calc_area_CD)\n self.integrateAB(self.C0, self.B0, self.calc_area_BC)\n if (self.box / self.calc_area()).min() < 0:\n print(self.box)\n self.box[:, :] = 0\n print(\"AB\")\n self.integrateAB(self.B0, self.A0, self.calc_area_AB)\n print(self.box)\n self.box[:, :] = 0\n print(\"DA\")\n self.integrateAB(self.A0, self.D0, self.calc_area_DA)\n print(self.box)\n self.box[:, :] = 0\n print(\"CD\")\n self.integrateAB(self.D0, self.C0, self.calc_area_CD)\n print(self.box)\n self.box[:, :] = 0\n print(\"BC\")\n self.integrateAB(self.C0, self.B0, self.calc_area_BC)\n print(self.box)\n print(self)\n raise RuntimeError()\n self.box /= self.calc_area_vectorial()\n\n def integrateAB(self, start, stop, calc_area):\n h = 0\n# print(start, stop, calc_area(start, stop)\n if start < stop: # positive contribution\n P = ceil(start)\n dP = P - start\n# print(\"Integrate\", start, P, stop, calc_area(start, stop)\n if P > stop: # start and stop are in the same unit\n A = calc_area(start, stop)\n if A != 0:\n AA = abs(A)\n sign = A / AA\n dA = (stop - start) # always positive\n# print(AA, sign, dA\n h = 0\n while AA > 0:\n if dA > AA:\n dA = AA\n AA = -1\n self.box[int(floor(start)), h] += sign * dA\n AA -= dA\n h += 1\n else:\n if dP > 0:\n A = calc_area(start, P)\n if A != 0:\n AA = abs(A)\n sign = A / AA\n h = 0\n dA = dP\n while AA > 0:\n if dA > AA:\n dA = AA\n AA = -1\n self.box[int(floor(P)) - 1, h] += sign * dA\n AA -= dA\n h += 1\n # subsection P1->Pn\n for i in range(int(floor(P)), int(floor(stop))):\n A = calc_area(i, i + 1)\n if A != 0:\n AA = abs(A)\n sign = A / AA\n\n h = 0\n dA = 1.0\n while AA > 0:\n if dA > AA:\n dA = AA\n AA = -1\n self.box[i, h] += sign * dA\n AA -= dA\n h += 1\n # Section Pn->B\n P = floor(stop)\n dP = stop - P\n if dP > 0:\n A = calc_area(P, stop)\n if A != 0:\n AA = abs(A)\n sign = A / AA\n h = 0\n dA = abs(dP)\n while AA > 0:\n if dA > AA:\n dA = AA\n AA = -1\n self.box[int(floor(P)), h] += sign * dA\n AA -= dA\n h += 1\n elif start > stop: # negative contribution. Nota is start=stop: no contribution\n P = floor(start)\n if stop > P: # start and stop are in the same unit\n A = calc_area(start, stop)\n if A != 0:\n AA = abs(A)\n sign = A / AA\n dA = (start - stop) # always positive\n h = 0\n while AA > 0:\n if dA > AA:\n dA = AA\n AA = -1\n self.box[int(floor(start)), h] += sign * dA\n AA -= dA\n h += 1\n else:\n dP = P - start\n if dP < 0:\n A = calc_area(start, P)\n if A != 0:\n AA = abs(A)\n sign = A / AA\n h = 0\n dA = abs(dP)\n while AA > 0:\n if dA > AA:\n dA = AA\n AA = -1\n self.box[int(floor(P)), h] += sign * dA\n AA -= dA\n h += 1\n # subsection P1->Pn\n for i in range(int(start), int(ceil(stop)), -1):\n A = calc_area(i, i - 1)\n if A != 0:\n AA = abs(A)\n sign = A / AA\n h = 0\n dA = 1\n while AA > 0:\n if dA > AA:\n dA = AA\n AA = -1\n self.box[i - 1, h] += sign * dA\n AA -= dA\n h += 1\n # Section Pn->B\n P = ceil(stop)\n dP = stop - P\n if dP < 0:\n A = calc_area(P, stop)\n if A != 0:\n AA = abs(A)\n sign = A / AA\n h = 0\n dA = abs(dP)\n while AA > 0:\n if dA > AA:\n dA = AA\n AA = -1\n self.box[int(floor(stop)), h] += sign * dA\n AA -= dA\n h += 1\n", "meta": {"hexsha": "0c3ff6709b98b27b367b1e5adfddc922030956cc", "size": 37655, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyFAI/distortion.py", "max_stars_repo_name": "weninc/pyFAI", "max_stars_repo_head_hexsha": "4d857851ade2888f5aee5eab0fc973775e43bb77", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pyFAI/distortion.py", "max_issues_repo_name": "weninc/pyFAI", "max_issues_repo_head_hexsha": "4d857851ade2888f5aee5eab0fc973775e43bb77", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pyFAI/distortion.py", "max_forks_repo_name": "weninc/pyFAI", "max_forks_repo_head_hexsha": "4d857851ade2888f5aee5eab0fc973775e43bb77", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.7340301974, "max_line_length": 196, "alphanum_fraction": 0.4741734165, "include": true, "reason": "import numpy,import scipy,from scipy", "num_tokens": 8422, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5813030906443133, "lm_q2_score": 0.34158249273565866, "lm_q1q2_score": 0.19856295873722707}} {"text": "#!/usr/bin/env python\n\n\nfrom astropy.io import fits as pyfits\nimport numpy as np\nimport os\nimport argparse\nfrom scipy.ndimage import filters\n\n\nif __name__ == '__main__':\n \n p = argparse.ArgumentParser( \n description='''\n Group pha files using optimum binning based on the instrument\n resoluions, or using the formula in Kaastra+Bleeker 16,\n with the addition of a signal to noise constraint.\n The input spectrum is assumed to have the RESPFILE and \n BACKFILE keywords\n ''', \n formatter_class=argparse.ArgumentDefaultsHelpFormatter ) \n\n p.add_argument(\"spec_file\" , metavar=\"spec_file\", type=str,\n help=\"The name of the input spectrum file.\")\n p.add_argument(\"out_file\" , metavar=\"out_file\", type=str,\n help=\"The name of the output spectrum file.\")\n p.add_argument('-s', '--snr', metavar='min_snr', \n type=float, default=3,\n help='The minimum signal to noise ration per bin. -1 to ignore')\n p.add_argument('-c', '--counts', metavar='min_counts', \n type=float, default=-1,\n help='The minimum counts per bin. -1 to ignore')\n p.add_argument('-f', '--osample_fac', metavar='osample_fac', \n type=float, default=3,\n help='The oversampling factor in units of the local FWHM')\n p.add_argument(\"--use_formula\", action='store_true', default=False,\n help=('Calculate the oversampling factor using formula 36-37 '\n 'in Kaastra & Bleeker 2016'))\n p.add_argument(\"--write_chan\", action='store_true', default=False,\n help=('Write grouping file, then use standard grppha.'\n 'This requires heasoft and ngroups < 100'))\n\n\n # process input #\n args = p.parse_args()\n spec_file = args.spec_file\n out_file = args.out_file\n min_snr = args.snr\n min_counts = args.counts\n osample_fac = args.osample_fac\n use_formula = args.use_formula\n write_chan = args.write_chan\n\n\n # some defaults #\n if osample_fac < 0: osample_fac = 1\n\n\n\n\n\n # ------------------------------------------- #\n # Read the response and background file names #\n with pyfits.open(spec_file) as fp:\n src_c = np.array(fp['SPECTRUM'].data.field(1), np.double)\n src_ex = fp['SPECTRUM'].header['EXPOSURE'] \n try:\n src_bs = fp['SPECTRUM'].header['BACKSCAL'] \n except:\n src_bs = 1.0\n try:\n rsp_file = fp['SPECTRUM'].header['RESPFILE']\n except:\n raise ValueError('No RESPFILE key in spectrum header')\n try:\n bgd_file = fp['SPECTRUM'].header['BACKFILE']\n except:\n bgd_file = None\n #raise ValueError('No BACKFILE key in spectrum header; Set to none if needed')\n # ------------------------------------------- #\n\n\n\n # --------------------- #\n # get background counts #\n bgd_c = np.zeros_like(src_c)\n if not bgd_file in [None, 'none', 'NONE']:\n with pyfits.open(bgd_file) as fp:\n bgd_c = np.array(fp['SPECTRUM'].data.field(1), np.double)\n bgd_ex = fp['SPECTRUM'].header['EXPOSURE'] \n try:\n bgd_bs = fp['SPECTRUM'].header['BACKSCAL'] \n except:\n bgd_bs = 1.0\n bgd_c *= (src_bs/bgd_bs) * (src_ex/bgd_ex)\n # --------------------- #\n\n\n # ------------------------- #\n # energy-channel conversion #\n with pyfits.open(rsp_file) as fp:\n edata = fp['EBOUNDS'].data\n chan = edata.field(0)\n energy = (edata.field(1)+edata.field(2)) / 2.\n try:\n matrix = fp['MATRIX'].data\n except:\n matrix = fp['SPECRESP MATRIX'].data\n nchan = len(chan)\n nen = len(matrix)\n men = np.array([(m[1]+m[0])/2 for m in matrix])\n # ------------------------- #\n\n\n\n # --------------------- #\n # loop through channels #\n ibin = np.zeros(nchan) - 1\n ich, ibin[0] = 0, 1\n smooth = nen * 1. / nchan\n while ich < nchan:\n\n # get the response curve at ich #\n ie = np.argmin(np.abs(men - energy[ich]))\n istart, ilen = matrix[ie][3], matrix[ie][4]\n if not isinstance(istart, (list, np.ndarray)):\n istart, ilen = [istart], [ilen]\n if len(istart) == 0 or len(ilen) == 0:\n ich += 1\n continue\n iarr = np.concatenate([np.arange(i1, i1+i2) for i1,i2 in zip(istart, ilen)])\n rarr = matrix[ie][5]\n rarr = filters.gaussian_filter1d(rarr, smooth)\n\n\n # work out fwhm at ich #\n if not np.allclose(rarr, 0) and nchan > 100:\n imax = np.argmax(rarr)\n\n # limits of fwhm in energy grid units\n ic1 = np.argmin(np.abs(rarr[:imax]-rarr[imax]/2.)) if imax !=0 else 0\n ic2 = np.argmin(np.abs(rarr[imax:]-rarr[imax]/2.)) + imax\n width = ic2 - ic1\n \n else:\n #width = nchan - ich\n width = 1\n\n\n # get oversampling factor if we use_formula is requested #\n if use_formula:\n width = np.max([1, width])\n ind = range(ich, ich+width)\n if ind[-1] >= nchan:\n ind = range(ich, nchan)\n counts = np.max([sum(src_c[ind] - bgd_c[ind]), 1e-10] )\n counts *= 1./width # per resolution element\n x = np.log(counts*(1 + 0.20 *np.log(width)))\n osample_fac = 1. if x<2.119 else (0.08+7./x + 1.8/x**2)/(1+5.9/x)\n osample_fac = 1. / osample_fac\n # ----- #\n\n\n # bin width in channel units using oversample_fac\n width = np.int(np.round(np.max([1, width*1./osample_fac])))\n ind = range(ich, np.min([ich+width, nchan]) )\n\n \n # increase width until snr > min_snr #\n if min_snr:\n snr = sum(src_c[ind] - bgd_c[ind])\n while snr < 1 and ich+width<=nchan:\n width += 1\n ind = range(ich, min(ich+width, nchan) )\n snr = sum(src_c[ind] - bgd_c[ind])\n if snr > 0:\n snr /= np.sqrt(sum(src_c[ind] + bgd_c[ind]))\n while (snr < min_snr) and (ich+width < nchan):\n ind = range(ich, ich+width)\n if ind[-1] >= nchan:\n ind = range(ich, nchan)\n break\n\n snr = sum(src_c[ind] - bgd_c[ind])\n if snr <= 0:\n width += 1; continue\n snr /= np.sqrt(sum(src_c[ind] + bgd_c[ind]))\n width += 1\n \n # do we have a min_counts requirement? # \n if min_counts:\n counts = sum(src_c[ind] - bgd_c[ind])\n while (counts < min_counts) and (ich+width < nchan):\n ind = range(ich, ich+width)\n if ind[-1] >= nchan:\n ind = range(ich, nchan)\n break\n counts = sum(src_c[ind] - bgd_c[ind])\n width += 1\n ich += len(ind)\n if ich < nchan: ibin[ich] = 1\n # --------------------- #\n\n\n # ------------------ #\n # write the grouping #\n \n if write_chan:\n # write an ascii file and use grppha #\n ichan = np.arange(nchan)[ibin==1]\n if ichan[-1] < nchan-1:\n ichan = np.append(ichan, nchan)\n bins = []\n for ich in range(len(ichan)-1):\n bins.append([ichan[ich], ichan[ich+1]-1, ichan[ich+1]-ichan[ich]])\n txt = '\\n'.join(['{} {} {}'.format(*x) for x in bins])\n with open('tmp_chans.dat', 'w') as fp: fp.write(txt)\n os.system('rm {0} &> /dev/null'.format(out_file))\n os.system('grppha {} {} \"group tmp_chans.dat&exit\"'.format(spec_file, out_file))\n else:\n # modify the file with pyfits #\n os.system('rm {} &> /dev/null'.format(out_file))\n os.system('grppha {} {} \"group min 20&exit\" &> /dev/null'.format(spec_file, out_file))\n with pyfits.open(out_file) as fp:\n hdu = fp['SPECTRUM']\n orig_cols = hdu.columns\n orig_cols['GROUPING'].array = np.array(ibin, np.int) \n cols = pyfits.ColDefs(orig_cols)\n tbl = pyfits.BinTableHDU.from_columns(cols)\n hdu.header.update(tbl.header.copy())\n tbl.header = hdu.header.copy()\n grp = pyfits.HDUList([fp[0],tbl])\n #os.system('rm {0} &> /dev/null'.format(out_file))\n grp.writeto(out_file, overwrite=True)\n print('Grouped file {} written sucessfully'.format(out_file))\n # ------------------ #\n", "meta": {"hexsha": "ba049e1be8f325c3cc2702815c2b04ac2f1d7cd1", "size": 8588, "ext": "py", "lang": "Python", "max_stars_repo_path": "scripts/ogrppha.py", "max_stars_repo_name": "abduzoghbi/aztools", "max_stars_repo_head_hexsha": "949cc2ec0dbb4426be0d39c5c9832243c4dbde43", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "scripts/ogrppha.py", "max_issues_repo_name": "abduzoghbi/aztools", "max_issues_repo_head_hexsha": "949cc2ec0dbb4426be0d39c5c9832243c4dbde43", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "scripts/ogrppha.py", "max_forks_repo_name": "abduzoghbi/aztools", "max_forks_repo_head_hexsha": "949cc2ec0dbb4426be0d39c5c9832243c4dbde43", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.2362869198, "max_line_length": 94, "alphanum_fraction": 0.5163018165, "include": true, "reason": "import numpy,from scipy,from astropy", "num_tokens": 2306, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6187804337438501, "lm_q2_score": 0.32082130731838393, "lm_q1q2_score": 0.1985179476967386}} {"text": "import itertools\nimport logging\nimport math\nimport os\nimport string\nimport subprocess\nimport tempfile\nfrom collections import defaultdict, Counter\nfrom dataclasses import dataclass, field\nfrom typing import Dict, Iterable, List, Tuple, Optional, Set\n\nimport numpy\n\nfrom eltetrado.model import Atom3D, Structure3D, Structure2D, BasePair3D, Residue3D, GlycosidicBond, ONZ, \\\n GbaTetradClassification, Ion, Direction, LoopType, ONZM, GbaQuadruplexClassification, LoopClassification\n\nlogging.basicConfig(level=os.environ.get(\"LOGLEVEL\", \"INFO\"))\n\n\n@dataclass(order=True)\nclass Tetrad:\n @staticmethod\n def is_valid(nt1: Residue3D, nt2: Residue3D, nt3: Residue3D, nt4: Residue3D,\n pair_dictionary: Dict[Tuple[Residue3D, Residue3D], BasePair3D]) -> bool:\n lw1 = pair_dictionary[(nt1, nt2)].lw\n lw2 = pair_dictionary[(nt2, nt3)].lw\n lw3 = pair_dictionary[(nt3, nt4)].lw\n lw4 = pair_dictionary[(nt4, nt1)].lw\n for lw_i, lw_j in ((lw1, lw4), (lw2, lw1), (lw3, lw2), (lw4, lw3)):\n if lw_i.name[1] == lw_j.name[2]:\n return False\n return True\n\n nt1: Residue3D\n nt2: Residue3D\n nt3: Residue3D\n nt4: Residue3D\n pair_12: BasePair3D\n pair_23: BasePair3D\n pair_34: BasePair3D\n pair_41: BasePair3D\n onz: ONZ = field(init=False)\n gba_class: Optional[GbaTetradClassification] = field(init=False)\n planarity_deviation: float = field(init=False)\n ions_channel: List[Atom3D] = field(default_factory=list)\n ions_outside: Dict[Residue3D, List[Atom3D]] = field(default_factory=dict)\n\n def __post_init__(self):\n self.reorder_to_match_5p_3p()\n self.planarity_deviation = self.__calculate_planarity_deviation()\n\n def reorder_to_match_5p_3p(self):\n # transform into (0, 1, 2, 3)\n ni, nj, nk, nl = map(lambda nt: nt.index, self.nucleotides)\n indices = sorted((ni, nj, nk, nl))\n ni, nj, nk, nl = (indices.index(x) for x in (ni, nj, nk, nl))\n\n nmin = min(ni, nj, nk, nl)\n if nmin == ni:\n pass\n elif nmin == nj:\n self.nt1, self.nt2, self.nt3, self.nt4 = self.nt2, self.nt3, self.nt4, self.nt1\n self.pair_12, self.pair_23, self.pair_34, self.pair_41 = self.pair_23, self.pair_34, self.pair_41, self.pair_12\n elif nmin == nk:\n self.nt1, self.nt2, self.nt3, self.nt4 = self.nt3, self.nt4, self.nt1, self.nt2\n self.pair_12, self.pair_23, self.pair_34, self.pair_41 = self.pair_34, self.pair_41, self.pair_12, self.pair_23\n else:\n self.nt1, self.nt2, self.nt3, self.nt4 = self.nt4, self.nt1, self.nt2, self.nt3\n self.pair_12, self.pair_23, self.pair_34, self.pair_41 = self.pair_41, self.pair_12, self.pair_23, self.pair_34\n\n # flip order if necessary\n if self.pair_12.score() > self.pair_41.reverse().score():\n self.nt1, self.nt2, self.nt3, self.nt4 = self.nt1, self.nt4, self.nt3, self.nt2\n self.pair_12, self.pair_23, self.pair_34, self.pair_41 = self.pair_41.reverse(), self.pair_34.reverse(), self.pair_23.reverse(), self.pair_12.reverse()\n\n # ONZ and da Silva's classification are valid in 5'-3' order\n self.onz = self.__classify_onz()\n self.gba_class = self.__classify_by_gba()\n\n def reorder_to_match_other_tetrad(self, order: Tuple[Residue3D, Residue3D, Residue3D, Residue3D]):\n if order == (self.nt1, self.nt2, self.nt3, self.nt4):\n pass\n elif order == (self.nt2, self.nt3, self.nt4, self.nt1):\n self.pair_12, self.pair_23, self.pair_34, self.pair_41 = self.pair_23, self.pair_34, self.pair_41, self.pair_12\n elif order == (self.nt3, self.nt4, self.nt1, self.nt2):\n self.pair_12, self.pair_23, self.pair_34, self.pair_41 = self.pair_34, self.pair_41, self.pair_12, self.pair_23\n elif order == (self.nt4, self.nt1, self.nt2, self.nt3):\n self.pair_12, self.pair_23, self.pair_34, self.pair_41 = self.pair_41, self.pair_12, self.pair_23, self.pair_34\n elif order == (self.nt4, self.nt3, self.nt2, self.nt1):\n self.pair_12, self.pair_23, self.pair_34, self.pair_41 = self.pair_34.reverse(), self.pair_23.reverse(), self.pair_12.reverse(), self.pair_41.reverse()\n elif order == (self.nt3, self.nt2, self.nt1, self.nt4):\n self.pair_12, self.pair_23, self.pair_34, self.pair_41 = self.pair_23.reverse(), self.pair_12.reverse(), self.pair_41.reverse(), self.pair_34.reverse()\n elif order == (self.nt2, self.nt1, self.nt4, self.nt3):\n self.pair_12, self.pair_23, self.pair_34, self.pair_41 = self.pair_12.reverse(), self.pair_41.reverse(), self.pair_34.reverse(), self.pair_23.reverse()\n elif order == (self.nt1, self.nt4, self.nt3, self.nt2):\n self.pair_12, self.pair_23, self.pair_34, self.pair_41 = self.pair_41.reverse(), self.pair_34.reverse(), self.pair_23.reverse(), self.pair_12.reverse()\n else:\n raise RuntimeError(f'Cannot apply order: {order}')\n\n self.nt1, self.nt2, self.nt3, self.nt4 = order\n\n def __classify_onz(self) -> ONZ:\n # transform into (0, 1, 2, 3)\n ni, nj, nk, nl = (nt.index for nt in self.nucleotides)\n indices = sorted((ni, nj, nk, nl))\n ni, nj, nk, nl = (indices.index(x) for x in (ni, nj, nk, nl))\n\n while ni != 0:\n ni, nj, nk, nl = nl, ni, nj, nk\n\n order = (nj, nk, nl)\n if order == (1, 2, 3):\n return ONZ.O_PLUS\n elif order == (3, 2, 1):\n return ONZ.O_MINUS\n elif order == (1, 3, 2):\n return ONZ.N_PLUS\n elif order == (2, 3, 1):\n return ONZ.N_MINUS\n elif order == (2, 1, 3):\n return ONZ.Z_PLUS\n elif order == (3, 1, 2):\n return ONZ.Z_MINUS\n\n raise RuntimeError(f'Impossible combination: {ni} {nj} {nk} {nl}')\n\n def __classify_by_gba(self) -> Optional[GbaTetradClassification]:\n \"\"\"\n See: Webba da Silva, M. (2007). Geometric Formalism for DNA Quadruplex Folding.\n Chemistry - A European Journal, 13(35), 9738–9745. https://doi.org/10.1002/chem.200701255\n\n :return: Classification according to Webba da Silva or n/a\n \"\"\"\n # without all nucleotides having a valid syn/anti, this classification is impossible\n if not all([nt.chi_class in (GlycosidicBond.syn, GlycosidicBond.anti) for nt in self.nucleotides]):\n return None\n\n # this will create a 4-letter string made of 's' for syn or 'a' for anti\n fingerprint = ''.join([nt.chi_class.value[0] for nt in self.nucleotides])\n\n # this dict has all classes mapped to fingerprints\n gba_classes = {\n 'aass': GbaTetradClassification.Ia,\n 'ssaa': GbaTetradClassification.Ib,\n 'asas': GbaTetradClassification.IIa,\n 'sasa': GbaTetradClassification.IIb,\n 'asaa': GbaTetradClassification.IIIa,\n 'sass': GbaTetradClassification.IIIb,\n 'aaas': GbaTetradClassification.IVa,\n 'sssa': GbaTetradClassification.IVb,\n 'aasa': GbaTetradClassification.Va,\n 'ssas': GbaTetradClassification.Vb,\n 'assa': GbaTetradClassification.VIa,\n 'saas': GbaTetradClassification.VIb,\n 'asss': GbaTetradClassification.VIIa,\n 'saaa': GbaTetradClassification.VIIb,\n 'aaaa': GbaTetradClassification.VIIIa,\n 'ssss': GbaTetradClassification.VIIIb\n }\n\n if fingerprint not in gba_classes:\n logging.error(f'Impossible combination of syn/anti: {[nt.chi_class for nt in self.nucleotides]}')\n return None\n return gba_classes[fingerprint]\n\n def __calculate_planarity_deviation(self) -> float:\n outer = [nt.outermost_atom for nt in self.nucleotides]\n inner = [nt.innermost_atom for nt in self.nucleotides]\n return numpy.linalg.norm(center_of_mass(outer) - center_of_mass(inner))\n\n @property\n def nucleotides(self) -> Tuple[Residue3D, Residue3D, Residue3D, Residue3D]:\n return self.nt1, self.nt2, self.nt3, self.nt4\n\n def __hash__(self):\n return hash(frozenset([self.nt1, self.nt2, self.nt3, self.nt4]))\n\n def __str__(self):\n return f' ' \\\n f'{self.nt1.full_name} {self.nt2.full_name} {self.nt3.full_name} {self.nt4.full_name} ' \\\n f'{self.pair_12.lw.value} {self.pair_23.lw.value} {self.pair_34.lw.value} {self.pair_41.lw.value} ' \\\n f'{self.onz.value} {self.gba_class.value} ' \\\n f'planarity={round(self.planarity_deviation, 2)} ' \\\n f'{self.__ions_channel_str()} ' \\\n f'{self.__ions_outside_str()}\\n'\n\n def chains(self) -> Set[str]:\n return set([nt.chain for nt in self.nucleotides])\n\n def is_disjoint(self, other) -> bool:\n return frozenset(self.nucleotides).isdisjoint(frozenset(other.nucleotides))\n\n def center(self) -> numpy.ndarray:\n return center_of_mass(self.outer_and_inner_atoms())\n\n def outer_and_inner_atoms(self) -> List[Atom3D]:\n return list(map(lambda residue: residue.outermost_atom, self.nucleotides)) + \\\n list(map(lambda residue: residue.innermost_atom, self.nucleotides))\n\n def __ions_channel_str(self) -> str:\n if self.ions_channel:\n return 'ions_channel=' + ','.join([atom.atomName for atom in self.ions_channel])\n return ''\n\n def __ions_outside_str(self) -> str:\n if self.ions_outside:\n result = []\n for residue, ions in self.ions_outside.items():\n result.append(f'{residue.full_name}: [{\",\".join([ion.atomName for ion in ions])}]')\n return 'ions_outside=' + ' '.join(result)\n return ''\n\n\n@dataclass\nclass TetradPair:\n tetrad1: Tetrad\n tetrad2: Tetrad\n stacked: Dict[Residue3D, Residue3D]\n tetrad2_nts_best_order: Tuple[Residue3D, Residue3D, Residue3D, Residue3D] = field(init=False)\n direction: Direction = field(init=False)\n rise: float = field(init=False)\n twist: float = field(init=False)\n\n def __post_init__(self):\n self.tetrad2_nts_best_order = (\n self.stacked[self.tetrad1.nt1], self.stacked[self.tetrad1.nt2],\n self.stacked[self.tetrad1.nt3], self.stacked[self.tetrad1.nt4]\n )\n self.direction = self.__determine_direction()\n self.rise = self.__calculate_rise()\n self.twist = self.__calculate_twist()\n\n def __determine_direction(self) -> Direction:\n indices1 = list(map(lambda nt: nt.index, self.tetrad1.nucleotides))\n indices2 = list(map(lambda nt: nt.index, self.tetrad2_nts_best_order))\n\n # count directions 5' -> 3' as +1 or -1\n counter = Counter(1 if j - i > 0 else -1 for i, j in zip(indices1, indices2))\n direction, count = counter.most_common()[0]\n\n if count == 4:\n # all in the same direction\n return Direction.parallel\n elif count == 2:\n # two in +, one in - direction\n return Direction.antiparallel\n\n return Direction.hybrid\n\n def __calculate_rise(self) -> float:\n t1 = self.tetrad1.outer_and_inner_atoms()\n t2 = self.tetrad2.outer_and_inner_atoms()\n return numpy.linalg.norm(center_of_mass(t1) - center_of_mass(t2))\n\n def __calculate_twist(self) -> float:\n nt1_1, nt1_2, _, _ = self.tetrad1.nucleotides\n nt2_1, nt2_2, _, _ = self.tetrad2_nts_best_order\n\n v1 = nt1_1.find_atom(\"C1'\").coordinates() - nt1_2.find_atom(\"C1'\").coordinates()\n v1 = v1 / numpy.linalg.norm(v1)\n v2 = nt2_1.find_atom(\"C1'\").coordinates() - nt2_2.find_atom(\"C1'\").coordinates()\n v2 = v2 / numpy.linalg.norm(v2)\n return math.degrees(numpy.arccos(numpy.clip(numpy.dot(v1, v2), -1.0, 1.0)))\n\n def __str__(self):\n return f' direction={self.direction.value} rise={round(self.rise, 2)} twist={round(self.twist, 2)}\\n'\n\n\n@dataclass\nclass Tract:\n nucleotides: List[Residue3D]\n\n def __str__(self):\n return f' {\", \".join(map(lambda nt: nt.full_name, self.nucleotides))}'\n\n\n@dataclass\nclass Loop:\n nucleotides: List[Residue3D]\n loop_type: Optional[LoopType]\n\n def __str__(self):\n return f' {self.loop_type.value if self.loop_type else \"n/a\"} ' \\\n f'{\", \".join(map(lambda nt: nt.full_name, self.nucleotides))}'\n\n\n@dataclass\nclass Quadruplex:\n tetrads: List[Tetrad]\n tetrad_pairs: List[TetradPair]\n structure3d: Structure3D\n onzm: Optional[ONZM] = field(init=False)\n gba_classes: List[GbaQuadruplexClassification] = field(init=False)\n tracts: List[Tract] = field(init=False)\n loops: List[Loop] = field(init=False)\n loop_class: Optional[LoopClassification] = field(init=False)\n\n def __post_init__(self):\n self.onzm = self.__classify_onzm()\n self.gba_classes = self.__classify_by_gba()\n self.tracts = self.__find_tracts()\n self.loops = self.__find_loops()\n self.loop_class = self.__classify_by_loops()\n\n def __classify_onzm(self) -> Optional[ONZM]:\n if len(self.tetrads) == 1:\n return None\n if any([t.onz is None for t in self.tetrads]):\n return None\n\n counter = Counter([t.onz.value[0] for t in self.tetrads])\n onz, support = counter.most_common()[0]\n if support != len(self.tetrads):\n onz = 'M'\n\n counter = Counter([tp.direction.value[0] for tp in self.tetrad_pairs])\n direction, support = counter.most_common()[0]\n if support != len(self.tetrad_pairs):\n direction = 'h'\n\n counter = Counter([t.onz.value[1] for t in self.tetrads])\n plus_minus, support = counter.most_common()[0]\n if support != len(self.tetrads):\n plus_minus = '*'\n\n return ONZM.from_value(f'{onz}{direction}{plus_minus}')\n\n def __classify_by_gba(self) -> List[GbaQuadruplexClassification]:\n gbas = set()\n for t in self.tetrads:\n gba = t.gba_class\n if gba is not None:\n gbas.add(gba.value[:-1]) # discard 'a' or 'b' subvariant\n roman_numerals = {'I': 1, 'II': 2, 'III': 3, 'IV': 4, 'V': 5, 'VI': 6, 'VII': 7, 'VIII': 8}\n gbas = sorted(gbas, key=lambda gba: roman_numerals.get(gba, 100))\n return list(map(lambda x: GbaQuadruplexClassification[x], gbas))\n\n def __find_tracts(self) -> List[Tract]:\n tracts = [[self.tetrads[0].nt1], [self.tetrads[0].nt2], [self.tetrads[0].nt3], [self.tetrads[0].nt4]]\n if len(self.tetrad_pairs) > 0:\n for tetrad_pair in self.tetrad_pairs:\n nt_dict = {\n tetrad_pair.tetrad1.nt1: tetrad_pair.tetrad2_nts_best_order[0],\n tetrad_pair.tetrad1.nt2: tetrad_pair.tetrad2_nts_best_order[1],\n tetrad_pair.tetrad1.nt3: tetrad_pair.tetrad2_nts_best_order[2],\n tetrad_pair.tetrad1.nt4: tetrad_pair.tetrad2_nts_best_order[3],\n }\n for i in range(4):\n tracts[i].append(nt_dict[tracts[i][-1]])\n return [Tract(nts) for nts in tracts]\n\n def __find_loops(self) -> List[Loop]:\n if len(self.tetrads) == 1:\n return []\n\n loops = []\n tetrad_nucleotides = sorted([nt for tetrad in self.tetrads for nt in tetrad.nucleotides],\n key=lambda nt: nt.index)\n\n for i in range(1, len(tetrad_nucleotides)):\n nprev = tetrad_nucleotides[i - 1]\n ncur = tetrad_nucleotides[i]\n if ncur.index - nprev.index > 1 and ncur.chain == nprev.chain:\n for tract in self.tracts:\n if nprev in tract.nucleotides and ncur in tract.nucleotides:\n break\n else:\n nts = list(filter(lambda nt: nprev.index < nt.index < ncur.index, self.structure3d.residues))\n loop_type = self.__detect_loop_type(nprev, ncur)\n loops.append(Loop(nts, loop_type))\n return loops\n\n def __detect_loop_type(self, nt_first: Residue3D, nt_last: Residue3D) -> Optional[LoopType]:\n tetrad_with_first = self.__find_tetrad_with_nt(nt_first)\n tetrad_with_last = self.__find_tetrad_with_nt(nt_last)\n\n if tetrad_with_first is None or tetrad_with_last is None:\n logging.warning(f'Failed to classify the loop between {nt_first} and {nt_last}')\n return None\n\n if tetrad_with_first == tetrad_with_last:\n # diagonal or laterals happen when first and last nt of a loop is in the same tetrad\n sign = self.__detect_loop_sign(nt_first, nt_last, tetrad_with_first)\n if sign is not None:\n return LoopType.from_value(f'lateral{sign}')\n return LoopType.diagonal\n\n tract_with_last = self.__find_tract_with_nt(nt_last)\n if tract_with_last is not None:\n # search along the tract to check what pairs with nt_first\n for nt in tract_with_last.nucleotides:\n if nt in tetrad_with_first.nucleotides:\n sign = self.__detect_loop_sign(nt_first, nt, tetrad_with_first)\n if sign is not None:\n return LoopType.from_value(f'propeller{sign}')\n logging.warning(f'Failed to classify the loop between {nt_first} and {nt_last}')\n return None\n\n def __find_tetrad_with_nt(self, nt: Residue3D) -> Optional[Tetrad]:\n for tetrad in self.tetrads:\n if nt in tetrad.nucleotides:\n return tetrad\n return None\n\n def __find_tract_with_nt(self, nt: Residue3D) -> Optional[Tract]:\n for tract in self.tracts:\n if nt in tract.nucleotides:\n return tract\n return None\n\n def __detect_loop_sign(self, first: Residue3D, last: Residue3D, tetrad: Tetrad) -> Optional[str]:\n for pair in [tetrad.pair_12, tetrad.pair_23, tetrad.pair_34, tetrad.pair_41]:\n # main check\n if pair.nt1 == first and pair.nt2 == last:\n if pair.score() < pair.reverse().score():\n return '-'\n return '+'\n # reverse check\n if pair.nt1 == last and pair.nt2 == first:\n if pair.score() < pair.reverse().score():\n return '+'\n return '-'\n return None\n\n def __classify_by_loops(self) -> Optional[LoopClassification]:\n if len(self.loops) != 3 or any([loop.loop_type is None for loop in self.loops]):\n return None\n\n loop_classes = {\n 'ppp': '1',\n 'ppl': '2',\n 'plp': '3',\n 'lpp': '4',\n 'pdp': '5',\n 'lll': '6',\n 'llp': '7',\n 'lpl': '8',\n 'pll': '9',\n 'pdl': '10',\n 'ldl': '11',\n 'dpd': '12',\n 'ldp': '13'\n }\n fingerprint = ''.join([loop.loop_type.value[0] for loop in self.loops])\n if fingerprint not in loop_classes:\n logging.error(f'Unknown loop classification: {fingerprint}')\n return None\n subtype = 'a' if self.loops[0 if fingerprint != 'dpd' else 1].loop_type.value[-1] == '-' else 'b'\n return LoopClassification.from_value(f'{loop_classes[fingerprint]}{subtype}')\n\n def __str__(self):\n builder = ''\n if len(self.tetrads) == 1:\n builder += ' single tetrad\\n'\n builder += str(self.tetrads[0])\n else:\n builder += f' {self.onzm.value if self.onzm is not None else \"R\"}'\n builder += f' {\",\".join(map(lambda gba: gba.value, self.gba_classes))}'\n if self.loop_class:\n builder += f' {self.loop_class.value} {self.loop_class.loop_progression()}'\n else:\n builder += f' n/a'\n builder += f' quadruplex with {len(self.tetrads)} tetrads\\n'\n builder += str(self.tetrad_pairs[0].tetrad1)\n for tetrad_pair in self.tetrad_pairs:\n builder += str(tetrad_pair)\n builder += str(tetrad_pair.tetrad2)\n if self.tracts:\n builder += '\\n Tracts:\\n'\n for tract in self.tracts:\n builder += f'{tract}\\n'\n if self.loops:\n builder += '\\n Loops:\\n'\n for loop in self.loops:\n builder += f'{loop}\\n'\n builder += '\\n'\n return builder\n\n\n@dataclass\nclass Helix:\n tetrads: List[Tetrad]\n tetrad_pairs: List[TetradPair]\n structure3d: Structure3D\n quadruplexes: List[Quadruplex] = field(init=False)\n\n def __post_init__(self):\n self.quadruplexes = self.__find_quadruplexes()\n\n def __find_quadruplexes(self):\n if len(self.tetrad_pairs) == 0:\n return [Quadruplex(self.tetrads, [], self.structure3d)]\n\n quadruplexes = list()\n tetrads = list()\n\n for tetrad in [self.tetrad_pairs[0].tetrad1] + [tetrad_pair.tetrad2 for tetrad_pair in self.tetrad_pairs]:\n if tetrads:\n if tetrad.chains().isdisjoint(tetrads[-1].chains()):\n quadruplexes.append(Quadruplex(tetrads, self.__filter_tetrad_pairs(tetrads), self.structure3d))\n tetrads = list()\n tetrads.append(tetrad)\n\n quadruplexes.append(Quadruplex(tetrads, self.__filter_tetrad_pairs(tetrads), self.structure3d))\n\n return quadruplexes\n\n def __filter_tetrad_pairs(self, tetrads: List[Tetrad]) -> List[TetradPair]:\n chains = set()\n for tetrad in tetrads:\n chains.update(tetrad.chains())\n\n def check_tetrad(t: Tetrad) -> bool:\n return not t.chains().isdisjoint(chains)\n\n def check_pair(tp: TetradPair) -> bool:\n return check_tetrad(tp.tetrad1) and check_tetrad(tp.tetrad2)\n\n return list(filter(check_pair, self.tetrad_pairs))\n\n def __str__(self):\n builder = ''\n if len(self.tetrads) > 1:\n builder += f'n4-helix with {len(self.tetrads)} tetrads\\n'\n for quadruplex in self.quadruplexes:\n builder += str(quadruplex)\n elif len(self.tetrads) == 1:\n builder += 'single tetrad without stacking\\n'\n builder += str(self.tetrads[0])\n return builder\n\n\n@dataclass\nclass Analysis:\n structure2d: Structure2D\n structure3d: Structure3D\n strict: bool\n no_reorder: bool\n stacking_mismatch: int\n base_pairs: List[BasePair3D] = field(init=False)\n base_pair_graph: Dict[Residue3D, List[Residue3D]] = field(init=False)\n base_pair_dict: Dict[Tuple[Residue3D, Residue3D], BasePair3D] = field(init=False)\n stacking_graph: Dict[Residue3D, List[Residue3D]] = field(init=False)\n tetrads: List[Tetrad] = field(init=False)\n tetrad_scores: Dict[Tetrad, Dict[Tetrad, Tuple[int, Tuple, Tuple]]] = field(init=False)\n tetrad_pairs: List[TetradPair] = field(init=False)\n helices: List[Helix] = field(init=False)\n ions: List[Atom3D] = field(init=False)\n sequence: str = field(init=False)\n line1: str = field(init=False)\n line2: str = field(init=False)\n shifts: Dict[Residue3D, int] = field(init=False)\n\n def __post_init__(self):\n self.base_pairs = self.structure3d.base_pairs(self.structure2d)\n self.base_pair_graph = self.structure3d.base_pair_graph(self.structure2d, self.strict)\n self.base_pair_dict = self.structure3d.base_pair_dict(self.structure2d, self.strict)\n self.stacking_graph = self.structure3d.stacking_graph(self.structure2d)\n self.tetrads = self.__find_tetrads(self.no_reorder)\n self.tetrad_scores = self.__calculate_tetrad_scores()\n self.tetrad_pairs = self.__find_tetrad_pairs(self.stacking_mismatch)\n self.helices = self.__find_helices()\n\n if not self.no_reorder:\n self.__find_best_chain_order()\n\n self.sequence, self.line1, self.line2, self.shifts = self.__generate_twoline_dotbracket()\n self.ions = self.__find_ions()\n self.__assign_ions_to_tetrads()\n\n def __find_tetrads(self, no_reorder=False) -> List[Tetrad]:\n # search for a tetrad: i -> j -> k -> l\n # ^--------------^\n tetrads = []\n for i in self.base_pair_graph:\n for j in filter(lambda x: x != i, self.base_pair_graph[i]):\n for k in filter(lambda x: x not in (i, j), self.base_pair_graph[j]):\n for l in filter(lambda x: x not in (i, j, k) and i in self.base_pair_graph[x],\n self.base_pair_graph[k]):\n if Tetrad.is_valid(i, j, k, l, self.base_pair_dict):\n pair_12 = self.base_pair_dict[(i, j)]\n pair_23 = self.base_pair_dict[(j, k)]\n pair_34 = self.base_pair_dict[(k, l)]\n pair_41 = self.base_pair_dict[(l, i)]\n tetrads.append(Tetrad(i, j, k, l, pair_12, pair_23, pair_34, pair_41))\n\n # build graph of tetrads\n while tetrads:\n graph = defaultdict(list)\n for (ti, tj) in itertools.combinations(tetrads, 2):\n if not ti.is_disjoint(tj):\n graph[ti].append(tj)\n graph[tj].append(ti)\n\n # remove tetrad which conflicts the most with others\n # in case of a tie, remove one which has the worst planarity deviation\n candidates = sorted(tetrads, key=lambda t: (len(graph[t]), t.planarity_deviation),\n reverse=True)\n if len(graph[candidates[0]]) > 0:\n tetrads.remove(candidates[0])\n else:\n break\n\n return sorted(tetrads, key=lambda t: min(map(lambda nt: nt.index, t.nucleotides)))\n\n def __calculate_tetrad_scores(self) \\\n -> Dict[Tetrad, Dict[Tetrad, Tuple[int, Tuple, Tuple]]]:\n def is_next_by_stacking(nt1: Residue3D, nt2: Residue3D) -> bool:\n return nt2 in self.stacking_graph.get(nt1, [])\n\n def is_next_sequentially(nt1: Residue3D, nt2: Residue3D) -> bool:\n return nt1.chain == nt2.chain and abs(nt1.index - nt2.index) == 1\n\n tetrad_scores = defaultdict(dict)\n\n for ti, tj in itertools.combinations(self.tetrads, 2):\n nts1 = ti.nucleotides\n best_score = 0\n best_score_sequential = 0\n best_score_stacking = 0\n best_order = tj.nucleotides\n\n n1, n2, n3, n4 = tj.nucleotides\n viable_permutations = [(n1, n2, n3, n4), (n2, n3, n4, n1), (n3, n4, n1, n2), (n4, n1, n2, n3),\n (n1, n4, n3, n2), (n4, n3, n2, n1), (n3, n2, n1, n4), (n2, n1, n4, n3)]\n\n for nts2 in viable_permutations:\n score_stacking = [1 if is_next_by_stacking(nts1[i], nts2[i]) else 0 for i in range(4)]\n score_sequential = [1 if is_next_sequentially(nts1[i], nts2[i]) else 0 for i in range(4)]\n score = sum([max(score_stacking[i], score_sequential[i]) for i in range(4)])\n score_sequential = sum(score_sequential)\n score_stacking = sum(score_stacking)\n\n if (score, score_sequential, score_stacking) > (best_score, best_score_sequential, best_score_stacking):\n best_score, best_score_sequential, best_score_stacking = score, score_sequential, score_stacking\n best_order = nts2\n if best_score == 4:\n break\n\n tetrad_scores[ti][tj] = (best_score, nts1, best_order)\n tetrad_scores[tj][ti] = (best_score, best_order, nts1)\n\n return tetrad_scores\n\n def __find_tetrad_pairs(self, stacking_mismatch: int) -> List[TetradPair]:\n tetrads = list(self.tetrads)\n best_score = 0\n best_order = tetrads\n\n for ti in tetrads:\n score = 0\n order = [ti]\n candidates = set(self.tetrads) - {ti}\n\n while candidates:\n tj = max([tj for tj in candidates], key=lambda tk: self.tetrad_scores[ti][tk][0])\n score += self.tetrad_scores[ti][tj][0]\n order.append(tj)\n candidates.remove(tj)\n ti = tj\n\n if score > best_score:\n best_score = score\n best_order = order\n\n if best_score == (len(self.tetrads) - 1) * 4:\n break\n\n tetrad_pairs = []\n\n for i in range(1, len(best_order)):\n ti, tj = best_order[i - 1], best_order[i]\n score = self.tetrad_scores[ti][tj][0]\n\n if score >= (4 - stacking_mismatch):\n nts1, nts2 = self.tetrad_scores[ti][tj][1:]\n stacked = {nts1[i]: nts2[i] for i in range(4)}\n stacked.update({v: k for k, v in stacked.items()})\n tetrad_pairs.append(TetradPair(ti, tj, stacked))\n order = (stacked[ti.nt1], stacked[ti.nt2], stacked[ti.nt3], stacked[ti.nt4])\n tj.reorder_to_match_other_tetrad(order)\n\n return tetrad_pairs\n\n def __find_helices(self):\n helices = []\n helix_tetrads = []\n helix_tetrad_pairs = []\n\n for tp in self.tetrad_pairs:\n ti, tj = tp.tetrad1, tp.tetrad2\n if not helix_tetrads:\n helix_tetrads.append(ti)\n score = self.tetrad_scores[helix_tetrads[-1]][tj][0]\n if score >= (4 - self.stacking_mismatch):\n helix_tetrads.append(tj)\n helix_tetrad_pairs.append(tp)\n else:\n helices.append(Helix(helix_tetrads, helix_tetrad_pairs, self.structure3d))\n helix_tetrads = [ti, tj]\n helix_tetrad_pairs = [tp]\n\n if helix_tetrads:\n helices.append(Helix(helix_tetrads, helix_tetrad_pairs, self.structure3d))\n\n for tetrad in self.tetrads:\n if not any([tetrad in helix.tetrads for helix in helices]):\n helices.append(Helix([tetrad], [], self.structure3d))\n\n return helices\n\n def __find_best_chain_order(self):\n chain_groups = self.__group_related_chains()\n final_order = []\n\n for chains in chain_groups:\n best_permutation, best_score = chains, (1e10, 1e10)\n\n if len(chains) > 1:\n for permutation in itertools.permutations(chains):\n self.__reorder_chains(permutation)\n classifications = [t.onz for h in self.helices for t in h.tetrads]\n logging.debug(\n f'Checking reorder: {\" \".join(permutation)} {\" \".join(map(lambda c: c.value, classifications))}')\n\n onz_score = sum(c.score() for c in classifications)\n chain_order_score = self.__chain_order_score(permutation)\n score = (onz_score, chain_order_score)\n\n if score < best_score:\n best_score = score\n best_permutation = permutation\n elif score == best_score:\n # in case of a tie, pick permutation earlier in lexicographical sense\n if permutation < best_permutation:\n best_permutation = permutation\n\n final_order.extend(best_permutation)\n\n if len(final_order) > 1:\n self.__reorder_chains(final_order)\n classifications = [t.onz for h in self.helices for t in h.tetrads]\n logging.debug(f'Selected chain order: {\" \".join(final_order)} '\n f'{\" \".join(map(lambda onz: onz.value, classifications))}')\n\n self.tetrads = self.__find_tetrads(True)\n self.tetrad_scores = self.__calculate_tetrad_scores()\n self.tetrad_pairs = self.__find_tetrad_pairs(self.stacking_mismatch)\n self.helices = self.__find_helices()\n\n def __group_related_chains(self) -> List[List[str]]:\n candidates = set()\n\n for h in self.helices:\n for t in h.tetrads:\n candidates.add(frozenset([t.nt1.chain, t.nt2.chain, t.nt3.chain, t.nt4.chain]))\n\n candidates = [set(c) for c in candidates]\n changed = True\n\n while changed:\n changed = False\n\n for i, j in itertools.combinations(range(len(candidates)), 2):\n qi, qj = candidates[i], candidates[j]\n\n if not qi.isdisjoint(qj):\n qi.update(qj)\n del candidates[j]\n changed = True\n break\n\n candidates = sorted(candidates, key=lambda x: len(x), reverse=True)\n groups = []\n\n for candidate in candidates:\n if any([group.issuperset(candidate) for group in groups]):\n continue\n groups.append(candidate)\n\n return sorted([sorted(group) for group in groups], key=lambda x: x[0])\n\n def __reorder_chains(self, chain_order: Iterable[str]):\n i = 1\n for chain in chain_order:\n for nt in self.structure3d.residues:\n if nt.chain == chain:\n nt.index = i\n i += 1\n for nt in self.structure3d.residues:\n if nt.chain not in chain_order:\n nt.index = i\n i += 1\n\n if len(self.tetrad_pairs) > 0:\n self.tetrad_pairs[0].tetrad1.reorder_to_match_5p_3p()\n for tp in self.tetrad_pairs:\n order = (tp.stacked[tp.tetrad1.nt1], tp.stacked[tp.tetrad1.nt2],\n tp.stacked[tp.tetrad1.nt3], tp.stacked[tp.tetrad1.nt4])\n tp.tetrad2.reorder_to_match_5p_3p() # this is required to recalculate ONZ\n tp.tetrad2.reorder_to_match_other_tetrad(order)\n\n def __chain_order_score(self, chain_order: Tuple[str, ...]) -> int:\n chain_pairs = []\n for h in self.helices:\n for t in h.tetrads:\n for p in [t.pair_12, t.pair_23, t.pair_34, t.pair_41]:\n c1 = p.nt1.chain\n c2 = p.nt2.chain\n if c1 != c2 and c1 in chain_order and c2 in chain_order:\n chain_pairs.append([c1, c2])\n sum_sq = 0\n for c1, c2 in chain_pairs:\n sum_sq += (chain_order.index(c1) - chain_order.index(c2)) ** 2\n return sum_sq\n\n def __find_ions(self) -> List[Atom3D]:\n metal_atom_names = set([ion.value.upper() for ion in Ion])\n ions = []\n used = set()\n for residue in self.structure3d.residues:\n for atom in residue.atoms:\n if atom.atomName.upper() in metal_atom_names:\n coordinates = tuple(atom.coordinates())\n if coordinates not in used:\n ions.append(atom)\n used.add(coordinates)\n return ions\n\n def __assign_ions_to_tetrads(self) \\\n -> Tuple[Dict[Tetrad, List[Atom3D]], Dict[Tuple[Tetrad, Residue3D], List[Atom3D]]]:\n if len(self.tetrads) == 0:\n return {}, {}\n\n ions_channel = defaultdict(list)\n ions_outside = defaultdict(list)\n\n for ion in self.ions:\n min_distance = math.inf\n min_tetrad = self.tetrads[0]\n\n for tetrad in self.tetrads:\n distance = numpy.linalg.norm(ion.coordinates() - tetrad.center())\n if distance < min_distance:\n min_distance = distance\n min_tetrad = tetrad\n\n # TODO: verify threshold of 6A between an ion and tetrad channel\n if min_distance < 6.0:\n ions_channel[min_tetrad].append(ion)\n continue\n\n min_distance = math.inf\n min_tetrad = self.tetrads[0]\n min_nt = min_tetrad.nt1\n\n for tetrad in self.tetrads:\n for nt in tetrad.nucleotides:\n for atom in nt.atoms:\n distance = numpy.linalg.norm(ion.coordinates() - atom.coordinates())\n if distance < min_distance:\n min_distance = distance\n min_tetrad = tetrad\n min_nt = nt\n\n # TODO: verify threshold of 3A between an ion and an atom\n if min_distance < 3.0:\n ions_outside[(min_tetrad, min_nt)].append(ion)\n continue\n\n logging.debug(f'Skipping an ion, because it is too far from any tetrad (distance={min_distance})')\n\n for tetrad, ions in ions_channel.items():\n tetrad.ions_channel = ions\n for pair, ions in ions_outside.items():\n tetrad, residue = pair\n tetrad.ions_outside[residue] = ions\n\n def __generate_twoline_dotbracket(self) -> Tuple[str, str, str, Dict[Residue3D, int]]:\n layer1, layer2 = [], []\n for tetrad in self.tetrads:\n layer1.extend([tetrad.pair_12, tetrad.pair_34])\n layer2.extend([tetrad.pair_23, tetrad.pair_41])\n sequence, line1, shifts = self.__elimination_conflicts(layer1)\n _, line2, _ = self.__elimination_conflicts(layer2)\n return sequence, line1, line2, shifts\n\n def __elimination_conflicts(self, pairs: List[BasePair3D]) -> Tuple[str, str, Dict[Residue3D, int]]:\n orders = dict()\n order = 0\n queue = list(pairs)\n removed = []\n\n while queue:\n conflicts = defaultdict(list)\n for pi, pj in itertools.combinations(queue, 2):\n if pi.conflicts_with(pj):\n conflicts[pi].append(pj)\n conflicts[pj].append(pi)\n if conflicts:\n pair, _ = max(conflicts.items(), key=lambda x: (len(x[1]), x[0].nt1))\n removed.append(pair)\n queue.remove(pair)\n else:\n orders.update({pair: order for pair in queue})\n queue, removed = removed, []\n order += 1\n\n opening = '([{<' + string.ascii_uppercase\n closing = ')]}>' + string.ascii_lowercase\n dotbracket = dict()\n for pair, order in orders.items():\n nt1, nt2 = sorted([pair.nt1, pair.nt2])\n dotbracket[nt1] = opening[order]\n dotbracket[nt2] = closing[order]\n\n sequence = ''\n structure = ''\n shifts = dict()\n shift_value = 0\n chain = None\n for nt in sorted(filter(lambda nt: nt.is_nucleotide, self.structure3d.residues), key=lambda nt: nt.index):\n if chain and chain != nt.chain:\n sequence += '-'\n structure += '-'\n shift_value += 1\n sequence += nt.one_letter_name\n structure += dotbracket.get(nt, '.')\n shifts[nt] = shift_value\n chain = nt.chain\n return sequence, structure, shifts\n\n def __str__(self):\n builder = f'Chain order: {\" \".join(self.__chain_order())}\\n'\n for helix in self.helices:\n builder += str(helix)\n builder += f'{self.sequence}\\n{self.line1}\\n{self.line2}'\n return builder\n\n def __chain_order(self) -> List[str]:\n only_nucleic_acids = filter(lambda nt: nt.is_nucleotide, self.structure3d.residues)\n return list({nt.chain: 0 for nt in sorted(only_nucleic_acids, key=lambda nt: nt.index)}.keys())\n\n def canonical(self) -> List[BasePair3D]:\n return [base_pair for base_pair in self.base_pairs if base_pair.is_canonical()]\n\n\n@dataclass\nclass Visualizer:\n analysis: Analysis\n tetrads: List[Tetrad]\n complete2d: bool\n onz_dict: Dict[BasePair3D, ONZ] = field(init=False)\n\n def __post_init__(self):\n self.onz_dict = {pair: tetrad.onz for tetrad in self.tetrads for pair in\n [tetrad.pair_12, tetrad.pair_23, tetrad.pair_34, tetrad.pair_41]}\n\n def visualize(self, prefix: str, suffix: str):\n fasta = tempfile.NamedTemporaryFile('w+', suffix='.fasta')\n fasta.write(f'>{prefix}-{suffix}\\n')\n fasta.write(self.analysis.sequence)\n fasta.flush()\n\n layer1, layer2 = [], []\n for tetrad in self.tetrads:\n layer1.extend([tetrad.pair_12, tetrad.pair_34])\n layer2.extend([tetrad.pair_23, tetrad.pair_41])\n helix1 = self.__to_helix(layer1, self.analysis.canonical() if self.complete2d else [])\n helix2 = self.__to_helix(layer2)\n\n currdir = os.path.dirname(os.path.realpath(__file__))\n output_pdf = f'{prefix}-{suffix}.pdf'\n run = subprocess.run([os.path.join(currdir, 'quadraw.R'), fasta.name, helix1.name, helix2.name, output_pdf],\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE)\n if run.returncode == 0:\n print('\\nPlot:', output_pdf)\n else:\n logging.error(f'Failed to prepare visualization, reason:\\n {run.stderr.decode()}')\n\n def __to_helix(self, layer: List[BasePair3D],\n canonical: Optional[List[BasePair3D]] = None) -> tempfile.NamedTemporaryFile():\n onz_value = {ONZ.O_PLUS: 1, ONZ.O_MINUS: 2, ONZ.N_PLUS: 3, ONZ.N_MINUS: 4, ONZ.Z_PLUS: 5, ONZ.Z_MINUS: 6}\n nucleotides = self.analysis.structure3d.residues\n shifts = self.analysis.shifts\n\n helix = tempfile.NamedTemporaryFile('w+', suffix='.helix')\n helix.write(f'#{len(self.analysis.sequence) + 1}\\n')\n helix.write('i\\tj\\tlength\\tvalue\\n')\n\n for pair in layer:\n x, y = pair.nt1, pair.nt2\n x, y = nucleotides.index(x) + 1 + shifts[x], nucleotides.index(y) + 1 + shifts[y]\n onz = self.onz_dict[pair]\n helix.write(f'{x}\\t{y}\\t1\\t{onz_value.get(onz, 7)}\\n')\n if canonical:\n for pair in canonical:\n x, y = pair.nt1, pair.nt2\n x, y = nucleotides.index(x) + 1 + shifts[x], nucleotides.index(y) + 1 + shifts[y]\n helix.write(f'{x}\\t{y}\\t1\\t8\\n')\n\n helix.flush()\n return helix\n\n\nclass AnalysisSimple:\n def __init__(self, structure2d: Structure2D, structure3d: Structure3D):\n self.pairs: List[BasePair3D] = structure3d.base_pairs(structure2d)\n self.graph: Dict[Residue3D, List[Residue3D]] = structure3d.base_pair_graph(structure2d)\n self.pair_dict: Dict[Tuple[Residue3D, Residue3D], BasePair3D] = structure3d.base_pair_dict(structure2d)\n\n def has_tetrads(self):\n tetrads = set()\n for i in self.graph:\n for j in filter(lambda x: x != i, self.graph[i]):\n for k in filter(lambda x: x not in (i, j), self.graph[j]):\n for l in filter(lambda x: x not in (i, j, k) and x in self.graph[i], self.graph[k]):\n if Tetrad.is_valid(i, j, k, l, self.pair_dict):\n tetrads.add(frozenset([i, j, k, l]))\n if len(tetrads) > 1:\n return True\n return False\n\n\ndef center_of_mass(atoms):\n coords = [atom.coordinates() for atom in atoms]\n xs = (coord[0] for coord in coords)\n ys = (coord[1] for coord in coords)\n zs = (coord[2] for coord in coords)\n return numpy.array((sum(xs) / len(coords), sum(ys) / len(coords), sum(zs) / len(coords)))\n\n\ndef eltetrado(structure2d: Structure2D, structure3d: Structure3D, strict: bool, no_reorder: bool,\n stacking_mismatch: int) -> Analysis:\n return Analysis(structure2d, structure3d, strict, no_reorder, stacking_mismatch)\n\n\ndef has_tetrad(structure2d: Structure2D, structure3d: Structure3D) -> bool:\n structure = AnalysisSimple(structure2d, structure3d)\n return structure.has_tetrads()\n", "meta": {"hexsha": "de49973926bf957773166d4a7786ff49e43be172", "size": 43892, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/eltetrado/analysis.py", "max_stars_repo_name": "tzok/el_tetrado", "max_stars_repo_head_hexsha": "b1890f9bc39d815e5b535047fca5500117e3f8f3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/eltetrado/analysis.py", "max_issues_repo_name": "tzok/el_tetrado", "max_issues_repo_head_hexsha": "b1890f9bc39d815e5b535047fca5500117e3f8f3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/eltetrado/analysis.py", "max_forks_repo_name": "tzok/el_tetrado", "max_forks_repo_head_hexsha": "b1890f9bc39d815e5b535047fca5500117e3f8f3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.122840691, "max_line_length": 163, "alphanum_fraction": 0.5900164039, "include": true, "reason": "import numpy", "num_tokens": 11689, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230157, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.19846836749957103}} {"text": "\"\"\"\r\n-------------------------------------------------\r\n File Name: Losses.py\r\n Author: Zhonghao Huang\r\n Date: 2019/10/21\r\n Description: Module implementing various loss functions\r\n Copy from: https://github.com/akanimax/pro_gan_pytorch\r\n-------------------------------------------------\r\n\"\"\"\r\n\r\nimport torch\r\nimport torch.nn as nn\r\nfrom torch.nn import BCEWithLogitsLoss\r\nimport numpy as np\r\nfrom utils import gradient_penalty\r\n\r\n# =============================================================\r\n# Interface for the losses\r\n# =============================================================\r\n\r\nclass GANLoss:\r\n \"\"\" Base class for all losses\r\n @args:\r\n disc: Discriminator used for calculating the loss\r\n Note this must be a part of the GAN framework\r\n \"\"\"\r\n\r\n def __init__(self, disc):\r\n self.disc = disc\r\n\r\n def disc_loss(self, real_samps, fake_samps, alpha, height):\r\n \"\"\"\r\n calculate the discriminator loss using the following data\r\n :param real_samps: batch of real samples\r\n :param fake_samps: batch of generated (fake) samples\r\n :param height: current height at which training is going on\r\n :param alpha: current value of the fader alpha\r\n :return: loss => calculated loss Tensor\r\n \"\"\"\r\n raise NotImplementedError(\"disc_loss method has not been implemented\")\r\n\r\n def gen_loss(self, real_samps, fake_samps, alpha, height):\r\n \"\"\"\r\n calculate the generator loss\r\n :param real_samps: batch of real samples\r\n :param fake_samps: batch of generated (fake) samples\r\n :param height: current height at which training is going on\r\n :param alpha: current value of the fader alpha\r\n :return: loss => calculated loss Tensor\r\n \"\"\"\r\n raise NotImplementedError(\"gen_loss method has not been implemented\")\r\n\r\n\r\nclass ConditionalGANLoss:\r\n \"\"\" Base class for all conditional losses \"\"\"\r\n\r\n def __init__(self, disc):\r\n self.disc = disc\r\n\r\n def disc_loss(self, real_samps, fake_samps, labels, alpha, height):\r\n raise NotImplementedError(\"disc_loss method has not been implemented\")\r\n\r\n def gen_loss(self, real_samps, fake_samps, labels, alpha, height):\r\n raise NotImplementedError(\"gen_loss method has not been implemented\")\r\n\r\n\r\n# =============================================================\r\n# Normal versions of the Losses:\r\n# =============================================================\r\n\r\nclass StandardGAN(GANLoss):\r\n\r\n def __init__(self, disc):\r\n super().__init__(disc)\r\n # define the criterion and activation used for object\r\n self.criterion = BCEWithLogitsLoss()\r\n\r\n def disc_loss(self, real_samps, fake_samps, alpha, height):\r\n # small assertion:\r\n assert real_samps.device == fake_samps.device, \\\r\n \"Real and Fake samples are not on the same device\"\r\n\r\n # device for computations:\r\n device = fake_samps.device\r\n\r\n # predictions for real images and fake images separately :\r\n r_preds = self.disc(real_samps, alpha, height)\r\n f_preds = self.disc(fake_samps, alpha, height)\r\n\r\n # calculate the real loss:\r\n real_loss = self.criterion(\r\n torch.squeeze(r_preds),\r\n torch.ones(real_samps.shape[0]).to(device))\r\n\r\n # calculate the fake loss:\r\n fake_loss = self.criterion(\r\n torch.squeeze(f_preds),\r\n torch.zeros(fake_samps.shape[0]).to(device))\r\n\r\n # return final losses\r\n return (real_loss + fake_loss) / 2\r\n\r\n def gen_loss(self, _, fake_samps, alpha, height):\r\n preds, _, _ = self.disc(fake_samps, alpha, height)\r\n return self.criterion(\r\n torch.squeeze(preds),\r\n torch.ones(fake_samps.shape[0]).to(fake_samps.device))\r\n\r\n\r\nclass WGAN_GP(GANLoss):\r\n\r\n def __init__(self, disc, LAMBDA_GP=10):\r\n super().__init__(disc)\r\n self.LAMBDA_GP = LAMBDA_GP\r\n\r\n def disc_loss(self, real_samps, fake_samps, alpha, height):\r\n critic_real = self.disc(real_samps, alpha, height)\r\n critic_fake = self.disc(fake_samps, alpha, height)\r\n gp = gradient_penalty(self.disc, real_samps, fake_samps, alpha, height, device=real_samps.device)\r\n loss = (\r\n -(torch.mean(critic_real) - torch.mean(critic_fake))\r\n + self.LAMBDA_GP * gp\r\n + (0.001 * torch.mean(critic_real ** 2))\r\n )\r\n return loss\r\n\r\n def gen_loss(self, _, fake_samps, alpha, height):\r\n return -torch.mean(self.disc(fake_samps, alpha, height))\r\n\r\n\r\nclass HingeGAN(GANLoss):\r\n\r\n def __init__(self, disc):\r\n super().__init__(disc)\r\n\r\n def disc_loss(self, real_samps, fake_samps, alpha, height):\r\n r_preds = self.disc(real_samps, alpha, height)\r\n f_preds = self.disc(fake_samps, alpha, height)\r\n\r\n loss = (torch.mean(nn.ReLU()(1 - r_preds)) +\r\n torch.mean(nn.ReLU()(1 + f_preds)))\r\n\r\n return loss\r\n\r\n def gen_loss(self, _, fake_samps, alpha, height):\r\n return -torch.mean(self.disc(fake_samps, alpha, height))\r\n\r\n\r\nclass RelativisticAverageHingeGAN(GANLoss):\r\n\r\n def __init__(self, disc):\r\n super().__init__(disc)\r\n\r\n def disc_loss(self, real_samps, fake_samps, alpha, height):\r\n # Obtain predictions\r\n r_preds = self.disc(real_samps, alpha, height)\r\n f_preds = self.disc(fake_samps, alpha, height)\r\n\r\n # difference between real and fake:\r\n r_f_diff = r_preds - torch.mean(f_preds)\r\n\r\n # difference between fake and real samples\r\n f_r_diff = f_preds - torch.mean(r_preds)\r\n\r\n # return the loss\r\n loss = (torch.mean(nn.ReLU()(1 - r_f_diff))\r\n + torch.mean(nn.ReLU()(1 + f_r_diff)))\r\n\r\n return loss\r\n\r\n def gen_loss(self, real_samps, fake_samps, alpha, height):\r\n # Obtain predictions\r\n r_preds = self.disc(real_samps, alpha, height)\r\n f_preds = self.disc(fake_samps, alpha, height)\r\n\r\n # difference between real and fake:\r\n r_f_diff = r_preds - torch.mean(f_preds)\r\n\r\n # difference between fake and real samples\r\n f_r_diff = f_preds - torch.mean(r_preds)\r\n\r\n # return the loss\r\n return (torch.mean(nn.ReLU()(1 + r_f_diff))\r\n + torch.mean(nn.ReLU()(1 - f_r_diff)))\r\n\r\n\r\nclass LogisticGAN(GANLoss):\r\n def __init__(self, disc):\r\n super().__init__(disc)\r\n\r\n # gradient penalty\r\n def R1Penalty(self, real_img, alpha, height):\r\n\r\n # TODO: use_loss_scaling, for fp16\r\n apply_loss_scaling = lambda x: x * torch.exp(x * torch.Tensor([np.float32(np.log(2.0))]).to(real_img.device))\r\n undo_loss_scaling = lambda x: x * torch.exp(-x * torch.Tensor([np.float32(np.log(2.0))]).to(real_img.device))\r\n\r\n real_img = torch.autograd.Variable(real_img, requires_grad=True)\r\n real_logit = self.disc(real_img, alpha, height)\r\n # real_logit = apply_loss_scaling(torch.sum(real_logit))\r\n real_grads = torch.autograd.grad(outputs=real_logit, inputs=real_img,\r\n grad_outputs=torch.ones(real_logit.size()).to(real_img.device),\r\n create_graph=True, retain_graph=True)[0].view(real_img.size(0), -1)\r\n # real_grads = undo_loss_scaling(real_grads)\r\n r1_penalty = torch.sum(torch.mul(real_grads, real_grads))\r\n return r1_penalty\r\n\r\n def disc_loss(self, real_samps, fake_samps, alpha, height, r1_gamma=10.0):\r\n # Obtain predictions\r\n r_preds = self.disc(real_samps, alpha, height)\r\n f_preds = self.disc(fake_samps, alpha, height)\r\n\r\n loss = torch.mean(nn.Softplus()(f_preds)) + torch.mean(nn.Softplus()(-r_preds))\r\n\r\n if r1_gamma != 0.0:\r\n r1_penalty = self.R1Penalty(real_samps.detach(), alpha, height) * (r1_gamma * 0.5)\r\n loss += r1_penalty\r\n\r\n return loss\r\n\r\n def gen_loss(self, _, fake_samps, alpha, height):\r\n f_preds = self.disc(fake_samps, alpha, height)\r\n\r\n return torch.mean(nn.Softplus()(-f_preds))", "meta": {"hexsha": "2541272dc85d56e44acb51ffb5cc5ef6e5e4c682", "size": 8159, "ext": "py", "lang": "Python", "max_stars_repo_path": "loss_fn.py", "max_stars_repo_name": "vkmavani/StyleGAN", "max_stars_repo_head_hexsha": "953fad62632c6ec1662cac18ad1502d1517cee3f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-12-18T04:43:15.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-18T04:43:15.000Z", "max_issues_repo_path": "loss_fn.py", "max_issues_repo_name": "vkmavani/StyleGAN", "max_issues_repo_head_hexsha": "953fad62632c6ec1662cac18ad1502d1517cee3f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "loss_fn.py", "max_forks_repo_name": "vkmavani/StyleGAN", "max_forks_repo_head_hexsha": "953fad62632c6ec1662cac18ad1502d1517cee3f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.4241071429, "max_line_length": 118, "alphanum_fraction": 0.5941904645, "include": true, "reason": "import numpy", "num_tokens": 1839, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230157, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.19846836749957103}} {"text": "\"\"\"\nFrank-Wolfe algorithm.\n\"\"\"\n# 2015-04-15\n#\n# We place this in its own module since using:\n#\n# from __future__ import division\n#\n# seems to cause some issues with `cvxopt.matrix`, causing a TypeError.\n#\n# >>> from cvxopt import matrix\n# >>> x = matrix([[1,2],[3,5]])\n# >>> x / 3\n# TypeError: unsupported operand type(s) for /: 'cvxopt.base.matrix' and 'int'\n\nfrom debtcollector import removals\n\nimport logging\nimport numpy as np\n\nfrom dit.utils import basic_logger\n\n\n__all__ = (\n 'frank_wolfe',\n)\n\n\n@removals.remove(message=\"Please see methods in dit.algorithms.distribution_optimizers.py.\",\n version='1.0.1')\ndef frank_wolfe(objective, gradient, A, b, initial_x,\n maxiters=2000, tol=1e-4, clean=True, verbose=None):\n \"\"\"\n Uses the Frank--Wolfe algorithm to minimize the convex objective.\n\n Minimization is subject to the linear equality constraint: :math:`A x = b`.\n\n Assumes x should be nonnegative.\n\n Parameters\n ----------\n objective : callable\n The objective function. It would receive a ``cvxopt`` matrix for the\n input `x` and return the value of the objective function.\n gradient : callable\n The gradient function. It should receive a ``cvxopt`` matrix for the\n input `x` and return the value of the gradient evaluated at `x`.\n A : matrix\n A ``cvxopt`` matrix specifying the LHS linear equality constraints.\n b : matrix\n A ``cvxopt`` matrix specifying the RHS linear equality constraints.\n initial_x : matrix\n A ``cvxopt`` matrix specifying the initial `x` to use.\n maxiters : int\n The maximum number of iterations to perform. If convergence was not\n reached after the last iteration, a warning is issued and the current\n value of `x` is returned.\n tol : float\n The tolerance used to determine when we have converged to the optimum.\n clean : bool\n Occasionally, the iteration process will take nonnegative values to be\n ever so slightly negative. If ``True``, then we forcibly make such\n values equal to zero and renormalize the vector. This is an application\n specific decision and is probably not more generally useful.\n verbose : int\n An integer representing the logging level ala the ``logging`` module.\n If `None`, then (effectively) the log level is set to `WARNING`. For\n a bit more information, set this to `logging.INFO`. For a bit less,\n set this to `logging.ERROR`, or perhaps 100.\n\n \"\"\"\n # Function level import to avoid circular import.\n from dit.algorithms.optutil import op_runner\n\n # Function level import to keep cvxopt dependency optional.\n # All variables should be cvxopt variables, not NumPy arrays\n from cvxopt.modeling import variable\n\n # Set up a custom logger.\n logger = basic_logger('dit.frankwolfe', verbose)\n\n # Set cvx info level based on logging.DEBUG level.\n if logger.isEnabledFor(logging.DEBUG):\n show_progress = True\n else:\n show_progress = False\n\n assert (A.size[1] == initial_x.size[0])\n\n n = initial_x.size[0]\n x = initial_x\n xdiff = 0\n\n TOL = 1e-7\n verbosechunk = maxiters / 10\n for i in range(maxiters):\n obj = objective(x)\n grad = gradient(x)\n\n xbar = variable(n)\n\n new_objective = grad.T * xbar\n constraints = []\n constraints.append((xbar >= 0))\n constraints.append((-TOL <= A * xbar - b))\n constraints.append((A * xbar - b <= TOL))\n\n logger.debug('FW Iteration: {}'.format(i))\n opt = op_runner(new_objective, constraints, show_progress=show_progress)\n if opt.status != 'optimal':\n msg = '\\tFrank-Wolfe: Did not find optimal direction on '\n msg += 'iteration {}: {}'\n msg = msg.format(i, opt.status)\n logger.info(msg)\n\n # Calculate optimality gap\n xbar_opt = opt.variables()[0].value\n opt_bd = grad.T * (xbar_opt - x)\n\n msg = \"i={:6} obj={:10.7f} opt_bd={:10.7f} xdiff={:12.10f}\"\n if logger.isEnabledFor(logging.DEBUG):\n logger.debug(msg.format(i, obj, opt_bd[0, 0], xdiff))\n logger.debug(\"\")\n elif i % verbosechunk == 0:\n logger.info(msg.format(i, obj, opt_bd[0, 0], xdiff))\n\n xnew = (i * x + 2 * xbar_opt) / (i + 2)\n xdiff = np.linalg.norm(xnew - x)\n x = xnew\n\n if xdiff < tol:\n obj = objective(x)\n break\n else:\n msg = \"Only converged to xdiff={:12.10f} after {} iterations. \"\n msg += \"Desired: {}\"\n logger.warn(msg.format(xdiff, maxiters, tol))\n\n xopt = np.array(x)\n\n if clean:\n xopt[np.abs(xopt) < tol] = 0\n xopt /= xopt.sum()\n\n return xopt, obj\n", "meta": {"hexsha": "21ee2171c692ffec646bf1c900eb3f7d7e1304ee", "size": 4779, "ext": "py", "lang": "Python", "max_stars_repo_path": "dit/algorithms/frankwolfe.py", "max_stars_repo_name": "Ejjaffe/dit", "max_stars_repo_head_hexsha": "c9d206f03d1de5a0a298b1d0ea9d79ea5e789ee1", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-03-13T10:30:11.000Z", "max_stars_repo_stars_event_max_datetime": "2020-03-13T10:30:11.000Z", "max_issues_repo_path": "dit/algorithms/frankwolfe.py", "max_issues_repo_name": "Ejjaffe/dit", "max_issues_repo_head_hexsha": "c9d206f03d1de5a0a298b1d0ea9d79ea5e789ee1", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "dit/algorithms/frankwolfe.py", "max_forks_repo_name": "Ejjaffe/dit", "max_forks_repo_head_hexsha": "c9d206f03d1de5a0a298b1d0ea9d79ea5e789ee1", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.5102040816, "max_line_length": 92, "alphanum_fraction": 0.6239799121, "include": true, "reason": "import numpy", "num_tokens": 1220, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230157, "lm_q2_score": 0.38491214448393346, "lm_q1q2_score": 0.198468367499571}} {"text": "\"\"\"All main functions for et_module\n\"\"\"\nimport os\nimport sys\nimport csv\nimport logging\nimport numpy as np\nimport pandas as pd\n\nfrom et_module import diffusion_functions\n\ndef load_curve_assignement(\n curr_yr,\n base_yr,\n yr_until_changed,\n et_service_demand_yh,\n load_profiles,\n regions,\n charging_scenario,\n diffusion='linear'\n ):\n \"\"\"Assign input electrictiy demand (given as \"tranport service\"\n for every hour in a year) to an hourly energy demand load profile\n depending (see documentation for more information).\n\n Arguments\n =========\n curr_yr : int\n Current simulation year\n base_yr : int\n Base year of simulation\n yr_until_changed : int\n Year until changed is fully implemented\n et_service_demand_yh : dict\n Transport energy demand for every region (hourly demand)\n load_profiles : list\n Load profile objects\n regions : list\n All region names\n charging_scenario : str\n Scenario\n\n 'sheduled' :\n\n 'sheduled' : \n TODO\n\n diffusion : str\n Type of diffusion between base year and end year load profile\n\n 'linear': Linear change over time towards future load profile\n\n 'sigmoid': Sigmoid change over time towards future load profile\n\n Returns\n =========\n et_demand_yh : array\n Houlry demand, np.array(reg_array_nr, 8760 timesteps)\n \"\"\"\n et_demand_yh = np.zeros((len(regions), 365 * 24), dtype=float)\n\n # -------------------\n # Calculate diffusion\n # -------------------\n if diffusion == 'linear':\n simulation_year_p = diffusion_functions.linear_diff(\n base_yr=base_yr,\n curr_yr=curr_yr,\n value_start=0,\n value_end=1,\n yr_until_changed=yr_until_changed)\n\n elif diffusion == 'sigmoid':\n # Default sigmoid parameters\n simulation_year_p = diffusion_functions.sigmoid_diffusion(\n base_yr=base_yr,\n curr_yr=curr_yr,\n end_yr=yr_until_changed,\n sig_midpoint=0,\n sig_steeppness=1)\n else:\n sys.exit(\"Error: No diffusion option is selected\")\n # --------------------------------------------------------------------\n # Calculate current year profile with base year and profile from 2015\n # --------------------------------------------------------------------\n\n # Get base year load profile\n for load_profile in load_profiles:\n if load_profile.name == 'av_lp_2015.csv':\n profile_yh_by = load_profile.shape_yh\n\n # Get future year load profile\n for load_profile in load_profiles:\n\n if charging_scenario == 'unsheduled':\n\n # Unsheduled load profile (same as base year)\n if load_profile.name == 'av_lp_2015.csv':\n profile_yh_ey = load_profile.shape_yh\n\n elif charging_scenario == 'sheduled':\n\n # Sheduled load profile\n if load_profile.name == 'av_lp_2050.csv':\n profile_yh_ey = load_profile.shape_yh\n \n if base_yr == curr_yr:\n profile_yh_cy = profile_yh_by\n elif curr_yr == yr_until_changed or curr_yr > yr_until_changed:\n profile_yh_cy = profile_yh_ey\n else:\n\n # Calculate difference between by and ey\n diff_profile = profile_yh_ey - profile_yh_by\n\n # Calculate difference up to cy\n diff_profile_cy = diff_profile * simulation_year_p\n\n # Add difference to by\n profile_yh_cy = profile_yh_by + diff_profile_cy\n\n assert round(np.sum(profile_yh_cy), 3) == 1\n\n # ----------\n # Plotting\n # ----------\n #from et_module import plotting_functions\n #fig_lp.plot_lp_dh(profile_yh_cy, day=2)\n\n # ------------------------------------\n # Disaggregate for every region\n # ------------------------------------\n for region_array_nr, region in enumerate(regions):\n\n # Sum total service demand to annual demand\n et_service_demand_y = np.sum(et_service_demand_yh[region])\n\n # Multiply the annual total service demand with yh load profile\n reg_profile_yh = et_service_demand_y * profile_yh_cy\n\n logging.debug(\n \"Assinging new shape {} {} {}\".format(\n region, et_service_demand_y, np.sum(profile_yh_cy)))\n\n # Reshape (365 days, 24hours) into 8760 timesteps\n et_demand_yh[region_array_nr] = reg_profile_yh.reshape(8760)\n\n return et_demand_yh\n\ndef get_load_profiles(path):\n \"\"\"Read in all load profiles from csv files and store in\n `LoadProfile`.\n\n Arguments\n =========\n path : str\n Path where load profiles are stored\n\n Returns\n =======\n load_profiles : list\n All load profiles objects\n \"\"\"\n load_profiles = []\n\n # Name of load profiles to load\n names = [\n 'av_lp_2015.csv',\n 'av_lp_2050.csv']\n\n for name in names:\n\n # Create path to csv file\n path_to_csv = os.path.join(path, name)\n\n # Read in csv load profile\n lp_dh = read_load_shape(path_to_csv)\n\n lp_dh_p = lp_dh / 100 # convert percentage to fraction\n\n # Shape for every hour in a year (Assign same profile to every day)\n shape_yd = np.full((365), 1/365)\n\n # Shape for every hour in a year (365) * (24)\n shape_yh = shape_yd[:, np.newaxis] * lp_dh_p\n\n # Create load profile\n load_profile = LoadProfile(\n name=name,\n year=name[-8:-4],\n shape_yd=shape_yd,\n shape_yh=shape_yh)\n\n load_profiles.append(load_profile)\n\n return load_profiles\n\ndef read_load_shape(path_to_csv):\n \"\"\"This function reads in a load profile from\n a csv file of a single day.\n\n Arguments\n =========\n path_to_csv : str\n Path to csv file\n\n Returns\n =======\n shape_dh : array (24)\n Load profile\n \"\"\"\n with open(path_to_csv, 'r') as csvfile:\n read_lines = csv.reader(csvfile, delimiter=',')\n _headings = next(read_lines) # Skip first row\n\n for row in read_lines:\n shape_dh = np.zeros((24), dtype=float)\n for cnt, row_entry in enumerate(row):\n shape_dh[int(_headings[cnt])] = float(row_entry)\n\n return shape_dh\n\nclass LoadProfile(object):\n \"\"\"Class to store load profiles\n\n Arguments\n ----------\n name : str\n Name of load profile\n year : int\n Year of load profile\n shape_yd : array\n Yearly load profile\n shape yh : array\n Daily load profile\n\n Note\n ====\n - `Yearly load profile (yd)` can be used to derive the energy demand\n of all days in year. This is achieved by multiplying total\n annual demand with this _yd array with the array shape (365)\n\n - `Daily load profile (yh)` can be used to derive the energy demand\n of all hours in a year. This is achieved by multiplying total\n annual demand with the this _yh array with the array shape (365, 24).\n \"\"\"\n def __init__(\n self,\n name,\n year,\n shape_yd,\n shape_yh\n ):\n \"\"\"Constructor\n \"\"\"\n self.name = name\n self.year = year\n self.shape_yd = shape_yd\n self.shape_yh = shape_yh\n", "meta": {"hexsha": "464bf96075ca19346e75ffb3cb782e43b42bf49a", "size": 7303, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/et_module/main_functions.py", "max_stars_repo_name": "nismod/et_module", "max_stars_repo_head_hexsha": "eb1a32aed1e0f7d85a9b2191d5b6c0a395510cdd", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/et_module/main_functions.py", "max_issues_repo_name": "nismod/et_module", "max_issues_repo_head_hexsha": "eb1a32aed1e0f7d85a9b2191d5b6c0a395510cdd", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2018-02-09T09:33:50.000Z", "max_issues_repo_issues_event_max_datetime": "2019-02-11T13:34:34.000Z", "max_forks_repo_path": "src/et_module/main_functions.py", "max_forks_repo_name": "nismod/et_module", "max_forks_repo_head_hexsha": "eb1a32aed1e0f7d85a9b2191d5b6c0a395510cdd", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.0884615385, "max_line_length": 77, "alphanum_fraction": 0.5920854443, "include": true, "reason": "import numpy", "num_tokens": 1694, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230156, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.198468367499571}} {"text": "import numpy as np\nimport sys\nimport warnings\nimport argparse\nfrom fit import do_fit\nfrom output import *\nfrom input import get_input,get_imax\nwarnings.simplefilter(\"error\")\n\ndef get_args():\n\n args_parser = argparse.ArgumentParser()\n \n # Data files arguments\n args_parser.add_argument(\n '--vmcfile',\n help='Local path to vmc data',\n required=True,\n type=str\n )\n \n \n args_parser.add_argument(\n '--dmcfile',\n help='Local path to dmc data',\n required=True,\n type=str\n )\n\n args_parser.add_argument(\n '--rfile',\n help='Local path to dmc data',\n required=True,\n type=str\n )\n\n args_parser.add_argument(\n '--max-pol',\n help='Maximum polynomial order.',\n required=False,\n type=int,\n default=3\n )\n\n args_parser.add_argument(\n '--min-pol',\n help='Minimum polynomial order.',\n required=False,\n type=int,\n default=3\n )\n \n args_parser.add_argument(\n '--plot',\n help='BOOL. Produce plot of the PCFs. 0 (default) FALSE. 1 TRUE. ',\n required=False,\n type=int,\n default=0\n )\n \n args_parser.add_argument(\n '--num-e',\n help='Total Number of electrons',\n required=False,\n type=int,\n default=3\n )\n \n args_parser.add_argument(\n '--lat-vec',\n help='Maximum polynomial order.',\n required=True,\n type=float\n )\n\n\n args_parser.add_argument(\n '--fit-range',\n help='Maximum polynomial order.',\n required=True,\n type=float\n )\n\n args_parser.add_argument(\n '--opt-method',\n\thelp='lm,trf or dogbox',\n\trequired=False,\n type=str,\n default='lm'\n )\n \n args_parser.add_argument(\n '--volume',\n help='Volume of the simulation cell.',\n required=True,\n type=float\n )\n\n args_parser.add_argument(\n '--metal',\n help='System is metallic (1) or not (0). Affects to the scaling of the extrapolated PCF. Default: 0.',\n required=False,\n type=int,\n default=0\n )\n \n args_parser.add_argument(\n '--verbosity',\n help='Controls the amount of info printed.',\n required=False,\n type=int,\n default=0\n )\n\n\n args_parser.add_argument(\n\t'--omit_pcf',\n help='skip pcfs.',\n required=False,\n nargs='+',\n\ttype=int,\n default=[-1]\n )\n\n args_parser.add_argument(\n '--corepart',\n help='tau_valence/tau_total.',\n type=float,\n default=1.0\n )\n\n args_parser.add_argument(\n\t'--table',\n help='Printout table in latex.',\n required=False,\n\ttype=int,\n default=[-1]\n )\n\n args_parser.add_argument(\n '--cross-val',\n help='Perform a cross-validation over the fits.',\n required=False,\n type=int,\n default=[-1]\n )\n\n return args_parser.parse_args()\n \ndef fit_statistics(args,fits,g,r):\n\n # The dimensions of our current experiment\n Nx=len(r)\n Npcf=len(g)\n p_degs=np.arange(args.min_pol,args.max_pol+1,2)\n N_degs = len(p_degs)\n bond_distance=args.fit_range*args.lat_vec\n \n # Averages of the PCFs and fits\n fit_average=np.zeros((Nx,N_degs))\n g_average=np.zeros((Nx,))\n for i in range(Npcf):\n g_average[:]=g_average[:]+g[i]\n for d in range(N_degs):\n fit_average[:,d]=fit_average[:,d]+fits[:,i,d]\n\n g_average=g_average/Npcf\n fit_average=fit_average/Npcf\n \n # Compute the fitting error\n fit_errors=np.zeros((N_degs,))\n fit_sqerrors=np.zeros((N_degs,))\n imax=get_imax(r,2)\n for i in range(N_degs):\n for j in range(imax):\n fit_errors[i]=fit_errors[i]+np.absolute(np.exp(fit_average[j,i])-g_average[j])\n fit_sqerrors[i]=fit_sqerrors[i]+(np.exp(fit_average[j,i])-g_average[j])**2\n fit_errors=fit_errors/imax\n fit_sqerrors=fit_sqerrors/imax\n\n \n if args.plot == 1:\n plot_results(p_degs,N_degs,g_average,fit_average,r,imax)\n\n return fit_errors,fit_sqerrors\n\ndef mean_and_error(g):\n '''\n Input: (N_pcf,N_degs)-order matrix of PCF-zeroes.\n Output: \n * Means over separate PCF's.\n * Mean average errors of PCF's.\n * Standard deviations of PCF's.\n\n \n '''\n gmean=np.mean(g,axis=0)\n mean_error=np.mean(np.absolute(gmean-g),axis=0)\n standard_deviation=np.std(g,axis=0)/np.sqrt(g.shape[0])#np.sqrt(np.mean((gmean-g)**2,axis=0))/np.sqrt(g.shape[0])\n \n return gmean,mean_error,standard_deviation\n\n\ndef main():\n\n args=get_args()\n \n r,r_ex,gex,glogex=get_input(args)\n\n r_range=args.fit_range*args.lat_vec\n \n # Fitting\n fits,opt_pol_coeff=do_fit(r,r_ex,r_range,glogex,args)\n\n # Fitting statistics\n fe,fsqe=fit_statistics(args,fits,gex,r)\n \n # Get g(0) values and statistics\n gzeros=np.exp(fits[0,:,:])\n m,e,std=mean_and_error(gzeros)\n \n # Lifetime statistics\n lifetimes=1000.0*(100.617/2*args.num_e/args.volume*gzeros)**-1\n mt,et,stdt=mean_and_error(lifetimes)\n\n if(args.table==1):\n make_table(args,m,mt,fe,fsqe,e,std,stdt,gzeros,lifetimes)\n else:\n print_output(args,m,mt,fe,fsqe,e,std,stdt,gzeros,lifetimes)\n \n sys.exit('All done.')\n\nif __name__ == '__main__':\n main()\n \n", "meta": {"hexsha": "083217f3d6fbdb392598c793e6c42cb81a114c02", "size": 5405, "ext": "py", "lang": "Python", "max_stars_repo_path": "casino/positron_utils/pcf_fit/plyfit.py", "max_stars_repo_name": "JMuff22/Scripts", "max_stars_repo_head_hexsha": "1cbc431031584c50e918e90be1b44715833e3f32", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "casino/positron_utils/pcf_fit/plyfit.py", "max_issues_repo_name": "JMuff22/Scripts", "max_issues_repo_head_hexsha": "1cbc431031584c50e918e90be1b44715833e3f32", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "casino/positron_utils/pcf_fit/plyfit.py", "max_forks_repo_name": "JMuff22/Scripts", "max_forks_repo_head_hexsha": "1cbc431031584c50e918e90be1b44715833e3f32", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 22.9025423729, "max_line_length": 117, "alphanum_fraction": 0.5874190564, "include": true, "reason": "import numpy", "num_tokens": 1362, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230156, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.198468367499571}} {"text": "#!/usr/bin/python3\n\n\"\"\"Calculate the RMSD between structures.\"\"\"\n\nimport argparse\n\nimport numpy as np\n\n# Inspired by\n# https://github.com/cclib/cclib/blob/master/cclib/parser/utils.py#L159\nelement = [\n None,\n \"H\",\n \"He\",\n \"Li\",\n \"Be\",\n \"B\",\n \"C\",\n \"N\",\n \"O\",\n \"F\",\n \"Ne\",\n \"Na\",\n \"Mg\",\n \"Al\",\n \"Si\",\n \"P\",\n \"S\",\n \"Cl\",\n \"Ar\",\n \"K\",\n \"Ca\",\n \"Sc\",\n \"Ti\",\n \"V\",\n \"Cr\",\n \"Mn\",\n \"Fe\",\n \"Co\",\n \"Ni\",\n \"Cu\",\n \"Zn\",\n \"Ga\",\n \"Ge\",\n \"As\",\n \"Se\",\n \"Br\",\n \"Kr\",\n \"Rb\",\n \"Sr\",\n \"Y\",\n \"Zr\",\n \"Nb\",\n \"Mo\",\n \"Tc\",\n \"Ru\",\n \"Rh\",\n \"Pd\",\n \"Ag\",\n \"Cd\",\n \"In\",\n \"Sn\",\n \"Sb\",\n \"Te\",\n \"I\",\n \"Xe\",\n \"Cs\",\n \"Ba\",\n \"La\",\n \"Ce\",\n \"Pr\",\n \"Nd\",\n \"Pm\",\n \"Sm\",\n \"Eu\",\n \"Gd\",\n \"Tb\",\n \"Dy\",\n \"Ho\",\n \"Er\",\n \"Tm\",\n \"Yb\",\n \"Lu\",\n \"Hf\",\n \"Ta\",\n \"W\",\n \"Re\",\n \"Os\",\n \"Ir\",\n \"Pt\",\n \"Au\",\n \"Hg\",\n \"Tl\",\n \"Pb\",\n \"Bi\",\n \"Po\",\n \"At\",\n \"Rn\",\n \"Fr\",\n \"Ra\",\n \"Ac\",\n \"Th\",\n \"Pa\",\n \"U\",\n \"Np\",\n \"Pu\",\n \"Am\",\n \"Cm\",\n \"Bk\",\n \"Cf\",\n \"Es\",\n \"Fm\",\n \"Md\",\n \"No\",\n \"Lr\",\n \"Rf\",\n \"Db\",\n \"Sg\",\n \"Bh\",\n \"Hs\",\n \"Mt\",\n \"Ds\",\n \"Rg\",\n \"Cn\",\n \"Nh\",\n \"Fl\",\n \"Mc\",\n \"Lv\",\n \"Ts\",\n \"Og\",\n]\n\n# Inspired by\n# https://github.com/cclib/cclib/blob/master/cclib/parser/utils.py#L159\natomic_number = {\n \"H\": 1,\n \"He\": 2,\n \"Li\": 3,\n \"Be\": 4,\n \"B\": 5,\n \"C\": 6,\n \"N\": 7,\n \"O\": 8,\n \"F\": 9,\n \"Ne\": 10,\n \"Na\": 11,\n \"Mg\": 12,\n \"Al\": 13,\n \"Si\": 14,\n \"P\": 15,\n \"S\": 16,\n \"Cl\": 17,\n \"Ar\": 18,\n \"K\": 19,\n \"Ca\": 20,\n \"Sc\": 21,\n \"Ti\": 22,\n \"V\": 23,\n \"Cr\": 24,\n \"Mn\": 25,\n \"Fe\": 26,\n \"Co\": 27,\n \"Ni\": 28,\n \"Cu\": 29,\n \"Zn\": 30,\n \"Ga\": 31,\n \"Ge\": 32,\n \"As\": 33,\n \"Se\": 34,\n \"Br\": 35,\n \"Kr\": 36,\n \"Rb\": 37,\n \"Sr\": 38,\n \"Y\": 39,\n \"Zr\": 40,\n \"Nb\": 41,\n \"Mo\": 42,\n \"Tc\": 43,\n \"Ru\": 44,\n \"Rh\": 45,\n \"Pd\": 46,\n \"Ag\": 47,\n \"Cd\": 48,\n \"In\": 49,\n \"Sn\": 50,\n \"Sb\": 51,\n \"Te\": 52,\n \"I\": 53,\n \"Xe\": 54,\n \"Cs\": 55,\n \"Ba\": 56,\n \"La\": 57,\n \"Ce\": 58,\n \"Pr\": 59,\n \"Nd\": 60,\n \"Pm\": 61,\n \"Sm\": 62,\n \"Eu\": 63,\n \"Gd\": 64,\n \"Tb\": 65,\n \"Dy\": 66,\n \"Ho\": 67,\n \"Er\": 68,\n \"Tm\": 69,\n \"Yb\": 70,\n \"Lu\": 71,\n \"Hf\": 72,\n \"Ta\": 73,\n \"W\": 74,\n \"Re\": 75,\n \"Os\": 76,\n \"Ir\": 77,\n \"Pt\": 78,\n \"Au\": 79,\n \"Hg\": 80,\n \"Tl\": 81,\n \"Pb\": 82,\n \"Bi\": 83,\n \"Po\": 84,\n \"At\": 85,\n \"Rn\": 86,\n \"Fr\": 87,\n \"Ra\": 88,\n \"Ac\": 89,\n \"Th\": 90,\n \"Pa\": 91,\n \"U\": 92,\n \"Np\": 93,\n \"Pu\": 94,\n \"Am\": 95,\n \"Cm\": 96,\n \"Bk\": 97,\n \"Cf\": 98,\n \"Es\": 99,\n \"Fm\": 100,\n \"Md\": 101,\n \"No\": 102,\n \"Lr\": 103,\n \"Rf\": 104,\n \"Db\": 105,\n \"Sg\": 106,\n \"Bh\": 107,\n \"Hs\": 108,\n \"Mt\": 109,\n \"Ds\": 110,\n \"Rg\": 111,\n \"Cn\": 112,\n \"Nh\": 113,\n \"Fl\": 114,\n \"Mc\": 115,\n \"Lv\": 116,\n \"Ts\": 117,\n \"Og\": 118,\n}\n\n\ndef read_xyz(path_file_or_str):\n \"\"\"Read a xyz file and return structures.\n\n Parameters\n ----------\n path_file_or_str : str\n\n Returns\n -------\n atomnos : array-like\n comments : str\n atomcoords : array-like\n \"\"\"\n\n def _process(lines):\n natom = int(lines[0])\n m = 2 + natom\n nstruct = len(lines) // m\n\n atomnos = []\n comments = []\n atomcoords = []\n for i in range(nstruct):\n nos = []\n coords = []\n initial = i * m + 2\n for j in range(initial, initial + natom):\n fields = lines[j].split()\n nos.append(atomic_number[fields[0]])\n coords.append([float(x) for x in fields[1:]])\n atomnos.append(np.array(nos))\n comments.append(lines[i * m + 1].strip(\"\\n\"))\n atomcoords.append(np.array(coords))\n return atomnos, comments, atomcoords\n\n try:\n with open(path_file_or_str, \"r\") as xyz_file:\n return _process(xyz_file.readlines())\n except TypeError:\n return _process(path_file_or_str.readlines())\n except FileNotFoundError:\n return _process(path_file_or_str.split(\"\\n\"))\n\n\ndef write_xyz(atomnos, atomcoords, comment=\"\"):\n \"\"\"Format a string as xyz coordinates.\n\n Parameters\n ----------\n atomnos, atomcoords : array-like\n\n Returns\n -------\n str\n \"\"\"\n lines = []\n for no, coord in zip(atomnos, atomcoords):\n lines.append(\n f\"{element[no]:2s} {coord[0]:12.6f} {coord[1]:12.6f} {coord[2]:12.6f}\"\n )\n\n lines = \"\\n\".join(lines)\n return f\"{len(atomnos)}\\n{comment}\\n{lines}\"\n\n\ndef calc_rmsd(P, Q, translate=True):\n \"\"\"Calculate the RMSD between P and Q using Kabsch algorithm.\n\n Parameters\n ----------\n P, Q : array-like\n translate : bool\n\n Returns\n -------\n float\n\n Notes\n -----\n If structures are not comparable, np.inf is returned.\n\n Examples\n --------\n >>> P = [[0, 0, 0],\n ... [1, 1, 1]]\n >>> calc_rmsd(P, P)\n 0.0\n >>> Q = [[1, 1, 1],\n ... [2, 2, 2]]\n >>> calc_rmsd(P, Q)\n 0.0\n >>> P = [[-3.652796902, 0.000000000, -4.445975658],\n ... [-3.527558151, 0.000000000, -3.430150234],\n ... [-4.501637325, 0.000000000, -3.833697320]]\n >>> Q = [[ 1.885538972, 0.000000000, -0.577489796],\n ... [ 0.911459798, 0.000000000, 0.201773543],\n ... [ 1.165525626, 1.078706033, -0.490031274]]\n >>> calc_rmsd(P, Q)\n 0.140663071340813\n \"\"\"\n P, Q = np.asanyarray(P), np.asanyarray(Q)\n if translate:\n P = P - P.mean(axis=0)\n Q = Q - Q.mean(axis=0)\n\n try:\n V, s, W = np.linalg.svd(P.T @ Q)\n except ValueError:\n return np.inf\n if np.linalg.det(V) * np.linalg.det(W) < 0:\n s[-1] = -s[-1]\n V[:, -1] = -V[:, -1]\n\n U = V @ W\n P = P @ U\n return np.sqrt(np.sum((P - Q) ** 2) / len(P))\n\n\ndef main():\n \"\"\"Run main procedure.\"\"\"\n parser = argparse.ArgumentParser()\n parser.add_argument(\n \"xyz_files\", type=argparse.FileType(\"r\"), default=\"-\", nargs=\"+\"\n )\n args = parser.parse_args()\n\n coords = []\n names = []\n for xyz_file in args.xyz_files:\n coords.append(read_xyz(xyz_file)[2])\n names.append(xyz_file.name)\n\n print(\"RMSD:\")\n for i in range(len(coords)):\n for j in range(i):\n rmsd = calc_rmsd(coords[j][-1], coords[i][-1])\n print(f\"{names[j]:14s} ~ {names[i]:14s} = {rmsd:6.4f} Å\")\n\n\nif __name__ == \"__main__\":\n main()\n", "meta": {"hexsha": "778544d590d9493870dc9d2000cce66ab64ae960", "size": 6690, "ext": "py", "lang": "Python", "max_stars_repo_path": "rmsd.py", "max_stars_repo_name": "schneiderfelipe/scripts", "max_stars_repo_head_hexsha": "43bb3d02d0b043f80a4840f4cc222944aad683c4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "rmsd.py", "max_issues_repo_name": "schneiderfelipe/scripts", "max_issues_repo_head_hexsha": "43bb3d02d0b043f80a4840f4cc222944aad683c4", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "rmsd.py", "max_forks_repo_name": "schneiderfelipe/scripts", "max_forks_repo_head_hexsha": "43bb3d02d0b043f80a4840f4cc222944aad683c4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 16.8090452261, "max_line_length": 82, "alphanum_fraction": 0.4137518685, "include": true, "reason": "import numpy", "num_tokens": 2507, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230156, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.198468367499571}} {"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# In[1]:\n\n\nimport os \nimport sys\nimport glob\nimport numpy as np\nimport itk\nfrom itk import TubeTK as ttk\n#from itkwidgets import view\n\n\n# In[2]:\n\nif len(sys.argv) != 2:\n print(\"ctp-head-CombinedScript.py \")\n print(\" format = C:/Data/unc/HighRes-005-ctp\")\n sys.exit()\n\n# NRRD Study Name\nprint(\"Directory = \", sys.argv[1])\nstudyname = sys.argv[1] #'C:/Users/steph/Desktop/Data/unc/HighRes-005-ctp'\n\n\n# NRRD Files\ndirectory = (studyname + '/')\n\n# Saved NRRD Files \ndirectory2 = (studyname + '-Reg/')\ntry:\n os.mkdir(directory2)\nexcept OSError as error:\n print(error)\n\n# Mask Creation and Location\ndirectory3 = (studyname + '-MinMax/')\ntry:\n os.mkdir(directory3)\nexcept OSError as error:\n print(error)\n\npic_folder = os.listdir(directory)\npic_folder = [pic_folder for pic_folder in pic_folder if \".nii\" in pic_folder]\npic_folder.sort()\nprint(pic_folder)\nnum_images = len(pic_folder)\n\nim0Tmp = itk.imread(directory + pic_folder[int(num_images/2)], itk.F)\n\nresample = ttk.ResampleImage.New(Input=im0Tmp,MakeIsotropic=True)\nresample.Update()\nim0 = resample.GetOutput()\nimmath = ttk.ImageMath.New(Input=im0)\nimmath.Blur(1)\nim0Blur = immath.GetOutput()\n\nimmath.Threshold(150, 800, 1, 0)\nimmath.Dilate(10, 1, 0)\nmask0 = immath.GetOutputUChar()\nmask0Tmp = itk.GetArrayViewFromImage(mask0)\nmask0Tmp[0:4,:,:] = 0\nsizeZ = mask0Tmp.shape[0]\nmask0Tmp[sizeZ-4:sizeZ,:,:] = 0 #No need to update mask0 since mask0Tmp is a view of mask0 (shared memory)\n\nitk.imwrite(mask0, directory3 + 'mask.mha', compression=True)\nmaskObj = itk.ImageMaskSpatialObject[3].New()\nmaskObj.SetImage(mask0)\nmaskObj.Update()\n\n\n# In[3]:\n\n\n#view(mask0)\n\n\n# In[ ]:\n\n\nDimension = 3\nPixelType = itk.ctype('float')\nImageType = itk.Image[PixelType, Dimension]\n\nimdatamax = itk.GetArrayFromImage(im0)\nimdatamin = imdatamax\nimdatamax2 = imdatamax\nimdatamin2 = imdatamax\nimdatamax3 = imdatamax\nimdatamin3 = imdatamax\n\nimFixedBlur = im0Blur\n\nfor imNum in range(num_images):\n imMoving = itk.imread( directory + pic_folder[imNum], itk.F )\n \n immath.SetInput(imMoving)\n immath.Blur(1)\n imMovingBlur = immath.GetOutput()\n \n imreg = ttk.RegisterImages[ImageType].New()\n imreg.SetFixedImage(imFixedBlur)\n imreg.SetMovingImage(imMovingBlur)\n \n imreg.SetRigidMaxIterations(3000)\n imreg.SetRegistration(\"RIGID\")\n imreg.SetExpectedOffsetMagnitude(20)\n imreg.SetExpectedRotationMagnitude(0.3)\n imreg.SetMetric(\"MEAN_SQUARED_ERROR_METRIC\")\n \n imreg.SetFixedImageMaskObject(maskObj)\n #imreg.SetSampleFromOverlap(True)\n\n imreg.SetReportProgress(True)\n imreg.Update()\n \n tfm = imreg.GetCurrentMatrixTransform()\n #imFixedBlur = imreg.GetFinalMovingImage(\"LINEAR_INTERPOLATION\", -1024)\n imMovingReg = imreg.ResampleImage(\"LINEAR_INTERPOLATION\", imMoving, tfm, -1024)\n \n itk.imwrite( imMovingReg, directory2 + pic_folder[imNum], compression=True )\n \n print(tfm)\n \n imdataTmp = itk.GetArrayFromImage(imMovingReg)\n \n imdatamax = np.maximum(imdatamax,imdataTmp)\n imdatamin = np.minimum(imdatamin,imdataTmp)\n imdataTmp[np.where(imdataTmp==imdatamax)] = 0\n imdataTmp[np.where(imdataTmp==imdatamin)] = 0\n imdatamax2 = np.maximum(imdatamax2,imdataTmp)\n imdatamin2 = np.minimum(imdatamin2,imdataTmp)\n imdataTmp[np.where(imdataTmp==imdatamax)] = 0\n imdataTmp[np.where(imdataTmp==imdatamin)] = 0\n imdatamax3 = np.maximum(imdatamax3,imdataTmp)\n imdatamin3 = np.minimum(imdatamin3,imdataTmp)\n \n #out = itk.GetImageFromArray(imdatamax)\n #out.CopyInformation(im0)\n #itk.imwrite(out, (directory3 + 'max_' + str(imNum) + '.nrrd'))\n \n #out = itk.GetImageFromArray(imdatamax3)\n #out.CopyInformation(im0)\n #itk.imwrite(out, (directory3 + 'max3_' + str(imNum) + '.nrrd'))\n \n percent = (imNum + 1) / num_images * 100\n print(str(round(percent)) + '% : ' + pic_folder[imNum])\n \nprint('Done') \n\n\n# In[ ]:\n\n\nout = itk.GetImageFromArray(imdatamax3)\nout.CopyInformation(im0)\nitk.imwrite(out, (directory3 + 'max3.nrrd'), compression=True)\n\nout = itk.GetImageFromArray(imdatamin3)\nout.CopyInformation(im0)\nitk.imwrite(out, (directory3 + 'min3.nrrd'), compression=True)\n\nout = itk.GetImageFromArray(imdatamax3 - imdatamin3)\nout.CopyInformation(im0)\nitk.imwrite(out, (directory3 + 'diff3.nrrd'), compression=True)\n\nprint('Done3')\n\n\n# In[ ]:\n\n\nout = itk.GetImageFromArray(imdatamax)\nout.CopyInformation(im0)\nitk.imwrite(out, (directory3 + 'max.nrrd'), compression=True)\n\nout = itk.GetImageFromArray(imdatamin)\nout.CopyInformation(im0)\nitk.imwrite(out, (directory3 + 'min.nrrd'), compression=True)\n\nout = itk.GetImageFromArray(imdatamax - imdatamin)\nout.CopyInformation(im0)\nitk.imwrite(out, (directory3 + 'diff.nrrd'), compression=True)\n\nprint('Done')\n\n\n# In[ ]:\n\n\n#out = itk.GetImageFromArray(imdatamax)\n#view(out)\n\n\n# In[ ]:\n\n\n#!/usr/bin/env python\n# coding: utf-8\n\n# This notebook is intended to demonstrate how select registration, segmentation, and image mathematical methods of ITKTubeTK can be combined to perform multi-channel brain extraction (aka. skull stripping for patient data containing multiple MRI sequences).\n# \n# There are many other (probably more effective) brain extraction methods available as open-source software such as BET and BET2 in the FSL package (albeit such methods are only for single channel data). If you need to perform brain extraction for a large collection of scans that do not contain major pathologies, please use one of those packages. This notebook is meant to show off the capabilities of specific ITKTubeTK methods, not to demonstration how to \"solve\" brain extraction.\n\n# In[1]:\n\n\n#import itk\n#from itk import TubeTK as ttk\n\n#from itkwidgets import view\n\n#import numpy as np\n\n\n# In[2]:\n\n\nImageType = itk.Image[itk.F, 3]\n\nInputBaseName = studyname + \"-MinMax/max3\"\n\nfilename = InputBaseName + \".nrrd\"\nim1iso = itk.imread(filename, itk.F)\n\n\n# In[3]:\n\n\nN = 8\nreaderList = [\"003\", \"010\", \"026\", \"034\", \"045\", \"056\", \"063\", \"071\"]\n\nimBase = []\nimBaseB = []\nfor i in range(0,N):\n name = \"../Data/Normal\"+readerList[i]+\"-FLASH.mha\"\n nameB = \"../Data/Normal\"+readerList[i]+\"-FLASH-Brain.mha\"\n imBaseTmp = itk.imread(name, itk.F)\n imBaseBTmp = itk.imread(nameB, itk.F)\n imBase.append(imBaseTmp)\n imBaseB.append(imBaseBTmp)\n\n\n# In[4]:\n\n\n#view(im1iso)\n\n\n# In[5]:\n\n\n#view(imBase[0])\n\n\n# In[6]:\n\n\nimMath = ttk.ImageMath.New(Input=im1iso)\n#imMath.Threshold(-4000,-500,1,0)\n#headMask = imMath.GetOutput()\nimMath.SetInput(im1iso)\n#imMath.IntensityWindow(0,1000,1000,0)\n#imMath.ReplaceValuesOutsideMaskRange(headMask,-0.5,0.5,-500)\nimMath.Blur(1)\nimMath.NormalizeMeanStdDev()\nimMath.IntensityWindow(-5,5,-500,500)\nim1isoBlur = imMath.GetOutput()\n#view(im1isoBlur)\n\n\n# In[7]:\n\n\nRegisterImagesType = ttk.RegisterImages[ImageType]\nregB = []\nregBB = []\nfor i in range(0,N):\n imMath.SetInput(imBase[i])\n imMath.Blur(1)\n imMath.NormalizeMeanStdDev()\n imMath.IntensityWindow(-5,5,-500,500)\n imBaseBlur = imMath.GetOutput()\n \n #regBTo1 = RegisterImagesType.New(FixedImage=im1isoBlur, MovingImage=imBaseBlur)\n regBTo1 = RegisterImagesType.New(FixedImage=imBaseBlur, MovingImage=im1isoBlur)\n regBTo1.SetReportProgress(True)\n \n regBTo1.SetRigidMaxIterations(3000)\n regBTo1.SetAffineMaxIterations(3000)\n \n regBTo1.SetExpectedRotationMagnitude(0.2)\n regBTo1.SetExpectedScaleMagnitude(0.25)\n regBTo1.SetExpectedSkewMagnitude(0.01)\n regBTo1.SetExpectedOffsetMagnitude(40) \n\n regBTo1.SetRigidSamplingRatio(0.1)\n regBTo1.SetAffineSamplingRatio(0.1)\n \n regBTo1.SetSampleFromOverlap(True)\n \n regBTo1.SetInitialMethodEnum(\"INIT_WITH_IMAGE_CENTERS\")\n regBTo1.SetRegistration(\"PIPELINE_AFFINE\")\n regBTo1.SetMetric(\"MATTES_MI_METRIC\")\n \n regBTo1.Update()\n \n tfm = regBTo1.GetCurrentMatrixTransform()\n tfmInv = tfm.GetInverseTransform()\n print(tfm)\n \n resm = ttk.ResampleImage.New(Input=imBase[i])\n resm.SetMatchImage(im1iso)\n resm.SetTransform(tfmInv)\n resm.SetLoadTransform(True)\n resm.Update()\n img = resm.GetOutput()\n regB.append( img )\n\n resm = ttk.ResampleImage.New(Input=imBaseB[i])\n resm.SetMatchImage(im1iso)\n resm.SetTransform(tfmInv)\n resm.SetLoadTransform(True)\n resm.Update()\n img = resm.GetOutput()\n regBB.append( img )\n\n\n# In[8]:\n\n\nimMath.SetInput(regB[1])\nimMath.AddImages(im1iso,20,1)\nimg = imMath.GetOutput()\n#view( img )\n\n\n# In[9]:\n\n\nregBBT = []\nfor i in range(0,N):\n imMath.SetInput(regBB[i])\n imMath.Threshold(0,1,0,1)\n img = imMath.GetOutput()\n if i==0:\n imMath.SetInput( img )\n imMath.AddImages( img, 1.0/N, 0 )\n sumBBT = imMath.GetOutput()\n else:\n imMath.SetInput( sumBBT )\n imMath.AddImages( img, 1, 1.0/N )\n sumBBT = imMath.GetOutput()\n \n#view(sumBBT)\n\n\n# In[10]:\n\n\nimMath.SetInput(sumBBT)\nimMath.Threshold(0.85,1.1,1,0)\nimMath.Dilate(5,1,0)\nimMath.Erode(25,1,0)\nbrainInside = imMath.GetOutput()\n\nimMath.SetInput( sumBBT )\nimMath.Threshold(0,0,1,0)\nimMath.Erode(1,1,0)\nbrainOutsideAll = imMath.GetOutput()\nimMath.Erode(20,1,0)\nimMath.AddImages(brainOutsideAll, -1, 1)\nbrainOutside = imMath.GetOutput()\n\nimMath.AddImages(brainInside,1,2)\nbrainCombinedMask = imMath.GetOutputUChar()\nbrainCombinedMaskF = imMath.GetOutput()\n\n\n# In[11]:\n\n\nimMath.SetInput(brainCombinedMaskF)\nimMath.AddImages(im1iso, 100, 1)\nbrainCombinedMaskView = imMath.GetOutput()\n#view(brainCombinedMaskView)\n\n\n# In[12]:\n\n\nLabelMapType = itk.Image[itk.UC,3]\n\nsegmenter = ttk.SegmentConnectedComponentsUsingParzenPDFs[ImageType,LabelMapType].New()\nsegmenter.SetFeatureImage( im1iso )\nsegmenter.SetInputLabelMap( brainCombinedMask )\nsegmenter.SetObjectId( 2 )\nsegmenter.AddObjectId( 1 )\nsegmenter.SetVoidId( 0 )\nsegmenter.SetErodeDilateRadius( 10 )\nsegmenter.SetHoleFillIterations( 40 )\nsegmenter.Update()\nsegmenter.ClassifyImages()\nbrainCombinedMaskClassified = segmenter.GetOutputLabelMap()\n\n\n# In[13]:\n\n\n#view(brainCombinedMaskClassified)\n\n\n# In[14]:\n\n\ncast = itk.CastImageFilter[LabelMapType, ImageType].New()\ncast.SetInput(brainCombinedMaskClassified)\ncast.Update()\nbrainMaskF = cast.GetOutput()\n\nbrainMath = ttk.ImageMath[ImageType,ImageType].New(Input = brainMaskF)\nbrainMath.Threshold(2,2,1,0)\nbrainMath.Erode(1,1,0)\nbrainMaskD = brainMath.GetOutput()\nbrainMath.SetInput( im1iso )\nbrainMath.ReplaceValuesOutsideMaskRange( brainMaskD, 1, 1, 0)\nbrain = brainMath.GetOutput()\n\n\n# In[15]:\n\n\n#view(brain)\n\n\n# In[16]:\n\n\nwriter = itk.ImageFileWriter[ImageType].New(Input = brain)\nfilename = InputBaseName + \"-Brain.nrrd\"\nwriter.SetFileName(filename)\nwriter.SetUseCompression(True)\nwriter.Update()\n\n\n# In[ ]:\n\n\n\n#!/usr/bin/env python\n# coding: utf-8\n\n# This notebook is intended to demonstrate how select registration, segmentation, and image mathematical methods of ITKTubeTK can be combined to perform multi-channel brain extraction (aka. skull stripping for patient data containing multiple MRI sequences).\n# \n# There are many other (probably more effective) brain extraction methods available as open-source software such as BET and BET2 in the FSL package (albeit such methods are only for single channel data). If you need to perform brain extraction for a large collection of scans that do not contain major pathologies, please use one of those packages. This notebook is meant to show off the capabilities of specific ITKTubeTK methods, not to demonstration how to \"solve\" brain extraction.\n\n# In[1]:\n\n\n#import itk\n#from itk import TubeTK as ttk\n\n#from itkwidgets import view\n\n#import numpy as np\n\n# In[2]:\n\nInputBaseDir = studyname \n\nCTPMaxFilename = InputBaseDir + \"-MinMax/max.nrrd\"\nCTPMinFilename = InputBaseDir + \"-MinMax/min.nrrd\"\nCTPBrainFilename = InputBaseDir + \"-MinMax/max3-Brain.nrrd\"\n\nimMax = itk.imread(CTPMaxFilename, itk.F)\nimMin = itk.imread(CTPMinFilename, itk.F)\nimBrain = itk.imread(CTPBrainFilename, itk.F)\n\n\n# In[3]:\n\n\n#view(imBrain)\n\n\n# In[4]:\n\n\nImageType = itk.Image[itk.F, 3]\n\nimMath = ttk.ImageMath.New(Input=imBrain)\nimMath.Threshold( 0.00001, 2000, 1, 0)\nimMath.Erode(10,1,0)\nimBrainMaskErode = imMath.GetOutput()\n\nimMath.SetInput(imMax)\nimMath.AddImages(imMin,1,-1)\nimDiff = imMath.GetOutput()\nimMath.ReplaceValuesOutsideMaskRange(imBrain, 0.0001, 2000, 0)\nimDiffBrain = imMath.GetOutput()\nimMath.ReplaceValuesOutsideMaskRange(imBrainMaskErode, 0.5, 1.5, 0)\nimDiffBrainErode = imMath.GetOutput()\n\n\n# In[5]:\n\n\ntmpA = itk.GetArrayViewFromImage(imDiffBrain)\ntmpAE = itk.GetArrayViewFromImage(imDiffBrainErode)\nzMax = tmpA.shape[0]\nclip = 0\nwhile((np.amax(tmpA[clip:clip+1,:,:])>1000) | (np.amax(tmpA[clip:clip+1,:,:])==0)):\n clip += 1\nif(clip>0):\n tmpA[0:clip,:,:]=0\n tmpAE[0:clip,:,:]=0\nclip = 1\nwhile((np.amax(tmpA[zMax-clip:zMax-clip+1,:,:])>1000) | (np.amax(tmpA[zMax-clip:zMax-clip+1,:,:])==0)):\n clip += 1\nprint(clip, np.amax(tmpA[zMax-clip:zMax-clip+1,:,:]))\nclip = clip - 1\nif(clip>0):\n tmpA[zMax-clip:zMax,:,:]=0 #Happens to imDiffBrain since this array is a view of an itk image\n tmpAE[zMax-clip:zMax,:,:]=0 #Happens to imDiffBrain since this array is a view of an itk image\n\n\n# In[6]:\n\n\n#view(imDiffBrain)\n\n\n# In[7]:\n\n\nimMath = ttk.ImageMath[ImageType,ImageType].New()\nimMath.SetInput(imDiffBrainErode)\nimMath.Blur(1.5)\nimBlur = imMath.GetOutput()\nimBlurArray = itk.GetArrayViewFromImage(imBlur)\n\nnumSeeds = 15\nseedCoverage = 20\nseedCoord = np.zeros([numSeeds,3])\nfor i in range(numSeeds):\n seedCoord[i] = np.unravel_index(np.argmax(imBlurArray, axis=None), imBlurArray.shape)\n indx = [int(seedCoord[i][0]),int(seedCoord[i][1]),int(seedCoord[i][2])]\n minX = max(indx[0]-seedCoverage,0)\n maxX = max(indx[0]+seedCoverage,imBlurArray.shape[0])\n minY = max(indx[1]-seedCoverage,0)\n maxY = max(indx[1]+seedCoverage,imBlurArray.shape[1])\n minZ = max(indx[2]-seedCoverage,0)\n maxZ = max(indx[2]+seedCoverage,imBlurArray.shape[2])\n imBlurArray[minX:maxX,minY:maxY,minZ:maxZ]=0\n indx.reverse()\n seedCoord[:][i] = imDiffBrain.TransformIndexToPhysicalPoint(indx)\nprint(seedCoord)\n\n\n# In[8]:\n\n\n# Manually extract a few vessels to form an image-specific training set\nvSeg = ttk.SegmentTubes.New(Input=imDiffBrain)\nvSeg.SetVerbose(True)\nvSeg.SetMinRoundness(0.4)\nvSeg.SetMinCurvature(0.002)\nvSeg.SetRadiusInObjectSpace( 1 )\nfor i in range(numSeeds):\n print(\"**** Processing seed \" + str(i) + \" : \" + str(seedCoord[i]))\n vSeg.ExtractTubeInObjectSpace( seedCoord[i], i )\n \ntubeMaskImage = vSeg.GetTubeMaskImage()\n\n\n# In[9]:\n\n\nimMath.SetInput(tubeMaskImage)\nimMath.AddImages(imDiffBrain, 200, 1)\nblendIm = imMath.GetOutput()\n#view(blendIm)\n\n\n# In[10]:\n\n\nLabelMapType = itk.Image[itk.UC,3]\n\ntrMask = ttk.ComputeTrainingMask[ImageType,LabelMapType].New()\ntrMask.SetInput( tubeMaskImage )\ntrMask.SetGap( 4 )\ntrMask.SetObjectWidth( 1 )\ntrMask.SetNotObjectWidth( 1 )\ntrMask.Update()\nfgMask = trMask.GetOutput()\n\n\n# In[11]:\n\n\n#view(fgMask)\n\n\n# In[12]:\n\n\nenhancer = ttk.EnhanceTubesUsingDiscriminantAnalysis[ImageType,LabelMapType].New()\nenhancer.AddInput( imDiff )\nenhancer.SetLabelMap( fgMask )\nenhancer.SetRidgeId( 255 )\nenhancer.SetBackgroundId( 128 )\nenhancer.SetUnknownId( 0 )\nenhancer.SetTrainClassifier(True)\nenhancer.SetUseIntensityOnly(True)\nenhancer.SetScales([0.43,1.29,3.01])\nenhancer.Update()\nenhancer.ClassifyImages()\n\n\n# In[13]:\n\n\nim1vess = itk.SubtractImageFilter( Input1=enhancer.GetClassProbabilityImage(0), Input2=enhancer.GetClassProbabilityImage(1))\n\nimMath.SetInput(imDiffBrain)\nimMath.Threshold(0.0001,2000,1,0)\nimMath.Erode(2,1,0)\nimBrainE = imMath.GetOutput()\n\nimMath.SetInput(im1vess)\nimMath.ReplaceValuesOutsideMaskRange(imBrainE, 1, 1, -0.001)\nim1vessBrain = imMath.GetOutput()\n#view(enhancer.GetClassProbabilityImage(0))\n#view(im1vessBrain)\n\n\n# In[14]:\n\n\nitk.imwrite( im1vess, InputBaseDir + \"-MinMax/diff-VesselEnhanced.nrrd\", compression=True)\n\nitk.imwrite( im1vessBrain, InputBaseDir + \"-MinMax/Brain-VesselEnhanced.nrrd\", compression=True)\n\n\n# In[ ]:\n\n\n#!/usr/bin/env python\n# coding: utf-8\n\n# This notebook is intended to demonstrate how vessel segmentation methods of ITKTubeTK can be applied to multi-channel MRI (MRA + T1, T2, etc).\n\n# In[1]:\n\n\n#import itk\n#from itk import TubeTK as ttk\n\n#from itkwidgets import view\n\n#import numpy as np\n\n\n# In[2]:\n\n\nImageType = itk.Image[itk.F, 3]\n\nimDir = studyname + \"-MinMax/\"\n\nim1iso = itk.imread(imDir + \"diff3.nrrd\")\nim1BrainVess = itk.imread(imDir + \"Brain-VesselEnhanced.nrrd\")\n\n\n# In[3]:\n\n\nimMath = ttk.ImageMath.New(im1BrainVess)\nimMath.MedianFilter(1)\nimMath.Threshold(0.000001, 1, 1, 0)\nim1VessMask = imMath.GetOutputShort()\n\nccSeg = ttk.SegmentConnectedComponents.New(im1VessMask)\nccSeg.SetMinimumVolume(10)\nccSeg.Update()\nim1VessMaskCC = ccSeg.GetOutput()\n\n\n# In[4]:\n\n\n#view(im1VessMaskCC)\n\n\n# In[5]:\n\n\nimMathSS = ttk.ImageMath.New(im1VessMaskCC)\nimMathSS.Threshold(0,0,1,0)\nim1VessMaskInv = imMathSS.GetOutputFloat()\n\ndistFilter = itk.DanielssonDistanceMapImageFilter.New(im1VessMaskInv)\ndistFilter.Update()\ndist = distFilter.GetOutput()\n\nimMath.SetInput(dist)\nimMath.Blur(0.4)\ntmp = imMath.GetOutput()\nimMath.ReplaceValuesOutsideMaskRange(tmp, 0.1, 10, 0)\nim1SeedRadius = imMath.GetOutput()\n\nitk.imwrite(im1SeedRadius, imDir+\"VesselsSeedRadius.mha\")\n\n\n# In[6]:\n\n\n#view(im1SeedRadius)\n\n\n# In[7]:\n\n\nimMath.SetInput(im1iso)\nimMath.ReplaceValuesOutsideMaskRange(im1BrainVess, 0, 1000, 0)\nimMath.Blur(0.4)\nimMath.IntensityWindow(0.5,1000,0,1000)\nim1Input = imMath.GetOutput()\n\nitk.imwrite(im1iso, imDir+\"VesselsInput.mha\")\n\n#view(im1Input)\n\n\n# In[8]:\n\n\nnumSeeds = 40\n\nvSeg = ttk.SegmentTubes.New(Input=im1Input)\n#vSeg.SetVerbose(True)\nvSeg.SetMinCurvature(0)#.0001)\nvSeg.SetMinRoundness(0.02)\nvSeg.SetMinRidgeness(0.5)\nvSeg.SetMinLevelness(0.0)\nvSeg.SetRadiusInObjectSpace( 0.8 )\nvSeg.SetBorderInIndexSpace(3)\nvSeg.SetSeedMask( im1SeedRadius )\nvSeg.SetSeedRadiusMask( im1SeedRadius )\nvSeg.SetOptimizeRadius(False)\nvSeg.SetUseSeedMaskAsProbabilities(True)\nvSeg.SetSeedExtractionMinimumProbability(0.4)\n#vSeg.SetSeedMaskMaximumNumberOfPoints( numSeeds )\nvSeg.ProcessSeeds()\n\n\n# In[9]:\n\n\ntubeMaskImage = vSeg.GetTubeMaskImage()\n#view(tubeMaskImage)\n\n\n# In[10]:\n\n\nSOWriter = itk.SpatialObjectWriter[3].New()\nSOWriter.SetInput(vSeg.GetTubeGroup())\nSOWriter.SetBinaryPoints(True)\nSOWriter.SetFileName( imDir+\"Vessels.tre\" )\nSOWriter.Update()\n\n\n# In[ ]:\n\n\n\n\n\n\n\n\n\n", "meta": {"hexsha": "901b7f97bef927192211c6c7d6ab962f9f49a74c", "size": 18295, "ext": "py", "lang": "Python", "max_stars_repo_path": "examples/CTP-Head/ctp-head-CombinedScript.py", "max_stars_repo_name": "kian-weimer/ITKTubeTK", "max_stars_repo_head_hexsha": "88da3195bfeca017745e7cddfe04f82571bd00ee", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 27, "max_stars_repo_stars_event_min_datetime": "2020-04-06T17:23:22.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-02T13:25:52.000Z", "max_issues_repo_path": "examples/CTP-Head/ctp-head-CombinedScript.py", "max_issues_repo_name": "kian-weimer/ITKTubeTK", "max_issues_repo_head_hexsha": "88da3195bfeca017745e7cddfe04f82571bd00ee", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 14, "max_issues_repo_issues_event_min_datetime": "2020-04-09T00:23:15.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-26T13:02:35.000Z", "max_forks_repo_path": "examples/CTP-Head/ctp-head-CombinedScript.py", "max_forks_repo_name": "kian-weimer/ITKTubeTK", "max_forks_repo_head_hexsha": "88da3195bfeca017745e7cddfe04f82571bd00ee", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 14, "max_forks_repo_forks_event_min_datetime": "2020-04-03T03:56:14.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-14T07:51:32.000Z", "avg_line_length": 23.2465057179, "max_line_length": 489, "alphanum_fraction": 0.7300901886, "include": true, "reason": "import numpy", "num_tokens": 5625, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230156, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.198468367499571}} {"text": "#!/usr/bin/env python\n# -*- coding: utf-8 -*\n\n\"\"\"\ntools module\n\"\"\"\n\n__author__ = 'Dr. Janus Juul Eriksen, University of Bristol, UK'\n__maintainer__ = 'Dr. Janus Juul Eriksen'\n__email__ = 'janus.eriksen@bristol.ac.uk'\n__status__ = 'Development'\n\nimport sys\nimport os\nimport copy\nimport numpy as np\ntry:\n import opt_einsum as oe\n OE_AVAILABLE = True\nexcept ImportError:\n OE_AVAILABLE = False\nfrom subprocess import Popen, PIPE\nfrom pyscf import gto, scf, dft, symm, lib\nfrom pyscf import tools as pyscf_tools\nfrom typing import Tuple, List, Dict, Union\n\nMAX_CYCLE = 100\nNATORB_THRES = 1.e-12\n\nclass Logger(object):\n \"\"\"\n this class pipes all write statements to both stdout and output_file\n \"\"\"\n def __init__(self, output_file, both=True) -> None:\n \"\"\"\n init Logger\n \"\"\"\n self.terminal = sys.stdout\n self.log = open(output_file, 'a')\n self.both = both\n\n def write(self, message) -> None:\n \"\"\"\n define write\n \"\"\"\n self.log.write(message)\n if self.both:\n self.terminal.write(message)\n\n def flush(self) -> None:\n \"\"\"\n define flush\n \"\"\"\n pass\n\n\ndef git_version() -> str:\n \"\"\"\n this function returns the git revision as a string\n \"\"\"\n def _minimal_ext_cmd(cmd):\n env = {}\n for k in ['SYSTEMROOT', 'PATH', 'HOME']:\n v = os.environ.get(k)\n if v is not None:\n env[k] = v\n # LANGUAGE is used on win32\n env['LANGUAGE'] = 'C'\n env['LANG'] = 'C'\n env['LC_ALL'] = 'C'\n out = Popen(cmd, stdout=PIPE, env=env, \\\n cwd=os.path.dirname(__file__)).communicate()[0]\n return out\n\n try:\n out = _minimal_ext_cmd(['git', 'rev-parse', 'HEAD'])\n GIT_REVISION = out.strip().decode('ascii')\n except OSError:\n GIT_REVISION = \"Unknown\"\n\n return GIT_REVISION\n\n\ndef dim(mo_occ: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:\n \"\"\"\n determine molecular dimensions\n \"\"\"\n return np.where(np.abs(mo_occ[0]) > 0.)[0], np.where(np.abs(mo_occ[1]) > 0.)[0]\n\n\ndef mf_info(mf: Union[scf.hf.SCF, dft.rks.KohnShamDFT]) -> Tuple[Tuple[np.ndarray, np.ndarray], \\\n Tuple[np.ndarray, np.ndarray]]:\n \"\"\"\n retrieve mf information (mo coefficients & occupations)\n \"\"\"\n # mo occupations\n if np.asarray(mf.mo_occ).ndim == 1:\n mo_occ = (np.ones(np.count_nonzero(0. < mf.mo_occ)), np.ones(np.count_nonzero(1. < mf.mo_occ)))\n else:\n mo_occ = (mf.mo_occ[0][np.nonzero(mf.mo_occ[0])], mf.mo_occ[1][np.nonzero(mf.mo_occ[1])])\n # dimensions\n alpha, beta = dim(mo_occ)\n # mo coefficients\n if np.asarray(mf.mo_coeff).ndim == 2:\n mo_coeff = (mf.mo_coeff[:, alpha], mf.mo_coeff[:, beta])\n else:\n mo_coeff = (mf.mo_coeff[0][:, alpha], mf.mo_coeff[1][:, beta])\n\n return mo_coeff, mo_occ\n\n\ndef orbsym(mol, mo_coeff):\n \"\"\"\n this functions returns orbital symmetries\n \"\"\"\n if isinstance(mo_coeff, np.ndarray):\n if mo_coeff.ndim == 2:\n try:\n orbsymm = symm.label_orb_symm(mol, mol.irrep_name, mol.symm_orb, mo_coeff)\n except:\n orbsymm = np.array(['A'] * mo_coeff.shape[1])\n else:\n try:\n orbsymm = np.array([symm.label_orb_symm(mol, mol.irrep_name, mol.symm_orb, c) for c in mo_coeff])\n except:\n orbsymm = np.array([['A'] * c.shape[1] for c in mo_coeff])\n else:\n try:\n orbsymm = np.array([symm.label_orb_symm(mol, mol.irrep_name, mol.symm_orb, c) for c in mo_coeff])\n except:\n orbsymm = np.array([['A'] * c.shape[1] for c in mo_coeff])\n\n return orbsymm\n\n\ndef make_rdm1(mo: np.ndarray, occup: np.ndarray) -> np.ndarray:\n \"\"\"\n this function returns an 1-RDM (in ao basis) corresponding to given mo(s)\n \"\"\"\n return contract('ip,jp->ij', occup * mo, mo)\n\n\ndef make_natorb(mol: gto.Mole, mo_coeff: np.ndarray, \\\n rdm1: np.ndarray, thres: float = NATORB_THRES) -> Tuple[Tuple[np.ndarray, np.ndarray], \\\n Tuple[np.ndarray, np.ndarray]]:\n \"\"\"\n this function returns no coefficients and occupations corresponding\n to given mo coefficients and rdm1\n \"\"\"\n # reshape mo_coeff and rdm1\n if mo_coeff.ndim == 2:\n c = np.asarray((mo_coeff,) * 2)\n else:\n c = mo_coeff\n if rdm1.ndim == 2:\n d = np.array([rdm1, rdm1]) * .5\n else:\n d = rdm1\n # overlap matrix\n s = mol.intor_symmetric('int1e_ovlp')\n # ao to mo transformation of dm\n rdm1_mo = contract('xpi,pq,xqr,rs,xsj->xij', c, s, d, s, c)\n # diagonalize rdm1_mo\n occ_no, u = np.linalg.eigh(rdm1_mo)\n # transform to no basis\n mo_no = contract('xip,xpj->xij', c, u)\n # retain only significant nos\n return (mo_no[0][:, np.where(np.abs(occ_no[0]) >= thres)[0]], mo_no[1][:, np.where(np.abs(occ_no[1]) >= thres)[0]]), \\\n (occ_no[0][np.where(np.abs(occ_no[0]) >= thres)], occ_no[1][np.where(np.abs(occ_no[1]) >= thres)])\n\n\ndef write_rdm1(mol: gto.Mole, part: str, \\\n mo_coeff: np.ndarray, mo_occ: np.ndarray, fmt: str, \\\n weights: List[np.ndarray], \\\n suffix: str = '') -> None:\n \"\"\"\n this function writes a 1-RDM as a numpy or cube (default) file\n \"\"\"\n # assertion\n assert part == 'atoms', '`write_rdm1` function only implemented for `atoms` partitioning'\n assert fmt in ['cube', 'numpy'], 'fmt arg to `write_rdm1` must be `cube` or `numpy`'\n # molecular dimensions\n alpha, beta = dim(mo_occ)\n # compute total 1-RDM (AO basis)\n rdm1_tot = np.array([make_rdm1(mo_coeff[0], mo_occ[0]), make_rdm1(mo_coeff[1], mo_occ[1])])\n # loop over atoms\n for a in range(mol.natm):\n # atom-specific rdm1\n rdm1_atom = np.zeros_like(rdm1_tot)\n # loop over spins\n for i, spin_mo in enumerate((alpha, beta)):\n # loop over spin-orbitals\n for m, j in enumerate(spin_mo):\n # get orbital(s)\n orb = mo_coeff[i][:, j].reshape(mo_coeff[i].shape[0], -1)\n # orbital-specific rdm1\n rdm1_orb = make_rdm1(orb, mo_occ[i][j])\n # weighted contribution to rdm1_atom\n rdm1_atom[i] += rdm1_orb * weights[i][m][a]\n if fmt == 'cube':\n # write rdm1_atom as cube file\n pyscf_tools.cubegen.density(mol, f'atom_{mol.atom_symbol(a).upper():s}{a:d}_rdm1{suffix:}.cube', \\\n np.sum(rdm1_atom, axis=0))\n else:\n # write rdm1_atom as numpy file\n np.save(f'atom_{mol.atom_symbol(a).upper():s}{a:d}_rdm1{suffix:}.npy', np.sum(rdm1_atom, axis=0))\n\n\ndef res_add(res_a, res_b):\n \"\"\"\n this function adds two result dictionaries\n \"\"\"\n return {key: res_a[key] + res_b[key] for key in res_a.keys()}\n\n\ndef res_sub(res_a, res_b):\n \"\"\"\n this function subtracts two result dictionaries\n \"\"\"\n return {key: res_a[key] - res_b[key] for key in res_a.keys()}\n\n\ndef contract(eqn, *tensors):\n \"\"\"\n interface to optimized einsum operation\n \"\"\"\n if OE_AVAILABLE:\n return oe.contract(eqn, *tensors)\n else:\n return np.einsum(eqn, *tensors, optimize=True)\n\n\n", "meta": {"hexsha": "4404ab7f872b125d775084569215a89c507428c5", "size": 8037, "ext": "py", "lang": "Python", "max_stars_repo_path": "decodense/tools.py", "max_stars_repo_name": "luna-component/decodense", "max_stars_repo_head_hexsha": "2579b7a3b7500b32ab231ebacb35c91e87e96735", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "decodense/tools.py", "max_issues_repo_name": "luna-component/decodense", "max_issues_repo_head_hexsha": "2579b7a3b7500b32ab231ebacb35c91e87e96735", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "decodense/tools.py", "max_forks_repo_name": "luna-component/decodense", "max_forks_repo_head_hexsha": "2579b7a3b7500b32ab231ebacb35c91e87e96735", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.4935622318, "max_line_length": 126, "alphanum_fraction": 0.5283065821, "include": true, "reason": "import numpy", "num_tokens": 2094, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230157, "lm_q2_score": 0.38491214448393346, "lm_q1q2_score": 0.198468367499571}} {"text": "import numpy as np\nfrom cppdefs import *\nfrom pom.modules_old import RLEN, bfm_lwp, LOGUNIT, seconds_per_day\n\n\nclass TimeInfo:\n\n def __init__(self, date0, time0, timeEnd, step0, timestep, stepnow, stepEnd):\n self.date0 = date0\n self.time0 = time0\n self.timeEnd = timeEnd\n self.step0 = step0\n self.timestep = timestep\n self.stepnow = stepnow\n self.stepEnd = stepEnd\n\n\n# PUBLIC DATA MEMBERS:\ntimestr = ' ' * 19\nstart = '2000-01-01 00:00:00'\nstop = ' ' * 19\n\n# PRIVATE DATA MEMBERS\njul0 = -1\nsecs0 = -1\n\n\n# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n#\n# # ROUTINE: INITIALIZE THE TIME SYSTEM\n#\n# DESCRIPTION: The subroutine {\\tt init\\_time()} initialises the time module by reading\n# a namelist and take actions according to the specifications.\n# On exit from this subroutine the two variables MinN and MaxN have well\n# defined values and can be used in the time loop.\n#\n# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n\ndef initialize_time_system(MinN,MaxN,timestep,timefmt,simdays,start,stop):\n\n \"\"\"\n Description: Initializes the time module by reading a namelist.\n Takes actions accrding to the specifications.\n\n :param MinN: minimum number of time steps\n :param MaxN: maximum number of time steps\n :param timestep: size of time step\n :param timefmt: time format\n :param simdays: number of days for simulation\n :param start: start date\n :param stop: end date\n :return:\n \"\"\"\n\n jul1 = -1\n secs1 = -1\n\n # -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n # READ TIME SPECIFIC THINGS FROM THE NAMELIST\n # -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n\n LEVEL1(); print('initialize_time_system')\n\n # CALCULATE MaxN -> MinN IS 1 IF NOT CHANGED BY HOTSTART\n MinN = 1\n LEVEL2(); print('Time step: ', timestep, ' seconds')\n LEVEL2(); print('Time format: ', timefmt)\n\n if timefmt == 1:\n HasRealTime = False\n LEVEL2(); print('# of timesteps: ', MaxN)\n # start = '2000-01-01 00:00:00'\n LEVEL2(); print('Fake start: ', start)\n\n elif timefmt == 2:\n HasRealTime = True\n LEVEL2(); print('Start: ', start)\n LEVEL2(); print('Stop: ', stop)\n jul1, secs1 = read_time_string(start)\n jul2, secs2 = read_time_string(stop)\n\n nsecs = time_diff(jul2, secs2, jul1, secs1)\n MaxN = round(nsecs / timestep)\n\n ndays = jul2 - jul1\n if nsecs < 86400 and jul1 != jul2:\n ndays = ndays - 1\n\n nsecs = nsecs - 86400 * ndays\n string = ' ==> ' + str(ndays) + ' day(s) and ' + str(nsecs) + ' seconds ==> ' + str(MaxN) + ' time steps'\n STDERR(string)\n\n elif timefmt == 3:\n HasRealTime = True\n LEVEL2(); print('Start: ', start)\n LEVEL2(); print('# of timesteps: ', MaxN)\n\n jul1, secs1 = read_time_string(start)\n\n nsecs = np.rint(MaxN * timestep) + secs1\n ndays = nsecs / 86400\n jul2 = jul1 + ndays\n secs2 = nsecs % 86400\n\n write_time_string(jul2, secs2)\n LEVEL2(); print('Stop: ', stop)\n\n elif timefmt == 4:\n HasRealTime = False\n nsecs = simdays * 86400\n MaxN = np.rint(nsecs / timestep)\n LEVEL2(); print('# of timesteps: ', MaxN)\n # start = '2000-01-01 00:00:00'\n LEVEL2(); print('Fake start: ', start)\n\n else:\n STDERR('Fatal error: A non valid input format has been chosen')\n return\n\n jul0 = jul1\n secs0 = secs1\n\n julianday = jul0\n secondsofday = secs0\n\n simtime = timestep * (MaxN - MinN + 1)\n\n # SET BFM TIME\n jday = float(jul0)\n yy, mm, dd, hh, nn = calendar_date(jday)\n\n bfmtime = TimeInfo(str(yy) + '-' + str(mm) + '-' + str(dd) + ' ' + str(hh) + ':' + str(nn),\n jday,\n jday + (float(MaxN) * timestep) / seconds_per_day,\n MinN - 1,\n timestep,\n MinN - 1,\n MaxN)\n\n LEVEL2(); print('bfmtime : ', bfmtime)\n\n return bfmtime\n\n\n# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n#\n# # ROUTINE: CONVERT TRUE JULIAN DAY TO CALENDAR DATE\n#\n# DESCRIPTION: Converts a Julian day to a calendar date --- year, month and day.\n# Based on a similar routine in \\emph{Numerical Recipes}.\n#\n# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n\ndef calendar_date(julian):\n\n \"\"\"\n Description: Converts a Julian day to a calender date --- year, month, and day\n\n :param julian: Julian day\n :return: calender date\n \"\"\"\n\n # LOCAL VARIABLES\n IGREG = 2299161\n\n # -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n\n jday = np.floor(julian)\n if jday >= IGREG:\n x = ((jday - 1867216) - 0.25) / 36524.25\n ja = jday + 1 + int(x) - int(0.25 * x)\n else:\n ja = jday\n\n jb = ja + 1524\n jc = int(6680 + ((jb - 2439870) - 122.1) / 365.25)\n jd = int(365 * jc + (0.25 * jc))\n je = int((jb - jd) / 30.6001)\n\n dd = jb - jd - int(30.6001 * je)\n mm = je - 1\n\n if mm > 12:\n mm = mm - 12\n\n yyyy = jc - 4715\n\n if mm > 2:\n yyyy = yyyy - 1\n\n if yyyy <= 0:\n yyyy = yyyy - 1\n\n res = julian - float(jday)\n hh = np.floor(res * 24)\n nn = np.floor(((res * 24) - float(hh)) * 60)\n\n return yyyy, mm, dd, hh, nn\n\n\n# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n#\n# # ROUTINE: CONVERT CALENDAR DATE TO JULIAN DAY\n#\n# DESCRIPTION: Converts a calendar date to a Julian day.\n# Based on a similar routine in \\emph{Numerical Recipes}.\n#\n# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n\ndef julian_day(yyyy,mm,dd,hh,nn):\n\n \"\"\"\n Description: Converts a calender date to a Julian day.\n\n :param yyyy: year\n :param mm: month\n :param dd: day\n :param hh: hour\n :param nn: minute\n :return: Julian day\n \"\"\"\n\n # LOCAL VARIABLES\n IGREG = 15 + 31 * (10 + 12 * 1582)\n\n # -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n\n jy = yyyy\n if jy < 0:\n jy = jy + 1\n\n if mm > 2:\n jm = mm + 1\n else:\n jy = jy - 1\n jm = mm + 13\n\n jday = int(np.floor(365.25 * jy) + np.floor(30.6001 * jm) + dd + 1720995)\n if dd + 31 * (mm + 12 * yyyy) >= IGREG:\n ja = int(0.01 * jy)\n jday = jday + 2 - ja + int(0.25 * ja)\n\n jh = hh\n jn = nn\n\n if jn >= 60:\n jh = jh + 1\n jn = jn - 60\n\n if jh >= 24:\n jday = jday + 1\n jh = jh - 24\n\n julian = float(jday) + float(jh) / 24 + float(jn) / (24 * 60)\n\n return julian\n\n\n# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n#\n# # ROUTINE: KEEP TRACK OF TIME (JULIAN DAYS AND SECONDS)\n#\n# DESCRIPTION: Based on a starting time this routine calculates the actual time\n# in a model integration using the number of time steps, {\\tt n},\n# and the size of the time step, {\\tt timestep}. More public variables\n# can be updated here if necessary.\n#\n# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n\ndef update_time(n,timestep,secs0):\n\n \"\"\"\n Description: Based on a starting time this routine calculates the actual time in a model integration\n using the number of time steps and the size of the time step.\n\n :param n: number of time steps\n :param timestep: size of time step\n :param secs0:\n :return: actual time in a model integration\n \"\"\"\n\n nsecs = np.rint(n * timestep) + secs0\n fsecs = n * timestep + secs0\n julianday = jul0 + nsecs / 86400\n secondsofday = nsecs % 86400\n\n return fsecs, julianday, secondsofday\n\n\n# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n#\n# # ROUTINE: CONVERT A TIME STRING TO JULIAN DAY AND SECONDS\n#\n# DESCRIPTION: Converts a time string to the true Julian day and seconds of that day.\n# The format of the time string must be: {\\tt yyyy-mm-dd hh:hh:ss }.\n#\n# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n\ndef read_time_string(timestr):\n\n \"\"\"\n Description: Converts a time string to the true Julian day and the seconds of that day.\n\n :param timestr: time string\n :return: Julian day and seconds of that day\n \"\"\"\n\n yy = timestr[0:4]\n mm = timestr[5:7]\n dd = timestr[8:10]\n hh = timestr[11:13]\n mins = timestr[14:16]\n ss = timestr[17:19]\n\n julian, jday = julian_day(yy,mm,dd,0,0)\n jul = int(jday)\n secs = 3600*hh + 60*mins + ss\n\n return jul, secs\n\n\n# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n#\n# # ROUTINE: CONVERT JULIAN DAY AND SECONDS TO A TIME STRING\n#\n# DESCRIPTION: Formats Julian day and seconds of that day to a nice looking\n# character string.\n#\n# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n\n\ndef write_time_string(jul,secs):\n\n \"\"\"\n Description: Formats Julian day and seconds of that day into a character string.\n\n :param jul: Julian day\n :param secs: seconds of Julian day\n :return: time string\n \"\"\"\n\n jday = float(jul)\n yy, mm, dd, hh, nn = calendar_date(jday)\n\n hh = secs / 3600\n mins = (secs - hh * 3600) / 60\n ss = secs - 3600 * hh - 60 * mins\n\n timestr = str(yy) + '-' + str(mm) + '-' + str(dd) + ' ' + str(hh) + ':' + str(mins) + ':' + str(ss)\n\n return timestr\n\n\n# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n#\n# # ROUTINE: RETURN THE TIME DIFFERENCE IN SECONDS\n#\n# DESCRIPTION: This functions returns the time difference between two\n# dates in seconds. The dates are given as Julian day and seconds\n# of that day.\n#\n# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n\ndef time_diff(jul2,secs2,jul1,secs1):\n\n \"\"\"\n Description: Returns the time difference between two dates in seconds.\n\n :param jul2: Julian day 2\n :param secs2: seconds of julian day 2\n :param jul1: Julian day 1\n :param secs1: seconds of julian day 1\n :return: difference between Julian day 2 and Julian day 1\n \"\"\"\n\n time_diff = 86400*(jul2-jul1) + (secs2-secs1)\n\n return time_diff\n\n\n# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n#\n# # ROUTINE: CONVERT A CALENDAR DATE TO TRUE JULIAN DAY\n#\n# DESCRIPTION: Converts a Julian day to the day number in the current year\n#\n# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n\ndef dayofyear(julian,yy):\n\n \"\"\"\n Description: Converts a Julian day to the day number in the curent year.\n\n :param julian: Julian day\n :param yy: current year\n :return: day number of the current year\n \"\"\"\n\n jday = float(julian)\n calendar_date(jday)\n julian0, jday = julian_day(yy,1,1,0,0)\n\n ddyear = julian - int(julian0) + 1\n\n return ddyear\n\n\n# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n#\n# # ROUTINE:\n#\n# DESCRIPTION:\n#\n# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n\ndef eomdays(Year,Month):\n\n \"\"\"\n Description: Provides system with the number of days in a given month.\n Accounts for leap year using Year input.\n\n :param Year: current year\n :param Month: current month\n :return: numbr of days in current month\n \"\"\"\n\n eomdays = 0\n if Month < 1 or Month > 12:\n print('eomdays: Invalid Month!!')\n elif Month in [1,3,4,7,8,10,12]: # Jan, Mar, May, July, Aug, Oct, Dec\n eomdays = 31\n elif Month == 2: # Feb\n eomdays = 28\n if Year % 4 == 0: # Leap Year\n eomdays = 29\n else: # Apr, June, Sep, Nov\n eomdays = 30\n\n return eomdays\n\n\n# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n#\n# # ROUTINE:\n#\n# DESCRIPTION:\n#\n# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n\n\ndef yeardays(Year):\n\n \"\"\"\n Description: Provides system with the number of days in the current year.\n\n :param Year: current year\n :return: number of days in current year\n \"\"\"\n\n yeardays = 0\n for i in range(0,12):\n yeardays = yeardays + float(eomdays(Year,i))\n\n if yeardays == 0 or yeardays > 366:\n print('yeardays out of bounds!!')\n\n return yeardays\n\n\n\n# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n# Copyright by the GOTM-team under the GNU Public License - www.gnu.org\n# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n", "meta": {"hexsha": "f2e3c50f61302c0601f5171365c956e5f760e110", "size": 13966, "ext": "py", "lang": "Python", "max_stars_repo_path": "share/time.py", "max_stars_repo_name": "MalikJordan/pyPOM1D", "max_stars_repo_head_hexsha": "196e5f52e4fb770a938f977a092d7eac77f61565", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "share/time.py", "max_issues_repo_name": "MalikJordan/pyPOM1D", "max_issues_repo_head_hexsha": "196e5f52e4fb770a938f977a092d7eac77f61565", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "share/time.py", "max_forks_repo_name": "MalikJordan/pyPOM1D", "max_forks_repo_head_hexsha": "196e5f52e4fb770a938f977a092d7eac77f61565", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-12-17T19:50:00.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-17T19:50:00.000Z", "avg_line_length": 29.4641350211, "max_line_length": 120, "alphanum_fraction": 0.4500214807, "include": true, "reason": "import numpy", "num_tokens": 3590, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230156, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.198468367499571}} {"text": "\"\"\"Inception_ResNet 1D models in Tensorflow-Keras.\nReference - [Rethinking the Inception Architecture for Computer Vision](http://arxiv.org/abs/1512.00567)\nInception_ResNet Review: https://towardsdatascience.com/review-inception-v4-evolved-from-googlenet-merged-with-resnet-idea-image-classification-5e8c339d18bc\n\"\"\"\n\nimport numpy as np\nimport tensorflow as tf\n\n\ndef Conv_1D_Block(x, model_width, kernel, strides=1, padding=\"same\"):\n # 1D Convolutional Block with BatchNormalization\n x = tf.keras.layers.Conv1D(model_width, kernel, strides=strides, padding=padding, kernel_initializer=\"he_normal\")(x)\n x = tf.keras.layers.BatchNormalization()(x)\n x = tf.keras.layers.Activation('relu')(x)\n\n return x\n\n\ndef classifier(inputs, class_number):\n # Construct the Classifier Group\n # inputs : input vector\n # class_number : number of output classes\n out = tf.keras.layers.Dense(class_number, activation='softmax')(inputs)\n return out\n\n\ndef regressor(inputs, feature_number):\n # Construct the Regressor Group\n # inputs : input vector\n # feature_number : number of output features\n out = tf.keras.layers.Dense(feature_number, activation='linear')(inputs)\n return out\n\n\ndef SE_Block(inputs, num_filters, ratio):\n squeeze = tf.keras.layers.GlobalAveragePooling1D()(inputs)\n\n excitation = tf.keras.layers.Dense(units=num_filters/ratio)(squeeze)\n excitation = tf.keras.layers.Activation('relu')(excitation)\n excitation = tf.keras.layers.Dense(units=num_filters)(excitation)\n excitation = tf.keras.layers.Activation('sigmoid')(excitation)\n excitation = tf.keras.layers.Reshape([1, num_filters])(excitation)\n\n scale = inputs * excitation\n\n return scale\n\n\ndef Inception_ResNet_Module_A(inputs, filterB1_1, filterB2_1, filterB2_2, filterB3_1, filterB3_2, filterB3_3, filterB4_1, i):\n # Inception ResNet Module A - Block i\n branch1x1 = Conv_1D_Block(inputs, filterB1_1, 1)\n\n branch3x3 = Conv_1D_Block(inputs, filterB2_1, 1)\n branch3x3 = Conv_1D_Block(branch3x3, filterB2_2, 3)\n\n branch3x3dbl = Conv_1D_Block(inputs, filterB3_1, 1)\n branch3x3dbl = Conv_1D_Block(branch3x3dbl, filterB3_2, 3)\n branch3x3dbl = Conv_1D_Block(branch3x3dbl, filterB3_3, 3)\n\n branch_concat = tf.keras.layers.concatenate([branch1x1, branch3x3, branch3x3dbl], axis=-1)\n branch1x1_ln = tf.keras.layers.Conv1D(filterB4_1, 1, activation='linear', strides=1, padding='same', kernel_initializer=\"he_normal\")(branch_concat)\n\n x = tf.keras.layers.Add(name='Inception_ResNet_Block_A'+str(i))([inputs, branch1x1_ln])\n x = tf.keras.layers.BatchNormalization()(x)\n out = tf.keras.layers.Activation('relu')(x)\n\n return out\n\n\ndef Inception_ResNet_Module_B(inputs, filterB1_1, filterB2_1, filterB2_2, filterB2_3, filterB3_1, i):\n # Inception ResNet Module B - Block i\n branch1x1 = Conv_1D_Block(inputs, filterB1_1, 1)\n\n branch7x7 = Conv_1D_Block(inputs, filterB2_1, 1)\n branch7x7 = Conv_1D_Block(branch7x7, filterB2_2, 7)\n branch7x7 = Conv_1D_Block(branch7x7, filterB2_3, 7)\n\n branch_concat = tf.keras.layers.concatenate([branch1x1, branch7x7], axis=-1)\n branch1x1_ln = tf.keras.layers.Conv1D(filterB3_1, 1, activation='linear', strides=1, padding='same', kernel_initializer=\"he_normal\")(branch_concat)\n\n x = tf.keras.layers.Add(name='Inception_ResNet_Block_B'+str(i))([inputs, branch1x1_ln])\n x = tf.keras.layers.BatchNormalization()(x)\n out = tf.keras.layers.Activation('relu')(x)\n\n return out\n\n\ndef Inception_ResNet_Module_C(inputs, filterB1_1, filterB2_1, filterB2_2, filterB2_3, filterB3_1, i):\n # Inception ResNet Module C - Block i\n branch1x1 = Conv_1D_Block(inputs, filterB1_1, 1)\n\n branch3x3 = Conv_1D_Block(inputs, filterB2_1, 1)\n branch3x3 = Conv_1D_Block(branch3x3, filterB2_2, 3)\n branch3x3 = Conv_1D_Block(branch3x3, filterB2_3, 3)\n\n branch_concat = tf.keras.layers.concatenate([branch1x1, branch3x3], axis=-1)\n branch1x1_ln = tf.keras.layers.Conv1D(filterB3_1, 1, activation='linear', strides=1, padding='same', kernel_initializer=\"he_normal\")(branch_concat)\n\n x = tf.keras.layers.Add(name='Inception_ResNet_Block_C'+str(i))([inputs, branch1x1_ln])\n x = tf.keras.layers.BatchNormalization()(x)\n out = tf.keras.layers.Activation('relu')(x)\n\n return out\n\n\ndef Reduction_Block_A(inputs, filterB1_1, filterB2_1, filterB2_2, filterB2_3):\n # Reduction Block A\n branch_pool = tf.keras.layers.MaxPooling1D(pool_size=3, strides=2)(inputs)\n\n branch3x3 = Conv_1D_Block(inputs, filterB1_1, 3, strides=2, padding='valid')\n\n branch3x3dbl = Conv_1D_Block(inputs, filterB2_1, 1)\n branch3x3dbl = Conv_1D_Block(branch3x3dbl, filterB2_2, 3)\n branch3x3dbl = Conv_1D_Block(branch3x3dbl, filterB2_3, 3, strides=2, padding='valid')\n\n x = tf.keras.layers.concatenate([branch_pool, branch3x3, branch3x3dbl], axis=-1, name='Reduction_Block_A')\n x = tf.keras.layers.BatchNormalization()(x)\n out = tf.keras.layers.Activation('relu')(x)\n\n return out\n\n\ndef Reduction_Block_B(inputs, filterB1_1, filterB1_2, filterB2_1, filterB2_2, filterB3_1, filterB3_2, filterB3_3):\n # Reduction Block B\n branch_pool = tf.keras.layers.MaxPooling1D(pool_size=3, strides=2)(inputs)\n\n branch3x3 = Conv_1D_Block(inputs, filterB1_1, 1)\n branch3x3 = Conv_1D_Block(branch3x3, filterB1_2, 3, strides=2, padding='valid')\n\n branch3x3_2 = Conv_1D_Block(inputs, filterB2_1, 1)\n branch3x3_2 = Conv_1D_Block(branch3x3_2, filterB2_2, 3, strides=2, padding='valid')\n\n branch3x3dbl = Conv_1D_Block(inputs, filterB3_1, 1)\n branch3x3dbl = Conv_1D_Block(branch3x3dbl, filterB3_2, 3)\n branch3x3dbl = Conv_1D_Block(branch3x3dbl, filterB3_3, 3, strides=2, padding='valid')\n\n x = tf.keras.layers.concatenate([branch_pool, branch3x3, branch3x3_2, branch3x3dbl], axis=-1)\n x = tf.keras.layers.BatchNormalization()(x)\n out = tf.keras.layers.Activation('relu')(x)\n\n return out\n\n\nclass SEInception_ResNet:\n def __init__(self, length, num_channel, num_filters, ratio=4, problem_type='Regression',\n output_nums=1, pooling='avg', dropout_rate=False, auxilliary_outputs=False):\n # length: Input Signal Segments Length\n # model_depth: Depth of the Model\n # model_width: Width of the Model\n # kernel_size: Kernel or Filter Size of the Input Convolutional Layer\n # num_channel: Number of Channels of the Input Predictor Signals\n # problem_type: Regression or Classification\n # output_nums: Number of Output Classes in Classification mode and output features in Regression mode\n # pooling: Choose either 'max' for MaxPooling or 'avg' for Averagepooling\n # dropout_rate: If turned on, some layers will be dropped out randomly based on the selected proportion\n # auxilliary_outputs: Two extra Auxullary outputs for the Inception models, acting like Deep Supervision\n self.length = length\n self.num_channel = num_channel\n self.num_filters = num_filters\n self.ratio = ratio\n self.problem_type = problem_type\n self.output_nums = output_nums\n self.pooling = pooling\n self.dropout_rate = dropout_rate\n self.auxilliary_outputs = auxilliary_outputs\n\n def MLP(self, x):\n if self.pooling == 'avg':\n x = tf.keras.layers.GlobalAveragePooling1D()(x)\n elif self.pooling == 'max':\n x = tf.keras.layers.GlobalMaxPooling1D()(x)\n x = tf.keras.layers.Flatten()(x)\n if self.dropout_rate:\n x = tf.keras.layers.Dropout(self.dropout_rate)(x)\n outputs = tf.keras.layers.Dense(self.output_nums, activation='linear')(x)\n if self.problem_type == 'Classification':\n outputs = tf.keras.layers.Dense(self.output_nums, activation='softmax')(x)\n\n return outputs\n\n def SEInception_ResNet_v1(self):\n inputs = tf.keras.Input((self.length, self.num_channel)) # The input tensor\n # Stem\n x = Conv_1D_Block(inputs, 32, 3, strides=2, padding='valid')\n x = Conv_1D_Block(x, 32, 3, padding='valid')\n x = Conv_1D_Block(x, 64, 3)\n x = tf.keras.layers.MaxPooling1D(3, strides=2)(x)\n x = Conv_1D_Block(x, 80, 1)\n x = Conv_1D_Block(x, 192, 3, padding='valid')\n x = Conv_1D_Block(x, 256, 3, strides=2, padding='valid')\n\n # 5x Inception ResNet A Blocks - 35 x 35 x 256\n for i in range(5):\n x = Inception_ResNet_Module_A(x, 32, 32, 32, 32, 32, 32, 256, i)\n x = SE_Block(x, int(np.shape(x)[-1]), self.ratio)\n\n aux_output_0 = []\n if self.auxilliary_outputs:\n # Auxilliary Output 0\n aux_pool = tf.keras.layers.AveragePooling1D(pool_size=5, strides=3)(x)\n aux_conv = Conv_1D_Block(aux_pool, 128, 1)\n aux_conv = Conv_1D_Block(aux_conv, 768, 5, padding='valid')\n aux_output_0 = self.MLP(aux_conv)\n\n x = Reduction_Block_A(x, 384, 192, 224, 256) # Reduction Block A: 17 x 17 x 768\n\n # 10x Inception ResNet B Blocks - 17 x 17 x 768\n for i in range(10):\n x = Inception_ResNet_Module_B(x, 128, 128, 128, 128, 896, i)\n x = SE_Block(x, int(np.shape(x)[-1]), self.ratio)\n\n aux_output_1 = []\n if self.auxilliary_outputs:\n # Auxilliary Output 1\n aux_pool = tf.keras.layers.AveragePooling1D(pool_size=5, strides=3, padding='valid')(x)\n aux_conv = Conv_1D_Block(aux_pool, 128, 1)\n aux_conv = Conv_1D_Block(aux_conv, 768, 5, padding='valid')\n aux_output_1 = self.MLP(aux_conv)\n\n x = Reduction_Block_B(x, 256, 384, 256, 256, 256, 256, 256) # Reduction Block B: 8 x 8 x 1280\n\n # 5x Inception ResNet C Blocks - 8 x 8 x 1280\n for i in range(5):\n x = Inception_ResNet_Module_C(x, 128, 192, 192, 192, 1792, i)\n x = SE_Block(x, int(np.shape(x)[-1]), self.ratio)\n\n # Final Dense MLP Layer for the outputs\n final_output = self.MLP(x)\n # Create model.\n model = tf.keras.Model(inputs, final_output, name='Inception_v4')\n if self.auxilliary_outputs:\n model = tf.keras.Model(inputs, outputs=[final_output, aux_output_0, aux_output_1], name='Inception_ResNet_v1')\n\n return model\n\n def SEInception_ResNet_v2(self):\n inputs = tf.keras.Input((self.length, self.num_channel)) # The input tensor\n # Stem\n x = Conv_1D_Block(inputs, 32, 3, strides=2, padding='valid')\n x = Conv_1D_Block(x, 32, 3, padding='valid')\n x = Conv_1D_Block(x, 64, 3)\n #\n branch1 = Conv_1D_Block(x, 96, 3, strides=2, padding='valid')\n branch2 = tf.keras.layers.MaxPooling1D(3, strides=2)(x)\n x = tf.keras.layers.concatenate([branch1, branch2], axis=-1)\n #\n branch1 = Conv_1D_Block(x, 64, 1)\n branch1 = Conv_1D_Block(branch1, 96, 3, padding='valid')\n branch2 = Conv_1D_Block(x, 64, 1)\n branch2 = Conv_1D_Block(branch2, 64, 7)\n branch2 = Conv_1D_Block(branch2, 96, 3, padding='valid')\n x = tf.keras.layers.concatenate([branch1, branch2], axis=-1)\n #\n branch1 = Conv_1D_Block(x, 192, 3, padding='valid')\n branch2 = tf.keras.layers.MaxPooling1D(3, strides=1)(x)\n x = tf.keras.layers.concatenate([branch1, branch2], axis=-1)\n\n # 5x Inception ResNet A Blocks - 35 x 35 x 256\n for i in range(10):\n x = Inception_ResNet_Module_A(x, 32, 32, 32, 32, 48, 64, 384, i)\n x = SE_Block(x, int(np.shape(x)[-1]), self.ratio)\n\n aux_output_0 = []\n if self.auxilliary_outputs:\n # Auxilliary Output 0\n aux_pool = tf.keras.layers.AveragePooling1D(pool_size=5, strides=3, padding='valid')(x)\n aux_conv = Conv_1D_Block(aux_pool, 96, 1)\n aux_output_0 = self.MLP(aux_conv)\n\n x = Reduction_Block_A(x, 384, 192, 224, 256) # Reduction Block A: 17 x 17 x 768\n\n # 10x Inception ResNet B Blocks - 17 x 17 x 768\n for i in range(20):\n x = Inception_ResNet_Module_B(x, 192, 128, 160, 192, 1024, i)\n x = SE_Block(x, int(np.shape(x)[-1]), self.ratio)\n\n aux_output_1 = []\n if self.auxilliary_outputs:\n # Auxilliary Output 1\n aux_pool = tf.keras.layers.AveragePooling1D(pool_size=5, strides=3, padding='valid')(x)\n aux_conv = Conv_1D_Block(aux_pool, 128, 1)\n aux_conv = Conv_1D_Block(aux_conv, 768, 5)\n aux_output_1 = self.MLP(aux_conv)\n\n x = Reduction_Block_B(x, 256, 384, 256, 288, 256, 288, 320) # Reduction Block B: 8 x 8 x 1280\n\n # 5x Inception ResNet C Blocks - 8 x 8 x 1280\n for i in range(10):\n x = Inception_ResNet_Module_C(x, 192, 192, 224, 256, 2016, i)\n x = SE_Block(x, int(np.shape(x)[-1]), self.ratio)\n\n # Final Dense MLP Layer for the outputs\n final_output = self.MLP(x)\n # Create model.\n model = tf.keras.Model(inputs, final_output)\n if self.auxilliary_outputs:\n model = tf.keras.Model(inputs, outputs=[final_output, aux_output_0, aux_output_1])\n\n return model\n\n\nif __name__ == '__main__':\n # Configurations\n length = 1024 # Length of each segment\n model_name = 'SEInceptionResNetV1' # DenseNet Models\n model_width = 64 # Width of the Initial Layer, subsequent layers start from here\n num_channel = 1 # Number of Input Channels in the Model\n problem_type = 'Regression' # Classification or Regression\n output_nums = 1 # Number of Class for Classification Problems, always '1' for Regression Problems\n reduction_ratio = 8 # Reduction Ratio or Cardinality for the Squeeze and Excite Block\n #\n Model = SEInception_ResNet(length, num_channel, model_width, ratio=reduction_ratio, problem_type=problem_type, output_nums=output_nums,\n pooling='avg', dropout_rate=False, auxilliary_outputs=False).SEInception_ResNet_v1()\n Model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.0003), loss=tf.keras.losses.MeanAbsoluteError(), metrics=tf.keras.metrics.MeanSquaredError())\n Model.summary()\n", "meta": {"hexsha": "6a540390a0bd8017d9405b93578eff58f1a96d99", "size": 14122, "ext": "py", "lang": "Python", "max_stars_repo_path": "Codes/SE_Inception_ResNet_1DCNN.py", "max_stars_repo_name": "Sakib1263/Inception-InceptionResNet-SEInception-SEInceptionResNet-1D-2D-Tensorflow-Keras", "max_stars_repo_head_hexsha": "022b1bd1ef70adbfebb8bfa751e7c4bf87296f87", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-03-27T13:24:29.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-27T13:24:29.000Z", "max_issues_repo_path": "Codes/SE_Inception_ResNet_1DCNN.py", "max_issues_repo_name": "Sakib1263/Inception-InceptionResNet-SEInception-SEInceptionResNet-1D-2D-Tensorflow-Keras", "max_issues_repo_head_hexsha": "022b1bd1ef70adbfebb8bfa751e7c4bf87296f87", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Codes/SE_Inception_ResNet_1DCNN.py", "max_forks_repo_name": "Sakib1263/Inception-InceptionResNet-SEInception-SEInceptionResNet-1D-2D-Tensorflow-Keras", "max_forks_repo_head_hexsha": "022b1bd1ef70adbfebb8bfa751e7c4bf87296f87", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.6898734177, "max_line_length": 162, "alphanum_fraction": 0.6768871265, "include": true, "reason": "import numpy", "num_tokens": 4192, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.546738151984614, "lm_q2_score": 0.3629692055196168, "lm_q1q2_score": 0.19844911265311882}} {"text": "# MIT License\n#\n# Copyright (c) 2016-2017 Anders Steen Christensen, Lars Andersen Bratholm\n#\n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# in the Software without restriction, including without limitation the rights\n# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n# copies of the Software, and to permit persons to whom the Software is\n# furnished to do so, subject to the following conditions:\n#\n# The above copyright notice and this permission notice shall be included in all\n# copies or substantial portions of the Software.\n#\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n# SOFTWARE.\n\nimport numpy as np\nimport copy\n\nfrom arad import ARAD\nfrom aras import ARAS\n\nfrom data import NUCLEAR_CHARGE\n\nfrom representations import fgenerate_coulomb_matrix\nfrom representations import fgenerate_unsorted_coulomb_matrix\nfrom representations import fgenerate_local_coulomb_matrix\nfrom representations import fgenerate_atomic_coulomb_matrix\n\nHOF_DFTB3 = dict()\nHOF_DFTB3[\"H\"] = -172.3145\nHOF_DFTB3[\"C\"] = -906.4342\nHOF_DFTB3[\"N\"] = -1327.2991\nHOF_DFTB3[\"O\"] = -1936.6161\nHOF_DFTB3[\"S\"] = -1453.3907\n\n\nclass Molecule(object):\n \"\"\" Implemented molecular descriptors:\n 1. Sorted Coulomb Matrix\n 2. Unsorted Coulomb Matrix\n 3. Sorted Coulomb Matrix Eigenvalues\n 4. Reduced Coulomb Matrix\n 5. Bag of Bonds\n\n Implemented local descriptors:\n 1. Local Coulomb Matrix\n 2. Atomic Coulomb Matrix\n 3. ARAD\n 4. ARAS\n\n Implemented periodic descriptors\n 1. ARAD\n 2. ARAS\n \"\"\"\n\n def __init__(self):\n self.natoms = -1\n self.energy = float(\"nan\")\n self.molid = -1\n self.name = None\n self.dftb3_energy = float(\"nan\")\n self.dftb3_hof = float(\"nan\")\n\n self.atomtypes = []\n self.nuclear_charges = []\n self.coordinates = []\n self.active_atoms = []\n self.unit_cell = None\n\n # Container for misc properties\n self.properties = []\n self.properties2 = []\n\n def generate_coulomb_matrix(self, size=23):\n self.descriptor = fgenerate_coulomb_matrix(self.nuclear_charges, \\\n self.coordinates, self.natoms, size)\n\n def generate_bob(self, size = 23, asize = {\"O\":3, \"C\":7, \"N\":3, \"H\":16, \"S\":1}):\n coulomb_matrix = fgenerate_unsorted_coulomb_matrix(self.nuclear_charges,\n self.coordinates, self.natoms, size)\n coulomb_matrix = vector_to_matrix(coulomb_matrix)\n self.descriptor = []\n self.atomtypes = np.asarray(self.atomtypes)\n for atom1, size1 in asize.items():\n pos1 = np.where(self.atomtypes == atom1)[0]\n feature_vector = np.zeros(size1)\n feature_vector[:pos1.size] = np.diag(coulomb_matrix)[pos1]\n feature_vector.sort()\n self.descriptor.append(feature_vector[:])\n for atom2, size2 in asize.items():\n if atom1 > atom2:\n continue\n if atom1 == atom2:\n size = size1*(size1-1)/2\n feature_vector = np.zeros(size)\n sub_matrix = coulomb_matrix[np.ix_(pos1,pos1)]\n feature_vector[:pos1.size*(pos1.size-1)/2] = sub_matrix[np.triu_indices(pos1.size, 1)]\n feature_vector.sort()\n self.descriptor.append(feature_vector[:])\n else:\n pos2 = np.where(self.atomtypes == atom2)[0]\n feature_vector = np.zeros(size1*size2)\n feature_vector[:pos1.size*pos2.size] = coulomb_matrix[np.ix_(pos1,pos2)].ravel()\n feature_vector.sort()\n self.descriptor.append(feature_vector[:])\n\n self.descriptor = np.concatenate(self.descriptor)\n\n def generate_eigenvalue_coulomb_matrix(self, size=23):\n coulomb_matrix = fgenerate_coulomb_matrix(self.nuclear_charges, \\\n self.coordinates, self.natoms, size)\n self.descriptor = np.linalg.eigh(vector_to_matrix(coulomb_matrix))[0]\n\n def generate_reduced_coulomb_matrix(self, size=23):\n coulomb_matrix = fgenerate_coulomb_matrix(self.nuclear_charges, \\\n self.coordinates, self.natoms, size)\n coulomb_matrix = vector_to_matrix(coulomb_matrix)\n self.descriptor = np.concatenate([np.diag(coulomb_matrix), coulomb_matrix[1:,0]])\n\n def generate_unsorted_coulomb_matrix(self, size=23):\n self.descriptor = fgenerate_unsorted_coulomb_matrix(self.nuclear_charges, \\\n self.coordinates, self.natoms, size)\n\n def generate_local_coulomb_matrix(self, calc=\"all\",size=23):\n self.local_descriptor = fgenerate_local_coulomb_matrix( \\\n self.nuclear_charges, self.coordinates, self.natoms, size)\n\n def generate_atomic_coulomb_matrix(self, size = 23, cutoff = 8.0):\n self.local_descriptor = fgenerate_atomic_coulomb_matrix( \\\n self.nuclear_charges, self.coordinates, self.natoms, size, cutoff)\n\n def generate_atomic_unsorted_coulomb_matrix(self, size = 23, cutoff = 8.0):\n self.local_descriptor = fgenerate_atomic_unsorted_coulomb_matrix( \\\n self.nuclear_charges, self.coordinates, self.natoms, size, cutoff)\n\n def generate_arad_descriptor(self, size=23):\n arad_object = ARAD(maxMolSize=size,maxAts=size)\n self.arad_descriptor = arad_object.describe(np.array(self.coordinates), \\\n np.array(self.nuclear_charges))\n\n assert (self.arad_descriptor).shape[0] == size, \"ERROR: Check ARAD descriptor size!\"\n assert (self.arad_descriptor).shape[2] == size, \"ERROR: Check ARAD descriptor size!\"\n\n def generate_arad_descriptor_periodic(self, size=23, unit_cell=None):\n\n if unit_cell is None:\n unit_cell = self.unit_cell\n\n arad_object = ARAD(maxMolSize=size,maxAts=size)\n self.arad_descriptor = arad_object.describe(np.array(self.coordinates), \\\n np.array(self.nuclear_charges), cell=unit_cell)\n\n assert (self.arad_descriptor).shape[0] == size, \"ERROR: Check ARAD descriptor size!\"\n assert (self.arad_descriptor).shape[2] == size, \"ERROR: Check ARAD descriptor size!\"\n\n def generate_aras_descriptor(self, size=23):\n aras_object = ARAS(maxMolSize=size,maxAts=size)\n self.aras_descriptor = aras_object.describe(np.array(self.coordinates), \\\n np.array(self.nuclear_charges))\n\n assert (self.aras_descriptor).shape[0] == size, \"ERROR: Check ARAS descriptor size!\"\n assert (self.aras_descriptor).shape[2] == size, \"ERROR: Check ARAS descriptor size!\"\n\n def read_xyz(self, filename):\n\n f = open(filename, \"r\")\n lines = f.readlines()\n f.close()\n\n self.natoms = int(lines[0])\n\n for line in lines[2:]:\n tokens = line.split()\n\n if len(tokens) < 4:\n break\n\n self.atomtypes.append(tokens[0])\n self.nuclear_charges.append(NUCLEAR_CHARGE[tokens[0]])\n\n x = float(tokens[1])\n y = float(tokens[2])\n z = float(tokens[3])\n\n self.coordinates.append(np.array([x, y, z]))\n\n self.coordinates = np.array(self.coordinates)\n\ndef get_lines(filename):\n\n f = open(filename, \"r\")\n lines = f.readlines()\n f.close()\n\n return lines\n\ndef parse_molecules(filename):\n\n lines = get_lines(filename)\n\n mols = []\n\n mol = Molecule()\n\n for line in lines:\n\n tokens = line.split()\n\n if len(tokens) == 1:\n\n if mol.natoms > 0:\n mols.append(mol)\n\n mol = Molecule()\n mol.natoms = int(tokens[0])\n\n if len(tokens) == 2:\n mol.molid = int(tokens[0])\n mol.energy = float(tokens[1])\n mol.dftb3_energy = parse_dft3_energy(mol.molid)\n\n\n if len(tokens) == 7:\n\n atom_type = tokens[0]\n mol.atomtypes.append(atom_type)\n mol.nuclear_charges.append(NUCLEAR_CHARGE[atom_type])\n x = float(tokens[4])\n y = float(tokens[5])\n z = float(tokens[6])\n\n mol.coordinates.append(np.array([x, y, z]))\n\n mol.dftb3_hof = 0.0\n mol.dftb3_hof += mol.dftb3_energy\n\n for atom in [\"H\", \"C\", \"N\", \"O\", \"S\"]:\n\n n = mol.atomtypes.count(atom)\n mol.dftb3_hof -= n * HOF_DFTB3[atom]\n\n mol.atomtypes = np.asarray(mol.atomtypes)\n mol.coordinates = np.asarray(mol.coordinates)\n mol.nuclear_charges = np.asarray(mol.nuclear_charges)\n\n return mols\n\ndef parse_dft3_energy(molid):\n\n filename = \"../logfiles/\" + str(molid) + \".log\"\n f = open(filename, \"r\")\n lines = f.readlines()\n f.close()\n\n energy = float(\"nan\")\n for line in lines:\n if \"Total Energy\" in line:\n tokens = line.split()\n energy = float(tokens[2]) * 627.51\n\n return energy\n\ndef vector_to_matrix(v):\n if not (np.sqrt(8*v.shape[0]+1) == int(np.sqrt(8*v.shape[0]+1))):\n print \"ERROR: Can not make a square matrix.\"\n exit(1)\n\n n = v.shape[0]\n l = (-1 + int(np.sqrt(8*n+1)))/2\n M = np.empty((l,l))\n\n index = 0\n for i in range(l):\n for j in range(l):\n if j > i:\n continue\n\n M[i,j] = v[index]\n M[j,i] = M[i,j]\n\n index += 1\n return M\n", "meta": {"hexsha": "48354efc09edb4e6a49876d6320e0a1381b58a23", "size": 9919, "ext": "py", "lang": "Python", "max_stars_repo_path": "fml/fml.py", "max_stars_repo_name": "larsbratholm/ml_clustering", "max_stars_repo_head_hexsha": "dec3386676f8b22054f18643b1ae7d3e44c65527", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "fml/fml.py", "max_issues_repo_name": "larsbratholm/ml_clustering", "max_issues_repo_head_hexsha": "dec3386676f8b22054f18643b1ae7d3e44c65527", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "fml/fml.py", "max_forks_repo_name": "larsbratholm/ml_clustering", "max_forks_repo_head_hexsha": "dec3386676f8b22054f18643b1ae7d3e44c65527", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.2034482759, "max_line_length": 106, "alphanum_fraction": 0.6256679101, "include": true, "reason": "import numpy", "num_tokens": 2443, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5467381372136563, "lm_q2_score": 0.3629691917376783, "lm_q1q2_score": 0.19844909975660466}} {"text": "\"\"\"Bader calculation methods.\n\nThis module is has __contains__ due to @njit hiding the names of the functions.\nAll functions in this module should have the same arguments as to help be called\nby bader_calc in the thread_handlers module.\n\"\"\"\nimport numpy as np\nfrom numba import njit\n\nfrom .utils import array_assign, volume_extend\n\n__contains__ = ['ongrid', 'neargrid']\n\n\n@njit(cache=True, nogil=True)\ndef ongrid(density, volumes, idx, dist_mat, T_grad, i_c):\n \"\"\"Parallel implementation of the ongrid Bader maximum searching.\n\n The ongrid method for Bader maximum searching based on W. Tang, E. Sanville,\n and G. Henkelman A grid-based Bader analysis algorithm without lattice bias,\n J. Phys.: Condens. Matter 21, 084204 (2009). Can be passed a volumes array\n of smaller size than density to reduce the active area for parallelisation\n purposes.\n\n args:\n density: read-only array of reference charge density\n volumes: array same shape as density to store bader volume indicators\n idx: the offset of the origin for the chunk (threading)\n dist_mat: rank-3 tensor of distances for moving in index direction\n T_grad: unused, kept for argument matching with neargrid method\n i_c: index counter for tqdm bar.\n returns:\n volumes: the updated volumes array\n bader_max: array containing location of Bader maxima\n edge_max: array containing location of edge crossings\n \"\"\"\n # get shapes\n vol_shape = np.zeros(3, dtype=np.int64)\n vx, vy, vz = volumes.shape\n # thread stuff\n extend = np.zeros(3, dtype=np.int64)\n positive_len = np.zeros(3, dtype=np.int64)\n new_positive_len = np.zeros(3, dtype=np.int64)\n negative_len = np.zeros(3, dtype=np.int64)\n new_negative_len = np.zeros(3, dtype=np.int64)\n for j in range(3):\n vol_shape[j] = volumes.shape[j]\n extend[j] = volumes.shape[j]\n positive_len[j] = volumes.shape[j]\n new_positive_len[j] = volumes.shape[j]\n # init array length counters\n bader_num = 0\n edge_num = 0\n path_num = 0\n # init arrays for bader maxima, edge crossings and current path\n # idx is type set for the maximum int that can be stored here\n bader_max = np.zeros((vx, 3), dtype=np.int64)\n edge_max = np.zeros((vx, 3), dtype=np.int64)\n path = np.zeros((vx, 3), dtype=np.int64)\n # init position arrays\n p = np.zeros(3, dtype=np.int64)\n pt = np.zeros(3, dtype=np.int64)\n pd = np.zeros(3, dtype=np.int64)\n pv = np.zeros(3, dtype=np.int64)\n # keep track of the lead index for filling the progress bar\n lead_idx = 0\n # for index in range of the volume size\n for i in np.ndindex(vx, vy, vz):\n if i[0] != lead_idx:\n lead_idx += 1\n i_c[0] += 1\n # skip if volume has been visited\n if volumes[i] != 0:\n continue\n # init p for current point, pv for next point in volume space\n # pd for next point in density space\n for j in range(3):\n p[j] = i[j] + idx[j]\n pv[j] = i[j]\n pd[j] = p[j]\n path[0][j] = pv[j]\n # path size is now 1 and max_val is current point\n path_num = 1\n max_val = density[p[0], p[1], p[2]]\n ctr_val = max_val\n while True:\n for ix in range(-1, 2):\n # shift p_x into density space and adjust for pbc\n pt[0] = p[0] + ix\n if pt[0] < 0:\n pt[0] += density.shape[0]\n elif pt[0] >= density.shape[0]:\n pt[0] -= density.shape[0]\n for iy in range(-1, 2):\n # shift p_y into density space and adjust for pbc\n pt[1] = p[1] + iy\n if pt[1] < 0:\n pt[1] += density.shape[1]\n elif pt[1] >= density.shape[1]:\n pt[1] -= density.shape[1]\n for iz in range(-1, 2):\n # shift p_z into density space and adjust for pbc\n pt[2] = p[2] + iz\n if pt[2] < 0:\n pt[2] += density.shape[2]\n elif pt[2] >= density.shape[2]:\n pt[2] -= density.shape[2]\n # check for new maxima, save density and index\n pd_tmp = density[pt[0], pt[1], pt[2]]\n pd_val = (pd_tmp - ctr_val) * dist_mat[ix, iy, iz]\n pd_val += ctr_val\n if pd_val > max_val:\n max_val = pd_val\n new_density = pd_tmp\n for j in range(3):\n pd[j] = pt[j]\n pv[j] = pd[j] - idx[j]\n # check if new pv is same as p or outside of volume space\n break_flag = True\n extend_flag = False\n for j in range(3):\n # outside volume to left\n if pv[j] < negative_len[j]:\n upper = pv[j] + density.shape[j] - positive_len[j] + 1\n lower = (pv[j] - negative_len[j]) * -1\n if upper <= 0:\n pv[j] += density.shape[j]\n elif upper > lower:\n new_negative_len[j] -= vol_shape[j] // 2\n extend[j] += vol_shape[j] // 2\n extend_flag = True\n else:\n new_positive_len[j] += vol_shape[j] // 2\n extend[j] += vol_shape[j] // 2\n pv[j] += density.shape[j]\n extend_flag = True\n elif pv[j] >= positive_len[j]:\n upper = pv[j] - positive_len[j] + 1\n lower = (pv[j] - density.shape[j] - negative_len[j]) * -1\n if lower <= 0:\n pv[j] -= density.shape[j]\n elif upper > lower:\n new_negative_len[j] -= vol_shape[j] // 2\n extend[j] += vol_shape[j] // 2\n pv[j] -= density.shape[j]\n extend_flag = True\n else:\n new_positive_len[j] += vol_shape[j] // 2\n extend[j] += vol_shape[j] // 2\n extend_flag = True\n if break_flag and pd[j] != p[j]:\n break_flag = False\n if extend_flag:\n for j in range(3):\n if extend[j] > density.shape[j]:\n extend[j] = density.shape[j]\n volumes = volume_extend(volumes, positive_len, extend)\n for j in range(3):\n if volumes.shape[j] == density.shape[j]:\n positive_len[j] = density.shape[j]\n negative_len[j] = 0\n else:\n positive_len[j] = new_positive_len[j]\n negative_len[j] = new_negative_len[j]\n # if known break without updating p\n if volumes[pv[0], pv[1], pv[2]] != 0:\n vol_num = volumes[pv[0], pv[1], pv[2]]\n break\n elif break_flag:\n # store maxima/edge in density space\n vol_num = 0\n for k in range(3):\n if pv[k] >= vol_shape[k]:\n vol_num = -2\n elif pv[k] < 0:\n vol_num = -2\n break\n # no break condition so add point to path\n else:\n if path_num >= path.shape[0]:\n path = array_assign(\n path, path.shape[0], path.shape[0] + vx)\n for j in range(3):\n p[j] = pd[j]\n path[path_num][j] = pv[j]\n path_num += 1\n # set new density values for max and control\n ctr_val = new_density\n max_val = new_density\n # if the volume is empty then create a new one\n if vol_num == -2:\n if edge_num >= edge_max.shape[0]:\n edge_max = array_assign(edge_max, edge_max.shape[0],\n edge_max.shape[0] + vx)\n # add max to bader_max list add one to len counter\n for j in range(3):\n edge_max[edge_num][j] = pd[j]\n edge_num += 1\n vol_num = -2 - edge_num # -1 is vacuum, -2 is maxima flag\n # we are at a maxima\n elif vol_num == 0:\n if bader_num >= bader_max.shape[0]:\n bader_max = array_assign(bader_max, bader_max.shape[0],\n bader_max.shape[0] + vx)\n # add max to bader_max list add one to len counter\n for j in range(3):\n bader_max[bader_num][j] = pd[j]\n bader_num += 1\n vol_num = bader_num\n # assign bader_num to volumes\n for j in range(path_num):\n for k in range(3):\n pv[k] = path[j][k]\n volumes[pv[0], pv[1], pv[2]] = vol_num\n # reduce size of bader_max and edge_max arrays to fit contents\n bader_max = array_assign(bader_max, bader_num, bader_num)\n edge_max = array_assign(edge_max, edge_num, edge_num)\n i_c[0] += 1\n return volumes, bader_max, edge_max\n\n\n@njit(cache=True, nogil=True)\ndef neargrid(density, volumes, idx, dist_mat, T_grad, i_c):\n \"\"\"Parallel implementation of the neargrid Bader maximum searching.\n\n The neargrid method for Bader maximum searching based on W. Tang,\n E. Sanville, and G. Henkelman A grid-based Bader analysis algorithm without\n lattice bias, J. Phys.: Condens. Matter 21, 084204 (2009). Can be passed a\n volumes array of smaller size than density to reduce the active area for\n parallelisation purposes.\n\n args:\n density: read-only array of reference charge density\n volumes: array same shape as density to store bader volume indicators\n idx: the offset of the origin for the chunk (threading)\n dist_mat: rank-3 tensor of distances for moving in index direction\n T_grad: transform matrix for converting gradient to direct basis\n i_c: index counter for tqdm bar\n returns:\n volumes: the updated volumes array.\n bader_max: array containing location of Bader maxima.\n edge_max: array containing location of edge crossings.\n \"\"\"\n # get shapes\n vol_shape = np.zeros(3, dtype=np.int64)\n vx, vy, vz = volumes.shape\n # thread stuff\n extend = np.zeros(3, dtype=np.int64)\n positive_len = np.zeros(3, dtype=np.int64)\n new_positive_len = np.zeros(3, dtype=np.int64)\n negative_len = np.zeros(3, dtype=np.int64)\n new_negative_len = np.zeros(3, dtype=np.int64)\n for j in range(3):\n vol_shape[j] = volumes.shape[j]\n extend[j] = volumes.shape[j]\n positive_len[j] = volumes.shape[j]\n new_positive_len[j] = volumes.shape[j]\n # init array length counters\n bader_num = 0\n edge_num = 0\n path_num = 0\n # init arrays for bader maxima, edge crossings and current path\n # idx is type set for the maximum int that can be stored here\n bader_max = np.zeros((vx, 3), dtype=np.int64)\n edge_max = np.zeros((vx, 3), dtype=np.int64)\n path = np.zeros((vx, 3), dtype=np.int64)\n # init position arrays\n p = np.zeros(3, dtype=np.int64)\n pd = np.zeros(3, dtype=np.int64)\n pv = np.zeros(3, dtype=np.int64)\n pt = np.zeros(3, dtype=np.int64)\n dr = np.zeros(3, dtype=np.float64)\n density_t = np.zeros(2, dtype=np.float64)\n grad = np.zeros(3, dtype=np.float64)\n grad_dir = np.zeros(3, dtype=np.float64)\n max_grad = np.float64(0.)\n known = np.zeros((vx, vy, vz), dtype=np.int8)\n # keep track of the lead index for filling the progress bar\n lead_idx = 0\n # for index in range of the volume size\n for i in np.ndindex(vx, vy, vz):\n if i[0] != lead_idx:\n lead_idx += 1\n i_c[0] += 1\n # skip if volume has been visited\n if volumes[i] == -1:\n continue\n elif known[i] == 2:\n continue\n # we've visited the point\n known[i] = 1\n # init p for current point, pv for next point in volume space\n # pd for next point in density space\n for j in range(3):\n p[j] = i[j] + idx[j]\n pd[j] = p[j]\n path[0][j] = i[j]\n dr[j] = 0.\n # path size is now 1 and max_val is current point\n path_num = 1\n while True:\n max_val = density[p[0], p[1], p[2]]\n # calculate density of heptacube around point\n for j in range(3):\n # convert to density space\n pd[j] += 1\n # wrap in pbc\n if pd[j] < 0:\n pd[j] += density.shape[j]\n elif pd[j] >= density.shape[j]:\n pd[j] -= density.shape[j]\n # store density at p+1\n density_t[0] = density[pd[0], pd[1], pd[2]]\n pd[j] -= 2\n # rewrap\n if pd[j] < 0:\n pd[j] += density.shape[j]\n elif pd[j] >= density.shape[j]:\n pd[j] -= density.shape[j]\n # store density of p-1\n density_t[1] = density[pd[0], pd[1], pd[2]]\n # if p is max in this axis grad is zero\n # else grad is density[p+1] - density[p-1] / 2\n if density_t[0] <= max_val >= density_t[1]:\n grad[j] = 0.\n else:\n grad[j] = (density_t[0] - density_t[1]) / 2.\n # reset current pd\n pd[j] = p[j]\n # convert grad to direct coords\n max_grad = 0.\n for j in range(3):\n grad_dir[j] = ((T_grad[j, 0] * grad[0])\n + (T_grad[j, 1] * grad[1])\n + (T_grad[j, 2] * grad[2]))\n if grad_dir[j] > max_grad:\n max_grad = grad_dir[j]\n elif -grad_dir[j] > max_grad:\n max_grad = -grad_dir[j]\n # max grad is zero then do ongrid step\n if max_grad < 1E-14:\n for j in range(3):\n pv[j] = pd[j] - idx[j]\n else:\n for j in range(3):\n grad_dir[j] /= max_grad\n if grad_dir[j] > 0:\n int_grad = np.int64(grad_dir[j] + .5)\n else:\n int_grad = np.int64(grad_dir[j] - .5)\n pd[j] = p[j] + int_grad\n dr[j] += grad_dir[j] - int_grad\n if dr[j] > 0:\n int_dr = np.int64(dr[j] + .5)\n else:\n int_dr = np.int64(dr[j] - .5)\n pd[j] += int_dr\n dr[j] -= int_dr\n if pd[j] >= density.shape[j]:\n pd[j] -= density.shape[j]\n elif pd[j] < 0:\n pd[j] += density.shape[j]\n pv[j] = pd[j] - idx[j]\n # check if pv is outside of volume space and either extend volume\n # space or wrap back in\n extend_flag = False\n for j in range(3):\n # outside volume to left\n if pv[j] < negative_len[j]:\n upper = pv[j] + density.shape[j] - positive_len[j] + 1\n lower = (pv[j] - negative_len[j]) * -1\n if upper <= 0:\n pv[j] += density.shape[j]\n elif upper > lower:\n new_negative_len[j] -= vol_shape[j] // 2\n extend[j] += vol_shape[j] // 2\n extend_flag = True\n else:\n new_positive_len[j] += vol_shape[j] // 2\n extend[j] += vol_shape[j] // 2\n pv[j] += density.shape[j]\n extend_flag = True\n elif pv[j] >= positive_len[j]:\n upper = pv[j] - positive_len[j] + 1\n lower = (pv[j] - density.shape[j] - negative_len[j]) * -1\n if lower <= 0:\n pv[j] -= density.shape[j]\n elif upper > lower:\n new_negative_len[j] -= vol_shape[j] // 2\n extend[j] += vol_shape[j] // 2\n pv[j] -= density.shape[j]\n extend_flag = True\n else:\n new_positive_len[j] += vol_shape[j] // 2\n extend[j] += vol_shape[j] // 2\n extend_flag = True\n if extend_flag:\n for j in range(3):\n if extend[j] > density.shape[j]:\n extend[j] = density.shape[j]\n volumes = volume_extend(volumes, positive_len, extend)\n known = volume_extend(known, positive_len, extend)\n for j in range(3):\n if volumes.shape[j] == density.shape[j]:\n positive_len[j] = density.shape[j]\n negative_len[j] = 0\n else:\n positive_len[j] = new_positive_len[j]\n negative_len[j] = new_negative_len[j]\n # already been here this path\n if known[pv[0], pv[1], pv[2]] == 1:\n for j in range(3):\n dr[j] = 0.\n pd[j] = p[j]\n pv[j] = p[j] - idx[j]\n max_val = density[p[0], p[1], p[2]]\n ctr_val = max_val\n for ix in range(-1, 2):\n # shift p_x into density space and adjust for pbc\n pt[0] = p[0] + ix\n if pt[0] < 0:\n pt[0] += density.shape[0]\n elif pt[0] >= density.shape[0]:\n pt[0] -= density.shape[0]\n for iy in range(-1, 2):\n # shift p_y into density space and adjust for pbc\n pt[1] = p[1] + iy\n if pt[1] < 0:\n pt[1] += density.shape[1]\n elif pt[1] >= density.shape[1]:\n pt[1] -= density.shape[1]\n for iz in range(-1, 2):\n # shift p_z into density space and adjust for pbc\n pt[2] = p[2] + iz\n if pt[2] < 0:\n pt[2] += density.shape[2]\n elif pt[2] >= density.shape[2]:\n pt[2] -= density.shape[2]\n # check for new maxima, save density and index\n pd_val = density[pt[0], pt[1], pt[2]]\n pd_val = (pd_val - ctr_val) * dist_mat[ix, iy, iz]\n pd_val += ctr_val\n if pd_val > max_val:\n max_val = pd_val\n for j in range(3):\n pd[j] = pt[j]\n pv[j] = pd[j] - idx[j]\n extend_flag = False\n break_flag = True\n for j in range(3):\n # outside volume to left\n if pv[j] < negative_len[j]:\n upper = pv[j] + density.shape[j] - positive_len[j] + 1\n lower = (pv[j] - negative_len[j]) * -1\n if upper <= 0:\n pv[j] += density.shape[j]\n elif upper > lower:\n new_negative_len[j] -= vol_shape[j] // 2\n extend[j] += vol_shape[j] // 2\n extend_flag = True\n else:\n new_positive_len[j] += vol_shape[j] // 2\n extend[j] += vol_shape[j] // 2\n pv[j] += density.shape[j]\n extend_flag = True\n elif pv[j] >= positive_len[j]:\n upper = pv[j] - positive_len[j] + 1\n lower = (pv[j] - density.shape[j] - negative_len[j])\n lower *= -1\n if lower <= 0:\n pv[j] -= density.shape[j]\n elif upper > lower:\n new_negative_len[j] -= vol_shape[j] // 2\n extend[j] += vol_shape[j] // 2\n pv[j] -= density.shape[j]\n extend_flag = True\n else:\n new_positive_len[j] += vol_shape[j] // 2\n extend[j] += vol_shape[j] // 2\n extend_flag = True\n if break_flag and pd[j] != p[j]:\n break_flag = False\n if extend_flag:\n for j in range(3):\n if extend[j] > density.shape[j]:\n extend[j] = density.shape[j]\n volumes = volume_extend(volumes, positive_len, extend)\n known = volume_extend(known, positive_len, extend)\n for j in range(3):\n if volumes.shape[j] == density.shape[j]:\n positive_len[j] = density.shape[j]\n negative_len[j] = 0\n else:\n positive_len[j] = new_positive_len[j]\n negative_len[j] = new_negative_len[j]\n if break_flag:\n # store maxima/edge in density space\n vol_num = 0\n if volumes[pv[0], pv[1], pv[2]] != 0:\n vol_num = volumes[pv[0], pv[1], pv[2]]\n else:\n for k in range(3):\n if pv[k] >= vol_shape[k]:\n vol_num = -2\n elif pv[k] < 0:\n vol_num = -2\n break\n # if known break without updating p\n if known[pv[0], pv[1], pv[2]] == 2:\n vol_num = volumes[pv[0], pv[1], pv[2]]\n break\n # no break condition so add point to path\n else:\n if path_num >= path.shape[0]:\n path = array_assign(\n path, path.shape[0], path.shape[0] + vx)\n for j in range(3):\n p[j] = pd[j]\n path[path_num][j] = pv[j]\n path_num += 1\n known[pv[0], pv[1], pv[2]] = 1\n # if the volume is empty then create a new one\n if vol_num == -2:\n if edge_num >= edge_max.shape[0]:\n edge_max = array_assign(edge_max, edge_max.shape[0],\n edge_max.shape[0] + vx)\n # add max to bader_max list add one to len counter\n for j in range(3):\n edge_max[edge_num][j] = pd[j]\n edge_num += 1\n vol_num = -2 - edge_num # -1 is vacuum, -2 is maxima flag\n # we are at a maxima\n elif vol_num == 0:\n if bader_num >= bader_max.shape[0]:\n bader_max = array_assign(bader_max, bader_max.shape[0],\n bader_max.shape[0] + vx)\n # add max to bader_max list add one to len counter\n for j in range(3):\n bader_max[bader_num][j] = pd[j]\n bader_num += 1\n vol_num = bader_num\n # assign bader_num to volumes and adjust known\n for j in range(path_num):\n for k in range(3):\n p[k] = path[j][k]\n pv[k] = p[k]\n pt[k] = p[k]\n volumes[p[0], p[1], p[2]] = vol_num\n # this should never == 2 ?\n if known[p[0], p[1], p[2]] != 2:\n known[p[0], p[1], p[2]] = 0\n for k in range(3):\n pv[k] += 1\n pt[k] += 1\n # pv[k] check is in bounds, if not we havent been there so skip\n if negative_len[k] <= pv[k] < positive_len[k]:\n known_flag = True\n vol_temp = volumes[pv[0], pv[1], pv[2]]\n if not (-2 < vol_temp < 1):\n for h in range(3):\n pt[h] += 1\n if not (negative_len[h] <= pt[h] < positive_len[h]):\n known_flag = False\n break\n elif vol_temp != volumes[pt[0], pt[1], pt[2]]:\n known_flag = False\n break\n pt[h] -= 2\n if not (negative_len[h] <= pt[h] < positive_len[h]):\n known_flag = False\n break\n elif vol_temp != volumes[pt[0], pt[1], pt[2]]:\n known_flag = False\n break\n pt[h] += 1\n if known_flag:\n known[pv[0], pv[1], pv[2]] = 2\n pv[k] -= 2\n for h in range(3):\n pt[h] = pv[h]\n if negative_len[k] <= pv[k] < positive_len[k]:\n # pv[k] check in bounds, if not we havent been there so skip\n known_flag = True\n vol_temp = volumes[pv[0], pv[1], pv[2]]\n if not (-2 < vol_temp < 1):\n for h in range(3):\n pt[h] += 1\n if not (negative_len[h] <= pt[h] < positive_len[h]):\n known_flag = False\n break\n elif vol_temp != volumes[pt[0], pt[1], pt[2]]:\n known_flag = False\n break\n pt[h] -= 2\n if not (negative_len[h] <= pt[h] < positive_len[h]):\n known_flag = False\n break\n elif vol_temp != volumes[pt[0], pt[1], pt[2]]:\n known_flag = False\n break\n pt[h] += 1\n if known_flag:\n known[pv[0], pv[1], pv[2]] = 2\n pv[k] += 1\n for h in range(3):\n pt[h] = pv[h]\n # reduce size of bader_max and edge_max arrays to fit contents\n bader_max = array_assign(bader_max, bader_num, bader_num)\n edge_max = array_assign(edge_max, edge_num, edge_num)\n i_c[0] += 1\n return volumes, bader_max, edge_max\n", "meta": {"hexsha": "5af74e1b4af36ab088c2df907efc0cc4d53122da", "size": 27471, "ext": "py", "lang": "Python", "max_stars_repo_path": "pybader/methods.py", "max_stars_repo_name": "adam-kerrigan/pybader", "max_stars_repo_head_hexsha": "1d675ae69ab64fe336b936b00990681e01258031", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-04-30T20:15:51.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-20T18:24:23.000Z", "max_issues_repo_path": "pybader/methods.py", "max_issues_repo_name": "kerrigoon/pybader", "max_issues_repo_head_hexsha": "1d675ae69ab64fe336b936b00990681e01258031", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pybader/methods.py", "max_forks_repo_name": "kerrigoon/pybader", "max_forks_repo_head_hexsha": "1d675ae69ab64fe336b936b00990681e01258031", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-03-18T13:39:53.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-18T13:39:53.000Z", "avg_line_length": 44.887254902, "max_line_length": 80, "alphanum_fraction": 0.4403552838, "include": true, "reason": "import numpy,from numba", "num_tokens": 6374, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5926665999540698, "lm_q2_score": 0.33458945452352534, "lm_q1q2_score": 0.19829999439294463}} {"text": "import numpy as np\nimport ctypes\nfrom ctypes import POINTER, pointer, c_int, c_long, c_char, c_char_p, c_double\n\nimport larch\nfrom larch.larchlib import get_dll\nfrom larch.xray import atomic_mass\n\nF8LIB = None\n\nFEFF_maxpts = 150 # nex\nFEFF_maxpot = 11 # nphx\nFEFF_maxleg = 9 # legtot\nBOHR = 0.52917721067\nRYDBERG = 13.605698\n\ndef with_phase_file(fcn):\n \"\"\"decorator to ensure that the wrapped function either\n has a non-None 'phase_file' argument or that that\n self.phase_file is not None\n \"\"\"\n errmsg = \"function '%s' needs a non-None phase_file\"\n def wrapper(*args, **keywords):\n \"needs phase_file\"\n phase_file = keywords.get('phase_file', None)\n if phase_file is None:\n phase_file = getattr(args[0], 'phase_file', None)\n if phase_file is None:\n raise AttributeError(errmsg % fcn.__name__)\n else:\n setattr(args[0], 'phase_file', phase_file)\n # raise Warning(errmsg % fcn.__name__)\n return fcn(*args, **keywords)\n wrapper.__doc__ = fcn.__doc__\n wrapper.__name__ = fcn.__name__\n wrapper.__filename__ = fcn.__code__.co_filename\n wrapper.__dict__.update(fcn.__dict__)\n return wrapper\n\nclass Feff8L_XAFSPath(object):\n \"\"\"Feff8 Scattering Path calculation\n\n A calculation requires a Potentials and Phase Shift calculation\n in PAD format from Feff8L, and a list of scattering paths\n\n Usage:\n ------\n # create path\n path = Feff8L_XAFSPath(phase_file='phase.pad')\n\n # list 'ipot' and labels for absorber, scatterers\n path.list_scatterers()\n\n # set coords for absorbing atom\n path.set_absorber(x=0., y=0., z=0.)\n\n # add scattering atom\n path.add_scatterer(x=1.5, y=1.5, z=1.5, ipot=1)\n\n # calculate basic (unaltered) XAFS contributions\n path.calcuate_xafs()\n\n \"\"\"\n def __init__(self, phase_file=None, title=''):\n global F8LIB\n if F8LIB is None:\n try:\n F8LIB = get_dll('feff8lpath')\n except:\n pass\n self.reset(phase_file=phase_file, title=title)\n\n def reset(self, phase_file=None, title=''):\n \"\"\"reset all path data\"\"\"\n self.phase_file = None\n if phase_file is not None:\n self.phase_file = phase_file\n self.index = 9999\n self.degen = 1.\n self.nnnn_out = False\n self.json_out = False\n self.verbose = False\n self.ipol = 0\n self.ellip = 0.\n self.nepts = 0\n self.genfmt_order = 2\n self.version= \"\"\n self.exch = \"\"\n self.title = title\n self.filename = \"%s_%s\" % (self.phase_file, self.title)\n self.rs_int = 0.\n self.vint = 0.\n self.mu = 0.\n self.edge = 0.\n self.kf = 0.\n self.rnorman = 0.\n self.gam_ch = 0.\n self.nepts = FEFF_maxpts\n\n dargs = dict(dtype=np.float64, order='F')\n largs = dict(dtype=np.int32, order='F')\n\n self.evec = np.zeros(3, **dargs)\n self.xivec = np.zeros(3, **dargs)\n self.ipot = np.zeros(1+FEFF_maxleg, **largs)\n self.beta = np.zeros(1+FEFF_maxleg, **dargs)\n self.eta = np.zeros(2+FEFF_maxleg, **dargs)\n self.ri = np.zeros(FEFF_maxleg, **dargs)\n self.rat = np.zeros((3, 2+FEFF_maxleg), **dargs)\n self.iz = np.zeros(1+FEFF_maxpot, **largs)\n self.k = np.zeros(FEFF_maxpts, **dargs)\n self.real_phc = np.zeros(FEFF_maxpts, **dargs)\n self.mag_feff = np.zeros(FEFF_maxpts, **dargs)\n self.pha_feff = np.zeros(FEFF_maxpts, **dargs)\n self.red_fact = np.zeros(FEFF_maxpts, **dargs)\n self.lam = np.zeros(FEFF_maxpts, **dargs)\n self.rep = np.zeros(FEFF_maxpts, **dargs)\n self.nleg = 1\n self.atoms = []\n\n if self.phase_file is not None:\n self.read_atoms()\n self.set_absorber()\n\n @with_phase_file\n def read_atoms(self):\n \"\"\"read atoms ipot, iz, symbol\"\"\"\n self.atoms = []\n with open(self.phase_file,'r') as fh:\n line1_words = fh.readline().strip().split()\n text = fh.readlines()\n npots = int(line1_words[4])\n for line in text[4:]:\n if not line.startswith('$'):\n words = line.split()\n self.atoms.append((int(words[1]), words[2]))\n if len(self.atoms) > npots:\n break\n\n @with_phase_file\n def list_atoms(self):\n \"\"\"list Feff Potentials atoms ('ipots') fo phase file\"\"\"\n if len(self.atoms) < 1:\n self.read_atoms()\n out = [\"# Potential Z Symbol\"]\n for ipot, atom in enumerate(self.atoms):\n out.append(\" %2i %3i %s\" % (ipot, atom[0], atom[1]))\n return \"\\n\".join(out)\n\n @with_phase_file\n def set_absorber(self, x=0., y=0., z=0., phase_file=None):\n \"\"\"set coordinates for absorbing atom ('ipot'=0)\"\"\"\n self.rat[0, 0] = x\n self.rat[1, 0] = y\n self.rat[2, 0] = z\n self.rat[0, self.nleg] = self.rat[0, 0]\n self.rat[1, self.nleg] = self.rat[1, 0]\n self.rat[2, self.nleg] = self.rat[2, 0]\n self.ipot[self.nleg] = self.ipot[0]\n\n @with_phase_file\n def add_scatterer(self, x=0., y=0., z=0., ipot=1, phase_file=None):\n self.rat[0, self.nleg] = x\n self.rat[1, self.nleg] = y\n self.rat[2, self.nleg] = z\n self.ipot[self.nleg] = ipot\n self.nleg += 1\n # set final atom coords to same as absorber\n self.rat[0, self.nleg] = self.rat[0, 0]\n self.rat[1, self.nleg] = self.rat[1, 0]\n self.rat[2, self.nleg] = self.rat[2, 0]\n self.ipot[self.nleg] = self.ipot[0]\n\n @with_phase_file\n def calculate_xafs(self, phase_file=None):\n if F8LIB is None:\n raise ValueError(\"Feff8 Dynamic library not found\")\n\n if len(self.atoms) < 1:\n self.read_atoms()\n\n class args:\n pass\n\n # strings / char*. Note fixed length to match Fortran\n args.phase_file = (self.phase_file + ' '*256)[:256]\n args.exch_label = ' '*8\n args.genfmt_version = ' '*30\n\n # integers, including booleans\n for attr in ('index', 'nleg', 'genfmt_order', 'ipol', 'nnnn_out',\n 'json_out', 'verbose', 'nepts'):\n setattr(args, attr, pointer(c_long(int(getattr(self, attr)))))\n\n # doubles\n for attr in ('degen', 'rs_int', 'vint', 'mu', 'edge', 'kf', 'rnorman',\n 'gam_ch', 'ellip'):\n setattr(args, attr, pointer(c_double(getattr(self, attr))))\n\n # integer arrays\n args.ipot = self.ipot.ctypes.data_as(POINTER(self.ipot.size*c_int))\n args.iz = self.iz.ctypes.data_as(POINTER(self.iz.size*c_int))\n\n # double arrays\n # print(\" Rat 0 \", self.rat)\n for attr in ('evec', 'xivec', 'ri', 'beta', 'eta',\n 'k', 'real_phc', 'mag_feff', 'pha_feff',\n 'red_fact', 'lam', 'rep'):\n arr = getattr(self, attr)\n cdata = arr.ctypes.data_as(POINTER(arr.size*c_double))\n setattr(args, attr, cdata)\n # handle rat (in atomic units)\n rat_atomic = self.rat/BOHR\n args.rat = (rat_atomic).ctypes.data_as(POINTER(rat_atomic.size*c_double))\n\n onepath = F8LIB.onepath_\n # print(\" Calc with onepath \", onepath, rat_atomic)\n # print(\" args rat = \", args.rat.contents[:])\n x = onepath(args.phase_file, args.index, args.nleg, args.degen,\n args.genfmt_order, args.exch_label, args.rs_int, args.vint,\n args.mu, args.edge, args.kf, args.rnorman,\n args.gam_ch, args.genfmt_version, args.ipot, args.rat,\n args.iz, args.ipol, args.evec, args.ellip, args.xivec,\n args.nnnn_out, args.json_out, args.verbose, args.ri,\n args.beta, args.eta, args.nepts, args.k,\n args.real_phc, args.mag_feff, args.pha_feff,\n args.red_fact, args.lam, args.rep)\n\n self.exch = args.exch_label.strip()\n self.version = args.genfmt_version.strip()\n # print(\" Calc with onepath done\")\n # unpack integers/floats\n for attr in ('index', 'nleg', 'genfmt_order', 'degen', 'rs_int',\n 'vint', 'mu', 'edge', 'kf', 'rnorman', 'gam_ch',\n 'ipol', 'ellip', 'nnnn_out', 'json_out', 'verbose',\n 'nepts'):\n setattr(self, attr, getattr(args, attr).contents.value)\n\n # some data needs recasting, reformatting\n self.mu *= (2*RYDBERG)\n self.nnnn_out = bool(self.nnnn_out)\n self.json_out = bool(self.json_out)\n self.verbose = bool(self.verbose)\n\n # unpck energies\n for attr in ('evec', 'xivec'):\n cdata = getattr(args, attr).contents[:]\n setattr(self, attr, np.array(cdata))\n\n nleg = self.nleg\n nepts = self.nepts\n\n # arrays of length 'nepts'\n for attr in ('k', 'real_phc', 'mag_feff', 'pha_feff',\n 'red_fact', 'lam', 'rep'):\n cdata = getattr(args, attr).contents[:nepts]\n setattr(self, attr, np.array(cdata))\n self.pha = self.real_phc + self.pha_feff\n self.amp = self.red_fact * self.mag_feff\n\n # unpack arrays of length 'nleg':\n for attr in ('ipot', 'beta', 'eta', 'ri'):\n cdata = getattr(args, attr).contents[:]\n setattr(self, attr, np.array(cdata))\n\n # rat is sort of special, and calculate reff too:\n rat = args.rat.contents[:]\n rat = np.array(rat).reshape(2+FEFF_maxleg, 3).transpose()\n self.rat = BOHR*rat\n\n _rat = self.rat.T\n reff = 0.\n for i, atom in enumerate(_rat[1:]):\n prev = _rat[i,:]\n reff += np.sqrt( (prev[0]-atom[0])**2 +\n (prev[1]-atom[1])**2 +\n (prev[2]-atom[2])**2 )\n self.reff = reff /2.0\n\n self.geom = []\n rmass = 0.\n for i in range(nleg):\n ipot = int(self.ipot[i])\n iz, sym = self.atoms[ipot]\n mass = atomic_mass(iz)\n\n x, y, z = _rat[i][0], _rat[i][1], _rat[i][2]\n self.geom.append((str(sym), iz, ipot, x, y, z))\n rmass += 1.0/max(1.0, mass)\n\n self.rmass = 1./rmass\n\n\ndef feff8_xafs(phase_file):\n return Feff8L_XAFSPath(phase_file=phase_file)\n\n\n\n## def initializeLarchPlugin(_larch=None):\n# \"\"\"initialize F8LIB\"\"\"\n# if _larch is not None:\n# global F8LIB\n# if F8LIB is None:\n# try:\n# F8LIB = get_dll('feff8lpath')\n# except:\n# pass\n##\n", "meta": {"hexsha": "8c9e428998d26e3be68aca1e748b5e96a61d9cdd", "size": 10838, "ext": "py", "lang": "Python", "max_stars_repo_path": "larch/xafs/feff8lpath.py", "max_stars_repo_name": "Bob620/xraylarch", "max_stars_repo_head_hexsha": "f8d38e6122cc0e8c990b0f024db3b503a5fbf057", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "larch/xafs/feff8lpath.py", "max_issues_repo_name": "Bob620/xraylarch", "max_issues_repo_head_hexsha": "f8d38e6122cc0e8c990b0f024db3b503a5fbf057", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "larch/xafs/feff8lpath.py", "max_forks_repo_name": "Bob620/xraylarch", "max_forks_repo_head_hexsha": "f8d38e6122cc0e8c990b0f024db3b503a5fbf057", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.074433657, "max_line_length": 81, "alphanum_fraction": 0.5482561358, "include": true, "reason": "import numpy", "num_tokens": 3093, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5926665999540698, "lm_q2_score": 0.334589441253186, "lm_q1q2_score": 0.19829998652805772}} {"text": "\"\"\"\nSet of functions used by the PyRSM class to compute detection maps and optimize the parameters\nof the RSM algorithm and PSF-subtraction techniques via the auto-RSM and auto-S/N frameworks\n\"\"\"\n__author__ = 'Carl-Henrik Dahlqvist'\n\nfrom scipy.interpolate import Rbf\nimport pandas as pd\nimport numpy.linalg as la\nfrom vip_hci.var import get_annulus_segments, frame_center,prepare_matrix\nfrom vip_hci.preproc.derotation import _define_annuli\nimport numpy as np\nfrom vip_hci.preproc import cube_derotate, cube_collapse, check_pa_vector,check_scal_vector\nfrom vip_hci.preproc.derotation import _find_indices_adi\nfrom vip_hci.preproc.rescaling import _find_indices_sdi\nimport scipy as sp\nfrom multiprocessing import cpu_count\nfrom vip_hci.conf.utils_conf import pool_map, iterable\nfrom vip_hci.pca.svd import get_eigenvectors\nfrom vip_hci.llsg.llsg import _patch_rlrps\nfrom vip_hci.preproc import cube_rescaling_wavelengths as scwave\nimport vip_hci as vip\nfrom sklearn.decomposition import NMF as NMF_sklearn\n \ndef check_delta_sep(scale_list,delta_sep,minradius,fwhm,c):\n wl = np.asarray(scale_list)\n wl_ref = wl[len(wl)//2]\n sep_lft = (wl_ref - wl) / wl_ref * ((minradius + fwhm * delta_sep) / fwhm)\n sep_rgt = (wl - wl_ref) / wl_ref * ((minradius - fwhm * delta_sep) / fwhm)\n map_lft = sep_lft >= delta_sep\n map_rgt = sep_rgt >= delta_sep\n indices = np.nonzero(map_lft | map_rgt)[0]\n\n if indices.size == 0:\n raise RuntimeError((\"No frames left after radial motion threshold for cube {}. Try \"\n \"decreasing the value of `delta_sep`\").format(c)) \n \ndef rot_scale(step,cube,cube_scaled,angle_list,scale_list, imlib, interpolation):\n \n \"\"\"\n Function used to rescale the frames when relying on ADI+SDI before the computation the reference PSF\n (step='ini') and rescale and derotate the frames to generate the cube of residuals used by the RSM \n algorithm (step='fin').\n \n Parameters\n ----------\n\n step: str\n 'ini' before the reference PSF computation and 'fin' after PSF subtraction.\n cube: numpy ndarray, 3d or 4d\n Original cube\n cube_scaled: numpy ndarray, 3d\n Cube of residuals to be rescaled and derotated (None for the step='ini')\n angle_list : numpy ndarray, 1d\n Parallactic angles for each frame of the ADI sequences. \n scale_list: numpy ndarray, 1d, optional\n Scaling factors in case of IFS data (ADI+mSDI cube). Usually, the\n scaling factors are the central channel wavelength divided by the\n shortest wavelength in the cube (more thorough approaches can be used\n to get the scaling factors). This scaling factors are used to re-scale\n the spectral channels and align the speckles. Default is None\n imlib : str, optional\n See the documentation of the ``vip_hci.preproc.frame_rotate`` function.\n interpolation : str, optional\n See the documentation of the ``vip_hci.preproc.frame_rotate`` function.\n \"\"\"\n \n if cube.ndim == 4:\n \n z, n, y_in, x_in = cube.shape\n scale_list = check_scal_vector(scale_list)\n \n if step=='ini':\n # rescaled cube, aligning speckles for SDI\n for i in range(n):\n if i==0:\n fin_cube = scwave(cube[:, i, :, :], scale_list,\n imlib=imlib, interpolation=interpolation)[0]\n fin_pa=np.repeat(angle_list[i],z)\n fin_scale=scale_list\n else: \n \n fin_cube = np.append(fin_cube,scwave(cube[:, i, :, :], scale_list,\n imlib=imlib, interpolation=interpolation)[0],axis=0)\n fin_pa=np.append(fin_pa,np.repeat(angle_list[i],z),axis=0)\n fin_scale=np.append(fin_scale,scale_list,axis=0)\n \n return fin_cube,fin_pa,fin_scale\n \n\n elif step=='fin': \n \n cube_fin=np.zeros((n,y_in, x_in))\n \n cube_rescaled = scwave(cube_scaled, scale_list, \n full_output=True, inverse=True,\n y_in=y_in, x_in=x_in, imlib=imlib,\n interpolation=interpolation)[0]\n \n cube_derotated=cube_derotate(cube_rescaled,angle_list, interpolation=interpolation,imlib=imlib)\n\n \n for i in range(n):\n \n cube_fin[i]=np.mean(cube_derotated[(i*z):((i+1)*z),:,:],axis=0)\n \n return cube_fin\n \n if cube.ndim == 3:\n \n if step=='ini':\n \n return cube,angle_list,None\n \n elif step=='fin': \n\n cube_derotated=cube_derotate(cube_scaled,angle_list, interpolation=interpolation,imlib=imlib)\n \n return cube_derotated\n \n \ndef remove_outliers(time_s, range_sel, k=5, t0=3):\n \"\"\"\n Hampel Filter to remove potential outliers in the set of selected parameters \n for the annular mode of the auto-RSM framework\n \"\"\"\n vals=pd.DataFrame(data=time_s[range_sel])\n L= 1.4826\n rolling_median=vals.rolling(k).median()\n difference=np.abs(rolling_median-vals)\n median_abs_deviation=difference.rolling(k).median()\n threshold= t0 *L * median_abs_deviation\n outlier_idx=difference>threshold\n vals[outlier_idx]=threshold[outlier_idx]\n return(vals.to_numpy().reshape(-1))\n \ndef interpolation(time_s,range_sel): \n \n \"\"\"\n Interpolation algorithm for the RSM parameters \n for the annular mode of the auto-RSM framework\n \"\"\"\n \n time_series=time_s.copy()\n time_series[range_sel]=remove_outliers(time_series,range_sel)\n fit = Rbf(range_sel,time_s[range_sel])\n inter_point = np.linspace(range_sel[0],range_sel[-1]+1, num=(range_sel[-1]-range_sel[0]+1), endpoint=True)\n return fit(inter_point)\n\ndef poly_fit(time_s,range_sel,poly_n):\n \n \"\"\"\n Smoothing procedure for the computation of the final radial thresholds\n which are subtracted from the final RSM detection map in the final step\n of the auto-RSM framework\n \"\"\"\n \n time_series=time_s.copy()\n time_series[range_sel]=remove_outliers(time_series,range_sel)\n fit_p=np.poly1d(np.polyfit(range_sel,time_series[range_sel], poly_n))\n time_series=fit_p(range(len(time_series)))\n return time_series\n\ndef get_time_series(mcube,ann_center):\n \n \"\"\"\n Function defining and ordering (anti-clockwise) the pixels composing\n an annulus at a radial distance of ann_center for an ADI sequence mcube\n \"\"\"\n if mcube.ndim == 4:\n indices = get_annulus_segments(mcube[0,0,:,:], ann_center,1,4,90)\n else:\n indices = get_annulus_segments(mcube[0], ann_center,1,4,90)\n\n tempind=np.vstack((indices[0][0],indices[0][1]))\n ind = np.lexsort((tempind[0], tempind[1]))\n\n indicesy=tempind[0,ind[::-1]]\n indicesx=tempind[1,ind[::-1]] \n\n tempind=np.vstack((indices[1][0],indices[1][1]))\n ind = np.lexsort((-tempind[0], tempind[1]))\n\n indicesy=np.hstack((indicesy,tempind[0,ind[::-1]]))\n indicesx=np.hstack((indicesx,tempind[1,ind[::-1]]))\n\n tempind=np.vstack((indices[2][0],indices[2][1]))\n ind = np.lexsort((tempind[0], tempind[1]))\n\n indicesy=np.hstack((indicesy,tempind[0,ind]))\n indicesx=np.hstack((indicesx,tempind[1,ind])) \n\n tempind=np.vstack((indices[3][0],indices[3][1]))\n ind = np.lexsort((-tempind[0], tempind[1]))\n\n indicesy=np.hstack((indicesy,tempind[0,ind]))\n indicesx=np.hstack((indicesx,tempind[1,ind]))\n \n return indicesy,indicesx\n \ndef perturb(frame,model_matrix,numbasis,evals_matrix, evecs_matrix, KL_basis_matrix,sci_mean_sub_matrix,refs_mean_sub_matrix, angle_list, fwhm, pa_threshold, ann_center):\n \n\n \"\"\"\n Function allowing the estimation of the PSF forward model when relying on KLIP\n for the computation of the speckle field. The code is based on the PyKLIP library\n considering only the ADI case with a singlle number of principal components considered.\n For more details about the code, consider the PyKLIP library or the originall articles\n (Pueyo, L. 2016, ApJ, 824, 117 or\n Ruffio, J.-B., Macintosh, B., Wang, J. J., & Pueyo, L. 2017, ApJ, 842)\n \"\"\"\n \n #Selection of the reference library based on the given parralactic angle threshold\n\n if pa_threshold != 0:\n indices_left = _find_indices_adi(angle_list, frame,\n pa_threshold, truncate=False)\n\n models_ref = model_matrix[indices_left]\n\n else:\n models_ref = model_matrix\n\n\n #Computation of the self-subtraction and over-subtraction for the current frame\n \n model_sci = model_matrix[frame] \n KL_basis=KL_basis_matrix[frame]\n sci_mean_sub=sci_mean_sub_matrix[frame]\n refs_mean_sub=refs_mean_sub_matrix[frame]\n evals=evals_matrix[frame]\n evecs=evecs_matrix[frame]\n\n max_basis = KL_basis.shape[0]\n N_pix = KL_basis.shape[1]\n\n models_mean_sub = models_ref - np.nanmean(models_ref, axis=1)[:,None] \n models_mean_sub[np.where(np.isnan(models_mean_sub))] = 0\n \n model_sci_mean_sub = model_sci- np.nanmean(model_sci)\n model_sci_mean_sub[np.where(np.isnan(model_sci_mean_sub))] = 0\n model_sci_mean_sub_rows = np.reshape(model_sci_mean_sub,(1,N_pix))\n sci_mean_sub_rows = np.reshape(sci_mean_sub,(1,N_pix))\n \n delta_KL = np.zeros([max_basis, N_pix])\n\n models_mean_sub_X_refs_mean_sub_T = models_mean_sub.dot(refs_mean_sub.transpose())\n\n for k in range(max_basis):\n Zk = np.reshape(KL_basis[k,:],(1,KL_basis[k,:].size))\n Vk = (evecs[:,k])[:,None]\n\n\n diagVk_X_models_mean_sub_X_refs_mean_sub_T = (Vk.T).dot(models_mean_sub_X_refs_mean_sub_T)\n models_mean_sub_X_refs_mean_sub_T_X_Vk = models_mean_sub_X_refs_mean_sub_T.dot(Vk)\n DeltaZk = -(1/(2*np.sqrt(evals[k])))*(diagVk_X_models_mean_sub_X_refs_mean_sub_T.dot(Vk) + ((Vk.T).dot(models_mean_sub_X_refs_mean_sub_T_X_Vk))).dot(Zk)+(Vk.T).dot(models_mean_sub)\n\n\n for j in range(k):\n Zj = KL_basis[j, :][None,:]\n Vj = evecs[:, j][:,None]\n DeltaZk += np.sqrt(evals[j])/(evals[k]-evals[j])*(diagVk_X_models_mean_sub_X_refs_mean_sub_T.dot(Vj) + ((Vj.T).dot(models_mean_sub_X_refs_mean_sub_T_X_Vk))).dot(Zj)\n for j in range(k+1, max_basis):\n Zj = KL_basis[j, :][None,:]\n Vj = evecs[:, j][:,None]\n DeltaZk += np.sqrt(evals[j])/(evals[k]-evals[j])*(diagVk_X_models_mean_sub_X_refs_mean_sub_T.dot(Vj) + ((Vj.T).dot(models_mean_sub_X_refs_mean_sub_T_X_Vk))).dot(Zj)\n\n delta_KL[k] = DeltaZk/np.sqrt(evals[k])\n \n oversubtraction_inner_products = np.dot(model_sci_mean_sub_rows, KL_basis.T) \n \n selfsubtraction_1_inner_products = np.dot(sci_mean_sub_rows, delta_KL.T)\n selfsubtraction_2_inner_products = np.dot(sci_mean_sub_rows, KL_basis.T)\n\n oversubtraction_inner_products[max_basis::] = 0\n klipped_oversub = np.dot(oversubtraction_inner_products, KL_basis)\n \n selfsubtraction_1_inner_products[0,max_basis::] = 0\n selfsubtraction_2_inner_products[0,max_basis::] = 0\n klipped_selfsub = np.dot(selfsubtraction_1_inner_products, KL_basis) + \\\n np.dot(selfsubtraction_2_inner_products, delta_KL)\n\n return model_sci[None,:] - klipped_oversub - klipped_selfsub \n \n\n\n\ndef KLIP(cube, angle_list, nann=None, local=False, fwhm=4, asize=2, n_segments=1,delta_rot=1, ncomp=1,min_frames_lib=2, max_frames_lib=200,imlib='opencv',nframes=None, interpolation='lanczos4', collapse='median',full_output=False, verbose=1):\n\n \"\"\"\n Function allowing the estimation of the cube of residuals after\n the subtraction of the speckle field modeled via the KLIP framework \n \"\"\"\n \n array = cube\n if array.ndim != 3:\n raise TypeError('Input array is not a cube or 3d array')\n if array.shape[0] != angle_list.shape[0]:\n raise TypeError('Input vector or parallactic angles has wrong length')\n\n n, y, _ = array.shape\n \n angle_list = check_pa_vector(angle_list)\n \n if asize is None:\n annulus_width = int(np.ceil(2 * fwhm))\n elif isinstance(asize, int):\n annulus_width = asize\n \n # Annulus parametrization \n \n radius_int=fwhm\n if local==True:\n if nann> 2*annulus_width:\n n_annuli = 5\n radius_int=(nann//annulus_width-2)*annulus_width \n else:\n n_annuli = 4 \n radius_int=(nann//annulus_width-1)*annulus_width\n else:\n n_annuli = int((y / 2 - radius_int) / asize)\n \n # Definition of the number of segment for the diifferent annuli\n\n if isinstance(n_segments, int):\n n_segments = [n_segments for _ in range(n_annuli)]\n elif n_segments == 'auto':\n n_segments = list()\n n_segments.append(2) \n n_segments.append(3) \n ld = 2 * np.tan(360 / 4 / 2) * asize\n for i in range(2, n_annuli): \n radius = i * asize\n ang = np.rad2deg(2 * np.arctan(ld / (2 * radius)))\n n_segments.append(int(np.ceil(360 / ang)))\n\n if verbose:\n msg = '# annuli = {}, Ann width = {}, FWHM = {:.3f}'\n print(msg.format(n_annuli, asize, fwhm))\n print('PCA per annulus (or annular sectors):')\n\n\n # Definition of the annuli and the corresmponding parralactic angle threshold \n \n cube_out = np.zeros_like(array)\n for ann in range(n_annuli):\n if isinstance(ncomp, list) or isinstance(ncomp, np.ndarray):\n if len(ncomp) == n_annuli:\n ncompann = ncomp[ann]\n else:\n msge = 'If ncomp is a list, it must match the number of annuli'\n raise TypeError(msge)\n else:\n ncompann = ncomp\n\n \n inner_radius = radius_int + ann * annulus_width\n n_segments_ann = n_segments[ann]\n\n\n if verbose:\n print('{} : in_rad={}, n_segm={}'.format(ann+1, inner_radius,\n n_segments_ann))\n\n\n theta_init = 90\n res_ann_par = _define_annuli(angle_list, ann, int((y / 2 - radius_int) / asize), fwhm,radius_int, annulus_width, delta_rot,n_segments_ann, verbose)\n pa_thr, inner_radius, ann_center = res_ann_par\n indices = get_annulus_segments(array[0], inner_radius, annulus_width,n_segments_ann,theta_init)\n \n # Computation of the speckle field for the different frames and estimation of the cube of residuals\n \n for j in range(n_segments_ann):\n\n for k in range(array.shape[0]):\n \n res =KLIP_patch(k,array[:, indices[j][0], indices[j][1]], ncompann, angle_list, fwhm, pa_thr, ann_center,nframes=nframes)\n cube_out[k,indices[j][0], indices[j][1]] = res[3]\n\n\n # Cube is derotated according to the parallactic angle and collapsed\n \n cube_der = cube_derotate(cube_out, angle_list, imlib=imlib,interpolation=interpolation)\n frame = cube_collapse(cube_der, mode=collapse)\n\n if full_output:\n return cube_out, cube_der, frame\n else:\n return frame\n \ndef KLIP_patch(frame, matrix, numbasis, angle_list, fwhm, pa_threshold, ann_center,nframes=None):\n\n \"\"\" \n Function allowing the computation via KLIP of the speckle field for a \n given sub-region of the original ADI sequence. Code inspired by the PyKLIP librabry\n \"\"\"\n \n max_frames_lib=200\n \n if pa_threshold != 0:\n if ann_center > fwhm*20:\n indices_left = _find_indices_adi(angle_list,frame,pa_threshold, truncate=True,max_frames=max_frames_lib)\n else:\n indices_left = _find_indices_adi(angle_list, frame,pa_threshold, truncate=False,nframes=nframes)\n\n refs = matrix[indices_left]\n \n else:\n refs = matrix\n\n sci = matrix[frame]\n sci_mean_sub = sci - np.nanmean(sci)\n #sci_mean_sub[np.where(np.isnan(sci_mean_sub))] = 0\n refs_mean_sub = refs- np.nanmean(refs, axis=1)[:, None]\n #refs_mean_sub[np.where(np.isnan(refs_mean_sub))] = 0\n\n # Covariance matrix definition\n covar_psfs = np.cov(refs_mean_sub)\n covar_psfs *= (np.size(sci)-1)\n\n tot_basis = covar_psfs.shape[0]\n\n numbasis = np.clip(numbasis - 1, 0, tot_basis-1)\n max_basis = np.max(numbasis) + 1\n\n #Computation of the eigenvectors/values of the covariance matrix\n evals, evecs = la.eigh(covar_psfs)\n evals = np.copy(evals[int(tot_basis-max_basis):int(tot_basis)])\n evecs = np.copy(evecs[:,int(tot_basis-max_basis):int(tot_basis)])\n evals = np.copy(evals[::-1])\n evecs = np.copy(evecs[:,::-1])\n\n # Computation of the principal components\n \n KL_basis = np.dot(refs_mean_sub.T,evecs)\n KL_basis = KL_basis * (1. / np.sqrt(evals))[None,:]\n KL_basis = KL_basis.T \n\n N_pix = np.size(sci_mean_sub)\n sci_rows = np.reshape(sci_mean_sub, (1,N_pix))\n \n inner_products = np.dot(sci_rows, KL_basis.T)\n inner_products[0,int(max_basis)::]=0\n\n #Projection of the science image on the selected prinicpal component\n #to generate the speckle field model\n\n klip_reconstruction = np.dot(inner_products, KL_basis)\n\n # Subtraction of the speckle field model from the riginal science image\n #to obtain the residual frame\n \n sub_img_rows = sci_rows - klip_reconstruction \n\n return evals,evecs,KL_basis,np.reshape(sub_img_rows, (N_pix)),refs_mean_sub,sci_mean_sub\n\n\ndef LOCI_FM(cube, psf, ann_center, angle_list,scale_list, asize,fwhm, Tol,delta_rot,delta_sep):\n\n\n \"\"\"\n Computation of the optimal factors weigthing the linear combination of reference\n frames used to obtain the modeled speckle field for each frame and allowing the \n determination of the forward modeled PSF. Estimation of the cube \n of residuals based on the modeled speckle field.\n \"\"\"\n\n\n cube_res = np.zeros_like(cube)\n ceny, cenx = frame_center(cube[0])\n radius_int=ann_center-int(1.5*asize)\n if radius_int<=0:\n radius_int=1\n \n for ann in range(3):\n n_segments_ann = 1\n inner_radius_ann = radius_int + ann*asize\n pa_threshold = _define_annuli(angle_list, ann, 3, asize,\n radius_int, asize, delta_rot,\n n_segments_ann, verbose=False)[0]\n \n indices = get_annulus_segments(cube[0], inner_radius=inner_radius_ann,\n width=asize, nsegm=n_segments_ann)\n ind_opt = get_annulus_segments(cube[0], inner_radius=inner_radius_ann,\n width=asize, nsegm=n_segments_ann,\n optim_scale_fact=2)\n \n ayxyx = [inner_radius_ann,pa_threshold, indices[0][0], indices[0][1],\n ind_opt[0][0], ind_opt[0][1]]\n \n matrix_res, ind_ref, coef, yy, xx = _leastsq_patch(ayxyx,\n angle_list,scale_list,fwhm,cube,ann_center,'manhattan', 100,delta_sep,\n 'lstsq', Tol,formod=True,psf=psf)\n \n if ann==1:\n ind_ref_list=ind_ref\n coef_list=coef\n \n cube_res[:, yy, xx] = matrix_res\n \n return cube_res, ind_ref_list,coef_list\n\n\ndef nmf_adisdi(cube, angle_list,scale_list=None, cube_ref=None, ncomp=1, scaling=None, max_iter=100,\n random_state=None, mask_center_px=None, imlib='opencv',\n interpolation='lanczos4', collapse='median', full_output=False,\n verbose=True, **kwargs):\n \"\"\" Non Negative Matrix Factorization for ADI or ADI+SDI sequences.This function embeds the \n scikit-learn NMF algorithm solved through coordinate descent method. \n \"\"\"\n \n array,angle_list_t,scale_list_t=rot_scale('ini',cube,None,angle_list,scale_list,imlib, interpolation)\n \n\n\n n, y, x = array.shape\n \n matrix = prepare_matrix(array, scaling, mask_center_px, mode='fullfr',\n verbose=verbose)\n matrix += np.abs(matrix.min())\n if cube_ref is not None:\n matrix_ref = prepare_matrix(cube_ref, scaling, mask_center_px,\n mode='fullfr', verbose=verbose)\n matrix_ref += np.abs(matrix_ref.min())\n \n mod = NMF_sklearn(n_components=ncomp, alpha=0, solver='cd', init='nndsvd', \n max_iter=max_iter, random_state=random_state, **kwargs) \n \n # H [ncomp, n_pixels]: Non-negative components of the data\n if cube_ref is not None:\n H = mod.fit(matrix_ref).components_\n else:\n H = mod.fit(matrix).components_ \n \n # W: coefficients [n_frames, ncomp]\n W = mod.transform(matrix)\n \n reconstructed = np.dot(W, H)\n residuals = matrix - reconstructed\n \n array_out = np.zeros_like(array)\n for i in range(n):\n array_out[i] = residuals[i].reshape(y,x)\n \n cube_der=rot_scale('fin',cube,array_out,angle_list_t,scale_list_t, imlib, interpolation)\n frame_fin = cube_collapse(cube_der, mode=collapse)\n \n return cube_der,frame_fin\n\n\ndef annular_NMF(cube, angle_list, nann=None, local=False, fwhm=4, asize=2, n_segments=1, ncomp=20,imlib='opencv', interpolation='lanczos4', collapse='median',max_iter=100,\n random_state=None,full_output=False, verbose=False):\n \n \"\"\"\n Function allowing the estimation of the cube of residuals after\n the subtraction of the speckle field modeled via the NMF framework.\n This codes is an adaptation of the VIP NMF function to the case of annular\n computation of the modeled speckle fields\n (only full-frame estimation in Gonzalez et al. AJ, 154:7,2017)\n \"\"\"\n \n array = cube\n if array.ndim != 3:\n raise TypeError('Input array is not a cube or 3d array')\n if array.shape[0] != angle_list.shape[0]:\n raise TypeError('Input vector or parallactic angles has wrong length')\n\n n, y, _ = array.shape\n \n angle_list = check_pa_vector(angle_list)\n \n if asize is None:\n annulus_width = int(np.ceil(2 * fwhm))\n elif isinstance(asize, int):\n annulus_width = asize\n \n # Annulus parametrization \n \n radius_int=fwhm\n if local==True:\n if nann> 2*annulus_width:\n n_annuli = 5\n radius_int=(nann//annulus_width-2)*annulus_width \n else:\n n_annuli = 4 \n radius_int=(nann//annulus_width-1)*annulus_width\n else:\n n_annuli = int((y / 2 - radius_int) / asize)\n \n\n # Definition of the annuli and the corresponding parralactic angle threshold \n \n cube_out = np.zeros_like(array)\n for ann in range(n_annuli):\n\n\n inner_radius = radius_int + ann * annulus_width\n\n\n if verbose:\n print('{} : in_rad={}'.format(ann+1, inner_radius))\n\n theta_init = 90\n indices = get_annulus_segments(array[0], inner_radius, annulus_width,n_segments,theta_init)\n \n # Computation of the speckle field for the different frames and estimation of the cube of residuals\n \n for j in range(n_segments):\n\n \n cube_out[:,indices[j][0], indices[j][1]] =NMF_patch(array[:, indices[j][0], indices[j][1]], ncomp, max_iter,random_state,verbose)\n\n\n # Cube is derotated according to the parallactic angle and collapsed\n \n cube_der = cube_derotate(cube_out, angle_list, imlib=imlib,interpolation=interpolation)\n frame = cube_collapse(cube_der, mode=collapse)\n\n if full_output:\n return cube_out, cube_der, frame\n else:\n return frame\n \n\ndef NMF_patch(matrix, ncomp, max_iter,random_state,sklearn=False):\n\n \"\"\"\n Function allowing the computation via NMF of the speckle field for a \n given sub-region of the original ADI sequence. The code is a partial reproduction of\n the VIP function NMF_patch (Gonzalez et al. AJ, 154:7,2017)\n \"\"\"\n\n refs = matrix+ np.abs(matrix.min())\n \n if sklearn==True:\n \n mod = NMF_sklearn(n_components=ncomp, alpha=0, solver='cd', init='nndsvd', \n max_iter=max_iter, random_state=random_state) \n \n # H [ncomp, n_pixels]: Non-negative components of the data\n \n H = mod.fit(refs).components_ \n \n W = mod.transform(refs)\n \n reconstructed = np.dot(W, H)\n \n else:\n \n mod = NMF(X=refs, n_components=ncomp)\n \n mod.SolveNMF(maxiters=max_iter, tol=0.001)\n \n \n H=mod.H\n W=mod.W\n reconstructed = np.dot(W, H)\n \n residuals = refs - reconstructed\n\n return residuals\n\ndef NMF_patch_range(matrix, ncomp_range, max_iter,random_state,verbose):\n\n \"\"\"\n Function allowing the computation via NMF of the speckle field for a range of principal \n components ncomp_range and a given sub-region of the original ADI sequence. The code is a\n partial reproduction of the VIP function NMF_patch (Gonzalez et al. AJ, 154:7,2017)\n \"\"\"\n\n\n refs = matrix+ np.abs(matrix.min())\n\n mod = NMF(X=refs, n_components=ncomp_range[len(ncomp_range)-1])\n \n mod.SolveNMF(maxiters=max_iter, tol=0.001)\n\n if verbose: \n print('Done NMF with sklearn.NMF.')\n\n residuals=[]\n for i in ncomp_range:\n H=mod.H[ncomp_range[0]:i,:]\n W=mod.W[:,ncomp_range[0]:i]\n reconstructed = np.dot(W, H)\n residuals.append(refs - reconstructed)\n\n return residuals\n\ndef annular_pca_adisdi(cube, angle_list,scale_list=None, radius_int=0, fwhm=4, asize=2, n_segments=1,\n delta_rot=1,delta_sep=0.1, ncomp=1, svd_mode='lapack', nproc=None,\n min_frames_lib=2, max_frames_lib=200, tol=1e-1, scaling=None,\n imlib='opencv', interpolation='lanczos4', collapse='median',\n full_output=False, verbose=False, cube_ref=None, weights=None):\n \"\"\" PCA exploiting angular and spectral variability (ADI or ADI+SDI fashion).\n \"\"\"\n\n array,angle_list_t,scale_list_t=rot_scale('ini',cube,None,angle_list,scale_list,imlib, interpolation)\n \n n, y, _ = array.shape\n\n angle_list_t = check_pa_vector(angle_list_t)\n n_annuli = int((y / 2 - radius_int) / asize)\n\n if isinstance(delta_rot, tuple):\n delta_rot = np.linspace(delta_rot[0], delta_rot[1], num=n_annuli)\n elif isinstance(delta_rot, (int, float)):\n delta_rot = [delta_rot] * n_annuli\n\n if isinstance(n_segments, int):\n n_segments = [n_segments for _ in range(n_annuli)]\n elif n_segments == 'auto':\n n_segments = list()\n n_segments.append(2) # for first annulus\n n_segments.append(3) # for second annulus\n ld = 2 * np.tan(360 / 4 / 2) * asize\n for i in range(2, n_annuli): # rest of annuli\n radius = i * asize\n ang = np.rad2deg(2 * np.arctan(ld / (2 * radius)))\n n_segments.append(int(np.ceil(360 / ang)))\n\n if verbose:\n msg = 'N annuli = {}, FWHM = {:.3f}'\n print(msg.format(n_annuli, fwhm))\n print('PCA per annulus (or annular sectors):')\n\n if nproc is None: # Hyper-threading \"duplicates\" the cores -> cpu_count/2\n nproc = cpu_count() // 2\n\n # The annuli are built, and the corresponding PA thresholds for frame\n # rejection are calculated (at the center of the annulus)\n cube_out = np.zeros_like(array)\n for ann in range(n_annuli):\n if isinstance(ncomp, tuple) or isinstance(ncomp, np.ndarray):\n if len(ncomp) == n_annuli:\n ncompann = ncomp[ann]\n else:\n raise TypeError('If `ncomp` is a tuple, it must match the '\n 'number of annuli')\n else:\n ncompann = ncomp\n\n n_segments_ann = n_segments[ann]\n res_ann_par = _define_annuli(angle_list_t, ann, n_annuli, fwhm,\n radius_int, asize, delta_rot[ann],\n n_segments_ann, verbose)\n pa_thr, inner_radius, ann_center = res_ann_par\n indices = get_annulus_segments(array[0], inner_radius, asize,\n n_segments_ann)\n # Library matrix is created for each segment and scaled if needed\n for j in range(n_segments_ann):\n yy = indices[j][0]\n xx = indices[j][1]\n matrix_segm = array[:, yy, xx] # shape [nframes x npx_segment]\n\n if cube_ref is not None:\n matrix_segm_ref = cube_ref[:, yy, xx]\n else:\n matrix_segm_ref = None\n\n res = pool_map(nproc, do_pca_patch, matrix_segm, iterable(range(n)),\n angle_list_t,scale_list_t, fwhm, pa_thr,delta_sep, ann_center, svd_mode,\n ncompann, min_frames_lib, max_frames_lib, tol,\n matrix_segm_ref)\n\n res = np.array(res)\n residuals = np.array(res[:, 0])\n\n for fr in range(n):\n cube_out[fr][yy, xx] = residuals[fr]\n\n\n # Cube is derotated according to the parallactic angle and collapsed\n cube_der=rot_scale('fin',cube,cube_out,angle_list_t,scale_list_t, imlib, interpolation)\n \n frame = cube_collapse(cube_der, mode=collapse)\n\n return cube_der, frame\n \ndef do_pca_patch(matrix, frame, angle_list,scale_list, fwhm, pa_threshold, delta_sep, ann_center,\n svd_mode, ncomp, min_frames_lib, max_frames_lib, tol,\n matrix_ref):\n \n \"\"\" \n Function doing the SVD/PCA for each frame patch. The code is a partial reproduction of\n the VIP function do_pca_patch (Gonzalez et al. AJ, 154:7,2017) \n \"\"\"\n\n\n if scale_list is not None:\n \n indices_left = np.intersect1d(_find_indices_adi(angle_list, frame,\n pa_threshold, truncate=False),_find_indices_sdi(scale_list, ann_center, frame,\n fwhm, delta_sep))\n else:\n indices_left = _find_indices_adi(angle_list, frame,\n pa_threshold, truncate=False)\n \n\n data_ref = matrix[indices_left]\n if matrix_ref is not None:\n # Stacking the ref and the target ref (pa thresh) libraries\n data_ref = np.vstack((matrix_ref, data_ref))\n\n curr_frame = matrix[frame] # current frame\n V = get_eigenvectors(ncomp, data_ref, svd_mode, noise_error=tol)\n transformed = np.dot(curr_frame, V.T)\n reconstructed = np.dot(transformed.T, V)\n residuals = curr_frame - reconstructed\n return residuals, V.shape[0], data_ref.shape[0]\n\n\ndef do_pca_patch_range(matrix, frame, angle_list,scale_list, fwhm, pa_threshold,delta_sep, ann_center,\n svd_mode, ncomp_range, min_frames_lib, max_frames_lib, tol,\n matrix_ref):\n \"\"\" \n Function doing the SVD/PCA for each frame patch for a range of principal\n component ncomp_range. The code is a partial reproduction of\n the VIP function do_pca_patch (Gonzalez et al. AJ, 154:7,2017) \n \"\"\"\n\n if scale_list is not None:\n \n indices_left = np.intersect1d(_find_indices_adi(angle_list, frame,\n pa_threshold, truncate=False),_find_indices_sdi(scale_list, ann_center, frame,\n fwhm, delta_sep))\n else:\n indices_left = _find_indices_adi(angle_list, frame,\n pa_threshold, truncate=False)\n\n data_ref = matrix[indices_left]\n if matrix_ref is not None:\n # Stacking the ref and the target ref (pa thresh) libraries\n data_ref = np.vstack((matrix_ref, data_ref))\n\n curr_frame = matrix[frame] # current frame\n V = get_eigenvectors(ncomp_range[len(ncomp_range)-1], data_ref, svd_mode, noise_error=tol)\n residuals=[]\n for i in ncomp_range:\n V_trunc=V[ncomp_range[0]:i,:]\n transformed = np.dot(curr_frame, V_trunc.T)\n reconstructed = np.dot(transformed.T, V_trunc)\n residuals.append(curr_frame - reconstructed)\n \n return residuals, V.shape[0], data_ref.shape[0]\n\n \ndef loci_adisdi(cube, angle_list,scale_list=None, fwhm=4, metric='manhattan',\n dist_threshold=50, delta_rot=0.5,delta_sep=0.1, radius_int=0, asize=4,\n n_segments=1, nproc=1, solver='lstsq', tol=1e-3,\n optim_scale_fact=1, imlib='opencv', interpolation='lanczos4',\n collapse='median', nann=None,local=False, verbose=True, full_output=False):\n \"\"\" Least-squares model PSF subtraction for ADI or ADI+SDI. This code is an adaptation of the VIP\n xloci function to provide, if required, the residuals after speckle field subtraction\n for a given annulus.\n \"\"\"\n \n cube_rot_scale,angle_list_t,scale_list_t=rot_scale('ini',cube,None,angle_list,scale_list,imlib, interpolation)\n \n \n y = cube_rot_scale.shape[1]\n if not asize < y // 2:\n raise ValueError(\"asize is too large\")\n\n angle_list = check_pa_vector(angle_list)\n if local==True:\n n_annuli = 3 \n radius_int=nann-asize\n else:\n n_annuli= int((y / 2 - radius_int) / asize)\n if verbose:\n print(\"Building {} annuli:\".format(n_annuli))\n\n if isinstance(delta_rot, tuple):\n delta_rot = np.linspace(delta_rot[0], delta_rot[1], num=n_annuli)\n elif isinstance(delta_rot, (int, float)):\n delta_rot = [delta_rot] * n_annuli\n\n if nproc is None:\n nproc = cpu_count() // 2 # Hyper-threading doubles the # of cores\n\n annulus_width = asize\n if isinstance(n_segments, int):\n n_segments = [n_segments]*n_annuli\n elif n_segments == 'auto':\n n_segments = list()\n n_segments.append(2) # for first annulus\n n_segments.append(3) # for second annulus\n ld = 2 * np.tan(360/4/2) * annulus_width\n for i in range(2, n_annuli): # rest of annuli\n radius = i * annulus_width\n ang = np.rad2deg(2 * np.arctan(ld / (2 * radius)))\n n_segments.append(int(np.ceil(360/ang)))\n\n # annulus-wise least-squares combination and subtraction\n cube_res = np.zeros_like(cube_rot_scale)\n\n ayxyx = [] # contains per-segment data\n\n for ann in range(n_annuli):\n n_segments_ann = n_segments[ann]\n inner_radius_ann = radius_int + ann*annulus_width\n\n # angles\n pa_threshold = _define_annuli(angle_list, ann, n_annuli, fwhm,\n radius_int, asize, delta_rot[ann],\n n_segments_ann, verbose)[0]\n\n # indices\n indices = get_annulus_segments(cube_rot_scale[0], inner_radius=inner_radius_ann,\n width=asize, nsegm=n_segments_ann)\n ind_opt = get_annulus_segments(cube_rot_scale[0], inner_radius=inner_radius_ann,\n width=asize, nsegm=n_segments_ann,\n optim_scale_fact=optim_scale_fact)\n\n # store segment data for multiprocessing\n ayxyx += [(inner_radius_ann+asize//2,pa_threshold, indices[nseg][0], indices[nseg][1],\n ind_opt[nseg][0], ind_opt[nseg][1]) for nseg in\n range(n_segments_ann)]\n\n\n\n msg = 'Patch-wise least-square combination and subtraction:'\n # reverse order of processing, as outer segments take longer\n res_patch = pool_map(nproc, _leastsq_patch, iterable(ayxyx[::-1]),\n angle_list_t,scale_list_t,fwhm,cube_rot_scale, None, metric, dist_threshold,delta_sep,\n solver, tol, verbose=verbose, msg=msg,\n progressbar_single=True)\n\n for patch in res_patch:\n matrix_res, yy, xx = patch\n cube_res[:, yy, xx] = matrix_res\n \n cube_der=rot_scale('fin',cube,cube_res,angle_list_t,scale_list_t, imlib, interpolation)\n frame_der_median = cube_collapse(cube_der, collapse)\n\n if verbose:\n print('Done processing annuli')\n\n return cube_der, frame_der_median\n\n\ndef _leastsq_patch(ayxyx, angle_list,scale_list,fwhm,cube, nann,metric, dist_threshold,delta_sep,\n solver, tol,formod=False,psf=None):\n\n \"\"\"\n Function allowing th estimation of the optimal factors for the modeled speckle field\n estimation via the LOCI framework. The code has been developped based on the VIP \n python function _leastsq_patch, but return additionnaly the set of coefficients used for\n the speckle field computation.\n \"\"\"\n \n ann_center,pa_threshold, yy, xx, yy_opti, xx_opti = ayxyx\n \n ind_ref_list=[]\n coef_list=[]\n \n yy_opt=[]\n xx_opt=[]\n \n for j in range(0,len(yy_opti)):\n if not any(x in np.where(yy==yy_opti[j])[0] for x in np.where(xx==xx_opti[j])[0]):\n xx_opt.append(xx_opti[j])\n yy_opt.append(yy_opti[j])\n \n\n values = cube[:, yy, xx] \n matrix_res = np.zeros((values.shape[0], yy.shape[0]))\n values_opt = cube[:, yy_opti, xx_opti]\n n_frames = cube.shape[0]\n\n\n for i in range(n_frames):\n \n if scale_list is not None:\n \n ind_fr_i = np.intersect1d(_find_indices_adi(angle_list, i,\n pa_threshold, truncate=False),_find_indices_sdi(scale_list, ann_center, i,\n fwhm, delta_sep))\n else:\n ind_fr_i = _find_indices_adi(angle_list, i,\n pa_threshold, truncate=False)\n if len(ind_fr_i) > 0:\n A = values_opt[ind_fr_i]\n b = values_opt[i]\n if solver == 'lstsq':\n coef = np.linalg.lstsq(A.T, b, rcond=tol)[0] # SVD method\n elif solver == 'nnls':\n coef = sp.optimize.nnls(A.T, b)[0]\n elif solver == 'lsq': \n coef = sp.optimize.lsq_linear(A.T, b, bounds=(0, 1),\n method='trf',\n lsq_solver='lsmr')['x']\n else:\n raise ValueError(\"`solver` not recognized\")\n else:\n msg = \"No frames left in the reference set. Try increasing \"\n msg += \"`dist_threshold` or decreasing `delta_rot`.\"\n raise RuntimeError(msg)\n\n\n if formod==True:\n ind_ref_list.append(ind_fr_i)\n coef_list.append(coef) \n \n recon = np.dot(coef, values[ind_fr_i])\n matrix_res[i] = values[i] - recon\n \n if formod==True:\n return matrix_res,ind_ref_list,coef_list, yy, xx,\n else:\n return matrix_res, yy,xx\n \n \ndef llsg_adisdi(cube, angle_list,scale_list, fwhm, rank=10, thresh=1, max_iter=10,\n low_rank_ref=False, low_rank_mode='svd', auto_rank_mode='noise',\n residuals_tol=1e-1, cevr=0.9, thresh_mode='soft', nproc=1,\n asize=None, n_segments=4, azimuth_overlap=None, radius_int=None,\n random_seed=None, imlib='opencv', interpolation='lanczos4',\n high_pass=None, collapse='median', full_output=True, verbose=True,\n debug=False):\n \n \"\"\" Local low rank plus Gaussian PSF subtraction for ADI or ADI+SDI. This \n code is an adaptation of the VIP llsg function.\n \"\"\"\n \n cube_rot_scale,angle_list_t,scale_list_t=rot_scale('ini',cube,None,angle_list,scale_list,imlib, interpolation)\n \n list_l, list_s, list_g, f_l, frame_fin, f_g = vip.llsg.llsg(cube_rot_scale, angle_list_t, fwhm, rank=rank,asize=asize, thresh=1,n_segments=n_segments, max_iter=40, random_seed=10, nproc=nproc,full_output=True,verbose=False)\n res_s=np.array(list_s)\n residuals_cube_=cube_derotate(res_s[0],-angle_list_t)\n cube_der=rot_scale('fin',cube,residuals_cube_,angle_list_t,scale_list_t, imlib, interpolation)\n frame_fin=cube_collapse(cube_der, collapse)\n return cube_der,frame_fin\n \n\ndef _decompose_patch(indices, i_patch,cube_init, n_segments_ann, rank, low_rank_ref,\n low_rank_mode, thresh, thresh_mode, max_iter,\n auto_rank_mode, cevr, residuals_tol, random_seed,\n debug=False, full_output=False):\n \n\n \"\"\" Patch decomposition from the LLSG VIP function.\n \"\"\"\n \n j = i_patch\n yy = indices[j][0]\n xx = indices[j][1]\n data_segm = cube_init[:, yy, xx]\n\n if low_rank_ref:\n ref_segments = list(range(n_segments_ann))\n ref_segments.pop(j)\n for m, n in enumerate(ref_segments):\n if m == 0:\n yy_ref = indices[n][0]\n xx_ref = indices[n][1]\n else:\n yy_ref = np.hstack((yy_ref, indices[n][0]))\n xx_ref = np.hstack((xx_ref, indices[n][1]))\n data_ref = cube_init[:, yy_ref, xx_ref]\n else:\n data_ref = data_segm\n\n patch = _patch_rlrps(data_segm, data_ref, rank, low_rank_ref,\n low_rank_mode, thresh, thresh_mode,\n max_iter, auto_rank_mode, cevr,\n residuals_tol, random_seed, debug=debug,\n full_output=full_output)\n return patch\n\n_largenumber = 1E100\n_smallnumber = 1E-5\n\nclass NMF:\n \"\"\"\n Nonnegative Matrix Factorization - Build a set of nonnegative basis components given \n a dataset with Heteroscedastic uncertainties and missing data with a vectorized update rule.\n Algorithm:\n -- Iterative multiplicative update rule\n Input: \n -- X: m x n matrix, the dataset\n Optional Input/Output: \n -- n_components: desired size of the basis set, default 5\n -- V: m x n matrix, the weight, (usually) the inverse variance\n -- M: m x n binary matrix, the mask, False means missing/undesired data\n -- H: n_components x n matrix, the H matrix, usually interpreted as the coefficients\n -- W: m x n_components matrix, the W matrix, usually interpreted as the basis set\n Comments:\n -- Between W and H, which one is the basis set and which one is the coefficient \n depends on how you interpret the data, because you can simply transpose everything\n as in X-WH versus X^T - (H^T)(W^T)\n -- Everything needs to be non-negative\n References:\n -- Guangtun Ben Zhu, 2016\n A Vectorized Algorithm for Nonnegative Matrix Factorization with \n Heteroskedastic Uncertainties and Missing Data\n AJ/PASP, (to be submitted)\n -- Blanton, M. and Roweis, S. 2007\n K-corrections and Filter Transformations in the Ultraviolet, Optical, and Near-infrared\n The Astronomical Journal, 133, 734\n -- Lee, D. D., & Seung, H. S., 2001\n Algorithms for non-negative matrix factorization\n Advances in neural information processing systems, pp. 556-562\n \"\"\"\n\n def __init__(self, X, W=None, H=None, V=None, M=None, n_components=5):\n \"\"\"\n Initialization\n \n Required Input:\n X -- the input data set\n Optional Input/Output:\n -- n_components: desired size of the basis set, default 5\n -- V: m x n matrix, the weight, (usually) the inverse variance\n -- M: m x n binary matrix, the mask, False means missing/undesired data\n -- H: n_components x n matrix, the H matrix, usually interpreted as the coefficients\n -- W: m x n_components matrix, the W matrix, usually interpreted as the basis set\n \"\"\"\n\n # I'm making a copy for the safety of everything; should not be a bottleneck\n self.X = np.copy(X) \n if (np.count_nonzero(self.X<0)>0):\n print(\"There are negative values in X. Setting them to be zero...\", flush=True)\n self.X[self.X<0] = 0.\n\n self.n_components = n_components\n self.maxiters = 100\n self.tol = _smallnumber\n np.random.seed(10)\n if (W is None):\n self.W = np.random.rand(self.X.shape[0], self.n_components)\n else:\n if (W.shape != (self.X.shape[0], self.n_components)):\n raise ValueError(\"Initial W has wrong shape.\")\n self.W = np.copy(W)\n if (np.count_nonzero(self.W<0)>0):\n print(\"There are negative values in W. Setting them to be zero...\", flush=True)\n self.W[self.W<0] = 0.\n\n if (H is None):\n self.H = np.random.rand(self.n_components, self.X.shape[1])\n else:\n if (H.shape != (self.n_components, self.X.shape[1])):\n raise ValueError(\"Initial H has wrong shape.\")\n self.H = np.copy(H)\n if (np.count_nonzero(self.H<0)>0):\n print(\"There are negative values in H. Setting them to be zero...\", flush=True)\n self.H[self.H<0] = 0.\n\n if (V is None):\n self.V = np.ones(self.X.shape)\n else:\n if (V.shape != self.X.shape):\n raise ValueError(\"Initial V(Weight) has wrong shape.\")\n self.V = np.copy(V)\n if (np.count_nonzero(self.V<0)>0):\n print(\"There are negative values in V. Setting them to be zero...\", flush=True)\n self.V[self.V<0] = 0.\n\n if (M is None):\n self.M = np.ones(self.X.shape, dtype=np.bool)\n else:\n if (M.shape != self.X.shape):\n raise ValueError(\"M(ask) has wrong shape.\")\n if (M.dtype != np.bool):\n raise TypeError(\"M(ask) needs to be boolean.\")\n self.M = np.copy(M)\n\n # Set masked elements to be zero\n self.V[(self.V*self.M)<=0] = 0\n self.V_size = np.count_nonzero(self.V)\n\n @property\n def cost(self):\n \"\"\"\n Total cost of a given set s\n \"\"\"\n diff = self.X - np.dot(self.W, self.H)\n chi2 = np.einsum('ij,ij', self.V*diff, diff)/self.V_size\n return chi2\n\n def SolveNMF(self, W_only=False, H_only=False, maxiters=None, tol=None):\n \"\"\"\n Construct the NMF basis\n Keywords:\n -- W_only: Only update W, assuming H is known\n -- H_only: Only update H, assuming W is known\n -- Only one of them can be set\n Optional Input:\n -- tol: convergence criterion, default 1E-5\n -- maxiters: allowed maximum number of iterations, default 1000\n Output: \n -- chi2: reduced final cost\n -- time_used: time used in this run\n \"\"\"\n\n\n if (maxiters is not None): \n self.maxiters = maxiters\n if (tol is not None):\n self.tol = tol\n\n chi2 = self.cost\n oldchi2 = _largenumber\n\n if (W_only and H_only):\n return (chi2, 0.)\n\n V = np.copy(self.V)\n VT = V.T\n\n #XV = self.X*self.V\n XV = np.multiply(V, self.X)\n XVT = np.multiply(VT, self.X.T)\n\n niter = 0\n\n while (niter < self.maxiters) and ((oldchi2-chi2)/oldchi2 > self.tol):\n\n # Update H\n if (not W_only):\n H_up = np.dot(XVT, self.W)\n WHVT = np.multiply(VT, np.dot(self.W, self.H).T)\n H_down = np.dot(WHVT, self.W)\n self.H = self.H*H_up.T/H_down.T\n\n # Update W\n if (not H_only):\n W_up = np.dot(XV, self.H.T)\n WHV = np.multiply(V, np.dot(self.W, self.H))\n W_down = np.dot(WHV, self.H.T)\n self.W = self.W*W_up/W_down\n\n # chi2\n oldchi2 = chi2\n chi2 = self.cost\n\n return\n \n\n", "meta": {"hexsha": "733a0eff21e557f8f32c9d92815d4f668db0c2d8", "size": 47930, "ext": "py", "lang": "Python", "max_stars_repo_path": "PyRSM/utils.py", "max_stars_repo_name": "chdahlqvist/RSMmap", "max_stars_repo_head_hexsha": "53984967d612eaf4feb90ba4972109638f6cf70a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-05-18T16:40:13.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-17T15:32:31.000Z", "max_issues_repo_path": "PyRSM/utils.py", "max_issues_repo_name": "chdahlqvist/RSMmap", "max_issues_repo_head_hexsha": "53984967d612eaf4feb90ba4972109638f6cf70a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "PyRSM/utils.py", "max_forks_repo_name": "chdahlqvist/RSMmap", "max_forks_repo_head_hexsha": "53984967d612eaf4feb90ba4972109638f6cf70a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-01-19T11:04:21.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-19T11:04:21.000Z", "avg_line_length": 38.5909822866, "max_line_length": 242, "alphanum_fraction": 0.6145420405, "include": true, "reason": "import numpy,import scipy,from scipy", "num_tokens": 12057, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5926665999540698, "lm_q2_score": 0.33458944125318596, "lm_q1q2_score": 0.1982999865280577}} {"text": "\"\"\"\nContains numerical kernel for Seismic FDFD class\n\"\"\"\n\nimport numpy\nimport scipy\nimport scipy.sparse\nimport SimPEG\nimport shutil, os, errno\nfrom IPython.parallel import require, interactive, Reference\n\nDEFAULT_FREESURF_BOUNDS = [False, False, False, False]\nDEFAULT_PML_SIZE = 10\nDEFAULT_IREG = 4\nDEFAULT_DTYPE = 'double'\n\ntry:\n from pymatsolver import MumpsSolver\n DEFAULT_SOLVER = MumpsSolver\nexcept:\n DEFAULT_SOLVER = SimPEG.SolverWrapD(scipy.sparse.linalg.splu)\n\nclass SeisFDFDKernel(object):\n\n # source array ref\n\n # receiver array ref\n\n mesh = None\n freq = None\n Solver = lambda: None\n\n\n def __init__(self, systemConfig, **kwargs):\n\n if systemConfig.get('cache', False):\n try:\n from tempfile import mkdtemp\n from joblib import Memory\n except ImportError:\n pass\n else:\n if 'cacheDir' in systemConfig:\n cacheDir = systemConfig['cacheDir']\n try:\n os.makedirs(cacheDir)\n except OSError as e:\n if e.errno == errno.EEXIST and os.path.isdir(cacheDir):\n pass\n else:\n raise\n else:\n cacheDir = mkdtemp()\n\n self._mem = Memory(cachedir=cacheDir, verbose=0)\n\n # Cache outputs of these methods\n self.forward = self._mem.cache(self.forward)\n self.backprop = self._mem.cache(self.backprop)\n\n hx = [(systemConfig['dx'], systemConfig['nx']-1)]\n hz = [(systemConfig['dz'], systemConfig['nz']-1)]\n self.mesh = SimPEG.Mesh.TensorMesh([hx, hz], '00')\n\n self.mesh.ireg = systemConfig.get('ireg', DEFAULT_IREG)\n self.mesh.freeSurf = systemConfig.get('freeSurf', DEFAULT_FREESURF_BOUNDS)\n\n initMap = {\n # Argument Rename to Property\n 'c': 'cR',\n 'Q': None,\n 'rho': None,\n 'nPML': None,\n 'freeSurf': None,\n 'freq': None,\n 'ky': None,\n 'kyweight': None,\n 'Solver': None,\n 'dx': None,\n 'dz': None,\n 'dtype': None,\n }\n\n for key in initMap.keys():\n if key in systemConfig:\n if initMap[key] is None:\n setattr(self, key, systemConfig[key])\n else:\n setattr(self, initMap[key], systemConfig[key])\n\n def __del__(self):\n if hasattr(self, '_mem'):\n self._mem.clear()\n cacheDir = self._mem.cachedir\n del self._mem\n shutil.rmtree(cacheDir)\n\n\n # Model properties\n\n @property\n def c(self):\n return self.cR + self.cI\n @c.setter\n def c(self, value):\n self._cR = value.real\n self._cI = value.imag\n self._invalidateMatrix()\n\n @property\n def rho(self):\n if getattr(self, '_rho', None) is None:\n self._rho = 310 * self.c**0.25\n return self._rho\n @rho.setter\n def rho(self, value):\n self._rho = value\n self._invalidateMatrix()\n\n @property\n def Q(self):\n if getattr(self, '_Q', None) is None:\n self._Q = numpy.inf\n return self._Q\n @Q.setter\n def Q(self, value):\n self._Q = value\n self._invalidateMatrix()\n\n @property\n def cR(self):\n return self._cR\n @cR.setter\n def cR(self, value):\n self._cR = value\n self._invalidateMatrix()\n \n @property\n def cI(self):\n if self.Q is numpy.inf:\n return 0\n else:\n return 1j * self.cR / (2*self.Q)\n @cI.setter\n def cI(self, value):\n if (value == 0).all():\n self._Q = numpy.inf\n else:\n self._Q = 1j * self.cR / (2*value)\n self._invalidateMatrix()\n\n # Modelling properties\n\n @property\n def nPML(self):\n if getattr(self, '_nPML', None) is None:\n self._nPML = DEFAULT_PML_SIZE\n return self._nPML\n @nPML.setter\n def nPML(self, value):\n self._nPML = value\n self._invalidateMatrix()\n\n @property\n def ky(self):\n if getattr(self, '_ky', None) is None:\n self._ky = 0.\n return self._ky\n @ky.setter\n def ky(self, value):\n self._ky = value\n self._invalidateMatrix()\n\n @property\n def kyweight(self):\n if getattr(self, '_kyweight', None) is None:\n self._kyweight = 1.\n return self._kyweight\n @kyweight.setter\n def kyweight(self, value):\n self._kyweight = value\n self._invalidateMatrix()\n\n # Clever matrix setup properties\n\n @property\n def Solver(self):\n if getattr(self, '_Solver', None) is None:\n self._Solver = DEFAULT_SOLVER\n return self._Solver\n @Solver.setter\n def Solver(self, value):\n self._Solver = value\n\n @property\n def A(self):\n if getattr(self, '_A', None) is None:\n self._A = self._initHelmholtzNinePoint()\n return self._A\n\n @property\n def Ainv(self):\n if getattr(self, '_Ainv', None) is None:\n self._mfact()\n return self._Ainv\n\n def _invalidateMatrix(self):\n if getattr(self, '_A', None) is not None:\n del(self._A)\n if getattr(self, '_Ainv', None) is not None:\n del(self._Ainv)\n if getattr(self, '_mem', None) is not None:\n self._mem.clear()\n\n @property\n def dtypeReal(self):\n if self.dtype == 'float':\n return numpy.float32\n elif self.dtype == 'double':\n return numpy.float64\n else:\n raise NotImplementedError('Unknown dtype: %s'%self.dtype)\n\n @property\n def dtypeComplex(self):\n if self.dtype == 'float':\n return numpy.complex64\n elif self.dtype == 'double':\n return numpy.complex128\n else:\n raise NotImplementedError('Unknown dtype: %s'%self.dtype)\n\n @property\n def dtype(self):\n return getattr(self, '_dtype', DEFAULT_DTYPE)\n @dtype.setter\n def dtype(self, value):\n # Currently this doesn't work because all the solvers assume doubles\n # if value in ['float', 'double']:\n if value in ['double']:\n self._dtype = value\n else:\n raise NotImplementedError('Unknown dtype: %s'%value)\n\n # ------------------------------------------------------------------------\n # Matrix setup\n\n def _mfact(self):\n self._Ainv = self.Solver(self.A)\n\n def _initHelmholtzNinePoint(self):\n \"\"\"\n An attempt to reproduce the finite-difference stencil and the\n general behaviour of OMEGA by Pratt et al. The stencil is a 9-point\n second-order version based on work by a number of people in the mid-90s\n including Ivan Stekl. The boundary conditions are based on the PML\n implementation by Steve Roecker in fdfdpml.f.\n \"\"\"\n\n # Set up SimPEG mesh\n dims = (self.mesh.nNy, self.mesh.nNx)\n # mAve = self.mesh.aveN2CC\n\n # c = (mAve.T * self.c.ravel()).reshape(dims)\n # rho = (mAve.T * self.rho.ravel()).reshape(dims)\n\n c = self.c\n rho = self.rho\n\n # fast --> slow is x --> y --> z as Fortran\n\n # Set up physical properties in matrices with padding\n omega = 2 * numpy.pi * self.freq \n cPad = numpy.pad(c, pad_width=1, mode='edge')\n rhoPad = numpy.pad(rho, pad_width=1, mode='edge')\n\n aky = 2*numpy.pi*self.ky\n\n # Model parameter M\n K = ((omega**2 / cPad**2) - aky**2) / rhoPad\n\n # Horizontal, vertical and diagonal geometry terms\n dx = self.mesh.hx[0]\n dz = self.mesh.hy[0]\n dxx = dx**2\n dzz = dz**2\n dxz = dx*dz\n dd = numpy.sqrt(dxz)\n\n # PML decay terms\n # NB: Arrays are padded later, but 'c' in these lines\n # comes from the original (un-padded) version\n\n nPML = self.nPML\n\n pmldx = dx*(nPML - 1)\n pmldz = dz*(nPML - 1)\n pmlr = 1e-3\n pmlfx = 3.0 * numpy.log(1/pmlr)/(2*pmldx**3)\n pmlfz = 3.0 * numpy.log(1/pmlr)/(2*pmldz**3)\n\n dpmlx = numpy.zeros(dims, dtype=self.dtypeComplex)\n dpmlz = numpy.zeros(dims, dtype=self.dtypeComplex)\n isnx = numpy.zeros(dims, dtype=self.dtypeReal)\n isnz = numpy.zeros(dims, dtype=self.dtypeReal)\n\n # Only enable PML if the free surface isn't set\n\n freeSurf = self.mesh.freeSurf\n\n if freeSurf[0]: \n isnz[-nPML:,:] = -1 # Top\n\n if freeSurf[1]:\n isnx[:,-nPML:] = -1 # Right Side\n\n if freeSurf[2]:\n isnz[:nPML,:] = 1 # Bottom\n\n if freeSurf[3]:\n isnx[:,:nPML] = 1 # Left side\n\n dpmlx[:,:nPML] = (numpy.arange(nPML, 0, -1)*dx).reshape((1,nPML))\n dpmlx[:,-nPML:] = (numpy.arange(1, nPML+1, 1)*dx).reshape((1,nPML))\n dnx = pmlfx*c*dpmlx**2\n ddnx = 2*pmlfx*c*dpmlx\n denx = dnx + 1j*omega\n r1x = 1j*omega / denx\n r1xsq = r1x**2\n r2x = isnx*r1xsq*ddnx/denx\n\n dpmlz[:nPML,:] = (numpy.arange(nPML, 0, -1)*dz).reshape((nPML,1))\n dpmlz[-nPML:,:] = (numpy.arange(1, nPML+1, 1)*dz).reshape((nPML,1))\n dnz = pmlfz*c*dpmlz**2\n ddnz = 2*pmlfz*c*dpmlz\n denz = dnz + 1j*omega\n r1z = 1j*omega / denz\n r1zsq = r1z**2\n r2z = isnz*r1zsq*ddnz/denz\n\n # Visual key for finite-difference terms\n # (per Pratt and Worthington, 1990)\n #\n # This Original\n # AF FF CF vs. AD DD CD\n # AA BE CC vs. AA BE CC\n # AD DD CD vs. AF FF CF\n\n # Set of keys to index the dictionaries\n keys = ['AD', 'DD', 'CD', 'AA', 'BE', 'CC', 'AF', 'FF', 'CF']\n\n # Diagonal offsets for the sparse matrix formation\n offsets = {\n 'AD': (-1) * dims[1] + (-1), \n 'DD': (-1) * dims[1] + ( 0),\n 'CD': (-1) * dims[1] + (+1),\n 'AA': ( 0) * dims[1] + (-1),\n 'BE': ( 0) * dims[1] + ( 0),\n 'CC': ( 0) * dims[1] + (+1),\n 'AF': (+1) * dims[1] + (-1),\n 'FF': (+1) * dims[1] + ( 0),\n 'CF': (+1) * dims[1] + (+1),\n }\n\n # Buoyancies\n bMM = 1. / rhoPad[0:-2,0:-2] # bottom left\n bME = 1. / rhoPad[0:-2,1:-1] # bottom centre\n bMP = 1. / rhoPad[0:-2,2: ] # bottom right\n bEM = 1. / rhoPad[1:-1,0:-2] # middle left\n bEE = 1. / rhoPad[1:-1,1:-1] # middle centre\n bEP = 1. / rhoPad[1:-1,2: ] # middle right\n bPM = 1. / rhoPad[2: ,0:-2] # top left\n bPE = 1. / rhoPad[2: ,1:-1] # top centre\n bPP = 1. / rhoPad[2: ,2: ] # top right\n\n # Initialize averaged buoyancies on most of the grid\n bMM = (bEE + bMM) / 2 # a2\n bME = (bEE + bME) / 2 # d1\n bMP = (bEE + bMP) / 2 # d2\n bEM = (bEE + bEM) / 2 # a1\n # ... middle\n bEP = (bEE + bEP) / 2 # c1\n bPM = (bEE + bPM) / 2 # f2\n bPE = (bEE + bPE) / 2 # f1\n bPP = (bEE + bPP) / 2 # c2\n\n # Reset the buoyancies on the outside edges\n # bMM[ 0, :] = bEE[ 0, :]\n # bMM[ :, 0] = bEE[ :, 0]\n # bME[ 0, :] = bEE[ 0, :]\n # bMP[ 0, :] = bEE[ 0, :]\n # bMP[ :,-1] = bEE[ :,-1]\n # bEM[ :, 0] = bEE[ :, 0]\n # bEP[ :,-1] = bEE[ :,-1]\n # bPM[-1, :] = bEE[-1, :]\n # bPM[ :, 0] = bEE[ :, 0]\n # bPE[-1, :] = bEE[-1, :]\n # bPP[-1, :] = bEE[-1, :]\n # bPP[ :,-1] = bEE[ :,-1]\n\n # K = omega^2/(c^2 . rho)\n kMM = K[0:-2,0:-2] # bottom left\n kME = K[0:-2,1:-1] # bottom centre\n kMP = K[0:-2,2: ] # bottom centre\n kEM = K[1:-1,0:-2] # middle left\n kEE = K[1:-1,1:-1] # middle centre\n kEP = K[1:-1,2: ] # middle right\n kPM = K[2: ,0:-2] # top left\n kPE = K[2: ,1:-1] # top centre\n kPP = K[2: ,2: ] # top right\n\n # 9-point fd star\n acoef = 0.5461\n bcoef = 0.4539\n ccoef = 0.6248\n dcoef = 0.09381\n ecoef = 0.000001297\n\n # 5-point fd star\n # acoef = 1.0\n # bcoef = 0.0\n # ecoef = 0.0\n\n # NB: bPM and bMP here are switched relative to S. Roecker's version\n # in OMEGA. This is because the labelling herein is always ?ZX.\n\n diagonals = {\n 'AD': ecoef*kMM\n + bcoef*bMM*((r1zsq+r1xsq)/(4*dxz) - (r2z+r2x)/(4*dd)),\n 'DD': dcoef*kME\n + acoef*bME*(r1zsq/dz - r2z/2)/dz\n + bcoef*(r1zsq-r1xsq)*(bMP+bMM)/(4*dxz),\n 'CD': ecoef*kMP\n + bcoef*bMP*((r1zsq+r1xsq)/(4*dxz) - (r2z+r2x)/(4*dd)),\n 'AA': dcoef*kEM\n + acoef*bEM*(r1xsq/dx - r2x/2)/dx\n + bcoef*(r1xsq-r1zsq)*(bPM+bMM)/(4*dxz),\n 'BE': ccoef*kEE\n + acoef*(r2x*(bEM-bEP)/(2*dx) + r2z*(bME-bPE)/(2*dz) - r1xsq*(bEM+bEP)/dxx - r1zsq*(bME+bPE)/dzz)\n + bcoef*(((r2x+r2z)*(bMM-bPP) + (r2z-r2x)*(bMP-bPM))/(4*dd) - (r1xsq+r1zsq)*(bMM+bPP+bPM+bMP)/(4*dxz)),\n 'CC': dcoef*kEP\n + acoef*bEP*(r1xsq/dx + r2x/2)/dx\n + bcoef*(r1xsq-r1zsq)*(bMP+bPP)/(4*dxz),\n 'AF': ecoef*kPM\n + bcoef*bPM*((r1zsq+r1xsq)/(4*dxz) - (r2z+r2x)/(4*dd)),\n 'FF': dcoef*kPE\n + acoef*bPE*(r1zsq/dz - r2z/2)/dz\n + bcoef*(r1zsq-r1xsq)*(bPM+bPP)/(4*dxz),\n 'CF': ecoef*kPP\n + bcoef*bPP*((r1zsq+r1xsq)/(4*dxz) - (r2z+r2x)/(4*dd)),\n }\n\n diagonals['AD'] = diagonals['AD'].ravel()[dims[1]+1: ]\n diagonals['DD'] = diagonals['DD'].ravel()[dims[1] : ]\n diagonals['CD'] = diagonals['CD'].ravel()[dims[1]-1: ]\n diagonals['AA'] = diagonals['AA'].ravel()[ 1: ]\n diagonals['BE'] = diagonals['BE'].ravel()[ : ]\n diagonals['CC'] = diagonals['CC'].ravel()[ :-1 ]\n diagonals['AF'] = diagonals['AF'].ravel()[ :-dims[1]+1]\n diagonals['FF'] = diagonals['FF'].ravel()[ :-dims[1] ]\n diagonals['CF'] = diagonals['CF'].ravel()[ :-dims[1]-1]\n\n # self._setupBoundary(diagonals, freeSurf)\n if any(freeSurf):\n raise NotImplementedError('Free surface not implemented!')\n\n # for key in diagonals.keys():\n # print('%s:\\t%d\\t%d'%(key, diagonals[key].size, offsets[key]))\n\n diagonals = [diagonals[key] for key in keys]\n offsets = [offsets[key] for key in keys]\n\n A = scipy.sparse.diags(diagonals, offsets, shape=(self.mesh.nN, self.mesh.nN), format='csr', dtype=self.dtypeComplex)#, shape=(self.mesh.nN, self.mesh.nN))#, self.mesh.nN, self.mesh.nN, format='csr')\n\n return A\n\n # def _setupBoundary(self, diagonals, freeSurf):\n # \"\"\"\n # Function to set up boundary regions for the Seismic FDFD problem\n # using the 9-point finite-difference stencil from OMEGA/FULLWV.\n # \"\"\"\n\n # keys = diagonals.keys()\n # pickDiag = lambda x: -1. if freeSurf[x] else 1.\n\n # # Left\n # for key in keys:\n # if key is 'BE':\n # diagonals[key][:,0] = pickDiag(3)\n # else:\n # diagonals[key][:,0] = 0.\n\n # # Right\n # for key in keys:\n # if key is 'BE':\n # diagonals[key][:,-1] = pickDiag(1)\n # else:\n # diagonals[key][:,-1] = 0.\n\n # # Bottom\n # for key in keys:\n # if key is 'BE':\n # diagonals[key][0,:] = pickDiag(2)\n # else:\n # diagonals[key][0,:] = 0.\n\n # # Top\n # for key in keys:\n # if key is 'BE':\n # diagonals[key][-1,:] = pickDiag(0)\n # else:\n # diagonals[key][-1,:] = 0.\n\n # ------------------------------------------------------------------------\n # Externally-callable functions\n\n def clear(self):\n self._invalidateMatrix()\n \n # What about @caching decorators?\n def forward(self, src, dOnly=True):\n\n q = self.kyweight * src.getq(self.mesh)\n u = self.Ainv * q\n\n d = numpy.array([numpy.dot(P,u) for P in src.getP(self.mesh, self.ky)]).ravel()\n\n if dOnly:\n return d\n else:\n return u, d\n\n def backprop(self, src, dresid=1.):\n\n qr = self.kyweight * src.getqback(self.mesh, dresid, self.ky)\n u = self.Ainv * qr\n\n return u\n\n # def gradient(self, isrc, sterm, dresid):\n\n # uF, d = self.forward(isrc, False, sterm)\n # uB = self.backprop(isrc, dresid)\n\n # return uF * uB\n\n", "meta": {"hexsha": "69677cefec1956aff7802dd8ff84abd8b7d57fb1", "size": 17157, "ext": "py", "lang": "Python", "max_stars_repo_path": "zephyr/Kernel.py", "max_stars_repo_name": "bsmithyman/zephyr", "max_stars_repo_head_hexsha": "ef74caadd74cc357b503560c3800e26c49587e61", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-04-06T18:31:16.000Z", "max_stars_repo_stars_event_max_datetime": "2019-04-06T18:31:16.000Z", "max_issues_repo_path": "zephyr/Kernel.py", "max_issues_repo_name": "bsmithyman/zephyr", "max_issues_repo_head_hexsha": "ef74caadd74cc357b503560c3800e26c49587e61", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "zephyr/Kernel.py", "max_forks_repo_name": "bsmithyman/zephyr", "max_forks_repo_head_hexsha": "ef74caadd74cc357b503560c3800e26c49587e61", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2015-02-24T15:03:54.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-08T20:18:56.000Z", "avg_line_length": 31.365630713, "max_line_length": 207, "alphanum_fraction": 0.4851081191, "include": true, "reason": "import numpy,import scipy", "num_tokens": 5234, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6113819732941511, "lm_q2_score": 0.3242354055108441, "lm_q1q2_score": 0.19823168203304917}} {"text": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Thu Jun 6 09:37:12 2019\n\n@author: bressler\n\"\"\"\n\nimport SBCcode as sbc\nfrom os import listdir\nfrom os.path import isfile,join\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport scipy\nfrom gaincalc import get_gain\nimport pulse_integrator as pi\nfrom runlistscatalogue import *\nimport gc\n\nCONVERSION_TO_CHARGE = (125.0/128)*(1/50.0)*(1/1000.0)*(1/(1.602e-19))\n\ndef trig_difference(runs):\n pmtdiffs = []\n pmtnobubdiffs = []\n dubbubdiffs = []\n for run in runs:\n print(run)\n runrawpath = \"/bluearc/storage/SBC-17-data/%s/\"%run\n runreconpath = \"/pnfs/coupp/persistent/grid_output/SBC-17/output/%s/\"%run\n acousticfilename = runreconpath+\"AcousticAnalysis_%s.bin\"%run\n getbubfile = \"/coupp/data/home/coupp/HumanGetBub_output_SBC-17/HumanGetBub_%s.bin\"%run\n a = sbc.DataHandling.ReadBinary.ReadBlock(acousticfilename)\n c = sbc.DataHandling.ReadBinary.ReadBlock(getbubfile)\n eventn = c[\"ev\"]\n bubt0 = a[\"bubble_t0\"]\n #events = [evnt for evnt in listdir(runrawpath) if not isfile(join(runrawpath,evnt))]\n #for x in events:\n for x in range(101):\n gc.collect()\n try:\n e = sbc.DataHandling.GetSBCEvent.GetEvent(runrawpath,x,'fastDAQ','PMTtraces')\n cgate = e[\"fastDAQ\"][\"CAMgate\"]\n dcam = np.diff(cgate)\n fdt = e[\"fastDAQ\"][\"time\"]\n camOffTimes = [fdt[i] for i in range(len(dcam)) if dcam[i] > 0.5]\n pmttracetime = e[\"PMTtraces\"][\"t0_sec\"][:,0]+e[\"PMTtraces\"][\"t0_frac\"][:,0]\n d=sbc.AnalysisModules.PMTfastDAQalignment.PMTandFastDAQalignment(e)\n pmtalign = d[\"PMT_trigt0_sec\"]+d[\"PMT_trigt0_frac\"]\n tracetimes = pmttracetime - pmtalign\n \n at0 = bubt0[int(x),0]\n for t in (tracetimes-at0):\n if t<0 and t>-500e-6:\n lastCamOff = 0\n for k in range(len(camOffTimes)):\n if t+at0 > camOffTimes[k]:\n lastCamOff = camOffTimes[k]\n elif t+at0 < camOffTimes[k]:\n break\n if t+at0-lastCamOff > 25e-6:\n if list(eventn).count(int(x)) == 2:\n pmtdiffs.append(t)\n elif list(eventn).count(int(x)) == 1:\n pmtnobubdiffs.append(t)\n elif list(eventn).count(int(x)) == 3:\n print(3)\n elif list(eventn).count(int(x)) == 4:\n dubbubdiffs.append(t)\n except:\n print(\"Last event: %d\"%(x-1))\n break\n\n return [pmtnobubdiffs,pmtdiffs,dubbubdiffs]\n \n\ndef zdependence(runs, m):\n #m = 1e7\n\n #m=get_gain(\"/bluearc/storage/SBC-17-data/\",runs[0])\n \n Ncoinc = [0,0]\n ntotcoinc = [0,0]\n totevents = [0,0]\n totbub = [0,0]\n diffs = [[],[]]\n goodz=[[],[]]\n pmtdiffs = [[],[]]\n coincspec = [[],[]]\n\n allxyzfname = \"/pnfs/coupp/persistent/grid_output/SBC-17/output/SimpleXYZ_all.bin\"\n xyzf = sbc.DataHandling.ReadBinary.ReadBlock(allxyzfname)\n for run in runs:\n print(\"zdependence processing run \"+run)\n indices = [i for i,x in enumerate(xyzf[\"runid\"]) if str(x[0])+\"_\"+str(x[1]) == run]\n runposreco = {\"ev\":[xyzf[\"ev\"][indices]],\"x\":[xyzf[\"bubX\"][indices]],\n \"y\":[xyzf[\"bubY\"][indices]],\"z\":[xyzf[\"bubZ\"][indices]]}\n runrawpath = \"/bluearc/storage/SBC-17-data/%s/\"%run\n runreconpath = \"/pnfs/coupp/persistent/grid_output/SBC-17/output/%s/\"%run\n acousticfilename = runreconpath+\"AcousticAnalysis_%s.bin\"%run\n a = sbc.DataHandling.ReadBinary.ReadBlock(acousticfilename)\n #c = sbc.DataHandling.ReadBinary.ReadBlock(getbubfile)\n bubt0 = a[\"bubble_t0\"]\n events = [evnt for evnt in listdir(runrawpath) if not isfile(join(runrawpath,evnt))]\n for j in [0,1]:\n with open(\"/nashome/b/bressler/sbcoutput/%s_PMTmatching_ch%s.txt\"%(run,str(j)),\"w+\") as f, open(\"/nashome/b/bressler/sbcoutput/%s_muonCoincidences.txt\"%run,'w+') as fmu:\n f.write(\"run event PMT_t0_index PMT_t0_-at0_us PMT_t0 at0 phe z\\n\")\n fmu.write(\"run event phe\\n\")\n for x in events:\n yes = False\n if int(x) 0.5]\n muon = False\n pmttracetime = e[\"PMTtraces\"][\"t0_sec\"][:,0]+e[\"PMTtraces\"][\"t0_frac\"][:,0]\n d=sbc.AnalysisModules.PMTfastDAQalignment.PMTandFastDAQalignment(e)\n pmtalign = d[\"PMT_trigt0_sec\"]+d[\"PMT_trigt0_frac\"]\n tracetimes = pmttracetime - pmtalign\n at0 = bubt0[int(x),j]\n i=0 # to match the indexing of the pre-made code I had 1???\n candidate = 0\n candidate_time = 0\n candidate_PMTtime = 0\n candidate_index = 0\n for t in (tracetimes-at0):\n # loop through every PMT trace for the event\n \n if t<-150e-6 and t>-600e-6: \n # if the trace time is within 500 microsec before acoustic t0\n if max(veto)>0.1:\n if fdt[list(veto).index(max(veto))]-at0<0 and fdt[list(veto).index(max(veto))]-at0>-500e-6:\n print(\"Veto Coincidence: event \"+run+\"-\"+str(x))\n muon = True\n \n #lastCamOff = 0\n #for k in range(len(camOffTimes)):\n # if t+at0 > camOffTimes[k]:\n # lastCamOff = camOffTimes[k]\n # elif t+at0 < camOffTimes[k]:\n # break\n #if t+at0-lastCamOff > 25e-6:\n # if the trace time is more than 25 microseconds away from a camera gate rise\n #but not doing it this way anymore because we'll check for the LED being on later during the merge\n ntotcoinc[j]+=1\n pmtdiffs.append(t)\n \n #take abs to get positive area:\n trace = np.fabs(e[\"PMTtraces\"][\"traces\"][i][0]) \n #if ch0 saturated, stitch in low res channel:\n if max(trace) == 128:\n trace = pi.stitchTraces(trace,np.fabs(e[\"PMTtraces\"][\"traces\"][i][1]))\n dt = e[\"PMTtraces\"][\"dt\"][i][0]\n \n #subtract baseline:\n #Actually this gets done in pulse_integrator anyway\n #baseline = np.mean(trace[0:50])\n #trace -= baseline \n \n #integrate and convert to phe:\n [phe,n,totInt,pktimes] = pi.SBC_pulse_integrator_bressler(trace,dt) \n if phe != None:\n phe /= m\n #keep track of largest candidate:\n if phe > candidate:\n candidate = phe\n candidate_time = t\n candidate_PMTtime = t+at0\n candidate_index = i\n #else:\n # candidate = -1.0\n i+=1\n #i.e. if there is a candidate PMT trace with area greater than zero\n if candidate > 0:\n Ncoinc[j] += 1\n ind = candidate_index\n pmtt = candidate_PMTtime\n diffs[j].append(candidate_time)\n goodz[j].append(runposreco[\"z\"][0][int(x)])\n coincspec[j].append(candidate)\n f.write(\"%s %s %d %f %f %f %f %f\\n\"%(run,x,ind,\n candidate_time*1e6,\n pmtt,at0,candidate,\n runposreco[\"z\"][0][int(x)]))\n if muon:\n fmu.write(\"%s %s %f\\n\"%(run,x,candidate))\n gc.collect()\n print(\"run \"+run+\" file %s written\"%str(j))\n #pmtdiffs.append(candidate_times[candidates.index(max(candidates))])\n print(\"total number of events: \"+str(totevents))\n print(\"total number of bubbles: \"+str(totbub)) \n print(\"total coincident triggers: \"+str(ntotcoinc))\n print(\"total coincident bubbles with scintillation greater than 0phe: \"+str(Ncoinc))\n print(\"fraction of bubbles with a coincident scintillation signal greater than 0phe: \"+str(sum(Ncoinc)*100/sum(totbub))+\"%\")\n \n return [goodz,diffs,coincspec,Ncoinc,ntotcoinc,totevents,totbub]\n \n\n \ndef main():\n bgruns = bgOct10and11\n \n biberuns = BiBeSept23and24\n \n \"\"\"\n ch1 files made for:\n \"20171003_4\",\"20171003_5\",\n \"20171004_0\",\"20171004_1\",\"20171004_2\",\"20171004_3\",\"20171004_4\",\n \"20171005_0\",\"20171005_1\",\"20171005_2\",\"20171005_3\",\"20171005_4\",\n \"20171006_0\",\"20171006_1\"\n \n ch0 files made for:\n \"20171003_4\",\"20171003_5\",\n \"20171004_0\",\"20171004_1\",\"20171004_2\",\"20171004_3\",\"20171004_4\",\n \"20171005_0\",\"20171005_1\",\"20171005_2\",\"20171005_3\",\"20171005_4\",\n \"20171006_0\",\"20171006_1\"\n \n \"\"\"\n \n BiAlruns = []\n \n \"\"\"\n ch1 files made for:\n \"20171006_2\",\"20171006_3\",\"20171006_4\",\"20171006_5\",\"20171007_0\",\n \"20171007_1\",\"20171007_2\",\"20171007_4\",\"20171007_5\",\n \"20171007_6\",\"20171008_0\",\"20171008_1\",\"20171008_4\",\"20171008_6\",\n \"20171008_7\",\"20171009_0\",\"20171009_1\",\"20171009_2\"\n \n ch0 files made for:\n \"20171006_2\",\"20171006_3\",\"20171006_4\",\"20171006_5\",\"20171007_0\",\n \"20171007_1\",\"20171007_2\",\"20171007_4\",\"20171007_5\",\n \"20171007_6\",\"20171008_0\",\"20171008_1\",\"20171008_4\",\"20171008_6\",\n \"20171008_7\",\"20171009_0\",\"20171009_1\",\"20171009_2\"\n \"\"\"\n\n cfruns = [\"20170711_15\",\"20170711_16\"]\n \"\"\"\n ch0 files made for:\n \"20170707_6\",\"20170707_7\",\"20170707_8\",\"20170707_9\",\"20170707_10\",\"20170708_0\",\n \"20170708_1\",\"20170708_3\",\"20170708_5\",\"20170708_6\",\"20170708_7\",\n \"20170708_8\",\"20170708_9\",\"20170709_0\",\"20170709_1\",\"20170709_2\",\n \"20170709_3\",\"20170709_4\",\"20170709_6\",\"20170709_7\",\"20170709_8\",\n \"20170710_0\",\"20170710_1\",\"20170710_2\",\"20170710_3\",\"20170710_4\",\n \"20170710_5\",\"20170710_6\",\"20170710_7\",\"20170710_8\",\"20170710_9\",\n \"20170711_0\",\"20170711_14\",\"20170711_16\"\n \n ch1 files made for:\n \n \"20170707_6\",\"20170707_7\",\"20170707_8\",\"20170707_9\",\"20170707_10\",\"20170708_0\",\n \"20170708_1\",\"20170708_3\",\"20170708_4\",\"20170708_5\",\"20170708_6\",\n \"20170708_7\",\"20170708_8\",\"20170708_9\",\"20170709_0\",\"20170709_1\",\"20170709_2\",\n \"20170709_3\",\"20170709_4\",\"20170709_6\",20170709_7\",\"20170709_8\",\n \"20170710_0\",\"20170710_1\",\"20170710_2\",\"20170710_3\",\"20170710_4\",\n \"20170710_5\",\"20170710_6\",\"20170710_7\",\"20170710_8\", \"20170710_9\",\"20170711_0\",\n \"20170711_14\",\"20170711_15\",\"20170711_16\"\n \n \n \n bad AcousticAnalysis_ .bin files:\n \"20170708_2\",\"20170708_4\",\n \"\"\"\n \n pmtnobubdiffs,pmtdiffs,dubbubdiffs = trig_difference(biberuns)\n goodz,diffs,coincspec,Ncoinc,ntotcoinc,totevents,totbub = zdependence(biberuns)\n \n bgpmtnobubdiffs,bgpmtdiffs,bgdubbubdiffs = trig_difference(bgruns)\n bggoodz,bgdiffs,bgcoincspec,bgNcoinc,bgntotcoinc,bgtotevents,bgtotbub = zdependence(bgruns)\n \n \"\"\"\n plt.figure()\n _,bins,_=plt.hist(pmtdiffs,150,histtype='step',label=\"one bubble\",lw=4)\n plt.hist(diffs,200,histtype='step')\n plt.hist(pmtnobubdiffs,bins,histtype='step', label = \"no bubble\",lw=4)\n plt.hist(dubbubdiffs,bins,histtype='step', label=\"two bubbles\",lw=4)\n plt.xlabel(\"PMT trigger times minus acoustic t_0\",fontsize=25)\n #plt.xlim([-100e-6,300e-6])\n plt.yscale('log')\n plt.legend(fontsize=18)\n plt.show\n \"\"\"\n def ft(x,m,b):\n return m*x +b\n \n params,params_cov = scipy.optimize.curve_fit(ft,goodz,diffs)\n p1 = params[0]\n p0 = params[1]\n print(\"the slope is\"+str(p1))\n print(\"The speed of sound is \"+str((1/np.fabs(p1))/100)+\" m/s\")\n \n plt.figure()\n plt.scatter(goodz,diffs)\n plt.plot(np.arange(-3,0.1,0.1),p0+p1*np.arange(-3,0.1,0.1),lw=3)\n plt.ylim([-500e-6, 0])\n plt.xlabel(\"z position (cm)\")\n plt.ylabel(\"time difference (seconds)\")\n plt.show\n \n \n \n plt.figure()\n vals,bins,_=plt.hist(coincspec,np.ceil(max(coincspec)),histtype='step',color='r')\n bgvals,_,_ = plt.hist(bgcoincspec,bins,histtype='step')\n plt.xlabel(\"spectrum of PMT pulse areas within 500 microseconds before acoustic t_0 (photoelectrons)\")\n plt.show\n\n plt.figure()\n plt.bar(bins[:(len(vals))],[v/totbub for v in vals],1,color='r',linewidth=0,label=\"californium\")\n plt.bar(bins[:len(vals)],[v/bgtotbub for v in bgvals],0.7,color='b',linewidth = 0,label=\"background\")\n plt.xlabel(\"spectrum of PMT pulse areas within 500 microseconds before acoustic t_0 (photoelectrons)\",fontsize=25)\n plt.ylabel(\"probability of a scintillation pulse of this area per bubble\",fontsize=25)\n plt.legend(fontsize=18)\n plt.show\n \nif __name__ == \"__main__\":\n main()\n", "meta": {"hexsha": "03d348f3ae8a55ae87004a3989bf9fc87b9aec28", "size": 15070, "ext": "py", "lang": "Python", "max_stars_repo_path": "UserCode/bressler/coincidentbubblescintillation.py", "max_stars_repo_name": "cericdahl/SBCcode", "max_stars_repo_head_hexsha": "90a7841a5c1208d64f71a332289d9005a011aa21", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2018-08-27T18:02:34.000Z", "max_stars_repo_stars_event_max_datetime": "2020-06-09T21:19:04.000Z", "max_issues_repo_path": "UserCode/bressler/coincidentbubblescintillation.py", "max_issues_repo_name": "SBC-Collaboration/SBC-Analysis", "max_issues_repo_head_hexsha": "90a7841a5c1208d64f71a332289d9005a011aa21", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "UserCode/bressler/coincidentbubblescintillation.py", "max_forks_repo_name": "SBC-Collaboration/SBC-Analysis", "max_forks_repo_head_hexsha": "90a7841a5c1208d64f71a332289d9005a011aa21", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2019-06-20T21:36:26.000Z", "max_forks_repo_forks_event_max_datetime": "2020-11-10T17:23:14.000Z", "avg_line_length": 46.801242236, "max_line_length": 181, "alphanum_fraction": 0.5122096881, "include": true, "reason": "import numpy,import scipy", "num_tokens": 4141, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6113819732941511, "lm_q2_score": 0.3242353989809524, "lm_q1q2_score": 0.19823167804079106}} {"text": "from __future__ import absolute_import\r\nfrom __future__ import print_function\r\n\r\nimport copy\r\nfrom collections import defaultdict\r\nimport numpy as np\r\nimport tensorflow as tf\r\nfrom tqdm import tqdm\r\nfrom six.moves import xrange\r\nimport sys\r\nsys.path.append('../../.')\r\nfrom cleverhans.utils import other_classes\r\nfrom cleverhans.utils_tf import model_argmax\r\nfrom cleverhans.evaluation import batch_eval\r\nfrom cleverhans.attacks_tf import (jacobian_graph, jacobian,\r\n apply_perturbations, saliency_map)\r\nimport keras.backend as K\r\nimport os\r\nimport pickle\r\n\r\ndef adaptive_fgsm(x, predictions, eps, clip_min=None, clip_max=None,\r\n log_dir=None, y=None, model_logits = None,\r\n alpha = None, dataset=None\r\n ):\r\n \"\"\"\r\n Computes symbolic TF tensor for the adversarial samples. This must\r\n be evaluated with a session.run call.\r\n :param x: the input placeholder\r\n :param predictions: the model's output tensor\r\n :param eps: the epsilon (input variation parameter)\r\n :param clip_min: optional parameter that can be used to set a minimum\r\n value for components of the example returned\r\n :param clip_max: optional parameter that can be used to set a maximum\r\n value for components of the example returned\r\n :param y: the output placeholder. Use None (the default) to avoid the\r\n label leaking effect.\r\n :return: a tensor for the adversarial example\r\n \"\"\"\r\n\r\n # Compute loss]\r\n logits, = predictions.op.inputs\r\n\r\n fingerprint_dir = log_dir\r\n fixed_dxs = pickle.load(open(os.path.join(fingerprint_dir, \"fp_inputs_dx.pkl\"), \"rb\"))\r\n fixed_dys = pickle.load(open(os.path.join(fingerprint_dir, \"fp_outputs.pkl\"), \"rb\"))\r\n\r\n if y is None:\r\n # In this case, use model predictions as ground truth\r\n y = tf.to_float(\r\n tf.equal(predictions,\r\n tf.reduce_max(predictions, 1, keep_dims=True)))\r\n\r\n output = logits\r\n pred_class = tf.argmax(y,axis=1)\r\n loss_fp = 0\r\n [a,b,c] = np.shape(fixed_dys)\r\n num_dx = b\r\n target_dys = tf.convert_to_tensor(fixed_dys)\r\n target_dys = (tf.gather(target_dys,pred_class))\r\n norms = tf.sqrt(tf.reduce_sum(tf.square(output), axis=1, keep_dims=True))\r\n norm_logits = output/norms\r\n\r\n for i in range(num_dx):\r\n logits_p = model_logits(x + fixed_dxs[i])\r\n p_norm = tf.sqrt(tf.reduce_sum(tf.square(logits_p), axis=1, keep_dims=True))\r\n logits_p_norm = logits_p/p_norm\r\n loss_fp = loss_fp + tf.losses.mean_squared_error((logits_p_norm - norm_logits),target_dys[:,i,:])\r\n #self appropriate fingerprint\r\n\r\n\r\n y = y / tf.reduce_sum(y, 1, keep_dims=True)\r\n loss_ce = tf.reduce_mean(\r\n tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=y)\r\n )\r\n ## Tune this alpha!!\r\n\r\n loss = loss_ce - alpha*loss_fp\r\n\r\n # Define gradient of loss wrt input\r\n grad, = tf.gradients(loss, x)\r\n\r\n # Take sign of gradient\r\n signed_grad = tf.sign(grad)\r\n\r\n # Multiply by constant epsilon\r\n scaled_signed_grad = eps * signed_grad\r\n\r\n # Add perturbation to original example to obtain adversarial example\r\n adv_x = tf.stop_gradient(x + scaled_signed_grad)\r\n\r\n # If clipping is needed, reset all values outside of [clip_min, clip_max]\r\n if (clip_min is not None) and (clip_max is not None):\r\n adv_x = tf.clip_by_value(adv_x, clip_min, clip_max)\r\n\r\n return adv_x\r\n\r\n\r\ndef adaptive_fast_gradient_sign_method(sess, model, X, Y, eps, clip_min=None,\r\n clip_max=None, batch_size=256, log_dir = None,\r\n model_logits = None, binary_steps = 2,\r\n dataset=\"cifar\"):\r\n \"\"\"\r\n TODO\r\n :param sess:\r\n :param model: predictions or after-softmax\r\n :param X:\r\n :param Y:\r\n :param eps:\r\n :param clip_min:\r\n :param clip_max:\r\n :param batch_size:\r\n :return:\r\n \"\"\"\r\n # Define TF placeholders for the input and output\r\n x = tf.placeholder(tf.float32, shape=(None,) + X.shape[1:])\r\n y = tf.placeholder(tf.float32, shape=(None,) + Y.shape[1:])\r\n alpha = tf.placeholder(tf.float32, shape=(None,) + (1,))\r\n num_samples = np.shape(X)[0]\r\n ALPHA = 0.1*np.ones((num_samples,1))\r\n ub = 10.0*np.ones(num_samples)\r\n lb = 0.0*np.ones(num_samples)\r\n Best_X_adv = None\r\n for i in range(binary_steps):\r\n adv_x = adaptive_fgsm(\r\n x, model(x), eps=eps,\r\n clip_min=clip_min,\r\n clip_max=clip_max, y=y,\r\n log_dir= log_dir,\r\n model_logits = model_logits,\r\n alpha = alpha\r\n )\r\n\r\n X_adv = batch_eval(\r\n sess, [x, y, alpha], [adv_x],\r\n [X, Y, ALPHA], feed={},\r\n args={'batch_size': batch_size}\r\n )\r\n X_adv = np.array(X_adv[0])\r\n if(i==0):\r\n Best_X_adv = X_adv\r\n\r\n ALPHA, Best_X_adv = binary_refinement(sess,Best_X_adv,\r\n X_adv, Y, ALPHA, ub, lb, model, dataset)\r\n\r\n return Best_X_adv\r\n\r\n\r\ndef binary_refinement(sess,Best_X_adv,\r\n X_adv, Y, ALPHA, ub, lb, model, dataset='cifar'):\r\n num_samples = np.shape(X_adv)[0]\r\n print(dataset)\r\n if(dataset==\"mnist\"):\r\n X_place = tf.placeholder(tf.float32, shape=[1, 1, 28, 28])\r\n else:\r\n X_place = tf.placeholder(tf.float32, shape=[1, 3, 32, 32])\r\n\r\n pred = model(X_place)\r\n for i in range(num_samples):\r\n logits_op = sess.run(pred,feed_dict={X_place:X_adv[i:i+1,:,:,:]})\r\n if(not np.argmax(logits_op) == np.argmax(Y[i,:])):\r\n # Success, increase alpha\r\n Best_X_adv[i,:,:,:] = X_adv[i,:,:,]\r\n lb[i] = ALPHA[i,0]\r\n else:\r\n ub[i] = ALPHA[i,0]\r\n ALPHA[i] = 0.5*(lb[i] + ub[i])\r\n return ALPHA, Best_X_adv\r\n\r\ndef adaptive_basic_iterative_method(sess, model, X, Y, eps, eps_iter, nb_iter=50,\r\n clip_min=None, clip_max=None, batch_size=256,\r\n log_dir = None, model_logits = None,\r\n binary_steps =2, attack_type = \"bim-b\",\r\n dataset=\"cifar\"):\r\n \"\"\"\r\n TODO\r\n :param sess:\r\n :param model: predictions or after-softmax\r\n :param X:\r\n :param Y:\r\n :param eps:\r\n :param eps_iter:\r\n :param nb_iter:\r\n :param clip_min:\r\n :param clip_max:\r\n :param batch_size:\r\n :return:\r\n \"\"\"\r\n print(\"nb_iter\",nb_iter)\r\n # Define TF placeholders for the input and output\r\n x = tf.placeholder(tf.float32, shape=(None,)+X.shape[1:])\r\n y = tf.placeholder(tf.float32, shape=(None,)+Y.shape[1:])\r\n alpha = tf.placeholder(tf.float32, shape=(None,) + (1,))\r\n num_samples = np.shape(X)[0]\r\n ALPHA = 0.1*np.ones((num_samples,1))\r\n ub = 10.0*np.ones(num_samples)\r\n lb = 0.0*np.ones(num_samples)\r\n Best_X_adv = None\r\n\r\n results = np.zeros((nb_iter, X.shape[0],) + X.shape[1:])\r\n # Initialize adversarial samples as the original samples, set upper and\r\n # lower bounds\r\n X_adv = X\r\n X_min = X_adv - eps\r\n X_max = X_adv + eps\r\n print('Running BIM iterations...')\r\n # \"its\" is a dictionary that keeps track of the iteration at which each\r\n # sample becomes misclassified. The default value will be (nb_iter-1), the\r\n # very last iteration.\r\n def f(val):\r\n return lambda: val\r\n its = defaultdict(f(nb_iter-1))\r\n # Out keeps track of which samples have already been misclassified\r\n out = set()\r\n for j in range(binary_steps):\r\n\r\n for i in tqdm(range(nb_iter)):\r\n adv_x = adaptive_fgsm(\r\n x, model(x), eps=eps_iter,\r\n clip_min=clip_min, clip_max=clip_max, y=y,\r\n log_dir= log_dir,\r\n model_logits = model_logits,\r\n alpha = alpha\r\n )\r\n X_adv, = batch_eval(\r\n sess, [x, y, alpha], [adv_x],\r\n [X_adv, Y, ALPHA], feed={K.learning_phase(): 0},\r\n args={'batch_size': batch_size}\r\n )\r\n X_adv = np.maximum(np.minimum(X_adv, X_max), X_min)\r\n results[i] = X_adv\r\n # check misclassifieds\r\n predictions = model.predict_classes(X_adv, batch_size=512, verbose=0)\r\n misclassifieds = np.where(predictions != Y.argmax(axis=1))[0]\r\n for elt in misclassifieds:\r\n if elt not in out:\r\n its[elt] = i\r\n out.add(elt)\r\n print(i)\r\n\r\n X_adv = results[-1]\r\n if(j==0):\r\n Best_X_adv = X_adv\r\n ALPHA, Best_X_adv = binary_refinement(sess,Best_X_adv,\r\n X_adv, Y, ALPHA, ub, lb, model, dataset)\r\n return Best_X_adv\r\n", "meta": {"hexsha": "45cd8cd79b7985a77b217cfc932114de4167b993", "size": 8854, "ext": "py", "lang": "Python", "max_stars_repo_path": "third_party/lid_adversarial_subspace_detection/adaptive_attacks.py", "max_stars_repo_name": "ptrcarta/neural-fingerprinting", "max_stars_repo_head_hexsha": "01fa8cb592f6fa7497c6884861adf7680ffa7f29", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 29, "max_stars_repo_stars_event_min_datetime": "2018-03-10T04:33:25.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-18T13:03:37.000Z", "max_issues_repo_path": "third_party/lid_adversarial_subspace_detection/adaptive_attacks.py", "max_issues_repo_name": "ptrcarta/neural-fingerprinting", "max_issues_repo_head_hexsha": "01fa8cb592f6fa7497c6884861adf7680ffa7f29", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2019-07-22T20:59:01.000Z", "max_issues_repo_issues_event_max_datetime": "2019-11-17T07:00:00.000Z", "max_forks_repo_path": "third_party/lid_adversarial_subspace_detection/adaptive_attacks.py", "max_forks_repo_name": "StephanZheng/neural-fingerprinting", "max_forks_repo_head_hexsha": "57e93e487ef324427456b14d1d81bc9e08483d27", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 20, "max_forks_repo_forks_event_min_datetime": "2018-03-14T14:01:55.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-17T19:19:56.000Z", "avg_line_length": 35.9918699187, "max_line_length": 106, "alphanum_fraction": 0.5834651005, "include": true, "reason": "import numpy", "num_tokens": 2164, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5350984286266115, "lm_q2_score": 0.3702253925955866, "lm_q1q2_score": 0.19810702581556874}} {"text": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n### Example of use\n###, L. Darme 02/07/2019\n\nimport matplotlib.pyplot as plt\nimport numpy as np\n# Importing additional user-defined function\n\nimport UsefulFunctions as uf\nimport Amplitudes as am\nimport Production as br\nimport Detection as de\nimport LimitsList as lim\n#############################################################################\n############### Several limits example ##############################\n#############################################################################\n\n\n# This example loads a list of limits, recast them and save them in the Output folder, then plot some of them\n\nif __name__ == \"__main__\":\n\n geffem={\"gu11\":2/3.,\"gu22\":2/3.,\"gd11\":-1/3.,\"gd22\":-1/3.,\"gd33\":-1/3.,\"gl11\":-1.,\"gl22\":-1.}\n\n ExperimentsList=np.array([\"lsnd_decay\",\"charm_decay\",\"seaquest_phase2_decay\",\"faser_decay\",\"ship_decay\", \\\n \"babar_monogam\",\"belle2_monogam\", \\\n \"miniboone_scattering\",\"sbnd_scattering\",\"ship_scattering\",\"nova_scattering\", \\\n \"sn1987_low_cooling\",\"sn1987_high_cooling\", \\\n \"na62_invisibledecayPi0\",\"bes_invisibledecayJPsi\",\"babar_invisibledecayUpsilon\",\\\n \"atlas_monojet_down\",\"atlas_monojet_up\",\"lep_monogam\"])\n\n Lim,LabelLimit = lim.GetLimits(ExperimentsList,10,geffem,\"V\",True)\n\n\n fig=plt.figure(1)\n s = fig.add_subplot(1, 1, 1)\n yup = 1e4;xup=5\n ydown = 10;xdown=0.005\n s.set_xlim((xdown,xup))\n s.set_ylim((ydown,yup))\n xbasic=np.linspace(xdown,xup,75)\n s.set_xscale(\"log\", nonposx='clip')\n s.set_yscale(\"log\", nonposy='clip')\n\n s.loglog(Lim['lsnd_decay'][0],Lim['lsnd_decay'][1],linestyle='-',linewidth=1.5,color='xkcd:green',zorder=15)\n s.fill_between(Lim['lsnd_decay'][0],ydown,Lim['lsnd_decay'][1],color='xkcd:green',alpha=0.5, zorder=15)\n s.loglog(Lim['ship_decay'][0],Lim['ship_decay'][1],linestyle='--',linewidth=1.5,color='xkcd:orange',zorder=15)\n s.loglog(Lim['charm_decay'][0],Lim['charm_decay'][1],linestyle='-',linewidth=1.5,color='xkcd:darkgreen',zorder=15)\n s.fill_between(Lim['charm_decay'][0],ydown,Lim['charm_decay'][1],color='xkcd:darkgreen',alpha=0.5, zorder=15)\n s.loglog(Lim['seaquest_phase2_decay'][0],Lim['seaquest_phase2_decay'][1],linestyle='--',linewidth=1.5,color='xkcd:red',zorder=15)\n s.loglog(Lim['faser_decay'][0],Lim['faser_decay'][1],linestyle='-.',linewidth=1.5,color='xkcd:indigo',zorder=15)\n\n # -------- Mono photon at LEP\n s.fill_between(Lim['lep_monogam'][0],200,Lim['lep_monogam'][1],color='xkcd:blue',alpha=0.25, zorder=15)\n s.axhline(200,linestyle='--',linewidth=1.,color='xkcd:blue',zorder=15)\n s.loglog(Lim['lep_monogam'][0],Lim['lep_monogam'][1],linestyle='--',linewidth=1.5,color='xkcd:blue',zorder=15)\n\n # -------- Missing energy searches\n s.loglog(Lim['babar_monogam'][0],Lim['babar_monogam'][1],linestyle='-',linewidth=2,color='xkcd:grey',zorder=15)\n s.fill_between(Lim['babar_monogam'][0],ydown,Lim['babar_monogam'][1],color='xkcd:grey',alpha=0.5, zorder=15)\n s.loglog(Lim['belle2_monogam'][0],Lim['belle2_monogam'][1],linestyle='--',linewidth=1.5,color='xkcd:black',zorder=15)\n\n # ------ Self consistency\n s.loglog(xbasic,2*xbasic,linestyle='-',linewidth=1.5,color='xkcd:grey',zorder=15)\n s.fill_between(xbasic,ydown,2*xbasic,color='xkcd:grey',alpha=0.5, zorder=15)\n\n # -------- SN bounds\n gp=np.logical_and(Lim['sn1987_high_cooling'][1]>1.1*Lim['sn1987_low_cooling'][1],Lim['sn1987_high_cooling'][1]>1)\n s.loglog(Lim['sn1987_high_cooling'][0][gp],Lim['sn1987_high_cooling'][1][gp],linestyle='-',linewidth=1,color='xkcd:purple',zorder=15)\n s.loglog(Lim['sn1987_low_cooling'][0][gp],Lim['sn1987_low_cooling'][1][gp],linestyle='--',linewidth=0.5,color='xkcd:purple',zorder=15)\n s.fill_between(Lim['sn1987_low_cooling'][0][gp],Lim['sn1987_low_cooling'][1][gp],Lim['sn1987_high_cooling'][1][gp],color='xkcd:purple',alpha=0.15, zorder=15)\n\n # ----- Invisible decay of Upsilon\n\n s.loglog(Lim['babar_invisibledecayUpsilon'][0],Lim['babar_invisibledecayUpsilon'][1],linestyle='-',linewidth=1.1,color='xkcd:dark grey',zorder=15)\n s.fill_between(Lim['babar_invisibledecayUpsilon'][0],ydown,Lim['babar_invisibledecayUpsilon'][1],color='xkcd:grey',alpha=0.25, zorder=15)\n\n s.text(0.08,220,r'FASER',fontsize=10,color='xkcd:indigo', zorder=40,rotation=40)\n s.text(1.1,52,r'BaBar' ,fontsize=10, zorder=50)\n s.text(1.1,110,r'Belle II ($50$ ab${}^{-1}$)' ,fontsize=10, zorder=50)\n s.text(1.1,220,r'LEP (DELPHI)' ,color='xkcd:darkblue',fontsize=10, zorder=50)\n s.text(0.01,2500,r'SN1987 (Cooling)' ,color='xkcd:purple',fontsize=10, zorder=50,rotation=0)\n s.text(0.015,70,r'LSND',fontsize=10,color='xkcd:darkgreen', zorder=50,rotation=20)\n s.text(0.15,610,r'SeaQuest',fontsize=10,color='xkcd:red', zorder=40,rotation=35)\n s.text(0.28,510,r'CHARM',fontsize=10,color='xkcd:darkgreen', zorder=40,rotation=35)\n s.text(1.,4.e3,'SHIP',fontsize=10,color='xkcd:rust', zorder=50,rotation=30)\n s.text(1.1,160,r'BaBar ($\\Upsilon \\to$ inv)' ,fontsize=10, zorder=50)\n s.text(0.02,0.94,r'$g_e:g_d:g_u = -1:-\\frac{1}{3}:\\frac{2}{3}$', style='italic',fontsize=14,transform = s.transAxes, zorder=20)\n #----Adjusting the labels and color bar\n s.set_xlabel(r'$M_{\\chi_2}$ [GeV]',fontsize=18)\n s.set_ylabel(r'$\\Lambda$ / $\\sqrt{g}$ [GeV]',fontsize=18)\n\n #---- Saving and showing on screen the Figure\n plt.tight_layout()\n plt.savefig('Output/Example2.pdf')\n plt.show()\n", "meta": {"hexsha": "e110c8abc1298d05fb3ceff0dadd93c2e0384a25", "size": 5586, "ext": "py", "lang": "Python", "max_stars_repo_path": "Examples/Example2.py", "max_stars_repo_name": "Luc-Darme/DarkEFT", "max_stars_repo_head_hexsha": "f4be14742ced9a1447dbcab40a6c7b18e61cb001", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Examples/Example2.py", "max_issues_repo_name": "Luc-Darme/DarkEFT", "max_issues_repo_head_hexsha": "f4be14742ced9a1447dbcab40a6c7b18e61cb001", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Examples/Example2.py", "max_forks_repo_name": "Luc-Darme/DarkEFT", "max_forks_repo_head_hexsha": "f4be14742ced9a1447dbcab40a6c7b18e61cb001", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-01-09T06:43:46.000Z", "max_forks_repo_forks_event_max_datetime": "2020-01-09T06:43:46.000Z", "avg_line_length": 56.4242424242, "max_line_length": 161, "alphanum_fraction": 0.6451843895, "include": true, "reason": "import numpy", "num_tokens": 1921, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5350984286266115, "lm_q2_score": 0.3702253786982541, "lm_q1q2_score": 0.19810701837912795}} {"text": "import os\nimport pickle\nimport warnings\n\nimport numpy as np\nfrom shutil import copyfile\n\nfrom astropy import units as u\nfrom astropy.table import Table, Column\n\nfrom .kinematic_distance import KinematicDistance\n\n\nclass BayesianDistance(object):\n def __init__(self, filename=None):\n \"\"\"\n initializes the BayesianDistance class\n\n Parameters\n ----------\n path_to_bdc : file path to the Bayesian distance program\n path_to_input_table : file path of a table containing information of the\n Gaussian decompositions\n verbose : The default is 'True'. Prints status messages to the\n terminal.\n \"\"\"\n self.path_to_bdc = None\n self.version = '2.4'\n self.path_to_input_table = None\n self.path_to_output_table = None\n self.input_table = None\n self.verbose = True\n self.add_kinematic_distance = True\n self.add_galactocentric_distance = True\n self.check_for_kda_solutions = True\n self.prior_velocity_dispersion = False\n self.colname_lon, self.colname_lat, self.colname_vel,\\\n self.colname_e_vel, self.colname_kda, self.colname_name,\\\n self.colname_vel_disp = (None for i in range(7))\n self.colnr_lon, self.colnr_lat, self.colnr_vel,\\\n self.colnr_e_vel, self.colnr_kda, self.colnr_name,\\\n self.colnr_vel_disp = (None for i in range(7))\n self.prob_sa, self.prob_kd, self.prob_gl, self.prob_ps, self.prob_pm =\\\n (None for _ in range(5))\n self.table_format = 'ascii'\n self.save_temporary_files = False\n self.max_e_vel = 5.0\n self.default_e_vel = 5.0\n self.kda_info_tables = []\n self.exclude_kda_info_tables = []\n self.kda_weight = 1\n\n self.random_seed = 177\n self.sample = 1000\n self.beam = None\n self.size_linewidth_index = 0.5\n self.size_linewidth_e_index = 0.1\n self.size_linewidth_sigma_0 = 0.7\n self.size_linewidth_e_sigma_0 = 0.1\n\n self.use_ncpus = None\n self.plot_probability = False\n\n self._p = {\n '1.0': {\n 'bdc_fortran': 'Bayesian_distance_v1.0.f',\n 'summary_suffix': '.prt',\n 'fct_extract': self.extract_results_v1p0,\n 'R_0': 8.34},\n '2.4': {\n 'bdc_fortran': 'Bayesian_distance_2019_fromlist_v2.4.f',\n 'summary_suffix': 'summary.prt',\n 'fct_extract': self.extract_results_v2p4,\n 'R_0': 8.15}\n }\n\n def say(self, message, end=None):\n \"\"\"Diagnostic messages.\"\"\"\n if self.verbose:\n print(message, end=end)\n\n def check_settings(self):\n self.initialize_bdc()\n self.initialize_table()\n self.set_probability_controls()\n if self.check_for_kda_solutions:\n self.initialize_kda_tables()\n if self.prior_velocity_dispersion:\n self.initialize_prior_velocity_dispersion()\n\n text = 'Python wrapper for Bayesian distance calculator v{}'.format(\n self.version)\n border = len(text) * '='\n heading = '\\n{a}\\n{b}\\n{a}\\n'.format(a=border, b=text)\n self.say(heading)\n\n def initialize_bdc(self):\n if self.version is None:\n raise Exception(\"Need to specify 'version'\")\n\n path_script = os.path.dirname(\n os.path.dirname(os.path.realpath(__file__)))\n\n self.path_to_bdc = os.path.join(\n path_script, 'BDC', 'v' + self.version)\n path_to_file = os.path.join(\n self.path_to_bdc, self._p[self.version]['bdc_fortran'])\n\n with open(path_to_file, \"r\") as fin:\n self.bdc_script = fin.readlines()\n\n def initialize_table(self):\n if self.path_to_output_table is not None:\n self.path_to_table = self.path_to_output_table\n\n if self.path_to_table is None:\n errorMessage = str(\"specify 'path_to_output_table'\")\n raise Exception(errorMessage)\n\n self.dirname_table = os.path.dirname(self.path_to_table)\n if len(self.dirname_table) == 0:\n self.dirname_table = os.getcwd()\n self.table_file = os.path.basename(self.path_to_table)\n self.table_filename, self.table_file_extension =\\\n os.path.splitext(self.table_file)\n if not os.path.exists(self.dirname_table):\n os.makedirs(self.dirname_table)\n\n def initialize_kda_tables(self):\n dirname = os.path.dirname(\n os.path.dirname(os.path.realpath(__file__)))\n if not self.kda_info_tables:\n files = os.listdir(os.path.join(dirname, 'KDA_info'))\n self.kda_info_tables = [\n name[:-4] for name in files if name.endswith('.ini')]\n\n if self.exclude_kda_info_tables:\n self.kda_info_tables = [\n table for table in self.kda_info_tables\n if table not in self.exclude_kda_info_tables]\n\n self._kda_tables = []\n keys = ['GLON', 'GLAT', 'VLSR', 'd_VLSR', 'p_far',\n 'cos_pa', 'sin_pa', 'aa', 'bb']\n for tablename in self.kda_info_tables:\n table = Table.read(os.path.join(\n dirname, 'KDA_info', tablename + '.dat'), format='ascii')\n table = table[keys]\n\n self._kda_tables.append(table)\n\n def initialize_prior_velocity_dispersion(self):\n try:\n self.beam = self.beam.to(u.rad).value\n except AttributeError:\n err_msg = \"'beam' needs to be specified as valid astropy unit\"\n raise Exception(err_msg)\n\n self.kd = KinematicDistance()\n self.kd.initialize()\n\n np.random.seed = self.random_seed\n self._indices = self.size_linewidth_index + np.random.randn(\n self.sample) * self.size_linewidth_e_index\n self._sigma_0 = self.size_linewidth_sigma_0 + np.random.randn(\n self.sample) * self.size_linewidth_e_sigma_0\n\n def set_probability_controls(self):\n s = ' '\n\n default_vals = {\n '1.0': {'SA': 0.5, 'KD': 1.0, 'GL': 1.0, 'PS': 0.25, 'PM': None},\n '2.4': {'SA': 0.85, 'KD': 0.85, 'GL': 0.85, 'PS': 0.15, 'PM': 0.85}\n }\n\n if self.prob_sa is None:\n self.prob_sa = default_vals[self.version]['SA']\n if self.prob_kd is None:\n self.prob_kd = default_vals[self.version]['KD']\n if self.prob_gl is None:\n self.prob_gl = default_vals[self.version]['GL']\n if self.prob_ps is None:\n self.prob_ps = default_vals[self.version]['PS']\n if self.prob_pm is None:\n self.prob_pm = default_vals[self.version]['PM']\n\n cwd = os.getcwd()\n os.chdir(self.path_to_bdc)\n\n with open(os.path.join(\n self.path_to_bdc, 'probability_controls.inp'), 'r') as fin:\n file_content = fin.readlines()\n with open(os.path.join(\n self.path_to_bdc, 'probability_controls.inp'), 'w') as fout:\n for line in file_content:\n if not line.startswith('!'):\n line = '{s}{a}{s}{b}{s}{c}{s}{d}'.format(\n s=s, a=self.prob_sa, b=self.prob_kd, c=self.prob_gl,\n d=self.prob_ps)\n if self.prob_pm is not None:\n line += '{s}{a}'.format(s=s, a=self.prob_pm)\n fout.write(line)\n os.chdir(cwd)\n\n string = str(\"prob_sa: {a}\\nprob_kd: {b}\\n\"\n \"prob_gl: {c}\\nprob_ps: {d}\\n\".format(\n a=self.prob_sa, b=self.prob_kd, c=self.prob_gl,\n d=self.prob_ps))\n if self.version == '2.4':\n string += 'prob_pm: {}\\n'.format(self.prob_pm)\n self.say(\"setting probability controls to the following values:\")\n self.say(string)\n\n def determine_column_indices(self):\n self.colnr_lon = self.input_table.colnames.index(self.colname_lon)\n self.colnr_lat = self.input_table.colnames.index(self.colname_lat)\n self.colnr_vel = self.input_table.colnames.index(self.colname_vel)\n if self.colname_e_vel is not None:\n if not isinstance(self.colname_e_vel, list):\n self.colname_e_vel = [self.colname_e_vel]\n self.colnr_e_vel = [self.input_table.colnames.index(colname)\n for colname in self.colname_e_vel]\n if self.colname_kda is not None:\n self.colnr_kda = self.input_table.colnames.index(self.colname_kda)\n if self.colname_vel_disp is not None:\n self.colnr_vel_disp = self.input_table.colnames.index(\n self.colname_vel_disp)\n if self.colname_name is not None:\n self.colnr_name = self.input_table.colnames.index(self.colname_name)\n\n def make_fortran_out(self, source):\n \"\"\"Create a fortran executable for the source.\n\n Replaces the default input file in the fortran script of the Bayesian\n distance calculator with the input file of the source, then creates a\n Fortran executable file.\n \"\"\"\n with open(\"{}.f\".format(self.path_to_source), \"w\") as fout:\n for line in self.bdc_script:\n fout.write(line.replace('sources_info.inp',\n '{}_sources_info.inp'.format(source)))\n os.system('gfortran {}.f -o {}.out'.format(\n self.path_to_source, self.path_to_source))\n\n def extract_string(self, s, first, last, incl=False):\n \"\"\"Search for a substring inside a string.\n\n Parameters\n ----------\n s : string that is searched for the substring\n first : first characters of the substring\n last : last characters of the substring\n incl : defines if the `first` and `last` characters are still part of\n the substring that will be returned. The default is `False`\n (`first` and `last` are not part of the returned substring)\n\n Returns\n -------\n substring of s\n\n \"\"\"\n try:\n if incl is True:\n start = s.index(first)\n end = s.index(last) + len(last)\n else:\n start = s.index(first) + len(first)\n end = s.index(last, start)\n return s[start:end]\n except ValueError:\n return \"\"\n\n def extract_probability_info(self, line, lon, lat, p_far):\n \"\"\"\n Extract the distance results from the corresponding string in\n the output file of the Bayesian distance calculator tool.\n \"\"\"\n deleteString = self.extract_string(\n line, 'Probability component', ':', incl=True)\n replaceString = self.extract_string(\n line, 'Probability component', ':')\n line = line.replace(deleteString, replaceString)\n line = line.replace('\\n', '')\n comp, dist, err, prob, arm = line.split()\n c_u, c_v, c_w = self.get_cartesian_coords(lon, lat, float(dist))\n # if np.isnan(dist) is True:\n # dist, err, prob = (0.0 for i in range(3))\n return [comp, dist, err, prob, arm, c_u, c_v, c_w, p_far]\n\n def extract_results_v1p0(self, input_file_content, result_file_content,\n kin_dist=None, kda_ref=None):\n \"\"\"\n Loop through the lines of the output file of the Bayesian distance\n calculator tool and search for the distance results.\n\n Parameters\n ----------\n result_file_content : List containing read-in lines of the output file\n ({source_name}.prt) of the Bayesian distance calculator tool\n \"\"\"\n results = []\n flag = False\n for line in result_file_content:\n if flag:\n params = line.split()\n lon, lat, p_far =\\\n float(params[1]), float(params[2]), float(params[4])\n flag = False\n if 'Extra_info' in line:\n flag = True\n searchString = 'Probability component'\n if searchString in line:\n result = self.extract_probability_info(line, lon, lat, p_far)\n\n if kda_ref is not None:\n result += [kda_ref]\n\n if kin_dist is not None:\n result += kin_dist\n\n results.append(result)\n return results\n\n def extract_kinematic_distances(self, result_file_content):\n \"\"\"\"\"\"\n kinDist = [np.NAN, np.NAN]\n\n flag = 'one'\n for line in result_file_content:\n searchString = 'Kinematic distance(s):'\n if searchString in line:\n if flag == 'one':\n kinDist[0] = self.extract_kinematic_info(line)\n flag = 'two'\n elif flag == 'two':\n kinDist[1] = self.extract_kinematic_info(line)\n return kinDist\n\n def extract_kinematic_info(self, line):\n \"\"\"\n Extract the distance results from the corresponding string in\n the output file of the Bayesian distance calculator tool.\n \"\"\"\n line = line.replace('Kinematic distance(s):', '')\n line = line.replace('\\n', '')\n return float(line)\n\n def extract_results_v2p4(self, input_file_content, result_file_content,\n kin_dist=None, kda_ref=None):\n for line in input_file_content:\n if line.startswith('!'):\n continue\n params = line.split()\n p_far = params[5]\n\n for line in result_file_content:\n if line.startswith('!'):\n continue\n params = line.split()\n\n n_params = len(params)\n\n lon, lat, vlsr, e_vlsr = params[:4]\n\n results = []\n\n for i in range(1, int(n_params / 4)):\n comp = int(n_params / 4) - 1\n dist, e_dist, prob, arm = params[i*4:(i + 1)*4]\n c_u, c_v, c_w = self.get_cartesian_coords(\n float(lon), float(lat), float(dist))\n\n result = [comp, dist, e_dist, prob, arm, c_u, c_v, c_w, p_far]\n\n if kda_ref is not None:\n result += [kda_ref]\n\n if kin_dist is not None:\n result += kin_dist\n\n results.append(result)\n return results\n\n def delete_all_temporary_files(self, source):\n for filename in [f for f in os.listdir(self.path_to_bdc) if f.startswith(source)]:\n os.remove(os.path.join(self.path_to_bdc, filename))\n\n def get_results(self, source, kda_ref=None, name=None):\n \"\"\"\n Extract the distance results from the output file ({source_name}.prt)\n of the Bayesian distance calculator tool.\n \"\"\"\n suffix = self._p[self.version]['summary_suffix']\n for filename in [f for f in os.listdir(self.path_to_bdc)\n if f.startswith(source) and f.endswith(suffix)]:\n with open(os.path.join(self.path_to_bdc, filename), 'r') as fin:\n result_file_content = fin.readlines()\n\n for filename in [f for f in os.listdir(self.path_to_bdc)\n if f.startswith(source) and f.endswith(\"info.inp\")]:\n with open(os.path.join(self.path_to_bdc, filename), 'r') as fin:\n input_file_content = fin.readlines()\n\n if self.add_kinematic_distance:\n if self.version == '1.0':\n kd_content = result_file_content.copy()\n elif self.version == '2.4':\n with open(os.path.join(self.path_to_bdc, source + '.prt'), 'r') as fin:\n kd_content = fin.readlines()\n kinDist = self.extract_kinematic_distances(kd_content)\n else:\n kinDist = None\n\n results = self._p[self.version]['fct_extract'](\n input_file_content, result_file_content, kin_dist=kinDist, kda_ref=kda_ref)\n\n if self.plot_probability:\n if self.save_temporary_files:\n for filename in [f for f in os.listdir(self.path_to_bdc) if f.startswith(source)]:\n src = os.path.join(self.path_to_bdc, filename)\n if name is not None:\n filename = filename.replace(source, name)\n dst = os.path.join(\n os.path.dirname(self.path_to_output_table), filename)\n copyfile(src, dst)\n\n self.plot_probability_density(\n source, results, input_file_content, name=name)\n\n self.delete_all_temporary_files(source)\n\n return results\n\n def run_bdc_script(self, source, input_string):\n self.path_to_source = os.path.join(self.path_to_bdc, source)\n filepath = '{}_sources_info.inp'.format(self.path_to_source)\n with open(filepath, 'w') as fin:\n fin.write(input_string)\n self.make_fortran_out(source)\n cwd = os.getcwd()\n os.chdir(self.path_to_bdc)\n os.system('./{}.out'.format(source))\n os.chdir(cwd)\n\n def bdc_calculation_ok(self, source):\n \"\"\"Check if BDC yielded any distance results.\"\"\"\n suffix = self._p[self.version]['summary_suffix']\n for filename in [f for f in os.listdir(self.path_to_bdc)\n if f.startswith(source) and f.endswith(suffix)]:\n with open(os.path.join(self.path_to_bdc, filename), 'r') as fin:\n result_file_content = fin.readlines()\n for line in result_file_content:\n if not line.startswith('!'):\n return True\n\n return False\n\n def determine_e_vel(self, row):\n \"\"\"Determine uncertainty for vlsr value.\"\"\"\n e_vel = None\n\n if self.colnr_e_vel is not None:\n e_vel = max([row[colnr] for colnr in self.colnr_e_vel])\n if abs(float(e_vel)) > self.max_e_vel: # abs(float(vel)):\n e_vel = None\n\n if self.version == '1.0':\n plusminus = ''\n elif self.version == '2.4':\n # TODO: implement minimum error for velocity\n if e_vel is not None:\n plusminus = '{}\\t'.format(e_vel)\n else:\n plusminus = '{}\\t'.format(self.default_e_vel)\n\n return plusminus\n\n def determine_p_far_and_kda_ref(self, row, lon, lat, vel):\n \"\"\"Determine KDA prior and corresponding literature reference.\"\"\"\n p_far = 0.5\n kda_ref = None\n\n if self.colnr_kda is not None:\n if row[self.colnr_kda] == 'F':\n p_far = 0.5 + 0.5 * self.kda_weight\n elif row[self.colnr_kda] == 'N':\n p_far = 0.5 - 0.5 * self.kda_weight\n elif isinstance(row[self.colnr_kda], float):\n warnings.warn(\n \"KDA solutions need to be given as strings ('N', 'F')\")\n p_far = row[self.colnr_kda] * self.kda_weight\n elif self.check_for_kda_solutions:\n p_far, kda_ref = self.check_KDA(lon, lat, vel)\n\n return round(p_far, 2), kda_ref\n\n def get_expected_vel_disp(self, distance):\n size = self.beam * distance * 1e3\n sigma_exp = self._sigma_0 * (size)**(self._indices)\n return np.mean(sigma_exp), np.std(sigma_exp)\n\n def normalized_gauss(self, mean, sigma, x):\n return np.exp(-0.5 * ((x - mean) / sigma)**2)\n\n def check_limit(self, mean, sigma, vel_disp, prob, limit=0.01):\n limit_prob = None\n if prob < limit:\n if (vel_disp - mean) > 0:\n limit_prob = 'higher'\n else:\n limit_prob = 'lower'\n return limit_prob\n\n def determine_pfar_from_vel_disp(self, dist_n, dist_f, vel_disp):\n sigma_exp_mean, sigma_exp_std = self.get_expected_vel_disp(dist_n)\n prob_near = self.normalized_gauss(\n sigma_exp_mean, sigma_exp_std, vel_disp)\n limit_n = self.check_limit(\n sigma_exp_mean, sigma_exp_std, vel_disp, prob_near)\n\n sigma_exp_mean, sigma_exp_std = self.get_expected_vel_disp(dist_f)\n prob_far = self.normalized_gauss(\n sigma_exp_mean, sigma_exp_std, vel_disp)\n limit_f = self.check_limit(\n sigma_exp_mean, sigma_exp_std, vel_disp, prob_far)\n\n if (limit_f == 'lower') and (limit_n != 'higher'):\n pfar = 0\n else:\n pfar = (-prob_near + prob_far) * 0.5 + 0.5\n\n return pfar\n\n def determine_p_far_from_velocity_dispersion(self, row, lon, lat, vel):\n dist_n, dist_f = self.kd.calc_kinematic_distance(lon, lat, vel)\n vel_disp = row[self.colnr_vel_disp]\n p_far = self.determine_pfar_from_vel_disp(dist_n, dist_f, vel_disp)\n return round(p_far, 2)\n\n def determine(self, row, idx):\n \"\"\"Determine distance of lbv data point via the BDC.\"\"\"\n row = list(row)\n\n source = \"SRC{}\".format(str(idx).zfill(9))\n lon, lat, vel =\\\n row[self.colnr_lon], row[self.colnr_lat], row[self.colnr_vel]\n\n name = None\n if self.colnr_name is not None:\n name = row[self.colnr_name]\n\n plusminus = self.determine_e_vel(row)\n p_far, kda_ref = self.determine_p_far_and_kda_ref(row, lon, lat, vel)\n condition = ((p_far == 0.5) and\n self.prior_velocity_dispersion and\n (self.colnr_vel_disp is not None))\n if condition:\n p_far = self.determine_p_far_from_velocity_dispersion(\n row, lon, lat, vel)\n\n input_string = \"{a}\\t{b}\\t{c}\\t{d}\\t{e}{f}\\t-\\n\".format(\n a=source, b=lon, c=lat, d=vel, e=plusminus, f=p_far)\n\n self.run_bdc_script(source, input_string)\n\n # rerun BDC calculation with p_far = 0.5 if chosen p_far value did not yield distance results\n if (self.version == '2.4') and (p_far != 0.5):\n if not self.bdc_calculation_ok(source):\n self.delete_all_temporary_files(source)\n\n p_far = 0.5\n input_string = \"{a}\\t{b}\\t{c}\\t{d}\\t{e}{f}\\t-\\n\".format(\n a=source, b=lon, c=lat, d=vel, e=plusminus, f=p_far)\n self.run_bdc_script(source, input_string)\n\n rows = []\n results = self.get_results(source, kda_ref=kda_ref, name=name)\n for result in results:\n rows.append(row + result)\n\n return rows\n\n def get_values_from_init_file(self, init_file):\n \"\"\"Read in values from init file.\"\"\"\n import ast\n import configparser\n config = configparser.ConfigParser()\n config.read(init_file)\n\n for key, value in config['DEFAULT'].items():\n try:\n setattr(self, '_' + key, ast.literal_eval(value))\n except ValueError:\n raise Exception('Could not parse parameter {} from config file'.format(key))\n\n def gaussian_weight(self, x, std=False):\n \"\"\"Calculate the Gaussian weight.\n\n Gaussian function: amp * np.exp(-4. * np.log(2) * (x-mean)**2 / fwhm**2)\n mean = 0\n\n Renormalization factor for amplitude, so that Gaussian function is 1 at the fwhm/2; scale = 1 / (np.exp(-np.log(2)) = np.exp(np.log(2)\n fwhm_factor = 2 * np.sqrt(2 * np.log(2)) = 2.354820045\n \"\"\"\n if std:\n return np.exp((1 - x**2) / 2) # = np.exp(0.5) * np.exp(-4. * np.log(2) * (x / 2.354820045)**2)\n else:\n return np.exp(np.log(2) * (1 - 4. * x**2)) # np.exp(np.log(2)) * np.exp(-4. * np.log(2) * x**2)\n\n def point_in_ellipse(self, table, lon, lat):\n \"\"\"Adapted from: https://stackoverflow.com/questions/7946187/\n See also: https://math.stackexchange.com/questions/426150/\"\"\"\n cos_pa = table['cos_pa'].data\n sin_pa = table['sin_pa'].data\n glon = table['GLON'].data\n glat = table['GLAT'].data\n aa = table['aa'].data\n bb = table['bb'].data\n\n a = (cos_pa * (lon - glon) + sin_pa * (lat - glat))**2\n b = (sin_pa * (lon - glon) - cos_pa * (lat - glat))**2\n epsilon = (a / aa) + (b / bb)\n\n std = False\n if self._size == 'std':\n std = True\n else:\n epsilon = epsilon / 4\n\n weight = self.gaussian_weight(np.sqrt(epsilon), std=std)\n weight[weight > 1] = 1\n\n return weight >= self._threshold_spatial, weight\n\n def get_weight_velocity(self, table, vel):\n \"\"\"Calculate the weight for the velocity association.\n\n Parameters\n ----------\n table : astropy.table.table.Table\n Table containing sources with solved kinematic distance ambiguities.\n vel : float\n vlsr position of the coordinate.\n\n Returns\n -------\n mask : numpy.ndarray\n Mask that is true for each weight that exceeds _threshold_spectral.\n weight : numpy.ndarray\n Array of the weight values.\n\n \"\"\"\n vlsr = table['VLSR'].data.data\n dvlsr = table['d_VLSR'].data.data\n\n x = np.abs(vlsr - vel) / dvlsr\n\n # fwhm_factor = 2.354820045\n # if fwhm:\n # x = np.abs((vlsr - vel) / (dvlsr))\n # else:\n # x = np.abs((vlsr - vel) / (dvlsr)) / (2 * fwhm_factor)\n\n std = False\n if self._linewidth == 'std':\n std = True\n\n weight = self.gaussian_weight(x, std=std)\n weight[weight > 1] = 1\n\n return weight >= self._threshold_spectral, weight\n\n def get_kda(self, weights_kda, refs):\n if len(weights_kda) == 0:\n return 0, '--'\n\n if len(weights_kda) == 1:\n return weights_kda[0], refs[0]\n\n weights_kda_abs = [abs(x) for x in weights_kda]\n max_weight = max(weights_kda_abs)\n\n indices = np.argwhere(weights_kda_abs == max_weight).flatten().tolist()\n\n if len(indices) == 1:\n i = indices[0]\n return weights_kda[i], refs[i]\n\n if sum(weights_kda[indices]) == 0:\n return 0, '--'\n else:\n list_weights_kda = weights_kda[indices].tolist()\n weight = max(list_weights_kda, key=list_weights_kda.count)\n i = np.argwhere(weights_kda == weight).flatten()[0]\n return weight, refs[i]\n\n def check_KDA(self, lon, lat, vel):\n weights_kda, refs = np.array([]), []\n dirname = os.path.dirname(\n os.path.dirname(os.path.realpath(__file__)))\n\n for table, tablename in zip(self._kda_tables, self.kda_info_tables):\n path_to_ini = os.path.join(dirname, 'KDA_info', tablename + '.ini')\n self.get_values_from_init_file(path_to_ini)\n mask_pp, weight_pp = self.point_in_ellipse(table, lon, lat)\n mask_vlsr, weight_vlsr = self.get_weight_velocity(table, vel)\n\n mask_total = np.logical_and(mask_pp, mask_vlsr)\n weight_total = weight_pp * weight_vlsr\n weight_total = weight_total[mask_total]\n p_far_values = table['p_far'].data\n p_far_values = p_far_values[mask_total]\n\n n_values = np.count_nonzero(mask_total)\n if n_values == 0:\n continue\n elif n_values == 1:\n weights_kda = np.append(\n weights_kda, self._weight_cat * p_far_values * weight_total)\n refs.append(self._reference)\n else:\n weights_kda = np.append(weights_kda, self._weight_cat * (np.average(\n p_far_values * weight_total, weights=weight_total)))\n refs.append(self._reference)\n\n weight_kda, ref = self.get_kda(weights_kda, refs)\n p_far = 0.5 + weight_kda\n\n return round(float(p_far), 2), ref\n\n def get_cartesian_coords(self, lon, lat, dist):\n from astropy.coordinates import SkyCoord\n from astropy import units as u\n\n c = SkyCoord(l=lon*u.degree,\n b=lat*u.degree,\n distance=dist*u.kpc,\n frame='galactic')\n c.representation_type = 'cartesian'\n c_u = round(c.u.value, 4)\n c_v = round(c.v.value, 4)\n c_w = round(c.w.value, 4)\n\n return c_u, c_v, c_w\n\n def calculate_distances(self):\n self.check_settings()\n self.say('calculating Bayesian distance...')\n\n if self.input_table is None:\n self.input_table = Table.read(\n self.path_to_input_table, format=self.table_format)\n # TESTING:\n # self.input_table = self.input_table[62000:62001]\n self.determine_column_indices()\n\n condition = (self.prior_velocity_dispersion and\n (self.colnr_vel_disp is None))\n if condition:\n self.colnr_vel_disp = False\n warnings.warn(str(\"Did not specify 'colnr_vel_disp' or 'colname_vel_disp'. Setting 'prior_velocity_dispersion=False'.\"))\n\n from . import BD_multiprocessing\n BD_multiprocessing.init([self, self.input_table])\n results_list = BD_multiprocessing.func(use_ncpus=self.use_ncpus)\n print('SUCCESS\\n')\n\n for i, item in enumerate(results_list):\n if not isinstance(item, list):\n self.say(\"Error for distance with index {}: {}\".format(i, item))\n del results_list[i]\n continue\n\n results_list = np.array([item for sublist in results_list\n for item in sublist])\n\n if self.save_temporary_files:\n filepath = os.path.join(\n os.path.dirname(self.path_to_table),\n '_bdc_results_list.pickle')\n with open(filepath, 'wb') as p_file:\n pickle.dump(results_list, p_file)\n\n self.create_astropy_table(results_list)\n\n def galactocentric_distance(self, glon, dist_los, glat=None):\n \"\"\"Calculate galactocentric distance.\n\n Parameters\n ----------\n glon : float [radians]\n Galactic longitude angle of the line of sight. Has to be supplied in [radians].\n dist_los : float [kpc]\n Distance along the line of sight. Has to be supplied in [kpc].\n glat : float [radians]\n Galactic latitude angle of the line of sight. Has to be supplied in [radians].\n\n Returns\n -------\n Galactocentric distance in [kpc].\n\n \"\"\"\n if glat is not None:\n dist_los = dist_los * np.cos(glat)\n R_0 = self._p[self.version]['R_0']\n return np.sqrt(R_0**2 + dist_los**2 - 2*R_0*dist_los*np.cos(glon))\n\n def create_astropy_table(self, results):\n self.say('creating Astropy table...')\n\n added_colnames = ['comp', 'dist', 'e_dist', 'prob', 'arm',\n 'c_u', 'c_v', 'c_w', 'p_far']\n\n dtypeinput_table = []\n for name, dtype in self.input_table.dtype.descr:\n dtypeinput_table.append(dtype)\n added_dtype = ['i4', 'f4', 'f4', 'f4', 'object',\n 'f4', 'f4', 'f4', 'f4']\n\n if self.check_for_kda_solutions and (self.colname_kda is None):\n added_colnames += ['KDA_ref']\n added_dtype += ['object']\n if self.add_kinematic_distance:\n added_colnames += ['kDist_1', 'kDist_2']\n added_dtype += ['f4', 'f4']\n\n names = self.input_table.colnames + added_colnames\n dtype = dtypeinput_table + added_dtype\n\n self.table_results = Table(data=results, names=names, dtype=dtype)\n\n if self.add_galactocentric_distance:\n rgal = self.galactocentric_distance(\n np.radians(self.table_results[self.colname_lon].data),\n self.table_results['dist'].data,\n glat=np.radians(self.table_results[self.colname_lat].data))\n self.table_results.add_column(Column(data=rgal, name='rgal'))\n\n for key in ['c_u', 'c_v', 'c_w', 'rgal']:\n if key in self.table_results.colnames:\n self.table_results[key].format = \"{0:.3f}\"\n for key in ['dist', 'e_dist', 'prob', 'p_far', 'kDist_1', 'kDist_2']:\n if key in self.table_results.colnames:\n self.table_results[key].format = \"{0:.2f}\"\n\n self.say(\">> saved table '{}' in {}\\n\".format(\n self.table_file, self.dirname_table))\n\n self.table_results.write(self.path_to_table, format=self.table_format,\n overwrite=True)\n\n def choose_distance(self, probabilities, distances, dist_errors):\n \"\"\"Choose distance from alternative solutions.\n\n Flags for the chosen distance:\n - 0: only 1 distance solution existed\n - 1: only distance solution for which associated Gaussian fit had amplitude above three standard deviations of flat distance probability density\n - 2: distance solution had the highest probability\n - 3: distance solutions were tied in their probabilites; chosen distance had the lowest distance error\n - 4: distance solutions were tied in their probabilites and distance errors; chosen distance is the near distance\n\n fwhm_factor = 2 * np.sqrt(2 * np.log(2)) = 2.354820045\n\n Calculate the integrated area of the Gaussian function:\n area_gauss = amp * fwhm / ((1. / np.sqrt(2*np.pi)) * 2*np.sqrt(2*np.log(2)))\n\n combining all constants yields a factor of 0.93943727869965132\n \"\"\"\n if len(probabilities) == 1:\n return [], 0\n\n # check if one of the components had a probability of 1; this implies\n # that the remaining components have a probability of zero. This can # happen as v2.4 of the BDC by default always returns two components\n if 1 in probabilities:\n remove = np.where(probabilities != 1)[0]\n return remove, 0\n\n # to get from integrated intensity (= probabilities) and std (= dist_errors) to amplitude\n amps = probabilities * 0.93943727869965132 / (2.354820045 * dist_errors)\n remove = np.where(amps < 3 * 0.04)[0]\n if len(remove) == 1:\n return remove, 1\n\n remove = np.where(probabilities == min(probabilities))[0]\n if len(remove) == 1:\n return remove, 2\n\n remove = np.where(dist_errors == max(dist_errors))[0]\n if len(remove) == 1:\n return remove, 3\n\n remove = np.argmax(distances)\n return remove, 4\n\n def get_table_distance_max_probability(self, save=True):\n from tqdm import tqdm\n self.say('creating Astropy table containing only distance results '\n 'with the highest probability...')\n\n remove_rows, choice_flags = np.array([]), np.array([])\n\n if self.version == '1.0':\n for idx, component in tqdm(enumerate(self.table_results['comp'])):\n if idx == 0:\n comps_indices = np.array([idx])\n else:\n if (component == 1):\n if comps_indices.size > 1:\n sort_indices_highest_probability = np.argsort(\n self.table_results['prob'][comps_indices])[::-1]\n remove = sort_indices_highest_probability[1:]\n remove_rows = np.append(remove_rows, comps_indices[remove])\n comps_indices = np.array([idx])\n else:\n comps_indices = np.append(comps_indices, idx)\n\n # take care of the last distance results in the list\n sort_indices_highest_probability = np.argsort(\n self.table_results['prob'][comps_indices])[::-1]\n remove = sort_indices_highest_probability[1:]\n remove_rows = np.append(remove_rows, comps_indices[remove])\n elif self.version == '2.4':\n comps_indices = np.array([], dtype='int')\n\n for idx, component in tqdm(enumerate(self.table_results['comp'])):\n comps_indices = np.append(comps_indices, idx)\n\n if len(comps_indices) == component:\n remove, flag = self.choose_distance(\n self.table_results['prob'][comps_indices],\n self.table_results['dist'][comps_indices],\n self.table_results['e_dist'][comps_indices]\n )\n remove_rows = np.append(remove_rows, comps_indices[remove])\n choice_flags = np.append(choice_flags, flag)\n comps_indices = np.array([], dtype='int')\n\n remove_rows = remove_rows.astype(int)\n self.table_results.remove_rows(remove_rows)\n\n if self.version == '2.4':\n self.table_results.add_column(\n Column(data=choice_flags, name='flag', dtype='int'))\n\n if save:\n self.table_file = '{}{}{}'.format(self.table_filename, '_p_max',\n self.table_file_extension)\n self.path_to_table = os.path.join(\n self.dirname_table, self.table_file)\n\n self.say(\">> saved table '{}' in {}\".format(\n self.table_file, self.dirname_table))\n\n self.table_results.write(self.path_to_table,\n format=self.table_format,\n overwrite=True)\n\n def find_index_max_probability(self, indices, arm=False):\n idx = [i for i in indices]\n prob = [self.table['prob'][i] for i in indices]\n max_idx = prob.index(max(prob))\n\n if arm:\n arms = [self.table['arm'][i] for i in indices]\n return idx[max_idx], arms[max_idx]\n else:\n return idx[max_idx]\n\n def order_distances(self, results):\n indices = list(range(len(results)))\n\n distances = np.array([float(result[1]) for result in results])\n dist_errors = np.array([float(result[2]) for result in results])\n probabilities = np.array([float(result[3]) for result in results])\n\n remove, _ = self.choose_distance(probabilities, distances, dist_errors)\n\n first_choice = [i for i in indices if i not in remove]\n choices = first_choice + remove.tolist()\n results = [results[i] for i in choices]\n return results\n\n def plot_probability_density(self, source, results, input_file_content,\n name=None):\n import matplotlib.pyplot as plt\n\n def get_maximum_distance(distance, probability, max_dist=None):\n try:\n prob_threshold = 0.05\n distance_cutoff = distance[probability > prob_threshold][-1]\n return max(max_dist, int(distance_cutoff + 1))\n except IndexError:\n return max_dist\n\n distKD, probKD = np.loadtxt(\n os.path.join(self.path_to_bdc, '{}_kinematic_distance_pdf.dat'.format(source)),\n usecols=(0, 1), skiprows=2, unpack=True)\n\n if self.version == '1.0':\n distGL, probGL = np.loadtxt(\n os.path.join(self.path_to_bdc, '{}_latitude_pdf.dat'.format(source)),\n usecols=(0, 1), skiprows=2, unpack=True)\n\n distSA, probSA = np.loadtxt(\n os.path.join(self.path_to_bdc, '{}_spiral_arm_pdf.dat'.format(source)),\n usecols=(0, 1), skiprows=2, unpack=True)\n elif self.version == '2.4':\n distSA, probSA = np.loadtxt(\n os.path.join(self.path_to_bdc, '{}_arm_latitude_pdf.dat'.format(source)),\n usecols=(0, 1), skiprows=2, unpack=True)\n\n distGL, probGL = distSA, probSA\n\n arm_ranges_lower, arm_ranges_upper = np.loadtxt(\n os.path.join(self.path_to_bdc, '{}_arm_ranges.dat'.format(source)),\n usecols=(0, 1), skiprows=2, unpack=True)\n\n spiral_arms = np.genfromtxt(\n os.path.join(self.path_to_bdc, '{}_arm_ranges.dat'.format(source)),\n skip_header=2, usecols=2, dtype='str')\n\n skip_spiral_arm_ranges = False\n if spiral_arms.size == 2:\n arm_ranges_lower = [arm_ranges_lower[1]]\n arm_ranges_upper = [arm_ranges_upper[1]]\n spiral_arms = [spiral_arms[1]]\n elif spiral_arms.size > 2:\n arm_ranges_lower = arm_ranges_lower[1:]\n arm_ranges_upper = arm_ranges_upper[1:]\n spiral_arms = spiral_arms[1:]\n else:\n skip_spiral_arm_ranges = True\n\n distPS, probPS = np.loadtxt(\n os.path.join(self.path_to_bdc, '{}_parallaxes_pdf.dat'.format(source)),\n usecols=(0, 1), skiprows=2, unpack=True)\n\n distFD, probFD = np.loadtxt(\n os.path.join(self.path_to_bdc, '{}_final_distance_pdf.dat'.format(source)),\n usecols=(0, 1), skiprows=2, unpack=True)\n\n max_dist = 0\n for dist, prob in zip(\n [distKD, distGL, distSA, distPS], [probKD, probGL, probSA, probPS]):\n max_dist = get_maximum_distance(dist, prob, max_dist=max_dist)\n\n fig = plt.figure(figsize=(10, 7.5))\n ax = fig.add_subplot(1, 1, 1)\n\n ax.set_xlabel('Distance [kpc]', size=20)\n ax.set_ylabel('Probability density [kpc$^{-1}$]', size=20)\n\n ax.tick_params(axis='both', labelsize=16, pad=8)\n ax.tick_params(axis='both', which='major', direction='out',\n width=1.25, length=10, pad=8)\n ax.tick_params(axis='both', which='minor', direction='out',\n width=1.25, length=5)\n\n ax.plot(distKD, probKD, label='KD', lw=2.5, ls='solid', c='dodgerblue', alpha=0.75)\n ax.plot(distGL, probGL, label='GL', lw=2.5, ls='dotted', c='orange', alpha=1.0)\n ax.plot(distSA, probSA, label='SA', lw=2.5, ls='--', c='indianred', alpha=1.0)\n ax.plot(distPS, probPS, label='PS', lw=2.5, ls='-.', c='forestgreen', alpha=1.0)\n ax.plot(distFD, probFD, label='combined', lw=2, ls='solid', c='black', alpha=1.0)\n\n if not skip_spiral_arm_ranges:\n for lower, upper, text in zip(\n arm_ranges_lower, arm_ranges_upper, spiral_arms):\n if lower > max_dist:\n continue\n horizontalalignment = 'center'\n if text == 'AqR':\n horizontalalignment = 'left'\n ax.axvspan(lower, upper, alpha=0.15, color='indianred')\n ax.text((upper + lower)/2, ax.get_ylim()[1] * 0.99, text, size=14, color='indianred', horizontalalignment=horizontalalignment, verticalalignment='top')\n\n box = ax.get_position()\n ax.set_position([box.x0, box.y0,\n box.width, box.height * 0.9])\n # Put a legend below current axis\n leg1 = ax.legend(\n loc='upper center', bbox_to_anchor=(0.5, 1.08),\n fancybox=False, shadow=False, ncol=5,\n fontsize=14, numpoints=1, frameon=0)\n\n markers, texts = [], []\n\n if self.version == '2.4':\n results = self.order_distances(results)\n for i, result in enumerate(results):\n dist = float(result[1])\n if dist <= 0:\n continue\n e_dist = float(result[2])\n prob = float(result[3])\n index = 'D$_{{\\\\mathregular{{{}}}}}$'.format(i + 1)\n text = '{a}={b:.1f}$\\\\pm${c:.1f} kpc ({d:.0%})'.format(\n a=index, b=dist, c=e_dist, d=prob)\n marker = ax.scatter(dist, 0 - i*0.01)\n markers.append(marker)\n texts.append(text)\n ax.errorbar(dist, 0 - i*0.01, xerr=e_dist)\n\n leg2 = ax.legend(\n markers, texts,\n loc='upper center', bbox_to_anchor=(0.5, 1.135),\n fancybox=False, shadow=False, ncol=len(results),\n fontsize=14, numpoints=1, frameon=0)\n\n for line in input_file_content:\n if line.startswith('!'):\n continue\n params = line.split()\n glon, glat, vlsr, e_vlsr, p_far = params[1:6]\n break\n\n text = str('$\\\\ell$={} deg, $b$={} deg, '\n 'V$_{{\\\\mathregular{{LSR}}}}$={} $\\\\pm$ {} km/s, '\n 'P$_{{\\\\mathregular{{far}}}}$={}'. format(\n glon, glat, vlsr, e_vlsr, p_far))\n plt.title(text, fontsize=14, pad=50)\n\n ax.set_xlim([0, max_dist])\n\n ax.add_artist(leg1)\n\n if name is not None:\n source = name\n\n path_to_file = os.path.join(self.dirname_table, source + '.pdf')\n plt.savefig(path_to_file, bbox_inches='tight')\n plt.close()\n", "meta": {"hexsha": "7a025a4bb7916bb978c1eb385bc9bc0f1f46bd8e", "size": 44641, "ext": "py", "lang": "Python", "max_stars_repo_path": "BD_wrapper/BD_wrapper.py", "max_stars_repo_name": "mriener/BD_wrapper", "max_stars_repo_head_hexsha": "e61a27c67420359db557329457fff586700d8001", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-03-29T11:35:21.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-29T11:35:21.000Z", "max_issues_repo_path": "BD_wrapper/BD_wrapper.py", "max_issues_repo_name": "mriener/BD_wrapper", "max_issues_repo_head_hexsha": "e61a27c67420359db557329457fff586700d8001", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "BD_wrapper/BD_wrapper.py", "max_forks_repo_name": "mriener/BD_wrapper", "max_forks_repo_head_hexsha": "e61a27c67420359db557329457fff586700d8001", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-06-09T00:37:19.000Z", "max_forks_repo_forks_event_max_datetime": "2020-06-09T00:37:19.000Z", "avg_line_length": 39.4355123675, "max_line_length": 167, "alphanum_fraction": 0.5703277256, "include": true, "reason": "import numpy,from astropy", "num_tokens": 10532, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5350984286266115, "lm_q2_score": 0.37022537869825406, "lm_q1q2_score": 0.19810701837912792}} {"text": "__copyright__ = \"\"\"\nCopyright (C) 2020 Xiaoyu Wei\n\"\"\"\n\n__license__ = \"\"\"\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n\"\"\"\n\nimport itertools\nimport numpy as np\nimport pyopencl as cl\nimport loopy as lp\nfrom pytools import memoize_method, ProcessLogger\nfrom pytools.obj_array import make_obj_array\nfrom boxtree.tools import DeviceDataRecord\nfrom meshmode.array_context import PyOpenCLArrayContext\nfrom meshmode.dof_array import unflatten, flatten, thaw\nfrom volumential.volume_fmm import interpolate_volume_potential\n\nimport logging\nlogger = logging.getLogger(__name__)\n\n\n__doc__ = r\"\"\"\n.. currentmodule:: volumential\n\nFrom :mod:`meshmode`\n-------------------------\n\nInterpolation from functions given by DoF vectors of :mod:`meshmode`.\nThe underlying mesh on the :mod:`meshmode` side must be discretizing the\nsame bounding box.\n\nThe intersection testing assumes a boundedness property for the supported\nelement types: each element is bounded inside the smallest :math:`l^\\infty`\nball that is centered at the element's center and covers all its vertices.\nThis property might be broken, for example, by high order elements that\nwarp the element boundary too much.\n\n.. autoclass:: ElementsToSourcesLookup\n\n.. autoclass:: LeavesToNodesLookup\n\n.. autofunction:: interpolate_from_meshmode\n\nTo :mod:`meshmode`\n---------------------------\n\n\"\"\"\n\n\n# {{{ output\n\nclass ElementsToSourcesLookup(DeviceDataRecord):\n \"\"\"\n .. attribute:: tree\n\n The :class:`boxtree.Tree` instance representing the box mesh.\n\n .. attribute:: discr\n\n The :class:`meshmode.discretization.Discretization` instance\n representing the external mesh and DoF distribution.\n\n .. attribute:: sources_in_element_starts\n\n Indices into :attr:`sources_in_element_lists`.\n\n .. code-block:: python\n\n sources_in_element_lists[\n sources_in_element_starts[global_iel]\n :sources_in_element_starts[global_iel] + 1\n ]\n\n contains the list of source nodes residing in the given element.\n\n .. note:: ``global_iel`` is the global element id in `meshmode`.\n ``global_iel = mesh.groups[igrp].element_nr_base + iel``.\n\n .. attribute:: sources_in_element_lists\n\n Indices into :attr:`tree.sources`.\n\n .. automethod:: get\n \"\"\"\n\n\nclass LeavesToNodesLookup(DeviceDataRecord):\n \"\"\"\n .. attribute:: trav\n\n The :class:`boxtree.FMMTraversalInfo` instance representing the\n box mesh with metadata needed for interpolation. It contains a\n reference to the underlying tree as `trav.tree`.\n\n .. attribute:: discr\n\n The :class:`meshmode.discretization.Discretization` instance\n representing the external mesh and DoF distribution.\n\n .. attribute:: nodes_in_leaf_starts\n\n Indices into :attr:`nodes_in_leaf_lists`.\n\n .. code-block:: python\n\n nodes_in_leaf_lists[\n nodes_in_leaf_starts[box_id]:nodes_in_leaf_starts[box_id] + 1]\n\n contains the list of discretization nodes residing in the given leaf box.\n\n .. note:: Only leaf boxes have non-empty entries in this table.\n Nonetheless, this list is indexed by the global box index.\n\n .. attribute:: nodes_in_leaf_lists\n\n Indices into :attr:`discr.nodes()`.\n\n .. note:: Unlike :class:`ElementsToSourcesLookup`, lists are not disjoint\n in the leaves-to-nodes lookup. :mod:`volumential` automatically computes\n the average contribution from overlapping boxes.\n\n .. automethod:: get\n \"\"\"\n\n# }}} End output\n\n\n# {{{ elements-to-sources lookup builder\n\nclass ElementsToSourcesLookupBuilder:\n \"\"\"Given a :mod:`meshmod` mesh and a :mod:`boxtree.Tree`, both discretizing\n the same bounding box, this class helps to build a look-up table from\n element to source nodes that are positioned inside the element.\n \"\"\"\n\n def __init__(self, context, tree, discr):\n \"\"\"\n :arg tree: a :class:`boxtree.Tree`\n :arg discr: a :class: `meshmode.discretization.Discretization`\n\n Boxes and elements can be non-aligned as long as the domains\n (bounding boxes) are the same.\n \"\"\"\n assert tree.dimensions == discr.dim\n self.dim = discr.dim\n self.context = context\n self.tree = tree\n self.discr = discr\n\n from pyopencl.algorithm import KeyValueSorter\n self.key_value_sorter = KeyValueSorter(context)\n\n from boxtree.area_query import AreaQueryBuilder\n self.area_query_builder = AreaQueryBuilder(self.context)\n\n # {{{ kernel generation\n\n @memoize_method\n def codegen_get_dimension_specific_snippets(self):\n \"\"\"Dimension-dependent code loopy instructions.\n \"\"\"\n import sympy as sp\n axis_names = [\"x\", \"y\", \"z\"]\n axis_names = axis_names[:self.dim]\n\n # tolerance\n tol = -1e-12\n\n def make_sympy_vec(comp_names):\n comps = []\n for cn in comp_names:\n comps.append(sp.var(cn))\n return sp.Matrix(comps)\n\n def get_simplex_measure(vtx_names):\n mat0 = sp.ones(self.dim + 1)\n for iv, v in enumerate(vtx_names):\n vtx = sp.Matrix([sp.var(f\"{v}{comp}\") for comp in axis_names])\n mat0[iv, :-1] = vtx.T\n return str(mat0.det())\n\n if self.dim == 2:\n\n # {{{ 2d\n\n code_get_simplex = \\\n \"\"\"\n <> Ax = mesh_vertices_0[mesh_vertex_indices[iel, 0]]\n <> Ay = mesh_vertices_1[mesh_vertex_indices[iel, 0]]\n <> Bx = mesh_vertices_0[mesh_vertex_indices[iel, 1]]\n <> By = mesh_vertices_1[mesh_vertex_indices[iel, 1]]\n <> Cx = mesh_vertices_0[mesh_vertex_indices[iel, 2]]\n <> Cy = mesh_vertices_1[mesh_vertex_indices[iel, 2]]\n \"\"\"\n code_get_point = \\\n \"\"\"\n <> Px = source_points_0[source_id]\n <> Py = source_points_1[source_id]\n \"\"\"\n # simplex measures\n code_s0 = get_simplex_measure([\"P\", \"B\", \"C\"])\n code_s1 = get_simplex_measure([\"A\", \"P\", \"C\"])\n code_s2 = get_simplex_measure([\"A\", \"B\", \"P\"])\n code_compute_simplex_measures = \\\n f\"\"\"\n <> s0 = {code_s0}\n <> s1 = {code_s1}\n <> s2 = {code_s2}\n \"\"\"\n code_measures_have_common_sign = \" and \".join([\n f\"s{c1} * s{c2} >= {tol}\"\n for c1, c2 in itertools.combinations([\"0\", \"1\"], 2)])\n\n # }}} End 2d\n\n elif self.dim == 3:\n\n # {{{ 3d\n\n code_get_simplex = \\\n \"\"\"\n <> Ax = mesh_vertices_0[mesh_vertex_indices[iel, 0]]\n <> Ay = mesh_vertices_1[mesh_vertex_indices[iel, 0]]\n <> Az = mesh_vertices_2[mesh_vertex_indices[iel, 0]]\n <> Bx = mesh_vertices_0[mesh_vertex_indices[iel, 1]]\n <> By = mesh_vertices_1[mesh_vertex_indices[iel, 1]]\n <> Bz = mesh_vertices_2[mesh_vertex_indices[iel, 1]]\n <> Cx = mesh_vertices_0[mesh_vertex_indices[iel, 2]]\n <> Cy = mesh_vertices_1[mesh_vertex_indices[iel, 2]]\n <> Cz = mesh_vertices_2[mesh_vertex_indices[iel, 2]]\n <> Dx = mesh_vertices_0[mesh_vertex_indices[iel, 3]]\n <> Dy = mesh_vertices_1[mesh_vertex_indices[iel, 3]]\n <> Dz = mesh_vertices_2[mesh_vertex_indices[iel, 3]]\n \"\"\"\n code_get_point = \\\n \"\"\"\n <> Px = source_points_0[source_id]\n <> Py = source_points_1[source_id]\n <> Pz = source_points_2[source_id]\n \"\"\"\n # simplex measures\n code_s0 = get_simplex_measure([\"P\", \"B\", \"C\", \"D\"])\n code_s1 = get_simplex_measure([\"A\", \"P\", \"C\", \"D\"])\n code_s2 = get_simplex_measure([\"A\", \"B\", \"P\", \"D\"])\n code_s3 = get_simplex_measure([\"A\", \"B\", \"C\", \"P\"])\n code_compute_simplex_measures = \\\n f\"\"\"\n <> s0 = {code_s0}\n <> s1 = {code_s1}\n <> s2 = {code_s2}\n <> s3 = {code_s3}\n \"\"\"\n code_measures_have_common_sign = \" and \".join([\n f\"s{c1} * s{c2} >= {tol}\"\n for c1, c2 in itertools.combinations([\"0\", \"1\", \"2\"], 2)])\n\n # }}} End 3d\n\n else:\n raise NotImplementedError()\n\n return {\"code_get_simplex\": code_get_simplex,\n \"code_get_point\": code_get_point,\n \"code_compute_simplex_measures\": code_compute_simplex_measures,\n \"code_measures_have_common_sign\": code_measures_have_common_sign,\n }\n\n @memoize_method\n def get_simplex_lookup_kernel(self):\n \"\"\"Returns a loopy kernel that computes a potential vector\n representing the (q_point --> element_id) relationship.\n When a source q_point lies on the element boundary, it will be\n assigned an element depending on code scheduling. This ensures\n that the resulting lookup lists are disjoint.\n\n The kernel assumes that the mesh uses one single group of simplex elements.\n Also, the test only works for affine elements.\n \"\"\"\n logger.debug(\"start building elements-to-sources lookup kernel\")\n\n snippets = self.codegen_get_dimension_specific_snippets()\n loopy_knl = lp.make_kernel(\n [\"{ [ iel ]: 0 <= iel < nelements }\",\n \"{ [ ineighbor ]: nearby_leaves_beg <= ineighbor < nearby_leaves_end }\",\n \"{ [ isrc ]: 0 <= isrc < n_box_sources }\"\n ],\n [\"\"\"\n for iel\n <> nearby_leaves_beg = leaves_near_ball_starts[iel]\n <> nearby_leaves_end = leaves_near_ball_starts[iel + 1]\n\n {code_get_simplex}\n\n for ineighbor\n <> ileaf = leaves_near_ball_lists[ineighbor]\n <> box_source_beg = box_source_starts[ileaf]\n <> n_box_sources = box_source_counts_cumul[ileaf]\n\n for isrc\n <> source_id = box_source_beg + isrc\n\n {code_get_point}\n {code_compute_simplex_measures}\n\n result[source_id] = if(\n {code_measures_have_common_sign},\n iel,\n result[source_id]) {{atomic}}\n end\n end\n end\n \"\"\".format(**snippets)],\n [lp.ValueArg(\"nelements, dim, nboxes, nsources\", np.int32),\n lp.GlobalArg(\"mesh_vertex_indices\", np.int32, \"nelements, dim+1\"),\n lp.GlobalArg(\"box_source_starts\", np.int32, \"nboxes\"),\n lp.GlobalArg(\"box_source_counts_cumul\", np.int32, \"nboxes\"),\n lp.GlobalArg(\"leaves_near_ball_lists\", np.int32, None),\n lp.GlobalArg(\"result\", np.int32, \"nsources\", for_atomic=True),\n \"...\"],\n name=\"build_sources_in_simplex_lookup\",\n lang_version=(2018, 2),\n )\n\n logger.debug(\"done building elements-to-sources lookup kernel\")\n return loopy_knl\n\n # }}} End kernel generation\n\n def compute_short_lists(self, actx, wait_for=None):\n \"\"\"balls --> overlapping leaves\n \"\"\"\n if not isinstance(actx, PyOpenCLArrayContext):\n if isinstance(actx, cl.CommandQueue):\n from warnings import warn\n warn(\"Command queue passed to the interpolator. \"\n \"Supply an array context to enable proper caching.\")\n actx = PyOpenCLArrayContext(actx)\n else:\n raise ValueError\n\n mesh = self.discr.mesh\n if len(mesh.groups) > 1:\n raise NotImplementedError(\"Mixed elements not supported\")\n melgrp = mesh.groups[0]\n ball_centers_host = (np.max(melgrp.nodes, axis=2)\n + np.min(melgrp.nodes, axis=2)) / 2\n ball_radii_host = np.max(\n np.max(melgrp.nodes, axis=2) - np.min(melgrp.nodes, axis=2),\n axis=0) / 2\n\n ball_centers = make_obj_array([\n cl.array.to_device(actx.queue, center_coord_comp)\n for center_coord_comp in ball_centers_host])\n ball_radii = cl.array.to_device(actx.queue, ball_radii_host)\n\n area_query_result, evt = self.area_query_builder(\n actx.queue, self.tree, ball_centers, ball_radii,\n peer_lists=None, wait_for=wait_for)\n return area_query_result, evt\n\n def __call__(self, actx, balls_to_leaves_lookup=None, wait_for=None):\n \"\"\"\n :arg queue: a :class:`pyopencl.CommandQueue`\n \"\"\"\n if not isinstance(actx, PyOpenCLArrayContext):\n if isinstance(actx, cl.CommandQueue):\n from warnings import warn\n warn(\"Command queue passed to the interpolator. \"\n \"Supply an array context to enable proper caching.\")\n actx = PyOpenCLArrayContext(actx)\n else:\n raise ValueError\n\n slk_plog = ProcessLogger(logger, \"element-to-source lookup: run area query\")\n\n if balls_to_leaves_lookup is None:\n balls_to_leaves_lookup, evt = \\\n self.compute_short_lists(actx.queue, wait_for=wait_for)\n wait_for = [evt]\n\n # -----------------------------------------------------------------\n # Refine the area query using point-in-simplex test\n\n logger.debug(\"element-to-source lookup: refine starts\")\n\n element_lookup_kernel = self.get_simplex_lookup_kernel()\n\n vertices_dev = make_obj_array([\n cl.array.to_device(actx.queue, verts)\n for verts in self.discr.mesh.vertices])\n\n mesh_vertices_kwargs = {\n f\"mesh_vertices_{iaxis}\": vertices_dev[iaxis]\n for iaxis in range(self.dim)}\n\n source_points_kwargs = {\n f\"source_points_{iaxis}\": self.tree.sources[iaxis]\n for iaxis in range(self.dim)}\n\n evt, res = element_lookup_kernel(\n actx.queue, dim=self.dim, nboxes=self.tree.nboxes,\n nelements=self.discr.mesh.nelements, nsources=self.tree.nsources,\n result=cl.array.zeros(actx.queue,\n self.tree.nsources, dtype=np.int32) - 1,\n mesh_vertex_indices=self.discr.mesh.groups[0].vertex_indices,\n box_source_starts=self.tree.box_source_starts,\n box_source_counts_cumul=self.tree.box_source_counts_cumul,\n leaves_near_ball_starts=balls_to_leaves_lookup.leaves_near_ball_starts,\n leaves_near_ball_lists=balls_to_leaves_lookup.leaves_near_ball_lists,\n wait_for=wait_for, **mesh_vertices_kwargs, **source_points_kwargs)\n\n source_to_element_lookup, = res\n\n wait_for = [evt]\n\n # elements = source_to_element_lookup.get()\n # for idx in [362, 365, 874, 877, 1386, 1389, 1898, 1901])\n\n # -----------------------------------------------------------------\n # Invert the source-to-element lookup by a key-value sort\n\n logger.debug(\"element-to-source lookup: key-value sort\")\n\n sources_in_element_starts, sources_in_element_lists, evt = \\\n self.key_value_sorter(\n actx.queue,\n keys=source_to_element_lookup,\n values=cl.array.arange(\n actx.queue, self.tree.nsources, dtype=self.tree.box_id_dtype),\n nkeys=self.discr.mesh.nelements,\n starts_dtype=self.tree.box_id_dtype,\n wait_for=wait_for)\n\n slk_plog.done()\n\n return ElementsToSourcesLookup(\n tree=self.tree, discr=self.discr,\n sources_in_element_starts=sources_in_element_starts,\n sources_in_element_lists=sources_in_element_lists), evt\n\n# }}} End elements-to-sources lookup builder\n\n\n# {{{ leaves-to-nodes lookup builder\n\nclass LeavesToNodesLookupBuilder:\n \"\"\"Given a :mod:`meshmod` mesh and a :mod:`boxtree.Tree`, both discretizing\n the same bounding box, this class helps to build a look-up table from\n leaf boxes to mesh nodes that are positioned inside the box.\n \"\"\"\n\n def __init__(self, context, trav, discr):\n \"\"\"\n :arg trav: a :class:`boxtree.FMMTraversalInfo`\n :arg discr: a :class: `meshmode.discretization.Discretization`\n\n Boxes and elements can be non-aligned as long as the domains\n (bounding boxes) are the same.\n \"\"\"\n assert trav.tree.dimensions == discr.dim\n self.dim = discr.dim\n self.context = context\n self.trav = trav\n self.discr = discr\n\n from boxtree.area_query import LeavesToBallsLookupBuilder\n self.leaves_to_balls_lookup_builder = \\\n LeavesToBallsLookupBuilder(self.context)\n\n def __call__(self, actx, tol=1e-12, wait_for=None):\n \"\"\"\n :arg queue: a :class:`pyopencl.CommandQueue`\n :tol: nodes close enough to the boundary will be treated as\n lying on the boundary, whose interpolated values are averaged.\n \"\"\"\n if not isinstance(actx, PyOpenCLArrayContext):\n if isinstance(actx, cl.CommandQueue):\n from warnings import warn\n warn(\"Command queue passed to the interpolator. \"\n \"Supply an array context to enable proper caching.\")\n actx = PyOpenCLArrayContext(actx)\n else:\n raise ValueError\n\n nodes = flatten(thaw(actx, self.discr.nodes()))\n radii = cl.array.zeros_like(nodes[0]) + tol\n\n lbl_lookup, evt = self.leaves_to_balls_lookup_builder(\n actx.queue, self.trav.tree, nodes, radii, wait_for=wait_for)\n\n return LeavesToNodesLookup(\n trav=self.trav, discr=self.discr,\n nodes_in_leaf_starts=lbl_lookup.balls_near_box_starts,\n nodes_in_leaf_lists=lbl_lookup.balls_near_box_lists), evt\n\n# }}} End leaves-to-nodes lookup builder\n\n\n# {{{ transform helper\n\ndef compute_affine_transform(source_simplex, target_simplex):\n \"\"\"Computes A and b for the affine transform :math:`y = A x + b`\n that maps ``source_simplex`` to ``target_simplex``.\n\n :param source_simplex: a dim-by-(dim+1) :mod:`numpy` array\n :param target_simplex: a dim-by-(dim+1) :mod:`numpy: array\n \"\"\"\n assert source_simplex.shape == target_simplex.shape\n dim = source_simplex.shape[0]\n\n if dim == 2:\n assert source_simplex.shape == (2, 3)\n mat = np.zeros([6, 6])\n mat[:3, :2] = source_simplex.T\n mat[-3:, 2:4] = source_simplex.T\n mat[:3, -2] = 1\n mat[-3:, -1] = 1\n rhs = target_simplex.reshape(-1)\n solu = np.linalg.solve(mat, rhs)\n return solu[:4].reshape(2, 2), solu[-2:]\n\n elif dim == 3:\n assert source_simplex.shape == (3, 4)\n mat = np.zeros([12, 12])\n mat[:4, :3] = source_simplex.T\n mat[4:8, 3:6] = source_simplex.T\n mat[-4:, 6:9] = source_simplex.T\n mat[:4, -3] = 1\n mat[4:8, -2] = 1\n mat[-4:, -1] = 1\n rhs = target_simplex.reshape(-1)\n solu = np.linalg.solve(mat, rhs)\n return solu[:9].reshape(3, 3), solu[-3:]\n\n else:\n raise NotImplementedError()\n\n\ndef invert_affine_transform(mat_a, disp_b):\n \"\"\"Inverts an affine transform given by :math:`y = A x + b`.\n\n :param mat_A: a dim*(dim+1)-by-dim*(dim+1) :mod:`numpy` array\n :param disp_b: a dim*(dim+1) :mod:`numpy` array\n \"\"\"\n iva = np.linalg.inv(mat_a)\n ivb = - iva @ disp_b\n return iva, ivb\n\n# }}} End transform helper\n\n\n# {{{ from meshmode interpolation\n\ndef interpolate_from_meshmode(actx, dof_vec, elements_to_sources_lookup,\n order=\"tree\"):\n \"\"\"Interpolate a DoF vector from :mod:`meshmode`.\n\n :arg dof_vec: a DoF vector representing a field in :mod:`meshmode`\n of shape ``(..., nnodes)``.\n :arg elements_to_sources_lookup: a :class:`ElementsToSourcesLookup`.\n :arg order: order of the output potential, either \"tree\" or \"user\".\n\n .. note:: This function currently supports meshes with just one element\n group. Also, the element group must be simplex-based.\n\n .. note:: This function does some heavy-lifting computation in Python,\n which we intend to optimize in the future. In particular, we plan\n to shift the batched linear solves and basis evaluations to\n :mod:`loopy`.\n\n TODO: make linear solvers available as :mod:`loopy` callables.\n TODO: make :mod:`modepy` emit :mod:`loopy` callables for basis evaluation.\n \"\"\"\n if not isinstance(dof_vec, cl.array.Array):\n raise TypeError(\"non-array passed to interpolator\")\n\n if not isinstance(actx, PyOpenCLArrayContext):\n if isinstance(actx, cl.CommandQueue):\n from warnings import warn\n warn(\"Command queue passed to the interpolator. \"\n \"Supply an array context to enable proper caching.\")\n actx = PyOpenCLArrayContext(actx)\n else:\n raise ValueError\n\n assert len(elements_to_sources_lookup.discr.groups) == 1\n assert len(elements_to_sources_lookup.discr.mesh.groups) == 1\n degroup = elements_to_sources_lookup.discr.groups[0]\n megroup = elements_to_sources_lookup.discr.mesh.groups[0]\n\n if not degroup.is_affine:\n raise ValueError(\n \"interpolation requires global-to-local map, \"\n \"which is only available for affinely mapped elements\")\n\n mesh = elements_to_sources_lookup.discr.mesh\n dim = elements_to_sources_lookup.discr.dim\n template_simplex = mesh.groups[0].vertex_unit_coordinates().T\n\n # -------------------------------------------------------\n # Inversely map source points with a global-to-local map.\n #\n # 1. For each element, solve for the affine map.\n #\n # 2. Apply the map to corresponding source points.\n #\n # This step computes `unit_sources`, the list of inversely\n # mapped source points.\n\n sources_in_element_starts = \\\n elements_to_sources_lookup.sources_in_element_starts.get(actx.queue)\n sources_in_element_lists = \\\n elements_to_sources_lookup.sources_in_element_lists.get(actx.queue)\n tree = elements_to_sources_lookup.tree.get(actx.queue)\n\n unit_sources_host = make_obj_array(\n [np.zeros_like(srccrd) for srccrd in tree.sources])\n\n for iel in range(degroup.nelements):\n vertex_ids = megroup.vertex_indices[iel]\n vertices = mesh.vertices[:, vertex_ids]\n afa, afb = compute_affine_transform(vertices, template_simplex)\n\n beg = sources_in_element_starts[iel]\n end = sources_in_element_starts[iel + 1]\n source_ids_in_el = sources_in_element_lists[beg:end]\n sources_in_el = np.vstack(\n [tree.sources[iaxis][source_ids_in_el] for iaxis in range(dim)])\n\n ivmapped_el_sources = afa @ sources_in_el + afb.reshape([dim, 1])\n for iaxis in range(dim):\n unit_sources_host[iaxis][source_ids_in_el] = \\\n ivmapped_el_sources[iaxis, :]\n\n unit_sources = make_obj_array(\n [cl.array.to_device(actx.queue, usc) for usc in unit_sources_host])\n\n # -----------------------------------------------------\n # Carry out evaluations in the local (template) frames.\n #\n # 1. Assemble a resampling matrix for each element, with\n # the basis functions and the local source points.\n #\n # 2. For each element, perform matvec on the resampling\n # matrix and the local DoF coefficients.\n #\n # This step assumes `unit_sources` computed on device, so\n # that the previous step can be swapped with a kernel without\n # interrupting the followed computation.\n\n mapped_sources = np.vstack(\n [usc.get(actx.queue) for usc in unit_sources])\n\n basis_funcs = degroup.basis()\n\n dof_vec_view = unflatten(\n actx, elements_to_sources_lookup.discr, dof_vec)[0]\n dof_vec_view = dof_vec_view.get()\n\n sym_shape = dof_vec.shape[:-1]\n source_vec = np.zeros(sym_shape + (tree.nsources, ))\n\n for iel in range(degroup.nelements):\n beg = sources_in_element_starts[iel]\n end = sources_in_element_starts[iel + 1]\n source_ids_in_el = sources_in_element_lists[beg:end]\n mapped_sources_in_el = mapped_sources[:, source_ids_in_el]\n local_dof_vec = dof_vec_view[..., iel, :]\n\n # resampling matrix built from Vandermonde matrices\n import modepy as mp\n rsplm = mp.resampling_matrix(\n basis=basis_funcs,\n new_nodes=mapped_sources_in_el,\n old_nodes=degroup.unit_nodes)\n\n if len(sym_shape) == 0:\n local_coeffs = local_dof_vec\n source_vec[source_ids_in_el] = rsplm @ local_coeffs\n else:\n from pytools import indices_in_shape\n for sym_id in indices_in_shape(sym_shape):\n source_vec[sym_id + (source_ids_in_el, )] = \\\n rsplm @ local_dof_vec[sym_id]\n\n source_vec = cl.array.to_device(actx.queue, source_vec)\n\n if order == \"tree\":\n pass # no need to do anything\n elif order == \"user\":\n source_vec = source_vec[tree.sorted_target_ids] # into user order\n else:\n raise ValueError(f\"order must be 'tree' or 'user' (got {order}).\")\n\n return source_vec\n\n# }}} End from meshmode interpolation\n\n\n# {{{ to meshmode interpolation\n\ndef interpolate_to_meshmode(actx, potential, leaves_to_nodes_lookup,\n order=\"tree\"):\n \"\"\"\n :arg potential: a DoF vector representing a field in :mod:`volumential`,\n in tree order.\n :arg leaves_to_nodes_lookup: a :class:`LeavesToNodesLookup`.\n :arg order: order of the input potential, either \"tree\" or \"user\".\n\n :returns: a :class:`pyopencl.Array` of shape (nnodes, 1) containing the\n interpolated data.\n \"\"\"\n if order == \"tree\":\n potential_in_tree_order = True\n elif order == \"user\":\n potential_in_tree_order = False\n else:\n raise ValueError(f\"order must be 'tree' or 'user' (got {order}).\")\n\n if not isinstance(actx, PyOpenCLArrayContext):\n if isinstance(actx, cl.CommandQueue):\n from warnings import warn\n warn(\"Command queue passed to the interpolator. \"\n \"Supply an array context to enable proper caching.\")\n actx = PyOpenCLArrayContext(actx)\n else:\n raise ValueError\n\n target_points = flatten(thaw(actx, leaves_to_nodes_lookup.discr.nodes()))\n\n traversal = leaves_to_nodes_lookup.trav\n tree = leaves_to_nodes_lookup.trav.tree\n\n dim = tree.dimensions\n\n # infer q_order from tree\n pts_per_box = tree.ntargets // traversal.ntarget_boxes\n assert pts_per_box * traversal.ntarget_boxes == tree.ntargets\n\n # allow for +/- 0.25 floating point error\n q_order = int(pts_per_box**(1 / dim) + 0.25)\n assert q_order**dim == pts_per_box\n\n interp_p = interpolate_volume_potential(\n target_points=target_points, traversal=traversal,\n wrangler=None, potential=potential,\n potential_in_tree_order=potential_in_tree_order,\n dim=dim, tree=tree, queue=actx.queue, q_order=q_order,\n dtype=potential.dtype, lbl_lookup=None,\n balls_near_box_starts=leaves_to_nodes_lookup.nodes_in_leaf_starts,\n balls_near_box_lists=leaves_to_nodes_lookup.nodes_in_leaf_lists)\n\n return interp_p\n\n# }}} End to meshmode interpolation\n", "meta": {"hexsha": "7330118979cf854a4a5d4f3e276b267ec45c005c", "size": 28760, "ext": "py", "lang": "Python", "max_stars_repo_path": "volumential/interpolation.py", "max_stars_repo_name": "xywei/volumential", "max_stars_repo_head_hexsha": "07c6ca8c623acf24fb8deddf93baa1035234db58", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2021-05-21T23:57:15.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-07T22:02:50.000Z", "max_issues_repo_path": "volumential/interpolation.py", "max_issues_repo_name": "inducer/volumential", "max_issues_repo_head_hexsha": "290a5943d3f47958dcab6736bc2b758525471570", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-03-26T15:41:27.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-26T15:42:21.000Z", "max_forks_repo_path": "volumential/interpolation.py", "max_forks_repo_name": "inducer/volumential", "max_forks_repo_head_hexsha": "290a5943d3f47958dcab6736bc2b758525471570", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-05-21T21:23:39.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-21T21:23:39.000Z", "avg_line_length": 37.157622739, "max_line_length": 85, "alphanum_fraction": 0.6173157163, "include": true, "reason": "import numpy,import sympy", "num_tokens": 6645, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.519521321952093, "lm_q2_score": 0.3812195803163617, "lm_q1q2_score": 0.19805170031997832}} {"text": "#! /usr/bin/env python\n\n\"LiDAR ground algorithm\"\n\nimport os, glob, argparse, time, math\nimport numpy as np\nfrom laspy.file import File\nimport sqlite3\nimport ConfigParser\n\ndef getArgs():\n\tparser = argparse.ArgumentParser(\n\t\tdescription=\"LiDAR ground and canopy classification.\"\n\t)\n\tparser.add_argument(\n\t\t\"-c\",\n\t\t\"--config\",\n\t\ttype=str,\n\t\trequired=True,\n\t\thelp=\"Configuration File.\"\n\t)\n\tparser.add_argument(\n\t\t\"-g\",\n\t\t\"--ground\",\n\t\taction = \"store_true\",\n\t\thelp=\"Ground classification.\"\n\n\t)\n\tparser.add_argument(\n\t\t\"-t\",\n\t\t\"--toc\",\n\t\taction = \"store_true\",\n\t\thelp=\"Canopy classification.\"\n\n\t)\n\tparser.add_argument(\n\t\t\"-v\",\n\t\t\"--verbose\",\n\t\taction = \"store_true\",\n\t\thelp=\"Print status to screen.\"\n\n\t)\n\n\treturn parser.parse_args()\n\ndef getConfigs(configFile):\n\tConfigs={}\n\ttry:\n\t\tconfig = ConfigParser.ConfigParser()\n\t\tconfig.read(configFile)\n\t\tConfigs[\"paths\"]=dict(config.items(\"paths\"))\n\t\tConfigs[\"vars\"]=dict(config.items(\"vars\"))\n\texcept Exception as e:\n\t\tprint \"Problem parsing configuration file: {}.\".format(configFile)\n\t\traise e\n\treturn Configs\n\nclass Points(object):\n\tdef __init__(self, points, configs, filename):\n\t\tself.points = points\n\t\tself.configs = configs\n\t\tself.filename = filename\n\n\tdef getParams(self):\n\t\t\"\"\"\n\t\t\"\"\"\n\t\tindirs = self.configs[\"paths\"][\"input\"]\n\t\tindir = indirs.split(\":\")[0]\n\t\tos.chdir(indir)\n\t\tinfile=glob.glob(\"*.las\")[0]\n\t\tdata = File(infile, mode=\"r\")\n\t\tself.header = data.header\n\t\t#print self.header\n\t\tself.dtype = data.points.dtype\n\n\tdef write(self):\n\t\toutput = self.configs[\"paths\"][\"output\"]\n\t\tpoints = np.array(self.points, dtype=self.dtype)\n\t\t#print self.header\n\t\toutfile = File(output + self.filename, mode=\"w\", header=self.header)\n\t\toutfile.points = points\n\t\toutfile.close()\n\ndef setGround(pt):\n\tpt = list(pt)\n\tpt[5]=2\n\treturn tuple(pt)\n\ndef setCanopy(pt):\n\tpt = list(pt)\n\tpt[5]=1\n\treturn tuple(pt)\n\ndef height(dz, thresh=1.5):\n\treturn dz < 1.5\n\ndef angle(dX, dY, dZ, thresh=5.5, eps=0.000000001):\n\thyp = math.sqrt((dX)**2+(dY)**2+(dZ)**2)\n\t# Use epsilon equality for floats\n\tif hyp < eps:\n\t\treturn False\n\tdegrees = math.asin(dZ/hyp)*(180/math.pi)\n\treturn degrees < thresh\n\n\ndef groundFilter(seed, pt):\n\tX0=seed[0]*0.001\n\tY0=seed[1]*0.001\n\tZ0=seed[2]*0.001\n\tX1=pt[0]*0.001\n\tY1=pt[1]*0.001\n\tZ1=pt[2]*0.001\n\tdX = X1-X0\n\tdY = Y1-Y0\n\tdZ = Z1-Z0\n\t# skip duplicated point\n\tif seed == pt:\n\t\treturn False\n\treturn height(dZ) and angle(dX, dY, dZ)\n\n\n\n\ndef groundClassifier(configs):\n\t\"\"\"\n\t\"\"\"\n\tt_i = time.time()\n\tpoints = []\n\n\tdatabase = configs[\"paths\"][\"db\"]\n\tconn = sqlite3.connect(database)\n\tc = conn.cursor()\n\tminZs = c.execute(\"\"\"SELECT distinct(hash10), min(Z) FROM pointcloud \n\t\t\t\t\t\t\tWHERE num_returns=return_number\n\t\t\t\t\t\t\tGROUP BY hash10;\"\"\"\n\t).fetchall()\n\tminZs = list(minZs)\n\tprint minZs\n\tcount = 0\n\tfor h, z in minZs:\n\t\tseed = c.execute(\"\"\"\n\t\t\tSELECT\n\t\t\t\tX,\n\t\t\t\tY,\n\t\t\t\tZ,\n\t\t\t\tintensity,\n\t\t\t\tflag_byte,\n\t\t\t\traw_classification,\n\t\t\t\tscan_angle_rank,\n\t\t\t\tuser_data,\n\t\t\t\tpt_src_id,\n\t\t\t\tgps_time\n\t\t\tFROM pointcloud\n\t\t\tWHERE Z=? and hash10=?;\n\t\t\t\"\"\", (z, h)).fetchall()[0]\n\t\tprint seed\n\t\tseed = setGround(seed)\n\t\tpoints.append((seed,))\n\t\tputative_grounds = c.execute(\"\"\"\n\t\t\tSELECT\n\t\t\t\tX,\n\t\t\t\tY,\n\t\t\t\tZ,\n\t\t\t\tintensity,\n\t\t\t\tflag_byte,\n\t\t\t\traw_classification,\n\t\t\t\tscan_angle_rank,\n\t\t\t\tuser_data,\n\t\t\t\tpt_src_id,\n\t\t\t\tgps_time\n\t\t\tFROM pointcloud\n\t\t\tWHERE hash10=? AND num_returns=return_number;\n\t\t\t\"\"\", (h,)).fetchall()\n\t\tfor putative_ground in putative_grounds:\n\t\t\tif groundFilter(seed, putative_ground):\n\t\t\t\tputative_ground=setGround(putative_ground)\n\t\t\t\tpoints.append((putative_ground,))\n\t\tcount += 1\n\t\tprint \"Finished {}; block hash {}.\".format(count, h)\n\tconn.close()\n\tt_f = time.time()\n\tprint \"Ground classifier took {} minutes.\".format((t_f-t_i)/60.0)\n\treturn points\n\n\ndef canopyClassifier(configs):\n\t\"\"\"\n\t\"\"\"\n\tt_i = time.time()\n\tpoints = []\n\tscale = float(configs[\"vars\"][\"scale\"])\n\theight_max = float(configs[\"vars\"][\"height_max\"])/scale # depends on scale\n\tdatabase = configs[\"paths\"][\"db\"]\n\tconn = sqlite3.connect(database)\n\tc = conn.cursor()\n\n\thashmap_list = c.execute(\"SELECT distinct(hash1),hash10 FROM pointcloud;\").fetchall()\n\thashmap = {}\n\tfor k,v in hashmap_list:\n\t\thashmap[k]=v\n\t\n\tminZ_list = c.execute(\"\"\"SELECT distinct(hash10), min(Z) FROM pointcloud\n\t\t\t\t\t\t\tGROUP BY hash10\"\"\"\n\t).fetchall()\n\tmin_z = {}\n\tfor k,v in minZ_list:\n\t\tmin_z[k]=v\n\n\tmaxZs = c.execute(\"\"\"SELECT distinct(hash1), max(Z) FROM pointcloud \n\t\t\t\t\t\t\tWHERE return_number=1\n\t\t\t\t\t\t\tGROUP BY hash1\"\"\"\t\n\t).fetchall()\n\tcount = 0\n\tfor h1,h10 in hashmap.iteritems():\n\t\tz_max = min_z[h10] + height_max\n\t\tresults = c.execute(\"\"\"\n\t\t\tSELECT\n\t\t\t\tX,\n\t\t\t\tY,\n\t\t\t\tZ,\n\t\t\t\tintensity,\n\t\t\t\tflag_byte,\n\t\t\t\traw_classification,\n\t\t\t\tscan_angle_rank,\n\t\t\t\tuser_data,\n\t\t\t\tpt_src_id,\n\t\t\t\tgps_time\n\t\t\tFROM pointcloud\n\t\t\tWHERE Z0:\n\t\t\tTOC = heights[max(heights)]\n\t\t\tTOC = setCanopy(TOC)\n\t\t\tpoints.append((TOC,))\n\t\t\tcount += 1\n\t\t\tprint \"Finished {}; block hash {}.\".format(count, h1)\n\tconn.close()\n\tt_f = time.time()\n\tprint \"Canopy classifier took {} minutes.\".format((t_f-t_i)/60.0)\n\treturn points\n\ndef main():\n\tt_i = time.time()\n\targs=getArgs()\n\tif args.verbose:\n\t\tprint args\n\t#base = os.getcwd()\n\tconfigs = getConfigs(args.config)\n\tif args.verbose:\n\t\tprint configs\n\tif args.ground:\n\t\tpoints = groundClassifier(configs)\n\t\tprint points\n\t\tgroundPoints = Points(points, configs, \"ground.las\")\n\t\tgroundPoints.getParams()\n\t\tgroundPoints.write()\n\t\tdel points\n\tif args.toc:\n\t\tpoints = canopyClassifier(configs)\n\t\tprint points\n\t\tcanopyPoints = Points(points, configs, \"canopy.las\")\n\t\tcanopyPoints.getParams()\n\t\tcanopyPoints.write()\n\t\tdel points\n\tt_f = time.time()\n\tif args.verbose:\n\t\tprint \"Total elapsed time {} minutes.\".format((t_f-t_i)/60)\n\n\n\n\n\n\t\t\t#list_data.append((window_index, data_text))\n\t\t#c.executemany('INSERT INTO pointcloud VALUES (?,?)', list_data)\n\n\n\t#data = group(args.input)\n\t#os.chdir(base)\n\t#print data\n\n\n\n\n\n\nif __name__ == \"__main__\":\n\tmain()", "meta": {"hexsha": "7daab047b080a3dc6a21a1c71ad53e5d45bf589e", "size": 5985, "ext": "py", "lang": "Python", "max_stars_repo_path": "classify.py", "max_stars_repo_name": "africker/lidargc", "max_stars_repo_head_hexsha": "421c21b7a0b6a678d4200007b9b5b5c0629bf6fd", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2015-02-06T03:51:39.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-08T14:57:07.000Z", "max_issues_repo_path": "classify.py", "max_issues_repo_name": "africker/lidargc", "max_issues_repo_head_hexsha": "421c21b7a0b6a678d4200007b9b5b5c0629bf6fd", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "classify.py", "max_forks_repo_name": "africker/lidargc", "max_forks_repo_head_hexsha": "421c21b7a0b6a678d4200007b9b5b5c0629bf6fd", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-07-22T09:53:08.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-28T07:07:10.000Z", "avg_line_length": 20.5670103093, "max_line_length": 86, "alphanum_fraction": 0.6604845447, "include": true, "reason": "import numpy", "num_tokens": 1746, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5195213368305398, "lm_q2_score": 0.3812195662561499, "lm_q1q2_score": 0.19805169868735353}} {"text": "# Copyright (c) 2019 - The Procedural Generation for Gazebo authors\n# For information on the respective copyright owner see the NOTICE file\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom ...parsers.sdf import create_sdf_element\nimport collections\nimport numpy as np\nfrom copy import deepcopy\nfrom .pose import Pose\n\n\nclass Inertial(object):\n def __init__(self, mass=0, ixx=0, iyy=0, izz=0, ixy=0, ixz=0, iyz=0): \n self._mass = mass\n self._pose = Pose()\n self._ixx = ixx\n self._iyy = iyy\n self._izz = izz\n self._ixy = ixy\n self._iyz = iyz\n self._ixz = ixz\n\n def __str__(self):\n pose = self._pose.position + self._pose.rpy\n msg = 'Mass [Kg]={}\\n'.format(self._mass)\n msg += 'Pose={}\\n'.format(pose)\n msg += 'I =\\n'\n msg += '\\tIxx={}\\n'.format(self._ixx)\n msg += '\\tIyy={}\\n'.format(self._iyy)\n msg += '\\tIzz={}\\n'.format(self._izz)\n msg += '\\tIxy={}\\n'.format(self._ixy)\n msg += '\\tIxz={}\\n'.format(self._ixz)\n msg += '\\tIyz={}\\n'.format(self._iyz)\n return msg\n\n @property\n def mass(self):\n return self._mass\n\n @mass.setter\n def mass(self, value):\n assert value > 0, 'Mass must be greater than zero'\n self._mass = value\n\n @property\n def pose(self):\n return self._pose\n\n @pose.setter\n def pose(self, vec):\n if isinstance(vec, Pose):\n self._pose = vec\n else:\n assert isinstance(vec, collections.Iterable), \\\n 'Input pose vector must be iterable'\n assert len(vec) == 6 or len(vec) == 7, \\\n 'Pose must be given as position and Euler angles (x, y, z, ' \\\n 'roll, pitch, yaw) or position and quaternions (x, y, z, ' \\\n 'qx, qy, qz, qw)'\n for item in vec:\n assert isinstance(item, float) or isinstance(item, int), \\\n 'All elements in pose vector must be a float or an integer' \n \n self._pose = Pose(pos=vec[0:3], rot=vec[3::])\n \n @property\n def ixx(self):\n return self._ixx\n\n @ixx.setter\n def ixx(self, value):\n assert isinstance(value, float) or isinstance(value, int), \\\n 'Input value must be a float or an integer, provided={}'.format(type(value))\n self._ixx = value\n\n @property\n def iyy(self):\n return self._iyy\n\n @iyy.setter\n def iyy(self, value):\n assert isinstance(value, float) or isinstance(value, int), \\\n 'Input value must be a float or an integer, provided={}'.format(type(value))\n self._iyy= value\n\n @property\n def izz(self):\n return self._izz\n\n @izz.setter\n def izz(self, value):\n assert isinstance(value, float) or isinstance(value, int), \\\n 'Input value must be a float or an integer, provided={}'.format(type(value))\n self._izz = value\n\n @property\n def ixy(self):\n return self._ixy\n\n @ixy.setter\n def ixy(self, value):\n assert isinstance(value, float) or isinstance(value, int), \\\n 'Input value must be a float or an integer, provided={}'.format(type(value))\n self._ixy = value\n\n @property\n def ixz(self):\n return self._ixz\n\n @ixz.setter\n def ixz(self, value):\n assert isinstance(value, float) or isinstance(value, int), \\\n 'Input value must be a float or an integer, provided={}'.format(type(value))\n self._ixz = value\n\n @property\n def iyz(self):\n return self._iyz\n\n @iyz.setter\n def iyz(self, value):\n assert isinstance(value, float) or isinstance(value, int), \\\n 'Input value must be a float or an integer, provided={}'.format(type(value))\n self._iyz = value\n\n @property\n def moi(self):\n return np.array([\n [self.ixx, self.ixy, self.ixz],\n [-self.ixy, self.iyy, self.iyz],\n [-self.ixz, -self.iyz, self.izz]])\n\n @staticmethod\n def create_inertia(inertia_type, **kwargs):\n if inertia_type == 'solid_sphere':\n return Inertial.create_solid_sphere_inertia(**kwargs)\n elif inertia_type == 'hollow_sphere':\n return Inertial.create_hollow_sphere_inertia(**kwargs)\n elif inertia_type == 'ellipsoid':\n return Inertial.create_ellipsoid_inertia(**kwargs)\n elif inertia_type == 'cuboid':\n return Inertial.create_cuboid_inertia(**kwargs)\n elif inertia_type == 'centered_rod':\n return Inertial.create_centered_rod_inertia(**kwargs)\n elif inertia_type == 'solid_cylinder':\n return Inertial.create_solid_cylinder_inertia(**kwargs)\n elif inertia_type == 'custom':\n return Inertial(**kwargs)\n else:\n return None\n\n @staticmethod\n def create_solid_sphere_inertia(mass, radius):\n assert mass > 0, 'Mass must be greater than zero'\n assert radius > 0, 'Radius must be greater than zero'\n inertia = Inertial()\n\n fac = 2. / 5\n inertia.mass = mass\n inertia.ixx = fac * mass * radius**2\n inertia.iyy = fac * mass * radius**2\n inertia.izz = fac * mass * radius**2\n\n return inertia\n\n @staticmethod\n def create_hollow_sphere_inertia(mass, radius):\n assert mass > 0, 'Mass must be greater than zero'\n assert radius > 0, 'Radius must be greater than zero'\n inertia = Inertial()\n\n fac = 2. / 3\n inertia.mass = mass\n inertia.ixx = fac * mass * radius**2\n inertia.iyy = fac * mass * radius**2\n inertia.izz = fac * mass * radius**2\n\n return inertia\n\n @staticmethod\n def create_ellipsoid_inertia(mass, axis_length_x, axis_length_y, axis_length_z):\n assert mass > 0\n assert axis_length_x > 0\n assert axis_length_y > 0\n assert axis_length_z > 0\n inertia = Inertial()\n\n fac = 1. / 5\n\n inertia.mass = mass\n inertia.ixx = fac * mass * (axis_length_y**2 + axis_length_z**2)\n inertia.iyy = fac * mass * (axis_length_x**2 + axis_length_z**2)\n inertia.izz = fac * mass * (axis_length_x**2 + axis_length_y**2)\n\n return inertia\n\n @staticmethod\n def create_cuboid_inertia(mass, length_x, length_y, length_z):\n assert mass > 0\n assert length_x > 0\n assert length_y > 0\n assert length_z > 0\n inertia = Inertial()\n\n fac = 1. / 12\n\n inertia.mass = mass\n inertia.ixx = fac * mass * (length_y**2 + length_z**2)\n inertia.iyy = fac * mass * (length_x**2 + length_z**2)\n inertia.izz = fac * mass * (length_x**2 + length_y**2)\n\n return inertia\n\n @staticmethod\n def create_centered_rod_inertia(mass, length, axis):\n assert mass > 0\n assert length > 0\n assert isinstance(axis, list)\n assert len(axis) == 3\n assert sum(axis) == 1\n assert axis[0] == 1 or axis[1] == 1 or axis[2] == 1\n inertia = Inertial()\n\n fac = 1. / 12\n inertia.mass = mass\n inertia.ixx = axis[0] * fac * mass * length**2\n inertia.iyy = axis[1] * fac * mass * length**2\n inertia.izz = axis[2] * fac * mass * length**2\n\n return inertia\n\n @staticmethod\n def create_solid_cylinder_inertia(mass, radius, length, axis):\n assert mass > 0, 'Mass must be greater than zero'\n assert length > 0, 'Length must be greater than zero'\n assert radius > 0, 'Radius must be greater than zero'\n assert isinstance(axis, list), 'Axis vector must be provided as a list'\n assert len(axis) == 3, 'Axis vector must have three elements'\n assert sum(axis) == 1, 'Axis vector must be a unit vector'\n assert axis[0] == 1 or axis[1] == 1 or axis[2] == 1\n inertia = Inertial()\n\n fac = 1. / 12\n inertia.mass = mass\n i_axis = 0.5 * mass * radius**2\n i_side = 1. / 12 * mass * (3 * radius**2 + length**2)\n\n inertia.ixx = i_side\n inertia.iyy = i_side\n inertia.izz = i_side\n\n if axis[0] == 1:\n inertia.ixx = i_axis\n elif axis[1] == 1:\n inertia.iyy = i_axis\n else:\n inertia.izz = i_axis\n\n return inertia\n\n def to_sdf(self):\n sdf = create_sdf_element('inertial')\n sdf.mass = self._mass\n sdf.pose = self._pose.to_sdf() \n sdf.inertia.ixx = self._ixx\n sdf.inertia.iyy = self._iyy\n sdf.inertia.izz = self._izz\n sdf.inertia.ixy = self._ixy\n sdf.inertia.ixz = self._ixz\n sdf.inertia.iyz = self._iyz\n return sdf\n\n @staticmethod\n def from_sdf(sdf):\n assert sdf._NAME == 'inertial', 'Input SDF element must be of type inertial'\n inertial = Inertial()\n inertial.mass = sdf.mass.value\n inertial._pose = Pose.from_sdf(sdf.pose)\n inertial.ixx = sdf.inertia.ixx.value\n inertial.iyy = sdf.inertia.iyy.value\n inertial.izz = sdf.inertia.izz.value\n inertial.ixy = sdf.inertia.ixy.value\n inertial.ixz = sdf.inertia.ixz.value\n inertial.iyz = sdf.inertia.iyz.value\n return inertial", "meta": {"hexsha": "4a7805c84e1f605f23846cec94e6c48c159ec0e8", "size": 9730, "ext": "py", "lang": "Python", "max_stars_repo_path": "pcg_libraries/src/pcg_gazebo/simulation/properties/inertial.py", "max_stars_repo_name": "boschresearch/pcg_gazebo_pkgs", "max_stars_repo_head_hexsha": "1c112d01847ca4f8da61ce9b273e13d13bc7eb73", "max_stars_repo_licenses": ["Apache-2.0", "BSD-3-Clause"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-06-26T09:46:03.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-18T17:56:26.000Z", "max_issues_repo_path": "pcg_libraries/src/pcg_gazebo/simulation/properties/inertial.py", "max_issues_repo_name": "boschresearch/pcg_gazebo_pkgs", "max_issues_repo_head_hexsha": "1c112d01847ca4f8da61ce9b273e13d13bc7eb73", "max_issues_repo_licenses": ["Apache-2.0", "BSD-3-Clause"], "max_issues_count": 9, "max_issues_repo_issues_event_min_datetime": "2019-07-18T10:36:05.000Z", "max_issues_repo_issues_event_max_datetime": "2020-10-02T15:26:32.000Z", "max_forks_repo_path": "pcg_libraries/src/pcg_gazebo/simulation/properties/inertial.py", "max_forks_repo_name": "boschresearch/pcg_gazebo_pkgs", "max_forks_repo_head_hexsha": "1c112d01847ca4f8da61ce9b273e13d13bc7eb73", "max_forks_repo_licenses": ["Apache-2.0", "BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-11-01T03:20:11.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-15T23:23:44.000Z", "avg_line_length": 32.8716216216, "max_line_length": 88, "alphanum_fraction": 0.5882836588, "include": true, "reason": "import numpy", "num_tokens": 2607, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.519521321952093, "lm_q2_score": 0.38121956625614994, "lm_q1q2_score": 0.19805169301539852}} {"text": "\"\"\"\nModule for snow masking\n\nCredits:\nCopyright (c) 2017-2022 Matej Aleksandrov, Matej Batič, Grega Milčinski, Domagoj Korais, Matic Lubej (Sinergise)\nCopyright (c) 2017-2022 Žiga Lukšič, Devis Peressutti, Nejc Vesel, Jovan Višnjić, Anže Zupanc (Sinergise)\nCopyright (c) 2019-2020 Jernej Puc, Lojze Žust (Sinergise)\nCopyright (c) 2017-2019 Blaž Sovdat, Andrej Burja, Eva Erzin (Sinergise)\n\nThis source code is licensed under the MIT license found in the LICENSE\nfile in the root directory of this source tree.\n\"\"\"\n\nimport logging\nimport itertools\n\nimport numpy as np\nfrom skimage.morphology import disk, binary_dilation\n\nfrom eolearn.core import EOTask, FeatureType\nfrom .utils import resize_images\n\n\nLOGGER = logging.getLogger(__name__)\n\n\nclass BaseSnowMaskTask(EOTask):\n \"\"\"Base class for snow detection and masking\"\"\"\n\n def __init__(self, data_feature, band_indices, dilation_size=0, undefined_value=0, mask_name=\"SNOW_MASK\"):\n \"\"\"\n :param data_feature: EOPatch feature represented by a tuple in the form of `(FeatureType, 'feature_name')`\n :type data_feature: tuple(FeatureType, str)\n :param band_indices: A list containing the indices at which the required bands can be found in the data_feature.\n :type band_indices: list(int)\n :param dilation_size: Size of the disk in pixels for performing dilation. Value 0 means do not perform\n this post-processing step.\n :type dilation_size: int\n \"\"\"\n self.bands_feature = self.parse_feature(data_feature)\n self.band_indices = band_indices\n self.dilation_size = dilation_size\n self.undefined_value = undefined_value\n self.mask_feature = (FeatureType.MASK, mask_name)\n\n def _apply_dilation(self, snow_masks):\n \"\"\"Apply binary dilation for each mask in the series\"\"\"\n if self.dilation_size:\n snow_masks = np.array([binary_dilation(mask, disk(self.dilation_size)) for mask in snow_masks])\n return snow_masks\n\n def execute(self, eopatch):\n raise NotImplementedError\n\n\nclass SnowMaskTask(BaseSnowMaskTask):\n \"\"\"The task calculates the snow mask using the given thresholds.\n\n The default values were optimised based on the Sentinel-2 L1C processing level. Values might not be optimal for L2A\n processing level\n \"\"\"\n\n NDVI_THRESHOLD = 0.1\n\n def __init__(self, data_feature, band_indices, ndsi_threshold=0.4, brightness_threshold=0.3, **kwargs):\n \"\"\"\n :param data_feature: EOPatch feature represented by a tuple in the form of `(FeatureType, 'feature_name')`\n containing the bands 2, 3, 7, 11, i.e. (FeatureType.DATA, 'BANDS')\n :type data_feature: tuple(FeatureType, str)\n :param band_indices: A list containing the indices at which the required bands can be found in the data_feature.\n The required bands are B03, B04, B08 and B11 and the indices should be provided in this order. If the\n 'BANDS' array contains all 13 L1C bands, then `band_indices=[2, 3, 7, 11]`. If the 'BANDS' are the 12 bands\n with L2A values, then `band_indices=[2, 3, 7, 10]`\n :type band_indices: list(int)\n :param ndsi_threshold: Minimum value of the NDSI required to classify the pixel as snow\n :type ndsi_threshold: float\n :param brightness_threshold: Minimum value of the red band for a pixel to be classified as bright\n :type brightness_threshold: float\n \"\"\"\n super().__init__(data_feature, band_indices, **kwargs)\n self.ndsi_threshold = ndsi_threshold\n self.brightness_threshold = brightness_threshold\n\n def execute(self, eopatch):\n bands = eopatch[self.bands_feature][..., self.band_indices]\n with np.errstate(divide=\"ignore\"):\n # (B03 - B11) / (B03 + B11)\n ndsi = (bands[..., 0] - bands[..., 3]) / (bands[..., 0] + bands[..., 3])\n # (B08 - B04) / (B08 + B04)\n ndvi = (bands[..., 2] - bands[..., 1]) / (bands[..., 2] + bands[..., 1])\n\n ndsi_invalid, ndvi_invalid = ~np.isfinite(ndsi), ~np.isfinite(ndvi)\n ndsi[ndsi_invalid] = self.undefined_value\n ndvi[ndvi_invalid] = self.undefined_value\n\n snow_mask = np.where(\n np.logical_and(\n np.logical_or(\n ndsi >= self.ndsi_threshold, np.abs(ndvi - self.NDVI_THRESHOLD) < self.NDVI_THRESHOLD / 2\n ),\n bands[..., 0] >= self.brightness_threshold,\n ),\n 1,\n 0,\n )\n\n snow_mask = self._apply_dilation(snow_mask)\n\n snow_mask[np.logical_or(ndsi_invalid, ndvi_invalid)] = self.undefined_value\n\n eopatch[self.mask_feature] = snow_mask[..., np.newaxis].astype(bool)\n return eopatch\n\n\nclass TheiaSnowMaskTask(BaseSnowMaskTask):\n \"\"\"Task to add a snow mask to an EOPatch. The input data is either Sentinel-2 L1C or L2A level\n\n Original implementation and documentation available at https://gitlab.orfeo-toolbox.org/remote_modules/let-it-snow\n\n ATBD https://gitlab.orfeo-toolbox.org/remote_modules/let-it-snow/blob/master/doc/atbd/ATBD_CES-Neige.pdf\n\n This task computes a snow mask for the input EOPatch. The `data_feature` to be used as input to the\n classifier is a mandatory argument. If all of the needed features exist already, the classifier is run.\n `linear` interpolation is used for resampling of the `data_feature` and cloud probability map, while `nearest`\n interpolation is used to upsample the binary cloud mask.\n \"\"\"\n\n B10_THR = 0.015\n DEM_FACTOR = 0.00001\n\n def __init__(\n self,\n data_feature,\n band_indices,\n cloud_mask_feature,\n dem_feature,\n dem_params=(100, 0.1),\n red_params=(12, 0.3, 0.1, 0.2, 0.040),\n ndsi_params=(0.4, 0.15, 0.001),\n b10_index=None,\n **kwargs,\n ):\n \"\"\"\n :param data_feature: EOPatch feature represented by a tuple in the form of `(FeatureType, 'feature_name')`\n containing the bands B3, B4, and B11\n\n Example: `(FeatureType.DATA, 'ALL-BANDS')`\n :type data_feature: tuple(FeatureType, str)\n :param band_indices: A list containing the indices at which the required bands can be found in the bands\n feature. If all L1C band values are provided, `band_indices=[2, 3, 11]`. If all L2A band values are\n provided, then `band_indices=[2, 3, 10]`\n :type band_indices: list(int)\n :param cloud_mask_feature: EOPatch CLM feature represented by a tuple in the form of\n `(FeatureType, 'feature_name')` containing the cloud mask\n :type cloud_mask_feature: tuple(FeatureType, str)\n :param dem_feature: EOPatch DEM feature represented by a tuple in the form of `(FeatureType, 'feature_name')`\n containing the digital elevation model\n :type dem_feature: tuple(FeatureType, str)\n :param b10_index: Array index where the B10 band is stored in the bands feature. This is used to refine the\n initial cloud mask\n :type b10_index: int\n :param dem_params: Tuple with parameters pertaining DEM processing. The first value specifies the bin size\n used to group DEM values, while the second value specifies the minimum snow fraction in an elevation band\n to define z_s. With reference to the ATBD, the tuple is (d_z, f_t)\n :type dem_params: (float, float)\n :param red_params: Tuple specifying parameters to process the B04 red band. The first parameter defines the\n scaling factor for down-sampling the red band, the second parameter is the maximum value of the\n down-sampled red band for a dark cloud pixel, the third parameter is the minimum value\n to return a non-snow pixel to the cloud mask, the fourth is the minimum reflectance value to pass the 1st\n snow test, and the fifth is the minimum reflectance value to pass the 2nd snow test. With reference to the\n ATBD, the tuple is (r_f, r_d, r_b, r_1, r_2)\n :type red_params: (float, float, float, float, float)\n :param ndsi_params: Tuple specifying parameters for the NDSI. First parameter is the minimum value to pass the\n 1st snow test, the second parameter is the minimum value to pass the 2nd snow test, and the third parameter\n is the minimum snow fraction in the image to activate the pass 2 snow test. With reference to the\n ATBD, the tuple is (n_1, n_2, f_s)\n :type ndsi_params: (float, float, float)\n \"\"\"\n super().__init__(data_feature, band_indices, **kwargs)\n self.dem_feature = self.parse_feature(dem_feature)\n self.clm_feature = self.parse_feature(cloud_mask_feature)\n self.dem_params = dem_params\n self.red_params = red_params\n self.ndsi_params = ndsi_params\n self.b10_index = b10_index\n self._validate_params()\n\n def _validate_params(self):\n \"\"\"Check length of parameters defining threshold values\"\"\"\n for params, n_params in [(self.dem_params, 2), (self.red_params, 5), (self.ndsi_params, 3)]:\n if not isinstance(params, (tuple, list)) or len(params) != n_params:\n raise ValueError(\n f\"Incorrect format or number of parameters for {params}. Has to be a tuple of length {n_params}\"\n )\n\n def _resample_red(self, input_array):\n \"\"\"Method to resample the values of the red band\n\n The input array is first down-scaled using bicubic interpolation and up-scaled back using nearest neighbour\n interpolation\n\n :param input_array: input values\n :return: resampled values\n \"\"\"\n height, width = input_array.shape[1:]\n size = (height // self.red_params[0], width // self.red_params[0])\n return resize_images(\n resize_images(input_array[..., np.newaxis], new_size=size), new_size=(height, width)\n ).squeeze()\n\n def _adjust_cloud_mask(self, bands, cloud_mask, dem, b10):\n \"\"\"Adjust existing cloud mask using cirrus band if L1C data and resampled red band\n\n Add to the existing cloud mask pixels found thresholding down-sampled red band and cirrus band/DEM\n \"\"\"\n clm_b10 = (\n np.where(b10 > self.B10_THR + self.DEM_FACTOR * dem, 1, 0)\n if b10 is not None\n else np.ones(shape=cloud_mask.shape, dtype=np.uint8)\n )\n return np.logical_or(\n np.where(np.logical_and(cloud_mask == 1, self._resample_red(bands[..., 1]) > self.red_params[1]), 1, 0),\n clm_b10,\n ).astype(np.uint8)\n\n def _apply_first_pass(self, bands, ndsi, clm, dem, clm_temp):\n \"\"\"Apply first pass of snow detection\"\"\"\n snow_mask_pass1 = np.where(\n np.logical_and(\n np.logical_not(clm_temp), np.logical_and(ndsi > self.ndsi_params[0], bands[..., 1] > self.red_params[3])\n ),\n 1,\n 0,\n )\n\n clm_pass1 = np.where(\n np.logical_or(clm_temp, (bands[..., 1] > self.red_params[2]) & np.logical_not(snow_mask_pass1) & clm), 1, 0\n )\n\n dem_edges = np.linspace(\n np.min(dem), np.max(dem), int(np.ceil((np.max(dem) - np.min(dem)) / self.dem_params[0]))\n )\n nbins = len(dem_edges) - 1\n dem_hist_clear_pixels, snow_frac = None, None\n if nbins > 0:\n snow_frac = np.zeros(shape=(bands.shape[0], nbins))\n dem_hist_clear_pixels = np.array(\n [np.histogram(dem[np.logical_not(mask)], bins=dem_edges)[0] for mask in clm_pass1]\n )\n\n for date, nbin in itertools.product(range(bands.shape[0]), range(nbins)):\n if dem_hist_clear_pixels[date, nbin] > 0:\n dem_mask = np.logical_and(dem_edges[nbin] <= dem, dem < dem_edges[nbin + 1])\n in_dem_range_clear = np.where(np.logical_and(dem_mask, np.logical_not(clm_pass1[date])))\n snow_frac[date, nbin] = (\n np.sum(snow_mask_pass1[date][in_dem_range_clear]) / dem_hist_clear_pixels[date, nbin]\n )\n return snow_mask_pass1, snow_frac, dem_edges\n\n def _apply_second_pass(self, bands, ndsi, dem, clm_temp, snow_mask_pass1, snow_frac, dem_edges):\n \"\"\"Second pass of snow detection\"\"\"\n _, height, width, _ = bands.shape\n total_snow_frac = np.sum(snow_mask_pass1, axis=(1, 2)) / (height * width)\n snow_mask_pass2 = np.zeros(snow_mask_pass1.shape)\n for date in range(bands.shape[0]):\n if (total_snow_frac[date] > self.ndsi_params[2]) and (\n snow_frac is not None and np.any(snow_frac[date] > self.dem_params[1])\n ):\n z_s = dem_edges[max(np.argmax(snow_frac[date] > self.dem_params[1]) - 2, 0)]\n snow_mask_pass2[date, :, :] = np.where(\n np.logical_and(\n dem > z_s,\n np.logical_and(\n np.logical_not(clm_temp[date]),\n np.logical_and(ndsi[date] > self.ndsi_params[1], bands[date, ..., 1] > self.red_params[-1]),\n ),\n ),\n 1,\n 0,\n )\n return snow_mask_pass2\n\n def execute(self, eopatch):\n \"\"\"Run multi-pass snow detection\"\"\"\n bands = eopatch[self.bands_feature][..., self.band_indices]\n b10 = eopatch[self.bands_feature][..., self.b10_index] if self.b10_index is not None else None\n dem = eopatch[self.dem_feature][..., 0]\n clm = eopatch[self.clm_feature][..., 0]\n\n with np.errstate(divide=\"ignore\"):\n # (B03 - B11) / (B03 + B11)\n ndsi = (bands[..., 0] - bands[..., 2]) / (bands[..., 0] + bands[..., 2])\n\n ndsi_invalid = ~np.isfinite(ndsi)\n ndsi[ndsi_invalid] = self.undefined_value\n\n clm_temp = self._adjust_cloud_mask(bands, clm, dem, b10)\n\n snow_mask_pass1, snow_frac, dem_edges = self._apply_first_pass(bands, ndsi, clm, dem, clm_temp)\n\n snow_mask_pass2 = self._apply_second_pass(bands, ndsi, dem, clm_temp, snow_mask_pass1, snow_frac, dem_edges)\n\n snow_mask = self._apply_dilation(np.logical_or(snow_mask_pass1, snow_mask_pass2))\n\n eopatch[self.mask_feature] = snow_mask[..., np.newaxis].astype(bool)\n\n return eopatch\n", "meta": {"hexsha": "fc629f2bf06d61a9139716c538f85d6d522a7a54", "size": 14458, "ext": "py", "lang": "Python", "max_stars_repo_path": "mask/eolearn/mask/snow_mask.py", "max_stars_repo_name": "chorng/eo-learn", "max_stars_repo_head_hexsha": "a1a3c6fa5568d398f5e43f5ad5aecdfeb05e8d3c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "mask/eolearn/mask/snow_mask.py", "max_issues_repo_name": "chorng/eo-learn", "max_issues_repo_head_hexsha": "a1a3c6fa5568d398f5e43f5ad5aecdfeb05e8d3c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "mask/eolearn/mask/snow_mask.py", "max_forks_repo_name": "chorng/eo-learn", "max_forks_repo_head_hexsha": "a1a3c6fa5568d398f5e43f5ad5aecdfeb05e8d3c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 46.9415584416, "max_line_length": 120, "alphanum_fraction": 0.638539217, "include": true, "reason": "import numpy", "num_tokens": 3634, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.519521321952093, "lm_q2_score": 0.38121956625614994, "lm_q1q2_score": 0.19805169301539852}} {"text": "import hashlib\nimport logging\nimport subprocess\nfrom abc import abstractmethod\nfrom collections import namedtuple\nfrom os.path import exists, getsize\nfrom typing import Any, Dict, NamedTuple, Optional, Tuple\n\nimport casadi as cas\nimport numpy as np\nfrom jax import jit, vmap\n\nimport lumos.numpy as lnp\nfrom lumos.optimal_control.nlp import MappedConstraints, JaxConstraints, CasConstraints\nfrom lumos.models.composition import CompositeModel\nfrom lumos.optimal_control.nlp import CasConstraints, JaxConstraints\n\nlogger = logging.getLogger(__name__)\n\n\n# Convert from names and arrays to dictionary\ndef _array_to_dict(names, values):\n # We could do dict(zip(names, values)), but unfortunately this does NOT work\n # for casadi as casadi matrices are designed to be non-iterable\n # see: https://github.com/casadi/casadi/issues/2278\n return {name: values[idx] for idx, name in enumerate(names)}\n\n\n# We use namedtuple to make the io names immutable after generation. They will be used\n# for two types of names:\n# the direct names: which are fully defined by the model itself\n# the 'names': which is the eventual IO taking into consideration submodels and etc.\nModelIO = namedtuple(\"BaseIO\", (\"inputs\", \"outputs\", \"residuals\"))\nStateSpaceIO = namedtuple(\n \"StateSpaceIO\",\n (\"states\", \"states_dot\", \"inputs\", \"outputs\", \"con_outputs\", \"residuals\"),\n)\n\n\ndef model_io(\n inputs: Tuple[str] = (), outputs: Tuple[str] = (), residuals: Tuple[str] = (),\n):\n \"\"\"Decorator to set the input and output names of a stateless model.\"\"\"\n\n def wrapper(cls):\n cls._direct_names = ModelIO(inputs=inputs, outputs=outputs, residuals=residuals)\n return cls\n\n return wrapper\n\n\ndef state_space_io(\n states: Tuple[str] = (),\n inputs: Tuple[str] = (),\n outputs: Tuple[str] = (),\n con_outputs: Tuple[str] = (),\n residuals: Tuple[str] = (),\n):\n \"\"\"Decorator to set the input and output names of a StateSpaceModel\"\"\"\n\n def wrapper(cls):\n\n # TODO: an issue with using a decorator instead of directly in the class is that\n # the decorator is executed during import time, which might be harder to debug.\n if not issubclass(cls, StateSpaceModel):\n raise RuntimeError(\n \"state_space_io can only be used for setting the io for \"\n \"StateSpaceModel. Use model_io for other models\"\n )\n\n cls._direct_names = StateSpaceIO(\n states=states,\n states_dot=states, # use the same name as states for the states_dot\n inputs=inputs,\n outputs=outputs,\n con_outputs=con_outputs,\n residuals=residuals,\n )\n\n return cls\n\n return wrapper\n\n\nclass ModelReturn(NamedTuple):\n \"\"\"Return data structure for a static model.\"\"\"\n\n outputs: Dict = {}\n residuals: Dict = {}\n\n\nclass StateSpaceModelReturn(NamedTuple):\n \"\"\"Return data structure for state space model.\"\"\"\n\n states_dot: Dict = {}\n outputs: Dict = {}\n con_outputs: Dict = {}\n residuals: Dict = {}\n\n\nclass ArrayModelReturn(NamedTuple):\n \"\"\"Return data structure for a static model in array forms.\"\"\"\n\n outputs: lnp.ndarray = np.array([])\n residuals: lnp.ndarray = np.array([])\n\n\nclass ArrayStateSpaceModelReturn(NamedTuple):\n \"\"\"Return data structure for state space model in array forms.\"\"\"\n\n # NOTE: we use np empty array instead of lnp.array([]) here because the type is\n # not really affected by user backend choice as it's determined already during the\n # import time as the default values.\n states_dot: lnp.ndarray = np.array([])\n outputs: lnp.ndarray = np.array([])\n con_outputs: lnp.ndarray = np.array([])\n residuals: lnp.ndarray = np.array([])\n\n\nclass Model(CompositeModel):\n \"\"\"Abstract class for mathematical models of the simplest form.\"\"\"\n\n # parameters of the model.\n # TODO: need to constrain this more.\n _params: Dict[str, Any]\n\n # TODO: not designed yet\n model_config: Dict[str, Any]\n\n def __init__(\n self, model_config: Dict[str, Any] = {}, params: Dict[str, Any] = {},\n ):\n super().__init__(model_config=model_config, params=params)\n\n # Build instance specific name attributes\n self._construct_io_names()\n\n @abstractmethod\n def forward(self, *args, **kwargs):\n \"\"\"Abstract method for calling the model.\n\n We name the method to 'forward' to emphasis it's the forward execution of a\n model.h\n \"\"\"\n pass\n\n def apply_and_forward(self, inputs, params):\n self.set_recursive_params(params)\n return self.forward(inputs)\n\n def apply_and_forward_with_arrays(self, inputs, params):\n self.set_recursive_params(params)\n return self.forward_with_array(inputs)\n\n def _construct_io_names(self):\n \"\"\"Create model io names while also taking into account submodels compositoin\"\"\"\n\n self.names = ModelIO(\n inputs=self._direct_names.inputs,\n residuals=self._direct_names.residuals,\n outputs=self._direct_names.outputs\n + tuple(self._collect_children_outputs()),\n )\n\n def _collect_children_outputs(self):\n \"\"\"Collect all children outputs and prefix them with submodel_name\n \n \n eg: the 'power' output of the 'engine' submodel becomes 'engine.power'\n \"\"\"\n children_outputs = []\n if not self.is_leaf():\n for submodel_name, model in self._submodels.items():\n children_outputs += [\n submodel_name + \".\" + n for n in model.names.outputs\n ]\n return children_outputs\n\n def combine_submodel_outputs(self, **kwargs):\n \"\"\"combine the outputs from submodels into large dictionary\n \n kwargs: {name_of_submodel: vector_of_outputs}\n \"\"\"\n combined_dict = {}\n for submodel_name, submodel_outputs in kwargs.items():\n # TODO: maybe we could convert the following to a helper method?\n combined_dict.update(\n {submodel_name + \".\" + n: v for n, v in submodel_outputs.items()}\n )\n\n return combined_dict\n\n @classmethod\n def get_direct_group_names(cls, group: str) -> Tuple[str, ...]:\n \"\"\"Return the direct names of variables inside an IO group.\"\"\"\n\n return getattr(cls._direct_names, group)\n\n def get_group_names(self, group: str) -> Tuple[str, ...]:\n \"\"\"Return the names of variables inside an IO group.\"\"\"\n\n return getattr(self.names, group)\n\n def get_var_index(self, group: str, name: str) -> int:\n if name not in self.get_group_names(group):\n raise KeyError(\n f\"{name} doesnot exist in group: {group}. Valid names are {self.get_group_names(group)} \"\n )\n return self.get_group_names(group).index(name)\n\n def get_var_index_in_flat(self, group: str, name: str) -> int:\n \"\"\"Return variable index in the flat input\"\"\"\n\n # offset before the group\n offsets = np.cumsum([self.get_num_vars(g) for g in self._implicit_inputs])[:-1]\n offsets = dict(zip(self._implicit_inputs, np.insert(offsets, 0, 0)))\n\n return self.get_var_index(group=group, name=name) + offsets[group]\n\n def get_group_indices_in_flat(self, group: str) -> np.ndarray:\n \"\"\"Return the indices for a group of varialbes in the flat input.\"\"\"\n return np.array(\n [self.get_var_index_in_flat(group, n) for n in self.get_group_names(group)],\n dtype=np.int32,\n )\n\n def get_num_vars(self, group: str) -> int:\n return len(self.get_group_names(group))\n\n # TODO: these are convenience methods. Can we dynamically generate them?\n def get_input(self, inputs: lnp.ndarray, name: str) -> float:\n return inputs[self.get_var_index(group=\"inputs\", name=name)]\n\n def get_output(self, outputs: lnp.ndarray, name: str) -> float:\n return outputs[self.get_var_index(group=\"outputs\", name=name)]\n\n def forward_with_arrays(self, inputs):\n inputs = _array_to_dict(self.names.inputs, inputs)\n model_return = self.forward(inputs)\n\n # Convert from dictionary to arrays for the outputs\n kwargs = {\n g: self.make_vector(g, **getattr(model_return, g))\n for g in model_return._fields\n }\n\n return ArrayModelReturn(**kwargs)\n\n @property\n def num_inputs(self):\n return self.get_num_vars(group=\"inputs\")\n\n @property\n def num_outputs(self):\n return self.get_num_vars(group=\"outputs\")\n\n @property\n def num_residuals(self):\n return self.get_num_vars(group=\"residuals\")\n\n @property\n def num_con_outputs(self):\n return self.get_num_vars(group=\"con_outputs\")\n\n def make_const_vector(self, group: str, val: float = 0.0):\n \"\"\"Create an array of constant value representing a group.\"\"\"\n\n return np.ones(self.get_num_vars(group=group)) * val\n\n def make_random_vector(self, group: str):\n \"\"\"Create a random vector representing a group\n\n We make all the values positive for now.\n \"\"\"\n return np.abs(np.random.randn(self.get_num_vars(group=group)))\n\n def _check_keys(self, group, kwargs):\n # check missing names\n input_set = set(kwargs.keys())\n expected_set = set(self.get_group_names(group))\n if not input_set == expected_set:\n if expected_set.issubset(input_set):\n logger.warning(\n f\"{input_set - expected_set} are not valid {group} names.\"\n \" These values are ignored.\"\n )\n else:\n raise ValueError(\n f\"Missing {group} values for {expected_set - input_set}\"\n )\n\n def make_vector(self, group: str, **kwargs) -> lnp.ndarray:\n \"\"\"Create a state vector from kwargs. All values must be provided.\"\"\"\n self._check_keys(group, kwargs)\n return lnp.array(list(kwargs[name] for name in self.get_group_names(group)))\n\n def make_dict(self, group: str, **kwargs) -> Dict[str, Any]:\n \"\"\"Create a dictionary from kwargs. All values must be provided.\n \n This is actually just a thing wrapper on the standard dictionary construction,\n but it additionally checks if all the necessary keys exist\n \"\"\"\n self._check_keys(group, kwargs)\n return kwargs\n\n def make_const_dict(self, group, value: float) -> Dict[str, Any]:\n \"\"\"Create a dictionary for a group filled with constant values.\"\"\"\n return {n: value for n in self.get_group_names(group)}\n\n def plot(self, *args, **kwargs):\n raise NotImplementedError\n\n\nclass StateSpaceModel(Model):\n \"\"\"Compare to a standard model, now we have states.\"\"\"\n\n # We name the inputs to the system simply \"inputs\" instead of \"controls\" in control\n # literature. This is so that StateSpaceModel can be naturally seen as a child of\n # the standard Model, where the only difference is the addition of states.\n\n # TODO: maybe we need a better name for this as this is now only used for the\n # flat input calls which is then used in ocp\n # Maybe explicit_inputs, and implicit_inputs? But for explicit formulation, we also\n # need the outputs defined, so it's not just 'inputs'\n _implicit_inputs: Tuple[str, str, str, str] = (\n \"states\",\n \"inputs\",\n \"states_dot\",\n \"con_outputs\",\n )\n\n def __init__(\n self, params: Dict[str, Any] = {}, model_config: Dict[str, Any] = {},\n ):\n super().__init__(model_config=model_config, params=params)\n self._check_names()\n\n @abstractmethod\n def forward(\n self, states: lnp.ndarray, inputs: lnp.ndarray, mesh: float\n ) -> StateSpaceModelReturn:\n \"\"\"The canonical form.\n\n x_dot = f(x, u, t, p)\n y = g(x, u, t, p)\n \"\"\"\n pass\n\n def apply_and_forward(self, states, inputs, mesh, params):\n self.set_recursive_params(params)\n return self.forward(states, inputs, mesh)\n\n def apply_and_forward_with_arrays(self, states, inputs, mesh, params):\n self.set_recursive_params(params)\n return self.forward_with_arrays(states, inputs, mesh)\n\n def make_state_space_model_return(\n self,\n states_dot: lnp.ndarray,\n outputs: lnp.ndarray = None,\n residuals: lnp.ndarray = None,\n ) -> StateSpaceModelReturn:\n \"\"\"Thin wrapper for StateSpaceModelReturn to handle con_outputs automatically.\"\"\"\n kwargs = {\"states_dot\": states_dot}\n if outputs is not None:\n kwargs[\"outputs\"] = outputs\n\n if residuals is not None:\n kwargs[\"residuals\"] = residuals\n\n return StateSpaceModelReturn(**kwargs)\n\n def _construct_io_names(self):\n \"\"\"Create model io names while also taking into account submodels compositoin.\n \n Similar to Model._construct_io_names, but now needs to operate on more groups\n for state space model.\n \"\"\"\n\n self.names = StateSpaceIO(\n inputs=self._direct_names.inputs,\n states=self._direct_names.states,\n states_dot=self._direct_names.states_dot,\n con_outputs=self._direct_names.con_outputs,\n residuals=self._direct_names.residuals,\n outputs=self._direct_names.outputs\n + tuple(self._collect_children_outputs()),\n )\n\n def _check_names(self):\n # Ensure con_outputs all exist\n for c in self.get_group_names(\"con_outputs\"):\n if c not in self.get_group_names(\"outputs\"):\n raise ValueError(f\"constraint outputs {c} not found in outputs\")\n\n def _extract_con_outputs(self, outputs: Dict[str, Any]) -> Dict[str, Any]:\n return {c: outputs[c] for c in self.get_group_names(\"con_outputs\")}\n\n @property\n def num_implicit_res(self):\n return self.num_states + self.num_con_outputs + self.num_residuals\n\n @property\n def num_implicit_var(self):\n return sum([self.get_num_vars(g) for g in self._implicit_inputs])\n\n @property\n def num_states(self):\n return self.get_num_vars(group=\"states\")\n\n def get_state(self, states: lnp.ndarray, name: str) -> float:\n return states[self.get_var_index(group=\"states\", name=name)]\n\n def forward_with_arrays(self, states, inputs, mesh):\n\n states = _array_to_dict(self.names.states, states)\n inputs = _array_to_dict(self.names.inputs, inputs)\n model_return = self.forward(states, inputs, mesh)\n\n # Convert from dictionary to arrays for the outputs\n kwargs = {\n g: self.make_vector(g, **getattr(model_return, g))\n for g in model_return._fields\n if g != \"con_outputs\"\n }\n\n kwargs[\"con_outputs\"] = self.make_vector(\n \"con_outputs\", **self._extract_con_outputs(model_return.outputs)\n )\n\n return ArrayStateSpaceModelReturn(**kwargs)\n\n def implicit(\n self,\n states: lnp.ndarray,\n inputs: lnp.ndarray,\n states_dot: lnp.ndarray,\n con_outputs: lnp.ndarray,\n mesh: float,\n ) -> lnp.ndarray:\n \"\"\"Implicit form: f(x, u, t, x_dot, y, p) = 0\n\n This is the base class method for models with a forward method to be turned into\n an implicit model.\n\n For models that are really implicit, the user should implement the implicit form\n directly.\n\n the order of the outputs should be: [states_dot, con_outputs, residuals]. This\n is a hard-coded limitation of the current design.\n \"\"\"\n\n model_return = self.forward_with_arrays(states, inputs, mesh)\n\n # TODO: here we return an array, but maybe we should at least always check\n # (especially for user-defined ones) that the residual size is correct.\n #\n # TODO: maybe we should also refer to constraints by name, just like what we did\n # for the decision variables.\n\n # Assemble scaled residuals. We could move scales outside of the residual\n # functions so the scales are no longer compiled into the residual calls. But\n # that would require manually scaling the jacobian and hessian as well -- Doable\n # but not necessary for now.\n\n res = lnp.vector_concat(\n [\n model_return.states_dot - states_dot,\n model_return.con_outputs - con_outputs,\n model_return.residuals,\n ]\n )\n return res\n\n def _split_flat_vars(self, flat_vars: lnp.ndarray):\n split_indices = list(\n np.cumsum([self.get_num_vars(g) for g in self._implicit_inputs])[:-1]\n )\n list_vars = lnp.vector_split(flat_vars, split_indices)\n\n return dict(zip(self._implicit_inputs, list_vars))\n\n def _apply_and_flat_implicit(\n self, flat_vars: lnp.ndarray, mesh: float, params,\n ) -> lnp.ndarray:\n self.set_recursive_params(params)\n dict_vars = self._split_flat_vars(flat_vars)\n\n return self.implicit(**dict_vars, mesh=mesh)\n\n def _implicit_jac(self, flat_vars, mesh, params):\n raise NotImplementedError(\n \"_implicit_jac and _implicit_jacobianstructure needs to be implemented to \"\n \"use custom jacobians\"\n )\n\n def _implicit_jacobianstructure(self):\n raise NotImplementedError(\n \"_implicit_jac and _implicit_jacobianstructure needs to be implemented to \"\n \"use custom jacobians\"\n )\n\n def _implicit_hess(self, flat_vars, mesh, params, mult):\n raise NotImplementedError(\n \"_implicit_hess and _implicit_hessianstructure needs to be implemented to \"\n \"use custom hessian\"\n )\n\n def _implicit_hessianstructure(self):\n raise NotImplementedError(\n \"_implicit_hess and _implicit_hessianstructure needs to be implemented to \"\n \"use custom hessian\"\n )\n\n def batched_forward(\n self,\n states: lnp.ndarray,\n inputs: lnp.ndarray,\n mesh: float,\n params: Optional[Dict[str, Any]] = None,\n ) -> StateSpaceModelReturn:\n return self._batched_forward(states, inputs, mesh, params)\n\n def make_model_algebra_cons(self, backend: str):\n \"\"\"Create the model_algebra constraints that are needed for the OCP.\n\n FIXME: currently we also require this function to formulate the _batched_forward\n function, which we should probaly consider moving somewhere else.\n \"\"\"\n if backend == \"casadi\":\n self._make_casadi_model_algebra_cons()\n elif backend == \"jax\":\n self._make_jax_model_algebra_cons()\n elif backend == \"custom\":\n self._make_custom_model_algebra_cons()\n else:\n raise ValueError(\n f\"{backend} is not supported. Only 'jax', 'casadi' and 'custom' backends are supported.\"\n )\n\n def _model_algebra_jacobianstructure(self):\n \"\"\"A pessimistic estimate for the jacobian structure of model algebra.\n\n NOTE: Here we rely on a few dangerous assumptions:\n 1) the implicit form is a explicit turned into implicit (see model.implicit),\n with states_dot and con_outputs only acting as linear variables.\n 2) the ordering of constraints are assumed to be defined by self.implicit\n\n TODO: if we really want to, we could use casadi to get the symbolic jac struct\n and then apply it to jax functions (and potentially other backend).\n \"\"\"\n # states and inputs are involved in all constraints\n # FIXME: this relies on the ordering of the constraints\n rows = np.stack(\n [np.arange(self.num_implicit_res)] * (self.num_states + self.num_inputs)\n ).T.ravel()\n cols = np.stack(\n [\n np.concatenate(\n [\n self.get_group_indices_in_flat(\"states\"),\n self.get_group_indices_in_flat(\"inputs\"),\n ]\n )\n ]\n * self.num_implicit_res\n ).ravel()\n\n # states_dot part\n # FIXME: this relies on both the ordering of the constraints and the variables\n states_dot_rows = np.arange(self.num_states)\n states_dot_cols = self.get_group_indices_in_flat(\"states_dot\")\n\n # con_outputs part\n # FIXME: this relies on both the ordering of the constraints and the variables\n con_outputs_rows = self.num_states + np.arange(self.num_con_outputs)\n con_outputs_cols = self.get_group_indices_in_flat(\"con_outputs\")\n\n rows = np.concatenate([rows, states_dot_rows, con_outputs_rows])\n cols = np.concatenate([cols, states_dot_cols, con_outputs_cols])\n\n return rows, cols\n\n def _model_algebra_hessianstructure(self):\n \"\"\"A pessimistic estimate for the hessian structure of model algebra.\n\n NOTE: states_dot and con_outputs are only linear, so no hessian entries for\n them, but for truely implicit equations where states_dot or con_outputs are\n algebraic variables they could become nonlinear! But in those case, the\n condensed approach also won't work. (because it has no explicit ODE to work on)\n\n TODO: if we really want to, we could use casadi to get the symbolic jac struct\n and then apply it to jax functions (and potentially other backend).\n \"\"\"\n\n rows, cols = np.nonzero(np.ones((self.num_implicit_var, self.num_implicit_var)))\n\n # remove those related to states_dot and con_outputs\n idx_remove = np.hstack(\n [\n self.get_group_indices_in_flat(\"states_dot\"),\n self.get_group_indices_in_flat(\"con_outputs\"),\n ]\n )\n\n keep_rows = np.array([r not in idx_remove for r in rows])\n keep_cols = np.array([c not in idx_remove for c in cols])\n keep = keep_rows & keep_cols\n\n return rows[keep], cols[keep]\n\n def _make_jax_model_algebra_cons(self):\n # For jax, we rely on jac and hessian to compute the constraints at a later\n # stage. See JaxConstraints\n implicit_functions = {\n \"constraints\": self._apply_and_flat_implicit,\n }\n\n # TODO: _stage_hessianstructure not yet implemented\n self.model_algebra = JaxConstraints(\n num_in=self.num_implicit_var,\n num_con=self.num_implicit_res,\n **implicit_functions,\n jacobian_structure=self._model_algebra_jacobianstructure(),\n hessian_structure=self._model_algebra_hessianstructure(),\n )\n\n # FIXME: handle batched_forward better\n self._batched_forward = lnp.use_backend(\"jax\")(\n jit(vmap(self.apply_and_forward_with_arrays, in_axes=[0, 0, 0, None]))\n )\n\n def _make_custom_model_algebra_cons(self):\n implicit_functions = {\n \"constraints\": self._apply_and_flat_implicit,\n \"jacobian\": self._implicit_jac,\n \"jacobian_structure\": self._implicit_jacobianstructure(),\n \"hessian\": self._implicit_hess,\n \"hessian_structure\": self._implicit_hessianstructure(),\n }\n\n self.model_algebra = MappedConstraints(\n num_in=self.num_implicit_var,\n num_con=self.num_implicit_res,\n **implicit_functions,\n )\n\n def custom_batched_forward(_states, _inputs, _mesh, _params):\n self.set_recursive_params(_params)\n out = lnp.lmap(self.forward)(_states, _inputs, _mesh)\n return StateSpaceModelReturn(*out)\n\n self._batched_forward = custom_batched_forward\n\n def _make_casadi_model_algebra_cons(self, CasType: type = cas.MX):\n # NOTE: for large linear operations, like those in FC layers, MX is much faster\n # than SX both for compilation and executtion\n params = self.get_recursive_params()\n flat_params, unravel = params.tree_ravel()\n\n cas_flat_params = CasType.sym(\"params\", len(flat_params))\n cas_dict_params = unravel(cas_flat_params)\n\n mesh = CasType.sym(\"distance\")\n states = CasType.sym(\"states\", self.num_states)\n inputs = CasType.sym(\"inputs\", self.num_inputs)\n stage_vars = CasType.sym(\"stage_vars\", self.num_implicit_var)\n mult = CasType.sym(\"mult\", self.num_implicit_res)\n\n # Only the model calls need to go inside the context manager.\n with lnp.use_backend(\"casadi\"):\n model_return = self.apply_and_forward_with_arrays(\n states, inputs, mesh, cas_dict_params\n )\n res = self._apply_and_flat_implicit(stage_vars, mesh, cas_dict_params)\n lagrange = lnp.dot(mult, res)\n\n jac = cas.jacobian(res, stage_vars)\n lagrange_hessian, lagrange_gradient = cas.hessian(lagrange, stage_vars)\n\n # Generate code\n filename = \"nlpfunctions\"\n cfile = filename + \".c\"\n # FIXME: path management, currently local directory only\n codegen = cas.CodeGenerator(cfile)\n\n codegen.add(\n cas.Function(\n \"forward\", [states, inputs, mesh, cas_flat_params], [*model_return]\n )\n )\n codegen.add(\n cas.Function(\"implicit_con\", [stage_vars, mesh, cas_flat_params], [res])\n )\n codegen.add(\n cas.Function(\"implicit_jac\", [stage_vars, mesh, cas_flat_params], [jac])\n )\n codegen.add(\n cas.Function(\n \"implicit_hess\",\n [stage_vars, mesh, cas_flat_params, mult],\n [lagrange_hessian],\n )\n )\n codegen.generate()\n\n logger.info(f\"Generated c-code with {getsize(cfile)} lines: \")\n # Call compiler if no library exists already\n with open(cfile, \"rb\") as f:\n file_hash = hashlib.md5()\n for chunk in iter(lambda: f.read(8192), b\"\"):\n file_hash.update(chunk)\n\n library_name = file_hash.hexdigest()\n library_path = \"./\" + library_name + \".so\"\n\n if exists(library_path):\n logger.info(f\"{library_path} already exists, no compliation is needed.\")\n else:\n logger.info(f\"Compiling casadi library {library_path}\")\n cmd = [\"gcc\", \"-fPIC\", \"-o2\", \"-shared\", cfile, \"-o\", library_path]\n p = subprocess.Popen(cmd)\n p.wait()\n\n # Wrap the functions to take in dict params\n # FIXME: fixed thread number\n _mapped_forward = lnp.cmap(\n cas.external(\"forward\", library_path),\n num_workers=32,\n in_axes=[0, 0, 0, None],\n )\n\n def cas_batched_forward(_states, _inputs, _mesh, _params):\n _flat_params, _ = _params.tree_ravel()\n out = _mapped_forward(_states, _inputs, _mesh, _flat_params)\n return StateSpaceModelReturn(*out)\n\n self._batched_forward = cas_batched_forward\n\n # add sparsity structure\n # Can we not get this from the symbolic SX? eg, jac.sparsity(), but then what?\n # This get_triplet interface almost looks like a bug...\n # [*row_indices, [*col_indices]] is what is returned\n # see: http://casadi.sourceforge.net/api/html/d5/da8/classcasadi_1_1Sparsity.html#a1f3eed93488c3cf121f47bec4956927f\n *jac_rows, jac_cols = jac.sparsity().get_triplet()\n *hess_rows, hess_cols = lagrange_hessian.sparsity().get_triplet()\n\n implicit_functions = {\n \"constraints\": cas.external(\"implicit_con\", library_path),\n \"jacobian\": cas.external(\"implicit_jac\", library_path),\n \"hessian\": cas.external(\"implicit_hess\", library_path),\n \"jacobian_structure\": (np.array(jac_rows), np.array(jac_cols)),\n \"hessian_structure\": (np.array(hess_rows), np.array(hess_cols)),\n }\n\n self.model_algebra = CasConstraints(\n num_in=self.num_implicit_var,\n num_con=self.num_implicit_res,\n **implicit_functions,\n )\n\n def export_c_mex(self, cfile: str, CasType: type = cas.MX):\n \"\"\"Export a state space model into c-code that is ready for mex.\n\n The exported function has the following API:\n\n states_dot, outputs, con_outputs, residuals = function(states, inputs, mesh, params)\n where each I/O is an array of the corresponding size.\n\n Args:\n cfile (str): path of the c-file for export, includg .c extension. Limited to\n current working directory only.\n CasType (type, optional): casadi type to use, SX or MX. Defaults to MX.\n\n \"\"\"\n # FIXME: path management, currently local directory only, which is a limitation\n # that comes from casadi\n params = self.get_recursive_params()\n flat_params, unravel = params.tree_ravel()\n\n cas_flat_params = CasType.sym(\"params\", len(flat_params))\n cas_dict_params = unravel(cas_flat_params)\n\n mesh = CasType.sym(\"distance\")\n states = CasType.sym(\"states\", self.num_states)\n inputs = CasType.sym(\"inputs\", self.num_inputs)\n\n # Only the model calls need to go inside the context manager.\n with lnp.use_backend(\"casadi\"):\n model_return = self.apply_and_forward_with_arrays(\n states, inputs, mesh, cas_dict_params\n )\n\n # Generate code\n codegen = cas.CodeGenerator(cfile, dict(mex=True, main=True))\n\n codegen.add(\n cas.Function(\n \"forward\", [states, inputs, mesh, cas_flat_params], [*model_return]\n )\n )\n\n codegen.generate()\n\n # Need to set the parameters back to the original params, as they were replaced\n # with casadi variables during the apply_and_forward_with_arrays\n # TODO: the same also happens to other casadi export and also jax tracing right?\n # Can we generalize this problem?\n self.set_recursive_params(params)\n", "meta": {"hexsha": "eaf6acdbdfb38e9670dbea83acd93cb2590f2d76", "size": 30010, "ext": "py", "lang": "Python", "max_stars_repo_path": "lumos/models/base.py", "max_stars_repo_name": "numagic/lumos", "max_stars_repo_head_hexsha": "f729354613fec84957384323da6d0b69e00ed7cc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-03-15T14:25:23.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-15T14:25:23.000Z", "max_issues_repo_path": "lumos/models/base.py", "max_issues_repo_name": "numagic/lumos", "max_issues_repo_head_hexsha": "f729354613fec84957384323da6d0b69e00ed7cc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lumos/models/base.py", "max_forks_repo_name": "numagic/lumos", "max_forks_repo_head_hexsha": "f729354613fec84957384323da6d0b69e00ed7cc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.049382716, "max_line_length": 123, "alphanum_fraction": 0.6385871376, "include": true, "reason": "import numpy,from jax", "num_tokens": 6559, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.519521321952093, "lm_q2_score": 0.38121955219593834, "lm_q1q2_score": 0.1980516857108188}} {"text": "# -*- coding: utf-8 -*-\n\"\"\"\nsRGB Colourspace\n================\n\nDefines the *sRGB* colourspace:\n\n- :attr:`colour.models.RGB_COLOURSPACE_sRGB`.\n\nReferences\n----------\n- :cite:`InternationalElectrotechnicalCommission1999a` : International\n Electrotechnical Commission. (1999). IEC 61966-2-1:1999 - Multimedia\n systems and equipment - Colour measurement and management - Part 2-1:\n Colour management - Default RGB colour space - sRGB (p. 51).\n https://webstore.iec.ch/publication/6169\n- :cite:`InternationalTelecommunicationUnion2015i` : International\n Telecommunication Union. (2015). Recommendation ITU-R BT.709-6 - Parameter\n values for the HDTV standards for production and international programme\n exchange BT Series Broadcasting service (pp. 1-32).\n https://www.itu.int/dms_pubrec/itu-r/rec/bt/\\\nR-REC-BT.709-6-201506-I!!PDF-E.pdf\n\"\"\"\n\nfrom __future__ import division, unicode_literals\n\nimport numpy as np\n\nfrom colour.colorimetry import CCS_ILLUMINANTS\nfrom colour.models.rgb import RGB_Colourspace, eotf_inverse_sRGB, eotf_sRGB\n\n__author__ = 'Colour Developers'\n__copyright__ = 'Copyright (C) 2013-2020 - Colour Developers'\n__license__ = 'New BSD License - https://opensource.org/licenses/BSD-3-Clause'\n__maintainer__ = 'Colour Developers'\n__email__ = 'colour-developers@colour-science.org'\n__status__ = 'Production'\n\n__all__ = [\n 'PRIMARIES_sRGB', 'WHITEPOINT_NAME_sRGB', 'CCS_WHITEPOINT_sRGB',\n 'MATRIX_sRGB_TO_XYZ', 'MATRIX_XYZ_TO_sRGB', 'RGB_COLOURSPACE_sRGB'\n]\n\nPRIMARIES_sRGB = np.array([\n [0.6400, 0.3300],\n [0.3000, 0.6000],\n [0.1500, 0.0600],\n])\n\"\"\"\n*sRGB* colourspace primaries.\n\nPRIMARIES_sRGB : ndarray, (3, 2)\n\"\"\"\n\nWHITEPOINT_NAME_sRGB = 'D65'\n\"\"\"\n*sRGB* colourspace whitepoint name.\n\nCCS_WHITEPOINT_sRGB : unicode\n\"\"\"\n\nCCS_WHITEPOINT_sRGB = (CCS_ILLUMINANTS['CIE 1931 2 Degree Standard Observer'][\n WHITEPOINT_NAME_sRGB])\n\"\"\"\n*sRGB* colourspace whitepoint chromaticity coordinates.\n\nCCS_WHITEPOINT_sRGB : ndarray\n\"\"\"\n\nMATRIX_sRGB_TO_XYZ = np.array([\n [0.4124, 0.3576, 0.1805],\n [0.2126, 0.7152, 0.0722],\n [0.0193, 0.1192, 0.9505],\n])\n\"\"\"\n*sRGB* colourspace to *CIE XYZ* tristimulus values matrix.\n\nMATRIX_sRGB_TO_XYZ : array_like, (3, 3)\n\"\"\"\n\nMATRIX_XYZ_TO_sRGB = np.array([\n [3.2406, -1.5372, -0.4986],\n [-0.9689, 1.8758, 0.0415],\n [0.0557, -0.2040, 1.0570],\n])\n\"\"\"\n*CIE XYZ* tristimulus values to *sRGB* colourspace matrix.\n\nMATRIX_XYZ_TO_sRGB : array_like, (3, 3)\n\"\"\"\n\nRGB_COLOURSPACE_sRGB = RGB_Colourspace(\n 'sRGB',\n PRIMARIES_sRGB,\n CCS_WHITEPOINT_sRGB,\n WHITEPOINT_NAME_sRGB,\n MATRIX_sRGB_TO_XYZ,\n MATRIX_XYZ_TO_sRGB,\n eotf_inverse_sRGB,\n eotf_sRGB,\n)\nRGB_COLOURSPACE_sRGB.__doc__ = \"\"\"\n*sRGB* colourspace.\n\nReferences\n----------\n:cite:`InternationalElectrotechnicalCommission1999a`,\n:cite:`InternationalTelecommunicationUnion2015i`\n\nRGB_COLOURSPACE_sRGB : RGB_Colourspace\n\"\"\"\n", "meta": {"hexsha": "6ac9d2e23e75d1033ee504e564bdf981305df283", "size": 2892, "ext": "py", "lang": "Python", "max_stars_repo_path": "colour/models/rgb/datasets/srgb.py", "max_stars_repo_name": "wenh06/colour", "max_stars_repo_head_hexsha": "445fdad2711ae39c95b4375166905568d24a95f4", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-09T01:53:40.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-09T01:53:40.000Z", "max_issues_repo_path": "colour/models/rgb/datasets/srgb.py", "max_issues_repo_name": "wenh06/colour", "max_issues_repo_head_hexsha": "445fdad2711ae39c95b4375166905568d24a95f4", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "colour/models/rgb/datasets/srgb.py", "max_forks_repo_name": "wenh06/colour", "max_forks_repo_head_hexsha": "445fdad2711ae39c95b4375166905568d24a95f4", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 25.8214285714, "max_line_length": 78, "alphanum_fraction": 0.7209543568, "include": true, "reason": "import numpy", "num_tokens": 920, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.6513548646660543, "lm_q2_score": 0.3040416686603661, "lm_q1q2_score": 0.19803901994311407}} {"text": "# Functions needed to run Excalibur\n# Data munging in separate file\nfrom os.path import basename\nimport numpy as np\nfrom astropy.time import Time\nfrom scipy import interpolate, optimize\nfrom tqdm.auto import trange\n\nimport warnings\nwarnings.simplefilter('ignore', np.RankWarning)\n\n\n###########################################################\n# PCA Patching\n###########################################################\n\ndef pcaPatch(x_values, mask, K=2, num_iters=50):\n \"\"\"\n Iterative PCA patching, where bad values are replaced\n with denoised values.\n \n Parameters\n ----------\n x_values : 2D array\n List of values we want to denoise\n mask : 2D array\n Mask for x_values that is true for values that\n we would like to denoise\n K : int, optional (default: 2)\n Number of principal components used for denoising\n num_iters : int, optional (default: 50)\n Number of iterations to run iterative PCA patching\n \n Returns\n -------\n x_values : 2D ndarray\n x_values with bad values replaced by denoised values\n mean_x_values : 2D ndarray\n Mean of x_values over all exposures.\n Used as fiducial model of line positions\n PCA is done over deviations from this fiducial model\n denoised_xs : 2D ndarray\n Denoised x values from PCA reconstruction\n uu, ss, vv : ndarrays\n Arrays from single value decomposition. Used to \n reconstruct principal components and their corresponding\n coefficients\n \"\"\"\n K = int(K)\n \n for i in range(num_iters):\n # There should be no more NaN values in x_values\n assert np.sum(np.isnan(x_values)) == 0\n # Redefine mean\n mean_x_values = np.mean(x_values,axis=0)\n \n # Run PCA\n uu,ss,vv = np.linalg.svd(x_values-mean_x_values, full_matrices=False)\n\n # Repatch bad data with K PCA reconstruction\n denoised_xs = mean_x_values + np.dot((uu*ss)[:,:K],vv[:K])\n x_values[mask] = denoised_xs[mask]\n \n return x_values, mean_x_values, denoised_xs, uu, ss, vv\n\n\ndef patchAndDenoise(x_values, orders, waves,\n x_errors=None, times=None, file_list=None,\n K=2, num_iters=50, running_window=9,\n line_cutoff=0.5, file_cutoff=0.5,\n outlier_cut=0, verbose=False):\n \"\"\"\n - Vet for bad lines/exposures\n - Initial patch of bad data with running mean\n - Iterative patch with PCA for specified number of iterations\n - Optional second round of interative PCA patching to catch outliers\n \n \n Parameters\n ----------\n x_values, x_errors : 2D ndarray\n Array of line positions for all lines for each exposure and errors\n orders : 1D ndarray\n Array of orders for each line\n waves : 1D ndarray\n Array of wavelengths for each line\n times : 1D ndarray, optional\n Time stamps for each exposure\n Just written into the returned patch dictionary\n (not explicitely used for this code, but helps with evalWaveSol)\n K : int, optional (default: 2)\n Number of principal components used for denoising\n num_iters : int, optional (default: 50)\n Number of iterations to run iterative PCA patching\n running_window ; int, optional (default: 9)\n Window size of running mean used to initialize pixel values\n for lines missing measured pixel values\n line_cutoff, file_cutoff : float [0,1], optional (default: 0.5)\n Cutoff for bad lines or files, respectively.\n i.e. defaults cut lines that show up in less than 50% of exposure\n and files that contain less than 50% of all lines\n outlier_cut : float, optional (default: 0)\n Sigma cut used to identify outliers following first round of\n iterative PCA.\n Note: 0 means this process isn't done.\n \n Returns\n -------\n patch : dict\n Dictionary containing all the useful information from this process\n (among, very many uselss information!)\n Needed for evalWaveSol function\n \"\"\"\n # Arrays that aren't needed, but are helpful to have in returned dictionary\n if times is None:\n times = np.zeros_like(file_list)\n if x_errors is None:\n x_errors = np.zeros_like(x_errors)\n if file_list is None:\n file_list = np.zeros_like(times)\n \n ### Vetting\n # Find where there is no line information\n x_values[np.nan_to_num(x_values) < 1] = np.nan\n \n # Mask out of order lines\n out_of_order = np.zeros_like(x_values,dtype=bool)\n for m in np.unique(orders):\n I = orders==m\n wave_sort = np.argsort(waves[I])\n for i, exp in enumerate(x_values):\n exp_sort = exp[I][wave_sort]\n exp_diff = np.diff(exp_sort)\n left_diff = np.insert(exp_diff<0,0,False)\n right_diff = np.append(exp_diff<0,False)\n exp_mask = np.logical_or(left_diff,right_diff)\n out_of_order[i,I] = exp_mask.copy()\n x_values[out_of_order] = np.nan\n if verbose:\n num_bad = np.sum(out_of_order)\n num_total = out_of_order.size\n print('{:.3}% of lines masked'.format(\n (num_bad)/num_total*100))\n \n # Get rid of bad lines\n good_lines = np.mean(np.isnan(x_values),axis=0) < line_cutoff\n # Trim everything\n orders = orders[good_lines]\n waves = waves[good_lines]\n x_values = x_values[:,good_lines]\n x_errors = x_errors[:,good_lines]\n if verbose:\n num_good = np.sum(good_lines)\n num_total = good_lines.size\n print('{} of {} lines cut ({:.3}%)'.format(\n (num_total - num_good),num_total,\n (num_total - num_good)/num_total*100))\n \n # Get rid of bad files\n good_files = np.mean(np.isnan(x_values),axis=1) < file_cutoff\n # Trim everything\n x_values = x_values[good_files]\n x_errors = x_errors[good_files]\n file_names = file_list[good_files]\n file_times = times[good_files]\n if verbose:\n num_good = np.sum(good_files)\n num_total = good_files.size\n print('{} of {} files cut ({:.3}%)'.format(\n (num_total - num_good),num_total,\n (num_total - num_good)/num_total*100))\n print('Files that were cut:')\n print(file_list[~good_files])\n \n ### Patching\n # Initial patch of bad data with mean\n bad_mask = np.isnan(x_values) # mask to identify patched x_values\n if running_window > 0:\n half_size = int(running_window//2)\n counter = 6\n while np.sum(np.isnan(x_values)) > 0:\n for i in range(x_values.shape[0]):\n # Identify files in window\n file_range = [max((i-half_size,0)), min((i+half_size+1,x_values.shape[1]))]\n # Find mean of non-NaN values\n run_med = np.nanmean(x_values[file_range[0]:file_range[1],:],axis=0)\n # Patch NaN values with mean for center file\n x_values[i][bad_mask[i,:]] = run_med[bad_mask[i,:]]\n counter -= 1\n if counter < 0:\n print(\"Persistant NaNs with running mean.\")\n print(\"Replacing remaining NaNs with global mean.\")\n tot_mean = np.nanmean(x_values,axis=0)[None,...]*np.ones_like(x_values)\n x_values[np.isnan(x_values)] = tot_mean[np.isnan(x_values)]\n break\n else: # don't bother with running mean\n mean_values = np.nanmean(x_values,axis=0)\n mean_patch = np.array([mean_values for _ in range(x_values.shape[0])])\n x_values[bad_mask] = mean_patch[bad_mask]\n \n # Iterative PCA\n pca_results = pcaPatch(x_values, bad_mask, K=K, num_iters=num_iters)\n x_values, mean_x_values, denoised_xs, uu, ss, vv = pca_results\n \n # Mask line center outliers\n if outlier_cut > 0:\n x_resids = x_values-denoised_xs\n out_mask = abs(x_resids-np.mean(x_resids)) > (outlier_cut*np.nanstd(x_resids))\n if verbose:\n num_out = np.sum(out_mask)\n num_total = out_mask.size\n num_bad = np.sum(np.logical_and(out_mask,bad_mask))\n print('{:.3}% of lines marked as Outliers'.format(\n (num_out)/num_total*100))\n print('{:.3}% of lines marked as Outliers that were PCA Patched'.format(\n (num_bad)/num_total*100))\n pca_results = pcaPatch(x_values, np.logical_or(bad_mask,out_mask),\n K=K, num_iters=num_iters)\n x_values, mean_x_values, denoised_xs, uu, ss, vv = pca_results\n \n # Load in all relevant information into dictionary\n patch_dict = {}\n patch_dict['K'] = K\n # Exposure Information\n patch_dict['files'] = file_names.copy()\n patch_dict['times'] = file_times.copy()\n min_date = Time(file_times.min(),format='mjd').isot.split('T')[0]\n yr, mn, dy = min_date.split('-')\n patch_dict['min_date'] = yr[2:]+mn+dy\n min_date = Time(file_times.max(),format='mjd').isot.split('T')[0]\n yr, mn, dy = min_date.split('-')\n patch_dict['max_date'] = yr[2:]+mn+dy\n # Line Information\n patch_dict['orders'] = orders.copy()\n patch_dict['waves'] = waves.copy()\n # Line Measurement Information\n patch_dict['x_values'] = x_values.copy()\n patch_dict['x_errors'] = x_errors.copy()\n patch_dict['denoised_xs'] = denoised_xs.copy()\n patch_dict['mean_xs'] = mean_x_values.copy()\n patch_dict['bad_mask'] = bad_mask.copy()\n # PCA Information\n patch_dict['u'] = uu.copy()\n patch_dict['s'] = ss.copy()\n patch_dict['v'] = vv.copy()\n patch_dict['ec'] = (uu*ss)[:,:K]\n # Outlier Information\n if outlier_cut > 0:\n patch_dict['out_mask'] = out_mask.copy()\n \n return patch_dict\n\n# Functions for recovering the date of an exposure\ndef isot2date(isot_time):\n yr, mn, dy = isot_time.split('T')[0].split('-')\n return str(int(yr[2:]+mn+dy))\n\ndef mjds2dates(times):\n return np.array([isot2date(Time(t, format='mjd').isot) for t in times]).astype(str)\n\ndef files2dates(files):\n dates = []\n for file_name in files:\n date = basename(file_name).split('_')[-1].split('.')[0]\n dates.append(date)\n return np.array(dates).astype(str)\n\ndef interpPCA(new_interps, patch_dict, intp_deg=1, interp_key='times'):\n \"\"\"\n Interpolate eigen coefficients with respect to chosen interp_key.\n \n Parameters\n ----------\n new_interps : 1D array or float\n New values for which we want principal component coefficients\n patch_dict : dictionary\n Result of patchAndDenoise function\n intp_deg : int, optional (default: 1)\n Degree of inteprolation\n interp_key : str, optional (default: 'times')\n Key in patch_dict of value we want to interpolate the principal\n component coeficients with respect to.\n \n Returns\n -------\n denoised_xs : 1D ndarray\n Pixel positions for calibration lines defined by order and \n wavelength in the provided patch.\n \"\"\"\n try:\n len(new_interps)\n unravel = False\n except TypeError:\n new_interps = [new_interps]\n unravel = True\n K = patch_dict['K']\n vv = patch_dict['v']\n \n # Set up nightly code if needed\n if intp_deg=='poly':\n new_dates = mjds2dates(new_interps)\n cal_dates = files2dates(patch_dict['files'])\n \n # Interpolate eigen coefficients\n new_ecs = np.empty((len(new_interps),K),dtype=float)\n for i in range(K):\n if intp_deg=='poly':\n for date in np.unique(new_dates):\n new_date_mask = new_dates==date\n cal_date_mask = cal_dates==date\n if np.sum(cal_date_mask) < 5:\n continue\n \n z = np.polyfit(patch_dict['times'][cal_date_mask][3:],\n patch_dict['ec'][cal_date_mask][3:,i],3)\n new_ecs[new_date_mask,i] = np.poly1d(z)(new_interps[new_date_mask])\n \n elif intp_deg==0:\n # Find nearest time for each time\n # IS THERE A WAY TO DO THIS NOT ONE BY ONE???\n for i_idx, i in enumerate(new_interps):\n idx = np.abs(patch_dict[interp_key]-i).argmin()\n new_ecs[i_idx,i] = patch_dict['ec'][idx,i]\n \n elif intp_deg==1: # Default\n f = interpolate.interp1d(patch_dict[interp_key],patch_dict['ec'][:,i],kind='linear',\n bounds_error=False,fill_value=np.nan)\n new_ecs[:,i] = f(new_interps)\n \n elif intp_deg==3:\n f = interpolate.interp1d(patch_dict[interp_key],patch_dict['ec'][:,i],kind='cubic',\n bounds_error=False,fill_value=np.nan)\n new_ecs[:,i] = f(new_interps)\n \n else:\n tck = interpolate.splrep(patch_dict[interp_key],patch_dict['ec'][:,i],k=interp_deg)\n new_ecs[:,i] = interpolate.splev(new_interps,tck)\n \n # Construct x values for that period of time\n denoised_xs = np.dot(new_ecs,vv[:K]) + patch_dict['mean_xs']\n \n if unravel:\n return denoised_xs[0]\n else:\n return denoised_xs\n\n\n###########################################################\n# Interpolation Code\n###########################################################\n\ndef interpWaveSol(newx, newm, x, m, data, interp_deg='pchip'):\n \"\"\"\n Interpolate from known lines to construct a wavelength solution\n over new pixels and orders. Proceeds order by order.\n \n Parameters\n ----------\n newx, newm : 1D arrays\n Line centers and matching orders for which to return wavelengths\n x, m, data : 1D arrays\n Line centers, matching orders, and known wavelengths for\n calibration lines\n interp_deg : str or int (1), optional (default: 'pchip')\n Specifies the type of interpolation\n - 'pchip', default, cubic spline with inforced monotonicity\n - 'inverse', fit wave vs. line position with a cubic spline\n (the idea was the constrain the cubic to be a function,\n but pchip does a better job and does it faster)\n - 1, linear interplation (I forget why this is still an option)\n - any other int, spline interpolation of specified degree\n \n Returns\n -------\n prediction : 1D ndarray\n Wavelengths for the input newx and newm\n \"\"\"\n \n # Make all the searches match-able\n newm = np.array(newm,dtype=int)\n m = np.array(m,dtype=int)\n \n # Initialize prediction array\n prediction = np.zeros_like(newx)\n prediction[:] = np.nan\n # Go order by order\n for r in np.unique(m):\n Inew = newm == r\n I = m==r\n if (np.sum(Inew)>0) and (np.sum(I)>0):\n # Sort lines in increasing wavelength\n wave_sort = np.argsort(data[I])\n ord_xs = x[I][wave_sort]\n ord_data = data[I][wave_sort]\n # Make sure the lines are in order\n assert np.all(np.diff(ord_xs) > 0.),print(r,ord_xs[1:][np.argmin(np.diff(ord_xs))])\n \n # Interpolate\n if interp_deg==1: # linear interpolation\n prediction[Inew] = np.interp(newx[Inew], ord_xs, ord_data,\n left=np.nan,right=np.nan,k=interp_deg)\n elif interp_deg == 'pchip': # PCHIP interpolator\n f = interpolate.PchipInterpolator(ord_xs,ord_data,extrapolate=False)\n prediction[Inew] = f(newx[Inew])\n elif interp_deg == 'inverse': # Interpolating wave vs. pixel\n f = interpolate.interp1d(ord_data, ord_xs, kind='cubic',\n bounds_error=False,fill_value=0)\n inv_f = lambda x, a: f(x)-a\n \n f0 = interpolate.UnivariateSpline(ord_xs,ord_data,ext=1)\n \n predict = np.zeros(np.sum(Inew),dtype=float)\n for i,pix in enumerate(newx[Inew]):\n if (pix <= ord_xs.min()) or (pix >= ord_xs.max()): # No extrapolation\n predict[i] = np.nan\n else:\n try:\n x0 = f0(pix)\n predict[i] = optimize.newton(inv_f,x0,args=(pix,))\n except RuntimeError:\n predict[i] = np.nan\n prediction[Inew] = predict\n else: # spline interpolation\n tck = interpolate.splrep(ord_xs, ord_data, k=interp_deg)\n predict = interpolate.splev(newx[Inew],tck,ext=1)\n predict[predict==0] = np.nan\n prediction[Inew] = predict\n return prediction", "meta": {"hexsha": "47c089ba659b2420d8a14587abd1d4f4d3c229a4", "size": 16713, "ext": "py", "lang": "Python", "max_stars_repo_path": "py/excalibur.py", "max_stars_repo_name": "lilyling27/excalibur", "max_stars_repo_head_hexsha": "0d64c89d9613a412c033affbc145920534c4d4ac", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-05-07T14:05:56.000Z", "max_stars_repo_stars_event_max_datetime": "2020-05-07T14:05:56.000Z", "max_issues_repo_path": "py/excalibur.py", "max_issues_repo_name": "davidwhogg/EPRVCalibration", "max_issues_repo_head_hexsha": "e3627366af176f738e1fea7b2701158863889bf6", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "py/excalibur.py", "max_forks_repo_name": "davidwhogg/EPRVCalibration", "max_forks_repo_head_hexsha": "e3627366af176f738e1fea7b2701158863889bf6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.0490654206, "max_line_length": 96, "alphanum_fraction": 0.5940884342, "include": true, "reason": "import numpy,from scipy,from astropy", "num_tokens": 4051, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.658417500561683, "lm_q2_score": 0.3007455852086007, "lm_q1q2_score": 0.19801615651800752}} {"text": "import json\nimport logging\nimport os\nimport traceback\nfrom itertools import compress\n\nimport numpy as np\nimport pymbar\nimport pytraj as pt\nfrom openff.units import unit\nfrom pymbar import timeseries\nfrom scipy.interpolate import Akima1DInterpolator\n\nfrom paprika.io import PaprikaDecoder, PaprikaEncoder\nfrom paprika.utils import check_unit\n\nlogger = logging.getLogger(__name__)\n\n\nclass fe_calc(object):\n \"\"\"\n Computes the free energy for an APR transformation. After calling ``compute_free_energy()``, the\n results are stored in a dictionary called ``results`` in units of kcal/mol.\n\n To get the binding free energy at standard state (ΔG°), we have used the following sign convention:\n\n .. math ::\n ΔG° = ΔG_{attach} + ΔG_{pull} - ΔG_{release} + ΔG_{reference}\n\n .. note ::\n It would be great to add unit support here from ``pint``.\n\n .. warning ::\n This class really ought to be split into a few smaller classes that sublcass a ``BaseAnalysis`` class. There\n could be separate ``MBARAnalysis`` and ``TIAnalysis`` classes, for example. This would make it much more modular\n and easy to test where TI and MBAR disagree. This could also be used to benchmark autocorrelation-based and\n blocking-analysis-based methods for evaluating the statistical inefficiency.\n\n \"\"\"\n\n @property\n def temperature(self):\n \"\"\"float or unit.Quantity: The temperature used during the simulation. This will update β (1/kT) as well.\"\"\"\n return self._temperature\n\n @temperature.setter\n def temperature(self, new_temperature):\n \"\"\"Update temperature and β with a new temperature.\"\"\"\n self._temperature = check_unit(new_temperature, base_unit=unit.kelvin)\n self.beta = 1 / (self.k_B * self._temperature)\n\n @property\n def topology(self):\n \"\"\"\n os.PathLike: The topology (prmtop or pdb) file used for the analysis.\n This should match the topology used for the simulation.\n \"\"\"\n return self._topology\n\n @topology.setter\n def topology(self, value):\n self._topology = value\n\n @property\n def trajectory(self):\n \"\"\"\n os.PathLike: File name of the trajectories to be analyzed in each window (can include a wildcard).\n \"\"\"\n return self._trajectory\n\n @trajectory.setter\n def trajectory(self, value):\n self._trajectory = value\n\n @property\n def path(self):\n \"\"\"\n os.PathLike: The parent directory that contains the simulation windows.\n \"\"\"\n return self._path\n\n @path.setter\n def path(self, value):\n self._path = value\n\n @property\n def restraint_list(self):\n \"\"\"\n list: The list of restraints to be used for analysis.\n \"\"\"\n return self._restraint_list\n\n @restraint_list.setter\n def restraint_list(self, value):\n self._restraint_list = value\n\n @property\n def changing_restraints(self):\n \"\"\"\n dict: Dictionary containing which restraints change during which phase of the calculation.\n\n .. note ::\n This should probably be a private attribute, as this property is determined automatically.\n\n \"\"\"\n return self._changing_restraints\n\n @changing_restraints.setter\n def changing_restraints(self, value):\n self._changing_restraints = value\n\n @property\n def orders(self):\n \"\"\"\n The sorted order of windows for analysis. In principle, windows could be out-of-order if subsequent additional\n sampling was requested.\n\n .. note ::\n As far as I know, we have not tested analysis on windows out of order. We imagined that one could add additional\n λ windows through multiple runs by modifying existing restraints (e.g., restraint values of [0, 0.5, 1.0, 0.8])\n and this module would be able to correctly sort the simulation directories and restraint targets.\n\n .. note ::\n This should probably be a private attribute, as this property is determined automatically.\n\n \"\"\"\n return self._orders\n\n @orders.setter\n def orders(self, value):\n self._orders = value\n\n @property\n def simulation_data(self):\n \"\"\"\n dict: Dictionary containing collected trajectory values for the relevant restraints and windows\n\n .. note ::\n This should probably be a private attribute, as this property is determined automatically.\n\n \"\"\"\n return self._simulation_data\n\n @simulation_data.setter\n def simulation_data(self, value):\n self._simulation_data = value\n\n @property\n def methods(self):\n \"\"\"\n list: List of analysis methods to be performed. This is a combination of free energy method (e.g., MBAR, TI, ...)\n and de-correlation method (blocking, autocorrelation, ...).\n\n Implemented methods are:\n\n - ``mbar-autoc``\n - ``mbar-block``\n - ``ti-block``\n\n .. note ::\n This is really fragile. We should definitely use something like an ``ENUM`` here to check for the few combinations\n that we support.\n\n .. todo ::\n - Add ``ti-autoc``.\n - Add ``wham-block``.\n - Add ``wham-autoc``.\n - Clarify naming.\n - Look into using ``pymbar`` for decorrelation.\n\n \"\"\"\n return self._methods\n\n @methods.setter\n def methods(self, value):\n self._methods = value\n\n @property\n def conservative_subsample(self):\n \"\"\"\n bool: Whether the statistical inefficiency is rounded up to the nearest integer. If ``False``, a non-integer\n value\n is used.\n \"\"\"\n return self._conservative_subsample\n\n @conservative_subsample.setter\n def conservative_subsample(self, value):\n self._conservative_subsample = value\n\n @property\n def bootcycles(self) -> int:\n \"\"\"\n int: The number of bootstrap iterations for the TI methods.\n\n **Default**: ``1000``\n \"\"\"\n return self._bootcycles\n\n @bootcycles.setter\n def bootcycles(self, value):\n self._bootcycles = value\n\n @property\n def compute_roi(self) -> bool:\n \"\"\"\n bool: Whether to compute the return on investment (ROI) value for each window. The more negative the ROI, the\n better the return on investment of computing more frames for this particular window.\n \"\"\"\n return self._compute_roi\n\n @compute_roi.setter\n def compute_roi(self, value):\n self._compute_roi = value\n\n @property\n def compute_largest_neighbor(self):\n \"\"\"\n bool: Whether to find and store the maximum SEM to the neighbor windows. This is useful if using the \"scale_w\"\n approach which is described in Equation (1) in: https://pubs.acs.org/doi/10.1021/acs.jctc.9b00748.\n \"\"\"\n return self._compute_largest_neighbor\n\n @compute_largest_neighbor.setter\n def compute_largest_neighbor(self, value):\n self._compute_largest_neighbor = value\n\n @property\n def ti_matrix(self):\n \"\"\"\n str: If ``full``, the TI mean and SEM free energy is computed between all windows (i.e., the energy differences between\n all windows and all other windows). If ``diagonal``, the mean and SEM of the free energy is computed between the\n first window and all other windows, as well as between all neighboring windows. If ``endpoints``, the mean and\n SEM free energy is computed between only the first and the last window.\n\n For most cases, ``diagonal`` should be sufficient and ``full`` is overkill.\n\n .. note ::\n This is fragile and we should be checking for the valid strings supported.\n\n \"\"\"\n return self._ti_matrix\n\n @ti_matrix.setter\n def ti_matrix(self, value):\n\n if value not in [\"full\", \"diagonal\", \"endpoints\"]:\n raise ValueError(f\"{value} is not a supported integration scheme.\")\n\n self._ti_matrix = value\n\n @property\n def exact_sem_each_ti_fraction(self):\n \"\"\"\n bool: Whether the SEM is computed once for the full data set and then the SEM for each fraction is estimated\n based on the total SEM and the fractional number of uncorrelated data points. If ``True``, the SEM will be recomputed\n each fraction using just that fraction of the raw data.\n \"\"\"\n return self._exact_sem_each_ti_fraction\n\n @exact_sem_each_ti_fraction.setter\n def exact_sem_each_ti_fraction(self, value):\n self._exact_sem_each_ti_fraction = value\n\n @property\n def fractions(self) -> list:\n \"\"\"\n list: A list of fractions of the total data for which a free energy will be computed. Default is [1.0].\n \"\"\"\n return self._fractions\n\n @fractions.setter\n def fractions(self, value):\n\n for fraction in value:\n if fraction < 0.0 or fraction > 1.0:\n raise ValueError(\n f\"Unable to calculation fraction of the data: {fraction}.\"\n )\n\n self._fractions = value\n\n @property\n def results(self):\n \"\"\"\n dict: A dictionary containing the results. The results dictionary is indexed first by phase, and then by\n method. That is, ``results[\"attach\"][\"mbar-block\"]`` will contain the results from analyzing the attach\n phase with the MBAR free energy estimator and blocking analysis used to estimate the SEM.\n\n The final free energy and uncertainty estimate is specified in the ``fe`` and ``sem`` keys.\n\n If multiple fractions of the data are specified, the free energy and SEM from each fraction are stored in a nested\n dictionary under the keys ``fraction_fe`` and ``fractrion_sem``. The number of frames analyzed for each fraciton\n is stored under ``fraction_n_frames``.\n\n The full free energy matrix (window-to-window free energy differences) is stored in the ``fe_matrix`` entry.\n Likewise, the full SEM matrix (window-to-window free energy SEMs) is stored in the ``sem_matrix`` entry.\n\n The work to release the guest to standard concentration is stored under ``ref_state_work``, and is\n negative by convention.\n\n The format of a typical dictionary will resemble this (where I have a omitted the values in the matrices for\n clarity):\n\n ::\n\n {'attach': {'mbar-block': {'fe': 13.019994367423227,\n 'fe_matrix': array(),\n 'fraction_fe': {'1.0': 13.019994367423227},\n 'fraction_fe_matrix': {'1.0': array()},\n 'fraction_n_frames': {'1.0': 2280000},\n 'fraction_sem': {'1.0': 0.12783177525365627},\n 'fraction_sem_matrix': {'1.0': array()},\n 'n_frames': 2280000,\n 'sem': 0.12783177525365627,\n 'sem_matrix': array()},\n 'window_order': array([ 0, 1, 2, ..., 12, 13, 14])},\n 'pull': {'mbar-block': {'fe': 5.367885925413715,\n 'fe_matrix': array(),\n 'fraction_fe': {'1.0': 5.367885925413715},\n 'fraction_fe_matrix': {'1.0': array()},\n 'fraction_n_frames': {'1.0': 2900000},\n 'fraction_sem': {'1.0': 0.21231171453084993},\n 'fraction_sem_matrix': {'1.0': array()},\n 'n_frames': 2900000,\n 'sem': 0.21231171453084993,\n 'sem_matrix': array()},\n 'window_order': array([ 0, 1, 2, ..., 43, 44, 45])},\n 'ref_state_work': -7.141514582862005}\n\n .. note ::\n This will be automatically populated with the outcome of the analysis. Do not directly modify these values.\n\n\n \"\"\"\n return self._results\n\n @results.setter\n def results(self, value):\n self._results = value\n\n @property\n def energy_unit(self):\n \"\"\"pint.unit: The based unit for energy.\"\"\"\n return self._energy_unit\n\n @energy_unit.setter\n def energy_unit(self, value: unit.Quantity):\n self._energy_unit = value\n\n @property\n def distance_unit(self):\n \"\"\"pint.unit: The base unit for distance.\"\"\"\n return self._distance_unit\n\n @distance_unit.setter\n def distance_unit(self, value: unit.Quantity):\n self._distance_unit = value\n\n @property\n def angle_unit(self):\n \"\"\"pint.unit: The base unit for angles.\"\"\"\n return self._angle_unit\n\n @angle_unit.setter\n def angle_unit(self, value: unit.Quantity):\n self._angle_unit = value\n\n @property\n def temperature_unit(self):\n \"\"\"pint.unit: The base unit for temperature.\"\"\"\n return self._temperature_unit\n\n @temperature_unit.setter\n def temperature_unit(self, value: unit.Quantity):\n self._temperature_unit = value\n\n def __init__(self):\n\n self._energy_unit = unit.kcal / unit.mole\n self._distance_unit = unit.angstrom\n self._angle_unit = unit.degrees\n self._temperature_unit = unit.kelvin\n\n self._temperature = 298.15 * self._temperature_unit\n self.k_B = 1.987204118e-3 * self._energy_unit / self._temperature_unit\n self.beta = 1 / (self.k_B * self._temperature)\n self._topology = None\n self._trajectory = None\n self._path = None\n self._restraint_list = []\n self._changing_restraints = None\n self._orders = None\n self._simulation_data = None\n self._methods = [\"mbar-block\"]\n self._conservative_subsample = False\n self._bootcycles = 1000\n self._compute_roi = False\n self._compute_largest_neighbor = False\n self._ti_matrix = \"full\"\n self._exact_sem_each_ti_fraction = False\n self._fractions = [1.0]\n self._results = {}\n\n def collect_data(self, single_topology=False):\n \"\"\"\n Gather simulation data on the distance, angle, and torsion restraints that change during the simulation.\n\n Parameters\n ----------\n single_topology: bool\n Whether a single `topology` file is read for all windows\n \"\"\"\n\n self.changing_restraints = self.identify_changing_restraints()\n self.orders = self.determine_window_order()\n self.simulation_data = self.read_trajectories(single_topology=single_topology)\n\n def collect_data_from_json(self, filepath):\n \"\"\"\n Read in simulation data from a JSON file.\n\n Parameters\n ----------\n filepath: os.PathLike\n The name of the JSON file.\n \"\"\"\n with open(filepath, \"r\") as f:\n json_data = f.read()\n data = json.loads(json_data, cls=PaprikaDecoder)\n\n self.changing_restraints = data[\"changing_restraints\"]\n self.orders = data[\"orders\"]\n self.simulation_data = data[\"simulation_data\"]\n\n def identify_changing_restraints(self):\n \"\"\"Figure out which restraints change during each phase of the calculation.\n\n Returns\n -------\n changing_restraints : dict\n A dictionary containing which restraints change during which phase of the calculation\n \"\"\"\n\n changing_restraints = {\"attach\": [], \"pull\": [], \"release\": []}\n\n for phase in [\"attach\", \"pull\", \"release\"]:\n if phase == \"attach\" or phase == \"release\":\n changing_parameter = \"force_constants\"\n else:\n changing_parameter = \"targets\"\n for restraint in self.restraint_list:\n if restraint.phase[phase][changing_parameter] is not None:\n static = all(\n np.isclose(x, restraint.phase[phase][changing_parameter][0])\n for x in restraint.phase[phase][changing_parameter]\n )\n else:\n static = True\n\n changing_restraints[phase].append(not static)\n\n return changing_restraints\n\n def determine_window_order(self):\n \"\"\"Order the trajectories (i.e., simulation windows) in terms of increasing force constants and\n targets for each restraint.\n\n Returns\n -------\n orders : dict\n The sorted order of windows for analysis\n \"\"\"\n\n orders = {\"attach\": [], \"pull\": [], \"release\": []}\n active_attach_restraints = list(\n compress(self.restraint_list, self.changing_restraints[\"attach\"])\n )\n active_pull_restraints = list(\n compress(self.restraint_list, self.changing_restraints[\"pull\"])\n )\n active_release_restraints = list(\n compress(self.restraint_list, self.changing_restraints[\"release\"])\n )\n\n attach_orders = []\n pull_orders = []\n release_orders = []\n\n for restraint in active_attach_restraints:\n attach_orders.append(\n np.argsort(restraint.phase[\"attach\"][\"force_constants\"])\n )\n if not all([np.array_equal(attach_orders[0], i) for i in attach_orders]):\n raise Exception(\n \"The order of increasing force constants is not the same in all restraints.\"\n )\n elif attach_orders:\n orders[\"attach\"] = attach_orders[0]\n else:\n orders[\"attach\"] = np.empty(0)\n\n for restraint in active_pull_restraints:\n pull_orders.append(np.argsort(restraint.phase[\"pull\"][\"targets\"]))\n if not all([np.array_equal(pull_orders[0], i) for i in pull_orders]):\n raise Exception(\n \"The order of increasing target distances is not the same in all restraints.\"\n )\n elif pull_orders:\n orders[\"pull\"] = pull_orders[0]\n else:\n orders[\"pull\"] = np.empty(0)\n\n for restraint in active_release_restraints:\n release_orders.append(\n np.argsort(restraint.phase[\"release\"][\"force_constants\"])\n )\n if not all([np.array_equal(release_orders[0], i) for i in release_orders]):\n raise Exception(\n \"The order of increasing force constants is not the same in all restraints.\"\n )\n elif release_orders:\n orders[\"release\"] = release_orders[0]\n else:\n orders[\"release\"] = np.empty(0)\n\n return orders\n\n def read_trajectories(self, single_topology=False):\n \"\"\"For each each phase and window, and for each non-static restraint, parse the trajectories to\n get the restraint values.\n\n Parameters\n ----------\n single_topology : bool\n Whether a single `topology` file is read for all windows\n\n Returns\n -------\n data : dict\n Dictionary containing restraint values for analysis\n \"\"\"\n\n data = {\"attach\": [], \"pull\": [], \"release\": []}\n\n ordered_attach_windows = [\n os.path.join(self.path, \"a{:03d}\".format(i))\n for i in self.orders[\"attach\"]\n if i is not None\n ]\n ordered_pull_windows = [\n os.path.join(self.path, \"p{:03d}\".format(i))\n for i in self.orders[\"pull\"]\n if i is not None\n ]\n ordered_release_windows = [\n os.path.join(self.path, \"r{:03d}\".format(i))\n for i in self.orders[\"release\"]\n if i is not None\n ]\n\n active_attach_restraints = np.asarray(self.restraint_list)[\n self.changing_restraints[\"attach\"]\n ]\n active_pull_restraints = np.asarray(self.restraint_list)[\n self.changing_restraints[\"pull\"]\n ]\n active_release_restraints = np.asarray(self.restraint_list)[\n self.changing_restraints[\"release\"]\n ]\n\n # Niel: I'm just checking if *one* restraint is `continuous_apr`,\n # which should be the same value for all restraints.\n if len(active_attach_restraints) > 0:\n if (\n active_attach_restraints[0].continuous_apr\n and self.orders[\"attach\"].size > 0\n and self.orders[\"pull\"].size > 0\n ):\n logger.debug(\n \"Replacing {} with {} in {} for `continuous_apr`...\".format(\n ordered_attach_windows[-1],\n ordered_pull_windows[0],\n ordered_attach_windows,\n )\n )\n ordered_attach_windows[-1] = ordered_pull_windows[0]\n\n if len(active_release_restraints) > 0:\n if (\n active_release_restraints[0].continuous_apr\n and self.orders[\"release\"].size > 0\n and self.orders[\"pull\"].size > 0\n ):\n logger.debug(\n \"Replacing {} with {} in {} for `continuous_apr`...\".format(\n ordered_release_windows[-1],\n ordered_pull_windows[-1],\n ordered_release_windows,\n )\n )\n ordered_release_windows[-1] = ordered_pull_windows[-1]\n\n for window_index, window in enumerate(ordered_attach_windows):\n phase = \"attach\"\n data[phase].append([])\n traj = load_trajectory(\n window, self.trajectory, self.topology, single_topology\n )\n for restraint_index, restraint in enumerate(active_attach_restraints):\n data[phase][window_index].append([])\n data[phase][window_index][restraint_index] = read_restraint_data(\n traj, restraint\n )\n\n for window_index, window in enumerate(ordered_pull_windows):\n phase = \"pull\"\n data[phase].append([])\n traj = load_trajectory(\n window, self.trajectory, self.topology, single_topology\n )\n for restraint_index, restraint in enumerate(active_pull_restraints):\n data[phase][window_index].append([])\n data[phase][window_index][restraint_index] = read_restraint_data(\n traj, restraint\n )\n\n for window_index, window in enumerate(ordered_release_windows):\n phase = \"release\"\n data[phase].append([])\n traj = load_trajectory(\n window, self.trajectory, self.topology, single_topology\n )\n for restraint_index, restraint in enumerate(active_release_restraints):\n data[phase][window_index].append([])\n data[phase][window_index][restraint_index] = read_restraint_data(\n traj, restraint\n )\n\n return data\n\n def prepare_data(self, phase):\n number_of_windows = len(self.simulation_data[phase])\n data_points = [len(np.asarray(x).T) for x in self.simulation_data[phase]]\n max_data_points = max(data_points)\n active_restraints = list(\n compress(self.restraint_list, self.changing_restraints[phase])\n )\n force_constants = [\n np.copy(i.phase[phase][\"force_constants\"]) for i in active_restraints\n ]\n targets = [i.phase[phase][\"targets\"] for i in active_restraints]\n\n ordered_force_constants = [i[self.orders[phase]] for i in force_constants]\n ordered_targets = [i[self.orders[phase]] for i in targets]\n\n return (\n number_of_windows,\n data_points,\n max_data_points,\n active_restraints,\n ordered_force_constants,\n ordered_targets,\n self.simulation_data[phase],\n )\n\n def run_mbar(self, phase, prepared_data, method, verbose=False):\n \"\"\"\n Compute the free energy matrix for a series of windows. We'll follow the pymbar nomenclature for data structures.\n\n Parameters\n ----------\n phase: str\n The phase of the calculation to analyze.\n prepared_data: :class:`np.array`\n The list of \"prepared data\" including the number of windows, data points, which restraints are changing,\n their force constants and targets, and well as the order of the windows. This probably ought to be\n redesigned.\n method: str\n The method used to calculate the SEM.\n verbose: bool, optional\n Whether to set the `verbose` option on pyMBAR.\n \"\"\"\n\n # Unpack the prepared data\n (\n num_win,\n data_points,\n max_data_points,\n active_rest,\n force_constants,\n targets,\n ordered_values,\n ) = prepared_data\n\n # Number of data points in each restraint value array\n N_k = np.array(data_points)\n\n # Setup the reduced potential energy array. ie, the potential of each window's\n # coordinates in each window's potential function\n u_kln = np.zeros([num_win, num_win, max_data_points], np.float64)\n\n # Transpose force_constants and targets into \"per window\" format, instead of\n # the \"per restraint\" format.\n target_units = np.array([targets[r][0].units for r in range(len(active_rest))])\n force_units = np.array(\n [force_constants[r][0].units for r in range(len(active_rest))]\n )\n\n force_constants_T = np.asarray(force_constants).T * force_units\n targets_T = np.asarray(targets).T * target_units\n\n # Note, the organization of k = coordinate windows, l = potential windows\n # seems to be opposite of the documentation. But I got wrong numbers\n # the other way around.\n for k in range(num_win): # Coordinate windows\n for l in range(num_win): # Potential Windows\n\n for r, rest in enumerate(active_rest): # Restraints\n # If this is a dihedral, we need to shift around restraint value\n # on the periodic axis to make sure the lowest potential is\n # used.\n if rest.mask3 is not None and rest.mask4 is not None:\n target = targets_T[l, r]\n # Coords from coord window, k\n bool_list = ordered_values[k][r] < target - 180.0 * unit.degrees\n ordered_values[k][r][bool_list] += 360.0 * unit.degrees\n bool_list = ordered_values[k][r] > target + 180.0 * unit.degrees\n ordered_values[k][r][bool_list] -= 360.0 * unit.degrees\n\n # Compute the potential ... for each frame, sum the contributions for each restraint\n # Note, we multiply by beta, and do some extra [l,:,None] to\n # get the math operation correct.\n u_kln[k, l, 0 : N_k[k]] = sum(\n [\n self.beta * k * (val - eq) ** 2\n for k, val, eq in zip(\n force_constants_T[l], ordered_values[k], targets_T[l]\n )\n ]\n ).magnitude\n\n g_k = np.ones([num_win], np.float64)\n # Should I subsample based on the restraint coordinate values? Here I'm\n # doing it on the potential. Should be pretty close ....\n if method == \"mbar-block\":\n # We want to use all possible data to get the free energy estimates Deltaf_ij,\n # but for uncertainty estimates we'll subsample to create\n # uncorrelated data.\n for k in range(num_win):\n l = k\n # If the potential is zero everywhere, we can't estimate the uncertainty, so\n # check the next *potential* window which probably had non-zero\n # force constants\n while not u_kln[k, l, 0 : N_k[k]].any():\n l += 1\n # Now compute statistical inefficiency: g = N*(SEM**2)/variance\n nearest_max = get_nearest_max(N_k[k])\n sem = get_block_sem(u_kln[k, l, 0:nearest_max])\n variance = np.var(u_kln[k, l, 0 : N_k[k]])\n g_k[k] = N_k[k] * (sem ** 2) / variance\n\n if method == \"mbar-autoc\":\n for k in range(num_win):\n [t0, g_k[k], Neff_max] = timeseries.detectEquilibration(\n N_k[k]\n ) # compute indices of uncorrelated\n # timeseries\n\n # Create subsampled indices and count their lengths. If g=1, ie no correlation,\n # then subsampling will return identical indices to original\n # (hopefully)\n ss_indices = []\n N_ss = np.zeros([num_win], np.int32) # N_subsample\n for k in range(num_win):\n ss_indices.append(\n get_subsampled_indices(\n N_k[k], g_k[k], conservative=self.conservative_subsample\n )\n )\n N_ss[k] = len(ss_indices[k])\n\n self.results[phase][method][\"fraction_fe_matrix\"] = {}\n self.results[phase][method][\"fraction_sem_matrix\"] = {}\n self.results[phase][method][\"fraction_fe_Neffective\"] = {}\n self.results[phase][method][\"fraction_sem_Neffective\"] = {}\n\n for fraction in self.fractions:\n # Setup mbar calc, and get matrix of free energies, uncertainties\n # To estimate the free energy, we won't do subsampling. We'll do\n # another MBAR calculation later with subsampling to estimate the\n # uncertainty.\n frac_N_k = np.array([int(fraction * n) for n in N_k], dtype=np.int32)\n\n mbar = pymbar.MBAR(u_kln, frac_N_k, verbose=verbose)\n mbar_results = mbar.getFreeEnergyDifferences(\n compute_uncertainty=True, return_dict=True\n )\n\n Deltaf_ij = mbar_results[\"Delta_f\"]\n dDeltaf_ij = mbar_results[\"dDelta_f\"]\n\n Deltaf_ij_N_eff = mbar.computeEffectiveSampleNumber()\n\n if method == \"mbar-block\" or \"mbar-autoc\":\n # Create subsampled indices and count their lengths\n frac_N_ss = np.array([int(fraction * n) for n in N_ss], dtype=np.int32)\n\n # Create a new potential array for the uncertainty calculation\n # (are we using too much memory?)\n u_kln_err = np.zeros([num_win, num_win, np.max(frac_N_ss)], np.float64)\n\n # Populate the subsampled array, drawing the appropriate\n # fraction of subsamples from the original\n for k in range(num_win):\n for l in range(num_win):\n u_kln_err[k, l, 0 : frac_N_ss[k]] = u_kln[\n k, l, ss_indices[k][0 : frac_N_ss[k]]\n ]\n\n # We toss junk_Deltaf_ij, because we got a better estimate for it from above using all data.\n # But dDeltaf_ij will replace the previous, because it correctly accounts for the\n # correlation in the data.\n mbar = pymbar.MBAR(u_kln_err, frac_N_ss, verbose=verbose)\n mbar_results = mbar.getFreeEnergyDifferences(\n compute_uncertainty=True, return_dict=True\n )\n dDeltaf_ij = mbar_results[\"dDelta_f\"]\n dDeltaf_ij_N_eff = mbar.computeEffectiveSampleNumber()\n\n # Put back into kcal/mol\n Deltaf_ij /= self.beta\n dDeltaf_ij /= self.beta\n\n self.results[phase][method][\"fraction_fe_matrix\"][fraction] = Deltaf_ij\n self.results[phase][method][\"fraction_fe_Neffective\"][\n fraction\n ] = Deltaf_ij_N_eff\n self.results[phase][method][\"fraction_sem_matrix\"][fraction] = dDeltaf_ij\n self.results[phase][method][\"fraction_sem_Neffective\"][\n fraction\n ] = dDeltaf_ij_N_eff\n\n def run_ti(self, phase, prepared_data, method):\n \"\"\"\n Compute the free energy using the TI method.\n\n We compute the partial derivative of the potential (i.e., forces), for each frame, with respect to the\n changing parameter, either a lambda or target value. The force constants are scaled by the λ parameter which\n controls their strength: ``0`` to ``fc_max``.\n\n Potential:\n U = λ × fc_max × (values - target)²\n Forces during attach:\n dU/dλ = fc_max × (values - target)²\n Forces during pull:\n dU/d(target) = 2 × λ × fc_max × (values - target)\n Forces during release:\n (same as attach)\n\n Then we integrate over the interval covered by λ or target.\n\n Parameters\n ----------\n phase: str\n The phase of the calculation to analyze.\n prepared_data: :class:`np.array`\n The list of \"prepared data\" including the number of windows, data points, which restraints are changing,\n their force constants and targets, and well as the order of the windows. This probably ought to be\n redesigned.\n method: str\n The method used to calculate the SEM.\n\n .. note ::\n ``phase`` and ``method`` should be `enum` types and tied to class attributes.\n\n .. warning ::\n We have only considered whether this will work for the case where the pull phase is a single distance\n restraint with a changing target value. This has not been tested for a changing angle or dihedral.\n\n \"\"\"\n\n # Unpack the prepared data\n (\n num_win,\n data_points,\n max_data_points,\n active_rest,\n force_constants,\n targets,\n ordered_values,\n ) = prepared_data\n\n # Number of data points in each restraint value array\n N_k = np.array(data_points)\n\n # The dU array to store the partial derivative of the potential with respect lambda or target,\n # depending on the whether attach/release or pull. Data stored for each frame. This just a\n # temporary storage space.\n dU = np.zeros([num_win, max_data_points], np.float64)\n\n # The mean, SEM, standard deviation, and number of uncorrelated dU values for each window.\n dU_avgs = np.zeros([num_win], np.float64)\n dU_sems = np.zeros([num_win], np.float64)\n dU_stdv = np.zeros([num_win], np.float64)\n dU_Nunc = np.zeros([num_win], np.float64)\n # The statistical inefficiency\n g = np.zeros([num_win], np.float64)\n\n # Array for values of the changing coordinate (x-axis), either lambda or target.\n # I'll name them dl_vals for dlambda values.\n dl_vals = np.zeros([num_win], np.float64)\n\n # Setup interpolation array for the dLambda (dl) coordinate. We're gonna create\n # this progressively by appending ...\n dl_intp = np.zeros([0], np.float64)\n\n # Get units\n target_units = np.array([targets[r][0].units for r in range(len(active_rest))])\n force_units = np.array(\n [force_constants[r][0].units for r in range(len(active_rest))]\n )\n\n # Store the max force constant value for each restraint.\n max_force_constants = (\n np.array(\n [np.max(force_constants[r]).magnitude for r in range(len(active_rest))]\n )\n * force_units\n )\n\n # Transpose force_constants and targets into \"per window\" format, instead of\n # the \"per restraint\" format.\n # print(targets)\n force_constants_T = np.asarray(force_constants).T * force_units\n targets_T = np.asarray(targets).T * target_units\n\n # For each window: do dihedral wrapping, compute forces, append dl_intp\n for k in range(num_win): # Coordinate windows\n\n # Wrap dihedrals so we get the right potential\n for r, rest in enumerate(active_rest): # Restraints\n # If this is a dihedral, we need to shift around restraint value\n # on the periodic axis to make sure the lowest potential is used.\n\n if rest.mask3 is not None and rest.mask4 is not None:\n target = targets_T[k, r]\n bool_list = ordered_values[k][r] < target - 180.0 * unit.degrees\n ordered_values[k][r][bool_list] += 360.0 * unit.degrees\n bool_list = ordered_values[k][r] > target + 180.0 * unit.degrees\n ordered_values[k][r][bool_list] -= 360.0 * unit.degrees\n\n # Compute forces and store the values of the changing coordinate,\n # either lambda or target\n if phase == \"attach\" or phase == \"release\":\n dU[k, 0 : N_k[k]] = (\n sum(\n [\n (k * (val - eq) ** 2)\n for k, val, eq in zip(\n max_force_constants, ordered_values[k], targets_T[k]\n )\n ]\n )\n .to(self.energy_unit)\n .magnitude\n )\n\n # this is lambda. assume the same scaling for all restraints\n dl_vals[k] = force_constants_T[k, 0] / max_force_constants[0]\n else:\n dU[k, 0 : N_k[k]] = (\n sum(\n [\n 2.0 * k * (val - eq)\n for k, val, eq in zip(\n max_force_constants, ordered_values[k], targets_T[k]\n )\n ]\n )\n .to(self.energy_unit / self.distance_unit)\n .magnitude\n )\n\n # Currently assuming a single distance restraint\n dl_vals[k] = targets_T[k, 0].to(self.distance_unit).magnitude\n\n # Compute standard deviations and SEMs, unless we're going to do\n # exact_sem_each_ti_fraction\n dU_avgs[k] = np.mean(dU[k, 0 : N_k[k]])\n dU_stdv[k] = np.std(dU[k, 0 : N_k[k]])\n if method == \"ti-block\":\n nearest_max = get_nearest_max(N_k[k])\n dU_sems[k] = get_block_sem(dU[k, 0:nearest_max])\n # Rearrange SEM = StdDev/sqrt(N) to get N_uncorrelated\n dU_Nunc[k] = (dU_stdv[k] / dU_sems[k]) ** 2\n elif method == \"ti-nocor\":\n dU_sems[k] = dU_stdv[k] / np.sqrt(N_k[k])\n dU_Nunc[k] = N_k[k]\n g[k] = N_k[k] / dU_Nunc[k]\n\n # Create the interpolation by appending 100 points between each window.\n # Start with k=1 so we don't double count.\n if k > 0:\n dl_intp = np.append(\n dl_intp,\n np.linspace(dl_vals[k - 1], dl_vals[k], num=100, endpoint=False),\n )\n\n # Tack on the final value to the dl interpolation\n dl_intp = np.append(dl_intp, dl_vals[-1])\n\n logger.debug(\"Running bootstrap calculations...\")\n\n # Setup fractions. For simplicity, we'll always do this, even\n # if we're doing the total data, ie self.fractions=[1.0].\n self.results[phase][method][\"fraction_fe_matrix\"] = {}\n self.results[phase][method][\"fraction_sem_matrix\"] = {}\n\n for fraction in self.fractions:\n\n logger.debug(\"Working on fraction ... {}\".format(fraction))\n\n # Compute means for this fraction.\n frac_dU_avgs = np.array(\n [np.mean(dU[k, 0 : int(fraction * n)]) for k, n in enumerate(N_k)]\n )\n\n # If self.exact_sem_each_ti_fraction, we're gonna recompute the SEM for each fraction\n # rather than estimating it from the standard deviation (dU_stdv) and number of\n # uncorrelated data points (dU_Nunc) from the total data set.\n if method == \"ti-block\" and self.exact_sem_each_ti_fraction:\n frac_dU_sems = np.zero([k], np.float64)\n for k in range(num_win):\n nearest_max = get_nearest_max(int(fraction * N_k[k]))\n frac_dU_sems[k] = get_block_sem(dU[k, 0:nearest_max])\n elif method == \"ti-nocor\" and self.exact_sem_each_ti_fraction:\n frac_dU_sems = np.zero([k], np.float64)\n for k in range(num_win):\n frac_dU_sems[k] = np.std(\n dU[k, 0 : int(fraction * N_k[k])]\n ) / np.sqrt(int(fraction * N_k[k]))\n else:\n frac_dU_sems = dU_stdv / np.sqrt(fraction * dU_Nunc)\n\n dU_samples = np.random.normal(\n frac_dU_avgs, frac_dU_sems, size=(self.bootcycles, frac_dU_avgs.size)\n )\n\n # Run bootstraps\n (\n self.results[phase][method][\"fraction_fe_matrix\"][fraction],\n self.results[phase][method][\"fraction_sem_matrix\"][fraction],\n ) = integrate_bootstraps(\n dl_vals, dU_samples, x_intp=dl_intp, matrix=self.ti_matrix\n )\n\n # Put units back on\n self.results[phase][method][\"fraction_fe_matrix\"][\n fraction\n ] *= self.energy_unit\n self.results[phase][method][\"fraction_sem_matrix\"][\n fraction\n ] *= self.energy_unit\n\n # The attach/release work (integration) yields appropriately positive work, but\n # the pull work needs a negative multiplier. Think W = −Force × distance type thing.\n if phase == \"pull\":\n self.results[phase][method][\"fraction_fe_matrix\"][fraction] *= -1.0\n\n if self.compute_roi:\n logger.info(phase + \": computing ROI for \" + method)\n # Do ROI calc\n max_fraction = np.max(self.fractions)\n # If we didn't compute fe/sem for fraction 1.0 already, do it now\n dU_samples = np.random.normal(\n dU_avgs, dU_sems, size=(self.bootcycles, dU_avgs.size)\n )\n if not np.isclose(max_fraction, 1.0):\n junk_fe, total_sem_matrix = integrate_bootstraps(\n dl_vals, dU_samples, x_intp=dl_intp, matrix=self.ti_matrix\n )\n else:\n total_sem_matrix = self.results[phase][method][\"fraction_sem_matrix\"][\n max_fraction\n ].magnitude\n self.results[phase][method][\"roi\"] = np.zeros([num_win], np.float64)\n\n for k in range(num_win):\n # Compute overall integrated SEM with 10% smaller SEM for dU[k]\n cnvg_dU_samples = np.array(dU_samples)\n cnvg_dU_samples[:, k] = np.random.normal(\n dU_avgs[k], 0.9 * dU_sems[k], self.bootcycles\n )\n junk_fe, cnvg_sem_matrix = integrate_bootstraps(\n dl_vals, cnvg_dU_samples, x_intp=dl_intp, matrix=self.ti_matrix\n )\n\n # d( dG_sem ) d( dUdl_sem )\n # ROI = --------------- * ---------------\n # d( dUdl_sem ) d( n_frames )\n #\n # Deriv1----^---^---^ ^---^---^----Deriv2\n\n # Deriv1:\n deriv1 = (cnvg_sem_matrix[0, -1] - total_sem_matrix[0, -1]) / (\n -0.1 * dU_sems[k]\n )\n\n # Deriv2:\n #\n # dUdl_sem = dUdl_stddev / sqrt(n_frames/g)\n #\n # d( dUdl_sem ) dUdl_stddev\n # -------------- = - --------------------------\n # d( n_frames ) 2g * (n_frames/g)**3/2\n\n deriv2 = (\n -1.0 * dU_stdv[k] / (2.0 * g[k] * (N_k[k] / g[k]) ** (3.0 / 2.0))\n )\n\n # ROI\n self.results[phase][method][\"roi\"][k] = deriv1 * deriv2\n\n def compute_free_energy(self, phases=[\"attach\", \"pull\", \"release\"], seed=None):\n \"\"\"\n Compute the free energy of binding from a simulation. This function populates the ``results`` dictionary\n of the :class:`fe_calc` object.\n\n Parameters\n ----------\n phases: list\n Which phases of the calculation to analyze.\n seed: int\n Random number seed.\n \"\"\"\n\n for fraction in self.fractions:\n if fraction <= 0.0 or fraction > 1.0:\n raise Exception(\n \"The fraction of data to analyze must be 0 < fraction ≤ 1.0.\"\n )\n\n for phase in phases:\n self.results[phase] = {}\n self.results[phase][\"window_order\"] = self.orders[phase]\n\n for method in self.methods:\n if seed is not None:\n np.random.seed(seed)\n logger.debug(f\"Setting random number seed = {seed}\")\n\n self.results[phase][method] = {}\n\n # Prepare data\n if sum(self.changing_restraints[phase]) == 0:\n logger.debug(\"Skipping free energy calculation for %s\" % phase)\n continue\n prepared_data = self.prepare_data(phase)\n self.results[phase][method][\"n_frames\"] = np.sum(prepared_data[1])\n\n logger.debug(\n \"Running {} analysis on {} phase ...\".format(method, phase)\n )\n\n if method == \"mbar-block\" or method == \"mbar-autoc\":\n self.run_mbar(phase, prepared_data, method)\n elif method == \"ti-block\":\n self.run_ti(phase, prepared_data, method)\n else:\n raise NotImplementedError(\n f\"Method ({method}) is not implemented yet.\"\n )\n\n # Store endpoint free energy and SEM for each fraction\n self.results[phase][method][\"fraction_n_frames\"] = {}\n self.results[phase][method][\"fraction_fe\"] = {}\n self.results[phase][method][\"fraction_sem\"] = {}\n\n for fraction in self.fractions:\n self.results[phase][method][\"fraction_n_frames\"][fraction] = int(\n fraction * self.results[phase][method][\"n_frames\"]\n )\n\n self.results[phase][method][\"fraction_fe\"][fraction] = self.results[\n phase\n ][method][\"fraction_fe_matrix\"][fraction][0, -1]\n\n self.results[phase][method][\"fraction_sem\"][\n fraction\n ] = self.results[phase][method][\"fraction_sem_matrix\"][fraction][\n 0, -1\n ]\n\n # Set these higher level (total) values, which will be slightly\n # easier to access\n max_fraction = np.max(self.fractions)\n self.results[phase][method][\"fe_matrix\"] = self.results[phase][method][\n \"fraction_fe_matrix\"\n ][max_fraction]\n self.results[phase][method][\"sem_matrix\"] = self.results[phase][method][\n \"fraction_sem_matrix\"\n ][max_fraction]\n self.results[phase][method][\"fe\"] = self.results[phase][method][\n \"fe_matrix\"\n ][0, -1]\n self.results[phase][method][\"sem\"] = self.results[phase][method][\n \"sem_matrix\"\n ][0, -1]\n\n if self.compute_largest_neighbor:\n # Store convergence values, which are helpful for running\n # simulations\n windows = len(self.results[phase][method][\"sem_matrix\"])\n self.results[phase][method][\"largest_neighbor\"] = unit.Quantity(\n np.ones([windows], np.float64) * -1.0,\n units=self.energy_unit,\n )\n logger.info(f\"{phase}: computing largest_neighbor for {method}...\")\n\n for i in range(windows):\n if i == 0:\n self.results[phase][method][\"largest_neighbor\"][\n i\n ] = self.results[phase][method][\"sem_matrix\"][i][i + 1]\n elif i == windows - 1:\n self.results[phase][method][\"largest_neighbor\"][\n i\n ] = self.results[phase][method][\"sem_matrix\"][i][i - 1]\n else:\n left = self.results[phase][method][\"sem_matrix\"][i][i - 1]\n right = self.results[phase][method][\"sem_matrix\"][i][i + 1]\n if left > right:\n max_val = left\n elif right > left:\n max_val = right\n else:\n max_val = right\n self.results[phase][method][\"largest_neighbor\"][i] = max_val\n\n def compute_ref_state_work(self, restraints):\n \"\"\"\n Compute the work to place a molecule at standard reference state conditions\n starting from a state defined by up to six restraints. These are Boresch-style restraints.\n\n Parameters\n ----------\n restraints : list\n A list of :class:`paprika.restraints.DAT_restraint` objects in order of the six translational and\n orientational restraints needed to describe the configuration of one molecule\n relative to another. The six restraints are: r, theta, phi, alpha, beta, gamma and they should be passed to\n this function in that order. If any of these coordinates is not being restrained, use a `None` in place of a\n :class:`paprika.restraints.DAT_restraint` object.\n\n See :meth:`paprika.analysis.ref_state_work` for details on the calculation.\n \"\"\"\n\n if not restraints or restraints[0] is None:\n raise ValueError(\n \"At minimum, a single distance restraint is necesarry to compute the work of releasing\"\n \" the guest to standard state.\"\n )\n\n fcs = []\n targs = []\n\n for restraint in restraints:\n if restraint is None:\n fcs.append(None)\n targs.append(None)\n elif restraint.phase[\"release\"][\"force_constants\"] is not None:\n fcs.append(np.sort(restraint.phase[\"release\"][\"force_constants\"])[-1])\n targs.append(np.sort(restraint.phase[\"release\"][\"targets\"])[-1])\n elif restraint.phase[\"pull\"][\"force_constants\"] is not None:\n fcs.append(np.sort(restraint.phase[\"pull\"][\"force_constants\"])[-1])\n targs.append(np.sort(restraint.phase[\"pull\"][\"targets\"])[-1])\n else:\n raise ValueError(\n \"Restraints should have pull or release values initialized in order to compute_ref_state_work\"\n )\n\n self.results[\"ref_state_work\"] = ref_state_work(\n self.temperature,\n fcs[0],\n targs[0],\n fcs[1],\n targs[1],\n fcs[2],\n targs[2],\n fcs[3],\n targs[3],\n fcs[4],\n targs[4],\n fcs[5],\n targs[5],\n )\n\n def save_results(self, filepath=\"results.json\", overwrite=False):\n \"\"\"\n Save the analysis results to a JSON file.\n\n Parameters\n ----------\n filepath: os.PathLike\n The name of the JSON file to write to.\n overwrite: bool\n Option to whether overwrite file if already exist.\n \"\"\"\n if overwrite and os.path.isfile(filepath):\n raise FileExistsError(f\"File `{filepath}` exists, will not overwrite.\")\n\n with open(filepath, \"w\") as f:\n dumped = json.dumps(self.results, cls=PaprikaEncoder)\n f.write(dumped)\n\n @staticmethod\n def load_results(filepath):\n \"\"\"\n Read in a JSON file for the results.\n\n Parameters\n ----------\n filepath: os.PathLike\n The name of the JSON file to read.\n \"\"\"\n with open(filepath, \"r\") as f:\n data = f.read()\n\n return json.loads(data, cls=PaprikaDecoder)\n\n def save_data(self, filepath=\"simulation_data.json\", overwrite=False):\n \"\"\"\n Save the simulation data (DAT values) to a JSON file.\n\n Parameters\n ----------\n filepath: os.PathLike\n The name of the JSON file to write to.\n overwrite: bool\n Option to whether overwrite file if already exist.\n \"\"\"\n if overwrite and os.path.isfile(filepath):\n raise FileExistsError(f\"File `{filepath}` exists, will not overwrite.\")\n\n with open(filepath, \"w\") as f:\n dumped = json.dumps(\n {\n \"simulation_data\": self.simulation_data,\n \"changing_restraints\": self.changing_restraints,\n \"orders\": self.orders,\n },\n cls=PaprikaEncoder,\n )\n f.write(dumped)\n\n\ndef get_factors(n):\n \"\"\"\n Return a list of integer factors for a number.\n\n Parameters\n ----------\n n: int or float\n Number to factor\n\n Returns\n -------\n sorted: list\n A list of sorted factors.\n\n \"\"\"\n factors = []\n sqrt_n = int(round(np.sqrt(n) + 0.5))\n i = 1\n while i <= sqrt_n:\n if n % i == 0:\n factors.append(int(i))\n j = n / i\n if j != i:\n factors.append(int(j))\n i += 1\n return sorted(factors, key=int)\n\n\ndef get_nearest_max(n):\n \"\"\"\n Return the number with the largest number of factors between n − 100 and n.\n\n Parameters\n ----------\n n: int\n Desired number to factor.\n\n Returns\n -------\n most_factors: int\n The number with the most factors.\n\n \"\"\"\n max_factors = 0\n if n % 2 == 0:\n beg = n - 100\n end = n\n else:\n beg = n - 101\n end = n - 1\n if beg < 0:\n beg = 0\n for i in range(beg, end + 2, 2):\n num_factors = len(get_factors(i))\n if num_factors >= max_factors:\n max_factors = num_factors\n most_factors = i\n return most_factors\n\n\ndef get_block_sem(data_array):\n \"\"\"\n Compute the standard error of the mean (SEM) using the blocking method.\n\n Note\n ----\n This is a conservative approach. Here, we report the maximum SEM determined from blocking analysis (cf. the\n \"plateau\" on the blocking curve).\n\n Parameters\n ----------\n data_array: :class:`np.array`\n Array containing data values.\n\n Returns\n -------\n np.max(sems): float\n The maximum SEM obtained from te blocking curve.\n\n \"\"\"\n # Get the integer factors for the number of data points. These\n # are equivalent to the block sizes we will check.\n block_sizes = get_factors(len(data_array))\n\n # An array to store means for each block ... make it bigger than we need.\n block_means = np.zeros([block_sizes[-1]], np.float64)\n\n # Store the SEM for each block size, except the last two size for which\n # there will only be two or one blocks total and thus very noisy.\n sems = np.zeros([len(block_sizes) - 2], np.float64)\n\n # Check each block size except the last two.\n for size_idx in range(len(block_sizes) - 2):\n # Check each block, the number of which is conveniently found as\n # the other number of the factor pair in block_sizes\n num_blocks = block_sizes[-size_idx - 1]\n for blk_idx in range(num_blocks):\n # Find the index for beg and end of data points for each block\n data_beg_idx = blk_idx * block_sizes[size_idx]\n data_end_idx = (blk_idx + 1) * block_sizes[size_idx]\n # Compute the mean of this block and store in array\n block_means[blk_idx] = np.mean(data_array[data_beg_idx:data_end_idx])\n # Compute the standard deviation across all blocks, devide by\n # num_blocks-1 for SEM\n sems[size_idx] = np.std(block_means[0:num_blocks], ddof=0) / np.sqrt(\n num_blocks - 1\n )\n # Hmm or should ddof=1? I think 0, see Flyvbjerg -----^\n\n return np.max(sems)\n\n\ndef get_subsampled_indices(N, g, conservative=False):\n \"\"\"Get the indices of independent (subsampled) frames. This is adapted from the implementation in `pymbar`.\n\n Parameters\n ----------\n N: int\n The length of the array to be indexed.\n g: int\n The statistical inefficiency of the data.\n conservative: bool, optional, default=False\n Whether `g` should be rounded up to the nearest integer.\n\n Returns\n -------\n indices: list\n A list of indices that can be used to pull out de-correlated frames from a time series.\n\n \"\"\"\n\n # g should not be less than 1.0\n if g < 1.0:\n g = 1.0\n\n # if conservative, assume integer g and round up\n if conservative:\n g = np.ceil(g)\n\n # initialize\n indices = [0]\n g_idx = 1.0\n int_step = int(np.round(g_idx * g))\n\n while int_step < N:\n indices.append(int_step)\n g_idx += 1.0\n int_step = int(np.round(g_idx * g))\n\n return indices\n\n\ndef load_trajectory(window, trajectory, topology, single_topology=False):\n \"\"\"Load a trajectory (or trajectories) and return a pytraj ``trajectory`` object.\n\n Parameters\n ----------\n window: str\n The simulation window to analyze\n trajectory: str or list\n The name or names of the trajectory\n topology: str or :class:`parmed.Structure`\n The topology the simulation\n single_topology: bool\n Whether a single topology is read for all windows\n\n Returns\n -------\n traj: pytraj.trajectory\n The trajectory of stored as a pytraj object.\n \"\"\"\n\n logger.debug(\"Load trajectories from {}/{}...\".format(window, trajectory))\n if isinstance(trajectory, str):\n trajectory_path = os.path.join(window, trajectory)\n elif isinstance(trajectory, list):\n trajectory_path = [os.path.join(window, i) for i in trajectory]\n logger.debug(\"Received list of trajectories: {}\".format(trajectory_path))\n else:\n raise RuntimeError(\"Trajectory path should be a `str` or `list`.\")\n\n if isinstance(topology, str) and not single_topology:\n if not os.path.isfile(os.path.join(window, topology)):\n raise FileNotFoundError(\n f\"Cannot find `topology` file: {os.path.join(window, topology)}\"\n )\n logger.debug(f\"Loading {os.path.join(window, topology)} and {trajectory_path}\")\n try:\n traj = pt.iterload(trajectory_path, os.path.join(window, topology))\n except ValueError as e:\n formatted_exception = traceback.format_exception(None, e, e.__traceback__)\n logger.info(\n f\"Failed trying to load {os.path.join(window, topology)} and {trajectory_path}: \"\n f\"{formatted_exception}\"\n )\n elif isinstance(topology, str) and single_topology:\n traj = pt.iterload(trajectory_path, os.path.join(topology))\n else:\n try:\n traj = pt.iterload(trajectory_path, topology)\n except BaseException:\n raise Exception(\"Tried to load `topology` object directly and failed.\")\n\n logger.debug(\"Loaded {} frames...\".format(traj.n_frames))\n\n return traj\n\n\ndef read_restraint_data(traj, restraint):\n \"\"\"Given a trajectory and restraint, read the restraint and return the DAT values.\n\n Parameters\n ----------\n traj: :class:`pytraj.trajectory`\n A trajectory, probably loaded by load_trajectory\n restraint: :class:`DAT_restraint`\n The restraint to analyze\n\n Returns\n -------\n data: :class:`np.array`\n The values for this restraint in this window\n \"\"\"\n\n if (\n restraint.mask1\n and restraint.mask2\n and not restraint.mask3\n and not restraint.mask4\n ):\n data = unit.Quantity(\n pt.distance(traj, \" \".join([restraint.mask1, restraint.mask2]), image=True),\n units=unit.angstrom,\n )\n\n elif (\n restraint.mask1 and restraint.mask2 and restraint.mask3 and not restraint.mask4\n ):\n data = unit.Quantity(\n pt.angle(\n traj, \" \".join([restraint.mask1, restraint.mask2, restraint.mask3])\n ),\n units=unit.degrees,\n )\n\n elif restraint.mask1 and restraint.mask2 and restraint.mask3 and restraint.mask4:\n data = unit.Quantity(\n pt.dihedral(\n traj,\n \" \".join(\n [restraint.mask1, restraint.mask2, restraint.mask3, restraint.mask4]\n ),\n ),\n units=unit.degrees,\n )\n\n return data\n\n\ndef ref_state_work(\n temperature,\n r_fc,\n r_tg,\n th_fc,\n th_tg,\n ph_fc,\n ph_tg,\n a_fc,\n a_tg,\n b_fc,\n b_tg,\n g_fc,\n g_tg,\n):\n \"\"\"\n Computes the free energy to release a molecule from some restrained translational\n and orientational configuration (relative to another molecule or lab frame) into\n the reference configuration: standard concentration (1.0/1660.5392 ų) and\n unrestrained orientational freedom (8π²).\n\n The Wikipedia entry on Euler angles is useful.\n\n Assume two molecules (H and G). Three translational and three orientational degrees\n of freedom define their relative configuration. In order to match experimentally\n reported free energies, we often need to compute the work (free energy) of moving\n a molecule (G) from a restrained configuration relative to H into the experimental\n reference state (usually defined as 1 M, or 1 molecule per 1660.5 ų)\n\n ::\n\n H3\n \\ [a1] [a2]\n H2-------H1--------------G1-------G2\n {t1} {t2} {t3} \\\n G3\n\n Degrees of Freedom\n -----------------------------------------------------------------\n id atoms type, spherical coordinate/Euler angle\n -----------------------------------------------------------------\n : H1-G1 distance, r\n [a1]: H2-H1-G1 angle, theta\n {t1}: H3-H2-H1-G1 torsion, phi\n {t2}: H2-H1-G1-G2 torsion, alpha\n [a2]: H1-G1-G2 angle, beta\n {t3}: H1-G1-G2-G3 torsion, gamma\n\n Parameters\n ----------\n temperature : unit.Quantity\n The temperature (in Kelvin) at which the reference state calculation will take place.\n r_fc: unit.Quantity\n The distance, :math:`r`, restraint force constant (kcal/mol-Ų).\n r_tg : unit.Quantity\n The distance, :math:`r`, restraint target values (Å). The target range is 0 to infinity.\n th_fc : unit.Quantity\n The angle, :math:`θ`, restraint force constant (kcal/mol-radian²).\n th_tg : unit.Quantity\n The angle, :math:`θ`, restraint target values (radian). The target range is 0 to π.\n ph_fc : unit.Quantity\n The torsion, :math:`\\\\phi`, restraint force constant (kcal/mol-radian²).\n ph_tg : unit.Quantity\n The torsion, :math:`\\\\phi`, restraint target values (radian). The target range is 0 to 2π.\n a_fc : unit.Quantity\n The torsion, :math:`α`, restraint force constant (kcal/mol-radian²).\n a_tg: unit.Quantity\n The torsion, :math:`α`, restraint target values (radian). The target range is 0 to 2π.\n b_fc : unit.Quantity\n The angle, :math:`β`, restraint force (kcal/mol-radian²).\n b_tg : unit.Quantity\n The angle, :math:`β`, restraint target values (radian). The target range is 0 to π.\n g_fc: unit.Quantity\n The angle, :math:`γ`, restraint force (kcal/mol-radian²).\n g_tg: unit.Quantity\n The angle, :math:`γ`, restraint target values (radian). The target range is 0 to 2π.\n\n Returns\n -------\n RT * np.log(trans * orient): float\n The free energy associated with releasing the restraints (in kcal/mol Pint units).\n \"\"\"\n\n R = 1.987204118e-3 * unit.kcal / unit.mole / unit.kelvin\n RT = R * temperature\n\n # Distance Integration Function\n def dist_int(RT, fc, targ):\n def potential(arange, RT, fc, targ):\n return (arange ** 2) * np.exp((-1.0 / RT) * fc * (arange - targ) ** 2)\n\n arange = np.arange(0.0, 100.0, 0.0001) * unit.angstrom\n return np.trapz(potential(arange, RT, fc, targ), arange)\n\n # Angle Integration Function\n def ang_int(RT, fc, targ):\n def potential(arange, RT, fc, targ):\n return np.sin(arange) * np.exp((-1.0 / RT) * fc * (arange - targ) ** 2)\n\n arange = np.arange(0.0, np.pi, 0.00005) * unit.radians\n return np.trapz(potential(arange, RT, fc, targ), arange)\n\n # Torsion Integration Function\n def tors_int(RT, fc, targ):\n def potential(arange, RT, fc, targ):\n return np.exp((-1.0 / RT) * fc * (arange - targ) ** 2)\n\n # Note, because of periodicity, I'm gonna wrap +/- pi around target for integration.\n arange = np.arange(targ - np.pi, targ + np.pi, 0.00005) * unit.radians\n return np.trapz(potential(arange, RT, fc, targ), arange)\n\n # Distance restraint, r\n if None in [r_fc, r_tg]:\n raise Exception(\"Distance restraint info (r_fc, r_tg) must be specified\")\n else:\n r_int = dist_int(RT, r_fc, r_tg)\n\n # Angle restraint, theta\n if None in [th_fc, th_tg]:\n th_int = 2.0\n else:\n th_int = ang_int(RT, th_fc, th_tg)\n\n # Torsion restraint, phi\n if None in [ph_fc, ph_tg]:\n ph_int = 2.0 * np.pi * unit.radians\n else:\n ph_int = tors_int(RT, ph_fc, ph_tg)\n\n # Torsion restraint, alpha\n if None in [a_fc, a_tg]:\n a_int = 2.0 * np.pi * unit.radians\n else:\n a_int = tors_int(RT, a_fc, a_tg)\n\n # Angle restraint, beta\n if None in [b_fc, b_tg]:\n b_int = 2.0\n else:\n b_int = ang_int(RT, b_fc, b_tg)\n\n # Torsion restraint, gamma\n if None in [g_fc, g_tg]:\n g_int = 2.0 * np.pi * unit.radians\n else:\n g_int = tors_int(RT, g_fc, g_tg)\n\n # Concentration term\n V0 = 1660.5392 * unit.angstrom ** 3\n translational = r_int * th_int * ph_int * (1.0 / V0) # C^o = 1/V^o\n\n # Orientational term\n rotational_volume = 8.0 * np.pi ** 2\n orientational = a_int * b_int * g_int / rotational_volume\n\n # Return the free energy\n return RT * np.log(translational * orientational)\n\n\ndef integrate_bootstraps(x, ys, x_intp=None, matrix=\"full\"):\n \"\"\"\n Integrate splines created via bootstrapping.\n\n Parameters\n ----------\n x: :class:`np.array`\n The x coordinate of the curve to be integrated.\n ys: :class:`np.array`\n Two dimensional array in which the first dimension is bootcycles and the second\n dimension contains the arrays of y values which correspond to the x values and will\n be used for integration. The shape of this is :code:`(bootcycles, len(x))`.\n x_intp: :class:`np.array`, optional, default=None\n An array which finely interpolates the x values. If not provided, it will be generated\n by adding 100 evenly spaced points between each x value. Default: None.\n matrix: str, optional, default='full`\n If ``full``, the mean and SEM integration is computed between x values. If ``diagonal``,\n the mean and SEM integration is computed between the first value and all other values,\n as well as the neighboring values to each value. If ``endpoints``, the integration\n is computed between only the first and last x value.\n\n Returns\n -------\n avg_matrix: :class:`np.array`\n Matrix of the integration mean between each x value (as specified by 'matrix')\n sem_matrix: :class:`np.array`\n Matrix of the uncertainty (SEM) between each x value (as specified by 'matrix')\n\n \"\"\"\n\n num_x = len(x)\n\n # Prepare to store the index location of the x values in the x_intp array\n x_idxs = np.zeros([num_x], np.int32)\n\n # If not provided, generate x interpolation with 100 inpolated points between\n # each x value. Store the index locations of the x values in the x_intp\n # array.\n if x_intp is None:\n x_intp = np.zeros([0], np.float64)\n for i in range(1, num_x):\n x_intp = np.append(\n x_intp, np.linspace(x[i - 1], x[i], num=100, endpoint=False)\n )\n x_idxs = len(x_intp)\n # Tack on the final value onto the interpolation\n x_intp = np.append(x_intp, x[-1])\n # If x_intp is provided, find the locations of x values in x_intp\n else:\n i = 0\n for j in range(len(x_intp)):\n if np.isclose(x[i], x_intp[j]):\n x_idxs[i] = j\n i += 1\n if i != num_x:\n raise Exception(\n \"One or more x values seem to be missing in the x_intp array,\"\n + \" or one of the lists is not monotonically increasing!\"\n )\n\n cycles = len(ys)\n\n # Setup array to store integration bootstraps\n int_matrix = np.zeros([num_x, num_x, cycles], np.float64)\n\n # Do the integration bootstraps. Originally, I had matrix=endpoints in the loop\n # below with everthing else, but I'll split it out here in case that's faster\n # due to avoiding the if statements.\n if matrix == \"endpoints\":\n for cycle in range(cycles):\n intp_func = Akima1DInterpolator(x, ys[cycle])\n y_intp = intp_func(x_intp)\n # for i in range(0, num_x):\n # for j in range(i+1, num_x):\n # int_matrix[i, j, cycle] = np.trapz( y_intp, x_intp )\n int_matrix[0, num_x - 1, cycle] = np.trapz(y_intp, x_intp)\n else:\n for cycle in range(cycles):\n intp_func = Akima1DInterpolator(x, ys[cycle])\n y_intp = intp_func(x_intp)\n for i in range(0, num_x):\n for j in range(i + 1, num_x):\n if matrix == \"diagonal\" and i != 0 and j - i > 1:\n continue\n beg = x_idxs[i]\n end = x_idxs[j]\n int_matrix[i, j, cycle] = np.trapz(y_intp[beg:end], x_intp[beg:end])\n\n # Setup matrices to store the average/sem values.\n # Is it bad that the default is 0.0 rather than None?\n avg_matrix = np.zeros([num_x, num_x], np.float64)\n sem_matrix = np.zeros([num_x, num_x], np.float64)\n\n # Second pass to compute the mean and standard deviation.\n for i in range(0, num_x):\n for j in range(i + 1, num_x):\n # If quick_ti_matrix, only populate first row and neighbors in\n # matrix\n if matrix == \"diagonal\" and i != 0 and j - i > 1:\n continue\n if matrix == \"endpoints\" and i != 0 and j != num_x - 1:\n continue\n avg_matrix[i, j] = np.mean(int_matrix[i, j])\n avg_matrix[j, i] = -1.0 * avg_matrix[i, j]\n sem_matrix[i, j] = np.std(int_matrix[i, j])\n sem_matrix[j, i] = sem_matrix[i, j]\n\n return avg_matrix, sem_matrix\n", "meta": {"hexsha": "0c712cbc452a9b38dee2ffd4affa53facd4941f6", "size": 72017, "ext": "py", "lang": "Python", "max_stars_repo_path": "paprika/analysis.py", "max_stars_repo_name": "slochower/pAPRika", "max_stars_repo_head_hexsha": "50a6c148f88db896e94bd5f03c4f4bebb129b0f1", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 16, "max_stars_repo_stars_event_min_datetime": "2017-04-19T23:46:49.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-05T19:47:02.000Z", "max_issues_repo_path": "paprika/analysis.py", "max_issues_repo_name": "slochower/pAPRika", "max_issues_repo_head_hexsha": "50a6c148f88db896e94bd5f03c4f4bebb129b0f1", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 154, "max_issues_repo_issues_event_min_datetime": "2017-04-20T16:05:26.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-24T21:07:18.000Z", "max_forks_repo_path": "paprika/analysis.py", "max_forks_repo_name": "slochower/pAPRika", "max_forks_repo_head_hexsha": "50a6c148f88db896e94bd5f03c4f4bebb129b0f1", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 12, "max_forks_repo_forks_event_min_datetime": "2017-07-06T07:55:31.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-12T05:05:44.000Z", "avg_line_length": 38.2458842273, "max_line_length": 127, "alphanum_fraction": 0.5671994113, "include": true, "reason": "import numpy,from scipy", "num_tokens": 16059, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5621765008857981, "lm_q2_score": 0.352201788847459, "lm_q1q2_score": 0.19799956925998322}} {"text": "\"\"\"Contains classes for transformer architecture within CrabNet.\"\"\"\nfrom os.path import join, dirname\n\nimport numpy as np\nimport pandas as pd\n\nimport torch\nfrom torch import nn\nfrom collections import OrderedDict\n\nRNG_SEED = 42\ntorch.manual_seed(RNG_SEED)\nnp.random.seed(RNG_SEED)\ndata_type_torch = torch.float32\n\n\n# %%\nclass ResidualNetwork(nn.Module):\n \"\"\"\n Feed forward Residual Neural Network as seen in Roost.\n\n https://doi.org/10.1038/s41467-020-19964-7\n \"\"\"\n\n def __init__(self, input_dim, output_dim, hidden_layer_dims, bias=False):\n \"\"\"Instantiate a ResidualNetwork model.\n\n Parameters\n ----------\n input_dim : int\n Input dimensions for the Residual Network, specified in SubCrab() model class, by default 512\n output_dim : int\n Output dimensions for Residual Network, by default 3\n hidden_layer_dims : list(int)\n Hidden layer architecture for the Residual Network, by default [1024, 512, 256, 128]\n bias : bool\n Whether to bias the linear network, by default False\n \"\"\"\n super(ResidualNetwork, self).__init__()\n dims = [input_dim] + hidden_layer_dims\n self.fcs = nn.ModuleList(\n [nn.Linear(dims[i], dims[i + 1]) for i in range(len(dims) - 1)]\n )\n self.res_fcs = nn.ModuleList(\n [\n nn.Linear(dims[i], dims[i + 1], bias=bias)\n if (dims[i] != dims[i + 1])\n else nn.Identity()\n for i in range(len(dims) - 1)\n ]\n )\n self.acts = nn.ModuleList([nn.LeakyReLU() for _ in range(len(dims) - 1)])\n self.fc_out = nn.Linear(dims[-1], output_dim)\n\n def forward(self, fea):\n \"\"\"Propagate Residual Network weights forward.\n\n Parameters\n ----------\n fea : torch.tensor (n_dim)\n Tensor output of self attention block\n Returns\n -------\n fc_out\n The output of the Residual Network\n \"\"\"\n for fc, res_fc, act in zip(self.fcs, self.res_fcs, self.acts):\n fea = act(fc(fea)) + res_fc(fea)\n return self.fc_out(fea)\n\n def __repr__(self):\n \"\"\"Return the class name.\"\"\"\n return f\"{self.__class__.__name__}\"\n\n\nclass TransferNetwork(nn.Module):\n \"\"\"Learn extended representations of materials during transfer learning.\n\n This network was designed to have little impact on predictions during\n training and enhance learning with the inclusion of extended features.\n \"\"\"\n\n def __init__(self, input_dims, output_dims):\n \"\"\"Instantiate a TransferNetwork to learn extended representations.\n\n Parameters\n ----------\n input_dims : int\n Dimensions of input layer\n\n output_dims : int\n Dimensions of output layer\n \"\"\"\n super().__init__()\n self.layers = nn.Sequential(\n OrderedDict(\n [\n (\"fc1\", nn.Linear(input_dims, 512)),\n (\"leakyrelu1\", nn.LeakyReLU()),\n (\"fc2\", nn.Linear(512, output_dims)),\n (\"leakyrelu2\", nn.LeakyReLU()),\n ]\n )\n )\n\n def forward(self, x):\n \"\"\"Perform a forward pass of the TransferNetwork.\n\n Parameters\n ----------\n x : _type_\n _description_\n\n Returns\n -------\n _type_\n _description_\n \"\"\"\n x = self.layers(x)\n return x\n\n\nclass Embedder(nn.Module):\n \"\"\"Perform composition-based embeddings of elemental features.\"\"\"\n\n def __init__(\n self,\n d_model: int,\n compute_device: str = None,\n elem_prop: str = \"mat2vec\",\n ):\n \"\"\"Embed elemental features, similar to CBFV.\n\n Parameters\n ----------\n d_model : int\n Row dimenions of elemental emeddings, by default 512\n compute_device : str\n Name of device which the model will be run on\n elem_prop : str\n Which elemental feature vector to use. Possible values are \"jarvis\",\n \"magpie\", \"mat2vec\", \"oliynyk\", \"onehot\", \"ptable\", and \"random_200\", by\n default \"mat2vec\"\n \"\"\"\n super().__init__()\n self.d_model = d_model\n self.compute_device = compute_device\n\n elem_dir = join(dirname(__file__), \"data\", \"element_properties\")\n # # Choose what element information the model receives\n mat2vec = join(elem_dir, elem_prop + \".csv\") # element embedding\n # mat2vec = f'{elem_dir}/onehot.csv' # onehot encoding (atomic number)\n # mat2vec = f'{elem_dir}/random_200.csv' # random vec for elements\n\n cbfv = pd.read_csv(mat2vec, index_col=0).values\n feat_size = cbfv.shape[-1]\n self.fc_mat2vec = nn.Linear(feat_size, d_model).to(self.compute_device)\n zeros = np.zeros((1, feat_size))\n cat_array = np.concatenate([zeros, cbfv])\n cat_array = torch.as_tensor(cat_array, dtype=data_type_torch)\n # NOTE: Parameters within nn.Embedding\n self.cbfv = nn.Embedding.from_pretrained(cat_array).to(\n self.compute_device, dtype=data_type_torch\n )\n\n def forward(self, src):\n \"\"\"Compute forward call for embedder class to perform elemental embeddings.\n\n Parameters\n ----------\n src : torch.tensor\n Tensor containing element numbers corresponding to elements in compound\n\n Returns\n -------\n torch.tensor\n Tensor containing elemental embeddings for compounds, reduced to d_model dimensions\n \"\"\"\n mat2vec_emb = self.cbfv(src)\n x_emb = self.fc_mat2vec(mat2vec_emb)\n return x_emb\n\n\n# %%\nclass FractionalEncoder(nn.Module):\n \"\"\"Encode element fractional amount using a \"fractional encoding\".\n\n This is inspired by the positional encoder discussed by Vaswani.\n https://arxiv.org/abs/1706.03762\n \"\"\"\n\n def __init__(self, d_model, resolution=100, log10=False, compute_device=None):\n \"\"\"Instantiate the FractionalEncoder.\n\n Parameters\n ----------\n d_model : int\n Model size, see paper, by default 512\n resolution : int\n Number of discretizations for the fractional prevalence encoding, by default 100\n log10 : bool\n Whether to apply a log operation to fraction prevalence encoding, by default False\n compute_device : str\n The compute device to store and run the FractionalEncoder class\n \"\"\"\n super().__init__()\n self.d_model = d_model // 2\n self.resolution = resolution\n self.log10 = log10\n self.compute_device = compute_device\n\n x = torch.linspace(\n 0, self.resolution - 1, self.resolution, requires_grad=False\n ).view(self.resolution, 1)\n fraction = (\n torch.linspace(0, self.d_model - 1, self.d_model, requires_grad=False)\n .view(1, self.d_model)\n .repeat(self.resolution, 1)\n )\n\n pe = torch.zeros(self.resolution, self.d_model)\n pe[:, 0::2] = torch.sin(x / torch.pow(50, 2 * fraction[:, 0::2] / self.d_model))\n pe[:, 1::2] = torch.cos(x / torch.pow(50, 2 * fraction[:, 1::2] / self.d_model))\n pe = self.register_buffer(\"pe\", pe)\n\n def forward(self, x):\n \"\"\"Perform the forward pass of the fractional encoding.\n\n Parameters\n ----------\n x : torch.tensor\n Tensor of linear spaced values based on defined resolution\n\n Returns\n -------\n out\n Sinusoidal expansions of elemental fractions\n \"\"\"\n x = x.clone()\n if self.log10:\n x = 0.0025 * (torch.log2(x)) ** 2\n x[x > 1] = 1\n # x = 1 - x # for sinusoidal encoding at x=0\n x[x < 1 / self.resolution] = 1 / self.resolution\n frac_idx = torch.round(x * (self.resolution)).to(dtype=torch.long) - 1\n out = self.pe[frac_idx]\n\n return out\n\n\n# %%\nclass Encoder(nn.Module):\n \"\"\"Create elemental descriptor matrix via element embeddings and frac. encodings.\n\n See the CrabNet paper for further details:\n https://www.nature.com/articles/s41524-021-00545-1\n \"\"\"\n\n def __init__(\n self,\n d_model,\n N,\n heads,\n extend_features=None,\n fractional=True,\n attention=True,\n compute_device=None,\n pe_resolution=5000,\n ple_resolution=5000,\n elem_prop=\"mat2vec\",\n emb_scaler=1.0,\n pos_scaler=1.0,\n pos_scaler_log=1.0,\n dim_feedforward=2048,\n dropout=0.1,\n ):\n \"\"\"Instantiate the Encoder class to create elemental descriptor matrix (EDM).\n\n Parameters\n ----------\n d_model : _type_\n _description_\n N : int, optional\n Number of encoder layers, by default 3\n heads : int, optional\n Number of attention heads to use, by default 4\n extend_features : Optional[List[str]]\n Additional features to grab from columns of the other DataFrames (e.g. state\n variables such as temperature or applied load), by default None\n fractional : bool, optional\n Whether to weight each element by its fractional contribution, by default True.\n attention : bool, optional\n Whether to perform self attention, by default True\n pe_resolution : int, optional\n Number of discretizations for the prevalence encoding, by default 5000\n ple_resolution : int, optional\n Number of discretizations for the prevalence log encoding, by default 5000\n elem_prop : str, optional\n Which elemental feature vector to use. Possible values are \"jarvis\",\n \"magpie\", \"mat2vec\", \"oliynyk\", \"onehot\", \"ptable\", and \"random_200\", by\n default \"mat2vec\"\n emb_scaler : float, optional\n _description_, by default 1.0\n pos_scaler : float, optional\n Scaling factor applied to fractional encoder, by default 1.0\n pos_scaler_log : float, optional\n Scaling factor applied to log fractional encoder, by default 1.0\n dim_feedforward : int, optional\n Dimenions of the feed forward network following transformer, by default 2048\n dropout : float, optional\n Percent dropout in the feed forward network following the transformer, by default 0.1\n \"\"\"\n super().__init__()\n self.d_model = d_model\n self.N = N\n self.heads = heads\n self.extend_features = extend_features\n self.fractional = fractional\n self.attention = attention\n self.compute_device = compute_device\n self.pe_resolution = pe_resolution\n self.ple_resolution = ple_resolution\n self.elem_prop = elem_prop\n self.embed = Embedder(d_model=self.d_model, compute_device=self.compute_device)\n self.prevalence_encoder = FractionalEncoder(\n self.d_model, resolution=pe_resolution, log10=False\n )\n self.prevalence_log_encoder = FractionalEncoder(\n self.d_model, resolution=ple_resolution, log10=True\n )\n\n self.emb_scaler = nn.parameter.Parameter(torch.tensor([emb_scaler]))\n self.pos_scaler = nn.parameter.Parameter(torch.tensor([pos_scaler]))\n self.pos_scaler_log = nn.parameter.Parameter(torch.tensor([pos_scaler_log]))\n\n if self.attention:\n encoder_layer = nn.TransformerEncoderLayer(\n self.d_model,\n nhead=self.heads,\n dim_feedforward=dim_feedforward,\n dropout=dropout,\n )\n self.transformer_encoder = nn.TransformerEncoder(\n encoder_layer, num_layers=self.N\n )\n\n def forward(self, src, frac, extra_features=None):\n \"\"\"Compute the forward pass for encoding the elemental descriptor matrix.\n\n Parameters\n ----------\n src : torch.tensor\n Tensor containing integers corresponding to elements in compound\n frac : torch.tensor\n Tensor containing the fractions of each element in compound\n extra_features : bool, optional\n Whether to append extra features after encoding, by default None\n\n Returns\n -------\n torch.tensor\n Tensor containing flattened transformer representations of compounds\n concatenated with extended features.\n \"\"\"\n x = self.embed(src) * self.emb_scaler # * 2 ** self.emb_scaler\n\n pe = torch.zeros_like(x)\n ple = torch.zeros_like(x)\n pe_scaler = self.pos_scaler\n ple_scaler = self.pos_scaler_log\n pe[:, :, : self.d_model // 2] = self.prevalence_encoder(frac) * pe_scaler\n ple[:, :, self.d_model // 2 :] = self.prevalence_log_encoder(frac) * ple_scaler\n\n mask = frac.unsqueeze(dim=-1)\n mask = torch.matmul(mask, mask.transpose(-2, -1))\n mask[mask != 0] = 1\n src_mask = mask[:, 0] != 1\n\n if self.attention:\n x_src = x + pe + ple\n x_src = x_src.transpose(0, 1)\n x = self.transformer_encoder(x_src, src_key_padding_mask=src_mask)\n x = x.transpose(0, 1)\n\n if self.fractional:\n x = x * frac.unsqueeze(2).repeat(1, 1, self.d_model)\n\n hmask = mask[:, :, 0:1].repeat(1, 1, self.d_model)\n if mask is not None:\n x = x.masked_fill(hmask == 0, 0)\n\n if self.extend_features is not None:\n n_elements = x.shape[1]\n X_extra = extra_features.repeat(1, 1, n_elements).permute([1, 2, 0])\n x = torch.concat((x, X_extra), axis=2)\n\n return x\n\n\n# %%\nclass SubCrab(nn.Module):\n \"\"\"SubCrab model class which implements the transformer architecture.\"\"\"\n\n def __init__(\n self,\n out_dims=3,\n d_model=512,\n extend_features=None,\n d_extend=0,\n N=3,\n heads=4,\n fractional=False,\n attention=True,\n compute_device=None,\n out_hidden=[1024, 512, 256, 128],\n pe_resolution=5000,\n ple_resolution=5000,\n elem_prop=\"mat2vec\",\n bias=False,\n emb_scaler=1.0,\n pos_scaler=1.0,\n pos_scaler_log=1.0,\n dim_feedforward=2048,\n dropout=0.1,\n ):\n \"\"\"Instantiate a SubCrab class to be used within CrabNet.\n\n Parameters\n ----------\n out_dims : int, optional\n Output dimensions for Residual Network, by default 3\n d_model : int, optional\n Model size. See paper, by default 512\n extend_features : _type_, optional\n Additional features to grab from columns of the other DataFrames (e.g. state\n variables such as temperature or applied load), by default None\n d_extend : int, optional\n Number of extended features, by default 0\n N : int, optional\n Number of attention layers, by default 3\n heads : int, optional\n Number of attention heads, by default 4\n frac : bool, optional\n Whether to multiply `x` by the fractional amounts for each element, by default False\n attn : bool, optional\n Whether to perform self attention, by default True\n compute_device : _type_, optional\n Computing device to run model on, by default None\n out_hidden : list(int), optional\n Architecture of hidden layers in the Residual Network, by default [1024, 512, 256, 128]\n pe_resolution : int, optional\n Number of discretizations for the prevalence encoding, by default 5000\n ple_resolution : int, optional\n Number of discretizations for the prevalence log encoding, by default 5000\n elem_prop : str, optional\n Which elemental feature vector to use. Possible values are \"jarvis\", \"magpie\",\n \"mat2vec\", \"oliynyk\", \"onehot\", \"ptable\", and \"random_200\", by default \"mat2vec\"\n bias : bool, optional\n Whether to bias the Residual Network, by default False\n emb_scaler : float, optional\n Float value by which to scale the elemental embeddings, by default 1.0\n pos_scaler : float, optional\n Float value by which to scale the fractional encodings, by default 1.0\n pos_scaler_log : float, optional\n Float value by which to scale the log fractional encodings, by default 1.0\n dim_feedforward : int, optional\n Dimenions of the feed forward network following transformer, by default 2048\n dropout : float, optional\n Percent dropout in the feed forward network following the transformer, by default 0.1\n \"\"\"\n super().__init__()\n self.avg = True\n self.out_dims = out_dims\n self.d_model = d_model\n self.extend_features = extend_features\n self.d_extend = d_extend\n self.N = N\n self.heads = heads\n self.fractional = fractional\n self.attention = attention\n self.compute_device = compute_device\n self.bias = bias\n self.encoder = Encoder(\n d_model=self.d_model,\n N=self.N,\n heads=self.heads,\n attention=self.attention,\n compute_device=self.compute_device,\n pe_resolution=pe_resolution,\n ple_resolution=ple_resolution,\n elem_prop=elem_prop,\n emb_scaler=emb_scaler,\n pos_scaler=pos_scaler,\n pos_scaler_log=pos_scaler_log,\n dim_feedforward=dim_feedforward,\n dropout=dropout,\n )\n\n self.out_hidden = out_hidden\n self.output_nn = ResidualNetwork(\n self.d_model + self.d_extend,\n self.out_dims,\n self.out_hidden,\n self.bias,\n )\n\n def forward(self, src, frac, extra_features=None):\n \"\"\"Compute forward pass of the SubCrab model class (i.e. transformer).\n\n Parameters\n ----------\n src : torch.tensor\n Tensor containing element numbers corresponding to elements in compound\n frac : torch.tensor\n Tensor containing fractional amounts of each element in compound\n extra_features : bool, optional\n Whether to append extra features after encoding, by default None\n\n Returns\n -------\n torch.tensor\n Model output containing predicted value and uncertainty for that value\n \"\"\"\n output = self.encoder(src, frac, extra_features)\n # output = self.transfer_nn(output)\n\n # average the \"element contribution\", mask so you only average \"elements\" (i.e.\n # not padded zero values)\n elem_pad_mask = (src == 0).unsqueeze(-1).repeat(1, 1, self.out_dims)\n output = self.output_nn(output) # simple linear\n if self.avg:\n output = output.masked_fill(elem_pad_mask, 0)\n output = output.sum(dim=1) / (~elem_pad_mask).sum(dim=1)\n output, logits = output.chunk(2, dim=-1)\n probability = torch.ones_like(output)\n probability[:, : logits.shape[-1]] = torch.sigmoid(logits)\n output = output * probability\n\n return output\n\n\n# %%\nif __name__ == \"__main__\":\n model = SubCrab()\n", "meta": {"hexsha": "5a6b1dfdd2b875de3ec445e229aa66abdf26a9f0", "size": 19393, "ext": "py", "lang": "Python", "max_stars_repo_path": "crabnet/kingcrab.py", "max_stars_repo_name": "sgbaird/CrabNet", "max_stars_repo_head_hexsha": "9b3966cb7238dd688b84eb3fae9f2c6ae3a4ae47", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2021-10-30T09:29:22.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-04T12:11:13.000Z", "max_issues_repo_path": "crabnet/kingcrab.py", "max_issues_repo_name": "sparks-baird/CrabNet", "max_issues_repo_head_hexsha": "9b3966cb7238dd688b84eb3fae9f2c6ae3a4ae47", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 6, "max_issues_repo_issues_event_min_datetime": "2022-03-09T07:51:03.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-21T18:52:04.000Z", "max_forks_repo_path": "crabnet/kingcrab.py", "max_forks_repo_name": "sparks-baird/CrabNet", "max_forks_repo_head_hexsha": "9b3966cb7238dd688b84eb3fae9f2c6ae3a4ae47", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-10-21T04:47:24.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-21T04:47:24.000Z", "avg_line_length": 35.5834862385, "max_line_length": 105, "alphanum_fraction": 0.599494663, "include": true, "reason": "import numpy", "num_tokens": 4341, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5621764862150636, "lm_q2_score": 0.3522017684487511, "lm_q1q2_score": 0.19799955262525035}} {"text": "\"\"\"\nTrade exit triggers\n\n\"\"\"\n\nimport numpy as np\n\nclass TradeTargets():\n \"\"\"\n Calculate profit targets, stop loss levels etc.\n\n \"\"\"\n @classmethod\n def exit_and_stop_targets(\n cls, prices, params, trade_price_dict):\n \"\"\"\n Calculate exit and stop targets.\n\n Parameters\n ----------\n prices : DataFrame\n The OHLC data.\n exit_amount : Float\n The dollar exit amount. The default is $1000.00.\n stop_amount : Float\n The dollar stop amount. The default is $500.00.\n position_size : Int, optional\n The number of units to trade. The default is based on equity.\n trade_price_dict : Dict\n Dictionary of trade entry/high/low/close series.\n\n Returns\n -------\n prices : DataFrame\n The OHLC data.\n\n \"\"\"\n\n if params['exit_type'] is not None:\n prices = cls._exit_targets(\n prices=prices,\n exit_amount=params['exit_amount'],\n trade_price_dict=trade_price_dict,\n params=params)\n\n if params['stop_type'] is not None:\n prices = cls._stop_targets(\n prices=prices,\n stop_amount=params['stop_amount'],\n trade_price_dict=trade_price_dict,\n params=params)\n\n return prices\n\n\n @classmethod\n def _exit_targets(\n cls, prices, exit_amount, trade_price_dict, params):\n \"\"\"\n Create 4 series of exit targets\n\n Parameters\n ----------\n prices : DataFrame\n The OHLC data.\n exit_amount : Float\n The dollar exit amount. The default is $1000.00.\n position_size : Int, optional\n The number of units to trade. The default is based on equity.\n trade_price_dict : Dict\n Dictionary of trade entry/high/low/close series.\n\n Returns\n -------\n prices : DataFrame\n The OHLC data..\n\n \"\"\"\n # Generate profit targets / trailing stops\n prices['exit_profit_target'], prices['exit_initial_dollar_loss'], \\\n prices['exit_trailing_close'], \\\n prices['exit_trailing_high_low'] = cls._pnl_targets(\n prices=prices, dollar_amount=exit_amount,\n trade_price_dict=trade_price_dict,\n params=params)\n\n return prices\n\n\n @classmethod\n def _stop_targets(\n cls, prices, stop_amount, trade_price_dict, params):\n \"\"\"\n Create 4 series of stop targets\n\n Parameters\n ----------\n prices : DataFrame\n The OHLC data.\n stop_amount : Float\n The dollar stop amount. The default is $500.00.\n position_size : Int, optional\n The number of units to trade. The default is based on equity.\n trade_price_dict : Dict\n Dictionary of trade entry/high/low/close series.\n\n Returns\n -------\n prices : DataFrame\n The OHLC data.\n\n \"\"\"\n # Generate profit targets / trailing stops\n prices['stop_profit_target'], prices['stop_initial_dollar_loss'], \\\n prices['stop_trailing_close'], \\\n prices['stop_trailing_high_low'] = cls._pnl_targets(\n prices=prices, dollar_amount=stop_amount,\n trade_price_dict=trade_price_dict,\n params=params)\n\n return prices\n\n\n @staticmethod\n def _pnl_targets(\n prices, dollar_amount, trade_price_dict, params):\n \"\"\"\n Create profit and loss stop and exit points\n\n Parameters\n ----------\n prices : DataFrame\n The OHLC data.\n exit_amount : Float\n The dollar exit amount. The default is $1000.00.\n position_size : Int\n The number of units of the chosen ticker to trade.\n trade_number : Series\n Array of trade numbers.\n end_of_day_position : Series\n The number of units of position held at the end of day.\n trade_entry_price : Series\n The entry price for each trade.\n trade_high_price : Series\n The high price for each trade.\n trade_low_price : Series\n The low price for each trade.\n trade_close_high_price : Series\n The highest closing price for each trade.\n trade_close_low_price : Series\n The lowest closing price for each trade.\n\n Returns\n -------\n profit_target : Series\n The exit levels for each trade based on a dollar loss from the\n entry level.\n initial_dollar_loss : Series\n The exit levels for each trade based on a profit target\n trailing_close : Series\n The exit levels for each trade based on the trailing close.\n trailing_high_low : Series\n The exit levels for each trade based on the trailing high / low.\n\n \"\"\"\n\n # Create empty arrays to store the values\n trade_target = np.array([0.0]*len(prices))\n profit_target = np.array([0.0]*len(prices))\n initial_dollar_loss = np.array([0.0]*len(prices))\n trailing_close = np.array([0.0]*len(prices))\n trailing_high_low = np.array([0.0]*len(prices))\n\n end_of_day_position = prices['raw_end_of_day_position']\n position_size = prices['position_size']\n\n # For each row in the data\n for row in range(1, len(prices)):\n\n # Calculate the trade target (distance that price has to change) by\n # dividing the dollar amount by the number of units making up the\n # position size\n if position_size[row] == 0:\n trade_target[row] = 0\n else:\n trade_target[row] = np.round(\n (dollar_amount / params['contract_point_value'])\n / position_size[row], 2)\n\n # If there is a trade on\n if prices['raw_trade_number'][row] != 0:\n\n # If there is a long position\n if end_of_day_position[row] > 0:\n\n # Set the profit target to the trade entry price plus the\n # trade target\n profit_target[row] = (\n trade_price_dict['trade_entry_price'][row]\n + trade_target[row])\n\n # Set the initial dollar loss target to the trade entry\n # price minus the trade target\n initial_dollar_loss[row] = (\n trade_price_dict['trade_entry_price'][row]\n - trade_target[row])\n\n # Set the trailing close target to the closing high price\n # of the trade minus the trade target\n trailing_close[row] = (\n trade_price_dict['trade_close_high_price'][row]\n - trade_target[row])\n\n # Set the trailing high/low target to the high price\n # of the trade minus the trade target\n trailing_high_low[row] = (\n trade_price_dict['trade_high_price'][row]\n - trade_target[row])\n\n # If there is a short position\n else:\n # Set the profit target to the trade entry price minus the\n # trade target\n profit_target[row] = (\n trade_price_dict['trade_entry_price'][row]\n - trade_target[row])\n\n # Set the initial dollar loss target to the trade entry\n # price plus the trade target\n initial_dollar_loss[row] = (\n trade_price_dict['trade_entry_price'][row]\n + trade_target[row])\n\n # Set the trailing close target to the closing low price\n # of the trade plus the trade target\n trailing_close[row] = (\n trade_price_dict['trade_close_low_price'][row]\n + trade_target[row])\n\n # Set the trailing high/low target to the low price\n # of the trade minus the trade target\n trailing_high_low[row] = (\n trade_price_dict['trade_low_price'][row]\n + trade_target[row])\n\n return profit_target, initial_dollar_loss, trailing_close, \\\n trailing_high_low\n", "meta": {"hexsha": "2e90949acd1822b21e3c6bab5d7f5ddb71aef9a4", "size": 8639, "ext": "py", "lang": "Python", "max_stars_repo_path": "tradingsystems/targets.py", "max_stars_repo_name": "GBERESEARCH/tradingsystems", "max_stars_repo_head_hexsha": "5158d41d32b48d35db34a6e132c7fa2f259987c1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-10T04:28:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-10T04:28:37.000Z", "max_issues_repo_path": "tradingsystems/targets.py", "max_issues_repo_name": "GBERESEARCH/tradingsystems", "max_issues_repo_head_hexsha": "5158d41d32b48d35db34a6e132c7fa2f259987c1", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "tradingsystems/targets.py", "max_forks_repo_name": "GBERESEARCH/tradingsystems", "max_forks_repo_head_hexsha": "5158d41d32b48d35db34a6e132c7fa2f259987c1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-09-10T04:28:38.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-10T04:28:38.000Z", "avg_line_length": 34.8346774194, "max_line_length": 79, "alphanum_fraction": 0.5449704827, "include": true, "reason": "import numpy", "num_tokens": 1654, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5736784220301064, "lm_q2_score": 0.34510528442897664, "lm_q1q2_score": 0.19797945500546638}} {"text": "import numpy as np\n\nfrom .libfft import FFT\nfrom .pencil import Pencil\nfrom .pencil import Subcomm\n\n\nclass Transform(object):\n \"\"\"Class for performing any parallel transform, forward or backward\n\n Parameters\n ----------\n xfftn : list of serial transform objects\n transfer : list of global redistribution objects\n pencil : list of two pencil objects\n The two pencils represent the input and final output configuration of\n the distributed global arrays\n\n \"\"\"\n def __init__(self, xfftn, transfer, pencil):\n assert len(xfftn) == len(transfer) + 1 and len(pencil) == 2\n self._xfftn = tuple(xfftn)\n self._transfer = tuple(transfer)\n self._pencil = tuple(pencil)\n\n @property\n def input_array(self):\n \"\"\"Return input array of Transform\"\"\"\n return self._xfftn[0].input_array\n\n @property\n def output_array(self):\n \"\"\"Return output array of Transform\"\"\"\n return self._xfftn[-1].output_array\n\n @property\n def input_pencil(self):\n \"\"\"Return input pencil of Transform\"\"\"\n return self._pencil[0]\n\n @property\n def output_pencil(self):\n \"\"\"Return output pencil of Transform\"\"\"\n return self._pencil[1]\n\n def __call__(self, input_array=None, output_array=None, **kw):\n \"\"\"Compute transform\n\n Parameters\n ----------\n input_array : array, optional\n output_array : array, optional\n kw : dict\n parameters to serial transforms\n Note in particular that the keyword 'normalize'=True/False can be\n used to turn normalization on or off. Default is to enable\n normalization for forward transforms and disable it for backward.\n\n Note\n ----\n If input_array/output_array are not given, then use predefined arrays\n as planned with serial transform object _xfftn.\n\n \"\"\"\n if input_array is not None:\n self.input_array[...] = input_array\n\n for i in range(len(self._transfer)):\n self._xfftn[i](**kw)\n arrayA = self._xfftn[i].output_array\n arrayB = self._xfftn[i+1].input_array\n self._transfer[i](arrayA, arrayB)\n self._xfftn[-1](**kw)\n\n if output_array is not None:\n output_array[...] = self.output_array\n return output_array\n else:\n return self.output_array\n\n\nclass PFFT(object):\n \"\"\"Base class for parallel FFT transforms\n\n Parameters\n ----------\n comm : MPI communicator\n shape : sequence of ints, optional\n shape of input array planned for\n axes : None, int, sequence of ints or sequence of sequence of ints, optional\n axes to transform over.\n\n - None -> All axes are transformed\n - int -> Just one axis to transform over\n - sequence of ints -> e.g., (0, 1, 2) or (0, 2, 1)\n - sequence of sequence of ints -> e.g., ((0,), (1,)) or ((0,), (1, 2))\n For seq. of seq. of ints all but the last transformed sequence\n may be longer than 1. This corresponds to collapsing axes, where\n serial FFTs are performed for all collapsed axes in one single call\n dtype : np.dtype, optional\n Type of input array\n grid : sequence of ints, optional\n Define processor grid sizes. Non positive values act as wildcards to\n allow MPI compute optimal decompositions. The sequence is padded with\n ones to match the global transform dimension.\n Use ``(-1,)`` to get a slab decomposition on the first axis.\n Use ``(1, -1)`` to get a slab decomposition on the second axis.\n Use ``(P, Q)`` or ``(P, Q, 1)`` to get a 3D transform with 2D-pencil\n decomposition on a PxQ processor grid with the last axis non distributed.\n Use ``(P, 1, Q)`` to get a 3D transform with 2D-pencil decomposition on\n a PxQ processor grid with the second to last axis non distributed.\n padding : bool, number or sequence of numbers, optional\n If False, then no padding. If number, then apply this number as padding\n factor for all axes. If sequence of numbers, then each number gives the\n padding for each axis. Must be same length as axes.\n collapse : bool, optional\n If True try to collapse several serial transforms into one\n backend : str, optional\n Choose backend for serial transforms (``fftw``, ``pyfftw``, ``numpy``,\n ``scipy``, ``mkl_fft``). Default is ``fftw``\n transforms : None or dict, optional\n Dictionary of axes to serial transforms (forward and backward) along\n those axes. For example::\n\n {(0, 1): (dctn, idctn), (2, 3): (dstn, idstn)}\n\n If missing the default is to use rfftn/irfftn for real input arrays and\n fftn/ifftn for complex input arrays. Real-to-real transforms can be\n configured using this dictionary and real-to-real transforms from the\n :mod:`.fftw.xfftn` module. See Examples.\n\n Other Parameters\n ----------------\n darray : DistArray object, optional\n Create PFFT using information contained in ``darray``, neglecting most\n optional Parameters above\n slab : bool or int, optional\n DEPRECATED. If True then distribute only one axis of the global array.\n\n Methods\n -------\n forward(input_array=None, output_array=None, **kw)\n Parallel forward transform. The method is an instance of the\n :class:`.Transform` class. See :meth:`.Transform.__call__`\n\n Parameters\n ----------\n input_array : array, optional\n output_array : array, optional\n kw : dict\n parameters to serial transforms\n\n Returns\n -------\n output_array : array\n\n backward(input_array=None, output_array=None, **kw)\n Parallel backward transform. The method is an instance of the\n :class:`.Transform` class. See :meth:`.Transform.__call__`\n\n Parameters\n ----------\n input_array : array, optional\n output_array : array, optional\n kw : dict\n parameters to serial transforms\n\n Returns\n -------\n output_array : array\n\n Examples\n --------\n >>> import numpy as np\n >>> from mpi4py import MPI\n >>> from mpi4py_fft import PFFT, newDistArray\n >>> N = np.array([12, 14, 15], dtype=int)\n >>> fft = PFFT(MPI.COMM_WORLD, N, axes=(0, 1, 2))\n >>> u = newDistArray(fft, False)\n >>> u[:] = np.random.random(u.shape).astype(u.dtype)\n >>> u_hat = fft.forward(u)\n >>> uj = np.zeros_like(u)\n >>> uj = fft.backward(u_hat, uj)\n >>> assert np.allclose(uj, u)\n\n Now configure with real-to-real discrete cosine transform type 3\n\n >>> from mpi4py_fft.fftw import rfftn, irfftn, dctn, idctn\n >>> import functools\n >>> dct = functools.partial(dctn, type=3)\n >>> idct = functools.partial(idctn, type=3)\n >>> transforms = {(1, 2): (dct, idct)}\n >>> r2c = PFFT(MPI.COMM_WORLD, N, axes=((0,), (1, 2)), transforms=transforms)\n >>> u = newDistArray(r2c, False)\n >>> u[:] = np.random.random(u.shape).astype(u.dtype)\n >>> u_hat = r2c.forward(u)\n >>> uj = np.zeros_like(u)\n >>> uj = r2c.backward(u_hat, uj)\n >>> assert np.allclose(uj, u)\n\n \"\"\"\n def __init__(self, comm, shape=None, axes=None, dtype=float, grid=None,\n padding=False, collapse=False, backend='fftw',\n transforms=None, darray=None, **kw):\n # pylint: disable=too-many-locals\n # pylint: disable=too-many-branches\n # pylint: disable=too-many-statements\n\n if shape is None:\n assert darray is not None\n shape = darray.pencil.shape\n\n if axes is not None:\n axes = list(axes) if np.ndim(axes) else [axes]\n else:\n axes = list(range(len(shape)))\n if darray is not None:\n # Make sure aligned axis of darray is transformed first\n axes = list(np.roll(axes, len(shape)-1-darray.alignment))\n\n for i, ax in enumerate(axes):\n if isinstance(ax, (int, np.integer)):\n if ax < 0:\n ax += len(shape)\n axes[i] = (ax,)\n else:\n assert isinstance(ax, (tuple, list))\n ax = list(ax)\n for j, a in enumerate(ax):\n assert isinstance(a, int)\n if a < 0:\n a += len(shape)\n ax[j] = a\n axes[i] = ax\n assert min(axes[i]) >= 0\n assert max(axes[i]) < len(shape)\n assert 0 < len(axes[i]) <= len(shape)\n assert sorted(axes[i]) == sorted(set(axes[i]))\n\n self.axes = axes\n shape = list(shape)\n\n if darray is None:\n dtype = np.dtype(dtype)\n assert dtype.char in 'fdgFDG'\n\n if padding is not False:\n assert len(padding) == len(shape)\n for ax in axes:\n if len(ax) == 1 and padding[ax[0]] > 1.0+1e-6:\n old = float(shape[ax[0]])\n shape[ax[0]] = int(np.floor(shape[ax[0]]*padding[ax[0]]))\n padding[ax[0]] = shape[ax[0]] / old\n\n self._input_shape = tuple(shape)\n assert len(shape) > 0\n assert min(shape) > 0\n\n slab = kw.pop('slab', False)\n\n if grid is not None:\n assert not isinstance(comm, Subcomm)\n assert slab is False\n grid = tuple(grid)\n assert len(grid) <= len(shape)\n dims = list(grid) + [1] * (len(shape) - len(grid))\n comm = Subcomm(comm, dims)\n\n if isinstance(comm, Subcomm):\n assert slab is False\n assert len(comm) == len(shape)\n assert np.all([comm[ax].Get_size() == 1 for ax in axes[-1]])\n self.subcomm = comm\n else:\n if slab is False or slab is None:\n dims = [0] * len(shape)\n for ax in axes[-1]:\n dims[ax] = 1\n else: #pragma: no cover\n if slab is True:\n axis = (axes[-1][-1] + 1) % len(shape)\n else:\n axis = slab\n if axis < 0:\n axis = axis + len(shape)\n assert 0 <= axis < len(shape)\n dims = [1] * len(shape)\n dims[axis] = comm.Get_size()\n\n self.subcomm = Subcomm(comm, dims)\n else:\n dtype = darray.dtype\n self.subcomm = darray.subcomm\n self._input_shape = tuple(shape)\n commsizes = darray.commsizes\n assert np.all([commsizes[ax] == 1 for ax in axes[-1]]), \"Set keyword axes such that axes to transform first are aligned\"\n\n self.collapse = collapse\n if collapse is True:\n groups = [[]]\n for ax in reversed(axes):\n if np.all([self.subcomm[axis].Get_size() == 1 for axis in ax]):\n [groups[0].insert(0, axis) for axis in reversed(ax)]\n else:\n groups.insert(0, ax)\n axes = groups\n\n self.axes = tuple(map(tuple, axes))\n self.xfftn = []\n self.transfer = []\n self.pencil = [None, None]\n\n axes = self.axes[-1]\n pencil = Pencil(self.subcomm, shape, axes[-1])\n xfftn = FFT(pencil.subshape, axes, dtype, padding, backend=backend,\n transforms=transforms, **kw)\n self.xfftn.append(xfftn)\n self.pencil[0] = pencilA = pencil\n if not shape[axes[-1]] == xfftn.forward.output_array.shape[axes[-1]]:\n dtype = xfftn.forward.output_array.dtype\n shape[axes[-1]] = xfftn.forward.output_array.shape[axes[-1]]\n pencilA = Pencil(self.subcomm, shape, axes[-1])\n\n for axes in reversed(self.axes[:-1]):\n pencilB = pencilA.pencil(axes[-1])\n transAB = pencilA.transfer(pencilB, dtype)\n xfftn = FFT(pencilB.subshape, axes, dtype, padding, backend=backend,\n transforms=transforms, **kw)\n self.xfftn.append(xfftn)\n self.transfer.append(transAB)\n pencilA = pencilB\n if not shape[axes[-1]] == xfftn.forward.output_array.shape[axes[-1]]:\n dtype = xfftn.forward.output_array.dtype\n shape[axes[-1]] = xfftn.forward.output_array.shape[axes[-1]]\n pencilA = Pencil(pencilB.subcomm, shape, axes[-1])\n\n self.pencil[1] = pencilA\n self._output_shape = tuple(shape)\n\n self.forward = Transform(\n [o.forward for o in self.xfftn],\n [o.forward for o in self.transfer],\n self.pencil)\n self.backward = Transform(\n [o.backward for o in self.xfftn[::-1]],\n [o.backward for o in self.transfer[::-1]],\n self.pencil[::-1])\n\n def destroy(self):\n if isinstance(self.subcomm, Subcomm):\n self.subcomm.destroy()\n for trans in self.transfer:\n trans.destroy()\n\n def shape(self, forward_output=True):\n \"\"\"The local (to each processor) shape of data\n\n Parameters\n ----------\n forward_output : bool, optional\n Return shape of output array (spectral space) if True, else return\n shape of input array (physical space)\n \"\"\"\n if forward_output is not True:\n return self.forward.input_pencil.subshape\n return self.backward.input_pencil.subshape\n\n def local_slice(self, forward_output=True):\n \"\"\"The local view into the global data\n\n Parameters\n ----------\n forward_output : bool, optional\n Return local slices of output array (spectral space) if True, else\n return local slices of input array (physical space)\n\n \"\"\"\n if forward_output is not True:\n ip = self.forward.input_pencil\n s = [slice(start, start+shape) for start, shape in zip(ip.substart,\n ip.subshape)]\n else:\n ip = self.backward.input_pencil\n s = [slice(start, start+shape) for start, shape in zip(ip.substart,\n ip.subshape)]\n return tuple(s)\n\n def global_shape(self, forward_output=False):\n \"\"\"Return global shape of associated tensors\n\n Parameters\n ----------\n forward_output : bool, optional\n If True then return global shape of spectral space, i.e., the input\n to a backward transfer. If False then return shape of physical\n space, i.e., the input to a forward transfer.\n \"\"\"\n if forward_output:\n return self._output_shape\n return self._input_shape\n\n @property\n def dimensions(self):\n \"\"\"The number of dimensions for transformed arrays\"\"\"\n return len(self.forward.input_array.shape)\n\n def dtype(self, forward_output=False):\n \"\"\"The type of transformed arrays\n\n Parameters\n ----------\n forward_output : bool, optional\n If True then return dtype of an array that is the result of a\n forward transform. Otherwise, return the dtype of an array that\n is input to a forward transform.\n \"\"\"\n if forward_output:\n return self.forward.output_array.dtype\n return self.forward.input_array.dtype\n", "meta": {"hexsha": "b379102d6380ce96d4e6e85184f5ed5253c542a5", "size": 15684, "ext": "py", "lang": "Python", "max_stars_repo_path": "mpi4py_fft/mpifft.py", "max_stars_repo_name": "spectralDNS/mpi4pt-fft", "max_stars_repo_head_hexsha": "ac510f8398f138bb860ed9f2580343e8b98cf799", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 12, "max_stars_repo_stars_event_min_datetime": "2019-03-29T20:20:01.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-08T10:54:54.000Z", "max_issues_repo_path": "mpi4py_fft/mpifft.py", "max_issues_repo_name": "spectralDNS/mpi4pt-fft", "max_issues_repo_head_hexsha": "ac510f8398f138bb860ed9f2580343e8b98cf799", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 14, "max_issues_repo_issues_event_min_datetime": "2019-05-02T07:53:34.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-05T03:10:00.000Z", "max_forks_repo_path": "mpi4py_fft/mpifft.py", "max_forks_repo_name": "spectralDNS/mpi4py-fft", "max_forks_repo_head_hexsha": "ac510f8398f138bb860ed9f2580343e8b98cf799", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-01-26T21:22:10.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-26T21:22:10.000Z", "avg_line_length": 37.3428571429, "max_line_length": 132, "alphanum_fraction": 0.5608263198, "include": true, "reason": "import numpy", "num_tokens": 3578, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5736784220301065, "lm_q2_score": 0.3451052642223204, "lm_q1q2_score": 0.19797944341334375}} {"text": "#!/usr/bin/env python\n# Copyright 2014-2019 The PySCF Developers. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n# Author: Qiming Sun \n# James D. McClain\n# Timothy Berkelbach \n#\n\n\nimport numpy as np\n\nfrom pyscf import lib\nfrom pyscf import ao2mo\nfrom pyscf.lib import logger\nfrom pyscf.cc import ccsd\nfrom pyscf.cc import rintermediates as imd\nfrom pyscf import __config__\n\n\ndef kernel(eom, nroots=1, koopmans=False, guess=None, left=False,\n eris=None, imds=None, **kwargs):\n cput0 = (logger.process_clock(), logger.perf_counter())\n log = logger.Logger(eom.stdout, eom.verbose)\n if eom.verbose >= logger.WARN:\n eom.check_sanity()\n eom.dump_flags()\n\n if imds is None:\n imds = eom.make_imds(eris)\n\n matvec, diag = eom.gen_matvec(imds, left=left, **kwargs)\n\n size = eom.vector_size()\n nroots = min(nroots, size)\n if guess is not None:\n user_guess = True\n for g in guess:\n assert g.size == size\n else:\n user_guess = False\n guess = eom.get_init_guess(nroots, koopmans, diag)\n\n def precond(r, e0, x0):\n return r/(e0-diag+1e-12)\n\n # GHF or customized RHF/UHF may be of complex type\n real_system = (eom._cc._scf.mo_coeff[0].dtype == np.double)\n\n eig = lib.davidson_nosym1\n if user_guess or koopmans:\n assert len(guess) == nroots\n def eig_close_to_init_guess(w, v, nroots, envs):\n x0 = lib.linalg_helper._gen_x0(envs['v'], envs['xs'])\n s = np.dot(np.asarray(guess).conj(), np.asarray(x0).T)\n snorm = np.einsum('pi,pi->i', s.conj(), s)\n idx = np.argsort(-snorm)[:nroots]\n return lib.linalg_helper._eigs_cmplx2real(w, v, idx, real_system)\n conv, es, vs = eig(matvec, guess, precond, pick=eig_close_to_init_guess,\n tol=eom.conv_tol, max_cycle=eom.max_cycle,\n max_space=eom.max_space, nroots=nroots, verbose=log)\n else:\n def pickeig(w, v, nroots, envs):\n real_idx = np.where(abs(w.imag) < 1e-3)[0]\n return lib.linalg_helper._eigs_cmplx2real(w, v, real_idx, real_system)\n conv, es, vs = eig(matvec, guess, precond, pick=pickeig,\n tol=eom.conv_tol, max_cycle=eom.max_cycle,\n max_space=eom.max_space, nroots=nroots, verbose=log)\n\n if eom.verbose >= logger.INFO:\n for n, en, vn, convn in zip(range(nroots), es, vs, conv):\n r1, r2 = eom.vector_to_amplitudes(vn)\n if isinstance(r1, np.ndarray):\n qp_weight = np.linalg.norm(r1)**2\n else: # for EOM-UCCSD\n r1 = np.hstack([x.ravel() for x in r1])\n qp_weight = np.linalg.norm(r1)**2\n logger.info(eom, 'EOM-CCSD root %d E = %.16g qpwt = %.6g conv = %s',\n n, en, qp_weight, convn)\n log.timer('EOM-CCSD', *cput0)\n if nroots == 1:\n return conv[0], es[0].real, vs[0]\n else:\n return conv, es.real, vs\n\n\nclass EOM(lib.StreamObject):\n def __init__(self, cc):\n self.mol = cc.mol\n self._cc = cc\n self.verbose = cc.verbose\n self.stdout = cc.stdout\n self.max_memory = cc.max_memory\n\n self.max_space = getattr(__config__, 'eom_rccsd_EOM_max_space', 20)\n self.max_cycle = getattr(__config__, 'eom_rccsd_EOM_max_cycle', cc.max_cycle)\n self.conv_tol = getattr(__config__, 'eom_rccsd_EOM_conv_tol', cc.conv_tol)\n self.partition = getattr(__config__, 'eom_rccsd_EOM_partition', None)\n\n##################################################\n# don't modify the following attributes, they are not input options\n self.e = None\n self.v = None\n self.nocc = cc.nocc\n self.nmo = cc.nmo\n self._keys = set(self.__dict__.keys())\n\n def dump_flags(self, verbose=None):\n logger.info(self, '')\n logger.info(self, '******** %s ********', self.__class__)\n logger.info(self, 'max_space = %d', self.max_space)\n logger.info(self, 'max_cycle = %d', self.max_cycle)\n logger.info(self, 'conv_tol = %s', self.conv_tol)\n logger.info(self, 'partition = %s', self.partition)\n #logger.info(self, 'nocc = %d', self.nocc)\n #logger.info(self, 'nmo = %d', self.nmo)\n logger.info(self, 'max_memory %d MB (current use %d MB)',\n self.max_memory, lib.current_memory()[0])\n return self\n\n def reset(self, mol=None):\n self._cc.reset(mol)\n return self\n\n\ndef _sort_left_right_eigensystem(eom, right_converged, right_evals, right_evecs,\n left_converged, left_evals, left_evecs, tol=1e-6):\n '''Ensures the left and right eigenvectors correspond to the same eigenvalue.\n\n Note:\n Useful for perturbative methods that need both eigenstates. Right now, just\n simply checks for equality between left and right eigenvalues, but can be\n extended to make sure the overlap between states is sufficiently large.\n\n Kwargs:\n eom : :class:`EOM`\n Class holding EOM results.\n right_converged : array-like of bool\n Whether the right eigenstates converged.\n right_evals : array-like\n Eigenvalues of right eigenstates.\n right_evecs : array-like of ndarray\n Eigenvectors of right eigenstates.\n left_converged : array-like of bool\n Whether the left eigenstates converged.\n left_evals : array-like\n Eigenvalues of left eigenstates.\n left_evecs : array-like of ndarray\n Eigenvectors of left eigenstates.\n tol : float\n Tolerance for determining whether a left and right eigenvalue\n should be considered equal.\n '''\n log = logger.Logger(eom.stdout, eom.verbose)\n\n right_evecs, left_evecs = [np.atleast_2d(x) for x in [right_evecs, left_evecs]]\n right_evals, left_evals = [np.atleast_1d(x) for x in [right_evals, left_evals]]\n right_converged, left_converged = [np.atleast_1d(x) for x in [right_converged, left_converged]]\n\n srt_right_idx = []\n srt_left_idx = []\n left_idx = [idx for idx in range(len(left_evals)) if left_converged[idx]]\n right_idx = [idx for idx in range(len(right_evals)) if right_converged[idx]]\n if len(right_idx) != len(left_idx):\n log.warn('Number of converged left and right eigenvalues are not equal.\\n'\n ' No. Left = %3d, No. Right = %3d.' %\n (len(left_idx), len(right_idx)))\n\n for ir_idx, ir in enumerate(right_idx):\n found = False\n for il_idx, il in enumerate(left_idx):\n if abs(right_evals[ir] - left_evals[il]) < tol:\n found = True\n srt_right_idx.append(ir)\n srt_left_idx.append(il)\n break\n if found:\n left_idx.pop(il_idx)\n else:\n log.warn('No converged left eigenvalue corresponding to right eigenvalue '\n '%.6g (right idx=%3d).\\nWill not perform perturbation on this state.'\n % (right_evals[ir], ir))\n\n log.info('Resulting left/right eigenstates:')\n log.info('Left Eigen (idx) <-> Right Eigen (idx)')\n for il, ir in zip(srt_left_idx, srt_right_idx):\n log.info('%10.6g (%3d) %10.6g (%3d)',\n left_evals[il], il, right_evals[ir], ir)\n return (right_evals[srt_right_idx], right_evecs[srt_right_idx], left_evecs[srt_left_idx])\n\n\ndef perturbed_ccsd_kernel(eom, nroots=1, koopmans=False, right_guess=None,\n left_guess=None, eris=None, imds=None):\n '''Wrapper for running perturbative excited-states that require both left\n and right amplitudes.'''\n if imds is None:\n imds = eom.make_imds(eris=eris)\n\n # Right eigenvectors\n r_converged, r_e, r_v = \\\n kernel(eom, nroots, koopmans=koopmans, guess=right_guess, left=False,\n eris=eris, imds=imds)\n # Left eigenvectors\n l_converged, l_e, l_v = \\\n kernel(eom, nroots, koopmans=koopmans, guess=right_guess, left=True,\n eris=eris, imds=imds)\n\n e, r_v, l_v = _sort_left_right_eigensystem(eom, r_converged, r_e, r_v, l_converged, l_e, l_v)\n e_star = eom.ccsd_star_contract(e, r_v, l_v, imds=imds)\n return e_star\n\n\n########################################\n# EOM-IP-CCSD\n########################################\n\ndef ipccsd(eom, nroots=1, left=False, koopmans=False, guess=None,\n partition=None, eris=None, imds=None):\n '''Calculate (N-1)-electron charged excitations via IP-EOM-CCSD.\n\n Kwargs:\n nroots : int\n Number of roots (eigenvalues) requested\n partition : bool or str\n Use a matrix-partitioning for the doubles-doubles block.\n Can be None, 'mp' (Moller-Plesset, i.e. orbital energies on the diagonal),\n or 'full' (full diagonal elements).\n koopmans : bool\n Calculate Koopmans'-like (quasiparticle) excitations only, targeting via\n overlap.\n guess : list of ndarray\n List of guess vectors to use for targeting via overlap.\n '''\n if partition is not None:\n eom.partition = partition.lower()\n assert eom.partition in ['mp','full']\n eom.converged, eom.e, eom.v \\\n = kernel(eom, nroots, koopmans, guess, left, eris=eris, imds=imds)\n return eom.e, eom.v\n\ndef ipccsd_star(eom, nroots=1, koopmans=False, right_guess=None,\n left_guess=None, eris=None, imds=None):\n \"\"\"Calculates CCSD* perturbative correction.\n\n Simply calls the relevant `kernel()` function and `perturb_star` of the\n `eom` class.\n\n Returns:\n e_t_a_star (list of float):\n The IP-CCSD* energy.\n \"\"\"\n return perturbed_ccsd_kernel(eom, nroots=nroots, koopmans=koopmans,\n right_guess=right_guess, left_guess=left_guess, eris=eris,\n imds=imds)\n\ndef vector_to_amplitudes_ip(vector, nmo, nocc):\n nvir = nmo - nocc\n r1 = vector[:nocc].copy()\n r2 = vector[nocc:].copy().reshape(nocc,nocc,nvir)\n return r1, r2\n\ndef amplitudes_to_vector_ip(r1, r2):\n vector = np.hstack((r1, r2.ravel()))\n return vector\n\ndef ipccsd_matvec(eom, vector, imds=None, diag=None):\n # Ref: Nooijen and Snijders, J. Chem. Phys. 102, 1681 (1995) Eqs.(8)-(9)\n if imds is None: imds = eom.make_imds()\n nocc = eom.nocc\n nmo = eom.nmo\n r1, r2 = vector_to_amplitudes_ip(vector, nmo, nocc)\n\n # 1h-1h block\n Hr1 = -np.einsum('ki,k->i', imds.Loo, r1)\n #1h-2h1p block\n Hr1 += 2*np.einsum('ld,ild->i', imds.Fov, r2)\n Hr1 += -np.einsum('kd,kid->i', imds.Fov, r2)\n Hr1 += -2*np.einsum('klid,kld->i', imds.Wooov, r2)\n Hr1 += np.einsum('lkid,kld->i', imds.Wooov, r2)\n\n # 2h1p-1h block\n Hr2 = -np.einsum('kbij,k->ijb', imds.Wovoo, r1)\n # 2h1p-2h1p block\n if eom.partition == 'mp':\n fock = imds.eris.fock\n foo = fock[:nocc,:nocc]\n fvv = fock[nocc:,nocc:]\n Hr2 += lib.einsum('bd,ijd->ijb', fvv, r2)\n Hr2 += -lib.einsum('ki,kjb->ijb', foo, r2)\n Hr2 += -lib.einsum('lj,ilb->ijb', foo, r2)\n elif eom.partition == 'full':\n diag_matrix2 = vector_to_amplitudes_ip(diag, nmo, nocc)[1]\n Hr2 += diag_matrix2 * r2\n else:\n Hr2 += lib.einsum('bd,ijd->ijb', imds.Lvv, r2)\n Hr2 += -lib.einsum('ki,kjb->ijb', imds.Loo, r2)\n Hr2 += -lib.einsum('lj,ilb->ijb', imds.Loo, r2)\n Hr2 += lib.einsum('klij,klb->ijb', imds.Woooo, r2)\n Hr2 += 2*lib.einsum('lbdj,ild->ijb', imds.Wovvo, r2)\n Hr2 += -lib.einsum('kbdj,kid->ijb', imds.Wovvo, r2)\n Hr2 += -lib.einsum('lbjd,ild->ijb', imds.Wovov, r2) #typo in Ref\n Hr2 += -lib.einsum('kbid,kjd->ijb', imds.Wovov, r2)\n tmp = 2*np.einsum('lkdc,kld->c', imds.Woovv, r2)\n tmp += -np.einsum('kldc,kld->c', imds.Woovv, r2)\n Hr2 += -np.einsum('c,ijcb->ijb', tmp, imds.t2)\n\n vector = amplitudes_to_vector_ip(Hr1, Hr2)\n return vector\n\ndef lipccsd_matvec(eom, vector, imds=None, diag=None):\n '''For left eigenvector'''\n # Note this is not the same left EA equations used by Nooijen and Bartlett.\n # Small changes were made so that the same type L2 basis was used for both the\n # left EA and left IP equations. You will note more similarity for these\n # equations to the left IP equations than for the left EA equations by Nooijen.\n if imds is None: imds = eom.make_imds()\n nocc = eom.nocc\n nmo = eom.nmo\n r1, r2 = vector_to_amplitudes_ip(vector, nmo, nocc)\n\n # 1h-1h block\n Hr1 = -np.einsum('ki,i->k', imds.Loo, r1)\n #1h-2h1p block\n Hr1 += -np.einsum('kbij,ijb->k', imds.Wovoo, r2)\n\n # 2h1p-1h block\n Hr2 = -np.einsum('kd,l->kld', imds.Fov, r1)\n Hr2 += 2.*np.einsum('ld,k->kld', imds.Fov, r1)\n Hr2 += -np.einsum('klid,i->kld', 2.*imds.Wooov-imds.Wooov.transpose(1,0,2,3), r1)\n # 2h1p-2h1p block\n if eom.partition == 'mp':\n fock = imds.eris.fock\n foo = fock[:nocc,:nocc]\n fvv = fock[nocc:,nocc:]\n Hr2 += lib.einsum('bd,klb->kld', fvv, r2)\n Hr2 += -lib.einsum('ki,ild->kld', foo, r2)\n Hr2 += -lib.einsum('lj,kjd->kld', foo, r2)\n elif eom.partition == 'full':\n diag_matrix2 = vector_to_amplitudes_ip(diag, nmo, nocc)[1]\n Hr2 += diag_matrix2 * r2\n else:\n Hr2 += lib.einsum('bd,klb->kld', imds.Lvv, r2)\n Hr2 += -lib.einsum('ki,ild->kld', imds.Loo, r2)\n Hr2 += -lib.einsum('lj,kjd->kld', imds.Loo, r2)\n Hr2 += lib.einsum('lbdj,kjb->kld', 2.*imds.Wovvo-imds.Wovov.transpose(0,1,3,2), r2)\n Hr2 += -lib.einsum('kbdj,ljb->kld', imds.Wovvo, r2)\n Hr2 += lib.einsum('klij,ijd->kld', imds.Woooo, r2)\n Hr2 += -lib.einsum('kbid,ilb->kld', imds.Wovov, r2)\n tmp = np.einsum('ijcb,ijb->c', imds.t2, r2)\n Hr2 += -np.einsum('lkdc,c->kld', 2.*imds.Woovv-imds.Woovv.transpose(1,0,2,3), tmp)\n\n vector = amplitudes_to_vector_ip(Hr1, Hr2)\n return vector\n\ndef ipccsd_diag(eom, imds=None):\n if imds is None: imds = eom.make_imds()\n t1, t2 = imds.t1, imds.t2\n dtype = np.result_type(t1, t2)\n nocc, nvir = t1.shape\n fock = imds.eris.fock\n foo = fock[:nocc,:nocc]\n fvv = fock[nocc:,nocc:]\n\n Hr1 = -np.diag(imds.Loo)\n Hr2 = np.zeros((nocc,nocc,nvir), dtype)\n for i in range(nocc):\n for j in range(nocc):\n for b in range(nvir):\n if eom.partition == 'mp':\n Hr2[i,j,b] += fvv[b,b]\n Hr2[i,j,b] += -foo[i,i]\n Hr2[i,j,b] += -foo[j,j]\n else:\n Hr2[i,j,b] += imds.Lvv[b,b]\n Hr2[i,j,b] += -imds.Loo[i,i]\n Hr2[i,j,b] += -imds.Loo[j,j]\n Hr2[i,j,b] += imds.Woooo[i,j,i,j]\n Hr2[i,j,b] +=2*imds.Wovvo[j,b,b,j]\n Hr2[i,j,b] += -imds.Wovvo[i,b,b,i]*(i==j)\n Hr2[i,j,b] += -imds.Wovov[j,b,j,b]\n Hr2[i,j,b] += -imds.Wovov[i,b,i,b]\n Hr2[i,j,b] += -2*np.dot(imds.Woovv[j,i,b,:], t2[i,j,:,b])\n Hr2[i,j,b] += np.dot(imds.Woovv[i,j,b,:], t2[i,j,:,b])\n\n vector = amplitudes_to_vector_ip(Hr1, Hr2)\n return vector\n\ndef ipccsd_star_contract(eom, ipccsd_evals, ipccsd_evecs, lipccsd_evecs, imds=None):\n from pyscf.cc.ccsd_t import _sort_eri, _sort_t2_vooo_\n cpu1 = (logger.process_clock(), logger.perf_counter())\n log = logger.Logger(eom.stdout, eom.verbose)\n if imds is None:\n imds = eom.make_imds()\n t1, t2 = imds.t1, imds.t2\n eris = imds.eris\n\n nocc, nvir = t1.shape\n nmo = nocc + nvir\n\n dtype = np.result_type(t1, t2, eris.ovoo.dtype)\n if eom._cc.incore_complete:\n ftmp = None\n eris_vvop = np.zeros((nvir,nvir,nocc,nmo), dtype)\n else:\n ftmp = lib.H5TmpFile()\n eris_vvop = ftmp.create_dataset('vvop', (nvir,nvir,nocc,nmo), dtype)\n\n orbsym = _sort_eri(eom._cc, eris, nocc, nvir, eris_vvop, log)\n mo_energy, t1T, t2T, vooo, fvo, restore_t2_inplace = \\\n _sort_t2_vooo_(eom._cc, orbsym, t1, t2, eris)\n\n cpu1 = log.timer_debug1('CCSD(T) sort_eri', *cpu1)\n\n mem_now = lib.current_memory()[0]\n max_memory = max(0, eom.max_memory - mem_now)\n blksize = min(nvir, max(ccsd.BLKMIN, int(max_memory*1e6/8/(nocc**3*6))))\n\n mo_e_occ = np.asarray(mo_energy[:nocc])\n mo_e_vir = np.asarray(mo_energy[nocc:])\n\n def contract_l2p(l1, l2, a0, a1, b0, b1, cache_vvop, out=None):\n '''Create perturbed l2.'''\n if out is None:\n out = np.zeros((nocc,)*3 + (a1-a0,b1-b0), dtype=dtype)\n out += 0.5*np.einsum('abij,k->ijkab', cache_vvop[:,:,:,:nocc].conj(), l1)\n out += lib.einsum('abie,jke->ijkab', cache_vvop[:,:,:,nocc:].conj(), l2)\n out += -lib.einsum('bjkm,ima->ijkab', vooo[b0:b1], l2[:,:,a0:a1])\n out += -lib.einsum('bjim,mka->ijkab', vooo[b0:b1], l2[:,:,a0:a1])\n return out\n\n def contract_pl2p(l1, l2, a0, a1, b0, b1, cache_vvop_a, cache_vvop_b):\n '''Create P(ia|jb) of perturbed l2.'''\n out = contract_l2p(l1, l2, a0, a1, b0, b1, cache_vvop_a)\n out += contract_l2p(l1, l2, b0, b1, a0, a1, cache_vvop_b).transpose(1,0,2,4,3) # P(ia|jb)\n return out\n\n def contract_r2p(r1, r2, a0, a1, b0, b1, cache_vvop, out=None):\n '''Create perturbed r2.'''\n if out is None:\n out = np.zeros((nocc,)*3 + (a1-a0,b1-b0), dtype=dtype)\n tmp = np.einsum('mkbe,m->bke', eris.oovv[:,:,b0:b1,:], r1)\n out += -lib.einsum('bke,aeji->ijkab', tmp, t2T[a0:a1])\n tmp = np.einsum('mebj,m->bej', eris.ovvo[:,:,b0:b1,:], r1)\n out += -lib.einsum('bej,aeki->ijkab', tmp, t2T[a0:a1])\n tmp = np.einsum('mjnk,n->mjk', eris.oooo, r1)\n out += lib.einsum('mjk,abmi->ijkab', tmp, t2T[a0:a1,b0:b1])\n out += lib.einsum('abie,kje->ijkab', cache_vvop[:,:,:,nocc:], r2)\n out += -lib.einsum('bjkm,mia->ijkab', vooo[b0:b1].conj(), r2[:,:,a0:a1])\n out += -lib.einsum('bjim,kma->ijkab', vooo[b0:b1].conj(), r2[:,:,a0:a1])\n return out\n\n def contract_pr2p(r1, r2, a0, a1, b0, b1, cache_vvop_a, cache_vvop_b):\n '''Create P(ia|jb) of perturbed r2.'''\n out = contract_r2p(r1, r2, a0, a1, b0, b1, cache_vvop_a)\n out += contract_r2p(r1, r2, b0, b1, a0, a1, cache_vvop_b).transpose(1,0,2,4,3) # P(ia|jb)\n return out\n\n ipccsd_evecs = np.array(ipccsd_evecs)\n lipccsd_evecs = np.array(lipccsd_evecs)\n e = []\n ipccsd_evecs, lipccsd_evecs = [np.atleast_2d(x) for x in [ipccsd_evecs, lipccsd_evecs]]\n ipccsd_evals = np.atleast_1d(ipccsd_evals)\n for eval_, evec_, levec_ in zip(ipccsd_evals, ipccsd_evecs, lipccsd_evecs):\n l1, l2 = eom.vector_to_amplitudes(levec_)\n r1, r2 = eom.vector_to_amplitudes(evec_)\n ldotr = np.dot(l1, r1) + np.dot(l2.ravel(), r2.ravel())\n l1 /= ldotr\n l2 /= ldotr\n l2 = 1./3*(l2 + 2.*l2.transpose(1,0,2))\n\n deltaE = 0.0\n eijk = (mo_e_occ[:,None,None,None,None] +\n mo_e_occ[None,:,None,None,None] +\n mo_e_occ[None,None,:,None,None] + eval_)\n for a0, a1 in lib.prange_tril(0, nvir, blksize):\n b0, b1 = 0, a1\n eijkab = (eijk - mo_e_vir[a0:a1][None,None,None,:,None] -\n mo_e_vir[b0:b1][None,None,None,None,:])\n eijkab = 1./eijkab\n vvov_a = eris_vvop[a0:a1,b0:b1,:,:]\n vvov_b = eris_vvop[b0:b1,a0:a1,:,:]\n lijkab = contract_pl2p(l1, l2, a0, a1, b0, b1, vvov_a, vvov_b)\n rijkab = contract_pr2p(r1, r2, a0, a1, b0, b1, vvov_a, vvov_b)\n\n lijkab = 4.*lijkab \\\n - 2.*lijkab.transpose(1,0,2,3,4) \\\n - 2.*lijkab.transpose(2,1,0,3,4) \\\n - 2.*lijkab.transpose(0,2,1,3,4) \\\n + 1.*lijkab.transpose(1,2,0,3,4) \\\n + 1.*lijkab.transpose(2,0,1,3,4)\n\n # Symmetry factors (1 for a == b, 2 for a < b)\n fac = 2*np.ones_like(rijkab, dtype=int)\n triu_idx = np.triu_indices(a1-a0, a0+1, m=b1-b0)\n fac[:,:,:,triu_idx[0],triu_idx[1]] = 0\n fac[:,:,:,np.arange(a1-a0),np.arange(a0,b1)] = 1\n eijkab *= fac\n\n deltaE += np.einsum('ijkab,ijkab,ijkab', lijkab, rijkab, eijkab)\n deltaE = 0.5*deltaE.real\n logger.info(eom, \"ipccsd energy, star energy, delta energy = %16.12f, %16.12f, %16.12f\",\n eval_, eval_+deltaE, deltaE)\n e.append(eval_+deltaE)\n t2 = restore_t2_inplace(t2T)\n return e\n\nclass EOMIP(EOM):\n def get_init_guess(self, nroots=1, koopmans=True, diag=None):\n size = self.vector_size()\n dtype = getattr(diag, 'dtype', np.double)\n nroots = min(nroots, size)\n guess = []\n if koopmans:\n for n in range(nroots):\n g = np.zeros(int(size), dtype)\n g[self.nocc-n-1] = 1.0\n guess.append(g)\n else:\n idx = diag.argsort()[:nroots]\n for i in idx:\n g = np.zeros(int(size), dtype)\n g[i] = 1.0\n guess.append(g)\n return guess\n\n kernel = ipccsd\n ipccsd = ipccsd\n ipccsd_star = ipccsd_star\n\n matvec = ipccsd_matvec\n l_matvec = lipccsd_matvec\n get_diag = ipccsd_diag\n ccsd_star_contract = ipccsd_star_contract\n\n def ipccsd_star_contract(self, ipccsd_evals, ipccsd_evecs, lipccsd_evecs, imds=None):\n return self.ccsd_star_contract(ipccsd_evals, ipccsd_evecs, lipccsd_evecs, imds=imds)\n\n def gen_matvec(self, imds=None, left=False, **kwargs):\n if imds is None: imds = self.make_imds()\n diag = self.get_diag(imds)\n if left:\n matvec = lambda xs: [self.l_matvec(x, imds, diag) for x in xs]\n else:\n matvec = lambda xs: [self.matvec(x, imds, diag) for x in xs]\n return matvec, diag\n\n def vector_to_amplitudes(self, vector, nmo=None, nocc=None):\n if nmo is None: nmo = self.nmo\n if nocc is None: nocc = self.nocc\n return vector_to_amplitudes_ip(vector, nmo, nocc)\n\n def amplitudes_to_vector(self, r1, r2):\n return amplitudes_to_vector_ip(r1, r2)\n\n def vector_size(self):\n nocc = self.nocc\n nvir = self.nmo - nocc\n return nocc + nocc*nocc*nvir\n\n def make_imds(self, eris=None):\n imds = _IMDS(self._cc, eris=eris)\n imds.make_ip(self.partition)\n return imds\n\n @property\n def eip(self):\n return self.e\n\n\nclass EOMIP_Ta(EOMIP):\n '''Class for EOM IPCCSD(T)*(a) method by Matthews and Stanton.'''\n def make_imds(self, eris=None):\n imds = _IMDS(self._cc, eris=eris)\n imds.make_t3p2_ip(self._cc, self.partition)\n return imds\n\n########################################\n# EOM-EA-CCSD\n########################################\n\ndef eaccsd(eom, nroots=1, left=False, koopmans=False, guess=None,\n partition=None, eris=None, imds=None):\n '''Calculate (N+1)-electron charged excitations via EA-EOM-CCSD.\n\n Args:\n See also ipccd()\n '''\n return ipccsd(eom, nroots, left, koopmans, guess, partition, eris, imds)\n\ndef eaccsd_star(eom, nroots=1, koopmans=False, right_guess=None,\n left_guess=None, eris=None, imds=None, **kwargs):\n \"\"\"Calculates CCSD* perturbative correction.\n\n Args:\n See also ipccd_star()\n \"\"\"\n return perturbed_ccsd_kernel(eom, nroots=nroots, koopmans=koopmans,\n right_guess=right_guess, left_guess=left_guess, eris=eris,\n imds=imds)\n\ndef vector_to_amplitudes_ea(vector, nmo, nocc):\n nvir = nmo - nocc\n r1 = vector[:nvir].copy()\n r2 = vector[nvir:].copy().reshape(nocc,nvir,nvir)\n return r1, r2\n\ndef amplitudes_to_vector_ea(r1, r2):\n vector = np.hstack((r1, r2.ravel()))\n return vector\n\ndef eaccsd_matvec(eom, vector, imds=None, diag=None):\n # Ref: Nooijen and Bartlett, J. Chem. Phys. 102, 3629 (1995) Eqs.(30)-(31)\n if imds is None: imds = eom.make_imds()\n nocc = eom.nocc\n nmo = eom.nmo\n nvir = nmo - nocc\n r1, r2 = vector_to_amplitudes_ea(vector, nmo, nocc)\n\n # Eq. (37)\n # 1p-1p block\n Hr1 = np.einsum('ac,c->a', imds.Lvv, r1)\n # 1p-2p1h block\n Hr1 += np.einsum('ld,lad->a', 2.*imds.Fov, r2)\n Hr1 += np.einsum('ld,lda->a', -imds.Fov, r2)\n Hr1 += np.einsum('alcd,lcd->a', 2.*imds.Wvovv-imds.Wvovv.transpose(0,1,3,2), r2)\n # Eq. (38)\n # 2p1h-1p block\n Hr2 = np.einsum('abcj,c->jab', imds.Wvvvo, r1)\n # 2p1h-2p1h block\n if eom.partition == 'mp':\n fock = imds.eris.fock\n foo = fock[:nocc,:nocc]\n fvv = fock[nocc:,nocc:]\n Hr2 += lib.einsum('ac,jcb->jab', fvv, r2)\n Hr2 += lib.einsum('bd,jad->jab', fvv, r2)\n Hr2 += -lib.einsum('lj,lab->jab', foo, r2)\n elif eom.partition == 'full':\n diag_matrix2 = vector_to_amplitudes_ea(diag, nmo, nocc)[1]\n Hr2 += diag_matrix2 * r2\n else:\n Hr2 += lib.einsum('ac,jcb->jab', imds.Lvv, r2)\n Hr2 += lib.einsum('bd,jad->jab', imds.Lvv, r2)\n Hr2 += -lib.einsum('lj,lab->jab', imds.Loo, r2)\n Hr2 += lib.einsum('lbdj,lad->jab', 2.*imds.Wovvo-imds.Wovov.transpose(0,1,3,2), r2)\n Hr2 += -lib.einsum('lajc,lcb->jab', imds.Wovov, r2)\n Hr2 += -lib.einsum('lbcj,lca->jab', imds.Wovvo, r2)\n for a in range(nvir):\n Hr2[:,a,:] += lib.einsum('bcd,jcd->jb', imds.Wvvvv[a], r2)\n tmp = np.einsum('klcd,lcd->k', 2.*imds.Woovv-imds.Woovv.transpose(0,1,3,2), r2)\n Hr2 += -np.einsum('k,kjab->jab', tmp, imds.t2)\n\n vector = amplitudes_to_vector_ea(Hr1,Hr2)\n return vector\n\ndef leaccsd_matvec(eom, vector, imds=None, diag=None):\n # Note this is not the same left EA equations used by Nooijen and Bartlett.\n # Small changes were made so that the same type L2 basis was used for both the\n # left EA and left IP equations. You will note more similarity for these\n # equations to the left IP equations than for the left EA equations by Nooijen.\n if imds is None: imds = eom.make_imds()\n nocc = eom.nocc\n nmo = eom.nmo\n nvir = nmo - nocc\n r1, r2 = vector_to_amplitudes_ea(vector, nmo, nocc)\n\n # Eq. (30)\n # 1p-1p block\n Hr1 = np.einsum('ac,a->c', imds.Lvv, r1)\n # 1p-2p1h block\n Hr1 += np.einsum('abcj,jab->c', imds.Wvvvo, r2)\n # Eq. (31)\n # 2p1h-1p block\n Hr2 = 2.*np.einsum('c,ld->lcd', r1, imds.Fov)\n Hr2 += -np.einsum('d,lc->lcd', r1, imds.Fov)\n Hr2 += np.einsum('a,alcd->lcd', r1, 2.*imds.Wvovv-imds.Wvovv.transpose(0,1,3,2))\n # 2p1h-2p1h block\n if eom.partition == 'mp':\n fock = imds.eris.fock\n foo = fock[:nocc,:nocc]\n fvv = fock[nocc:,nocc:]\n Hr2 += lib.einsum('lad,ac->lcd', r2, fvv)\n Hr2 += lib.einsum('lcb,bd->lcd', r2, fvv)\n Hr2 += -lib.einsum('jcd,lj->lcd', r2, foo)\n elif eom.partition == 'full':\n diag_matrix2 = vector_to_amplitudes_ea(diag, nmo, nocc)[1]\n Hr2 += diag_matrix2 * r2\n else:\n Hr2 += lib.einsum('lad,ac->lcd', r2, imds.Lvv)\n Hr2 += lib.einsum('lcb,bd->lcd', r2, imds.Lvv)\n Hr2 += -lib.einsum('jcd,lj->lcd', r2, imds.Loo)\n Hr2 += lib.einsum('jcb,lbdj->lcd', r2, 2.*imds.Wovvo-imds.Wovov.transpose(0,1,3,2))\n Hr2 += -lib.einsum('lajc,jab->lcb', imds.Wovov, r2)\n Hr2 += -lib.einsum('lbcj,jab->lca', imds.Wovvo, r2)\n for a in range(nvir):\n Hr2 += lib.einsum('lb,bcd->lcd', r2[:,a,:], imds.Wvvvv[a])\n tmp = np.einsum('ijcb,ibc->j', imds.t2, r2)\n Hr2 += -np.einsum('kjfe,j->kef', 2.*imds.Woovv-imds.Woovv.transpose(0,1,3,2),tmp)\n\n vector = amplitudes_to_vector_ea(Hr1,Hr2)\n return vector\n\ndef eaccsd_diag(eom, imds=None):\n if imds is None: imds = eom.make_imds()\n t1, t2 = imds.t1, imds.t2\n dtype = np.result_type(t1, t2)\n nocc, nvir = t1.shape\n\n fock = imds.eris.fock\n foo = fock[:nocc,:nocc]\n fvv = fock[nocc:,nocc:]\n\n Hr1 = np.diag(imds.Lvv)\n Hr2 = np.zeros((nocc,nvir,nvir), dtype)\n for a in range(nvir):\n if eom.partition != 'mp':\n _Wvvvva = np.array(imds.Wvvvv[a])\n for b in range(nvir):\n for j in range(nocc):\n if eom.partition == 'mp':\n Hr2[j,a,b] += fvv[a,a]\n Hr2[j,a,b] += fvv[b,b]\n Hr2[j,a,b] += -foo[j,j]\n else:\n Hr2[j,a,b] += imds.Lvv[a,a]\n Hr2[j,a,b] += imds.Lvv[b,b]\n Hr2[j,a,b] += -imds.Loo[j,j]\n Hr2[j,a,b] += 2*imds.Wovvo[j,b,b,j]\n Hr2[j,a,b] += -imds.Wovov[j,b,j,b]\n Hr2[j,a,b] += -imds.Wovov[j,a,j,a]\n Hr2[j,a,b] += -imds.Wovvo[j,b,b,j]*(a==b)\n Hr2[j,a,b] += _Wvvvva[b,a,b]\n Hr2[j,a,b] += -2*np.dot(imds.Woovv[:,j,a,b], t2[:,j,a,b])\n Hr2[j,a,b] += np.dot(imds.Woovv[:,j,b,a], t2[:,j,a,b])\n\n vector = amplitudes_to_vector_ea(Hr1,Hr2)\n return vector\n\ndef eaccsd_star_contract(eom, eaccsd_evals, eaccsd_evecs, leaccsd_evecs, imds=None):\n cpu1 = (logger.process_clock(), logger.perf_counter())\n log = logger.Logger(eom.stdout, eom.verbose)\n if imds is None:\n imds = eom.make_imds()\n t1, t2 = imds.t1, imds.t2\n eris = imds.eris\n\n nocc, nvir = t1.shape\n dtype = np.result_type(t1, t2, eris.ovoo.dtype)\n # Notice we do not use `sort_eri` as compared to the eaccsd_star.\n # The sort_eri does not produce eri's that are read-in quickly for the current contraction\n # scheme. Here, we have that the block loop is over occupied indices whereas in the\n # sort_eri it is done over virtual indices (due to the permutation over occupied indices\n # in ipccsd_star versus virtual indices in eaccsd_star).\n cpu1 = log.timer_debug1('CCSD(T) sort_eri', *cpu1) # Left if new sort_eri implemented\n\n mem_now = lib.current_memory()[0]\n max_memory = max(0, eom.max_memory - mem_now)\n blksize = min(nocc, max(ccsd.BLKMIN, int(max_memory*1e6/8/(nvir**3*6))))\n\n mo_energy = np.asarray(eris.mo_energy)\n mo_e_occ = np.asarray(mo_energy[:nocc])\n mo_e_vir = np.asarray(mo_energy[nocc:])\n\n def contract_l2p(l1, l2, i0, i1, j0, j1, cache_ovvv_i, cache_ovvv_j, out=None):\n '''Create perturbed l2.'''\n if out is None:\n out = np.zeros((i1-i0,j1-j0) + (nvir,)*3, dtype=dtype)\n out += -0.5*np.einsum('iajb,c->ijabc', eris.ovov[i0:i1,:,j0:j1], l1)\n out += lib.einsum('iajm,mbc->ijabc', eris.ovoo[i0:i1,:,j0:j1], l2)\n out -= lib.einsum('iaeb,jec->ijabc', cache_ovvv_i, l2[j0:j1])\n out -= lib.einsum('jbec,iae->ijabc', cache_ovvv_j, l2[i0:i1])\n return out\n\n def contract_pl2p(l1, l2, i0, i1, j0, j1, cache_ovvv_i, cache_ovvv_j):\n '''Create P(ia|jb) of perturbed l2.'''\n out = contract_l2p(l1, l2, i0, i1, j0, j1, cache_ovvv_i, cache_ovvv_j)\n tmp = contract_l2p(l1, l2, j0, j1, i0, i1, cache_ovvv_j, cache_ovvv_i)\n tmp = tmp.transpose(1,0,3,2,4) # P(ia|jb)\n out = out + tmp\n return out\n\n def _get_vvvv(eris):\n if eris.vvvv is None and getattr(eris, 'vvL', None) is not None: # DF eris\n vvL = np.asarray(eris.vvL)\n nvir = int(np.sqrt(eris.vvL.shape[0]*2))\n return ao2mo.restore(1, lib.dot(vvL, vvL.T), nvir)\n elif eris.vvvv.ndim == 2:\n nvir = int(np.sqrt(eris.vvvv.shape[0]*2))\n return ao2mo.restore(1, np.asarray(eris.vvvv), nvir)\n else:\n return eris.vvvv\n\n def contract_r2p(r1, r2, i0, i1, j0, j1, cache_ovvv_i, cache_ovvv_j, out=None):\n '''Create perturbed r2.'''\n if out is None:\n out = np.zeros((i1-i0,j1-j0) + (nvir,)*3, dtype=dtype)\n tmp = np.einsum('becf,f->bce', _get_vvvv(eris), r1)\n out += -lib.einsum('bce,ijae->ijabc', tmp, t2[i0:i1,j0:j1])\n tmp = np.einsum('mjce,e->mcj', eris.oovv[:,j0:j1], r1)\n out += lib.einsum('mcj,imab->ijabc', tmp, t2[i0:i1])\n tmp = np.einsum('jbem,e->mbj', eris.ovvo[j0:j1], r1)\n out += lib.einsum('mbj,imac->ijabc', tmp, t2[i0:i1])\n out += lib.einsum('iajm,mbc->ijabc', eris.ovoo[i0:i1,:,j0:j1].conj(), r2)\n out += -lib.einsum('iaeb,jec->ijabc', cache_ovvv_i.conj(), r2[j0:j1])\n out += -lib.einsum('jbec,iae->ijabc', cache_ovvv_j.conj(), r2[i0:i1])\n return out\n\n def contract_pr2p(r1, r2, i0, i1, j0, j1, cache_ovvv_i, cache_ovvv_j):\n '''Create P(ia|jb) of perturbed r2.'''\n out = contract_r2p(r1, r2, i0, i1, j0, j1, cache_ovvv_i, cache_ovvv_j)\n tmp = contract_r2p(r1, r2, j0, j1, i0, i1, cache_ovvv_j, cache_ovvv_i)\n tmp = tmp.transpose(1,0,3,2,4) # P(ia|jb)\n out = out + tmp\n return out\n\n eaccsd_evecs = np.array(eaccsd_evecs)\n leaccsd_evecs = np.array(leaccsd_evecs)\n e = []\n eaccsd_evecs, leaccsd_evecs = [np.atleast_2d(x) for x in [eaccsd_evecs, leaccsd_evecs]]\n eaccsd_evals = np.atleast_1d(eaccsd_evals)\n for eval_, evec_, levec_ in zip(eaccsd_evals, eaccsd_evecs, leaccsd_evecs):\n l1, l2 = eom.vector_to_amplitudes(levec_)\n r1, r2 = eom.vector_to_amplitudes(evec_)\n ldotr = np.dot(l1, r1) + np.dot(l2.ravel(),r2.ravel())\n l1 /= ldotr\n l2 /= ldotr\n l2 = 1./3*(1.*l2 + 2.*l2.transpose(0,2,1))\n r2 = r2.transpose(0,2,1)\n\n deltaE = 0.0\n eabc = (mo_e_vir[None,None,:,None,None] +\n mo_e_vir[None,None,None,:,None] +\n mo_e_vir[None,None,None,None,:] - eval_)\n\n for i0, i1 in lib.prange_tril(0, nocc, blksize):\n j0, j1 = 0, i1\n eijabc = (mo_e_occ[i0:i1][:,None,None,None,None] +\n mo_e_occ[j0:j1][None,:,None,None,None] - eabc)\n eijabc = 1./eijabc\n cache_ovvv_i = eris.get_ovvv(slice(i0,i1))\n cache_ovvv_j = eris.get_ovvv(slice(j0,j1))\n lijabc = contract_pl2p(l1, l2, i0, i1, j0, j1, cache_ovvv_i, cache_ovvv_j)\n rijabc = contract_pr2p(r1, r2, i0, i1, j0, j1, cache_ovvv_i, cache_ovvv_j)\n\n lijabc = 4.*lijabc \\\n - 2.*lijabc.transpose(0,1,3,2,4) \\\n - 2.*lijabc.transpose(0,1,4,3,2) \\\n - 2.*lijabc.transpose(0,1,2,4,3) \\\n + 1.*lijabc.transpose(0,1,3,4,2) \\\n + 1.*lijabc.transpose(0,1,4,2,3)\n\n # Symmetry factors (1 for a == b, 2 for a < b)\n fac = 2*np.ones_like(rijabc, dtype=int)\n triu_idx = np.triu_indices(i1-i0,i0+1,m=j1-j0)\n fac[triu_idx[0],triu_idx[1],:,:,:] = 0\n fac[np.arange(i1-i0),np.arange(i0,j1)] = 1\n eijabc *= fac\n\n deltaE += np.einsum('ijabc,ijabc,ijabc',lijabc,rijabc,eijabc)\n deltaE = 0.5*deltaE.real\n logger.info(eom, \"eaccsd energy, star energy, delta energy = %16.12f, %16.12f, %16.12f\",\n eval_, eval_+deltaE, deltaE)\n e.append(eval_+deltaE)\n return e\n\n\nclass EOMEA(EOM):\n def get_init_guess(self, nroots=1, koopmans=True, diag=None):\n size = self.vector_size()\n dtype = getattr(diag, 'dtype', np.double)\n nroots = min(nroots, size)\n guess = []\n if koopmans:\n for n in range(nroots):\n g = np.zeros(size, dtype)\n g[n] = 1.0\n guess.append(g)\n else:\n idx = diag.argsort()[:nroots]\n for i in idx:\n g = np.zeros(size, dtype)\n g[i] = 1.0\n guess.append(g)\n return guess\n\n kernel = eaccsd\n eaccsd = eaccsd\n eaccsd_star = eaccsd_star\n\n matvec = eaccsd_matvec\n l_matvec = leaccsd_matvec\n get_diag = eaccsd_diag\n ccsd_star_contract = eaccsd_star_contract\n\n def eaccsd_star_contract(self, eaccsd_evals, eaccsd_evecs, leaccsd_evecs, imds=None):\n return self.ccsd_star_contract(eaccsd_evals, eaccsd_evecs, leaccsd_evecs, imds=imds)\n\n def gen_matvec(self, imds=None, left=False, **kwargs):\n if imds is None: imds = self.make_imds()\n diag = self.get_diag(imds)\n if left:\n matvec = lambda xs: [self.l_matvec(x, imds, diag) for x in xs]\n else:\n matvec = lambda xs: [self.matvec(x, imds, diag) for x in xs]\n return matvec, diag\n\n def vector_to_amplitudes(self, vector, nmo=None, nocc=None):\n if nmo is None: nmo = self.nmo\n if nocc is None: nocc = self.nocc\n return vector_to_amplitudes_ea(vector, nmo, nocc)\n\n def amplitudes_to_vector(self, r1, r2):\n return amplitudes_to_vector_ea(r1, r2)\n\n def vector_size(self):\n nocc = self.nocc\n nvir = self.nmo - nocc\n return nvir + nocc*nvir*nvir\n\n def make_imds(self, eris=None):\n imds = _IMDS(self._cc, eris=eris)\n imds.make_ea(self.partition)\n return imds\n\n @property\n def eea(self):\n return self.e\n\n\nclass EOMEA_Ta(EOMEA):\n '''Class for EOM EACCSD(T)*(a) method by Matthews and Stanton.'''\n def make_imds(self, eris=None):\n imds = _IMDS(self._cc, eris=eris)\n imds.make_t3p2_ea(self._cc, self.partition)\n return imds\n\n########################################\n# EOM-EE-CCSD\n########################################\n\n#TODO: double spin-flip EOM-EE\n\ndef eeccsd(eom, nroots=1, koopmans=False, guess=None, eris=None, imds=None):\n '''Calculate N-electron neutral excitations via EOM-EE-CCSD.\n\n Kwargs:\n nroots : int\n Number of roots (eigenvalues) requested\n koopmans : bool\n Calculate Koopmans'-like (1p1h) excitations only, targeting via\n overlap.\n guess : list of ndarray\n List of guess vectors to use for targeting via overlap.\n '''\n if eris is None: eris = eom._cc.ao2mo()\n if imds is None: imds = eom.make_imds(eris)\n\n spinvec_size = eom.vector_size()\n nroots = min(nroots, spinvec_size)\n\n diag_eeS, diag_eeT, diag_sf = eom.get_diag(imds)\n guess_eeS = []\n guess_eeT = []\n guess_sf = []\n if guess:\n for g in guess:\n if g is None: # beta->alpha spin-flip excitation\n pass\n elif g.size == diag_eeS.size:\n guess_eeS.append(g)\n elif g.size == diag_eeT.size:\n guess_eeT.append(g)\n else:\n guess_sf.append(g)\n nroots_eeS = len(guess_eeS)\n nroots_eeT = len(guess_eeT)\n nroots_sf = len(guess_sf)\n if len(guess) != nroots:\n logger.warn(eom, 'Number of states in initial guess %d does not '\n 'equal to nroots %d.', len(guess), nroots)\n else:\n deeS = np.sort(diag_eeS)[:nroots]\n deeT = np.sort(diag_eeT)[:nroots]\n dsf = np.sort(diag_sf)[:nroots]\n dmax = np.sort(np.hstack([deeS,deeT,dsf,dsf]))[nroots-1]\n nroots_eeS = np.count_nonzero(deeS <= dmax)\n nroots_eeT = np.count_nonzero(deeT <= dmax)\n nroots_sf = np.count_nonzero(dsf <= dmax)\n guess_eeS = guess_eeT = guess_sf = None\n\n def eomee_sub(cls, nroots, guess, diag):\n ee_sub = cls(eom._cc)\n ee_sub.__dict__.update(eom.__dict__)\n e, v = ee_sub.kernel(nroots, koopmans, guess, eris, imds, diag=diag)\n if nroots == 1:\n e, v = [e], [v]\n ee_sub.converged = [ee_sub.converged]\n return list(ee_sub.converged), list(e), list(v)\n\n e0 = e1 = e2 = []\n v0 = v1 = v2 = []\n conv0 = conv1 = conv2 = []\n if nroots_eeS > 0:\n conv0, e0, v0 = eomee_sub(EOMEESinglet, nroots_eeS, guess_eeS, diag_eeS)\n if nroots_eeT > 0:\n conv2, e2, v2 = eomee_sub(EOMEETriplet, nroots_eeT, guess_eeT, diag_eeT)\n if nroots_sf > 0:\n conv1, e1, v1 = eomee_sub(EOMEESpinFlip, nroots_sf, guess_sf, diag_sf)\n # The associated solutions of beta->alpha excitations\n e1 = e1 + e1\n conv1 = conv1 + conv1\n v1 = v1 + [None] * len(v1)\n# beta->alpha spin-flip excitations, the coefficients are (-r1, (-r2[0], r2[1]))\n# as below. The EOMEESpinFlip class only handles alpha->beta excitations.\n# Setting beta->alpha to None to bypass the vectors in initial guess\n #for i in range(nroots_sf):\n # r1, r2 = vector_to_amplitudes_eomsf(v1[i], eom.nmo, eom.nocc)\n # v1.append(amplitudes_to_vector_eomsf(-r1, (-r2[0], r2[1])))\n\n e = np.hstack([e0,e2,e1])\n idx = e.argsort()\n e = e[idx]\n conv = conv0 + conv2 + conv1\n conv = [conv[x] for x in idx]\n v = v0 + v2 + v1\n v = [v[x] for x in idx]\n\n if nroots == 1:\n conv = conv[0]\n e = e[0]\n v = v[0]\n eom.converged = conv\n eom.e = e\n eom.v = v\n return eom.e, eom.v\n\n\ndef eomee_ccsd_singlet(eom, nroots=1, koopmans=False, guess=None,\n eris=None, imds=None, diag=None):\n '''EOM-EE-CCSD singlet\n '''\n eom.converged, eom.e, eom.v \\\n = kernel(eom, nroots, koopmans, guess, eris=eris, imds=imds, diag=diag)\n return eom.e, eom.v\n\ndef eomee_ccsd_triplet(eom, nroots=1, koopmans=False, guess=None,\n eris=None, imds=None, diag=None):\n '''EOM-EE-CCSD triplet\n '''\n return eomee_ccsd_singlet(eom, nroots, koopmans, guess, eris, imds, diag)\n\ndef eomsf_ccsd(eom, nroots=1, koopmans=False, guess=None,\n eris=None, imds=None, diag=None):\n '''Spin flip EOM-EE-CCSD\n '''\n return eomee_ccsd_singlet(eom, nroots, koopmans, guess, eris, imds, diag)\n\nvector_to_amplitudes_ee = vector_to_amplitudes_singlet = ccsd.vector_to_amplitudes\namplitudes_to_vector_ee = amplitudes_to_vector_singlet = ccsd.amplitudes_to_vector\n\ndef amplitudes_to_vector_eomsf(t1, t2, out=None):\n nocc, nvir = t1.shape\n t2baaa, t2aaba = t2\n otril = np.tril_indices(nocc, k=-1)\n vtril = np.tril_indices(nvir, k=-1)\n baaa = np.take(t2baaa.reshape(nocc*nocc,nvir*nvir),\n vtril[0]*nvir+vtril[1], axis=1)\n vector = np.hstack((t1.ravel(), baaa.ravel(), t2aaba[otril].ravel()))\n return vector\n\ndef vector_to_amplitudes_eomsf(vector, nmo, nocc):\n nvir = nmo - nocc\n t1 = vector[:nocc*nvir].reshape(nocc,nvir).copy()\n pvec = vector[t1.size:]\n\n nbaaa = nocc*nocc*nvir*(nvir-1)//2\n naaba = nocc*(nocc-1)//2*nvir*nvir\n t2baaa = np.zeros((nocc*nocc,nvir*nvir), dtype=vector.dtype)\n t2aaba = np.zeros((nocc*nocc,nvir*nvir), dtype=vector.dtype)\n otril = np.tril_indices(nocc, k=-1)\n vtril = np.tril_indices(nvir, k=-1)\n\n v = pvec[:nbaaa].reshape(nocc*nocc,nvir*(nvir-1)//2)\n t2baaa[:,vtril[0]*nvir+vtril[1]] = v\n t2baaa[:,vtril[1]*nvir+vtril[0]] = -v\n\n v = pvec[nbaaa:nbaaa+naaba].reshape(-1,nvir*nvir)\n t2aaba[otril[0]*nocc+otril[1]] = v\n t2aaba[otril[1]*nocc+otril[0]] = -v\n\n t2baaa = t2baaa.reshape(nocc,nocc,nvir,nvir)\n t2aaba = t2aaba.reshape(nocc,nocc,nvir,nvir)\n return t1, (t2baaa, t2aaba)\n\ndef amplitudes_to_vector_triplet(t1, t2, out=None):\n t2aa, t2ab = t2\n dtype = np.result_type(t1, t2aa, t2ab)\n nocc, nvir = t1.shape\n nov = nocc * nvir\n size1 = nov + nocc*(nocc-1)//2*nvir*(nvir-1)//2\n size = size1 + nov*(nov+1)//2\n vector = np.ndarray(size, dtype, buffer=out)\n ccsd.amplitudes_to_vector_s4(t1, t2[0], out=vector)\n t2ab = t2[1].transpose(0,2,1,3).reshape(nov,nov)\n lib.pack_tril(t2ab, out=vector[size1:])\n return vector\n\ndef vector_to_amplitudes_triplet(vector, nmo, nocc):\n nvir = nmo - nocc\n nov = nocc * nvir\n size1 = nov + nocc*(nocc-1)//2*nvir*(nvir-1)//2\n size = size1 + nov*(nov+1)//2\n t1, t2aa = ccsd.vector_to_amplitudes_s4(vector[:size1], nmo, nocc)\n t2ab = lib.unpack_tril(vector[size1:size], filltriu=2)\n t2ab = t2ab.reshape(nocc,nvir,nocc,nvir).transpose(0,2,1,3).copy()\n return t1, (t2aa, t2ab)\n\ndef eeccsd_matvec_singlet(eom, vector, imds=None):\n if imds is None: imds = eom.make_imds()\n nocc = eom.nocc\n nmo = eom.nmo\n nvir = nmo - nocc\n\n r1, r2 = vector_to_amplitudes_singlet(vector, nmo, nocc)\n t1, t2, eris = imds.t1, imds.t2, imds.eris\n nocc, nvir = t1.shape\n\n Hr1 = lib.einsum('ae,ie->ia', imds.Fvv, r1)\n Hr1 -= lib.einsum('mi,ma->ia', imds.Foo, r1)\n Hr1 += np.einsum('me,imae->ia',imds.Fov, r2) * 2\n Hr1 -= np.einsum('me,imea->ia',imds.Fov, r2)\n\n #:eris_vvvv = ao2mo.restore(1,np.asarray(eris.vvvv), t1.shape[1])\n #:Hr2 += lib.einsum('ijef,aebf->ijab', tau2, eris_vvvv) * .5\n tau2 = _make_tau(r2, r1, t1, fac=2)\n Hr2 = eom._cc._add_vvvv(None, tau2, eris, with_ovvv=False, t2sym='jiba')\n\n woOoO = np.asarray(imds.woOoO)\n Hr2 += lib.einsum('mnij,mnab->ijab', woOoO, r2)\n Hr2 *= .5\n woOoO = None\n\n Hr2 += lib.einsum('be,ijae->ijab', imds.Fvv , r2)\n Hr2 -= lib.einsum('mj,imab->ijab', imds.Foo , r2)\n\n mem_now = lib.current_memory()[0]\n max_memory = max(0, eom.max_memory - mem_now - Hr2.size*8e-6)\n blksize = min(nocc, max(ccsd.BLKMIN, int(max_memory*1e6/8/(nvir**3*3))))\n for p0,p1 in lib.prange(0, nocc, blksize):\n ovvv = eris.get_ovvv(slice(p0,p1)) # ovvv = eris.ovvv[p0:p1]\n theta = r2[p0:p1] * 2 - r2[p0:p1].transpose(0,1,3,2)\n Hr1 += lib.einsum('mfae,mife->ia', ovvv, theta)\n theta = None\n tmp = lib.einsum('meaf,ijef->maij', ovvv, tau2)\n Hr2 -= lib.einsum('ma,mbij->ijab', t1[p0:p1], tmp)\n tmp = lib.einsum('meaf,me->af', ovvv, r1[p0:p1]) * 2\n tmp -= lib.einsum('mfae,me->af', ovvv, r1[p0:p1])\n Hr2 += lib.einsum('af,ijfb->ijab', tmp, t2)\n ovvv = tmp = None\n tau2 = None\n Hr2 -= lib.einsum('mbij,ma->ijab', imds.woVoO, r1)\n\n blksize = min(nvir, max(ccsd.BLKMIN, int(max_memory*1e6/8/(nocc*nvir**2*2))))\n for p0, p1 in lib.prange(0, nvir, nocc):\n Hr2 += lib.einsum('ejab,ie->ijab', np.asarray(imds.wvOvV[p0:p1]), r1[:,p0:p1])\n\n woVVo = np.asarray(imds.woVVo)\n tmp = lib.einsum('mbej,imea->jiab', woVVo, r2)\n Hr2 += tmp\n tmp *= .5\n Hr2 += tmp.transpose(0,1,3,2)\n tmp = None\n\n woVvO = woVVo * .5\n woVVo = None\n woVvO += np.asarray(imds.woVvO)\n theta = r2*2 - r2.transpose(0,1,3,2)\n Hr1 += np.einsum('maei,me->ia', woVvO, r1) * 2\n Hr2 += lib.einsum('mbej,imae->ijab', woVvO, theta)\n woVvO = None\n\n woOoV = np.asarray(imds.woOoV)\n Hr1-= lib.einsum('mnie,mnae->ia', woOoV, theta)\n tmp = lib.einsum('nmie,me->ni', woOoV, r1) * 2\n tmp-= lib.einsum('mnie,me->ni', woOoV, r1)\n Hr2 -= lib.einsum('ni,njab->ijab', tmp, t2)\n tmp = woOoV = None\n\n eris_ovov = np.asarray(eris.ovov)\n tmp = np.einsum('mfne,mf->en', eris_ovov, r1) * 2\n tmp -= np.einsum('menf,mf->en', eris_ovov, r1)\n tmp = np.einsum('en,nb->eb', tmp, t1)\n tmp += lib.einsum('menf,mnbf->eb', eris_ovov, theta)\n Hr2 -= lib.einsum('eb,ijea->jiab', tmp, t2)\n tmp = None\n\n tmp = lib.einsum('nemf,imef->ni', eris_ovov, theta)\n Hr1 -= lib.einsum('na,ni->ia', t1, tmp)\n Hr2 -= lib.einsum('mj,miab->ijba', tmp, t2)\n tmp = theta = None\n\n tau2 = _make_tau(r2, r1, t1, fac=2)\n tmp = lib.einsum('menf,ijef->mnij', eris_ovov, tau2)\n tau2 = None\n\n tau = _make_tau(t2, t1, t1)\n tau *= .5\n Hr2 += lib.einsum('mnij,mnab->ijab', tmp, tau)\n tau = tmp = eris_ovov = None\n\n Hr2 = Hr2 + Hr2.transpose(1,0,3,2)\n vector = amplitudes_to_vector_ee(Hr1, Hr2)\n return vector\n\ndef eeccsd_matvec_triplet(eom, vector, imds=None):\n if imds is None: imds = eom.make_imds()\n nocc = eom.nocc\n nmo = eom.nmo\n nvir = nmo - nocc\n\n r1, r2 = vector_to_amplitudes_triplet(vector, nmo, nocc)\n r2aa, r2ab = r2\n t1, t2, eris = imds.t1, imds.t2, imds.eris\n nocc, nvir = t1.shape\n\n Hr1 = lib.einsum('ae,ie->ia', imds.Fvv, r1)\n Hr1 -= lib.einsum('mi,ma->ia', imds.Foo, r1)\n Hr1 += np.einsum('me,imae->ia',imds.Fov, r2aa)\n Hr1 += np.einsum('ME,iMaE->ia',imds.Fov, r2ab)\n\n tau2ab = np.einsum('ia,jb->ijab', r1, t1)\n tau2ab-= np.einsum('ia,jb->ijab', t1, r1)\n tau2ab+= r2ab\n tau2aa = np.einsum('ia,jb->ijab', r1, t1)\n tau2aa-= np.einsum('ia,jb->jiab', r1, t1)\n tau2aa = tau2aa - tau2aa.transpose(0,1,3,2)\n tau2aa+= r2aa\n\n #:eris_vvvv = ao2mo.restore(1,np.asarray(eris.vvvv), t1.shape[1])\n #:Hr2aa += lib.einsum('ijef,aebf->ijab', tau2aa, eris_vvvv) * .25\n #:Hr2ab += lib.einsum('ijef,aebf->ijab', tau2ab, eris_vvvv) * .5\n Hr2aa = eom._cc._add_vvvv(None, tau2aa, eris, with_ovvv=False, t2sym='jiba')\n Hr2ab = eom._cc._add_vvvv(None, tau2ab, eris, with_ovvv=False, t2sym='-jiba')\n\n woOoO = np.asarray(imds.woOoO)\n Hr2aa += lib.einsum('mnij,mnab->ijab', woOoO, r2aa)\n Hr2ab += lib.einsum('mNiJ,mNaB->iJaB', woOoO, r2ab)\n Hr2aa *= .25\n Hr2ab *= .5\n woOoO = None\n\n Hr2aa += lib.einsum('be,ijae->ijab', imds.Fvv*.5, r2aa)\n Hr2aa -= lib.einsum('mj,imab->ijab', imds.Foo*.5, r2aa)\n Hr2ab += lib.einsum('BE,iJaE->iJaB', imds.Fvv, r2ab)\n Hr2ab -= lib.einsum('MJ,iMaB->iJaB', imds.Foo, r2ab)\n\n mem_now = lib.current_memory()[0]\n max_memory = max(0, eom.max_memory - mem_now - Hr2aa.size*8e-6)\n blksize = min(nocc, max(ccsd.BLKMIN, int(max_memory*1e6/8/(nvir**3*3))))\n tmp1 = np.zeros((nvir,nvir), dtype=r1.dtype)\n for p0,p1 in lib.prange(0, nocc, blksize):\n ovvv = eris.get_ovvv(slice(p0,p1)) # ovvv = eris.ovvv[p0:p1]\n theta = r2aa[:,p0:p1] + r2ab[:,p0:p1]\n Hr1 += lib.einsum('mfae,imef->ia', ovvv, theta)\n theta = None\n tmpaa = lib.einsum('meaf,ijef->maij', ovvv, tau2aa)\n tmpab = lib.einsum('meAF,iJeF->mAiJ', ovvv, tau2ab)\n tmp1 += lib.einsum('mfae,me->af', ovvv, r1[p0:p1])\n Hr2aa+= lib.einsum('mb,maij->ijab', t1[p0:p1]*.5, tmpaa)\n Hr2ab-= lib.einsum('mb,mAiJ->iJbA', t1[p0:p1], tmpab)\n ovvv = tmpaa = tmpab = None\n tau2aa = tau2ab = None\n\n woVVo = np.asarray(imds.woVVo)\n Hr1 += np.einsum('maei,me->ia', woVVo, r1)\n Hr2aa += lib.einsum('mbej,imae->ijba', woVVo, r2ab)\n Hr2ab += lib.einsum('MBEJ,iMEa->iJaB', woVVo, r2aa)\n Hr2ab += lib.einsum('MbeJ,iMeA->iJbA', woVVo, r2ab)\n\n woVVo = woVVo + np.asarray(imds.woVvO)\n theta = r2aa + r2ab\n tmp = lib.einsum('mbej,imae->ijab', woVVo, theta)\n woVVo = None\n\n woOoV = np.asarray(imds.woOoV)\n Hr1 -= lib.einsum('mnie,mnae->ia', woOoV, theta)\n tmpa = lib.einsum('mnie,me->ni', woOoV, r1)\n tmp += lib.einsum('ni,njab->ijab', tmpa, t2)\n tmp -= lib.einsum('af,ijfb->ijab', tmp1, t2)\n tmp -= lib.einsum('mbij,ma->ijab', imds.woVoO, r1)\n\n blksize = min(nvir, max(ccsd.BLKMIN, int(max_memory*1e6/8/(nocc*nvir**2*2))))\n for p0,p1 in lib.prange(0, nvir, blksize):\n tmp += lib.einsum('ejab,ie->ijab', np.asarray(imds.wvOvV[p0:p1]), r1[:,p0:p1])\n\n Hr2aa += tmp\n Hr2ab += tmp\n tmp = woOoV = None\n\n eris_ovov = np.asarray(eris.ovov)\n tmpa = -lib.einsum('menf,imfe->ni', eris_ovov, theta)\n Hr1 += lib.einsum('na,ni->ia', t1, tmpa)\n tmp = lib.einsum('mj,imab->ijab', tmpa, t2)\n tmp1 = np.einsum('menf,mf->en', eris_ovov, r1)\n tmpa = lib.einsum('en,nb->eb', tmp1, t1)\n tmpa-= lib.einsum('menf,mnbf->eb', eris_ovov, theta)\n tmp += lib.einsum('eb,ijae->ijab', tmpa, t2)\n Hr2aa += tmp\n Hr2ab -= tmp\n tmp = theta = tmp1 = tmpa = None\n\n tau2aa = np.einsum('ia,jb->ijab', r1, t1)\n tau2aa-= np.einsum('ia,jb->jiab', r1, t1)\n tau2aa = tau2aa - tau2aa.transpose(0,1,3,2)\n tau2aa+= r2aa\n tmpaa = lib.einsum('menf,ijef->mnij', eris_ovov, tau2aa)\n tau2aa = None\n tmpaa *= .25\n tau = _make_tau(t2, t1, t1)\n Hr2aa += lib.einsum('mnij,mnab->ijab', tmpaa, tau)\n tmpaa = tau = None\n\n tau2ab = np.einsum('ia,jb->ijab', r1, t1)\n tau2ab-= np.einsum('ia,jb->ijab', t1, r1)\n tau2ab+= r2ab\n tmpab = lib.einsum('meNF,iJeF->mNiJ', eris_ovov, tau2ab)\n tau2ab = None\n tmpab *= .5\n tau = _make_tau(t2, t1, t1)\n Hr2ab += lib.einsum('mNiJ,mNaB->iJaB', tmpab, tau)\n tmpab = tau = None\n eris_ovov = None\n\n Hr2aa = Hr2aa - Hr2aa.transpose(0,1,3,2)\n Hr2aa = Hr2aa - Hr2aa.transpose(1,0,2,3)\n Hr2ab = Hr2ab - Hr2ab.transpose(1,0,3,2)\n vector = amplitudes_to_vector_triplet(Hr1, (Hr2aa,Hr2ab))\n return vector\n\ndef eeccsd_matvec_sf(eom, vector, imds=None):\n '''Spin flip EOM-CCSD'''\n if imds is None: imds = eom.make_imds()\n nocc = eom.nocc\n nmo = eom.nmo\n nvir = nmo - nocc\n\n t1, t2, eris = imds.t1, imds.t2, imds.eris\n r1, r2 = vector_to_amplitudes_eomsf(vector, nmo, nocc)\n r2baaa, r2aaba = r2\n nocc, nvir = t1.shape\n\n Hr1 = np.einsum('ae,ie->ia', imds.Fvv, r1)\n Hr1 -= np.einsum('mi,ma->ia', imds.Foo, r1)\n Hr1 += np.einsum('me,imae->ia', imds.Fov, r2baaa)\n Hr1 += np.einsum('me,imae->ia', imds.Fov, r2aaba)\n\n tau2baaa = np.einsum('ia,jb->ijab', r1, t1)\n tau2baaa += r2baaa * .5\n tau2baaa = tau2baaa - tau2baaa.transpose(0,1,3,2)\n tau2aaba = np.einsum('ia,jb->ijab', r1, t1)\n tau2aaba += r2aaba * .5\n tau2aaba = tau2aaba - tau2aaba.transpose(1,0,2,3)\n\n #:eris_vvvv = ao2mo.restore(1,np.asarray(eris.vvvv), t1.shape[1])\n #:Hr2baaa += .5*lib.einsum('ijef,aebf->ijab', tau2baaa, eris_vvvv)\n #:Hr2aaba += .5*lib.einsum('ijef,aebf->ijab', tau2aaba, eris_vvvv)\n Hr2aaba = eom._cc._add_vvvv(None, tau2aaba, eris, with_ovvv=False, t2sym='-jiab')\n Hr2baaa = eom._cc._add_vvvv(None, tau2baaa, eris, with_ovvv=False, t2sym=False)\n\n woOoO = np.asarray(imds.woOoO)\n Hr2baaa += lib.einsum('mnij,mnab->ijab', woOoO, r2baaa)\n Hr2aaba += lib.einsum('mnij,mnab->ijab', woOoO, r2aaba)\n Hr2aaba *= .5\n Hr2baaa *= .5\n woOoO = None\n\n Hr2baaa -= lib.einsum('mj,imab->ijab', imds.Foo*.5, r2baaa)\n Hr2aaba -= lib.einsum('mj,imab->ijab', imds.Foo*.5, r2aaba)\n Hr2baaa -= lib.einsum('mj,miab->jiab', imds.Foo*.5, r2baaa)\n Hr2aaba -= lib.einsum('mj,miab->jiab', imds.Foo*.5, r2aaba)\n Hr2baaa += lib.einsum('be,ijae->ijab', imds.Fvv*.5, r2baaa)\n Hr2aaba += lib.einsum('be,ijae->ijab', imds.Fvv*.5, r2aaba)\n Hr2baaa += lib.einsum('be,ijea->ijba', imds.Fvv*.5, r2baaa)\n Hr2aaba += lib.einsum('be,ijea->ijba', imds.Fvv*.5, r2aaba)\n\n mem_now = lib.current_memory()[0]\n max_memory = max(0, eom.max_memory - mem_now - Hr2aaba.size*8e-6)\n blksize = min(nocc, max(ccsd.BLKMIN, int(max_memory*1e6/8/(nvir**3*3))))\n for p0,p1 in lib.prange(0, nocc, blksize):\n ovvv = eris.get_ovvv(slice(p0,p1)) # ovvv = eris.ovvv[p0:p1]\n theta = r2baaa[:,p0:p1] + r2aaba[:,p0:p1]\n Hr1 += lib.einsum('mfae,imef->ia', ovvv, theta)\n theta = None\n\n tmp1aaba = lib.einsum('meaf,ijef->maij', ovvv, tau2baaa)\n Hr2baaa -= lib.einsum('mb,maij->ijba', t1[p0:p1]*.5, tmp1aaba)\n tmp1aaba = tmp1baaa = tmp1abaa = tmp2aaba = None\n\n tmp2aaba = lib.einsum('meaf,ijfe->maij', ovvv, tau2baaa)\n Hr2baaa -= lib.einsum('mb,maij->ijab', t1[p0:p1]*.5, tmp2aaba)\n tmp1aaba = tmp1baaa = tmp1abaa = tmp2aaba = None\n\n tmp1baaa = lib.einsum('meaf,ijef->maij', ovvv, tau2aaba)\n Hr2aaba -= lib.einsum('mb,maij->ijba', t1[p0:p1]*.5, tmp1baaa)\n tmp1aaba = tmp1baaa = tmp1abaa = tmp2aaba = None\n\n tmp1abaa = lib.einsum('meaf,ijfe->maij', ovvv, tau2aaba)\n Hr2aaba -= lib.einsum('mb,maij->ijab', t1[p0:p1]*.5, tmp1abaa)\n tmp1aaba = tmp1baaa = tmp1abaa = tmp2aaba = None\n\n tmp = lib.einsum('mfae,me->af', ovvv, r1[p0:p1])\n tmp = lib.einsum('af,jibf->ijab', tmp, t2)\n Hr2baaa -= tmp\n Hr2aaba -= tmp\n tmp = ovvv = None\n tau2aaba = tau2baaa = None\n\n tmp = lib.einsum('mbij,ma->ijab', imds.woVoO, r1)\n Hr2baaa -= tmp\n Hr2aaba -= tmp\n tmp = None\n\n woOoV = np.asarray(imds.woOoV)\n Hr1 -= lib.einsum('mnie,mnae->ia', woOoV, r2aaba)\n Hr1 -= lib.einsum('mnie,mnae->ia', woOoV, r2baaa)\n tmp = lib.einsum('mnie,me->ni', woOoV, r1)\n tmp = lib.einsum('ni,njab->ijab', tmp, t2)\n Hr2baaa += tmp\n Hr2aaba += tmp\n tmp = woOoV = None\n\n for p0,p1 in lib.prange(0, nvir, nocc):\n tmp = lib.einsum('ejab,ie->ijab', np.asarray(imds.wvOvV[p0:p1]), r1[:,p0:p1])\n Hr2baaa += tmp\n Hr2aaba += tmp\n tmp = None\n\n woVVo = np.asarray(imds.woVVo)\n Hr1 += np.einsum('maei,me->ia', woVVo, r1)\n Hr2baaa += lib.einsum('mbej,miea->jiba', woVVo, r2baaa)\n Hr2aaba += lib.einsum('mbej,miea->jiba', woVVo, r2aaba)\n woVVo = None\n woVvO = np.asarray(imds.woVvO)\n Hr2baaa += lib.einsum('mbej,imae->ijab', woVvO, r2aaba)\n Hr2aaba += lib.einsum('mbej,imae->ijab', woVvO, r2baaa)\n woVvO = woVvO + np.asarray(imds.woVVo)\n Hr2baaa += lib.einsum('mbej,imae->ijab', woVvO, r2baaa)\n Hr2aaba += lib.einsum('mbej,imae->ijab', woVvO, r2aaba)\n woVvO = None\n\n eris_ovov = np.asarray(eris.ovov)\n theta = r2aaba + r2baaa\n tmp = lib.einsum('nfme,imfe->ni', eris_ovov, theta)\n Hr1 -= np.einsum('na,ni->ia', t1, tmp)\n Hr2baaa -= lib.einsum('mj,imba->jiab', tmp, t2)\n Hr2aaba -= lib.einsum('mj,imba->jiab', tmp, t2)\n\n tmp = np.einsum('menf,mf->en', eris_ovov, r1)\n tmp = np.einsum('en,nb->eb', tmp, t1)\n tmp-= lib.einsum('menf,mnbf->eb', eris_ovov, theta)\n Hr2baaa += lib.einsum('ea,ijbe->jiab', tmp, t2)\n Hr2aaba += lib.einsum('ea,ijbe->jiab', tmp, t2)\n theta = tmp = None\n\n tau2baaa = np.einsum('ia,jb->ijab', r1, t1)\n tau2baaa += r2baaa * .5\n tau2baaa = tau2baaa - tau2baaa.transpose(0,1,3,2)\n tau = _make_tau(t2, t1, t1)\n tmp1aaba = lib.einsum('menf,ijef->mnij', eris_ovov, tau2baaa)\n tau2baaa = None\n Hr2baaa += .5*lib.einsum('mnij,mnab->ijab', tmp1aaba, tau)\n tau = tmp1aaba = None\n\n tau2aaba = np.einsum('ia,jb->ijab', r1, t1)\n tau2aaba += r2aaba * .5\n tau2aaba = tau2aaba - tau2aaba.transpose(1,0,2,3)\n tau = _make_tau(t2, t1, t1)\n tmp1baaa = lib.einsum('menf,ijef->mnij', eris_ovov, tau2aaba)\n tau2aaba = None\n Hr2aaba += .5*lib.einsum('mnij,mnab->ijab', tmp1baaa, tau)\n tau = tmp1baaa = None\n eris_ovov = None\n\n Hr2baaa = Hr2baaa - Hr2baaa.transpose(0,1,3,2)\n Hr2aaba = Hr2aaba - Hr2aaba.transpose(1,0,2,3)\n vector = amplitudes_to_vector_eomsf(Hr1, (Hr2baaa,Hr2aaba))\n return vector\n\ndef eeccsd_diag(eom, imds=None):\n if imds is None: imds = eom.make_imds()\n eris = imds.eris\n t1, t2 = imds.t1, imds.t2\n dtype = np.result_type(t1, t2)\n tau = _make_tau(t2, t1, t1)\n nocc, nvir = t1.shape\n\n Fo = imds.Foo.diagonal()\n Fv = imds.Fvv.diagonal()\n Wovab = np.einsum('iaai->ia', imds.woVVo)\n Wovaa = Wovab + np.einsum('iaai->ia', imds.woVvO)\n\n eia = lib.direct_sum('-i+a->ia', Fo, Fv)\n Hr1aa = eia + Wovaa\n Hr1ab = eia + Wovab\n\n eris_ovov = np.asarray(eris.ovov)\n Wvvab = np.einsum('mnab,manb->ab', tau, eris_ovov)\n Wvvaa = .5*Wvvab - .5*np.einsum('mnba,manb->ab', tau, eris_ovov)\n ijb = np.einsum('iejb,ijeb->ijb', eris_ovov, t2)\n Hr2ab = lib.direct_sum('iJB+a->iJaB',-ijb, Fv)\n jab = np.einsum('kajb,kjab->jab', eris_ovov, t2)\n Hr2ab+= lib.direct_sum('-i-jab->ijab', Fo, jab)\n\n jib = np.einsum('iejb,ijbe->jib', eris_ovov, t2)\n jib = jib + jib.transpose(1,0,2)\n jib-= ijb + ijb.transpose(1,0,2)\n jba = np.einsum('kajb,jkab->jba', eris_ovov, t2)\n jba = jba + jba.transpose(0,2,1)\n jba-= jab + jab.transpose(0,2,1)\n Hr2aa = lib.direct_sum('jib+a->jiba', jib, Fv)\n Hr2aa+= lib.direct_sum('-i+jba->ijba', Fo, jba)\n eris_ovov = None\n\n Hr2baaa = lib.direct_sum('ijb+a->ijba',-ijb, Fv)\n Hr2baaa += Wovaa.reshape(1,nocc,1,nvir)\n Hr2baaa += Wovab.reshape(nocc,1,1,nvir)\n Hr2baaa = Hr2baaa + Hr2baaa.transpose(0,1,3,2)\n Hr2baaa+= lib.direct_sum('-i+jab->ijab', Fo, jba)\n Hr2baaa-= Fo.reshape(1,-1,1,1)\n Hr2aaba = lib.direct_sum('-i-jab->ijab', Fo, jab)\n Hr2aaba += Wovaa.reshape(1,nocc,1,nvir)\n Hr2aaba += Wovab.reshape(1,nocc,nvir,1)\n Hr2aaba = Hr2aaba + Hr2aaba.transpose(1,0,2,3)\n Hr2aaba+= lib.direct_sum('ijb+a->ijab', jib, Fv)\n Hr2aaba+= Fv.reshape(1,1,1,-1)\n Hr2ab += Wovaa.reshape(1,nocc,1,nvir)\n Hr2ab += Wovab.reshape(nocc,1,1,nvir)\n Hr2ab = Hr2ab + Hr2ab.transpose(1,0,3,2)\n Hr2aa += Wovaa.reshape(1,nocc,1,nvir) * 2\n Hr2aa = Hr2aa + Hr2aa.transpose(0,1,3,2)\n Hr2aa = Hr2aa + Hr2aa.transpose(1,0,2,3)\n Hr2aa *= .5\n\n Wooab = np.einsum('ijij->ij', imds.woOoO)\n Wooaa = Wooab - np.einsum('ijji->ij', imds.woOoO)\n Hr2aa += Wooaa.reshape(nocc,nocc,1,1)\n Hr2ab += Wooab.reshape(nocc,nocc,1,1)\n Hr2baaa += Wooab.reshape(nocc,nocc,1,1)\n Hr2aaba += Wooaa.reshape(nocc,nocc,1,1)\n\n #:eris_ovvv = lib.unpack_tril(np.asarray(eris.ovvv).reshape(nocc*nvir,nvir**2)).reshape(nocc,nvir,nvir,nvir)\n #:tmp = np.einsum('mb,mbaa->ab', t1, eris_ovvv)\n #:Wvvaa += np.einsum('mb,maab->ab', t1, eris_ovvv)\n mem_now = lib.current_memory()[0]\n max_memory = max(0, eom.max_memory - mem_now)\n blksize = min(nocc, max(ccsd.BLKMIN, int(max_memory*1e6/8/(nvir**3*3))))\n tmp = np.zeros((nvir,nvir), dtype=dtype)\n for p0,p1 in lib.prange(0, nocc, blksize):\n ovvv = eris.get_ovvv(slice(p0,p1)) # ovvv = eris.ovvv[p0:p1]\n tmp += np.einsum('mb,mbaa->ab', t1[p0:p1], ovvv)\n Wvvaa += np.einsum('mb,maab->ab', t1[p0:p1], ovvv)\n ovvv = None\n Wvvaa -= tmp\n Wvvab -= tmp\n Wvvab -= tmp.T\n Wvvaa = Wvvaa + Wvvaa.T\n if eris.vvvv is None: # AO-direct CCSD, vvvv is not generated.\n pass\n elif eris.vvvv.ndim == 4:\n eris_vvvv = ao2mo.restore(1,np.asarray(eris.vvvv), t1.shape[1])\n tmp = np.einsum('aabb->ab', eris_vvvv)\n Wvvaa += tmp\n Wvvaa -= np.einsum('abba->ab', eris_vvvv)\n Wvvab += tmp\n else:\n for i in range(nvir):\n i0 = i*(i+1)//2\n vvv = lib.unpack_tril(np.asarray(eris.vvvv[i0:i0+i+1]))\n tmp = np.einsum('bb->b', vvv[i])\n Wvvaa[i] += tmp\n Wvvab[i] += tmp\n tmp = np.einsum('bb->b', vvv[:,:i+1,i])\n Wvvaa[i,:i+1] -= tmp\n Wvvaa[:i ,i] -= tmp[:i]\n vvv = None\n\n Hr2aa += Wvvaa.reshape(1,1,nvir,nvir)\n Hr2ab += Wvvab.reshape(1,1,nvir,nvir)\n Hr2baaa += Wvvaa.reshape(1,1,nvir,nvir)\n Hr2aaba += Wvvab.reshape(1,1,nvir,nvir)\n\n vec_eeS = amplitudes_to_vector_singlet(Hr1aa, Hr2ab)\n vec_eeT = amplitudes_to_vector_triplet(Hr1aa, (Hr2aa,Hr2ab))\n vec_sf = amplitudes_to_vector_eomsf(Hr1ab, (Hr2baaa,Hr2aaba))\n return vec_eeS, vec_eeT, vec_sf\n\n\nclass EOMEE(EOM):\n def get_init_guess(self, nroots=1, koopmans=True, diag=None):\n if koopmans:\n nocc = self.nocc\n nvir = self.nmo - nocc\n idx = diag[:nocc*nvir].argsort()\n else:\n idx = diag.argsort()\n\n size = self.vector_size()\n dtype = getattr(diag, 'dtype', np.double)\n nroots = min(nroots, size)\n guess = []\n for i in idx[:nroots]:\n g = np.zeros(size, dtype)\n g[i] = 1.0\n guess.append(g)\n return guess\n\n kernel = eeccsd\n eeccsd = eeccsd\n get_diag = eeccsd_diag\n\n def vector_size(self):\n '''size of the vector based on spin-orbital basis'''\n nocc = self.nocc\n nvir = self.nmo - nocc\n return nocc*nvir + nocc*nocc*nvir*nvir\n\n def make_imds(self, eris=None):\n imds = _IMDS(self._cc, eris=eris)\n imds.make_ee()\n return imds\n\n @property\n def eee(self):\n return self.e\n\n\nclass EOMEESinglet(EOMEE):\n kernel = eomee_ccsd_singlet\n eomee_ccsd_singlet = eomee_ccsd_singlet\n matvec = eeccsd_matvec_singlet\n\n def gen_matvec(self, imds=None, diag=None, **kwargs):\n if imds is None: imds = self.make_imds()\n if diag is None: diag = self.get_diag(imds)[0]\n matvec = lambda xs: [self.matvec(x, imds) for x in xs]\n return matvec, diag\n\n def vector_to_amplitudes(self, vector, nmo=None, nocc=None):\n if nmo is None: nmo = self.nmo\n if nocc is None: nocc = self.nocc\n return vector_to_amplitudes_singlet(vector, nmo, nocc)\n\n def amplitudes_to_vector(self, r1, r2):\n return amplitudes_to_vector_singlet(r1, r2)\n\n def vector_size(self):\n nocc = self.nocc\n nvir = self.nmo - nocc\n nov = nocc * nvir\n return nov + nov*(nov+1)//2\n\n\nclass EOMEETriplet(EOMEE):\n kernel = eomee_ccsd_triplet\n eomee_ccsd_triplet = eomee_ccsd_triplet\n matvec = eeccsd_matvec_triplet\n\n def gen_matvec(self, imds=None, diag=None, **kwargs):\n if imds is None: imds = self.make_imds()\n if diag is None: diag = self.get_diag(imds)[1]\n matvec = lambda xs: [self.matvec(x, imds) for x in xs]\n return matvec, diag\n\n def vector_to_amplitudes(self, vector, nmo=None, nocc=None):\n if nmo is None: nmo = self.nmo\n if nocc is None: nocc = self.nocc\n return vector_to_amplitudes_triplet(vector, nmo, nocc)\n\n def amplitudes_to_vector(self, r1, r2):\n return amplitudes_to_vector_triplet(r1, r2)\n\n def vector_size(self):\n nocc = self.nocc\n nvir = self.nmo - nocc\n nov = nocc * nvir\n return nov + nocc*(nocc-1)//2*nvir*(nvir-1)//2 + nov*(nov+1)//2\n\n\nclass EOMEESpinFlip(EOMEE):\n kernel = eomsf_ccsd\n eomsf_ccsd = eomsf_ccsd\n matvec = eeccsd_matvec_sf\n\n def gen_matvec(self, imds=None, diag=None, **kwargs):\n if imds is None: imds = self.make_imds()\n if diag is None: diag = self.get_diag(imds)[2]\n matvec = lambda xs: [self.matvec(x, imds) for x in xs]\n return matvec, diag\n\n def vector_to_amplitudes(self, vector, nmo=None, nocc=None):\n if nmo is None: nmo = self.nmo\n if nocc is None: nocc = self.nocc\n return vector_to_amplitudes_eomsf(vector, nmo, nocc)\n\n def amplitudes_to_vector(self, r1, r2):\n return amplitudes_to_vector_eomsf(r1, r2)\n\n def vector_size(self):\n nocc = self.nocc\n nvir = self.nmo - nocc\n nbaaa = nocc*nocc*nvir*(nvir-1)//2\n naaba = nocc*(nocc-1)//2*nvir*nvir\n return nocc*nvir + nbaaa + naaba\n\n#TODO: Check whether EOM methods works with rccsd.RCCSD when orbitals are complex\nccsd.CCSD.EOMIP = lib.class_as_method(EOMIP)\nccsd.CCSD.EOMIP_Ta = lib.class_as_method(EOMIP_Ta)\nccsd.CCSD.EOMEA = lib.class_as_method(EOMEA)\nccsd.CCSD.EOMEA_Ta = lib.class_as_method(EOMEA_Ta)\nccsd.CCSD.EOMEE = lib.class_as_method(EOMEE)\nccsd.CCSD.EOMEESinglet = lib.class_as_method(EOMEESinglet)\nccsd.CCSD.EOMEETriplet = lib.class_as_method(EOMEETriplet)\nccsd.CCSD.EOMEESpinFlip = lib.class_as_method(EOMEESpinFlip)\n\n\nclass _IMDS:\n def __init__(self, cc, eris=None):\n self.verbose = cc.verbose\n self.stdout = cc.stdout\n self.max_memory = cc.max_memory\n self.t1 = cc.t1\n self.t2 = cc.t2\n if eris is None:\n eris = cc.ao2mo()\n self.eris = eris\n self._made_shared_2e = False\n\n def _make_shared_1e(self):\n cput0 = (logger.process_clock(), logger.perf_counter())\n\n t1, t2, eris = self.t1, self.t2, self.eris\n self.Loo = imd.Loo(t1, t2, eris)\n self.Lvv = imd.Lvv(t1, t2, eris)\n self.Fov = imd.cc_Fov(t1, t2, eris)\n\n logger.timer_debug1(self, 'EOM-CCSD shared one-electron '\n 'intermediates', *cput0)\n return self\n\n def _make_shared_2e(self):\n cput0 = (logger.process_clock(), logger.perf_counter())\n log = logger.Logger(self.stdout, self.verbose)\n\n t1, t2, eris = self.t1, self.t2, self.eris\n # 2 virtuals\n self.Wovov = imd.Wovov(t1, t2, eris)\n self.Wovvo = imd.Wovvo(t1, t2, eris)\n self.Woovv = np.asarray(eris.ovov).transpose(0,2,1,3)\n\n self._made_shared_2e = True\n log.timer_debug1('EOM-CCSD shared two-electron intermediates', *cput0)\n return self\n\n def make_ip(self, ip_partition=None):\n self._make_shared_1e()\n if not self._made_shared_2e and ip_partition != 'mp':\n self._make_shared_2e()\n\n cput0 = (logger.process_clock(), logger.perf_counter())\n log = logger.Logger(self.stdout, self.verbose)\n\n t1, t2, eris = self.t1, self.t2, self.eris\n\n # 0 or 1 virtuals\n if ip_partition != 'mp':\n self.Woooo = imd.Woooo(t1, t2, eris)\n self.Wooov = imd.Wooov(t1, t2, eris)\n self.Wovoo = imd.Wovoo(t1, t2, eris)\n log.timer_debug1('EOM-CCSD IP intermediates', *cput0)\n return self\n\n def make_t3p2_ip(self, cc, ip_partition=None):\n assert(ip_partition is None)\n cput0 = (logger.process_clock(), logger.perf_counter())\n\n t1, t2, eris = cc.t1, cc.t2, self.eris\n delta_E_corr, pt1, pt2, Wovoo, Wvvvo = \\\n imd.get_t3p2_imds_slow(cc, t1, t2, eris)\n self.t1 = pt1\n self.t2 = pt2\n\n self._made_shared_2e = False # Force update\n self.make_ip() # Make after t1/t2 updated\n self.Wovoo = self.Wovoo + Wovoo\n\n logger.timer_debug1(self, 'EOM-CCSD(T)a IP intermediates', *cput0)\n return self\n\n\n def make_ea(self, ea_partition=None):\n self._make_shared_1e()\n if not self._made_shared_2e and ea_partition != 'mp':\n self._make_shared_2e()\n\n cput0 = (logger.process_clock(), logger.perf_counter())\n log = logger.Logger(self.stdout, self.verbose)\n\n t1, t2, eris = self.t1, self.t2, self.eris\n\n # 3 or 4 virtuals\n self.Wvovv = imd.Wvovv(t1, t2, eris)\n if ea_partition == 'mp':\n self.Wvvvo = imd.Wvvvo(t1, t2, eris)\n else:\n self.Wvvvv = imd.Wvvvv(t1, t2, eris)\n self.Wvvvo = imd.Wvvvo(t1, t2, eris, self.Wvvvv)\n log.timer_debug1('EOM-CCSD EA intermediates', *cput0)\n return self\n\n def make_t3p2_ea(self, cc, ea_partition=None):\n assert(ea_partition is None)\n cput0 = (logger.process_clock(), logger.perf_counter())\n\n t1, t2, eris = cc.t1, cc.t2, self.eris\n delta_E_corr, pt1, pt2, Wovoo, Wvvvo = \\\n imd.get_t3p2_imds_slow(cc, t1, t2, eris)\n self.t1 = pt1\n self.t2 = pt2\n\n self._made_shared_2e = False # Force update\n self.make_ea() # Make after t1/t2 updated\n self.Wvvvo = self.Wvvvo + Wvvvo\n\n logger.timer_debug1(self, 'EOM-CCSD(T)a EA intermediates', *cput0)\n return self\n\n\n def make_ee(self):\n cput0 = (logger.process_clock(), logger.perf_counter())\n log = logger.Logger(self.stdout, self.verbose)\n\n t1, t2, eris = self.t1, self.t2, self.eris\n dtype = np.result_type(t1, t2)\n if np.iscomplexobj(t2):\n raise NotImplementedError('Complex integrals are not supported in EOM-EE-CCSD')\n\n nocc, nvir = t1.shape\n\n fswap = lib.H5TmpFile()\n self.saved = lib.H5TmpFile()\n self.wvOvV = self.saved.create_dataset('wvOvV', (nvir,nocc,nvir,nvir), dtype.char)\n self.woVvO = self.saved.create_dataset('woVvO', (nocc,nvir,nvir,nocc), dtype.char)\n self.woVVo = self.saved.create_dataset('woVVo', (nocc,nvir,nvir,nocc), dtype.char)\n self.woOoV = self.saved.create_dataset('woOoV', (nocc,nocc,nocc,nvir), dtype.char)\n\n foo = eris.fock[:nocc,:nocc]\n fov = eris.fock[:nocc,nocc:]\n fvv = eris.fock[nocc:,nocc:]\n\n self.Fov = np.zeros((nocc,nvir), dtype=dtype)\n self.Foo = np.zeros((nocc,nocc), dtype=dtype)\n self.Fvv = np.zeros((nvir,nvir), dtype=dtype)\n\n #:eris_ovvv = lib.unpack_tril(np.asarray(eris.ovvv).reshape(nocc*nvir,nvir**2)).reshape(nocc,nvir,nvir,nvir)\n #:self.Fvv = np.einsum('mf,mfae->ae', t1, eris_ovvv) * 2\n #:self.Fvv -= np.einsum('mf,meaf->ae', t1, eris_ovvv)\n #:self.woVvO = lib.einsum('jf,mebf->mbej', t1, eris_ovvv)\n #:self.woVVo = lib.einsum('jf,mfbe->mbej',-t1, eris_ovvv)\n #:tau = _make_tau(t2, t1, t1)\n #:self.woVoO = 0.5 * lib.einsum('mebf,ijef->mbij', eris_ovvv, tau)\n #:self.woVoO += 0.5 * lib.einsum('mfbe,ijfe->mbij', eris_ovvv, tau)\n eris_ovoo = np.asarray(eris.ovoo)\n woVoO = np.empty((nocc,nvir,nocc,nocc), dtype=dtype)\n tau = _make_tau(t2, t1, t1)\n theta = t2*2 - t2.transpose(0,1,3,2)\n\n mem_now = lib.current_memory()[0]\n max_memory = max(0, self.max_memory - mem_now)\n blksize = min(nocc, max(ccsd.BLKMIN, int(max_memory*1e6/8/(nvir**3*3))))\n for seg, (p0,p1) in enumerate(lib.prange(0, nocc, blksize)):\n ovvv = eris.get_ovvv(slice(p0,p1)) # ovvv = eris.ovvv[p0:p1]\n # transform integrals (ia|bc) -> (ac|ib)\n fswap['ebmf/%d'%seg] = np.einsum('mebf->ebmf', ovvv)\n\n self.Fvv += np.einsum('mf,mfae->ae', t1[p0:p1], ovvv) * 2\n self.Fvv -= np.einsum('mf,meaf->ae', t1[p0:p1], ovvv)\n woVoO[p0:p1] = lib.einsum('mebf,ijef->mbij', ovvv, tau)\n woVvO = lib.einsum('jf,mebf->mbej', t1, ovvv)\n woVVo = lib.einsum('jf,mfbe->mbej',-t1, ovvv)\n ovvv = None\n\n eris_ovov = np.asarray(eris.ovov[p0:p1])\n woOoV = lib.einsum('if,mfne->mnie', t1, eris_ovov)\n woOoV+= eris_ovoo[:,:,p0:p1].transpose(2,0,3,1)\n self.woOoV[p0:p1] = woOoV\n woOoV = None\n\n tmp = lib.einsum('njbf,mfne->mbej', t2, eris_ovov)\n woVvO -= tmp * .5\n woVVo += tmp\n\n ovoo = lib.einsum('menf,jf->menj', eris_ovov, t1)\n woVvO -= lib.einsum('nb,menj->mbej', t1, ovoo)\n ovoo = lib.einsum('mfne,jf->menj', eris_ovov, t1)\n woVVo += lib.einsum('nb,menj->mbej', t1, ovoo)\n ovoo = None\n\n ovov = eris_ovov * 2 - eris_ovov.transpose(0,3,2,1)\n woVvO += lib.einsum('njfb,menf->mbej', theta, ovov) * .5\n\n self.Fov[p0:p1] = np.einsum('nf,menf->me', t1, ovov)\n tilab = np.einsum('ia,jb->ijab', t1[p0:p1], t1) * .5\n tilab += t2[p0:p1]\n self.Foo += lib.einsum('mief,menf->ni', tilab, ovov)\n self.Fvv -= lib.einsum('mnaf,menf->ae', tilab, ovov)\n eris_ovov = ovov = tilab = None\n\n woVvO -= lib.einsum('nb,menj->mbej', t1, eris_ovoo[p0:p1,:,:])\n woVVo += lib.einsum('nb,nemj->mbej', t1, eris_ovoo[:,:,p0:p1])\n\n woVvO += np.asarray(eris.ovvo[p0:p1]).transpose(0,2,1,3)\n woVVo -= np.asarray(eris.oovv[p0:p1]).transpose(0,2,3,1)\n\n self.woVvO[p0:p1] = woVvO\n self.woVVo[p0:p1] = woVVo\n\n self.Foo += foo + 0.5*np.einsum('me,ie->mi', self.Fov+fov, t1)\n self.Fvv += fvv - 0.5*np.einsum('me,ma->ae', self.Fov+fov, t1)\n\n # 0 or 1 virtuals\n woOoO = lib.einsum('je,nemi->mnij', t1, eris_ovoo)\n woOoO = woOoO + woOoO.transpose(1,0,3,2)\n woOoO += np.asarray(eris.oooo).transpose(0,2,1,3)\n\n tmp = lib.einsum('meni,jneb->mbji', eris_ovoo, t2)\n woVoO -= tmp.transpose(0,1,3,2) * .5\n woVoO -= tmp\n tmp = None\n ovoo = eris_ovoo*2 - eris_ovoo.transpose(2,1,0,3)\n woVoO += lib.einsum('nemi,njeb->mbij', ovoo, theta) * .5\n self.Foo += np.einsum('ne,nemi->mi', t1, ovoo)\n ovoo = None\n\n eris_ovov = np.asarray(eris.ovov)\n woOoO += lib.einsum('ijef,menf->mnij', tau, eris_ovov)\n self.woOoO = self.saved['woOoO'] = woOoO\n woVoO -= lib.einsum('nb,mnij->mbij', t1, woOoO)\n woOoO = None\n\n tmpoovv = lib.einsum('njbf,nemf->ejmb', t2, eris_ovov)\n ovov = eris_ovov*2 - eris_ovov.transpose(0,3,2,1)\n eris_ovov = None\n\n tmpovvo = lib.einsum('nifb,menf->eimb', theta, ovov)\n ovov = None\n\n tmpovvo *= -.5\n tmpovvo += tmpoovv * .5\n woVoO -= lib.einsum('ie,ejmb->mbij', t1, tmpovvo)\n woVoO -= lib.einsum('ie,ejmb->mbji', t1, tmpoovv)\n woVoO += eris_ovoo.transpose(3,1,2,0)\n\n # 3 or 4 virtuals\n eris_ovvo = np.asarray(eris.ovvo)\n tmpovvo -= eris_ovvo.transpose(1,3,0,2)\n fswap['ovvo'] = tmpovvo\n tmpovvo = None\n\n eris_oovv = np.asarray(eris.oovv)\n tmpoovv -= eris_oovv.transpose(3,1,0,2)\n fswap['oovv'] = tmpoovv\n tmpoovv = None\n\n woVoO += lib.einsum('mebj,ie->mbij', eris_ovvo, t1)\n woVoO += lib.einsum('mjbe,ie->mbji', eris_oovv, t1)\n woVoO += lib.einsum('me,ijeb->mbij', self.Fov, t2)\n self.woVoO = self.saved['woVoO'] = woVoO\n woVoO = eris_ovvo = eris_oovv = None\n\n #:theta = t2*2 - t2.transpose(0,1,3,2)\n #:eris_ovvv = lib.unpack_tril(np.asarray(eris.ovvv).reshape(nocc*nvir,nvir**2)).reshape(nocc,nvir,nvir,nvir)\n #:ovvv = eris_ovvv*2 - eris_ovvv.transpose(0,3,2,1)\n #:tmpab = lib.einsum('mebf,miaf->eiab', eris_ovvv, t2)\n #:tmpab = tmpab + tmpab.transpose(0,1,3,2) * .5\n #:tmpab-= lib.einsum('mfbe,mifa->eiba', ovvv, theta) * .5\n #:self.wvOvV += eris_ovvv.transpose(2,0,3,1).conj()\n #:self.wvOvV -= tmpab\n nsegs = len(fswap['ebmf'])\n def load_ebmf(slice):\n dat = [fswap['ebmf/%d'%i][slice] for i in range(nsegs)]\n return np.concatenate(dat, axis=2)\n\n mem_now = lib.current_memory()[0]\n max_memory = max(0, self.max_memory - mem_now)\n blksize = min(nocc, max(ccsd.BLKMIN, int(max_memory*1e6/8/(nocc*nvir**2*4))))\n for p0, p1 in lib.prange(0, nvir, blksize):\n #:wvOvV = lib.einsum('mebf,miaf->eiab', ovvv, t2)\n #:wvOvV += lib.einsum('mfbe,miaf->eiba', ovvv, t2)\n #:wvOvV -= lib.einsum('mfbe,mifa->eiba', ovvv, t2)*2\n #:wvOvV += lib.einsum('mebf,mifa->eiba', ovvv, t2)\n\n ebmf = load_ebmf(slice(p0, p1))\n wvOvV = lib.einsum('ebmf,miaf->eiab', ebmf, t2)\n wvOvV = -.5 * wvOvV.transpose(0,1,3,2) - wvOvV\n\n # Using the permutation symmetry (em|fb) = (em|bf)\n efmb = load_ebmf((slice(None), slice(p0, p1)))\n wvOvV += np.einsum('ebmf->bmfe', efmb.conj())\n\n # tmp = (mf|be) - (me|bf)*.5\n tmp = -.5 * ebmf\n tmp += efmb.transpose(1,0,2,3)\n ebmf = None\n wvOvV += lib.einsum('efmb,mifa->eiba', tmp, theta)\n tmp = None\n\n wvOvV += lib.einsum('meni,mnab->eiab', eris_ovoo[:,p0:p1], tau)\n wvOvV -= lib.einsum('me,miab->eiab', self.Fov[:,p0:p1], t2)\n wvOvV += lib.einsum('ma,eimb->eiab', t1, fswap['ovvo'][p0:p1])\n wvOvV += lib.einsum('ma,eimb->eiba', t1, fswap['oovv'][p0:p1])\n\n self.wvOvV[p0:p1] = wvOvV\n\n self.made_ee_imds = True\n log.timer('EOM-CCSD EE intermediates', *cput0)\n return self\n\ndef _make_tau(t2, t1, r1, fac=1, out=None):\n tau = np.einsum('ia,jb->ijab', t1, r1)\n tau = tau + tau.transpose(1,0,3,2)\n tau *= fac * .5\n tau += t2\n return tau\n\ndef _cp(a):\n return np.array(a, copy=False, order='C')\n\n\nif __name__ == '__main__':\n from pyscf import scf\n from pyscf import gto\n from pyscf.cc import rccsd\n\n mol = gto.Mole()\n mol.atom = [\n [8 , (0. , 0. , 0.)],\n [1 , (0. , -0.757 , 0.587)],\n [1 , (0. , 0.757 , 0.587)]]\n mol.basis = 'cc-pvdz'\n mol.verbose = 0\n mol.spin = 0\n mol.build()\n mf = scf.RHF(mol).run(conv_tol=1e-14)\n\n mycc = rccsd.RCCSD(mf)\n ecc, t1, t2 = mycc.kernel()\n print(ecc - -0.21334326214236796)\n\n myeom = EOMIP(mycc)\n print(\"IP energies... (right eigenvector)\")\n e,v = ipccsd(myeom, nroots=3)\n print(e[0] - 0.43356041409195489)\n print(e[1] - 0.51876598058509493)\n print(e[2] - 0.6782879569941862 )\n\n print(\"IP energies... (left eigenvector)\")\n le,lv = ipccsd(myeom, nroots=3,left=True)\n print(le[0] - 0.43356040428879794)\n print(le[1] - 0.51876597800180335)\n print(le[2] - 0.67828755013874864)\n\n e = myeom.ipccsd_star_contract(e, v, lv)\n print(e[0] - 0.43793202073189047)\n print(e[1] - 0.52287073446559729)\n print(e[2] - 0.67994597948852287)\n\n myeom = EOMEA(mycc)\n print(\"EA energies... (right eigenvector)\")\n e,v = eaccsd(myeom, nroots=3)\n print(e[0] - 0.16737886282063008)\n print(e[1] - 0.24027622989542635)\n print(e[2] - 0.51006796667905585)\n\n print(\"EA energies... (left eigenvector)\")\n le,lv = eaccsd(myeom, nroots=3, left=True)\n print(le[0] - 0.16737896537079733)\n print(le[1] - 0.24027634198123343)\n print(le[2] - 0.51006809015066612)\n\n e = myeom.eaccsd_star_contract(e,v,lv)\n print(e[0] - 0.16656250953550664)\n print(e[1] - 0.23944144521387614)\n print(e[2] - 0.41399436888830721)\n\n myeom = EOMEESpinFlip(mycc)\n np.random.seed(1)\n v = np.random.random(myeom.vector_size())\n r1, r2 = vector_to_amplitudes_eomsf(v, myeom.nmo, myeom.nocc)\n print(lib.finger(r1) - 0.017703197938757409)\n print(lib.finger(r2[0]) --21.605764517401415)\n print(lib.finger(r2[1]) - 6.5857056438834842)\n print(abs(amplitudes_to_vector_eomsf(r1, r2) - v).max())\n\n myeom = EOMEE(mycc)\n e,v = myeom.eeccsd(nroots=1)\n print(e - 0.2757159395886167)\n\n e,v = myeom.eeccsd(nroots=4)\n print(e[0] - 0.2757159395886167)\n print(e[1] - 0.2757159395886167)\n print(e[2] - 0.2757159395886167)\n print(e[3] - 0.3005716731825082)\n\n e,v = myeom.eeccsd(nroots=4, koopmans=True)\n print(e[0] - 0.2757159395886167)\n print(e[1] - 0.2757159395886167)\n print(e[2] - 0.2757159395886167)\n print(e[3] - 0.3005716731825082)\n\n e,v = myeom.eeccsd(nroots=4, guess=v[:4])\n print(e[0] - 0.2757159395886167)\n print(e[1] - 0.2757159395886167)\n print(e[2] - 0.2757159395886167)\n print(e[3] - 0.3005716731825082)\n\n\n mycc = ccsd.CCSD(mf)\n ecc, t1, t2 = mycc.kernel()\n print(ecc - -0.21334326214236796)\n\n myeom = EOMIP(mycc)\n print(\"IP energies... (right eigenvector)\")\n e,v = ipccsd(myeom, nroots=3)\n print(e[0] - 0.43356041409195489)\n print(e[1] - 0.51876598058509493)\n print(e[2] - 0.6782879569941862 )\n\n print(\"IP energies... (left eigenvector)\")\n le,lv = ipccsd(myeom, nroots=3,left=True)\n print(le[0] - 0.43356040428879794)\n print(le[1] - 0.51876597800180335)\n print(le[2] - 0.67828755013874864)\n\n e = myeom.ipccsd_star_contract(e, v, lv)\n print(e[0] - 0.43793202073189047)\n print(e[1] - 0.52287073446559729)\n print(e[2] - 0.67994597948852287)\n\n myeom = EOMEA(mycc)\n print(\"EA energies... (right eigenvector)\")\n e,v = eaccsd(myeom, nroots=3)\n print(e[0] - 0.16737886282063008)\n print(e[1] - 0.24027622989542635)\n print(e[2] - 0.51006796667905585)\n\n print(\"EA energies... (left eigenvector)\")\n le,lv = eaccsd(myeom, nroots=3, left=True)\n print(le[0] - 0.16737896537079733)\n print(le[1] - 0.24027634198123343)\n print(le[2] - 0.51006809015066612)\n\n e = myeom.eaccsd_star_contract(e,v,lv)\n print(e[0] - 0.16656250953550664)\n print(e[1] - 0.23944144521387614)\n print(e[2] - 0.41399436888830721)\n\n myeom = EOMEE(mycc)\n e,v = myeom.eeccsd(nroots=1)\n print(e - 0.2757159395886167)\n\n e,v = myeom.eeccsd(nroots=4)\n print(e[0] - 0.2757159395886167)\n print(e[1] - 0.2757159395886167)\n print(e[2] - 0.2757159395886167)\n print(e[3] - 0.3005716731825082)\n\n e,v = myeom.eeccsd(nroots=4, koopmans=True)\n print(e[0] - 0.2757159395886167)\n print(e[1] - 0.2757159395886167)\n print(e[2] - 0.2757159395886167)\n print(e[3] - 0.3005716731825082)\n\n e,v = myeom.eeccsd(nroots=4, guess=v[:4])\n print(e[0] - 0.2757159395886167)\n print(e[1] - 0.2757159395886167)\n print(e[2] - 0.2757159395886167)\n print(e[3] - 0.3005716731825082)\n", "meta": {"hexsha": "48e9b493f9b1b4cf9dabf6da422e040a92a41289", "size": 83813, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyscf/cc/eom_rccsd.py", "max_stars_repo_name": "QuESt-Calculator/pyscf", "max_stars_repo_head_hexsha": "0ed03633b699505c7278f1eb501342667d0aa910", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 501, "max_stars_repo_stars_event_min_datetime": "2018-12-06T23:48:17.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T11:53:18.000Z", "max_issues_repo_path": "pyscf/cc/eom_rccsd.py", "max_issues_repo_name": "QuESt-Calculator/pyscf", "max_issues_repo_head_hexsha": "0ed03633b699505c7278f1eb501342667d0aa910", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 710, "max_issues_repo_issues_event_min_datetime": "2018-11-26T22:04:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-30T03:53:12.000Z", "max_forks_repo_path": "pyscf/cc/eom_rccsd.py", "max_forks_repo_name": "QuESt-Calculator/pyscf", "max_forks_repo_head_hexsha": "0ed03633b699505c7278f1eb501342667d0aa910", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 273, "max_forks_repo_forks_event_min_datetime": "2018-11-26T10:10:24.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-30T12:25:28.000Z", "avg_line_length": 38.1314831665, "max_line_length": 116, "alphanum_fraction": 0.588775011, "include": true, "reason": "import numpy", "num_tokens": 31175, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5736784220301065, "lm_q2_score": 0.34510525748676846, "lm_q1q2_score": 0.19797943954930294}} {"text": "# Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.\n#\n# This work is licensed under the Creative Commons Attribution-NonCommercial\n# 4.0 International License. To view a copy of this license, visit\n# http://creativecommons.org/licenses/by-nc/4.0/ or send a letter to\n# Creative Commons, PO Box 1866, Mountain View, CA 94042, USA.\n\nimport numpy as np\nimport tensorflow as tf\n\nimport tfutil\n\n#----------------------------------------------------------------------------\n# Convenience func that casts all of its arguments to tf.float32.\n\ndef fp32(*values):\n if len(values) == 1 and isinstance(values[0], tuple):\n values = values[0]\n values = tuple(tf.cast(v, tf.float32) for v in values)\n return values if len(values) >= 2 else values[0]\n\n#----------------------------------------------------------------------------\n# Generator loss function used in the paper (WGAN + AC-GAN).\n\ndef G_wgan_acgan(G, D, opt, training_set, minibatch_size, unlabeled_reals,\n cond_weight = 0.0): # Weight of the conditioning term.\n '''\n Calculating the feature matching loss for the generator\n '''\n # get generated samples\n latents = tf.random_normal([minibatch_size] + G.input_shapes[0][1:])\n # get random labels for the generated samples\n rand_gen_labels = training_set.get_random_labels_tf(minibatch_size)\n # use the generator to deconvolve the latents into images\n fake_images_out = G.get_output_for(latents, rand_gen_labels, is_training=True)\n\n # use the discriminator to get the features from the last convolution layer as well as the logits\n fake_logits_out, _, fake_features_out = fp32(D.get_output_for(fake_images_out, is_training=False))\n # Pass the unlabeled real data to the discriminator and grab the real features out from the last convolutional layer\n _, _, real_features_out = fp32(D.get_output_for(unlabeled_reals, is_training=False))\n\n # calculate feature-matching loss\n # mean squared error of fake and real features\n feat_diff = tf.math.reduce_mean(fake_features_out, axis=0) - tf.math.reduce_mean(real_features_out, axis=0)\n loss = tf.math.reduce_mean(tf.math.square(feat_diff))\n\n loss = tfutil.autosummary('Loss/G_feat_match_loss', loss)\n\n # if D.output_shapes[1][1] > 0:\n # with tf.name_scope('LabelPenalty'):\n # # pass fake logits and labels to a softmax layer\n # label_penalty_fakes = tf.nn.softmax_cross_entropy_with_logits_v2(labels=rand_gen_labels, logits=fake_logits_out)\n # loss += label_penalty_fakes * cond_weight\n # loss = tfutil.autosummary('Loss/G_feat_match_loss_post_LabelPenalty', loss)\n return loss\n\n\ndef G_pggan_loss(G, D, opt, training_set, minibatch_size,\n cond_weight = 1.0): # Weight of the conditioning term.\n\n latents = tf.random_normal([minibatch_size] + G.input_shapes[0][1:])\n labels = training_set.get_random_labels_tf(minibatch_size)\n fake_images_out = G.get_output_for(latents, labels, is_training=True)\n fake_labels_out, fake_scores_out, _ = fp32(D.get_output_for(fake_images_out, is_training=True))\n loss = -fake_scores_out\n\n return loss\n\n#----------------------------------------------------------------------------\n# Discriminator loss function used in the paper (WGAN-GP + AC-GAN).\n\ndef D_wgangp_acgan(G, D, opt, training_set, minibatch_size, reals, labels, unlabeled_reals,\n wgan_lambda = 0.0, # Weight for the gradient penalty term.\n wgan_epsilon = 0.0, # Weight for the epsilon term, \\epsilon_{drift}.\n wgan_target = 0.1, # Target value for gradient magnitudes.\n cond_weight = 0.0): # Weight of the conditioning terms.\n\n # Generate latents and pass through the generator to decolvolve into fake images\n latents = tf.random_normal([minibatch_size] + G.input_shapes[0][1:])\n fake_images_out = G.get_output_for(latents, labels, is_training=True)\n\n # REALS\n output_before_softmax_lab, real_flogit_out, _ = fp32(D.get_output_for(reals, is_training=True))\n # UNLABELED REALS\n output_before_softmax_unl, _, _ = fp32(D.get_output_for(unlabeled_reals, is_training=True))\n # GENERATED\n output_before_softmax_fake, fake_flogit_out, _ = fp32(D.get_output_for(fake_images_out, is_training=True))\n\n # Direct port labeled loss from Tim Salimans et al. https://arxiv.org/pdf/1606.03498.pdf\n # no support for tensor indexing, so no work\n #simple_labels = tf.argmax(labels, axis=1)\n #z_exp_lab = tf.math.reduce_mean(tf.math.reduce_logsumexp(output_before_softmax_lab, axis=1))\n #l_lab = output_before_softmax_lab[tf.range(minibatch_size), simple_labels]\n #loss_lab = -tf.math.reduce_mean(l_lab) + tf.math.reduce_mean(z_exp_lab)\n\n train_err = tf.math.reduce_mean(tf.cast(tf.math.not_equal(tf.math.argmax(output_before_softmax_lab, axis=1),\n tf.math.argmax(labels, axis=1)), tf.float32))\n train_err = tfutil.autosummary('Loss/D_train_err', train_err)\n\n # labeled sample loss is equivalent to cross entropy w/ softmax (I think?)\n loss_lab = tf.math.reduce_sum(tf.nn.softmax_cross_entropy_with_logits_v2(labels=labels, logits=output_before_softmax_lab))\n\n # Another implementation of Salimans code ported to TF (NOT WORKING the tf.gather is wrong)\n #l_lab = tf.gather(output_before_softmax_lab, tf.range(minibatch_size),labels)\n #loss_lab = -tf.math.reduce_sum(l_lab) + tf.math.reduce_sum(tf.math.reduce_sum(tf.math.reduce_logsumexp(output_before_softmax_lab)))\n\n # Direct port of unlabeled loss and fake loss. from Tim Salimans et al. https://arxiv.org/pdf/1606.03498.pdf\n # Code reference https://github.com/openai/improved-gan/blob/master/mnist_svhn_cifar10/train_cifar_feature_matching.py#L87\n #z_exp_unl = tf.math.reduce_mean(tf.math.reduce_logsumexp(output_before_softmax_unl, axis=1))\n loss_unl = -0.5*tf.math.reduce_mean(tf.math.reduce_logsumexp(output_before_softmax_unl, axis=1)) + \\\n 0.5*tf.math.reduce_mean(tf.math.softplus(tf.math.reduce_logsumexp(output_before_softmax_unl, axis=1)))\n loss_fake = 0.5*tf.math.reduce_mean(tf.math.softplus(tf.math.reduce_logsumexp(output_before_softmax_fake, axis=1)))\n\n # Using autosummary for tensorboard\n loss_lab = tfutil.autosummary('Loss/D_loss_lab', loss_lab)\n loss_unl = tfutil.autosummary('Loss/D_loss_unl', loss_unl)\n loss_fake = tfutil.autosummary('Loss/D_loss_fake', loss_fake)\n\n # combine losses\n loss = loss_lab + loss_unl + loss_fake + (train_err*0)\n\n loss = tfutil.autosummary('Loss/D_combined_loss', loss)\n\n # with tf.name_scope('GradientPenalty'):\n # mixing_factors = tf.random_uniform([minibatch_size, 1, 1, 1], 0.0, 1.0, dtype=fake_images_out.dtype)\n # mixed_images_out = tfutil.lerp(tf.cast(reals, fake_images_out.dtype), fake_images_out, mixing_factors)\n # mixed_scores_out, mixed_labels_out, _ = fp32(D.get_output_for(mixed_images_out, is_training=True))\n # mixed_scores_out = tfutil.autosummary('Loss/mixed_scores', mixed_scores_out)\n # mixed_loss = opt.apply_loss_scaling(tf.reduce_sum(mixed_scores_out))\n # mixed_grads = opt.undo_loss_scaling(fp32(tf.gradients(mixed_loss, [mixed_images_out])[0]))\n # mixed_norms = tf.sqrt(tf.reduce_sum(tf.square(mixed_grads), axis=[1,2,3]))\n # mixed_norms = tfutil.autosummary('Loss/mixed_norms', mixed_norms)\n # gradient_penalty = tf.square(mixed_norms - wgan_target)\n # loss += gradient_penalty * (wgan_lambda / (wgan_target**2))\n\n # with tf.name_scope('EpsilonPenalty'):\n # epsilon_penalty = tfutil.autosummary('Loss/epsilon_penalty', tf.square(real_flogit_out))\n # loss += epsilon_penalty * wgan_epsilon\n\n # if D.output_shapes[1][1] > 0:\n # with tf.name_scope('LabelPenalty'):\n # label_penalty_reals = tf.nn.softmax_cross_entropy_with_logits_v2(labels=labels, logits=output_before_softmax_lab)\n # label_penalty_fakes = tf.nn.softmax_cross_entropy_with_logits_v2(labels=labels, logits=output_before_softmax_fake)\n # label_penalty_reals = tfutil.autosummary('Loss/label_penalty_reals', label_penalty_reals)\n # label_penalty_fakes = tfutil.autosummary('Loss/label_penalty_fakes', label_penalty_fakes)\n # loss += (label_penalty_reals + label_penalty_fakes) * cond_weight\n\n # loss = tfutil.autosummary('Loss/D_combined_loss_post_penalties', loss)\n return loss\n\n\ndef D_pggan_loss(G, D, opt, training_set, minibatch_size, unlabeled_reals,\n wgan_lambda = 10.0, # Weight for the gradient penalty term.\n wgan_epsilon = 0.001, # Weight for the epsilon term, \\epsilon_{drift}.\n wgan_target = 1.0, # Target value for gradient magnitudes.\n cond_weight = 1.0): # Weight of the conditioning terms.\n\n latents = tf.random_normal([minibatch_size] + G.input_shapes[0][1:])\n labels = training_set.get_random_labels_tf(minibatch_size)\n fake_images_out = G.get_output_for(latents, labels, is_training=True)\n real_labels_out, real_scores_out, _ = fp32(D.get_output_for(unlabeled_reals, is_training=True))\n fake_labels_out, fake_scores_out, _ = fp32(D.get_output_for(fake_images_out, is_training=True))\n real_scores_out = tfutil.autosummary('Loss/D_pggan_real_scores', real_scores_out)\n fake_scores_out = tfutil.autosummary('Loss/D_pggan_fake_scores', fake_scores_out)\n loss = fake_scores_out - real_scores_out\n\n with tf.name_scope('GradientPenalty'):\n mixing_factors = tf.random_uniform([minibatch_size, 1, 1, 1], 0.0, 1.0, dtype=fake_images_out.dtype)\n mixed_images_out = tfutil.lerp(tf.cast(unlabeled_reals, fake_images_out.dtype), fake_images_out, mixing_factors)\n mixed_labels_out, mixed_scores_out, _ = fp32(D.get_output_for(mixed_images_out, is_training=True))\n mixed_scores_out = tfutil.autosummary('Loss/D_pggan_mixed_scores', mixed_scores_out)\n mixed_loss = opt.apply_loss_scaling(tf.reduce_sum(mixed_scores_out))\n mixed_grads = opt.undo_loss_scaling(fp32(tf.gradients(mixed_loss, [mixed_images_out])[0]))\n mixed_norms = tf.sqrt(tf.reduce_sum(tf.square(mixed_grads), axis=[1,2,3]))\n mixed_norms = tfutil.autosummary('Loss/D_pggan_mixed_norms', mixed_norms)\n gradient_penalty = tf.square(mixed_norms - wgan_target)\n loss += gradient_penalty * (wgan_lambda / (wgan_target**2))\n\n with tf.name_scope('EpsilonPenalty'):\n epsilon_penalty = tfutil.autosummary('Loss/D_pggan_epsilon_penalty', tf.square(real_scores_out))\n loss += epsilon_penalty * wgan_epsilon\n return loss\n\n#----------------------------------------------------------------------------\n\n\n", "meta": {"hexsha": "f1be11ab85c110747b3af97d2b0f18fdd0bc8514", "size": 10631, "ext": "py", "lang": "Python", "max_stars_repo_path": "loss.py", "max_stars_repo_name": "ACK-J/SSL-PG-GAN", "max_stars_repo_head_hexsha": "95287db6dda3340acf2417a026c030fea506957e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "loss.py", "max_issues_repo_name": "ACK-J/SSL-PG-GAN", "max_issues_repo_head_hexsha": "95287db6dda3340acf2417a026c030fea506957e", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "loss.py", "max_forks_repo_name": "ACK-J/SSL-PG-GAN", "max_forks_repo_head_hexsha": "95287db6dda3340acf2417a026c030fea506957e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-07-09T04:19:54.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-09T04:19:54.000Z", "avg_line_length": 56.8502673797, "max_line_length": 136, "alphanum_fraction": 0.7127269307, "include": true, "reason": "import numpy", "num_tokens": 2710, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5736783928749127, "lm_q2_score": 0.34510526422232046, "lm_q1q2_score": 0.19797943335173293}} {"text": "#! /usr/bin/python3\n# -*- coding: utf-8 -*-\n\n\n\"\"\"\n TO DO:\n map to healpix grid\n\"\"\"\n\n\n__author__ = 'Alan Loh, Julien Girard'\n__copyright__ = 'Copyright 2019, nenupytv'\n__credits__ = ['Alan Loh', 'Julien Girard']\n__maintainer__ = 'Alan'\n__email__ = 'alan.loh@obspm.fr'\n__status__ = 'Production'\n__all__ = [\n 'Grid',\n 'Grid_Simple',\n 'Grid_HPX'\n ]\n\n\n# import healpy as hp\nimport numpy as np\nimport astropy.units as un\n\nfrom nenupytv.image import AAFilter\n\n\n# ============================================================= #\n# ---------------------------- Grid --------------------------- #\n# ============================================================= #\nclass Grid(object):\n \"\"\" Gridding class\n\n :param vis: Visibilities\n :type vis: `~np.ndarray`\n :param uvw: UVW coordinates\n :type uvw: `~np.ndarray`\n :param fov: Field of view radius in degrees\n :type fov: float\n :param freq: Observing frequency\n :type freq: float\n :param filter: Convolution filter to apply\n :type filter: `~nenupytv.image.AAFilter`\n :param cellsize: Cell size in degrees\n :type cellsize: float\n \"\"\"\n\n def __init__(\n self,\n vis,\n uvw,\n freq,\n fov,\n conv_filter=AAFilter(),\n cellsize=None,\n robust=0.\n ):\n self.nsize = None\n self.fov = fov\n self.vis = vis\n self.uvw = uvw\n self.freq = freq\n self.filter = conv_filter\n self.cellsize = cellsize\n self.robust = robust\n\n\n # --------------------------------------------------------- #\n # --------------------- Getter/Setter --------------------- #\n @property\n def _ovsmpl(self):\n \"\"\" Filter oversampling\n \"\"\"\n return self.filter.oversample\n\n\n @property\n def _hsup(self):\n \"\"\" Filter Half_sup\n \"\"\"\n return self.filter.half_sup\n\n\n @property\n def _filter_idx(self):\n \"\"\" Filter indices\n \"\"\"\n return np.arange(-self._hsup, self._hsup + 1)\n\n\n @property\n def _ftaps(self):\n \"\"\"\n \"\"\"\n return self.filter.filter_taps\n\n\n @property\n def vis(self):\n return self._vis\n @vis.setter\n def vis(self, v):\n x, y = np.tril_indices(v.shape[0], 0)\n xx = np.hstack((x[x!=y], y[x!=y]))\n yy = np.hstack((y[x!=y], x[x!=y]))\n self._vis = v[xx, yy, ...] + v[yy, xx, ...].conj()\n return\n\n\n @property\n def uvw(self):\n return self._uvw\n @uvw.setter\n def uvw(self, u):\n x, y = np.tril_indices(u.shape[0], 0)\n xx = np.hstack((x[x!=y], y[x!=y]))\n yy = np.hstack((y[x!=y], x[x!=y]))\n self._uvw = u[xx, yy, ...]\n\n maxu = np.max(np.abs(self._uvw[..., 0]))\n maxv = np.max(np.abs(self._uvw[..., 1]))\n self.resol = 1. / (5 * 2 * np.max((maxu, maxv))) * un.rad\n # self.resol = 1. / (10 * 2 * np.max((maxu, maxv))) * un.rad\n resol = self.resol.to(un.deg).value\n self.nsize = int(np.round(self.fov / resol))\n return\n\n\n @property\n def nsize(self):\n return self._nsize\n @nsize.setter\n def nsize(self, n):\n if n is None:\n self._nsize = None\n else:\n self._nsize = n\n self.measurement = np.zeros(\n (self.vis.shape[1], self.nsize, self.nsize),\n dtype='complex64'\n )\n self._meas_w = np.zeros(\n (self.nsize, self.nsize),\n dtype='float'\n )\n # for deconvolution the PSF should be 2x size of the image (see \n # Hogbom CLEAN for details), one grid for the sampling function:\n self.sampling = np.zeros(\n (2*self.nsize, 2*self.nsize),\n dtype='complex64'\n )\n self._samp_w = np.zeros(\n (2*self.nsize, 2*self.nsize),\n dtype='float'\n )\n\n\n # --------------------------------------------------------- #\n # ------------------------ Methods ------------------------ #\n def populate(self):\n \"\"\"\n \"\"\"\n # if self.uvw.shape[0] != 1:\n # raise ValueError(\n # 'UVW need to be averaged in time'\n # )\n # if self.uvw.shape[1] != 1:\n # raise ValueError(\n # 'UVW need to be averaged in frequency'\n # )\n # iter over number of baselines in the triangular inferior\n # matrix (i.e. not autocorr), divided by 3 because (u, v, w)\n for vis_bl in range(int(self.uvw.size / 3)):\n u = self.uvw[vis_bl, 0] * np.radians(self.fov)\n v = self.uvw[vis_bl, 1] * np.radians(self.fov)\n\n if np.ma.is_masked(u) or np.ma.is_masked(v):\n continue\n\n du = int(np.round(u))\n dv = int(np.round(v))\n fu_offset = int(\n (1 + self._hsup + (-u + du)) * self._ovsmpl\n )\n fv_offset = int(\n (1 + self._hsup + (-v + dv)) * self._ovsmpl\n )\n\n du_psf = int(np.round(u*2))\n dv_psf = int(np.round(v*2))\n fu_offset_psf = int(\n (1 + self._hsup + (-u*2 + du_psf)) * self._ovsmpl\n )\n fv_offset_psf = int(\n (1 + self._hsup + (-v*2 + dv_psf)) * self._ovsmpl\n )\n\n if (dv + self.nsize // 2 + self._hsup >= self.nsize or\n du + self.nsize // 2 + self._hsup >= self.nsize or\n dv + self.nsize // 2 - self._hsup < 0 or\n du + self.nsize // 2 - self._hsup < 0):\n continue\n\n for conv_v in self._filter_idx:\n v_tap = self._ftaps[conv_v * self._ovsmpl + fv_offset]\n v_tap_psf = self._ftaps[conv_v * self._ovsmpl + fv_offset_psf]\n\n grid_v = dv + conv_v + self.nsize // 2\n grid_v_psf = dv_psf + conv_v + self.nsize\n \n for conv_u in self._filter_idx:\n u_tap = self._ftaps[conv_u * self._ovsmpl + fu_offset]\n u_tap_psf = self._ftaps[conv_u * self._ovsmpl + fu_offset_psf]\n \n grid_u = du + conv_u + self.nsize // 2\n grid_u_psf = du_psf + conv_u + self.nsize\n\n conv_weight = v_tap * u_tap\n conv_weight_psf = v_tap_psf * u_tap_psf\n \n # for p in range(self.vis.shape[3]):\n # self.measurement[p, grid_v, grid_u] += self.vis[0, 0, vis_bl, p] * conv_weight\n for p in range(self.vis.shape[1]):\n self.measurement[p, grid_v, grid_u] += self.vis[vis_bl, p] * conv_weight\n # self._meas_w[grid_v, grid_u] += 1\n self._meas_w[grid_v, grid_u] += 1. * conv_weight\n # assuming the PSF is the same for different correlations:\n self.sampling[grid_v_psf, grid_u_psf] += (1+0.0j) * conv_weight_psf\n # self._samp_w[grid_v_psf, grid_u_psf] += 1\n self._samp_w[grid_v_psf, grid_u_psf] += 1. * conv_weight_psf\n\n self._compute_weights()\n return\n\n # --------------------------------------------------------- #\n # ----------------------- Internal ------------------------ #\n def _compute_weights(self):\n \"\"\"\n \"\"\"\n # nbsl = self.uvw.size / 3\n # bsl_time = (2.*nbsl*1) # one time step\n # num = (5.*10.**(-self.robust))**2.*bsl_time\n # meas_f = num/np.sum(self._meas_w**2.)\n # samp_f = num/np.sum(self._samp_w**2.)\n\n # self.meas_weighted = self._meas_w / (1 + self._meas_w * meas_f)\n # self.samp_weighted = self._samp_w / (1 + self._samp_w * samp_f)\n\n factor = (5. * 10.**(-self.robust) )**2\n f = factor / (np.sum(self._meas_w**2.) / np.sum(self._meas_w))\n self.meas_weights = self._meas_w / (1 + self._meas_w * f)\n self.meas_weights /= self.meas_weights.max()\n\n f = factor / (np.sum(self._samp_w**2.) / np.sum(self._samp_w))\n self.samp_weights = self._samp_w / (1 + self._samp_w * f)\n self.samp_weights /= self.samp_weights.max()\n return\n# ============================================================= #\n\n\n\n# ============================================================= #\n# ---------------------------- Grid --------------------------- #\n# ============================================================= #\nclass Grid_Simple(object):\n \"\"\"\n \"\"\"\n\n def __init__(\n self,\n vis,\n uvw,\n freq,\n fov,\n cellsize=None,\n robust=0.,\n convolution=None\n ):\n self.nsize = None\n self.fov = fov\n self.vis = vis\n self.uvw = uvw\n self.freq = freq\n self.cellsize = cellsize\n self.robust = robust\n self.convolution = convolution\n\n\n # --------------------------------------------------------- #\n # --------------------- Getter/Setter --------------------- #\n @property\n def vis(self):\n return self._vis\n @vis.setter\n def vis(self, v):\n x, y = np.tril_indices(v.shape[0], 0)\n xx = np.hstack((x[x!=y], y[x!=y]))\n yy = np.hstack((y[x!=y], x[x!=y]))\n self._vis = v[xx, yy, ...] + v[yy, xx, ...].conj()\n return\n\n\n @property\n def uvw(self):\n return self._uvw\n @uvw.setter\n def uvw(self, u):\n x, y = np.tril_indices(u.shape[0], 0)\n xx = np.hstack((x[x!=y], y[x!=y]))\n yy = np.hstack((y[x!=y], x[x!=y]))\n self._uvw = u[xx, yy, ...]\n\n maxu = np.max(np.abs(self._uvw[..., 0]))\n maxv = np.max(np.abs(self._uvw[..., 1]))\n self.resol = 1. / (5 * 2 * np.max((maxu, maxv))) * un.rad\n resol = self.resol.to(un.deg).value\n self.nsize = int(np.round(self.fov / resol))\n return\n\n\n @property\n def nsize(self):\n return self._nsize\n @nsize.setter\n def nsize(self, n):\n if n is None:\n self._nsize = None\n else:\n self._nsize = n\n self.measurement = np.zeros(\n (self.vis.shape[1], self.nsize, self.nsize),\n dtype='complex64'\n )\n self._meas_w = np.zeros(\n (self.nsize, self.nsize),\n dtype='float'\n )\n # for deconvolution the PSF should be 2x size of the image (see \n # Hogbom CLEAN for details), one grid for the sampling function:\n self.sampling = np.zeros(\n (2*self.nsize, 2*self.nsize),\n dtype='complex64'\n )\n self._samp_w = np.zeros(\n (2*self.nsize, 2*self.nsize),\n dtype='float'\n )\n\n\n # --------------------------------------------------------- #\n # ------------------------ Methods ------------------------ #\n def populate(self):\n \"\"\"\n \"\"\"\n for vis_bl in range(int(self.uvw.size / 3)):\n u = self.uvw[vis_bl, 0] * np.radians(self.fov)\n v = self.uvw[vis_bl, 1] * np.radians(self.fov)\n\n if np.ma.is_masked(u) or np.ma.is_masked(v):\n continue\n\n du = int(np.round(u)) + self.nsize // 2\n dv = int(np.round(v)) + self.nsize // 2\n du_psf = int(np.round(u*2)) + self.nsize\n dv_psf = int(np.round(v*2)) + self.nsize\n \n for p in range(self.vis.shape[1]):\n self.measurement[p, dv, du] += self.vis[vis_bl, p]\n self._meas_w[dv, du] += 1.\n # assuming the PSF is the same for different correlations:\n self.sampling[dv_psf, du_psf] += (1+0.0j)\n self._samp_w[dv_psf, du_psf] += 1.\n\n self._convolve()\n\n self._compute_weights()\n return\n\n\n # --------------------------------------------------------- #\n # ----------------------- Internal ------------------------ #\n def _compute_weights(self):\n \"\"\"\n \"\"\"\n factor = (5. * 10.**(-self.robust) )**2\n f = factor / (np.sum(self._meas_w**2.) / np.sum(self._meas_w))\n self.meas_weights = self._meas_w / (1 + self._meas_w * f)\n self.meas_weights /= self.meas_weights.max()\n\n f = factor / (np.sum(self._samp_w**2.) / np.sum(self._samp_w))\n self.samp_weights = self._samp_w / (1 + self._samp_w * f)\n self.samp_weights /= self.samp_weights.max()\n return\n\n\n def _convolve(self):\n \"\"\"\n \"\"\"\n if self.convolution is None:\n return\n elif self.convolution.lower() == 'gaussian':\n from scipy.ndimage import gaussian_filter\n def _scipy_gauss(im, sig=0.25):\n if im.dtype == np.complex64:\n im_re = gaussian_filter(\n input=im.real,\n sigma=sig,\n order=0,\n output=None,\n mode='reflect',\n cval=0.0,\n truncate=4.0\n )\n im_im = gaussian_filter(\n input=im.imag,\n sigma=sig,\n order=0,\n output=None,\n mode='reflect',\n cval=0.0,\n truncate=4.0\n )\n return im_re + 1.j*im_im\n else:\n return gaussian_filter(\n input=im,\n sigma=sig,\n order=0,\n output=None,\n mode='reflect',\n cval=0.0,\n truncate=4.0\n )\n for p in range(self.measurement.shape[0]):\n self.measurement[p, ...] = _scipy_gauss(self.measurement[p, ...])\n self.sampling = _scipy_gauss(self.sampling)\n self._meas_w = _scipy_gauss(self._meas_w)\n self._samp_w = _scipy_gauss(self._samp_w)\n else:\n raise Exception(\n 'Convolution kernel {} not implemented.'.format(self.convolution)\n )\n# ============================================================= #\n\n\n\n# ============================================================= #\n# -------------------------- Grid_HPX ------------------------- #\n# ============================================================= #\nclass Grid_HPX(object):\n \"\"\"\n \"\"\"\n\n def __init__(self, resolution):\n self.nside = None\n self.resol = resolution\n self.ra, self.dec = self._hpx_radec()\n\n\n # --------------------------------------------------------- #\n # --------------------- Getter/Setter --------------------- #\n @property\n def resol(self):\n \"\"\" Resolution of the cell in degrees\n \"\"\"\n return self._resol\n @resol.setter\n def resol(self, r):\n nsides = 2**np.arange(1, 12)\n resol_rad = hp.nside2resol(\n nside=nsides,\n arcmin=False\n )\n resol_deg = np.degrees(resol_rad)\n idx = (np.abs(resol_deg - r)).argmin()\n self._resol = resol_deg[idx]\n self.nside = nsides[idx]\n return\n\n\n @property\n def nside(self):\n return self._nside\n @nside.setter\n def nside(self, n):\n if n is None:\n self._nside = None\n else:\n self.npix = hp.nside2npix(n)\n self._nside = n\n return\n\n\n # --------------------------------------------------------- #\n # ------------------------ Methods ------------------------ #\n\n\n # --------------------------------------------------------- #\n # ----------------------- Internal ------------------------ #\n def _hpx_radec(self):\n \"\"\"\n \"\"\"\n ra, dec = hp.pix2ang(\n nside=self.nside,\n ipix=np.arange(self.npix),\n lonlat=True,\n nest=False\n )\n return ra, dec\n\n# ============================================================= #\n\n\n\n\n# class ImgWPlus(aipy.img.ImgW):\n# \"\"\"\n# Sub-class of the aipy.img.ImgW class that adds support for different \n# visibility weighting scheme and uv plane tapering. This class also\n# adds in a couple of additional methods that help determine the size of\n# the field of view and the pixels near the phase center.\n# \"\"\"\n# def __init__(self, size=100, res=1, wres=.5, mf_order=0):\n# \"\"\"size = number of wavelengths which the UV matrix spans (this \n# determines the image resolution).\n# res = resolution of the UV matrix (determines image field of view).\n# wres: the gridding resolution of sqrt(w) when projecting to w=0.\"\"\"\n# self.res = float(res)\n# self.size = float(size)\n# ## Small change needed to work with Numpy 1.12+\n# dim = numpy.int64(numpy.round(self.size / self.res))\n# self.shape = (dim,dim)\n# self.uv = numpy.zeros(shape=self.shape, dtype=numpy.complex64)\n# self.bm = []\n# for i in range(mf_order+1):\n# self.bm.append(numpy.zeros(shape=self.shape, dtype=numpy.complex64))\n# self.wres = float(wres)\n# self.wcache = {}\n# def put(self, uvw, data, wgts=None, invker2=None):\n# \"\"\"Same as Img.put, only now the w component is projected to the w=0\n# plane before applying the data to the UV matrix.\"\"\"\n# u, v, w = uvw\n# if len(u) == 0: return\n# if wgts is None:\n# wgts = []\n# for i in range(len(self.bm)):\n# if i == 0:\n# wgts.append(numpy.ones_like(data))\n# else:\n# wgts.append(numpy.zeros_like(data))\n# if len(self.bm) == 1 and len(wgts) != 1:\n# wgts = [wgts]\n# assert(len(wgts) == len(self.bm))\n# # Sort uvw in order of w\n# order = numpy.argsort(w)\n# u = u.take(order)\n# v = v.take(order)\n# w = w.take(order)\n# data = data.take(order)\n# wgts = [wgt.take(order) for wgt in wgts]\n# sqrt_w = numpy.sqrt(numpy.abs(w)) * numpy.sign(w)\n# i = 0\n# while True:\n# # Grab a chunk of uvw's that grid w to same point.\n# j = sqrt_w.searchsorted(sqrt_w[i]+self.wres)\n# print('%d/%d datums' % (j, len(w)))\n# avg_w = numpy.average(w[i:j])\n# # Put all uv's down on plane for this gridded w point\n# wgtsij = [wgt[i:j] for wgt in wgts]\n# uv,bm = aipy.img.Img.put(self, (u[i:j],v[i:j],w[i:j]),\n# data[i:j], wgtsij, apply=False)\n# # Convolve with the W projection kernel\n# invker = numpy.fromfunction(lambda u,v: self.conv_invker(u,v,avg_w),\n# uv.shape)\n# if not invker2 is None:\n# invker *= invker2\n# self.uv += ifft2Function(fft2Function(uv) * invker)\n# #self.uv += uv\n# for b in range(len(self.bm)):\n# self.bm[b] += ifft2Function(fft2Function(bm[b]) * invker)\n# #self.bm[b] += numpy.array(bm)[0,:,:]\n# if j >= len(w):\n# break\n# i = j\n", "meta": {"hexsha": "67e1e005fb8488423fc16e3eb51d6e0a89115edf", "size": 19435, "ext": "py", "lang": "Python", "max_stars_repo_path": "nenupytv/image/grid.py", "max_stars_repo_name": "AlanLoh/nenupy-tv", "max_stars_repo_head_hexsha": "9c33652521293eaba726f02fdb2331ae32dda6f6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "nenupytv/image/grid.py", "max_issues_repo_name": "AlanLoh/nenupy-tv", "max_issues_repo_head_hexsha": "9c33652521293eaba726f02fdb2331ae32dda6f6", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 14, "max_issues_repo_issues_event_min_datetime": "2019-11-12T09:48:00.000Z", "max_issues_repo_issues_event_max_datetime": "2020-02-28T17:02:54.000Z", "max_forks_repo_path": "nenupytv/image/grid.py", "max_forks_repo_name": "AlanLoh/nenupy-tv", "max_forks_repo_head_hexsha": "9c33652521293eaba726f02fdb2331ae32dda6f6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-09-09T17:40:58.000Z", "max_forks_repo_forks_event_max_datetime": "2020-09-09T17:40:58.000Z", "avg_line_length": 33.0527210884, "max_line_length": 104, "alphanum_fraction": 0.4442500643, "include": true, "reason": "import numpy,from scipy,import astropy", "num_tokens": 4888, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5736783928749127, "lm_q2_score": 0.3451052642223204, "lm_q1q2_score": 0.1979794333517329}} {"text": "#!/usr/bin/env python3\nimport sys\nimport time\nimport numpy.linalg\nimport numpy.random\nimport random\n\n\nVK_SPREAD = [\n [-24, 58.0], [-23, 36.0], [-22, 20.0], [-21, 17.0],\n [-20, 16.0], [-19, 19.0], [-18, 24.0], [-17, 36.0],\n [-16, 45.0], [-15, 55.0], [-14, 60.0], [-13, 70.0],\n [-12, 75.0], [-11, 79.0], [-10, 83.0], [-9, 87.0],\n [-8, 92.0], [-7, 96.0], [-6, 100.0], [-5, 105.0],\n [-4, 108.0], [-3, 105.0], [-2, 96.0], [-1, 80.0],\n [0, 58.0], [1, 36.0], [2, 20.0], [3, 17.0],\n [4, 16.0], [5, 19.0], [6, 24.0], [7, 36.0],\n [8, 45.0], [9, 55.0], [10, 60.0], [11, 70.0],\n [12, 75.0], [13, 79.0], [14, 83.0], [15, 87.0],\n [16, 92.0], [17, 96.0], [18, 100.0], [19, 105.0],\n [20, 108.0], [21, 105.0], [22, 96.0], [23, 80.0],\n [24, 58.0], [25, 36.0], [26, 20.0], [27, 17.0],\n [28, 16.0], [29, 19.0], [30, 24.0], [31, 36.0],\n [32, 45.0], [33, 55.0], [34, 60.0], [35, 70.0],\n [36, 75.0], [37, 79.0], [38, 83.0], [39, 87.0],\n [40, 92.0], [41, 96.0], [42, 100.0], [43, 105.0],\n [44, 108.0], [45, 105.0], [46, 96.0], [47, 80.0],\n [48, 58.0],\n]\n\n\ndef WR_params(date, f=1):\n \"\"\"\n Generates params for WeightRandom class\n \"\"\"\n tm = time.localtime(date)\n date = (tm.tm_hour * 60 + tm.tm_min) * 60 + tm.tm_sec\n return [\n [date, 0.0],\n [date + (3600 + 600) / f, 3200],\n [date + (2 * 3600) / f, 1850]\n ]\n\n\nclass PyWeightRandom:\n \"\"\"\n use post date and time of publish\n to generate weight random method()\n it emulates when user creates reposts/likes\n \"\"\"\n\n def __init__(self, data):\n \"\"\"\n data = [\n [ x0 , y0 ] , - левая точка нуля пораболы\n [ x1 , y1 ] , - пик\n [ x2 , y2 ] - точка после точки пика через ( x1-x0 )\n ]\n endpoint = mun of second that:\n 1. > x0\n 2. <= x0 + 86000\n \"\"\"\n # p = [ x0 , x1 , y1 , y2]\n self.p = [data[0][0], data[1][0], data[1][1], data[2][1]]\n mm = [\n [self.p[0]**2, self.p[0], 1],\n [self.p[1]**2, self.p[1], 1],\n [(2 * self.p[1] - self.p[0])**2, (2 * self.p[1] - self.p[0]), 1]\n ]\n abc = list(numpy.linalg.solve(mm, [0, self.p[2], 0]))\n self.a = abc[0]\n self.b = abc[1]\n self.c = abc[2]\n mm = [\n [1.0, -self.p[2]],\n [1.0, -self.p[3]]\n ]\n dk = numpy.linalg.solve(mm, [self.p[2] * self.p[1], self.p[3] * (2 * self.p[1] - self.p[0])])\n self.d = dk[0]\n self.k = dk[1]\n\n self.data = {}\n self._fill()\n\n self._weight = list(self.data.values())\n self._m = sum(self._weight)\n self.elem = list(self.data.keys())\n self.weight = list(map(lambda x: float(x) / float(self._m), self._weight))\n\n # ==========================================================================\n # INTERNAL METHODS\n # ==========================================================================\n\n def spread(self, x):\n \"\"\"\n формула распределения случайно величиный\n p = [\n 0 - start point (flaot)\n 1 - X where max of Y (float)\n 2 - max of Y (float)\n 3 - Y when x = ( 2*p[1]-p[0] )\n ]\n \"\"\"\n if self.p[0] + 1 <= x <= self.p[1] + 1:\n res = self.a * (x**2) + self.b * x + self.c\n elif self.p[1] <= x:\n res = (self.d / (x + self.k))\n else:\n res = self.spread(x + 3600 * 24)\n return res\n\n def _fill(self):\n \"\"\"\n should fill self.data with values of spread function in interesing range\n return None\n \"\"\"\n end = 86400 + (i := self.p[0])\n while i < end:\n self.data[i % 86400] = self.spread(i)\n i += 1\n\n def random(self, y=1):\n \"\"\"\n return random number using spread function\n \"\"\"\n if y <= 1:\n x = random.random()\n i = 0\n while x > 0.0:\n x -= self.weight[i]\n i += 1\n return [i - 1]\n else:\n k = float(self._m) / float(y)\n x = []\n y = k\n for i in range(len(ww := list(self._weight))):\n while ww[i] > 0.0:\n y -= (z := min(y, ww[i]))\n ww[i] -= z\n if y <= 0.0:\n y = k\n x.append(ww[i])\n return x\n\n def destruct(self):\n \"\"\"\n really do nothing (here)\n \"\"\"\n pass\n\n def will_be(self, count_now, now):\n \"\"\"\n predict now many obj will be in 24 hours\n \"\"\"\n def en(_time):\n tm = time.localtime(_time)\n return (tm.tm_hour * 60 + tm.tm_min) * 60 + tm.tm_sec\n if (now := en(now)) < self.p[0]:\n now += 24 * 3600\n\n return (\n (count_now * sum(self.weight) / s)\n if (\n s := sum(\n self.weight[i]\n for i in range(len(self.weight))\n if self.p[0] < i < now\n )\n ) > 0 else\n 0\n )\n\n\ndef py__interpolice(ff, x):\n \"\"\"\n real interpolice method\n USE ONLY BY INTERPOLICE\n \"\"\"\n res = 0.0\n for i in ff:\n if not(-12 < (i[0] - x) < 12):\n continue\n li = 1.0\n for j in ff:\n if not(-12 < (j[0] - x) < 12):\n continue\n if i[0] != j[0]:\n z = (i[0] - j[0])\n li *= ((x - j[0]) / z)\n res += li * i[1]\n return res\n\n\nboo = False\nif sys.platform in {'linux', 'darwin'} and '--no-c' not in sys.argv[1:]:\n try:\n from .ext import interpolice as __interpolice\n from .ext import CWeightRandom as WeightRandom\n boo = True\n except Exception:\n pass\n\nif not boo:\n WeightRandom = PyWeightRandom\n __interpolice = py__interpolice\n\n\ndef interpolice(x, ff=None):\n \"\"\"\n takes as x float() - number of hours\n 13:30 - 13.5\n return float from [0..1]\n ff = [\n [x0 , f(x0)],\n [x1 , f(x1)],\n ]\n \"\"\"\n if ff is None:\n ff = VK_SPREAD\n _max = 108.0\n else:\n _max = float(max(i[1] for i in ff))\n return __interpolice(ff, x) / _max\n", "meta": {"hexsha": "590b1ad4a335ac3514b6d0c96f1225e4ab5c7a19", "size": 6420, "ext": "py", "lang": "Python", "max_stars_repo_path": "logic/rank/wr.py", "max_stars_repo_name": "moff4/gladius", "max_stars_repo_head_hexsha": "773a4e81fcfca7376292c8f9ba601b62324a65f0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "logic/rank/wr.py", "max_issues_repo_name": "moff4/gladius", "max_issues_repo_head_hexsha": "773a4e81fcfca7376292c8f9ba601b62324a65f0", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "logic/rank/wr.py", "max_forks_repo_name": "moff4/gladius", "max_forks_repo_head_hexsha": "773a4e81fcfca7376292c8f9ba601b62324a65f0", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.5333333333, "max_line_length": 101, "alphanum_fraction": 0.4035825545, "include": true, "reason": "import numpy", "num_tokens": 2142, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.665410558746814, "lm_q2_score": 0.2974699426047947, "lm_q1q2_score": 0.19793964071903913}} {"text": "# -*- coding: utf-8 -*-\n# ---------------------\n\nimport numpy as np\nimport ergonomics.utils as utils\n\n\nclass RebaScore:\n '''\n Class to compute REBA metrics\n\n Pose:\n [0]: Head\n [1]: Neck\n [2, 3, 4, 14]: Left arm + (optional)left hand\n [5, 6, 7, 15]: Right arm + (optional)right hand\n [8, 9, 10]: Left leg\n [11, 12, 13]: Right leg\n '''\n def __init__(self):\n # Table A ( Neck X Trunk X Legs)\n self.table_a = np.zeros((3, 5, 4))\n # Table B ( UpperArm X LowerArm X Wrist)\n self.table_b = np.zeros((6, 2, 3))\n # Table C ( ScoreA X ScoreB)\n self.table_c = np.zeros((12, 12))\n\n # Body Params\n self.body = {'neck_angle': 0, 'neck_side': False,\n 'trunk_angle': 0, 'trunk_side': False,\n 'legs_walking': False, 'legs_angle': 0,\n 'load': 0}\n\n # Arms Params\n self.arms = {'upper_arm_angle': 0, 'shoulder_raised': False, 'arm_abducted': False, 'leaning': False,\n 'lower_arm_angle': 0,\n 'wrist_angle': 0, 'wrist_twisted': False}\n\n # Init lookup tables\n self.init_table_a()\n self.init_table_b()\n self.init_table_c()\n\n\n def init_table_a(self):\n '''\n Table used to compute upper body score\n\n :return: None\n '''\n self.table_a = np.array([\n [[1, 2, 3, 4], [2, 3, 4, 5], [2, 4, 5, 6], [3, 5, 6, 7], [4, 6, 7, 8]],\n [[1, 2, 3, 4], [3, 4, 5, 6], [4, 5, 6, 7], [5, 6, 7, 8], [6, 7, 8, 9]],\n [[3, 3, 5, 6], [4, 5, 6, 7], [5, 6, 7, 8], [6, 7, 8, 9], [7, 8, 9, 9]]\n ])\n\n def init_table_b(self):\n '''\n Table used to computer lower body score\n\n :return: None\n '''\n self.table_b = np.array([\n [[1, 2, 2], [1, 2, 3]],\n [[1, 2, 3], [2, 3, 4]],\n [[3, 4, 5], [4, 5, 5]],\n [[4, 5, 5], [5, 6, 7]],\n [[6, 7, 8], [7, 8, 8]],\n [[7, 8, 8], [8, 9, 9]],\n ])\n\n def init_table_c(self):\n '''\n Table to compute score_c\n\n :return: None\n '''\n self.table_c = np.array([\n [1, 1, 1, 2, 3, 3, 4, 5, 6, 7, 7, 7],\n [1, 2, 2, 3, 4, 4, 5, 6, 6, 7, 7, 8],\n [2, 3, 3, 3, 4, 5, 6, 7, 7, 8, 8, 8],\n [3, 4, 4, 4, 5, 6, 7, 8, 8, 9, 9, 9],\n [4, 4, 4, 5, 6, 7, 8, 8, 9, 9, 9, 9],\n [6, 6, 6, 7, 8, 8, 9, 9, 10, 10, 10, 10],\n [7, 7, 7, 8, 9, 9, 9, 10, 10, 11, 11, 11],\n [8, 8, 8, 9, 10, 10, 10, 10, 10, 11, 11, 11],\n [9, 9, 9, 10, 10, 10, 11, 11, 11, 12, 12, 12],\n [10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, 12],\n [11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12],\n [12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12],\n ])\n\n def set_body(self, values):\n # type: (np.ndarray) -> None\n '''\n Set body params\n\n :param values: [neck_angle, neck_side, trunk_angle, trunk_side,\n legs_walking, legs_angle, load]\n\n :return: None\n '''\n assert len(values) == len(self.body)\n\n for i, (key, _) in enumerate(self.body.items()):\n self.body[key] = values[i]\n\n def set_arms(self, values):\n # type: (np.ndarray) -> None\n '''\n Set arms params\n\n :param values: [upper_arm_angle, shoulder_raised, arm_abducted, leaning,\n lower_arm_angle, wrist_angle, wrist_twisted]\n\n :return: None\n '''\n assert len(values) == len(self.arms)\n\n for i, (key, _) in enumerate(self.arms.items()):\n self.arms[key] = values[i]\n\n def compute_score_a(self):\n # type: (RebaScore) -> (np.ndarray, np.ndarray)\n '''\n Compute score A\n >>> rebascore = RebaScore()\n >>> rebascore.set_body(np.array([10, 0, 20, 0, 1, 50, 0]))\n >>> rebascore.compute_score_a()\n (4, array([1, 2, 3]))\n\n :return: Score A, [neck_score, trunk_score, leg_score]\n '''\n neck_score, trunk_score, leg_score, load_score = 0, 0, 0, 0\n\n # Neck position\n if 10 <= self.body['neck_angle'] <= 20 :\n neck_score +=1\n else:\n neck_score +=2\n # Neck adjust\n neck_score +=1 if self.body['neck_side'] else 0\n\n # Trunk position\n if 0 <= self.body['trunk_angle'] <= 1:\n trunk_score +=1\n elif self.body['trunk_angle'] <= 20:\n trunk_score +=2\n elif 20 <= self.body['trunk_angle'] <= 60:\n trunk_score +=3\n elif self.body['trunk_angle'] > 60:\n trunk_score +=4\n # Trunk adjust\n trunk_score += 1 if self.body['trunk_side'] else 0\n\n # Legs position\n leg_score += 2 if self.body['legs_walking'] else 1\n # Legs adjust\n if 30 <= self.body['legs_angle'] <= 60:\n leg_score += 1\n elif self.body['legs_angle'] > 60:\n leg_score += 2\n\n # Load\n if 5 <= self.body['load'] <= 10:\n load_score += 1\n elif self.body['load'] > 10:\n load_score += 2\n\n assert neck_score > 0 and trunk_score > 0 and leg_score > 0\n\n score_a = self.table_a[neck_score-1][trunk_score-1][leg_score-1]\n return score_a, np.array([neck_score, trunk_score, leg_score])\n\n def compute_score_b(self):\n # type: (RebaScore) -> (np.ndarray, np.ndarray)\n '''\n Compute score B\n >>> rebascore = RebaScore()\n >>> rebascore.set_arms(np.array([45, 0, 0, 0, 70, 0, 1]))\n >>> rebascore.compute_score_b()\n (2, array([2, 1, 2]))\n\n :return: scoreB, [upper_arm_score, lower_arm_score, wrist_score]\n '''\n upper_arm_score, lower_arm_score, wrist_score = 0, 0, 0\n\n # Upper arm position\n if -20 <= self.arms['upper_arm_angle'] <= 20:\n upper_arm_score +=1\n elif self.arms['upper_arm_angle'] <= 45:\n upper_arm_score +=2\n elif 45 <= self.arms['upper_arm_angle'] <= 90:\n upper_arm_score +=3\n elif self.arms['upper_arm_angle'] > 90:\n upper_arm_score +=4\n\n # Upper arm adjust\n upper_arm_score += 1 if self.arms['shoulder_raised'] else 0\n upper_arm_score += 1 if self.arms['arm_abducted'] else 0\n upper_arm_score -= 1 if self.arms['leaning'] else 0\n\n # Lower arm position\n if 60 <= self.arms['lower_arm_angle'] <= 100:\n lower_arm_score += 1\n else:\n lower_arm_score += 2\n\n # Wrist position\n if -15 <= self.arms['wrist_angle'] <= 15:\n wrist_score += 1\n else:\n wrist_score += 2\n\n # Wrist adjust\n wrist_score += 1 if self.arms['wrist_twisted'] else 0\n\n assert lower_arm_score > 0 and wrist_score > 0\n\n score_b = self.table_b[upper_arm_score-1][lower_arm_score-1][wrist_score-1]\n return score_b, np.array([upper_arm_score, lower_arm_score, wrist_score])\n\n def compute_score_c(self, score_a, score_b):\n # type: (np.ndarray, np.ndarray) -> (np.ndarray, str)\n '''\n Compute score C\n\n :param score_a: Score A\n :param score_b: Score B\n\n :return: Score C, caption\n '''\n reba_scoring = ['Negligible Risk',\n 'Low Risk. Change may be needed',\n 'Medium Risk. Further Investigate. Change Soon',\n 'High Risk. Investigate and Implement Change',\n 'Very High Risk. Implement Change'\n ]\n\n score_c = self.table_c[score_a-1][score_b-1]\n ix = self.score_c_to_5_classes(score_c)\n caption = reba_scoring[ix]\n\n return score_c, caption\n\n @staticmethod\n def score_c_to_5_classes(score_c):\n # type: (np.ndarray) -> int\n '''\n Score C to 5 risk-classes\n\n :param score_c: Score C\n :return: Risk-class\n '''\n if score_c == 1:\n ret = 0\n elif 2 <= score_c <= 3:\n ret = 1\n elif 4 <= score_c <= 7:\n ret = 2\n elif 8 <= score_c <= 10:\n ret = 3\n else:\n ret = 4\n\n return ret\n\n @staticmethod\n def get_body_angles_from_pose_left(pose, verbose=False):\n # type: (np.ndarray, bool) -> np.ndarray\n '''\n Get body angles from pose (look at left)\n\n :param pose: Pose (Joints coordinates)\n :param verbose: If true show each pose for debugging\n\n :return: Body params (neck_angle, neck_side, trunk_angle, trunk_side,\n legs_walking, legs_angle, load)\n '''\n\n pose = np.expand_dims(np.copy(pose), 0)\n\n neck_angle, neck_side, trunk_angle, trunk_side, \\\n legs_walking, legs_angle, load = 0, 0, 0, 0, 0, 0, 0\n\n if verbose:\n utils.show_skeleton(pose, title=\"GT pose\")\n _pose, _ = utils.rotate_pose(np.copy(pose), rotation_joint=8)\n utils.show_skeleton(_pose, title=\"GT pose left\")\n\n # Trunk position\n pose, _ = utils.rotate_pose(pose, rotation_joint=8)\n pose -= (pose[:, 8] + pose[:, 11]) /2\n\n if quad(pose[0, 1]) < 3:\n trunk_angle = np.rad2deg(np.arctan2(pose[0, 1, 1], pose[0, 1, 0]) - (np.pi / 2))\n else:\n trunk_angle = 270 + np.rad2deg(np.arctan2(pose[0, 1, 1], pose[0, 1, 0]))\n\n if verbose:\n utils.show_skeleton(pose, title=\"Trunk angle: \" + str(round(trunk_angle, 2)))\n\n # Trunk bending\n pose, _ = utils.rotate_pose(pose, rotation_joint=8, m_coeff=np.pi/2)\n\n angle = np.pi /2 if quad(pose[0, 1]) > 2 else -np.pi/2\n trunk_side_angle = abs(np.rad2deg(np.arctan2(pose[0, 1, 1], pose[0, 1, 0]) + angle))\n trunk_side = 1 if trunk_side_angle > 30 else 0\n\n if verbose:\n utils.show_skeleton(pose, title=\"Trunk side angle: \" + str(round(trunk_side_angle, 2)))\n\n # Neck position\n pose, _ = utils.rotate_pose(pose, rotation_joint=8, m_coeff=-np.pi/2)\n pose -= pose[:, 1]\n\n if quad(pose[0, 0]) < 3:\n neck_angle = np.rad2deg(np.arctan2(pose[0, 0, 1], pose[0, 0, 0]) - (np.pi / 2)) - trunk_angle\n else:\n neck_angle = 270 + np.rad2deg(np.arctan2(pose[0, 0, 1], pose[0, 0, 0])) - trunk_angle\n\n if verbose:\n utils.show_skeleton(pose, title=\"Neck angle: \" + str(round(neck_angle, 2)))\n\n # Neck bending\n pose, _ = utils.rotate_pose(pose, rotation_joint=8, m_coeff=np.pi / 2)\n angle = np.pi /2 if quad(pose[0, 0]) > 2 else -np.pi/2\n neck_side_angle = abs(np.rad2deg(np.arctan2(pose[0, 0, 1], pose[0, 0, 0]) + angle)) - trunk_side_angle\n neck_side = 1 if neck_side_angle > 20 else 0\n\n if verbose:\n utils.show_skeleton(pose, title=\"Neck side angle: \" + str(round(neck_side_angle, 2)))\n\n # Legs position\n pose, _ = utils.rotate_pose(pose, rotation_joint=8, m_coeff=-np.pi / 2)\n pose -= pose[:, 8]\n\n if quad(pose[0, 9]) > 2:\n legs_angle = -np.rad2deg(np.arctan2(pose[0, 9, 1], pose[0, 9, 0]) + (np.pi/2))\n else:\n legs_angle = 270 - np.rad2deg(np.arctan2(pose[0, 9, 1], pose[0, 9, 0]))\n\n step_size = abs(np.linalg.norm(pose[0, 10, :2] - pose[0, 13, :2]))\n legs_walking = 1 if step_size > 0.1 else 0\n\n if verbose:\n title = \"Leg angle: \" + str(round(legs_angle, 2)) + \" Step size: \" + str(round(step_size, 2))\n utils.show_skeleton(pose, title=title)\n\n return np.array([neck_angle, neck_side, trunk_angle, trunk_side,\n legs_walking, legs_angle, load])\n\n\n @staticmethod\n def get_body_angles_from_pose_right(pose, verbose=False):\n # type: (np.ndarray, bool) -> np.ndarray\n '''\n Get body angles from pose (look at right)\n\n :param pose: Pose (Joints coordinates)\n :param verbose: If true show each pose for debugging\n\n :return: Body params (neck_angle, neck_side, trunk_angle, trunk_side,\n legs_walking, legs_angle, load)\n '''\n pose = np.expand_dims(np.copy(pose), 0)\n\n neck_angle, neck_side, trunk_angle, trunk_side, \\\n legs_walking, legs_angle, load = 0, 0, 0, 0, 0, 0, 0\n\n if verbose:\n utils.show_skeleton(pose, title=\"GT pose\")\n _pose, _ = utils.rotate_pose(np.copy(pose), rotation_joint=8)\n _pose, _ = utils.rotate_pose(_pose, rotation_joint=8, m_coeff=np.pi)\n utils.show_skeleton(_pose, title=\"GT pose Right\")\n\n pose, _ = utils.rotate_pose(pose, rotation_joint=8)\n\n # Trunk position\n pose, _ = utils.rotate_pose(pose, rotation_joint=8, m_coeff=np.pi)\n pose -= (pose[:, 8] + pose[:, 11]) / 2\n trunk_angle = np.rad2deg((np.pi / 2) - np.arctan2(pose[0, 1, 1], pose[0, 1, 0]))\n\n if verbose:\n utils.show_skeleton(pose, title=\"Trunk angle: \" + str(round(trunk_angle, 2)))\n\n # Trunk bending\n pose, _ = utils.rotate_pose(pose, rotation_joint=8, m_coeff=np.pi / 2)\n trunk_side_angle = abs(np.rad2deg(np.arctan2(pose[0, 1, 1], pose[0, 1, 0]) - (np.pi / 2)))\n trunk_side = 1 if trunk_side_angle > 30 else 0\n\n if verbose:\n utils.show_skeleton(pose, title=\"Trunk side angle: \" + str(round(trunk_side_angle, 2)))\n\n # Neck position\n pose, _ = utils.rotate_pose(pose, rotation_joint=8, m_coeff=-np.pi / 2)\n pose -= pose[:, 1]\n neck_angle = np.rad2deg((np.pi / 2) - np.arctan2(pose[0, 0, 1], pose[0, 0, 0])) - trunk_angle\n\n if verbose:\n utils.show_skeleton(pose, title=\"Neck angle: \" + str(round(neck_angle, 2)))\n\n # Neck bending\n pose, _ = utils.rotate_pose(pose, rotation_joint=8, m_coeff=np.pi / 2)\n neck_side_angle = np.abs(np.rad2deg(np.abs(np.arctan2(pose[0, 0, 1], pose[0, 0, 0])) - (np.pi / 2)))\n neck_side = 1 if neck_side_angle > 20 else 0\n\n if verbose:\n utils.show_skeleton(pose, title=\"Neck side angle: \" + str(round(neck_side_angle, 2)))\n\n # Legs position\n pose, _ = utils.rotate_pose(pose, rotation_joint=8, m_coeff=-np.pi / 2)\n pose -= pose[:, 11]\n legs_angle = np.rad2deg((np.pi / 2) + np.arctan2(pose[0, 12, 1], pose[0, 12, 0]))\n step_size = abs(np.linalg.norm(pose[0, 10, :2] - pose[0, 13, :2]))\n legs_walking = 1 if step_size > 0.1 else 0\n\n if verbose:\n title = \"Leg angle: \" + str(round(legs_angle, 2)) + \" Step size: \" + str(round(step_size, 2))\n utils.show_skeleton(pose, title=title)\n\n return np.array([neck_angle, neck_side, trunk_angle, trunk_side,\n legs_walking, legs_angle, load])\n\n @staticmethod\n def get_arms_angles_from_pose_left(pose, verbose=False):\n # type: (np.ndarray, bool) -> np.ndarray\n '''\n Get arms angles from pose (look at left)\n\n :param pose: Pose (Joints coordinates)\n :param verbose: If true show each pose for debugging\n\n :return: Body params (upper_arm_angle, shoulder_raised, arm_abducted, leaning,\n lower_arm_angle, wrist_angle, wrist_twisted)\n '''\n pose = np.expand_dims(np.copy(pose), 0)\n if verbose:\n utils.show_skeleton(pose, title=\"GT pose\")\n\n # Leaning\n pose, _ = utils.rotate_pose(pose, rotation_joint=8)\n pose -= (pose[:, 8] + pose[:, 11]) / 2\n\n if quad(pose[0, 1]) < 3:\n trunk_angle = np.rad2deg(np.arctan2(pose[0, 1, 1], pose[0, 1, 0]) - (np.pi / 2))\n else:\n trunk_angle = 270 + np.rad2deg(np.arctan2(pose[0, 1, 1], pose[0, 1, 0]))\n\n leaning = 1 if trunk_angle > 30 else 0\n\n if verbose:\n utils.show_skeleton(pose, title=\"Leaning angle: \" + str(round(trunk_angle, 2)))\n\n # Upper Arm position\n pose, _ = utils.rotate_pose(pose, rotation_joint=8)\n pose -= pose[:, 2]\n\n if quad(pose[0, 3]) > 2:\n upper_arm_angle = -np.rad2deg(np.arctan2(pose[0, 3, 1], pose[0, 3, 0]) + (np.pi / 2))\n else:\n upper_arm_angle = 270 - np.rad2deg(np.arctan2(pose[0, 3, 1], pose[0, 3, 0]))\n\n\n upper_arm_angle += trunk_angle\n\n if verbose:\n utils.show_skeleton(pose, title=\"Upper Arms angle: \" + str(round(upper_arm_angle, 2)))\n\n # Upper Arm Adjust\n pose, _ = utils.rotate_pose(pose, rotation_joint=8, m_coeff=np.pi/2)\n shoulder_step = pose[:, 2, 1] - pose[:, 1, 1]\n\n if quad(pose[0, 3]) > 2:\n arm_abducted_angle = -np.rad2deg(np.arctan2(pose[0, 3, 1], pose[0, 3, 0]) + (np.pi / 2))\n else:\n arm_abducted_angle = 270 - np.rad2deg(np.arctan2(pose[0, 3, 1], pose[0, 3, 0]))\n\n shoulder_raised = 1 if shoulder_step > 0.02 else 0\n arm_abducted = 1 if arm_abducted_angle > 45 else 0\n\n if verbose:\n print(shoulder_raised)\n utils.show_skeleton(pose, title=\"Upper Arms abducted: \" + str(round(arm_abducted_angle, 2)))\n\n # Lower Arm position\n pose, _ = utils.rotate_pose(pose, rotation_joint=8, m_coeff=-np.pi/2)\n pose -= pose[:, 3]\n\n if quad(pose[0, 4]) > 2:\n lower_arm_angle = -np.rad2deg(np.arctan2(pose[0, 4, 1], pose[0, 4, 0]) + (np.pi / 2))\n else:\n lower_arm_angle = 270 - np.rad2deg(np.arctan2(pose[0, 4, 1], pose[0, 4, 0]))\n\n lower_arm_angle = lower_arm_angle + trunk_angle - upper_arm_angle\n\n if verbose:\n utils.show_skeleton(pose, title=\"Lower Arms angle: \" + str(round(lower_arm_angle, 2)))\n\n # Wrist position\n wrist_angle = 0\n wrist_twisted = 0\n\n if pose.shape[1] > 14:\n pose -= pose[:, 4]\n wrist_angle = np.rad2deg(np.arctan2(pose[0, 14, 1], pose[0, 14, 0]) - (np.pi / 2) )\n\n if verbose:\n utils.show_skeleton(pose, title=\"Wrist Angle: \" + str(round(wrist_angle, 2)))\n\n pose, _ = utils.rotate_pose(pose, rotation_joint=8, m_coeff=-np.pi / 2)\n wrist_twisted_angle = abs(np.rad2deg(np.arctan2(pose[0, 14, 1], pose[0, 14, 0]) - (np.pi / 2)))\n wrist_twisted = 1 if wrist_twisted_angle > 30 else 0\n\n return np.array([upper_arm_angle, shoulder_raised, arm_abducted, leaning,\n lower_arm_angle, wrist_angle, wrist_twisted])\n\n\n @staticmethod\n def get_arms_angles_from_pose_right(pose, verbose=False):\n # type: (np.ndarray, bool) -> np.ndarray\n '''\n Get arms angles from pose (look at right)\n\n :param pose: Pose (Joints coordinates)\n :param verbose: If true show each pose for debugging\n\n :return: Body params (upper_arm_angle, shoulder_raised, arm_abducted, leaning,\n lower_arm_angle, wrist_angle, wrist_twisted)\n '''\n pose = np.expand_dims(np.copy(pose), 0)\n if verbose:\n utils.show_skeleton(pose, title=\"GT pose\")\n\n pose, _ = utils.rotate_pose(pose, rotation_joint=8)\n pose, _ = utils.rotate_pose(pose, rotation_joint=8, m_coeff=np.pi)\n\n # Leaning\n pose -= (pose[:, 8] + pose[:, 11]) / 2\n trunk_angle = np.rad2deg((np.pi / 2) - np.arctan2(pose[0, 1, 1], pose[0, 1, 0]))\n leaning = 1 if trunk_angle > 60 else 0\n\n if verbose:\n utils.show_skeleton(pose, title=\"Leaning angle: \" + str(round(trunk_angle, 2)))\n\n # Upper Arm position\n pose -= pose[:, 5]\n if quad(pose[0, 6]) == 2:\n upper_arm_angle = -(270 - np.rad2deg(np.arctan2(pose[0, 6, 1], pose[0, 6, 0])) - trunk_angle)\n else:\n upper_arm_angle = np.rad2deg((np.pi /2) + np.arctan2(pose[0, 6, 1], pose[0, 6, 0])) + trunk_angle\n\n if verbose:\n utils.show_skeleton(pose, title=\"Upper Arms angle: \" + str(round(upper_arm_angle, 2)))\n\n # Upper Arm Adjust\n pose, _ = utils.rotate_pose(pose, rotation_joint=8, m_coeff=np.pi / 2)\n shoulder_step = pose[:, 5, 1] - pose[:, 1, 1]\n arm_abducted_angle = abs(np.rad2deg((np.pi / 2) + np.arctan2(pose[0, 6, 1], pose[0, 6, 0])))\n shoulder_raised = 1 if shoulder_step > 0.02 else 0\n arm_abducted = 1 if arm_abducted_angle > 45 else 0\n\n if verbose:\n print(shoulder_raised)\n utils.show_skeleton(pose, title=\"Upper Arms abducted: \" + str(round(arm_abducted_angle, 2)))\n\n # Lower Arm position\n pose, _ = utils.rotate_pose(pose, rotation_joint=8, m_coeff=-np.pi / 2)\n pose -= pose[:, 6]\n lower_arm_angle = np.rad2deg((np.pi / 2) + np.arctan2(pose[0, 7, 1], pose[0, 7, 0]) ) + trunk_angle - upper_arm_angle\n\n if verbose:\n utils.show_skeleton(pose, title=\"Lower Arms angle: \" + str(round(lower_arm_angle, 2)))\n\n # Wrist position\n wrist_angle = 0\n wrist_twisted = 0\n\n if pose.shape[1] > 14:\n pose -= pose[:, 7]\n wrist_angle = np.rad2deg((np.pi / 2) + np.arctan2(pose[0, 15, 1], pose[0, 15, 0]))\n\n if verbose:\n utils.show_skeleton(pose, title=\"Wrist Angle: \" + str(round(wrist_angle, 2)))\n\n pose, _ = utils.rotate_pose(pose, rotation_joint=8, m_coeff=-np.pi / 2)\n wrist_twisted_angle = abs(np.rad2deg((np.pi / 2) + np.arctan2(pose[0, 15, 1], pose[0, 15, 0])))\n wrist_twisted = 1 if wrist_twisted_angle > 30 else 0\n\n\n return np.array([upper_arm_angle, shoulder_raised, arm_abducted, leaning,\n lower_arm_angle, wrist_angle, wrist_twisted])\n\ndef quad(coord):\n q = 0\n if coord[0] >= 0 and coord[1] >= 0:\n q = 1\n elif coord[0] <= 0 and coord[1] >= 0:\n q = 2\n elif coord[0] <= 0 and coord[1] <= 0:\n q = 3\n elif coord[0] >= 0 and coord[1] <= 0:\n q = 4\n return q\n\nif __name__ == '__main__':\n\n import doctest\n doctest.testmod()\n\n sample_pose = np.array([[ 0.08533354, 1.03611605, 0.09013124],\n [ 0.15391247, 0.91162637, -0.00353906],\n [ 0.22379057, 0.87361878, 0.11541229],\n [ 0.4084777 , 0.69462843, 0.1775224 ],\n [ 0.31665226, 0.46389668, 0.16556387],\n [ 0.1239769 , 0.82994377, -0.11715403],\n [ 0.08302169, 0.58146328, -0.19830338],\n [-0.06767788, 0.53928527, -0.00511249],\n [ 0.11368726, 0.49372503, 0.21275574],\n [ 0.069179 , 0.07140968, 0.26841402],\n [ 0.10831762, -0.36339359, 0.34032449],\n [ 0.11368726, 0.41275504, -0.01171348],\n [ 0. , 0. , 0. ],\n [ 0.02535541, -0.43954643, 0.04373671],\n [ 0.26709431, 0.33643749, 0.17985192],\n [-0.15117603, 0.49462711, 0.02703403]])\n\n rebaScore = RebaScore()\n\n body_params = rebaScore.get_body_angles_from_pose_right(sample_pose)\n arms_params = rebaScore.get_arms_angles_from_pose_right(sample_pose)\n\n rebaScore.set_body(body_params)\n score_a, partial_a = rebaScore.compute_score_a()\n\n rebaScore.set_arms(arms_params)\n score_b, partial_b = rebaScore.compute_score_b()\n\n score_c, caption = rebaScore.compute_score_c(score_a, score_b)\n\n print(\"Score A: \", score_a, \"Partial: \", partial_a)\n print(\"Score A: \", score_b, \"Partial: \", partial_b)\n print(\"Score C: \", score_c, caption)\n", "meta": {"hexsha": "f05fff30d8ff945767e5a54e9eaea0fb23df0144", "size": 24071, "ext": "py", "lang": "Python", "max_stars_repo_path": "ergonomics/reba.py", "max_stars_repo_name": "rs9000/ergonomics", "max_stars_repo_head_hexsha": "78a41799c53b0fb3afbc09d30f0039104e739f80", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-02-01T21:27:03.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-01T21:27:03.000Z", "max_issues_repo_path": "ergonomics/reba.py", "max_issues_repo_name": "rs9000/ergonomics", "max_issues_repo_head_hexsha": "78a41799c53b0fb3afbc09d30f0039104e739f80", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-11-13T16:10:17.000Z", "max_issues_repo_issues_event_max_datetime": "2021-11-13T16:24:12.000Z", "max_forks_repo_path": "ergonomics/reba.py", "max_forks_repo_name": "rs9000/ergonomics", "max_forks_repo_head_hexsha": "78a41799c53b0fb3afbc09d30f0039104e739f80", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-02-01T21:27:12.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-04T17:10:22.000Z", "avg_line_length": 37.3773291925, "max_line_length": 125, "alphanum_fraction": 0.5303061776, "include": true, "reason": "import numpy", "num_tokens": 7446, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6370307944803831, "lm_q2_score": 0.3106943768319878, "lm_q1q2_score": 0.19792188571386873}} {"text": "# ======================================================================\n#\n# Brad T. Aagaard\n# U.S. Geological Survey\n#\n# ======================================================================\n#\n\nimport os\nimport logging\nfrom importlib import import_module\nimport numpy\n\nfrom . import analysis_utils\nfrom . import gdalraster\n\nclass CostSavings(object):\n \"\"\"Cost savings weighted by area and population.\n \"\"\"\n \n def __init__(self, config):\n self.config = config\n return\n\n def compute(self, event, shakemap, alerts, shakingTime, populationDensity, magAlertThreshold, mmiAlertThreshold, plotAlertMaps=False):\n\n functionPath = self.config.get(\"mmi_predicted\", \"function\").split(\".\")\n fn = getattr(import_module(\".\".join(functionPath[:-1])), functionPath[-1])\n \n shape = shakemap.data[\"mmi\"].shape\n warningTimeZero = numpy.zeros((1,), dtype=\"timedelta64[us]\")\n warningTime = gdalraster.NO_DATA_VALUE * 1.0e+6 * numpy.ones(shape, dtype=\"timedelta64[us]\")\n mmiPred = gdalraster.NO_DATA_VALUE * numpy.ones(shape, numpy.float32)\n\n gmpe = self.config.get(\"mmi_predicted\", \"gmpe\")\n gmice = self.config.get(\"mmi_predicted\", \"gmice\")\n alertLatency = numpy.timedelta64(int(self.config.getfloat(\"alerts\", \"alert_latency_sec\")*1.0e+3), \"ms\")\n if gmice == \"default\":\n gmice = shakemap.gmiceGrid\n \n thresholdReached = False\n for alert in alerts:\n alertTime = numpy.datetime64(alert[\"timestamp\"]) + alertLatency\n\n if alertTime > numpy.max(shakingTime):\n # Skip alerts with no positive warning times in\n # domain. Changes in estimated earthquake location\n # could result in later alerts having positive warning\n # times.\n logging.getLogger(__name__).debug(\"Skipping alert version {ver} with no positive warning times.\".format(ver=alert[\"version\"]))\n continue\n if not thresholdReached and alert[\"magnitude\"] < magAlertThreshold:\n continue\n else:\n if not thresholdReached:\n wtime = analysis_utils.timedelta_to_seconds(alertTime - numpy.datetime64(event[\"origin_time\"]))\n msg = \"Alert threshold reached at {tstamp}, {wtime:.1f}s after origin time.\".format(tstamp=alertTime, wtime=wtime)\n logging.getLogger(__name__).info(msg)\n thresholdReached = True\n \n mmiPredCur = fn(alert, shakemap.data, gmpe, gmice)\n warningTimeCur = shakingTime - alertTime\n \n if plotAlertMaps:\n plotsDir = self.config.get(\"files\", \"plots_dir\")\n if not os.path.isdir(plotsDir):\n os.makedirs(plotsDir)\n filename = analysis_utils.analysis_event_label(self.config, self.eqId, magAlertThreshold, mmiAlertThreshold)+\"_alert_snapshot.tiff\"\n values = [\n (\"mmi_pred\", mmiPredCur,),\n (\"warning_time\", analysis_utils.timedelta_to_seconds(warningTimeCur),),\n ]\n gdalraster.write(filename, values, shakemap.num_lon(), shakemap.num_lat(), shakemap.spatial_ref(), shakemap.geo_transform())\n mapPanels = maps.MapPanels(self.config)\n mapPanels.load_data(event[\"event_id\"], alert=alert)\n tafterOT = analysis_utils.timedelta_to_seconds(alertTime-numpy.datetime64(event[\"origin_time\"]))\n mapPanels.mmi_warning_time(tafterOT)\n \n # Update alert time if greater than previous\n maskAlert = numpy.bitwise_and(warningTimeCur > warningTime, mmiPredCur >= mmiAlertThreshold)\n warningTime[maskAlert] = warningTimeCur[maskAlert]\n\n # Update predicted MMI if greater than previous AND\n # positive warning time. Assumes action will be taken if\n # alert threshold is reached (cannot be undone if later\n # updates reduce predicted MMI).\n maskMMI = numpy.bitwise_and(mmiPredCur > mmiPred, warningTimeCur >= warningTimeZero)\n mmiPred[maskMMI] = mmiPredCur[maskMMI]\n\n filename = \"analysis_\" + analysis_utils.analysis_event_label(self.config, event[\"event_id\"], magAlertThreshold, mmiAlertThreshold) + \".tiff\"\n metrics = self._cost(mmiPred, shakemap, warningTime, populationDensity, mmiAlertThreshold, filename)\n return metrics\n\n def _cost(self, mmiPred, shakemap, warningTime, populationDensity, mmiAlertThreshold, filename):\n \"\"\"Compute cost savings metrics.\n \"\"\"\n mmiObs = shakemap.data[\"mmi\"]\n \n # Compute costNoEEW, costEEW, costPerfectEEW, costSavings\n objectPath = self.config.get(\"fragility_curves\", \"object\").split(\".\")\n fragilityOptions = dict(self.config.items(\"fragility_curves\"))\n fragilityOptions.pop(\"object\")\n fragilityOptions.pop(\"label\")\n fragilityOptions = {k: float(v) for k,v in fragilityOptions.items()}\n fragility = getattr(import_module(\".\".join(objectPath[:-1])), objectPath[-1])(**fragilityOptions)\n \n costDamage = fragility.cost_damage(mmiObs)\n costActionObs = fragility.cost_action(mmiObs)\n costNoEEW = costDamage\n costPerfectEEW = costDamage*(costDamage < costActionObs) + costActionObs*(costDamage >= costActionObs)\n costEEW = fragility.cost_action(mmiPred)*(mmiPred >= mmiAlertThreshold) + costDamage*(mmiPred < mmiAlertThreshold)\n\n pixelArea = shakemap.pixel_area(self.config.get(\"shakemap\", \"projection\"))\n areaCostNoEEW = numpy.sum(pixelArea * costNoEEW)\n areaCostPerfectEEW = numpy.sum(pixelArea * costPerfectEEW)\n areaCostEEW = numpy.sum(pixelArea * costEEW)\n areaDamage = numpy.sum(pixelArea * (costDamage > 0.0))\n areaAlert = numpy.sum(pixelArea * (mmiPred >= mmiAlertThreshold))\n areaAlertPerfect = numpy.sum(pixelArea * (costDamage > costActionObs))\n \n popCostNoEEW = numpy.sum(populationDensity * pixelArea * costNoEEW)\n popCostPerfectEEW = numpy.sum(populationDensity * pixelArea * costPerfectEEW)\n popCostEEW = numpy.sum(populationDensity * pixelArea * costEEW)\n popDamage = numpy.sum(pixelArea * populationDensity * (costDamage > 0.0))\n popAlert = numpy.sum(pixelArea * populationDensity * (mmiPred >= mmiAlertThreshold))\n popAlertPerfect = numpy.sum(pixelArea * populationDensity * (costDamage > costActionObs))\n\n # Alert categories TN(0),FN(1),FP(2),TP(3)\n alertCategory = numpy.zeros(costDamage.shape)\n maskTN = numpy.bitwise_and(mmiPred < mmiAlertThreshold, costDamage < costActionObs)\n maskFN = numpy.bitwise_and(mmiPred < mmiAlertThreshold, costDamage >= costActionObs)\n maskFP = numpy.bitwise_and(mmiPred >= mmiAlertThreshold, costDamage < costActionObs)\n maskTP = numpy.bitwise_and(mmiPred >= mmiAlertThreshold, costDamage >= costActionObs)\n alertCategory = maskTN*0.0 + maskFN*1.0 + maskFP*2.0 + maskTP*3.0\n\n values = [\n (\"mmi_obs\", mmiObs,),\n (\"mmi_pred\", mmiPred,),\n (\"warning_time\", analysis_utils.timedelta_to_seconds(warningTime),),\n (\"population_density\", populationDensity,),\n (\"cost_no_eew\", costNoEEW,),\n (\"cost_perfect_eew\", costPerfectEEW,),\n (\"cost_eew\", costEEW,),\n (\"alert_category\", alertCategory,),\n (\"pixel_area\", pixelArea,),\n ]\n cacheDir = self.config.get(\"files\", \"analysis_cache_dir\")\n if not os.path.isdir(cacheDir):\n os.makedirs(cacheDir)\n gdalraster.write(os.path.join(cacheDir, filename), values, shakemap.num_lon(), shakemap.num_lat(), shakemap.spatial_ref(), shakemap.geo_transform())\n\n metrics = {\n \"area_damage\": areaDamage,\n \"area_alert\": areaAlert,\n \"area_alert_perfect\": areaAlertPerfect,\n \"area_costsavings_eew\": areaCostNoEEW - areaCostEEW,\n \"area_costsavings_perfecteew\": areaCostNoEEW - areaCostPerfectEEW,\n \"population_damage\": popDamage,\n \"population_alert\": popAlert,\n \"population_alert_perfect\": popAlertPerfect,\n \"population_costsavings_eew\": popCostNoEEW - popCostEEW,\n \"population_costsavings_perfecteew\": popCostNoEEW - popCostPerfectEEW,\n }\n return metrics\n\n# End of file\n", "meta": {"hexsha": "d71388e654d77c12a75599d7934ed88f1d5d5d77", "size": 8563, "ext": "py", "lang": "Python", "max_stars_repo_path": "eewperformance/perfmetrics.py", "max_stars_repo_name": "baagaard-usgs/eew-analyze", "max_stars_repo_head_hexsha": "5f9ec7d6eecd693fc0a3147d2695c957da64d4b2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-05-24T01:41:46.000Z", "max_stars_repo_stars_event_max_datetime": "2018-05-24T01:41:46.000Z", "max_issues_repo_path": "eewperformance/perfmetrics.py", "max_issues_repo_name": "baagaard-usgs/eew-performance", "max_issues_repo_head_hexsha": "5f9ec7d6eecd693fc0a3147d2695c957da64d4b2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "eewperformance/perfmetrics.py", "max_forks_repo_name": "baagaard-usgs/eew-performance", "max_forks_repo_head_hexsha": "5f9ec7d6eecd693fc0a3147d2695c957da64d4b2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 51.2754491018, "max_line_length": 156, "alphanum_fraction": 0.6303865468, "include": true, "reason": "import numpy", "num_tokens": 1954, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073655352404, "lm_q2_score": 0.359364152021239, "lm_q1q2_score": 0.19786854901222004}} {"text": "# Licensed under a 3-clause BSD style license - see LICENSE.rst\nimport abc\nimport copy\nimport inspect\nimport logging\nfrom collections.abc import Sequence\nimport numpy as np\nimport scipy.interpolate\nfrom astropy import units as u\nfrom astropy.coordinates import SkyCoord\nfrom astropy.io import fits\nfrom astropy.table import Column, Table, hstack\nfrom astropy.utils import lazyproperty\nfrom gammapy.utils.interpolation import interpolation_scale\nfrom .utils import INVALID_INDEX, edges_from_lo_hi, find_bands_hdu, find_hdu\n\n__all__ = [\"MapCoord\", \"Geom\", \"MapAxis\", \"MapAxes\"]\n\nlog = logging.getLogger(__name__)\n\n\ndef flat_if_equal(array):\n if array.ndim == 2:\n return array[0]\n else:\n return array\n\ndef get_shape(param):\n if param is None:\n return tuple()\n\n if not isinstance(param, tuple):\n param = [param]\n\n return max([np.array(p, ndmin=1).shape for p in param])\n\n\ndef skycoord_to_lonlat(skycoord, frame=None):\n \"\"\"Convert SkyCoord to lon, lat, frame.\n\n Returns\n -------\n lon : `~numpy.ndarray`\n Longitude in degrees.\n lat : `~numpy.ndarray`\n Latitude in degrees.\n \"\"\"\n if frame:\n skycoord = skycoord.transform_to(frame)\n\n return skycoord.data.lon.deg, skycoord.data.lat.deg, skycoord.frame.name\n\n\ndef pix_tuple_to_idx(pix):\n \"\"\"Convert a tuple of pixel coordinate arrays to a tuple of pixel indices.\n\n Pixel coordinates are rounded to the closest integer value.\n\n Parameters\n ----------\n pix : tuple\n Tuple of pixel coordinates with one element for each dimension\n\n Returns\n -------\n idx : `~numpy.ndarray`\n Array of pixel indices\n \"\"\"\n idx = []\n for p in pix:\n p = np.array(p, ndmin=1)\n if np.issubdtype(p.dtype, np.integer):\n idx += [p]\n else:\n p_idx = np.rint(p).astype(int)\n p_idx[~np.isfinite(p)] = INVALID_INDEX.int\n idx += [p_idx]\n\n return tuple(idx)\n\n\ndef coord_to_pix(edges, coord, interp=\"lin\"):\n \"\"\"Convert axis to pixel coordinates for given interpolation scheme.\"\"\"\n scale = interpolation_scale(interp)\n\n interp_fn = scipy.interpolate.interp1d(\n scale(edges), np.arange(len(edges), dtype=float), fill_value=\"extrapolate\"\n )\n\n return interp_fn(scale(coord))\n\n\ndef pix_to_coord(edges, pix, interp=\"lin\"):\n \"\"\"Convert pixel to grid coordinates for given interpolation scheme.\"\"\"\n scale = interpolation_scale(interp)\n\n interp_fn = scipy.interpolate.interp1d(\n np.arange(len(edges), dtype=float), scale(edges), fill_value=\"extrapolate\"\n )\n\n return scale.inverse(interp_fn(pix))\n\n\nclass MapAxes(Sequence):\n \"\"\"MapAxis container class.\n\n Parameters\n ----------\n axes : list of `MapAxis`\n List of map axis objects.\n \"\"\"\n\n def __init__(self, axes, n_spatial_axes=None):\n unique_names = []\n\n for ax in axes:\n if ax.name in unique_names:\n raise (\n ValueError(f\"Axis names must be unique, got: '{ax.name}' twice.\")\n )\n unique_names.append(ax.name)\n\n self._axes = axes\n self._n_spatial_axes = n_spatial_axes\n\n @property\n def reverse(self):\n \"\"\"Reverse axes order\"\"\"\n return MapAxes(self[::-1])\n\n @property\n def iter_with_reshape(self):\n \"\"\"Iterate by shape\"\"\"\n for idx, axis in enumerate(self):\n # Extract values for each axis, default: nodes\n shape = [1] * len(self)\n shape[idx] = -1\n if self._n_spatial_axes:\n shape = shape[::-1] + [1, ] * self._n_spatial_axes\n yield tuple(shape), axis\n\n def get_coord(self, mode=\"center\", axis_name=None):\n \"\"\"Get axes coordinates\n\n Parameters\n ----------\n mode : {\"center\", \"edges\"}\n Coordinate center or edges\n axis_name : str\n Axis name for which mode='edges' applies\n\n Returns\n -------\n coords : dict of `~astropy.units.Quanity`\n Map coordinates\n \"\"\"\n coords = {}\n\n for shape, axis in self.iter_with_reshape:\n if mode == \"edges\" and axis.name == axis_name:\n coord = axis.edges\n else:\n coord = axis.center\n coords[axis.name] = coord.reshape(shape)\n\n return coords\n\n def bin_volume(self):\n \"\"\"Bin axes volume\n\n Returns\n -------\n bin_volume : `~astropy.units.Quantity`\n Bin volume\n \"\"\"\n bin_volume = np.array(1)\n\n for shape, axis in self.iter_with_reshape:\n bin_volume = bin_volume * axis.bin_width.reshape(shape)\n\n return bin_volume\n\n @property\n def shape(self):\n \"\"\"Shape of the axes\"\"\"\n return tuple([ax.nbin for ax in self])\n\n @property\n def names(self):\n \"\"\"Names of the axes\"\"\"\n return [ax.name for ax in self]\n\n def index(self, axis_name):\n \"\"\"Get index in list\"\"\"\n return self.names.index(axis_name)\n\n def index_data(self, axis_name):\n \"\"\"Get data index of the axes\n\n Parameters\n ----------\n axis_name : str\n Name of the axis.\n\n Returns\n -------\n idx : int\n Data index\n \"\"\"\n idx = self.names.index(axis_name)\n return len(self) - idx - 1\n\n def __len__(self):\n return len(self._axes)\n\n def __add__(self, other):\n return self.__class__(list(self) + list(other))\n\n def upsample(self, factor, axis_name):\n \"\"\"Upsample axis by a given factor\n\n Parameters\n ----------\n factor : int\n Upsampling factor.\n axis_name : str\n Axis to upsample.\n\n Returns\n -------\n axes : `MapAxes`\n Map axes\n \"\"\"\n axes = []\n\n for ax in self:\n if ax.name == axis_name:\n ax = ax.upsample(factor=factor)\n\n axes.append(ax.copy())\n\n return self.__class__(axes=axes)\n\n def replace(self, axis):\n \"\"\"Replace a give axis\n\n Parameters\n ----------\n axis : `MapAxis`\n Map axis\n\n Returns\n -------\n axes : MapAxes\n Map axe\n \"\"\"\n axes = []\n\n for ax in self:\n if ax.name == axis.name:\n ax = axis\n\n axes.append(ax)\n\n return self.__class__(axes=axes)\n\n def resample(self, axis):\n \"\"\"Resample axis binning.\n\n This method groups the existing bins into a new binning.\n\n Parameters\n ----------\n axis : `MapAxis`\n New map axis.\n\n Returns\n -------\n axes : `MapAxes`\n Axes object with resampled axis.\n \"\"\"\n axis_self = self[axis.name]\n groups = axis_self.group_table(axis.edges)\n\n # Keep only normal bins\n groups = groups[groups[\"bin_type\"] == \"normal \"]\n\n edges = edges_from_lo_hi(\n groups[axis.name + \"_min\"].quantity, groups[axis.name + \"_max\"].quantity,\n )\n\n axis_resampled = MapAxis.from_edges(\n edges=edges, interp=axis.interp, name=axis.name\n )\n\n axes = []\n for ax in self:\n if ax.name == axis.name:\n axes.append(axis_resampled)\n else:\n axes.append(ax.copy())\n\n return self.__class__(axes=axes)\n\n def downsample(self, factor, axis_name):\n \"\"\"Downsample axis by a given factor\n\n Parameters\n ----------\n factor : int\n Upsampling factor.\n axis_name : str\n Axis to upsample.\n\n Returns\n -------\n axes : `MapAxes`\n Map axes\n\n \"\"\"\n axes = []\n\n for ax in self:\n if ax.name == axis_name:\n ax = ax.downsample(factor=factor)\n\n axes.append(ax.copy())\n\n return self.__class__(axes=axes)\n\n def squash(self, axis_name):\n \"\"\"Squash axis.\n\n Parameters\n ----------\n axis_name : str\n Axis to squash.\n\n Returns\n -------\n axes : `MapAxes`\n Axes with squashed axis.\n \"\"\"\n axes = []\n\n for ax in self:\n if ax.name == axis_name:\n ax = ax.squash()\n axes.append(ax.copy())\n\n return self.__class__(axes=axes)\n\n def pad(self, axis_name, pad_width):\n \"\"\"Pad axes\n\n Parameters\n ----------\n axis_name : str\n Name of the axis to pad.\n pad_width : int or tuple of int\n Pad width\n\n Returns\n -------\n axes : `MapAxes`\n Axes with squashed axis.\n\n \"\"\"\n axes = []\n\n for ax in self:\n if ax.name == axis_name:\n ax = ax.pad(pad_width=pad_width)\n axes.append(ax)\n\n return self.__class__(axes=axes)\n\n def drop(self, axis_name):\n \"\"\"Drop an axis.\n\n Parameters\n ----------\n axis_name : str\n Name of the axis to remove.\n\n Returns\n -------\n axes : `MapAxes`\n Axes with squashed axis.\n \"\"\"\n axes = []\n for ax in self:\n if ax.name == axis_name:\n continue\n axes.append(ax.copy())\n\n return self.__class__(axes=axes)\n\n def __getitem__(self, idx):\n if isinstance(idx, (int, slice)):\n return self._axes[idx]\n elif isinstance(idx, str):\n for ax in self._axes:\n if ax.name == idx:\n return ax\n raise KeyError(f\"No axes: {idx!r}\")\n elif isinstance(idx, list):\n axes = []\n for name in idx:\n axes.append(self[name])\n\n return self.__class__(axes=axes)\n else:\n raise TypeError(f\"Invalid type: {type(idx)!r}\")\n\n def coord_to_idx(self, coord, clip=True):\n \"\"\"Transform from axis to pixel indices.\n\n Parameters\n ----------\n coord : dict of `~numpy.ndarray` or `MapCoord`\n Array of axis coordinate values.\n\n Returns\n -------\n pix : tuple of `~numpy.ndarray`\n Array of pixel indices values.\n \"\"\"\n return tuple([ax.coord_to_idx(coord[ax.name], clip=clip) for ax in self])\n\n def coord_to_pix(self, coord):\n \"\"\"Transform from axis to pixel coordinates.\n\n Parameters\n ----------\n coord : dict of `~numpy.ndarray`\n Array of axis coordinate values.\n\n Returns\n -------\n pix : tuple of `~numpy.ndarray`\n Array of pixel coordinate values.\n \"\"\"\n return tuple([ax.coord_to_pix(coord[ax.name]) for ax in self])\n\n def pix_to_coord(self, pix):\n \"\"\"Convert pixel coordinates to map coordinates.\n\n Parameters\n ----------\n pix : tuple\n Tuple of pixel coordinates.\n\n Returns\n -------\n coords : tuple\n Tuple of map coordinates.\n \"\"\"\n return tuple([ax.pix_to_coord(p) for ax, p in zip(self, pix)])\n\n def pix_to_idx(self, pix, clip=False):\n \"\"\"Convert pix to idx\n\n Parameters\n ----------\n pix : tuple of `~numpy.ndarray`\n Pixel coordinates.\n clip : bool\n Choose whether to clip indices to the valid range of the\n axis. If false then indices for coordinates outside\n the axi range will be set -1.\n\n Returns\n -------\n idx : tuple `~numpy.ndarray`\n Pixel indices.\n \"\"\"\n idx = []\n\n for pix_array, ax in zip(pix, self):\n idx.append(ax.pix_to_idx(pix_array, clip=clip))\n\n return tuple(idx)\n\n def slice_by_idx(self, slices):\n \"\"\"Create a new geometry by slicing the non-spatial axes.\n\n Parameters\n ----------\n slices : dict\n Dict of axes names and integers or `slice` object pairs. Contains one\n element for each non-spatial dimension. For integer indexing the\n corresponding axes is dropped from the map. Axes not specified in the\n dict are kept unchanged.\n\n Returns\n -------\n geom : `~Geom`\n Sliced geometry.\n \"\"\"\n axes = []\n for ax in self:\n ax_slice = slices.get(ax.name, slice(None))\n\n # in the case where isinstance(ax_slice, int) the axes is dropped\n if isinstance(ax_slice, slice):\n ax_sliced = ax.slice(ax_slice)\n axes.append(ax_sliced.copy())\n\n return self.__class__(axes=axes)\n\n def to_header(self, format=\"gadf\"):\n \"\"\"Convert axes to FITS header\n\n Parameters\n ----------\n format : {\"gadf\"}\n Header format\n\n Returns\n -------\n header : `~astropy.io.fits.Header`\n FITS header.\n \"\"\"\n header = fits.Header()\n\n for idx, ax in enumerate(self, start=1):\n header_ax = ax.to_header(format=format, idx=idx)\n header.update(header_ax)\n\n return header\n\n def to_table(self, format=\"gadf\"):\n \"\"\"Convert axes to table\n\n Parameters\n ----------\n format : {\"gadf\", \"gadf-dl3\", \"fgst-ccube\", \"fgst-template\", \"ogip\", \"ogip-sherpa\", \"ogip-arf\", \"ogip-arf-sherpa\"}\n Format to use.\n\n Returns\n -------\n table : `~astropy.table.Table`\n Table with axis data\n \"\"\"\n if format == \"gadf-dl3\":\n tables = []\n\n for ax in self:\n tables.append(ax.to_table(format=format))\n\n table = hstack(tables)\n elif format in [\"gadf\", \"fgst-ccube\", \"fgst-template\"]:\n table = Table()\n table[\"CHANNEL\"] = np.arange(np.prod(self.shape))\n\n axes_ctr = np.meshgrid(*[ax.center for ax in self])\n axes_min = np.meshgrid(*[ax.edges[:-1] for ax in self])\n axes_max = np.meshgrid(*[ax.edges[1:] for ax in self])\n\n for idx, ax in enumerate(self):\n name = ax.name.upper()\n\n if name == \"ENERGY\":\n colnames = [\"ENERGY\", \"E_MIN\", \"E_MAX\"]\n else:\n colnames = [name, name + \"_MIN\", name + \"_MAX\"]\n\n for colname, v in zip(colnames, [axes_ctr, axes_min, axes_max]):\n table[colname] = np.ravel(v[idx]).astype(np.float32)\n elif format in [\"ogip\", \"ogip-sherpa\", \"ogip\", \"ogip-arf\"]:\n energy_axis = self[\"energy\"]\n table = energy_axis.to_table(format=format)\n else:\n raise ValueError(f\"Unsupported format: '{format}'\")\n\n return table\n\n def to_table_hdu(self, format=\"gadf\", hdu_bands=None):\n \"\"\"Make FITS table columns for map axes.\n\n Parameters\n ----------\n format : {\"gadf\", \"fgst-ccube\", \"fgst-template\"}\n Format to use.\n hdu_bands : str\n Name of the bands HDU to use.\n\n Returns\n -------\n hdu : `~astropy.io.fits.BinTableHDU`\n Bin table HDU.\n \"\"\"\n # FIXME: Check whether convention is compatible with\n # dimensionality of geometry and simplify!!!\n\n if format in [\"fgst-ccube\", \"ogip\", \"ogip-sherpa\"]:\n hdu_bands = \"EBOUNDS\"\n elif format == \"fgst-template\":\n hdu_bands = \"ENERGIES\"\n elif format == \"gadf\" or format is None:\n if hdu_bands is None:\n hdu_bands = \"BANDS\"\n else:\n raise ValueError(f\"Unknown format {format}\")\n\n table = self.to_table(format=format)\n header = self.to_header(format=format)\n return fits.BinTableHDU(table, name=hdu_bands, header=header)\n\n @classmethod\n def from_table_hdu(cls, hdu, format=\"gadf\"):\n \"\"\"Create MapAxes from BinTableHDU\n\n Parameters\n ----------\n hdu : `~astropy.io.fits.BinTableHDU`\n Bin table HDU\n\n\n Returns\n -------\n axes : `MapAxes`\n Map axes object\n \"\"\"\n if hdu is None:\n return cls([])\n\n table = Table.read(hdu)\n return cls.from_table(table, format=format)\n\n @classmethod\n def from_table(cls, table, format=\"gadf\"):\n \"\"\"Create MapAxes from BinTableHDU\n\n Parameters\n ----------\n table : `~astropy.table.Table`\n Bin table HDU\n format : {\"gadf\", \"gadf-dl3\", \"fgst-ccube\", \"fgst-template\", \"fgst-bexcube\", \"ogip-arf\"}\n Format to use.\n\n Returns\n -------\n axes : `MapAxes`\n Map axes object\n \"\"\"\n from gammapy.irf.io import IRF_DL3_AXES_SPECIFICATION\n\n axes = []\n\n # Formats that support only one energy axis\n if format in [\n \"fgst-ccube\",\n \"fgst-template\",\n \"fgst-bexpcube\",\n \"ogip\",\n \"ogip-arf\",\n ]:\n axes.append(MapAxis.from_table(table, format=format))\n elif format == \"gadf\":\n # This limits the max number of axes to 5\n for idx in range(5):\n axcols = table.meta.get(\"AXCOLS{}\".format(idx + 1))\n if axcols is None:\n break\n\n axis = MapAxis.from_table(table, format=format, idx=idx)\n axes.append(axis)\n elif format == \"gadf-dl3\":\n for column_prefix in IRF_DL3_AXES_SPECIFICATION.keys():\n try:\n axis = MapAxis.from_table(\n table, format=format, column_prefix=column_prefix\n )\n except KeyError:\n continue\n axes.append(axis)\n else:\n raise ValueError(f\"Unsupported format: '{format}'\")\n\n return cls(axes)\n\n @classmethod\n def from_default(cls, axes, n_spatial_axes=None):\n \"\"\"Make a sequence of `~MapAxis` objects.\"\"\"\n if axes is None:\n return cls([])\n\n axes_out = []\n for idx, ax in enumerate(axes):\n if isinstance(ax, np.ndarray):\n ax = MapAxis(ax)\n\n if ax.name == \"\":\n ax.name = f\"axis{idx}\"\n\n axes_out.append(ax)\n\n return cls(axes_out, n_spatial_axes=n_spatial_axes)\n\n def assert_names(self, required_names):\n \"\"\"Assert required axis names and order\n\n Parameters\n ----------\n required_names : list of str\n Required\n \"\"\"\n message = (\"Incorrect axis order or names. Expected axis \"\n f\"order: {required_names}, got: {self.names}.\")\n\n if not len(self) == len(required_names):\n raise ValueError(message)\n\n try:\n for ax, required_name in zip(self, required_names):\n ax.assert_name(required_name)\n\n except ValueError:\n raise ValueError(message)\n\n @property\n def center_coord(self):\n \"\"\"Center coordinates\"\"\"\n return tuple([ax.pix_to_coord((float(ax.nbin) - 1.0) / 2.0) for ax in self])\n\n\nclass MapAxis:\n \"\"\"Class representing an axis of a map.\n\n Provides methods for\n transforming to/from axis and pixel coordinates. An axis is\n defined by a sequence of node values that lie at the center of\n each bin. The pixel coordinate at each node is equal to its index\n in the node array (0, 1, ..). Bin edges are offset by 0.5 in\n pixel coordinates from the nodes such that the lower/upper edge of\n the first bin is (-0.5,0.5).\n\n Parameters\n ----------\n nodes : `~numpy.ndarray` or `~astropy.units.Quantity`\n Array of node values. These will be interpreted as either bin\n edges or centers according to ``node_type``.\n interp : str\n Interpolation method used to transform between axis and pixel\n coordinates. Valid options are 'log', 'lin', and 'sqrt'.\n name : str\n Axis name\n node_type : str\n Flag indicating whether coordinate nodes correspond to pixel\n edges (node_type = 'edge') or pixel centers (node_type =\n 'center'). 'center' should be used where the map values are\n defined at a specific coordinate (e.g. differential\n quantities). 'edge' should be used where map values are\n defined by an integral over coordinate intervals (e.g. a\n counts histogram).\n unit : str\n String specifying the data units.\n \"\"\"\n\n # TODO: Cache an interpolation object?\n def __init__(self, nodes, interp=\"lin\", name=\"\", node_type=\"edges\", unit=\"\"):\n self._name = name\n\n if len(nodes) != len(np.unique(nodes)):\n raise ValueError(\"MapAxis: node values must be unique\")\n\n if ~(np.all(nodes == np.sort(nodes)) or np.all(nodes[::-1] == np.sort(nodes))):\n raise ValueError(\"MapAxis: node values must be sorted\")\n\n if len(nodes) == 1 and node_type == \"center\":\n raise ValueError(\"Single bins can only be used with node-type 'edges'\")\n\n if isinstance(nodes, u.Quantity):\n unit = nodes.unit if nodes.unit is not None else \"\"\n nodes = nodes.value\n else:\n nodes = np.array(nodes)\n\n self._unit = u.Unit(unit)\n self._nodes = nodes.astype(float)\n self._node_type = node_type\n self._interp = interp\n\n if (self._nodes < 0).any() and interp != \"lin\":\n raise ValueError(\n f\"Interpolation scaling {interp!r} only support for positive node values.\"\n )\n\n # Set pixel coordinate of first node\n if node_type == \"edges\":\n self._pix_offset = -0.5\n nbin = len(nodes) - 1\n elif node_type == \"center\":\n self._pix_offset = 0.0\n nbin = len(nodes)\n else:\n raise ValueError(f\"Invalid node type: {node_type!r}\")\n\n self._nbin = nbin\n\n def assert_name(self, required_name):\n \"\"\"Assert axis name if a specific one is required.\n\n Parameters\n ----------\n required_name : str\n Required\n \"\"\"\n if self.name != required_name:\n raise ValueError(\n \"Unexpected axis name,\"\n f' expected \"{required_name}\", got: \"{self.name}\"'\n )\n\n def is_aligned(self, other, atol=2e-2):\n \"\"\"Check if other map axis is aligned.\n\n Two axes are aligned if their center coordinate values map to integers\n on the other axes as well and if the interpolation modes are equivalent.\n\n Parameters\n ----------\n other : `MapAxis`\n Other map axis.\n atol : float\n Absolute numerical tolerance for the comparison measured in bins.\n\n Returns\n -------\n aligned : bool\n Whether the axes are aligned\n \"\"\"\n pix = self.coord_to_pix(other.center)\n pix_other = other.coord_to_pix(self.center)\n pix_all = np.append(pix, pix_other)\n aligned = np.allclose(np.round(pix_all) - pix_all, 0, atol=atol)\n return aligned and self.interp == other.interp\n\n def __eq__(self, other):\n if not isinstance(other, self.__class__):\n return NotImplemented\n\n # TODO: implement an allclose method for MapAxis and call it here\n if self.edges.shape != other.edges.shape:\n return False\n if self.unit.is_equivalent(other.unit) is False:\n return False\n return (\n np.allclose(\n self.edges.to(other.unit).value, other.edges.value, atol=1e-6, rtol=1e-6\n )\n and self._node_type == other._node_type\n and self._interp == other._interp\n and self.name.upper() == other.name.upper()\n )\n\n def __ne__(self, other):\n return not self.__eq__(other)\n\n def __hash__(self):\n return id(self)\n\n @property\n def is_energy_axis(self):\n return self.name in [\"energy\", \"energy_true\"]\n\n @property\n def interp(self):\n \"\"\"Interpolation scale of the axis.\"\"\"\n return self._interp\n\n @property\n def name(self):\n \"\"\"Name of the axis.\"\"\"\n return self._name\n\n @name.setter\n def name(self, value):\n \"\"\"Name of the axis.\"\"\"\n self._name = value\n\n @lazyproperty\n def edges(self):\n \"\"\"Return array of bin edges.\"\"\"\n pix = np.arange(self.nbin + 1, dtype=float) - 0.5\n return u.Quantity(self.pix_to_coord(pix), self._unit, copy=False)\n\n @property\n def as_xerr(self):\n \"\"\"Return tuple of xerr to be used with plt.errorbar()\"\"\"\n return (\n self.center - self.edges[:-1],\n self.edges[1:] - self.center,\n )\n\n @property\n def iter_by_edges(self):\n \"\"\"Iterate by intervals defined by the edges\"\"\"\n for value_min, value_max in zip(self.edges[:-1], self.edges[1:]):\n yield (value_min, value_max)\n\n @lazyproperty\n def center(self):\n \"\"\"Return array of bin centers.\"\"\"\n pix = np.arange(self.nbin, dtype=float)\n return u.Quantity(self.pix_to_coord(pix), self._unit, copy=False)\n\n @lazyproperty\n def bin_width(self):\n \"\"\"Array of bin widths.\"\"\"\n return np.diff(self.edges)\n\n @property\n def nbin(self):\n \"\"\"Return number of bins.\"\"\"\n return self._nbin\n\n @property\n def nbin_per_decade(self):\n \"\"\"Return number of bins.\"\"\"\n if self.interp != \"log\":\n raise ValueError(\"Bins per decade can only be computed for log-spaced axes\")\n\n if self.node_type == \"edges\":\n values = self.edges\n else:\n values = self.center\n\n ndecades = np.log10(values.max() / values.min())\n return (self._nbin / ndecades).value\n\n @property\n def node_type(self):\n \"\"\"Return node type ('center' or 'edge').\"\"\"\n return self._node_type\n\n @property\n def unit(self):\n \"\"\"Return coordinate axis unit.\"\"\"\n return self._unit\n\n @classmethod\n def from_bounds(cls, lo_bnd, hi_bnd, nbin, **kwargs):\n \"\"\"Generate an axis object from a lower/upper bound and number of bins.\n\n If node_type = 'edge' then bounds correspond to the\n lower and upper bound of the first and last bin. If node_type\n = 'center' then bounds correspond to the centers of the first\n and last bin.\n\n Parameters\n ----------\n lo_bnd : float\n Lower bound of first axis bin.\n hi_bnd : float\n Upper bound of last axis bin.\n nbin : int\n Number of bins.\n interp : {'lin', 'log', 'sqrt'}\n Interpolation method used to transform between axis and pixel\n coordinates. Default: 'lin'.\n \"\"\"\n nbin = int(nbin)\n interp = kwargs.setdefault(\"interp\", \"lin\")\n node_type = kwargs.setdefault(\"node_type\", \"edges\")\n\n if node_type == \"edges\":\n nnode = nbin + 1\n elif node_type == \"center\":\n nnode = nbin\n else:\n raise ValueError(f\"Invalid node type: {node_type!r}\")\n\n if interp == \"lin\":\n nodes = np.linspace(lo_bnd, hi_bnd, nnode)\n elif interp == \"log\":\n nodes = np.exp(np.linspace(np.log(lo_bnd), np.log(hi_bnd), nnode))\n elif interp == \"sqrt\":\n nodes = np.linspace(lo_bnd ** 0.5, hi_bnd ** 0.5, nnode) ** 2.0\n else:\n raise ValueError(f\"Invalid interp: {interp}\")\n\n return cls(nodes, **kwargs)\n\n @classmethod\n def from_energy_edges(cls, energy_edges, unit=None, name=None, interp=\"log\"):\n \"\"\"Make an energy axis from adjacent edges.\n\n Parameters\n ----------\n energy_edges : `~astropy.units.Quantity`, float\n Energy edges\n unit : `~astropy.units.Unit`\n Energy unit\n name : str\n Name of the energy axis, either 'energy' or 'energy_true'\n interp: str\n interpolation mode. Default is 'log'.\n\n Returns\n -------\n axis : `MapAxis`\n Axis with name \"energy\" and interp \"log\".\n \"\"\"\n energy_edges = u.Quantity(energy_edges, unit)\n\n if unit is None:\n unit = energy_edges.unit\n energy_edges = energy_edges.to(unit)\n\n if name is None:\n name = \"energy\"\n\n if name not in [\"energy\", \"energy_true\"]:\n raise ValueError(\"Energy axis can only be named 'energy' or 'energy_true'\")\n\n return cls.from_edges(energy_edges, unit=unit, interp=interp, name=name)\n\n @classmethod\n def from_energy_bounds(\n cls,\n energy_min,\n energy_max,\n nbin,\n unit=None,\n per_decade=False,\n name=None,\n node_type=\"edges\",\n ):\n \"\"\"Make an energy axis.\n\n Used frequently also to make energy grids, by making\n the axis, and then using ``axis.center`` or ``axis.edges``.\n\n Parameters\n ----------\n energy_min, energy_max : `~astropy.units.Quantity`, float\n Energy range\n nbin : int\n Number of bins\n unit : `~astropy.units.Unit`\n Energy unit\n per_decade : bool\n Whether `nbin` is given per decade.\n name : str\n Name of the energy axis, either 'energy' or 'energy_true'\n\n Returns\n -------\n axis : `MapAxis`\n Axis with name \"energy\" and interp \"log\".\n \"\"\"\n energy_min = u.Quantity(energy_min, unit)\n energy_max = u.Quantity(energy_max, unit)\n\n if unit is None:\n unit = energy_max.unit\n energy_min = energy_min.to(unit)\n\n if per_decade:\n nbin = np.ceil(np.log10(energy_max / energy_min).value * nbin)\n\n if name is None:\n name = \"energy\"\n\n if name not in [\"energy\", \"energy_true\"]:\n raise ValueError(\"Energy axis can only be named 'energy' or 'energy_true'\")\n\n return cls.from_bounds(\n energy_min.value,\n energy_max.value,\n nbin=nbin,\n unit=unit,\n interp=\"log\",\n name=name,\n node_type=node_type,\n )\n\n @classmethod\n def from_nodes(cls, nodes, **kwargs):\n \"\"\"Generate an axis object from a sequence of nodes (bin centers).\n\n This will create a sequence of bins with edges half-way\n between the node values. This method should be used to\n construct an axis where the bin center should lie at a\n specific value (e.g. a map of a continuous function).\n\n Parameters\n ----------\n nodes : `~numpy.ndarray`\n Axis nodes (bin center).\n interp : {'lin', 'log', 'sqrt'}\n Interpolation method used to transform between axis and pixel\n coordinates. Default: 'lin'.\n \"\"\"\n if len(nodes) < 1:\n raise ValueError(\"Nodes array must have at least one element.\")\n\n return cls(nodes, node_type=\"center\", **kwargs)\n\n @classmethod\n def from_edges(cls, edges, **kwargs):\n \"\"\"Generate an axis object from a sequence of bin edges.\n\n This method should be used to construct an axis where the bin\n edges should lie at specific values (e.g. a histogram). The\n number of bins will be one less than the number of edges.\n\n Parameters\n ----------\n edges : `~numpy.ndarray`\n Axis bin edges.\n interp : {'lin', 'log', 'sqrt'}\n Interpolation method used to transform between axis and pixel\n coordinates. Default: 'lin'.\n \"\"\"\n if len(edges) < 2:\n raise ValueError(\"Edges array must have at least two elements.\")\n\n return cls(edges, node_type=\"edges\", **kwargs)\n\n def append(self, axis):\n \"\"\"Append another map axis to this axis\n\n Name, interp type and node type must agree between the axes. If the node\n type is \"edges\", the edges must be contiguous and non-overlapping.\n\n Parameters\n ----------\n axis : `MapAxis`\n Axis to append.\n\n Returns\n -------\n axis : `MapAxis`\n Appended axis\n \"\"\"\n if self.node_type != axis.node_type:\n raise ValueError(\n f\"Node type must agree, got {self.node_type} and {axis.node_type}\"\n )\n\n if self.name != axis.name:\n raise ValueError(f\"Names must agree, got {self.name} and {axis.name} \")\n\n if self.interp != axis.interp:\n raise ValueError(\n f\"Interp type must agree, got {self.interp} and {axis.interp}\"\n )\n\n if self.node_type == \"edges\":\n edges = np.append(self.edges, axis.edges[1:])\n return self.from_edges(edges=edges, interp=self.interp, name=self.name)\n else:\n nodes = np.append(self.center, axis.center)\n return self.from_nodes(nodes=nodes, interp=self.interp, name=self.name)\n\n def pad(self, pad_width):\n \"\"\"Pad axis by a given number of pixels\n\n Parameters\n ----------\n pad_width : int or tuple of int\n A single int pads in both direction of the axis, a tuple specifies,\n which number of bins to pad at the low and high edge of the axis.\n\n Returns\n -------\n axis : `MapAxis`\n Padded axis\n \"\"\"\n if isinstance(pad_width, tuple):\n pad_low, pad_high = pad_width\n else:\n pad_low, pad_high = pad_width, pad_width\n\n if self.node_type == \"edges\":\n pix = np.arange(-pad_low, self.nbin + pad_high + 1) - 0.5\n edges = self.pix_to_coord(pix)\n return self.from_edges(edges=edges, interp=self.interp, name=self.name)\n else:\n pix = np.arange(-pad_low, self.nbin + pad_high)\n nodes = self.pix_to_coord(pix)\n return self.from_nodes(nodes=nodes, interp=self.interp, name=self.name)\n\n @classmethod\n def from_stack(cls, axes):\n \"\"\"Create a map axis by merging a list of other map axes.\n\n If the node type is \"edges\" the bin edges in the provided axes must be\n contiguous and non-overlapping.\n\n Parameters\n ----------\n axes : list of `MapAxis`\n List of map axis to merge.\n\n Returns\n -------\n axis : `MapAxis`\n Merged axis\n \"\"\"\n ax_stacked = axes[0]\n\n for ax in axes[1:]:\n ax_stacked = ax_stacked.append(ax)\n\n return ax_stacked\n\n def pix_to_coord(self, pix):\n \"\"\"Transform from pixel to axis coordinates.\n\n Parameters\n ----------\n pix : `~numpy.ndarray`\n Array of pixel coordinate values.\n\n Returns\n -------\n coord : `~numpy.ndarray`\n Array of axis coordinate values.\n \"\"\"\n pix = pix - self._pix_offset\n values = pix_to_coord(self._nodes, pix, interp=self._interp)\n return u.Quantity(values, unit=self.unit, copy=False)\n\n def pix_to_idx(self, pix, clip=False):\n \"\"\"Convert pix to idx\n\n Parameters\n ----------\n pix : `~numpy.ndarray`\n Pixel coordinates.\n clip : bool\n Choose whether to clip indices to the valid range of the\n axis. If false then indices for coordinates outside\n the axi range will be set -1.\n\n Returns\n -------\n idx : `~numpy.ndarray`\n Pixel indices.\n \"\"\"\n if clip:\n idx = np.clip(pix, 0, self.nbin - 1)\n else:\n condition = (pix < 0) | (pix >= self.nbin)\n idx = np.where(condition, -1, pix)\n\n return idx\n\n def coord_to_pix(self, coord):\n \"\"\"Transform from axis to pixel coordinates.\n\n Parameters\n ----------\n coord : `~numpy.ndarray`\n Array of axis coordinate values.\n\n Returns\n -------\n pix : `~numpy.ndarray`\n Array of pixel coordinate values.\n \"\"\"\n coord = u.Quantity(coord, self.unit, copy=False).value\n pix = coord_to_pix(self._nodes, coord, interp=self._interp)\n return np.array(pix + self._pix_offset, ndmin=1)\n\n def coord_to_idx(self, coord, clip=False):\n \"\"\"Transform from axis coordinate to bin index.\n\n Parameters\n ----------\n coord : `~numpy.ndarray`\n Array of axis coordinate values.\n clip : bool\n Choose whether to clip the index to the valid range of the\n axis. If false then indices for values outside the axis\n range will be set -1.\n\n Returns\n -------\n idx : `~numpy.ndarray`\n Array of bin indices.\n \"\"\"\n coord = u.Quantity(coord, self.unit, copy=False, ndmin=1).value\n edges = self.edges.value\n idx = np.digitize(coord, edges) - 1\n\n if clip:\n idx = np.clip(idx, 0, self.nbin - 1)\n else:\n with np.errstate(invalid=\"ignore\"):\n idx[coord > edges[-1]] = INVALID_INDEX.int\n\n idx[~np.isfinite(coord)] = INVALID_INDEX.int\n\n return idx\n\n def slice(self, idx):\n \"\"\"Create a new axis object by extracting a slice from this axis.\n\n Parameters\n ----------\n idx : slice\n Slice object selecting a subselection of the axis.\n\n Returns\n -------\n axis : `~MapAxis`\n Sliced axis object.\n \"\"\"\n center = self.center[idx].value\n idx = self.coord_to_idx(center)\n # For edge nodes we need to keep N+1 nodes\n if self._node_type == \"edges\":\n idx = tuple(list(idx) + [1 + idx[-1]])\n\n nodes = self._nodes[(idx,)]\n return MapAxis(\n nodes,\n interp=self._interp,\n name=self._name,\n node_type=self._node_type,\n unit=self._unit,\n )\n\n def squash(self):\n \"\"\"Create a new axis object by squashing the axis into one bin.\n\n Returns\n -------\n axis : `~MapAxis`\n Sliced axis object.\n \"\"\"\n # TODO: Decide on handling node_type=center\n # See https://github.com/gammapy/gammapy/issues/1952\n return MapAxis.from_bounds(\n lo_bnd=self.edges[0].value,\n hi_bnd=self.edges[-1].value,\n nbin=1,\n interp=self._interp,\n name=self._name,\n unit=self._unit,\n )\n\n def __repr__(self):\n str_ = self.__class__.__name__\n str_ += \"\\n\\n\"\n fmt = \"\\t{:<10s} : {:<10s}\\n\"\n str_ += fmt.format(\"name\", self.name)\n str_ += fmt.format(\"unit\", \"{!r}\".format(str(self.unit)))\n str_ += fmt.format(\"nbins\", str(self.nbin))\n str_ += fmt.format(\"node type\", self.node_type)\n vals = self.edges if self.node_type == \"edges\" else self.center\n str_ += fmt.format(f\"{self.node_type} min\", \"{:.1e}\".format(vals.min()))\n str_ += fmt.format(f\"{self.node_type} max\", \"{:.1e}\".format(vals.max()))\n str_ += fmt.format(\"interp\", self._interp)\n return str_\n\n def _init_copy(self, **kwargs):\n \"\"\"Init map axis instance by copying missing init arguments from self.\n \"\"\"\n argnames = inspect.getfullargspec(self.__init__).args\n argnames.remove(\"self\")\n\n for arg in argnames:\n value = getattr(self, \"_\" + arg)\n kwargs.setdefault(arg, copy.deepcopy(value))\n\n return self.__class__(**kwargs)\n\n def copy(self, **kwargs):\n \"\"\"Copy `MapAxis` instance and overwrite given attributes.\n\n Parameters\n ----------\n **kwargs : dict\n Keyword arguments to overwrite in the map axis constructor.\n\n Returns\n -------\n copy : `MapAxis`\n Copied map axis.\n \"\"\"\n return self._init_copy(**kwargs)\n\n def round(self, coord, clip=False):\n \"\"\"Round coord to nearest axis edge.\n\n Parameters\n ----------\n coord : `~astropy.units.Quantity`\n Coordinates\n clip : bool\n Choose whether to clip indices to the valid range of the axis.\n\n Returns\n -------\n coord : `~astropy.units.Quantity`\n Rounded coordinates\n \"\"\"\n edges_pix = self.coord_to_pix(coord)\n\n if clip:\n edges_pix = np.clip(edges_pix, -0.5, self.nbin - 0.5)\n\n edges_idx = np.round(edges_pix + 0.5) - 0.5\n return self.pix_to_coord(edges_idx)\n\n def group_table(self, edges):\n \"\"\"Compute bin groups table for the map axis, given coarser bin edges.\n\n Parameters\n ----------\n edges : `~astropy.units.Quantity`\n Group bin edges.\n\n Returns\n -------\n groups : `~astropy.table.Table`\n Map axis group table.\n \"\"\"\n # TODO: try to simplify this code\n if not self.node_type == \"edges\":\n raise ValueError(\"Only edge based map axis can be grouped\")\n\n edges_pix = self.coord_to_pix(edges)\n edges_pix = np.clip(edges_pix, -0.5, self.nbin - 0.5)\n edges_idx = np.round(edges_pix + 0.5) - 0.5\n edges_idx = np.unique(edges_idx)\n edges_ref = self.pix_to_coord(edges_idx)\n\n groups = Table()\n groups[f\"{self.name}_min\"] = edges_ref[:-1]\n groups[f\"{self.name}_max\"] = edges_ref[1:]\n\n groups[\"idx_min\"] = (edges_idx[:-1] + 0.5).astype(int)\n groups[\"idx_max\"] = (edges_idx[1:] - 0.5).astype(int)\n\n if len(groups) == 0:\n raise ValueError(\"No overlap between reference and target edges.\")\n\n groups[\"bin_type\"] = \"normal \"\n\n edge_idx_start, edge_ref_start = edges_idx[0], edges_ref[0]\n if edge_idx_start > 0:\n underflow = {\n \"bin_type\": \"underflow\",\n \"idx_min\": 0,\n \"idx_max\": edge_idx_start,\n f\"{self.name}_min\": self.pix_to_coord(-0.5),\n f\"{self.name}_max\": edge_ref_start,\n }\n groups.insert_row(0, vals=underflow)\n\n edge_idx_end, edge_ref_end = edges_idx[-1], edges_ref[-1]\n\n if edge_idx_end < (self.nbin - 0.5):\n overflow = {\n \"bin_type\": \"overflow\",\n \"idx_min\": edge_idx_end + 1,\n \"idx_max\": self.nbin - 1,\n f\"{self.name}_min\": edge_ref_end,\n f\"{self.name}_max\": self.pix_to_coord(self.nbin - 0.5),\n }\n groups.add_row(vals=overflow)\n\n group_idx = Column(np.arange(len(groups)))\n groups.add_column(group_idx, name=\"group_idx\", index=0)\n return groups\n\n def upsample(self, factor):\n \"\"\"Upsample map axis by a given factor.\n\n When up-sampling for each node specified in the axis, the corresponding\n number of sub-nodes are introduced and preserving the initial nodes. For\n node type \"edges\" this results in nbin * factor new bins. For node type\n \"center\" this results in (nbin - 1) * factor + 1 new bins.\n\n Parameters\n ----------\n factor : int\n Upsampling factor.\n\n Returns\n -------\n axis : `MapAxis`\n Usampled map axis.\n\n \"\"\"\n if self.node_type == \"edges\":\n pix = self.coord_to_pix(self.edges)\n nbin = int(self.nbin * factor) + 1\n pix_new = np.linspace(pix.min(), pix.max(), nbin)\n edges = self.pix_to_coord(pix_new)\n return self.from_edges(edges, name=self.name, interp=self.interp)\n else:\n pix = self.coord_to_pix(self.center)\n nbin = int((self.nbin - 1) * factor) + 1\n pix_new = np.linspace(pix.min(), pix.max(), nbin)\n nodes = self.pix_to_coord(pix_new)\n return self.from_nodes(nodes, name=self.name, interp=self.interp)\n\n def downsample(self, factor):\n \"\"\"Downsample map axis by a given factor.\n\n When down-sampling each n-th (given by the factor) bin is selected from\n the axis while preserving the axis limits. For node type \"edges\" this\n requires nbin to be dividable by the factor, for node type \"center\" this\n requires nbin - 1 to be dividable by the factor.\n\n Parameters\n ----------\n factor : int\n Downsampling factor.\n\n\n Returns\n -------\n axis : `MapAxis`\n Downsampled map axis.\n \"\"\"\n if self.node_type == \"edges\":\n nbin = self.nbin / factor\n\n if np.mod(nbin, 1) > 0:\n raise ValueError(\n f\"Number of {self.name} bins is not divisible by {factor}\"\n )\n\n edges = self.edges[::factor]\n return self.from_edges(edges, name=self.name, interp=self.interp)\n else:\n nbin = (self.nbin - 1) / factor\n\n if np.mod(nbin, 1) > 0:\n raise ValueError(\n f\"Number of {self.name} bins - 1 is not divisible by {factor}\"\n )\n\n nodes = self.center[::factor]\n return self.from_nodes(nodes, name=self.name, interp=self.interp)\n\n def to_header(self, format=\"ogip\", idx=0):\n \"\"\"Create FITS header\n\n Parameters\n ----------\n format : {\"ogip\"}\n Format specification\n idx : int\n Column index of the axis.\n\n Returns\n -------\n header : `~astropy.io.fits.Header`\n Header to extend.\n \"\"\"\n header = fits.Header()\n\n if format in [\"ogip\", \"ogip-sherpa\"]:\n header[\"EXTNAME\"] = \"EBOUNDS\", \"Name of this binary table extension\"\n header[\"TELESCOP\"] = \"DUMMY\", \"Mission/satellite name\"\n header[\"INSTRUME\"] = \"DUMMY\", \"Instrument/detector\"\n header[\"FILTER\"] = \"None\", \"Filter information\"\n header[\"CHANTYPE\"] = \"PHA\", \"Type of channels (PHA, PI etc)\"\n header[\"DETCHANS\"] = self.nbin, \"Total number of detector PHA channels\"\n header[\"HDUCLASS\"] = \"OGIP\", \"Organisation devising file format\"\n header[\"HDUCLAS1\"] = \"RESPONSE\", \"File relates to response of instrument\"\n header[\"HDUCLAS2\"] = \"EBOUNDS\", \"This is an EBOUNDS extension\"\n header[\"HDUVERS\"] = \"1.2.0\", \"Version of file format\"\n elif format in [\"gadf\", \"fgst-ccube\", \"fgst-template\"]:\n key = f\"AXCOLS{idx}\"\n name = self.name.upper()\n\n if self.name == \"energy\" and self.node_type == \"edges\":\n header[key] = \"E_MIN,E_MAX\"\n elif self.name == \"energy\" and self.node_type == \"center\":\n header[key] = \"ENERGY\"\n elif self.node_type == \"edges\":\n header[key] = f\"{name}_MIN,{name}_MAX\"\n elif self.node_type == \"center\":\n header[key] = name\n else:\n raise ValueError(f\"Invalid node type {self.node_type!r}\")\n\n key_interp = f\"INTERP{idx}\"\n header[key_interp] = self.interp\n\n else:\n raise ValueError(f\"Unknown format {format}\")\n\n return header\n\n def to_table(self, format=\"ogip\"):\n \"\"\"Convert `~astropy.units.Quantity` to OGIP ``EBOUNDS`` extension.\n\n See https://heasarc.gsfc.nasa.gov/docs/heasarc/caldb/docs/memos/cal_gen_92_002/cal_gen_92_002.html#tth_sEc3.2\n\n The 'ogip-sherpa' format is equivalent to 'ogip' but uses keV energy units.\n\n Parameters\n ----------\n format : {\"ogip\", \"ogip-sherpa\", \"gadf-dl3\", \"gtpsf\"}\n Format specification\n\n Returns\n -------\n table : `~astropy.table.Table`\n Table HDU\n \"\"\"\n table = Table()\n edges = self.edges\n\n if format in [\"ogip\", \"ogip-sherpa\"]:\n self.assert_name(\"energy\")\n\n if format == \"ogip-sherpa\":\n edges = edges.to(\"keV\")\n\n table[\"CHANNEL\"] = np.arange(self.nbin, dtype=np.int16)\n table[\"E_MIN\"] = edges[:-1]\n table[\"E_MAX\"] = edges[1:]\n elif format in [\"ogip-arf\", \"ogip-arf-sherpa\"]:\n self.assert_name(\"energy_true\")\n\n if format == \"ogip-arf-sherpa\":\n edges = edges.to(\"keV\")\n\n table[\"ENERG_LO\"] = edges[:-1]\n table[\"ENERG_HI\"] = edges[1:]\n elif format == \"gadf-dl3\":\n from gammapy.irf.io import IRF_DL3_AXES_SPECIFICATION\n\n if self.name == \"energy\":\n column_prefix = \"ENERG\"\n else:\n for column_prefix, spec in IRF_DL3_AXES_SPECIFICATION.items():\n if spec[\"name\"] == self.name:\n break\n\n if self.node_type == \"edges\":\n edges_hi, edges_lo = edges[:-1], edges[1:]\n else:\n edges_hi, edges_lo = self.center, self.center\n\n table[f\"{column_prefix}_LO\"] = edges_hi[np.newaxis]\n table[f\"{column_prefix}_HI\"] = edges_lo[np.newaxis]\n elif format == \"gtpsf\":\n if self.name == \"energy_true\":\n table[\"Energy\"] = self.center.to(\"MeV\")\n elif self.name == \"rad\":\n table[\"Theta\"] = self.center.to(\"deg\")\n else:\n raise ValueError(\n \"Can only convert true energy or rad axis to\"\n f\"'gtpsf' format, got {self.name}\"\n )\n else:\n raise ValueError(f\"{format} is not a valid format\")\n\n return table\n\n def to_table_hdu(self, format=\"ogip\"):\n \"\"\"Convert `~astropy.units.Quantity` to OGIP ``EBOUNDS`` extension.\n\n See https://heasarc.gsfc.nasa.gov/docs/heasarc/caldb/docs/memos/cal_gen_92_002/cal_gen_92_002.html#tth_sEc3.2\n\n The 'ogip-sherpa' format is equivalent to 'ogip' but uses keV energy units.\n\n Parameters\n ----------\n format : {\"ogip\", \"ogip-sherpa\", \"gtpsf\"}\n Format specification\n\n Returns\n -------\n hdu : `~astropy.io.fits.BinTableHDU`\n Table HDU\n \"\"\"\n table = self.to_table(format=format)\n\n if format == \"gtpsf\":\n name = \"THETA\"\n else:\n name = None\n\n hdu = fits.BinTableHDU(table, name=name)\n\n if format in [\"ogip\", \"ogip-sherpa\"]:\n hdu.header.update(self.to_header(format=format))\n\n return hdu\n\n @classmethod\n def from_table(cls, table, format=\"ogip\", idx=0, column_prefix=\"\"):\n \"\"\"Instanciate MapAxis from table HDU\n\n Parameters\n ----------\n table : `~astropy.table.Table`\n Table\n format : {\"ogip\", \"ogip-arf\", \"fgst-ccube\", \"fgst-template\", \"gadf\", \"gadf-dl3\"}\n Format specification\n idx : int\n Column index of the axis.\n column_prefix : str\n Column name prefix of the axis, used for creating the axis.\n\n Returns\n -------\n axis : `MapAxis`\n Map Axis\n \"\"\"\n if format in [\"ogip\", \"fgst-ccube\"]:\n energy_min = table[\"E_MIN\"].quantity\n energy_max = table[\"E_MAX\"].quantity\n energy_edges = (\n np.append(energy_min.value, energy_max.value[-1]) * energy_min.unit\n )\n axis = cls.from_edges(energy_edges, name=\"energy\", interp=\"log\")\n\n elif format == \"ogip-arf\":\n energy_min = table[\"ENERG_LO\"].quantity\n energy_max = table[\"ENERG_HI\"].quantity\n energy_edges = (\n np.append(energy_min.value, energy_max.value[-1]) * energy_min.unit\n )\n axis = cls.from_edges(energy_edges, name=\"energy_true\", interp=\"log\")\n\n elif format in [\"fgst-template\", \"fgst-bexpcube\"]:\n allowed_names = [\"Energy\", \"ENERGY\", \"energy\"]\n for colname in table.colnames:\n if colname in allowed_names:\n tag = colname\n break\n\n nodes = table[tag].data\n axis = cls.from_nodes(\n nodes=nodes, name=\"energy_true\", unit=\"MeV\", interp=\"log\"\n )\n\n elif format == \"gadf\":\n axcols = table.meta.get(\"AXCOLS{}\".format(idx + 1))\n colnames = axcols.split(\",\")\n node_type = \"edges\" if len(colnames) == 2 else \"center\"\n\n # TODO: check why this extra case is needed\n if colnames[0] == \"E_MIN\":\n name = \"energy\"\n else:\n name = colnames[0].replace(\"_MIN\", \"\").lower()\n # this is need for backward compatibility\n if name == \"theta\":\n name = \"rad\"\n\n interp = table.meta.get(\"INTERP{}\".format(idx + 1), \"lin\")\n\n if node_type == \"center\":\n nodes = np.unique(table[colnames[0]].quantity)\n else:\n edges_min = np.unique(table[colnames[0]].quantity)\n edges_max = np.unique(table[colnames[1]].quantity)\n nodes = edges_from_lo_hi(edges_min, edges_max)\n\n axis = MapAxis(nodes=nodes, node_type=node_type, interp=interp, name=name)\n\n elif format == \"gadf-dl3\":\n from gammapy.irf.io import IRF_DL3_AXES_SPECIFICATION\n\n spec = IRF_DL3_AXES_SPECIFICATION[column_prefix]\n name, interp = spec[\"name\"], spec[\"interp\"]\n\n # background models are stored in reconstructed energy\n hduclass = table.meta.get(\"HDUCLAS2\")\n if hduclass == \"BKG\" and column_prefix == \"ENERG\":\n name = \"energy\"\n\n edges_lo = table[f\"{column_prefix}_LO\"].quantity[0]\n edges_hi = table[f\"{column_prefix}_HI\"].quantity[0]\n\n if np.allclose(edges_hi, edges_lo):\n axis = MapAxis.from_nodes(edges_hi, interp=interp, name=name)\n else:\n edges = edges_from_lo_hi(edges_lo, edges_hi)\n axis = MapAxis.from_edges(edges, interp=interp, name=name)\n elif format == \"gtpsf\":\n try:\n energy = table[\"Energy\"].data * u.MeV\n axis = MapAxis.from_nodes(energy, name=\"energy_true\", interp=\"log\")\n except KeyError:\n rad = table[\"Theta\"].data * u.deg\n axis = MapAxis.from_nodes(rad, name=\"rad\")\n elif format == \"gadf-sed\":\n sed_type = table.meta.get(\"SED_TYPE\")\n if sed_type in [\"dnde\", \"e2dnde\"]:\n e_ref = flat_if_equal(table[\"e_ref\"].quantity)\n axis = MapAxis.from_nodes(e_ref, name=\"energy\", interp=\"log\")\n else:\n e_min = flat_if_equal(table[\"e_min\"].quantity)\n e_max = flat_if_equal(table[\"e_max\"].quantity)\n edges = edges_from_lo_hi(e_min, e_max)\n axis = MapAxis.from_energy_edges(edges)\n else:\n raise ValueError(f\"Format '{format}' not supported\")\n\n return axis\n\n @classmethod\n def from_table_hdu(cls, hdu, format=\"ogip\", idx=0):\n \"\"\"Instanciate MapAxis from table HDU\n\n Parameters\n ----------\n hdu : `~astropy.io.fits.BinTableHDU`\n Table HDU\n format : {\"ogip\", \"ogip-arf\", \"fgst-ccube\", \"fgst-template\"}\n Format specification\n idx : int\n Column index of the axis.\n\n Returns\n -------\n axis : `MapAxis`\n Map Axis\n \"\"\"\n table = Table.read(hdu)\n return cls.from_table(table, format=format, idx=idx)\n\n\nclass MapCoord:\n \"\"\"Represents a sequence of n-dimensional map coordinates.\n\n Contains coordinates for 2 spatial dimensions and an arbitrary\n number of additional non-spatial dimensions.\n\n For further information see :ref:`mapcoord`.\n\n Parameters\n ----------\n data : `dict` of `~numpy.ndarray`\n Dictionary of coordinate arrays.\n frame : {\"icrs\", \"galactic\", None}\n Spatial coordinate system. If None then the coordinate system\n will be set to the native coordinate system of the geometry.\n match_by_name : bool\n Match coordinates to axes by name?\n If false coordinates will be matched by index.\n \"\"\"\n\n def __init__(self, data, frame=None, match_by_name=True):\n if \"lon\" not in data or \"lat\" not in data:\n raise ValueError(\"data dictionary must contain axes named 'lon' and 'lat'.\")\n\n self._data = {k: np.atleast_1d(v) for k, v in data.items()}\n self._frame = frame\n self._match_by_name = match_by_name\n\n def __getitem__(self, key):\n if isinstance(key, str):\n return self._data[key]\n else:\n return list(self._data.values())[key]\n\n def __iter__(self):\n return iter(self._data.values())\n\n @property\n def ndim(self):\n \"\"\"Number of dimensions.\"\"\"\n return len(self._data)\n\n @property\n def shape(self):\n \"\"\"Coordinate array shape.\"\"\"\n arrays = [_ for _ in self._data.values()]\n return np.broadcast(*arrays).shape\n\n @property\n def size(self):\n return np.prod(self.shape)\n\n @property\n def lon(self):\n \"\"\"Longitude coordinate in degrees.\"\"\"\n return self._data[\"lon\"]\n\n @property\n def lat(self):\n \"\"\"Latitude coordinate in degrees.\"\"\"\n return self._data[\"lat\"]\n\n @property\n def theta(self):\n \"\"\"Theta co-latitude angle in radians.\"\"\"\n theta = u.Quantity(self.lat, unit=\"deg\", copy=False).to_value(\"rad\")\n return np.pi / 2.0 - theta\n\n @property\n def phi(self):\n \"\"\"Phi longitude angle in radians.\"\"\"\n phi = u.Quantity(self.lon, unit=\"deg\", copy=False).to_value(\"rad\")\n return phi\n\n @property\n def frame(self):\n \"\"\"Coordinate system (str).\"\"\"\n return self._frame\n\n @property\n def match_by_name(self):\n \"\"\"Boolean flag: axis lookup by name (True) or index (False).\"\"\"\n return self._match_by_name\n\n @property\n def skycoord(self):\n return SkyCoord(self.lon, self.lat, unit=\"deg\", frame=self.frame)\n\n @classmethod\n def _from_lonlat(cls, coords, frame=None, axis_names=None):\n \"\"\"Create a `~MapCoord` from a tuple of coordinate vectors.\n\n The first two elements of the tuple should be longitude and latitude in degrees.\n\n Parameters\n ----------\n coords : tuple\n Tuple of `~numpy.ndarray`.\n\n Returns\n -------\n coord : `~MapCoord`\n A coordinates object.\n \"\"\"\n if axis_names is None:\n axis_names = [f\"axis{idx}\" for idx in range(len(coords) - 2)]\n\n if isinstance(coords, (list, tuple)):\n coords_dict = {\"lon\": coords[0], \"lat\": coords[1]}\n for name, c in zip(axis_names, coords[2:]):\n coords_dict[name] = c\n else:\n raise ValueError(\"Unrecognized input type.\")\n\n return cls(coords_dict, frame=frame, match_by_name=False)\n\n @classmethod\n def _from_tuple(cls, coords, frame=None, axis_names=None):\n \"\"\"Create from tuple of coordinate vectors.\"\"\"\n if isinstance(coords[0], (list, np.ndarray)) or np.isscalar(coords[0]):\n return cls._from_lonlat(coords, frame=frame, axis_names=axis_names)\n elif isinstance(coords[0], SkyCoord):\n lon, lat, frame = skycoord_to_lonlat(coords[0], frame=frame)\n coords = (lon, lat) + coords[1:]\n return cls._from_lonlat(coords, frame=frame, axis_names=axis_names)\n else:\n raise TypeError(f\"Type not supported: {type(coords)!r}\")\n\n @classmethod\n def _from_dict(cls, coords, frame=None):\n \"\"\"Create from a dictionary of coordinate vectors.\"\"\"\n if \"lon\" in coords and \"lat\" in coords:\n return cls(coords, frame=frame)\n elif \"skycoord\" in coords:\n lon, lat, frame = skycoord_to_lonlat(coords[\"skycoord\"], frame=frame)\n coords_dict = {\"lon\": lon, \"lat\": lat}\n for k, v in coords.items():\n if k == \"skycoord\":\n continue\n coords_dict[k] = v\n return cls(coords_dict, frame=frame)\n else:\n raise ValueError(\"coords dict must contain 'lon'/'lat' or 'skycoord'.\")\n\n @classmethod\n def create(cls, data, frame=None, axis_names=None):\n \"\"\"Create a new `~MapCoord` object.\n\n This method can be used to create either unnamed (with tuple input)\n or named (via dict input) axes.\n\n Parameters\n ----------\n data : tuple, dict, `MapCoord` or `~astropy.coordinates.SkyCoord`\n Object containing coordinate arrays.\n frame : {\"icrs\", \"galactic\", None}, optional\n Set the coordinate system for longitude and latitude. If\n None longitude and latitude will be assumed to be in\n the coordinate system native to a given map geometry.\n axis_names : list of str\n Axis names use if a tuple is provided\n\n Examples\n --------\n >>> from astropy.coordinates import SkyCoord\n >>> from gammapy.maps import MapCoord\n\n >>> lon, lat = [1, 2], [2, 3]\n >>> skycoord = SkyCoord(lon, lat, unit='deg')\n >>> energy = [1000]\n >>> c = MapCoord.create((lon,lat))\n >>> c = MapCoord.create((skycoord,))\n >>> c = MapCoord.create((lon,lat,energy))\n >>> c = MapCoord.create(dict(lon=lon,lat=lat))\n >>> c = MapCoord.create(dict(lon=lon,lat=lat,energy=energy))\n >>> c = MapCoord.create(dict(skycoord=skycoord,energy=energy))\n \"\"\"\n if isinstance(data, cls):\n if data.frame is None or frame == data.frame:\n return data\n else:\n return data.to_frame(frame)\n elif isinstance(data, dict):\n return cls._from_dict(data, frame=frame)\n elif isinstance(data, (list, tuple)):\n return cls._from_tuple(data, frame=frame, axis_names=axis_names)\n elif isinstance(data, SkyCoord):\n return cls._from_tuple((data,), frame=frame, axis_names=axis_names)\n else:\n raise TypeError(f\"Unsupported input type: {type(data)!r}\")\n\n def to_frame(self, frame):\n \"\"\"Convert to a different coordinate frame.\n\n Parameters\n ----------\n frame : {\"icrs\", \"galactic\"}\n Coordinate system, either Galactic (\"galactic\") or Equatorial (\"icrs\").\n\n Returns\n -------\n coords : `~MapCoord`\n A coordinates object.\n \"\"\"\n if frame == self.frame:\n return copy.deepcopy(self)\n else:\n lon, lat, frame = skycoord_to_lonlat(self.skycoord, frame=frame)\n data = copy.deepcopy(self._data)\n if isinstance(self.lon, u.Quantity):\n lon = u.Quantity(lon, unit=\"deg\", copy=False)\n\n if isinstance(self.lon, u.Quantity):\n lat = u.Quantity(lat, unit=\"deg\", copy=False)\n\n data[\"lon\"] = lon\n data[\"lat\"] = lat\n return self.__class__(data, frame, self._match_by_name)\n\n def apply_mask(self, mask):\n \"\"\"Return a masked copy of this coordinate object.\n\n Parameters\n ----------\n mask : `~numpy.ndarray`\n Boolean mask.\n\n Returns\n -------\n coords : `~MapCoord`\n A coordinates object.\n \"\"\"\n try:\n data = {k: v[mask] for k, v in self._data.items()}\n except IndexError:\n data = {}\n\n for name, coord in self._data.items():\n if name in [\"lon\", \"lat\"]:\n data[name] = np.squeeze(coord)[mask]\n else:\n data[name] = np.squeeze(coord, axis=-1)\n\n return self.__class__(data, self.frame, self._match_by_name)\n\n @property\n def flat(self):\n \"\"\"Return flattened, valid coordinates\"\"\"\n coords = self.broadcasted\n is_finite = np.isfinite(coords[0])\n return coords.apply_mask(is_finite)\n\n @property\n def broadcasted(self):\n \"\"\"Return broadcasted coords\"\"\"\n vals = np.broadcast_arrays(*self._data.values(), subok=True)\n data = dict(zip(self._data.keys(), vals))\n return self.__class__(data=data, frame=self.frame, match_by_name=self._match_by_name)\n\n def copy(self):\n \"\"\"Copy `MapCoord` object.\"\"\"\n return copy.deepcopy(self)\n\n def __repr__(self):\n return (\n f\"{self.__class__.__name__}\\n\\n\"\n f\"\\taxes : {list(self._data.keys())}\\n\"\n f\"\\tshape : {self.shape[::-1]}\\n\"\n f\"\\tndim : {self.ndim}\\n\"\n f\"\\tframe : {self.frame}\\n\"\n )\n\n\nclass Geom(abc.ABC):\n \"\"\"Map geometry base class.\n\n See also: `~gammapy.maps.WcsGeom` and `~gammapy.maps.HpxGeom`\n \"\"\"\n\n @property\n @abc.abstractmethod\n def data_shape(self):\n \"\"\"Shape of the Numpy data array matching this geometry.\"\"\"\n pass\n\n def data_nbytes(self, dtype=\"float32\"):\n \"\"\"Estimate memory usage in megabytes of the Numpy data array\n matching this geometry depending on the given type.\n\n Parameters\n ----------\n dtype : data-type\n The desired data-type for the array. Default is \"float32\"\n \n Returns\n -------\n memory : `~astropy.units.Quantity`\n Estimated memory usage in megabytes (MB)\n \"\"\"\n return (np.empty(self.data_shape, dtype).nbytes * u.byte).to(\"MB\")\n\n @property\n @abc.abstractmethod\n def is_allsky(self):\n pass\n\n @property\n @abc.abstractmethod\n def center_coord(self):\n pass\n\n @property\n @abc.abstractmethod\n def center_pix(self):\n pass\n\n @property\n @abc.abstractmethod\n def center_skydir(self):\n pass\n\n @classmethod\n def from_hdulist(cls, hdulist, hdu=None, hdu_bands=None):\n \"\"\"Load a geometry object from a FITS HDUList.\n\n Parameters\n ----------\n hdulist : `~astropy.io.fits.HDUList`\n HDU list containing HDUs for map data and bands.\n hdu : str\n Name or index of the HDU with the map data.\n hdu_bands : str\n Name or index of the HDU with the BANDS table. If not\n defined this will be inferred from the FITS header of the\n map HDU.\n\n Returns\n -------\n geom : `~Geom`\n Geometry object.\n \"\"\"\n if hdu is None:\n hdu = find_hdu(hdulist)\n else:\n hdu = hdulist[hdu]\n\n if hdu_bands is None:\n hdu_bands = find_bands_hdu(hdulist, hdu)\n\n if hdu_bands is not None:\n hdu_bands = hdulist[hdu_bands]\n\n return cls.from_header(hdu.header, hdu_bands)\n\n def to_bands_hdu(self, hdu_bands=None, format=\"gadf\"):\n table_hdu = self.axes.to_table_hdu(format=format, hdu_bands=hdu_bands)\n cols = table_hdu.columns.columns\n cols.extend(self._make_bands_cols())\n return fits.BinTableHDU.from_columns(\n cols, header=table_hdu.header, name=table_hdu.name\n )\n\n @abc.abstractmethod\n def _make_bands_cols(self):\n pass\n\n @abc.abstractmethod\n def get_idx(self, idx=None, local=False, flat=False):\n \"\"\"Get tuple of pixel indices for this geometry.\n\n Returns all pixels in the geometry by default. Pixel indices\n for a single image plane can be accessed by setting ``idx``\n to the index tuple of a plane.\n\n Parameters\n ----------\n idx : tuple, optional\n A tuple of indices with one index for each non-spatial\n dimension. If defined only pixels for the image plane with\n this index will be returned. If none then all pixels\n will be returned.\n local : bool\n Flag to return local or global pixel indices. Local\n indices run from 0 to the number of pixels in a given\n image plane.\n flat : bool, optional\n Return a flattened array containing only indices for\n pixels contained in the geometry.\n\n Returns\n -------\n idx : tuple\n Tuple of pixel index vectors with one vector for each\n dimension.\n \"\"\"\n pass\n\n @abc.abstractmethod\n def get_coord(self, idx=None, flat=False):\n \"\"\"Get the coordinate array for this geometry.\n\n Returns a coordinate array with the same shape as the data\n array. Pixels outside the geometry are set to NaN.\n Coordinates for a single image plane can be accessed by\n setting ``idx`` to the index tuple of a plane.\n\n Parameters\n ----------\n idx : tuple, optional\n A tuple of indices with one index for each non-spatial\n dimension. If defined only coordinates for the image\n plane with this index will be returned. If none then\n coordinates for all pixels will be returned.\n flat : bool, optional\n Return a flattened array containing only coordinates for\n pixels contained in the geometry.\n\n Returns\n -------\n coords : tuple\n Tuple of coordinate vectors with one vector for each\n dimension.\n \"\"\"\n pass\n\n @abc.abstractmethod\n def coord_to_pix(self, coords):\n \"\"\"Convert map coordinates to pixel coordinates.\n\n Parameters\n ----------\n coords : tuple\n Coordinate values in each dimension of the map. This can\n either be a tuple of numpy arrays or a MapCoord object.\n If passed as a tuple then the ordering should be\n (longitude, latitude, c_0, ..., c_N) where c_i is the\n coordinate vector for axis i.\n\n Returns\n -------\n pix : tuple\n Tuple of pixel coordinates in image and band dimensions.\n \"\"\"\n pass\n\n def coord_to_idx(self, coords, clip=False):\n \"\"\"Convert map coordinates to pixel indices.\n\n Parameters\n ----------\n coords : tuple or `~MapCoord`\n Coordinate values in each dimension of the map. This can\n either be a tuple of numpy arrays or a MapCoord object.\n If passed as a tuple then the ordering should be\n (longitude, latitude, c_0, ..., c_N) where c_i is the\n coordinate vector for axis i.\n clip : bool\n Choose whether to clip indices to the valid range of the\n geometry. If false then indices for coordinates outside\n the geometry range will be set -1.\n\n Returns\n -------\n pix : tuple\n Tuple of pixel indices in image and band dimensions.\n Elements set to -1 correspond to coordinates outside the\n map.\n \"\"\"\n pix = self.coord_to_pix(coords)\n return self.pix_to_idx(pix, clip=clip)\n\n @abc.abstractmethod\n def pix_to_coord(self, pix):\n \"\"\"Convert pixel coordinates to map coordinates.\n\n Parameters\n ----------\n pix : tuple\n Tuple of pixel coordinates.\n\n Returns\n -------\n coords : tuple\n Tuple of map coordinates.\n \"\"\"\n pass\n\n @abc.abstractmethod\n def pix_to_idx(self, pix, clip=False):\n \"\"\"Convert pixel coordinates to pixel indices.\n\n Returns -1 for pixel coordinates that lie outside of the map.\n\n Parameters\n ----------\n pix : tuple\n Tuple of pixel coordinates.\n clip : bool\n Choose whether to clip indices to the valid range of the\n geometry. If false then indices for coordinates outside\n the geometry range will be set -1.\n\n Returns\n -------\n idx : tuple\n Tuple of pixel indices.\n \"\"\"\n pass\n\n @abc.abstractmethod\n def contains(self, coords):\n \"\"\"Check if a given map coordinate is contained in the geometry.\n\n Parameters\n ----------\n coords : tuple or `~gammapy.maps.MapCoord`\n Tuple of map coordinates.\n\n Returns\n -------\n containment : `~numpy.ndarray`\n Bool array.\n \"\"\"\n pass\n\n def contains_pix(self, pix):\n \"\"\"Check if a given pixel coordinate is contained in the geometry.\n\n Parameters\n ----------\n pix : tuple\n Tuple of pixel coordinates.\n\n Returns\n -------\n containment : `~numpy.ndarray`\n Bool array.\n \"\"\"\n idx = self.pix_to_idx(pix)\n return np.all(np.stack([t != INVALID_INDEX.int for t in idx]), axis=0)\n\n def slice_by_idx(self, slices):\n \"\"\"Create a new geometry by slicing the non-spatial axes.\n\n Parameters\n ----------\n slices : dict\n Dict of axes names and integers or `slice` object pairs. Contains one\n element for each non-spatial dimension. For integer indexing the\n corresponding axes is dropped from the map. Axes not specified in the\n dict are kept unchanged.\n\n Returns\n -------\n geom : `~Geom`\n Sliced geometry.\n \"\"\"\n axes = self.axes.slice_by_idx(slices)\n return self._init_copy(axes=axes)\n\n @property\n def as_energy_true(self):\n \"\"\"If the geom contains an energy axis rename it to energy true\"\"\"\n energy_axis = self.axes[\"energy\"].copy(name=\"energy_true\")\n return self.to_image().to_cube([energy_axis])\n\n @property\n def has_energy_axis(self):\n \"\"\"Whether geom has an energy axis\"\"\"\n return (\"energy\" in self.axes.names) ^ (\"energy_true\" in self.axes.names)\n\n @abc.abstractmethod\n def to_image(self):\n \"\"\"Create 2D image geometry (drop non-spatial dimensions).\n\n Returns\n -------\n geom : `~Geom`\n Image geometry.\n \"\"\"\n pass\n\n @abc.abstractmethod\n def to_cube(self, axes):\n \"\"\"Append non-spatial axes to create a higher-dimensional geometry.\n\n This will result in a new geometry with\n N+M dimensions where N is the number of current dimensions and\n M is the number of axes in the list.\n\n Parameters\n ----------\n axes : list\n Axes that will be appended to this geometry.\n\n Returns\n -------\n geom : `~Geom`\n Map geometry.\n \"\"\"\n pass\n\n def squash(self, axis_name):\n \"\"\"Squash geom axis.\n\n Parameters\n ----------\n axis_name : str\n Axis to squash.\n\n Returns\n -------\n geom : `Geom`\n Geom with squashed axis.\n \"\"\"\n axes = self.axes.squash(axis_name=axis_name)\n return self.to_image().to_cube(axes=axes)\n\n def drop(self, axis_name):\n \"\"\"Drop an axis from the geom.\n\n Parameters\n ----------\n axis_name : str\n Name of the axis to remove.\n\n Returns\n -------\n geom : `Geom`\n New geom with the axis removed.\n \"\"\"\n axes = self.axes.drop(axis_name=axis_name)\n return self.to_image().to_cube(axes=axes)\n\n def pad(self, pad_width, axis_name):\n \"\"\"\n Pad the geometry at the edges.\n\n Parameters\n ----------\n pad_width : {sequence, array_like, int}\n Number of values padded to the edges of each axis.\n axis_name : str\n Name of the axis to pad.\n\n Returns\n -------\n geom : `~Geom`\n Padded geometry.\n \"\"\"\n if axis_name is None:\n return self._pad_spatial(pad_width)\n else:\n axes = self.axes.pad(axis_name=axis_name, pad_width=pad_width)\n return self.to_image().to_cube(axes)\n\n @abc.abstractmethod\n def _pad_spatial(self, pad_width):\n pass\n\n @abc.abstractmethod\n def crop(self, crop_width):\n \"\"\"\n Crop the geometry at the edges.\n\n Parameters\n ----------\n crop_width : {sequence, array_like, int}\n Number of values cropped from the edges of each axis.\n\n Returns\n -------\n geom : `~Geom`\n Cropped geometry.\n \"\"\"\n pass\n\n @abc.abstractmethod\n def downsample(self, factor, axis_name):\n \"\"\"Downsample the spatial dimension of the geometry by a given factor.\n\n Parameters\n ----------\n factor : int\n Downsampling factor.\n axis_name : str\n Axis to downsample.\n\n Returns\n -------\n geom : `~Geom`\n Downsampled geometry.\n\n \"\"\"\n pass\n\n @abc.abstractmethod\n def upsample(self, factor, axis_name):\n \"\"\"Upsample the spatial dimension of the geometry by a given factor.\n\n Parameters\n ----------\n factor : int\n Upsampling factor.\n axis_name : str\n Axis to upsample.\n\n Returns\n -------\n geom : `~Geom`\n Upsampled geometry.\n\n \"\"\"\n pass\n\n def resample_axis(self, axis):\n \"\"\"Resample geom to a new axis binning.\n\n This method groups the existing bins into a new binning.\n\n Parameters\n ----------\n axis : `MapAxis`\n New map axis.\n\n Returns\n -------\n map : `Geom`\n Geom with resampled axis.\n \"\"\"\n axes = self.axes.resample(axis=axis)\n return self._init_copy(axes=axes)\n\n @abc.abstractmethod\n def solid_angle(self):\n \"\"\"Solid angle (`~astropy.units.Quantity` in ``sr``).\"\"\"\n pass\n\n @property\n def is_image(self):\n \"\"\"Whether the geom is an image without extra dimensions.\"\"\"\n if self.axes is None:\n return True\n return len(self.axes) == 0\n\n @property\n def is_flat(self):\n \"\"\"Whether the geom non spatial axes have length 1, i.e. if the geom is equivalent to an image.\"\"\"\n if self.is_image:\n return True\n else:\n valid = True\n for axis in self.axes:\n valid = valid and (axis.nbin == 1)\n return valid\n\n def _init_copy(self, **kwargs):\n \"\"\"Init map geom instance by copying missing init arguments from self.\n \"\"\"\n argnames = inspect.getfullargspec(self.__init__).args\n argnames.remove(\"self\")\n\n for arg in argnames:\n value = getattr(self, \"_\" + arg)\n kwargs.setdefault(arg, copy.deepcopy(value))\n\n return self.__class__(**kwargs)\n\n def copy(self, **kwargs):\n \"\"\"Copy and overwrite given attributes.\n\n Parameters\n ----------\n **kwargs : dict\n Keyword arguments to overwrite in the map geometry constructor.\n\n Returns\n -------\n copy : `Geom`\n Copied map geometry.\n \"\"\"\n return self._init_copy(**kwargs)\n\n def energy_mask(self, energy_min=None, energy_max=None, round_to_edge=False):\n \"\"\"Create a mask for a given energy range.\n\n The energy bin must be fully contained to be included in the mask.\n\n Parameters\n ----------\n energy_min, energy_max : `~astropy.units.Quantity`\n Energy range\n\n Returns\n -------\n mask : `~numpy.ndarray`\n Energy mask\n \"\"\"\n from . import Map\n\n # get energy axes and values\n energy_axis = self.axes[\"energy\"]\n\n if round_to_edge:\n energy_min, energy_max = energy_axis.round([energy_min, energy_max])\n\n # TODO: make this more general\n shape = (-1, 1) if self.is_hpx else (-1, 1, 1)\n energy_edges = energy_axis.edges.reshape(shape)\n\n # set default values\n energy_min = energy_min if energy_min is not None else energy_edges[0]\n energy_max = energy_max if energy_max is not None else energy_edges[-1]\n\n mask = (energy_edges[:-1] >= energy_min) & (energy_edges[1:] <= energy_max)\n data = np.broadcast_to(mask, shape=self.data_shape)\n return Map.from_geom(geom=self, data=data)\n", "meta": {"hexsha": "5dea069bdb729f1d6b97d7b608c2d0038d8ba620", "size": 80294, "ext": "py", "lang": "Python", "max_stars_repo_path": "gammapy/maps/geom.py", "max_stars_repo_name": "Devot1on/gammapy", "max_stars_repo_head_hexsha": "6a5255cd7221f50079d36250888ca8cc763ebaf7", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "gammapy/maps/geom.py", "max_issues_repo_name": "Devot1on/gammapy", "max_issues_repo_head_hexsha": "6a5255cd7221f50079d36250888ca8cc763ebaf7", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "gammapy/maps/geom.py", "max_forks_repo_name": "Devot1on/gammapy", "max_forks_repo_head_hexsha": "6a5255cd7221f50079d36250888ca8cc763ebaf7", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.2881931347, "max_line_length": 122, "alphanum_fraction": 0.5470396294, "include": true, "reason": "import numpy,import scipy,from astropy", "num_tokens": 18020, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073655352403, "lm_q2_score": 0.35936414516010196, "lm_q1q2_score": 0.1978685452344274}} {"text": "#!/usr/bin/env python3\n\nimport argparse\nfrom collections import Counter\nfrom multiprocessing import set_start_method\nimport pdb\nimport re\nimport sys\nimport time\nimport copy\n\nimport numpy as np\nimport torch\nimport torch.nn as nn\nfrom torch.autograd import Variable\nfrom torch import optim\nimport torch.nn.functional as F\nimport torch.multiprocessing as mp\n\nimport data_producer\n\nfrom word2atoms import skipgram_atoms, trivial_atoms, morpheme_split\n\nparser = argparse.ArgumentParser()\nparser.add_argument(\"--train\", type=str, default=\"\", help=\"training file\")\nparser.add_argument(\"--output\", type=str, default=\"vectors.txt\", help=\"output word embedding file\")\nparser.add_argument(\"--atomoutput\", type=str, default=\"atomvectors.txt\", help=\"output atom embedding file\")\nparser.add_argument(\"--ctxoutput\", type=str, default=\"atomvectors.txt\", help=\"context vectors file\")\nparser.add_argument(\"--ctxatomoutput\", type=str, default=\"atomvectors.txt\", help=\"context atom vectors file\")\nparser.add_argument(\"--losslog\", type=str, default=\"all_losses.txt\", help=\"log of training losses\")\nparser.add_argument(\"--opt\", type=str, default=\"SGD\", help=\"optimiser to use\")\nparser.add_argument(\"--size\", type=int, default=300, help=\"word embedding dimension\")\nparser.add_argument(\"--cbow\", type=int, default=1, help=\"1 for cbow, 0 for skipgram\")\nparser.add_argument(\"--window\", type=int, default=5, help=\"context window size\")\nparser.add_argument(\"--sample\", type=float, default=1e-4, help=\"subsample threshold\")\nparser.add_argument(\"--negative\", type=int, default=10, help=\"number of negative samples\")\nparser.add_argument(\"--min_count\", type=int, default=5, help=\"minimum frequency of a word\")\nparser.add_argument(\"--processes\", type=int, default=4, help=\"number of processes\")\nparser.add_argument(\"--num_workers\", type=int, default=6, help=\"number of workers for data processsing\")\nparser.add_argument(\"--iter\", type=int, default=5, help=\"number of iterations\")\nparser.add_argument(\"--lr\", type=float, default=-1.0, help=\"initial learning rate\")\nparser.add_argument(\"--momentum\", type=float, default=0.0, help=\"momentum\")\nparser.add_argument(\"--batch_size\", type=int, default=100, help=\"(max) batch size\")\nparser.add_argument(\"--megabatch_size\", type=int, default=100000, help=\"(max) megabatch size\")\nparser.add_argument(\"--cuda\", action='store_true', default=False, help=\"enable cuda\")\nparser.add_argument(\"--output_ctx\", action='store_true', default=False, help=\"output context embeddings\")\nparser.add_argument(\"--anneal\", action='store_true', default=False, help=\"anneal the learning rate linearly to 0\")\nparser.add_argument(\"--shuffle\", action='store_true', default=False, help=\"shuffle the training data points\")\nparser.add_argument(\"--atomizer\", type=str, choices=['fasttext', 'morphoseg', 'word2vec'], default=\"word2vec\", help=\"atomizer to use (vanilla word2vec by default, can also choose fasttext or morphoseg)\")\nparser.add_argument(\"--minL\", type=int, default=5, help=\"minimum possible length of n-grams to take when atomizing\")\nparser.add_argument(\"--maxL\", type=int, default=5, help=\"maximum possible length of n-grams to take when atomizing\")\nparser.add_argument(\"--halfletters\", action='store_true', default=False, help=\"whether to use half-letters/raw Unicode characters when taking n-grams, or whole Tamil letters\")\n\nMAX_SENT_LEN = 1000\n\n# Build the vocabulary.\ndef file_split(f, delim=' \\t\\n', bufsize=1024):\n prev = ''\n while True:\n s = f.read(bufsize)\n if not s:\n break\n tokens = re.split('['+delim+']{1,}', s)\n if len(tokens) > 1:\n yield prev + tokens[0]\n prev = tokens[-1]\n for x in tokens[1:-1]:\n yield x\n else:\n prev += s\n if prev:\n yield prev\n\ndef build_vocab(args):\n vocab = Counter()\n word_count = 0\n for word in file_split(open(args.train)):\n vocab[word] += 1\n word_count += 1\n if word_count % 10000 == 0:\n sys.stdout.write('%d\\r' % len(vocab))\n freq = {k:v for k,v in vocab.items() if v >= args.min_count}\n word_count = sum([freq[k] for k in freq])\n word_list = sorted(freq, key=freq.get, reverse=True)\n word2idx = {}\n for i,w in enumerate(word_list):\n word2idx[w] = i\n\n print(\"Vocab size: %ld\" % len(word2idx))\n print(\"Words in train file: %ld\" % word_count)\n vars(args)['vocab_size'] = len(word2idx)\n vars(args)['train_words'] = word_count\n\n \"\"\" for i, word in enumerate(word_list):\n if word[-1] == '0':\n print(i, word)\n if i == 1761:\n print(word) \"\"\"\n #print(\"Initial mattrum count\")\n #print(freq['மற்றும்'])\n return word2idx, word_list, freq\n\ndef build_morph(args, word2idx, word_list, freq, atomiser):\n morph_list = []\n morph2idx = {}\n word2morph = []\n #total_morphperword = 0\n max_morphperword = 0\n #total_freq = 0\n for i, word in enumerate(word_list):\n idxs = []\n cnt = 0\n for morph in atomiser(word):\n if morph in morph2idx:\n idx = morph2idx[morph]\n else:\n idx = len(morph_list)\n morph_list.append(morph)\n morph2idx[morph] = idx\n idxs.append(idx)\n cnt += 1\n #total_morphperword += freq[word] * cnt\n #total_freq += freq[word]\n if cnt > max_morphperword:\n max_morphperword = cnt\n word2morph.append(torch.LongTensor(idxs))\n if i % 100 == 0:\n sys.stdout.write('%d\\r' % i)\n \n # actual padding index\n word2morph.append(torch.LongTensor([len(morph2idx)]))\n\n word2morphfinal = torch.zeros((len(word2morph), max_morphperword), dtype=torch.long)\n word2morphfinal = word2morphfinal.fill_(len(morph2idx) +1)\n for i in range(len(word2morph)):\n row = word2morph[i]\n word2morphfinal[i, :row.shape[0]] = row\n\n #print(word2morphfinal.shape)\n #print(freq[word_list[0]])\n \"\"\" indices = [0]\n for index in indices:\n print(word_list[index])\n print(' '.join([morph_list[j] for j in word2morph[index]]))\n print(word2morph[816])\n print(word2morph[0])\n print(word2morph[10520]) \"\"\"\n\n print(\"Morpheme size: %ld\" % len(morph2idx))\n #print(\"Average morphemes per word: %f\" % (float(total_morphperword)/total_freq))\n print(\"Max morphemes per word: %d\" % max_morphperword)\n #vars(args)['morph_size'] = len(morph2idx)\n #vars(args)['word2morph'] = word2morph\n\n return morph2idx, morph_list, word2morphfinal\n\nclass CBOWMean(torch.autograd.Function):\n @staticmethod\n def forward(ctx, x, lens):\n ctx.save_for_backward(x)\n x = torch.sum(x, 1, keepdim=True)\n x = x.permute(1,2,0) / lens\n return x.permute(2,0,1)\n @staticmethod\n def backward(ctx, g):\n x, = ctx.saved_variables\n return g.expand_as(x), None\n\nclass CBOW(nn.Module):\n def __init__(self, args):\n super(CBOW, self).__init__()\n self.emb0_lookup = nn.Embedding(args.vocab_size+1, args.size, padding_idx=args.vocab_size, sparse=True)\n self.emb1_lookup = nn.Embedding(args.vocab_size, args.size, sparse=True)\n self.emb0_lookup.weight.data.uniform_(-0.5/args.size, 0.5/args.size)\n self.emb0_lookup.weight.data[args.vocab_size].fill_(0)\n self.emb1_lookup.weight.data.uniform_(-0.5/args.size, 0.5/args.size)\n self.window = args.window\n self.negative = args.negative\n self.pad_idx = args.vocab_size\n\n def forward(self, data):\n ctx_indices = data[:, 0:2*self.window]\n ctx_lens = data[:, 2*self.window].float()\n word_idx = data[:, 2*self.window+1]\n neg_indices = data[:, 2*self.window+2:2*self.window+2+self.negative]\n neg_mask = data[:, 2*self.window+2+self.negative:].float()\n\n c_embs = self.emb0_lookup(ctx_indices)\n w_embs = self.emb1_lookup(word_idx)\n n_embs = self.emb1_lookup(neg_indices)\n\n c_embs = CBOWMean.apply(c_embs, ctx_lens)\n\n pos_ips = torch.sum(c_embs[:,0,:] * w_embs, 1)\n neg_ips = torch.bmm(n_embs, c_embs.permute(0,2,1))[:,:,0]\n\n # Neg Log Likelihood\n pos_loss = torch.sum( -F.logsigmoid(torch.clamp(pos_ips,max=10,min=-10)) )\n neg_loss = torch.sum( -F.logsigmoid(torch.clamp(-neg_ips,max=10,min=-10)) * neg_mask )\n\n return pos_loss + neg_loss\n\nclass SG(nn.Module):\n def __init__(self, args):\n super(SG, self).__init__()\n self.emb0morph_lookup = nn.Embedding(args.morph_size+2, args.size, padding_idx=args.morph_size, sparse=True)\n self.emb1morph_lookup = nn.Embedding(args.ctxmorph_size+2, args.size, padding_idx=args.ctxmorph_size, sparse=True)\n\n #self.emb0_lookup = nn.Embedding(args.vocab_size+1, args.size, padding_idx=args.vocab_size, sparse=True)\n #self.emb1_lookup = nn.Embedding(args.vocab_size, args.size, sparse=True)\n\n self.emb0morph_lookup.weight.data.uniform_(-0.5/args.size, 0.5/args.size)\n self.emb0morph_lookup.weight.data[args.morph_size+1].fill_(0)\n # randomly initialise context vectors\n #self.emb1morph_lookup.weight.data.uniform_(-0.5/args.size, 0.5/args.size)\n #self.emb1morph_lookup.weight.data[args.ctxmorph_size+1].fill_(0)\n\n # OR zero initialise them as usual\n self.emb1morph_lookup.weight.data.zero_()\n\n #self.emb0_lookup.weight.data.uniform_(-0.5/args.size, 0.5/args.size)\n #self.emb1_lookup.weight.data.zero_()\n #self.emb1morph_lookup.weight.data.zero_()\n\n #self.emb0morph_lookup.weight.data[args.morph_size+1].requires_grad = False\n\n self.window = args.window\n self.negative = args.negative\n self.pad_idx = args.vocab_size\n self.morph_size = args.morph_size\n\n def forward(self, data, word2morph, word2morph_mask, ctx2morph, ctx2morph_mask):\n word_idx = data[:, 0]\n ctx_idx = data[:, 1]\n neg_indices = data[:, 2:2+self.negative]\n neg_mask = data[:, 2+self.negative:].float()\n\n #print(word2morph.shape)\n #print(word2morph_mask.shape)\n\n #print(torch.max(word2morph))\n #print(\"MORPHEMES\")\n #print(word2morph[3])\n #print(torch.norm(self.emb0morph_lookup.weight.data[-1]))\n #print(torch.norm(torch.squeeze(word2morph_mask), dim=0)) # should start nonzero, then eventually be 0\n\n #print((self.emb0morph_lookup(word2morph[:, 0]) * word2morph_mask[:, 0]).shape)\n #t = self.emb0morph_lookup(word2morph) * word2morph_mask\n #print(t.shape)\n #print(torch.sum(t, dim=1).shape)\n w_embs = torch.sum(self.emb0morph_lookup(word2morph) * word2morph_mask, dim=1)\n #w_embs = self.emb0_lookup(word_idx)\n\n #t = self.emb1morph_lookup(ctx2morph[:, 0]) * ctx2morph_mask[:, 0]\n #print(t.shape)\n #print(torch.sum(t, dim=1).shape)\n #print((self.emb0morph_lookup(word2morph[:, 1]) * word2morph_mask[:, 1]).shape)\n c_embs = torch.sum(self.emb1morph_lookup(ctx2morph[:, 0]) * ctx2morph_mask[:, 0], dim=1)\n #c_embs = self.emb1_lookup(ctx_idx)\n \n #t = self.emb1morph_lookup(ctx2morph[:, 1:1+self.negative]) * ctx2morph_mask[:, 1:1+self.negative]\n #print(t.shape)\n #print(torch.sum(t, dim=2).shape)\n #print((self.emb0morph_lookup(word2morph[:, 2:2+self.negative]) * word2morph_mask[:, 2:2+self.negative]).shape)\n n_embs = torch.sum(self.emb1morph_lookup(ctx2morph[:, 1:1+self.negative]) * ctx2morph_mask[:, 1:1+self.negative], dim=2)\n #n_embs = self.emb1_lookup(neg_indices)\n\n pos_ips = torch.sum(w_embs * c_embs, 1)\n neg_ips = torch.bmm(n_embs, torch.unsqueeze(w_embs,1).permute(0,2,1))[:,:,0]\n\n # Neg Log Likelihood\n pos_loss = torch.sum( -F.logsigmoid(torch.clamp(pos_ips,max=10,min=-10)) )\n neg_loss = torch.sum( -F.logsigmoid(torch.clamp(-neg_ips,max=10,min=-10)) * neg_mask )\n\n return pos_loss + neg_loss\n\n# Initialize model.\ndef init_net(args):\n if args.cbow == 1:\n if args.lr == -1.0:\n vars(args)['lr'] = 0.05\n return CBOW(args)\n elif args.cbow == 0:\n if args.lr == -1.0:\n vars(args)['lr'] = 0.025\n return SG(args)\n\n# Training\ndef train_process_sent_producer(p_id, data_queue, word_count_actual, word2idx, word_list, freq, args):\n if args.negative > 0:\n table_ptr_val = data_producer.init_unigram_table(word_list, freq, args.train_words)\n\n train_file = open(args.train)\n file_pos = args.file_size * p_id // args.processes\n train_file.seek(file_pos, 0)\n while True:\n try:\n train_file.read(1)\n except UnicodeDecodeError:\n file_pos -= 1\n train_file.seek(file_pos, 0)\n else:\n train_file.seek(file_pos, 0)\n break\n\n batch_count = 0\n if args.cbow == 1:\n batch_placeholder = np.zeros((args.megabatch_size, 2*args.window+2+2*args.negative), 'int64')\n else:\n batch_placeholder = np.zeros((args.megabatch_size, 2+2*args.negative), 'int64')\n #mattrum_cnt = 0\n for it in range(args.iter):\n train_file.seek(file_pos, 0)\n\n last_word_cnt = 0\n word_cnt = 0\n sentence = []\n prev = ''\n eof = False\n while True:\n if eof or train_file.tell() > file_pos + args.file_size / args.processes:\n break\n\n while True:\n s = train_file.read(1)\n if not s:\n eof = True\n break\n elif s == ' ' or s == '\\t':\n if prev in word2idx:\n sentence.append(prev)\n prev = ''\n if len(sentence) >= MAX_SENT_LEN:\n break\n elif s == '\\n':\n if prev in word2idx:\n sentence.append(prev)\n prev = ''\n break\n else:\n prev += s\n\n if len(sentence) > 0:\n #print(\"Full sentence\")\n #print(' '.join(sentence))\n # subsampling\n sent_id = []\n trimmed = []\n if args.sample != 0:\n sent_len = len(sentence)\n i = 0\n while i < sent_len:\n word = sentence[i]\n f = freq[word] / args.train_words\n pb = (np.sqrt(f / args.sample) + 1) * args.sample / f\n\n if pb > np.random.random_sample():\n sent_id.append( word2idx[word] )\n \"\"\" if word2idx[word] == 'மற்றும்' and mattrum_cnt % 1000 == 0:\n print(\"Hit another 1000 mattrums\")\n mattrum_cnt += 1\n else:\n trimmed.append(word) \"\"\"\n i += 1\n\n if len(sent_id) < 2:\n word_cnt += len(sentence)\n sentence.clear()\n continue\n \n #print(\"Killed words\")\n #print(' '.join(trimmed))\n #print(\"Trimmed sentence\")\n #print(' '.join([word_list[index] for index in sent_id]))\n\n next_random = (2**24) * np.random.randint(0, 2**24) + np.random.randint(0, 2**24)\n if args.cbow == 1: # train CBOW\n chunk = data_producer.cbow_producer(sent_id, len(sent_id), table_ptr_val,\n args.window, args.negative, args.vocab_size, args.batch_size, next_random)\n elif args.cbow == 0: # train skipgram\n chunk = data_producer.sg_producer(sent_id, len(sent_id), table_ptr_val,\n args.window, args.negative, args.vocab_size, args.batch_size, next_random)\n \n #print(\"Data points\")\n #print(chunk)\n \n chunk_pos = 0\n while chunk_pos < chunk.shape[0]:\n remain_space = args.megabatch_size - batch_count\n remain_chunk = chunk.shape[0] - chunk_pos\n\n if remain_chunk < remain_space:\n take_from_chunk = remain_chunk\n else:\n take_from_chunk = remain_space\n\n batch_placeholder[batch_count:batch_count+take_from_chunk, :] = chunk[chunk_pos:chunk_pos+take_from_chunk, :]\n batch_count += take_from_chunk\n\n if batch_count == args.megabatch_size:\n if args.shuffle:\n p = torch.randperm(batch_count)\n batch_placeholder = batch_placeholder[p]\n\n start = 0\n while start < batch_count:\n data_queue.put(batch_placeholder[start : min(start + args.batch_size, batch_count)])\n start += args.batch_size\n #print(\"Batch placeholder\")\n #print(batch_placeholder)\n batch_count = 0\n\n chunk_pos += take_from_chunk\n\n word_cnt += len(sentence)\n if word_cnt - last_word_cnt > 10000:\n with word_count_actual.get_lock():\n word_count_actual.value += word_cnt - last_word_cnt\n last_word_cnt = word_cnt\n sentence.clear()\n\n with word_count_actual.get_lock():\n word_count_actual.value += word_cnt - last_word_cnt\n\n #print(\"Total occurrences of mattrum: \" + str(mattrum_cnt))\n #print(\"Total non-occurrences of mattrum: \" + str(non_mattrum_cnt))\n if batch_count > 0:\n if args.shuffle:\n p = torch.randperm(batch_count)\n batch_placeholder[:batch_count] = batch_placeholder[p]\n\n start = 0\n while start < batch_count:\n data_queue.put(batch_placeholder[start : min(start + args.batch_size, batch_count)])\n start += args.batch_size\n #print(\"Batch placeholder\")\n #print(batch_placeholder)\n batch_count = 0\n data_queue.put(None)\n\ndef train_process(p_id, word_count_actual, word2idx, word_list, freq, args, model, word2morph, word2morph_mask, ctx2morph, ctx2morph_mask):\n data_queue = mp.SimpleQueue()\n\n if args.opt == \"Adagrad\":\n optimizer = optim.Adagrad(model.parameters(), lr=args.lr)\n elif args.opt == \"SGD\":\n optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum)\n elif args.opt == 'SparseAdam':\n optimizer = optim.SparseAdam(model.parameters(), lr=args.lr)\n\n t = mp.Process(target=train_process_sent_producer, args=(p_id, data_queue, word_count_actual, word2idx, word_list, freq, args))\n t.start()\n\n # get from data_queue and feed to model\n prev_word_cnt = 0\n losses_cnt = 0\n total_loss = 0.0\n losses_file = open(args.losslog, 'w')\n lr = args.lr\n #mattrum_cnt = 0\n #non_mattrum_cnt = 0\n while True:\n d = data_queue.get()\n if d is None:\n break\n else:\n # lr anneal\n if args.anneal:\n if word_count_actual.value - prev_word_cnt > 10000:\n lr = args.lr * (1 - word_count_actual.value / (args.iter * args.train_words))\n if lr < 0.0001 * args.lr:\n lr = 0.0001 * args.lr\n for param_group in optimizer.param_groups:\n param_group['lr'] = lr\n else:\n lr = args.lr\n\n if args.cuda:\n data = Variable(torch.LongTensor(d).cuda(), requires_grad=False)\n else:\n data = Variable(torch.LongTensor(d), requires_grad=False)\n\n if args.cbow == 1:\n optimizer.zero_grad()\n loss = model(data)\n loss.backward()\n optimizer.step()\n model.emb0_lookup.weight.data[args.vocab_size].fill_(0)\n elif args.cbow == 0:\n optimizer.zero_grad()\n #print(\"WORD\")\n #print(data[3][0])\n loss = model(data, word2morph[data[:, 0]], word2morph_mask[data[:, 0]], ctx2morph[data[:, 1:2+args.negative]], ctx2morph_mask[data[:, 1:2+args.negative]])\n loss.backward()\n #model.emb0morph_lookup.weight.data.grad[args.morph_size+1].fill_(0)\n optimizer.step()\n #model.emb0morph_lookup.weight.data[args.morph_size+1].zero_()\n \n losses_cnt += data.shape[0]\n total_loss += loss\n\n # output\n if word_count_actual.value - prev_word_cnt > 10000:\n avg_loss = total_loss/losses_cnt\n sys.stdout.write(\"\\rAlpha: %0.8f, Loss: %0.8f, Progress: %0.2f, Words/sec: %f\" % (lr, avg_loss, word_count_actual.value / (args.iter * args.train_words) * 100, word_count_actual.value / (time.monotonic() - args.t_start)))\n sys.stdout.flush()\n prev_word_cnt = word_count_actual.value\n losses_cnt = 0\n total_loss = 0.0\n losses_file.write(str(avg_loss.item()) + '\\n')\n\n losses_file.close()\n t.join()\n\nif __name__ == '__main__':\n set_start_method('forkserver')\n\n args = parser.parse_args()\n print(\"Starting training using file %s\" % args.train)\n train_file = open(args.train)\n train_file.seek(0, 2)\n vars(args)['file_size'] = train_file.tell()\n\n word2idx, word_list, freq = build_vocab(args)\n # constructing and applying atomizer to all words\n minL = args.minL\n maxL = args.maxL\n use_listify = not args.halfletters\n if args.atomizer == 'word2vec':\n atomizer = lambda w: trivial_atoms(w)\n elif args.atomizer == 'fasttext':\n atomizer = lambda w: skipgram_atoms(w, minL=minL, maxL=maxL)\n elif args.atomizer == 'morphoseg':\n atomizer = lambda w: morpheme_split(w, minL=minL, maxL=maxL, use_listify=use_listify, to_stem=True)\n \n morph2idx, morph_list, word2morph = build_morph(args, word2idx, word_list, freq, atomizer)\n vars(args)['morph_size'] = len(morph2idx)\n\n ctxmorph2idx, ctxmorph_list, ctx2morph = build_morph(args, word2idx, word_list, freq, trivial_atoms)\n vars(args)['ctxmorph_size'] = len(ctxmorph2idx)\n\n #print(word2morph.shape)\n #print(ctx2morph.shape)\n \n\n \"\"\" idx = 200\n word = word_list[idx]\n print(\"Word: \" + word)\n print(\"Index should be: \" + str(word2idx[word]))\n all_morphs = word2morph[idx]\n for midx in all_morphs:\n print(\"Morpheme: \" + morph_list[midx])\n print(\"Index used for lookup: \" + str(midx))\n print(\"Index retrieved: \" + str(morph2idx[morph_list[midx]])) \"\"\"\n\n word_count_actual = mp.Value('L', 0)\n\n model = init_net(args)\n model.share_memory()\n word2morph_mask = torch.unsqueeze((word2morph <= args.morph_size), dim=2).type(model.emb0morph_lookup.weight.data.dtype)\n ctx2morph_mask = torch.unsqueeze((ctx2morph <= args.ctxmorph_size), dim=2).type(model.emb1morph_lookup.weight.data.dtype)\n \n if args.cuda:\n model.cuda()\n word2morph = word2morph.cuda()\n word2morph_mask = word2morph_mask.cuda()\n ctx2morph = ctx2morph.cuda()\n ctx2morph_mask = ctx2morph_mask.cuda()\n\n #print(word2morph_mask.shape)\n #print(ctx2morph_mask.shape)\n\n vars(args)['t_start'] = time.monotonic()\n processes = []\n for p_id in range(args.processes):\n p = mp.Process(target=train_process, args=(p_id, word_count_actual, word2idx, word_list, freq, args, model, word2morph, word2morph_mask, ctx2morph, ctx2morph_mask))\n p.start()\n processes.append(p)\n\n for p in processes:\n p.join()\n\n torch.cuda.empty_cache()\n\n # print out the atom input vectors\n if args.cuda:\n embs = model.emb0morph_lookup.weight.data.cpu().numpy()\n else:\n embs = model.emb0morph_lookup.weight.data.numpy()\n \n #print(embs.shape)\n data_producer.write_embs(args.atomoutput, morph_list, embs, args.morph_size, args.size)\n del embs\n torch.cuda.empty_cache()\n\n wordembs = np.zeros((word2morph.shape[0], args.size), dtype=np.float32)\n print(wordembs.shape)\n # word input vectors\n if args.cuda:\n numpieces = 5\n cnt = word2morph.shape[0] // numpieces\n print(\"Need to handle \" + str(word2morph.shape[0]) + \" words\")\n for j in range(numpieces):\n start = j * cnt\n end = start + cnt\n if j == numpieces - 1:\n end = word2morph.shape[0]\n print(\"Handling all words from \" + str(start) + \" to \" + str(end))\n wordembs[start:end] = torch.sum(model.emb0morph_lookup(word2morph[start:end]) * word2morph_mask[start:end], dim=1).detach().cpu().numpy()\n else:\n wordembs = torch.sum(model.emb0morph_lookup(word2morph) * word2morph_mask, dim=1).detach().numpy()\n\n #print(wordembs.shape)\n data_producer.write_embs(args.output, word_list, wordembs, args.vocab_size, args.size)\n del wordembs\n torch.cuda.empty_cache()\n\n # atom context vectors\n if args.cuda:\n atembs = model.emb1morph_lookup.weight.data.cpu().numpy()\n else:\n atembs = model.emb1morph_lookup.weight.data.numpy()\n \n #print(atembs.shape)\n data_producer.write_embs(args.ctxatomoutput, ctxmorph_list, atembs, args.ctxmorph_size, args.size)\n del atembs\n torch.cuda.empty_cache()\n\n # word context vectors\n ctxembs = np.zeros((ctx2morph.shape[0], args.size), dtype=np.float32)\n print(ctxembs.shape)\n if args.cuda:\n numpieces = 5\n cnt = ctx2morph.shape[0] // numpieces\n print(\"Need to handle \" + str(ctx2morph.shape[0]) + \" words\")\n for j in range(numpieces):\n start = j * cnt\n end = start + cnt\n if j == numpieces - 1:\n end = ctx2morph.shape[0]\n print(\"Handling all words from \" + str(start) + \" to \" + str(end))\n ctxembs[start:end] = torch.sum(model.emb1morph_lookup(ctx2morph[start:end]) * ctx2morph_mask[start:end], dim=1).detach().cpu().numpy()\n else:\n ctxembs = torch.sum(model.emb1morph_lookup(ctx2morph) * ctx2morph_mask, dim=1).detach().numpy()\n\n #print(ctxembs.shape)\n data_producer.write_embs(args.ctxoutput, word_list, ctxembs, args.vocab_size, args.size)\n del ctxembs\n torch.cuda.empty_cache()\n\n print(\"\")\n\n", "meta": {"hexsha": "94633901f9dd9fe9d6453b2bb827bffd3f1c2613", "size": 26576, "ext": "py", "lang": "Python", "max_stars_repo_path": "pytorch-word2vec-master/.ipynb_checkpoints/main-checkpoint.py", "max_stars_repo_name": "arjun-sai-krishnan/tamil-morpho-embeddings", "max_stars_repo_head_hexsha": "a33bcb427d635dba3b1857f26ea7ab287e1a44c5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-04-11T18:25:16.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-16T03:48:52.000Z", "max_issues_repo_path": "pytorch-word2vec-master/.ipynb_checkpoints/main-checkpoint.py", "max_issues_repo_name": "arjun-sai-krishnan/tamil-morpho-embeddings", "max_issues_repo_head_hexsha": "a33bcb427d635dba3b1857f26ea7ab287e1a44c5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pytorch-word2vec-master/.ipynb_checkpoints/main-checkpoint.py", "max_forks_repo_name": "arjun-sai-krishnan/tamil-morpho-embeddings", "max_forks_repo_head_hexsha": "a33bcb427d635dba3b1857f26ea7ab287e1a44c5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.6983154671, "max_line_length": 237, "alphanum_fraction": 0.6038154726, "include": true, "reason": "import numpy", "num_tokens": 6726, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073655352403, "lm_q2_score": 0.35936413829896496, "lm_q1q2_score": 0.19786854145663482}} {"text": "###################################\n# Script : \n# 1) Contains class to validate models\n# built using SAS datasets\n#\n# ganesans - Salilab - UCSF\n# ganesans@salilab.org\n###################################\nimport pandas as pd\nimport sys,os,math\nimport numpy as np\nimport pandas as pd\nimport re,pickle,requests,json\nfrom sklearn.linear_model import LinearRegression\nfrom decimal import Decimal\nfrom validation import get_input_information \nfrom subprocess import run, call, PIPE\nfrom decouple import config\n\n\n\nclass sas_validation(get_input_information):\n def __init__(self,mmcif_file):\n super().__init__(mmcif_file)\n self.ID=str(get_input_information.get_id(self))\n self.nos=get_input_information.get_number_of_models(self)\n self.dataset=get_input_information.get_dataset_comp(self) \n self.imagepath='../static/images/'\n self.saslink='https://www.sasbdb.org/media/sascif/sascif_files/'\n self.sasentry='https://www.sasbdb.org/rest-api/entry/summary/'\n \n def get_SASBDB_code(self)->list:\n '''\n function to get all SASBDB codes used in the model,\n returns a list of SASBDB codes\n '''\n SAS_db_codes=[]\n for indx,datatype in enumerate(self.dataset['Dataset type']):\n if 'SAS' in str(datatype):\n SAS_db_codes.append(self.dataset['Data access code'][indx])\n return SAS_db_codes\n\n def clean_SASBDB_code(self)->list:\n '''\n function to clean SASBDB list of codes\n as some might have 'None' or can be repetitive \n '''\n codes=list(set(self.get_SASBDB_code()))\n cleaned_code=[i for i in codes if i != 'None']\n return cleaned_code\n\n def get_data_from_SASBDB(self)->dict:\n '''\n get data from JSON\n '''\n data_dic={}\n for code in self.get_SASBDB_code():\n if 'None' not in str(code):\n url_f=self.sasentry+code+'.json'\n response=requests.get(url_f, data={'key':'value'});\n if response.status_code!=200:\n print (\"Error....unable to fetch data from SASBDB, please check the entry ID\")\n data_dic[code]=response.json();\n with open (code+'.json', 'w') as f:\n formatted_data=json.dumps(response.json(), indent = 4, sort_keys=True);\n f.write(formatted_data);\n return data_dic\n\n def get_sascif_file(self):\n '''\n get data from SASCIF files\n '''\n for code in self.get_SASBDB_code():\n if 'None' not in str(code):\n url_f=self.saslink+code+'.sascif'\n response=requests.get(url_f);\n if response.status_code!=200:\n print (\"Error....unable to fetch data from SASBDB, please check the entry ID\")\n with open (code+'.sascif', 'w') as f:\n f.write(response.text);\n\n def get_all_sascif(self,sasbdb)->list:\n '''\n get a list of all lines in a SASCIF file\n '''\n if 'None' not in str(sasbdb):\n file=open(sasbdb+'.sascif','r')\n all_lines=[data.strip().split() for indx,data in enumerate(file.readlines())]\n return all_lines\n\n def get_intensities(self)->dict:\n '''\n get intensity data from SASCIF file\n if SASCIF file is not present, this information will not be present/used in the report\n JSON file typically has raw data \n '''\n self.get_sascif_file()\n Int_dict={}\n for code in self.clean_SASBDB_code():\n #Int_dict={}\n all_lines=self.get_all_sascif(code)\n data={}\n for indx,sascifline in enumerate(all_lines):\n if len(sascifline)<2 and len(sascifline)>0 and 'scan_intensity' in sascifline[0]:\n data[(sascifline[0].split('.')[1])]=[]\n if len(sascifline)>2 and len(all_lines[indx-1])>0 and'scan_intensity' in all_lines[indx-1][0]:\n for indx_sub,sascifline_sub in enumerate(all_lines[indx:]):\n if len(sascifline_sub)>2 and '#' not in sascifline_sub and 'sas' not in sascifline_sub[0] : \n for num,key in enumerate(list(data.keys())):\n data[key].append(sascifline_sub[num])\n else:\n break \n I_df=pd.DataFrame(list(data.values()),index=list(data.keys())).T\n I_df_re=I_df[['momentum_transfer','intensity','intensity_su_counting']]\n I_df_re.rename(columns={'momentum_transfer':'Q','intensity':'I','intensity_su_counting':'E'},inplace=True)\n Int_dict[code]=I_df_re\n return Int_dict\n\n def modify_intensity(self)->dict:\n '''\n modify intensity data to calcualte errors and log values\n '''\n Int_dict=self.get_intensities()\n Int_dict_modify={}\n rg_and_io=self.get_rg_and_io()\n for key,val in Int_dict.items():\n Rg=rg_and_io[key][0]\n IO=rg_and_io[key][1]\n dim_num=Rg*Rg/IO\n I_df=val.astype({'Q':float,'I':float,'E':float})\n I_df=I_df[I_df['I']-I_df['E']>0]\n I_df['Q']=I_df['Q']*10\n I_df['err_x']=I_df.apply(lambda row: (row['Q'],row['Q']), axis=1) \n I_df['err_y']=I_df.apply(lambda row: (np.log(row['I']-row['E']),np.log(row['I']+row['E'])),axis=1)\n I_df['logI']=np.log(I_df['I'])\n I_df['logQ']=np.log(I_df['Q'])\n I_df['logX']=I_df.apply(lambda row: (row['logQ'],row['logQ']), axis=1)\n I_df['Ky']=I_df['Q']*I_df['Q']*I_df['I']*dim_num\n I_df['Kx']=I_df['Q']*Rg\n I_df['Px']=I_df['Q']**4\n I_df['Px'].round(3)\n I_df['Py']=I_df['Px']*I_df['I']\n Int_dict_modify[key]=I_df\n return Int_dict_modify\n\n def modify_intensity_dep(self)->dict:\n '''\n depreciated function to get intensities from JSON/raw data\n '''\n Int_dict=self.get_intensities()\n Int_dict_modify={}\n for key,val in Int_dict.items():\n I_df=val.astype({'Q':float,'I':float,'E':float})\n I_df.head()\n I_df=I_df[I_df['I']-I_df['E']>0]\n I_df['Q']=I_df['Q']*10\n I_df['err_x']=I_df.apply(lambda row: (row['Q'],row['Q']), axis=1) \n I_df['err_y']=I_df.apply(lambda row: (np.log(row['I']-row['E']),np.log(row['I']+row['E'])),axis=1)\n I_df['logI']=np.log(I_df['I'])\n I_df['logQ']=np.log(I_df['Q'])\n I_df['logX']=I_df.apply(lambda row: (row['logQ'],row['logQ']), axis=1)\n I_df['Ky']=I_df['Q']*I_df['Q']*I_df['I']\n I_df['Px']=I_df['Q']**4\n I_df['Px'].round(3)\n I_df['Py']=I_df['Px']*I_df['I']\n Int_dict_modify[key]=I_df\n return Int_dict_modify\n\n def get_rg_for_plot(self)->dict:\n '''\n get Rg values from SASCIF file, if unavailabel, get it from JSON\n '''\n self.get_sascif_file()\n Rg_dict={}\n for code in self.clean_SASBDB_code():\n rg={};\n all_lines=self.get_all_sascif(code)\n for indx,sascifline in enumerate(all_lines):\n if len(sascifline)<3 and len(sascifline)>0 and 'sas_result.Rg_from_PR' in sascifline[0] and'sas_result.Rg_from_PR_' not in sascifline[0] :\n rg[sascifline[0].split('.')[1]]=float(sascifline[1])\n if len(sascifline)<3 and len(sascifline)>0 and 'sas_result.Rg_from_Guinier' in sascifline[0] and'sas_result.Rg_from_Guinier_' not in sascifline[0] :\n rg[sascifline[0].split('.')[1]]=float(sascifline[1])\n Rg_dict[code]=list(rg.values())\n\n if len(list(rg.values()))<1:\n data_dic=self.get_data_from_SASBDB()\n for key,val in data_dic.items():\n Rg_dict[key]=[]\n Rg_dict[key].append(round(float(val['guinier_rg']),2))\n Rg_dict[key].append(round(float(val['pddf_rg']),2))\n return Rg_dict\n\n def get_rg_and_io(self)->dict:\n '''\n get rg information from SASCIF file\n '''\n self.get_sascif_file()\n rg_and_io={}\n for code in self.clean_SASBDB_code():\n all_lines=self.get_all_sascif(code)\n for indx,sascifline in enumerate(all_lines):\n if len(sascifline)<3 and len(sascifline)>0 and 'sas_result.Rg_from_PR' in sascifline[0] and'sas_result.Rg_from_PR_' not in sascifline[0] :\n rg=float(sascifline[1])\n if len(sascifline)<3 and len(sascifline)>0 and '_sas_result.I0_from_PR' in sascifline[0] and'_sas_result.I0_from_PR_' not in sascifline[0] :\n io=float(sascifline[1])\n rg_and_io[code]=(rg,io)\n return rg_and_io\n\n def get_rg_table_many(self)->dict:\n '''\n get rg information from multiple SASCIF files\n '''\n data_dic=self.get_data_from_SASBDB()\n rg_table={'SASDB ID':[],'Rg':[],'Rg error':[],'MW':[],'MW error':[]} \n for key,val in data_dic.items():\n rg_table['Rg'].append(str(round(float(val['guinier_rg']),2))+ ' nm')\n try:\n rg_table['Rg error'].append(val['guinier_rg_error']+ ' nm')\n except:\n rg_table['Rg error'].append('N/A')\n try:\n rg_table['MW'].append(val['guinier_i0_mw']+ ' nm')\n except:\n rg_table['MW'].append('N/A')\n try:\n rg_table['MW error'].append(val['guinier_i0_mw_error']+ ' nm')\n except:\n rg_table['MW error'].append('N/A')\n rg_table['SASDB ID'].append(key)\n return rg_table\n\n\n def get_fits_for_plot(self)->dict:\n '''\n get chi-squared values from SASCIF files\n '''\n self.get_sascif_file()\n fit_dict={}\n for code in self.clean_SASBDB_code():\n fits=[];\n all_lines=self.get_all_sascif(code)\n for indx,sascifline in enumerate(all_lines):\n if (len(sascifline)<3) and (len(sascifline)>0) and ('sas_model_fitting_details.chi_square' in sascifline[0]) and (float(sascifline[1])>0.00000):\n fits.append(round(float(sascifline[1]),2))\n if len(fits)>0:\n fit_dict[code]=fits\n return fit_dict\n\n def get_pofr(self)->dict:\n '''\n get pair-dist distribution from SASCIF files\n '''\n pofr_dict={}\n for code in self.clean_SASBDB_code():\n all_lines=self.get_all_sascif(code)\n data={}\n for indx,sascifline in enumerate(all_lines):\n if len(sascifline)<2 and len(sascifline)>0 and 'sas_p_of_R.' in sascifline[0]:\n data[(sascifline[0].split('.')[1])]=[]\n if len(sascifline)>2 and len(all_lines[indx-1])>0 and 'sas_p_of_R.' in all_lines[indx-1][0]:\n for subindx,subval in enumerate(all_lines[indx:]):\n if len(subval)>2 and '#' not in subval and 'sas' not in subval[0] :\n for num,key in enumerate(list(data.keys())):\n data[key].append(subval[num])\n else:\n break\n pdf=pd.DataFrame(list(data.values()),index=list(data.keys())).T\n pdf_re=pdf[['r','P','P_error']]\n pdf_re.rename(columns={'r':'R','P':'P','P_error':'E'},inplace=True)\n pofr_dict[code]=pdf_re\n return pofr_dict\n\n def get_pvals(self)->dict:\n '''\n get p-values from ATSAS \n '''\n data_dic=self.get_data_from_SASBDB()\n num_of_fits=self.get_number_of_fits()\n pval_table={'SASDB ID':[],'Model':[],'p-value':[]} \n for key,val in data_dic.items():\n num=num_of_fits[key]\n if num>0:\n for fitnum in range(0,num):\n pval_table['SASDB ID'].append(key)\n pval_table['Model'].append(fitnum+1)\n target_url=val['fits'][fitnum]['fit_data'] \n fit = requests.get(target_url);\n if fit.status_code !=200:\n print (\"Error....unable to fetch data from SASBDB, please check the entry ID\")\n fname=key+str(fitnum)+'fit.csv'\n with open (fname,'w') as f:\n f.write(fit.text)\n f_df=pd.read_csv(fname, skiprows=3,delim_whitespace=True, names=['Q','Ie','Ib','E'])\n if abs(f_df.iloc[22,2]-f_df.iloc[22,1])>abs(f_df.iloc[22,3]-f_df.iloc[22,1]):\n f_df.rename(columns={'Q':'Q','Ie':'Ie','Ib':'E','E':'Ib'},inplace=True)\n fit_1=f_df[['Q','Ie']]\n fit_1.to_csv('fit1.csv',header=False,index=False)\n fit_2=f_df[['Q','Ib']]\n fit_2.to_csv('fit2.csv',header=False,index=False)\n f1=open('pval.txt','w+')\n with f1 as outfile:\n run([config('ATSAS'),'fit1.csv','fit2.csv'],stdout=outfile)\n f2=open('pval.txt','r')\n all_lines=[j.strip().split() for i,j in enumerate(f2.readlines())]\n p_val=[all_lines[i+1][4] for i,j in enumerate(all_lines) if 'adj' in j][0]\n pval_table['p-value'].append('%.2E' % Decimal(p_val))\n else:\n pval_table['SASDB ID'].append(key)\n pval_table['Model'].append('N/A')\n pval_table['p-value'].append('N/A')\n return pval_table\n\n def get_pofr_ext(self)->dict:\n '''\n get pair-distance details from SASCIF files\n '''\n pofr_dict={}\n for code in self.clean_SASBDB_code():\n all_lines=self.get_all_sascif(code)\n data={}\n for indx,sascifline in enumerate(all_lines):\n if len(sascifline)<2 and len(sascifline)>0 and '_sas_p_of_R_extrapolated_intensity.' in sascifline[0]:\n data[(sascifline[0].split('.')[1])]=[]\n if len(sascifline)>2 and len(all_lines[indx-1])>0 and '_sas_p_of_R_extrapolated_intensity.' in all_lines[indx-1][0]:\n for subindx,subval in enumerate(all_lines[indx:]):\n if len(subval)>2 and '#' not in subval and 'sas' not in subval[0] :\n for num,key in enumerate(list(data.keys())):\n data[key].append(subval[num])\n else:\n break\n pdf=pd.DataFrame(list(data.values()),index=list(data.keys())).T\n pdf_re=pdf[['momentum_transfer','intensity_reg']]\n pdf_re.rename(columns={'momentum_transfer':'Q','intensity_reg':'I'},inplace=True)\n pdf_re=pdf_re.astype({'Q':float,'I':float})\n pdf_re['Q']=pdf_re['Q']*10\n pdf_re['logI']=np.log(pdf_re['I'])\n pofr_dict[code]=pdf_re\n return pofr_dict\n\n def get_pofr_errors(self)->dict:\n '''\n get pair-distance details and errors from JSON files\n '''\n pofr_dict=self.get_pofr_ext()\n Int_dict=self.modify_intensity()\n compiled_dict={}\n for code in self.clean_SASBDB_code():\n I_df=Int_dict[code]\n I_df_dict= dict(zip(I_df.Q, I_df.I))\n I_df_err_dict= dict(zip(I_df.Q, I_df.E))\n p_df=pofr_dict[code]\n p_df_dict=dict(zip(p_df.Q, p_df.I))\n errors=[]\n for Q,I in p_df_dict.items():\n data_Q=self.findMinDiff(list(I_df_dict.keys()),Q)\n if data_Q != 9999:\n data_I=I_df_dict[data_Q]\n delta_I=(I-data_I)\n if I_df_err_dict[data_Q] != 0:\n wt_delta_I=delta_I/I_df_err_dict[data_Q]\n else:\n wt_delta_I=0\n errors.append([Q,delta_I,wt_delta_I])\n errors_df=pd.DataFrame(errors,columns=['Q','R','WR'])\n compiled_dict[code]=errors_df\n return compiled_dict\n\n def findMinDiff(self,listn: list, num: int)-> int: \n '''\n quick min diff operation for calculating errors\n '''\n list_sub=[(i,abs(j-num)) for i,j in enumerate(listn)]\n list_sort=sorted(list_sub, key=lambda x: x[1])\n if list_sort[0][1]<0.00001:\n return listn[list_sort[0][0]]\n else:\n return 9999 \n\n def get_Guinier_data(self)->(dict,dict):\n '''\n get Guinier plot data from JSON files\n '''\n Int_dict=self.get_intensities()\n data_dic=self.get_data_from_SASBDB()\n Guinier_dict={};Guinier_score={}\n for key,val in Int_dict.items():\n G_df=val.astype({'Q':float,'I':float,'E':float})\n G_df['logI']=np.log(G_df['I'])\n rg=float(data_dic[key]['pddf_rg'])\n dmax=float(data_dic[key]['pddf_dmax'])\n index_low=int(data_dic[key]['guinier_point_first'])\n index_high=int(data_dic[key]['guinier_point_last'])\n q_min=math.pi/(dmax*10)\n q_max=1.3/(rg*10)\n G_df_range=G_df[G_df['Q']dict:\n '''\n get volume parameters from JSON files \n '''\n data_dic=self.get_data_from_SASBDB()\n parameter_table={'SASDB ID':[],'Estimated volume':[],'Estimated volume method':[],'Porod volume':[]}\n for key,val in data_dic.items():\n try:\n if parameter_table['Estimated volume'] is None:\n parameter_table['Estimated volume'].append('N/A')\n else:\n parameter_table['Estimated volume'].append(val['estimated_volume'])\n if parameter_table['Estimated volume method'] is None:\n parameter_table['Estimated volume method'].append('N/A')\n else:\n parameter_table['Estimated volume method'].append(val['estimated_volume_method'])\n except:\n parameter_table['Estimated volume'].append('N/A')\n parameter_table['Estimated volume method'].append('N/A')\n try:\n parameter_table['Porod volume'].append(val['porod_volume']+' nm\\u00b3')\n except:\n parameter_table['Porod volume'].append('N/A')\n parameter_table['SASDB ID'].append(key)\n return parameter_table\n\n def get_parameters_vol_many(self)->dict:\n '''\n get volume details from SASCIF files\n '''\n self.get_sascif_file()\n parameter_table={'SASDB ID':[],'Estimated Volume':[],'Porod Volume':[],'Specific Volume':[],\n 'Sample Contrast':[],'Sample Concentration':[]} \n for code in self.clean_SASBDB_code():\n parameter_table['SASDB ID'].append(code)\n all_lines=self.get_all_sascif(code)\n for indx,sascifline in enumerate(all_lines):\n if len(sascifline)<3 and len(sascifline)>0 and '_sas_sample.specimen_concentration' in sascifline[0]:\n if len(sascifline[1])>1:\n parameter_table['Sample Concentration'].append(str(round(float(sascifline[1]),2))+' mg/ml')\n else:\n parameter_table['Sample Concentration'].append('N/A')\n if len(sascifline)<3 and len(sascifline)>0 and '_sas_sample.contrast' in sascifline[0] :\n if len(sascifline[1])>1:\n parameter_table['Sample Contrast'].append(str(round(float(sascifline[1]),2)))\n else:\n parameter_table['Sample Contrast'].append('N/A')\n if len(sascifline)<3 and len(sascifline)>0 and '_sas_sample.specific_vol' in sascifline[0]:\n if len(sascifline[1])>1:\n parameter_table['Specific Volume'].append(str(round(float(sascifline[1]),2))+' nm\\u00b3')\n else:\n parameter_table['Specific Volume'].append('N/A')\n if len(sascifline)<3 and len(sascifline)>0 and '_sas_result.Porod_volume' in sascifline[0] and '_sas_result.Porod_volume_error' not in sascifline[0]:\n if len(sascifline[1])>1:\n parameter_table['Porod Volume'].append(str(round(float(sascifline[1]),2))+' nm\\u00b3')\n else:\n parameter_table['Porod Volume'].append('N/A')\n if len(sascifline)<3 and len(sascifline)>0 and '_sas_result.estimated_volume' in sascifline[0] and '_sas_result.estimated_volume_error' not in sascifline[0]:\n if len(sascifline[1])>1:\n parameter_table['Estimated Volume'].append(str(round(float(sascifline[1]),2))+' nm\\u00b3')\n else:\n parameter_table['Estimated Volume'].append('N/A')\n return parameter_table\n\n\n def get_parameters_mw_many(self)->dict:\n '''\n get MW details from SASCIF files\n '''\n self.get_sascif_file()\n parameter_table={'SASDB ID':[],'Chemical composition MW':[],'Standard MW':[],'Porod Volume/MW':[]} \n for code in self.clean_SASBDB_code():\n parameter_table['SASDB ID'].append(code)\n all_lines=self.get_all_sascif(code)\n for indx,sascifline in enumerate(all_lines):\n if len(sascifline)<3 and len(sascifline)>0 and '_sas_result.experimental_MW' in sascifline[0] and '_sas_result.experimental_MW_error' not in sascifline[0]:\n if len(sascifline[1])>1:\n parameter_table['Chemical composition MW'].append(str(round(float(sascifline[1]),2))+' kDa')\n else:\n parameter_table['Chemical composition MW'].append('N/A')\n if len(sascifline)<3 and len(sascifline)>0 and '_sas_result.MW_standard' in sascifline[0] and '_sas_result.MW_standard_error' not in sascifline[0]:\n if len(sascifline[1])>1:\n parameter_table['Standard MW'].append(str(round(float(sascifline[1]),2))+' kDa')\n else:\n parameter_table['Standard MW'].append('N/A')\n if len(sascifline)<3 and len(sascifline)>0 and '_sas_result.MW_Porod' in sascifline[0] and '_sas_result.MW_Porod_error' not in sascifline[0]:\n if len(sascifline[1])>1:\n Porod_MW=round(float(sascifline[1]),2)\n else:\n Porod_MW=0\n if len(sascifline)<3 and len(sascifline)>0 and '_sas_result.Porod_volume' in sascifline[0] and '_sas_result.Porod_volume_error' not in sascifline[0]:\n if len(sascifline[1])>1 and Porod_MW>0:\n Porod_V=round(float(sascifline[1]),2)/Porod_MW\n parameter_table['Porod Volume/MW'].append(str(round(Porod_V,2))+' nm \\u00b3/kDa')\n else:\n parameter_table['Porod Volume/MW'].append('N/A')\n\n return parameter_table\n\n def get_parameters_mw_many_dep(self)->dict:\n '''\n depreciated function on getting MW from JSON\n '''\n data_dic=self.get_data_from_SASBDB()\n #MW based on chemical composition\n parameter_table={'SASDB ID':[],'Sequence MW':[],'Experimental MW':[],'Porod MW':[]} \n for key,val in data_dic.items():\n try:\n parameter_table['Experimental MW'].append(list(data_dic.values())[0]['experimental_mw']+' kDa')\n except:\n parameter_tabel['Experimental MW'].append('N/A')\n try:\n parameter_table['Porod MW'].append(list(data_dic.values())[0]['porod_mw']+' kDa')\n except:\n parameter_table['Porod MW'].append('N/A')\n try:\n parameter_table['Sequence MW'].append(list(data_dic.values())[0]['experiment']['sample']['molecule'][0]['total_mw']+' kDa')\n except:\n parameter_table['Sequence MW'].append('N/A')\n parameter_table['SASDB ID'].append(key)\n return parameter_table\n \n def get_pddf(self)->dict:\n '''\n get p(r) data from JSON\n '''\n data_dic=self.get_data_from_SASBDB()\n pofr_dic=self.get_pofr()\n pddf_dic={}\n for key,val in pofr_dic.items():\n pd_df=val.astype({'P':float,'R':float,'E':float})\n pd_df['R']=pd_df['R']/10;\n pd_df['err_x']=pd_df.apply(lambda row: (row['R'],row['R']), axis=1)\n pd_df['err_y']=pd_df.apply(lambda row: (row['P']-row['E'],row['P']+row['E']),axis=1)\n pddf_dic[key]=pd_df\n return pddf_dic\n\n def get_pddf_info(self)->dict:\n '''\n get p(r) related info from JSON\n '''\n data_dic=self.get_data_from_SASBDB()\n pddf_info={'SASDB ID':[],'Software used':[],'Dmax':[],'Dmax error':[],'Rg':[],'Rg error':[]}\n for key,val in data_dic.items():\n pddf_info['Software used'].append(str(val['pddf_software']))\n try:\n pddf_info['Dmax'].append(str(val['pddf_dmax'])+' nm')\n except: \n pddf_info['Dmax'].append('N/A')\n try:\n pddf_info['Rg'].append(str(val['pddf_rg'])+' nm')\n except:\n pddf_info['Rg'].append('N/A')\n try:\n if val['pddf_dmax_error'] is None:\n pddf_info['Dmax error'].append('N/A')\n else:\n pddf_info['Dmax error'].append(str(val['pddf_dmax_error'])+' nm')\n except:\n pddf_info['Dmax error'].append('N/A')\n try:\n pddf_info['Rg error'].append(str(val['pddf_rg_error'])+' nm')\n except:\n pddf_info['Rg error'].append('N/A')\n pddf_info['SASDB ID'].append(key)\n return pddf_info\n\n def get_number_of_fits(self)->dict:\n '''\n get number of fits from JSON, deprecated\n '''\n data_dic=self.get_data_from_SASBDB()\n num_of_fits={}\n for key,val in data_dic.items():\n num_of_fits[key]=len(val['fits'])\n return num_of_fits\n\n def get_chi_table(self)->dict:\n '''\n get chi value from JSON, deprecated\n '''\n data_dic=self.get_data_from_SASBDB()\n chi_table={'SASDB ID':[],'Model':[],'\\u03C7\\u00b2':[]} \n for key,val in data_dic.items():\n numoffits=self.get_number_of_fits()[key]\n if numoffits>0:\n for fitnum in range(0,numoffits):\n count=fitnum+1\n chi_table['SASDB ID'].append(key) \n chi_table['Model'].append(str(count))\n chi_value=val['fits'][fitnum]['chi_square_value']\n chi_value_round=round(chi_value,2)\n chi_table['\\u03C7'+'\\u00b2'].append(chi_value_round)\n else:\n chi_table['SASDB ID'].append(key)\n chi_table['Model'].append('N/A')\n chi_table['\\u03C7'+'\\u00b2'].append('N/A')\n return chi_table\n\n def get_sasdb_code_fits(self)->list:\n '''\n get number of fits per SASBDB ID\n '''\n fit_dict=self.get_number_of_fits()\n return list(fit_dict.values())\n\n def get_fit_data(self)->dict:\n '''\n get fit information to make plots, from JSON\n '''\n data_dic=self.get_data_from_SASBDB()\n num_of_fits=self.get_number_of_fits()\n data_fit={}\n for key,val in data_dic.items():\n num=num_of_fits[key]\n fits={}\n if num>0:\n for fitnum in range(0,num):\n target_url=val['fits'][fitnum]['fit_data'] \n fit = requests.get(target_url);\n if fit.status_code !=200:\n print (\"Error....unable to fetch data from SASBDB, please check the entry ID\")\n \n fname=key+str(fitnum)+'fit.csv'\n with open (fname,'w') as f:\n f.write(fit.text)\n \n f_df=pd.read_csv(fname, skiprows=3,delim_whitespace=True, names=['Q','Ie','Ib','E'])\n if abs(f_df.iloc[22,2]-f_df.iloc[22,1])>abs(f_df.iloc[22,3]-f_df.iloc[22,1]):\n f_df.rename(columns={'Q':'Q','Ie':'Ie','Ib':'E','E':'Ib'},inplace=True)\n f_df['logIe']=np.log(f_df['Ie'])\n f_df['logIb']=np.log(f_df['Ib'])\n f_df['r']=f_df['Ie']-f_df['Ib']\n \n if f_df['E'].isnull().values.any():\n f_df['rsigma']=0\n else:\n f_df['rsigma']=f_df['r']/f_df['E']\n #f_df['rsigma']=f_df['r']/f_df['E']\n f_df['logr']=f_df['logIe']-f_df['logIb']\n f_df['r2a']=(f_df['Ib']-f_df['Ie'].mean())**2\n f_df['r2b']=(f_df['Ie']-f_df['Ie'].mean())**2\n fits[fitnum]=(self.get_fit_r2(f_df),f_df)\n else:\n fits[0]=(0,pd.DataFrame())\n #data_fit=None\n data_fit[key]=fits \n return data_fit\n\n def get_fit_r2(self,df:pd.DataFrame)->int:\n rsquared=df['r2a'].sum()/df['r2b'].sum()\n return round(rsquared,2)\n \n def get_total_fits(self)->int:\n '''\n get number of fits\n '''\n data_dic=self.get_data_from_SASBDB()\n num_of_fits=0\n for key,val in data_dic.items():\n num_of_fits += len(val['fits'])\n return num_of_fits\n\n def get_fit_image(self):\n '''\n get fit image from fit, deprecated\n '''\n data_dic=self.get_data_from_SASBDB()\n num_of_fits=self.get_number_of_fits()\n data_fit={}\n for key,val in data_dic.items():\n num=num_of_fits[key]\n if num>0:\n for fitnum in range(0,num): \n target_url=val['fits'][fitnum]['models'][0]['model_plot']\n fitdata = requests.get(target_url);\n if fitdata.status_code !=200:\n print (\"Error....unable to fetch data from SASBDB, please check the entry ID\")\n dirname=os.path.dirname(os.path.abspath(__file__))\n filename = os.path.abspath(os.path.join(os.getcwd(),self.imagepath,self.ID+key+str(fitnum)+'fit.png'))\n with open (filename,'wb') as f:\n f.write(fitdata.content)\n\n", "meta": {"hexsha": "479caf2c5d286ebaca5605766b6cf358e7740e82", "size": 31453, "ext": "py", "lang": "Python", "max_stars_repo_path": "master/pyext/src/validation/sas.py", "max_stars_repo_name": "salilab/IHMValidation", "max_stars_repo_head_hexsha": "ddf1a080a4b7f66c2f067312f5f4a5c6584848d1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "master/pyext/src/validation/sas.py", "max_issues_repo_name": "salilab/IHMValidation", "max_issues_repo_head_hexsha": "ddf1a080a4b7f66c2f067312f5f4a5c6584848d1", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 23, "max_issues_repo_issues_event_min_datetime": "2020-12-09T22:27:29.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-30T18:01:43.000Z", "max_forks_repo_path": "master/pyext/src/validation/sas.py", "max_forks_repo_name": "salilab/IHMValidation", "max_forks_repo_head_hexsha": "ddf1a080a4b7f66c2f067312f5f4a5c6584848d1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-21T22:55:24.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-21T22:55:24.000Z", "avg_line_length": 45.3867243867, "max_line_length": 173, "alphanum_fraction": 0.5382952342, "include": true, "reason": "import numpy", "num_tokens": 7862, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073655352404, "lm_q2_score": 0.35936413143782797, "lm_q1q2_score": 0.1978685376788423}} {"text": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\"\"\"\nPackage: mesxr.calibration\nModule: trimscan\nAuthor: Patrick VanMeter\nAffiliation: Department of Physics, University of Wisconsin-Madison\nLast Updated: November 2018\n\nDescription:\n This module is a significant overhaul to the overiginal ME-SXR calibration software. The\n goals of the re-write are to improve usability and transperency, and to more naturally\n facilitate features which were added on to the original code. \nAcknowledgements:\n - Novimir Pablant and Jacob Maddox, for the original calibration code.\n - Luis Felipe Delgado-Aparicio, for heading the PPPL/MST collaboration.\n - Daniel Den Hartog and Lisa Reusch, for advising me.\n\"\"\"\nimport copy\nimport os\nimport multiprocessing as mp\nimport numpy as np\nimport scipy as sp\nfrom scipy.optimize import curve_fit\nfrom scipy.special import erf\nimport mesxr.calibration.utilities as utilities\n\n\ndef calibrate_mp(pixel):\n \"\"\"\n This is a helper function in order to use multiprocessing to invoke the calibrate() method for an array\n of Pilatus_Pixel objects.\n \"\"\"\n pixel.calibrate()\n return copy.copy(pixel)\n\ndef calibrate_module_mp(chip):\n \"\"\"\n This helper function is used to calibrate an entire module using multiprocessing. This ensures that each individual chip does\n not itself attempt to spawn additional processes.\n \"\"\"\n chip.calibrate(num_cores=1)\n return copy.copy(chip)\n\nclass Pilatus_Pixel(object):\n \"\"\"\n Description:\n TBD\n Arguments:\n - calibration_data = (list of np.array) Contains the calibration data for this pixel. The list should have\n a number of entries equal to the length of self.energies, and each entry should be an array with a\n length equal to the length of the corresponding entry in self.trimbits.\n - calibration_energies = (np.array) The photon energy for each calibration source element.\n - elements = (list) Each entry should be a string which identifies the element corresponding to the\n same index in calibration_energies.\n - trimbits = (list of np.array) Identifies the trimbit values which correspond to the arrays in calibration_data.\n This allows the user to remove certain trimbit settings from the calibration, if necessary.\n - coords = (tuple of ints) The global (x,y) coordinates of this pixel.\n - size = (tuple of float) The physical dimensions (x,y) of the pixel, in micrometers.\n \"\"\"\n def __init__(self, calibration_data, calibration_energies, elements, trimbits, coords, chip_number, module_number, size=(172.0, 172.0)):\n # Physical parameters\n self.data = calibration_data\n self.energies = calibration_energies\n self.elements = elements\n self.trimbits = trimbits\n self.coords = coords\n self.chip = chip_number\n self.module = module_number\n self.size = size\n self.edge_pixel = False\n\n # Calibration parameters to be fit to the data\n self.num_elements = len(self.elements)\n self.trimfit_params = np.zeros([self.num_elements, 6])\n self.trimfit_cov = np.zeros([self.num_elements, 6, 6])\n\n self.enfit_params = np.zeros(3)\n self.enfit_cov = np.zeros([3, 3])\n\n self.trimfit_chi2 = np.zeros(self.num_elements)\n self.enfit_chi2 = 0.0\n\n # Keep track of failed fits\n self.good_trimfits = np.array([False for x in range(self.num_elements)])\n self.good_enfit = False\n\n def __str__(self):\n return str(self.coords)\n\n def s_curve(self, trim, A0, A1, A2, A3, A4, A5):\n \"\"\"\n This function parameterizes the detector response to a given trimbit setting. This returns the predicted\n photon counts given the calibration parameters and supplied trimbit value. This function permits non-integer\n trimbit values, which in reality must be rounded to the nearest integer.\n \"\"\"\n return 0.5*(erf( -1*(trim - A0)/(np.sqrt(2)*A1) ) + 1.)*(A2 + A3*(trim - A0)) + A4 + A5*(trim - A0)\n\n def s_curve_model(self, element, trim):\n \"\"\"\n Use the fit results to return values from the analytic model for the S-curve fit.\n \"\"\"\n elem_index = self.elements.index(element)\n return self.s_curve(trim, *self.trimfit_params[elem_index, :])\n\n def en_curve(self, energy, C0, C1, C2):\n \"\"\"\n This function parameterizes the mapping between the trimbit of the S-curve inflection point and the calibration\n line energies.\n \"\"\"\n return C0*energy**2 + C1*energy + C2\n\n def en_curve_model(self, energy):\n \"\"\"\n Use the fit results to return values from the analytic model for the energy fit.\n \"\"\"\n return self.en_curve(energy, *self.enfit_params)\n\n def en_curve_uncertainty(self, energy):\n \"\"\"\n Returns the uncertainty in the trimbit required to set the threshold to a given energy, based on the\n energy fit results.\n \"\"\"\n var_2 = (energy**4)*self.enfit_cov[0,0] + (energy**2)*self.enfit_cov[1,1] + self.enfit_cov[2,2]\n cov_2 = 2*energy*( (energy**2)*self.enfit_cov[0,1] + energy*self.enfit_cov[0,2] + self.enfit_cov[1,2] )\n return np.sqrt(var_2 + cov_2)\n\n def trimbit_from_threshold(self, energy):\n \"\"\"\n This is just a wrapper for the en_curve_model function which provides a more consistent notation for some\n use cases.\n \"\"\"\n return self.en_curve_model(energy)\n\n def trimbit_uncertainty(self, energy):\n \"\"\"\n This is just a wrapper for the en_curve_model function which provides a more consistent notation for some\n use cases.\n \"\"\"\n return self.en_curve_uncertainty(energy)\n \n def threshold_from_trimbit(self, trimbit):\n \"\"\"\n Invert the threshold fit. That is, get the lower threshold energy corresponding to a specific trimbit value. This\n is useful when considering the impact of trimbit rounding.\n \"\"\"\n c0, c1, c2 = self.enfit_params\n return (-c1 + np.sqrt(c1**2 - 4*c0*(c2 - trimbit))) / (2*c0)\n\n def threshold_uncertainty(self, trimbit):\n \"\"\"\n \"\"\"\n return 0\n\n def exclude_trimbits(self, remove_bits):\n \"\"\"\n Remove the given trimbits and corresponding data so that they will not be used in the calibration.\n \"\"\"\n for elem_index in range(self.num_elements):\n if set(remove_bits).issubset(set(self.trimbits[elem_index])):\n exclude_indices = [np.where(tbit == self.trimbits[elem_index])[0][0] for tbit in remove_bits]\n slice_indices = [i for i in range(len(self.trimbits[elem_index])) if i not in exclude_indices]\n self.trimbits[elem_index] = self.trimbits[elem_index][slice_indices]\n self.data[elem_index] = self.data[elem_index][slice_indices]\n\n def exclude_elements(self, remove_elem):\n \"\"\"\n Remove the given elements and corresponding data so that they will not be used in the calibration.\n \"\"\"\n # Determine the indices of the entries to keep\n try:\n remove_indices = [self.elements.index(elem) for elem in remove_elem]\n except:\n print('ERROR: Supplied element(s) not in the elements array.')\n remove_indices = []\n\n slice_indices = [i for i in range(len(self.elements)) if i not in remove_indices]\n\n # Remove the unwanted elements\n self.elements = [self.elements[i] for i in slice_indices]\n self.data = [self.data[i] for i in slice_indices]\n self.trimbits = [self.trimbits[i] for i in slice_indices]\n self.energies = self.energies[slice_indices]\n self.num_elements = len(self.elements)\n\n # Remake the calibration result arrays which depend on the number of elements\n self.trimfit_params = np.zeros([self.num_elements, 6])\n self.trimfit_cov = np.zeros([self.num_elements, 6, 6])\n self.trimfit_chi2 = np.zeros(self.num_elements)\n self.good_trimfits = np.array([False for x in range(self.num_elements)])\n \n # Calibration functions\n def trimbit_fit(self):\n \"\"\"\n Use the calibration data to determine the best-fit parameters and covariance matrix for this pixel.\n \"\"\"\n for elem_index in range(self.num_elements):\n # Use a gradient method to guess the trimbit of the inflection point\n data_slope = np.gradient(self.data[elem_index], 1)\n index = np.argmin(data_slope) + self.trimbits[elem_index][0]\n\n # Initial guesses\n p0 = [float(index), # A0 - Inflection trimbit\n 1.0, # A1 - S-curve width\n np.amax(self.data[elem_index]), # A2 - Response amplitude\n 0.0, # A3 - CX slope\n np.amin(self.data[elem_index]), # A4 - BG amplitude\n 0.0] # A5 - BG CX slope\n\n # Do the fit\n bounds = (np.array([-np.inf, -np.inf, -np.inf, -np.inf, -np.inf, -np.inf]), # Lower bounds\n np.array([np.inf, np.inf, np.inf, 0.0, np.inf, 0.0])) # Upper bounds\n\n sigma = np.sqrt(self.data[elem_index])\n\n try:\n self.trimfit_params[elem_index, :], self.trimfit_cov[elem_index, :, :] = curve_fit(self.s_curve, self.trimbits[elem_index], self.data[elem_index],\n p0=p0, bounds=bounds, sigma=sigma, absolute_sigma=True)\n\n # Determine the reduced Chi^2 of the fit\n model_data = self.s_curve(self.trimbits[elem_index], *self.trimfit_params[elem_index, :])\n self.trimfit_dof = len(self.data[elem_index]) - 6.0\n self.trimfit_chi2[elem_index] = np.sum( (self.data[elem_index] - model_data)**2/(sigma**2) )\n\n self.good_trimfits[elem_index] = True\n except:\n # The fit did not work - consider including fallback options here\n self.good_trimfits[elem_index] = False\n self.trimfit_params[elem_index, :] = np.nan\n self.trimfit_cov[elem_index, :, :] = np.nan\n self.trimfit_chi2[elem_index] = np.nan\n self.trimfit_dof = np.nan\n\n def energy_fit(self):\n \"\"\"\n Use the results of the trimbit_fit to fit the en_curve.\n \"\"\"\n # Only use the successful fits\n if np.sum(self.good_trimfits) >= 4:\n trim_data = self.trimfit_params[self.good_trimfits, 0]\n trim_sigma = np.sqrt(self.trimfit_cov[self.good_trimfits, 0, 0])\n trim_energies = self.energies[self.good_trimfits]\n\n #self.enfit_params, self.enfit_cov = np.polyfit(self.energies, trim_data, 2, w=1/trim_sigma, cov=True)\n p0 = [np.mean(trim_data), 0.0, 0.0]\n\n try:\n self.enfit_params[:], self.enfit_cov[:,:] = curve_fit(self.en_curve, trim_energies, trim_data, p0=p0,\n sigma=trim_sigma, absolute_sigma=True)\n\n # Determine the Chi^2 of the fit\n trim_model = self.en_curve(trim_energies, *self.enfit_params)\n self.enfit_dof = len(trim_data) - 3.0\n self.enfit_chi2 = np.sum( (trim_data - trim_model)**2/(trim_sigma**2) )\n self.good_enfit = True\n except:\n # The fit did not work - consider including fallback options here\n self.good_enfit = False\n self.enfit_params[:] = np.nan\n self.enfit_cov[:] = np.nan\n self.enfit_chi2 = np.nan\n self.enfit_dof = np.nan\n else:\n # There is too little good data for a reliable fit\n self.good_enfit = False\n self.enfit_params[:] = np.nan\n self.enfit_cov[:,:] = np.nan\n self.enfit_chi2 = np.nan\n self.enfit_dof = np.nan\n\n def calibrate(self):\n \"\"\"\n Performs both the trimbit fit and the energy fit in a single command.\n \"\"\"\n self.trimbit_fit()\n self.energy_fit()\n\n\nclass Pilatus_Null_Pixel(Pilatus_Pixel):\n \"\"\"\n This class exists to allow the creation of placeholder Pixel objects which do nothing and hold no data, but share the\n same methods. This is useful as a placeholder and for representing the empty row between pixels.\n \"\"\"\n def __init__(self):\n self.coords = (-1,-1)\n self.chip = -1\n self.module = -1\n self.edge_pixel = False\n\n # Calibration parameters to be fit to the data\n self.elements = ['none']\n self.num_elements = len(self.elements)\n self.trimfit_params = np.array([[np.nan, np.nan, np.nan, np.nan, np.nan, np.nan]])\n self.trimfit_cov = np.zeros([1,6,6])\n self.trimfit_cov[:,:,:] = np.nan\n\n self.enfit_params = np.array([np.nan, np.nan, np.nan])\n self.enfit_cov = np.nan\n\n self.trimfit_chi2 = np.array([np.nan])\n self.enfit_chi2 = np.nan\n \n self.good_trimfits = np.array([False])\n self.good_enfit = False\n\n def s_curve_model(self, element, trim):\n return -1.0\n\n def en_curve_model(self, energy):\n return -1.0\n \n def trimbit_fit(self):\n pass\n\n def energy_fit(self):\n pass\n\n\nclass Pilatus_Chip(object):\n \"\"\"\n Description:\n The chip is the basic organizational unit for pixels in the PILATUS series of X-ray detectors. Chips essentially\n consist of an array of pixels and some additional properties.\n Inputs:\n - pixel_dims = (tuple of int) The size n x m of the array of pixels on the chip.\n - chip_number = (int) ID number for the chip.\n - calibration_data = (list of np.array) Each array in the list corresponds to the calibration data for the\n corresponding entry in elements. The arrays are 3D with indices corresponding to [x, y, trimbit].\n - calibration_energies = (np.array) The photon energy for each calibration source element.\n - elements = (list) Each entry should be a string which identifies the element corresponding to the\n same index in calibration_energies.\n - trimbits = (list of np.array) The trimbits to include for the calibration of this chip. This is expected to vary\n on a chip-by-chip basis. This should be the same length as the third axis of each element in the\n calibration_data list.\n - pixel_coords = (np.array) This array assigns the global coordinates for each pixel on the chip. The array\n is indexed by [x, y, coord] where coord=0 gives the global X coordinate and coord=1 gives the global Y.\n The indices x,y refer to the local (chip-level) coordinates.\n - vcmp = (float) The Vcmp value for this chip. This is the global value with the offset applied.\n \"\"\"\n def __init__(self, pixel_dims, chip_number, module_number, calibration_data, calibration_energies, elements, trimbits, pixel_coords, vcmp):\n self.pixel_dims = pixel_dims\n self.number = chip_number\n self.module = module_number\n self.trimbits = trimbits\n\n # Create the array of pixels\n self.pixels = np.empty(self.pixel_dims, dtype=object)\n\n for y in range(self.pixel_dims[1]):\n for x in range(self.pixel_dims[0]):\n self.pixels[x, y] = Pilatus_Pixel([data[x, y, :] for data in calibration_data], calibration_energies,\n elements, copy.copy(self.trimbits), tuple(pixel_coords[x,y,:]), self.number, self.module)\n \n if x == 0 or y == 0 or x == self.pixel_dims[0]-1 or y == self.pixel_dims[1]-1:\n self.pixels[x, y].edge_pixel = True\n\n # Store chip-level detector properties\n self.vcmp = vcmp\n\n def __str__(self):\n return str(self.number)\n\n def exclude_trimbits(self, remove_bits):\n \"\"\"\n Remove the specified trimbits and associated data for all pixels on the chip.\n \"\"\"\n for pixel in self.pixels.ravel():\n pixel.exclude_trimbits(remove_bits)\n\n def remove_elements(self, remove_elem):\n \"\"\"\n Remove the specified elements and associated data for all pixels on the chip.\n \"\"\"\n for pixel in self.pixels.ravel():\n pixel.exclude_elements(remove_elem)\n \n def calibrate(self, num_cores=16):\n \"\"\"\n Calibrate all pixels on a chip. Returns the reduced chi^2 metric for the energy fits. This is mostly of interest when\n investigating individual modules. Otherwise, see the detector-level calibrate() function.\n \"\"\"\n if num_cores == 1:\n [pixel.calibrate() for pixel in self.pixels.ravel()]\n else:\n pool = mp.Pool(num_cores)\n pixels = pool.map(calibrate_mp, self.pixels.ravel())\n self.pixels = np.array(pixels).reshape(self.pixel_dims)\n\n\nclass Pilatus_Module(object):\n \"\"\"\n Description:\n TBD\n Inputs:\n - chip_dims = (tuple of int) The global (X, Y) layout of chips on the module.\n - pixel_dims = (tuple of int) The local layout (x,y) of pixels on a chip.\n - module_number = (int) Identifier for the module. This is important for multi-module detectors.\n - calibration_data = (list of np.array) Each array in the list corresponds to the calibration data for the\n corresponding entry in elements. The arrays are 3D with indices corresponding to [X, Y, trimbit], where\n (X,Y) are the pixel coordinates in the module frame. It is assumed that no trimbit data has been dropped\n - calibration_energies = (np.array) The photon energy for each calibration source element.\n - elements = (list) Each entry should be a string which identifies the element corresponding to the\n same index in calibration_energies.\n - trimbit_start = (np.array) The trimbit to start the scan for each element for each module. This array is indexed\n by [elem, chip_num]. Any value above zero will cause some data to be omitted from the calibration procedure.\n - chip_coords = (np.array) Entries in this array define the starting pixel (upper-left) for each chip. This is indexed\n by [chip_num, dim] where dim=0 is x and dim=1 is y. For example, on the Pilatus3 chip 0 start with pixel (0,0)\n and chip 1 starts with (61, 0) so chip_coords[0,:] = [0,0] and chip_coords[1,:] = [61,0].\n - num_trimbits = [keyword](int) Specify the number of trimbits available to each pixel.\n \"\"\"\n def __init__(self, chip_dims, pixel_dims, module_number, calibration_data, calibration_energies, elements,\n trimbit_start, chip_coords, num_trimbits=64):\n self.number = module_number\n self.chip_dims = chip_dims\n self.pixel_dims = pixel_dims\n self.num_trimbits = num_trimbits\n\n # Initialize the chips on the module\n self.chips = np.empty(self.chip_dims, dtype=object)\n chip_num = 0\n\n for y in range(self.chip_dims[1]):\n for x in range(self.chip_dims[0]):\n vcmp = 0\n\n # Determine the pixel coordinates based on the supplied dimensions and the start coordinates\n pixel_coords = np.zeros([self.pixel_dims[0], self.pixel_dims[1], 2], dtype=int)\n for pix_x in range(self.pixel_dims[0]):\n for pix_y in range(self.pixel_dims[1]):\n pixel_coords[pix_x, pix_y, :] = chip_coords[chip_num, :] + [pix_x, pix_y]\n \n # Trim the calibration data to the appropriate size\n trimbits = [np.arange(trimbit_start[elem, chip_num], self.num_trimbits) for elem in range(len(elements))]\n\n start_x = chip_coords[chip_num, 0]\n end_x = chip_coords[chip_num, 0]+self.pixel_dims[0]\n start_y = chip_coords[chip_num, 1]\n end_y = chip_coords[chip_num, 1]+self.pixel_dims[1]\n pixel_data = [calibration_data[elem][start_x:end_x, start_y:end_y, trimbits[elem][0]:] for elem in range(len(elements))]\n\n self.chips[x, y] = Pilatus_Chip(self.pixel_dims, chip_num, self.number, pixel_data, calibration_energies, elements,\n trimbits, pixel_coords, vcmp)\n chip_num += 1\n\n def __str__(self):\n return str(self.number)\n\n def get_pixels(self):\n \"\"\"\n Return an array with all pixels organized by module coordinates.\n \"\"\"\n x_dim = 487\n y_dim = 195\n pixels_mod = np.array([[Pilatus_Null_Pixel() for y in range(y_dim)] for x in range(x_dim)])\n\n for chip in self.chips.ravel():\n for pixel in chip.pixels.ravel():\n pixels_mod[pixel.coords] = pixel\n\n return pixels_mod\n\n def calibrate(self, num_cores=16):\n \"\"\"\n Use multiprocessing to calibrate all pixels. If possible it is advisable to set num_cores equal to the\n number of chips on the module.\n \"\"\"\n if num_cores == 1:\n chips = [chip.calibrate() for chip in self.chips.ravel()]\n else:\n pool = mp.Pool(num_cores)\n chips = pool.map(calibrate_module_mp, self.chips.ravel())\n\n self.chips = np.array(chips).reshape(self.chip_dims)\n\n\nclass Pilatus_Detector(object):\n \"\"\"\n Description:\n A detector is an object which holds an array of Modules and the associated global settings. Objects\n of this class also provide methods for initiating the calibration process.\n Usage:\n This class is intended to be inhereted by classes representing the implementation of specific Pilatus\n detectors. As such, direct instances of this class will be of limited use. For an example implementation,\n see the Pilatus3_100k class below.\n Parameters:\n - TBD\n \"\"\"\n def __init__(self, *args, **kwargs):\n # Detector properties\n self.global_pixel_dims = (0, 0) # Dimensions of all pixels on the detector face, including fake pixels\n self.num_chips = 0 # The number of chips which compose the module\n self.module_dims = (0, 0) # The layout of modules on the detector\n self.chip_dims = (0, 0) # The layout of chips on the module\n self.pixel_dims = (0, 0) # The layout of pixels on a chip\n self.num_trimbits = 0 # The number of trimbits available to each pixel\n self.trimbit_start = [[0]] # Value to start trimbit data at, indexed by [elem, chip_num]\n self.calibrated = False # Flag to tell whether the detector has been calibrated already\n self.bad_pixels = [] # Keep track of which pixels are problematic\n\n # Initialize the modules and global settings\n self.load_trimscan_data([], [])\n self.load_global_settings(0)\n self.init_modules()\n\n # Make pixels easily accessible by global coordinates\n self.pixels = self.get_pixels()\n\n def init_modules(self):\n \"\"\"\n Run this to initialize the modules which compose the detector. This is separated out from the __init__ method\n since it does generally not need to be overwritten for inhereted classes.\n \"\"\"\n self.modules = np.empty(self.module_dims, dtype=object)\n module_number = 0\n\n for y in range(self.module_dims[1]):\n for x in range(self.module_dims[0]):\n self.modules[x,y] = Pilatus_Module(self.chip_dims, self.pixel_dims, module_number, self.trimscan_data, self.trimscan_energy,\n self.elements, self.trimbit_start, self.get_chip_coords(module_number),\n num_trimbits=self.num_trimbits)\n module_number += 1\n\n def load_global_settings(self, settings_path):\n \"\"\"\n Load the detector settings in from the data file. This may require slight modification for multi-module\n detectors since I do not know which settings are shared across modules. I have separated out the VCMP settings\n due to its unique chip-level variation.\n \"\"\"\n self.vcmp = np.zeros(self.num_chips)\n self.settings = {}\n\n # Load the settings data from the file\n if settings_path != 0:\n try:\n fname = os.path.join(settings_path, 'setdacs_b01_m01.dat')\n settings_file = open(fname, 'r')\n\n for line in settings_file.readlines():\n line_elems = line.split()\n if line_elems[0] == 'set':\n key = line_elems[1].split('_')[2]\n self.settings[key] = float(line_elems[2])\n\n settings_file.close()\n\n # Pull out the VCMP settings\n for key in self.settings.keys():\n if 'VCMP' in key:\n index = int(key.split('VCMP')[1])\n self.vcmp[index] = self.settings[key]\n \n except:\n print('ERROR: Failed to load supplied settings file. Check path name.')\n else:\n pass\n\n def load_trimscan_data(self, elements, trimscan_paths):\n \"\"\"\n \"\"\"\n self.elements = elements\n\n self.trimscan_data = [np.zeros([self.global_pixel_dims[0], self.global_pixel_dims[1], self.num_trimbits]) for i in self.elements]\n self.trimscan_energy = utilities.get_line_energy(self.elements)\n self.trimbits = [np.arange(self.num_trimbits) for elem in self.elements]\n \n for elem, fname in enumerate(trimscan_paths):\n self.trimscan_data[elem] = utilities.load_calibration_data(fname)\n\n def generate_settings_file(self, output_path):\n \"\"\"\n Used to generate the settings file for use in ME-SXR operation. This removes the requirement of keeping\n up with the original file used in the calibration procedure.\n \"\"\"\n pass\n\n def pixel_mapping(self, x, y):\n \"\"\"\n Returns the mapping between between global (x,y) coordinates and local (mod_num, chip_num, (pix_x, pix_y))\n coordinates. This is important for mapping the trimbit scan data to the Detector data structure.\n \"\"\"\n return (0, 0, (x, y))\n\n def get_chip_coords(self, mod_number):\n \"\"\"\n Override to set the global coordinates for the first (upper-left) pixel on each chip.\n \"\"\"\n return np.array([[0,0]])\n\n def get_pixels(self):\n \"\"\"\n Return an array of all pixel objects following the global coordinates.\n \"\"\"\n pass\n\n def calibrate(self, num_cores=16):\n \"\"\"\n Use multiprocessing to calibrate all pixels. \n \"\"\"\n pass\n\n def determine_bad_pixels(self, include=[]):\n \"\"\"\n Update the list of bad pixels. This should generally be called immediately after calibration. Use\n the 'include' keyword to manually add points, even if the fit did not fail. This keyword accepts a\n list of tuples.\n \"\"\"\n # Ensure that the specified fits are marked as bad\n for coords in include:\n if coords not in self.bad_pixels:\n self.pixels[coords].good_enfit = False\n\n # Now add all remaining pixels for which a fit was not found\n for pixel in self.pixels.ravel():\n if not pixel.good_enfit and type(pixel) != Pilatus_Null_Pixel:\n if pixel.coords not in self.bad_pixels:\n self.bad_pixels.append(pixel.coords)\n \n def get_trimbit_map(self, threshold_map):\n \"\"\"\n Returns the trimbit values for the supplied threshold map (in keV).\n \"\"\"\n if self.calibrated:\n trimbit_map = np.zeros(self.global_pixel_dims, dtype=int)\n\n for x in range(self.global_pixel_dims[0]):\n for y in range(self.global_pixel_dims[1]):\n # Ensure that the trimbit is within the valid range\n tbit = self.pixels[x,y].trimbit_from_threshold(threshold_map[x,y])\n if tbit < 0 or np.isnan(tbit):\n tbit = 0\n elif tbit > self.num_trimbits - 1:\n tbit = self.num_trimbits - 1\n else:\n tbit = int(round(tbit))\n \n trimbit_map[x,y] = tbit\n else:\n print('Detector is not yet calibrated.')\n trimbit_map = -1*np.ones(self.global_pixel_dims, dtype=int)\n return trimbit_map\n\n# ---------------------------------------- Specific Detector Implementations ----------------------------------------\n\nclass Pilatus3_100k(Pilatus_Detector):\n \"\"\"\n Description:\n This is a specific implementation of the Pilatus_Detector which integrates the appropraite pixel geometry\n and device settings. The PILATUS3 100K detector, produced by DECTRIS Ltd., is composed of a single module\n with approximately 100,000 total pixels.\n \"\"\"\n def __init__(self, elements, trimscan_paths, settings_path, trimbit_start=0, omit_trimbits=False, calib_name='MST'):\n # Pilatus3 pixel properties\n self.global_pixel_dims = (487, 195)\n self.num_chips = 16\n self.module_dims = ( 1, 1)\n self.chip_dims = ( 8, 2)\n self.pixel_dims = ( 60, 97)\n self.num_trimbits = 64\n self.calibrated = False\n self.bad_pixels = []\n self.name = calib_name\n\n if not omit_trimbits:\n self.trimbit_start = np.zeros([len(elements), self.num_chips], dtype=int)\n else:\n self.trimbit_start = trimbit_start\n\n # Pilatus3 physical characteristics\n\n # Load modules and settings\n self.load_trimscan_data(elements, trimscan_paths)\n self.load_global_settings(settings_path)\n self.init_modules()\n\n # Make pixels easily accessible by global coordinates\n self.pixels = self.get_pixels()\n\n def pixel_mapping(self, x, y):\n \"\"\"\n Implement the proper mapping for the PILATUS3 100K detector. This is most easily done using the pre-existing\n mapping function from Novi.\n \"\"\"\n chip_num, chip_x, chip_y = utilities.get_chip_coords(x, y)\n return (0, chip_num, (chip_x, chip_y))\n\n def get_chip_coords(self, mod_number):\n \"\"\"\n Returns the global coordinates for the first (upper-left) pixel on each chip for the PILATUS3 100K.\n \"\"\"\n dx = 61\n dy = 98\n chip_coords = np.array([[0*dx, 0], [1*dx, 0], [2*dx, 0], [3*dx, 0], [4*dx, 0], [5*dx, 0], [6*dx, 0], [7*dx, 0],\n [0*dx,dy], [1*dx,dy], [2*dx,dy], [3*dx,dy], [4*dx,dy], [5*dx,dy], [6*dx,dy], [7*dx,dy]])\n return chip_coords\n\n def write_settings_file(self, filepath):\n \"\"\"\n Writes the settings used to generate the trimscan back out to a file.\n \"\"\"\n # Format the settings into a string with linebreaks\n settings = '# /dev/shm/setdacs_b01_m01.dat\\n'\n settings += 'set B01_M01_VTRM {0: 2.4f}\\n'.format(self.settings['VTRM'])\n\n for vcmp in range(self.num_chips):\n vcmp_str = 'VCMP{0:}'.format(vcmp)\n settings += 'set B01_M01_{0:} {1: 2.4f}\\n'.format(vcmp_str, self.settings[vcmp_str])\n\n for key in ['VCCA', 'VRF', 'VRFS', 'VCAL', 'VDEL', 'VADJ']:\n settings += 'set B01_M01_{0:} {1: 2.4f}\\n'.format(key, self.settings[key])\n\n # Remove the final unwanted newline\n settings = settings[:-1]\n\n with open(os.path.join(filepath, 'setdacs_b01_m01.dat'), 'wb') as f:\n f.write(settings)\n\n print('Settings file written to {0:}.'.format(filepath))\n\n def write_autotrim_files(self, threshold_map, filepath, filename='autotrim'):\n \"\"\"\n Generate autotrim files given a specified threshold map using the calibration.\n \"\"\"\n trimbit_map = self.get_trimbit_map(threshold_map)\n trimbit_sorted = np.zeros([self.num_chips, self.pixel_dims[0], self.pixel_dims[1]])\n\n for g_x in range(self.global_pixel_dims[0]):\n for g_y in range(self.global_pixel_dims[1]):\n cn, cx, cy = utilities.get_chip_coords(g_x, g_y)\n if cn != -1:\n trimbit_sorted[cn, cx, cy] = trimbit_map[g_x, g_y]\n \n for cn in range(self.num_chips):\n trim_string = '# AUTOTRIM files for PILATUS3 100K by UW Madison code\\n'\n trim_string += 'set B01_M01_CHSEL{0:} 1\\n'.format(cn)\n\n for cx in range(self.pixel_dims[0]):\n for cy in range(self.pixel_dims[1]):\n trim_string += 'trim {0:} {1:} {2:}\\n'.format(cx, cy, hex(int(trimbit_sorted[cn, cx, cy])))\n\n trim_string += 'settrims'\n\n # Write the output file\n fname = '{0:}_b01_m01_c{1:02d}.dat'.format(filename, cn)\n with open(os.path.join(filepath, fname), 'wb') as f:\n f.write(trim_string)\n\n print('Saved {0:} to file.'.format(fname))\n\n def write_bad_pixels_file(self, filepath):\n \"\"\"\n Outputs a CSV file containing all of the bad pixels. This is useful in later analysis.\n \"\"\"\n fname = 'bad_pixels.csv'\n np.savetxt(os.path.join(filepath, fname), self.bad_pixels, delimiter=',', fmt='%d')\n\n def get_pixels(self):\n \"\"\"\n Since this detector has only one module, just call that module's get_pixels() method.\n \"\"\"\n return self.modules[0,0].get_pixels()\n\n def calibrate(self, num_cores=16, bad_pix=[]):\n \"\"\"\n Since this detector has only one module, just call that module's calibrate() method. Use the 'bad_pix'\n to manually ensure that the specified pixels get marked as bad, even if the fit does not fail.\n \"\"\"\n self.modules[0,0].calibrate(num_cores=num_cores)\n self.calibrated = True\n self.pixels = self.get_pixels()\n self.determine_bad_pixels(include=bad_pix)", "meta": {"hexsha": "dbb45cdd56d39a91bd3a3b25791a67b077f5b063", "size": 34614, "ext": "py", "lang": "Python", "max_stars_repo_path": "mesxr/calibration/trimscan.py", "max_stars_repo_name": "pdvanmeter/meSXR", "max_stars_repo_head_hexsha": "c281e15c5fd01591bba9e0c1510f83c5f7ef771a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "mesxr/calibration/trimscan.py", "max_issues_repo_name": "pdvanmeter/meSXR", "max_issues_repo_head_hexsha": "c281e15c5fd01591bba9e0c1510f83c5f7ef771a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "mesxr/calibration/trimscan.py", "max_forks_repo_name": "pdvanmeter/meSXR", "max_forks_repo_head_hexsha": "c281e15c5fd01591bba9e0c1510f83c5f7ef771a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.9532467532, "max_line_length": 162, "alphanum_fraction": 0.6105910903, "include": true, "reason": "import numpy,import scipy,from scipy", "num_tokens": 7914, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6723317123102956, "lm_q2_score": 0.29421497216298875, "lm_q1q2_score": 0.1978100560216682}} {"text": "#!/usr/bin/env python\n\n\"\"\"@package docstring\nFile: me_solver.py\nAuthor: Adam Lamson\nEmail: adam.lamson@colorado.edu\nDescription:\n\"\"\"\n\nimport time\nimport numpy as np\nfrom scipy.integrate import solve_ivp\nfrom .choose_me_evolver import choose_me_evolver\nfrom .solver import Solver\nfrom .non_dimensionalizer import NonDimensionalizer\nfrom .rod_steric_forces import get_min_dist_vec\n\n\nclass MomentExpansionSolver(Solver):\n\n \"\"\"!Solve the evolution of two rods by expanding the Fokker - Planck equation\n in a series of moments of motor end positions on rods.\n \"\"\"\n\n def __init__(self, pfile=None, pdict=None):\n \"\"\"!Set parameters for ODE to be solved including initial conditions.\n\n @param pfile: yaml parameter file name\n @param pdict: parameter dictionary\n \"\"\"\n print(\"Init MomentExpansionSolver ->\", end=\" \")\n Solver.__init__(self, pfile, pdict)\n\n def ParseParams(self):\n \"\"\"!Collect parameters from yaml file or dictionary then calculate\n some necessary parameters if not defined. Also non-dimensionalize parameters.\n @return: void\n \"\"\"\n Solver.ParseParams(self)\n\n self.dt = self._params[\"dt\"] # Time step\n if \"nt\" not in self._params:\n print(\"!!! Warning: nt not defined. Using nsteps and dt to find \",\n \"total time. nsteps and dt are not used in this calculation.\")\n self.nsteps = int(self._params[\"nsteps\"])\n self.nt = self.nsteps * self.dt\n self._params[\"nt\"] = self.nt\n else:\n self.nt = self._params[\"nt\"]\n\n if \"nwrite\" not in self._params:\n self.twrite = self._params[\"twrite\"]\n self.nwrite = int(self.twrite / self.dt)\n elif \"twrite\" not in self._params:\n self.nwrite = self._params[\"nwrite\"]\n self.twrite = float(self.nwrite * self.dt)\n else:\n print(\"!!! Warning: Write parameters over defined,\",\n \"using twrite to calculate number of steps between write out.\")\n self.twrite = self._params[\"twrite\"]\n self.nwrite = int(self.twrite / self.dt)\n\n self.non_dimmer = self.non_dimensionalize()\n # Rod orientation vectors\n self.R1_vec = np.asarray(self._params['R1_vec'])\n self.R2_vec = np.asarray(self._params['R2_vec'])\n # Make sure to renormalize\n self.R1_vec /= np.linalg.norm(self.R1_vec)\n self.R2_vec /= np.linalg.norm(self.R2_vec)\n\n # Check to see if steric forces should be used\n self.steric_flag = self._params.get('steric_interactions', None)\n if self.steric_flag == 'constrained':\n self.constr_vec = get_min_dist_vec(self.R2_pos - self.R1_pos,\n self.R1_vec, self.R2_vec)\n self.constr_vec /= np.linalg.norm(self.constr_vec)\n\n print(\"R1_vec = \", self.R1_vec)\n print(\"R2_vec = \", self.R2_vec)\n\n self.t_eval = np.linspace(0, self.nt, int(self.nt / self.twrite) + 1)\n self._nframes = self.t_eval.size\n\n # Set integration method for solver\n self.method = self._params.get('method', 'LSODA')\n self._params['method'] = self.method\n print(\"Solving method = \", self.method)\n\n # Specify the ODE type\n self.ODE_type = self._params.get('ODE_type', 'zrl')\n self._params['ODE_type'] = self.ODE_type\n print(\"ODE type = \", self.ODE_type)\n\n def setInitialConditions(self):\n \"\"\"!Set the initial conditions for the system of ODEs\n @return: void\n \"\"\"\n self.sol_init = np.zeros(26)\n # Set all geometric variables\n self.sol_init[:12] = np.concatenate(\n (self.R1_pos, self.R2_pos, self.R1_vec, self.R2_vec))\n print(\"=== Initial conditions ===\")\n print(self.sol_init)\n # TODO Allow for different initial conditions of moments besides zero\n\n # Set solver once you set initial conditions\n # Add kwargs\n self.ode_solver = choose_me_evolver(self.sol_init, self)\n\n def makeDataframe(self):\n \"\"\"!Create data frame to be written out\n @return: TODO\n \"\"\"\n t_arr = self.non_dimmer.dim_val(self.t_eval, ['time'])\n print(\"Evaluated at:\", t_arr)\n if not self.data_frame_made:\n self._time_dset = self._h5_data.create_dataset('time',\n data=t_arr,\n dtype=np.float32)\n self._xl_grp = self._h5_data.create_group('xl_data')\n self._rod_grp = self._h5_data.create_group('rod_data')\n\n Solver.makeDataframe(self)\n self.data_frame_made = True\n\n def Run(self):\n \"\"\"!Run algorithm to solve system of ODEs\n @return: TODO\n \"\"\"\n\n t0 = time.time()\n self.sol = solve_ivp(self.ode_solver, [0, self.nt], self.sol_init,\n t_eval=self.t_eval, method=self.method,)\n # min_step=self.dt, atol=1e-6)\n self.cpu_time = time.time() - t0\n print(\n r\" --- Total simulation time {:.4f} seconds ---\".format(self.cpu_time))\n\n self.Write()\n\n def make_rod_dataset(self):\n \"\"\"!Initialize dataframe with empty rod configuration data\n @return: void\n\n \"\"\"\n self._R1_pos_dset = self._rod_grp.create_dataset(\n 'R1_pos', data=self.sol.y[: 3, :].T)\n self._R2_pos_dset = self._rod_grp.create_dataset(\n 'R2_pos', data=self.sol.y[3: 6, :].T)\n self._R1_vec_dset = self._rod_grp.create_dataset(\n 'R1_vec', data=self.sol.y[6: 9, :].T)\n self._R2_vec_dset = self._rod_grp.create_dataset(\n 'R2_vec', data=self.sol.y[9: 12, :].T)\n\n def make_xl_moment_dataset(self):\n \"\"\"!Initialize dataframe with empty crosslinker moment data\n @return: void\n\n \"\"\"\n self._mu0_dset = self._xl_grp.create_dataset('zeroth_moment',\n data=self.sol.y[12, :].T,\n dtype=np.float32)\n self._mu1_dset = self._xl_grp.create_dataset('first_moments',\n data=self.sol.y[13: 15, :].T,\n dtype=np.float32)\n self._mu2_dset = self._xl_grp.create_dataset('second_moments',\n data=self.sol.y[15:18, :].T,\n dtype=np.float32)\n self._B0_dset = self._xl_grp.create_dataset('zeroth_boundary_terms',\n data=self.sol.y[18:20, :].T,\n dtype=np.float32)\n self._B1_dset = self._xl_grp.create_dataset('first_boundary_terms',\n data=self.sol.y[20:22, :].T,\n dtype=np.float32)\n self._B2_dset = self._xl_grp.create_dataset('second_boundary_terms',\n data=self.sol.y[22:24, :].T,\n dtype=np.float32)\n self._B3_dset = self._xl_grp.create_dataset('third_boundary_terms',\n data=self.sol.y[24:26, :].T,\n dtype=np.float32)\n\n def Write(self):\n \"\"\"!Write out data\n @return: void\n\n \"\"\"\n self.redimensionalize()\n self.make_xl_moment_dataset()\n self.make_rod_dataset()\n # Store how long the simulation took\n self._h5_data.attrs['cpu_time'] = self.cpu_time\n\n def non_dimensionalize(self):\n \"\"\"!Non-dimensionalize parameters to reduce error in calculations.\n @return: non dimensionalizer\n\n \"\"\"\n # non_dim_dict = {'time': 1. / self._params['ko'],\n # # 'length': max(self._params['L1'], self._params['L2']),\n # 'length': self._params['fs'] / self._params['ks'],\n # 'energy': 1. / self._params['beta']}\n # NonDimensionalizer not working currently\n non_dim_dict = {'time': 1.,\n 'length': float(max(self._params['L1'],\n self._params['L2'])),\n # 'length': 1.,\n 'energy': 1.}\n non_dimmer = NonDimensionalizer(**non_dim_dict)\n # non_dimmer.calc_new_dim('force', ['energy', 'length'], [1, -1])\n\n self.beta = non_dimmer.non_dim_val(self._params['beta'],\n ['energy'], [-1])\n self.visc = non_dimmer.non_dim_val(self._params['viscosity'],\n ['energy', 'time', 'length'],\n [1, 1, -3])\n self.L_i = non_dimmer.non_dim_val(self._params['L1'], ['length'])\n self.L_j = non_dimmer.non_dim_val(self._params['L2'], ['length'])\n self.R1_pos = non_dimmer.non_dim_val(\n self._params['R1_pos'], ['length'])\n self.R2_pos = non_dimmer.non_dim_val(\n self._params['R2_pos'], ['length'])\n self.rod_diam = non_dimmer.non_dim_val(self._params['rod_diameter'],\n ['length'])\n self.dt = non_dimmer.non_dim_val(self.dt, ['time'])\n self.nt = non_dimmer.non_dim_val(self.nt, ['time'])\n self.twrite = non_dimmer.non_dim_val(self.twrite, ['time'])\n self.ko = non_dimmer.non_dim_val(self._params['ko'], ['time'], [-1])\n self.co = non_dimmer.non_dim_val(self._params['co'], ['length'], [-2])\n self.ks = non_dimmer.non_dim_val(self._params['ks'],\n ['energy', 'length'], [1, -2])\n self.ho = non_dimmer.non_dim_val(self._params['ho'], ['length'])\n self.vo = non_dimmer.non_dim_val(self._params['vo'],\n ['length', 'time'], [1, -1])\n self.fs = non_dimmer.non_dim_val(\n self._params['fs'], ['energy', 'length'], [1, -1])\n return non_dimmer\n\n def redimensionalize(self):\n \"\"\"!Redimensionalize data arrays\n @return: void\n\n \"\"\"\n # Redimensionalize rod positions\n self.sol.y[:6, :] = self.non_dimmer.dim_val(self.sol.y[:6, :],\n ['length'])\n # Redimensionalize first moments\n self.sol.y[13:15, :] = self.non_dimmer.dim_val(self.sol.y[13: 15, :],\n ['length'])\n # Redimensionalize second moments\n self.sol.y[15:18, :] = self.non_dimmer.dim_val(self.sol.y[15:18, :],\n ['length'], [2])\n self.sol.y[20:22, :] = self.non_dimmer.dim_val(self.sol.y[20:22, :],\n ['length'])\n self.sol.y[22:24, :] = self.non_dimmer.dim_val(self.sol.y[22:24, :],\n ['length'], [2])\n self.sol.y[24:26, :] = self.non_dimmer.dim_val(self.sol.y[24:26, :],\n ['length'], [3])\n", "meta": {"hexsha": "d3e1056675968ca30c675087f516b5c6bed24348", "size": 11376, "ext": "py", "lang": "Python", "max_stars_repo_path": "foxlink/me_solver.py", "max_stars_repo_name": "lamsoa729/FoXlink", "max_stars_repo_head_hexsha": "3c061b02968cdab1def752d5c145a6df4615504b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "foxlink/me_solver.py", "max_issues_repo_name": "lamsoa729/FoXlink", "max_issues_repo_head_hexsha": "3c061b02968cdab1def752d5c145a6df4615504b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "foxlink/me_solver.py", "max_forks_repo_name": "lamsoa729/FoXlink", "max_forks_repo_head_hexsha": "3c061b02968cdab1def752d5c145a6df4615504b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-06-18T16:48:03.000Z", "max_forks_repo_forks_event_max_datetime": "2019-06-20T23:50:02.000Z", "avg_line_length": 44.0930232558, "max_line_length": 85, "alphanum_fraction": 0.5259317862, "include": true, "reason": "import numpy,from scipy", "num_tokens": 2605, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5851011542032312, "lm_q2_score": 0.3380771374883919, "lm_q1q2_score": 0.19780932335418258}} {"text": "import numpy as np\n\ntry:\n import classy\n HAVE_CLASS = True\nexcept ImportError:\n HAVE_CLASS = False\n\ntry:\n import camb\n import camb.model\n HAVE_CAMB = True\nexcept ImportError:\n HAVE_CAMB = False\n\ntry:\n import isitgr # noqa: F401\nexcept ImportError:\n pass # prevent nans from isitgr\n\nfrom . import ccllib as lib\nfrom .pyutils import check\nfrom .pk2d import Pk2D\nfrom .errors import CCLError\n\n\ndef get_camb_pk_lin(cosmo, nonlin=False):\n \"\"\"Run CAMB and return the linear power spectrum.\n\n Args:\n cosmo (:class:`~pyccl.core.Cosmology`): Cosmological\n parameters. The cosmological parameters with\n which to run CAMB.\n nonlin (:obj:`bool`, optional): Whether to compute and return the\n non-linear power spectrum as well.\n\n Returns:\n :class:`~pyccl.pk2d.Pk2D`: Power spectrum object. The linear power \\\n spectrum. If ``nonlin=True``, returns a tuple \\\n ``(pk_lin, pk_nonlin)``.\n \"\"\"\n\n # Comment from Jarvis: TODO clean up this and other assert\n # anti-patterns in this file\n assert HAVE_CAMB, (\n \"You must have the `camb` python package \"\n \"installed to run CCL with CAMB!\")\n\n # Get extra CAMB parameters that were specified\n extra_camb_params = {}\n try:\n extra_camb_params = cosmo[\"extra_parameters\"][\"camb\"]\n except (KeyError, TypeError):\n pass\n\n # z sampling from CCL parameters\n na = lib.get_pk_spline_na(cosmo.cosmo)\n status = 0\n a_arr, status = lib.get_pk_spline_a(cosmo.cosmo, na, status)\n check(status)\n a_arr = np.sort(a_arr)\n zs = 1.0 / a_arr - 1\n zs = np.clip(zs, 0, np.inf)\n\n # deal with normalization\n if np.isfinite(cosmo[\"A_s\"]):\n A_s_fid = cosmo[\"A_s\"]\n elif np.isfinite(cosmo[\"sigma8\"]):\n # in this case, CCL will internally normalize for us when we init\n # the linear power spectrum - so we just get close\n A_s_fid = 2.43e-9 * (cosmo[\"sigma8\"] / 0.87659)**2\n else:\n raise CCLError(\n \"Could not normalize the linear power spectrum! \"\n \"A_s = %f, sigma8 = %f\" % (\n cosmo['A_s'], cosmo['sigma8']))\n\n # init camb params\n cp = camb.model.CAMBparams()\n\n # turn some stuff off\n cp.WantCls = False\n cp.DoLensing = False\n cp.Want_CMB = False\n cp.Want_CMB_lensing = False\n cp.Want_cl_2D_array = False\n cp.WantTransfer = True\n\n # basic background stuff\n h2 = cosmo['h']**2\n cp.H0 = cosmo['h'] * 100\n cp.ombh2 = cosmo['Omega_b'] * h2\n cp.omch2 = cosmo['Omega_c'] * h2\n cp.omk = cosmo['Omega_k']\n\n # \"constants\"\n cp.TCMB = cosmo['T_CMB']\n\n # neutrinos\n # We maually setup the CAMB neutrinos to match the adjustments CLASS\n # makes to their temperatures.\n cp.share_delta_neff = False\n cp.omnuh2 = cosmo['Omega_nu_mass'] * h2\n cp.num_nu_massless = cosmo['N_nu_rel']\n cp.num_nu_massive = int(cosmo['N_nu_mass'])\n cp.nu_mass_eigenstates = int(cosmo['N_nu_mass'])\n\n delta_neff = cosmo['Neff'] - 3.046 # used for BBN YHe comps\n\n # CAMB defines a neutrino degeneracy factor as T_i = g^(1/4)*T_nu\n # where T_nu is the standard neutrino temperature from first order\n # computations\n # CLASS defines the temperature of each neutrino species to be\n # T_i_eff = TNCDM * T_cmb where TNCDM is a fudge factor to get the\n # total mass in terms of eV to match second-order computations of the\n # relationship between m_nu and Omega_nu.\n # We are trying to get both codes to use the same neutrino temperature.\n # thus we set T_i_eff = T_i = g^(1/4) * T_nu and solve for the right\n # value of g for CAMB. We get g = (TNCDM / (11/4)^(-1/3))^4\n g = np.power(\n lib.cvar.constants.TNCDM / np.power(11.0/4.0, -1.0/3.0),\n 4.0)\n\n if cosmo['N_nu_mass'] > 0:\n nu_mass_fracs = cosmo['m_nu'][:cosmo['N_nu_mass']]\n nu_mass_fracs = nu_mass_fracs / np.sum(nu_mass_fracs)\n\n cp.nu_mass_numbers = np.ones(cosmo['N_nu_mass'], dtype=np.int)\n cp.nu_mass_fractions = nu_mass_fracs\n cp.nu_mass_degeneracies = np.ones(int(cosmo['N_nu_mass'])) * g\n else:\n cp.nu_mass_numbers = []\n cp.nu_mass_fractions = []\n cp.nu_mass_degeneracies = []\n\n # get YHe from BBN\n cp.bbn_predictor = camb.bbn.get_predictor()\n cp.YHe = cp.bbn_predictor.Y_He(\n cp.ombh2 * (camb.constants.COBE_CMBTemp / cp.TCMB) ** 3,\n delta_neff)\n\n camb_de_models = ['DarkEnergyPPF', 'ppf', 'DarkEnergyFluid', 'fluid']\n camb_de_model = extra_camb_params.get('dark_energy_model', 'fluid')\n if camb_de_model not in camb_de_models:\n raise ValueError(\"The only dark energy models CCL supports with\"\n \" camb are fluid and ppf.\")\n cp.set_classes(\n dark_energy_model=camb_de_model\n )\n\n if camb_de_model not in camb_de_models[:2] and cosmo['wa'] and \\\n (cosmo['w0'] < -1 - 1e-6 or\n 1 + cosmo['w0'] + cosmo['wa'] < - 1e-6):\n raise ValueError(\"If you want to use w crossing -1,\"\n \" then please set the dark_energy_model to ppf.\")\n cp.DarkEnergy.set_params(\n w=cosmo['w0'],\n wa=cosmo['wa']\n )\n\n if nonlin:\n cp.NonLinearModel = camb.nonlinear.Halofit()\n halofit_version = extra_camb_params.get(\"halofit_version\", \"mead\")\n options = {k: extra_camb_params[k] for k in\n [\"HMCode_A_baryon\",\n \"HMCode_eta_baryon\",\n \"HMCode_logT_AGN\"] if k in extra_camb_params}\n cp.NonLinearModel.set_params(halofit_version=halofit_version,\n **options)\n\n cp.set_matter_power(\n redshifts=[_z for _z in zs],\n kmax=extra_camb_params.get(\"kmax\", 10.0),\n nonlinear=nonlin)\n if not nonlin:\n assert cp.NonLinear == camb.model.NonLinear_none\n\n cp.set_for_lmax(extra_camb_params.get(\"lmax\", 5000))\n cp.InitPower.set_params(\n As=A_s_fid,\n ns=cosmo['n_s'])\n\n # run CAMB and get results\n camb_res = camb.get_results(cp)\n k, z, pk = camb_res.get_linear_matter_power_spectrum(\n hubble_units=True, nonlinear=False)\n\n # convert to non-h inverse units\n k *= cosmo['h']\n pk /= (h2 * cosmo['h'])\n\n # now build interpolant\n nk = k.shape[0]\n lk_arr = np.log(k)\n a_arr = 1.0 / (1.0 + z)\n na = a_arr.shape[0]\n sinds = np.argsort(a_arr)\n a_arr = a_arr[sinds]\n ln_p_k_and_z = np.zeros((na, nk), dtype=np.float64)\n for i, sind in enumerate(sinds):\n ln_p_k_and_z[i, :] = np.log(pk[sind, :])\n\n pk_lin = Pk2D(\n pkfunc=None,\n a_arr=a_arr,\n lk_arr=lk_arr,\n pk_arr=ln_p_k_and_z,\n is_logp=True,\n extrap_order_lok=1,\n extrap_order_hik=2,\n cosmo=cosmo)\n\n if not nonlin:\n return pk_lin\n else:\n k, z, pk = camb_res.get_linear_matter_power_spectrum(\n hubble_units=True, nonlinear=True)\n\n # convert to non-h inverse units\n k *= cosmo['h']\n pk /= (h2 * cosmo['h'])\n\n # now build interpolant\n nk = k.shape[0]\n lk_arr = np.log(k)\n a_arr = 1.0 / (1.0 + z)\n na = a_arr.shape[0]\n sinds = np.argsort(a_arr)\n a_arr = a_arr[sinds]\n ln_p_k_and_z = np.zeros((na, nk), dtype=np.float64)\n for i, sind in enumerate(sinds):\n ln_p_k_and_z[i, :] = np.log(pk[sind, :])\n\n pk_nonlin = Pk2D(\n pkfunc=None,\n a_arr=a_arr,\n lk_arr=lk_arr,\n pk_arr=ln_p_k_and_z,\n is_logp=True,\n extrap_order_lok=1,\n extrap_order_hik=2,\n cosmo=cosmo)\n\n return pk_lin, pk_nonlin\n\n\ndef get_isitgr_pk_lin(cosmo):\n \"\"\"Run ISiTGR-CAMB and return the linear power spectrum.\n\n Args:\n cosmo (:class:`~pyccl.core.Cosmology`): Cosmological\n parameters. The cosmological parameters with\n which to run ISiTGR-CAMB.\n\n Returns:\n :class:`~pyccl.pk2d.Pk2D`: Power spectrum \\\n object. The linear power spectrum.\n \"\"\"\n\n try:\n import isitgr # noqa: F811\n import isitgr.model\n except ImportError as e:\n e.args = (\n \"You must have the `isitgr` python package \"\n \"installed to run CCL with ISiTGR-CAMB!\",\n *e.args)\n raise\n\n # Get extra CAMB parameters that were specified\n extra_camb_params = {}\n try:\n extra_camb_params = cosmo[\"extra_parameters\"][\"camb\"]\n except (KeyError, TypeError):\n pass\n\n # z sampling from CCL parameters\n na = lib.get_pk_spline_na(cosmo.cosmo)\n status = 0\n a_arr, status = lib.get_pk_spline_a(cosmo.cosmo, na, status)\n check(status)\n a_arr = np.sort(a_arr)\n zs = 1.0 / a_arr - 1\n zs = np.clip(zs, 0, np.inf)\n\n # deal with normalization\n if np.isfinite(cosmo[\"A_s\"]):\n A_s_fid = cosmo[\"A_s\"]\n elif np.isfinite(cosmo[\"sigma8\"]):\n # in this case, CCL will internally normalize for us when we init\n # the linear power spectrum - so we just get close\n A_s_fid = 2.43e-9 * (cosmo[\"sigma8\"] / 0.87659)**2\n else:\n raise CCLError(\n \"Could not normalize the linear power spectrum! \"\n \"A_s = %f, sigma8 = %f\" % (\n cosmo['A_s'], cosmo['sigma8']))\n\n # init isitgr params\n cp = isitgr.model.CAMBparams()\n\n # turn some stuff off\n cp.WantCls = False\n cp.DoLensing = False\n cp.Want_CMB = False\n cp.Want_CMB_lensing = False\n cp.Want_cl_2D_array = False\n cp.WantTransfer = True\n\n # basic background stuff\n h2 = cosmo['h']**2\n cp.H0 = cosmo['h'] * 100\n cp.ombh2 = cosmo['Omega_b'] * h2\n cp.omch2 = cosmo['Omega_c'] * h2\n cp.omk = cosmo['Omega_k']\n# cp.GR = 1 means GR modified!\n cp.GR = 1\n cp.ISiTGR_muSigma = True\n cp.mu0 = cosmo['mu_0']\n cp.Sigma0 = cosmo['sigma_0']\n cp.c1 = cosmo['c1_mg']\n cp.c2 = cosmo['c2_mg']\n cp.Lambda = cosmo['lambda_mg']\n\n # \"constants\"\n cp.TCMB = cosmo['T_CMB']\n\n # neutrinos\n # We maually setup the CAMB neutrinos to match the adjustments CLASS\n # makes to their temperatures.\n cp.share_delta_neff = False\n cp.omnuh2 = cosmo['Omega_nu_mass'] * h2\n cp.num_nu_massless = cosmo['N_nu_rel']\n cp.num_nu_massive = int(cosmo['N_nu_mass'])\n cp.nu_mass_eigenstates = int(cosmo['N_nu_mass'])\n\n delta_neff = cosmo['Neff'] - 3.046 # used for BBN YHe comps\n\n # ISiTGR built on CAMB which defines a neutrino degeneracy\n # factor as T_i = g^(1/4)*T_nu\n # where T_nu is the standard neutrino temperature from first order\n # computations\n # CLASS defines the temperature of each neutrino species to be\n # T_i_eff = TNCDM * T_cmb where TNCDM is a fudge factor to get the\n # total mass in terms of eV to match second-order computations of the\n # relationship between m_nu and Omega_nu.\n # We are trying to get both codes to use the same neutrino temperature.\n # thus we set T_i_eff = T_i = g^(1/4) * T_nu and solve for the right\n # value of g for CAMB. We get g = (TNCDM / (11/4)^(-1/3))^4\n g = np.power(\n lib.cvar.constants.TNCDM / np.power(11.0/4.0, -1.0/3.0),\n 4.0)\n\n if cosmo['N_nu_mass'] > 0:\n nu_mass_fracs = cosmo['m_nu'][:cosmo['N_nu_mass']]\n nu_mass_fracs = nu_mass_fracs / np.sum(nu_mass_fracs)\n\n cp.nu_mass_numbers = np.ones(cosmo['N_nu_mass'], dtype=np.int)\n cp.nu_mass_fractions = nu_mass_fracs\n cp.nu_mass_degeneracies = np.ones(int(cosmo['N_nu_mass'])) * g\n else:\n cp.nu_mass_numbers = []\n cp.nu_mass_fractions = []\n cp.nu_mass_degeneracies = []\n\n # get YHe from BBN\n cp.bbn_predictor = isitgr.bbn.get_predictor()\n cp.YHe = cp.bbn_predictor.Y_He(\n cp.ombh2 * (isitgr.constants.COBE_CMBTemp / cp.TCMB) ** 3,\n delta_neff)\n\n camb_de_models = ['DarkEnergyPPF', 'ppf', 'DarkEnergyFluid', 'fluid']\n camb_de_model = extra_camb_params.get('dark_energy_model', 'fluid')\n if camb_de_model not in camb_de_models:\n raise ValueError(\"The only dark energy models CCL supports with\"\n \" camb are fluid and ppf.\")\n cp.set_classes(\n dark_energy_model=camb_de_model\n )\n if camb_de_model not in camb_de_models[:2] and cosmo['wa'] and \\\n (cosmo['w0'] < -1 - 1e-6 or\n 1 + cosmo['w0'] + cosmo['wa'] < - 1e-6):\n raise ValueError(\"If you want to use w crossing -1,\"\n \" then please set the dark_energy_model to ppf.\")\n cp.DarkEnergy.set_params(\n w=cosmo['w0'],\n wa=cosmo['wa']\n )\n # cp.set_cosmology()\n cp.set_matter_power(\n redshifts=[_z for _z in zs],\n kmax=10,\n nonlinear=False)\n assert cp.NonLinear == isitgr.model.NonLinear_none\n\n cp.set_for_lmax(5000)\n cp.InitPower.set_params(\n As=A_s_fid,\n ns=cosmo['n_s'])\n\n # run ISITGR and get results\n isitgr_res = isitgr.get_results(cp)\n k, z, pk = isitgr_res.get_linear_matter_power_spectrum(\n hubble_units=True, nonlinear=False)\n\n # convert to non-h inverse units\n k *= cosmo['h']\n pk /= (h2 * cosmo['h'])\n\n # now build interpolant\n nk = k.shape[0]\n lk_arr = np.log(k)\n a_arr = 1.0 / (1.0 + z)\n na = a_arr.shape[0]\n sinds = np.argsort(a_arr)\n a_arr = a_arr[sinds]\n ln_p_k_and_z = np.zeros((na, nk), dtype=np.float64)\n for i, sind in enumerate(sinds):\n ln_p_k_and_z[i, :] = np.log(pk[sind, :])\n\n pk_lin = Pk2D(\n pkfunc=None,\n a_arr=a_arr,\n lk_arr=lk_arr,\n pk_arr=ln_p_k_and_z,\n is_logp=True,\n extrap_order_lok=1,\n extrap_order_hik=2,\n cosmo=cosmo)\n return pk_lin\n\n\ndef get_class_pk_lin(cosmo):\n \"\"\"Run CLASS and return the linear power spectrum.\n\n Args:\n cosmo (:class:`~pyccl.core.Cosmology`): Cosmological\n parameters. The cosmological parameters with\n which to run CLASS.\n\n Returns:\n :class:`~pyccl.pk2d.Pk2D`: Power spectrum object.\\\n The linear power spectrum.\n \"\"\"\n\n assert HAVE_CLASS, (\n \"You must have the python wrapper for CLASS \"\n \"installed to run CCL with CLASS!\")\n\n params = {\n \"output\": \"mPk\",\n \"non linear\": \"none\",\n \"P_k_max_1/Mpc\": cosmo.cosmo.spline_params.K_MAX_SPLINE,\n \"z_max_pk\": 1.0/cosmo.cosmo.spline_params.A_SPLINE_MINLOG_PK-1.0,\n \"modes\": \"s\",\n \"lensing\": \"no\",\n \"h\": cosmo[\"h\"],\n \"Omega_cdm\": cosmo[\"Omega_c\"],\n \"Omega_b\": cosmo[\"Omega_b\"],\n \"Omega_k\": cosmo[\"Omega_k\"],\n \"n_s\": cosmo[\"n_s\"]}\n\n # cosmological constant?\n # set Omega_Lambda = 0.0 if w !=-1 or wa != 0\n if cosmo['w0'] != -1 or cosmo['wa'] != 0:\n params[\"Omega_Lambda\"] = 0\n params['w0_fld'] = cosmo['w0']\n params['wa_fld'] = cosmo['wa']\n\n # neutrino parameters\n # massless neutrinos\n if cosmo[\"N_nu_rel\"] > 1e-4:\n params[\"N_ur\"] = cosmo[\"N_nu_rel\"]\n else:\n params[\"N_ur\"] = 0.0\n\n # massive neutrinos\n if cosmo[\"N_nu_mass\"] > 0:\n params[\"N_ncdm\"] = cosmo[\"N_nu_mass\"]\n masses = lib.parameters_get_nu_masses(cosmo._params, 3)\n params[\"m_ncdm\"] = \", \".join(\n [\"%g\" % m for m in masses[:cosmo[\"N_nu_mass\"]]])\n\n params[\"T_cmb\"] = cosmo[\"T_CMB\"]\n\n # if we have sigma8, we need to find A_s\n if np.isfinite(cosmo[\"A_s\"]):\n params[\"A_s\"] = cosmo[\"A_s\"]\n elif np.isfinite(cosmo[\"sigma8\"]):\n # in this case, CCL will internally normalize for us when we init\n # the linear power spectrum - so we just get close\n A_s_fid = 2.43e-9 * (cosmo[\"sigma8\"] / 0.87659)**2\n params[\"A_s\"] = A_s_fid\n else:\n raise CCLError(\n \"Could not normalize the linear power spectrum! \"\n \"A_s = %f, sigma8 = %f\" % (\n cosmo['A_s'], cosmo['sigma8']))\n\n model = None\n try:\n model = classy.Class()\n model.set(params)\n model.compute()\n\n # Set k and a sampling from CCL parameters\n nk = lib.get_pk_spline_nk(cosmo.cosmo)\n na = lib.get_pk_spline_na(cosmo.cosmo)\n status = 0\n a_arr, status = lib.get_pk_spline_a(cosmo.cosmo, na, status)\n check(status)\n\n # FIXME - getting the lowest CLASS k value from the python interface\n # appears to be broken - setting to 1e-5 which is close to the\n # old value\n lk_arr = np.log(np.logspace(\n -5,\n np.log10(cosmo.cosmo.spline_params.K_MAX_SPLINE), nk))\n\n # we need to cut this to the max value used for calling CLASS\n msk = lk_arr < np.log(cosmo.cosmo.spline_params.K_MAX_SPLINE)\n nk = int(np.sum(msk))\n lk_arr = lk_arr[msk]\n\n # now do interp by hand\n ln_p_k_and_z = np.zeros((na, nk), dtype=np.float64)\n for aind in range(na):\n z = max(1.0 / a_arr[aind] - 1, 1e-10)\n for kind in range(nk):\n ln_p_k_and_z[aind, kind] = np.log(\n model.pk_lin(np.exp(lk_arr[kind]), z))\n finally:\n if model is not None:\n model.struct_cleanup()\n model.empty()\n\n params[\"P_k_max_1/Mpc\"] = cosmo.cosmo.spline_params.K_MAX_SPLINE\n\n # make the Pk2D object\n pk_lin = Pk2D(\n pkfunc=None,\n a_arr=a_arr,\n lk_arr=lk_arr,\n pk_arr=ln_p_k_and_z,\n is_logp=True,\n extrap_order_lok=1,\n extrap_order_hik=2,\n cosmo=cosmo)\n\n return pk_lin\n", "meta": {"hexsha": "1681c445b64739489b775a5971292d1badbeadb4", "size": 17528, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyccl/boltzmann.py", "max_stars_repo_name": "Jappenn/CCL", "max_stars_repo_head_hexsha": "a37cad61f060f3928fa5d47b1e2670db3e9bce6f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 91, "max_stars_repo_stars_event_min_datetime": "2017-07-14T02:45:59.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-28T08:55:54.000Z", "max_issues_repo_path": "pyccl/boltzmann.py", "max_issues_repo_name": "Jappenn/CCL", "max_issues_repo_head_hexsha": "a37cad61f060f3928fa5d47b1e2670db3e9bce6f", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 703, "max_issues_repo_issues_event_min_datetime": "2017-07-07T16:27:17.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-30T14:40:10.000Z", "max_forks_repo_path": "pyccl/boltzmann.py", "max_forks_repo_name": "Jappenn/CCL", "max_forks_repo_head_hexsha": "a37cad61f060f3928fa5d47b1e2670db3e9bce6f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 54, "max_forks_repo_forks_event_min_datetime": "2017-07-12T13:08:25.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-06T13:12:10.000Z", "avg_line_length": 31.8112522686, "max_line_length": 76, "alphanum_fraction": 0.5977863989, "include": true, "reason": "import numpy", "num_tokens": 5279, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5851011542032312, "lm_q2_score": 0.3380771308191988, "lm_q1q2_score": 0.19780931945203}} {"text": "# Licensed under a 3-clause BSD style license - see LICENSE.rst\nfrom __future__ import absolute_import, division, print_function\nimport os\nimport json\nimport copy\nimport pprint\nimport logging\nimport numpy as np\nfrom astropy.io import fits\nfrom astropy.coordinates import SkyCoord\nfrom astropy.table import Table, Column\nfrom gammapy.maps import WcsNDMap, MapCoord\nimport fermipy.config\nfrom fermipy import utils\nfrom fermipy import defaults\nfrom fermipy import wcs_utils\nfrom fermipy import fits_utils\nfrom fermipy.sourcefind_utils import fit_error_ellipse\nfrom fermipy.sourcefind_utils import find_peaks\nfrom fermipy.skymap import Map\nfrom fermipy.config import ConfigSchema\nfrom fermipy.gtutils import FreeParameterState, SourceMapState\nfrom fermipy.timing import Timer\nfrom fermipy.model_utils import get_function_norm_par_name\nfrom LikelihoodState import LikelihoodState\nimport pyLikelihood as pyLike\n\n\nclass SourceFind(object):\n \"\"\"Mixin class which provides source-finding functionality to\n `~fermipy.gtanalysis.GTAnalysis`.\"\"\"\n\n def find_sources(self, prefix='', **kwargs):\n \"\"\"An iterative source-finding algorithm that uses likelihood\n ratio (TS) maps of the region of interest to find new sources.\n After each iteration a new TS map is generated incorporating\n sources found in the previous iteration. The method stops\n when the number of iterations exceeds ``max_iter`` or no\n sources exceeding ``sqrt_ts_threshold`` are found.\n\n Parameters\n ----------\n {options}\n\n tsmap : dict\n Keyword arguments dictionary for tsmap method.\n\n tscube : dict\n Keyword arguments dictionary for tscube method.\n\n Returns\n -------\n\n peaks : list\n List of peak objects.\n\n sources : list\n List of source objects.\n\n \"\"\"\n timer = Timer.create(start=True)\n self.logger.info('Starting.')\n\n schema = ConfigSchema(self.defaults['sourcefind'],\n tsmap=self.defaults['tsmap'],\n tscube=self.defaults['tscube'])\n\n schema.add_option('search_skydir', None, '', SkyCoord)\n schema.add_option('search_minmax_radius', [None, 1.0], '', list)\n\n config = utils.create_dict(self.config['sourcefind'],\n tsmap=self.config['tsmap'],\n tscube=self.config['tscube'])\n config = schema.create_config(config, **kwargs)\n\n # Defining default properties of test source model\n config['model'].setdefault('Index', 2.0)\n config['model'].setdefault('SpectrumType', 'PowerLaw')\n config['model'].setdefault('SpatialModel', 'PointSource')\n config['model'].setdefault('Prefactor', 1E-13)\n\n o = {'sources': [], 'peaks': []}\n\n for i in range(config['max_iter']):\n srcs, peaks = self._find_sources_iterate(prefix, i, **config)\n\n self.logger.info('Found %i sources in iteration %i.' %\n (len(srcs), i))\n\n o['sources'] += srcs\n o['peaks'] += peaks\n if len(srcs) == 0:\n break\n\n self.logger.info('Done.')\n self.logger.info('Execution time: %.2f s', timer.elapsed_time)\n\n return o\n\n def _build_src_dicts_from_peaks(self, peaks, maps, src_dict_template):\n\n tsmap = maps['ts']\n amp = maps['amplitude']\n\n src_dicts = []\n names = []\n\n for p in peaks:\n\n o = fit_error_ellipse(tsmap, (p['ix'], p['iy']), dpix=2)\n skydir = o['skydir']\n p['fit_loc'] = o\n p['fit_skydir'] = o['skydir']\n\n p.update(o)\n name = utils.create_source_name(skydir)\n src_dict = copy.deepcopy(src_dict_template)\n norm_par = get_function_norm_par_name(\n src_dict_template['SpectrumType'])\n src_dict.update({norm_par: amp.data[p['iy'], p['ix']],\n 'ra': skydir.icrs.ra.deg,\n 'dec': skydir.icrs.dec.deg})\n\n src_dict['glon_err'] = o['glon_err']\n src_dict['glat_err'] = o['glat_err']\n src_dict['ra_err'] = o['ra_err']\n src_dict['dec_err'] = o['dec_err']\n src_dict['pos_err'] = o['pos_err']\n src_dict['pos_err_semimajor'] = o['pos_err_semimajor']\n src_dict['pos_err_semiminor'] = o['pos_err_semiminor']\n src_dict['pos_r68'] = o['pos_r68']\n src_dict['pos_r95'] = o['pos_r95']\n src_dict['pos_r99'] = o['pos_r99']\n src_dict['pos_angle'] = o['pos_angle']\n src_dict['pos_gal_cov'] = o['pos_gal_cov']\n src_dict['pos_gal_corr'] = o['pos_gal_corr']\n src_dict['pos_cel_cov'] = o['pos_cel_cov']\n src_dict['pos_cel_corr'] = o['pos_cel_corr']\n\n self.logger.info('Found source\\n' +\n 'name: %s\\n' % name +\n 'ts: %f' % p['amp'] ** 2)\n\n names.append(name)\n src_dicts.append(src_dict)\n\n return names, src_dicts\n\n def _find_sources_iterate(self, prefix, iiter, **kwargs):\n\n src_dict_template = kwargs.pop('model')\n\n threshold = kwargs.get('sqrt_ts_threshold')\n multithread = kwargs.get('multithread', False)\n min_separation = kwargs.get('min_separation')\n sources_per_iter = kwargs.get('sources_per_iter')\n search_skydir = kwargs.get('search_skydir', None)\n search_minmax_radius = kwargs.get('search_minmax_radius', [None, 1.0])\n tsmap_fitter = kwargs.get('tsmap_fitter', 'tsmap')\n free_params = kwargs.get('free_params', None)\n if not free_params:\n free_params = None\n\n if tsmap_fitter == 'tsmap':\n kw = kwargs.get('tsmap', {})\n kw['model'] = src_dict_template\n kw['multithread'] = multithread\n m = self.tsmap(utils.join_strings([prefix,\n 'sourcefind_%02i' % iiter]),\n **kw)\n\n elif tsmap_fitter == 'tscube':\n kw = kwargs.get('tscube', {})\n kw['model'] = src_dict_template\n kw['do_sed'] = False\n m = self.tscube(utils.join_strings([prefix,\n 'sourcefind_%02i' % iiter]),\n **kw)\n else:\n raise Exception(\n 'Unrecognized option for fitter: %s.' % tsmap_fitter)\n\n if tsmap_fitter == 'tsmap':\n peaks = find_peaks(m['sqrt_ts'], threshold, min_separation)\n (names, src_dicts) = \\\n self._build_src_dicts_from_peaks(peaks, m, src_dict_template)\n elif tsmap_fitter == 'tscube':\n peaks = find_peaks(m['sqrt_ts'], threshold, min_separation)\n (names, src_dicts) = \\\n self._build_src_dicts_from_peaks(peaks, m, src_dict_template)\n \"\"\"\n sd = m['tscube'].find_sources(threshold ** 2, min_separation,\n use_cumul=False,\n output_src_dicts=True,\n output_peaks=True)\n peaks = sd['Peaks']\n names = sd['Names']\n src_dicts = sd['SrcDicts']\n \"\"\"\n\n # Loop over the seeds and add them to the model\n new_src_names = []\n for name, src_dict in zip(names, src_dicts):\n # Protect against finding the same source twice\n if self.roi.has_source(name):\n self.logger.info('Source %s found again. Ignoring it.' % name)\n continue\n # Skip the source if it's outside the search region\n if search_skydir is not None:\n\n skydir = SkyCoord(src_dict['ra'], src_dict['dec'], unit='deg')\n separation = search_skydir.separation(skydir).deg\n\n if not utils.apply_minmax_selection(separation,\n search_minmax_radius):\n self.logger.info('Source %s outside of '\n 'search region. Ignoring it.',\n name)\n continue\n\n self.add_source(name, src_dict, free=True)\n self.free_source(name, False)\n new_src_names.append(name)\n\n if len(new_src_names) >= sources_per_iter:\n break\n\n # Re-fit spectral parameters of each source individually\n for name in new_src_names:\n self.logger.info('Performing spectral fit for %s.', name)\n self.logger.debug(pprint.pformat(self.roi[name].params))\n self.free_source(name, True, pars=free_params)\n self.fit()\n self.logger.info(pprint.pformat(self.roi[name].params))\n self.free_source(name, False)\n\n srcs = []\n for name in new_src_names:\n srcs.append(self.roi[name])\n\n return srcs, peaks\n\n def localize(self, name, **kwargs):\n \"\"\"Find the best-fit position of a source. Localization is\n performed in two steps. First a TS map is computed centered\n on the source with half-width set by ``dtheta_max``. A fit is\n then performed to the maximum TS peak in this map. The source\n position is then further refined by scanning the likelihood in\n the vicinity of the peak found in the first step. The size of\n the scan region is set to encompass the 99% positional\n uncertainty contour as determined from the peak fit.\n\n Parameters\n ----------\n name : str\n Source name.\n\n {options}\n\n optimizer : dict\n Dictionary that overrides the default optimizer settings.\n\n Returns\n -------\n localize : dict\n Dictionary containing results of the localization\n analysis.\n\n \"\"\"\n timer = Timer.create(start=True)\n name = self.roi.get_source_by_name(name).name\n\n schema = ConfigSchema(self.defaults['localize'],\n optimizer=self.defaults['optimizer'])\n schema.add_option('use_cache', True)\n schema.add_option('prefix', '')\n config = utils.create_dict(self.config['localize'],\n optimizer=self.config['optimizer'])\n config = schema.create_config(config, **kwargs)\n\n self.logger.info('Running localization for %s' % name)\n\n free_state = FreeParameterState(self)\n loc = self._localize(name, **config)\n free_state.restore()\n\n self.logger.info('Finished localization.')\n\n if config['make_plots']:\n self._plotter.make_localization_plots(loc, self.roi,\n prefix=config['prefix'])\n\n outfile = \\\n utils.format_filename(self.workdir, 'loc',\n prefix=[config['prefix'],\n name.lower().replace(' ', '_')])\n\n if config['write_fits']:\n loc['file'] = os.path.basename(outfile) + '.fits'\n self._make_localize_fits(loc, outfile + '.fits',\n **config)\n\n if config['write_npy']:\n np.save(outfile + '.npy', dict(loc))\n\n self.logger.info('Execution time: %.2f s', timer.elapsed_time)\n return loc\n\n def _make_localize_fits(self, loc, filename, **kwargs):\n\n tab = fits_utils.dict_to_table(loc)\n hdu_data = fits.table_to_hdu(tab)\n hdu_data.name = 'LOC_DATA'\n\n hdus = [loc['tsmap_peak'].make_hdu(hdu='PRIMARY'),\n loc['tsmap'].make_hdu(hdu='TSMAP'),\n hdu_data]\n\n hdus[0].header['CONFIG'] = json.dumps(loc['config'])\n hdus[2].header['CONFIG'] = json.dumps(loc['config'])\n fits_utils.write_hdus(hdus, filename)\n\n def _localize(self, name, **kwargs):\n\n nstep = kwargs.get('nstep')\n dtheta_max = kwargs.get('dtheta_max')\n update = kwargs.get('update', True)\n prefix = kwargs.get('prefix', '')\n use_cache = kwargs.get('use_cache', False)\n free_background = kwargs.get('free_background', False)\n free_radius = kwargs.get('free_radius', None)\n fix_shape = kwargs.get('fix_shape', False)\n tsmap_fitter = kwargs.get('tsmap_fitter', 'tsmap')\n\n saved_state = LikelihoodState(self.like)\n loglike_init = -self.like()\n self.logger.debug('Initial Model Log-Likelihood: %f', loglike_init)\n\n if not free_background:\n self.free_sources(free=False, loglevel=logging.DEBUG)\n\n if free_radius is not None:\n diff_sources = [s.name for s in self.roi.sources if s.diffuse]\n skydir = self.roi[name].skydir\n free_srcs = [s.name for s in\n self.roi.get_sources(skydir=skydir,\n distance=free_radius,\n exclude=diff_sources)]\n self.free_sources_by_name(free_srcs, pars='norm',\n loglevel=logging.DEBUG)\n\n src = self.roi.copy_source(name)\n skydir = src.skydir\n skywcs = self.geom.wcs\n src_pix = skydir.to_pixel(skywcs)\n\n fit0 = self._fit_position_tsmap(name, prefix=prefix,\n dtheta_max=dtheta_max,\n zmin=-3.0,\n use_pylike=False,\n tsmap_fitter=tsmap_fitter)\n\n self.logger.debug('Completed localization with TS Map.\\n'\n '(ra,dec) = (%10.4f,%10.4f) '\n '(glon,glat) = (%10.4f,%10.4f)',\n fit0['ra'], fit0['dec'],\n fit0['glon'], fit0['glat'])\n\n # Fit baseline (point-source) model\n self.free_source(name, loglevel=logging.DEBUG)\n if fix_shape:\n self.free_source(name, free=False, pars='shape',\n loglevel=logging.DEBUG)\n fit_output = self._fit(loglevel=logging.DEBUG, **\n kwargs.get('optimizer', {}))\n\n # Save likelihood value for baseline fit\n loglike_base = fit_output['loglike']\n self.logger.debug('Baseline Model Log-Likelihood: %f', loglike_base)\n\n o = defaults.make_default_tuple(defaults.localize_output)\n o.name = name\n o.config = kwargs\n o.fit_success = True\n o.loglike_init = loglike_init\n o.loglike_base = loglike_base\n o.loglike_loc = np.nan\n o.dloglike_loc = np.nan\n\n if fit0['fit_success']:\n scan_cdelt = 2.0 * fit0['pos_r95'] / (nstep - 1.0)\n else:\n scan_cdelt = np.abs(skywcs.wcs.cdelt[0])\n\n self.logger.debug('Refining localization search to '\n 'region of width: %.4f deg',\n scan_cdelt * nstep)\n\n fit1 = self._fit_position_scan(name,\n skydir=fit0['skydir'],\n scan_cdelt=scan_cdelt,\n **kwargs)\n\n o.loglike_loc = fit1['loglike']\n o.dloglike_loc = o.loglike_loc - o.loglike_base\n o.tsmap = fit0.pop('tsmap')\n o.tsmap_peak = fit1.pop('tsmap')\n # o.update(fit1)\n\n # Best fit position and uncertainty from fit to TS map\n o.fit_init = fit0\n\n # Best fit position and uncertainty from pylike scan\n o.fit_scan = fit1\n o.update(fit1)\n\n cdelt0 = np.abs(skywcs.wcs.cdelt[0])\n cdelt1 = np.abs(skywcs.wcs.cdelt[1])\n pix = fit1['skydir'].to_pixel(skywcs)\n o.pos_offset = skydir.separation(fit1['skydir']).deg\n o.xpix = float(pix[0])\n o.ypix = float(pix[1])\n o.deltax = (o.xpix - src_pix[0]) * cdelt0\n o.deltay = (o.ypix - src_pix[1]) * cdelt1\n\n o.ra_preloc = skydir.ra.deg\n o.dec_preloc = skydir.dec.deg\n o.glon_preloc = skydir.galactic.l.deg\n o.glat_preloc = skydir.galactic.b.deg\n\n if o.pos_offset > dtheta_max:\n o.fit_success = False\n\n if not o.fit_success:\n self.logger.warning('Fit to localization contour failed.')\n elif not o.fit_inbounds:\n self.logger.warning('Best-fit position outside of search region.')\n else:\n self.logger.info('Localization succeeded.')\n\n if update and ((not o.fit_success) or (not o.fit_inbounds)):\n self.logger.warning(\n 'Localization failed. Keeping existing position.')\n\n if update and o.fit_success and o.fit_inbounds:\n self.logger.info('Updating source %s '\n 'to localized position.', name)\n src = self.delete_source(name)\n src.set_position(fit1['skydir'])\n self.add_source(name, src, free=True)\n self.free_source(name, loglevel=logging.DEBUG)\n if fix_shape:\n self.free_source(name, free=False, pars='shape',\n loglevel=logging.DEBUG)\n\n fit_output = self.fit(loglevel=logging.DEBUG)\n o.loglike_loc = fit_output['loglike']\n o.dloglike_loc = o.loglike_loc - o.loglike_base\n src = self.roi.get_source_by_name(name)\n\n src['glon_err'] = o.glon_err\n src['glat_err'] = o.glat_err\n src['ra_err'] = o.ra_err\n src['dec_err'] = o.dec_err\n src['pos_err'] = o.pos_err\n src['pos_err_semimajor'] = o.pos_err_semimajor\n src['pos_err_semiminor'] = o.pos_err_semiminor\n src['pos_r68'] = o.pos_r68\n src['pos_r95'] = o.pos_r95\n src['pos_r99'] = o.pos_r99\n src['pos_angle'] = o.pos_angle\n src['pos_gal_cov'] = o.pos_gal_cov\n src['pos_gal_corr'] = o.pos_gal_corr\n src['pos_cel_cov'] = o.pos_cel_cov\n src['pos_cel_corr'] = o.pos_cel_corr\n else:\n saved_state.restore()\n self._sync_params(name)\n self._update_roi()\n\n self.logger.info('Localization completed with new position:\\n'\n '( ra, dec) = (%10.4f +/- %8.4f,%10.4f +/- %8.4f)\\n'\n '(glon,glat) = (%10.4f +/- %8.4f,%10.4f +/- %8.4f)\\n'\n 'offset = %8.4f r68 = %8.4f r95 = %8.4f r99 = %8.4f',\n o.ra, o.ra_err, o.dec, o.dec_err,\n o.glon, o.glon_err, o.glat, o.glat_err,\n o.pos_offset, o.pos_r68, o.pos_r95, o.pos_r99)\n self.logger.info('LogLike: %12.3f DeltaLogLike: %12.3f',\n o.loglike_loc, o.loglike_loc - o.loglike_init)\n\n return o\n\n def _fit_position(self, name, **kwargs):\n\n dtheta_max = kwargs.setdefault('dtheta_max', 0.5)\n nstep = kwargs.setdefault('nstep', 5)\n fit0 = self._fit_position_tsmap(name, **kwargs)\n\n if np.isfinite(fit0['pos_r68']):\n scan_cdelt = min(2.0 * fit0['pos_r68'] / (nstep - 1.0),\n self._binsz)\n else:\n scan_cdelt = self._binsz\n\n fit1 = self._fit_position_scan(name,\n skydir=fit0['skydir'],\n scan_cdelt=scan_cdelt,\n **kwargs)\n return fit1, fit0\n\n def _fit_position_tsmap(self, name, **kwargs):\n \"\"\"Localize a source from its TS map.\"\"\"\n\n prefix = kwargs.get('prefix', '')\n dtheta_max = kwargs.get('dtheta_max', 0.5)\n zmin = kwargs.get('zmin', -3.0)\n tsmap_fitter = kwargs.get('tsmap_fitter', 'tsmap')\n\n kw = {'map_size': 2.0 * dtheta_max,\n 'write_fits': kwargs.get('write_fits', False),\n 'write_npy': kwargs.get('write_npy', False),\n 'max_kernel_radius': self.config['tsmap']['max_kernel_radius'],\n 'loglevel': logging.DEBUG}\n\n src = self.roi.copy_source(name)\n\n if src['SpatialModel'] in ['RadialDisk', 'RadialGaussian']:\n kw['max_kernel_radius'] = max(kw['max_kernel_radius'],\n 2.0 * src['SpatialWidth'])\n\n skydir = kwargs.get('skydir', src.skydir)\n \n if tsmap_fitter == 'tsmap':\n tsmap = self.tsmap(utils.join_strings([prefix, name.lower().\n replace(' ', '_')]),\n model=src.data,\n map_skydir=skydir,\n exclude=[name],\n use_pylike=kwargs.get('use_pylike', True),\n make_plots=False, **kw)\n else:\n tsmap = self.tscube(utils.join_strings([prefix, name.lower().replace(' ', '_')]), \n model=src.data,\n map_skydir=skydir,\n exclude=[name],\n make_plots=False,\n do_sed=False,\n **kw)\n \n\n # Find peaks with TS > 4\n peaks = find_peaks(tsmap['ts'], 4.0, 0.2)\n peak_best = None\n o = {}\n for p in sorted(peaks, key=lambda t: t['amp'], reverse=True):\n xy = p['ix'], p['iy']\n ts_value = tsmap['ts'].data[xy[1], xy[0]]\n posfit = fit_error_ellipse(tsmap['ts'], xy=xy, dpix=2,\n zmin=max(zmin, -ts_value * 0.5))\n offset = posfit['skydir'].separation(self.roi[name].skydir).deg\n if posfit['fit_success'] and posfit['fit_inbounds']:\n peak_best = p\n break\n\n if peak_best is None:\n ts_value = np.max(tsmap['ts'].data)\n posfit = fit_error_ellipse(tsmap['ts'], dpix=2,\n zmin=max(zmin, -ts_value * 0.5))\n\n o.update(posfit)\n pix = posfit['skydir'].to_pixel(self.geom.wcs)\n o['xpix'] = float(pix[0])\n o['ypix'] = float(pix[1])\n o['skydir'] = posfit['skydir'].transform_to('icrs')\n o['pos_offset'] = posfit['skydir'].separation(\n self.roi[name].skydir).deg\n o['loglike'] = 0.5 * posfit['zoffset']\n o['tsmap'] = tsmap['ts']\n\n return o\n\n def _fit_position_scan(self, name, **kwargs):\n\n zmin = kwargs.get('zmin', -9.0)\n tsmap, loglike = self._scan_position(name, **kwargs)\n ts_value = np.max(tsmap.data)\n posfit = fit_error_ellipse(tsmap, dpix=2,\n zmin=max(zmin, -ts_value * 0.5))\n pix = posfit['skydir'].to_pixel(self.geom.wcs)\n\n o = {}\n o.update(posfit)\n o['xpix'] = float(pix[0])\n o['ypix'] = float(pix[1])\n o['skydir'] = posfit['skydir'].transform_to('icrs')\n o['pos_offset'] = posfit['skydir'].separation(\n self.roi[name].skydir).deg\n o['loglike'] = 0.5 * posfit['zoffset'] + loglike\n o['tsmap'] = tsmap\n\n return o\n\n def _scan_position(self, name, **kwargs):\n\n saved_state = LikelihoodState(self.like)\n\n skydir = kwargs.pop('skydir', self.roi[name].skydir)\n scan_cdelt = kwargs.pop('scan_cdelt', 0.02)\n nstep = kwargs.pop('nstep', 5)\n use_cache = kwargs.get('use_cache', True)\n use_pylike = kwargs.get('use_pylike', False)\n optimizer = kwargs.get('optimizer', {})\n\n # Fit without source\n self.zero_source(name, loglevel=logging.DEBUG)\n fit_output_nosrc = self._fit(loglevel=logging.DEBUG,\n **optimizer)\n self.unzero_source(name, loglevel=logging.DEBUG)\n saved_state.restore()\n self.free_norm(name, loglevel=logging.DEBUG)\n\n lnlmap = WcsNDMap.create(skydir=skydir, binsz=scan_cdelt, npix=(nstep, nstep),\n coordsys=wcs_utils.get_coordsys(self.geom.wcs))\n\n src = self.roi.copy_source(name)\n\n if use_cache and not use_pylike:\n self._create_srcmap_cache(src.name, src)\n\n coord = MapCoord.create(lnlmap.geom.get_coord(flat=True),\n coordsys=lnlmap.geom.coordsys)\n scan_skydir = coord.skycoord.icrs\n for lon, lat, ra, dec in zip(coord.lon, coord.lat,\n scan_skydir.ra.deg, scan_skydir.dec.deg):\n\n spatial_pars = {'ra': ra, 'dec': dec}\n self.set_source_morphology(name,\n spatial_pars=spatial_pars,\n use_pylike=use_pylike)\n fit_output = self._fit(loglevel=logging.DEBUG,\n **optimizer)\n lnlmap.set_by_coord((lon, lat), fit_output['loglike'])\n\n self.set_source_morphology(name, spatial_pars=src.spatial_pars,\n use_pylike=use_pylike)\n saved_state.restore()\n\n lnlmap.data -= fit_output_nosrc['loglike']\n tsmap = WcsNDMap(lnlmap.geom, 2.0 * lnlmap.data)\n\n self._clear_srcmap_cache()\n return tsmap, fit_output_nosrc['loglike']\n\n def _fit_position_opt(self, name, use_cache=True):\n\n state = SourceMapState(self.like, [name])\n\n src = self.roi.copy_source(name)\n\n if use_cache:\n self._create_srcmap_cache(src.name, src)\n\n loglike = []\n skydir = src.skydir\n skywcs = self.geom.wcs\n src_pix = skydir.to_pixel(skywcs)\n\n c = skydir.transform_to('icrs')\n src.set_radec(c.ra.deg, c.dec.deg)\n self._update_srcmap(src.name, src)\n\n print(src_pix, self.like())\n\n import time\n\n def fit_fn(params):\n\n t0 = time.time()\n\n c = SkyCoord.from_pixel(params[0], params[1], self.geom.wcs)\n c = c.transform_to('icrs')\n src.set_radec(c.ra.deg, c.dec.deg)\n\n t1 = time.time()\n\n self._update_srcmap(src.name, src)\n\n t2 = time.time()\n\n val = self.like()\n\n t3 = time.time()\n\n print(params, val)\n # print(t1-t0,t2-t1,t3-t2)\n\n return val\n\n #lnl0 = fit_fn(src_pix[0],src_pix[1])\n #lnl1 = fit_fn(src_pix[0]+0.1,src_pix[1])\n # print(lnl0,lnl1)\n\n import scipy\n\n #src_pix[1] += 3.0\n p0 = [src_pix[0], src_pix[1]]\n\n #p0 = np.array([14.665692574327048, 16.004594098101926])\n #delta = np.array([0.3,-0.4])\n #p0 = [14.665692574327048, 16.004594098101926]\n\n o = scipy.optimize.minimize(fit_fn, p0,\n bounds=[(0.0, 39.0),\n (0.0, 39.0)],\n # method='L-BFGS-B',\n method='SLSQP',\n tol=1e-6)\n\n print('fit 2')\n\n o = scipy.optimize.minimize(fit_fn, o.x,\n bounds=[(0.0, 39.0),\n (0.0, 39.0)],\n # method='L-BFGS-B',\n method='SLSQP',\n tol=1e-6)\n print(o)\n\n print(fit_fn(p0))\n print(fit_fn(o.x))\n print(fit_fn(o.x + np.array([0.02, 0.02])))\n print(fit_fn(o.x + np.array([0.02, -0.02])))\n print(fit_fn(o.x + np.array([-0.02, 0.02])))\n print(fit_fn(o.x + np.array([-0.02, -0.02])))\n\n state.restore()\n\n return o\n", "meta": {"hexsha": "6fd2f58ee6fd65fe0a6bbf51216ac4e073e20c56", "size": 27897, "ext": "py", "lang": "Python", "max_stars_repo_path": "fermipy/sourcefind.py", "max_stars_repo_name": "damgreen/fermipy", "max_stars_repo_head_hexsha": "92b693a9272453bc6eb5c21e9bbac912408122fb", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "fermipy/sourcefind.py", "max_issues_repo_name": "damgreen/fermipy", "max_issues_repo_head_hexsha": "92b693a9272453bc6eb5c21e9bbac912408122fb", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "fermipy/sourcefind.py", "max_forks_repo_name": "damgreen/fermipy", "max_forks_repo_head_hexsha": "92b693a9272453bc6eb5c21e9bbac912408122fb", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.749661705, "max_line_length": 125, "alphanum_fraction": 0.5303796107, "include": true, "reason": "import numpy,import scipy,from astropy", "num_tokens": 6574, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5851011542032312, "lm_q2_score": 0.33807711748081287, "lm_q1q2_score": 0.197809311647725}} {"text": "\n\n\n# ZBFitter5.py\n# Reverting to radial scaling factors UVMAX=27mrad, XYmax=390mm: RT169.py\n# Reading RT169_Nrings_8_Rmax_27.txt\n#\n# 0.000023 0.000002 -0.013169 -0.000001 0.000012 0.018778 0.000187 -0.000000 -0.000005 0.000001 0.000000 \n# 0.000001 0.000001 0.000001 0.000002 0.000001 0.000002 0.000002 0.000004 0.000001 0.000002 0.000005\n#\n# all 24 look good!\n# Maybe a Diameter effect at the focal surface?\n# DESI-9.OPT has 840mm: should be plenty!\n# Let's try eliminating that Diameter: DESI-10.OPT go to RT170.py and YES here we are:\n#\n# Here using radial scaling factors UVMAX=28mrad, XYMAX=407mm\n# Reading RT170_Nrings_8_Rmax_28.txt using DESI-10.OPT lacking FP Diameter\n#\n# Results forward, 11 ZB coefs, RT170, ZBF5fwd, UVMAX=28\n# ADC0 Xtrans Ytrans Magnif UpDownUp RightLeftRight InOut OutInOut Roll LeftRightCurl UpDownCurl RollAntiRoll\n# coefs 0.000023 0.000001 -0.019117 -0.000001 0.000012 0.020128 0.000215 -0.000000 -0.000005 0.000001 0.000000 \n# sigma 0.000001 0.000001 0.000001 0.000002 0.000001 0.000002 0.000002 0.000000 0.000001 0.000002 0.000005\n# ADC6 (180 deg):\n# coefs -0.012770 0.000001 -0.019101 -0.000001 -0.000699 0.020127 0.000214 0.000000 -0.000104 0.000001 -0.000000 \n# sigma 0.000001 0.000001 0.000001 0.000002 0.000002 0.000002 0.000003 0.000003 0.000002 0.000002 0.000005\n# .. in fact all the 25 ADC settings look good. No \"nan\" or crazy results. \n#\n# Results reverse, 11 ZB coefs, RT170, ZBF5fwd, UVMAX=28\n# ADC0 Xtrans Ytrans Magnif UpDownUp RightLeftRight InOut OutInOut Roll LeftRightCurl UpDownCurl RollAntiRoll\n# coefs -0.000023 -0.000001 0.018720 0.000001 -0.000010 -0.020395 0.000566 0.000000 0.000005 -0.000001 0.000000 \n# sigma 0.000001 0.000001 0.000001 0.000002 0.000001 0.000002 0.000002 0.000000 0.000001 0.000002 0.000005\n# .. in fact ALL the 25 ADC settings look good. No \"nan\" or crazy results. \n#\n# Conclusion: use DESI-10.OPT prescription with its absence of FP Diameter spec. \n#\n#\n# Earlier: using radial scaling factors UVMAX=28mrad, XYMAX=407mm\n# Reading RT168_Nrings_8_Rmax_28.txt\n#\n# Results forward, 11 ZB coefs, RT168, ZBF3fwd, UVMAX=28\n# ADC0 Xtrans Ytrans Magnif UpDownUp RightLeftRight InOut OutInOut Roll LeftRightCurl UpDownCurl RollAntiRoll\n# coefs 0.000023 -0.000000 -0.019118 0.000000 0.000012 0.020126 0.000236 -0.000000 -0.000005 0.000000 0.000000 \n# sigma 0.000001 0.000005 0.000001 nan 0.000001 0.000002 0.000002 0.000007 0.000001 nan 0.000008\n# ADC6 (180 deg)\n# coefs -0.012771 -0.000000 -0.019103 0.000000 -0.000701 0.020126 0.000236 -0.000000 -0.000108 0.000000 0.000000 \n# sigma 0.000001 0.000006 0.000002 631.809570 0.000002 0.000002 0.000003 0.000010 0.000002 631.809566 0.000010\n# ^^^^^^^^ ^^^^^^^^\n# Yikes, why do the sigmas go crazy at ADC settings of 0, 180 degrees?\n# Could it be my UVMAX=28, or is it some other bug?\n# To find out, see RT169: just like RT168 but with UVMAX=27.\n#\n# Results reverse, 11 ZB coefs, RT168, ZBF3rev,UVMAX=28\n# ADC0:\n# coefs -0.000023 -0.000000 0.018720 -0.000000 -0.000010 -0.020398 0.000538 0.000000 0.000005 -0.000000 -0.000000 \n# sigma 0.000001 0.000005 0.000001 52.833776 0.000001 0.000002 0.000002 0.000008 0.000001 52.833778 0.000008\n# ADC6:\n# coefs 0.012763 0.000000 0.018716 -0.000000 -0.000237 -0.020398 0.000537 0.000000 0.000271 -0.000000 -0.000000 \n# sigma 0.000001 0.000005 0.000001 348.925720 0.000001 0.000002 0.000002 0.000009 0.000001 348.925720 0.000009\n#\n# COMPARE PREVIOUS RESULTS USING ZBFitter2.py:\n#\n# Results forward, 11 ZB coefs, RT166, ZBF2fwd, UVMAX=27\n# ADC0 Xtrans Ytrans Magnif UpDownUp RightLeftRight InOut OutInOut Roll LeftRightCurl UpDownCurl RollAntiRoll\n# coefs 0.000023 0.000002 -0.013169 -0.000001 0.000012 0.018778 0.000187 -0.000000 -0.000005 0.000001 0.000000 \n# sigma 0.000001 0.000001 0.000001 0.000002 0.000001 0.000002 0.000002 0.000004 0.000001 0.000002 0.000005\n# ADC6:\n# coefs -0.013285 0.000002 -0.013153 -0.000001 -0.000678 0.018777 0.000187 0.000000 -0.000101 0.000001 -0.000000 \n# sigma 0.000001 0.000001 0.000002 0.000002 0.000001 0.000002 0.000002 0.000004 0.000001 0.000002 0.000004\n#\n# Results reverse, 11 ZB coefs, RT166, ZBF2rev,UVMAX=27\n# ADC0:\n# coefs -0.000023 -0.000002 0.012965 0.000001 -0.000010 -0.018778 0.000475 0.000000 0.000005 -0.000001 0.000000 \n# sigma 0.000001 0.000001 0.000001 0.000002 0.000001 0.000002 0.000002 0.000000 0.000001 0.000002 0.000005\n# ADC6:\n# coefs 0.013233 -0.000002 0.012961 0.000001 -0.000226 -0.018777 0.000473 -0.000000 0.000256 -0.000001 -0.000000 \n# sigma 0.000001 0.000001 0.000001 0.000002 0.000001 0.000002 0.000002 0.000001 0.000001 0.000002 0.000000\n \n\n\n\n\n\n\n\n\n# coefs -0.000023 -0.000002 0.012965 0.000001 -0.000010 -0.018778 0.000475 0.000000 0.000005 -0.000001 0.000000 \n#\n# Modelling ADC roll as Zhao-Burge distortions.\n# Assumes that RT168.py has already run a complete monochromatic trace,\n# with ~ 400 rays per pupil, and 217 sky locations with image centroids,\n# for ADC1 = 0,30,60,... and then ADC2 = 0, 30, 60...degrees\n# These 24 cases are built into RT166.\n# The results file with all 24 cases is RT166_Nrings_8_Rmax_27.txt\n#\n\nimport csv\nimport numpy as np\nfrom numpy import genfromtxt\nimport matplotlib.pyplot as plt\nimport math\nfrom scipy.optimize import curve_fit\n\nPROGNAME = 'ZBFitter5.py'\n\nLUT = [0, 1, 2, 5, 6, 9, 20, 27, 28, 29, 30] # 11 polynomials\n# parm 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 # parm numbers\n# ZB: S2, S3, S4, S7, S8, S11, S22, T4, T7, T8, T11 # Zhao-Burge labels\n# Xt, Yt, mag,\n\n\nNPARMS = len(LUT)\n\n\ninfilename = 'RT169_Nrings_8_Rmax_27.txt' # 5425 records = 25 x 217\n\n\ndef getFileArray(filename):\n nums2D = list() \n with open(filename) as f:\n data = f.readlines()\n for row in data:\n numrow = list()\n words = row.split()\n for word in words:\n try:\n x = float(word)\n except:\n x = -0.0\n numrow.append(x)\n nums2D.append(numrow)\n #---Make nums2D rectangular, lest asarray() will return a 2D list---\n nrows = len(nums2D)\n ncols = 0\n for i in range(nrows):\n ncols = max(ncols, len(nums2D[i]))\n print(' ncols = ' + str(ncols))\n for i in range(nrows):\n while len(nums2D[i]) < ncols:\n nums2D[i].append(-0.0)\n myArray = np.asarray(nums2D)\n return myArray\n\n\n#-------ZERNIKE NORMALIZED FUNCTIONS & DERIVATIVES--------\n#-------------Using {n,m} definitions---------------------\n\ndef factorial(n):\n if n > 1:\n return int(n*factorial(n-1))\n else:\n return 1\n \ndef convertNolltoBW(noll):\n # converts a Noll Zernike index to the B&W {n,m,t} triplet\n n = int(-0.5+np.sqrt(2*noll-1.75))\n m = 0\n base = int(0.5*n**2 +0.5*n + 1)\n diff = noll - base\n if n%2==0:\n m = 2*int(0.5*diff + 0.7)\n else:\n m = 2*int(0.5*diff + 1.2) - 1\n if noll%2>0: \n m = -m\n return np.array([n, m])\n\ndef convertWyanttoBW(wyant):\n # converts a Wyant Zernike index to the B&W {n,m,t} \n halfsum = int(np.sqrt(wyant))\n idif = int(wyant - halfsum**2)\n halfdif = int (idif/2)\n n = halfsum + halfdif\n m = halfsum - halfdif\n if idif%2 >0:\n m = -m\n return np.array([n, m]) \n \ndef getZernFuncXY(nm, xnorm, ynorm): # BIG NINE: #1\n # Here, xnorm and ynorm must lie within the unit circle\n rnorm = np.sqrt(xnorm*xnorm + ynorm*ynorm)\n angle = np.arctan2(ynorm,xnorm)\n return getZernRadial(nm,rnorm) * getZernAngular(nm,angle)\n\n \ndef getZernRadial(nm, rnorm): # BIG NINE: #4\n n = nm[0] # B&W\n m = np.abs(nm[1]) # B&W\n halfsum = (n+m)/2\n idif = n-m\n halfdif = int(idif/2)\n # n = halfsum + halfdif # or, halfsum = (n+m)/2\n # m = halfsum - halfdif # or, halfdif = (n-m)/2\n # loop through the polynomial\n result = 0.\n for i in range(0, halfdif+1):\n expon = int(n-2*i)\n sign = 1 if i%2 == 0 else -1\n numer = sign * factorial(n-i)\n denom = factorial(i) * factorial(halfsum-i) * factorial(halfdif-i)\n coef = numer / denom\n term = coef*math.pow(rnorm, expon)\n result = result + term\n return result \n \ndef getZernAngular(nm, theta): \n m = nm[1] # B&W\n if m==0:\n return 1.\n if m>0:\n return math.cos(m*theta)\n m = np.abs(m) # note this abs() function\n return math.sin(m*theta) \n\ndef zernFormulaText(nm): # BIG NINE: #8\n #---generates a text representation of the specified Zernike function--\n n = nm[0] # B&W\n m = nm[1] # B&W\n # print 'New zernFormulaText() is using n, m: ', n, m\n needsine = True if m<0 else False\n m = np.abs(m)\n halfsum = (n+m)/2\n idif = n-m\n halfdif = int(idif/2)\n \n #--first do the radial part----\n nterms = 0\n s = ''\n #--evaluate the radial polynomial-----\n for i in range(0, halfdif+1):\n nterms = nterms + 1\n # print \"Starting with n, m, i, nterms = \", n, m, i, nterms\n expon = int(n-2*i) # start with highest exponent\n # print \" expon = \", expon\n sign = 1 if i%2 == 0 else -1 # alternating signs in Zernike series\n strsign = '+' if i%2==0 else '-'\n numer = sign * factorial(n-i)\n denom = factorial(i) * factorial(halfsum-i) * factorial(halfdif-i)\n coef = numer / denom\n scoef = str(coef)\n if coef==1 and expon>0: # suppress showing coef=1\n scoef = ''\n if coef > 0 and nterms > 1:\n scoef = '+' + scoef\n s = s + scoef\n if expon > 0:\n s = s + 'r'\n if expon > 1:\n s = s + '^' + str(expon)\n if nterms>1 and m!=0:\n s = '('+ s + ')'\n #--then do the azimuthal part, if any--------\n if m==0:\n return s\n strm = ''\n if m>1: \n strm = str(m)\n if needsine:\n s = s + '*sin(' + strm + 't)'\n else:\n s = s + '*cos(' + strm + 't)'\n return s\n\n#--END ZERNIKES with {n,m} B&W indexing------------\n\n\n\n\n#-----Zhao-Burge functions built from Zernikes---------------------\n\nrh = np.sqrt(0.5)\nrt = np.sqrt(2.0)\n\n\nNPARMS = len(LUT)\n \ndef getZ(noll, x, y):\n return getZernFuncXY(convertNolltoBW(noll), x, y)\n\ndef getZhaoBurgeTerm(whichparm, x, y):\n # Given a Lampton index \"which\" 0....19 and an object point x, y,\n # fetches the needed the Zernikes via their Noll numbers..\n # Returns the modeled image point deviation x, y.\n # Case numbers shown are from Zhao & Burge Tables 1 and 2. \n which = LUT[whichparm]\n if which==0: # case \"S2\" r^0, keep; X translate\n return getZ(1,x,y), 0.0\n \n if which==1: # case \"S3\" r^0, keep; Y translate\n return 0.0, getZ(1,x,y)\n \n if which==2: # case \"S4\" r^1, keep: magnification\n return rh*getZ(2,x,y), rh*getZ(3,x,y)\n \n if which==3: # case \"S5\" r^1 -1ppm Mangled, 3ppm PartlyMangled, 4ppm ADC45\n return rh*getZ(3,x,y), rh*getZ(2,x,y)\n \n if which==4: # case \"S6\" r^1 24ppm Mangled, 6ppm PartlyMangled,-5ppm ADC45\n return rh*getZ(2,x,y), -rh*getZ(3,x,y)\n \n if which==5: # case \"S7\" r^2 125ppm Mangled -908ppm PartlyMangled, ADC=423\n return 0.5*getZ(5,x,y), rh*getZ(4,x,y)-0.5*getZ(6,x,y)\n \n if which==6: # case \"S8\" r^2, 1223 Mangled, 653 PartlyMangled 10ppm ADC\n return rh*getZ(4,x,y)+0.5*getZ(6,x,y), 0.5*getZ(5,x,y)\n \n if which==7: # case \"S9\" r^3, 77ppm Mangled, 383 PartlyMangled, 116ppm ADC\n return rh*getZ(5,x,y), rh*getZ(6,x,y)\n \n if which==8: # case \"S10\" r^2, -6ppm Mangled -1ppm PartlyMangled, zero ADC\n return rh*getZ(6,x,y), -rh*getZ(5,x,y)\n \n if which==9: # case \"S11\" r^3, huge\n return rh*getZ(8,x,y), rh*getZ(7,x,y)\n \n if which==10: # case \"S12\" r^3, 2ppm Mangled,zero PartlyMangled, zero ADC\n return 0.5*getZ(8,x,y)+0.5*getZ(10,x,y), -0.5*getZ(7,x,y)+0.5*getZ(9,x,y)\n \n if which==11: # case \"S13\" r^3, zero Mangled zero PartlyMangled, 1ppm ADC\n return 0.5*getZ(7,x,y)+0.5*getZ(9,x,y), 0.5*getZ(8,x,y)-0.5*getZ(10,x,y)\n \n if which==12: # case \"S14\" r^3, 1ppm Mangled zero PartlyMangled zero ppm ADC\n return rh*getZ(10,x,y), -rh*getZ(9,x,y)\n \n if which==13: # case \"S15\" r^3, zero Mangled zeroPartlyMangled zero ppm ADC\n return rh*getZ(9,x,y), rh*getZ(10,x,y)\n \n if which==14: # Case \"S16\" r^4 38ppm Mangled; 9ppm PartlyMangled, zeroADCero ADC\n return rh*getZ(11,x,y)+0.5*getZ(12,x,y), 0.5*getZ(3,x,y)\n \n if which==15: # Case \"S17\": r^4 15ppmMangled, -7ppm PartlyMangled, 8ppm ADC\n return 0.5*getZ(3,x,y), rh*getZ(11,x,y)-0.5*getZ(12,x,y)\n \n if which==16: # Case \"S18\" r^4 -6ppm Mangled, zero PartlyMangled, zero ADC\n return 0.5*getZ(12,x,y)+0.5*getZ(14,x,y), 0.5*getZ(15,x,y)-0.5*getZ(13,x,y)\n \n if which==17: # Case \"S19\" r^4 2ppm Mangled -1ppm PartlyMangled 1ppm ADC;\n return 0.5*getZ(13,x,y)+0.5*getZ(15,x,y), 0.5*getZ(12,x,y)-0.5*getZ(14,x,y)\n \n if which==18: # Case \"S20\" r^4 zero Mangled, zero PartlyMangled, zero ADC\n return rh*getZ(14,x,y), -rh*getZ(15,x,y)\n \n if which==19: # Case \"S21\" r^4 zero Mangled 1ppm PartlyMangled, zero ADC\n return rh*getZ(15,x,y), rh*getZ(14,x,y)\n \n if which==20: # Case \"S22\" r^5 171 ppm Mangled 172ppm PartlyMangled, 172ppm ADC\n return rh*getZ(16,x,y), rh*getZ(17,x,y)\n \n if which==21: # Case \"S23\" r^5 zero Mangled 1ppm PartlyMangled, zero ADC\n return 0.5*getZ(17,x,y)+0.5*getZ(19,x,y), 0.5*getZ(16,x,y)-0.5*getZ(18,x,y)\n \n if which==22: # Case \"S24\" r^5 -1ppm Mangled zeroPartlyMangled,zero ADC\n return 0.5*getZ(16,x,y)+0.5*getZ(18,x,y), -0.5*getZ(17,x,y)+0.5*getZ(19,x,y)\n \n if which==23: # Case \"S25\" r^5 zero Mangled zero PartlyMangled zero ADC\n return 0.5*getZ(19,x,y)+0.5*getZ(21,x,y), 0.5*getZ(18,x,y)-0.5*getZ(20,x,y)\n \n if which==24: # Case \"S26\" r^5 zero ppm zero PartlyMangled zero ADC\n return 0.5*getZ(18,x,y)+0.5*getZ(20,x,y), -0.5*getZ(19,x,y)+0.5*getZ(21,x,y)\n\n if which==25: # Case \"S27\" r^5 zero ppm zero, PartlyMangled; zero ADC\n return rh*getZ(21,x,y), rh*getZ(20,x,y)\n\n if which==26: # Case \"S28\" r^5 zero ppm zero PartlyMangled, zero ADC\n return rh*getZ(20,x,y), -rh*getZ(21,x,y)\n\n if which==27: # case \"T4\" r^1, huge, -6ppm ADC. Roll.\n return rh*getZ(3,x,y), -rh*getZ(2,x,y)\n \n if which==28: # case \"T7\" r^2, -265ppm Mangled, 131 PartlyMangled, -4ppm ADC\n return rh*getZ(4,x,y)-0.5*getZ(6,x,y), -0.5*getZ(5,x,y)\n \n if which==29: # case \"T8\" r^2, -105ppm Mangled. -544ppm PartlyMangled, -163 ADC\n return 0.5*getZ(5,x,y), -rh*getZ(4,x,y)+0.5*getZ(6,x,y)\n \n if which==30: # case \"T11\" r^3, 358ppm Mangled, 358 PartlyMangled zero ADC\n return rh*getZ(7,x,y), -rh*getZ(8,x,y)\n \n if which==31: # case \"T12\" r^3, -1ppm Mangled, zero PartlyMangled, zero ADC\n return -0.5*getZ(7,x,y)+0.5*getZ(9,x,y), -0.5*getZ(8,x,y)-0.5*getZ(10,x,y)\n \n if which==32: # case \"T13\" r^3, +1ppm Mangled, zero PartlyMangled, zero ADC\n return 0.5*getZ(8,x,y)-0.5*getZ(10,x,y), -0.5*getZ(7,x,y)-0.5*getZ(9,x,y)\n \n print(\"ZhaoBurgeTerm() is exitting because which = \", which)\n quit()\n\n\n\"\"\"\ndef doRemapping(myParms):\n # feeds each sky point {u,v} into getZhaoSum()\n # will be called by optimizer to try out a mix of parameters.\n for i in range(0, len(SkyGrid)):\n u = SkyGrid[i, 0]\n v = SkyGrid[i, 1]\n x, y = getZhaoSum(myParms, u, v)\n # print 'result: i, x, y ={:6d}{:12.6f}{:12.6f}'.format(i, x, y) \n X[i] = x\n Y[i] = y\n\"\"\" \n\ndef zbFunc(uv, *parms): # uv = 1D array input concatenate(u[],v[])\n # Model: any number of Zhao & Burge parameters\n # note: curve_fit() calls its given func(args, *parms)\n # print(\"anyFunc() hasreceived parms = \")\n # print([\"{0:0.6f}\".format(xx) for xx in parms])\n pq = np.zeros(len(uv))\n half = len(uv)//2\n for i in range(0, half): # EACH OBJECT POINT NOT AN ARRAY\n u = uv[i]\n v = uv[i+half]\n x, y = getZhaoSum(u, v, *parms) # always args then parms\n pq[i] = x\n pq[i+half] = y\n return pq \n\ndef getZhaoSum(u, v, *coefs):\n # This models the distortion of ONE SKY POINT onto ONE FOCAL POINT.\n # Sums over all terms.\n # coefs is the array of 20 coefficients\n # u and v are Cartesian sky coordinates mapped into unit radius circle.\n x = u # initially undeviated\n y = v # initially undeviated\n for index in range(0, len(coefs)):\n dx, dy = getZhaoBurgeTerm(index, u, v)\n x += dx * coefs[index]\n y += dy * coefs[index]\n return x, y\n\ndef radialFunc(uv, *parms):\n # 6 parms model: dx, dy, a1, a3, a5, a7\n # untested!\n pq = np.zeros(len(uv))\n half = len(uv)//2\n for i in range(0, half):\n u = uv[i]\n v = uv[i+half]\n r = np.sqrt(u*u+v*v)\n if r==0.:\n u = 1E-12\n t = np.arctan2(u,v)\n rpoly = (1.+p[2])*r + p[3]*r**3 + p[4]*r**5 + p[5]*r**7\n x = p[0] + np.cos(t)*rpoly\n y = p[1] + np.sin(t)*rpoly\n pq[i] = x\n pq[i+half] = y\n return pq\n \n#-------------------Main program------------------------- \n\n\nalldata = getFileArray(infilename)\nprint(alldata.shape) # 5208 x 9; 24 fields of 217 spots each\nprint(' ADC1 ADC2 RU RV Ngood Xave Yave Xrms Yrms')\nNadcs = 25\nNeach = 217\nNRINGS = 8\nUVMAX = 28 # milliradians\nXYMAX = 407 # millimeters\n\n\n# first get the forward (sky to FP) fits to the 25 ADC tasks\n\noutfilename = 'ZBF5fwd_Nrings_' + str(NRINGS) + '_Rmax_' + str(UVMAX) + '.txt'\n\nwith open(outfilename, 'w') as outfile:\n for adc in range(Nadcs):\n adc12 = np.copy(alldata[adc*Neach:(adc+1)*Neach, 0:2]) # rows,cols\n uv = np.copy(alldata[adc*Neach:(adc+1)*Neach, 2:4]) # rows,cols\n xy = np.copy(alldata[adc*Neach:(adc+1)*Neach, 5:7]) # rows,cols\n uv *= 1000./UVMAX # for unit circle scaling\n xy *= 1./XYMAX # for unit circle scaling\n print()\n\n pinitial = np.zeros(NPARMS)\n args = np.concatenate([uv[:,0], uv[:,1]])\n goals = np.concatenate([xy[:,0], xy[:,1]])\n popt, covar = curve_fit(zbFunc, args, goals, pinitial)\n # note: curve_fit() calls its given func(args, *parms)\n print('\\npopt: \\n', popt)\n perror = np.sqrt(covar.diagonal())\n print('\\nerrors: \\n', perror)\n combo = np.concatenate((popt, perror)) # double parentheses\n result = ''\n for item in combo:\n result += '{:12.6f}'.format(item)\n outfile.writelines(result + '\\n') # yes, plural even for one line\n\n# then get the reverse (FP to sky) fits to the 25 ADC tasks\n\noutfilename = 'ZBF5rev_Nrings_' + str(NRINGS) + '_Rmax_' + str(UVMAX) + '.txt'\n\nwith open(outfilename, 'w') as outfile:\n for adc in range(Nadcs):\n adc12 = np.copy(alldata[adc*Neach:(adc+1)*Neach, 0:2]) # rows,cols\n uv = np.copy(alldata[adc*Neach:(adc+1)*Neach, 2:4]) # rows,cols\n xy = np.copy(alldata[adc*Neach:(adc+1)*Neach, 5:7]) # rows,cols\n uv *= 1000./UVMAX # for unit circle scaling\n xy *= 1./XYMAX # for unit circle scaling\n print()\n\n pinitial = np.zeros(NPARMS)\n goals = np.concatenate([uv[:,0], uv[:,1]])\n args = np.concatenate([xy[:,0], xy[:,1]])\n popt, covar = curve_fit(zbFunc, args, goals, pinitial)\n # note: curve_fit() calls its given func(args, *parms)\n print('\\npopt: \\n', popt)\n perror = np.sqrt(covar.diagonal())\n print('\\nerrors: \\n', perror)\n combo = np.concatenate((popt, perror)) # double parentheses\n result = ''\n for item in combo:\n result += '{:12.6f}'.format(item)\n outfile.writelines(result + '\\n') # yes, plural even for one line\n\n", "meta": {"hexsha": "028abfc833a6ccf21930de31a7a6ff50aea43736", "size": 21178, "ext": "py", "lang": "Python", "max_stars_repo_path": "py/desici/DESI-5095-v6/ZBFitter5.py", "max_stars_repo_name": "desihub/desici", "max_stars_repo_head_hexsha": "d9d165e2d9595e114d2330f92776089368df01c2", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "py/desici/DESI-5095-v6/ZBFitter5.py", "max_issues_repo_name": "desihub/desici", "max_issues_repo_head_hexsha": "d9d165e2d9595e114d2330f92776089368df01c2", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "py/desici/DESI-5095-v6/ZBFitter5.py", "max_forks_repo_name": "desihub/desici", "max_forks_repo_head_hexsha": "d9d165e2d9595e114d2330f92776089368df01c2", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.1223300971, "max_line_length": 144, "alphanum_fraction": 0.5638870526, "include": true, "reason": "import numpy,from numpy,from scipy", "num_tokens": 8092, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6297746074044134, "lm_q2_score": 0.31405054499180746, "lm_q1q2_score": 0.1977810586773576}} {"text": "# Copyright (c) 2019, CNRS-LAAS\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or without\n# modification, are permitted provided that the following conditions are met:\n#\n# * Redistributions of source code must retain the above copyright notice, this\n# list of conditions and the following disclaimer.\n#\n# * Redistributions in binary form must reproduce the above copyright notice,\n# this list of conditions and the following disclaimer in the documentation\n# and/or other materials provided with the distribution.\n#\n# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nimport typing as ty\n\nimport cv2\nimport numpy as np\nimport skimage.draw\nimport skimage.measure\n\nimport fire_rs.geodata.geo_data\nimport fire_rs.rbf\n\n\nclass Perimeter:\n\n def __init__(self, wildfire: fire_rs.geodata.geo_data.GeoData, threshold: float,\n layer: str = 'ignition', perimeter_background=np.inf):\n self._wildfire = wildfire\n self._threshold = threshold\n self._layer = layer\n self._empty_val = perimeter_background\n\n self._perimeter_array, self._cells, self._contour = _compute_perimeter(\n self._wildfire, self._threshold, layer=self._layer, empty_val=self._empty_val)\n\n if self._contour:\n for cont in self._contour:\n skimage.measure.grid_points_in_poly(self._wildfire.data.shape, cont)\n\n self._perimeter_geodata = None\n self._area_array = None\n\n @property\n def array(self) -> np.ndarray:\n return self._perimeter_array\n\n @property\n def cells(self) -> ty.MutableMapping[ty.Tuple[int, int], np.float64]:\n return self._cells\n\n @property\n def count(self) -> int:\n \"\"\"Number of indepedent perimeters\"\"\"\n return len(self._contour)\n\n @property\n def geodata(self) -> fire_rs.geodata.geo_data.GeoData:\n if self._perimeter_geodata is None:\n self._perimeter_geodata = self._wildfire.clone(data_array=self._perimeter_array,\n dtype=self._wildfire.data.dtype)\n return self._perimeter_geodata\n\n @property\n def area_array(self):\n \"\"\"Mask of cells inside the perimeter\"\"\"\n if self._area_array is None:\n if self._contour:\n self._area_array = skimage.measure.grid_points_in_poly(self._wildfire.data.shape,\n self._contour[0])\n if len(self._contour) > 1:\n for cont in self._contour[1:]:\n self._area_array += skimage.measure.grid_points_in_poly(\n self._wildfire.data.shape, cont)\n return self._area_array\n\n\n_compute_perimeter_output_type = ty.Tuple[\n np.ndarray, ty.MutableMapping[ty.Tuple[int, int], np.float64], ty.List[np.ndarray]]\n\n\ndef _compute_perimeter(wildfire: fire_rs.geodata.geo_data.GeoData, threshold: float,\n layer: str = 'ignition', empty_val=np.inf) -> _compute_perimeter_output_type:\n \"\"\"Extract the perimeter given by threshold from a fire map.\"\"\"\n\n array = np.ones(wildfire.data.shape, dtype=np.float64) * empty_val\n cells = {}\n\n contours = skimage.measure.find_contours(wildfire.data[layer], threshold)\n\n for contour in contours:\n try:\n rr, cc = skimage.draw.polygon_perimeter(contour[..., 0], contour[..., 1],\n shape=wildfire.data.shape, clip=True)\n # Set perimeter in array format\n array[rr, cc] = wildfire.data[layer][rr, cc]\n # Set perimeter in dict format\n for r, c in zip(rr, cc):\n cells[r, c] = wildfire.data[layer][r, c]\n except IndexError as e:\n pass # Ignore contour if it contains NaN (polygon_perimeter throws IndexError)\n\n\n # for contour in contours:\n # prev_edge = contour[0]\n # for edge in contour[1:]:\n # if np.isnan(prev_edge).any() or np.isnan(edge).any():\n # continue\n # rr, cc = skimage.draw.line(*np.asarray(prev_edge, dtype=int),\n # *np.asarray(edge, dtype=int))\n # # Set perimeter in array format\n # array[rr, cc] = wildfire.data[layer][rr, cc]\n # # Set perimeter in dict format\n # for r, c in zip(rr, cc):\n # cells[r, c] = wildfire.data[layer][r, c]\n #\n # prev_edge = edge\n\n return array, cells, contours\n\n\ndef interpolate(x, y, z, shape, function='thin_plate') -> np.ndarray:\n \"\"\"RBF interpolation\"\"\"\n # Wildland fire modeling with an Eulerian level set method and automated calibration\n # might give a clue of which kind of kernel function to use\n\n # default smooth=0 for interpolation\n interpolator = fire_rs.rbf.Rbf(x, y, z, function=function, smooth=0, cond=10 ** -5)\n\n xi = np.linspace(0, shape[0] - 1, shape[0])\n yi = np.linspace(0, shape[1] - 1, shape[1])\n meshgrid = np.meshgrid(xi, yi, indexing=\"ij\")\n\n dense_array = interpolator(*[x.flatten() for x in meshgrid])\n\n return dense_array.reshape(shape[0], shape[1])\n\n\ndef rate_of_spread_map(firemap: fire_rs.geodata.geo_data.GeoData, layer=\"ignition\",\n output_layer=\"ros\") -> fire_rs.geodata.geo_data.GeoData:\n \"\"\"Compute the Rate of Spread from a wildfire_map\"\"\"\n gradient = firemap.clone(data_array=np.linalg.norm(np.gradient(firemap[layer]), axis=0),\n dtype=[(output_layer, 'float64')])\n return gradient\n\n\nclass WildfireGraph:\n \"\"\"Computation of the propagation graph and end of ignition from a wildfire map\"\"\"\n IGNITION_END = 'ignition_end'\n PROP_X = 'prop_x'\n PROP_Y = 'prop_y'\n PROP_DIR = 'prop_dir'\n\n def __init__(self, firemap: fire_rs.geodata.geo_data.GeoData, ignition_layer: str = 'ignition',\n ignition_end_layer: str = IGNITION_END, prop_x_layer: str = PROP_X,\n prop_y_layer: str = PROP_Y, prop_dir_layer: str = PROP_DIR):\n self._ignition_layer = ignition_layer\n self._ignition_end_layer = ignition_end_layer\n self._prop_x_layer = prop_x_layer\n self._prop_y_layer = prop_y_layer\n self._prop_dir_layer = prop_dir_layer\n self.geodata = firemap.clone(fill_value=0,\n dtype=[(ignition_layer, 'float64'),\n ('ignition_end', 'float64'),\n ('prop_x', 'int8'),\n ('prop_y', 'int8'),\n ('prop_dir', 'float64')])\n self.geodata.data[ignition_layer] = firemap.data[ignition_layer]\n grad = np.gradient(self.geodata.data[ignition_layer])\n self.geodata.data[prop_dir_layer] = np.arctan2(grad[1], grad[0])\n self.geodata.data[prop_x_layer] = np.array(\n np.round(np.cos(self.geodata.data[prop_dir_layer])), np.int)\n self.geodata.data[prop_y_layer] = np.array(\n np.round(np.sin(self.geodata.data[prop_dir_layer])), np.int)\n self.geodata.data[ignition_end_layer] = WildfireGraph._compute_traversal_end(\n self.geodata.data[ignition_layer])\n\n @staticmethod\n def _compute_propagation_direction(fire_array: np.array):\n def default_ignition(x, y, dx, dy):\n if x == 0 and dx < 0:\n return fire_array[x, y]\n if x + dx >= fire_array.shape[0]:\n return fire_array[x, y]\n if y == 0 and dy < 0:\n return fire_array[x, y]\n if y + dy >= fire_array.shape[1]:\n return fire_array[x, y]\n if fire_array[x + dx, y + dy] < np.inf:\n return fire_array[x + dx, y + dy]\n else:\n return fire_array[x, y]\n\n prop_delta_x = np.zeros_like(fire_array, np.int)\n prop_delta_y = np.zeros_like(fire_array, np.int)\n prop_dir = np.zeros_like(fire_array)\n\n for x in range(0, fire_array.shape[0]):\n for y in range(0, fire_array.shape[1]):\n if fire_array[x, y] < np.inf:\n ign = lambda dx, dy: default_ignition(x, y, dx, dy)\n prop_delta_x[x, y] = ign(1, -1) + 2 * ign(1, 0) + ign(1, 1) - ign(-1,\n -1) - 2 * ign(\n -1, 0) - ign(-1, 1)\n prop_delta_y[x, y] = ign(1, 1) + 2 * ign(0, 1) + ign(-1, 1) - ign(1,\n -1) - 2 * ign(\n 0, -1) - ign(-1, -1)\n prop_dir = np.arctan2(prop_delta_y[x, y], prop_delta_x[x, y])\n\n return prop_delta_x, prop_delta_y, prop_dir\n\n @staticmethod\n def _compute_traversal_end(fire_array: np.ndarray):\n \"\"\"Compute the ignition end time for each cell.\n\n The ignition end time is the latest ignition time among all neighbor cells.\"\"\"\n end = np.zeros_like(fire_array) * np.inf\n\n for x in range(0, fire_array.shape[0]):\n for y in range(0, fire_array.shape[1]):\n if fire_array[x, y] < np.inf:\n max_neighbor = 0.0\n for dx in [-1, 0, 1]:\n for dy in [-1, 0, 1]:\n if (dx == 0 and dy == 0) or (x == 0 and dx < 0) or (\n x + dx >= fire_array.shape[0]) or (y == 0 and dy < 0) or (\n y + dy >= fire_array.shape[1]):\n continue\n if fire_array[x + dx, y + dy] < np.inf:\n max_neighbor = max(max_neighbor, fire_array[x + dx, y + dy])\n if max_neighbor <= fire_array[x, y]:\n # propagation_border\n end[x, y] = fire_array[x, y] + 180 # assume 3 minutes\n else:\n end[x, y] = max_neighbor\n else:\n end[x, y] = fire_array[x, y]\n return end\n\n def find_parent_or_child_of_time(self, start_cell: fire_rs.geodata.geo_data.Cell, time: float):\n \"\"\"Find an ignited cell at 'time' in the propagation graph starting from 'start_cell'\n\n This function similar to the c++ planning 'project on firefront' algorithm.\n \"\"\"\n\n coord = start_cell\n found = False\n while not found:\n if self.geodata.data[self._ignition_layer][coord] <= time and time < \\\n self.geodata.data[self._ignition_end_layer][coord]:\n found = True\n else:\n uphill_cell = (coord[0] + self.geodata.data[self._prop_x_layer][coord],\n coord[1] + self.geodata.data[self._prop_y_layer][coord])\n downhill_cell = (coord[0] - self.geodata.data[self._prop_x_layer][coord],\n coord[1] - self.geodata.data[self._prop_y_layer][coord])\n if uphill_cell[0] == downhill_cell[0] and uphill_cell[1] == downhill_cell[1]:\n # Extrema reached\n coord = uphill_cell\n found = True\n next_cell = downhill_cell if self.geodata.data[self._ignition_layer][\n coord] > time else uphill_cell\n\n if (next_cell[0] < 0 or next_cell[0] >\n self.geodata.data[self._ignition_layer].shape[0] - 1) and (\n next_cell[1] < 0 or next_cell[1] >\n self.geodata.data[self._ignition_layer].shape[1] - 1):\n found = True\n if (next_cell == downhill_cell) and (\n self.geodata.data[self._ignition_layer][next_cell] >\n self.geodata.data[self._ignition_layer][coord]) or (\n next_cell == uphill_cell) and (\n self.geodata.data[self._ignition_layer][next_cell] <\n self.geodata.data[self._ignition_layer][coord]):\n # Extrema reached\n found = True\n if self.geodata.data[self._ignition_layer][next_cell] < np.inf:\n coord = next_cell\n return coord\n\n\ndef warp_firemap(gd: fire_rs.geodata.geo_data.GeoData, orig: ty.Sequence[ty.Tuple[int, int]],\n dest: ty.Sequence[ty.Tuple[int, int]],\n layer: str = \"ignition\"):\n array = _warp_image(gd[layer], orig, dest)\n new_gd = fire_rs.firemodel.propagation.empty_firemap(gd, layer=layer)\n new_gd.data[\"ignition\"] = array\n return new_gd\n\n\ndef _warp_image(array: np.ndarray, orig: ty.Sequence[ty.Tuple[int, int]],\n dest: ty.Sequence[ty.Tuple[int, int]]) -> np.ndarray:\n newarray = array.copy()\n newarray = newarray.T # opencv convention on columns and rows is inverted\n newarray_min = newarray.min()\n newarray_max = newarray.max()\n newarray = (newarray - newarray_min) / (newarray_max - newarray_min)\n orig_p = np.array(orig, np.int32)\n orig_p = orig_p.reshape(1, -1, 2) # Don't ask why. https://stackoverflow.com/a/47114049\n dest_p = np.array(dest, np.int32)\n dest_p = dest_p.reshape(1, -1, 2) # Don't ask why. https://stackoverflow.com/a/47114049\n good_matches = [cv2.DMatch(p, p, 0) for p in range(len(orig))]\n tps = cv2.createThinPlateSplineShapeTransformer()\n tps.estimateTransformation(dest_p, orig_p, good_matches)\n warped = None\n warped = tps.warpImage(newarray, warped, cv2.INTER_LINEAR, cv2.BORDER_CONSTANT, np.inf)\n warped = warped * (newarray_max - newarray_min) + newarray_min\n warped = warped.T\n return warped\n", "meta": {"hexsha": "9f788fd06f698dcba093d450c0bfe7b2d1c41bf5", "size": 14606, "ext": "py", "lang": "Python", "max_stars_repo_path": "python/fire_rs/geodata/wildfire.py", "max_stars_repo_name": "arthur-bit-monnot/fire-rs-saop", "max_stars_repo_head_hexsha": "321e16fceebf44e8e97b482c24f37fbf6dd7d162", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 13, "max_stars_repo_stars_event_min_datetime": "2018-11-19T15:51:23.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-16T11:24:21.000Z", "max_issues_repo_path": "python/fire_rs/geodata/wildfire.py", "max_issues_repo_name": "fire-rs-laas/fire-rs-saop", "max_issues_repo_head_hexsha": "321e16fceebf44e8e97b482c24f37fbf6dd7d162", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 14, "max_issues_repo_issues_event_min_datetime": "2017-10-12T16:19:19.000Z", "max_issues_repo_issues_event_max_datetime": "2018-03-12T12:07:56.000Z", "max_forks_repo_path": "python/fire_rs/geodata/wildfire.py", "max_forks_repo_name": "fire-rs-laas/fire-rs-saop", "max_forks_repo_head_hexsha": "321e16fceebf44e8e97b482c24f37fbf6dd7d162", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2018-03-12T12:28:55.000Z", "max_forks_repo_forks_event_max_datetime": "2021-07-07T18:32:17.000Z", "avg_line_length": 45.5015576324, "max_line_length": 100, "alphanum_fraction": 0.5804463919, "include": true, "reason": "import numpy", "num_tokens": 3443, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5039061705290806, "lm_q2_score": 0.3923368301671084, "lm_q1q2_score": 0.19770094964702586}} {"text": "import calendar\nimport glob\nimport numpy as np\nimport openapi_client as dbitApi\nimport os\nimport pandas as pd\n\nfrom datetime import datetime\n\napi = dbitApi.MarketDataApi()\n\ndef format_datetime_to_expiry(date):\n if os.name == 'nt':\n return datetime.strftime(date, '%#d%b%y').upper()\n else:\n return datetime.strftime(date, '%-d%b%y').upper()\n\ndef get_near_next_terms(now):\n c = calendar.Calendar(firstweekday=calendar.MONDAY)\n \n this_month_cal = c.monthdatescalendar(now.year, now.month)\n this_fridays = [datetime(day.year, day.month, day.day, 8, 0, 0) \n for week in this_month_cal for day in week \n if day.weekday() == calendar.FRIDAY and day.month == now.month \n and datetime(day.year, day.month, day.day, 8, 0, 0) >= now]\n \n next_year = now.year if now.month < 12 else now.year + 1\n next_month = now.month + 1 if now.month < 12 else 1\n \n next_month_cal = c.monthdatescalendar(next_year, next_month)\n next_fridays = [datetime(day.year, day.month, day.day, 8, 0, 0) \n for week in next_month_cal for day in week \n if day.weekday() == calendar.FRIDAY and day.month == next_month \n and datetime(day.year, day.month, day.day, 8, 0, 0) >= now]\n \n fridays = this_fridays + next_fridays\n \n near_term, next_term = fridays[0], fridays[1]\n \n return (format_datetime_to_expiry(near_term), format_datetime_to_expiry(next_term), near_term, next_term)\n\ndef get_index(currency='BTC'):\n try:\n index_result = api.public_get_index_get(currency)['result'][currency]\n return index_result\n except dbitApi.exceptions.ApiException as e:\n print(e)\n #logger.exception('Exception when calling MarketDataApi->public_get_instruments_get!')\n exit()\n\ndef get_instruments_with_expiry(expiry, currency='BTC', kind='option', expired='false'):\n try:\n instrument_result = api.public_get_instruments_get(currency, kind=kind, expired=expired)['result']\n return [instrument['instrument_name'] for instrument in instrument_result if expiry in instrument['instrument_name']]\n except dbitApi.exceptions.ApiException as e:\n print(e)\n #logger.exception('Exception when calling MarketDataApi->public_get_instruments_get!')\n exit()\n\ndef get_ticker(instrument):\n try:\n instrument_result = api.public_ticker_get(instrument)['result']\n return instrument_result\n except dbitApi.exceptions.ApiException as e:\n print(e)\n #logger.exception('Exception when calling MarketDataApi->public_get_instruments_get!')\n exit()\n\ndef get_bids_asks(near_list, next_list):\n near_calls = dict()\n near_puts = dict()\n next_calls = dict()\n next_puts = dict()\n\n for instrument in near_list:\n data = get_ticker(instrument)\n best_bid, best_ask = data['best_bid_price'], data['best_ask_price']\n strike, cp = int(instrument.split('-')[2]), instrument.split('-')[3]\n\n if cp == 'C':\n near_calls[strike] = {'best_bid': best_bid, 'best_ask': best_ask}\n elif cp == 'P':\n near_puts[strike] = {'best_bid': best_bid, 'best_ask': best_ask}\n else:\n print(f'Error {instrument}')\n\n for instrument in next_list:\n data = get_ticker(instrument)\n best_bid, best_ask = data['best_bid_price'], data['best_ask_price']\n strike, cp = int(instrument.split('-')[2]), instrument.split('-')[3]\n\n if cp == 'C':\n next_calls[strike] = {'best_bid': best_bid, 'best_ask': best_ask}\n elif cp == 'P':\n next_puts[strike] = {'best_bid': best_bid, 'best_ask': best_ask}\n else:\n print(f'Error {instrument}')\n\n near_calls_df = pd.DataFrame.from_dict(near_calls, orient='index').sort_index().replace(0, np.nan)\n near_puts_df = pd.DataFrame.from_dict(near_puts, orient='index').sort_index().replace(0, np.nan)\n next_calls_df = pd.DataFrame.from_dict(next_calls, orient='index').sort_index().replace(0, np.nan)\n next_puts_df = pd.DataFrame.from_dict(next_puts, orient='index').sort_index().replace(0, np.nan)\n\n return near_calls_df, near_puts_df, next_calls_df, next_puts_df\n\ndef calculate_indices(time, near_datetime, next_datetime, const_mature_days, R, near_calls_df, near_puts_df, next_calls_df, next_puts_df):\n # Compute strikes with min call/put price difference\n near_prices = pd.DataFrame(index=near_calls_df.index)\n near_prices['call_price'] = (near_calls_df['best_bid'] + near_calls_df['best_ask']) / 2\n near_prices['put_price'] = (near_puts_df['best_bid'] + near_puts_df['best_ask']) / 2\n near_prices['abs_diff'] = abs(near_prices['call_price'] - near_prices['put_price'])\n\n min_near_strike = near_prices['abs_diff'].idxmin()\n min_near_diff = near_prices.loc[min_near_strike].abs_diff\n\n next_prices = pd.DataFrame(index=next_calls_df.index)\n next_prices['call_price'] = (next_calls_df['best_bid'] + next_calls_df['best_ask']) / 2\n next_prices['put_price'] = (next_puts_df['best_bid'] + next_puts_df['best_ask']) / 2\n next_prices['abs_diff'] = abs(next_prices['call_price'] - next_prices['put_price'])\n\n min_next_strike = next_prices['abs_diff'].idxmin()\n min_next_diff = next_prices.loc[min_next_strike].abs_diff\n\n n1 = (near_datetime - time).total_seconds() / 60\n n2 = (next_datetime - time).total_seconds() / 60\n nY = 525600\n n = const_mature_days * 24 * 60\n\n t1 = n1/nY\n t2 = n2/nY\n\n # Compute forward prices and at-the-money strikes\n f1 = min_near_strike + np.e**(R*t1) * min_near_diff\n k0_1 = max([strike for strike in near_prices.index if strike <= min_near_strike])\n\n f2 = min_next_strike + np.e**(R*t2) * min_next_diff\n k0_2 = max([strike for strike in next_prices.index if strike <= min_next_strike])\n\n near_otm_puts_df = near_puts_df.loc[:k0_1].iloc[:-1]\n near_otm_calls_df = near_calls_df.loc[k0_1:].iloc[1:]\n next_otm_puts_df = next_puts_df.loc[:k0_2].iloc[:-1]\n next_otm_calls_df = next_calls_df.loc[k0_2:].iloc[1:]\n\n near_otm_puts_df = near_otm_puts_df.sort_index(ascending=False)\n near_otm_puts_df = near_otm_puts_df.assign(zero_bid=lambda df: (df['best_bid'] == 0).astype(int))\n near_otm_puts_df['zero_bid_cumsum'] = near_otm_puts_df['zero_bid'].cumsum()\n near_otm_puts_df = near_otm_puts_df[(near_otm_puts_df['zero_bid_cumsum'] <= 2) & (near_otm_puts_df['best_bid'] > 0)]\n \n near_otm_calls_df = near_otm_calls_df.assign(zero_bid=lambda df: (df['best_bid'] == 0).astype(int))\n near_otm_calls_df['zero_bid_cumsum'] = near_otm_calls_df['zero_bid'].cumsum()\n near_otm_calls_df = near_otm_calls_df[(near_otm_calls_df['zero_bid_cumsum'] <= 2) & (near_otm_calls_df['best_bid'] > 0)]\n\n next_otm_puts_df = next_otm_puts_df.sort_index(ascending=False)\n next_otm_puts_df = next_otm_puts_df.assign(zero_bid=lambda df: (df['best_bid'] == 0).astype(int))\n next_otm_puts_df['zero_bid_cumsum'] = next_otm_puts_df['zero_bid'].cumsum()\n next_otm_puts_df = next_otm_puts_df[(next_otm_puts_df['zero_bid_cumsum'] <= 2) & (next_otm_puts_df['best_bid'] > 0)]\n\n next_otm_calls_df = next_otm_calls_df.assign(zero_bid=lambda df: (df['best_bid'] == 0).astype(int))\n next_otm_calls_df['zero_bid_cumsum'] = next_otm_calls_df['zero_bid'].cumsum()\n next_otm_calls_df = next_otm_calls_df[(next_otm_calls_df['zero_bid_cumsum'] <= 2) & (next_otm_calls_df['best_bid'] > 0)]\n\n near_calc_strikes_df = pd.DataFrame(index=near_prices.index)\n near_calc_strikes_df['price'] = (near_otm_puts_df['best_bid'] + near_otm_puts_df['best_ask']) / 2\n near_calc_strikes_df['price'] = near_calc_strikes_df.price.combine_first((near_otm_calls_df['best_bid'] + near_otm_calls_df['best_ask']) / 2)\n near_calc_strikes_df.at[k0_1] = (near_prices.loc[k0_1].call_price + near_prices.loc[k0_1].put_price) / 2\n near_calc_strikes_df = near_calc_strikes_df.dropna()\n\n next_calc_strikes_df = pd.DataFrame(index=next_prices.index)\n next_calc_strikes_df['price'] = (next_otm_puts_df['best_bid'] + next_otm_puts_df['best_ask']) / 2\n next_calc_strikes_df['price'] = next_calc_strikes_df.price.combine_first((next_otm_calls_df['best_bid'] + next_otm_calls_df['best_ask']) / 2)\n next_calc_strikes_df.at[k0_2] = (next_prices.loc[k0_2].call_price + next_prices.loc[k0_2].put_price) / 2\n next_calc_strikes_df = next_calc_strikes_df.dropna()\n\n near_sum = 0\n for i in range(len(near_calc_strikes_df)):\n row = near_calc_strikes_df.iloc[i]\n if i == 0:\n deltaKi = near_calc_strikes_df.iloc[i+1].name - row.name\n elif i == len(near_calc_strikes_df) - 1:\n deltaKi = row.name - near_calc_strikes_df.iloc[i-1].name\n else:\n deltaKi = (near_calc_strikes_df.iloc[i+1].name - near_calc_strikes_df.iloc[i-1].name) / 2\n\n near_sum += deltaKi/(row.name ** 2) * np.e**(R*t1) * row.price\n \n next_sum = 0\n for i in range(len(next_calc_strikes_df)):\n row = next_calc_strikes_df.iloc[i]\n if i == 0:\n deltaKi = next_calc_strikes_df.iloc[i+1].name - row.name\n elif i == len(next_calc_strikes_df) - 1:\n deltaKi = row.name - next_calc_strikes_df.iloc[i-1].name\n else:\n deltaKi = (next_calc_strikes_df.iloc[i+1].name - next_calc_strikes_df.iloc[i-1].name) / 2\n \n next_sum += deltaKi/(row.name ** 2) * np.e**(R*t2) * row.price\n \n sigma1 = ((2/t1) * near_sum) - (1/t1)*((f1/k0_1 - 1)**2)\n sigma2 = ((2/t2) * next_sum) - (1/t2)*((f2/k0_2 - 1)**2)\n\n VXBT = 100 * np.sqrt(((t1*sigma1)*((n2-n)/(n2-n1)) + (t2*sigma2)*((n-n1)/(n2-n1)))*(nY/n))\n\n omega = ((n2-nY)/(n2-n1))*n\n sigma1_a = sigma1 * (f1**-2)\n sigma2_a = sigma2 * (f2**-2)\n\n GVXBT = np.sqrt(omega*t1*sigma1 + (1-omega)*t2*sigma2)\n AVXBT = np.sqrt(omega*t1*sigma1_a + (1-omega)*t2*sigma2_a)\n \n return VXBT, GVXBT, AVXBT\n\ndef get_indices(maturity=7, rate=0, live=True, time=None, dfs=None):\n if live:\n now = datetime.now()\n near_expiry, next_expiry, near_datetime, next_datetime = get_near_next_terms(now)\n near_instruments = get_instruments_with_expiry(near_expiry)\n next_instruments = get_instruments_with_expiry(next_expiry)\n\n near_calls_df, near_puts_df, next_calls_df, next_puts_df = get_bids_asks(near_instruments, next_instruments)\n \n VXBT, GVXBT, AVXBT = calculate_indices(now, near_datetime, next_datetime, maturity, rate, near_calls_df, near_puts_df, next_calls_df, next_puts_df)\n\n else:\n near_expiry, next_expiry, near_datetime, next_datetime = get_near_next_terms(time)\n VXBT, GVXBT, AVXBT = calculate_indices(time, near_datetime, next_datetime, maturity, rate, dfs[0], dfs[1], dfs[2], dfs[3])\n \n return VXBT, GVXBT, AVXBT\n\n\nif __name__ == '__main__':\n print(get_indices())", "meta": {"hexsha": "12cc2001208170d19e293e93e984e3fe3ee7d06b", "size": 10878, "ext": "py", "lang": "Python", "max_stars_repo_path": "vix-implementation/vxbt_calc/vxbt_calc.py", "max_stars_repo_name": "mewmix/bitfear", "max_stars_repo_head_hexsha": "8fb5263a0d0b53f2f5cd063ec6e5de30bb42e4e6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-19T22:02:22.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-19T22:02:22.000Z", "max_issues_repo_path": "vix-implementation/vxbt_calc/vxbt_calc.py", "max_issues_repo_name": "mewmix/bitfear", "max_issues_repo_head_hexsha": "8fb5263a0d0b53f2f5cd063ec6e5de30bb42e4e6", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "vix-implementation/vxbt_calc/vxbt_calc.py", "max_forks_repo_name": "mewmix/bitfear", "max_forks_repo_head_hexsha": "8fb5263a0d0b53f2f5cd063ec6e5de30bb42e4e6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 47.0909090909, "max_line_length": 155, "alphanum_fraction": 0.6817429675, "include": true, "reason": "import numpy", "num_tokens": 3081, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5039061705290805, "lm_q2_score": 0.3923368301671084, "lm_q1q2_score": 0.1977009496470258}} {"text": "#!/usr/bin/env python3\n\nimport os\nimport re\nimport time\n\nimport click\nfrom netCDF4 import Dataset\nimport numpy as np\nimport numpy.ma as ma\nimport osr\n\nimport projections.geotools as geotools\nimport projections.utils as utils\n\nBINS = 52\n\ndef sum_layers(ds, idx, layers, out):\n out.fill(0)\n for l in layers:\n out += ds.variables[l][idx]\n return\n\ndef find_frac(values, tot, frac):\n frac.fill(1)\n ## FIXME: need np.clip() because pos - neg < 0\n frac -= np.clip(ma.where(values[-1] > 0, tot / values[-1], 0), 0, 1)\n #frac -= np.clip(tot / values[-1], 0, 1)\n return\n\ndef dorem(values, remove, frac):\n find_frac(values, remove, frac)\n values[1:-1] *= np.broadcast_to(frac, values[1:-1].shape)\n return\n\ndef to_year(scenario, idx):\n if scenario == 'historical':\n return idx + 850\n return idx + 2015\n\ndef asserts(state, idx, name, values, atol):\n assert np.all(values[0] <= 1.0 + atol), 'current > 1'\n assert np.all(values[0] >= 0.0 - atol), 'current < 0'\n secd = state.variables[name][idx]\n assert np.allclose(values[-1] - secd, 0, atol=atol)\n\ndef write_data(out, fnf, idx, values):\n out.variables['secdy%s' % fnf][idx, :, :] = values[0:30].sum(axis=0)\n out.variables['secdi%s' % fnf][idx, :, :] = values[30:50].sum(axis=0)\n out.variables['secdm%s' % fnf][idx, :, :] = values[50]\n\ndef write_bins(out, vname, values):\n # FIXME: verify masked values are written and read correctly.\n out.variables[vname][:] = values\n return values\n\ndef init_values(state, vname, start_index, mask):\n shape = state.variables[vname].shape\n values = ma.zeros((BINS, shape[1], shape[2]),\n dtype=state.variables[vname].dtype,\n fill_value=-9999)\n values.mask = np.broadcast_to(mask == 1.0, values.shape)\n values[-1] = state.variables[vname][start_index]\n values[-2] = state.variables[vname][start_index]\n return values\n\ndef roll_values(values):\n values[-3] += values[-2]\n values[-2] = values[0:-2].sum(axis=0)\n return np.roll(values, 1, 0)\n\ndef neg_re(fnf):\n return r'secd{fnf}_to_'.format(fnf=fnf)\n\ndef pos_re(fnf):\n return r'^(?!secd{fnf}).*_to_secd{fnf}$|prim{fnf}_harv$'.format(fnf=fnf)\n\n@click.command()\n@click.option('--scenario', type=click.Choice(utils.luh2_scenarios() +\n ('all', )),\n default='all',\n help='Which LUH2 scenario to run (default: all)')\n@click.option('--outdir', type=click.Path(file_okay=False),\n default='/out/luh2',\n help='Output directory (default: /out/luh2)')\n@click.option('--start-index', type=int, default=0,\n help='Start from given index skipping earlier years (default: 0)')\ndef doit(scenario, outdir, start_index=0):\n static = Dataset(os.path.join(utils.luh2_dir(), 'staticData_quarterdeg.nc'))\n icwtr = static.variables['icwtr'][:, :]\n atol = 5e-5\n\n variables = tuple([(x % fnf, 'f4', '1', -9999, 'time')\n for fnf in ('f', 'n')\n for x in ('secd%s%%s' % n for n in ('y', 'i', 'm'))] +\n [('bins%s' % fnf, 'f4', '1', -9999, 'bins')\n for fnf in ('f', 'n')])\n baselinef = None\n baselinen = None\n\n if scenario == 'all':\n # historical must be the first scenario processed\n scenarios = sorted(utils.luh2_scenarios())\n else:\n scenarios = [scenario]\n\n for scenario in scenarios:\n oname = os.path.join(outdir, 'secd-%s.nc' % scenario)\n tname = utils.luh2_transitions(scenario)\n sname = utils.luh2_states(scenario)\n if not (os.path.isfile(tname) and os.path.isfile(sname)):\n click.echo(\"skipping %s\" % scenario)\n continue\n click.echo('%s -> %s' % (scenario, oname))\n\n with Dataset(oname, 'w') as out:\n click.echo(sname)\n click.echo(tname)\n with Dataset(tname) as trans:\n with Dataset(sname) as state:\n _ = init_nc(out, state, variables)\n if scenario == 'historical':\n # Create a 3-D array to hold the last 50 years (plus 2)\n valuesf = init_values(state, 'secdf', start_index, icwtr)\n valuesn = init_values(state, 'secdn', start_index, icwtr)\n elif baselinef is None or baselinen is None:\n with Dataset(os.path.join(outdir, 'secd-historical.nc')) as hist:\n valuesf = hist.variables['binsf'][:]\n valuesn = hist.variables['binsn'][:]\n else:\n valuesf = baselinef.copy()\n valuesn = baselinen.copy()\n\n # Write initial data to output.\n valuesf[0].fill(0)\n valuesn[0].fill(0)\n write_data(out, 'f', start_index, valuesf)\n write_data(out, 'n', start_index, valuesn)\n\n remove = ma.empty_like(valuesf[0])\n frac = ma.empty_like(valuesf[0])\n posf = tuple(filter(lambda x: re.match(pos_re('f'), x),\n trans.variables.keys()))\n posn = tuple(filter(lambda x: re.match(pos_re('n'), x),\n trans.variables.keys()))\n negf = tuple(filter(lambda x: re.match(neg_re('f'), x),\n trans.variables.keys()))\n negn = tuple(filter(lambda x: re.match(neg_re('n'), x),\n trans.variables.keys()))\n click.echo(\" \" + ', '.join(posf))\n click.echo(\" \" + ', '.join(negf))\n click.echo(\" \" + ', '.join(posn))\n click.echo(\" \" + ', '.join(negn))\n for idx in range(start_index, trans.variables['time'].shape[0]):\n click.echo(\" year %d\" % to_year(scenario, idx))\n # Compute transitions from / to secondary.\n sum_layers(trans, idx, negf, remove)\n sum_layers(trans, idx, posf, valuesf[0])\n # Adjust secondary history\n dorem(valuesf, remove, frac)\n\n # Repeat for non-forested\n sum_layers(trans, idx, negn, remove)\n sum_layers(trans, idx, posn, valuesn[0])\n dorem(valuesn, remove, frac)\n\n # Check consistency of data.\n asserts(state, idx, 'secdf', valuesf, atol)\n asserts(state, idx, 'secdn', valuesn, atol)\n\n # Write data to output.\n write_data(out, 'f', idx + 1, valuesf)\n write_data(out, 'n', idx + 1, valuesn)\n\n # Rotate the array.\n valuesf = roll_values(valuesf)\n valuesn = roll_values(valuesn)\n\n if scenario == 'historical':\n baselinef = write_bins(out, 'binsf', valuesf).copy()\n baselinen = write_bins(out, 'binsn', valuesn).copy()\n start_index = 0\n\ndef init_nc(dst_ds, src_ds, variables):\n # Set attributes\n dst_ds.setncattr('Conventions', u'CF-1.5')\n dst_ds.setncattr('GDAL', u'GDAL 1.11.3, released 2015/09/16')\n\n # Create dimensions\n dst_ds.createDimension('time', None)\n dst_ds.createDimension('lat', len(src_ds.variables['lat']))\n dst_ds.createDimension('lon', len(src_ds.variables['lon']))\n dst_ds.createDimension('bins', BINS)\n\n # Create variables\n times = dst_ds.createVariable(\"time\", \"f8\", (\"time\"), zlib=True,\n least_significant_digit=3)\n latitudes = dst_ds.createVariable(\"lat\", \"f4\", (\"lat\"), zlib=True,\n least_significant_digit=3)\n longitudes = dst_ds.createVariable(\"lon\", \"f4\", (\"lon\"), zlib=True,\n least_significant_digit=3)\n crs = dst_ds.createVariable('crs', \"S1\", ())\n\n # Add metadata\n dst_ds.history = \"Created at \" + time.ctime(time.time())\n dst_ds.source = \"secd-dist.py\"\n latitudes.units = \"degrees_north\"\n latitudes.long_name = 'latitude'\n longitudes.units = \"degrees_east\"\n longitudes.long_name = \"longitude\"\n times.units = \"years since 850-01-01 00:00:00.0\"\n times.calendar = \"gregorian\"\n times.standard_name = \"time\"\n times.axis = 'T'\n\n # Assign data to variables\n latitudes[:] = src_ds.variables['lat'][:]\n longitudes[:] = src_ds.variables['lon'][:]\n times[:] = src_ds.variables['time'][:]\n\n srs = osr.SpatialReference()\n srs.ImportFromWkt(geotools.WGS84_WKT)\n src_trans = (-180.0, 0.25, 0.0, 90.0, 0.0, -0.25)\n crs.grid_mapping_name = 'latitude_longitude'\n crs.spatial_ref = srs.ExportToWkt()\n crs.GetTransform = ' '.join(tuple(map(str, src_trans)))\n # FIXME: Attribute getters don't work in python3 or GDAL2\n crs.longitude_of_prime_meridian = geotools.srs_get_prime_meridian(srs)\n crs.semi_major_axis = geotools.srs_get_semi_major(srs)\n crs.inverse_flattening = geotools.srs_get_inv_flattening(srs)\n\n out = {}\n for name, dtype, units, fill, dimension in variables:\n dst_data = dst_ds.createVariable(name, dtype,\n (dimension, \"lat\", \"lon\"), zlib=True,\n least_significant_digit=4,\n fill_value=fill)\n dst_data.units = units\n dst_data.grid_mapping = 'crs'\n out[name] = dst_data\n return out\n\nif __name__ == '__main__':\n#pylint: disable-msg=no-value-for-parameter\n doit()\n#pylint: enable-msg=no-value-for-parameter\n click.echo('done')\n", "meta": {"hexsha": "afb52387d7853a320b7c4f22b7c5ca69c14f40d4", "size": 9033, "ext": "py", "lang": "Python", "max_stars_repo_path": "secd-dist.py", "max_stars_repo_name": "ricardog/raster-project", "max_stars_repo_head_hexsha": "37d508ca329d31d4b1d21614371596f4c1bca526", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-02-23T14:26:17.000Z", "max_stars_repo_stars_event_max_datetime": "2018-02-23T14:26:17.000Z", "max_issues_repo_path": "secd-dist.py", "max_issues_repo_name": "NaturalHistoryMuseum/raster-project", "max_issues_repo_head_hexsha": "319a0f633de8cf2317eba5d82396036f01ce5262", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "secd-dist.py", "max_forks_repo_name": "NaturalHistoryMuseum/raster-project", "max_forks_repo_head_hexsha": "319a0f633de8cf2317eba5d82396036f01ce5262", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2017-10-11T15:49:18.000Z", "max_forks_repo_forks_event_max_datetime": "2017-10-11T15:49:18.000Z", "avg_line_length": 36.4233870968, "max_line_length": 80, "alphanum_fraction": 0.5990257943, "include": true, "reason": "import numpy", "num_tokens": 2500, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5039061705290805, "lm_q2_score": 0.39233683016710835, "lm_q1q2_score": 0.19770094964702578}} {"text": "# This module needs: numpy, matplotlib, scipy, ase, spglib\nimport numpy\nfrom futile.Utils import write as safe_print\n\nAU_eV = 27.21138386\n\n\ndef get_ev(ev, keys=None, ikpt=1):\n \"\"\"Get the correct list of the energies for this eigenvalue.\"\"\"\n res = False\n if keys is None:\n ener = ev.get('e')\n spin = ev.get('s')\n kpt = ev.get('k')\n if not kpt and ikpt == 1:\n kpt = True\n elif kpt and kpt != ikpt:\n kpt = False\n if ener and (spin == 1 or not spin):\n if kpt:\n res = [ener]\n elif ener and spin == -1:\n if kpt:\n res = [None, ener]\n else:\n for k in keys:\n if k in ev:\n res = ev[k]\n if not isinstance(res, list): # type(res) != type([]):\n res = [res]\n break\n return res\n\n\ndef astruct_to_cell(astruct):\n \"\"\"\n Convert the astruct information as parsed from the module Logfiles into\n the cell structure as needed from spglib\n \"\"\"\n import numpy\n celltmp = [a if a != float('inf') else 1.0 for a in astruct['cell']]\n lattice = numpy.diag(celltmp)\n pos = [[a/b if b != float('inf') else 0.0\n for a, b in zip(list(at.values())[0], celltmp)]\n for at in astruct['positions']]\n atoms = [list(at.keys())[0] for at in astruct['positions']]\n ianames, iatype = numpy.unique(atoms, return_inverse=True)\n return (lattice, pos, iatype)\n\n\nclass BandArray(numpy.ndarray):\n \"\"\"\n Defines the array of data for one band. It is a dictionary which contains\n a numpy array for both spin channels.\n \"\"\"\n def __new__(cls, *args, **kwargs): # logdata,ikpt=0,kpt=(0.0,0.0,0.0):\n \"Takes the data from the logfile and convert it\"\n datain = kwargs.get(\"data\", None)\n if datain is not None:\n evs = datain\n shape0 = len(evs)\n norbs = list(map(len, evs))\n if len(norbs) == 1:\n norbs = [norbs[0], 0]\n else:\n evs = [[], []]\n logdata = kwargs.get(\"logdata\", args[0])\n ikpt = kwargs.get(\"ikpt\", 1 if len(args) < 2 else args[1])\n # Ugly patch to detect proper k point in Davidson...\n prev_vrt = True\n cur_ikpt = 0\n # End of ugly patch\n for ev in logdata:\n occ = get_ev(ev, ['e_occ', 'e_occupied'], ikpt=ikpt)\n vrt = get_ev(ev, ['e_vrt', 'e_virt'], ikpt=ikpt)\n eigen = occ or vrt\n # Ugly patch to detect proper k point in Davidson...\n if occ and prev_vrt:\n cur_ikpt += 1\n prev_vrt = vrt\n if eigen and cur_ikpt != ikpt:\n continue\n # End of ugly patch\n if not eigen:\n eigen = get_ev(ev, ikpt=ikpt)\n if not eigen:\n continue\n for i, e in enumerate(eigen):\n if e:\n evs[i].append(e)\n shape0 = 2 if len(evs[1]) > 0 else 1\n norbs = list(map(len, evs))\n data = numpy.ndarray.__new__(cls, shape=(shape0, max(norbs)),\n dtype=numpy.float)\n data.fill(numpy.nan)\n data[0, :len(evs[0])] = evs[0]\n if norbs[1] > 0:\n data[1, :len(evs[1])] = evs[1]\n data.info = norbs # (map(len,evs))\n return data\n\n def __init__(self, *args, **kwargs):\n ikpt = kwargs.get(\"ikpt\", 1 if len(args) < 2 else args[1])\n kpt = kwargs.get(\"kpt\", (0., 0., 0.) if len(args) < 3 else args[2])\n kwgt = kwargs.get('kwgt', 1.0)\n self.set_kpt(ikpt, kpt, kwgt)\n\n def set_kpt(self, ikpt, kpt, kwgt=1.0):\n if not isinstance(ikpt, int):\n raise TypeError('ikpt should be a integer')\n if len(kpt) != 3:\n raise TypeError('kpt should be a object of len 3')\n self.ikpt = ikpt\n self.kpt = kpt\n self.kwgt = kwgt\n\n def __add__(self, b):\n if hasattr(b, 'kpt') and (b.kpt != self.kpt):\n raise ValueError('cannot sum BandArray with different kpoints')\n if hasattr(b, 'kwgt') and (b.kwgt != self.kwgt):\n raise ValueError('cannot sum BandArray with different kweights')\n c = super(type(self), self).__add__(b)\n return BandArray(data=c, ikpt=self.ikpt, kpt=self.kpt, kwgt=self.kwgt)\n\n\nclass BZPath():\n \"\"\"\n Defines a set of points which are associated to a path in the reduced\n Brillouin Zone.\n \"\"\"\n\n def __init__(self, lattice, path, special_points, npts=50):\n import ase.dft.kpoints as ase\n self.special_points = special_points\n path_tmp = []\n self.symbols = []\n # construct the path\n for p in path:\n if isinstance(p, str):\n # then this is a special point\n path_tmp.append(self.special_points[p])\n self.symbols.append(p.replace('G', '$\\\\Gamma$'))\n else:\n path_tmp.append(list(p.values())[0])\n self.symbols.append(list(p.keys())[0])\n self.path, self.xaxis, self.xlabel = ase.get_bandpath(\n path_tmp, lattice, npts)\n\n\nclass BrillouinZone():\n def __init__(self, astruct, mesh, evals, fermi_energy):\n import spglib\n import numpy\n cell = astruct_to_cell(astruct)\n self.lattice = cell[0]\n # celltmp=[ a if a!=float('inf') else 1.0 for a in astruct['cell']]\n # self.lattice=numpy.diag(celltmp)\n # print 'lattice',self.lattice\n # pos=[[ a/b if b!=float('inf') else 0.0\n # for a,b in zip(at.values()[0], celltmp)]\n # for at in astruct['positions']]\n # atoms=[ at.keys()[0] for at in astruct['positions']]\n # ianames,iatype=numpy.unique(atoms,return_inverse=True) #[1,]*4+[2,]*4\n # we should write a function for the iatype\n # print 'iatype', iatype\n # cell=(self.lattice,pos,iatype)\n safe_print('spacegroup', spglib.get_spacegroup(cell, symprec=1e-5))\n # then define the pathes and special points\n import ase.dft.kpoints as ase\n # we should adapt the 'cubic'\n cell_tmp = astruct['cell']\n # print 'cell',\n # cell_tmp,numpy.allclose(cell_tmp,[cell_tmp[0],]*len(cell_tmp))\n if numpy.allclose(cell_tmp, [cell_tmp[0], ]*len(cell_tmp)):\n lattice_string = 'cubic'\n else:\n lattice_string = 'orthorhombic'\n safe_print('Lattice found:', lattice_string)\n self.special_points = ase.get_special_points(\n lattice_string, self.lattice, eps=0.0001)\n self.special_paths = ase.parse_path_string(\n ase.special_paths[lattice_string])\n self.fermi_energy = fermi_energy\n # dataset = spglib.get_symmetry_dataset(cell, symprec=1e-3)\n # print dataset\n # the shift has also to be put if present\n mapping, grid = spglib.get_ir_reciprocal_mesh(\n mesh, cell, is_shift=[0, 0, 0])\n lookup = []\n for ikpt in numpy.unique(mapping):\n ltmp = []\n for ind, (m, g) in enumerate(zip(mapping, grid)):\n if m == ikpt:\n ltmp.append((g, ind))\n lookup.append(ltmp)\n safe_print('irreductible k-points', len(lookup))\n # print 'mapping',mapping\n # print 'grid',len(grid),numpy.max(grid)\n coords = numpy.array(grid, dtype=numpy.float)/mesh\n # print 'coords',coords\n # print 'shape',coords.shape\n # print grid #[ x+mesh[0]*y+mesh[0]*mesh[1]*z for x,y,z in grid]\n # brillouin zone\n kp = numpy.array([k.kpt for k in evals])\n ourkpt = numpy.rint(kp*(numpy.array(mesh))).astype(int)\n # print ourkpt\n bz = numpy.ndarray((coords.shape[0], evals[0].size), dtype=float)\n # print bz\n # shift = (numpy.array(mesh)-1)/2\n # print 'shift',shift\n for ik in lookup:\n irrk = None\n for orbs, bzk in zip(evals, ourkpt):\n for (kt, ind) in ik:\n if (bzk == kt).all():\n irrk = orbs\n # print 'hello',orbs.kpt,kt\n break\n if irrk is not None:\n break\n if irrk is None:\n safe_print('error in ik', ik)\n safe_print('our', ourkpt)\n safe_print('spglib', grid)\n safe_print('mapping', mapping)\n for (kt, ind) in ik:\n # r=kt+shift\n # ind=numpy.argwhere([(g==kt).all() for g in grid])\n # print 'ik',kt,r,ind\n # print irrk.shape, bz.shape\n # bz[r[0],r[1],r[2],:]=irrk.reshape(irrk.size)\n bz[ind, :] = irrk.reshape(irrk.size)\n # duplicate coordinates for the interpolation\n bztmp = bz # .reshape((mesh[0]*mesh[1]*mesh[2], -1))\n # print bztmp\n ndup = 7\n duplicates = [[-1, 0, 0], [1, 0, 0], [0, -1, 0],\n [0, 1, 0], [0, 0, -1], [0, 0, 1]]\n bztot = numpy.ndarray((ndup, bztmp.shape[0], bztmp.shape[1]))\n bztot[0, :, :] = bztmp\n ctot = numpy.ndarray((ndup, coords.shape[0], coords.shape[1]))\n ctot[0, :, :] = coords\n for i, sh in enumerate(duplicates):\n bztot[i+1, :, :] = bztmp\n ctot[i+1, :, :] = coords+sh\n # print 'coors',coords,coords+[1.0,0,0]\n bztot = bztot.reshape((ndup*bztmp.shape[0], -1))\n ctot = ctot.reshape((ndup*coords.shape[0], -1))\n import scipy.interpolate.interpnd as interpnd\n self.interpolator = interpnd.LinearNDInterpolator(ctot, bztot)\n # sanity check of the interpolation\n sanity = 0.0\n for kpt in evals:\n diff = numpy.ravel(numpy.ravel(\n kpt)-numpy.ravel(self.interpolator([kpt.kpt])))\n sanity = max(sanity, numpy.dot(diff, diff))\n print('Interpolation bias', sanity)\n\n def conversion_factor(self, units):\n if units == 'AU':\n fac = 1.0\n elif units == 'eV':\n fac = AU_eV\n else:\n raise ValueError('Unrecognized units ('+units+')')\n return fac\n\n def plot(self, path=None, npts=50, units='eV'):\n if path is None:\n # ppath=BZPath(self.lattice,self.special_paths[0]+['G',],self.special_points,npts)\n ppath = BZPath(\n self.lattice, self.special_paths[0], self.special_points, npts)\n else:\n ppath = path\n toto = self.interpolator(ppath.path)\n import matplotlib.pyplot as plt\n # print toto.min(),toto.max()\n for b in toto.transpose():\n plt.plot(ppath.xaxis, [ib * self.conversion_factor(units)\n for ib in b]) # , 'b-')\n\n plt.axhline(self.conversion_factor(units)*self.fermi_energy, color='k',\n linestyle='--')\n for p in ppath.xlabel:\n plt.axvline(p, color='k', linestyle='-')\n plt.xticks(ppath.xlabel, ppath.symbols)\n\n # if units == 'eV':\n # plt.ylabel('Energy [eV]', fontsize=18)\n # else:\n # plt.ylabel('Energy [Ha]', fontsize=18)\n\n plt.show()\n", "meta": {"hexsha": "6892b3675564e36b4a7b688ad04012296d8ce58c", "size": 11367, "ext": "py", "lang": "Python", "max_stars_repo_path": "aiida_bigdft/PyBigDFT/BigDFT/BZ.py", "max_stars_repo_name": "adegomme/aiida-bigdft-plugin", "max_stars_repo_head_hexsha": "dfd17f166a8cd547d3e581c7c3c9f4eb32bd2aab", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-06-10T02:45:59.000Z", "max_stars_repo_stars_event_max_datetime": "2020-08-05T18:55:05.000Z", "max_issues_repo_path": "aiida_bigdft/PyBigDFT/BigDFT/BZ.py", "max_issues_repo_name": "BigDFT-group/aiida-bigdft-plugin", "max_issues_repo_head_hexsha": "5a0091fde3784d699b1791a05d8ad4fa4bb3c1fa", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 6, "max_issues_repo_issues_event_min_datetime": "2019-12-15T19:35:34.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-07T15:32:18.000Z", "max_forks_repo_path": "aiida_bigdft/PyBigDFT/BigDFT/BZ.py", "max_forks_repo_name": "adegomme/aiida-bigdft-plugin", "max_forks_repo_head_hexsha": "dfd17f166a8cd547d3e581c7c3c9f4eb32bd2aab", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-08-05T18:55:21.000Z", "max_forks_repo_forks_event_max_datetime": "2020-08-05T18:55:21.000Z", "avg_line_length": 38.6632653061, "max_line_length": 94, "alphanum_fraction": 0.5252925134, "include": true, "reason": "import numpy,import scipy", "num_tokens": 3073, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.523420348936324, "lm_q2_score": 0.37754066879814546, "lm_q1q2_score": 0.19761246859997844}} {"text": "\"\"\"Code for BBPSSW entanglement purification.\n\nThis module defines code to support the BBPSSW protocol for entanglement purification.\nSuccess results are pre-determined based on network parameters.\nAlso defined is the message type used by the BBPSSW code.\n\"\"\"\n\nfrom enum import Enum, auto\nfrom typing import List, TYPE_CHECKING\nfrom functools import lru_cache\n\nfrom numpy.random import random\n\nif TYPE_CHECKING:\n from ..components.memory import Memory\n from ..topology.node import Node\n\nfrom ..message import Message\nfrom .entanglement_protocol import EntanglementProtocol\nfrom ..utils import log\nfrom ..components.circuit import Circuit\n\n\nclass BBPSSWMsgType(Enum):\n \"\"\"Defines possible message types for entanglement purification\"\"\"\n\n PURIFICATION_RES = auto()\n\n\nclass BBPSSWMessage(Message):\n \"\"\"Message used by entanglement purification protocols.\n\n This message contains all information passed between purification protocol instances.\n\n Attributes:\n msg_type (BBPSSWMsgType): defines the message type.\n receiver (str): name of destination protocol instance.\n \"\"\"\n\n def __init__(self, msg_type: BBPSSWMsgType, receiver: str, **kwargs):\n Message.__init__(self, msg_type, receiver)\n if self.msg_type is BBPSSWMsgType.PURIFICATION_RES:\n self.meas_res = kwargs['meas_res']\n else:\n raise Exception(\"BBPSSW protocol create unknown type of message: %s\" % str(msg_type))\n\n\nclass BBPSSW(EntanglementProtocol):\n \"\"\"Purification protocol instance.\n\n This class provides an implementation of the BBPSSW purification protocol.\n It should be instantiated on a quantum router node.\n\n Variables:\n BBPSSW.circuit (Circuit): circuit that purifies entangled memories.\n\n Attributes:\n own (QuantumRouter): node that protocol instance is attached to.\n name (str): label for protocol instance.\n kept_memo: memory to be purified by the protocol (should already be entangled).\n meas_memo: memory to measure and discart (should already be entangled).\n another (BBPSSW): pointer of BBPSSW on another side (may be removed in the future).\n meas_res (int): measurement result from circuit.\n \"\"\"\n\n circuit = Circuit(2)\n circuit.cx(0, 1)\n circuit.measure(1)\n\n def __init__(self, own: \"Node\", name: str, kept_memo: \"Memory\", meas_memo: \"Memory\"):\n \"\"\"Constructor for purification protocol.\n\n Args:\n own (Node): node protocol is attached to.\n name (str): name of protocol instance.\n kept_memo (Memory): memory to have fidelity improved.\n meas_memo (Memory): memory to measure and discard.\n \"\"\"\n\n assert kept_memo != meas_memo\n EntanglementProtocol.__init__(self, own, name)\n self.memories = [kept_memo, meas_memo]\n self.kept_memo = kept_memo\n self.meas_memo = meas_memo\n self.another = None\n self.meas_res = None\n if self.meas_memo is None:\n self.memories.pop()\n\n def is_ready(self) -> bool:\n return self.another is not None\n\n def set_others(self, another: \"BBPSSW\") -> None:\n \"\"\"Method to set other entanglement protocol instance.\n\n Args:\n another (BBPSSW): other purification protocol instance.\n \"\"\"\n\n self.another = another\n\n def start(self) -> None:\n \"\"\"Method to start entanglement purification.\n\n Run the circuit below on two pairs of entangled memories on both sides of protocol.\n\n o -------(x)----------| M |\n . |\n . o ----.----------------\n . .\n . .\n . o\n .\n o\n\n The overall circuit is shown below:\n\n o -------(x)----------| M |\n . |\n . o ----.----------------\n . .\n . .\n . o ----.----------------\n . |\n o -------(x)----------| M |\n\n Side Effects:\n May update parameters of kept memory.\n Will send message to other protocol instance.\n \"\"\"\n\n log.logger.info(self.own.name + \" protocol start with partner {}\".format(self.another.own.name))\n\n assert self.another is not None, \"other protocol is not set; please use set_others function to set it.\"\n kept_memo_ent = self.kept_memo.entangled_memory[\"node_id\"]\n meas_memo_ent = self.meas_memo.entangled_memory[\"node_id\"]\n assert kept_memo_ent == meas_memo_ent, \"mismatch of entangled memories {}, {} on node {}\".format(kept_memo_ent, meas_memo_ent, self.own.name)\n assert self.kept_memo.fidelity == self.meas_memo.fidelity > 0.5\n\n self.meas_res = self.own.timeline.quantum_manager.run_circuit(self.circuit, [self.kept_memo.qstate_key,\n self.meas_memo.qstate_key])\n self.meas_res = self.meas_res[self.meas_memo.qstate_key]\n dst = self.kept_memo.entangled_memory[\"node_id\"]\n\n message = BBPSSWMessage(BBPSSWMsgType.PURIFICATION_RES, self.another.name, meas_res=self.meas_res)\n self.own.send_message(dst, message)\n\n def received_message(self, src: str, msg: BBPSSWMessage) -> None:\n \"\"\"Method to receive messages.\n\n Args:\n src (str): name of node that sent the message.\n msg (BBPSSW message): message received.\n\n Side Effects:\n Will call `update_resource_manager` method.\n \"\"\"\n\n log.logger.info(self.own.name + \" received result message, succeeded: {}\".format(self.meas_res == msg.meas_res))\n assert src == self.another.own.name\n self.update_resource_manager(self.meas_memo, \"RAW\")\n if self.meas_res == msg.meas_res:\n self.kept_memo.fidelity = self.improved_fidelity(self.kept_memo.fidelity)\n self.update_resource_manager(self.kept_memo, state=\"ENTANGLED\")\n else:\n self.update_resource_manager(self.kept_memo, state=\"RAW\")\n\n def memory_expire(self, memory: \"Memory\") -> None:\n \"\"\"Method to receive memory expiration events.\n\n Args:\n memory (Memory): memory that has expired.\n\n Side Effects:\n Will call `update_resource_manager` method.\n \"\"\"\n\n assert memory in self.memories\n if self.meas_memo is None:\n self.update_resource_manager(memory, \"RAW\")\n else:\n for memory in self.memories:\n self.update_resource_manager(memory, \"RAW\")\n\n def release(self) -> None:\n pass\n\n @staticmethod\n @lru_cache(maxsize=128)\n def success_probability(F: float) -> float:\n \"\"\"Method to calculate probability of purification success.\n \n Formula comes from Dur and Briegel (2007) page 14.\n\n Args:\n F (float): fidelity of entanglement.\n \"\"\"\n\n return F ** 2 + 2 * F * (1 - F) / 3 + 5 * ((1 - F) / 3) ** 2\n\n @staticmethod\n @lru_cache(maxsize=128)\n def improved_fidelity(F: float) -> float:\n \"\"\"Method to calculate fidelity after purification.\n \n Formula comes from Dur and Briegel (2007) formula (18) page 14.\n\n Args:\n F (float): fidelity of entanglement.\n \"\"\"\n\n return (F ** 2 + ((1 - F) / 3) ** 2) / (F ** 2 + 2 * F * (1 - F) / 3 + 5 * ((1 - F) / 3) ** 2)\n\n", "meta": {"hexsha": "d362fa943569f2640480c60cb9e75c485016ef29", "size": 7355, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/entanglement_management/purification.py", "max_stars_repo_name": "alexk101/SeQUeNCe", "max_stars_repo_head_hexsha": "3ae6a9c0f787e65b905fd28de29303af0c9420c1", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 35, "max_stars_repo_stars_event_min_datetime": "2020-09-11T20:06:17.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-09T04:01:17.000Z", "max_issues_repo_path": "src/entanglement_management/purification.py", "max_issues_repo_name": "alexk101/SeQUeNCe", "max_issues_repo_head_hexsha": "3ae6a9c0f787e65b905fd28de29303af0c9420c1", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 62, "max_issues_repo_issues_event_min_datetime": "2020-09-03T16:49:06.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-25T16:08:48.000Z", "max_forks_repo_path": "src/entanglement_management/purification.py", "max_forks_repo_name": "alexk101/SeQUeNCe", "max_forks_repo_head_hexsha": "3ae6a9c0f787e65b905fd28de29303af0c9420c1", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 15, "max_forks_repo_forks_event_min_datetime": "2020-09-11T20:06:26.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-03T14:31:31.000Z", "avg_line_length": 34.3691588785, "max_line_length": 149, "alphanum_fraction": 0.6179469748, "include": true, "reason": "from numpy", "num_tokens": 1734, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.523420348936324, "lm_q2_score": 0.3775406687981454, "lm_q1q2_score": 0.1976124685999784}} {"text": "\"\"\"plot_utils module for plotting SEDs.\"\"\"\n\nimport copy\nimport glob\nfrom random import choice\n\nimport matplotlib.pyplot as plt\nimport matplotlib.ticker as ticker\nimport pandas as pd\nimport numpy as np\nfrom astropy import units as u\nfrom astropy.io import fits\nfrom astropy.table import Table\nfrom extinction import apply\nfrom isochrones.interp import DFInterpolator\nfrom matplotlib.collections import LineCollection\nfrom matplotlib.gridspec import GridSpec\nfrom PyAstronomy import pyasl\nfrom scipy.optimize import curve_fit\nfrom scipy.stats import gaussian_kde\n\nimport corner\nfrom dynesty import plotting as dyplot\n\nfrom .config import filesdir, gridsdir, modelsdir\nfrom .isochrone import get_isochrone\nfrom .phot_utils import *\nfrom .sed_library import *\nfrom .utils import *\n\n\nclass SEDPlotter:\n \"\"\"Artist class for all things SED.\n\n Parameters\n ----------\n input_files : str\n Directory containing the code's output files.\n out_folder : type\n Directory where to put the output plots.\n pdf : type\n Set to True to output plots in pdf.\n png : type\n Set to True to output plots in png.\n model : type\n Set to override the SED model that's going to be plotted.\n Possible values are:\n - Phoenix\n - BTSettl\n - NextGen\n - CK04 (Castelli & Kurucz 2004)\n - Kurucz (Kurucz 1993)\n\n Examples\n -------\n Examples should be written in doctest format, and\n should illustrate how to use the function/class.\n >>>\n\n Attributes\n ----------\n chain_out : str\n Output directory for chain plot.\n like_out : str\n Output directory for likelihood plot.\n post_out : str\n Output directory for posteriors plot.\n moddir : type\n Directory wheere the SED models are located.\n out : dict\n SED fitting routine output.\n engine : str\n Selected fitting engine.\n star : Star\n The fitted Star object.\n coordinator : array_like\n Array coordinating fixed parameters.\n fixed : array_like\n Array coordinating fixed parameters.\n norm : bool\n norm is set to True if a normalization constant is fitted instead of\n radius + distance.\n grid : str\n Selected model grid.\n av_law : function\n Exticntion law chosen for the fit.\n order : array_like\n Array coordinating parameter order.\n interpolator : function\n Interpolator function.\n theta : array_like\n `Best fit` parameter vector\n\n \"\"\"\n\n __wav_file = 'PHOENIXv2/WAVE_PHOENIX-ACES-AGSS-COND-2011.fits'\n\n def __init__(self, input_files, out_folder, pdf=False,\n model=None, settings=None, method='averaged',\n save_model=False):\n \"\"\"See class docstring.\"\"\"\n print('\\nInitializing plotter.\\n')\n # General setup\n self.pdf = pdf\n png = True if not pdf else False\n self.png = png\n self.out_folder = out_folder\n self.bma = False\n self.method = method\n self.save = save_model\n\n traces = f'{out_folder}/traces'\n histograms = f'{out_folder}/histograms'\n self.traces_out = traces\n self.hist_out = histograms\n self.moddir = modelsdir\n self.settings_dir = settings\n\n # Read output files.\n if input_files != 'raw':\n out = pickle.load(open(input_files, 'rb'))\n self.out = out\n self.engine = out['engine']\n self.star = out['star']\n self.coordinator = out['coordinator']\n self.fixed = out['fixed']\n self.norm = out['norm']\n if model is None:\n if self.engine != 'Bayesian Model Averaging':\n self.grid = out['model_grid']\n else:\n self.bma = True\n zs = np.array([out['lnZ'][key]\n for key in out['lnZ'].keys()])\n keys = np.array([key for key in out['lnZ'].keys()])\n grid = keys[np.argmax(zs)]\n self.grid = grid\n else:\n self.grid = model\n self.av_law = out['av_law']\n\n # Create target folders\n create_dir(out_folder)\n if self.engine != 'Bayesian Model Averaging':\n create_dir(traces)\n create_dir(histograms)\n\n self.star.load_grid(self.grid)\n\n if not self.norm:\n self.order = np.array(\n [\n 'teff', 'logg', 'z',\n 'dist', 'rad', 'Av',\n ]\n )\n else:\n self.order = np.array(\n ['teff', 'logg', 'z', 'norm', 'Av'])\n\n mask = self.star.filter_mask\n flxs = self.star.flux[mask]\n errs = self.star.flux_er[mask]\n filters = self.star.filter_names[mask]\n wave = self.star.wave[mask]\n for filt, flx, flx_e in zip(filters, flxs, errs):\n p_ = get_noise_name(filt) + '_noise'\n self.order = np.append(self.order, p_)\n\n if self.grid.lower() == 'phoenix':\n with open(gridsdir + '/Phoenixv2_DF.pkl', 'rb') as intp:\n self.interpolator = DFInterpolator(pd.read_pickle(intp))\n if self.grid.lower() == 'btsettl':\n with open(gridsdir + '/BTSettl_DF.pkl', 'rb') as intp:\n self.interpolator = DFInterpolator(pd.read_pickle(intp))\n if self.grid.lower() == 'btnextgen':\n with open(gridsdir + '/BTNextGen_DF.pkl', 'rb') as intp:\n self.interpolator = DFInterpolator(pd.read_pickle(intp))\n if self.grid.lower() == 'btcond':\n with open(gridsdir + '/BTCond_DF.pkl', 'rb') as intp:\n self.interpolator = DFInterpolator(pd.read_pickle(intp))\n if self.grid.lower() == 'ck04':\n with open(gridsdir + '/CK04_DF.pkl', 'rb') as intp:\n self.interpolator = DFInterpolator(pd.read_pickle(intp))\n if self.grid.lower() == 'kurucz':\n with open(gridsdir + '/Kurucz_DF.pkl', 'rb') as intp:\n self.interpolator = DFInterpolator(pd.read_pickle(intp))\n if self.grid.lower() == 'coelho':\n with open(gridsdir + '/Coelho_DF.pkl', 'rb') as intp:\n self.interpolator = DFInterpolator(pd.read_pickle(intp))\n\n # Get best fit parameters.\n theta_samples = np.zeros(self.order.shape[0])\n theta_average = np.zeros(self.order.shape[0])\n for i, param in enumerate(self.order):\n if param != 'inflation':\n theta_samples[i] = out['best_fit_samples'][param]\n theta_average[i] = out['best_fit_averaged'][param]\n\n # Calculate best fit model.\n model_samples = model_grid(theta_samples, filters, wave,\n self.interpolator, self.norm,\n self.av_law)\n model_average = model_grid(theta_average, filters, wave,\n self.interpolator, self.norm,\n self.av_law)\n if method == 'averaged':\n self.theta = theta_average\n self.model = model_average\n elif method == 'samples':\n self.theta = theta_samples\n self.model = model_samples\n\n # Get archival fluxes.\n self.__extract_info()\n else:\n self.star = None\n\n # Setup plots.\n self.__read_config()\n print('\\nPlotter initialized.\\n')\n\n def __extract_info(self):\n self.flux = []\n self.flux_er = []\n self.wave = []\n self.bandpass = []\n\n for i, f in zip(self.star.used_filters, self.star.flux):\n if i:\n self.flux.append(f)\n for i, e in zip(self.star.used_filters, self.star.flux_er):\n if i:\n self.flux_er.append(e)\n for i, w in zip(self.star.used_filters, self.star.wave):\n if i:\n self.wave.append(w)\n for i, bp in zip(self.star.used_filters, self.star.bandpass):\n if i:\n self.bandpass.append(bp)\n\n self.flux = np.array(self.flux)\n self.flux_er = np.array(self.flux_er)\n self.wave = np.array(self.wave)\n self.bandpass = np.array(self.bandpass).T\n\n def plot_SED_no_model(self, s=None):\n \"\"\"Plot raw photometry.\"\"\"\n if self.star is None:\n self.star = s\n self.__extract_info()\n # Get plot ylims.\n ymin = (self.flux * self.wave).min()\n ymax = (self.flux * self.wave).max()\n\n f, ax = plt.subplots(figsize=self.figsize)\n\n # Model plot\n used_f = self.star.filter_names[self.star.filter_mask]\n colors = np.array([\n 'tomato', 'indianred', 'tab:red',\n 'salmon', 'coral',\n 'mediumorchid', 'mediumslateblue', 'tab:blue',\n 'darkslateblue', 'darkblue',\n 'olivedrab', 'yellowgreen', 'greenyellow', 'yellow',\n 'orangered', 'chocolate', 'khaki',\n 'limegreen', 'darkgreen', 'lime', 'seagreen', 'lawngreen', 'green',\n 'aquamarine', 'turquoise', 'lightseagreen', 'teal', 'cadetblue',\n 'firebrick', 'darkred',\n 'blueviolet', 'darkviolet',\n 'midnightblue', 'blue',\n 'deeppink', 'fuchsia', 'mediumslateblue'\n ])\n\n for c, w, fl, fe, bp, fi in zip(\n colors[self.star.filter_mask],\n self.wave, self.flux, self.flux_er,\n self.bandpass, used_f):\n ax.errorbar(w, fl * w,\n xerr=bp, yerr=fe,\n fmt='',\n ecolor=c,\n marker=None)\n\n ax.scatter(w, fl * w,\n edgecolors='black',\n marker=self.marker,\n c=c,\n s=self.scatter_size,\n alpha=self.scatter_alpha, label=fi)\n\n ax.set_ylim([ymin * .8, ymax * 1.25])\n ax.set_xscale('log', nonposx='clip')\n ax.set_yscale('log', nonposy='clip')\n ax.set_ylabel(r'$\\lambda$F$_\\lambda$ (erg cm$^{-2}$s$^{-1}$)',\n fontsize=self.fontsize,\n fontname=self.fontname\n )\n ax.legend(loc=0)\n\n ax.tick_params(\n axis='both', which='major',\n labelsize=self.tick_labelsize\n )\n ax.set_xticks(np.linspace(1, 10, 10))\n ax.get_xaxis().set_major_formatter(ticker.ScalarFormatter())\n ax.set_xlim([0.1, 6])\n\n for tick in ax.get_yticklabels():\n tick.set_fontname(self.fontname)\n\n if self.pdf:\n plt.savefig(self.out_folder + '/SED_no_model.pdf',\n bbox_inches='tight')\n if self.png:\n plt.savefig(self.out_folder + '/SED_no_model.png',\n bbox_inches='tight')\n pass\n\n def plot_SED(self, method='average'):\n \"\"\"Create the plot of the SED.\"\"\"\n if self.moddir is None:\n print('Models directory not provided, skipping SED plot.')\n return\n print('Plotting SED')\n # Get plot ylims.\n ymin = (self.flux * self.wave).min()\n ymax = (self.flux * self.wave).max()\n\n n_filt = self.star.used_filters.sum()\n n_pars = int(len(self.theta) - n_filt)\n\n # Get models residuals\n mask = self.star.filter_mask\n mags = self.star.mags[mask]\n flxs = self.star.flux[mask]\n errs = self.star.flux_er[mask]\n filters = self.star.filter_names[mask]\n wave = self.star.wave[mask]\n\n for i, th in enumerate(self.theta[n_pars:]):\n mag = mags[i]\n filt = filters[i]\n _, er = mag_to_flux(mag, th, filt)\n self.theta[n_pars + i] = er\n\n residuals, errors = get_residuals(\n self.theta, flxs, errs, wave, filters, self.interpolator, self.norm,\n self.av_law)\n\n norm_res = residuals / errors\n\n # Create plot layout\n\n f = plt.figure(figsize=self.figsize)\n gs = GridSpec(2, 1, height_ratios=[3, 0.5], hspace=0.05)\n\n ax = f.add_subplot(gs[0])\n ax_r = f.add_subplot(gs[1])\n\n self.SED(ax)\n\n # Model plot\n ax.errorbar(self.wave, self.flux * self.wave,\n xerr=self.bandpass, yerr=errors,\n fmt=',',\n ecolor=self.error_color,\n zorder=0,\n marker=None)\n\n ax.scatter(self.wave, self.flux * self.wave,\n edgecolors='black',\n marker=self.marker,\n c=self.marker_colors,\n s=self.scatter_size, zorder=1,\n alpha=self.scatter_alpha)\n\n ax.scatter(self.wave, self.model * self.wave,\n marker=self.marker_model,\n edgecolors=self.marker_colors_model,\n s=self.scatter_size,\n facecolor='', zorder=3,\n lw=3)\n\n # Residual plot\n ax_r.axhline(y=0, lw=2, ls='--', c='k', alpha=.7)\n\n ax_r.errorbar(self.wave, np.zeros(self.wave.shape[0]),\n xerr=self.bandpass, yerr=self.flux_er,\n fmt=',',\n ecolor=self.error_color,\n marker=None)\n ax_r.scatter(self.wave, np.zeros(self.wave.shape[0]),\n edgecolors='black',\n marker=self.marker,\n c=self.marker_colors,\n s=self.scatter_size,\n alpha=self.scatter_alpha)\n ax_r.scatter(self.wave, norm_res,\n marker=self.marker_model,\n edgecolors=self.marker_colors_model,\n s=self.scatter_size,\n facecolor='',\n lw=3,\n zorder=10)\n\n # Formatting\n res_std = norm_res.std()\n ax.set_ylim([ymin * 0.8, ymax * 1.2])\n # ax_r.set_ylim([-5, 5])\n ax_r.set_ylim([-4 * res_std, 4 * res_std])\n ax.set_xscale('log', nonposx='clip')\n ax.set_yscale('log', nonposy='clip')\n ax_r.set_xscale('log', nonposx='clip')\n ax_r.set_xlabel(r'$\\lambda (\\mu m)$',\n fontsize=self.fontsize,\n fontname=self.fontname\n )\n ax.set_ylabel(r'$\\lambda$F$_\\lambda$ (erg cm$^{-2}$s$^{-1}$)',\n fontsize=self.fontsize,\n fontname=self.fontname\n )\n ax_r.set_ylabel('Residuals\\n$(\\\\sigma)$',\n fontsize=self.fontsize,\n fontname=self.fontname\n )\n\n ax.tick_params(\n axis='both', which='major',\n labelsize=self.tick_labelsize\n )\n ax_r.tick_params(\n axis='both', which='major',\n labelsize=self.tick_labelsize\n )\n ax_r.set_xticks(np.linspace(1, 10, 10))\n ax_r.get_xaxis().set_major_formatter(ticker.ScalarFormatter())\n ax.set_xticks(np.linspace(1, 10, 10))\n ax.get_xaxis().set_major_formatter(ticker.NullFormatter())\n ylocmin = ticker.LinearLocator(numticks=4)\n\n ax_r.yaxis.set_minor_locator(ylocmin)\n ax_r.yaxis.set_minor_formatter(ticker.NullFormatter())\n\n if 'GALEX_FUV' in self.star.filter_names[self.star.filter_mask] or \\\n 'GALEX_NUV' in self.star.filter_names[self.star.filter_mask]:\n ax.set_xlim([0.125, 6])\n ax_r.set_xlim([0.125, 6])\n else:\n ax.set_xlim([0.25, 6])\n ax_r.set_xlim([0.25, 6])\n\n labels = [item.get_text() for item in ax.get_xticklabels()]\n\n empty_string_labels = [''] * len(labels)\n ax.set_xticklabels(empty_string_labels)\n\n for tick in ax.get_yticklabels():\n tick.set_fontname(self.fontname)\n for tick in ax_r.get_yticklabels():\n tick.set_fontname(self.fontname)\n for tick in ax_r.get_xticklabels():\n tick.set_fontname(self.fontname)\n\n if self.pdf:\n plt.savefig(f'{self.out_folder}/SED.pdf', bbox_inches='tight')\n if self.png:\n plt.savefig(f'{self.out_folder}/SED.png', bbox_inches='tight')\n if self.save:\n data = np.vstack((self.wave, self.model * self.wave)).T\n np.savetxt(f'{self.out_folder}/synthetic.dat', data, fmt='%s',\n header='wavelength(mu m) wave*flux(erg cm-2 s-2)')\n pass\n\n def SED(self, ax):\n \"\"\"Plot the SED model.\"\"\"\n Rv = 3.1 # For extinction.\n if not self.norm:\n rad = self.theta[4]\n dist = self.theta[3] * u.pc.to(u.solRad)\n norm = (rad / dist) ** 2\n Av = self.theta[5]\n else:\n norm = self.theta[3]\n Av = self.theta[4]\n\n # SED plot.\n if self.grid == 'phoenix':\n wave = fits.open(self.moddir + self.__wav_file)[0].data\n wave *= u.angstrom.to(u.um)\n\n lower_lim = 0.125 < wave\n upper_lim = wave < 4.629296073126975\n\n flux = self.fetch_Phoenix()\n\n new_w = wave[lower_lim * upper_lim]\n\n new_ww = np.linspace(new_w[0], new_w[-1], len(new_w))\n\n ext = self.av_law(new_w * 1e4, Av, Rv)\n\n brf, _ = pyasl.instrBroadGaussFast(\n new_ww, flux, 1500,\n edgeHandling=\"firstlast\",\n fullout=True, maxsig=8\n )\n brf = brf[lower_lim * upper_lim]\n brf = apply(ext, brf)\n flx = brf * norm * new_w\n ax.plot(new_w[:-1000], flx[:-1000], lw=1.25, color=self.model_color,\n zorder=0)\n\n elif self.grid == 'btsettl':\n wave, flux = self.fetch_btsettl()\n\n lower_lim = 0.125 < wave\n upper_lim = wave < 4.629296073126975\n\n wave = wave[lower_lim * upper_lim]\n flux = flux[lower_lim * upper_lim]\n ext = self.av_law(wave * 1e4, Av, Rv)\n\n new_w = np.linspace(wave[0], wave[-1], len(wave))\n\n brf, _ = pyasl.instrBroadGaussFast(\n new_w, flux, 1500,\n edgeHandling=\"firstlast\",\n fullout=True, maxsig=8\n )\n flx = apply(ext, brf)\n flx *= wave * norm\n ax.plot(wave, flx, lw=1.25, color=self.model_color, zorder=0)\n\n elif self.grid == 'btnextgen':\n wave, flux = self.fetch_btnextgen()\n\n lower_lim = 0.125 < wave\n upper_lim = wave < 4.629296073126975\n\n wave = wave[lower_lim * upper_lim]\n flux = flux[lower_lim * upper_lim]\n ext = self.av_law(wave * 1e4, Av, Rv)\n\n new_w = np.linspace(wave[0], wave[-1], len(wave))\n\n brf, _ = pyasl.instrBroadGaussFast(\n new_w, flux, 1500,\n edgeHandling=\"firstlast\",\n fullout=True, maxsig=8\n )\n flx = apply(ext, brf)\n flx *= wave * norm\n ax.plot(wave, flx, lw=1.25, color=self.model_color, zorder=0)\n\n elif self.grid == 'btcond':\n wave, flux = self.fetch_btcond()\n\n lower_lim = 0.125 < wave\n upper_lim = wave < 4.629296073126975\n\n wave = wave[lower_lim * upper_lim]\n flux = flux[lower_lim * upper_lim]\n ext = self.av_law(wave * 1e4, Av, Rv)\n\n new_w = np.linspace(wave[0], wave[-1], len(wave))\n\n brf, _ = pyasl.instrBroadGaussFast(\n new_w, flux, 1500,\n edgeHandling=\"firstlast\",\n fullout=True, maxsig=8\n )\n flx = apply(ext, brf)\n flx *= wave * norm\n ax.plot(wave, flx, lw=1.25, color=self.model_color, zorder=0)\n\n elif self.grid == 'ck04':\n wave, flux = self.fetch_ck04()\n\n lower_lim = 0.125 < wave\n upper_lim = wave < 4.629296073126975\n\n wave = wave[lower_lim * upper_lim]\n flux = flux[lower_lim * upper_lim]\n ext = self.av_law(wave * 1e4, Av, Rv)\n flux = apply(ext, flux)\n flux *= wave * norm\n ax.plot(wave, flux, lw=1.25, color=self.model_color, zorder=0)\n\n elif self.grid == 'kurucz':\n wave, flux = self.fetch_kurucz()\n\n lower_lim = 0.15 < wave\n upper_lim = wave < 4.629296073126975\n\n wave = wave[lower_lim * upper_lim]\n flux = flux[lower_lim * upper_lim]\n ext = self.av_law(wave * 1e4, Av, Rv)\n flux = apply(ext, flux)\n flux *= wave * norm\n ax.plot(wave, flux, lw=1.25, color=self.model_color, zorder=0)\n\n elif self.grid == 'coelho':\n wave, flux = self.fetch_coelho()\n\n lower_lim = 0.15 < wave\n upper_lim = wave < 4.629296073126975\n\n wave = wave[lower_lim * upper_lim]\n flux = flux[lower_lim * upper_lim]\n ext = self.av_law(wave * 1e4, Av, Rv)\n flux = apply(ext, flux)\n flux *= wave * norm\n ax.plot(wave, flux, lw=1.25, color=self.model_color, zorder=0)\n if self.save:\n data = np.vstack((wave, flux)).T\n np.savetxt(f'{self.out_folder}/SED.dat', data, fmt='%s',\n header='wavelength(mu m) wave*flux(erg cm-2 s-2)')\n pass\n\n def plot_trace(self):\n \"\"\"Plot SED chains.\"\"\"\n samples = self.out['posterior_samples']\n for i, param in enumerate(self.order):\n if not self.coordinator[i]:\n f, ax = plt.subplots(figsize=(12, 4))\n ax.step(range(len(samples[param])), samples[param],\n color='k', alpha=0.8)\n ax.set_ylabel(param,\n fontsize=self.fontsize,\n fontname=self.fontname\n )\n ax.set_xlabel('Steps',\n fontsize=self.fontsize,\n fontname=self.fontname\n )\n best = self.out['best_fit'][param]\n # ax.axhline(np.median(samples[param]), color='red', lw=2)\n ax.axhline(best, color='red', lw=2)\n ax.tick_params(\n axis='both', which='major',\n labelsize=self.tick_labelsize\n )\n plt.savefig(self.chain_out + '/' + param +\n '.png', bbox_inches='tight')\n plt.close('all')\n pass\n\n def plot_like(self):\n \"\"\"Plot Likelihoods.\"\"\"\n samples = self.out['posterior_samples']\n for i, param in enumerate(self.order):\n if not self.coordinator[i]:\n f, ax = plt.subplots(figsize=(12, 4))\n ax.scatter(samples[param], samples['loglike'], alpha=0.5, s=40)\n best = self.out['best_fit'][param]\n # ax.axvline(np.median(samples[param]), color='red', lw=1.5)\n ax.axvline(best, color='red', lw=1.5)\n ax.set_ylabel('log likelihood',\n fontsize=self.fontsize,\n fontname=self.fontname\n )\n ax.set_xlabel(param,\n fontsize=self.fontsize,\n fontname=self.fontname\n )\n ax.tick_params(\n axis='both', which='major',\n labelsize=self.tick_labelsize\n )\n plt.savefig(self.like_out + '/' + param + '.png',\n bbox_inches='tight')\n plt.close('all')\n if self.engine == 'dynesty':\n fig, axes = dyplot.traceplot(\n self.out['dynesty'],\n truths=self.theta,\n show_titles=True, trace_cmap='plasma',\n )\n plt.savefig(self.like_out + '/dynesty_trace.png')\n pass\n\n def plot_post(self):\n \"\"\"Plot posteriors.\"\"\"\n samples = self.out['posterior_samples']\n for i, param in enumerate(self.order):\n if not self.coordinator[i]:\n f, ax = plt.subplots(figsize=(12, 4))\n ax.scatter(samples[param], samples['posteriors'], alpha=0.5,\n s=40)\n best = self.out['best_fit'][param]\n # ax.axvline(np.median(samples[param]), color='red', lw=1.5)\n ax.axvline(best, color='red', lw=1.5)\n ax.set_ylabel('log posterior',\n fontsize=self.fontsize,\n fontname=self.fontname\n )\n ax.set_xlabel(param,\n fontsize=self.fontsize,\n fontname=self.fontname\n )\n ax.tick_params(\n axis='both', which='major',\n labelsize=self.tick_labelsize\n )\n plt.savefig(self.post_out + '/' + param + '.png',\n bbox_inches='tight')\n plt.close('all')\n pass\n\n def plot_hist(self):\n pass\n\n def plot_bma_hist(self):\n \"\"\"Plot histograms.\"\"\"\n print('Plotting BMA histograms.')\n colors = [\n 'tab:blue', 'tab:orange', 'tab:green', 'tab:red', 'tab:purple',\n 'tab:brown'\n ]\n models = [key for key in self.out['originals'].keys()]\n for i, param in enumerate(self.order):\n if 'noise' in param:\n continue\n if not self.coordinator[i]:\n f1, ax1 = plt.subplots(figsize=(12, 6))\n f2, ax2 = plt.subplots(figsize=(12, 6))\n for j, m in enumerate(models):\n # Get samples\n samp = self.out['originals'][m][param]\n # Plot sample histogram\n label = m + ' prob: {:.3f}'.format(self.out['weights'][m])\n # Normal\n n, bins1, patches = ax1.hist(samp, alpha=.3, bins=20,\n label=label, density=True,\n color=colors[j])\n # Weighted\n n, bins2, patches = ax2.hist(\n samp, alpha=.3, bins=20, label=label,\n weights=[self.out['weights'][m]] * len(samp)\n )\n # Fit a KDE to data\n kde = gaussian_kde(samp)\n # Estimate amplitude of the weighted distributions\n mu, sig = norm.fit(samp)\n try:\n bc = bins2[:-1] + np.diff(bins2)\n popt, pcov = curve_fit(norm_fit, xdata=bc, ydata=n,\n p0=[mu, sig, n.max()],\n maxfev=50000)\n except RuntimeError:\n popt = (mu, sig, n.max())\n xx1 = np.linspace(bins1[0], bins1[-1], 1000)\n xx2 = np.linspace(bins2[0], bins2[-1], 1000)\n # Plot best fit\n ax1.plot(xx1, kde(xx2), lw=2, alpha=1, color=colors[j])\n ax2.plot(xx1, kde(xx2) * popt[2], lw=2, alpha=1,\n color=colors[j])\n # The same but for the weighted samples\n n, bins, patches = ax1.hist(\n self.out['weighted_samples'][param], alpha=.3,\n bins=20, label='Weighted sampling', density=True,\n color='tab:cyan'\n )\n kde = gaussian_kde(self.out['weighted_samples'][param])\n xx = np.linspace(bins[0], bins[-1], 300)\n ax1.plot(xx, kde(xx), color='tab:cyan', lw=2, alpha=1, ls='--')\n\n # Now ditto for the weighted average\n n, bins, patches = ax1.hist(\n self.out['weighted_average'][param], alpha=.3,\n bins=20, label='Weighted average', density=True,\n color='tab:pink'\n )\n kde = gaussian_kde(self.out['weighted_average'][param])\n xx = np.linspace(bins[0], bins[-1], 300)\n ax1.plot(xx, kde(xx), color='tab:pink', lw=2, alpha=1, ls='-.')\n if param == 'z':\n param = '[Fe/H]'\n # Normal\n ax1.set_ylabel('PDF',\n fontsize=self.fontsize,\n fontname=self.fontname\n )\n # Weighted\n ax2.set_ylabel('N',\n fontsize=self.fontsize,\n fontname=self.fontname\n )\n axes = [ax1, ax2]\n for ax in axes:\n ax.set_xlabel(param,\n fontsize=self.fontsize,\n fontname=self.fontname\n )\n for tick in ax.get_yticklabels():\n tick.set_fontname(self.fontname)\n for tick in ax.get_xticklabels():\n tick.set_fontname(self.fontname)\n\n ax.tick_params(\n axis='both', which='major',\n labelsize=self.tick_labelsize\n )\n ax.legend(loc=0, prop={'size': 16})\n\n if param == '[Fe/H]':\n param = 'Fe_H'\n if self.png:\n f1.savefig(self.hist_out + '/' + param + '.png',\n bbox_inches='tight')\n f2.savefig(self.hist_out + '/weighted_' + param + '.png',\n bbox_inches='tight')\n if self.pdf:\n f1.savefig(self.hist_out + '/' + param + '.pdf',\n bbox_inches='tight')\n f2.savefig(self.hist_out + '/weighted_' + param + '.pdf',\n bbox_inches='tight')\n plt.close(f1)\n plt.close(f2)\n\n if self.bma:\n # Age hist\n f, ax = plt.subplots(figsize=(12, 4))\n samp = self.out['mist_samples']['age']\n n, bins, patches = ax.hist(\n samp, alpha=.3, bins=20, label='MIST', density=True\n )\n kde = gaussian_kde(samp)\n xx = np.linspace(bins[0], bins[-1], 10000)\n ax.plot(xx, kde(xx), color='k', lw=2, alpha=.7)\n ax.set_ylabel('PDF',\n fontsize=self.fontsize,\n fontname=self.fontname)\n ax.set_xlabel('Age',\n fontsize=self.fontsize,\n fontname=self.fontname)\n\n for tick in ax.get_yticklabels():\n tick.set_fontname(self.fontname)\n for tick in ax.get_xticklabels():\n tick.set_fontname(self.fontname)\n\n ax.tick_params(\n axis='both', which='major',\n labelsize=self.tick_labelsize\n )\n plt.legend(loc=0)\n if self.png:\n plt.savefig(self.hist_out + '/age.png',\n bbox_inches='tight')\n if self.pdf:\n plt.savefig(self.hist_out + '/age.pdf',\n bbox_inches='tight')\n plt.close(f)\n # Mass hist\n f, ax = plt.subplots(figsize=(12, 4))\n samp = self.out['mist_samples']['iso_mass']\n n, bins, patches = ax.hist(\n samp, alpha=.3, bins=20, label='MIST', density=True\n )\n kde = gaussian_kde(samp)\n xx = np.linspace(bins[0], bins[-1], 10000)\n ax.plot(xx, kde(xx), color='k', lw=2, alpha=.7)\n ax.set_ylabel('PDF',\n fontsize=self.fontsize,\n fontname=self.fontname)\n ax.set_xlabel('Mass',\n fontsize=self.fontsize,\n fontname=self.fontname)\n\n for tick in ax.get_yticklabels():\n tick.set_fontname(self.fontname)\n for tick in ax.get_xticklabels():\n tick.set_fontname(self.fontname)\n\n ax.tick_params(\n axis='both', which='major',\n labelsize=self.tick_labelsize\n )\n plt.legend(loc=0)\n if self.png:\n plt.savefig(self.hist_out + '/iso_mass.png',\n bbox_inches='tight')\n if self.pdf:\n plt.savefig(self.hist_out + '/iso_mass.pdf',\n bbox_inches='tight')\n plt.close(f)\n # EEP hist\n f, ax = plt.subplots(figsize=(12, 4))\n samp = self.out['mist_samples']['eep']\n n, bins, patches = ax.hist(\n samp, alpha=.3, bins=20, label='MIST', density=True\n )\n kde = gaussian_kde(samp)\n xx = np.linspace(bins[0], bins[-1], 10000)\n ax.plot(xx, kde(xx), color='k', lw=2, alpha=.7)\n ax.set_ylabel('PDF',\n fontsize=self.fontsize,\n fontname=self.fontname)\n ax.set_xlabel('EEP',\n fontsize=self.fontsize,\n fontname=self.fontname)\n\n for tick in ax.get_yticklabels():\n tick.set_fontname(self.fontname)\n for tick in ax.get_xticklabels():\n tick.set_fontname(self.fontname)\n\n ax.tick_params(\n axis='both', which='major',\n labelsize=self.tick_labelsize\n )\n plt.legend(loc=0)\n if self.png:\n plt.savefig(self.hist_out + '/EEP.png',\n bbox_inches='tight')\n if self.pdf:\n plt.savefig(self.hist_out + '/EEP.pdf',\n bbox_inches='tight')\n plt.close(f)\n\n def plot_bma_HR(self, nsamp):\n \"\"\"Plot HR diagram for the star.\"\"\"\n print('Plotting HR diagram')\n # Get necessary info from the star.\n age = self.out[f'best_fit_{self.method}']['age']\n feh = self.out[f'best_fit_{self.method}']['z']\n teff = np.log10(self.out[f'best_fit_{self.method}']['teff'])\n lum = np.log10(self.out[f'best_fit_{self.method}']['lum'])\n teff_lo, teff_hi = self.out[f'uncertainties_{self.method}']['teff']\n lum_lo, lum_hi = self.out[f'uncertainties_{self.method}']['lum']\n teff_lo = teff_lo / (10 ** teff * np.log(10))\n teff_hi = teff_hi / (10 ** teff * np.log(10))\n lum_lo = lum_lo / (10 ** lum * np.log(10))\n lum_hi = lum_hi / (10 ** lum * np.log(10))\n ages = self.out['mist_samples']['age']\n m = self.method if self.method == 'samples' else 'average'\n fehs = self.out[f'weighted_{m}']['z']\n\n if feh > 0.5:\n feh = 0.5\n\n iso_bf = get_isochrone(np.log10(age) + 9, feh)\n\n logteff = iso_bf['logTeff'].values\n loglum = iso_bf['logL'].values\n mass = iso_bf['mass'].values\n\n fig, ax = plt.subplots(figsize=self.hr_figsize)\n\n points = np.array([logteff, loglum]).T.reshape(-1, 1, 2)\n segments = np.concatenate([points[:-1], points[1:]], axis=1)\n\n norm = plt.Normalize(mass.min(), mass.max())\n lc = LineCollection(segments, cmap=self.hr_cmap, norm=norm,\n linewidths=5)\n\n lc.set_array(mass)\n line = ax.add_collection(lc)\n line.zorder = 1000\n cbar = fig.colorbar(line, ax=ax, pad=0.01)\n cbar.set_label(r'$M_\\odot$',\n rotation=270,\n fontsize=self.fontsize,\n fontname=self.fontname,\n labelpad=20)\n\n for i in range(nsamp):\n a = np.log10(choice(ages)) + 9\n z = choice(fehs)\n if z > 0.5:\n z = 0.5\n iso = get_isochrone(a, z)\n\n logt = iso['logTeff'].values\n logl = iso['logL'].values\n ax.plot(logt, logl, color='gray')\n\n ax.errorbar(teff, lum, xerr=[[teff_lo], [teff_hi]],\n yerr=[[lum_lo], [lum_hi]], color=self.hr_color,\n zorder=1001)\n ax.scatter(teff, lum, s=350, color=self.hr_color, zorder=1002,\n edgecolors='k', marker=self.hr_marker)\n\n ax.invert_xaxis()\n ax.set_xlabel('logTeff',\n fontsize=self.fontsize,\n fontname=self.fontname)\n ax.set_ylabel('logL',\n fontsize=self.fontsize,\n fontname=self.fontname)\n ax.tick_params(\n axis='both', which='major',\n labelsize=self.tick_labelsize\n )\n for ll in cbar.ax.yaxis.get_ticklabels():\n ll.set_fontsize(self.tick_labelsize)\n for tick in ax.get_yticklabels():\n tick.set_fontname(self.fontname)\n for tick in ax.get_yticklabels():\n tick.set_fontname(self.fontname)\n\n if self.png:\n plt.savefig(self.out_folder + '/HR_diagram.png',\n bbox_inches='tight')\n if self.pdf:\n plt.savefig(self.out_folder + '/HR_diagram.pdf',\n bbox_inches='tight')\n\n def plot_corner(self):\n \"\"\"Make corner plot.\"\"\"\n print('Plotting corner.')\n m = self.method if self.method == 'samples' else 'average'\n samples = self.out[f'weighted_{m}']\n all_samps = []\n theta_lo = []\n theta_up = []\n\n for i, o in enumerate(self.order):\n if 'noise' in o:\n self.coordinator[i] = 1\n\n theta = self.theta[self.coordinator == 0]\n used_params = self.order[self.coordinator == 0]\n\n for i, param in enumerate(self.order):\n if not self.coordinator[i]:\n if 'noise' in param:\n continue\n _, lo, up = credibility_interval(samples[param])\n theta_lo.append(lo)\n theta_up.append(up)\n all_samps.append(samples[param])\n\n corner_samp = np.vstack(all_samps)\n\n titles = self.__create_titles(used_params, theta, theta_up, theta_lo)\n labels = self.__create_labels(used_params)\n\n fig = corner.corner(\n corner_samp.T,\n plot_contours=True,\n fill_contours=False,\n plot_datapoints=True,\n no_fill_contours=True,\n max_n_ticks=4\n )\n\n axes = np.array(fig.axes).reshape((theta.shape[0], theta.shape[0]))\n\n for i in range(theta.shape[0]):\n ax = axes[i, i]\n ax.axvline(theta[i], color=self.corner_med_c,\n linestyle=self.corner_med_style)\n ax.axvline(theta_lo[i], color=self.corner_v_c,\n linestyle=self.corner_v_style)\n ax.axvline(theta_up[i], color=self.corner_v_c,\n linestyle=self.corner_v_style)\n t = titles[i]\n\n ax.set_title(t, fontsize=self.corner_fontsize,\n fontname=self.fontname)\n\n for yi in range(theta.shape[0]):\n for xi in range(yi):\n ax = axes[yi, xi]\n if xi == 0:\n for tick in ax.yaxis.get_major_ticks():\n tick.label.set_fontsize(self.corner_tick_fontsize)\n tick.label.set_fontname(self.fontname)\n ax.set_ylabel(\n labels[yi],\n labelpad=self.corner_labelpad,\n fontsize=self.corner_fontsize,\n fontname=self.fontname\n )\n if yi == theta.shape[0] - 1:\n for tick in ax.xaxis.get_major_ticks():\n tick.label.set_fontsize(self.corner_tick_fontsize)\n tick.label.set_fontname(self.fontname)\n ax.set_xlabel(\n labels[xi],\n labelpad=self.corner_labelpad,\n fontsize=self.corner_fontsize,\n fontname=self.fontname\n )\n ax.axvline(theta[xi], color=self.corner_med_c,\n linestyle=self.corner_med_style)\n ax.axhline(theta[yi], color=self.corner_med_c,\n linestyle=self.corner_med_style)\n ax.plot(theta[xi], theta[yi], self.corner_marker)\n axes[-1, -1].set_xlabel(\n labels[-1],\n labelpad=self.corner_labelpad,\n fontsize=self.corner_fontsize,\n fontname=self.fontname\n )\n for tick in axes[-1, -1].xaxis.get_major_ticks():\n tick.label.set_fontsize(self.corner_tick_fontsize)\n tick.label.set_fontname(self.fontname)\n\n if self.pdf:\n plt.savefig(f'{self.out_folder}/CORNER.pdf',\n bbox_inches='tight')\n if self.png:\n plt.savefig(f'{self.out_folder}/CORNER.png',\n bbox_inches='tight')\n pass\n\n def clean(self):\n \"\"\"Close opened figures.\"\"\"\n plt.close('all')\n\n def fetch_Phoenix(self):\n \"\"\"Fetch correct Phoenixv2 SED file.\n\n The directory containing the Phoenix spectra must be called PHOENIXv2\n Within PHOENIXv2 there should be the wavelength file called\n WAVE_PHOENIX-ACES-AGSS-COND-2011.fits and several folders called\n Z[-/+]X.X where X.X are the metallicities (e.g. Z-0.0, Z+1.0, etc)\n \"\"\"\n # Change hdd to a class variable depending on an env param.\n teff = self.theta[0]\n logg = self.theta[1]\n z = self.theta[2]\n select_teff = np.argmin((abs(teff - np.unique(self.star.teff))))\n select_logg = np.argmin((abs(logg - np.unique(self.star.logg))))\n select_z = np.argmin((abs(z - np.unique(self.star.z))))\n sel_teff = int(np.unique(self.star.teff)[select_teff])\n sel_logg = np.unique(self.star.logg)[select_logg]\n sel_z = np.unique(self.star.z)[select_z]\n selected_SED = self.moddir + 'PHOENIXv2/Z'\n metal_add = ''\n if sel_z < 0:\n metal_add = str(sel_z)\n if sel_z == 0:\n metal_add = '-0.0'\n if sel_z > 0:\n metal_add = '+' + str(sel_z)\n selected_SED += metal_add\n selected_SED += '/lte'\n selected_SED += str(sel_teff) if len(str(sel_teff)) == 5 else \\\n '0' + str(sel_teff)\n selected_SED += '-' + str(sel_logg) + '0'\n selected_SED += metal_add\n selected_SED += '.PHOENIX-ACES-AGSS-COND-2011-HiRes.fits'\n flux = fits.open(selected_SED)[0].data\n flux *= (u.erg / u.s / u.cm ** 2 / u.cm).to(\n u.erg / u.s / u.cm ** 2 / u.um)\n return flux\n\n def fetch_btsettl(self):\n \"\"\"Fetch correct BT-Settl SED file.\n\n The directory containing the BT-Settl spectra must be called BTSettl\n Within BTSettl there should be yet another directory\n called AGSS2009, within BTSettl/AGSS2009 there should be the SED fits\n files with the following naming convention:\n\n lteTTT-G.G[-/+]Z.Za+0.0.BT-Settl.AGSS2009.fits\n\n where TTT are the first 3 digits of the effective temperature if it's a\n number over 10000, else it's the first 2 digit prepended by a 0.\n G.G is the log g and Z.Z the metallicity.\n \"\"\"\n conversion = (u.erg / u.s / u.cm ** 2 / u.angstrom)\n conversion = conversion.to(u.erg / u.s / u.cm ** 2 / u.um)\n teff = self.theta[0]\n logg = self.theta[1]\n z = self.theta[2]\n select_teff = np.argmin((abs(teff - np.unique(self.star.teff))))\n select_logg = np.argmin((abs(logg - np.unique(self.star.logg))))\n select_z = np.argmin((abs(z - np.unique(self.star.z))))\n sel_teff = int(np.unique(self.star.teff)[select_teff]) // 100\n sel_logg = np.unique(self.star.logg)[select_logg]\n sel_z = np.unique(self.star.z)[select_z]\n metal_add = ''\n if sel_z < 0:\n metal_add = str(sel_z)\n if sel_z == 0:\n metal_add = '-0.0'\n if sel_z > 0:\n metal_add = '+' + str(sel_z)\n selected_SED = self.moddir + 'BTSettl/AGSS2009/lte'\n selected_SED += str(sel_teff) if len(str(sel_teff)) == 3 else \\\n '0' + str(sel_teff)\n selected_SED += '-' + str(sel_logg) + metal_add + 'a+*'\n gl = glob.glob(selected_SED)\n selected_SED = gl[0]\n tab = Table(fits.open(selected_SED)[1].data)\n flux = np.array(tab['FLUX'].tolist()) * conversion\n wave = np.array(tab['WAVELENGTH'].tolist()) * u.angstrom.to(u.um)\n return wave, flux\n\n def fetch_btnextgen(self):\n \"\"\"Fetch correct BT-NextGen SED file.\n\n The directory containing the BT-NextGen spectra must be called\n BTNextGen. Within BTNextGen there should be yet another directory\n called AGSS2009, within BTNextGen/AGSS2009 there should be the SED fits\n files with the following naming convention:\n\n lteTTT-G.G[-/+]Z.Za+0.0..BT-NextGen.AGSS2009.fits\n\n where TTT are the first 3 digits of the effective temperature if it's a\n number over 10000, else it's the first 2 digit prepended by a 0.\n G.G is the log g and Z.Z the metallicity.\n \"\"\"\n conversion = (u.erg / u.s / u.cm ** 2 / u.angstrom)\n conversion = conversion.to(u.erg / u.s / u.cm ** 2 / u.um)\n teff = self.theta[0]\n logg = self.theta[1]\n z = self.theta[2]\n select_teff = np.argmin((abs(teff - np.unique(self.star.teff))))\n select_logg = np.argmin((abs(logg - np.unique(self.star.logg))))\n select_z = np.argmin((abs(z - np.unique(self.star.z))))\n sel_teff = int(np.unique(self.star.teff)[select_teff]) // 100\n sel_logg = np.unique(self.star.logg)[select_logg]\n sel_z = np.unique(self.star.z)[select_z]\n metal_add = ''\n if sel_z < 0:\n metal_add = str(sel_z)\n if sel_z == 0:\n metal_add = '-0.0'\n if sel_z > 0:\n metal_add = '+' + str(sel_z)\n selected_SED = self.moddir + 'BTNextGen/AGSS2009/lte'\n selected_SED += str(sel_teff) if len(str(sel_teff)) == 3 else \\\n '0' + str(sel_teff)\n selected_SED += '-' + str(sel_logg) + metal_add + 'a+*'\n gl = glob.glob(selected_SED)\n selected_SED = gl[0]\n tab = Table(fits.open(selected_SED)[1].data)\n flux = np.array(tab['FLUX'].tolist()) * conversion\n wave = np.array(tab['WAVELENGTH'].tolist()) * u.angstrom.to(u.um)\n return wave, flux\n\n def fetch_btcond(self):\n \"\"\"Fetch correct BT-COND SED file.\n\n The directory containing the BT-COND spectra must be called\n BTCOND. Within BTCOND there should be yet another directory\n called CIFIST2011, within BTCOND/CIFIST2011 there should be the SED\n fits files with the following naming convention:\n\n lteTTT-G.G[-/+]Z.Za+0.0..BT-Cond.CIFIST2011.fits\n\n where TTT are the first 3 digits of the effective temperature if it's a\n number over 10000, else it's the first 2 digit prepended by a 0.\n G.G is the log g and Z.Z the metallicity.\n \"\"\"\n conversion = (u.erg / u.s / u.cm ** 2 / u.angstrom)\n conversion = conversion.to(u.erg / u.s / u.cm ** 2 / u.um)\n teff = self.theta[0]\n logg = self.theta[1]\n z = self.theta[2]\n select_teff = np.argmin((abs(teff - np.unique(self.star.teff))))\n select_logg = np.argmin((abs(logg - np.unique(self.star.logg))))\n select_z = np.argmin((abs(z - np.unique(self.star.z))))\n sel_teff = int(np.unique(self.star.teff)[select_teff]) // 100\n sel_logg = np.unique(self.star.logg)[select_logg]\n sel_z = np.unique(self.star.z)[select_z]\n metal_add = ''\n if sel_z < 0:\n metal_add = str(sel_z)\n if sel_z == 0:\n metal_add = '-0.0'\n if sel_z > 0:\n metal_add = '+' + str(sel_z)\n selected_SED = self.moddir + 'BTCond/CIFIST2011/lte'\n selected_SED += str(sel_teff) if len(str(sel_teff)) == 3 else \\\n '0' + str(sel_teff)\n selected_SED += '-' + str(sel_logg) + metal_add + 'a+*'\n gl = glob.glob(selected_SED)\n selected_SED = gl[0]\n tab = Table(fits.open(selected_SED)[1].data)\n flux = np.array(tab['FLUX'].tolist()) * conversion\n wave = np.array(tab['WAVELENGTH'].tolist()) * u.angstrom.to(u.um)\n return wave, flux\n\n def fetch_ck04(self):\n \"\"\"Fetch correct Castelli-Kurucz 2004 SED file.\n\n The directory containing the Castelli-Kurucz spectra must be called\n Castelli_Kurucz. Within Castelli_Kurucz there should be a group of\n directories called ck[pm]ZZ where ZZ is the metalicity without the dot.\n Within each directory there are fits files named:\n\n ck[pm]ZZ_TTTT.fits\n\n where ZZ is metalicity as previous and TTTT is the effective\n temperature.\n \"\"\"\n conversion = (u.erg / u.s / u.cm ** 2 / u.angstrom)\n conversion = conversion.to(u.erg / u.s / u.cm ** 2 / u.um)\n teff = self.theta[0]\n logg = self.theta[1]\n z = self.theta[2]\n select_teff = np.argmin((abs(teff - np.unique(self.star.teff))))\n select_logg = np.argmin((abs(logg - np.unique(self.star.logg))))\n select_z = np.argmin((abs(z - np.unique(self.star.z))))\n sel_teff = int(np.unique(self.star.teff)[select_teff])\n sel_logg = np.unique(self.star.logg)[select_logg]\n sel_z = np.unique(self.star.z)[select_z]\n metal_add = ''\n if sel_z < 0:\n metal_add = 'm' + str(-sel_z).replace('.', '')\n if sel_z == 0:\n metal_add = 'p00'\n if sel_z > 0:\n metal_add = 'p' + str(sel_z).replace('.', '')\n name = 'ck' + metal_add\n lgg = 'g{:.0f}'.format(sel_logg * 10)\n selected_SED = self.moddir + 'Castelli_Kurucz/' + name + '/' + name\n selected_SED += '_' + str(sel_teff) + '.fits'\n tab = Table(fits.open(selected_SED)[1].data)\n wave = np.array(tab['WAVELENGTH'].tolist()) * u.angstrom.to(u.um)\n flux = np.array(tab[lgg].tolist()) * conversion\n return wave, flux\n\n def fetch_kurucz(self):\n \"\"\"Fetch correct Kurucz 1993 SED file.\n\n The directory containing the Kurucz spectra must be called\n Kurucz. Within Kurucz there should be a group of\n directories called k[pm]ZZ where ZZ is the metalicity without the dot.\n Within each directory there are fits files named:\n\n k[pm]ZZ_TTTT.fits\n\n where ZZ is metalicity as previous and TTTT is the effective\n temperature.\n \"\"\"\n conversion = (u.erg / u.s / u.cm ** 2 / u.angstrom)\n conversion = conversion.to(u.erg / u.s / u.cm ** 2 / u.um)\n teff = self.theta[0]\n logg = self.theta[1]\n z = self.theta[2]\n select_teff = np.argmin((abs(teff - np.unique(self.star.teff))))\n select_logg = np.argmin((abs(logg - np.unique(self.star.logg))))\n select_z = np.argmin((abs(z - np.unique(self.star.z))))\n sel_teff = int(np.unique(self.star.teff)[select_teff])\n sel_logg = np.unique(self.star.logg)[select_logg]\n sel_z = np.unique(self.star.z)[select_z]\n metal_add = ''\n if sel_z < 0:\n metal_add = 'm' + str(-sel_z).replace('.', '')\n if sel_z == 0:\n metal_add = 'p00'\n if sel_z > 0:\n metal_add = 'p' + str(sel_z).replace('.', '')\n name = 'k' + metal_add\n lgg = 'g{:.0f}'.format(sel_logg * 10)\n selected_SED = self.moddir + 'Kurucz/' + name + '/' + name\n selected_SED += '_' + str(sel_teff) + '.fits'\n tab = Table(fits.open(selected_SED)[1].data)\n wave = np.array(tab['WAVELENGTH'].tolist()) * u.angstrom.to(u.um)\n flux = np.array(tab[lgg].tolist()) * conversion\n return wave, flux\n\n def fetch_coelho(self):\n \"\"\"Fetch correct Coelho 2014 SED file.\n\n The directory containing the Coelho spectra must be called\n Coelho14. Within Coelho14 there should be a group of\n files called t[0X]XXXX_g[+-]Y.Y_[mp]ZZp0[14]_sed.fits\n where X is the temperature, Y is the logg and Z the metallicity.\n \"\"\"\n conversion = (u.erg / u.s / u.cm ** 2 / u.angstrom)\n conversion = conversion.to(u.erg / u.s / u.cm ** 2 / u.um)\n teff = self.theta[0]\n logg = self.theta[1]\n z = self.theta[2]\n select_teff = np.argmin((abs(teff - np.unique(self.star.teff))))\n select_logg = np.argmin((abs(logg - np.unique(self.star.logg))))\n select_z = np.argmin((abs(z - np.unique(self.star.z))))\n sel_teff = int(np.unique(self.star.teff)[select_teff])\n sel_logg = np.unique(self.star.logg)[select_logg]\n sel_z = np.unique(self.star.z)[select_z]\n sel_teff = str(sel_teff) if sel_teff >= 1e5 else '0{}'.format(sel_teff)\n selected_SED = self.moddir + 'Coelho14/t' + sel_teff + '_g'\n sel_logg = '+{:.1f}'.format(sel_logg) if sel_logg > 0 else '-0.5'\n selected_SED += sel_logg\n if sel_z < 0:\n selected_SED += '_m{:02.0f}'.format(-sel_z * 10)\n else:\n selected_SED += '_p{:02.0f}'.format(sel_z * 10)\n\n selected_SED = glob.glob(selected_SED + 'p0[04]_sed.fits')\n selected_SED = selected_SED[0]\n hdul = fits.open(selected_SED)\n head = hdul[0].header\n data = hdul[0].data\n flux = data * conversion\n CRVAL1 = head['CRVAL1']\n CDEL1 = head['CDELT1']\n wave = 10 ** np.array(\n [CRVAL1 + CDEL1 * i for i in range(data.shape[0])])\n wave *= u.angstrom.to(u.um)\n return wave, flux\n\n def __create_titles(self, titles, theta, theta_up, theta_lo):\n new_titles = np.empty(titles.shape[0], dtype=object)\n for i, param in enumerate(titles):\n if param == 'teff':\n new_titles[i] = r'Teff ='\n if param == 'logg':\n new_titles[i] = r' Log g ='\n if param == 'z':\n new_titles[i] = r' [Fe/H] ='\n if param == 'dist':\n new_titles[i] = r' D ='\n if param == 'rad':\n new_titles[i] = r'R ='\n if param == 'norm':\n new_titles[i] = r' (R/D)$^2$ ='\n if param == 'Av':\n new_titles[i] = r'Av ='\n if param == 'inflation':\n new_titles[i] = r'$\\sigma$ ='\n if param == 'rad' or param == 'dist':\n new_titles[i] += '{:.3f}'.format(theta[i])\n new_titles[i] += r'$^{+' + \\\n '{:.3f}'.format(theta_up[i] - theta[i])\n new_titles[i] += r'}_{-' + \\\n '{:.3f}'.format(theta[i] - theta_lo[i])\n new_titles[i] += r'}$'\n else:\n new_titles[i] += '{:.2f}'.format(theta[i])\n new_titles[i] += r'$^{+' + \\\n '{:.2f}'.format(theta_up[i] - theta[i])\n new_titles[i] += r'}_{-' + \\\n '{:.2f}'.format(theta[i] - theta_lo[i])\n new_titles[i] += r'}$'\n return new_titles\n\n def __create_labels(self, labels):\n new_labels = np.empty(labels.shape[0], dtype=object)\n for i, param in enumerate(labels):\n if param == 'teff':\n new_labels[i] = r'Teff (K)'\n if param == 'logg':\n new_labels[i] = r'Log g'\n if param == 'z':\n new_labels[i] = r'[Fe/H]'\n if param == 'dist':\n new_labels[i] = r'D (pc)'\n if param == 'rad':\n new_labels[i] = r'R $($R$_\\odot)$'\n if param == 'norm':\n new_labels[i] = r'(R/D)'\n if param == 'Av':\n new_labels[i] = r'Av'\n if param == 'inflation':\n new_labels[i] = r'$\\sigma$'\n return new_labels\n\n def __read_config(self):\n \"\"\"Read plotter configuration file.\"\"\"\n if self.settings_dir is None:\n settings = open(filesdir + '/plot_settings.dat', 'r')\n else:\n settings = open(self.settings_dir, 'r')\n for line in settings.readlines():\n if line[0] == '#' or line[0] == '\\n':\n continue\n splt = line.split(' ')\n attr = splt[0]\n if attr == 'figsize':\n vals = splt[1].split('\\n')[0].split(',')\n val = (int(vals[0]), int(vals[1]))\n elif attr == 'hr_figsize':\n vals = splt[1].split('\\n')[0].split(',')\n val = (int(vals[0]), int(vals[1]))\n elif 'alpha' in attr:\n val = float(splt[1].split('\\n')[0])\n else:\n try:\n val = int(splt[1].split('\\n')[0])\n except ValueError:\n val = splt[1].split('\\n')[0]\n setattr(self, attr, val)\n", "meta": {"hexsha": "c74b2be753dda81aaade13d2e41e0e13bc0c0a72", "size": 58212, "ext": "py", "lang": "Python", "max_stars_repo_path": "astroARIADNE/plotter.py", "max_stars_repo_name": "danhey/astroARIADNE", "max_stars_repo_head_hexsha": "1bce4684e565b89e9234c4693094480adf960f0b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "astroARIADNE/plotter.py", "max_issues_repo_name": "danhey/astroARIADNE", "max_issues_repo_head_hexsha": "1bce4684e565b89e9234c4693094480adf960f0b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "astroARIADNE/plotter.py", "max_forks_repo_name": "danhey/astroARIADNE", "max_forks_repo_head_hexsha": "1bce4684e565b89e9234c4693094480adf960f0b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.2264150943, "max_line_length": 80, "alphanum_fraction": 0.5057720058, "include": true, "reason": "import numpy,from scipy,from astropy", "num_tokens": 13876, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5389832354982647, "lm_q2_score": 0.36658973632215985, "lm_q1q2_score": 0.19758572218337342}} {"text": "# Copyright 2021 D-Wave Systems Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nr\"\"\"This module contains a class that represents an influence path/functional.\n\"\"\"\n\n\n\n#####################################\n## Load libraries/packages/modules ##\n#####################################\n\n# For explicitly releasing memory.\nimport gc\n\n\n\n# For general array handling.\nimport numpy as np\n\n# For creating tensor networks.\nimport tensornetwork as tn\n\n\n\n# Assign an alias to the ``spinbosonchain`` library.\nimport spinbosonchain as sbc\n\n# For calculating the total two-point influence function.\nimport spinbosonchain._influence.twopt\n\n# For creating influence nodes and MPOs used to calculate the influence path.\nimport spinbosonchain._influence.tensorfactory\n\n# For applying MPO's to MPS's.\nimport spinbosonchain._mpomps\n\n# For shifting orthogonal centers of MPS's.\nimport spinbosonchain._qr\n\n\n\n############################\n## Authorship information ##\n############################\n\n__author__ = \"D-Wave Systems Inc.\"\n__copyright__ = \"Copyright 2021\"\n__credits__ = [\"Matthew Fitzpatrick\"]\n__maintainer__ = \"D-Wave Systems Inc.\"\n__email__ = \"support@dwavesys.com\"\n__status__ = \"Development\"\n\n\n\n##################################\n## Define classes and functions ##\n##################################\n\nclass PathPklPart():\n def __init__(self, compress_params, alg):\n # DM: Detailed manuscript.\n\n # 'Pickle parts' can be saved to file in case of a crash and then\n # subsequently recovered in a future run. See docs of method\n # spinbosonchain.state.recover_and_resume for background information on\n # pickles and simulation recovery.\n \n self.compress_params = compress_params\n self.alg = alg # yz- or z-noise algorithm?\n\n self.n = 0 # Time step index.\n self.m2 = 0\n \n # For caching purposes.\n self.Xi_I_dashv_1_nodes = None # Introduced in Eq. (143) of DM.\n self.Xi_I_dashv_2_nodes = None # Introduced in Eq. (143) of DM.\n self.Xi_I_dashv_nodes = None # Introduced in Eq. (143) of DM.\n self.Xi_I_1_1_nodes = None # Introduced in Eq. (126) of DM.\n self.Xi_I_1_2_nodes = None # Introduced in Eq. (126) of DM.\n\n return None\n\n\n\nclass Path():\n r\"\"\"This class represents a local influence path/functional, given by\n Eq. (103) of the detailed manuscript (DM). For context read Sec. 4.3 and 4.4\n of DM.\"\"\"\n def __init__(self,\n r, # Site index.\n system_model,\n bath_model,\n dt, # Time step size.\n compress_params,\n pkl_parts=None): # Used in loading/creating backups.\n # DM: Detailed manuscript.\n\n # 'Pickle parts' can be saved to file in case of a crash and then\n # subsequently recovered in a future run. See docs of method\n # spinbosonchain.state.recover_and_resume for background information on\n # pickles and simulation recovery.\n \n # total_two_point_influence represents the quantity in Eq. (109) of DM.\n total_two_point_influence = sbc._influence.twopt.Total(r,\n system_model,\n bath_model,\n dt,\n pkl_parts)\n\n # This class generates the M-nodes given by Eq. (118) of DM.\n InfluenceNodeRank3 = sbc._influence.tensorfactory.InfluenceNodeRank3\n\n # This class generates the W-nodes given by Eqs. (120)-(123) of DM.\n InfluenceMPO = sbc._influence.tensorfactory.InfluenceMPO\n \n influence_node_rank_3_factory = \\\n InfluenceNodeRank3(total_two_point_influence)\n self.influence_mpo_factory = \\\n InfluenceMPO(total_two_point_influence)\n\n # K_tau is given by Eq. (87) of DM.\n K_tau = total_two_point_influence.z_bath.pkl_part.K_tau\n\n # dm is given by Eq. (89) of DM.\n dm = 3 if bath_model.y_spectral_densities is not None else 1\n\n # mu_m_tau is given by Eq. (108) of DM.\n self.mu_m_tau = lambda m: max(0, m-K_tau*dm+1)\n\n # The 'first iteration procedure' involves executing Eqs. (130)-(137) of\n # DM, whereas the 'second iteration procedure' involves executing\n # Eqs. (146)-(154) of DM.\n self.max_m2_in_first_iteration_procedure = lambda n: n*dm-2\n self.max_m2_in_second_iteration_procedure = lambda n: (n+1)*dm-1\n\n if pkl_parts is None: # Create pickle part from scratch.\n alg = total_two_point_influence.alg # yz- or z-noise algorithm.\n self.pkl_part = PathPklPart(compress_params, alg)\n\n # M_r_1_0_I is given by Eq. (118) of DM with m2=0 and n=1.\n M_r_1_0_I = influence_node_rank_3_factory.build(m=0, n=1)\n\n # The quantities below are introduced in Eq. (126) of DM.\n self.pkl_part.Xi_I_1_1_nodes = []\n self.pkl_part.Xi_I_1_2_nodes = [M_r_1_0_I]\n else: # Reload pickle part from backup.\n self.pkl_part = pkl_parts[\"influence_path\"]\n\n return None\n\n\n\n def reset_evolve_procedure(self, num_n_steps, k, forced_gc):\n # DM: Detailed manuscript.\n\n # The 'evolve procedure' refers to the step-evolution procedure\n # implemented for the spinbosonchain.state.SystemState class, which\n # represents the system state. An 'evolution step' consists of a\n # sequence of 'k-steps', where in each k-step, a MPO is constructed\n # which is applied to the MPS representing the system state [given by\n # one of Eqs. (215)-(217) of DM depending on scenario]. Each of these\n # MPO's requires a set of influence nodes taken from the MPS's\n # representing the local influence paths. Details on the MPO\n # construction procedure are given in Sec. 4.8 of DM. Instances of\n # k-steps are given by Eqs. (219), (220), (221), (223), and (224) of\n # DM. The current method here essentially calculates the required set of\n # influence nodes to perform the first k-step of the current evolution\n # step.\n\n # The 'first iteration procedure' involves executing Eqs. (130)-(137) of\n # DM, whereas the 'second iteration procedure' involves executing\n # Eqs. (146)-(154) of DM.\n n = self.pkl_part.n\n m2 = max(0, self.max_m2_in_first_iteration_procedure(n)+1)\n n += num_n_steps\n\n self.pkl_part.n = n\n self.pkl_part.m2 = m2\n\n while self.first_m2_step_seq_in_reset_evolve_procedure_not_finished(k):\n self.m2_step()\n if forced_gc:\n gc.collect() # Enforce garbage collection.\n\n if self.pkl_part.m2 <= self.max_m2_in_first_iteration_procedure(n):\n return None\n\n # At this point the first iteration procedure as finished, so the\n # second procedure is initiated. The following code block is essentially\n # Eq. (146) of DM.\n self.pkl_part.Xi_I_dashv_1_nodes = []\n self.pkl_part.Xi_I_dashv_2_nodes = self.pkl_part.Xi_I_1_2_nodes[:]\n\n while self.second_m2_step_seq_in_reset_evolve_procedure_not_finished(k):\n self.m2_step()\n if forced_gc:\n gc.collect() # Enforce garbage collection.\n\n return None\n\n\n\n def first_m2_step_seq_in_reset_evolve_procedure_not_finished(self, k):\n # See comments in method reset_evolve_procedure for context.\n\n m2_limit = self.max_m2_in_first_iteration_procedure(self.pkl_part.n)\n \n if (k != -1) and (self.pkl_part.alg == \"yz-noise\"):\n target_num_Xi_I_1_1_nodes = 3\n else:\n target_num_Xi_I_1_1_nodes = 1\n\n num_Xi_I_1_1_nodes = len(self.pkl_part.Xi_I_1_1_nodes)\n\n # If target_num_Xi_I_1_1_nodes of the Xi_I_1_1 nodes have been obtained\n # before iterating through all the m2 steps of the 'first procedure',\n # then the 'reset evolve procedure' is finished and we can proceed to\n # executing our first 'k-step'. Otherwise, we iterate through all the m2\n # steps of the first procedure.\n \n condition_1 = self.pkl_part.m2 <= m2_limit\n condition_2 = num_Xi_I_1_1_nodes < target_num_Xi_I_1_1_nodes\n\n return condition_1 and condition_2\n\n\n\n def second_m2_step_seq_in_reset_evolve_procedure_not_finished(self, k):\n # See comments in method reset_evolve_procedure for context.\n \n m2_limit = self.max_m2_in_second_iteration_procedure(self.pkl_part.n)\n \n if (k != -1) and (self.pkl_part.alg == \"yz-noise\"):\n target_num_Xi_I_dashv_1_nodes = 3\n else:\n target_num_Xi_I_dashv_1_nodes = 1\n\n num_Xi_I_dashv_1_nodes = len(self.pkl_part.Xi_I_dashv_1_nodes)\n\n # If target_num_Xi_I_dashv_1_nodes of the Xi_I_1_1 nodes have been\n # obtained before iterating through all the m2 steps of the 'second\n # procedure', then the 'reset evolve procedure' is finished and we can\n # proceed to executing our first 'k-step'. Otherwise, we iterate through\n # all the m2 steps of the secon procedure.\n\n condition_1 = self.pkl_part.m2 <= m2_limit\n condition_2 = num_Xi_I_dashv_1_nodes < target_num_Xi_I_dashv_1_nodes\n\n return condition_1 and condition_2\n\n\n def k_step(self, forced_gc):\n # DM: Detailed manuscript.\n\n # An 'evolution step', wherein the system state is evolved, consists of\n # a sequence of 'k-steps', where in each k-step, a MPO is constructed\n # which is applied to the MPS representing the system state [given by\n # one of Eqs. (215)-(217) of DM depending on scenario]. The role that\n # the influence paths play in a single k-step is that they construct the\n # set of influence nodes taken from the MPS's representing the local\n # influence paths that are required to construct the aforementioned MPO\n # for that k-step. Details on the MPO construction procedure are given\n # in Sec. 4.8 of DM. Instances of k-steps are given by Eqs. (219),\n # (220), (221), (223), and (224) of DM. \n\n # The 'first iteration procedure' involves executing Eqs. (130)-(137) of\n # DM, whereas the 'second iteration procedure' involves executing\n # Eqs. (146)-(154) of DM.\n n = self.pkl_part.n\n max_m2_in_first_iteration_procedure_plus_1 = \\\n self.max_m2_in_first_iteration_procedure(n)+1\n max_m2_in_second_iteration_procedure = \\\n self.max_m2_in_second_iteration_procedure(n)\n\n if ((self.pkl_part.alg == \"z-noise\")\n or (self.pkl_part.m2 == max_m2_in_second_iteration_procedure)):\n num_m2_steps = 1 # The number of m2-steps taken in current k-step.\n else:\n num_m2_steps = 3 # The number of m2-steps taken in current k-step.\n\n for _ in range(num_m2_steps):\n self.m2_step()\n if self.pkl_part.m2 == max_m2_in_first_iteration_procedure_plus_1:\n # The following code block is essentially Eq. (146) of DM.\n self.pkl_part.Xi_I_dashv_1_nodes = []\n self.pkl_part.Xi_I_dashv_2_nodes = \\\n self.pkl_part.Xi_I_1_2_nodes[:]\n if forced_gc:\n gc.collect() # Enforce garbage collection.\n\n return None\n\n\n \n def m2_step(self):\n # DM: Detailed manuscript.\n\n # This method either performs a single 'm2-step' in the 'first\n # procedure' which involves executing Eqs. (130)-(137) of DM, or the\n # 'second procedure' which involves executing Eqs. (146)-(154) of DM.\n \n m2 = self.pkl_part.m2\n n = self.pkl_part.n\n\n if m2 <= self.max_m2_in_first_iteration_procedure(n):\n mps_nodes = self.pkl_part.Xi_I_1_2_nodes\n else:\n mps_nodes = self.pkl_part.Xi_I_dashv_2_nodes\n\n # The following code block implements Eq. (131) if in first procedure,\n # and Eq. (147) if in second procedure.\n node = tn.Node(np.ones([1, 4, 1]))\n mps_nodes.append(node)\n kwargs = {\"nodes\": mps_nodes,\n \"current_orthogonal_center_idx\": len(mps_nodes) - 2}\n sbc._qr.shift_orthogonal_center_to_the_right(**kwargs)\n mps_nodes[-1] /= tn.norm(mps_nodes[-1])\n\n # Perform MPS compression for computational efficiency.\n kwargs = {\"mpo_nodes\": self.influence_mpo_factory.build(m2+1, n),\n \"mps_nodes\": mps_nodes,\n \"compress_params\": self.pkl_part.compress_params}\n sbc._mpomps.apply_finite_mpo_to_finite_mps_and_compress(**kwargs)\n\n if m2 <= self.max_m2_in_first_iteration_procedure(n):\n if self.mu_m_tau(m=m2+2) >= 1:\n # This is essentially Eq. (137) of DM.\n self.pkl_part.Xi_I_1_1_nodes.append(mps_nodes.pop(0))\n # This is essentially Eq. (136) of DM.\n self.pkl_part.Xi_I_1_2_nodes = mps_nodes\n else:\n if self.mu_m_tau(m=m2+2) >= 1:\n # This is essentially Eq. (154) of DM.\n self.pkl_part.Xi_I_dashv_1_nodes.append(mps_nodes.pop(0))\n # This is essentially Eq. (153) of DM.\n self.pkl_part.Xi_I_dashv_2_nodes = mps_nodes\n # This is essentially Eq. (156) of DM.\n self.pkl_part.Xi_I_dashv_nodes = \\\n (self.pkl_part.Xi_I_dashv_1_nodes\n + self.pkl_part.Xi_I_dashv_2_nodes)\n\n self.pkl_part.m2 += 1\n\n return None\n \n", "meta": {"hexsha": "424c7d04549d76b1c2225dc642a6c228563072c2", "size": 14219, "ext": "py", "lang": "Python", "max_stars_repo_path": "spinbosonchain/_influence/path.py", "max_stars_repo_name": "bonedog3000/spin-boson-chain", "max_stars_repo_head_hexsha": "8b8d4b91ed98d231be404b4de19ffe83dc2ace31", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "spinbosonchain/_influence/path.py", "max_issues_repo_name": "bonedog3000/spin-boson-chain", "max_issues_repo_head_hexsha": "8b8d4b91ed98d231be404b4de19ffe83dc2ace31", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "spinbosonchain/_influence/path.py", "max_forks_repo_name": "bonedog3000/spin-boson-chain", "max_forks_repo_head_hexsha": "8b8d4b91ed98d231be404b4de19ffe83dc2ace31", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-10-06T17:44:23.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-06T17:44:23.000Z", "avg_line_length": 39.717877095, "max_line_length": 80, "alphanum_fraction": 0.6299317814, "include": true, "reason": "import numpy", "num_tokens": 3516, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.5389832206876841, "lm_q2_score": 0.36658974324230986, "lm_q1q2_score": 0.19758572048381134}} {"text": "#! /usr/bin/env python\n#\n\n\"\"\" Loading, transforming and comparing the corners of Camera CCDs.\"\"\"\n\nimport numpy as np\nfrom shapely import geometry\nfrom shapely import affinity\nfrom shapely.ops import cascaded_union\nfrom descartes import PolygonPatch\n\n\n##############################\n# #\n# Camera Class #\n# #\n##############################\n\nclass Camera:\n \"\"\"\n Class for collection and manipulation of a camera's CCD corner\n coordinates. A list of CCD corner coordinates is inputted as a\n *coordsList*, resulting in a shapely.geometry.multipolygon object\n stored in *poly*. This *poly* can be geometrically translated and\n rotated to model astronomical dither patterns.\n\n Attributes:\n coordsList : *list*\n List of coordinates of the corners of each CCD in the camera.\n The *coordsList* must follow these rules:\n\n 1) Coordinates are (ra, dec) numeric pairs of the angular\n position of each camera's corners.\n 2) The *coordsList* must contain at least one CCD. If there\n is only one CCD in the *coordsList*, then it must be passed\n to the Camera as a list of length 1.\n 2) Each CCD in the *coordsList* must contain at least three\n corners.\n 4) The CCDs in the *coordsList* CANNOT overlap.\n name : *str*, optional\n Name by which to identify a Camera.\n\n Examples:\n 1) For a *coordsList* of two CCDs:\n coordsList = [ [(0,0),(0,1),(1,1),(1,0)],\n [(2,2),(2,3),(3,3),(3,2)] ]\n camera = Camera(coordsList)\n\n 2) For a *coordsList* of one CCD.\n coordsList = [ [(0,0),(0,1),(1,1),(1,0)] ]\n camera = Camera(coordsList)\n \"\"\"\n\n def __init__(self, coordsList, name=None):\n\n if not isinstance(coordsList[0], list):\n raise TypeError('coordsList must be a list of coordinates '\n 'for the corners of each CCD in the camera.')\n\n if name is not None and not isinstance(name, str):\n raise TypeError('Camera name must be a string.')\n\n # Combine corners of the CCDs in the coordsList into one poly\n polys = []\n for coords in coordsList:\n polys.append(geometry.Polygon(coords))\n self.poly = cascaded_union(polys)\n self.name = name\n\n @property\n def poly(self):\n return self.Poly\n\n @poly.setter\n def poly(self, newPoly):\n \"\"\"\n Sets the new poly and updates the Camera's coordsList\n\n Parameters:\n newPoly : *shapely.geometry.multipolygon.MultiPolygon*\n or\n *shapely.geometry.multipolygon.Polygon*\n Sets the polygon for this Camera as *newPoly*, as well\n as updating the *coordsList*.\n \"\"\"\n self.Poly = newPoly\n self.coordsList = self.get_coordsList()\n\n def get_coordsList(self):\n \"\"\"\n Returns the *coordsList* for THIS Camera's *poly*. This list will\n follow the conventions for a *coordsList* as outlined in the\n Camera Attributes.\n \"\"\"\n return self._get_coordsList(self.poly)\n\n def _get_coordsList(self, poly):\n \"\"\"\n Returns the *coordsList* for ANY Camera's *poly*. This list will\n follow the conventions for a *coordsList* as outlined in the\n Camera Attributes.\n\n Parameters:\n poly : *shapely.geometry.multipolygon.MultiPolygon*\n or\n *shapely.geometry.multipolygon.Polygon*\n Polygon from which a *coordsList* will be calculated.\n \"\"\"\n if poly.area == 0:\n # If Camera is an empty polygon\n coordsList = [[(0, 0), (0, 0), (0, 0)]]\n\n elif poly.type == 'MultiPolygon':\n # If Cameara is a collection of multiple polygons\n coordsList = []\n for p in poly:\n coords = []\n for x, y in p.exterior.coords:\n coords.append((x, y))\n coordsList.append(coords)\n\n elif poly.type == 'Polygon':\n # If Camera is a single polygon\n coords = []\n for x, y in poly.exterior.coords:\n coords.append((x, y))\n coordsList = [coords]\n\n return coordsList\n\n def copy(self):\n \"\"\"\n Returns a copy of the current Camera.\n \"\"\"\n return Camera(self.coordsList)\n\n def buffer(self, buffer, resolution=16):\n \"\"\"\n Expands the coundaries of each polygon in the Camera's *poly*\n by the size of the *buffer*.\n Parameters:\n buffer : *float*\n The number of degrees by which each polygon in *poly*\n will be expanded.\n resolution : *int*\n The number of points added to the camera *poly* to\n approximate the additional buffer\n \"\"\"\n self.poly = self.poly.buffer(buffer, resolution)\n\n def expand_ra(self):\n \"\"\"\n Applys a spherical distortion to the Camera's coordinates to\n adjust for the declination of the Camera's current position.\n This function must be called AFTER geometric transformations\n (translate, rotate) have been applied.\n \"\"\"\n centroid = self.get_center()\n polys = []\n for coords in self.coordsList:\n new_coords = []\n for (coordX, coordY) in coords:\n coordX -= centroid[0]\n coordX /= np.cos(np.radians(coordY))\n coordX += centroid[0]\n new_coords.append((coordX, coordY))\n polys.append(geometry.Polygon(new_coords))\n self.poly = cascaded_union(polys)\n\n def collapse_ra(self):\n \"\"\"\n Applys a spherical distortion to the Camera's coordinates to\n adjust for the declination of the Camera's current position.\n This function must be called BEFORE geometric transformations\n (translate, rotate) have been applied.\n \"\"\"\n centroid = self.get_center()\n polys = []\n for coords in self.coordsList:\n new_coords = []\n for (coordX, coordY) in coords:\n coordX -= centroid[0]\n coordX *= np.cos(np.radians(coordY))\n coordX += centroid[0]\n new_coords.append((coordX, coordY))\n polys.append(geometry.Polygon(new_coords))\n self.poly = cascaded_union(polys)\n\n def rotate(self, degrees=0, origin=False):\n \"\"\"\n Rotates the Camera's *poly* by *degrees*. This is a rotation\n around each polygon's center, not the origin (0,0). Rotation\n can be performed around the origin by setting the *origin* flag to\n True. Prior to and after rotation, *poly* is adjusted to account\n for spherical distrotion effects at different declinations.\n\n Parameters:\n degrees : *float*\n The number of degrees by which to rotate *poly*. Positive\n angles are counter-clockwise and negative are clockwise\n rotations.\n origin : *bool*\n Rotates the Camera's *poly* around the center of the *poly*\n bounding box. If set to False, rotation will be performed\n around the origin.\n \"\"\"\n self.collapse_ra()\n if not origin:\n self.poly = affinity.rotate(self.poly, degrees)\n else:\n self.poly = affinity.rotate(self.poly, degrees, origin=(0, 0))\n self.expand_ra()\n\n def translate(self, raOffset=0, decOffset=0):\n \"\"\"\n Translates the Camera's *poly* by *raOffset* and *decOffset*.\n Prior to and after rotation, the Camera's *poly* is adjusted\n to account for spherical distrotion effects at different\n declinations.\n\n Parameters:\n raOffset : *float*\n The number of degrees by which to translate *poly* in\n right ascension.\n decOffset : *float*\n The number of degrees by which to translate *poly* in\n declination.\n \"\"\"\n self.collapse_ra()\n self.poly = affinity.translate(self.poly,\n xoff=raOffset,\n yoff=decOffset)\n self.expand_ra()\n\n def get_radius(self):\n \"\"\"\n Returns the radius of the smallest circle which could encompass\n all of the polygons in the Camera's *poly*. If the Camera's *poly*\n is centered around (0,0), the radius is equal to the distance to\n the polygon corner furthest from the Camera's center. Radius is\n returned in degrees.\n \"\"\"\n center = self.get_center()\n radius_list = []\n for coords in self.coordsList:\n for coord in coords:\n radius = np.sqrt((coord[0] - center[0]) ** 2. +\n (coord[1] - center[1]) ** 2.)\n radius_list.append(radius)\n return np.max(radius_list)\n\n def get_area(self):\n \"\"\"\n Returns the total area of all polygons in the Camera's *poly*.\n Area is returned in square degrees.\n \"\"\"\n return self.poly.area\n\n def get_limits(self):\n \"\"\"\n Returns the coordinates of the smallest box which could surround\n all of the polygons in the Camera's *poly*. Limits are returned\n in degrees.\n\n Returns:\n ra_lim, dec_lim : *tuple* of *floats*\n Two tuples, each containing the range of the Camera's *poly*\n in right ascension and declination respectively.\n \"\"\"\n if self.poly.type == 'Polygon':\n # If Camera is a single polygon\n xArr = []\n yArr = []\n for x, y in self.poly.exterior.coords:\n xArr.append(x)\n yArr.append(y)\n else:\n # If Camera is a collection of multiple polygons\n xArr = []\n yArr = []\n for poly in self.poly:\n for x, y in poly.exterior.coords:\n xArr.append(x)\n yArr.append(y)\n\n ra_lim = (min(xArr), max(xArr))\n dec_lim = (min(yArr), max(yArr))\n\n return ra_lim, dec_lim\n\n def get_center(self, raOffset=0, decOffset=0):\n \"\"\"\n Returns the geometric center of the smallest box which could\n surround all of the polygons in the Camera's *poly*. The center\n is returned in degrees. User can apply a forced offset to the\n right ascension or declination of the center if there is a known\n asymmetry in the Camera's design.\n\n Parameters:\n raOffset : *float*\n The number of degrees by which to offset the *poly* center\n in right ascension.\n decOffset : *float*\n The number of degrees by which to offset the *poly* center\n in declination.\n\n Returns:\n centerRa, centerDec : *float*\n Two floats at the center location of the Camera's *poly*.\n \"\"\"\n bounds = self.poly.bounds\n centerRa = np.mean([bounds[0], bounds[2]]) + raOffset\n centerDec = np.mean([bounds[1], bounds[3]]) + decOffset\n return centerRa, centerDec\n\n def get_centroid(self, raOffset=0, decOffset=0):\n \"\"\"\n Returns the geometric centroid of the Camera's *poly*, as\n calculated by the Shapely package. The centroid is returned in\n degrees. User can apply a forced offset to the right ascension or\n declination to the centroid if there is a known asymmetry in the\n Camera's design.\n\n Parameters:\n raOffset : *float*\n The number of degrees by which to offset the *poly*\n centroid in right ascension.\n decOffset : *float*\n The number of degrees by which to offset the *poly*\n centroid in declination.\n\n Returns:\n centroidRa, centroidDec : *float*\n Two floats at the centroid location of the Camera's *poly*.\n \"\"\"\n if self.poly.type == 'Polygon':\n for x, y in self.poly.centroid.coords:\n return (x, y)\n else:\n centroidXList = []\n centroidYList = []\n for poly in self.poly:\n for x, y in self.poly.centroid.coords:\n centroidXList.append(x)\n centroidYList.append(y)\n\n centroidRa = np.mean(centroidXList) + raOffset\n centroidDec = np.mean(centroidYList) + decOffset\n return centroidRa, centroidDec\n\n def intersect(self, camera):\n \"\"\"\n Calculates the intersection between this Camera's *poly* and the\n *poly* of the *camera* passed as a parameter. The intersection is\n then returned as a Camera object.\n\n Parameters:\n camera : *camera.Camera* object\n An object from the camera.Camera class containing a *poly*\n and a *coordsList*.\n\n Returns:\n camera : *camera.Camera* object\n An object from the camera.Camera class that is the\n intersection between this Camera and the *camera*\n parameter.\n \"\"\"\n intersectPoly = self.poly.intersection(camera.poly)\n coordsList = self._get_coordsList(intersectPoly)\n return Camera(coordsList)\n\n def union(self, camera):\n \"\"\"\n Calculates the union between this Camera's *poly* and the\n *poly* of the *camera* passed as a parameter. The union is\n then returned as a Camera object.\n\n Parameters:\n camera : *camera.Camera* object\n An object from the camera.Camera class containing a *poly*\n and a *coordsList*.\n\n Returns:\n camera : *camera.Camera* object\n An object from the camera.Camera class that is the\n union between this Camera and the *camera*\n parameter.\n \"\"\"\n unionPoly = cascaded_union([self.poly, camera.poly])\n coordsList = self._get_coordsList(unionPoly)\n return Camera(coordsList)\n\n def difference(self, camera):\n \"\"\"\n Calculates the difference between this Camera's *poly* and the\n *poly* of the *camera* passed as a parameter. The difference is\n then returned as a Camera object.\n\n Parameters:\n camera : *camera.Camera* object\n An object from the camera.Camera class containing a *poly*\n and a *coordsList*.\n\n Returns:\n camera : *camera.Camera* object\n An object from the camera.Camera class that is the\n difference between this Camera and the *camera*\n parameter.\n \"\"\"\n differencePoly = self.poly.difference(camera.poly)\n coordsList = self._get_coordsList(differencePoly)\n return Camera(coordsList)\n\n def plot(self, ax,\n color='k',\n alpha=0.5,\n xlim=None,\n ylim=None):\n \"\"\"\n Plots the Camera's *poly* onto an axis object from Matplotlib.\n The user can specify the color and transparency of *poly*. Unless\n the xlim and ylim of the Matplotlib axis is specified by the user,\n this command will set the limits of the axis to surround just the\n Camera's *poly*.\n\n Parameters:\n ax : *matplotlib.axes._subplots.AxesSubplot*\n A Matplotlib axes object from the plt.subplots() command.\n color : *str*\n A color string compatible with a Matplotlib axis specifying\n the color of the *poly*.\n alpha : *float*\n A number between 0 and 1 specifying the transparency of\n the *poly*\n xlim : *tuple* of *floats*\n The range of x values with which to plot the *poly*\n ylim : *tuple* of *floats*\n The range of y values with which to plot the *poly*\n\n Example:\n 1) For a single Camera object\n camera = Camera(coordsList)\n fig,ax = plt.subplots()\n camera.plot(ax, color='g', alpha=0.3)\n\n 2) For multiple Camera objects\n camera = Camera(coordsList)\n camera2 = Camera(coordsList)\n camera2.translate(raOffset=1.0)\n fig,ax = plt.subplots()\n camera.plot(ax,\n color='g',\n alpha=0.3,\n xlim=(-2,2),\n ylim=(-2,2))\n camera2.plot(ax,\n color='b',\n alpha=0.3,\n xlim=(-2,2),\n ylim=(-2,2))\n \"\"\"\n ax.add_patch(PolygonPatch(self.poly,\n fc=color,\n alpha=alpha))\n\n if xlim is None or ylim is None:\n xlimPoly, ylimPoly = self.get_limits()\n\n if xlim is None:\n ax.set_xlim(xlimPoly)\n else:\n ax.set_xlim(xlim)\n\n if ylim is None:\n ax.set_ylim(ylimPoly)\n else:\n ax.set_ylim(ylim)\n\n\nemptyCamera = Camera([[(0, 0), (0, 0), (0, 0)]])\n\n\n##############################\n# #\n# Return Known Cameras #\n# #\n##############################\n\ndef return_machoCamera():\n \"\"\"\n Returns the CCD coordinates of the MACHO camera as a camera.Camera\n object.\n \"\"\"\n from skysight import corners\n corners = corners.load_machoCorners()\n machoCamera = Camera([corners], name='macho')\n return machoCamera\n\n\ndef return_hscCamera():\n \"\"\"\n Returns the CCD coordinates of the Hyper-Supreme Camera as a\n camera.Camera object.\n \"\"\"\n from skysight import corners\n corners = corners.load_hscCorners()\n hscCamera = Camera(corners, name='hsc')\n return hscCamera\n\n\ndef return_decamCamera():\n \"\"\"\n Returns the CCD coordinates of the Dark Energy Camera as a\n camera.Camera object.\n \"\"\"\n from skysight import corners\n corners = corners.load_decamCorners()\n decamCamera = Camera(corners, name='decam')\n return decamCamera\n", "meta": {"hexsha": "26c0dc8fb2b5c662d18af7f597d1e9327d56391b", "size": 18569, "ext": "py", "lang": "Python", "max_stars_repo_path": "skysight/camera.py", "max_stars_repo_name": "MichaelMedford/skysight", "max_stars_repo_head_hexsha": "121ac7134a3d45d5359243d95379ee1fa085532d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "skysight/camera.py", "max_issues_repo_name": "MichaelMedford/skysight", "max_issues_repo_head_hexsha": "121ac7134a3d45d5359243d95379ee1fa085532d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "skysight/camera.py", "max_forks_repo_name": "MichaelMedford/skysight", "max_forks_repo_head_hexsha": "121ac7134a3d45d5359243d95379ee1fa085532d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.7096153846, "max_line_length": 76, "alphanum_fraction": 0.5529646185, "include": true, "reason": "import numpy", "num_tokens": 3885, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5389832206876841, "lm_q2_score": 0.36658973632215985, "lm_q1q2_score": 0.1975857167539666}} {"text": "# -*- coding: utf-8 -*-\n\"\"\"\nColour\n======\n\n`Colour `_ is an open-source\n`Python `_ package providing a comprehensive number of\nalgorithms and datasets for colour science.\n\nIt is freely available under the\n`New BSD License `_ terms.\n\nSub-packages\n------------\n- adaptation: Chromatic adaptation models and transformations.\n- algebra: Algebra utilities.\n- appearance: Colour appearance models.\n- biochemistry: Biochemistry computations.\n- blindness: Colour vision deficiency models.\n- characterisation: Colour fitting and camera characterisation.\n- colorimetry: Core objects for colour computations.\n- constants: *CIE* and *CODATA* constants.\n- continuous: Base objects for continuous data representation.\n- contrast: Objects for contrast sensitivity computation.\n- corresponding: Corresponding colour chromaticities computations.\n- difference: Colour difference computations.\n- examples: Examples for the sub-packages.\n- graph: Graph for automatic colour conversions.\n- io: Input / output objects for reading and writing data.\n- models: Colour models.\n- notation: Colour notation systems.\n- phenomena: Computation of various optical phenomena.\n- plotting: Diagrams, figures, etc...\n- quality: Colour quality computation.\n- recovery: Reflectance recovery.\n- temperature: Colour temperature and correlated colour temperature\n computation.\n- utilities: Various utilities and data structures.\n- volume: Colourspace volumes computation and optimal colour stimuli.\n\"\"\"\n\nfrom __future__ import absolute_import\n\nimport numpy as np\nimport sys\n\nfrom .utilities.deprecation import ModuleAPI, build_API_changes\nfrom .utilities.documentation import is_documentation_building\nfrom .utilities.common import (domain_range_scale, get_domain_range_scale,\n set_domain_range_scale)\n\nfrom .adaptation import (CHROMATIC_ADAPTATION_METHODS,\n CHROMATIC_ADAPTATION_TRANSFORMS,\n CMCCAT2000_VIEWING_CONDITIONS, chromatic_adaptation)\nfrom .algebra import (CubicSplineInterpolator, Extrapolator,\n KernelInterpolator, NearestNeighbourInterpolator,\n LinearInterpolator, NullInterpolator, PchipInterpolator,\n SpragueInterpolator, TABLE_INTERPOLATION_METHODS,\n kernel_cardinal_spline, kernel_lanczos, kernel_linear,\n kernel_nearest_neighbour, kernel_sinc,\n table_interpolation, lagrange_coefficients)\nfrom .colorimetry import (\n ASTME308_PRACTISE_SHAPE, BANDPASS_CORRECTION_METHODS, CMFS,\n DEFAULT_SPECTRAL_SHAPE, HUNTERLAB_ILLUMINANTS, ILLUMINANTS,\n ILLUMINANTS_SDS, LEFS, LIGHTNESS_METHODS, LIGHT_SOURCES, LIGHT_SOURCES_SDS,\n LMS_CMFS, LUMINANCE_METHODS, MULTI_SD_TO_XYZ_METHODS,\n MultiSpectralDistributions, PHOTOPIC_LEFS, RGB_CMFS, SCOTOPIC_LEFS,\n SD_GAUSSIAN_METHODS, SD_MULTI_LEDS_METHODS, SD_SINGLE_LED_METHODS,\n SD_TO_XYZ_METHODS, STANDARD_OBSERVERS_CMFS, SpectralDistribution,\n SpectralShape, WHITENESS_METHODS, YELLOWNESS_METHODS, bandpass_correction,\n colorimetric_purity, complementary_wavelength, dominant_wavelength,\n excitation_purity, lightness, luminance, luminous_efficacy,\n luminous_efficiency, luminous_flux, multi_sds_to_XYZ,\n sd_CIE_standard_illuminant_A, sd_CIE_illuminant_D_series, sd_blackbody,\n sd_constant, sd_gaussian, sd_mesopic_luminous_efficiency_function,\n sd_multi_leds, sd_ones, sd_single_led, sd_zeros, sd_to_XYZ,\n wavelength_to_XYZ, whiteness, yellowness)\nfrom .blindness import (\n CVD_MATRICES_MACHADO2010, anomalous_trichromacy_cmfs_Machado2009,\n anomalous_trichromacy_matrix_Machado2009, cvd_matrix_Machado2009)\nfrom .appearance import (\n ATD95_Specification, CAM16_Specification, CAM16_VIEWING_CONDITIONS,\n CAM16_to_XYZ, CIECAM02_Specification, CIECAM02_VIEWING_CONDITIONS,\n CIECAM02_to_XYZ, HUNT_VIEWING_CONDITIONS, Hunt_Specification,\n LLAB_Specification, LLAB_VIEWING_CONDITIONS, Nayatani95_Specification,\n RLAB_D_FACTOR, RLAB_Specification, RLAB_VIEWING_CONDITIONS, XYZ_to_ATD95,\n XYZ_to_CAM16, XYZ_to_CIECAM02, XYZ_to_Hunt, XYZ_to_LLAB, XYZ_to_Nayatani95,\n XYZ_to_RLAB)\nfrom .difference import DELTA_E_METHODS, delta_E\nfrom .characterisation import (\n CAMERAS_RGB_SPECTRAL_SENSITIVITIES, COLOURCHECKERS, COLOURCHECKERS_SDS,\n DISPLAYS_RGB_PRIMARIES, POLYNOMIAL_EXPANSION_METHODS, polynomial_expansion,\n COLOUR_CORRECTION_MATRIX_METHODS, colour_correction_matrix,\n COLOUR_CORRECTION_METHODS, colour_correction)\nfrom .io import (LUT1D, LUT3x1D, LUT3D, LUTSequence, READ_IMAGE_METHODS,\n SpectralDistribution_IESTM2714, WRITE_IMAGE_METHODS,\n read_image, read_LUT, read_sds_from_csv_file,\n read_sds_from_xrite_file, read_spectral_data_from_csv_file,\n write_image, write_LUT, write_sds_to_csv_file)\nfrom .models import (\n CAM02LCD_to_JMh_CIECAM02, CAM02SCD_to_JMh_CIECAM02,\n CAM02UCS_to_JMh_CIECAM02, CAM16LCD_to_JMh_CAM16, CAM16SCD_to_JMh_CAM16,\n CAM16UCS_to_JMh_CAM16, CCTF_DECODINGS, CCTF_ENCODINGS, CMYK_to_CMY,\n CMY_to_CMYK, CMY_to_RGB, CV_range, DIN99_to_Lab, EOTFS, EOTF_INVERSES,\n HDR_CIELAB_METHODS, HDR_IPT_METHODS, HSL_to_RGB, HSV_to_RGB,\n Hunter_Lab_to_XYZ, Hunter_Rdab_to_XYZ, ICTCP_to_RGB, IPT_hue_angle,\n IPT_to_XYZ, JMh_CAM16_to_CAM16LCD, JMh_CAM16_to_CAM16SCD,\n JMh_CAM16_to_CAM16UCS, JMh_CIECAM02_to_CAM02LCD, JMh_CIECAM02_to_CAM02SCD,\n JMh_CIECAM02_to_CAM02UCS, JzAzBz_to_XYZ, LCHab_to_Lab, LCHuv_to_Luv,\n LOG_DECODINGS, LOG_ENCODINGS, Lab_to_DIN99, Lab_to_LCHab, Lab_to_XYZ,\n Luv_to_LCHuv, Luv_to_XYZ, Luv_to_uv, Luv_uv_to_xy,\n MACADAM_1942_ELLIPSES_DATA, OETFS, OETF_INVERSES, OOTFS, OOTF_INVERSES,\n OSA_UCS_to_XYZ, POINTER_GAMUT_BOUNDARIES, POINTER_GAMUT_DATA,\n POINTER_GAMUT_ILLUMINANT, Prismatic_to_RGB, RGB_COLOURSPACES,\n RGB_Colourspace, RGB_luminance, RGB_luminance_equation, RGB_to_CMY,\n RGB_to_HSL, RGB_to_HSV, RGB_to_ICTCP, RGB_to_Prismatic, RGB_to_RGB,\n RGB_to_RGB_matrix, RGB_to_XYZ, RGB_to_YCbCr, RGB_to_YcCbcCrc, RGB_to_YCoCg,\n UCS_to_XYZ, UCS_to_uv, UCS_uv_to_xy, UVW_to_XYZ, XYZ_to_Hunter_Lab,\n XYZ_to_Hunter_Rdab, XYZ_to_IPT, XYZ_to_JzAzBz, XYZ_to_K_ab_HunterLab1966,\n XYZ_to_Lab, XYZ_to_Luv, XYZ_to_OSA_UCS, XYZ_to_RGB, XYZ_to_UCS, XYZ_to_UVW,\n XYZ_to_hdr_CIELab, XYZ_to_hdr_IPT, XYZ_to_sRGB, XYZ_to_xy, XYZ_to_xyY,\n YCBCR_WEIGHTS, YCbCr_to_RGB, YcCbcCrc_to_RGB, YCoCg_to_RGB, cctf_decoding,\n cctf_encoding, chromatically_adapted_primaries, eotf, eotf_inverse,\n full_to_legal, gamma_function, hdr_CIELab_to_XYZ, hdr_IPT_to_XYZ,\n legal_to_full, linear_function, log_decoding, log_encoding,\n normalised_primary_matrix, oetf, oetf_inverse, ootf, ootf_inverse,\n primaries_whitepoint, sd_to_aces_relative_exposure_values, sRGB_to_XYZ,\n uv_to_Luv, uv_to_UCS, xyY_to_XYZ, xyY_to_xy, xy_to_Luv_uv, xy_to_UCS_uv,\n xy_to_XYZ, xy_to_xyY)\nfrom .corresponding import (\n BRENEMAN_EXPERIMENTS, BRENEMAN_EXPERIMENTS_PRIMARIES_CHROMATICITIES,\n CORRESPONDING_CHROMATICITIES_PREDICTION_MODELS, CorrespondingColourDataset,\n CorrespondingChromaticitiesPrediction,\n corresponding_chromaticities_prediction)\nfrom .contrast import (CONTRAST_SENSITIVITY_METHODS,\n contrast_sensitivity_function)\nfrom .phenomena import (rayleigh_scattering, scattering_cross_section,\n sd_rayleigh_scattering)\nfrom .notation import (MUNSELL_COLOURS, MUNSELL_VALUE_METHODS,\n munsell_colour_to_xyY, munsell_value,\n xyY_to_munsell_colour)\nfrom .quality import (COLOUR_QUALITY_SCALE_METHODS, colour_quality_scale,\n colour_rendering_index)\nfrom .recovery import XYZ_TO_SD_METHODS, XYZ_to_sd\nfrom .temperature import (CCT_TO_UV_METHODS, CCT_TO_XY_METHODS, CCT_to_uv,\n CCT_to_xy, UV_TO_CCT_METHODS, XY_TO_CCT_METHODS,\n uv_to_CCT, xy_to_CCT)\nfrom .volume import (\n ILLUMINANTS_OPTIMAL_COLOUR_STIMULI, RGB_colourspace_limits,\n RGB_colourspace_pointer_gamut_coverage_MonteCarlo,\n RGB_colourspace_visible_spectrum_coverage_MonteCarlo,\n RGB_colourspace_volume_MonteCarlo,\n RGB_colourspace_volume_coverage_MonteCarlo, is_within_macadam_limits,\n is_within_mesh_volume, is_within_pointer_gamut, is_within_visible_spectrum)\nfrom .graph import describe_conversion_path, convert\n\n__author__ = 'Colour Developers'\n__copyright__ = 'Copyright (C) 2013-2019 - Colour Developers'\n__license__ = 'New BSD License - https://opensource.org/licenses/BSD-3-Clause'\n__maintainer__ = 'Colour Developers'\n__email__ = 'colour-developers@colour-science.org'\n__status__ = 'Production'\n\n__all__ = [\n 'domain_range_scale', 'get_domain_range_scale', 'set_domain_range_scale'\n]\n__all__ += [\n 'CHROMATIC_ADAPTATION_METHODS', 'CHROMATIC_ADAPTATION_TRANSFORMS',\n 'CMCCAT2000_VIEWING_CONDITIONS', 'chromatic_adaptation'\n]\n__all__ += [\n 'CubicSplineInterpolator', 'Extrapolator', 'KernelInterpolator',\n 'NearestNeighbourInterpolator', 'LinearInterpolator', 'NullInterpolator',\n 'PchipInterpolator', 'SpragueInterpolator', 'TABLE_INTERPOLATION_METHODS',\n 'kernel_cardinal_spline', 'kernel_lanczos', 'kernel_linear',\n 'kernel_nearest_neighbour', 'kernel_sinc', 'table_interpolation',\n 'lagrange_coefficients'\n]\n__all__ += [\n 'ASTME308_PRACTISE_SHAPE', 'BANDPASS_CORRECTION_METHODS', 'CMFS',\n 'DEFAULT_SPECTRAL_SHAPE', 'HUNTERLAB_ILLUMINANTS', 'ILLUMINANTS',\n 'ILLUMINANTS_SDS', 'LEFS', 'LIGHTNESS_METHODS', 'LIGHT_SOURCES',\n 'LIGHT_SOURCES_SDS', 'LMS_CMFS', 'LUMINANCE_METHODS',\n 'MULTI_SD_TO_XYZ_METHODS', 'MultiSpectralDistributions', 'PHOTOPIC_LEFS',\n 'RGB_CMFS', 'SCOTOPIC_LEFS', 'SD_GAUSSIAN_METHODS',\n 'SD_MULTI_LEDS_METHODS', 'SD_SINGLE_LED_METHODS', 'SD_TO_XYZ_METHODS',\n 'STANDARD_OBSERVERS_CMFS', 'SpectralDistribution', 'SpectralShape',\n 'WHITENESS_METHODS', 'YELLOWNESS_METHODS', 'bandpass_correction',\n 'colorimetric_purity', 'complementary_wavelength', 'dominant_wavelength',\n 'excitation_purity', 'lightness', 'luminance', 'luminous_efficacy',\n 'luminous_efficiency', 'luminous_flux', 'multi_sds_to_XYZ',\n 'sd_CIE_standard_illuminant_A', 'sd_CIE_illuminant_D_series',\n 'sd_blackbody', 'sd_constant', 'sd_gaussian',\n 'sd_mesopic_luminous_efficiency_function', 'sd_multi_leds', 'sd_ones',\n 'sd_zeros', 'sd_single_led', 'sd_to_XYZ', 'wavelength_to_XYZ', 'whiteness',\n 'yellowness'\n]\n__all__ += [\n 'CVD_MATRICES_MACHADO2010', 'anomalous_trichromacy_cmfs_Machado2009',\n 'anomalous_trichromacy_matrix_Machado2009', 'cvd_matrix_Machado2009'\n]\n__all__ += [\n 'ATD95_Specification', 'CAM16_Specification', 'CAM16_VIEWING_CONDITIONS',\n 'CAM16_to_XYZ', 'CIECAM02_Specification', 'CIECAM02_VIEWING_CONDITIONS',\n 'CIECAM02_to_XYZ', 'HUNT_VIEWING_CONDITIONS', 'Hunt_Specification',\n 'LLAB_Specification', 'LLAB_VIEWING_CONDITIONS',\n 'Nayatani95_Specification', 'RLAB_D_FACTOR', 'RLAB_Specification',\n 'RLAB_VIEWING_CONDITIONS', 'XYZ_to_ATD95', 'XYZ_to_CAM16',\n 'XYZ_to_CIECAM02', 'XYZ_to_Hunt', 'XYZ_to_LLAB', 'XYZ_to_Nayatani95',\n 'XYZ_to_RLAB'\n]\n__all__ += ['DELTA_E_METHODS', 'delta_E']\n__all__ += [\n 'CAMERAS_RGB_SPECTRAL_SENSITIVITIES', 'COLOURCHECKERS',\n 'COLOURCHECKERS_SDS', 'DISPLAYS_RGB_PRIMARIES',\n 'POLYNOMIAL_EXPANSION_METHODS', 'polynomial_expansion',\n 'COLOUR_CORRECTION_MATRIX_METHODS', 'colour_correction_matrix',\n 'COLOUR_CORRECTION_METHODS', 'colour_correction'\n]\n__all__ += [\n 'LUT1D', 'LUT3x1D', 'LUT3D', 'LUTSequence', 'READ_IMAGE_METHODS',\n 'SpectralDistribution_IESTM2714', 'WRITE_IMAGE_METHODS', 'read_image',\n 'read_LUT', 'read_sds_from_csv_file', 'read_sds_from_xrite_file',\n 'read_spectral_data_from_csv_file', 'write_image', 'write_LUT',\n 'write_sds_to_csv_file'\n]\n__all__ += [\n 'CAM02LCD_to_JMh_CIECAM02', 'CAM02SCD_to_JMh_CIECAM02',\n 'CAM02UCS_to_JMh_CIECAM02', 'CAM16LCD_to_JMh_CAM16',\n 'CAM16SCD_to_JMh_CAM16', 'CAM16UCS_to_JMh_CAM16', 'CCTF_DECODINGS',\n 'CCTF_ENCODINGS', 'CMYK_to_CMY', 'CMY_to_CMYK', 'CMY_to_RGB', 'CV_range',\n 'DIN99_to_Lab', 'EOTFS', 'EOTF_INVERSES', 'HDR_CIELAB_METHODS',\n 'HDR_IPT_METHODS', 'HSL_to_RGB', 'HSV_to_RGB', 'Hunter_Lab_to_XYZ',\n 'Hunter_Rdab_to_XYZ', 'ICTCP_to_RGB', 'IPT_hue_angle', 'IPT_to_XYZ',\n 'JMh_CAM16_to_CAM16LCD', 'JMh_CAM16_to_CAM16SCD', 'JMh_CAM16_to_CAM16UCS',\n 'JMh_CIECAM02_to_CAM02LCD', 'JMh_CIECAM02_to_CAM02SCD',\n 'JMh_CIECAM02_to_CAM02UCS', 'JzAzBz_to_XYZ', 'LCHab_to_Lab',\n 'LCHuv_to_Luv', 'LOG_DECODINGS', 'LOG_ENCODINGS', 'Lab_to_DIN99',\n 'Lab_to_LCHab', 'Lab_to_XYZ', 'Luv_to_LCHuv', 'Luv_to_XYZ', 'Luv_to_uv',\n 'Luv_uv_to_xy', 'OETFS', 'OETF_INVERSES', 'OOTFS',\n 'MACADAM_1942_ELLIPSES_DATA', 'OOTF_INVERSES', 'OSA_UCS_to_XYZ',\n 'POINTER_GAMUT_BOUNDARIES', 'POINTER_GAMUT_DATA',\n 'POINTER_GAMUT_ILLUMINANT', 'Prismatic_to_RGB', 'RGB_COLOURSPACES',\n 'RGB_Colourspace', 'RGB_luminance', 'RGB_luminance_equation', 'RGB_to_CMY',\n 'RGB_to_HSL', 'RGB_to_HSV', 'RGB_to_ICTCP', 'RGB_to_Prismatic',\n 'RGB_to_RGB', 'RGB_to_RGB_matrix', 'RGB_to_XYZ', 'RGB_to_YCbCr',\n 'RGB_to_YcCbcCrc', 'RGB_to_YCoCg', 'UCS_to_XYZ', 'UCS_to_uv',\n 'UCS_uv_to_xy', 'UVW_to_XYZ', 'XYZ_to_Hunter_Lab', 'XYZ_to_Hunter_Rdab',\n 'XYZ_to_IPT', 'XYZ_to_JzAzBz', 'XYZ_to_K_ab_HunterLab1966', 'XYZ_to_Lab',\n 'XYZ_to_Luv', 'XYZ_to_OSA_UCS', 'XYZ_to_RGB', 'XYZ_to_UCS', 'XYZ_to_UVW',\n 'XYZ_to_hdr_CIELab', 'XYZ_to_hdr_IPT', 'XYZ_to_sRGB', 'XYZ_to_xy',\n 'XYZ_to_xyY', 'YCBCR_WEIGHTS', 'YCbCr_to_RGB', 'YcCbcCrc_to_RGB',\n 'YCoCg_to_RGB', 'cctf_decoding', 'cctf_encoding',\n 'chromatically_adapted_primaries', 'eotf', 'eotf_inverse', 'full_to_legal',\n 'gamma_function', 'hdr_CIELab_to_XYZ', 'hdr_IPT_to_XYZ', 'legal_to_full',\n 'linear_function', 'log_decoding', 'log_encoding',\n 'normalised_primary_matrix', 'oetf', 'oetf_inverse', 'ootf',\n 'ootf_inverse', 'primaries_whitepoint',\n 'sd_to_aces_relative_exposure_values', 'sRGB_to_XYZ', 'uv_to_Luv',\n 'uv_to_UCS', 'xyY_to_XYZ', 'xyY_to_xy', 'xy_to_Luv_uv', 'xy_to_UCS_uv',\n 'xy_to_XYZ', 'xy_to_xyY'\n]\n__all__ += [\n 'BRENEMAN_EXPERIMENTS', 'BRENEMAN_EXPERIMENTS_PRIMARIES_CHROMATICITIES',\n 'CORRESPONDING_CHROMATICITIES_PREDICTION_MODELS',\n 'CorrespondingColourDataset', 'CorrespondingChromaticitiesPrediction',\n 'corresponding_chromaticities_prediction'\n]\n__all__ += ['CONTRAST_SENSITIVITY_METHODS', 'contrast_sensitivity_function']\n__all__ += [\n 'rayleigh_scattering', 'scattering_cross_section', 'sd_rayleigh_scattering'\n]\n__all__ += [\n 'MUNSELL_COLOURS', 'MUNSELL_VALUE_METHODS', 'munsell_colour_to_xyY',\n 'munsell_value', 'xyY_to_munsell_colour'\n]\n__all__ += [\n 'COLOUR_QUALITY_SCALE_METHODS', 'colour_quality_scale',\n 'colour_rendering_index'\n]\n__all__ += ['XYZ_TO_SD_METHODS', 'XYZ_to_sd']\n__all__ += [\n 'CCT_TO_UV_METHODS', 'CCT_TO_XY_METHODS', 'CCT_to_uv', 'CCT_to_xy',\n 'UV_TO_CCT_METHODS', 'XY_TO_CCT_METHODS', 'uv_to_CCT', 'xy_to_CCT'\n]\n__all__ += [\n 'ILLUMINANTS_OPTIMAL_COLOUR_STIMULI', 'RGB_colourspace_limits',\n 'RGB_colourspace_pointer_gamut_coverage_MonteCarlo',\n 'RGB_colourspace_visible_spectrum_coverage_MonteCarlo',\n 'RGB_colourspace_volume_MonteCarlo',\n 'RGB_colourspace_volume_coverage_MonteCarlo', 'is_within_macadam_limits',\n 'is_within_mesh_volume', 'is_within_pointer_gamut',\n 'is_within_visible_spectrum'\n]\n__all__ += ['describe_conversion_path', 'convert']\n\n__application_name__ = 'Colour'\n\n__major_version__ = '0'\n__minor_version__ = '3'\n__change_version__ = '14'\n__version__ = '.'.join(\n (__major_version__,\n __minor_version__,\n __change_version__)) # yapf: disable\n\n# TODO: Remove legacy printing support when deemed appropriate.\ntry:\n np.set_printoptions(legacy='1.13')\nexcept TypeError: # pragma: no cover\n pass\n\n\n# ----------------------------------------------------------------------------#\n# --- API Changes and Deprecation Management ---#\n# ----------------------------------------------------------------------------#\nclass colour(ModuleAPI):\n def __getattr__(self, attribute):\n return super(colour, self).__getattr__(attribute)\n\n\ncolour.__application_name__ = __application_name__\n\ncolour.__major_version__ = __major_version__\ncolour.__minor_version__ = __minor_version__\ncolour.__change_version__ = __change_version__\ncolour.__version__ = __version__\n\n# v0.3.11\nAPI_CHANGES = {\n 'ObjectFutureAccessChange': [\n [\n 'colour.ACES_2065_1_COLOURSPACE',\n 'colour.models.ACES_2065_1_COLOURSPACE',\n ],\n [\n 'colour.ACES_CCT_COLOURSPACE',\n 'colour.models.ACES_CCT_COLOURSPACE',\n ],\n [\n 'colour.ACES_CC_COLOURSPACE',\n 'colour.models.ACES_CC_COLOURSPACE',\n ],\n [\n 'colour.ACES_CG_COLOURSPACE',\n 'colour.models.ACES_CG_COLOURSPACE',\n ],\n [\n 'colour.ACES_PROXY_COLOURSPACE',\n 'colour.models.ACES_PROXY_COLOURSPACE',\n ],\n [\n 'colour.ACES_RICD',\n 'colour.models.ACES_RICD',\n ],\n [\n 'colour.ADOBE_RGB_1998_COLOURSPACE',\n 'colour.models.ADOBE_RGB_1998_COLOURSPACE',\n ],\n [\n 'colour.ADOBE_WIDE_GAMUT_RGB_COLOURSPACE',\n 'colour.models.ADOBE_WIDE_GAMUT_RGB_COLOURSPACE',\n ],\n [\n 'colour.ALEXA_WIDE_GAMUT_COLOURSPACE',\n 'colour.models.ALEXA_WIDE_GAMUT_COLOURSPACE',\n ],\n [\n 'colour.APPLE_RGB_COLOURSPACE',\n 'colour.models.APPLE_RGB_COLOURSPACE',\n ],\n [\n 'colour.AVOGADRO_CONSTANT',\n 'colour.constants.AVOGADRO_CONSTANT',\n ],\n [\n 'colour.AbstractContinuousFunction',\n 'colour.continuous.AbstractContinuousFunction',\n ],\n [\n 'colour.BEST_RGB_COLOURSPACE',\n 'colour.models.BEST_RGB_COLOURSPACE',\n ],\n [\n 'colour.BETA_RGB_COLOURSPACE',\n 'colour.models.BETA_RGB_COLOURSPACE',\n ],\n [\n 'colour.BOLTZMANN_CONSTANT',\n 'colour.constants.BOLTZMANN_CONSTANT',\n ],\n [\n 'colour.BRADFORD_CAT',\n 'colour.adaptation.BRADFORD_CAT',\n ],\n [\n 'colour.BS_CAT',\n 'colour.adaptation.BS_CAT',\n ],\n [\n 'colour.BS_PC_CAT',\n 'colour.adaptation.BS_PC_CAT',\n ],\n [\n 'colour.BT2020_COLOURSPACE',\n 'colour.models.BT2020_COLOURSPACE',\n ],\n [\n 'colour.BT470_525_COLOURSPACE',\n 'colour.models.BT470_525_COLOURSPACE',\n ],\n [\n 'colour.BT470_625_COLOURSPACE',\n 'colour.models.BT470_625_COLOURSPACE',\n ],\n [\n 'colour.BT709_COLOURSPACE',\n 'colour.models.BT709_COLOURSPACE',\n ],\n [\n 'colour.CAM16_InductionFactors',\n 'colour.appearance.CAM16_InductionFactors',\n ],\n [\n 'colour.CAT02_BRILL_CAT',\n 'colour.adaptation.CAT02_BRILL_CAT',\n ],\n [\n 'colour.CAT02_CAT',\n 'colour.adaptation.CAT02_CAT',\n ],\n [\n 'colour.CCT_to_uv_Krystek1985',\n 'colour.temperature.CCT_to_uv_Krystek1985',\n ],\n [\n 'colour.CCT_to_uv_Ohno2013',\n 'colour.temperature.CCT_to_uv_Ohno2013',\n ],\n [\n 'colour.CCT_to_uv_Robertson1968',\n 'colour.temperature.CCT_to_uv_Robertson1968',\n ],\n [\n 'colour.CCT_to_xy_CIE_D',\n 'colour.temperature.CCT_to_xy_CIE_D',\n ],\n [\n 'colour.CCT_to_xy_Kang2002',\n 'colour.temperature.CCT_to_xy_Kang2002',\n ],\n [\n 'colour.CIECAM02_InductionFactors',\n 'colour.appearance.CIECAM02_InductionFactors',\n ],\n [\n 'colour.CIE_RGB_COLOURSPACE',\n 'colour.models.CIE_RGB_COLOURSPACE',\n ],\n [\n 'colour.CINEMA_GAMUT_COLOURSPACE',\n 'colour.models.CINEMA_GAMUT_COLOURSPACE',\n ],\n [\n 'colour.CMCCAT2000_CAT',\n 'colour.adaptation.CMCCAT2000_CAT',\n ],\n [\n 'colour.CMCCAT2000_InductionFactors',\n 'colour.adaptation.CMCCAT2000_InductionFactors',\n ],\n [\n 'colour.CMCCAT97_CAT',\n 'colour.adaptation.CMCCAT97_CAT',\n ],\n [\n 'colour.COLOR_MATCH_RGB_COLOURSPACE',\n 'colour.models.COLOR_MATCH_RGB_COLOURSPACE',\n ],\n [\n 'colour.COLOURCHECKER_INDEXES_TO_NAMES_MAPPING',\n 'colour.characterisation.COLOURCHECKER_INDEXES_TO_NAMES_MAPPING',\n ],\n [\n 'colour.COLOURSPACE_MODELS',\n 'colour.models.COLOURSPACE_MODELS',\n ],\n [\n 'colour.COLOURSPACE_MODELS_LABELS',\n 'colour.models.COLOURSPACE_MODELS_AXIS_LABELS',\n ],\n [\n 'colour.CQS_Specification',\n 'colour.quality.CQS_Specification',\n ],\n [\n 'colour.CRI_Specification',\n 'colour.quality.CRI_Specification',\n ],\n [\n 'colour.CaseInsensitiveMapping',\n 'colour.utilities.CaseInsensitiveMapping',\n ],\n [\n 'colour.ColourWarning',\n 'colour.utilities.ColourWarning',\n ],\n [\n 'colour.DCI_P3_COLOURSPACE',\n 'colour.models.DCI_P3_COLOURSPACE',\n ],\n [\n 'colour.DCI_P3_P_COLOURSPACE',\n 'colour.models.DCI_P3_P_COLOURSPACE',\n ],\n [\n 'colour.DEFAULT_FLOAT_DTYPE',\n 'colour.constants.DEFAULT_FLOAT_DTYPE',\n ],\n [\n 'colour.DON_RGB_4_COLOURSPACE',\n 'colour.models.DON_RGB_4_COLOURSPACE',\n ],\n [\n 'colour.DRAGON_COLOR_2_COLOURSPACE',\n 'colour.models.DRAGON_COLOR_2_COLOURSPACE',\n ],\n [\n 'colour.DRAGON_COLOR_COLOURSPACE',\n 'colour.models.DRAGON_COLOR_COLOURSPACE',\n ],\n [\n 'colour.D_ILLUMINANTS_S_SPDS',\n 'colour.colorimetry.D_ILLUMINANTS_S_SDS',\n ],\n [\n 'colour.ECI_RGB_V2_COLOURSPACE',\n 'colour.models.ECI_RGB_V2_COLOURSPACE',\n ],\n [\n 'colour.EKTA_SPACE_PS_5_COLOURSPACE',\n 'colour.models.EKTA_SPACE_PS_5_COLOURSPACE',\n ],\n [\n 'colour.EPSILON',\n 'colour.constants.EPSILON',\n ],\n [\n 'colour.ERIMM_RGB_COLOURSPACE',\n 'colour.models.ERIMM_RGB_COLOURSPACE',\n ],\n [\n 'colour.FAIRCHILD_CAT',\n 'colour.adaptation.FAIRCHILD_CAT',\n ],\n [\n 'colour.FLOATING_POINT_NUMBER_PATTERN',\n 'colour.constants.FLOATING_POINT_NUMBER_PATTERN',\n ],\n [\n 'colour.Hunt_InductionFactors',\n 'colour.appearance.Hunt_InductionFactors',\n ],\n [\n 'colour.INTEGER_THRESHOLD',\n 'colour.constants.INTEGER_THRESHOLD',\n ],\n [\n 'colour.KP_M',\n 'colour.constants.KP_M',\n ],\n [\n 'colour.K_M',\n 'colour.constants.K_M',\n ],\n [\n 'colour.LIGHT_SPEED',\n 'colour.constants.LIGHT_SPEED',\n ],\n [\n 'colour.LLAB_InductionFactors',\n 'colour.appearance.LLAB_InductionFactors',\n ],\n [\n 'colour.LMS_10_degree_cmfs_to_XYZ_10_degree_cmfs',\n 'colour.colorimetry.LMS_10_degree_cmfs_to_XYZ_10_degree_cmfs',\n ],\n [\n 'colour.LMS_2_degree_cmfs_to_XYZ_2_degree_cmfs',\n 'colour.colorimetry.LMS_2_degree_cmfs_to_XYZ_2_degree_cmfs',\n ],\n [\n 'colour.LMS_ConeFundamentals',\n 'colour.colorimetry.LMS_ConeFundamentals',\n ],\n [\n 'colour.LineSegmentsIntersections_Specification',\n 'colour.algebra.LineSegmentsIntersections_Specification',\n ],\n [\n 'colour.Lookup',\n 'colour.utilities.Lookup',\n ],\n [\n 'colour.MAX_RGB_COLOURSPACE',\n 'colour.models.MAX_RGB_COLOURSPACE',\n ],\n [\n 'colour.MUNSELL_COLOURS_1929',\n 'colour.notation.MUNSELL_COLOURS_1929',\n ],\n [\n 'colour.MUNSELL_COLOURS_ALL',\n 'colour.notation.MUNSELL_COLOURS_ALL',\n ],\n [\n 'colour.MUNSELL_COLOURS_REAL',\n 'colour.notation.MUNSELL_COLOURS_REAL',\n ],\n [\n 'colour.MultiSignal',\n 'colour.continuous.MultiSignals',\n ],\n [\n 'colour.NTSC_1953_COLOURSPACE',\n 'colour.models.NTSC_1953_COLOURSPACE',\n ],\n [\n 'colour.PAL_SECAM_COLOURSPACE',\n 'colour.models.PAL_SECAM_COLOURSPACE',\n ],\n [\n 'colour.PLANCK_CONSTANT',\n 'colour.constants.PLANCK_CONSTANT',\n ],\n [\n 'colour.PROPHOTO_RGB_COLOURSPACE',\n 'colour.models.PROPHOTO_RGB_COLOURSPACE',\n ],\n [\n 'colour.PROTUNE_NATIVE_COLOURSPACE',\n 'colour.models.PROTUNE_NATIVE_COLOURSPACE',\n ],\n [\n 'colour.RED_COLOR_2_COLOURSPACE',\n 'colour.models.RED_COLOR_2_COLOURSPACE',\n ],\n [\n 'colour.RED_COLOR_3_COLOURSPACE',\n 'colour.models.RED_COLOR_3_COLOURSPACE',\n ],\n [\n 'colour.RED_COLOR_4_COLOURSPACE',\n 'colour.models.RED_COLOR_4_COLOURSPACE',\n ],\n [\n 'colour.RED_COLOR_COLOURSPACE',\n 'colour.models.RED_COLOR_COLOURSPACE',\n ],\n [\n 'colour.RED_WIDE_GAMUT_RGB_COLOURSPACE',\n 'colour.models.RED_WIDE_GAMUT_RGB_COLOURSPACE',\n ],\n [\n 'colour.RGB_10_degree_cmfs_to_LMS_10_degree_cmfs',\n 'colour.colorimetry.RGB_10_degree_cmfs_to_LMS_10_degree_cmfs',\n ],\n [\n 'colour.RGB_10_degree_cmfs_to_XYZ_10_degree_cmfs',\n 'colour.colorimetry.RGB_10_degree_cmfs_to_XYZ_10_degree_cmfs',\n ],\n [\n 'colour.RGB_2_degree_cmfs_to_XYZ_2_degree_cmfs',\n 'colour.colorimetry.RGB_2_degree_cmfs_to_XYZ_2_degree_cmfs',\n ],\n [\n 'colour.RGB_ColourMatchingFunctions',\n 'colour.colorimetry.RGB_ColourMatchingFunctions',\n ],\n [\n 'colour.RGB_DisplayPrimaries',\n 'colour.characterisation.RGB_DisplayPrimaries',\n ],\n [\n 'colour.RGB_SpectralSensitivities',\n 'colour.characterisation.RGB_SpectralSensitivities',\n ],\n [\n 'colour.RGB_to_sd_Smits1999',\n 'colour.recovery.RGB_to_sd_Smits1999',\n ],\n [\n 'colour.RIMM_RGB_COLOURSPACE',\n 'colour.models.RIMM_RGB_COLOURSPACE',\n ],\n [\n 'colour.ROMM_RGB_COLOURSPACE',\n 'colour.models.ROMM_RGB_COLOURSPACE',\n ],\n [\n 'colour.RUSSELL_RGB_COLOURSPACE',\n 'colour.models.RUSSELL_RGB_COLOURSPACE',\n ],\n [\n 'colour.SHARP_CAT',\n 'colour.adaptation.SHARP_CAT',\n ],\n [\n 'colour.SMITS_1999_SPDS',\n 'colour.recovery.SMITS_1999_SDS',\n ],\n [\n 'colour.SMPTE_240M_COLOURSPACE',\n 'colour.models.SMPTE_240M_COLOURSPACE',\n ],\n [\n 'colour.S_GAMUT3_CINE_COLOURSPACE',\n 'colour.models.S_GAMUT3_CINE_COLOURSPACE',\n ],\n [\n 'colour.S_GAMUT3_COLOURSPACE',\n 'colour.models.S_GAMUT3_COLOURSPACE',\n ],\n [\n 'colour.S_GAMUT_COLOURSPACE',\n 'colour.models.S_GAMUT_COLOURSPACE',\n ],\n [\n 'colour.Signal',\n 'colour.continuous.Signal',\n ],\n [\n 'colour.Structure',\n 'colour.utilities.Structure',\n ],\n [\n 'colour.TCS_SPDS',\n 'colour.quality.TCS_SDS',\n ],\n [\n 'colour.VON_KRIES_CAT',\n 'colour.adaptation.VON_KRIES_CAT',\n ],\n [\n 'colour.VS_SPDS',\n 'colour.quality.VS_SDS',\n ],\n [\n 'colour.V_GAMUT_COLOURSPACE',\n 'colour.models.V_GAMUT_COLOURSPACE',\n ],\n [\n 'colour.XTREME_RGB_COLOURSPACE',\n 'colour.models.XTREME_RGB_COLOURSPACE',\n ],\n [\n 'colour.XYZ_ColourMatchingFunctions',\n 'colour.colorimetry.XYZ_ColourMatchingFunctions',\n ],\n [\n 'colour.XYZ_SCALING_CAT',\n 'colour.adaptation.XYZ_SCALING_CAT',\n ],\n [\n 'colour.XYZ_to_colourspace_model',\n 'colour.models.XYZ_to_colourspace_model',\n ],\n [\n 'colour.XYZ_to_sd_Meng2015',\n 'colour.recovery.XYZ_to_sd_Meng2015',\n ],\n [\n 'colour.adjust_tristimulus_weighting_factors_ASTME30815',\n 'colour.colorimetry.adjust_tristimulus_weighting_factors_ASTME308',\n ],\n [\n 'colour.as_namedtuple',\n 'colour.utilities.as_namedtuple',\n ],\n [\n 'colour.as_numeric',\n 'colour.utilities.as_numeric',\n ],\n [\n 'colour.bandpass_correction_Stearns1988',\n 'colour.colorimetry.bandpass_correction_Stearns1988',\n ],\n [\n 'colour.batch',\n 'colour.utilities.batch',\n ],\n [\n 'colour.blackbody_spectral_radiance',\n 'colour.colorimetry.blackbody_spectral_radiance',\n ],\n [\n 'colour.cartesian_to_cylindrical',\n 'colour.algebra.cartesian_to_cylindrical',\n ],\n [\n 'colour.cartesian_to_polar',\n 'colour.algebra.cartesian_to_polar',\n ],\n [\n 'colour.cartesian_to_spherical',\n 'colour.algebra.cartesian_to_spherical',\n ],\n [\n 'colour.centroid',\n 'colour.utilities.centroid',\n ],\n [\n 'colour.chromatic_adaptation_CIE1994',\n 'colour.adaptation.chromatic_adaptation_CIE1994',\n ],\n [\n 'colour.chromatic_adaptation_CMCCAT2000',\n 'colour.adaptation.chromatic_adaptation_CMCCAT2000',\n ],\n [\n 'colour.chromatic_adaptation_Fairchild1990',\n 'colour.adaptation.chromatic_adaptation_Fairchild1990',\n ],\n [\n 'colour.chromatic_adaptation_VonKries',\n 'colour.adaptation.chromatic_adaptation_VonKries',\n ],\n [\n 'colour.chromatic_adaptation_forward_CMCCAT2000',\n 'colour.adaptation.chromatic_adaptation_forward_CMCCAT2000',\n ],\n [\n 'colour.chromatic_adaptation_matrix_VonKries',\n 'colour.adaptation.chromatic_adaptation_matrix_VonKries',\n ],\n [\n 'colour.chromatic_adaptation_reverse_CMCCAT2000',\n 'colour.adaptation.chromatic_adaptation_inverse_CMCCAT2000',\n ],\n [\n 'colour.closest',\n 'colour.utilities.closest',\n ],\n [\n 'colour.closest_indexes',\n 'colour.utilities.closest_indexes',\n ],\n [\n 'colour.corresponding_chromaticities_prediction_CIE1994',\n 'colour.corresponding.corresponding_chromaticities_prediction_CIE1994', # noqa\n ],\n [\n 'colour.corresponding_chromaticities_prediction_CMCCAT2000',\n 'colour.corresponding.corresponding_chromaticities_prediction_CMCCAT2000', # noqa\n ],\n [\n 'colour.corresponding_chromaticities_prediction_Fairchild1990',\n 'colour.corresponding.corresponding_chromaticities_prediction_Fairchild1990', # noqa\n ],\n [\n 'colour.corresponding_chromaticities_prediction_VonKries',\n 'colour.corresponding.corresponding_chromaticities_prediction_VonKries', # noqa\n ],\n [\n 'colour.cylindrical_to_cartesian',\n 'colour.algebra.cylindrical_to_cartesian',\n ],\n [\n 'colour.delta_E_CAM02LCD',\n 'colour.difference.delta_E_CAM02LCD',\n ],\n [\n 'colour.delta_E_CAM02SCD',\n 'colour.difference.delta_E_CAM02SCD',\n ],\n [\n 'colour.delta_E_CAM02UCS',\n 'colour.difference.delta_E_CAM02UCS',\n ],\n [\n 'colour.delta_E_CAM16LCD',\n 'colour.difference.delta_E_CAM16LCD',\n ],\n [\n 'colour.delta_E_CAM16SCD',\n 'colour.difference.delta_E_CAM16SCD',\n ],\n [\n 'colour.delta_E_CAM16UCS',\n 'colour.difference.delta_E_CAM16UCS',\n ],\n [\n 'colour.delta_E_CIE1976',\n 'colour.difference.delta_E_CIE1976',\n ],\n [\n 'colour.delta_E_CIE1994',\n 'colour.difference.delta_E_CIE1994',\n ],\n [\n 'colour.delta_E_CIE2000',\n 'colour.difference.delta_E_CIE2000',\n ],\n [\n 'colour.delta_E_CMC',\n 'colour.difference.delta_E_CMC',\n ],\n [\n 'colour.dot_matrix',\n 'colour.utilities.dot_matrix',\n ],\n [\n 'colour.dot_vector',\n 'colour.utilities.dot_vector',\n ],\n [\n 'colour.eotf_BT1886',\n 'colour.models.eotf_BT1886',\n ],\n [\n 'colour.eotf_BT2020',\n 'colour.models.eotf_BT2020',\n ],\n [\n 'colour.eotf_BT2100_HLG',\n 'colour.models.eotf_HLG_BT2100',\n ],\n [\n 'colour.eotf_BT2100_PQ',\n 'colour.models.eotf_PQ_BT2100',\n ],\n [\n 'colour.eotf_DCIP3',\n 'colour.models.eotf_DCDM',\n ],\n [\n 'colour.eotf_DICOMGSDF',\n 'colour.models.eotf_DICOMGSDF',\n ],\n [\n 'colour.cctf_decoding_ProPhotoRGB',\n 'colour.models.cctf_decoding_ProPhotoRGB',\n ],\n [\n 'colour.cctf_decoding_RIMMRGB',\n 'colour.models.cctf_decoding_RIMMRGB',\n ],\n [\n 'colour.cctf_decoding_ROMMRGB',\n 'colour.models.cctf_decoding_ROMMRGB',\n ],\n [\n 'colour.eotf_SMPTE240M',\n 'colour.models.eotf_SMPTE240M',\n ],\n [\n 'colour.eotf_ST2084',\n 'colour.models.eotf_ST2084',\n ],\n [\n 'colour.eotf_reverse_BT1886',\n 'colour.models.eotf_inverse_BT1886',\n ],\n [\n 'colour.eotf_reverse_BT2100_HLG',\n 'colour.models.eotf_inverse_HLG_BT2100',\n ],\n [\n 'colour.eotf_reverse_BT2100_PQ',\n 'colour.models.eotf_inverse_PQ_BT2100',\n ],\n [\n 'colour.eotf_reverse_ST2084',\n 'colour.models.eotf_inverse_ST2084',\n ],\n [\n 'colour.eotf_reverse_sRGB',\n 'colour.models.eotf_inverse_sRGB',\n ],\n [\n 'colour.eotf_sRGB',\n 'colour.models.eotf_sRGB',\n ],\n [\n 'colour.euclidean_distance',\n 'colour.algebra.euclidean_distance',\n ],\n [\n 'colour.extend_line_segment',\n 'colour.algebra.extend_line_segment',\n ],\n [\n 'colour.fill_nan',\n 'colour.utilities.fill_nan',\n ],\n [\n 'colour.filter_kwargs',\n 'colour.utilities.filter_kwargs',\n ],\n [\n 'colour.filter_warnings',\n 'colour.utilities.filter_warnings',\n ],\n [\n 'colour.first_item',\n 'colour.utilities.first_item',\n ],\n [\n 'colour.handle_numpy_errors',\n 'colour.utilities.handle_numpy_errors',\n ],\n [\n 'colour.ignore_numpy_errors',\n 'colour.utilities.ignore_numpy_errors',\n ],\n [\n 'colour.ignore_python_warnings',\n 'colour.utilities.ignore_python_warnings',\n ],\n [\n 'colour.in_array',\n 'colour.utilities.in_array',\n ],\n [\n 'colour.intersect_line_segments',\n 'colour.algebra.intersect_line_segments',\n ],\n [\n 'colour.interval',\n 'colour.utilities.interval',\n ],\n [\n 'colour.is_identity',\n 'colour.algebra.is_identity',\n ],\n [\n 'colour.is_integer',\n 'colour.utilities.is_integer',\n ],\n [\n 'colour.is_iterable',\n 'colour.utilities.is_iterable',\n ],\n [\n 'colour.is_numeric',\n 'colour.utilities.is_numeric',\n ],\n [\n 'colour.is_openimageio_installed',\n 'colour.utilities.is_openimageio_installed',\n ],\n [\n 'colour.is_pandas_installed',\n 'colour.utilities.is_pandas_installed',\n ],\n [\n 'colour.is_string',\n 'colour.utilities.is_string',\n ],\n [\n 'colour.is_uniform',\n 'colour.utilities.is_uniform',\n ],\n [\n 'colour.lagrange_coefficients_ASTME2022',\n 'colour.colorimetry.lagrange_coefficients_ASTME2022',\n ],\n [\n 'colour.lightness_CIE1976',\n 'colour.colorimetry.lightness_CIE1976',\n ],\n [\n 'colour.lightness_Fairchild2010',\n 'colour.colorimetry.lightness_Fairchild2010',\n ],\n [\n 'colour.lightness_Fairchild2011',\n 'colour.colorimetry.lightness_Fairchild2011',\n ],\n [\n 'colour.lightness_Glasser1958',\n 'colour.colorimetry.lightness_Glasser1958',\n ],\n [\n 'colour.lightness_Wyszecki1963',\n 'colour.colorimetry.lightness_Wyszecki1963',\n ],\n [\n 'colour.linear_conversion',\n 'colour.utilities.linear_conversion',\n ],\n [\n 'colour.log_decoding_ACEScc',\n 'colour.models.log_decoding_ACEScc',\n ],\n [\n 'colour.log_decoding_ACEScct',\n 'colour.models.log_decoding_ACEScct',\n ],\n [\n 'colour.log_decoding_ACESproxy',\n 'colour.models.log_decoding_ACESproxy',\n ],\n [\n 'colour.log_decoding_ALEXALogC',\n 'colour.models.log_decoding_ALEXALogC',\n ],\n [\n 'colour.log_decoding_CanonLog',\n 'colour.models.log_decoding_CanonLog',\n ],\n [\n 'colour.log_decoding_CanonLog2',\n 'colour.models.log_decoding_CanonLog2',\n ],\n [\n 'colour.log_decoding_CanonLog3',\n 'colour.models.log_decoding_CanonLog3',\n ],\n [\n 'colour.log_decoding_Cineon',\n 'colour.models.log_decoding_Cineon',\n ],\n [\n 'colour.log_decoding_ERIMMRGB',\n 'colour.models.log_decoding_ERIMMRGB',\n ],\n [\n 'colour.log_decoding_Log3G10',\n 'colour.models.log_decoding_Log3G10',\n ],\n [\n 'colour.log_decoding_Log3G12',\n 'colour.models.log_decoding_Log3G12',\n ],\n [\n 'colour.log_decoding_Panalog',\n 'colour.models.log_decoding_Panalog',\n ],\n [\n 'colour.log_decoding_PivotedLog',\n 'colour.models.log_decoding_PivotedLog',\n ],\n [\n 'colour.log_decoding_Protune',\n 'colour.models.log_decoding_Protune',\n ],\n [\n 'colour.log_decoding_REDLog',\n 'colour.models.log_decoding_REDLog',\n ],\n [\n 'colour.log_decoding_REDLogFilm',\n 'colour.models.log_decoding_REDLogFilm',\n ],\n [\n 'colour.log_decoding_SLog',\n 'colour.models.log_decoding_SLog',\n ],\n [\n 'colour.log_decoding_SLog2',\n 'colour.models.log_decoding_SLog2',\n ],\n [\n 'colour.log_decoding_SLog3',\n 'colour.models.log_decoding_SLog3',\n ],\n [\n 'colour.log_decoding_VLog',\n 'colour.models.log_decoding_VLog',\n ],\n [\n 'colour.log_decoding_ViperLog',\n 'colour.models.log_decoding_ViperLog',\n ],\n [\n 'colour.log_encoding_ACEScc',\n 'colour.models.log_encoding_ACEScc',\n ],\n [\n 'colour.log_encoding_ACEScct',\n 'colour.models.log_encoding_ACEScct',\n ],\n [\n 'colour.log_encoding_ACESproxy',\n 'colour.models.log_encoding_ACESproxy',\n ],\n [\n 'colour.log_encoding_ALEXALogC',\n 'colour.models.log_encoding_ALEXALogC',\n ],\n [\n 'colour.log_encoding_CanonLog',\n 'colour.models.log_encoding_CanonLog',\n ],\n [\n 'colour.log_encoding_CanonLog2',\n 'colour.models.log_encoding_CanonLog2',\n ],\n [\n 'colour.log_encoding_CanonLog3',\n 'colour.models.log_encoding_CanonLog3',\n ],\n [\n 'colour.log_encoding_Cineon',\n 'colour.models.log_encoding_Cineon',\n ],\n [\n 'colour.log_encoding_ERIMMRGB',\n 'colour.models.log_encoding_ERIMMRGB',\n ],\n [\n 'colour.log_encoding_Log3G10',\n 'colour.models.log_encoding_Log3G10',\n ],\n [\n 'colour.log_encoding_Log3G12',\n 'colour.models.log_encoding_Log3G12',\n ],\n [\n 'colour.log_encoding_Panalog',\n 'colour.models.log_encoding_Panalog',\n ],\n [\n 'colour.log_encoding_PivotedLog',\n 'colour.models.log_encoding_PivotedLog',\n ],\n [\n 'colour.log_encoding_Protune',\n 'colour.models.log_encoding_Protune',\n ],\n [\n 'colour.log_encoding_REDLog',\n 'colour.models.log_encoding_REDLog',\n ],\n [\n 'colour.log_encoding_REDLogFilm',\n 'colour.models.log_encoding_REDLogFilm',\n ],\n [\n 'colour.log_encoding_SLog',\n 'colour.models.log_encoding_SLog',\n ],\n [\n 'colour.log_encoding_SLog2',\n 'colour.models.log_encoding_SLog2',\n ],\n [\n 'colour.log_encoding_SLog3',\n 'colour.models.log_encoding_SLog3',\n ],\n [\n 'colour.log_encoding_VLog',\n 'colour.models.log_encoding_VLog',\n ],\n [\n 'colour.luminance_ASTMD153508',\n 'colour.colorimetry.luminance_ASTMD1535',\n ],\n [\n 'colour.luminance_CIE1976',\n 'colour.colorimetry.luminance_CIE1976',\n ],\n [\n 'colour.luminance_Fairchild2010',\n 'colour.colorimetry.luminance_Fairchild2010',\n ],\n [\n 'colour.luminance_Fairchild2011',\n 'colour.colorimetry.luminance_Fairchild2011',\n ],\n [\n 'colour.luminance_Newhall1943',\n 'colour.colorimetry.luminance_Newhall1943',\n ],\n [\n 'colour.mesopic_weighting_function',\n 'colour.colorimetry.mesopic_weighting_function',\n ],\n [\n 'colour.message_box',\n 'colour.utilities.message_box',\n ],\n [\n 'colour.munsell_value_ASTMD153508',\n 'colour.notation.munsell_value_ASTMD1535',\n ],\n [\n 'colour.munsell_value_Ladd1955',\n 'colour.notation.munsell_value_Ladd1955',\n ],\n [\n 'colour.munsell_value_McCamy1987',\n 'colour.notation.munsell_value_McCamy1987',\n ],\n [\n 'colour.munsell_value_Moon1943',\n 'colour.notation.munsell_value_Moon1943',\n ],\n [\n 'colour.munsell_value_Munsell1933',\n 'colour.notation.munsell_value_Munsell1933',\n ],\n [\n 'colour.munsell_value_Priest1920',\n 'colour.notation.munsell_value_Priest1920',\n ],\n [\n 'colour.munsell_value_Saunderson1944',\n 'colour.notation.munsell_value_Saunderson1944',\n ],\n [\n 'colour.ndarray_write',\n 'colour.utilities.ndarray_write',\n ],\n [\n 'colour.normalise_maximum',\n 'colour.utilities.normalise_maximum',\n ],\n [\n 'colour.normalise_vector',\n 'colour.algebra.normalise_vector',\n ],\n [\n 'colour.numpy_print_options',\n 'colour.utilities.numpy_print_options',\n ],\n [\n 'colour.oetf_ARIBSTDB67',\n 'colour.models.oetf_ARIBSTDB67',\n ],\n [\n 'colour.oetf_BT2020',\n 'colour.models.oetf_BT2020',\n ],\n [\n 'colour.oetf_BT2100_HLG',\n 'colour.models.oetf_HLG_BT2100',\n ],\n [\n 'colour.oetf_BT2100_PQ',\n 'colour.models.oetf_PQ_BT2100',\n ],\n [\n 'colour.oetf_BT601',\n 'colour.models.oetf_BT601',\n ],\n [\n 'colour.oetf_BT709',\n 'colour.models.oetf_BT709',\n ],\n [\n 'colour.oetf_DCIP3',\n 'colour.models.eotf_inverse_DCIP3',\n ],\n [\n 'colour.oetf_DICOMGSDF',\n 'colour.models.eotf_inverse_DICOMGSDF',\n ],\n [\n 'colour.cctf_encoding_ProPhotoRGB',\n 'colour.models.cctf_encoding_ProPhotoRGB',\n ],\n [\n 'colour.cctf_encoding_RIMMRGB',\n 'colour.models.cctf_encoding_RIMMRGB',\n ],\n [\n 'colour.cctf_encoding_ROMMRGB',\n 'colour.models.cctf_encoding_ROMMRGB',\n ],\n [\n 'colour.oetf_SMPTE240M',\n 'colour.models.oetf_SMPTE240M',\n ],\n [\n 'colour.oetf_reverse_ARIBSTDB67',\n 'colour.models.oetf_inverse_ARIBSTDB67',\n ],\n [\n 'colour.oetf_reverse_BT2100_HLG',\n 'colour.models.oetf_inverse_HLG_BT2100',\n ],\n [\n 'colour.oetf_reverse_BT2100_PQ',\n 'colour.models.oetf_inverse_PQ_BT2100',\n ],\n [\n 'colour.oetf_reverse_BT601',\n 'colour.models.oetf_inverse_BT601',\n ],\n [\n 'colour.oetf_reverse_BT709',\n 'colour.models.oetf_inverse_BT709',\n ],\n [\n 'colour.ootf_BT2100_HLG',\n 'colour.models.ootf_HLG_BT2100',\n ],\n [\n 'colour.ootf_BT2100_PQ',\n 'colour.models.ootf_PQ_BT2100',\n ],\n [\n 'colour.ootf_reverse_BT2100_HLG',\n 'colour.models.ootf_inverse_HLG_BT2100',\n ],\n [\n 'colour.ootf_reverse_BT2100_PQ',\n 'colour.models.ootf_inverse_PQ_BT2100',\n ],\n [\n 'colour.orient',\n 'colour.utilities.orient',\n ],\n [\n 'colour.planck_law',\n 'colour.colorimetry.planck_law',\n ],\n [\n 'colour.polar_to_cartesian',\n 'colour.algebra.polar_to_cartesian',\n ],\n [\n 'colour.print_numpy_errors',\n 'colour.utilities.print_numpy_errors',\n ],\n [\n 'colour.raise_numpy_errors',\n 'colour.utilities.raise_numpy_errors',\n ],\n [\n 'colour.random_triplet_generator',\n 'colour.algebra.random_triplet_generator',\n ],\n [\n 'colour.rayleigh_optical_depth',\n 'colour.phenomena.rayleigh_optical_depth',\n ],\n [\n 'colour.reaction_rate_MichealisMenten',\n 'colour.biochemistry.reaction_rate_MichealisMenten',\n ],\n [\n 'colour.row_as_diagonal',\n 'colour.utilities.row_as_diagonal',\n ],\n [\n 'colour.sRGB_COLOURSPACE',\n 'colour.models.sRGB_COLOURSPACE',\n ],\n [\n 'colour.sd_to_XYZ_ASTME30815',\n 'colour.colorimetry.sd_to_XYZ_ASTME308',\n ],\n [\n 'colour.sd_to_XYZ_integration',\n 'colour.colorimetry.sd_to_XYZ_integration',\n ],\n [\n 'colour.sd_to_XYZ_tristimulus_weighting_factors_ASTME30815',\n 'colour.colorimetry.sd_to_XYZ_tristimulus_weighting_factors_ASTME308', # noqa\n ],\n [\n 'colour.spherical_to_cartesian',\n 'colour.algebra.spherical_to_cartesian',\n ],\n [\n 'colour.substrate_concentration_MichealisMenten',\n 'colour.biochemistry.substrate_concentration_MichealisMenten',\n ],\n [\n 'colour.tristimulus_weighting_factors_ASTME2022',\n 'colour.colorimetry.tristimulus_weighting_factors_ASTME2022',\n ],\n [\n 'colour.tsplit',\n 'colour.utilities.tsplit',\n ],\n [\n 'colour.tstack',\n 'colour.utilities.tstack',\n ],\n [\n 'colour.uv_to_CCT_Ohno2013',\n 'colour.temperature.uv_to_CCT_Ohno2013',\n ],\n [\n 'colour.uv_to_CCT_Robertson1968',\n 'colour.temperature.uv_to_CCT_Robertson1968',\n ],\n [\n 'colour.warn_numpy_errors',\n 'colour.utilities.warn_numpy_errors',\n ],\n [\n 'colour.warning',\n 'colour.utilities.warning',\n ],\n [\n 'colour.whiteness_ASTME313',\n 'colour.colorimetry.whiteness_ASTME313',\n ],\n [\n 'colour.whiteness_Berger1959',\n 'colour.colorimetry.whiteness_Berger1959',\n ],\n [\n 'colour.whiteness_CIE2004',\n 'colour.colorimetry.whiteness_CIE2004',\n ],\n [\n 'colour.whiteness_Ganz1979',\n 'colour.colorimetry.whiteness_Ganz1979',\n ],\n [\n 'colour.whiteness_Stensby1968',\n 'colour.colorimetry.whiteness_Stensby1968',\n ],\n [\n 'colour.whiteness_Taube1960',\n 'colour.colorimetry.whiteness_Taube1960',\n ],\n [\n 'colour.xy_to_CCT_Hernandez1999',\n 'colour.temperature.xy_to_CCT_Hernandez1999',\n ],\n [\n 'colour.xy_to_CCT_McCamy1992',\n 'colour.temperature.xy_to_CCT_McCamy1992',\n ],\n [\n 'colour.yellowness_ASTMD1925',\n 'colour.colorimetry.yellowness_ASTMD1925',\n ],\n [\n 'colour.yellowness_ASTME313',\n 'colour.colorimetry.yellowness_ASTME313',\n ],\n ]\n}\n\"\"\"\nDefines *colour* package API changes.\n\nAPI_CHANGES : dict\n\"\"\"\n\nAPI_CHANGES.update({\n 'ObjectRemoved': [\n 'colour.DEFAULT_WAVELENGTH_DECIMALS',\n 'colour.ArbitraryPrecisionMapping',\n 'colour.SpectralMapping',\n ],\n 'ObjectRenamed': [\n [\n 'colour.eotf_ARIBSTDB67',\n 'colour.models.oetf_inverse_ARIBSTDB67',\n ],\n [\n 'colour.eotf_BT709',\n 'colour.models.oetf_inverse_BT709',\n ],\n [\n 'colour.oetf_BT1886',\n 'colour.models.eotf_inverse_BT1886',\n ],\n [\n 'colour.eotf_sRGB',\n 'colour.models.eotf_sRGB',\n ],\n [\n 'colour.ALEXA_WIDE_GAMUT_RGB_COLOURSPACE',\n 'colour.models.ALEXA_WIDE_GAMUT_COLOURSPACE',\n ],\n [\n 'colour.NTSC_1953_RGB_COLOURSPACE',\n 'colour.models.NTSC_1953_COLOURSPACE',\n ],\n [\n 'colour.PAL_SECAM_RGB_COLOURSPACE',\n 'colour.models.PAL_SECAM_COLOURSPACE',\n ],\n [\n 'colour.REC_709_COLOURSPACE',\n 'colour.models.BT709_COLOURSPACE',\n ],\n [\n 'colour.REC_2020_COLOURSPACE',\n 'colour.models.BT2020_COLOURSPACE',\n ],\n [\n 'colour.SMPTE_C_RGB_COLOURSPACE',\n 'colour.models.SMPTE_240M_COLOURSPACE',\n ],\n [\n 'colour.TriSpectralPowerDistribution',\n 'colour.MultiSpectralDistributions',\n ],\n ]\n})\n\n# v0.3.12\nAPI_CHANGES['ObjectRenamed'] = API_CHANGES['ObjectRenamed'] + [\n [\n 'colour.CIE_standard_illuminant_A_function',\n 'colour.sd_CIE_standard_illuminant_A',\n ],\n [\n 'colour.COLOURCHECKERS_SPDS',\n 'colour.COLOURCHECKERS_SDS',\n ],\n [\n 'colour.D_illuminant_relative_spd',\n 'colour.sd_CIE_illuminant_D_series',\n ],\n [\n 'colour.ILLUMINANTS_RELATIVE_SPDS',\n 'colour.ILLUMINANTS_SDS',\n ],\n [\n 'colour.LIGHT_SOURCES_RELATIVE_SPDS',\n 'colour.LIGHT_SOURCES_SDS',\n ],\n [\n 'colour.MultiSpectralPowerDistribution',\n 'colour.MultiSpectralDistributions',\n ],\n [\n 'colour.REFLECTANCE_RECOVERY_METHODS',\n 'colour.XYZ_TO_SD_METHODS',\n ],\n [\n 'colour.SPECTRAL_TO_XYZ_METHODS',\n 'colour.SD_TO_XYZ_METHODS',\n ],\n [\n 'colour.SpectralPowerDistribution',\n 'colour.SpectralDistribution',\n ],\n [\n 'colour.blackbody_spd',\n 'colour.sd_blackbody',\n ],\n [\n 'colour.constant_spd',\n 'colour.sd_constant',\n ],\n [\n 'colour.first_order_colour_fit',\n 'colour.colour_correction_matrix',\n ],\n [\n 'colour.IES_TM2714_Spd',\n 'colour.SpectralDistribution_IESTM2714',\n ],\n [\n 'colour.function_gamma',\n 'colour.gamma_function',\n ],\n [\n 'colour.function_linear',\n 'colour.linear_function',\n ],\n [\n 'colour.mesopic_luminous_efficiency_function',\n 'colour.sd_mesopic_luminous_efficiency_function',\n ],\n [\n 'colour.ones_spd',\n 'colour.sd_ones',\n ],\n [\n 'colour.rayleigh_scattering_spd',\n 'colour.sd_rayleigh_scattering',\n ],\n [\n 'colour.read_spds_from_csv_file',\n 'colour.read_sds_from_csv_file',\n ],\n [\n 'colour.read_spds_from_xrite_file',\n 'colour.read_sds_from_xrite_file',\n ],\n [\n 'colour.spectral_to_aces_relative_exposure_values',\n 'colour.sd_to_aces_relative_exposure_values',\n ],\n [\n 'colour.spectral_to_XYZ',\n 'colour.sd_to_XYZ',\n ],\n [\n 'colour.write_spds_to_csv_file',\n 'colour.write_sds_to_csv_file',\n ],\n [\n 'colour.XYZ_to_spectral',\n 'colour.XYZ_to_sd',\n ],\n [\n 'colour.zeros_spd',\n 'colour.sd_zeros',\n ],\n]\n\n# v0.3.14\nAPI_CHANGES['ObjectRenamed'] = API_CHANGES['ObjectRenamed'] + [\n [\n 'colour.ASTME30815_PRACTISE_SHAPE',\n 'colour.ASTME308_PRACTISE_SHAPE',\n ],\n [\n 'colour.decoding_cctf',\n 'colour.cctf_decoding',\n ],\n [\n 'colour.DECODING_CCTFS',\n 'colour.CCTF_DECODINGS',\n ],\n [\n 'colour.encoding_cctf',\n 'colour.cctf_encoding',\n ],\n [\n 'colour.ENCODING_CCTFS',\n 'colour.CCTF_ENCODINGS',\n ],\n [\n 'colour.EOTFS_REVERSE',\n 'colour.EOTF_INVERSES',\n ],\n [\n 'colour.eotf_reverse',\n 'colour.eotf_inverse',\n ],\n [\n 'colour.log_decoding_curve',\n 'colour.log_decoding',\n ],\n [\n 'colour.LOG_DECODING_CURVES',\n 'colour.LOG_DECODINGS',\n ],\n [\n 'colour.log_encoding_curve',\n 'colour.log_encoding',\n ],\n [\n 'colour.LOG_ENCODING_CURVES',\n 'colour.LOG_ENCODINGS',\n ],\n [\n 'colour.OETFS_REVERSE',\n 'colour.OETF_INVERSES',\n ],\n [\n 'colour.oetf_reverse',\n 'colour.oetf_inverse',\n ],\n [\n 'colour.OOTFS_REVERSE',\n 'colour.OOTF_INVERSES',\n ],\n [\n 'colour.ootf_reverse',\n 'colour.ootf_inverse',\n ],\n [\n 'colour.MultiSpectralDistribution',\n 'colour.MultiSpectralDistributions',\n ],\n]\n\nif not is_documentation_building():\n sys.modules['colour'] = colour(sys.modules['colour'],\n build_API_changes(API_CHANGES))\n\n del ModuleAPI, is_documentation_building, build_API_changes, sys\n", "meta": {"hexsha": "867971ab31b8ec83171f2f605a662446c8e2e9c6", "size": 57181, "ext": "py", "lang": "Python", "max_stars_repo_path": "colour/__init__.py", "max_stars_repo_name": "MaxSchambach/colour", "max_stars_repo_head_hexsha": "3f3685d616fda4be58cec20bc1e16194805d7e2d", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "colour/__init__.py", "max_issues_repo_name": "MaxSchambach/colour", "max_issues_repo_head_hexsha": "3f3685d616fda4be58cec20bc1e16194805d7e2d", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "colour/__init__.py", "max_forks_repo_name": "MaxSchambach/colour", "max_forks_repo_head_hexsha": "3f3685d616fda4be58cec20bc1e16194805d7e2d", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.1422147274, "max_line_length": 97, "alphanum_fraction": 0.5919448768, "include": true, "reason": "import numpy", "num_tokens": 14380, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.5389832206876841, "lm_q2_score": 0.3665897294020099, "lm_q1q2_score": 0.1975857130241219}} {"text": "# coding: utf-8\n\"\"\"\nName: cycloen_deepeningrate.py\n\nFind cyclone center location and\ncalucurate cyclone deepinrate.\n\nexample:\npython3 cyclone_deepinrate.py -x 137 -y 40 -d -t yy-mm-dd-hh\n\nAuthor: Ryosuke Tomita\nDate: 2021/08/13\n\"\"\"\nimport argparse\nfrom datetime import datetime, timedelta\nimport math\nimport os\nfrom os.path import abspath, dirname, join\nimport re\nimport sys\nfrom typing import Union\nfrom netCDF4 import Dataset\nimport numpy as np\n\n\ndef parse_args() -> dict:\n \"\"\"parse_args.\n User have to determine ambiguous cyclen center location by weather map and so on.\n\n Args:\n\n Returns:\n dict:\n \"\"\"\n parser = argparse.ArgumentParser()\n parser.add_argument(\n \"-y\", \"--lat\", help=\"Center of low pressure latitude\", type=float)\n parser.add_argument(\n \"-x\", \"--lon\", help=\"Center of low pressure longitude\", type=float)\n parser.add_argument(\n \"-d\", \"--dir\", help=\"set directory name. This is the initial time.\", type=str)\n parser.add_argument(\n \"-t\", \"--time\", help=\"set starttime. Format is yy-mm-dd-hh.\", type=str)\n p = parser.parse_args()\n args = {\"lat\": p.lat, \"lon\": p.lon, \"dir\": p.dir, \"time\": p.time}\n return args\n\n\ndef mk_prmsl_file_list(data_root_dir: str, start_date: datetime) -> list:\n \"\"\"mk_prmsl_file_list.\n split data_root_dir's into prmslfile or the others. These lists are sorted by datetime.\n\n Args:\n data_root_dir (str): data_root_dir\n start_date (datetime): start_date\n\n Returns:\n list:\n \"\"\"\n def _get_abs_path(par_dir: str, child: str) -> str:\n \"\"\"get_abs_path.\n\n Args:\n par_dir:\n child:\n \"\"\"\n abs_dir = abspath(join(par_dir, child))\n return abs_dir\n\n prmsl_all_list = sorted([_get_abs_path(data_root_dir, i)\n for i in os.listdir(data_root_dir) if \"prmsl\" in i])\n date_list = [\n datetime.strptime(re.search('[0-9]{4}-[0-9]{2}-[0-9]{2}_[0-9]{2}', i).group(),\"%Y-%m-%d_%H\")\n for i in prmsl_all_list\n ]\n prmsl_list = [prmsl_all_list[i]\n for i in range(len(prmsl_all_list)) if date_list[i] >= start_date]\n #print(prmsl_list)\n return prmsl_list\n\n\ndef read_loc_prmsl(ncfile: str) -> Union[\n np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray\n ]:\n \"\"\"read_loc_prmsl.\n read ncfile and extract near Japan data.\n\n Args:\n file_name (str): file_name\n\n Returns:\n Union[\n np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray\n ]:\n \"\"\"\n read_ncfile = Dataset(ncfile)\n prmsl_raw = read_ncfile.variables['prmsl'][0]\n lat = [\n i\n if 20 <= i <= 60\n else -99\n for i in np.array(read_ncfile.variables['latitude'])\n ]\n lon =[\n i if 110 <= i <= 180\n else -99\n for i in np.array(read_ncfile.variables['longitude'])\n ]\n prmsl_1d = [\n prmsl_raw[i][j]\n for i in range(len(lat))\n if lat[i] != -99\n for j in range(len(lon))\n if lon[j] != -99\n ]\n\n near_jp_lat = np.array([i for i in lat if i != -99])\n near_jp_lon = np.array([i for i in lon if i != -99])\n prmsl = np.array(prmsl_1d).reshape(len(near_jp_lat), len(near_jp_lon))\n #read_ncfile.close()\n return lat, lon, near_jp_lat, near_jp_lon, prmsl\n\n\nclass CenterInfo:\n \"\"\"CenterInfo.\n store cycloen center information.\n \"\"\"\n\n\n def __init__(self, lat_index: np.ndarray, lon_index: np.ndarray,\n prmsl: np.ndarray, lat: np.ndarray, lon: np.ndarray, date: str):\n \"\"\"__init__.\n set varues.\n\n Args:\n lat_index (np.ndarray): lat_index\n lon_index (np.ndarray): lon_index\n prmsl (np.ndarray): prmsl\n lat (np.ndarray): lat\n lon (np.ndarray): lon\n date (str): date\n \"\"\"\n self.lat_index = lat_index\n self.lon_index = lon_index\n self.prmsl = prmsl\n self.lat = lat\n self.lon = lon\n date_jts = datetime.strptime(date, \"%Y-%m-%d_%H\") + timedelta(hours=9)\n self.date = date_jts.strftime('%Y-%m-%d-%H')\n self.epsilon = -999 # epsilon is None.\n self.u_wind = None\n self.v_wind = None\n self.abs_wind = None\n self.wind_direction = None\n\n def __str__(self):\n \"\"\"__str__.\n print format settings.\n \"\"\"\n lat_data = f'latitude={self.lat},Index={self.lat_index}'\n lon_data = f'longitude={self.lon},Index={self.lon_index}'\n prmsl_data = f'prmslMin={self.prmsl}'\n date_data = f'date={self.date}'\n u_wind = f'u_wind={self.u_wind}'\n v_wind = f'v_wind={self.v_wind}'\n return f'{date_data},{lat_data},{lon_data},{prmsl_data},{u_wind},{v_wind}'\n\n def read_wind(self, ncfile: str, lat: np.ndarray, lon: np.ndarray,\n near_jp_lat: np.ndarray, near_jp_lon: np.ndarray, param: str) -> np.ndarray:\n read_ncfile = Dataset(ncfile.replace(\"-prmsl_hPa\", \"\"))\n var_all = read_ncfile.variables[param][0]\n var_1d = [\n var_all[i][j]\n for i in range(len(lat))\n if lat[i] != -99\n for j in range(len(lon))\n if lon[j] != -99\n ]\n var = np.array(var_1d).reshape(len(near_jp_lat), len(near_jp_lon))\n return var[self.lat_index][self.lon_index]\n\n\ndef find_initial_prmslmin(lat: np.ndarray, lon: np.ndarray,\n center_lat_index: float, center_lon_index: float,\n prmsl: np.ndarray, date: str):# -> CenterInfo:\n \"\"\"find center of cyclone using user's input lat,lon.\"\"\"\n # if y,x are not varid value, then convert to int and recursion function.\n flag = True\n prmsl_min = 99999\n prmsl_min_lat, prmsl_min_lon = np.where(lat == center_lat_index), np.where(lon == center_lon_index)\n if lat[prmsl_min_lat].size == 0:\n center_lat_index = round(center_lat_index)\n flag = False\n if lon[prmsl_min_lon].size == 0:\n center_lon_index = round(center_lon_index)\n flag = False\n if not flag:\n return find_initial_prmslmin(lat, lon, center_lat_index, center_lon_index, prmsl, date)\n\n lat_search_area = np.arange(-2, 2.1, 0.5)\n lon_search_area = np.arange(-2, 2.1, 0.5)\n for la in [np.where(lat == i) for i in (lat_search_area + center_lat_index) if 20 <= i <= 60]:\n for lo in [np.where(lon == i) for i in (lon_search_area + center_lon_index) if 110 <= i <= 180]:\n la_index = (list(map(int, la))[0])\n lo_index = (list(map(int, lo))[0])\n\n if prmsl[la_index][lo_index] < prmsl_min:\n min_data = CenterInfo(\n la_index, lo_index, prmsl[la_index][lo_index],\n lat[la_index], lon[lo_index], date\n )\n prmsl_min = prmsl[la_index][lo_index]\n print(min_data)\n return min_data\n\n\ndef find_next_prmslmin(lat:np.ndarray, lon:np.ndarray, prmsl: np.ndarray,\n prev_center_info, date: str) -> CenterInfo:\n \"\"\"Using previous cyclone center location. Find next cyclone center location.\"\"\"\n prmsl_min = 99999\n prev_min_lat = prev_center_info.lat\n prev_min_lon = prev_center_info.lon\n #lat_search_area = np.arange(-6, 6.1, 0.5)\n #lon_search_area = np.arange(-9, 9.1, 0.5)\n #lat_search_area = np.arange(-3, 3.1, 0.5)\n #lon_search_area = np.arange(-5, 5.1, 0.5)\n lat_search_area = np.arange(-3, 3.1, 0.5)\n lon_search_area = np.arange(-1, 7.1, 0.5)\n\n for la in [np.where(lat == i) for i in lat_search_area + prev_min_lat if 20 <= i <= 60]:\n for lo in [np.where(lon == i) for i in lon_search_area + prev_min_lon if 110 <= i <= 180]:\n la_index = (list(map(int, la))[0])\n lo_index = (list(map(int, lo))[0])\n\n if prmsl[la_index][lo_index] < prmsl_min:\n min_data = CenterInfo(\n la_index, lo_index, prmsl[la_index][lo_index],\n lat[la_index], lon[lo_index], date\n )\n prmsl_min = prmsl[la_index][lo_index]\n print(min_data)\n return min_data\n\n\ndef cal_deeping_rate(prmsl_tracks: list):\n \"\"\"calcurate cycloen deeping rate.\"\"\"\n for i in range(1, len(prmsl_tracks)-1, 1):\n prmsl6h_ago = prmsl_tracks[i-1].prmsl\n prmsl6h_later = prmsl_tracks[i+1].prmsl\n nowlat_rad = math.radians(prmsl_tracks[i].lat)\n rad_45 = math.radians(45)\n\n prmsl_tracks[i].epsilon = (\n (prmsl6h_ago - prmsl6h_later)/12) * (math.sin(rad_45)/math.sin(nowlat_rad))\n\n\ndef write_data(prmsl_tracks, outname: str):\n \"\"\"write_data.\n\n Args:\n prmsl_tracks:\n outname (str): outname\n \"\"\"\n columns = [\"year-month-day_Hour\", \"prmsl center (hPa)\",\"latitude\", \"longitude\",\n \"deepingRate\", \"u_wind\", \"v_wind\", \"abs_wind\", \"direction of wind(rad)\"]\n file_path = join(abspath(dirname(__file__)) + \"/\" + outname + \".csv\")\n with open(file_path, mode='w') as f:\n f.write(\"{}\\n\".format(\",\".join(columns)))\n for p in prmsl_tracks:\n datas = list(map(str, [p.date, p.prmsl, p.lat, p.lon, p.epsilon, p.u_wind, p.v_wind, p.abs_wind, p.wind_direction]))\n f.write(\"{}\\n\".format(\",\".join(datas)))\n\n\ndef main():\n \"\"\"main\n 1. Set initial cyclone center info, initialtime,\n directory path from stdin.\n 2. Make file list using directory path.\n 3. Get lan lot data and extract near japan area.\n 4. Find cyclone center location data and store in CenterInfo.\n 5. Go to next files and find next cyclone center location data.\n 6. Save to CSV file.\n \"\"\"\n args = parse_args()\n\n data_root_dir = join(abspath(args[\"dir\"]))\n data_root_dir_has_datetime = re.search('[0-9]{10}', data_root_dir)\n if data_root_dir_has_datetime:\n outname = data_root_dir_has_datetime.group()\n else:\n outname = \"initialdata\"\n start_date = datetime.strptime(args[\"time\"], \"%Y-%m-%d_%H\")\n ncfiles = mk_prmsl_file_list(data_root_dir, start_date)\n\n # initial cyclone center data.\n prmsl_tracks = []\n lat, lon, near_jp_lat, near_jp_lon, prmsl = read_loc_prmsl(ncfiles[0])\n pressure_center = find_initial_prmslmin(\n near_jp_lat, near_jp_lon, args[\"lat\"], args[\"lon\"], prmsl, args[\"time\"])\n pressure_center.u_wind = pressure_center.read_wind(\n ncfiles[0], lat, lon, near_jp_lat, near_jp_lon,\n 'u10',\n )\n pressure_center.v_wind = pressure_center.read_wind(\n ncfiles[0], lat, lon, near_jp_lat, near_jp_lon,\n 'v10',\n )\n prmsl_tracks.append(pressure_center)\n\n # next cyclone center data.\n for i in range(1, len(ncfiles), 1):\n lat, lon, near_jp_lat, near_jp_lon, prmsl = read_loc_prmsl(ncfiles[i])\n\n ncfiles_has_datetime = re.search('[0-9]{4}-[0-9]{2}-[0-9]{2}_[0-9]{2}', ncfiles[i])\n if ncfiles_has_datetime:\n date = ncfiles_has_datetime.group()\n else:\n raise Exception(\"ncfiles doesn't have datetime.\")\n\n pressure_center = find_next_prmslmin(\n near_jp_lat, near_jp_lon, prmsl, pressure_center, date)\n pressure_center.u_wind = pressure_center.read_wind(\n ncfiles[i], lat, lon, near_jp_lat, near_jp_lon,\n 'u10'\n )\n pressure_center.v_wind = pressure_center.read_wind(\n ncfiles[i], lat, lon, near_jp_lat, near_jp_lon,\n 'v10'\n )\n pressure_center.abs_wind = (pressure_center.u_wind ** 2\n + pressure_center.v_wind ** 2) ** 0.5\n pressure_center.wind_direction = np.arctan2(pressure_center.u_wind, pressure_center.v_wind)\n\n prmsl_tracks.append(pressure_center)\n if pressure_center.lon == 180.0:\n break\n\n cal_deeping_rate(prmsl_tracks)\n write_data(prmsl_tracks, outname)\n\n\nif __name__ == \"__main__\":\n main()\n", "meta": {"hexsha": "e62a1308cb7484cc99368cb0aa9d3ac37c27da15", "size": 11908, "ext": "py", "lang": "Python", "max_stars_repo_path": "main/oldVersion/cyclone_deepingrate.py", "max_stars_repo_name": "RyosukeDTomita/gcmPlot", "max_stars_repo_head_hexsha": "430f8af353daf464b5c5566f1c163d5bef63f584", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "main/oldVersion/cyclone_deepingrate.py", "max_issues_repo_name": "RyosukeDTomita/gcmPlot", "max_issues_repo_head_hexsha": "430f8af353daf464b5c5566f1c163d5bef63f584", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "main/oldVersion/cyclone_deepingrate.py", "max_forks_repo_name": "RyosukeDTomita/gcmPlot", "max_forks_repo_head_hexsha": "430f8af353daf464b5c5566f1c163d5bef63f584", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.6162790698, "max_line_length": 128, "alphanum_fraction": 0.6046355391, "include": true, "reason": "import numpy", "num_tokens": 3350, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5389832206876841, "lm_q2_score": 0.36658972248186006, "lm_q1q2_score": 0.19758570929427727}} {"text": "# pylint: disable=too-many-locals,too-many-lines\nimport os\nimport io\nimport math\nimport json\nimport shlex\nimport queue\nimport base64\nimport typing\nimport hashlib\nimport warnings\nimport logging\nimport fractions\nimport threading\nimport functools\nimport itertools\nimport subprocess\nfrom urllib import request\nfrom http import client\n\nimport numpy as np\nimport validators\nimport cv2\n\ntry:\n import PIL\n import PIL.Image\nexcept ImportError: # pragma: no cover\n PIL = None\n\nLOGGER = logging.getLogger(__name__)\n\nImageInputType = typing.Union[str, np.ndarray, 'PIL.Image.Image', io.BytesIO]\n\nSIZES = {'float32': 32, 'uint8': 8, 'bool': 1}\n\n# Map codec names to the CUDA-accelerated version. Obtain\n# from ffmpeg -codecs after building using CUDA.\nCUDA_CODECS = {\n \"h264\": \"h264_cuvid\",\n \"hevc\": \"hevc_cuvid\",\n \"mjpeg\": \"mjpeg_cuvid\",\n \"mpeg1video\": \"mpeg1_cuvid\",\n \"mpeg2video\": \"mpeg2_cuvid\",\n \"mpeg4\": \"mpeg4_cuvid\",\n \"vc1\": \"vc1_cuvid\",\n \"vp8\": \"vp8_cuvid\",\n \"vp9\": \"vp9_cuvid\",\n}\n\nFramesWithIndexesAndTimestamps = typing.Generator[\n typing.Tuple[np.ndarray, typing.Optional[int], typing.\n Optional[float]], None, None]\n\n\ndef get_ffprobe():\n return os.environ.get(\"PERCEPTION_FFPROBE_BINARY\", \"ffprobe\")\n\n\ndef get_ffmpeg():\n return os.environ.get(\"PERCEPTION_FFMPEG_BINARY\", \"ffmpeg\")\n\n\n# pylint: disable=invalid-name\ndef compute_quality(image) -> int:\n \"\"\"Compute a quality metric, using the calculation proposed by\n `Facebook `_\n for their PDQ hash algorithm.\"\"\"\n if len(image.shape) == 3:\n image = cv2.cvtColor(image, code=cv2.COLOR_RGB2GRAY)\n if image.shape[0] != 64 or image.shape[1] != 64:\n image = cv2.resize(src=image, dsize=(64, 64)).astype('float32')\n dx = 100 * np.abs(image[:, 1:] - image[:, :-1]) / 255\n dy = 100 * np.abs(image[1:] - image[:-1]) / 255\n dx = dx.astype('int').sum()\n dy = dy.astype('int').sum()\n return int(np.clip(a=int((dx + dy) / 90), a_min=0, a_max=100))\n\n\ndef compute_md5(filepath) -> str:\n \"\"\"Compute the md5 hash for a file at `filepath`.\n\n Args:\n filepath: The path to the file\n \"\"\"\n with open(filepath, 'rb') as f: # pylint: disable=invalid-name\n hash_str = hashlib.md5(f.read()).hexdigest()\n return hash_str\n\n\ndef get_string_length(hash_length: int, dtype: str, hash_format='hex') -> int:\n \"\"\"Compute the expected length of a hash string.\n\n Args:\n hash_length: The length of the hash vector\n dtype: The dtype of the vector\n hash_format: One of 'base64' or 'hex'\n\n Returns:\n The expected string length\n \"\"\"\n hash_bytes = math.ceil(hash_length * SIZES[dtype] / 8)\n\n if hash_format == 'base64':\n return int((4 * hash_bytes / 3) + 3) & ~3\n if hash_format == 'hex':\n return 2 * hash_bytes\n raise NotImplementedError('Unknown hash format: ' + hash_format)\n\n\ndef vector_to_string(vector: np.ndarray, dtype: str,\n hash_format: str) -> typing.Optional[str]:\n \"\"\"Convert vector to hash.\n\n Args:\n vector: Input vector\n \"\"\"\n # At times, a vector returned by a hasher is None (e.g., for hashes\n # that depend on the image not being featureless). In those cases,\n # we need to just return None, which is the least surprising outcome\n # because after all, the string representation of None is None.\n if vector is None:\n return None\n if hash_format == 'vector':\n # return vector.astype(dtype) # old behavior\n raise DeprecationWarning(\"`hash_format` `vector` has been removed.\")\n if dtype == 'uint8':\n vector_bytes = vector.astype('uint8')\n elif dtype == 'float32':\n vector_bytes = vector.astype('float32')\n elif dtype == 'bool':\n vector_bytes = np.packbits(vector.astype('bool'))\n else:\n raise NotImplementedError(f'Cannot convert hash of type {dtype}.')\n if hash_format == 'base64':\n return base64.b64encode(vector_bytes.tobytes()).decode('utf-8')\n if hash_format == 'hex':\n return vector_bytes.tobytes().hex()\n raise NotImplementedError(\n f'Cannot convert to string format: {hash_format}.')\n\n\ndef string_to_vector(hash_string: str,\n dtype: str,\n hash_length: int,\n hash_format: str,\n verify_length: bool = True) -> np.ndarray:\n \"\"\"Convert hash back to vector.\n\n Args:\n hash_string: The input hash string\n dtype: The data type of the hash\n hash_length: The length of the hash vector\n hash_format: The input format of the hash (base64 or hex)\n verify_length: Whether to verify the string length\n \"\"\"\n assert not verify_length or len(hash_string) == get_string_length(\n hash_length=hash_length, hash_format=hash_format,\n dtype=dtype), 'Incorrect string length for this hash format.'\n if hash_format == 'base64':\n vector_bytes = np.frombuffer(\n base64.b64decode(hash_string),\n dtype='uint8' if dtype in ['bool', 'uint8'] else dtype)\n elif hash_format == 'hex':\n vector_bytes = np.frombuffer(\n bytearray.fromhex(hash_string),\n dtype='uint8' if dtype in ['bool', 'uint8'] else dtype)\n else:\n raise NotImplementedError(\n f'Cannot convert to string format: {hash_format}')\n if dtype == 'uint8':\n return vector_bytes[:hash_length]\n if dtype == 'float32':\n return vector_bytes[:hash_length]\n if dtype == 'bool':\n return np.unpackbits(vector_bytes)[:hash_length].astype('bool')\n raise NotImplementedError(f'Cannot convert hash of type {dtype}.')\n\n\ndef hex_to_b64(hash_string: str,\n dtype: str,\n hash_length: int,\n verify_length: bool = True):\n \"\"\"Convert a hex-encoded hash to base64.\n\n Args:\n hash_string: The input base64 hash string\n dtype: The data type of the hash\n hash_length: The length of the hash vector\n verify_length: Whether to verify the string length\n \"\"\"\n return vector_to_string(\n string_to_vector(\n hash_string,\n hash_length=hash_length,\n hash_format='hex',\n dtype=dtype,\n verify_length=verify_length),\n dtype=dtype,\n hash_format='base64')\n\n\ndef b64_to_hex(hash_string: str,\n dtype: str,\n hash_length: int,\n verify_length: bool = True):\n \"\"\"Convert a base64-encoded hash to hex.\n\n Args:\n hash_string: The input hex hash string\n dtype: The data type of the hash\n hash_length: The length of the hash vector\n verify_length: Whether to verify the string length\n \"\"\"\n return vector_to_string(\n string_to_vector(\n hash_string,\n hash_length=hash_length,\n hash_format='base64',\n dtype=dtype,\n verify_length=verify_length),\n dtype=dtype,\n hash_format='hex')\n\n\ndef to_image_array(image: ImageInputType, require_color=True):\n if isinstance(image, np.ndarray):\n assert image.flags['C_CONTIGUOUS'], (\n 'Provided arrays must be contiguous to avoid '\n 'erroneous results when arrays are passed to '\n 'underlying libraries. This can be achieved using'\n 'np.ascontiguousarray(image)')\n assert not require_color or (len(image.shape) == 3\n and image.shape[-1] == 3), (\n 'Provided images must be RGB images.')\n return image\n return read(image)\n\n\ndef get_common_framerates(id_rates: dict):\n \"\"\"Compute an optimal set of framerates for a list\n of framerates. Optimal here means that reading the video\n at each of the framerates will allow one to collect all\n of the frames required with the smallest possible number of\n frames decoded.\n\n For example, consider if we need to read a video at\n 3 fps, 5 fps, 1 fps and 0.5 fps. We could read the video\n 4 times (once per framerate). But a more optimal approach\n is to read the video only twice, once at 3 frames per second\n and another time at 5 frames per second. For the 1 fps hasher,\n we simply pass every 3rd frame of the 3 fps pass. For the\n 0.5 fps hasher, we pass every 6th frame of the 3 fps pass. So\n if you pass this function {A: 3, B: 5, C: 1, D: 0.5}, you will\n get back {3: [A, C, D], 5: C}.\n\n Args:\n id_rates: A dictionary with IDs as keys and frame rates as values.\n\n Returns:\n rate_ids: A dictionary with framerates as keys and a list of\n ids as values.\n \"\"\"\n\n def partition(collection):\n \"\"\"This function taken from\n https://stackoverflow.com/questions/19368375/set-partitions-in-python/30134039#30134039\n \"\"\"\n if len(collection) == 1:\n yield [collection]\n return\n\n first = collection[0]\n for smaller in partition(collection[1:]):\n # insert `first` in each of the subpartition's subsets\n for n, subset in enumerate(smaller):\n yield smaller[:n] + [[first] + subset] + smaller[n + 1:]\n # put `first` in its own subset\n yield [[first]] + smaller\n\n framerates = list(id_rates.values())\n factor = 2 * 3 * 5 * 7 * 11 * 60 * 60\n assert min(framerates\n ) >= 1 / factor, 'Framerates must be at least 1 frame per hour.'\n best_frame_count = np.inf\n best_grouping: typing.Optional[typing.List] = None\n best_frame_rates: typing.Optional[typing.List] = None\n\n # We try every possible grouping of framerates to minimize the number\n # of frames we decode. There is likely a better way to do this,\n # but this seems to do the job for now.\n for grouping in partition(list(set(framerates))):\n current_frame_rates = [\n # pylint: disable=no-member\n functools.reduce(np.lcm,\n (np.array(group) * factor).round().astype(int)) /\n factor for group in grouping\n ]\n current_frame_count = sum(current_frame_rates)\n if current_frame_count < best_frame_count:\n best_frame_count = current_frame_count\n best_frame_rates = current_frame_rates\n best_grouping = grouping\n\n assert best_frame_rates is not None\n assert best_grouping is not None\n return {\n framerate:\n tuple(name for name, rate in id_rates.items() if rate in group)\n for framerate, group in zip(best_frame_rates, best_grouping)\n }\n\n\ndef get_isometric_transforms(image: ImageInputType, require_color=True):\n image = to_image_array(image, require_color=require_color)\n return dict(\n r0=image,\n fv=np.ascontiguousarray(image[::-1, :]),\n fh=np.ascontiguousarray(image[:, ::-1]),\n r180=np.ascontiguousarray(image[::-1, ::-1]),\n r90=np.ascontiguousarray(image.transpose(1, 0, 2)[::-1, :, :]),\n r90fv=np.ascontiguousarray(image.transpose(1, 0, 2)),\n r90fh=np.ascontiguousarray(image.transpose(1, 0, 2)[::-1, ::-1]),\n r270=np.ascontiguousarray(image.transpose(1, 0, 2)[:, ::-1]))\n\n\ndef get_isometric_dct_transforms(dct: np.ndarray):\n # pylint: disable=invalid-name\n T1 = np.empty_like(dct)\n T1[::2] = 1\n T1[1::2] = -1\n\n # pylint: disable=invalid-name\n T2 = np.empty_like(dct)\n T2[::2, ::2] = 1\n T2[1::2, 1::2] = 1\n T2[::2, 1::2] = -1\n T2[1::2, ::2] = -1\n return dict(\n r0=dct,\n fv=dct * T1,\n fh=dct * T1.T,\n r180=dct * T2,\n r90=dct.T * T1,\n r90fv=dct.T,\n r90fh=dct.T * T2,\n r270=dct.T * T1.T)\n\n\ndef read(filepath_or_buffer: ImageInputType, timeout=None):\n \"\"\"Read a file into an image object\n\n Args:\n filepath_or_buffer: The path to the file or any object\n with a `read` method (such as `io.BytesIO`)\n timeout: If filepath_or_buffer is a URL, the timeout to\n use for making the HTTP request.\n \"\"\"\n if PIL is not None and isinstance(filepath_or_buffer, PIL.Image.Image):\n return np.array(filepath_or_buffer.convert(\"RGB\"))\n if isinstance(filepath_or_buffer, (io.BytesIO, client.HTTPResponse)):\n image = np.asarray(\n bytearray(filepath_or_buffer.read()), dtype=np.uint8)\n image = cv2.imdecode(image, cv2.IMREAD_UNCHANGED)\n elif isinstance(filepath_or_buffer, str):\n if validators.url(filepath_or_buffer):\n return read(request.urlopen(filepath_or_buffer, timeout=timeout))\n if not os.path.isfile(filepath_or_buffer):\n raise FileNotFoundError('Could not find image at path: ' +\n filepath_or_buffer)\n image = cv2.imread(filepath_or_buffer)\n else:\n raise RuntimeError(\"Unhandled filepath_or_buffer type: \" +\n str(type(filepath_or_buffer)))\n if image is None:\n raise ValueError(f'An error occurred reading {filepath_or_buffer}.')\n # We use cvtColor here instead of just ret[..., ::-1]\n # in order to ensure that we provide a contiguous\n # array for later processing. Some hashers use ctypes\n # to pass the array and non-contiguous arrays can lead\n # to erroneous results.\n return cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n\n\ndef _get_keyframes(filepath):\n \"\"\"Get the keyframes for a video.\n\n Args:\n filepath: Path to the target file\n\n Returns:\n A list of frame indexes.\n \"\"\"\n args = [\n get_ffprobe(), '-select_streams', 'v', '-i', f\"'{filepath}'\",\n '-print_format', 'json', '-show_entries',\n 'frame=pict_type,coded_picture_number'\n ]\n with subprocess.Popen(\n args, stdout=subprocess.PIPE, stderr=subprocess.PIPE) as p:\n out, err = p.communicate()\n if p.returncode != 0:\n raise ValueError(\"{out}: {err}\".format(out=str(out), err=str(err)))\n data = json.loads(out.decode('utf-8'))['frames']\n frames = [\n f['coded_picture_number'] for f in data if f['pict_type'] == 'I'\n ]\n frames = list(set(frames))\n frames.sort()\n return frames\n\n\ndef get_video_properties(filepath):\n cmd = f\"\"\"\n {get_ffprobe()} -select_streams v:0 -i '{filepath}'\n -print_format json -show_entries stream=width,height,avg_frame_rate,codec_name,start_time\n \"\"\"\n with subprocess.Popen(\n shlex.split(cmd), stdout=subprocess.PIPE,\n stderr=subprocess.PIPE) as p:\n out, err = p.communicate()\n if p.returncode != 0:\n raise ValueError(\"{out}: {err}\".format(out=str(out), err=str(err)))\n data = json.loads(out.decode(\"utf-8\"))[\"streams\"][0]\n numerator, denominator = tuple(\n map(int, data[\"avg_frame_rate\"].split(\"/\")[:2]))\n avg_frame_rate: typing.Optional[fractions.Fraction]\n if numerator > 0 and denominator > 0:\n avg_frame_rate = fractions.Fraction(\n numerator=numerator, denominator=denominator)\n else:\n avg_frame_rate = None\n return data[\"width\"], data[\"height\"], avg_frame_rate, data[\n \"codec_name\"], float(data.get(\"start_time\", \"0\"))\n\n\n# pylint: disable=too-many-branches,too-many-statements,too-many-arguments\ndef read_video_to_generator_ffmpeg(\n filepath,\n frames_per_second: typing.Optional[typing.Union[str, float]] = None,\n errors=\"raise\",\n max_duration: float = None,\n max_size: int = None,\n interp: str = None,\n frame_rounding: str = \"up\",\n draw_timestamps=False,\n use_cuda=False) -> FramesWithIndexesAndTimestamps:\n \"\"\"This is used by :code:`read_video` when :code:`use_ffmpeg` is True. It\n differs from :code:`read_video_to_generator` in that it uses FFMPEG instead of\n OpenCV and, optionally, allows for CUDA acceleration. CUDA acceleration\n can be faster for larger videos (>1080p) where downsampling is desired.\n For other videos, CUDA may be slower, but the decoding load will still be\n taken off the CPU, which may still be advantageous. You can specify which\n FFMPEG binary to use by setting PERCEPTION_FFMPEG_BINARY.\n\n Args:\n filepath: See read_video\n frames_per_second: See read_video\n errors: See read_video\n max_duration: See read_video\n max_size: See read_video\n interp: The interpolation method to use. When not using CUDA, you must choose one\n of the `interpolation options `_\n (default: area). When using CUDA, you must choose from the\n `interp_algo options `_\n (default: super).\n frame_rounding: The frame rounding method.\n draw_timestamps: Draw original timestamps onto the frames (for debugging only)\n use_cuda: Whether to enable CUDA acceleration. Requires a\n CUDA-accelerated version of ffmpeg.\n\n To build FFMPEG with CUDA, do the following in a Docker\n container based on nvidia/cuda:10.1-cudnn7-devel-ubuntu18.04. The\n FFMPEG binary will be ffmpeg/ffmpeg.\n\n .. code-block:: bash\n\n git clone https://git.videolan.org/git/ffmpeg/nv-codec-headers.git\n cd nv-codec-headers\n make\n sudo make install\n cd ..\n git clone --branch release/4.3 https://git.ffmpeg.org/ffmpeg.git\n cd ffmpeg\n sudo apt-get update && sudo apt-get -y install yasm\n export PATH=$PATH:/usr/local/cuda/bin\n ./configure --enable-cuda-nvcc --enable-cuvid --enable-nvenc --enable-nvdec \\\n --enable-libnpp --enable-nonfree --extra-cflags=-I/usr/local/cuda/include \\\n --extra-ldflags=-L/usr/local/cuda/lib64\n make -j 10\n\n Returns:\n See :code:`read_video`\n \"\"\"\n if interp is None:\n interp = \"super\" if use_cuda else \"area\"\n try:\n raw_width, raw_height, avg_frame_rate, codec_name, start_time = get_video_properties(\n filepath)\n start_time_offset = 0.0 if avg_frame_rate is None else float(\n (1 / (2 * avg_frame_rate)))\n LOGGER.debug(\n \"raw_width: %s, raw_height: %s, avg_frame_rate: %s, codec_name: %s, start_time: %s\",\n raw_width, raw_height, avg_frame_rate, codec_name, start_time)\n channels = 3\n scale = (min(max_size / raw_width, max_size / raw_height, 1)\n if max_size is not None else 1)\n width, height = map(lambda d: int(round(scale * d)),\n [raw_width, raw_height])\n # If there is no average frame rate, the offset tends to be unreliable.\n offset = max(start_time,\n start_time_offset) if avg_frame_rate is not None else 0\n cmd = (f\"{get_ffmpeg()} -hide_banner -an -vsync 0 -loglevel fatal \"\n f\"-itsoffset -{offset}\")\n filters = []\n if draw_timestamps:\n pattern = \"%{pts}-%{frame_num}\"\n filters.append(f\"drawtext=fontsize={int(raw_height * 0.1)}:\"\n f\"fontcolor=yellow:text={pattern}\"\n \":x=(w-text_w):y=(h-text_h)\")\n # Add frame rate filters.\n if frames_per_second is None:\n seconds_per_frame = float(\n 1 / avg_frame_rate) if avg_frame_rate is not None else None\n elif frames_per_second == \"keyframes\":\n seconds_per_frame = None\n filters.append(r\"select=eq(pict_type\\,I)\")\n else:\n assert isinstance(\n frames_per_second,\n (float, int)), f\"Invalid framerate: {frames_per_second}\"\n seconds_per_frame = 1 / frames_per_second\n filters.append(f\"fps={frames_per_second}:\"\n f\"round={frame_rounding}:\"\n f\"start_time={offset}\")\n # Add resizing filters.\n if use_cuda and codec_name in CUDA_CODECS:\n cuda_codec = CUDA_CODECS[codec_name]\n cmd += f\" -hwaccel cuda -c:v {cuda_codec}\"\n filters.append(\"hwupload_cuda\")\n if scale != 1:\n filters.append(\n f\"scale_npp={width}:{height}:interp_algo={interp}\")\n filters.extend([\n \"hwdownload\",\n \"format=nv12\",\n ])\n elif scale != 1:\n filters.append(f\"scale={width}:{height}:flags={interp}\")\n cmd += f\" -i '{filepath}'\"\n if filters:\n cmd += \" -vf '{fstring}'\".format(fstring=\",\".join(filters))\n cmd += \" -pix_fmt rgb24 -f image2pipe -vcodec rawvideo -\"\n LOGGER.debug(\"running ffmpeg with: %s\", cmd)\n framebytes = width * height * channels\n bufsize = framebytes * int(\n os.environ.get(\"PERCEPTION_FFMPEG_BUFSIZE\", \"5\"))\n with subprocess.Popen(\n shlex.split(cmd),\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE,\n bufsize=bufsize) as p:\n assert p.stdout is not None, \"Could not launch subprocess pipe.\"\n timestamp: typing.Optional[float] = 0\n frame_index: typing.Optional[int] = 0\n while True:\n batch = p.stdout.read(bufsize)\n if not batch:\n break\n for image in np.frombuffer(\n batch, dtype=\"uint8\").reshape((-1, height, width,\n channels)):\n if frames_per_second != \"keyframes\":\n yield (image, frame_index, timestamp)\n if seconds_per_frame is not None:\n assert timestamp is not None\n timestamp += seconds_per_frame\n frame_index = math.ceil(\n avg_frame_rate * timestamp\n ) if avg_frame_rate is not None else None\n else:\n timestamp = None\n frame_index = None\n else:\n # Obtaining the keyframe indexes with ffprobe is very slow (slower\n # than reading the video sometimes). We don't *have* to do it\n # when using ffmpeg, so we don't. The OpenCV approach *does*\n # get the keyframe indexes, but only because they're required\n # in order to select them.\n yield (image, None, None)\n if (max_duration is not None and timestamp is not None\n and timestamp > max_duration):\n break\n stdout, stderr = p.communicate()\n if p.returncode != 0:\n raise ValueError(\n f\"Error parsing video: {stdout.decode('utf-8')} {stderr.decode('utf-8')}\"\n )\n # pylint: disable=broad-except\n except Exception as e:\n if errors not in [\"warn\", \"ignore\"]:\n raise e\n if errors == \"warn\":\n warnings.warn(\n message=\n f\"An error occurred while reading {filepath}. Processing may be truncated.\"\n )\n\n\n# pylint: disable=too-many-branches,too-many-locals,too-many-statements\ndef read_video_to_generator(\n filepath,\n frames_per_second: typing.Optional[typing.Union[str, float]] = None,\n errors='raise',\n max_duration: float = None,\n max_size: int = None) -> FramesWithIndexesAndTimestamps:\n \"\"\"This is used by :code:`read_video` when :code:`use_ffmpeg` is False (default).\n\n Args:\n filepath: See :code:`read_video`.\n frames_per_second: See :code:`read_video`.\n errors: See :code:`read_video`.\n max_duration: See :code:`read_video`.\n max_size: See :code:`read_video`.\n\n Returns:\n See :code:`read_video`.\n \"\"\"\n # pylint: disable=no-member\n if cv2.__version__ < '4.1.1' and filepath.lower().endswith('gif'):\n message = 'Versions of OpenCV < 4.1.1 may read GIF files improperly. Upgrade recommended.'\n if errors == 'raise':\n raise ValueError(message)\n warnings.warn(message=message)\n\n if not os.path.isfile(filepath):\n raise FileNotFoundError(f'Could not find {filepath}.')\n cap = cv2.VideoCapture(filename=filepath, apiPreference=cv2.CAP_FFMPEG)\n try:\n # The purpose of the following block is largely to create a\n # frame_indexes (iterator or list) that indicates which\n # frames we should be returning to the user and then\n # yielding those frames as we come across them.\n file_frames_per_second = cap.get(cv2.CAP_PROP_FPS)\n if file_frames_per_second == 0:\n if errors == \"raise\":\n raise ValueError(\"Video file has framerate of 0fps.\")\n # The known case where this occurs is for GIFs, where\n # 0 fps is typically inferred as 10 fps.\n file_frames_per_second = 10\n if errors == \"warn\":\n warnings.warn(\n message=\n \"Video file has framerate of 0 fps. Guessing framerate of 10fps.\"\n )\n if frames_per_second is None:\n frames_per_second = file_frames_per_second\n seconds_between_desired_frames = None if (\n frames_per_second is not None\n and isinstance(frames_per_second,\n str)) else 1 / frames_per_second # type: ignore\n seconds_between_grabbed_frames = 1 / file_frames_per_second\n grabbed_frame_count = 0\n if frames_per_second == 'keyframes':\n frame_indexes: typing.Union[range, typing.List[int], typing.\n Iterator[int]] = _get_keyframes(\n filepath)\n # The repeat flag is used to handle the case where the\n # desired sampling rate is higher than the file's frame\n # rate. In this case, we will need to repeat frames in\n # order to provide the least-surprising behavior that\n # we can.\n repeat = False\n else:\n frame_indexes = itertools.count(\n 0, max(1, file_frames_per_second / frames_per_second))\n repeat = file_frames_per_second < frames_per_second\n input_width = cap.get(cv2.CAP_PROP_FRAME_WIDTH)\n input_height = cap.get(cv2.CAP_PROP_FRAME_HEIGHT)\n if max_size is not None:\n scale = min(max_size / max(input_width, input_height), 1)\n else:\n scale = 1\n target_size: typing.Optional[typing.Tuple[int, int]]\n if scale < 1:\n target_size = (int(scale * input_width), int(scale * input_height))\n else:\n target_size = None\n for frame_index in frame_indexes:\n while grabbed_frame_count < frame_index:\n # We need to skip this frame.\n success = cap.grab()\n if not success:\n break\n grabbed_frame_count += 1\n success, frame = cap.read()\n grabbed_frame_count += 1\n if not success:\n # The video is over or an error has occurred.\n break\n frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n if target_size is not None:\n frame = cv2.resize(\n frame, target_size, interpolation=cv2.INTER_NEAREST)\n current_timestamp = frame_index / file_frames_per_second\n yield frame, grabbed_frame_count - 1, current_timestamp\n if max_duration is not None and current_timestamp > max_duration:\n break\n if repeat:\n next_desired_timestamp = current_timestamp + seconds_between_desired_frames\n next_timestamp = current_timestamp + seconds_between_grabbed_frames\n while next_desired_timestamp < next_timestamp:\n yield (frame, grabbed_frame_count - 1,\n next_desired_timestamp)\n next_desired_timestamp += seconds_between_desired_frames\n # pylint: disable=broad-except\n except Exception as e:\n if errors not in ['warn', 'ignore']:\n raise e\n if errors == 'warn':\n warnings.warn(\n message=\n f'An error occurred while reading {filepath}. Processing may be truncated.'\n )\n finally:\n cap.release()\n\n\ndef read_video_into_queue(*args, video_queue, terminate, func, **kwargs):\n # We're inside a thread now and the queue is being read elsewhere.\n try:\n for frame, frame_index, timestamp in func(*args, **kwargs):\n if not terminate.isSet():\n video_queue.put((frame, frame_index, timestamp))\n else:\n break\n finally:\n video_queue.put((None, None, None))\n\n\n# pylint: disable=too-many-arguments\ndef read_video(\n filepath,\n frames_per_second: typing.Optional[typing.Union[str, float]] = None,\n max_queue_size=128,\n use_queue=True,\n errors='raise',\n use_ffmpeg=False,\n **kwargs) -> FramesWithIndexesAndTimestamps:\n \"\"\"Provides a generator of RGB frames, frame indexes, and timestamps from a\n video. This function requires you to have installed ffmpeg. All other\n arguments passed to read_video_to_generator.\n\n Args:\n filepath: Path to the video file\n frames_per_second: How many frames to provide for\n each second of video. If None, all frames\n are provided. If frames_per_second is \"keyframes\",\n we use ffmpeg to select I frames from the video.\n max_queue_size: The maximum number of frames to load in the queue\n use_queue: Whether to use a queue of frames during processing\n max_duration: The maximum length of the video to hash.\n max_size: The maximum size of frames to queue\n errors: Whether to 'raise', 'warn', or 'ignore' errors\n use_ffmpeg: Whether to use the FFMPEG CLI to read videos. If True, other\n kwargs (e.g., :code:`use_cuda`) are passed to\n :code:`read_video_to_generator_ffmpeg`.\n\n Yields:\n (frame, frame_index, timestamp) tuples\n \"\"\"\n for ffmpeg_kwarg in [\n \"interp\", \"frame_rounding\", \"draw_timestamps\", \"use_cuda\"\n ]:\n if not use_ffmpeg and ffmpeg_kwarg in kwargs:\n warnings.warn(\n f\"{ffmpeg_kwarg} is ignored when use_ffmpeg is False.\",\n UserWarning)\n del kwargs[ffmpeg_kwarg]\n generator: typing.Callable[..., FramesWithIndexesAndTimestamps]\n if use_ffmpeg:\n generator = read_video_to_generator_ffmpeg\n else:\n generator = read_video_to_generator\n frame_index: typing.Optional[int]\n timestamp: typing.Optional[float]\n if use_queue:\n video_queue = queue.Queue(\n maxsize=max_queue_size\n ) # type: queue.Queue[typing.Tuple[np.ndarray, int, float]]\n terminate = threading.Event()\n thread = threading.Thread(\n target=read_video_into_queue,\n kwargs={\n 'frames_per_second': frames_per_second,\n 'func': generator,\n 'video_queue': video_queue,\n 'filepath': filepath,\n 'errors': errors,\n 'terminate': terminate,\n **kwargs\n })\n thread.start()\n try:\n while True:\n frame, frame_index, timestamp = video_queue.get()\n video_queue.task_done()\n if frame is None:\n break\n yield (frame, frame_index, timestamp)\n finally:\n # Set the termination flag for the\n # background thread.\n terminate.set()\n try:\n # Unblock the thread, in the event\n # that it is waiting.\n video_queue.get_nowait()\n\n # Do it twice for the edge case\n # where the queue is completely\n # full and the end sentinel is\n # blocking.\n video_queue.get_nowait()\n except queue.Empty:\n # It doesn't matter if it's empty.\n pass\n # Wait for the background thread to terminate.\n thread.join()\n else:\n for frame, frame_index, timestamp in generator(\n filepath=filepath,\n frames_per_second=frames_per_second,\n errors=errors,\n **kwargs):\n yield (frame, frame_index, timestamp)\n\n\ndef compute_synchronized_video_hashes(filepath: str,\n hashers: dict,\n framerates=None,\n hash_format='base64',\n use_queue=True):\n \"\"\"Compute the video hashes for a group of hashers with synchronized\n frame processing wherever possible.\n\n Args:\n filepath: Path to video file.\n hashers: A dictionary mapping hasher names to video hasher objects\n hash_format: The format in which to return the hashes\n use_queue: Whether to use queued video frames\n \"\"\"\n if framerates is None:\n framerates = get_common_framerates({\n k: h.frames_per_second\n for k, h in hashers.items() if h.frames_per_second is not None\n })\n else:\n assert all(\n any(hasher_name in hasher_names\n for hasher_names in framerates.values())\n for hasher_name, hasher in hashers.items()\n if hasher.frames_per_second is not None\n ), 'Provided framerates do not have an entry for all required hashers.'\n\n results = {\n hasher_name: {\n 'state':\n None,\n 'hash':\n None,\n 'relative_framerate':\n next(framerate / hasher.frames_per_second\n for framerate, hasher_names in framerates.items()\n if hasher_name in hasher_names)\n }\n for hasher_name, hasher in hashers.items()\n if hasher.frames_per_second is not None\n }\n for current_framerate, current_hasher_names in framerates.items():\n for frame_index, (frame, grabbed_frame_index,\n frame_timestamp) in enumerate(\n read_video(\n filepath=filepath,\n frames_per_second=current_framerate,\n use_queue=use_queue)):\n for hasher_name in current_hasher_names:\n config = results[hasher_name]\n hasher = hashers[hasher_name]\n assert config['relative_framerate'] is not None\n if frame_index % config['relative_framerate'] == 0:\n config['state'] = hasher.process_frame(\n frame=frame,\n frame_index=grabbed_frame_index,\n frame_timestamp=frame_timestamp,\n state=config['state'])\n for hasher_name in current_hasher_names:\n config = results[hasher_name]\n hasher = hashers[hasher_name]\n current_hash = hasher.hash_from_final_state(state=config['state'])\n if hash_format == 'vector':\n config['hash'] = current_hash\n else:\n if not hasher.returns_multiple:\n config['hash'] = hasher.vector_to_string(\n current_hash, hash_format=hash_format)\n else:\n config['hash'] = [\n hasher.vector_to_string(h, hash_format=hash_format)\n for h in current_hash\n ]\n config['state'] = None\n hashes = {\n hasher_name: config['hash']\n for hasher_name, config in results.items()\n }\n for hasher_name, hasher in hashers.items():\n if hasher.frames_per_second is None:\n # This is a custom hasher that we just pass a video path to.\n hashes[hasher_name] = hasher.compute(filepath)\n return hashes\n\n\ndef unletterbox(image) -> typing.Optional[\n typing.Tuple[typing.Tuple[int, int], typing.Tuple[int, int]]]:\n \"\"\"Return bounds of non-trivial region of image or None.\n\n Unletterboxing is cropping an image such that trivial edge regions\n are removed. Trivial in this context means that the majority of\n the values in that row or column are zero or very close to\n zero. This is why we don't use the terms \"non-blank\" or\n \"non-empty.\"\n\n In order to do unletterboxing, this function returns bounds in the\n form (x1, x2), (y1, y2) where:\n\n - x1 is the index of the first column where over 10% of the pixels\n have means (average of R, G, B) > 2.\n - x2 is the index of the last column where over 10% of the pixels\n have means > 2.\n - y1 is the index of the first row where over 10% of the pixels\n have means > 2.\n - y2 is the index of the last row where over 10% of the pixels\n have means > 2.\n\n If there are zero columns or zero rows where over 10% of the\n pixels have means > 2, this function returns `None`.\n\n Note that in the case(s) of a single column and/or row of\n non-trivial pixels that it is possible for x1 = x2 and/or y1 = y2.\n\n Consider these examples to understand edge cases. Given two\n images, `L` (entire left and bottom edges are 1, all other pixels\n 0) and `U` (left, bottom and right edges 1, all other pixels 0),\n `unletterbox(L)` would return the bounds of the single bottom-left\n pixel and `unletterbox(U)` would return the bounds of the entire\n bottom row.\n\n Consider `U1` which is the same as `U` but with the bottom two\n rows all 1s. `unletterbox(U1)` returns the bounds of the bottom\n two rows.\n\n Args:\n image: The image from which to remove letterboxing.\n\n Returns:\n A pair of coordinates bounds of the form (x1, x2)\n and (y1, y2) representing the left, right, top, and\n bottom bounds.\n\n \"\"\"\n # adj should be thought of as a boolean at each pixel indicating\n # whether or not that pixel is non-trivial (True) or not (False).\n adj = image.mean(axis=2) > 2\n\n if adj.all():\n return (0, image.shape[1] + 1), (0, image.shape[0] + 1)\n\n y = np.where(adj.sum(axis=1) > 0.1 * image.shape[1])[0]\n x = np.where(adj.sum(axis=0) > 0.1 * image.shape[0])[0]\n\n if len(y) == 0 or len(x) == 0:\n return None\n\n if len(y) == 1:\n y1 = y2 = y[0]\n else:\n y1, y2 = y[[0, -1]]\n if len(x) == 1:\n x1 = x2 = x[0]\n else:\n x1, x2 = x[[0, -1]]\n bounds = (x1, x2 + 1), (y1, y2 + 1)\n\n return bounds\n", "meta": {"hexsha": "053b0b8092021377dd384041d0c86fba87c67729", "size": 39155, "ext": "py", "lang": "Python", "max_stars_repo_path": "perception/hashers/tools.py", "max_stars_repo_name": "thorn-oss/perception", "max_stars_repo_head_hexsha": "e78790982ea3a02d100955ea45583243e2bd8ccd", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 123, "max_stars_repo_stars_event_min_datetime": "2019-11-04T19:29:46.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-18T13:49:12.000Z", "max_issues_repo_path": "perception/hashers/tools.py", "max_issues_repo_name": "thorn-oss/perception", "max_issues_repo_head_hexsha": "e78790982ea3a02d100955ea45583243e2bd8ccd", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 13, "max_issues_repo_issues_event_min_datetime": "2019-11-05T06:51:46.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-22T04:09:58.000Z", "max_forks_repo_path": "perception/hashers/tools.py", "max_forks_repo_name": "thorn-oss/perception", "max_forks_repo_head_hexsha": "e78790982ea3a02d100955ea45583243e2bd8ccd", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 11, "max_forks_repo_forks_event_min_datetime": "2019-11-05T17:47:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-25T15:27:31.000Z", "avg_line_length": 39.312248996, "max_line_length": 98, "alphanum_fraction": 0.5950453327, "include": true, "reason": "import numpy", "num_tokens": 8931, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6224593452091673, "lm_q2_score": 0.31742626558767584, "lm_q1q2_score": 0.19758494542989596}} {"text": "'''\nhttps://github.com/christiancosgrove/pytorch-spectral-normalization-gan\n\nchainer: https://github.com/pfnet-research/sngan_projection\n'''\n\n# ResNet generator and discriminator\nimport torch\nfrom torch import nn\nimport torch.nn.functional as F\n\n# from spectral_normalization import SpectralNorm\nimport numpy as np\nfrom torch.nn.utils import spectral_norm\n\n\n\nchannels = 3\nbias = True\nGEN_SIZE=64\nDISC_SIZE=64\n\nDIM_EMBED=128\n\n\n\nclass ConditionalBatchNorm2d(nn.Module):\n def __init__(self, num_features, dim_embed):\n super().__init__()\n self.num_features = num_features\n self.bn = nn.BatchNorm2d(num_features, affine=False)\n\n # self.embed = nn.Linear(dim_embed, num_features * 2, bias=False)\n # self.embed.weight.data[:, :num_features].normal_(1, 0.02) # Initialise scale at N(1, 0.02)\n # self.embed.weight.data[:, num_features:].zero_() # Initialise bias at 0\n # # self.embed = spectral_norm(self.embed) #seems not work\n\n self.embed_gamma = nn.Linear(dim_embed, num_features, bias=False)\n self.embed_beta = nn.Linear(dim_embed, num_features, bias=False)\n\n def forward(self, x, y):\n out = self.bn(x)\n\n # gamma, beta = self.embed(y).chunk(2, 1)\n # out = gamma.view(-1, self.num_features, 1, 1) * out + beta.view(-1, self.num_features, 1, 1)\n\n gamma = self.embed_gamma(y).view(-1, self.num_features, 1, 1)\n beta = self.embed_beta(y).view(-1, self.num_features, 1, 1)\n out = out + out*gamma + beta\n\n return out\n\n\nclass ResBlockGenerator(nn.Module):\n\n def __init__(self, in_channels, out_channels, dim_embed, bias=True):\n super(ResBlockGenerator, self).__init__()\n\n self.conv1 = nn.Conv2d(in_channels, out_channels, 3, 1, padding=1, bias=bias)\n self.conv2 = nn.Conv2d(out_channels, out_channels, 3, 1, padding=1, bias=bias)\n nn.init.xavier_uniform_(self.conv1.weight.data, np.sqrt(2))\n nn.init.xavier_uniform_(self.conv2.weight.data, np.sqrt(2))\n\n self.condbn1 = ConditionalBatchNorm2d(in_channels, dim_embed)\n self.condbn2 = ConditionalBatchNorm2d(out_channels, dim_embed)\n self.relu = nn.ReLU()\n self.upsample = nn.Upsample(scale_factor=2)\n\n # unconditional case\n self.model = nn.Sequential(\n nn.BatchNorm2d(in_channels),\n nn.ReLU(),\n nn.Upsample(scale_factor=2),\n self.conv1,\n nn.BatchNorm2d(out_channels),\n nn.ReLU(),\n self.conv2\n )\n\n\n self.bypass_conv = nn.Conv2d(in_channels,out_channels, 1, 1, padding=0, bias=bias) #h=h\n nn.init.xavier_uniform_(self.bypass_conv.weight.data, 1.0)\n self.bypass = nn.Sequential(\n nn.Upsample(scale_factor=2),\n self.bypass_conv,\n )\n\n def forward(self, x, y):\n if y is not None:\n out = self.condbn1(x, y)\n out = self.relu(out)\n out = self.upsample(out)\n out = self.conv1(out)\n out = self.condbn2(out, y)\n out = self.relu(out)\n out = self.conv2(out)\n out = out + self.bypass(x)\n else:\n out = self.model(x) + self.bypass(x)\n\n return out\n\nclass ResBlockDiscriminator(nn.Module):\n\n def __init__(self, in_channels, out_channels, stride=1):\n super(ResBlockDiscriminator, self).__init__()\n\n self.conv1 = nn.Conv2d(in_channels, out_channels, 3, 1, padding=1, bias=bias)\n self.conv2 = nn.Conv2d(out_channels, out_channels, 3, 1, padding=1, bias=bias)\n nn.init.xavier_uniform_(self.conv1.weight.data, np.sqrt(2))\n nn.init.xavier_uniform_(self.conv2.weight.data, np.sqrt(2))\n\n if stride == 1:\n self.model = nn.Sequential(\n nn.ReLU(),\n spectral_norm(self.conv1),\n nn.ReLU(),\n spectral_norm(self.conv2)\n )\n else:\n self.model = nn.Sequential(\n nn.ReLU(),\n spectral_norm(self.conv1),\n nn.ReLU(),\n spectral_norm(self.conv2),\n nn.AvgPool2d(2, stride=stride, padding=0)\n )\n\n self.bypass_conv = nn.Conv2d(in_channels,out_channels, 1, 1, padding=0, bias=bias)\n nn.init.xavier_uniform_(self.bypass_conv.weight.data, 1.0)\n if stride != 1:\n self.bypass = nn.Sequential(\n spectral_norm(self.bypass_conv),\n nn.AvgPool2d(2, stride=stride, padding=0)\n )\n else:\n self.bypass = nn.Sequential(\n spectral_norm(self.bypass_conv),\n )\n\n def forward(self, x):\n return self.model(x) + self.bypass(x)\n\n# special ResBlock just for the first layer of the discriminator\nclass FirstResBlockDiscriminator(nn.Module):\n\n def __init__(self, in_channels, out_channels, stride=1):\n super(FirstResBlockDiscriminator, self).__init__()\n\n self.conv1 = nn.Conv2d(in_channels, out_channels, 3, 1, padding=1, bias=bias)\n self.conv2 = nn.Conv2d(out_channels, out_channels, 3, 1, padding=1, bias=bias)\n self.bypass_conv = nn.Conv2d(in_channels, out_channels, 1, 1, padding=0, bias=bias)\n nn.init.xavier_uniform_(self.conv1.weight.data, np.sqrt(2))\n nn.init.xavier_uniform_(self.conv2.weight.data, np.sqrt(2))\n nn.init.xavier_uniform_(self.bypass_conv.weight.data, 1.0)\n\n # we don't want to apply ReLU activation to raw image before convolution transformation.\n self.model = nn.Sequential(\n spectral_norm(self.conv1),\n nn.ReLU(),\n spectral_norm(self.conv2),\n nn.AvgPool2d(2)\n )\n self.bypass = nn.Sequential(\n nn.AvgPool2d(2),\n spectral_norm(self.bypass_conv),\n )\n\n def forward(self, x):\n return self.model(x) + self.bypass(x)\n\n\n\nclass cont_cond_cnn_generator(nn.Module):\n def __init__(self, nz=128, img_size=64, dim_embed=DIM_EMBED):\n super(cont_cond_cnn_generator, self).__init__()\n self.z_dim = nz\n self.dim_embed = dim_embed\n\n self.dense = nn.Linear(self.z_dim, 4 * 4 * GEN_SIZE*16, bias=True)\n self.final = nn.Conv2d(GEN_SIZE, channels, 3, stride=1, padding=1, bias=bias)\n nn.init.xavier_uniform_(self.dense.weight.data, 1.)\n nn.init.xavier_uniform_(self.final.weight.data, 1.)\n\n self.genblock0 = ResBlockGenerator(GEN_SIZE*16, GEN_SIZE*8, dim_embed=dim_embed) #4--->8\n self.genblock1 = ResBlockGenerator(GEN_SIZE*8, GEN_SIZE*4, dim_embed=dim_embed) #8--->16\n self.genblock2 = ResBlockGenerator(GEN_SIZE*4, GEN_SIZE*2, dim_embed=dim_embed) #16--->32\n self.genblock3 = ResBlockGenerator(GEN_SIZE*2, GEN_SIZE, dim_embed=dim_embed) #32--->64\n\n self.final = nn.Sequential(\n nn.BatchNorm2d(GEN_SIZE),\n nn.ReLU(),\n self.final,\n nn.Tanh()\n )\n\n def forward(self, z, y): #y is embedded in the feature space\n z = z.view(z.size(0), z.size(1))\n out = self.dense(z)\n out = out.view(-1, GEN_SIZE*16, 4, 4)\n\n out = self.genblock0(out, y)\n out = self.genblock1(out, y)\n out = self.genblock2(out, y)\n out = self.genblock3(out, y)\n out = self.final(out)\n\n return out\n\n\nclass cont_cond_cnn_discriminator(nn.Module):\n def __init__(self, img_size=64, dim_embed=DIM_EMBED):\n super(cont_cond_cnn_discriminator, self).__init__()\n self.dim_embed = dim_embed\n\n self.discblock1 = nn.Sequential(\n FirstResBlockDiscriminator(channels, DISC_SIZE, stride=2), #64--->32\n ResBlockDiscriminator(DISC_SIZE, DISC_SIZE*2, stride=2), #32--->16\n ResBlockDiscriminator(DISC_SIZE*2, DISC_SIZE*4, stride=2), #16--->8\n )\n self.discblock2 = ResBlockDiscriminator(DISC_SIZE*4, DISC_SIZE*8, stride=2) #8--->4\n self.discblock3 = nn.Sequential(\n ResBlockDiscriminator(DISC_SIZE*8, DISC_SIZE*16, stride=1), #4--->4;\n nn.ReLU(),\n )\n\n\n # self.linear1 = nn.Linear(DISC_SIZE*16, 1, bias=True)\n # nn.init.xavier_uniform_(self.linear1.weight.data, 1.)\n # self.linear1 = spectral_norm(self.linear1)\n # self.linear2 = nn.Linear(self.dim_embed, DISC_SIZE*16, bias=False)\n # nn.init.xavier_uniform_(self.linear2.weight.data, 1.)\n # self.linear2 = spectral_norm(self.linear2)\n\n self.linear1 = nn.Linear(DISC_SIZE*16*4*4, 1, bias=True)\n nn.init.xavier_uniform_(self.linear1.weight.data, 1.)\n self.linear1 = spectral_norm(self.linear1)\n self.linear2 = nn.Linear(self.dim_embed, DISC_SIZE*16*4*4, bias=False)\n nn.init.xavier_uniform_(self.linear2.weight.data, 1.)\n self.linear2 = spectral_norm(self.linear2)\n\n def forward(self, x, y):\n output = self.discblock1(x)\n output = self.discblock2(output)\n output = self.discblock3(output)\n\n # output = torch.sum(output, dim=(2,3))\n # output_y = torch.sum(output*self.linear2(y), 1, keepdim=True)\n # output = self.linear1(output) + output_y\n\n output = output.view(-1, DISC_SIZE*16*4*4)\n output_y = torch.sum(output*self.linear2(y), 1, keepdim=True)\n output = self.linear1(output) + output_y\n\n return output.view(-1, 1)\n", "meta": {"hexsha": "202a027c80d461adf1b8b78e6a842f85a74e1b13", "size": 9338, "ext": "py", "lang": "Python", "max_stars_repo_path": "RC-49/RC-49_64x64/CcGAN-improved/models/cont_cond_cnn_generator_discriminator.py", "max_stars_repo_name": "asatk/improved_CcGAN", "max_stars_repo_head_hexsha": "29a58e6e2a03e56c2ad80ae1a2ebbd0710e026f3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-02-26T00:07:37.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-26T00:07:37.000Z", "max_issues_repo_path": "RC-49/RC-49_64x64/CcGAN-improved/models/cont_cond_cnn_generator_discriminator.py", "max_issues_repo_name": "asatk/improved_CcGAN", "max_issues_repo_head_hexsha": "29a58e6e2a03e56c2ad80ae1a2ebbd0710e026f3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "RC-49/RC-49_64x64/CcGAN-improved/models/cont_cond_cnn_generator_discriminator.py", "max_forks_repo_name": "asatk/improved_CcGAN", "max_forks_repo_head_hexsha": "29a58e6e2a03e56c2ad80ae1a2ebbd0710e026f3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.4765625, "max_line_length": 102, "alphanum_fraction": 0.6200471193, "include": true, "reason": "import numpy", "num_tokens": 2454, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6224593312018546, "lm_q2_score": 0.31742627204485063, "lm_q1q2_score": 0.1975849450029357}} {"text": "from __future__ import print_function\nimport numpy as np\nimport copy\nimport logging\nimport traceback\nfrom simtk import openmm, unit\nfrom perses.dispersed.feptasks import Particle, compute_reduced_potential\nfrom perses.storage import NetCDFStorageView\nfrom perses.annihilation.relative import HybridTopologyFactory\nfrom perses.tests.utils import quantity_is_finite\nfrom openmmtools.constants import kB\nfrom openmmtools.cache import LRUCache, global_context_cache\nfrom openmmtools.states import ThermodynamicState, SamplerState, CompoundThermodynamicState\nfrom perses.annihilation.lambda_protocol import RelativeAlchemicalState, LambdaProtocol\n\ndefault_temperature = 300.0*unit.kelvin\ndefault_nsteps = 1\ndefault_timestep = 1.0 * unit.femtoseconds\ndefault_steps_per_propagation = 1\n_logger = logging.getLogger(\"NCMCEngine\")\n\nclass NaNException(Exception):\n def __init__(self, *args, **kwargs):\n super(NaNException,self).__init__(*args,**kwargs)\n\nclass NCMCEngine(object):\n \"\"\"\n NCMC switching engine\n\n Examples\n --------\n\n Create a transformation for an alanine dipeptide test system where the N-methyl group is eliminated.\n\n >>> from openmmtools import testsystems\n >>> testsystem = testsystems.AlanineDipeptideVacuum()\n >>> from perses.rjmc.topology_proposal import TopologyProposal\n >>> new_to_old_atom_map = { index : index for index in range(testsystem.system.getNumParticles()) if (index > 3) } # all atoms but N-methyl\n >>> topology_proposal = TopologyProposal(old_system=testsystem.system, old_topology=testsystem.topology, old_chemical_state_key='AA', new_chemical_state_key='AA', new_system=testsystem.system, new_topology=testsystem.topology, logp_proposal=0.0, new_to_old_atom_map=new_to_old_atom_map, metadata=dict())\n >>> ncmc_engine = NCMCEngine(temperature=300.0*unit.kelvin, functions=default_functions, nsteps=50, timestep=1.0*unit.femtoseconds)\n >>> positions = testsystem.positions\n >>> [positions, logP_delete, potential_delete] = ncmc_engine.integrate(topology_proposal, positions, direction='delete')\n >>> [positions, logP_insert, potential_insert] = ncmc_engine.integrate(topology_proposal, positions, direction='insert')\n\n \"\"\"\n\n def __init__(self, temperature=default_temperature, functions=None, nsteps=default_nsteps,\n steps_per_propagation=default_steps_per_propagation, timestep=default_timestep,\n constraint_tolerance=None, platform=None, write_ncmc_interval=1, measure_shadow_work=False,\n integrator_splitting='V R O H R V', storage=None, verbose=False, LRUCapacity=10, pressure=None, bond_softening_constant=1.0, angle_softening_constant=1.0):\n \"\"\"\n This is the base class for NCMC switching between two different systems.\n\n Arguments\n ---------\n temperature : simtk.unit.Quantity with units compatible with kelvin\n The temperature at which switching is to be run\n functions : dict of str:str, optional, default=default_functions\n functions[parameter] is the function (parameterized by 't' which switched from 0 to 1) that\n controls how alchemical context parameter 'parameter' is switched\n nsteps : int, optional, default=1\n The number of steps to use for switching.\n steps_per_propagation : int, optional, default=1\n The number of intermediate propagation steps taken at each switching step\n timestep : simtk.unit.Quantity with units compatible with femtoseconds, optional, default=1*femtosecond\n The timestep to use for integration of switching velocity Verlet steps.\n constraint_tolerance : float, optional, default=None\n If not None, this relative constraint tolerance is used for position and velocity constraints.\n platform : simtk.openmm.Platform, optional, default=None\n If specified, the platform to use for OpenMM simulations.\n write_ncmc_interval : int, optional, default=None\n If a positive integer is specified, a snapshot frame will be written to storage with the specified interval on NCMC switching.\n 'storage' must also be specified.\n measure_shadow_work : bool, optional, default False\n Whether to measure shadow work\n integrator_splitting : str, optional, default='V R O H R V'\n NCMC internal integrator splitting based on OpenMMTools Langevin splittings\n storage : NetCDFStorageView, optional, default=None\n If specified, write data using this class.\n verbose : bool, optional, default=False\n If True, print debug information.\n LRUCapacity : int, default 10\n Capacity of LRU cache for hybrid systems\n pressure : float, default None\n The pressure to use for the simulation. If None, no barostat\n \"\"\"\n # Handle some defaults.\n if functions == None:\n functions = LambdaProtocol.default_functions\n if nsteps == None:\n nsteps = default_nsteps\n if timestep == None:\n timestep = default_timestep\n if temperature == None:\n temperature = default_temperature\n\n self._temperature = temperature\n self._functions = copy.deepcopy(functions)\n self._nsteps = nsteps\n self._timestep = timestep\n self._constraint_tolerance = constraint_tolerance\n self._platform = platform\n self._integrator_splitting = integrator_splitting\n self._steps_per_propagation = steps_per_propagation\n self._verbose = verbose\n self._pressure = pressure\n self._bond_softening_constant = bond_softening_constant\n self._angle_softening_constant = angle_softening_constant\n self._disable_barostat = False\n self._hybrid_cache = LRUCache(capacity=LRUCapacity)\n self._measure_shadow_work = measure_shadow_work\n\n self._nattempted = 0\n\n self._storage = None\n if storage is not None:\n self._storage = NetCDFStorageView(storage, modname=self.__class__.__name__)\n self._save_configuration = True\n else:\n self._save_configuration = False\n if write_ncmc_interval is not None:\n self._write_ncmc_interval = write_ncmc_interval\n else:\n self._write_ncmc_interval = 1\n self._work_save_interval = write_ncmc_interval\n\n @property\n def beta(self):\n kT = kB * self._temperature\n beta = 1.0 / kT\n return beta\n\n def _compute_energy_contribution(self, hybrid_thermodynamic_state, initial_sampler_state, final_sampler_state):\n \"\"\"\n Compute NCMC energy contribution to log probability.\n\n See Eqs. 62 and 63 (two-stage) and Eq. 45 (hybrid) of reference document.\n In both cases, the contribution is u(final_positions, final_lambda) - u(initial_positions, initial_lambda).\n\n Parameters\n ----------\n hybrid_thermodynamic_state : openmmtools.states.CompoundThermodynamicState\n The thermodynamic state of the hybrid sampler.\n initial_sampler_state : openmmtools.states.SamplerState\n The sampler state of the nonalchemical system at the start of the NCMC protocol with box vectors\n final_sampler_state : openmmtools.states.SamplerState\n The sampler state of the nonalchemical system at the end of the NCMC protocol\n\n Returns\n -------\n logP_energy : float\n The NCMC energy contribution to log probability.\n \"\"\"\n hybrid_thermodynamic_state.set_alchemical_parameters(0.0)\n initial_reduced_potential = compute_reduced_potential(hybrid_thermodynamic_state, initial_sampler_state)\n\n hybrid_thermodynamic_state.set_alchemical_parameters(1.0)\n final_reduced_potential = compute_reduced_potential(hybrid_thermodynamic_state, final_sampler_state)\n\n return final_reduced_potential - initial_reduced_potential\n\n def _topology_proposal_to_thermodynamic_states(self, topology_proposal):\n \"\"\"\n Convert a topology proposal to thermodynamic states for the end systems. This will be used to compute the\n \"logP_energy\" quantity.\n\n Arguments\n ---------\n topology_proposal : perses.rjmc.TopologyProposal\n topology proposal for whose endpoint systems we want ThermodynamicStates\n\n Returns\n -------\n old_thermodynamic_state : openmmtools.states.ThermodynamicState\n The old system (nonalchemical) thermodynamic state\n new_thermodynamic_state : openmmtools.states.ThermodynamicState\n The new system (nonalchemical) thermodynamic state\n \"\"\"\n systems = [topology_proposal.old_system, topology_proposal.new_system]\n thermostates = []\n for system in systems:\n thermodynamic_state = ThermodynamicState(system, temperature=self._temperature, pressure=self._pressure)\n thermostates.append(thermodynamic_state)\n\n return thermostates[0], thermostates[1]\n\n def make_alchemical_system(self, topology_proposal, current_positions, new_positions):\n \"\"\"\n Generate an alchemically-modified system at the correct atoms\n based on the topology proposal. This method generates a hybrid system using the new\n HybridTopologyFactory. It memoizes so that calling multiple times (within a recent time period)\n will immediately return a cached object.\n\n Arguments\n ---------\n topology_proposal : perses.rjmc.TopologyProposal\n Unmodified real system corresponding to appropriate leg of transformation.\n current_positions : np.ndarray of float\n Positions of \"old\" system\n new_positions : np.ndarray of float\n Positions of \"new\" system atoms\n\n Returns\n -------\n hybrid_factory : perses.annihilation.relative.HybridTopologyFactory\n a factory object containing the hybrid system\n \"\"\"\n try:\n hybrid_factory = self._hybrid_cache[topology_proposal]\n\n #If we've retrieved the factory from the cache, update it to include the relevant positions\n hybrid_factory._old_positions = current_positions\n hybrid_factory._new_positions = new_positions\n hybrid_factory._compute_hybrid_positions()\n except KeyError:\n try:\n hybrid_factory = HybridTopologyFactory(topology_proposal, current_positions, new_positions, bond_softening_constant=self._bond_softening_constant, angle_softening_constant=self._angle_softening_constant)\n self._hybrid_cache[topology_proposal] = hybrid_factory\n except:\n hybrid_factory = None\n\n\n return hybrid_factory\n\n def integrate(self, topology_proposal, initial_sampler_state, proposed_sampler_state, iteration=None):\n \"\"\"\n Performs NCMC switching to either delete or insert atoms according to the provided `topology_proposal`.\n\n For `delete`, the system is first modified from fully interacting to alchemically modified, and then NCMC switching is used to eliminate atoms.\n For `insert`, the system begins with eliminated atoms in an alchemically noninteracting form and NCMC switching is used to turn atoms on, followed by making system real.\n\n Parameters\n ----------\n topology_proposal : TopologyProposal\n Contains old/new Topology and System objects and atom mappings.\n initial_sampler_state : openmmtools.states.SamplerState representing the initial (old) system\n Configurational properties of the atoms at the beginning of the NCMC switching.\n proposed_sampler_state : openmmtools.states.SamplerState representing the proposed (post-geometry new) system\n Configurational properties new system atoms at beginning of NCMC switching\n iteration : int, optional, default=None\n Iteration number, for storage purposes.\n\n Returns\n -------\n final_old_sampler_state : openmmtools.State.SamplerState\n The final configurational properties of the old system after hybrid alchemical switching\n final_sampler_state : openmmtools.states.SamplerState\n The final configurational properties after `nsteps` steps of alchemical switching, and reversion to the nonalchemical system\n logP_work : float\n The NCMC work contribution to the log acceptance probability (Eqs. 62 and 63)\n logP_initial : float\n The initial logP of the hybrid configuration\n logP_final : float\n The final logP of the hybrid configuration\n \"\"\"\n\n assert not initial_sampler_state.has_nan() and not proposed_sampler_state.has_nan()\n\n #generate or retrieve the hybrid topology factory:\n hybrid_factory = self.make_alchemical_system(topology_proposal, initial_sampler_state.positions, proposed_sampler_state.positions)\n\n if hybrid_factory is None:\n _logger.warning(\"Unable to construct hybrid system for {} -> {}\".format(topology_proposal.old_chemical_state_key, topology_proposal.new_chemical_state_key))\n return initial_sampler_state, proposed_sampler_state, -np.inf, 0.0, 0.0\n\n\n topology = hybrid_factory.hybrid_topology\n\n #generate the corresponding thermodynamic and sampler states so that we can use the NonequilibriumSwitchingMove:\n\n #First generate the thermodynamic state:\n hybrid_system = hybrid_factory.hybrid_system\n hybrid_thermodynamic_state = ThermodynamicState(hybrid_system, temperature=self._temperature, pressure=self._pressure)\n\n #Now create an RelativeAlchemicalState from the hybrid system:\n alchemical_state = RelativeAlchemicalState.from_system(hybrid_system)\n alchemical_state.set_alchemical_parameters(0.0)\n\n #Now create a compound thermodynamic state that combines the hybrid thermodynamic state with the alchemical state:\n compound_thermodynamic_state = CompoundThermodynamicState(hybrid_thermodynamic_state, composable_states=[alchemical_state])\n\n #construct a sampler state from the hybrid positions and the box vectors of the initial sampler state:\n initial_hybrid_positions = hybrid_factory.hybrid_positions\n initial_hybrid_box_vectors = initial_sampler_state.box_vectors\n\n initial_hybrid_sampler_state = SamplerState(initial_hybrid_positions, box_vectors=initial_hybrid_box_vectors)\n final_hybrid_sampler_state = copy.deepcopy(initial_hybrid_sampler_state)\n\n #create the nonequilibrium move:\n #ne_move = NonequilibriumSwitchingMove(self._functions, self._integrator_splitting, self._temperature, self._nsteps, self._timestep,\n # work_save_interval=self._write_ncmc_interval, top=topology,subset_atoms=None,\n # save_configuration=self._save_configuration, measure_shadow_work=self._measure_shadow_work)\n\n ne_move = ExternalNonequilibriumSwitchingMove(self._functions, nsteps_neq=self._nsteps,\n timestep=self._timestep, temperature=self._temperature,\n work_configuration_save_interval=self._work_save_interval,\n splitting=\"V R O R V\")\n\n\n #run the NCMC protocol\n try:\n ne_move.apply(compound_thermodynamic_state, final_hybrid_sampler_state)\n except Exception as e:\n _logger.warn(\"NCMC failed because {}; rejecting.\".format(str(e)))\n logP_work = -np.inf\n return [initial_sampler_state, proposed_sampler_state, -np.inf, 0.0, 0.0]\n\n #get the total work:\n logP_work = - ne_move.cumulative_work[-1]\n\n # Compute contribution of transforming to and from the hybrid system:\n context, integrator = global_context_cache.get_context(hybrid_thermodynamic_state)\n\n #set all alchemical parameters to zero:\n for parameter in self._functions.keys():\n context.setParameter(parameter, 0.0)\n\n initial_hybrid_sampler_state.apply_to_context(context, ignore_velocities=True)\n initial_reduced_potential = hybrid_thermodynamic_state.reduced_potential(context)\n\n #set all alchemical parameters to one:\n for parameter in self._functions.keys():\n context.setParameter(parameter, 1.0)\n\n final_hybrid_sampler_state.apply_to_context(context, ignore_velocities=True)\n final_reduced_potential = hybrid_thermodynamic_state.reduced_potential(context)\n\n #reset the parameters back to zero just in case\n for parameter in self._functions.keys():\n context.setParameter(parameter, 0.0)\n\n #compute the output SamplerState, which has the atoms only for the new system post-NCMC:\n new_positions = hybrid_factory.new_positions(final_hybrid_sampler_state.positions)\n new_box_vectors = final_hybrid_sampler_state.box_vectors\n final_sampler_state = SamplerState(new_positions, box_vectors=new_box_vectors)\n\n #compute the output SamplerState for the atoms only in the old system (required for geometry_logP_reverse)\n old_positions = hybrid_factory.old_positions(final_hybrid_sampler_state.positions)\n old_box_vectors = copy.deepcopy(new_box_vectors) #these are the same as the new system\n final_old_sampler_state = SamplerState(old_positions, box_vectors=old_box_vectors)\n\n #extract the trajectory and box vectors from the move:\n trajectory = ne_move.trajectory[::-self._write_ncmc_interval, :, :][::-1]\n topology = hybrid_factory.hybrid_topology\n position_varname = \"ncmcpositions\"\n nframes = np.shape(trajectory)[0]\n\n #extract box vectors:\n box_vec_varname = \"ncmcboxvectors\"\n box_lengths = ne_move.box_lengths[::-self._write_ncmc_interval, :][::-1]\n box_angles = ne_move.box_angles[::-self._write_ncmc_interval, :][::-1]\n box_lengths_and_angles = np.stack([box_lengths, box_angles])\n\n #write out the positions of the topology\n if self._storage:\n for frame in range(nframes):\n self._storage.write_configuration(position_varname, trajectory[frame, :, :], topology, iteration=iteration, frame=frame, nframes=nframes)\n\n #write out the periodict box vectors:\n if self._storage:\n self._storage.write_array(box_vec_varname, box_lengths_and_angles, iteration=iteration)\n\n #retrieve the protocol work and write that out too:\n protocol_work = ne_move.cumulative_work\n if self._storage:\n self._storage.write_array(\"protocolwork\", protocol_work, iteration=iteration)\n\n # Return\n return [final_old_sampler_state, final_sampler_state, logP_work, -initial_reduced_potential, -final_reduced_potential]\n", "meta": {"hexsha": "ec4aaa7e0b7c7c9118304cd32ffd2fcef9d69149", "size": 18992, "ext": "py", "lang": "Python", "max_stars_repo_path": "perses/annihilation/ncmc_switching.py", "max_stars_repo_name": "hannahbrucemacdonald/perses", "max_stars_repo_head_hexsha": "6b43d200501e587b352dce5aaefef38e4145048b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "perses/annihilation/ncmc_switching.py", "max_issues_repo_name": "hannahbrucemacdonald/perses", "max_issues_repo_head_hexsha": "6b43d200501e587b352dce5aaefef38e4145048b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "perses/annihilation/ncmc_switching.py", "max_forks_repo_name": "hannahbrucemacdonald/perses", "max_forks_repo_head_hexsha": "6b43d200501e587b352dce5aaefef38e4145048b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 51.3297297297, "max_line_length": 307, "alphanum_fraction": 0.712247262, "include": true, "reason": "import numpy", "num_tokens": 3926, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5964331462646255, "lm_q2_score": 0.33111974622959367, "lm_q1q2_score": 0.19749079203406092}} {"text": "#!/usr/bin/env python\n\n# stdlib modules\nimport copy\n\n# third party imports\nimport numpy as np\nfrom openquake.hazardlib.geo.mesh import Mesh\nfrom openquake.hazardlib.geo.point import Point\nfrom openquake.hazardlib.geo.utils import get_orthographic_projection\n\nfrom impactutils.vectorutils.ecef import latlon2ecef\nfrom impactutils.vectorutils.ecef import ecef2latlon\nfrom impactutils.vectorutils.vector import Vector\nfrom impactutils.time.ancient_time import HistoricTime\nfrom shakelib.utils.exception import ShakeLibException\nfrom shakelib.rupture.base import Rupture\nfrom shakelib.rupture import utils\nfrom shakelib.rupture import gc2\n\n\nclass QuadRupture(Rupture):\n \"\"\"\n Rupture class that represents the rupture surface as a combination of\n quadrilaterals. Each quadrilateral must have horizontal top and bottom\n edges and must be coplanar. These restrictions make the computation of\n rupture distances more efficient. The number of points in the top edges\n must match the number of points in the bottom edge.\n \"\"\"\n\n def __init__(self, d, origin):\n \"\"\"\n Create a QuadRupture instance from a GeoJSON dictionary and an Origin.\n\n Args:\n d (dict): Rupture GeoJSON dictionary.\n origin (Origin): Reference to a ShakeMap Origin object.\n\n Returns:\n QuadRupture instance.\n\n \"\"\"\n\n polys = d['features'][0]['geometry']['coordinates'][0]\n n_polygons = len(polys)\n lon = []\n lat = []\n dep = []\n for i in range(n_polygons):\n p = polys[i]\n p_lons = [pt[0] for pt in p][0:-1]\n p_lats = [pt[1] for pt in p][0:-1]\n p_depths = [pt[2] for pt in p][0:-1]\n lon = lon + p_lons + [np.nan]\n lat = lat + p_lats + [np.nan]\n dep = dep + p_depths + [np.nan]\n\n # Add origin information to metadata\n odict = origin.__dict__\n for k, v in odict.items():\n if isinstance(v, HistoricTime):\n d['metadata'][k] = v.strftime('%Y-%m-%dT%H:%M:%SZ')\n else:\n d['metadata'][k] = v\n\n self._geojson = d\n self._lon = lon\n self._lat = lat\n self._depth = dep\n self._origin = origin\n self._reference = d['metadata']['reference']\n self._setQuadrilaterals()\n\n def getDepthAtPoint(self, lat, lon):\n SMALL_DISTANCE = 2e-03 # 2 meters\n depth = np.nan\n\n tmp = self.computeRjb(np.array([lon]), np.array([lat]), np.array([0]))\n if tmp > SMALL_DISTANCE:\n return depth\n\n i = 0\n imin = -1\n dmin = 9999999999999999\n for quad in self.getQuadrilaterals():\n pX = Vector.fromPoint(Point(lon, lat, 0))\n points = np.reshape(np.array([pX.x, pX.y, pX.z]), (1, 3))\n rjb = utils._quad_distance(quad, points, horizontal=True)\n if rjb[0][0] < dmin:\n dmin = rjb[0][0]\n imin = i\n i += 1\n\n quad = self._quadrilaterals[imin]\n P0, P1, P2, P3 = quad\n # project the quad and the point in question to orthographic defined by\n # quad\n xmin = np.min([P0.x, P1.x, P2.x, P3.x])\n xmax = np.max([P0.x, P1.x, P2.x, P3.x])\n ymin = np.min([P0.y, P1.y, P2.y, P3.y])\n ymax = np.max([P0.y, P1.y, P2.y, P3.y])\n proj = get_orthographic_projection(xmin, xmax, ymax, ymin)\n\n # project each vertex of quad (at 0 depth)\n s0x, s0y = proj(P0.x, P0.y)\n s1x, s1y = proj(P1.x, P1.y)\n s2x, s2y = proj(P2.x, P2.y)\n s3x, s3y = proj(P3.x, P3.y)\n sxx, sxy = proj(lon, lat)\n\n # turn these to vectors\n s0 = Vector(s0x, s0y, 0)\n s1 = Vector(s1x, s1y, 0)\n s3 = Vector(s3x, s3y, 0)\n sx = Vector(sxx, sxy, 0)\n\n # Compute vector from s0 to s1\n s0s1 = s1 - s0\n # Compute the vector from s0 to s3\n s0s3 = s3 - s0\n # Compute the vector from s0 to sx\n s0sx = sx - s0\n\n # cross products\n s0normal = s0s3.cross(s0s1)\n dd = s0s1.cross(s0normal)\n # normalize dd (down dip direction)\n ddn = dd.norm()\n # dot product\n sxdd = ddn.dot(s0sx)\n\n # get width of quad\n w = utils.get_quad_width(quad)\n\n # Get weights for top and bottom edge depths\n N = utils.get_quad_normal(quad)\n V = utils.get_vertical_vector(quad)\n dip = np.degrees(np.arccos(Vector.dot(N, V)))\n ws = (w * np.cos(np.radians(dip)))\n wtt = (ws - sxdd) / ws\n wtb = sxdd / ws\n\n # Compute the depth of of the plane at Px:\n depth = wtt * P0.z + wtb * P3.z * 1000\n\n return depth\n\n def getLength(self):\n \"\"\"\n Compute length of rupture based on top edge in km.\n\n Returns:\n float: Length of rupture (km).\n\n \"\"\"\n flength = 0\n for quad in self._quadrilaterals:\n flength = flength + utils.get_quad_length(quad)\n return flength\n\n def getWidth(self):\n \"\"\"\n Compute average rupture width (km) for all quadrilaterals defined for\n the rupture.\n\n Returns:\n float: Average width in km of all rupture quadrilaterals.\n \"\"\"\n wsum = 0.0\n for quad in self._quadrilaterals:\n wsum = wsum + utils.get_quad_width(quad)\n mwidth = (wsum / len(self._quadrilaterals)) / 1000.0\n return mwidth\n\n def getArea(self):\n \"\"\"\n Compute area of rupture.\n\n Returns:\n float: Rupture area in square km.\n\n \"\"\"\n asum = 0.0\n for quad in self._quadrilaterals:\n width = utils.get_quad_width(quad)\n length = utils.get_quad_length(quad)\n asum = asum + width * length\n return asum\n\n @classmethod\n def fromTrace(cls, xp0, yp0, xp1, yp1, zp, widths, dips, origin,\n strike=None, group_index=None, reference=\"\"):\n \"\"\"\n Create a QuadRupture instance from a set of vertices that define the\n top of the rupture, and an array of widths/dips.\n\n Each rupture quadrilaterial is defined by specifying the latitude,\n longitude, and depth of the two vertices on the top edges, which must\n have the dame depths. The other verticies are then constructed from\n the top edges and the width and dip of the quadrilateral.\n\n Args:\n xp0 (array): Array or list of longitudes (floats) of p0.\n yp0 (array): Array or list of latitudes (floats) of p0.\n xp1 (array): Array or list of longitudes (floats) of p1.\n yp1 (array): Array or list of latitudes (floats) of p1.\n zp (array): Array or list of depths for each of the top of rupture\n rectangles (km).\n widths (array): Array of widths for each of rectangle (km).\n dips (array): Array of dips for each of rectangle (degrees).\n origin (Origin): Reference to a ShakeMap origin object.\n strike (array): If None then strike is computed from verticies of\n top edge of each quadrilateral. If a scalar, then all\n quadrilaterals are constructed assuming this strike direction.\n If an array with the same length as the trace coordinates then\n it specifies the strike for each quadrilateral.\n group_index (list): List of integers to indicate group index. If\n None then each quadrilateral is assumed to be in a different\n group since there is no guarantee that any of them are\n continuous.\n reference (str): String explaining where the rupture definition\n came from (publication style reference, etc.).\n\n Returns:\n QuadRupture instance.\n\n \"\"\"\n if len(xp0) == len(yp0) == len(xp1) == len(\n yp1) == len(zp) == len(dips) == len(widths):\n pass\n else:\n raise ShakeLibException(\n 'Number of xp0,yp0,xp1,yp1,zp,widths,dips points must be '\n 'equal.')\n if strike is None:\n pass\n else:\n if (len(xp0) == len(strike)) | (len(strike) == 1):\n pass\n else:\n raise ShakeLibException(\n 'Strike must be None, scalar, or same length as '\n 'trace coordinates.')\n\n if group_index is None:\n group_index = np.array(range(len(xp0)))\n\n # Convert dips to radians\n dips = np.radians(dips)\n\n # Ensure that all input sequences are numpy arrays\n xp0 = np.array(xp0, dtype='d')\n xp1 = np.array(xp1, dtype='d')\n yp0 = np.array(yp0, dtype='d')\n yp1 = np.array(yp1, dtype='d')\n zp = np.array(zp, dtype='d')\n widths = np.array(widths, dtype='d')\n dips = np.array(dips, dtype='d')\n\n # Get a projection object\n west = np.min((xp0.min(), xp1.min()))\n east = np.max((xp0.max(), xp1.max()))\n south = np.min((yp0.min(), yp1.min()))\n north = np.max((yp0.max(), yp1.max()))\n\n # Projected coordinates are in km\n proj = get_orthographic_projection(west, east, north, south)\n xp2 = np.zeros_like(xp0)\n xp3 = np.zeros_like(xp0)\n yp2 = np.zeros_like(xp0)\n yp3 = np.zeros_like(xp0)\n zpdown = np.zeros_like(zp)\n for i in range(0, len(xp0)):\n # Project the top edge coordinates\n p0x, p0y = proj(xp0[i], yp0[i])\n p1x, p1y = proj(xp1[i], yp1[i])\n\n # Get the rotation angle defined by these two points\n if strike is None:\n dx = p1x - p0x\n dy = p1y - p0y\n theta = np.arctan2(dx, dy) # theta is angle from north\n elif len(strike) == 1:\n theta = np.radians(strike[0])\n else:\n theta = np.radians(strike[i])\n\n R = np.array([[np.cos(theta), -np.sin(theta)],\n [np.sin(theta), np.cos(theta)]])\n\n # Rotate the top edge points into a new coordinate system (vertical\n # line)\n p0 = np.array([p0x, p0y])\n p1 = np.array([p1x, p1y])\n p0p = np.dot(R, p0)\n p1p = np.dot(R, p1)\n\n # Get right side coordinates in project, rotated system\n dz = np.sin(dips[i]) * widths[i]\n dx = np.cos(dips[i]) * widths[i]\n p3xp = p0p[0] + dx\n p3yp = p0p[1]\n p2xp = p1p[0] + dx\n p2yp = p1p[1]\n\n # Get right side coordinates in un-rotated projected system\n p3p = np.array([p3xp, p3yp])\n p2p = np.array([p2xp, p2yp])\n Rback = np.array([[np.cos(-theta), -np.sin(-theta)],\n [np.sin(-theta), np.cos(-theta)]])\n p3 = np.dot(Rback, p3p)\n p2 = np.dot(Rback, p2p)\n p3x = np.array([p3[0]])\n p3y = np.array([p3[1]])\n p2x = np.array([p2[0]])\n p2y = np.array([p2[1]])\n\n # project lower edge points back to lat/lon coordinates\n lon3, lat3 = proj(p3x, p3y, reverse=True)\n lon2, lat2 = proj(p2x, p2y, reverse=True)\n\n xp2[i] = lon2\n xp3[i] = lon3\n yp2[i] = lat2\n yp3[i] = lat3\n zpdown[i] = zp[i] + dz\n\n # ---------------------------------------------------------------------\n # Create GeoJSON object\n # ---------------------------------------------------------------------\n\n coords = []\n u_groups = np.unique(group_index)\n n_groups = len(u_groups)\n for i in range(n_groups):\n ind = np.where(u_groups[i] == group_index)[0]\n lons = np.concatenate(\n [xp0[ind[0]].reshape((1,)),\n xp1[ind], xp2[ind][::-1],\n xp3[ind][::-1][-1].reshape((1,)),\n xp0[ind[0]].reshape((1,))\n ])\n lats = np.concatenate(\n [yp0[ind[0]].reshape((1,)),\n yp1[ind],\n yp2[ind][::-1],\n yp3[ind][::-1][-1].reshape((1,)),\n yp0[ind[0]].reshape((1,))\n ])\n deps = np.concatenate(\n [zp[ind[0]].reshape((1,)),\n zp[ind],\n zpdown[ind][::-1],\n zpdown[ind][::-1][-1].reshape((1,)),\n zp[ind[0]].reshape((1,))])\n\n poly = []\n for lon, lat, dep in zip(lons, lats, deps):\n poly.append([lon, lat, dep])\n coords.append(poly)\n\n d = {\"type\": \"FeatureCollection\",\n \"metadata\": {\n \"reference\": reference\n },\n \"features\": [{\n \"type\": \"Feature\",\n \"properties\": {\n \"rupture type\": \"rupture extent\"\n },\n \"geometry\": {\n \"type\": \"MultiPolygon\",\n \"coordinates\": [coords]\n }\n }]}\n\n # Add origin information to metadata\n odict = origin.__dict__\n for k, v in odict.items():\n if isinstance(v, HistoricTime):\n d['metadata'][k] = v.strftime('%Y-%m-%dT%H:%M:%SZ')\n else:\n d['metadata'][k] = v\n\n return cls(d, origin)\n\n def writeTextFile(self, rupturefile):\n \"\"\"\n Write rupture data to rupture file format as defined in ShakeMap\n Software Guide.\n\n Note that this currently treats each quadrilateral as a separate\n polygon. This needs to be udpated.\n\n Args:\n rupturefile (str): Filename of output data file OR file-like\n object.\n\n \"\"\"\n if not hasattr(rupturefile, 'read'):\n f = open(rupturefile, 'wt')\n else:\n f = rupturefile # just a reference to the input file-like object\n f.write('#%s\\n' % self._reference)\n for quad in self.getQuadrilaterals():\n P0, P1, P2, P3 = quad\n f.write('%.4f %.4f %.4f\\n' % (P0.latitude, P0.longitude, P0.depth))\n f.write('%.4f %.4f %.4f\\n' % (P1.latitude, P1.longitude, P1.depth))\n f.write('%.4f %.4f %.4f\\n' % (P2.latitude, P2.longitude, P2.depth))\n f.write('%.4f %.4f %.4f\\n' % (P3.latitude, P3.longitude, P3.depth))\n f.write('%.4f %.4f %.4f\\n' % (P0.latitude, P0.longitude, P0.depth))\n f.write(u'>\\n')\n if not hasattr(rupturefile, 'read'):\n f.close()\n\n @classmethod\n def fromVertices(cls,\n xp0, yp0, zp0, xp1, yp1, zp1,\n xp2, yp2, zp2, xp3, yp3, zp3,\n origin,\n group_index=None,\n reference=None):\n \"\"\"\n Create a QuadDrupture instance from the vector of vertices that fully\n define the quadrilaterals. The points p0, ..., p3 are labeled below for\n a trapezoid:\n\n ::\n\n p0--------p1\n / |\n / |\n p3-----------p2\n\n All of the following vector arguments must have the same length.\n\n Args:\n xp0 (array): Array or list of longitudes (floats) of p0.\n yp0 (array): Array or list of latitudes (floats) of p0.\n zp0 (array): Array or list of depths (floats) of p0.\n xp1 (array): Array or list of longitudes (floats) of p1.\n yp1 (array): Array or list of latitudes (floats) of p1.\n zp1 (array): Array or list of depths (floats) of p1.\n xp2 (array): Array or list of longitudes (floats) of p2.\n yp2 (array): Array or list of latitudes (floats) of p2.\n zp2 (array): Array or list of depths (floats) of p2.\n xp3 (array): Array or list of longitudes (floats) of p3.\n yp3 (array): Array or list of latitudes (floats) of p3.\n zp3 (array): Array or list of depths (floats) of p3.\n origin (Origin): Reference to a ShakeMap Origin object.\n group_index (list): List of integers to indicate group index. If\n None then each quadrilateral is assumed to be in a different\n group since there is no guarantee that any of them are\n continuous.\n reference (str): String explaining where the rupture definition\n came from (publication style reference, etc.)\n\n Returns:\n QuadRupture object, where the rupture is modeled as a series of\n trapezoids.\n\n \"\"\"\n if len(xp0) == len(yp0) == len(zp0) == len(xp1) == len(yp1) == \\\n len(zp1) == len(xp2) == len(yp2) == len(zp2) == len(xp3) == \\\n len(yp3) == len(zp3):\n pass\n else:\n raise ShakeLibException('All vectors specifying quadrilateral '\n 'vertices must have the same length.')\n\n nq = len(xp0)\n if group_index is not None:\n if len(group_index) != nq:\n raise Exception(\n \"group_index must have same length as vertices.\")\n else:\n group_index = np.array(range(nq))\n\n xp0 = np.array(xp0, dtype='d')\n yp0 = np.array(yp0, dtype='d')\n zp0 = np.array(zp0, dtype='d')\n xp1 = np.array(xp1, dtype='d')\n yp1 = np.array(yp1, dtype='d')\n zp1 = np.array(zp1, dtype='d')\n xp2 = np.array(xp2, dtype='d')\n yp2 = np.array(yp2, dtype='d')\n zp2 = np.array(zp2, dtype='d')\n xp3 = np.array(xp3, dtype='d')\n yp3 = np.array(yp3, dtype='d')\n zp3 = np.array(zp3, dtype='d')\n\n # ---------------------------------------------------------------------\n # Create GeoJSON object\n # ---------------------------------------------------------------------\n\n coords = []\n u_groups = np.unique(group_index)\n n_groups = len(u_groups)\n for i in range(n_groups):\n ind = np.where(u_groups[i] == group_index)[0]\n lons = np.concatenate(\n [xp0[ind[0]].reshape((1,)),\n xp1[ind],\n xp2[ind][::-1],\n xp3[ind][::-1][-1].reshape((1,)),\n xp0[ind[0]].reshape((1,))\n ])\n lats = np.concatenate(\n [yp0[ind[0]].reshape((1,)),\n yp1[ind],\n yp2[ind][::-1],\n yp3[ind][::-1][-1].reshape((1,)),\n yp0[ind[0]].reshape((1,))\n ])\n deps = np.concatenate(\n [zp0[ind[0]].reshape((1,)),\n zp1[ind],\n zp2[ind][::-1],\n zp3[ind][::-1][-1].reshape((1,)),\n zp0[ind[0]].reshape((1,))\n ])\n\n poly = []\n for lon, lat, dep in zip(lons, lats, deps):\n poly.append([lon, lat, dep])\n coords.append(poly)\n\n d = {\"type\": \"FeatureCollection\",\n \"metadata\": {\n \"reference\": reference\n },\n \"features\": [{\n \"type\": \"Feature\",\n \"properties\": {\n \"rupture type\": \"rupture extent\"\n },\n \"geometry\": {\n \"type\": \"MultiPolygon\",\n \"coordinates\": [coords]\n }\n }]}\n\n # Add origin information to metadata\n odict = origin.__dict__\n for k, v in odict.items():\n if isinstance(v, HistoricTime):\n d['metadata'][k] = v.strftime('%Y-%m-%dT%H:%M:%SZ')\n else:\n d['metadata'][k] = v\n if hasattr(origin, 'id'):\n d['metadata']['eventid'] = origin.id\n\n return cls(d, origin)\n\n def getQuadrilaterals(self):\n \"\"\"\n Return a list of quadrilaterals.\n\n Returns:\n list: List of quadrilaterals where each quad is a tuple of four\n `Point `__\n objects.\n \"\"\" # noqa\n return copy.deepcopy(self._quadrilaterals)\n\n def getStrike(self):\n \"\"\"\n Return strike angle. If rupture consists of multiple quadrilaterals,\n the average strike angle, weighted by quad length, is returned.\n Note: for ruptures with quads where the strike angle changes by 180 deg\n due to reverses in dip direction are problematic and not handeled well\n by this algorithm.\n\n Returns:\n float: Strike angle in degrees.\n\n \"\"\"\n nq = len(self._quadrilaterals)\n strikes = np.zeros(nq)\n lengths = np.zeros(nq)\n for i in range(nq):\n P0 = self._quadrilaterals[i][0]\n P1 = self._quadrilaterals[i][1]\n strikes[i] = P0.azimuth(P1)\n lengths[i] = utils.get_quad_length(self._quadrilaterals[i])\n x = np.sin(np.radians(strikes))\n y = np.cos(np.radians(strikes))\n xbar = np.sum(x * lengths) / np.sum(lengths)\n ybar = np.sum(y * lengths) / np.sum(lengths)\n return np.degrees(np.arctan2(xbar, ybar))\n\n def getDepthToTop(self):\n \"\"\"\n Determine shallowest vertex of entire rupture.\n\n :returns:\n Shallowest depth of all vertices (float).\n \"\"\"\n mindep = 9999999\n for quad in self._quadrilaterals:\n P0, P1, P2, P3 = quad\n depths = np.array([P0.depth, P1.depth, P2.depth, P3.depth])\n if np.min(depths) < mindep:\n mindep = np.min(depths)\n return mindep\n\n def getDip(self):\n \"\"\"\n Return average dip of all quadrilaterals in the rupture.\n\n Returns:\n float: Average dip in degrees.\n\n \"\"\"\n dipsum = 0.0\n for quad in self._quadrilaterals:\n N = utils.get_quad_normal(quad)\n V = utils.get_vertical_vector(quad)\n dipsum = dipsum + np.degrees(np.arccos(Vector.dot(N, V)))\n dip = dipsum / len(self._quadrilaterals)\n return dip\n\n def getIndividualWidths(self):\n \"\"\"\n Return an array of rupture widths (km), one for each quadrilateral\n defined for the rupture.\n\n Returns:\n Array of quad widths in km of all rupture quadrilaterals.\n \"\"\"\n nquad = self.getNumQuads()\n widths = np.zeros(nquad)\n for i in range(nquad):\n q = self._quadrilaterals[i]\n widths[i] = utils.get_quad_width(q) / 1000.0\n return widths\n\n def getIndividualTopLengths(self):\n \"\"\"\n Return an array of rupture lengths along top edge (km),\n one for each quadrilateral defined for the rupture.\n\n :returns:\n Array of lengths in km of top edge of quadrilaterals.\n \"\"\"\n nquad = self.getNumQuads()\n lengths = np.zeros(nquad)\n for i in range(nquad):\n P0, P1, P2, P3 = self._quadrilaterals[i]\n p0 = Vector.fromPoint(P0)\n p1 = Vector.fromPoint(P1)\n lengths[i] = (p1 - p0).mag() / 1000.0\n return lengths\n\n @staticmethod\n def _fixStrikeDirection(quad):\n P0, P1, P2, P3 = quad\n eps = 1e-6\n p0 = Vector.fromPoint(P0) # fromPoint converts to ECEF\n p1 = Vector.fromPoint(P1)\n p2 = Vector.fromPoint(P2)\n p1p0 = p1 - p0\n p2p0 = p2 - p0\n qnv = Vector.cross(p2p0, p1p0).norm()\n tmp = p0 + qnv\n tmplat, tmplon, tmpz = ecef2latlon(tmp.x, tmp.y, tmp.z)\n if (tmpz - P0.depth) < eps: # If True then do nothing\n fixed = quad\n else:\n newP0 = copy.deepcopy(P1)\n newP1 = copy.deepcopy(P0)\n newP2 = copy.deepcopy(P3)\n newP3 = copy.deepcopy(P2)\n fixed = [newP0, newP1, newP2, newP3]\n return fixed\n\n def _setQuadrilaterals(self):\n \"\"\"\n Create internal list of N quadrilaterals. Reverses quad if dip\n direction is incorrect.\n \"\"\"\n\n # Make sure arrays are numpy arrays.\n self._lon = np.array(self._lon)\n self._lat = np.array(self._lat)\n self._depth = np.array(self._depth)\n\n # Find the nans, which tells is where the separate polygons/groups are\n group_ends = np.where(np.isnan(self._lon))[0]\n n_groups = len(group_ends)\n\n # Check that arrays are the same length\n if len(self._lon) != len(self._lat) != len(self._depth):\n raise IndexError(\n 'Length of input lon, lat, depth arrays must be equal')\n\n # Construct quads\n group_start = 0\n\n self._quadrilaterals = []\n self._group_index = []\n groupind = 0\n for i in range(n_groups):\n lonseg = self._lon[group_start:group_ends[i]]\n latseg = self._lat[group_start:group_ends[i]]\n depthseg = self._depth[group_start:group_ends[i]]\n\n # Each group can have many contiguous quadrilaterals defined in it\n # separations (nans) between segments mean that segments are not\n # contiguous.\n\n npoints = len(lonseg)\n nquads = int((npoints - 4) / 2) + 1\n quad_start = 0\n quad_end = -1\n for j in range(nquads):\n P0 = Point(lonseg[quad_start],\n latseg[quad_start],\n depthseg[quad_start])\n P1 = Point(lonseg[quad_start + 1],\n latseg[quad_start + 1],\n depthseg[quad_start + 1])\n P2 = Point(lonseg[quad_end - 1],\n latseg[quad_end - 1],\n depthseg[quad_end - 1])\n P3 = Point(lonseg[quad_end],\n latseg[quad_end],\n depthseg[quad_end])\n quad = [P0, P1, P2, P3]\n\n # Enforce plane by moving P2 -- already close because of check\n # in read_rupture_file/is_quadrupture_class/is_quad\n\n dummy, fixed_quad = utils.is_quad(quad)\n\n # Reverse quad if necessary\n fixed_quad = self._fixStrikeDirection(fixed_quad)\n\n self._quadrilaterals.append(fixed_quad)\n\n quad_start = quad_start + 1\n quad_end = quad_end - 1\n\n group_start = group_ends[i] + 1\n self._group_index.extend([groupind] * nquads)\n groupind = groupind + 1\n\n def _getGroupIndex(self):\n \"\"\"\n Return a list of segment group indexes.\n\n Returns:\n list: Segment group indexes; length equals the number of\n quadrilaterals.\n \"\"\"\n return copy.deepcopy(self._group_index)\n\n @property\n def lats(self):\n \"\"\"\n Return an array of latitudes for the rupture verticies arranged for\n plotting purposes; will give an outline of each group connected\n segments.\n\n Returns:\n array: Numpy array of closed-loop latitude values; disconnected\n segments are separated by nans.\n \"\"\"\n lats = []\n quads = self.getQuadrilaterals()\n groups = self._getGroupIndex()\n u_groups = np.unique(groups)\n ng = len(u_groups)\n for i in range(ng):\n q_ind = np.where(groups == u_groups[i])[0]\n nq = len(q_ind)\n top_lats = []\n bot_lats = []\n for j in range(nq):\n if j == 0:\n top0 = [quads[q_ind[j]][0].latitude]\n bot0 = [quads[q_ind[j]][3].latitude]\n top_lats = top_lats + top0\n bot_lats = bot_lats + bot0\n top_lats = top_lats + [quads[q_ind[j]][1].latitude]\n bot_lats = bot_lats + [quads[q_ind[j]][2].latitude]\n lats = lats + top_lats + bot_lats[::-1] + top0 + [np.nan]\n\n return np.array(lats)\n\n @property\n def lons(self):\n \"\"\"\n Return an array of longitudes for the rupture verticies arranged for\n plotting purposes; will give an outline of each group connected\n segments.\n\n Returns:\n array: Numpy array of closed-loop longitude values; disconnected\n segments are separated by nans.\n \"\"\"\n lons = []\n quads = self.getQuadrilaterals()\n groups = self._getGroupIndex()\n u_groups = np.unique(groups)\n ng = len(u_groups)\n for i in range(ng):\n q_ind = np.where(groups == u_groups[i])[0]\n nq = len(q_ind)\n top_lons = []\n bot_lons = []\n for j in range(nq):\n if j == 0:\n top0 = [quads[q_ind[j]][0].longitude]\n bot0 = [quads[q_ind[j]][3].longitude]\n top_lons = top_lons + top0\n bot_lons = bot_lons + bot0\n top_lons = top_lons + [quads[q_ind[j]][1].longitude]\n bot_lons = bot_lons + [quads[q_ind[j]][2].longitude]\n lons = lons + top_lons + bot_lons[::-1] + top0 + [np.nan]\n return np.array(lons)\n\n @property\n def depths(self):\n \"\"\"\n Return an array of depths for the rupture verticies arranged for\n plotting purposes; will give an outline of each group connected\n segments.\n\n Returns:\n array: Numpy array of closed-loop depths; disconnected\n segments are separated by nans.\n \"\"\"\n deps = []\n quads = self.getQuadrilaterals()\n groups = self._getGroupIndex()\n u_groups = np.unique(groups)\n ng = len(u_groups)\n for i in range(ng):\n q_ind = np.where(groups == u_groups[i])[0]\n nq = len(q_ind)\n top_deps = []\n bot_deps = []\n for j in range(nq):\n if j == 0:\n top0 = [quads[q_ind[j]][0].depth]\n bot0 = [quads[q_ind[j]][3].depth]\n top_deps = top_deps + top0\n bot_deps = bot_deps + bot0\n top_deps = top_deps + [quads[q_ind[j]][1].depth]\n bot_deps = bot_deps + [quads[q_ind[j]][2].depth]\n deps = deps + top_deps + bot_deps[::-1] + top0 + [np.nan]\n\n return np.array(deps)\n\n def getDeps(self):\n \"\"\"\n Return a copy of the array of depths for the rupture verticies.\n\n Returns:\n array: Numpy array of latitude values.\n \"\"\"\n return self._depth.copy()\n\n def getNumGroups(self):\n \"\"\"\n Return a count of the number of rupture groups.\n\n Returns:\n int:Rnumber of rupture groups.\n\n \"\"\"\n return len(np.unique(self._group_index))\n\n def getNumQuads(self):\n \"\"\"\n Return a count of the number of rupture quadrilaterals.\n\n Returns:\n int: Number of rupture quadrilaterals.\n \"\"\"\n return len(self._quadrilaterals)\n\n def getRuptureAsArrays(self):\n \"\"\"\n Return a 3-tuple of numpy arrays indicating X, Y, Z (lon,lat,depth)\n coordinates. Rupture groups are separated by numpy.NaN values.\n\n Returns:\n tuple: 3-tuple of numpy arrays indicating X,Y,Z (lon,lat,depth)\n coordinates.\n \"\"\"\n return (np.array(self._lon),\n np.array(self._lat),\n np.array(self._depth))\n\n def getRuptureAsMesh(self):\n \"\"\"\n Return rupture segments as a OQ-Hazardlib Mesh object.\n\n Returns:\n Mesh (https://github.com/gem/oq-hazardlib/blob/master/openquake/hazardlib/geo/mesh.py)\n \"\"\" # noqa\n rupture = Mesh(self._lon, self._lat, self._depth)\n return rupture\n\n def computeRjb(self, lon, lat, depth):\n \"\"\"\n Method for computing Joyner-Boore distance.\n\n Args:\n lon (array): Numpy array of longitudes.\n lat (array): Numpy array of latitudes.\n depth (array): Numpy array of depths (km; positive down).\n\n Returns:\n array: Joyner-Boore distance (km).\n\n \"\"\"\n\n # ---------------------------------------------------------------------\n # Sort out sites\n # ---------------------------------------------------------------------\n oldshape = lon.shape\n\n if len(oldshape) == 2:\n newshape = (oldshape[0] * oldshape[1], 1)\n else:\n newshape = (oldshape[0], 1)\n\n x, y, z = latlon2ecef(lat, lon, depth)\n x.shape = newshape\n y.shape = newshape\n z.shape = newshape\n sites_ecef = np.hstack((x, y, z))\n\n minrjb = np.ones(newshape, dtype=lon.dtype) * 1e16\n quads = self.getQuadrilaterals()\n\n for i in range(len(quads)):\n P0, P1, P2, P3 = quads[i]\n S0 = copy.deepcopy(P0)\n S1 = copy.deepcopy(P1)\n S2 = copy.deepcopy(P2)\n S3 = copy.deepcopy(P3)\n S0.depth = 0.0\n S1.depth = 0.0\n S2.depth = 0.0\n S3.depth = 0.0\n squad = [S0, S1, S2, S3]\n rjbdist = utils._quad_distance(squad, sites_ecef, horizontal=True)\n minrjb = np.minimum(minrjb, rjbdist)\n\n minrjb = minrjb.reshape(oldshape)\n return minrjb\n\n def computeRrup(self, lon, lat, depth):\n \"\"\"\n Method for computing rupture distance.\n\n Args:\n lon (array): Numpy array of longitudes.\n lat (array): Numpy array of latitudes.\n depth (array): Numpy array of depths (km; positive down).\n\n Returns:\n array: Rupture distance (km).\n\n \"\"\"\n\n # ---------------------------------------------------------------------\n # Sort out sites\n # ---------------------------------------------------------------------\n oldshape = lon.shape\n\n if len(oldshape) == 2:\n newshape = (oldshape[0] * oldshape[1], 1)\n else:\n newshape = (oldshape[0], 1)\n\n x, y, z = latlon2ecef(lat, lon, depth)\n x.shape = newshape\n y.shape = newshape\n z.shape = newshape\n sites_ecef = np.hstack((x, y, z))\n\n minrrup = np.ones(newshape, dtype=lon.dtype) * 1e16\n quads = self.getQuadrilaterals()\n\n for i in range(len(quads)):\n rrupdist = utils._quad_distance(quads[i], sites_ecef)\n minrrup = np.minimum(minrrup, rrupdist)\n\n minrrup = minrrup.reshape(oldshape)\n return minrrup\n\n def computeGC2(self, lon, lat, depth):\n \"\"\"\n Method for computing version 2 of the Generalized Coordinate system\n (GC2) by Spudich and Chiou OFR 2015-1028.\n\n Args:\n lon (array): Numpy array of longitudes.\n lat (array): Numpy array of latitudes.\n depth (array): Numpy array of depths (km; positive down).\n\n Returns:\n dict: Dictionary with keys for each of the GC2-related distances,\n which include 'rx', 'ry', 'ry0', 'U', 'T'.\n \"\"\"\n # This just hands off to the module-level method\n dict = gc2._computeGC2(self, lon, lat, depth)\n return dict\n", "meta": {"hexsha": "9c298626db1d797e5c37dc8b9f5ce94b16318019", "size": 35549, "ext": "py", "lang": "Python", "max_stars_repo_path": "shakelib/rupture/quad_rupture.py", "max_stars_repo_name": "ynthdhj/shakemap", "max_stars_repo_head_hexsha": "2771b8aee6b22f065cc80632c894a0ba77829619", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "shakelib/rupture/quad_rupture.py", "max_issues_repo_name": "ynthdhj/shakemap", "max_issues_repo_head_hexsha": "2771b8aee6b22f065cc80632c894a0ba77829619", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "shakelib/rupture/quad_rupture.py", "max_forks_repo_name": "ynthdhj/shakemap", "max_forks_repo_head_hexsha": "2771b8aee6b22f065cc80632c894a0ba77829619", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.0581854043, "max_line_length": 108, "alphanum_fraction": 0.5116037019, "include": true, "reason": "import numpy", "num_tokens": 8896, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5964331462646255, "lm_q2_score": 0.33111973302838926, "lm_q1q2_score": 0.19749078416042504}} {"text": "# -*- coding: utf-8 -*-\n\"\"\"\nSpyder Editor\n\nThis is a temporary script file.\n\"\"\"\n\n# standard imports \nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# custom imports\nimport GaN_fun\nimport GaN_type_peak_assignments\n\nimport peak_param_determination as ppd\nfrom histogram_functions import bin_dat\n\nplt.close('all')\n\n# Read in data\nepos = GaN_fun.load_epos(run_number='R44_03146', \n epos_trim=[5000, 5000],\n fig_idx=999)\n\npk_data = GaN_type_peak_assignments.In_doped_GaN()\nbg_rois=[[0.4,0.9]]\n#bg_rois=[[10,11]]\n\npk_params, glob_bg_param, Ga1p_idxs, Ga2p_idxs = GaN_fun.fit_spectrum(\n epos=epos, \n pk_data=pk_data, \n peak_height_fraction=0.1, \n bg_rois=bg_rois)\n\ncts, compositions, is_peak = GaN_fun.count_and_get_compositions(\n epos=epos, \n pk_data=pk_data,\n pk_params=pk_params, \n glob_bg_param=glob_bg_param, \n bg_frac=1, \n noise_threshhold=2)\n\n# Print out the composition of the full dataset\nppd.pretty_print_compositions(compositions,pk_data)\n\n# Plot the full spectrum\nxs, ys_sm = GaN_fun.bin_and_smooth_spectrum(epos=epos,\n user_roi=[0,150],\n bin_wid_mDa=30,\n smooth_wid_mDa=-1)\n\nfig = plt.figure(num=1)\nfig.set_size_inches(w=6.69, h=3)\nfig.clear()\nax = fig.gca()\n\nax.plot(xs, ys_sm, lw=1, label='full spec')\n\nglob_bg = ppd.physics_bg(xs,glob_bg_param) \nax.plot(xs, glob_bg, lw=1, label='bg', alpha=1)\n\nax.set_xlim(0,120)\nax.set_ylim(1e0,1e5)\nax.grid(b=True)\nax.set(xlabel='m/z', ylabel='counts')\nax.set_yscale('log') \nax.legend()\nfig.tight_layout()\n\nfig.savefig('InGaN_full_spectrum.pdf')\nfig.savefig('InGaN_full_spectrum.jpg', dpi=300)\n\n\n\n\n# Find the pole center and show it\nm2q_roi = [3, 100]\nsel_idxs = np.where((epos['m2q']>m2q_roi[0]) & (epos['m2q']0:\n is_In = is_In | ((epos['m2q']>=param['pre_rng']) & (epos['m2q']<=param['post_rng']))\n \n# Fit the QW to a plane and rotate the point cloud to 'flatten' wrt z-axis\np = GaN_fun.qw_plane_fit(epos['x'][is_In],epos['y'][is_In],epos['z'][is_In],np.array([0,0,1.8]))\nepos['x'],epos['y'],epos['z'] = GaN_fun.rotate_data_flat(p,epos['x'],epos['y'],epos['z'])\n\n# USER DEFINED!!!\n# Z-ROIs TO TAKE COMPOSITIONS IN\nz_roi_qw = [38, 38.6]\nz_roi_buf = [43, 48]\nz_roi_gan = [40, 42]\n\n# Find all the Ga events\nis_Ga = ~np.isfinite(epos['m2q'])\nfor pk,param in zip(pk_data,pk_params):\n if pk['Ga']>0:\n is_Ga = is_Ga | ((epos['m2q']>=param['pre_rng']) & (epos['m2q']<=param['post_rng']))\n\nimport colorcet as cc \ncm=cc.cm.glasbey\n\n# Plot the 'flat' interface to verify vector algebra didn't go awry\nfig = plt.figure(num=11)\nfig.clear()\nax = fig.gca()\n#ax.plot(epos['x'][is_In],epos['z'][is_In],'.')\n#ax.plot(epos['y'][is_In],epos['z'][is_In],'.')\nax.plot(epos['x'][is_Ga],epos['z'][is_Ga],'.', alpha=0.05, color=cm(2), ms=2)\nax.plot(epos['x'][is_In],epos['z'][is_In],'.', alpha=0.5, color=cm(10), ms=2)\n\n\n# Plot the ROIs for visual inspection\nax.fill([-8,-8, 8,8], [z_roi_qw[0], z_roi_qw[1], z_roi_qw[1], z_roi_qw[0]], color=[1,0,0,0.5]) \nax.fill([-8,-8, 8,8], [z_roi_buf[0], z_roi_buf[1], z_roi_buf[1], z_roi_buf[0]], color=[1,0,0,0.5]) \nax.fill([-8,-8, 8,8], [z_roi_gan[0], z_roi_gan[1], z_roi_gan[1], z_roi_gan[0]], color=[1,0,0,0.5]) \n\n\n# Calculate the QW composition\nis_roi = (epos['z']>=z_roi_qw[0]) & (epos['z']<=z_roi_qw[1])\nsub_epos = epos[is_roi]\n\nbg_frac_roi = [120,150]\nbg_frac = np.sum((sub_epos['m2q']>bg_frac_roi[0]) & (sub_epos['m2q']bg_frac_roi[0]) & (epos['m2q']=z_roi_buf[0]) & (epos['z']<=z_roi_buf[1])\nsub_epos = epos[is_roi]\n\nbg_frac_roi = [120,150]\nbg_frac = np.sum((sub_epos['m2q']>bg_frac_roi[0]) & (sub_epos['m2q']bg_frac_roi[0]) & (epos['m2q']=z_roi_gan[0]) & (epos['z']<=z_roi_gan[1])\nsub_epos = epos[is_roi]\n\nbg_frac_roi = [120,150]\nbg_frac = np.sum((sub_epos['m2q']>bg_frac_roi[0]) & (sub_epos['m2q']bg_frac_roi[0]) & (epos['m2q']\" % self._rep_type\n\n def __eq__(self, other):\n \"\"\"Determine if this `ReparameterizationType` is equal to another.\n\n Since RepaparameterizationType instances are constant static global\n instances, equality checks if two instances' id() values are equal.\n\n Args:\n other: Object to compare against.\n\n Returns:\n `self is other`.\n \"\"\"\n return self is other\n\n\n# Fully reparameterized distribution: samples from a fully\n# reparameterized distribution support straight-through gradients with\n# respect to all parameters.\nFULLY_REPARAMETERIZED = ReparameterizationType(\"FULLY_REPARAMETERIZED\")\ntf_export(\"distributions.FULLY_REPARAMETERIZED\").export_constant(\n __name__, \"FULLY_REPARAMETERIZED\")\n\n\n# Not reparameterized distribution: samples from a non-\n# reparameterized distribution do not support straight-through gradients for\n# at least some of the parameters.\nNOT_REPARAMETERIZED = ReparameterizationType(\"NOT_REPARAMETERIZED\")\ntf_export(\"distributions.NOT_REPARAMETERIZED\").export_constant(\n __name__, \"NOT_REPARAMETERIZED\")\n\n\n@six.add_metaclass(_DistributionMeta)\n@tf_export(\"distributions.Distribution\")\nclass Distribution(_BaseDistribution):\n \"\"\"A generic probability distribution base class.\n\n `Distribution` is a base class for constructing and organizing properties\n (e.g., mean, variance) of random variables (e.g, Bernoulli, Gaussian).\n\n #### Subclassing\n\n Subclasses are expected to implement a leading-underscore version of the\n same-named function. The argument signature should be identical except for\n the omission of `name=\"...\"`. For example, to enable `log_prob(value,\n name=\"log_prob\")` a subclass should implement `_log_prob(value)`.\n\n Subclasses can append to public-level docstrings by providing\n docstrings for their method specializations. For example:\n\n ```python\n @util.AppendDocstring(\"Some other details.\")\n def _log_prob(self, value):\n ...\n ```\n\n would add the string \"Some other details.\" to the `log_prob` function\n docstring. This is implemented as a simple decorator to avoid python\n linter complaining about missing Args/Returns/Raises sections in the\n partial docstrings.\n\n #### Broadcasting, batching, and shapes\n\n All distributions support batches of independent distributions of that type.\n The batch shape is determined by broadcasting together the parameters.\n\n The shape of arguments to `__init__`, `cdf`, `log_cdf`, `prob`, and\n `log_prob` reflect this broadcasting, as does the return value of `sample` and\n `sample_n`.\n\n `sample_n_shape = [n] + batch_shape + event_shape`, where `sample_n_shape` is\n the shape of the `Tensor` returned from `sample_n`, `n` is the number of\n samples, `batch_shape` defines how many independent distributions there are,\n and `event_shape` defines the shape of samples from each of those independent\n distributions. Samples are independent along the `batch_shape` dimensions, but\n not necessarily so along the `event_shape` dimensions (depending on the\n particulars of the underlying distribution).\n\n Using the `Uniform` distribution as an example:\n\n ```python\n minval = 3.0\n maxval = [[4.0, 6.0],\n [10.0, 12.0]]\n\n # Broadcasting:\n # This instance represents 4 Uniform distributions. Each has a lower bound at\n # 3.0 as the `minval` parameter was broadcasted to match `maxval`'s shape.\n u = Uniform(minval, maxval)\n\n # `event_shape` is `TensorShape([])`.\n event_shape = u.event_shape\n # `event_shape_t` is a `Tensor` which will evaluate to [].\n event_shape_t = u.event_shape_tensor()\n\n # Sampling returns a sample per distribution. `samples` has shape\n # [5, 2, 2], which is [n] + batch_shape + event_shape, where n=5,\n # batch_shape=[2, 2], and event_shape=[].\n samples = u.sample_n(5)\n\n # The broadcasting holds across methods. Here we use `cdf` as an example. The\n # same holds for `log_cdf` and the likelihood functions.\n\n # `cum_prob` has shape [2, 2] as the `value` argument was broadcasted to the\n # shape of the `Uniform` instance.\n cum_prob_broadcast = u.cdf(4.0)\n\n # `cum_prob`'s shape is [2, 2], one per distribution. No broadcasting\n # occurred.\n cum_prob_per_dist = u.cdf([[4.0, 5.0],\n [6.0, 7.0]])\n\n # INVALID as the `value` argument is not broadcastable to the distribution's\n # shape.\n cum_prob_invalid = u.cdf([4.0, 5.0, 6.0])\n ```\n\n #### Shapes\n\n There are three important concepts associated with TensorFlow Distributions\n shapes:\n - Event shape describes the shape of a single draw from the distribution;\n it may be dependent across dimensions. For scalar distributions, the event\n shape is `[]`. For a 5-dimensional MultivariateNormal, the event shape is\n `[5]`.\n - Batch shape describes independent, not identically distributed draws, aka a\n \"collection\" or \"bunch\" of distributions.\n - Sample shape describes independent, identically distributed draws of batches\n from the distribution family.\n\n The event shape and the batch shape are properties of a Distribution object,\n whereas the sample shape is associated with a specific call to `sample` or\n `log_prob`.\n\n For detailed usage examples of TensorFlow Distributions shapes, see\n [this tutorial](\n https://github.com/tensorflow/probability/blob/master/tensorflow_probability/examples/jupyter_notebooks/Understanding_TensorFlow_Distributions_Shapes.ipynb)\n\n #### Parameter values leading to undefined statistics or distributions.\n\n Some distributions do not have well-defined statistics for all initialization\n parameter values. For example, the beta distribution is parameterized by\n positive real numbers `concentration1` and `concentration0`, and does not have\n well-defined mode if `concentration1 < 1` or `concentration0 < 1`.\n\n The user is given the option of raising an exception or returning `NaN`.\n\n ```python\n a = tf.exp(tf.matmul(logits, weights_a))\n b = tf.exp(tf.matmul(logits, weights_b))\n\n # Will raise exception if ANY batch member has a < 1 or b < 1.\n dist = distributions.beta(a, b, allow_nan_stats=False)\n mode = dist.mode().eval()\n\n # Will return NaN for batch members with either a < 1 or b < 1.\n dist = distributions.beta(a, b, allow_nan_stats=True) # Default behavior\n mode = dist.mode().eval()\n ```\n\n In all cases, an exception is raised if *invalid* parameters are passed, e.g.\n\n ```python\n # Will raise an exception if any Op is run.\n negative_a = -1.0 * a # beta distribution by definition has a > 0.\n dist = distributions.beta(negative_a, b, allow_nan_stats=True)\n dist.mean().eval()\n ```\n\n \"\"\"\n\n def __init__(self,\n dtype,\n reparameterization_type,\n validate_args,\n allow_nan_stats,\n parameters=None,\n graph_parents=None,\n name=None):\n \"\"\"Constructs the `Distribution`.\n\n **This is a private method for subclass use.**\n\n Args:\n dtype: The type of the event samples. `None` implies no type-enforcement.\n reparameterization_type: Instance of `ReparameterizationType`.\n If `distributions.FULLY_REPARAMETERIZED`, this\n `Distribution` can be reparameterized in terms of some standard\n distribution with a function whose Jacobian is constant for the support\n of the standard distribution. If `distributions.NOT_REPARAMETERIZED`,\n then no such reparameterization is available.\n validate_args: Python `bool`, default `False`. When `True` distribution\n parameters are checked for validity despite possibly degrading runtime\n performance. When `False` invalid inputs may silently render incorrect\n outputs.\n allow_nan_stats: Python `bool`, default `True`. When `True`, statistics\n (e.g., mean, mode, variance) use the value \"`NaN`\" to indicate the\n result is undefined. When `False`, an exception is raised if one or\n more of the statistic's batch members are undefined.\n parameters: Python `dict` of parameters used to instantiate this\n `Distribution`.\n graph_parents: Python `list` of graph prerequisites of this\n `Distribution`.\n name: Python `str` name prefixed to Ops created by this class. Default:\n subclass name.\n\n Raises:\n ValueError: if any member of graph_parents is `None` or not a `Tensor`.\n \"\"\"\n graph_parents = [] if graph_parents is None else graph_parents\n for i, t in enumerate(graph_parents):\n if t is None or not tensor_util.is_tensor(t):\n raise ValueError(\"Graph parent item %d is not a Tensor; %s.\" % (i, t))\n if not name or name[-1] != \"/\": # `name` is not a name scope\n non_unique_name = name or type(self).__name__\n with ops.name_scope(non_unique_name) as name:\n pass\n self._dtype = dtype\n self._reparameterization_type = reparameterization_type\n self._allow_nan_stats = allow_nan_stats\n self._validate_args = validate_args\n self._parameters = parameters or {}\n self._graph_parents = graph_parents\n self._name = name\n\n @property\n def _parameters(self):\n return self._parameter_dict\n\n @_parameters.setter\n def _parameters(self, value):\n \"\"\"Intercept assignments to self._parameters to avoid reference cycles.\n\n Parameters are often created using locals(), so we need to clean out any\n references to `self` before assigning it to an attribute.\n\n Args:\n value: A dictionary of parameters to assign to the `_parameters` property.\n \"\"\"\n if \"self\" in value:\n del value[\"self\"]\n self._parameter_dict = value\n\n @classmethod\n def param_shapes(cls, sample_shape, name=\"DistributionParamShapes\"):\n \"\"\"Shapes of parameters given the desired shape of a call to `sample()`.\n\n This is a class method that describes what key/value arguments are required\n to instantiate the given `Distribution` so that a particular shape is\n returned for that instance's call to `sample()`.\n\n Subclasses should override class method `_param_shapes`.\n\n Args:\n sample_shape: `Tensor` or python list/tuple. Desired shape of a call to\n `sample()`.\n name: name to prepend ops with.\n\n Returns:\n `dict` of parameter name to `Tensor` shapes.\n \"\"\"\n with ops.name_scope(name, values=[sample_shape]):\n return cls._param_shapes(sample_shape)\n\n @classmethod\n def param_static_shapes(cls, sample_shape):\n \"\"\"param_shapes with static (i.e. `TensorShape`) shapes.\n\n This is a class method that describes what key/value arguments are required\n to instantiate the given `Distribution` so that a particular shape is\n returned for that instance's call to `sample()`. Assumes that the sample's\n shape is known statically.\n\n Subclasses should override class method `_param_shapes` to return\n constant-valued tensors when constant values are fed.\n\n Args:\n sample_shape: `TensorShape` or python list/tuple. Desired shape of a call\n to `sample()`.\n\n Returns:\n `dict` of parameter name to `TensorShape`.\n\n Raises:\n ValueError: if `sample_shape` is a `TensorShape` and is not fully defined.\n \"\"\"\n if isinstance(sample_shape, tensor_shape.TensorShape):\n if not sample_shape.is_fully_defined():\n raise ValueError(\"TensorShape sample_shape must be fully defined\")\n sample_shape = sample_shape.as_list()\n\n params = cls.param_shapes(sample_shape)\n\n static_params = {}\n for name, shape in params.items():\n static_shape = tensor_util.constant_value(shape)\n if static_shape is None:\n raise ValueError(\n \"sample_shape must be a fully-defined TensorShape or list/tuple\")\n static_params[name] = tensor_shape.TensorShape(static_shape)\n\n return static_params\n\n @staticmethod\n def _param_shapes(sample_shape):\n raise NotImplementedError(\"_param_shapes not implemented\")\n\n @property\n def name(self):\n \"\"\"Name prepended to all ops created by this `Distribution`.\"\"\"\n return self._name\n\n @property\n def dtype(self):\n \"\"\"The `DType` of `Tensor`s handled by this `Distribution`.\"\"\"\n return self._dtype\n\n @property\n def parameters(self):\n \"\"\"Dictionary of parameters used to instantiate this `Distribution`.\"\"\"\n # Remove \"self\", \"__class__\", or other special variables. These can appear\n # if the subclass used:\n # `parameters = dict(locals())`.\n return {k: v for k, v in self._parameters.items()\n if not k.startswith(\"__\") and k != \"self\"}\n\n @property\n def reparameterization_type(self):\n \"\"\"Describes how samples from the distribution are reparameterized.\n\n Currently this is one of the static instances\n `distributions.FULLY_REPARAMETERIZED`\n or `distributions.NOT_REPARAMETERIZED`.\n\n Returns:\n An instance of `ReparameterizationType`.\n \"\"\"\n return self._reparameterization_type\n\n @property\n def allow_nan_stats(self):\n \"\"\"Python `bool` describing behavior when a stat is undefined.\n\n Stats return +/- infinity when it makes sense. E.g., the variance of a\n Cauchy distribution is infinity. However, sometimes the statistic is\n undefined, e.g., if a distribution's pdf does not achieve a maximum within\n the support of the distribution, the mode is undefined. If the mean is\n undefined, then by definition the variance is undefined. E.g. the mean for\n Student's T for df = 1 is undefined (no clear way to say it is either + or -\n infinity), so the variance = E[(X - mean)**2] is also undefined.\n\n Returns:\n allow_nan_stats: Python `bool`.\n \"\"\"\n return self._allow_nan_stats\n\n @property\n def validate_args(self):\n \"\"\"Python `bool` indicating possibly expensive checks are enabled.\"\"\"\n return self._validate_args\n\n def copy(self, **override_parameters_kwargs):\n \"\"\"Creates a deep copy of the distribution.\n\n Note: the copy distribution may continue to depend on the original\n initialization arguments.\n\n Args:\n **override_parameters_kwargs: String/value dictionary of initialization\n arguments to override with new values.\n\n Returns:\n distribution: A new instance of `type(self)` initialized from the union\n of self.parameters and override_parameters_kwargs, i.e.,\n `dict(self.parameters, **override_parameters_kwargs)`.\n \"\"\"\n parameters = dict(self.parameters, **override_parameters_kwargs)\n return type(self)(**parameters)\n\n def _batch_shape_tensor(self):\n raise NotImplementedError(\n \"batch_shape_tensor is not implemented: {}\".format(type(self).__name__))\n\n def batch_shape_tensor(self, name=\"batch_shape_tensor\"):\n \"\"\"Shape of a single sample from a single event index as a 1-D `Tensor`.\n\n The batch dimensions are indexes into independent, non-identical\n parameterizations of this distribution.\n\n Args:\n name: name to give to the op\n\n Returns:\n batch_shape: `Tensor`.\n \"\"\"\n with self._name_scope(name):\n if self.batch_shape.is_fully_defined():\n return ops.convert_to_tensor(self.batch_shape.as_list(),\n dtype=dtypes.int32,\n name=\"batch_shape\")\n return self._batch_shape_tensor()\n\n def _batch_shape(self):\n return tensor_shape.TensorShape(None)\n\n @property\n def batch_shape(self):\n \"\"\"Shape of a single sample from a single event index as a `TensorShape`.\n\n May be partially defined or unknown.\n\n The batch dimensions are indexes into independent, non-identical\n parameterizations of this distribution.\n\n Returns:\n batch_shape: `TensorShape`, possibly unknown.\n \"\"\"\n return tensor_shape.as_shape(self._batch_shape())\n\n def _event_shape_tensor(self):\n raise NotImplementedError(\n \"event_shape_tensor is not implemented: {}\".format(type(self).__name__))\n\n def event_shape_tensor(self, name=\"event_shape_tensor\"):\n \"\"\"Shape of a single sample from a single batch as a 1-D int32 `Tensor`.\n\n Args:\n name: name to give to the op\n\n Returns:\n event_shape: `Tensor`.\n \"\"\"\n with self._name_scope(name):\n if self.event_shape.is_fully_defined():\n return ops.convert_to_tensor(self.event_shape.as_list(),\n dtype=dtypes.int32,\n name=\"event_shape\")\n return self._event_shape_tensor()\n\n def _event_shape(self):\n return tensor_shape.TensorShape(None)\n\n @property\n def event_shape(self):\n \"\"\"Shape of a single sample from a single batch as a `TensorShape`.\n\n May be partially defined or unknown.\n\n Returns:\n event_shape: `TensorShape`, possibly unknown.\n \"\"\"\n return tensor_shape.as_shape(self._event_shape())\n\n def is_scalar_event(self, name=\"is_scalar_event\"):\n \"\"\"Indicates that `event_shape == []`.\n\n Args:\n name: Python `str` prepended to names of ops created by this function.\n\n Returns:\n is_scalar_event: `bool` scalar `Tensor`.\n \"\"\"\n with self._name_scope(name):\n return ops.convert_to_tensor(\n self._is_scalar_helper(self.event_shape, self.event_shape_tensor),\n name=\"is_scalar_event\")\n\n def is_scalar_batch(self, name=\"is_scalar_batch\"):\n \"\"\"Indicates that `batch_shape == []`.\n\n Args:\n name: Python `str` prepended to names of ops created by this function.\n\n Returns:\n is_scalar_batch: `bool` scalar `Tensor`.\n \"\"\"\n with self._name_scope(name):\n return ops.convert_to_tensor(\n self._is_scalar_helper(self.batch_shape, self.batch_shape_tensor),\n name=\"is_scalar_batch\")\n\n def _sample_n(self, n, seed=None):\n raise NotImplementedError(\"sample_n is not implemented: {}\".format(\n type(self).__name__))\n\n def _call_sample_n(self, sample_shape, seed, name, **kwargs):\n with self._name_scope(name, values=[sample_shape]):\n sample_shape = ops.convert_to_tensor(\n sample_shape, dtype=dtypes.int32, name=\"sample_shape\")\n sample_shape, n = self._expand_sample_shape_to_vector(\n sample_shape, \"sample_shape\")\n samples = self._sample_n(n, seed, **kwargs)\n batch_event_shape = array_ops.shape(samples)[1:]\n final_shape = array_ops.concat([sample_shape, batch_event_shape], 0)\n samples = array_ops.reshape(samples, final_shape)\n samples = self._set_sample_static_shape(samples, sample_shape)\n return samples\n\n def sample(self, sample_shape=(), seed=None, name=\"sample\"):\n \"\"\"Generate samples of the specified shape.\n\n Note that a call to `sample()` without arguments will generate a single\n sample.\n\n Args:\n sample_shape: 0D or 1D `int32` `Tensor`. Shape of the generated samples.\n seed: Python integer seed for RNG\n name: name to give to the op.\n\n Returns:\n samples: a `Tensor` with prepended dimensions `sample_shape`.\n \"\"\"\n return self._call_sample_n(sample_shape, seed, name)\n\n def _log_prob(self, value):\n raise NotImplementedError(\"log_prob is not implemented: {}\".format(\n type(self).__name__))\n\n def _call_log_prob(self, value, name, **kwargs):\n with self._name_scope(name, values=[value]):\n value = ops.convert_to_tensor(value, name=\"value\")\n try:\n return self._log_prob(value, **kwargs)\n except NotImplementedError as original_exception:\n try:\n return math_ops.log(self._prob(value, **kwargs))\n except NotImplementedError:\n raise original_exception\n\n def log_prob(self, value, name=\"log_prob\"):\n \"\"\"Log probability density/mass function.\n\n Args:\n value: `float` or `double` `Tensor`.\n name: Python `str` prepended to names of ops created by this function.\n\n Returns:\n log_prob: a `Tensor` of shape `sample_shape(x) + self.batch_shape` with\n values of type `self.dtype`.\n \"\"\"\n return self._call_log_prob(value, name)\n\n def _prob(self, value):\n raise NotImplementedError(\"prob is not implemented: {}\".format(\n type(self).__name__))\n\n def _call_prob(self, value, name, **kwargs):\n with self._name_scope(name, values=[value]):\n value = ops.convert_to_tensor(value, name=\"value\")\n try:\n return self._prob(value, **kwargs)\n except NotImplementedError as original_exception:\n try:\n return math_ops.exp(self._log_prob(value, **kwargs))\n except NotImplementedError:\n raise original_exception\n\n def prob(self, value, name=\"prob\"):\n \"\"\"Probability density/mass function.\n\n Args:\n value: `float` or `double` `Tensor`.\n name: Python `str` prepended to names of ops created by this function.\n\n Returns:\n prob: a `Tensor` of shape `sample_shape(x) + self.batch_shape` with\n values of type `self.dtype`.\n \"\"\"\n return self._call_prob(value, name)\n\n def _log_cdf(self, value):\n raise NotImplementedError(\"log_cdf is not implemented: {}\".format(\n type(self).__name__))\n\n def _call_log_cdf(self, value, name, **kwargs):\n with self._name_scope(name, values=[value]):\n value = ops.convert_to_tensor(value, name=\"value\")\n try:\n return self._log_cdf(value, **kwargs)\n except NotImplementedError as original_exception:\n try:\n return math_ops.log(self._cdf(value, **kwargs))\n except NotImplementedError:\n raise original_exception\n\n def log_cdf(self, value, name=\"log_cdf\"):\n \"\"\"Log cumulative distribution function.\n\n Given random variable `X`, the cumulative distribution function `cdf` is:\n\n ```none\n log_cdf(x) := Log[ P[X <= x] ]\n ```\n\n Often, a numerical approximation can be used for `log_cdf(x)` that yields\n a more accurate answer than simply taking the logarithm of the `cdf` when\n `x << -1`.\n\n Args:\n value: `float` or `double` `Tensor`.\n name: Python `str` prepended to names of ops created by this function.\n\n Returns:\n logcdf: a `Tensor` of shape `sample_shape(x) + self.batch_shape` with\n values of type `self.dtype`.\n \"\"\"\n return self._call_log_cdf(value, name)\n\n def _cdf(self, value):\n raise NotImplementedError(\"cdf is not implemented: {}\".format(\n type(self).__name__))\n\n def _call_cdf(self, value, name, **kwargs):\n with self._name_scope(name, values=[value]):\n value = ops.convert_to_tensor(value, name=\"value\")\n try:\n return self._cdf(value, **kwargs)\n except NotImplementedError as original_exception:\n try:\n return math_ops.exp(self._log_cdf(value, **kwargs))\n except NotImplementedError:\n raise original_exception\n\n def cdf(self, value, name=\"cdf\"):\n \"\"\"Cumulative distribution function.\n\n Given random variable `X`, the cumulative distribution function `cdf` is:\n\n ```none\n cdf(x) := P[X <= x]\n ```\n\n Args:\n value: `float` or `double` `Tensor`.\n name: Python `str` prepended to names of ops created by this function.\n\n Returns:\n cdf: a `Tensor` of shape `sample_shape(x) + self.batch_shape` with\n values of type `self.dtype`.\n \"\"\"\n return self._call_cdf(value, name)\n\n def _log_survival_function(self, value):\n raise NotImplementedError(\n \"log_survival_function is not implemented: {}\".format(\n type(self).__name__))\n\n def _call_log_survival_function(self, value, name, **kwargs):\n with self._name_scope(name, values=[value]):\n value = ops.convert_to_tensor(value, name=\"value\")\n try:\n return self._log_survival_function(value, **kwargs)\n except NotImplementedError as original_exception:\n try:\n return math_ops.log1p(-self.cdf(value, **kwargs))\n except NotImplementedError:\n raise original_exception\n\n def log_survival_function(self, value, name=\"log_survival_function\"):\n \"\"\"Log survival function.\n\n Given random variable `X`, the survival function is defined:\n\n ```none\n log_survival_function(x) = Log[ P[X > x] ]\n = Log[ 1 - P[X <= x] ]\n = Log[ 1 - cdf(x) ]\n ```\n\n Typically, different numerical approximations can be used for the log\n survival function, which are more accurate than `1 - cdf(x)` when `x >> 1`.\n\n Args:\n value: `float` or `double` `Tensor`.\n name: Python `str` prepended to names of ops created by this function.\n\n Returns:\n `Tensor` of shape `sample_shape(x) + self.batch_shape` with values of type\n `self.dtype`.\n \"\"\"\n return self._call_log_survival_function(value, name)\n\n def _survival_function(self, value):\n raise NotImplementedError(\"survival_function is not implemented: {}\".format(\n type(self).__name__))\n\n def _call_survival_function(self, value, name, **kwargs):\n with self._name_scope(name, values=[value]):\n value = ops.convert_to_tensor(value, name=\"value\")\n try:\n return self._survival_function(value, **kwargs)\n except NotImplementedError as original_exception:\n try:\n return 1. - self.cdf(value, **kwargs)\n except NotImplementedError:\n raise original_exception\n\n def survival_function(self, value, name=\"survival_function\"):\n \"\"\"Survival function.\n\n Given random variable `X`, the survival function is defined:\n\n ```none\n survival_function(x) = P[X > x]\n = 1 - P[X <= x]\n = 1 - cdf(x).\n ```\n\n Args:\n value: `float` or `double` `Tensor`.\n name: Python `str` prepended to names of ops created by this function.\n\n Returns:\n `Tensor` of shape `sample_shape(x) + self.batch_shape` with values of type\n `self.dtype`.\n \"\"\"\n return self._call_survival_function(value, name)\n\n def _entropy(self):\n raise NotImplementedError(\"entropy is not implemented: {}\".format(\n type(self).__name__))\n\n def entropy(self, name=\"entropy\"):\n \"\"\"Shannon entropy in nats.\"\"\"\n with self._name_scope(name):\n return self._entropy()\n\n def _mean(self):\n raise NotImplementedError(\"mean is not implemented: {}\".format(\n type(self).__name__))\n\n def mean(self, name=\"mean\"):\n \"\"\"Mean.\"\"\"\n with self._name_scope(name):\n return self._mean()\n\n def _quantile(self, value):\n raise NotImplementedError(\"quantile is not implemented: {}\".format(\n type(self).__name__))\n\n def _call_quantile(self, value, name, **kwargs):\n with self._name_scope(name, values=[value]):\n value = ops.convert_to_tensor(value, name=\"value\")\n return self._quantile(value, **kwargs)\n\n def quantile(self, value, name=\"quantile\"):\n \"\"\"Quantile function. Aka \"inverse cdf\" or \"percent point function\".\n\n Given random variable `X` and `p in [0, 1]`, the `quantile` is:\n\n ```none\n quantile(p) := x such that P[X <= x] == p\n ```\n\n Args:\n value: `float` or `double` `Tensor`.\n name: Python `str` prepended to names of ops created by this function.\n\n Returns:\n quantile: a `Tensor` of shape `sample_shape(x) + self.batch_shape` with\n values of type `self.dtype`.\n \"\"\"\n return self._call_quantile(value, name)\n\n def _variance(self):\n raise NotImplementedError(\"variance is not implemented: {}\".format(\n type(self).__name__))\n\n def variance(self, name=\"variance\"):\n \"\"\"Variance.\n\n Variance is defined as,\n\n ```none\n Var = E[(X - E[X])**2]\n ```\n\n where `X` is the random variable associated with this distribution, `E`\n denotes expectation, and `Var.shape = batch_shape + event_shape`.\n\n Args:\n name: Python `str` prepended to names of ops created by this function.\n\n Returns:\n variance: Floating-point `Tensor` with shape identical to\n `batch_shape + event_shape`, i.e., the same shape as `self.mean()`.\n \"\"\"\n with self._name_scope(name):\n try:\n return self._variance()\n except NotImplementedError as original_exception:\n try:\n return math_ops.square(self._stddev())\n except NotImplementedError:\n raise original_exception\n\n def _stddev(self):\n raise NotImplementedError(\"stddev is not implemented: {}\".format(\n type(self).__name__))\n\n def stddev(self, name=\"stddev\"):\n \"\"\"Standard deviation.\n\n Standard deviation is defined as,\n\n ```none\n stddev = E[(X - E[X])**2]**0.5\n ```\n\n where `X` is the random variable associated with this distribution, `E`\n denotes expectation, and `stddev.shape = batch_shape + event_shape`.\n\n Args:\n name: Python `str` prepended to names of ops created by this function.\n\n Returns:\n stddev: Floating-point `Tensor` with shape identical to\n `batch_shape + event_shape`, i.e., the same shape as `self.mean()`.\n \"\"\"\n\n with self._name_scope(name):\n try:\n return self._stddev()\n except NotImplementedError as original_exception:\n try:\n return math_ops.sqrt(self._variance())\n except NotImplementedError:\n raise original_exception\n\n def _covariance(self):\n raise NotImplementedError(\"covariance is not implemented: {}\".format(\n type(self).__name__))\n\n def covariance(self, name=\"covariance\"):\n \"\"\"Covariance.\n\n Covariance is (possibly) defined only for non-scalar-event distributions.\n\n For example, for a length-`k`, vector-valued distribution, it is calculated\n as,\n\n ```none\n Cov[i, j] = Covariance(X_i, X_j) = E[(X_i - E[X_i]) (X_j - E[X_j])]\n ```\n\n where `Cov` is a (batch of) `k x k` matrix, `0 <= (i, j) < k`, and `E`\n denotes expectation.\n\n Alternatively, for non-vector, multivariate distributions (e.g.,\n matrix-valued, Wishart), `Covariance` shall return a (batch of) matrices\n under some vectorization of the events, i.e.,\n\n ```none\n Cov[i, j] = Covariance(Vec(X)_i, Vec(X)_j) = [as above]\n ```\n\n where `Cov` is a (batch of) `k' x k'` matrices,\n `0 <= (i, j) < k' = reduce_prod(event_shape)`, and `Vec` is some function\n mapping indices of this distribution's event dimensions to indices of a\n length-`k'` vector.\n\n Args:\n name: Python `str` prepended to names of ops created by this function.\n\n Returns:\n covariance: Floating-point `Tensor` with shape `[B1, ..., Bn, k', k']`\n where the first `n` dimensions are batch coordinates and\n `k' = reduce_prod(self.event_shape)`.\n \"\"\"\n with self._name_scope(name):\n return self._covariance()\n\n def _mode(self):\n raise NotImplementedError(\"mode is not implemented: {}\".format(\n type(self).__name__))\n\n def mode(self, name=\"mode\"):\n \"\"\"Mode.\"\"\"\n with self._name_scope(name):\n return self._mode()\n\n def _cross_entropy(self, other):\n return kullback_leibler.cross_entropy(\n self, other, allow_nan_stats=self.allow_nan_stats)\n\n def cross_entropy(self, other, name=\"cross_entropy\"):\n \"\"\"Computes the (Shannon) cross entropy.\n\n Denote this distribution (`self`) by `P` and the `other` distribution by\n `Q`. Assuming `P, Q` are absolutely continuous with respect to\n one another and permit densities `p(x) dr(x)` and `q(x) dr(x)`, (Shanon)\n cross entropy is defined as:\n\n ```none\n H[P, Q] = E_p[-log q(X)] = -int_F p(x) log q(x) dr(x)\n ```\n\n where `F` denotes the support of the random variable `X ~ P`.\n\n Args:\n other: `tfp.distributions.Distribution` instance.\n name: Python `str` prepended to names of ops created by this function.\n\n Returns:\n cross_entropy: `self.dtype` `Tensor` with shape `[B1, ..., Bn]`\n representing `n` different calculations of (Shanon) cross entropy.\n \"\"\"\n with self._name_scope(name):\n return self._cross_entropy(other)\n\n def _kl_divergence(self, other):\n return kullback_leibler.kl_divergence(\n self, other, allow_nan_stats=self.allow_nan_stats)\n\n def kl_divergence(self, other, name=\"kl_divergence\"):\n \"\"\"Computes the Kullback--Leibler divergence.\n\n Denote this distribution (`self`) by `p` and the `other` distribution by\n `q`. Assuming `p, q` are absolutely continuous with respect to reference\n measure `r`, the KL divergence is defined as:\n\n ```none\n KL[p, q] = E_p[log(p(X)/q(X))]\n = -int_F p(x) log q(x) dr(x) + int_F p(x) log p(x) dr(x)\n = H[p, q] - H[p]\n ```\n\n where `F` denotes the support of the random variable `X ~ p`, `H[., .]`\n denotes (Shanon) cross entropy, and `H[.]` denotes (Shanon) entropy.\n\n Args:\n other: `tfp.distributions.Distribution` instance.\n name: Python `str` prepended to names of ops created by this function.\n\n Returns:\n kl_divergence: `self.dtype` `Tensor` with shape `[B1, ..., Bn]`\n representing `n` different calculations of the Kullback-Leibler\n divergence.\n \"\"\"\n with self._name_scope(name):\n return self._kl_divergence(other)\n\n def __str__(self):\n return (\"tfp.distributions.{type_name}(\"\n \"\\\"{self_name}\\\"\"\n \"{maybe_batch_shape}\"\n \"{maybe_event_shape}\"\n \", dtype={dtype})\".format(\n type_name=type(self).__name__,\n self_name=self.name,\n maybe_batch_shape=(\", batch_shape={}\".format(self.batch_shape)\n if self.batch_shape.ndims is not None\n else \"\"),\n maybe_event_shape=(\", event_shape={}\".format(self.event_shape)\n if self.event_shape.ndims is not None\n else \"\"),\n dtype=self.dtype.name))\n\n def __repr__(self):\n return (\"\".format(\n type_name=type(self).__name__,\n self_name=self.name,\n batch_shape=self.batch_shape,\n event_shape=self.event_shape,\n dtype=self.dtype.name))\n\n @contextlib.contextmanager\n def _name_scope(self, name=None, values=None):\n \"\"\"Helper function to standardize op scope.\"\"\"\n with ops.name_scope(self.name):\n with ops.name_scope(name, values=(\n ([] if values is None else values) + self._graph_parents)) as scope:\n yield scope\n\n def _expand_sample_shape_to_vector(self, x, name):\n \"\"\"Helper to `sample` which ensures input is 1D.\"\"\"\n x_static_val = tensor_util.constant_value(x)\n if x_static_val is None:\n prod = math_ops.reduce_prod(x)\n else:\n prod = np.prod(x_static_val, dtype=x.dtype.as_numpy_dtype())\n\n ndims = x.get_shape().ndims # != sample_ndims\n if ndims is None:\n # Maybe expand_dims.\n ndims = array_ops.rank(x)\n expanded_shape = util.pick_vector(\n math_ops.equal(ndims, 0),\n np.array([1], dtype=np.int32), array_ops.shape(x))\n x = array_ops.reshape(x, expanded_shape)\n elif ndims == 0:\n # Definitely expand_dims.\n if x_static_val is not None:\n x = ops.convert_to_tensor(\n np.array([x_static_val], dtype=x.dtype.as_numpy_dtype()),\n name=name)\n else:\n x = array_ops.reshape(x, [1])\n elif ndims != 1:\n raise ValueError(\"Input is neither scalar nor vector.\")\n\n return x, prod\n\n def _set_sample_static_shape(self, x, sample_shape):\n \"\"\"Helper to `sample`; sets static shape info.\"\"\"\n # Set shape hints.\n sample_shape = tensor_shape.TensorShape(\n tensor_util.constant_value(sample_shape))\n\n ndims = x.get_shape().ndims\n sample_ndims = sample_shape.ndims\n batch_ndims = self.batch_shape.ndims\n event_ndims = self.event_shape.ndims\n\n # Infer rank(x).\n if (ndims is None and\n sample_ndims is not None and\n batch_ndims is not None and\n event_ndims is not None):\n ndims = sample_ndims + batch_ndims + event_ndims\n x.set_shape([None] * ndims)\n\n # Infer sample shape.\n if ndims is not None and sample_ndims is not None:\n shape = sample_shape.concatenate([None]*(ndims - sample_ndims))\n x.set_shape(x.get_shape().merge_with(shape))\n\n # Infer event shape.\n if ndims is not None and event_ndims is not None:\n shape = tensor_shape.TensorShape(\n [None]*(ndims - event_ndims)).concatenate(self.event_shape)\n x.set_shape(x.get_shape().merge_with(shape))\n\n # Infer batch shape.\n if batch_ndims is not None:\n if ndims is not None:\n if sample_ndims is None and event_ndims is not None:\n sample_ndims = ndims - batch_ndims - event_ndims\n elif event_ndims is None and sample_ndims is not None:\n event_ndims = ndims - batch_ndims - sample_ndims\n if sample_ndims is not None and event_ndims is not None:\n shape = tensor_shape.TensorShape([None]*sample_ndims).concatenate(\n self.batch_shape).concatenate([None]*event_ndims)\n x.set_shape(x.get_shape().merge_with(shape))\n\n return x\n\n def _is_scalar_helper(self, static_shape, dynamic_shape_fn):\n \"\"\"Implementation for `is_scalar_batch` and `is_scalar_event`.\"\"\"\n if static_shape.ndims is not None:\n return static_shape.ndims == 0\n shape = dynamic_shape_fn()\n if (shape.get_shape().ndims is not None and\n shape.get_shape()[0].value is not None):\n # If the static_shape is correctly written then we should never execute\n # this branch. We keep it just in case there's some unimagined corner\n # case.\n return shape.get_shape().as_list() == [0]\n return math_ops.equal(array_ops.shape(shape)[0], 0)\n", "meta": {"hexsha": "76d980679e6bff533eecb60e2ad683b5e0a59975", "size": 45160, "ext": "py", "lang": "Python", "max_stars_repo_path": "tensorflow/python/ops/distributions/distribution.py", "max_stars_repo_name": "hsm207/tensorflow", "max_stars_repo_head_hexsha": "8ab4678ba216c3ec8fa32f417cb667b056689939", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-11-18T01:52:29.000Z", "max_stars_repo_stars_event_max_datetime": "2018-11-18T01:52:29.000Z", "max_issues_repo_path": "tensorflow/python/ops/distributions/distribution.py", "max_issues_repo_name": "hsm207/tensorflow", "max_issues_repo_head_hexsha": "8ab4678ba216c3ec8fa32f417cb667b056689939", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "tensorflow/python/ops/distributions/distribution.py", "max_forks_repo_name": "hsm207/tensorflow", "max_forks_repo_head_hexsha": "8ab4678ba216c3ec8fa32f417cb667b056689939", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2018-12-20T01:35:20.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-10T17:29:57.000Z", "avg_line_length": 35.0893550894, "max_line_length": 158, "alphanum_fraction": 0.6751107174, "include": true, "reason": "import numpy", "num_tokens": 10589, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792044, "lm_q2_score": 0.38861802670584894, "lm_q1q2_score": 0.19734484463400281}} {"text": "#!/usr/bin/env python\n\"\"\"\n# =================================================================================================================== #\n# - Written by Enrico Ciraci - 04/24/2019\n# =================================================================================================================== #\n# - Create Basins Binary Mask given:\n# -\n# - input basin shapefile;\n# - reference lat/lon grid;\n# -\n# =================================================================================================================== #\n# - INPUT PARAMETERS:\n# - \"-S\", \"--basins\" - list of basins to consider passed as csv\n# - (def. 'indus_river', 'lower_indus_river', 'upper_indus_river')\n# - \"-B\", \"--buffer\" - boundary shapefile buffer used in the intersection operation. (def. 0)\n# - \"-N\", \"--nproc\" - number of maximum simultaneous processes (def. 32)\n# =================================================================================================================== #\n# OUTPUTS - (see introduction)\n# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #\n# To Run this procedure digit:\n#\n# python create_basins_mask.py\n# =================================================================================================================== #\n# PYTHON DEPENDENCIES:\n#\tnumpy: Scientific Computing Tools For Python (http://www.numpy.org)\n# netCDF4: python/numpy interface to netCDF library (https://pypi.python.org/pypi/netCDF4)\n# getopt: C-style parser for command line options (https://docs.python.org/2/library/getopt.html)\n# xarray: xarray: N-D labeled arrays and datasets in Python (http://xarray.pydata.org)\n# pyshp: This library reads and writes ESRI Shapefiles in pure Python. (https://github.com/GeospatialPython/pyshp)\n# shapely: Manipulation and analysis of geometric objects in the Cartesian plane. (https://shapely.readthedocs.\n# io/en/stable/manual.html)\n# concurrent.futures: https://docs.python.org/3/library/concurrent.futures.html\n# PROGRAM DEPENDENCIES:\n# enrico_library: https://github.com/uci-gravity/Enrico\n# =================================================================================================================== #\n# - UPDATE - \n# =================================================================================================================== #\n# IMPORTANT:\n# =================================================================================================================== #\n\"\"\"\n# - python dependencies\nfrom __future__ import print_function\nimport os\nimport sys\nimport numpy as np\nimport netCDF4 as nC4\nimport getopt\nimport shapefile\nfrom shapely.geometry import shape, Point, polygon\nfrom concurrent.futures import ThreadPoolExecutor, as_completed\nfrom tqdm import tqdm\nfrom time import time\n\n\ndef write_point_shapefile(output_path_shp, lat_vect, lon_vect, attribute_vect, attribute_name=''):\n \"\"\"\n Save a Point Type esri shapefile with a single attribute per point\n :param output_path_shp: absolute path to the output file\n :param lat_vect: vector containing the latitude points coordinates\n :param lon_vect: vector containing the longitude points coordinates\n :param attribute_vect: vector containing the discharge magnitude\n :param attribute_name: name of the attribute\n :return: \n \"\"\"\n # - python\n w = shapefile.Writer(output_path_shp[:-4], shapeType=1)\n w.autoBalance = 1\n w.field(attribute_name, 'F', 10, 8)\n # -\n for ind in range(0, len(attribute_vect)):\n w.point(np.float(lon_vect[ind]), np.float(lat_vect[ind]))\n w.record(float(attribute_vect[ind]))\n w.close()\n # - create the PRJ file\n with open(output_path_shp[:-3] + 'prj', \"w\") as prj:\n epsg = 'GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563]], ' \\\n 'PRIMEM[\"Greenwich\",0],UNIT[\"degree\",0.0174532925199433]]'\n prj.write(epsg)\n\n\ndef verify_and_create_dir(abs_path, dir_name):\n \"\"\"\n Create directory\n :param abs_path:absolute path to the output directory\n :param dir_name: new directory name\n :return: path to the new directory\n \"\"\"\n directory = os.path.join(abs_path, dir_name)\n\n if not os.path.exists(directory):\n os.mkdir(directory)\n # -\n return directory\n\n\ndef calculate_area_mask_vect(lat_vect, lon_vect):\n \"\"\"\n Calculate Latitude/Longitude Area mask at a selected degree resolution grid\n defined employing the input latitude and longitude vector.\n :param lat_vect: latitude vector\n :param lon_vect: latitude vector\n :return: Area Mask - Expressed in cm2\n \"\"\"\n # - General Parameters\n dtr = np.pi / 180. # - Coefficient for the deg to radiant conversion\n rad_e = 6.371e8 # - Earth Radius in cm\n out_lat = lat_vect\n out_lon = lon_vect\n resolution_lat = np.abs(lat_vect[1] - lat_vect[0])\n resolution_lon = np.abs(lon_vect[1] - lon_vect[0])\n area0 = resolution_lat * resolution_lon * dtr * dtr # - Area of a single point mass\n out_lat_grid, out_lon_grid = np.meshgrid(out_lat, out_lon)\n # - output area mask\n radius = np.sqrt(area0 * np.cos(out_lat_grid * dtr) / np.pi) * rad_e\n out_mask = np.pi * (radius ** 2) # - Circular Area in cm^2\n # -\n return out_mask\n\n\ndef from_shp_to_polygon(path_to_shape, buffer_p=0.5):\n \"\"\"\n Read the input shapefile and return a list of polygon objects\n :param path_to_shape: absolute path to the input shapefile\n :param buffer_p: boundary buffer in degree\n :return:\n \"\"\"\n # - open the shapefile using the python fiona package\n region_list = list()\n # - read the input regional shapefile\n pol = shapefile.Reader(path_to_shape)\n # - extract polygon-shapes\n sub = pol.shapes()\n # - Build the regional ice-covered region domain\n for ss in range(0, len(sub)):\n if len(sub[ss].parts) > 1:\n # - the shapefile is composed by multiple parts defining an external ring and one ore more\n # - interior holes\n limits = sub[ss].parts\n holes = [] # - holes boundaries\n for x in range(2, len(limits)):\n holes.append(sub[ss].points[limits[x - 1]:limits[x]])\n # - define polygon with holes\n shp_tmp = polygon.Polygon(sub[ss].points[limits[0]:limits[1]], holes)\n else:\n # - polygon composed only by an external ring\n shp_tmp = shape(sub[ss]).buffer(buffer_p)\n\n region_list.append(shp_tmp)\n # -\n return region_list\n\n\ndef write_netcdf_mask(binary_mask, area_mask, lat, lon, file_to_save):\n \"\"\"\n Write spatial field in a netcdf archive\n :param binary_mask: input binary mask\n :param area_mask: regional area mask in cm2\n :param lat: latitude axis\n :param lon: longitude axis\n :param file_to_save: absolute path to the output fi;e\n :return:\n \"\"\"\n # - Writing the Output file\n rootgrp = nC4.Dataset(file_to_save, mode='w', format='NETCDF4')\n # - Create Variable dimensions\n rootgrp.createDimension('lat', len(lat))\n rootgrp.createDimension('lon', len(lon))\n # - Create output variables:\n var_lat = rootgrp.createVariable('lat', 'f4', 'lat')\n var_lon = rootgrp.createVariable('lon', 'f4', 'lon')\n var_mask = rootgrp.createVariable('area', 'f8', ('lat', 'lon'))\n var_mask_binary = rootgrp.createVariable('binary', 'f8', ('lat', 'lon'))\n\n # - Longitude attributes\n var_lon.units = 'degree east'\n var_lon.long_name = 'Longitude'\n var_lon.actual_range = [np.min(lon), np.max(lon)]\n var_lon.standard_name = 'longitude'\n var_lon.axis = 'X'\n var_lon.coordinate_defines = 'point'\n # - Latitude Attributes\n var_lat.units = 'degree north'\n var_lat.long_name = 'Latitude'\n var_lat.actual_range = [np.min(lat), np.max(lat)]\n var_lat.standard_name = 'latitude'\n var_lat.axis = 'Y'\n var_lat.coordinate_defines = 'point'\n # - Mask Attributes\n var_mask.units = 'cm2'\n var_mask.var_desc = 'Basin Area Mask'\n var_mask.actual_range = [np.min(area_mask), np.max(area_mask)]\n # - Binary Mask Attributes\n var_mask_binary.units = ''\n var_mask_binary.var_desc = 'basin binary mask'\n var_mask_binary.actual_range = [np.min(binary_mask), np.max(binary_mask)]\n\n var_lon[:] = lon\n var_lat[:] = lat\n var_mask[:, :] = area_mask\n var_mask_binary[:, :] = binary_mask\n # - close the netcdf file created\n rootgrp.close()\n\n\ndef parallel_code(data_dict):\n \"\"\"\n Contains the portion of the code that is executed in parallel\n :param data_dict: python dictionary containing the input parameters\n :return:\n \"\"\"\n lon_s = data_dict['lon_s']\n lat_s = data_dict['lat_s']\n xy_point = Point(lon_s, lat_s)\n region_list = data_dict['rl']\n out_index = -9999.\n for rl in region_list:\n if xy_point.within(rl):\n out_index = data_dict['index']\n break\n return out_index\n\n\ndef main():\n \"\"\"\n Main Section of the script.\n :return:\n \"\"\"\n # -- Read the system arguments listed after the program and run the program\n long_options = ['basins=', 'buffer=', 'nproc=']\n try:\n optlist = getopt.getopt(sys.argv[1:], 'S:B:N:', long_options)\n except ValueError:\n optlist = list()\n\n # - list of the river basin to consider\n basin_list = ['indus_river']\n # - uses by default a number of simultaneous processes equal to the number of CPUs\n max_processes = None\n # - basin boundaries buffer\n buffer_p = 0.\n try:\n for opt, arg in optlist[0]:\n if opt in (\"-S\", \"--basins\"):\n # - list of the basins to process\n # - passed as csv\n basin_list = arg.split(',')\n elif opt in (\"-B\", \"--buffer\"):\n # - Basin boundary buffer\n buffer_p = float(arg)\n elif opt in (\"-N\", \"--nproc\"):\n # - number of simultaneous processes\n max_processes = int(arg)\n except ValueError:\n pass\n start = time()\n \n # - input/output data directory\n input_dir = os.path.join('.', 'input')\n output_dir = verify_and_create_dir('.', 'output')\n\n # - lat/lon arrays\n lat_vect = np.arange(-90, 90+1, 1)\n lon_vect = np.arange(-180, 180+1, 1)\n # - create lat lon domain grid\n l_lon, l_lat = np.meshgrid(lon_vect, lat_vect)\n l_lon_vect = l_lon.flatten()\n l_lat_vect = l_lat.flatten()\n\n # - calculate a global area mask in cm2 ad the model resolution\n area_mask = np.transpose(calculate_area_mask_vect(lat_vect, lon_vect))\n\n # - crop the model mask using the selected river mask\n if basin_list:\n print('# - Create Basins Mask.')\n for basin in basin_list:\n print('# - ' + basin)\n # - load basin mask\n b_info = dict()\n b_info['basin_boundary'] = os.path.join(input_dir, basin, basin+'.shp')\n out_dir_reg = verify_and_create_dir(output_dir, basin)\n # - read regional shapefile and convert it to a shapely polygon object\n region_list = from_shp_to_polygon(b_info['basin_boundary'], buffer_p=buffer_p)\n # - list that will contain the indexes of the points within the region of interest\n tot_ind = list()\n # - parallel portion of the code\n processes = []\n with ThreadPoolExecutor(max_workers=max_processes) as executor:\n for ll in tqdm(range(0, len(l_lon_vect)), ncols=50):\n lon_s = l_lon_vect[ll]\n lat_s = l_lat_vect[ll]\n # -\n data_dict = dict()\n data_dict['lon_s'] = lon_s\n data_dict['lat_s'] = lat_s\n data_dict['index'] = ll\n data_dict['rl'] = region_list\n processes.append(executor.submit(parallel_code, data_dict))\n\n for res in as_completed(processes):\n res_out = res.result()\n if res_out != -9999.:\n tot_ind.append(res_out)\n # - Save the obtained mask\n out_lat = np.array(l_lat_vect)[tot_ind]\n out_lon = np.array(l_lon_vect)[tot_ind]\n id_y = np.arange(len(out_lon)) + 1\n output_path_shp = os.path.join(out_dir_reg, basin + '.shp')\n write_point_shapefile(output_path_shp, out_lat, out_lon, id_y, attribute_name='id')\n\n # - Save the mask also in netcdf format\n binary_mask = np.zeros(np.shape(l_lon))\n # - fill the binary mask\n for k in range(0, len(out_lat)):\n binary_mask[np.where(lat_vect == out_lat[k]), np.where(lon_vect == out_lon[k])] = 1.\n output_path_shp = os.path.join(out_dir_reg, basin + '.nc')\n write_netcdf_mask(binary_mask, area_mask*binary_mask, lat_vect, lon_vect, output_path_shp)\n\n end = time()\n hours, rem = divmod(end - start, 3600)\n minutes, seconds = divmod(rem, 60)\n print(f'Execution Time: ' + \"{:0>2}:{:0>2}:{:05.2f}\".format(int(hours), int(minutes), seconds))\n\n\n# -- run main program\nif __name__ == '__main__':\n main()\n", "meta": {"hexsha": "44fa2f49b6d563808e8b4ce11d0ca4a48e2a3301", "size": 13205, "ext": "py", "lang": "Python", "max_stars_repo_path": "read_gridded_latlon_data/create_basins_mask.py", "max_stars_repo_name": "eciraci/Geophysics", "max_stars_repo_head_hexsha": "6e216e78e09157769d6192f0ed8c5981be128a02", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "read_gridded_latlon_data/create_basins_mask.py", "max_issues_repo_name": "eciraci/Geophysics", "max_issues_repo_head_hexsha": "6e216e78e09157769d6192f0ed8c5981be128a02", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "read_gridded_latlon_data/create_basins_mask.py", "max_forks_repo_name": "eciraci/Geophysics", "max_forks_repo_head_hexsha": "6e216e78e09157769d6192f0ed8c5981be128a02", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.3822629969, "max_line_length": 119, "alphanum_fraction": 0.5824308974, "include": true, "reason": "import numpy", "num_tokens": 3176, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792044, "lm_q2_score": 0.3886180267058489, "lm_q1q2_score": 0.1973448446340028}} {"text": "# Copyright (C) 2013 Lindley Graham\n\n\"\"\"\nThis module contains a set of methods and a class for interacting with NCSU\nSubdomain Modeling Python code and associated files. The focus of this module\nis the :class:`subdomain`.\n\"\"\"\n\nimport glob, os, sys, subprocess, re, math \nimport numpy as np\nimport scipy.io as sio\nimport py.gensub as gensub \nimport polyadcirc.run_framework.domain as dom\nimport polyadcirc.pyADCIRC.fort15_management as f15\nimport polyadcirc.pyADCIRC.fort13_management as f13\nimport polyadcirc.pyADCIRC.output as output\nimport polyadcirc.run_framework.random_manningsn as rmn\nimport polyadcirc.pyADCIRC.post_management as post\nimport polyadcirc.pyGriddata.file_management as fm\nfrom polyadcirc.pyADCIRC.basic import comm\n\ndef loadmat(save_file, base_dir, grid_dir, save_dir, basis_dir):\n \"\"\"\n Loads data from ``save_file`` into a\n :class:`~polyadcirc.run_framwork.random_manningsn.runSet` object.\n Reconstructs :class:`~polyadcirc.run_framwork.random_manningsn.subdomain`. \n\n :param string save_file: local file name\n :param string grid_dir: directory containing ``fort.14``, ``fort.15``, and\n ``fort.22`` \n :param string save_dir: directory where ``RF_directory_*`` are\n saved, and where fort.13 is located \n :param string basis_dir: directory where ``landuse_*`` folders are located\n :param string base_dir: directory that contains ADCIRC executables, and\n machine specific ``in.prep#`` files \n :rtype: tuple of :class:`~polyadcirc.run_framwork.random_manningsn.runSet`\n and :class:`~polyadcirc.run_framwork.random_manningsn.domain` objects\n :returns: (main_run, domain)\n\n \"\"\"\n \n # the lines below are only necessary if you need to update what the\n # directories are when swithcing from euclid to your desktop/laptop\n # assumes that the landuse directory and ADCIRC_landuse directory are in\n # the same directory\n domain = subdomain(grid_dir)\n domain.update()\n domain.get_Triangulation()\n #domain.set_station_bathymetry()\n\n main_run = rmn.runSet(grid_dir, save_dir, basis_dir, base_dir=base_dir)\n main_run.ts_error = {}\n main_run.nts_error = {}\n main_run.time_obs = {}\n\n # load the data from at *.mat file\n mdat = sio.loadmat(os.path.join(save_dir, save_file))\n\n for k, v in mdat.iteritems():\n skey = k.split('_')\n if skey[-1] == 'time':\n # check to see if the key is \"*_time\"\n main_run.time_obs[skey[0]] = v\n elif f15.filetype.has_key(skey[0]):\n if not re.match('fort', skey[0]):\n # check to see if key is nts_data\n main_run.nts_error[skey[0]] = v\n else:\n # check to see if key is ts_data\n main_run.ts_error[skey[0]] = v\n #print k, v\n \n return (main_run, domain)\n\nclass subdomain(dom.domain):\n \"\"\"\n Objects of this class contain all the data needed by :mod:`py.genbcs`,\n :mod:`py.genfull`, and :mod:`py.gensub` for a particular subdomain\n mesh/grid. References to :class:`polyadcirc.run_framework.subdomain` objects\n are also contained in an instantiation of this class.\n \"\"\"\n def __init__(self, path, node_num=0, element_num=0,\n node=None, element=None):\n \"\"\"\n Initialization\n \"\"\"\n super(subdomain, self).__init__(path, node_num, element_num, node,\n element)\n\n # figure out where the script dir for the ncsu subdomain code is\n for sys_path in sys.path:\n potential_file_list = glob.glob(os.path.join(sys_path, 'py'))\n if potential_file_list:\n self.script_dir = potential_file_list[0]\n break\n\n fm.mkdir(path)\n\n #: flag for shape of subdomain (0 ellipse, 1 circle)\n self.flag = None\n\n def set_fulldomain(self, fulldomain):\n \"\"\"\n Sets the fulldomain of this subdomain to fulldomain and adds this\n subdomain to that fulldomain.\n\n :type fulldomain: :class:`~polyadcirc.run_framework.fulldomain`\n :param fulldomain: the fulldomain for this subdomain\n\n \"\"\"\n self.fulldomain = fulldomain\n self.fulldomain.subdomains.append(self)\n\n def gensub(self, bound_ele=1, bound_vel=1, bound_wd=1, winddir=None):\n \"\"\"\n Generate the subdomain input files (``fort.13``, ``fort.14``,\n ``fort.015``, ``py.141``, ``py.140``) and shape file. Creates\n ``fort.15`` based on the ``fort.15`` in\n :class:`polyadcirc.run_framework.fulldomain` to ``self.path``, and\n creates symbolic links to meterological forcing files (``fort.22*``).\n \n :param int bound_ele: a flag determining whether surface elevations of\n the boundary nodes of a subdomain are enforced using a boundary\n condition file.\n :param int bound_vel: a flag determining whether velocities of\n the boundary nodes of a subdomain are enforced using a boundary\n condition file.\n :param int bound_wd: a flag determining whether wet/dry status of\n the boundary nodes of a subdomain are enforced using a boundary\n condition file.\n :rtype: string\n :returns: command line for invoking gensub.py\n\n \"\"\"\n with open(os.path.join(self.path, 'gensub.in'), 'w') as fid:\n fid.write(str(bound_ele)+'\\n')\n fid.write(str(bound_vel)+'\\n')\n fid.write(str(bound_wd)+'\\n')\n command = 'python '+os.path.join(self.script_dir, 'gensub.py')+' '\n command += os.path.join(self.fulldomain.path, 'fort.14')\n command += ' '+str(self.flag)+' fort.14 '\n \n if os.path.exists(os.path.join(self.fulldomain.path, 'fort.13')):\n command += os.path.join(self.fulldomain.path, 'fort.13')+' '\n command += 'fort.13 ' \n \n command += '< gensub.in'\n subprocess.call(command, shell=True, cwd=self.path)\n\n #self.update_sub2full_map()\n self.create_fort15()\n self.link_fort22(winddir)\n return command\n\n def link_fort22(self, fdir=None):\n \"\"\"\n Create symboolic links to ``fort.22*`` meterological files in this\n subdomain folder from the fulldomain folder.\n \"\"\"\n if fdir is None:\n fdir = self.fulldomain.path\n fort22_files = glob.glob(os.path.join(fdir, 'fort.22*'))\n for fid in fort22_files:\n fm.symlink(fid, os.path.join(self.path, fid.rpartition('/')[-1]))\n\n def genfull(self, noutgs=1, nspoolgs=1):\n \"\"\" \n Generate the full domain control file, ``fort.015``, and save it to\n ``self.fulldomain.path``.\n\n :param int noutgs: flag controlling whether or not ``fort.06*`` will be\n written out \n :param int nspoolgs: the number of timesteps at which information is\n written to the new output files ``fort.06*``\n :rtype: string\n :returns: command line for invoking genfull.py\n \n \"\"\"\n return self.fulldomain.genfull(noutgs, nspoolgs, [self])\n\n def genbcs(self, forcing_freq=1, dt=None, nspoolgs=1, h0=None, L=False):\n \"\"\"\n Generate the ``fort.019`` which is the boundary conditions file needed\n for a subdomain run of :program:`ADCIRC`. This requires the presence of\n the output files from a fulldomain run, ``fort.06*``.\n\n :param int forcing_freq: number of timesteps at which infomration\n is written to a boudnary conditions file (``fort.019``) THIS MUST\n BE A MULTIPLE OF NSPOOLGS\n :param float dt: One timestep in seconds\n :param int nspoolgs: the number of timesteps at which information is\n written to the new output files ``fort.06*``\n :param float h0: minimum water depth for a node to be wet\n :param bool L: flag whether or not :program:`PADCIRC` was run with\n ``-L`` flag and if local files need to be post-processed into\n global files\n :rtype: string\n :returns: command line for invoking genbcs.py\n\n \"\"\"\n if L:\n # create post-processing input file\n post.write_sub(self.fulldomain.path)\n # run ADCPOST\n subprocess.call('./adcpost < in.postsub > post_o.txt', shell=True,\n cwd=self.fulldomain.path)\n \n self.create_fort15()\n self.link_fort22()\n self.read_recording_data()\n\n if self.check_fulldomain():\n if h0 is None:\n h0 = self.h0\n if dt is None:\n dt = self.fulldomain.time.dt\n command = \"python \"+self.script_dir+\"/genbcs.py -p \"\n command += self.fulldomain.path+'/ '+self.path+'/ '\n command += str(forcing_freq)+' '+str(dt)+' '+str(nspoolgs)\n command += ' '+str(h0)\n print command\n subprocess.call(command, shell=True, cwd=self.path)\n return command\n else:\n print \"Output files from the fulldomain run do not exist\"\n return \"Output files from the fulldomain run do not exist\"\n\n def circle(self, x, y, r):\n \"\"\"\n Generate a subdomain shape file for a circular subdomain\n\n :param float x: x coordinate of circle center\n :param float y: y coordinate of circle center\n :param float r: radius of circle\n :rtype: int\n :returns: flag for :meth:`py.gensub`\n\n \"\"\"\n with open(os.path.join(self.path, 'shape.c14'), 'w') as fid:\n fid.write('{:17.15f} {:17.15f}\\n'.format(x, y))\n fid.write(str(r))\n self.flag = 1\n return self.flag\n\n def ellipse(self, x, y, w):\n \"\"\"\n Generate a subdomain shape file for an elliptical subdomain\n \n :param list x: x coordinates of the first and second focal points\n :param list y: y coordinates of the first and second focal points\n :param float w: width of ellipse\n :rtype: int\n :returns: flag for :meth:`py.gensub`\n\n \"\"\"\n with open(os.path.join(self.path, 'shape.e14'), 'w') as fid:\n fid.write('{:17.15f} {:17.15f}\\n'.format(x[0], y[0]))\n fid.write('{:17.15f} {:17.15f}\\n'.format(x[1], y[1]))\n fid.write(str(w))\n self.flag = 0\n return self.flag\n\n def read_circle(self):\n \"\"\"\n Read in the parameters used to define the circular subdomain cut out and\n store them as ``self.x``, ``self.y``, and ``self.r``\n\n :rtype: tuple\n :returns: (x, y, r)\n\n \"\"\"\n with open(os.path.join(self.path, \"shape.c14\"), \"r\") as fid:\n t = fid.readline().split()\n x = float(t[0])\n y = float(t[1])\n r = float(fid.readline())\n\n self.x = x\n self.y = y\n self.r = r\n return (x, y, r)\n\n def read_ellipse(self):\n \"\"\"\n Read in the parameters used to define the circular subdomain cut out and\n store them as ``self.x``, ``self.y``, and ``self.r``\n\n :rtype: tuple\n :returns: (x, y, w)\n\n \"\"\"\n\n with open(os.path.join(self.path, \"shape.e14\"), \"r\") as fid:\n point1 = fid.readline().split()\n point2 = fid.readline().split()\n x = [float(point1[0]), float(point2[0])]\n y = [float(point1[1]), float(point2[1])]\n w = float(fid.readline())\n self.x = x\n self.y = y\n self.w = w\n return (x, y, w)\n\n def ellipse_properties(self, x, y, w):\n \"\"\"\n Given a the (x,y) locations of the foci of the ellipse and the width\n return the center of the ellipse, width, height, and angle relative to\n the x-axis.\n\n :param double x: x-coordinates of the foci\n :param double y: y-coordinates of the foci\n :param double w: width of the ellipse\n :rtype: tuple of doubles\n :returns: (center_coordinates, width, height, angle_in_rads)\n\n \"\"\"\n return ellipse_properties(x, y, w)\n\n def setup(self, flag=None, bound_ele=1, bound_vel=1, bound_wd=1,\n winddir=None):\n \"\"\"\n Generate the subdomain input files (``fort.13``, ``fort.14``,\n ``fort.015``, ``py.141``, ``py.140``) and shape file. Creates\n ``fort.15`` based on the ``fort.15`` in\n :class:`polyadcirc.run_framework.fulldomain` to ``self.path``, and\n creates symbolic links to meterological forcing files (``fort.22*``).\n \n :param int flag: flag determining whether or not the subdomain is an\n ellipse (0) or a circle (1)\n :param int bound_ele: a flag determining whether surface elevations of\n the boundary nodes of a subdomain are enforced using a boundary\n condition file.\n :param int bound_vel: a flag determining whether velocities of\n the boundary nodes of a subdomain are enforced using a boundary\n condition file.\n :param int bound_wd: a flag determining whether wet/dry status of\n the boundary nodes of a subdomain are enforced using a boundary\n condition file.\n :rtype: string\n :returns: command line for invoking gensub.py\n\n \"\"\"\n # Appropriately flag subdomain\n if flag is None and self.flag is None:\n circle = glob.glob(os.path.join(self.path, 'shape.c14'))\n if len(circle) > 0:\n self.flag = 1\n ellipse = glob.glob(os.path.join(self.path, 'shape.e14'))\n if len(ellipse) > 0:\n self.flag = 0\n elif flag != None:\n self.flag = flag #: flag for :meth:`py.gensub`\n # Get rid of old files\n f_list = ['fort.015', 'fort.13', 'fort.14', 'bv.nodes', 'py.140',\n 'py.141']\n for fid in f_list:\n if os.path.exists(os.path.join(self.path, fid)):\n os.remove(os.path.join(self.path, fid))\n return self.gensub(bound_ele, bound_vel, bound_wd, winddir)\n \n def check_fulldomain(self):\n \"\"\"\n Check to see if the ``fort.06*`` and ``PE*/fort.065`` files exist\n\n :rtype: bool\n :returns: False if the ``fort.06*`` files don't exist\n \n \"\"\"\n return self.fulldomain.check_fulldomain()\n\n def check(self):\n \"\"\"\n Check to make sure the ``fort.019`` file exists\n\n :rtype: bool\n :returns: False the ``fort.019`` doesn't exist\n\n \"\"\"\n fort019 = glob.glob(os.path.join(self.path, 'fort.019'))\n return len(fort019) > 0\n\n def compare_runSet(self, ts_data, nts_data, ts_names=None, \n nts_names=None, save_file=None): \n \"\"\"\n Reads in :class:`polyadcirc.random_manningsn.runSet` output from this\n subdomain and from it's fulldomain and compares them.\n\n NOTE THIS DOES NOT CURRENTLY WORK FOR STATION DATA! ONLY USE FOR GLOBAL\n DATA i.e files that are fort.*3 or fort.*4\n\n comparision_data = fulldomain_data - subdomain_data\n \n :param list ts_data: (ts_data_subdomain, ts_data_fulldomain)\n :param list nts_data: (nts_data_subdomain, nts_data_fulldomain)\n :param list ts_names: names of ADCIRC timeseries\n output files to be recorded from each run\n :param list nts_names: names of ADCIRC non timeseries\n output files to be recorded from each run\n :param string save_file: name of file to save comparision matricies to\n :rtype: tuple\n :returns: (ts_error, nts_error)\n\n \"\"\"\n \n if save_file is None:\n save_file = os.path.join(self.path, 'compare_s2f_runSet.mat')\n\n nts_keys = []\n if nts_names is None:\n nts_keys = nts_data[0].keys()\n else:\n for fid in nts_names:\n nts_keys.append(fid.replace('.', ''))\n\n ts_keys = []\n if ts_names is None:\n ts_keys = ts_data[0].keys()\n else:\n for fid in ts_names:\n ts_keys.append(fid.replace('.', ''))\n\n # Save matricies to *.mat file for use by MATLAB or Python\n mdict = dict()\n\n # Pre-allocate arrays for non-timeseries data\n nts_error = {}\n ts_error = {}\n\n fulldom_nodes = [v-1 for v in self.sub2full_node.values()]\n\n # Get nts_error\n for key in nts_keys:\n full_data = nts_data[1][key][fulldom_nodes]\n sub_data = nts_data[0][key]\n nts_error[key] = (full_data - sub_data)#/full_data\n\n # fix dry nodes\n if 'fort63' in ts_keys:\n ts_data[0] = rmn.fix_dry_nodes(ts_data[0], self)\n ts_data[1] = rmn.fix_dry_nodes(ts_data[1], self)\n\n # fix dry data\n if 'fort61' in ts_keys:\n self.set_station_bathymetry()\n ts_data[0] = rmn.fix_dry_data(ts_data[0], self)\n ts_data[1] = rmn.fix_dry_data(ts_data[1], self)\n\n # Get ts_data\n for key in ts_keys:\n # Theres a bug wrt stations here either we need a mapping between\n # fulldomain stations and subdomain stations or these stations MUST\n # be the same.\n if key == 'fort61' or key == 'fort62':\n continue\n sub_data = ts_data[0][key]\n total_obs = sub_data.shape[1]\n if self.recording[key][2] == 1:\n full_data = ts_data[1][key][fulldom_nodes, 0:total_obs]\n else:\n full_data = ts_data[1][key][fulldom_nodes, 0:total_obs, :]\n ts_error[key] = (full_data - sub_data)#/full_data\n\n # Update and save\n # export nontimeseries data\n for k, v in nts_error.iteritems():\n mdict[k] = v\n print k\n b = np.ma.fix_invalid(v, fill_value=0)\n print np.max(abs(b)), np.argmax(abs(b))\n # export timeseries data\n for k, v in ts_error.iteritems():\n mdict[k] = v\n print k\n b = np.ma.fix_invalid(v, fill_value=0)\n print np.max(abs(b)), np.argmax(abs(b))\n\n sio.savemat(save_file, mdict, do_compression=True)\n return (ts_error, nts_error)\n \n def compare_to_fulldomain(self, ts_names, nts_names, save_file=None,\n timesteps=None, savefull=True, readmatfull=False,\n savesub=True, readmatsub=False, fulldict=None):\n \"\"\"\n Reads in output files from this subdomain and from it's fulldomain and\n compares them.\n\n NOTE THIS DOES NOT CURRENTLY WORK FOR STATION DATA! ONLY USE FOR GLOBAL\n DATA i.e files that are fort.*3 or fort.*4\n\n NOTE THIS DOES NOT CURRENTLY WORK FOR ANY NTS DATA EXCEPT FOR MAXELE\n\n comparision_data = fulldomain_data - subdomain_data\n\n :param list ts_names: names of ADCIRC timeseries\n output files to be recorded from each run\n :param list nts_names: names of ADCIRC non timeseries\n output files to be recorded from each run\n :param string save_file: name of file to save comparision matricies to\n :param int timesteps: number of timesteps to read from file\n :rtype: tuple\n :returns: (ts_error, nts_error, time_obs, ts_data, nts_data)\n\n \"\"\"\n \n if save_file is None:\n save_file = os.path.join(self.path, 'compare_s2f.mat')\n\n full_file = os.path.join(self.fulldomain.path, 'full.mat')\n sub_file = os.path.join(self.path, 'sub.mat')\n\n # Save matricies to *.mat file for use by MATLAB or Python\n mdict = dict()\n if readmatsub:\n subdict = sio.loadmat(sub_file)\n savesub = False\n else:\n subdict = dict()\n\n if fulldict is None:\n if readmatfull:\n fulldict = sio.loadmat(full_file)\n savefull = False\n else:\n fulldict = dict()\n else:\n readmatfull = True\n savefull = False\n\n # Pre-allocate arrays for non-timeseries data\n nts_error = {}\n ts_error = {}\n time_obs = {}\n\n fulldom_nodes = [v-1 for v in self.sub2full_node.values()]\n\n # Get nts_data\n for fid in nts_names:\n key = fid.replace('.', '')\n if not readmatfull:\n fulldict[key] = output.get_nts_sr(self.fulldomain.path,\n self.fulldomain, fid)\n if not readmatsub:\n subdict[key] = output.get_nts_sr(self.path, self, fid)\n\n # Get ts_data\n for fid in ts_names:\n key = fid.replace('.', '')\n if not readmatsub:\n subdict[key], time_obs[key] = output.get_ts_sr(self.path, fid,\n True,\n ihot=self.ihot) \n subdict[key+'_time'] = time_obs[key]\n if not readmatfull:\n fulldict[key] = output.get_ts_sr(self.fulldomain.path,\n fid, timesteps=timesteps,\n ihot=self.fulldomain.ihot)[0]\n \n if not readmatsub:\n # fix dry nodes\n if subdict.has_key('fort63'):\n subdict['fort63'] = np.expand_dims(subdict['fort63'], axis=2)\n subdict = rmn.fix_dry_nodes(subdict, self)\n subdict['fort63'] = np.squeeze(subdict['fort63'])\n # fix dry data\n if subdict.has_key('fort61'):\n subdict['fort61'] = np.expand_dims(subdict['fort61'], axis=1)\n subdict = rmn.fix_dry_data(subdict, self)\n subdict['fort61'] = np.squeeze(subdict['fort61'])\n # fix dry nodes nts\n if subdict.has_key('maxele63'):\n subdict['maxele63'] = np.expand_dims(subdict['maxele63'],\n axis=1) \n subdict = rmn.fix_dry_nodes_nts(subdict, self)\n subdict['maxele63'] = np.squeeze(subdict['maxele63'])\n\n\n if not readmatfull:\n # fix dry nodes\n if fulldict.has_key('fort63'):\n fulldict['fort63'] = np.expand_dims(fulldict['fort63'], axis=2)\n fulldict = rmn.fix_dry_nodes(fulldict, self)\n fulldict['fort63'] = np.squeeze(fulldict['fort63'])\n # fix dry data\n if fulldict.has_key('fort61'):\n fulldict['fort61'] = np.expand_dims(fulldict['fort61'], axis=1)\n fulldict = rmn.fix_dry_data(fulldict, self)\n fulldict['fort61'] = np.squeeze(fulldict['fort61'])\n # fix dry nodes nts\n if fulldict.has_key('maxele63'):\n fulldict['maxele63'] = np.expand_dims(fulldict['maxele63'], \n axis=1)\n fulldict = rmn.fix_dry_nodes_nts(fulldict, self)\n fulldict['maxele63'] = np.squeeze(fulldict['maxele63'])\n \n # Get ts_error\n for fid in ts_names:\n key = fid.replace('.', '')\n sub_data, time_obs[key] = subdict[key], subdict[key+'_time']\n total_obs = sub_data.shape[1]\n if timesteps and timesteps < total_obs:\n total_obs = timesteps\n full_data = fulldict[key]\n if self.recording[key][2] == 1:\n full_data = full_data[fulldom_nodes, 0:total_obs] \n else:\n full_data = full_data[fulldom_nodes, 0:total_obs, :]\n ts_error[key] = (full_data - sub_data)\n if key == 'fort63' and (subdict.has_key('maxele63') or\\\n subdict.has_key('maxele.63')):\n nts_error['maxele63'] = np.max(full_data,\n axis=1) - subdict['maxele63']\n if key == 'fort64' and (subdict.has_key('maxvel63') or\\\n subdict.has_key('maxvel.63')):\n nts_error['maxvel63'] = np.max(np.sqrt(full_data[:, :, 0]**2 +\n full_data[:, :, 1]**2), \n axis=1) - subdict['maxvel63']\n \n # Get nts_error\n for fid in nts_names:\n key = fid.replace('.', '')\n if key != 'maxele63' and key != 'maxevel63':\n nts_error[key] = fulldict[key][fulldom_nodes] - subdict[key]\n \n # Update and save\n # export nontimeseries data\n for k, v in nts_error.iteritems():\n mdict[k] = v\n print k\n #b = np.ma.fix_invalid(v, fill_value=0)\n b = v\n print np.max(abs(b)), np.argmax(abs(b))\n print \"Nodes above threshold\", sum(np.abs(b) > 1e-2)\n # export timeseries data\n for k, v in ts_error.iteritems():\n mdict[k] = v\n print k\n #b = np.ma.fix_invalid(v, fill_value=0)\n b = v\n print np.max(abs(b)), np.argmax(abs(b))\n print \"Nodes above threshold\", sum(np.abs(b) > 1e-2)\n\n # export time_obs data\n for k, v in time_obs.iteritems():\n mdict[k+'_time'] = v\n\n sio.savemat(save_file, mdict, do_compression=True)\n if savesub:\n sio.savemat(sub_file, subdict, do_compression=True)\n if savefull:\n sio.savemat(full_file, fulldict, do_compression=True)\n\n return (ts_error, nts_error, time_obs, None, None)\n\n def create_fort15(self):\n \"\"\"\n Copy the ``fort.15`` from ``fulldomain.path`` to ``self.path`` and\n modify for a subdomain run.\n\n .. seealso:: :meth:`polyadcirc.pyADCIRC.fort15_management.subdomain`\n \"\"\"\n\n f15.subdomain(self.fulldomain.path, self.path)\n\n def read_py_node(self):\n \"\"\"\n Read in the subdomain to fulldomain node map\n \n Store as ::\n \n self.sub2full_node = dict()\n \n where key = subdomain node #, value = fulldomain node #\n \"\"\"\n self.sub2full_node = {}\n with open(os.path.join(self.path, 'py.140'), 'r') as fid:\n fid.readline() # skip header\n for line in fid:\n k, v = np.fromstring(line, dtype=int, sep=' ')\n self.sub2full_node[k] = v\n\n def read_py_ele(self):\n \"\"\"\n Read in the subdomain to fulldomain element map\n \n Store as ::\n \n self.sub2full_element = dict()\n \n where key = subdomain element #, value = fulldomain element #\n \"\"\"\n self.sub2full_element = {}\n with open(os.path.join(self.path, 'py.141'), 'r') as fid:\n fid.readline() # skip header\n for line in fid:\n k, v = np.fromstring(line, dtype=int, sep=' ')\n self.sub2full_element[k] = v\n\n def read_bv_nodes(self):\n \"\"\"\n Read in the nodes on the boundary and store in ``self.bv_nodes`` as a\n list.\n\n :rtype: list\n :returns: list of boundary nodes\n \"\"\"\n self.bv_nodes = []\n with open(os.path.join(self.path, 'bv.nodes'), 'r') as fid:\n for line in fid:\n self.bv_nodes.append(int(np.fromstring(line, sep=' ')[0]))\n return self.bv_nodes\n\n def update_sub2full_map(self):\n \"\"\"\n Read in the subdomain to fulldomain element and node maps\n \"\"\"\n #: dict where key = subdomain node #, value = fulldomain node #\n self.read_py_node()\n #: dict where key = subdomain element #, value = fulldomain element #\n self.read_py_ele()\n #: list of boundary nodes\n self.read_bv_fort13()\n\n def trim_fort13(self, old_fort13, new_fort13):\n \"\"\"\n Trim ``old_fort13`` to match the nodes in this subdomain and save as\n ``new_fort13``. This only assumes that a ``py.140`` file exists.\n\n :param string old_fort13: path to the old ``fort.13`` file to be\n trimmed\n :param string new_fort13: path to save the new ``fort.13`` file\n \"\"\"\n trim_fort13(old_fort13, new_fort13, os.path.join(self.path, 'py.140'))\n\n def trim_multiple_fort13(self, old_fort13, new_fort13):\n \"\"\"\n Trim ``old_fort13`` to match the nodes in this subdomain and save as\n ``new_fort13``. This only assumes that a ``py.140`` file exists.\n\n :param string old_fort13: path to the old ``fort.13`` file to be\n trimmed\n :param string new_fort13: path to save the new ``fort.13`` file\n \"\"\"\n trim_multiple_fort13(old_fort13, new_fort13, os.path.join(self.path,\n 'py.140'))\n\n def read_bv_fort13(self):\n \"\"\"\n Read the boundary value nodal values for Manning's n from\n ``self.fulldomain`` and save as a ``dict`` as ``self.bv_fort13``.\n \"\"\"\n self.read_bv_nodes()\n self.bv_fort13 = f13.read_nodal_attr(self, self.path,\n nums=self.bv_nodes)\n\n def set_bv_fort13(self, mann_data):\n \"\"\"\n Replace the boundary nodal values with the boundary nodal values in the\n fulldomain.\n\n :type mann_data: :class:`numpy.ndarray` or :class:`dict`\n :param mann_data: containing the nodal attribute information\n \n :rtype: :class:`numpy.ndarray` or :class:`dict`\n :returns: dictionary or array of nodal values\n\n \"\"\"\n if isinstance(mann_data, dict):\n for k, v in self.bv_fort13.iteritems():\n mann_data[k] = v\n else:\n for k, v in self.bv_fort13.iteritems():\n mann_data[k-1] = v\n return mann_data\n\n def update_mann(self, data, path=None, default=None, file_name='fort.13'):\n \"\"\"\n Write out fort.13 to path with the attributes contained in Data. \n\n :type data: :class:`numpy.ndarray` or :class:`dict`\n :param data: containing the nodal attribute information\n :type path: string or None\n :param path: the directory to which the fort.13 file will be written\n :type default: None or float\n :param default: default value\n :type file_name: string\n :param file_name: the name of the ``fort.13`` formatted file\n\n \"\"\"\n data = self.set_bv_fort13(data)\n f13.update_mann(data, path, default, file_name)\n\n\ndef trim_fort13(old_fort13, new_fort13, pynode_map):\n \"\"\"\n Trim ``old_fort13`` to match the nodes in this subdomain and save as\n ``new_fort13``. This only assumes that a ``py.140`` file exists.\n\n :param string old_fort13: path to the old ``fort.13`` file to be\n trimmed\n :param string new_fort13: path to save the new ``fort.13`` file\n \"\"\"\n print pynode_map\n gensub.main13(None, old_fort13, new_fort13, pynode_map)\n\ndef trim_multiple_fort13(old_fort13, new_fort13, pynode_map):\n \"\"\"\n Trim ``old_fort13`` to match the nodes in this subdomain and save as\n ``new_fort13``. This only assumes that a ``py.140`` file exists.\n\n :param string old_fort13: path to the old ``fort.13`` file to be\n trimmed\n :param string new_fort13: path to save the new ``fort.13`` file\n \"\"\"\n size = comm.Get_size()\n rank = comm.Get_rank()\n\n print \"len old, len new\", len(old_fort13), len(new_fort13)\n\n for i in range(0+rank, len(old_fort13), size):\n if not os.path.exists(os.path.dirname(new_fort13[i])):\n os.makedirs(os.path.dirname(new_fort13[i]))\n trim_fort13(old_fort13[i], new_fort13[i], pynode_map)\n\ndef ellipse_properties(x, y, w):\n \"\"\"\n Given a the (x,y) locations of the foci of the ellipse and the width return\n the center of the ellipse, width, height, and angle relative to the x-axis.\n\n :param double x: x-coordinates of the foci\n :param double y: y-coordinates of the foci\n :param double w: width of the ellipse\n :rtype: tuple of doubles\n :returns: (center_coordinates, width, height, angle_in_rads)\n\n \"\"\"\n p1 = [x[0], y[0]]\n p2 = [x[1], y[1]]\n \n #center point\n xy = [(p1[0] + p2[0])/2, (p1[1] + p2[1])/2]\t\t\n #distance between points\n d = ((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2)**(0.5)\t\n #theta to positive Xaxis\n angle = math.atan((p1[1] - p2[1])/(p1[0] - p2[0])) \n #sin = math.sin(-angle)\n #cos = math.cos(-angle)\n #width will be the axis the points lie on\n width = 2*((0.5*d)**2 + (0.5*w)**2)**(0.5) \t\t\n height = w\n\n return (xy, width, height, angle*180/math.pi)\n\n", "meta": {"hexsha": "c74c4344c8cb6c21fff53be55fe738f32b7a02b7", "size": 32711, "ext": "py", "lang": "Python", "max_stars_repo_path": "polyadcirc/run_framework/subdomain.py", "max_stars_repo_name": "tmiesse/PolyADCIRC", "max_stars_repo_head_hexsha": "a4a31dda2c2dac4cd696c0f3827dbbcea7feab33", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2016-03-04T19:42:32.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-20T15:39:25.000Z", "max_issues_repo_path": "polyadcirc/run_framework/subdomain.py", "max_issues_repo_name": "tmiesse/PolyADCIRC", "max_issues_repo_head_hexsha": "a4a31dda2c2dac4cd696c0f3827dbbcea7feab33", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2015-04-28T05:14:28.000Z", "max_issues_repo_issues_event_max_datetime": "2017-01-19T12:54:59.000Z", "max_forks_repo_path": "polyadcirc/run_framework/subdomain.py", "max_forks_repo_name": "UT-CHG/PolyADCIRC", "max_forks_repo_head_hexsha": "a4a31dda2c2dac4cd696c0f3827dbbcea7feab33", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2016-01-20T00:34:47.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-02T11:00:56.000Z", "avg_line_length": 38.3481828839, "max_line_length": 80, "alphanum_fraction": 0.5719177035, "include": true, "reason": "import numpy,import scipy", "num_tokens": 8255, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792044, "lm_q2_score": 0.3886180267058489, "lm_q1q2_score": 0.1973448446340028}} {"text": "# The MIT License (MIT)\n# Copyright (c) 2016, 2017 by the ESA CCI Toolbox development team and contributors\n#\n# Permission is hereby granted, free of charge, to any person obtaining a copy of\n# this software and associated documentation files (the \"Software\"), to deal in\n# the Software without restriction, including without limitation the rights to\n# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies\n# of the Software, and to permit persons to whom the Software is furnished to do\n# so, subject to the following conditions:\n#\n# The above copyright notice and this permission notice shall be included in all\n# copies or substantial portions of the Software.\n#\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n# SOFTWARE.\n\n\"\"\"\nDescription\n===========\n\nThis module provides aggregation operations\n\nComponents\n==========\n\"\"\"\nfrom datetime import timezone\n\nimport numpy as np\nimport pandas as pd\nimport xarray as xr\nfrom xarray.core.resample import DatasetResample as resampler\n\nfrom cate.core.op import op, op_input, op_return\nfrom cate.core.types import VarNamesLike, DatasetLike, ValidationError, DimNamesLike\nfrom cate.ops.normalize import adjust_temporal_attrs\nfrom cate.ops.select import select_var\nfrom cate.util.monitor import Monitor\n\n\n@op(tags=['aggregate', 'temporal'], version='1.5')\n@op_input('ds', data_type=DatasetLike)\n@op_input('var', value_set_source='ds', data_type=VarNamesLike)\n@op_return(add_history=True)\ndef long_term_average(ds: DatasetLike.TYPE,\n var: VarNamesLike.TYPE = None,\n monitor: Monitor = Monitor.NONE) -> xr.Dataset:\n \"\"\"\n Create a 'mean over years' dataset by averaging the values of the given input\n dataset over all years. The output is a climatological dataset with the same\n resolution as the input dataset. E.g. a daily input dataset will create a daily\n climatology consisting of 365 days, a monthly input dataset will create a monthly\n climatology, etc.\n\n Seasonal input datasets must have matching seasons over all years denoted by the\n same date each year. E.g., first date of each quarter. The output dataset will\n then be a seasonal climatology where each season is denoted with the same date\n as in the input dataset.\n\n For further information on climatological datasets, see\n http://cfconventions.org/cf-conventions/v1.6.0/cf-conventions.html#climatological-statistics\n\n :param ds: A dataset to average\n :param var: If given, only these variables will be preserved in the resulting dataset\n :param monitor: A progress monitor\n :return: A climatological long term average dataset\n \"\"\"\n ds = DatasetLike.convert(ds)\n # Check if time dtype is what we want\n if 'datetime64[ns]' != ds.time.dtype:\n raise ValidationError('Long term average operation expects a dataset with the'\n ' time coordinate of type datetime64[ns], but received'\n ' {}. Running the normalize operation on this'\n ' dataset may help'.format(ds.time.dtype))\n\n try:\n t_resolution = ds.attrs['time_coverage_resolution']\n except KeyError:\n raise ValidationError('Could not determine temporal resolution. Running'\n ' the adjust_temporal_attrs operation beforehand may'\n ' help.')\n\n var = VarNamesLike.convert(var)\n # Shallow\n\n if var:\n ds = select_var(ds, var)\n\n if t_resolution == 'P1D':\n return _lta_daily(ds)\n elif t_resolution == 'P1M':\n return _lta_monthly(ds, monitor)\n else:\n return _lta_general(ds, monitor)\n\n\ndef _lta_monthly(ds: xr.Dataset, monitor: Monitor):\n \"\"\"\n Carry out a long term average on a monthly dataset\n\n :param ds: Dataset to aggregate\n :param monitor: Progress monitor\n :return: Aggregated dataset\n \"\"\"\n time_min = pd.Timestamp(ds.time.values[0], tzinfo=timezone.utc)\n time_max = pd.Timestamp(ds.time.values[-1], tzinfo=timezone.utc)\n total_work = 100\n retset = ds\n\n with monitor.starting('LTA', total_work=total_work):\n monitor.progress(work=0)\n step = total_work / 12\n kwargs = {'monitor': monitor, 'step': step}\n retset = retset.groupby('time.month', squeeze=False).apply(_mean, **kwargs)\n\n # Make the return dataset CF compliant\n retset = retset.rename({'month': 'time'})\n retset['time'] = pd.date_range('{}-01-01'.format(time_min.year),\n freq='MS',\n periods=12)\n\n climatology_bounds = xr.DataArray(data=np.tile([time_min, time_max],\n (12, 1)),\n dims=['time', 'nv'],\n name='climatology_bounds')\n retset['climatology_bounds'] = climatology_bounds\n retset.time.attrs = ds.time.attrs\n retset.time.attrs['climatology'] = 'climatology_bounds'\n\n for var in retset.data_vars:\n try:\n retset[var].attrs['cell_methods'] = \\\n retset[var].attrs['cell_methods'] + ' time: mean over years'\n except KeyError:\n retset[var].attrs['cell_methods'] = 'time: mean over years'\n\n return retset\n\n\ndef _groupby_day(ds: xr.Dataset, monitor: Monitor, step: float):\n \"\"\"\n Groupby the given dataset by day of month and apply mean to it\n\n :param ds: Dataset to aggregate\n :param monitor: Progress monitor\n :param step: Progress step\n \"\"\"\n kwargs = {'monitor': monitor, 'step': step}\n return ds.groupby('time.day', squeeze=False).apply(_mean, **kwargs)\n\n\ndef _lta_daily(ds: xr.Dataset):\n \"\"\"\n Carry out a long term average of a daily dataset\n\n :param ds: Dataset to aggregate\n :return: Aggregated dataset\n \"\"\"\n\n retset = ds.groupby('time.dayofyear', squeeze=False).mean('time')\n\n for var in retset.data_vars:\n try:\n retset[var].attrs['cell_methods'] = \\\n retset[var].attrs['cell_methods'] + ' time: mean over years'\n except KeyError:\n retset[var].attrs['cell_methods'] = 'time: mean over years'\n\n return retset\n\n\ndef _lta_general(ds: xr.Dataset, monitor: Monitor):\n \"\"\"\n Try to carry out a long term average in a general case, notably\n in the case of having seasonal datasets\n\n :param ds: Dataset to aggregate\n :param monitor: Progress monitor\n :return: Aggregated dataset\n \"\"\"\n time_min = pd.Timestamp(ds.time.values[0], tzinfo=timezone.utc)\n time_max = pd.Timestamp(ds.time.values[-1], tzinfo=timezone.utc)\n total_work = 100\n retset = ds\n\n # The dataset should feature time periods consistent over years\n # and denoted with the same dates each year\n if not _is_seasonal(ds.time):\n raise ValidationError(\"A long term average dataset can not be created for\"\n \" a dataset with inconsistent seasons.\")\n\n # Get 'representative year'\n c = 0\n for group in ds.time.groupby('time.year'):\n c = c + 1\n if c == 1:\n rep_year = group[1].time\n continue\n if c == 2 and len(group[1].time) > len(rep_year):\n rep_year = group[1].time\n break\n\n with monitor.starting('LTA', total_work=total_work):\n monitor.progress(work=0)\n step = total_work / len(rep_year.time)\n kwargs = {'monitor': monitor, 'step': step}\n retset = retset.groupby('time.month', squeeze=False).apply(_groupby_day, **kwargs)\n\n # Make the return dataset CF compliant\n retset = retset.stack(time=('month', 'day'))\n\n # Turn month, day coordinates to time\n retset = retset.reset_index('time')\n retset = retset.drop(['month', 'day'])\n retset['time'] = rep_year.time\n\n climatology_bounds = xr.DataArray(data=np.tile([time_min, time_max],\n (len(rep_year), 1)),\n dims=['time', 'nv'],\n name='climatology_bounds')\n retset['climatology_bounds'] = climatology_bounds\n retset.time.attrs = ds.time.attrs\n retset.time.attrs['climatology'] = 'climatology_bounds'\n\n for var in retset.data_vars:\n try:\n retset[var].attrs['cell_methods'] = \\\n retset[var].attrs['cell_methods'] + ' time: mean over years'\n except KeyError:\n retset[var].attrs['cell_methods'] = 'time: mean over years'\n\n return retset\n\n\ndef _is_seasonal(time: xr.DataArray):\n \"\"\"\n Check if the given timestamp dataarray features consistent\n seasons. E.g. Each year has the same date-month values in it.\n \"\"\"\n c = 0\n test = None\n for group in time.groupby('time.year'):\n # Test (month, day) dates of all years against\n # (month, day) dates of the first year, or second\n # year in case the first year is not full\n c = c + 1\n np_time = group[1].time.values\n months = pd.DatetimeIndex(np_time).month\n days = pd.DatetimeIndex(np_time).day\n if c == 1:\n first_months = months\n first_days = days\n continue\n elif c == 2:\n second_months = months\n second_days = days\n if len(second_months) > len(first_months):\n test = list(zip(second_months, second_days))\n for date in zip(first_months, first_days):\n if date not in test:\n return False\n else:\n test = list(zip(first_months, first_days))\n for date in zip(second_months, second_days):\n if date not in test:\n return False\n continue\n\n for date in zip(months, days):\n if date not in test:\n return False\n\n return True\n\n\ndef _mean(ds: xr.Dataset, monitor: Monitor, step: float):\n \"\"\"\n Calculate mean of the given dataset and update the given monitor.\n\n :param ds: Dataset to take the mean of\n :param monitor: Monitor to update\n :param step: Work step\n \"\"\"\n retset = ds.mean(dim='time', keep_attrs=True)\n monitor.progress(work=step)\n return retset\n\n\n@op(tags=['aggregate', 'temporal'], version='1.5')\n@op_input('ds', data_type=DatasetLike)\n@op_input('method', value_set=['mean', 'max', 'median', 'prod', 'sum', 'std',\n 'var', 'argmax', 'argmin', 'first', 'last'])\n@op_input('output_resolution', value_set=['month', 'season'])\n@op_return(add_history=True)\ndef temporal_aggregation(ds: DatasetLike.TYPE,\n method: str = 'mean',\n output_resolution: str = 'month',\n custom_resolution: str = None,\n monitor: Monitor = Monitor.NONE) -> xr.Dataset:\n \"\"\"\n Perform aggregation of dataset according to the given\n method and output resolution.\n\n Note that the operation does not perform weighting. Depending on the\n combination of input and output resolutions, as well as aggregation\n method, the resulting dataset might yield unexpected results.\n\n Resolution 'month' will result in a monthly dataset with each month\n denoted by its first date. Resolution 'season' will result in a dataset\n aggregated to DJF, MAM, JJA, SON seasons, each denoted by the first\n date of the season.\n\n The operation also works with custom resolution strings, see:\n http://pandas.pydata.org/pandas-docs/stable/timeseries.html#offset-aliases\n If ``custom_resolution`` is provided, it will override ``output_resolution``.\n\n Some examples:\n 'QS-JUN' produces an output dataset on a quarterly resolution where the\n year ends in 1st of June and each quarter is denoted by its first date\n '8MS' produces an output dataset on an eight-month resolution where each\n period is denoted by the first date. Note that such periods will not be\n consistent over years.\n '8D' produces a dataset on an eight day resolution\n\n :param ds: Dataset to aggregate\n :param method: Aggregation method\n :param output_resolution: Desired temporal resolution of the output dataset\n :param custom_resolution: Custom temporal resolution, overrides output_resolution\n :return: Aggregated dataset\n \"\"\"\n ds = DatasetLike.convert(ds)\n # Check if time dtype is what we want\n if 'datetime64[ns]' != ds.time.dtype:\n raise ValidationError('Temporal aggregation operation expects a dataset with the'\n ' time coordinate of type datetime64[ns], but received'\n ' {}. Running the normalize operation on this'\n ' dataset may help'.format(ds.time.dtype))\n\n # Try to figure out the input frequency\n try:\n in_freq = ds.attrs['time_coverage_resolution']\n except KeyError:\n raise ValidationError('Could not determine temporal resolution of input dataset.'\n ' Running the adjust_temporal_attrs operation beforehand may'\n ' help.')\n\n if custom_resolution:\n freq = custom_resolution\n else:\n frequencies = {'month': 'MS', 'season': 'QS-DEC'}\n freq = frequencies[output_resolution]\n\n _validate_freq(in_freq, freq)\n\n with monitor.observing(\"resample dataset\"):\n try:\n retset = getattr(resampler, method)(ds.resample(time=freq, keep_attrs=True))\n except AttributeError:\n raise ValidationError(f'Provided aggregation method {method} is not valid.')\n\n for var in retset.data_vars:\n try:\n retset[var].attrs['cell_methods'] = \\\n retset[var].attrs['cell_methods'] + \\\n ' time: {} within years'.format(method)\n except KeyError:\n retset[var].attrs['cell_methods'] = 'time: {} within years'.format(method)\n\n return adjust_temporal_attrs(retset)\n\n\ndef _validate_freq(in_res: str, out_res: str) -> None:\n \"\"\"\n Validate the aggregation step\n\n See also: `ISO 8601 Durations `_\n \"\"\"\n # Validate output frequency as a valid offset string\n try:\n dates = pd.date_range('2000-01-01', periods=5, freq=out_res)\n except ValueError:\n raise ValidationError('Invalid custom resolution: {}.'\n ' Please check operation documentation.'.format(out_res))\n\n # Assuming simple ISO_8601 periods: PXXD/M\n try:\n count = int(in_res[1:-1])\n except ValueError:\n raise ValidationError('Could not interpret time coverage resolution of'\n ' the given dataset: {}'.format(in_res))\n\n if in_res == 'P1M' and out_res == 'MS':\n raise ValidationError('Input dataset is already at the requested output resolution.'\n ' Execution stopped.')\n\n in_delta = pd.Timedelta(count, unit=in_res[-1])\n out_delta = dates[1] - dates[0]\n\n if out_delta < in_delta:\n raise ValidationError('Requested output resolution is smaller than dataset resolution.'\n ' This operation only performs aggregation to larger resolutions.')\n elif out_delta == in_delta:\n raise ValidationError('Input dataset is already at the requested output resolution.'\n 'Execution stopped.')\n\n return\n\n\n@op(tags=['aggregate'], version='1.0')\n@op_input('ds', data_type=DatasetLike)\n@op_input('var', value_set_source='ds', data_type=VarNamesLike)\n@op_input('dim', value_set_source='ds', data_type=DimNamesLike)\n@op_input('method', value_set=['mean', 'min', 'max', 'sum', 'median'])\n@op_return(add_history=True)\ndef reduce(ds: DatasetLike.TYPE,\n var: VarNamesLike.TYPE = None,\n dim: DimNamesLike.TYPE = None,\n method: str = 'mean',\n monitor: Monitor = Monitor.NONE) -> xr.Dataset:\n \"\"\"\n Reduce the given variables of the given dataset along the given dimensions.\n If no variables are given, all variables of the dataset will be reduced. If\n no dimensions are given, all dimensions will be reduced. If no variables\n have been given explicitly, it can be set that only variables featuring numeric\n values should be reduced.\n\n :param ds: Dataset to reduce\n :param var: Variables in the dataset to reduce\n :param dim: Dataset dimensions along which to reduce\n :param method: reduction method\n :param monitor: A progress monitor\n \"\"\"\n ufuncs = {'min': np.nanmin, 'max': np.nanmax, 'mean': np.nanmean,\n 'median': np.nanmedian, 'sum': np.nansum}\n\n ds = DatasetLike.convert(ds)\n\n if not var:\n var = list(ds.data_vars.keys())\n var_names = VarNamesLike.convert(var)\n\n if not dim:\n dim = list(ds.coords.keys())\n else:\n dim = DimNamesLike.convert(dim)\n\n retset = ds.copy()\n\n for var_name in var_names:\n intersection = [value for value in dim if value in retset[var_name].dims]\n with monitor.starting(\"Reduce dataset\", total_work=100):\n monitor.progress(5)\n with monitor.child(95).observing(\"Reduce\"):\n retset[var_name] = retset[var_name].reduce(ufuncs[method],\n dim=intersection,\n keep_attrs=True)\n\n return retset\n", "meta": {"hexsha": "e2cd1d663d65800d833f73420defa50eaf066fa9", "size": 17848, "ext": "py", "lang": "Python", "max_stars_repo_path": "cate/ops/aggregate.py", "max_stars_repo_name": "pwambach/cate", "max_stars_repo_head_hexsha": "956eff12530e4a339f56d6d3739bc41328df4f75", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "cate/ops/aggregate.py", "max_issues_repo_name": "pwambach/cate", "max_issues_repo_head_hexsha": "956eff12530e4a339f56d6d3739bc41328df4f75", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "cate/ops/aggregate.py", "max_forks_repo_name": "pwambach/cate", "max_forks_repo_head_hexsha": "956eff12530e4a339f56d6d3739bc41328df4f75", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.5485961123, "max_line_length": 97, "alphanum_fraction": 0.6344128194, "include": true, "reason": "import numpy", "num_tokens": 3960, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792044, "lm_q2_score": 0.3886180267058489, "lm_q1q2_score": 0.1973448446340028}} {"text": "#!/usr/bin/env python3\n\n#\n# Copyright 2015 Dovetail Genomics LLC\n#\n#\n\nfrom __future__ import division\nfrom __future__ import print_function\nfrom builtins import map\nfrom builtins import str\nfrom builtins import range\nfrom past.utils import old_div\nimport sys\nimport networkx as nx\nimport chicago_edge_scores as ces\n\ndefault_gapsize=100.0\n\nll={}\nlinks={}\n\ndef is_shaved_tail(G,shave_round,shaved_degree,shave_limit):\n leaves=[]\n r={}\n for n in G.nodes():\n if shave_round.get(n,0)>shave_limit and shaved_degree.get(n,0)==1:\n leaves.append(n)\n for l in leaves:\n q=[l]\n while len(q)>0:\n n=q.pop()\n r[n]=True\n for nn in G.neighbors(n):\n if shave_round.get(nn,0)>shave_limit and shaved_degree.get(nn,0)<=2 and (not nn in q) and (not nn in r ):\n q.append(nn)\n return r\n\n\ndef distance_to_nearest_branch(G,shave_round,shave_limit,trim_degree):\n branchpoints=[]\n r={}\n\n for n in G.nodes():\n #print \"#\",n, G.degree(n),G.degree(n)==1\n if shave_round.get(n,0)>shave_limit and trim_degree.get(n,0)>2:\n branchpoints.append(n)\n# print leaves\n\n round=1\n# print \"#\",leaves\n boundary=list(branchpoints)\n next=[]\n done=[]\n #r={}\n for b in boundary: r[b]=round\n while len(boundary)>0:\n round +=1\n next=[]\n for n in boundary:\n for nn in G.neighbors(n):\n if (not nn in boundary+done+next) :\n next.append(nn)\n# r[nn]=round\n for b in next: \n r[b] = round\n# if len( [nn for nn in G.neighbors(b) if not r.has_key(nn)] )==1: r[b]=round\n for b in boundary: done.append(b)\n boundary = []\n for n in next: \n if n in r: boundary.append(n)\n# next=[]\n\n# for n in G.nodes():\n# if not r.has_key(n): r[n]=round\n return r\n\n\ndef distance_to_nearest_leaf(G,shave_round,shave_limit,trim_degree):\n leaves=[]\n r={}\n for n in G.nodes():\n #print \"#\",n, G.degree(n),G.degree(n)==1\n if shave_round.get(n,0)<=shave_limit :\n r[n]=0\n for n in G.nodes():\n #print \"#\",n, G.degree(n),G.degree(n)==1\n if trim_degree.get(n,0)==1 and shave_round.get(n,0)>shave_limit:\n leaves.append(n)\n# print leaves\n\n round=1\n# print \"#\",leaves\n boundary=list(leaves)\n next=[]\n done=[]\n# r={}\n for b in boundary: r[b]=round\n while len(boundary)>0:\n round +=1\n next=[]\n for n in boundary:\n for nn in G.neighbors(n):\n if (not nn in boundary+done+next):\n next.append(nn)\n# r[nn]=round\n for b in next: \n r[b] = round\n# if len( [nn for nn in G.neighbors(b) if not r.has_key(nn)] )==1: r[b]=round\n for b in boundary: done.append(b)\n boundary = []\n for n in next: \n if n in r: boundary.append(n)\n# next=[]\n# for n in G.nodes():\n# if not r.has_key(n): r[n]=round\n return r\n \n\ndef shave_round(G):\n leaves=[]\n for n in G.nodes():\n #print \"#\",n, G.degree(n),G.degree(n)==1\n if G.degree(n)==1:\n leaves.append(n)\n# print leaves\n\n round=1\n# print \"#\",leaves\n boundary=list(leaves)\n next=[]\n done=[]\n r={}\n for b in boundary: r[b]=round\n while len(boundary)>0:\n round +=1\n next=[]\n for n in boundary:\n for nn in G.neighbors(n):\n if (not nn in boundary+done+next):\n next.append(nn)\n# r[nn]=round\n nr={}\n for b in next: \n if len( [nn for nn in G.neighbors(b) if nn not in r] )==1: nr[b]=round\n r.update(nr)\n for b in boundary: done.append(b)\n boundary = []\n for n in next: \n if n in r: boundary.append(n)\n# next=[]\n for n in G.nodes():\n if n not in r: r[n]=round\n return r\n\ndef log(x):\n sys.stderr.write(x+\"\\n\")\n\n\nLOCAL_BRIDGE=1\nCUT_ME=2\n\nedge_tags={}\n\ndef add_tag(s1,s2,tag):\n if s1min( float(bhi[3]), float(bhi[4]) ): chr_mins[bhi[1]]=min( float(bhi[3]), float(bhi[4]) )\n if chr_maxs.get(bhi[1],-1.0) 0:\n# print a,b,G[a][b],q,r\n n=q.pop(0)\n r.append(n)\n for nn in G.neighbors(n):\n if (n==a and nn==b) or (n==b and nn==a): continue\n if G[n][nn]['weight']>-t: continue\n if nn==b: return True\n# print q,[l[i] for i in q]\n l[nn] = min(l.get(nn,10000), l[n]+1)\n if (not nn in q+r) and (l[nn]<=k):\n q.append(nn)\n return False\n \ndef annotate_edges(t,G,node_list):\n an={}\n# nn= len(list(t.edges()))\n# i=0.0\n for a,b in t.edges():\n\n if not independent_path(G,a,b,4,2): \n an[a,b]=\"local_bridge\"\n an[b,a]=\"local_bridge\"\n \n return an\n\n\ndef pairs_overlap(x,y):\n a=min(x[0],x[1])\n b=max(x[0],x[1])\n c=min(y[0],y[1])\n d=max(y[0],y[1])\n \n if a<=c and c<=b: return True\n if a<=d and d<=b: return True\n if c<=a and a<=d: return True\n if c<=b and b<=d: return True\n return False\n\ndef qdist(x,y):\n if (not x) or (not y): return (-1)\n if x[0]==y[0]:\n x,y,w,z = list(map(int,[x[2],x[3],y[2],y[3]]))\n ol = pairs_overlap((x,y),(w,z))\n if ol:\n return(-1*min(\n abs(x-w),\n abs(x-z),\n abs(y-w),\n abs(y-z )))\n else:\n return(min(\n abs(x-w),\n abs(x-z),\n abs(y-w),\n abs(y-z )))\n else:\n return(1.0e12)\n\ndef test_inversion_option(c1,c2,join_options,ograph,linked):\n a=c1\n b=linked[c1]\n c=c2\n d=linked[c2]\n\n #k=linked[internal_node]\n ograph.remove_edge(a,b)\n ograph.remove_edge(c,d)\n ## ---b a-------c d----\n if a in nx.node_connected_component(ograph,c): ## exchance labels of a,b if necessary, so the nodes are in this config: ---a b-------c d------ \n x=b\n b=a\n a=x\n \n ## ---b a-------d c----\n if a in nx.node_connected_component(ograph,d): ## exchance labels of a,b if necessary, so the nodes are in this config: ---a b-------c d------ \n x=b\n b=a\n a=x\n\n x=d\n d=c\n c=x\n\n ## ---a b-------d c----\n if b in nx.node_connected_component(ograph,d): ## exchance labels of c,d if necessary, so the nodes are in this config: ---a b-------c d------ \n x=d\n d=c\n c=x\n\n n_scaffold = old_div(len(nx.node_connected_component(ograph,b)),2)\n print(\"inversion n nodes\",n_scaffold)\n\n\n total_i_len = sum( ograph[i][j]['length'] for i,j in nx.bfs_edges(ograph,b) )\n print(\"inv len\",total_i_len)\n if total_i_len < 10000.0 or n_scaffold<2:\n print(\"inversion length\",total_i_len,n_scaffold,\"too short\")\n join_options.append( (0.0,(),() ) ) \n ograph.add_edge(a,b,length=default_gapsize,contig=False)\n ograph.add_edge(c,d,length=default_gapsize,contig=False)\n\n return\n\n interc_score0 = intercalation_score_raw(a,b,d,ograph) \n interc_score1 = intercalation_score_raw(a,c,d,ograph) \n print(\"inversion0\", interc_score0)\n print(\"inversion\", interc_score1)\n join_options.append( (interc_score0,(),() ) )\n join_options.append( (interc_score1,((a,c),(b,d)),((a,b),(c,d)) ) )\n ograph.add_edge(a,b,length=default_gapsize,contig=False)\n ograph.add_edge(c,d,length=default_gapsize,contig=False)\n\n return\n\ndef test_endInversion_option(free_end,internal_node,join_options,ograph,linked):\n if free_end in linked:\n x=free_end\n free_end = internal_node\n internal_node = x\n print(\"end inversion\",free_end,linked.get(free_end),internal_node,linked[internal_node])\n\n k=linked[internal_node]\n ograph.remove_edge(internal_node,k)\n\n if free_end in nx.node_connected_component(ograph,internal_node): \n x=k\n k=internal_node\n internal_node=x\n\n sc = link_test(ograph,k,internal_node)\n join_options.append( (sc,(),()))\n print(\"end inversion existing:\",sc)\n\n sc = link_test(ograph,free_end,internal_node)\n join_options.append( (sc ,((free_end,internal_node),),((internal_node,k),) ) ) \n print(\"end inversion:\",sc)\n\n ograph.add_edge(internal_node,k,length=default_gapsize, contig=False) \n return\n\ndef test_interc_option( gap_edge1, gap_edge2, free_end1, join_options, ograph ):\n if not ograph.has_edge(gap_edge1,gap_edge2):\n print(\"expected nodes to be connected: {} {}\".format(gap_edge1, gap_edge2))\n raise Exception('not connected')\n ograph.remove_edge( gap_edge1, gap_edge2 )\n if gap_edge1 in nx.node_connected_component(ograph,gap_edge2): \n print(\"problem: these should be disconnected now:\",gap_edge1,gap_edge2)\n raise Exception('too connected i')\n if gap_edge2 in nx.node_connected_component(ograph,free_end1): \n print(\"problem: these should have been disconnected all along\",free_end1,gap_edge2)\n raise Exception('too connected j')\n if gap_edge1 in nx.node_connected_component(ograph,free_end1): \n print(\"problem: these should have been disconnected all along\",free_end1,gap_edge1) \n raise Exception('too connected k')\n interc_score = intercalation_score(gap_edge1,free_end1,gap_edge2,ograph)\n ograph.add_edge(gap_edge1, gap_edge2, length=default_gapsize,contig=False)\n d = far_end(ograph,free_end1)\n join_options.append( (interc_score,((gap_edge1,free_end1),(d,gap_edge2)),((gap_edge1, gap_edge2),) ) )\n\n\nN=76710553.0 #100000000.0\npn=0.3\nGenomeSize=3.0e9\nimport math\n\ndef get_score(c1_stranded,c2_stranded,gaplen=default_gapsize,cache={}):\n if gaplen<0.0: print(math.log(-1))\n# if cache.has_key((c1_stranded,c2_stranded,gaplen)):\n# return cache[c1_stranded,c2_stranded,gaplen]\n# if cache.has_key((c2_stranded,c1_stranded,gaplen)):\n# return cache[c2_stranded,c1_stranded,gaplen]\n o1,o2=0,0\n if c1_stranded[-2:]==\".5\": o1=1\n if c2_stranded[-2:]==\".3\": o2=1\n c1=c1_stranded[:-2]\n c2=c2_stranded[:-2]\n l1=ll[c1]\n l2=ll[c2]\n p0 = ces.p_not_a_hit(l1,l2,GenomeSize,gaplen,pn)\n if p0<0.0:\n print(\"wtf? p0<0\",p0,l1,l2,GenomeSize,gaplen,pn)\n thisscore=ces.llr_v0(l1,l2,o1,o2,GenomeSize,pn,links.get((c1,c2),[]),N,gaplen,p0 )\n #cache[c1_stranded,c2_stranded,gaplen]=thisscore\n return thisscore\n\ndef traverse_and_layout(n,coords,facing,x,s,og,maxD=2000000):\n color={}\n q=[n]\n ptr=x\n if s>0: \n facing[n]=\"L\" \n else: \n facing[n]=\"R\"\n while (abs(ptr-x)0:\n m=q.pop(0)\n coords[m]=ptr\n color[m]=1\n for mm in og.neighbors(m):\n if not mm in color:\n q.append(mm)\n ptr+=s*og[m][mm]['length']\n if not og[m][mm]['contig']:\n if s==-1:\n facing[mm]='R'\n else:\n facing[mm]='L'\n else:\n if s==-1:\n facing[mm]='L'\n else:\n facing[mm]='R'\n\ndef far_end(g,n):\n if not g.degree(n)==1:\n print(\"wtf: this should be a leaf\")\n exit(0)\n for m in nx.node_connected_component(g,n):\n if (not m==n) and g.degree(m)==1:\n return m\n\ndef both_ends(g,n):\n p=[]\n for m in nx.node_connected_component(g,n):\n if g.degree(m)==1:\n p.append( m)\n return p\n\ndef strand_check(a,b,x,f):\n if x[a]0.0:\n# if len(join_options[0][2]) >=1 : print \"#accept join\",label, join_options[0], join_options\n for x,y in join_options[0][2]:\n og.remove_edge(x,y)\n del linked[x]\n del linked[y]\n for x,y in join_options[0][1]:\n linked[x]=y\n linked[y]=x\n og.add_edge(x,y,length=default_gapsize,contig=False)\n edge_options[x,y] = \"[color=brown label=\\\"{:.2f}\\\"]\".format(weights.get((x,y),0))\n edge_options[y,x] = \"[color=brown label=\\\"{:.2f}\\\"]\".format(weights.get((x,y),0))\n \ndef link_test(og,a,b,gapsize=default_gapsize,max_stretch=200000):\n coords = {}\n facing={}\n traverse_and_layout(a,coords,facing,0,-1,og,maxD=200000)\n traverse_and_layout(b,coords,facing,gapsize,+1,og,maxD=200000)\n# print \"#x:setup done\"\n sys.stdout.flush()\n \n score=0.0\n for n1 in nx.node_connected_component(og,a):\n if abs(coords.get(n1,-1e10))>max_stretch: continue\n for n2 in nx.node_connected_component(og,b):\n if abs(coords.get(n2,1e10))>max_stretch: continue\n if strand_check(n1,n2,coords,facing):\n distance = coords[n2] - coords[n1]\n if distance < max_stretch:\n x=get_score(n1,n2,distance)\n# print \"#x:partial\",n1,n2,x\n sys.stdout.flush()\n score += x\n return score\n\ndef intercalation_score(a,b,c,og):\n# print \"#intercalation test:\",a,b,c\n if a in nx.node_connected_component(og,b): \n print(\"a should not be connected to b\",a,b)\n raise Exception('too connected a')\n if b in nx.node_connected_component(og,c): \n print(\"b should not be connected to c\",b,c)\n raise Exception('too connected b')\n if a in nx.node_connected_component(og,c): \n print(\"a should not be connected to c\",a,c)\n raise Exception('too connected c')\n coordinates1={}\n coordinates2={}\n facing={}\n traverse_and_layout(a,coordinates1,facing,0,-1,og)\n coordinates2=dict(coordinates1)\n traverse_and_layout(c,coordinates1,facing,default_gapsize,+1,og)\n traverse_and_layout(b,coordinates2,facing,default_gapsize,+1,og)\n traverse_and_layout(c,coordinates2,facing,default_gapsize+max(coordinates2.values()),+1,og)\n\n score_0=0.0\n for n1 in nx.node_connected_component(og,a):\n for n2 in nx.node_connected_component(og,c):\n if strand_check(n1,n2,coordinates1,facing):\n distance = coordinates1[n2] - coordinates1[n1]\n if distance < 200000:\n if distance<0: print(\"wtf1?\")\n score_0 += get_score(n1,n2,distance)\n\n score_1=0.0\n for n1 in nx.node_connected_component(og,a):\n for n2 in nx.node_connected_component(og,c):\n if strand_check(n1,n2,coordinates2,facing):\n distance = coordinates2[n2] - coordinates2[n1]\n if distance < 200000:\n if distance<0: print(\"wtf2?\")\n score_1 += get_score(n1,n2,distance)\n\n for n2 in nx.node_connected_component(og,b):\n if strand_check(n1,n2,coordinates2,facing):\n distance = coordinates2[n2] - coordinates2[n1]\n if distance < 200000:\n if distance<0: print(\"wtf3?\")\n score_1 += get_score(n1,n2,distance)\n\n for n1 in nx.node_connected_component(og,b):\n for n2 in nx.node_connected_component(og,c):\n if strand_check(n1,n2,coordinates2,facing):\n distance = coordinates2[n2] - coordinates2[n1]\n if distance < 200000:\n if distance<0: print(\"wtf4?\")\n score_1 += get_score(n1,n2,distance)\n\n# print \"#intercalation scores:\",score_1,score_0\n\n\n if a in nx.node_connected_component(og,b): \n print(\"a should not be connected to b\",a,b)\n raise Exception('too connected d')\n if b in nx.node_connected_component(og,c): \n print(\"b should not be connected to c\",b,c)\n raise Exception('too connected e')\n if a in nx.node_connected_component(og,c): \n print(\"a should not be connected to c\",a,c)\n raise Exception('too connected f')\n\n return (score_1-score_0)\n\ndef intercalation_score_raw(a,b,c,og):\n# print \"#intercalation test:\",a,b,c\n if a in nx.node_connected_component(og,b): print(\"a should not be connected to b\",a,b)\n if b in nx.node_connected_component(og,c): print(\"b should not be connected to c\",b,c)\n if a in nx.node_connected_component(og,c): print(\"a should not be connected to c\",a,c)\n# coordinates1={}\n coordinates2={}\n facing={}\n traverse_and_layout(a,coordinates2,facing,0,-1,og)\n# coordinates2=dict(coordinates1)\n# traverse_and_layout(c,coordinates1,facing,1000,+1,og)\n traverse_and_layout(b,coordinates2,facing,default_gapsize,+1,og)\n traverse_and_layout(c,coordinates2,facing,default_gapsize+max(coordinates2.values()),+1,og)\n\n# score_0=0.0\n# for n1 in nx.node_connected_component(og,a):\n# for n2 in nx.node_connected_component(og,c):\n# if strand_check(n1,n2,coordinates1,facing):\n# distance = coordinates1[n2] - coordinates1[n1]\n# if distance < 200000:\n# if distance<0: print \"wtf1?\"\n# score_0 += get_score(n1,n2,distance)\n\n score_1=0.0\n for n1 in nx.node_connected_component(og,a):\n for n2 in nx.node_connected_component(og,c):\n if strand_check(n1,n2,coordinates2,facing):\n distance = coordinates2[n2] - coordinates2[n1]\n if distance < 200000:\n if distance<0: print(\"wtf2?\")\n score_1 += get_score(n1,n2,distance)\n\n for n2 in nx.node_connected_component(og,b):\n if strand_check(n1,n2,coordinates2,facing):\n distance = coordinates2[n2] - coordinates2[n1]\n if distance < 200000:\n if distance<0: print(\"wtf3?\")\n score_1 += get_score(n1,n2,distance)\n\n for n1 in nx.node_connected_component(og,b):\n for n2 in nx.node_connected_component(og,c):\n if strand_check(n1,n2,coordinates2,facing):\n distance = coordinates2[n2] - coordinates2[n1]\n if distance < 200000:\n if distance<0: print(\"wtf4?\")\n score_1 += get_score(n1,n2,distance)\n\n# print \"#intercalation scores:\",score_1,score_0\n return (score_1)\n\n\nif __name__==\"__main__\":\n\n import sys\n import argparse\n parser = argparse.ArgumentParser()\n \n parser.add_argument('-t','--threshold',default=0.0 , type=float)\n\n parser.add_argument('-H','--head',default=False,type=int)\n parser.add_argument('-D','--savetreedots',default=False,action='store_true')\n parser.add_argument('-d','--debug',default=False,action='store_true')\n# parser.add_argument('-I','--nointerc',default=False,action='store_true')\n parser.add_argument('-p','--progress',default=False,action='store_true')\n parser.add_argument('-M','--maxdegree',default=False,type=int)\n parser.add_argument('-m','--minlength',default=500,type=int)\n\n parser.add_argument('-S','--silent',default=False,action='store_true')\n parser.add_argument('-K','--cutPromisc',default=False,action='store_true')\n parser.add_argument('-J','--logH',default=False,action='store_true')\n parser.add_argument('-T','--logTags',default=False,action='store_true')\n parser.add_argument('-C','--cheat',default=False,action='store_true')\n parser.add_argument('-B','--blacklist')\n\n parser.add_argument('-j','--joins') #pre-join these\n parser.add_argument('-k','--links') \n parser.add_argument('-b','--besthits')\n parser.add_argument('-s','--skip',default=0,type=int) \n parser.add_argument('-l','--lengths')\n parser.add_argument('-E','--edgefile')\n parser.add_argument('--set_insert_size_dist_fit_params')\n parser.add_argument('-L','--maxLength',type=float,default=150000.0)\n parser.add_argument('-P','--promisc',type=float,default=0.023)\n parser.add_argument('-o','--dotLabel',default=\"bad\")\n\n args = parser.parse_args()\n if args.debug:\n args.progress=True\n\n if args.progress: log( str(args) )\n print(\"#\"+str(args))\n\n if args.set_insert_size_dist_fit_params:\n s=args.set_insert_size_dist_fit_params\n a,b,c,d,f,pn,N = list(map(float,list(s.split(','))))\n print(\"#\",a,b,c,d,f)\n ces.set_insert_size_dist_fit_params(a,b,c,d,f,pn,N)\n sys.stdout.flush()\n\n G=nx.Graph()\n SG=nx.Graph()\n\n ll={}\n if args.lengths:\n f = open(args.lengths)\n while True:\n l = f.readline()\n if not l: break\n if l[0]==\"#\": continue\n\n c=l.strip().split()\n l = int(c[1])\n ll[c[0]]=int(c[1])\n if l>= args.minlength:\n G.add_node(c[0])\n SG.add_node(c[0])\n f.close()\n if args.progress: print(\"#Done reading lengths\")\n\n #broken.al.masked.links.txt\n def read_links(contigs=False):\n links={}\n import glob\n for f in glob.glob(args.links): #[\"same_component-t4.links.txt\"]:\n print(\"#file:\",f)\n ff=open(f)\n while True:\n l = ff.readline()\n if not l: break\n if l[0]==\"#\": continue\n c=l.strip().split(\"\\t\")\n if (not contigs) or (c[0] in contigs) and (c[1] in contigs):\n links[(c[0],c[1])]=eval(c[5])\n return links\n\n\n besthit={}\n if args.besthits:\n# besthit={}\n if args.besthits:\n f = open(args.besthits)\n while True:\n l = f.readline()\n if not l: break\n\n if not l[:5]==\"best:\": continue\n c=l.strip().split()\n besthit[c[1]]=c[2:]\n # print c[1],besthit[c[1]]\n f.close()\n if args.progress: print(\"#Done reading besthits\")\n\n if args.edgefile:\n f = open(args.edgefile)\n else:\n f=sys.stdin\n while True:\n l = f.readline()\n if not l: break\n if l[0]==\"#\": continue\n c=l.strip().split()\n u,v,w = c[0],c[1],float(c[2])\n if ( not args.lengths ) or (ll[u]>=args.minlength and ll[v]>=args.minlength):\n G.add_edge(u,v,weight=-w)\n if w >= args.threshold:\n SG.add_edge(u,v,weight=-w)\n if args.edgefile:\n f.close()\n\n if args.progress: print(\"#Done reading edgelist\")\n\n bad_nodes=[]\n total_discarded_length=0\n total_discarded_length1=0\n n_discarded1=0\n n_discarded2=0\n if args.maxdegree:\n for n in SG.nodes():\n print(\"#dg:\", SG.degree(n))\n if SG.degree(n)>args.maxdegree:\n n_discarded1+=1\n bad_nodes.append(n)\n total_discarded_length += ll[n]\n print(\"#discard:\",n,ll[n],SG.degree(n))\n for nn in SG.neighbors(n):\n if SG.degree(nn)==1:\n n_discarded2+=1\n total_discarded_length1+=ll[nn]\n for n in bad_nodes:\n e_to_remove=[]\n for e in SG.edges([n]):\n e_to_remove.append(e)\n SG.remove_edges_from(e_to_remove)\n\n if args.cutPromisc:\n bad_nodes=[]\n for n in G.nodes():\n# print \"#dg:\", SG.degree(n)\n if (old_div(float(G.degree(n)), ll[n]))>args.promisc : # G.degree(n)/ll[n]>args.maxdegree:\n n_discarded1+=1\n bad_nodes.append(n)\n total_discarded_length += ll[n]\n print(\"#discard:\",n,ll[n],G.degree(n))\n# for nn in G.neighbors(n):\n# if G.degree(nn)==1:\n# n_discarded2+=1\n# total_discarded_length1+=ll[nn]\n for n in bad_nodes:\n e_to_remove=[]\n for e in G.edges([n]):\n e_to_remove.append(e)\n G.remove_edges_from(e_to_remove)\n SG.remove_edges_from(e_to_remove)\n \n if args.blacklist:\n f=open(args.blacklist)\n e_to_remove=[]\n while True:\n l=f.readline()\n if not l: break\n c=l.strip().split()\n e_to_remove.append((c[1],c[2]))\n G.remove_edges_from(e_to_remove)\n SG.remove_edges_from(e_to_remove)\n \n \n if args.cheat:\n e_to_remove=[]\n for a,b in SG.edges():\n if not ( a in besthit and b in besthit):\n e_to_remove.append((a,b))\n else:\n aa = tuple(besthit[a][1:5])\n bb = tuple(besthit[b][1:5])\n qd = qdist(aa,bb)\n if qd >= args.maxLength : \n e_to_remove.append((a,b))\n SG.remove_edges_from(e_to_remove)\n \n\n if args.progress: print(\"#total_discarded_length\",n_discarded1,n_discarded2,old_div(float(total_discarded_length),1.0e6),old_div(float(total_discarded_length1),1.0e6),old_div(float(total_discarded_length+total_discarded_length1),1.0e6))\n\n\n promisc = {}\n for n in G.nodes():\n if args.debug: print(\"#r:\",old_div(float(G.degree(n)),ll[n]))\n if (old_div(float(G.degree(n)),ll[n]))>args.promisc: promisc[n]=True\n\n tag_tallies={}\n bad_tag_tallies={}\n strx={\"+\":0, \"-\":1}\n strings = []\n ccn=1\n\n if args.progress: \n print(\"about to load the links\")\n sys.stdout.flush()\n links = read_links()\n if args.progress: \n print(\"loaded the links\")\n sys.stdout.flush()\n\n\n print(\"#n_connected_components:\",len(nx.connected_components(SG)))\n for c in nx.connected_components(SG):\n if ccn<=args.skip:\n ccn+=1\n continue\n\n if len(c)==1: \n print(\"#edge:\",c[0]+\".5\",c[0]+\".3\",{\"length\": ll[c[0]],\"contig\": True})\n continue\n\n# if args.progress: \n# print \"about to load the links\"\n# sys.stdout.flush()\n# links = read_links(c)\n# if args.progress: \n# print \"loaded the links\"\n# sys.stdout.flush()\n\n print(\"cc:\",ccn,len(c),c)\n\n edge_options={}\n nodes={}\n\n og=nx.Graph()\n linked={}\n\n for cc in c:\n og.add_node(cc+\".5\")\n og.add_node(cc+\".3\")\n nodes[cc+\".5\"]=\"5'\"\n nodes[cc+\".3\"]=\"3'\"\n og.add_edge(cc+\".5\",cc+\".3\",length=ll[cc],contig=True)\n edge_options[cc+\".5\",cc+\".3\"] = \"[label=\\\"{} {}\\\" penwidth=3]\".format(cc,old_div((ll[cc]+500),1000))\n edge_options[cc+\".3\",cc+\".5\"] = \"[label=\\\"{} {}\\\" penwidth=3]\".format(cc,old_div((ll[cc]+500),1000))\n\n if args.joins:\n f = open(args.joins)\n while True:\n l = f.readline()\n if not l: break\n cz=l.strip().split()\n if not len(cz)>=3: continue\n #print \"z:\",cz[1][:-2],cz[2][:-2],cz\n if cz[0]==\"#join:\" :\n if (cz[1][:-2] in c) and (cz[2][:-2] in c):\n print(\"join\",cz[1:])\n og.add_edge( cz[1],cz[2],length=default_gapsize,contig=False)\n linked[cz[1]]=cz[2]\n linked[cz[2]]=cz[1]\n# og.add_edge(c1,c2,length=1000.0,contig=False)\n edge_options[cz[1],cz[2]] = \"[label=\\\"pre\\\" penwidth=2]\"\n edge_options[cz[2],cz[1]] = \"[label=\\\"pre\\\" penwidth=2]\"\n else: \n pass\n# print \"skip\",cz[1:]\n f.close()\n\n weights = {}\n for c1 in c:\n if args.progress: print(\"#\",c1)\n l1=ll[c1]\n for c2 in c:\n if not c112:\n if c2 in nx.node_connected_component(og, c1): # link within one of the scaffolds. \n if c1 in linked and linked[c1]==c2: continue # this join pre made!\n if (not c1 in linked) and (not c2 in linked): # this would circularize\n pass\n elif ( c1 in linked) and ( c2 in linked): # test to invert (or excize circle?)\n if og.has_edge(c1,c2): \n print(\"skip test flip of\",c1,c2)\n continue #don't test inversions of individual contigs\n# print \"test invert\",c1,linked.get(c1),c2, linked.get(c2) \n join_options=[]\n test_inversion_option(c1,c2,join_options,og,linked)\n take_best_join_option(join_options,og,linked,edge_options,\"inversion\")\n \n elif (not c1 in linked) or (not c2 in linked): # test for end inversion (scorpion tail?) or pinch off circle from end?\n# print \"test end invert\",c1,c2,linked.get(c1), linked.get(c2)\n join_options=[]\n test_endInversion_option(c1,c2,join_options,og,linked)\n take_best_join_option(join_options,og,linked,edge_options,\"end inversion\") \n \n else:\n if (not c1 in linked) and (not c2 in linked): # and not c2 in nx.node_connected_component(og, c1):\n linked[c1]=c2\n linked[c2]=c1\n print(\"#easy\",c1,c2,weights[c1,c2])\n og.add_edge(c1,c2,length=default_gapsize,contig=False)\n edge_options[c1,c2] = \"[color=blue label=\\\"{:.2f}\\\"]\".format(weights[c1,c2])\n edge_options[c2,c1] = \"[color=blue label=\\\"{:.2f}\\\"]\".format(weights[c1,c2])\n elif (c1 in linked) and (c2 in linked):\n # This edge looks like an H. test whether the two linked scaffolds can be put end-to-end:\n # a-b k-d : we'll test b+k, a+k, b+d and a+d, and if the best one raises the total score, we'll add it.\n a,b = both_ends(og,c1)\n k,d = both_ends(og,c2)\n sc={}\n for x,y in ((b,k),(a,k),(b,d),(a,d)):\n sc[x,y] = link_test(og,x,y)\n sll=list(sc.items())\n sll.sort(key=lambda x: x[1],reverse=True)\n print(\"# Htest:\", c1,c2,sll)\n x,y = sll[0][0]\n if sc[x,y]>0:\n print(\"#H accept\", sc[x,y] ,x,y)\n linked[x]=y\n linked[y]=x\n og.add_edge(x,y,length=default_gapsize,contig=False)\n edge_options[x,y] = \"[color=green label=\\\"{:.2f}\\\"]\".format(weights.get((x,y),0))\n edge_options[y,x] = \"[color=green label=\\\"{:.2f}\\\"]\".format(weights.get((x,y),0))\n \n elif (not c1 in linked) or (not c2 in linked): #test whether one can be intercalated in the other:\n accepted=False\n join_options=[]\n if (not c1 in linked):\n b=c1\n a=c2\n cP=linked[a]\n print(\"#1:\",c1,c2,a,b,cP,weights[c1,c2])\n elif (not c2 in linked):\n b=c2\n a=c1\n cP=linked[a]\n print(\"#2:\",c1,c2,a,b,cP,weights[c1,c2])\n if (not c1 in linked) or (not c2 in linked):\n # not linking end-to-end: \n #but one of them IS an end link, try inserting that scaffold into the other one.\n # a and c are the contig ends flanking the gap we're inserting into, b is the end of\n # the scaffold being tested for insertion.\n\n\n test_interc_option(a,cP,b,join_options,og)\n test_interc_option(a,cP,far_end(og,b),join_options,og)\n\n a,k = both_ends(og,a)\n b,d = both_ends(og,b)\n sc={}\n for x,y in ((a,b),(k,b),(a,d),(k,d)):\n sc[x,y] = link_test(og,x,y)\n join_options.append( (sc[x,y],((x,y),),() ) )\n\n take_best_join_option(join_options,og,linked,edge_options,\"interc or end\")\n \n\n if False:\n for c1,c2 in link_pairs:\n if weights[c1,c2]>12 and not c2 in nx.node_connected_component(og, c1):\n # linked[c1]=True\n # linked[c2]=True\n og.add_edge(c1,c2) \n edge_options[c1,c2] = \"[style=dotted label=\\\"{:.2f}\\\"]\".format(weights[c1,c2]) #]\"\n edge_options[c2,c1] = \"[style=dotted label=\\\"{:.2f}\\\"]\".format(weights[c1,c2]) #]\"\n\n red_edges=\"\"\n node_fill={}\n if args.besthits:\n import colorsys\n\n chromosomes={}\n chr_mins={}\n chr_maxs={}\n ends=[]\n \n for cc in c:\n#best: Scaffold91_1 46380.0 chr12 + 49064574 49095652 \n# besthit[c[1]]=c[2:]\n\n if cc not in besthit: continue\n aa = tuple(besthit[cc][1:5])\n chromosomes[aa[0]]=1\n xxx = old_div((int(aa[2])+int(aa[3])),2)\n if chr_mins.get(aa[0],1.0e9)>xxx: chr_mins[aa[0]]=xxx\n if chr_maxs.get(aa[0],-1.0e9)args.head:\n break\n\n \n\n\n", "meta": {"hexsha": "003f09ea04f5084917e678207ca0be439ad47a03", "size": 43724, "ext": "py", "lang": "Python", "max_stars_repo_path": "scripts/greedy_chicagoan.py", "max_stars_repo_name": "aakashsur/docker-hirise", "max_stars_repo_head_hexsha": "9b97cc4e7522e287aa2ee39c2993270e75b43a6d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "scripts/greedy_chicagoan.py", "max_issues_repo_name": "aakashsur/docker-hirise", "max_issues_repo_head_hexsha": "9b97cc4e7522e287aa2ee39c2993270e75b43a6d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "scripts/greedy_chicagoan.py", "max_forks_repo_name": "aakashsur/docker-hirise", "max_forks_repo_head_hexsha": "9b97cc4e7522e287aa2ee39c2993270e75b43a6d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.1802721088, "max_line_length": 240, "alphanum_fraction": 0.5161467386, "include": true, "reason": "import networkx", "num_tokens": 12029, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792044, "lm_q2_score": 0.3886180267058489, "lm_q1q2_score": 0.1973448446340028}} {"text": "\"\"\"Plot figures from the paper.\"\"\"\nimport logging\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom pathlib import Path\nfrom astropy import units as u\nfrom astropy.table import Table\nfrom gammapy.spectrum import CrabSpectrum, CountsPredictor\nfrom gammapy.spectrum.models import LogParabola\nimport matplotlib.lines as mlines\nfrom matplotlib import gridspec\nfrom .models import Log10Parabola\nfrom .utils import load_yaml\nfrom .conf import config\nfrom .errors import stat_errorband\n\nlog = logging.getLogger(__name__)\n\nFONTSIZE = 15\nFONTSIZE_CONTOURS = 18\nE_UNIT_LABEL = r\"$E\\,/\\,\\mathrm{TeV}$\"\nSED_UNIT_LABEL = (\n r\"$E^2 \\cdot {\\rm d}\\phi/{\\rm d}E\\,/\\,({\\rm erg}\\,{\\rm cm}^{-2} {\\rm s}^{-1})$\"\n)\nCOLORS = [\"#21ABCD\", \"#FF9933\", \"#893F45\", \"#3EB489\", \"#002E63\", \"crimson\"]\n\n\ndef plot_crab():\n \"\"\"Plot Crab pulsar and nebula SED.\"\"\"\n log.info(\"Executing plot_crab ...\")\n\n fig, ax = plt.subplots()\n\n # Plot flux points\n for component in [\"pulsar\", \"nebula\"]:\n table = Table.read(\"data/other/crab_mwl.fits.gz\")\n table = table[table[\"component\"] == component]\n x = table[\"energy\"].data\n y = table[\"energy_flux\"].data\n yerr_lo = table[\"energy_flux_err_lo\"].data\n yerr_hi = table[\"energy_flux_err_hi\"].data\n ax.errorbar(x, y, yerr=(yerr_lo, yerr_hi), fmt=\"o\", label=component)\n\n # Plot SED model\n energy = np.logspace(2, 8, 100) * u.MeV\n\n crab = CrabSpectrum(reference=\"meyer\")\n\n flux = crab.model(energy)\n energy_flux = (energy ** 2 * flux).to(\"erg cm^-2 s^-1\")\n ax.plot(energy.value, energy_flux.value, label=\"Meyer (2010) model\", lw=3)\n\n ax.set_xlim((3e-1, 3e8))\n ax.set_ylim((3e-12, 3e-8))\n ax.set_xlabel(\"Energy (MeV)\")\n ax.set_ylabel(\"E^2 dN/dE (erg cm^-2 s^-1)\")\n fig.legend(loc=\"upper center\", ncol=3)\n ax.grid()\n ax.loglog()\n\n path = Path(\"results/figures\")\n path.mkdir(parents=True, exist_ok=True)\n filename = \"results/figures/crab_mwl.png\"\n log.info(f\"Writing {filename}\")\n fig.savefig(filename)\n\n\ndef plot_fit_results(tool):\n \"\"\"plot the SEDs result of the gammapy / sherpa fit\n for comparison with the literature we choose only the Mayer spectrum\n\n Here we plot the butterfly as a result of the multivariate sampling\n with the 68% containment in flux\n \"\"\"\n fig, ax = plt.subplots()\n\n model_meyer_ref = CrabSpectrum(\"meyer\").model\n model_meyer_ref.plot(\n [10 * u.GeV, 100 * u.TeV],\n energy_power=2,\n flux_unit=\"erg-1 cm-2 s-1\",\n ls=\":\",\n lw=2.2,\n color=\"#555555\",\n label=\"Meyer et al. (2010)\",\n )\n\n # where to take the results, configurations for the individual butterflies\n instruments = [\"fermi\", \"magic\", \"veritas\", \"fact\", \"hess\", \"joint\"]\n labels = [\"Fermi-LAT\", \"MAGIC\", \"VERITAS\", \"FACT\", \"H.E.S.S.\", \"joint fit\"]\n lss = [\"--\", \"--\", \"--\", \"--\", \"--\", \"-\"]\n colors = COLORS\n # with one loop we realize all the butterfly plots\n for instrument, label, color, ls in zip(instruments, labels, colors, lss):\n\n path = (\n config.repo_path\n / f\"results/fit/{tool}/{instrument}/fit_results_logparabola.yaml\"\n )\n\n if not path.exists():\n log.warning(f\"Missing: {path} . Skipping.\")\n continue\n\n results = load_yaml(path)\n parameters = results[\"parameters\"]\n\n model_lp = LogParabola.from_log10(\n amplitude=parameters[0][\"value\"] * u.Unit(parameters[0][\"unit\"]),\n reference=parameters[1][\"value\"] * u.Unit(parameters[1][\"unit\"]),\n alpha=parameters[2][\"value\"] * u.Unit(parameters[2][\"unit\"]),\n beta=parameters[3][\"value\"] * u.Unit(parameters[3][\"unit\"]),\n )\n\n # energy range for the plot\n dataset = config.get_dataset(instrument)\n energy_range = dataset.energy_range\n\n # just in case of the joint fit put a thicker line and a less transparent butterfly\n if instrument == \"joint\":\n model_lp.plot(\n energy_range,\n energy_power=2,\n flux_unit=\"erg-1 cm-2 s-1\",\n ls=ls,\n lw=3,\n color=color,\n label=label,\n )\n else:\n model_lp.plot(\n energy_range,\n energy_power=2,\n flux_unit=\"erg-1 cm-2 s-1\",\n ls=ls,\n lw=2.2,\n color=color,\n label=label,\n )\n\n # read the butterfly from the multivariate sampling results\n table_path = Path(\n f\"{config.repo_path}/results/figures/stat_err/{instrument}_flux_errorband.dat\"\n )\n log.info(f\"reading butterfly values from {table_path}\")\n t = Table.read(table_path, format=\"ascii.ecsv\")\n energies = t[\"energies\"].data * t[\"energies\"].unit\n flux_lo = t[\"flux_lo\"].data * t[\"flux_lo\"].unit\n flux_hi = t[\"flux_hi\"].data * t[\"flux_hi\"].unit\n\n if instrument == \"joint\":\n alpha = 0.38\n else:\n alpha = 0.28\n\n plt.fill_between(\n energies.to(\"TeV\"),\n (energies ** 2 * flux_lo).to(\"erg cm-2 s-1\"),\n (energies ** 2 * flux_hi).to(\"erg cm-2 s-1\"),\n color=color,\n alpha=alpha,\n label=\"\",\n )\n\n ax.legend(fontsize=FONTSIZE)\n ax.set_ylim([1e-12, 2e-10])\n\n ax.set_xlabel(E_UNIT_LABEL, size=FONTSIZE)\n ax.set_ylabel(SED_UNIT_LABEL, size=FONTSIZE)\n # make axis thicker\n for axis in [\"top\", \"bottom\", \"left\", \"right\"]:\n ax.spines[axis].set_linewidth(1.6)\n ax.tick_params(\"both\", length=7, width=1.6, which=\"major\", labelsize=FONTSIZE)\n ax.tick_params(\"both\", length=4, width=1.6, which=\"minor\", labelsize=FONTSIZE)\n\n plt.tight_layout()\n\n filename = f\"results/figures/crab_sed_{tool}_fit.png\"\n filename_pdf = f\"results/figures/crab_sed_{tool}_fit.pdf\"\n log.info(f\"Writing {filename}\")\n fig.savefig(filename)\n fig.savefig(filename_pdf)\n\n\ndef plot_sherpa_contours():\n \"\"\"plot the confidence contours obtained from the sherpa fit\n \"\"\"\n log.info(\"plotting parameters contours obtained from sherpa\")\n # where to take the results, configurations for the individual butterflies\n instruments = [\"fermi\", \"magic\", \"hess\", \"fact\", \"veritas\", \"joint\"]\n labels = [\"Fermi-LAT\", \"MAGIC\", \"H.E.S.S.\", \"FACT\", \"VERITAS\", \"joint fit\"]\n colors = [\"#21ABCD\", \"#FF9933\", \"#5A4FCF\", \"#5CC184\", \"#702963\", \"crimson\"]\n lss = [\"--\", \"--\", \"--\", \"--\", \"--\", \"-\"]\n\n fig, axarr = plt.subplots(1, 3, figsize=(18, 6))\n\n # with one loop we realize all the contour plots\n for instrument, label, color, ls in zip(instruments, labels, colors, lss):\n\n path = config.repo_path / f\"results/fit/sherpa/{instrument}\"\n\n contours_path = path / \"fit_contours_logparabola.npy\"\n results_path = path / \"fit_results_logparabola.yaml\"\n\n if not path.exists():\n log.warning(f\"Missing: {path} . Skipping.\")\n continue\n\n # load the contours and the results of the fit\n contours = np.load(contours_path).tolist()\n results = load_yaml(results_path)\n\n # define a 2 x 2 matrix to visualise the plot\n # we will delete one of the subplots and make something like a corner plot\n # useful variables for the plot\n ampl_range = contours[\"contour_ampl_c1\"][\"x0_range\"]\n c1_range = contours[\"contour_ampl_c1\"][\"x1_range\"]\n c2_range = contours[\"contour_ampl_c2\"][\"x1_range\"]\n # actual values output of the fit\n # remember in sherpa notation: (amplitude->ampl, alpha->c1, beta->c2)\n ampl = results[\"parameters\"][0][\"value\"]\n c1 = results[\"parameters\"][2][\"value\"]\n c2 = results[\"parameters\"][3][\"value\"]\n\n # axarr[0,0]\n extent = [ampl_range[0] * 1e9, ampl_range[1] * 1e9, c1_range[0], c1_range[1]]\n\n axarr[0].contour(\n contours[\"contour_ampl_c1\"][\"like_values\"],\n contours[\"contour_ampl_c1\"][\"levels\"],\n origin=\"lower\",\n extent=extent,\n colors=color,\n linewidths=(2., 1.5, 1.3),\n linestyles=(\"-\", \"--\", \":\"),\n )\n\n # print actual value\n axarr[0].plot(ampl, c1, marker=\"X\", markersize=7, color=color)\n axarr[0].set_xlabel(\n r\"$f_0 / (\\mathrm{TeV} \\, \\mathrm{cm}^{-2} \\mathrm{s}^{-1})$\"\n )\n axarr[0].set_ylabel(r\"$\\Gamma$\")\n\n extent = [ampl_range[0] * 1e9, ampl_range[1] * 1e9, c2_range[0], c2_range[1]]\n\n axarr[1].contour(\n contours[\"contour_ampl_c2\"][\"like_values\"],\n contours[\"contour_ampl_c2\"][\"levels\"],\n origin=\"lower\",\n extent=extent,\n colors=color,\n linewidths=(2., 1.5, 1.3),\n linestyles=(\"-\", \"--\", \":\"),\n )\n\n # print actual value\n axarr[1].plot(ampl, c2, marker=\"X\", markersize=7, color=color)\n axarr[1].set_ylabel(r\"$\\beta$\")\n axarr[1].set_xlabel(\n r\"$f_0 / (\\mathrm{TeV} \\, \\mathrm{cm}^{-2} \\, \\mathrm{s}^{-1})$\"\n )\n\n extent = [c1_range[0], c1_range[1], c2_range[0], c2_range[1]]\n\n axarr[2].contour(\n contours[\"contour_c1_c2\"][\"like_values\"],\n contours[\"contour_c1_c2\"][\"levels\"],\n origin=\"lower\",\n extent=extent,\n colors=color,\n linewidths=(2., 1.5, 1.3),\n linestyles=(\"-\", \"--\", \":\"),\n )\n\n # print actual value\n axarr[2].plot(c1, c2, marker=\"X\", markersize=7, color=color)\n axarr[2].set_ylabel(r\"$\\beta$\")\n axarr[2].set_xlabel(r\"$\\Gamma$\")\n\n # axarr[0,1] is for the legend\n import matplotlib.lines as mlines\n\n sigma_1 = mlines.Line2D(\n [], [], color=\"k\", marker=\"\", ls=\"-\", lw=2., label=r\"1 $\\sigma$ contour\"\n )\n sigma_2 = mlines.Line2D(\n [], [], color=\"k\", marker=\"\", ls=\"--\", lw=1.5, label=r\"2 $\\sigma$ contour\"\n )\n sigma_3 = mlines.Line2D(\n [], [], color=\"k\", marker=\"\", ls=\":\", lw=1.3, label=r\"3 $\\sigma$ contour\"\n )\n fermi = mlines.Line2D(\n [], [], color=\"#21ABCD\", marker=\"\", ls=\"-\", lw=2., label=\"Fermi-LAT\"\n )\n magic = mlines.Line2D(\n [], [], color=\"#FF9933\", marker=\"\", ls=\"-\", lw=2., label=\"MAGIC\"\n )\n hess = mlines.Line2D(\n [], [], color=\"#5A4FCF\", marker=\"\", ls=\"-\", lw=2., label=\"H.E.S.S.\"\n )\n fact = mlines.Line2D(\n [], [], color=\"#5CC184\", marker=\"\", ls=\"-\", lw=2., label=\"FACT\"\n )\n veritas = mlines.Line2D(\n [], [], color=\"#702963\", marker=\"\", ls=\"-\", lw=2., label=\"VERITAS\"\n )\n joint = mlines.Line2D(\n [], [], color=\"crimson\", marker=\"\", ls=\"-\", lw=2., label=\"joint fit\"\n )\n axarr[2].legend(\n handles=[sigma_1, sigma_2, sigma_3, fermi, magic, hess, fact, veritas, joint],\n loc=3,\n fontsize=12,\n )\n # axarr[2].set_axis_off()\n\n plt.tight_layout()\n filename = \"results/figures/sherpa_logparabola_contour.png\"\n fig.savefig(filename)\n log.info(f\"Writing {filename}\")\n fig.savefig(filename)\n\n\ndef plot_iminuit_contours():\n \"\"\"plot the confidence contours obtained from the sherpa fit\n \"\"\"\n log.info(\"plotting parameters contours obtained from iminuit\")\n # where to take the results, configurations for the individual butterflies\n instruments = [\"fermi\", \"magic\", \"veritas\", \"fact\", \"hess\", \"joint\"]\n labels = [\"Fermi-LAT\", \"MAGIC\", \"VERITAS\", \"FACT\", \"H.E.S.S.\", \"joint fit\"]\n colors = COLORS\n lss = [\"--\", \"--\", \"--\", \"--\", \"--\", \"-\"]\n\n fig, axarr = plt.subplots(1, 3, figsize=(16, 5))\n\n # with one loop we realize all the contour plots\n for instrument, label, color, ls in zip(instruments, labels, colors, lss):\n path = config.repo_path / f\"results/fit/gammapy/{instrument}\"\n\n contours_path = path / \"fit_1.0_sigma_contours_logparabola.npy\"\n results_path = path / \"fit_results_logparabola.yaml\"\n\n if not path.exists():\n log.warning(f\"Missing: {path} . Skipping.\")\n continue\n\n # load the contours and the results of the fit\n contours = np.load(contours_path).tolist()\n results = load_yaml(results_path)\n # true values to be plotted\n amplitude = float(results[\"parameters\"][0][\"value\"])\n alpha = float(results[\"parameters\"][2][\"value\"])\n beta = float(results[\"parameters\"][3][\"value\"])\n\n # amplitude vs alpha\n amplitude_alpha = contours[\"contour_amplitude_alpha\"]\n axarr[0].plot(\n amplitude_alpha[\"amplitude\"] * 10,\n amplitude_alpha[\"alpha\"],\n marker=\"\",\n ls=\"-\",\n lw=2.5,\n color=color,\n )\n # plot actual value\n axarr[0].plot(\n amplitude * 1e11, alpha, marker=\"X\", markersize=7, color=color, lw=2.5\n )\n axarr[0].set_xlabel(\n r\"$\\phi_0 \\,/\\,(10^{-11}\\,{\\rm TeV} \\, {\\rm cm}^{-2} {\\rm s}^{-1})$\",\n size=FONTSIZE_CONTOURS,\n )\n axarr[0].set_ylabel(r\"$\\Gamma$\", size=FONTSIZE_CONTOURS)\n # make axis thicker\n for axis in [\"top\", \"bottom\", \"left\", \"right\"]:\n axarr[0].spines[axis].set_linewidth(2.5)\n axarr[0].set_yticks([2.2, 2.4, 2.6, 2.8])\n axarr[0].set_ylim([2.1, 2.9])\n axarr[0].set_xticks([3, 4, 5])\n axarr[0].set_xlim([2.8, 5.2])\n axarr[0].tick_params(\n \"both\", length=7, width=1.6, which=\"major\", labelsize=FONTSIZE_CONTOURS\n )\n axarr[0].tick_params(\n \"both\", length=4, width=1.6, which=\"minor\", labelsize=FONTSIZE_CONTOURS\n )\n\n # amplitude vs beta\n amplitude_beta = contours[\"contour_amplitude_beta\"]\n axarr[1].plot(\n amplitude_beta[\"amplitude\"] * 10,\n # contour have a scale factor of 1e-10, parameters are in units of 1e-11\n amplitude_beta[\"beta\"],\n marker=\"\",\n ls=\"-\",\n lw=2.5,\n color=color,\n )\n # plot actual value\n axarr[1].plot(amplitude * 1e11, beta, marker=\"X\", markersize=7, color=color)\n axarr[1].set_xlabel(\n r\"$\\phi_0 \\,/\\,(10^{-11}\\,{\\rm TeV} \\, {\\rm cm}^{-2} {\\rm s}^{-1})$\",\n size=FONTSIZE_CONTOURS,\n )\n axarr[1].set_ylabel(r\"$\\beta$\", size=FONTSIZE_CONTOURS)\n axarr[1].set_xticks([3, 4, 5])\n axarr[1].set_xlim([2.8, 5.2])\n axarr[1].set_yticks([0.2, 0.4, 0.6])\n axarr[1].set_ylim([0.0, 0.8])\n # make axis thicker\n for axis in [\"top\", \"bottom\", \"left\", \"right\"]:\n axarr[1].spines[axis].set_linewidth(2.5)\n axarr[1].tick_params(\n \"both\", length=7, width=1.6, which=\"major\", labelsize=FONTSIZE_CONTOURS\n )\n axarr[1].tick_params(\n \"both\", length=4, width=1.6, which=\"minor\", labelsize=FONTSIZE_CONTOURS\n )\n\n # alpha vs beta\n alpha_beta = contours[\"contour_alpha_beta\"]\n axarr[2].plot(\n alpha_beta[\"alpha\"],\n alpha_beta[\"beta\"],\n marker=\"\",\n ls=\"-\",\n lw=2.5,\n color=color,\n )\n # plot actual value\n axarr[2].plot(alpha, beta, marker=\"X\", markersize=7, color=color)\n axarr[2].set_xlabel(r\"$\\Gamma$\", size=FONTSIZE_CONTOURS)\n axarr[2].set_ylabel(r\"$\\beta$\", size=FONTSIZE_CONTOURS)\n axarr[2].set_xticks([2.2, 2.4, 2.6, 2.8])\n axarr[2].set_xlim([2.1, 2.9])\n axarr[2].set_yticks([0.2, 0.4, 0.6])\n axarr[2].set_ylim([0.0, 0.8])\n # make axis thicker\n for axis in [\"top\", \"bottom\", \"left\", \"right\"]:\n axarr[2].spines[axis].set_linewidth(2.5)\n axarr[2].tick_params(\n \"both\", length=7, width=1.6, which=\"major\", labelsize=FONTSIZE_CONTOURS\n )\n axarr[2].tick_params(\n \"both\", length=4, width=1.6, which=\"minor\", labelsize=FONTSIZE_CONTOURS\n )\n\n # legend\n import matplotlib.lines as mlines\n\n fermi = mlines.Line2D(\n [], [], color=COLORS[0], marker=\"\", ls=\"-\", lw=2.5, label=\"Fermi-LAT\"\n )\n magic = mlines.Line2D(\n [], [], color=COLORS[1], marker=\"\", ls=\"-\", lw=2.5, label=\"MAGIC\"\n )\n veritas = mlines.Line2D(\n [], [], color=COLORS[2], marker=\"\", ls=\"-\", lw=2.5, label=\"VERITAS\"\n )\n fact = mlines.Line2D(\n [], [], color=COLORS[3], marker=\"\", ls=\"-\", lw=2.5, label=\"FACT\"\n )\n hess = mlines.Line2D(\n [], [], color=COLORS[4], marker=\"\", ls=\"-\", lw=2.5, label=\"H.E.S.S.\"\n )\n joint = mlines.Line2D(\n [], [], color=COLORS[5], marker=\"\", ls=\"-\", lw=2.5, label=\"joint fit\"\n )\n\n box = axarr[2].get_position()\n axarr[2].set_position([box.x0, box.y0, box.width * 0.97, box.height])\n # plot the legend on top of the central plot\n axarr[2].legend(\n handles=[fermi, magic, veritas, fact, hess, joint],\n loc=\"center left\",\n fontsize=FONTSIZE_CONTOURS,\n bbox_to_anchor=(1., 0.5),\n )\n\n plt.tight_layout()\n filename = \"results/figures/iminuit_logparabola_contour.png\"\n filename_pdf = \"results/figures/iminuit_logparabola_contour.pdf\"\n fig.savefig(filename)\n log.info(f\"Writing {filename}\")\n fig.savefig(filename)\n fig.savefig(filename_pdf)\n\n\ndef run_butterfly_stat(which):\n \"\"\"run the estimation of the butterfly\"\"\"\n if which in [\"fermi\", \"all\"]:\n butterfly_stat(\"fermi\")\n if which in [\"magic\", \"all\"]:\n butterfly_stat(\"magic\")\n if which in [\"veritas\", \"all\"]:\n butterfly_stat(\"veritas\")\n if which in [\"fact\", \"all\"]:\n butterfly_stat(\"fact\")\n if which in [\"hess\", \"all\"]:\n butterfly_stat(\"hess\")\n if which in [\"joint\", \"all\"]:\n butterfly_stat(\"joint\")\n\n\ndef butterfly_stat(which, tool=\"gammapy\"):\n \"\"\"plot an example figure showing how to correctly estimate a butterfly per each dataset\n We do it by default with the gammapy (iminuit) results\n \"\"\"\n # the sampling in energy shall be consistent with the nbins of the spectrum extraction\n if which == \"fermi\":\n num_energy_points = 20\n else:\n num_energy_points = 60\n energies, flux_min, flux_max = stat_errorband(\n which=which, tool=tool, dim_sample=500, energy_points=num_energy_points, sigma=1\n )\n\n # plot best fit model\n fig, ax = plt.subplots()\n # best fit parameters for this fit\n result_file = f\"results/fit/{tool}/{which}/fit_results_logparabola.yaml\"\n results = load_yaml(result_file)\n\n parameters = results[\"parameters\"]\n covariance = results[\"covariance\"]\n\n # best fit parameters\n amplitude = parameters[0][\"value\"] * u.Unit(parameters[0][\"unit\"])\n reference = parameters[1][\"value\"] * u.Unit(parameters[1][\"unit\"])\n alpha = parameters[2][\"value\"] * u.Unit(parameters[2][\"unit\"])\n beta = parameters[3][\"value\"] * u.Unit(parameters[3][\"unit\"])\n\n # gammapy model with best-fit parameters\n model_lp = Log10Parabola(\n amplitude=amplitude, reference=reference, alpha=alpha, beta=beta\n )\n\n # set the covariance matrix from the output of the fit, this is needed to propagate the error\n model_lp.parameters.covariance = np.asarray(covariance)\n\n # plot some model representing the sampling\n # dictionary from the multivariate sampling\n path = Path(\n f\"{config.repo_path}/results/debug/stat-err/{tool}/{which}/multivariate_sampling_fluxes.yaml\"\n )\n sampled_dict = load_yaml(path)\n sampled_amplitude = sampled_dict[\"sampled_amplitude\"]\n sampled_alpha = sampled_dict[\"sampled_alpha\"]\n sampled_beta = sampled_dict[\"sampled_beta\"]\n\n for (_ampl, _alpha, _beta) in zip(\n sampled_amplitude[:100], sampled_alpha[:100], sampled_beta[:100]\n ):\n _amplitude = _ampl * u.Unit(parameters[0][\"unit\"])\n _alpha = _alpha * u.Unit(parameters[2][\"unit\"])\n _beta = _beta * u.Unit(parameters[3][\"unit\"])\n\n _model_lp = Log10Parabola(\n amplitude=_amplitude, reference=reference, alpha=_alpha, beta=_beta\n )\n _model_lp.plot(\n energy_range=[energies[0], energies[-1]],\n energy_unit=\"TeV\",\n flux_unit=\"cm-2 s-1 erg-1\",\n energy_power=2,\n color=\"gray\",\n lw=0.8,\n alpha=0.8,\n ax=ax,\n )\n\n # plot the 68 % containment correction\n ax.plot(energies, (energies ** 2 * flux_min).to(\"erg cm-2 s-1\"), color=\"k\", lw=2.5)\n ax.plot(\n energies,\n (energies ** 2 * flux_max).to(\"erg cm-2 s-1\"),\n color=\"k\",\n lw=2.5,\n label=\"68% containment\" + \"\\n\" + \"multivariate sampling\",\n )\n\n model_lp.plot(\n energy_range=[energies[0], energies[-1]],\n energy_unit=\"TeV\",\n flux_unit=\"cm-2 s-1 erg-1\",\n energy_power=2,\n color=\"k\",\n lw=2.2,\n ls=\"--\",\n label=\"best fit model\",\n ax=ax,\n )\n\n # plt.title(f'{which} dataset')\n for axis in [\"top\", \"bottom\", \"left\", \"right\"]:\n ax.spines[axis].set_linewidth(2.)\n ax.tick_params(\"both\", length=7, width=1.6, which=\"major\", labelsize=FONTSIZE)\n ax.tick_params(\"both\", length=4, width=1.6, which=\"minor\", labelsize=FONTSIZE)\n ax.set_ylabel(SED_UNIT_LABEL, size=FONTSIZE)\n ax.set_xlabel(E_UNIT_LABEL, size=FONTSIZE)\n ax.set_xscale(\"log\")\n ax.set_yscale(\"log\")\n # ax.set_ylim([1e-12, 2e-10])\n ax.legend(fontsize=FONTSIZE)\n plt.tight_layout()\n\n figname = f\"{config.repo_path}/results/figures/stat_err/{tool}_{which}_butterfly_comparison.png\"\n figname_pdf = f\"{config.repo_path}/results/figures/stat_err/{tool}_{which}_butterfly_comparison.pdf\"\n logging.info(f\"saving {figname}\")\n fig.savefig(figname)\n fig.savefig(figname_pdf)\n\n log.info(\"making debug plots with histograms of the sampled parameters and fluxes\")\n fig2, ax2 = plt.subplots(1, 3, sharey=True)\n nbins_params = int(len(sampled_amplitude) / 20)\n ax2[0].hist(sampled_amplitude, bins=nbins_params, color=\"lightgray\")\n ax2[0].axvline(amplitude.value, lw=1.5, color=\"k\")\n ax2[0].axvline(\n amplitude.value - np.sqrt(covariance[0][0]), lw=1.5, ls=\"--\", color=\"k\"\n )\n ax2[0].axvline(\n amplitude.value + np.sqrt(covariance[0][0]), lw=1.5, ls=\"--\", color=\"k\"\n )\n ax2[0].set_xlabel(\n r\"$f_0 (\\mathrm{TeV}^{-1} \\, \\mathrm{cm}^{-2} \\, \\mathrm{s}^{-1})$\", labelpad=9\n )\n\n ax2[1].hist(sampled_alpha, bins=int(len(sampled_alpha) / 10), color=\"lightgray\")\n ax2[1].axvline(alpha.value, lw=1.5, color=\"k\")\n ax2[1].axvline(alpha.value - np.sqrt(covariance[2][2]), lw=1.5, ls=\"--\", color=\"k\")\n ax2[1].axvline(alpha.value + np.sqrt(covariance[2][2]), lw=1.5, ls=\"--\", color=\"k\")\n ax2[1].set_xlabel(r\"$\\Gamma$\")\n\n ax2[2].hist(\n sampled_beta,\n bins=int(len(sampled_beta) / 10),\n color=\"lightgray\",\n label=\"sampled\",\n )\n ax2[2].axvline(beta.value, lw=1.5, color=\"k\", label=\"best fit\")\n ax2[2].axvline(\n beta.value - np.sqrt(covariance[3][3]),\n lw=1.5,\n ls=\"--\",\n color=\"k\",\n label=r\"best fit $\\pm$ 1 $\\sigma$\",\n )\n ax2[2].axvline(beta.value + np.sqrt(covariance[3][3]), lw=1.5, ls=\"--\", color=\"k\")\n ax2[2].legend()\n ax2[2].set_xlabel(r\"$\\beta$\")\n\n figname2 = f\"{config.repo_path}/results/figures/stat_err/{tool}_{which}_sampled_parameters.png\"\n logging.info(f\"saving {figname2}\")\n fig2.savefig(figname2)\n\n # sampled fluxes\n fig3, ax3 = plt.subplots(1, 3, sharey=True, figsize=(12, 8))\n for i, ene in enumerate([\"emin\", \"emid\", \"emax\"]):\n flux_dict = sampled_dict[\"sampled_fluxes\"][ene]\n energy = sampled_dict[\"sampled_fluxes\"][ene][\"value\"] * u.Unit(\n sampled_dict[\"sampled_fluxes\"][\"energy_unit\"]\n )\n log.info(f\"building histogram of sampled fluxes for {energy}\")\n nbins_fluxes = int(len(flux_dict[\"fluxes\"]) / 20)\n bins_fluxes = np.logspace(\n np.log10(np.min(flux_dict[\"fluxes\"])),\n np.log10(np.max(flux_dict[\"fluxes\"])),\n nbins_fluxes,\n )\n ax3[i].hist(\n flux_dict[\"fluxes\"],\n bins=bins_fluxes,\n color=\"lightgray\",\n label=\"sampled fluxes\",\n )\n ax3[i].axvline(\n np.mean(flux_dict[\"fluxes\"]),\n lw=1.5,\n ls=\"-\",\n color=\"k\",\n label=\"mean sampled\",\n )\n ax3[i].axvline(\n flux_dict[\"flux_quantiles\"][0],\n lw=1.5,\n ls=\"--\",\n color=\"k\",\n label=\"68% containment sampled\",\n )\n ax3[i].axvline(flux_dict[\"flux_quantiles\"][1], lw=1.5, ls=\"--\", color=\"k\")\n ax3[i].set_xlabel(\n r\"$F (\\mathrm{TeV}^{-1} \\, \\mathrm{cm}^{-2} \\, \\mathrm{s}^{-1})$\",\n labelpad=9,\n )\n # evaluate normal model and error\n fit_value = model_lp(energy).to(\"TeV-1 cm-2 s-1\").value\n fit_value_err = model_lp.evaluate_error(energy).to(\"TeV-1 cm-2 s-1\").value\n ax3[i].axvline(\n fit_value, lw=2, ls=\"-\", color=\"crimson\", label=\"best fit result\"\n )\n ax3[i].axvline(\n fit_value + fit_value_err[1],\n lw=1.5,\n ls=\"--\",\n color=\"crimson\",\n label=\"error propagation\",\n )\n ax3[i].axvline(fit_value - fit_value_err[1], lw=1.5, ls=\"--\", color=\"crimson\")\n ax3[i].set_title(\"E = {:.2f}\".format(energy))\n ax3[i].legend()\n ax3[i].set_xscale(\"log\")\n\n plt.tight_layout()\n figname3 = (\n f\"{config.repo_path}/results/figures/stat_err/{tool}_{which}_sampled_fluxes.png\"\n )\n logging.info(f\"saving {figname3}\")\n fig3.savefig(figname3)\n\n\ndef counts_histogram(predicted=False):\n \"\"\"function to plot the excesses per dataset and compare them with the predicted counts\n if predicted == True will shwo the predicted counts from the results of the fit (for debug purpose)\n \"\"\"\n log.info(\"loading the results from the joint fit to predict the counts\")\n results = load_yaml(\n f\"{config.repo_path}/results/fit/gammapy/joint/fit_results_logparabola.yaml\"\n )\n parameters = results[\"parameters\"]\n\n model_lp = LogParabola.from_log10(\n amplitude=parameters[0][\"value\"] * u.Unit(parameters[0][\"unit\"]),\n reference=parameters[1][\"value\"] * u.Unit(parameters[1][\"unit\"]),\n alpha=parameters[2][\"value\"] * u.Unit(parameters[2][\"unit\"]),\n beta=parameters[3][\"value\"] * u.Unit(parameters[3][\"unit\"]),\n )\n\n # defining the figure\n dict_color = {\n \"fermi\": COLORS[0],\n \"magic\": COLORS[1],\n \"veritas\": COLORS[2],\n \"fact\": COLORS[3],\n \"hess\": COLORS[4],\n }\n fig, ax = plt.subplots()\n\n for which in config.all_datasets:\n log.info(f\"predicting counts for {which} dataset\")\n dataset = config.get_dataset(which)\n obs = dataset.get_SpectrumObservationList().stack()\n cts_pred = CountsPredictor(\n model=model_lp, aeff=obs.aeff, edisp=obs.edisp, livetime=obs.livetime\n )\n cts_pred.run()\n\n e_max = dataset.energy_range[1].to(\"TeV\").value\n e_min = dataset.energy_range[0].to(\"TeV\").value\n\n kwargs_mdl = dict(ls=\":\", range=(e_min, e_max), lw=2.2, color=dict_color[which])\n kwargs_data = dict(\n ls=\"-\", range=(e_min, e_max), lw=2.2, color=dict_color[which]\n )\n\n # CountsSpectrum with observed and predicted excesses\n ex_pred = cts_pred.npred\n ex_obs = obs.excess_vector\n # if it is an IACT rebin the counts before plotting\n if which != \"fermi\":\n ex_pred = ex_pred.rebin(2)\n ex_obs = ex_obs.rebin(2)\n\n if predicted: # if you want to display the predicted counts\n ex_pred.plot_hist(ax, **kwargs_mdl)\n ex_obs.plot_hist(ax, **kwargs_data)\n\n # custom legend\n legend_observed = mlines.Line2D(\n [], [], color=\"gray\", marker=\"\", ls=\"-\", lw=2, label=\"observed\"\n )\n legend_expected = mlines.Line2D(\n [], [], color=\"gray\", marker=\"\", ls=\":\", lw=2, label=\"expected\"\n )\n legend_fermi = mlines.Line2D(\n [], [], color=COLORS[0], marker=\"\", ls=\"-\", lw=2, label=\"Fermi-LAT\"\n )\n legend_magic = mlines.Line2D(\n [], [], color=COLORS[1], marker=\"\", ls=\"-\", lw=2, label=\"MAGIC\"\n )\n legend_veritas = mlines.Line2D(\n [], [], color=COLORS[2], marker=\"\", ls=\"-\", lw=2, label=\"VERITAS\"\n )\n legend_fact = mlines.Line2D(\n [], [], color=COLORS[3], marker=\"\", ls=\"-\", lw=2, label=\"FACT\"\n )\n legend_hess = mlines.Line2D(\n [], [], color=COLORS[4], marker=\"\", ls=\"-\", lw=2, label=\"H.E.S.S.\"\n )\n legend_handles = [\n legend_fermi,\n legend_magic,\n legend_veritas,\n legend_fact,\n legend_hess,\n ]\n if predicted: # if you want to display the predicted counts\n legend_handles = [legend_observed, legend_expected] + legend_handles\n\n ax.legend(handles=legend_handles, fontsize=FONTSIZE)\n\n ax.set_xscale(\"log\")\n ax.set_ylabel(\"Excess counts\", size=FONTSIZE)\n ax.set_xlabel(E_UNIT_LABEL, size=FONTSIZE)\n\n # make axis thicker\n for axis in [\"top\", \"bottom\", \"left\", \"right\"]:\n ax.spines[axis].set_linewidth(1.6)\n ax.tick_params(\"both\", length=7, width=1.6, which=\"major\", labelsize=FONTSIZE)\n ax.tick_params(\"both\", length=4, width=1.6, which=\"minor\", labelsize=FONTSIZE)\n\n plt.tight_layout()\n\n filename = f\"{config.repo_path}/results/figures/counts_spectra.png\"\n filename_pdf = f\"{config.repo_path}/results/figures/counts_spectra.pdf\"\n log.info(f\"saving figure in {filename}\")\n fig.savefig(filename)\n fig.savefig(filename_pdf)\n\n\ndef butterfly_syst():\n \"\"\"representation of the joint fit result w/ systematics uncertainty\"\"\"\n log.info(\"plotting syst. + stat. butterfly\")\n # reading the joint stat butterfly values\n stat_table_path = Path(\n f\"{config.repo_path}/results/figures/stat_err/joint_flux_errorband.dat\"\n )\n log.info(f\"reading butterfly values from {stat_table_path}\")\n stat_table = Table.read(stat_table_path, format=\"ascii.ecsv\")\n stat_energies = stat_table[\"energies\"].data * stat_table[\"energies\"].unit\n stat_flux_min = stat_table[\"flux_lo\"].data * stat_table[\"flux_lo\"].unit\n stat_flux_max = stat_table[\"flux_hi\"].data * stat_table[\"flux_hi\"].unit\n # load result of stat fit\n stat_result_file = f\"results/fit/gammapy/joint/fit_results_logparabola.yaml\"\n stat_results = load_yaml(stat_result_file)\n\n stat_parameters = stat_results[\"parameters\"]\n\n # best fit parameters\n stat_amplitude = stat_parameters[0][\"value\"] * u.Unit(stat_parameters[0][\"unit\"])\n stat_reference = stat_parameters[1][\"value\"] * u.Unit(stat_parameters[1][\"unit\"])\n stat_alpha = stat_parameters[2][\"value\"] * u.Unit(stat_parameters[2][\"unit\"])\n stat_beta = stat_parameters[3][\"value\"] * u.Unit(stat_parameters[3][\"unit\"])\n\n # reading the joint stat butterfly values\n syst_table_path = Path(\n f\"{config.repo_path}/results/figures/syst_err/joint_flux_errorband.dat\"\n )\n log.info(f\"reading butterfly values from {syst_table_path}\")\n syst_table = Table.read(syst_table_path, format=\"ascii.ecsv\")\n syst_energies = syst_table[\"energies\"].data * syst_table[\"energies\"].unit\n syst_flux_min = syst_table[\"flux_lo\"].data * syst_table[\"flux_lo\"].unit\n syst_flux_max = syst_table[\"flux_hi\"].data * syst_table[\"flux_hi\"].unit\n\n # load result of syst fit\n syst_result_file = (\n f\"results/fit/gammapy/joint/fit_results_logparabola_energy_scale.yaml\"\n )\n syst_results = load_yaml(syst_result_file)\n\n syst_parameters = syst_results[\"parameters\"]\n\n # best fit parameters\n syst_amplitude = syst_parameters[0][\"value\"] * u.Unit(syst_parameters[0][\"unit\"])\n syst_reference = syst_parameters[1][\"value\"] * u.Unit(syst_parameters[1][\"unit\"])\n syst_alpha = syst_parameters[2][\"value\"] * u.Unit(syst_parameters[2][\"unit\"])\n syst_beta = syst_parameters[3][\"value\"] * u.Unit(syst_parameters[3][\"unit\"])\n\n fig = plt.figure()\n gs = gridspec.GridSpec(2, 1, height_ratios=[2.5, 1], wspace=0.)\n ax0 = plt.subplot(gs[0])\n ax1 = plt.subplot(gs[1], sharex=ax0)\n\n ax0.fill_between(\n syst_energies.to(\"TeV\"),\n (syst_energies ** 2 * syst_flux_min).to(\"erg cm-2 s-1\"),\n (syst_energies ** 2 * syst_flux_max).to(\"erg cm-2 s-1\"),\n color=\"#002E63\",\n alpha=0.4,\n label=\"stat. + syst.\",\n )\n\n ax0.fill_between(\n stat_energies.to(\"TeV\"),\n (stat_energies ** 2 * stat_flux_min).to(\"erg cm-2 s-1\"),\n (stat_energies ** 2 * stat_flux_max).to(\"erg cm-2 s-1\"),\n color=\"crimson\",\n alpha=0.4,\n label=\"stat. only\",\n )\n\n stat_flux = Log10Parabola.evaluate(\n stat_energies, stat_amplitude, stat_reference, stat_alpha, stat_beta\n )\n\n ax0.plot(\n stat_energies.to(\"TeV\"),\n (stat_energies ** 2 * stat_flux).to(\"erg cm-2 s-1\"),\n color=\"crimson\",\n lw=2.2,\n ls=\"-\",\n )\n\n syst_flux = Log10Parabola.evaluate(\n syst_energies, syst_amplitude, syst_reference, syst_alpha, syst_beta\n )\n\n ax0.plot(\n syst_energies.to(\"TeV\"),\n (syst_energies ** 2 * syst_flux).to(\"erg cm-2 s-1\"),\n color=\"#002E63\",\n lw=2.2,\n ls=\"-\",\n )\n\n ax0.set_xscale(\"log\")\n ax0.set_yscale(\"log\")\n ax0.set_ylabel(SED_UNIT_LABEL, size=FONTSIZE)\n ax0.legend(fontsize=FONTSIZE, loc=3)\n # make axis thicker\n for axis in [\"top\", \"bottom\", \"left\", \"right\"]:\n ax0.spines[axis].set_linewidth(1.6)\n ax0.tick_params(\"both\", length=7, width=1.6, which=\"major\", labelsize=FONTSIZE)\n ax0.tick_params(\"both\", length=4, width=1.6, which=\"minor\", labelsize=FONTSIZE)\n\n # plot the flux ratios\n ax1.fill_between(\n syst_energies.to(\"TeV\"),\n (syst_flux_min - stat_flux) / stat_flux,\n (syst_flux_max - stat_flux) / stat_flux,\n color=\"#002E63\",\n alpha=0.4,\n label=\"stat. + syst.\",\n )\n\n ax1.fill_between(\n stat_energies.to(\"TeV\"),\n (stat_flux_min - stat_flux) / stat_flux,\n (stat_flux_max - stat_flux) / stat_flux,\n color=\"crimson\",\n alpha=0.4,\n label=\"stat. only\",\n )\n\n ax1.plot(\n stat_energies.to(\"TeV\"),\n (stat_flux - stat_flux) / stat_flux,\n color=\"crimson\",\n lw=2.2,\n ls=\"-\",\n )\n\n ax1.plot(\n syst_energies.to(\"TeV\"),\n (syst_flux - stat_flux) / stat_flux,\n color=\"#002E63\",\n lw=2.2,\n ls=\"-\",\n )\n\n ax1.set_xscale(\"log\")\n ax1.set_ylim([-0.35, 0.35])\n ax1.set_xlabel(E_UNIT_LABEL, size=FONTSIZE)\n ax1.set_ylabel(\"fractional diff. \\n to stat.\", size=FONTSIZE)\n # make axis thicker\n for axis in [\"top\", \"bottom\", \"left\", \"right\"]:\n ax1.spines[axis].set_linewidth(1.6)\n ax1.tick_params(\"both\", length=7, width=1.6, which=\"major\", labelsize=FONTSIZE)\n ax1.tick_params(\"both\", length=4, width=1.6, which=\"minor\", labelsize=FONTSIZE)\n\n plt.tight_layout()\n\n filename = \"results/figures/crab_sed_joint_fit_syst.png\"\n filename_pdf = \"results/figures/crab_sed_joint_fit_syst.pdf\"\n log.info(f\"Writing {filename}\")\n fig.savefig(filename)\n fig.savefig(filename_pdf)\n\n\ndef syst_contour():\n \"\"\"plot a comparison of the contours obtained with the wstat statistics\n and with the stat + syst likelihood\"\"\"\n\n fig, axarr = plt.subplots(1, 3, figsize=(16, 5))\n\n # first plot in light gray the stat contours\n instruments = [\"fermi\", \"magic\", \"veritas\", \"fact\", \"hess\", \"joint\"]\n\n # with one loop we realize all the contour plots\n color = \"lightgray\"\n for instrument in instruments:\n path = f\"{config.repo_path}/results/fit/gammapy/{instrument}\"\n\n contours_path = f\"{path}/fit_1.0_sigma_contours_logparabola.npy\"\n results_path = f\"{path}/fit_results_logparabola.yaml\"\n\n # load the contours and the results of the fit\n contours = np.load(contours_path).tolist()\n results = load_yaml(results_path)\n # true values to be plotted\n amplitude = float(results[\"parameters\"][0][\"value\"])\n alpha = float(results[\"parameters\"][2][\"value\"])\n beta = float(results[\"parameters\"][3][\"value\"])\n\n # amplitude vs alpha\n amplitude_alpha = contours[\"contour_amplitude_alpha\"]\n axarr[0].plot(\n amplitude_alpha[\"amplitude\"] * 10,\n amplitude_alpha[\"alpha\"],\n marker=\"\",\n ls=\"-\",\n lw=2.5,\n color=color,\n )\n # plot actual value\n axarr[0].plot(\n amplitude * 1e11, alpha, marker=\"X\", markersize=7, color=color, lw=2.5\n )\n\n # amplitude vs beta\n amplitude_beta = contours[\"contour_amplitude_beta\"]\n axarr[1].plot(\n amplitude_beta[\"amplitude\"] * 10,\n # contour have a scale factor of 1e-10, parameters are in units of 1e-11\n amplitude_beta[\"beta\"],\n marker=\"\",\n ls=\"-\",\n lw=2.5,\n color=color,\n )\n # plot actual value\n axarr[1].plot(amplitude * 1e11, beta, marker=\"X\", markersize=7, color=color)\n\n # alpha vs beta\n alpha_beta = contours[\"contour_alpha_beta\"]\n axarr[2].plot(\n alpha_beta[\"alpha\"],\n alpha_beta[\"beta\"],\n marker=\"\",\n ls=\"-\",\n lw=2.5,\n color=color,\n )\n # plot actual value\n axarr[2].plot(alpha, beta, marker=\"X\", markersize=7, color=color)\n\n # plotting stat vs syst result on top of instrument-wise contours in gray\n path = config.repo_path / f\"results/fit/gammapy/joint\"\n\n stat_contours_path = f\"{path}/fit_1.0_sigma_contours_logparabola.npy\"\n stat_results_path = f\"{path}/fit_results_logparabola.yaml\"\n\n syst_contours_path = f\"{path}/fit_1.0_sigma_contours_logparabola_energy_scale.npy\"\n syst_results_path = f\"{path}/fit_results_logparabola_energy_scale.yaml\"\n\n for (contours_path, results_path, color, label) in zip(\n [stat_contours_path, syst_contours_path],\n [stat_results_path, syst_results_path],\n [\"crimson\", \"#002E63\"],\n [\"stat. only\", \"stat. + syst.\"],\n ):\n # load the contours and the results of the fit\n contours = np.load(contours_path).tolist()\n results = load_yaml(results_path)\n # true values to be plotted\n amplitude = float(results[\"parameters\"][0][\"value\"])\n alpha = float(results[\"parameters\"][2][\"value\"])\n beta = float(results[\"parameters\"][3][\"value\"])\n\n # amplitude vs alpha\n amplitude_alpha = contours[\"contour_amplitude_alpha\"]\n if label == \"stat. only\":\n axarr[0].plot(\n amplitude_alpha[\"amplitude\"] * 10,\n # gammapy contour have a scale factor of 1e-10, parameters are in units of 1e-11\n amplitude_alpha[\"alpha\"],\n marker=\"\",\n ls=\"-\",\n lw=2.5,\n color=color,\n )\n else:\n axarr[0].plot(\n amplitude_alpha[\"amplitude\"] * 1e11,\n amplitude_alpha[\"alpha\"],\n marker=\"\",\n ls=\"-\",\n lw=2.5,\n color=color,\n )\n\n # plot actual value\n axarr[0].plot(\n amplitude * 1e11, alpha, marker=\"X\", markersize=7, color=color, lw=2.5\n )\n\n # amplitude vs beta\n amplitude_beta = contours[\"contour_amplitude_beta\"]\n if label == \"stat. only\":\n axarr[1].plot(\n amplitude_beta[\"amplitude\"] * 10,\n # gammapy contour have a scale factor of 1e-10, parameters are in units of 1e-11\n amplitude_beta[\"beta\"],\n marker=\"\",\n ls=\"-\",\n lw=2.5,\n color=color,\n )\n else:\n axarr[1].plot(\n amplitude_beta[\"amplitude\"] * 1e11,\n amplitude_beta[\"beta\"],\n marker=\"\",\n ls=\"-\",\n lw=2.5,\n color=color,\n )\n\n # plot actual value\n axarr[1].plot(amplitude * 1e11, beta, marker=\"X\", markersize=7, color=color)\n\n # alpha vs beta\n alpha_beta = contours[\"contour_alpha_beta\"]\n axarr[2].plot(\n alpha_beta[\"alpha\"],\n alpha_beta[\"beta\"],\n marker=\"\",\n ls=\"-\",\n lw=2.5,\n color=color,\n )\n # plot actual value\n axarr[2].plot(alpha, beta, marker=\"X\", markersize=7, color=color)\n\n # legend\n import matplotlib.lines as mlines\n\n stat_label = mlines.Line2D(\n [],\n [],\n color=\"crimson\",\n marker=\"\",\n ls=\"-\",\n lw=2.5,\n label=\"joint fit \\n stat. only\",\n )\n syst_label = mlines.Line2D(\n [],\n [],\n color=\"#002E63\",\n marker=\"\",\n ls=\"-\",\n lw=2.5,\n label=\"joint fit \\n stat. + syst.\",\n )\n single_label = mlines.Line2D(\n [],\n [],\n color=\"lightgray\",\n marker=\"\",\n ls=\"-\",\n lw=2.5,\n label=\"instr. fit \\n stat. only\",\n )\n\n axarr[0].set_xlabel(\n r\"$\\phi_0 \\,/\\,(10^{-11}\\,{\\rm TeV} \\, {\\rm cm}^{-2} {\\rm s}^{-1})$\",\n size=FONTSIZE_CONTOURS,\n )\n axarr[0].set_ylabel(r\"$\\Gamma$\", size=FONTSIZE_CONTOURS)\n # make axis thicker\n axarr[0].set_yticks([2.2, 2.4, 2.6, 2.8])\n axarr[0].set_ylim([2.1, 2.9])\n axarr[0].set_xticks([3, 4, 5])\n axarr[0].set_xlim([2.8, 5.2])\n for axis in [\"top\", \"bottom\", \"left\", \"right\"]:\n axarr[0].spines[axis].set_linewidth(2.5)\n axarr[0].tick_params(\n \"both\", length=7, width=1.6, which=\"major\", labelsize=FONTSIZE_CONTOURS\n )\n axarr[0].tick_params(\n \"both\", length=4, width=1.6, which=\"minor\", labelsize=FONTSIZE_CONTOURS\n )\n\n axarr[1].set_xlabel(\n r\"$\\phi_0 \\,/\\,(10^{-11}\\,{\\rm TeV} \\, {\\rm cm}^{-2} {\\rm s}^{-1})$\",\n size=FONTSIZE_CONTOURS,\n )\n axarr[1].set_ylabel(r\"$\\beta$\", size=FONTSIZE_CONTOURS)\n # make axis thicker\n axarr[1].set_xticks([3, 4, 5])\n axarr[1].set_xlim([2.8, 5.2])\n axarr[1].set_yticks([0.2, 0.4, 0.6])\n axarr[1].set_ylim([0.0, 0.8])\n for axis in [\"top\", \"bottom\", \"left\", \"right\"]:\n axarr[1].spines[axis].set_linewidth(2.5)\n axarr[1].tick_params(\n \"both\", length=7, width=1.6, which=\"major\", labelsize=FONTSIZE_CONTOURS\n )\n axarr[1].tick_params(\n \"both\", length=4, width=1.6, which=\"minor\", labelsize=FONTSIZE_CONTOURS\n )\n\n axarr[2].set_xlabel(r\"$\\Gamma$\", size=FONTSIZE_CONTOURS)\n axarr[2].set_ylabel(r\"$\\beta$\", size=FONTSIZE_CONTOURS)\n axarr[2].set_xticks([2.2, 2.4, 2.6, 2.8])\n axarr[2].set_xlim([2.1, 2.9])\n axarr[2].set_yticks([0.2, 0.4, 0.6])\n axarr[2].set_ylim([0.0, 0.8])\n # make axis thicker\n for axis in [\"top\", \"bottom\", \"left\", \"right\"]:\n axarr[2].spines[axis].set_linewidth(2.5)\n axarr[2].tick_params(\n \"both\", length=7, width=1.6, which=\"major\", labelsize=FONTSIZE_CONTOURS\n )\n axarr[2].tick_params(\n \"both\", length=4, width=1.6, which=\"minor\", labelsize=FONTSIZE_CONTOURS\n )\n\n box = axarr[2].get_position()\n axarr[2].set_position([box.x0, box.y0, box.width * 0.97, box.height])\n # plot the legend on top of the central plot\n axarr[2].legend(\n handles=[stat_label, syst_label, single_label],\n loc=\"center left\",\n fontsize=FONTSIZE_CONTOURS,\n bbox_to_anchor=(1., 0.5),\n )\n\n plt.tight_layout()\n filename = \"results/figures/iminuit_logparabola_energy_scale_contour.png\"\n filename_pdf = \"results/figures/iminuit_logparabola_energy_scale_contour.pdf\"\n fig.savefig(filename)\n log.info(f\"Writing {filename}\")\n fig.savefig(filename)\n fig.savefig(filename_pdf)\n", "meta": {"hexsha": "31aa639c9883f2b0ccda5c07050896ffd338a5dd", "size": 43883, "ext": "py", "lang": "Python", "max_stars_repo_path": "joint_crab/figures.py", "max_stars_repo_name": "Bultako/public-joint-crab", "max_stars_repo_head_hexsha": "2efcfa423b4ab682c8a28398d2bd04e5582616a1", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "joint_crab/figures.py", "max_issues_repo_name": "Bultako/public-joint-crab", "max_issues_repo_head_hexsha": "2efcfa423b4ab682c8a28398d2bd04e5582616a1", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "joint_crab/figures.py", "max_forks_repo_name": "Bultako/public-joint-crab", "max_forks_repo_head_hexsha": "2efcfa423b4ab682c8a28398d2bd04e5582616a1", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.1908580593, "max_line_length": 104, "alphanum_fraction": 0.5807032336, "include": true, "reason": "import numpy,from astropy", "num_tokens": 12555, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792044, "lm_q2_score": 0.3886180267058489, "lm_q1q2_score": 0.1973448446340028}} {"text": "import torch.nn as nn\nimport torch.nn.functional as F\nimport torch\n\nimport numpy as np\n\n\n \ndef model_box_to_xy_ori(box,ori_im_shape,prior_w = 0.5, prior_cx=0.5, prior_cy=0.5,size_variance = 0.1,center_variance = 0.1):\n \n box[:,0] = (box[:,0] * center_variance + prior_cx * 2.0)/2.0\n box[:,1] = (box[:,1] * center_variance + prior_cy * 2.0)/2.0\n box[:,2] = torch.exp(box[:,2] * size_variance) * prior_w\n box[:,3] = torch.exp(box[:,3] * size_variance) * prior_w\n \n box_numpy = box.cpu().numpy()\n \n box_xyxy = np.zeros((box_numpy.shape[0],4),dtype = 'float32')\n \n \n \n \n box_xyxy[:,0] = box_numpy[:,0] - box_numpy[:,2]/2.0\n box_xyxy[:,1] = box_numpy[:,1] - box_numpy[:,3]/2.0\n box_xyxy[:,2] = box_numpy[:,0] + box_numpy[:,2]/2.0\n box_xyxy[:,3] = box_numpy[:,1] + box_numpy[:,3]/2.0\n \n return box_xyxy\n\ndef model_box_to_xy_ori_l1(box):\n \n \n \n box_numpy = box.cpu().numpy()\n \n box_xyxy = np.zeros((box_numpy.shape[0],4),dtype = 'float32')\n \n \n \n \n box_xyxy[:,0] = box_numpy[:,0] - box_numpy[:,2]/2.0\n box_xyxy[:,1] = box_numpy[:,1] - box_numpy[:,3]/2.0\n box_xyxy[:,2] = box_numpy[:,0] + box_numpy[:,2]/2.0\n box_xyxy[:,3] = box_numpy[:,1] + box_numpy[:,3]/2.0\n \n return box_xyxy\n\n\ndef norm_box_to_abs(box_norm,ori_im_shape):\n box = box_norm.copy()\n box[0] *=ori_im_shape[1]\n box[1] *=ori_im_shape[0]\n box[2] *=ori_im_shape[1]\n box[3] *=ori_im_shape[0]\n return box\n\n\ndef area_of(left_top, right_bottom) -> torch.Tensor:\n \"\"\"Compute the areas of rectangles given two corners.\n\n Args:\n left_top (N, 2): left top corner.\n right_bottom (N, 2): right bottom corner.\n\n Returns:\n area (N): return the area.\n \"\"\"\n hw = torch.clamp(right_bottom - left_top, min=0.0)\n return hw[..., 0] * hw[..., 1]\n\n\ndef iou_of(boxes0, boxes1, eps=1e-5):\n \"\"\"Return intersection-over-union (Jaccard index) of boxes.\n\n Args:\n boxes0 (N, 4): ground truth boxes.\n boxes1 (N or 1, 4): predicted boxes.\n eps: a small number to avoid 0 as denominator.\n Returns:\n iou (N): IoU values.\n \"\"\"\n overlap_left_top = torch.max(boxes0[..., :2], boxes1[..., :2])\n overlap_right_bottom = torch.min(boxes0[..., 2:], boxes1[..., 2:])\n\n overlap_area = area_of(overlap_left_top, overlap_right_bottom)\n area0 = area_of(boxes0[..., :2], boxes0[..., 2:])\n area1 = area_of(boxes1[..., :2], boxes1[..., 2:])\n return overlap_area / (area0 + area1 - overlap_area + eps)\n\n \n \ndef iou_ori(box_pred,box_gt,ori_im_shape):\n # one box input\n b_pred = torch.from_numpy(box_pred)\n b_gt = torch.from_numpy(box_gt)\n \n \n \n b_gt[:,0] *=ori_im_shape[1]\n b_gt[:,1] *=ori_im_shape[0]\n b_gt[:,2] *=ori_im_shape[1]\n b_gt[:,3] *=ori_im_shape[0]\n\n b_pred[:,0] *=ori_im_shape[1]\n b_pred[:,1] *=ori_im_shape[0]\n b_pred[:,2] *=ori_im_shape[1]\n b_pred[:,3] *=ori_im_shape[0]\n\n\n return iou_of(b_pred,b_gt)\n \n\n\n#class Location_Box_Loss(nn.Module):\n# def __init__(self,prior_w = 0.5, prior_cx=0.5, prior_cy=0.5,size_variance = 0.1,center_variance = 0.1):\n# \"\"\"Implement Loss of box locolization\n#\n# smooth L1 regression loss.\n# \"\"\"\n# super(Location_Box_Loss, self).__init__()\n# self.prior_w = prior_w\n# \n# self.prior_cx = prior_cx\n# self.prior_cy = prior_cy\n# \n# self.size_variance = size_variance\n# self.center_variance = center_variance\n#\n# def forward(self, gt_box, predicted_vec):\n# \"\"\"\n# # predicted_vec x_center(-1,1) /center_variance\n# y_center(-1,1) /center_variance\n# w ( -inf, inf) 0-1x, 1-2.7x -1 -0.36x /size_variance\n# \"\"\"\n# ww_gt = gt_box[:,2] - gt_box[:,0]\n# ww_gt_tr = torch.log(ww_gt/self.prior_w)/self.size_variance\n# \n# hh_gt = gt_box[:,3] - gt_box[:,1]\n# hh_gt_tr = torch.log(hh_gt/self.prior_w)/self.size_variance\n# \n# xx_gt_tr = ((gt_box[:,2] + gt_box[:,0]) - self.prior_cx * 2.0)/ self.center_variance # (0.1) -> (-1,1) \n# yy_gt_tr = ((gt_box[:,3] + gt_box[:,1]) - self.prior_cy * 2.0)/ self.center_variance # (0.1) -> (-1,1) \n# \n# loss_xx = F.smooth_l1_loss(predicted_vec[:,0], xx_gt_tr, size_average=True) \n# loss_yy = F.smooth_l1_loss(predicted_vec[:,1], yy_gt_tr, size_average=True) \n# \n# loss_ww = F.smooth_l1_loss(predicted_vec[:,2], ww_gt_tr, size_average=True) \n# loss_hh = F.smooth_l1_loss(predicted_vec[:,3], hh_gt_tr, size_average=True) \n# \n# \n# loss = loss_xx + loss_yy + loss_ww + loss_hh\n# return loss,loss_xx,loss_yy,loss_ww,loss_hh\n\n \n\n\nclass Location_Box_Loss(nn.Module):\n def __init__(self,prior_w = 0.5, prior_cx=0.5, prior_cy=0.5,size_variance = 0.1,center_variance = 0.1):\n \"\"\"Implement Loss of box locolization\n\n smooth L1 regression loss.\n \"\"\"\n super(Location_Box_Loss, self).__init__()\n self.prior_w = prior_w\n \n self.prior_cx = prior_cx\n self.prior_cy = prior_cy\n \n self.size_variance = size_variance\n self.center_variance = center_variance\n\n def forward(self, gt_box, predicted_vec):\n \"\"\"\n # predicted_vec x_center(-1,1) /center_variance\n y_center(-1,1) /center_variance\n w ( -inf, inf) 0-1x, 1-2.7x -1 -0.36x /size_variance\n \"\"\"\n ww_gt = gt_box[:,2] - gt_box[:,0] # (0,1)\n #ww_gt_tr = torch.log(ww_gt/self.prior_w)/self.size_variance\n \n hh_gt = gt_box[:,3] - gt_box[:,1]\n #hh_gt_tr = torch.log(hh_gt/self.prior_w)/self.size_variance\n \n xx_gt_tr = (gt_box[:,2] + gt_box[:,0])/2.0 #(0.1) \n yy_gt_tr = (gt_box[:,3] + gt_box[:,1])/2.0 # (0.1) \n \n #loss_xx = F.smooth_l1_loss(predicted_vec[:,0], xx_gt_tr, size_average=True) \n #loss_yy = F.smooth_l1_loss(predicted_vec[:,1], yy_gt_tr, size_average=True) \n \n #loss_ww = F.smooth_l1_loss(predicted_vec[:,2], ww_gt, size_average=True) \n #loss_hh = F.smooth_l1_loss(predicted_vec[:,3], hh_gt, size_average=True) \n \n \n loss_xx = F.l1_loss(predicted_vec[:,0], xx_gt_tr, size_average=True) \n loss_yy = F.l1_loss(predicted_vec[:,1], yy_gt_tr, size_average=True) \n \n loss_ww = F.l1_loss(predicted_vec[:,2], ww_gt, size_average=True) \n loss_hh = F.l1_loss(predicted_vec[:,3], hh_gt, size_average=True) \n \n loss = loss_xx + loss_yy + loss_ww + loss_hh\n return loss,loss_xx,loss_yy,loss_ww,loss_hh\n\n\n\nclass Location_Box_CenterNet(nn.Module):\n def __init__(self):\n \"\"\"Implement Loss of box locolization\n\n hm focal-loss xywh L1 regression loss.\n \"\"\"\n super(Location_Box_CenterNet, self).__init__()\n\n\n def forward(self, gt_box, pred):\n \n #score\n hm = gt_box['hm'] \n pred_s = pred[:,0:1,...]\n pos_inds = hm.eq(1).float()\n neg_inds = hm.lt(1).float()\n\n neg_weights = torch.pow(1.0 - hm, 4)\n pos_loss = torch.log(pred_s) * torch.pow(1 - pred_s, 2) * pos_inds\n neg_loss = torch.log(1 - pred_s) * torch.pow(pred_s, 2) * neg_weights * neg_inds\n\n num_pos = pos_inds.float().sum()\n pos_loss = pos_loss.sum()\n neg_loss = neg_loss.sum()\n \n loss_s = -(pos_loss + neg_loss) / num_pos\n\n \n\n dense_xy = gt_box['dense_xy']\n dense_wh = gt_box['dense_wh']\n dense_mask = gt_box['dense_mask']\n pred_xy = pred[:,1:3,...]\n pred_wh = pred[:,3:,...]\n\n \n loss_xy = F.l1_loss(pred_xy*dense_mask,dense_xy*dense_mask,size_average=False) / num_pos\n loss_wh = F.l1_loss(pred_wh*dense_mask,dense_wh*dense_mask,size_average=False) / num_pos\n \n loss = loss_s + loss_xy + loss_wh\n return loss,loss_s,loss_xy,loss_wh\n\n\n", "meta": {"hexsha": "22fe822ce78d18976d7207d02c2126acd41071d5", "size": 7988, "ext": "py", "lang": "Python", "max_stars_repo_path": "modeling/location_box_loss.py", "max_stars_repo_name": "zyxwvu321/Classifer_SSL_Longtail", "max_stars_repo_head_hexsha": "e6c09414c49e695b0f4221a3c6245ae3929a1788", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "modeling/location_box_loss.py", "max_issues_repo_name": "zyxwvu321/Classifer_SSL_Longtail", "max_issues_repo_head_hexsha": "e6c09414c49e695b0f4221a3c6245ae3929a1788", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "modeling/location_box_loss.py", "max_forks_repo_name": "zyxwvu321/Classifer_SSL_Longtail", "max_forks_repo_head_hexsha": "e6c09414c49e695b0f4221a3c6245ae3929a1788", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.2096774194, "max_line_length": 126, "alphanum_fraction": 0.5846269404, "include": true, "reason": "import numpy", "num_tokens": 2470, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792044, "lm_q2_score": 0.3886180267058489, "lm_q1q2_score": 0.1973448446340028}} {"text": "#!/usr/bin/env python\n\n\"\"\"\"\nSimple implementation of http://arxiv.org/pdf/1502.04623v2.pdf in TensorFlow\n\nExample Usage: \n python train.py --data_file= --log_dir=\n\nAuthor: Anurag Vempati\n\"\"\"\n\nimport tensorflow as tf\nimport numpy as np\nimport os\nimport sys\nimport math\nimport time\nfrom tqdm import tqdm\nfrom config import train_config\nfrom model import DrawModel\n\ntf.flags.DEFINE_string(\"data_file\", \"\", \"\")\ntf.flags.DEFINE_string(\"log_dir\", \"\", \"\")\nFLAGS = tf.flags.FLAGS\n\n\ndef export_config(config, output_file):\n \"\"\"\n Write the configuration parameters into a human readable file.\n :param config: the configuration dictionary\n :param output_file: the output text file\n \"\"\"\n if not output_file.endswith('.txt'):\n output_file.append('.txt')\n max_key_length = np.amax([len(k) for k in config.keys()])\n with open(output_file, 'w') as f:\n for k in sorted(config.keys()):\n out_string = '{:<{width}}: {}\\n'.format(k, config[k], width=max_key_length)\n f.write(out_string)\n\n \ndef load_data(config, data_file):\n print('Loading data from {} ...'.format(data_file))\n\n # Reads an image from a file, decodes it into a dense tensor, and resizes it\n # to a fixed shape.\n def _parse_function(filename):\n data_fmt = {\n \"height\": tf.FixedLenFeature((), tf.int64, -1),\n \"width\": tf.FixedLenFeature((), tf.int64, -1),\n \"depth\": tf.FixedLenFeature((), tf.int64, -1),\n \"image_raw\": tf.FixedLenFeature((), tf.string, \"\")\n }\n \n parsed_data = tf.parse_single_example(filename, data_fmt)\n image_gray = tf.image.decode_jpeg(parsed_data[\"image_raw\"], channels=1)\n image_converted = tf.image.convert_image_dtype(image_gray, tf.float32)\n image_resized = tf.image.resize_images(image_converted, [config['A'], config['B']])\n image_flattened = tf.reshape(image_resized, [-1])\n return_image = image_flattened\n if not config['draw_with_white']:\n return_image = 1.0 - image_flattened\n return_image = tf.clip_by_value(return_image, 0.0, 0.99) # for numeric stability during arctanh() operation\n return return_image\n\n if not os.path.exists(data_file):\n print(\"Data TFRecord not found\")\n sys.exit()\n \n data_files = tf.data.Dataset.list_files(data_file)\n dataset = data_files.interleave(tf.data.TFRecordDataset, cycle_length=2)\n dataset = dataset.map(map_func=_parse_function, num_parallel_calls=4)\n epoch_counter = tf.data.TFRecordDataset.range(config['n_epochs'])\n dataset = epoch_counter.flat_map(lambda i: tf.data.Dataset.zip(\n (dataset, tf.data.Dataset.from_tensors(i).repeat())))\n dataset = dataset.repeat()\n dataset = dataset.batch(config['batch_size'])\n dataset = dataset.prefetch(buffer_size=config['batch_size'])\n dataset_iterator = dataset.make_one_shot_iterator()\n next_data_batch = dataset_iterator.get_next()\n \n return next_data_batch\n\n\ndef get_model_and_placeholders(config):\n # create placeholders that we need to feed the required data into the model\n input_pl = tf.placeholder(tf.float32, shape=(config['batch_size'], config['img_size']))\n canvas_pl = tf.placeholder(tf.float32, shape=(config['batch_size'], config['img_size']))\n placeholders = {'input_pl': input_pl,\n 'canvas_pl': canvas_pl}\n return DrawModel, placeholders\n\n\ndef main(config):\n # create unique output directory for this model\n timestamp = str(int(time.time()))\n config['model_dir'] = os.path.abspath(os.path.join(FLAGS.log_dir, 'DRAW' + '_' + timestamp))\n os.makedirs(config['model_dir'])\n print('Logging data to {}'.format(config['model_dir']))\n \n # Export configuration for the current run\n export_config(config, os.path.join(config['model_dir'], 'config.txt'))\n \n # load the data\n next_data_batch = load_data(config, FLAGS.data_file)\n\n # get input placeholders and get the model that we want to train\n draw_model_class, placeholders = get_model_and_placeholders(config)\n \n # create a training graph, this is the graph we will use to optimize the parameters\n print('Building training graph')\n with tf.name_scope('training'):\n draw_model = draw_model_class(config, placeholders, mode='training', annealing_schedules=config['annealing_schedules'])\n draw_model.build_graph()\n print('created DRAW model with {} parameters'.format(draw_model.n_parameters))\n \n print('Building valid graph')\n with tf.name_scope('validation'):\n draw_model_valid = draw_model_class(config, placeholders, mode='validation', annealing_schedules=config['annealing_schedules'])\n draw_model_valid.build_graph()\n print('Finished Building valid graphs')\n \n with tf.Session() as sess:\n # Add the ops to initialize variables.\n init_op = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer())\n # Actually intialize the variables\n sess.run(init_op)\n \n # Summaries\n training_summaries = tf.summary.merge(tf.get_collection('training_summaries'))\n train_writer = tf.summary.FileWriter(config['model_dir'] + '/summary/train', sess.graph)\n valid_summaries = tf.summary.merge(tf.get_collection('validation_summaries'))\n valid_writer = tf.summary.FileWriter(config['model_dir'] + '/summary/validation', sess.graph)\n \n # create a saver for writing training checkpoints\n saver = tf.train.Saver(var_list=tf.trainable_variables(), max_to_keep=50)\n\n # start training\n draw_T = config['T']\n# lowest_test_loss = 1.0e6\n last_saved_epoch = 0 # epoch corresponding to last saved chkpnt\n iteration = 0\n previous_epoch = 0\n epoch = 0\n with tqdm() as pbar:\n while epoch < config['n_epochs']:\n # Next data batch\n previous_epoch = epoch\n xnext, epoch = sess.run(next_data_batch)\n epoch = epoch[0]\n if (previous_epoch > 0 and epoch == 0): break\n \n step = tf.train.global_step(sess, draw_model.global_step)\n \n # Hot start\n if config['use_hot_start']:\n crop_fraction = (epoch + 1) * config['crop_fraction_increase_rate']\n if crop_fraction >= 1.0:\n cnext = np.zeros([config['batch_size'], config['img_size']])\n draw_T = config['T']\n else:\n xnext_reshaped = np.copy(xnext)\n xnext_reshaped = xnext_reshaped.reshape((config['batch_size'], config['B'], config['A']))\n start_row = np.random.randint(config['B'] * (1 - crop_fraction)) # , size=config['batch_size'])\n start_col = np.random.randint(config['A'] * (1 - crop_fraction)) # , size=config['batch_size'])\n xnext_reshaped[:, start_row:start_row + int(crop_fraction * config['B']), \\\n start_col:start_col + int(crop_fraction * config['A'])] = 0.0\n cnext = np.reshape(xnext_reshaped, (config['batch_size'], config['img_size']))\n draw_T = max(1, int(config['T'] * crop_fraction))\n else:\n cnext = np.zeros([config['batch_size'], config['img_size']])\n draw_T = config['T']\n \n # Validate every 100th iteration\n if iteration % 100 == 0:\n valid_feed_dict = draw_model_valid.get_feed_dict(xnext, cnext)\n valid_feed_dict[draw_model_valid.T] = draw_T\n valid_feed_dict[draw_model_valid.global_step] = step\n valid_fetches = {'summaries': valid_summaries,\n 'reconstruction_loss': draw_model_valid.Lx,\n 'latent_loss': draw_model_valid.Lz,\n 'write_loss': draw_model_valid.Lwrite,\n 'intensity_change_loss': draw_model_valid.Lintensity,\n 'movement_loss': draw_model_valid.Lmove,\n 'loss': draw_model_valid.loss}\n valid_out = sess.run(valid_fetches, valid_feed_dict)\n # For saving plot data\n xlog = xnext\n cost = valid_out['loss']\n print(\"epoch=%d, iter=%d : Lx: %f Lz: %f Lwrite: %f cost: %f\" % \\\n (epoch, iteration, valid_out['reconstruction_loss'], valid_out['latent_loss'], valid_out['write_loss'], cost))\n valid_writer.add_summary(valid_out['summaries'], global_step=step)\n # save this checkpoint if necessary\n if (epoch - last_saved_epoch + 1) >= config['save_checkpoints_every_epoch']: # and cost < lowest_test_loss:\n last_saved_epoch = epoch\n # lowest_test_loss = cost\n saver.save(sess, os.path.join(config['model_dir'], 'drawmodel'), epoch)\n else:\n train_feed_dict = draw_model.get_feed_dict(xnext, cnext)\n train_feed_dict[draw_model.T] = draw_T\n train_fetches = {'summaries': training_summaries,\n 'train_op': draw_model.train_op}\n train_out = sess.run(train_fetches, train_feed_dict)\n if iteration % 100 == 1:\n train_writer.add_summary(train_out['summaries'], global_step=step)\n \n iteration += 1\n pbar.update(1)\n \n print('Training finished.')\n\n # # Logging + Visualization\n log_fetches = {'canvases': draw_model_valid.cs.stack(), 'read_bbs': draw_model_valid.read_bb.stack(), \\\n 'write_bbs': draw_model_valid.write_bb.stack(), 'write_times': draw_model_valid.stop_times}\n log_out = sess.run(log_fetches, valid_feed_dict) # generate some examples\n canvases = np.array(log_out['canvases']) # T x batch x img_size\n read_bounding_boxes = np.array(log_out['read_bbs']) # T x batch x 3\n write_bounding_boxes = np.array(log_out['write_bbs']) # T x batch x 3\n write_times = np.array(log_out['write_times']) # batch\n \n log_file = os.path.join(config['model_dir'], \"draw_data.npy\")\n np.save(log_file, [xlog, canvases, read_bounding_boxes, write_bounding_boxes, write_times, config['draw_with_white']])\n print(\"Visualization outputs saved in file: %s\" % log_file)\n \n ckpt_file = os.path.join(config['model_dir'], \"drawmodel.ckpt\")\n print(\"Model saved in file: %s\" % saver.save(sess, ckpt_file))\n\n\nif __name__ == '__main__':\n main(train_config)\n", "meta": {"hexsha": "e59d17a4d09dbb033487be29959144b7d5903715", "size": 10071, "ext": "py", "lang": "Python", "max_stars_repo_path": "train.py", "max_stars_repo_name": "vanurag/draw", "max_stars_repo_head_hexsha": "6d24e6485c7688c94affed11183ea6f3df8418d3", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "train.py", "max_issues_repo_name": "vanurag/draw", "max_issues_repo_head_hexsha": "6d24e6485c7688c94affed11183ea6f3df8418d3", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "train.py", "max_forks_repo_name": "vanurag/draw", "max_forks_repo_head_hexsha": "6d24e6485c7688c94affed11183ea6f3df8418d3", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.5974025974, "max_line_length": 131, "alphanum_fraction": 0.6692483368, "include": true, "reason": "import numpy", "num_tokens": 2398, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792043, "lm_q2_score": 0.38861802670584894, "lm_q1q2_score": 0.19734484463400276}} {"text": "import os\n\nimport cv2\nimport numpy as np\n\nfrom . import Config\nfrom . import TrackersProvider\nfrom .CalibrationResults import get_current_time\nfrom .QueuesEntries import Point\nfrom .QueuesProvider import QueuesProvider\n\n\nclass Localization(object):\n \"\"\"Provides localizattion process\"\"\"\n\n objects_count = Config.objects_count\n rotation_matrix1 = None\n rotation_matrix2 = None\n projection_matrix1 = None\n projection_matrix2 = None\n mono_calibration_results = None\n\n localization_precision = 5 # in millimeters\n last_located_point = [None for _ in range(objects_count)]\n last_located_point_time = [-1 for _ in range(objects_count)]\n time_threshold_skip = 1 / 20\n time_threshold_correspondence = 1 / 10\n\n @classmethod\n def prepare_projection_matrices(cls, calibration_results1, calibration_results2, stereo_calibration_results):\n '''Prepares projeciton matrices for localization'''\n cls.mono_calibration_results = [calibration_results1, calibration_results2]\n rt = np.append(stereo_calibration_results.rotation_matrix, stereo_calibration_results.translation_vector,\n axis=1)\n cls.projection_matrix2 = calibration_results2.camera_matrix.dot(rt)\n cls.projection_matrix1 = calibration_results1.camera_matrix.dot(np.eye(3, 4))\n\n @classmethod\n def get_3d_coordinates(cls, *points):\n '''Undistort points and then compute the estimated 3D position'''\n if any(point is None for point in points) or len(points) != 2:\n return None\n\n # OpenCv function works with a set of points. In our case we have only one point per camera,\n # therefore we reshape into required format\n points = [np.array(point).reshape(1, 1, 2).astype(float) for point in points]\n points = [cls.get_undistorted_point(point, i) for i, point in enumerate(points)]\n\n located_points_hom = cv2.triangulatePoints(projMatr1=cls.projection_matrix1, projMatr2=cls.projection_matrix2,\n projPoints1=points[0],\n projPoints2=points[1])\n return cls.convert_from_homogenous(located_points_hom)\n\n @classmethod\n def get_undistorted_point(cls, point, cam_ind):\n '''Undistort point by using saved calibration data'''\n calib_results = cls.mono_calibration_results[cam_ind]\n undistorted = cv2.undistortPoints(point, calib_results.camera_matrix, calib_results.distortion_coeffs,\n P=calib_results.camera_matrix) # without setting P normalized points would be returned\n return undistorted\n\n @classmethod\n def save_localization_data(cls):\n '''Saves all localization data of all objects'''\n times = [x[0].timestamp for x in QueuesProvider.LocalizatedPoints3D if x]\n if not times:\n return\n\n first_point_time = min(times)\n for i, localizated in enumerate(QueuesProvider.LocalizatedPoints3D):\n if not localizated:\n return\n\n curr_dir = os.path.dirname(os.path.abspath(__file__))\n filename = os.path.join(curr_dir, \"localization_data\", \"{}-{}.txt\".format(get_current_time(), i + 1))\n os.makedirs(os.path.dirname(filename), exist_ok=True)\n\n with open(filename, 'w') as output:\n for point in localizated:\n point.timestamp -= first_point_time\n output.write('{}\\n'.format(point))\n\n @classmethod\n def localize_point(cls, object_id):\n '''Localize point in 3D and save it to corresponding queue'''\n points1 = QueuesProvider.TrackedPoints2D[(TrackersProvider.get_tracker_uid(0, object_id))]\n points2 = QueuesProvider.TrackedPoints2D[(TrackersProvider.get_tracker_uid(1, object_id))]\n\n if len(points1) == 0 or len(points2) == 0:\n return\n\n point1 = points1[-1]\n point2 = points2[-1]\n\n if abs(point1.timestamp - point2.timestamp) > cls.time_threshold_correspondence:\n return\n\n time = (point1.timestamp + point2.timestamp) / 2\n\n try:\n if time - cls.last_located_point_time[object_id] < cls.time_threshold_skip:\n return\n except IndexError:\n return\n\n cls.last_located_point_time[object_id] = time\n\n located_point = Localization.get_3d_coordinates(point1.coordinates,\n point2.coordinates)\n if located_point is None:\n return\n\n if cls.moved_more_than(cls.last_located_point[object_id], located_point, cls.localization_precision):\n point = Point(located_point, time)\n QueuesProvider.LocalizatedPoints3D[object_id].append(point)\n cls.last_located_point[object_id] = located_point\n\n @classmethod\n def moved_more_than(cls, old, new, distance):\n return old is None or np.linalg.norm(new - old) > distance\n\n @classmethod\n def convert_from_homogenous(cls, coords):\n return (coords[:-1] / coords[-1])[:, 0]\n", "meta": {"hexsha": "96206349bf2349a2d5a2c3453223374f17c5111d", "size": 5120, "ext": "py", "lang": "Python", "max_stars_repo_path": "program/program/Localization.py", "max_stars_repo_name": "JankaSvK/thesis", "max_stars_repo_head_hexsha": "c440ab8242b058f580fdf9d5a1d00708a1696561", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-11-29T14:13:47.000Z", "max_stars_repo_stars_event_max_datetime": "2018-11-29T14:13:47.000Z", "max_issues_repo_path": "program/program/Localization.py", "max_issues_repo_name": "JankaSvK/thesis", "max_issues_repo_head_hexsha": "c440ab8242b058f580fdf9d5a1d00708a1696561", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2018-04-24T18:30:00.000Z", "max_issues_repo_issues_event_max_datetime": "2018-05-11T23:25:07.000Z", "max_forks_repo_path": "program/program/Localization.py", "max_forks_repo_name": "JankaSvK/thesis", "max_forks_repo_head_hexsha": "c440ab8242b058f580fdf9d5a1d00708a1696561", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.96, "max_line_length": 129, "alphanum_fraction": 0.66328125, "include": true, "reason": "import numpy", "num_tokens": 1128, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792043, "lm_q2_score": 0.38861802670584894, "lm_q1q2_score": 0.19734484463400276}} {"text": "\"\"\"Provides a class, HP_model, to model the impact of a heat pump on\nenergy use and cost.\n\"\"\"\nfrom pprint import pformat\nimport inspect\nfrom pathlib import Path\nimport pickle\nimport time\nimport gzip\n\nimport pandas as pd\nimport numpy as np\n\nfrom . import library as lib\nfrom . import elec_cost\nfrom .home_heat_model import HomeHeatModel\nfrom .elec_cost import ElecCostCalc\nfrom .utils import is_null\nfrom . import ui_helper\n\n# --------- Some Constants\n\n# The days in each month\nDAYS_IN_MONTH = np.array([\n 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31\n])\n\n# The pattern or Lights and appliances other than DHW, Clothes Drying & Cooking.\n# This is average power in the month divided average annual power.\nLIGHTS_OTHER_PAT = np.array([\n 1.13, 1.075, 1.0, 0.925, 0.87, 0.85, 0.87, 0.925, 1.0, 1.075, 1.13, 1.15\n])\n\ndef make_pattern(esc, life):\n \"\"\"Makes a numpy array of length (life + 1) containing an escalation pattern\n that starts with a 1.0 in year 1 and escalates at the rate of 'esc' per year.\n \"\"\"\n pat = np.ones(life - 1) * (1 + esc)\n return np.insert(pat.cumprod(), 0, [0.0, 1.0])\n\ndef convert_co2_to_miles_driven(co2_saved):\n \"\"\"Converts CO2 emissions to a mileage driven\n equivalent for vehicles in the U.S. using EPA\n methodology: https://www.epa.gov/energy/greenhouse-gases-equivalencies-calculator-calculations-and-references#miles\n \"\"\"\n pounds_in_metric_ton = 2204.62\n tons_co2_per_gallon = 0.0089\n avg_gas_mileage_us_fleet = 22\n mileage_equivalent = co2_saved / pounds_in_metric_ton / tons_co2_per_gallon * avg_gas_mileage_us_fleet\n \n return mileage_equivalent\n\n\nclass HP_model:\n \"\"\"This is the class that orchestrates the heat pump analysis, running the home\n energy model with and without the heat pump. The class performs the economic\n analysis and stores all results as object attributes. The main method that\n is run to perform the analysis is \"run()\".\n \"\"\"\n\n # Some of inputs parameters are documented in the home_heat_model.HomeHeatModel class constructor;\n # those inputs are marked as such below.\n def __init__(self,\n bldg_name, # name of the building\n notes, # notes about the building\n city_id, # see home_heat_model.HomeHeatModel\n utility, # The full Pandas Series describing the Electric Utility\n pce_limit, # The maximum kWh in a month subsidized by PCE (0 will mean no PCE subsidy)\n co2_lbs_per_kwh, # see home_heat_model.HomeHeatModel\n exist_heat_fuel_id, # see home_heat_model.HomeHeatModel\n exist_unit_fuel_cost, # Cost per physical unit (e.g. gallon, CCF) of the existing space heating fuel.\n exist_fuel_use, # Annual existing fuel use for Space Heating and the other end uses identified using that fuel. None if not available.\n elec_uses, # 'all' if Annual Electric Use given by user includes lights & appliances, or 'space' if it is just Space Heating use.\n exist_heat_effic, # see home_heat_model.HomeHeatModel\n exist_kwh_per_mmbtu, # see home_heat_model.HomeHeatModel\n includes_dhw, # True if the existing Space Heating Fuel type also is used for DHW.\n includes_dryer, # True if the existing Space Heating Fuel type also is used for Clothes Drying.\n includes_cooking, # True if the existing Space Heating Fuel type also is used for Cooking.\n occupant_count, # Number of occupants using DHW, Clothes Drying, Cooking\n elec_use_jan, # The electric use in January, prior to heat pump installation, kWh.\n elec_use_may, # The electric use in May, prior to heat pump installation, kWh.\n hp_model_id, # see home_heat_model.HomeHeatModel\n low_temp_cutoff, # see home_heat_model.HomeHeatModel\n off_months_chks, # see home_heat_model.HomeHeatModel, parameter 'off_months' there\n garage_stall_count, # see home_heat_model.HomeHeatModel\n garage_heated_by_hp, # see home_heat_model.HomeHeatModel\n bldg_floor_area, # see home_heat_model.HomeHeatModel\n indoor_heat_setpoint, # see home_heat_model.HomeHeatModel\n insul_level, # see home_heat_model.HomeHeatModel\n pct_exposed_to_hp, # see home_heat_model.HomeHeatModel\n doors_open_to_adjacent, # see home_heat_model.HomeHeatModel\n bedroom_temp_tolerance, # see home_heat_model.HomeHeatModel\n capital_cost, # Initial cost of the heat pump installation\n rebate_dol, # Rebate $ received for heat pump installation\n pct_financed, # fraction (0 - 1.0) of heat pump installation cost financed by a loan.\n loan_term, # Length of loan in years.\n loan_interest, # interest rate of loan, expressed as fraction, i.e. 0.1 for 10%.\n hp_life, # life of heat pump in years\n op_cost_chg, # operating cost increase associated with heat pump (negative if decrease)\n sales_tax, # sales tax, expressed as a fraction (0.05 for 5%/yr) that applies to electricity and fuel costs\n discount_rate, # economic discount rate, expressed as a fraction, per year. Nominal, not adjusted for inflation.\n inflation_rate, # general inflation rate expressed as a fraction, per year.\n fuel_esc_rate, # price escalation rate of fuel used for existing heating system, fraction/year, nominal\n elec_esc_rate, # price escalation rate of electricity, fraction/year, nominal\n ):\n\n # Store all of these input parameters as object attributes.\n args, _, _, values = inspect.getargvalues(inspect.currentframe())\n for arg in args[1:]:\n setattr(self, arg, values[arg])\n \n # Look up the objects associated with the IDs\n self.city = lib.city_from_id(city_id)\n self.exist_fuel = lib.fuel_from_id(exist_heat_fuel_id)\n self.hp_model = lib.heat_pump_from_id(hp_model_id)\n \n def __repr__(self):\n \"\"\"Returns a string with all the object attributes shown. Text is truncated\n at 1,000 characters for attributes with long representations.\n \"\"\"\n s = ''\n for attr in self.__dict__:\n val = pformat(self.__dict__[attr])[:1500]\n if len(val)>70:\n s+=f'\\n{attr}:\\n{val}\\n\\n'\n else:\n s += f'{attr}: {val}\\n'\n return s\n \n def run(self):\n \"\"\"This method performs all of the modeling and analysis, storing\n results as object attributes.\n \"\"\"\n \n # shortcut for self\n s = self\n \n # shortcut to existing heating fuel\n fuel = s.exist_fuel\n\n # holds summary measures for the heat pump project (e.g. seasonal COP,\n # internal rate of return). Fill out first item: secondary fuel info.\n s.summary = {'fuel_unit': fuel.unit, 'fuel_desc': fuel.desc}\n \n # Create the home energy simulation object\n sim = HomeHeatModel(\n city_id=s.city_id,\n hp_model_id=s.hp_model_id,\n exist_heat_fuel_id=s.exist_heat_fuel_id,\n exist_heat_effic=s.exist_heat_effic,\n exist_kwh_per_mmbtu=s.exist_kwh_per_mmbtu, \n co2_lbs_per_kwh=s.co2_lbs_per_kwh,\n low_temp_cutoff=s.low_temp_cutoff,\n off_months=s.off_months_chks,\n garage_stall_count=s.garage_stall_count,\n garage_heated_by_hp=s.garage_heated_by_hp,\n bldg_floor_area=s.bldg_floor_area,\n indoor_heat_setpoint=s.indoor_heat_setpoint,\n insul_level=s.insul_level,\n pct_exposed_to_hp=s.pct_exposed_to_hp,\n doors_open_to_adjacent=s.doors_open_to_adjacent,\n bedroom_temp_tolerance=s.bedroom_temp_tolerance, \n )\n\n # If other end uses use the heating fuel, make an estimate of their annual\n # consumption of that fuel. This figure is expressed in the physical unit\n # for the fuel type, e.g. gallons of oil. Save this as an object attribute\n # so it is accessible in other routines. See Evernote notes on values (AkWarm\n # for DHW and Michael Bluejay for Drying and Cooking).\n is_electric = (s.exist_heat_fuel_id == ui_helper.ELECTRIC_ID) # True if Electric\n s.fuel_other_uses = s.includes_dhw * 4.23e6 / fuel.dhw_effic\n s.fuel_other_uses += s.includes_dryer * (0.86e6 if is_electric else 2.15e6)\n s.fuel_other_uses += s.includes_cooking * (0.64e6 if is_electric else 0.8e6)\n s.fuel_other_uses *= s.occupant_count / fuel.btus\n\n # For elecric heat we also need to account for lights and other applicances not\n # itemized above.\n if is_electric:\n # Use the AkWarm Medium Lights/Appliances formula but take 25% off\n # due to efficiency improvements since then.\n s.lights_other_elec = 2086. + 1.20 * s.bldg_floor_area # kWh in the year\n else:\n s.lights_other_elec = 0.0\n \n # Match the existing space heating use if it is provided. Do so by using\n # the UA true up factor.\n if not is_null(s.exist_fuel_use):\n \n # Remove the energy use from the other end uses that use the fuel, unless\n # this is electric heat and the user indicated that the entered value is\n # just space heating.\n if is_electric and s.elec_uses=='space':\n # user explicitly indicated that the entered annual usage value is\n # just space heating.\n space_fuel_use = s.exist_fuel_use\n else:\n space_fuel_use = s.exist_fuel_use - s.fuel_other_uses - s.lights_other_elec\n\n sim.no_heat_pump_use = True\n sim.calculate()\n if is_electric:\n # For electric heat, electric use for space heat is in secondary_kwh\n fuel_use1 = sim.annual_results().secondary_kwh\n else:\n fuel_use1 = sim.annual_results().secondary_fuel_units\n \n # scale the UA linearly to attempt to match the target fuel use\n ua_true_up = space_fuel_use / fuel_use1\n sim.ua_true_up = ua_true_up\n sim.calculate()\n\n if is_electric:\n # For electric heat, electric use for space heat is in secondary_kwh\n fuel_use2 = sim.annual_results().secondary_kwh\n else:\n fuel_use2 = sim.annual_results().secondary_fuel_units\n \n # In case it wasn't linear, inter/extrapolate to the final ua_true_up\n slope = (fuel_use2 - fuel_use1)/(ua_true_up - 1.0)\n # print(space_fuel_use, fuel_use1, fuel_use2, ua_true_up)\n ua_true_up = 1.0 + (space_fuel_use - fuel_use1) / slope\n # print(ua_true_up)\n\n else:\n ua_true_up = 1.0\n \n # Set the UA true up value into the model and also save it as\n # an attribute of this object so it can be observed.\n sim.ua_true_up = ua_true_up\n s.ua_true_up = ua_true_up\n \n # Run the base case with no heat pump and record energy results.\n # This model only models the space heating end use.\n sim.no_heat_pump_use = True\n sim.calculate()\n s.df_mo_en_base = sim.monthly_results()\n s.ann_en_base = sim.annual_results()\n # print(s.ann_en_base.secondary_kwh)\n \n # Run the model with the heat pump and record energy results\n sim.no_heat_pump_use = False\n sim.calculate()\n s.df_mo_en_hp = sim.monthly_results()\n s.ann_en_hp = sim.annual_results()\n s.df_hourly = sim.df_hourly\n\n # record design heat load\n s.summary['design_heat_load'], s.summary['design_heat_temp'] = sim.design_heat_load()\n \n # Calculate some summary measures\n s.summary['cop'] = s.ann_en_hp.cop\n s.summary['hp_max_capacity_5F'] = sim.hp_max_capacity_5F()\n s.summary['max_hp_reached'] = sim.max_hp_reached\n \n # CO2 savings\n s.summary['co2_lbs_saved'] = s.ann_en_base.co2_lbs - s.ann_en_hp.co2_lbs\n s.summary['co2_driving_miles_saved'] = convert_co2_to_miles_driven(s.summary['co2_lbs_saved'])\n s.summary['hp_load_frac'] = s.ann_en_hp.hp_load_mmbtu / (s.ann_en_hp.hp_load_mmbtu + s.ann_en_hp.secondary_load_mmbtu)\n \n # Create DataFrames that hold monthly energy cost amounts\n # Results are stored as object attributes.\n self.calc_monthly_cash()\n \n # Create a multi-year Cash Flow DataFrame and summary economic measures.\n # Results are stored as object attributes.\n self.calc_cash_flow()\n\n # Save a gzipped pickle of this object using Unix time as the file name.\n # make a directory to hold the files\n save_dir = 'hpcalc_runs'\n Path(save_dir).mkdir(exist_ok=True)\n fname = f'{time.time():.2f}.pkl.gz'\n s.file_name = fname\n pickle.dump(self, gzip.open(f'{save_dir}/{fname}', 'wb'))\n\n def calc_monthly_cash(self):\n \"\"\"Calculates two DataFrames, s.df_mo_dol_base and s.df_mo_dol_hp, that contain\n the fuel and electricity costs in the base case (no heat pump) scenario and the\n with heat pump scenario. A number of inputs found as object attributes are used. \n \"\"\"\n # shortcut to self\n s = self\n\n # Start the DataFrames, base and w/ heat pump\n # Each starts with just an index column with the month\n # Make shortcut variables as well.\n s.df_mo_dol_base = dfb = s.df_mo_en_base[[]].copy()\n s.df_mo_dol_hp = dfh = s.df_mo_en_base[[]].copy()\n\n # Determine the base electric use by month. Approach is different \n # if there is electric heat.\n is_electric_heat = (s.exist_heat_fuel_id == ui_helper.ELECTRIC_ID)\n if not is_electric_heat:\n # Fuel-based space heat.\n # The User supplied a January and a May kWh usage value that should\n # be used for the base case (no heat pump) total electricity use.\n # But, need to come up with a kWh value for every month. Do that by\n # adjusting the kWh pattern available for this city.\n #\n # Determine the multiplier to adjust to the pattern to the actual.\n pat_use = np.array(s.city.avg_elec_usage)\n mult = (s.elec_use_jan - s.elec_use_may) / (pat_use[0] - pat_use[4])\n pat_use = mult * pat_use\n pat_use += s.elec_use_jan - pat_use[0]\n\n # The electricity use in the base case\n dfb['elec_kwh'] = pat_use\n\n # rough estimate of a base demand: not super critical, as the demand rate \n # structure does not have blocks. Assume a load factor of 0.4\n dfb['elec_kw'] = dfb.elec_kwh / (DAYS_IN_MONTH * 24.0) / 0.4\n\n else:\n # Electric Heat Case\n # No Jan and May values are provided. Instead we have possibly some\n # DHW, clothes drying, and cooking. Plus, we have base lights/other appliances.\n # And finally we have the Elecric heat making up the base electric usage.\n\n # First, DHW, Clothes Drying and Cooking. Assume flat use through year.\n # This is a numpy array because DAYS_IN_MONTH is an array.\n elec_kwh = s.fuel_other_uses / 8760.0 * DAYS_IN_MONTH * 24.0\n\n # Now lights and other misc. appliances. Some monthly variation, given\n # by LIGHTS_OTHER_PAT.\n elec_kwh += s.lights_other_elec / 8760.0 * LIGHTS_OTHER_PAT * DAYS_IN_MONTH * 24.0\n\n # For the peak demand of those two categories of use, just assume 40% load factor.\n elec_kw = elec_kwh / (DAYS_IN_MONTH * 24.0) / 0.4\n\n # Now add in space heating kWh and kW\n elec_kwh += s.df_mo_en_base.total_kwh.values\n elec_kw += s.df_mo_en_base.total_kw.values\n\n # store results\n dfb['elec_kwh'] = elec_kwh\n dfb['elec_kw'] = elec_kw\n\n # Make an object to calculate electric utility costs\n elec_cost_calc = ElecCostCalc(s.utility, sales_tax=s.sales_tax, pce_limit=s.pce_limit)\n # cost function that will be applied to each row of the cost DataFrame\n cost_func = lambda r: elec_cost_calc.monthly_cost(r.elec_kwh, r.elec_kw)\n\n dfb['elec_dol'] = dfb.apply(cost_func, axis=1)\n\n if not is_electric_heat:\n # Now fuel use by month. Remember that the home heat model only looked at\n # space heating, so we need to add in the fuel use from the other end uses\n # that use this fuel.\n dfb['secondary_fuel_units'] = s.df_mo_en_base.secondary_fuel_units + \\\n s.fuel_other_uses / 12.0\n dfb['secondary_fuel_dol'] = dfb.secondary_fuel_units * s.exist_unit_fuel_cost * (1. + s.sales_tax)\n else:\n # Electric Heat, so no secondary fuel\n dfb['secondary_fuel_units'] = 0.0\n dfb['secondary_fuel_dol'] = 0.0\n\n # Total Electric + space heat\n dfb['total_dol'] = dfb.elec_dol + dfb.secondary_fuel_dol\n\n # Now with the heat pump\n # determine extra kWh used in the heat pump scenario. Note, this will\n # be negative numbers if the base case used electric heat.\n extra_kwh = (s.df_mo_en_hp.total_kwh - s.df_mo_en_base.total_kwh).values\n dfh['elec_kwh'] = dfb['elec_kwh'] + extra_kwh\n extra_kw = (s.df_mo_en_hp.total_kw - s.df_mo_en_base.total_kw).values\n dfh['elec_kw'] = dfb['elec_kw'] + extra_kw\n dfh['elec_dol'] = dfh.apply(cost_func, axis=1)\n\n # Now fuel, including other end uses using the heating fuel\n if not is_electric_heat:\n dfh['secondary_fuel_units'] = s.df_mo_en_hp.secondary_fuel_units + \\\n s.fuel_other_uses / 12.0\n dfh['secondary_fuel_dol'] = dfh.secondary_fuel_units * s.exist_unit_fuel_cost * (1. + s.sales_tax)\n else:\n # Electric Heat, so no secondary fuel\n dfh['secondary_fuel_units'] = 0.0\n dfh['secondary_fuel_dol'] = 0.0\n\n # Total Electric + space heat\n dfh['total_dol'] = dfh.elec_dol + dfh.secondary_fuel_dol\n \n def calc_cash_flow(self):\n \"\"\"Calculates the cash flow impacts of the installation over the \n life of the heat pump. Creates a DataFrame, self.df_cash_flow, that shows\n the impacts. In that DataFrame, postive values are benefits and negative \n values are costs. \n Also calculates some summary economic measures that are added to\n the self.summary dictionary.\n \"\"\"\n s = self # shortcut variable\n\n # determine the changes caused by the heat pump on an annual basis.\n # First calculate annual totals for base case and heat pump case and\n # then calculate the change.\n ann_base = s.df_mo_dol_base.sum()\n ann_hp = s.df_mo_dol_hp.sum()\n ann_chg = ann_hp - ann_base\n initial_cost = np.zeros(s.hp_life+1)\n \n # Am not automatically adding sales tax to the initial cost as the user was\n # supposed to includes sales tax in their input.\n initial_cost[0] = -s.capital_cost * (1 - s.pct_financed) + s.rebate_dol\n loan_pmt = np.pmt(s.loan_interest, s.loan_term, s.capital_cost * s.pct_financed)\n if loan_pmt < -0.01: # loan payment is negative\n loan_cost = [0.0] + [loan_pmt] * s.loan_term + [0.0] * (s.hp_life - s.loan_term)\n loan_cost = np.array(loan_cost)\n else:\n loan_cost = 0.0\n op_cost = -s.op_cost_chg * make_pattern(s.inflation_rate, s.hp_life)\n fuel_cost = -ann_chg.secondary_fuel_dol * make_pattern(s.fuel_esc_rate, s.hp_life)\n elec_cost = -ann_chg.elec_dol * make_pattern(s.elec_esc_rate, s.hp_life)\n cash_flow = initial_cost + loan_cost + op_cost + fuel_cost + elec_cost\n\n # calculate cumulative, discounted cash flow.\n disc_factor = np.ones(s.hp_life) * (1 + s.discount_rate)\n disc_factor = np.insert(disc_factor.cumprod(), 0, 1.0)\n cum_disc_cash_flow = np.cumsum(cash_flow / disc_factor)\n \n s.df_cash_flow = pd.DataFrame(\n {'initial_cost': initial_cost,\n 'loan_cost': loan_cost,\n 'op_cost': op_cost,\n 'fuel_cost': fuel_cost,\n 'elec_cost': elec_cost,\n 'cash_flow': cash_flow,\n 'cum_disc_cash_flow': cum_disc_cash_flow,\n }\n )\n s.df_cash_flow.index.name = 'year'\n \n # Calculate IRR and NPV for w/ and w/o PCE.\n s.summary['irr'] = np.irr(s.df_cash_flow.cash_flow)\n s.summary['npv'] = np.npv(s.discount_rate, s.df_cash_flow.cash_flow)\n \n # Add some summary fuel and electric usage and unit cost info\n s.summary['fuel_use_base'] = ann_base.secondary_fuel_units\n s.summary['fuel_use_hp'] = ann_hp.secondary_fuel_units\n s.summary['fuel_use_chg'] = ann_chg.secondary_fuel_units\n if ann_chg.secondary_fuel_units != 0.0:\n s.summary['fuel_price_incremental'] = ann_chg.secondary_fuel_dol / ann_chg.secondary_fuel_units\n else:\n s.summary['fuel_price_incremental'] = np.nan\n s.summary['elec_use_base'] = ann_base.elec_kwh\n s.summary['elec_use_hp'] = ann_hp.elec_kwh\n s.summary['elec_use_chg'] = ann_chg.elec_kwh\n s.summary['elec_rate_avg_base'] = ann_base.elec_dol / ann_base.elec_kwh\n s.summary['elec_rate_avg_hp'] = ann_hp.elec_dol / ann_hp.elec_kwh\n s.summary['elec_rate_incremental'] = ann_chg.elec_dol / ann_chg.elec_kwh\n ", "meta": {"hexsha": "46c047f9f058702fdc9792f6585f24fc003e9652", "size": 22381, "ext": "py", "lang": "Python", "max_stars_repo_path": "heatpump/hp_model.py", "max_stars_repo_name": "alanmitchell/heat-pump-calc", "max_stars_repo_head_hexsha": "fd3efab5a956ce8ef68b5a7f35f3d0a1bd58565b", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2018-03-19T17:37:47.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-10T19:32:48.000Z", "max_issues_repo_path": "heatpump/hp_model.py", "max_issues_repo_name": "alanmitchell/heat-pump-calc", "max_issues_repo_head_hexsha": "fd3efab5a956ce8ef68b5a7f35f3d0a1bd58565b", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "heatpump/hp_model.py", "max_forks_repo_name": "alanmitchell/heat-pump-calc", "max_forks_repo_head_hexsha": "fd3efab5a956ce8ef68b5a7f35f3d0a1bd58565b", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-03-11T23:57:11.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-11T23:57:11.000Z", "avg_line_length": 49.846325167, "max_line_length": 159, "alphanum_fraction": 0.6278539833, "include": true, "reason": "import numpy", "num_tokens": 5525, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118493816806, "lm_q2_score": 0.38861802670584894, "lm_q1q2_score": 0.19734483884455647}} {"text": "# Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved.\n# This software is licensed to you under the Universal Permissive License (UPL) 1.0 as shown at\n# https://oss.oracle.com/licenses/upl\n\"\"\"Module contains the MACEst model to estimate prediction intervals.\"\"\"\n\nimport nmslib\nimport logging\nimport os\nimport numpy as np\nimport scipy\nfrom scipy.optimize import differential_evolution\nfrom scipy.stats import laplace, norm\nfrom scipy.stats._continuous_distns import laplace_gen\nfrom typing import Optional, Union, NamedTuple, Tuple, Dict, Any\nfrom typing_extensions import Protocol, Literal\n\nlog = logging.getLogger()\n\nnum_threads_available = os.cpu_count()\n\n\nclass _RegressionPointPredictionModel(Protocol):\n \"\"\"\n Defines a protocol for the type PointPredModel.\n\n if a model has a predict method then it is the same type as PointPredModel.\n \"\"\"\n\n def predict(self, x_star: np.ndarray) -> Any:\n \"\"\"Return nothing as is only needed to check method exists.\"\"\"\n pass\n\n\nclass HnswGraphArgs(NamedTuple):\n \"\"\"Object for passing arguments to the nmslib function.\"\"\"\n\n init_kwargs: Dict[str, str] = {\"method\": \"hnsw\", \"space\": \"l2\"}\n construction_kwargs: Dict[str, int] = {\"post\": 2, \"efConstruction\": 1000, \"M\": 100}\n query_kwargs: Dict[str, int] = {\"ef\": 1000}\n\n\nclass SearchBounds(NamedTuple):\n \"\"\"Object for passing the range of allowed MACEst parameters.\"\"\"\n\n alpha_bounds: Tuple[float, float] = (0.1, 50.0)\n beta_bounds: Tuple[float, float] = (0.1, 50.0)\n k_bounds: Tuple[int, int] = (5, 20)\n\n\nclass MacestPredIntervalModelParams(NamedTuple):\n \"\"\"Class container for MACEst model parameters.\"\"\"\n\n alpha: float = 1.0\n beta: float = 1.0\n num_neighbours: int = 10\n\n\nclass PrecomputedNeighbourInfo(NamedTuple):\n \"\"\"Class container for the information about pre-computed nearest neighbours per class.\"\"\"\n\n prec_distance_to_nn: Union[Dict[int, np.ndarray], np.ndarray]\n prec_ind_of_nn: Union[Dict[int, np.ndarray], np.ndarray] # Rhys- only dict for training, where I cache\n # arrays for all values of allowed num neighbours\n\n\nclass ModelWithPredictionInterval:\n \"\"\"Creates a model which returns a prediction and a confidence interval.\"\"\"\n\n def __init__(\n self,\n model: _RegressionPointPredictionModel,\n x_train: np.ndarray,\n train_err: np.ndarray,\n macest_model_params: MacestPredIntervalModelParams = MacestPredIntervalModelParams(),\n error_dist: Literal[\"normal\", \"laplace\"] = \"normal\",\n dist_func: Literal[\"linear\", \"error_weighted_poly\"] = \"linear\",\n precomputed_neighbour_info: Optional[PrecomputedNeighbourInfo] = None,\n prec_point_preds: Optional[np.ndarray] = None,\n prec_graph: Optional[nmslib.dist.FloatIndex] = None,\n search_method_args: HnswGraphArgs = HnswGraphArgs(),\n ):\n \"\"\"\n Init.\n\n :param model: Any model which takes some variables x and returns a point prediction y\n :param x_train: The variables used to train the model\n :param train_err: The error for each training point\n :param num_neighbours: The number of points which define the local neighbourhood\n :param alpha: co-efficient for distance function (hyper-parameter)\n :param beta: The hyper-parameter used in distance function\n :param error_dist: The assumed distribution for the errors\n :param dist_func: The function to convert distance to confidence \\\n (currently linear or error_weighted_poly implemented)\n :param prec_point_preds: The pre-computed model predictions\n :param prec_distance_to_nn: The pre-computed nearest neighbour distances for the calibration and test data\n :param prec_ind_of_nn: The pre-computed nearest neighbour indices for the calibration and test data\n :param prec_graph: The pre-computed graph to use for online hnsw search\n \"\"\"\n self.model = model\n self.x_train = x_train\n self.train_err = train_err\n self.macest_model_params = macest_model_params\n self._num_neighbours = macest_model_params.num_neighbours\n self._alpha = macest_model_params.alpha\n self._beta = macest_model_params.beta\n self.dist_func = dist_func\n self.error_dist = error_dist\n self.prec_graph = prec_graph\n self.point_preds = prec_point_preds\n self.precomputed_neighbour_info = precomputed_neighbour_info\n if not self.precomputed_neighbour_info:\n self._distance_to_nn = None\n self._ind_of_nn = None\n else:\n self._distance_to_nn = self.precomputed_neighbour_info.prec_distance_to_nn\n self._ind_of_nn = self.precomputed_neighbour_info.prec_ind_of_nn\n self.search_method_args = search_method_args\n self._check_consistent_search_method_args()\n self._check_data_consistent_with_search_args()\n\n def predict(self, x_star: np.ndarray) -> np.ndarray:\n \"\"\"\n Return a point prediction for x_star.\n\n :param x_star: The position for which we would like to predict\n\n :return: pred_star : The point prediction for x_star\n \"\"\"\n pred_star = self.model.predict(x_star)\n return pred_star\n\n def build_graph(self) -> nmslib.dist.FloatIndex:\n \"\"\"\n Build the Hierarchical Navigable Small World (hnsw) index graph.\n\n :return: A queryable HNSW graph\n \"\"\"\n graph = nmslib.init(**self.search_method_args.init_kwargs)\n graph.addDataPointBatch(self.x_train)\n graph.createIndex(self.search_method_args.construction_kwargs)\n graph.setQueryTimeParams(self.search_method_args.query_kwargs)\n\n return graph\n\n def calc_nn_dist(self, x_star: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:\n \"\"\"\n Calculate the distant to a set of k nearest neighbours.\n\n :param x_star: The position for which we would like to predict\n\n :return: The distance to k nearest neighbours and the indices of the k closest neighbours\n \"\"\"\n if self.prec_graph is None:\n self.prec_graph = self.build_graph()\n\n neighbours = np.array(\n self.prec_graph.knnQueryBatch(\n x_star, k=self._num_neighbours, num_threads=num_threads_available\n )\n )\n dist = neighbours[:, 1, :]\n ind = neighbours[:, 0, :].astype(int)\n return dist, ind\n\n def calc_linear_dist_func(self, x_star: np.ndarray) -> np.ndarray:\n \"\"\"\n Calculate the linear sum of average distance to neighbours and average per neighbour error.\n\n :param x_star: The position for which we would like to predict\n\n :return: the sum of average distance to neighbours and average per neighbour error for x_star\n \"\"\"\n if self._distance_to_nn is not None:\n local_distance = self._distance_to_nn\n if self._ind_of_nn is None:\n raise ValueError(\"_ind_of_nn has not been cached during training\")\n ind = self._ind_of_nn\n else:\n local_distance, ind = self.calc_nn_dist(x_star)\n if isinstance(local_distance, np.ndarray):\n dist = self._alpha * np.average(\n local_distance, weights=np.arange(local_distance.shape[1], 0, -1), axis=1,\n )\n else:\n raise ValueError('Need to remove pre-cached training neighbour data from training')\n if isinstance(ind, np.ndarray):\n error = self._beta * np.average(\n abs(self.train_err[ind.astype(int)]),\n weights=1.0 / (1 + local_distance),\n axis=1,)\n else:\n raise ValueError('Need to remove pre-cached training neighbour data from training')\n\n return dist + error\n\n def calc_error_weighted_dist(self, x_star: np.ndarray) -> np.ndarray:\n \"\"\"\n Calculate average distance to neighbours weighted by the per neighbour prediction error.\n\n :param x_star: The position for which we would like to predict\n\n :return: the error weighted distance from x_star point to it's neighbours\n \"\"\"\n if self._distance_to_nn is not None:\n local_distance = self._distance_to_nn\n if self._ind_of_nn is None:\n raise ValueError(\"_ind_of_nn has not been cached during training\")\n ind = self._ind_of_nn\n else:\n local_distance, ind = self.calc_nn_dist(x_star)\n\n if isinstance(ind, np.ndarray):\n train_error = self.train_err[ind.astype(int)]\n else:\n raise ValueError('Need to remove pre-cached training neighbour data from training')\n if isinstance(local_distance, np.ndarray):\n error_weighted_dist = np.average(\n local_distance * abs(train_error),\n weights=1.0 / (1 + local_distance),\n axis=1,\n )\n else:\n raise ValueError('Need to remove pre-cached training neighbour data from training')\n\n error_weighted_poly = self._alpha * error_weighted_dist ** self._beta\n return error_weighted_poly\n\n def std_on_y_star(self, x_star: np.ndarray) -> np.ndarray:\n \"\"\"\n Return the predicted variance for x_star.\n\n :param x_star: The position for which we would like to predict\n\n :return: sigma: The standard deviation for the prediction at x_star\n \"\"\"\n if self.dist_func == \"error_weighted_poly\":\n dist = self.calc_error_weighted_dist(x_star)\n elif self.dist_func == \"linear\":\n dist = self.calc_linear_dist_func(x_star)\n else:\n raise ValueError(f\"Unknown distance function: {self.dist_func}\")\n sigma = dist\n return sigma\n\n def laplace_scale_on_y_star(self, x_star: np.ndarray) -> np.ndarray:\n \"\"\"\n Return the predicted laplacian variance for x_star.\n\n :param x_star: The position for which we would like to predict\n\n :return: sigma: The laplacian scaler for the prediction at x_star\n \"\"\"\n if self.dist_func == \"error_weighted_poly\":\n dist = self.calc_error_weighted_dist(x_star)\n elif self.dist_func == \"linear\":\n dist = self.calc_linear_dist_func(x_star)\n else:\n raise ValueError(f\"Unknown distance function: {self.dist_func}\")\n sigma = dist\n return sigma\n\n def _distribution(self, x_star: np.ndarray) -> laplace_gen:\n \"\"\"\n Return the distribution that we will predict from.\n\n :return:\n \"\"\"\n if self.point_preds is not None:\n point_preds = self.point_preds\n else:\n point_preds = self.predict(x_star,)\n if self.error_dist == \"normal\":\n scale = self.std_on_y_star(x_star,)\n dist = norm(loc=point_preds, scale=scale)\n elif self.error_dist == \"laplace\":\n scale = self.laplace_scale_on_y_star(x_star,)\n dist = laplace(loc=point_preds, scale=scale)\n else:\n raise ValueError(f\"Unknown distance function: {self.dist_func}\")\n return dist\n\n def predict_interval(\n self, x_star: np.ndarray, conf_level: Union[np.ndarray, int, float] = 90,\n ) -> np.ndarray:\n \"\"\"\n Predict the upper and lower prediction interval bounds for a given confidence level.\n\n :param x_star: The position for which we would like to predict\n :param conf_level:\n\n :return: The confidence bounds for each x_star for each confidence level\n \"\"\"\n dist = self._distribution(x_star)\n lower_perc = (100 - conf_level) / 2\n upper_perc = 100 - lower_perc\n\n lower_vec = 0.01 * np.ones((x_star.shape[0], len([conf_level]))) * lower_perc\n upper_vec = 0.01 * np.ones((x_star.shape[0], len([conf_level]))) * upper_perc\n return np.array([dist.ppf(lower_vec.T), dist.ppf(upper_vec.T)]).T\n\n def calculate_prediction_interval_width(\n self, x_star: np.ndarray, conf_level: Union[np.ndarray, int, float] = 90,\n ) -> np.ndarray:\n \"\"\"\n Calculate the absolute width of a prediction interval for a given confidence level.\n\n :param x_star: The position for which we would like to predict\n :param conf_level:\n\n :return: the absolute width of a prediction interval for each x_star for each confidence level\n \"\"\"\n intervals = self.predict_interval(x_star, conf_level)\n return np.diff(intervals)\n\n def sample_prediction(\n self, x_star: np.ndarray, nsamples: int = 10 ** 3\n ) -> np.ndarray:\n \"\"\"\n Draw samples from any predicted distribution to get a distribution of predictions.\n\n :param x_star: The position in feature space for which we would like to predict\n :param nsamples: The number of samples to draw from the distribution\n\n :return: Samples from the predicted distribution\n \"\"\"\n dist = self._distribution(x_star)\n return dist.rvs(size=(nsamples, x_star.shape[0])).T\n\n def fit(\n self,\n x_cal: np.ndarray,\n y_cal: np.ndarray,\n param_range: SearchBounds = SearchBounds(),\n optimiser_args: Optional[Dict[Any, Any]] = None,\n ) -> None:\n \"\"\"\n Fit MACEst model using the calibration data.\n\n :param x_cal: Calibration data\n :param y_cal: Target values\n :param param_range: The bounds within which to search for MACEst parameters\n :param optimiser_args: Any arguments for the optimiser (see scipy.optimize)\n\n :return: None\n \"\"\"\n if optimiser_args is None:\n optimiser_args = {}\n\n train_helper = _TrainingHelper(self, x_cal, y_cal, param_range)\n train_helper.fit(optimiser_args=optimiser_args)\n\n def _check_consistent_search_method_args(self) -> None:\n init_args = self.search_method_args.init_kwargs\n index = nmslib.init(**init_args)\n\n if 'space' not in list(init_args.keys()):\n raise ValueError('You must pass a space in your search method init args')\n\n space = init_args['space']\n if space[-6:] == 'sparse':\n sparse_metric = True\n else:\n sparse_metric = False\n\n data_type = index.dataType\n if data_type == nmslib.DataType.SPARSE_VECTOR:\n sparse_data = True\n else:\n sparse_data = False\n\n if sparse_metric != sparse_data:\n raise ValueError(\n f'Data type and space are not compatible, your space is {space} '\n f'and search data type is data_type nmslib.{data_type}')\n\n def _check_data_consistent_with_search_args(self) -> None:\n init_args = self.search_method_args.init_kwargs\n\n space = init_args['space']\n if space[-6:] == 'sparse':\n sparse_metric = True\n else:\n sparse_metric = False\n\n training_data_type = type(self.x_train)\n\n if training_data_type == scipy.sparse.csr.csr_matrix:\n sparse_data = True\n else:\n sparse_data = False\n\n if sparse_metric != sparse_data:\n raise ValueError(\n f'Training data type and space are not compatible, your space is {space} '\n f'and training data type is {training_data_type}')\n\n\nclass _TrainingHelper(object):\n def __init__(\n self,\n init_conf_model: ModelWithPredictionInterval,\n x_cal: np.ndarray,\n y_cal: np.ndarray,\n param_range: SearchBounds = SearchBounds(),\n ):\n \"\"\"\n Init.\n\n :param init_conf_model: an initialised ModelWithConfidence object that we want to fit\n :param x_cal: The X variables that we will use to calibrate the confidence predictions\n :param y_cal: The target variables that we will use to calibrate the confidence predictions\n :param param_range: The bounds on the hyper-parameter space we want to search\n \"\"\"\n self.model = init_conf_model\n self.x_cal = x_cal\n self.y_cal = y_cal\n self.param_range = param_range\n self.prec_graph = self.model.build_graph()\n self.model.prec_graph = self.prec_graph\n self.prec_dist, self.prec_ind = self._prec_neighbours()\n self.model.point_preds = self.model.predict(self.x_cal)\n\n def _prec_neighbours(self) -> Tuple[Dict[int, np.ndarray], Dict[int, np.ndarray]]:\n \"\"\"\n Pre-compute the nearest neighbours and their distances.\n\n :return:\n \"\"\"\n min_nbrs = self.param_range[2][0]\n max_nbrs = self.param_range[2][1]\n num_nbrs = np.arange(min_nbrs, max_nbrs + 0.1, 1)\n x_cal_len_array = np.arange(len(self.x_cal))\n\n dist_dict = {}\n ind_dict = {}\n\n max_neighbours = np.array(\n self.prec_graph.knnQueryBatch(\n self.x_cal, k=int(max_nbrs), num_threads=num_threads_available\n )\n )\n\n max_dist = max_neighbours[x_cal_len_array, 1]\n max_ind = max_neighbours[x_cal_len_array, 0]\n\n for k in num_nbrs:\n dist = max_dist[x_cal_len_array, 0: int(k)]\n ind = max_ind[x_cal_len_array, 0: int(k)]\n\n dist_dict[k] = dist\n ind_dict[k] = ind\n\n return dist_dict, ind_dict\n\n def set_macest_model_params(self) -> MacestPredIntervalModelParams:\n \"\"\"\n Return MACEst parameter values.\n\n :return:\n \"\"\"\n params = MacestPredIntervalModelParams(\n num_neighbours=self.model._num_neighbours,\n alpha=self.model._alpha,\n beta=self.model._beta,\n )\n self.model.macest_model_params = params\n return params\n\n def loss_func(self, params: MacestPredIntervalModelParams) -> float:\n \"\"\"\n Calculate the loss for a given set of parameters, this will then be optimised when fit is called.\n\n :param params: A tuple containing the model hyper-paramters\n :return:\n \"\"\"\n self.model._alpha, self.model._beta, self.model._num_neighbours = params\n\n self.model._num_neighbours = int(np.round(self.model._num_neighbours))\n\n self.model.prec_graph = self.prec_graph\n self.model._distance_to_nn = self.prec_dist[self.model._num_neighbours]\n self.model._ind_of_nn = self.prec_ind[self.model._num_neighbours]\n\n return picp_loss(self.model, self.x_cal, self.y_cal)\n\n def fit(\n self,\n optimiser: Literal[\"de\"] = \"de\",\n optimiser_args: Optional[Dict[Any, Any]] = None,\n ) -> ModelWithPredictionInterval:\n \"\"\"\n Fit MACEst parameters.\n\n :param optimiser: The optimisation method\n :param optimiser_args: Any arguments for the optimisation strategy\n :return: A ModelWithConfidence object with the hyper-parameters that minimises the loss function\n \"\"\"\n if optimiser == \"de\":\n result = differential_evolution(\n self.loss_func, self.param_range, **optimiser_args\n )\n else:\n raise ValueError(\n \"The only optimisation method currently implemented is differential evolution\"\n )\n\n log.info(f\"min_loss = {result.fun}\")\n\n alpha, beta, k = result.x\n k = int(np.round(k, 0))\n log.info(f\" best_alpha: {alpha}\")\n log.info(f\" best_beta: {beta}\")\n log.info(f\" best_k: {k}\")\n\n self.model._alpha = alpha\n self.model._beta = beta\n self.model._num_neighbours = int(np.round(k))\n\n self.model.macest_model_params = self.set_macest_model_params()\n\n self.model._distance_to_nn = None\n self.model._ind_of_nn = None\n self.model.point_preds = None\n\n return self.model\n\n\ndef picp_loss(\n interval_model: ModelWithPredictionInterval, x_test: np.ndarray, y_true: np.ndarray\n) -> float:\n \"\"\"\n Calculate the difference between the desired confidence level and the \\\n prediction_interval_coverage_probability for several intervals.\n\n :param interval_model: Some model which makes predictions with a standard deviation\n :param x_test: The variables for which we would like to use to predict a distribution\n :param y_true: The True target value\n\n :return: The loss score\n \"\"\"\n levels = np.array((90, 70, 50, 30, 10))\n\n intervals = interval_model.predict_interval(x_test, conf_level=levels,).T\n\n lower = intervals[0]\n upper = intervals[1]\n loss = 0\n\n for i in range(len(levels)):\n loss += abs(\n levels[i]\n - (\n 100\n * len(\n np.where(np.logical_and(y_true >= lower[i], y_true <= upper[i]))[0]\n )\n / len(y_true)\n )\n )\n return loss / len(levels)\n", "meta": {"hexsha": "be78b929c6ad4429eb33eff858779b56c3d2b1e6", "size": 20794, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/macest/regression/models.py", "max_stars_repo_name": "LaudateCorpus1/macest", "max_stars_repo_head_hexsha": "0a6b7bd26a31900a55164c75938c074c116c78f6", "max_stars_repo_licenses": ["UPL-1.0", "Apache-2.0"], "max_stars_count": 88, "max_stars_repo_stars_event_min_datetime": "2021-08-20T15:34:10.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-17T04:26:20.000Z", "max_issues_repo_path": "src/macest/regression/models.py", "max_issues_repo_name": "LaudateCorpus1/macest", "max_issues_repo_head_hexsha": "0a6b7bd26a31900a55164c75938c074c116c78f6", "max_issues_repo_licenses": ["UPL-1.0", "Apache-2.0"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2022-01-09T17:11:36.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-02T00:43:03.000Z", "max_forks_repo_path": "src/macest/regression/models.py", "max_forks_repo_name": "LaudateCorpus1/macest", "max_forks_repo_head_hexsha": "0a6b7bd26a31900a55164c75938c074c116c78f6", "max_forks_repo_licenses": ["UPL-1.0", "Apache-2.0"], "max_forks_count": 11, "max_forks_repo_forks_event_min_datetime": "2021-08-23T15:28:08.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-18T01:29:24.000Z", "avg_line_length": 37.0659536542, "max_line_length": 114, "alphanum_fraction": 0.6430220256, "include": true, "reason": "import numpy,import scipy,from scipy", "num_tokens": 4641, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5660185351961015, "lm_q2_score": 0.348645142101806, "lm_q1q2_score": 0.19733961263570088}} {"text": "\"\"\"\nThis is the code associated to the paper \"Low Dimensional State Representation Learning with Robotics Priors in Continuous Action Spaces\"\nBotteghi N., et al, published in the International Conference of Intelligent Systems and Robots (IROS), September 2021.\n\nThe StateRepresentation class includes the encoder neural network for learning a low-dimensional state representation\nfrom high-dimesional observations (lidar data points + RGB camera images). The encoder is trained with a new set of\nrobotics priors tailored for continuous state and action spaces.\n\"\"\"\n\nimport tensorflow as tf\n# Hide some depreacation warnings and disable eager execution\ntf.logging.set_verbosity(tf.logging.ERROR)\nimport os\nimport numpy as np\nimport sonnet as snt\nfrom utils import load_pickle, reshape_observation, save_pickle\nfrom tqdm import tqdm\n\nclass ReplayBuffer:\n def __init__(self, obs_dim, act_dim, size):\n self.obs_dim = obs_dim\n self.act_dim = act_dim\n self.size = size\n\n self.obs_buf = np.zeros([int(size), int(obs_dim)], dtype=np.float32)\n self.acts_buf = np.zeros([int(size), int(act_dim)], dtype=np.float32)\n self.rews_buf = np.zeros(int(size), dtype=np.float32)\n self.done_buf = np.zeros(int(size), dtype=np.float32)\n self.sample_nr_buf = np.zeros(int(size), dtype=np.float32)\n self.ptr, self.size, self.max_size = 0, 0, int(size)\n\n def store(self, obs, act, rew, done, sample_nr):\n self.obs_buf[self.ptr] = obs\n self.acts_buf[self.ptr] = act\n self.rews_buf[self.ptr] = rew\n self.done_buf[self.ptr] = done\n self.sample_nr_buf[self.ptr] = sample_nr\n self.ptr = (self.ptr + 1) % self.max_size # replace oldest entry from memory\n self.size = min(self.size + 1, self.max_size)\n\n # def _get_act_seq\n\n def sample_batch(self, batch_size=32):\n idxs = np.random.randint(0, self.size - 1, size=batch_size)\n idxs = idxs[self.done_buf[idxs] != 1.] # remove the last samples of the sequence\n\n obs_dict = dict(obs=self.obs_buf[idxs],\n acts=self.acts_buf[idxs],\n rews=self.rews_buf[idxs - 1],\n done=self.done_buf[idxs],\n sample_nr=self.sample_nr_buf[idxs])\n next_obs_dict = dict(obs=self.obs_buf[idxs + 1],\n acts=self.acts_buf[idxs + 1],\n rews=self.rews_buf[idxs],\n done=self.done_buf[idxs + 1],\n sample_nr=self.sample_nr_buf[idxs + 1])\n return obs_dict, next_obs_dict\n\n def get_all_samples(self):\n return dict(obs=self.obs_buf[:self.size],\n acts=self.acts_buf[:self.size],\n rews=self.rews_buf[:self.size],\n done=self.done_buf[:self.size],\n sample_nr=self.sample_nr_buf[:self.size])\n\n def remove_all(self):\n self.__init__(self.obs_dim, self.act_dim, self.size)\n\n\nclass StateRepresentation(object):\n \"\"\"This class takes care of learning the state representation\"\"\"\n\n def __init__(self, obs_dim, state_dim=5, act_dim=2, batch_size=256, learning_rate=5e-4,\n alpha=2, beta=10, seed=1, continuelearning=False, usingros=False):\n\n folder = \"training_results\"\n filename = 'SRLnetwork'\n if usingros:\n import rospkg\n self.model_path = os.path.join(rospkg.RosPack().get_path(\"rosbot_srl\"), folder, \"srl\", filename + \".ckpt\")\n else:\n self.model_path = os.path.join(\"..\", folder, \"srl\", filename + \".ckpt\")\n\n self.obs_dim = obs_dim # size [32, 24, 40] with 32x24x3 --> size RGB image and 40 --> size of lidar array\n self.obs_count = obs_dim[0] * obs_dim[1] * 3 + obs_dim[2] # calculate the flattened dimension of the observation vector\n self.state_dim = state_dim\n self.act_dim = act_dim # linear and angular velocity of the robot\n self.batch_size = batch_size\n self.learning_rate = learning_rate\n self.alpha = alpha # priors coefficient (see paper for more details)\n self.beta = beta # priors coefficient (see paper for more details)\n self.continuelearning = continuelearning\n\n self.memory = ReplayBuffer(self.obs_count, act_dim=act_dim, size=3e4)\n\n tf.random.set_random_seed(seed=seed)\n np.random.seed(seed=seed)\n\n # DEFINE THE FUNCTIONS REQUIRED FOR TRAINING\n self.graph = tf.Graph()\n with self.graph.as_default():\n # Define the placeholders\n self.obs_1 = tf.placeholder(tf.float32, shape=[None, self.obs_count], name='observation_1')\n self.obs_2 = tf.placeholder(tf.float32, shape=[None, self.obs_count], name='observation_2')\n self.obs_3 = tf.placeholder(tf.float32, shape=[None, self.obs_count], name='observation_3')\n self.obs_4 = tf.placeholder(tf.float32, shape=[None, self.obs_count], name='observation_4')\n\n self.act_1 = tf.placeholder(tf.float32, shape=[None, 2], name='action_1')\n self.act_2 = tf.placeholder(tf.float32, shape=[None, 2], name='action_2')\n\n self.is_training = tf.placeholder(tf.bool, shape=[], name=\"train_cond\")\n\n # Define the neural network architecture and its output\n self.nn = snt.Module(self.SRLencoder, name='SRL_Network')\n self.state_1 = self.nn(self.obs_1, self.is_training)\n self.state_2 = self.nn(self.obs_2, self.is_training)\n\n self.state_delta = self.state_2 - self.state_1\n\n self.state_shuff = self.nn(self.obs_3, self.is_training)\n self.state_4 = self.nn(self.obs_4, self.is_training)\n self.state_delt_shuff = self.state_4 - self.state_shuff\n\n # define losses (i.e. the robotics priors) and optimizer (ADAM)\n\n self.temp_coh_loss = self.temporal_coherence_prior(self.state_delta, self.act_1,alpha=self.alpha)\n\n self.caus_loss = self.causality_prior(self.state_1, self.state_shuff, self.act_1,self.act_2, self.beta)\n\n self.prop_loss = self.proportionality_prior(self.state_delta, self.state_delt_shuff, self.act_1, self.act_2,\n self.beta)\n\n self.repeat_loss = self.repeatability_prior(self.state_1, self.state_shuff, self.state_delta,\n self.state_delt_shuff, self.act_1, self.act_2, self.beta)\n\n graph_regularizers = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)\n total_regularization_loss = tf.reduce_sum(graph_regularizers)\n\n self.losses = [0, 1*self.temp_coh_loss, 2*self.caus_loss, 1*self.prop_loss, 1*self.repeat_loss,\n total_regularization_loss]\n self.loss = tf.reduce_sum(self.losses)\n self.losses[0] = tf.reduce_sum(self.losses[:])\n\n optimizer = tf.train.AdamOptimizer(learning_rate=self.learning_rate)\n update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\n with tf.control_dependencies(update_ops):\n self.train_op = optimizer.minimize(self.loss)\n\n self.saver = tf.train.Saver()\n self.init = tf.global_variables_initializer()\n\n # Initialize the session\n self.sess = tf.Session(graph=self.graph)\n # Restore session if desired\n if continuelearning:\n print('Loading SR model from memory')\n self.load_model()\n else:\n print(\"Starting SR model from scratch!\")\n self.sess.run(self.init)\n\n def SRLencoder(self, observations, is_training, l2_reg=0.001, batch_norm=False):\n\n \"\"\"\n The camera image and the lidar data points are separated from the flattened observation vector via snt.SliceByDim()\n in camera_inputs and laser_inputs. camera_inputs are reshaped into [32, 24, 3] and fed to conv2d layers,\n while laser_inputs are reshaped into [40, 1] and fed to a conv1d layer. Noise is added to the output during training\n for preventing equal state predictions (for more details we reference to \"Learning State Representations with Robotics Priors\"\n Jonschkowski R. et al).\n\n image laser\n | |\n conv2d conv1d\n | |\n conv2d |\n | |\n flatten flatten\n | |\n dense dense\n | |\n --------merge--------\n |\n dense\n |\n dense\n |\n dense\n |\n state\n\n\n :param observations:\n :param is_training:\n :param l2_reg:\n :param batch_norm:\n :return state:\n \"\"\"\n\n regularizers = {\"w\": tf.contrib.layers.l2_regularizer(scale=l2_reg)}\n initializers = {\"w\": tf.keras.initializers.he_normal()}\n\n # Camera branch\n camera_inputs = snt.SliceByDim(dims=[1], begin=[0], size=[self.obs_dim[0] * self.obs_dim[1] * 3])(observations)\n camera_inputs = tf.reshape(camera_inputs, [-1, self.obs_dim[0], self.obs_dim[1], 3])\n\n camera_conv1 = tf.layers.conv2d(camera_inputs, filters=32, kernel_size=3, strides=1, padding='valid',\n activation=tf.nn.relu, kernel_regularizer=regularizers[\"w\"],\n kernel_initializer=initializers[\"w\"])\n\n if batch_norm:\n camera_conv1 = tf.layers.batch_normalization(camera_conv1, training=is_training)\n\n camera_conv2 = tf.layers.conv2d(camera_conv1, filters=64, kernel_size=3, strides=1, padding='valid',\n activation=tf.nn.relu, kernel_regularizer=regularizers[\"w\"],\n kernel_initializer=initializers[\"w\"])\n if batch_norm:\n camera_conv2 = tf.layers.batch_normalization(camera_conv2, training=is_training)\n\n camera_flatten = snt.BatchFlatten()(camera_conv2)\n\n camera_dense1 = tf.layers.dense(camera_flatten, 64, activation=tf.nn.relu, kernel_regularizer=regularizers[\"w\"],\n kernel_initializer=initializers[\"w\"])\n\n # Laser branch\n laser_inputs = snt.SliceByDim(dims=[1], begin=[self.obs_dim[0] * self.obs_dim[1] * 3], size=[self.obs_dim[2]])(\n observations)\n laser_inputs = tf.reshape(laser_inputs, [-1, self.obs_dim[2], 1])\n\n laser_conv1 = tf.layers.conv1d(laser_inputs, filters=32, kernel_size=3, strides=1, padding='valid',\n activation=tf.nn.relu, kernel_regularizer=regularizers[\"w\"],\n kernel_initializer=initializers[\"w\"])\n\n if batch_norm:\n laser_conv1 = tf.layers.batch_normalization(laser_conv1, training=is_training)\n\n\n laser_flatten = snt.BatchFlatten()(laser_conv1)\n\n laser_dense1 = tf.layers.dense(laser_flatten, 64, activation=tf.nn.relu, kernel_regularizer=regularizers[\"w\"],\n kernel_initializer=initializers[\"w\"])\n\n # Merged layers\n merge_input = tf.concat(values=[camera_dense1, laser_dense1], axis=1)\n merge_dense1 = tf.layers.dense(merge_input, 64, activation=tf.nn.relu, kernel_regularizer=regularizers[\"w\"],\n kernel_initializer=initializers[\"w\"])\n merge_dense2 = tf.layers.dense(merge_dense1, 32, activation=tf.nn.relu, kernel_regularizer=regularizers[\"w\"],\n kernel_initializer=initializers[\"w\"])\n\n state = tf.layers.dense(merge_dense2, self.state_dim, activation=None,\n kernel_regularizer=regularizers[\"w\"], kernel_initializer=tf.initializers.zeros)\n\n merge_noise = lambda x: tf.cond(self.is_training, lambda: x + tf.random_normal(shape=tf.shape(x), stddev=1e-6),\n lambda: x)\n return merge_noise(state)\n\n def remember(self, observation, action, reward, done, sample_number):\n self.memory.store(observation, action, reward, done, sample_number)\n\n def learn(self):\n with tqdm(total=self.memory.size) as pbar:\n t_loss = 0\n losses = np.zeros(6)\n nr_batches = self.memory.size // self.batch_size\n for _ in range(nr_batches):\n b1 = self.memory.sample_batch(self.batch_size)\n b2 = self.memory.sample_batch(self.batch_size)\n\n l = min(len(b1[0].get('obs')), len(b2[0].get('obs')))\n\n feed_dict = {self.obs_1: b1[0].get('obs')[:l], self.obs_2: b1[1].get('obs')[:l],\n self.obs_3: b2[0].get('obs')[:l], self.obs_4: b2[1].get('obs')[:l],\n self.act_1: b1[0].get('acts')[:l],\n self.act_2: b2[0].get('acts')[:l],\n self.is_training: True}\n\n _, loss, l = self.sess.run([self.train_op, self.loss, self.losses], feed_dict=feed_dict)\n t_loss += loss\n losses += l\n pbar.update(self.batch_size)\n\n return t_loss / nr_batches, losses / nr_batches\n\n def predict(self, observation):\n feed_dict = {self.obs_1: np.reshape(observation, (1, -1)),\n self.is_training: False}\n state = self.sess.run(self.state_1, feed_dict=feed_dict)\n return state\n\n def predict_all(self, observations, batch_size=512):\n observations = observations.reshape(len(observations), -1)\n states = np.ndarray([len(observations), self.state_dim])\n num_batches = int(np.trunc((observations.shape[0] / batch_size)))\n\n for i in range(num_batches):\n states[i * batch_size: (i + 1) * (batch_size)] = self.sess.run(self.state_1, feed_dict={\n self.obs_1: observations[i * batch_size: (i + 1) * (batch_size)], self.is_training: False})\n states[num_batches * batch_size:] = self.sess.run(self.state_1, feed_dict={\n self.obs_1: observations[num_batches * batch_size:], self.is_training: False})\n return states\n\n def get_memory_states(self):\n states = []\n mem = self.memory.get_all_samples().get('obs')\n\n states = self.predict_all(mem)\n return states, self.memory.get_all_samples()\n\n def save_model(self):\n print(\"SRL Network storing model..........\")\n return self.saver.save(self.sess, self.model_path)\n\n def load_model(self):\n print(\"SRL Network restoring data...........\")\n self.saver.restore(self.sess, self.model_path)\n\n # Each prior is defined in a function\n\n def temporal_coherence_prior(self, s_d, a1, alpha=2):\n \"\"\"\n E[||s_t+1 - s_t||_2 * e^(-alpha * ||a||_2)]\n\n :param s_d: s_t+1 - s_t\n :param a1: action connecting s_t and s_t+1\n :param alpha:\n :return: expectation of the temporal coherence loss\n \"\"\"\n\n return tf.reduce_mean(tf.math.exp(-alpha * tf.norm(a1, ord=2, axis=1)) * tf.norm(s_d, ord=2, axis=1) ** 2)\n\n\n def causality_prior(self, s1, s2, a1, a2, beta):\n \"\"\"\n E[e^(-||s1-s2||^2) * e^(-beta*||a1-a2||^2)]\n\n :param s1: state s_t1\n :param s2: state s_t2\n :param a1: action connecting s_t1 and s_t1+1\n :param a2: action connecting s_t2 and s_t2+1\n :param beta: weighting factor\n :return: expectation of the causality loss\n \"\"\"\n closs1 = tf.math.exp(-tf.norm(s1 - s2, ord=2, axis=1) ** 2)\n closs2 = tf.math.exp(-beta*tf.norm(a2 - a1, ord=2, axis=1) ** 2)\n\n return tf.reduce_mean(closs1 * closs2)\n\n def proportionality_prior(self, sd1, sd2, a1, a2, beta):\n \"\"\"\n E[(||s_t2+1 - s_t2||_2 - ||s_t1+1 - s_t1||_2)^2 * e^(-beta * ||a1 - a2||_2)^2]\n\n :param sd1: s_t1+1 - s_t1\n :param sd2: s_t2+1 - s_t2\n :param a1: action connecting s_t1 and s_t1+1\n :param a2: action connecting s_t2 and s_t2+1\n :param beta: weighting factor\n :return: expectation of the proportinality loss\n \"\"\"\n ploss1 = (tf.norm(sd2, ord=2, axis=1) - tf.norm(sd1, ord=2, axis=1)) ** 2\n ploss2 = tf.math.exp(-beta * tf.norm(a1 - a2, ord=2, axis=1) ** 2)\n\n return tf.reduce_mean(ploss1 * ploss2)\n\n\n def repeatability_prior(self, s1, s2, s_d1, s_d2, a1, a2, beta):\n \"\"\"\n E[||(s_t2+1 - s_t2) - (s_t1+1 - s_t1)||_2)^2 * e^(-||s1-s2||^2) * e^(-beta * ||a1 - a2||_2)^2]\n\n\n :param s1: state s_t1\n :param s2: state s_t2\n :param s_d1: s_t1+1 - s_t1\n :param s_d2: s_t2+1 - s_t2\n :param a1: action connecting s_t1 and s_t1+1\n :param a2: action connecting s_t2 and s_t2+1\n :param beta: weighting factor\n :return: expectation of the repeatability loss\n \"\"\"\n rloss1 = tf.math.exp(-tf.norm(s1 - s2, ord=2, axis=1) ** 2)\n rloss2 = tf.norm(s_d2 - s_d1, ord=2, axis=1) ** 2\n rloss3 = tf.math.exp( -beta*tf.norm(a1 - a2, ord=2, axis=1) ** 2)\n\n return tf.reduce_mean(rloss1 * rloss2 * rloss3)\n\n\nif __name__ == '__main__':\n from Logger import Logger\n import Plotter as plotter\n\n # Load saved observations from memory (samples collected by random exploring the large 4 walls environment --> see our paper)\n folder = 'training_data/observations_4walls_large.pkl'\n\n data = load_pickle(folder)\n print('Loaded {} data points'.format(len(data)))\n\n\n srl = StateRepresentation(obs_dim=[32, 24, 40], state_dim=5, act_dim=2, batch_size=256, learning_rate=5e-4, alpha=2,\n beta=10, seed=3, continuelearning=False, usingros=False)\n\n\n # add all data to srl memory\n for d in data:\n srl.remember(reshape_observation(d[0]), d[1], d[2], d[3], d[4])\n\n epochs = 20\n loss_history = []\n\n # training the encoder for 20 epochs\n for epoch in range(epochs):\n loss, losses = srl.learn()\n print('Finished epoch {}/{}. The loss this epoch was: {}'.format(epoch + 1, epochs, loss))\n print('temp_coh_loss: {} caus_loss: {} prop_loss: {} repeat_loss: {}'.format(losses[1], losses[2], losses[3],\n losses[4]))\n\n loss_history.append(losses)\n\n # save the trained model\n srl.save_model()\n\n # compute all the states from the observations\n print('Finished training, now predicting all states')\n lg = Logger('./')\n gt = []\n for d in data:\n gt.append(d[0][40:45])\n lg.log(\"position_obs\", d[0][40:45])\n lg.log(\"rewards\", d[2])\n\n states, _ = srl.get_memory_states()\n\n # visualise the results\n print('Plotting the results')\n\n plotter.plot_all_srl(states=states, rews=srl.memory.get_all_samples().get('rews'), data_dict=lg.logDict,\n loss_history=loss_history, trainingcycle=2, save=True, size=15000, name=\"continuous\")\n\n\n", "meta": {"hexsha": "0824950831489ea668059fc94cafc692f1cbf0a6", "size": 19188, "ext": "py", "lang": "Python", "max_stars_repo_path": "SRL_RoboticsPriors_ContinuousActions.py", "max_stars_repo_name": "nicob15/StateRepresentationLearning_with_RoboticsPriors", "max_stars_repo_head_hexsha": "a5bf33b3bafe2cdd55f9f2de5ecd1736c3165656", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "SRL_RoboticsPriors_ContinuousActions.py", "max_issues_repo_name": "nicob15/StateRepresentationLearning_with_RoboticsPriors", "max_issues_repo_head_hexsha": "a5bf33b3bafe2cdd55f9f2de5ecd1736c3165656", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "SRL_RoboticsPriors_ContinuousActions.py", "max_forks_repo_name": "nicob15/StateRepresentationLearning_with_RoboticsPriors", "max_forks_repo_head_hexsha": "a5bf33b3bafe2cdd55f9f2de5ecd1736c3165656", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.9084668192, "max_line_length": 137, "alphanum_fraction": 0.5976652074, "include": true, "reason": "import numpy", "num_tokens": 4712, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5660185498374789, "lm_q2_score": 0.3486451217982255, "lm_q1q2_score": 0.19733960624814278}} {"text": "\"\"\"\nadaptive split data into bins.\n\"\"\"\n\nimport functools\n\nimport numpy as np\n\nfrom .data import data_index, data_mask\n\ntry:\n import matplotlib.patches as mpathes\nexcept ImportError:\n pass\n\n\nclass AdaptiveBound(object):\n \"\"\"adaptive bound cut for data value\"\"\"\n\n def __init__(self, base_data, bins):\n if isinstance(bins, int):\n self._base_data = np.array([base_data])\n self.bins = [bins]\n elif isinstance(bins, list):\n self._base_data = np.array(base_data)\n self.bins = bins\n else:\n raise TypeError(\n \"bins should be int or list of int, \"\n + \"insteading of {}\".format(type(bins))\n )\n\n @functools.lru_cache()\n def get_bounds_data(self):\n \"\"\"get split data bounds, and the data after splitting\"\"\"\n base_bound = AdaptiveBound.base_bound(self._base_data)\n bounds, datas = AdaptiveBound.loop_split_bound(\n self._base_data, self.bins\n )\n return bounds, datas\n\n def get_bounds(self):\n \"\"\"get split data bounds\"\"\"\n bounds, _ = self.get_bounds_data()\n return bounds\n\n def get_bool_mask(self, data):\n \"\"\"bool mask for splitting data\"\"\"\n bounds = self.get_bounds()\n idx_data = data[: bounds[0][0].shape[0]]\n ret = []\n for lb, rb in bounds:\n mask = np.logical_and(\n idx_data >= lb[..., np.newaxis], idx_data < rb[..., np.newaxis]\n )\n mask = np.all(mask, axis=0)\n ret.append(mask)\n return ret\n\n def split_full_data(self, data, base_index=None):\n \"\"\"split structure data, (TODO because large IO, the method is slow.)\"\"\"\n base_data = [[data_index(data, i) for i in base_index]]\n mask = self.get_bool_mask(base_data)\n ret = []\n for i in mask:\n ret.append(data_mask(data, i))\n return ret\n\n def split_data(self, data):\n \"\"\"split data, the shape is same as base_data\"\"\"\n mask = self.get_bool_mask(data)\n ret = []\n for i in mask:\n ret.append(data[..., i])\n return ret\n\n @staticmethod\n def single_split_bound(data, n=2, base_bound=None):\n \"\"\"split data in the order of data value\n\n >>> data = np.array([1.0, 2.0, 1.4, 3.1])\n >>> AdaptiveBound.single_split_bound(data)\n [(1.0, 1.7...), (1.7..., 3.1...)]\n\n \"\"\"\n if base_bound is None:\n base_bound = np.min(data), np.max(data) + 1e-6\n num_lb = base_bound[0]\n bounds = []\n for j in range(1, n):\n num_rb = np.percentile(data, j / n * 100, axis=0) + 1e-6\n bounds.append((num_lb, num_rb))\n num_lb = num_rb\n bounds.append((num_lb, base_bound[1]))\n return bounds\n\n @staticmethod\n def multi_split_bound(datas, n, base_bound=None):\n \"\"\"multi data for single_split_bound, so `n` is list of int\n\n >>> data = np.array([[1.0, 2.0, 1.4, 3.1], [2.0, 1.0, 3.0, 1.0]])\n >>> bound, _ = AdaptiveBound.multi_split_bound(data, [2, 1])\n >>> [(i[0][0]+1e-6, i[1][0]+1e-6) for i in bound]\n [(1.0..., 1.7...), (1.7..., 3.1...)]\n\n \"\"\"\n datas = np.array(datas)\n if base_bound is None:\n base_bound = AdaptiveBound.base_bound(datas)\n bound_chain = [base_bound]\n data_chain = [datas]\n for idx, size in enumerate(n):\n new_bound_chain = []\n new_data_chain = []\n for bnd, data in zip(bound_chain, data_chain):\n idx_data = data[idx]\n bounds = AdaptiveBound.single_split_bound(\n idx_data, size, base_bound=(bnd[0][idx], bnd[1][idx])\n )\n for i in bounds:\n lb, rb = i\n l_bnd, r_bnd = bnd\n l_bnd = np.copy(l_bnd)\n r_bnd = np.copy(r_bnd)\n l_bnd[idx] = lb\n r_bnd[idx] = rb\n new_bound_chain.append((l_bnd, r_bnd))\n mask = np.logical_and(idx_data >= lb, idx_data < rb)\n new_data_chain.append(data[:, mask])\n bound_chain = new_bound_chain\n data_chain = new_data_chain\n return bound_chain, data_chain\n\n @staticmethod\n def loop_split_bound(datas, n, base_bound=None):\n \"\"\"loop for multi_split_bound, so `n` is list of list of int\"\"\"\n datas = np.array(datas)\n if base_bound is None:\n base_bound = AdaptiveBound.base_bound(datas)\n bound_chain = [base_bound]\n data_chain = [datas]\n for idx, size in enumerate(n):\n new_bound_chain = []\n new_data_chain = []\n for bnd, data in zip(bound_chain, data_chain):\n bound, data_i = AdaptiveBound.multi_split_bound(\n data, size, base_bound=bnd\n )\n new_bound_chain += bound\n new_data_chain += data_i\n bound_chain = new_bound_chain\n data_chain = new_data_chain\n return bound_chain, data_chain\n\n @staticmethod\n def base_bound(data):\n \"\"\"base bound for the data\"\"\"\n lb = np.min(data, axis=-1) - 1e-6\n rb = np.max(data, axis=-1) + 1e-6\n return (lb, rb)\n\n def get_bound_patch(self, **kwargs):\n ret = []\n for i, bnd in enumerate(self.get_bounds()):\n min_x, min_y = bnd[0]\n max_x, max_y = bnd[1]\n rect = mpathes.Rectangle(\n (min_x, min_y), max_x - min_x, max_y - min_y, **kwargs\n ) # cmap(weights[i]/max_weight))\n ret.append(rect)\n return ret\n\n def plot_bound(self, ax, **kwargs):\n for i in self.get_bound_patch(**kwargs):\n ax.add_patch(i)\n\n\ndef cal_chi2(numbers, n_fp):\n weights = []\n # print(numbers)\n # chi21 = []\n for ndata, nmc in numbers:\n weight = (ndata - nmc) / np.sqrt(np.abs(ndata))\n weights.append(weight ** 2)\n # chi21.append(ndata * np.log(nmc))\n max_weight = np.max(weights)\n chi2 = np.sum(weights)\n print(\"bins: \", len(weights))\n print(\"number of free parameters: \", n_fp)\n ndf = len(weights) - 1 - n_fp\n print(\n \"chi2/ndf: \", np.sum(weights), \"/\", ndf\n ) # ,\"another\", np.sum(chi21))\n return chi2, ndf\n", "meta": {"hexsha": "b5d4f988a7a84bcc1c34aa933855a3047e2b8b57", "size": 6390, "ext": "py", "lang": "Python", "max_stars_repo_path": "tf_pwa/adaptive_bins.py", "max_stars_repo_name": "ReynLieu/tf-pwa", "max_stars_repo_head_hexsha": "f354b5036bc8c37ffba95849de5ec3367934eef8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2021-05-10T15:17:24.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-16T07:40:06.000Z", "max_issues_repo_path": "tf_pwa/adaptive_bins.py", "max_issues_repo_name": "ReynLieu/tf-pwa", "max_issues_repo_head_hexsha": "f354b5036bc8c37ffba95849de5ec3367934eef8", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 45, "max_issues_repo_issues_event_min_datetime": "2020-10-24T08:26:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-20T06:14:58.000Z", "max_forks_repo_path": "tf_pwa/adaptive_bins.py", "max_forks_repo_name": "ReynLieu/tf-pwa", "max_forks_repo_head_hexsha": "f354b5036bc8c37ffba95849de5ec3367934eef8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2020-10-24T06:41:06.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-03T01:29:49.000Z", "avg_line_length": 32.7692307692, "max_line_length": 81, "alphanum_fraction": 0.5374021909, "include": true, "reason": "import numpy", "num_tokens": 1613, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5660185351961013, "lm_q2_score": 0.34864512856608565, "lm_q1q2_score": 0.19733960497423222}} {"text": "import psi4 \nimport numpy as np\n\npsi4.set_options({'scf_type': 'df',\n 'freeze_core': 'true'})\n \n#different combinations of the isomers \n\n#O/M = comparison1 \n#O/P = comparison2 \n#M/P = comparison3 \n\n#comparison1 O/M \n\n\ncomparison1 = psi4.geometry(\"\"\"\n\n0 1 \n\nO 1.72900 1.44890 1.30290\nO 0.52150 -2.76860 0.50990\nO 1.94280 1.60280 -0.95480\nO 1.94610 -1.35340 -0.55510\nC -0.07460 0.73300 -0.00740\nC -0.28440 -0.64490 -0.05810\nC -1.16380 1.60440 0.00750\nC -1.58340 -1.15170 -0.09400\nC -2.46290 1.09750 -0.02840\nC -2.67270 -0.28050 -0.07920\nC 1.27000 1.29310 0.03190\nC 0.83250 -1.58060 -0.07500\nH -1.01340 2.68020 0.04680\nH -1.78090 -2.21920 -0.14740\nH -3.31100 1.77580 -0.01770\nH -3.68430 -0.67460 -0.11040\nH 2.63430 1.82640 1.32040\nH 1.27850 -3.39240 0.49470\n\n--\n\n0 1 \nO -3.54720 0.18420 0.00030\nO 3.54710 0.18450 -0.00070\nO -2.58510 -1.87520 -0.00050\nO 2.58550 -1.87510 0.00060\nC -1.20810 0.08130 0.00030\nC 1.20790 0.08110 -0.00010\nC -0.00020 -0.61630 0.00010\nC -1.20790 1.47630 0.00020\nC 1.20790 1.47610 -0.00020\nC 0.00000 2.17360 0.00010\nC -2.46790 -0.64530 -0.00040\nC 2.46800 -0.64530 0.00040\nH -0.00020 -1.70390 0.00010\nH -2.12470 2.05900 0.00020\nH 2.12470 2.05880 -0.00020\nH 0.00010 3.25980 0.00000\nH -4.39140 -0.31530 0.00040\nH 4.39150 -0.31500 -0.00100\n\"\"\")\n\npsi4.energy('sapt0/jun-cc-pvdz', molecule=comparison1)\n\n\none_disp = psi4.variable('SSAPT0 DISP ENERGY')\none_elst = psi4.variable('SSAPT0 ELST ENERGY')\none_exch = psi4.variable('SSAPT0 EXCH ENERGY')\none_ind = psi4.variable('SSAPT0 IND ENERGY')\none_tot =psi4.variable('SSAPT0 TOTAL ENERGY')\n\n\n\n#comparison2 O/P\n \ncomparison2 = psi4.geometry(\"\"\"\n \n0 1\n \nO 1.72900 1.44890 1.30290\nO 0.52150 -2.76860 0.50990\nO 1.94280 1.60280 -0.95480\nO 1.94610 -1.35340 -0.55510\nC -0.07460 0.73300 -0.00740\nC -0.28440 -0.64490 -0.05810\nC -1.16380 1.60440 0.00750\nC -1.58340 -1.15170 -0.09400\nC -2.46290 1.09750 -0.02840\nC -2.67270 -0.28050 -0.07920\nC 1.27000 1.29310 0.03190\nC 0.83250 -1.58060 -0.07500\nH -1.01340 2.68020 0.04680\nH -1.78090 -2.21920 -0.14740\nH -3.31100 1.77580 -0.01770\nH -3.68430 -0.67460 -0.11040\nH 2.63430 1.82640 1.32040\nH 1.27850 -3.39240 0.49470\n \n--\n \n0 1 \nO 3.39660 1.18370 -0.00030\nO -3.39650 -1.18360 -0.00070\nO 3.54230 -1.08460 0.00020\nO -3.54230 1.08470 0.00000\nC 1.39460 -0.03050 -0.00050\nC -1.39450 0.03050 0.00050\nC 0.72350 1.19240 -0.00030\nC -0.67100 1.22300 0.00030\nC 0.67090 -1.22310 -0.00020\nC -0.72370 -1.19250 0.00030\nC 2.84840 -0.06240 0.00030\nC -2.84820 0.06250 0.00030\nH 1.24760 2.14410 -0.00030\nH -1.17530 2.18580 0.00040\nH 1.17520 -2.18590 -0.00010\nH -1.24770 -2.14420 0.00050\nH 4.37700 1.15110 -0.00040\nH -4.37700 -1.15080 -0.00130\n\"\"\")\n\npsi4.energy('sapt0/jun-cc-pvdz', molecule=comparison2)\n\n\n\ntwo_disp = psi4.variable('SSAPT0 DISP ENERGY')\ntwo_elst = psi4.variable('SSAPT0 ELST ENERGY')\ntwo_exch = psi4.variable('SSAPT0 EXCH ENERGY')\ntwo_ind = psi4.variable('SSAPT0 IND ENERGY')\ntwo_tot =psi4.variable('SSAPT0 TOTAL ENERGY')\n\n\n#comparison3 M/P\n\ncomparison3 = psi4.geometry(\"\"\"\n\n0 1 \nO -3.54720 0.18420 0.00030\nO 3.54710 0.18450 -0.00070\nO -2.58510 -1.87520 -0.00050\nO 2.58550 -1.87510 0.00060\nC -1.20810 0.08130 0.00030\nC 1.20790 0.08110 -0.00010\nC -0.00020 -0.61630 0.00010\nC -1.20790 1.47630 0.00020\nC 1.20790 1.47610 -0.00020\nC 0.00000 2.17360 0.00010\nC -2.46790 -0.64530 -0.00040\nC 2.46800 -0.64530 0.00040\nH -0.00020 -1.70390 0.00010\nH -2.12470 2.05900 0.00020\nH 2.12470 2.05880 -0.00020\nH 0.00010 3.25980 0.00000\nH -4.39140 -0.31530 0.00040\nH 4.39150 -0.31500 -0.00100\n\n--\n \n0 1 \nO 3.39660 1.18370 -0.00030\nO -3.39650 -1.18360 -0.00070\nO 3.54230 -1.08460 0.00020\nO -3.54230 1.08470 0.00000\nC 1.39460 -0.03050 -0.00050\nC -1.39450 0.03050 0.00050\nC 0.72350 1.19240 -0.00030\nC -0.67100 1.22300 0.00030\nC 0.67090 -1.22310 -0.00020\nC -0.72370 -1.19250 0.00030\nC 2.84840 -0.06240 0.00030\nC -2.84820 0.06250 0.00030\nH 1.24760 2.14410 -0.00030\nH -1.17530 2.18580 0.00040\nH 1.17520 -2.18590 -0.00010\nH -1.24770 -2.14420 0.00050\nH 4.37700 1.15110 -0.00040\nH -4.37700 -1.15080 -0.00130\n\"\"\")\n\n\npsi4.energy('sapt0/jun-cc-pvdz', molecule=comparison3)\n\n\nthree_disp = psi4.variable('SSAPT0 DISP ENERGY')\nthree_elst = psi4.variable('SSAPT0 ELST ENERGY')\nthree_exch = psi4.variable('SSAPT0 EXCH ENERGY')\nthree_ind = psi4.variable('SSAPT0 IND ENERGY')\nthree_tot =psi4.variable('SSAPT0 TOTAL ENERGY')\n\n#comparing the interaction energies for each dimer \n\nlabels = np.array(['disp','elst','exch','ind','tot'])\n\ndispersion = np.array([one_disp,two_disp,three_disp])\n\nelst = np.array([one_elst,two_elst,three_elst])\n\nexch = np.array([one_exch,two_exch,three_exch])\n\nind = np.array([one_ind,two_ind,three_ind])\n\nind = np.array([one_ind,two_ind,three_ind])\n\ntot = np.array([one_tot,two_tot,three_tot])\n\n#plotting these comparisons \n\nplt.plot(comparison,tot,'-ob')\n\nplt.plot(comparison,ind,'-xr')\n\nplt.plot(comparison,exch,'-py')\n\nplt.plot(comparison,elst,'-dk')\n\nplt.plot(comparison,dispersion,'-m<')\n\nplt.show()\n\n\n", "meta": {"hexsha": "af226cfce5a6d0af4f02d92d573b4c352f09cc96", "size": 7256, "ext": "py", "lang": "Python", "max_stars_repo_path": "calculation.py", "max_stars_repo_name": "mw00847/OMP", "max_stars_repo_head_hexsha": "b2cd0e4d212e359e11afb5940e25d20018f07053", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "calculation.py", "max_issues_repo_name": "mw00847/OMP", "max_issues_repo_head_hexsha": "b2cd0e4d212e359e11afb5940e25d20018f07053", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "calculation.py", "max_forks_repo_name": "mw00847/OMP", "max_forks_repo_head_hexsha": "b2cd0e4d212e359e11afb5940e25d20018f07053", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.9818181818, "max_line_length": 54, "alphanum_fraction": 0.4714718853, "include": true, "reason": "import numpy", "num_tokens": 2748, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6150878555160665, "lm_q2_score": 0.3208212878370535, "lm_q1q2_score": 0.19733327793959593}} {"text": "\"\"\"\nDynamic Routing Between Capsules\nhttps://arxiv.org/abs/1710.09829\n\nPyTorch implementation by Kenta Iwasaki @ Gram.AI.\nCapsRT implemented by horsepurve.\n\"\"\"\n\nimport torch\nimport torch.nn.functional as F\nfrom torch import nn\nimport numpy as np\nfrom torch.autograd import Variable\nimport pickle\nfrom scipy import sparse\nfrom config import *\n\nCNN_EMB = True # False # \n\nBATCH_SIZE = 16 # 16\nNUM_CLASSES = 10\nNUM_EPOCHS = 20\nNUM_ROUTING_ITERATIONS = 1\nCUDA = False # True # False # \nLR = 0.01\n\n# train_path = 'data/dia_train_269.txt' # 'data/mod_train_2.txt' # 'data/unmod_train_2.txt' # 'data/SCX_train_42.txt' # \n# test_path = 'data/dia_test_269.txt' # 'data/mod_test_2.txt' # 'data/unmod_test_2.txt' # 'data/SCX_test_42.txt' # \n# result_path = 'dia_pred_269.txt' # 'mod_pred_2.txt' # 'unmod_pred_2.txt' # 'SCX_pred_42.txt' # \nRTdata_path = 'dia.pkl' # 'mod.pkl' # 'unmod.pkl' # 'SCX.pkl' # \nLOAD_DATA = True # False # \n# TODO: add max_length to config.py\n## max_length = 66 # 66 # 50 # 38 # 50 # \n\n# log_path = ''\nif '' == dict_path:\n dict_path = train_path\n\nfrom RTdata_emb import Dictionary, RTdata, Pearson, Spearman, Delta_t95, DATA_AUGMENTATION, Corpus\ndictionary = Dictionary(dict_path)\n'''\nif True == LOAD_DATA:\n dictionary = Dictionary(dict_path)\n RTtrain = RTdata(dictionary, max_length, train_path)\n RTtest = RTdata(dictionary, max_length, test_path)\n with open(RTdata_path, 'wb') as output:\n pickle.dump(dictionary, output)\n pickle.dump(RTtrain, output)\n pickle.dump(RTtest, output)\nif False == LOAD_DATA:\n with open(RTdata_path, 'rb') as input:\n dictionary = pickle.load(input)\n RTtrain = pickle.load(input)\n RTtest = pickle.load(input)\n print('>> note: load pre-read RTdata from:', RTdata_path)\n\n# DATA_AUGMENTATION = True\nSPARSE = True\ndef desparse(RTtt):\n X = np.zeros((RTtt.number_seq, RTtt.N_aa, RTtt.N_time_step)) # DATA_AUGMENTATION->*2\n for i in range(RTtt.number_seq): # DATA_AUGMENTATION->*2\n # sparse to dense\n X[i,::] = RTtt.X[i].todense()\n RTtt.X = X\nif True == SPARSE:\n print('>> note: de-sparse for both train & test data.')\n desparse(RTtrain)\n desparse(RTtest)\n'''\n\ndef softmax(input, dim=1):\n transposed_input = input.transpose(dim, len(input.size()) - 1)\n # print(transposed_input.contiguous().view(-1, transposed_input.size(-1)).shape)\n '''\n PyTorch 0.3.0:\n UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n '''\n softmaxed_output = F.softmax(transposed_input.contiguous().view(-1, transposed_input.size(-1)),dim=1)\n return softmaxed_output.view(*transposed_input.size()).transpose(dim, len(input.size()) - 1)\n\n\ndef augmentation(x, max_shift=2):\n _, _, height, width = x.size()\n\n h_shift, w_shift = np.random.randint(-max_shift, max_shift + 1, size=2)\n source_height_slice = slice(max(0, h_shift), h_shift + height)\n source_width_slice = slice(max(0, w_shift), w_shift + width)\n target_height_slice = slice(max(0, -h_shift), -h_shift + height)\n target_width_slice = slice(max(0, -w_shift), -w_shift + width)\n\n shifted_image = torch.zeros(*x.size())\n shifted_image[:, :, source_height_slice, source_width_slice] = x[:, :, target_height_slice, target_width_slice]\n return shifted_image.float() # Note float here!\n\n\nclass CapsuleLayer(nn.Module):\n def __init__(self, \n num_capsules, \n num_route_nodes, \n in_channels, \n out_channels, \n kernel_size=None, \n stride=None,\n num_iterations=NUM_ROUTING_ITERATIONS):\n\n super(CapsuleLayer, self).__init__()\n\n self.num_route_nodes = num_route_nodes\n self.num_iterations = num_iterations\n\n self.num_capsules = num_capsules\n\n if num_route_nodes != -1:\n self.route_weights = nn.Parameter(torch.randn(num_capsules, \n num_route_nodes, \n in_channels, \n out_channels))\n else:\n self.capsules = nn.ModuleList(\n [nn.Conv2d(in_channels, \n out_channels, \n kernel_size=kernel_size, \n stride=stride, \n padding=0) for _ in\n range(num_capsules)])\n\n def squash(self, tensor, dim=-1):\n squared_norm = (tensor ** 2).sum(dim=dim, keepdim=True)\n scale = squared_norm / (1 + squared_norm)\n return scale * tensor / torch.sqrt(squared_norm)\n\n def forward(self, x):\n if self.num_route_nodes != -1:\n priors = x[None, :, :, None, :] @ self.route_weights[:, None, :, :, :]\n\n if True == CUDA:\n logits = Variable(torch.zeros(*priors.size())).cuda()\n if False == CUDA:\n logits = Variable(torch.zeros(*priors.size()))\n\n for i in range(self.num_iterations):\n probs = softmax(logits, dim=2)\n outputs = self.squash((probs * priors).sum(dim=2, keepdim=True))\n\n if i != self.num_iterations - 1:\n delta_logits = (priors * outputs).sum(dim=-1, keepdim=True)\n logits = logits + delta_logits\n else:\n outputs = [capsule(x).view(x.size(0), -1, 1) for capsule in self.capsules]\n outputs = torch.cat(outputs, dim=-1)\n outputs = self.squash(outputs)\n\n return outputs\n\nparam_2D = {'data' : 'mnist',\n 'dim' : 2,\n 'conv1_kernel' : 9,\n 'pri_caps_kernel' : 9,\n 'stride' : 2,\n 'digit_caps_nodes' : 32 * 6 * 6,\n 'NUM_CLASSES' : NUM_CLASSES}\n\nparam_1D = {'data' : 'mnist',\n 'dim' : 1,\n 'conv1_kernel' : (28, 9),\n 'pri_caps_kernel' : (1, 9),\n 'stride' : 1,\n 'digit_caps_nodes' : 32 * 1 * 12,\n 'NUM_CLASSES' : 1}\n\n# conv1_kernel = 15\n# conv2_kernel = 15\nparam_1D_rt = {'data' : 'rt',\n 'dim' : 1,\n 'conv1_kernel' : (len(dictionary), conv1_kernel),\n 'pri_caps_kernel' : (1, conv2_kernel),\n 'stride' : 1,\n 'digit_caps_nodes' : 32 * 1 * (max_length - conv1_kernel*2 + 2 - conv2_kernel + 1), # 32 # Note: number of conv!\n 'NUM_CLASSES' : 1}\n\nparam = param_1D_rt\n\nif 2 == param['dim']:\n print('>> note: using image mode.')\nif 1 == param['dim']:\n print('>> note: using seq mode.')\n\nclass CapsuleNet(nn.Module):\n def __init__(self,conv1_kernel,conv2_kernel):\n super(CapsuleNet, self).__init__()\n EMB_SIZE = 0\n if True == CNN_EMB:\n # self.emb = nn.Embedding(len(dictionary), len(dictionary))\n # Note: if using embedding, EMB_SIZE can be any value, and we choose 20 here\n EMB_SIZE = 20\n self.emb = nn.Embedding(len(dictionary), EMB_SIZE) # we use 20 for all data\n else:\n # Note: if using one-hot encoding, EMB_SIZE must be the same as len(dictionary)\n EMB_SIZE = len(dictionary)\n self.conv1 = nn.Conv2d(in_channels=1, \n out_channels=256, # 256\n kernel_size=(EMB_SIZE, conv1_kernel), # param['conv1_kernel'], # (28, 9), # 9, \n stride=1)\n ''''''\n self.bn1 = nn.BatchNorm2d(256) # Note: do we need this or not?\n self.conv2 = nn.Conv2d(in_channels=256, \n out_channels=256, # 256\n kernel_size=(1, conv1_kernel), # (28, 9), # 9, \n stride=1)\n self.bn2 = nn.BatchNorm2d(256)\n '''\n self.conv3 = nn.Conv2d(in_channels=128, \n out_channels=256, # 256\n kernel_size=(1, conv1_kernel), # (28, 9), # 9, \n stride=1)\n self.bn3 = nn.BatchNorm2d(256)\n '''\n\n self.primary_capsules = CapsuleLayer(num_capsules=8, # 8\n num_route_nodes=-1, \n in_channels=256, # 256\n out_channels=32, # 32\n kernel_size=(1, conv2_kernel), # param['pri_caps_kernel'], # (1, 9), # 9, \n stride=param['stride']) # 1) # 2)\n\n self.digit_capsules = CapsuleLayer(num_capsules=param['NUM_CLASSES'], # 1, #NUM_CLASSES, # DeepRT\n num_route_nodes=32 * 1 * (max_length - conv1_kernel*2 + 2 - conv2_kernel + 1), # param['digit_caps_nodes'], # 32 * 1 * 12, # 32 * 6 * 6, \n in_channels=8, # 8\n out_channels=16) # max_length-conv1_kernel + 1) # 16\n\n # add dropout:\n # self.dropout = nn.Dropout(0.1) # not good!\n # self.linear = nn.Linear((max_length-conv1_kernel+1)*256,16) # try residue: not good!\n ''' residue is not very good!\n pad = 0\n kernel_h = pad*2+1 # len + pad*2 - (kernel_h - 1) = len\n self.conv_res = nn.Conv2d(in_channels=256, \n out_channels=1, # 256\n kernel_size=(1, kernel_h), # (28, 9), # 9, \n stride=1)\n #padding =(0,pad))\n '''\n self.decoder = nn.Sequential(\n nn.Linear(16 * NUM_CLASSES, 512),\n nn.ReLU(inplace=True),\n nn.Linear(512, 1024),\n nn.ReLU(inplace=True),\n nn.Linear(1024, 784),\n nn.Sigmoid()\n )\n\n def forward(self, x, y=None):\n # print('>>dim: input', x.shape) # [batch, 1, 28, 28]\n # print('>>dim: y', y) # [batch, 10] ~ [batch, NUM_CLASSES]\n if True == CNN_EMB:\n x = self.emb(x) # [batch, len] -> [batch, len, dict]\n x = x.transpose(dim0=1, dim1=2) # -> [batch, dict, len]\n x = x[:,None,:,:] # -> [batch, 1, dict, len]\n\n # ^^^^^ pre-process x ^^^^^\n x = F.relu(self.bn1(self.conv1(x)), inplace=True) \n\n ''' try residue: not good! \n residue = x.view(x.shape[0],-1) \n residue = self.linear(residue).view(residue.shape[0],1,16)\n # another residue method\n residue = F.relu(self.conv_res(x), inplace=True)\n residue = residue.view(residue.shape[0],1,residue.shape[-1])\n '''\n\n # x = self.dropout(x)\n x = F.relu(self.bn2(self.conv2(x)), inplace=True) # improvement\n # x = F.relu(self.bn3(self.conv3(x)), inplace=True)\n # print('>>dim: conv1', x.shape) # [batch, 256, 20, 20]\n x = self.primary_capsules(x)\n # print('>>dim: primary_capsules', x.shape) # [batch, 1152, 8] = [batch, 6*6*32, 8]\n # print('>>dim: unsqueezeed', self.digit_capsules(x).shape) # [10, batch, 1, 1, 16] ~ [num_caps, batch, ...]\n if 2 == param['dim']:\n x = self.digit_capsules(x).squeeze().transpose(0, 1) # DeepRT\n # [10, batch, 1, 1, 16] -> squeeze: [10, batch, 16] -> transpose: [batch, 10, 16]\n if 1 == param['dim']:\n x = self.digit_capsules(x).squeeze()[:, None, :]\n # [1, batch, 1, 1, 16] -> squeeze: [batch, 16]\n # print('>>dim: digit_capsules', x.shape) # [batch, 10, 16]\n\n # add dropout:\n # x = self.dropout(x)\n # x = self.linear(x)\n # x = F.sigmoid(x)\n \n # x = x + residue # try residue: not good!\n classes = (x ** 2).sum(dim=-1) ** 0.5\n # print('>>dim: classes', classes) # [batch, 10]\n if 2 == param['dim']:\n classes = F.softmax(classes) # DeepRT\n # print('>>dim: softmax', classes)\n\n if y is None: # Note: not do this during training. Here y is only used for reconstruction\n if 2 == param['dim']:\n # In all batches, get the most active capsule.\n # print('>>dim: reconstruction', classes) # [batch, 10]\n _, max_length_indices = classes.max(dim=1) \n # give: [torch.FloatTensor of size batch] and [torch.FloatTensor of size batch]\n if True == CUDA:\n y = Variable(torch.sparse.torch.eye(NUM_CLASSES)).cuda().index_select(dim=0, index=max_length_indices.data)\n if False == CUDA:\n y = Variable(torch.sparse.torch.eye(NUM_CLASSES)).index_select(dim=0, index=max_length_indices.data)\n # generate a new y: [batch, 10] with each column having 1 in batch 0\n\n if 2 == param['dim']:\n # print('>>dim: x*y', x.shape, y.shape)\n reconstructions = self.decoder((x * y[:, :, None]).view(x.size(0), -1))\n # x: [batch, 10, 16], y: [batch, 10] -> [batch, 10, 1]\n return classes, reconstructions\n if 1 == param['dim']:\n return classes, x # Note here\n\nclass CapsuleLoss(nn.Module):\n def __init__(self):\n super(CapsuleLoss, self).__init__()\n self.reconstruction_loss = nn.MSELoss(size_average=False)\n\n def forward(self, images, labels, classes, reconstructions):\n if 2 == param['dim']:\n # print('>>dim: labels', labels) # [batch, 10]\n # print('>>dim: classes', classes) # [batch, 10]\n left = F.relu(0.9 - classes, inplace=True) ** 2\n right = F.relu(classes - 0.1, inplace=True) ** 2\n\n margin_loss = labels * left + 0.5 * (1. - labels) * right\n margin_loss = margin_loss.sum()\n\n reconstruction_loss = self.reconstruction_loss(reconstructions, images)\n\n loss = (margin_loss + 0.0005 * reconstruction_loss) / images.size(0)\n # print('>>dim: loss', loss) # it's a single value\n return loss\n if 1 == param['dim']:\n # print('>>dim: labels', labels) # torch.cuda.FloatTensor of size batch x 1\n # print('>>dim: classes', classes) # [batch, 1]\n\n '''\n square = (labels - classes) ** 2\n square = square.sort(dim=0,descending=False)[0]\n cut = int(labels.shape[0]-1)\n loss = (square[:cut]).sum()/cut\n loss = loss ** 0.5 + square[cut] ** 0.5\n '''\n loss = ((labels - classes) ** 2).sum()/labels.shape[0] # MSE # Note: here it must be sum()\n loss = loss ** 0.5 # RMSE\n \n # print('>>dim: loss', loss)\n return loss\n\ndef desparse(RTtt):\n if False == DATA_AUGMENTATION:\n X = np.zeros((RTtt.number_seq, RTtt.N_aa, RTtt.N_time_step)) # DATA_AUGMENTATION->*2\n for i in range(RTtt.number_seq): # DATA_AUGMENTATION->*2\n # sparse to dense\n X[i,::] = RTtt.X[i].todense()\n RTtt.X = X\n else:\n print('>> note: usnig data_augmentation')\n X = np.zeros((RTtt.number_seq*2, RTtt.N_aa, RTtt.N_time_step)) # DATA_AUGMENTATION->*2\n for i in range(RTtt.number_seq*2): # DATA_AUGMENTATION->*2\n # sparse to dense\n X[i,::] = RTtt.X[i].todense()\n RTtt.X = X\n\nif __name__ == \"__main__\":\n # from torch.autograd import Variable\n from torch.optim import Adam # Adam\n from torchnet.engine import Engine\n # from torchnet.logger import VisdomPlotLogger, VisdomLogger\n # from torchvision.utils import make_grid\n # from torchvision.datasets.mnist import MNIST\n from tqdm import tqdm\n import torchnet as tnt\n import gc \n from time import sleep, time\n import timeit\n T1 = timeit.default_timer()\n\n # read data ========== ========== ========== ========== ========== ==========\n # CNN_EMB = True\n if False == CNN_EMB:\n print('>> note: using one-hot encoding.')\n if True == LOAD_DATA:\n # dictionary = Dictionary(dict_path)\n RTtrain = RTdata(dictionary, max_length, train_path)\n RTtest = RTdata(dictionary, max_length, test_path)\n with open(RTdata_path, 'wb') as output:\n # pickle.dump(dictionary, output)\n pickle.dump(RTtrain, output)\n pickle.dump(RTtest, output)\n if False == LOAD_DATA:\n with open(RTdata_path, 'rb') as input:\n # dictionary = pickle.load(input)\n RTtrain = pickle.load(input)\n RTtest = pickle.load(input)\n print('>> note: load pre-read RTdata from:', RTdata_path)\n \n # DATA_AUGMENTATION = True\n SPARSE = True\n # def desparse(RTtt):\n # X = np.zeros((RTtt.number_seq, RTtt.N_aa, RTtt.N_time_step)) # DATA_AUGMENTATION->*2\n # for i in range(RTtt.number_seq): # DATA_AUGMENTATION->*2\n # # sparse to dense\n # X[i,::] = RTtt.X[i].todense()\n # RTtt.X = X\n if True == SPARSE:\n print('>> note: de-sparse for both train & test data.')\n desparse(RTtrain)\n desparse(RTtest)\n if True == CNN_EMB:\n print('>> note: using >>>embedding<<< method.')\n corpus = Corpus(dictionary, # format: Corpus(dictionary, train_path, val_path='', test_path='', pad_length=0)\n train_path,\n test_path=test_path,\n pad_length=max_length) \n\n\n # read data ========== ========== ========== ========== ========== ==========\n\n LOG = False\n flog = open(log_path, 'w')\n\n model = CapsuleNet(conv1_kernel,conv2_kernel)\n if '' == pretrain_path:\n pass\n else:\n model.load_state_dict(torch.load(pretrain_path)) # epoch.pt\n print('>> note: load pre-trained model from:',pretrain_path)\n\n if True == CUDA:\n model.cuda()\n\n print(\"# parameters:\", sum(param.numel() for param in model.parameters()))\n flog.write(\"# parameters:\"+str(sum(param.numel() for param in model.parameters()))+'\\n')\n\n optimizer = Adam(model.parameters(), lr = LR)\n # optimizer = SGD(model.parameters(), lr = LR/10., momentum = 0.5)\n\n engine = Engine()\n meter_loss = tnt.meter.AverageValueMeter()\n if 2 == param['dim']: \n meter_accuracy = tnt.meter.ClassErrorMeter(accuracy=True)\n confusion_meter = tnt.meter.ConfusionMeter(NUM_CLASSES, normalized=True)\n if 1 == param['dim']:\n pass\n # meter_mse = tnt.meter.MSEMeter()\n\n if True == LOG:\n train_loss_logger = VisdomPlotLogger('line', opts={'title': 'Train Loss'})\n train_error_logger = VisdomPlotLogger('line', opts={'title': 'Train Accuracy'})\n test_loss_logger = VisdomPlotLogger('line', opts={'title': 'Test Loss'})\n test_accuracy_logger = VisdomPlotLogger('line', opts={'title': 'Test Accuracy'})\n confusion_logger = VisdomLogger('heatmap', opts={'title': 'Confusion matrix',\n 'columnnames': list(range(NUM_CLASSES)),\n 'rownames': list(range(NUM_CLASSES))})\n if 2 == param['dim']:\n ground_truth_logger = VisdomLogger('image', opts={'title': 'Ground Truth'})\n reconstruction_logger = VisdomLogger('image', opts={'title': 'Reconstruction'})\n\n capsule_loss = CapsuleLoss()\n\n def get_iterator(mode):\n dataset = MNIST(root='./data', download=True, train=mode)\n data = getattr(dataset, 'train_data' if mode else 'test_data')[:47]\n # [torch.ByteTensor of size number x 28 x 28]\n labels = getattr(dataset, 'train_labels' if mode else 'test_labels')[:47]\n # [torch.LongTensor of size number]\n tensor_dataset = tnt.dataset.TensorDataset([data, labels])\n\n return tensor_dataset.parallel(batch_size=BATCH_SIZE, num_workers=4, shuffle=mode)\n\n if False == CNN_EMB:\n data_train = torch.FloatTensor(RTtrain.X)\n label_train = torch.FloatTensor(RTtrain.y)\n print('>> note: delete RTtrain.')\n del RTtrain\n gc.collect()\n print('>> sleeping...')\n for i in range(5):\n print('~.~')\n print('>> wake up!') \n if True == CNN_EMB:\n data_train = corpus.train\n label_train = corpus.train_label\n \n def get_rt_iterator(mode):\n if mode:\n data = data_train # Note: here must be FloatTensor not ByteTensor! \n labels = label_train\n else:\n if False == CNN_EMB:\n data = torch.FloatTensor(RTtest.X)\n labels = torch.FloatTensor(RTtest.y)\n if True == CNN_EMB:\n data = corpus.test\n labels = corpus.test_label\n # print('>>dim: test data:', data.shape, labels.shape)\n tensor_dataset = tnt.dataset.TensorDataset([data, labels])\n return tensor_dataset.parallel(batch_size=BATCH_SIZE, num_workers=1, shuffle=mode) # 1 for heatmap\n\n def processor(sample):\n data, labels, training = sample\n # print('>>dim: data, labels, training', data.shape, labels.shape, training)\n # torch.Size([batch, 28, 28]) torch.Size([batch]) True\n\n if 'mnist' == param['data']:\n data = augmentation(data.unsqueeze(1).float() / 255.0) \n # print('>>dim: data augmentation', data.shape) # torch.Size([batch, 1, 28, 28])\n # print('>>dim: labels', labels) # Note: labels is already LongTensor?\n if 'rt' == param['data']:\n if False == CNN_EMB:\n data = data[:, None, :, :] # Note: add dimension\n if True == CNN_EMB:\n pass\n\n if 2 == param['dim']:\n # for classification, we use LongTensor\n labels = torch.LongTensor(labels)\n labels = torch.sparse.torch.eye(NUM_CLASSES).index_select(dim=0, index=labels) \n if 1 == param['dim']:\n # for regression, we use FloatTensor\n labels = torch.FloatTensor(labels.numpy())\n labels = labels.view(-1, 1) # from [batch] to [batch, 1]\n\n if True == CUDA:\n data = Variable(data).cuda()\n labels = Variable(labels).cuda()\n if False == CUDA:\n data = Variable(data)\n labels = Variable(labels)\n\n if training:\n classes, reconstructions = model(data, labels)\n else:\n classes, reconstructions = model(data)\n\n loss = capsule_loss(data, labels, classes, reconstructions)\n\n return loss, classes\n\n\n def reset_meters():\n meter_loss.reset()\n if 2 == param['dim']:\n meter_accuracy.reset() \n confusion_meter.reset()\n if 1 == param['dim']:\n pass\n # meter_mse.reset()\n\n def on_sample(state):\n state['sample'].append(state['train'])\n\n\n def on_forward(state):\n '''\n So it is just used for recording?\n '''\n if 1 == param['dim']:\n # print('>>dim: state output', state['output'].data.view(-1)) \n # torch.FloatTensor of size [batch x 10]\n # print('>>dim: state sample', state['sample'][1]) \n # torch.LongTensor of size [batch]\n # (1): [batch, 1] (2): [batch], so we view (1) as [batch], but no view is fine \n pass \n # meter_mse.add(state['output'].data, torch.FloatTensor(state['sample'][1].numpy()))\n if 2 == param['dim']:\n meter_accuracy.add(state['output'].data, torch.LongTensor(state['sample'][1]))\n confusion_meter.add(state['output'].data, torch.LongTensor(state['sample'][1]))\n meter_loss.add(state['loss'].data[0])\n\n\n def on_start_epoch(state):\n reset_meters()\n state['iterator'] = tqdm(state['iterator'])\n\n\n def on_end_epoch(state):\n if 2 == param['dim']:\n print('[Epoch %d] Training Loss: %.4f (Accuracy: %.2f%%)' % (\n state['epoch'], meter_loss.value()[0], meter_accuracy.value()[0]))\n flog.write('[Epoch %d] Training Loss: %.4f (Accuracy: %.2f%%)\\n' % (\n state['epoch'], meter_loss.value()[0], meter_accuracy.value()[0]))\n if True == LOG:\n train_loss_logger.log(state['epoch'], meter_loss.value()[0])\n train_error_logger.log(state['epoch'], meter_accuracy.value()[0])\n if 1 == param['dim']:\n print('[Epoch %d] Training Loss: %.4f (MSE: %.4f)' % (\n state['epoch'], meter_loss.value()[0], 7)) # meter_mse.value()\n flog.write('[Epoch %d] Training Loss: %.4f (MSE: %.4f)\\n' % (\n state['epoch'], meter_loss.value()[0], 7)) # meter_mse.value()\n\n reset_meters()\n\n # iterator\n if 'mnist' == param['data']:\n engine.test(processor, get_iterator(False))\n if 'rt' == param['data']:\n engine.test(processor, get_rt_iterator(False))\n\n if True == LOG:\n test_loss_logger.log(state['epoch'], meter_loss.value()[0])\n if 2 == param['dim']:\n test_accuracy_logger.log(state['epoch'], meter_accuracy.value()[0])\n confusion_logger.log(confusion_meter.value())\n if 1 == param['dim']:\n test_accuracy_logger.log(state['epoch'], 7) # meter_mse.value()\n\n if 2 == param['dim']:\n print('[Epoch %d] Testing Loss: %.4f (Accuracy: %.2f%%)' % (\n state['epoch'], meter_loss.value()[0], meter_accuracy.value()[0]))\n flog.write('[Epoch %d] Testing Loss: %.4f (Accuracy: %.2f%%)\\n' % (\n state['epoch'], meter_loss.value()[0], meter_accuracy.value()[0]))\n if 1 == param['dim']:\n print('[Epoch %d] Testing Loss: %.4f (MSE: %.4f)' % (\n state['epoch'], meter_loss.value()[0], 7)) # meter_mse.value()\n flog.write('[Epoch %d] Testing Loss: %.4f (MSE: %.4f)\\n' % (\n state['epoch'], meter_loss.value()[0], 7)) # meter_mse.value()\n\n if 10 <= state['epoch']: # for heatmap\n torch.save(model.state_dict(), save_prefix+'/epoch_%d.pt' % state['epoch'])\n print('>> model: saved.') \n\n # prediction:\n # model.load_state_dict(torch.load(PATH))\n # pred_data = Variable(torch.FloatTensor(RTtest.X)[:,None,:,:]) \n PRED_BATCH = 16 # 1000 # 16 for heatmap\n\n if PRED_BATCH > 0:\n '''\n solve memory problem using batch\n '''\n if False == CNN_EMB:\n pred = np.array([])\n # TODO: handle int\n pred_batch_number = int(RTtest.X.shape[0] / PRED_BATCH)+1\n for bi in range(pred_batch_number):\n test_batch = Variable(torch.FloatTensor(RTtest.X[bi*PRED_BATCH:(bi+1)*PRED_BATCH,:,:])[:,None,:,:])\n test_batch = test_batch.cuda() # Note: we don't use this block anymore\n pred_batch = model(test_batch)\n pred = np.append(pred, pred_batch[0].data.cpu().numpy().flatten())\n # print('>>dim: pred', pred.shape) \n\n if True == DATA_AUGMENTATION:\n ''' data augmentation:'''\n pep_num = int(len(pred) / 2)\n pred = pred[:pep_num]*0.5 + pred[pep_num:]*0.5\n obse = RTtest.y[:pep_num]\n pearson = Pearson(pred,obse)\n spearman = Spearman(pred,obse)\n else:\n pearson = Pearson(pred,RTtest.y)\n spearman = Spearman(pred,RTtest.y) \n if True == CNN_EMB:\n pred = np.array([])\n # TODO: handle int\n pred_batch_number = int(corpus.test.shape[0] / PRED_BATCH)+1\n for bi in range(pred_batch_number):\n test_batch = Variable(corpus.test[bi*PRED_BATCH:(bi+1)*PRED_BATCH,:])\n if True == CUDA:\n test_batch = test_batch.cuda()\n pred_batch = model(test_batch)\n pred = np.append(pred, pred_batch[0].data.cpu().numpy().flatten())\n if False == CUDA:\n # test_batch = test_batch.cuda()\n pred_batch = model(test_batch)\n pred = np.append(pred, pred_batch[0].data.numpy().flatten())\n # print('>>dim: pred', pred.shape) \n obse = corpus.test_label.numpy().flatten() \n pearson = Pearson(pred,obse)\n spearman = Spearman(pred,obse) \n \n else:\n pred_data = Variable(torch.FloatTensor(RTtest.X)[:,None,:,:]) \n if True == CUDA:\n pred_data = pred_data.cuda()\n pred = model(pred_data)\n if True == CUDA:\n # print('>>dim: pred', pred[0].data.cpu().numpy().flatten().shape)\n pearson = Pearson(pred[0].data.cpu().numpy().flatten(),RTtest.y)\n spearman = Spearman(pred[0].data.cpu().numpy().flatten(),RTtest.y)\n if False == CUDA:\n pearson = Pearson(pred[0].data.numpy().flatten(),RTtest.y)\n spearman = Spearman(pred[0].data.numpy().flatten(),RTtest.y)\n ''''''\n print('>> Corr on %d testing samples: %.5f | %.5f' % (len(pred), pearson, spearman))\n flog.write('>> Corr on %d testing samples: %.5f | %.5f\\n' % (len(pred), pearson, spearman))\n # writing:\n if True == CNN_EMB:\n obse = corpus.test_label.numpy().flatten()\n if False == CNN_EMB:\n obse = RTtest.y\n with open(result_path, 'w') as fo:\n fo.write('observed\\tpredicted\\n')\n for i in range(len(pred)):\n fo.write('%.5f\\t%.5f\\n' % (obse[i],pred[i]))\n # writing done\n\n # Reconstruction visualization.\n if 2 == param['dim']:\n\n # iterator\n if 'mnist' == param['data']:\n test_sample = next(iter(get_iterator(False)))\n if 'rt' == param['data']:\n test_sample = next(iter(get_rt_iterator(False)))\n # print('>>dim: test_sample', test_sample) # [batch, 28, 28]\n\n ground_truth = (test_sample[0].unsqueeze(1).float() / 255.0)\n # print('>>dim: ground_truth', ground_truth.shape) # torch.FloatTensor of size batch x 1 x 28 x 28\n\n if True == CUDA:\n pred, reconstructions = model(Variable(ground_truth).cuda())\n if False == CUDA:\n pred, reconstructions = model(Variable(ground_truth))\n # print('>>dim: pred', pred)\n reconstruction = reconstructions.cpu().view_as(ground_truth).data\n\n if True == LOG:\n ground_truth_logger.log(\n make_grid(ground_truth, nrow=int(BATCH_SIZE ** 0.5), normalize=True, range=(0, 1)).numpy())\n reconstruction_logger.log(\n make_grid(reconstruction, nrow=int(BATCH_SIZE ** 0.5), normalize=True, range=(0, 1)).numpy())\n\n # def on_start(state):\n # state['epoch'] = 327\n #\n # engine.hooks['on_start'] = on_start\n\n engine.hooks['on_sample'] = on_sample\n engine.hooks['on_forward'] = on_forward\n engine.hooks['on_start_epoch'] = on_start_epoch\n engine.hooks['on_end_epoch'] = on_end_epoch\n\n if 'mnist' == param['data']:\n engine.train(processor, get_iterator(True), maxepoch=NUM_EPOCHS, optimizer=optimizer)\n if 'rt' == param['data']:\n engine.train(processor, get_rt_iterator(True), maxepoch=NUM_EPOCHS, optimizer=optimizer)\n\n T2 = timeit.default_timer()\n print('>> time: %.5f min\\n' %((T2-T1)/60.))\n flog.write('>> time: %.5f min\\n' %((T2-T1)/60.))\n flog.close()\n", "meta": {"hexsha": "d8063fe1171024d9eee1b05d6b80a52ea8b891d2", "size": 31879, "ext": "py", "lang": "Python", "max_stars_repo_path": "capsule_network_emb_cpu.py", "max_stars_repo_name": "horsepurve/DeepRTplus", "max_stars_repo_head_hexsha": "b29041c71f84c1d1a56c5c5f20fd49a805ed4d46", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 39, "max_stars_repo_stars_event_min_datetime": "2018-03-29T12:00:20.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-20T07:26:16.000Z", "max_issues_repo_path": "capsule_network_emb_cpu.py", "max_issues_repo_name": "Jun-NIBS/DeepRTplus", "max_issues_repo_head_hexsha": "213f5101000377e17ec470b9a2057b9edc92ceb2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 13, "max_issues_repo_issues_event_min_datetime": "2018-09-20T14:59:50.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-12T04:51:46.000Z", "max_forks_repo_path": "capsule_network_emb_cpu.py", "max_forks_repo_name": "Jun-NIBS/DeepRTplus", "max_forks_repo_head_hexsha": "213f5101000377e17ec470b9a2057b9edc92ceb2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 18, "max_forks_repo_forks_event_min_datetime": "2018-04-17T06:43:27.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-23T19:52:26.000Z", "avg_line_length": 42.562082777, "max_line_length": 180, "alphanum_fraction": 0.5385990778, "include": true, "reason": "import numpy,from scipy", "num_tokens": 7990, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5544704649604273, "lm_q2_score": 0.3557749071749625, "lm_q1q2_score": 0.19726667820255434}} {"text": "# -*- coding: utf-8 -*-\n\"\"\"\n.. module: pyAPES\n :synopsis: APES-model component\n.. moduleauthor:: Kersti Haahti\n\nModel framework for Atmosphere-Plant Exchange Simulations\n\nCreated on Tue Oct 02 09:04:05 2018\n\nNote:\n migrated to python3\n - print on same line\n - dict.keys(), but these are iterated after in for-each-loop\n\nReferences:\nLauniainen, S., Katul, G.G., Lauren, A. and Kolari, P., 2015. Coupling boreal\nforest CO2, H2O and energy flows by a vertically structured forest canopy –\nSoil model with separate bryophyte layer. Ecological modelling, 312, pp.385-405.\n\nTo call model and run single simulation and read results: see example in sandbox.py\n from tools.iotools import read_results\n from pyAPES import driver\n # for NetCDF-outputs\n outputfile = driver(create_ncf=True, result_file='test.nc')\n results = read_results(outputfile) # opens NetCDF-file using xarray\n\n # for returning results directly\n results = driver(create_ncf=False) # returns dict with integer keys\n results = results[0] # first simulation\n\nLAST EDIT: 15.1.2020 Samuli Launiainen\n * new forestfloor and altered outputs\nTodo:\n\n - make minimal example of handling and plotting outputs using xarray -tools;\n now see tools.iotools.read_forcing for documentation!\n\n\"\"\"\nimport time\nimport logging\n\nimport numpy as np\nfrom pandas import date_range\n\nfrom tools.iotools import initialize_netcdf, write_ncf\nfrom canopy.canopy import CanopyModel\nfrom soil.soil import Soil\nfrom canopy.constants import WATER_DENSITY\n\ndef driver(parameters,\n create_ncf=False,\n result_file=None):\n \"\"\"\n Reads parameters as argument, prepares output files, runs model.\n Args:\n parameters (dict/list): either single parameter dictionary or list of parameters\n create_ncf (bool): results saved to netCDF4 file\n result_file (str): name of result file\n \"\"\"\n\n # --- CONFIGURATION PARAMETERS of LOGGING and NetCDF -outputs read\n from parameters.outputs import output_variables, logging_configuration\n from logging.config import dictConfig\n\n # --- LOGGING ---\n dictConfig(logging_configuration)\n logger = logging.getLogger(__name__)\n\n # --- CHECK PARAMETERS ---\n\n if isinstance(parameters, dict):\n Nsim = 1\n parameters = [parameters]\n elif isinstance(parameters, list):\n Nsim = len(parameters)\n else:\n raise TypeError('Parameters should be either dict or list.')\n\n logger.info('Simulation started. Number of simulations: {}'.format(Nsim))\n\n # --- SIMULATIOS AND OUTPUTS ---\n\n tasks = []\n\n for k in range(Nsim):\n tasks.append(\n Model(\n parameters[k]['general']['dt'],\n parameters[k]['canopy'],\n parameters[k]['soil'],\n parameters[k]['forcing'],\n output_variables['variables'],\n nsim=k\n )\n )\n\n if create_ncf: # outputs to NetCDF-file, returns filename\n gpara = parameters[0]['general'] # same for all tasks\n timestr = time.strftime('%Y%m%d%H%M')\n if result_file:\n filename = result_file\n else:\n filename = timestr + '_pyAPES_results.nc'\n\n #freq = '{}S'.format(gpara['dt'])\n #time_index = date_range(gpara['start_time'], gpara['end_time'], freq=freq, closed='left')\n\n time_index = parameters[0]['forcing'].index\n\n ncf, _ = initialize_netcdf(\n output_variables['variables'],\n Nsim,\n tasks[k].Nsoil_nodes,\n tasks[k].Ncanopy_nodes,\n tasks[k].Nplant_types,\n tasks[k].Nground_types,\n time_index=time_index,\n filepath=gpara['results_directory'],\n filename=filename)\n\n for task in tasks:\n logger.info('Running simulation number (start time %s): %s' % (\n time.strftime('%Y-%m-%d %H:%M'), task.Nsim))\n running_time = time.time()\n results = task.run()\n logger.info('Running time %.2f seconds' % (time.time() - running_time))\n write_ncf(nsim=task.Nsim, results=results, ncf=ncf)\n\n del results\n\n output_file = gpara['results_directory'] + filename\n logger.info('Ready! Results are in: ' + output_file)\n\n ncf.close()\n\n return output_file, tasks[0]\n\n else: # returns dictionary of outputs\n running_time = time.time()\n results = {task.Nsim: task.run() for task in tasks}\n\n logger.info('Running time %.2f seconds' % (time.time() - running_time))\n\n return results, tasks[0] # this would return also 1st Model instance\n\n\nclass Model(object):\n \"\"\"\n pyAPES - main model class.\n Combines submodels 'CanopyModel' and 'Soil' and handles data-transfer\n between these model components and writing results.\n\n Last edit: SL 13.01.2020\n \"\"\"\n def __init__(self,\n dt,\n canopy_para,\n soil_para,\n forcing,\n outputs,\n nsim=0):\n\n logger = logging.getLogger(__name__)\n\n self.dt = dt\n\n self.Nsteps = len(forcing)\n self.forcing = forcing\n self.Nsim = nsim\n\n self.Nsoil_nodes = len(soil_para['grid']['dz'])\n self.Ncanopy_nodes = canopy_para['grid']['Nlayers']\n\n # create soil model instance\n self.soil = Soil(soil_para)\n\n if 'Wa' in forcing and soil_para['water_model']['solve'] is False:\n logger.info(\"Soil moisture from forcing file\")\n soil_para['water_model']['initial_condition']['volumetric_water_content'] = (\n forcing['Wa'].iloc[0])\n if 'Tsa' in forcing and soil_para['heat_model']['solve'] is False:\n logger.info(\"Soil temperature from forcing file\")\n soil_para['heat_model']['initial_condition']['temperature'] = (\n forcing['Tsa'].iloc[0])\n\n # create canopy model instance\n # initial delayed temperature and degreedaysum for pheno & LAI-models\n if canopy_para['ctr']['pheno_cycle'] and 'X' in forcing:\n for pt in list(canopy_para['planttypes'].keys()):\n canopy_para['planttypes'][pt]['phenop'].update({'Xo': forcing['X'].iloc[0]})\n if canopy_para['ctr']['seasonal_LAI'] and 'DDsum' in forcing:\n for pt in list(canopy_para['planttypes'].keys()):\n canopy_para['planttypes'][pt]['laip'].update({'DDsum0': forcing['DDsum'].iloc[0]})\n\n\n self.canopy_model = CanopyModel(canopy_para, self.soil.grid['dz'])\n\n self.Nplant_types = len(self.canopy_model.planttypes)\n self.Nground_types = len(self.canopy_model.forestfloor.bottomlayer_types)\n\n # initialize structure to save results\n self.results = _initialize_results(outputs,\n self.Nsteps,\n self.Nsoil_nodes,\n self.Ncanopy_nodes,\n self.Nplant_types,\n self.Nground_types)\n\n def run(self):\n \"\"\"\n Loops through self.forcing and appends to self.results.\n\n self.forcing variables and units; correspond to uppermost gridpoint:\n precipitation [kg m-2 s-1]\n air_pressure [Pa]\n air_temperature [degC]\n wind_speed [m/s]\n friction_velocity [m/s]\n h2o[mol/mol]\n co2 [ppm]\n zenith_angle [rad]\n lw_in: Downwelling long wave radiation [W/m2]\n diffPar: Diffuse PAR [W/m2]\n dirPar: Direct PAR [W/m2]\n diffNir: Diffuse NIR [W/m2]\n dirNir: Direct NIR [W/m2]\n \"\"\"\n\n logger = logging.getLogger(__name__)\n logger.info('Running simulation {}'.format(self.Nsim))\n time0 = time.time()\n\n #print('RUNNING')\n k_steps=np.arange(0, self.Nsteps, int(self.Nsteps/10))\n\n for k in range(0, self.Nsteps):\n # --- print progress on screen\n if k in k_steps[:-1]:\n s = str(np.where(k_steps==k)[0][0]*10) + '%'\n print('{0}..'.format(s), end=' ')\n\n # --- CanopyModel ---\n # run daily loop: updates LAI, phenology and moisture stress ---\n if self.forcing['doy'].iloc[k] != self.forcing['doy'].iloc[k-1] or k == 0:\n self.canopy_model.run_daily(\n self.forcing['doy'].iloc[k],\n self.forcing['Tdaily'].iloc[k])\n\n # compile forcing dict for canopy model: soil_ refers to state of soil model\n canopy_forcing = {\n 'wind_speed': self.forcing['U'].iloc[k], # [m s-1]\n 'friction_velocity': self.forcing['Ustar'].iloc[k], # [m s-1]\n 'air_temperature': self.forcing['Tair'].iloc[k], # [deg C]\n 'precipitation': self.forcing['Prec'].iloc[k], # [kg m-2 s-1]\n 'h2o': self.forcing['H2O'].iloc[k], # [mol mol-1]\n 'co2': self.forcing['CO2'].iloc[k], # [ppm]\n 'PAR': {'direct': self.forcing['dirPar'].iloc[k], # [W m-2]\n 'diffuse': self.forcing['diffPar'].iloc[k]},\n 'NIR': {'direct': self.forcing['dirNir'].iloc[k], # [W m-2]\n 'diffuse': self.forcing['diffNir'].iloc[k]},\n 'lw_in': self.forcing['LWin'].iloc[k], # [W m-2]\n 'air_pressure': self.forcing['P'].iloc[k], # [Pa]\n 'zenith_angle': self.forcing['Zen'].iloc[k], # [rad]\n\n # from soil model\n 'soil_temperature': self.soil.heat.T[self.canopy_model.ix_roots], # [deg C]\n 'soil_water_potential': self.soil.water.h[self.canopy_model.ix_roots], # [m] ?\n 'soil_volumetric_water': self.soil.heat.Wliq[self.canopy_model.ix_roots], # [m3 m-3]\n 'soil_volumetric_air': self.soil.heat.Wair[self.canopy_model.ix_roots], # [m3 m-3]\n 'soil_pond_storage': self.soil.water.h_pond * WATER_DENSITY, # [kg m-2]\n }\n\n canopy_parameters = {\n 'soil_depth': self.soil.grid['z'][0], # [m]\n 'soil_hydraulic_conductivity': self.soil.water.Kv[self.canopy_model.ix_roots], # [m s-1]\n 'soil_thermal_conductivity': self.soil.heat.thermal_conductivity[0], # [W m-1 K-1]?\n 'date': self.forcing.index[k] # pd.datetime\n }\n\n # call self.canopy_model.run to solve above-ground part\n out_canopy, out_planttype, out_ffloor, out_groundtype = self.canopy_model.run(\n dt=self.dt,\n forcing=canopy_forcing,\n parameters=canopy_parameters\n )\n\n # --- Soil model ---\n # compile forcing for Soil: potential infiltration and evaporation are at from ground surface\n # water fluxes must be in [m s-1]\n soil_forcing = {\n 'potential_infiltration': out_ffloor['throughfall'] / WATER_DENSITY,\n 'potential_evaporation': ((out_ffloor['soil_evaporation'] +\n out_ffloor['capillary_rise']) / WATER_DENSITY),\n 'pond_recharge': out_ffloor['pond_recharge'] / WATER_DENSITY,\n 'atmospheric_pressure_head': -1.0E6, # set to large value, because potential_evaporation already account for h_soil\n 'ground_heat_flux': -out_ffloor['ground_heat'],\n 'date': self.forcing.index[k]}\n\n\n if 'Ws' in self.forcing and self.soil.solve_water is False:\n soil_forcing.update({\n 'state_water':{'volumetric_water_content': self.forcing['Ws'].iloc[k]}})\n if 'Tsa' in self.forcing and self.soil.solve_heat is False:\n soil_forcing.update({\n 'state_heat':{'temperature': self.forcing['Tsa'].iloc[k]}})\n\n # call self.soil to solve below-ground water and heat flow\n soil_flux, soil_state = self.soil.run(\n dt=self.dt,\n forcing=soil_forcing,\n water_sink=out_canopy['root_sink'])\n\n # --- append results and copy of forcing to self.results\n forcing_output = {\n 'wind_speed': self.forcing['U'].iloc[k],\n 'friction_velocity': self.forcing['Ustar'].iloc[k],\n 'air_temperature': self.forcing['Tair'].iloc[k],\n 'precipitation': self.forcing['Prec'].iloc[k],\n 'h2o': self.forcing['H2O'].iloc[k],\n 'co2': self.forcing['CO2'].iloc[k],\n 'pressure': self.forcing['P'].iloc[k],\n 'par': self.forcing['dirPar'].iloc[k] + self.forcing['diffPar'].iloc[k],\n 'nir': self.forcing['dirNir'].iloc[k] + self.forcing['diffNir'].iloc[k],\n 'lw_in': self.forcing['LWin'].iloc[k]\n }\n\n\n soil_state.update(soil_flux)\n\n self.results = _append_results('forcing', k, forcing_output, self.results)\n self.results = _append_results('canopy', k, out_canopy, self.results)\n self.results = _append_results('ffloor', k, out_ffloor, self.results)\n self.results = _append_results('soil', k, soil_state, self.results)\n self.results = _append_results('pt', k, out_planttype, self.results)\n self.results = _append_results('gt', k, out_groundtype, self.results)\n\n print('100%')\n\n ptnames = [pt.name for pt in self.canopy_model.planttypes]\n\n self.results = _append_results('canopy', None, {'z': self.canopy_model.z,\n 'planttypes': np.array(ptnames)}, self.results)\n\n gtnames = [gt.name for gt in self.canopy_model.forestfloor.bottomlayer_types]\n\n self.results = _append_results('ffloor', None, {'groundtypes': np.array(gtnames)}, self.results)\n\n self.results = _append_results('soil', None, {'z': self.soil.grid['z']}, self.results)\n\n logger.info('Finished simulation %.0f, running time %.2f seconds' % (self.Nsim, time.time() - time0))\n\n return self.results\n\n\ndef _initialize_results(variables, Nstep, Nsoil_nodes, Ncanopy_nodes, Nplant_types, Nground_types):\n \"\"\"\n Creates temporary results dictionary to accumulate simulation results\n SL 12.11.2019: removed if 'date' in dimensions and added option to save planttype profiles\n \"\"\"\n\n results = {}\n\n for var in variables:\n\n var_name = var[0]\n dimensions = var[2]\n\n if 'canopy' in dimensions:\n if 'planttype' in dimensions:\n var_shape = [Nstep, Nplant_types, Ncanopy_nodes]\n else:\n var_shape = [Nstep, Ncanopy_nodes]\n\n elif 'soil' in dimensions:\n var_shape = [Nstep, Nsoil_nodes]\n\n elif 'planttype' in dimensions and 'canopy' not in dimensions:\n var_shape = [Nstep, Nplant_types]\n\n elif 'groundtype' in dimensions:\n if 'date' not in dimensions:\n var_shape = [Nground_types]\n else:\n var_shape = [Nstep, Nground_types]\n\n else:\n var_shape = [Nstep]\n\n results[var_name] = np.full(var_shape, np.NAN)\n # print(var_name, var_shape, dimensions)\n\n return results\n\n\ndef _append_results(group, step, step_results, results):\n \"\"\"\n Adds results from each simulation steps to temporary results dictionary\n \"\"\"\n\n results_keys = results.keys()\n step_results_keys = step_results.keys()\n\n for key in step_results_keys:\n variable = group + '_' + key\n if variable in results_keys:\n if key == 'z' or key == 'planttypes' or key == 'groundtypes':\n results[variable] = step_results[key]\n else:\n #print(variable, key, np.shape(results[variable][step]), np.shape(step_results[key]))\n results[variable][step] = step_results[key]\n\n return results\n\n#if __name__ == '__main__':\n#\n# from parameters.parametersets import lettosuo_parameters\n# outputfile=driver(create_ncf=True, parametersets=lettosuo_parameters)\n#\n# print(outputfile)\n", "meta": {"hexsha": "2f85e2431e795b8f9dfbbc1af603da4f24935e87", "size": 16459, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyAPES.py", "max_stars_repo_name": "LukeEcomod/pyAPES_VESBO", "max_stars_repo_head_hexsha": "fdb4f44907e3055eb42db4a1260e0d7b9c55b415", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-12-21T16:33:21.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-02T05:13:14.000Z", "max_issues_repo_path": "pyAPES.py", "max_issues_repo_name": "LukeEcomod/pyAPES_VESBO", "max_issues_repo_head_hexsha": "fdb4f44907e3055eb42db4a1260e0d7b9c55b415", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pyAPES.py", "max_forks_repo_name": "LukeEcomod/pyAPES_VESBO", "max_forks_repo_head_hexsha": "fdb4f44907e3055eb42db4a1260e0d7b9c55b415", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.0950118765, "max_line_length": 132, "alphanum_fraction": 0.5780424084, "include": true, "reason": "import numpy", "num_tokens": 3873, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5544704649604273, "lm_q2_score": 0.35577489351363034, "lm_q1q2_score": 0.19726667062774914}} {"text": "#!/usr/bin/python\r\n# -*- coding: utf-8 -*-\r\n#The script builds an evolutionary history of clones by sharing mutations between samples.\r\n\r\nimport os\r\nimport re\r\nimport numpy \r\nimport random \r\nimport sys, getopt\r\nfrom Bio import Phylo\r\nfrom io import StringIO\r\nimport matplotlib\r\nmatplotlib.use('Agg')\r\nimport matplotlib.pyplot as plt\r\n\r\n#24 chromosome\r\nall_chr=[]\r\nfor i in range(1,24):\r\n\tall_chr.append(str(i))\r\nall_chr.append('X')\r\nall_chr.append('Y')\r\n\r\n\r\n#parameter\r\n\r\nopts,args = getopt.getopt(sys.argv[1:], \"i:o:\",[\"AF=\",\"input=\", \"output=\"])\r\ndef get_driver_gene_path():\r\n '''\r\n return the driver gene path\r\n '''\r\n current_path = os.path.dirname(os.path.realpath(__file__))\r\n return current_path\r\n\r\n\r\nAF=''\r\nfile_path=''\r\nfile_path_out=''\r\nfor para,value in opts:\r\n\tif para in ('--AF'):\r\n\t\tAF=value\r\n\tif para in ('-i','--input'):\r\n\t\tfile_path=value\r\n\tif para in ('-o','--output'):\r\n\t\tfile_path_out=value\r\nprint('AF: '+str(AF))\r\nif file_path[-len(os.path.sep):]==os.path.sep:\r\n\tfile_path=file_path[:-len(os.path.sep)]\r\nprint('file_path: '+str(file_path))\r\nif file_path_out[-len(os.path.sep):]==os.path.sep:\r\n\tfile_path_out=file_path_out[:-len(os.path.sep)]\r\nprint('file_path_out: '+str(file_path_out))\r\n\r\ndef fact(n):\r\n if n == 0:\r\n return 1\r\n else:\r\n return n*fact(n-1)\r\ndef Cmn(n,m):\r\n return fact(n)/(fact(n-m)*fact(m))\r\n\r\n#map driver gene:\r\n# @ a is a list including mutation which is used to map driver gene\r\n# @ b =='FALSE', then output driver gene without mutation\r\n# @ b =='TRUE', then output driver gene with mutation\r\ndef search_gene(a,b):\r\n\tglobal count_gene\r\n\tcount_gene=0\r\n\tglobal gene_list\r\n\tgene_list=[]\r\n\tfor item in a:#read a mutation\r\n\t\tif item in all_mutation.keys():\r\n\t\t\tfor gene in all_mutation[item]:\r\n\t\t\t\tif gene in driver_gene.keys():\r\n\t\t\t\t\tif b=='FALSE':#do not output driver gene with mutation\r\n\t\t\t\t\t\tgene=gene\r\n\t\t\t\t\tif b=='TRUE':\r\n\t\t\t\t\t\tgene=gene+':'+item\r\n\t\t\t\t\tif gene not in gene_list:\r\n\t\t\t\t\t\tgene_list.append(gene)\r\n\tcount_gene=len(gene_list)\r\n\tgene_list.append(count_gene)\r\n\treturn gene_list\t\t\t\t\t\t\t\r\n\t\t\t\t\t\t\t\t\t\r\n#.................................................find best branch..........................\r\ndef xunhuan(a):\r\n\tnum=1\r\n\tglobal first_1\r\n\tfirst_1={}\r\n\tglobal first_3\r\n\tfirst_3={}\r\n\tglobal first_4\r\n\tfirst_4={}\r\n\tfirst_6={}\r\n\twhile num<=len(a)/2:\r\n\t\tstruct_pattern=str(num)+'-'+str(len(a)-num)\r\n\t\tDIC={}#including structure info: Cmn information for a specific branch split\r\n\t\tcishu=int(Cmn(len(a),num))\r\n\t\twhile len(DIC.keys())1:\r\n\t\t\t\tda=','\r\n\t\t\t\tfor Item in sel:\r\n\t\t\t\t\tda=da+','+Item\r\n\t\t\t\tif da[2:] not in DIC.keys():\r\n\t\t\t\t\tDIC.update({da[2:]:[]})\r\n\t\t\tif num==1:\r\n\t\t\t\tDIC.update({sel[0]:[]})\r\n\t\tfirst_2={}#struct info\r\n\t\tfor item in DIC.keys():\r\n\t\t\ta_1=[]#first =a, then remove item from [a]. \r\n\t\t\tjiaoji_2=[]\r\n\t\t\tjiaoji_1=[]\r\n\t\t\tfor sample in a:\r\n\t\t\t\ta_1.append(sample)\r\n\t\t\tsplit=item.split(',')\r\n\t\t\tsplit.sort()\r\n\t\t\tfor item5 in split:\r\n\t\t\t\ta_1.remove(item5)\r\n\t\t\tif len(split)==1:\r\n\t\t\t\tjiaoji_1=dic[item]#sample mutation which is removed\r\n\t\t\telse:\r\n\t\t\t\tNUM=0\r\n\t\t\t\tfor item6 in split:\r\n\t\t\t\t\tNUM=NUM+1\r\n\t\t\t\t\tif NUM==1:\r\n\t\t\t\t\t\tjiaoji_1=dic[item6]\r\n\t\t\t\t\tjiaoji_1=[val for val in jiaoji_1 if val in dic[item6]]#sample mutation which are removed\r\n\r\n\t\t\ti=0\r\n\t\t\tno_item=','\r\n\t\t\ta_1.sort()\r\n\t\t\tfor item1 in a_1:\r\n\t\t\t\tno_item=no_item+','+item1\r\n\t\t\t\ti=i+1\r\n\t\t\t\tif i==1:\r\n\t\t\t\t\tjiaoji_2=dic[item1]\r\n\t\t\t\tjiaoji_2 = [val for val in jiaoji_2 if val in dic[item1]]#sample mutation which are retained; also is big group\r\n\r\n\t\t\tstruct_name=no_item[2:]\r\n\t\t\tstruct_share_mut=len(jiaoji_2)\r\n\t\t\tnum_1=str(len(jiaoji_1))+str(search_gene(jiaoji_1,'FALSE'))\r\n\t\t\tfirst_3.update({item:num_1})\r\n\t\t\tfirst_4.update({item:jiaoji_1})\r\n\t\t\tnum_2=str(len(jiaoji_2))+str(search_gene(jiaoji_2,'FALSE'))\r\n\t\t\tfirst_3.update({struct_name:num_2})\r\n\t\t\tfirst_4.update({struct_name:jiaoji_2})\r\n\t\t\t#if struct: n/2,n/2: we should retained group info which mutation is small\r\n\t\t\tif num==len(a)/2:\r\n\t\t\t\tif len(jiaoji_1)>len(jiaoji_2):\r\n\t\t\t\t\tstruct_name=no_item[2:]\r\n\t\t\t\t\tstruct_share_mut=len(jiaoji_2)\r\n\t\t\t\tif len(jiaoji_1)1 and key!=max_data_name and value==max_data_value:\r\n\t\t\t\t\tstruct_pattern1=struct_pattern+':'+key\r\n\t\t\t\t\tif struct_pattern1 not in first_6.keys():\r\n\t\t\t\t\t\tfirst_6.update({struct_pattern1:value})\r\n\t\telse:\r\n\t\t\tfor key,value in sort_d:\r\n\t\t\t\tcount+=1\r\n\t\t\t\tif count==1:\r\n\t\t\t\t\tmax_data_name=key\r\n\t\t\t\t\tmax_data_value=value\r\n\t\t\t\t\tmax_data.append(value)\r\n\t\t\t\t\tstruct_pattern1=struct_pattern+':'+max_data_name\r\n\t\t\t\t\tif struct_pattern1 not in first_6.keys():\r\n\t\t\t\t\t\tfirst_6.update({struct_pattern1:max_data_value})\r\n\t\t\t\t\t#print(key,value)\r\n\t\t\t\t\tchongfu={}#judge random chongfu \r\n\t\t\t\t\twhile len(chongfu.keys())<(fact(len(key.split(',')))-1):\r\n\t\t\t\t\t\tlist1=key.split(',')\r\n\t\t\t\t\t\trandom.shuffle(list1)\r\n\t\t\t\t\t\t#print(list1)\r\n\t\t\t\t\t\tfan_da=','\r\n\t\t\t\t\t\tfor Item1 in list1:\r\n\t\t\t\t\t\t\tfan_da=fan_da+','+Item1\r\n\t\t\t\t\t\tif fan_da[2:]!=key:\r\n\t\t\t\t\t\t\tchongfu.update({fan_da[2:]:[]})\r\n\t\t\t\tif key != max_data_name and key not in chongfu.keys() and len(max_data)==1:\r\n\t\t\t\t\tmax_data.append(value)\r\n\t\t\t\t\t#print(key,value)\r\n\t\t\t\tif count>1 and key not in chongfu.keys() and key!=max_data_name and value==max_data_value:\r\n\t\t\t\t\tchongfu2={}\r\n\t\t\t\t\twhile len(chongfu2.keys())<(fact(len(key.split(',')))-1):\r\n\t\t\t\t\t\tlist1=key.split(',')\r\n\t\t\t\t\t\trandom.shuffle(list1)\r\n\t\t\t\t\t\tfan_da=','\r\n\t\t\t\t\t\tfor Item1 in list1:\r\n\t\t\t\t\t\t\tfan_da=fan_da+','+Item1\r\n\t\t\t\t\t\tif fan_da[2:]!=key:\r\n\t\t\t\t\t\t\tchongfu2.update({fan_da[2:]:[]})\r\n\t\t\t\t\tchongfu_count=0\r\n\t\t\t\t\tfor item_name in chongfu2.keys():\r\n\t\t\t\t\t\tstruct_pattern1=struct_pattern+':'+item_name\r\n\t\t\t\t\t\tif struct_pattern not in first_6.keys():\r\n\t\t\t\t\t\t\tchongfu_count=chongfu_count+1\r\n\t\t\t\t\tif chongfu_count==len(chongfu.keys()):\r\n\t\t\t\t\t\tstruct_pattern1=struct_pattern+':'+key\r\n\t\t\t\t\t\tif struct_pattern1 not in first_6.keys():\r\n\t\t\t\t\t\t\tfirst_6.update({struct_pattern1:value})\r\n\t\tif int(max_data[1])!=0:\r\n\t\t\tratio=int(max_data[0])/int(max_data[1])\r\n\t\telse:\r\n\t\t\tratio=int(max_data[0])\r\n\t\tstruct_pattern2=struct_pattern+':'+max_data_name\r\n\t\tfirst_1.update({struct_pattern2:ratio})\r\n\t\tnum=num+1\r\n\tsort_data=sorted(first_1.items(),key = lambda d:d[1],reverse=True) \r\n\t#print(sort_data)\r\n\tglobal return_data\r\n\treturn_data=[]\r\n\tcount_data=0\r\n\tfor key,value in sort_data:\r\n\t\tcount_data=count_data+1\r\n\t\tif count_data==1:\r\n\t\t\tmax_data_name=key\r\n\t\t\tmax_data_value=value\r\n\t\tif value==max_data_value:\r\n\t\t\treturn_data.append(key)\r\n\tfor item in return_data:\r\n\t\tidentify=item.split(':')[0]\r\n\t\tfor item1 in first_6.keys():\r\n\t\t\tif identify in item1 :\r\n\t\t\t\tif item1 not in return_data:\r\n\t\t\t\t\treturn_data.append(item1)\r\n\tif max_data_value==0:#ratio==0\r\n\t\tvalue1=[]\r\n\t\treturn_data=[]\r\n\t\tnum=divmod(len(a),2)[0]\r\n\t\twhile num>0:\r\n\t\t\tfor key in first_4.keys():\r\n\t\t\t\tif len(key.split(','))==num and len(first_4[key])!=0:\r\n\t\t\t\t\tvalue1.append(len(first_4[key]))\r\n\t\t\tif len(value1)!=0:\r\n\t\t\t\tbreak\r\n\t\t\telse:\r\n\t\t\t\tnum=num-1\r\n\t\tmax_data=value1[0]\r\n\t\tstruct_pattern=str(num)+'-'+str(len(a)-num)\r\n\t\tfor data in value1[1:]:\r\n\t\t\tif int(data)>max_data:\r\n\t\t\t\tmax_data=int(data)\r\n\t\tfor key in first_4.keys():\r\n\t\t\tif len(key.split(','))==num and len(first_4[key])==max_data:\r\n\t\t\t\tstruct_pattern1=struct_pattern+':'+key\r\n\t\t\t\treturn_data.append(struct_pattern1)\r\n\treturn_data.sort()\r\n\treturn(return_data)\r\n#split tree\r\ndef split_tree(tree_label_split):\r\n\tnew_tree_label=[]\r\n\tnum=0\r\n\tcount1=0\r\n\tcount2=0\r\n\tindex1=[]\r\n\tnew_tree_label=[]\r\n\twhile num =float(AF) and data[0].split('_')[0] in all_chr:\r\n\t\t\t\t\t\t\tif data[0] not in dic[sample_id] :\r\n\t\t\t\t\t\t\t\tdic[sample_id].append(data[0])\r\n\t\t\t\t\t\t\t\tif data[0] not in all_mutation.keys():\r\n\t\t\t\t\t\t\t\t\tall_mutation.update({data[0]:[]})\r\n\t\t\t\t\t\t\t\tfor refer_gene in data[3].split(';'):\r\n\t\t\t\t\t\t\t\t\tif refer_gene not in all_mutation[data[0]]:\r\n\t\t\t\t\t\t\t\t\t\tall_mutation[data[0]].append(refer_gene)\r\n\t\t\t\t\t\t\telse:\r\n\t\t\t\t\t\t\t\tprint(filename+' contains two or more identical mutation!')\r\n\t\t\t\t\telse:\r\n\t\t\t\t\t\tprint(data[0]+': this sample have mutations that are uncovered!')\r\n\telse:\r\n\t\t# 0-1 matrix\r\n\t\tprint('0-1 matrix')\r\n\t\tall_mutation={}\r\n\t\tprint('patient: '+patient)\r\n\t\tdic={}#[sample_id: all mutation_ID]\r\n\t\tall_data=[]#all_sample_ID\r\n\t\tsample_shu=0#the number of all samples of this patient\r\n\t\tsample_index={}#[index:smaple_name]\r\n\t\tfile=open(file_path+os.path.sep+patient+'.txt','r')\r\n\t\tlines=file.readlines()\r\n\t\tdata_0=lines[0].rstrip().split('\\t')\r\n\t\tfor item in data_0[1:-1]:#sample_id\r\n\t\t\tsample_shu=sample_shu+1\r\n\t\t\tif item not in dic.keys() :\r\n\t\t\t\tdic.update({item:[]})\r\n\t\t\t\tall_data.append(item)\r\n\t\t\t\tsample_index.update({sample_shu:item})\r\n\t\t\telse:\r\n\t\t\t\tprint('sample_id is not uniq!')\r\n\t\t#print(sample_index)\r\n\t\t#print(dic)\r\n\t\tfor line in lines[1:]:\r\n\t\t\tdata=line.rstrip().split('\\t')\r\n\t\t\tfor i in range(1,len(data)-1):\r\n\t\t\t\tif int(data[i])==1 and data[0] not in dic[sample_index[i]]:\r\n\t\t\t\t\tdic[sample_index[i]].append(data[0])\r\n\t\t\tif data[0] not in all_mutation.keys():\r\n\t\t\t\tall_mutation.update({data[0]:[]})\r\n\t\t\t\tfor refer_gene in data[-1].split(';'):\r\n\t\t\t\t\tif refer_gene not in all_mutation[data[0]]:\r\n\t\t\t\t\t\tall_mutation[data[0]].append(refer_gene)\r\n\r\n\t#calculate the length of root trunk\r\n\t#remove the sample which have 0 muatation\r\n\tprint(all_data)\r\n\tfor item in dic.keys():\r\n\t\tif len(dic[item])==0:\r\n\t\t\tsample_shu=sample_shu-1\r\n\t\t\tprint(item+' have '+str(len(dic[item]))+' mutation,so remove this sample')\r\n\t\telse:\r\n\t\t\tprint(item+' have mutations: '+str(len(dic[item])))\r\n\tfor key in list(dic.keys()):\r\n\t\tif not dic.get(key):\r\n\t\t\tdel dic[key]\r\n\t\t\tall_data.remove(key)\r\n\tif len(all_data)>=3:\r\n\t\tall_driver_mutation={}\r\n\t\tfor item in dic.keys():\r\n\t\t\tif len(search_gene(dic[item],'FALSE'))>1:\r\n\t\t\t\tfor info in search_gene(dic[item],'TRUE')[:-1]:#remove count_map_driver_gene\r\n\t\t\t\t\tsplit=info.split(':')\r\n\t\t\t\t\tif split[0] not in all_driver_mutation.keys():\r\n\t\t\t\t\t\tall_driver_mutation.update({split[0]:[split[1]]})\r\n\t\t\t\t\telse:\r\n\t\t\t\t\t\tif split[1] not in all_driver_mutation[split[0]]:\r\n\t\t\t\t\t\t\tall_driver_mutation[split[0]].append(split[1])\r\n\t\tun_uniq_gene=0\r\n\t\tfor key in all_driver_mutation.keys():\r\n\t\t\tif len(all_driver_mutation[key])>1:\r\n\t\t\t\tprint(key+' have '+str(len(all_driver_mutation[key]))+' uniq mutations: '+str(all_driver_mutation[key]))\r\n\t\t\telse:\r\n\t\t\t\tun_uniq_gene=un_uniq_gene+1\r\n\t\tif un_uniq_gene==len(all_driver_mutation.keys()):\r\n\t\t\tprint('every gene refer to a uniq gene')\r\n\t\t#........................................................................\r\n\t\ti=0\r\n\t\tfor item in dic.keys():\r\n\t\t\ti=i+1\r\n\t\t\tif i==1:\r\n\t\t\t\tall_jiaoji=dic[item]\r\n\t\t\tall_jiaoji = [val for val in all_jiaoji if val in dic[item]]\r\n\t\troot_node=str(len(all_jiaoji))+'['+str(search_gene(all_jiaoji,'False')[-1])+'-'\r\n\t\tfor item in search_gene(all_jiaoji,'False')[:-1]:\r\n\t\t\troot_node=root_node+item+';'\r\n\t\troot_node=root_node[:-1]+']'\r\n\t\tfor item in dic.keys():\r\n\t\t\tfor item1 in all_jiaoji:\r\n\t\t\t\tdic[item].remove(item1)\r\n\r\n\t\t#...............................................body......................\r\n\t\tdic_baocun={}\r\n\t\tfor item in all_data:\r\n\t\t\tdic_baocun.update({item:[]})\r\n\t\tfor item in dic_baocun.keys():\r\n\t\t\tfor item_data in dic[item]:\r\n\t\t\t\tdic_baocun[item].append(item_data)\r\n\t\tglobal all_DATA\r\n\t\tall_result_1=[]\r\n\t\tglobal branch_path\r\n\t\tbranch_path=[]\r\n\t\tglobal path_string\r\n\t\tpath_string=[]\r\n\t\tglobal final_path_count\r\n\t\tfinal_path_count=-1\r\n\t\tglobal DIC_result\r\n\t\tDIC_result={}\r\n\t\tDIC_count=0\r\n\t\tduli_count=0\r\n\t\tduli_state='false'\r\n\t\tchongfu_bianli=0\r\n\t\twhile final_path_count!=len(branch_path) or len(path_string)!=len(branch_path):\r\n\t\t\tchongfu_bianli=chongfu_bianli+1\r\n\t\t\tdic={}\r\n\t\t\tfor item in all_data:\r\n\t\t\t\tdic.update({item:[]})\r\n\t\t\tfor item in dic.keys():\r\n\t\t\t\tfor item_data in dic_baocun[item]:\r\n\t\t\t\t\tdic[item].append(item_data)\r\n\t\t\tall_DATA=[]\r\n\t\t\tall_DATA.append(all_data)\r\n\t\t\tresult_1=[]\r\n\t\t\tpath=','\r\n\t\t\tdic_result={}\r\n\t\t\tfor all_item in all_DATA:\r\n\t\t\t\tdic1={}\r\n\t\t\t\tfor item in all_item:\r\n\t\t\t\t\tdic1.update({item:[]})\r\n\t\t\t\tfor item in dic1.keys():\r\n\t\t\t\t\tfor item_data in dic[item]:\r\n\t\t\t\t\t\tdic1[item].append(item_data)\r\n\t\t\t\t#check if there are any-two sample that do not share any mutation?\r\n\t\t\t\twhile len(all_item)>=2:\r\n\t\t\t\t\tsample_2={}\r\n\t\t\t\t\tcount2=0\r\n\t\t\t\t\tcishu2=int(Cmn(len(all_item),2))\r\n\t\t\t\t\twhile len(sample_2.keys())0:\r\n\t\t\t\t\t\tduli_count=duli_count+1\t\r\n\t\t\t\t\t\tresult_all=xunhuan(all_item)\r\n\t\t\t\t\t\tpath_state='false'\r\n\t\t\t\t\t\tfor result_path in result_all:\r\n\t\t\t\t\t\t\tsame_path_count=0\r\n\t\t\t\t\t\t\tidentify1=result_path.split(':')[0]\r\n\t\t\t\t\t\t\tfor result_path_1 in result_all:\r\n\t\t\t\t\t\t\t\tif identify1 == result_path_1.split(':')[0]:\r\n\t\t\t\t\t\t\t\t\tsame_path_count=same_path_count+1\r\n\t\t\t\t\t\t\tif same_path_count>=2:\r\n\t\t\t\t\t\t\t\tpath_state='true'\r\n\t\t\t\t\t\tbranch_path_iter=[]\r\n\t\t\t\t\t\tfor path_item in branch_path:\r\n\t\t\t\t\t\t\tif path_item not in branch_path_iter:\r\n\t\t\t\t\t\t\t\tbranch_path_iter.append(path_item)\r\n\t\t\t\t\t\t\telse:\r\n\t\t\t\t\t\t\t\tprint('branch_path error')\r\n\t\t\t\t\t\t#print('path_state: '+path_state)\r\n\t\t\t\t\t\tfor result_all_1 in result_all:\r\n\t\t\t\t\t\t\tif path_state=='false':\r\n\t\t\t\t\t\t\t\tpath_merge=path+';'+result_all_1.split(':')[0]\r\n\t\t\t\t\t\t\telse:\r\n\t\t\t\t\t\t\t\tpath_merge=path+';'+result_all_1\r\n\t\t\t\t\t\t\t#print('path_merge: '+path_merge)\r\n\t\t\t\t\t\t\tif path_merge[0]==',' and chongfu_bianli==1:\r\n\t\t\t\t\t\t\t\tif path_merge[2:] not in branch_path:\r\n\t\t\t\t\t\t\t\t\tbranch_path.append(path_merge[2:])\r\n\t\t\t\t\t\t\telse:\r\n\t\t\t\t\t\t\t\tif path_merge[0]==',':\r\n\t\t\t\t\t\t\t\t\tpath_merge=path_merge[2:]\r\n\t\t\t\t\t\t\t\tpath_all=len(branch_path_iter)\r\n\t\t\t\t\t\t\t\tpath_count=0\r\n\t\t\t\t\t\t\t\twhile path_count0:\r\n\t\t\t\tpath=path+';end'\r\n\t\t\t\tif path==',;end':\r\n\t\t\t\t\tprint('error: '+path)\r\n\t\t\t\tfor path_2 in branch_path:\r\n\t\t\t\t\tif path[:-4]==path_2:\r\n\t\t\t\t\t\tbranch_path.remove(path_2)\r\n\t\t\t\tif path not in branch_path:\r\n\t\t\t\t\tbranch_path.append(path)\r\n\t\t\tfor i in branch_path:\r\n\t\t\t\tif branch_path.count(i)>1:\r\n\t\t\t\t\tprint('branch_path have chongfu item: '+i)\r\n\t\t\tfinal_path_count=0\r\n\t\t\tfor path_data in branch_path:\r\n\t\t\t\tif path_data.split(';')[-1]=='end' or path_data[0].isalpha():\r\n\t\t\t\t\tfinal_path_count=final_path_count+1\r\n\r\n\t\t\tif duli_state=='false':\r\n\t\t\t\tif path not in path_string and path[-3:]=='end':\r\n\t\t\t\t\tpath_string.append(path)\r\n\r\n\t\t\t\t\tDIC_result.update({DIC_count:dic_result})\r\n\t\t\t\t\tDIC_count=DIC_count+1\r\n\t\t\t\t\tall_result_1.append(result_1)\r\n\t\t\telse:\r\n\t\t\t\tfor path_1 in branch_path:\r\n\t\t\t\t\tif path_1 not in path_string and path_1[-3:]=='end':\r\n\t\t\t\t\t\tpath_string.append(path_1)\r\n\t\t\t\t\telse:\r\n\t\t\t\t\t\tprint('The tree structure that completely branches from the root node is wrong!')\r\n\t\t\t\tDIC_result.update({DIC_count:dic_result})\r\n\t\t\t\tDIC_count=DIC_count+1\r\n\t\tprint('branch_path count: '+str(len(branch_path)))\r\n\t\tprint('path_string: '+str(len(path_string)))\r\n\t\tprint('all_result: '+str(len(all_result_1)))\r\n\t\tprint('DIC_result: '+str(len(DIC_result.keys())))\r\n\t\tfor item in all_result_1:\r\n\t\t\titem_copy = item[:]\r\n\r\n\t\t\tfor data in item_copy:\r\n\t\t\t\tif int(data.split(':')[1].split('[')[0])==0 and len(data.split(':')[0].split(','))>1:\r\n\t\t\t\t\titem.remove(data)\r\n\t\tall_result_weight=[]\r\n\t\tfor item in all_result_1:\r\n\t\t\tweight=0\r\n\r\n\t\t\tfor data in item:\r\n\t\t\t\tlength=len(data.split(':')[0].split(','))\r\n\t\t\t\tdata=data.split(':')[1].split('[')[0]\r\n\t\t\t\tif length>=2:\r\n\t\t\t\t\tweight=weight+length*int(data)\r\n\t\t\tall_result_weight.append(weight)\r\n\r\n\t\ti=0\r\n\t\tmax_weight_data=0\r\n\t\twhile i max_weight_data:\r\n\t\t\t\tmax_weight_data=all_result_weight[i]\r\n\t\t\ti=i+1\r\n\t\tresult_max_weight=[]\r\n\t\tif max_weight_data==0:\r\n\t\t\tDIC_result_max_weight={}\r\n\t\t\tfor item in all_result_1:\r\n\t\t\t\tresult_max_weight.append(item)\r\n\t\t\tDIC_result_max_weight.update({0:DIC_result[0]})\r\n\t\telse:\r\n\t\t\tDIC_result_max_weight={}\r\n\t\t\ti=0\r\n\t\t\ti1=0\r\n\t\t\twhile i 0 and final_result!=first_final):\r\n\t\t\t\tout=open(file_path_out+os.path.sep+patient+'_info_'+str(tree_count)+'.txt','w')\r\n\t\t\t\tfor item in ll:\r\n\t\t\t\t\tout.write(str(item))\r\n\t\t\t\t\tout.write('\\t')\r\n\t\t\t\tout.write('\\n')\r\n\t\t\t\tfor item in dic_final.keys():\r\n\t\t\t\t\tcount=0\r\n\t\t\t\t\tfor data in dic_final[item][1:-1]:\r\n\t\t\t\t\t\tcount=count+int(data)\r\n\t\t\t\t\tif count>=2:\r\n\t\t\t\t\t\tout.write(item)\r\n\t\t\t\t\t\tout.write('\\t')\r\n\t\t\t\t\t\tfor data in dic_final[item][1:]:\r\n\t\t\t\t\t\t\tout.write(str(data))\r\n\t\t\t\t\t\t\tout.write('\\t')\r\n\t\t\t\t\t\tout.write('\\n')\r\n\t\t\t\tout.close()\r\n\t\t\t\ttree = Phylo.read(StringIO(tree_structure), \"newick\")\r\n\t\t\t\t#tree.ladderize()# Flip branches so deeper clades are displayed at top\r\n\t\t\t\ttree.rooted = True\r\n\t\t\t\ttree.name=patient\r\n\t\t\t\ttree = tree.as_phyloxml()\r\n\t\t\t\ttree.root.branch_labels=root_node\r\n\t\t\t\t#global tree_label\r\n\t\t\t\tif ('[' in final_result[1:].split(':')[-1]) and (']' in final_result[1:].split(':')[-1]):\r\n\t\t\t\t\ttree_label=final_result[1:].split(':')[:-1]\r\n\t\t\t\telse:\r\n\t\t\t\t\ttree_label=final_result[1:].split(':')[:-2]\r\n\t\t\t\ttree_label_1=[str(i) for i in tree_label]\r\n\t\t\t\ttree_labels = ':'.join(tree_label_1)\r\n\t\t\t\ttree_label_split=tree_labels[:-1]\r\n\t\t\t\tglobal new_tree_labels\r\n\t\t\t\tnew_tree_labels=split_tree(tree_label_split)\r\n\t\t\t\toriginal_count=len(new_tree_labels)\r\n\t\t\t\toriginal_count1=original_count\r\n\t\t\t\tnum=0\r\n\t\t\t\tfor item in new_tree_labels:\r\n\t\t\t\t\tif num <=original_count-1:\r\n\t\t\t\t\t\ttree.clade[num].branch_labels=item.split(':')[-1]\r\n\t\t\t\t\t\tif ('(' in item) or (')' in item):\r\n\t\t\t\t\t\t\tnew_item_1=[str(i) for i in item.split(':')[:-1]]\r\n\t\t\t\t\t\t\tnew_item_split=':'.join(new_item_1)\r\n\t\t\t\t\t\t\tnew_item_split=new_item_split[1:-1]\r\n\t\t\t\t\t\t\tnew_items=split_tree(new_item_split)\r\n\t\t\t\t\t\t\tindex=0\r\n\t\t\t\t\t\t\tfor branch in new_items:\r\n\t\t\t\t\t\t\t\tbranch=str(num)+'*'+str(index)+'*'+branch\r\n\t\t\t\t\t\t\t\tnew_tree_labels.append(branch)\r\n\t\t\t\t\t\t\t\tindex=index+1\r\n\t\t\t\t\t\toriginal_count1=original_count1-1\r\n\t\t\t\t\telse:\r\n\t\t\t\t\t\tbranch=item.split('*')[-1]\r\n\t\t\t\t\t\tbranch_count=item.split('*')[:-1]\r\n\t\t\t\t\t\t#print(branch_count)\r\n\t\t\t\t\t\tbranch_count_merge=','\r\n\t\t\t\t\t\tfor index in branch_count:\r\n\t\t\t\t\t\t\tbranch_count_merge=branch_count_merge+'*'+index\r\n\t\t\t\t\t\tbranch_count_merge=branch_count_merge[2:]\r\n\t\t\t\t\t\tstr_count='tree.clade['\r\n\t\t\t\t\t\tfor ITEM in branch_count:\r\n\t\t\t\t\t\t\tstr_count=str_count+ITEM+','\r\n\t\t\t\t\t\tstr_count=str_count[:-1]+'].branch_labels = '+'\"'+item.split(':')[-1]+'\"'\r\n\t\t\t\t\t\t#print(str_count)\r\n\t\t\t\t\t\texec(str_count)\r\n\t\t\t\t\t\t#print(tree)\r\n\t\t\t\t\t\tif ('(' in item) or (')' in item):\r\n\t\t\t\t\t\t\tnew_item_1=[str(i) for i in item.split(':')[:-1]]\r\n\t\t\t\t\t\t\tnew_item_split=':'.join(new_item_1)\r\n\t\t\t\t\t\t\tnew_item_split=new_item_split.split('*')[-1]\r\n\t\t\t\t\t\t\tnew_item_split=new_item_split[1:-1]\r\n\t\t\t\t\t\t\tnew_items=split_tree(new_item_split)\r\n\t\t\t\t\t\t\tindex=0\r\n\t\t\t\t\t\t\tfor branch1 in new_items:\r\n\t\t\t\t\t\t\t\tbranch1=str(branch_count_merge)+'*'+str(index)+'*'+branch1\r\n\t\t\t\t\t\t\t\tnew_tree_labels.append(branch1)\r\n\t\t\t\t\t\t\t\tindex=index+1\r\n\t\t\t\t\tnum=num+1\r\n\t\t\t\tmatplotlib.rc('font', size=6)\r\n\t\t\t\tplt.rcParams['lines.linewidth'] = 0.7\r\n\t\t\t\tPhylo.draw(tree,do_show=False,branch_labels=lambda c: c.branch_labels)\t\r\n\t\t\t\t#Phylo.draw(tree,do_show=False,branch_labels=lambda c: int(c.branch_length))\r\n\t\t\t\tplt.savefig(file_path_out+os.path.sep+patient+'_tree_'+str(tree_count)+'.pdf',dpi=500)\r\n\t\t\t\tplt.close()\r\n\t\t\t\ttree_count=tree_count+1\r\n\t\tprint(patient+' ok!')\r\n\telse:\r\n\t\tprint(patient+' have less patients!')\r\n", "meta": {"hexsha": "fe784a6c6eeb2d1b38205f43fb058af9cef38af2", "size": 31274, "ext": "py", "lang": "Python", "max_stars_repo_path": "PTI-v1.0/PTI.py", "max_stars_repo_name": "morinlab/PTI", "max_stars_repo_head_hexsha": "cd3a9009021027551465a123aa31edad8b3caeb6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "PTI-v1.0/PTI.py", "max_issues_repo_name": "morinlab/PTI", "max_issues_repo_head_hexsha": "cd3a9009021027551465a123aa31edad8b3caeb6", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "PTI-v1.0/PTI.py", "max_forks_repo_name": "morinlab/PTI", "max_forks_repo_head_hexsha": "cd3a9009021027551465a123aa31edad8b3caeb6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-09-28T09:39:37.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-26T16:56:55.000Z", "avg_line_length": 32.7819706499, "max_line_length": 171, "alphanum_fraction": 0.609963548, "include": true, "reason": "import numpy", "num_tokens": 8581, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5544704649604273, "lm_q2_score": 0.35577489351363034, "lm_q1q2_score": 0.19726667062774914}} {"text": "#!/usr/bin/env python\n\"\"\"\ngapfill : Fills gaps of flux data from Eddy covariance measurements according\n to Reichstein et al. (Global Change Biology, 2005) or estimate flux\n uncertainties after Lasslop et al. (Biogeosciences, 2008).\n\nThis module was written by Matthias Cuntz while at Department of\nComputational Hydrosystems, Helmholtz Centre for Environmental\nResearch - UFZ, Leipzig, Germany, and continued while at Institut\nNational de Recherche pour l'Agriculture, l'Alimentation et\nl'Environnement (INRAE), Nancy, France.\n\nCopyright (c) 2012-2020 Matthias Cuntz - mc (at) macu (dot) de\nReleased under the MIT License; see LICENSE file for details.\n\n* Written Mar 2012 by Matthias Cuntz - mc (at) macu (dot) de\n* Ported to Python 3, Feb 2013, Matthias Cuntz\n* Input data can be ND-array, Apr 2014, Matthias Cuntz\n* Bug in longestmarginalgap: was only working at time series edges, rename it\n to longgap, Apr 2014, Matthias Cuntz\n* Keyword fullday, Apr 2014, Matthias Cuntz\n* Input can be pandas Dataframe or numpy array(s), Apr 2020, Matthias Cuntz\n* Using numpy docstring format, May 2020, Matthias Cuntz\n* error estimates are undef by default, Jun 2021, Matthias Cuntz\n* mean of values for error estimates, Jun 2021, Matthias Cuntz\n\n.. moduleauthor:: Matthias Cuntz\n\nThe following functions are provided\n\n.. autosummary::\n gapfill\n\"\"\"\nfrom __future__ import division, absolute_import, print_function\nimport numpy as np\nimport pandas as pd\n\n\n__all__ = ['gapfill']\n\n\ndef gapfill(dfin, flag=None, date=None, timeformat='%Y-%m-%d %H:%M:%S',\n colhead=None,\n sw_dev=50., ta_dev=2.5, vpd_dev=5.,\n longgap=60, fullday=False, undef=-9999, ddof=1,\n err=False, errmean=False, verbose=0):\n \"\"\"\n Fills gaps in flux data from Eddy covariance measurements with\n Marginal Distribution Sampling (MDS) according to Reichstein et al.\n (Global Change Biology, 2005).\n\n This means, if there is a gap in the data, look for similar meteorological\n conditions (defined as maximum possible deviations) in a certain time\n window and fill with the average of these 'similar' values.\n\n The routine can also do the same search for similar meteorological\n conditions for every data point and calculate its standard deviation as a\n measure of uncertainty after Lasslop et al. (Biogeosciences, 2008).\n\n Parameters\n ----------\n dfin : pandas.Dataframe or numpy.array\n time series of fluxes to fill as well as\n meteorological variables incoming short-wave radiation,\n air temperature, air vapour pressure deficit.\n\n `dfin` can be a pandas.Dataframe with the columns\n 'SW_IN' (or starting with 'SW_IN') for incoming short-wave radiation [W m-2]\n 'TA' (or starting with 'TA\\_') for air temperature [deg C]\n 'VPD' (or starting with 'VPD') for air vapour deficit [hPa]\n and columns with ecosystem fluxes with possible missing values (gaps).\n The index is taken as date variable.\n\n `dfin` can also me a numpy array with the same columns. In this case\n `colhead`, `date`, and possibly `dateformat` must be given.\n flag : pandas.Dataframe or numpy.array, optional\n flag Dataframe or array has the same shape as dfin. Non-zero values in\n `flag` will be treated as missing values in `dfin`.\n\n `flag` must follow the same rules as `dfin` if pandas.Dataframe.\n\n If `flag` is numpy array, `df.columns.values` will be used as\n column heads and the index of `dfin` will be copied to `flag`.\n date : array_like of string, optional\n 1D-array_like of calendar dates in format given in `timeformat`.\n\n `date` must be given if `dfin` is numpy array.\n timeformat : str, optional\n Format of dates in `date`, if given (default: '%Y-%m-%d %H:%M:%S').\n See strftime documentation of Python's datetime module:\n https://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior\n colhed : array_like of str, optional\n column names if `dfin` is numpy array. See `dfin` for mandatory\n column names.\n sw_dev : float, optional\n threshold for maximum deviation of global radiation (default: 50)\n ta_dev : float, optional\n threshold for maximum deviation of air Temperature (default: 2.5)\n vpd_dev : float, optional\n threshold for maximum deviation of vpd (default: 5.)\n longgap : int, optional\n avoid extraploation into a gap longer than `longgap` days (default: 60)\n fullday : bool, optional\n True: move beginning of large gap to start of next day and move end of\n large gap to end of last day (default: False)\n undef : float, optional\n values having `undef` value are treated as missing values in `dfin`\n (default: -9999)\n\n np.nan is not allowed (not working).\n ddof : int, optional\n Delta Degrees of Freedom. The divisor used in calculation of standard\n deviation for error estimates (`err=True`) is ``N-ddof``, where ``N``\n represents the number of elements (default: 1).\n err : bool, optional\n True: fill every data point with standard deviation instead of mean,\n i.e. used for error generation as in Lasslop et al. (Biogeosci 2008)\n (default: False)\n errmean : bool, optional\n True: also return mean value of values for error estimate\n `if err == True` (default: False)\n shape : bool or tuple, optional\n True: output have the same shape as input data if `dfin` is\n numpy array; if a tuple is given, then this tuple is used to reshape.\n\n False: outputs are 1D arrays if `dfin` is numpy array (default: False).\n verbose : int, optional\n Verbosity level 0-3 (default: 0). 0 is no output; 3 is very verbose.\n\n Returns\n -------\n pandas.Dataframe(s) or numpy array(s)\n `if not err:` filled_data, quality_class\n\n `if err and not errmean:` err_estimate\n\n `if err and errmean:` err_estimate, mean_estimate\n\n pandas.Dataframe(s) will be returned if `dfin` was Dataframe.\n\n numpy array(s) will be returned if `dfin` was numpy array.\n\n Notes\n -----\n If `err`, there is no error estimate if there are no meteorological\n conditions in the vicinity of the data point (first cycle of\n Reichstein et al. GCB 2005).\n\n Routine does not work with `undef=np.nan`.\n\n Reichstein et al. (2005)\n On the separation of net ecosystem exchange into assimilation and\n ecosystem respiration: review and improved algorithm\n Global Change Biology 11, 1424-1439\n\n Lasslop et al. (2008)\n Influences of observation errors in eddy flux data on inverse model\n parameter estimation\n Biogeosciences, 5, 1311–1324\n\n Examples\n --------\n >>> import numpy as np\n >>> from fread import fread\n >>> from date2dec import date2dec\n >>> from dec2date import dec2date\n >>> ifile = 'test_gapfill.csv' # Tharandt 1998 = Online tool example file\n >>> undef = -9999.\n >>> # data\n >>> dat = fread(ifile, skip=2, transpose=True)\n >>> ndat = dat.shape[1]\n >>> head = fread(ifile, skip=2, header=True)\n >>> head1 = head[0]\n >>> # colhead\n >>> idx = []\n >>> for i in head1:\n ... if i in ['NEE', 'LE', 'H', 'Rg', 'Tair', 'VPD']:\n ... idx.append(head1.index(i))\n >>> colhead = ['FC', 'LE', 'H', 'SW_IN', 'TA', 'VPD']\n >>> # data\n >>> dfin = dat[idx,:]\n >>> # flag\n >>> flag = np.where(dfin == undef, 2, 0)\n >>> flag[0, :] = dat[head1.index('qcNEE'), :].astype(int)\n >>> flag[1, :] = dat[head1.index('qcLE'), :].astype(int)\n >>> flag[2, :] = dat[head1.index('qcH'), :].astype(int)\n >>> flag[np.where(flag==1)] = 0\n >>> # date\n >>> day_id = head1.index('Day')\n >>> hour_id = head1.index('Hour')\n >>> ntime = dat.shape[1]\n >>> year = np.ones(ntime, dtype=int) * 1998\n >>> hh = dat[hour_id, :].astype(int)\n >>> mn = np.rint((dat[hour_id,:] - hh) * 60.).astype(int)\n >>> y0 = date2dec(yr=year[0], mo=1, dy=1, hr=hh, mi=mn)\n >>> jdate = y0 + dat[day_id, :]\n >>> adate = dec2date(jdate, eng=True)\n >>> # fill\n >>> dat_f, flag_f = gapfill(dfin, flag=flag, date=adate, colhead=colhead,\n ... undef=undef, verbose=0)\n >>> print('{:d} {:d} {:d} {:d} {:d} {:d}'.format(*flag_f[0, 11006:11012]))\n 1 1 1 2 2 2\n >>> print('{:.2f} {:.2f} {:.2f} {:.2f} {:.2f} {:.2f}'.format(\n ... *dat_f[0, 11006:11012]))\n -18.68 -15.63 -19.61 -15.54 -12.40 -15.33\n\n >>> # 1D err\n >>> dat_std = gapfill(dfin, flag=flag, date=adate, colhead=colhead,\n ... undef=undef, verbose=0, err=True)\n >>> print('{:.3f} {:.3f} {:.3f} {:.3f} {:.3f} {:.3f}'.format(\n ... *dat_std[0, 11006:11012]))\n 5.372 13.118 6.477 -9999.000 -9999.000 -9999.000\n\n >>> dat_err = np.ones(ndat, dtype=int)*(-1)\n >>> kk = np.where((dat_std[0, :] != undef) & (dat_f[0, :] != 0.))[0]\n >>> dat_err[kk] = np.abs(dat_std[0,kk]/dat_f[0,kk]*100.).astype(int)\n >>> print('{:d} {:d} {:d} {:d} {:d} {:d}'.format(*dat_err[11006:11012]))\n 28 83 33 -1 -1 -1\n\n >>> # 1D err + mean\n >>> dat_std, dat_mean = gapfill(dfin, flag=flag, date=adate,\n ... colhead=colhead, undef=undef, verbose=0,\n ... err=True, errmean=True)\n >>> print('{:.3f} {:.3f} {:.3f} {:.3f} {:.3f} {:.3f}'.format(\n ... *dat_std[0, 11006:11012]))\n 5.372 13.118 6.477 -9999.000 -9999.000 -9999.000\n >>> print('{:.3f} {:.3f} {:.3f} {:.3f} {:.3f} {:.3f}'.format(\n ... *dat_mean[0, 11006:11012]))\n -18.677 -15.633 -19.610 -9999.000 -9999.000 -9999.000\n\n\n History\n -------\n Written, Matthias Cuntz, Mar 2012 - modified gap_filling.py\n Modified, Matthias Cuntz, Feb 2013 - ported to Python 3\n Matthias Cuntz, Apr 2014 - assert\n - data ND-array\n - longestmarginalgap was only working at\n beginning and end of time series\n renamed to longgap\n - fullday\n Matthias Cuntz, Apr 2020 - Input can be pandas Dataframe or\n numpy array(s)\n Matthias Cuntz, May 2020 - numpy docstring format\n Matthias Cuntz, Jun 2021 - prefill error estimates with undef\n - errmean\n \"\"\"\n # Check input\n # numpy or panda\n if isinstance(dfin, (np.ndarray, np.ma.MaskedArray)):\n isnumpy = True\n istrans = False\n astr = 'colhead must be given if input is numpy.ndarray.'\n assert colhead is not None, astr\n if dfin.shape[0] == len(colhead):\n istrans = True\n df = pd.DataFrame(dfin.T, columns=colhead)\n elif dfin.shape[1] == len(colhead):\n df = pd.DataFrame(dfin, columns=colhead)\n else:\n estr = 'Length of colhead must be number of columns in input'\n estr = estr + ' array. len(colhead)=' + str(len(colhead))\n estr = estr + ' shape(input)=(' + str(dfin.shape[0])\n estr = estr + ',' + str(dfin.shape[1]) + ').'\n raise ValueError(estr)\n assert date is not None, 'date must be given if input is numpy arrary.'\n df['Datetime'] = pd.to_datetime(date, format=timeformat)\n df.set_index('Datetime', drop=True, inplace=True)\n else:\n isnumpy = False\n istrans = False\n astr = 'Input must be either numpy.ndarray or pandas.DataFrame.'\n assert isinstance(dfin, pd.core.frame.DataFrame), astr\n df = dfin.copy(deep=True)\n\n # Incoming flags\n if flag is not None:\n if isinstance(flag, (np.ndarray, np.ma.MaskedArray)):\n fisnumpy = True\n fistrans = False\n if flag.shape[0] == len(df):\n ff = pd.DataFrame(flag, columns=df.columns.values)\n elif flag.shape[1] == len(df):\n fistrans = True\n ff = pd.DataFrame(flag.T, columns=df.columns.values)\n else:\n estr = 'flag must have same shape as data array. data:'\n estr += ' ({:d},{:d}); flag: ({:d},{:d})'.format(\n dfin.shape[0], dfin.shape[1], flag.shape[0], flag.shape[1])\n raise ValueError(estr)\n ff = ff.set_index(df.index)\n else:\n fisnumpy = False\n fistrans = False\n astr = 'Flag must be either numpy.ndarray or pandas.DataFrame.'\n assert isinstance(flag, pd.core.frame.DataFrame), astr\n ff = flag.copy(deep=True)\n else:\n fisnumpy = isnumpy\n fistrans = istrans\n # flags: 0: good; 1: input flagged; 2: output flagged\n ff = df.copy(deep=True).astype(int)\n ff[:] = 0\n ff[df == undef] = 1\n ff[df.isna()] = 1\n\n # Data and flags\n sw_id = ''\n for cc in df.columns:\n if cc.startswith('SW_IN_') or (cc == 'SW_IN'):\n sw_id = cc\n break\n ta_id = ''\n for cc in df.columns:\n if cc.startswith('TA_') or (cc == 'TA'):\n ta_id = cc\n break\n vpd_id = ''\n for cc in df.columns:\n if cc.startswith('VPD_') or (cc == 'VPD'):\n vpd_id = cc\n break\n astr = 'Global radiation with name SW or starting with SW_'\n astr = astr + ' must be in input.'\n assert sw_id, astr\n astr = 'Air temperature with name TA or starting with TA_'\n astr = astr + ' must be in input.'\n assert ta_id, astr\n astr = 'Vapour pressure deficit with name VPD or starting'\n astr = astr + ' with VPD_ must be in input.'\n assert vpd_id, astr\n\n sw = df[sw_id].to_numpy()\n sw_flg = ff[sw_id].to_numpy()\n ta = df[ta_id].to_numpy()\n ta_flg = ff[ta_id].to_numpy()\n vpd = df[vpd_id].to_numpy()\n vpd_flg = ff[vpd_id].to_numpy()\n\n # dfill is filled data\n # ffill is fill flag if not err else error estimate\n dfill = df.copy(deep=True)\n if err:\n ffill = df.copy(deep=True)\n else:\n ffill = ff.copy(deep=True)\n ffill[:] = 0\n\n # Times\n # number of data points per week; basic factor of the time window\n week = pd.Timedelta('1 W') / (df.index[1] - df.index[0])\n nperday = week // 7\n hour = df.index.hour + df.index.minute/60.\n day = (df.index.to_julian_date()-0.5).astype(int)\n\n # Filling variables\n ndata = len(df)\n for hcol in df.columns:\n\n if hcol.startswith('SW_IN_') or (hcol == 'SW_IN'):\n continue\n if hcol.startswith('TA_') or (hcol == 'TA'):\n continue\n if hcol.startswith('VPD_') or (hcol == 'VPD'):\n continue\n\n if verbose > 0:\n if err:\n print(' Error estimate ', str(hcol))\n else:\n print(' Filling ', str(hcol))\n\n data = df[hcol].to_numpy()\n dflag = ff[hcol].to_numpy()\n\n data_f = dfill[hcol].to_numpy()\n dflag_f = ffill[hcol].to_numpy()\n\n if err:\n data_f[:] = undef\n dflag_f[:] = undef\n\n # Large margins\n\n # Check for large margins at beginning\n largegap = np.zeros(ndata, dtype=bool)\n firstvalid = np.amin(np.where(dflag == 0)[0])\n lastvalid = np.amax(np.where(dflag == 0)[0])\n nn = int(nperday*longgap)\n if firstvalid > nn:\n if verbose > 1:\n print(' Large margin at beginning: ', firstvalid)\n largegap[0:(firstvalid-nn)] = True\n if lastvalid < (ndata-nn):\n if verbose > 1:\n print(' Large margin at end: ', lastvalid-nn)\n largegap[(lastvalid+nn):] = True\n\n # Large gaps\n\n # search largegap - code from maskgroup.py\n index = []\n length = []\n count = 0\n for i in range(ndata):\n if i == 0:\n if dflag[i] != 0:\n index += [i]\n count = 1\n if i > 0:\n if (dflag[i] != 0) and (dflag[i-1] == 0):\n index += [i]\n count = 1\n elif dflag[i] != 0:\n count += 1\n elif (dflag[i] == 0) and (dflag[i-1] != 0):\n length += [count]\n count = 0\n else:\n pass\n if count > 0:\n length += [count]\n\n # set largegap\n for i in range(len(index)):\n if length[i] > nn:\n if verbose > 1:\n print(' Large gap: ', index[i], ':', index[i]+length[i])\n largegap[index[i]:index[i]+length[i]] = True\n\n # set or unset rest of days in large gaps\n if fullday:\n for i in range(ndata-1):\n # end of large margin\n if largegap[i] and not largegap[i+1]:\n largegap[np.where(day == day[i])[0]] = False\n # beginning of large margin\n elif not largegap[i] and largegap[i+1]:\n largegap[np.where(day == day[i])[0]] = False\n else:\n continue\n\n # Gap filling\n\n # flag for all meteorological conditions\n meteo_flg = (ta_flg == 0) & (vpd_flg == 0) & (sw_flg == 0)\n # flag for all meteorological conditions and data\n total_flg = meteo_flg & (dflag == 0)\n\n # Fill loop over all data points\n for j in range(ndata):\n if not err:\n # no reason to go further, no gap -> continue\n if (dflag[j] == 0) | largegap[j]:\n continue\n # 3 Methods\n # 1. ta, vpd and global radiation sw;\n # 2. just global radiation sw;\n # 3. no meteorolgical conditions: take the mean of +- hour\n\n # for better overview: dynamic calculation of radiation threshold\n # minimum 20; maximum 50 [Wm-2] according to private correspondence\n # with Markus Reichstein\n sw_devmax = np.maximum(20., np.minimum(sw[j], sw_dev))\n\n # Method 1: all met conditions\n if meteo_flg[j]:\n # search for values around the met-conditions\n # in a window of time\n # (one week in the first iteration and odd weeks in the next)\n j1 = j - np.arange(1, week+1, dtype=int) + 1\n j2 = j + np.arange(1, week, dtype=int)\n jj = np.append(j1, j2)\n win = np.unique(np.sort(np.clip(jj, 0, ndata-1)))\n # get boolean array where meteo-conditions are in a given width\n conditions = ( (np.abs(sw[win]-sw[j]) < sw_devmax) &\n (np.abs(ta[win]-ta[j]) < ta_dev) &\n (np.abs(vpd[win]-vpd[j]) < vpd_dev) &\n total_flg[win] )\n num4avg = np.sum(conditions)\n # we need at least two samples with similar conditions\n if num4avg >= 2:\n dat = np.ma.array(data[win], mask=~conditions)\n if verbose > 2:\n print(' m1.1: ', j, win.size, dat.mean(),\n dat.std(ddof=ddof))\n data_f[j] = dat.mean()\n if err:\n dflag_f[j] = dat.std(ddof=ddof)\n else:\n # assign also quality category of gap filling\n dflag_f[j] = 1\n continue\n else: # --> extend time window to two weeks\n j1 = j - np.arange(1, 2*week+1, dtype=int) + 1\n j2 = j + np.arange(1, 2*week, dtype=int)\n jj = np.append(j1, j2)\n win = np.unique(np.sort(np.clip(jj, 0, ndata-1)))\n conditions = ( (np.abs(sw[win] - sw[j]) < sw_devmax) &\n (np.abs(ta[win] - ta[j]) < ta_dev) &\n (np.abs(vpd[win] - vpd[j]) < vpd_dev) &\n total_flg[win] )\n num4avg = np.sum(conditions)\n if num4avg >= 2:\n dat = np.ma.array(data[win], mask=~conditions)\n if verbose > 2:\n print(' m1.2: ', j, win.size, dat.mean(),\n dat.std(ddof=ddof))\n data_f[j] = dat.mean()\n if err:\n dflag_f[j] = dat.std(ddof=ddof)\n else:\n # assign also quality category of gap filling\n dflag_f[j] = 1\n continue\n\n if err:\n continue\n # if you come here, gap-filling rather than error estimate\n\n # If nothing is found under similar meteo within two weeks,\n # look for global radiation within one week ->\n\n # Method 2: just global radiation available\n if sw_flg[j] == 0:\n j1 = j - np.arange(1, week+1, dtype=int) + 1\n j2 = j + np.arange(1, week, dtype=int)\n jj = np.append(j1, j2)\n win = np.unique(np.sort(np.clip(jj, 0, ndata-1)))\n # get boolean array where meteo-conditions are in a given width\n conditions = ( (np.abs(sw[win]-sw[j]) < sw_devmax) &\n total_flg[win] )\n num4avg = np.sum(conditions)\n # we need at least two samples with similar conditions\n if num4avg >= 2:\n dat = np.ma.array(data[win], mask=~conditions)\n if verbose > 2:\n print(' m2: ', j, win.size, dat.mean(),\n dat.std(ddof=ddof))\n data_f[j] = dat.mean()\n dflag_f[j] = 1\n continue\n\n # If still nothing is found under similar sw within one week,\n # take the same hour within 1-7 days\n\n # Method 3: same hour\n enough = False\n for i in range(2):\n t_win = (nperday * (2*i+1))//2\n j1 = j - np.arange(1, t_win+1, dtype=int) + 1\n j2 = j + np.arange(1, t_win, dtype=int)\n jj = np.append(j1, j2)\n win = np.unique(np.sort(np.clip(jj, 0, ndata-1)))\n conditions = ( (np.abs(hour[win]-hour[j]) < 1.1)\n & (dflag[win] == 0) )\n num4avg = np.sum(conditions)\n if num4avg >= 2:\n dat = np.ma.array(data[win], mask=~conditions)\n if verbose > 2:\n print(' m3.{:d}: '.format(i), j, win.size,\n dat.mean(), dat.std(ddof=ddof))\n data_f[j] = dat.mean()\n if i == 0:\n dflag_f[j] = 1\n else:\n dflag_f[j] = 2\n break\n\n # sanity check\n if dflag_f[j] > 0:\n continue\n\n # If still nothing is found, start a new cycle\n # with increased window size\n # Method 4: same as 1 but for 3-12 weeks\n if meteo_flg[j]:\n for multi in range(3, 12):\n j1 = j - np.arange(1, multi*week+1, dtype=int) + 1\n j2 = j + np.arange(1, multi*week, dtype=int)\n jj = np.append(j1, j2)\n win = np.unique(np.sort(np.clip(jj, 0, ndata-1)))\n conditions = ( (np.abs(sw[win] - sw[j]) < sw_devmax) &\n (np.abs(ta[win] - ta[j]) < ta_dev) &\n (np.abs(vpd[win] - vpd[j]) < vpd_dev) &\n total_flg[win] )\n num4avg = np.sum(conditions)\n # we need at least two samples with similar conditions\n if num4avg >= 2:\n dat = np.ma.array(data[win], mask=~conditions)\n if verbose > 2:\n print(' m4.{:d}: '.format(multi), j, win.size,\n dat.mean(), dat.std(ddof=ddof))\n data_f[j] = dat.mean()\n # assign also quality category of gap filling\n if multi <= 2:\n dflag_f[j] = 1\n elif multi > 4:\n dflag_f[j] = 3\n else:\n dflag_f[j] = 2\n break\n\n # Check because continue does not support\n # to jump out of two loops\n if dflag_f[j] > 0:\n continue\n\n # Method 5: same as 2 but for 2-12 weeks\n if sw_flg[j] == 0:\n for multi in range(2, 12):\n j1 = j - np.arange(1, multi*week+1, dtype=int) + 1\n j2 = j + np.arange(1, multi*week, dtype=int)\n jj = np.append(j1, j2)\n win = np.unique(np.sort(np.clip(jj, 0, ndata-1)))\n # get boolean array where meteo-conditions are\n # in a given width\n conditions = ( (np.abs(sw[win] - sw[j]) < sw_devmax) &\n total_flg[win] )\n num4avg = np.sum(conditions)\n # we need at least two samples with similar conditions\n if num4avg >= 2:\n dat = np.ma.array(data[win], mask=~conditions)\n if verbose > 2:\n print(' m5.{:d}: '.format(multi), j, win.size,\n dat.mean(), dat.std(ddof=ddof))\n data_f[j] = dat.mean()\n if multi == 0:\n dflag_f[j] = 1\n elif multi <= 2:\n dflag_f[j] = 2\n else:\n dflag_f[j] = 3\n break\n\n if dflag_f[j] > 0:\n continue\n\n # Method 6: same as 3 but for 3-120 days\n for i in range(3, 120):\n t_win = nperday * (2*i+1)/2\n j1 = j - np.arange(1, t_win+1, dtype=int) + 1\n j2 = j + np.arange(1, t_win, dtype=int)\n jj = np.append(j1, j2)\n win = np.unique(np.sort(np.clip(jj, 0, ndata-1)))\n conditions = ( (np.abs(hour[win]-hour[j]) < 1.1)\n & (dflag[win] == 0) )\n num4avg = np.sum(conditions)\n if num4avg >= 2:\n dat = np.ma.array(data[win], mask=~conditions)\n if verbose > 2:\n print(' m6.{:d}: '.format(i), j, win.size,\n dat.mean(), dat.std(ddof=ddof))\n data_f[j] = dat.mean()\n dflag_f[j] = 3\n break\n\n dfill[hcol] = data_f\n ffill[hcol] = dflag_f\n\n # Finish\n\n if isnumpy:\n if istrans:\n dfout = dfill.to_numpy().T\n else:\n dfout = dfill.to_numpy()\n else:\n dfout = dfill\n\n if fisnumpy:\n if fistrans:\n ffout = ffill.to_numpy().T\n else:\n ffout = ffill.to_numpy()\n else:\n ffout = ffill\n\n if err:\n if errmean:\n return ffout, dfout\n else:\n return ffout\n else:\n return dfout, ffout\n\n\nif __name__ == '__main__':\n import doctest\n doctest.testmod(optionflags=doctest.NORMALIZE_WHITESPACE)\n\n # import numpy as np\n # from fread import fread\n # from date2dec import date2dec\n # from dec2date import dec2date\n # from autostring import astr\n # ifile = 'test_gapfill.csv' # Tharandt 1998 = Online tool example file\n # undef = -9999.\n # # Day Hour NEE qcNEE LE qcLE H qcH Rg Tair Tsoil rH VPD Ustar\n # # -- -- umolm-2s-1 -- Wm-2 -- Wm-2 -- Wm-2 degC degC % hPa ms-1\n # # 1 0.5 -1.21 1 1.49 1 -11.77 1 0 7.4 4.19 55.27 4.6 0.72\n # dat = fread(ifile, skip=2, transpose=True)\n # # dat = dat[:,:1000]\n # ndat = dat.shape[1]\n # head = fread(ifile, skip=2, header=True)\n # head1 = head[0]\n # # colhead\n # idx = []\n # for i in head1:\n # if i in ['NEE', 'LE', 'H', 'Rg', 'Tair', 'VPD']: idx.append(head1.index(i))\n # colhead = ['FC', 'LE', 'H', 'SW_IN', 'TA', 'VPD']\n # # data\n # dfin = dat[idx,:]\n # # flag\n # flag = np.where(dfin == undef, 2, 0)\n # flag[0,:] = dat[head1.index('qcNEE'),:].astype(int)\n # flag[1,:] = dat[head1.index('qcLE'),:].astype(int)\n # flag[2,:] = dat[head1.index('qcH'),:].astype(int)\n # flag[np.where(flag==1)] = 0\n # # date\n # day_id = head1.index('Day')\n # hour_id = head1.index('Hour')\n # ntime = dat.shape[1]\n # year = np.ones(ntime, dtype=int) * 1998\n # hh = dat[hour_id,:].astype(int)\n # mn = np.rint((dat[hour_id,:]-hh)*60.).astype(int)\n # y0 = date2dec(yr=year[0], mo=1, dy=1, hr=hh, mi=mn)\n # jdate = y0 + dat[day_id,:]\n # adate = dec2date(jdate, eng=True)\n # # fill\n # dat_f, flag_f = gapfill(dfin, flag=flag, date=adate, colhead=colhead, undef=undef, verbose=0)\n # print(astr(flag_f[0,11006:11012],0,pp=True))\n # # ['1' '1' '1' '2' '2' '2']\n # print(astr(dat_f[0,11006:11012],3,pp=True))\n # # ['-18.678' '-15.633' '-19.610' '-15.536' '-12.402' '-15.329']\n\n # # 1D err\n # dat_std = gapfill(dfin, flag=flag, date=adate, colhead=colhead, undef=undef, verbose=0, err=True)\n # print(astr(dat_std[0,11006:11012],3,pp=True))\n # # [' 5.372' ' 13.118' ' 6.477' '-9999.000' '-9999.000' '-9999.000']\n\n # dat_err = np.ones(ndat, dtype=int)*(-1)\n # kk = np.where((dat_std[0,:] != undef) & (dat_f[0,:] != 0.))[0]\n # dat_err[kk] = np.abs(dat_std[0,kk]/dat_f[0,kk]*100.).astype(int)\n # print(astr(dat_err[11006:11012],pp=True))\n # # [' 28' ' 83' ' 33' ' -1' ' -1' ' -1']\n", "meta": {"hexsha": "ae1870b9d00ac8a701ccb0ea3ab9df07d5d121d3", "size": 30647, "ext": "py", "lang": "Python", "max_stars_repo_path": "hesseflux/gapfill.py", "max_stars_repo_name": "mcuntz/hesseflux", "max_stars_repo_head_hexsha": "18884e1b33c647da18dcfa5ee689a37d2f274b5a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2020-05-26T08:56:22.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-29T14:45:03.000Z", "max_issues_repo_path": "hesseflux/gapfill.py", "max_issues_repo_name": "mcuntz/hesseflux", "max_issues_repo_head_hexsha": "18884e1b33c647da18dcfa5ee689a37d2f274b5a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-02-22T15:15:56.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-25T23:30:00.000Z", "max_forks_repo_path": "hesseflux/gapfill.py", "max_forks_repo_name": "mcuntz/hesseflux", "max_forks_repo_head_hexsha": "18884e1b33c647da18dcfa5ee689a37d2f274b5a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-11-24T21:38:35.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-24T11:12:28.000Z", "avg_line_length": 41.0267737617, "max_line_length": 103, "alphanum_fraction": 0.5076516462, "include": true, "reason": "import numpy", "num_tokens": 8350, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5544704796847396, "lm_q2_score": 0.3557748798522984, "lm_q1q2_score": 0.19726666829148448}} {"text": "from PyQt5 import QtCore, QtGui, QtWidgets\nimport res_rc\nimport ui as gui\nimport global_ as g\nimport numpy as np \nimport matplotlib\nimport matplotlib.pyplot as plt\nfrom matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas\nfrom matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as NavigationToolbar\nfrom matplotlib.figure import Figure\n\nimport pickle\nimport sys\nimport random\nimport numpy as np\nimport argparse\nimport Reader\nimport Spectrum\nimport Algorithm\nclass Button:\n def __init__(self,button,entry):\n self.button = button\n self.entry = entry\n g.values[self.entry] = self.button.value()\n self.button.valueChanged.connect(self.valuechange)\n def valuechange(self):\n g.values[self.entry] = self.button.value()\n if(self.entry == \"lb\" or self.entry == \"hb\"):\n for i in range(len(g.canvas_list)):\n try:\n g.canvas_list[i].change_x()\n except:\n pass\n elif(self.entry == \"w\" or self.entry == \"T\"):\n try:\n g.Spectrum.Boltzmann_weight_IR()\n g.canvas_list[2].plot_IR_theo()\n g.Spectrum.Boltzmann_weight_VCD()\n g.canvas_list[3].plot_VCD_theo()\n except:\n pass\nclass Click_Button:\n def __init__(self,button,entry,args = None):\n self.button = button\n self.entry = entry\n self.button.clicked.connect(self.click)\n self.args = args\n def click(self):\n if(self.entry == \"normalize_1\"):\n try:\n tmp = (g.exp_ir[:,0] <= g.values[\"hb\"]) & (g.exp_ir[:,0] >= g.values[\"lb\"])\n g.exp_ir[:,1] = g.exp_ir[:,1]/np.max(g.exp_ir[tmp,1])\n g.canvas_list[0].plot_IR()\n except:\n pass\n try:\n tmp = (g.exp_vcd[:,0] <= g.values[\"hb\"]) & (g.exp_vcd[:,0] >= g.values[\"lb\"])\n g.exp_vcd[:,1] = g.exp_vcd[:,1]/np.max(np.abs(g.exp_vcd[tmp,1]))\n g.canvas_list[1].plot_VCD() \n except:\n pass\n elif(self.entry == \"normalize_2\"):\n try:\n tmp = (g.theo_ir[:,0] <= g.values[\"hb\"]) & (g.theo_ir[:,0] >= g.values[\"lb\"])\n g.theo_ir[:,1] = g.theo_ir[:,1]/np.max(g.theo_ir[tmp,1])\n g.canvas_list[2].plot_IR()\n except:\n pass\n try:\n tmp = (g.theo_vcd[:,0] <= g.values[\"hb\"]) & (g.theo_vcd[:,0] >= g.values[\"lb\"])\n g.theo_vcd[:,1] = g.theo_vcd[:,1]/np.max(np.abs(g.theo_vcd[tmp,1]))\n g.canvas_list[3].plot_VCD() \n except:\n pass\n elif(self.entry == \"automatic\"):\n try:\n tmp = (g.exp_ir[:,0] <= g.values[\"hb\"]) & (g.exp_ir[:,0] >= g.values[\"lb\"])\n tmp_ir = np.asarray(g.exp_ir[tmp])\n g.peak_list_x = []\n g.peak_list_y = []\n g.peak_list_VCD_y = []\n for i in range(1,len(tmp_ir)-1):\n if(tmp_ir[i-1,1]<=tmp_ir[i,1]>=tmp_ir[i+1,1]):\n g.peak_list_x.append(tmp_ir[i,0])\n g.peak_list_y.append(tmp_ir[i,1])\n print(g.peak_list_x)\n g.canvas_list[0].plot_peaks()\n g.exp_peaks = np.zeros((len(g.peak_list_x),2))\n g.exp_peaks[:,0] = np.asarray(g.peak_list_x)\n g.exp_peaks[:,1] = np.asarray(g.peak_list_y)\n for peak in g.peak_list_x:\n g.peak_list_VCD_y.append(g.exp_vcd[abs(g.exp_vcd[:,0]-peak)<10e-1,1][0])\n g.canvas_list[1].plot_peaks_VCD()\n except:\n pass\n elif(self.entry == \"align\"):\n try:\n del Algo\n print(\"del\")\n except: \n pass\n Algo = Algorithm.Algorithm()\n if(g.set_VCD==False):\n g.returnvalue, g.old_freq, g.freq_new, g.inten_new = Algo.Needleman_IR()\n else:\n g.returnvalue, g.old_freq, g.freq_new, g.inten_new,g.inten_VCD_new = Algo.Needleman_IR()\n g.canvas_list[4].plot_IR_assigned()\n g.Spectrum.IR_shifted()\n if(g.set_VCD==True):\n g.Spectrum.VCD_shifted()\n p_ir,p_vcd = g.Spectrum.integrate()\n\n self.args.setText(\"Score: \" + str(g.returnvalue)[0:6]+\"\\np_ir: \" + str(p_ir)[0:4]+\"\\np_vcd: \" + str(p_vcd)[0:4]+\"\\n\")\n else:\n p_ir = g.Spectrum.integrate()\n self.args.setText(\"Score: \" + str(g.returnvalue)[0:6]+\"\\np_ir: \" + str(p_ir)[0:4]+\"\\n\")\n g.canvas_list[5].plot_IR_shifted()\nclass Load_Button:\n def __init__(self,button,entry):\n self.button = button\n self.entry = entry\n self.button.clicked.connect(self.click)\n def click(self):\n if(self.entry == \"experimental IR\"):\n try:\n fileName, _ = QtWidgets.QFileDialog.getOpenFileName(None,\"Select \"+self.entry +\" Spectrum\",\"\",\"\")\n g.exp_ir = np.loadtxt(fileName,usecols=(0,1))\n g.exp_ir = g.exp_ir[g.exp_ir[:,0].argsort()]\n g.canvas_list[0].plot_IR()\n g.set_IR = True\n except:\n pass\n elif(self.entry == \"experimental VCD\"):\n try:\n fileName, _ = QtWidgets.QFileDialog.getOpenFileName(None,\"Select \"+self.entry +\" Spectrum\",\"\",\"\")\n g.exp_vcd = np.loadtxt(fileName,usecols=(0,1,))\n g.exp_vcd = g.exp_vcd[g.exp_vcd[:,0].argsort()]\n g.canvas_list[1].plot_VCD()\n g.set_VCD = True\n except:\n pass\n elif(self.entry == \"energies\"):\n fileName_energy, _ = QtWidgets.QFileDialog.getOpenFileName(None,\"Select \"+self.entry +\" Energies\",\"\",\"\")\n g.E = pickle.load(open(fileName_energy,\"rb\"))\n elif(self.entry == \"theoretical IR\"):\n fileName_IR, _ = QtWidgets.QFileDialog.getOpenFileName(None,\"Select \"+self.entry +\" Spectrum\",\"\",\"\")\n g.theo_ir = pickle.load(open(fileName_IR,\"rb\"))\n g.Spectrum.Boltzmann_weight_IR()\n g.canvas_list[2].plot_IR_theo()\n elif(self.entry == \"theoretical VCD\"):\n try:\n fileName_VCD, _ = QtWidgets.QFileDialog.getOpenFileName(None,\"Select \"+self.entry +\" Spectrum\",\"\",\"\")\n g.theo_vcd = pickle.load(open(fileName_VCD,\"rb\"))\n g.Spectrum.Boltzmann_weight_VCD()\n g.canvas_list[3].plot_VCD_theo()\n except:\n pass\nclass Canvas(FigureCanvas):\n def __init__(self, single = None, parent = None, Button = None, dpi = 100):\n height = parent.height()/100.\n width = parent.width()/100.\n fig = Figure(figsize=(width, height), dpi=dpi)\n FigureCanvas.__init__(self, fig)\n self.setParent(parent)\n self.ax = self.figure.add_subplot(111)\n #Button\n def change_x(self):\n self.ax.set_xlim(g.values[\"lb\"],g.values[\"hb\"])\n self.draw()\n def plot_IR(self):\n self.delete()\n self.ax.plot(g.exp_ir[:,0],g.exp_ir[:,1],color=\"black\")\n self.ax.set_ylim(0,1.05)\n self.ax.set_xlim(g.values[\"lb\"],g.values[\"hb\"])\n self.draw()\n def plot_IR_shifted(self):\n self.delete()\n self.ax.plot(g.exp_ir[:,0],g.exp_ir[:,1],color=\"black\")\n self.ax.plot(g.IR_shifted[:,0],g.IR_shifted[:,1],color=\"red\")\n if(g.set_VCD==True):\n self.ax.plot(g.exp_vcd[:,0],g.exp_vcd[:,1],\"--\",color=\"black\")\n self.ax.plot(g.VCD_shifted[:,0],g.VCD_shifted[:,1],\"--\",color=\"red\")\n self.ax.set_ylim(-1.05,1.05)\n self.ax.set_xlim(g.values[\"lb\"],g.values[\"hb\"])\n self.draw()\n def plot_peaks(self):\n self.delete()\n self.ax.plot(g.exp_ir[:,0],g.exp_ir[:,1],color=\"black\")\n self.ax.set_ylim(0,1.05)\n self.ax.set_xlim(g.values[\"lb\"],g.values[\"hb\"])\n self.ax.plot(g.peak_list_x,g.peak_list_y,\"o\",color=\"blue\")\n self.draw()\n def plot_peaks_VCD(self):\n self.delete()\n self.ax.plot(g.exp_vcd[:,0],g.exp_vcd[:,1],\"--\",color=\"black\")\n self.ax.plot(g.peak_list_x,g.peak_list_VCD_y,\"o\",color=\"blue\")\n self.ax.set_ylim(-1.05,1.05)\n self.ax.set_xlim(g.values[\"lb\"],g.values[\"hb\"])\n self.draw()\n def delete(self):\n try:\n while(len(self.ax.lines)>0):\n self.ax.lines[-1].remove()\n except:\n pass\n def plot_VCD(self):\n self.delete()\n self.ax.plot(g.exp_vcd[:,0],g.exp_vcd[:,1],\"--\",color=\"black\")\n self.ax.set_ylim(-1,1)\n self.ax.set_xlim(g.values[\"lb\"],g.values[\"hb\"])\n self.draw()\n def plot_IR_theo(self):\n self.delete()\n self.ax.plot(g.spectrum_boltzmann[:,0],g.spectrum_boltzmann[:,1],color=\"red\") ##x_axis 0..2000\n self.ax.set_ylim(0,1)\n self.ax.set_xlim(g.values[\"lb\"],g.values[\"hb\"])\n tmp_ir = g.spectrum_boltzmann[g.values[\"lb\"]:g.values[\"hb\"]]\n g.theo_peaks_x = []\n g.theo_peaks_y = []\n for i in range(1,len(tmp_ir)-1):\n if(tmp_ir[i-1,1]<=tmp_ir[i,1]>=tmp_ir[i+1,1]):\n g.theo_peaks_x.append(tmp_ir[i,0])\n g.theo_peaks_y.append(tmp_ir[i,1])\n self.ax.plot(g.theo_peaks_x,g.theo_peaks_y,\"o\",color=\"blue\")\n g.theo_peaks = np.zeros((len(g.theo_peaks_x),2))\n g.theo_peaks[:,0] = np.asarray(g.theo_peaks_x)\n g.theo_peaks[:,1] = np.asarray(g.theo_peaks_y)\n self.draw()\n def plot_IR_assigned(self):\n self.delete()\n #g.returnvalue, g.old_freq, g.freq, g.inten\n self.ax.plot(g.spectrum_boltzmann[:,0],g.spectrum_boltzmann[:,1],color=\"red\") ##x_axis 0..2000\n self.ax.plot(g.exp_ir[:,0],g.exp_ir[:,1],color=\"black\")\n if(g.set_VCD==True):\n self.ax.plot(g.exp_vcd[:,0],g.exp_vcd[:,1],\"--\",color=\"black\")\n self.ax.plot(g.spectrum_boltzmann_vcd[:,0],g.spectrum_boltzmann_vcd[:,1],\"--\",color=\"red\")\n for i in range(len(g.old_freq)):\n self.ax.plot([g.old_freq[i],g.freq_new[i]],[g.inten_new[i],g.inten_new[i]],color=\"blue\")\n self.ax.set_ylim(-1,1)\n self.ax.set_xlim(g.values[\"lb\"],g.values[\"hb\"])\n tmp_ir = g.spectrum_boltzmann[g.values[\"lb\"]:g.values[\"hb\"]]\n\n self.draw()\n def plot_VCD_theo(self):\n self.delete()\n self.ax.plot(g.spectrum_boltzmann_vcd[:,0],g.spectrum_boltzmann_vcd[:,1],\"--\",color=\"red\") ##x_axis 0..2000\n tmp_vcd = g.spectrum_boltzmann_vcd[g.values[\"lb\"]:g.values[\"hb\"]]\n self.ax.set_ylim(-1,1)\n g.peak_list_VCD_y_theo = []\n for peak in g.theo_peaks_x:\n g.peak_list_VCD_y_theo.append(tmp_vcd[np.abs(tmp_vcd[:,0]-peak)<10e-3,1][0])\n self.ax.plot(g.theo_peaks_x,g.peak_list_VCD_y_theo,\"o\",color=\"blue\")\n self.ax.set_xlim(g.values[\"lb\"],g.values[\"hb\"])\n self.draw()\nif __name__ == \"__main__\":\n import sys\n app = QtWidgets.QApplication(sys.argv)\n MainWindow = QtWidgets.QMainWindow()\n ui = gui.Ui_MainWindow()\n ui.setupUi(MainWindow)\n g.Spectrum = Spectrum.Spectrum()\n g.canvas_list = []\n g.canvas_list.append(Canvas(parent = ui.exp_ir_graph))\n g.canvas_list.append(Canvas(parent = ui.exp_vcd_graph))\n g.canvas_list.append(Canvas(parent = ui.theo_ir_graph))\n g.canvas_list.append(Canvas(parent = ui.theo_vcd_graph))\n g.canvas_list.append(Canvas(parent = ui.assignment_graph))\n g.canvas_list.append(Canvas(parent = ui.shifted_graph))\n g.list_buttons = []\n g.list_buttons.append(Button(ui.w,\"w\"))\n g.list_buttons.append(Button(ui.lb,\"lb\"))\n g.list_buttons.append(Button(ui.hb,\"hb\"))\n g.list_buttons.append(Button(ui.sigma_1,\"s0\"))\n g.list_buttons.append(Button(ui.sigma_2,\"s1\"))\n g.list_buttons.append(Button(ui.mu,\"mu\"))\n g.list_buttons.append(Button(ui.cutoff,\"c\"))\n g.list_buttons.append(Button(ui.temperature,\"T\"))\n\n g.list_buttons.append(Load_Button(ui.Load_EXP,\"experimental IR\"))\n g.list_buttons.append(Load_Button(ui.Load_EXP_VCD,\"experimental VCD\"))\n g.list_buttons.append(Load_Button(ui.load_theo_exp,\"theoretical IR\"))\n g.list_buttons.append(Load_Button(ui.load_theo_vcd,\"theoretical VCD\"))\n g.list_buttons.append(Load_Button(ui.load_theo_exp_2,\"energies\"))\n #g.list_buttons.append(Load_Button(ui.load_theo_vcd,\"theoretical VCD\"))\n\n\n g.list_buttons.append(Click_Button(ui.normalize_1,\"normalize_1\"))\n g.list_buttons.append(Click_Button(ui.normalize_2,\"normalize_2\"))\n g.list_buttons.append(Click_Button(ui.automatic,\"automatic\"))\n g.list_buttons.append(Click_Button(ui.align,\"align\",args = ui.results))\n\n MainWindow.show()\n sys.exit(app.exec_())\n", "meta": {"hexsha": "468441901994e3205b9c3479d30d445579b1fa9c", "size": 12842, "ext": "py", "lang": "Python", "max_stars_repo_path": "GUI/Gui.py", "max_stars_repo_name": "Lennard94/IRSA", "max_stars_repo_head_hexsha": "67dc6162f993de99289606740ed6b5d7402df0c2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "GUI/Gui.py", "max_issues_repo_name": "Lennard94/IRSA", "max_issues_repo_head_hexsha": "67dc6162f993de99289606740ed6b5d7402df0c2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "GUI/Gui.py", "max_forks_repo_name": "Lennard94/IRSA", "max_forks_repo_head_hexsha": "67dc6162f993de99289606740ed6b5d7402df0c2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.6802721088, "max_line_length": 133, "alphanum_fraction": 0.5692259773, "include": true, "reason": "import numpy", "num_tokens": 3359, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5544704649604274, "lm_q2_score": 0.35577488668296436, "lm_q1q2_score": 0.19726666684034663}} {"text": "\"\"\"\nMolecule generation and representation for generating theoretical spectre\n\"\"\"\nimport json\nimport os\nfrom bisect import (\n bisect_left,\n bisect_right,\n)\nfrom typing import (\n List,\n Optional,\n)\n\nimport IsoSpecPy as iso\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport typer # pylint: disable=C0411\nfrom molmass import Formula\nfrom scipy.interpolate import interp1d\nfrom scipy.spatial import (\n ckdtree,\n distance,\n)\n\nfrom msaris.utils.distributions_util import generate_gauss_distribution\nfrom msaris.utils.intensities_util import (\n get_spectrum_by_close_values,\n norm,\n)\nfrom msaris.utils.molecule_utils import convert_into_formula_for_plot\n\n\nclass Molecule: # pylint: disable=R0902\n \"\"\"\n Molecule generation and saving for performing molecule search\n \"\"\"\n\n def __init__(self, *, formula: str = \"\", delta: float = 0.5):\n self.formula = formula # saving for using to refer\n self.brutto = self._get_brutto() if formula else None\n self.mass_out: List = []\n self.intens_out: List = []\n self.mz: np.array = np.array([])\n self.it: np.array = np.array([])\n self.bar_raw = np.array([])\n self.averaged_mass: float = 0.0\n self.delta: float = delta\n\n def _get_brutto(self) -> str:\n \"\"\"\n Generating brutto formula from provided one\n\n :returns: brutto formula\n \"\"\"\n f = Formula(self.formula)\n return \"\".join(map(lambda x: f\"{x[0]}{x[1]}\", f.composition()))\n\n def _get_bar_isotope(self):\n \"\"\"\n Generating raw bar isotope pattern\n :return:\n \"\"\"\n non_zero = np.argwhere(np.array(self.intens_out) > 0)\n self.bar_raw = self.intens_out.copy()\n for ind in non_zero:\n left = bisect_left(self.mass_out, self.mass_out[ind] - self.delta)\n right = bisect_right(\n self.mass_out, self.mass_out[ind] + self.delta\n )\n self.bar_raw[left:right] = self.intens_out[ind]\n\n def calculate(\n self, *, resolution: int = 20, ppm: int = 50, scale: bool = False\n ) -> None:\n \"\"\"\n\n :param resolution: generating m/z and intensities for provided formula\n :return: None\n \"\"\"\n scaling: np.array\n\n try:\n sp = iso.IsoTotalProb(formula=self.brutto, prob_to_cover=0.99999)\n except ValueError:\n raise ValueError(f\"Invalid {self.formula}\")\n\n for mass, prob in sp:\n prob *= 100.0\n self.mass_out += [mass]\n self.intens_out += [prob]\n\n self.mz, self.it, self.averaged_mass = generate_gauss_distribution(\n self.mass_out, self.intens_out, ppm=ppm, resolution=resolution\n )\n\n if scale:\n scaling = 100 / max(self.it)\n else:\n scaling = max(self.intens_out) / max(self.it)\n # scaling resulting curve\n self.it = self.it * scaling\n\n def plot(\n self,\n *,\n save: bool = False,\n path: str = \"./\",\n name: Optional[str] = None,\n ) -> None:\n \"\"\"\n Plot spectra\n\n :param save: bool value to save image of spectra\n :param path: path to save image\n :param name: name format\n\n :return: None\n \"\"\"\n # TODO: change to be more flexible for output params\n plt.rcParams[\"figure.figsize\"] = (30, 30)\n # plot settings\n fig, (ax_spiketrain, ax_filtered) = plt.subplots(2, 1, sharex=True)\n ax_spiketrain.tick_params(axis=\"x\", labelbottom=True, rotation=-90)\n ax_spiketrain.tick_params(axis=\"both\")\n # tick parameters\n plt.xticks(\n np.arange(\n int(min(self.mass_out)) - 1, int(max(self.mass_out)) + 2, 1.0\n ),\n rotation=-90,\n )\n markerline, stemlines, baseline = ax_spiketrain.stem(\n self.mass_out,\n self.intens_out,\n use_line_collection=\"True\",\n linefmt=\"grey\",\n markerfmt=\"D\",\n basefmt=\"k-\",\n bottom=0,\n )\n markerline.set_markerfacecolor(\"none\")\n plt.setp(stemlines, \"linewidth\", 0.9)\n plt.setp(markerline, \"linewidth\", 0.8)\n plt.setp(baseline, \"linewidth\", 0.9)\n ax_spiketrain.set_title(\"Original spike train from IsoSpec data\")\n ax_spiketrain.set_ylabel(\"Relative intensity, %\")\n ax_spiketrain.set_xlabel(\"Mass, Da\")\n\n ax_filtered.plot(self.mz, self.it, color=\"blue\", lw=1.2)\n # axes labels\n ax_filtered.set_title(\"Gaussian-filtered predicted spectra\")\n ax_filtered.set_ylabel(\"Relative intensity, %\")\n ax_filtered.set_xlabel(\"Mass, Da\")\n plt.rcParams.update({\"font.size\": 30})\n\n if save:\n name = f\"{path}{name}.png\" if name else f\"{path}{self.formula}.png\"\n fig.savefig(name, dpi=300, format=\"png\", bbox_inches=\"tight\")\n\n plt.show()\n plt.close()\n\n def to_dict(self) -> dict:\n \"\"\"\n Present result in dict format\n :return: dictionary of the main parameters\n \"\"\"\n return {\n \"formula\": self.formula,\n \"brutto\": self.brutto,\n \"mz\": self.mz.tolist(),\n \"it\": self.it.tolist(),\n \"mass_out\": self.mass_out,\n \"intens_out\": self.intens_out,\n \"averaged_mass\": self.averaged_mass,\n }\n\n def to_json(self, path: str = \"./\", name: Optional[str] = None) -> None:\n \"\"\"\n Saves the molecule's to json\n\n :param path: string default save to place where executed\n :param name: redifine name default is formula with .mol format\n :return: None\n \"\"\"\n\n if not os.path.isdir(path):\n os.makedirs(path)\n\n name = f\"{self.formula}.json\" if name is None else f\"{name}.json\"\n if not path.endswith(\"/\"):\n path = f\"{path}/\"\n\n with open(f\"{path}{name}\", \"w\") as outfile:\n json.dump(self.to_dict(), outfile)\n\n typer.echo(f\"✨ JSON with was created: {os.path.abspath(path)}{name} ✨\")\n\n def read_dict_data(self, data: dict) -> None:\n \"\"\"\n Gets Molecule from dictionary representation of molecule\n\n :param data: data in dictionary format\n :return: None\n \"\"\"\n for field, value in data.items():\n if field in (\"mz\", \"it\"):\n value = np.array(value)\n setattr(self, field, value)\n\n def load(self, file_path: str) -> None:\n \"\"\"\n Load file in JSON format\n\n :param: Path to load data\n :return: None\n \"\"\"\n with open(file_path, \"r\") as file:\n self.read_dict_data(json.load(file))\n\n def __str__(self) -> str:\n return self.formula\n\n def __repr__(self) -> str:\n return (\n f\"\"\n )\n\n def compare(self, experimental: tuple) -> dict:\n\n \"\"\"\n Function to perform calculations for the theoretical and experimental spectrum\n Based on interpolation selected peaks are recalculated to the same mz_t value\n\n :param experimental: m/z and it of experimantal data\n\n :return: calculated metrics for the selected spectras\n \"\"\"\n metrics: dict = {}\n mz_t, it_t = self.mz.copy(), self.it.copy()\n mz_e, it_e = experimental\n it_t = norm(it_t)\n it_e = norm(it_e)\n\n interpol_t = interp1d(\n mz_t, norm(it_t), bounds_error=False, fill_value=(0, 0)\n )\n interpol_e = interp1d(\n mz_e, norm(it_e), bounds_error=False, fill_value=(0, 0)\n )\n theory = interpol_t(mz_e) * 100\n exp = interpol_e(mz_e) * 100\n\n metrics[\"cosine\"] = distance.cosine(theory, exp)\n # TODO: improve and add other statistics calculations\n return metrics\n\n\ndef plot_graph_for_comparing_molecules(\n mz: np.array,\n it: np.array,\n formula: str,\n *,\n save: bool = False,\n path: str = \"./\",\n step: float = 0.5,\n font: int = 18,\n):\n \"\"\"\n Provides plot with comparing stats with original spectrum\n :param mz: original spectrum m/z values\n :param it: original spectrum intensity\n :param formula: formula to find in original spectrum\n :param save: save plot into provided path\n :param path: path to save plot\n :param step: parameter to tweak width of the spectrum\n \"\"\"\n mol = Molecule(formula=formula)\n mol.calculate()\n mz, it = mz.copy(), it.copy()\n bar_mz: List = list()\n bar_it: List = list()\n visited: List = list()\n\n mz_f, it_f, _, _ = get_spectrum_by_close_values(\n mz, it, mol.mz[0], mol.mz[-1]\n )\n mpl.rcParams[\"xtick.labelsize\"] = font\n mpl.rcParams[\"ytick.labelsize\"] = font\n max_it_x_ind, max_it_t_ind = np.argmax(it_f), np.argmax(mol.it)\n m_x, it_max_x, m_t, _ = (\n mz_f[max_it_x_ind],\n it_f[max_it_x_ind],\n mol.mz[max_it_t_ind],\n mol.it[max_it_t_ind],\n )\n tree = ckdtree.cKDTree(np.array([mol.mz, mol.mz]).T)\n for _, val in enumerate(mol.mass_out):\n inds = tree.query_ball_point((val, val), step)\n S1, S2 = set(inds), set(visited)\n if S1.intersection(S2):\n continue\n visited.extend(inds)\n bar_mz.append(np.mean(mol.mz[inds]))\n bar_it.append(np.mean(mol.it[inds]))\n\n delta_b = m_x - m_t\n spectrum = (\n mz_f,\n it_f,\n )\n stats = {\n \"delta\": abs(delta_b),\n \"metrics\": mol.compare(spectrum),\n \"relative\": max(it_f) / max(it),\n }\n _, ax = plt.subplots(1, 1, figsize=(15, 5))\n ax.bar(\n bar_mz,\n (bar_it / max(bar_it)) * 100,\n width=step,\n align=\"center\",\n alpha=1,\n color=\"r\",\n )\n ax.plot(\n spectrum[0],\n (spectrum[1] / it_max_x) * 100,\n color=\"black\",\n )\n plotted_formula = convert_into_formula_for_plot(formula)\n ax.set_xlabel(\"M/Z\", fontsize=20)\n ax.set_ylabel(\"Intensity\", fontsize=20)\n labels = [\n plotted_formula,\n f\"Delta m/z: {stats['delta']:.3f}\",\n f\"Cosine: {stats['metrics']['cosine']:.3f}\",\n f\"Relative: {stats['relative']:.3f}\",\n ]\n ax.text(\n 0.8,\n 0.8,\n \"\\n\".join(labels),\n color=\"black\",\n horizontalalignment=\"center\",\n verticalalignment=\"center\",\n fontsize=font,\n transform=ax.transAxes,\n )\n ax.set_title(f\"{plotted_formula}\", fontsize=20)\n if save and path:\n if not os.path.exists(path):\n os.makedirs(path)\n plt.savefig(f\"{path}/{formula}.png\", dpi=600)\n plt.show()\n plt.close()\n", "meta": {"hexsha": "4982733c04db4385d9649f5b6eeee34521ab5b90", "size": 10736, "ext": "py", "lang": "Python", "max_stars_repo_path": "msaris/molecule/molecule.py", "max_stars_repo_name": "Borschevik/msaris", "max_stars_repo_head_hexsha": "a12722441679d8246faa6028d31c3f2e51e58665", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "msaris/molecule/molecule.py", "max_issues_repo_name": "Borschevik/msaris", "max_issues_repo_head_hexsha": "a12722441679d8246faa6028d31c3f2e51e58665", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "msaris/molecule/molecule.py", "max_forks_repo_name": "Borschevik/msaris", "max_forks_repo_head_hexsha": "a12722441679d8246faa6028d31c3f2e51e58665", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.8222222222, "max_line_length": 86, "alphanum_fraction": 0.5751676602, "include": true, "reason": "import numpy,from scipy", "num_tokens": 2693, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5544704649604273, "lm_q2_score": 0.35577488668296436, "lm_q1q2_score": 0.19726666684034658}} {"text": "\"\"\"\n.. module:: adaptive_sampling\n :synopsis: Ways of finding the next point to evaluate in the adaptive phase\n\n.. moduleauthor:: David Eriksson ,\n David Bindel \n\n:Module: adaptive_sampling\n:Author: David Eriksson ,\n David Bindel \n\n\"\"\"\n\nimport math\nimport scipy.stats as stats\nfrom merit_functions import *\nimport types\n\n\ndef __fix_docs(cls):\n \"\"\"Help function for stealing docs from the parent\"\"\"\n for name, func in vars(cls).items():\n if isinstance(func, types.FunctionType) and not func.__doc__:\n for parent in cls.__bases__:\n parfunc = getattr(parent, name, None)\n if parfunc and getattr(parfunc, '__doc__', None):\n func.__doc__ = parfunc.__doc__\n break\n return cls\n\n\n\nclass CandidateSRBF(object):\n \"\"\"An implementation of Stochastic RBF\n\n This is an implementation of the candidate points method that is\n proposed in the first SRBF paper. Candidate points are generated\n by making normally distributed perturbations with standard\n deviation sigma around the best solution. The candidate point that\n minimizes a specified merit function is selected as the next\n point to evaluate.\n\n :param data: Optimization problem object\n :type data: Object\n :param numcand: Number of candidate points to be used. Default is min([5000, 100*data.dim])\n :type numcand: int\n :param weights: Weights used for the merit function, to balance exploration vs exploitation\n :type weights: list of numpy.array\n\n :raise ValueError: If number of candidate points is\n incorrect or if the weights aren't a list in [0, 1]\n\n :ivar data: Optimization problem object\n :ivar fhat: Response surface object\n :ivar xrange: Variable ranges, xup - xlow\n :ivar dtol: Smallest allowed distance between evaluated points 1e-3 * sqrt(dim)\n :ivar weights: Weights used for the merit function\n :ivar proposed_points: List of points proposed to the optimization algorithm\n :ivar dmerit: Minimum distance between the points and the proposed points\n :ivar xcand: Candidate points\n :ivar fhvals: Predicted values by the surrogate model\n :ivar next_weight: Index of the next weight to be used\n :ivar numcand: Number of candidate points\n :ivar budget: Remaining evaluation budget\n\n .. note:: This object needs to be initialized with the init method. This is done when the\n initial phase has finished.\n\n .. todo:: Get rid of the proposed_points object and replace it by something that is\n controlled by the strategy.\n \"\"\"\n\n def __init__(self, data, numcand=None, weights=None):\n self.data = data\n self.fhat = None\n self.xrange = self.data.xup - self.data.xlow\n self.dtol = 1e-3 * math.sqrt(data.dim)\n self.weights = weights\n if self.weights is None:\n self.weights = [0.3, 0.5, 0.8, 0.95]\n self.proposed_points = None\n self.dmerit = None\n self.xcand = None\n self.fhvals = None\n self.next_weight = 0\n self.numcand = numcand\n if self.numcand is None:\n self.numcand = min([5000, 100*data.dim])\n self.budget = None\n\n # Check that the inputs make sense\n if not(isinstance(self.numcand, int) and self.numcand > 0):\n raise ValueError(\"The number of candidate points has to be a positive integer\")\n if not((isinstance(self.weights, np.ndarray) or isinstance(self.weights, list))\n and max(self.weights) <= 1 and min(self.weights) >= 0):\n raise ValueError(\"Incorrect weights\")\n\n def init(self, start_sample, fhat, budget):\n \"\"\"Initialize the sampling method after the initial phase\n\n This initializes the list of sampling methods after the initial phase\n has finished and the experimental design has been evaluated. The user\n provides the points in the experimental design, the surrogate model,\n and the remaining evaluation budget.\n\n :param start_sample: Points in the experimental design\n :type start_sample: numpy.array\n :param fhat: Surrogate model\n :type fhat: Object\n :param budget: Evaluation budget\n :type budget: int\n \"\"\"\n\n self.proposed_points = start_sample\n self.budget = budget\n self.fhat = fhat\n\n def remove_point(self, x):\n \"\"\"Remove x from proposed_points\n\n This removes x from the list of proposed points in the case where the optimization\n strategy decides to not evaluate x.\n\n :param x: Point to be removed\n :type x: numpy.array\n :return: True if points was removed, False otherwise\n :type: bool\n \"\"\"\n\n idx = np.sum(np.abs(self.proposed_points - x), axis=1).argmin()\n if np.sum(np.abs(self.proposed_points[idx, :] - x)) < 1e-10:\n self.proposed_points = np.delete(self.proposed_points, idx, axis=0)\n return True\n return False\n\n def __generate_cand__(self, scalefactors, xbest, subset):\n self.xcand = np.ones((self.numcand, self.data.dim)) * xbest\n for i in subset:\n lower, upper = self.data.xlow[i], self.data.xup[i]\n ssigma = scalefactors[i]\n self.xcand[:, i] = stats.truncnorm.rvs(\n (lower - xbest[i]) / ssigma, (upper - xbest[i]) / ssigma,\n loc=xbest[i], scale=ssigma, size=self.numcand)\n\n def make_points(self, npts, xbest, sigma, subset=None, proj_fun=None,\n merit=candidate_merit_weighted_distance):\n \"\"\"Proposes npts new points to evaluate\n\n :param npts: Number of points to select\n :type npts: int\n :param xbest: Best solution found so far\n :type xbest: numpy.array\n :param sigma: Current sampling radius w.r.t the unit box\n :type sigma: float\n :param subset: Coordinates to perturb, the others are fixed\n :type subset: numpy.array\n :param proj_fun: Routine for projecting infeasible points onto the feasible region\n :type proj_fun: Object\n :param merit: Merit function for selecting candidate points\n :type merit: Object\n\n :return: Points selected for evaluation, of size npts x dim\n :rtype: numpy.array\n\n .. todo:: Change the merit function from being hard-coded\n \"\"\"\n\n if subset is None:\n subset = np.arange(0, self.data.dim)\n scalefactors = sigma * self.xrange\n\n # Make sure that the scale factors are correct for\n # the integer variables (at least 1)\n ind = np.intersect1d(self.data.integer, subset)\n if len(ind) > 0:\n scalefactors[ind] = np.maximum(scalefactors[ind], 1.0)\n\n # Generate candidate points\n self.__generate_cand__(scalefactors, xbest, subset)\n if proj_fun is not None:\n self.xcand = proj_fun(self.xcand)\n\n dists = scp.distance.cdist(self.xcand, self.proposed_points)\n fhvals = self.fhat.evals(self.xcand)\n\n self.dmerit = np.amin(np.asmatrix(dists), axis=1)\n self.fhvals = unit_rescale(fhvals)\n\n xnew = merit(self, npts)\n self.proposed_points = np.vstack((self.proposed_points,\n np.asmatrix(xnew)))\n return xnew\n\n\n@__fix_docs\nclass CandidateDYCORS(CandidateSRBF):\n \"\"\"An implementation of the DYCORS method\n\n The DYCORS method only perturbs a subset of the dimensions when\n perturbing the best solution. The probability for a dimension\n to be perturbed decreases after each evaluation and is capped\n in order to guarantee global convergence.\n\n :param data: Optimization problem object\n :type data: Object\n :param numcand: Number of candidate points to be used. Default is min([5000, 100*data.dim])\n :type numcand: int\n :param weights: Weights used for the merit function, to balance exploration vs exploitation\n :type weights: list of numpy.array\n\n :raise ValueError: If number of candidate points is\n incorrect or if the weights aren't a list in [0, 1]\n\n :ivar data: Optimization problem object\n :ivar fhat: Response surface object\n :ivar xrange: Variable ranges, xup - xlow\n :ivar dtol: Smallest allowed distance between evaluated points 1e-3 * sqrt(dim)\n :ivar weights: Weights used for the merit function\n :ivar proposed_points: List of points proposed to the optimization algorithm\n :ivar dmerit: Minimum distance between the points and the proposed points\n :ivar xcand: Candidate points\n :ivar fhvals: Predicted values by the surrogate model\n :ivar next_weight: Index of the next weight to be used\n :ivar numcand: Number of candidate points\n :ivar budget: Remaining evaluation budget\n :ivar minprob: Smallest allowed perturbation probability\n :ivar n0: Evaluations spent when the initial phase ended\n :ivar probfun: Function that computes the perturbation probability of a given iteration\n\n .. note:: This object needs to be initialized with the init method. This is done when the\n initial phase has finished.\n\n .. todo:: Get rid of the proposed_points object and replace it by something that is\n controlled by the strategy.\n \"\"\"\n\n def __init__(self, data, numcand=None, weights=None):\n CandidateSRBF.__init__(self, data, numcand=numcand, weights=weights)\n self.minprob = np.min([1.0, 1.0/self.data.dim])\n self.n0 = None\n\n if data.dim <= 1:\n raise ValueError(\"You can't use DYCORS on a 1d problem\")\n\n def probfun(numevals, budget):\n if budget < 2:\n return 0\n return min([20.0/data.dim, 1.0]) * (1.0 - (np.log(numevals + 1.0) / np.log(budget)))\n self.probfun = probfun\n\n def init(self, start_sample, fhat, budget):\n CandidateSRBF.init(self, start_sample, fhat, budget)\n self.n0 = start_sample.shape[0]\n\n def remove_point(self, x):\n return CandidateSRBF.remove_point(self, x)\n\n def make_points(self, npts, xbest, sigma, subset=None, proj_fun=None,\n merit=candidate_merit_weighted_distance):\n return CandidateSRBF.make_points(self, npts, xbest, sigma, subset, proj_fun, merit)\n\n def __generate_cand__(self, scalefactors, xbest, subset):\n ddsprob = self.probfun(self.proposed_points.shape[0] - self.n0, self.budget - self.n0)\n ddsprob = np.max([self.minprob, ddsprob])\n\n nlen = len(subset)\n\n # Fix when nlen is 1\n # Todo: Use SRBF instead\n if nlen == 1:\n ar = np.ones((self.numcand, 1))\n else:\n ar = (np.random.rand(self.numcand, nlen) < ddsprob)\n ind = np.where(np.sum(ar, axis=1) == 0)[0]\n ar[ind, np.random.randint(0, nlen - 1, size=len(ind))] = 1\n\n self.xcand = np.ones((self.numcand, self.data.dim)) * xbest\n for i in range(nlen):\n lower, upper = self.data.xlow[i], self.data.xup[i]\n ssigma = scalefactors[subset[i]]\n ind = np.where(ar[:, i] == 1)[0]\n self.xcand[ind, subset[i]] = stats.truncnorm.rvs(\n (lower - xbest[subset[i]]) / ssigma, (upper - xbest[subset[i]]) / ssigma,\n loc=xbest[subset[i]], scale=ssigma, size=len(ind))\n\n", "meta": {"hexsha": "a9a34c1b1a0ba106d501c0f6c3a0113ad0adce30", "size": 11369, "ext": "py", "lang": "Python", "max_stars_repo_path": "dyno_pods/adaptive_sampling.py", "max_stars_repo_name": "louisXW/PODS-DYNO", "max_stars_repo_head_hexsha": "5cd3cced8f0556a5c42d9021ff1d965880f360dd", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "dyno_pods/adaptive_sampling.py", "max_issues_repo_name": "louisXW/PODS-DYNO", "max_issues_repo_head_hexsha": "5cd3cced8f0556a5c42d9021ff1d965880f360dd", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-03-24T18:17:50.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-24T18:17:50.000Z", "max_forks_repo_path": "dyno_pods/adaptive_sampling.py", "max_forks_repo_name": "louisXW/PODS-DYNO", "max_forks_repo_head_hexsha": "5cd3cced8f0556a5c42d9021ff1d965880f360dd", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-08-01T12:57:30.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-01T12:57:30.000Z", "avg_line_length": 39.7517482517, "max_line_length": 96, "alphanum_fraction": 0.6511566541, "include": true, "reason": "import scipy", "num_tokens": 2797, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5544704649604272, "lm_q2_score": 0.35577488668296436, "lm_q1q2_score": 0.19726666684034655}} {"text": "# MINLP written by GAMS Convert at 08/13/20 17:38:08\n# \n# Equation counts\n# Total E G L N X C B\n# 53 18 0 35 0 0 0 0\n# \n# Variable counts\n# x b i s1s s2s sc si\n# Total cont binary integer sos1 sos2 scont sint\n# 96 21 75 0 0 0 0 0\n# FX 0 0 0 0 0 0 0 0\n# \n# Nonzero counts\n# Total const NL DLL\n# 306 261 45 0\n# \n# Reformulation has removed 1 variable and 1 equation\n\n\nfrom pyomo.environ import *\n\nmodel = m = ConcreteModel()\n\n\nm.b1 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b2 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b3 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b4 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b5 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b6 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b7 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b8 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b9 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b10 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b11 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b12 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b13 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b14 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b15 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b16 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b17 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b18 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b19 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b20 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b21 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b22 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b23 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b24 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b25 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b26 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b27 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b28 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b29 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b30 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b31 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b32 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b33 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b34 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b35 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b36 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b37 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b38 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b39 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b40 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b41 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b42 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b43 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b44 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b45 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b46 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b47 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b48 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b49 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b50 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b51 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b52 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b53 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b54 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b55 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b56 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b57 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b58 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b59 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b60 = Var(within=Binary,bounds=(0,1),initialize=0.2)\nm.b61 = Var(within=Binary,bounds=(0,1),initialize=0.333333333333333)\nm.b62 = Var(within=Binary,bounds=(0,1),initialize=0.333333333333333)\nm.b63 = Var(within=Binary,bounds=(0,1),initialize=0.333333333333333)\nm.b64 = Var(within=Binary,bounds=(0,1),initialize=0.333333333333333)\nm.b65 = Var(within=Binary,bounds=(0,1),initialize=0.333333333333333)\nm.b66 = Var(within=Binary,bounds=(0,1),initialize=0.333333333333333)\nm.b67 = Var(within=Binary,bounds=(0,1),initialize=0.333333333333333)\nm.b68 = Var(within=Binary,bounds=(0,1),initialize=0.333333333333333)\nm.b69 = Var(within=Binary,bounds=(0,1),initialize=0.333333333333333)\nm.b70 = Var(within=Binary,bounds=(0,1),initialize=0.333333333333333)\nm.b71 = Var(within=Binary,bounds=(0,1),initialize=0.333333333333333)\nm.b72 = Var(within=Binary,bounds=(0,1),initialize=0.333333333333333)\nm.b73 = Var(within=Binary,bounds=(0,1),initialize=0.333333333333333)\nm.b74 = Var(within=Binary,bounds=(0,1),initialize=0.333333333333333)\nm.b75 = Var(within=Binary,bounds=(0,1),initialize=0.333333333333333)\nm.x76 = Var(within=Reals,bounds=(0,None),initialize=1.18464727499703)\nm.x77 = Var(within=Reals,bounds=(0,None),initialize=2.21055142184158)\nm.x78 = Var(within=Reals,bounds=(0,None),initialize=1.19998063005095)\nm.x79 = Var(within=Reals,bounds=(0,None),initialize=1.11549458684761)\nm.x80 = Var(within=Reals,bounds=(0,None),initialize=1.13890807654545)\nm.x81 = Var(within=Reals,bounds=(0,None),initialize=0.18075340102651)\nm.x82 = Var(within=Reals,bounds=(0,None),initialize=0.18075340102651)\nm.x83 = Var(within=Reals,bounds=(0,None),initialize=0.18075340102651)\nm.x84 = Var(within=Reals,bounds=(0,None),initialize=0.229509008619004)\nm.x85 = Var(within=Reals,bounds=(0,None),initialize=0.229509008619004)\nm.x86 = Var(within=Reals,bounds=(0,None),initialize=0.229509008619004)\nm.x87 = Var(within=Reals,bounds=(0,None),initialize=0.181816847787907)\nm.x88 = Var(within=Reals,bounds=(0,None),initialize=0.181816847787907)\nm.x89 = Var(within=Reals,bounds=(0,None),initialize=0.181816847787907)\nm.x90 = Var(within=Reals,bounds=(0,None),initialize=0.175765767145396)\nm.x91 = Var(within=Reals,bounds=(0,None),initialize=0.175765767145396)\nm.x92 = Var(within=Reals,bounds=(0,None),initialize=0.175765767145396)\nm.x93 = Var(within=Reals,bounds=(0,None),initialize=0.177490575531558)\nm.x94 = Var(within=Reals,bounds=(0,None),initialize=0.177490575531558)\nm.x95 = Var(within=Reals,bounds=(0,None),initialize=0.177490575531558)\n\nm.obj = Objective(expr= 301.899928098152*m.b1 + 282.051473607022*m.b2 + 151.594044960674*m.b3 + 114.784185877557*m.b4\n + 213.364530716922*m.b5 + 772.653148294131*m.b6 + 697.676211791334*m.b7 + 146.306371684975*m.b8\n + 390.583393857486*m.b9 + 208.147527440482*m.b10 + 662.892902187869*m.b11\n + 577.461337631217*m.b12 + 221.10047354739*m.b13 + 425.919826737657*m.b14\n + 123.074770812851*m.b15 + 333.28129673946*m.b16 + 248.380746723092*m.b17\n + 249.162942146638*m.b18 + 164.598799150643*m.b19 + 280.957171099846*m.b20\n + 308.552481034871*m.b21 + 270.059605282374*m.b22 + 104.633483616243*m.b23\n + 79.6631898566695*m.b24 + 170.696237801571*m.b25 + 237.754076296143*m.b26\n + 189.862911729786*m.b27 + 107.217531395173*m.b28 + 131.358715293396*m.b29\n + 103.406777059692*m.b30 + 626.417763832299*m.b31 + 487.184730842973*m.b32\n + 502.300580630229*m.b33 + 506.426352475088*m.b34 + 463.185748318154*m.b35\n + 358.178221555384*m.b36 + 281.629247221142*m.b37 + 230.4203839171*m.b38\n + 251.915433121165*m.b39 + 209.261088879339*m.b40 + 303.899003044044*m.b41\n + 243.197489456663*m.b42 + 237.390965850675*m.b43 + 57.1385835039462*m.b44\n + 301.733744039334*m.b45 + 30.6123768510861*m.b46 + 21.3396948414106*m.b47\n + 278.520865043453*m.b48 + 162.122145724483*m.b49 + 304.508803157003*m.b50\n + 252.516206195527*m.b51 + 178.796029580139*m.b52 + 319.145634893211*m.b53\n + 257.755103285795*m.b54 + 317.996864520235*m.b55 + 936.171150833806*m.b56\n + 887.611963724196*m.b57 + 419.760722838682*m.b58 + 519.981401235063*m.b59\n + 524.621957902125*m.b60 + 326.37044675*m.b61 + 119.610927362864*m.b62 + 76.800859418795*m.b63\n + 338.15311375*m.b64 + 113.101546866718*m.b65 + 69.3762358590679*m.b66 + 313.6973235*m.b67\n + 116.266585440261*m.b68 + 75.0744657614982*m.b69 + 401.4402965*m.b70 + 138.599587312691*m.b71\n + 86.376825937843*m.b72 + 456.70672375*m.b73 + 150.554161322115*m.b74 + 91.6821859840903*m.b75\n + 93617.1150833806*m.x76 + 93617.1150833806*m.x77 + 93617.1150833806*m.x78\n + 93617.1150833806*m.x79 + 93617.1150833806*m.x80, sense=minimize)\n\nm.c2 = Constraint(expr= 0.609376132*m.b1 + 1.180016336*m.b6 + 0.967493052*m.b11 + 1.004918785*m.b16\n + 0.698898063*m.b21 + 0.540292599*m.b26 + 1.460452986*m.b31 + 0.811980791*m.b36\n + 0.973180988*m.b41 + 0.544914116*m.b46 + 0.78515855*m.b51 + 1.312281472*m.b56\n - 2.0080698912*m.x81 - 4.0161397824*m.x82 - 6.0242096736*m.x83 == 0)\n\nm.c3 = Constraint(expr= 0.609376132*m.b2 + 1.180016336*m.b7 + 0.967493052*m.b12 + 1.004918785*m.b17\n + 0.698898063*m.b22 + 0.540292599*m.b27 + 1.460452986*m.b32 + 0.811980791*m.b37\n + 0.973180988*m.b42 + 0.544914116*m.b47 + 0.78515855*m.b52 + 1.312281472*m.b57\n - 1.581486777*m.x84 - 3.162973554*m.x85 - 4.744460331*m.x86 == 0)\n\nm.c4 = Constraint(expr= 0.609376132*m.b3 + 1.180016336*m.b8 + 0.967493052*m.b13 + 1.004918785*m.b18\n + 0.698898063*m.b23 + 0.540292599*m.b28 + 1.460452986*m.b33 + 0.811980791*m.b38\n + 0.973180988*m.b43 + 0.544914116*m.b48 + 0.78515855*m.b53 + 1.312281472*m.b58\n - 1.9963246902*m.x87 - 3.9926493804*m.x88 - 5.9889740706*m.x89 == 0)\n\nm.c5 = Constraint(expr= 0.609376132*m.b4 + 1.180016336*m.b9 + 0.967493052*m.b14 + 1.004918785*m.b19\n + 0.698898063*m.b24 + 0.540292599*m.b29 + 1.460452986*m.b34 + 0.811980791*m.b39\n + 0.973180988*m.b44 + 0.544914116*m.b49 + 0.78515855*m.b54 + 1.312281472*m.b59\n - 2.065052076*m.x90 - 4.130104152*m.x91 - 6.195156228*m.x92 == 0)\n\nm.c6 = Constraint(expr= 0.609376132*m.b5 + 1.180016336*m.b10 + 0.967493052*m.b15 + 1.004918785*m.b20\n + 0.698898063*m.b25 + 0.540292599*m.b30 + 1.460452986*m.b35 + 0.811980791*m.b40\n + 0.973180988*m.b45 + 0.544914116*m.b50 + 0.78515855*m.b55 + 1.312281472*m.b60\n - 2.0449844238*m.x93 - 4.0899688476*m.x94 - 6.1349532714*m.x95 == 0)\n\nm.c7 = Constraint(expr= m.b1 + m.b2 + m.b3 + m.b4 + m.b5 == 1)\n\nm.c8 = Constraint(expr= m.b6 + m.b7 + m.b8 + m.b9 + m.b10 == 1)\n\nm.c9 = Constraint(expr= m.b11 + m.b12 + m.b13 + m.b14 + m.b15 == 1)\n\nm.c10 = Constraint(expr= m.b16 + m.b17 + m.b18 + m.b19 + m.b20 == 1)\n\nm.c11 = Constraint(expr= m.b21 + m.b22 + m.b23 + m.b24 + m.b25 == 1)\n\nm.c12 = Constraint(expr= m.b26 + m.b27 + m.b28 + m.b29 + m.b30 == 1)\n\nm.c13 = Constraint(expr= m.b31 + m.b32 + m.b33 + m.b34 + m.b35 == 1)\n\nm.c14 = Constraint(expr= m.b36 + m.b37 + m.b38 + m.b39 + m.b40 == 1)\n\nm.c15 = Constraint(expr= m.b41 + m.b42 + m.b43 + m.b44 + m.b45 == 1)\n\nm.c16 = Constraint(expr= m.b46 + m.b47 + m.b48 + m.b49 + m.b50 == 1)\n\nm.c17 = Constraint(expr= m.b51 + m.b52 + m.b53 + m.b54 + m.b55 == 1)\n\nm.c18 = Constraint(expr= m.b56 + m.b57 + m.b58 + m.b59 + m.b60 == 1)\n\nm.c19 = Constraint(expr= m.b61 + m.b62 + m.b63 <= 1)\n\nm.c20 = Constraint(expr= m.b64 + m.b65 + m.b66 <= 1)\n\nm.c21 = Constraint(expr= m.b67 + m.b68 + m.b69 <= 1)\n\nm.c22 = Constraint(expr= m.b70 + m.b71 + m.b72 <= 1)\n\nm.c23 = Constraint(expr= m.b73 + m.b74 + m.b75 <= 1)\n\nm.c24 = Constraint(expr= - m.b61 + m.x81 <= 0)\n\nm.c25 = Constraint(expr= - m.b62 + m.x82 <= 0)\n\nm.c26 = Constraint(expr= - m.b63 + m.x83 <= 0)\n\nm.c27 = Constraint(expr= - m.b64 + m.x84 <= 0)\n\nm.c28 = Constraint(expr= - m.b65 + m.x85 <= 0)\n\nm.c29 = Constraint(expr= - m.b66 + m.x86 <= 0)\n\nm.c30 = Constraint(expr= - m.b67 + m.x87 <= 0)\n\nm.c31 = Constraint(expr= - m.b68 + m.x88 <= 0)\n\nm.c32 = Constraint(expr= - m.b69 + m.x89 <= 0)\n\nm.c33 = Constraint(expr= - m.b70 + m.x90 <= 0)\n\nm.c34 = Constraint(expr= - m.b71 + m.x91 <= 0)\n\nm.c35 = Constraint(expr= - m.b72 + m.x92 <= 0)\n\nm.c36 = Constraint(expr= - m.b73 + m.x93 <= 0)\n\nm.c37 = Constraint(expr= - m.b74 + m.x94 <= 0)\n\nm.c38 = Constraint(expr= - m.b75 + m.x95 <= 0)\n\nm.c39 = Constraint(expr=m.x81*m.b61 + m.x81*m.x76 - m.x76*m.b61 <= 0)\n\nm.c40 = Constraint(expr=m.x82*m.b62 + m.x82*m.x76 - m.x76*m.b62 <= 0)\n\nm.c41 = Constraint(expr=m.x83*m.b63 + m.x83*m.x76 - m.x76*m.b63 <= 0)\n\nm.c42 = Constraint(expr=m.x84*m.b64 + m.x84*m.x77 - m.x77*m.b64 <= 0)\n\nm.c43 = Constraint(expr=m.x85*m.b65 + m.x85*m.x77 - m.x77*m.b65 <= 0)\n\nm.c44 = Constraint(expr=m.x86*m.b66 + m.x86*m.x77 - m.x77*m.b66 <= 0)\n\nm.c45 = Constraint(expr=m.x87*m.b67 + m.x87*m.x78 - m.x78*m.b67 <= 0)\n\nm.c46 = Constraint(expr=m.x88*m.b68 + m.x88*m.x78 - m.x78*m.b68 <= 0)\n\nm.c47 = Constraint(expr=m.x89*m.b69 + m.x89*m.x78 - m.x78*m.b69 <= 0)\n\nm.c48 = Constraint(expr=m.x90*m.b70 + m.x90*m.x79 - m.x79*m.b70 <= 0)\n\nm.c49 = Constraint(expr=m.x91*m.b71 + m.x91*m.x79 - m.x79*m.b71 <= 0)\n\nm.c50 = Constraint(expr=m.x92*m.b72 + m.x92*m.x79 - m.x79*m.b72 <= 0)\n\nm.c51 = Constraint(expr=m.x93*m.b73 + m.x93*m.x80 - m.x80*m.b73 <= 0)\n\nm.c52 = Constraint(expr=m.x94*m.b74 + m.x94*m.x80 - m.x80*m.b74 <= 0)\n\nm.c53 = Constraint(expr=m.x95*m.b75 + m.x95*m.x80 - m.x80*m.b75 <= 0)\n", "meta": {"hexsha": "7cfac397480461d61e2ca617c98156c48290f6f4", "size": 14023, "ext": "py", "lang": "Python", "max_stars_repo_path": "models_nonconvex_simple/sssd12-05persp.py", "max_stars_repo_name": "grossmann-group/pyomo-MINLP-benchmarking", "max_stars_repo_head_hexsha": "714f0a0dffd61675649a805683c0627af6b4929e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7, "max_stars_repo_stars_event_min_datetime": "2019-05-08T19:14:34.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-24T00:00:40.000Z", "max_issues_repo_path": "models_nonconvex_simple/sssd12-05persp.py", "max_issues_repo_name": "grossmann-group/pyomo-MINLP-benchmarking", "max_issues_repo_head_hexsha": "714f0a0dffd61675649a805683c0627af6b4929e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "models_nonconvex_simple/sssd12-05persp.py", "max_forks_repo_name": "grossmann-group/pyomo-MINLP-benchmarking", "max_forks_repo_head_hexsha": "714f0a0dffd61675649a805683c0627af6b4929e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-05-10T18:34:18.000Z", "max_forks_repo_forks_event_max_datetime": "2019-05-10T18:34:18.000Z", "avg_line_length": 52.9169811321, "max_line_length": 119, "alphanum_fraction": 0.6283962062, "include": true, "reason": "from pyomo", "num_tokens": 5479, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.5774953797290153, "lm_q2_score": 0.34158251284363395, "lm_q1q2_score": 0.19726232296342563}} {"text": "\"\"\" Layout helper functions.\n\nAuthors: Thomas Ferreira de Lima @thomaslima\n Lukas Chrostowski @lukasc-ubc\n\nThe following functions are useful for scripted layout, or making\nPDK Pcells.\n\nFunctions:\n\nlayout_waveguide2\nlayout_waveguide\nlayout_waveguide_sbend_bezier\nmake_pin\ny_splitter_tree\n\nTODO: enhance documentation\nTODO: make some of the functions in util use these.\n\"\"\"\n\nfrom itertools import repeat\nimport pya\nimport numpy as np\nfrom numpy import cos, sin, pi, sqrt\nfrom functools import reduce\nfrom .sampling import sample_function\nfrom .geometry import rotate90, rotate, bezier_optimal, curve_length\n\n'''\nCreate a waveguide, in a specific technology\ninputs\n- cell: into which Cell we add the waveguide\n- dpath: DPath type\n- waveguide_type: a name from Waveguides.XML\n can be a \n or a primitive waveguide type containing info\noutput\n- compound waveguide, or regular waveguide\nby Lukas Chrostowski\nacknowledgements: Diedrik Vermeulen for the code to place the taper in the correct orientation\n'''\ndef layout_waveguide4(cell, dpath, waveguide_type, debug=True):\n\n \n if debug:\n print ('SiEPIC.utils.layout.layout_waveguide4: ' )\n print (' - waveguide_type: %s' % (waveguide_type) )\n\n # get the path and clean it up\n layout = cell.layout()\n dbu = layout.dbu\n dpath = dpath.to_itype(dbu)\n dpath.unique_points()\n pts = dpath.get_points()\n dpts = dpath.get_dpoints()\n\n # Load the technology and all waveguide types\n from SiEPIC.utils import load_Waveguides_by_Tech\n technology_name = layout.technology_name\n waveguide_types = load_Waveguides_by_Tech(technology_name) \n if debug:\n print (' - technology_name: %s' % (technology_name) )\n print (' - waveguide_types: %s' % (waveguide_types) )\n\n # Load parameters for the chosen waveguide type\n params = [t for t in waveguide_types if t['name'] == waveguide_type]\n if type(params) == type([]) and len(params)>0:\n params = params[0]\n else:\n print('error: waveguide type not found in PDK waveguides')\n raise Exception('error: waveguide type (%s) not found in PDK waveguides' % waveguide_type)\n\n # compound waveguide types:\n if 'compound_waveguide' in params:\n # find the singlemode and multimode waveguides:\n if 'singlemode' in params['compound_waveguide']:\n singlemode = params['compound_waveguide']['singlemode']\n else:\n raise Exception('error: waveguide type (%s) does not have singlemode defined' % waveguide_type)\n if 'multimode' in params['compound_waveguide']:\n multimode = params['compound_waveguide']['multimode']\n else:\n raise Exception('error: waveguide type (%s) does not have multimode defined' % waveguide_type)\n params_singlemode = [t for t in waveguide_types if t['name'] == singlemode]\n params_multimode = [t for t in waveguide_types if t['name'] == multimode]\n if type(params_singlemode) == type([]) and len(params_singlemode)>0:\n params_singlemode = params_singlemode[0]\n else:\n raise Exception('error: waveguide type (%s) not found in PDK waveguides' % singlemode)\n if type(params_multimode) == type([]) and len(params_multimode)>0:\n params_multimode = params_multimode[0]\n else:\n raise Exception('error: waveguide type (%s) not found in PDK waveguides' % multimode)\n # find the taper\n if 'taper_library' in params['compound_waveguide'] and 'taper_cell' in params['compound_waveguide']:\n taper = layout.create_cell(params['compound_waveguide']['taper_cell'], params['compound_waveguide']['taper_library'])\n if not taper:\n raise Exception ('Cannot import cell %s : %s' % (params['compound_waveguide']['taper_cell'], params['compound_waveguide']['taper_library']))\n else:\n raise Exception('error: waveguide type (%s) does not have taper cell and library defined' % waveguide_type)\n from pya import Trans, CellInstArray\n\n '''\n find sections of waveguides that are larger than (2 x radius + 2 x taper_length)\n - insert two tapers\n - insert multimode straight section\n - insert singlemode waveguides (including bends) before\n '''\n import math\n from SiEPIC.extend import to_itype\n from pya import Point\n radius = to_itype(params_singlemode['radius'],dbu)\n taper_length = taper.find_pins()[0].center.distance(taper.find_pins()[1].center)\n min_length = 2*radius + 2*taper_length\n offset = radius\n wg_sm_segment_pts = []\n wg_last=0\n waveguide_length = 0\n for ii in range(1,len(dpts)):\n start_point = dpts[ii-1]\n end_point = dpts[ii]\n distance_points = end_point.distance(start_point)\n if distance_points < min_length:\n # single mode segment, keep track\n if ii==1:\n wg_sm_segment_pts.append(pts[ii-1])\n wg_sm_segment_pts.append(pts[ii])\n if ii==len(pts)-1:\n subcell = layout.create_cell(\"Waveguide_sm_%s\" %ii)\n cell.insert(CellInstArray(subcell.cell_index(), Trans()))\n waveguide_length += layout_waveguide3(subcell, wg_sm_segment_pts, params_singlemode, debug=True)\n else:\n # insert two tapers and multimode waveguide\n angle = math.atan2((end_point.y-start_point.y),(end_point.x-start_point.x))/math.pi*180\n if ii==1:\n wg_first=offset\n else:\n wg_first=0\n if ii==len(pts)-1:\n wg_last=offset\n if round(angle)%360 == 270.0:\n t = Trans(Trans.R270, start_point.x, start_point.y-offset+wg_first)\n t2 = Trans(Trans.R90, end_point.x, end_point.y+offset-wg_last)\n wg_start_pt = Point(start_point.x, start_point.y-offset-taper_length+wg_first)\n wg_end_pt = Point(end_point.x, end_point.y+offset+taper_length-wg_last)\n if round(angle)%360 == 90.0:\n t = Trans(Trans.R90, start_point.x, start_point.y+offset-wg_first)\n t2 = Trans(Trans.R270, end_point.x, end_point.y-offset+wg_last)\n wg_start_pt = Point(start_point.x, start_point.y+offset+taper_length-wg_first)\n wg_end_pt = Point(end_point.x, end_point.y-offset-taper_length+wg_last)\n if round(angle)%360 == 180.0:\n t = Trans(Trans.R180, start_point.x-offset+wg_first, start_point.y)\n t2 = Trans(Trans.R0, end_point.x+offset-wg_last, end_point.y)\n wg_start_pt = Point(start_point.x-offset-taper_length+wg_first, start_point.y)\n wg_end_pt = Point(end_point.x+offset+taper_length-wg_last, end_point.y)\n if round(angle)%360 == 0.0:\n t = Trans(Trans.R0, start_point.x+offset-wg_first, start_point.y)\n t2 = Trans(Trans.R180, end_point.x-offset+wg_last, end_point.y)\n wg_start_pt = Point(start_point.x+offset+taper_length-wg_first, start_point.y)\n wg_end_pt = Point(end_point.x-offset-taper_length+wg_last, end_point.y)\n inst_taper = cell.insert(CellInstArray(taper.cell_index(), t))\n inst_taper = cell.insert(CellInstArray(taper.cell_index(), t2))\n waveguide_length += taper_length*2\n subcell = layout.create_cell(\"Waveguide_mm_%s\" %ii)\n cell.insert(CellInstArray(subcell.cell_index(), Trans()))\n waveguide_length += layout_waveguide3(subcell, [wg_start_pt, wg_end_pt], params_multimode, debug=True)\n # compound segment\n if ii>1:\n wg_sm_segment_pts.append(t.disp.to_p())\n subcell = layout.create_cell(\"Waveguide_sm_%s\" %ii)\n cell.insert(CellInstArray(subcell.cell_index(), Trans()))\n waveguide_length += layout_waveguide3(subcell, wg_sm_segment_pts, params_singlemode, debug=True)\n wg_sm_segment_pts = [t2.disp.to_p(), pts[ii]]\n else:\n wg_sm_segment_pts = [t2.disp.to_p(), pts[ii]]\n \n else:\n # primitive waveguide type\n waveguide_length = layout_waveguide3(cell, pts, params, debug=True)\n\n return waveguide_length\n\n'''\nCreate a waveguide, in a specific technology\ninputs\n- cell: into which Cell we add the waveguide\n from SiEPIC.utils import get_layout_variables\n TECHNOLOGY, lv, layout, cell = get_layout_variables()\n- pts\n- params, obtained from load_Waveguides_by_Tech and Waveguides.XML\n must be a primitive waveguide type containing info\noutput:\n- waveguide\n- DevRec, PinRec\nby Lukas Chrostowski\n'''\ndef layout_waveguide3(cell, pts, params, debug=True):\n\n if debug:\n print ('SiEPIC.utils.layout.layout_waveguide3: ' )\n\n layout = cell.layout()\n dbu = layout.dbu\n technology_name = layout.technology_name\n from SiEPIC.utils import get_technology_by_name\n TECHNOLOGY = get_technology_by_name(technology_name)\n\n from SiEPIC.extend import to_itype\n wg_width = to_itype(params['width'],dbu)\n radius = float(params['radius'])\n model = params['model']\n cellName = 'Waveguide2'\n CML = params['CML']\n \n if debug:\n print (' - waveguide params: %s' % (params) )\n\n if 'compound_waveguide' in params: \n print('error: this function cannot handle compound waveguides')\n raise Exception('error: this function cannot handle compound waveguides (%s)' % waveguide_type)\n \n # draw the waveguide\n waveguide_length = layout_waveguide2(TECHNOLOGY, layout, cell, [wg['layer'] for wg in params['component']], [wg['width'] for wg in params['component']], [wg['offset'] for wg in params['component']], pts, radius, params['adiabatic'], params['bezier'])\n\n # Draw the marking layers\n from SiEPIC.utils import angle_vector\n LayerPinRecN = layout.layer(TECHNOLOGY['PinRec'])\n\n make_pin(cell, 'opt1', pts[0], wg_width, LayerPinRecN, angle_vector(pts[0]-pts[1])%360)\n make_pin(cell, 'opt2', pts[-1], wg_width, LayerPinRecN, angle_vector(pts[-1]-pts[-2])%360)\n\n from pya import Trans, Text, Path, Point \n\n '''\n t1 = Trans(angle_vector(pts[0]-pts[1])/90, False, pts[0])\n cell.shapes(LayerPinRecN).insert(Path([Point(-10, 0), Point(10, 0)], wg_width).transformed(t1))\n cell.shapes(LayerPinRecN).insert(Text(\"opt1\", t1, 0.3/dbu, -1))\n \n t = Trans(angle_vector(pts[-1]-pts[-2])/90, False, pts[-1])\n cell.shapes(LayerPinRecN).insert(Path([Point(-10, 0), Point(10, 0)], wg_width).transformed(t))\n cell.shapes(LayerPinRecN).insert(Text(\"opt2\", t, 0.3/dbu, -1))\n '''\n \t\n LayerDevRecN = layout.layer(TECHNOLOGY['DevRec'])\n \n # Compact model information\n angle_vec = angle_vector(pts[0]-pts[1])/90\n halign = 0 # left\n angle=0\n dpt = Point(0,0)\n if angle_vec == 0: # horizontal\n halign = 2 # right\n angle=0\n dpt = Point(0, 0.2*wg_width)\n if angle_vec == 2: # horizontal\n halign = 0 # left\n angle = 0\n dpt=Point(0, 0.2*wg_width)\n if angle_vec == 1: # vertical\n halign = 2 # right\n angle = 1\n dpt=Point(0.2*wg_width,0)\n if angle_vec == -1: # vertical\n halign = 0 # left\n angle = 1\n dpt=Point(0.2*wg_width,0)\n pt2=pts[0] + dpt\n pt3=pts[0] - dpt\n pt4=pts[0] - 6*dpt\n pt5=pts[0] + 2*dpt\n\n t = Trans(angle, False, pt3) \n text = Text ('Lumerical_INTERCONNECT_library=Design kits/%s' % CML, t, 0.1*wg_width, -1)\n text.halign=halign\n shape = cell.shapes(LayerDevRecN).insert(text)\n t = Trans(angle, False, pt2)\n text = Text ('Component=%s' % model, t, 0.1*wg_width, -1)\n text.halign=halign\n shape = cell.shapes(LayerDevRecN).insert(text)\n t = Trans(angle, False, pt5)\n text = Text ('cellName=%s' % cellName, t, 0.1*wg_width, -1)\n text.halign=halign\n shape = cell.shapes(LayerDevRecN).insert(text)\n t = Trans(angle, False, pts[0])\n pts_txt = str([ [round(p.to_dtype(dbu).x,3), round(p.to_dtype(dbu).y,3)] for p in pts ]).replace(', ',',')\n text = Text ( \\\n 'Spice_param:wg_length=%.9f wg_width=%.3g points=\"%s\" radius=%.3g' %\\\n (waveguide_length*1e-6, wg_width*1e-9, pts_txt,radius*1e-6 ), t, 0.1*wg_width, -1 )\n text.halign=halign\n shape = cell.shapes(LayerDevRecN).insert(text)\n t = Trans(angle, False, pt4)\n text = Text ( \\\n 'Length=%.3f (microns)' %(waveguide_length), t, 0.5*wg_width, -1 )\n text.halign=halign\n shape = cell.shapes(LayerDevRecN).insert(text)\n \n return waveguide_length\n\n'''\nCreate a waveguide, in a specific technology\ninputs\n- TECHNOLOGY, layout, cell:\n from SiEPIC.utils import get_layout_variables\n TECHNOLOGY, lv, layout, cell = get_layout_variables()\n- layers: list of text names, e.g., ['Waveguide']\n- widths: list of floats in units Microns, e.g., [0.50]\n- offsets: list of floats in units Microns, e.g., [0]\n- pts: a list of pya.Points, e.g. \n L=15/dbu\n pts = [Point(0,0), Point(L,0), Point(L,L)]\n- radius: in Microns, e.g., 5\n- adiab: 1 = Bezier curve, 0 = radial bend (arc)\n- bezier: the bezier parameter, between 0 and 0.45 (almost a radial bend)\n\nNote: bezier parameters need to be simulated and optimized, and will depend on \n wavelength, polarization, width, etc. TM and rib waveguides don't benefit from bezier curves\n most useful for TE \nby Lukas Chrostowski\n'''\ndef layout_waveguide2(TECHNOLOGY, layout, cell, layers, widths, offsets, pts, radius, adiab, bezier):\n from SiEPIC.utils import arc_xy, arc_bezier, angle_vector, angle_b_vectors, inner_angle_b_vectors, translate_from_normal\n from SiEPIC.extend import to_itype\n from pya import Path, Polygon, Trans\n dbu = layout.dbu\n \n if 'Errors' in TECHNOLOGY:\n error_layer = layout.layer(TECHNOLOGY['Errors'])\n else: \n error_layer = None\n \n width=widths[0]\n turn=0\n waveguide_length = 0\n for lr in range(0, len(layers)):\n wg_pts = [pts[0]]\n layer = layout.layer(TECHNOLOGY[layers[lr]])\n width = to_itype(widths[lr],dbu)\n offset = to_itype(offsets[lr],dbu)\n for i in range(1,len(pts)-1):\n turn = ((angle_b_vectors(pts[i]-pts[i-1],pts[i+1]-pts[i])+90)%360-90)/90\n dis1 = pts[i].distance(pts[i-1])\n dis2 = pts[i].distance(pts[i+1])\n angle = angle_vector(pts[i]-pts[i-1])/90\n pt_radius = to_itype(radius,dbu)\n error_seg1 = False\n error_seg2 = False\n # determine the radius, based on how much space is available\n if len(pts)==3:\n # simple corner, limit radius by the two edges\n if dis1 < pt_radius:\n error_seg1 = True\n if dis2 < pt_radius:\n error_seg2 = True\n pt_radius = min (dis1, dis2, pt_radius)\n else:\n if i==1:\n # first corner, limit radius by first edge, or 1/2 of second one\n if dis1 < pt_radius:\n error_seg1 = True\n if dis2/2 < pt_radius:\n error_seg2 = True\n pt_radius = min (dis1, dis2/2, pt_radius)\n elif i==len(pts)-2:\n # last corner, limit radius by second edge, or 1/2 of first one\n if dis1/2 < pt_radius:\n error_seg1 = True\n if dis2 < pt_radius:\n error_seg2 = True\n pt_radius = min (dis1/2, dis2, pt_radius)\n else:\n if dis1/2 < pt_radius:\n error_seg1 = True\n if dis2/2 < pt_radius:\n error_seg2 = True\n pt_radius = min (dis1/2, dis2/2, pt_radius)\n\n if error_seg1 or error_seg2:\n if not error_layer:\n # we have an error, but no Error layer\n print('- SiEPIC:layout_waveguide2: missing Error layer')\n elif layer == layout.layer(TECHNOLOGY['Waveguide']): # and pt_radius < to_itype(radius,dbu):\n # add an error polygon to flag the incorrect bend \n if error_seg1:\n error_pts = pya.Path([pts[i-1], pts[i]], width)\n cell.shapes(error_layer).insert(error_pts)\n if error_seg2:\n error_pts = pya.Path([pts[i], pts[i+1]], width)\n cell.shapes(error_layer).insert(error_pts)\n # error_pts = pya.Path([pts[i-1], pts[i], pts[i+1]], width)\n # cell.shapes(error_layer).insert(error_pts)\n # waveguide bends:\n if abs(turn)==1:\n if(adiab):\n wg_pts += Path(arc_bezier(pt_radius, 270, 270 + inner_angle_b_vectors(pts[i-1]-pts[i], pts[i+1]-pts[i]), float(bezier), DevRec='DevRec' in layers[lr]), 0).transformed(Trans(angle, turn < 0, pts[i])).get_points()\n else:\n wg_pts += Path(arc_xy(-pt_radius, pt_radius, pt_radius, 270, 270 + inner_angle_b_vectors(pts[i-1]-pts[i], pts[i+1]-pts[i]),DevRec='DevRec' in layers[lr]), 0).transformed(Trans(angle, turn < 0, pts[i])).get_points()\n \n wg_pts += [pts[-1]]\n wg_pts = pya.Path(wg_pts, 0).unique_points().get_points()\n wg_polygon = Polygon(translate_from_normal(wg_pts, width/2 + (offset if turn > 0 else - offset))+translate_from_normal(wg_pts, -width/2 + (offset if turn > 0 else - offset))[::-1])\n cell.shapes(layer).insert(wg_polygon)\n \n if layout.layer(TECHNOLOGY['Waveguide']) == layer:\n waveguide_length = wg_polygon.area() / width * dbu\n\n return waveguide_length\n\n\ndef layout_waveguide(cell, layer, points_list, width):\n \"\"\" Lays out a waveguide (or trace) with a certain width with along given points.\n\n This is very useful for laying out Bezier curves with or without adiabatic tapers.\n\n Args:\n cell: cell to place into\n layer: layer to place into. It is done with cell.shapes(layer).insert(pya.Polygon)\n points_list: list of pya.DPoint (at least 2 points)\n width (microns): constant or list. If list, then it has to have the same length as points\n\n \"\"\"\n if len(points_list) < 2:\n raise NotImplemented(\"ERROR: points_list too short\")\n return\n\n if type(width)==type(0.0):\n width_iterator = repeat(width)\n points_iterator = iter(points_list)\n else:\n try:\n if len(width) == len(points_list):\n width_iterator = iter(width)\n else:\n width_iterator = repeat(width[0])\n except TypeError:\n width_iterator = repeat(width)\n finally:\n points_iterator = iter(points_list)\n\n dbu = cell.layout().dbu\n\n points_low = list()\n points_high = list()\n\n def norm(self):\n return sqrt(self.x**2 + self.y**2)\n\n def cos_angle(point1, point2):\n return point1 * point2 / norm(point1) / norm(point2)\n\n point_width_list = list(zip(points_iterator, width_iterator))\n N = len(point_width_list)\n\n first_point, first_width = point_width_list[0]\n next_point, next_width = point_width_list[1]\n\n delta = next_point - first_point\n theta = np.arctan2(delta.y, delta.x)\n first_high_point = first_point + 0.5 * first_width * \\\n pya.DPoint(cos(theta + pi / 2), sin(theta + pi / 2))\n first_low_point = first_point + 0.5 * first_width * \\\n pya.DPoint(cos(theta - pi / 2), sin(theta - pi / 2))\n points_high.append(first_high_point)\n points_low.append(first_low_point)\n\n for i in range(1, N - 1):\n prev_point, prev_width = point_width_list[i - 1]\n point, width = point_width_list[i]\n next_point, next_width = point_width_list[i + 1]\n\n delta_prev = point - prev_point\n delta_next = next_point - point\n theta_prev = np.arctan2(delta_prev.y, delta_prev.x)\n theta_next = np.arctan2(delta_next.y, delta_next.x)\n\n next_point_high = (next_point + 0.5 * next_width *\n pya.DPoint(cos(theta_next + pi / 2), sin(theta_next + pi / 2)))\n next_point_low = (next_point + 0.5 * next_width *\n pya.DPoint(cos(theta_next - pi / 2), sin(theta_next - pi / 2)))\n\n forward_point_high = (point + 0.5 * width *\n pya.DPoint(cos(theta_next + pi / 2), sin(theta_next + pi / 2)))\n forward_point_low = (point + 0.5 * width *\n pya.DPoint(cos(theta_next - pi / 2), sin(theta_next - pi / 2)))\n\n prev_point_high = (prev_point + 0.5 * prev_width *\n pya.DPoint(cos(theta_prev + pi / 2), sin(theta_prev + pi / 2)))\n prev_point_low = (prev_point + 0.5 * prev_width *\n pya.DPoint(cos(theta_prev - pi / 2), sin(theta_prev - pi / 2)))\n\n backward_point_high = (point + 0.5 * width *\n pya.DPoint(cos(theta_prev + pi / 2), sin(theta_prev + pi / 2)))\n backward_point_low = (point + 0.5 * width *\n pya.DPoint(cos(theta_prev - pi / 2), sin(theta_prev - pi / 2)))\n\n # High point decision\n next_high_edge = pya.DEdge(forward_point_high, next_point_high)\n prev_high_edge = pya.DEdge(backward_point_high, prev_point_high)\n\n if next_high_edge.crossed_by(prev_high_edge):\n intersect_point = next_high_edge.crossing_point(prev_high_edge)\n points_high.append(intersect_point)\n else:\n if width * (1 - cos_angle(delta_next, delta_prev)) > dbu:\n points_high.append(backward_point_high)\n points_high.append(forward_point_high)\n else:\n points_high.append((backward_point_high + forward_point_high) * 0.5)\n\n # Low point decision\n next_low_edge = pya.DEdge(forward_point_low, next_point_low)\n prev_low_edge = pya.DEdge(backward_point_low, prev_point_low)\n\n if next_low_edge.crossed_by(prev_low_edge):\n intersect_point = next_low_edge.crossing_point(prev_low_edge)\n points_low.append(intersect_point)\n else:\n if width * (1 - cos_angle(delta_next, delta_prev)) > dbu:\n points_low.append(backward_point_low)\n points_low.append(forward_point_low)\n else:\n points_low.append((backward_point_low + forward_point_low) * 0.5)\n\n last_point, last_width = point_width_list[-1]\n point, width = point_width_list[-2]\n delta = last_point - point\n theta = np.arctan2(delta.y, delta.x)\n final_high_point = last_point + 0.5 * last_width * \\\n pya.DPoint(cos(theta + pi / 2), sin(theta + pi / 2))\n final_low_point = last_point + 0.5 * last_width * \\\n pya.DPoint(cos(theta - pi / 2), sin(theta - pi / 2))\n if (final_high_point - points_high[-1]) * delta > 0:\n points_high.append(final_high_point)\n if (final_low_point - points_low[-1]) * delta > 0:\n points_low.append(final_low_point)\n\n # Append point only if change in direction is less than 120 degrees.\n def smooth_append(point_list, point):\n if point_list is None:\n print(point)\n if len(point_list) < 1:\n point_list.append(point)\n return point_list\n elif len(point_list) < 2:\n curr_edge = point - point_list[-1]\n if norm(curr_edge) > dbu:\n point_list.append(point)\n return point_list\n\n curr_edge = point - point_list[-1]\n if norm(curr_edge) > dbu:\n prev_edge = point_list[-1] - point_list[-2]\n if cos_angle(curr_edge, prev_edge) > cos(120 / 180 * pi):\n point_list.append(point)\n return point_list\n\n polygon_points = points_low + list(reversed(points_high))\n polygon_points = list(reduce(smooth_append, polygon_points, list()))\n\n poly = pya.DPolygon(polygon_points)\n cell.shapes(layer).insert(poly)\n\n\ndef layout_ring(cell, layer, center, r, w):\n # function to produce the layout of a ring\n # cell: layout cell to place the layout\n # layer: which layer to use\n # center: origin DPoint\n # r: radius\n # w: waveguide width\n # units in microns\n\n # example usage. Places the ring layout in the presently selected cell.\n # cell = pya.Application.instance().main_window().current_view().active_cellview().cell\n # layout_ring(cell, cell.layout().layer(LayerInfo(1, 0)), pya.DPoint(0,0), 10, 0.5)\n\n layout_arc(cell, layer, center, r, w, 0, 2 * np.pi)\n\n\ndef layout_arc(cell, layer, center, r, w, theta_start, theta_end, ex=None):\n # function to produce the layout of an arc\n # cell: layout cell to place the layout\n # layer: which layer to use\n # center: origin DPoint\n # r: radius\n # w: waveguide width\n # theta_start, theta_end: angle in radians\n # units in microns\n\n # example usage. Places the ring layout in the presently selected cell.\n # cell = pya.Application.instance().main_window().current_view().active_cellview().cell\n # layout_arc(cell, layer, pya.DPoint(0,0), 10, 0.5, 0, np.pi/2)\n\n # fetch the database parameters\n\n if ex is None:\n ex = pya.DPoint(1, 0)\n\n delta_theta = np.arctan2(ex.y, ex.x)\n theta_start += delta_theta\n theta_end += delta_theta\n\n # optimal sampling\n arc_function = lambda t: np.array([center.x + r * np.cos(t), center.y + r * np.sin(t)])\n t, coords = sample_function(arc_function,\n [theta_start, theta_end], tol=0.002 / r)\n\n # # This yields a better polygon\n coords = np.insert(coords, 0, arc_function(theta_start - 0.001),\n axis=1) # start the waveguide a little bit before\n coords = np.append(coords, np.atleast_2d(arc_function(theta_end + 0.001)).T,\n axis=1) # finish the waveguide a little bit after\n\n layout_waveguide(cell, layer, [pya.DPoint(x, y) for x, y in zip(*coords)], w)\n\n\ndef layout_arc_drc_exclude(cell, drc_layer, center, r, w, theta_start, theta_end, ex=None):\n corner_points = [center + (r + w / 2) * rotate(ex, theta_start),\n center + (r - w / 2) * rotate(ex, theta_start),\n center + (r + w / 2) * rotate(ex, theta_end),\n center + (r - w / 2) * rotate(ex, theta_end)]\n for corner_point in corner_points:\n layout_square(cell, drc_layer, corner_point, 0.1, ex)\n\n\ndef layout_arc_with_drc_exclude(cell, layer, drc_layer, center, r, w, theta_start, theta_end, ex=None):\n layout_arc(cell, layer, center, r, w, theta_start, theta_end, ex)\n layout_arc_drc_exclude(cell, drc_layer, center, r, w, theta_start, theta_end, ex)\n\n\ndef layout_circle(cell, layer, center, r):\n # function to produce the layout of a filled circle\n # cell: layout cell to place the layout\n # layer: which layer to use\n # center: origin DPoint\n # r: radius\n # w: waveguide width\n # theta_start, theta_end: angle in radians\n # units in microns\n # optimal sampling\n\n arc_function = lambda t: np.array([center.x + r * np.cos(t), center.y + r * np.sin(t)])\n t, coords = sample_function(arc_function,\n [0, 2 * np.pi - 0.001], tol=0.002 / r)\n\n dbu = cell.layout().dbu\n dpoly = pya.DPolygon([pya.DPoint(x, y) for x, y in zip(*coords)])\n cell.shapes(layer).insert(dpoly.to_itype(dbu))\n\n\ndef layout_path(cell, layer, point_iterator, w):\n path = pya.DPath(list(point_iterator), w, 0, 0).to_itype(cell.layout().dbu)\n cell.shapes(layer).insert(pya.Path.from_dpath(path))\n\n\ndef layout_path_with_ends(cell, layer, point_iterator, w):\n dpath = pya.DPath(list(point_iterator), w, w / 2, w / 2)\n cell.shapes(layer).insert(dpath)\n\n\ndef box_dpolygon(point1, point3, ex=None):\n # position point2 to the right of point1\n if ex is None:\n ex = pya.DPoint(1, 0)\n ey = rotate90(ex)\n point2 = point1 * ex * ex + point3 * ey * ey\n point4 = point3 * ex * ex + point1 * ey * ey\n\n return pya.DPolygon([point1, point2, point3, point4])\n\n\ndef square_dpolygon(center, width, ex=None):\n # returns the polygon of a square centered at center,\n # aligned with ex, with width in microns\n if ex is None:\n ex = pya.DPoint(1, 0)\n ey = rotate90(ex)\n quadrant = (width / 2) * (ex + ey)\n point1 = center + quadrant\n quadrant = rotate90(quadrant)\n point2 = center + quadrant\n quadrant = rotate90(quadrant)\n point3 = center + quadrant\n quadrant = rotate90(quadrant)\n point4 = center + quadrant\n\n return pya.DPolygon([point1, point2, point3, point4])\n\n\ndef layout_square(cell, layer, center, width, ex=None):\n \"\"\" Lays out a square in the DRC layer\n\n Args:\n center: pya.DPoint (um units)\n width: float (um units)\n ex: orientation\n\n \"\"\"\n\n if ex is None:\n ex = pya.DPoint(1, 0)\n\n square = square_dpolygon(center, width, ex)\n cell.shapes(layer).insert(square)\n\ndef layout_taper(cell, layer, trans, w1, w2, length, insert = True):\n \"\"\" Lays out a taper\n\n Args:\n trans: pya.Trans: location and rotation\n w1: width of waveguide, float for DPoint type (microns); int for Point type (nm)\n w2: width of waveguide, float for DPoint type (microns); int for Point type (nm)\n length: length, float\n insert: flag to insert drawn waveguide or return shape, boolean\n\n \"\"\"\n import pya\n if type(w1)==type(float()):\n pts = [pya.DPoint(0,-w1/2), pya.DPoint(0,w1/2), pya.DPoint(length,w2/2), pya.DPoint(length,-w2/2)]\n shape_taper = pya.DPolygon(pts).transformed(trans)\n else:\n pts = [pya.Point(0,-w1/2), pya.Point(0,w1/2), pya.Point(length,w2/2), pya.Point(length,-w2/2)]\n shape_taper = pya.Polygon(pts).transformed(trans)\n \n if insert == True:\n cell.shapes(layer).insert(shape_taper)\n else:\n return shape_taper\n\ndef layout_waveguide_sbend_bezier(cell, layer, trans, w=0.5, wo=None, h=2.0, length=15.0, insert = True):\n \"\"\" Creates a waveguide s-bend using a bezier curve\n Author: Lukas Chrostowski\n Args:\n trans: pya.Trans: location and rotation\n w: width of input waveguide, float for DPoint type (microns); int for Point type (nm)\n wo (optional): width of output waveguide, float\n h: height\n length: length\n insert: flag to insert drawn waveguide or return shape, boolean\n Usage:\n from SiEPIC.utils import get_layout_variables\n TECHNOLOGY, lv, ly, cell = get_layout_variables()\n layer = cell.layout().layer(TECHNOLOGY['Waveguide'])\n layout_waveguide_sbend_bezier(cell, layer, pya.Trans(), w=0.5, h=2.0, length=15.0, insert = True)\n \"\"\"\n \n if wo==None:\n wo = w\n \n from SiEPIC.utils.geometry import bezier_parallel, translate_from_normal2\n from pya import DPoint, DPolygon, Point, Polygon\n\n if type(w)==type(int()):\n dbu = cell.layout().dbu\n w=w*dbu\n wo=wo*dbu\n h=h*dbu\n length=length*dbu\n trans=trans.to_dtype(dbu)\n \n p = bezier_parallel(DPoint(0,0), DPoint(length,h), 0)\n\n pt1 = translate_from_normal2(p,w/2,wo/2)\n pt2 = translate_from_normal2(p,-w/2, -wo/2)\n pt = pt1+pt2[::-1]\n \n poly = pya.DPolygon(pt)\n print(poly)\n poly_t = poly.transformed(trans)\n if insert == True:\n cell.shapes(layer).insert(poly_t)\n return poly_t.area()/((w+wo)/2)\n else:\n return poly_t\n \n\ndef layout_waveguide_sbend(cell, layer, trans, w=500, r=25000, h=2000, length=15000, insert = True):\n \"\"\" Lays out an s-bend\n\n Args:\n trans: pya.Trans: location and rotation\n w: width of waveguide, int\n r: radius, int\n h: height, int\n length: length, int\n insert: flag to insert drawn waveguide or return shape, boolean\n\n \"\"\"\n\n from math import pi, cos, sin, log, sqrt, acos\n from SiEPIC.utils import points_per_circle\n import pya\n \n theta = acos(float(r-abs(h/2))/r)*180/pi\n x = int(2*r*sin(theta/180.0*pi))\n straight_l = int( (length - x)/2 )\n\n if (straight_l < 0):\n # Problem: target length is too short. increase\n print('SBend, too short: straight_l = %s' % straight_l)\n length = x\n straight_l = 0\n\n # waveguide_length = (2*pi*r*(2*theta/360.0)+straight_l*2)\n \n\n # define the cell origin as the left side of the waveguide sbend\n\n if (straight_l >= 0):\n circle_fraction = abs(theta) / 360.0\n npoints = int(points_per_circle(r*cell.layout().dbu) * circle_fraction)\n if npoints == 0:\n npoints = 1\n da = 2 * pi / npoints * circle_fraction # increment, in radians\n x1=straight_l\n x2=length-straight_l\n\n if h>0:\n y1=r\n theta_start1 = 270\n y2=h-r\n theta_start2 = 90\n pts = []\n th1 = theta_start1 / 360.0 * 2 * pi\n th2 = theta_start2 / 360.0 * 2 * pi\n pts.append(pya.Point.from_dpoint(pya.DPoint(0,w/2)))\n pts.append(pya.Point.from_dpoint(pya.DPoint(0,-w/2)))\n for i in range(0, npoints+1): # lower left\n pts.append(pya.Point.from_dpoint(pya.DPoint((x1+(r+w/2)*cos(i*da+th1))/1, (y1+(r+w/2)*sin(i*da+th1))/1)))\n for i in range(npoints, -1, -1): # lower right\n pts.append(pya.Point.from_dpoint(pya.DPoint((x2+(r-w/2)*cos(i*da+th2))/1, (y2+(r-w/2)*sin(i*da+th2))/1)))\n pts.append(pya.Point.from_dpoint(pya.DPoint(length,h-w/2)))\n pts.append(pya.Point.from_dpoint(pya.DPoint(length,h+w/2)))\n for i in range(0, npoints+1): # upper right\n pts.append(pya.Point.from_dpoint(pya.DPoint((x2+(r+w/2)*cos(i*da+th2))/1, (y2+(r+w/2)*sin(i*da+th2))/1)))\n for i in range(npoints, -1, -1): # upper left\n pts.append(pya.Point.from_dpoint(pya.DPoint((x1+(r-w/2)*cos(i*da+th1))/1, (y1+(r-w/2)*sin(i*da+th1))/1)))\n else:\n y1=-r\n theta_start1 = 90-theta\n y2=r+h\n theta_start2 = 270-theta\n pts = []\n th1 = theta_start1 / 360.0 * 2 * pi\n th2 = theta_start2 / 360.0 * 2 * pi\n pts.append(pya.Point.from_dpoint(pya.DPoint(length,h-w/2)))\n pts.append(pya.Point.from_dpoint(pya.DPoint(length,h+w/2)))\n for i in range(npoints, -1, -1): # upper right\n pts.append(pya.Point.from_dpoint(pya.DPoint((x2+(r-w/2)*cos(i*da+th2))/1, (y2+(r-w/2)*sin(i*da+th2))/1)))\n for i in range(0, npoints+1): # upper left\n pts.append(pya.Point.from_dpoint(pya.DPoint((x1+(r+w/2)*cos(i*da+th1))/1, (y1+(r+w/2)*sin(i*da+th1))/1)))\n pts.append(pya.Point.from_dpoint(pya.DPoint(0,w/2)))\n pts.append(pya.Point.from_dpoint(pya.DPoint(0,-w/2)))\n for i in range(npoints, -1, -1): # lower left\n pts.append(pya.Point.from_dpoint(pya.DPoint((x1+(r-w/2)*cos(i*da+th1))/1, (y1+(r-w/2)*sin(i*da+th1))/1)))\n for i in range(0, npoints+1): # lower right\n pts.append(pya.Point.from_dpoint(pya.DPoint((x2+(r+w/2)*cos(i*da+th2))/1, (y2+(r+w/2)*sin(i*da+th2))/1)))\n \n shape_bend = pya.Polygon(pts).transformed(trans)\n if insert == True:\n cell.shapes(layer).insert(shape_bend)\n else:\n return shape_bend\n\n print('SBend: theta %s, x %s, straight_l %s, r %s, h %s, length %s' % (theta, x, straight_l, r, h, length) )\n return length\n\ndef append_relative(points, *relative_vectors):\n \"\"\" Appends to list of points in relative steps \"\"\"\n try:\n if len(points) > 0:\n origin = points[-1]\n except TypeError:\n raise TypeError(\"First argument must be a list of points\")\n\n for vector in relative_vectors:\n points.append(origin + vector)\n origin = points[-1]\n return points\n\n\ndef place_cell(parent_cell, cell, placement_origin, params=None, relative_to=None):\n \"\"\" Places a cell and return ports\n Args:\n parent_cell: cell to place into\n cell: cell to be placed\n placement_origin: pya.Point object to be used as origin\n relative_to: port name\n\n Returns:\n ports(dict): key:port.name, value: geometry.Port with positions relative to parent_cell's origin\n \"\"\"\n layout = parent_cell.layout()\n pcell, ports = cell.pcell(layout, params=params)\n if relative_to is not None:\n offset = next((port.position for port in ports if port.name == relative_to), None)\n placement_origin = placement_origin - offset\n parent_cell.insert(pya.CellInstArray(pcell.cell_index(),\n pya.Trans(pya.Trans.R0, placement_origin.to_itype(layout.dbu))))\n for port in ports:\n port.position += placement_origin\n\n return {port.name: port for port in ports}\n\n\ndef layout_connect_ports(cell, layer, port_from, port_to):\n\n P0 = port_from.position\n P3 = port_to.position\n angle_from = np.arctan2(port_from.direction.y, port_from.direction.x) * 180 / pi\n angle_to = np.arctan2(-port_to.direction.y, -port_to.direction.x) * 180 / pi\n\n curve = bezier_optimal(P0, P3, angle_from, angle_to)\n layout_waveguide(cell, layer, curve, [port_from.width, port_to.width])\n return curve_length(curve)\n\n\n\n\n\ndef make_pin(cell, name, center, w, layer, direction, debug=False):\n\n '''\n Makes a pin that SiEPIC-Tools will recognize\n cell: which cell to draw it in\n name: text label for the pin\n center: location, int [x,y]\n w: pin width\n layer: layout.layer() type\n direction = \n 0: right\n 90: up\n 180: left\n 270: down\n\n Units: intput can be float for microns, or int for nm\n '''\n \n from SiEPIC.extend import to_itype\n from pya import Point, DPoint\n import numpy\n dbu = cell.layout().dbu\n if type(w)==type(float()):\n w = to_itype(w,dbu)\n if debug:\n print('SiEPIC.utils.layout.make_pin: w converted to %s' %w )\n else:\n if debug:\n print('SiEPIC.utils.layout.make_pin: w %s' %w )\n# print(type(center[0]))\n if type(center) == type(Point()) or type(center) == type(DPoint()):\n center = [center.x, center.y]\n if type(center[0])==type(float()) or type(center[0])==type(numpy.float64()):\n center[0] = to_itype(center[0],dbu)\n center[1] = to_itype(center[1],dbu)\n if debug:\n print('SiEPIC.utils.layout.make_pin: center converted to %s' % (center) )\n else:\n if debug:\n print('SiEPIC.utils.layout.make_pin: center %s' % (center) )\n\n from SiEPIC._globals import PIN_LENGTH as pin_length\n\n direction = direction % 360 \n if direction not in [0, 90, 180, 270]:\n raise('error in make_pin: direction must be one of [0, 90, 180, 270]')\n\n # text label\n t = pya.Trans(pya.Trans.R0, center[0],center[1])\n text = pya.Text (name, t)\n shape = cell.shapes(layer).insert(text)\n shape.text_dsize = float(w*dbu/2)\n shape.text_valign=1\n\n if direction == 0:\n p1 = pya.Point(center[0]-pin_length/2, center[1])\n p2 = pya.Point(center[0]+pin_length/2, center[1])\n shape.text_halign=2\n if direction == 90:\n p1 = pya.Point(center[0], center[1]-pin_length/2)\n p2 = pya.Point(center[0], center[1]+pin_length/2)\n shape.text_halign=2\n shape.text_rot=1\n if direction == 180:\n p1 = pya.Point(center[0]+pin_length/2, center[1])\n p2 = pya.Point(center[0]-pin_length/2, center[1])\n shape.text_halign=3\n if direction == 270:\n p1 = pya.Point(center[0], center[1]+pin_length/2)\n p2 = pya.Point(center[0], center[1]-pin_length/2)\n shape.text_halign=3\n shape.text_rot=1\n \n pin = pya.Path([p1,p2],w)\n cell.shapes(layer).insert(pin)\n\n\n\n\ndef y_splitter_tree(cell, tree_depth=4, y_splitter_cell=\"y_splitter_1310\", library=\"SiEPICfab_Shuksan_PDK\", wg_type='Strip TE 1310 nm, w=350 nm', draw_waveguides=True):\n '''\n Create a tree of splitters\n - cell: layout cell to create the structures in\n - tree_depth: Tree depth (2^N outputs)\n - y_splitter_cell: name of the y-splitter cell\n - library: the library containing the y_splitter_cell\n - wg_type: waveguide type from WAVEGUIDES.XML\n - draw_waveguides: True draws the waveguides, False is faster for debugging\n \n Returns\n - inst_in: instance of the input cell\n - inst_out[]: array of instances of the output cells\n - cell_tree: new cell created\n This is useful for subsequent routing\n \n Limitations:\n - the design uses regular 90 degree bends, rather than S-bends.\n hence it could be made more compact\n '''\n \n from SiEPIC.scripts import connect_pins_with_waveguide\n from SiEPIC.extend import to_itype\n from math import floor\n\n # create a new sub-cell where the tree will go\n ly = cell.layout()\n tech = ly.technology().name\n cell_tree = ly.create_cell(\"y_splitter_tree\")\n\n # load the y-splitter from the library\n y_splitter = ly.create_cell(y_splitter_cell, library)\n if not y_splitter:\n raise Exception ('Cannot import cell %s:%s' % (library,y_splitter_cell))\n\n # Load waveguide information\n from SiEPIC.utils import load_Waveguides_by_Tech\n waveguides = load_Waveguides_by_Tech(tech)\n wg = [w for w in waveguides if wg_type in w['name'] ][0]\n if not wg:\n raise Exception(\"Waveguide type not defined in WAVEGUIDES.XML: %s\" %wg_type )\n return\n wg_width = to_itype(float(wg['width']), ly.dbu)\n wg_radius = to_itype(float(wg['radius']), ly.dbu)\n\n # build the tree, using measurements from the cell and waveguide parameters\n x = 0\n dx = y_splitter.bbox().width() + wg_radius*2\n # calculate the spacing for the y-splitters based on waveguide radius and 90 degree bends\n y_wg_offset = (y_splitter.pinPoint(\"opt2\").y-y_splitter.pinPoint(\"opt3\").y)\n dy = max(y_splitter.bbox().height(), wg_radius*4 + y_wg_offset)\n # intialize loop\n inst_out = []\n y0 = 0\n for i in range(0,tree_depth):\n inst = []\n y = y0\n for j in range(0, int(2**(tree_depth-i-1))):\n t = pya.Trans(pya.Trans.R0, x, y)\n inst.append(cell_tree.insert(pya.CellInstArray(y_splitter.cell_index(), t)))\n # perform waveguide routing\n if (i > 0) and draw_waveguides: \n connect_pins_with_waveguide(\n inst[j], 'opt2',\n inst_higher[j*2+1], 'opt1', waveguide_type=wg_type)\n connect_pins_with_waveguide(\n inst[j], 'opt3',\n inst_higher[j*2], 'opt1', waveguide_type=wg_type)\n y += dy\n inst_higher = inst\n if i == 0:\n inst_out = inst\n if i == tree_depth-1:\n inst_in = inst[0]\n x += -dx\n y0 = y0 + dy/2\n dy = dy * 2\n \n \n return inst_in, inst_out, cell_tree\n", "meta": {"hexsha": "3638b56b82875318d545820c7d0f192c5ba31b82", "size": 43248, "ext": "py", "lang": "Python", "max_stars_repo_path": "klayout_dot_config/python/SiEPIC/utils/layout.py", "max_stars_repo_name": "lukasc-ubc/SiEPIC-Tools", "max_stars_repo_head_hexsha": "9c3046f51dfce96c34715c66d9a903b1f883eca2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 41, "max_stars_repo_stars_event_min_datetime": "2017-12-11T22:15:43.000Z", "max_stars_repo_stars_event_max_datetime": "2020-05-11T12:35:24.000Z", "max_issues_repo_path": "klayout_dot_config/python/SiEPIC/utils/layout.py", "max_issues_repo_name": "lukasc-ubc/SiEPIC-Tools", "max_issues_repo_head_hexsha": "9c3046f51dfce96c34715c66d9a903b1f883eca2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 110, "max_issues_repo_issues_event_min_datetime": "2017-12-13T08:36:06.000Z", "max_issues_repo_issues_event_max_datetime": "2020-05-07T05:42:19.000Z", "max_forks_repo_path": "klayout_dot_config/python/SiEPIC/utils/layout.py", "max_forks_repo_name": "lukasc-ubc/SiEPIC-Tools", "max_forks_repo_head_hexsha": "9c3046f51dfce96c34715c66d9a903b1f883eca2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 24, "max_forks_repo_forks_event_min_datetime": "2018-01-04T18:34:16.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-07T03:53:47.000Z", "avg_line_length": 40.0815569972, "max_line_length": 254, "alphanum_fraction": 0.6159591195, "include": true, "reason": "import numpy,from numpy", "num_tokens": 11803, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5774953651858118, "lm_q2_score": 0.3415825128436339, "lm_q1q2_score": 0.1972623179957216}} {"text": "\"\"\"必要的工具\"\"\"\nimport numpy as np\nimport tensorflow as tf\nfrom PIL import Image\nimport keras\nimport numpy as np\nimport math\n\ndef get_new_img_size(width, height, img_min_side=600):\n \"\"\"把图片最小边resize到600\"\"\"\n if width <= height:\n f = float(img_min_side) / width\n resized_height = int(f * height)\n resized_width = int(img_min_side)\n else:\n f = float(img_min_side) / height\n resized_width = int(f * width)\n resized_height = int(img_min_side)\n\n return resized_width, resized_height\n\n\nclass BBoxUtility(object):\n def __init__(self, priors=None, overlap_threshold=0.7, ignore_threshold=0.3,\n nms_thresh=0.7, top_k=300):\n self.priors = priors\n self.num_priors = 0 if priors is None else len(priors)\n self.overlap_threshold = overlap_threshold\n self.ignore_threshold = ignore_threshold\n self._nms_thresh = nms_thresh\n self._top_k = top_k\n self.boxes = tf.placeholder(dtype='float32', shape=(None, 4))\n self.scores = tf.placeholder(dtype='float32', shape=(None,))\n self.nms = tf.image.non_max_suppression(self.boxes, self.scores,\n self._top_k,\n iou_threshold=self._nms_thresh)\n self.sess = tf.Session(config=tf.ConfigProto(device_count={'GPU': 0}))\n\n @property\n def nms_thresh(self):\n return self._nms_thresh\n\n @nms_thresh.setter\n def nms_thresh(self, value):\n self._nms_thresh = value\n self.nms = tf.image.non_max_suppression(self.boxes, self.scores,\n self._top_k,\n iou_threshold=self._nms_thresh)\n\n @property\n def top_k(self):\n return self._top_k\n\n @top_k.setter\n def top_k(self, value):\n self._top_k = value\n self.nms = tf.image.non_max_suppression(self.boxes, self.scores,\n self._top_k,\n iou_threshold=self._nms_thresh)\n\n def iou(self, box):\n \"\"\"\n box：真实框\n 计算真实框与所有先验框的IOU值\n \"\"\"\n # 计算出每个真实框与所有的先验框的iou\n # 判断真实框与先验框的重合情况\n inter_upleft = np.maximum(self.priors[:, :2], box[:2])\n inter_botright = np.minimum(self.priors[:, 2:4], box[2:])\n\n inter_wh = inter_botright - inter_upleft\n inter_wh = np.maximum(inter_wh, 0)\n inter = inter_wh[:, 0] * inter_wh[:, 1]\n # 真实框的面积\n area_true = (box[2] - box[0]) * (box[3] - box[1])\n # 先验框的面积\n area_gt = (self.priors[:, 2] - self.priors[:, 0]) * (self.priors[:, 3] - self.priors[:, 1])\n # 计算iou\n union = area_true + area_gt - inter\n\n iou = inter / union\n return iou\n\n def encode_box(self, box, return_iou=True):\n \"\"\"如果重合度超过0.7，认为可以进行调节成真实框\"\"\"\n #box为传入的真实框，计算与先验框的重合度\n iou = self.iou(box)\n encoded_box = np.zeros((self.num_priors, 4 + return_iou))\n\n # 找到每一个真实框，重合程度较高的先验框\n # 如果iou>0.7，认为可以利用这个先验框回归到真实框\n assign_mask = iou > self.overlap_threshold\n if not assign_mask.any():\n assign_mask[iou.argmax()] = True\n if return_iou:\n encoded_box[:, -1][assign_mask] = iou[assign_mask]\n\n #对真实框与先验框进行编码，计算出应该有的预测结果，用于网络回归训练\n # 找到对应的先验框\n assigned_priors = self.priors[assign_mask]\n # 逆向编码，将真实框转化为FasterRCNN预测结果的格式\n # 先计算真实框的中心与长宽\n box_center = 0.5 * (box[:2] + box[2:])\n box_wh = box[2:] - box[:2]\n # 再计算重合度较高的先验框的中心与长宽\n assigned_priors_center = 0.5 * (assigned_priors[:, :2] +\n assigned_priors[:, 2:4])\n assigned_priors_wh = (assigned_priors[:, 2:4] -\n assigned_priors[:, :2])\n\n # 逆向求取FasterRCNN应该有的预测结果\n encoded_box[:, :2][assign_mask] = box_center - assigned_priors_center\n encoded_box[:, :2][assign_mask] /= assigned_priors_wh\n encoded_box[:, :2][assign_mask] *= 4\n\n encoded_box[:, 2:4][assign_mask] = np.log(box_wh / assigned_priors_wh)\n encoded_box[:, 2:4][assign_mask] *= 4\n return encoded_box.ravel()\n\n def ignore_box(self, box):\n \"\"\"\n box:标记中真实的框\n \"\"\"\n # 获取所有先验框和真实框的重合程度\n iou = self.iou(box)\n\n ignored_box = np.zeros((self.num_priors, 1))\n\n # 找到每一个真实框，重合程度较高的先验框\n # 如果重合程度大于0.3或者小于0.7，就应该忽略这个框\n assign_mask = (iou > self.ignore_threshold) & (iou < self.overlap_threshold)\n\n if not assign_mask.any():\n assign_mask[iou.argmax()] = True\n\n #找出需要忽略的先验框\n ignored_box[:, 0][assign_mask] = iou[assign_mask]\n return ignored_box.ravel()\n\n def assign_boxes(self, boxes, anchors):\n \"\"\"计算真实框对应的先验框，与这个先验框应当有的预测结果\"\"\"\n #先求出先验框个数\n self.num_priors = len(anchors)\n self.priors = anchors\n #创建一个全0矩阵，第一维是先验框个数，第二维的前4列是先验框的位置信息，第5列代表是否包含物体\n assignment = np.zeros((self.num_priors, 4 + 1))\n\n #初始时，认为所有先验框为背景，所以第5列=0\n assignment[:, 4] = 0.0\n if len(boxes) == 0:\n return assignment\n\n # 对每一个真实框都进行iou计算，找到需要忽略的先验框\n ingored_boxes = np.apply_along_axis(self.ignore_box, 1, boxes[:, :4])\n # 取重合程度最大的先验框，并且获取这个先验框的index\n ingored_boxes = ingored_boxes.reshape(-1, self.num_priors, 1)\n # (num_priors)\n ignore_iou = ingored_boxes[:, :, 0].max(axis=0)\n # (num_priors)\n ignore_iou_mask = ignore_iou > 0\n\n #代表忽略此先验框，将ignore_iou_mask的序号下的先验框设为忽略\n assignment[:, 4][ignore_iou_mask] = -1\n\n # (n, num_priors, 5)encode_box将真实框进行编码，计算出训练使用的预测结果：即偏移信息\n encoded_boxes = np.apply_along_axis(self.encode_box, 1, boxes[:, :4])\n # 每一个真实框的编码后的值，和iou\n # (n, num_priors)\n encoded_boxes = encoded_boxes.reshape(-1, self.num_priors, 5)\n\n #由于某些先验框会与多个真实框重合，所以要找iou最大的真实框进行对应\n # 取重合程度最大的先验框，并且获取这个先验框的index\n # (num_priors)\n best_iou = encoded_boxes[:, :, -1].max(axis=0)\n # (num_priors)\n best_iou_idx = encoded_boxes[:, :, -1].argmax(axis=0)\n # (num_priors)\n best_iou_mask = best_iou > 0\n # 某个先验框它属于哪个真实框\n best_iou_idx = best_iou_idx[best_iou_mask]\n\n assign_num = len(best_iou_idx)\n # 保留重合程度最大的先验框的应该有的预测结果\n # 哪些先验框存在真实框\n encoded_boxes = encoded_boxes[:, best_iou_mask, :]\n\n assignment[:, :4][best_iou_mask] = encoded_boxes[best_iou_idx, np.arange(assign_num), :4]\n # 4代表为背景的概率，为0\n # 1为正样本，代表有物体，0为负样本，代表背景，-1代表不要的框\n assignment[:, 4][best_iou_mask] = 1\n # 通过assign_boxes我们就获得了，输入进来的这张图片，应该有的预测结果是什么样子的\n # assignment即为找到的合理先验框\n return assignment\n\n def decode_boxes(self, mbox_loc, mbox_priorbox):\n \"\"\"\n 使用边框回归公式得到调整后的框\n mbox_loc: RPN输出的先验框的调整参数\n mbox_priorbox: 传入根据特征图生成好的先验框\n \"\"\"\n # 获得先验框的宽与高\n prior_width = mbox_priorbox[:, 2] - mbox_priorbox[:, 0]\n prior_height = mbox_priorbox[:, 3] - mbox_priorbox[:, 1]\n\n # 获得先验框的中心点\n prior_center_x = 0.5 * (mbox_priorbox[:, 2] + mbox_priorbox[:, 0])\n prior_center_y = 0.5 * (mbox_priorbox[:, 3] + mbox_priorbox[:, 1])\n\n # 真实框距离先验框中心的xy轴偏移情况\n decode_bbox_center_x = mbox_loc[:, 0] * prior_width / 4\n decode_bbox_center_x += prior_center_x\n decode_bbox_center_y = mbox_loc[:, 1] * prior_height / 4\n decode_bbox_center_y += prior_center_y\n\n # 真实框的宽与高的求取\n decode_bbox_width = np.exp(mbox_loc[:, 2] / 4)\n decode_bbox_width *= prior_width\n decode_bbox_height = np.exp(mbox_loc[:, 3] / 4)\n decode_bbox_height *= prior_height\n\n # 获取真实框的左上角与右下角\n decode_bbox_xmin = decode_bbox_center_x - 0.5 * decode_bbox_width\n decode_bbox_ymin = decode_bbox_center_y - 0.5 * decode_bbox_height\n decode_bbox_xmax = decode_bbox_center_x + 0.5 * decode_bbox_width\n decode_bbox_ymax = decode_bbox_center_y + 0.5 * decode_bbox_height\n\n # 真实框的左上角与右下角进行堆叠\n decode_bbox = np.concatenate((decode_bbox_xmin[:, None],\n decode_bbox_ymin[:, None],\n decode_bbox_xmax[:, None],\n decode_bbox_ymax[:, None]), axis=-1)\n # 为方便计算，框的坐标值设置在0-1，即防止超出0与1\n decode_bbox = np.minimum(np.maximum(decode_bbox, 0.0), 1.0)\n return decode_bbox\n\n def detection_out(self, predictions, mbox_priorbox, num_classes, keep_top_k=300,confidence_threshold=0.5):\n \"\"\"\n 初步选出300个建议框\n predictions：RPN输出的结果，对每个先验框都要计算\n mbox_priorbox：传入根据特征图生成好的先验框\n \"\"\"\n\n # 网络预测的结果\n # x_class即置信度\n mbox_conf = predictions[0]\n # 先验框的调整参数\n mbox_loc = predictions[1]\n # 先验框\n mbox_priorbox = mbox_priorbox\n results = []\n # 对每一个框进行处理\n for i in range(len(mbox_loc)):\n results.append([])\n #得到调整后的框，这里是所有的框\n decode_bbox = self.decode_boxes(mbox_loc[i], mbox_priorbox)\n #选出含物体的框，并用NMS删除重叠框\n for c in range(num_classes):\n c_confs = mbox_conf[i, :, c]\n #先进行对比，如果x_class的概率大于设置的置信度，认为框里有物体\n c_confs_m = c_confs > confidence_threshold\n if len(c_confs[c_confs_m]) > 0:\n # 取出得分高于confidence_threshold的框\n boxes_to_process = decode_bbox[c_confs_m]\n # 获取我们所选出的框的置信度用于NMS\n confs_to_process = c_confs[c_confs_m]\n # 进行iou的非极大抑制，删除重叠框\n feed_dict = {self.boxes: boxes_to_process,\n self.scores: confs_to_process}\n idx = self.sess.run(self.nms, feed_dict=feed_dict)\n # 取出在非极大抑制中效果较好的内容\n good_boxes = boxes_to_process[idx]\n confs = confs_to_process[idx][:, None]\n # 将label、置信度、框的位置进行堆叠，label代表是否有物体，作用其实不大，因为置信度也可以反映\n labels = c * np.ones((len(idx), 1))\n c_pred = np.concatenate((labels, confs, good_boxes),\n axis=1)\n # 添加进result里\n results[-1].extend(c_pred)\n #将以上得到的框排序，选出前k个作为RPN的输出框，默认k=300\n if len(results[-1]) > 0:\n # 按照置信度进行排序\n results[-1] = np.array(results[-1])\n argsort = np.argsort(results[-1][:, 1])[::-1]\n results[-1] = results[-1][argsort]\n # 选出置信度最大的keep_top_k个\n results[-1] = results[-1][:keep_top_k]\n # 获得，在所有预测结果里面，置信度比较高的框\n # 另外，利用先验框和RPN的预测结果x_class,x_regr，调整到真实框（预测框）的位置\n return results\n\n def nms_for_out(self, all_labels, all_confs, all_bboxes, num_classes, nms):\n results = []\n nms_out = tf.image.non_max_suppression(self.boxes, self.scores,\n self._top_k,\n iou_threshold=nms)\n for c in range(num_classes):\n c_pred = []\n mask = all_labels == c\n if len(all_confs[mask]) > 0:\n # 取出得分高于confidence_threshold的框\n boxes_to_process = all_bboxes[mask]\n confs_to_process = all_confs[mask]\n # 进行iou的非极大抑制\n feed_dict = {self.boxes: boxes_to_process,\n self.scores: confs_to_process}\n idx = self.sess.run(nms_out, feed_dict=feed_dict)\n # 取出在非极大抑制中效果较好的内容\n good_boxes = boxes_to_process[idx]\n confs = confs_to_process[idx][:, None]\n # 将label、置信度、框的位置进行堆叠。\n labels = c * np.ones((len(idx), 1))\n c_pred = np.concatenate((labels, confs, good_boxes), axis=1)\n results.extend(c_pred)\n return results", "meta": {"hexsha": "90c5970a5e3c29de35e7fe2c74ca5e54b9d3dba6", "size": 11950, "ext": "py", "lang": "Python", "max_stars_repo_path": "net/tools.py", "max_stars_repo_name": "TangZhenchaoTZC/Keras-mask-detection", "max_stars_repo_head_hexsha": "325679d06a12a90b2552ed7d447298a23e3b9d57", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-05-26T15:13:06.000Z", "max_stars_repo_stars_event_max_datetime": "2020-05-27T02:57:27.000Z", "max_issues_repo_path": "net/tools.py", "max_issues_repo_name": "TangZhenchaoTZC/Keras-mask-detection", "max_issues_repo_head_hexsha": "325679d06a12a90b2552ed7d447298a23e3b9d57", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "net/tools.py", "max_forks_repo_name": "TangZhenchaoTZC/Keras-mask-detection", "max_forks_repo_head_hexsha": "325679d06a12a90b2552ed7d447298a23e3b9d57", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.0573248408, "max_line_length": 110, "alphanum_fraction": 0.5671129707, "include": true, "reason": "import numpy", "num_tokens": 4026, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5774953651858117, "lm_q2_score": 0.34158249943831703, "lm_q1q2_score": 0.1972623102542132}} {"text": "import numpy as np\nimport matplotlib.pyplot as plt\nfrom .GetFieldLine import GetFieldLine\n\ndef PlotFieldLineDensity(pos,Params,fig=None,maps=[1,1,0,0],Overplot=False,**kwargs):\n\t'''\n\tSimple routine to plot the modelled plasma mass density along a field line.\n\t\n\tArgs\n\t=====\n\t\tpos: 3 element ndarray containing the cartesian position to trace from in Rp.\n\t\tParams: For power law: 2-element array/list [p_eq,power].\n\t\t\t\tFor Sandhu model: 5-element array/list [n0,alpha,a,beta,mav0] (see GetSandhuParams).\n\t\tfig: Pyplot instance, useful if plotting as a subplot on a pre-existing figure, by default will create new figure.\n\t\tmaps: 4 element list containing subplot information [xmaps,ymaps,xmap,ymap] where xmaps and ymaps represent the number of subplots in the x and y directions and xmap and ymap are the specific x and y indices to plot to.\n\t\tOverplot: When set to True, this will inhibit the creation of a new subplot, fig must be supplied with a pre-existing figure, where the routine will plot over.\n\n\tKeyword Args\n\t============\n\t\tThe following keyword argument form **kwargs - they are completely \n\t\toptional and depend on which model is being used.\n\t\t\n\t\tModel\t\tkwargs\n\t\tT89\t\t\tiopt,Kp,Vx,Vy,Vz,tilt,CoordIn,CoordOut,Alt,MaxLen,DSMax,FlattenSingleTraces,Verbose\n\t\tT96\t\t\tparmod,Pdyn,SymH,By,Bz,Vx,Vy,Vz,tilt,CoordIn,CoordOut,Alt,MaxLen,DSMax,FlattenSingleTraces,Verbose\n\t\tT01\t\t\tparmod,Pdyn,SymH,By,Bz,Vx,Vy,Vz,tilt,CoordIn,CoordOut,Alt,MaxLen,DSMax,FlattenSingleTraces,Verbose\n\t\tTS05\t\tparmod,Pdyn,SymH,By,Bz,Vx,Vy,Vz,tilt,CoordIn,CoordOut,Alt,MaxLen,DSMax,FlattenSingleTraces,Verbose\n\t\tKT17\n\t\t\n\t\t\n\t\tMaxStepSize: Trace step size maximum in Rp (default = None).\n\t\tModelArgs: \tTuple containing arguments for the magnetic field models, \n\t\t\t\t\twhen set to None, a set of default parameters are used.\n\t\t\t\t\t'T89'|'T96'|'T01'|'TS05'|'T89c'|'T96c'|'T01c'|'TS05c': \n\t\t\t\t\t\tModelArgs = (Date,ut,CoordIn,CoordOut,Alt,MaxLen,DSMax,iopt,parmod,tilt,Vx,Vy,Vz)\n\t\t\t\t\t\t****NOTE****\n\t\t\t\t\t\tWhen using models 'T89'|'T96'|'T01'|'TS05' - the iopt,parmod,tilt,Vx,Vy,Vz parameters need not\n\t\t\t\t\t\tbe specified as they will be calculated automatically within the Geopack model from Omni data\n\t\t\t\t\t\tusing the Date and ut parameters\n\t\t\t\t\t\t\n\t\t\t\t\t\tTo use those parameters, add 'c' tot he model name string: 'T89c'|'T96c'|'T01c'|'TS05c'\n\t\t\t\t\t\tThen all parameters will be needed\n\t\t\t\t\t\t\n\t\t\t\t\t\t************\n\t\t\t\t\t\tDate: Date in format yyyymmdd.\n\t\t\t\t\t\tUT: Time in format hh.hh (hh + mm/60.0 + ss/3600.0).\n\t\t\t\t\t\tCoordIn: Coordinate system of input position, by default 'SM' (Solar-Magnetic), can be set to 'GSM' (Geocentric Solar Magnetospheric).\n\t\t\t\t\t\tCoordOut: Coordinate system of output positions and field vectors, by default 'SM', can be set to 'GSM'.\n\t\t\t\t\t\tAlt: Altitude to stop tracing at - default = 100km\n\t\t\t\t\t\tMaxLen: maximum number of trace steps\n\t\t\t\t\t\tDSMax: Maximum step size\n\t\t\t\t\t\tiopt: integer for controlling T89c model\n\t\t\t\t\t\tparmod: 10-element floating point array to control T96c,T01c and TS05c models,\n\t\t\t\t\t\t\t\tfor T96:\n\t\t\t\t\t\t\t\t\tparmod[0] = Pdyn (nPa)\n\t\t\t\t\t\t\t\t\tparmod[1] = Dst (nT)\n\t\t\t\t\t\t\t\t\tparmod[2] = IMF By (nT)\n\t\t\t\t\t\t\t\t\tparmod[3] = IMF Bz (nT)\n\t\t\t\t\t\t\t\tfor T01:\n\t\t\t\t\t\t\t\t\tparmod[0] = Pdyn (nPa)\n\t\t\t\t\t\t\t\t\tparmod[1] = Dst (nT)\n\t\t\t\t\t\t\t\t\tparmod[2] = IMF By (nT)\n\t\t\t\t\t\t\t\t\tparmod[3] = IMF Bz (nT)\n\t\t\t\t\t\t\t\t\tparmod[4] = G1 parameter (See Tsyganenko [2001])\n\t\t\t\t\t\t\t\t\tparmod[5] = G2 parameter (See Tsyganenko [2001])\n\t\t\t\t\t\t\t\tfor TS05:\n\t\t\t\t\t\t\t\t\tparmod[0] = Pdyn (nPa)\n\t\t\t\t\t\t\t\t\tparmod[1] = Dst (nT)\n\t\t\t\t\t\t\t\t\tparmod[2] = IMF By (nT)\n\t\t\t\t\t\t\t\t\tparmod[3] = IMF Bz (nT)\n\t\t\t\t\t\t\t\t\tparmod[4] = W1 parameter (See Tsyganenko and Sitnov [2005])\n\t\t\t\t\t\t\t\t\tparmod[5] = W2 parameter (See Tsyganenko and Sitnov [2005])\t\n\t\t\t\t\t\t\t\t\tparmod[6] = W3 parameter (See Tsyganenko and Sitnov [2005])\n\t\t\t\t\t\t\t\t\tparmod[7] = W4 parameter (See Tsyganenko and Sitnov [2005])\n\t\t\t\t\t\t\t\t\tparmod[8] = W5 parameter (See Tsyganenko and Sitnov [2005])\n\t\t\t\t\t\t\t\t\tparmod[9] = W6 parameter (See Tsyganenko and Sitnov [2005])\t\t\n\t\t\t\t\t\ttilt: Geodipole tilt angle - if set to NaN then will be calculated using Date and ut\n\t\t\t\t\t\tVx,Vy,Vz: IMF velocity components\n\t\t\t\t\tKT17:\n\t\t\t\t\t\tModelArgs = (Rsun,DistIndex,MaxLen,InitStep,MaxStepSize,LimType)\n\t\t\t\t\t\tRsun: radial distance from the Sun in AU\n\t\t\t\t\t\tDistIndex: Disturbance index (0.0 - 100.0)\n\t\t\t\t\t\tMaxLen: Maximum number of steps for trace\n\t\t\t\t\t\tInitStep: Starting step size.\n\t\t\t\t\t\tMaxStepSize: Maximum step size\n\t\t\t\t\t\tLimType: Integer value to define where to stop the field trace (default 0):\n\t\t\t\t\t\t\t0: Terminate trace at planet surface and magnetopause\n\t\t\t\t\t\t\t1: Confine to box -6 < x < 2, -4 < y < 4, -4 < z < 4\n\t\t\t\t\t\t\t2: Confine to box and terminate at planet\n\t\t\t\t\t\t\t3: Terminate trace at planet\n\t\t\t\t\t\t\t4: Trace to MP, Planet and stop at 10Rm\n\t\t\t\t\t\t\t\t\n\t\t\t\t\tKT14:\n\t\t\t\t\t\tModelArgs = (MaxLen,InitStep,MaxStep,LimType,Rsm,t1,t2)\n\t\t\t\t\t\tMaxLen: Maximum number of steps for trace\n\t\t\t\t\t\tInitStep: Starting step size.\n\t\t\t\t\t\tMaxStepSize: Maximum step size\n\t\t\t\t\t\tLimType: Integer value to define where to stop the field trace (default 0):\n\t\t\t\t\t\t\t0: Terminate trace at planet surface and magnetopause\n\t\t\t\t\t\t\t1: Confine to box -6 < x < 2, -4 < y < 4, -4 < z < 4\n\t\t\t\t\t\t\t2: Confine to box and terminate at planet\n\t\t\t\t\t\t\t3: Terminate trace at planet\n\t\t\t\t\t\t\t4: Trace to MP, Planet and stop at 10Rm\n\t\t\t\t\t\tRsm: Subsolar magnetopause radius (default=1.42).\n\t\t\t\t\t\tt1: Tail disk current strength (default=7.37).\n\t\t\t\t\t\tt2: Tail quasi-harris current sheet strength (default=2.16).\n\t\t\t\t\tDipole:\n\t\t\t\t\t\tModelArgs = [Beq]\n\t\t\t\t\t\tBeq: Megnatic field strength at equator in nT (Default=-31200.0).\n\t\tDelta: Separation between two traced field lines\n\t\tPolarization: 'none'|'toroidal'|'poloidal'\n\t\tCore: This only applies to the KT14/KT17 field, as it will include tracing to the core of the planet rather than the surface.\t\n\n\t\t\n\tReturns\n\t========\n\t\tpyplot instance\n\t\n\t'''\n\ttmp = GetFieldLine(pos,**kwargs)\n\tPolarization = kwargs.get('Polarization','none')\n\tif Polarization == 'none':\n\t\tT,s = tmp\n\telse:\n\t\tT,s,h = tmp\n\t\t\n\t\n\tBm = np.sqrt(T.Bx**2.0 + T.By**2.0 + T.Bz**2.0).astype('float32')\n\tR = np.sqrt(T.x**2.0 + T.y**2.0 + T.z**2.0)\n\tmaxR = np.float32(R.max())\n\t\n\tif np.size(Params) == 2:\n\t\tp = Params[0]*(maxR/R)**Params[1]\n\t\tlabel='$\\\\rho_{eq} = $'+'{:5.1f}'.format(Params[0])+', $m = $'+'{:3.1f}'.format(Params[1])\n\telse:\n\t\tRnorm = R/maxR\n\t\tne = Params[2]*np.exp(-0.5*((Rnorm-1.0)/0.1)**2) + Params[0]*Rnorm**(-Params[1])\n\t\tmav = Params[4]*Rnorm**(-Params[3])\n\t\tp = ne*mav\n\t\tlabel='$\\\\rho_{eq} = $'+'{:5.1f}'.format(Params[0]*Params[4])\n\t\n\tif fig is None:\n\t\tfig = plt\n\t\tfig.figure()\n\tif hasattr(fig,'Axes'):\t\n\t\tax = fig.subplot2grid((maps[1],maps[0]),(maps[3],maps[2]))\n\telse:\n\t\tprint('here')\n\t\tax = fig\n\n\t\t\t\n\tax.plot(s,p,label=label)\n\tax.legend()\n\tax.set_ylabel('$\\\\rho$ (amu cm$^{-3}$)')\n\tax.set_xlabel('$x$ (km)')\n\treturn ax\n\t\n", "meta": {"hexsha": "2a1a5862d6b96afaefcde2372ac02672a69b9de1", "size": 6778, "ext": "py", "lang": "Python", "max_stars_repo_path": "MHDWaveHarmonics/PlotFieldLineDensity.py", "max_stars_repo_name": "mattkjames7/MHDWaveHarmonics", "max_stars_repo_head_hexsha": "ac8fcc5bf9190d300774c4e114a6ec4be865f014", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-03-11T13:47:00.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-11T13:47:00.000Z", "max_issues_repo_path": "MHDWaveHarmonics/PlotFieldLineDensity.py", "max_issues_repo_name": "mattkjames7/MHDWaveHarmonics", "max_issues_repo_head_hexsha": "ac8fcc5bf9190d300774c4e114a6ec4be865f014", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "MHDWaveHarmonics/PlotFieldLineDensity.py", "max_forks_repo_name": "mattkjames7/MHDWaveHarmonics", "max_forks_repo_head_hexsha": "ac8fcc5bf9190d300774c4e114a6ec4be865f014", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.8987341772, "max_line_length": 221, "alphanum_fraction": 0.6555030983, "include": true, "reason": "import numpy", "num_tokens": 2228, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5774953651858118, "lm_q2_score": 0.341582499438317, "lm_q1q2_score": 0.1972623102542132}} {"text": "#!/usr/bin/env python3\r\nimport logging\r\nfrom enum import Enum\r\n\r\nimport numpy as np\r\n\r\n\r\nlog = logging.getLogger('LabberDriver')\r\n\r\n\r\nclass PulseType(Enum):\r\n \"\"\"Define possible qubit pulse types.\"\"\"\r\n\r\n XY = 'XY'\r\n Z = 'Z'\r\n DELAY = 'Delay'\r\n READOUT = 'Readout'\r\n NONE = 'None'\r\n\r\nclass PulseShape(Enum):\r\n \"\"\"Define possible qubit pulses shapes.\"\"\"\r\n\r\n GAUSSIAN = 'Gaussian'\r\n SQUARE = 'Square'\r\n ZBIAS = 'Z-Bias'\r\n READ_FAST = 'Read_fast'\r\n CUSTOM = 'Custom'\r\n\r\nclass Pulse(object):\r\n \"\"\"Represents physical pulses played by an AWG.\r\n\r\n Parameters\r\n ----------\r\n pulse_type : :obj:`PulseType`\r\n Pulse type (the default is PulseType.XY).\r\n shape : :obj:`PulseShape`\r\n Pulse shape (the default is PulseShape.GAUSSIAN).\r\n\r\n Attributes\r\n ----------\r\n length : float\r\n Pulse length\r\n amplitude : float\r\n Pulse amplitude.\r\n frequency : float\r\n Carrier frequency of pulse.\r\n phase : float\r\n Pulse phase.\r\n use_drag : bool\r\n If True, applies DRAG correction.\r\n drag_coefficient : float\r\n Drag coefficient.\r\n drag_detuning : float\r\n Applies a frequnecy detuning for DRAG pulses.\r\n gaussian_num_STDs : float\r\n The truncation range of Gaussian pulses,\r\n in units of standard deviations.\r\n square_rise_time : float\r\n How fast does the pulse edge rise\r\n\r\n \"\"\"\r\n\r\n def __init__(self, pulse_type=PulseType.Z, shape=PulseShape.SQUARE):\r\n\r\n # set variables\r\n self.pulse_type = pulse_type\r\n self.shape = shape\r\n\r\n self.length = 30e-9\r\n self.amplitude = 1.0\r\n self.frequency = 0.0\r\n self.phase = 0.0\r\n self.use_drag = False\r\n self.drag_coefficient = 0.0\r\n self.drag_detuning = 0.0\r\n self.gaussian_num_stds = 3.0\r\n self.square_rise_time = 2e-9\r\n\r\n\r\n def calculate_envelope(self, t,): #args will be for flux modulation on the Z-bias\r\n \"\"\"Calculate pulse envelope.\r\n\r\n Parameters\r\n ----------\r\n t : numpy array\r\n Array with time values for which to calculate the pulse envelope.\r\n\r\n Returns\r\n -------\r\n envelope : numpy array\r\n Array containing pulse envelope.\r\n\r\n \"\"\"\r\n dt = t[1] - t[0]\r\n len_pulse = len(t)\r\n envelope = np.zeros(len_pulse) #initialize envelope array\r\n\r\n if self.shape == PulseShape.SQUARE:\r\n\r\n len_edge = np.int(np.ceil(self.square_rise_time/dt)+1) #calculate length of rising edge in samples\r\n\r\n if len_pulse > 2*len_edge: #adding linear rising and falling edges to pulse if length of pulse > 2* length edge\r\n envelope[:len_edge] = np.linspace(0,1,len_edge)\r\n envelope[-len_edge:] = np.linspace(1,0,len_edge)\r\n envelope[len_edge:-len_edge] = 1\r\n\r\n else: #if length of pulse is smaller than 2*length of edge, then make an envelope with only falling and rising edges\r\n halfway_t = np.int(np.floor(len_pulse/2)) #halfway point of the pulse, in samples\r\n envelope[:halfway_t] = np.linspace(0,1, halfway_t)\r\n envelope[halfway_t:] = np.linspace(1,0, len_pulse - halfway_t) #I do len_pulse - halfway_t instead of just halfway_t if the number of samples is odd\r\n\r\n elif self.shape == PulseShape.GAUSSIAN:\r\n halfway_t = int(np.floor(len_pulse/2)) #calculate midpoint of pulse, in samples\r\n t0 = t[halfway_t] #midpoint of pulse\r\n σ = self.length/(2*self.gaussian_num_stds) #calculate σ of gaussian based on pulse length and num of std deviations we want to fit\r\n envelope = np.exp( -(t-t0)**2/(2*σ**2) )\r\n envelope = envelope - envelope.min() #make pulse start at 0\r\n envelope = envelope/envelope.max()\r\n\r\n elif self.shape == PulseShape.READ_FAST: #for readout pulses with a starting high amplitude transient region to ring-up RO resonator faster\r\n # Below I am hardcoding length of transient here to be 1/4 of pulse length, for it's shape to be Gaussian to minimize spectal leakage, and for it's amplitude to be 2.5 times larger than the steady region\r\n halfway_t = int(np.floor(len_pulse/8)) #halfway_t is midpoint of transient region, in samples\r\n t0 = t[halfway_t] #midpoint of transient region\r\n σ = (self.length/4)/(2*3) #I am harcoding 3 gaussian standard deviations here\r\n envelope[:halfway_t] = 2.5*np.exp( -(t[:halfway_t]-t0)**2/(2*σ**2) ) #the first half of the transient region is a pure Gaussian\r\n envelope[halfway_t:2*halfway_t] = 1.5*np.exp( -(t[halfway_t:2*halfway_t]-t0)**2/(2*σ**2) )\r\n envelope[halfway_t:] = envelope[halfway_t:] + np.ones(len_pulse-halfway_t) #the second region of the transient region is a down-scaled gaussian + the steady part; such that the second half of the transient smoothly converges to the steady part\r\n envelope = envelope - envelope.min()\r\n\r\n envelope = envelope * self.amplitude\r\n\r\n return envelope\r\n\r\n #if self.shape == PulseShape.ZBIAS: #Z-bias pulse consists of starting from the last Z-bias value and ramping to a new Z-bias value\r\n #len_edge = np.int(np.ceil(self.square_rise_time/dt)+1) #calculate length of rising edge in samples\r\n #if len_pulse > len_edge:\r\n # envelope[:len_edge] = np.linspace(last_value_Zbias,self.amplitude,len_edge) #make rising edge start from last Z-bias value and end at the new Z-bias level\r\n # envelope[len_edge:] = self.amplitude\r\n #else:\r\n # envelope = np.linspace(last_value_Zbias, self.amplitude, len_pulse) #if length of pulse is smaller than rising edge, make the whole Z-bias pulse a rising edge\r\n #envelope = np.ones(len_pulse) * self.amplitude + args[0] * np.cos(2*pi*args[1] * 1e6* (t-t[0]))\r\n #return envelope\r\n\r\n\r\n def calculate_waveform(self, t, IQ_ratio = 1.0, IQ_skew = 0.0, I_offset = 0.0, Q_offset = 0.0, custom_waveform = None,\r\n Z_bias_mod_amp = 0.0, Z_bias_mod_freq = 0.0): #custom waveform input is for Custom pulses\r\n \"\"\"Calculate pulse waveform including carrier frequency, phase offsets, IQ mixer compensations, and DRAG implementation\r\n\r\n Parameters\r\n ----------\r\n t : numpy array\r\n Array with time values for which to calculate the pulse waveform.\r\n\r\n Returns\r\n -------\r\n waveform : numpy array\r\n Array containing pulse waveform.\r\n\r\n \"\"\"\r\n π = np.pi\r\n if self.shape == PulseShape.CUSTOM: #make the \"envelope\" the custom waveform for a \"Custom\" Pulse\r\n envelope = custom_waveform\r\n elif self.shape == PulseShape.ZBIAS:\r\n envelope = np.ones(len(t)) * self.amplitude + Z_bias_mod_amp * np.cos(2*np.pi*Z_bias_mod_freq * 1e6* (t-t[0]))\r\n else:\r\n envelope = self.calculate_envelope(t)\r\n ω = self.frequency * 2 * π\r\n dt = t[1]-t[0]\r\n\r\n if self.pulse_type == PulseType.XY: #below I generate I/Q waveforms with the IQ parameters and DRAG\r\n DRAG_δ = self.drag_detuning * 2 * π\r\n I_waveform = (envelope * np.cos( (ω + DRAG_δ) * t + self.phase ) +\r\n -self.drag_coefficient * np.gradient(envelope)/dt * np.sin( (ω + DRAG_δ) * t + self.phase ) ) + I_offset\r\n Q_waveform = IQ_ratio*(envelope * np.sin( (ω + DRAG_δ) * t + self.phase + IQ_skew ) -\r\n -self.drag_coefficient * np.gradient(envelope)/dt * np.cos( (ω + DRAG_δ) * t + self.phase + IQ_skew ) ) + Q_offset\r\n waveform = I_waveform + 1j*Q_waveform\r\n\r\n elif self.pulse_type == PulseType.Z:\r\n t_noPhase = t-t[0] #make sure pulse doesn't have any intrinsic phase regardless of when it starts\r\n waveform = envelope * np.cos(ω * t_noPhase + self.phase)\r\n\r\n elif self.pulse_type == PulseType.READOUT:\r\n I_waveform = envelope * np.cos(ω * t + self.phase) + I_offset\r\n Q_waveform = envelope * IQ_ratio * np.sin(ω * t + self.phase + IQ_skew) + Q_offset\r\n waveform = I_waveform + 1j*Q_waveform\r\n\r\n elif self.pulse_type == PulseType.NONE or self.pulse_type == PulseType.DELAY:\r\n waveform = np.zeros(len(t))\r\n\r\n return waveform\r\n\r\nif __name__ == '__main__':\r\n pass\r\n", "meta": {"hexsha": "fce2543fd5ecf66b1ba9a31da781016bbd85a880", "size": 8453, "ext": "py", "lang": "Python", "max_stars_repo_path": "Painter_Arbitrary_Sequence_Generator/pulses.py", "max_stars_repo_name": "sherryue123/Labber-Drivers", "max_stars_repo_head_hexsha": "90fc217db4158857f650122cd780f18fcf6d9a78", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-06-18T21:14:50.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-11T19:05:35.000Z", "max_issues_repo_path": "Painter_Arbitrary_Sequence_Generator/pulses.py", "max_issues_repo_name": "sherryue123/Labber-Drivers", "max_issues_repo_head_hexsha": "90fc217db4158857f650122cd780f18fcf6d9a78", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Painter_Arbitrary_Sequence_Generator/pulses.py", "max_forks_repo_name": "sherryue123/Labber-Drivers", "max_forks_repo_head_hexsha": "90fc217db4158857f650122cd780f18fcf6d9a78", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-04-03T16:54:28.000Z", "max_forks_repo_forks_event_max_datetime": "2020-04-03T16:54:28.000Z", "avg_line_length": 43.5721649485, "max_line_length": 256, "alphanum_fraction": 0.609606057, "include": true, "reason": "import numpy", "num_tokens": 2114, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5774953651858118, "lm_q2_score": 0.341582499438317, "lm_q1q2_score": 0.1972623102542132}} {"text": "\"\"\"\nFunctions for explaining classifiers that use Multimodal data.\nDeveloped initially for the hateful memes challenge in mmf\n\"\"\"\n\nimport copy\nfrom functools import partial\nimport numpy as np\nimport scipy as sp\nimport sklearn\nfrom sklearn.utils import check_random_state\nfrom tqdm.auto import tqdm\n\nfrom lime.wrappers.scikit_image import SegmentationAlgorithm\nfrom mmxai.interpretability.classification.lime.lime_base import LimeBase\n\nfrom lime.lime_text import IndexedString, TextDomainMapper\nfrom lime.exceptions import LimeError\n\nfrom sklearn.calibration import CalibratedClassifierCV\nfrom PIL import Image\nfrom skimage.segmentation import mark_boundaries\n\n# from object_detection import *\n\n\nclass MultiModalExplanation(object):\n def __init__(\n self,\n image,\n segments,\n domain_mapper,\n n_txt_features,\n n_img_features,\n n_detection_features,\n ratio_txt_img,\n detection_label,\n mode=\"classification\",\n class_names=None,\n random_state=None,\n ):\n \"\"\"Init function.\n\n Args:\n image: 3d numpy array\n segments: 2d numpy array, with the output from skimage.segmentation\n domain_mapper: Maps text feature ids to words or word-positions\n n_txt_features:number of words to include in explanation\n n_img_features: number of superpixels to include in explanation\n n_detection_features:number of detected objects to include in explanation\n ratio_txt_img: weight ratio between text and image features\n detection_label: numpy array of names of detected objects\n mode: what kind of model for this object, classification default\n class_names: list of class names, ordered according to whatever the\n classifier is using. If not present, class names will be '0',\n '1', ...\n random_state: an integer or numpy.RandomState that will be used to\n generate random numbers. If None, the random state will be\n initialized using the internal numpy seed.\n \"\"\"\n self.image = image\n self.segments = segments\n self.random_state = random_state\n self.mode = mode\n self.domain_mapper = domain_mapper\n self.n_txt_features = n_txt_features\n self.n_img_features = n_img_features\n self.n_detection_features = n_detection_features\n self.ratio_txt_img = ratio_txt_img\n self.detection_label = detection_label\n self.local_exp = {}\n self.intercept = {}\n self.score = {}\n self.local_pred = {}\n self.unsorted_weights = {}\n\n # divide explanations of the two modalities\n self.local_exp_img = {}\n self.local_exp_txt = {}\n self.local_exp_det = {}\n\n if mode == \"classification\":\n self.class_names = class_names\n self.top_labels = None\n self.predict_proba = None\n\n def get_image_and_mask(\n self,\n label,\n positive_only=True,\n negative_only=False,\n hide_rest=False,\n num_features=5,\n min_weight=0.0,\n ):\n \"\"\"\n\n Args:\n label: label to explain\n positive_only: if True, only take superpixels that positively contribute to\n the prediction of the label.\n negative_only: if True, only take superpixels that negatively contribute to\n the prediction of the label. If false, and so is positive_only, then both\n negativey and positively contributions will be taken.\n Both can't be True at the same time\n hide_rest: if True, make the non-explanation part of the return\n image gray\n num_features: number of superpixels to include in explanation\n min_weight: minimum weight of the superpixels to include in explanation\n Returns:\n (image, mask), where image is a 3d numpy array and mask is a 2d\n numpy array that can be used with\n skimage.segmentation.mark_boundaries\n \"\"\"\n\n if label not in self.local_exp_img:\n raise KeyError(\"Label not in explanation\")\n if positive_only & negative_only:\n raise ValueError(\n \"Positive_only and negative_only cannot be true at the same time.\"\n )\n segments = self.segments\n image = self.image\n exp = self.local_exp_img[label]\n mask = np.zeros(segments.shape, segments.dtype)\n if hide_rest:\n temp = np.zeros(self.image.shape)\n else:\n temp = self.image.copy()\n if positive_only:\n fs = [x[0] for x in exp if x[1] > 0 and x[1] > min_weight][:num_features]\n if negative_only:\n fs = [x[0] for x in exp if x[1] < 0 and abs(x[1]) > min_weight][\n :num_features\n ]\n if positive_only or negative_only:\n for f in fs:\n temp[segments == f] = image[segments == f].copy()\n mask[segments == f] = 1\n return temp, mask\n else:\n for f, w in exp[:num_features]:\n if np.abs(w) >= min_weight:\n c = 0 if w < 0 else 1\n mask[segments == f] = -1 if w < 0 else 1\n temp[segments == f] = image[segments == f].copy()\n temp[segments == f, c] = np.max(image)\n return temp, mask\n\n def as_list(self, label=1, **kwargs):\n \"\"\"\n Returns the explanation as a list.\n Args:\n label: desired label. If you ask for a label for which an\n explanation wasn't computed, will throw an exception.\n Will be ignored for regression explanations.\n kwargs: keyword arguments, passed to domain_mapper\n Returns:\n list of tuples (representation, weight), where representation is\n given by domain_mapper. Weight is a float.\n \"\"\"\n label_to_use = label\n ans = self.domain_mapper.map_exp_ids(self.local_exp_txt[label_to_use], **kwargs)\n ans = [(x[0], float(x[1])) for x in ans]\n return ans\n\n def get_explanation(self, label, num_features=10, which_exp=\"positive\"):\n\n # the explanation to display:\n \"\"\"\n :param label: label to explain\n :param num_features: how many top features to display\n :param which_exp: want features that encourage or discourage the dicision (label)\n :return:\n text_message: informative message to interpret text features\n img_message: informative message to interpret image features\n txt_exp_list: text part of the explanation, ready to display\n temp, mask: image part of the explanation, ready to display\n \"\"\"\n this_exp = np.array(self.local_exp[label])\n\n if which_exp == \"positive\":\n positives = this_exp[this_exp[:, 1] >= 0]\n else: # negative\n positives = this_exp[this_exp[:, 1] < 0]\n\n if positives.shape[0] < num_features:\n num_features = positives.shape[0]\n top_exp = positives[:num_features]\n top_exp_unique, top_idx = np.unique(top_exp[:, 0], return_index=True)\n\n txt_exp = top_exp[top_exp[:, 0] < self.n_txt_features]\n n_txt_exp = txt_exp.shape[0]\n txt_top_idx = []\n for txt_feature in txt_exp:\n txt_top_idx.append(top_idx[top_exp_unique == txt_feature[0]] + 1)\n\n img_exp = top_exp[self.n_txt_features <= top_exp[:, 0]]\n img_exp = img_exp[img_exp[:, 0] < (self.n_txt_features + self.n_img_features)]\n n_img_exp = img_exp.shape[0]\n img_top_idx = []\n for img_feature in img_exp:\n img_top_idx.append(top_idx[top_exp_unique == img_feature[0]] + 1)\n\n # detection features\n det_exp = top_exp[top_exp[:, 0] >= self.n_txt_features + self.n_img_features]\n n_det_exp = det_exp.shape[0]\n det_top_idx = []\n for det_feature in det_exp:\n det_top_idx.append(\n det_feature[0] - n_txt_exp - n_img_exp\n ) # index for retrieving the labels\n\n if n_det_exp != 0:\n readable_exp_det = (\n f\" Also, we have detected {n_det_exp} types \"\n f\"of objects from the input image that can be the reason for the decision, they are:\"\n )\n for i in det_top_idx:\n readable_exp_det += str(self.detection_label[i])\n else:\n readable_exp_det = (\n \" No objects in the image contributed to the model decision\"\n )\n\n # explanation of explanations\n readable_exp_txt = \"\"\n readable_exp_img = \"\"\n if n_txt_exp > 0:\n readable_exp_txt = f\"{n_txt_exp} are from the text (the top\"\n for i in txt_top_idx:\n readable_exp_txt += str(i)\n readable_exp_txt += \"th), \"\n else:\n readable_exp_txt += \"none are from the words, \"\n\n if n_img_exp > 0:\n readable_exp_img = f\"{n_img_exp} are from the image (the top\"\n for j in img_top_idx:\n readable_exp_img += str(j)\n readable_exp_img += (\n \"th, some adjacent regions might merge into a larger area).\"\n )\n else:\n readable_exp_img += \"none are from the image pixel areas.\"\n\n txt_exp_list = np.array(self.as_list(label), dtype=\"object\")\n\n # return explanations upon request\n if which_exp == \"positive\":\n # txt_list = txt_exp_list[txt_exp_list[:, 1] >= 0]\n temp, mask = self.get_image_and_mask(\n label, num_features=n_img_exp, positive_only=True\n )\n else:\n # txt_list = txt_exp_list[txt_exp_list[:, 1] < 0]\n temp, mask = self.get_image_and_mask(\n label, num_features=n_img_exp, positive_only=False, negative_only=True\n )\n # txt_list = txt_list[:n_txt_exp]\n\n # image and text hover display message\n label_decision = \"\"\n if label == 1:\n label_decision = \"hateful\"\n else:\n label_decision = \"not hateful\"\n\n txt_message = (\n f\"For this result, the value associated with each word indicates how much it pushes \"\n f\"the model towards making a {label_decision} decision.\"\n )\n\n img_message = (\n f\"Your image has been segmented into {self.n_img_features} small pixel areas, \"\n f\"the ones that most encourage (or discourage) your \"\n f\"model decision has been marked by the yellow boundaries.\"\n )\n\n top_message = (\n f\"Each small pixel area in your image input and each distinct word \"\n f\"in your text input are called an interpretable feature. There are \"\n f\"{self.n_img_features + self.n_txt_features} features in total ({self.n_img_features} \"\n f\"pixel areas and {self.n_txt_features} words). Among the top 10 \"\n f\"such features that encourage (or discourage) your model decision, \"\n )\n top_message = top_message + readable_exp_txt + readable_exp_img\n\n ratio_message = self.get_txt_img_ratio()\n\n # format new line as html\n img_message = \"

\" + img_message + \"

\" + top_message + \"

\"\n img_message = img_message + ratio_message\n return txt_message, img_message, txt_exp_list, temp, mask\n\n def get_txt_img_ratio(self):\n \"\"\"\n Get informative message about the weight ratio between text and image features\n Return:\n words: informative string message to interpret the relative weight of text and image features\n \"\"\"\n img_percentage = 1 / (1 + self.ratio_txt_img)\n txt_percentage = 1 - img_percentage\n words = (\n f\"For this prediction, the relative importance of \"\n f\"text and image inputs to your model decision are respectively {round(100*txt_percentage, 2)}% \"\n f\"and {round(100*img_percentage, 2)}%\"\n )\n return words\n\n\nclass LimeMultimodalExplainer(object):\n def __init__(\n self,\n image,\n text,\n model,\n kernel_width=0.25,\n kernel=None,\n feature_selection=\"auto\",\n class_names=None,\n ):\n \"\"\"\n Object to explain predictions on texts and images\n Args:\n image: input 3D numpy array\n text: input string in the meme\n model: multi-modal model to give predictions for given image and text\n kernel_width: kernel width for the exponential kernel.\n If None, defaults to sqrt(number of columns) * 0.75.\n kernel: similarity kernel that takes euclidean distances and kernel\n width as input and outputs weights in (0,1). If None, defaults to\n an exponential kernel.\n feature_selection: feature selection method. can be\n 'forward_selection', 'lasso_path', 'none' or 'auto'.\n See function 'explain_instance_with_data' in lime_base.py for\n details on what each of the options does.\n class_names: list of class names, ordered according to whatever the\n classifier is using. If not present, class names will be '0',\n '1', ...\n \"\"\"\n self.image = image\n self.text = text\n self.pred_model = model\n self.random_state = check_random_state(None)\n if kernel is None:\n\n def kernel(d, kernel_width):\n return np.sqrt(np.exp(-(d ** 2) / kernel_width ** 2))\n\n kernel_fn = partial(kernel, kernel_width=kernel_width)\n self.feature_selection = feature_selection\n self.class_names = class_names\n self.base = LimeBase(kernel_fn, verbose=False, random_state=self.random_state)\n\n def explain_instance(self, classifier_fn, n_samples, top_labels=2):\n\n \"\"\"\n Generate explanations for a multi-modal input\n Arguments:\n classifier_fn: classification function to give predictions for given texts and images\n num_samples: size of the neighborhood to learn the linear model\n top_labels: if not None, ignore labels and produce explanations for\n the K labels with highest prediction probabilities, where K is\n this parameter.\n Return:\n ret_exp: A MultiModalExplanation object with the corresponding\n explanations.\n \"\"\"\n (\n data,\n labels,\n distances,\n n_txt_features,\n n_img_features,\n segments,\n domain_mapper,\n n_detection_features,\n detection_label,\n ratio_txt_img,\n ) = self.data_labels(n_samples, classifier_fn)\n num_features = data.shape[1]\n\n if self.class_names is None:\n self.class_names = [str(x) for x in range(labels[0].shape[0])]\n\n ret_exp = MultiModalExplanation(\n self.image,\n segments,\n domain_mapper=domain_mapper,\n n_txt_features=n_txt_features,\n n_img_features=n_img_features,\n n_detection_features=n_detection_features,\n ratio_txt_img=ratio_txt_img,\n detection_label=detection_label,\n class_names=self.class_names,\n random_state=self.random_state,\n )\n ret_exp.predict_proba = labels[0]\n\n if top_labels:\n top = np.argsort(labels[0])[-top_labels:]\n ret_exp.top_labels = list(top)\n ret_exp.top_labels.reverse()\n for label in top:\n (\n ret_exp.intercept[label],\n ret_exp.unsorted_weights[label],\n ret_exp.local_exp[label],\n ret_exp.local_exp_txt[label],\n ret_exp.local_exp_img[label],\n ret_exp.local_exp_det[label],\n ret_exp.score[label],\n ret_exp.local_pred[label],\n ) = self.base.explain_instance_with_data(\n data,\n labels,\n distances,\n label,\n num_features,\n n_txt_features,\n n_img_features,\n n_detection_features,\n feature_selection=None,\n )\n\n # split local explanation into text and image features\n\n return ret_exp\n\n def data_labels(self, num_samples, classifier_fn, detection=False):\n \"\"\"\n Steps of this function:\n 1. generate perturbed text features and image features\n 2. in a loop, 1) using these features to make instances of perturbed (text, image) pairs,\n 2) make predictions on these pairs, store labels into 'labels'\n 3. concatenate text and image features, store into 'data',\n also append the original input and prediction of it\n 4. calculate distances\n Arguments:\n classifier_fn: classification function to give predictions for given texts and images\n num_samples: size of the neighborhood to learn the linear model\n detection: Whether object detection method is invoked, default to be false\n Return:\n data: dense num_samples * num_superpixels\n labels: prediction probabilities matrix\n distances:distance including text/image distance ratio where\n text and image distance are cosine distances between the original instance and\n each perturbed instance (computed in the binary 'data'\n matrix), times 100.\n doc_size: number of words in indexed string, where indexed string is the string with various indexes\n n_img_features: number of superpixels to include in explanation\n segments:2d numpy array, with the output from skimage.segmentation\n domain_mapper:Maps text feature ids to words or word-positions\n num_object_detection:number of detected objects to include in explanation\n ori_label: numpy including deteced objects in the original image\n ratio_txt_img: weight ratio between text and image features\n \"\"\"\n\n \"\"\" 1. make text features \"\"\"\n indexed_string = IndexedString(\n self.text, bow=True, split_expression=r\"\\W+\", mask_string=None\n )\n domain_mapper = TextDomainMapper(indexed_string)\n\n doc_size = indexed_string.num_words()\n sample = self.random_state.randint(\n 1, doc_size + 1, num_samples\n ) # num_samples - 1\n data_txt = np.ones((num_samples, doc_size))\n # data[0] = np.ones(doc_size)\n features_range = range(doc_size)\n inverse_data_txt = []\n\n \"\"\" 1. make image features \"\"\"\n random_seed = self.random_state.randint(0, high=1000)\n segmentation_fn = SegmentationAlgorithm(\n \"quickshift\",\n kernel_size=4,\n max_dist=200,\n ratio=0.2,\n random_seed=random_seed,\n )\n\n # segmentation_fn = SegmentationAlgorithm('felzenszwalb', scale=200, sigma=2, min_size=100)\n \"\"\"segmentation_fn = SegmentationAlgorithm('slic', n_segments=60, compactness=10, sigma=1,\n start_label=1)\"\"\"\n\n segments = segmentation_fn(self.image) # get segmentation\n n_img_features = np.unique(segments).shape[0] # get num of superpixel features\n data_img = self.random_state.randint(\n 0, 2, n_img_features * num_samples\n ).reshape((num_samples, n_img_features))\n data_img_rows = tqdm(data_img)\n imgs = []\n\n \"\"\" 1. make object detection features \n if detection:\n predictor, cfg = object_detection_predictor()\n ori_label = object_detection_obtain_label(predictor, cfg, self.image)\n num_object_detection = ori_label.shape[0]\n data_object_detection = np.zeros((num_samples,num_object_detection))\"\"\"\n\n # create fudged_image\n fudged_image = self.image.copy()\n for x in np.unique(segments):\n fudged_image[segments == x] = (\n np.mean(self.image[segments == x][:, 0]),\n np.mean(self.image[segments == x][:, 1]),\n np.mean(self.image[segments == x][:, 2]),\n )\n\n # img_features[0, :] = 1 # the first sample is the full image # num_samples\n\n \"\"\"2. create data instances and make predictions\"\"\"\n labels = []\n for i, instance in enumerate(zip(sample, data_img_rows)):\n size_txt, row_img = instance\n\n # make text instance\n inactive = self.random_state.choice(features_range, size_txt, replace=False)\n data_txt[i, inactive] = 0\n inverse_data_txt.append(indexed_string.inverse_removing(inactive))\n\n # make image instance\n temp = copy.deepcopy(self.image)\n zeros = np.where(row_img == 0)[\n 0\n ] # get segment numbers that are turned off in this instance\n mask = np.zeros(segments.shape).astype(bool)\n for zero in zeros:\n mask[segments == zero] = True\n temp[mask] = fudged_image[mask]\n\n \"\"\"if detection:\n label = object_detection_obtain_label(predictor, cfg, temp)\n label_diff = compare_labels(ori_label,label)\n data_object_detection[i] = label_diff\"\"\"\n imgs.append(temp)\n\n # make prediction and append result\n if len(imgs) == 10:\n preds = classifier_fn(self.pred_model, imgs, inverse_data_txt)\n labels.extend(preds)\n imgs = []\n inverse_data_txt = []\n\n if len(imgs) > 0:\n preds = classifier_fn(self.pred_model, imgs, inverse_data_txt)\n labels.extend(preds)\n\n \"\"\"3. concatenate and append features\"\"\"\n data = np.concatenate((data_txt, data_img), axis=1)\n\n # append the original input to the last\n orig_img_f = np.ones((n_img_features,))\n orig_txt_f = np.ones(doc_size)\n\n \"\"\"if detection:\n data = np.concatenate((data, data_object_detection),axis=1)\n orig_ot = np.ones(num_object_detection)\n data = np.vstack((data, np.concatenate((np.concatenate((orig_txt_f, orig_img_f)),orig_ot))))\n else:\"\"\"\n data = np.vstack((data, np.ones((data.shape[1])))) ###\n\n labels.extend(classifier_fn(self.pred_model, [self.image], [self.text]))\n\n \"\"\"4. compute distance# distances[:, :(doc_size-1)] *= 100\n use platt scaling t get relative importance of text and image modalities\n \"\"\"\n\n labels = np.array(labels, dtype=float)\n\n # Modify MMF source code to zero out image / text attributes\n # dummy_label_image = np.array(classifier_fn([self.image], [self.text], zero_text=True)) # zero out text\n # dummy_label_text = np.array(classifier_fn([self.image], [self.text], zero_image=True)) # zero out image\n\n # perform calibration\n try:\n labels_for_calib = np.array(labels[:, 0] < 0.5, dtype=float)\n calibrated = CalibratedClassifierCV(cv=3)\n calibrated.fit(data[:, : doc_size + n_img_features], labels_for_calib)\n\n calib_data = np.ones((3, doc_size + n_img_features), dtype=float)\n calib_data[0][:doc_size] = 0 # zero out text\n calib_data[1][doc_size:] = 0 # zero out image\n calibrated_labels = calibrated.predict_proba(calib_data)\n\n delta_txt = abs(calibrated_labels[-1][0] - calibrated_labels[0][0])\n delta_img = abs(calibrated_labels[-1][0] - calibrated_labels[1][0])\n\n ratio_txt_img = max(min(100, delta_txt / delta_img), 0.01)\n except:\n dummy_text = \"\"\n dummy_image = np.zeros_like(self.image)\n label_text_out = np.array(\n classifier_fn(\n self.pred_model, [self.image], [self.text], zero_text=True\n )\n ) # zero out text\n label_image_out = np.array(\n classifier_fn(\n self.pred_model, [self.image], [self.text], zero_image=True\n )\n ) # zero out image\n\n delta_txt = abs(labels[-1][0] - label_text_out[0][0])\n delta_img = abs(labels[-1][0] - label_image_out[0][0])\n ratio_txt_img = max(min(10, delta_txt / delta_img), 0.1)\n\n # calculate distances\n distances_img = sklearn.metrics.pairwise_distances(\n data[:, doc_size:], data[-1, doc_size:].reshape(1, -1), metric=\"cosine\"\n ).ravel()\n\n def distance_fn(x):\n return sklearn.metrics.pairwise.pairwise_distances(\n x, x[-1], metric=\"cosine\"\n ).ravel()\n\n distances_txt = distance_fn(sp.sparse.csr_matrix(data[:, :doc_size]))\n\n distances = (\n 1 / (1 + ratio_txt_img) * distances_img\n + (1 - 1 / (1 + ratio_txt_img)) * distances_txt\n )\n\n # As required by lime_base, make the first element of data, labels, distances the original data point\n data[0] = data[-1]\n labels[0] = labels[-1]\n distances[0] = distances[-1]\n\n \"\"\"if not detection:\"\"\"\n num_object_detection = 0\n ori_label = None\n\n return (\n data,\n labels,\n distances,\n doc_size,\n n_img_features,\n segments,\n domain_mapper,\n num_object_detection,\n ori_label,\n ratio_txt_img,\n )\n", "meta": {"hexsha": "bcb7017e1b27d55bc680bb2ddaf55ea34f582752", "size": 25926, "ext": "py", "lang": "Python", "max_stars_repo_path": "mmxai/interpretability/classification/lime/lime_multimodal.py", "max_stars_repo_name": "junqi-jiang/mmxai", "max_stars_repo_head_hexsha": "08ae70a6d443fbdfa92dba6cd285429e85ac851f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2021-05-19T16:44:46.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-19T16:46:43.000Z", "max_issues_repo_path": "mmxai/interpretability/classification/lime/lime_multimodal.py", "max_issues_repo_name": "junqi-jiang/mmxai", "max_issues_repo_head_hexsha": "08ae70a6d443fbdfa92dba6cd285429e85ac851f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 8, "max_issues_repo_issues_event_min_datetime": "2021-05-19T17:23:29.000Z", "max_issues_repo_issues_event_max_datetime": "2021-06-09T09:58:02.000Z", "max_forks_repo_path": "mmxai/interpretability/classification/lime/lime_multimodal.py", "max_forks_repo_name": "junqi-jiang/mmxai", "max_forks_repo_head_hexsha": "08ae70a6d443fbdfa92dba6cd285429e85ac851f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.9476117103, "max_line_length": 115, "alphanum_fraction": 0.5941140168, "include": true, "reason": "import numpy,import scipy", "num_tokens": 5448, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5774953797290153, "lm_q2_score": 0.3415824860330003, "lm_q1q2_score": 0.19726230748040857}} {"text": "from CHECLabPy.plotting.setup import Plotter\nimport numpy as np\nimport pandas as pd\nfrom sstcam_simulation.utils.efficiency import CameraEfficiency\nfrom sstcam_simulation.utils.sipm import SiPMOvervoltage\nfrom sstcam_simulation.utils.window_durham_needle import SSTWindowRun3, Window\n\nMINIMGAMP_GAMMA = 250\nMINIMGAMP_PROTON = 480\nBTEL1170_PDE = 0.2\nBTEL0090_SNR = 0.35\nPROD4_OPCT = 0.08\nPROD4_MINIMGAMP_GAMMA = 153\nPROD4_MINIMGAMP_PROTON = 208\n\n\ndef main():\n sipm_tool = SiPMOvervoltage.lvr3_6mm_50um_uncoated()\n sipm_tool.overvoltage = 6\n pde_at_450nm = sipm_tool.pde\n window_tool = SSTWindowRun3()\n\n eff = CameraEfficiency.from_sstcam(\n fov_angle=0,\n pde_at_450nm=pde_at_450nm,\n window=window_tool,\n )\n\n p = Plotter()\n p.ax.plot(eff.wavelength, eff._cherenkov_diff_flux_on_ground, \"-\", color='blue', alpha=0.3, label=\"On-ground\")\n p.ax.plot(eff.wavelength, eff._cherenkov_diff_flux_at_camera, \"--\", color='blue', alpha=0.6, label=\"At-camera\")\n p.ax.plot(eff.wavelength, eff._cherenkov_diff_flux_at_pixel, \"-.\", color='blue', alpha=0.9, label=\"At-pixel\")\n p.ax.plot(eff.wavelength, eff._cherenkov_diff_flux_inside_pixel, \":\", color='blue', alpha=1, label=\"Inside-pixel\")\n p.ax.set_ylim(0, 0.45)\n p.ax.set_xlabel(\"Wavelength [nm]\")\n p.ax.set_ylabel(\"Cherenkov photons [100 * 1 / nm]\")\n p.save(\"foldings/spectra_cherenkov.pdf\")\n\n p = Plotter()\n p.ax.plot(eff.wavelength, eff._nsb_diff_flux_on_ground, \"-\", color='red', alpha=0.3, label=\"On-ground\")\n p.ax.plot(eff.wavelength, eff._nsb_diff_flux_at_camera, \"--\", color='red', alpha=0.6, label=\"At-camera\")\n p.ax.plot(eff.wavelength, eff._nsb_diff_flux_at_pixel, \"-.\", color='red', alpha=0.9, label=\"At-pixel\")\n p.ax.plot(eff.wavelength, eff._nsb_diff_flux_inside_pixel, \":\", color='red', alpha=1, label=\"Inside-pixel\")\n p.ax.set_ylim(0, 25)\n p.ax.set_xlabel(\"Wavelength [nm]\")\n p.ax.set_ylabel(\"NSB photons [ 1 / (nm m2 ns sr) ]\")\n p.save(\"foldings/spectra_nsb.pdf\")\n\n p = Plotter()\n camera_sensitivity = eff.pde * eff.window_transmissivity\n p.ax.plot(eff.wavelength, eff.pde, label=\"PDE\")\n p.ax.plot(eff.wavelength, eff.window_transmissivity, label=\"Window Transmissivity\")\n p.ax.plot(eff.wavelength, camera_sensitivity, label=\"PDE * Window Transmissivity\")\n # p.ax.plot(eff.wavelength, eff.telescope_transmissivity, label=\"Telescope Transmissivity\")\n p.ax.plot(eff.wavelength, eff.mirror_reflectivity, label=\"Mirror Reflectivity\")\n p.ax.set_xlabel(\"Wavelength [nm]\")\n p.ax.set_ylabel(\"Sensitivity\")\n p.add_legend()\n p.save(\"foldings/sensitivity.pdf\")\n\n p = Plotter()\n def add_window(window_tool):\n angles = np.array([0, 20, 45, 50, 60])\n arrays = np.vstack([\n window_tool.df['M0'],\n window_tool.df['M20'],\n window_tool.df['M45'],\n window_tool.df['M50'],\n window_tool.df['M60'],\n ])\n window_tool = Window(incidence_angles=angles, transmission=arrays)\n \n eff = CameraEfficiency.from_sstcam(\n fov_angle=0,\n pde_at_450nm=pde_at_450nm,\n window=window_tool,\n )\n label = f\"NSB={eff.nominal_nsb_rate.to_value('MHz'):.2f}, PDE={eff.camera_cherenkov_pde:.2f}, S/N={eff.camera_signal_to_noise:.2f}\"\n x = eff.wavelength.value\n y = eff.window_transmissivity\n p.ax.plot(x, y, alpha=0.7, label=label)\n\n add_window(window_tool)\n # from IPython import embed\n # embed()\n # window_tool.df.loc[window_tool.df.index < 300] = 0\n # add_window(window_tool)\n # window_tool.df.loc[window_tool.df.index > 750] = 0.2\n # add_window(window_tool)\n p.ax.set_xlabel(\"Wavelength [nm]\")\n p.ax.set_ylabel(\"Sensitivity\")\n p.add_legend()\n p.save(\"foldings/window.pdf\")\n\n\n\n\nif __name__ == '__main__':\n main()\n", "meta": {"hexsha": "8803fc4b394f6e3f3a461d33c600cce3b8287ce1", "size": 3853, "ext": "py", "lang": "Python", "max_stars_repo_path": "scratch/plot_foldings.py", "max_stars_repo_name": "cta-chec/sstCASSIM", "max_stars_repo_head_hexsha": "75bb863675991f1a36b7d430f9253ae09416f33e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-12-23T23:26:36.000Z", "max_stars_repo_stars_event_max_datetime": "2019-12-23T23:26:36.000Z", "max_issues_repo_path": "scratch/plot_foldings.py", "max_issues_repo_name": "cta-chec/sstCASSIM", "max_issues_repo_head_hexsha": "75bb863675991f1a36b7d430f9253ae09416f33e", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "scratch/plot_foldings.py", "max_forks_repo_name": "cta-chec/sstCASSIM", "max_forks_repo_head_hexsha": "75bb863675991f1a36b7d430f9253ae09416f33e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.53, "max_line_length": 139, "alphanum_fraction": 0.6781728523, "include": true, "reason": "import numpy", "num_tokens": 1160, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5774953651858118, "lm_q2_score": 0.3415824927356586, "lm_q1q2_score": 0.19726230638345907}} {"text": "from __future__ import division, absolute_import, print_function\n\n__copyright__ = \"Copyright (C) 2017 - 2018 Xiaoyu Wei\"\n\n__license__ = \"\"\"\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n\"\"\"\n\nimport numpy as np\nimport logging\nimport pyopencl as cl\nimport pyopencl.array\nfrom pytools.obj_array import make_obj_array\n\n# from pytools import memoize_method\nfrom volumential.nearfield_potential_table import NearFieldInteractionTable\nfrom volumential.expansion_wrangler_interface import (\n ExpansionWranglerInterface, ExpansionWranglerCodeContainerInterface)\nfrom sumpy.fmm import SumpyExpansionWrangler, \\\n SumpyTimingFuture, SumpyExpansionWranglerCodeContainer\nfrom boxtree.pyfmmlib_integration import FMMLibExpansionWrangler\n\nfrom sumpy.kernel import (\n LaplaceKernel, HelmholtzKernel, AxisTargetDerivative,\n DirectionalSourceDerivative)\n\nlogger = logging.getLogger(__name__)\n\n\ndef level_to_rscale(tree, level):\n return tree.root_extent * (2 ** -level)\n\n\ndef inverse_id_map(queue, mapped_ids):\n \"\"\"Given a index mapping as its mapped ids, compute its inverse,\n and return the inverse by the inversely-mapped ids.\n \"\"\"\n cl_array = False\n if isinstance(mapped_ids, cl.array.Array):\n cl_array = True\n mapped_ids = mapped_ids.get(queue)\n\n inv_ids = np.zeros_like(mapped_ids)\n inv_ids[mapped_ids] = np.arange(len(mapped_ids))\n\n if cl_array:\n inv_ids = cl.array.to_device(queue, inv_ids)\n\n return inv_ids\n\n\n# {{{ sumpy backend\n\n\nclass FPNDSumpyExpansionWranglerCodeContainer(\n ExpansionWranglerCodeContainerInterface,\n SumpyExpansionWranglerCodeContainer):\n \"\"\"Objects of this type serve as a place to keep the code needed\n for ExpansionWrangler if it is using sumpy to perform multipole\n expansion and manipulations.\n\n Since :class:`SumpyExpansionWrangler` necessarily must have a\n :class:`pyopencl.CommandQueue`, but this queue is allowed to be\n more ephemeral than the code, the code's lifetime\n is decoupled by storing it in this object.\n \"\"\"\n get_wrangler = SumpyExpansionWranglerCodeContainer.get_wrangler\n\n\nclass FPNDSumpyExpansionWrangler(\n ExpansionWranglerInterface, SumpyExpansionWrangler):\n \"\"\"This expansion wrangler uses \"fpnd\" strategy. That is, Far field is\n computed via Particle approximation and Near field is computed Directly.\n The FMM is performed using sumpy backend.\n\n .. attribute:: source_extra_kwargs\n\n Keyword arguments to be passed to interactions that involve\n the source field.\n\n .. attribute:: kernel_extra_kwargs\n\n Keyword arguments to be passed to interactions that involve\n expansions, but not the source field.\n\n .. attribute:: self_extra_kwargs\n\n Keyword arguments to be passed for handling\n self interactions (singular integrals)\n \"\"\"\n\n # {{{ constructor\n\n def __init__(\n self,\n code_container,\n queue,\n tree,\n near_field_table,\n dtype,\n fmm_level_to_order,\n quad_order,\n potential_kind=1,\n source_extra_kwargs=None,\n kernel_extra_kwargs=None,\n self_extra_kwargs=None,\n list1_extra_kwargs=None,\n ):\n \"\"\"\n near_field_table can either one of three things:\n 1. a single table, when len(target_kernels) = 1 (single level)\n 2. a list of tables, when len(target_kernels) = 1 (multiple levels)\n 3. otherwise, a dictionary from kernel.__repr__() to a list of its tables\n \"\"\"\n\n self.code = code_container\n self.queue = queue\n self.tree = tree\n\n self.near_field_table = {}\n # list of tables for a single out kernel\n if isinstance(near_field_table, list):\n assert len(self.code.target_kernels) == 1\n self.near_field_table[\n self.code.target_kernels[0].__repr__()\n ] = near_field_table\n self.n_tables = len(near_field_table)\n\n # single table\n elif isinstance(near_field_table, NearFieldInteractionTable):\n assert len(self.code.target_kernels) == 1\n self.near_field_table[self.code.target_kernels[0].__repr__()] = [\n near_field_table\n ]\n self.n_tables = 1\n\n # dictionary of lists of tables\n elif isinstance(near_field_table, dict):\n self.n_tables = dict()\n for out_knl in self.code.target_kernels:\n if repr(out_knl) not in near_field_table:\n raise RuntimeError(\n \"Missing nearfield table for %s.\" % repr(out_knl))\n if isinstance(near_field_table[repr(out_knl)],\n NearFieldInteractionTable):\n near_field_table[repr(out_knl)] = [\n near_field_table[repr(out_knl)]]\n else:\n assert isinstance(near_field_table[repr(out_knl)], list)\n\n self.n_tables[repr(out_knl)] = len(near_field_table[repr(out_knl)])\n\n self.near_field_table = near_field_table\n else:\n raise RuntimeError(\"Table type unrecognized.\")\n\n self.quad_order = quad_order\n self.potential_kind = potential_kind\n\n # TODO: make all parameters table-specific (allow using inhomogeneous tables)\n kname = repr(self.code.target_kernels[0])\n self.root_table_source_box_extent = (\n self.near_field_table[kname][0].source_box_extent)\n table_starting_level = np.round(\n np.log(self.tree.root_extent / self.root_table_source_box_extent)\n / np.log(2)\n )\n for kid in range(len(self.code.target_kernels)):\n kname = self.code.target_kernels[kid].__repr__()\n for lev, table in zip(\n range(len(self.near_field_table[kname])),\n self.near_field_table[kname]\n ):\n assert table.quad_order == self.quad_order\n\n if not table.is_built:\n raise RuntimeError(\n \"Near field interaction table needs to be built \"\n \"prior to being used\"\n )\n\n table_root_extent = table.source_box_extent * 2 ** lev\n assert (\n abs(self.root_table_source_box_extent - table_root_extent)\n < 1e-15\n )\n\n # If the kernel cannot be scaled,\n # - tree_root_extent must be integral times of table_root_extent\n # - n_tables must be sufficient\n if not isinstance(self.n_tables, dict) and self.n_tables > 1:\n if (\n not abs(\n int(self.tree.root_extent / table_root_extent)\n * table_root_extent\n - self.tree.root_extent\n )\n < 1e-15\n ):\n raise RuntimeError(\n \"Incompatible list of tables: the \"\n \"source_box_extent of the root table must \"\n \"divide the bounding box's extent by an integer.\"\n )\n\n if not isinstance(self.n_tables, dict) and self.n_tables > 1:\n # this checks that the boxes at the highest level are covered\n if (\n not tree.nlevels\n <= len(self.near_field_table[kname]) + table_starting_level\n ):\n raise RuntimeError(\n \"Insufficient list of tables: the \"\n \"finest level mesh cells at level \"\n + str(tree.nlevels)\n + \" are not covered.\"\n )\n\n # the check that the boxes at the coarsest level are covered is\n # deferred until trav.target_boxes is passed when invoking\n # eval_direct\n\n self.dtype = dtype\n\n if source_extra_kwargs is None:\n source_extra_kwargs = {}\n\n if kernel_extra_kwargs is None:\n kernel_extra_kwargs = {}\n\n if self_extra_kwargs is None:\n self_extra_kwargs = {}\n\n if list1_extra_kwargs is None:\n list1_extra_kwargs = {}\n\n if not callable(fmm_level_to_order):\n raise TypeError(\"fmm_level_to_order not passed\")\n\n base_kernel = code_container.get_base_kernel()\n kernel_arg_set = frozenset(kernel_extra_kwargs.items())\n self.level_orders = [\n fmm_level_to_order(base_kernel, kernel_arg_set, tree, lev)\n for lev in range(tree.nlevels)\n ]\n\n # print(\"Multipole order = \",self.level_orders)\n\n self.source_extra_kwargs = source_extra_kwargs\n self.kernel_extra_kwargs = kernel_extra_kwargs\n self.self_extra_kwargs = self_extra_kwargs\n self.list1_extra_kwargs = list1_extra_kwargs\n\n self.extra_kwargs = source_extra_kwargs.copy()\n self.extra_kwargs.update(self.kernel_extra_kwargs)\n\n # }}} End constructor\n\n # {{{ data vector utilities\n\n def multipole_expansion_zeros(self):\n return SumpyExpansionWrangler.multipole_expansion_zeros(self)\n\n def local_expansion_zeros(self):\n return SumpyExpansionWrangler.local_expansion_zeros(self)\n\n def output_zeros(self):\n return SumpyExpansionWrangler.output_zeros(self)\n\n def reorder_sources(self, source_array):\n return SumpyExpansionWrangler.reorder_sources(self, source_array)\n\n def reorder_targets(self, target_array):\n if not hasattr(self.tree, 'user_target_ids'):\n self.tree.user_target_ids = inverse_id_map(\n self.queue, self.tree.sorted_target_ids)\n return target_array.with_queue(self.queue)[self.tree.user_target_ids]\n\n def reorder_potentials(self, potentials):\n return SumpyExpansionWrangler.reorder_potentials(self, potentials)\n\n def finalize_potentials(self, potentials):\n # return potentials\n return SumpyExpansionWrangler.finalize_potentials(self, potentials)\n\n # }}} End data vector utilities\n\n # {{{ formation & coarsening of multipoles\n\n def form_multipoles(self, level_start_source_box_nrs, source_boxes, src_weights):\n return SumpyExpansionWrangler.form_multipoles(\n self, level_start_source_box_nrs, source_boxes, src_weights\n )\n\n def coarsen_multipoles(\n self, level_start_source_parent_box_nrs, source_parent_boxes, mpoles\n ):\n return SumpyExpansionWrangler.coarsen_multipoles(\n self, level_start_source_parent_box_nrs, source_parent_boxes, mpoles\n )\n\n # }}} End formation & coarsening of multipoles\n\n # {{{ direct evaluation of near field interactions\n\n def eval_direct_single_out_kernel(\n self,\n out_pot,\n out_kernel,\n target_boxes,\n neighbor_source_boxes_starts,\n neighbor_source_boxes_lists,\n mode_coefs,\n ):\n\n # NOTE: mode_coefs are similar to source_weights BUT\n # do not include quadrature weights (purely function\n # expansiona coefficients)\n\n if 0:\n print(\"Returns range for list1\")\n out_pot[:] = cl.array.to_device(self.queue, np.arange(len(out_pot)))\n return out_pot, None\n\n kname = out_kernel.__repr__()\n\n if isinstance(self.n_tables, int) and self.n_tables > 1:\n use_multilevel_tables = True\n elif isinstance(self.n_tables, dict) and self.n_tables[kname] > 1:\n use_multilevel_tables = True\n else:\n use_multilevel_tables = False\n\n if use_multilevel_tables:\n # this checks that the boxes at the coarsest level\n # and allows for some round-off error\n min_lev = np.min(\n self.tree.box_levels.get(self.queue)[target_boxes.get(self.queue)]\n )\n largest_cell_extent = self.tree.root_extent * 0.5 ** min_lev\n if not self.near_field_table[kname][0].source_box_extent >= (\n largest_cell_extent - 1e-15\n ):\n raise RuntimeError(\n \"Insufficient list of tables: the \"\n \"coarsest level mesh cells at level \"\n + str(min_lev)\n + \" are not covered.\"\n )\n\n # table.case_encode\n distinct_numbers = set()\n for vec in self.near_field_table[kname][0].interaction_case_vecs:\n for cvc in vec:\n distinct_numbers.add(cvc)\n base = len(range(min(distinct_numbers), max(distinct_numbers) + 1))\n shift = -min(distinct_numbers)\n\n case_indices_dev = cl.array.to_device(\n self.queue, self.near_field_table[kname][0].case_indices\n )\n\n # table.data\n table_data_combined = np.zeros(\n (\n len(self.near_field_table[kname]),\n len(self.near_field_table[kname][0].data),\n ), dtype=self.near_field_table[kname][0].data.dtype\n )\n mode_nmlz_combined = np.zeros(\n (\n len(self.near_field_table[kname]),\n len(self.near_field_table[kname][0].mode_normalizers),\n ), dtype=self.near_field_table[kname][0].mode_normalizers.dtype\n )\n exterior_mode_nmlz_combined = np.zeros(\n (\n len(self.near_field_table[kname]),\n len(self.near_field_table[kname][0].kernel_exterior_normalizers),\n ),\n dtype=self.near_field_table[kname][0].kernel_exterior_normalizers.dtype\n )\n for lev in range(len(self.near_field_table[kname])):\n table_data_combined[lev, :] = self.near_field_table[kname][lev].data\n mode_nmlz_combined[lev, :] = \\\n self.near_field_table[kname][lev].mode_normalizers\n exterior_mode_nmlz_combined[lev, :] = \\\n self.near_field_table[kname][lev].kernel_exterior_normalizers\n\n self.queue.finish()\n logger.info(\n \"table data for kernel \"\n + out_kernel.__repr__() + \" congregated\")\n\n # The loop domain needs to know some info about the tables being used\n table_data_shapes = {\n \"n_tables\": len(self.near_field_table[kname]),\n \"n_q_points\": self.near_field_table[kname][0].n_q_points,\n \"n_table_entries\": len(self.near_field_table[kname][0].data),\n }\n assert table_data_shapes[\"n_q_points\"] == len(\n self.near_field_table[kname][0].mode_normalizers\n )\n\n from volumential.list1 import NearFieldFromCSR\n\n near_field = NearFieldFromCSR(out_kernel, table_data_shapes,\n potential_kind=self.potential_kind,\n **self.list1_extra_kwargs)\n\n table_data_combined = cl.array.to_device(self.queue,\n table_data_combined)\n mode_nmlz_combined = cl.array.to_device(self.queue,\n mode_nmlz_combined)\n exterior_mode_nmlz_combined = cl.array.to_device(self.queue,\n exterior_mode_nmlz_combined)\n self.queue.finish()\n logger.info(\"sent table data to device\")\n\n # NOTE: box_sources for this evaluation should be \"box_targets\".\n # This is due to the special features of how box-FMM works.\n\n res, evt = near_field(\n self.queue,\n result=out_pot,\n box_centers=self.tree.box_centers,\n box_levels=self.tree.box_levels,\n box_source_counts_cumul=self.tree.box_target_counts_cumul,\n box_source_starts=self.tree.box_target_starts,\n box_target_counts_cumul=self.tree.box_target_counts_cumul,\n box_target_starts=self.tree.box_target_starts,\n case_indices=case_indices_dev,\n encoding_base=base,\n encoding_shift=shift,\n mode_nmlz_combined=mode_nmlz_combined,\n exterior_mode_nmlz_combined=exterior_mode_nmlz_combined,\n neighbor_source_boxes_starts=neighbor_source_boxes_starts,\n root_extent=self.tree.root_extent,\n neighbor_source_boxes_lists=neighbor_source_boxes_lists,\n mode_coefs=mode_coefs,\n table_data_combined=table_data_combined,\n target_boxes=target_boxes,\n table_root_extent=self.root_table_source_box_extent,\n )\n\n # print(near_field.get_kernel())\n # import pudb; pu.db\n\n assert res is out_pot\n\n # sorted_target_ids=self.tree.user_source_ids,\n # user_source_ids=self.tree.user_source_ids)\n\n # FIXME: lazy evaluation sometimes returns incorrect results\n res.finish()\n\n return out_pot, evt\n\n def eval_direct(\n self,\n target_boxes,\n neighbor_source_boxes_starts,\n neighbor_source_boxes_lists,\n mode_coefs,\n ):\n pot = self.output_zeros()\n events = []\n for i in range(len(self.code.target_kernels)):\n # print(\"processing near-field of out_kernel\", i)\n pot[i], evt = self.eval_direct_single_out_kernel(\n pot[i],\n self.code.target_kernels[i],\n target_boxes,\n neighbor_source_boxes_starts,\n neighbor_source_boxes_lists,\n mode_coefs,\n )\n events.append(evt)\n\n for out_pot in pot:\n out_pot.finish()\n\n return (pot, SumpyTimingFuture(self.queue, events))\n\n # }}} End direct evaluation of near field interactions\n\n # {{{ downward pass of fmm\n\n def multipole_to_local(\n self,\n level_start_target_box_nrs,\n target_boxes,\n src_box_starts,\n src_box_lists,\n mpole_exps,\n ):\n return SumpyExpansionWrangler.multipole_to_local(\n self,\n level_start_target_box_nrs,\n target_boxes,\n src_box_starts,\n src_box_lists,\n mpole_exps,\n )\n\n def eval_multipoles(\n self, target_boxes_by_source_level, source_boxes_by_level, mpole_exps\n ):\n return SumpyExpansionWrangler.eval_multipoles(\n self, target_boxes_by_source_level, source_boxes_by_level, mpole_exps\n )\n\n def form_locals(\n self,\n level_start_target_or_target_parent_box_nrs,\n target_or_target_parent_boxes,\n starts,\n lists,\n src_weights,\n ):\n return SumpyExpansionWrangler.form_locals(\n self,\n level_start_target_or_target_parent_box_nrs,\n target_or_target_parent_boxes,\n starts,\n lists,\n src_weights,\n )\n\n def refine_locals(\n self,\n level_start_target_or_target_parent_box_nrs,\n target_or_target_parent_boxes,\n local_exps,\n ):\n return SumpyExpansionWrangler.refine_locals(\n self,\n level_start_target_or_target_parent_box_nrs,\n target_or_target_parent_boxes,\n local_exps,\n )\n\n def eval_locals(self, level_start_target_box_nrs, target_boxes, local_exps):\n return SumpyExpansionWrangler.eval_locals(\n self, level_start_target_box_nrs, target_boxes, local_exps\n )\n\n # }}} End downward pass of fmm\n\n # {{{ direct evaluation of p2p (discrete) interactions\n\n def eval_direct_p2p(\n self, target_boxes, source_box_starts, source_box_lists, src_weights\n ):\n return SumpyExpansionWrangler.eval_direct(\n self, target_boxes, source_box_starts, source_box_lists, src_weights\n )\n\n # }}} End direct evaluation of p2p interactions\n\n# }}} End sumpy backend\n\n# {{{ fmmlib backend (for laplace, helmholtz)\n\n\nclass FPNDFMMLibExpansionWranglerCodeContainer(\n ExpansionWranglerCodeContainerInterface,\n ):\n \"\"\"Objects of this type serve as a place to keep the code needed\n for ExpansionWrangler if it is using fmmlib to perform multipole\n expansion and manipulations.\n\n The interface is augmented with unecessary arguments acting as\n placeholders, such that it can be a drop-in replacement of sumpy\n backend.\n \"\"\"\n def __init__(self, cl_context,\n multipole_expansion_factory, local_expansion_factory,\n target_kernels, exclude_self=True, *args, **kwargs):\n self.cl_context = cl_context\n self.multipole_expansion_factory = multipole_expansion_factory\n self.local_expansion_factory = local_expansion_factory\n\n self.target_kernels = target_kernels\n self.exclude_self = True\n\n def get_wrangler(self, queue, tree, dtype, fmm_level_to_order,\n source_extra_kwargs={}, kernel_extra_kwargs=None,\n *args, **kwargs):\n return FPNDFMMLibExpansionWrangler(self, queue, tree,\n dtype, fmm_level_to_order,\n source_extra_kwargs, kernel_extra_kwargs,\n *args, **kwargs)\n\n\nclass FPNDFMMLibExpansionWrangler(\n ExpansionWranglerInterface, FMMLibExpansionWrangler):\n \"\"\"This expansion wrangler uses \"fpnd\" strategy. That is, Far field is\n computed via Particle approximation and Near field is computed Directly.\n The FMM is performed using FMMLib backend.\n\n .. attribute:: source_extra_kwargs\n\n Keyword arguments to be passed to interactions that involve\n the source field.\n\n .. attribute:: kernel_extra_kwargs\n\n Keyword arguments to be passed to interactions that involve\n expansions, but not the source field.\n\n Much of this class is borrowed from pytential.qbx.fmmlib.\n \"\"\"\n # {{{ constructor\n\n def __init__(self, code_container, queue, tree,\n near_field_table, dtype,\n fmm_level_to_order,\n quad_order,\n potential_kind=1,\n source_extra_kwargs=None,\n kernel_extra_kwargs=None,\n self_extra_kwargs=None,\n list1_extra_kwargs=None,\n *args, **kwargs):\n self.code = code_container\n self.queue = queue\n\n tree = tree.get(queue)\n self.tree = tree\n\n self.dtype = dtype\n self.quad_order = quad_order\n self.potential_kind = potential_kind\n\n # {{{ digest target_kernels\n\n ifgrad = False\n outputs = []\n source_deriv_names = []\n k_names = []\n\n for out_knl in self.code.target_kernels:\n\n if self.is_supported_helmknl(out_knl):\n outputs.append(())\n no_target_deriv_knl = out_knl\n\n elif (isinstance(out_knl, AxisTargetDerivative)\n and self.is_supported_helmknl(out_knl.inner_kernel)):\n outputs.append((out_knl.axis,))\n ifgrad = True\n no_target_deriv_knl = out_knl.inner_kernel\n\n else:\n raise ValueError(\n \"only the 2/3D Laplace and Helmholtz kernel \"\n \"and their derivatives are supported\")\n\n source_deriv_names.append(no_target_deriv_knl.dir_vec_name\n if isinstance(no_target_deriv_knl, DirectionalSourceDerivative)\n else None)\n\n base_knl = out_knl.get_base_kernel()\n k_names.append(base_knl.helmholtz_k_name\n if isinstance(base_knl, HelmholtzKernel)\n else None)\n\n self.outputs = outputs\n\n from pytools import is_single_valued\n\n if not is_single_valued(source_deriv_names):\n raise ValueError(\"not all kernels passed are the same in \"\n \"whether they represent a source derivative\")\n\n source_deriv_name = source_deriv_names[0]\n\n if not is_single_valued(k_names):\n raise ValueError(\"not all kernels passed have the same \"\n \"Helmholtz parameter\")\n\n k_name = k_names[0]\n\n if k_name is None:\n helmholtz_k = 0\n else:\n helmholtz_k = kernel_extra_kwargs[k_name]\n\n # }}}\n\n # {{{ table setup\n # TODO put this part into the inteferce class\n\n self.near_field_table = {}\n # list of tables for a single out kernel\n if isinstance(near_field_table, list):\n assert len(self.code.target_kernels) == 1\n self.near_field_table[\n self.code.target_kernels[0].__repr__()\n ] = near_field_table\n self.n_tables = len(near_field_table)\n\n # single table\n elif isinstance(near_field_table, NearFieldInteractionTable):\n assert len(self.code.target_kernels) == 1\n self.near_field_table[self.code.target_kernels[0].__repr__()] = [\n near_field_table\n ]\n self.n_tables = 1\n\n # dictionary of lists of tables\n elif isinstance(near_field_table, dict):\n self.n_tables = dict()\n for out_knl in self.code.target_kernels:\n if repr(out_knl) not in near_field_table:\n raise RuntimeError(\n \"Missing nearfield table for %s.\" % repr(out_knl))\n if isinstance(near_field_table[repr(out_knl)],\n NearFieldInteractionTable):\n near_field_table[repr(out_knl)] = [\n near_field_table[repr(out_knl)]]\n else:\n assert isinstance(near_field_table[repr(out_knl)], list)\n\n self.n_tables[repr(out_knl)] = len(near_field_table[repr(out_knl)])\n\n self.near_field_table = near_field_table\n else:\n raise RuntimeError(\"Table type unrecognized.\")\n\n # TODO: make all parameters table-specific (allow using inhomogeneous tables)\n kname = repr(self.code.target_kernels[0])\n self.root_table_source_box_extent = (\n self.near_field_table[kname][0].source_box_extent)\n table_starting_level = np.round(\n np.log(self.tree.root_extent / self.root_table_source_box_extent)\n / np.log(2)\n )\n for kid in range(len(self.code.target_kernels)):\n kname = self.code.target_kernels[kid].__repr__()\n for lev, table in zip(\n range(len(self.near_field_table[kname])),\n self.near_field_table[kname]\n ):\n assert table.quad_order == self.quad_order\n\n if not table.is_built:\n raise RuntimeError(\n \"Near field interaction table needs to be built \"\n \"prior to being used\"\n )\n\n table_root_extent = table.source_box_extent * 2 ** lev\n assert (\n abs(self.root_table_source_box_extent - table_root_extent)\n < 1e-15\n )\n\n # If the kernel cannot be scaled,\n # - tree_root_extent must be integral times of table_root_extent\n # - n_tables must be sufficient\n if not isinstance(self.n_tables, dict) and self.n_tables > 1:\n if (\n not abs(\n int(self.tree.root_extent / table_root_extent)\n * table_root_extent\n - self.tree.root_extent\n )\n < 1e-15\n ):\n raise RuntimeError(\n \"Incompatible list of tables: the \"\n \"source_box_extent of the root table must \"\n \"divide the bounding box's extent by an integer.\"\n )\n\n if not isinstance(self.n_tables, dict) and self.n_tables > 1:\n # this checks that the boxes at the highest level are covered\n if (\n not tree.nlevels\n <= len(self.near_field_table[kname]) + table_starting_level\n ):\n raise RuntimeError(\n \"Insufficient list of tables: the \"\n \"finest level mesh cells at level \"\n + str(tree.nlevels)\n + \" are not covered.\"\n )\n\n # the check that the boxes at the coarsest level are covered is\n # deferred until trav.target_boxes is passed when invoking\n # eval_direct\n\n if source_extra_kwargs is None:\n source_extra_kwargs = {}\n\n if kernel_extra_kwargs is None:\n kernel_extra_kwargs = {}\n\n if self_extra_kwargs is None:\n self_extra_kwargs = {}\n\n if list1_extra_kwargs is None:\n list1_extra_kwargs = {}\n\n self.list1_extra_kwargs = list1_extra_kwargs\n\n # }}} End table setup\n\n if not callable(fmm_level_to_order):\n raise TypeError(\"fmm_level_to_order not passed\")\n\n dipole_vec = None\n if source_deriv_name is not None:\n dipole_vec = np.array([\n d_i.get(queue=queue)\n for d_i in source_extra_kwargs[source_deriv_name]],\n order=\"F\")\n\n def inner_fmm_level_to_nterms(tree, level):\n if helmholtz_k == 0:\n return fmm_level_to_order(\n LaplaceKernel(tree.dimensions),\n frozenset(), tree, level)\n else:\n return fmm_level_to_order(\n HelmholtzKernel(tree.dimensions),\n frozenset([(\"k\", helmholtz_k)]), tree, level)\n\n rotation_data = None\n if 'traversal' in kwargs:\n # add rotation data if traversal is passed as a keyword argument\n from boxtree.pyfmmlib_integration import FMMLibRotationData\n rotation_data = FMMLibRotationData(self.queue, kwargs['traversal'])\n else:\n logger.warning(\"Rotation data is not utilized since traversal is \"\n \"not known to FPNDFMMLibExpansionWrangler.\")\n\n FMMLibExpansionWrangler.__init__(\n self, tree,\n\n helmholtz_k=helmholtz_k,\n dipole_vec=dipole_vec,\n dipoles_already_reordered=True,\n\n fmm_level_to_nterms=inner_fmm_level_to_nterms,\n rotation_data=rotation_data,\n\n ifgrad=ifgrad)\n\n # }}} End constructor\n\n# {{{ scale factor for fmmlib\n\n def get_scale_factor(self):\n if self.eqn_letter == \"l\" and self.dim == 2:\n scale_factor = -1/(2*np.pi)\n elif self.eqn_letter == \"h\" and self.dim == 2:\n scale_factor = 1\n elif self.eqn_letter in [\"l\", \"h\"] and self.dim == 3:\n scale_factor = 1/(4*np.pi)\n else:\n raise NotImplementedError(\n \"scale factor for pyfmmlib %s for %d dimensions\" % (\n self.eqn_letter,\n self.dim))\n\n return scale_factor\n\n# }}} End scale factor for fmmlib\n\n # {{{ data vector utilities\n\n def multipole_expansion_zeros(self):\n return FMMLibExpansionWrangler.multipole_expansion_zeros(self)\n\n def local_expansion_zeros(self):\n return FMMLibExpansionWrangler.local_expansion_zeros(self)\n\n def output_zeros(self):\n return FMMLibExpansionWrangler.output_zeros(self)\n\n def reorder_sources(self, source_array):\n return FMMLibExpansionWrangler.reorder_sources(self, source_array)\n\n def reorder_targets(self, target_array):\n if not hasattr(self.tree, 'user_target_ids'):\n self.tree.user_target_ids = inverse_id_map(\n self.queue, self.tree.sorted_target_ids)\n return target_array[self.tree.user_target_ids]\n\n def reorder_potentials(self, potentials):\n return FMMLibExpansionWrangler.reorder_potentials(self, potentials)\n\n def finalize_potentials(self, potentials):\n # return potentials\n return FMMLibExpansionWrangler.finalize_potentials(self, potentials)\n\n # }}} End data vector utilities\n\n # {{{ formation & coarsening of multipoles\n\n def form_multipoles(self, level_start_source_box_nrs, source_boxes, src_weights):\n return FMMLibExpansionWrangler.form_multipoles(\n self, level_start_source_box_nrs, source_boxes, src_weights\n )\n\n def coarsen_multipoles(\n self, level_start_source_parent_box_nrs, source_parent_boxes, mpoles\n ):\n return FMMLibExpansionWrangler.coarsen_multipoles(\n self, level_start_source_parent_box_nrs, source_parent_boxes, mpoles\n )\n\n # }}} End formation & coarsening of multipoles\n\n # {{{ direct evaluation of near field interactions\n\n def eval_direct_single_out_kernel(\n self,\n out_pot,\n out_kernel,\n target_boxes,\n neighbor_source_boxes_starts,\n neighbor_source_boxes_lists,\n mode_coefs,\n ):\n\n # NOTE: mode_coefs are similar to source_weights BUT\n # do not include quadrature weights (purely function\n # expansiona coefficients)\n\n if 0:\n print(\"Returns range for list1\")\n out_pot[:] = np.arange(len(out_pot))\n return out_pot, None\n\n kname = out_kernel.__repr__()\n\n if isinstance(self.n_tables, int) and self.n_tables > 1:\n use_multilevel_tables = True\n elif isinstance(self.n_tables, dict) and self.n_tables[kname] > 1:\n use_multilevel_tables = True\n else:\n use_multilevel_tables = False\n\n if use_multilevel_tables:\n # this checks that the boxes at the coarsest level\n # and allows for some round-off error\n min_lev = np.min(\n self.tree.box_levels.get(self.queue)[target_boxes.get(self.queue)]\n )\n largest_cell_extent = self.tree.root_extent * 0.5 ** min_lev\n if not self.near_field_table[kname][0].source_box_extent >= (\n largest_cell_extent - 1e-15\n ):\n raise RuntimeError(\n \"Insufficient list of tables: the \"\n \"coarsest level mesh cells at level \"\n + str(min_lev)\n + \" are not covered.\"\n )\n\n # table.case_encode\n distinct_numbers = set()\n for vec in self.near_field_table[kname][0].interaction_case_vecs:\n for cvc in vec:\n distinct_numbers.add(cvc)\n base = len(range(min(distinct_numbers), max(distinct_numbers) + 1))\n shift = -min(distinct_numbers)\n\n case_indices_dev = cl.array.to_device(\n self.queue, self.near_field_table[kname][0].case_indices\n )\n\n # table.data\n table_data_combined = np.zeros(\n (\n len(self.near_field_table[kname]),\n len(self.near_field_table[kname][0].data),\n ), dtype=self.near_field_table[kname][0].data.dtype\n )\n mode_nmlz_combined = np.zeros(\n (\n len(self.near_field_table[kname]),\n len(self.near_field_table[kname][0].mode_normalizers),\n ), dtype=self.near_field_table[kname][0].mode_normalizers.dtype\n )\n for lev in range(len(self.near_field_table[kname])):\n table_data_combined[lev, :] = self.near_field_table[kname][lev].data\n mode_nmlz_combined[lev, :] = self.near_field_table[kname][\n lev\n ].mode_normalizers\n exterior_mode_nmlz_combined = np.zeros(\n (\n len(self.near_field_table[kname]),\n len(self.near_field_table[kname][0].kernel_exterior_normalizers),\n ),\n dtype=self.near_field_table[kname][0].kernel_exterior_normalizers.dtype\n )\n for lev in range(len(self.near_field_table[kname])):\n table_data_combined[lev, :] = self.near_field_table[kname][lev].data\n mode_nmlz_combined[lev, :] = \\\n self.near_field_table[kname][lev].mode_normalizers\n exterior_mode_nmlz_combined[lev, :] = \\\n self.near_field_table[kname][lev].kernel_exterior_normalizers\n\n logger.info(\n \"Table data for kernel \"\n + out_kernel.__repr__() + \" congregated\")\n\n # The loop domain needs to know some info about the tables being used\n table_data_shapes = {\n \"n_tables\": len(self.near_field_table[kname]),\n \"n_q_points\": self.near_field_table[kname][0].n_q_points,\n \"n_table_entries\": len(self.near_field_table[kname][0].data),\n }\n assert table_data_shapes[\"n_q_points\"] == len(\n self.near_field_table[kname][0].mode_normalizers\n )\n\n from volumential.list1 import NearFieldFromCSR\n\n near_field = NearFieldFromCSR(out_kernel, table_data_shapes,\n potential_kind=self.potential_kind,\n **self.list1_extra_kwargs)\n\n res, evt = near_field(\n self.queue,\n result=out_pot,\n box_centers=self.tree.box_centers,\n box_levels=self.tree.box_levels,\n box_source_counts_cumul=self.tree.box_target_counts_cumul,\n box_source_starts=self.tree.box_target_starts,\n box_target_counts_cumul=self.tree.box_target_counts_cumul,\n box_target_starts=self.tree.box_target_starts,\n case_indices=case_indices_dev,\n encoding_base=base,\n encoding_shift=shift,\n mode_nmlz_combined=mode_nmlz_combined,\n exterior_mode_nmlz_combined=exterior_mode_nmlz_combined,\n neighbor_source_boxes_starts=neighbor_source_boxes_starts,\n root_extent=self.tree.root_extent,\n neighbor_source_boxes_lists=neighbor_source_boxes_lists,\n mode_coefs=mode_coefs,\n table_data_combined=table_data_combined,\n target_boxes=target_boxes,\n table_root_extent=self.root_table_source_box_extent,\n )\n\n if isinstance(out_pot, cl.array.Array):\n assert res is out_pot\n # FIXME: lazy evaluation sometimes returns incorrect results\n res.finish()\n else:\n assert isinstance(out_pot, np.ndarray)\n out_pot = res\n\n # sorted_target_ids=self.tree.user_source_ids,\n # user_source_ids=self.tree.user_source_ids)\n\n scale_factor = self.get_scale_factor()\n return out_pot / scale_factor, evt\n\n def eval_direct(\n self,\n target_boxes,\n neighbor_source_boxes_starts,\n neighbor_source_boxes_lists,\n mode_coefs,\n ):\n pot = self.output_zeros()\n if pot.dtype != np.object:\n pot = make_obj_array([pot, ])\n events = []\n for i in range(len(self.code.target_kernels)):\n # print(\"processing near-field of out_kernel\", i)\n pot[i], evt = self.eval_direct_single_out_kernel(\n pot[i],\n self.code.target_kernels[i],\n target_boxes,\n neighbor_source_boxes_starts,\n neighbor_source_boxes_lists,\n mode_coefs,\n )\n events.append(evt)\n\n for out_pot in pot:\n if isinstance(out_pot, cl.array.Array):\n out_pot.finish()\n\n # boxtree.pyfmmlib_integration handles things diffferently\n # when target_kernels has only one element\n if len(pot) == 1:\n pot = pot[0]\n\n return (pot, SumpyTimingFuture(self.queue, events))\n\n # }}} End direct evaluation of near field interactions\n\n # {{{ downward pass of fmm\n\n def multipole_to_local(\n self,\n level_start_target_box_nrs,\n target_boxes,\n src_box_starts,\n src_box_lists,\n mpole_exps,\n ):\n return FMMLibExpansionWrangler.multipole_to_local(\n self,\n level_start_target_box_nrs,\n target_boxes,\n src_box_starts,\n src_box_lists,\n mpole_exps,\n )\n\n def eval_multipoles(\n self, target_boxes_by_source_level, source_boxes_by_level, mpole_exps\n ):\n return FMMLibExpansionWrangler.eval_multipoles(\n self, target_boxes_by_source_level, source_boxes_by_level, mpole_exps\n )\n\n def form_locals(\n self,\n level_start_target_or_target_parent_box_nrs,\n target_or_target_parent_boxes,\n starts,\n lists,\n src_weights,\n ):\n return FMMLibExpansionWrangler.form_locals(\n self,\n level_start_target_or_target_parent_box_nrs,\n target_or_target_parent_boxes,\n starts,\n lists,\n src_weights,\n )\n\n def refine_locals(\n self,\n level_start_target_or_target_parent_box_nrs,\n target_or_target_parent_boxes,\n local_exps,\n ):\n return FMMLibExpansionWrangler.refine_locals(\n self,\n level_start_target_or_target_parent_box_nrs,\n target_or_target_parent_boxes,\n local_exps,\n )\n\n def eval_locals(self, level_start_target_box_nrs, target_boxes, local_exps):\n return FMMLibExpansionWrangler.eval_locals(\n self, level_start_target_box_nrs, target_boxes, local_exps\n )\n\n # }}} End downward pass of fmm\n\n # {{{ direct evaluation of p2p (discrete) interactions\n\n def eval_direct_p2p(\n self, target_boxes, source_box_starts, source_box_lists, src_weights\n ):\n return FMMLibExpansionWrangler.eval_direct(\n self, target_boxes, source_box_starts, source_box_lists, src_weights\n )\n\n # }}} End direct evaluation of p2p interactions\n\n @staticmethod\n def is_supported_helmknl(knl):\n if isinstance(knl, DirectionalSourceDerivative):\n knl = knl.inner_kernel\n\n return (isinstance(knl, (LaplaceKernel, HelmholtzKernel))\n and knl.dim in (2, 3))\n\n\n# }}} End fmmlib backend (for laplace, helmholtz)\n\n\nclass FPNDExpansionWranglerCodeContainer(FPNDSumpyExpansionWranglerCodeContainer):\n \"\"\"The default code container.\n \"\"\"\n\n\nclass FPNDExpansionWrangler(FPNDSumpyExpansionWrangler):\n \"\"\"The default wrangler class.\n \"\"\"\n\n# vim: filetype=pyopencl:foldmethod=marker\n", "meta": {"hexsha": "b691f63f4d7edd57cb36c2dd68f229d47f2d88a6", "size": 43511, "ext": "py", "lang": "Python", "max_stars_repo_path": "volumential/expansion_wrangler_fpnd.py", "max_stars_repo_name": "xywei/volumential", "max_stars_repo_head_hexsha": "07c6ca8c623acf24fb8deddf93baa1035234db58", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2021-05-21T23:57:15.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-07T22:02:50.000Z", "max_issues_repo_path": "volumential/expansion_wrangler_fpnd.py", "max_issues_repo_name": "inducer/volumential", "max_issues_repo_head_hexsha": "290a5943d3f47958dcab6736bc2b758525471570", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-03-26T15:41:27.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-26T15:42:21.000Z", "max_forks_repo_path": "volumential/expansion_wrangler_fpnd.py", "max_forks_repo_name": "inducer/volumential", "max_forks_repo_head_hexsha": "290a5943d3f47958dcab6736bc2b758525471570", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-05-21T21:23:39.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-21T21:23:39.000Z", "avg_line_length": 35.8410214168, "max_line_length": 85, "alphanum_fraction": 0.6143503942, "include": true, "reason": "import numpy", "num_tokens": 9053, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5774953651858118, "lm_q2_score": 0.3415824860330003, "lm_q1q2_score": 0.19726230251270496}} {"text": "r\"\"\"Functions for spectator scattering corrections to $B\\to V\\ell^+\\ell^-$ decays.\n\nThis includes weak annihilation, chromomagnetic contributions, and light\nquark-loop spectator scattering.\n\"\"\"\n\nimport flavio\nimport numpy as np\nfrom flavio.classes import AuxiliaryQuantity, Implementation\nfrom flavio.physics.bdecays.common import meson_quark\nfrom flavio.physics.bdecays.wilsoncoefficients import wctot_dict\nfrom flavio.physics.common import conjugate_par, conjugate_wc, add_dict\nfrom flavio.config import config\n\n\n\n# Auxiliary quantities and implementations\n\n# function needed for the QCD factorization implementation (see qcdf.py)\ndef ha_qcdf_function(B, V):\n scale = config['renormalization scale']['bvll']\n label = meson_quark[(B,V)] + 'ee' # the lepton flavour is irrelevant here\n # as only dipole and 4-quark operators contribute!\n def function(wc_obj, par_dict, q2, cp_conjugate):\n par = par_dict.copy()\n if cp_conjugate:\n par = conjugate_par(par)\n wc = wctot_dict(wc_obj, label, scale, par)\n if cp_conjugate:\n wc = conjugate_wc(wc)\n return flavio.physics.bdecays.bvll.qcdf.helicity_amps_qcdf(q2, wc, par, B, V)\n return function\n\n# ... and the same for the interpolated version (see qcdf_interpolate.py)\ndef ha_qcdf_interpolate_function(B, V, contribution='all'):\n scale = config['renormalization scale']['bvll']\n def function(wc_obj, par_dict, q2, cp_conjugate):\n return flavio.physics.bdecays.bvll.qcdf_interpolate.helicity_amps_qcdf(q2, par_dict, B, V, cp_conjugate, contribution)\n return function\n\n# loop over hadronic transitions and lepton flavours\n# BTW, it is not necessary to loop over tau: for tautau final states, the minimum\n# q2=4*mtau**2 is so high that QCDF is not valid anymore anyway!\nfor had in [('B0','K*0'), ('B+','K*+'), ('B0','rho0'), ('B+','rho+'), ('Bs','phi'), ]:\n process = had[0] + '->' + had[1] + 'll' # e.g. B0->K*0mumu\n quantity = process + ' spectator scattering'\n a = AuxiliaryQuantity(name=quantity, arguments=['q2', 'cp_conjugate'])\n a.description = ('Contribution to ' + process + ' helicity amplitudes from'\n ' non-factorizable spectator scattering.')\n\n # Implementation: QCD factorization\n iname = process + ' QCDF'\n i = Implementation(name=iname, quantity=quantity,\n function=ha_qcdf_function(B=had[0], V=had[1]))\n i.set_description(\"QCD factorization\")\n\n # Implementation: interpolated QCD factorization\n iname = process + ' QCDF interpolated'\n i = Implementation(name=iname, quantity=quantity,\n function=ha_qcdf_interpolate_function(B=had[0], V=had[1]))\n i.set_description(\"Interpolated version of QCD factorization\")\n", "meta": {"hexsha": "184b0daa3e58653d7f742a83ccefb562276dd59f", "size": 2778, "ext": "py", "lang": "Python", "max_stars_repo_path": "flavio/physics/bdecays/bvll/nonfactorizable.py", "max_stars_repo_name": "Felicia56/flavio", "max_stars_repo_head_hexsha": "ea735bd8febbb961d249eddf338a4960c1fbee69", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 61, "max_stars_repo_stars_event_min_datetime": "2016-03-09T16:19:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T00:55:51.000Z", "max_issues_repo_path": "flavio/physics/bdecays/bvll/nonfactorizable.py", "max_issues_repo_name": "Felicia56/flavio", "max_issues_repo_head_hexsha": "ea735bd8febbb961d249eddf338a4960c1fbee69", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 167, "max_issues_repo_issues_event_min_datetime": "2016-03-15T15:25:57.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-27T22:19:22.000Z", "max_forks_repo_path": "flavio/physics/bdecays/bvll/nonfactorizable.py", "max_forks_repo_name": "Felicia56/flavio", "max_forks_repo_head_hexsha": "ea735bd8febbb961d249eddf338a4960c1fbee69", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 57, "max_forks_repo_forks_event_min_datetime": "2016-03-15T14:24:23.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-14T01:00:03.000Z", "avg_line_length": 44.8064516129, "max_line_length": 126, "alphanum_fraction": 0.6958243341, "include": true, "reason": "import numpy", "num_tokens": 730, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5273165233795671, "lm_q2_score": 0.3738758367247085, "lm_q1q2_score": 0.19715090639729996}} {"text": "# Copyright 2021 Huawei Technologies Co., Ltd\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Visualization of the results 3D VTK form\"\"\"\n\nimport os\nfrom pyevtk.hl import gridToVTK\nimport numpy as np\n\n\ndef vtk_structure(grid_tensor, eh_tensor, path_res):\n r\"\"\"\n Generates 3D vtk file for visualizaiton.\n\n Args:\n grid_tensor (numpy.ndarray): grid data (shape: (dim_t, dim_x, dim_y, dim_z, 4)).\n eh_tensor (numpy.ndarray): electric and magnetic data (np.array, shape: (dim_t, dim_x, dim_y, dim_z, 6)).\n path_res (str): save path for the output vtk file.\n\n Supported Platforms:\n ``Ascend``\n\n Examples:\n >>> import numpy as np\n >>> from mindelec.vision import vtk_structure\n >>> grid_tensor = np.random.rand(20, 10, 10, 10, 4).astype(np.float32)\n >>> eh_tensor = np.random.rand(20, 10, 10, 10, 6).astype(np.float32)\n >>> path_res = './result_vtk'\n >>> vtk_structure(grid_tensor, eh_tensor, path_res)\n \"\"\"\n if not isinstance(grid_tensor, np.ndarray):\n raise TypeError(\"The type of grid_tensor should be numpy array, but get {}\".format(type(grid_tensor)))\n\n if not isinstance(eh_tensor, np.ndarray):\n raise TypeError(\"The type of eh_tensor should be numpy array, but get {}\".format(type(eh_tensor)))\n\n if not isinstance(path_res, str):\n raise TypeError(\"The type of path_res should be str, but get {}\".format(type(path_res)))\n if not os.path.exists(path_res):\n os.makedirs(path_res)\n\n input_grid = grid_tensor\n output_grid = eh_tensor\n\n shape_grid = input_grid.shape\n shape_eh = output_grid.shape\n\n if len(shape_grid) != 5 or shape_grid[-1] != 4:\n raise ValueError(\"grid_tensor shape should be (dim_t, dim_x, dim_y, dim_z, 4), but get {}\"\n .format(shape_grid))\n\n if len(shape_eh) != 5 or shape_eh[-1] != 6:\n raise ValueError(\"eh_tensor shape should be (dim_t, dim_x, dim_y, dim_z, 6), but get {}\"\n .format(shape_eh))\n\n if shape_grid[:4] != shape_eh[:4]:\n raise ValueError(\"grid_tensor and eh_tensor should have the same dimension except the last axis, \"\n \"but get grid_tensor shape {} and eh_tensor shape{}\".format(shape_grid, shape_eh))\n\n (dim_t, dim_x, dim_y, dim_z, d) = input_grid.shape\n input_grid = np.reshape(input_grid, (dim_t * dim_x * dim_y * dim_z, d))\n x_min, x_max = np.min(input_grid[:, 0]), np.max(input_grid[:, 0])\n y_min, y_max = np.min(input_grid[:, 1]), np.max(input_grid[:, 1])\n z_min, z_max = np.min(input_grid[:, 2]), np.max(input_grid[:, 2])\n\n x_all = np.linspace(x_min, x_max, dim_x, endpoint=True, dtype='float64')\n y_all = np.linspace(y_min, y_max, dim_y, endpoint=True, dtype='float64')\n z_all = np.linspace(z_min, z_max, dim_z, endpoint=True, dtype='float64')\n\n x = np.zeros((dim_x, dim_y, dim_z))\n y = np.zeros((dim_x, dim_y, dim_z))\n z = np.zeros((dim_x, dim_y, dim_z))\n\n for i in range(dim_x):\n for j in range(dim_y):\n for k in range(dim_z):\n x[i, j, k] = x_all[i]\n y[i, j, k] = y_all[j]\n z[i, j, k] = z_all[k]\n\n for t in range(dim_t):\n output_grid_show = output_grid[t]\n ex, ey, ez = output_grid_show[:, :, :, 0], output_grid_show[:, :, :, 1], output_grid_show[:, :, :, 2]\n hx, hy, hz = output_grid_show[:, :, :, 3], output_grid_show[:, :, :, 4], output_grid_show[:, :, :, 5]\n ex, ey, ez = ex.astype(np.float64), ey.astype(np.float64), ez.astype(np.float64)\n hx, hy, hz = hx.astype(np.float64), hy.astype(np.float64), hz.astype(np.float64)\n gridToVTK(os.path.join(path_res, 'eh_t' + str(t)),\n x, y, z,\n pointData={\"Ex\": ex, \"Ey\": ey, \"Ez\": ez, \"Hx\": hx, \"Hy\": hy, \"Hz\": hz})\n", "meta": {"hexsha": "5051d730136f433055017c062dd64c2887a625ba", "size": 4399, "ext": "py", "lang": "Python", "max_stars_repo_path": "MindElec/mindelec/vision/body.py", "max_stars_repo_name": "mindspore-ai/mindscience", "max_stars_repo_head_hexsha": "b5269245915695de2d99fb290fef662c241db189", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-11-10T06:17:50.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-21T14:25:30.000Z", "max_issues_repo_path": "MindElec/mindelec/vision/body.py", "max_issues_repo_name": "mindspore-ai/mindscience", "max_issues_repo_head_hexsha": "b5269245915695de2d99fb290fef662c241db189", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "MindElec/mindelec/vision/body.py", "max_forks_repo_name": "mindspore-ai/mindscience", "max_forks_repo_head_hexsha": "b5269245915695de2d99fb290fef662c241db189", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-12-05T11:41:29.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-05T11:41:29.000Z", "avg_line_length": 43.5544554455, "max_line_length": 113, "alphanum_fraction": 0.6180950216, "include": true, "reason": "import numpy", "num_tokens": 1182, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5273165382362518, "lm_q2_score": 0.3738758227716966, "lm_q1q2_score": 0.19715090459420145}} {"text": "\"\"\"\nrun_crack_lotf.py\nScript to run LOTF molecular dynamics for a crack slab,\nincrementing the load in small steps until fracture starts.\nJames Kermode \nFebruary 2013\n\"\"\"\nimport numpy as np\n\nfrom ase.constraints import FixAtoms\nfrom ase.md.verlet import VelocityVerlet\nfrom ase.md.velocitydistribution import MaxwellBoltzmannDistribution\nimport ase.units as units\n\nfrom quippy import set_fortran_indexing\nfrom quippy.atoms import Atoms\nfrom quippy.potential import Potential\nfrom quippy.io import AtomsWriter\n\nfrom quippy.crack import (get_strain,\n get_energy_release_rate,\n ConstantStrainRate,\n find_crack_tip_stress_field)\n\n# additional requirements for the QM/MM simulation:\nfrom quippy.potential import ForceMixingPotential\nfrom quippy.lotf import LOTFDynamics, update_hysteretic_qm_region\n\n\n# ******* Start of parameters ***********\n\ninput_file = 'crack.xyz' # File from which to read crack slab structure\nsim_T = 300.0*units.kB # Simulation temperature\nnsteps = 1000000 # Total number of timesteps to run for\ntimestep = 1.0*units.fs # Timestep (NB: time base units are not fs!)\ncutoff_skin = 2.0*units.Ang # Amount by which potential cutoff is increased\n # for neighbour calculations\ntip_move_tol = 10.0 # Distance tip has to move before crack\n # is taken to be running\nstrain_rate = 1e-5*(1/units.fs) # Strain rate\ntraj_file = 'traj.xyz' # Trajectory output file (NetCDF or XYZ format)\ntraj_interval = 10 # Number of time steps between\n # writing output frames\nparam_file = 'params.xml' # Filename of XML file containing\n # potential parameters\nmm_init_args = 'IP SW' # Initialisation arguments for\n # classical potential\n\n# additional parameters for the QM/MM simulation:\nqm_init_args = 'TB DFTB' # Initialisation arguments for QM potential\nqm_inner_radius = 6.0*units.Ang # Inner hysteretic radius for QM region\nqm_outer_radius = 8.0*units.Ang # Inner hysteretic radius for QM region\nextrapolate_steps = 10 # Number of steps for predictor-corrector\n # interpolation and extrapolation\n\n# ******* End of parameters *************\n\nset_fortran_indexing(False)\n\n# ********** Read input file ************\n\nprint 'Loading atoms from file %s' % input_file\natoms = Atoms(input_file)\n\norig_height = atoms.info['OrigHeight']\norig_crack_pos = atoms.info['CrackPos'].copy()\n\n# ***** Setup constraints *******\n\ntop = atoms.positions[:, 1].max()\nbottom = atoms.positions[:, 1].min()\nleft = atoms.positions[:, 0].min()\nright = atoms.positions[:, 0].max()\n\n# fix atoms in the top and bottom rows\nfixed_mask = ((abs(atoms.positions[:, 1] - top) < 1.0) |\n (abs(atoms.positions[:, 1] - bottom) < 1.0))\nfix_atoms = FixAtoms(mask=fixed_mask)\nprint('Fixed %d atoms\\n' % fixed_mask.sum())\natoms.set_constraint([fix_atoms])\n\n# Increase epsilon_yy applied to all atoms at constant strain rate\nstrain_atoms = ConstantStrainRate(orig_height, strain_rate*timestep)\n\n# ******* Set up potentials and calculators ********\n\nmm_pot = Potential(mm_init_args,\n param_filename=param_file,\n cutoff_skin=cutoff_skin)\n\n# Density functional tight binding (DFTB) potential\nqm_pot = Potential(qm_init_args,\n param_filename=param_file)\n\n# Construct the QM/MM potential, which mixes QM and MM forces.\n# The qm_args_str parameters control how the QM calculation is carried out:\n# we use a single cluster, periodic in the z direction and terminated\n# with hydrogen atoms. The positions of the outer layer of buffer atoms\n# are not randomised.\nqmmm_pot = ForceMixingPotential(pot1=mm_pot,\n pot2=qm_pot,\n qm_args_str='single_cluster cluster_periodic_z carve_cluster '+\n 'terminate cluster_hopping=F randomise_buffer=F',\n fit_hops=4,\n lotf_spring_hops=3,\n hysteretic_buffer=True,\n hysteretic_buffer_inner_radius=7.0,\n hysteretic_buffer_outer_radius=9.0,\n cluster_hopping_nneighb_only=False,\n min_images_only=True)\n\n# Use the force mixing potential as the Atoms' calculator\natoms.set_calculator(qmmm_pot)\nqmmm_pot.atoms = atoms\n\n# *** Set up the initial QM region ****\n\nqm_list = update_hysteretic_qm_region(atoms, [], orig_crack_pos,\n qm_inner_radius, qm_outer_radius)\n\n# ********* Setup and run MD ***********\n\n# Set the initial temperature to 2*simT: it will then equilibriate to\n# simT, by the virial theorem\nMaxwellBoltzmannDistribution(atoms, 2.0*sim_T)\n\n# Initialise the dynamical system\ndynamics = LOTFDynamics(atoms, timestep, extrapolate_steps)\n\n# array to store time averaged stress field\navg_sigma = np.zeros((len(atoms), 3, 3))\n\n# Print some information every time step\ndef printstatus():\n if dynamics.nsteps == 1:\n print \"\"\"\nState Time/fs Temp/K Strain G/(J/m^2) CrackPos/A D(CrackPos)/A\n---------------------------------------------------------------------------------\"\"\"\n\n log_format = ('%(label)-4s%(time)12.1f%(temperature)12.6f'+\n '%(strain)12.5f%(G)12.4f%(crack_pos_x)12.2f (%(d_crack_pos_x)+5.2f)')\n\n atoms.info['label'] = dynamics.state_label # Label for the status line\n atoms.info['time'] = dynamics.get_time()/units.fs\n atoms.info['temperature'] = (atoms.get_kinetic_energy() /\n (1.5*units.kB*len(atoms)))\n atoms.info['strain'] = get_strain(atoms)\n atoms.info['G'] = get_energy_release_rate(atoms)/(units.J/units.m**2)\n\n crack_pos = find_crack_tip_stress_field(atoms, calc=mm_pot,\n avg_sigma=avg_sigma)\n atoms.info['crack_pos_x'] = crack_pos[0]\n atoms.info['d_crack_pos_x'] = crack_pos[0] - orig_crack_pos[0]\n\n print log_format % atoms.info\n\ndynamics.attach(printstatus)\n\ndef atom_straining(atoms):\n crack_pos = find_crack_tip_stress_field(atoms, calc=mm_pot,\n avg_sigma=avg_sigma)\n # keep straining until the crack tip has advanced to tip_move_tol\n if not atoms.info['is_cracked'] and (crack_pos[0] - orig_crack_pos[0]) < tip_move_tol:\n strain_atoms.apply_strain(atoms)\n elif not atoms.info['is_cracked']:\n atoms.info['is_cracked'] = True\n\ndynamics.attach(atom_straining, 1, dynamics.atoms)\n\n# Function to update the QM region at the beginning of each extrapolation cycle\ndef update_qm_region(atoms):\n crack_pos = find_crack_tip_stress_field(atoms, calc=mm_pot,\n avg_sigma=avg_sigma)\n qm_list = qmmm_pot.get_qm_atoms(atoms)\n qm_list = update_hysteretic_qm_region(atoms, qm_list, crack_pos,\n qm_inner_radius, qm_outer_radius)\n qmmm_pot.set_qm_atoms(qm_list, atoms)\n #assert (atoms.hybrid == 1).sum() == len(qm_list)\n\ndynamics.set_qm_update_func(update_qm_region)\n\n\n# Save frames to the trajectory every `traj_interval` time steps\n# but only when interpolating\ntrajectory = AtomsWriter(traj_file)\n\ndef traj_writer(dynamics):\n if dynamics.state == LOTFDynamics.Interpolation:\n # copy time-averaged stress into Atoms so it will be written to trajectory file\n dynamics.atoms.set_array('avg_sigma', avg_sigma.reshape((len(atoms), 9)))\n trajectory.write(dynamics.atoms)\n\ndynamics.attach(traj_writer, traj_interval, dynamics)\n\n# Start running!\ndynamics.run(nsteps)\n", "meta": {"hexsha": "b4565469e9c4a2ed6d97a71eef4173eb83fad750", "size": 7912, "ext": "py", "lang": "Python", "max_stars_repo_path": "doc/Tutorials/run_crack_lotf.py", "max_stars_repo_name": "albapa/QUIP", "max_stars_repo_head_hexsha": "ecde1e332c6bd62c238d3cd90e31dba4fb390313", "max_stars_repo_licenses": ["NRL"], "max_stars_count": 229, "max_stars_repo_stars_event_min_datetime": "2015-01-20T16:35:59.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T10:44:32.000Z", "max_issues_repo_path": "doc/Tutorials/run_crack_lotf.py", "max_issues_repo_name": "albapa/QUIP", "max_issues_repo_head_hexsha": "ecde1e332c6bd62c238d3cd90e31dba4fb390313", "max_issues_repo_licenses": ["NRL"], "max_issues_count": 356, "max_issues_repo_issues_event_min_datetime": "2015-05-29T08:28:59.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T22:55:34.000Z", "max_forks_repo_path": "doc/Tutorials/run_crack_lotf.py", "max_forks_repo_name": "albapa/QUIP", "max_forks_repo_head_hexsha": "ecde1e332c6bd62c238d3cd90e31dba4fb390313", "max_forks_repo_licenses": ["NRL"], "max_forks_count": 106, "max_forks_repo_forks_event_min_datetime": "2015-01-21T12:56:29.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-25T08:39:24.000Z", "avg_line_length": 40.1624365482, "max_line_length": 95, "alphanum_fraction": 0.6449696663, "include": true, "reason": "import numpy", "num_tokens": 1876, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5273165085228825, "lm_q2_score": 0.3738758367247085, "lm_q1q2_score": 0.19715090084274456}} {"text": "# Copyright 2016-2020 Blue Marble Analytics LLC.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport csv\nimport os.path\nfrom pyomo.environ import Param, Set, NonNegativeReals, PercentFraction, Expression\n\n\ndef generic_add_model_components(\n m,\n d,\n reserve_zone_set,\n reserve_requirement_tmp_param,\n reserve_requirement_percent_param,\n reserve_zone_load_zone_set,\n ba_prj_req_contribution_set,\n prj_power_param,\n prj_capacity_param,\n reserve_requirement_expression,\n):\n \"\"\"\n :param m:\n :param d:\n :param reserve_zone_set:\n :param reserve_requirement_tmp_param:\n :param reserve_requirement_percent_param:\n :param reserve_zone_load_zone_set:\n :param ba_prj_req_contribution_set:\n :param prj_power_param:\n :param prj_capacity_param:\n :param reserve_requirement_expression:\n :return:\n\n Generic treatment of reserves. This function creates model components\n related to a particular reserve requirement, including\n 1) the reserve requirement by zone and timepoint, if any\n 2) the reserve requirement as a percent of load and map for which load\n zones' load to consider\n 3) the contributions to the reserve requirement from projects: there are two\n types of these contributions, those based on the power output in the timepoint\n and those based on the project capacity.\n \"\"\"\n\n # Magnitude of the requirement by reserve zone and timepoint\n # If not specified for a reserve zone - timepoint combination,\n # will default to 0\n setattr(\n m,\n reserve_requirement_tmp_param,\n Param(getattr(m, reserve_zone_set), m.TMPS, within=NonNegativeReals, default=0),\n )\n\n # Requirement as percentage of load\n setattr(\n m,\n reserve_requirement_percent_param,\n Param(getattr(m, reserve_zone_set), within=PercentFraction, default=0),\n )\n\n # Load zones included in the reserve percentage requirement\n setattr(\n m,\n reserve_zone_load_zone_set,\n Set(dimen=2, within=getattr(m, reserve_zone_set) * m.LOAD_ZONES),\n )\n\n # Projects contributing to BA requirement based on power output in the timepoint\n # and on capacity in the period\n setattr(\n m,\n ba_prj_req_contribution_set,\n Set(dimen=2, within=getattr(m, reserve_zone_set) * m.PROJECTS),\n )\n\n setattr(\n m,\n prj_power_param,\n Param(\n getattr(m, ba_prj_req_contribution_set), within=PercentFraction, default=0\n ),\n )\n\n setattr(\n m,\n prj_capacity_param,\n Param(\n getattr(m, ba_prj_req_contribution_set), within=PercentFraction, default=0\n ),\n )\n\n def reserve_requirement_rule(mod, reserve_zone, tmp):\n # If we have a map of reserve zones to load zones, apply the percentage\n # target; if no map provided, the percentage_target is 0\n if getattr(mod, reserve_zone_load_zone_set):\n percentage_target = sum(\n getattr(mod, reserve_requirement_percent_param)[reserve_zone]\n * mod.static_load_mw[lz, tmp]\n for (_reserve_zone, lz) in getattr(mod, reserve_zone_load_zone_set)\n if _reserve_zone == reserve_zone\n )\n else:\n percentage_target = 0\n\n # Project contributions, if any projects in the respective set\n if getattr(mod, ba_prj_req_contribution_set):\n # Project contributions to requirement based on power output\n prj_pwr_contribution = sum(\n getattr(mod, prj_power_param)[reserve_zone, prj]\n * mod.Power_Provision_MW[prj, tmp]\n for (_reserve_zone, prj) in getattr(mod, ba_prj_req_contribution_set)\n if _reserve_zone == reserve_zone\n if (prj, tmp) in mod.PRJ_OPR_TMPS\n )\n\n # Project contributions to requirement based on (available) capacity\n # We are not holding the extra reserves when projects are unavailable\n prj_cap_contribution = sum(\n getattr(mod, prj_capacity_param)[reserve_zone, prj]\n * mod.Capacity_MW[prj, mod.period[tmp]]\n * mod.Availability_Derate[prj, tmp]\n for (_reserve_zone, prj) in getattr(mod, ba_prj_req_contribution_set)\n if _reserve_zone == reserve_zone\n if (prj, tmp) in mod.PRJ_OPR_TMPS\n )\n else:\n prj_pwr_contribution = 0\n prj_cap_contribution = 0\n\n return (\n getattr(mod, reserve_requirement_tmp_param)[reserve_zone, tmp]\n + percentage_target\n + prj_pwr_contribution\n + prj_cap_contribution\n )\n\n setattr(\n m,\n reserve_requirement_expression,\n Expression(\n getattr(m, reserve_zone_set) * m.TMPS, rule=reserve_requirement_rule\n ),\n )\n\n\ndef generic_load_model_data(\n m,\n d,\n data_portal,\n scenario_directory,\n subproblem,\n stage,\n reserve_requirement_param,\n reserve_zone_load_zone_set,\n reserve_requirement_percent_param,\n ba_prj_req_contribution_set,\n prj_power_param,\n prj_capacity_param,\n reserve_type,\n):\n \"\"\"\n\n :param m:\n :param d:\n :param data_portal:\n :param scenario_directory:\n :param subproblem:\n :param stage:\n :param reserve_requirement_param:\n :param reserve_zone_load_zone_set:\n :param reserve_requirement_percent_param\n :param ba_prj_req_contribution_set\n :param prj_power_param\n :param prj_capacity_param\n :param reserve_type:\n :return:\n \"\"\"\n input_dir = os.path.join(scenario_directory, str(subproblem), str(stage), \"inputs\")\n\n # Load by-tmp requriement if input file was written\n by_tmp_req_filename = os.path.join(\n input_dir, \"{}_tmp_requirement.tab\".format(reserve_type)\n )\n if os.path.exists(by_tmp_req_filename):\n tmp_params_to_load = (\n (\n getattr(m, reserve_requirement_param),\n m.frequency_response_requirement_partial_mw,\n )\n if reserve_type == \"frequency_response\"\n else getattr(m, reserve_requirement_param)\n )\n data_portal.load(filename=by_tmp_req_filename, param=tmp_params_to_load)\n\n # If we have a RPS zone to load zone map input file, load it and the\n # percent requirement; otherwise, initialize the set as an empty list (\n # the param defaults to 0)\n map_filename = os.path.join(input_dir, \"{}_percent_map.tab\".format(reserve_type))\n if os.path.exists(map_filename):\n data_portal.load(\n filename=map_filename, set=getattr(m, reserve_zone_load_zone_set)\n )\n data_portal.load(\n filename=os.path.join(\n input_dir, \"{}_percent_requirement.tab\".format(reserve_type)\n ),\n param=getattr(m, reserve_requirement_percent_param),\n )\n else:\n data_portal.data()[reserve_zone_load_zone_set] = {None: []}\n\n # If we have a project contributions file, load it into the respective\n prj_contr_filename = os.path.join(\n input_dir, \"{}_requirement_project_contributions.tab\".format(reserve_type)\n )\n if os.path.exists(prj_contr_filename):\n data_portal.load(\n filename=prj_contr_filename,\n index=getattr(m, ba_prj_req_contribution_set),\n param=(getattr(m, prj_power_param), getattr(m, prj_capacity_param)),\n )\n else:\n data_portal.data()[ba_prj_req_contribution_set] = {None: []}\n\n\ndef generic_get_inputs_from_database(\n scenario_id,\n subscenarios,\n subproblem,\n stage,\n conn,\n reserve_type,\n reserve_type_ba_subscenario_id,\n reserve_type_req_subscenario_id,\n):\n \"\"\"\n :param subscenarios:\n :param subproblem:\n :param stage:\n :param conn:\n :param reserve_type:\n :param reserve_type_ba_subscenario_id:\n :param reserve_type_req_subscenario_id:\n :return:\n \"\"\"\n subproblem = 1 if subproblem == \"\" else subproblem\n stage = 1 if stage == \"\" else stage\n c = conn.cursor()\n\n partial_freq_resp_extra_column = (\n \", frequency_response_partial_mw\"\n if reserve_type == \"frequency_response\"\n else \"\"\n )\n\n tmp_req = c.execute(\n \"\"\"SELECT {}_ba, timepoint, {}_mw{}\n FROM inputs_system_{}\n INNER JOIN\n (SELECT timepoint\n FROM inputs_temporal\n WHERE temporal_scenario_id = {}\n AND subproblem_id = {}\n AND stage_id = {}) as relevant_timepoints\n USING (timepoint)\n INNER JOIN\n (SELECT {}_ba\n FROM inputs_geography_{}_bas\n WHERE {}_ba_scenario_id = {}) as relevant_bas\n USING ({}_ba)\n WHERE {}_scenario_id = {}\n AND stage_id = {}\n \"\"\".format(\n reserve_type,\n reserve_type,\n partial_freq_resp_extra_column,\n reserve_type,\n subscenarios.TEMPORAL_SCENARIO_ID,\n subproblem,\n stage,\n reserve_type,\n reserve_type,\n reserve_type,\n reserve_type_ba_subscenario_id,\n reserve_type,\n reserve_type,\n reserve_type_req_subscenario_id,\n stage,\n )\n )\n\n c2 = conn.cursor()\n # Get any percentage requirement\n percentage_req = c2.execute(\n \"\"\"\n SELECT {}_ba, percent_load_req\n FROM inputs_system_{}_percent\n WHERE {}_scenario_id = {}\n \"\"\".format(\n reserve_type, reserve_type, reserve_type, reserve_type_req_subscenario_id\n )\n )\n\n # Get any reserve zone to load zone mapping for the percent target\n c3 = conn.cursor()\n lz_mapping = c3.execute(\n \"\"\"\n SELECT {}_ba, load_zone\n FROM inputs_system_{}_percent_lz_map\n JOIN\n (SELECT {}_ba\n FROM inputs_geography_{}_bas\n WHERE {}_ba_scenario_id = {}) as relevant_bas\n USING ({}_ba)\n WHERE {}_scenario_id = {}\n \"\"\".format(\n reserve_type,\n reserve_type,\n reserve_type,\n reserve_type,\n reserve_type,\n reserve_type_ba_subscenario_id,\n reserve_type,\n reserve_type,\n reserve_type_req_subscenario_id,\n )\n )\n\n # Get any project contributions to the magnitude of the reserve requirement\n c4 = conn.cursor()\n project_contributions = c4.execute(\n \"\"\"\n SELECT {reserve_type}_ba, project, percent_power_req, percent_capacity_req\n FROM inputs_system_{reserve_type}_project\n JOIN (\n SELECT {reserve_type}_ba\n FROM inputs_geography_{reserve_type}_bas\n WHERE {reserve_type}_ba_scenario_id = {reserve_type_ba_subscenario_id}\n ) as relevant_bas\n USING ({reserve_type}_ba)\n JOIN (\n SELECT project\n FROM inputs_project_portfolios\n WHERE project_portfolio_scenario_id = (\n SELECT project_portfolio_scenario_id\n FROM scenarios\n WHERE scenario_id = {scenario_id}\n )\n ) as relevant_prj\n USING (project)\n WHERE {reserve_type}_scenario_id = {reserve_type_req_subscenario_id}\n \"\"\".format(\n reserve_type=reserve_type,\n reserve_type_ba_subscenario_id=reserve_type_ba_subscenario_id,\n scenario_id=scenario_id,\n reserve_type_req_subscenario_id=reserve_type_req_subscenario_id,\n )\n )\n\n return tmp_req, percentage_req, lz_mapping, project_contributions\n\n\ndef generic_write_model_inputs(\n scenario_directory,\n subproblem,\n stage,\n timepoint_req,\n percent_req,\n percent_map,\n project_contributions,\n reserve_type,\n):\n \"\"\"\n Get inputs from database and write out the model input\n lf_reserves_down_requirement.tab file.\n :param scenario_directory: string, the scenario directory\n :param subproblem:\n :param stage:\n :param timepoint_req:\n :param percent_req:\n :param percent_map:\n :param project_contributions:\n :param reserve_type:\n :return:\n \"\"\"\n inputs_dir = os.path.join(scenario_directory, str(subproblem), str(stage), \"inputs\")\n\n # Write the by-timepoint requirement file if by-tmp requirement specified\n timepoint_req = timepoint_req.fetchall()\n if timepoint_req:\n with open(\n os.path.join(inputs_dir, \"{}_tmp_requirement.tab\".format(reserve_type)),\n \"w\",\n newline=\"\",\n ) as tmp_req_file:\n writer = csv.writer(tmp_req_file, delimiter=\"\\t\", lineterminator=\"\\n\")\n\n # Write header\n extra_column = (\n [\"partial_requirement\"] if reserve_type == \"frequency_response\" else []\n )\n writer.writerow([\"ba\", \"timepoint\", \"requirement\"] + extra_column)\n\n for row in timepoint_req:\n writer.writerow(row)\n\n # Write the percent requirement files only if there's a mapping\n ba_lz_map_list = [row for row in percent_map]\n\n if ba_lz_map_list:\n with open(\n os.path.join(inputs_dir, \"{}_percent_requirement.tab\".format(reserve_type)),\n \"w\",\n newline=\"\",\n ) as percent_req_file:\n writer = csv.writer(percent_req_file, delimiter=\"\\t\", lineterminator=\"\\n\")\n\n # Write header\n writer.writerow([\"ba\", \"percent_requirement\"])\n\n for row in percent_req:\n writer.writerow(row)\n\n with open(\n os.path.join(inputs_dir, \"{}_percent_map.tab\".format(reserve_type)),\n \"w\",\n newline=\"\",\n ) as percent_map_file:\n writer = csv.writer(percent_map_file, delimiter=\"\\t\", lineterminator=\"\\n\")\n\n # Write header\n writer.writerow([\"ba\", \"load_zone\"])\n\n for row in ba_lz_map_list:\n writer.writerow(row)\n else:\n pass\n\n # Project contributions to the magnitude requirement\n project_contributions = project_contributions.fetchall()\n\n prj_contributions = False\n for (ba, prj, pwr, cap) in project_contributions:\n if pwr is not None or cap is not None:\n prj_contributions = True\n\n if prj_contributions:\n with open(\n os.path.join(\n inputs_dir,\n \"{}_requirement_project_contributions.tab\".format(reserve_type),\n ),\n \"w\",\n newline=\"\",\n ) as prj_file:\n writer = csv.writer(prj_file, delimiter=\"\\t\", lineterminator=\"\\n\")\n\n # Write header\n writer.writerow(\n [\"ba\", \"project\", \"percent_power_req\", \"percent_capacity_req\"]\n )\n for (ba, prj, pwr, cap) in project_contributions:\n if pwr is None:\n pwr = \".\"\n if cap is None:\n cap = \".\"\n writer.writerow([ba, prj, pwr, cap])\n", "meta": {"hexsha": "a68a396ae61a1be229daba28fd8b851ab05ae4a1", "size": 15454, "ext": "py", "lang": "Python", "max_stars_repo_path": "gridpath/system/reserves/requirement/reserve_requirements.py", "max_stars_repo_name": "souissim/gridpath", "max_stars_repo_head_hexsha": "4eeca2be24b485edc56026e38cfda83f4a6b27ea", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "gridpath/system/reserves/requirement/reserve_requirements.py", "max_issues_repo_name": "souissim/gridpath", "max_issues_repo_head_hexsha": "4eeca2be24b485edc56026e38cfda83f4a6b27ea", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "gridpath/system/reserves/requirement/reserve_requirements.py", "max_forks_repo_name": "souissim/gridpath", "max_forks_repo_head_hexsha": "4eeca2be24b485edc56026e38cfda83f4a6b27ea", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.3305439331, "max_line_length": 88, "alphanum_fraction": 0.6305163712, "include": true, "reason": "from pyomo", "num_tokens": 3416, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.5273165233795671, "lm_q2_score": 0.3738758227716966, "lm_q1q2_score": 0.19715089903964625}} {"text": "\"\"\"\n Copyright (c) 2015 Semafor Informatik & Energie AG\n\n\"\"\"\nimport sys\nimport numpy as np\nimport copy\nimport operator as op\n\n\nclass Individual:\n def __init__(self, n_dim, f_dim):\n self.cur_f = [0]*f_dim\n self.cur_x = [0]*n_dim\n self.cur_v = []\n self.cur_c = []\n\n self.rank = 0\n self.crowd_d = 0\n self.idx = 0\n\n def __str__(self):\n return \"f {} x {} rank {} crowd_d {}\".format(self.cur_f, self.cur_x,\n self.rank, self.crowd_d)\n\n\nclass Population:\n\n def __init__(self, probl, size, seed=None):\n self.individuals = []\n self.problem = probl\n self.champion = None\n self.dom_count = []\n self.dom_list = []\n np.random.seed(seed)\n for s in range(size):\n self.append([np.random.uniform(lb, ub)\n for lb, ub in zip(self.problem.lower,\n self.problem.upper)])\n# kmax=int(np.sqrt(size))+1\n# f=[]\n# for i in range(kmax):\n# for k in range(kmax):\n# f.append((i*0.8/kmax +0.1, k*0.8/kmax +0.1))\n# for k,i in enumerate(self.individuals):\n# i.cur_f = f[k]\n\n def size(self):\n return len(self.individuals)\n\n def copy(self):\n return copy.copy(self)\n\n def append(self, child):\n self.individuals.append(Individual(self.problem.dimension,\n self.problem.f_dim))\n self.individuals[-1].cur_x = child\n self.individuals[-1].idx = len(self.individuals)-1\n self.init_velocity()\n\n def eval(self):\n for k, i in enumerate(self.individuals):\n i.cur_f = self.problem.objfun(i.cur_x)\n self.update()\n\n def best_idx(self):\n return [i.idx for i in sorted(self.individuals,\n key=op.attrgetter('rank',\n 'crowd_d'))]\n\n def merge(self, pop):\n \"sort by rank and crowding distance (proximity)\"\n self.individuals += pop.individuals\n self.update()\n for i in self.individuals:\n if abs(i.crowd_d) > sys.float_info.epsilon:\n i.crowd_d = 1/i.crowd_d\n else:\n i.crowd_d = sys.float_info.max\n\n best = sorted(self.individuals,\n key=op.attrgetter('rank',\n 'crowd_d'))\n self.individuals = best[:pop.size()]\n self.update()\n\n def init_velocity(self):\n for i, j in enumerate(self.individuals[-1].cur_x):\n w = (self.problem.upper[i] - self.problem.lower[i])/2\n self.individuals[-1].cur_v.append(np.random.uniform(-w, w))\n\n def populate(self, x, f, s):\n \"\"\"populate with decision and objective values multiplied by sign\n x: vector of decision values\n f: matrix of objective values\n s: vector of signs (1, -1)\"\"\"\n for k, i in enumerate(self.individuals):\n i.cur_x = x[k]\n i.cur_f = [v*sign\n for v, sign in zip(f[:, k], s)]\n self.update()\n\n def get_ranked_decisions(self):\n px = dict()\n for i in self.individuals:\n k = i.rank\n if k in px:\n px[k].append(i.cur_x)\n else:\n px[k] = [i.cur_x]\n return px\n\n def get_ranked_objectives(self, s):\n po = dict()\n for i in self.individuals:\n cur_f = [v*sign\n for v, sign in zip(i.cur_f, s)]\n k = i.rank\n if k in po:\n po[k].append(cur_f)\n else:\n po[k] = [cur_f]\n return po\n\n def update(self):\n size = len(self.individuals)\n self.dom_count = []\n self.dom_list = [[] for s in range(size)]\n self.champion = None\n for s in range(size):\n self.dom_count.append(0)\n self.update_dom(s)\n self.update_champion(s)\n self.update_pareto_information()\n\n def update_dom(self, n):\n \"\"\"Loop over the population (j) and construct\n dom_list[n] and dom_count \"\"\"\n\n for i, x in enumerate(self.individuals):\n if i != n:\n # check if individual in position i\n # dominates the one in position n\n if self.problem.compare_fc(x.cur_f, x.cur_c,\n self.individuals[n].cur_f,\n self.individuals[n].cur_c):\n self.dom_count[n] += 1\n self.dom_list[i].append(n)\n\n def update_champion(self, idx):\n if self.champion is None or \\\n self.problem.compare_fc(self.individuals[idx].cur_f,\n self.individuals[idx].cur_c,\n self.champion['f'], self.champion['c']):\n self.champion = dict(x=self.individuals[idx].cur_x,\n f=self.individuals[idx].cur_f,\n c=self.individuals[idx].cur_c)\n\n def update_crowding(self, F):\n # sort along the fitness dimension\n for i in range(self.problem.f_dim):\n I = sorted(F, key=lambda k: self.individuals[k].cur_f[i],\n reverse=True)\n self.individuals[I[0]].crowd_d = sys.float_info.max\n self.individuals[I[-1]].crowd_d = sys.float_info.max\n df = (self.individuals[I[-1]].cur_f[i] -\n self.individuals[I[0]].cur_f[i])\n for j in range(1, len(F)-1):\n if abs(df) > sys.float_info.epsilon:\n self.individuals[I[j]].crowd_d += (\n self.individuals[I[j+1]].cur_f[i] -\n self.individuals[I[j-1]].cur_f[i])/df\n\n def update_pareto_information(self):\n size = len(self.individuals)\n self.pareto_rank = [0]*size\n F = [i for i, c in enumerate(self.dom_count) if c == 0]\n irank = 1\n dom_count_copy = list(self.dom_count)\n while True:\n self.update_crowding(F)\n S = []\n for i, f in enumerate(F):\n for j, k in enumerate(self.dom_list[f]):\n dom_count_copy[k] -= 1\n if dom_count_copy[k] == 0:\n S.append(k)\n self.pareto_rank[k] = irank\n self.individuals[k].rank = irank\n if S:\n F = list(S)\n else:\n return\n\n irank += 1\n\n def compute_pareto_fronts(self):\n self.update_pareto_information()\n retval = [[] for s in range(max(self.pareto_rank)+1)]\n for i, j in enumerate(self.individuals):\n retval[self.pareto_rank[i]].append(i)\n return retval\n\n def compute_ideal(self):\n return [min(x)\n for x in zip(*[i.cur_f\n for i in self.individuals if i.rank == 0])]\n\n def compute_nadir(self):\n return [max(x)\n for x in zip(*[i.cur_f\n for i in self.individuals if i.rank == 0])]\n\n def compute_worst(self):\n return [max(x)\n for x in zip(*[i.cur_f\n for i in self.individuals])]\n\n def compute_norm_dist(self):\n zi = np.array(self.compute_ideal())\n zw = np.array(self.compute_worst())\n znad = np.array(self.compute_nadir())\n return np.sqrt(((znad-zi)**2).sum() / ((zw-zi)**2).sum())\n\n def plot_pareto_fronts(\n self,\n rgb=(\n 0,\n 0,\n 0),\n comp=[\n 0,\n 1],\n symbol='o',\n size=6,\n fronts=[]):\n \"\"\"\n Plots the population pareto front in a 2-D graph\n\n USAGE: pop.plot_pareto_front(comp = [0,1], rgb=(0,1,0))\n\n * comp: components of the fitness function to plot in the 2-D window\n * rgb: specify the color of the 1st front (use strong colors here)\n * symbol: marker for the individual\n * size: size of the markersymbol\n * fronts: list of fronts to be plotted (use [0] to only show the first)\n \"\"\"\n from numpy import linspace\n import matplotlib.pyplot as plt\n\n if len(comp) != 2:\n raise ValueError(\n 'Invalid components of the objective function selected for plot')\n\n p_dim = self.problem.f_dimension\n\n if p_dim == 1:\n raise ValueError(\n 'Pareto fronts of a 1-dimensional problem cannot be plotted')\n\n if not all([c in range(0, p_dim) for c in comp]):\n raise ValueError(\n 'You need to select valid components of the objective function')\n\n p_list = self.compute_pareto_fronts()\n if (len(fronts) > 0):\n n = len(p_list)\n consistent = [d < n for d in fronts]\n if consistent.count(False) > 0:\n raise ValueError(\n 'Check your fronts list, there seem to be not enough fronts')\n p_list = [p_list[idx] for idx in fronts]\n\n cl = list(zip(linspace(0.9 if rgb[0] else 0.1, 0.9, len(p_list)),\n linspace(0.9 if rgb[1] else 0.1, 0.9, len(p_list)),\n linspace(0.9 if rgb[2] else 0.1, 0.9, len(p_list))))\n\n for id_f, f in enumerate(p_list):\n for ind in f:\n plt.plot([ind.cur_f[comp[0]]],\n [ind.cur_f[comp[1]]],\n symbol,\n color=cl[id_f], markersize=size)\n x = [ind.cur_f[comp[0]] for ind in f]\n y = [ind.cur_f[comp[1]] for ind in f]\n tmp = [(a, b) for a, b in zip(x, y)]\n tmp = sorted(tmp, key=lambda k: k[0])\n plt.step([c[0] for c in tmp], [c[1]\n for c in tmp], color=cl[id_f], where='post')\n return plt.gca()\n", "meta": {"hexsha": "4ec0a77895892c19694b22e3a8a62c518d0cabab", "size": 10100, "ext": "py", "lang": "Python", "max_stars_repo_path": "femagtools/moo/population.py", "max_stars_repo_name": "dapu/femagtools", "max_stars_repo_head_hexsha": "95eaf750adc2013232cdf482e523b3900ac6eb08", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 21, "max_stars_repo_stars_event_min_datetime": "2016-09-07T12:17:21.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-08T11:43:24.000Z", "max_issues_repo_path": "femagtools/moo/population.py", "max_issues_repo_name": "dapu/femagtools", "max_issues_repo_head_hexsha": "95eaf750adc2013232cdf482e523b3900ac6eb08", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 63, "max_issues_repo_issues_event_min_datetime": "2016-09-11T12:04:48.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-28T13:22:16.000Z", "max_forks_repo_path": "femagtools/moo/population.py", "max_forks_repo_name": "dapu/femagtools", "max_forks_repo_head_hexsha": "95eaf750adc2013232cdf482e523b3900ac6eb08", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2017-07-12T13:05:57.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-08T11:43:26.000Z", "avg_line_length": 34.7079037801, "max_line_length": 81, "alphanum_fraction": 0.4947524752, "include": true, "reason": "import numpy,from numpy", "num_tokens": 2407, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5273165233795671, "lm_q2_score": 0.373875808818685, "lm_q1q2_score": 0.19715089168199268}} {"text": "from __future__ import annotations\n\nfrom typing import Any, Generic, Tuple, TypeVar\n\nimport jax.numpy as jnp\nfrom jax import vjp\nfrom jax.tree_util import tree_map\n\nfrom ..annotations import PyTree\nfrom ..dataclasses import dataclass\nfrom ..shims import custom_vjp\nfrom .augmented import State\nfrom .comparing import ComparingIteratedFunction, ComparingState\nfrom .iterated_function import (Comparand, IteratedFunction, Parameters, TheAugmentedState,\n Trajectory)\n\n__all__ = ['IteratedFunctionWithCombinator', 'ComparingIteratedFunctionWithCombinator']\n\n\nDifferentiand = TypeVar('Differentiand', bound=PyTree)\n\n\n@dataclass\nclass _ZResiduals(Generic[Parameters, State, Comparand, Differentiand, TheAugmentedState]):\n outer_iterated_function: IteratedFunctionWithCombinator[Parameters, State, Comparand,\n Differentiand, Any, TheAugmentedState]\n outer_theta: Parameters\n x_star: State\n\n\n@dataclass\nclass _ZParameters(Generic[Parameters, State, Differentiand]):\n outer_theta: Parameters\n x_star: State\n x_star_differentiand: Differentiand\n x_star_bar_differentiand: Differentiand\n\n\ndef _ffp_fwd(outer_iterated_function: IteratedFunctionWithCombinator[Parameters, State, Comparand,\n Differentiand, Any,\n TheAugmentedState],\n theta: Parameters,\n initial_state: State) -> Tuple[TheAugmentedState, _ZResiduals[Parameters, State,\n Comparand, Differentiand,\n TheAugmentedState]]:\n \"\"\"\n Args:\n theta: The parameters for which gradients can be calculated.\n initial_state: An initial guess of the final state.\n Returns:\n x_star: the result of the minimization.\n residuals: residuals used in _ffp_bwd.\n \"\"\"\n augmented: TheAugmentedState = outer_iterated_function.find_fixed_point(\n theta, initial_state)\n return augmented, _ZResiduals(outer_iterated_function, theta, augmented.current_state)\n\n\ndef _ffp_bwd(residuals: _ZResiduals[Parameters, State, Comparand, Differentiand, TheAugmentedState],\n augmented_star_bar: TheAugmentedState) -> Tuple[None, Parameters, None]:\n \"\"\"\n Args:\n residuals: residuals produced by _ffp_fwd.\n augmented_star_bar: cotangents\n Returns:\n theta_bar: cotangents for theta\n zeroed_xs: cotangents for initial_state\n \"\"\"\n outer_iterated_function = residuals.outer_iterated_function\n outer_theta = residuals.outer_theta\n x_star = residuals.x_star\n x_star_differentiand = outer_iterated_function.extract_differentiand(outer_theta, x_star)\n x_star_bar = augmented_star_bar.current_state\n x_star_bar_differentiand = outer_iterated_function.extract_differentiand(outer_theta,\n x_star_bar)\n\n def f_of_theta(some_theta: Parameters) -> Differentiand:\n state = outer_iterated_function.expected_state(some_theta, x_star)\n return outer_iterated_function.extract_differentiand(outer_theta, state)\n\n z_iterator = _ZIterate(minimum_iterations=outer_iterated_function.z_minimum_iterations,\n maximum_iterations=outer_iterated_function.z_maximum_iterations,\n iterated_function=outer_iterated_function)\n z_parameters = _ZParameters(residuals.outer_theta, x_star, x_star_differentiand,\n x_star_bar_differentiand)\n augmented = z_iterator.find_fixed_point(z_parameters, x_star_bar_differentiand)\n z_star_differentiand: State = augmented.current_state\n\n _, df_by_dtheta = vjp(f_of_theta, residuals.outer_theta)\n theta_bar, = df_by_dtheta(z_star_differentiand)\n return None, theta_bar, None\n\n\n@dataclass\nclass IteratedFunctionWithCombinator(\n IteratedFunction[Parameters, State, Comparand, Trajectory, TheAugmentedState],\n Generic[Parameters, State, Comparand, Differentiand, Trajectory, TheAugmentedState]):\n \"\"\"\n An IteratedFunctionWithCombinator is an IteratedFunction that invokes a combinator so that\n differentiation works through the fixed point. Besides inheriting from this class, no other\n action is necessary to get this capability.\n\n It is a generic class with all of the parameters of IteratedFunction, and Differentiand, which\n is the type of the *portion of the state* with respect to which derivatives at the fixed point\n are calculated.\n\n Attributes:\n z_maximum_iterations:\n The maximum number of iterations to use to evaluate the adjoint's fixed point.\n \"\"\"\n z_minimum_iterations: int = 11\n z_maximum_iterations: int = 1000\n\n # Overridden methods ---------------------------------------------------------------------------\n def find_fixed_point(self,\n theta: Parameters,\n initial_state: State) -> TheAugmentedState:\n \"\"\"\n Args:\n theta: The parameters for which gradients can be calculated.\n initial_state: An initial guess of the final state.\n Returns: The augmented state at the fixed point.\n \"\"\"\n return super().find_fixed_point(theta, initial_state)\n\n find_fixed_point = custom_vjp(find_fixed_point) # type: ignore\n\n # Abstract methods -----------------------------------------------------------------------------\n def extract_differentiand(self, theta: Parameters, state: State) -> Differentiand:\n \"\"\"\n Returns: The differentiable values in the state. It is used by the combinator to find\n cotangents.\n \"\"\"\n raise NotImplementedError\n\n def implant_differentiand(self,\n theta: Parameters,\n state: State,\n differentiand: Differentiand) -> State:\n \"\"\"\n Args:\n state: A state that will provide nondifferentiable values.\n differentiand: A differentiand that will provide differentiable values.\n Returns: A state containing differentiable from the differentiand and nondifferentiable\n values from the inputted state.\n \"\"\"\n raise NotImplementedError\n\n # Apply vjp ------------------------------------------------------------------------------------\n find_fixed_point.defvjp(_ffp_fwd, _ffp_bwd) # type: ignore\n\n\nclass ComparingIteratedFunctionWithCombinator(\n IteratedFunctionWithCombinator[Parameters, State, Comparand, Differentiand, Trajectory,\n ComparingState[State, Comparand]],\n ComparingIteratedFunction[Parameters, State, Comparand, Trajectory],\n Generic[Parameters, State, Comparand, Differentiand, Trajectory]):\n pass\n\n\n@dataclass\nclass _ZIterate(ComparingIteratedFunctionWithCombinator[\n _ZParameters[Parameters, State, Differentiand],\n Differentiand,\n Differentiand,\n Differentiand,\n None],\n Generic[Parameters, State, Comparand, TheAugmentedState, Differentiand]):\n \"\"\"\n The state of _ZIterate is the differentiand of the outer iterated function.\n \"\"\"\n iterated_function: IteratedFunctionWithCombinator[\n Parameters, State, Comparand, Differentiand, Any, TheAugmentedState]\n\n # Implemented methods --------------------------------------------------------------------------\n def expected_state(self,\n theta: _ZParameters[Parameters, State, Differentiand],\n state: Differentiand) -> Differentiand:\n return self.sampled_state(theta, state)\n\n def sampled_state(self,\n theta: _ZParameters[Parameters, State, Differentiand],\n state: Differentiand) -> Differentiand:\n # The state should be called z, but we can't change the interface because of Liskov's\n # substitution principle.\n z = state\n del state\n\n def f_of_x(x_differentiand: Differentiand) -> Differentiand:\n x = self.iterated_function.implant_differentiand(theta.outer_theta, theta.x_star,\n x_differentiand)\n state = self.iterated_function.expected_state(theta.outer_theta, x)\n return self.iterated_function.extract_differentiand(theta.outer_theta, state)\n\n _, df_by_dx = vjp(f_of_x, theta.x_star_differentiand)\n df_by_dx_times_z, = df_by_dx(z)\n return tree_map(jnp.add, theta.x_star_bar_differentiand, df_by_dx_times_z)\n\n def extract_comparand(self, state: Differentiand) -> Differentiand:\n return state\n\n def extract_differentiand(self,\n theta: _ZParameters[Parameters, State, Differentiand],\n state: Differentiand) -> Differentiand:\n return state\n\n def implant_differentiand(self,\n theta: _ZParameters[Parameters, State, Differentiand],\n state: Differentiand,\n differentiand: Differentiand) -> Differentiand:\n return differentiand\n", "meta": {"hexsha": "b3424acb3fd8272b66c7e197851babcbd54dcdfe", "size": 9381, "ext": "py", "lang": "Python", "max_stars_repo_path": "tjax/_src/fixed_point/combinator.py", "max_stars_repo_name": "NeilGirdhar/tjax", "max_stars_repo_head_hexsha": "11a3abe3d287ddd4df4e0b3b04b46969b8bdc881", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 25, "max_stars_repo_stars_event_min_datetime": "2020-07-14T02:22:05.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-24T15:27:28.000Z", "max_issues_repo_path": "tjax/_src/fixed_point/combinator.py", "max_issues_repo_name": "NeilGirdhar/tjax", "max_issues_repo_head_hexsha": "11a3abe3d287ddd4df4e0b3b04b46969b8bdc881", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-11-24T13:13:30.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-22T16:08:47.000Z", "max_forks_repo_path": "tjax/_src/fixed_point/combinator.py", "max_forks_repo_name": "NeilGirdhar/tjax", "max_forks_repo_head_hexsha": "11a3abe3d287ddd4df4e0b3b04b46969b8bdc881", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.25, "max_line_length": 100, "alphanum_fraction": 0.6416160324, "include": true, "reason": "import jax,from jax", "num_tokens": 1905, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5428632979641571, "lm_q2_score": 0.3629692193015556, "lm_q1q2_score": 0.19704266744951787}} {"text": "import os\nimport json\nimport random\nimport pickle\nimport numpy as np\nfrom copy import deepcopy\n\nimport cma\nfrom svreg.optimizers import GAWrapper#, SofomoreWrapper\nfrom svreg.nodes import SVNode\nfrom svreg.tree import SVTree\nfrom svreg.tree import MultiComponentTree as MCTree\n\nimport dask\n\nclass SVRegressor:\n \"\"\"\n A class for running a genetic algorithm to perform symbolic\n regression using structure vectors.\n\n Attributes:\n\n settings (Settings):\n The settings used during regression. Use\n Settings.printValidSettings() to see valid settings options and\n suggested values.\n\n svNodePool (list):\n A list of SVNode objects representing the different types of SVs\n to be used during the regression.\n\n optimizer (object):\n The constructor for an optimizer object that will be used to\n optimize tree parameters. It is assumed that `optimizer` is a\n population-based optimizer and that it implements an ask() and\n tell() interface. An optimizer instance will be generated by calling\n optimizer(tree.populate(N=1)[0], **optimizerArgs) for tree in\n self.trees.\n\n optimizerArgs (dict):\n A dictionary of named arguments to be passed to the tree optimizers.\n\n trees (list):\n A list of SVTree objects being optimized.\n \"\"\"\n\n def __init__(\n self,\n settings,\n database,\n ):\n\n # Note: it is assumed that Settings has already performed all validation\n # checks on the provided settings.\n\n self.settings = settings\n self.svNodePool = buildSVNodePool(database)\n\n self.structNames = database.attrs['structNames']\n self.svNames = database.attrs['svNames']\n self.elements = database.attrs['elements']\n\n if settings['optimizer'] == 'CMA':\n self.optimizer = cma.CMAEvolutionStrategy\n self.optimizerArgs = [\n 1.0, # defaulted sigma0 value\n {\n 'verb_disp': 0,\n 'popsize': settings['optimizerPopSize'],\n 'maxiter': settings['maxNumOptimizerSteps'],\n 'tolx': 1e-8, # changes in x-values\n 'tolfunhist': 1e-8,\n 'tolfun': 1e-8,\n 'tolfunrel': 1e-8,\n }\n ]\n elif settings['optimizer'] == 'GA':\n self.optimizer = GAWrapper\n self.optimizerArgs = [\n {\n 'verb_disp': 0,\n 'popsize': settings['optimizerPopSize'],\n 'maxiter': settings['maxNumOptimizerSteps'],\n 'tolx': 1e-8, # changes in x-values\n 'tolfunhist': 1e-8,\n 'tolfun': 1e-8,\n 'tolfunrel': 1e-8,\n }\n ]\n # elif settings['optimizer'] == 'Sofomore':\n # self.optimizer = SofomoreWrapper\n # self.optimizerArgs = {\n # 'numStructs': numStructs,\n # 'paretoDimensionality': 2,\n # 'CMApopSize': settings['optimizerPopSize'],\n # 'SofomorePopSize': settings['numberOfTrees'], # Placeholder\n # 'threads_per_node': settings['PROCS_PER_PHYS_NODE'],\n # 'threads_per_node': None,\n # }\n else:\n raise NotImplementedError(\n 'Must be one of `GA`, `CMA`, or `Sofomore`.'\n )\n\n self.trees = []\n self.populationDict = None\n\n\n def initializeTrees(self, elements):\n \"\"\"Populates the GA with randomly-generated equation trees.\"\"\"\n\n numElements = len(elements)\n\n if numElements < 1:\n raise RuntimeError(\"numElements must be >= 1 in initializeTrees()\")\n\n uniqueTreeNames = []\n\n for ii, tree in enumerate(self.trees):\n tn = str(tree)\n if tn not in uniqueTreeNames:\n uniqueTreeNames.append(tn)\n else:\n del self.trees[ii]\n print(\"Removed duplicate tree: {}\".format(tn))\n\n treesToAdd = []\n while len(uniqueTreeNames) < self.settings['numberOfTrees']:\n randTree = MCTree.random(\n svNodePool=self.svNodePool,\n maxDepth=random.randint(0, self.settings['maxTreeDepth']),\n elements=elements,\n allSums=self.settings['allSums']\n )\n\n if str(randTree) not in uniqueTreeNames:\n uniqueTreeNames.append(str(randTree))\n treesToAdd.append(randTree)\n\n self.trees += treesToAdd\n\n\n def evaluateTrees(self, svEng, svFcs, P, trueValues, useDask=True):\n \"\"\"\n Updates the SVNode objects in the trees with the given values, then\n evaluate the trees\n\n Args:\n svEng (dict):\n svEng[structName][svName][elem] = computed values for given node\n\n svFcs (dict):\n svFcs[structName][svName][elem] = computed values for given node\n\n P (int):\n The number of parameter sets for each node. Used for splitting\n the population of results.\n\n Return:\n energies, forces (dict):\n {structName: [tree.eval() for tree in self.trees]}\n \"\"\"\n\n structNames = list(svEng.keys())\n svNames = list(svEng[structNames[0]].keys())\n \n # NOTE: elements must be sorted here to match assumed ordering of\n # tree.svNodes\n elements = sorted(list(svEng[structNames[0]][svNames[0]].keys()))\n\n # indexers[sv][el][i] = list of indices for svEng[*][sv][el] for tree i\n indexers = {}\n\n struct0 = structNames[0]\n # Build dictionary of indexers for each SV\n for svName in svEng[struct0]:\n indexers[svName] = {}\n for elem in elements:\n indexers[svName][elem] = []\n\n counter = 0\n\n for tree in self.trees:\n treeIndices = []\n for svNode in tree.chemistryTrees[elem].svNodes:\n # Only update the SVNode objects of the current type\n if svNode.description == svName:\n treeIndices.append(counter)\n counter += 1\n\n # Reverse list here since we'll be popping from it later\n indexers[svName][elem].append(treeIndices[::-1])\n\n taskArgs = []\n for struct in structNames:\n indexCopy = deepcopy(indexers)\n\n for ii, tree in enumerate(self.trees):\n treeArgs = []\n for elem in elements:\n for svNode in tree.chemistryTrees[elem].svNodes:\n svName = svNode.description\n\n engDot = svEng[struct][svName][elem]\n fcsDot = svFcs[struct][svName][elem]\n\n treeArgs.append(\n (engDot, fcsDot, indexCopy[svName][elem][ii].pop())\n )\n\n taskArgs.append(treeArgs)\n\n taskArgs = taskArgs[::-1]\n\n perTreeResults = []\n for structName in structNames:\n for t in self.trees:\n args = taskArgs.pop()\n\n if useDask:\n perTreeResults.append(\n dask.delayed(parseAndEval, pure=True, nout=2)(\n pickle.dumps(t), args, P,\n trueValues[structName]['forces'],\n allSums=self.settings['allSums']\n )\n )\n else:\n perTreeResults.append(\n parseAndEval(\n t, args, P,\n trueValues[structName]['forces'],\n allSums=self.settings['allSums']\n )\n )\n\n return perTreeResults \n\n\n def initializeOptimizers(self):\n import hashlib\n\n h5Hash = lambda t: hashlib.md5(str(t).encode()).hexdigest()\n\n path = os.path.join(self.settings['outputPath'], 'outcmaes', '{}/')\n\n # self.optimizers = [\n # self.optimizer(\n # tree.populate(N=1)[0],\n # *.update(\n # self.optimizerArgs[-1]\n # )\n # )\n # for tree in self.trees\n # ]\n\n argsCopy = deepcopy(self.optimizerArgs)\n\n self.optimizers = []\n for tree in self.trees:\n d = {'verb_filenameprefix': path.format(h5Hash(tree))}\n d.update(self.optimizerArgs[-1])\n\n argsCopy[-1] = d\n\n self.optimizers.append(\n self.optimizer(\n tree.populate(N=1)[0],\n *argsCopy\n )\n )\n\n\n def tournament(self, topN):\n \"\"\"\n Randomly return a random individual from the topN individuals in the\n population.\n\n Return:\n A deep copy (to avoid multiple trees pointing to the same nodes) of\n the best individual.\n \"\"\"\n\n indices = np.arange(len(self.trees))\n costs = [t.cost for t in self.trees]\n\n argsort = np.argsort(costs)\n costs = costs[argsort]\n indices = indices[argsort]\n\n return deepcopy(self.trees[random.choice(indices[:topN])])\n\n\n def newIndividual(self):\n \"\"\"\n Generates a new individual using the current population. Allow for\n random point mutation.\n \"\"\"\n\n newTree = self.tournament(self.settings['tournamentSize'])\n donor = self.tournament(self.settings['tournamentSize'])\n\n newTree.crossover(donor)\n\n if random.random() < self.settings['pointMutateProb']:\n newTree.pointMutate(\n self.svNodePool, self.settings['pointMutateProb']\n )\n\n newTree.updateSVNodes()\n\n return newTree\n\n\n def printTop10Header(self, regStep):\n print(regStep, flush=True)\n\n for treeNum, t in enumerate(self.trees):\n print(treeNum, t)\n\n print('\\t\\t\\t', ''.join(['{:<10}'.format(i) for i in range(10)]))\n\n\n def generatePopulationDict(self, N):\n \"\"\"\n Generates N parameter sets for each tree, then groups them by SV name\n for easy batch evaluation.\n\n Returns:\n populationDict: {svName: {el: stacked population}}\n rawPopulation: the parameter arrays generated by each optimizer\n \"\"\"\n\n rawPopulations = [np.array(opt.ask(N)) for opt in self.optimizers]\n\n # Used for parsing later\n self.numNodes = {}\n\n # Now parse the populations and group them by SV type\n\n # populationDict[svName][elem]\n populationDict = {}\n for pop, tree in zip(rawPopulations, self.trees):\n # popDict= {el: {svName: population}}\n popDict = tree.parseArr2Dict(pop)\n\n for elem in popDict:\n for svName in popDict[elem]:\n if svName not in populationDict:\n populationDict[svName] = {}\n\n if elem not in populationDict[svName]:\n populationDict[svName][elem] = []\n\n populationDict[svName][elem].append(popDict[elem][svName])\n\n\n # Count the number of each node to help with parsing results later\n for tree in self.trees:\n for elem in tree.chemistryTrees:\n for svNode in tree.chemistryTrees[elem].svNodes:\n svName = svNode.description\n\n if svName not in self.numNodes:\n self.numNodes[svName] = {}\n\n if elem not in self.numNodes[svName]:\n self.numNodes[svName][elem] = 0\n\n self.numNodes[svName][elem] += 1\n\n self.chunks = {}\n # Stack each group\n for svName in populationDict:\n if svName not in self.chunks:\n self.chunks[svName] = {}\n\n for elem, popList in populationDict[svName].items():\n dat = np.concatenate(popList, axis=0).T\n\n populationDict[svName][elem] = dat.astype('float32')\n\n return populationDict, rawPopulations\n\n \n def updateOptimizers(self, rawPopulations, costs, penalties):\n for treeIdx in range(len(self.optimizers)):\n fullCost = costs[treeIdx] + penalties[treeIdx]\n\n opt = self.optimizers[treeIdx]\n opt.tell(rawPopulations[treeIdx], fullCost)\n opt.logger.add()\n\n\n def checkStale(self):\n \"\"\"\n Returns a list of the indices of any trees that have finished\n optimizing.\n \"\"\"\n\n stale = []\n messages = []\n\n for i, opt in enumerate(self.optimizers):\n if opt.stop():\n stale.append(i)\n messages.append(opt.stop())\n\n return stale, messages\n\n\ndef buildSVNodePool(database):\n \"\"\"Prepare svNodePool for use in tree construction\"\"\"\n\n svNodePool = []\n\n for svName in database:\n\n restrictions = None\n if 'restrictions' in database.attrs[svName]:\n restrictions = []\n resList = database.attrs[svName]['restrictions'].tolist()[::-1]\n for num in database.attrs[svName]['numRestrictions']:\n tmp = []\n for _ in range(num):\n tmp.append(tuple(resList.pop()))\n restrictions.append(tmp)\n\n bondComps = sorted(set(database.attrs[svName]['components']))\n numParams = []\n restr = []\n\n cList = database.attrs[svName]['components'].tolist()\n for c in bondComps:\n idx = cList.index(c)\n numParams.append(database.attrs[svName]['numParams'][idx].astype(int))\n restr.append(restrictions[idx])\n\n if 'paramRanges' in database.attrs[svName]:\n pRanges = []\n for c in bondComps:\n idx = cList.index(c)\n pRanges.append(database.attrs[svName]['paramRanges'][idx])\n else:\n pRanges = None\n\n bondComps = [c.decode('utf-8') for c in bondComps]\n\n\n svNodePool.append(\n SVNode(\n description=svName,\n components=bondComps,\n constructor=[\n c.decode('utf-8')\n for c in database.attrs[svName]['components']\n ],\n numParams=numParams,\n restrictions=restr,\n paramRanges=pRanges,\n inputTypes=json.loads(\n database.attrs[svName]['inputTypes'].decode('utf-8').replace(\"'\", '\"')\n )\n )\n )\n\n return svNodePool\n\n \ndef parseAndEval(\n *args,\n **kwargs,\n ):\n\n tree = kwargs['tree']\n listOfIndices = kwargs['listOfIndices']\n P = kwargs['P']\n tvF = kwargs['tvF']\n numChunks = kwargs['numChunks']\n allSums = kwargs['allSums']\n\n import pickle\n tree = pickle.loads(tree)\n\n nodeCounter = 0\n chunkCounter = 0\n for elem in tree.elements:\n for svNode in tree.chemistryTrees[elem].svNodes:\n svName = svNode.description\n\n chunkTup = []\n for _ in range(numChunks[svName][elem]):\n chunkTup.append(args[chunkCounter])\n chunkCounter += 1\n\n idx = listOfIndices[nodeCounter]\n nodeCounter += 1\n\n eng = np.concatenate([c[0] for c in chunkTup], axis=-1)\n fcs = np.concatenate([c[1] for c in chunkTup], axis=-1)\n\n Ne = eng.shape[0]\n Nn = eng.shape[1] // P\n\n eng = eng.reshape((Ne, Nn, P))\n eng = np.moveaxis(eng, 1, 0)\n eng = np.moveaxis(eng, -1, 1)\n\n # fcs shape: (Ne, Na, 3, P*Nn)\n\n if allSums:\n Na = fcs.shape[0]\n fcs = fcs.reshape(Na, 3, Nn, P)\n else:\n Na = fcs.shape[1]\n fcs = fcs.reshape(Ne, Na, 3, Nn, P)\n\n fcs = np.moveaxis(fcs, -2, 0)\n fcs = np.moveaxis(fcs, -1, 1)\n\n # fcs shape: (Nn, P, Ne, Na, 3)\n\n svNode.values = (eng[idx], fcs[idx])\n\n engResult, fcsResult = tree.eval(useDask=False, allSums=allSums)\n\n fcsErrors = np.average(abs(sum(fcsResult) - tvF['forces']), axis=(1,2))\n\n return sum(engResult), fcsErrors\n", "meta": {"hexsha": "602b4922d5785f48d31a021e22747ecb06d728ff", "size": 16689, "ext": "py", "lang": "Python", "max_stars_repo_path": "svreg/regressor.py", "max_stars_repo_name": "TrinkleGroup/svreg", "max_stars_repo_head_hexsha": "b0c5b3c53792f0cc7b31a9d85f2e9b33824aaca1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "svreg/regressor.py", "max_issues_repo_name": "TrinkleGroup/svreg", "max_issues_repo_head_hexsha": "b0c5b3c53792f0cc7b31a9d85f2e9b33824aaca1", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2020-10-28T17:14:29.000Z", "max_issues_repo_issues_event_max_datetime": "2020-10-28T17:16:55.000Z", "max_forks_repo_path": "svreg/regressor.py", "max_forks_repo_name": "TrinkleGroup/svreg", "max_forks_repo_head_hexsha": "b0c5b3c53792f0cc7b31a9d85f2e9b33824aaca1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.4886792453, "max_line_length": 90, "alphanum_fraction": 0.5237581641, "include": true, "reason": "import numpy", "num_tokens": 3633, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5428632831725051, "lm_q2_score": 0.3629692193015555, "lm_q1q2_score": 0.19704266208060342}} {"text": "###############################################################\n#\n# Cantera UPF : freely-propagating premixed flames\n# Description : perform calculations of UPF for a range of eq. ratio\n# and compute global indices (integrated fuel, CO, NO consumption, ...)\n# Author : A. Felden\n# Last modified : 02/2018\n#\n###############################################################\n\n#import :\nfrom cantera import *\nimport numpy as np\nimport csv\nimport sys,os\n\n#################################################################\n# Prepare your run\n#################################################################\n#Mechanism used for the process\ncas = 'DET.cti' \npref = 'C2H4DET_T298_P1'\nrestore = 'no'\ninit_flame = 'RedHighP_HighP_save.xml' \n\n#General parameter values :\np \t= 101325.0 # pressure\ntin \t= 298.0 # unburned gas temperature\nphi_min \t= 0.8\nphi_max \t= 1.5\nnpoints \t= 1\n\n########\n#STORAGE\n########\n# KSI\nksi = np.zeros(npoints,'d')\n# YC eq\nYc_equil = np.zeros(npoints,'d')\n#phiv\nphi = np.zeros(npoints,'d')\n#sl0phiv\nsl_phi = np.zeros(npoints,'d')\n#tadphiv\nt_phi = np.zeros(npoints,'d')\n#omega0phiv\n#delta0phiv\ndl0_phi = np.zeros(npoints,'d')\n\n#########################################\n# SPECS : profiles, wdot, consump, val max\n# prof : Fuel, oxy, CO, CO2, OH, C2H2\n# max : oxy, CO, CO2, OH, C2H2\n# wdot : Fuel, oxy, CO, C2H2\n# cons : Fuel, CO, C2H2 \n#########################################\n#FUEL consump\nFuel_c \t\t= np.zeros(npoints,'d')\n#OXY consump\nO2m_phi \t= np.zeros(npoints,'d')\n#CO consump\nCOm_phi \t= np.zeros(npoints,'d')\nCO_c \t\t= np.zeros(npoints,'d')\n#CO2 consump\nCO2m_phi \t= np.zeros(npoints,'d')\n#OH consump\nOHm_phi \t= np.zeros(npoints,'d')\n\n\n#################\n#Run parameters:\n\n#Initial grids, chosen to be 15cm long : \ninitial_grid = np.array([0.0, 0.001, 0.005, 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.1], 'd')/0.1 #, 0.11, 0.115, 0.119, 0.12],'d')/0.1 # m\n\n#Tolerance properties\ntol_ss = [1.0e-8, 1.0e-12] # [rtol atol] for steady-state problem\ntol_ts = [1.0e-8, 1.0e-12] # [rtol atol] for time stepping\n\nloglevel = 1 # amount of diagnostic output\n\t\t\t\t \nrefine_grid = True # True to enable refinement\n\n#################\n#Stoechiometry :\n\nfuel_species = 'C2H4'\nstoich_O2 = 3.0\nair_N2_O2_ratio = 3.76\n\ngas = Solution(cas)\nm=gas.n_species\n\nifuel = gas.species_index(fuel_species)\nioh = gas.species_index('OH')\nih2 = gas.species_index('H2')\nio2 = gas.species_index('O2')\nin2 = gas.species_index('N2')\nico = gas.species_index('CO')\nico2 = gas.species_index('CO2')\nih2o = gas.species_index('H2O')\n\n#################################################################\n#BILGER PRE PROC :\n#################################################################\n#Mixt frac calculation based on Bilger\n#molecular weight of CHON\nC_W = 0.012\nH_W = 0.001\nO_W = 0.016\nN_W = 0.014\n#Bilger coefs pour formule\nBilger_coefs \t\t= np.zeros(4,'d')\nBilger_coefs[0]\t\t= 2.0 / C_W\nBilger_coefs[1]\t\t= 1.0 / ( 2.0 * H_W )\nBilger_coefs[2]\t\t= -1.0 / O_W\nBilger_coefs[3]\t\t= 0.0\n#Storage nb d atomes par especes\nNb_C\t\t\t= np.zeros(m,'d')\nNb_H\t\t\t= np.zeros(m,'d')\nNb_O\t\t\t= np.zeros(m,'d')\n#Compo du fuel et oxi tank\nFtank\t\t\t= np.zeros(m,'d')\nFtank[ifuel]\t\t= 1.0\nOxtank\t\t\t= np.zeros(m,'d')\nOxtank[io2]\t\t= 0.233\nOxtank[in2]\t\t= 0.767\n#Normalisation\nBetaF \t\t\t= 0.0\nBetaOx \t\t\t= 0.0\nfor i, spec in enumerate(gas.species_names):\n Nb_C[i] = gas.n_atoms(spec,'C') \n Nb_H[i] = gas.n_atoms(spec,'H') \n Nb_O[i] = gas.n_atoms(spec,'O') \n Weightedatom = Bilger_coefs[0] * C_W * Nb_C[i] + Bilger_coefs[1] * H_W * Nb_H[i] + Bilger_coefs[2] * O_W * Nb_O[i]\n BetaF = BetaF + 1000.0 * Weightedatom * Ftank[i] / gas.molecular_weights[i]\n BetaOx = BetaOx + 1000.0 * Weightedatom * Oxtank[i] / gas.molecular_weights[i]\n\nif (restore == 'yes'): \n#################################################################\n# RESTORE PREVIOUS FLAME\n#################################################################\n phi[0] = phi_min \n x = np.zeros(m,'d')\n x[ifuel] = phi[0]\n x[io2] = stoich_O2\n x[in2] = stoich_O2*air_N2_O2_ratio\n \n gas.TPX = tin, p, x\n \n f = FreeFlame(gas, initial_grid)\n f.restore(init_flame, 'phi_'+str(phi[0]))\nelse:\n#################################################################\n#FIRST SIMULATION :\n#################################################################\n#Stoechiometry :\n phi[0] = phi_min \n x = np.zeros(m,'d')\n x[ifuel] = phi[0]\n x[io2] = stoich_O2\n x[in2] = stoich_O2*air_N2_O2_ratio\n\n print(' ')\n print(' ### First flame at Phi : '+str(phi[0]))\n \n gas.TPX = tin, p, x\n\n#Create the free laminar premixed flame\n f = FreeFlame(gas, initial_grid)\n \n f.flame.set_steady_tolerances(default=tol_ss)\n f.flame.set_transient_tolerances(default=tol_ts)\n \n f.inlet.X = x\n f.inlet.T = tin\n \n f.transport_model = 'Mix'\n\n#First flame:\n\n #No energy for starters\n f.energy_enabled = False\n\n #Refinement criteria\n f.set_refine_criteria(ratio = 5.0, slope = 1, curve = 1)\n\n #Max number of times the Jacobian will be used before it must be re-evaluated\n f.set_max_jac_age(30, 30)\n\n #Set time steps whenever Newton convergence fails\n f.set_time_step(1.0e-6, [5, 10, 20]) #s\n\n #Calculation\n f.solve(loglevel, refine_grid)\n\n#################\n#Second flame:\n\n\t#Energy equation enabled\n f.energy_enabled = True\n\n #Refinement criteria when energy equation is enabled\n f.set_refine_criteria(ratio = 5.0, slope = 0.5, curve = 0.5)\n\n #Calculation and save of the results\n f.solve(loglevel, refine_grid)\n\n #Refinement criteria when energy equation is enabled\n f.set_refine_criteria(ratio = 3.0, slope = 0.2, curve = 0.2)\n\n #Calculation and save of the results\n f.solve(loglevel, refine_grid)\n\n#################\n#Third flame and so on ...:\n\n\t#Refinement criteria should be changed ...\n f.set_refine_criteria(ratio = 2.0, slope = 0.04, curve = 0.04)\n\n f.solve(loglevel, refine_grid)\n\n\t#Refinement criteria should be changed ...\n f.set_refine_criteria(ratio = 2.0, slope = 0.02, curve = 0.02)\n\n f.solve(loglevel, refine_grid)\n\n sl_phi[0] = f.u[0]\n t_phi[0] = f.T[f.flame.n_points-1]\n print( \"Sl ? \", sl_phi[0])\n print( \"Tad ? \", t_phi[0])\n\n\t#...and saving of the results\n #f.save(str(pref)+'_save.xml','phi_'+str(phi[0]))\n f.write_csv(str(pref)+'_Phi'+str(phi[0])+'_Y.csv', species='Y', quiet=False)\n\n", "meta": {"hexsha": "1db1c0e1163d308406a589ea1de52caaf3d35115", "size": 6593, "ext": "py", "lang": "Python", "max_stars_repo_path": "Support/Fuego/Mechanism/Models/ethylene_af/CANTERA/Cantera_UPF_Global.py", "max_stars_repo_name": "balos1/PelePhysics", "max_stars_repo_head_hexsha": "d01190cc7b0eaad4ec96fac573034ccb485f0e9f", "max_stars_repo_licenses": ["BSD-3-Clause-LBNL"], "max_stars_count": 31, "max_stars_repo_stars_event_min_datetime": "2018-11-21T01:49:06.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T03:41:43.000Z", "max_issues_repo_path": "Support/Fuego/Mechanism/Models/ethylene_af/CANTERA/Cantera_UPF_Global.py", "max_issues_repo_name": "balos1/PelePhysics", "max_issues_repo_head_hexsha": "d01190cc7b0eaad4ec96fac573034ccb485f0e9f", "max_issues_repo_licenses": ["BSD-3-Clause-LBNL"], "max_issues_count": 123, "max_issues_repo_issues_event_min_datetime": "2019-03-12T22:27:29.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-29T17:00:04.000Z", "max_forks_repo_path": "Support/Fuego/Mechanism/Models/ethylene_af/CANTERA/Cantera_UPF_Global.py", "max_forks_repo_name": "sundials-codes/PelePhysics", "max_forks_repo_head_hexsha": "5624f83a04f43aa95288be9d8a7bb372a4adefe6", "max_forks_repo_licenses": ["BSD-3-Clause-LBNL"], "max_forks_count": 32, "max_forks_repo_forks_event_min_datetime": "2018-11-05T11:51:59.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-29T13:09:32.000Z", "avg_line_length": 27.8185654008, "max_line_length": 154, "alphanum_fraction": 0.5490671925, "include": true, "reason": "import numpy", "num_tokens": 2134, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5428632683808532, "lm_q2_score": 0.36296921930155557, "lm_q1q2_score": 0.1970426567116891}} {"text": "from torch.optim.optimizer import Optimizer, required\nimport torch\nimport math\nimport numpy as np\n\n\nclass LRangerMod(Optimizer):\n\n # AMSGrad/Adam + AdaMod + QH Momentum + Iterate Averaging + Lookahead + Rule of Thumb Linear Warmup (instead of RAdam Rectification) + P from PAdam\n\n def __init__(self, params, lr=1e-3,\n betas=(0.999, 0.999, 0.999),\n nus=(0.7, 1.0),\n p=0.5,\n eps=1e-8,\n k=5,\n alpha=0.8,\n amsgrad=True,\n AdaMod=True,\n warmup=True,\n AdaMod_bias_correct=True,\n IA=True,\n use_gc=False,\n IA_cycle=1000,\n epochs=100,\n step_per_epoch=None,\n weight_decay=0):\n\n # betas = (beta1 for first order moments, beta2 for second order moments, beta3 for ema over adaptive learning rates (AdaMod))\n # nus = (nu1,nu2) (for quasi hyperbolic momentum)\n # eps = small value for numerical stability (avoid divide by zero)\n # k = lookahead cycle\n # alpha = outer learning rate (lookahead)\n # amsgrad = bool to decide whether to use amsgrad instead of adam as the core optimizer\n # AdaMod_bias_correct = bool to decide whether to add bias correction to AdaMod\n # IA = bool to decide if Iterate Averaging is ever going to be used\n # IA_cycle = Iterate Averaging Cycle (Recommended to initialize with no. of iterations in Epoch) (doesn't matter if you are not using IA)\n # epochs = No. of epochs you plan to use (Only relevant if using DEMON)\n # step_per_epoch = No. of iterations in an epoch (only relevant if using DEMON)\n # weight decay = decorrelated weight decay value\n\n if not 0.0 <= lr:\n raise ValueError(\"Invalid learning rate: {}\".format(lr))\n if not 0.0 <= eps:\n raise ValueError(\"Invalid epsilon value: {}\".format(eps))\n if not 0.0 <= p <= 0.5:\n raise ValueError(\"Invalid p value: {}\".format(p))\n if not 0.0 <= betas[0] < 1.0:\n raise ValueError(\"Invalid beta parameter at index 0: {}\".format(betas[0]))\n if not 0.0 <= betas[1] < 1.0:\n raise ValueError(\"Invalid beta parameter at index 1: {}\".format(betas[1]))\n if not 0.0 <= betas[2] < 1.0:\n raise ValueError(\"Invalid beta parameter at index 2: {}\".format(betas[2]))\n if not 0.0 <= nus[0] <= 1.0:\n raise ValueError(\"Invalid nu parameter at index 0: {}\".format(nus[0]))\n if not 0.0 <= nus[1] <= 1.0:\n raise ValueError(\"Invalid nu parameter at index 1: {}\".format(nus[1]))\n if not 0.0 <= alpha <= 1.0:\n raise ValueError(\"Invalid alpha parameter: {}\".format(alpha))\n\n self.k = k\n self.epochs = epochs\n self.amsgrad = amsgrad\n self.warmup_period = 2/(1-betas[1])\n self.IA_cycle = IA_cycle\n self.IA = IA\n self.AdaMod = AdaMod\n self.use_gc = use_gc\n self.AdaMod_bias_correct = AdaMod_bias_correct\n self.warmup = warmup\n if step_per_epoch is None:\n self.step_per_epoch = IA_cycle\n else:\n self.step_per_epoch = step_per_epoch\n\n self.T = self.epochs*self.step_per_epoch\n\n defaults = dict(lr=lr,\n betas=betas,\n nus=nus,\n eps=eps,\n p=p,\n alpha=alpha,\n weight_decay=weight_decay)\n super(LRangerMod, self).__init__(params, defaults)\n\n def __setstate__(self, state):\n super(LRangerMod, self).__setstate__(state)\n\n def apply_AdaMod(self, beta3, n_avg, n, step):\n n_avg.mul_(beta3).add_(1 - beta3, n)\n if self.AdaMod_bias_correct:\n n_avg_ = n_avg.clone()\n n_avg_.div_(1 - (beta3 ** step))\n torch.min(n, n_avg_, out=n)\n else:\n torch.min(n, n_avg, out=n)\n return n\n\n def step(self, activate_IA=False, closure=None):\n\n loss = None\n if closure is not None:\n loss = closure()\n\n for group in self.param_groups:\n\n for p in group['params']:\n if p.grad is None:\n continue\n grad = p.grad.data.float()\n if grad.is_sparse:\n raise RuntimeError('LRangerMod does not support sparse gradients')\n\n state = self.state[p]\n\n if len(state) == 0:\n state['step'] = 0\n state['exp_avg'] = torch.zeros_like(p.data)\n state['exp_avg_sq'] = torch.zeros_like(p.data)\n state['num_models'] = 0\n state['cached_params'] = p.data.clone()\n if self.amsgrad:\n state['max_exp_avg_sq'] = torch.zeros_like(p.data)\n if self.AdaMod:\n state['n_avg'] = torch.zeros_like(p.data)\n\n state['step'] += 1\n\n w = min([1.0, state['step']/self.warmup_period])\n exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']\n beta1, beta2, beta3 = group['betas']\n nu1, nu2 = group['nus']\n\n if self.warmup:\n lr = w*group['lr']\n else:\n lr = group['lr']\n\n wd = group['weight_decay']\n alpha = group['alpha']\n\n do_IA = False\n lookahead_step = False\n\n if self.IA and activate_IA:\n lookahead_step = False\n if state['step'] % self.IA_cycle == 0:\n do_IA = True\n elif self.k == 0:\n lookahead_step = False\n else:\n if state['step'] % self.k == 0:\n lookahead_step = True\n else:\n lookahead_step = False\n\n if self.use_gc:\n grad.add_(-grad.mean(dim=tuple(range(1, len(list(grad.size())))), keepdim=True))\n\n exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)\n exp_avg.mul_(beta1).add_(1 - beta1, grad)\n\n momentum = exp_avg.clone()\n momentum.div_(1 - (beta1 ** state['step'])).mul_(nu1).add_(1-nu1, grad)\n\n if wd != 0:\n p.data.add_(-wd*lr, p.data)\n\n beta2_t = beta2 ** state['step']\n\n if self.amsgrad and state['step'] > 1:\n max_exp_avg_sq = state['max_exp_avg_sq']\n # Maintains the maximum of all 2nd moment running avg. till now\n torch.max(max_exp_avg_sq, exp_avg_sq, out=max_exp_avg_sq)\n vt = max_exp_avg_sq.clone()\n else:\n vt = exp_avg_sq.clone()\n\n bias_correction2 = 1 - beta2_t\n vt.div_(bias_correction2)\n if nu2 != 1.0:\n vt.mul_(nu2).addcmul_(1-nu2, grad, grad)\n denom = vt.pow_(group['p']).add_(group['eps'])\n n = lr/denom\n if self.AdaMod:\n n_avg = state['n_avg']\n n = self.apply_AdaMod(beta3, n_avg, n, step=state['step'])\n\n p.data.add_(-n*momentum)\n\n if lookahead_step:\n p.data.mul_(alpha).add_(1.0 - alpha, state['cached_params'])\n state['cached_params'].copy_(p.data)\n\n if do_IA:\n p.data.add_(state[\"num_models\"], state['cached_params']\n ).div_(state[\"num_models\"]+1.0)\n state['cached_params'].copy_(p.data)\n state[\"num_models\"] += 1\n\n return loss\n\n\nclass DemonRanger(Optimizer):\n\n # Rectified-AMSGrad/RAdam + AdaMod + QH Momentum + Iterat Averaging + Lookahead + DEMON (decaying Momentum) + gradient centralization + grad noise\n\n def __init__(self, params, lr=1e-3,\n betas=(0.999, 0.999, 0.999),\n nus=(0.7, 1.0),\n eps=1e-8,\n k=5,\n alpha=0.8,\n gamma=0.55,\n use_demon=True,\n rectify=True,\n amsgrad=True,\n AdaMod=True,\n AdaMod_bias_correct=True,\n IA=True,\n IA_cycle=1000,\n epochs=100,\n step_per_epoch=None,\n weight_decay=0,\n use_gc=True,\n use_grad_noise=False):\n\n # betas = (beta1 for first order moments, beta2 for second order moments, beta3 for ema over adaptive learning rates (AdaMod))\n # nus = (nu1,nu2) (for quasi hyperbolic momentum)\n # eps = small value for numerical stability (avoid divide by zero)\n # k = lookahead cycle\n # alpha = outer learning rate (lookahead)\n # gamma = gradient noise control parameter (for regularization)\n # use_demon = bool to decide whether to use DEMON (Decaying Momentum) or not\n # rectify = bool to decide whether to apply the recitification term (from RAdam) or not\n # amsgrad = bool to decide whether to use amsgrad instead of adam as the core optimizer\n # AdaMod_bias_correct = bool to decide whether to add bias correction to AdaMod\n # IA = bool to decide if Iterate Averaging is ever going to be used\n # IA_cycle = Iterate Averaging Cycle (Recommended to initialize with no. of iterations in Epoch) (doesn't matter if you are not using IA)\n # epochs = No. of epochs you plan to use (Only relevant if using DEMON)\n # step_per_epoch = No. of iterations in an epoch (only relevant if using DEMON)\n # weight decay = decorrelated weight decay value\n # use_gc = bool to determine whether to use gradient centralization or not.\n # use_grad_noise = bool to determine whether to use gradient noise or not.\n\n if not 0.0 <= lr:\n raise ValueError(\"Invalid learning rate: {}\".format(lr))\n if not 0.0 <= eps:\n raise ValueError(\"Invalid epsilon value: {}\".format(eps))\n if not 0.0 <= betas[0] < 1.0:\n raise ValueError(\"Invalid beta parameter at index 0: {}\".format(betas[0]))\n if not 0.0 <= betas[1] < 1.0:\n raise ValueError(\"Invalid beta parameter at index 1: {}\".format(betas[1]))\n if not 0.0 <= betas[2] < 1.0:\n raise ValueError(\"Invalid beta parameter at index 2: {}\".format(betas[2]))\n if not 0.0 <= nus[0] <= 1.0:\n raise ValueError(\"Invalid nu parameter at index 0: {}\".format(nus[0]))\n if not 0.0 <= nus[1] <= 1.0:\n raise ValueError(\"Invalid nu parameter at index 1: {}\".format(nus[1]))\n if not 0.0 <= alpha <= 1.0:\n raise ValueError(\"Invalid alpha parameter: {}\".format(alpha))\n\n self.use_gc = use_gc\n self.use_grad_noise = use_grad_noise\n self.k = k\n self.epochs = epochs\n self.amsgrad = amsgrad\n self.use_demon = use_demon\n self.IA_cycle = IA_cycle\n self.IA = IA\n self.rectify = rectify\n self.AdaMod = AdaMod\n self.AdaMod_bias_correct = AdaMod_bias_correct\n if step_per_epoch is None:\n self.step_per_epoch = IA_cycle\n else:\n self.step_per_epoch = step_per_epoch\n\n self.T = self.epochs*self.step_per_epoch\n\n defaults = dict(lr=lr,\n betas=betas,\n nus=nus,\n eps=eps,\n alpha=alpha,\n gamma=gamma,\n weight_decay=weight_decay)\n super(DemonRanger, self).__init__(params, defaults)\n\n def __setstate__(self, state):\n super(DemonRanger, self).__setstate__(state)\n\n def apply_AdaMod(self, beta3, n_avg, n, step):\n n_avg.mul_(beta3).add_(1 - beta3, n)\n if self.AdaMod_bias_correct:\n n_avg_ = n_avg.clone()\n n_avg_.div_(1 - (beta3 ** step))\n torch.min(n, n_avg_, out=n)\n else:\n torch.min(n, n_avg, out=n)\n return n\n\n def step(self, activate_IA=False, closure=None):\n\n loss = None\n if closure is not None:\n loss = closure()\n\n for group in self.param_groups:\n\n for p in group['params']:\n if p.grad is None:\n continue\n grad = p.grad.data.float()\n if grad.is_sparse:\n raise RuntimeError('DemonRanger does not support sparse gradients')\n\n state = self.state[p]\n\n if len(state) == 0:\n state['step'] = 0\n state['exp_avg'] = torch.zeros_like(p.data)\n state['exp_avg_sq'] = torch.zeros_like(p.data)\n state['num_models'] = 0\n state['cached_params'] = p.data.clone()\n if self.amsgrad:\n state['max_exp_avg_sq'] = torch.zeros_like(p.data)\n if self.AdaMod:\n state['n_avg'] = torch.zeros_like(p.data)\n\n state['step'] += 1\n exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']\n beta1_init, beta2, beta3 = group['betas']\n rho_inf = (2/(1-beta2)) - 1\n nu1, nu2 = group['nus']\n lr = group['lr']\n wd = group['weight_decay']\n alpha = group['alpha']\n gamma = group['gamma']\n\n do_IA = False\n lookahead_step = False\n\n if self.IA and activate_IA:\n lookahead_step = False\n if state['step'] % self.IA_cycle == 0:\n do_IA = True\n elif self.k == 0:\n lookahead_step = False\n else:\n if state['step'] % self.k == 0:\n lookahead_step = True\n else:\n lookahead_step = False\n\n if self.use_demon:\n temp = 1-(state['step']/self.T)\n beta1 = beta1_init * temp / ((1-beta1_init)+beta1_init*temp)\n else:\n beta1 = beta1_init\n\n if self.use_grad_noise:\n grad_var = lr/((1+state['step'])**gamma)\n grad_noise = torch.empty_like(grad).normal_(mean=0.0, std=math.sqrt(grad_var))\n grad.add_(grad_noise)\n\n if self.use_gc:\n grad.add_(-grad.mean(dim=tuple(range(1, len(list(grad.size())))), keepdim=True))\n\n exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)\n exp_avg.mul_(beta1).add_(1 - beta1, grad)\n\n momentum = exp_avg.clone()\n momentum.div_(1 - (beta1 ** state['step'])).mul_(nu1).add_(1-nu1, grad)\n\n if wd != 0:\n p.data.add_(-wd*lr, p.data)\n\n beta2_t = beta2 ** state['step']\n\n if self.amsgrad and state['step'] > 1:\n max_exp_avg_sq = state['max_exp_avg_sq']\n # Maintains the maximum of all 2nd moment running avg. till now\n torch.max(max_exp_avg_sq, exp_avg_sq, out=max_exp_avg_sq)\n vt = max_exp_avg_sq.clone()\n else:\n vt = exp_avg_sq.clone()\n\n if self.rectify:\n rho_t = rho_inf - 2 * state['step'] * beta2_t / (1 - beta2_t)\n\n # more conservative since it's an approximated value\n if rho_t >= 5:\n R = math.sqrt(((rho_t-4)*(rho_t-2)*rho_inf) /\n ((rho_inf-4)*(rho_inf-2)*rho_t))\n bias_correction2 = 1 - beta2_t\n vt.div_(bias_correction2)\n if nu2 != 1.0:\n vt.mul_(nu2).addcmul_(1-nu2, grad, grad)\n denom = vt.sqrt_().add_(group['eps'])\n\n n = (lr*R)/denom\n\n if self.AdaMod:\n n_avg = state['n_avg']\n n = self.apply_AdaMod(beta3, n_avg, n, step=state['step'])\n\n p.data.add_(-n*momentum)\n else:\n if self.AdaMod:\n n_avg = state['n_avg']\n n_avg.mul_(beta3).add_(1 - beta3, lr)\n p.data.add_(-lr, momentum)\n else:\n bias_correction2 = 1 - beta2_t\n vt.div_(bias_correction2)\n if nu2 != 1.0:\n vt.mul_(nu2).addcmul_(1-nu2, grad, grad)\n denom = vt.sqrt_().add_(group['eps'])\n n = lr/denom\n if self.AdaMod:\n n_avg = state['n_avg']\n n = self.apply_AdaMod(beta3, n_avg, n, step=state['step'])\n\n p.data.add_(-n*momentum)\n\n if lookahead_step:\n p.data.mul_(alpha).add_(1.0 - alpha, state['cached_params'])\n state['cached_params'].copy_(p.data)\n\n if do_IA:\n p.data.add_(state[\"num_models\"], state['cached_params']\n ).div_(state[\"num_models\"]+1.0)\n state['cached_params'].copy_(p.data)\n state[\"num_models\"] += 1\n\n return loss\n\n\nclass HyperRanger(Optimizer):\n\n # Nostalgic PAdam + QH Momentum + Iterate Averaging + Lookahead + DEMON (decaying Momentum) + gradient centralization + hypergradient descent on lr and nu1\n\n def __init__(self, params, lr=1e-3,\n betas=(0.999, 0.999),\n nus=(0.7, 1.0),\n eps=1e-8,\n gamma=0.0001,\n nostalgia=True,\n use_demon=True,\n hypergrad_lr=1e-7,\n HDM=False,\n hypertune_nu1=False,\n p=0.25,\n k=5,\n alpha=0.8,\n IA=True,\n IA_cycle=1000,\n epochs=100,\n step_per_epoch=None,\n weight_decay=0,\n use_gc=True):\n\n # betas = (beta1 for first order moments, beta2 for second order moments)\n # nus = (nu1,nu2) (for quasi hyperbolic momentum)\n # eps = small value for numerical stability (avoid divide by zero)\n # k = lookahead cycle\n # alpha = outer learning rate (lookahead)\n # gamma = used for nostalgia\n # nostalgia = bool to decide whether to use nostalgia (from Nostalgic Adam or NosAdam)\n # use_demon = bool to decide whether to use DEMON (Decaying Momentum) or not\n # hypergrad_lr = learning rate for updating hyperparameters (like lr) through hypergradient descent (probably need to increase around 0.02 if HDM is True). Set to 0.0 to disable hypergradient descent.\n # HDM = bool to decide whether to use Multiplicative rule for updating hyperparameters or not\n # hypertune_nu1 = bool to decide whether apply hypergradient descent on nu1 as well or not.\n # p = p from PAdam\n # IA = bool to decide if Iterate Averaging is ever going to be used\n # IA_cycle = Iterate Averaging Cycle (Recommended to initialize with no. of iterations in Epoch) (doesn't matter if you are not using IA)\n # epochs = No. of epochs you plan to use (Only relevant if using DEMON)\n # step_per_epoch = No. of iterations in an epoch (only relevant if using DEMON)\n # weight decay = decorrelated weight decay value\n # use_gc = bool to determine whether to use gradient centralization or not.\n # use_grad_noise = bool to determine whether to use gradient noise or not.\n\n if not 0.0 <= lr:\n raise ValueError(\"Invalid learning rate: {}\".format(lr))\n if not 0.0 <= hypergrad_lr:\n raise ValueError(\"Invalid hypergradient learning rate: {}\".format(hypergrad_lr))\n if not 0.0 <= eps:\n raise ValueError(\"Invalid epsilon value: {}\".format(eps))\n if not 0.0 <= betas[0] < 1.0:\n raise ValueError(\"Invalid beta parameter at index 0: {}\".format(betas[0]))\n if not 0.0 <= betas[1] < 1.0:\n raise ValueError(\"Invalid beta parameter at index 1: {}\".format(betas[1]))\n if not 0.0 <= nus[0] <= 1.0:\n raise ValueError(\"Invalid nu parameter at index 0: {}\".format(nus[0]))\n if not 0.0 <= nus[1] <= 1.0:\n raise ValueError(\"Invalid nu parameter at index 1: {}\".format(nus[1]))\n if not 0.0 <= p <= 0.5:\n raise ValueError(\"Invalid p parameter: {}\".format(p))\n if not 0.0 <= alpha < 1.0:\n raise ValueError(\"Invalid alpha parameter: {}\".format(alpha))\n\n self.nostalgia = nostalgia\n self.use_demon = use_demon\n self.k = k\n self.IA = IA\n self.IA_cycle = IA_cycle\n self.epochs = epochs\n if step_per_epoch is None:\n self.step_per_epoch = IA_cycle\n else:\n self.step_per_epoch = step_per_epoch\n self.use_gc = use_gc\n self.T = self.epochs*self.step_per_epoch\n self.hypertune_nu1 = hypertune_nu1\n self.HDM = HDM\n\n defaults = dict(lr=lr,\n betas=betas,\n nu1=nus[0],\n nu2=nus[1],\n eps=eps,\n alpha=alpha,\n gamma=gamma,\n p=p,\n hypergrad_lr=hypergrad_lr,\n weight_decay=weight_decay)\n super(HyperRanger, self).__init__(params, defaults)\n\n def __setstate__(self, state):\n super(HyperRanger, self).__setstate__(state)\n\n def step(self, activate_IA=False, display=False, closure=None):\n\n loss = None\n if closure is not None:\n loss = closure()\n\n for group in self.param_groups:\n\n for p in group['params']:\n if p.grad is None:\n continue\n grad = p.grad.data.float()\n if grad.is_sparse:\n raise RuntimeError('HyperRanger does not support sparse gradients')\n\n state = self.state[p]\n\n hypergrad_lr = group['hypergrad_lr']\n beta1_init, beta2 = group['betas']\n wd = group['weight_decay']\n alpha = group['alpha']\n gamma = group['gamma']\n\n if len(state) == 0:\n state['step'] = 0\n state['exp_avg'] = torch.zeros_like(p.data)\n state['exp_avg_sq'] = torch.zeros_like(p.data)\n state['lr'] = group['lr']\n\n if self.IA:\n state['num_models'] = 0\n if self.IA or (self.k > 0):\n state['cached_params'] = p.data.clone()\n if self.nostalgia:\n state['B_old'] = 0\n state['B_new'] = 1\n if hypergrad_lr > 0.0:\n state['nu'] = group['nu']\n state['prev_lr_grad'] = torch.zeros_like(grad.view(-1))\n if self.hypertune_nu1:\n state['prev_nu_grad'] = torch.zeros_like(grad.view(-1))\n\n state['step'] += 1\n exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']\n\n if self.use_demon:\n temp = 1-(state['step']/self.T)\n beta1 = beta1_init * temp / ((1-beta1_init)+beta1_init*temp)\n else:\n beta1 = beta1_init\n\n if self.nostalgia:\n beta2 = state['B_old']/state['B_new']\n state['B_old'] += math.pow(state['step'], -gamma)\n state['B_new'] += math.pow(state['step']+1, -gamma)\n\n do_IA = False\n lookahead_step = False\n\n if self.IA and activate_IA:\n lookahead_step = False\n if state['step'] % self.IA_cycle == 0:\n do_IA = True\n elif self.k == 0:\n lookahead_step = False\n else:\n if state['step'] % self.k == 0:\n lookahead_step = True\n else:\n lookahead_step = False\n\n if state['step'] > 1 and hypergrad_lr > 0.0:\n prev_lr_grad = state['prev_lr_grad']\n h = torch.dot(grad.view(-1), prev_lr_grad)\n\n if self.HDM:\n grad_norm = grad.view(-1).norm()\n norm_denom = grad_norm*(prev_lr_grad.norm())\n norm_denom.add_(group['eps'])\n state['lr'] = state['lr']*(1-hypergrad_lr*(h/norm_denom))\n else:\n state['lr'] -= hypergrad_lr * h\n\n torch.max(state['lr'], torch.zeros_like(state['lr']), out=state['lr'])\n\n if display:\n print(\"lr\", state['lr'])\n\n if self.hypertune_nu1:\n prev_nu_grad = state['prev_nu_grad']\n h = torch.dot(grad.view(-1), prev_nu_grad)\n if self.HDM:\n norm_denom = grad_norm*(prev_nu_grad.norm())\n norm_denom.add_(group['eps'])\n state['nu1'] = state['nu1']*(1-hypergrad_lr*(h/norm_denom))\n else:\n state['nu1'] -= hypergrad_lr * h\n\n torch.max(state['nu1'], torch.zeros_like(state['nu1']), out=state['nu1'])\n torch.min(state['nu1'], torch.ones_like(state['nu1']), out=state['nu1'])\n\n if display:\n print(\"nu\", state['nu1'])\n\n if self.use_gc:\n grad.add_(-grad.mean(dim=tuple(range(1, len(list(grad.size())))), keepdim=True))\n\n nu1 = state['nu1']\n nu2 = state['nu2']\n exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)\n exp_avg.mul_(beta1).add_(1 - beta1, grad)\n\n momentum = exp_avg.clone()\n bias_correction1 = 1 - (beta1 ** state['step'])\n momentum.div_(bias_correction1)\n\n vt = exp_avg_sq.clone()\n\n if not self.nostalgia:\n vt.div_(1 - (beta2 ** state['step']))\n if nu2 != 1.0:\n vt.mul_(nu2).addcmul_(1-nu2, grad, grad)\n\n denom = vt.pow_(group['p']).add_(group['eps'])\n\n n = state['lr']/denom\n\n if lookahead_step:\n dalpha = alpha\n elif do_IA:\n dalpha = (1/(state[\"num_models\"]+1.0))\n else:\n dalpha = 1.0\n\n if hypergrad_lr > 0.0 and self.hypertune_nu1:\n state['prev_nu_grad'] = (-dalpha*n*(momentum - grad)).view(-1)\n\n momentum.mul_(nu1).add_(1-nu1, grad) # quasi hyperbolic momentum\n\n if hypergrad_lr > 0.0:\n temp = dalpha*(-(momentum/denom) - wd*p.data)\n state['prev_lr_grad'] = temp.view(-1)\n\n p.data.add_(-n*momentum)\n\n if wd != 0:\n p.data.add_(-wd*state['lr'], p.data)\n\n if lookahead_step:\n p.data.mul_(alpha).add_(1.0 - alpha, state['cached_params'])\n state['cached_params'].copy_(p.data)\n\n if do_IA:\n p.data.add_(state[\"num_models\"], state['cached_params']\n ).div_(state[\"num_models\"]+1.0)\n state['cached_params'].copy_(p.data)\n state[\"num_models\"] += 1\n\n return loss\n\n\nclass HyperRangerMod(Optimizer):\n\n # Different from HyperRanger integrates AdaMod, and hypergradient descent through it. Slower, however.\n # doesn't have hypertunability for nu1 though.\n\n def __init__(self, params, lr=1e-3,\n betas=(0.999, 0.999, 0.999),\n nus=(0.7, 1.0),\n eps=1e-8,\n AdaMod_bias_correct=True,\n gamma=0.0001,\n nostalgia=True,\n use_demon=True,\n hypergrad_lr=1e-7,\n p=0.5,\n k=5,\n alpha=0.8,\n IA=True,\n IA_cycle=1000,\n epochs=100,\n step_per_epoch=None,\n weight_decay=0,\n use_gc=True):\n\n # betas = (beta1 for first order moments, beta2 for second order moments, beta3 for AdaMod) # set beta3 = 0 to disable AdaMod\n # nus = (nu1,nu2) (for quasi hyperbolic momentum)\n # eps = small value for numerical stability (avoid divide by zero)\n # AdaMod_bias_correct = bool to determine whether to apply bias correction on AdaMod or not\n # k = lookahead cycle\n # alpha = outer learning rate (lookahead)\n # gamma = used for nostalgia\n # nostalgia = bool to decide whether to use nostalgia (from Nostalgic Adam or NosAdam)\n # use_demon = bool to decide whether to use DEMON (Decaying Momentum) or not\n # hypergrad_lr = learning rate for updating hyperparameters (like lr) through hypergradient descent (probably need to increase around 0.02 if HDM is True). Set to 0.0 to disable hypergradient descent.\n # HDM = bool to decide whether to use Multiplicative rule for updating hyperparameters or not\n # hypertune_nu1 = bool to decide whether apply hypergradient descent on nu1 as well or not.\n # p = p from PAdam\n # IA = bool to decide if Iterate Averaging is ever going to be used\n # IA_cycle = Iterate Averaging Cycle (Recommended to initialize with no. of iterations in Epoch) (doesn't matter if you are not using IA)\n # epochs = No. of epochs you plan to use (Only relevant if using DEMON)\n # step_per_epoch = No. of iterations in an epoch (only relevant if using DEMON)\n # weight decay = decorrelated weight decay value\n # use_gc = bool to determine whether to use gradient centralization or not.\n # use_grad_noise = bool to determine whether to use gradient noise or not.\n\n if not 0.0 <= lr:\n raise ValueError(\"Invalid learning rate: {}\".format(lr))\n if not 0.0 <= hypergrad_lr:\n raise ValueError(\"Invalid hypergradient learning rate: {}\".format(hypergrad_lr))\n if not 0.0 <= eps:\n raise ValueError(\"Invalid epsilon value: {}\".format(eps))\n if not 0.0 <= betas[0] < 1.0:\n raise ValueError(\"Invalid beta parameter at index 0: {}\".format(betas[0]))\n if not 0.0 <= betas[1] < 1.0:\n raise ValueError(\"Invalid beta parameter at index 1: {}\".format(betas[1]))\n if not 0.0 <= betas[2] < 1.0:\n raise ValueError(\"Invalid beta parameter at index 2: {}\".format(betas[2]))\n if not 0.0 <= nus[0] <= 1.0:\n raise ValueError(\"Invalid nu parameter at index 0: {}\".format(nus[0]))\n if not 0.0 <= nus[1] <= 1.0:\n raise ValueError(\"Invalid nu parameter at index 1: {}\".format(nus[1]))\n if not 0.0 <= p <= 0.5:\n raise ValueError(\"Invalid p parameter: {}\".format(p))\n if not 0.0 <= alpha < 1.0:\n raise ValueError(\"Invalid alpha parameter: {}\".format(alpha))\n\n self.AdaMod_bias_correct = AdaMod_bias_correct\n self.nostalgia = nostalgia\n self.use_demon = use_demon\n self.k = k\n self.IA = IA\n self.IA_cycle = IA_cycle\n self.epochs = epochs\n if step_per_epoch is None:\n self.step_per_epoch = IA_cycle\n else:\n self.step_per_epoch = step_per_epoch\n self.use_gc = use_gc\n self.T = self.epochs*self.step_per_epoch\n\n defaults = dict(lr=lr,\n betas=betas,\n nus=nus,\n eps=eps,\n alpha=alpha,\n gamma=gamma,\n p=p,\n hypergrad_lr=hypergrad_lr,\n weight_decay=weight_decay)\n super(HyperRangerMod, self).__init__(params, defaults)\n\n def __setstate__(self, state):\n super(HyperRangerMod, self).__setstate__(state)\n\n def step(self, display=False, activate_IA=False, closure=None):\n\n loss = None\n if closure is not None:\n loss = closure()\n\n for group in self.param_groups:\n\n for p in group['params']:\n if p.grad is None:\n continue\n grad = p.grad.data.float()\n if grad.is_sparse:\n raise RuntimeError('HyperRangerMod does not support sparse gradients')\n\n state = self.state[p]\n\n hypergrad_lr = group['hypergrad_lr']\n beta1_init, beta2, beta3 = group['betas']\n nu1, nu2 = group['nus']\n wd = group['weight_decay']\n alpha = group['alpha']\n gamma = group['gamma']\n\n if len(state) == 0:\n state['step'] = 0\n state['exp_avg'] = torch.zeros_like(p.data)\n state['exp_avg_sq'] = torch.zeros_like(p.data)\n\n if self.IA:\n state['num_models'] = 0\n if self.IA or self.k > 0:\n state['cached_params'] = p.data.clone()\n if beta3 > 0.0:\n state['n_avg'] = torch.zeros_like(p.data)\n if self.nostalgia:\n state['B_old'] = 0\n state['B_new'] = 1\n if hypergrad_lr > 0.0:\n state['cached_hypergrad_comp'] = torch.zeros_like(grad.view(-1))\n\n state['step'] += 1\n exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']\n\n if self.use_demon:\n temp = 1-(state['step']/self.T)\n beta1 = beta1_init * temp / ((1-beta1_init)+beta1_init*temp)\n else:\n beta1 = beta1_init\n\n if self.nostalgia:\n beta2 = state['B_old']/state['B_new']\n state['B_old'] += math.pow(state['step'], -gamma)\n state['B_new'] += math.pow(state['step']+1, -gamma)\n\n do_IA = False\n lookahead_step = False\n\n if self.IA and activate_IA:\n lookahead_step = False\n if state['step'] % self.IA_cycle == 0:\n do_IA = True\n elif self.k == 0:\n lookahead_step = False\n else:\n if state['step'] % self.k == 0:\n lookahead_step = True\n else:\n lookahead_step = False\n\n if state['step'] > 1 and hypergrad_lr > 0.0:\n du = state['cached_hypergrad_comp']\n h = torch.dot(grad.view(-1), du)\n state['lr'] -= hypergrad_lr * h\n torch.max(state['lr'], torch.zeros_like(state['lr']), out=state['lr'])\n if display:\n print(state['lr'])\n\n if self.use_gc:\n grad.add_(-grad.mean(dim=tuple(range(1, len(list(grad.size())))), keepdim=True))\n\n exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)\n exp_avg.mul_(beta1).add_(1 - beta1, grad)\n\n momentum = exp_avg.clone()\n momentum.div_(1 - (beta1 ** state['step'])).mul_(nu1).add_(1-nu1, grad)\n vt = exp_avg_sq.clone()\n\n if not self.nostalgia:\n vt.div_(1 - (beta2 ** state['step']))\n if nu2 != 1.0:\n vt.mul_(nu2).addcmul_(1-nu2, grad, grad)\n\n denom = vt.pow_(group['p']).add_(group['eps'])\n\n n = state['lr']/denom\n\n if beta3 > 0.0: # apply AdaMod\n n_avg = state['n_avg']\n n_avg.mul_(beta3).add_(1 - beta3, n)\n if self.AdaMod_bias_correct:\n n_avg_ = n_avg.clone()\n bias_correction3 = 1 - (beta3 ** state['step'])\n n_avg_.div_(bias_correction3)\n torch.min(n, n_avg_, out=n)\n else:\n torch.min(n, n_avg, out=n)\n\n p.data.add_(-n*momentum)\n\n if lookahead_step:\n dalpha = alpha\n elif do_IA:\n dalpha = (1/(state[\"num_models\"]+1.0))\n else:\n dalpha = 1.0\n\n if hypergrad_lr > 0.0:\n\n if beta3 > 0.0:\n grad_from_n = dalpha*(-(momentum/denom) - wd*p.data)\n\n if self.AdaMod_bias_correct:\n grad_from_n_avg_ = dalpha * \\\n (-((1-beta3)/bias_correction3)*(momentum/denom) - wd*p.data)\n du = torch.where(n_avg_ < n,\n grad_from_n_avg_,\n grad_from_n)\n else:\n grad_from_n_avg = dalpha*(-(1-beta3)*(momentum/denom) - wd*p.data)\n du = torch.where(n_avg < n,\n grad_from_n_avg,\n grad_from_n)\n\n else:\n du = dalpha*(-(momentum/denom) - wd*p.data)\n\n state['cached_hypergrad_comp'] = du.view(-1)\n\n if wd != 0:\n p.data.add_(-wd*state['lr'], p.data)\n\n if lookahead_step:\n p.data.mul_(alpha).add_(1.0 - alpha, state['cached_params'])\n state['cached_params'].copy_(p.data)\n\n if do_IA:\n p.data.add_(state[\"num_models\"], state['cached_params']\n ).div_(state[\"num_models\"]+1.0)\n state['cached_params'].copy_(p.data)\n state[\"num_models\"] += 1\n\n return loss\n\n\nclass HDQHSGDW(Optimizer):\n def __init__(self, params, lr=1e-3,\n beta=0.999,\n nu=0.7,\n hypergrad_lr=1e-3,\n HDM=False,\n k=5,\n alpha=0.5,\n eps=1e-8,\n weight_decay=0,\n use_gc=True):\n\n # BASIC SGD + Momentum but with QHMomentum and Hypergradient descent over all beta, lr, and nu + Lookahead and decorrelated weight decay\n # they say the best of them all is still SGD + Momentum?\n\n if not 0.0 <= lr:\n raise ValueError(\"Invalid learning rate: {}\".format(lr))\n if not 0.0 <= hypergrad_lr:\n raise ValueError(\"Invalid hypergradient learning rate: {}\".format(hypergrad_lr))\n if not 0.0 <= beta < 1.0:\n raise ValueError(\"Invalid beta parameter: {}\".format(beta))\n if not 0.0 <= nu <= 1.0:\n raise ValueError(\"Invalid nu parameter: {}\".format(nu))\n if not 0.0 <= alpha < 1.0:\n raise ValueError(\"Invalid alpha parameter: {}\".format(alpha))\n\n self.k = k\n self.use_gc = use_gc\n self.HDM = HDM\n\n defaults = dict(lr=lr,\n beta=beta,\n nu=nu,\n alpha=alpha,\n hypergrad_lr=hypergrad_lr,\n eps=eps,\n weight_decay=weight_decay)\n super(HDQHSGDW, self).__init__(params, defaults)\n\n def __setstate__(self, state):\n super(HDQHSGDW, self).__setstate__(state)\n\n def hyperupdate(self, update, grad, grad_comp, hypergrad_lr, eps):\n h = torch.dot(grad.view(-1), grad_comp)\n\n if self.HDM:\n grad_norm = grad.view(-1).norm()\n norm_denom = grad_norm*(grad_comp.norm())\n norm_denom.add_(eps)\n update = update*(1-hypergrad_lr*(h/norm_denom))\n else:\n update -= hypergrad_lr * h\n\n return update\n\n def step(self, display=False, closure=None):\n\n loss = None\n if closure is not None:\n loss = closure()\n\n for group in self.param_groups:\n\n for p in group['params']:\n if p.grad is None:\n continue\n grad = p.grad.data.float()\n if grad.is_sparse:\n raise RuntimeError('HDQHSGDW does not support sparse gradients')\n\n state = self.state[p]\n\n hypergrad_lr = group['hypergrad_lr']\n wd = group['weight_decay']\n alpha = group['alpha']\n\n if len(state) == 0:\n state['step'] = 0\n state['lr'] = group['lr']\n state['nu'] = group['nu']\n state['beta'] = group['beta']\n state['exp_avg'] = torch.zeros_like(p.data)\n if self.k > 0:\n state['cached_params'] = p.data.clone()\n if hypergrad_lr > 0.0:\n state['prev_lr_grad'] = torch.zeros_like(grad.view(-1))\n state['prev_nu_grad'] = torch.zeros_like(grad.view(-1))\n state['prev_beta_grad'] = torch.zeros_like(grad.view(-1))\n\n state['step'] += 1\n exp_avg = state['exp_avg']\n\n lookahead_step = False\n\n if self.k == 0:\n lookahead_step = False\n else:\n if state['step'] % self.k == 0:\n lookahead_step = True\n else:\n lookahead_step = False\n\n if state['step'] > 1 and hypergrad_lr > 0.0:\n\n prev_lr_grad = state['prev_lr_grad']\n prev_beta_grad = state['prev_beta_grad']\n prev_nu_grad = state['prev_nu_grad']\n\n state['lr'] = self.hyperupdate(update=state['lr'],\n grad=grad,\n grad_comp=prev_lr_grad,\n hypergrad_lr=hypergrad_lr,\n eps=group['eps'])\n\n torch.max(state['lr'], torch.zeros_like(state['lr']), out=state['lr'])\n\n if display:\n print(\"lr\", state['lr'])\n\n state['beta'] = self.hyperupdate(update=state['beta'],\n grad=grad,\n grad_comp=prev_beta_grad,\n hypergrad_lr=hypergrad_lr,\n eps=group['eps'])\n\n torch.max(state['beta'], torch.zeros_like(state['beta']), out=state['beta'])\n torch.min(state['beta'], torch.ones_like(state['beta']), out=state['beta'])\n\n if display:\n print(\"beta\", group['beta'])\n\n state['nu'] = self.hyperupdate(update=state['nu'],\n grad=grad,\n grad_comp=prev_beta_grad,\n hypergrad_lr=hypergrad_lr,\n eps=group['eps'])\n\n torch.max(state['nu'], torch.zeros_like(state['nu']), out=state['nu'])\n torch.min(state['nu'], torch.ones_like(state['nu']), out=state['nu'])\n\n if display:\n print(\"nu\", state['nu'])\n\n if self.use_gc:\n grad.add_(-grad.mean(dim=tuple(range(1, len(list(grad.size())))), keepdim=True))\n\n nu = state['nu']\n beta = state['beta']\n lr = state['lr']\n\n if lookahead_step:\n dalpha = alpha\n else:\n dalpha = 1.0\n\n gx = 1 - (beta ** state['step'])\n fx = beta*exp_avg + (1-beta)*grad\n\n if hypergrad_lr > 0.0:\n dfx = exp_avg - grad\n dgx = - state['step'] * beta**(state['step']-1)\n dbeta = (gx*dfx + fx*dgx)/(math.pow(gx, 2)+group['eps'])\n dbeta = - dalpha*lr*nu*dbeta\n state['prev_beta_grad'] = dbeta.view(-1)\n\n momentum = fx/gx\n group['exp_avg'] = fx\n\n if hypergrad_lr > 0.0:\n state['prev_nu_grad'] = (-dalpha*lr*(momentum - grad)).view(-1)\n\n momentum.mul_(nu).add_(1-nu, grad) # quasi hyperbolic momentum\n\n if hypergrad_lr > 0.0:\n temp = dalpha*(-momentum - wd*p.data)\n state['prev_lr_grad'] = temp.view(-1)\n\n p.data.add_(-group['lr']*momentum)\n\n if wd != 0:\n p.data.add_(-wd*group['lr'], p.data)\n\n if lookahead_step:\n p.data.mul_(alpha).add_(1.0 - alpha, state['cached_params'])\n state['cached_params'].copy_(p.data)\n\n return loss\n\n\nclass HyperProp(Optimizer):\n\n # LaProp + hypergradient descent on lr and nu (for QH momentum) + QH Momentum + Decaying Momentum (DEMON) + Lookahead + Iterate Averaging + Nostalgia (from NosAdam) + P from PAdam\n # + gradient centralization + weight decay\n def __init__(self, params, lr=1e-3,\n betas=(0.999, 0.999),\n nu=0.7,\n eps=1e-8,\n gamma=0.0001,\n nostalgia=True,\n use_demon=True,\n hypergrad_lr=0.02,\n HDM=True,\n hypertune_nu=True,\n p=0.25,\n k=5,\n alpha=0.8,\n IA=True,\n IA_cycle=1000,\n epochs=100,\n step_per_epoch=None,\n weight_decay=0,\n use_gc=True):\n\n # betas = (beta1 for first order moments, beta2 for second order moments)\n # nu = for quasi hyperbolic momentum\n # eps = small value for numerical stability (avoid divide by zero)\n # k = lookahead cycle\n # alpha = outer learning rate (lookahead)\n # gamma = used for nostalgia\n # nostalgia = bool to decide whether to use nostalgia (from Nostalgic Adam or NosAdam)\n # use_demon = bool to decide whether to use DEMON (Decaying Momentum) or not\n # hypergrad_lr = learning rate for updating hyperparameters (like lr) through hypergradient descent (probably need to increase around 0.02 if HDM is True). Set to 0.0 to disable hypergradient descent.\n # HDM = bool to decide whether to use Multiplicative rule for updating hyperparameters or not\n # hypertune_nu1 = bool to decide whether apply hypergradient descent on nu1 as well or not.\n # p = p from PAdam\n # IA = bool to decide if Iterate Averaging is ever going to be used\n # IA_cycle = Iterate Averaging Cycle (Recommended to initialize with no. of iterations in Epoch) (doesn't matter if you are not using IA)\n # epochs = No. of epochs you plan to use (Only relevant if using DEMON)\n # step_per_epoch = No. of iterations in an epoch (only relevant if using DEMON)\n # weight decay = decorrelated weight decay value\n # use_gc = bool to determine whether to use gradient centralization or not.\n # use_grad_noise = bool to determine whether to use gradient noise or not.\n\n if not 0.0 <= lr:\n raise ValueError(\"Invalid learning rate: {}\".format(lr))\n if not 0.0 <= hypergrad_lr:\n raise ValueError(\"Invalid hypergradient learning rate: {}\".format(hypergrad_lr))\n if not 0.0 <= eps:\n raise ValueError(\"Invalid epsilon value: {}\".format(eps))\n if not 0.0 <= betas[0] < 1.0:\n raise ValueError(\"Invalid beta parameter at index 0: {}\".format(betas[0]))\n if not 0.0 <= betas[1] < 1.0:\n raise ValueError(\"Invalid beta parameter at index 1: {}\".format(betas[1]))\n if not 0.0 <= nu <= 1.0:\n raise ValueError(\"Invalid nu parameter: {}\".format(nu))\n if not 0.0 <= p <= 0.5:\n raise ValueError(\"Invalid p parameter: {}\".format(p))\n if not 0.0 <= alpha < 1.0:\n raise ValueError(\"Invalid alpha parameter: {}\".format(alpha))\n\n self.nostalgia = nostalgia\n self.use_demon = use_demon\n self.k = k\n self.IA = IA\n self.IA_cycle = IA_cycle\n self.epochs = epochs\n if step_per_epoch is None:\n self.step_per_epoch = IA_cycle\n else:\n self.step_per_epoch = step_per_epoch\n self.use_gc = use_gc\n self.T = self.epochs*self.step_per_epoch\n self.hypertune_nu = hypertune_nu\n self.HDM = HDM\n\n defaults = dict(lr=lr,\n betas=betas,\n nu=nu,\n eps=eps,\n alpha=alpha,\n gamma=gamma,\n p=p,\n hypergrad_lr=hypergrad_lr,\n weight_decay=weight_decay)\n super(HyperProp, self).__init__(params, defaults)\n\n def __setstate__(self, state):\n super(HyperProp, self).__setstate__(state)\n\n def step(self, activate_IA=False, display=False, closure=None):\n\n loss = None\n if closure is not None:\n loss = closure()\n\n for group in self.param_groups:\n\n for p in group['params']:\n if p.grad is None:\n continue\n grad = p.grad.data.float()\n if grad.is_sparse:\n raise RuntimeError('HyperProp does not support sparse gradients')\n\n state = self.state[p]\n\n hypergrad_lr = group['hypergrad_lr']\n beta1_init, beta2 = group['betas']\n wd = group['weight_decay']\n alpha = group['alpha']\n gamma = group['gamma']\n\n if len(state) == 0:\n state['lr'] = group['lr']\n state['nu'] = group['nu']\n state['step'] = 0\n state['exp_avg'] = torch.zeros_like(p.data)\n state['exp_avg_sq'] = torch.zeros_like(p.data)\n\n if self.IA:\n state['num_models'] = 0\n if self.IA or (self.k > 0):\n state['cached_params'] = p.data.clone()\n if self.nostalgia:\n state['B_old'] = 0\n state['B_new'] = 1\n if hypergrad_lr > 0.0:\n state['prev_lr_grad'] = torch.zeros_like(grad.view(-1))\n if self.hypertune_nu:\n state['prev_nu_grad'] = torch.zeros_like(grad.view(-1))\n\n state['step'] += 1\n exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']\n\n if self.use_demon:\n temp = 1-(state['step']/self.T)\n beta1 = beta1_init * temp / ((1-beta1_init)+beta1_init*temp)\n else:\n beta1 = beta1_init\n\n if self.nostalgia:\n beta2 = state['B_old']/state['B_new']\n state['B_old'] += math.pow(state['step'], -gamma)\n state['B_new'] += math.pow(state['step']+1, -gamma)\n\n do_IA = False\n lookahead_step = False\n\n if self.IA and activate_IA:\n lookahead_step = False\n if state['step'] % self.IA_cycle == 0:\n do_IA = True\n elif self.k == 0:\n lookahead_step = False\n else:\n if state['step'] % self.k == 0:\n lookahead_step = True\n else:\n lookahead_step = False\n\n if state['step'] > 1 and hypergrad_lr > 0.0:\n prev_lr_grad = state['prev_lr_grad']\n h = torch.dot(grad.view(-1), prev_lr_grad)\n\n if self.HDM:\n grad_norm = grad.view(-1).norm()\n norm_denom = grad_norm*(prev_lr_grad.norm())\n norm_denom.add_(group['eps'])\n state['lr'] = state['lr']*(1-hypergrad_lr*(h/norm_denom))\n else:\n state['lr'] -= hypergrad_lr * h\n\n torch.max(state['lr'], torch.zeros_like(state['lr']), out=state['lr'])\n\n if display:\n print(\"lr\", state['lr'])\n\n if self.hypertune_nu:\n prev_nu_grad = state['prev_nu_grad']\n h = torch.dot(grad.view(-1), prev_nu_grad)\n if self.HDM:\n norm_denom = grad_norm*(prev_nu_grad.norm())\n norm_denom.add_(group['eps'])\n state['nu'] = state['nu']*(1-hypergrad_lr*(h/norm_denom))\n else:\n state['nu'] -= hypergrad_lr * h\n\n torch.max(state['nu'], torch.zeros_like(state['nu']), out=state['nu'])\n torch.min(state['nu'], torch.ones_like(state['nu']), out=state['nu'])\n\n if display:\n print(\"nu\", state['nu'])\n\n if self.use_gc:\n grad.add_(-grad.mean(dim=tuple(range(1, len(list(grad.size())))), keepdim=True))\n\n nu = state['nu']\n exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)\n\n vt = exp_avg_sq.clone()\n\n if not self.nostalgia:\n vt.div_(1 - (beta2 ** state['step']))\n\n denom = vt.pow_(group['p']).add_(group['eps'])\n\n exp_avg.mul_(beta1).addcdiv_(1 - beta1, grad, denom)\n\n momentum = exp_avg.clone()\n bias_correction1 = 1 - (beta1 ** state['step'])\n momentum.div_(bias_correction1)\n\n if lookahead_step:\n dalpha = alpha\n elif do_IA:\n dalpha = (1/(state[\"num_models\"]+1.0))\n else:\n dalpha = 1.0\n\n if hypergrad_lr > 0.0 and self.hypertune_nu:\n state['prev_nu_grad'] = (-dalpha*state['lr']*(momentum - grad)).view(-1)\n\n momentum.mul_(nu).add_(1-nu, grad) # quasi hyperbolic momentum\n\n if hypergrad_lr > 0.0:\n temp = dalpha*(-momentum - wd*p.data)\n state['prev_lr_grad'] = temp.view(-1)\n\n p.data.add_(-state['lr'] * momentum)\n\n if wd != 0:\n p.data.add_(-wd*state['lr'], p.data)\n\n if lookahead_step:\n p.data.mul_(alpha).add_(1.0 - alpha, state['cached_params'])\n state['cached_params'].copy_(p.data)\n\n if do_IA:\n p.data.add_(state[\"num_models\"], state['cached_params']\n ).div_(state[\"num_models\"]+1.0)\n state['cached_params'].copy_(p.data)\n state[\"num_models\"] += 1\n\n return loss\n\n# new stuffs to try: https://arxiv.org/pdf/1607.04381.pdf\n", "meta": {"hexsha": "106a295d4157c965d3a731ed518fb3fbf65915b7", "size": 56673, "ext": "py", "lang": "Python", "max_stars_repo_path": "models/optim/optimizers.py", "max_stars_repo_name": "JRC1995/SocialMediaNER", "max_stars_repo_head_hexsha": "236b22ded48f64516ebf0577c3b9d9d907db84e0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "models/optim/optimizers.py", "max_issues_repo_name": "JRC1995/SocialMediaNER", "max_issues_repo_head_hexsha": "236b22ded48f64516ebf0577c3b9d9d907db84e0", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "models/optim/optimizers.py", "max_forks_repo_name": "JRC1995/SocialMediaNER", "max_forks_repo_head_hexsha": "236b22ded48f64516ebf0577c3b9d9d907db84e0", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.0673913043, "max_line_length": 208, "alphanum_fraction": 0.4850810792, "include": true, "reason": "import numpy", "num_tokens": 12847, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5428632831725052, "lm_q2_score": 0.3629692055196168, "lm_q1q2_score": 0.19704265459889497}} {"text": "import numpy as np\nimport matplotlib.pyplot as plt\nfrom astropy import units as u\nimport scipy.integrate\nfrom sys import float_info\nimport warnings\n\n\n\nclass Baseliner:\n \"\"\"\n A class for interactive baseliner of spectroscopic data.\n\n The class works by being fed a spectrum and a matplotlib axis on which\n it should be plotted. The spectrum is then plotted to the given axis,\n and a number of interactive options are made available to the user.\n\n Left-clicking with the mouse for the first time starts defining a window\n from the x-axis location of the click. A second click finishes the\n window between the locations of the first and second click.\n A third click will finish selecting windows, and perform the baselining.\n Alternately, right-clicking will cancel the last left-clicking action,\n allowing misplaced windows to be adjusted.\n\n Two keys are also accepted:\n Pressing \"q\" will cause the baselining process to be canceled,\n effectively skipping the baselining of this spectrum.\n Pressing \"a\" will allow an additional window to be defined, assuming\n one has been defined so far (by left-clicking twice to define its \n boundaries).\n\n Attributes\n ----------\n windows : `list`\n A list of all the set windows.\n \"\"\"\n def __init__(self,ax,spec):\n \"\"\"\n Baseliner(ax,spec,order=1)\n\n Initialise the `Baseliner` class by giving it the target axis and\n spectrum.\n\n Parameters\n ----------\n ax : `matplotlib.axis`\n The matplotlib axis on which the interation will happen.\n spec : `omnifit.spectrum.BaseSpectrum`\n The spectrum which will be plotted as the visual reference on\n the given axis.\n \"\"\"\n self.__ax = ax\n self.__spec = spec\n self.__x = spec.x.value\n self.__y = spec.y.value\n self.__limlo=None\n self.__limhi=None\n self.__minx=np.min(self.__x)\n self.__maxx=np.max(self.__x)\n self.__miny=np.min(self.__y)\n self.__maxy=np.max(self.__y)\n self.__ax.set_xlim(self.__minx,self.__maxx)\n self.__ax.set_ylim(self.__miny,self.__maxy)\n self.__specplot,=self.__ax.plot(self.__x,self.__y,'k-',drawstyle='steps-mid')\n self.__buttonListener = self.__ax.figure.canvas.mpl_connect('button_press_event', self.__mouse_press)\n self.__keyListener = self.__ax.figure.canvas.mpl_connect('key_press_event', self.__key_press)\n self.windows=[]\n def __key_press(self, event):\n if event.key=='q':\n self.__skip()\n if event.key=='a' and self.__limlo != None and self.__limhi != None:\n self.__addwindow(self.__limlo,self.__limhi)\n self.__ax.plot([self.__limlo,self.__limlo],[self.__miny,self.__maxy],'g-')\n self.__ax.plot([self.__limhi,self.__limhi],[self.__miny,self.__maxy],'g-')\n self.__remlim()\n self.__remlim()\n print 'Window added. Ready to receive another one.'\n else:\n return\n def __mouse_press(self, event):\n if event.button==1:\n self.__setlim(event.xdata)\n elif event.button==2:\n return\n elif event.button==3:\n self.__remlim()\n def __skip(self):\n plt.close()\n def __setlim(self,i_x):\n if self.__limlo==None:\n self.__limlo=i_x\n self.__limloplot,=self.__ax.plot([i_x,i_x],[self.__miny,self.__maxy],'b-')\n self.__ax.figure.canvas.draw()\n elif self.__limhi==None:\n self.__limhi=i_x\n self.__limhiplot,=self.__ax.plot([i_x,i_x],[self.__miny,self.__maxy],'b-')\n self.__ax.figure.canvas.draw()\n print 'Ready for finalising. Press once more to do so, or press a to add another window.'\n else:\n self.__finalise()\n def __remlim(self):\n if self.__limhi!=None:\n self.__limhi=None\n self.__limhiplot.set_ydata([self.__miny,self.__miny])\n self.__ax.figure.canvas.draw()\n elif self.__limlo!=None:\n self.__limlo=None\n self.__limloplot.set_ydata([self.__miny,self.__miny])\n self.__ax.figure.canvas.draw()\n else:\n print 'No limits to cancel.'\n def __addwindow(self,limlo,limhi):\n if limhi < limlo:\n limlo,limhi = limhi,limlo\n self.windows.append([limlo,limhi])\n def __finalise(self):\n self.__addwindow(self.__limlo,self.__limhi)\n self.__ax.figure.canvas.mpl_disconnect(self.__buttonListener)\n self.__ax.figure.canvas.mpl_disconnect(self.__keyListener)\n plt.close(self.__ax.figure)\n\n#---------------------\n#New units definitions\n#---------------------\n#the units themselves\nunit_t = u.def_unit('transmittance units',doc='Transmittance of radiation')\nunit_transmittance = unit_t\nunit_abs = u.def_unit('absorbance units',doc='Absorbance of radiation')\nunit_absorbance = unit_abs\nunit_od = u.def_unit('optical depth units',doc='Optical depth of radiation')\nunit_opticaldepth = unit_od\n\n#the equivalencies between the units\nequivalencies_absorption = [\n (unit_t,unit_abs,lambda x:-np.log10(x),lambda x:10**-x),\n (unit_od,unit_abs,lambda x:x/np.log(10),lambda x:x*np.log(10)),\n (unit_od,unit_t,lambda x:10**(-x/np.log(10)),lambda x:-np.log10(x)*np.log(10))\n ]\n\n#------------------------------------------------------\n#Functions related to light scattering and transmission\n#------------------------------------------------------\ndef cde_correct(freq,m):\n \"\"\"\n cde_correct(freq,m)\n\n Generate a CDE-corrected spectrum from a complex refractive index\n spectrum.\n\n Parameters\n ----------\n freq : `numpy.ndarray`\n The frequency data of the input spectrum, in reciprocal\n wavenumbers (cm^-1).\n m : `numpy.ndarray`\n The complex refractive index spectrum.\n\n Returns\n -------\n A list containing the following numpy arrays, in given order:\n * The spectrum of the absorption cross section of the simulated grain.\n * The spectrum of the absorption cross section of the simulated grain,\n normalized by the volume distribution of the grain. This parameter\n is the equivalent of optical depth in most cases.\n * The spectrum of the scattering cross section of the simulated grain,\n normalized by the volume distribution of the grain.\n * The spectrum of the total cross section of the simulated grain. \n \"\"\"\n wl=1.e4/freq\n m2=m**2.0\n im_part=((m2/(m2-1.0))*np.log(m2)).imag\n cabs_vol=(4.0*np.pi/wl)*im_part\n cabs=freq*(2.0*m.imag/(m.imag-1))*np.log10(m.imag)\n cscat_vol=(freq**3.0/(6.0*np.pi))*cabs\n ctot=cabs+cscat_vol\n return cabs,cabs_vol,cscat_vol,ctot\n\ndef complex_transmission_reflection(in_m0,in_m1,in_m2):\n \"\"\"\n complex_transmission_reflection(in_m0,in_m1,in_m2)\n\n Calculate the complex transmission and reflection coefficients between\n media 0, 1, and 2 given their complex refractive indices.\n In the Kramers-Kronig implementation (in which this is most likely used\n in the context of Omnifit) media 0, 1, and 2 correspond\n respectively to the vacuum, ice, and substrate.\n\n Parameters\n ----------\n in_m0 : `complex` or `numpy.ndarray`\n The complex refractive index of medium 0.\n in_m1 : `complex` or `numpy.ndarray`\n The complex refractive index of medium 1.\n in_m2 : `complex` or `numpy.ndarray`\n The complex refractive index of medium 2.\n\n Returns\n -------\n A tuple containing the following elements:\n * The complex transmission coefficient between media 0 and 1\n * The complex transmission coefficient between media 0 and 2\n * The complex transmission coefficient between media 1 and 2\n * The complex reflection coefficient between media 0 and 1\n * The complex reflection coefficient between media 0 and 2\n * The complex reflection coefficient between media 1 and 2\n \"\"\"\n complex_transmission = lambda m1,m2: (2.*m1.real)/(m1+m2)\n complex_reflection = lambda m1,m2: (m1-m2)/(m1+m2)\n return (\n complex_transmission(in_m0,in_m1),\n complex_transmission(in_m0,in_m2),\n complex_transmission(in_m1,in_m2),\n complex_reflection(in_m0,in_m1),\n complex_reflection(in_m0,in_m2),\n complex_reflection(in_m1,in_m2)\n )\n\ndef kramers_kronig(freq,transmittance,m_substrate,d_ice,m0,freq_m0,m_guess=1.0+0.0j,tol=0.001,maxiter=100,ignore_fraction=0.1,force_kkint_unity=False,precalc=False):\n \"\"\"\n kramers_kronig(freq,transmittance,m_substrate,d_ice,m0,freq_m0,\n m_guess=1.0+0.0j,tol=0.001,maxiter=100,ignore_fraction=0.1,\n force_kkint_unity=False,precalc=False)\n\n Kramers-Kronig relation.\n This is an implementation of the Kramers-Kronig relation calculation\n presented in Hudgins et al 1993 (1993ApJS...86..713H), with an improved\n integration method adapted from Trotta et al 1996 \n (The Cosmic Dust Connection, 1996 169-184)\n\n Parameters\n ----------\n wn : `astropy.units.Quantity` or `numpy.ndarray`\n The frequency data of the input spectrum. If no units are given, this\n is assumed to be in reciprocal wavenumbers (cm^-1).\n transmittance : `astropy.units.Quantity` or `numpy.ndarray`\n The transmittance data of the input spectrum. This can be given in\n units other than transmittance, as long as they can be converted to \n transmittance by making use of the `utils.equivalencies_absorption`\n equivalency information. If no units are given, transmittance is\n assumed.\n m_substrate : `complex`\n The complex refractive index of the substrate on which the ice being\n studied was grown.\n d_ice : `astropy.units.Quantity` or `float`\n The thickness of the ice which is being studied. If no units are given,\n centimeters are assumed.\n m0 : `complex`\n The complex refractive index of the ice at the reference frequency\n defined by `freq_m0` (see below).\n freq_m0 : `astropy.units.Quantity` or `float`\n The frequency at which the reference complex refractive index `m0`\n (see above) is defined. Best results are usually achieved if this\n frequency is high compared to the frequency range being probed by\n the spectrum.\n If this is not defined as `astropy.units.Quantity` in spectroscopic\n units, it is assumed to be in reciprocal wavenumbers (cm^-1).\n m_guess : `complex` or `numpy.ndarray`\n The starting guess of the complex refractive index of the ice. This\n can either be a single number (in which case it is assumed to be this\n number throughout the entire spectrum) or an array\n tol : `float`\n The square-sum of the residual between the original transmittance and\n the transmittance modeled with the iterated complex refractive index\n of the ice must be below this value for the iteration to converge. In\n other words, the smaller this number is, the better the final result\n will be at the expense of extra iterations.\n maxiter : `int`\n The maximum number of iterations allowed. If this number is reached,\n the iteration is considered to not have converged, and an exception is\n raised.\n ignore_fraction : `float` between 0 and 0.5\n The edges of the spectrum are blanked out (and replaced with the\n non-blanked value closest to the edge) during iteration to avoid edge\n effects arising from the usage of a non-infinite integration range.\n This parameter controls how large of a fraction of the edges is blanked\n out.\n force_kkint_unity : `bool`\n The results of the Kramers-Kronig integration are responsible for\n determining the real part of the complex refractive index i.e. the\n one which represents refraction. Normally this number should not drop\n below unity, and unexpected behaviour can arise if it does.\n Usually this means that there is something wrong with the input\n parameters, but sometimes forcing the result to always be greater or\n equal to unity can help. It should be noted, however, that the\n accuracy of the results of an integration forced in this way are\n suspect at best.\n precalc : `bool`\n The Kramers-Kronig iteration can be a very computationally intensive\n operation. In some situations it may result in a faster iteration to\n pre-calculate the large denominator which is part of the\n Kramers-Kronig integration instead of computing new values of it in a\n for loop. This denominator can be, however, a very\n large variable as it contains a number of elements equal to the size\n of the spectrum squared. Pre-calculating this can outright fail on\n lower-end computers as Python runs out of available memory.\n High-end systems may benefit from such pre-calculation, though.\n\n Returns\n -------\n A `numpy.ndarray` which contains the complex refractive index of the\n ice, in order of increasing frequency.\n \"\"\"\n #set up constants\n m_vacuum = 1.0+0.0j\n #make sure the input array units are correct; convert if necessary\n if type(freq) != u.quantity.Quantity:\n warnings.warn('No units detected in input freq. Assuming kayser.',RuntimeWarning)\n freq *= u.kayser\n else:\n with u.set_enabled_equivalencies(u.equivalencies.spectral()):\n freq=freq.to(u.kayser)\n if type(transmittance) != u.quantity.Quantity:\n warnings.warn('No units detected in input transmittance. Assuming transmittance units.',RuntimeWarning)\n transmittance *= unit_t\n else:\n with u.set_enabled_equivalencies(equivalencies_absorption):\n transmittance = transmittance.to(unit_t)\n if type(d_ice) != u.quantity.Quantity:\n warnings.warn('No units detected in input d_ice. Assuming centimeters.',RuntimeWarning)\n d_ice *= u.cm\n else:\n d_ice = d_ice.to(u.cm)\n #sort the arrays and get rid of units; won't need them after this\n initial_sorter = np.argsort(freq)\n freq = freq[initial_sorter].value\n transmittance = transmittance[initial_sorter].value\n d_ice = d_ice.value\n #initialise complex refractive index and alpha arrays\n m = np.full_like(freq,np.nan+np.nan*1j,dtype=complex)\n alpha = np.full_like(freq,np.nan+np.nan*1j,dtype=complex)\n #initial guess at m at first index\n if type(m_guess)==complex:\n m_ice = np.full_like(freq,m_guess,dtype=complex)\n else:\n m_ice = m_guess\n #find top and bottom fraction indices. These will be replaced with dummy values after each integration to get rid of edge effects\n if ignore_fraction > 0.5 or ignore_fraction < 0:\n raise RuntimeError('ignore_fraction must be between 0.0 and 0.5')\n bot_fraction = round(ignore_fraction*len(freq))\n top_fraction = len(freq)-bot_fraction\n #pre-calculate the large denominator component of the KK integration, if desired\n if precalc:\n try:\n sfreq=(freq).reshape(len(freq),1)\n kkint_deno1 = freq**2-sfreq**2\n kkint_deno1[kkint_deno1!=0] = 1./kkint_deno1[kkint_deno1!=0]\n precalc = True\n #or at least try to do so; if run out of memory, switch to the slower no-precalc mode\n except MemoryError:\n precalc = False\n #some other parts can always be precalced\n kkint_mul = 1./(2*np.pi*np.pi)\n kkint_deno2 = freq**2-freq_m0**2\n kkint_deno2[kkint_deno2!=0] = 1./kkint_deno2[kkint_deno2!=0]\n #calculate alpha at freq0\n alpha0 = m0.imag/(4*np.pi*freq)\n #iteration begin!\n niter = 0\n squaresum_diff = tol+1\n while squaresum_diff > tol and niter < maxiter:\n #calculate transmission and relfection coefficients\n #in these 0 means vacuum, 1 means ice, 2 means substrate\n t01,t02,t12,r01,r02,r12 = complex_transmission_reflection(m_vacuum,m_ice,m_substrate)\n #the reflection component\n # reflection_component = np.abs((t01*t12/t02)/(1.+r01*r12*np.exp(4.j*np.pi*d_ice*m_ice*freq)))**2.)\n #this is an evil equation. do NOT touch it\n #it calculates the lambert absorption coefficient using the current best guess at m_ice\n alpha = (1./d_ice)*(-np.log(transmittance)+np.log(np.abs((t01*t12/t02)/(1.+r01*r12*np.exp(4.j*np.pi*d_ice*m_ice*freq)))**2.))\n #using the new alpha, calculate a new n (and thus m) for the ice\n #this is done in a parallel for loop, to avoid killing the computer when dealing with large amounts of data\n kkint_nomi = alpha-alpha0\n kkint = np.full_like(alpha,m0.real)\n numcols = kkint_nomi.shape[0]\n for current_col in range(numcols):\n if precalc:\n kkint[current_col]+=kkint_mul*scipy.integrate.simps((alpha-alpha[current_col])*kkint_deno1[current_col,:]-kkint_nomi*kkint_deno2)\n else:\n kkint_deno1 = freq[current_col]**2-freq**2\n kkint_deno1[kkint_deno1!=0] = 1./kkint_deno1[kkint_deno1!=0]\n kkint[current_col]+=kkint_mul*scipy.integrate.simps((alpha-alpha[current_col])*kkint_deno1-kkint_nomi/(freq**2-freq_m0**2))\n if np.any(kkint<1):\n if np.any(kkint<0):\n warnings.warn('KK integration is producing negative refractive indices! This will most likely produce nonsensical results.',RuntimeWarning)\n else:\n warnings.warn('KK integration is producing refractive indices below unity! This may result in unexpected behaviour.',RuntimeWarning)\n if force_kkint_unity:\n kkint[kkint<1]=1.\n m_ice = kkint+1j*alpha/(4*np.pi*freq)\n if np.any(np.isnan(m_ice.real)) or np.any(np.isnan(m_ice.imag)):\n raise RuntimeError('Produced complex refractive index contains NaNs. Check your input parameters.')\n #replace top and bottom fractions of m_ice with the value closest to that edge\n #this is done to combat edge effects arising from integrating over a non-infinite range\n m_ice[:bot_fraction] = m_ice[bot_fraction]\n m_ice[top_fraction:] = m_ice[top_fraction]\n #calculate transmission and relfection coefficients (again)\n #in these 0 means vacuum, 1 means ice, 2 means substrate\n t01,t02,t12,r01,r02,r12 = complex_transmission_reflection(m_vacuum,m_ice,m_substrate)\n #model a transmittance using given m_ice and alpha\n #yes, this is another evil equation\n transmittance_model = np.exp(-alpha*d_ice)*np.abs((t01*t12/t02)/(1.+r01*r12*np.exp(4.j*np.pi*d_ice*m_ice*freq)))**2.\n diff = transmittance - transmittance_model\n diff[:bot_fraction] = 0. #ignore top...\n diff[top_fraction:] = 0. #...and bottom fraction differences\n squaresum_diff = np.sum(diff**2) #square sum of difference\n niter += 1\n #at this point we are done\n if niter>=maxiter:\n raise RuntimeError('Maximum number of iterations reached before convergence criterion was met.')\n return m_ice", "meta": {"hexsha": "ea263079e5d79bb71d5b830f68e49a093bee54c1", "size": 17927, "ext": "py", "lang": "Python", "max_stars_repo_path": "omnifit/utils/utils.py", "max_stars_repo_name": "astrobot/omnifit", "max_stars_repo_head_hexsha": "7cc9e499fd149d6d3a3a15761c5380778a3f4f42", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2015-08-25T16:40:30.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-13T08:25:07.000Z", "max_issues_repo_path": "omnifit/utils/utils.py", "max_issues_repo_name": "astrobot/omnifit", "max_issues_repo_head_hexsha": "7cc9e499fd149d6d3a3a15761c5380778a3f4f42", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 22, "max_issues_repo_issues_event_min_datetime": "2015-08-27T15:19:50.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-12T18:50:31.000Z", "max_forks_repo_path": "omnifit/utils/utils.py", "max_forks_repo_name": "astrobot/omnifit", "max_forks_repo_head_hexsha": "7cc9e499fd149d6d3a3a15761c5380778a3f4f42", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2015-12-31T19:24:48.000Z", "max_forks_repo_forks_event_max_datetime": "2019-06-18T07:28:19.000Z", "avg_line_length": 43.8312958435, "max_line_length": 165, "alphanum_fraction": 0.715903386, "include": true, "reason": "import numpy,import scipy,from astropy", "num_tokens": 4796, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5428632831725052, "lm_q2_score": 0.36296919862864757, "lm_q1q2_score": 0.1970426508580408}} {"text": "# -*- coding: utf-8 -*-\n'''Chemical Engineering Design Library (ChEDL). Utilities for process modeling.\nCopyright (C) 2016, 2017 Caleb Bell \n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.'''\n\nfrom __future__ import division\ntry: # pragma: no cover\n from cStringIO import StringIO\nexcept: # pragma: no cover\n from io import BytesIO as StringIO\nimport os\nimport gzip\nimport datetime\nfrom calendar import isleap\nfrom collections import namedtuple\n\nimport numpy as np\nfrom fluids.core import F2K\nfrom scipy.constants import mile, knot, inch\nfrom scipy.spatial import KDTree, cKDTree\nfrom scipy.stats import scoreatpercentile\n\n\ntry: # pragma: no cover\n from urllib.request import urlopen\n from urllib.error import HTTPError\nexcept ImportError: # pragma: no cover\n from urllib2 import urlopen\n from urllib2 import HTTPError\n \ntry: # pragma: no cover\n from appdirs import user_data_dir, user_config_dir\n data_dir = user_config_dir('fluids')\nexcept ImportError: # pragma: no cover\n data_dir = ''\n pass\n# TODO: Import ephem and get hours/minutes of sunlight per day.\n \n__all__ = ['get_clean_isd_history', 'IntegratedSurfaceDatabaseStation',\n 'get_closest_station', 'get_station_year_text', 'gsod_day_parser',\n 'StationDataGSOD', 'heating_degree_days', 'cooling_degree_days', 'stations']\n\nfolder = os.path.join(os.path.dirname(__file__), 'data')\n\n\ndef heating_degree_days(T, T_base=F2K(65), truncate=True):\n r'''Calculates the heating degree days for a period of time.\n\n .. math::\n \\text{heating degree days} = max(T - T_{base}, 0)\n\n Parameters\n ----------\n T : float\n Measured temperature; sometimes an average over a length of time is used,\n other times the average of the lowest and highest temperature in a \n period are used, [K]\n T_base : float, optional\n Reference temperature for the degree day calculation, defaults\n to 65 °F (18.33 °C, 291.483 K), the value most used in the US, [K]\n truncate : bool\n If truncate is True, no negative values will be returned; if negative, \n the value is truncated to 0, [-]\n\n Returns\n -------\n heating_degree_days : float\n Degree above the base temperature multiplied by the length of time of\n the measurement, normally days [day*K]\n\n Notes\n -----\n Some common base temperatures are 18 °C (Canada), 15.5 °C (EU), \n 17 °C (Denmark, Finland), 12 °C Switzerland. The base temperature\n should always be presented with the results.\n \n The time unit does not have to be days; it can be any time unit, and the\n calculation behaves the same.\n\n Examples\n --------\n >>> heating_degree_days(303.8)\n 12.31666666666672\n \n >>> heating_degree_days(273)\n 0.0\n \n >>> heating_degree_days(322, T_base=300)\n 22\n\n References\n ----------\n .. [1] \"Heating Degree Day.\" Wikipedia, January 24, 2018. \n https://en.wikipedia.org/w/index.php?title=Heating_degree_day&oldid=822187764.\n '''\n dd = T - T_base\n if truncate and dd < 0.0:\n dd = 0.0\n return dd\n\n\ndef cooling_degree_days(T, T_base=283.15, truncate=True):\n r'''Calculates the cooling degree days for a period of time.\n\n .. math::\n \\text{cooling degree days} = max(T_{base} - T, 0)\n\n Parameters\n ----------\n T : float\n Measured temperature; sometimes an average over a length of time is used,\n other times the average of the lowest and highest temperature in a \n period are used, [K]\n T_base : float, optional\n Reference temperature for the degree day calculation, defaults\n to 10 °C, 283.15 K, a common value, [K]\n truncate : bool\n If truncate is True, no negative values will be returned; if negative, \n the value is truncated to 0, [-]\n\n Returns\n -------\n cooling_degree_days : float\n Degree below the base temperature multiplied by the length of time of\n the measurement, normally days [day*K]\n\n Notes\n -----\n The base temperature should always be presented with the results.\n \n The time unit does not have to be days; it can be time unit, and the\n calculation behaves the same.\n\n Examples\n --------\n >>> cooling_degree_days(250)\n 33.14999999999998\n \n >>> cooling_degree_days(300)\n 0.0\n \n >>> cooling_degree_days(250, T_base=300)\n 50\n\n References\n ----------\n .. [1] \"Heating Degree Day.\" Wikipedia, January 24, 2018. \n https://en.wikipedia.org/w/index.php?title=Heating_degree_day&oldid=822187764.\n '''\n dd = T_base - T\n if truncate and dd < 0.0:\n dd = 0.0\n return dd\n\n\ndef get_clean_isd_history(dest=os.path.join(folder, 'isd-history-cleaned.tsv'),\n url=\"ftp://ftp.ncdc.noaa.gov/pub/data/noaa/isd-history.csv\"): # pragma: no cover\n '''Basic method to update the isd-history file from the NOAA. This is \n useful as new weather stations are updated all the time.\n \n This function requires pandas to run. If fluids is installed for the \n superuser, this method must be called in an instance of Python running\n as the superuser (administrator).\n \n Retrieving the file from ftp typically takes several seconds.\n Pandas reads the file in ~30 ms and writes it in ~220 ms. Reading it with \n the code below takes ~220 ms but is necessary to prevent a pandas \n dependency.\n \n Parameters\n ----------\n dest : str, optional\n The file to store the data retrieved; leave as the default argument\n for it to be accessible by fluids.\n url : str, optional\n The location of the data file; this can be anywhere that can be read\n by pandas, including a local file as would be useful in an offline\n situation.\n '''\n import pandas as pd\n df = pd.read_csv(url)\n df.to_csv(dest, sep='\\t', index=False, header=False)\n\n\nclass IntegratedSurfaceDatabaseStation(object):\n '''Class to hold data on a weather station in the Integrated Surface\n Database.\n \n License information for the database can be found at the following link:\n https://data.noaa.gov/dataset/global-surface-summary-of-the-day-gsod\n\n Parameters\n ----------\n USAF : int or None if unassigned\n Air Force station ID. May contain a letter in the first position.\n WBAN : int or None if unassigned\n NCDC WBAN number\n NAME : str\n Name of the station; ex. 'CENTRAL COLORADO REGIONAL AP'\n CTRY : str or None if unspecified\n FIPS country ID\n ST : str or None if not in the US\n State for US stations\n ICAO : str or None if not an airport\n ICAO airport code\n LAT : float\n Latitude with a precision of one thousandths of a decimal degree, \n [degrees]\n LON : float\n Longitude with a precision of one thousandths of a decimal degree, \n [degrees]\n ELEV : float\n Elevation of weather station, [m]\n BEGIN : float\n Beginning Period Of Record (YYYYMMDD). There may be reporting gaps \n within the P.O.R.\n END : Ending Period Of Record (YYYYMMDD). There may be reporting gaps\n within the P.O.R.\n '''\n __slots__ = ['USAF', 'WBAN', 'NAME', 'CTRY', 'ST', 'ICAO', 'LAT', 'LON',\n 'ELEV', 'BEGIN', 'END', 'raw_data', 'parsed_data']\n \n def __repr__(self):\n s = ('' )\n return s%(self.NAME, self.CTRY, self.USAF, self.WBAN, self.LAT, self.LON, str(self.BEGIN)[0:4], str(self.END)[0:4])\n \n def __init__(self, USAF, WBAN, NAME, CTRY, ST, ICAO, LAT, LON, ELEV, BEGIN,\n END):\n try:\n self.USAF = int(USAF)\n except TypeError:\n self.USAF = USAF # Nones\n try:\n self.WBAN = int(WBAN) \n except TypeError:\n self.WBAN = WBAN\n self.NAME = NAME\n self.CTRY = CTRY\n self.ST = ST\n self.ICAO = ICAO\n self.LAT = LAT\n self.LON = LON\n self.ELEV = ELEV\n self.BEGIN = int(BEGIN)\n self.END = int(END)\n \n\nclass StationDataGSOD(object):\n # Holds data, caches and retrieves data\n def __init__(self, station):\n self.station = station\n self.begin = datetime.datetime.strptime(str(self.station.BEGIN), '%Y%m%d')\n self.end = datetime.datetime.strptime(str(self.station.END), '%Y%m%d')\n \n self.year_range = range(self.begin.year, self.end.year + 1)\n \n# Would be nice to create these later, when using a download_data method\n self.raw_text = {}\n self.raw_data = {}\n self.parsed_data = {}\n self.load_empty_vectors()\n self.download_data()\n self.parse_data()\n \n def load_empty_vectors(self):\n for year in self.year_range:\n days_in_year = 366 if isleap(year) else 365\n self.raw_data[year] = [None]*days_in_year\n self.parsed_data[year] = [None]*days_in_year\n self.raw_text[year] = None\n# days = [None]*days_in_year(y)\n\n def download_data(self):\n for year in self.year_range:\n if self.raw_text[year] is None:\n try:\n year_data = get_station_year_text(self.station.USAF, self.station.WBAN, year)\n self.raw_text[year] = year_data\n except:\n pass\n \n def parse_data(self):\n for year, data in self.raw_text.items():\n if data is not None:\n days = self.parsed_data[year]\n for line in data.split('\\n')[1:-1]:\n parsed = gsod_day_parser(line)\n doy = parsed.DATE.timetuple().tm_yday-1\n days[doy] = parsed\n \n def coldest_month(self, older_year=None, newer_year=None, minimum_days=23):\n # Tested\n month_data = self.month_average_temperature(older_year=older_year,\n newer_year=newer_year, \n minimum_days=minimum_days)\n return month_data.index(min(month_data))\n \n def warmest_month(self, older_year=None, newer_year=None, minimum_days=23):\n # Tested\n month_data = self.month_average_temperature(older_year=older_year,\n newer_year=newer_year, \n minimum_days=minimum_days)\n return month_data.index(max(month_data))\n\n def month_average_temperature(self, older_year=None, newer_year=None,\n include_yearly=False, minimum_days=23):\n '''\n >> station = get_closest_station(38.8572, -77.0369)\n >> station_data = StationDataGSOD(station)\n >> station_data.month_average_temperature(1990, 2000, include_yearly=False)\n [276.1599380905833, 277.5375516246206, 281.1881231671554, 286.7367003367004, 291.8689638318671, 296.79545454545456, 299.51868686868687, 298.2097914630174, 294.4116161616162, 288.25883023786247, 282.3188552188553, 277.8282339524275]\n '''\n # Take years, make them inclusive; add minimum valid days.\n year_month_averages = {}\n year_month_counts = {}\n \n for year, data in self.parsed_data.items():\n if not (older_year <= year <= newer_year):\n continue # Ignore out-of-range years easily\n year_month_averages[year] = [0.0]*12\n year_month_counts[year] = [0]*12\n\n for i, day in enumerate(data):\n if day is None:\n continue\n # Don't do these comparisions to make it fast\n if day.DATE.year < older_year or day.DATE.year > newer_year:\n continue # Ignore out-of-range days as possible\n \n T = day.TEMP\n if T is None:\n continue\n # Cache these lookups\n year_month_averages[year][day.DATE.month-1] += T\n year_month_counts[year][day.DATE.month-1] += 1\n \n for month in range(12):\n count = year_month_counts[year][month]\n if count < minimum_days:\n ans = None\n else:\n ans = year_month_averages[year][month]/count\n year_month_averages[year][month] = ans\n \n # Compute the average of the month\n actual_averages = [0.0]*12\n actual_averages_counts = [0]*12\n for year, average in year_month_averages.items():\n for month in range(12):\n if average is not None and average[month] is not None:\n count = actual_averages_counts[month] \n if count is None:\n count = 1\n else: \n count += 1\n actual_averages_counts[month] = count\n month_average_sum = actual_averages[month]\n if month_average_sum is None:\n month_average_sum = average[month]\n else:\n month_average_sum += average[month]\n actual_averages[month] = month_average_sum\n \n for month in range(12):\n actual_averages[month] = actual_averages[month]/actual_averages_counts[month]\n \n # Don't set anything as properties - too many variables used in calculating thems\n # Speed is not that important.\n if include_yearly:\n return actual_averages, year_month_averages\n else:\n return actual_averages\n\n # Copy and paste\n def month_average_windspeed(self, older_year=None, newer_year=None,\n include_yearly=False, minimum_days=23):\n # Take years, make them inclusive; add minimum valid days.\n year_month_averages = {}\n year_month_counts = {}\n \n for year, data in self.parsed_data.items():\n if not (older_year <= year <= newer_year):\n continue # Ignore out-of-range years easily\n year_month_averages[year] = [0.0]*12\n year_month_counts[year] = [0]*12\n\n for i, day in enumerate(data):\n if day is None:\n continue\n # Don't do these comparisions to make it fast\n if day.DATE.year < older_year or day.DATE.year > newer_year:\n continue # Ignore out-of-range days as possible\n \n wind_speed = day.WDSP\n if wind_speed is None:\n continue\n # Cache these lookups\n year_month_averages[year][day.DATE.month-1] += wind_speed\n year_month_counts[year][day.DATE.month-1] += 1\n \n for month in range(12):\n count = year_month_counts[year][month]\n if count < minimum_days:\n ans = None\n else:\n ans = year_month_averages[year][month]/count\n year_month_averages[year][month] = ans\n \n # Compute the average of the month\n actual_averages = [0.0]*12\n actual_averages_counts = [0]*12\n for year, average in year_month_averages.items():\n for month in range(12):\n if average is not None and average[month] is not None:\n count = actual_averages_counts[month] \n if count is None:\n count = 1\n else: \n count += 1\n actual_averages_counts[month] = count\n month_average_sum = actual_averages[month]\n if month_average_sum is None:\n month_average_sum = average[month]\n else:\n month_average_sum += average[month]\n actual_averages[month] = month_average_sum\n \n for month in range(12):\n actual_averages[month] = actual_averages[month]/actual_averages_counts[month]\n \n # Don't set anything as properties - too many variables used in calculating thems\n # Speed is not that important.\n if include_yearly:\n return actual_averages, year_month_averages\n else:\n return actual_averages\n\n def percentile_extreme_condition(self, older_year=None, newer_year=None,\n include_yearly=False, minimum_days=23, attr='WDSP'):\n # Really need to normalize data with interpolation etc here.\n # Need to get the data, and process it and score interpolation regimes.\n # Or could just randomly drop data and try to fill it in.\n accepted_values = []\n for year, data in self.parsed_data.items():\n if not (older_year <= year <= newer_year):\n continue # Ignore out-of-range years easily\n\n\n\nstations = []\n_latlongs = []\n'''Read in the parsed data into \n1) a list of latitudes and longitudes, temporary, which will get converted to\na numpy array for use in KDTree\n2) a list of IntegratedSurfaceDatabaseStation objects; the query will return\nthe index of the nearest weather stations.\n'''\nwith open(os.path.join(folder, 'isd-history-cleaned.tsv')) as f:\n for line in f:\n values = line.split('\\t')\n for i in range(0, 11):\n v = values[i]\n if not v:\n values[i] = None # '' case\n else:\n try:\n values[i] = float(v)\n if int(v) == 99999:\n values[i] = None\n except:\n continue\n lat, lon = values[6], values[7]\n if lat and lon:\n # Some stations have no lat-long; this isn't useful\n stations.append(IntegratedSurfaceDatabaseStation(*values))\n _latlongs.append((lat, lon))\n_latlongs = np.array(_latlongs)\nstation_count = len(stations)\n\n\nkd_tree = cKDTree(_latlongs) # _latlongs must be unchanged as data is not copied\n\n\ndef get_closest_station(latitude, longitude, minumum_recent_data=20140000, \n match_max=100):\n '''Query function to find the nearest weather station to a particular \n set of coordinates. Optionally allows for a recent date by which the \n station is required to be still active at.\n \n Parameters\n ----------\n latitude : float\n Latitude to search for nearby weather stations at, [degrees]\n longitude : float\n Longitude to search for nearby weather stations at, [degrees]\n minumum_recent_data : int, optional\n Date that the weather station is required to have more recent\n weather data than; format YYYYMMDD; set this to 0 to not restrict data\n by date.\n match_max : int, optional\n The maximum number of results in the KDTree to search for before \n applying the filtering criteria; an internal parameter which is\n increased automatically if the default value is insufficient [-]\n \n Returns\n -------\n station : IntegratedSurfaceDatabaseStation\n Instance of IntegratedSurfaceDatabaseStation which was nearest\n to the requested coordinates and with sufficiently recent data\n available [-]\n \n Notes\n -----\n Searching for 100 stations is a reasonable choice as it takes, ~70 \n microseconds vs 50 microsecond to find only 1 station. The search does get \n slower as more points are requested. Bad data is returned from a KDTree\n search if more points are requested than are available.\n \n Examples\n --------\n >>> get_closest_station(51.02532675, -114.049868485806, 20150000)\n \n '''\n # Both station strings may be important\n # Searching for 100 stations is fine, 70 microseconds vs 50 microsecond for 1\n # but there's little point for more points, it gets slower.\n # bad data is returned if k > station_count\n distances, indexes = kd_tree.query([latitude, longitude], k=min(match_max, station_count)) \n #\n for i in indexes:\n latlon = _latlongs[i]\n enddate = stations[i].END\n # Iterate for all indexes until one is found whose date is current\n if enddate > minumum_recent_data:\n return stations[i]\n if match_max < station_count:\n return get_closest_station(latitude, longitude, minumum_recent_data=minumum_recent_data, match_max=match_max*10)\n raise Exception('Could not find a station with more recent data than '\n 'specified near the specified coordinates.')\n\n\n# This should be agressively cached\ndef get_station_year_text(WMO, WBAN, year):\n '''Basic method to download data from the GSOD database, given a \n station idenfifier and year. \n\n Parameters\n ----------\n WMO : int or None\n World Meteorological Organization (WMO) identifiers, [-]\n WBAN : int or None\n Weather Bureau Army Navy (WBAN) weather station identifier, [-]\n year : int\n Year data should be retrieved from, [year]\n \n Returns\n -------\n data : str\n Downloaded data file\n '''\n if WMO is None:\n WMO = 999999\n if WBAN is None:\n WBAN = 99999\n station = str(int(WMO)) + '-' + str(int(WBAN)) \n gsod_year_dir = os.path.join(data_dir, 'gsod', str(year))\n path = os.path.join(gsod_year_dir, station + '.op')\n if os.path.exists(path):\n data = open(path).read()\n if data and data != 'Exception':\n return data\n else:\n raise Exception(data)\n \n toget = ('ftp://ftp.ncdc.noaa.gov/pub/data/gsod/' + str(year) + '/' \n + station + '-' + str(year) +'.op.gz')\n try:\n data = urlopen(toget, timeout=5)\n except Exception as e:\n if not os.path.exists(gsod_year_dir):\n os.makedirs(gsod_year_dir)\n open(path, 'w').write('Exception')\n raise Exception('Could not obtain desired data; check '\n 'if the year has data published for the '\n 'specified station and the station was specified '\n 'in the correct form. The full error is %s' %(e))\n \n data = data.read()\n data_thing = StringIO(data)\n\n f = gzip.GzipFile(fileobj=data_thing, mode=\"r\")\n year_station_data = f.read()\n try: \n year_station_data = year_station_data.decode('utf-8')\n except:\n pass\n \n # Cache the data for future use\n if not os.path.exists(gsod_year_dir):\n os.makedirs(gsod_year_dir)\n open(path, 'w').write(year_station_data)\n \n \n return year_station_data\n \n\n\ngsod_fields = ['DATE', # 15-18 int year; 19-22 int month/day\n 'TEMP', # 25-30 Real Mean temperature for the day in degrees Fahrenheit to tenths. Missing = 9999.9\n 'TEMP_COUNT', # 32-33 Int. Number of observations used in calculating mean temperature\n 'DEWP', # 36-41 Real Mean dew point for the day in degrees Fahrenheit to tenths. Missing = 9999.9\n 'DEWP_COUNT', # 43-44 Int. Number of observations used in calculating mean dew point\n 'SLP', # 47-52 Real Mean sea level pressure for the day in millibars to tenths. Missing = 9999.9\n 'SLP_COUNT', # 54-55 Int. Number of observations used in calculating mean sea level pressure\n 'STP', # 58-63 Real Mean station pressure for the day in millibars to tenths. Missing = 9999.9\n 'STP_COUNT', # 65-66 Int. Number of observations used in calculating mean station pressure\n 'VISIB', # 69-73 Real Mean visibility for the day in miles to tenths. Missing = 999.9\n 'VISIB_COUNT', # 75-76 Int. Number of observations used in calculating mean visibility\n 'WDSP', # 79-83 Real Mean wind speed for the day in knots to tenths. Missing = 999.9\n 'WDSP_COUNT', # 85-86 Int. Number of observations used in calculating mean wind speed\n 'MXSPD', # 89-93 Real Maximum sustained wind speed reported for the day in knots to tenths. Missing = 999.9\n 'GUST', # 96-100 Real Maximum wind gust reported for the day in knots to tenths. Missing = 999.9\n 'MAX', # 103-108 Real Maximum temperature reported during the \n # day in Fahrenheit to tenths--time of max temp report varies by country and\n # region, so this will sometimes not be the max for the calendar day.\n # Missing = 9999.9; FLAG of '*' is present on 109-109!\n 'MIN', # 111-116 Real Minimum temperature reported during the day in Fahrenheit to tenths--time of min\n # temp report varies by country and region, so this will sometimes not be \n # the min for the calendar day. Missing = 9999.9 FLAG of '*' is present on 117-117!\n 'PRCP', # 119-123 Real Total precipitation (rain and/or melted snow) reported during the day in inches\n # and hundredths; will usually not end with the midnight observation--i.e.,\n # may include latter part of previous day. .00 indicates no measurable\n # precipitation (includes a trace).\n # Missing = 99.99\n\n 'SNDP', # 126-130 Real Snow depth in inches to tenths--last report for the day if reported more than\n # once. Missing = 999.9 Note: Most stations do not report '0' on days with no snow on the\n # ground--therefore, '999.9' will often appear on these days.\n 'FRSHTT' # 133-138 Int. Indicators (1 = yes, 0 = no/not reported) for the occurrence during the day of:\n # Fog ('F' - 1st digit).\n # Rain or Drizzle ('R' - 2nd digit).\n # Snow or Ice Pellets ('S' - 3rd digit).\n # Hail ('H' - 4th digit).\n # Thunder ('T' - 5th digit).\n # Tornado or Funnel Cloud ('T' - 6th digit). \n ]\n# Use TEMP and DEWP and STP to calculate wet bulb temperatures\n# Values to be converted to floats always\ngsod_float_fields = ('TEMP', 'DEWP', 'SLP', 'STP', 'VISIB', 'WDSP', 'MXSPD', \n 'GUST', 'MAX', 'MIN', 'PRCP', 'SNDP')\n# Values to be converted to ints always\ngsod_int_fields = ('TEMP_COUNT', 'DEWP_COUNT', 'SLP_COUNT', 'STP_COUNT', \n 'VISIB_COUNT', 'WDSP_COUNT')\n\n# Values which signify flags\ngsod_flag_chars = '*ABCDEFGHI'\n# Values which should be converted to None, as normally there is no value\ngsod_bad_values = set(['99.99', '999.9', '9999.9'])\n\ngsod_indicator_names = ['fog', 'rain', 'snow_ice', 'hail', 'thunder', \n 'tornado']\nfive_ninths = 5.0/9.0\n\ngsod_day = namedtuple('gsod_day', gsod_fields + gsod_indicator_names)\n\n\ndef gsod_day_parser(line, SI=True, to_datetime=True):\n '''One line (one file) parser of data in the format of the GSOD database.\n Returns all parsed results as a namedtuple for reduced memory consumption.\n Will convert all data to base SI units unless the `SI` flag is set to \n False. As the values are rounded to one or two decimal places in the\n GSOD database in Imperial units, it may be useful to look at the values\n directly. \n \n The names columns of the columns in the GSOD database are retained and used\n as the attributes of the namedtuple results.\n \n The day, month, and year are normally converted to a datetime instance in\n resulting namedtuple; this behavior can be disabled by setting the \n `datetime` flag to False; it will be a string in the format YYYYMMDD if so.\n This may be useful because datetime conversion roughly doubles the speed of\n this function.\n \n Parameters\n ----------\n line : str\n Line in format of GSOD documentation, [-]\n SI : bool\n Whether or not the results get converted to base SI units, [-] \n to_datetime : bool\n Whether or not the date gets converted to a datetime instance or stays\n as a string, [-]\n\n Returns\n -------\n gsod_day_instance : gsod_day\n namedtuple with fields described in the source (all values in SI units,\n if `SI` is True, i.e. meters, m/s, Kelvin, Pascal; otherwise the \n original unit set is used), [-]\n ''' \n # Ignore STN--- and WBAN, 8-12 characters\n fields = line.strip().split()[2:]\n # For the case the field is blank, set it to None; strip it either way \n for i in range(len(fields)):\n field = fields[i].strip()\n if not field:\n field = None\n fields[i] = field \n\n obj = dict(zip(gsod_fields, fields))\n # Convert the date to a datetime object if specified\n if to_datetime and obj['DATE'] is not None:\n obj['DATE'] = datetime.datetime.strptime(obj['DATE'], '%Y%m%d')\n \n # Parse float values as floats\n for field in gsod_float_fields:\n value = obj[field].rstrip(gsod_flag_chars)\n if value in gsod_bad_values:\n value = None\n else:\n value = float(value)\n obj[field] = value\n \n if SI:\n # All temperatures are in deg F\n for field in ('TEMP', 'DEWP', 'MAX', 'MIN'):\n value = obj[field]\n if value is not None:\n # F2K inline for efficiency unfortunately\n obj[field] = (value + 459.67)*five_ninths\n\n # Convert visibility, wind speed, pressures\n # to si units of meters, Pascal, and meters/second.\n if obj['VISIB'] is not None:\n obj['VISIB'] = obj['VISIB']*mile\n if obj['PRCP'] is not None:\n obj['PRCP'] = obj['PRCP']*inch\n if obj['SNDP'] is not None:\n obj['SNDP'] = obj['SNDP']*inch\n if obj['WDSP'] is not None:\n obj['WDSP'] = obj['WDSP']*knot \n if obj['MXSPD'] is not None:\n obj['MXSPD'] = obj['MXSPD']*knot\n if obj['GUST'] is not None:\n obj['GUST'] = obj['GUST']*knot\n if obj['SLP'] is not None:\n obj['SLP'] = obj['SLP']*100.0\n if obj['STP'] is not None:\n obj['STP'] = obj['STP']*100.0\n\n # Parse int values as ints\n for field in gsod_int_fields:\n value = obj[field] \n if value is not None:\n obj[field] = int(value)\n\n indicator_values = [flag == '1' for flag in obj['FRSHTT']]\n obj.update(zip(gsod_indicator_names, indicator_values))\n return gsod_day(**obj)\n", "meta": {"hexsha": "346b730e4a3e8673457107c68b11371a8b6b271d", "size": 32051, "ext": "py", "lang": "Python", "max_stars_repo_path": "fluids/design_climate.py", "max_stars_repo_name": "rddaz2013/fluids", "max_stars_repo_head_hexsha": "acde6a6edc2110c152c59341574739b24a2f1bad", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "fluids/design_climate.py", "max_issues_repo_name": "rddaz2013/fluids", "max_issues_repo_head_hexsha": "acde6a6edc2110c152c59341574739b24a2f1bad", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "fluids/design_climate.py", "max_forks_repo_name": "rddaz2013/fluids", "max_forks_repo_head_hexsha": "acde6a6edc2110c152c59341574739b24a2f1bad", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.1437740693, "max_line_length": 239, "alphanum_fraction": 0.6054725282, "include": true, "reason": "import numpy,from scipy", "num_tokens": 7553, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5428632831725052, "lm_q2_score": 0.3629691986286475, "lm_q1q2_score": 0.19704265085804076}} {"text": "from __future__ import print_function\n#\n# Computing the free energy difference of an organic crystal polymorph at different gamma values\n# \n# Copyright Eric Dybeck and Michael R. Shirts, University of Virginia, 2014\n#\n\nimport numpy as np\nimport pymbar # multistate Bennett acceptance ratio\nfrom pymbar import timeseries # timeseries analysis\nfrom optparse import OptionParser # for parsing command-line options\nimport sys\nimport panedr\nimport os\n\ndef dA_MBAR(minimum=0, maximum=100, spacing=10, exponent=2, polymorphs='p1 p2', Molecules=72, Independent=4, Temp=200,\n bonds=False, primary_directory='.', added_directories=[]):\n # =============================================================================================\n # Setting up the values for gamma or lambda states\n # =============================================================================================\n# raw_value = minimum\n# values = []\n directory_names = np.arange(minimum, maximum + spacing, spacing)\n directory_names = np.sort(np.append(directory_names, added_directories)) \n\n# while raw_value <= maximum:\n# if exponent >= 0:\n# value = int(100 * (float(raw_value) / float(maximum)) ** abs(exponent))\n# else:\n# value = int(100 * (1 - (float(maximum - raw_value) / float(maximum)) ** abs(exponent)))\n# values.append(value)\n# raw_value = raw_value + spacing\n# print(values)\n# print(directory_names)\n# exit() \n \n # POLYMORPH\n polymorphs = polymorphs.split()\n\n # =============================================================================================\n # READ IN RAW DATA\n # =============================================================================================\n # Constants.\n kB = 1.3806488e-23 * 6.0221413e23 / (1000.0 * 4.184) # Boltzmann constant in kcal/mol\n \n # Parameters\n T_k = Temp * np.ones(len(directory_names), float) # Convert temperatures to floats\n print(T_k)\n # print(values)\n\n K = len(directory_names) # How many states?\n \n # total number of states examined; 0 are unsampled if bonds are left on, 1 is unsampled if the bonds are removed\n Kbig = K\n \n # maximum number of snapshots/simulation (could make this automated) - doesn't matter, as long as it's long enough.\n N_max = 5000\n \n # beta factor for the different temperatures\n beta_k = 1.0 / (kB * T_k)\n dA = np.zeros([len(polymorphs), Kbig], float)\n ddA = np.zeros([len(polymorphs), Kbig], float)\n convert_units = 0.2390057 * np.ones(Kbig, float) # Convert all energies to kcal/mol\n \n # Allocate storage for simulation data\n for i, poly in enumerate(polymorphs):\n # N_k[k] is the total number of snapshots from alchemical state k\n N_k = np.zeros([Kbig], np.int32)\n \n # N_k_s[k,s] is the total number of snapshots from alchemical state k from seed s\n N_k_s = np.zeros([Kbig], np.int32)\n \n # u_kln[k,l,n] is the adjusted energy of snapshot n from simulation k\n u_kln = np.zeros([K, Kbig, N_max], np.float64)\n \n # dhdl_kn[k,n] is the derivative of energy with respect to lambda of snapshot n from simulation k\n dhdl_kn = np.zeros([K, N_max], np.float64)\n \n #Load in the data for each run\n for k in range(K):\n n = 0\n\n # cycle through all the input total energy data\n if directory_names[k] == int(directory_names[k]):\n dirpath = polymorphs[i] + '/' + primary_directory + '/' + str(int(directory_names[k]))\n else:\n dirpath = polymorphs[i] + '/' + primary_directory + '/' + str(directory_names[k])\n if os.path.isdir(dirpath):\n fname = dirpath + '/PROD.edr'\n dhdlname = dirpath + '/dhdl_PROD.xvg'\n\n potential_energy = panedr.edr_to_df(fname)['Potential'].values\n print(\"loading \" + fname)\n\n dhdl_energy = np.loadtxt(dhdlname, comments=['#', '$', '@', '!'])\n print(\"loading \" + dhdlname)\n\n # Removing any non-equilibrated points of the simulation\n [start_production, _, _] = timeseries.detectEquilibration(potential_energy)\n potential_energy = potential_energy[start_production:]\n dhdl_energy = dhdl_energy[start_production:,:]\n\n # Cutting points if they exceed N_max\n if len(potential_energy) > N_max:\n potential_energy = potential_energy[len(potential_energy) - N_max:]\n dhdl_energy = dhdl_energy[len(dhdl_energy) - N_max:,:]\n\n # the energy of every configuration from each state evaluated at its sampled state\n n = len(potential_energy)\n dhdl_placement = len(dhdl_energy[0, :]) - K\n u_kln[k, :K, :n] = (potential_energy.reshape((n, 1)) + dhdl_energy[:, dhdl_placement:]).T * convert_units[k]\n dhdl_kn[k, :n] = (float(Independent) / Molecules) * \\\n np.sum(dhdl_energy[:, 2:dhdl_placement], axis=1) * convert_units[k]\n\n N_k_s[k] = n\n N_k[k] = n\n\n # convert to nondimensional units from kcal/mol\n u_kln *= beta_k[0]\n \n #u_kln_save = u_kln.copy()\n u_kln_save = u_kln[:]\n g_k = np.zeros([K])\n\n print(\"Number of retained samples\")\n print(N_k)\n print(\"Number of retained samples from each seed\")\n print(N_k_s)\n\n # =============================================================================================\n # COMPUTE FREE ENERGY DIFFERENCE USING MBAR\n # =============================================================================================\n \n # Initialize MBAR.\n print(\"Running MBAR...\")\n \n # generate the weights of each of the umbrella set\n mbar = pymbar.MBAR(u_kln, N_k, verbose=True, subsampling_protocol=[{'method': 'L-BFGS-B'}])\n \n print(\"MBAR Converged...\")\n # testing\n \n for k in range(Kbig):\n w = np.exp(mbar.Log_W_nk[:, k])\n print(\"max weight in state %d is %12.7f\" % (k, np.max(w)))\n neff = 1 / np.sum(w ** 2)\n print(\"Effective number of sample in state %d is %10.3f\" % (k, neff))\n print(\"Efficiency for state %d is %d/%d = %10.4f\" % (k, neff, len(w), neff / len(w)))\n \n # extract self-consistent weights and uncertainties\n (df_i, ddf_i, theta_i) = mbar.getFreeEnergyDifferences()\n \n print(\"Free Energies Optained...\")\n \n # convert PMF to kcal/mol and normalize by the number of molecules\n df_i /= (beta_k[0] * float(Independent))\n ddf_i /= (beta_k[0] * float(Independent))\n \n dA[i, :] = df_i[-1]\n\n # =============================================================================================\n # COMPUTE UNCERTAINTY USING THE UNCORRELATED DATA\n # =============================================================================================\n \n for k in range(K):\n N_k[k] = 0\n n_old = 0\n\n g_k[k] = timeseries.statisticalInefficiency(dhdl_kn[k, n_old: (n_old + N_k_s[k])])\n print(\"Correlation time for sampled state %d is %10.3f\" % (k, g_k[k]))\n # subsample the data to get statistically uncorrelated data\n indices = np.array(timeseries.subsampleCorrelatedData(u_kln[k, k, n_old:(n_old + N_k_s[k])],\n g=g_k[k])) # subsample\n \n # not sure why we have to transpose\n if indices != []:\n u_kln[k, :, N_k[k]: (N_k[k] + len(indices))] = u_kln_save[k, :, (indices + n_old)].transpose()\n N_k[k] = N_k[k] + len(indices)\n n_old += N_k_s[k]\n\n print(\"Number of retained samples\")\n print(N_k)\n print(\"Number of retained samples from each seed\")\n print(N_k_s)\n \n # generate the weights of each of the umbrella set\n mbar = pymbar.MBAR(u_kln, N_k, verbose=True, subsampling_protocol=[{'method': 'L-BFGS-B'}])\n \n print(\"MBAR Converged...\")\n \n # extract self-consistent weights and uncertainties\n try:\n (df_u, ddf_u, theta_i) = mbar.getFreeEnergyDifferences()\n except ValueError:\n pass\n \n print(\"Free Energies Optained...\")\n \n # convert PMF to kcal/mol and normalize by the number of molecules\n df_u /= (beta_k[0] * float(Independent))\n ddf_u /= (beta_k[0] * float(Independent))\n \n ddA[i, :] = ddf_u[-1]\n# ddA[i, :] = ddf_i[-1]\n \n # Write out free energy differences\n print(\"Free Energy Difference (in units of kcal/mol)\")\n print(\" dA(Gamma) = A(Gamma) - A(Interactions Off)\")\n for k in range(Kbig):\n print(\"%8.3f %8.3f\" % (df_i[k, -1], ddf_u[k, -1]))\n\n del N_k\n del N_k_s\n del u_kln\n del dhdl_kn\n\n out_dA = np.zeros(len(polymorphs))\n out_ddA = np.zeros(len(polymorphs))\n for i, poly in enumerate(polymorphs):\n out_dA[i] = dA[i, 0]\n out_ddA[i] = ddA[i, 0]\n\n return out_dA, out_ddA\n\n", "meta": {"hexsha": "eae4c33673463f4203a7a6309a84f593cc1f9faf", "size": 9297, "ext": "py", "lang": "Python", "max_stars_repo_path": "PSCP/analysis-scripts/dA_MBAR.py", "max_stars_repo_name": "shirtsgroup/finite-temperature-crystal-scripts", "max_stars_repo_head_hexsha": "799bc882d958d9afa264a168dae0b3051bafaf0b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "PSCP/analysis-scripts/dA_MBAR.py", "max_issues_repo_name": "shirtsgroup/finite-temperature-crystal-scripts", "max_issues_repo_head_hexsha": "799bc882d958d9afa264a168dae0b3051bafaf0b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 8, "max_issues_repo_issues_event_min_datetime": "2017-07-25T04:59:35.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-25T22:48:53.000Z", "max_forks_repo_path": "PSCP/analysis-scripts/dA_MBAR.py", "max_forks_repo_name": "shirtsgroup/finite-temperature-crystal-scripts", "max_forks_repo_head_hexsha": "799bc882d958d9afa264a168dae0b3051bafaf0b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-01-04T07:01:25.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-04T07:01:25.000Z", "avg_line_length": 41.32, "max_line_length": 124, "alphanum_fraction": 0.531676885, "include": true, "reason": "import numpy", "num_tokens": 2263, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5888891451980403, "lm_q2_score": 0.33458943461801643, "lm_q1q2_score": 0.19703608614449927}} {"text": "# This file is part of LayerModel_lib\n#\n# A tool to compute the transmission behaviour of plane electromagnetic waves\n# through human tissue.\n#\n# Copyright (C) 2018 Jan-Christoph Brumm\n#\n# Licensed under MIT license.\n#\nimport numpy as np\nimport os\nfrom scipy import ndimage\n\nfrom LayerModel_lib import VoxelModel, VoxelModelImporter, Coordinate, TissueProperties\n\ncurrent_directory = os.path.dirname(__file__)\nbase_path = os.path.join(current_directory, '..', '..', '..', '..', '..', 'Numerical Human Phantoms', 'Golem')\n\n# path to the AVW File of this model\nfilename = os.path.join(base_path, 'segm_golem')\n# path to the tissue_mapping file\ntissue_file = os.path.join('ImportGolem_tissues.txt')\n\nAVW_Data = VoxelModelImporter(filename, tissue_file, 'AVW')\nmodel_orig = AVW_Data.data['image']\ntissue_name_orig = AVW_Data.tissue_names\ntissue_mapping = AVW_Data.tissue_mapping\n\nGolem = VoxelModel()\nGolem.show_progress_bar = True\n\n# needs to be set manually from README.txt\nGolem.set_scale(2.08, 2.08, 8)\n\nGolem.name = 'Golem'\nGolem.description = 'Golem model from the Helmholtz Zentrum München. ' \\\n 'Resolution %.2fmm x %.2fmm x %.2fmm' % (Golem.scaling.x,\n Golem.scaling.y, Golem.scaling.z)\n\n# Golem is upside down and left right in wrong direction\nmodel_orig = np.flip(model_orig, axis=0)\nmodel_orig = np.flip(model_orig, axis=2)\n# The space around the model is too much\nmodel_orig = model_orig[0:166, :, :]\n\n# Calculate the outer_shape of the original and the complete model\nouter_shape = AVW_Data.calculate_outer_shape(model_orig, tissue_mapping)\n\nGolem.add_voxel_data(short_name='original',\n name='Original data from AVW file',\n model=model_orig,\n outer_shape=outer_shape,\n tissue_names=tissue_name_orig)\n\nGolem.add_voxel_data(short_name='complete',\n name='The \\'original\\' model converted to our TissueProperties.',\n model=Golem.models['original'].data,\n outer_shape=outer_shape,\n tissue_mapping=tissue_mapping)\n\n# Calculate the trunk model\nstart_slice = int(110)\nend_slice = int(175)\n\n(model_trunk, trunk_mask) = AVW_Data.calculate_trunk_model(Golem, 'complete', z_start=start_slice, z_end=end_slice)\nouter_shape_trunk = AVW_Data.calculate_outer_shape(model_trunk)\n\n# label the inner parts of the small intestine as GIcontents. For that erode the small intestine in\n# 3D and replace the resulting voxels with GIcontents.\ntp = TissueProperties()\n\ntrunk = model_trunk\n\n# Golem has no labeled SmallIntestineContents. Therefore, we need to label that by ourself:\n# select only the small intenstine\ntrunk_si = trunk == tp.get_tissue_id_for_name(['SmallIntestine'])\nstruct = ndimage.generate_binary_structure(3, 1)\n# Erode the small intestine wall:\ntrunk_si_eroded = ndimage.binary_erosion(trunk_si, structure=struct, iterations=1)\ntrunk_si_out = np.copy(trunk)\n# replace remaining inner small intestine with GIcontents\ntrunk_si_out[trunk_si_eroded] = tp.get_tissue_id_for_name(['GIcontents'])\n\nmodel_trunk = trunk_si_out\n\nGolem.add_voxel_data(short_name='trunk',\n name=\"The trunk of the 'complete' model. Arms have been removed using \"\n \"VoxelModel.remove_arms().\",\n outer_shape=outer_shape_trunk,\n model=model_trunk,\n mask=trunk_mask,\n tissue_mapping=None)\n\nsurface = Golem.create_3d_model(model_type='trunk', patch_size=(30, 30))\nGolem.models['trunk'].surface_3d = surface\n\nGolem.models['trunk'].endpoints = []\nfor (i, s) in enumerate(surface):\n Golem.models['trunk'].endpoints.append(Coordinate(np.array(s['centroid'])))\n\nGolem.save_model()\n", "meta": {"hexsha": "8a885302c0d4d342f15954825c585a0284b4ecf8", "size": 3822, "ext": "py", "lang": "Python", "max_stars_repo_path": "phantom_import/ImportGolem.py", "max_stars_repo_name": "janbrumm/layermodel_lib", "max_stars_repo_head_hexsha": "0d5e0c9ac77d302910823ebc757a4ec99541f3ff", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "phantom_import/ImportGolem.py", "max_issues_repo_name": "janbrumm/layermodel_lib", "max_issues_repo_head_hexsha": "0d5e0c9ac77d302910823ebc757a4ec99541f3ff", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "phantom_import/ImportGolem.py", "max_forks_repo_name": "janbrumm/layermodel_lib", "max_forks_repo_head_hexsha": "0d5e0c9ac77d302910823ebc757a4ec99541f3ff", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.4705882353, "max_line_length": 115, "alphanum_fraction": 0.7006802721, "include": true, "reason": "import numpy,from scipy", "num_tokens": 927, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.588889130767832, "lm_q2_score": 0.33458943461801643, "lm_q1q2_score": 0.19703608131630407}} {"text": "#!/usr/bin/env python\n\n\"\"\"\nshort script to transform remodnav\n(https://github.com/psychoinformatics-de/remodnav) outputs from naturalistic\nstimulation with hollywood movie forrest gump into fixation vectors\n\"\"\"\n\nimport numpy as np\nimport pandas as pd\nfrom bisect import bisect_right\nimport os.path as op\n\n\ndef pursuits_to_fixations(npdata):\n \"\"\"this function takes a numpy record array from Asims eye-event detection\n algorithm. Start and end points of pursuits are transformed into a fixation,\n the pursuit movement can then be simplified as a saccade. The function\n returns a recordarray\"\"\"\n # initialize empty rec array of the same shape\n newdata = np.recarray((0,), dtype=[('onset', '= 0,\n Filterevents['start_x'] <= sz[0])]\n # within y coordinates?\n Filterybounds = Filterxbounds[np.logical_and(Filterxbounds['start_y'] >= 0,\n Filterxbounds['end_y'] <= sz[1])]\n # give me onset times, start_x, start_y and duration\n fixations = Filterybounds[[\"onset\", \"start_x\", \"start_y\",\n \"duration\"]]\n return fixations\n\n\ndef takeClosestright(myList, myNumber):\n \"\"\"return the integer closest to 'myNumber' in an ordered list.(shamelessly\n stolen from\n https://stackoverflow.com/questions/12141150/from-list-of-integers-get-number-\n closest-to-a-given-value)\n \"\"\"\n pos = bisect_right(myList, myNumber)\n if pos == 0:\n return myList[0]\n if pos == len(myList):\n return myList[-1]\n after = myList[pos]\n return after\n\n\ndef createOnsets(data, dur):\n \"\"\"create onset times of all shots of 'dur' seconds of length\n data = dataframe, should be location annotation\n dur = duration in seconds\"\"\"\n onsets = []\n for index, row in data.iterrows():\n if row['duration'] >= dur:\n onsets.append(row['onset'])\n return onsets\n\n\ndef createChunks(onsets, fixations, dur):\n \"\"\"Create and return start and end indices to chunk eye movement data into\n segments to compare scanpaths across.\n onsets = output from CreateOnsets()\n fixations = output from preprocess(). n x 4 np record array\n dur = durations of segments in seconds\"\"\"\n # initialize empty lists\n startidx, endidx = [], []\n for shotonset in onsets:\n start = takeClosestright(fixations['onset'], shotonset)\n startidx.append(np.where(fixations['onset'] == start)[0].tolist())\n end = takeClosestright(fixations['onset'], shotonset + dur)\n endidx.append(np.where(fixations['onset'] == end)[0].tolist())\n # flatten the nested lists\n startidx = [element for sublist in startidx for element in sublist]\n endidx = [element for sublist in endidx for element in sublist]\n return startidx, endidx\n\n\ndef FixationsChunks(fixations, startid, endid):\n \"\"\"Chunk eye movement data into segments of approximate length to compute\n scanpath similarities. Output is returned as a n x 3 fixation vector.\n startid, endid = output from createChunks\n fixations = output from preprocess\"\"\"\n fixation_vector = []\n # slice fixation data according to indices, take columns start_x, start_y and\n # duration\n for idx in range(0, len(startid)):\n ind = fixations[startid[idx]:endid[idx]][[\"start_x\", \"start_y\", \"duration\"]]\n fixation_vector.append(ind)\n return fixation_vector\n\n\ndef longshot(shots, dur):\n \"\"\"group movie shots without a cut together to obtain longer movie\n segments. This way, fewer but longer scanpaths are obtained. Example: use\n median shotlength of 4.92s.\n shots = dataframe, contains movie location annotation\n dur = length in seconds for movie shot\n \"\"\"\n # turn pandas dataframe shots into record array\n structshots = shots.to_records()\n i = 0\n while i < len(structshots):\n # break before running into index error\n if structshots[i] == structshots[-1]:\n break\n else:\n if (structshots[i]['duration'] < dur) & \\\n (structshots[i + 1]['duration'] < dur) & \\\n (structshots[i]['locale'] == structshots[i + 1]['locale']):\n # add durations together and delete second row\n structshots[i]['duration'] += structshots[i + 1]['duration']\n structshots = np.delete(structshots, i + 1, 0)\n else:\n i += 1\n aggregated = pd.DataFrame({'onset': structshots['onset'].tolist(),\n 'duration': structshots['duration'].tolist()}, columns=['onset',\n 'duration'])\n return aggregated\n\n\ndef savefile(fixation_vector, output, header):\n newheader = ''.join([w + '\\t' for w in header]).strip()\n np.savetxt(output, fixation_vector, delimiter='\\t', comments='', header=newheader)\n\n\ndef run(data1, shots, sz, dur, subname):\n newdata1 = pursuits_to_fixations(data1)\n fixations1 = preprocess(newdata1, sz)\n shots = longshot(shots, dur)\n onset = createOnsets(shots, dur)\n startid1, endid1 = createChunks(onset, fixations1, dur)\n fixation_vectors1 = FixationsChunks(fixations1, startid1, endid1)\n header = fixation_vectors1[0].dtype.names\n for i in range(0, len(onset)):\n output = args.output + '/fixvectors/segment_' + str(i) + '_' + subname + '.tsv'\n print('saving file', i, 'into', output)\n savefile(fixation_vectors1[i], output, header)\n\n\nif __name__ == '__main__':\n import argparse\n\n parser = argparse.ArgumentParser()\n # define arguments\n parser.add_argument('-i', '--input1', nargs='+', help='Input: eyemovement data of one subject', metavar='PATH',\n required=True)\n parser.add_argument('-o', '--output', help='Output: Specify path where output should be saved', metavar='PATH',\n required=True)\n parser.add_argument('-sz', '--screensize',\n help='Screensize: what are the dimensions of the screen the stimulus was displayed on in px, e.g. [1280, 720]',\n default=[1280, 720])\n parser.add_argument('-s', '--shots', help='Input3: location annotation of the movie segment', metavar='PATH',\n required=True)\n parser.add_argument('-d', '--duration',\n help='approximate duration of video segments to derive fixation vectors from', default=5.0)\n args = parser.parse_args()\n\n\n data1 = np.recfromcsv(args.input1[0],\n delimiter='\\t',\n dtype={'names': ('onset', 'duration', 'label', 'start_x', 'start_y',\n 'end_x', 'end_y', 'amp', 'peak_vel', 'med_vel', 'avg_vel'),\n 'formats': ('f8', 'f8', 'U10', 'f8', 'f8', 'f8', 'f8', 'f8', 'f8',\n 'f8', 'f8')})\n shots = pd.read_csv(args.shots, sep='\\t')\n\n subname = op.basename(args.input1[0]).split('_')[0]\n\n if args.screensize:\n sz = args.screensize\n else:\n sz = [1280, 720]\n\n if args.duration:\n dur = float(args.duration)\n else:\n dur = 5.0\n\n # run everything\n run(data1, shots, sz, dur, subname)\n", "meta": {"hexsha": "ff8397edcc057f1ccf02cecc761f946aace0da64", "size": 9174, "ext": "py", "lang": "Python", "max_stars_repo_path": "data/code/create_videodata.py", "max_stars_repo_name": "kyleniemeyer/multimatch_gaze", "max_stars_repo_head_hexsha": "fd022cf90f0690c0d334d3a2ed1d77dd2cf6db7d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 18, "max_stars_repo_stars_event_min_datetime": "2019-06-25T06:12:41.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-24T14:56:39.000Z", "max_issues_repo_path": "data/code/create_videodata.py", "max_issues_repo_name": "kyleniemeyer/multimatch_gaze", "max_issues_repo_head_hexsha": "fd022cf90f0690c0d334d3a2ed1d77dd2cf6db7d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 24, "max_issues_repo_issues_event_min_datetime": "2019-05-01T12:24:56.000Z", "max_issues_repo_issues_event_max_datetime": "2020-12-26T11:21:20.000Z", "max_forks_repo_path": "data/code/create_videodata.py", "max_forks_repo_name": "AdinaWagner/MultiMatch", "max_forks_repo_head_hexsha": "36fd53076b8e95897ed2e8650ecaa9d9c4de9bc0", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2019-07-18T13:12:06.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-21T07:35:44.000Z", "avg_line_length": 41.7, "max_line_length": 135, "alphanum_fraction": 0.5808807499, "include": true, "reason": "import numpy", "num_tokens": 2161, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6076631840431539, "lm_q2_score": 0.32423541204073586, "lm_q1q2_score": 0.1970259228602175}} {"text": "\"\"\"Automatic differentiation filter-error method estimation models.\"\"\"\n\n\nimport collections\nimport functools\nimport inspect\nimport itertools\n\nimport jax\nfrom jax import numpy as jnp\nfrom jax import scipy as jscipy\n\nimport numpy as onp\n\n\n### Enable 64-bit in jax ###\njax.config.update(\"jax_enable_x64\", True)\n\n\nclass BoundADFunction:\n def __init__(self, adfun, model):\n self.adfun = adfun\n self.model = model\n \n @property\n def __signature__(self):\n return bound_signature(self.adfun)\n \n @property\n def __name__(self):\n return self.adfun.__name__\n \n def __repr__(self):\n cls = type(self)\n name = getattr(self, '__name__', '*no name*')\n return f\"<{cls.__module__}.{cls.__name__} '{name}'>\"\n \n def __call__(self, *args, **kwargs):\n return self.adfun(self.model, *args, **kwargs)\n \n def hess_filter(self, dec_shapes=None, out_shape=None):\n filt_name = f'_{self.__name__}_hess_filter'\n try:\n return getattr(self.model, filt_name)\n except AttributeError:\n assert dec_shapes is not None\n assert out_shape is not None\n \n hess_filter = {}\n adfun = self.adfun\n wrt_seq = adfun.hessian\n ind_base = adfun._sparse_deriv_ind(wrt_seq, dec_shapes, out_shape)\n for wrt, ind in ind_base.items():\n if len(wrt) == 2 and wrt[0] == wrt[1]:\n hess_filter[wrt] = ind[0] > ind[1]\n setattr(self.model, filt_name, hess_filter)\n return hess_filter\n \n def hess_nnz(self, dec_shapes, out_shape):\n adfun = self.adfun\n wrt_seq = adfun.hessian\n filter = self.hess_filter(dec_shapes, out_shape)\n return adfun._sparse_deriv_nnz(wrt_seq, dec_shapes, out_shape, filter)\n \n def hess_ind(self, dec_shapes, out_shape):\n adfun = self.adfun\n wrt_seq = adfun.hessian\n filter = self.hess_filter(dec_shapes, out_shape)\n return adfun._sparse_deriv_ind(wrt_seq, dec_shapes, out_shape, filter)\n\n def hess_val(self, *args, **kwargs):\n adfun = self.adfun\n model = self.model\n wrt_seq = adfun.hessian\n \n # The filter must be built by a previous call to hess_ind or hess_nnz\n filter = self.hess_filter()\n \n return adfun._sparse_deriv_val(wrt_seq, model, args, kwargs, filter)\n\n\nclass BoundADConstraint(BoundADFunction):\n def jac_nnz(self, dec_shapes, out_shape):\n adfun = self.adfun\n d1 = adfun.first_derivatives\n return adfun._sparse_deriv_nnz(d1, dec_shapes, out_shape)\n \n def jac_ind(self, dec_shapes, out_shape):\n adfun = self.adfun\n d1 = adfun.first_derivatives\n return adfun._sparse_deriv_ind(d1, dec_shapes, out_shape)\n\n def jac_val(self, *args, **kwargs):\n adfun = self.adfun\n d1 = adfun.first_derivatives\n return adfun._sparse_deriv_val(d1, args, kwargs)\n\n\nclass BoundADObjective(BoundADFunction):\n def grad(self, *args, **kwargs):\n adfun = self.adfun\n ret = collections.OrderedDict()\n for wrt in adfun.first_derivatives:\n # Calculate the gradient\n grad_fun = adfun.derivatives[wrt,]\n grad_val = grad_fun(self.model, *args, **kwargs)\n \n # skip empty gradients\n if not grad_val.size:\n continue\n \n # Get the shape of the wrt argument\n try:\n wrt_shape = onp.shape(kwargs[wrt])\n except KeyError:\n wrt_shape = onp.shape(args[adfun.argnum(wrt) - 1])\n \n # Accumulate so the gradient has the same shape as the variable\n ret[wrt] = grad_val.reshape(-1, *wrt_shape).sum(0)\n return ret\n\n\nclass ADFunction:\n \"\"\"Helper for optimization function automatic differentiation.\"\"\"\n\n BoundClass = BoundADFunction\n \n def __init__(self, fun, core_shape=''):\n self.fun = fun\n \"\"\"Underlying function.\"\"\"\n \n self.core_shape = core_shape\n \"\"\"The shape of the output of the elementary function, if vectorized.\"\"\"\n \n self.hessian = None\n \"\"\"Hessian elements.\"\"\"\n \n self.__signature__ = inspect.signature(self.fun)\n \"\"\"The underlying function's signature.\"\"\"\n \n self.args = list(self.__signature__.parameters)\n \"\"\"The underlying function argument names.\"\"\"\n \n self.derivatives = {}\n \"\"\"Dictionary of function derivatives.\"\"\"\n\n self.first_derivatives = []\n \"\"\"Sequence of registered first derivatives.\"\"\"\n \n self.isvectorized = False\n \"\"\"Whether the function is vectorized\"\"\"\n \n def __call__(self, *args, **kwargs):\n return self.fun(*args, **kwargs)\n\n def __get__(self, instance, owner=None):\n if instance is None:\n return self\n else:\n return self.BoundClass(self, instance)\n\n def __set_name__(self, owner, name):\n self.__name__ = name\n \n def __repr__(self):\n cls = type(self)\n name = getattr(self, '__name__', '*no name*')\n return f\"<{cls.__module__}.{cls.__name__} '{name}'>\"\n \n def argnum(self, argname):\n return self.args.index(argname)\n \n def derivative(self, wrt):\n if isinstance(wrt, str):\n wrt_tuple = wrt,\n return self.derivative(wrt_tuple)\n \n # Trivial case, i.e., 0-th derivative\n if wrt == ():\n return self.fun\n \n # Return the registered derivative, if it exists\n try:\n return self.derivatives[wrt]\n except KeyError:\n pass\n \n # Compute the derivative\n assert len(wrt) >= 1\n fun = self.derivative(wrt[1:])\n argnum = self.argnum(wrt[0])\n deriv = jax.jacrev(fun, argnum)\n \n # Save it and return\n self.derivatives[wrt] = deriv\n return deriv\n \n def prepare_derivatives(self, decision):\n # Compute and save the first derivatives\n for d in self.args:\n if d in decision:\n self.derivative(d)\n self.first_derivatives.append(d)\n \n # Define default Hessian, if unset\n if self.hessian is None:\n first_deriv = self.first_derivatives\n hess_gen = itertools.combinations_with_replacement(first_deriv, 2)\n self.hessian = list(hess_gen)\n \n # Compute second derivatives\n for wrt_pair in self.hessian:\n self.derivative(wrt_pair)\n \n def vectorize(self, vectorized):\n vec_args = [a for a in self.args if a in vectorized]\n excluded = [i for i,a in enumerate(self.args) if a not in vectorized]\n \n if not vec_args:\n return\n \n arg_sig = \",\".join(f'({vectorized[a]})' for a in vec_args)\n sig = f\"{arg_sig}->({self.core_shape})\"\n \n self.fun = jnp.vectorize(self.fun, excluded=excluded, signature=sig)\n for wrt, d in self.derivatives.items():\n wrtsig = (vectorized[var] for var in reversed(wrt))\n if self.core_shape:\n outsig = ','.join((self.core_shape, *wrtsig))\n else:\n outsig = ','.join(wrtsig)\n dsig = f\"{arg_sig}->({outsig})\"\n vecd = jnp.vectorize(d, excluded=excluded, signature=dsig)\n self.derivatives[wrt] = vecd\n \n core_shape = self.core_shape\n out_core_ndim = len(core_shape.split(',')) if core_shape else 0\n self.core_ndim = {a: len(vectorized[a].split(',')) for a in vec_args}\n self.core_ndim[None] = out_core_ndim\n self.isvectorized = True\n \n def _split_shape(self, shape, varname=None):\n \"\"\"Split a variable's shape into extension and core.\"\"\"\n try:\n core_ndim = self.core_ndim[varname]\n except KeyError:\n return (), shape #This variable is not vectorized\n \n # Test whether the core element is scalar (ndim==0)\n if core_ndim:\n return shape[:-core_ndim], shape[-core_ndim:]\n else:\n return shape, () \n \n def _ext_shape(self, shape, varname=None):\n \"\"\"Return a variable's shape extension.\"\"\"\n return self._split_shape(shape, varname)[0]\n \n def _core_shape(self, shape, varname=None):\n \"\"\"Return a variable's core shape.\"\"\"\n return self._split_shape(shape, varname)[1]\n \n def _deriv_core_shape(self, wrt, dec_shapes, out_shape):\n out_ext, out_core = self._split_shape(out_shape)\n if len(wrt) == 0:\n return out_core\n else:\n wrt0, *wrt_rem = wrt\n wrt0_shape = dec_shapes[wrt0]\n wrt0_ext, wrt0_core = self._split_shape(wrt0_shape, wrt0)\n rem_core = self._deriv_core_shape(wrt_rem, dec_shapes, out_shape)\n return rem_core + wrt0_core\n \n def _deriv_core_ind(self, wrt, dec_shapes, out_shape):\n if len(wrt) == 0:\n out_ext, out_core = self._split_shape(out_shape)\n return [onp.arange(shape_size(out_core))]\n else:\n wrt0, *wrt_rem = wrt\n wrt0_shape = dec_shapes[wrt0]\n wrt0_ext, wrt0_core = self._split_shape(wrt0_shape, wrt0)\n rem_ind = self._deriv_core_ind(wrt_rem, dec_shapes, out_shape)\n \n wrt0_core_size = shape_size(wrt0_core)\n wrt0_tile = rem_ind[0].size\n wrt0_ind = onp.tile(onp.arange(wrt0_core_size), wrt0_tile)\n core_ind = [onp.repeat(i, wrt0_core_size) for i in rem_ind]\n core_ind.insert(0, wrt0_ind)\n return core_ind\n \n def _sparse_deriv_nnz(self, wrt_seq, dec_shapes, out_shape, filter={}):\n nnz = 0\n out_ext, out_core = self._split_shape(out_shape)\n ext_sz = shape_size(out_ext)\n for wrt in wrt_seq:\n if wrt in filter:\n nnz += filter[wrt].sum()\n else:\n deriv_core = self._deriv_core_shape(wrt, dec_shapes, out_shape)\n nnz += shape_size(deriv_core) * ext_sz\n return nnz\n \n def _sparse_deriv_ind(self, wrt_seq, dec_shapes, out_shape, filter={}):\n out_ext, out_core = self._split_shape(out_shape)\n core_out_sz = shape_size(out_core)\n \n ret = collections.OrderedDict()\n for wrt in wrt_seq:\n ind = []\n base_ind = self._deriv_core_ind(wrt, dec_shapes, out_shape)\n for wrt_name, wrt_ind in zip(wrt, base_ind):\n wrt_shape = dec_shapes[wrt_name]\n wrt_ext, wrt_core = self._split_shape(wrt_shape, wrt_name)\n wrt_core_sz = shape_size(wrt_core)\n \n wrt_offs = ndim_range(wrt_ext) * wrt_core_sz\n wrt_offs = onp.broadcast_to(wrt_offs, out_ext)\n ind.append((wrt_ind + wrt_offs[..., None]).ravel())\n \n # Extend the output indices\n out_ind = base_ind[-1]\n out_offs = ndim_range(out_ext) * core_out_sz\n ind.append((out_ind + out_offs[..., None]).ravel())\n \n # Save in dictionary\n selected = filter.get(wrt, slice(None))\n ret[wrt] = onp.array(ind)[:, selected]\n return ret\n \n def _sparse_deriv_val(self, wrt_seq, args, kwargs, filter={}):\n ret = collections.OrderedDict()\n for wrt in wrt_seq:\n deriv = self.derivatives[wrt]\n selected = filter.get(wrt, slice(None))\n ret[wrt] = deriv(*args, **kwargs).ravel()[selected]\n return ret\n\n\nclass ADConstraint(ADFunction):\n \"\"\"Helper for constraint function automatic differentiation.\"\"\"\n\n BoundClass = BoundADConstraint\n \n\nclass ADObjective(ADFunction):\n \"\"\"Helper for objective function automatic differentiation.\"\"\"\n\n BoundClass = BoundADObjective\n\n\ndef constraint(core_shape_or_fun=None):\n if callable(core_shape_or_fun):\n fun = core_shape_or_fun\n return constraint()(fun)\n else:\n core_shape = core_shape_or_fun\n def decorator(fun):\n return ADConstraint(fun, core_shape)\n return decorator\n\n\ndef objective(fun):\n return ADObjective(fun)\n\n\ndef hessian(*args):\n def decorator(obj):\n obj.hessian = args\n return obj\n return decorator\n\n\nclass ADModel:\n def __init_subclass__(cls):\n base_dec = getattr(super(), 'decision', set())\n cls_dec = getattr(cls, 'decision', set()) \n cls.decision = set.union(base_dec, cls_dec)\n \"\"\"The decision variables of this model.\"\"\"\n \n base_vec = getattr(super(), 'vectorized', {})\n cls_vec = getattr(cls, 'vectorized', {}) \n cls.vectorized = {**base_vec, **cls_vec}\n \"\"\"The core shape of vectorized variables.\"\"\"\n \n cls_items = cls.__dict__.items()\n adfuns = {k:v for k,v in cls_items if isinstance(v, ADFunction)}\n for name, adfun in adfuns.items():\n adfun.prepare_derivatives(cls.decision)\n adfun.vectorize(cls.vectorized)\n\n\nclass InnovationDTModel(ADModel):\n \n decision = {\n 'x', 'en', 'xnext', 'xprev', 'enprev', 'ybias', \n 'A', 'B', 'C', 'D', 'Ln', 'isRp_tril'\n }\n \"\"\"Decision variables of the optimization problem.\"\"\"\n \n vectorized = dict(\n x='nx', en='ny', xnext='nx', xprev='nx', enprev='ny',\n u='nu', y='ny', uprev='nu',\n A='nx,nx', B='nx,nu', C='ny,nx', D='ny,nu', Ln='nx,ny', ybias='ny',\n isRp_tril='nty',\n )\n \"\"\"Decision variables of the optimization problem.\"\"\"\n \n def __init__(self, nx, nu, ny):\n self.nx = nx\n \"\"\"Number of states.\"\"\"\n \n self.nu = nu\n \"\"\"Number of inputs.\"\"\"\n \n self.ny = ny\n \"\"\"Number of outputs.\"\"\"\n \n @hessian(('xprev', 'A'), ('enprev', 'Ln'))\n @constraint('nx')\n def dynamics(self, xnext, xprev, uprev, enprev, A, B, Ln):\n \"\"\"Model dynamics defects.\"\"\"\n xpred = A @ xprev + B @ uprev + Ln @ enprev\n return xnext - xpred\n \n @hessian(('x', 'C'), ('x', 'isRp_tril'), ('C', 'isRp_tril'), \n ('D', 'isRp_tril'), ('ybias', 'isRp_tril'))\n @constraint('ny')\n def innovation(self, y, en, x, u, C, D, ybias, isRp_tril):\n \"\"\"Model normalized innovation constraint.\"\"\"\n ymodel = C @ x + D @ u + ybias\n isRp = tril_mat(isRp_tril)\n return isRp @ (y - ymodel) - en\n \n @hessian(('en', 'en'), ('isRp_tril', 'isRp_tril'))\n @objective\n def Ln(self, en, isRp_tril):\n \"\"\"Measurement log-likelihood.\"\"\"\n isRp = tril_mat(isRp_tril)\n log_det_isRp = jnp.log(isRp.diagonal()).sum()\n return -0.5 * (en ** 2).sum() + log_det_isRp\n\n\ndef tril_mat(tril_elem):\n \"\"\"Build a matrix from its lower-triangular elements.\"\"\"\n ntril = len(tril_elem)\n n = int(round(0.5*(onp.sqrt(8*ntril + 1) - 1)))\n tril_ind = onp.tril_indices(n)\n M = jnp.zeros((n, n))\n return M.at[tril_ind].set(tril_elem)\n\n\ndef shape_size(shape):\n return onp.prod(shape, dtype=int)\n\n\ndef ndim_range(shape):\n assert isinstance(shape, tuple)\n return onp.arange(shape_size(shape)).reshape(shape)\n\n\ndef bound_signature(method):\n \"\"\"Return the signature of a method when bound.\"\"\"\n sig = inspect.signature(method)\n param = list(sig.parameters.values())[1:]\n return inspect.Signature(param, return_annotation=sig.return_annotation)\n", "meta": {"hexsha": "26a5616a24a0e4ff402cae951456f3e518d89db0", "size": 15543, "ext": "py", "lang": "Python", "max_stars_repo_path": "adfem.py", "max_stars_repo_name": "dimasad/colloc-fem-code", "max_stars_repo_head_hexsha": "1004e9b4aada426e1aa243d4c60cf80d2e1d1431", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "adfem.py", "max_issues_repo_name": "dimasad/colloc-fem-code", "max_issues_repo_head_hexsha": "1004e9b4aada426e1aa243d4c60cf80d2e1d1431", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "adfem.py", "max_forks_repo_name": "dimasad/colloc-fem-code", "max_forks_repo_head_hexsha": "1004e9b4aada426e1aa243d4c60cf80d2e1d1431", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.3540772532, "max_line_length": 80, "alphanum_fraction": 0.584571833, "include": true, "reason": "import numpy,import scipy,import jax,from jax", "num_tokens": 3874, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.3849121585956185, "lm_q1q2_score": 0.1969659429059011}} {"text": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Mon Sep 21 14:09:18 2020\n\n@author: gao\n\"\"\"\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom matplotlib import colors\nfrom mpl_toolkits.axes_grid1 import AxesGrid\nimport matplotlib as mpl\nimport os\nfrom matplotlib.colors import LinearSegmentedColormap\n#-------------------------------------------------------------------------------\n# set display width\nnp.get_printoptions()['linewidth']\nnp.set_printoptions(linewidth=400)\n#-------------------------------------------------------------------------------\n\"read size data at n=3, only size effects\"\n\ngrid_chi=101 # grid size in figure, so check figure.py file first\ngrid_n=7 # 13[5], 23[6], 37[7]; 58[8]; 87[9]; 128[10]\n\nchi_ratio_num=grid_chi\nchi_ratio_log = np.linspace(-0.4,0.4, chi_ratio_num) # log scale for chi/chi_neutral\nchi_ratio_list=[np.power(10,i) for i in chi_ratio_log] # chi/chi_neutral\nratio_index=72\n\nwith open(\"../simulation/LC.txt\", \"r\") as file:\n lcs = eval(file.readline()) # read lc list\n\n#--------define a function to transform [1+2] to 1+2--------------------\ndef lc_add(x): # x is the number for life cycles\n\tlcs[x].sort(reverse=True)\n\toff_num=len(lcs[x])\n\tini=str(lcs[x][0]) #initial lcs\n\tfor i in range(1,off_num):\n\t\tini=ini+'+'+str(lcs[x][i])\n\treturn ini\n\n#----------------------------------------\nN=3\nlc_list=[5,56]\n\n\"add a list [[maturity size=3],[],[],;;;]\"\ndata_list=[ ]\n\t\nfor chi_cluster in range(ratio_index,ratio_index+1): # how many figures or cell divisions\n\tfor N_cluster in range(N-1,N): # y axes points = a\n\t\tall_list=[] # algin all lcs' growth rates\n\t\tfor i_th in lc_list: # read all lcs data = growth rate\n\t\t\t\t\n\t\t\twith open('../data/data_size_effect/%d_%d_%d.txt'%(N_cluster,chi_cluster,i_th), \"r\") as file:\n\t\t\t\tnan=float(np.nan)\n\t\t\t\tinf=np.inf\n\t\t\t\tgrate = eval(file.readline()) # read growth rate\n\t\t\tdata_list.append(np.array([chi_cluster,i_th,grate]))\n\t\t\t\ndata_size=np.array(data_list)\n\n#-------------------------------------------------------------------------------\n\"read data of the threshold effects across k, only threshold effects\"\n\ngrid_num=31 # grid size in figure, so check figure.py file first\ngrid_m_num=11 # 13[5], 23[6], 37[7]; 58[8]; 87[9]; 128[10]\n\nb_range=np.array([1,16])\nm_range=np.array([0,0.1])\nk_range=np.array([1,2,3,4,5,6,7,8]) # first take 1,2,3, \nk_cluster_list=np.array([0,1,2,3,4,5,6])\n\ngrid_b=np.linspace(b_range[0],b_range[1],num=grid_num,endpoint=True)\ngrid_m=np.linspace(m_range[0],m_range[1],num=grid_m_num,endpoint=True)\n\ncell_number=[3,4,5,6,7,8]\nend_lc_list=[3,7,13,23,37,58] # 13[5], 23[6], 37[7]; 58[8]; 87[9]; 128[10] # how many lcs we care\n\n\"add a list [[maturity size=3],[],[],;;;]\"\ndata_game=[]\nmax_size=8\nfor i in range(5,max_size-2):\n\tn=cell_number[i]\n\tend_lc=end_lc_list[i]\n\t#-------------------------------------------------------------------------------\n\t\"read max and min dps from data into result []\"\n\tnum_k=len(k_cluster_list)\n\tfor b_cluster in range(18,19): # b=10\n\t\tfor m_cluster in range(1,2): # y axes points = a\n\t\t\tfor k_cluster in k_cluster_list:\n\t\t\t\tfor i_th in lc_list: # read all lcs data = growth rate\n\t\t\t\t\twith open('../data/data_threshold_effect/%d_%d_%d_%d.txt'%(b_cluster,m_cluster,k_cluster,i_th), \"r\") as file:\n\t\t\t\t\t\tnan=float(np.nan)\n\t\t\t\t\t\tinf=np.inf\n\t\t\t\t\t\tgrate = eval(file.readline()) # read growth rate\n\t\t\t\t\tdata_game.append([b_cluster,m_cluster,k_cluster,i_th,grate])\ndata_game=np.array(data_game)\n\n#-------------------------------------------------------------------------------\n\"read data of both effects across k,\"\ngrid_num=7 # grid size in figure, so check figure.py file first\nt_ratio=1.5\n\nresult_list=[[],[]] # to store data of each k value\noptimal_matrix_list=[np.zeros(shape=(grid_num,grid_num))*np.nan for i in range(2)]\n\n\"add a list [[maturity size=3],[],[],;;;]\"\ndata_both=[]\nfor t_pterb_cluster in range(2,3): # perturbation at n=3\n\tfor k_cluster in range(0,grid_num): # y axes points = a\n\t\tall_list=[] # algin all lcs' growth rates\n\t\tfor i_th in lc_list: # read all lcs data = growth rate\n\t\t\t\t\t\t\t\t\t\t\n\t\t\twith open('../data/data_size_threshold_chi_%s/%d_%d_%d.txt'%(t_ratio,t_pterb_cluster,k_cluster,i_th), \"r\") as file:\n\t\t\t\tnan=float(np.nan)\n\t\t\t\tinf=np.inf\n\t\t\t\tgrate = eval(file.readline()) # read growth rate\n\t\t\tdata_both.append(np.array([t_ratio,t_pterb_cluster,k_cluster,i_th,grate]))\n\ndata_both=np.array(data_both)\n\n#================= draw figures====================================================\nc = np.arange(1, 58 + 1)\n\nnorm = mpl.colors.Normalize(vmin=c.min(), vmax=c.max())\ncmap = mpl.cm.ScalarMappable(norm=norm, cmap=mpl.cm.jet)\ncmap.set_array([])\n \nfig, ax = plt.subplots(1, 1, figsize=(4, 4.5))\nfig.subplots_adjust(top=0.82)\nax.set_axisbelow(True)\nk_list=[1,2,3,4,5,6,7]\n\n\"size figure\"\ns_size=1\nfor i in lc_list:\n\ty=data_size[np.where(data_size[:,1]==i)][0,2]\n\tax.scatter(k_list, [y for i in range(7)], s=s_size,marker=\"^\",c=cmap.to_rgba(i + 1),alpha=0.9)\n\tif s_size==1:\n\t\tax.plot(k_list, [y for i in range(7)], ':',label=\"Size effects\",linewidth=1.5,c=cmap.to_rgba(i + 1),alpha=0.95)\n\telse:\n\t\tax.plot(k_list, [y for i in range(7)], ':',linewidth=1.5,c=cmap.to_rgba(i + 1),alpha=0.95)\n\t\n\t\"game figure\"\t\n\ty_game=data_game[np.where(data_game[:,3]==i)][:,4]\n\tax.scatter(k_list, y_game, s=s_size,marker=\"^\",c=cmap.to_rgba(i + 1),alpha=0.9)\n\tif s_size==1:\n\t\tax.plot(k_list, y_game, '--',label=\"Threshold effets\",linewidth=2,c=cmap.to_rgba(i + 1),alpha=0.95)\n\telse:\n\t\tax.plot(k_list, y_game, '--',linewidth=2,c=cmap.to_rgba(i + 1),alpha=0.95)\n\t\t\n\t\"size and game figure\"\t\n\ty_both=data_both[np.where(data_both[:,3]==i)][:,4]\n\tax.scatter(k_list, y_both, s=s_size,marker=\"^\",c=cmap.to_rgba(i + 1),alpha=0.9)\n\t\n\tif s_size==1:\n\t\tax.plot(k_list, y_both, '-',label=\"Combined effects\",linewidth=2,c=cmap.to_rgba(i + 1),alpha=0.75)\n\telse:\n\t\tax.plot(k_list, y_both, '-',linewidth=2,c=cmap.to_rgba(i + 1),alpha=0.75)\n\n\ts_size+=1\n\t\nleg=ax.legend(frameon=False,loc='upper center', bbox_to_anchor=(0.7, 0.98), shadow=True, ncol=1, fontsize=10)\nfor i in range(3):\n\tleg.legendHandles[i].set_color('k')\n\t\nax.annotate(lc_add(lc_list[0]), (2.3, 1.65),color=cmap.to_rgba(5 + 1))\t\nax.annotate(lc_add(lc_list[1]), (4.5, 1.85),color=cmap.to_rgba(56 + 1))\t\n\nax.set_xlabel(r\"Contribution threshold $k$\",fontsize=12)\nax.set_xticks([i for i in range(1,8)], minor=False)\nax.set_ylim([0.65, 3.5])\nax.set_ylabel(r\"Population growth rate $\\lambda$\",fontsize=12)\n\nax.spines['right'].set_visible(False)\nax.spines['top'].set_visible(False)\nax.spines['left'].set_visible(False)\nax.yaxis.set_ticks_position('left')\n\nplt.show();\n\n\n", "meta": {"hexsha": "d40aa0c70acd7fef4a729d46fd208a7c700f41ce", "size": 7227, "ext": "py", "lang": "Python", "max_stars_repo_path": "figure/Figure4D.py", "max_stars_repo_name": "YuanxiaoGao/Evolution_of_reproductive_strategies_in_incipient_multicellularity", "max_stars_repo_head_hexsha": "13eb51639fcee630a76e197b50ef321e3a94ce0f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "figure/Figure4D.py", "max_issues_repo_name": "YuanxiaoGao/Evolution_of_reproductive_strategies_in_incipient_multicellularity", "max_issues_repo_head_hexsha": "13eb51639fcee630a76e197b50ef321e3a94ce0f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "figure/Figure4D.py", "max_forks_repo_name": "YuanxiaoGao/Evolution_of_reproductive_strategies_in_incipient_multicellularity", "max_forks_repo_head_hexsha": "13eb51639fcee630a76e197b50ef321e3a94ce0f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.277173913, "max_line_length": 119, "alphanum_fraction": 0.5738203957, "include": true, "reason": "import numpy", "num_tokens": 2052, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166195971441, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.19696594141720597}} {"text": "# Main entrance of GAIL\nimport numpy as np\nimport torch\nimport torch.nn.functional as F\nimport gym\nimport safety_gym\nimport time\nimport os.path as osp\n\nfrom torch.distributions.categorical import Categorical\n\nfrom neural_nets import Discriminator, ActorCritic, ValorDiscriminator, count_vars\n\nfrom utils import BufferS, BufferT, BufferActor, VALORBuffer\nfrom utils import mpi_fork, proc_id, num_procs, EpochLogger,\\\n average_gradients, sync_all_params\n\n\n\ndef ppo_penalized(env_fn,\n actor_critic=ActorCritic,\n ac_kwargs=dict(),\n seed=0,\n episodes_per_epoch=40,\n epochs=500,\n gamma=0.99,\n lam=0.97,\n pi_lr=3e-4,\n vf_lr=1e-3,\n train_v_iters=80,\n max_ep_len=1000,\n logger_kwargs=dict(),\n save_freq=10):\n\n logger = EpochLogger(**logger_kwargs)\n logger.save_config(locals())\n\n seed += 10000 * proc_id()\n torch.manual_seed(seed)\n np.random.seed(seed)\n\n env = env_fn()\n obs_dim = env.observation_space.shape\n act_dim = env.action_space.shape\n\n ac_kwargs['action_space'] = env.action_space\n\n # Models\n ac = actor_critic(input_dim=obs_dim[0], **ac_kwargs)\n\n # Set up model saving\n logger.setup_pytorch_saver(ac)\n\n # Buffers\n local_episodes_per_epoch = int(episodes_per_epoch / num_procs())\n buf = BufferActor(obs_dim[0], act_dim[0], local_episodes_per_epoch, max_ep_len)\n\n # Count variables\n var_counts = tuple(count_vars(module) for module in [ac.policy, ac.value_f])\n print(\"POLICY GRADIENT\")\n logger.log('\\nNumber of parameters: \\t pi: %d, \\t v: %d\\n' % var_counts)\n\n # Optimizers\n train_pi = torch.optim.Adam(ac.policy.parameters(), lr=pi_lr)\n train_v = torch.optim.Adam(ac.value_f.parameters(), lr=vf_lr)\n\n # Parameters Sync\n sync_all_params(ac.parameters())\n\n def update(e):\n obs, act, adv, ret, lgp_old = [torch.Tensor(x) for x in buf.retrieve_all()]\n\n # Policy\n _, lgp, _ = ac.policy(obs, act)\n entropy = (-lgp).mean()\n\n # Policy loss # policy gradient term + entropy term\n pi_loss = -(lgp * adv).mean()\n\n # Train policy\n train_pi.zero_grad()\n pi_loss.backward()\n average_gradients(train_pi.param_groups)\n train_pi.step()\n\n # Value function\n v = ac.value_f(obs)\n v_l_old = F.mse_loss(v, ret)\n for _ in range(train_v_iters):\n v = ac.value_f(obs)\n v_loss = F.mse_loss(v, ret)\n\n # Value function train\n train_v.zero_grad()\n v_loss.backward()\n average_gradients(train_v.param_groups)\n train_v.step()\n\n # Log the changes\n _, lgp, _, v = ac(obs, act)\n entropy_new = (-lgp).mean()\n pi_loss_new = -(lgp * adv).mean()\n v_loss_new = F.mse_loss(v, ret)\n kl = (lgp_old - lgp).mean()\n logger.store(LossPi=pi_loss, LossV=v_l_old, DeltaLossPi=(pi_loss_new - pi_loss),\n DeltaLossV=(v_loss_new - v_l_old), Entropy=entropy, KL=kl)\n\n start_time = time.time()\n o, r, d, ep_ret, ep_len = env.reset(), 0, False, 0, 0\n total_t = 0\n\n for epoch in range(epochs):\n ac.eval()\n # Policy rollout\n for _ in range(local_episodes_per_epoch):\n for _ in range(max_ep_len):\n obs = torch.Tensor(o.reshape(1, -1))\n a, _, lopg_t, v_t = ac(obs)\n\n buf.store(o, a.detach().numpy(), r, v_t.item(), lopg_t.detach().numpy())\n logger.store(VVals=v_t)\n\n o, r, d, _ = env.step(a.detach().numpy()[0])\n ep_ret += r\n ep_len += 1\n total_t += 1\n\n terminal = d or (ep_len == max_ep_len)\n if terminal:\n buf.end_episode()\n logger.store(EpRet=ep_ret, EpLen=ep_len)\n o, r, d, ep_ret, ep_len = env.reset(), 0, False, 0, 0\n\n if (epoch % save_freq == 0) or (epoch == epochs - 1):\n # logger._torch_save(ac, fname=\"expert_torch_save.pt\")\n # logger._torch_save(ac, fname=\"model.pt\")\n logger.save_state({'env': env}, None, None)\n\n # Update\n ac.train()\n\n update(epoch)\n\n # Log\n logger.log_tabular('Epoch', epoch)\n logger.log_tabular('EpRet', with_min_and_max=True)\n logger.log_tabular('EpLen', average_only=True)\n logger.log_tabular('VVals', with_min_and_max=True)\n logger.log_tabular('TotalEnvInteracts', total_t)\n logger.log_tabular('LossPi', average_only=True)\n logger.log_tabular('DeltaLossPi', average_only=True)\n logger.log_tabular('LossV', average_only=True)\n logger.log_tabular('DeltaLossV', average_only=True)\n logger.log_tabular('Entropy', average_only=True)\n logger.log_tabular('KL', average_only=True)\n logger.log_tabular('Time', time.time() - start_time)\n logger.dump_tabular()\n\n\n\n\n\n\n\ndef gail_penalized(env_fn, actor_critic=ActorCritic, ac_kwargs=dict(),\n disc=Discriminator,\n dc_kwargs=dict(), seed=0,\n episodes_per_epoch=40,\n epochs=500,\n gamma=0.99, lam=0.97,\n pi_lr=3e-3, vf_lr=3e-3, dc_lr=5e-4, train_v_iters=80, train_dc_iters=80,\n max_ep_len=1000, logger_kwargs=dict(), save_freq=10):\n l_lam = 0 # balance two loss term\n\n print(\"starting now\")\n\n logger = EpochLogger(**logger_kwargs)\n logger.save_config(locals())\n\n seed += 10000 * proc_id()\n torch.manual_seed(seed)\n np.random.seed(seed)\n\n env = env_fn()\n obs_dim = env.observation_space.shape\n act_dim = env.action_space.shape\n\n ac_kwargs['action_space'] = env.action_space\n\n # Models\n ac = actor_critic(input_dim=obs_dim[0], **ac_kwargs)\n disc = disc(input_dim=obs_dim[0], **dc_kwargs)\n\n # Set up model saving\n logger.setup_pytorch_saver([ac, disc])\n\n # TODO: Load expert policy here\n expert = actor_critic(input_dim=obs_dim[0], **ac_kwargs)\n # expert_name = \"expert_torch_save.pt\"\n expert_name = \"model.pt\"\n # expert = torch.load(osp.join(logger_kwargs['output_dir'],'pyt_save' , expert_name))\n expert = torch.load('/home/tyna/Documents/openai/research-project/data/anonymous-expert/anonymous-expert_s0/pyt_save/model.pt')\n\n print('RUNNING GAIL')\n\n # Buffers\n local_episodes_per_epoch = int(episodes_per_epoch / num_procs())\n buff_s = BufferS(obs_dim[0], act_dim[0], local_episodes_per_epoch, max_ep_len)\n buff_t = BufferT(obs_dim[0], act_dim[0], local_episodes_per_epoch, max_ep_len)\n\n # Count variables\n var_counts = tuple(count_vars(module) for module in [ac.policy, ac.value_f, disc.policy])\n print(\"GAIL\")\n logger.log('\\nNumber of parameters: \\t pi: %d, \\t v: %d, \\t d: %d\\n' % var_counts)\n\n\n # Optimizers\n train_pi = torch.optim.Adam(ac.policy.parameters(), lr=pi_lr)\n train_v = torch.optim.Adam(ac.value_f.parameters(), lr=vf_lr)\n train_dc = torch.optim.Adam(disc.policy.parameters(), lr=dc_lr)\n\n # Parameters Sync\n sync_all_params(ac.parameters())\n sync_all_params(disc.parameters())\n\n def update(e):\n obs_s, act, adv, ret, lgp_old = [torch.Tensor(x) for x in buff_s.retrieve_all()]\n obs_t, _ = [torch.Tensor(x) for x in buff_t.retrieve_all()]\n\n # Policy\n _, lgp, _ = ac.policy(obs_s, act)\n entropy = (-lgp).mean()\n\n # Policy loss\n # policy gradient term + entropy term\n pi_loss = -(lgp * adv).mean() - l_lam * entropy\n\n # Train policy\n if e > 10:\n train_pi.zero_grad()\n pi_loss.backward()\n average_gradients(train_pi.param_groups)\n train_pi.step()\n\n # Value function\n v = ac.value_f(obs_s)\n v_l_old = F.mse_loss(v, ret)\n\n for _ in range(train_v_iters):\n v = ac.value_f(obs_s)\n v_loss = F.mse_loss(v, ret)\n\n # Value function train\n train_v.zero_grad()\n v_loss.backward()\n average_gradients(train_v.param_groups)\n train_v.step()\n\n # Discriminator\n gt1 = torch.ones(obs_s.size()[0], dtype=torch.int)\n gt2 = torch.zeros(obs_t.size()[0], dtype=torch.int)\n _, lgp_s, _ = disc(obs_s, gt=gt1)\n _, lgp_t, _ = disc(obs_t, gt=gt2)\n dc_loss_old = - lgp_s.mean() - lgp_t.mean()\n\n for _ in range(train_dc_iters):\n _, lgp_s, _ = disc(obs_s, gt=gt1)\n _, lgp_t, _ = disc(obs_t, gt=gt2)\n dc_loss = - lgp_s.mean() - lgp_t.mean()\n\n # Discriminator train\n train_dc.zero_grad()\n dc_loss.backward()\n average_gradients(train_dc.param_groups)\n train_dc.step()\n\n _, lgp_s, _ = disc(obs_s, gt=gt1)\n _, lgp_t, _ = disc(obs_t, gt=gt2)\n dc_loss_new = - lgp_s.mean() - lgp_t.mean()\n\n # Log the changes\n _, lgp, _, v = ac(obs, act)\n entropy_new = (-lgp).mean()\n pi_loss_new = -(lgp * adv).mean() - l_lam * entropy\n v_loss_new = F.mse_loss(v, ret)\n kl = (lgp_old - lgp).mean()\n logger.store(LossPi=pi_loss, LossV=v_l_old, LossDC=dc_loss_old, DeltaLossPi=(pi_loss_new - pi_loss),\n DeltaLossV=(v_loss_new - v_l_old), DeltaLossDC=(dc_loss_new - dc_loss_old),\n DeltaEnt=(entropy_new - entropy),\n Entropy=entropy, KL=kl)\n\n start_time = time.time()\n o, r, sdr, d, ep_ret, ep_sdr, ep_len = env.reset(), 0, 0, False, 0, 0, 0\n total_t = 0\n\n ep_len_t = 0\n for epoch in range(epochs):\n ac.eval()\n disc.eval()\n # We recognize the probability term of index [0] correspond to the teacher's policy\n\n # Student's policy rollout\n for _ in range(local_episodes_per_epoch):\n for _ in range(max_ep_len):\n obs = torch.Tensor(o.reshape(1, -1))\n a, _, lopg_t, v_t = ac(obs)\n\n buff_s.store(o, a.detach().numpy(), r, sdr, v_t.item(), lopg_t.detach().numpy())\n logger.store(VVals=v_t)\n\n o, r, d, _ = env.step(a.detach().numpy()[0])\n _, sdr, _ = disc(torch.Tensor(o.reshape(1, -1)), gt=torch.Tensor([0]))\n if sdr < -4: # Truncate rewards\n sdr = -4\n ep_ret += r\n ep_sdr += sdr\n ep_len += 1\n total_t += 1\n\n terminal = d or (ep_len == max_ep_len)\n if terminal:\n buff_s.end_episode()\n logger.store(EpRetS=ep_ret, EpLenS=ep_len, EpSdrS=ep_sdr)\n print(\"Student Episode Return: \\t\", ep_ret)\n o, r, sdr, d, ep_ret, ep_sdr, ep_len = env.reset(), 0, 0, False, 0, 0, 0\n\n # Teacher's policy rollout\n for _ in range(local_episodes_per_epoch):\n for _ in range(max_ep_len):\n obs = torch.Tensor(o.reshape(1, -1))\n a, _, _, _ = expert(obs)\n\n buff_t.store(o, a.detach().numpy(), r)\n\n o, r, d, _ = env.step(a.detach().numpy()[0])\n ep_ret += r\n ep_len += 1\n total_t += 1\n\n terminal = d or (ep_len == max_ep_len)\n if terminal:\n buff_t.end_episode()\n logger.store(EpRetT=ep_ret, EpLenT=ep_len)\n print(\"Teacher Episode Return: \\t\", ep_ret)\n o, r, d, ep_ret, ep_len = env.reset(), 0, False, 0, 0\n\n if (epoch % save_freq == 0) or (epoch == epochs - 1):\n logger.save_state({'env': env}, [ac, disc], None)\n\n # Update\n ac.train()\n disc.train()\n\n update(epoch)\n\n # Log\n logger.log_tabular('Epoch', epoch)\n logger.log_tabular('EpRetS', with_min_and_max=True)\n logger.log_tabular('EpSdrS', with_min_and_max=True)\n logger.log_tabular('EpLenS', average_only=True)\n logger.log_tabular('EpRetT', with_min_and_max=True)\n logger.log_tabular('EpLenT', average_only=True)\n logger.log_tabular('VVals', with_min_and_max=True)\n logger.log_tabular('TotalEnvInteracts', total_t)\n logger.log_tabular('LossPi', average_only=True)\n logger.log_tabular('DeltaLossPi', average_only=True)\n logger.log_tabular('LossV', average_only=True)\n logger.log_tabular('DeltaLossV', average_only=True)\n logger.log_tabular('LossDC', average_only=True)\n logger.log_tabular('DeltaLossDC', average_only=True)\n logger.log_tabular('Entropy', average_only=True)\n logger.log_tabular('DeltaEnt', average_only=True)\n logger.log_tabular('KL', average_only=True)\n logger.log_tabular('Time', time.time() - start_time)\n logger.dump_tabular()\n\n\ndef valor_penalized(env_fn, actor_critic=ActorCritic, ac_kwargs=dict(),\n disc=Discriminator, dc_kwargs=dict(), seed=0,\n episodes_per_epoch=40,\n epochs=50, gamma=0.99, pi_lr=3e-4, vf_lr=1e-3, dc_lr=5e-4,\n train_v_iters=80, train_dc_iters=10,\n train_dc_interv=10,\n lam=0.97, max_ep_len=1000, logger_kwargs=dict(), con_dim=5, save_freq=10, k=1):\n\n logger = EpochLogger(**logger_kwargs)\n logger.save_config(locals())\n\n seed += 10000 * proc_id()\n torch.manual_seed(seed)\n np.random.seed(seed)\n\n env = env_fn()\n obs_dim = env.observation_space.shape\n act_dim = env.action_space.shape\n\n ac_kwargs['action_space'] = env.action_space\n\n # Model\n ac = actor_critic(input_dim=obs_dim[0] + con_dim, **ac_kwargs)\n disc = disc(input_dim=obs_dim[0], context_dim=con_dim, **dc_kwargs)\n\n # Set up model saving\n logger.setup_pytorch_saver([ac, disc])\n\n # Buffer\n local_episodes_per_epoch = int(episodes_per_epoch / num_procs())\n buffer = VALORBuffer(con_dim, obs_dim[0], act_dim[0], local_episodes_per_epoch, max_ep_len, train_dc_interv)\n\n # Count variables\n var_counts = tuple(count_vars(module) for module in\n [ac.policy, ac.value_f, disc.policy])\n logger.log('\\nNumber of parameters: \\t pi: %d, \\t v: %d, \\t d: %d\\n' % var_counts)\n\n # Optimizers\n train_pi = torch.optim.Adam(ac.policy.parameters(), lr=pi_lr)\n train_v = torch.optim.Adam(ac.value_f.parameters(), lr=vf_lr)\n train_dc = torch.optim.Adam(disc.policy.parameters(), lr=dc_lr)\n\n # Parameters Sync\n sync_all_params(ac.parameters())\n sync_all_params(disc.parameters())\n\n def update(e):\n obs, act, adv, pos, ret, logp_old = [torch.Tensor(x) for x in buffer.retrieve_all()]\n\n # Policy\n _, logp, _ = ac.policy(obs, act)\n entropy = (-logp).mean()\n\n # Policy loss\n pi_loss = -(logp * (k * adv + pos)).mean()\n\n # Train policy\n train_pi.zero_grad()\n pi_loss.backward()\n average_gradients(train_pi.param_groups)\n train_pi.step()\n\n # Value function\n v = ac.value_f(obs)\n v_l_old = F.mse_loss(v, ret)\n for _ in range(train_v_iters):\n v = ac.value_f(obs)\n v_loss = F.mse_loss(v, ret)\n\n # Value function train\n train_v.zero_grad()\n v_loss.backward()\n average_gradients(train_v.param_groups)\n train_v.step()\n\n # Discriminator\n if (e + 1) % train_dc_interv == 0:\n print('Discriminator Update!')\n con, s_diff = [torch.Tensor(x) for x in buffer.retrieve_dc_buff()]\n _, logp_dc, _ = disc(s_diff, con)\n d_l_old = -logp_dc.mean()\n\n # Discriminator train\n for _ in range(train_dc_iters):\n _, logp_dc, _ = disc(s_diff, con)\n d_loss = -logp_dc.mean()\n train_dc.zero_grad()\n d_loss.backward()\n average_gradients(train_dc.param_groups)\n train_dc.step()\n\n _, logp_dc, _ = disc(s_diff, con)\n dc_l_new = -logp_dc.mean()\n else:\n d_l_old = 0\n dc_l_new = 0\n\n # Log the changes\n _, logp, _, v = ac(obs, act)\n pi_l_new = -(logp * (k * adv + pos)).mean()\n v_l_new = F.mse_loss(v, ret)\n kl = (logp_old - logp).mean()\n logger.store(LossPi=pi_loss, LossV=v_l_old, KL=kl, Entropy=entropy, DeltaLossPi=(pi_l_new - pi_loss),\n DeltaLossV=(v_l_new - v_l_old), LossDC=d_l_old, DeltaLossDC=(dc_l_new - d_l_old))\n # logger.store(Adv=adv.reshape(-1).numpy().tolist(), Pos=pos.reshape(-1).numpy().tolist())\n\n start_time = time.time()\n o, r, d, ep_ret, ep_len = env.reset(), 0, False, 0, 0\n context_dist = Categorical(logits=torch.Tensor(np.ones(con_dim)))\n total_t = 0\n\n for epoch in range(epochs):\n ac.eval()\n disc.eval()\n for _ in range(local_episodes_per_epoch):\n c = context_dist.sample()\n c_onehot = F.one_hot(c, con_dim).squeeze().float()\n for _ in range(max_ep_len):\n concat_obs = torch.cat([torch.Tensor(o.reshape(1, -1)), c_onehot.reshape(1, -1)], 1)\n a, _, logp_t, v_t = ac(concat_obs)\n\n buffer.store(c, concat_obs.squeeze().detach().numpy(), a.detach().numpy(), r, v_t.item(),\n logp_t.detach().numpy())\n logger.store(VVals=v_t)\n\n o, r, d, _ = env.step(a.detach().numpy()[0])\n ep_ret += r\n ep_len += 1\n total_t += 1\n\n terminal = d or (ep_len == max_ep_len)\n if terminal:\n dc_diff = torch.Tensor(buffer.calc_diff()).unsqueeze(0)\n con = torch.Tensor([float(c)]).unsqueeze(0)\n _, _, log_p = disc(dc_diff, con)\n buffer.end_episode(log_p.detach().numpy())\n logger.store(EpRet=ep_ret, EpLen=ep_len)\n o, r, d, ep_ret, ep_len = env.reset(), 0, False, 0, 0\n\n if (epoch % save_freq == 0) or (epoch == epochs - 1):\n logger.save_state({'env': env}, [ac, disc], None)\n\n # Update\n ac.train()\n disc.train()\n\n update(epoch)\n\n # Log\n logger.log_tabular('Epoch', epoch)\n logger.log_tabular('EpRet', with_min_and_max=True)\n logger.log_tabular('EpLen', average_only=True)\n logger.log_tabular('VVals', with_min_and_max=True)\n logger.log_tabular('TotalEnvInteracts', total_t)\n logger.log_tabular('LossPi', average_only=True)\n logger.log_tabular('DeltaLossPi', average_only=True)\n logger.log_tabular('LossV', average_only=True)\n logger.log_tabular('DeltaLossV', average_only=True)\n logger.log_tabular('LossDC', average_only=True)\n logger.log_tabular('DeltaLossDC', average_only=True)\n logger.log_tabular('Entropy', average_only=True)\n logger.log_tabular('KL', average_only=True)\n logger.log_tabular('Time', time.time() - start_time)\n logger.dump_tabular()\n\nif __name__ == '__main__':\n import argparse\n\n parser = argparse.ArgumentParser()\n parser.add_argument('--env', type=str, default='Safexp-PointGoal1-v0')\n parser.add_argument('--hid', type=int, default=64)\n parser.add_argument('--l', type=int, default=2)\n parser.add_argument('--gamma', type=float, default=0.99)\n parser.add_argument('--lam', type=float, default=0.97)\n parser.add_argument('--seed', '-s', type=int, default=0)\n parser.add_argument('--cpu', type=int, default=1)\n parser.add_argument('--episodes-per-epoch', type=int, default=5)\n # parser.add_argument('--episodes-per-epoch', type=int, default=40)\n parser.add_argument('--epochs', type=int, default=1000)\n parser.add_argument('--exp_name', type=str, default='valor-anonymous-expert')\n parser.add_argument('--con', type=int, default=5)\n args = parser.parse_args()\n\n mpi_fork(args.cpu)\n\n from utils import setup_logger_kwargs\n\n logger_kwargs = setup_logger_kwargs(args.exp_name, args.seed)\n\n # ppo_penalized(lambda: gym.make(args.env), actor_critic=ActorCritic, ac_kwargs=dict(hidden_dims=[args.hid]*args.l),\n # gamma=args.gamma, lam=args.lam, seed=args.seed, episodes_per_epoch=args.episodes_per_epoch,\n # epochs=args.epochs, logger_kwargs=logger_kwargs)\n\n # gail_penalized(lambda: gym.make(args.env), actor_critic=ActorCritic, ac_kwargs=dict(hidden_dims=[args.hid] * args.l),\n # disc=Discriminator, dc_kwargs=dict(hidden_dims=[args.hid] * args.l), gamma=args.gamma, lam=args.lam,\n # seed=args.seed, episodes_per_epoch=args.episodes_per_epoch, epochs=args.epochs, logger_kwargs=logger_kwargs)\n\n\n valor_penalized(lambda: gym.make(args.env), actor_critic=ActorCritic, ac_kwargs=dict(hidden_dims=[args.hid] * args.l),\n disc=ValorDiscriminator, dc_kwargs=dict(hidden_dims=args.hid),\n gamma=args.gamma, seed=args.seed, episodes_per_epoch=args.episodes_per_epoch, epochs=args.epochs,\n logger_kwargs=logger_kwargs, con_dim=args.con)\n\n", "meta": {"hexsha": "be2035f9c5b84e1e72fdcebe05bdfe73db117673", "size": 21044, "ext": "py", "lang": "Python", "max_stars_repo_path": "algos/training_regimes_penalized.py", "max_stars_repo_name": "feloundou/safe-experts", "max_stars_repo_head_hexsha": "9592bd48ce7eed721a36cb688dd10dc7f527a13b", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "algos/training_regimes_penalized.py", "max_issues_repo_name": "feloundou/safe-experts", "max_issues_repo_head_hexsha": "9592bd48ce7eed721a36cb688dd10dc7f527a13b", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "algos/training_regimes_penalized.py", "max_forks_repo_name": "feloundou/safe-experts", "max_forks_repo_head_hexsha": "9592bd48ce7eed721a36cb688dd10dc7f527a13b", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.2203098107, "max_line_length": 131, "alphanum_fraction": 0.5968922258, "include": true, "reason": "import numpy", "num_tokens": 5444, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.1969659356847176}} {"text": "# ===========================================================================\n# This module is adpated from: https://github.com/fchollet/keras\n# Revision: @bec2701\n# Original work Copyright (c) 2014-2015 keras contributors\n# Some idea are also borrowed from Lasagne library\n# Original work Copyright (c) 2014-2015 Lasagne contributors\n# Some work are adapted from tensorfuse library\n# Original work Copyright (c) [dementrock](https://github.com/dementrock)\n# Modified work Copyright 2016-2017 TrungNT\n# ===========================================================================\n\nimport tensorflow as tf\nimport numpy as np\nimport os\nfrom collections import OrderedDict\n\nfrom .. import config\nfrom .numpy_backend import get_random_magic_seed\n\nfrom six.moves import range, zip\n\n_FLOATX = config.floatX()\n_EPSILON = config.epsilon()\n\n# ===========================================================================\n# INTERNAL UTILS\n# ===========================================================================\n_SESSION = None\n\n\ndef get_session():\n global _SESSION\n if _SESSION is None:\n if not os.environ.get('OMP_NUM_THREADS'):\n _SESSION = tf.Session('')\n else:\n nb_thread = int(os.environ.get('OMP_NUM_THREADS'))\n _SESSION = tf.Session(config=tf.ConfigProto(intra_op_parallelism_threads=nb_thread))\n return _SESSION\n\n\ndef _set_session(session):\n global _SESSION\n _SESSION = session\n\n# From Theano\n\n\ndef _format_as(use_list, use_tuple, outputs):\n \"\"\"\n Formats the outputs according to the flags `use_list` and `use_tuple`.\n If `use_list` is True, `outputs` is returned as a list (if `outputs`\n is not a list or a tuple then it is converted in a one element list).\n If `use_tuple` is True, `outputs` is returned as a tuple (if `outputs`\n is not a list or a tuple then it is converted into a one element tuple).\n Otherwise (if both flags are false), `outputs` is returned.\n \"\"\"\n assert not (use_list and use_tuple), \\\n \"Both flags cannot be simultaneously True\"\n if (use_list or use_tuple) and not isinstance(outputs, (list, tuple)):\n if use_list:\n return [outputs]\n else:\n return (outputs,)\n elif not (use_list or use_tuple) and isinstance(outputs, (list, tuple)):\n assert len(outputs) == 1, \\\n \"Wrong arguments. Expected a one element list\"\n return outputs[0]\n elif use_list or use_tuple:\n if use_list:\n return list(outputs)\n else:\n return tuple(outputs)\n else:\n return outputs\n\n\ndef _wrap_into_list(x):\n \"\"\"\n Wrap the input into a list if it is not already a list.\n \"\"\"\n if x is None:\n return []\n elif not isinstance(x, (list, tuple)):\n return [x]\n else:\n return list(x)\n# ===========================================================================\n# VARIABLE MANIPULATION\n# ===========================================================================\n\n\ndef variable(value, dtype=_FLOATX, name=None, broadcastable=None):\n v = tf.Variable(np.asarray(value, dtype=dtype), name=name)\n get_session().run(v.initializer)\n return v\n\n\ndef zeros_var(shape, dtype=_FLOATX, name=None):\n return variable(np.zeros(shape), dtype, name)\n\n\ndef ones_var(shape, dtype=_FLOATX, name=None):\n return variable(np.ones(shape), dtype, name)\n\n\ndef is_variable(v):\n return isinstance(v, tf.python.Variable)\n\n_PLACEHOLDER_ID = 0\n_PLACEHOLDER_SHAPE = {}\n\n\ndef placeholder(shape=None, ndim=None, dtype=_FLOATX, name=None):\n # name must match: [A-Za-z0-9.][A-Za-z0-9_.\\-/]*\n if not shape:\n if ndim:\n shape = [None for _ in range(ndim)]\n\n # ====== Modify add name prefix ====== #\n global _PLACEHOLDER_ID\n name_prefix = 'ID.%02d.' % _PLACEHOLDER_ID\n _PLACEHOLDER_ID += 1\n if name is None:\n name = ''\n name = name_prefix + name\n placeholder = tf.placeholder(dtype, shape=shape, name=name)\n _PLACEHOLDER_SHAPE[placeholder.name] = shape\n return placeholder\n\n\ndef is_expression(v):\n return isinstance(v, tf.python.Tensor)\n\n\ndef is_placeholder(v):\n if is_expression(v) and v.name in _PLACEHOLDER_SHAPE:\n return True\n return False\n\n\ndef eval(x):\n '''Run a graph.\n '''\n if isinstance(x, tf.TensorShape):\n return x.as_list()\n return x.eval(session=get_session())\n\n# ===========================================================================\n# Shape operators\n# ===========================================================================\n\n\ndef shape(x):\n return x.get_shape()\n\n\ndef int_shape(x):\n shape = x.get_shape()\n return tuple([i.__int__() for i in shape])\n\n\ndef ndim(x):\n return len(x.get_shape())\n\n\ndef broadcastable(x):\n return None\n\n\ndef addbroadcast(x, *axes):\n return x\n\n# ===========================================================================\n# Predefined data\n# ===========================================================================\n\n\ndef zeros(shape, dtype=_FLOATX, name=None):\n return tf.zeros(shape, dtype=dtype, name=name)\n\n\ndef ones(shape, dtype=_FLOATX, name=None):\n return tf.ones(shape, dtype=dtype, name=name)\n\n\ndef ones_like(x, name=None):\n return tf.ones_like(x, name=name)\n\n\ndef zeros_like(x, name=None):\n return tf.zeros_like(x, name=name)\n\n\ndef count_params(x):\n '''Return number of scalars in a tensor.\n '''\n shape = x.get_shape()\n return np.prod([shape[i]._value for i in range(len(shape))])\n\n\ndef cast(x, dtype):\n if 'tensorflow.' in str(x.__class__):\n return tf.cast(x, dtype)\n return np.cast[dtype](x)\n\n\ndef castX(x):\n return cast(x, _FLOATX)\n\n# ===========================================================================\n# LINEAR ALGEBRA\n# ===========================================================================\n\n\ndef dot(x, y):\n return tf.matmul(x, y)\n\n\ndef transpose(x):\n return tf.transpose(x)\n\n\ndef gather(reference, indices):\n '''\n # Arguments\n reference: a tensor.\n indices: an int tensor of indices.\n\n # Returns\n a tensor of same type as `reference`.\n '''\n return tf.gather(reference, indices)\n\n\n# ===========================================================================\n# ELEMENT-WISE OPERATIONS\n# ===========================================================================\ndef normalize_axis(axis, ndim):\n if type(axis) is tuple:\n axis = list(axis)\n if type(axis) is list:\n for i, a in enumerate(axis):\n if a is not None and a < 0:\n axis[i] = a % ndim\n else:\n if axis is not None and axis < 0:\n axis = axis % ndim\n return axis\n\n\ndef max(x, axis=None, keepdims=False):\n axis = normalize_axis(axis, ndim(x))\n return tf.reduce_max(x, reduction_indices=axis, keep_dims=keepdims)\n\n\ndef min(x, axis=None, keepdims=False):\n axis = normalize_axis(axis, ndim(x))\n return tf.reduce_min(x, reduction_indices=axis, keep_dims=keepdims)\n\n\ndef sum(x, axis=None, keepdims=False):\n '''Sum of the values in a tensor, alongside the specified axis.\n '''\n axis = normalize_axis(axis, ndim(x))\n return tf.reduce_sum(x, reduction_indices=axis, keep_dims=keepdims)\n\n\ndef prod(x, axis=None, keepdims=False):\n '''Multiply the values in a tensor, alongside the specified axis.\n '''\n axis = normalize_axis(axis, ndim(x))\n return tf.reduce_prod(x, reduction_indices=axis, keep_dims=keepdims)\n\n\ndef var(x, axis=None, keepdims=False):\n axis = normalize_axis(axis, ndim(x))\n if x.dtype.base_dtype == tf.bool:\n x = tf.cast(x, _FLOATX)\n m = tf.reduce_mean(x, reduction_indices=axis, keep_dims=True)\n devs_squared = tf.square(x - m)\n return tf.reduce_mean(devs_squared,\n reduction_indices=axis,\n keep_dims=keepdims)\n\n\ndef std(x, axis=None, keepdims=False):\n axis = normalize_axis(axis, ndim(x))\n if x.dtype.base_dtype == tf.bool:\n x = tf.cast(x, _FLOATX)\n m = tf.reduce_mean(x, reduction_indices=axis, keep_dims=True)\n devs_squared = tf.square(x - m)\n return tf.sqrt(tf.reduce_mean(devs_squared,\n reduction_indices=axis,\n keep_dims=keepdims))\n\n\ndef mean(x, axis=None, keepdims=False):\n axis = normalize_axis(axis, ndim(x))\n if x.dtype.base_dtype == tf.bool:\n x = tf.cast(x, _FLOATX)\n return tf.reduce_mean(x, reduction_indices=axis, keep_dims=keepdims)\n\n\ndef any(x, axis=None, keepdims=False):\n '''Bitwise reduction (logical OR).\n\n Return array of uint8 (0s and 1s).\n '''\n axis = normalize_axis(axis, ndim(x))\n x = tf.cast(x, tf.bool)\n x = tf.reduce_any(x, reduction_indices=axis, keep_dims=keepdims)\n return tf.cast(x, tf.uint8)\n\n\ndef argmax(x, axis=-1):\n if axis < 0:\n axis = axis % len(x.get_shape())\n return tf.argmax(x, axis)\n\n\ndef argsort(x, axis=-1):\n raise NotImplementedError\n\n\ndef argtop_k(x, k=1):\n ''' See also: tf.nn.in_top_k '''\n return tf.nn.top_k(x, k)[1]\n\n\ndef argmin(x, axis=-1):\n if axis < 0:\n axis = axis % len(x.get_shape())\n return tf.argmin(x, axis)\n\n\ndef square(x):\n return tf.square(x)\n\n\ndef abs(x):\n return tf.abs(x)\n\n\ndef sqrt(x):\n x = tf.clip_by_value(x, tf.cast(0., dtype=_FLOATX),\n tf.cast(np.inf, dtype=_FLOATX))\n return tf.sqrt(x)\n\n\ndef exp(x):\n return tf.exp(x)\n\n\ndef log(x):\n return tf.log(x)\n\n\ndef round(x):\n return tf.round(x)\n\n\ndef pow(x, a):\n return tf.pow(x, a)\n\n\ndef clip(x, min_value, max_value):\n if max_value < min_value:\n max_value = min_value\n return tf.clip_by_value(x, tf.cast(min_value, dtype=_FLOATX),\n tf.cast(max_value, dtype=_FLOATX))\n\n\ndef maximum(x, y):\n return tf.maximum(x, y)\n\n\ndef minimum(x, y):\n return tf.minimum(x, y)\n\n\n# ===========================================================================\n# SHAPE OPERATIONS\n# ===========================================================================\ndef reverse(x, axis=-1):\n '''Apply [::-1] to appropriate axis'''\n ndim = len(x.get_shape())\n dims = [False] * ndim\n if axis < 0:\n axis = axis % ndim\n dims[axis] = True\n return tf.reverse(x, dims)\n\n\ndef concatenate(tensors, axis=-1):\n if axis < 0:\n axis = axis % len(tensors[0].get_shape())\n return tf.concat(axis, tensors)\n\n\ndef reshape(x, shape):\n return tf.reshape(x, shape)\n\n\ndef dimshuffle(x, pattern):\n '''\n # Arguments\n pattern: should be a tuple or list of\n dimension indices, e.g. [0, 2, 1].\n '''\n if 'x' in pattern:\n x = tf.transpose(x, perm=[i for i in pattern if i != 'x'])\n for i, p in enumerate(pattern):\n if p == 'x':\n x = tf.expand_dims(x, i)\n return x\n\n\ndef resize_images(X, height_factor, width_factor, dim_ordering):\n '''Resize the images contained in a 4D tensor of shape\n - [batch, channels, height, width] (for 'th' dim_ordering)\n - [batch, height, width, channels] (for 'tf' dim_ordering)\n by a factor of (height_factor, width_factor). Both factors should be\n positive integers.\n '''\n if dim_ordering == 'th':\n new_height = shape(X)[2].value * height_factor\n new_width = shape(X)[3].value * width_factor\n X = dimshuffle(X, [0, 2, 3, 1])\n X = tf.image.resize_nearest_neighbor(X, (new_height, new_width))\n return dimshuffle(X, [0, 3, 1, 2])\n elif dim_ordering == 'tf':\n new_height = shape(X)[1].value * height_factor\n new_width = shape(X)[2].value * width_factor\n return tf.image.resize_nearest_neighbor(X, (new_height, new_width))\n else:\n raise Exception('Invalid dim_ordering: ' + dim_ordering)\n\n\ndef repeat_elements(x, rep, axis):\n '''Repeats the elements of a tensor along an axis, like np.repeat\n\n If x has shape (s1, s2, s3) and axis=1, the output\n will have shape (s1, s2 * rep, s3)\n '''\n x_shape = x.get_shape().as_list()\n # slices along the repeat axis\n splits = tf.split(axis, x_shape[axis], x)\n # repeat each slice the given number of reps\n x_rep = [s for s in splits for i in range(rep)]\n return tf.concat(axis, x_rep)\n\n\ndef repeat(x, n):\n '''Repeat a 2D tensor:\n\n if x has shape (samples, dim) and n=2,\n the output will have shape (samples, 2, dim)\n '''\n assert ndim(x) == 2\n tensors = [x] * n\n stacked = tf.pack(tensors)\n return tf.transpose(stacked, (1, 0, 2))\n\n\ndef tile(x, n):\n return tf.tile(x, n)\n\n\ndef flatten(x, outdim=2):\n '''Turn a n-D tensor into a m-D tensor (m < n) where\n the first dimension is conserved.\n '''\n if outdim == 1:\n pattern = [-1]\n else:\n pattern = [-1, np.prod(x.get_shape()[(outdim - 1):].as_list())]\n return tf.reshape(x, pattern)\n\n\ndef expand_dims(x, dim=-1):\n '''Add a 1-sized dimension at index \"dim\".\n '''\n return tf.expand_dims(x, dim)\n\n\ndef squeeze(x, axis):\n '''Remove a 1-dimension from the tensor at index \"axis\".\n '''\n return tf.squeeze(x, [axis])\n\n\ndef temporal_padding(x, padding=1):\n '''Pad the middle dimension of a 3D tensor\n with \"padding\" zeros left and right.\n '''\n pattern = [[0, 0], [padding, padding], [0, 0]]\n return tf.pad(x, pattern)\n\n\ndef spatial_2d_padding(x, padding=(1, 1), dim_ordering='th'):\n '''Pad the 2nd and 3rd dimensions of a 4D tensor\n with \"padding[0]\" and \"padding[1]\" (resp.) zeros left and right.\n '''\n if dim_ordering == 'th':\n pattern = [[0, 0], [0, 0],\n [padding[0], padding[0]], [padding[1], padding[1]]]\n else:\n pattern = [[0, 0],\n [padding[0], padding[0]], [padding[1], padding[1]],\n [0, 0]]\n return tf.pad(x, pattern)\n\n\ndef stack(*x):\n return tf.pack(x)\n\n# ===========================================================================\n# VALUE MANIPULATION\n# ===========================================================================\n\n\ndef get_value(x, borrow=False):\n '''Technically the same as eval() for TF.\n '''\n return x.eval(session=get_session())\n\n\ndef set_value(x, value):\n tf.assign(x, np.asarray(value)).op.run(session=get_session())\n\n\ndef set_subtensor(x, y):\n raise NotImplementedError\n\n\n# ===========================================================================\n# GRAPH MANIPULATION\n# ===========================================================================\n_GLOBALS_UPDATES = OrderedDict()\n\n\ndef add_global_updates(variable, value):\n '''trick to update tensorflow variables anywhere\n This dictionary will be reseted after each time you create a function\n '''\n _GLOBALS_UPDATES[variable] = value\n\n\ndef reset_global_updates():\n global _GLOBALS_UPDATES\n _GLOBALS_UPDATES = OrderedDict()\n\n\nclass Function(object):\n\n def __init__(self, inputs, outputs, updates=[]):\n assert type(inputs) in {list, tuple}\n if type(outputs) not in {list, tuple}:\n outputs = [outputs]\n self._return_list = False\n else:\n self._return_list = True\n if isinstance(updates, OrderedDict):\n updates = updates.items()\n assert type(updates) in {list, tuple}\n self.inputs = list(inputs)\n self.outputs = list(outputs)\n with tf.control_dependencies(self.outputs):\n self.updates = [tf.assign(p, new_p) for (p, new_p) in updates]\n # ====== add global_update ====== #\n self.global_update = [tf.assign(p, new_p) for (p, new_p) in _GLOBALS_UPDATES.items()]\n reset_global_updates()\n\n def __call__(self, *inputs):\n assert type(inputs) in {list, tuple}\n names = [v.name for v in self.inputs]\n feed_dict = dict(zip(names, inputs))\n session = get_session()\n # ====== add global updates ====== #\n updated = session.run(self.outputs + self.updates + self.global_update,\n feed_dict=feed_dict)\n if self._return_list:\n return updated[:len(self.outputs)]\n return updated[0]\n\n\ndef function(inputs, outputs, updates=[]):\n return Function(inputs, outputs, updates=updates)\n\n\ndef gradients(loss, variables, consider_constant=None, known_grads=None):\n \"\"\"\n Return symbolic gradients for one or more variables with respect to some\n cost.\n\n For more information about how automatic differentiation works in Theano,\n see :mod:`gradient`. For information on how to implement the gradient of\n a certain Op, see :func:`grad`.\n\n Parameters\n ----------\n cost : scalar (0-dimensional) tensor variable or None\n Value with respect to which we are differentiating. May be\n `None` if known_grads is provided.\n wrt : variable or list of variables\n term[s] for which we want gradients\n consider_constant : list of expressions(variables)\n expressions not to backpropagate through\n known_grads : dict, optional\n A dictionary mapping variables to their gradients. This is\n useful in the case where you know the gradient on some\n variables but do not know the original cost.\n Returns\n -------\n variable or list/tuple of variables (matches `wrt`)\n symbolic expression of gradient of `cost` with respect to each\n of the `wrt` terms. If an element of `wrt` is not\n differentiable with respect to the output, then a zero\n variable is returned.\n\n \"\"\"\n if consider_constant is not None:\n for i in consider_constant:\n tf.stop_gradient(i)\n raise NotImplementedError\n grad = tf.gradients(loss, variables)\n if known_grads is not None:\n grad = [known_grads[i] if i in known_grads else j\n for i, j in zip(variables, grad)]\n return grad\n\n\ndef grad_clip(x, clip):\n '''\n This clip the gradient of expression, used on forward pass but clip the\n gradient on backward pass\n\n This is an elemwise operation.\n\n Parameters\n ----------\n x: expression\n the variable we want its gradient inputs clipped\n lower_bound: float\n The lower bound of the gradient value\n upper_bound: float\n The upper bound of the gradient value.\n\n Example\n -------\n >>> x = theano.tensor.scalar()\n >>>\n >>> z = theano.tensor.grad(grad_clip(x, -1, 1)**2, x)\n >>> z2 = theano.tensor.grad(x**2, x)\n >>>\n >>> f = theano.function([x], outputs = [z, z2])\n >>>\n >>> print(f(2.0)) # output (1.0, 4.0)\n\n Note\n ----\n We register an opt in tensor/opt.py that remove the GradClip.\n So it have 0 cost in the forward and only do work in the grad.\n\n '''\n # TODO: no implementation for grad_clipping on tensorflow on forward pass\n return x\n\n\ndef jacobian(expression, wrt):\n # copying theano's implementation, which is based on scan\n #from theano.tensor import arange\n # Check inputs have the right format\n assert is_variable(expression), \\\n \"tensor.jacobian expects a Variable as `expression`\"\n assert expression.ndim < 2, \\\n (\"tensor.jacobian expects a 1 dimensional variable as \"\n \"`expression`. If not use flatten to make it a vector\")\n assert not is_variable(expression.shape[0]), \\\n \"shape of the expression must be known\"\n\n using_list = isinstance(wrt, list)\n using_tuple = isinstance(wrt, tuple)\n\n if isinstance(wrt, (list, tuple)):\n wrt = list(wrt)\n else:\n wrt = [wrt]\n\n if expression.ndim == 0:\n # expression is just a scalar, use grad\n return _format_as(using_list, using_tuple, gradients(expression, wrt))\n\n def inner_function(*args):\n idx = args[0]\n expr = args[1]\n rvals = []\n for inp in args[2:]:\n try:\n rval = gradients(expr[idx], inp)\n except Exception as e:\n import ipdb; ipdb.set_trace()\n if rval is None:\n import ipdb; ipdb.set_trace()\n rvals.append(rval)\n return rvals\n # Computing the gradients does not affect the random seeds on any random\n # generator used n expression (because during computing gradients we are\n # just backtracking over old values. (rp Jan 2012 - if anyone has a\n # counter example please show me)\n jacobs, updates = scan(inner_function,\n sequences=[range(expression.shape[0])],\n non_sequences=[expression] + wrt,\n n_steps=expression.shape[0])\n assert not updates\n return _format_as(using_list, using_tuple, jacobs)\n\n\ndef hessian(expression, wrt):\n raise NotImplementedError\n\n# ===========================================================================\n# CONTROL FLOW\n# ===========================================================================\n\n\ndef scan(step_fn, sequences=None, outputs_info=None, non_sequences=None,\n n_steps=None, truncate_gradient=-1, go_backwards=False):\n from operator import itemgetter\n # n_steps must be provided under cgt or tensorflow\n if n_steps is None:\n raise ValueError(\n 'n_steps must be provided for scan to work under TensorFlow')\n sequences = _wrap_into_list(sequences)\n non_sequences = _wrap_into_list(non_sequences)\n if outputs_info is not None:\n outputs_info = _wrap_into_list(outputs_info)\n if go_backwards and n_steps < 0:\n go_backwards = False\n n_steps = -n_steps\n if go_backwards or n_steps < 0:\n go_backwards = True\n n_steps = abs(n_steps)\n step_outputs = []\n cur_output = outputs_info\n loop_range = range(n_steps - 1, -1, -1) if go_backwards else range(n_steps)\n for i in loop_range:\n # Only pass output if needed\n if outputs_info is not None:\n cur_output = step_fn(*(map(itemgetter(i), sequences) + cur_output + non_sequences))\n else:\n cur_output = step_fn(*(map(itemgetter(i), sequences) + non_sequences))\n step_outputs.append(cur_output)\n outputs = []\n try:\n if len(step_outputs) > 0:\n if outputs_info is None:\n for i in range(len(step_outputs[0])):\n outputs.append(tf.pack(map(itemgetter(i), step_outputs)))\n #outputs = step_outputs\n else:\n for i in range(len(outputs_info)):\n outputs.append(tf.pack(map(itemgetter(i), step_outputs)))\n else:\n import ipdb; ipdb.set_trace()\n except Exception as e:\n raise e\n # This is quite ugly, but unfortunately it's what theano does\n if len(outputs) > 1:\n # update is not supported yet\n return outputs, None\n elif len(outputs) == 1:\n return outputs[0], None\n else:\n return None, None\n\n\ndef loop(step_fn, n_steps, sequences=None, outputs_info=None, non_sequences=None,\n go_backwards=False):\n \"\"\"\n Helper function to unroll for loops. Can be used to unroll theano.scan.\n The parameter names are identical to theano.scan, please refer to here\n for more information.\n\n Note that this function does not support the truncate_gradient\n setting from theano.scan.\n\n Parameters\n ----------\n step_fn : function\n Function that defines calculations at each step.\n\n sequences : TensorVariable or list of TensorVariables\n List of TensorVariable with sequence data. The function iterates\n over the first dimension of each TensorVariable.\n\n outputs_info : list of TensorVariables\n List of tensors specifying the initial values for each recurrent\n value. Specify output_info to None for non-arguments to\n the step_function\n\n non_sequences: list of TensorVariables\n List of theano.shared variables that are used in the step function.\n\n n_steps: int\n Number of steps to unroll.\n\n go_backwards: bool\n If true the recursion starts at sequences[-1] and iterates\n backwards.\n\n Returns\n -------\n List of TensorVariables. Each element in the list gives the recurrent\n values at each time step.\n\n \"\"\"\n if not isinstance(sequences, (list, tuple)):\n sequences = [] if sequences is None else [sequences]\n\n # When backwards reverse the recursion direction\n counter = range(n_steps)\n if go_backwards:\n counter = counter[::-1]\n\n # ====== check if outputs_info is None ====== #\n output = []\n if outputs_info is not None:\n prev_vals = outputs_info\n else:\n prev_vals = []\n output_idx = [i for i in range(len(prev_vals)) if prev_vals[i] is not None]\n # ====== check if non_sequences is None ====== #\n if non_sequences is None:\n non_sequences = []\n # ====== Main loop ====== #\n for i in counter:\n step_input = [s[i] for s in sequences] + \\\n [prev_vals[idx] for idx in output_idx] + \\\n non_sequences\n out_ = step_fn(*step_input)\n # The returned values from step can be either a TensorVariable,\n # a list, or a tuple. Below, we force it to always be a list.\n if isinstance(out_, tf.python.Tensor):\n out_ = [out_]\n if isinstance(out_, tuple):\n out_ = list(out_)\n output.append(out_)\n prev_vals = output[-1]\n\n # iterate over each scan output and convert it to same format as scan:\n # [[output11, output12,...output1n],\n # [output21, output22,...output2n],...]\n output_scan = []\n for i in range(len(output[0])):\n l = map(lambda x: x[i], output)\n output_scan.append(tf.pack(l))\n return output_scan\n\n\ndef rnn(step_function, inputs, initial_states,\n go_backwards=False, mask=None, constants=None):\n '''Iterates over the time dimension of a tensor.\n # Arguments\n inputs: tensor of temporal data of shape (samples, time, ...)\n (at least 3D).\n step_function:\n Parameters:\n input: tensor with shape (samples, ...) (no time dimension),\n representing input for the batch of samples at a certain\n time step.\n states: list of tensors.\n Returns:\n output: tensor with shape (samples, ...) (no time dimension),\n new_states: list of tensors, same length and shapes\n as 'states'.\n initial_states: tensor with shape (samples, ...) (no time dimension),\n containing the initial values for the states used in\n the step function.\n go_backwards: boolean. If True, do the iteration over\n the time dimension in reverse order.\n mask: binary tensor with shape (samples, time, 1),\n with a zero for every element that is masked.\n constants: a list of constant values passed at each step.\n # Returns\n A tuple (last_output, outputs, new_states).\n last_output: the latest output of the rnn, of shape (samples, ...)\n outputs: tensor with shape (samples, time, ...) where each\n entry outputs[s, t] is the output of the step function\n at time t for sample s.\n new_states: list of tensors, latest states returned by\n the step function, of shape (samples, ...).\n '''\n ndim = len(inputs.get_shape())\n assert ndim >= 3, \"Input should be at least 3D.\"\n axes = [1, 0] + list(range(2, ndim))\n inputs = tf.transpose(inputs, (axes))\n input_list = tf.unpack(inputs)\n if constants is None:\n constants = []\n\n states = initial_states\n successive_states = []\n successive_outputs = []\n if go_backwards:\n input_list.reverse()\n\n if mask is not None:\n # Transpose not supported by bool tensor types, hence round-trip to uint8.\n mask = tf.cast(mask, tf.uint8)\n if len(mask.get_shape()) == ndim - 1:\n mask = expand_dims(mask)\n mask = tf.cast(tf.transpose(mask, axes), tf.bool)\n mask_list = tf.unpack(mask)\n\n for input, mask_t in zip(input_list, mask_list):\n output, new_states = step_function(input, states + constants)\n\n # tf.select needs its condition tensor to be the same shape as its two\n # result tensors, but in our case the condition (mask) tensor is\n # (nsamples, 1), and A and B are (nsamples, ndimensions). So we need to\n # broadcast the mask to match the shape of A and B. That's what the\n # tile call does, is just repeat the mask along its second dimension\n # ndimensions times.\n tiled_mask_t = tf.tile(mask_t, tf.pack([1, tf.shape(output)[1]]))\n\n if len(successive_outputs) == 0:\n prev_output = zeros_like(output)\n else:\n prev_output = successive_outputs[-1]\n\n output = tf.select(tiled_mask_t, output, prev_output)\n\n return_states = []\n for state, new_state in zip(states, new_states):\n # (see earlier comment for tile explanation)\n tiled_mask_t = tf.tile(mask_t, tf.pack([1, tf.shape(new_state)[1]]))\n return_states.append(tf.select(tiled_mask_t, new_state, state))\n\n states = return_states\n successive_outputs.append(output)\n successive_states.append(states)\n else:\n for input in input_list:\n output, states = step_function(input, states + constants)\n successive_outputs.append(output)\n successive_states.append(states)\n\n last_output = successive_outputs[-1]\n outputs = tf.pack(successive_outputs)\n new_states = successive_states[-1]\n\n axes = [1, 0] + list(range(2, len(outputs.get_shape())))\n outputs = tf.transpose(outputs, axes)\n return last_output, outputs, new_states\n\n\ndef switch(condition, then_expression, else_expression):\n '''Switch between two operations depending on a scalar value.\n\n # Arguments\n condition: scalar tensor.\n then_expression: TensorFlow operation.\n else_expression: TensorFlow operation.\n '''\n return tf.python.control_flow_ops.cond(condition,\n lambda: then_expression,\n lambda: else_expression)\n\n\n# ===========================================================================\n# NN OPERATIONS\n# ===========================================================================\ndef relu(x, alpha=0., max_value=None):\n '''ReLU.\n # Arguments\n alpha: slope of negative section.\n max_value: saturation threshold.\n '''\n negative_part = tf.nn.relu(-x)\n x = tf.nn.relu(x)\n if max_value is not None:\n x = tf.clip_by_value(x, tf.cast(0., dtype=_FLOATX),\n tf.cast(max_value, dtype=_FLOATX))\n if isinstance(alpha, (tuple, list, np.ndarray)) or np.isscalar(alpha):\n alpha = tf.constant(alpha, dtype=_FLOATX)\n x -= alpha * negative_part\n return x\n\n\ndef linear(x):\n return x\n\n\ndef softmax(x):\n return tf.nn.softmax(x)\n\n\ndef softplus(x):\n return tf.nn.softplus(x)\n\n\ndef categorical_crossentropy(output, target, from_logits=False):\n '''Note: tf.nn.softmax_cross_entropy_with_logits\n expects logits, Keras expects probabilities.\n '''\n if not from_logits:\n # scale preds so that the class probas of each sample sum to 1\n output /= tf.reduce_sum(output,\n reduction_indices=len(output.get_shape()) - 1,\n keep_dims=True)\n # manual computation of crossentropy\n output = tf.clip_by_value(output, tf.cast(_EPSILON, dtype=_FLOATX),\n tf.cast(1. - _EPSILON, dtype=_FLOATX))\n return - tf.reduce_sum(target * tf.log(output),\n reduction_indices=len(output.get_shape()) - 1)\n else:\n return tf.nn.softmax_cross_entropy_with_logits(output, target)\n\n\ndef binary_crossentropy(output, target, from_logits=False):\n '''Note: tf.nn.sigmoid_cross_entropy_with_logits\n expects logits, Keras expects probabilities.\n '''\n if not from_logits:\n # transform back to logits\n output = tf.clip_by_value(output, tf.cast(_EPSILON, dtype=_FLOATX),\n tf.cast(1. - _EPSILON, dtype=_FLOATX))\n output = tf.log(output / (1 - output))\n return tf.nn.sigmoid_cross_entropy_with_logits(output, target)\n\n\ndef sigmoid(x):\n return tf.nn.sigmoid(x)\n\n\ndef hard_sigmoid(x):\n x = (0.2 * x) + 0.5\n x = tf.clip_by_value(x, tf.cast(0., dtype=_FLOATX),\n tf.cast(1., dtype=_FLOATX))\n return x\n\n\ndef tanh(x):\n return tf.nn.tanh(x)\n\n\ndef dropout(x, level, rescale=True, noise_shape=None,\n seed=None, rng=None):\n \"\"\"Computes dropout.\n\n With probability `keep_prob`, outputs the input element scaled up by\n `1 / keep_prob`, otherwise outputs `0`. The scaling is so that the expected\n sum is unchanged.\n\n By default, each element is kept or dropped independently. If `noise_shape`\n is specified, it must be\n [broadcastable](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html)\n to the shape of `x`, and only dimensions with `noise_shape[i] == shape(x)[i]`\n will make independent decisions. For example, if `shape(x) = [k, l, m, n]`\n and `noise_shape = [k, 1, 1, n]`, each batch and channel component will be\n kept independently and each row and column will be kept or not kept together.\n\n Parameters\n ----------\n x: A tensor.\n level: float(0.-1.)\n probability dropout values in given tensor\n rescale: bool\n whether rescale the outputs by dividing the retain probablity\n noise_shape: A 1-D `Tensor` of type `int32`, representing the\n shape for randomly generated keep/drop flags.\n seed: int\n A Python integer. Used to create random seeds. See\n rng: `tensor.rng`\n random generator from tensor class\n \"\"\"\n retain_prob = 1. - level\n if isinstance(rng, _RandomWrapper):\n seed = rng._rng.randint(10e6)\n elif seed is None:\n seed = get_random_magic_seed()\n\n if noise_shape is not None:\n # from tensorflow.python.ops import array_ops\n # shape_x = array_ops.shape(x)\n noise_shape = tuple([shape(x)[i].value if j is None or j < 0 else j\n for i, j in enumerate(noise_shape)])\n # the dummy 1. works around a TF bug\n # (float32_ref vs. float32 incomptability)\n x = tf.nn.dropout(x * 1., retain_prob, noise_shape=noise_shape, seed=seed)\n if not rescale:\n x = x * retain_prob\n return x\n\n# ==================== Regularizations ==================== #\n\n\ndef l2_normalize(x, axis):\n if axis < 0:\n axis = axis % len(x.get_shape())\n return tf.nn.l2_normalize(x, dim=axis)\n\n\ndef l2_regularize(x):\n return sum(tf.square(x))\n\n\ndef l1_regularize(x):\n return sum(tf.abs(x))\n\n\ndef jacobian_regularize(hidden, params):\n ''' Computes the jacobian of the hidden layer with respect to\n the input, reshapes are necessary for broadcasting the\n element-wise product on the right axis\n '''\n hidden = hidden * (1 - hidden)\n L = expand_dims(hidden, 1) * expand_dims(params, 0)\n # Compute the jacobian and average over the number of samples/minibatch\n L = sum(mean(tf.pow(L, 2), axis=0)) # avr over all samples in batch\n return mean(L)\n\n\ndef kl_gaussian(mean_, logsigma,\n prior_mean=0., prior_logsigma=0.,\n regularizer_scale=1.):\n ''' KL-divergence between two gaussians.\n Useful for Variational AutoEncoders. Use this as an activation regularizer\n Parameters:\n -----------\n mean, logsigma: parameters of the input distributions\n prior_mean, prior_logsigma: paramaters of the desired distribution (note the\n log on logsigma)\n regularizer_scale: Rescales the regularization cost. Keep this 1 for most cases.\n\n Note\n ----\n origin implementation from seya:\n https://github.com/Philip-Bachman/ICML-2015/blob/master/LogPDFs.py\n Copyright (c) Philip Bachman\n '''\n gauss_klds = 0.5 * (prior_logsigma - logsigma +\n ((tf.exp(logsigma) + pow((mean_ - prior_mean), 2.0)) / tf.exp(prior_logsigma)) - 1.0)\n return mean(gauss_klds)\n\n\ndef correntropy_regularize(x, sigma=1.):\n '''\n Note\n ----\n origin implementation from seya:\n https://github.com/EderSantana/seya/blob/master/seya/regularizers.py\n Copyright (c) EderSantana\n '''\n return -sum(mean(tf.exp(tf.pow(x, 2) / sigma), axis=0)) / tf.sqrt(2 * np.pi * sigma)\n\n# ===========================================================================\n# CONVOLUTIONS\n# ===========================================================================\n\n\ndef conv2d(x, kernel, strides=(1, 1), border_mode='valid', dim_ordering='th',\n image_shape=None, filter_shape=None):\n '''Runs on cuDNN if available.\n\n # Arguments\n border_mode: string, \"same\" or \"valid\".\n dim_ordering: whether to use Theano or TensorFlow dimension ordering\n in inputs/kernels/ouputs.\n '''\n if border_mode == 'same':\n padding = 'SAME'\n elif border_mode == 'valid':\n padding = 'VALID'\n else:\n raise Exception('Invalid border mode: ' + str(border_mode))\n\n strides = (1,) + strides + (1,)\n\n if _FLOATX == 'float64':\n # tf conv2d only supports float32\n x = tf.cast(x, 'float32')\n kernel = tf.cast(kernel, 'float32')\n\n if dim_ordering == 'th':\n # TF uses the last dimension as channel dimension,\n # instead of the 2nd one.\n # TH input shape: (samples, input_depth, rows, cols)\n # TF input shape: (samples, rows, cols, input_depth)\n # TH kernel shape: (depth, input_depth, rows, cols)\n # TF kernel shape: (rows, cols, input_depth, depth)\n x = tf.transpose(x, (0, 2, 3, 1))\n kernel = tf.transpose(kernel, (2, 3, 1, 0))\n x = tf.nn.conv2d(x, kernel, strides, padding=padding)\n x = tf.transpose(x, (0, 3, 1, 2))\n elif dim_ordering == 'tf':\n x = tf.nn.conv2d(x, kernel, strides, padding=padding)\n else:\n raise Exception('Unknown dim_ordering: ' + str(dim_ordering))\n\n if _FLOATX == 'float64':\n x = tf.cast(x, 'float64')\n return x\n\n\ndef conv3d(x, kernel, strides=(1, 1, 1), border_mode='valid', dim_ordering='th',\n image_shape=None, filter_shape=None):\n raise NotImplementedError\n\n\ndef pool2d(x, pool_size, strides=(1, 1),\n border_mode='valid', dim_ordering='th', pool_mode='max'):\n '''\n # Arguments\n pool_size: tuple of 2 integers.\n strides: tuple of 2 integers.\n border_mode: one of \"valid\", \"same\".\n dim_ordering: one of \"th\", \"tf\".\n '''\n if border_mode == 'same':\n padding = 'SAME'\n elif border_mode == 'valid':\n padding = 'VALID'\n else:\n raise Exception('Invalid border mode: ' + str(border_mode))\n\n strides = (1,) + strides + (1,)\n pool_size = (1,) + pool_size + (1,)\n\n if _FLOATX == 'float64':\n # tf max_pool only supports float32\n x = tf.cast(x, 'float32')\n\n if dim_ordering in {'tf', 'th'}:\n if dim_ordering == 'th':\n # TF uses the last dimension as channel dimension,\n # instead of the 2nd one.\n # TH input shape: (samples, input_depth, rows, cols)\n # TF input shape: (samples, rows, cols, input_depth)\n # TH kernel shape: (depth, input_depth, rows, cols)\n # TF kernel shape: (rows, cols, input_depth, depth)\n x = tf.transpose(x, (0, 2, 3, 1))\n if pool_mode == 'max':\n x = tf.nn.max_pool(x, pool_size, strides, padding=padding)\n elif pool_mode == 'avg':\n x = tf.nn.avg_pool(x, pool_size, strides, padding=padding)\n else:\n raise Exception('Invalid pooling mode: ' + str(pool_mode))\n if dim_ordering == 'th':\n x = tf.transpose(x, (0, 3, 1, 2))\n else:\n raise Exception('Unknown dim_ordering: ' + str(dim_ordering))\n\n if _FLOATX == 'float64':\n x = tf.cast(x, 'float64')\n return x\n\n\ndef pool3d(x, pool_size, strides=(1, 1, 1),\n border_mode='valid', dim_ordering='th', pool_mode='max'):\n raise NotImplementedError\n\n# ===========================================================================\n# RANDOMNESS\n# ===========================================================================\n\n\nclass _RandomWrapper(object):\n\n def __init__(self, rng):\n super(_RandomWrapper, self).__init__()\n self._rng = np.random.RandomState(rng)\n self._state = np.random.RandomState(rng)\n\n def randint(self):\n return self._state.randint(10e6)\n\n def normal(self, shape, mean, std, dtype=_FLOATX):\n return tf.random_normal(shape=shape, mean=mean, stddev=std,\n dtype=dtype, seed=self._rng.randint(10e6))\n\n def uniform(self, shape, low, high, dtype=_FLOATX):\n return tf.random_uniform(shape=shape, minval=low, maxval=high,\n dtype=dtype, seed=self._rng.randint(10e6))\n\n def binomial(self, shape, p, dtype=_FLOATX):\n return tf.cast(\n tf.less(\n tf.random_uniform(shape=shape, minval=0., maxval=1.,\n dtype=_FLOATX, seed=self._rng.randint(10e6)),\n p),\n dtype)\n\n\ndef rng(seed=None):\n if seed is None:\n seed = get_random_magic_seed()\n return _RandomWrapper(seed)\n\n\ndef random_normal(shape, mean=0.0, std=1.0, dtype=_FLOATX, seed=None):\n if seed is None:\n seed = get_random_magic_seed()\n return tf.random_normal(shape, mean=mean, stddev=std,\n dtype=dtype, seed=seed)\n\n\ndef random_uniform(shape, low=0.0, high=1.0, dtype=_FLOATX, seed=None):\n if seed is None:\n seed = get_random_magic_seed()\n return tf.random_uniform(shape, minval=low, maxval=high,\n dtype=dtype, seed=seed)\n\n\ndef random_binomial(shape, p, dtype=_FLOATX, seed=None):\n if seed is None:\n seed = get_random_magic_seed()\n return tf.cast(\n tf.less(\n tf.random_uniform(shape=shape, minval=0., maxval=1.,\n dtype=dtype, seed=seed),\n p),\n dtype)\n\n# ===========================================================================\n# Comparator\n# ===========================================================================\n\n\ndef eq(x, y):\n \"\"\"a == b\"\"\"\n return tf.equal(x, y)\n\n\ndef neq(x, y):\n \"\"\"a != b\"\"\"\n return tf.not_equal(x, y)\n\n\ndef gt(a, b):\n \"\"\"a > b\"\"\"\n return tf.greater(a, b)\n\n\ndef ge(a, b):\n \"\"\"a >= b\"\"\"\n return tf.greater_equal(a, b)\n\n\ndef lt(a, b):\n \"\"\"a < b\"\"\"\n return tf.less(a, b)\n\n\ndef le(a, b):\n \"\"\"a <= b\"\"\"\n return tf.less_equal(a, b)\n\n\ndef one_hot(x, nb_class):\n ''' x: 1D-integer vector '''\n shape = x.get_shape()\n ret = tf.zeros((shape[0].value, nb_class), dtype=_FLOATX)\n ret[np.arange(shape[0].value), x] = 1\n return ret\n\n\ndef one_hot_max(x, axis=-1):\n '''\n Example\n -------\n >>> Input: [[0.0, 0.0, 0.5],\n >>> [0.0, 0.3, 0.1],\n >>> [0.6, 0.0, 0.2]]\n >>> Output: [[0.0, 0.0, 1.0],\n >>> [0.0, 1.0, 0.0],\n >>> [1.0, 0.0, 0.0]]\n '''\n if axis < 0:\n axis = axis % len(x.get_shape())\n shape = x.get_shape()[axis].value\n return tf.cast(\n tf.equal(tf.cast(tf.range(shape), 'int64'),\n expand_dims(tf.argmax(x, axis))),\n _FLOATX\n )\n\n\ndef apply_mask(x, mask):\n '''\n x : 3D tensor\n mask : 2D tensor\n\n Example\n -------\n >>> Input: [128, 500, 120]\n >>> Mask: [1, 1, 0]\n >>> Output: [128, 500, 0]\n '''\n return tf.mul(x, tf.expand_dims(mask, -1))\n", "meta": {"hexsha": "c72722e8f83a96fb9a15bbbf179446766073582c", "size": 43735, "ext": "py", "lang": "Python", "max_stars_repo_path": "odin/tensor/tf_backend.py", "max_stars_repo_name": "trungnt13/odin_old", "max_stars_repo_head_hexsha": "e5f44f9b6c483d6498767899315ae56e06fe36c4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2016-02-24T20:41:08.000Z", "max_stars_repo_stars_event_max_datetime": "2016-02-29T02:25:16.000Z", "max_issues_repo_path": "odin/tensor/tf_backend.py", "max_issues_repo_name": "trungnt13/odin", "max_issues_repo_head_hexsha": "e5f44f9b6c483d6498767899315ae56e06fe36c4", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "odin/tensor/tf_backend.py", "max_forks_repo_name": "trungnt13/odin", "max_forks_repo_head_hexsha": "e5f44f9b6c483d6498767899315ae56e06fe36c4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.1724875267, "max_line_length": 97, "alphanum_fraction": 0.5825311535, "include": true, "reason": "import numpy,from theano", "num_tokens": 10383, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.1969659356847176}} {"text": "import math\nfrom collections import OrderedDict\n\nimport numpy as np\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\n'''\nAdaCos and Ad margin loss taken from https://github.com/4uiiurz1/pytorch-adacos\n'''\n\nclass DropClassBase(nn.Module):\n\n def __init__(self, num_classes):\n '''\n DropClass class which other classifier heads should inherit from\n\n This is to package the useful wrapper scripts for which classes to include/ignore\n\n The class has two main modes, called via .drop() and .nodrop(), which sets which method will be\n called by .forward()\n\n forward_drop defines the ordinary behaviour\n forward_nodrop defines the behaviour in which only the remaining class columns are used\n '''\n super(DropClassBase, self).__init__()\n self.n_classes = num_classes\n self.dropmode = False # Default is the normal behaviour\n self.set_ignored_classes([])\n self.combined_class_label = None\n\n def forward(self, input, label=None):\n '''\n input: (batch_size, num_features): FloatTensor\n label (optional): (batch_size): LongTensor\n '''\n if self.dropmode:\n if label is not None:\n assert (torch.max(label) < len(self.rem_classes)), 'Contains label out of range of allowed classes: Have they been converted?'\n return self.forward_drop(input, label=label)\n else:\n return self.forward_nodrop(input, label=label)\n\n def drop(self):\n self.dropmode = True\n \n def nodrop(self):\n self.dropmode = False\n\n def forward_drop(self, input, label=None):\n raise NotImplementedError\n\n def forward_nodrop(self, input, label=None):\n raise NotImplementedError\n\n def set_ignored_classes(self, ignored:list):\n if len(ignored) != 0:\n assert min(ignored) >= 0\n assert max(ignored) < self.n_classes\n self.ignored = sorted(list(set(ignored)))\n self.rem_classes = sorted(set(np.arange(self.n_classes)) - set(ignored))\n self.ldict = OrderedDict({k:v for v, k in enumerate(self.rem_classes)}) #mapping of original label to new index\n self.idict = OrderedDict({k:v for k, v in enumerate(self.rem_classes)}) #mapping of remaining indexes to original label\n\n def set_remaining_classes(self, remaining:list):\n assert min(remaining) >= 0\n assert max(remaining) < self.n_classes\n self.rem_classes = sorted(set(remaining))\n self.ignored = sorted(set(np.arange(self.n_classes)) - set(remaining))\n self.ldict = OrderedDict({k:v for v, k in enumerate(self.rem_classes)}) #mapping of original label to new index\n self.idict = OrderedDict({k:v for k, v in enumerate(self.rem_classes)}) #mapping of remaining indexes to original label\n\n def get_mini_labels(self, label:list):\n # convert list of labels into new indexes for ignored classes\n mini_labels = torch.LongTensor(list(map(lambda x: self.ldict[x], label)))\n return mini_labels\n\n def get_orig_labels(self, label:list):\n # convert list of mini_labels into original class labels\n # assert not self.combined_class_label, 'Combined classes means original labels not recoverable'\n orig_labels = list(map(lambda x: self.idict[x], label))\n return orig_labels\n\n def set_remaining_classes_comb(self, remaining:list):\n # remaining must not include the combined class\n assert self.combined_class_label is not None, 'combined_class_label has not been set'\n assert min(remaining) >= 0\n assert max(remaining) < self.n_classes\n remaining.append(self.combined_class_label)\n self.rem_classes = sorted(set(remaining))\n self.ignored = sorted(set(np.arange(self.n_classes)) - set(remaining)) # not really ignored, just combined\n self.ldict = OrderedDict({k:v for v, k in enumerate(self.rem_classes)})\n for k in self.ignored:\n self.ldict[k] = self.combined_class_label # set all ignored classes to the combined class label\n self.idict = OrderedDict({k:v for k, v in enumerate(self.rem_classes)}) # not the original mapping for comb classes\n\nclass DropAffine(DropClassBase):\n\n def __init__(self, num_features, num_classes):\n super(DropAffine, self).__init__(num_classes)\n self.fc = nn.Linear(num_features, num_classes)\n self.reset_parameters()\n\n def reset_parameters(self):\n self.fc.reset_parameters()\n \n def forward_nodrop(self, input, label=None):\n W = self.fc.weight\n b = self.fc.bias\n logits = F.linear(input, W, b)\n return logits\n\n def forward_drop(self, input, label=None):\n W = self.fc.weight[self.rem_classes]\n b = self.fc.bias[self.rem_classes]\n logits = F.linear(input, W, b)\n return logits\n\nclass L2SoftMax(DropClassBase):\n\n def __init__(self, num_features, num_classes):\n super(L2SoftMax, self).__init__(num_classes)\n self.W = nn.Parameter(torch.FloatTensor(num_classes, num_features))\n self.reset_parameters()\n\n def reset_parameters(self):\n nn.init.xavier_uniform_(self.W)\n \n def forward_nodrop(self, input, label=None):\n x = F.normalize(input)\n W = F.normalize(self.W)\n logits = F.linear(x, W)\n return logits\n\n def forward_drop(self, input, label=None):\n x = F.normalize(input)\n W = F.normalize(self.W[self.rem_classes])\n logits = F.linear(x, W)\n return logits\n\nclass SoftMax(DropClassBase):\n\n def __init__(self, num_features, num_classes):\n super(SoftMax, self).__init__(num_classes)\n self.W = nn.Parameter(torch.FloatTensor(num_classes, num_features))\n self.reset_parameters()\n\n def reset_parameters(self):\n nn.init.xavier_uniform_(self.W)\n \n def forward_nodrop(self, input, label=None):\n x = input\n W = self.W\n logits = F.linear(x, W)\n return logits\n\n def forward_drop(self, input, label=None):\n x = input\n W = self.W[self.rem_classes]\n logits = F.linear(x, W)\n return logits\n\nclass XVecHead(DropClassBase):\n\n def __init__(self, num_features, num_classes, hidden_features=None):\n super(XVecHead, self).__init__(num_classes)\n hidden_features = num_features if not hidden_features else hidden_features\n self.fc_hidden = nn.Linear(num_features, hidden_features)\n self.nl = nn.LeakyReLU()\n self.bn = nn.BatchNorm1d(hidden_features)\n self.fc = nn.Linear(hidden_features, num_classes)\n self.reset_parameters()\n\n def reset_parameters(self):\n self.fc.reset_parameters()\n\n def forward_nodrop(self, input, label=None):\n input = self.fc_hidden(input)\n input = self.nl(input)\n input = self.bn(input)\n W = self.fc.weight\n b = self.fc.bias\n logits = F.linear(input, W, b)\n return logits\n\n def forward_drop(self, input, label=None):\n input = self.fc_hidden(input)\n input = self.nl(input)\n input = self.bn(input)\n W = self.fc.weight[self.rem_classes]\n b = self.fc.bias[self.rem_classes]\n logits = F.linear(input, W, b)\n return logits\n\n\nclass AMSMLoss(DropClassBase):\n\n def __init__(self, num_features, num_classes, s=30.0, m=0.4):\n super(AMSMLoss, self).__init__(num_classes)\n self.num_features = num_features\n self.n_classes = num_classes\n self.s = s\n self.m = m\n self.W = nn.Parameter(torch.FloatTensor(num_classes, num_features))\n self.reset_parameters()\n\n def reset_parameters(self):\n nn.init.xavier_uniform_(self.W)\n\n def forward_nodrop(self, input, label=None):\n # normalize features\n x = F.normalize(input)\n # normalize weights\n W = F.normalize(self.W)\n # dot product\n logits = F.linear(x, W)\n if label is None:\n return logits\n # add margin\n target_logits = logits - self.m\n one_hot = torch.zeros_like(logits)\n one_hot.scatter_(1, label.view(-1, 1).long(), 1)\n output = logits * (1 - one_hot) + target_logits * one_hot\n # feature re-scale\n output *= self.s\n\n return output\n\n def forward_drop(self, input, label=None):\n # normalize features\n x = F.normalize(input)\n # normalize weights\n W = F.normalize(self.W[self.rem_classes])\n # dot product\n logits = F.linear(x, W)\n if label is None:\n return logits\n # add margin\n target_logits = logits - self.m\n one_hot = torch.zeros_like(logits)\n one_hot.scatter_(1, label.view(-1, 1).long(), 1)\n output = logits * (1 - one_hot) + target_logits * one_hot\n # feature re-scale\n output *= self.s\n\n return output\n\n\nclass SphereFace(DropClassBase):\n\n def __init__(self, num_features, num_classes, s=30.0, m=1.35):\n super(SphereFace, self).__init__(num_classes)\n self.num_features = num_features\n self.n_classes = num_classes\n self.s = s\n self.m = m\n self.W = nn.Parameter(torch.FloatTensor(num_classes, num_features))\n self.reset_parameters()\n\n def reset_parameters(self):\n nn.init.xavier_uniform_(self.W)\n\n def forward_nodrop(self, input, label=None):\n # normalize features\n x = F.normalize(input)\n # normalize weights\n W = F.normalize(self.W)\n # dot product\n logits = F.linear(x, W)\n if label is None:\n return logits\n # add margin\n theta = torch.acos(torch.clamp(logits, -1.0 + 1e-7, 1.0 - 1e-7))\n target_logits = torch.cos(self.m * theta)\n one_hot = torch.zeros_like(logits)\n one_hot.scatter_(1, label.view(-1, 1).long(), 1)\n output = logits * (1 - one_hot) + target_logits * one_hot\n # feature re-scale\n output *= self.s\n\n return output\n \n def forward_drop(self, input, label=None):\n # normalize features\n x = F.normalize(input)\n # normalize weights\n W = F.normalize(self.W[self.rem_classes])\n # dot product\n logits = F.linear(x, W)\n if label is None:\n return logits\n # add margin\n theta = torch.acos(torch.clamp(logits, -1.0 + 1e-7, 1.0 - 1e-7))\n target_logits = torch.cos(self.m * theta)\n one_hot = torch.zeros_like(logits)\n one_hot.scatter_(1, label.view(-1, 1).long(), 1)\n output = logits * (1 - one_hot) + target_logits * one_hot\n # feature re-scale\n output *= self.s\n\n return output\n\nclass ArcFace(DropClassBase):\n\n def __init__(self, num_features, num_classes, s=30.0, m=0.50):\n super(ArcFace, self).__init__(num_classes)\n self.num_features = num_features\n self.n_classes = num_classes\n self.s = s\n self.m = m\n self.W = nn.Parameter(torch.FloatTensor(num_classes, num_features))\n self.reset_parameters()\n\n def reset_parameters(self):\n nn.init.xavier_uniform_(self.W)\n\n def forward_nodrop(self, input, label=None):\n # normalize features\n x = F.normalize(input)\n # normalize weights\n W = F.normalize(self.W)\n # dot product\n logits = F.linear(x, W)\n if label is None:\n return logits\n # add margin\n theta = torch.acos(torch.clamp(logits, -1.0 + 1e-7, 1.0 - 1e-7))\n target_logits = torch.cos(theta + self.m)\n one_hot = torch.zeros_like(logits)\n one_hot.scatter_(1, label.view(-1, 1).long(), 1)\n output = logits * (1 - one_hot) + target_logits * one_hot\n # feature re-scale\n output *= self.s\n\n return output\n \n def forward_drop(self, input, label=None):\n # normalize features\n x = F.normalize(input)\n # normalize weights\n W = F.normalize(self.W[self.rem_classes])\n # dot product\n logits = F.linear(x, W)\n if label is None:\n return logits\n # add margin\n theta = torch.acos(torch.clamp(logits, -1.0 + 1e-7, 1.0 - 1e-7))\n target_logits = torch.cos(theta + self.m)\n one_hot = torch.zeros_like(logits)\n one_hot.scatter_(1, label.view(-1, 1).long(), 1)\n output = logits * (1 - one_hot) + target_logits * one_hot\n # feature re-scale\n output *= self.s\n\n return output\n\nclass AdaCos(DropClassBase):\n\n def __init__(self, num_features, num_classes, m=0.50):\n super(AdaCos, self).__init__(num_classes)\n self.num_features = num_features\n self.n_classes = num_classes\n self.s = math.sqrt(2) * math.log(num_classes - 1)\n self.m = m\n self.W = nn.Parameter(torch.FloatTensor(num_classes, num_features))\n self.reset_parameters()\n\n def reset_parameters(self):\n nn.init.xavier_uniform_(self.W)\n\n def forward_nodrop(self, input, label=None):\n # normalize features\n x = F.normalize(input)\n # normalize weights\n W = F.normalize(self.W)\n # dot product\n logits = F.linear(x, W)\n if label is None:\n return logits\n # feature re-scale\n theta = torch.acos(torch.clamp(logits, -1.0 + 1e-7, 1.0 - 1e-7))\n one_hot = torch.zeros_like(logits)\n one_hot.scatter_(1, label.view(-1, 1).long(), 1)\n with torch.no_grad():\n B_avg = torch.where(one_hot < 1, torch.exp(self.s * logits), torch.zeros_like(logits))\n B_avg = torch.sum(B_avg) / input.size(0)\n theta_med = torch.median(theta[one_hot == 1])\n self.s = torch.log(B_avg) / torch.cos(torch.min(math.pi/4 * torch.ones_like(theta_med), theta_med))\n output = self.s * logits\n\n return output\n\n def forward_drop(self, input, label=None):\n # normalize features\n x = F.normalize(input)\n # normalize weights\n W = F.normalize(self.W[self.rem_classes])\n # dot product\n logits = F.linear(x, W)\n if label is None:\n return logits\n # feature re-scale\n theta = torch.acos(torch.clamp(logits, -1.0 + 1e-7, 1.0 - 1e-7))\n one_hot = torch.zeros_like(logits)\n one_hot.scatter_(1, label.view(-1, 1).long(), 1)\n with torch.no_grad():\n B_avg = torch.where(one_hot < 1, torch.exp(self.s * logits), torch.zeros_like(logits))\n B_avg = torch.sum(B_avg) / input.size(0)\n theta_med = torch.median(theta[one_hot == 1])\n self.s = torch.log(B_avg) / torch.cos(torch.min(math.pi/4 * torch.ones_like(theta_med), theta_med))\n output = self.s * logits\n\n return output\n\n\n\n\nclass DisturbLabelLoss(nn.Module):\n\n def __init__(self, device, disturb_prob=0.1):\n super(DisturbLabelLoss, self).__init__()\n self.disturb_prob = disturb_prob\n self.ce = nn.CrossEntropyLoss()\n self.device = device\n\n def forward(self, pred, target):\n with torch.no_grad():\n disturb_indexes = torch.rand(len(pred)) < self.disturb_prob\n target[disturb_indexes] = torch.randint(pred.shape[-1], (int(disturb_indexes.sum()),)).to(self.device)\n return self.ce(pred, target)\n\n \nclass LabelSmoothingLoss(nn.Module):\n\n def __init__(self, smoothing=0.1, dim=-1):\n super(LabelSmoothingLoss, self).__init__()\n self.confidence = 1.0 - smoothing\n self.smoothing = smoothing\n self.dim = dim\n\n def forward(self, pred, target):\n pred = pred.log_softmax(dim=self.dim)\n with torch.no_grad():\n true_dist = torch.zeros_like(pred)\n true_dist.fill_(self.smoothing / (pred.shape[-1] - 1))\n true_dist.scatter_(1, target.data.unsqueeze(1), self.confidence)\n return torch.mean(torch.sum(-true_dist * pred, dim=self.dim))", "meta": {"hexsha": "8c204830a6d3589113c20fe7c4b6294a14aecceb", "size": 15892, "ext": "py", "lang": "Python", "max_stars_repo_path": "loss_functions.py", "max_stars_repo_name": "entn-at/dropclass_speaker", "max_stars_repo_head_hexsha": "4f3f7627226986b9b5d8c969f7707237b71c2ddf", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 21, "max_stars_repo_stars_event_min_datetime": "2020-02-12T19:27:06.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-26T00:14:32.000Z", "max_issues_repo_path": "loss_functions.py", "max_issues_repo_name": "entn-at/dropclass_speaker", "max_issues_repo_head_hexsha": "4f3f7627226986b9b5d8c969f7707237b71c2ddf", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-10-29T03:32:21.000Z", "max_issues_repo_issues_event_max_datetime": "2020-10-29T07:16:20.000Z", "max_forks_repo_path": "loss_functions.py", "max_forks_repo_name": "entn-at/dropclass_speaker", "max_forks_repo_head_hexsha": "4f3f7627226986b9b5d8c969f7707237b71c2ddf", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 13, "max_forks_repo_forks_event_min_datetime": "2020-01-31T10:14:00.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-23T07:39:03.000Z", "avg_line_length": 35.3942093541, "max_line_length": 142, "alphanum_fraction": 0.6233324943, "include": true, "reason": "import numpy", "num_tokens": 3770, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.1969659356847176}} {"text": "#!/usr/bin/python\r\n# -*- coding: UTF-8 -*-\r\n\r\nimport matplotlib\r\nmatplotlib.use('Agg')\r\n\r\n# Pytorch requirements\r\nimport unicodedata\r\nimport string\r\nimport re\r\nimport random\r\n\r\nimport torch\r\nimport torch.nn as nn\r\nfrom torch.nn import init\r\nfrom torch.autograd import Variable\r\nfrom torch import optim\r\nimport torch.nn.functional as F\r\nfrom MatchingLayer import MatchingLayer\r\nimport numpy as np\r\n\r\n\r\nif torch.cuda.is_available():\r\n dtype = torch.cuda.FloatTensor\r\n dtype_l = torch.cuda.LongTensor\r\nelse:\r\n dtype = torch.FloatTensor\r\n dtype_l = torch.cuda.LongTensor\r\n\r\ndef sinkhorn_knopp(A, iterations=1):\r\n A_size = A.size()\r\n for it in range(iterations):\r\n A = A.view(A_size[0]*A_size[1], A_size[2])\r\n A = F.softmax(A)\r\n A = A.view(*A_size).permute(0, 2, 1)\r\n A = A.view(A_size[0]*A_size[1], A_size[2])\r\n A = F.softmax(A)\r\n A = A.view(*A_size).permute(0, 2, 1)\r\n return A\r\n\r\ndef gmul(input):\r\n W, x = input\r\n # x is a tensor of size (bs, N, num_features)\r\n # W is a tensor of size (bs, N, N, J)\r\n x_size = x.size()\r\n W_size = W.size()\r\n N = W_size[-2]\r\n J = W_size[-1]\r\n W = W.split(1, 3)\r\n W = torch.cat(W, 1).squeeze(3) # W is now a tensor of size (bs, J*N, N)\r\n output = torch.bmm(W, x) # output has size (bs, J*N, num_features)\r\n output = output.split(N, 1)\r\n output = torch.cat(output, 2) # output has size (bs, N, J*num_features)\r\n return output\r\n\r\nclass Gconv_last(nn.Module):\r\n def __init__(self, feature_maps, J):\r\n super(Gconv_last, self).__init__()\r\n self.num_inputs = J*feature_maps[0]\r\n self.num_outputs = feature_maps[2]\r\n self.fc = nn.Linear(self.num_inputs, self.num_outputs)\r\n\r\n def forward(self, input):\r\n W = input[0]\r\n x = gmul(input) # out has size (bs, N, num_inputs)\r\n x_size = x.size()\r\n x = x.contiguous()\r\n x = x.view(x_size[0]*x_size[1], -1)\r\n x = self.fc(x) # has size (bs*N, num_outputs)\r\n x = x.view(*x_size[:-1], self.num_outputs)\r\n return W, x\r\n\r\nclass Gconv(nn.Module):\r\n def __init__(self, feature_maps, J):\r\n super(Gconv, self).__init__()\r\n self.num_inputs = J*feature_maps[0]\r\n self.num_outputs = feature_maps[2]\r\n self.fc1 = nn.Linear(self.num_inputs, self.num_outputs // 2)\r\n self.fc2 = nn.Linear(self.num_inputs, self.num_outputs // 2)\r\n self.bn = nn.BatchNorm1d(self.num_outputs)\r\n\r\n def forward(self, input):\r\n W = input[0]\r\n x = gmul(input) # out has size (bs, N, num_inputs)\r\n x_size = x.size()\r\n x = x.contiguous()\r\n x = x.view(-1, self.num_inputs)\r\n x1 = F.relu(self.fc1(x)) # has size (bs*N, num_outputs)\r\n x2 = self.fc2(x)\r\n x = torch.cat((x1, x2), 1)\r\n x = self.bn(x)\r\n x = x.view(*x_size[:-1], self.num_outputs)\r\n return W, x\r\n\r\nclass GNN(nn.Module):\r\n def __init__(self, num_features, num_layers, J):\r\n super(GNN, self).__init__()\r\n self.num_features = num_features\r\n self.num_layers = num_layers\r\n self.featuremap_in = [1, 1, num_features]\r\n self.featuremap_mi = [num_features, num_features, num_features]\r\n self.featuremap_end = [num_features, num_features, num_features]\r\n self.layer0 = Gconv(self.featuremap_in, J)\r\n for i in range(num_layers):\r\n module = Gconv(self.featuremap_mi, J)\r\n self.add_module('layer{}'.format(i + 1), module)\r\n self.layerlast = Gconv_last(self.featuremap_end, J)\r\n\r\n def forward(self, input):\r\n cur = self.layer0(input)\r\n for i in range(self.num_layers):\r\n cur = self._modules['layer{}'.format(i+1)](cur)\r\n out = self.layerlast(cur)\r\n return out[1]\r\n\r\n\r\n\r\n\r\n\r\nclass GNN_Matcher(nn.Module):\r\n def __init__(self, num_features, num_layers, J, matching_layer):\r\n super(GNN_Matcher, self).__init__()\r\n self.num_features = num_features\r\n self.num_layers = num_layers\r\n self.featuremap_in = [1, 1, num_features]\r\n self.featuremap_mi = [num_features, num_features, num_features]\r\n self.featuremap_end = [num_features, num_features, num_features]\r\n self.layer0 = Gconv(self.featuremap_in, J)\r\n self.matching_layer = matching_layer\r\n for i in range(num_layers):\r\n module = Gconv(self.featuremap_mi, J)\r\n self.add_module('layer{}'.format(i + 1), module)\r\n self.layerlast = Gconv_last(self.featuremap_end, J)\r\n\r\n def forward(self, input):\r\n cur = self.layer0(input)\r\n for i in range(self.num_layers):\r\n cur = self._modules['layer{}'.format(i+1)](cur)\r\n\r\n out = self.layerlast(cur)\r\n\r\n\r\n x = out[1]\r\n outsize = x.size()\r\n\r\n x = x.sum(2) # sum along the axis of 'features' from the GNN\r\n outsize = x.size()\r\n\r\n \"\"\"\r\n print(\"after sum\")\r\n print(\"outsize\")\r\n print( outsize )\r\n \"\"\"\r\n\r\n ns = np.ceil(np.sqrt(x.size()[1])).astype(int)\r\n\r\n x = self.matching_layer(x.view(1,-1)).view(outsize)\r\n #x = self.matching_layer(x.view(1,ns,ns))#.view(outsize)\r\n\r\n return x.view(1,ns,ns)\r\n #return out[1]\r\n\r\n\r\n\r\n\r\nclass Siamese_GNN(nn.Module):\r\n def __init__(self, num_features, num_layers, J):\r\n super(Siamese_GNN, self).__init__()\r\n self.gnn = GNN(num_features, num_layers, J)\r\n\r\n def forward(self, g1, g2):\r\n \"\"\"\r\n print(\"Inside Siamese GNN forward\")\r\n print(\"g1 = \")\r\n print( g1 )\r\n print(\"g2 = \")\r\n print( g2 )\r\n \"\"\"\r\n emb1 = self.gnn(g1)\r\n emb2 = self.gnn(g2)\r\n \"\"\"\r\n print(\"emb1 = \")\r\n print( emb1 )\r\n print(\"emb2 = \")\r\n print( emb2 )\r\n print(\"emb2.size() = \")\r\n print( emb2.size() )\r\n \"\"\"\r\n\r\n\r\n # embx are tensors of size (bs, N, num_features)\r\n out = torch.bmm(emb1, emb2.permute(0, 2, 1))\r\n return out # out has size (bs, N, N)\r\n\r\n\r\nclass Siamese_Matcher(nn.Module):\r\n def __init__(self, num_features, num_layers, J, matching_layer):\r\n super(Siamese_Matcher, self).__init__()\r\n self.gnn = GNN(num_features, num_layers, J)\r\n self.matching_layer = matching_layer #MatchingLayer(nNodes=n, eps=1e-4)\r\n\r\n def forward(self, g1, g2):\r\n\r\n emb1 = self.gnn(g1)\r\n emb2 = self.gnn(g2)\r\n\r\n # embx are tensors of size (bs, N, num_features)\r\n out = torch.bmm(emb1, emb2.permute(0, 2, 1))\r\n outsize = out.size()\r\n out = self.matching_layer(out.view(1,-1)).view(outsize)\r\n # adjust training loop to accomodate this output\r\n return out # out has size (bs, N, N)\r\n\r\n\r\n\r\nif __name__ == '__main__':\r\n # test modules\r\n bs = 4\r\n num_features = 10\r\n num_layers = 5\r\n N = 8\r\n x = torch.ones((bs, N, num_features))\r\n W1 = torch.eye(N).unsqueeze(0).unsqueeze(-1).expand(bs, N, N, 1)\r\n W2 = torch.ones(N).unsqueeze(0).unsqueeze(-1).expand(bs, N, N, 1)\r\n J = 2\r\n W = torch.cat((W1, W2), 3)\r\n input = [Variable(W), Variable(x)]\r\n ######################### test gmul ##############################\r\n # feature_maps = [num_features, num_features, num_features]\r\n # out = gmul(input)\r\n # print(out[0, :, num_features:])\r\n ######################### test gconv ##############################\r\n # feature_maps = [num_features, num_features, num_features]\r\n # gconv = Gconv(feature_maps, J)\r\n # _, out = gconv(input)\r\n # print(out.size())\r\n ######################### test gnn ##############################\r\n # x = torch.ones((bs, N, 1))\r\n # input = [Variable(W), Variable(x)]\r\n # gnn = GNN(num_features, num_layers, J)\r\n # out = gnn(input)\r\n # print(out.size())\r\n ######################### test siamese gnn ##############################\r\n x = torch.ones((bs, N, 1))\r\n input1 = [Variable(W), Variable(x)]\r\n input2 = [Variable(W.clone()), Variable(x.clone())]\r\n siamese_gnn = Siamese_GNN(num_features, num_layers, J)\r\n out = siamese_gnn(input1, input2)\r\n print(out.size())\r\n", "meta": {"hexsha": "13509ba37e16ba0cb2855b54f5a1d59074929bb6", "size": 8123, "ext": "py", "lang": "Python", "max_stars_repo_path": "qap-lp/model.py", "max_stars_repo_name": "j-kota/LP-QAP", "max_stars_repo_head_hexsha": "8b972d754f916b1905f4d89d995b6e9cce093595", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "qap-lp/model.py", "max_issues_repo_name": "j-kota/LP-QAP", "max_issues_repo_head_hexsha": "8b972d754f916b1905f4d89d995b6e9cce093595", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "qap-lp/model.py", "max_forks_repo_name": "j-kota/LP-QAP", "max_forks_repo_head_hexsha": "8b972d754f916b1905f4d89d995b6e9cce093595", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.492, "max_line_length": 81, "alphanum_fraction": 0.5596454512, "include": true, "reason": "import numpy", "num_tokens": 2218, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.1969659356847176}} {"text": "\"\"\"\n.. class:: SpectraStackingEBOSS\n\n.. moduleauthor:: Johan Comparat \n\nThe class SpectraStacking is dedicated to stacking spectra from SDSS-IV eBOSS\n\nCurrent version\n\n\"\"\"\nimport os \nimport astropy.io.fits as fits\nimport numpy as n\nfrom scipy.interpolate import interp1d\nimport spectres as sp\n\nmaskLambda = n.loadtxt(os.path.join(os.environ['GIT_ARCHETYPES'],'data',\"dr12-sky-mask.txt\"), unpack=True)\n\nget_path_to_spectrum_v5_13_0 = lambda plate, mjd, fiberid : os.path.join(\n\tos.environ['HOME'], \n\t'SDSS', \n\t'v5_13_0', \n\t'spectra', \n\tstr(int(plate)).zfill(4), \n\t\"spec-\"+str(int(plate)).zfill(4)+\"-\"+str(int(mjd)).zfill(5)+\"-\"+str(int(fiberid)).zfill(4)+\".fits\" \n\t)\n\nget_path_to_spectrum_26 = lambda plate, mjd, fiberid : os.path.join(\n\tos.environ['HOME'], \n\t'SDSS', \n\t'26', \n\t'spectra', \n\tstr(int(plate)).zfill(4), \n\t\"spec-\"+str(int(plate)).zfill(4)+\"-\"+str(int(mjd)).zfill(5)+\"-\"+str(int(fiberid)).zfill(4)+\".fits\" )\n\n\nline_list_abs = n.array([2249.88, 2260.78, 2344.21, 2374.46, 2382.76, 2576.88, 2586.65, 2594.50, 2600.17, 2606.46, 2796.35, 2803.53, 2852.96])\nline_list_abs_names = n.array(['FeII', 'FeII', 'FeII', 'FeII', 'FeII', 'MnII', 'FeII', 'MnII','FeII', 'MnII', 'MgII','MgII','MgI'])\nline_list_em = n.array([2327, 2365.55, 2396.36, 2612.65,2626.45])\nline_list_em_names = n.array(['CII]', 'FeII*', 'FeII*', 'FeII*', 'FeII*'])\n\n\nclass SpectraStackingEBOSS:\n\t\"\"\"\n\tThe model luminosity function class\n\t:param in_file: file containing spectra ids to be stacked\n\t:param Resolution: Resolution\n\t:param out_file: where to output stacks\n\t\"\"\"\n\tdef __init__(self, in_file, out_file, dLambda = 0.0001, dV=-9999, l_start=2.9, l_end=4.04, KZ_input=False, PBKT_input=False, csv_input=False):\n\t\tprint( \"input list:\", in_file )\n\t\tself.in_file = in_file\n\t\tif KZ_input :\n\t\t\tprint('KZ input')\n\t\t\tself.mjds, self.plates, self.fiberids, self.redshifts = n.loadtxt(self.in_file, unpack=True)\n\t\telif PBKT_input :\n\t\t\tprint('PBKT input')\n\t\t\tself.plates, self.mjds, self.fiberids, self.redshifts, self.weights = n.loadtxt(self.in_file, unpack=True)\n\t\telif csv_input :\n\t\t\tprint('csv input list')\n\t\t\tself.plates, self.mjds, self.fiberids, self.redshifts = n.loadtxt(self.in_file, unpack=True, delimiter=',', skiprows=1)\n\t\telse:\n\t\t\tprint('regular input list')\n\t\t\tself.plates, self.mjds, self.fiberids, self.redshifts = n.loadtxt(self.in_file, unpack=True)\n\t\t\n\t\tprint('N spectra = ', len(self.plates))\n\t\tself.out_file = out_file\n\t\tself.dLambda = dLambda\n\t\t#self.wave= 10**n.arange(2.6, 4.0211892990699383, dLambda) # 1500,10500\n\t\tself.wave= 10**n.arange(l_start, l_end, dLambda) # 1500,10500\n\t\tprint('wavelength array', self.wave)\n\t\tself.R = int(1/n.mean((self.wave[1:] -self.wave[:-1])/ self.wave[1:]))\n\t\tprint( \"R=\", n.median(self.R) )\n\t\tself.dV = dV\n\t\tself.survey=\"eBOSS\"\n\t\tself.N_angstrom_masked = 20.\n\t\t#self.run2d = run2d\n\t\t#self.run1d = self.run2d\n\t\t#self.topdirBOSS = os.path.join(os.environ['BOSS_SPECTRO_REDUX'], run2d)\n\n\tdef stack_function(self,specMatrix,specMatrixWeight):\n\t\t\"\"\"Creates the stack.\n\t\t:param specMatrix: matrix of observed spectra\n\t\t:param specMatrixWeight: matrix of the statistical weights used in the LF.\n\t\t\"\"\"\n\t\tstackMed = n.ones_like(n.empty(len(self.wave)))*self.dV\n\t\tstackMean = n.ones_like(n.empty(len(self.wave)))*self.dV\n\t\t#stackMeanWeighted = n.ones_like(n.empty(len(self.wave)))*self.dV\n\t\tstackVar = n.ones_like(n.empty(len(self.wave)))*self.dV\n\t\tstackN = n.ones_like(n.empty(len(self.wave)))*self.dV\n\t\tjackknifes = n.ones_like(n.empty((len(self.wave),10)))*self.dV\n\t\tfor i in range(len(specMatrix.T)):\n\t\t\t\tpt=specMatrix.T[i]\n\t\t\t\twt=specMatrixWeight.T[i]\n\t\t\t\tsel=(pt!=self.dV)\n\t\t\t\t# jackknife sub-sampling\n\t\t\t\trd=n.random.random(len(pt))\n\t\t\t\taim=n.arange(0,1.01,0.1)\n\t\t\t\tjks=n.array([ (rd>aim[jj])&(rd1:\n\t\t\t\t\t\tstackMed[i] = n.median(pt[sel])\n\t\t\t\t\t\tstackMean[i] = n.mean(pt[sel])\n\t\t\t\t\t\t#stackMeanWeighted[i] = n.average(pt[sel],weights=wt[sel])\n\t\t\t\t\t\tstackN[i] = len(pt[sel])\n\t\t\t\t\t\tinter = n.array([ n.median( pt[sel & (seK==False)] ) for seK in jks ])\n\t\t\t\t\t\tjackknifes[i] = inter\n\t\t\t\t\t\tstackVar[i] = n.std(inter)\n\n\t\twavelength = fits.Column(name=\"wavelength\",format=\"D\", unit=\"Angstrom\", array= self.wave)\n\t\tmedianStack=fits.Column(name=\"medianStack\",format=\"D\", unit=\"erg/s/cm2/Angstrom\", array= n.array(stackMed))\n\t\tmeanStack=fits.Column(name=\"meanStack\",format=\"D\", unit=\"erg/s/cm2/Angstrom\", array= n.array(stackMean))\n\t\t#meanWeightedStack=fits.Column(name=\"meanWeightedStack\",format=\"D\", unit= \"erg/s/cm2/Angstrom\", array= n.array(stackMeanWeighted))\n\t\tjackknifeSpectra=fits.Column(name=\"jackknifeSpectra\",format=\"10D\", unit=\"erg/s/cm2/Angstrom\", array= n.array(jackknifes))\n\t\tjackknifStackErrors=fits.Column(name=\"jackknifStackErrors\",format=\"D\", unit=\"erg/s/cm2/Angstrom\", array= n.array(stackVar))\n\t\tNspectraPerPixel=fits.Column(name=\"NspectraPerPixel\",format=\"D\", unit=\"\", array= n.array(stackN))\n\t\treturn wavelength, medianStack, meanStack, jackknifStackErrors, jackknifeSpectra, NspectraPerPixel\n\t\t#return wavelength, medianStack, meanStack, meanWeightedStack, jackknifStackErrors, jackknifeSpectra, NspectraPerPixel\n\n\tdef convertSpectrum(self,redshift):\n\t\t\"\"\"\n\t\tShifts the spectrum in the rest-frame and creates a spectrum with the sampling desired.\n\t\tUses the spectres package from A.C. Carnall\n\t\t:param redshift: redshift of the spectrum\n\t\treturn the new flux and erro flux array\n\t\t\"\"\"\t\n\t\tnwave=self.wavelength/(1+redshift)\n\t\t\n\t\t#inL=(self.wave>nwave.min())&(self.wave0)&(ivar>0)\n\t\tself.fluxl =flux[out_sel]\n\t\tself.fluxlErr=ivar[out_sel]**(-0.5)\n\t\tself.wavelength = wave[out_sel] #/(1+z)\n\n\tdef fit_UV_continuum(self,x,y,yerr,degree=3):\n\t\t\"\"\"\n\t\tWe then mask out\n\t\tabsorption and emission features and fit a cubic polyno-\n\t\tmial function through the rest of the spectrum. \n\t\tUsing\n\t\tthe best-fit polynomial function as an estimate of the un-\n\t\tderlying continuum, F lambda\n\t\twe normalize the observed spectrum to obtain the continuum-normalized spectrum\n\t\t\"\"\"\t\t\t\t\t\n\t\tself.bad_flags = n.ones(len(x))\n\n\t\t# masking sky contaminated pixels\n\t\tmaskLambda = n.loadtxt(os.path.join(os.environ['GIT_SPM'],'data',\"dr12-sky-mask.txt\"), unpack=True)\n\t\tratio = n.min(abs(10000.*n.log10(n.outer(x, 1./maskLambda))), axis=1)\n\t\tmargin = 1.5\n\t\tveto_sky = ( ratio <= margin )\n\t\t\n\t\t# UV mask\n\t\tUV_mask = (x>2000)&(x<3600)\n\t\t\n\t\t# UV line mask\n\t\tratio = n.min(abs(10000.*n.log10(n.outer(x, 1./line_list_abs))), axis=1)\n\t\tmargin = 8\n\t\tveto_line_abs = ( ratio <= margin )\n\n\t\tratio = n.min(abs(10000.*n.log10(n.outer(x, 1./line_list_em))), axis=1)\n\t\tmargin = 8\n\t\tveto_line_em = ( ratio <= margin )\n\t\t\n\t\t# MASKING BAD DATA\n\t\tbad_data = n.isnan(y) | n.isinf(y) | (y <= 0.0) | n.isnan(yerr) | n.isinf(yerr)\n\t\t# creating new arrays\n\t\tx = x[(UV_mask)&(veto_sky==False)&(bad_data==False)&(veto_line_abs==False)&(veto_line_em==False)] \n\t\ty = y[(UV_mask)&(veto_sky==False)&(bad_data==False)&(veto_line_abs==False)&(veto_line_em==False)] \n\t\tyerr = yerr[(UV_mask)&(veto_sky==False)&(bad_data==False)&(veto_line_abs==False)&(veto_line_em==False)] \n\t\t\n\t\tout=n.polyfit(x, y, degree, w=1/yerr)\n\t\treturn out\n\n\tdef createStackMatrix_Weighted(self):\n\t\t\"\"\"\n\t\tFunction that constructs the stack matrix UV normed\n\t\t\"\"\"\n\t\t# loop over the file with N sorted with luminosity\n\t\tspecMatrix, specMatrixErr, specMatrixWeight=[],[],[]\n\t\tprint('plate, mjd, fiber, z, weights',self.plates[:10], self.mjds[:10], self.fiberids[:10], self.redshifts[:10], self.weights[:10])\n\t\tfor plate, mjd, fiber, redshift, weight in zip(self.plates, self.mjds, self.fiberids, self.redshifts, self.weights):\n\t\t\ttry:\n\t\t\t\t#print(plate, mjd, fiber, redshift)\n\t\t\t\tif plate > 3006 :\n\t\t\t\t\tpath_to_spectrum = get_path_to_spectrum_v5_13_0(plate, mjd, fiber)\n\t\t\t\telse:\n\t\t\t\t\tpath_to_spectrum = get_path_to_spectrum_26(plate, mjd, fiber)\n\t\t\t\t\t\n\t\t\t\tif os.path.isfile(path_to_spectrum):\n\t\t\t\t\tself.getSpectra(path_to_spectrum)\n\t\t\t\t\tpts,ptsErr = self.convertSpectrum(redshift)\n\t\t\t\t\tspecMatrix.append(pts)\n\t\t\t\t\tspecMatrixErr.append(ptsErr)\n\t\t\t\t\tspecMatrixWeight.append(n.ones_like(pts)*weight)\n\t\t\t\telse: # for ELG spectra in v5_10_7\n\t\t\t\t\tpath_to_spectrum = get_path_to_spectrum_v5_13_0(plate, mjd, fiber)\n\t\t\t\t\tif os.path.isfile(path_to_spectrum):\n\t\t\t\t\t\tself.getSpectra(path_to_spectrum)\n\t\t\t\t\t\tpts,ptsErr = self.convertSpectrum(redshift)\n\t\t\t\t\t\tspecMatrix.append(pts)\n\t\t\t\t\t\tspecMatrixErr.append(ptsErr)\n\t\t\t\t\t\tspecMatrixWeight.append(n.ones_like(pts)*weight)\n\t\t\texcept(ValueError,FileNotFoundError):\n\t\t\t\tprint('value / file not found error !',plate, mjd, fiber)\n\n\t\tspecMatrixWeight=n.array(specMatrixWeight)\n\t\tspecMatrix=n.array(specMatrix)\n\t\tspecMatrixErr=n.array(specMatrixErr)\n\t\tn.savetxt(self.out_file+'.specMatrix.dat', specMatrix)\n\t\tn.savetxt(self.out_file+'.specMatrixErr.dat', specMatrixErr)\n\t\tn.savetxt(self.out_file+'.specMatrixWeight.dat', specMatrixWeight)\n\t\n\tdef createStackMatrix(self):\n\t\t\"\"\"\n\t\tFunction that constructs the stack matrix UV normed\n\t\t\"\"\"\n\t\t# loop over the file with N sorted with luminosity\n\t\tspecMatrix, specMatrixErr, specMatrixWeight=[],[],[]\n\t\tprint(self.plates, self.mjds, self.fiberids, self.redshifts)\n\t\tfor plate, mjd, fiber, redshift in zip(self.plates, self.mjds, self.fiberids, self.redshifts):\n\t\t\ttry:\n\t\t\t\tprint(plate, mjd, fiber, redshift)\n\t\t\t\tif plate > 3006 :\n\t\t\t\t\tpath_to_spectrum = get_path_to_spectrum_v5_13_0(plate, mjd, fiber)\n\t\t\t\telse:\n\t\t\t\t\tpath_to_spectrum = get_path_to_spectrum_26(plate, mjd, fiber)\n\t\t\t\t\t\n\t\t\t\tif os.path.isfile(path_to_spectrum):\n\t\t\t\t\tself.getSpectra(path_to_spectrum)\n\t\t\t\t\tpts,ptsErr = self.convertSpectrum(redshift)\n\t\t\t\t\tspecMatrix.append(pts)\n\t\t\t\t\tspecMatrixErr.append(ptsErr)\n\t\t\t\t\tweight=1.\n\t\t\t\t\tspecMatrixWeight.append(n.ones_like(pts)*weight)\n\t\t\t\telse: # for ELG spectra in v5_10_7\n\t\t\t\t\tpath_to_spectrum = get_path_to_spectrum_v5_13_0(plate, mjd, fiber)\n\t\t\t\t\tif os.path.isfile(path_to_spectrum):\n\t\t\t\t\t\tself.getSpectra(path_to_spectrum)\n\t\t\t\t\t\tpts,ptsErr = self.convertSpectrum(redshift)\n\t\t\t\t\t\tspecMatrix.append(pts)\n\t\t\t\t\t\tspecMatrixErr.append(ptsErr)\n\t\t\t\t\t\tweight=1.\n\t\t\t\t\t\tspecMatrixWeight.append(n.ones_like(pts)*weight)\n\t\t\texcept(ValueError,FileNotFoundError):\n\t\t\t\tprint('value / file not found error !',plate, mjd, fiber)\n\n\t\tspecMatrixWeight=n.array(specMatrixWeight)\n\t\tspecMatrix=n.array(specMatrix)\n\t\tspecMatrixErr=n.array(specMatrixErr)\n\t\tn.savetxt(self.out_file+'.specMatrix.dat', specMatrix)\n\t\tn.savetxt(self.out_file+'.specMatrixErr.dat', specMatrixErr)\n\t\tn.savetxt(self.out_file+'.specMatrixWeight.dat', specMatrixWeight)\n\t\n\tdef createStackMatrix_UVnormed(self):\n\t\t\"\"\"\n\t\tFunction that constructs the stack matrix UV normed\n\t\t\"\"\"\n\t\t# loop over the file with N sorted with luminosity\n\t\tspecMatrix, specMatrixErr, specMatrixWeight=[],[],[]\n\t\t\n\t\tfor plate, mjd, fiber, redshift in zip(self.plates, self.mjds, self.fiberids, self.redshifts):\n\t\t\ttry:\n\t\t\t\t#print(plate, mjd, fiber, redshift)\n\t\t\t\tif plate > 3006 :\n\t\t\t\t\tpath_to_spectrum = get_path_to_spectrum_v5_13_0(plate, mjd, fiber)\n\t\t\t\telse:\n\t\t\t\t\tpath_to_spectrum = get_path_to_spectrum_26(plate, mjd, fiber)\n\t\t\t\tif os.path.isfile(path_to_spectrum):\n\t\t\t\t\tself.getSpectra(path_to_spectrum)\n\t\t\t\t\tpts,ptsErr = self.convertSpectrum(redshift)\n\t\t\t\t\tpfit = self.fit_UV_continuum(self.wave, pts ,ptsErr)\n\t\t\t\t\tFcont = n.polyval(pfit, self.wave)\n\t\t\t\t\tspecMatrix.append(pts/Fcont)\n\t\t\t\t\tspecMatrixErr.append(ptsErr/Fcont)\n\t\t\t\t\tspecMatrix.append(pts)\n\t\t\t\t\tspecMatrixErr.append(ptsErr)\n\t\t\t\t\tweight=1.\n\t\t\t\t\tspecMatrixWeight.append(n.ones_like(pts)*weight)\n\t\t\t\telse: # get ELG spectra in v5_10_7\n\t\t\t\t\tpath_to_spectrum = get_path_to_spectrum_v5_13_0(plate, mjd, fiber)\n\t\t\t\t\tif os.path.isfile(path_to_spectrum):\n\t\t\t\t\t\tself.getSpectra(path_to_spectrum)\n\t\t\t\t\t\tpts,ptsErr = self.convertSpectrum(redshift)\n\t\t\t\t\t\tpfit = self.fit_UV_continuum(self.wave, pts ,ptsErr)\n\t\t\t\t\t\tFcont = n.polyval(pfit, self.wave)\n\t\t\t\t\t\tspecMatrix.append(pts/Fcont)\n\t\t\t\t\t\tspecMatrixErr.append(ptsErr/Fcont)\n\t\t\t\t\t\tspecMatrix.append(pts)\n\t\t\t\t\t\tspecMatrixErr.append(ptsErr)\n\t\t\t\t\t\tweight=1.\n\t\t\t\t\t\tspecMatrixWeight.append(n.ones_like(pts)*weight)\n\n\t\t\texcept(ValueError,TypeError,FileNotFoundError):\n\t\t\t\tprint('value or type error !',plate, mjd, fiber)\n\n\t\tspecMatrixWeight=n.array(specMatrixWeight)\n\t\tspecMatrix=n.array(specMatrix)\n\t\tspecMatrixErr=n.array(specMatrixErr)\n\t\tn.savetxt(self.out_file+'.specMatrix.dat', specMatrix)\n\t\tn.savetxt(self.out_file+'.specMatrixErr.dat', specMatrixErr)\n\t\tn.savetxt(self.out_file+'.specMatrixWeight.dat', specMatrixWeight)\n\n\tdef stackSpectra(self):\n\t\t\"\"\"\n\t\tStacks\n\t\t\"\"\"\n\t\t# loop over the file with N sorted with luminosity\n\t\tself.specMatrix = n.loadtxt(self.out_file+'.specMatrix.dat')\n\t\t#specMatrixErr = n.loadtxt(self.out_file+'.specMatrixErr.dat')\n\t\tself.specMatrixWeight = n.loadtxt(self.out_file+'.specMatrixWeight.dat')\n\t\tprint( \"now stacks\" )\n\t\t#wavelength, medianStack, meanStack, meanWeightedStack, jackknifStackErrors, jackknifeSpectra, NspectraPerPixel = self.stack_function( specMatrix ,specMatrixWeight)\n\t\t#cols = fits.ColDefs([wavelength, medianStack, meanStack, meanWeightedStack, jackknifStackErrors, jackknifeSpectra, NspectraPerPixel])\n\t\twavelength, medianStack, meanStack, jackknifStackErrors, jackknifeSpectra, NspectraPerPixel = self.stack_function( self.specMatrix ,self.specMatrixWeight)\n\t\tcols = fits.ColDefs([wavelength, medianStack, meanStack, jackknifStackErrors, jackknifeSpectra, NspectraPerPixel])\n\t\ttbhdu = fits.BinTableHDU.from_columns(cols)\n\t\tprihdr = fits.Header()\n\t\tprihdr['author'] = \"JC\"\n\t\tprihdr['survey'] = self.survey\n\t\tprihdr['in_file'] = os.path.basename(self.in_file)[:-4]\n\t\tprihdr['Nspec'] = len(self.plates)\n\t\tprihdu = fits.PrimaryHDU(header=prihdr)\n\t\tthdulist = fits.HDUList([prihdu, tbhdu])\n\t\tif os.path.isfile(self.out_file):\n\t\t\tos.remove(self.out_file)\n\t\tprint( \"stack written to\", self.out_file )\n\t\tthdulist.writeto(self.out_file)\n\t", "meta": {"hexsha": "e7a85e228e29a6e770e34a94edfe4219e7ff9694", "size": 15287, "ext": "py", "lang": "Python", "max_stars_repo_path": "galaxy/python/SpectraStackingEBOSS.py", "max_stars_repo_name": "AndresSixtos/pyeBOSS", "max_stars_repo_head_hexsha": "4750908c8bc409633bef8f790133e3a1f3f0c9e4", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "galaxy/python/SpectraStackingEBOSS.py", "max_issues_repo_name": "AndresSixtos/pyeBOSS", "max_issues_repo_head_hexsha": "4750908c8bc409633bef8f790133e3a1f3f0c9e4", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "galaxy/python/SpectraStackingEBOSS.py", "max_forks_repo_name": "AndresSixtos/pyeBOSS", "max_forks_repo_head_hexsha": "4750908c8bc409633bef8f790133e3a1f3f0c9e4", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.8098958333, "max_line_length": 166, "alphanum_fraction": 0.7070713678, "include": true, "reason": "import numpy,from scipy,import astropy", "num_tokens": 4797, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.1969659356847176}} {"text": "'''\nAndrew Till\nSummer 2014\n\nUtility functions for materials.\n\nReferences:\nmcnp5: MCNP 5 Manual, Volume I, LA-UR-03-1987, Appendix G (MCNP Data Libraries, including S(alpha,beta))\nmcnpdata: Listing of Available ACE Data Tables [for MCNP6], LA-UR-13-21822 (An updated version of the above)\nnjoy2012: The NJOY Nuclear Data Processing System, Version 2012, LA-UR-12-27079 (NJOY 2012 manual)\nendf6: ENDF-6 Formats Manual, BNL-90365-2009 Rev.2 (Description of the ENDF-6 format)\n\nNaming conventions:\n'Thermal name' is specified in materials_materials.py and applies to a material (e.g., ZrH is 'zrh').\n'Element thermal name' includes the (bound) thermal treatment of the material and the applicable \n element (e.g., H in Zr is 'hzrh'). Uses Hollerith strings specified in Table 21 of MATXSR chapter\n in NJOY manual (ref: njoy2012).\n Elsewhere, this is called Sab.\n'Thermal XS name' includes the (bound) thermal treatment of the material, the applicable element,\n and the applicable type of thermal XS (e.g., the inelastic bound thermal XS for H in ZrH is 'hzrhinel')\n'MCNP thermal name' is the string used by MCNP to refer to a bound thermal treatment of a material along\n with a consituent element (e.g., the bound thermal XS for H in ZrH is 'h/zr')\nNB: 'free' is used for thermal name, element thermal name, and thermal xs name for free-gas thermal \n treatment\nNB: ''/None/'none' is used for thermal name; 'none' is used for element thermal name; [] is used\n for the thermal xs list (for no thermal treatment)\n'''\n\n#TPL\nimport numpy as np\n\n###############################################################################\ndef get_nearest_points(value, sortedArray):\n '''If value in sortedArray, return [value], else return two nearest points in sortedArray'''\n nearestIndex = np.argmin(np.abs(sortedArray - value))\n nearestPoints = [sortedArray[nearestIndex]]\n lastIndex = len(sortedArray) - 1\n if value < sortedArray[nearestIndex] and nearestIndex != 0:\n nearestPoints.append(sortedArray[nearestIndex-1])\n elif value > sortedArray[nearestIndex] and nearestIndex != lastIndex:\n nearestPoints.append(sortedArray[nearestIndex+1])\n return nearestPoints\n\ndef thin_list(inList, useLinSpacing=True):\n '''Thin a list by returning the value of the point which is nearest to its two neighbors.'''\n sortedList = np.array(sorted(inList))\n # Use [2:] and [:-2] to get sum of distances to neighbors. Add 1 for the indexing to be correct.\n if useLinSpacing:\n distance = sortedList[2:] - sortedList[:-2]\n else:\n distance = sortedList[2:] / sortedList[:-2]\n index = np.argmin(distance) + 1\n return sortedList[index]\n\n###############################################################################\ndef calc_chord_length(fuelRadius):\n if fuelRadius == 'unshielded':\n return 1.e10\n elif fuelRadius:\n surfaceArea = 2 * np.pi * fuelRadius\n volume = np.pi * fuelRadius * fuelRadius\n chordLength = surfaceArea / (4 * volume)\n return chordLength\n else:\n return 0.0\n\ndef has_bondarenko_iteration(Z):\n if Z <= 5:\n return False\n else:\n return True\n\ndef is_fissionable((Z,A)):\n if Z >= 89:\n return True\n elif (Z,A) in [(88, 223), (88, 226)]:\n return True\n else:\n return False\n\ndef avogadros_number():\n '''In units of atoms / mole, but multiplied by 1E-24'''\n return 0.60221413\n \ndef get_inelastic_thermal_mt_list():\n '''Ref: Culled from Table 4 in the NJOY manual (ref: njoy2012)'''\n return set([221, 222, 223, 225, 227, 228, 229, 231, 233, 235, 237, 239, 241, 243, 245])\n\n###############################################################################\ndef format_zaid():\n '''Use format_ZAID()(**dict) to apply to a dictionary'''\n return '{Z:d}{A:03d}'.format\n\ndef format_zaid_leading_zeros():\n return '{Z:02d}{A:03d}'.format\n\ndef format_thermal_filename():\n return 'endf_th_{Z:02d}_{thermalName}_vii1'.format\n\ndef get_nuclide_dirr(sym, A, elementThermalName, metastableStr=''):\n '''Returns the directory name for a nuclide'''\n nuclideName = '{0}-{1}{2}'.format(sym.lower(), A, metastableStr)\n et2t = get_element_thermal_name_to_thermal_name_dict()\n if elementThermalName in et2t:\n thermalName = et2t[elementThermalName]\n nuclideName = '{0}-{1}'.format(nuclideName, thermalName)\n return nuclideName\n\ndef get_ace_extension(elementThermalName):\n '''Returns the ACE extension given an element thermal name. The extension is 9 (as in .90c)\n if the *nuclide* does not have a bound thermal treatment.'''\n if elementThermalName in get_non_bound_names():\n return 9\n else:\n et2t = get_element_thermal_name_to_thermal_name_dict()\n t2ext = get_thermal_name_to_ace_ext_dict()\n return t2ext[et2t[elementThermalName]]\n\n###############################################################################\ndef get_thermal_name_to_element_thermal_name_dict():\n '''Returns a dict that maps tuple (Z, thermal_name) to element thermal name (a Hollerith string).\n Free thermal treatment is not in dict'''\n return {(1,'poly'): 'hpoly', (1,'h2o'): 'hh2o', (8,'uo2'): 'ouo2', (92,'uo2'): 'uuo2', (1,'zrh'): 'hzrh', (40,'zrh'): 'zrzrh', (6,'graphite'): 'graph', (13,'al'): 'al', (26,'fe'): 'fe'}\n\ndef get_element_thermal_name_to_nuclide_list_dict():\n '''Returns a dict that maps element thermal name to the (Z,A)'s of the nuclides to which it applies.\n Free thermal treatment is not in dict. Ref: mcnp5, mcnpdata'''\n return {'hpoly': [(1,1)], 'hh2o': [(1,1)], 'ouo2': [(8,16), (8,17), (8,18)], 'uuo2': [(92,238)], 'hzrh': [(1,1)], 'zrzrh': [(40,0), (40,90), (40,91), (40,92), (40,94), (40,96)], 'graph': [(6,0), (6,12)], 'al': [(13,27)], 'fe': [(26,56)]}\n\ndef get_element_thermal_name_to_inelastic_mt_number_dict():\n '''Returns a dict that maps element thermal name to the MT number corresponding to the\n inelastic thermal XS for that element thermal name. See Tables 4 and 25 in NJOY manual (ref: njoy2012).\n Should correspond to 'inel' endf numbers in Readgroupr.py's get_endf_mt_list() function.'''\n return {'free': 221, 'hh2o': 222, 'hpoly': 223, 'ouo2': 239, 'uuo2': 241, 'hzrh': 225, 'zrzrh': 235, 'graph': 229, 'al': 243, 'fe': 245}\n\ndef get_thermal_name_to_nuclide_list_dict():\n '''Returns a dict that maps thermal name to the (Z,A)'s of the nuclides to which it applies.\n Free thermal treatment is not in dict'''\n # Derive this dictionary from previous information\n Zthermal2elem = get_thermal_name_to_element_thermal_name_dict()\n elem2ZAs = get_element_thermal_name_to_nuclide_list_dict() \n # First, initialize each thermal name as an empty set of nuclides\n thermal2ZAs = {}\n for (Z,thermalName) in Zthermal2elem:\n thermal2ZAs[thermalName] = set()\n # Then, populate nuclides that correspond to that thermal name\n for (Z,thermalName) in Zthermal2elem:\n elem = Zthermal2elem[(Z,thermalName)]\n ZAList = elem2ZAs[elem]\n thermal2ZAs[thermalName].update(ZAList)\n return thermal2ZAs\n\ndef get_element_thermal_name_to_thermal_name_dict():\n '''Returns a dict that maps element thermal name (e.g., hh2o) to thermal name (h2o).\n Free thermal treatment is not in dict.'''\n # Derive this dictionary from previous information\n return {et: t for (Z,t), et in get_thermal_name_to_element_thermal_name_dict().items()}\n\n###############################################################################\ndef get_non_bound_names():\n '''Returns a set of thermal names that do not use bound cross sections'''\n return set(['free', '', None, 'none'])\n\ndef get_element_thermal_name_to_thermal_xs_list_dict():\n '''Returns a dict that maps element thermal name to a list of thermal XS names.\n See Tables 4 and 25 in NJOY manual (ref: njoy2012)'''\n return {'free': ['free'], 'none': [], 'hpoly': ['hpolyinel', 'hpolyelas'], 'hh2o': ['hh2o'], 'ouo2': ['ouo2inel', 'ouo2elas'], 'uuo2': ['uuo2inel', 'uuo2elas'], 'hzrh': ['hzrhinel', 'hzrhelas'], 'zrzrh': ['zrzrhinel', 'zrzrhelas'], 'graph': ['graphinel', 'graphelas'], 'al': ['alinel', 'alelas'], 'fe': ['feinel', 'feelas'],}\n\ndef get_element_thermal_name_to_mat_number_dict():\n '''Returns a dict that maps element thermal name to thermal MAT number.\n See Table 4 in THERMR chapter of NJOY manual (ref: njoy2012).\n Change: Manuals say Al is material 45, but the data file has material 53'''\n return {'free': 0, 'none': 0, 'hpoly': 37, 'hh2o': 1, 'ouo2': 75, 'uuo2': 48, 'hzrh': 7, 'zrzrh': 58, 'graph': 31, 'al': 53, 'fe': 56}\n\ndef get_element_thermal_name_to_bnl_id_dict():\n '''Returns a dict that maps element thermal name to BNL's ID. Used in URL for automatic downloads.\n Free thermal treatment not in dict. \n Can be check at http://www.nndc.bnl.gov/sigma/tree/index.html. Last verified: 05/31/2016.'''\n return {'hpoly': 15390, 'hh2o': 15391, 'ouo2': 15395, 'uuo2': 15402, 'hzrh': 15392, 'zrzrh': 15403, 'graph': 15389, 'al': 15383, 'fe': 15384}\n \ndef get_element_thermal_name_to_endf_filename_dict():\n '''Returns a dict that maps element thermal name to bound thermal ENDF file name'''\n # Derive this dictionary from previous information\n ZName2elem = get_thermal_name_to_element_thermal_name_dict()\n ZName2filename = format_thermal_filename()\n elem2filename = {}\n for (Z,thermalName) in ZName2elem:\n elem = ZName2elem[(Z,thermalName)]\n elem2filename[elem] = ZName2filename(Z=Z, thermalName=thermalName) \n for key in ['free', None]:\n elem2filename[key] = None\n return elem2filename\n\n###############################################################################\ndef get_thermal_name_to_ace_ext_dict():\n '''Returns a dict that maps thermal name to ACE extension (e.g., the 9 in 1001.92c).\n Reasonable extension options include poly (CH2) being 6, benzene (C6H6) being 7, and d2o (D2O) being 8, though these are currently unsupported'''\n return {'h2o': 0, 'uo2': 1, 'zrh': 2, 'graphite': 3, 'al': 4, 'fe': 5, 'free': 9}\n\ndef get_element_thermal_name_to_mcnp_thermal_name_dict():\n '''Returns a dict that maps element thermal name to MCNP thermal material name. Ref: mcnp5, mcnpdata'''\n return {'hpoly': 'poly', 'hh2o': 'lwtr', 'zrzrh': 'zr/h', 'hzrh': 'h/zr', 'uuo2': 'u/o2', 'ouo2': 'o2/u', 'graph': 'grph', 'fe': 'fe56', 'al': 'al27'}\n\ndef get_mcnp_thermal_name_to_main_za_dict():\n '''Returns a dict that maps MCNP bound thermal material name to the (Z,A) of the nuclide from which to read PENDF tape (for ACE only). Uses nuclide with highest atom fraction.'''\n return {'poly': (1,1), 'lwtr': (1,1), 'o2/u': (8,16), 'u/o2': (92,238), 'grph': (6,0), 'h/zr': (1,1), 'zr/h': (40,90), 'al27': (13,27), 'fe56': (26,56), }\n\ndef get_mcnp_thermal_name_to_zaid_list_dict():\n '''Returns a dict that maps MCNP bound thermal material name to a ZZAAA string of the nuclides that use this thermal option. Ref: mcnp5, mcnpdata'''\n # Derive this dictionary from previous information\n elem2mcnp = get_element_thermal_name_to_mcnp_thermal_name_dict()\n elem2ZAs = get_element_thermal_name_to_nuclide_list_dict() \n ZA2zaid = format_zaid()\n mcnp2zaid = {}\n for elem in elem2mcnp:\n mcnpName = elem2mcnp[elem]\n ZAList = elem2ZAs[elem]\n zaidList = [ZA2zaid(Z=Z, A=A) for (Z,A) in ZAList]\n mcnp2zaid[mcnpName] = zaidList\n return mcnp2zaid\n \n###############################################################################\ndef print_newline(verbosity=False):\n if verbosity:\n print ''\n", "meta": {"hexsha": "3bf5d14972799f466225f97e763fa93c28e956cc", "size": 11593, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/materials_util.py", "max_stars_repo_name": "attom/barnfire", "max_stars_repo_head_hexsha": "6c9fd7c3ef481ada2a31c8618cfb2a33e135b6ef", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2016-09-27T07:25:32.000Z", "max_stars_repo_stars_event_max_datetime": "2016-09-27T07:25:32.000Z", "max_issues_repo_path": "src/materials_util.py", "max_issues_repo_name": "attom/barnfire", "max_issues_repo_head_hexsha": "6c9fd7c3ef481ada2a31c8618cfb2a33e135b6ef", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2016-02-21T18:26:32.000Z", "max_issues_repo_issues_event_max_datetime": "2016-02-21T22:14:41.000Z", "max_forks_repo_path": "src/materials_util.py", "max_forks_repo_name": "attom/barnfire", "max_forks_repo_head_hexsha": "6c9fd7c3ef481ada2a31c8618cfb2a33e135b6ef", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2018-01-23T23:13:36.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-29T17:03:42.000Z", "avg_line_length": 51.296460177, "max_line_length": 329, "alphanum_fraction": 0.6519451393, "include": true, "reason": "import numpy", "num_tokens": 3355, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.1969659356847176}} {"text": "\"\"\" Methods related to galaxy photometry \"\"\"\n\nimport os\nimport warnings\nimport numpy as np\n\nfrom pkg_resources import resource_filename\n\nfrom IPython import embed\n\nfrom astropy.io import fits\nfrom astropy.table import Table, hstack, vstack, join\nfrom astropy.coordinates import SkyCoord\nfrom astropy.coordinates import match_coordinates_sky\nfrom astropy import units\nfrom astropy.cosmology import Planck15 as cosmo\nfrom astropy.wcs import utils as wcs_utils\nfrom astropy.nddata import Cutout2D\nfrom astropy.wcs import WCS\nfrom astropy import stats\n\nfrom photutils import SkyCircularAperture\nfrom photutils import aperture_photometry\n\nfrom frb.galaxies import defs\n\ntry:\n import extinction\nexcept ImportError:\n print(\"extinction package not loaded. Extinction corrections will fail\")\n\n# Photometry globals\ntable_format = 'ascii.fixed_width'\nfill_values_list = [('-999', '0'), ('-999.0', '0')]\nfill_value = -999.\n\ndef merge_photom_tables(new_tbl, old_file, tol=1*units.arcsec, debug=False):\n \"\"\"\n Merge photometry tables\n\n Args:\n new_tbl (astropy.table.Table):\n New table of photometry\n old_file (str or Table):\n Path to the old table\n\n Returns:\n astropy.table.Table:\n Merged tables\n\n \"\"\"\n # File or tbl?\n if isinstance(old_file, str):\n # New file?\n if not os.path.isfile(old_file):\n return new_tbl\n # Load me\n old_tbl = Table.read(old_file, format=table_format)\n elif isinstance(old_file, Table):\n old_tbl = old_file\n else:\n embed(header='42 of photom')\n # Coords\n new_coords = SkyCoord(ra=new_tbl['ra'], dec=new_tbl['dec'], unit='deg')\n old_coords = SkyCoord(ra=old_tbl['ra'], dec=old_tbl['dec'], unit='deg')\n idx, d2d, _ = match_coordinates_sky(new_coords, old_coords, nthneighbor=1)\n match = d2d < tol\n\n\n # Match?\n if np.sum(match) == len(new_coords):\n # Insist on the same RA, DEC\n new_tbl['ra'] = old_tbl['ra'][idx[0]]\n new_tbl['dec'] = old_tbl['dec'][idx[0]]\n # Join\n merge_tbl = hstack([old_tbl.filled(-999.), new_tbl.filled(-999.)])\n merge_tbl.remove_columns(['ra_2', 'dec_2'])\n merge_tbl.rename_columns(['ra_1', 'dec_1'], ['ra', 'dec'])\n #merge_tbl = join(old_tbl.filled(-999.), new_tbl, join_type='left').filled(-999.)\n elif np.sum(match) == 0:\n merge_tbl = vstack([old_tbl, new_tbl]).filled(-999.)\n else:\n embed(header='50 of photom') # Best to avoid!! Use photom_by_name\n # Return\n return merge_tbl\n\ndef photom_by_name(name, filelist):\n \"\"\"\n Generate a Table for a given galaxy from a list of photom files\n\n Warning: Order matters! Use best data last\n\n Args:\n name (str):\n filelist (list):\n\n Returns:\n astropy.table.Table:\n\n \"\"\"\n # Loop on tables\n final_tbl = None\n for ifile in filelist:\n # Load an insure it is a masked Table\n tbl = Table(Table.read(ifile, format=table_format, fill_values=fill_values_list), masked=True)\n idx = tbl['Name'] == name\n if np.sum(idx) == 1:\n sub_tbl = tbl[idx]\n if final_tbl is None:\n final_tbl = sub_tbl\n else:\n for key in sub_tbl.keys():\n if sub_tbl[key].mask != True: # Cannot use \"is\"\n final_tbl[key] = sub_tbl[key]\n # Return\n return final_tbl.filled(fill_value)\n\n\ndef extinction_correction(filt, EBV, RV=3.1, max_wave=None, required=True):\n \"\"\"\n calculate MW extinction correction for given filter\n\n Uses the Fitzpatrick & Massa (2007) extinction law\n\n Args:\n filt (str):\n filter name (name of file without .dat extension)\n EBV (float):\n E(B-V) (can get from frb.galaxies.nebular.get_ebv which uses IRSA Dust extinction query\n RV:\n from gbrammer/threedhst eazyPy.py -- characterizes MW dust\n max_wave (float, optional):\n If set, cut off the calculation at this maximum wavelength.\n A bit of a hack for the near-IR, in large part because the\n MW extinction curve ends at 1.4 microns.\n required (bool, optional):\n Crash out if the transmission curve is not present\n\n Returns:\n float: linear extinction correction\n\n \"\"\"\n # Read in filter in Table\n path_to_filters = os.path.join(resource_filename('frb', 'data'), \n 'analysis', 'CIGALE')\n # Hack for LRIS which does not differentiate between cameras\n if 'LRIS' in filt:\n _filter = 'LRIS_{}'.format(filt[-1])\n else:\n _filter = filt\n filter_file = os.path.join(path_to_filters, _filter+'.dat')\n if not os.path.isfile(filter_file):\n msg = \"Filter {} is not in the Repo. Add it!!\".format(filter_file)\n if required:\n raise IOError(msg)\n else:\n warnings.warn(msg)\n return 1.\n filter_tbl = Table.read(filter_file, format='ascii')\n\n #get wave and transmission (file should have these headers in first row)\n wave = filter_tbl['col1'].data\n throughput = filter_tbl['col2'].data\n\n if max_wave:\n warnings.warn(\"Cutting off the extinction correction calculation at {} Ang\".format(max_wave))\n gdwv = wave < max_wave\n wave = wave[gdwv]\n throughput = throughput[gdwv]\n\n #get MW extinction correction\n AV = EBV * RV\n #AlAV = nebular.load_extinction('MW')\n Alambda = extinction.fm07(wave, AV)\n source_flux = 1.\n\n #calculate linear correction\n delta = np.trapz(throughput * source_flux * 10 ** (-0.4 * Alambda), wave) / np.trapz(\n throughput * source_flux, wave)\n\n correction = 1./delta\n\n return correction\n\n\ndef correct_photom_table(photom, EBV, name, max_wave=None, required=True):\n \"\"\"\n Correct the input photometry table for Galactic extinction\n Table is modified in place\n\n If there is SDSS photometry, we look for the extinction values\n provided by the Survey itself.\n\n Uses extinction_correction()\n\n Args:\n photom (astropy.table.Table):\n EBV (float):\n E(B-V) (can get from frb.galaxies.nebular.get_ebv which uses IRSA Dust extinction query\n name (str):\\\n Name of the object to correct\n required (bool, optional):\n Crash out if the transmission curve is not present\n\n \"\"\"\n # Cut the table\n mt_name = photom['Name'] == name\n if not np.any(mt_name):\n print(\"No matches to input name={}. Returning\".format(name))\n return\n elif np.sum(mt_name) > 1:\n raise ValueError(\"More than 1 match to input name={}. Bad idea!!\".format(name))\n idx = np.where(mt_name)[0][0]\n cut_photom = photom[idx] # This is a Row\n\n # Dust correct\n for key in photom.keys():\n if key in ['Name', 'ra', 'dec', 'extinction', 'SDSS_ID',\n 'run', 'rerun'] or 'err' in key:\n continue\n filt = key\n if filt not in defs.valid_filters:\n print(\"Assumed filter {} is not in our valid list. Skipping extinction\".format(\n filt))\n continue\n # -999? -- Not even measured\n try:\n if cut_photom[filt] <= -999.:\n continue\n except:\n embed(header='187 in photom')\n # SDSS\n if 'SDSS' in filt:\n if 'extinction_{}'.format(filt[-1]) in photom.keys():\n print(\"Appying SDSS-provided extinction correction\")\n cut_photom[key] -= cut_photom['extinction_{}'.format(filt[-1])]\n continue\n # Hack for LRIS\n if 'LRIS' in filt:\n _filter = 'LRIS_{}'.format(filt[-1])\n else:\n _filter = filt\n # Do it\n dust_correct = extinction_correction(_filter, EBV, max_wave=max_wave, \n required=required)\n mag_dust = 2.5 * np.log10(1. / dust_correct)\n cut_photom[key] += mag_dust\n # Add it back in\n photom[idx] = cut_photom\n\ndef sb_at_frb(host, cut_dat:np.ndarray, cut_err:np.ndarray, wcs:WCS, \n fwhm=3., physical=False, min_uncert=2):\n \"\"\" Measure the surface brightness at an FRB location\n in a host galaxy\n\n Args:\n host (Host object): host galaxy object from frb repo\n cut_dat (np.ndarray): data (data from astorpy 2D Cutout object)\n cut_err (np.ndarray): inverse variance of data (from astropy 2D Cutout object)\n wcs (WCS): WCS for the cutout\n fwhm (float, optional): FWHM of the PSF of the image in either\n pixels or kpc. Defaults to 3 [pix].\n physical (bool, optional): If True, FWHM is in kpc. Defaults to False.\n min_uncert (int, optional): Minimum localization unceratainty\n for the FRB, in pixels. Defaults to 2.\n\n Returns:\n tuple: sb_average, sb_average_err [counts/sqarcsec]\n \"\"\"\n # Generate the x,y grid of coordiantes\n x = np.arange(np.shape(cut_dat)[0])\n y = np.arange(np.shape(cut_dat)[1])\n xx, yy = np.meshgrid(x, y)\n coords = wcs_utils.pixel_to_skycoord(xx, yy, wcs)\n xfrb, yfrb = wcs_utils.skycoord_to_pixel(host.frb.coord, wcs)\n plate_scale = coords[0, 0].separation(coords[0, 1]).to('arcsec').value\n\n # Calculate total a, b uncertainty (FRB frame)\n uncerta, uncertb = host.calc_tot_uncert()\n\n # Put in pixel space\n uncerta /= plate_scale \n uncertb /= plate_scale \n\n # Set a minimum threshold\n uncerta = max(uncerta, min_uncert)\n uncertb = max(uncertb, min_uncert)\n \n # check if in ellipse -- pixel space!\n theta = host.frb.eellipse['theta']\n in_ellipse = ((xx - xfrb.item()) * np.cos(theta) + \n (yy - yfrb.item()) * np.sin(theta)) ** 2 / (uncerta ** 2) + (\n (xx - xfrb.item()) * np.sin(theta) - (\n yy - yfrb.item()) * np.cos(theta)) ** 2 / (uncertb ** 2) <= 1\n idx = np.where(in_ellipse)\n xval = xx[idx]\n yval = yy[idx]\n\n # x, y gal on the tilted grid (same for frb coords)\n xp = yval * np.cos(theta) - xval * np.sin(theta)\n yp = xval * np.cos(theta) + yval * np.sin(theta)\n\n xpfrb = yfrb.item() * np.cos(theta) - xfrb.item() * np.sin(theta)\n ypfrb = xfrb.item() * np.cos(theta) + yfrb.item() * np.sin(theta)\n\n # convert fwhm from pixels to arcsec or kpc to arcsec\n if physical:\n fwhm_as = fwhm * units.kpc * cosmo.arcsec_per_kpc_proper(host.z)\n else:\n fwhm_as = fwhm * plate_scale * units.arcsec\n\n # Aperture photometry at every pixel in the ellipse\n photom = []\n photom_var = []\n for i in np.arange(np.shape(idx)[1]):\n aper = SkyCircularAperture(coords[idx[0][i], idx[1][i]], fwhm_as)\n apermap = aper.to_pixel(wcs)\n\n # aperture photometry for psf-size within the galaxy\n photo_frb = aperture_photometry(cut_dat, apermap)\n photo_err = aperture_photometry(1 / cut_err, apermap)\n\n photom.append(photo_frb['aperture_sum'][0])\n photom_var.append(photo_err['aperture_sum'][0])\n\n # ff prob distribution\n p_ff = np.exp(-(xp - xpfrb) ** 2 / (2 * uncerta ** 2)) * np.exp(\n -(yp - ypfrb) ** 2 / (2 * uncertb ** 2))\n f_weight = (photom / (np.pi * fwhm_as.value ** 2)) * p_ff # weighted photometry\n fvar_weight = (photom_var / (np.pi * fwhm_as.value ** 2)) * p_ff # weighted sigma\n\n weight_avg = np.sum(f_weight) / np.sum(p_ff) # per unit area (arcsec^2)\n\n # Errors\n weight_var_avg = np.sum(fvar_weight) / np.sum(p_ff)\n weight_err_avg = np.sqrt(weight_var_avg)\n\n\n return weight_avg, weight_err_avg\n\n\ndef fractional_flux(cutout, frbdat, hg, nsig=3.):\n \"\"\"Calculate the fractional flux at the FRB location\n\n Args:\n cutout (WCS Cutout2D): astropy 2D Cutout of data around host galaxy\n frbdat (frb.FRB): frb object loaded from frb repo\n hg (frb.galaxies.frbgalaxy.FRBHost): host galaxy object loaded from frb repo\n nsig (float, optional): sigma for FRB localization within which the measurement should be made. Defaults to 3.\n\n Returns:\n tuple: median_ff, sig_ff, ff_weight [no units]\n Median fractional flux, uncertainty\n \"\"\"\n\n # get image data from cutout\n cut_data = cutout.data\n frbcoord = frbdat.coord\n\n # shift the data to above zero (all positive values)\n shift_data = cut_data - np.min(cut_data)\n\n # make mesh grid\n if np.shape(cut_data)[0] != np.shape(cut_data)[1]:\n cut_data = np.resize(cut_data, (np.shape(cut_data)[1], np.shape(cut_data)[1]))\n x = np.arange(np.shape(cut_data)[0])\n y = np.arange(np.shape(cut_data)[1])\n xx, yy = np.meshgrid(x, y)\n coords = wcs_utils.pixel_to_skycoord(xx, yy, cutout.wcs)\n xfrb, yfrb = wcs_utils.skycoord_to_pixel(frbcoord, cutout.wcs)\n\n # Calc plate scale\n plate_scale = coords[0, 0].separation(coords[0, 1]).to('arcsec').value\n\n # get a, b, and theta from frb object -- convert to pixel space\n sig_a, sig_b = hg.calc_tot_uncert()\n # Put in pixel space\n sig_a /= plate_scale \n sig_b /= plate_scale \n\n # sigma\n a = nsig * sig_a\n if a < 1:\n print('a is less than 1!')\n a = 3\n\n b = nsig * sig_b\n if b < 1:\n print('b is less than 1!')\n b = 3\n\n\n # check if in ellipse -- pixel space!\n theta = hg.frb.eellipse['theta'] * units.deg\n in_ellipse = ((xx - xfrb.item()) * np.cos(theta).value + (yy - yfrb.item()) * np.sin(theta).value) ** 2 / (\n a ** 2) + (\n (xx - xfrb.item()) * np.sin(theta).value - (yy - yfrb.item()) * np.cos(\n theta).value) ** 2 / (\n b ** 2) <= 1\n\n #print(frbdat.FRB, a, b, np.size(cut_data), np.size(cut_data[in_ellipse]))\n\n idx = np.where(in_ellipse)\n xval = xx[idx]\n yval = yy[idx]\n\n # x, y gal\n xp = yval * np.cos(theta).value - xval * np.sin(theta).value\n yp = xval * np.cos(theta).value + yval * np.sin(theta).value\n\n xpfrb = yfrb.item() * np.cos(theta).value - xfrb.item() * np.sin(theta).value\n ypfrb = xfrb.item() * np.cos(theta).value + yfrb.item() * np.sin(theta).value\n\n # sigma clip data to exclude background\n clipp = stats.sigma_clip(shift_data, sigma=1, maxiters=5)\n mask = np.ma.getmask(clipp)\n masked_dat = shift_data[mask]\n\n # fractional flux for all values in ellipse\n fprime_inlocal = []\n for dat in shift_data[idx]:\n fprime = np.sum(shift_data[shift_data < dat]) / np.sum(shift_data)\n fprime_inlocal.append(fprime)\n\n # ff prob distribution\n p_ff = np.exp(-(xp - xpfrb) ** 2 / (2 * a ** 2)) * np.exp(-(yp - ypfrb) ** 2 / (2 * b ** 2))\n f_weight = fprime_inlocal * p_ff # weighted fractional fluxes\n\n avg_ff = np.sum(fprime_inlocal * p_ff) / np.sum(p_ff)\n var_ff = np.sum((fprime_inlocal - avg_ff) ** 2 * p_ff) / np.sum(p_ff)\n sig_ff = np.sqrt(var_ff)\n\n med_ff = np.percentile(f_weight, 50)\n l68, u68 = np.abs(np.percentile(f_weight, (16, 84)))\n\n # make array into list for writing out\n f_weight = np.array(f_weight).tolist()\n\n # return med_ff, med_flux, fprime_inlocal\n return med_ff, sig_ff, f_weight", "meta": {"hexsha": "48746601f0ee391c239f23b80de2e432f5307f7a", "size": 15154, "ext": "py", "lang": "Python", "max_stars_repo_path": "frb/galaxies/photom.py", "max_stars_repo_name": "Lachimax/FRB", "max_stars_repo_head_hexsha": "aa3bb6828db0cf81931dac35cf7bd7184fc3b598", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "frb/galaxies/photom.py", "max_issues_repo_name": "Lachimax/FRB", "max_issues_repo_head_hexsha": "aa3bb6828db0cf81931dac35cf7bd7184fc3b598", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "frb/galaxies/photom.py", "max_forks_repo_name": "Lachimax/FRB", "max_forks_repo_head_hexsha": "aa3bb6828db0cf81931dac35cf7bd7184fc3b598", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.4409090909, "max_line_length": 118, "alphanum_fraction": 0.6125115481, "include": true, "reason": "import numpy,from astropy", "num_tokens": 4190, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.38491214448393346, "lm_q1q2_score": 0.19696593568471757}} {"text": "import numpy as np\nimport util\nimport ctypes\nimport units.springel_units\nimport physicalmodels.attenuation.attenuate as atten\n\ndef checklen(x):\n return len(np.array(x,ndmin=1));\n\ndef vfloat(x):\n return x.ctypes.data_as(ctypes.POINTER(ctypes.c_float));\n\ndef fcor(x):\n return np.array(x,dtype='f',ndmin=1)\n\ndef ok_scan(input,xmax=1.0e10,pos=0):\n if (pos==1):\n return (np.isnan(input)==False) & (np.fabs(input)<=xmax) & (input > 0.);\n else:\n return (np.isnan(input)==False) & (np.fabs(input)<=xmax);\n\n\ndef get_attenuated_stellar_luminosities( BAND_IDS, star_pos, gas_pos, bh_pos, \\\n stellar_age, stellar_metallicity, stellar_mass, \\\n gas_u, gas_rho, gas_hsml, gas_numh, gas_nume, gas_metallicity, gas_mass, \\\n bh_luminosity, \\\n xrange=0, yrange=0, zrange=0, \\\n INCLUDE_BH=0, SKIP_ATTENUATION=0,\n IMF_SALPETER=0, IMF_CHABRIER=1, \\\n MIN_CELL_SIZE=0.01, OUTER_RANGE_OF_INT=1200., \\\n SCATTERED_FRACTION=0.0, \\\n REDDENING_SMC=0, REDDENING_LMC=0, REDDENING_MW=0, \\\n AGN_MARCONI=0, AGN_HRH=1, AGN_RICHARDS=0, AGN_SDSS=0 ):\n \n ## first some basic pre-processing to make sure the numbers are in order\n if ((checklen(gas_pos[0,:])==3) & (checklen(gas_pos[:,0]) !=3)): gas_pos=np.transpose(gas_pos);\n if ((checklen(star_pos[0,:])==3) & (checklen(star_pos[:,0]) !=3)): star_pos=np.transpose(star_pos);\n if (INCLUDE_BH==1):\n if ((checklen(bh_pos[0,:])==3) & (checklen(bh_pos[:,0]) !=3)): bh_pos=np.transpose(bh_pos);\n if checklen(stellar_metallicity.shape)>1: stellar_metallicity=stellar_metallicity[:,0];\n if checklen(gas_metallicity.shape)>1: gas_metallicity=gas_metallicity[:,0];\n \n gas_temp = units.springel_units.gas_code_to_temperature(gas_u,gas_nume);\n gas_metallicity[gas_temp > 1.0e6] = 0.0; ## don't allow hot gas to have dust\n \n \n ## now call the extinction calculation\n Nstar=checklen(star_pos[0,:]);\n if (SKIP_ATTENUATION==0):\n if (INCLUDE_BH==1):\n Nbh=checklen(bh_pos[0,:]);\n source_pos=np.zeros(3,Nstar+Nbh);\n for j in [0,1,2]:\n source_pos[j,0:Nstar]=star_pos[j,:];\n source_pos[j,Nstar:Nstar+Nbh]=bh_pos[j,:];\n else:\n source_pos=star_pos;\n \n LOS_NH, LOS_NH_HOT, LOS_Z = \\\n return_columns_to_sources( source_pos, gas_pos, \\\n gas_u, gas_rho, gas_hsml, gas_numh, gas_nume, gas_metallicity, gas_mass, \\\n xrange=xrange, yrange=yrange, zrange=zrange, \\\n MIN_CELL_SIZE=MIN_CELL_SIZE, OUTER_RANGE_OF_INT=OUTER_RANGE_OF_INT, \\\n TRIM_PARTICLES=1 );\n\n else: ## SKIP_ATTENUATION==1\n N_sources=checklen(star_pos[0,:]);\n if(INCLUDE_BH==1): N_sources+=checklen(bh_pos[0,:]);\n NHmin=1.0e10; LOS_NH=np.zeros(N_sources)+NHmin; LOS_NH_HOT=np.copy(LOS_NH); LOS_Z=0.*LOS_NH+1.0;\n \n print ' == ',np.median(LOS_NH),' == ',np.median(LOS_Z)\n\n\n ## alright now we're ready to get the (intrinsic) stellar luminosities\n nband=checklen(BAND_IDS); lums=np.zeros([nband,Nstar]); nu_eff_l=np.zeros([nband]);\n for i_band in range(nband):\n nu_eff_l[i_band] = colors_table(np.array([1.0]),np.array([1.0]), \\\n BAND_ID=BAND_IDS[i_band],RETURN_NU_EFF=1);\n lums[i_band,:] = stellar_mass * colors_table( stellar_age, stellar_metallicity/0.02, \\\n BAND_ID=BAND_IDS[i_band], CHABRIER_IMF=IMF_CHABRIER, SALPETER_IMF=IMF_SALPETER, CRUDE=1, \\\n UNITS_SOLAR_IN_BAND=1); ## this is such that solar-type colors appear white\n\n ## if we're using the BH, also get its luminosities at the bands of interest\n if (INCLUDE_BH==1):\n Nbh=checklen(bh_pos[0,:]); Nbands=checklen(BAND_IDS); lums_bh=np.zeros([Nbands,Nbh]);\n for i_bh in range(Nbh):\n lums_bh[:,i_bh] = util.agn_spectrum( nu_eff_l, np.log10(bh_luminosity[i_bh]), \\\n HRH=AGN_HRH,MARCONI=AGN_MARCONI,RICHARDS=AGN_RICHARDS,SDSS=AGN_SDSS );\n lums_new=np.zeros([Nbands,Nstar+Nbh]);\n for i_band in range(Nbands):\n lums_new[i_band,0:Nstar]=lums[i_band,:];\n lums_new[i_band,Nstar:Nstar+Nbh]=lums_bh[i_band,:];\n lums=lums_new\n\n\n ## call the attenuation routine to get the post-extinction luminosities\n lums_atten=1.0*lums;\n LOS_NH_TO_USE = LOS_NH;\n for i_band in range(checklen(BAND_IDS)):\n f_atten = attenuate( nu_eff_l[i_band], np.log10(LOS_NH), LOS_Z/0.02, \\\n SMC=REDDENING_SMC, LMC=REDDENING_LMC, MW=REDDENING_MW );\n lums_atten[i_band,:] = lums[i_band,:] * \\\n ((1.-SCATTERED_FRACTION)*f_atten + SCATTERED_FRACTION);\n \n return lums, lums_atten;\n\n\n\n\n##\n## return: los_NH_allgas, los_NH_hotphase, los_gas_metallicity\n##\ndef return_columns_to_sources( source_pos, gas_pos, \\\n gas_u, gas_rho, gas_hsml, gas_numh, gas_nume, gas_metallicity, gas_mass, \\\n xrange=0, yrange=0, zrange=0, \\\n MIN_CELL_SIZE=0.01, OUTER_RANGE_OF_INT=1200., \\\n TRIM_PARTICLES=1 ):\n \n ## check the ordering of the position matrices:\n if ((checklen(gas_pos[0,:])==3) & (checklen(gas_pos[:,0]) !=3)): gas_pos=np.transpose(gas_pos);\n if ((checklen(source_pos[0,:])==3) & (checklen(source_pos[:,0]) !=3)): source_pos=np.transpose(source_pos);\n ## and that metallicities are a vector, not a matrix\n if (len(gas_metallicity.shape)>1): gas_metallicity=gas_metallicity[:,0]\n \n if ((checklen(gas_pos[:,0]) != 3) | (checklen(gas_pos[0,:]) <= 1)):\n print 'ERROR WILL OCCUR :: need pos to be (3,N)'\n \n x=source_pos[0,:] ; y=source_pos[1,:] ; z=source_pos[2,:]\n if(checklen(xrange)<=1): xrange=[np.min(x),np.max(x)];\n if(checklen(yrange)<=1): yrange=[np.min(y),np.max(y)];\n xr=xrange; yr=yrange;\n if(checklen(zrange)<=1):\n zrr=np.sqrt((xr[1]-xr[0])**2.+(yr[1]-yr[0])**2.)/np.sqrt(2.);\n zmin=np.median(z)-zrr; zmax=np.median(z)+zrr;\n if (np.min(z) > zmin): zmin=np.min(z);\n zrange=[zmin,zmax]; print 'z_range (calc) == ',zrange\n zr=zrange;\n x00=0.5*(xr[1]+xr[0]); y00=0.5*(yr[1]+yr[0]); z00=0.5*(zr[1]+zr[0]);\n tolfac = 1.0e10;\n if (TRIM_PARTICLES==1):\n tolfac = 0.05;\n #tolfac = -0.01;\n ## trim down the incoming list to only whats in the range plotted\n ## (saves a ton of time and memory overflow crashes)\n \n dx=(0.5+tolfac)*(xr[1]-xr[0]); dy=(0.5+tolfac)*(yr[1]-yr[0]); dz=(0.5+tolfac)*(zr[1]-zr[0]);\n ok_sources=ok_scan(x-x00,xmax=dx) & ok_scan(y-y00,xmax=dy) & ok_scan(z-z00,xmax=dz);\n x=gas_pos[0,:] ; y=gas_pos[1,:] ; z=gas_pos[2,:]\n gw=gas_rho ; gh=gas_hsml ; gz=gas_metallicity ; gm=gas_mass\n ok_gas=ok_scan(x-x00,xmax=dx) & ok_scan(y-y00,xmax=dy) & ok_scan(z-z00,xmax=dz) & \\\n ok_scan(gw,pos=1) & ok_scan(gh,pos=1) & ok_scan(gz,pos=1) & ok_scan(gm,pos=1,xmax=1.0e40);\n \n Ngas = checklen(gas_mass[ok_gas]);\n Nstars = checklen(source_pos[0,ok_sources]);\n if (Nstars<=1) or (Ngas<=1):\n print ' UH-OH: EXPECT ERROR NOW, there are no valid source/gas particles to send!'\n print 'Ngas=',Ngas,'Nstars=',Nstars,'dx=',dx,'dy=',dy,'dz=',dz,'x00=',x00,'y00=',y00,'z00=',z00\n return -1,-1,-1;\n \n dzmax=np.max(gas_pos[2,ok_gas])-z00;\n if(dzmax 13):\n print 'BAND_ID must be < 13';\n return 0;\n \n b=['Bolometric', \\\n 'Sloan u','Sloan g','Sloan r','Sloan i','Sloan z', \\\n 'Johnsons U','Johnsons B', 'Johnsons V','Johnsons R','Johnsons I', \\\n 'Cousins J','Cousins H','Cousins K']\n if (QUIET==0): print 'Calculating M/L in '+str(b[band])+' ('+str(band)+','+str(band_standardordering)+')'\n \n if (RETURN_NU_EFF==1) or (RETURN_LAMBDA_EFF==1):\n lam_eff=np.array([1.e-5, 3541., 4653., 6147., 7461., 8904., 3600., 4400., \\\n 5556., 6940., 8700., 12150., 16540., 21790.]);\n nu_eff = 2.998e18 / lam_eff;\n if (RETURN_NU_EFF==1): return nu_eff[band];\n if (RETURN_LAMBDA_EFF==1): return lam_eff[band];\n\n#froot = util.return_python_routines_homedir()+'/colors_sps/'; # directory in which the data binaries are stored\n if (CHABRIER_IMF==1): fname=util.dir.sps_dir()+'colors.chabrier.dat'\n if (SALPETER_IMF==1): fname=util.dir.sps_dir()+'colors.salpeter.dat'\n\n lut = open(fname,'r');\n lut_dat = lut.read();\n Nl,Na,Nz = struct.unpack('3i',lut_dat[0:12])\n z_grid = np.array(struct.unpack(str(Nz)+'d',lut_dat[12:12+8*Nz]))\n age_grid = np.array(struct.unpack(str(Na)+'d',lut_dat[12+8*Nz:12+8*Nz+8*Na]))\n l_all_l = np.array(struct.unpack(str(Nl*Na*Nz)+'d',lut_dat[12+8*Nz+8*Na:12+8*Nz+8*Na+8*Nl*Na*Nz]))\n l_all = np.transpose(l_all_l.reshape(Nz,Na,Nl))\n lut.close()\n \n l_band = np.zeros((Na,Nz),dtype=np.float64);\n for iz in range(Nz): l_band[:,iz]=l_all[band,:,iz]\n \n # allow for extreme metallicities (extrapolate linearly past table)\n push_metals = 1;\n if (push_metals==1):\n Nz = Nz + 1;\n z_ext = [1000.0];\n z_grid = np.concatenate([z_grid,z_ext])\n lb1 = l_band[:,Nz-3]\n lb2 = l_band[:,Nz-2]\n lbx = np.zeros((Na,Nz),dtype=np.float64)\n lbx[:,0:Nz-1] = l_band\n lbx[:,Nz-1] = (lb2 - lb1) / (np.log10(z_grid[Nz-2]/z_grid[Nz-3])) * \\\n np.log10(z_grid[Nz-1]/z_grid[Nz-2])\n l_band = lbx;\n\n # get the x-axis (age) locations of input points\n ia_pts=np.interp(np.log10(age_in_Gyr)+9.0,age_grid,np.arange(0,Na,1));\n # this returns the boundary values for points outside of them (no extrapolation)\n #f=interp.interp1d(age_grid,np.arange(0,Na,1),kind='linear');\n #ia_pts=f(np.log10(age_in_Gyr)+9.0);\n \n # get the y-axis (metallicity) locations of input points\n zsun = 0.02;\n iz_pts=np.interp(np.log10(metallicity_in_solar_units*zsun),np.log10(z_grid),np.arange(0,Nz,1));\n #f=interp.interp1d(np.log10(z_grid),np.arange(0,Nz,1),kind='linear');\n #iz_pts=f(np.log10(metallicity_in_solar_units*zsun));\n \n if (CRUDE==1):\n ia_pts=np.around(ia_pts).astype(int);\n iz_pts=np.around(iz_pts).astype(int);\n print ia_pts, iz_pts, ia_pts, iz_pts\n print np.min( ia_pts), np.min( iz_pts), np.min( ia_pts), np.min( iz_pts)\n print np.max( ia_pts), np.max( iz_pts), np.max( ia_pts), np.max( iz_pts)\n ia_pts[ia_pts < 0] = np.max(ia_pts) \n iz_pts[iz_pts < 0] = np.max(iz_pts)\n l_b=l_band[ia_pts,iz_pts];\n else:\n l_b = interpolate.map_coordinates(l_band, (ia_pts,iz_pts), order=1);\n l_b = 10.**l_b\n \n # output is currently L/M in L_sun_IN_THE_BAND_OF_INTEREST/M_sun,\n # but we want our default to be L/M in units of L_bolometric/M_sun = 3.9e33/2.0e33, so\n # need to get rid fo the L_sun_IN_THE_BAND_OF_INTEREST/L_bolometric\n \n # AB system solar luminosities used for determining L_sun in absolute units for each of these\n N_BANDS=14\n mag_sun_ab = np.zeros(N_BANDS,dtype=float)\n mag_sun_ab[0] = 4.74;\n l_bol_sun = 3.9e33; # bolometric solar in erg/s\n mag_sun_ab[1] = 6.34; #U (BESSEL)\n mag_sun_ab[2] = 5.33; #B (BESSEL)\n mag_sun_ab[3] = 4.81; #V (BESSEL)\n mag_sun_ab[4] = 4.65; #R (KPNO)\n mag_sun_ab[5] = 4.55; #I (KPNO)\n mag_sun_ab[6] = 4.57; #J (BESSEL)\n mag_sun_ab[7] = 4.71; #H (BESSEL)\n mag_sun_ab[8] = 5.19; #K (BESSEL)\n mag_sun_ab[9] = 6.75; #SDSS u (unprimed AB)\n mag_sun_ab[10] = 5.33; #SDSS g (unprimed AB)\n mag_sun_ab[11] = 4.67; #SDSS r (unprimed AB)\n mag_sun_ab[12] = 4.48; #SDSS i (unprimed AB)\n mag_sun_ab[13] = 4.42; #SDSS z (unprimed AB)\n \n # Effective wavelengths of the bands (in Angstroms), to compute nuLnu<->Lnu\n # UBVRIJHK from http://cassfos02.ucsd.edu/physics/ph162/mags.html\n # SDSS ugriz from http://www.sdss.org/dr4/instruments/imager/index.html#filters\n lambda_eff = np.zeros(N_BANDS,dtype=float);\n lambda_eff[0] = 4243.93; #bolometric, no nu\n lambda_eff[1] = 3600.0; #U\n lambda_eff[2] = 4400.0; #B\n lambda_eff[3] = 5556.0; #V\n lambda_eff[4] = 6940.0; #R\n lambda_eff[5] = 8700.0; #I\n lambda_eff[6] = 12150.; #J\n lambda_eff[7] = 16540.; #H\n lambda_eff[8] = 21790.; #K\n lambda_eff[9] = 3551.; #SDSS u\n lambda_eff[10] = 4686.; #SDSS g\n lambda_eff[11] = 6165.; #SDSS r\n lambda_eff[12] = 7481.; #SDSS i\n lambda_eff[13] = 8931.; #SDSS z\n c_light = 2.998e10; # speed of light in cm/s\n nu_eff = c_light / (lambda_eff * 1.0e-8); # converts to nu_eff in Hz\n \n ten_pc = 10.e0 * 3.086e18; # 10 pc in cm\n log_S_nu = -(mag_sun_ab + 48.6)/2.5; # zero point definition for ab magnitudes\n S_nu = 10.**log_S_nu; # get the S_nu at 10 pc which defines M_AB\n lnu_sun_band = S_nu * (4.*3.14159*ten_pc*ten_pc); # multiply by distance modulus\n nulnu_sun_band = lnu_sun_band * nu_eff; # multiply by nu_eff to get nu*L_nu\n l_bol_sun = nulnu_sun_band[0];\n \n if (UNITS_SOLAR_IN_BAND==0):\n l_b *= nulnu_sun_band[band_standardordering] / l_bol_sun; \n \n return l_b;\n\n\n\n\n## routines from attenuation module\ndef attenuate( nu_in_Hz, log_NH, metallicity_in_solar, \\\n SMC=0, LMC=0, MW=0, BB=0, IR=0, SX=0, HX=0):\n return atten.attenuate( nu_in_Hz, log_NH, metallicity_in_solar, \\\n SMC=SMC, LMC=LMC, MW=MW, BB=BB, IR=IR, SX=SX, HX=HX)\n", "meta": {"hexsha": "033334cecc74bc09b6dff3a8504bb5ad9dde01c6", "size": 18272, "ext": "py", "lang": "Python", "max_stars_repo_path": "paul_analysis/Python/physicalmodels/stellarproperties/stellar_luminosities.py", "max_stars_repo_name": "lzkelley/arepo-mbh-sims_analysis", "max_stars_repo_head_hexsha": "f14519552cedd39a040b53e6d7cc538b5b8f38a3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "paul_analysis/Python/physicalmodels/stellarproperties/stellar_luminosities.py", "max_issues_repo_name": "lzkelley/arepo-mbh-sims_analysis", "max_issues_repo_head_hexsha": "f14519552cedd39a040b53e6d7cc538b5b8f38a3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "paul_analysis/Python/physicalmodels/stellarproperties/stellar_luminosities.py", "max_forks_repo_name": "lzkelley/arepo-mbh-sims_analysis", "max_forks_repo_head_hexsha": "f14519552cedd39a040b53e6d7cc538b5b8f38a3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 46.7314578005, "max_line_length": 136, "alphanum_fraction": 0.6081983363, "include": true, "reason": "import numpy,import scipy", "num_tokens": 6130, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6619228758499941, "lm_q2_score": 0.2974699363766585, "lm_q1q2_score": 0.19690215576535255}} {"text": "#!/usr/bin/env python3\n\nimport io\nimport numpy as np\n#import psycopg2\nimport sys\n#import sqlite3\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.optim as optim\nimport torch.utils.data\nfrom torchvision import transforms\n\nimport modelInput\nimport deep.dataStorage\n\n#this could go in a config file or something\n#dbConnect = \"dbname='shallow-red' user='shallow-red' host='localhost' password='shallow-red'\"\n\n\n#model of the network\n#the topology of this really should be configurable\nclass Net(nn.Module):\n def __init__(self, softmax=False, width=1000):\n super(Net, self).__init__()\n\n self.softmax = softmax\n\n #simple feed forward\n #this is kind of big, but I waste CPU cycles\n #with smaller networks (given mini-batching)\n #and this should be even more true with a GPU\n self.fc1 = nn.Linear(modelInput.stateSize, width)\n self.fc2 = nn.Linear(width, width)\n self.fc3 = nn.Linear(width, width)\n #self.fc4 = nn.Linear(width, width)\n #self.fc5 = nn.Linear(width, width)\n self.fc6 = nn.Linear(width, modelInput.numActions)\n\n #I don't know how this function works but whatever\n #that's how we roll\n #self.normalizer = nn.LayerNorm((width,))\n\n def forward(self, x):\n x = F.relu(self.fc1(x))\n x = F.relu(self.fc2(x))\n x = F.relu(self.fc3(x))\n #x = F.relu(self.fc4(x))\n #x = F.relu(self.fc5(x))\n #normalize to 0 mean and unit variance\n #like in the paper\n #x = self.normalizer(x)\n if self.softmax:\n x = F.softmax(self.fc6(x), dim=1)\n else:\n x = self.fc6(x)\n return x\n\nclass DeepCfrModel:\n\n #for advantages, the input is the state vector\n #and the output is a vector of each move's advantage\n #for strategies, the input is the state vector\n #and the output is a vector of each move's probability\n\n #so the inputs are exactly the same (modelInput.stateSize), and the outputs\n #are almost the same (modelInput.numActions)\n #strategy is softmaxed, advantage is not\n\n def __init__(self, name, softmax, writeLock, sharedDict, lr=0.0001, sampleCacheSize=10000, clearDb=True):\n self.softmax = softmax\n self.lr = lr\n self.writeLock = writeLock\n self.sharedDict = sharedDict\n\n #if we're not clearing the db, then we should also load in the id map\n #so that the inputs to the model will match those in the db\n if not clearDb:\n modelInput.readIdMap('idmap.pickle')\n\n self.net = Net(softmax=softmax)\n self.optimizer = optim.Adam(self.net.parameters(), lr=lr)\n #self.optimizer = optim.SGD(self.net.parameters(), lr=lr, momentum=0.9)\n\n #cache of (state tensor, label tensor, iteration) tuples\n #will eventually be put in training db\n self.sampleCacheSize = sampleCacheSize\n self.sampleCache = []\n\n self.name = name\n\n def addSample(self, data, label, iter):\n stateTensor = modelInput.stateToTensor(data)\n\n labelTensor = np.zeros(modelInput.numActions)\n for action, value in label:\n n = modelInput.enumAction(action)\n labelTensor[n] = value\n\n #put the np array in a tuple because that's what sqlite expects\n self.sampleCache.append(np.concatenate((stateTensor, labelTensor, [iter])))\n if len(self.sampleCache) > self.sampleCacheSize:\n self.clearSampleCache()\n\n #moves all samples from cache to the db\n def clearSampleCache(self):\n if len(self.sampleCache) == 0:\n return\n deep.dataStorage.addSamples(self.writeLock, self.name, self.sampleCache, self.sharedDict)\n self.sampleCache = []\n\n #we need to clean our db, clear out caches\n def close(self):\n #make sure we save everything first\n #so we can use the same training data in the future\n self.clearSampleCache()\n\n def predict(self, state):\n data = modelInput.stateToTensor(state)\n device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\n data = torch.from_numpy(data).float().to(device)\n self.net.to(device)\n return self.net(data).cpu().detach().numpy()\n\n def train(self, epochs=100):\n #I'm doing this so we can manually resume a stopped run\n modelInput.saveIdMap('idmap.pickle')\n\n #move from write cache to db\n self.clearSampleCache()\n\n\n device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\n #device = torch.device('cpu')\n\n self.net = Net(softmax=self.softmax)\n self.net = self.net.to(device)\n #self.optimizer = optim.SGD(self.net.parameters(), lr=self.lr, momentum=0.9)\n self.optimizer = optim.Adam(self.net.parameters(), lr=self.lr)\n miniBatchSize = 4\n\n dataset = deep.dataStorage.Dataset(self.name, self.sharedDict)\n loader = torch.utils.data.DataLoader(dataset, batch_size=miniBatchSize, shuffle=True, num_workers=4, pin_memory=True)\n\n print('dataset size:', dataset.size, file=sys.stderr)\n\n batchIter = iter(loader)\n for i in range(epochs):\n #print('getting data from loader', file=sys.stderr)\n try:\n data, labels, iters = next(batchIter)\n except StopIteration:\n batchIter = iter(loader)\n data, labels, iters = next(batchIter)\n\n #print('moving data to device', file=sys.stderr)\n data = data.to(device)\n labels = labels.to(device)\n iters = iters.to(device)\n \n #print('getting ys', file=sys.stderr)\n #evaluate on network\n self.optimizer.zero_grad()\n ys = self.net(data)\n\n #print('getting loss', file=sys.stderr)\n #loss function from the paper\n loss = torch.sum(iters.view(labels.shape[0],-1) * ((labels - ys) ** 2))\n #print the last 10 losses\n if i > epochs-11:\n print(i, loss, file=sys.stderr)\n #get gradient of loss\n #print('backward', file=sys.stderr)\n loss.backward()\n #clip gradient norm, which was done in the paper\n #print('clip', file=sys.stderr)\n nn.utils.clip_grad_norm_(self.net.parameters(), 1000)\n #train the network\n #print('step', file=sys.stderr)\n self.optimizer.step()\n #print('done with step', file=sys.stderr)\n\n self.net = self.net.to(torch.device('cpu'))\n", "meta": {"hexsha": "c04f3b05aabb5051ae47a78de5e850ada4cb874f", "size": 6576, "ext": "py", "lang": "Python", "max_stars_repo_path": "old/deep/deepModel.py", "max_stars_repo_name": "samhippie/shallow-red", "max_stars_repo_head_hexsha": "5690cdf380c6e138e25d88e85093738951438298", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "old/deep/deepModel.py", "max_issues_repo_name": "samhippie/shallow-red", "max_issues_repo_head_hexsha": "5690cdf380c6e138e25d88e85093738951438298", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "old/deep/deepModel.py", "max_forks_repo_name": "samhippie/shallow-red", "max_forks_repo_head_hexsha": "5690cdf380c6e138e25d88e85093738951438298", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-03-13T12:53:35.000Z", "max_forks_repo_forks_event_max_datetime": "2020-03-13T12:53:35.000Z", "avg_line_length": 35.5459459459, "max_line_length": 125, "alphanum_fraction": 0.6215024331, "include": true, "reason": "import numpy", "num_tokens": 1531, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6334102636778403, "lm_q2_score": 0.31069438321455395, "lm_q1q2_score": 0.19679701119515455}} {"text": "# -*- coding: utf-8 -*-\n\"\"\"\nRED Colourspaces\n================\n\nDefines the *RED* colourspaces:\n\n- :attr:`colour.models.RGB_COLOURSPACE_RED_COLOR`\n- :attr:`colour.models.RGB_COLOURSPACE_RED_COLOR_2`\n- :attr:`colour.models.RGB_COLOURSPACE_RED_COLOR_3`\n- :attr:`colour.models.RGB_COLOURSPACE_RED_COLOR_4`\n- :attr:`colour.models.RGB_COLOURSPACE_DRAGON_COLOR`\n- :attr:`colour.models.RGB_COLOURSPACE_DRAGON_COLOR_2`\n- :attr:`colour.models.RGB_COLOURSPACE_RED_WIDE_GAMUT_RGB`\n\nReferences\n----------\n- :cite:`Mansencal2015d` : Mansencal, T. (2015). RED Colourspaces Derivation.\n Retrieved May 20, 2015, from\n https://www.colour-science.org/posts/red-colourspaces-derivation\n- :cite:`Nattress2016a` : Nattress, G. (2016). Private Discussion with Shaw,\n N.\n- :cite:`SonyImageworks2012a` : Sony Imageworks. (2012). make.py. Retrieved\n November 27, 2014, from\n https://github.com/imageworks/OpenColorIO-Configs/blob/master/\\\nnuke-default/make.py\n\"\"\"\n\nfrom __future__ import division, unicode_literals\n\nimport numpy as np\n\nfrom colour.colorimetry import CCS_ILLUMINANTS\nfrom colour.models.rgb import (\n RGB_Colourspace, normalised_primary_matrix, log_encoding_REDLogFilm,\n log_decoding_REDLogFilm, log_encoding_Log3G10, log_decoding_Log3G10)\n\n__author__ = 'Colour Developers'\n__copyright__ = 'Copyright (C) 2013-2020 - Colour Developers'\n__license__ = 'New BSD License - https://opensource.org/licenses/BSD-3-Clause'\n__maintainer__ = 'Colour Developers'\n__email__ = 'colour-developers@colour-science.org'\n__status__ = 'Production'\n\n__all__ = [\n 'PRIMARIES_RED_COLOR', 'WHITEPOINT_NAME_RED_COLOR',\n 'CCS_WHITEPOINT_RED_COLOR', 'MATRIX_RED_COLOR_TO_XYZ',\n 'MATRIX_XYZ_TO_RED_COLOR', 'RGB_COLOURSPACE_RED_COLOR',\n 'PRIMARIES_RED_COLOR_2', 'WHITEPOINT_NAME_RED_COLOR_2',\n 'CCS_WHITEPOINT_RED_COLOR_2', 'MATRIX_RED_COLOR_2_TO_XYZ',\n 'MATRIX_XYZ_TO_RED_COLOR_2', 'RGB_COLOURSPACE_RED_COLOR_2',\n 'PRIMARIES_RED_COLOR_3', 'WHITEPOINT_NAME_RED_COLOR_3',\n 'CCS_WHITEPOINT_RED_COLOR_3', 'MATRIX_RED_COLOR_3_TO_XYZ',\n 'MATRIX_XYZ_TO_RED_COLOR_3', 'RGB_COLOURSPACE_RED_COLOR_3',\n 'PRIMARIES_RED_COLOR_4', 'WHITEPOINT_NAME_RED_COLOR_4',\n 'CCS_WHITEPOINT_RED_COLOR_4', 'MATRIX_RED_COLOR_4_TO_XYZ',\n 'MATRIX_XYZ_TO_RED_COLOR_4', 'RGB_COLOURSPACE_RED_COLOR_4',\n 'PRIMARIES_DRAGON_COLOR', 'WHITEPOINT_NAME_DRAGON_COLOR',\n 'CCS_WHITEPOINT_DRAGON_COLOR', 'MATRIX_DRAGON_COLOR_TO_XYZ',\n 'MATRIX_XYZ_TO_DRAGON_COLOR', 'RGB_COLOURSPACE_DRAGON_COLOR',\n 'PRIMARIES_DRAGON_COLOR_2', 'WHITEPOINT_NAME_DRAGON_COLOR_2',\n 'CCS_WHITEPOINT_DRAGON_COLOR_2', 'MATRIX_DRAGON_COLOR_2_TO_XYZ',\n 'MATRIX_XYZ_TO_DRAGON_COLOR_2', 'RGB_COLOURSPACE_DRAGON_COLOR_2',\n 'PRIMARIES_RED_WIDE_GAMUT_RGB', 'WHITEPOINT_NAME_RED_WIDE_GAMUT_RGB',\n 'CCS_WHITEPOINT_RED_WIDE_GAMUT_RGB', 'MATRIX_RED_WIDE_GAMUT_RGB_TO_XYZ',\n 'MATRIX_XYZ_TO_RED_WIDE_GAMUT_RGB', 'RGB_COLOURSPACE_RED_WIDE_GAMUT_RGB'\n]\n\nPRIMARIES_RED_COLOR = np.array([\n [0.701058563171395, 0.330180975940326],\n [0.298811317306316, 0.625169245953133],\n [0.135038675201355, 0.035261776551191],\n])\n\"\"\"\n*REDcolor* colourspace primaries.\n\nPRIMARIES_RED_COLOR : ndarray, (3, 2)\n\"\"\"\n\nWHITEPOINT_NAME_RED_COLOR = 'D65'\n\"\"\"\n*REDcolor* colourspace whitepoint name.\n\nWHITEPOINT_NAME_RED_COLOR : unicode\n\"\"\"\n\nCCS_WHITEPOINT_RED_COLOR = (CCS_ILLUMINANTS[\n 'CIE 1931 2 Degree Standard Observer'][WHITEPOINT_NAME_RED_COLOR])\n\"\"\"\n*REDcolor* colourspace whitepoint chromaticity coordinates.\n\nCCS_WHITEPOINT_RED_COLOR : ndarray\n\"\"\"\n\nMATRIX_RED_COLOR_TO_XYZ = normalised_primary_matrix(PRIMARIES_RED_COLOR,\n CCS_WHITEPOINT_RED_COLOR)\n\"\"\"\n*REDcolor* colourspace to *CIE XYZ* tristimulus values matrix.\n\nMATRIX_RED_COLOR_XYZ : array_like, (3, 3)\n\"\"\"\n\nMATRIX_XYZ_TO_RED_COLOR = np.linalg.inv(MATRIX_RED_COLOR_TO_XYZ)\n\"\"\"\n*CIE XYZ* tristimulus values to *REDcolor* colourspace matrix.\n\nMATRIX_XYZ_TO_RED_COLOR : array_like, (3, 3)\n\"\"\"\n\nRGB_COLOURSPACE_RED_COLOR = RGB_Colourspace(\n 'REDcolor',\n PRIMARIES_RED_COLOR,\n CCS_WHITEPOINT_RED_COLOR,\n WHITEPOINT_NAME_RED_COLOR,\n MATRIX_RED_COLOR_TO_XYZ,\n MATRIX_XYZ_TO_RED_COLOR,\n log_encoding_REDLogFilm,\n log_decoding_REDLogFilm,\n)\nRGB_COLOURSPACE_RED_COLOR.__doc__ = \"\"\"\n*REDcolor* colourspace.\n\nReferences\n----------\n:cite:`Mansencal2015d`, :cite:`SonyImageworks2012a`\n\nRGB_COLOURSPACE_RED_COLOR : RGB_Colourspace\n\"\"\"\n\nPRIMARIES_RED_COLOR_2 = np.array([\n [0.897407221929776, 0.330776225980398],\n [0.296022094516625, 0.684635550900945],\n [0.099799512883393, -0.023000513177992],\n])\n\"\"\"\n*REDcolor2* colourspace primaries.\n\nPRIMARIES_RED_COLOR_2 : ndarray, (3, 2)\n\"\"\"\n\nWHITEPOINT_NAME_RED_COLOR_2 = WHITEPOINT_NAME_RED_COLOR\n\"\"\"\n*REDcolor2* colourspace whitepoint name.\n\nWHITEPOINT_NAME_RED_COLOR_2 : unicode\n\"\"\"\n\nCCS_WHITEPOINT_RED_COLOR_2 = CCS_WHITEPOINT_RED_COLOR\n\"\"\"\n*REDcolor2* colourspace whitepoint chromaticity coordinates.\n\nCCS_WHITEPOINT_RED_COLOR_2 : ndarray\n\"\"\"\n\nMATRIX_RED_COLOR_2_TO_XYZ = normalised_primary_matrix(\n PRIMARIES_RED_COLOR_2, CCS_WHITEPOINT_RED_COLOR_2)\n\"\"\"\n*REDcolor2* colourspace to *CIE XYZ* tristimulus values matrix.\n\nMATRIX_RED_COLOR_2_XYZ : array_like, (3, 3)\n\"\"\"\n\nMATRIX_XYZ_TO_RED_COLOR_2 = np.linalg.inv(MATRIX_RED_COLOR_2_TO_XYZ)\n\"\"\"\n*CIE XYZ* tristimulus values to *REDcolor2* colourspace matrix.\n\nMATRIX_XYZ_TO_RED_COLOR_2 : array_like, (3, 3)\n\"\"\"\n\nRGB_COLOURSPACE_RED_COLOR_2 = RGB_Colourspace(\n 'REDcolor2',\n PRIMARIES_RED_COLOR_2,\n CCS_WHITEPOINT_RED_COLOR_2,\n WHITEPOINT_NAME_RED_COLOR_2,\n MATRIX_RED_COLOR_2_TO_XYZ,\n MATRIX_XYZ_TO_RED_COLOR_2,\n log_encoding_REDLogFilm,\n log_decoding_REDLogFilm,\n)\nRGB_COLOURSPACE_RED_COLOR_2.__doc__ = \"\"\"\n*REDcolor2* colourspace.\n\nReferences\n----------\n:cite:`Mansencal2015d`, :cite:`SonyImageworks2012a`\n\nRGB_COLOURSPACE_RED_COLOR_2 : RGB_Colourspace\n\"\"\"\n\nPRIMARIES_RED_COLOR_3 = np.array([\n [0.702598658589917, 0.330185588938484],\n [0.295782235737268, 0.689748258397534],\n [0.111090529079787, -0.004332320984771],\n])\n\"\"\"\n*REDcolor3* colourspace primaries.\n\nPRIMARIES_RED_COLOR_3 : ndarray, (3, 2)\n\"\"\"\n\nWHITEPOINT_NAME_RED_COLOR_3 = WHITEPOINT_NAME_RED_COLOR\n\"\"\"\n*REDcolor3* colourspace whitepoint name.\n\nWHITEPOINT_NAME_RED_COLOR_3 : unicode\n\"\"\"\n\nCCS_WHITEPOINT_RED_COLOR_3 = CCS_WHITEPOINT_RED_COLOR\n\"\"\"\n*REDcolor3* colourspace whitepoint chromaticity coordinates.\n\nCCS_WHITEPOINT_RED_COLOR_3 : ndarray\n\"\"\"\n\nMATRIX_RED_COLOR_3_TO_XYZ = normalised_primary_matrix(\n PRIMARIES_RED_COLOR_3, CCS_WHITEPOINT_RED_COLOR_3)\n\"\"\"\n*REDcolor3* colourspace to *CIE XYZ* tristimulus values matrix.\n\nMATRIX_RED_COLOR_3_TO_XYZ : array_like, (3, 3)\n\"\"\"\n\nMATRIX_XYZ_TO_RED_COLOR_3 = np.linalg.inv(MATRIX_RED_COLOR_3_TO_XYZ)\n\"\"\"\n*CIE XYZ* tristimulus values to *REDcolor3* colourspace matrix.\n\nMATRIX_XYZ_TO_RED_COLOR_3 : array_like, (3, 3)\n\"\"\"\n\nRGB_COLOURSPACE_RED_COLOR_3 = RGB_Colourspace(\n 'REDcolor3',\n PRIMARIES_RED_COLOR_3,\n CCS_WHITEPOINT_RED_COLOR_3,\n WHITEPOINT_NAME_RED_COLOR_3,\n MATRIX_RED_COLOR_3_TO_XYZ,\n MATRIX_XYZ_TO_RED_COLOR_3,\n log_encoding_REDLogFilm,\n log_decoding_REDLogFilm,\n)\nRGB_COLOURSPACE_RED_COLOR_3.__doc__ = \"\"\"\n*REDcolor3* colourspace.\n\nReferences\n----------\n:cite:`Mansencal2015d`, :cite:`SonyImageworks2012a`\n\nRGB_COLOURSPACE_RED_COLOR_3 : RGB_Colourspace\n\"\"\"\n\nPRIMARIES_RED_COLOR_4 = np.array([\n [0.702598154635438, 0.330185096210515],\n [0.295782328047083, 0.689748253964859],\n [0.144459236489795, 0.050837720977386],\n])\n\"\"\"\n*REDcolor4* colourspace primaries.\n\nPRIMARIES_RED_COLOR_4 : ndarray, (3, 2)\n\"\"\"\n\nWHITEPOINT_NAME_RED_COLOR_4 = WHITEPOINT_NAME_RED_COLOR\n\"\"\"\n*REDcolor4* colourspace whitepoint name.\n\nWHITEPOINT_NAME_RED_COLOR_4 : unicode\n\"\"\"\n\nCCS_WHITEPOINT_RED_COLOR_4 = CCS_WHITEPOINT_RED_COLOR\n\"\"\"\n*REDcolor4* colourspace whitepoint chromaticity coordinates.\n\nCCS_WHITEPOINT_RED_COLOR_4 : ndarray\n\"\"\"\n\nMATRIX_RED_COLOR_4_TO_XYZ = normalised_primary_matrix(\n PRIMARIES_RED_COLOR_4, CCS_WHITEPOINT_RED_COLOR_4)\n\"\"\"\n*REDcolor4* colourspace to *CIE XYZ* tristimulus values matrix.\n\nMATRIX_RED_COLOR_4_TO_XYZ : array_like, (3, 3)\n\"\"\"\n\nMATRIX_XYZ_TO_RED_COLOR_4 = np.linalg.inv(MATRIX_RED_COLOR_4_TO_XYZ)\n\"\"\"\n*CIE XYZ* tristimulus values to *REDcolor4* colourspace matrix.\n\nMATRIX_XYZ_TO_RED_COLOR_4 : array_like, (3, 3)\n\"\"\"\n\nRGB_COLOURSPACE_RED_COLOR_4 = RGB_Colourspace(\n 'REDcolor4',\n PRIMARIES_RED_COLOR_4,\n CCS_WHITEPOINT_RED_COLOR_4,\n WHITEPOINT_NAME_RED_COLOR_4,\n MATRIX_RED_COLOR_4_TO_XYZ,\n MATRIX_XYZ_TO_RED_COLOR_4,\n log_encoding_REDLogFilm,\n log_decoding_REDLogFilm,\n)\nRGB_COLOURSPACE_RED_COLOR_4.__doc__ = \"\"\"\n*REDcolor4* colourspace.\n\nReferences\n----------\n:cite:`Mansencal2015d`, :cite:`SonyImageworks2012a`\n\nRGB_COLOURSPACE_RED_COLOR_4 : RGB_Colourspace\n\"\"\"\n\nPRIMARIES_DRAGON_COLOR = np.array([\n [0.758655892599321, 0.330355348611293],\n [0.294923619810175, 0.708053242065117],\n [0.085961601167585, -0.045879436983969],\n])\n\"\"\"\n*DRAGONcolor* colourspace primaries.\n\nPRIMARIES_DRAGON_COLOR : ndarray, (3, 2)\n\"\"\"\n\nWHITEPOINT_NAME_DRAGON_COLOR = WHITEPOINT_NAME_RED_COLOR\n\"\"\"\n*DRAGONcolor* colourspace whitepoint name.\n\nWHITEPOINT_NAME_DRAGON_COLOR : unicode\n\"\"\"\n\nCCS_WHITEPOINT_DRAGON_COLOR = CCS_WHITEPOINT_RED_COLOR\n\"\"\"\n*DRAGONcolor* colourspace whitepoint chromaticity coordinates.\n\nCCS_WHITEPOINT_DRAGON_COLOR : ndarray\n\"\"\"\n\nMATRIX_DRAGON_COLOR_TO_XYZ = normalised_primary_matrix(\n PRIMARIES_DRAGON_COLOR, CCS_WHITEPOINT_DRAGON_COLOR)\n\"\"\"\n*DRAGONcolor* colourspace to *CIE XYZ* tristimulus values matrix.\n\nMATRIX_DRAGON_COLOR_TO_XYZ : array_like, (3, 3)\n\"\"\"\n\nMATRIX_XYZ_TO_DRAGON_COLOR = np.linalg.inv(MATRIX_DRAGON_COLOR_TO_XYZ)\n\"\"\"\n*CIE XYZ* tristimulus values to *DRAGONcolor* colourspace matrix.\n\nMATRIX_XYZ_TO_DRAGON_COLOR : array_like, (3, 3)\n\"\"\"\n\nRGB_COLOURSPACE_DRAGON_COLOR = RGB_Colourspace(\n 'DRAGONcolor',\n PRIMARIES_DRAGON_COLOR,\n CCS_WHITEPOINT_DRAGON_COLOR,\n WHITEPOINT_NAME_DRAGON_COLOR,\n MATRIX_DRAGON_COLOR_TO_XYZ,\n MATRIX_XYZ_TO_DRAGON_COLOR,\n log_encoding_REDLogFilm,\n log_decoding_REDLogFilm,\n)\nRGB_COLOURSPACE_DRAGON_COLOR.__doc__ = \"\"\"\n*DRAGONcolor* colourspace.\n\nReferences\n----------\n:cite:`Mansencal2015d`, :cite:`SonyImageworks2012a`\n\nRGB_COLOURSPACE_DRAGON_COLOR : RGB_Colourspace\n\"\"\"\n\nPRIMARIES_DRAGON_COLOR_2 = np.array([\n [0.758656214177604, 0.330355835762678],\n [0.294923887732982, 0.708053363192126],\n [0.144168726866337, 0.050357384587121],\n])\n\"\"\"\n*DRAGONcolor2* colourspace primaries.\n\nPRIMARIES_DRAGON_COLOR_2 : ndarray, (3, 2)\n\"\"\"\n\nWHITEPOINT_NAME_DRAGON_COLOR_2 = WHITEPOINT_NAME_RED_COLOR\n\"\"\"\n*DRAGONcolor2* colourspace whitepoint name.\n\nWHITEPOINT_NAME_DRAGON_COLOR_2 : unicode\n\"\"\"\n\nCCS_WHITEPOINT_DRAGON_COLOR_2 = CCS_WHITEPOINT_RED_COLOR\n\"\"\"\n*DRAGONcolor2* colourspace whitepoint chromaticity coordinates.\n\nCCS_WHITEPOINT_DRAGON_COLOR_2 : ndarray\n\"\"\"\n\nMATRIX_DRAGON_COLOR_2_TO_XYZ = normalised_primary_matrix(\n PRIMARIES_DRAGON_COLOR_2, CCS_WHITEPOINT_DRAGON_COLOR_2)\n\"\"\"\n*DRAGONcolor2* colourspace to *CIE XYZ* tristimulus values matrix.\n\nMATRIX_DRAGON_COLOR_2_TO_XYZ : array_like, (3, 3)\n\"\"\"\n\nMATRIX_XYZ_TO_DRAGON_COLOR_2 = np.linalg.inv(MATRIX_DRAGON_COLOR_2_TO_XYZ)\n\"\"\"\n*CIE XYZ* tristimulus values to *DRAGONcolor2* colourspace matrix.\n\nMATRIX_XYZ_TO_DRAGON_COLOR_2 : array_like, (3, 3)\n\"\"\"\n\nRGB_COLOURSPACE_DRAGON_COLOR_2 = RGB_Colourspace(\n 'DRAGONcolor2',\n PRIMARIES_DRAGON_COLOR_2,\n CCS_WHITEPOINT_DRAGON_COLOR_2,\n WHITEPOINT_NAME_DRAGON_COLOR_2,\n MATRIX_DRAGON_COLOR_2_TO_XYZ,\n MATRIX_XYZ_TO_DRAGON_COLOR_2,\n log_encoding_REDLogFilm,\n log_decoding_REDLogFilm,\n)\nRGB_COLOURSPACE_DRAGON_COLOR_2.__doc__ = \"\"\"\n*DRAGONcolor2* colourspace.\n\nReferences\n----------\n:cite:`Mansencal2015d`, :cite:`SonyImageworks2012a`\n\nRGB_COLOURSPACE_DRAGON_COLOR_2 : RGB_Colourspace\n\"\"\"\n\nPRIMARIES_RED_WIDE_GAMUT_RGB = np.array([\n [0.780308, 0.304253],\n [0.121595, 1.493994],\n [0.095612, -0.084589],\n])\n\"\"\"\n*REDWideGamutRGB* colourspace primaries.\n\nPRIMARIES_RED_WIDE_GAMUT_RGB : ndarray, (3, 2)\n\"\"\"\n\nWHITEPOINT_NAME_RED_WIDE_GAMUT_RGB = WHITEPOINT_NAME_RED_COLOR\n\"\"\"\n*REDWideGamutRGB* colourspace whitepoint name.\n\nWHITEPOINT_NAME_RED_WIDE_GAMUT_RGB : unicode\n\"\"\"\n\nCCS_WHITEPOINT_RED_WIDE_GAMUT_RGB = CCS_WHITEPOINT_RED_COLOR\n\"\"\"\n*REDWideGamutRGB* colourspace whitepoint chromaticity coordinates.\n\nCCS_WHITEPOINT_RED_WIDE_GAMUT_RGB : ndarray\n\"\"\"\n\nMATRIX_RED_WIDE_GAMUT_RGB_TO_XYZ = np.array([\n [0.735275, 0.068609, 0.146571],\n [0.286694, 0.842979, -0.129673],\n [-0.079681, -0.347343, 1.516082],\n])\n\"\"\"\n*REDWideGamutRGB* colourspace to *CIE XYZ* tristimulus values matrix.\n\nMATRIX_RED_WIDE_GAMUT_RGB_TO_XYZ : array_like, (3, 3)\n\"\"\"\n\nMATRIX_XYZ_TO_RED_WIDE_GAMUT_RGB = np.linalg.inv(\n MATRIX_RED_WIDE_GAMUT_RGB_TO_XYZ)\n\"\"\"\n*CIE XYZ* tristimulus values to *REDWideGamutRGB* colourspace matrix.\n\nMATRIX_XYZ_TO_RED_WIDE_GAMUT_RGB : array_like, (3, 3)\n\"\"\"\n\nRGB_COLOURSPACE_RED_WIDE_GAMUT_RGB = RGB_Colourspace(\n 'REDWideGamutRGB',\n PRIMARIES_RED_WIDE_GAMUT_RGB,\n CCS_WHITEPOINT_RED_WIDE_GAMUT_RGB,\n WHITEPOINT_NAME_RED_WIDE_GAMUT_RGB,\n MATRIX_RED_WIDE_GAMUT_RGB_TO_XYZ,\n MATRIX_XYZ_TO_RED_WIDE_GAMUT_RGB,\n log_encoding_Log3G10,\n log_decoding_Log3G10,\n)\nRGB_COLOURSPACE_RED_WIDE_GAMUT_RGB.__doc__ = \"\"\"\n*REDWideGamutRGB* colourspace.\n\nReferences\n----------\n:cite:`Mansencal2015d`, :cite:`Nattress2016a`, :cite:`SonyImageworks2012a`\n\nRGB_COLOURSPACE_RED_WIDE_GAMUT_RGB : RGB_Colourspace\n\"\"\"\n", "meta": {"hexsha": "52102a78e0d3ab992492680e980adfc8c64325c6", "size": 13466, "ext": "py", "lang": "Python", "max_stars_repo_path": "colour/models/rgb/datasets/red.py", "max_stars_repo_name": "wenh06/colour", "max_stars_repo_head_hexsha": "445fdad2711ae39c95b4375166905568d24a95f4", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-09T01:53:40.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-09T01:53:40.000Z", "max_issues_repo_path": "colour/models/rgb/datasets/red.py", "max_issues_repo_name": "wenh06/colour", "max_issues_repo_head_hexsha": "445fdad2711ae39c95b4375166905568d24a95f4", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "colour/models/rgb/datasets/red.py", "max_forks_repo_name": "wenh06/colour", "max_forks_repo_head_hexsha": "445fdad2711ae39c95b4375166905568d24a95f4", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.3144016227, "max_line_length": 79, "alphanum_fraction": 0.7798158325, "include": true, "reason": "import numpy", "num_tokens": 4179, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.6688802471698041, "lm_q2_score": 0.2942149783515162, "lm_q1q2_score": 0.19679458744082073}} {"text": "# Copyright 2019-2021 Cambridge Quantum Computing\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\nfrom pytket import Circuit\nfrom pytket.backends import Backend\nfrom pytket.transform import Transform # type: ignore\nfrom pytket.utils import QubitPauliOperator\nfrom pytket.pauli import Pauli, QubitPauliString # type: ignore\nfrom pytket.tailoring import apply_clifford_basis_change # type: ignore\nfrom numpy import mean\n\nfrom typing import List, Tuple, cast, Union, Dict\nimport copy\n\nfrom qermit import (\n MitEx,\n SymbolsDict,\n MeasurementCircuit,\n ObservableTracker,\n MitTask,\n AnsatzCircuit,\n ObservableExperiment,\n TaskGraph,\n)\nfrom qermit.taskgraph.mitex import get_basic_measurement_circuit, gen_compiled_MitRes\n\n\ndef get_clifford_mcs(input_circuit: Circuit) -> List[MeasurementCircuit]:\n \"\"\"\n For given Circuit, rebases and substitutes all non-Clifford angles with symbols.\n Then, makes MeasurementCircuit objects wherein each Circuit is the same, but each SymbolsDict\n object varies with some different set of Clifford angles.\n\n :param input_circuit: Circuit to make all-non Clifford gates paramterised.\n :type input_circuit: Circuit\n\n :return: New MeasurementCircuits with Clifford parameters\n :rtype: List[MeasurementCircuit]\n \"\"\"\n copy_circ = input_circuit.copy()\n symbols = copy_circ.free_symbols()\n symbols_dict = dict()\n for s in symbols:\n symbols_dict[s] = cast(Union[None, float], float(0))\n sd = SymbolsDict.symbols_from_dict(symbols_dict)\n return [MeasurementCircuit(copy_circ, sd)]\n\n\n# TODO: make prepare -1 eigenstate also\ndef preparation_circuit_for_partition(\n clifford_circuit: Circuit, partition: List[QubitPauliString]\n) -> Circuit:\n \"\"\"\n For each Pauli string in partition, finds Pauli string produced by applying a Clifford basis change from given Clifford circuit.\n Returns a state preparation circuit for preparing a +1 eigenstate of all basis changed Pauli strings.\n \"\"\"\n\n eigenstate_circuit = Circuit(0)\n for q in clifford_circuit.qubits:\n eigenstate_circuit.add_qubit(q)\n # to make +1 eigenstate of all transformed strings\n # transform string, then append gates for preparing\n # +1 eigenstate to circuit\n # use RemoveRedundancies after to minimise gates required in cosntruction\n Transform.RebaseToCliffordSingles().apply(clifford_circuit)\n for string in partition:\n transformed_string = apply_clifford_basis_change(string, clifford_circuit)\n transformed_dict = transformed_string.map\n for qubit in transformed_dict:\n if transformed_dict[qubit] == Pauli.X:\n eigenstate_circuit.H(qubit)\n if transformed_dict[qubit] == Pauli.Y:\n eigenstate_circuit.V(qubit)\n Transform.RemoveRedundancies().apply(eigenstate_circuit)\n return eigenstate_circuit\n\n\ndef DFSC_circuit_task_gen() -> MitTask:\n \"\"\"\n For each experiment, the ansatz circuit has all symbolic gates substituted for Clifford angles (in this case, all 0's).\n If any non symbolic gates are non Clifford, an error is thrown.\n For each Clifford ansatz circuit, a new ObservableTracke is forme with new measurement circuits\n added for each Qubit Pauli String in the operator.\n\n :return: MitTask object that produces characterisation circuits for DFSC on a new wire as new experiments\n :rtype: MitTask\n \"\"\"\n\n def task(\n obj,\n measurement_wires: List[ObservableExperiment],\n ) -> Tuple[List[ObservableExperiment], List[List[List[ObservableExperiment]]],]:\n \"\"\"\n :param measurement_wires: A list of tuples, each tuple representing a different experiment\n :type measurement_wires: List[ObservableExperiment]\n\n :return: Original experiment wires and another list of characterisation experiments for each original experiment.\n These are organised in later task.\n :rtype: Tuple[List[ObservableExperiment], List[List[List[ObservableExperiment]]]]\n \"\"\"\n characterisation_wires = []\n for measurement_wire in measurement_wires:\n ansatz_circ = measurement_wire.AnsatzCircuit\n base_circ = ansatz_circ[0]\n tracker = measurement_wire.ObservableTracker\n # Given a circuit, sets all Symbols to Clifford angles\n # If circuit has non-Clifford elements not as symbolics, error thrown\n clifford_circuits = get_clifford_mcs(base_circ)\n\n # make a new ObservableTracker for holding characterisation circuits\n single_experiment_wires = []\n for c in clifford_circuits:\n clifford_trackers = []\n for string in tracker._qps_to_indices.keys():\n # each characterisation circuit must have its own observable tracker\n # this is as the 'ansatz' circuit changes for each string + Clifford combo\n # as state preparation changes\n new_tracker = ObservableTracker(QubitPauliOperator({string: 1}))\n # get measurement circuit\n measurement_circuit_info = get_basic_measurement_circuit(string)\n\n para_circuit = c.get_parametric_circuit()\n # get preparation circuit for partition, though only pass 1 string\n prep_circuit = preparation_circuit_for_partition(\n para_circuit, [string]\n )\n # add components to get characterisation circuit\n prep_circuit.append(para_circuit)\n new_ansatz_c = AnsatzCircuit(\n Circuit=prep_circuit.copy(),\n Shots=ansatz_circ[1],\n SymbolsDict=c._symbols,\n )\n prep_circuit.append(measurement_circuit_info[0])\n # add to new tracker for given Clifford circuit\n\n new_tracker.add_measurement_circuit(\n MeasurementCircuit(prep_circuit, c._symbols),\n [measurement_circuit_info[1]],\n )\n clifford_trackers.append(\n ObservableExperiment(\n AnsatzCircuit=new_ansatz_c, ObservableTracker=new_tracker\n )\n )\n # a single experiment being all pauli string measurement circuits for a single Clifford Circuit\n single_experiment_wires.append(clifford_trackers)\n # single experiment wires being all observable trackers for all sampled Clifford circuits with\n # added measurement circuits for all pauli strings in given experiment\n characterisation_wires.append(single_experiment_wires)\n return (measurement_wires, characterisation_wires)\n\n return MitTask(_label=\"DFSCCircuits\", _n_in_wires=1, _n_out_wires=2, _method=task)\n\n\ndef DFSC_collater_task_gen() -> MitTask:\n \"\"\"\n For each experiment passed to MitEx, DFSC characterisation produces an ObservableTracker\n of a single Measurement Circuit for each combination of Clifford circuit produced, eigenstates preparation\n and QubitPauliString in operator, via several nested Lists.\n This task unpackages these Lists into a single List as suitable for input to MitEx objects.\n It also stores information required to produce characterisation from resulting QubitPauliOperators out of\n MitEx object.\n\n :return: MitTask object that collates many BackendResult objects for a single\n frame randomisation instance and converts them into a single\n BackendResult object.\n :rtype: MitTask\n \"\"\"\n\n def task(\n obj,\n all_characterisation_trackers: List[List[List[ObservableExperiment]]],\n ) -> Tuple[List[ObservableExperiment], List[int]]:\n \"\"\"\n :param all_characterisation_trackers: Experiment wires; outer list is experiments, second outer list\n is Cliffords, inner list is qubit pauli strings.\n :type all_characterisation_trackers: List[List[List[ObservableExperiment]]]\n\n :return: Wire 1; All individual experiments collated into a single wire.\n Wire 2; Indexing to produce characterisation later.\n :rtype: Tuple[List[ObservableExperiment], List[Tuple[int, List[int]]]]\n \"\"\"\n organisation_indices = []\n collated_experiments = []\n for experiment_char in all_characterisation_trackers:\n # individual list is for some cliffords\n # qps is stored in output\n base_len = 0\n for cliff_ots in experiment_char:\n base_len += len(cliff_ots)\n for qps_ot in cliff_ots:\n collated_experiments.append(qps_ot)\n organisation_indices.append(base_len)\n return (collated_experiments, organisation_indices)\n\n return MitTask(_label=\"DFSCCollation\", _n_in_wires=1, _n_out_wires=2, _method=task)\n\n\ndef DFSC_characterisation_task_gen() -> MitTask:\n \"\"\"\n Given characterisation results for all experiments, Clifford circuits and QubitPauliStrings, produces\n a characterisation result for each Experiment.\n\n :return: MitTask object for organising and calculating characterisation.\n :rtype: MitTask\n \"\"\"\n\n def task(\n obj,\n characterisation_results: List[QubitPauliOperator],\n experiment_indexing: List[int],\n ) -> Tuple[List[QubitPauliOperator]]:\n \"\"\"\n :param characterisation_results: All QubitPauliOperators returned from running experiment through some MitEx object\n :type characteriastion_results: List[QubitPauliOperator]\n :param experiment_indexing: Number of characteriastion results for each experiment, used to split results up.\n :type experiment_indexing: List[int]\n\n :return: Collated characterisation results, one QubitPauliOperator characterisation for each experiment\n :rtype: Tuple[List[QubitPauliOperator]]\n \"\"\"\n split_results = []\n lower_bound = 0\n for size in experiment_indexing:\n upper_bound = lower_bound + size\n split_results.append(characterisation_results[lower_bound:upper_bound])\n lower_bound = upper_bound\n\n characterisation_qpos = []\n for experiment_results in split_results:\n characterisation_dict: Dict[QubitPauliString, List[float]] = dict()\n # add all expectations for each Clifford + String combo to dict\n for qpo in experiment_results:\n for string in qpo._dict:\n if string not in characterisation_dict:\n characterisation_dict[string] = list()\n characterisation_dict[string].append(qpo._dict[string])\n # set entry to average of values in list\n # add characterisation for DFSC to output list\n characterisation_qpos.append(\n QubitPauliOperator(\n {k: mean(characterisation_dict[k]) for k in characterisation_dict}\n )\n )\n # number of characterisation qpos should match original number of experiments\n return (characterisation_qpos,)\n\n return MitTask(\n _label=\"DFSCCharacterisation\", _n_in_wires=2, _n_out_wires=1, _method=task\n )\n\n\ndef DFSC_correction_task_gen(zero_threshold: float) -> MitTask:\n \"\"\"\n For each experiment expectation, if characterisation value greater than threshold, divide experiment expectation\n by characteriastion value to correct for depolaring noise.\n\n :param zero_threshold: Method does not correct for zero characteriastion expectation values, threshold for this zero limit.\n :type zero_threshold: float\n\n :return: Function for DFSC correctoin.\n :rtype: MitTask\n \"\"\"\n\n def task(\n obj,\n experiment_results: List[QubitPauliOperator],\n characterisation_results: List[QubitPauliOperator],\n ) -> Tuple[List[QubitPauliOperator]]:\n \"\"\"\n :param experiment_results: QubitPauliOperators corresponding to expectations for all observable experiments.\n :type experiment_results: List[QubitPauliOperator]\n :param characteriastion_results: QubitPauliOperators corresponding to expectations for all characterisation experiments.\n :type characterisation_results: List[QubitPauliOperator]\n\n :return: Corrected expectations as QubitPauliOperator objects.\n :rtype: Tuple[List[QubitPauliOperator]]\n \"\"\"\n if len(experiment_results) != len(characterisation_results):\n raise ValueError(\n \"{} Experiment results and {} Characterisation results: mismatch for DFSC correction.\".format(\n len(experiment_results), len(characterisation_results)\n ),\n )\n corrected_results = []\n for experiment_qpo, characterisation_qpo in zip(\n experiment_results, characterisation_results\n ):\n new_qpo = dict()\n for key in experiment_qpo._dict:\n val = characterisation_qpo._dict[key]\n if val > zero_threshold:\n new_qpo[key] = experiment_qpo._dict[key] / val\n else:\n new_qpo[key] = experiment_qpo._dict[key]\n corrected_results.append(QubitPauliOperator(new_qpo))\n return (corrected_results,)\n\n return MitTask(_label=\"DFSCCorrection\", _n_in_wires=2, _n_out_wires=1, _method=task)\n\n\ndef gen_DFSC_MitEx(backend: Backend, **kwargs) -> MitEx:\n \"\"\"\n Produces a MitEx object that applies DFSC characteriastion to all experiment results.\n\n :param backend: Backend experiments are run through.\n :type backend: Backend\n :key experiment_mitex: MitEx object observable experiments are run through\n :key characterisation_mitex: MitEX object characteriastion experiments are run through.\n\n :return: MitEx object for automatic DFSC correction of circuits.\n :rtype: MitEx\n\n \"\"\"\n\n _experiment_mitex = copy.copy(\n kwargs.get(\n \"experiment_mitex\",\n MitEx(\n backend,\n _label=\"ExperimentMitex\",\n mitres=gen_compiled_MitRes(backend, 0),\n ),\n )\n )\n _characterisation_mitex = copy.copy(\n kwargs.get(\n \"characterisation_mitex\",\n MitEx(\n backend,\n _label=\"CharacterisationMitex\",\n mitres=gen_compiled_MitRes(backend, 0),\n ),\n )\n )\n\n _characterisation_taskgraph = TaskGraph().from_TaskGraph(_characterisation_mitex)\n _experiment_taskgraph = TaskGraph().from_TaskGraph(_experiment_mitex)\n\n _characterisation_taskgraph.add_wire()\n _characterisation_taskgraph.prepend(DFSC_collater_task_gen())\n _characterisation_taskgraph.append(DFSC_characterisation_task_gen())\n\n _experiment_taskgraph.parallel(\n MitEx(backend).from_TaskGraph(_characterisation_taskgraph)\n )\n _experiment_taskgraph.prepend(DFSC_circuit_task_gen())\n _experiment_taskgraph.append(\n DFSC_correction_task_gen(kwargs.get(\"DFSC_threshold\", 0.01))\n )\n return MitEx(backend).from_TaskGraph(_experiment_taskgraph)\n", "meta": {"hexsha": "2e66c83a15a24f16b5861eb2a7a0cff3478514a0", "size": 15767, "ext": "py", "lang": "Python", "max_stars_repo_path": "qermit/clifford_noise_characterisation/dfsc.py", "max_stars_repo_name": "CQCL/qermit", "max_stars_repo_head_hexsha": "931e8ee3bfcf4497f4be9e9278a9544d3136e67c", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 11, "max_stars_repo_stars_event_min_datetime": "2021-05-28T00:20:42.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-05T14:14:27.000Z", "max_issues_repo_path": "qermit/clifford_noise_characterisation/dfsc.py", "max_issues_repo_name": "CQCL/qermit", "max_issues_repo_head_hexsha": "931e8ee3bfcf4497f4be9e9278a9544d3136e67c", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2021-10-08T10:13:13.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-27T20:23:07.000Z", "max_forks_repo_path": "qermit/clifford_noise_characterisation/dfsc.py", "max_forks_repo_name": "CQCL/qermit", "max_forks_repo_head_hexsha": "931e8ee3bfcf4497f4be9e9278a9544d3136e67c", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2021-06-11T10:04:51.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-12T19:19:22.000Z", "avg_line_length": 43.197260274, "max_line_length": 132, "alphanum_fraction": 0.6809792605, "include": true, "reason": "from numpy", "num_tokens": 3321, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5312093733737563, "lm_q2_score": 0.37022540649291935, "lm_q1q2_score": 0.19666720619014788}} {"text": "from typing import Dict, Tuple, Text, Sequence\nfrom pydantic import BaseModel\nfrom clu.phontools import features\nimport numpy as np\n\n\nclass PhonemeErrors(BaseModel):\n \"\"\"\n stores phoneme errors.\n \"\"\"\n\n insertions: Sequence[Tuple[Text, Text]]\n deletions: Sequence[Tuple[Text, Text]]\n substitutions: Sequence[Tuple[Text, Text]]\n\n @property\n def edit_distance(self) -> int:\n return len(self.insertions) + len(self.deletions) + len(self.substitutions)\n\n def to_dict(self) -> Dict[str, float]:\n return {\n \"insertions\": self.insertions,\n \"deletions\": self.deletions,\n \"substitutions\": self.substitutions,\n }\n\n\nclass ReAline:\n \"\"\"\n Feature-based algorithm for aligning two sequences of phones.\n\n Based on Kondrak 2002\n \"\"\"\n\n inf = float(\"inf\")\n\n def __init__(\n self,\n similarity_matrix=features.similarity_matrix,\n feature_matrix=features.feature_matrix,\n salience=features.salience,\n consonants=features.consonants,\n C_skip=features.C_skip,\n C_vwl=features.C_vwl,\n C_sub=features.C_sub,\n C_exp=features.C_exp,\n R_c=features.R_c,\n R_v=features.R_v,\n ):\n self.similarity_matrix = similarity_matrix\n self.feature_matrix = feature_matrix\n self.consonants = consonants\n self.salience = salience\n self.C_skip = C_skip\n # weight assigned to vowel, consonant pairs\n self.C_vwl = C_vwl\n self.C_sub = C_sub\n self.C_exp = C_exp\n # List of relevant features for consonants\n self.R_c = R_c\n # List of relevant features for vowels\n self.R_v = R_v\n # sanity check\n self.sanity_check()\n\n @staticmethod\n def phoneme_errors(alignments: Sequence[Tuple[Text, Text]]) -> PhonemeErrors:\n \"\"\"\n Counts insertions, deletions, and substitutions according to the output of Re-Aline\n \"\"\"\n insertions = []\n deletions = []\n substitutions = []\n for pair in alignments:\n (phone_1, phone_2) = pair\n if phone_1 == \"-\":\n insertions.append(pair)\n elif phone_2 == \"-\":\n deletions.append(pair)\n elif phone_1 != phone_2 and phone_1 != \"-\" and phone_2 != \"-\":\n substitutions.append(pair)\n return PhonemeErrors(\n insertions=insertions, deletions=deletions, substitutions=substitutions\n )\n\n def sanity_check(self):\n \"\"\"\n Sanity check that ensures necessary features are present\n \"\"\"\n\n similarity_matrix = self.similarity_matrix\n feature_matrix = self.feature_matrix\n salience = self.salience\n consonants = self.consonants\n\n # ensure all salience values are found in feature matrix\n feats = set()\n feat_values = set()\n for phone_fm in feature_matrix.values():\n for (k, v) in phone_fm.items():\n feats.add(k)\n feat_values.add(v)\n\n assert (\n len(salience.keys() - feats) == 0\n ), f\"salience and features for each sound in feature_matrix do not match: {salience.keys() - feats}\"\n\n assert (\n len(similarity_matrix.keys() - feat_values) == 0\n ), f\"similarity_matrix and feature values for each sound in feature_matrix do not match: {similarity_matrix.keys() - feat_values}\"\n\n missing = [c for c in consonants if c not in feature_matrix.keys()]\n assert (\n len(missing) == 0\n ), f\"Some consonants missing from feature_matrix: {missing}\"\n\n def sigma_skip(self, p: Text) -> int:\n \"\"\"\n Returns score of an indel of P.\n (Kondrak 2002: 54)\n \"\"\"\n return self.C_skip\n\n def V(self, p: Text) -> int:\n \"\"\"\n Return vowel weight if P is vowel.\n (Kondrak 2002: 54)\n \"\"\"\n return 0 if p in self.consonants else self.C_vwl\n\n def R(self, p: Text, q: Text) -> Sequence[Text]:\n \"\"\"\n Return relevant features for segment comparsion.\n (Kondrak 2002: 54)\n \"\"\"\n consonants = self.consonants\n\n return self.R_c if p in consonants or q else self.R_v\n\n def diff(self, p: Text, q: Text, f: Text) -> int:\n \"\"\"\n Returns difference between phonetic segments P and Q for feature F.\n (Kondrak 2002: 52, 54)\n \"\"\"\n p_features, q_features = self.feature_matrix[p], self.feature_matrix[q]\n return abs(\n self.similarity_matrix[p_features[f]]\n - self.similarity_matrix[q_features[f]]\n )\n\n def delta(self, p: Text, q: Text) -> int:\n \"\"\"\n Return weighted sum of difference between P and Q.\n (Kondrak 2002: 54)\n \"\"\"\n features = self.R(p, q)\n total = 0\n for f in features:\n total += self.diff(p, q, f) * self.salience[f]\n return total\n\n def sigma_sub(self, p: Text, q: Text) -> int:\n \"\"\"\n Returns score of a substitution of P with Q.\n (Kondrak 2002: 54)\n \"\"\"\n return self.C_sub - self.delta(p, q) - self.V(p) - self.V(q)\n\n def sigma_exp(self, p: Text, q: Sequence[Text]) -> int:\n \"\"\"\n Returns score of an expansion/compression.\n (Kondrak 2002: 54)\n \"\"\"\n q1 = q[0]\n q2 = q[1]\n return (\n self.C_exp\n - self.delta(p, q1)\n - self.delta(p, q2)\n - self.V(p)\n - max(self.V(q1), self.V(q2))\n )\n\n def _retrieve(self, i, j, s, S, T, seq1, seq2, out) -> Sequence[Tuple[Text, Text]]:\n \"\"\"\n Retrieve the path through the similarity matrix S starting at (i, j).\n\n :return: Alignment of seq1 and seq2\n \"\"\"\n if S[i, j] == 0:\n return out\n else:\n if (\n j > 1\n and S[i - 1, j - 2] + self.sigma_exp(seq1[i - 1], seq2[j - 2 : j]) + s\n >= T\n ):\n out.insert(0, (seq1[i - 1], seq2[j - 2 : j]))\n self._retrieve(\n i - 1,\n j - 2,\n s + self.sigma_exp(seq1[i - 1], seq2[j - 2 : j]),\n S,\n T,\n seq1,\n seq2,\n out,\n )\n elif (\n i > 1\n and S[i - 2, j - 1] + self.sigma_exp(seq2[j - 1], seq1[i - 2 : i]) + s\n >= T\n ):\n out.insert(0, (seq1[i - 2 : i], seq2[j - 1]))\n self._retrieve(\n i - 2,\n j - 1,\n s + self.sigma_exp(seq2[j - 1], seq1[i - 2 : i]),\n S,\n T,\n seq1,\n seq2,\n out,\n )\n elif S[i, j - 1] + self.sigma_skip(seq2[j - 1]) + s >= T:\n out.insert(0, (\"-\", seq2[j - 1]))\n self._retrieve(\n i, j - 1, s + self.sigma_skip(seq2[j - 1]), S, T, seq1, seq2, out\n )\n elif S[i - 1, j] + self.sigma_skip(seq1[i - 1]) + s >= T:\n out.insert(0, (seq1[i - 1], \"-\"))\n self._retrieve(\n i - 1, j, s + self.sigma_skip(seq1[i - 1]), S, T, seq1, seq2, out\n )\n elif S[i - 1, j - 1] + self.sigma_sub(seq1[i - 1], seq2[j - 1]) + s >= T:\n out.insert(0, (seq1[i - 1], seq2[j - 1]))\n self._retrieve(\n i - 1,\n j - 1,\n s + self.sigma_sub(seq1[i - 1], seq2[j - 1]),\n S,\n T,\n seq1,\n seq2,\n out,\n )\n return out\n\n def align(\n self, seq1: Sequence[Text], seq2: Sequence[Text], epsilon: float = 0\n ) -> Sequence[Tuple[Text, Text]]:\n \"\"\"\n Computes the alignment of two symbol sequences.\n\n :param seq1: a sequence of symbols\n :param seq2: a sequence of symbols\n\n :type epsilon: float (0.0 to 1.0)\n :param epsilon: Adjusts threshold similarity score for near-optimal alignments\n :return: Alignment(s) of seq1 and seq2\n (Kondrak 2002: 51)\n \"\"\"\n\n assert 0.0 <= epsilon <= 1.0, \"Epsilon must be between 0.0 and 1.0.\"\n\n m = len(seq1)\n n = len(seq2)\n # This includes Kondrak's initialization of row 0 and column 0 to all 0s.\n S = np.zeros((m + 1, n + 1), dtype=float)\n # If i <= 1 or j <= 1, don't allow expansions as it doesn't make sense,\n # and breaks array and string indices. Make sure they never get chosen\n # by setting them to -inf.\n for i in range(1, m + 1):\n for j in range(1, n + 1):\n edit1 = S[i - 1, j] + self.sigma_skip(seq1[i - 1])\n edit2 = S[i, j - 1] + self.sigma_skip(seq2[j - 1])\n edit3 = S[i - 1, j - 1] + self.sigma_sub(seq1[i - 1], seq2[j - 1])\n if i > 1:\n edit4 = S[i - 2, j - 1] + self.sigma_exp(\n seq2[j - 1], seq1[i - 2 : i]\n )\n else:\n edit4 = -ReAline.inf\n if j > 1:\n edit5 = S[i - 1, j - 2] + self.sigma_exp(\n seq1[i - 1], seq2[j - 2 : j]\n )\n else:\n edit5 = -ReAline.inf\n S[i, j] = max(edit1, edit2, edit3, edit4, edit5, 0)\n T = (1 - epsilon) * np.amax(S) # Threshold score for near-optimal alignments\n\n alignments = []\n for i in range(1, m + 1):\n for j in range(1, n + 1):\n if S[i, j] >= T:\n alignments.append(self._retrieve(i, j, 0, S, T, seq1, seq2, []))\n return [pair for alignment in alignments for pair in alignment]\n", "meta": {"hexsha": "65c20ab5c9c3d5a7bd7c3ac397b636e5dd6c7138", "size": 10002, "ext": "py", "lang": "Python", "max_stars_repo_path": "clu/phontools/alignment/realine.py", "max_stars_repo_name": "clu-ling/clu-phontools", "max_stars_repo_head_hexsha": "304510150c6f9a4b0e1372bc9275630b7f976aeb", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "clu/phontools/alignment/realine.py", "max_issues_repo_name": "clu-ling/clu-phontools", "max_issues_repo_head_hexsha": "304510150c6f9a4b0e1372bc9275630b7f976aeb", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2021-06-15T23:32:30.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-01T18:49:20.000Z", "max_forks_repo_path": "clu/phontools/alignment/realine.py", "max_forks_repo_name": "clu-ling/clu-phontools", "max_forks_repo_head_hexsha": "304510150c6f9a4b0e1372bc9275630b7f976aeb", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-06-18T05:48:29.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-18T05:48:29.000Z", "avg_line_length": 33.4515050167, "max_line_length": 138, "alphanum_fraction": 0.4927014597, "include": true, "reason": "import numpy", "num_tokens": 2603, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5312093585306514, "lm_q2_score": 0.37022539954425293, "lm_q1q2_score": 0.19666719700365673}} {"text": "#!/usr/bin python\n# -*- coding: utf-8 -*-\n# FIXME: -par_plot option fails:\n# ValueError: range parameter must be finite\n# ('vis_range', [nan, nan])\n# ('ticks', [nan, nan])\n\n\nfrom __future__ import (print_function)\nimport os\nimport sys\nimport argparse\nimport matplotlib\nmatplotlib.use('Agg')\nlabel_size = 6\nmatplotlib.rcParams['xtick.labelsize'] = label_size\nmatplotlib.rcParams['ytick.labelsize'] = label_size\npath = os.path.normpath(os.path.join(os.path.dirname(sys.argv[0]), '..'))\nsys.path.insert(0, path)\nimport glob\nimport numpy as np\nfrom vlbi_errors.uv_data import UVData\nfrom vlbi_errors.spydiff import (import_difmap_model, modelfit_difmap)\nfrom vlbi_errors.bootstrap import CleanBootstrap\nfrom vlbi_errors.model import Model\nfrom vlbi_errors.utils import hdi_of_mcmc\n\ntry:\n import corner as triangle\nexcept ImportError:\n triangle = None\n\noutname = 'boot_uv'\nerrors_fname = 'bootstrap_errors.txt'\n\n\nif 'DIFMAP_LOGIN' in os.environ:\n del os.environ['DIFMAP_LOGIN']\n\n\ndef xy_2_rtheta(params):\n flux, x, y = params[:3]\n r = np.sqrt(x ** 2 + y ** 2)\n theta = np.rad2deg(np.arctan(x / y))\n result = [flux, r, theta]\n try:\n result.extend(params[3:])\n except IndexError:\n pass\n return result\n\n\ndef analyze_bootstrap_samples(dfm_model_fname, booted_mdl_paths,\n dfm_model_dir=None, plot_comps=None,\n plot_file=None, txt_file=None, cred_mass=0.68,\n coordinates='xy'):\n \"\"\"\n Plot bootstrap distribution of model component parameters.\n\n :param dfm_model_fname:\n File name of original difmap model.\n :param booted_mdl_paths:\n Iterable of paths to bootstrapped difmap models.\n :param dfm_model_dir: (optional)\n Directory with original difmap model. If ``None`` then CWD. (default:\n ``None``)\n :param plot_comps: (optional)\n Iterable of components number to plot on same plot. If ``None`` then\n plot parameter distributions of all components.\n :param plot_file: (optional)\n File to save picture. If ``None`` then don't save picture. (default:\n ``None``)\n :param txt_file: (optional)\n File to save credible intervals for parameters. If ``None`` then don't\n save credible intervals. (default: ``None``)\n :param cred_mass: (optional)\n Value of credible interval mass. Float in range (0., 1.). (default:\n ``0.68``)\n :param coordinates: (optional)\n Type of coordinates to use. ``xy`` or ``rtheta``. (default: ``xy``)\n \"\"\"\n n_boot = len(booted_mdl_paths)\n # Get params of initial model used for bootstrap\n comps_orig = import_difmap_model(dfm_model_fname, dfm_model_dir)\n comps_params0 = {i: [] for i in range(len(comps_orig))}\n for i, comp in enumerate(comps_orig):\n # FIXME: Move (x, y) <-> (r, theta) mapping to ``Component``\n if coordinates == 'xy':\n params = comp.p\n elif coordinates == 'rtheta':\n params = xy_2_rtheta(comp.p)\n else:\n raise Exception\n comps_params0[i].extend(list(params))\n\n # Load bootstrap models\n comps_params = {i: [] for i in range(len(comps_orig))}\n for booted_mdl_path in booted_mdl_paths:\n path, booted_mdl_file = os.path.split(booted_mdl_path)\n comps = import_difmap_model(booted_mdl_file, path)\n for i, comp in enumerate(comps):\n # FIXME: Move (x, y) <-> (r, theta) mapping to ``Component``\n if coordinates == 'xy':\n params = comp.p\n elif coordinates == 'rtheta':\n params = xy_2_rtheta(comp.p)\n else:\n raise Exception\n comps_params[i].extend(list(params))\n\n comps_to_plot = [comps_orig[k] for k in plot_comps]\n # (#boot, #parameters)\n boot_data = np.hstack(np.array(comps_params[i]).reshape((n_boot,\n comps_orig[i].size)) for\n i in plot_comps)\n\n # Optionally plot\n if plot_file:\n if triangle:\n lens = list(np.cumsum([comp.size for comp in comps_orig]))\n lens.insert(0, 0)\n\n labels = list()\n for comp in comps_to_plot:\n for lab in np.array(comp._parnames)[~comp._fixed]:\n # FIXME: Move (x, y) <-> (r, theta) mapping to ``Component``\n if coordinates == 'rtheta':\n if lab == 'x':\n lab = 'r'\n if lab == 'y':\n lab = 'theta'\n elif coordinates == 'xy':\n pass\n else:\n raise Exception\n labels.append(lab)\n\n try:\n n = sum([c.size for c in comps_to_plot])\n figure, axes = matplotlib.pyplot.subplots(nrows=n, ncols=n)\n figure.set_size_inches(19.5, 19.5)\n triangle.corner(boot_data, labels=labels, plot_contours=False,\n truths=np.hstack([comps_params0[i] for i in\n plot_comps]),\n title_kwargs={\"fontsize\": 6},\n label_kwargs={\"fontsize\": 6},\n quantiles=[0.16, 0.5, 0.84], fig=figure,\n use_math_text=True, show_titles=True,\n title_fmt=\".3f\")\n figure.gca().annotate(\"Components {}\".format(plot_comps),\n xy=(0.5, 1.0),\n xycoords=\"figure fraction\",\n xytext=(0, -5),\n textcoords=\"offset points\", ha=\"center\",\n va=\"top\")\n figure.savefig(plot_file, bbox_inches='tight', dpi=300)\n except ValueError:\n print(\"Failed to plot... ValueError\")\n else:\n print(\"Install ``corner`` for corner-plots\")\n\n if txt_file:\n # Print credible intervals\n fn = open(txt_file, 'w')\n fn.write(\"# parameter original.value low.boot high.boot mean.boot\"\n \" median.boot (mean-low).boot (high-mean).boot\\n\")\n recorded = 0\n for i in plot_comps:\n comp = comps_orig[i]\n for j in range(comp.size):\n low, high, mean, median = hdi_of_mcmc(boot_data[:, recorded+j],\n cred_mass=cred_mass,\n return_mean_median=True)\n # FIXME: Move (x, y) <-> (r, theta) mapping to ``Component``\n parnames = comp._parnames\n if coordinates == 'xy':\n params = comp.p\n elif coordinates == 'rtheta':\n params = xy_2_rtheta(comp.p)\n parnames[1] = 'r'\n parnames[2] = 'theta'\n else:\n raise Exception\n fn.write(\"{:<4} {:.4f} {:.4f} {:.4f} {:.4f} {:.4f} {:.4f}\"\n \" {:.4f}\".format(parnames[j], params[j], low,\n high, mean, median, abs(median - low),\n abs(high - median)))\n fn.write(\"\\n\")\n recorded += (j + 1)\n fn.close()\n\n\nif __name__ == \"__main__\":\n parser = \\\n argparse.ArgumentParser(description='Bootstrap Difmap models.\\n'\n ' Required '\n 'arguments are ``dfm_model_path`` &'\n ' one of the ``-uv_fits_path`` or'\n ' ``-booted_mdl_path``. If'\n ' ``-booted_mdl_path`` is used then'\n ' options ``-parametric``,'\n ' ``-n_boot``, ``-n_iter``,'\n ' ``-res_plot`` are not used.')\n\n parser.add_argument('dfm_model_path', type=str, metavar='dfm_model_path',\n help='Path to Difmap-format file with model.')\n parser.add_argument('-uv_fits_path', action='store', nargs='?', type=str,\n metavar='PATH TO UV-DATA FITS FILE', default=None,\n help='Path to FITS-file with self-calibrated UV-data.')\n parser.add_argument('-booted_mdl_card', action='store', nargs='?', type=str,\n default=None,\n help='Wildcard to find bootstrapped model'\n ' files', metavar='WILCARD WITH FULL PATH')\n parser.add_argument('-n_boot', action='store', nargs='?', default=100,\n type=int, help='Number of bootstrap realizations.'\n ' Default value = 100',\n metavar='INT')\n parser.add_argument('-n_iter', action='store', nargs='?', default=50,\n type=int, help='Number of iterations in difmap internal'\n ' fitting. Default is 50.',\n metavar='INT')\n parser.add_argument('-cred_value', action='store', nargs='?', default=0.68,\n type=float, help='Credible interval specification.'\n ' Float from (0, 1) interval. Default'\n ' is 0.68.',\n metavar='FLOAT FROM (0, 1)')\n parser.add_argument('-out_dir', action='store', nargs='?',\n default=os.getcwd(), type=str, help='Directory to store'\n ' bootstrap files, models'\n ' & results.',\n metavar='DIRECTORY')\n parser.add_argument('-errors_file', action='store', nargs='?',\n default='bootstrap_errors.txt', type=str,\n help='File name to store bootstrap errors. Default is'\n '`bootstrap_errors.txt`.',\n metavar='FILE NAME')\n parser.add_argument('-res_plot', action='store', nargs='?', default=None,\n type=str, help='File name to store IF-averages'\n ' residuals of Stokes I real & imag part'\n ' plot in output directory.',\n metavar='FILE NAME')\n parser.add_argument('-amplitude_scale_sigma', action='store', nargs='?',\n default=None, type=float, help='Sigma of amplitude'\n ' scale. In fractions of'\n ' amplitude.',\n metavar='FLOAT nearly 0.05-0.1')\n parser.add_argument('-res_plot_full', action='store', nargs='?', default=None,\n type=str, help='File name to store residuals of Stokes '\n 'RR & LL real & imag part'\n ' plot in output directory.',\n metavar='FILE NAME')\n parser.add_argument('-par_plot', action='store', nargs='?', default=None,\n type=str, help='File name to store parameters plot in'\n ' output directory.',\n metavar='FILE NAME')\n parser.add_argument('-plot_comps', action='store', nargs='+', default=None,\n type=str, help='Components numbers to plot.',\n metavar='COMPONENT #')\n parser.add_argument('-txt_comps', action='store', nargs='*', default=None,\n type=str, help='Components numbers to output'\n ' parameters in a text file.',\n metavar='COMPONENT #')\n parser.add_argument('-parametric', action='store_true', dest='parametric',\n default=False,\n help='Use parametric bootstrap instead of'\n ' nonparametric (nonparametric is the default).')\n parser.add_argument('-recenter', action='store_true', dest='recenter',\n default=False,\n help='Recenter residuals on each baseline.')\n parser.add_argument('-clean_after', action='store_true', dest='clean_after',\n default=False,\n help='Remove bootstrapped data & model files in the'\n ' end.')\n parser.add_argument('-bic', action='store_true', dest='bic',\n default=False,\n help='Calculate BIC criterion value for original model'\n ' and bootstrapped samples.')\n parser.add_argument('-rtheta', action='store_true', dest='use_rtheta',\n default=False,\n help='Use `r-theta` coordinates instead of `xy`.')\n parser.add_argument('-split_scans', action='store_true', dest='split_scans',\n default=False, help='Resample each scan individually?')\n\n args = parser.parse_args()\n\n data_dir = args.out_dir\n if not os.path.exists(data_dir):\n os.makedirs(data_dir)\n print(\"Data directory: {}\".format(data_dir))\n\n cred_value = args.cred_value\n uv_fits_path = args.uv_fits_path\n booted_mdl_card = args.booted_mdl_card\n dfm_model_path = args.dfm_model_path\n n_boot = args.n_boot\n niter = args.n_iter\n nonparametric = not args.parametric\n errors_fname = args.errors_file\n par_plot = args.par_plot\n recenter = args.recenter\n plot_comps = args.plot_comps\n txt_comps = args.txt_comps\n split_scans = args.split_scans\n amplitude_scale_sigma = args.amplitude_scale_sigma\n\n bic = args.bic\n if args.use_rtheta:\n coordinates = 'rtheta'\n else:\n coordinates = 'xy'\n\n if par_plot and not plot_comps:\n raise Exception(\"Use -plot_comps argument to specify # of components\"\n \" to plot\")\n\n dfm_model_dir, dfm_model_fname = os.path.split(dfm_model_path)\n try:\n comps = import_difmap_model(dfm_model_fname, dfm_model_dir)\n except ValueError:\n print(\"Problem importing difmap model...\")\n sys.exit(1)\n\n # Check that component numbers in input are among model components\n if plot_comps:\n for c in plot_comps:\n if int(c) not in range(len(comps)):\n raise Exception(\"No such component {} in current\"\n \" model!\".format(c))\n if not txt_comps:\n txt_comps = range(len(comps))\n else:\n txt_comps = [int(k) for k in txt_comps]\n for c in txt_comps:\n if int(c) not in range(len(comps)):\n raise Exception(\"No such component {} in current model!\".format(c))\n\n if uv_fits_path:\n print(\"Bootstrapping uv-data\")\n uv_fits_dir, uv_fits_fname = os.path.split(uv_fits_path)\n boot_type_dict = {True: \"non-parametric\", False: \"parametric\"}\n print(\"==================================\")\n print(\"Bootstrap uv-data: {}\".format(uv_fits_fname))\n print(\"With model: {}\".format(dfm_model_fname))\n print(\"Using {} bootstrap\".format(boot_type_dict[nonparametric]))\n if not nonparametric:\n if recenter:\n print(\"Recentering KDE-fitted residuals\")\n else:\n print(\"Using fitted KDE Model to generate resamples\")\n print(\"Using {} bootstrap replications\".format(n_boot))\n if amplitude_scale_sigma:\n print(\"Using amplitude sigma for scale\"\n \" = {}\".format(amplitude_scale_sigma))\n print(\"Using {} fitting iterations\".format(niter))\n print(\"Finding {}-confidence regions\".format(cred_value))\n print(\"Using directory {} for storing output\".format(data_dir))\n txt_save_dict = {'None': \"all\"}\n try:\n print(\"Saving errors of {} components to file\"\n \" {}\".format(txt_save_dict[str(txt_comps)], errors_fname))\n except KeyError:\n print(\"Saving errors of {} components to file\"\n \" {}\".format(txt_comps, errors_fname))\n\n if split_scans:\n print(\"Resampling each scan individually\")\n if par_plot:\n print(\"Saving components {} parameters distributions plot to file\"\n \" {}\".format(plot_comps, par_plot))\n if args.res_plot:\n print(\"Saving residuals I plot to file {}\".format(args.res_plot))\n if args.res_plot_full:\n print(\"Saving residulas RR & LL plots to files\"\n \" {}*\".format(args.res_plot_full))\n print(\"==================================\")\n\n uvdata = UVData(uv_fits_path)\n model = Model(stokes='I')\n model.add_components(*comps)\n\n if bic:\n bic_orig = model.bic(uvdata)\n bic_booted = list()\n\n try:\n boot = CleanBootstrap([model], uvdata,\n sigma_ampl_scale=amplitude_scale_sigma)\n # If uv-data contains only one Stokes parameter (e.g. `0838+133`)\n except IndexError:\n print(\"Problem in bootstrapping data...\")\n sys.exit(1)\n # FIXME: Broken - ValueError\n if args.res_plot:\n print(\"Plotting histograms of I residuals...\")\n boot.plot_residuals(args.res_plot)\n\n curdir = os.getcwd()\n os.chdir(data_dir)\n boot.run(n=n_boot, nonparametric=nonparametric, outname=[outname,\n '.fits'],\n recenter=recenter, use_kde=True, use_v=False)\n if args.res_plot_full:\n print(\"Plotting histograms of RR & LL residuals...\")\n boot.plot_residuals_trio(args.res_plot_full, split_scans,\n stokes=['RR', 'LL'])\n\n os.chdir(curdir)\n\n booted_uv_paths = sorted(glob.glob(os.path.join(data_dir,\n outname + \"*\")))\n booted_mdl_paths = list()\n # Modelfit bootstrapped uvdata\n for booted_uv_path in booted_uv_paths:\n path, booted_uv_file = os.path.split(booted_uv_path)\n i = booted_uv_file.split('_')[-1].split('.')[0]\n out_fname = dfm_model_fname + '_' + i\n modelfit_difmap(booted_uv_file, dfm_model_fname, out_fname,\n path=path, mdl_path=dfm_model_dir,\n out_path=data_dir, niter=niter)\n booted_mdl_paths.append(os.path.join(data_dir, out_fname))\n if bic:\n uvdata_ = UVData(booted_uv_path)\n model_ = Model(stokes='I')\n comps_ = import_difmap_model(out_fname, data_dir)\n model_.add_components(comps_)\n bic_booted.append(model_.bic(uvdata_))\n\n if bic:\n low_, high_, mean_, median_ = hdi_of_mcmc(bic_booted,\n cred_mass=0.68,\n return_mean_median=True)\n print(\"Model BIC with bootstrapped 68% interval = {:.2f}\"\n \" -{:.2f} +{:.2f}\".format(bic_orig, abs(mean_ - low_),\n abs(high_ - mean_)))\n\n elif booted_mdl_card:\n print(\"Using already bootstrapped uv-data\")\n booted_mdl_paths = glob.glob(booted_mdl_card)\n n_boot = len(booted_mdl_paths)\n print(\"==================================\")\n print(\"With {} bootstrap replications\".format(n_boot))\n print(\"Finding {}-confidence regions\".format(cred_value))\n print(\"Using directory {} for storing output\".format(data_dir))\n txt_save_dict = {'None': \"all\"}\n try:\n print(\"Saving errors of {} components to file\"\n \" {}\".format(txt_save_dict[str(txt_comps)], errors_fname))\n except KeyError:\n print(\"Saving errors of {} components to file\"\n \" {}\".format(txt_comps, errors_fname))\n if par_plot:\n print(\"Saving components {} parameters distributions plot to file\"\n \" {}\".format(plot_comps, par_plot))\n print(\"==================================\")\n\n else:\n raise Exception(\"Use -uv_fits_path or -booted_mdl_card to create/get\"\n \" bootstrapped models.\")\n\n # Optionally plot component parameters\n if par_plot:\n plot_comps = [int(k) for k in plot_comps]\n analyze_bootstrap_samples(dfm_model_fname, booted_mdl_paths,\n dfm_model_dir=dfm_model_dir,\n plot_comps=plot_comps,\n plot_file=os.path.join(data_dir, par_plot),\n cred_mass=cred_value,\n coordinates=coordinates)\n analyze_bootstrap_samples(dfm_model_fname, booted_mdl_paths,\n dfm_model_dir=dfm_model_dir,\n plot_comps=txt_comps,\n txt_file=os.path.join(data_dir, errors_fname),\n cred_mass=cred_value, coordinates=coordinates)\n\n if args.clean_after:\n for rmfile in booted_uv_paths:\n os.unlink(rmfile)\n for rmfile in booted_mdl_paths:\n os.unlink(rmfile)\n", "meta": {"hexsha": "9645f8cf706925f5ca3413046ac3fa6762c8c99d", "size": 21768, "ext": "py", "lang": "Python", "max_stars_repo_path": "silke/boot_silke.py", "max_stars_repo_name": "akutkin/SACA", "max_stars_repo_head_hexsha": "2d9b759e2de91734f7f7b61b8810ffbd73443d9a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "silke/boot_silke.py", "max_issues_repo_name": "akutkin/SACA", "max_issues_repo_head_hexsha": "2d9b759e2de91734f7f7b61b8810ffbd73443d9a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-10-16T20:36:19.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-24T19:28:01.000Z", "max_forks_repo_path": "silke/boot_silke.py", "max_forks_repo_name": "ipashchenko/ve", "max_forks_repo_head_hexsha": "b866b6d9465310d4cd5bb4d2e92595d918b681d0", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 45.35, "max_line_length": 85, "alphanum_fraction": 0.5210859978, "include": true, "reason": "import numpy", "num_tokens": 4487, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5312093585306515, "lm_q2_score": 0.3702253925955866, "lm_q1q2_score": 0.1966671933124602}} {"text": "\"\"\"\n@author: reubendo\n\"\"\"\n\n# -*- coding: utf-8 -*-\nfrom __future__ import absolute_import, print_function, division\n\nimport numpy as np\nimport tensorflow as tf\n\nfrom niftynet.layer.base_layer import TrainableLayer\nfrom niftynet.layer.convolution import ConvolutionalLayer\nfrom niftynet.layer.deconvolution import DeconvolutionalLayer\nfrom niftynet.layer.fully_connected import FullyConnectedLayer\nfrom niftynet.layer.activation import ActiLayer\nfrom niftynet.layer.bn import InstanceNormLayer\nfrom niftynet.layer.convolution import ConvLayer\nfrom niftynet.layer.elementwise import ElementwiseLayer\nfrom niftynet.layer.downsample import DownSampleLayer as Pooling\nfrom niftynet.layer.linear_resize import LinearResizeLayer\n\n\nMODALITIES = ['T1', 'T1c', 'T2', 'Flair', 'seg']\n\nHIDDEN_SPACE = 512\n\nNB_CONV = 8\ntf.set_random_seed(1)\nclass U_HeMIS(TrainableLayer):\n \"\"\"\n Implementation of U-HeMIS introduced [1] mixing HeMIS [2] and a U-Net architecture [3]\n [1] Dorent, et al. \"Hetero-Modal Variational Encoder-Decoder for\n Joint Modality Completion and Segmentation\". \n MICCAI 2019.\n [2] Havaei, et al. \"HeMIS: Hetero-Modal Image Segmentation\". \n MICCAI 2016. https://arxiv.org/abs/1607.05194\n [3] Ronneberger, et al. \"U-Net: Convolutional Networks for Biomedical Image Segmentation\". \n MICCAI 2015. https://arxiv.org/abs/1505.04597\n \"\"\"\n\n def __init__(self,\n num_classes,\n w_initializer=None,\n w_regularizer=None,\n b_initializer=None,\n b_regularizer=None,\n acti_func='leakyrelu',\n name='VAE'):\n\n super(U_HeMIS, self).__init__(name=name)\n\n self.initializers = {'w': w_initializer, 'b': b_initializer}\n self.regularizers = {'w': w_regularizer, 'b': b_regularizer}\n self.num_classes = num_classes\n\n def layer_op(self, images, choices, is_training=True, is_inference=False, **unused_kwargs):\n\n encoder = ConvEncoder(w_initializer=self.initializers['w'], w_regularizer=self.regularizers['w'], b_initializer=self.initializers['b'],b_regularizer=self.regularizers['b'])\n\n abstraction_op = HeMISAbstractionBlock()\n\n img_decoder = ConvDecoderImg(w_initializer=self.initializers['w'], w_regularizer=self.regularizers['w'], b_initializer=self.initializers['b'],b_regularizer=self.regularizers['b'])\n\n\n mod_img = MODALITIES[:4]\n\n # Encode the input\n list_skips = encoder(images)\n\n # Sample from the posterior distribution P(latent variables|input)\n skip_flow = []\n for k in range(len(list_skips)):\n sample = abstraction_op(list_skips[k], choices, is_inference)\n skip_flow.append(sample)\n\n img_output = img_decoder(skip_flow)\n\n \n\n\n return img_output\n\n\nclass ConvEncoder(TrainableLayer):\n \"\"\"\n Each modality are encoded indepedently.\n \"\"\"\n\n def __init__(self,\n w_initializer=None,\n w_regularizer=None,\n b_initializer=None,\n b_regularizer=None,\n name='ConvEncoder'):\n\n super(ConvEncoder, self).__init__(name=name)\n\n\n self.initializers = {'w': w_initializer, 'b': b_initializer}\n self.regularizers = {'w': w_regularizer, 'b': b_regularizer}\n\n self.ini_f = NB_CONV\n self.layers = [\n {'name': 'conv_0', 'n_features': self.ini_f, 'kernel_size': (1,1,1)},\n {'name': 'block_1', 'n_features': self.ini_f, 'kernels': ((3,3,3), (3,3,3)), 'downsampling':True},\n {'name': 'block_2', 'n_features': 2*self.ini_f, 'kernels': ((3,3,3), (3,3,3)), 'downsampling':True},\n {'name': 'block_3', 'n_features': 4*self.ini_f, 'kernels': ((3,3,3), (3,3,3)), 'downsampling':True},\n {'name': 'block_4', 'n_features': 8*self.ini_f, 'kernels': ((3,3,3), (3,3,3)), 'downsampling':False}]\n\n self.skip_ind = [1, 3, 5, 7]\n self.hidden = [self.layers[k]['n_features'] for k in range(1,len(self.layers))] \n self.hidden = [int(k/2) for k in self.hidden]\n \n\n def layer_op(self, images):\n # Define the encoding convolutional layers\n def clip(input):\n # This is for clipping logvars,\n # so that variances = exp(logvars) behaves well\n output = tf.maximum(input, -50)\n output = tf.minimum(output, 50)\n return output\n \n layer_instances = [] #list layers\n means = dict()\n logvars = dict()\n\n pooling_params = {'kernel_size': 2, 'stride': 2}\n\n\n list_skip_flow = [[] for k in range(len(self.skip_ind))]\n\n layer_fc_mod = dict()\n layer_cnn_mod = dict()\n \n\n for mod in MODALITIES[:4]:\n layer_cnn_mod[mod] = []\n layer_fc_mod[mod] = []\n\n\n params = self.layers[0]\n first_conv_layer = ConvolutionalLayer(\n n_output_chns=params['n_features'],\n kernel_size=params['kernel_size'],\n acti_func='leakyrelu',\n with_bn=False,\n w_initializer=self.initializers['w'],\n w_regularizer=self.regularizers['w'],\n name='%s_%s' % (params['name'],mod))\n \n layer_instances.append(first_conv_layer)\n layer_cnn_mod[mod].append(first_conv_layer)\n\n\n for i in range(1,len(self.layers)):\n\n params = self.layers[i]\n res_block = ResBlock(\n n_output_chns=params['n_features'],\n kernels=params['kernels'],\n acti_func='leakyrelu',\n encoding=True,\n w_initializer=self.initializers['w'],\n w_regularizer=self.regularizers['w'],\n name='%s_%s' % (params['name'],mod))\n layer_instances.append(res_block)\n layer_cnn_mod[mod].append(res_block)\n \n if params['downsampling']: \n downsampler = Pooling(func='MAX', kernel_size=2, stride=2,)\n\n layer_instances.append(downsampler)\n layer_cnn_mod[mod].append(downsampler)\n\n\n\n\n \n for mod in MODALITIES[:4]:\n flow_mod = images[mod]\n print(flow_mod)\n \n for ind, cnn_mod in enumerate(layer_cnn_mod[mod]):\n \n flow_mod = cnn_mod(flow_mod)\n layer_cnn_mod[mod][ind] = cnn_mod\n if ind in self.skip_ind:\n pos = self.skip_ind.index(ind)\n list_skip_flow[pos].append(flow_mod)\n print(flow_mod)\n print('list_flow')\n \n print(list_skip_flow)\n \n\n output = list_skip_flow\n\n\n\n if True:\n self._print(layer_instances)\n return output\n return output\n\n def _print(self, list_of_layers):\n for op in list_of_layers:\n print(op)\n\nclass HeMISAbstractionBlock(TrainableLayer):\n def __init__(self,\n pooling_type='average',\n name='HeMISAbstractionBlock'):\n\n super(HeMISAbstractionBlock, self).__init__(name=name)\n\n self.pooling_type = pooling_type\n self.name = name\n\n def layer_op(self, input_tensor, choices, is_training):\n \"\"\"\n Written by Thomas Varsavsky.\n\n Function will drop all zero columns and compute E[C] and Var[C]\n :param backend_output: backend_output\n :return: 1xC tensor where C is the number of features.\n \"\"\"\n # Omit zero columns from average\n # intermediate_tensor = tf.reduce_sum(tf.abs(input_tensor), 0)\n # zero_vector = tf.zeros(shape=(1, 1), dtype=tf.float32)\n # bool_mask = tf.not_equal(intermediate_tensor, zero_vector)\n # omit_zero_columns = tf.boolean_mask(input_tensor, bool_mask)\n # Compute E[C]\n input_tensor = tf.boolean_mask(input_tensor, choices)\n average_over_modalities, variance_between_modalities = tf.nn.moments(input_tensor, axes=[0])\n abstraction_output = tf.concat([average_over_modalities, variance_between_modalities], axis=-1)\n return abstraction_output\n\n\nclass ConvDecoderImg(TrainableLayer):\n \"\"\"\n Each modality are then decoded using the average of the skip-connections across\n the available modalities. \n \"\"\"\n\n def __init__(self,\n w_initializer=None,\n w_regularizer=None,\n b_initializer=None,\n b_regularizer=None,\n name='ConvDecoderImg'):\n\n super(ConvDecoderImg, self).__init__(name=name)\n\n\n self.initializers = {'w': w_initializer, 'b': b_initializer}\n self.regularizers = {'w': w_regularizer, 'b': b_regularizer}\n\n self.ini_f = NB_CONV\n self.layers = [\n {'name': 'block_1', 'n_features': 4*self.ini_f, 'kernels': ((3,3,3), (3,3,3))},\n {'name': 'block_2', 'n_features': 2*self.ini_f, 'kernels': ((3,3,3), (3,3,3))},\n {'name': 'block_3', 'n_features': self.ini_f, 'kernels': ((3,3,3), (3,3,3))}]\n\n def layer_op(self, list_skips):\n\n # Define the decoding convolutional layers\n layer_instances = [] #list layers\n layer_mod = dict()\n decoders_fc = dict()\n flow = dict()\n\n list_skips = list_skips[::-1]\n\n for mod in ['seg']:\n layer_mod[mod] = []\n\n flow_mod = list_skips[0]\n\n if mod =='seg':\n double = True\n n_output = 4\n else:\n double = True\n n_output = 1\n\n for i in range(len(self.layers)):\n \n params = self.layers[i]\n\n flow_mod = LinearResizeLayer(list_skips[i+1].shape.as_list()[1:-1])(flow_mod)\n\n print(mod)\n print(flow_mod)\n print('added with ')\n print(list_skips[i+1])\n flow_mod = ElementwiseLayer('CONCAT')(flow_mod, list_skips[i+1])\n print(flow_mod)\n\n\n res_block = ResBlock(\n n_output_chns=params['n_features'],\n kernels=params['kernels'],\n acti_func='leakyrelu',\n encoding=False,\n double_n = double,\n w_initializer=self.initializers['w'],\n w_regularizer=self.regularizers['w'],\n name='%s_%s' % (params['name'],mod))\n layer_instances.append(res_block)\n layer_mod[mod].append(res_block)\n flow_mod = res_block(flow_mod)\n\n\n last_conv = ConvolutionalLayer(\n n_output_chns=n_output,\n kernel_size=(1,1,1),\n with_bn=False,\n acti_func=None,\n w_initializer=self.initializers['w'],\n w_regularizer=self.regularizers['w'],\n name='final_conv_seg')\n layer_instances.append(last_conv)\n flow_mod = last_conv(flow_mod)\n flow[mod] = flow_mod\n\n if True:\n self._print(layer_instances)\n return flow['seg']\n return flow['seg']\n \n def _print(self, list_of_layers):\n for op in list_of_layers:\n print(op)\n\nclass ResBlock(TrainableLayer):\n \"\"\"\n This class define a high-resolution block with residual connections\n kernels\n\n - specify kernel sizes of each convolutional layer\n - e.g.: kernels=(5, 5, 5) indicate three conv layers of kernel_size 5\n\n with_res\n\n - whether to add residual connections to bypass the conv layers\n \"\"\"\n\n def __init__(self,\n n_output_chns,\n kernels=((3,3,3), (3,3,3)),\n acti_func='leakyrelu',\n encoding=False,\n double_n = True,\n w_initializer=None,\n w_regularizer=None,\n with_res=True,\n name='ResBlock',\n stride=1):\n\n super(ResBlock, self).__init__(name=name)\n\n self.n_output_chns = n_output_chns\n if hasattr(kernels, \"__iter__\"): # a list of layer kernel_sizes\n self.kernels = kernels\n else: # is a single number (indicating single layer)\n self.kernels = [kernels]\n self.acti_func = acti_func\n self.with_res = with_res\n\n self.initializers = {'w': w_initializer}\n self.regularizers = {'w': w_regularizer}\n self.stride = stride\n self.encoding = encoding\n self.double_n = double_n\n self.kernels = self.kernels if double_n else [self.kernels[0]]\n\n def layer_op(self, input_tensor):\n output_tensor = input_tensor\n for (i, k) in enumerate(self.kernels):\n # create parameterised layers\n if self.encoding:\n if i==0:\n nb_channels = self.n_output_chns\n elif i==1:\n nb_channels = int(self.n_output_chns/2)\n else:\n if self.double_n:\n if i==0:\n nb_channels = self.n_output_chns\n elif i==1:\n nb_channels = int(self.n_output_chns/2)\n else:\n nb_channels = int(self.n_output_chns/2)\n\n in_op = InstanceNormLayer(name='in_{}'.format(i))\n acti_op = ActiLayer(func=self.acti_func,\n regularizer=self.regularizers['w'],\n name='acti_{}'.format(i))\n conv_op = ConvLayer(n_output_chns=nb_channels,\n kernel_size=k,\n stride=self.stride,\n w_initializer=self.initializers['w'],\n w_regularizer=self.regularizers['w'],\n name='conv_{}'.format(i))\n # connect layers\n output_tensor = in_op(output_tensor)\n output_tensor = acti_op(output_tensor)\n output_tensor = conv_op(output_tensor)\n # make residual connections\n # if self.with_res:\n # output_tensor = ElementwiseLayer('SUM')(output_tensor, input_tensor)\n return output_tensor\n\n\n", "meta": {"hexsha": "98e74a01892c655b9a5765b427e07068d8c2f34f", "size": 14383, "ext": "py", "lang": "Python", "max_stars_repo_path": "extensions/u_hemis/u_hemis_net.py", "max_stars_repo_name": "ReubenDo/U-HVED", "max_stars_repo_head_hexsha": "1d293a87d496c52adafd69dbcea37767ac6a7ee8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 18, "max_stars_repo_stars_event_min_datetime": "2019-10-29T08:04:45.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-05T12:17:28.000Z", "max_issues_repo_path": "extensions/u_hemis/u_hemis_net.py", "max_issues_repo_name": "ReubenDo/U-HVED", "max_issues_repo_head_hexsha": "1d293a87d496c52adafd69dbcea37767ac6a7ee8", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 10, "max_issues_repo_issues_event_min_datetime": "2020-01-28T22:14:59.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-09T23:31:15.000Z", "max_forks_repo_path": "extensions/u_hemis/u_hemis_net.py", "max_forks_repo_name": "ReubenDo/U-HVED", "max_forks_repo_head_hexsha": "1d293a87d496c52adafd69dbcea37767ac6a7ee8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2020-02-10T23:59:10.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-28T05:22:41.000Z", "avg_line_length": 34.5745192308, "max_line_length": 187, "alphanum_fraction": 0.5652506431, "include": true, "reason": "import numpy", "num_tokens": 3260, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5312093733737563, "lm_q2_score": 0.37022537869825406, "lm_q1q2_score": 0.19666719142536115}} {"text": "from collections import defaultdict\nfrom collections.abc import MutableSequence, Iterable\nimport io\n\nimport numpy as np\nfrom numpy.polynomial import Polynomial\nimport pandas as pd\n\nfrom .data import NEUTRON_MASS\nfrom .endf import get_head_record, get_cont_record, get_tab1_record, get_list_record\ntry:\n from .reconstruct import wave_number, penetration_shift, reconstruct_mlbw, \\\n reconstruct_slbw, reconstruct_rm\n _reconstruct = True\nexcept ImportError:\n _reconstruct = False\nimport openmc.checkvalue as cv\n\n\nclass Resonances(object):\n \"\"\"Resolved and unresolved resonance data\n\n Parameters\n ----------\n ranges : list of openmc.data.ResonanceRange\n Distinct energy ranges for resonance data\n\n Attributes\n ----------\n ranges : list of openmc.data.ResonanceRange\n Distinct energy ranges for resonance data\n resolved : openmc.data.ResonanceRange or None\n Resolved resonance range\n unresolved : openmc.data.Unresolved or None\n Unresolved resonance range\n\n \"\"\"\n\n def __init__(self, ranges):\n self.ranges = ranges\n\n def __iter__(self):\n for r in self.ranges:\n yield r\n\n @property\n def ranges(self):\n return self._ranges\n\n @property\n def resolved(self):\n resolved_ranges = [r for r in self.ranges\n if not isinstance(r, Unresolved)]\n if len(resolved_ranges) > 1:\n raise ValueError('More than one resolved range present')\n elif len(resolved_ranges) == 0:\n return None\n else:\n return resolved_ranges[0]\n\n @property\n def unresolved(self):\n for r in self.ranges:\n if isinstance(r, Unresolved):\n return r\n else:\n return None\n\n @ranges.setter\n def ranges(self, ranges):\n cv.check_type('resonance ranges', ranges, MutableSequence)\n self._ranges = cv.CheckedList(ResonanceRange, 'resonance ranges',\n ranges)\n\n @classmethod\n def from_endf(cls, ev):\n \"\"\"Generate resonance data from an ENDF evaluation.\n\n Parameters\n ----------\n ev : openmc.data.endf.Evaluation\n ENDF evaluation\n\n Returns\n -------\n openmc.data.Resonances\n Resonance data\n\n \"\"\"\n file_obj = io.StringIO(ev.section[2, 151])\n\n # Determine whether discrete or continuous representation\n items = get_head_record(file_obj)\n n_isotope = items[4] # Number of isotopes\n\n ranges = []\n for iso in range(n_isotope):\n items = get_cont_record(file_obj)\n abundance = items[1]\n fission_widths = (items[3] == 1) # fission widths are given?\n n_ranges = items[4] # number of resonance energy ranges\n\n for j in range(n_ranges):\n items = get_cont_record(file_obj)\n resonance_flag = items[2] # flag for resolved (1)/unresolved (2)\n formalism = items[3] # resonance formalism\n\n if resonance_flag in (0, 1):\n # resolved resonance region\n erange = _FORMALISMS[formalism].from_endf(ev, file_obj, items)\n\n elif resonance_flag == 2:\n # unresolved resonance region\n erange = Unresolved.from_endf(file_obj, items, fission_widths)\n\n # erange.material = self\n ranges.append(erange)\n\n return cls(ranges)\n\n\nclass ResonanceRange(object):\n \"\"\"Resolved resonance range\n\n Parameters\n ----------\n target_spin : float\n Intrinsic spin, :math:`I`, of the target nuclide\n energy_min : float\n Minimum energy of the resolved resonance range in eV\n energy_max : float\n Maximum energy of the resolved resonance range in eV\n channel : dict\n Dictionary whose keys are l-values and values are channel radii as a\n function of energy\n scattering : dict\n Dictionary whose keys are l-values and values are scattering radii as a\n function of energy\n\n Attributes\n ----------\n channel_radius : dict\n Dictionary whose keys are l-values and values are channel radii as a\n function of energy\n energy_max : float\n Maximum energy of the resolved resonance range in eV\n energy_min : float\n Minimum energy of the resolved resonance range in eV\n scattering_radius : dict\n Dictionary whose keys are l-values and values are scattering radii as a\n function of energ\n target_spin : float\n Intrinsic spin, :math:`I`, of the target nuclide\n\n \"\"\"\n def __init__(self, target_spin, energy_min, energy_max, channel, scattering):\n self.target_spin = target_spin\n self.energy_min = energy_min\n self.energy_max = energy_max\n self.channel_radius = channel\n self.scattering_radius = scattering\n\n self._prepared = False\n self._parameter_matrix = {}\n\n def __copy__(self):\n cls = type(self)\n new_copy = cls.__new__(cls)\n new_copy.__dict__.update(self.__dict__)\n new_copy._prepared = False\n return new_copy\n\n @classmethod\n def from_endf(cls, ev, file_obj, items):\n \"\"\"Create resonance range from an ENDF evaluation.\n\n This factory method is only used when LRU=0, indicating that only a\n scattering radius appears in MF=2, MT=151. All subclasses of\n ResonanceRange override this method with their own.\n\n Parameters\n ----------\n ev : openmc.data.endf.Evaluation\n ENDF evaluation\n file_obj : file-like object\n ENDF file positioned at the second record of a resonance range\n subsection in MF=2, MT=151\n items : list\n Items from the CONT record at the start of the resonance range\n subsection\n\n Returns\n -------\n openmc.data.ResonanceRange\n Resonance range data\n\n \"\"\"\n energy_min, energy_max = items[0:2]\n\n # For scattering radius-only, NRO must be zero\n assert items[4] == 0\n\n # Get energy-independent scattering radius\n items = get_cont_record(file_obj)\n target_spin = items[0]\n ap = Polynomial((items[1],))\n\n # Calculate channel radius from ENDF-102 equation D.14\n a = Polynomial((0.123 * (NEUTRON_MASS*ev.target['mass'])**(1./3.) + 0.08,))\n\n return cls(target_spin, energy_min, energy_max, {0: a}, {0: ap})\n\n def reconstruct(self, energies):\n \"\"\"Evaluate cross section at specified energies.\n\n Parameters\n ----------\n energies : float or Iterable of float\n Energies at which the cross section should be evaluated\n\n Returns\n -------\n 3-tuple of float or numpy.ndarray\n Elastic, capture, and fission cross sections at the specified\n energies\n\n \"\"\"\n if not _reconstruct:\n raise RuntimeError(\"Resonance reconstruction not available.\")\n\n # Pre-calculate penetrations and shifts for resonances\n if not self._prepared:\n self._prepare_resonances()\n\n if isinstance(energies, Iterable):\n elastic = np.zeros_like(energies)\n capture = np.zeros_like(energies)\n fission = np.zeros_like(energies)\n\n for i, E in enumerate(energies):\n xse, xsg, xsf = self._reconstruct(self, E)\n elastic[i] = xse\n capture[i] = xsg\n fission[i] = xsf\n else:\n elastic, capture, fission = self._reconstruct(self, energies)\n\n return {2: elastic, 102: capture, 18: fission}\n\n\nclass MultiLevelBreitWigner(ResonanceRange):\n \"\"\"Multi-level Breit-Wigner resolved resonance formalism data.\n\n Multi-level Breit-Wigner resolved resonance data is identified by LRF=2 in\n the ENDF-6 format.\n\n Parameters\n ----------\n target_spin : float\n Intrinsic spin, :math:`I`, of the target nuclide\n energy_min : float\n Minimum energy of the resolved resonance range in eV\n energy_max : float\n Maximum energy of the resolved resonance range in eV\n channel : dict\n Dictionary whose keys are l-values and values are channel radii as a\n function of energy\n scattering : dict\n Dictionary whose keys are l-values and values are scattering radii as a\n function of energy\n\n Attributes\n ----------\n atomic_weight_ratio : float\n Atomic weight ratio of the target nuclide given as a function of\n l-value. Note that this may be different than the value for the\n evaluation as a whole.\n channel_radius : dict\n Dictionary whose keys are l-values and values are channel radii as a\n function of energy\n energy_max : float\n Maximum energy of the resolved resonance range in eV\n energy_min : float\n Minimum energy of the resolved resonance range in eV\n parameters : pandas.DataFrame\n Energies, spins, and resonances widths for each resonance\n q_value : dict\n Q-value to be added to incident particle's center-of-mass energy to\n determine the channel energy for use in the penetrability factor. The\n keys of the dictionary are l-values.\n scattering_radius : dict\n Dictionary whose keys are l-values and values are scattering radii as a\n function of energy\n target_spin : float\n Intrinsic spin, :math:`I`, of the target nuclide\n\n \"\"\"\n\n def __init__(self, target_spin, energy_min, energy_max, channel, scattering):\n super().__init__(target_spin, energy_min, energy_max, channel,\n scattering)\n self.parameters = None\n self.q_value = {}\n self.atomic_weight_ratio = None\n\n # Set resonance reconstruction function\n if _reconstruct:\n self._reconstruct = reconstruct_mlbw\n else:\n self._reconstruct = None\n\n @classmethod\n def from_endf(cls, ev, file_obj, items):\n \"\"\"Create MLBW data from an ENDF evaluation.\n\n Parameters\n ----------\n ev : openmc.data.endf.Evaluation\n ENDF evaluation\n file_obj : file-like object\n ENDF file positioned at the second record of a resonance range\n subsection in MF=2, MT=151\n items : list\n Items from the CONT record at the start of the resonance range\n subsection\n\n Returns\n -------\n openmc.data.MultiLevelBreitWigner\n Multi-level Breit-Wigner resonance parameters\n\n \"\"\"\n\n # Read energy-dependent scattering radius if present\n energy_min, energy_max = items[0:2]\n nro, naps = items[4:6]\n if nro != 0:\n params, ape = get_tab1_record(file_obj)\n\n # Other scatter radius parameters\n items = get_cont_record(file_obj)\n target_spin = items[0]\n ap = Polynomial((items[1],)) # energy-independent scattering-radius\n NLS = items[4] # number of l-values\n\n # Read resonance widths, J values, etc\n channel_radius = {}\n scattering_radius = {}\n q_value = {}\n records = []\n for l in range(NLS):\n items, values = get_list_record(file_obj)\n l_value = items[2]\n awri = items[0]\n q_value[l_value] = items[1]\n competitive = items[3]\n\n # Calculate channel radius from ENDF-102 equation D.14\n a = Polynomial((0.123 * (NEUTRON_MASS*awri)**(1./3.) + 0.08,))\n\n # Construct scattering and channel radius\n if nro == 0:\n scattering_radius[l_value] = ap\n if naps == 0:\n channel_radius[l_value] = a\n elif naps == 1:\n channel_radius[l_value] = ap\n elif nro == 1:\n scattering_radius[l_value] = ape\n if naps == 0:\n channel_radius[l_value] = a\n elif naps == 1:\n channel_radius[l_value] = ape\n elif naps == 2:\n channel_radius[l_value] = ap\n\n energy = values[0::6]\n spin = values[1::6]\n gt = np.asarray(values[2::6])\n gn = np.asarray(values[3::6])\n gg = np.asarray(values[4::6])\n gf = np.asarray(values[5::6])\n if competitive > 0:\n gx = gt - (gn + gg + gf)\n else:\n gx = np.zeros_like(gt)\n\n for i, E in enumerate(energy):\n records.append([energy[i], l_value, spin[i], gt[i], gn[i],\n gg[i], gf[i], gx[i]])\n\n columns = ['energy', 'L', 'J', 'totalWidth', 'neutronWidth',\n 'captureWidth', 'fissionWidth', 'competitiveWidth']\n parameters = pd.DataFrame.from_records(records, columns=columns)\n\n # Create instance of class\n mlbw = cls(target_spin, energy_min, energy_max,\n channel_radius, scattering_radius)\n mlbw.q_value = q_value\n mlbw.atomic_weight_ratio = awri\n mlbw.parameters = parameters\n\n return mlbw\n\n def _prepare_resonances(self):\n df = self.parameters.copy()\n\n # Penetration and shift factors\n p = np.zeros(len(df))\n s = np.zeros(len(df))\n\n # Penetration and shift factors for competitive reaction\n px = np.zeros(len(df))\n sx = np.zeros(len(df))\n\n l_values = []\n competitive = []\n\n A = self.atomic_weight_ratio\n for i, E, l, J, gt, gn, gg, gf, gx in df.itertuples():\n if l not in l_values:\n l_values.append(l)\n competitive.append(gx > 0)\n\n # Determine penetration and shift corresponding to resonance energy\n k = wave_number(A, E)\n rho = k*self.channel_radius[l](E)\n rhohat = k*self.scattering_radius[l](E)\n p[i], s[i] = penetration_shift(l, rho)\n\n # Determine penetration at modified energy for competitive reaction\n if gx > 0:\n Ex = E + self.q_value[l]*(A + 1)/A\n rho = k*self.channel_radius[l](Ex)\n rhohat = k*self.scattering_radius[l](Ex)\n px[i], sx[i] = penetration_shift(l, rho)\n else:\n px[i] = sx[i] = 0.0\n\n df['p'] = p\n df['s'] = s\n df['px'] = px\n df['sx'] = sx\n\n self._l_values = np.array(l_values)\n self._competitive = np.array(competitive)\n for l in l_values:\n self._parameter_matrix[l] = df[df.L == l].values\n\n self._prepared = True\n\n\nclass SingleLevelBreitWigner(MultiLevelBreitWigner):\n \"\"\"Single-level Breit-Wigner resolved resonance formalism data.\n\n Single-level Breit-Wigner resolved resonance data is is identified by LRF=1\n in the ENDF-6 format.\n\n Parameters\n ----------\n target_spin : float\n Intrinsic spin, :math:`I`, of the target nuclide\n energy_min : float\n Minimum energy of the resolved resonance range in eV\n energy_max : float\n Maximum energy of the resolved resonance range in eV\n channel : dict\n Dictionary whose keys are l-values and values are channel radii as a\n function of energy\n scattering : dict\n Dictionary whose keys are l-values and values are scattering radii as a\n function of energy\n\n Attributes\n ----------\n atomic_weight_ratio : float\n Atomic weight ratio of the target nuclide given as a function of\n l-value. Note that this may be different than the value for the\n evaluation as a whole.\n channel_radius : dict\n Dictionary whose keys are l-values and values are channel radii as a\n function of energy\n energy_max : float\n Maximum energy of the resolved resonance range in eV\n energy_min : float\n Minimum energy of the resolved resonance range in eV\n parameters : pandas.DataFrame\n Energies, spins, and resonances widths for each resonance\n q_value : dict\n Q-value to be added to incident particle's center-of-mass energy to\n determine the channel energy for use in the penetrability factor. The\n keys of the dictionary are l-values.\n scattering_radius : dict\n Dictionary whose keys are l-values and values are scattering radii as a\n function of energy\n target_spin : float\n Intrinsic spin, :math:`I`, of the target nuclide\n\n \"\"\"\n\n def __init__(self, target_spin, energy_min, energy_max, channel, scattering):\n super().__init__(target_spin, energy_min, energy_max, channel,\n scattering)\n\n # Set resonance reconstruction function\n if _reconstruct:\n self._reconstruct = reconstruct_slbw\n else:\n self._reconstruct = None\n\n\nclass ReichMoore(ResonanceRange):\n \"\"\"Reich-Moore resolved resonance formalism data.\n\n Reich-Moore resolved resonance data is identified by LRF=3 in the ENDF-6\n format.\n\n Parameters\n ----------\n target_spin : float\n Intrinsic spin, :math:`I`, of the target nuclide\n energy_min : float\n Minimum energy of the resolved resonance range in eV\n energy_max : float\n Maximum energy of the resolved resonance range in eV\n channel : dict\n Dictionary whose keys are l-values and values are channel radii as a\n function of energy\n scattering : dict\n Dictionary whose keys are l-values and values are scattering radii as a\n function of energy\n\n Attributes\n ----------\n angle_distribution : bool\n Indicate whether parameters can be used to compute angular distributions\n atomic_weight_ratio : float\n Atomic weight ratio of the target nuclide given as a function of\n l-value. Note that this may be different than the value for the\n evaluation as a whole.\n channel_radius : dict\n Dictionary whose keys are l-values and values are channel radii as a\n function of energy\n energy_max : float\n Maximum energy of the resolved resonance range in eV\n energy_min : float\n Minimum energy of the resolved resonance range in eV\n num_l_convergence : int\n Number of l-values which must be used to converge the calculation\n scattering_radius : dict\n Dictionary whose keys are l-values and values are scattering radii as a\n function of energy\n parameters : pandas.DataFrame\n Energies, spins, and resonances widths for each resonance\n target_spin : float\n Intrinsic spin, :math:`I`, of the target nuclide\n\n \"\"\"\n\n def __init__(self, target_spin, energy_min, energy_max, channel, scattering):\n super().__init__(target_spin, energy_min, energy_max, channel,\n scattering)\n self.parameters = None\n self.angle_distribution = False\n self.num_l_convergence = 0\n\n # Set resonance reconstruction function\n if _reconstruct:\n self._reconstruct = reconstruct_rm\n else:\n self._reconstruct = None\n\n @classmethod\n def from_endf(cls, ev, file_obj, items):\n \"\"\"Create Reich-Moore resonance data from an ENDF evaluation.\n\n Parameters\n ----------\n ev : openmc.data.endf.Evaluation\n ENDF evaluation\n file_obj : file-like object\n ENDF file positioned at the second record of a resonance range\n subsection in MF=2, MT=151\n items : list\n Items from the CONT record at the start of the resonance range\n subsection\n\n Returns\n -------\n openmc.data.ReichMoore\n Reich-Moore resonance parameters\n\n \"\"\"\n # Read energy-dependent scattering radius if present\n energy_min, energy_max = items[0:2]\n nro, naps = items[4:6]\n if nro != 0:\n params, ape = get_tab1_record(file_obj)\n\n # Other scatter radius parameters\n items = get_cont_record(file_obj)\n target_spin = items[0]\n ap = Polynomial((items[1],))\n angle_distribution = (items[3] == 1) # Flag for angular distribution\n NLS = items[4] # Number of l-values\n num_l_convergence = items[5] # Number of l-values for convergence\n\n # Read resonance widths, J values, etc\n channel_radius = {}\n scattering_radius = {}\n records = []\n for i in range(NLS):\n items, values = get_list_record(file_obj)\n apl = Polynomial((items[1],)) if items[1] != 0.0 else ap\n l_value = items[2]\n awri = items[0]\n\n # Calculate channel radius from ENDF-102 equation D.14\n a = Polynomial((0.123 * (NEUTRON_MASS*awri)**(1./3.) + 0.08,))\n\n # Construct scattering and channel radius\n if nro == 0:\n scattering_radius[l_value] = apl\n if naps == 0:\n channel_radius[l_value] = a\n elif naps == 1:\n channel_radius[l_value] = apl\n elif nro == 1:\n if naps == 0:\n channel_radius[l_value] = a\n scattering_radius[l_value] = ape\n elif naps == 1:\n channel_radius[l_value] = scattering_radius[l_value] = ape\n elif naps == 2:\n channel_radius[l_value] = apl\n scattering_radius[l_value] = ape\n\n energy = values[0::6]\n spin = values[1::6]\n gn = values[2::6]\n gg = values[3::6]\n gfa = values[4::6]\n gfb = values[5::6]\n\n for i, E in enumerate(energy):\n records.append([energy[i], l_value, spin[i], gn[i], gg[i],\n gfa[i], gfb[i]])\n\n # Create pandas DataFrame with resonance data\n columns = ['energy', 'L', 'J', 'neutronWidth', 'captureWidth',\n 'fissionWidthA', 'fissionWidthB']\n parameters = pd.DataFrame.from_records(records, columns=columns)\n\n # Create instance of ReichMoore\n rm = cls(target_spin, energy_min, energy_max,\n channel_radius, scattering_radius)\n rm.parameters = parameters\n rm.angle_distribution = angle_distribution\n rm.num_l_convergence = num_l_convergence\n rm.atomic_weight_ratio = awri\n\n return rm\n\n def _prepare_resonances(self):\n df = self.parameters.copy()\n\n # Penetration and shift factors\n p = np.zeros(len(df))\n s = np.zeros(len(df))\n\n l_values = []\n lj_values = []\n\n A = self.atomic_weight_ratio\n for i, E, l, J, gn, gg, gfa, gfb in df.itertuples():\n if l not in l_values:\n l_values.append(l)\n if (l, abs(J)) not in lj_values:\n lj_values.append((l, abs(J)))\n\n # Determine penetration and shift corresponding to resonance energy\n k = wave_number(A, E)\n rho = k*self.channel_radius[l](E)\n rhohat = k*self.scattering_radius[l](E)\n p[i], s[i] = penetration_shift(l, rho)\n\n df['p'] = p\n df['s'] = s\n\n self._l_values = np.array(l_values)\n for (l, J) in lj_values:\n self._parameter_matrix[l, J] = df[(df.L == l) &\n (abs(df.J) == J)].values\n\n self._prepared = True\n\n\nclass RMatrixLimited(ResonanceRange):\n \"\"\"R-matrix limited resolved resonance formalism data.\n\n R-matrix limited resolved resonance data is identified by LRF=7 in the\n ENDF-6 format.\n\n Parameters\n ----------\n energy_min : float\n Minimum energy of the resolved resonance range in eV\n energy_max : float\n Maximum energy of the resolved resonance range in eV\n particle_pairs : list of dict\n List of particle pairs. Each particle pair is represented by a\n dictionary that contains the mass, atomic number, spin, and parity of\n each particle as well as other characteristics.\n spin_groups : list of dict\n List of spin groups. Each spin group is characterized by channels,\n resonance energies, and resonance widths.\n\n Attributes\n ----------\n reduced_width : bool\n Flag indicating whether channel widths in eV or reduced-width amplitudes\n in eV^1/2 are given\n formalism : int\n Flag to specify which formulae for the R-matrix are to be used\n particle_pairs : list of dict\n List of particle pairs. Each particle pair is represented by a\n dictionary that contains the mass, atomic number, spin, and parity of\n each particle as well as other characteristics.\n spin_groups : list of dict\n List of spin groups. Each spin group is characterized by channels,\n resonance energies, and resonance widths.\n\n \"\"\"\n\n def __init__(self, energy_min, energy_max, particle_pairs, spin_groups):\n super().__init__(0.0, energy_min, energy_max, None, None)\n self.reduced_width = False\n self.formalism = 3\n self.particle_pairs = particle_pairs\n self.spin_groups = spin_groups\n\n @classmethod\n def from_endf(cls, ev, file_obj, items):\n \"\"\"Read R-Matrix limited resonance data from an ENDF evaluation.\n\n Parameters\n ----------\n ev : openmc.data.endf.Evaluation\n ENDF evaluation\n file_obj : file-like object\n ENDF file positioned at the second record of a resonance range\n subsection in MF=2, MT=151\n items : list\n Items from the CONT record at the start of the resonance range\n subsection\n\n Returns\n -------\n openmc.data.RMatrixLimited\n R-matrix limited resonance parameters\n\n \"\"\"\n energy_min, energy_max = items[0:2]\n\n items = get_cont_record(file_obj)\n reduced_width = (items[2] == 1) # reduced width amplitude?\n formalism = items[3] # Specify which formulae are used\n n_spin_groups = items[4] # Number of Jpi values (NJS)\n\n particle_pairs = []\n spin_groups = []\n\n items, values = get_list_record(file_obj)\n n_pairs = items[5]//2 # Number of particle pairs (NPP)\n for i in range(n_pairs):\n first = {'mass': values[12*i],\n 'z': int(values[12*i + 2]),\n 'spin': values[12*i + 4],\n 'parity': values[12*i + 10]}\n second = {'mass': values[12*i + 1],\n 'z': int(values[12*i + 3]),\n 'spin': values[12*i + 5],\n 'parity': values[12*i + 11]}\n\n q_value = values[12*i + 6]\n penetrability = values[12*i + 7]\n shift = values[12*i + 8]\n mt = int(values[12*i + 9])\n\n particle_pairs.append(ParticlePair(\n first, second, q_value, penetrability, shift, mt))\n\n # loop over spin groups\n for i in range(n_spin_groups):\n items, values = get_list_record(file_obj)\n J = items[0]\n if J == 0.0:\n parity = '+' if items[1] == 1.0 else '-'\n else:\n parity = '+' if J > 0. else '-'\n J = abs(J)\n kbk = items[2]\n kps = items[3]\n n_channels = items[5]\n channels = []\n for j in range(n_channels):\n channel = {}\n channel['particle_pair'] = particle_pairs[\n int(values[6*j]) - 1]\n channel['l'] = values[6*j + 1]\n channel['spin'] = values[6*j + 2]\n channel['boundary'] = values[6*j + 3]\n channel['effective_radius'] = values[6*j + 4]\n channel['true_radius'] = values[6*j + 5]\n channels.append(channel)\n\n # Read resonance energies and widths\n items, values = get_list_record(file_obj)\n n_resonances = items[3]\n records = []\n m = n_channels//6 + 1\n for j in range(n_resonances):\n energy = values[6*m*j]\n records.append([energy] + [values[6*m*j + k + 1]\n for k in range(n_channels)])\n\n # Determine column names\n columns = ['energy']\n for channel in channels:\n mt = channel['particle_pair'].mt\n if mt == 2:\n columns.append('neutronWidth')\n elif mt == 18:\n columns.append('fissionWidth')\n elif mt == 102:\n columns.append('captureWidth')\n else:\n columns.append('width (MT={})'.format(mt))\n\n # Create Pandas dataframe with resonance parameters\n parameters = pd.DataFrame.from_records(records, columns=columns)\n\n # Construct SpinGroup instance and add to list\n sg = SpinGroup(J, parity, channels, parameters)\n spin_groups.append(sg)\n\n # Optional extension (Background R-Matrix)\n if kbk > 0:\n items, values = get_list_record(file_obj)\n lbk = items[4]\n if lbk == 1:\n params, rbr = get_tab1_record(file_obj)\n params, rbi = get_tab1_record(file_obj)\n\n # Optional extension (Tabulated phase shifts)\n if kps > 0:\n items, values = get_list_record(file_obj)\n lps = items[4]\n if lps == 1:\n params, psr = get_tab1_record(file_obj)\n params, psi = get_tab1_record(file_obj)\n\n rml = cls(energy_min, energy_max, particle_pairs, spin_groups)\n rml.reduced_width = reduced_width\n rml.formalism = formalism\n\n return rml\n\n\nclass ParticlePair(object):\n def __init__(self, first, second, q_value, penetrability,\n shift, mt):\n self.first = first\n self.second = second\n self.q_value = q_value\n self.penetrability = penetrability\n self.shift = shift\n self.mt = mt\n\n\nclass SpinGroup(object):\n \"\"\"Resonance spin group\n\n Attributes\n ----------\n spin : float\n Total angular momentum (nuclear spin)\n parity : {'+', '-'}\n Even (+) or odd(-) parity\n channels : list of openmc.data.Channel\n Available channels\n parameters : pandas.DataFrame\n Energies/widths for each resonance/channel\n\n \"\"\"\n\n def __init__(self, spin, parity, channels, parameters):\n self.spin = spin\n self.parity = parity\n self.channels = channels\n self.parameters = parameters\n\n def __repr__(self):\n return ''.format(self.spin, self.parity)\n\n\nclass Unresolved(ResonanceRange):\n \"\"\"Unresolved resonance parameters as identified by LRU=2 in MF=2.\n\n Parameters\n ----------\n target_spin : float\n Intrinsic spin, :math:`I`, of the target nuclide\n energy_min : float\n Minimum energy of the unresolved resonance range in eV\n energy_max : float\n Maximum energy of the unresolved resonance range in eV\n channel : openmc.data.Function1D\n Channel radii as a function of energy\n scattering : openmc.data.Function1D\n Scattering radii as a function of energy\n\n Attributes\n ----------\n add_to_background : bool\n If True, file 3 contains partial cross sections to be added to the\n average unresolved cross sections calculated from parameters.\n atomic_weight_ratio : float\n Atomic weight ratio of the target nuclide\n channel_radius : openmc.data.Function1D\n Channel radii as a function of energy\n energies : Iterable of float\n Energies at which parameters are tabulated\n energy_max : float\n Maximum energy of the unresolved resonance range in eV\n energy_min : float\n Minimum energy of the unresolved resonance range in eV\n parameters : list of pandas.DataFrame\n Average resonance parameters at each energy\n scattering_radius : openmc.data.Function1D\n Scattering radii as a function of energy\n target_spin : float\n Intrinsic spin, :math:`I`, of the target nuclide\n\n \"\"\"\n\n def __init__(self, target_spin, energy_min, energy_max, channel, scattering):\n super().__init__(target_spin, energy_min, energy_max, channel,\n scattering)\n self.energies = None\n self.parameters = None\n self.add_to_background = False\n self.atomic_weight_ratio = None\n\n @classmethod\n def from_endf(cls, file_obj, items, fission_widths):\n \"\"\"Read unresolved resonance data from an ENDF evaluation.\n\n Parameters\n ----------\n file_obj : file-like object\n ENDF file positioned at the second record of a resonance range\n subsection in MF=2, MT=151\n items : list\n Items from the CONT record at the start of the resonance range\n subsection\n fission_widths : bool\n Whether fission widths are given\n\n Returns\n -------\n openmc.data.Unresolved\n Unresolved resonance region parameters\n\n \"\"\"\n # Read energy-dependent scattering radius if present\n energy_min, energy_max = items[0:2]\n nro, naps = items[4:6]\n if nro != 0:\n params, ape = get_tab1_record(file_obj)\n\n # Get SPI, AP, and LSSF\n formalism = items[3]\n if not (fission_widths and formalism == 1):\n items = get_cont_record(file_obj)\n target_spin = items[0]\n if nro == 0:\n ap = Polynomial((items[1],))\n add_to_background = (items[2] == 0)\n\n if not fission_widths and formalism == 1:\n # Case A -- fission widths not given, all parameters are\n # energy-independent\n NLS = items[4]\n columns = ['L', 'J', 'd', 'amun', 'gn0', 'gg']\n records = []\n for ls in range(NLS):\n items, values = get_list_record(file_obj)\n awri = items[0]\n l = items[2]\n NJS = items[5]\n for j in range(NJS):\n d, j, amun, gn0, gg = values[6*j:6*j + 5]\n records.append([l, j, d, amun, gn0, gg])\n parameters = pd.DataFrame.from_records(records, columns=columns)\n energies = None\n\n elif fission_widths and formalism == 1:\n # Case B -- fission widths given, only fission widths are\n # energy-dependent\n items, energies = get_list_record(file_obj)\n target_spin = items[0]\n if nro == 0:\n ap = Polynomial((items[1],))\n add_to_background = (items[2] == 0)\n NE, NLS = items[4:6]\n records = []\n columns = ['L', 'J', 'E', 'd', 'amun', 'amuf', 'gn0', 'gg', 'gf']\n for ls in range(NLS):\n items = get_cont_record(file_obj)\n awri = items[0]\n l = items[2]\n NJS = items[4]\n for j in range(NJS):\n items, values = get_list_record(file_obj)\n muf = items[3]\n d = values[0]\n j = values[1]\n amun = values[2]\n gn0 = values[3]\n gg = values[4]\n gfs = values[6:]\n for E, gf in zip(energies, gfs):\n records.append([l, j, E, d, amun, muf, gn0, gg, gf])\n parameters = pd.DataFrame.from_records(records, columns=columns)\n\n elif formalism == 2:\n # Case C -- all parameters are energy-dependent\n NLS = items[4]\n columns = ['L', 'J', 'E', 'd', 'amux', 'amun', 'amuf', 'gx', 'gn0',\n 'gg', 'gf']\n records = []\n for ls in range(NLS):\n items = get_cont_record(file_obj)\n awri = items[0]\n l = items[2]\n NJS = items[4]\n for j in range(NJS):\n items, values = get_list_record(file_obj)\n ne = items[5]\n j = items[0]\n amux = values[2]\n amun = values[3]\n amuf = values[5]\n energies = []\n for k in range(1, ne + 1):\n E = values[6*k]\n d = values[6*k + 1]\n gx = values[6*k + 2]\n gn0 = values[6*k + 3]\n gg = values[6*k + 4]\n gf = values[6*k + 5]\n energies.append(E)\n records.append([l, j, E, d, amux, amun, amuf, gx, gn0,\n gg, gf])\n parameters = pd.DataFrame.from_records(records, columns=columns)\n\n # Calculate channel radius from ENDF-102 equation D.14\n a = Polynomial((0.123 * (NEUTRON_MASS*awri)**(1./3.) + 0.08,))\n\n # Determine scattering and channel radius\n if nro == 0:\n scattering_radius = ap\n if naps == 0:\n channel_radius = a\n elif naps == 1:\n channel_radius = ap\n elif nro == 1:\n scattering_radius = ape\n if naps == 0:\n channel_radius = a\n elif naps == 1:\n channel_radius = ape\n elif naps == 2:\n channel_radius = ap\n\n urr = cls(target_spin, energy_min, energy_max, channel_radius,\n scattering_radius)\n urr.parameters = parameters\n urr.add_to_background = add_to_background\n urr.atomic_weight_ratio = awri\n urr.energies = energies\n\n return urr\n\n\n_FORMALISMS = {0: ResonanceRange,\n 1: SingleLevelBreitWigner,\n 2: MultiLevelBreitWigner,\n 3: ReichMoore,\n 7: RMatrixLimited}\n\n_RESOLVED = (SingleLevelBreitWigner, MultiLevelBreitWigner,\n ReichMoore, RMatrixLimited)\n", "meta": {"hexsha": "628ad184b588a666f57a187107f5eedc54f5938b", "size": 38375, "ext": "py", "lang": "Python", "max_stars_repo_path": "openmc/data/resonance.py", "max_stars_repo_name": "janmalec/openmc", "max_stars_repo_head_hexsha": "4a4ac4c351d41fe153ca3341820cc507e484ce50", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-11-19T14:46:10.000Z", "max_stars_repo_stars_event_max_datetime": "2020-11-19T14:46:10.000Z", "max_issues_repo_path": "openmc/data/resonance.py", "max_issues_repo_name": "janmalec/openmc", "max_issues_repo_head_hexsha": "4a4ac4c351d41fe153ca3341820cc507e484ce50", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2020-02-24T15:13:15.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-17T18:59:22.000Z", "max_forks_repo_path": "openmc/data/resonance.py", "max_forks_repo_name": "janmalec/openmc", "max_forks_repo_head_hexsha": "4a4ac4c351d41fe153ca3341820cc507e484ce50", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.7285067873, "max_line_length": 84, "alphanum_fraction": 0.5718566775, "include": true, "reason": "import numpy,from numpy", "num_tokens": 8669, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.600188359260205, "lm_q2_score": 0.3276682942552091, "lm_q1q2_score": 0.196662695910624}} {"text": "# coding: utf-8\n# Copyright (c) Max-Planck-Institut für Eisenforschung GmbH - Computational Materials Design (CM) Department\n# Distributed under the terms of \"New BSD License\", see the LICENSE file.\n\nimport numpy as np\nfrom pyiron.atomistics.job.interactivewrapper import InteractiveWrapper, ReferenceJobOutput\nfrom pyiron_base import InputList, Settings\n\n__author__ = \"Osamu Waseda\"\n__copyright__ = \"Copyright 2020, Max-Planck-Institut für Eisenforschung GmbH \" \\\n \"- Computational Materials Design (CM) Department\"\n__version__ = \"1.0\"\n__maintainer__ = \"Osamu Waseda\"\n__email__ = \"waseda@mpie.de\"\n__status__ = \"development\"\n__date__ = \"Sep 1, 2018\"\n\ns = Settings()\n\n\nclass ARTInteractive(object):\n def __init__(self, art_id, direction, gamma=0.1, fix_layer=False, non_art_id=None):\n if int(art_id) != art_id or art_id < 0:\n raise ValueError('art_id must be a posive integer')\n if len(direction) != 3 or np.isclose(np.linalg.norm(direction), 0):\n raise ValueError('direction must be a finite 3d vector')\n if gamma < 0:\n raise ValueError('gamma must be a positive float')\n if fix_layer and non_art_id is not None:\n raise ValueError('fix_layer and non_art_id cannot be set at the same time')\n self.art_id = art_id\n self.direction = direction\n self.gamma = gamma\n self.non_art_id = non_art_id\n if non_art_id is not None:\n self.non_art_id = np.array([non_art_id]).flatten()\n self.fix_layer = fix_layer\n\n @property\n def _R(self):\n value = np.array(self.direction)\n value = value / np.linalg.norm(value)\n return np.outer(value, value)\n\n def get_forces(self, f_in):\n f = np.array(f_in)\n if len(f.shape) == 2:\n f = np.array([f])\n if self.non_art_id is None:\n self.non_art_id = np.arange(len(f[0])) != self.art_id\n f_art = (1.0+self.gamma)*np.einsum('ij,nj->ni', self._R, f[:, self.art_id])\n if self.fix_layer:\n f[:, self.non_art_id] = np.einsum('nmj,ij->nmi', f[:, self.non_art_id], np.identity(3)-self._R)\n else:\n f[:, self.non_art_id] += f_art[:, np.newaxis, :] / np.sum(self.non_art_id != False)\n f[:, self.art_id] -= f_art\n return f.reshape(np.array(f_in).shape)\n\nclass ART(InteractiveWrapper):\n \"\"\"\n Apply an artificial force according to the Activation Relaxation Technique (ART)\n DOI:https://doi.org/10.1103/PhysRevE.57.2419\n\n The applied force f_art is calculated from the original force f by:\n\n f_art = f-(1+gamma)*np.dot(n,f)*n\n\n where gamma is a parameter to be determined in the input (default: 0.1) and n is\n the direction along which the force is reversed (3d-vector). In order to homogenize\n the total force in the system, f_art is distributed among atoms specified by\n non_art_id (default: all atoms), or if fix_layer is defined, the forces acting on\n all the other atoms along the direction n are cancelled. Note: Since the energy\n is not compatible with the forces anymore, structure optimization methods which\n rely on the energy variation (such as conjugate gradient) cannot/should not be used.\n\n Input:\n - art_id (int): atom id on which ART force is applied\n - direction (list/numpy.ndarray): direction along which force is reversed\n - gamma (float): prefactor for force inversion. v.s.\n - non_art_id (list/numpy.ndarray): list of atoms to be used for the force cancellation\n - fix_layer (bool): whether or not to fix all other atoms on the layer perpendicular\n to the direction along which force is reversed.\n\n Example:\n\n # Structure creation\n >>> vacancy_position = structure.positions[0]\n >>> del structure[0]\n >>> neighbors = structure.get_neighborhood(vacancy_position)\n >>> direction = neighbors.vecs[0]\n >>> art_id = neighbors.indices[0]\n >>> structure.positions[art_id] -= 0.5*direction\n\n # Job creation\n >>> some_atomistic_job.structure = structure\n >>> art = ART(job_name='art')\n >>> art.ref_job = some_atomistic_job\n >>> art.input.art_id = art_id\n >>> art.input.direction = direction\n >>> some_minimizer.ref_job = art\n >>> some_minimizer.run()\n\n\n \"\"\"\n def __init__(self, project, job_name):\n super(ART, self).__init__(project, job_name)\n self.__name__ = \"ART\"\n self.input = InputList(table_name='custom_dict')\n self.input.gamma = 0.1\n self.input.fix_layer = False\n self.input.non_art_id = None\n self.input.art_id = None\n self.input.direction = None\n self.output = ARTIntOutput(job=self)\n self.server.run_mode.interactive = True\n self._interactive_interface = None\n self._art = None\n\n def set_input_to_read_only(self):\n \"\"\"\n This function enforces read-only mode for the input classes, but it has to be implement in the individual\n classes.\n \"\"\"\n self.input.read_only = True\n\n @property\n def art(self):\n if self._art is None:\n self._art = ARTInteractive(\n art_id=self.input.art_id,\n direction=self.input.direction,\n gamma=self.input.gamma,\n fix_layer=self.input.fix_layer,\n non_art_id=self.input.non_art_id\n )\n return self._art\n\n def run_if_interactive(self):\n self._logger.debug('art status: ' + str(self.status))\n if not self.status.running:\n self.ref_job_initialize()\n self.status.running = True\n if self.ref_job.server.run_mode.interactive:\n self.ref_job.run()\n else:\n self.ref_job.run(run_again=True)\n self._logger.debug('art status: ' + str(self.status))\n\n def interactive_forces_getter(self):\n return self.art.get_forces(self.ref_job.output.forces[-1])\n\n def validate_ready_to_run(self):\n \"\"\"\n check whether art_id and direction are set\n \"\"\"\n if self.input.art_id is None or self.input.direction is None:\n raise AssertionError('art_id and/or direction not set')\n\n def interactive_close(self):\n self.status.collect = True\n if self.ref_job.server.run_mode.interactive:\n self.ref_job.interactive_close()\n self.status.finished = True\n\n\nclass ARTIntOutput(ReferenceJobOutput):\n def __init__(self, job):\n super(ARTIntOutput, self).__init__(job=job)\n\n @property\n def forces(self):\n return self._job.art.get_forces(self._job.ref_job.output.forces)\n", "meta": {"hexsha": "075667a8ade84d7e799386ccbbedf5d295f811dd", "size": 6673, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyiron/interactive/activation_relaxation_technique.py", "max_stars_repo_name": "t-brink/pyiron", "max_stars_repo_head_hexsha": "c07552b54a39e3f036ba395325cd4b372af0f794", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pyiron/interactive/activation_relaxation_technique.py", "max_issues_repo_name": "t-brink/pyiron", "max_issues_repo_head_hexsha": "c07552b54a39e3f036ba395325cd4b372af0f794", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-11-02T09:22:56.000Z", "max_issues_repo_issues_event_max_datetime": "2021-11-02T09:22:56.000Z", "max_forks_repo_path": "pyiron/interactive/activation_relaxation_technique.py", "max_forks_repo_name": "t-brink/pyiron", "max_forks_repo_head_hexsha": "c07552b54a39e3f036ba395325cd4b372af0f794", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-11-02T08:35:47.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-02T08:35:47.000Z", "avg_line_length": 38.5722543353, "max_line_length": 113, "alphanum_fraction": 0.6445376892, "include": true, "reason": "import numpy", "num_tokens": 1583, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5698526514141572, "lm_q2_score": 0.34510527769342453, "lm_q1q2_score": 0.19665915751061697}} {"text": "from __future__ import print_function, absolute_import, division, unicode_literals\n\nimport logging\nfrom collections import namedtuple, deque, OrderedDict\n\nimport casadi as ca\nimport numpy as np\nimport itertools\nfrom typing import Union, Dict, Iterable\n\nfrom pymoca import ast\nfrom pymoca.tree import TreeWalker, TreeListener, flatten\n\nfrom .alias_relation import AliasRelation\nfrom .model import Model, Variable, DelayArgument\nfrom .mtensor import _MTensor, _new_mx\n\nfrom ._options import _merge_default_options\n\nlogger = logging.getLogger(\"pymoca\")\n\n# TODO\n# - Nested for loops\n# - Delay operator on arbitrary expressions\n# - Pre operator\n\nOP_MAP = {'*': \"__mul__\",\n '+': \"__add__\",\n \"-\": \"__sub__\",\n \"/\": \"__div__\",\n '^': \"__pow__\",\n '>': '__gt__',\n '<': '__lt__',\n '<=': '__le__',\n '>=': '__ge__',\n '!=': '__ne__',\n '==': '__eq__',\n \"min\": \"fmin\",\n \"max\": \"fmax\",\n \"abs\": \"fabs\",\n \"and\": \"__mul__\",\n \"or\": \"__add__\"}\n\nForLoopIndexedSymbol = namedtuple('ForLoopIndexedSymbol', ['tree', 'transpose', 'indices'])\n\n\n# noinspection PyPep8Naming,PyUnresolvedReferences\nclass ForLoop:\n def __init__(self, generator, tree):\n self.tree = tree\n self.generator = generator\n i = tree.indices[0]\n e = i.expression\n start = e.start.value\n step = e.step.value\n stop = self.generator.get_integer(e.stop)\n self.values = np.arange(start, stop + step, step, dtype=np.int)\n self.index_variable = _new_mx(i.name)\n self.name = i.name\n self.indexed_symbols = OrderedDict()\n\n def register_indexed_symbol(self, e, index_function, transpose, tree, index_expr=None):\n if isinstance(index_expr, ca.MX) and index_expr is not self.index_variable:\n F = ca.Function('index_expr', [self.index_variable], [index_expr])\n # expr = lambda ar: np.array([F(a)[0] for a in ar], dtype=np.int)\n Fmap = F.map(\"map\", self.generator.map_mode, len(self.values), [], [])\n res = Fmap.call([self.values])\n indices = np.array(res[0].T, dtype=np.int)\n else:\n indices = self.values\n self.indexed_symbols[e] = ForLoopIndexedSymbol(tree, transpose, index_function(indices - 1))\n\n\nAssignment = namedtuple('Assignment', ['left', 'right'])\n\n\nclass GeneratorWalker(TreeWalker):\n \"\"\"TreeWalker that skips processing of annotations\"\"\"\n\n def skip_child(self, tree: ast.Node, child_name: str) -> bool:\n skip = super().skip_child(tree, child_name)\n if isinstance(tree, ast.Class) and child_name == \"annotation\":\n return True\n return skip\n\n def order_keys(self, keys: Iterable[str]):\n # Symbols must come before classes, as we need to access symbol values when creating\n # CasADi interpolant functions.\n return sorted(keys, key=lambda attr: 0 if attr == 'symbols' else 1)\n\n\n# noinspection PyPep8Naming,PyUnresolvedReferences\nclass Generator(TreeListener):\n def __init__(self, root: ast.Tree, class_name: str, options: Dict[str, bool]):\n super(Generator, self).__init__()\n self.src = {}\n self.model = Model()\n self.root = root\n c = self.root.classes[class_name]\n self.nodes = {c: {'time': self.model.time, 'finalTime': self.model.finalTime}}\n self.derivative = {}\n self.for_loops = deque()\n self.functions = {}\n self.entered_classes = deque()\n self.map_mode = 'inline' if options['unroll_loops'] else 'serial'\n self.function_mode = (True, False) if options['inline_functions'] else (False, True)\n self.delay_counter = 0\n\n # NOTE: Part of MTensor workaround.\n self._expand_vectors_enabled = options['expand_vectors']\n\n @property\n def current_class(self):\n return self.entered_classes[-1]\n\n def _ast_symbols_to_variables(self, ast_symbols, differentiate=False):\n variables = []\n for ast_symbol in ast_symbols:\n mx_symbol = self.get_mx(ast_symbol)\n modelica_shape = mx_symbol._modelica_shape\n if mx_symbol.is_empty():\n continue\n if differentiate:\n mx_symbol = self.get_derivative(mx_symbol)\n mx_symbol._modelica_shape = modelica_shape\n python_type = self.get_python_type(ast_symbol)\n variable = Variable(mx_symbol, python_type)\n if not differentiate:\n for a in ast.Symbol.ATTRIBUTES:\n v = self.get_mx(getattr(ast_symbol, a))\n if v is not None:\n if isinstance(v, ca.DM) and all(x == (None,) for x in modelica_shape):\n # Scalar numeric type that behaves like an array.\n # Coerce to Pyhton type to avoid interpretation\n # issues.\n v = python_type(v)\n elif isinstance(v, (float, int)) and not isinstance(v, python_type):\n # We skip booleans for now, as users likely depend\n # on them being integer/float-like.\n try:\n v = python_type(v)\n except (OverflowError, ValueError):\n # Cannot convert NaN/infs to integer\n pass\n\n setattr(variable, a, v)\n variable.prefixes = ast_symbol.prefixes\n variables.append(variable)\n return variables\n\n def enterClass(self, tree):\n logger.debug('enterClass {}'.format(tree.name))\n\n self.entered_classes.append(tree)\n self.nodes.setdefault(tree, {})\n\n def exitClass(self, tree):\n logger.debug('exitClass {}'.format(tree.name))\n\n if tree.type == 'function':\n # Already handled previously\n self.entered_classes.pop()\n return\n\n ode_states = []\n alg_states = []\n inputs = []\n constants = []\n parameters = []\n symbols = sorted(tree.symbols.values(), key=lambda x: x.order)\n for s in symbols:\n if 'constant' in s.prefixes:\n constants.append(s)\n elif 'parameter' in s.prefixes:\n parameters.append(s)\n elif 'input' in s.prefixes:\n inputs.append(s)\n elif 'state' in s.prefixes:\n ode_states.append(s)\n else:\n alg_states.append(s)\n\n self.model.states = self._ast_symbols_to_variables(ode_states)\n self.model.der_states = self._ast_symbols_to_variables(ode_states, differentiate=True)\n self.model.alg_states = self._ast_symbols_to_variables(alg_states)\n self.model.constants = self._ast_symbols_to_variables(constants)\n self.model.parameters = self._ast_symbols_to_variables(parameters)\n\n # We extend the input list, as it is already populated with delayed states.\n self.model.inputs.extend(self._ast_symbols_to_variables(inputs))\n\n # The outputs are a list of strings of state names. Specifying\n # multiple aliases of the same state is allowed.\n self.model.outputs = [v.symbol.name() for v in itertools.chain(self.model.states, self.model.alg_states) if 'output' in v.prefixes]\n\n def discard_empty(l):\n return list(filter(lambda x: not ca.MX(x).is_empty(), l))\n\n self.model.equations = discard_empty([self.get_mx(e) for e in tree.equations])\n self.model.initial_equations = discard_empty([self.get_mx(e) for e in tree.initial_equations])\n\n # TODO: check if it is valid (like not empty equation)\n self.model.constraints = [self.get_mx(e) for e in tree.constraints]\n\n if tree.type == 'optimization':\n self.model.optimization_attributes = {argument.value.component.name: self.src[argument.value.modifications[0]] for argument in tree.optimization_attributes.arguments}\n\n if len(tree.statements) + len(tree.initial_statements) > 0:\n raise NotImplementedError('Statements are currently supported inside functions only')\n\n self.entered_classes.pop()\n\n def exitArray(self, tree):\n self.src[tree] = [self.src[e] for e in tree.values]\n\n def exitPrimary(self, tree):\n self.src[tree] = tree.value\n\n def exitExpression(self, tree):\n if isinstance(tree.operator, ast.ComponentRef):\n op = tree.operator.name\n else:\n op = tree.operator\n\n if op == '*':\n op = 'mtimes' # .* differs from *\n if op.startswith('.'):\n op = op[1:]\n\n logger.debug('exitExpression')\n\n n_operands = len(tree.operands)\n if op == 'der':\n v = self.get_mx(tree.operands[0])\n src = self.get_derivative(v)\n elif op == '-' and n_operands == 1:\n src = -self.get_mx(tree.operands[0])\n elif op == 'not' and n_operands == 1:\n src = ca.if_else(self.get_mx(tree.operands[0]), 0, 1, True)\n elif op == 'mtimes':\n assert n_operands >= 2\n src = self.get_mx(tree.operands[0])\n for i in tree.operands[1:]:\n src = ca.mtimes(src, self.get_mx(i))\n elif op == 'transpose' and n_operands == 1:\n src = self.get_mx(tree.operands[0]).T\n elif op == 'sum' and n_operands == 1:\n v = self.get_mx(tree.operands[0])\n src = ca.sum1(v)\n elif op == 'linspace' and n_operands == 3:\n a = self.get_mx(tree.operands[0])\n b = self.get_mx(tree.operands[1])\n n_steps = self.get_integer(tree.operands[2])\n src = ca.linspace(a, b, n_steps)\n elif op == 'fill' and n_operands == 2:\n val = self.get_mx(tree.operands[0])\n n_row = self.get_integer(tree.operands[1])\n src = val * ca.DM.ones(n_row)\n elif op == 'fill' and n_operands == 3:\n val = self.get_mx(tree.operands[0])\n n_row = self.get_integer(tree.operands[1])\n n_col = self.get_integer(tree.operands[2])\n src = val * ca.DM.ones(n_row, n_col)\n elif op == 'zeros' and n_operands == 1:\n n_row = self.get_integer(tree.operands[0])\n src = ca.DM.zeros(n_row)\n elif op == 'zeros' and n_operands == 2:\n n_row = self.get_integer(tree.operands[0])\n n_col = self.get_integer(tree.operands[1])\n src = ca.DM.zeros(n_row, n_col)\n elif op == 'ones' and n_operands == 1:\n n_row = self.get_integer(tree.operands[0])\n src = ca.DM.ones(n_row)\n elif op == 'ones' and n_operands == 2:\n n_row = self.get_integer(tree.operands[0])\n n_col = self.get_integer(tree.operands[1])\n src = ca.DM.ones(n_row, n_col)\n elif op == 'identity' and n_operands == 1:\n n = self.get_integer(tree.operands[0])\n src = ca.DM.eye(n)\n elif op == 'diagonal' and n_operands == 1:\n diag = self.get_mx(tree.operands[0])\n n = len(diag)\n indices = list(range(n))\n src = ca.DM.triplet(indices, indices, diag, n, n)\n elif op == 'cat':\n axis = self.get_integer(tree.operands[0])\n assert axis == 1, \"Currently only concatenation on first axis is supported\"\n\n entries = []\n for sym in [self.get_mx(op) for op in tree.operands[1:]]:\n if isinstance(sym, list):\n for e in sym:\n entries.append(e)\n else:\n entries.append(sym)\n src = ca.vertcat(*entries)\n elif op == 'delay' and n_operands == 2:\n expr = self.get_mx(tree.operands[0])\n duration = self.get_mx(tree.operands[1])\n\n src = _new_mx('_pymoca_delay_{}'.format(self.delay_counter), *expr.size())\n self.delay_counter += 1\n\n for f in self.for_loops:\n syms = set(ca.symvar(expr))\n if syms.intersection(f.indexed_symbols):\n f.register_indexed_symbol(src, lambda i: i, True, tree.operands[0], f.index_variable)\n\n self.model.delay_states.append(src.name())\n self.model.inputs.append(Variable(src))\n\n delay_argument = DelayArgument(expr, duration)\n self.model.delay_arguments.append(delay_argument)\n elif op == '_pymoca_interp1d' and n_operands >= 3 and n_operands <= 4:\n entered_class = self.entered_classes[-1]\n if isinstance(tree.operands[0], ast.ComponentRef):\n xp = self.get_mx(entered_class.symbols[tree.operands[0].name].value)\n else:\n xp = self.get_mx(tree.operands[0])\n if isinstance(tree.operands[1], ast.ComponentRef):\n yp = self.get_mx(entered_class.symbols[tree.operands[1].name].value)\n else:\n yp = self.get_mx(tree.operands[1])\n arg = self.get_mx(tree.operands[2])\n if n_operands == 4:\n assert isinstance(tree.operands[3], ast.Primary)\n mode = tree.operands[3].value\n else:\n mode = 'linear'\n func = ca.interpolant('interpolant', mode, [xp], yp)\n src = func(arg)\n elif op == '_pymoca_interp2d' and n_operands >= 5 and n_operands <= 6:\n entered_class = self.entered_classes[-1]\n if isinstance(tree.operands[0], ast.ComponentRef):\n xp = self.get_mx(entered_class.symbols[tree.operands[0].name].value)\n else:\n xp = self.get_mx(tree.operands[0])\n if isinstance(tree.operands[1], ast.ComponentRef):\n yp = self.get_mx(entered_class.symbols[tree.operands[1].name].value)\n else:\n yp = self.get_mx(tree.operands[1])\n if isinstance(tree.operands[2], ast.ComponentRef):\n zp = self.get_mx(entered_class.symbols[tree.operands[2].name].value)\n else:\n zp = self.get_mx(tree.operands[2])\n arg_1 = self.get_mx(tree.operands[3])\n arg_2 = self.get_mx(tree.operands[4])\n if n_operands == 6:\n assert isinstance(tree.operands[5], ast.Primary)\n mode = tree.operands[5].value\n else:\n mode = 'linear'\n func = ca.interpolant('interpolant', mode, [xp, yp], np.array(zp).ravel(order='F'))\n src = func(ca.vertcat(arg_1, arg_2))\n elif op in OP_MAP and n_operands == 2:\n lhs = ca.MX(self.get_mx(tree.operands[0]))\n rhs = ca.MX(self.get_mx(tree.operands[1]))\n lhs_op = getattr(lhs, OP_MAP[op])\n src = lhs_op(rhs)\n elif op in OP_MAP and n_operands == 1:\n lhs = ca.MX(self.get_mx(tree.operands[0]))\n lhs_op = getattr(lhs, OP_MAP[op])\n src = lhs_op()\n else:\n src = ca.MX(self.get_mx(tree.operands[0]))\n # Check for built-in operations, such as the\n # elementary functions, first.\n if hasattr(src, op) and n_operands <= 2:\n if n_operands == 1:\n src = ca.MX(self.get_mx(tree.operands[0]))\n src = getattr(src, op)()\n else:\n lhs = ca.MX(self.get_mx(tree.operands[0]))\n rhs = ca.MX(self.get_mx(tree.operands[1]))\n lhs_op = getattr(lhs, op)\n src = lhs_op(rhs)\n else:\n try: # Check if there is a component named as the operation. In that case we are dealing with a time access\n # Should we check for symbol as well?\n v = self.get_mx(ast.ComponentRef(name=op))\n t = self.get_mx(tree.operands[0])\n src = self.get_symbol_time_access(v, t)\n\n except KeyError:\n func = self.get_function(op)\n src = ca.vertcat(*func.call([self.get_mx(operand) for operand in tree.operands], *self.function_mode))\n\n self.src[tree] = src\n\n def exitIfExpression(self, tree):\n logger.debug('exitIfExpression')\n\n assert (len(tree.conditions) + 1 == len(tree.expressions))\n\n src = self.get_mx(tree.expressions[-1])\n for cond_index in range(len(tree.conditions)):\n cond = self.get_mx(tree.conditions[-(cond_index + 1)])\n expr1 = self.get_mx(tree.expressions[-(cond_index + 2)])\n\n src = ca.if_else(cond, expr1, src, True)\n\n self.src[tree] = src\n \n def exitConstraint(self, tree):\n logger.debug('exitConstraint')\n\n src_left = self.get_mx(tree.left)\n src_right = self.get_mx(tree.right)\n\n # Always return bigger equal constraints\n if tree.operand == '>=':\n self.src[tree] = src_left - src_right\n elif tree.operand == '<=':\n self.src[tree] = src_right - src_left\n else:\n raise Exception('Operand {} is not supported in constraints'.format(tree.operand))\n\n\n def exitEquation(self, tree):\n logger.debug('exitEquation')\n\n if isinstance(tree.left, list):\n src_left = ca.vertcat(*[self.get_mx(c) for c in tree.left])\n else:\n src_left = self.get_mx(tree.left)\n\n if isinstance(tree.right, list):\n src_right = ca.vertcat(*[self.get_mx(c) for c in tree.right])\n else:\n src_right = self.get_mx(tree.right)\n\n src_left = ca.MX(src_left)\n src_right = ca.MX(src_right)\n\n # According to the Modelica spec,\n # \"It is possible to omit left hand side component references and/or truncate the left hand side list in order to discard outputs from a function call.\"\n if isinstance(tree.right, ast.Expression) and tree.right.operator in self.root.classes:\n if src_left.size1() < src_right.size1():\n src_right = src_right[0:src_left.size1()]\n if isinstance(tree.left, ast.Expression) and tree.left.operator in self.root.classes:\n if src_left.size1() > src_right.size1():\n src_left = src_left[0:src_right.size1()]\n\n # If dimensions between the lhs and rhs do not match, but the dimensions of lhs\n # and transposed rhs do match, transpose the rhs.\n if src_left.shape != src_right.shape and src_left.shape == src_right.shape[::-1]:\n src_right = ca.transpose(src_right)\n\n self.src[tree] = src_left - src_right\n\n def enterForEquation(self, tree):\n logger.debug('enterForEquation')\n\n self.for_loops.append(ForLoop(self, tree))\n\n def exitForEquation(self, tree):\n logger.debug('exitForEquation')\n\n f = self.for_loops.pop()\n if len(f.values) > 0:\n indexed_symbols = list(f.indexed_symbols.keys())\n args = [f.index_variable] + indexed_symbols\n expr = ca.vcat([ca.vec(self.get_mx(e)) for e in tree.equations])\n free_vars = ca.symvar(expr)\n\n arg_names = [arg.name() for arg in args]\n free_vars = [e for e in free_vars if e.name() not in arg_names]\n all_args = args + free_vars\n F = ca.Function('loop_body', all_args, [expr])\n\n indexed_symbols_full = []\n for k in indexed_symbols:\n s = f.indexed_symbols[k]\n indices = s.indices\n try:\n i = self.model.delay_states.index(k.name())\n except ValueError:\n orig_symbol = self.nodes[self.current_class][s.tree.name]\n else:\n # We are missing a similarly shaped delayed symbol. Make a new one with the appropriate shape.\n delay_symbol = self.model.delay_arguments[i]\n\n # We need to figure out the shape of the expression that\n # we are delaying. The symbols that can occur in the delay\n # expression should have been encountered before this\n # iteration of the loop. The assert statement below covers\n # this.\n delay_expr_args = free_vars + all_args[:len(indexed_symbols_full)+1]\n assert set(ca.symvar(delay_symbol.expr)).issubset(delay_expr_args)\n\n f_delay_expr = ca.Function('delay_expr', delay_expr_args, [delay_symbol.expr])\n f_delay_map = f_delay_expr.map(\"map\", self.map_mode, len(f.values), list(\n range(len(free_vars))), [])\n [res] = f_delay_map.call(free_vars + [f.values] + indexed_symbols_full)\n res = res.T\n\n # Make the symbol with the appropriate size, and replace the old symbol with the new one.\n orig_symbol = _new_mx(k.name(), *res.size())\n assert res.size1() == 1 or res.size2() == 1, \"Slicing does not yet work with 2-D indices\"\n indices = slice(None, None)\n\n model_input = next(x for x in self.model.inputs if x.symbol.name() == k.name())\n model_input.symbol = orig_symbol\n self.model.delay_arguments[i] = DelayArgument(res, delay_symbol.duration)\n\n indexed_symbol = orig_symbol[indices]\n if s.transpose:\n indexed_symbol = ca.transpose(indexed_symbol)\n indexed_symbols_full.append(indexed_symbol)\n\n Fmap = F.map(\"map\", self.map_mode, len(f.values), list(\n range(len(args), len(all_args))), [])\n res = Fmap.call([f.values] + indexed_symbols_full + free_vars)\n\n self.src[tree] = res[0].T\n else:\n self.src[tree] = ca.MX()\n\n def exitIfEquation(self, tree):\n logger.debug('exitIfEquation')\n\n # Check if every equation block contains the same number of equations\n if len(set((len(x) for x in tree.blocks))) != 1:\n raise Exception(\"Every branch in an if-equation needs the same number of equations.\")\n\n # NOTE: We currently assume that we always have an else-clause. This\n # is not strictly necessary, see the Modelica Spec on if equations.\n assert tree.conditions[-1] == True\n\n src = ca.vertcat(*[self.get_mx(e) for e in tree.blocks[-1]])\n\n for cond_index in range(1, len(tree.conditions)):\n cond = self.get_mx(tree.conditions[-(cond_index + 1)])\n expr1 = ca.vertcat(*[self.get_mx(e) for e in tree.blocks[-(cond_index + 1)]])\n src = ca.if_else(cond, expr1, src, True)\n\n self.src[tree] = src\n\n def exitAssignmentStatement(self, tree):\n logger.debug('exitAssignmentStatement')\n\n all_assignments = []\n\n expr = self.get_mx(tree.right)\n for component_ref in tree.left:\n all_assignments.append(Assignment(self.get_mx(component_ref), expr))\n\n self.src[tree] = all_assignments\n\n def exitIfStatement(self, tree):\n logger.debug('exitIfStatement')\n\n # We assume an equal number of statements per branch.\n # Furthermore, we assume that every branch assigns to the same variables.\n assert len(set((len(x) for x in tree.blocks))) == 1\n\n # NOTE: We currently assume that we always have an else-clause. This\n # is not strictly necessary, see the Modelica Spec on if statements.\n assert tree.conditions[-1] == True\n\n expanded_blocks = OrderedDict()\n\n for b in tree.blocks:\n block_assignments = []\n for s in b:\n assignments = self.get_mx(s)\n for assignment in assignments:\n expanded_blocks.setdefault(assignment.left, []).append(assignment.right)\n\n assert len(set((len(x) for x in expanded_blocks.values()))) == 1\n\n all_assignments = []\n\n for lhs, values in expanded_blocks.items():\n # Set default value to else block, and then loop in reverse over all branches\n src = values[-1]\n for cond, rhs in zip(tree.conditions[-2::-1], values[-2::-1]):\n cond = self.get_mx(cond)\n src = ca.if_else(cond, rhs, src, True)\n\n all_assignments.append(Assignment(lhs, src))\n\n self.src[tree] = all_assignments\n\n def enterForStatement(self, tree):\n logger.debug('enterForStatement')\n\n self.for_loops.append(ForLoop(self, tree))\n\n def exitForStatement(self, tree):\n logger.debug('exitForStatement')\n\n f = self.for_loops.pop()\n if len(f.values) > 0:\n indexed_symbols = list(f.indexed_symbols.keys())\n args = [f.index_variable] + indexed_symbols\n expr = ca.vcat([ca.vec(self.get_mx(e.right)) for e in tree.statements])\n free_vars = ca.symvar(expr)\n\n arg_names = [arg.name() for arg in args]\n free_vars = [e for e in free_vars if e.name() not in arg_names]\n all_args = args + free_vars\n F = ca.Function('loop_body', all_args, [expr])\n\n indexed_symbols_full = []\n for k in indexed_symbols:\n s = f.indexed_symbols[k]\n orig_symbol = self.nodes[self.current_class][s.tree.name]\n indexed_symbol = orig_symbol[s.indices]\n if s.transpose:\n indexed_symbol = ca.transpose(indexed_symbol)\n indexed_symbols_full.append(indexed_symbol)\n\n Fmap = F.map(\"map\", self.map_mode, len(f.values), list(\n range(len(args), len(all_args))), [])\n res = Fmap.call([f.values] + indexed_symbols_full + free_vars)\n\n # Split into a list of statements\n variables = [assignment.left for statement in tree.statements for assignment in self.get_mx(statement)]\n all_assignments = []\n for i in range(len(f.values)):\n for j, variable in enumerate(variables):\n all_assignments.append(Assignment(variable, res[0][j, i].T))\n\n self.src[tree] = all_assignments\n else:\n self.src[tree] = []\n\n def get_integer(self, tree: Union[ast.Primary, ast.ComponentRef, ast.Expression, ast.Slice]) -> Union[int, ca.MX, np.ndarray]:\n # CasADi needs to know the dimensions of symbols at instantiation.\n # We therefore need a mechanism to evaluate expressions that define dimensions of symbols.\n if isinstance(tree, ast.Primary):\n return None if tree.value is None else int(tree.value)\n if isinstance(tree, ast.ComponentRef):\n s = self.current_class.symbols[tree.name]\n assert (s.type.name == 'Integer')\n return self.get_integer(s.value)\n if isinstance(tree, ast.Expression):\n # Make sure that the expression has been converted to MX by (re)visiting the\n # relevant part of the AST.\n ast_walker = TreeWalker()\n ast_walker.walk(self, tree)\n\n # Obtain expression\n expr = self.get_mx(tree)\n\n # Obtain the symbols it depends on\n free_vars = ca.symvar(expr)\n\n # Find the values of the symbols\n vals = []\n for free_var in free_vars:\n if free_var.is_symbolic():\n if (len(self.for_loops) > 0) and (free_var.name() == self.for_loops[-1].name):\n vals.append(self.for_loops[-1].index_variable)\n else:\n vals.append(self.get_integer(self.current_class.symbols[free_var.name()].value))\n\n # Evaluate the expression\n F = ca.Function('get_integer', free_vars, [expr])\n ret = F.call(vals, *self.function_mode)\n if ret[0].is_constant():\n # We managed to evaluate the expression. Assume the result to be integer.\n return int(ret[0])\n else:\n # Expression depends on other symbols. Could not extract integer value.\n return ret[0]\n if isinstance(tree, ast.Slice):\n start = self.get_integer(tree.start)\n step = self.get_integer(tree.step)\n stop = self.get_integer(tree.stop)\n return slice(start, stop, step)\n else:\n raise Exception('Unexpected node type {}'.format(tree.__class__.__name__))\n\n @staticmethod\n def get_python_type(tree):\n if tree.type.name == 'Boolean':\n return bool\n elif tree.type.name == 'Integer':\n return int\n else:\n return float\n\n def get_shape(self, tree):\n return [[self.get_integer(d) for d in d_list] for d_list in tree.dimensions]\n\n def get_symbol(self, tree):\n # Create symbol\n shape = self.get_shape(tree)\n\n if any(isinstance(x, slice) for var_shape in shape for x in var_shape):\n # Symbol has unspecified dimensions. Value is specified, and\n # carries the correct dimensions.\n\n # We should only get slices as dimensions for a symbol if one of\n # the dimensions is unspecified, i.e. None.\n assert None in (itertools.chain.from_iterable((x.start, x.stop)\n for var_shape in shape for x in var_shape if isinstance(x, slice)))\n\n val_shape = np.array(self.src[tree.value]).shape\n\n # Check if specified dimensions agree between definition and value\n val_dim_i = -1\n for var_i, var_shape in enumerate(shape):\n for dim_i, dim_size in enumerate(var_shape):\n if dim_size is None:\n continue\n\n val_dim_i += 1\n if isinstance(dim_size, slice):\n shape[var_i][dim_i] = val_shape[val_dim_i]\n continue\n\n if val_shape[val_dim_i] != dim_size:\n raise Exception(\"Dimension {} of definition and value for symbol {} \"\n \"differs: {} != {}\"\n .format(val_dim_i + 1, tree.name, dim_size,\n val_shape[val_dim_i]))\n\n tensor_shape = [d for var_shape in shape for d in var_shape if d is not None]\n if len(tensor_shape) > 2:\n # MX does not support this, so we have to use our own wrapper.\n if not self._expand_vectors_enabled:\n raise NotImplementedError(\"Cannot handle 3D+ arrays without setting 'expand_vectors'\")\n s = _MTensor(tree.name, *tensor_shape)\n else:\n s = _new_mx(tree.name, *tensor_shape)\n\n # Make a notion of the original shape, as MX is always 2D (even for 1D symbols),\n # and for nested classes we want to remember at which symbols to place indices.\n s._modelica_shape = tuple([tuple(var_shape) for var_shape in shape])\n\n self.nodes[self.current_class][tree.name] = s\n return s\n\n def get_derivative(self, s):\n\n # Case 1: s is a constant, e.g. MX(5)\n if ca.MX(s).is_constant():\n return 0\n\n # Case 2: s is a symbol, e.g. MX(x)\n elif s.is_symbolic():\n if s.name() not in self.derivative:\n if len(self.for_loops) > 0 and s in self.for_loops[-1].indexed_symbols:\n # Create a new indexed symbol, referencing to the for loop index inside the vector derivative symbol.\n for_loop_symbol = self.for_loops[-1].indexed_symbols[s]\n s_without_index = self.get_mx(ast.ComponentRef(name=for_loop_symbol.tree.name))\n der_s_without_index = self.get_derivative(s_without_index)\n if ca.MX(der_s_without_index).is_symbolic():\n return self.get_indexed_symbol(ast.ComponentRef(name=der_s_without_index.name(), indices=for_loop_symbol.tree.indices), der_s_without_index)\n else:\n return 0\n else:\n der_s = _new_mx(\"der({})\".format(s.name()), s.size())\n # If the derivative contains an expression (e.g. der(x + y)) this method is\n # called with MX variables that are the result of a ca.symvar call. This\n # ca.symvar call strips the _modelica_shape field from the MX variable,\n # therefore we need to find the original MX to get the modelica shape.\n der_s._modelica_shape = \\\n self.nodes[self.current_class][s.name()]._modelica_shape\n self.derivative[s.name()] = der_s\n self.nodes[self.current_class][der_s.name()] = der_s\n return der_s\n else:\n return self.derivative[s.name()]\n\n # Case 3: s is an already indexed symbol, e.g. MX(x[1])\n elif s.is_op(ca.OP_GETNONZEROS) and s.dep().is_symbolic():\n slice_info = s.info()['slice']\n dep = s.dep()\n if dep.name() not in self.derivative:\n der_dep = _new_mx(\"der({})\".format(dep.name()), dep.size())\n der_dep._modelica_shape = \\\n self.nodes[self.current_class][dep.name()]._modelica_shape\n self.derivative[dep.name()] = der_dep\n self.nodes[self.current_class][der_dep.name()] = der_dep\n return der_dep[slice_info['start']:slice_info['stop']:slice_info['step']]\n else:\n return self.derivative[dep.name()][slice_info['start']:slice_info['stop']:slice_info['step']]\n\n # Case 4: s is an expression that requires differentiation, e.g. MX(x2 * x2)\n # Need to do this sort of expansion: der(x1 * x2) = der(x1) * x2 + x1 * der(x2)\n else:\n # Differentiate expression using CasADi\n orig_deps = ca.symvar(s)\n deps = ca.vertcat(*orig_deps)\n J = ca.Function('J', [deps], [ca.jacobian(s, deps)])\n J_sparsity = J.sparsity_out(0)\n der_deps = [self.get_derivative(dep) if J_sparsity.has_nz(0, j) else ca.DM.zeros(dep.size()) for j, dep in enumerate(orig_deps)]\n return ca.mtimes(J(deps), ca.vertcat(*der_deps))\n\n def get_indexed_symbol(self, tree, s):\n assert len([dim for shape in s._modelica_shape for dim in shape if dim is not None]) <= 2,\\\n \"Dimensions higher than two are not yet supported\"\n\n assert len(s._modelica_shape) >= len(tree.indices)\n\n # For nested variables where an equation is defined at one of the nested models,\n # the modelica shape will contain the shape for the whole nested variable, but the indices\n # will only contain the indices for the symbol in the nested model. We only use the last\n # part of _modelica_shape in this case.\n assert tree.indices\n shapes = s._modelica_shape[-len(tree.indices):]\n\n # Check whether we loop over an index of this symbol\n indices = []\n for_loop = None\n for i, (index_array, shape) in enumerate(zip(tree.indices, shapes)):\n if len(index_array) > len(shape):\n symbol_name = s.name() if len(tree.indices) == 1 \\\n else s.name().split('.')[i] + ' in nested symbol ' + s.name()\n raise ValueError('Too many indices found for symbol {}, check if the symbol has '\n 'the correct dimensions.'.format(symbol_name))\n\n for index, dim in zip(index_array, shape):\n if index is None and dim is None:\n continue\n\n sl = None\n\n if isinstance(index, ast.ComponentRef):\n for f in self.for_loops:\n if index.name == f.name:\n # TODO support nested loops\n for_loop = f\n sl = for_loop.index_variable\n\n if sl is None:\n sl = self.get_integer(index) if index is not None else None\n\n if sl is None and dim is not None:\n sl = slice(None, None, 1)\n if sl is not None and dim is None:\n symbol_name = s.name() if len(tree.indices) == 1 \\\n else s.name().split('.')[i] + ' in nested symbol ' + s.name()\n raise ValueError('Symbol {} was given an index of {} but this symbol '\n 'is not an array.'.format(symbol_name, sl))\n elif isinstance(sl, int):\n # Modelica indexing starts from one; Python from zero.\n if sl <= 0 or sl > dim:\n symbol_name = s.name() if len(tree.indices) == 1 \\\n else s.name().split('.')[i] + ' in nested symbol ' + s.name()\n raise ValueError(\"Index {} of symbol {} is out of bounds. \"\n \"Index should be in range [1,{}] \"\n \"(Modelica uses 1-based indexing).\"\n .format(sl, symbol_name, dim))\n sl = sl - 1\n elif isinstance(sl, slice):\n # Modelica indexing starts from one; Python from zero.\n sl = slice(None if sl.start is None else sl.start - 1, sl.stop, sl.step)\n else:\n for_loop = self.for_loops[-1]\n\n indices.append(sl)\n\n if for_loop is not None:\n if isinstance(indices[0], ca.MX):\n if len(indices) > 1:\n s = s[:, indices[1]]\n indexed_symbol = _new_mx('{}[{},{}]'.format(tree.name, for_loop.name, indices[1]), s.size2())\n index_function = lambda i : (i, indices[1])\n else:\n indexed_symbol = _new_mx('{}[{}]'.format(tree.name, for_loop.name))\n index_function = lambda i : i\n\n # If the indexed symbol is empty, we know we do not have to\n # map the for loop over it\n if np.prod(s.shape) != 0:\n for_loop.register_indexed_symbol(indexed_symbol, index_function, True, tree, indices[0])\n else:\n s = ca.transpose(s[indices[0], :])\n indexed_symbol = _new_mx('{}[{},{}]'.format(tree.name, indices[0], for_loop.name), s.size2())\n index_function = lambda i: (indices[0], i)\n if np.prod(s.shape) != 0:\n for_loop.register_indexed_symbol(indexed_symbol, index_function, False, tree, indices[1])\n return indexed_symbol\n else:\n if len(indices) == 1:\n return s[indices[0]]\n else:\n return s[indices[0], indices[1]]\n\n def get_symbol_time_access(self, v, t):\n return _new_mx('{}({})'.format(v.name(), str(t)), v.size())\n\n\n def get_component(self, tree):\n # Check special symbols\n if tree.name == 'time':\n return self.model.time\n elif tree.name == 'finalTime':\n return self.model.finalTime\n else:\n for f in reversed(self.for_loops):\n if f.name == tree.name:\n return f.index_variable\n\n # Check ordinary symbols\n symbol = self.current_class.symbols[tree.name]\n s = self.get_mx(symbol)\n if len([index for index_array in tree.indices\n for index in index_array if index is not None]) > 0:\n s = self.get_indexed_symbol(tree, s)\n return s\n\n def get_mx(self, tree: Union[ast.Symbol, ast.ComponentRef, ast.Expression]) -> ca.MX:\n \"\"\"\n We pull components and symbols from the AST on demand.\n This is to ensure that parametrized vector dimensions can be resolved. Vector\n dimensions need to be known at CasADi MX creation time.\n :param tree:\n :return:\n \"\"\"\n if tree not in self.src:\n if isinstance(tree, ast.Symbol):\n s = self.get_symbol(tree)\n elif isinstance(tree, ast.ComponentRef):\n s = self.get_component(tree)\n else:\n raise Exception('Tried to look up expression before it was reached by the tree walker')\n self.src[tree] = s\n return self.src[tree]\n\n def get_function(self, function_name):\n if function_name in self.functions:\n return self.functions[function_name]\n\n try:\n tree = self.root.classes[function_name]\n except KeyError:\n raise Exception('Unknown function {}'.format(function_name))\n\n inputs = []\n outputs = []\n tmp = []\n for s in tree.symbols.values():\n src = self.get_mx(s)\n if 'input' in s.prefixes:\n inputs.append(src)\n elif 'output' in s.prefixes:\n outputs.append(src)\n else:\n tmp.append(src)\n\n # Store current variable values\n values = {}\n for variable in inputs:\n values[variable] = variable\n\n # Process statements in order\n for statement in tree.statements:\n src = self.get_mx(statement)\n for assignment in src:\n [values[assignment.left]] = ca.substitute([assignment.right], list(values.keys()), list(values.values()))\n\n output_expr = ca.substitute([values[output] for output in outputs], tmp, [values[t] for t in tmp])\n func = ca.Function(tree.name, inputs, output_expr)\n self.functions[function_name] = func\n\n return func\n\n\ndef generate(ast_tree: ast.Tree, model_name: str, options: Dict[str, bool]=None) -> Model:\n \"\"\"\n :param ast_tree: AST to generate from\n :param model_name: class to generate\n :param options: dictionary of generator options\n :return: casadi model\n \"\"\"\n options = _merge_default_options(options)\n\n\n component_ref = ast.ComponentRef.from_string(model_name)\n ast_walker = GeneratorWalker()\n flat_tree = flatten(ast_tree, component_ref)\n component_ref_tuple = component_ref.to_tuple()\n casadi_gen = Generator(flat_tree, component_ref_tuple[-1], options)\n ast_walker.walk(casadi_gen, flat_tree)\n return casadi_gen.model\n", "meta": {"hexsha": "670d0e007809a4701dcedec008bc22b07f739890", "size": 42683, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/pymoca/backends/casadi/generator.py", "max_stars_repo_name": "PeterRabbit95/pymoca", "max_stars_repo_head_hexsha": "e10d7b14538062a144026be2c6fa3e0d1a8cfad3", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/pymoca/backends/casadi/generator.py", "max_issues_repo_name": "PeterRabbit95/pymoca", "max_issues_repo_head_hexsha": "e10d7b14538062a144026be2c6fa3e0d1a8cfad3", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/pymoca/backends/casadi/generator.py", "max_forks_repo_name": "PeterRabbit95/pymoca", "max_forks_repo_head_hexsha": "e10d7b14538062a144026be2c6fa3e0d1a8cfad3", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.4211597152, "max_line_length": 178, "alphanum_fraction": 0.5674624558, "include": true, "reason": "import numpy", "num_tokens": 9301, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5698526368038304, "lm_q2_score": 0.34510527769342453, "lm_q1q2_score": 0.19665915246851606}} {"text": "\"\"\"\nA Python interface to CPTEC's Plume Rise Model.\n\nTO DO: Create a base class name PLUMES and share code with the LockPlume.\n\n\"\"\"\n\nfrom numpy import zeros, ones, meshgrid, linspace, any, \\\n pi, sin, cos, arccos, arange, array, \\\n savez, NaN, isnan\n\nfrom scipy import optimize as opt\n\nfrom datetime import datetime, date, timedelta\nfrom glob import glob\n\nfrom dozier import DOZIER, granules\nfrom PlumeRise_ import * # f2py extension\nfrom gfio import GFIO\n\nfrom pyobs import NPZ, kde\nfrom pyobs.binObs_ import binareas\nfrom pyobs.minx import MINXs\nfrom MAPL.constants import *\n\nimport eta\n\n__VERSION__ = 2.1\n__CVSTAG__ = '@CVSTAG'\n__AMISS__ = 1.E+20\n\nBioma = [ 'Tropical Forest',\n 'Extra-Tropical Forest',\n 'Savanna',\n 'Grassland' ]\n\nDAY = timedelta(seconds=60*60*24)\n\n#----------------------------------------------------------------------------------------------\n\n#----\nclass MINXs_PR(MINXs):\n\n \"\"\"\n Extension of the MINXs class adding the Freitas Plume Rise\n functionality. This class handles non-gridded, observation\n location fires.\n\n Parabolic Vertical Mass Distribution (VMD)\n ------------------------------------------\n If using the parabolic VMD as in getVMD() below, the (z_c,delta) parameters can\n be computed from the (z_i,z_f,z_d) parameters returned by plumevmd().\n\n a) Like Saulo:\n z_c = (z_f+z_i)/2\n delta = (z_f-z_i)/2\n\n b) Preserve bottom half:\n z_c = z_d\n delta = z_d - z_i\n\n c) Preserve upper half:\n z_c = z_d\n delta = z_f - z_d\n\n ---\n\n \"\"\"\n \n def getPlume1(self,i,\n hflux_kW=None,\n frp_MW=None,\n area_m2=None,afac=None,\n Area=None,\n rad2conv=5.,\n Nominal=False,\n which='z_a',\n Verbose=False):\n \n \"\"\"\n Runs the Plume Rise extension to compute the extent of the plume.\n On input,\n \n i --- index to operate on\n frp_MW --- fire radiative power in MW\n area_m2 --- firea are im m2\n afac --- scale area by this amount\n Area --- if specified, PR model will see this value, but heat flux\n will be computed the regular way, based on *area*\n rad2conv --- factor for converting radiative to convective heat fluxes.\n which --- Return one of z_i, z_f, z_d, z_a or all (Tupple), where\n z_i -- height of maximum W (bottom of plume)\n z_d -- height of maximum detrainment\n z_a -- average height in (z_i,z_f), weighted by -dw/dz\n z_f -- height where w<1 (top of plume)\n Nominal --- by default, areas and heat fluxes are from a\n Dozier type algorithm, If Nominal=True,\n area = 20e4 (20 ha)\n hflux = rad2conv * FRP / area\n \n\t\"\"\"\n\n area = area_m2\n ptop = 1. # Pascal\n\n # Default areas, heat flux\n # ------------------------\n if Nominal:\n d_area = 20e4 # typical fire size in m2 (20 ha)\n else: \n d_area = 1e6 * self.mod14.farea[i] # km2 --> m2\n\n # Area\n # ----\n if area == None:\n area = d_area # m2\n\n # FRP\n # ---\n if frp_MW == None:\n frp_MW = self.mod14.frp[i] # MW\n\n # Convective Heat Flux\n # --------------------\n if hflux_kW == None:\n hflux_kW = 1e3 * rad2conv * frp_MW / area # kW/m2\n\n # Scaled Area\n # -----------\n if afac!=None:\n if afac==0:\n afac = 1e-8\n area = afac * area\n hflux_kW = hflux_kW / afac\n \n u = self.sample.u[i]\n v = self.sample.v[i]\n T = self.sample.t[i]\n q = self.sample.qv[i]\n delp = self.sample.delp[i]\n\n if delp.min()<=0 or T.min()<=0:\n print \"out of range: \", delp.min(), T.min() \n return NaN\n\n # Ensure arrays are top-down as in GEOS-5\n # ---------------------------------------\n if delp[0] > delp[-1]:\n u = u[::-1]\n v = v[::-1]\n T = T[::-1]\n q = q[::-1]\n delp = delp[::-1]\n\n # Override firea area\n # -------------------\n if Area is not None:\n area = Area\n \n # Run plume rise model\n # --------------------\n # p,z,k,rc = plume(u,v,T,q,delp,ptop,hflux_kW,area)\n z_i,z_d,z_a,z_f,z,w,rc = plumevmd(u,v,T,q,delp,ptop,hflux_kW,area)\n if rc:\n raise ValueError, \"error on return from , rc = %d\"%rc\n\n if z_i==-1.: \n z_i,z_d,z_a,z_f = (NaN,self.sample.pblh[i],NaN,NaN)\n \n if which=='z_i': z = z_i\n elif which=='z_f': z = z_f\n elif which=='z_d': z = z_d\n elif which=='z_a': z = z_a\n else: z = (z_i,z_d,z_a,z_f,z,w)\n \n if Verbose:\n print \" \", self.tyme[i], \"| %8.2f | %8.2f %8.2f | %8.2f %8.2f %8.2f %8.2f | %03d\"%\\\n (self.mod14.fdist[i], area/1e4, hflux_kW, z_i,z_d,z_a,z_f,i)\n\n return z\n\n#---\n def getPlume(self,I=None,Verbose=True,**kwopts):\n \n \"\"\"\n Runs the Plume Rise extension to compute the extent of each plume.\n\t \"\"\"\n\n z_plume = __AMISS__ * ones(self.N)\n\n R = arange(self.N)\n if I is not None:\n R = R[I]\n\n if Verbose:\n print \"\"\n print \" Plume Height Estimates\"\n print \"\"\n print \" --------------------|----------|-------------------|-------------------------------------------\"\n print \" | Distance | Fire Properties | Plume Height\"\n print \" MINX Date/Time | to Fire | Area Heat Flx | z_i z_d z_a z_f\"\n print \" | km | ha kW | km km km km\"\n print \" --------------------|----------|-------------------|-------------------------------------------\"\n \n# Loop over time\n# --------------\n for i in R:\n z_plume[i] = self.getPlume1(i,Verbose=Verbose,**kwopts)\n if Verbose:\n print \" --------------------|----------|-------------------|-------------------------------------------\"\n\n return array(z_plume)\n\n if Verbose:\n print \" --------------------|----------|-------------------|----------\"\n\n#---\n def getFires(self,mod14_path='/home/adasilva/iesa/aerosol/data/MODIS/Level2/MOD14',\n method='classic',\n npzFile=None,Verbose=True):\n \"\"\"\n Retrieves Level2 MOD14 fire data for each MINX fire.\n \"\"\"\n from dozier import DOZIER\n\n self.mod14 = []\n d2r = pi / 180.\n a = MAPL_RADIUS/1000. # Earth radius in km\n dt = timedelta(seconds=5*60)\n\n self.mod14 = MOD14(self.N)\n \n if Verbose:\n print \"\"\n print \" Fire Heat Flux Estimates\"\n print \"\"\n print \" --------------------|----------|-------------------|----------\"\n print \" | Distance | FRP Estimates | Fire\"\n print \" MINX Date/Time | to Fire | MINX MODIS | Heat Flux\"\n print \" | km | MW MW | kW/m2\"\n print \" --------------------|----------|-------------------|----------\"\n\n for i in range(self.N):\n\n # Get fire granule for this particular day\n # ----------------------------------------\n t = self.tyme[i]\n p = mod14_path\n m = DOZIER(_getGran(t-dt,p) + _getGran(t,p) + _getGran(t+dt,p))\n\n # Select closest fires\n # --------------------\n x0 = cos(d2r*self.lat_f[i]) * cos(d2r*self.lon_f[i])\n y0 = cos(d2r*self.lat_f[i]) * sin(d2r*self.lon_f[i])\n z0 = sin(d2r*self.lat_f[i])\n dx = x0*cos(d2r*m.lat) * cos(d2r*m.lon)\n dy = y0*cos(d2r*m.lat) * sin(d2r*m.lon)\n dz = z0*sin(d2r*m.lat) \n s = a * arccos(dx+dy+dz) # great circle distance\n j = s.argmin()\n\n # Estimate fire heat flux\n # -----------------------\n if method=='bimodal':\n m.bimodal_u() # bimodal Dozier, need to provide trasnmittance\n self.mod14.hflux[i] = m.h_F[j] # flaming Radiative Heat Flux\n self.mod14.fdist[i] = s[j]\n self.mod14.frp[i] = m.pow_F[j]\n self.mod14.pixar[i] = m.pixar[j]\n self.mod14.farea[i] = m.r_F[j]\n self.mod14.qa[i] = m.m[j] # bolean\n else:\n m.classic_var() # classic Dozier, need to provide trasnmittance\n self.mod14.hflux[i] = m.hflux[j] # Radiative Heat Flux\n self.mod14.fdist[i] = s[j]\n self.mod14.frp[i] = m.pow[j]\n self.mod14.pixar[i] = m.pixar[j]\n self.mod14.farea[i] = m.farea[j]\n self.mod14.qa[i] = m.m[j] # bolean\n if Verbose:\n print \" \", t, \"| %8.2f | %8.2f %8.2f | %8.2f\"%\\\n (self.mod14.fdist[i], self.mod14.frp[i], self.mod14.frp[i], \\\n self.mod14.hflux[i] )\n\n # Save fire properties in NPZ file for later\n # ------------------------------------------\n if npzFile!=None:\n savez(npzFile,**self.mod14.__dict__)\n \n if Verbose:\n print \" --------------------|----------|-------------------|----------\"\n\n#---\n def getOptBrute(self,I=None,Verbose=True,**kwopts):\n \n \"\"\"\n Runs the Plume Rise extension to compute brute force optimal value of (hflux,area)\n to match MISR plume height.\n\t \"\"\"\n\n z_opt = __AMISS__ * ones(self.N)\n h_opt = __AMISS__ * ones(self.N)\n a_opt = __AMISS__ * ones(self.N)\n \n R = arange(self.N)\n if I is not None:\n R = R[I]\n\n Hflux_kW = linspace(1,100,10)\n Area = linspace(0.1e4,2e4,10)\n\n print Hflux_kW\n print Area\n\n if Verbose:\n print \"\"\n print \" Plume Height Estimates\"\n print \"\"\n print \" --------------------|----------|-------------------|----------\"\n print \" | Observed | Opt Properties | Optimal \"\n print \" MINX Date/Time | Height | Area Heat Flx | Height\"\n print \" | km | ha kW | km\"\n print \" --------------------|----------|-------------------|----------\"\n \n\n# Loop over time\n# --------------\n for i in R:\n z = m.z[i]\n e = 1e20 # overestimate\n for hflux_kW in Hflux_kW:\n for area in Area:\n z_ = self.getPlume1(i,Verbose=False,hflux_kW=hflux_kW,area=area)\n if isnan(z)==False:\n e_ = (z-z_)**2\n if e_ m2\n else:\n area = area_m2\n hflux_kW = 1e3 * rad2conv * self.sample.pow[i] / area\n \n # Meteorology\n # ----------- \n ptop = 1. # Pascal\n u = self.sample.u[i]\n v = self.sample.v[i]\n T = self.sample.t[i]\n q = self.sample.qv[i]\n delp = self.sample.delp[i]\n\n if delp.min()<=0 or T.min()<=0:\n print \"out of range: \", delp.min(), T.min() \n return None\n\n # Ensure arrays are top-down as in GEOS-5\n # ---------------------------------------\n if delp[0] > delp[-1]:\n u = u[::-1]\n v = v[::-1]\n T = T[::-1]\n q = q[::-1]\n delp = delp[::-1]\n\n # Run plume rise model\n # -------------------- \n z_i,z_d,z_a,z_f,z,w,rc = plumevmd(u,v,T,q,delp,ptop,hflux_kW,area)\n if rc:\n raise ValueError, \"error on return from , rc = %d\"%rc\n\n if Verbose:\n print \"| %8.2f %8.2f %s | %8.2f %8.2f | %8.2f %8.2f %8.2f %8.2f | %03d\"%\\\n (self.lon[i],self.lat[i], str(self.tyme[i]), area/1e4, hflux_kW, z_i,z_d,z_a,z_f,i)\n \n return (z_i,z_d,z_a,z_f,z,w)\n\n#---\n def getPlume(self,algo='dozier',Verbose=False,**kwargs):\n \n \"\"\"\n Runs the Plume Rise extension to compute the extent of the plume for each fire.\n It is assumed that the necessary met fields have already been loaded in attribute\n *sample* by method sampleFP or alternative.\n\n \"\"\"\n\n I = self.sample.I # spatial subsetting\n if len(I) != self.lon.size:\n raise ValueError, 'sampling data appear inconsistent'\n \n N = len(self.lon) # all obs\n n = len(self.lon[I]) # reduced set in case of regional subsetting\n self.sample.z_i = __AMISS__ * ones(n,dtype='float32')\n self.sample.z_d = __AMISS__ * ones(n,dtype='float32')\n self.sample.z_a = __AMISS__ * ones(n,dtype='float32')\n self.sample.z_f = __AMISS__ * ones(n,dtype='float32')\n\n \n # Gather fire properties\n # ----------------------\n self.sample.pow = self.pow[I]\n self.sample.m = self.m[I]\n \n # Assume that fire area has alread been estimated by classic_var()\n # ----------------------------------------------------------------\n if algo is not None:\n self.sample.farea = self.farea[I]\n if self.algo != algo:\n raise ValueError, 'only dozier algorithm supportted'\n\n if Verbose:\n print \"\"\n print \" Plume Height Estimates\"\n print \"\"\n print \" --------------------|-----------------------|-------------------------------------------\"\n print \" | Fire Properties | Plume Height\"\n print \" Lon Lat Time | Area Conv Pwr | z_i z_d z_a z_f\"\n print \" | ha kW | km km km km\"\n print \" --------------------|-----------------------|-------------------------------------------\"\n \n\n# Loop over time\n# --------------\n s = self.sample # shorthand\n for i in range(n):\n\n# Interpolate met fields to fire location\n# ---------------------------------------\n if not self.sample.m[i]: continue # skip over bad points\n\n# Compute plume rise for this fire\n# --------------------------------\n s.z_i[i],s.z_d[i],s.z_a[i],s.z_f[i],z,q = self.getPlume1(i,Verbose=Verbose,**kwargs)\n\n#---\n def getPlumeDeprecated(self,met):\n \n \"\"\"\n Runs the Plume Rise extension to compute the extent of the plume.\n On input,\n\n met --- MET object for computing Met fields\n\n Notice that the Dozier must have been run and produced the farea\n attribute. In addition, the veg attribute with the biome type must\n have been defined as well.\n\t\"\"\"\n\n if self.algo != 'dozier':\n raise ValueError, 'only Dozier algorithm supported for now'\n\n if self.veg is None:\n raise ValueError, 'veg attribute with biome type has not been defined'\n\n\n# Initialize Plume Rise ranges\n# ----------------------------\n ntd = met.ntd\n N = self.lon.size\n self.p_plume = zeros((ntd,N,2))\n self.k_plume = zeros((ntd,N,2))\n self.z_plume = zeros((ntd,N,2))\n yyyy = self.yyyy[N/2]\n jjj = self.jjj[N/2]\n\n# Loop over time\n# --------------\n for t in range(1,ntd+1):\n \n# Interpolate met fields to fire location\n# ---------------------------------------\n met.interp(yyyy,jjj,t,lon=self.lon,lat=self.lat)\n\n# Compute plume rise for this time\n# --------------------------------\n farea = self.r_F * self.farea # reduce area by flaming fraction\n p, z, k = getPlume(farea,self.veg,met,t,ntd,self.verb) \n\n# Save in the approapriate containers\n# -----------------------------------\n self.p_plume[t-1,:,:] = p[:,:]\n self.z_plume[t-1,:,:] = z[:,:]\n self.k_plume[t-1,:,:] = k[:,:]\n\n#...............................................................................\n\nclass PLUME_L3(object):\n\n \"\"\"\n Extension of the MxD14,IGBP and DOZIER classes, adding the\n Plume Rise functionality. This class handles non-gridded,\n observation location fires.\n \"\"\"\n\n def __init__(self,plume,refine=4,res=None):\n \"\"\"\n Create a gridded Plume Rise object from a Level 2\n PLUME_L2 object *plume*. The grid resolution is\n specified by\n\n refine -- refinement level for a base 4x5 GEOS-5 grid\n refine=1 produces a 4 x 5 grid\n refine=2 produces a 2 x2.50 grid\n refine=4 produces a 1 x1,25 grid\n refine=8 produces a 0.50x0.625 grid\n refine=16 produces a 0.25x0.3125 grid\n\n Alternatively, one can specify the grid resolution with a\n single letter:\n\n res -- single letter denoting GEOS-5 resolution,\n res='a' produces a 4 x 5 grid\n res='b' produces a 2 x2.50 grid\n res='c' produces a 1 x1,25 grid\n res='d' produces a 0.50x0.625 grid\n res='e' produces a 0.25x0.3125 grid\n\n NOTE: *res*, if specified, supersedes *refine*.\n\n After initialization only the FRP weighted average area is\n set, for each gridbox/biome, along with the coordinates of the\n global grid.\n \n \"\"\"\n\n N = plume.lon.size\n self.verb = plume.verb\n\n# Output grid resolution\n# ----------------------\n if res is not None:\n if res=='a': refine = 1 \n if res=='b': refine = 2\n if res=='c': refine = 4\n if res=='d': refine = 8\n if res=='e': refine = 16\n\n# Lat lon grid\n# ------------\n dx = 5. / refine\n dy = 4. / refine\n im = int(360. / dx)\n jm = int(180. / dy + 1)\n self.im = im\n self.jm = jm\n self.glon = linspace(-180.,180.,im,endpoint=False)\n self.glat = linspace(-90.,90.,jm)\n Lat, Lon = meshgrid(self.glat,self.glon) # shape should be (im,jm)\n\n self.yyyy = plume.yyyy[N/2]\n self.jjj = plume.jjj[N/2]\n self.date = date((int(self.yyyy),1,1)) + (int(self.jjj) - 1)*DAY\n self.col = plume.col\n \n# Supperobed fire attributes for each biome\n# These will have 1D arrays for each biome, using\n# a standard sparse matrix storage\n# -----------------------------------------------\n self.bioma = [1,2,3,4]\n NONE = [None,None,None,None] \n self.idx = NONE[:] # non-zero indices for each biome\n self.area = NONE[:] # non-zero areas for \n self.r_F = NONE[:] # corresponding flaming fraction\n self.lon = NONE[:] # corresponding lon\n self.lat = NONE[:] # corresponding lat\n\n# Plume extent to be filled later\n# -------------------------------\n self.p_plume = NONE[:]\n self.k_plume = NONE[:]\n self.z_plume = NONE[:]\n\n# Grid box average of fire flaming area, weighted by FRP\n# -----------------------------------------------------\n for b in self.bioma:\n\n# Compute average area in gridbox for this biome\n# ----------------------------------------------\n Frac = zeros((im,jm))\n Area = zeros((im,jm))\n FRP = zeros((im,jm))\n i = (plume.veg==b)\n if any(i):\n blon = plume.lon[i]\n blat = plume.lat[i]\n bfrac = plume.r_F[i] * plume.pow[i] \n barea = plume.r_F[i] * plume.farea[i] * plume.pow[i] # notice flaming fraction \n bfrp = plume.pow[i]\n Area += binareas(blon,blat,barea,im,jm) # to be normalized\n Frac += binareas(blon,blat,bfrac,im,jm) # to be normalized\n FRP += binareas(blon,blat,bfrp, im,jm)\n I = (FRP>0.0)\n if any(I):\n Area[I] = Area[I] / FRP[I]\n Frac[I] = Frac[I] / FRP[I]\n\n# Use sparse matrix storage scheme\n# --------------------------------\n I = Area.nonzero()\n if any(I):\n self.area[b-1] = Area[I]\n self.r_F[b-1] = Frac[I] # average flaming/total energy fraction\n self.lon[b-1] = Lon[I]\n self.lat[b-1] = Lat[I]\n self.idx[b-1] = I # save indices for going to global grid\n\n def getPlume(self):\n \n \"\"\"\n Runs the Plume Rise extension to compute the extent of the plume.\n On input,\n\n met --- MET object for computing Met Fields at obs location.\n\n\t\"\"\"\n\n ntd = met.ntd # number of time steps per day\n self.ntd = ntd\n \n# Loop over bioma\n# ---------------\n for i in range(len(self.bioma)):\n\n# No data for this bioma, nothing to do\n# -------------------------------------\n if self.idx[i] is None:\n if self.verb>0:\n print \"[x] no data for %s\"%Bioma[i] \n continue\n\n lon = self.lon[i]\n lat = self.lat[i]\n area = self.area[i]\n N = lon.size\n veg = self.bioma[i] * ones(N)\n\n p_plume = zeros((ntd,2,N))\n z_plume = zeros((ntd,2,N))\n k_plume = zeros((ntd,2,N))\n \n if self.verb>0:\n print \"[ ] got %d burning gridboxes in %s\"%(N,Bioma[i]) \n\n# Loop over time \n# --------------\n for t in range(1,ntd+1):\n\n# Interpolate met fields to fire locations\n# ----------------------------------------\n met.interp(self.yyyy,self.jjj,t,lon=lon,lat=lat)\n\n# Compute plume rise for this time, biome\n# ---------------------------------------\n p, z, k = getPlume(area,veg,met,t,ntd,self.verb) \n\n# Save in the approapriate containers\n# -----------------------------------\n p_plume[t-1,:,:] = p.T[:,:]\n z_plume[t-1,:,:] = z.T[:,:]\n k_plume[t-1,:,:] = k.T[:,:]\n\n# Plume extent for this biome (sparse storage)\n# --------------------------------------------\n self.p_plume[i] = p_plume\n self.z_plume[i] = z_plume\n self.k_plume[i] = k_plume\n\n#---\n def write(self,filename=None,dir='.',expid='qfed2',tag=None):\n \"\"\"\n Writes gridded Area and FRP to file.\n \"\"\"\n\n vtitle = {}\n vtitle['fa'] = 'Flaming Area'\n vtitle['ff'] = 'Fraction of Flaming Energy'\n vtitle['p2'] = 'Plume Bottom Pressure'\n vtitle['p1'] = 'Plume Top Pressure' \n vtitle['z2'] = 'Plume Bottom Height' \n vtitle['z1'] = 'Plume Top Height' \n vtitle['k2'] = 'Plume Bottom Vertical Index' \n vtitle['k1'] = 'Plume Top Vertical Index' \n \n vunits = {}\n vunits['fa'] = 'km2'\n vunits['ff'] = '1'\n vunits['p2'] = 'Pa'\n vunits['p1'] = 'Pa'\n vunits['z2'] = 'meter'\n vunits['z1'] = 'meter'\n vunits['k2'] = '1'\n vunits['k1'] = '1'\n \n btitle = {}\n btitle['tf'] = 'Tropical Forest' \n btitle['xf'] = 'Extra-Tropical Forest'\n btitle['sv'] = 'Savanna'\n btitle['gl'] = 'Grassland'\n\n# Create master variable list\n# ---------------------------\n Vname = []\n Vtitle = []\n Vunits = []\n for v in vtitle.keys():\n vt = vtitle[v]\n vu = vunits[v]\n for b in btitle.keys(): \n bt = btitle[b]\n Vname.append(v+'_'+b)\n Vtitle.append(vt+' ('+bt+')')\n Vunits.append(v)\n\n# Global metadata\n# ---------------\n title = 'QFED Level3c v%3.1f (%s) Gridded Plume Rise Estimates' % (__VERSION__, _getTagName(tag))\n source = 'NASA/GSFC/GMAO GEOS-5 Aerosol Group'\n contact = 'arlindo.dasilva@nasa.gov'\n\n# Time/date handling\n# ------------------\n if self.date is None:\n print \"[x] did not find matching files, skipped writing an output file\"\n return\n\n if 24%self.ntd != 0:\n raise ValueError,\"invalid number of times per day (%d),\"%self.ntd\\\n +\"it must be a divisor of 24.\"\n else:\n dT = 240000/self.ntd # timestep in hhmmss format\n NHMS = range(0,240000,dT)\n\n nymd = 10000*self.date.year + 100*self.date.month + self.date.day\n nhms = NHMS[0]\n col = self.col\n\n# Create output file name\n# -----------------------\n if filename is None:\n filename = '%s/%s.plumerise.%s.%d.nc'%(dir,expid,col,nymd)\n self.filename = filename\n f = GFIO()\n f.create(filename,Vname, nymd, nhms,\n lon=self.glon, lat=self.glat,\n vtitle=Vtitle, vunits=Vunits,\n timinc=dT, amiss=__AMISS__,\n title=title, source=source, contact=contact)\n\n# Write out Plume Rise variables\n# ------------------------------\n d = (self.im,self.jm)\n for t in range(self.ntd):\n nhms = NHMS[t]\n b = 0\n for bn in btitle.keys():\n I = self.idx[b]\n f_area = self.area[b]\n f_frac = self.r_F[b]\n p_plume = self.p_plume[b]\n z_plume = self.z_plume[b]\n k_plume = self.k_plume[b]\n _writeOne(f,'fa_'+bn,nymd,nhms,I,f_area, t,0,d)\n _writeOne(f,'ff_'+bn,nymd,nhms,I,f_frac, t,0,d)\n _writeOne(f,'p1_'+bn,nymd,nhms,I,p_plume,t,0,d)\n _writeOne(f,'p1_'+bn,nymd,nhms,I,p_plume,t,0,d)\n _writeOne(f,'p2_'+bn,nymd,nhms,I,p_plume,t,1,d)\n _writeOne(f,'z1_'+bn,nymd,nhms,I,z_plume,t,0,d)\n _writeOne(f,'z2_'+bn,nymd,nhms,I,z_plume,t,1,d)\n _writeOne(f,'k1_'+bn,nymd,nhms,I,k_plume,t,0,d)\n _writeOne(f,'k2_'+bn,nymd,nhms,I,k_plume,t,1,d)\n b += 1\n\n try:\n f.close()\n except:\n pass\n\n if self.verb >=1:\n print \"[w] Wrote file \"+filename\n\n#..............................................................................\n\n#\n# Static Methods\n# --------------\n#\n\ndef _writeOne(f,vname,nymd,nhms,I,S,t,k,d):\n \"\"\"\n Write one sparse variable to a GFIO file.\n \"\"\"\n A = zeros(d) + __AMISS__\n if I is not None:\n if len(S.shape)==3:\n A[I] = S[t,k,:]\n elif len(S.shape)==1:\n A[I] = S[:]\n else:\n raise ValueError, 'invalid S rank = %d'%len(S.shape)\n \n f.write(vname,nymd,nhms,A)\n\n\ndef getPlumeDeprecated(farea,veg,met,t,ntd,Verb=0):\n \n \"\"\"\n Runs the Plume Rise extension to compute the extent of the plume.\n\n p, z, k = getPlume(farea,veg,met,t,ntd)\n\n where p, z and k are nd-arrays of shape(N,2), N being the\n number of observations (as in met.lon.size). On input,\n\n farea --- (flaming) fire area\n veg --- biome type\n \n \"\"\"\n\n N = met.lon.size\n nominal_area = 1.e6 # 1 km^2: pixar and farea are in units of km2\n km = met.lev.size\n ptop = met.ptop\n ktop = met.ktop # 1-offset\n\n if Verb:\n if N>100:\n Np = range(0,N,N/10)\n elif N>10:\n Np = range(0,N,N/10)\n else:\n Np = range(N)\n print \"\"\n print \" Plume Rise Estimation for t=%d\"%t\n print \" ------------------------------\"\n print \"\"\n print \" % | Lon Lat b | p_bot p_top | z_bot z_top | k k\" \n print \" | deg deg | mb mb | km km | bot top\"\n print \"---- | ------ ------ - | -------- -------- | ------ ------ | --- ---\"\n\n# Allocate space\n# --------------\n p_plume = zeros((N,2))\n k_plume = zeros((N,2))\n z_plume = zeros((N,2))\n \n# Compute plume extent, one fire at a time\n# ----------------------------------------\n for i in range(N):\n\n u = met.fields['u'][i]\n v = met.fields['v'][i]\n T = met.fields['t'][i]\n q = met.fields['qv'][i]\n delp = met.fields['delp'][i]\n\n# Ensure arrays are top-down as in GEOS-5\n# ---------------------------------------\n if delp[0] > delp[-1]:\n u = u[::-1]\n v = v[::-1]\n T = T[::-1]\n q = q[::-1]\n delp = delp[::-1]\n\n# Units:\n# farea - km2 (must multiply by nominal area for m2)\n# area - m2 as required by plume rise model\n# ------------------------------------------------------ \n area = farea[i] * nominal_area\n veg_ = veg[i]\n\n# Run plume rise model\n# --------------------\n p1, p2, z1, z2, k1, k2, rc = \\\n biome(u, v, T, q, delp, ptop, area, veg_)\n\n k1, k2 = (k1+ktop-1, k2+ktop-1)\n\n p_plume[i,:] = (p1, p2)\n k_plume[i,:] = (k1, k2)\n z_plume[i,:] = (z1, z2)\n\n if Verb:\n if i in Np:\n ip = int(0.5+100.*i/N)\n print \"%3d%% | %7.2f %6.2f %d | %8.2f %8.2f | %6.2f %6.2f | %3d %3d \"%\\\n (ip,met.lon[i],met.lat[i],veg[i], \\\n p2/100,p1/100,z2/1000,z1/1000,k2,k1)\n\n return (p_plume, z_plume, k_plume)\n\n\ndef _getTagName(tag):\n if tag != None:\n tag_name = tag\n else: \n if __CVSTAG__ not in (None, ''):\n tag_name = __CVSTAG__\n else:\n tag_name = 'unknown'\n\n return tag_name\n\n#----\ndef _getGran(t,mod14_path):\n doy = t.date().toordinal() - date(t.year-1,12,31).toordinal()\n hhmm = \"%02d%02d\"%(t.hour,5*(t.minute/5))\n patt = mod14_path+'/%4d/%03d/MOD14.A%4d%03d.%s.005.*.hdf'%(t.year,doy,t.year,doy,hhmm)\n# print '--> ', patt\n return glob(patt)\n\n#---\n\n#..............................................................................\n\ndef plotMINX(m,imfile=None,Title=None):\n\n from matplotlib.pyplot import plot, legend, xlabel, ylabel, title, grid, figure, savefig\n\n I_ = m.z>0\n I = m.z>(m.sample.pblh+250)\n J = m.zm>(m.sample.pblh+250)\n K = m.zt>(m.sample.pblh+250)\n\n figure(dpi=120)\n plot([0,5],[0,5],'k') # 1:1 line\n plot(m.sample.pblh[I_]/1000,m.z[I_]/1000, 'bo',label='Mode Height < PBL')\n plot(m.sample.pblh[I]/1000,m.z[I]/1000, 'co',label='Mode Height > PBL')\n plot(m.sample.pblh[K]/1000,m.zt[K]/1000, 'ro',label='95%-ile Height > PBL')\n\n print \"Percent above PBL: \",100.*len(m.z[I])/len(m.z[I_])\n \n \n x, ya, yb = m.sample.pblh[K]/1000, m.zt[K]/1000, m.z[K]/1000\n for i in range(len(x)):\n plot([x[i],x[i]],[ya[i],yb[i]],'k')\n \n xlabel('GEOS-5 PBL Height AGL [km]')\n ylabel('MINX Plume Height AGL [km]')\n legend(loc='upper right',fontsize='medium')\n grid()\n\n if Title is not None:\n title(Title)\n \n if imfile is not None:\n savefig(imfile,bbox_inches='tight')\n\ndef plotAreaFRP(m,z_plume,imfile=None,Title=None):\n from matplotlib.pyplot import plot, legend, xlabel, ylabel, title, grid, figure, savefig\n\n figure(dpi=120)\n J = z_plume>(m.sample.pblh+250)\n area = m.mod14.farea * m.mod14.pixar * 1e6 / 1e4\n plot(area,m.mod14.frp,'bo')\n plot(area[J],m.mod14.frp[J],'ro')\n grid()\n xlabel(r'Fire Area [Ha]')\n ylabel('FRP/Area [MW]')\n \ndef plotPR(m,z_plume,imfile=None,Title=None):\n from matplotlib.pyplot import plot, legend, xlabel, ylabel, title, grid, figure, savefig\n \n I = m.z>(m.sample.pblh+250)\n J = z_plume>(m.sample.pblh+250)\n \n figure(dpi=120)\n plot([0.5,4],[0.5,4],'k')\n plot(m.sample.pblh/1000,z_plume/1000, 'bo',label='Modeled Below PBL')\n plot(m.sample.pblh[J]/1000,z_plume[J]/1000,'co',label='Modeled above PBL')\n #plot(m.sample.pblh[I]/1000,z_plume[I]/1000,'ro',label='Observed above PBL')\n plot(m.sample.pblh[I]/1000,m.z[I]/1000,'ro',label='Observed above PBL')\n\n x, ya, yb = m.sample.pblh[I]/1000, z_plume[I]/1000, m.z[I]/1000\n for i in range(len(x)):\n plot([x[i],x[i]],[ya[i],yb[i]],'k')\n \n xlabel('GEOS-5 PBL Height AGL [km]')\n ylabel('Plume Height AGL [km]')\n legend(loc='lower right')\n grid()\n\n if Title is not None:\n title(Title)\n \n if imfile is not None:\n savefig(imfile,bbox_inches='tight')\n \ndef scatOpt(m,imfile=None,Title=None,norm=True,xymax=1.9999):\n\n from matplotlib.pyplot import plot, legend, xlabel, ylabel, title, grid, figure, savefig\n\n z = m.z/m.sample.pblh\n z_opt = m.z_opt/m.sample.pblh\n \n I = z>0\n J = z_opt>1\n K = (z>1)&(z_opt>1)\n\n if not norm: \n z = m.z/1000\n z_opt = m.z_opt/1000\n \n figure(dpi=120)\n if norm:\n plot([0,xymax],[0,xymax],'k')\n plot([0,xymax],[1,1],'k')\n plot([1,1],[0,xymax],'k')\n plot(z[I],z_opt[I],'yo',label=r'$z_{OBS}z_{PBL}$')\n plot(z[K],z_opt[K],'go',label=r'$z_{OBS}>z_{PBL}$, $z_{OPT}>z_{PBL}$')\n\n if norm:\n xlabel(r'$z_{OBS}/z_{PBL}$')\n ylabel(r'$z_{OPT}/z_{PBL}$')\n else:\n xlabel(r'$z_{OBS}$')\n ylabel(r'$z_{OPT}$')\n \n legend(loc='lower right')\n grid()\n\n if Title is not None:\n title(Title)\n \n if imfile is not None:\n savefig(imfile,bbox_inches='tight')\n\ndef scatOptF(m,imfile=None,Title=None,norm=True,xymax=1.9999):\n\n from matplotlib.pyplot import plot, legend, xlabel, ylabel, title, grid, figure, savefig, loglog\n\n z = m.z/m.sample.pblh\n z_opt = m.z_opt/m.sample.pblh\n \n I = (z>0)&(isnan(m.f_opt)==False)#&(m.f_opt<100)&(m.mod14.frp<100)\n J = I&(z_opt>1)\n K = I&(z>1)&(z_opt>1)\n\n if not norm: \n z = m.z/1000\n z_opt = m.z_opt/1000\n \n figure(dpi=120)\n loglog(m.mod14.frp[I],m.f_opt[I],'yo',label=r'$z_{OBS}z_{PBL}$')\n loglog(m.mod14.frp[K],m.f_opt[K],'go',label=r'$z_{OBS}>z_{PBL}$, $z_{OPT}>z_{PBL}$')\n\n xlabel('FRP [MW]')\n ylabel(r'$\\gamma$') \n #legend(loc='upper right')\n grid()\n\n if Title is not None:\n title(Title)\n \n if imfile is not None:\n savefig(imfile,bbox_inches='tight')\n\ndef scatPR(m,z_plume,imfile=None,Title=None):\n\n from matplotlib.pyplot import plot, legend, xlabel, ylabel, title, grid, figure, savefig\n\n z = m.z/m.sample.pblh\n z_pr = z_plume/m.sample.pblh\n \n I = z>0\n J = (z_pr>1)|((z_pr<1)&(z>1))\n K = (z>1)&(z_pr>1)\n\n figure(dpi=120)\n plot([0,1.5999],[0,1.5999],'k')\n plot([0,2.999],[1,1],'k')\n plot([1,1],[0,1.5999],'k')\n plot(z[I],z_pr[I],'yo',label=r'$z_{OBS}z_{PBL}$')\n plot(z[K],z_pr[K],'go',label=r'$z_{OBS}>z_{PBL}$, $z_{PR}>z_{PBL}$')\n\n xlabel(r'$z_{OBS}/z_{PBL}$')\n ylabel(r'$z_{PR}/z_{PBL}$')\n \n legend(loc='lower right')\n grid()\n\n if Title is not None:\n title(Title)\n \n if imfile is not None:\n savefig(imfile,bbox_inches='tight')\n\n#--\n\ndef plotKDE(s,s2=None,Title='',imfile=None):\n\n from matplotlib.pyplot import plot, legend, xlabel, ylabel, title, grid, figure, savefig\n\n J = (s.pblh>100)&(s.z_a>0)\n r = s.z_a/s.pblh\n if s2 is not None:\n J2 = (s2.pblh>100)&(s2.z_a>0)\n r2 = s2.z_a/s2.pblh\n \n # KDE 1d\n # ------\n figure(dpi=120)\n bins, P = kde.calc_kde1d(r[J],range=(0,5))\n plot(bins,P,'b',linewidth=2,label='Terra')\n if s2 is not None:\n bins, P2 = kde.calc_kde1d(r2[J2],range=(0,5))\n plot(bins,P2,'r',linewidth=2,label='Aqua')\n legend(loc='upper right')\n grid()\n xlabel(r'$z_{PR}/z_{PBL}$')\n ylabel('p.d.f.')\n if Title is not None:\n title(Title)\n if imfile is not None:\n savefig('kde1d.'+imfile,bbox_inches='tight')\n\n if s2 is not None: return\n \n # KDE 2d\n # ------\n x, y, P = kde.calc_kde2d(s.pblh[J]/1000,s.z_a[J]/1000,x_range=(0,3),y_range=(0,3))\n kde.plot_kde2d(x,y,P,dpi=120,Title=Title,\n xLabel=r'$z_{PBL}$', yLabel=r'$z_{PR}$')\n grid()\n if imfile is not None:\n savefig('kde2d.'+imfile,bbox_inches='tight')\n \ndef aveVMD(s):\n \"\"\"\n Compute average vertical mass distribution, weighted by FRP.\n \"\"\"\n J = (s.pblh>100)&(s.z_a>0)\n\n z_c = s.z_d[J]/1000\n delta = (s.z_f[J] - s.z_d[J])/1000\n pow = s.pow[J]\n pblh = s.pblh[J]/1000\n \n nz = 100\n nf = len(pblh)\n z = linspace(0,5,nz)\n\n\n # PBL mass distribution\n # ---------------------\n V = zeros(nz)\n for i in range(nf):\n v = zeros(nz)\n v[z0\n \n print \"Loading Meteorology\"\n f.sampleLoadz('%s/AGU-2014/%s.sample_nam.%4d-%02d.npz'%(topdir,p,t1.year,t1.month))\n\n I_na = (f.lon>-170)&(f.lon<-50)&(f.lat>15)&(f.lat<80)\n f.sample.I = I_na\n\n f.getPlume(algo=None,Verbose=True,area_m2=10e4,rad2conv=5)\n\n f.sample.pblh = f.sample.pblh[I_na]\n savez('%s.sample_a1_r10_r5.2013-08.npz'%p,**f.sample.__dict__)\n \ndef xxxxx():\n \n#--\n \n Files = granules(t1,t2,product=p,rootdir=topdir+'/MODIS')\n\n print 'Number of files: ', len(Files)\n f = PLUME_L2(Files,Verb=1)\n\n print \"Computing fire properties\"\n ###f.classic_var()\n\n print \"Checkpointing\"\n f.checkpoint('%s.fires_nam.%4d-%02d.npz'%(p,t1.year,t1.month))\n\ndef minx_test():\n \n m = MINXs_PR('/Users/adasilva/workspace/misrPlumes/western_fires_2013/*.txt')\n m.sampleLoadz('/Users/adasilva/workspace/Data_Analysis/AGU-2014/seac4rs_01.npz')\n m.mod14 = NPZ(('/Users/adasilva/workspace/Data_Analysis/AGU-2014/mod14_seac4rs.npz',))\n #plotMINX(m)\n\n #z_plume = m.getPlume()\n\n \ndef arctas():\n # m.getFires(npzFile='mod14_seac4rs.npz')\n# m = MINXs_PR('/Users/adasilva/workspace/misrPlumes/canada2008/Plumes*.txt')\n\n m = MINXs_PR('/Users/adasilva/workspace/misrPlumes/canada2008/Plumes*.txt')\n m.sampleLoadz('merraero.npz')\n m.mod14 = NPZ('mod14.npz')\n \n# z_plume = m.getPlume()\n\ndef Mac():\n m = MINXs_PR('/Users/adasilva/workspace.local/misrPlumes/canada2008/Plumes*.txt')\n# m.sampleLoadz('/Users/adasilva/workspace.local/misrPlumes/canada2008/merra.npz')\n# m.sampleLoadz('merra.npz')\n# m.mod14 = NPZ('mod14.npz')\n# z_plume = m.getPlume()\n", "meta": {"hexsha": "1251a32277ffcbb2dfcf4ad987c9deb150be9a4b", "size": 46464, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/Components/qfed/qfed/PlumeRise.py", "max_stars_repo_name": "GEOS-ESM/AeroApps", "max_stars_repo_head_hexsha": "874dad6f34420c014d98eccbe81a061bdc0110cf", "max_stars_repo_licenses": ["NASA-1.3", "ECL-2.0", "Apache-2.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-12-02T14:23:30.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-31T15:39:30.000Z", "max_issues_repo_path": "src/Components/qfed/qfed/PlumeRise.py", "max_issues_repo_name": "GEOS-ESM/AeroApps", "max_issues_repo_head_hexsha": "874dad6f34420c014d98eccbe81a061bdc0110cf", "max_issues_repo_licenses": ["NASA-1.3", "ECL-2.0", "Apache-2.0"], "max_issues_count": 9, "max_issues_repo_issues_event_min_datetime": "2020-04-15T16:22:14.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-24T13:59:25.000Z", "max_forks_repo_path": "src/Components/qfed/qfed/PlumeRise.py", "max_forks_repo_name": "GEOS-ESM/AeroApps", "max_forks_repo_head_hexsha": "874dad6f34420c014d98eccbe81a061bdc0110cf", "max_forks_repo_licenses": ["NASA-1.3", "ECL-2.0", "Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.0234541578, "max_line_length": 117, "alphanum_fraction": 0.462035124, "include": true, "reason": "from numpy,from scipy", "num_tokens": 13144, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5698526514141571, "lm_q2_score": 0.34510526422232046, "lm_q1q2_score": 0.19665914983407257}} {"text": "# Copyright (c) Anand Patil, 2007\n\n__docformat__ = 'reStructuredText'\n\nimport pymc as pm\nimport linalg_utils\nimport copy\nimport types\nimport numpy as np\nfrom gp_submodel import *\nimport warnings\n\nfrom Realization import Realization\nfrom Mean import Mean\nfrom Covariance import Covariance\nfrom GPutils import observe, regularize_array\n\n__all__ = ['wrap_metropolis_for_gp_parents', 'GPEvaluationGibbs', 'GPParentAdaptiveMetropolis']\n\ndef wrap_metropolis_for_gp_parents(metro_class):\n \"\"\"\n Wraps Metropolis step methods so they can handle extended parents of\n Gaussian processes.\n \"\"\"\n class wrapper(metro_class):\n def __init__(self, stochastic, *args, **kwds):\n \n self.metro_class.__init__(self, stochastic, *args, **kwds)\n \n # Remove f from the set that will be used to compute logp_plus_loglike.\n self.markov_blanket_no_f = filter(lambda x: not isinstance(x, GaussianProcess), self.markov_blanket)\n self.fs = filter(lambda x: isinstance(x, GaussianProcess), self.markov_blanket)\n self.fr_checks = [f.submodel.fr_check for f in self.fs]\n\n def get_logp_plus_loglike(self):\n return pm.logp_of_set(self.markov_blanket_no_f)\n logp_plus_loglike = property(get_logp_plus_loglike)\n \n def propose(self):\n self.metro_class.propose(self)\n try:\n # First make sure none of the stochastics handled by metro_method forbid their current values.\n for s in self.stochastics:\n s.logp\n # Then make sure the covariances are all still full-rank on the observation locations.\n for frc in self.fr_checks:\n frc.logp\n for f in self.fs:\n f.rand()\n self.f_proposed = True\n except pm.ZeroProbability:\n self.f_proposed = False\n \n def reject(self):\n self.metro_class.reject(self)\n if self.f_proposed:\n for f in self.fs:\n f.revert()\n \n @staticmethod\n def competence(stochastic, metro_class=metro_class):\n if any([isinstance(child, GaussianProcess) for child in stochastic.extended_children]):\n return metro_class.competence(stochastic)+.01\n else:\n return 0\n \n wrapper.__name__ = 'GPParent%s'%metro_class.__name__\n wrapper.metro_class = metro_class\n wrapper.__doc__ = \"\"\"A modified version of class %s that handles parents of Gaussian processes.\nDocstring of class %s: \\n\\n%s\"\"\"%(metro_class.__name__,metro_class.__name__,metro_class.__doc__)\n \n return wrapper\n\n\n# Wrap all registered Metropolis step methods to use GP parents.\nnew_sm_dict = {}\nfiltered_registry = filter(lambda x: issubclass(x, pm.Metropolis), pm.StepMethodRegistry)\nfor sm in filtered_registry:\n wrapped_method = wrap_metropolis_for_gp_parents(sm)\n new_sm_dict[wrapped_method.__name__] = wrapped_method\nGPParentAdaptiveMetropolis = wrap_metropolis_for_gp_parents(pm.AdaptiveMetropolis)\n__all__ += new_sm_dict.keys()\nlocals().update(new_sm_dict)\n\n\nclass GPEvaluationGibbs(pm.Metropolis):\n \"\"\"\n Updates a GP evaluation f_eval. Assumes the only children of f_eval\n are as distributed follows:\n \n eps_p_f ~ Normal(f_eval[ti], 1./V)\n \n or\n \n eps_p_f ~ Normal(f_eval, 1./V)\n \n if ti is None.\n \"\"\"\n def __init__(self, submod, V, eps_p_f, ti=None, tally=True, verbose=0): \n\n self.f_eval = submod.f_eval\n self.f = submod.f\n pm.StepMethod.__init__(self, [self.f, self.f_eval], tally=tally)\n \n self.children_no_data = copy.copy(self.children)\n if isinstance(eps_p_f, pm.Variable):\n self.children_no_data.discard(eps_p_f)\n else:\n for epf in eps_p_f:\n self.children_no_data.discard(epf)\n \n self.V = V\n self.C_eval = submod.C_eval\n self.M_eval = submod.M_eval\n self.S_eval = submod.S_eval\n self.eps_p_f = eps_p_f\n\n M_eval_shape = pm.utils.value(self.M_eval).shape\n C_eval_shape = pm.utils.value(self.C_eval).shape\n self.ti = ti or np.arange(M_eval_shape[0])\n\n # Work arrays\n self.scratch1 = np.asmatrix(np.empty(C_eval_shape, order='F'))\n self.scratch2 = np.asmatrix(np.empty(C_eval_shape, order='F'))\n self.scratch3 = np.empty(M_eval_shape) \n\n # Initialize hidden attributes\n self.accepted = 0.\n self.rejected = 0.\n self._state = ['rejected', 'accepted', 'proposal_distribution']\n self._tuning_info = []\n self.proposal_distribution=None\n \n \n def get_logp(self):\n return 0.\n logp = property(get_logp)\n \n def get_loglike(self):\n return pm.utils.logp_of_set(self.children_no_data)\n loglike = property(get_loglike)\n \n def get_logp_plus_loglike(self):\n return self.get_loglike()\n logp_plus_loglike = property(get_logp_plus_loglike)\n \n def reject(self):\n self.rejected += 1\n if self.verbose:\n print self._id + ' rejecting'\n # Revert the field evaluation and the rest of the field.\n self.f_eval.revert()\n self.f.revert()\n \n def tune(self, verbose=0):\n return False\n \n def propose(self):\n if self.verbose:\n print self._id + ' proposing'\n\n fc = pm.gp.fast_matrix_copy\n\n eps_p_f = pm.utils.value(self.eps_p_f)\n f = pm.utils.value(self.f_eval)\n for i in xrange(len(self.scratch3)):\n self.scratch3[i] = np.sum(eps_p_f[self.ti[i]] - f[i])\n\n # Compute Cholesky factor of covariance of eps_p_f, C(x,x) + V\n C_eval_value = pm.utils.value(self.C_eval)\n C_eval_shape = C_eval_value.shape\n \n # Get the Cholesky factor of C_eval, plus the nugget.\n # I don't think you can use S_eval for speed, unfortunately.\n in_chol = fc(C_eval_value, self.scratch1)\n for i in xrange(pm.utils.value(C_eval_shape)[0]):\n in_chol[i,i] += pm.utils.value(self.V) / np.alen(self.ti[i])\n info = pm.gp.linalg_utils.dpotrf_wrap(in_chol)\n if info > 0:\n raise np.linalg.LinAlgError\n\n # Compute covariance of f conditional on eps_p_f.\n offdiag = fc(C_eval_value, self.scratch2)\n offdiag = pm.gp.trisolve(in_chol, offdiag, uplo='U', transa='T', inplace=True)\n\n C_step = offdiag.T * offdiag\n C_step *= -1\n C_step += C_eval_value\n\n # Compute mean of f conditional on eps_p_f.\n for i in xrange(len(self.scratch3)):\n self.scratch3[i] = np.mean(eps_p_f[self.ti[i]])\n m_step = pm.utils.value(self.M_eval) + np.dot(offdiag.T, pm.gp.trisolve(in_chol,(self.scratch3 - self.M_eval.value),uplo='U',transa='T')).view(np.ndarray).ravel()\n\n sig_step = C_step\n info = pm.gp.linalg_utils.dpotrf_wrap(C_step.T)\n if info > 0:\n warnings.warn('Full conditional covariance was not positive definite.')\n return\n\n # Update value of f.\n self.f_eval.value = m_step+np.dot(sig_step,np.random.normal(size=sig_step.shape[1])).view(np.ndarray).ravel()\n # Propose the rest of the field from its conditional prior.\n self.f.rand() ", "meta": {"hexsha": "f3dc3dd8495dcd07802b80359ac42a625cb05614", "size": 7397, "ext": "py", "lang": "Python", "max_stars_repo_path": "pymc/gp/step_methods.py", "max_stars_repo_name": "matthew-brett/pymc", "max_stars_repo_head_hexsha": "3a31613f056e7993a449d89bafef5fdaa40d47e9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2015-12-03T09:42:44.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-06T19:23:29.000Z", "max_issues_repo_path": "pymc/gp/step_methods.py", "max_issues_repo_name": "matthew-brett/pymc", "max_issues_repo_head_hexsha": "3a31613f056e7993a449d89bafef5fdaa40d47e9", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2016-09-27T02:00:41.000Z", "max_issues_repo_issues_event_max_datetime": "2016-09-27T02:15:32.000Z", "max_forks_repo_path": "pymc/gp/step_methods.py", "max_forks_repo_name": "matthew-brett/pymc", "max_forks_repo_head_hexsha": "3a31613f056e7993a449d89bafef5fdaa40d47e9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2017-10-27T13:27:32.000Z", "max_forks_repo_forks_event_max_datetime": "2017-10-27T13:27:32.000Z", "avg_line_length": 36.2598039216, "max_line_length": 170, "alphanum_fraction": 0.6303906989, "include": true, "reason": "import numpy", "num_tokens": 1788, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583270090337583, "lm_q2_score": 0.3522017820478897, "lm_q1q2_score": 0.1966437675471579}} {"text": "#!/usr/bin/python\n# -*- coding: utf-8 -*-\n\n\"\"\"\n This file belong to https://github.com/snolfi/evorobotpy\n and has been written by Stefano Nolfi and Paolo Pagliuca, stefano.nolfi@istc.cnr.it, paolo.pagliuca@istc.cnr.it\n salimans.py include an implementation of the OpenAI-ES algorithm described in\n Salimans T., Ho J., Chen X., Sidor S & Sutskever I. (2017). Evolution strategies as a scalable alternative to reinforcement learning. arXiv:1703.03864v2\n requires es.py, policy.py, and evoalgo.py \n\"\"\"\n\nimport numpy as np\nfrom numpy import zeros, ones, dot, sqrt\nimport math\nimport time\nfrom evoalgo import EvoAlgo\nfrom utils import ascendent_sort\nimport sys\nimport os\nimport configparser\n\n# Parallel implementation of Open-AI-ES algorithm developed by Salimans et al. (2017)\n# the workers evaluate a fraction of the population in parallel\n# the master post-evaluate the best sample of the last generation and eventually update the input normalization vector\n\nclass Algo(EvoAlgo):\n def __init__(self, env, policy, seed, fileini, filedir):\n EvoAlgo.__init__(self, env, policy, seed, fileini, filedir)\n\n def loadhyperparameters(self):\n\n if os.path.isfile(self.fileini):\n\n config = configparser.ConfigParser()\n config.read(self.fileini)\n self.maxsteps = 1000000\n self.stepsize = 0.01\n self.batchSize = 20\n self.noiseStdDev = 0.02\n self.wdecay = 0\n self.symseed = 1\n self.saveeach = 60\n options = config.options(\"ALGO\")\n for o in options:\n found = 0\n if o == \"maxmsteps\":\n self.maxsteps = config.getint(\"ALGO\",\"maxmsteps\") * 1000000\n found = 1\n if o == \"stepsize\":\n self.stepsize = config.getfloat(\"ALGO\",\"stepsize\")\n found = 1\n if o == \"noisestddev\":\n self.noiseStdDev = config.getfloat(\"ALGO\",\"noiseStdDev\")\n found = 1\n if o == \"samplesize\":\n self.batchSize = config.getint(\"ALGO\",\"sampleSize\")\n found = 1\n if o == \"wdecay\":\n self.wdecay = config.getint(\"ALGO\",\"wdecay\")\n found = 1\n if o == \"symseed\":\n self.symseed = config.getint(\"ALGO\",\"symseed\")\n found = 1\n if o == \"saveeach\":\n self.saveeach = config.getint(\"ALGO\",\"saveeach\")\n found = 1\n\n if found == 0:\n print(\"\\033[1mOption %s in section [ALGO] of %s file is unknown\\033[0m\" % (o, filename))\n print(\"available hyperparameters are: \")\n print(\"maxmsteps [integer] : max number of (million) steps (default 1)\")\n print(\"stepsize [float] : learning stepsize (default 0.01)\")\n print(\"samplesize [int] : popsize/2 (default 20)\")\n print(\"noiseStdDev [float] : samples noise (default 0.02)\")\n print(\"wdecay [0/2] : weight decay (default 0), 1 = L1, 2 = L2\")\n print(\"symseed [0/1] : same environmental seed to evaluate symmetrical samples [default 1]\")\n print(\"saveeach [integer] : save file every N minutes (default 60)\")\n\n sys.exit()\n else:\n print(\"\\033[1mERROR: configuration file %s does not exist\\033[0m\" % (self.fileini))\n \n\n\n def setProcess(self):\n self.loadhyperparameters() # load hyperparameters\n self.center = np.copy(self.policy.get_trainable_flat()) # the initial centroid\n self.nparams = len(self.center) # number of adaptive parameters\n self.cgen = 0 # currrent generation\n self.samplefitness = zeros(self.batchSize * 2) # the fitness of the samples\n self.samples = None # the random samples\n self.m = zeros(self.nparams) # Adam: momentum vector \n self.v = zeros(self.nparams) # Adam: second momentum vector (adam)\n self.epsilon = 1e-08 # Adam: To avoid numerical issues with division by zero...\n self.beta1 = 0.9 # Adam: beta1\n self.beta2 = 0.999 # Adam: beta2\n self.bestgfit = -99999999 # the best generalization fitness\n self.bfit = 0 # the fitness of the best sample\n self.gfit = 0 # the postevaluation fitness of the best sample of last generation\n self.rs = None # random number generator\n self.inormepisodes = self.batchSize * 2 * self.policy.ntrials / 100.0 # number of normalization episode for generation (1% of generation episodes)\n self.tnormepisodes = 0.0 # total epsidoes in which normalization data should be collected so far\n self.normepisodes = 0 # numer of episodes in which normalization data has been actually collected so far\n self.normalizationdatacollected = False # whether we collected data for updating the normalization vector\n\n def savedata(self):\n self.save() # save the best agent so far, the best postevaluated agent so far, and progress data across generations\n fname = self.filedir + \"/S\" + str(self.seed) + \".fit\"\n fp = open(fname, \"w\") # save summary\n fp.write('Seed %d (%.1f%%) gen %d msteps %d bestfit %.2f bestgfit %.2f bestsam %.2f avgfit %.2f paramsize %.2f \\n' %\n (self.seed, self.steps / float(self.maxsteps) * 100, self.cgen, self.steps / 1000000, self.bestfit, self.bestgfit, self.bfit, self.avgfit, self.avecenter))\n fp.close()\n \n def evaluate(self):\n cseed = self.seed + self.cgen * self.batchSize # Set the seed for current generation (master and workers have the same seed)\n self.rs = np.random.RandomState(cseed)\n self.samples = self.rs.randn(self.batchSize, self.nparams)\n self.cgen += 1\n\n # evaluate samples\n candidate = np.arange(self.nparams, dtype=np.float64)\n for b in range(self.batchSize): \n for bb in range(2):\n if (bb == 0):\n candidate = self.center + self.samples[b,:] * self.noiseStdDev\n else:\n candidate = self.center - self.samples[b,:] * self.noiseStdDev\n self.policy.set_trainable_flat(candidate)\n self.policy.nn.normphase(0) # normalization data is collected during the post-evaluation of the best sample of he previous generation\n eval_rews, eval_length = self.policy.rollout(self.policy.ntrials, seed=(self.seed + (self.cgen * self.batchSize) + b))\n self.samplefitness[b*2+bb] = eval_rews\n self.steps += eval_length\n\n fitness, self.index = ascendent_sort(self.samplefitness) # sort the fitness\n self.avgfit = np.average(fitness) # compute the average fitness \n\n self.bfit = fitness[(self.batchSize * 2) - 1]\n bidx = self.index[(self.batchSize * 2) - 1] \n if ((bidx % 2) == 0): # regenerate the genotype of the best samples\n bestid = int(bidx / 2)\n self.bestsol = self.center + self.samples[bestid] * self.noiseStdDev \n else:\n bestid = int(bidx / 2)\n self.bestsol = self.center - self.samples[bestid] * self.noiseStdDev\n\n self.updateBest(self.bfit, self.bestsol) # Stored if it is the best obtained so far \n \n # postevaluate best sample of the last generation\n # in openaiesp.py this is done the next generation, move this section before the section \"evaluate samples\" to produce identical results\n gfit = 0\n if self.bestsol is not None:\n self.policy.set_trainable_flat(self.bestsol)\n self.tnormepisodes += self.inormepisodes\n for t in range(self.policy.nttrials):\n if self.policy.normalize == 1 and self.normepisodes < self.tnormepisodes:\n self.policy.nn.normphase(1)\n self.normepisodes += 1 # we collect normalization data\n self.normalizationdatacollected = True\n else:\n self.policy.nn.normphase(0)\n eval_rews, eval_length = self.policy.rollout(1, seed=(self.seed + 100000 + t))\n gfit += eval_rews \n self.steps += eval_length\n gfit /= self.policy.nttrials \n self.updateBestg(gfit, self.bestsol)\n\n\n def optimize(self):\n \n popsize = self.batchSize * 2 # compute a vector of utilities [-0.5,0.5]\n utilities = zeros(popsize)\n for i in range(popsize):\n utilities[self.index[i]] = i\n utilities /= (popsize - 1)\n utilities -= 0.5\n \n weights = zeros(self.batchSize) # Assign the weights (utility) to samples on the basis of their fitness rank\n for i in range(self.batchSize):\n idx = 2 * i\n weights[i] = (utilities[idx] - utilities[idx + 1]) # merge the utility of symmetric samples\n\n g = 0.0\n i = 0\n while i < self.batchSize: # Compute the gradient (the dot product of the samples for their utilities)\n gsize = -1\n if self.batchSize - i < 500: # if the popsize is larger than 500, compute the gradient for multiple sub-populations\n gsize = self.batchSize - i\n else:\n gsize = 500\n g += dot(weights[i:i + gsize], self.samples[i:i + gsize,:]) \n i += gsize\n g /= popsize # normalize the gradient for the popsize\n \n if self.wdecay == 1:\n globalg = -g + 0.005 * self.center # apply weight decay\n else:\n globalg = -g\n\n # adam stochastic optimizer\n a = self.stepsize * sqrt(1.0 - self.beta2 ** self.cgen) / (1.0 - self.beta1 ** self.cgen)\n self.m = self.beta1 * self.m + (1.0 - self.beta1) * globalg\n self.v = self.beta2 * self.v + (1.0 - self.beta2) * (globalg * globalg)\n dCenter = -a * self.m / (sqrt(self.v) + self.epsilon)\n \n self.center += dCenter # move the center in the direction of the momentum vectors\n self.avecenter = np.average(np.absolute(self.center)) \n\n\n def run(self):\n\n self.setProcess() # initialize class variables\n start_time = time.time()\n last_save_time = start_time\n elapsed = 0\n self.steps = 0\n print(\"Salimans: seed %d maxmsteps %d batchSize %d stepsize %lf noiseStdDev %lf wdecay %d symseed %d nparams %d\" % (self.seed, self.maxsteps / 1000000, self.batchSize, self.stepsize, self.noiseStdDev, self.wdecay, self.symseed, self.nparams))\n\n while (self.steps < self.maxsteps):\n\n \n self.evaluate() # evaluate samples \n \n self.optimize() # estimate the gradient and move the centroid in the gradient direction\n\n self.stat = np.append(self.stat, [self.steps, self.bestfit, self.bestgfit, self.bfit, self.avgfit, self.avecenter]) # store performance across generations\n\n if ((time.time() - last_save_time) > (self.saveeach * 60)):\n self.savedata() # save data on files\n last_save_time = time.time()\n\n if self.normalizationdatacollected:\n self.policy.nn.updateNormalizationVectors() # update the normalization vectors with the new data collected\n self.normalizationdatacollected = False\n\n print('Seed %d (%.1f%%) gen %d msteps %d bestfit %.2f bestgfit %.2f bestsam %.2f avg %.2f weightsize %.2f' %\n (self.seed, self.steps / float(self.maxsteps) * 100, self.cgen, self.steps / 1000000, self.bestfit, self.bestgfit, self.bfit, self.avgfit, self.avecenter))\n\n self.savedata() # save data at the end of evolution\n\n # print simulation time\n end_time = time.time()\n print('Simulation time: %dm%ds ' % (divmod(end_time - start_time, 60)))\n\n", "meta": {"hexsha": "651fcb74b3801ffa34d37787b37ae0c4640fd65a", "size": 12778, "ext": "py", "lang": "Python", "max_stars_repo_path": "Week-04/evorobotpy2/bin/openaies.py", "max_stars_repo_name": "mhd-medfa/BCR22", "max_stars_repo_head_hexsha": "9f892928f293bb9c2c7152e82713f976d8cd0485", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Week-04/evorobotpy2/bin/openaies.py", "max_issues_repo_name": "mhd-medfa/BCR22", "max_issues_repo_head_hexsha": "9f892928f293bb9c2c7152e82713f976d8cd0485", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Week-04/evorobotpy2/bin/openaies.py", "max_forks_repo_name": "mhd-medfa/BCR22", "max_forks_repo_head_hexsha": "9f892928f293bb9c2c7152e82713f976d8cd0485", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-03T17:27:47.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T17:27:47.000Z", "avg_line_length": 52.368852459, "max_line_length": 250, "alphanum_fraction": 0.5585381124, "include": true, "reason": "import numpy,from numpy", "num_tokens": 2981, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583269943353744, "lm_q2_score": 0.35220178204788966, "lm_q1q2_score": 0.19664376237036085}} {"text": "import copy\nimport numpy as np\nimport scipy as sp\nfrom scipy import sparse\nfrom mesohops.dynamics.eom_functions import operator_expectation\nfrom mesohops.util.physical_constants import hbar\nfrom mesohops.util.exceptions import UnsupportedRequest\n\n\n__title__ = \"Basis Class\"\n__author__ = \"D. I. G. Bennett\"\n__version__ = \"1.0\"\n\n\nclass HopsBasis(object):\n \"\"\"\n Every HOPS calculation is defines by the HopsSystem, HopsHierarchy, and HopsEOM\n classes (and their associated parameters). These form the basis set for the\n calculation. HopsBasis is the class that contains all of these sub-classes and\n mediates the way the HopsTrajectory will interact with them.\n \"\"\"\n\n def __init__(self, system, hierarchy, eom):\n \"\"\"\n INPUTS:\n -------\n 1. system: dictionary of user inputs\n [see hops_system.py]\n a. HAMILTONIAN\n b. GW_SYSBATH\n c. CORRELATION_FUNCTION_TYPE\n d. LOPERATORS\n e. CORRELATION_FUNCTION\n 2. hierarchy_parameters: dictionary of user inputs\n [see hops_hierarchy.py]\n f. MAXHIER\n g. TERMINATOR\n h. STATIC_FILTERS\n 3. eom_parameters: dictionary of user inputs\n [see hops_eom.py]\n i. TIME_DEPENDENCE\n j. EQUATION_OF_MOTION\n k. ADAPTIVE_H\n l. ADAPTIVE_S\n m. DELTA_H\n n. DELTA_S\n\n RETURNS\n -------\n None\n \"\"\"\n self.system = system\n self.hierarchy = hierarchy\n self.eom = eom\n\n def initialize(self, psi_0):\n \"\"\"\n This function initializes the hierarchy and equations of motion classes\n so that everything is prepared for integration. It returns the\n dsystem_dt function to be used in the integrator.\n\n PARAMETERS\n ----------\n 1. psi_0 : np.array\n the initial wave function\n\n RETURNS\n -------\n 1. dsystem_dt : function\n this is the core function for calculating the time-evolution of\n the wave function\n \"\"\"\n self.hierarchy.initialize(self.adaptive_h)\n self.system.initialize(self.adaptive_s, psi_0)\n dsystem_dt = self.eom._prepare_derivative(self.system, self.hierarchy)\n\n return dsystem_dt\n\n def define_basis(self, Φ, delta_t, z_step):\n \"\"\"\n This is the function that determines what basis is needed for a given\n full hierarchy (Φ) in order to construct an approximate derivative with\n error below the specified threshold.\n\n PARAMETERS\n ----------\n 1. Φ : np.array\n the current full hierarchy\n 2. delta_t : float\n the timestep for the calculation\n 3. z_step : list\n the list of noise terms (compressed) for the next timestep\n\n RETURNS\n -------\n 1. state_update :\n a. list_state_new : list\n list of states in the new basis (S_1)\n b. list_state_stable : list\n list of stable states in the new basis (S_S)\n c. list_state_bound : list\n list of boundary states in the new basis (S_B)\n 2. hierarchy_update :\n d. list_aux_new : list\n list of auxiliaries in new basis (H_1)\n e. list_stable_aux : list\n list of stable auxiliaries in the new basis (H_S)\n f. list_aux_bound : list\n list of boundary auxiliaries in the new basis (H_B)\n\n \"\"\"\n # ==========================================\n # ======= Calculate Updates ======\n # ==========================================\n\n # Calculate New Hierarchy List\n # ----------------------------\n if self.adaptive_h:\n list_aux_stable, list_aux_bound = self._check_hierarchy_list(\n Φ, delta_t, z_step\n )\n list_aux_new = list(set(list_aux_stable) | set(list_aux_bound))\n list_index_stable_aux = [\n self.hierarchy._aux_index(aux) for aux in list_aux_stable\n ]\n list_index_stable_aux.sort()\n else:\n list_aux_new = self.hierarchy.auxiliary_list\n list_aux_stable = self.hierarchy.auxiliary_list\n list_aux_bound = []\n list_index_stable_aux = np.arange(len(self.hierarchy.auxiliary_list))\n E2_flux = None\n\n # Calculate New State List\n # ------------------------\n if self.adaptive_s:\n list_state_stable, list_state_bound = self._check_state_list(\n Φ, delta_t, z_step, list_index_stable_aux\n )\n list_state_new = list(set(list_state_stable) | set(list_state_bound))\n list_state_stable.sort()\n else:\n list_state_new = list(set(self.system.state_list))\n list_state_bound = []\n list_state_stable = list_state_new\n\n return [\n (list_state_new, list_state_stable, list_state_bound),\n (list_aux_new, list_aux_stable, list_aux_bound),\n ]\n\n def update_basis(self, Φ, state_update, aux_update):\n \"\"\"\n This function updates the derivative function and full hierarchy vector (Φ) for the\n new basis (hierarchy and/or system).\n\n PARAMETERS\n ----------\n 1. Φ : np.array\n the current full hierarchy\n 2. state_update : list\n list of list containing list_state_new, list_stable_state, and list_add_state\n 3. aux_update : list\n list of list containing list_aux_new, list_stable_aux, and list_add_aux\n\n RETURNS\n -------\n 1. Φ_new : np.array\n the updated full hierarchy\n 2. dsystem_dt : function\n the updated derivative function\n \"\"\"\n # Unpack input values\n # ===================\n (list_state_new, list_stable_state, list_add_state) = state_update\n (list_aux_new, list_stable_aux, list_add_aux) = aux_update\n\n # Update State List\n # =================\n flag_update = False\n if set(list_state_new) != set(self.system.state_list):\n flag_update = True\n list_state_previous = copy.deepcopy(self.system.state_list)\n list_absindex_l2_old = copy.deepcopy(self.system.list_absindex_L2)\n self.system.state_list = np.array(list_state_new)\n else:\n list_state_previous = self.system.state_list\n list_absindex_l2_old = self.system.list_absindex_L2\n\n # Update Hierarchy List\n # =====================\n if set(list_aux_new) != set(self.hierarchy.auxiliary_list):\n flag_update = True\n # Update Auxiliary List\n list_old_aux = self.hierarchy.auxiliary_list\n self.hierarchy.auxiliary_list = list_aux_new\n else:\n list_old_aux = self.hierarchy.auxiliary_list\n\n # Update state of calculation for new basis\n # =========================================\n if flag_update:\n\n # Define permutation matrix from old basis --> new basis\n # ------------------------------------------------------\n permute_aux_row = []\n permute_aux_col = []\n nstate_old = len(list_state_previous)\n list_index_old_stable_state = np.array(\n [\n i_rel\n for (i_rel, i_abs) in enumerate(list_state_previous)\n if i_abs in list_stable_state\n ]\n )\n list_index_new_stable_state = np.array(\n [\n i_rel\n for (i_rel, i_abs) in enumerate(self.system.state_list)\n if i_abs in list_stable_state\n ]\n )\n\n for aux in list_stable_aux:\n permute_aux_row.extend(\n self.hierarchy._aux_index(aux) * self.n_state\n + list_index_new_stable_state\n )\n permute_aux_col.extend(\n list_old_aux.index(aux) * nstate_old + list_index_old_stable_state\n )\n\n # Update phi\n # ----------\n Φ_new = np.zeros(self.n_hier * self.n_state, dtype=np.complex128)\n Φ_new[permute_aux_row] = Φ[permute_aux_col]\n\n # Update dsystem_dt\n # -----------------\n dsystem_dt = self.eom._prepare_derivative(\n self.system,\n self.hierarchy,\n list_stable_aux,\n list_add_aux,\n list_stable_state,\n list_absindex_l2_old,\n len(list_old_aux) * nstate_old,\n [permute_aux_row, permute_aux_col],\n update=True,\n )\n\n return (Φ_new, dsystem_dt)\n else:\n return (Φ, self.eom.dsystem_dt)\n\n def _check_state_list(self, Φ, delta_t, z_step, list_index_aux_stable):\n \"\"\"\n This is a function that determines the states which should be\n included in the adaptive integration for the next time point.\n\n PARAMETERS\n ----------\n 1. Φ : np.array\n the current full hierarchy\n 2. delta_t : float\n the timestep for the calculation\n 3. z_step : list\n the list of noise terms (compressed) for the next timestep\n 4. list_index_aux_stable : list\n a list of relative indices for the stable auxiliaries\n\n RETURNS\n -------\n 1. list_state_stable : list\n list of stable states (absolute state index, S_S)\n 2. list_state_boundary : list\n a list of the boundary states (absolute state index, S_B)\n \"\"\"\n # Define Constants\n # ----------------\n delta_state = self.delta_s # * np.linalg.norm(Φ)\n\n # CONSTRUCT STABLE STATE (S_S)\n # ============================\n\n # Construct Error For Excluding Member of S0\n # ------------------------------------------\n error_by_state = self.error_stable_state(\n Φ, delta_t, z_step, list_index_aux_stable\n )\n\n # Determine the Stable States (S_S = S_0 & S_1)\n # ---------------------------------------------\n list_index_stable, list_state_stable = self._determine_basis_from_list(\n error_by_state, delta_state / 2, self.system.state_list\n )\n\n # CONSTRUCT BOUNDARY STATE (S_B)\n # ==============================\n\n # Establish the error available for the boundary states\n # -----------------------------------------------------\n stable_error = np.sqrt(\n np.max([\n np.sum(error_by_state ** 2) - np.sum(error_by_state[list_index_stable] ** 2),\n 0])\n )\n bound_error = delta_state - stable_error\n\n # Construct Error for Excluding Member of S0^C\n # --------------------------------------------\n list_index_nonzero, list_error_nonzero = self.error_boundary_state(\n Φ, list_index_stable, list_index_aux_stable\n )\n\n # Determine Boundary States\n # -------------------------\n if len(list_error_nonzero) > 0:\n _, list_state_boundary = self._determine_basis_from_list(\n list_error_nonzero, bound_error, list_index_nonzero\n )\n else:\n list_state_boundary = []\n\n # Check for overlap with populated states\n # ---------------------------------------\n list_state_boundary = list(\n set(list_state_boundary) - set(self.system.state_list)\n )\n list_state_boundary.sort()\n\n return (\n np.array(list_state_stable, dtype=np.int),\n np.array(list_state_boundary, dtype=np.int),\n )\n\n def _check_hierarchy_list(self, Φ, delta_t, z_step):\n \"\"\"\n This is a function that determines the auxiliaries which should be\n included in the adaptive integration for the next time point.\n\n PARAMETERS\n ----------\n 1. Φ : np.array\n the current full hierarchy\n 2. delta_t : float\n the timestep for the calculation\n 3. z_step : list\n the list of noise terms (compressed) for the next timestep\n\n RETURNS\n -------\n 1. list_aux_stable : list\n a list of the stable auxiliaries (H_S)\n 2. list_aux_boundary : list\n a list of auxiliaries that share a boundary with stable\n auxiliaries (H_B)\n \"\"\"\n # Define Constants\n # ----------------\n delta_hier = self.delta_h # * np.linalg.norm(Φ)\n\n # CONSTRUCT STABLE HIERARCHY\n # ==========================\n\n # Construct Error For Excluding Member of H0\n # ------------------------------------------\n error_by_aux, list_e2_kflux = self.hier_stable_error(Φ, delta_t, z_step)\n\n # Determine the Stable Auxiliaries (H_S = H_0 & H_1)\n # --------------------------------------------------\n list_index_stable, list_aux_stable = self._determine_basis_from_list(\n error_by_aux, delta_hier / 2, self.hierarchy.auxiliary_list\n )\n\n # CONSTRUCT BOUNDARY HIERARCHY\n # ============================\n\n # Establish the error available for the boundary auxiliaries\n # ----------------------------------------------------------\n stable_error = np.sqrt(\n np.max([\n np.sum(error_by_aux ** 2) - np.sum(error_by_aux[list_index_stable] ** 2),\n 0])\n )\n bound_error = delta_hier - stable_error\n\n # Construct Error For Excluding Members of H0^C\n # ---------------------------------------------\n E2_flux_up = list_e2_kflux[0][:, list_index_stable]\n E2_flux_down = list_e2_kflux[1][:, list_index_stable]\n\n # Determine the Boundary Auxiliaries (H_B = H0^C & H_1)\n # -----------------------------------------------------\n list_aux_up, list_aux_down = self._determine_boundary_hier(\n [E2_flux_up, E2_flux_down], list_index_stable, bound_error\n )\n\n # Check Boundary Set For Duplication\n # ----------------------------------\n # NOTE: Theoretically, the boundary should not contain any members of H0, but\n # when we implemented that in practice it resulted in a huge explosion\n # of the number of inch wormsteps that were required.\n list_aux_boundary = list(\n (set(list_aux_up) | set(list_aux_down)) - set(self.hierarchy.auxiliary_list)\n )\n\n # Filter Boundary Set for Auxiliaries That Are Not Part of H_T\n # ------------------------------------------------------------\n if len(list_aux_boundary) > 0:\n list_aux_boundary = self.hierarchy.filter_aux_list(list_aux_boundary)\n return list_aux_stable, list_aux_boundary\n\n def _determine_boundary_hier(\n self, list_e2_kflux, list_index_aux_stable, bound_error\n ):\n \"\"\"\n This function determines the set of boundary auxiliaries for the next time step\n\n PARAMETERS\n ----------\n 1. list_e2_kflux : list\n a list of list containing the error values for the flux up\n and flux down terms\n 2. list_index_aux_stable : list\n a list of the indices for stable auxiliaries\n 3. bound_error : float\n the boundary error value\n\n RETURNS\n -------\n 1. list_aux_up : list\n a list of the flux up auxiliaries\n 2. list_aux_down : list\n a list of the flux down auxiliaries\n \"\"\"\n # Construct constants\n # -------------------\n E2_flux_up = list_e2_kflux[0]\n E2_flux_down = list_e2_kflux[1]\n\n # Find the error threshold for edge auxiliaries\n # ---------------------------------------------\n E1_nonzero_flux = E2_flux_up[E2_flux_up != 0]\n sorted_error = np.sort(\n np.append(E1_nonzero_flux, E2_flux_down[E2_flux_down != 0])\n )\n error_thresh = self._determine_error_thresh(sorted_error, bound_error)\n\n # Loop over residual fluxes to identify boundary auxiliaries\n # ----------------------------------------------------------\n list_aux_up = [\n self.hierarchy.auxiliary_list[list_index_aux_stable[i_aux]].e_step(\n self.system.list_absindex_mode[i_mode_rel], 1\n )\n for (i_mode_rel, i_aux) in zip(*np.where(E2_flux_up > error_thresh))\n ]\n\n list_aux_down = [\n self.hierarchy.auxiliary_list[list_index_aux_stable[i_aux]].e_step(\n self.system.list_absindex_mode[i_mode_rel], -1\n )\n for (i_mode_rel, i_aux) in zip(*np.where(E2_flux_down > error_thresh))\n ]\n return (list_aux_up, list_aux_down)\n\n def _determine_basis_from_list(self, error_by_member, max_error, list_member):\n \"\"\"\n This function determines the members of a list that must be kept in order\n for the total error (terms that are dropped) to be below the max_error value.\n\n PARAMETERS\n ----------\n 1. error_by_member : np.array\n a list of error values\n 2. max_error : float\n the maximum error value\n 3. list_member : np.array\n a list of members\n\n RETURNS\n -------\n 1. list_index : np.array\n a list of indices for the members\n 2. list_new_member : list\n a list of the members\n \"\"\"\n error_thresh = self._determine_error_thresh(np.sort(error_by_member), max_error)\n list_index = np.where(error_by_member > error_thresh)[0]\n list_new_member = [list_member[i_aux] for i_aux in list_index]\n return (list_index, list_new_member)\n\n @staticmethod\n def _determine_error_thresh(sorted_error, max_error):\n \"\"\"\n This function determines which error value becomes the error threshold such\n that the sum of all errors below the threshold remains less then max_error.\n\n PARAMETERS\n ----------\n 1. sorted_error : np.array\n a list of error values\n 2. max_error : float\n the maximum error value\n\n RETURNS\n -------\n 3. error_thresh : float\n the error value at which the threshold is established\n\n \"\"\"\n index_thresh = np.argmax(np.sqrt(np.cumsum(sorted_error ** 2)) > max_error)\n\n if index_thresh > 0:\n error_thresh = sorted_error[index_thresh - 1]\n else:\n error_thresh = 0.0\n\n return error_thresh\n\n def error_boundary_state(self, Φ, list_index_stable, list_index_aux_stable):\n \"\"\"\n This function determines the error associated with neglecting flux into n not\n a member of S_t. This corresponds to equations 43-45 in arXiv:2008.06496\n\n PARAMETERS\n ----------\n 1. Φ : np.array\n the current full hierarchy vector\n 2. list_index_stable : list\n a list of the stable states\n 3. list_index_aux_stable : list\n a list relative indices for the stable auxiliaries\n\n RETURNS\n -------\n 1. list_index_nonzero : list\n a list of the nonzero state boundary indices\n 2. list_error_nonzero : list\n a list of the nonzero state boundary error values\n \"\"\"\n if len(list_index_stable) < self.system.param[\"NSTATES\"]:\n # Remove aux components from H0\\H1\n # -------------------------------------\n C2_phi = np.zeros([self.n_state, self.n_hier], dtype=np.complex128)\n C2_phi[np.ix_(list_index_stable, list_index_aux_stable)] = np.array(\n Φ\n ).reshape([self.n_state, self.n_hier], order=\"F\")[\n np.ix_(list_index_stable, list_index_aux_stable)\n ]\n\n # Construct Hamiltonian\n # ---------------------------------------------------------\n list_s0 = np.array(self.system.state_list)\n\n # First construct ST<--S0 Hamiltonian\n H2_sparse_hamiltonian = self.system.param[\"SPARSE_HAMILTONIAN\"][:, list_s0]\n\n # Remove components that map S0<--S0\n H2_sparse_subset = sparse.coo_matrix(\n H2_sparse_hamiltonian[np.ix_(list_s0, range(len(list_s0)))]\n )\n H2_removal = sparse.csc_matrix(\n (\n H2_sparse_subset.data,\n (\n list_s0[H2_sparse_subset.row],\n np.arange(len(list_s0))[H2_sparse_subset.col],\n ),\n ),\n shape=H2_sparse_hamiltonian.shape,\n )\n H2_sparse_hamiltonian = H2_sparse_hamiltonian - H2_removal\n\n # Determine Boundary States\n # -------------------------\n C2_phi_deriv = abs(\n H2_sparse_hamiltonian @ sparse.csc_matrix(C2_phi / hbar)\n ).power(2)\n C1_sum_deriv = np.sum(C2_phi_deriv, axis=1)\n return (\n C1_sum_deriv.nonzero()[0],\n np.sqrt(np.array(C1_sum_deriv[C1_sum_deriv.nonzero()])[0]),\n )\n\n else:\n return [], []\n\n def error_stable_state(self, Φ, delta_t, z_step, list_index_aux_stable):\n \"\"\"\n This function finds the total error associated with neglecting n in the state\n basis S_t. This includes the error associated with deleting a state from the basis,\n the error associated with losing all flux into a state, and the error associated\n with losing all flux out of a state. This corresponds to equations 37-42 in\n arXiv:2008.06496\n\n\n PARAMETERS\n ----------\n 1. Φ : np.array\n the current full hierarchy vector\n 2. delta_t : float\n the timestep for the calculation\n 3. z_step : list\n the list of noise terms (compressed) for the next timestep\n 4. list_index_aux_stable : list\n a list relative indices for the stable auxiliaries (A_p)\n\n RETURNS\n -------\n 1. error : np.array\n list of error associated with removing each state\n \"\"\"\n M2_state_from_mode = np.zeros([self.n_state, self.system.n_hmodes])\n M2_state_from_mode[\n self.system.list_state_indices_by_hmode[:, 0],\n np.arange(np.shape(self.system.list_state_indices_by_hmode)[0]),\n ] = 1\n\n # Construct the error terms\n # -------------------------\n E2_deriv_state = self.error_deriv(Φ, z_step, list_index_aux_stable)[\n :, list_index_aux_stable\n ]\n E2_deletion = self.error_deletion(Φ, delta_t)[:, list_index_aux_stable]\n E1_state_flux = self.error_sflux_state(\n Φ, list_index_aux_stable, self.system.state_list\n )\n E2_flux_down = self.error_flux_down(Φ, \"S\")[:, list_index_aux_stable]\n E2_flux_up = self.error_flux_up(Φ)[:, list_index_aux_stable]\n # Map flux_up error from mode to state space\n E2_flux_up = np.sqrt(M2_state_from_mode @ E2_flux_up ** 2)\n\n # Compress the error onto the state/mode axis\n # -------------------------------------------\n return np.sqrt(\n np.sum(E2_deriv_state ** 2, axis=1)\n + np.sum(E2_deletion ** 2, axis=1)\n + np.sum(E2_flux_up ** 2, axis=1)\n + np.sum(E2_flux_down ** 2, axis=1)\n + E1_state_flux ** 2\n )\n\n def hier_stable_error(self, Φ, delta_t, z_step):\n \"\"\"\n This function finds the total error associated with removing k in A_t.\n This corresponds to the sum of equations 29,30,31,33, and 34 in arXiv:2008.06496\n\n PARAMETERS\n ----------\n 1. Φ : np.array\n the current full hierarchy vector\n 2. delta_t : float\n the timestep for the calculation\n 3. z_step : list\n the list of noise terms (compressed) for the next timestep\n\n RETURNS\n -------\n 1. error : np.array\n list of error associated with removing each auxiliary in A_t\n 2. E2_flux_up : np.array\n the error induced by neglecting flux from A_t (or A_p)\n to auxiliaries with lower summed index in A_t^C.\n 3. E2_flux_down : np.array\n the error induced by neglecting flux from A_t (or A_p)\n to auxiliaries with higher summed index in A_t^C.\n \"\"\"\n # Construct the error terms\n # -------------------------\n E2_deletion = self.error_deletion(Φ, delta_t)\n E2_deriv_self = self.error_deriv(Φ, z_step)\n E1_flux_state = self.error_sflux_hier(Φ, self.system.state_list)\n E2_flux_up = self.error_flux_up(Φ)\n E2_flux_down = self.error_flux_down(Φ, \"H\")\n\n # Compress the error onto the aux axis\n # ------------------------------------\n return (\n np.sqrt(\n np.sum(E2_deriv_self ** 2, axis=0)\n + np.sum(E2_deletion ** 2, axis=0)\n + np.sum(E2_flux_down ** 2, axis=0)\n + np.sum(E2_flux_up ** 2, axis=0)\n + E1_flux_state\n ),\n [E2_flux_up, E2_flux_down],\n )\n\n def error_sflux_state(self, Φ, list_index_aux_stable, list_states):\n \"\"\"\n The error associated with losing all flux out of n in S_t. This flux always involves\n changing the state index and, as a result, can be rewritten in terms of the -iH\n component of the self-interaction. This corresponds to equation 38 and 39 in\n arXiv:2008.06496\n\n PARAMETERS\n ----------\n 1. Φ : np.array\n the current full hierarchy vector\n 2. list_index_aux_stable : list\n a list relative indices for the stable auxiliaries (A_p)\n 3. list_states : list\n the list of current states (absolute index)\n\n RETURNS\n -------\n 1. E1_state_flux : array\n the error associated with flux out of each state in S_t\n \"\"\"\n C2_phi = np.asarray(Φ).reshape([self.n_state, self.n_hier], order=\"F\")[\n :, list_index_aux_stable\n ]\n H2_sparse_hamiltonian = self.system.param[\"SPARSE_HAMILTONIAN\"][:, list_states]\n H2_sparse_hamiltonian = H2_sparse_hamiltonian - sp.sparse.diags(\n H2_sparse_hamiltonian.diagonal(0),\n format=\"csc\",\n shape=H2_sparse_hamiltonian.shape,\n )\n V1_norm_squared = np.array(\n np.sum(np.abs(H2_sparse_hamiltonian).power(2), axis=0))[:, 0]\n C1_norm_squared_by_state = np.sum(np.abs(C2_phi) ** 2, axis=1)\n return np.sqrt(V1_norm_squared * C1_norm_squared_by_state) / hbar\n\n def error_sflux_hier(self, Φ, list_s0):\n \"\"\"\n The error associated with losing all flux terms inside the kth auxiliary to\n states not contained in S_t. This corresponds to equation 30 in arXiv:2008.06496\n\n\n PARAMETERS\n ----------\n 1. Φ : np.array\n the current full hierarchy vector\n 2. list_s0 : list\n a list of the current states (absolute index)\n\n RETURNS\n -------\n 1. E2_flux_state : array\n the error introduced by losing flux within k from S_t to S_t^C\n for each k in A_t\n\n \"\"\"\n # Construct the 2D phi and sparse Hamiltonian\n # -------------------------------------------\n list_s0 = np.array(list_s0)\n C2_phi = np.asarray(Φ).reshape([self.n_state, self.n_hier], order=\"F\")\n\n H2_sparse_hamiltonian = self.system.param[\"SPARSE_HAMILTONIAN\"][:, list_s0]\n\n # Remove the components of the Hamiltonian that map S0-->S0\n # ---------------------------------------------------------\n H2_sparse_subset = sparse.coo_matrix(\n H2_sparse_hamiltonian[np.ix_(list_s0, range(len(list_s0)))]\n )\n H2_removal = sparse.csc_matrix(\n (\n H2_sparse_subset.data,\n (\n list_s0[H2_sparse_subset.row],\n np.arange(len(list_s0))[H2_sparse_subset.col],\n ),\n ),\n shape=H2_sparse_hamiltonian.shape,\n )\n H2_sparse_hamiltonian = H2_sparse_hamiltonian - H2_removal\n D2_derivative_abs_sq = np.abs(\n H2_sparse_hamiltonian @ sparse.csc_matrix(C2_phi) / hbar).power(2)\n return np.sqrt(np.array(np.sum(D2_derivative_abs_sq, axis=0))[0])\n\n def error_deriv(self, Φ, z_step, list_index_aux_stable=None):\n \"\"\"\n The error associated with losing all flux terms into the k auxiliary and n state,\n where k is in A_t and n is in S_t. This corresponds to equation 29 in arXiv:2008.06496\n\n PARAMETERS\n ----------\n 1. Φ : np.array\n The current full hierarchy vector\n 2. z_step : list\n the list of noise terms (compressed) for the next timestep\n 3. list_index_aux_stable : list\n a list relative indices for the stable auxiliaries\n\n RETURNS\n -------\n 1. E2_del_phi : np.array\n the error associated with losing flux to a component (either\n hierarchy or state basis element) in H_t direct sum S_t\n \"\"\"\n if list_index_aux_stable is not None:\n # Error arises for flux only out of the stable auxiliaries\n # --------------------------------------------------------\n Φ_stab = np.zeros(self.n_state * self.n_hier, dtype=np.complex128)\n Φ_stab_v = Φ_stab.view().reshape([self.n_state, self.n_hier], order=\"F\")\n Φ_stab_v[:, list_index_aux_stable] = Φ.view().reshape(\n [self.n_state, self.n_hier], order=\"F\"\n )[:, list_index_aux_stable]\n else:\n Φ_stab = Φ\n\n list_avg_L2 = [\n operator_expectation(L, Φ[: self.n_state]) for L in self.system.list_L2_coo\n ]\n\n P1_del_phi = (\n self.eom.K2_k @ Φ_stab + self.eom.K2_kp1 @ Φ_stab + self.eom.K2_km1 @ Φ_stab\n )\n\n for j in range(len(self.system.list_absindex_L2)):\n P1_del_phi += z_step[j] * self.eom.Z2_k[j] @ Φ_stab\n P1_del_phi += np.conj(list_avg_L2[j]) * self.eom.Z2_kp1[j] @ Φ_stab\n\n E2_del_phi = np.abs(\n P1_del_phi.reshape([self.n_state, self.n_hier], order=\"F\") / hbar\n )\n\n return E2_del_phi\n\n def error_deletion(self, Φ, delta_t):\n \"\"\"\n The error associated with setting the corresponding component of Phi to 0,\n corresponding to equation 34 and 42 in arXiv:2008.06496\n\n PARAMETERS\n ----------\n 1. Φ : np.array\n The current position of the full hierarchy vector\n 2. delta_t : float\n the timestep for the calculation\n\n RETURNS\n -------\n 1. E2_site_aux : np.array\n the error induced by removing components of Φ in A_t+S_t\n \"\"\"\n\n # Error arising from removing the auxiliary directly\n # --------------------------------------------------\n E2_site_aux = np.abs(\n np.asarray(Φ).reshape([self.n_state, self.n_hier], order=\"F\") / delta_t\n )\n\n return E2_site_aux\n\n def error_flux_down(self, Φ, type):\n \"\"\"\n A function that returns the error associated with neglecting flux from members of\n A_t to auxiliaries in A_t^C that arise due to flux from higher auxiliaries to\n lower auxiliaries. This corresponds to equation 33 and 41 in arXiv:2008.06496\n\n PARAMETERS\n ----------\n 1. Φ : np.array\n The current state of the hierarchy\n 2. type: string\n 'H' - Hierarchy type calculation\n 'S' - State type calculation\n\n RETURNS\n -------\n 1. E2_flux_down_error : np.array\n the error induced by neglecting flux from A_t (or A_S)\n to auxiliaries with higher summed index in A_t^C.\n \"\"\"\n # Constants\n # ---------\n list_new_states = [\n self.system.list_state_indices_by_hmode[:, 0] + i * self.n_state\n for i in range(self.n_hier)\n ]\n list_modes_from_site_index = [\n item for sublist in list_new_states for item in sublist\n ]\n\n # Reshape hierarchy (to matrix)\n # ------------------------------\n P2_pop_site = (\n np.abs(np.asarray(Φ).reshape([self.n_state, self.n_hier], order=\"F\")) ** 2\n )\n P1_aux_norm = np.sqrt(np.sum(P2_pop_site, axis=0))\n P2_modes_from0 = np.asarray(Φ)[\n np.tile(self.system.list_state_indices_by_hmode[:, 0], self.n_hier)\n ]\n P2_pop_modes_down_1 = (np.abs(P2_modes_from0) ** 2).reshape(\n [self.n_hmodes, self.n_hier], order=\"F\"\n )\n P1_modes = np.asarray(Φ)[list_modes_from_site_index]\n P2_pop_modes = np.abs(P1_modes).reshape([self.n_hmodes, self.n_hier], order=\"F\")\n\n # Get flux factors\n # ----------------\n G2_bymode = np.array(self.system.g)[\n np.tile(list(range(self.n_hmodes)), self.n_hier)\n ].reshape([self.n_hmodes, self.n_hier], order=\"F\")\n W2_bymode = np.array(self.system.w)[\n np.tile(list(range(self.n_hmodes)), self.n_hier)\n ].reshape([self.n_hmodes, self.n_hier], order=\"F\")\n\n F2_filter_aux = np.array(\n [\n [\n 1 if aux[self.system.list_absindex_mode[i_mode_rel]] - 1 >= 0 else 0\n for aux in self.hierarchy.auxiliary_list\n ]\n for i_mode_rel in range(self.n_hmodes)\n ]\n )\n\n if type == \"H\":\n # Hierarchy Type Downward Flux\n # ============================\n E2_flux_down_error = (\n np.real(\n F2_filter_aux\n * np.abs(G2_bymode / W2_bymode)\n * (P2_pop_modes_down_1 * P1_aux_norm[None, :] + P2_pop_modes)\n )\n / hbar\n )\n elif type == \"S\":\n # State Type Downward Flux\n # ========================\n # Construct term\n # --------------------\n E2_lm = np.tile(\n np.sum(\n F2_filter_aux * np.abs(G2_bymode / W2_bymode) * P2_pop_modes_down_1,\n axis=0,\n ),\n [self.n_state, 1],\n )\n\n # Map Error to States\n # -------------------\n M2_state_from_mode = np.zeros([self.n_state, self.system.n_hmodes])\n M2_state_from_mode[\n self.system.list_state_indices_by_hmode[:, 0],\n np.arange(np.shape(self.system.list_state_indices_by_hmode)[0]),\n ] = 1\n E2_flux_down_error = (\n M2_state_from_mode\n @ np.real(F2_filter_aux * np.abs(G2_bymode / W2_bymode) * P2_pop_modes)\n / hbar\n )\n E2_flux_down_error += E2_lm * P2_pop_site / hbar\n else:\n E2_flux_down_error = 0\n raise UnsupportedRequest(type, \"error_flux_down\")\n\n return E2_flux_down_error\n\n def error_flux_up(self, Φ):\n \"\"\"\n A function that returns the error associated with neglecting flux from members of\n A_t to auxiliaries in A_t^C that arise due to flux from lower auxiliaries to\n higher auxiliaries. This corresponds to equation 31 and 40 in arXiv:2008.06496\n\n PARAMETERS\n ----------\n 1. Φ : np.array\n The current state of the hierarchy\n\n RETURNS\n -------\n 1. E2_flux_up_error : np. array\n the error induced by neglecting flux from A_t (or A_S)\n to auxiliaries with lower summed index in A_t^C.\n \"\"\"\n # Constants\n # ---------\n list_new_states = [\n self.system.list_state_indices_by_hmode[:, 0] + i * self.n_state\n for i in range(self.n_hier)\n ]\n list_modes_from_site_index = [\n item for sublist in list_new_states for item in sublist\n ]\n\n # Reshape hierarchy (to matrix)\n # ------------------------------\n P1_modes = np.asarray(Φ)[list_modes_from_site_index]\n P2_pop_modes = np.sqrt(np.abs(P1_modes) ** 2).reshape(\n [self.n_hmodes, self.n_hier], order=\"F\"\n )\n\n # Get flux factors\n # ----------------\n W2_bymode = np.array(self.system.w)[\n np.tile(list(range(self.n_hmodes)), self.n_hier)\n ].reshape([self.n_hmodes, self.n_hier], order=\"F\")\n K2aux_bymode = np.transpose(\n np.array(\n [\n aux.get_values(self.system.list_absindex_mode)\n for aux in self.hierarchy.auxiliary_list\n ]\n )\n )\n\n # Filter out fluxes beyond the hierarchy depth\n # --------------------------------------------\n filter_aux = np.array(\n [\n i_aux\n for (i_aux, aux) in enumerate(self.hierarchy.auxiliary_list)\n if np.sum(aux) + 1 > self.hierarchy.param[\"MAXHIER\"]\n ]\n )\n F2_filter = np.ones([self.n_hmodes, self.n_hier])\n if filter_aux.size > 0:\n F2_filter[:, filter_aux] = 0\n\n # Filter out Markovian Modes\n # --------------------------\n array2D_mark_param = np.array(\n [\n np.array(param)[self.system.list_absindex_mode]\n for (name, param) in self.hierarchy.param[\"STATIC_FILTERS\"]\n if name == \"Markovian\"\n ]\n )\n if len(array2D_mark_param) > 0:\n array_mark_param = np.any(array2D_mark_param, axis=0)\n F2_filter_markov = np.ones([self.n_hmodes, self.n_hier])\n F2_filter_markov[array_mark_param, 1:] = 0\n F2_filter = F2_filter * F2_filter_markov\n\n # Test upward fluxes\n # ------------------\n return F2_filter * np.abs(W2_bymode) * (1 + K2aux_bymode) * P2_pop_modes / hbar\n\n @property\n def n_hmodes(self):\n return self.system.n_hmodes\n\n @property\n def n_state(self):\n return self.system.size\n\n @property\n def n_hier(self):\n return self.hierarchy.size\n\n @property\n def adaptive(self):\n return self.eom.param[\"ADAPTIVE\"]\n\n @property\n def adaptive_h(self):\n return self.eom.param[\"ADAPTIVE_H\"]\n\n @property\n def adaptive_s(self):\n return self.eom.param[\"ADAPTIVE_S\"]\n\n @property\n def delta_h(self):\n return self.eom.param[\"DELTA_H\"]\n\n @property\n def delta_s(self):\n return self.eom.param[\"DELTA_S\"]\n", "meta": {"hexsha": "eece8ad60efc833327882e67bc68c5952f178e6e", "size": 40101, "ext": "py", "lang": "Python", "max_stars_repo_path": "mesohops/dynamics/hops_basis.py", "max_stars_repo_name": "MesoscienceLab/mesohops", "max_stars_repo_head_hexsha": "b845dc61e65af158382a47c4894c3875e05f09e1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7, "max_stars_repo_stars_event_min_datetime": "2020-08-17T03:39:42.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-10T22:55:55.000Z", "max_issues_repo_path": "mesohops/dynamics/hops_basis.py", "max_issues_repo_name": "MesoscienceLab/mesohops", "max_issues_repo_head_hexsha": "b845dc61e65af158382a47c4894c3875e05f09e1", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "mesohops/dynamics/hops_basis.py", "max_forks_repo_name": "MesoscienceLab/mesohops", "max_forks_repo_head_hexsha": "b845dc61e65af158382a47c4894c3875e05f09e1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-07-26T02:11:16.000Z", "max_forks_repo_forks_event_max_datetime": "2021-07-26T02:11:16.000Z", "avg_line_length": 37.6535211268, "max_line_length": 103, "alphanum_fraction": 0.5325552979, "include": true, "reason": "import numpy,import scipy,from scipy", "num_tokens": 8974, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583269943353745, "lm_q2_score": 0.3522017820478896, "lm_q1q2_score": 0.19664376237036085}} {"text": "# -*- coding: utf-8 -*-\nimport re\nimport os\nimport gc\nimport math\nimport glob\nimport nltk\nimport shutil\nimport numpy as np\nfrom os import listdir\nfrom zipfile import ZipFile\nfrom collections import Counter\nfrom os.path import isfile, join\nfrom collections import defaultdict\nfrom nltk.stem import PorterStemmer\nfrom nltk.corpus import stopwords as stopWords\nfrom nltk.tokenize import word_tokenize as wordTokenize\n\nnltk.download('punkt')\nnltk.download('stopwords')\n\nstopWordsSet = set(stopWords.words('english'))\nps = PorterStemmer()\n\nclass Node:\n def __init__(self, docId, freq):\n self.freq = freq\n self.doc = docId\n self.next = None\n \n def __str__(self): \n return 'doc:' + str(self.doc) + ', freq:' + str(self.freq)\n\nclass LinkedList:\n def __init__(self):\n self.head = None\n self.tail = None\n self.n_docs = 0\n \n def print_list(self):\n aux = self.head\n while aux:\n print(aux)\n aux = aux.next\n \n def get_doclist(self):\n l = []\n aux = self.head\n while aux:\n l.append([aux.doc, aux.freq])\n aux = aux.next\n return l\n \n def add_doc(self, doc, freq):\n node = Node(doc, freq) \n if self.head == None:\n self.head = node \n else:\n self.tail.next = node\n self.tail = node\n self.n_docs += 1\n\ndef removeSpecialCharacters(text):\n regex = re.compile('[^a-zA-Z0-9\\s]')\n return re.sub(regex, '', text)\n\ndef tokenizeAndRemoveSpecialCharacters(text):\n return wordTokenize(removeSpecialCharacters(text))\n\ndef listsIntersection(lst1, lst2):\n return list(set(lst1) & set(lst2))\n\ndef computeNorm(word, maxFreq, linkedListData, wordsInDocument, itf, docsIds):\n sum = 0\n docs = linkedListData[word].get_doclist()\n\n for doc in wordsInDocument.keys():\n if doc in docs:\n freq = docs[1]\n else:\n freq = 0\n a = pow((0.5 + 0.5 * (freq / maxFreq)), 2)\n b = pow(itf[docsIds[doc]], 2)\n sum = sum + a * b\n\n return math.sqrt(sum)\n\ndef getMaxFreq(word, linkedListData):\n maxFreq = 0\n docs = linkedListData[word].get_doclist()\n\n for doc in docs:\n freq = doc[1]\n if freq > maxFreq:\n maxFreq = freq\n return maxFreq\n\ndef getFileText(text):\n try:\n text = re.search('(.+?)', text, flags=re.DOTALL).group(1)\n except AttributeError: # not found in the original string\n text = ''\n return text\n\ndef getFileName(text):\n try:\n name = re.search('(.+?)', text, flags=re.DOTALL).group(1)\n except AttributeError: # not found in the original string\n name = ''\n return name\n\ndef filterText(removeStopWords, removeStemmingWords, value):\n words = []\n for w in value:\n if removeStopWords == True and w not in stopWordsSet: # stop words\n if removeStemmingWords == True:\n w = ps.stem(w) # stemming\n elif removeStopWords == False:\n if removeStemmingWords == True:\n w = ps.stem(w) # stemming\n words.append(w)\n return words\n\ndef readDocs(path):\n numDocs = 0\n docsIds = {}\n docsNames = []\n wordsInDocument = {}\n\n for folder in glob.glob(path):\n for subfolder in glob.glob(folder + '/*'):\n for directory in glob.glob(subfolder + '/*'):\n for subdir in glob.glob(directory):\n with open(subdir, \"r\") as doc:\n text = doc.read()\n \n fileName = getFileName(text)\n \n wordsInDocument[fileName] = getFileText(text)\n \n wordsInDocument[fileName] = tokenizeAndRemoveSpecialCharacters(wordsInDocument[fileName].lower())\n \n # atribuindo um id pra cada documento\n docsIds[fileName] = numDocs\n\n # salvando nomes dos arquivos\n docsNames.append(fileName)\n \n numDocs = numDocs + 1\n doc.close()\n\n return numDocs, docsIds, docsNames, wordsInDocument\n\ndef readQueriesDoc(path):\n \"\"\"Lê o documento en.topics e armazena as queries, e seus respectivos ids, que serão usados\"\"\"\n\n queries = defaultdict()\n with open(path) as file:\n text = file.read()\n splitted = text.split(\"\\n\\n\")\n\n for line in splitted:\n if 'topics' in line: continue\n id = re.search(r'(.*?)', line).group(1)\n query = re.search(r'(.*?).', line, flags=re.DOTALL).group(1)\n query += re.search(r'(.*?)', line, flags=re.DOTALL).group(1)\n query = removeSpecialCharacters(query)\n queries[id] = wordTokenize(query)\n queries[id] = filterText(True, True, queries[id])\n\n return queries\n\ndef prob_model(wordsInDocument, query, linkedListData, numDocs, uniqueWords):\n \"\"\"\n Modelo probabilistico\n \"\"\"\n\n print(\"\\nRealizando seleção inicial no Modelo probabilístico...\\n\")\n # Seleção inicial\n initial_sel_answer = {}\n \n for doc in wordsInDocument.keys():\n words = wordsInDocument[doc]\n commonWordsBetweenQueryAndDoc = listsIntersection(query, words)\n relevance = 0\n for ki in commonWordsBetweenQueryAndDoc:\n numDocsWithKi = linkedListData[ki].n_docs\n relevance += math.log10((numDocs + 0.5)/(numDocsWithKi + 0.5))\n if relevance > 0:\n initial_sel_answer[doc] = relevance\n \n # verifica qual a maior relevancia encontrada\n # na seleção inicial dentre os documentos\n max = 0\n doc = ''\n for item in initial_sel_answer.keys():\n if initial_sel_answer[item] > max:\n max = initial_sel_answer[item]\n doc = item\n \n print(\"Documento mais relevante na seleção inicial:\", doc)\n\n # Ranqueamento final\n print(\"\\nRealizando Rnaqueamento final no Modelo probabilístico...\\n\")\n\n relevantDocs = []\n numRelevantDocs = {}\n \n sorted_answer = sorted(initial_sel_answer.items(), key = lambda x: x[1], reverse = True)\n\n relevantDocs.append(sorted_answer[0][0])\n \n print(\"Documentos mais relevantes:\", relevantDocs)\n\n final_rank_answer = {}\n \n for word in query:\n if word not in uniqueWords:\n continue\n postings = linkedListData[word].head\n numRelevantDocs[word] = 0\n while postings:\n if postings.doc in relevantDocs:\n numRelevantDocs[word] += 1\n postings = postings.next\n \n numRelevantDocsToQuery = len(relevantDocs)\n \n for doc in wordsInDocument.keys():\n words = wordsInDocument[doc]\n commonWordsBetweenQueryAndDoc = listsIntersection(query, words)\n relevance = 0\n \n for ki in commonWordsBetweenQueryAndDoc:\n numDocsWithKi = linkedListData[ki].n_docs\n numRelevantDocsWithKi = numRelevantDocs[ki]\n numerator = ((numRelevantDocsWithKi + 0.5) * (numDocs - numDocsWithKi - numRelevantDocsToQuery + numRelevantDocsWithKi + 0.5))\n denominator = ((numRelevantDocsToQuery - numRelevantDocsWithKi + 0.5) * (numDocsWithKi - numRelevantDocsWithKi + 0.5))\n relevance += math.log10(numerator / denominator)\n final_rank_answer[doc] = relevance\n\n # final_rank_answer\n\n # Se os dois prints tiverem o mesmo valor, significa que\n # o documento com mais relevância na seleção inicial\n # é o mesmo na seleção final\n\n max = 0\n for item in final_rank_answer.keys():\n if final_rank_answer[item] > max:\n max = final_rank_answer[item]\n\n if final_rank_answer[relevantDocs[0]] == max:\n print(\"\\nResultados iguais = \", final_rank_answer[relevantDocs[0]])\n\n print(\"\\nFim do Modelo probabilístico...\\n\\n\")\n\n return initial_sel_answer, final_rank_answer\n\ndef vect_model(wordsIds, uniqueWords, numDocs, linkedListData, query, docsNames, docsIds):\n \"\"\"\n Modelo Vetorial\n\n Iremos utilizar a ponderação de termos TF-IDF, que considera a frequência de cada termo e a frequência inversa de documento.\n\n Alguns termos possuem maior importância semântica para representar determinado elemento. Por exemplo, um termo que aparece em todos os documentos indexados não nos auxilia em nada no rankeamento dos mesmos, da mesma forma que um termo raro pode ser de extrema importância para identificar um determinado assunto.\n\n \"\"\"\n # Ponderação TF-IDF\n print(\"Realizando ponderação TF-IDF no Modelo Vetorial...\\n\")\n\n m = np.zeros((len(uniqueWords), numDocs))\n \n for word in uniqueWords:\n postings = linkedListData[word].get_doclist()\n \n idf = math.log2(numDocs/ linkedListData[word].n_docs)\n \n for node in postings:\n \n docName = node[0]\n freq = node[1]\n \n # tf-idf = (1+log2(freq))*idf, se freq > 0\n if freq > 0:\n m[wordsIds[word], docsIds[docName]] = (1 + math.log2(freq)) * idf\n # tf-idf = 0, caso contrario\n # m[wordsIds[word], docsIds[docName]] = 0\n\n \"\"\"Normalização pelo tamanho dos documentos\"\"\"\n print(\"Realizando Normalização pelo tamanho dos documentos no Modelo Vetorial...\\n\")\n\n m = m**2\n norm = np.sum(m, axis=0)\n norm = [math.sqrt(norm[i]) for i in range(len(norm))]\n\n \"\"\"Realizando a ponderação TF-IDF na query\"\"\"\n print(\"Realizando ponderação TF-IDF na query no Modelo Vetorial...\\n\")\n\n i = 0\n queryVector = np.zeros(len(uniqueWords))\n \n for word in uniqueWords:\n if word in query:\n idf = math.log2(numDocs/ linkedListData[word].n_docs)\n queryVector[i] = (1 + math.log2(query.count(word))) * idf\n i += 1\n\n \"\"\"Ranqueamento\"\"\"\n print(\"Realizando Ranqueamento no Modelo Vetorial...\\n\")\n \n ranking = {}\n \n for docName in docsNames:\n ranking[docName] = np.dot(m[:,docsIds[docName]], queryVector) / norm[docsIds[docName]]\n \n sorted_ranking = {k: v for k, v in sorted(ranking.items(), key = lambda item: item[1], reverse=True)}\n\n del m\n gc.collect()\n\n print(\"\\nFim do Modelo Vetorial...\\n\\n\")\n\n return sorted_ranking\n\ndef query_expansion(numDocs, wordsInDocument, docsIds, uniqueWords, linkedListData, query, wordsIds):\n \"\"\"\n Expansão de consultas\n\n \"\"\"\n \n \"\"\"Frequência inversa de termo (itf)\"\"\"\n print(\"Realizando Frequência inversa de termo (itf) na Expansao\\n\")\n\n # Frequencia inversa de termo (itf) pra cada documento j\n # Calculo dele é dado por:\n # numerador = nro de termos distintos em tds os docs\n # denominador = nro de termos distintos no doc j\n # itf(doc j) = numerador / denominador\n itf = [0] * numDocs\n\n for doc in wordsInDocument.keys():\n uniqueWordsInDoc = set(wordsInDocument[doc])\n if(len(uniqueWordsInDoc) == 0): \n continue\n docId = docsIds[doc]\n itf[docId] = math.log2(len(uniqueWords) / len(uniqueWordsInDoc))\n\n \"\"\"Pesagem dos documentos\"\"\"\n print(\"Realizando Pesagem dos documentos na Expansao\\n\")\n\n w = np.zeros((len(uniqueWords), numDocs))\n \n for word in uniqueWords:\n maxFreq = getMaxFreq(word, linkedListData)\n norm = computeNorm(word, maxFreq, linkedListData, wordsInDocument, itf, docsIds)\n \n for docs in linkedListData[word].get_doclist():\n fileName = docs[0]\n freq = docs[1]\n a = (0.5 + 0.5 * (freq / maxFreq))\n b = itf[docsIds[fileName]]\n w[wordsIds[word]][docsIds[fileName]] = (a * b) / norm\n\n \"\"\"Similaridade\"\"\"\n print(\"Calculando similaridade na Expansao\\n\")\n\n # Similaridade\n c = np.dot(w, w.transpose())\n\n del w\n gc.collect()\n\n \"\"\"Pesagem da consulta\"\"\"\n print(\"Realizando Pesagem da consulta na Expansao\\n\")\n\n # Pesagem da consulta\n q = [0] * len(query)\n \n uniqueWordsInQuery = set(query)\n \n i = 0\n wordsInQueryIds = {}\n for word in query:\n wordsInQueryIds[word] = i\n i = i + 1\n \n sum = 0\n for i in range(len(itf)):\n sum = sum + math.pow(itf[i], 2)\n norm = math.sqrt(sum)\n \n for word in query:\n q[wordsInQueryIds[word]] = math.log2(len(uniqueWords)/ len(uniqueWordsInQuery)) / norm\n\n \"\"\"Combinação da similaridade com pesagem da consulta\"\"\"\n print(\"Combinando similaridade com pesagem da consulta na Expansao\\n\")\n\n result = {}\n \n # Combinação da similaridade com a pesagem da consulta\n for word in uniqueWords:\n similaridade = 0\n result[word] = similaridade\n for item in query:\n a = q[wordsInQueryIds[item]]\n if item not in uniqueWords:\n b = 0\n else:\n b = c[wordsIds[item]][wordsIds[word]]\n similaridade = similaridade + a * b\n result[word] = similaridade\n\n \"\"\"Resultado da expansão\"\"\"\n\n sorted_result = {k: v for k, v in sorted(result.items(), key = lambda item: item[1], reverse=True)}\n\n keys = list(sorted_result.keys())\n\n print(\"Query expandida: \", keys[:4])\n\n print(\"\\nFim da Expansao...\\n\\n\")\n\n return sorted_result\n\ndef getRelDocs(path):\n rel_docs = defaultdict()\n\n with open(path) as file:\n for line in file:\n token = wordTokenize(line)\n if token[3] == '1':\n if int(token[0]) in rel_docs.keys():\n rel_docs[int(token[0])].append(token[2])\n else:\n rel_docs[int(token[0])] = [token[2]]\n\n return rel_docs\n\ndef evaluation(queryId, rel_docs, answer):\n \"\"\"\n Avaliação\n \n A avaliação serve para julgar o quão bem o sistema atende à necessidade de \n informação do usuário. Estamos considerando precisão e revocação. \n \"\"\"\n\n intersec = 0\n\n for rel_doc in answer.keys():\n if rel_doc in rel_docs[int(queryId)]:\n intersec += 1\n\n precisao = intersec/len(rel_docs[int(queryId)])\n revocacao = intersec/len(answer)\n\n return precisao, revocacao\n\ndef main():\n\n docsPath = 'a/*'\n topicsPath = 'en.topics.76-125.2010.txt'\n queriesPath = 'en.qrels.76-125.2010.txt'\n\n\n numDocs, docsIds, docsNames, wordsInDocument = readDocs(docsPath)\n\n # Remoção de stopwords, radicalização e indexação\n\n dict = defaultdict(int)\n\n for key, value in wordsInDocument.items():\n wordsInDocument[key] = filterText(True, True, value)\n\n for key, value in wordsInDocument.items():\n for w in set(value): \n dict[w] += 1\n\n i = 0\n wordsIds = {}\n linkedListData = {}\n uniqueWords = sorted(set(dict.keys()))\n \n # atribuindo um id pra cada palavra\n for word in uniqueWords:\n wordsIds[word] = i\n linkedListData[word] = LinkedList()\n i = i + 1\n \n print(\"\\nFound %d unique words\" % len(uniqueWords))\n\n for doc in wordsInDocument.keys():\n words = wordsInDocument[doc]\n for word in set(words):\n linkedListData[word].add_doc(doc, words.count(word))\n\n queries = readQueriesDoc(topicsPath)\n\n # Define qual query iremos trabalhar em cima\n queryId = '76'\n query = queries[queryId]\n\n initial_sel_answer, final_rank_answer = prob_model(wordsInDocument, query, linkedListData, numDocs, uniqueWords)\n\n ranked_vect_answer = vect_model(wordsIds, uniqueWords, numDocs, linkedListData, query, docsNames, docsIds)\n\n expansion_answer = query_expansion(numDocs, wordsInDocument, docsIds, uniqueWords, linkedListData, query, wordsIds)\n\n rel_docs = getRelDocs(queriesPath)\n \n precisao = defaultdict()\n revocacao = defaultdict()\n\n precisao[queryId], revocacao[queryId] = evaluation(queryId, rel_docs, initial_sel_answer)\n\n print(\"precisao \", precisao[queryId], \"\\nrevocacao \", revocacao[queryId])\n\nmain()", "meta": {"hexsha": "d22b271e99353432ed7fb9570f630f69950b618f", "size": 15966, "ext": "py", "lang": "Python", "max_stars_repo_path": "Information Retrieval/project.py", "max_stars_repo_name": "henriquesqs/Codes", "max_stars_repo_head_hexsha": "59e5bb683f3de2ee1b13621569954be1e4f37396", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Information Retrieval/project.py", "max_issues_repo_name": "henriquesqs/Codes", "max_issues_repo_head_hexsha": "59e5bb683f3de2ee1b13621569954be1e4f37396", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-09-21T03:26:14.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-21T03:26:14.000Z", "max_forks_repo_path": "Information Retrieval/project.py", "max_forks_repo_name": "henriquesqs/Codes", "max_forks_repo_head_hexsha": "59e5bb683f3de2ee1b13621569954be1e4f37396", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-03-31T01:49:23.000Z", "max_forks_repo_forks_event_max_datetime": "2020-03-31T01:49:23.000Z", "avg_line_length": 30.8223938224, "max_line_length": 316, "alphanum_fraction": 0.6118627083, "include": true, "reason": "import numpy", "num_tokens": 4041, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583269943353745, "lm_q2_score": 0.3522017684487511, "lm_q1q2_score": 0.19664375477759474}} {"text": "\"\"\" Implementation of the Constrained Policy Optimization (CPO) algorithm.\n\n see:\n Joshua Achiam, David Held, Aviv Tamar, Peter Abbeel\n Constrained Policy Optimization\n ICML 2017\n\nAuthor: Sven Gronauer (sven.gronauer@tum.de)\nCreated: 12.10.2020\nUpdated: 27.10.2020\n\"\"\"\n\nimport numpy as np\nimport torch\nfrom rl_safety_algorithms.common import utils\nfrom rl_safety_algorithms.algs.trpo.trpo import TRPOAlgorithm\nfrom rl_safety_algorithms.algs.npg.npg import NaturalPolicyGradientAlgorithm\nimport rl_safety_algorithms.algs.utils as U\nimport rl_safety_algorithms.common.mpi_tools as mpi_tools\n\n\nclass CPOAlgorithm(TRPOAlgorithm):\n \"\"\"Constrained Policy Optimization Algorithm.\n\n This implementation does not use cost shaping, but relies on exploration\n noise annealing.\n Large parts are inspired and taken from:\n https://github.com/openai/safety-starter-agents/blob/master/safe_rl/pg/agents.py#L209\n (MIT License)\n \"\"\"\n def __init__(\n self,\n alg: str = 'cpo',\n cost_limit: float = 25.,\n **kwargs\n ):\n super().__init__(\n alg=alg,\n cost_limit=cost_limit,\n use_cost_value_function=True,\n **kwargs\n )\n self.cost_limit = cost_limit\n self.loss_pi_cost_before = 0.\n\n def adjust_cpo_step_direction(\n self,\n step_dir,\n g_flat,\n c,\n optim_case,\n p_dist,\n data,\n total_steps: int = 25,\n decay: float = 0.8\n ):\n \"\"\"CPO algorithm performs line-search to ensure constraint satisfaction\n for rewards and costs.\"\"\"\n step_frac = 1.0\n _theta_old = U.get_flat_params_from(self.ac.pi.net)\n _, old_log_p = self.ac.pi(data['obs'], data['act'])\n expected_rew_improve = g_flat.dot(step_dir)\n\n # while not within_trust_region:\n for j in range(total_steps):\n new_theta = _theta_old + step_frac * step_dir\n U.set_param_values_to_model(self.ac.pi.net, new_theta)\n acceptance_step = j + 1\n\n with torch.no_grad():\n loss_pi_rew, _ = self.compute_loss_pi(data=data)\n loss_pi_cost, _ = self.compute_loss_cost_performance(data=data)\n # determine KL div between new and old policy\n q_dist = self.ac.pi.dist(data['obs'])\n torch_kl = torch.distributions.kl.kl_divergence(\n p_dist, q_dist).mean().item()\n loss_rew_improve = self.loss_pi_before - loss_pi_rew.item()\n cost_diff = loss_pi_cost.item() - self.loss_pi_cost_before\n\n # Average across MPI processes...\n torch_kl = mpi_tools.mpi_avg(torch_kl)\n loss_rew_improve = mpi_tools.mpi_avg(loss_rew_improve)\n cost_diff = mpi_tools.mpi_avg(cost_diff)\n\n self.logger.log(\"Expected Improvement: %.3f Actual: %.3f\" % (\n expected_rew_improve, loss_rew_improve))\n\n if not torch.isfinite(loss_pi_rew) and not torch.isfinite(\n loss_pi_cost):\n self.logger.log('WARNING: loss_pi not finite')\n elif loss_rew_improve < 0 if optim_case > 1 else False:\n self.logger.log('INFO: did not improve improve <0')\n\n elif cost_diff > max(-c, 0):\n self.logger.log(f'INFO: no improve {cost_diff} > {max(-c, 0)}')\n elif torch_kl > self.target_kl * 1.5:\n self.logger.log(\n f'INFO: violated KL constraint {torch_kl} at step {j + 1}.')\n else:\n # step only if surrogate is improved and we are\n # within the trust region\n self.logger.log(f'Accept step at i={j + 1}')\n break\n step_frac *= decay\n else:\n self.logger.log('INFO: no suitable step found...')\n step_dir = torch.zeros_like(step_dir)\n acceptance_step = 0\n\n U.set_param_values_to_model(self.ac.pi.net, _theta_old)\n return step_frac * step_dir, acceptance_step\n\n def algorithm_specific_logs(self):\n NaturalPolicyGradientAlgorithm.algorithm_specific_logs(self)\n self.logger.log_tabular('Misc/cost_gradient_norm')\n self.logger.log_tabular('Misc/A')\n self.logger.log_tabular('Misc/B')\n self.logger.log_tabular('Misc/q')\n self.logger.log_tabular('Misc/r')\n self.logger.log_tabular('Misc/s')\n self.logger.log_tabular('Misc/Lambda_star')\n self.logger.log_tabular('Misc/Nu_star')\n self.logger.log_tabular('Misc/OptimCase')\n\n def compute_loss_cost_performance(self, data):\n dist, _log_p = self.ac.pi(data['obs'], data['act'])\n ratio = torch.exp(_log_p - data['log_p'])\n cost_loss = (ratio * data['cost_adv']).mean()\n # ent = dist.entropy().mean().item()\n info = {}\n return cost_loss, info\n\n def update_policy_net(self, data):\n # Get loss and info values before update\n theta_old = U.get_flat_params_from(self.ac.pi.net)\n self.pi_optimizer.zero_grad()\n loss_pi, pi_info = self.compute_loss_pi(data=data)\n self.loss_pi_before = loss_pi.item()\n self.loss_v_before = self.compute_loss_v(data['obs'],\n data['target_v']).item()\n self.loss_c_before = self.compute_loss_c(data['obs'],\n data['target_c']).item()\n # get prob. distribution before updates\n p_dist = self.ac.pi.dist(data['obs'])\n # Train policy with multiple steps of gradient descent\n loss_pi.backward()\n # average grads across MPI processes\n mpi_tools.mpi_avg_grads(self.ac.pi.net)\n g_flat = U.get_flat_gradients_from(self.ac.pi.net)\n\n # flip sign since policy_loss = -(ration * adv)\n g_flat *= -1\n\n x = U.conjugate_gradients(self.Fvp, g_flat, self.cg_iters)\n assert torch.isfinite(x).all()\n eps = 1.0e-8\n # Note that xHx = g^T x, but calculating xHx is faster than g^T x\n xHx = torch.dot(x, self.Fvp(x)) # equivalent to : g^T x\n alpha = torch.sqrt(2 * self.target_kl / (xHx + eps))\n assert xHx.item() >= 0, 'No negative values'\n\n # get the policy cost performance gradient b (flat as vector)\n self.pi_optimizer.zero_grad()\n loss_cost, _ = self.compute_loss_cost_performance(data=data)\n loss_cost.backward()\n # average grads across MPI processes\n mpi_tools.mpi_avg_grads(self.ac.pi.net)\n self.loss_pi_cost_before = loss_cost.item()\n b_flat = U.get_flat_gradients_from(self.ac.pi.net)\n\n ep_costs = self.logger.get_stats('EpCosts')[0]\n c = ep_costs - self.cost_limit\n c /= (self.logger.get_stats('EpLen')[0] + eps) # rescale\n self.logger.log(f'c = {c}')\n self.logger.log(f'b^T b = {b_flat.dot(b_flat).item()}')\n\n # set variable names as used in the paper\n p = U.conjugate_gradients(self.Fvp, b_flat, self.cg_iters)\n q = xHx\n r = g_flat.dot(p) # g^T H^{-1} b\n s = b_flat.dot(p) # b^T H^{-1} b\n\n # print('b^T g', g_flat.dot(b_flat))\n\n if b_flat.dot(b_flat) <= 1e-6 and c < 0:\n # feasible step and cost grad is zero: use plain TRPO update...\n A = torch.zeros(1)\n B = torch.zeros(1)\n optim_case = 4\n else:\n\n self.logger.log(f'q={q.item()}')\n self.logger.log(f'r={r.item()}')\n self.logger.log(f's={s.item()}')\n self.logger.log(f'r/c={(r / c).item()}')\n assert torch.isfinite(r).all()\n assert torch.isfinite(s).all()\n\n A = q - r ** 2 / s # must be always >= 0 (Cauchy-Schwarz inequality)\n B = 2 * self.target_kl - c ** 2 / s # safety line intersects trust-region if B > 0\n\n if c < 0 and B < 0:\n # point in trust region is feasible and safety boundary doesn't intersect\n # ==> entire trust region is feasible\n optim_case = 3\n elif c < 0 and B >= 0:\n # x = 0 is feasible and safety boundary intersects\n # ==> most of trust region is feasible\n optim_case = 2\n elif c >= 0 and B >= 0:\n # x = 0 is infeasible and safety boundary intersects\n # ==> part of trust region is feasible, recovery possible\n optim_case = 1\n self.logger.log('Alert! Attempting feasible recovery!',\n 'yellow')\n else:\n # x = 0 infeasible, and safety halfspace is outside trust region\n # ==> whole trust region is infeasible, try to fail gracefully\n optim_case = 0\n self.logger.log('Alert! Attempting infeasible recovery!', 'red')\n\n if optim_case in [3, 4]:\n alpha = torch.sqrt(2 * self.target_kl / (xHx + 1e-8))\n nu_star = torch.zeros(1)\n lambda_star = 1 / alpha\n step_dir = alpha * x\n\n elif optim_case in [1, 2]:\n def project_on_set(t: torch.Tensor,\n low: float,\n high: float\n ) -> torch.Tensor:\n return torch.Tensor([max(low, min(t, high))])\n\n lambda_a = torch.sqrt(A / B)\n lambda_b = torch.sqrt(q / (2 * self.target_kl))\n if c < 0:\n lambda_a_star = project_on_set(lambda_a, 0., r / c)\n lambda_b_star = project_on_set(lambda_b, r / c, np.inf)\n else:\n lambda_a_star = project_on_set(lambda_a, r / c, np.inf)\n lambda_b_star = project_on_set(lambda_b, 0., r / c)\n\n def f_a(lam):\n return -0.5 * (A / (lam + eps) + B * lam) - r * c / (s + eps)\n\n def f_b(lam):\n return -0.5 * (q / (lam + eps) + 2 * self.target_kl * lam)\n\n lambda_star = lambda_a_star \\\n if f_a(lambda_a_star) >= f_b(lambda_b_star) else lambda_b_star\n\n # Discard all negative values with torch.clamp(x, min=0)\n nu_star = torch.clamp(lambda_star * c - r, min=0) / (s + eps)\n step_dir = 1. / (lambda_star + eps) * (x - nu_star * p)\n\n else: # case == 0\n # purely decrease costs\n lambda_star = torch.zeros(1)\n nu_star = np.sqrt(2 * self.target_kl / (s + eps))\n step_dir = -nu_star * p\n\n final_step_dir, accept_step = self.adjust_cpo_step_direction(\n step_dir,\n g_flat,\n c=c,\n optim_case=optim_case,\n p_dist=p_dist,\n data=data,\n total_steps=20\n )\n # update actor network parameters\n new_theta = theta_old + final_step_dir\n U.set_param_values_to_model(self.ac.pi.net, new_theta)\n\n q_dist = self.ac.pi.dist(data['obs'])\n torch_kl = torch.distributions.kl.kl_divergence(\n p_dist, q_dist).mean().item()\n\n self.logger.store(**{\n 'Values/Adv': data['act'].numpy(),\n 'Entropy': pi_info['ent'],\n 'KL': torch_kl,\n 'PolicyRatio': pi_info['ratio'],\n 'Loss/Pi': self.loss_pi_before,\n 'Loss/DeltaPi': loss_pi.item() - self.loss_pi_before,\n 'Misc/StopIter': 1,\n 'Misc/AcceptanceStep': accept_step,\n 'Misc/Alpha': alpha.item(),\n 'Misc/FinalStepNorm': final_step_dir.norm().numpy(),\n 'Misc/xHx': xHx.numpy(),\n 'Misc/H_inv_g': x.norm().item(), # H^-1 g\n 'Misc/gradient_norm': torch.norm(g_flat).numpy(),\n 'Misc/cost_gradient_norm': torch.norm(b_flat).numpy(),\n 'Misc/Lambda_star': lambda_star.item(),\n 'Misc/Nu_star': nu_star.item(),\n 'Misc/OptimCase': int(optim_case),\n 'Misc/A': A.item(),\n 'Misc/B': B.item(),\n 'Misc/q': q.item(),\n 'Misc/r': r.item(),\n 'Misc/s': s.item(),\n })\n\n\ndef get_alg(env_id, **kwargs) -> CPOAlgorithm:\n defaults = utils.get_defaults_kwargs(alg='cpo', env_id=env_id)\n defaults.update(**kwargs)\n return CPOAlgorithm(\n env_id=env_id,\n **defaults\n )\n\n\ndef learn(\n env_id,\n **kwargs\n) -> tuple:\n defaults = utils.get_defaults_kwargs(alg='cpo', env_id=env_id)\n defaults.update(**kwargs)\n alg = CPOAlgorithm(\n env_id=env_id,\n **defaults\n )\n ac, env = alg.learn()\n return ac, env\n", "meta": {"hexsha": "fa830007fa1784e0a4383923c61cef7a8491acc7", "size": 12665, "ext": "py", "lang": "Python", "max_stars_repo_path": "rl_safety_algorithms/algs/cpo/cpo.py", "max_stars_repo_name": "liuzuxin/RL-Safety-Algorithms", "max_stars_repo_head_hexsha": "2575225b1ea8ce12e1e13f7a81f8dda7b4189708", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2021-09-05T17:49:02.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-22T03:13:39.000Z", "max_issues_repo_path": "rl_safety_algorithms/algs/cpo/cpo.py", "max_issues_repo_name": "liuzuxin/RL-Safety-Algorithms", "max_issues_repo_head_hexsha": "2575225b1ea8ce12e1e13f7a81f8dda7b4189708", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "rl_safety_algorithms/algs/cpo/cpo.py", "max_forks_repo_name": "liuzuxin/RL-Safety-Algorithms", "max_forks_repo_head_hexsha": "2575225b1ea8ce12e1e13f7a81f8dda7b4189708", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-09-05T17:49:07.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-30T17:36:30.000Z", "avg_line_length": 38.7308868502, "max_line_length": 95, "alphanum_fraction": 0.5627319384, "include": true, "reason": "import numpy", "num_tokens": 3081, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.626124191181315, "lm_q2_score": 0.31405055141190724, "lm_q1q2_score": 0.19663464749282641}} {"text": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nRun future simulations based on IUCN data and status transition rates\n\nCreated on Wed Oct 30 20:59:28 2019\n@author: Tobias Andermann (tobias.andermann@bioenv.gu.se)\n\"\"\"\n\nimport numpy as np\nnp.set_printoptions(suppress=True)\nimport pandas as pd\nimport matplotlib.pyplot as plt\nfrom matplotlib.backends.backend_pdf import PdfPages\nimport os\nimport sys\nimport iucn_sim.functions as cust_func\n\n\ndef add_arguments(parser):\n parser.add_argument(\n '--input_data',\n required=True,\n help=\"Path to 'simulation_input_data.pkl' file created by esimate_rates function.\"\n )\n parser.add_argument(\n '--outdir',\n required=True,\n help=\"Provide path to outdir where results will be saved.\"\n )\n parser.add_argument(\n '--n_years',\n default=100,\n help=\"How many years to simulate into the future.\"\n )\n parser.add_argument(\n '--n_sim',\n default=10000,\n help=\"How many simulation replicates to run. At least 10,000 simulations are recommended for accurate rate estimation (default). If the number of simulation replicates exceeds the number of available transition rate estimates (produced by the 'transition_rates' function), these rates will be randomely resampled for the remaining simulations.\"\n )\n parser.add_argument(\n '--status_change',\n default=1,\n help=\"Model IUCN status changes in future simulations. 0=off, 1=on (default=1).\"\n )\n parser.add_argument(\n '--conservation_increase_factor',\n default=1,\n help=\"The transition rates leading to improvements in IUCN conservation status are multiplied by this factor.\"\n )\n parser.add_argument(\n '--threat_increase_factor',\n default=1,\n help=\"Opposite of conservation_increase_factor, multiplies the transition rates leading to worsening in IUCN conservation status.\"\n )\n parser.add_argument(\n '--model_unknown_as_lc',\n default=0,\n help=\"Model new status for all DD and NE species as LC (best case scenario). 0=off, 1=on (default=0).\"\n )\n parser.add_argument(\n '--n_extinct_taxa',\n default=0,\n help=\"Setting this value will stop the simulations when n taxa have gone extinct. This can be used to simulate the expected time until n extinctions. The value of the --n_years flag in this case will be interpreted as the maximum possible time frame, so set it large enough to cover a realistic time-frame for these extinctions to occur. Set to 0 to disable this function (default=0).\"\n )\n parser.add_argument(\n '--extinction_rates',\n default=1,\n help=\"Estimation of extinction rates from simulation results: 0=off, 1=on (default=1).\"\n )\n parser.add_argument(\n '--n_gen',\n default=100000,\n help=\"Number of generations for MCMC for extinction rate estimation (default=100000).\"\n )\n parser.add_argument(\n '--burnin',\n default=1000,\n help=\"Burn-in for MCMC for extinction rate estimation (default=1000).\"\n )\n parser.add_argument(\n '--plot_diversity_trajectory',\n default=1,\n help=\"Plots the simulated diversity trajectory: 0=off, 1=on (default=1).\"\n )\n parser.add_argument(\n '--plot_status_trajectories',\n default=1,\n help=\"Plots the simulated IUCN status trajectory: 0=off, 1=on (default=0).\"\n )\n parser.add_argument(\n '--plot_histograms',\n default=0,\n help=\"Plots histograms of simulated extinction times for each species: 0=off, 1=on (default=0).\"\n )\n parser.add_argument(\n '--plot_posterior',\n default=0,\n help=\"Plots histograms of posterior rate estimates for each species: 0=off, 1=on (default=0).\"\n )\n parser.add_argument(\n '--plot_status_piechart',\n default=1,\n help=\"Plots pie charts of status distribution: 0=off, 1=on (default=1).\"\n )\n parser.add_argument(\n '--seed',\n default=None,\n help=\"Set random seed for future simulations.\"\n )\n\n\ndef p_e_year(years,p_e):\n pe_year = 1-(1-p_e)**(1/years)\n return pe_year\n\ndef update_multiplier(q,d=1.1):\n u = np.random.uniform(0,1)\n l = 2*np.log(d)\n m = np.exp(l*(u-.5))\n new_q = q * m\n return new_q, np.log(m)\n\ndef get_rate_estimate(ext_time_array,max_t,index,species_list,plot_posterior=0,pdf=0,n_gen = 100000,burnin = 1000):\n sys.stdout.write('\\rProcessing species: %i/%i '%(index+1,len(species_list)))\n ext_time_array_new = ext_time_array.copy()\n ext_time_array_new[ext_time_array_new!=ext_time_array_new] = max_t\n ext_time_array_new = ext_time_array_new.astype(float)\n w_times = np.sum(ext_time_array_new)\n ext_events = len(ext_time_array_new[ext_time_array_new= np.log(np.random.random()):\n q = new_q\n likA = lik\n if i > burnin and i % 10==0:\n post_samples.append(q)\n mean_value = np.mean(post_samples)\n lower,upper = cust_func.calcHPD(post_samples,0.95)\n if plot_posterior:\n plt.figure()\n plt.hist(post_samples,100)\n plt.xlabel('Extinction rate estimates')\n plt.ylabel('Counts')\n plt.title(species_list[index])\n plt.tight_layout()\n pdf.savefig()\n plt.close()\n #fig.savefig(os.path.join(posterior_plot_dir,'%s.pdf'%species_list[index]),bbox_inches='tight', dpi = 500)\n return [mean_value,lower,upper]\n\ndef select_target_species(species,species_list_status,species_list,en_ext_data,cr_ext_data):\n target_species = species\n target_index = species_list_status[species_list_status.species==target_species].index.values[0]\n species_list_status = species_list_status.iloc[target_index,:]\n species_list = np.array([species_list[target_index]])\n en_ext_data = np.array([en_ext_data[target_index]])\n cr_ext_data = np.array([cr_ext_data[target_index]])\n return pd.DataFrame(species_list_status).T,species_list,en_ext_data,cr_ext_data\n\ndef get_rate_estimate_posterior(ext_time_array,max_t,index,species_list,n_gen = 100000,burnin = 1000):\n sys.stdout.write('\\rProcessing species: %i/%i '%(index+1,len(species_list)))\n ext_time_array_new = ext_time_array.copy()\n ext_time_array_new[ext_time_array_new!=ext_time_array_new] = max_t\n ext_time_array_new = ext_time_array_new.astype(float)\n w_times = np.sum(ext_time_array_new)\n ext_events = len(ext_time_array_new[ext_time_array_new= np.log(np.random.random()):\n q = new_q\n likA = lik\n if i > burnin and i % 10==0:\n post_samples.append(q)\n return post_samples\n\n## test rate estimator\n#true_rate = 0.01\n#n_sim = 100\n#ext_time_array = (np.random.exponential(1./true_rate, n_sim)).astype(int)\n#max_t=100\n#ext_time_array[ext_time_array>max_t] = max_t\n#get_rate_estimate(ext_time_array,max_t)\n\ndef main(args):\n \n # get user input___________________________________________________________\n seed = args.seed\n try:\n random_seed = int(seed)\n print('Simulating with user-set starting seed %i.'%random_seed)\n\n except:\n random_seed = np.random.randint(999999999)\n print('Simulating with randomely generated starting seed %i.'%random_seed)\n np.random.seed(random_seed)\n \n infile = args.input_data\n outdir = args.outdir\n n_years = int(args.n_years)\n n_sim = int(args.n_sim)\n n_extinct_taxa = int(args.n_extinct_taxa)\n allow_status_change = int(args.status_change)\n conservation_increase_factor = int(args.conservation_increase_factor)\n threat_increase_factor = int(args.threat_increase_factor)\n extinction_rates = int(args.extinction_rates)\n n_gen = int(args.n_gen)\n burnin = int(args.burnin)\n plot_diversity_trajectory = int(args.plot_diversity_trajectory)\n plot_histograms = int(args.plot_histograms)\n plot_posterior = int(args.plot_posterior)\n model_unknown_as_lc = int(args.model_unknown_as_lc)\n plot_status_trajectories = int(args.plot_status_trajectories)\n plot_status_piechart = int(args.plot_status_piechart)\n if not os.path.exists(outdir):\n os.makedirs(outdir)\n np.savetxt(os.path.join(outdir,'starting_seed.txt'),np.array([random_seed]),fmt='%i')\n \n input_data = cust_func.load_obj(infile)\n species_input_data, dd_probs = input_data\n species_list = np.array([i[0] for i in species_input_data])\n current_status_list = np.array([i[1] for i in species_input_data])\n q_matrix_list = [i[2] for i in species_input_data]\n n_rates = dd_probs.shape[1]\n #__________________________________________________________________________ \n\n\n\n\n # modify q-matrices, if set by user________________________________________\n final_qmatrix_list = []\n q_matrix_list_copy = np.array(q_matrix_list).copy()\n for q_matrix_list_i in q_matrix_list_copy:\n q_matrix_list_temp = []\n for q_matrix in q_matrix_list_i:\n if conservation_increase_factor != 1:\n indeces_lower_triangle = np.tril_indices(q_matrix.shape[0],-1)\n q_matrix[indeces_lower_triangle] = q_matrix[indeces_lower_triangle] * conservation_increase_factor\n np.fill_diagonal(q_matrix,0)\n np.fill_diagonal(q_matrix, -np.sum(q_matrix,axis=1))\n if threat_increase_factor != 1:\n indeces_upper_triangle = np.triu_indices(q_matrix.shape[0],1)\n q_matrix[indeces_upper_triangle] = q_matrix[indeces_upper_triangle] * threat_increase_factor\n np.fill_diagonal(q_matrix,0)\n np.fill_diagonal(q_matrix, -np.sum(q_matrix,axis=1)) \n q_matrix_list_temp.append(q_matrix)\n final_qmatrix_list.append(q_matrix_list_temp)\n # turn into a dict with the n qmatrices for each species\n final_qmatrix_dict = dict(zip(species_list,final_qmatrix_list)) \n #__________________________________________________________________________ \n \n\n\n\n # if more n_rep are set than there are q-matrices, resample________________\n if n_sim <= n_rates:\n sample_columns = np.random.choice(np.arange(n_rates),size=n_sim,replace=False)\n # since there are only as many cr and en p(ex) estimates as there are provided GL values, we may have to resample some (but make sure all are present at least once)\n else:\n sample_columns1 = np.random.choice(np.arange(n_rates),size=n_rates,replace=False)\n sample_columns2 = np.random.choice(np.arange(n_rates),size=(n_sim-n_rates),replace=True)\n sample_columns = np.concatenate([sample_columns1,sample_columns2]) \n #__________________________________________________________________________ \n\n\n\n\n # run simulations__________________________________________________________\n delta_t = n_years\n model_ne_as_dd = False\n dynamic_qmatrix = True\n\n if model_ne_as_dd:\n current_status_list[current_status_list=='NE'] = 'DD' \n if model_unknown_as_lc:\n print('\\nSetting all DD and NE species to LC.')\n all_lc=True\n else:\n all_lc=False\n if allow_status_change:\n status_change=True\n else:\n print('\\nNot simulating future status changes!')\n status_change=False\n\n print('\\nStarting simulations ...')\n diversity_through_time,te_array,status_through_time,time_until_n_extinctions_list = cust_func.run_multi_sim(n_sim,delta_t,species_list,current_status_list,dd_probs,final_qmatrix_dict,sample_columns,outdir,all_lc=all_lc,status_change=status_change,dynamic_qmatrix=dynamic_qmatrix,n_extinct_taxa=n_extinct_taxa)\n # summarize simulation results\n sim_species_list = te_array[:,0].copy()\n ext_date_data = te_array[:,1:].copy()\n extinction_occs = np.array([len(row[~np.isnan(list(row))]) for row in ext_date_data])\n extinction_prob = extinction_occs/ext_date_data.shape[1]\n # produce output file for status distribution through time\n mean_status_through_time = np.mean(status_through_time,axis=2)\n year = np.arange(delta_t+1).astype(int)\n status_df_data = np.round(np.vstack([year,mean_status_through_time])).astype(int)\n status_df = pd.DataFrame(data = status_df_data.T,columns=['year','LC','NT','VU','EN','CR','EX'])\n status_df.to_csv(os.path.join(outdir,'status_distribution_through_time.txt'),sep='\\t',index=False)\n np.savetxt(os.path.join(outdir,'simulated_extinctions_array.txt'),status_through_time[-1],fmt='%i')\n pd.DataFrame(data=te_array).to_csv(os.path.join(outdir,'te_all_species.txt'),sep='\\t',header=False,index=False)\n #__________________________________________________________________________ \n\n\n\n\n #__________________________________________________________________________ \n# if target_species:\n# posterior = get_rate_estimate_posterior(ext_date_data[0],n_years,0,sim_species_list,n_gen=n_gen,burnin=burnin)\n# np.savetxt('/Users/tobias/GitHub/iucn_predictions/doc/figures/Figure_2/figure_data/posterior_samples/%s_gl_no_status_change.txt'%target_species.replace(' ','_'),posterior,fmt='%.8f')\n# print('\\nPrinted posterior')\n #__________________________________________________________________________ \n \n if n_extinct_taxa: \n np.savetxt(os.path.join(outdir,'time_until_%i_extinctions.txt'%n_extinct_taxa),time_until_n_extinctions_list,fmt='%.2f')\n fig = plt.figure()\n plt.hist(time_until_n_extinctions_list)\n plt.xlabel('Time in years')\n plt.ylabel('N')\n plt.title('Simulated years until %i extinctions (%i simulations)'%(n_extinct_taxa,n_sim))\n fig.savefig(os.path.join(outdir,'time_until_%i_extinctions.pdf'%n_extinct_taxa),bbox_inches='tight', dpi = 500)\n\n #__________________________________________________________________________ \n if plot_diversity_trajectory:\n # plot diversity trajectory of species list________________________________\n #colors = [\"#9a002e\",\"#df4a3d\",\"#fecd5f\",\"#5cd368\",\"#916200\"]\n # define time axis\n time_axis = np.array(range(len(diversity_through_time[0])))\n fig = plt.figure()\n y_values = np.mean(diversity_through_time, axis =0)\n plt.plot(time_axis,y_values,color=\"#b80033\", label='accounting for GL')\n # get upper and lower confidence interval boundaries\n min_hpd, max_hpd = np.array([cust_func.calcHPD(i,0.95) for i in diversity_through_time.T]).T\n mean_min_max = np.vstack([y_values,min_hpd,max_hpd])\n np.savetxt(os.path.join(outdir,'future_diversity_trajectory.txt'),mean_min_max,fmt='%.2f')\n plt.fill_between(time_axis, min_hpd, max_hpd,\n color=\"#b80033\", alpha=0.2)\n #plt.legend()\n plt.ylabel('Total diversity')\n plt.xlabel('Years from present')\n ax = plt.gca()\n ax1 = ax.twinx()\n # Set the limits of the new axis from the original axis limits\n ax1.set_ylim(ax.get_ylim())\n current_diversity = diversity_through_time[0,0]\n plt.yticks([np.mean(diversity_through_time[:,-1])],[int(current_diversity-np.mean(diversity_through_time[:,-1]))])\n #plt.xticks(modified_q_matrix.year[::10],modified_q_matrix.year[::10])\n plt.ylabel('Lost species')\n plt.tight_layout()\n fig.savefig(os.path.join(outdir,'future_diversity_trajectory.pdf'),bbox_inches='tight', dpi = 500)\n #__________________________________________________________________________ \n\n\n\n\n #__________________________________________________________________________ \n if plot_status_trajectories:\n # color palette\n colors = [\"#227a00\",\"#a5c279\",\"#f3d248\",\"#6956cb\",\"#79262a\",\"#e34349\"]\n # define time axis\n time_axis = np.array(range(len(diversity_through_time[0])))\n # plot results\n def plot_mean_and_interval(div,color,label,fig):\n plt.plot(time_axis,np.mean(div,axis=0),color=color,label=label);\n min_hpd, max_hpd = np.array([cust_func.calcHPD(i,0.95) for i in div.T]).T\n plt.fill_between(time_axis, min_hpd, max_hpd, color=color, alpha=0.2);\n return fig\n fig = plt.figure(figsize=(10,10))\n plot_mean_and_interval(status_through_time[0,:,:].T,colors[0],'LC',fig)\n plot_mean_and_interval(status_through_time[1,:,:].T,colors[1],'NT',fig)\n plot_mean_and_interval(status_through_time[2,:,:].T,colors[2],'VU',fig)\n plot_mean_and_interval(status_through_time[3,:,:].T,colors[3],'EN',fig)\n plot_mean_and_interval(status_through_time[4,:,:].T,colors[4],'CR',fig)\n plot_mean_and_interval(status_through_time[5,:,:].T,colors[5],'EX',fig)\n # add title, legend and axis-labels\n plt.legend(loc='best',fancybox=True)\n plt.title('Diversity trajectory IUCN categories - status change') #10x higher conservation\n plt.ylabel('Number species in category')\n plt.xlabel('Years from present')\n ax = plt.gca()\n ax1 = ax.twinx()\n # Set the limits of the new axis from the original axis limits\n ax1.set_ylim(ax.get_ylim())\n # annotate final counts with labels\n right_ticks = [int(np.round(np.mean(status_through_time[i,-1,:]))) for i in range(status_through_time.shape[0])]\n plt.yticks(right_ticks,right_ticks)\n #plt.xticks(modified_q_matrix.year[::10],modified_q_matrix.year[::10])\n plt.tight_layout()\n fig.savefig(os.path.join(outdir,'future_status_trajectory.pdf'),bbox_inches='tight', dpi = 500)\n #__________________________________________________________________________ \n\n\n\n\n #__________________________________________________________________________ \n if plot_status_piechart:\n statuses, counts = np.unique(current_status_list,return_counts=True)\n init_status_dict = dict(zip(statuses, counts))\n init_status_dict['EX'] = 0\n iucn_status_code = {0:'LC', 1:'NT', 2:'VU', 3:'EN', 4:'CR', 5:'EX', 6:'DD'}\n status_count_list = []\n for status_id in np.arange(status_through_time.shape[0]+1):\n status = iucn_status_code[status_id]\n if status in init_status_dict.keys():\n pre_dd_modeling_count = init_status_dict[status]\n else:\n pre_dd_modeling_count = 0\n if not status == 'DD':\n present_status_count = int(np.round(np.mean(status_through_time[status_id][0])))\n final_status_count = int(np.round(np.mean(status_through_time[status_id][-1])))\n else:\n present_status_count = 0\n final_status_count = 0\n status_count_list.append([pre_dd_modeling_count,present_status_count,final_status_count])\n status_count_list = np.array(status_count_list).T\n colors = np.array([\"#227a00\",\"#a5c279\",\"#f3d248\",\"#6956cb\",\"#79262a\",\"#b80033\",'black'])\n labels = np.array(['LC', 'NT', 'VU', 'EN', 'CR', 'EX', 'DD'])\n def func(pct, allvals):\n absolute = int(np.round((pct/100.*np.sum(allvals))))\n return \"{:d}\".format(absolute)\n fig, axs = plt.subplots(1, 3,figsize=(12,10))\n # status distribution beginning\n wedges, texts, autotexts =axs[1].pie(status_count_list[1][status_count_list[1] >0], colors= colors[status_count_list[1] >0], autopct=lambda pct: func(pct, status_count_list[1][status_count_list[1] >0]), shadow=False,textprops=dict(color=\"w\"))\n # status distribution end\n wedges, texts, autotexts =axs[2].pie(status_count_list[2][status_count_list[2] >0], colors= colors[status_count_list[2] >0], autopct=lambda pct: func(pct, status_count_list[2][status_count_list[2] >0]), shadow=False,textprops=dict(color=\"w\"))\n ext = wedges[-1]\n # status distribution pre-dd\n wedges, texts, autotexts =axs[0].pie(status_count_list[0][status_count_list[0] >0], colors= colors[status_count_list[0] >0], autopct=lambda pct: func(pct, status_count_list[0][status_count_list[0] >0]), shadow=False,textprops=dict(color=\"w\"))\n axs[0].set_title('Current (including DD)')\n axs[1].set_title('Current (DD corrected)')\n axs[2].set_title('Final (%i years)'%delta_t)\n final_labels = list(labels[status_count_list[0] >0]) + ['EX']\n plt.legend(wedges+[ext], final_labels,title=\"IUCN status\\n(N=%i sp.)\"%status_count_list[2].sum(),loc=\"center left\",bbox_to_anchor=(1, 0, 0.5, 1))\n fig.savefig(os.path.join(outdir,'status_pie_chart.pdf'),bbox_inches='tight', dpi = 500)\n #__________________________________________________________________________ \n\n\n\n\n #__________________________________________________________________________ \n if extinction_rates:\n # calculate some extinction stats\n # estimate extinction rates scaled by year\n print('\\nRunning %i MCMCs to estimate species-specific extinction rates from simulation output...'%len(species_list))\n #ext_date_data = ext_date_data[:10,:]\n if plot_posterior:\n with PdfPages(os.path.join(outdir,'posterior_ext_rate_histograms.pdf')) as pdf:\n sampled_rates = np.array([get_rate_estimate(species_values,n_years,i,sim_species_list,plot_posterior=plot_posterior,pdf=pdf,n_gen=n_gen,burnin=burnin) for i,species_values in enumerate(ext_date_data)])\n else:\n sampled_rates = np.array([get_rate_estimate(species_values,n_years,i,sim_species_list,plot_posterior=plot_posterior,pdf=0,n_gen=n_gen,burnin=burnin) for i,species_values in enumerate(ext_date_data)])\n # export extinction stats to file\n column_names = ['species','rate_e_mean','rate_e_lower','rate_e_upper','simulated_p_e_in_%i_years'%delta_t]\n extinction_prob_df = pd.DataFrame(np.array([sim_species_list,sampled_rates[:,0],sampled_rates[:,1],sampled_rates[:,2],extinction_prob]).T,columns=column_names)\n else:\n column_names = ['species','simulated_p_e_in_%i_years'%delta_t]\n extinction_prob_df = pd.DataFrame(np.array([sim_species_list,extinction_prob]).T,columns=column_names) \n extinction_prob_df[column_names[1:]] = extinction_prob_df[column_names[1:]].astype(float)\n extinction_prob_df.to_csv(os.path.join(outdir,'extinction_prob_all_species.txt'),sep='\\t',index=False,float_format='%.8f')\n print('\\n')\n #__________________________________________________________________________ \n\n\n\n\n #__________________________________________________________________________ \n if plot_histograms:\n # plot histograms of extinction times\n with PdfPages(os.path.join(outdir,'extinction_time_histograms.pdf')) as pdf:\n for i,species in enumerate(te_array[:,0]):\n sys.stdout.write('\\rPlotting extinction histogram for species %i/%i'%(i+1,len(te_array[:,0])))\n plt.figure()\n species_te_array = te_array[:,1:][i]\n not_na_values = species_te_array[~np.isnan(list(species_te_array))]\n heights, bins = np.histogram(not_na_values,np.arange(0,delta_t+10,10))\n percent = heights/n_sim\n plt.bar(bins[:-1],percent,width=10, align=\"edge\")\n plt.ylim(0,0.5)\n #survival_prob = 1-sum(percent)\n #if survival_prob >= 0.5:\n # text_color = 'green'\n #else:\n # text_color = 'red'\n ax = plt.gca()\n #plt.text(0.05, 0.7, 'survival probability: %.2f'%survival_prob,color=text_color, horizontalalignment='left',verticalalignment='baseline', transform=ax.transAxes)\n # annotate last bar \n if ax.patches[-1].get_height() > 0:\n ax.text(ax.patches[-1].get_x()+3, np.round(ax.patches[-1].get_height()+0.001,4), '**', fontsize=12, color='black')\n plt.title('%s - Extinct in %i years: %i/%i'%(species,delta_t,sum(heights),n_sim))\n plt.xlabel('Years from present')\n plt.ylabel('Fraction of simulations')\n plt.tight_layout()\n pdf.savefig() # saves the current figure into a pdf page\n plt.close()\n print('\\n')\n #__________________________________________________________________________ \n\n\n\n\n \n", "meta": {"hexsha": "a1714bca427aa15eb97e9f307f7ea8b613514509", "size": 24694, "ext": "py", "lang": "Python", "max_stars_repo_path": "iucn_sim/misc/run_sim.py", "max_stars_repo_name": "tobiashofmann88/iucn_extinction_simulator", "max_stars_repo_head_hexsha": "9953be13637fbc9c5ec629700dc1d4ee9ad8225c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 11, "max_stars_repo_stars_event_min_datetime": "2020-06-18T11:34:47.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-25T17:38:52.000Z", "max_issues_repo_path": "iucn_sim/misc/run_sim.py", "max_issues_repo_name": "tobiashofmann88/iucn_extinction_simulator", "max_issues_repo_head_hexsha": "9953be13637fbc9c5ec629700dc1d4ee9ad8225c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "iucn_sim/misc/run_sim.py", "max_forks_repo_name": "tobiashofmann88/iucn_extinction_simulator", "max_forks_repo_head_hexsha": "9953be13637fbc9c5ec629700dc1d4ee9ad8225c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-02-05T19:00:33.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-09T21:07:45.000Z", "avg_line_length": 48.6102362205, "max_line_length": 393, "alphanum_fraction": 0.685065198, "include": true, "reason": "import numpy", "num_tokens": 5899, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.626124191181315, "lm_q2_score": 0.31405055141190724, "lm_q1q2_score": 0.19663464749282641}} {"text": "# Copyright 2002 Gary Strangman. All rights reserved\n# Copyright 2002-2016 The SciPy Developers\n#\n# The original code from Gary Strangman was heavily adapted for\n# use in SciPy by Travis Oliphant. The original code came with the\n# following disclaimer:\n#\n# This software is provided \"as-is\". There are no expressed or implied\n# warranties of any kind, including, but not limited to, the warranties\n# of merchantability and fitness for a given application. In no event\n# shall Gary Strangman be liable for any direct, indirect, incidental,\n# special, exemplary or consequential damages (including, but not limited\n# to, loss of use, data or profits, or business interruption) however\n# caused and on any theory of liability, whether in contract, strict\n# liability or tort (including negligence or otherwise) arising in any way\n# out of the use of this software, even if advised of the possibility of\n# such damage.\n\n\"\"\"\nA collection of basic statistical functions for Python.\n\nReferences\n----------\n.. [CRCProbStat2000] Zwillinger, D. and Kokoska, S. (2000). CRC Standard\n Probability and Statistics Tables and Formulae. Chapman & Hall: New\n York. 2000.\n\n\"\"\"\nimport warnings\nimport math\nfrom math import gcd\nfrom collections import namedtuple\n\nimport numpy as np\nfrom numpy import array, asarray, ma\n\nfrom scipy.spatial.distance import cdist\nfrom scipy.ndimage import measurements\nfrom scipy._lib._util import (check_random_state, MapWrapper,\n rng_integers, float_factorial)\nimport scipy.special as special\nfrom scipy import linalg\nfrom scipy.stats import distributions\n\n\n\n# Functions/classes in other files should be added in `__init__.py`, not here\n__all__ = ['find_repeats', 'gmean', 'hmean', 'mode', 'tmean', 'tvar',\n 'tmin', 'tmax', 'tstd', 'tsem', 'moment', 'variation',\n 'skew', 'kurtosis', 'describe', 'skewtest', 'kurtosistest',\n 'normaltest', 'jarque_bera', 'itemfreq',\n 'scoreatpercentile', 'percentileofscore',\n 'cumfreq', 'relfreq', 'obrientransform',\n 'sem', 'zmap', 'zscore', 'iqr', 'gstd', 'median_absolute_deviation',\n 'median_abs_deviation',\n 'sigmaclip', 'trimboth', 'trim1', 'trim_mean',\n 'f_oneway', 'F_onewayConstantInputWarning',\n 'F_onewayBadInputSizesWarning',\n 'PearsonRConstantInputWarning', 'PearsonRNearConstantInputWarning',\n 'pearsonr', 'fisher_exact',\n 'SpearmanRConstantInputWarning', 'spearmanr', 'pointbiserialr',\n 'kendalltau', 'weightedtau', 'multiscale_graphcorr',\n 'linregress', 'siegelslopes', 'theilslopes', 'ttest_1samp',\n 'ttest_ind', 'ttest_ind_from_stats', 'ttest_rel',\n 'kstest', 'ks_1samp', 'ks_2samp',\n 'chisquare', 'power_divergence',\n 'tiecorrect', 'ranksums', 'kruskal', 'friedmanchisquare',\n 'rankdata',\n 'combine_pvalues', 'wasserstein_distance', 'energy_distance',\n 'brunnermunzel', 'alexandergovern']\n\n\ndef _contains_nan(a, nan_policy='propagate'):\n policies = ['propagate', 'raise', 'omit']\n if nan_policy not in policies:\n raise ValueError(\"nan_policy must be one of {%s}\" %\n ', '.join(\"'%s'\" % s for s in policies))\n try:\n # Calling np.sum to avoid creating a huge array into memory\n # e.g. np.isnan(a).any()\n with np.errstate(invalid='ignore'):\n contains_nan = np.isnan(np.sum(a))\n except TypeError:\n # This can happen when attempting to sum things which are not\n # numbers (e.g. as in the function `mode`). Try an alternative method:\n try:\n contains_nan = np.nan in set(a.ravel())\n except TypeError:\n # Don't know what to do. Fall back to omitting nan values and\n # issue a warning.\n contains_nan = False\n nan_policy = 'omit'\n warnings.warn(\"The input array could not be properly \"\n \"checked for nan values. nan values \"\n \"will be ignored.\", RuntimeWarning)\n\n if contains_nan and nan_policy == 'raise':\n raise ValueError(\"The input contains nan values\")\n\n return contains_nan, nan_policy\n\n\ndef _chk_asarray(a, axis):\n if axis is None:\n a = np.ravel(a)\n outaxis = 0\n else:\n a = np.asarray(a)\n outaxis = axis\n\n if a.ndim == 0:\n a = np.atleast_1d(a)\n\n return a, outaxis\n\n\ndef _chk2_asarray(a, b, axis):\n if axis is None:\n a = np.ravel(a)\n b = np.ravel(b)\n outaxis = 0\n else:\n a = np.asarray(a)\n b = np.asarray(b)\n outaxis = axis\n\n if a.ndim == 0:\n a = np.atleast_1d(a)\n if b.ndim == 0:\n b = np.atleast_1d(b)\n\n return a, b, outaxis\n\n\ndef _shape_with_dropped_axis(a, axis):\n \"\"\"\n Given an array `a` and an integer `axis`, return the shape\n of `a` with the `axis` dimension removed.\n\n Examples\n --------\n >>> a = np.zeros((3, 5, 2))\n >>> _shape_with_dropped_axis(a, 1)\n (3, 2)\n\n \"\"\"\n shp = list(a.shape)\n try:\n del shp[axis]\n except IndexError:\n raise np.AxisError(axis, a.ndim) from None\n return tuple(shp)\n\n\ndef _broadcast_shapes(shape1, shape2):\n \"\"\"\n Given two shapes (i.e. tuples of integers), return the shape\n that would result from broadcasting two arrays with the given\n shapes.\n\n Examples\n --------\n >>> _broadcast_shapes((2, 1), (4, 1, 3))\n (4, 2, 3)\n \"\"\"\n d = len(shape1) - len(shape2)\n if d <= 0:\n shp1 = (1,)*(-d) + shape1\n shp2 = shape2\n else:\n shp1 = shape1\n shp2 = (1,)*d + shape2\n shape = []\n for n1, n2 in zip(shp1, shp2):\n if n1 == 1:\n n = n2\n elif n2 == 1 or n1 == n2:\n n = n1\n else:\n raise ValueError(f'shapes {shape1} and {shape2} could not be '\n 'broadcast together')\n shape.append(n)\n return tuple(shape)\n\n\ndef _broadcast_shapes_with_dropped_axis(a, b, axis):\n \"\"\"\n Given two arrays `a` and `b` and an integer `axis`, find the\n shape of the broadcast result after dropping `axis` from the\n shapes of `a` and `b`.\n\n Examples\n --------\n >>> a = np.zeros((5, 2, 1))\n >>> b = np.zeros((1, 9, 3))\n >>> _broadcast_shapes_with_dropped_axis(a, b, 1)\n (5, 3)\n \"\"\"\n shp1 = _shape_with_dropped_axis(a, axis)\n shp2 = _shape_with_dropped_axis(b, axis)\n try:\n shp = _broadcast_shapes(shp1, shp2)\n except ValueError:\n raise ValueError(f'non-axis shapes {shp1} and {shp2} could not be '\n 'broadcast together') from None\n return shp\n\n# Map from names to lambda_ values used in power_divergence().\n_power_div_lambda_names = {\n \"pearson\": 1,\n \"log-likelihood\": 0,\n \"freeman-tukey\": -0.5,\n \"mod-log-likelihood\": -1,\n \"neyman\": -2,\n \"cressie-read\": 2/3,\n}\n\n\ndef _count(a, axis=None):\n \"\"\"Count the number of non-masked elements of an array.\n\n This function behaves like `np.ma.count`, but is much faster\n for ndarrays.\n \"\"\"\n if hasattr(a, 'count'):\n num = a.count(axis=axis)\n if isinstance(num, np.ndarray) and num.ndim == 0:\n # In some cases, the `count` method returns a scalar array (e.g.\n # np.array(3)), but we want a plain integer.\n num = int(num)\n else:\n if axis is None:\n num = a.size\n else:\n num = a.shape[axis]\n return num\n\n\ndef _m_broadcast_to(a, shape):\n if np.ma.isMaskedArray(a):\n return np.ma.masked_array(np.broadcast_to(a, shape),\n mask=np.broadcast_to(a.mask, shape))\n return np.broadcast_to(a, shape, subok=True)\n\nPower_divergenceResult = namedtuple('Power_divergenceResult',\n ('statistic', 'pvalue'))\n\ndef power_divergence(f_obs, f_exp=None, ddof=0, axis=0, lambda_=None):\n \"\"\"Cressie-Read power divergence statistic and goodness of fit test.\n\n This function tests the null hypothesis that the categorical data\n has the given frequencies, using the Cressie-Read power divergence\n statistic.\n\n Parameters\n ----------\n f_obs : array_like\n Observed frequencies in each category.\n f_exp : array_like, optional\n Expected frequencies in each category. By default the categories are\n assumed to be equally likely.\n ddof : int, optional\n \"Delta degrees of freedom\": adjustment to the degrees of freedom\n for the p-value. The p-value is computed using a chi-squared\n distribution with ``k - 1 - ddof`` degrees of freedom, where `k`\n is the number of observed frequencies. The default value of `ddof`\n is 0.\n axis : int or None, optional\n The axis of the broadcast result of `f_obs` and `f_exp` along which to\n apply the test. If axis is None, all values in `f_obs` are treated\n as a single data set. Default is 0.\n lambda_ : float or str, optional\n The power in the Cressie-Read power divergence statistic. The default\n is 1. For convenience, `lambda_` may be assigned one of the following\n strings, in which case the corresponding numerical value is used::\n\n String Value Description\n \"pearson\" 1 Pearson's chi-squared statistic.\n In this case, the function is\n equivalent to `stats.chisquare`.\n \"log-likelihood\" 0 Log-likelihood ratio. Also known as\n the G-test [3]_.\n \"freeman-tukey\" -1/2 Freeman-Tukey statistic.\n \"mod-log-likelihood\" -1 Modified log-likelihood ratio.\n \"neyman\" -2 Neyman's statistic.\n \"cressie-read\" 2/3 The power recommended in [5]_.\n\n Returns\n -------\n statistic : float or ndarray\n The Cressie-Read power divergence test statistic. The value is\n a float if `axis` is None or if` `f_obs` and `f_exp` are 1-D.\n pvalue : float or ndarray\n The p-value of the test. The value is a float if `ddof` and the\n return value `stat` are scalars.\n\n See Also\n --------\n chisquare\n\n Notes\n -----\n This test is invalid when the observed or expected frequencies in each\n category are too small. A typical rule is that all of the observed\n and expected frequencies should be at least 5.\n\n Also, the sum of the observed and expected frequencies must be the same\n for the test to be valid; `power_divergence` raises an error if the sums\n do not agree within a relative tolerance of ``1e-8``.\n\n When `lambda_` is less than zero, the formula for the statistic involves\n dividing by `f_obs`, so a warning or error may be generated if any value\n in `f_obs` is 0.\n\n Similarly, a warning or error may be generated if any value in `f_exp` is\n zero when `lambda_` >= 0.\n\n The default degrees of freedom, k-1, are for the case when no parameters\n of the distribution are estimated. If p parameters are estimated by\n efficient maximum likelihood then the correct degrees of freedom are\n k-1-p. If the parameters are estimated in a different way, then the\n dof can be between k-1-p and k-1. However, it is also possible that\n the asymptotic distribution is not a chisquare, in which case this\n test is not appropriate.\n\n This function handles masked arrays. If an element of `f_obs` or `f_exp`\n is masked, then data at that position is ignored, and does not count\n towards the size of the data set.\n\n .. versionadded:: 0.13.0\n\n References\n ----------\n .. [1] Lowry, Richard. \"Concepts and Applications of Inferential\n Statistics\". Chapter 8.\n https://web.archive.org/web/20171015035606/http://faculty.vassar.edu/lowry/ch8pt1.html\n .. [2] \"Chi-squared test\", https://en.wikipedia.org/wiki/Chi-squared_test\n .. [3] \"G-test\", https://en.wikipedia.org/wiki/G-test\n .. [4] Sokal, R. R. and Rohlf, F. J. \"Biometry: the principles and\n practice of statistics in biological research\", New York: Freeman\n (1981)\n .. [5] Cressie, N. and Read, T. R. C., \"Multinomial Goodness-of-Fit\n Tests\", J. Royal Stat. Soc. Series B, Vol. 46, No. 3 (1984),\n pp. 440-464.\n\n Examples\n --------\n (See `chisquare` for more examples.)\n\n When just `f_obs` is given, it is assumed that the expected frequencies\n are uniform and given by the mean of the observed frequencies. Here we\n perform a G-test (i.e. use the log-likelihood ratio statistic):\n\n >>> from scipy.stats import power_divergence\n >>> power_divergence([16, 18, 16, 14, 12, 12], lambda_='log-likelihood')\n (2.006573162632538, 0.84823476779463769)\n\n The expected frequencies can be given with the `f_exp` argument:\n\n >>> power_divergence([16, 18, 16, 14, 12, 12],\n ... f_exp=[16, 16, 16, 16, 16, 8],\n ... lambda_='log-likelihood')\n (3.3281031458963746, 0.6495419288047497)\n\n When `f_obs` is 2-D, by default the test is applied to each column.\n\n >>> obs = np.array([[16, 18, 16, 14, 12, 12], [32, 24, 16, 28, 20, 24]]).T\n >>> obs.shape\n (6, 2)\n >>> power_divergence(obs, lambda_=\"log-likelihood\")\n (array([ 2.00657316, 6.77634498]), array([ 0.84823477, 0.23781225]))\n\n By setting ``axis=None``, the test is applied to all data in the array,\n which is equivalent to applying the test to the flattened array.\n\n >>> power_divergence(obs, axis=None)\n (23.31034482758621, 0.015975692534127565)\n >>> power_divergence(obs.ravel())\n (23.31034482758621, 0.015975692534127565)\n\n `ddof` is the change to make to the default degrees of freedom.\n\n >>> power_divergence([16, 18, 16, 14, 12, 12], ddof=1)\n (2.0, 0.73575888234288467)\n\n The calculation of the p-values is done by broadcasting the\n test statistic with `ddof`.\n\n >>> power_divergence([16, 18, 16, 14, 12, 12], ddof=[0,1,2])\n (2.0, array([ 0.84914504, 0.73575888, 0.5724067 ]))\n\n `f_obs` and `f_exp` are also broadcast. In the following, `f_obs` has\n shape (6,) and `f_exp` has shape (2, 6), so the result of broadcasting\n `f_obs` and `f_exp` has shape (2, 6). To compute the desired chi-squared\n statistics, we must use ``axis=1``:\n\n >>> power_divergence([16, 18, 16, 14, 12, 12],\n ... f_exp=[[16, 16, 16, 16, 16, 8],\n ... [8, 20, 20, 16, 12, 12]],\n ... axis=1)\n (array([ 3.5 , 9.25]), array([ 0.62338763, 0.09949846]))\n\n \"\"\"\n # Convert the input argument `lambda_` to a numerical value.\n if isinstance(lambda_, str):\n if lambda_ not in _power_div_lambda_names:\n names = repr(list(_power_div_lambda_names.keys()))[1:-1]\n raise ValueError(\"invalid string for lambda_: {0!r}. \"\n \"Valid strings are {1}\".format(lambda_, names))\n lambda_ = _power_div_lambda_names[lambda_]\n elif lambda_ is None:\n lambda_ = 1\n\n f_obs = np.asanyarray(f_obs)\n f_obs_float = f_obs.astype(np.float64)\n\n if f_exp is not None:\n f_exp = np.asanyarray(f_exp)\n bshape = _broadcast_shapes(f_obs_float.shape, f_exp.shape)\n f_obs_float = _m_broadcast_to(f_obs_float, bshape)\n f_exp = _m_broadcast_to(f_exp, bshape)\n rtol = 1e-2 # to pass existing tests #EDIT from 1e-8 to 1e-2\n with np.errstate(invalid='ignore'):\n f_obs_sum = f_obs_float.sum(axis=axis)\n f_exp_sum = f_exp.sum(axis=axis)\n relative_diff = (np.abs(f_obs_sum - f_exp_sum) /\n np.minimum(f_obs_sum, f_exp_sum))\n diff_gt_tol = (relative_diff > rtol).any()\n if diff_gt_tol:\n msg = (f\"For each axis slice, the sum of the observed \"\n f\"frequencies must agree with the sum of the \"\n f\"expected frequencies to a relative tolerance \"\n f\"of {rtol}, but the percent differences are:\\n\"\n f\"{relative_diff}\")\n raise ValueError(msg)\n\n else:\n # Ignore 'invalid' errors so the edge case of a data set with length 0\n # is handled without spurious warnings.\n with np.errstate(invalid='ignore'):\n f_exp = f_obs.mean(axis=axis, keepdims=True)\n\n # `terms` is the array of terms that are summed along `axis` to create\n # the test statistic. We use some specialized code for a few special\n # cases of lambda_.\n if lambda_ == 1:\n # Pearson's chi-squared statistic\n terms = (f_obs_float - f_exp)**2 / f_exp\n elif lambda_ == 0:\n # Log-likelihood ratio (i.e. G-test)\n terms = 2.0 * special.xlogy(f_obs, f_obs / f_exp)\n elif lambda_ == -1:\n # Modified log-likelihood ratio\n terms = 2.0 * special.xlogy(f_exp, f_exp / f_obs)\n else:\n # General Cressie-Read power divergence.\n terms = f_obs * ((f_obs / f_exp)**lambda_ - 1)\n terms /= 0.5 * lambda_ * (lambda_ + 1)\n\n stat = terms.sum(axis=axis)\n\n num_obs = _count(terms, axis=axis)\n ddof = asarray(ddof)\n p = distributions.chi2.sf(stat, num_obs - 1 - ddof)\n\n return Power_divergenceResult(stat, p)\n\n\ndef chisquare(f_obs, f_exp=None, ddof=0, axis=0):\n \"\"\"Calculate a one-way chi-square test.\n\n The chi-square test tests the null hypothesis that the categorical data\n has the given frequencies.\n\n Parameters\n ----------\n f_obs : array_like\n Observed frequencies in each category.\n f_exp : array_like, optional\n Expected frequencies in each category. By default the categories are\n assumed to be equally likely.\n ddof : int, optional\n \"Delta degrees of freedom\": adjustment to the degrees of freedom\n for the p-value. The p-value is computed using a chi-squared\n distribution with ``k - 1 - ddof`` degrees of freedom, where `k`\n is the number of observed frequencies. The default value of `ddof`\n is 0.\n axis : int or None, optional\n The axis of the broadcast result of `f_obs` and `f_exp` along which to\n apply the test. If axis is None, all values in `f_obs` are treated\n as a single data set. Default is 0.\n\n Returns\n -------\n chisq : float or ndarray\n The chi-squared test statistic. The value is a float if `axis` is\n None or `f_obs` and `f_exp` are 1-D.\n p : float or ndarray\n The p-value of the test. The value is a float if `ddof` and the\n return value `chisq` are scalars.\n\n See Also\n --------\n scipy.stats.power_divergence\n scipy.stats.fisher_exact : Fisher exact test on a 2x2 contingency table.\n scipy.stats.barnard_exact : An unconditional exact test. An alternative\n to chi-squared test for small sample sizes.\n\n Notes\n -----\n This test is invalid when the observed or expected frequencies in each\n category are too small. A typical rule is that all of the observed\n and expected frequencies should be at least 5. According to [3]_, the\n total number of samples is recommended to be greater than 13,\n otherwise exact tests (such as Barnard's Exact test) should be used\n because they do not overreject.\n\n Also, the sum of the observed and expected frequencies must be the same\n for the test to be valid; `chisquare` raises an error if the sums do not\n agree within a relative tolerance of ``1e-8``.\n\n The default degrees of freedom, k-1, are for the case when no parameters\n of the distribution are estimated. If p parameters are estimated by\n efficient maximum likelihood then the correct degrees of freedom are\n k-1-p. If the parameters are estimated in a different way, then the\n dof can be between k-1-p and k-1. However, it is also possible that\n the asymptotic distribution is not chi-square, in which case this test\n is not appropriate.\n\n References\n ----------\n .. [1] Lowry, Richard. \"Concepts and Applications of Inferential\n Statistics\". Chapter 8.\n https://web.archive.org/web/20171022032306/http://vassarstats.net:80/textbook/ch8pt1.html\n .. [2] \"Chi-squared test\", https://en.wikipedia.org/wiki/Chi-squared_test\n .. [3] Pearson, Karl. \"On the criterion that a given system of deviations from the probable\n in the case of a correlated system of variables is such that it can be reasonably\n supposed to have arisen from random sampling\", Philosophical Magazine. Series 5. 50\n (1900), pp. 157-175.\n\n Examples\n --------\n When just `f_obs` is given, it is assumed that the expected frequencies\n are uniform and given by the mean of the observed frequencies.\n\n >>> from scipy.stats import chisquare\n >>> chisquare([16, 18, 16, 14, 12, 12])\n (2.0, 0.84914503608460956)\n\n With `f_exp` the expected frequencies can be given.\n\n >>> chisquare([16, 18, 16, 14, 12, 12], f_exp=[16, 16, 16, 16, 16, 8])\n (3.5, 0.62338762774958223)\n\n When `f_obs` is 2-D, by default the test is applied to each column.\n\n >>> obs = np.array([[16, 18, 16, 14, 12, 12], [32, 24, 16, 28, 20, 24]]).T\n >>> obs.shape\n (6, 2)\n >>> chisquare(obs)\n (array([ 2. , 6.66666667]), array([ 0.84914504, 0.24663415]))\n\n By setting ``axis=None``, the test is applied to all data in the array,\n which is equivalent to applying the test to the flattened array.\n\n >>> chisquare(obs, axis=None)\n (23.31034482758621, 0.015975692534127565)\n >>> chisquare(obs.ravel())\n (23.31034482758621, 0.015975692534127565)\n\n `ddof` is the change to make to the default degrees of freedom.\n\n >>> chisquare([16, 18, 16, 14, 12, 12], ddof=1)\n (2.0, 0.73575888234288467)\n\n The calculation of the p-values is done by broadcasting the\n chi-squared statistic with `ddof`.\n\n >>> chisquare([16, 18, 16, 14, 12, 12], ddof=[0,1,2])\n (2.0, array([ 0.84914504, 0.73575888, 0.5724067 ]))\n\n `f_obs` and `f_exp` are also broadcast. In the following, `f_obs` has\n shape (6,) and `f_exp` has shape (2, 6), so the result of broadcasting\n `f_obs` and `f_exp` has shape (2, 6). To compute the desired chi-squared\n statistics, we use ``axis=1``:\n\n >>> chisquare([16, 18, 16, 14, 12, 12],\n ... f_exp=[[16, 16, 16, 16, 16, 8], [8, 20, 20, 16, 12, 12]],\n ... axis=1)\n (array([ 3.5 , 9.25]), array([ 0.62338763, 0.09949846]))\n\n \"\"\"\n return power_divergence(f_obs, f_exp=f_exp, ddof=ddof, axis=axis,\n lambda_=\"pearson\")\n\n\n\ndef _sum_of_squares(a, axis=0):\n \"\"\"Square each element of the input array, and return the sum(s) of that.\n\n Parameters\n ----------\n a : array_like\n Input array.\n axis : int or None, optional\n Axis along which to calculate. Default is 0. If None, compute over\n the whole array `a`.\n\n Returns\n -------\n sum_of_squares : ndarray\n The sum along the given axis for (a**2).\n\n See Also\n --------\n _square_of_sums : The square(s) of the sum(s) (the opposite of\n `_sum_of_squares`).\n\n \"\"\"\n a, axis = _chk_asarray(a, axis)\n return np.sum(a*a, axis)\n\n\ndef _square_of_sums(a, axis=0):\n \"\"\"Sum elements of the input array, and return the square(s) of that sum.\n\n Parameters\n ----------\n a : array_like\n Input array.\n axis : int or None, optional\n Axis along which to calculate. Default is 0. If None, compute over\n the whole array `a`.\n\n Returns\n -------\n square_of_sums : float or ndarray\n The square of the sum over `axis`.\n\n See Also\n --------\n _sum_of_squares : The sum of squares (the opposite of `square_of_sums`).\n\n \"\"\"\n a, axis = _chk_asarray(a, axis)\n s = np.sum(a, axis)\n if not np.isscalar(s):\n return s.astype(float) * s\n else:\n return float(s) * s\n", "meta": {"hexsha": "ce2caa4d38fbef56eedbd853f987be27a53ae586", "size": 24030, "ext": "py", "lang": "Python", "max_stars_repo_path": "stats_modified.py", "max_stars_repo_name": "seamanticscience/Benfords-law", "max_stars_repo_head_hexsha": "3e59ca7dc16ac6657048ee9703e6bb1896cc7277", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "stats_modified.py", "max_issues_repo_name": "seamanticscience/Benfords-law", "max_issues_repo_head_hexsha": "3e59ca7dc16ac6657048ee9703e6bb1896cc7277", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "stats_modified.py", "max_forks_repo_name": "seamanticscience/Benfords-law", "max_forks_repo_head_hexsha": "3e59ca7dc16ac6657048ee9703e6bb1896cc7277", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.9124423963, "max_line_length": 100, "alphanum_fraction": 0.6200998752, "include": true, "reason": "import numpy,from numpy,import scipy,from scipy", "num_tokens": 6611, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230156, "lm_q2_score": 0.3812195803163617, "lm_q1q2_score": 0.1965644078746858}} {"text": "#!/usr/bin/env python\n#This script plots drag around an inline oscillating cylinder for re 200 kc 10 against dutsch et als work at cycle 14\nimport argparse\nimport os\nimport os.path\nimport sys\nimport csv\nimport matplotlib\nfrom matplotlib import pyplot as plt\nimport numpy\n\ncuibmFolder = os.path.expandvars(\"/scratch/src/cuIBM\")\n\nvalidationData = '/osc_Re200_KC10_Dutsch.txt'\n\nexecPath = cuibmFolder + '/bin/cuIBM'\ncaseFolder = cuibmFolder + '/validation/osc/static'\nvalidationData = cuibmFolder + '/validation-data' + validationData\n\nprint \"\\n\"+\"-\"*100\nprint \"Plotting validation for flow around inline oscillating cylinder with Re200 and KC10\\n\"\nprint \"-\"*100+\"\\n\"\n\nexperiment = numpy.genfromtxt(validationData,delimiter='\\t')\nexternal = numpy.genfromtxt(caseFolder+'/externalkc10/forces',delimiter='\\t')\nembedded = numpy.genfromtxt(caseFolder+'/embeddedkc10/forces',delimiter='\\t')\n\n#external\nplt.plot([i-13 for i in zip(*external)[0]],[i*5 for i in zip(*external)[1]],'-',color='blue',linewidth=2,label='External')\nplt.plot(zip(*experiment)[0],zip(*experiment)[1],'o', color = 'red', markersize = 8, label = 'Dutsch et al')\nplt.title('Drag for flow around inline oscillating cylinder Re 200, KC 10')\nplt.legend(loc='lower right',numpoints=1, fancybox=True)\nplt.xlabel('t/T')\nplt.ylabel('Fd')\nplt.ylim([-6,6])\nplt.xlim([0,1])\nplt.savefig('%s/External_static_kc10.pdf' % (caseFolder))\nplt.clf()\n\n#emb\nplt.plot([i-13 for i in zip(*embedded)[0]],[i*5 for i in zip(*embedded)[1]],'-',color='blue',linewidth=2,label='Embedded')\nplt.plot(zip(*experiment)[0],zip(*experiment)[1],'o', color = 'red', markersize = 8, label = 'Dutsch et al')\nplt.title('Drag for flow around inline oscillating cylinder Re 200, KC 10')\nplt.legend(loc='lower right',numpoints=1, fancybox=True)\nplt.xlabel('t/T')\nplt.ylabel('Fd')\nplt.ylim([-6,6])\nplt.xlim([0,1])\nplt.savefig('%s/Embedded_static_kc10.pdf' % (caseFolder))\nplt.clf()\n\n\nprint '\\nDone plotting!\\n Files saved to %s' % caseFolder\n", "meta": {"hexsha": "ccbc293e44f9e193c1aa8b2cc6e9c264d0cadafc", "size": 1972, "ext": "py", "lang": "Python", "max_stars_repo_path": "scripts/validation/osc_Re200_KC10.py", "max_stars_repo_name": "Niemeyer-Research-Group/cuIBM", "max_stars_repo_head_hexsha": "0fa913a465e4f0f3432e0dbd4d3df9bc47905406", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-07-05T17:48:41.000Z", "max_stars_repo_stars_event_max_datetime": "2020-07-05T17:48:41.000Z", "max_issues_repo_path": "scripts/validation/osc_Re200_KC10.py", "max_issues_repo_name": "Niemeyer-Research-Group/cuIBM-FSI", "max_issues_repo_head_hexsha": "0fa913a465e4f0f3432e0dbd4d3df9bc47905406", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2016-05-11T16:04:33.000Z", "max_issues_repo_issues_event_max_datetime": "2016-05-12T01:40:27.000Z", "max_forks_repo_path": "scripts/validation/osc_Re200_KC10.py", "max_forks_repo_name": "Niemeyer-Research-Group/cuIBM-FSI", "max_forks_repo_head_hexsha": "0fa913a465e4f0f3432e0dbd4d3df9bc47905406", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-07-06T14:32:36.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-03T13:36:48.000Z", "avg_line_length": 36.5185185185, "max_line_length": 122, "alphanum_fraction": 0.7231237323, "include": true, "reason": "import numpy", "num_tokens": 564, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230157, "lm_q2_score": 0.38121956625614994, "lm_q1q2_score": 0.19656440062496064}} {"text": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n\"\"\"RGB color space.\n\"\"\"\n\nfrom __future__ import annotations\n\nfrom typing import cast\nfrom typing import Union\n\nimport cv2\nimport numpy as np\nimport torch\nfrom multipledispatch import dispatch\nfrom torch import nn\nfrom torch import Tensor\n\nfrom onevision.cv.utils import batch_image_processing\nfrom onevision.cv.utils import channel_last_processing\nfrom onevision.factory import TRANSFORMS\nfrom onevision.type import TensorOrArray\n\n__all__ = [\n \"bgr_to_rgb\",\n \"bgr_to_rgba\",\n \"linear_rgb_to_rgb\",\n \"rgb_to_bgr\",\n \"rgb_to_linear_rgb\",\n \"rgb_to_rgba\",\n \"rgba_to_bgr\",\n \"rgba_to_rgb\",\n \"BgrToRgb\",\n \"BgrToRgba\",\n \"LinearRgbToRgb\",\n \"RgbaToBgr\",\n \"RgbaToRgb\",\n \"RgbToBgr\",\n \"RgbToLinearRgb\",\n \"RgbToRgba\"\n]\n\n\n# MARK: - Functional\n\n@dispatch(Tensor)\ndef bgr_to_rgb(image: Tensor) -> Tensor:\n \"\"\"Convert a BGR image to RGB.\n\n Args:\n image (Tensor[B, 3, H, W]):\n BGR Image to be converted to BGR.\n\n Returns:\n rgb (Tensor[B, 3, H, W]):\n RGB version of the image.\n \"\"\"\n # Flip image channels\n rgb = image.flip(-3)\n return rgb\n\n\n@batch_image_processing\n@channel_last_processing\n@dispatch(np.ndarray)\ndef bgr_to_rgb(image: np.ndarray) -> np.ndarray:\n \"\"\"Convert a BGR image to RGB.\n\n Args:\n image (np.ndarray[B, 3, H, W]):\n BGR Image to be converted to BGR.\n\n Returns:\n rgb (np.ndarray[B, 3, H, W]):\n RGB version of the image.\n \"\"\"\n return cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n\n\n@dispatch(Tensor, (float, Tensor))\ndef bgr_to_rgba(image: Tensor, alpha_val: Union[float, Tensor]) -> Tensor:\n \"\"\"Convert an image from BGR to RGBA.\n\n Args:\n image (Tensor[B, 3, H, W]):\n BGR Image to be converted to RGBA.\n alpha_val (float, Tensor[B, 1, H, W]):\n A float number or tensor for the alpha value.\n\n Returns:\n rgba (Tensor[B, 4, H, W]):\n RGBA version of the image.\n\n Notes:\n Current functionality is NOT supported by Torchscript.\n \"\"\"\n if not isinstance(alpha_val, (float, Tensor)):\n raise TypeError(f\"`alpha_val` must be a `float` or `Tensor`. \"\n f\"But got: {type(alpha_val)}.\")\n \n # Convert first to RGB, then add alpha channel\n rgb = bgr_to_rgb(image)\n rgba = rgb_to_rgba(rgb, alpha_val)\n\n return rgba\n\n\n@batch_image_processing\n@channel_last_processing\n@dispatch(np.ndarray, (float, np.ndarray))\ndef bgr_to_rgba(image: np.ndarray, alpha_val: Union[float, np.ndarray]) -> np.ndarray:\n \"\"\"Convert an image from BGR to RGBA.\n\n Args:\n image (np.ndarray[B, 3, H, W]):\n BGR Image to be converted to RGBA.\n alpha_val (float, np.ndarray[B, 1, H, W]):\n A float number or tensor for the alpha value.\n\n Returns:\n rgba (np.ndarray[B, 4, H, W]):\n RGBA version of the image.\n\n Notes:\n Current functionality is NOT supported by Torchscript.\n \"\"\"\n return cv2.cvtColor(image, cv2.COLOR_BGR2RGBA)\n\n\n@dispatch(Tensor)\ndef linear_rgb_to_rgb(image: Tensor) -> Tensor:\n \"\"\"Convert a linear RGB image to sRGB. Used in colorspace conversions.\n\n Args:\n image (Tensor[B, 3, H, W]):\n Linear RGB Image to be converted to sRGB.\n\n Returns:\n rgb (Tensor[B, 3, H, W]):\n sRGB version of the image.\n \"\"\"\n threshold = 0.0031308\n rgb = torch.where(\n image > threshold,\n 1.055 * torch.pow(image.clamp(min=threshold), 1 / 2.4) - 0.055,\n 12.92 * image\n )\n return rgb\n\n\ndef rgb_to_bgr(image: TensorOrArray) -> TensorOrArray:\n \"\"\"Convert an RGB image to BGR.\n\n Args:\n image (TensorOrArray[B, 3, H, W]):\n RGB Image to be converted to BGR.\n\n Returns:\n bgr (TensorOrArray[B, 3, H, W]):\n BGR version of the image.\n \"\"\"\n return bgr_to_rgb(image)\n\n\n@dispatch(Tensor)\ndef rgb_to_linear_rgb(image: Tensor) -> Tensor:\n \"\"\"Convert an sRGB image to linear RGB. Used in colorspace conversions.\n\n Args:\n image (Tensor[B, 3, H, W]):\n sRGB Image to be converted to linear RGB.\n\n Returns:\n linear_rgb (Tensor[B, 3, H, W]):\n linear RGB version of the image.\n \"\"\"\n lin_rgb = torch.where(\n image > 0.04045,\n torch.pow(((image + 0.055) / 1.055), 2.4),\n image / 12.92\n )\n return lin_rgb\n\n\n@dispatch(Tensor, (float, Tensor))\ndef rgb_to_rgba(image: Tensor, alpha_val: Union[float, Tensor]) -> Tensor:\n \"\"\"Convert an image from RGB to RGBA.\n\n Args:\n image (Tensor[B, 3, H, W]):\n RGB Image to be converted to RGBA.\n alpha_val (float, Tensor[B, 1, H, W]):\n A float number or tensor for the alpha value.\n\n Returns:\n rgba (Tensor[B, 4, H, W]):\n RGBA version of the image\n\n Notes:\n Current functionality is NOT supported by Torchscript.\n \"\"\"\n if not isinstance(alpha_val, (float, Tensor)):\n raise TypeError(f\"`alpha_val` must be `float` or `Tensor`. \"\n f\"But got: {type(alpha_val)}.\")\n \n # Add one channel\n r, g, b = torch.chunk(image, image.shape[-3], dim=-3)\n a = cast(Tensor, alpha_val)\n\n if isinstance(alpha_val, float):\n a = torch.full_like(r, fill_value=float(alpha_val))\n rgba = torch.cat([r, g, b, a], dim=-3)\n\n return rgba\n\n\n@batch_image_processing\n@channel_last_processing\n@dispatch(np.ndarray, (float, np.ndarray))\ndef rgb_to_rgba(image: np.ndarray, alpha_val: Union[float, np.ndarray]) -> np.ndarray:\n \"\"\"Convert an image from RGB to RGBA.\n\n Args:\n image (np.ndarray[B, 3, H, W]):\n RGB Image to be converted to RGBA.\n alpha_val (float, np.ndarray[B, 1, H, W]):\n A float number or tensor for the alpha value.\n\n Returns:\n rgba (np.ndarray[B, 4, H, W]):\n RGBA version of the image\n\n Notes:\n Current functionality is NOT supported by Torchscript.\n \"\"\"\n return cv2.cvtColor(image, cv2.COLOR_RGB2RGBA)\n\n\n@dispatch(Tensor)\ndef rgba_to_bgr(image: Tensor) -> Tensor:\n \"\"\"Convert an image from RGBA to BGR.\n\n Args:\n image (Tensor[B, 4, H, W]):\n RGBA Image to be converted to BGR.\n\n Returns:\n rgb (Tensor[B, 3, H, W]):\n RGB version of the image.\n \"\"\"\n if not isinstance(image, Tensor):\n raise TypeError(f\"`image` must be a `Tensor`. But got: {type(image)}\")\n if image.ndim < 3 or image.shape[-3] != 4:\n raise ValueError(f\"`image` must have a shape of [*, 4, H, W]. \"\n f\"But got: {image.shape}\")\n\n # Convert to RGB first, then to BGR\n rgb = rgba_to_rgb(image)\n bgr = rgb_to_bgr(rgb)\n \n return bgr\n\n\n@batch_image_processing\n@channel_last_processing\n@dispatch(np.ndarray)\ndef rgba_to_bgr(image: np.ndarray) -> np.ndarray:\n \"\"\"Convert an image from RGBA to BGR.\n\n Args:\n image (np.ndarray[B, 4, H, W]):\n RGBA Image to be converted to BGR.\n\n Returns:\n bgr (np.ndarray[B, 3, H, W]):\n BGR version of the image.\n \"\"\"\n return cv2.cvtColor(image, cv2.COLOR_RGBA2BGR)\n\n\n@dispatch(Tensor)\ndef rgba_to_rgb(image: Tensor) -> Tensor:\n \"\"\"Convert an image from RGBA to RGB.\n\n Args:\n image (Tensor[B, 4, H, W]):\n RGBA Image to be converted to RGB.\n\n Returns:\n rgb (Tensor[B, 3, H, W]):\n RGB version of the image.\n \"\"\"\n # Unpack channels\n r, g, b, a = torch.chunk(image, image.shape[-3], dim=-3)\n\n # Compute new channels\n a_one = torch.tensor(1.0) - a\n r_new = a_one * r + a * r\n g_new = a_one * g + a * g\n b_new = a_one * b + a * b\n rgb = torch.cat([r_new, g_new, b_new], dim=-3)\n\n return rgb\n\n\n@batch_image_processing\n@channel_last_processing\n@dispatch(np.ndarray)\ndef rgba_to_rgb(image: np.ndarray) -> np.ndarray:\n \"\"\"Convert an image from RGBA to RGB.\n\n Args:\n image (np.ndarray[B, 4, H, W]):\n RGBA Image to be converted to RGB.\n\n Returns:\n rgb (np.ndarray[B, 3, H, W]):\n RGB version of the image.\n \"\"\"\n return cv2.cvtColor(image, cv2.COLOR_RGBA2RGB)\n\n\n# MARK: - Modules\n\n@TRANSFORMS.register(name=\"bgr_to_rgb\")\nclass BgrToRgb(nn.Module):\n \"\"\"Convert image from BGR to RGB. Image data is assumed to be in the\n range of [0.0, 1.0].\n \"\"\"\n\n # MARK: Forward Pass\n \n def forward(self, image: TensorOrArray) -> TensorOrArray:\n return bgr_to_rgb(image)\n\n\n@TRANSFORMS.register(name=\"bgr_to_rgba\")\nclass BgrToRgba(nn.Module):\n \"\"\"Convert an image from BGR to RGBA. Add an alpha channel to existing RGB\n image.\n\n Args:\n alpha_val (float, TensorOrArray[B, 1, H, W]):\n A float number or tensor for the alpha value.\n \n Notes:\n Current functionality is NOT supported by Torchscript.\n \"\"\"\n\n # MARK: Magic Functions\n \n def __init__(self, alpha_val: Union[float, TensorOrArray]):\n super().__init__()\n self.alpha_val = alpha_val\n\n # MARK: Forward Pass\n \n def forward(self, image: TensorOrArray) -> TensorOrArray:\n return rgb_to_rgba(image, self.alpha_val)\n\n\n@TRANSFORMS.register(name=\"linear_rgb_to_rgb\")\nclass LinearRgbToRgb(nn.Module):\n \"\"\"Convert a linear RGB image to sRGB. Applies gamma correction to linear\n RGB values, at the end of colorspace conversions, to get sRGB.\n \n References:\n [1] https://stackoverflow.com/questions/35952564/convert-rgb-to-srgb\n [2] https://www.cambridgeincolour.com/tutorials/gamma-correction.htm\n [3] https://en.wikipedia.org/wiki/SRGB\n \"\"\"\n\n # MARK: Forward Pass\n \n def forward(self, image: TensorOrArray) -> TensorOrArray:\n return linear_rgb_to_rgb(image)\n\n\n@TRANSFORMS.register(name=\"rgb_to_bgr\")\nclass RgbToBgr(nn.Module):\n \"\"\"Convert an image from RGB to BGR. Image data is assumed to be in the\n range of [0.0, 1.0].\n \"\"\"\n\n # MARK: Forward Pass\n \n def forward(self, image: TensorOrArray) -> TensorOrArray:\n return rgb_to_bgr(image)\n\n\n@TRANSFORMS.register(name=\"rgb_to_linear_rgb\")\nclass RgbToLinearRgb(nn.Module):\n \"\"\"Convert an image from sRGB to linear RGB. Reverses the gamma correction\n of sRGB to get linear RGB values for colorspace conversions. Image data\n is assumed to be in the range of [0.0, 1.0].\n \n References:\n [1] https://stackoverflow.com/questions/35952564/convert-rgb-to-srgb\n [2] https://www.cambridgeincolour.com/tutorials/gamma-correction.htm\n [3] https://en.wikipedia.org/wiki/SRGB\n \"\"\"\n\n # MARK: Forward Pass\n \n def forward(self, image: TensorOrArray) -> TensorOrArray:\n return rgb_to_linear_rgb(image)\n\n\n@TRANSFORMS.register(name=\"rgb_to_rgba\")\nclass RgbToRgba(nn.Module):\n \"\"\"Convert an image from RGB to RGBA. Add an alpha channel to existing RGB\n image.\n\n Args:\n alpha_val (float, TensorOrArray[B, 1, H, W]):\n A float number or tensor for the alpha value.\n \n Notes:\n Current functionality is NOT supported by Torchscript.\n \"\"\"\n\n # MARK: Magic Functions\n \n def __init__(self, alpha_val: Union[float, TensorOrArray]) -> None:\n super().__init__()\n self.alpha_val = alpha_val\n\n # MARK: Forward Pass\n \n def forward(self, image: TensorOrArray) -> TensorOrArray:\n return rgb_to_rgba(image, self.alpha_val)\n\n\n@TRANSFORMS.register(name=\"rgba_to_bgr\")\nclass RgbaToBgr(nn.Module):\n \"\"\"Convert an image from RGBA to BGR. Remove an alpha channel from BGR\n image.\n \"\"\"\n\n # MARK: Forward Pass\n \n def forward(self, image: TensorOrArray) -> TensorOrArray:\n return rgba_to_bgr(image)\n\n\n@TRANSFORMS.register(name=\"rgba_to_rgb\")\nclass RgbaToRgb(nn.Module):\n \"\"\"Convert an image from RGBA to RGB. Remove an alpha channel from RGB\n image.\n \"\"\"\n\n # MARK: Forward Pass\n \n def forward(self, image: TensorOrArray) -> TensorOrArray:\n return rgba_to_rgb(image)\n", "meta": {"hexsha": "d01958d5bdff8057ec2a9bafa4da149c845a20eb", "size": 11971, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/onevision/cv/imgproc/color/rgb.py", "max_stars_repo_name": "phlong3105/onevision", "max_stars_repo_head_hexsha": "90552b64df7213e7fbe23c80ffd8a89583289433", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2022-03-28T09:46:38.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-28T14:12:32.000Z", "max_issues_repo_path": "src/onevision/cv/imgproc/color/rgb.py", "max_issues_repo_name": "phlong3105/onevision", "max_issues_repo_head_hexsha": "90552b64df7213e7fbe23c80ffd8a89583289433", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/onevision/cv/imgproc/color/rgb.py", "max_forks_repo_name": "phlong3105/onevision", "max_forks_repo_head_hexsha": "90552b64df7213e7fbe23c80ffd8a89583289433", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.2521929825, "max_line_length": 86, "alphanum_fraction": 0.6218361039, "include": true, "reason": "import numpy", "num_tokens": 3159, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230157, "lm_q2_score": 0.38121956625614994, "lm_q1q2_score": 0.19656440062496064}} {"text": "import math\nfrom typing import Optional, Union, Tuple, List\n\nimport numpy as np\n\nimport torch\nimport torch.nn.functional as F\nfrom torch import Tensor\nfrom torch_geometric.utils.num_nodes import maybe_num_nodes\nfrom torch_scatter import scatter, segment_csr, gather_csr\nfrom torch_scatter.utils import broadcast\n\nimport tsl\n\n__all__ = [\n 'expand_then_cat',\n 'gated_tanh',\n 'reverse_tensor',\n 'sparse_softmax',\n 'sparse_multi_head_attention'\n]\n\n\ndef expand_then_cat(tensors: Union[Tuple[Tensor, ...], List[Tensor]],\n dim=-1) -> Tensor:\n r\"\"\"\n Match the dimensions of tensors in the input list and then concatenate.\n\n Args:\n tensors: Tensors to concatenate.\n dim (int): Dimension along which to concatenate.\n \"\"\"\n shapes = [t.shape for t in tensors]\n expand_dims = list(np.max(shapes, 0))\n expand_dims[dim] = -1\n tensors = [t.expand(*expand_dims) for t in tensors]\n return torch.cat(tensors, dim=dim)\n\n\n@torch.jit.script\ndef gated_tanh(input: Tensor, dim: int = -1) -> Tensor:\n r\"\"\"The gated tanh unite. Computes:\n\n .. math ::\n \\text{GatedTanH}(a, b) = \\text{TanH}(a) \\otimes \\sigma(b)\n\n where `input` is split in half along `dim` to form `a` and `b`, :math:`\\text{TanH}` is the hyperbolic tangent\n function, :math:`\\sigma` is the sigmoid function and :math:`\\otimes` is the element-wise product between matrices.\n\n Args:\n input (Tensor): Input tensor.\n dim (int, optional): Dimension on which to split the input.\n (default: -1)\n \"\"\"\n\n out, gate = torch.tensor_split(input, 2, dim=dim)\n return torch.tanh(out) * torch.sigmoid(gate)\n\n\n@torch.jit.script\ndef reverse_tensor(tensor: Tensor, dim: int) -> Tensor:\n \"\"\"Reverse tensor along specific dimension.\n\n Args:\n tensor (Tensor): Input tensor.\n dim (int): Dimension along which to reverse sequence.\n \"\"\"\n indices = torch.arange(tensor.size(dim) - 1, -1, -1, device=tensor.device)\n return tensor.index_select(dim, indices)\n\n\n@torch.jit.script\ndef sparse_softmax(src: Tensor, index: Optional[Tensor] = None,\n ptr: Optional[Tensor] = None,\n num_nodes: Optional[int] = None,\n dim: int = -2) -> Tensor:\n r\"\"\"Extension of ~torch_geometric.softmax with index broadcasting to compute\n a sparsely evaluated softmax over multiple broadcast dimensions.\n\n Given a value tensor :attr:`src`, this function first groups the values\n along the first dimension based on the indices specified in :attr:`index`,\n and then proceeds to compute the softmax individually for each group.\n\n Args:\n src (Tensor): The source tensor.\n index (Tensor, optional): The indices of elements for applying the softmax.\n ptr (LongTensor, optional): If given, computes the softmax based on\n sorted inputs in CSR representation. (default: :obj:`None`)\n num_nodes (int, optional): The number of nodes, *i.e.*\n :obj:`max_val + 1` of :attr:`index`. (default: :obj:`None`)\n dim (int, optional): The dimension in which to normalize, i.e., the edge\n dimension. (default: :obj:`-2`)\n \"\"\"\n if ptr is not None:\n dim = dim + src.dim() if dim < 0 else dim\n size = ([1] * dim) + [-1]\n ptr = ptr.view(size)\n src_max = gather_csr(segment_csr(src, ptr, reduce='max'), ptr)\n out = (src - src_max).exp()\n out_sum = gather_csr(segment_csr(out, ptr, reduce='sum'), ptr)\n elif index is not None:\n N = maybe_num_nodes(index, num_nodes)\n expanded_index = broadcast(index, src, dim)\n src_max = scatter(src, expanded_index, dim, dim_size=N, reduce='max')\n src_max = src_max.index_select(dim, index)\n out = (src - src_max).exp()\n out_sum = scatter(out, expanded_index, dim, dim_size=N, reduce='sum')\n out_sum = out_sum.index_select(dim, index)\n else:\n raise NotImplementedError\n\n return out / (out_sum + tsl.epsilon)\n\n\n@torch.jit.script\ndef sparse_multi_head_attention(q: Tensor, k: Tensor, v: Tensor, index: Tensor,\n dim_size: Optional[int] = None,\n dropout_p: float = 0.0):\n r\"\"\"Computes multi-head, scaled, dot product attention on query, key and\n value tensors, applying dropout if a probability greater than 0.0 is\n specified. Index specifies for each query in q the belonging sequence in the\n original batched, dense tensor.\n Returns a tensor pair containing attended values and attention weights.\n\n Args:\n q (Tensor): Query tensor. See Shape section for shape details.\n k (Tensor): Key tensor. See Shape section for shape details.\n v (Tensor): Value tensor. See Shape section for shape details.\n index (Tensor): Tensor containing mask values to be added to calculated\n attention. May be 2D or 3D; see Shape section for details.\n dim_size (int, optional): The batched target length sequence, i.e.\n :obj:`max_val + 1` of :attr:`index`. (default: :obj:`None`)\n dropout_p: dropout probability. If greater than 0.0, dropout is applied.\n\n Shape:\n - q: :math:`(S, H, E)` where S is sparsed dimension, H is the number of\n heads, and E is embedding dimension.\n - k: :math:`(S, H, E)` where S is sparsed dimension, H is the number of\n heads, and E is embedding dimension.\n - v: :math:`(S, H, O)` where S is sparsed dimension, H is the number of\n heads, and O is output dimension.\n - index: :math:`(S)` where S is sparsed dimension.\n - dim_size: must be :math:`(B \\times Nt)`\n\n - Output: attention values have shape :math:`(B, Nt, E)`; attention\n weights have shape :math:`(S, H)`\n \"\"\"\n dim = 0\n B, H, E = q.shape\n N = maybe_num_nodes(index, dim_size)\n # scores\n alpha = (q * k).sum(dim=-1) / math.sqrt(E)\n alpha = sparse_softmax(alpha, index, num_nodes=N, dim=dim)\n if dropout_p > 0.0:\n alpha = F.dropout(alpha, p=dropout_p)\n v *= alpha.view(-1, H, 1)\n # out\n out = torch.zeros((N, H, v.size(2)), dtype=v.dtype, device=v.device)\n add_index = broadcast(index, v, dim)\n out.scatter_add_(dim, add_index, v)\n return out, alpha\n", "meta": {"hexsha": "b6dc9cc154880b1deb3d98f14f03edffbf6158a5", "size": 6314, "ext": "py", "lang": "Python", "max_stars_repo_path": "tsl/nn/functional.py", "max_stars_repo_name": "TorchSpatiotemporal/tsl", "max_stars_repo_head_hexsha": "da13493b0cf83826bf41fe78a67e8d4ce1d7a8a0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2022-03-21T09:16:33.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T12:24:30.000Z", "max_issues_repo_path": "tsl/nn/functional.py", "max_issues_repo_name": "TorchSpatiotemporal/tsl", "max_issues_repo_head_hexsha": "da13493b0cf83826bf41fe78a67e8d4ce1d7a8a0", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "tsl/nn/functional.py", "max_forks_repo_name": "TorchSpatiotemporal/tsl", "max_forks_repo_head_hexsha": "da13493b0cf83826bf41fe78a67e8d4ce1d7a8a0", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.975308642, "max_line_length": 118, "alphanum_fraction": 0.6352549889, "include": true, "reason": "import numpy", "num_tokens": 1601, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230157, "lm_q2_score": 0.3812195662561499, "lm_q1q2_score": 0.1965644006249606}} {"text": "from __future__ import print_function, division, absolute_import\n\nimport os\nimport copy\nimport json\nfrom collections import OrderedDict\nfrom warnings import warn\nfrom six import iteritems, string_types\n\nfrom sympy import Basic, sympify, Symbol\nfrom numpy import bool_, float_\nfrom jsonschema import validate, ValidationError\nimport cobra\n\nimport cobrame\nfrom cobrame.util import me_model_interface, mu\n\ntry:\n # If cannot import SymbolicParameter, assume using cobrapy\n # versions <= 0.5.11\n from optlang.interface import SymbolicParameter\nexcept ImportError:\n from cobra.io.json import metabolite_from_dict, save_json_model\nelse:\n from cobra.io.json import save_json_model\n from cobra.io.dict import metabolite_from_dict\n\nmu_temp = Symbol('mu')\n\ncur_dir = os.path.dirname(os.path.abspath(__file__))\n\n\ndef save_json_me(me0, file_name):\n \"\"\"\n Save a stripped-down JSON version of the ME-model. This will exclude all of\n ME-Model information except the reaction stoichiometry information and the\n reaction bounds. Saving/loading a model in this format will thus occur much\n quicker, but limit the ability to edit the model and use most of its\n features.\n\n :param :class:`~cobrame.core.model.MEModel` me0:\n A full ME-model\n\n :param str or file-like object file_name:\n Filename of the JSON output\n\n :returns JSON-object:\n Stripped-down JSON representation of full ME-model\n \"\"\"\n me = copy.deepcopy(me0)\n\n for rxn in me.reactions:\n for met in rxn.metabolites:\n s = rxn._metabolites[met]\n if isinstance(s, Basic):\n rxn._metabolites[met] = str(s)\n if isinstance(rxn.lower_bound, Basic):\n rxn.lower_bound = str(rxn.lower_bound)\n if isinstance(rxn.upper_bound, Basic):\n rxn.upper_bound = str(rxn.upper_bound)\n\n for met in me.metabolites:\n if isinstance(met._bound, Basic):\n met._bound = str(met._bound)\n\n save_json_model(me, file_name)\n\n\ndef get_sympy_expression(value):\n \"\"\"\n Return sympy expression from json string using sympify\n\n\n mu is assumed to be positive but using sympify does not apply this\n assumption\"\"\"\n\n expression_value = sympify(value)\n return expression_value.subs(mu_temp, mu)\n\n\ndef get_numeric_from_string(string):\n try:\n return float(string)\n except ValueError:\n return get_sympy_expression(string)\n\n\ndef load_json_me(file_name):\n \"\"\"\n Load a stripped-down JSON version of the ME-model. This will exclude all of\n ME-Model information except the reaction stoichiometry information and the\n reaction bounds. Saving/loading a model in this format will thus occur much\n quicker, but limit the ability to edit the model and use most of its\n features.\n\n :param str or file-like object file_name:\n Filename of the JSON ME-model\n\n Returns\n -------\n :class:`cobra.core.model.Model`\n COBRA Model representation of the ME-model. This will not include\n all of the functionality of a :class:`~cobrame.core.model.MEModel` but\n will solve identically compared to the full model.\n \"\"\"\n if isinstance(file_name, string_types):\n with open(file_name, 'r') as f:\n obj = json.load(f)\n else:\n obj = file_name\n\n model = cobra.Model()\n\n # If cannot import SymbolicParameter, assume using cobrapy\n # versions <= 0.5.11. If versions >= 0.8.0 are used, a ME-model interface\n # must be assigned as the solver interface\n try:\n from optlang.interface import SymbolicParameter\n except ImportError:\n pass\n else:\n model.solver = me_model_interface\n\n default_reactions = [i.id for i in model.reactions]\n\n for k, v in iteritems(obj):\n if k in {'id', 'name'}:\n setattr(model, k, v)\n\n def _reaction_from_dict(reaction, model):\n new_reaction = cobra.Reaction()\n for k, v in iteritems(reaction):\n if k in {'objective_coefficient', 'reversibility', 'reaction'}:\n continue\n elif k == 'metabolites':\n new_reaction.add_metabolites(OrderedDict(\n (model.metabolites.get_by_id(str(met)),\n get_numeric_from_string(coeff))\n for met, coeff in iteritems(v)))\n elif k in {'upper_bound', 'lower_bound'}:\n v = get_numeric_from_string(v)\n setattr(new_reaction, k, v)\n else:\n setattr(new_reaction, k, v)\n return new_reaction\n\n model.add_metabolites(\n [metabolite_from_dict(metabolite) for metabolite in obj['metabolites']]\n )\n\n new_reactions = [\n _reaction_from_dict(reaction, model) for reaction in obj['reactions']]\n\n model.remove_reactions(default_reactions)\n model.add_reactions(new_reactions)\n\n return model\n\n# -----------------------------------------------------------------------------\n# Functions below here facilitate json dumping/loading of full ME-models with\n# all process_data/reaction info intact.\n_REQUIRED_REACTION_ATTRIBUTES = {\"id\", \"name\", \"metabolites\", \"lower_bound\",\n \"upper_bound\", \"objective_coefficient\",\n \"variable_kind\"}\n\n# Reaction types can have different attributes\n_REACTION_TYPE_DEPENDENCIES = \\\n {'MetabolicReaction': ['complex_data',\n 'stoichiometric_data',\n 'keff', 'reverse'],\n 'ComplexFormation': ['_complex_id',\n 'complex_data_id'],\n 'PostTranslationReaction':\n ['posttranslation_data'],\n 'TranscriptionReaction': ['transcription_data'],\n 'GenericFormationReaction': [],\n 'MEReaction': [],\n 'SummaryVariable': [],\n 'TranslationReaction': ['translation_data'],\n 'tRNAChargingReaction': ['tRNA_data']}\n\n_REQUIRED_PROCESS_DATA_ATTRIBUTES = {\"id\"}\n\n# Process data types have different attributes\n_PROCESS_DATA_TYPE_DEPENDENCIES = \\\n {'StoichiometricData': ['_stoichiometry', 'lower_bound', 'upper_bound',\n 'subreactions'],\n\n 'ComplexData': ['stoichiometry', 'complex_id', 'subreactions'],\n\n 'TranscriptionData': ['subreactions', 'nucleotide_sequence',\n 'RNA_products', 'RNA_polymerase'],\n\n 'TranslationData': ['subreactions', 'nucleotide_sequence', 'mRNA',\n 'protein'],\n\n 'tRNAData': ['subreactions', 'codon', 'RNA', 'amino_acid',\n 'synthetase', 'synthetase_keff'],\n\n 'TranslocationData': ['enzyme_dict', 'stoichiometry', 'keff',\n 'length_dependent_energy'],\n\n 'PostTranslationData': ['processed_protein_id', 'unprocessed_protein_id',\n 'propensity_scaling', 'aggregation_propensity',\n 'translocation', 'subreactions', 'surface_area',\n 'keq_folding', 'k_folding', 'biomass_type',\n 'translocation_multipliers'],\n\n 'SubreactionData': ['stoichiometry', 'enzyme', 'keff',\n 'element_contribution'],\n\n 'GenericData': ['component_list']\n }\n\n_REQUIRED_METABOLITE_ATTRIBUTES = {\"id\", \"name\", \"formula\"}\n\n_OPTIONAL_METABOLITE_ATTRIBUTES = {\"charge\", \"formula\", \"compartment\",\n \"_bound\", \"_constraint_sense\"}\n\n# Some metabolite types require additional attributes\n_METABOLITE_TYPE_DEPENDENCIES = \\\n {'TranscribedGene': ['left_pos', 'right_pos', 'strand', 'RNA_type',\n 'nucleotide_sequence'],\n 'ProcessedProtein': ['unprocessed_protein_id']\n }\n\n\ndef get_schema():\n with open(os.path.join(cur_dir, 'JSONSCHEMA'), 'r') as f:\n return json.load(f)\n\n\ndef _fix_type(value):\n \"\"\"convert possible types to str, float, and bool\"\"\"\n # Because numpy floats can not be pickled to json\n if isinstance(value, string_types):\n return str(value)\n if isinstance(value, float_):\n return float(value)\n if isinstance(value, bool_):\n return bool(value)\n if isinstance(value, set):\n return list(value)\n if isinstance(value, Basic):\n return str(value)\n if hasattr(value, 'id'):\n return str(value.id)\n # if value is None:\n # return ''\n return value\n\n\ndef _reaction_to_dict(reaction):\n new_reaction = {key: _fix_type(getattr(reaction, key))\n for key in _REQUIRED_REACTION_ATTRIBUTES\n if key != 'metabolites'}\n\n reaction_type = reaction.__class__.__name__\n new_reaction['reaction_type'] = {}\n new_reaction['reaction_type'][reaction_type] = {}\n\n for attribute in _REACTION_TYPE_DEPENDENCIES.get(reaction_type, []):\n reaction_attribute = getattr(reaction, attribute)\n\n new_reaction['reaction_type'][reaction_type][attribute] = \\\n _fix_type(reaction_attribute)\n\n # Add metabolites\n new_reaction['metabolites'] = {}\n for met, value in reaction.metabolites.items():\n new_reaction['metabolites'][met.id] = _fix_type(value)\n\n return new_reaction\n\n\ndef _process_data_to_dict(data):\n process_data_type = data.__class__.__name__\n\n new_data = {key: _fix_type(getattr(data, key))\n for key in _REQUIRED_PROCESS_DATA_ATTRIBUTES}\n\n new_data['process_data_type'] = {}\n new_data['process_data_type'][process_data_type] = {}\n new_process_data_type_dict = \\\n new_data['process_data_type'][process_data_type]\n\n special_list = ['subreactions', 'stoichiometry', 'enzyme_dict',\n 'surface_area', 'keq_folding' 'k_folding']\n\n for attribute in _PROCESS_DATA_TYPE_DEPENDENCIES[process_data_type]:\n if attribute not in special_list:\n data_attribute = getattr(data, attribute)\n\n new_process_data_type_dict[attribute] = _fix_type(data_attribute)\n\n elif attribute == 'enzyme_dict':\n new_process_data_type_dict[attribute] = {}\n for cplx, values in getattr(data, attribute).items():\n new_process_data_type_dict[attribute][cplx] = {}\n for property, value in values.items():\n new_process_data_type_dict[attribute][cplx][property] = \\\n _fix_type(value)\n else:\n new_process_data_type_dict[attribute] = {}\n for metabolite, coefficient in getattr(data, attribute).items():\n new_process_data_type_dict[attribute][metabolite] = \\\n _fix_type(coefficient)\n\n return new_data\n\n\ndef _metabolite_to_dict(metabolite):\n\n metabolite_type = metabolite.__class__.__name__\n\n new_metabolite = {key: _fix_type(getattr(metabolite, key))\n for key in _REQUIRED_METABOLITE_ATTRIBUTES}\n\n # Som metabolites require additional information to construct working\n # ME-model\n new_metabolite['metabolite_type'] = {}\n new_metabolite['metabolite_type'][metabolite_type] = {}\n for attribute in _METABOLITE_TYPE_DEPENDENCIES.get(metabolite_type, []):\n metabolite_attribute = getattr(metabolite, attribute)\n new_metabolite['metabolite_type'][metabolite_type][attribute] = \\\n metabolite_attribute\n\n return new_metabolite\n\n\ndef get_attribute_array(dictlist, type):\n if type == 'reaction':\n return [_reaction_to_dict(reaction) for reaction in dictlist]\n elif type == 'process_data':\n return [_process_data_to_dict(data) for data in dictlist]\n elif type == 'metabolite':\n return [_metabolite_to_dict(metabolite) for metabolite in dictlist]\n else:\n raise TypeError('Type must be reaction, process_data or metabolite')\n\n\ndef get_global_info_dict(global_info):\n new_global_info = {}\n for key, value in global_info.items():\n if type(value) != dict:\n new_global_info[key] = _fix_type(value)\n else:\n new_global_info[key] = value\n return new_global_info\n\n\ndef _to_dict(model):\n\n obj = dict(\n reactions=get_attribute_array(model.reactions, 'reaction'),\n process_data=get_attribute_array(model.process_data,\n 'process_data'),\n metabolites=get_attribute_array(model.metabolites, 'metabolite'),\n global_info=get_global_info_dict(model.global_info)\n )\n\n return obj\n\n\ndef save_full_me_model_json(model, file_name):\n \"\"\"\n Save a full JSON version of the ME-model. Saving/loading a model in this\n format can then be loaded to return a ME-model identical to the one saved.\n\n :param :class:`~cobrame.core.MEModel.MEModel` model:\n A full ME-model\n\n :param str or file-like object file_name:\n Filename of the JSON output\n\n :returns JSON-object:\n Full JSON representation of full ME-model\n \"\"\"\n\n should_close = False\n if isinstance(file_name, string_types):\n file_name = open(file_name, 'w')\n should_close = True\n\n json.dump(_to_dict(model), file_name)\n\n if should_close:\n file_name.close()\n\n\ndef add_metabolite_from_dict(model, metabolite_info):\n \"\"\"\n Builds metabolite instances defined in dictionary, then add it to the\n ME-model being constructed.\n\n ProcessedProteins require additional information\n \"\"\"\n\n metabolite_type_dict = metabolite_info['metabolite_type']\n if len(metabolite_type_dict) != 1:\n raise Exception('Only 1 metabolite_type in valid json')\n\n metabolite_type = list(metabolite_type_dict.keys())[0]\n\n # ProcessedProtein types require their unprocessed protein id as well\n if metabolite_type == 'ProcessedProtein':\n unprocessed_id = \\\n metabolite_type_dict['ProcessedProtein']['unprocessed_protein_id']\n\n metabolite_obj = \\\n getattr(cobrame, metabolite_type)(metabolite_info['id'],\n unprocessed_id)\n\n elif metabolite_type == 'TranscribedGene':\n rna_type = metabolite_type_dict['TranscribedGene']['RNA_type']\n nucleotide_sequence = \\\n metabolite_type_dict['TranscribedGene']['nucleotide_sequence']\n metabolite_obj = \\\n getattr(cobrame, metabolite_type)(metabolite_info['id'],\n rna_type, nucleotide_sequence)\n else:\n metabolite_obj = \\\n getattr(cobrame, metabolite_type)(metabolite_info['id'])\n\n for attribute in _REQUIRED_METABOLITE_ATTRIBUTES:\n setattr(metabolite_obj, attribute, metabolite_info[attribute])\n\n for attribute in _METABOLITE_TYPE_DEPENDENCIES.get(metabolite_type, []):\n value = metabolite_type_dict[metabolite_type][attribute]\n setattr(metabolite_obj, attribute, value)\n\n model.add_metabolites([metabolite_obj])\n\n\ndef add_process_data_from_dict(model, process_data_dict):\n \"\"\"\n Builds process_data instances defined in dictionary, then add it to the\n ME-model being constructed.\n\n Most classes of process_data only require an id and model to initiate them,\n but TranslationData, tRNAData, PostTranslationData and GenericData require\n additional inputs.\n\n \"\"\"\n\n # Create process data instances. Handel certain types individually\n id = process_data_dict['id']\n process_data_type_dict = process_data_dict['process_data_type']\n if len(process_data_type_dict) == 1:\n process_data_type, process_data_info = process_data_type_dict.popitem()\n else:\n print(process_data_type_dict, len(process_data_type_dict))\n raise Exception('Only 1 reaction_type in valid json')\n\n if process_data_type == 'TranslationData':\n mrna = process_data_info['mRNA']\n protein = process_data_info['protein']\n process_data = \\\n getattr(cobrame, process_data_type)(id, model, mrna, protein)\n elif process_data_type == 'tRNAData':\n amino_acid = process_data_info['amino_acid']\n rna = process_data_info['RNA']\n codon = process_data_info['codon']\n process_data = \\\n getattr(cobrame, process_data_type)(id, model, amino_acid, rna,\n codon)\n elif process_data_type == 'PostTranslationData':\n processed_protein_id = process_data_info['processed_protein_id']\n unprocessed_protein_id = process_data_info['unprocessed_protein_id']\n process_data = \\\n getattr(cobrame, process_data_type)(id, model,\n processed_protein_id,\n unprocessed_protein_id)\n elif process_data_type == 'GenericData':\n component_list = process_data_info['component_list']\n process_data = \\\n getattr(cobrame, process_data_type)(id, model, component_list)\n # Create reaction from generic process data\n process_data.create_reactions()\n else:\n process_data = getattr(cobrame, process_data_type)(id, model)\n\n # Set all of the required attributes using information in info dictionary\n for attribute in _REQUIRED_PROCESS_DATA_ATTRIBUTES:\n setattr(process_data, attribute, process_data_dict[attribute])\n\n # Some attributes depend on process data type. Set those here.\n for attribute in _PROCESS_DATA_TYPE_DEPENDENCIES.get(process_data_type,\n []):\n value = process_data_info[attribute]\n try:\n setattr(process_data, attribute, value)\n except AttributeError:\n # set to the hidden attribute instead\n setattr(process_data, '_' + attribute, value)\n\n\ndef add_reaction_from_dict(model, reaction_info):\n \"\"\"\n Builds reaction instances defined in dictionary, then add it to the\n ME-model being constructed.\n\n \"\"\"\n reaction_type_dict = reaction_info['reaction_type']\n\n if len(reaction_type_dict) == 1:\n reaction_type = list(reaction_type_dict.keys())[0]\n reaction_obj = getattr(cobrame, reaction_type)(reaction_info['id'])\n else:\n raise Exception('Only 1 reaction_type in valid json')\n\n for attribute in _REQUIRED_REACTION_ATTRIBUTES:\n # Metabolites are added to reactions using their update function,\n # skip setting metabolite stoichiometries here\n if attribute == 'metabolites':\n continue\n\n # upper and lower bounds may contain mu values. Handle that here\n value = reaction_info[attribute]\n if attribute in ['upper_bound', 'lower_bound']:\n value = get_sympy_expression(value)\n setattr(reaction_obj, attribute, value)\n\n # Some reactions are added to model when ME-models are initialized\n try:\n model.add_reactions([reaction_obj])\n except Exception:\n reaction_obj = model.reactions.get_by_id(reaction_obj.id)\n if reaction_type not in ['SummaryVariable',\n 'GenericFormationReaction']:\n warn('Reaction (%s) already in model' % reaction_obj.id)\n\n # These reactions types do not have update functions and need their\n # stoichiometries set explicitly .\n if reaction_type in ['SummaryVariable', 'MEReaction']:\n for key, value in reaction_info['metabolites'].items():\n reaction_obj.add_metabolites({key: get_sympy_expression(value)},\n combine=False)\n\n for attribute in _REACTION_TYPE_DEPENDENCIES.get(reaction_type, []):\n # Spontaneous reactions do no require complex_data\n if attribute == 'complex_data' and 'SPONT' in reaction_obj.id:\n continue\n\n value = reaction_type_dict[reaction_type][attribute]\n setattr(reaction_obj, attribute, value)\n\n if hasattr(reaction_obj, 'update'):\n reaction_obj.update()\n\n\ndef full_me_model_from_dict(obj):\n \"\"\"\n Validate and load JSON representation of the ME-model. This will return\n a full :class:`~cobrame.core.model.MEModel` object identical to the\n one saved.\n\n :param str or file-like object obj:\n JSON-serialized ME-model\n\n :returns :class:`~cobrame.core.model.MEModel`:\n Full COBRAme ME-model\n \"\"\"\n\n try:\n validate(obj, get_schema())\n except ValidationError:\n raise Exception('Must pass valid ME-model json file')\n\n model = cobrame.MEModel()\n\n for k, v in iteritems(obj):\n if k in {'id', 'name', 'global_info'}:\n setattr(model, k, v)\n\n for metabolite in obj['metabolites']:\n add_metabolite_from_dict(model, metabolite)\n\n for process_data in obj['process_data']:\n add_process_data_from_dict(model, process_data)\n\n for reaction in obj['reactions']:\n add_reaction_from_dict(model, reaction)\n\n model.update()\n\n return model\n\n\ndef load_full_me_model_json(file_name):\n\n with open(file_name, 'r') as f:\n model_dict = json.load(f)\n\n return full_me_model_from_dict(model_dict)\n", "meta": {"hexsha": "d821fac968f6bf5cf0cee8ac2fb27b8fe664ce09", "size": 20891, "ext": "py", "lang": "Python", "max_stars_repo_path": "cobrame/io/jsonme.py", "max_stars_repo_name": "zakandrewking/cobrame", "max_stars_repo_head_hexsha": "66fc05de462f1aa9ce79c9812f7a24457560510b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "cobrame/io/jsonme.py", "max_issues_repo_name": "zakandrewking/cobrame", "max_issues_repo_head_hexsha": "66fc05de462f1aa9ce79c9812f7a24457560510b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "cobrame/io/jsonme.py", "max_forks_repo_name": "zakandrewking/cobrame", "max_forks_repo_head_hexsha": "66fc05de462f1aa9ce79c9812f7a24457560510b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-10-07T08:39:29.000Z", "max_forks_repo_forks_event_max_datetime": "2019-10-07T08:39:29.000Z", "avg_line_length": 35.0520134228, "max_line_length": 79, "alphanum_fraction": 0.6549710402, "include": true, "reason": "from numpy,from sympy", "num_tokens": 4552, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230156, "lm_q2_score": 0.38121956625614994, "lm_q1q2_score": 0.19656440062496058}} {"text": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\nimport os\nimport sys\n\nimport argparse\n\nimport multiprocessing\nimport numpy as np\n\nimport torch\nfrom torch import nn, optim, Tensor\n\nfrom ctp.training.data import Data\nfrom ctp.training.batcher import Batcher\n\nfrom ctp.kernels import BaseKernel, GaussianKernel\n\nfrom ctp.smart.kb import NeuralKB\nfrom ctp.smart.simple import SimpleHoppy\n\nfrom ctp.reformulators import BaseReformulator\nfrom ctp.reformulators import StaticReformulator\nfrom ctp.reformulators import LinearReformulator\nfrom ctp.reformulators import AttentiveReformulator\nfrom ctp.reformulators import MemoryReformulator\nfrom ctp.reformulators import NTPReformulator\n\nfrom ctp.regularizers import N2, N3\nfrom ctp.evaluation import evaluate_slow as evaluate\nfrom ctp.evaluation import evaluate_naive\nfrom ctp.evaluation import evaluate_on_countries\n\nfrom typing import Tuple, Dict, Optional\n\nimport logging\n\nlogger = logging.getLogger(os.path.basename(sys.argv[0]))\nnp.set_printoptions(linewidth=48, precision=5, suppress=True)\n\ntorch.set_num_threads(multiprocessing.cpu_count())\n# torch.autograd.set_detect_anomaly(True)\n\n\ndef metrics_to_str(metrics):\n return f'MRR {metrics[\"MRR\"]:.6f}\\tH@1 {metrics[\"hits@1\"]:.6f}\\tH@3 {metrics[\"hits@3\"]:.6f}\\t' \\\n f'H@5 {metrics[\"hits@5\"]:.6f}\\tH@10 {metrics[\"hits@10\"]:.6f}'\n\n\ndef decode(vector: Tensor,\n kernel: BaseKernel,\n predicate_embeddings: nn.Module) -> Tuple[int, float]:\n weight = predicate_embeddings.weight\n k = kernel.pairwise(vector, weight)[0, :]\n top_idx = k.argmax(dim=0).item()\n top_score = k[top_idx].item()\n return top_idx, top_score\n\n\ndef show_rules(model: SimpleHoppy,\n kernel: BaseKernel,\n predicate_embeddings: nn.Embedding,\n predicate_to_idx: Dict[str, int],\n device: Optional[torch.device] = None):\n idx_to_predicate = {i: p for p, i in predicate_to_idx.items()}\n\n pred_idx_pair_lst = sorted(predicate_to_idx.items(), key=lambda kv: kv[1])\n\n for p, i in pred_idx_pair_lst:\n indices = torch.tensor([i], dtype=torch.long, device=device)\n\n p_emb = predicate_embeddings(indices)\n\n hops_lst = [p for p in model.hops_lst]\n\n for reformulator, is_reversed in hops_lst:\n def _to_pair(hop: Tensor) -> Tuple[str, float]:\n idx, score = decode(hop, kernel, predicate_embeddings)\n rel = idx_to_predicate[idx]\n return rel, score\n\n hop_tensor_lst = [hop for hop in reformulator(p_emb)]\n\n r_hops = [_to_pair(hop) for hop in hop_tensor_lst]\n print(p, ' ← ', ', '.join(f'({a} {b:.4f})' for a, b in r_hops), is_reversed)\n return\n\n\ndef main(argv):\n parser = argparse.ArgumentParser('KBC Research', formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n\n parser.add_argument('--train', action='store', required=True, type=str)\n\n parser.add_argument('--dev', action='store', type=str, default=None)\n parser.add_argument('--test', action='store', type=str, default=None)\n\n parser.add_argument('--test-i', action='store', type=str, default=None)\n parser.add_argument('--test-ii', action='store', type=str, default=None)\n\n parser.add_argument('--embedding-size', '-k', action='store', type=int, default=20)\n parser.add_argument('--k-max', '-K', action='store', type=int, default=3)\n\n parser.add_argument('--hops', nargs='+', type=str, default=['1', '2'])\n\n # training params\n parser.add_argument('--epochs', '-e', action='store', type=int, default=100)\n parser.add_argument('--learning-rate', '-l', action='store', type=float, default=0.001)\n\n parser.add_argument('--batch-size', '-b', action='store', type=int, default=8)\n parser.add_argument('--eval-batch-size', '-E', action='store', type=int, default=None)\n\n parser.add_argument('--optimizer', '-o', action='store', type=str, default='adam',\n choices=['adagrad', 'adam', 'sgd'])\n\n parser.add_argument('--N2', action='store', type=float, default=None)\n parser.add_argument('--N3', action='store', type=float, default=None)\n\n parser.add_argument('--reformulator', '-r', action='store', type=str, default='linear',\n choices=['static', 'linear', 'attentive', 'memory', 'ntp'])\n parser.add_argument('--nb-rules', '-R', action='store', type=int, default=4)\n\n # parser.add_argument('--GNTP-R', action='store', type=int, default=None)\n\n parser.add_argument('--seed', action='store', type=int, default=0)\n\n parser.add_argument('--validate-every', '-V', action='store', type=int, default=None)\n parser.add_argument('--input-type', '-I', action='store', type=str, default='standard',\n choices=['standard', 'reciprocal'])\n\n parser.add_argument('--init-size', '-i', action='store', type=float, default=1.0)\n\n parser.add_argument('--init', action='store', type=str, default='uniform')\n parser.add_argument('--ref-init', action='store', type=str, default='uniform')\n\n parser.add_argument('--load', action='store', type=str, default=None)\n parser.add_argument('--save', action='store', type=str, default=None)\n\n parser.add_argument('--nb-negatives', action='store', type=int, default=1)\n\n parser.add_argument('--quiet', '-q', action='store_true', default=False)\n\n parser.add_argument('--freeze-entities', '-f', action='store', type=int, default=None)\n parser.add_argument('--refresh-interval', '--refresh', action='store', type=int, default=None)\n parser.add_argument('--index-type', '--index', action='store', type=str, default='faiss',\n choices=['np', 'faiss', 'nms'])\n\n parser.add_argument('--lower-bound', '--lb', action='store', type=float, default=-1.0)\n parser.add_argument('--upper-bound', '--ub', action='store', type=float, default=1.0)\n\n parser.add_argument('--slow-eval', action='store_true', default=False)\n\n parser.add_argument('--show', action='store_true', default=False)\n\n parser.add_argument('--fix-entities', action='store_true', default=False)\n parser.add_argument('--fix-predicates', action='store_true', default=False)\n\n args = parser.parse_args(argv)\n\n import pprint\n pprint.pprint(vars(args))\n\n train_path = args.train\n dev_path = args.dev\n test_path = args.test\n\n test_i_path = args.test_i\n test_ii_path = args.test_ii\n\n embedding_size = args.embedding_size\n k_max = args.k_max\n\n hops_str = args.hops\n\n nb_epochs = args.epochs\n learning_rate = args.learning_rate\n batch_size = args.batch_size\n optimizer_name = args.optimizer\n\n N2_weight = args.N2\n N3_weight = args.N3\n\n reformulator_type = args.reformulator\n nb_rules = args.nb_rules\n\n # gntp_R = args.GNTP_R\n\n eval_batch_size = batch_size if args.eval_batch_size is None else args.eval_batch_size\n\n seed = args.seed\n\n validate_every = args.validate_every\n input_type = args.input_type\n init_size = args.init_size\n\n init_type = args.init\n ref_init_type = args.ref_init\n\n load_path = args.load\n save_path = args.save\n\n nb_neg = args.nb_negatives\n is_quiet = args.quiet\n\n freeze_entities = args.freeze_entities\n refresh_interval = args.refresh_interval\n index_type = args.index_type\n\n lower_bound = args.lower_bound\n upper_bound = args.upper_bound\n\n slow_eval = args.slow_eval\n\n evaluate_ = evaluate_naive if slow_eval else evaluate\n\n is_show = args.show\n\n is_fix_entities = args.fix_entities\n is_fix_predicates = args.fix_predicates\n\n # set the seeds\n np.random.seed(seed)\n random_state = np.random.RandomState(seed)\n torch.manual_seed(seed)\n\n if torch.cuda.is_available():\n torch.cuda.manual_seed(seed)\n\n rs = np.random.RandomState(seed)\n\n device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n logger.info(f'Device: {device}')\n\n if torch.cuda.is_available():\n torch.set_default_tensor_type(torch.cuda.FloatTensor)\n\n data = Data(train_path=train_path, dev_path=dev_path, test_path=test_path,\n test_i_path=test_i_path, test_ii_path=test_ii_path, input_type=input_type)\n\n triples_name_pairs = [\n (data.dev_triples, 'dev'),\n (data.test_triples, 'test'),\n (data.test_i_triples, 'test-I'),\n (data.test_ii_triples, 'test-II'),\n ]\n\n entity_embeddings = nn.Embedding(data.nb_entities, embedding_size, sparse=True)\n predicate_embeddings = nn.Embedding(data.nb_predicates, embedding_size, sparse=True)\n\n print('Entity Embeddings', entity_embeddings)\n print('Predicate Embeddings', predicate_embeddings)\n\n if init_type in {'uniform'}:\n nn.init.uniform_(entity_embeddings.weight, lower_bound, upper_bound)\n nn.init.uniform_(predicate_embeddings.weight, lower_bound, upper_bound)\n\n nn.init.uniform_(entity_embeddings.weight, lower_bound, upper_bound)\n nn.init.uniform_(predicate_embeddings.weight, lower_bound, upper_bound)\n\n entity_embeddings.weight.data *= init_size\n predicate_embeddings.weight.data *= init_size\n\n if freeze_entities is not None:\n entity_embeddings.weight.requires_grad = False\n\n if is_fix_entities is True:\n entity_embeddings.weight.requires_grad = False\n\n if is_fix_predicates is True:\n predicate_embeddings.weight.requires_grad = False\n\n kernel = GaussianKernel(slope=1.0)\n\n fact_rel = torch.tensor([data.predicate_to_idx[p] for (_, p, _) in data.train_triples],\n dtype=torch.long, device=device)\n fact_arg1 = torch.tensor([data.entity_to_idx[s] for (s, _, _) in data.train_triples],\n dtype=torch.long, device=device)\n fact_arg2 = torch.tensor([data.entity_to_idx[o] for (_, _, o) in data.train_triples],\n dtype=torch.long, device=device)\n facts = [fact_rel, fact_arg1, fact_arg2]\n\n base_model = NeuralKB(entity_embeddings=entity_embeddings, predicate_embeddings=predicate_embeddings,\n k=k_max, facts=facts, kernel=kernel, device=device,\n index_type=index_type, refresh_interval=refresh_interval).to(device)\n\n memory: Dict[int, MemoryReformulator.Memory] = {}\n\n def make_hop(s: str) -> Tuple[BaseReformulator, bool]:\n nonlocal memory\n if s.isdigit():\n nb_hops, is_reversed = int(s), False\n else:\n nb_hops, is_reversed = int(s[:-1]), True\n res = None\n if reformulator_type in {'static'}:\n res = StaticReformulator(nb_hops, embedding_size, init_name=ref_init_type,\n lower_bound=lower_bound, upper_bound=upper_bound)\n elif reformulator_type in {'linear'}:\n res = LinearReformulator(nb_hops, embedding_size, init_name=ref_init_type,\n lower_bound=lower_bound, upper_bound=upper_bound)\n elif reformulator_type in {'attentive'}:\n res = AttentiveReformulator(nb_hops, predicate_embeddings, init_name=ref_init_type,\n lower_bound=lower_bound, upper_bound=upper_bound)\n elif reformulator_type in {'memory'}:\n if nb_hops not in memory:\n memory[nb_hops] = MemoryReformulator.Memory(nb_hops, nb_rules, embedding_size, init_name=ref_init_type)\n\n res = MemoryReformulator(memory[nb_hops])\n elif reformulator_type in {'ntp'}:\n res = NTPReformulator(nb_hops=nb_hops, embedding_size=embedding_size,\n kernel=kernel, init_name=ref_init_type,\n lower_bound=lower_bound, upper_bound=upper_bound)\n assert res is not None\n return res, is_reversed\n\n hops_lst = [make_hop(s) for s in hops_str]\n\n # model = MultiHoppy(model=base_model, entity_embeddings=entity_embeddings, hops_lst=hops_lst).to(device)\n # model = SimpleHoppy(model=base_model, entity_embeddings=entity_embeddings, hops_lst=hops_lst).to(device)\n model = SimpleHoppy(model=base_model, entity_embeddings=entity_embeddings, hops_lst=hops_lst).to(device)\n\n def scoring_function(batch_xs: np.ndarray,\n batch_xp: np.ndarray,\n batch_xo: np.ndarray) -> np.ndarray:\n with torch.no_grad():\n tensor_xs = torch.tensor(batch_xs, dtype=torch.long, device=device)\n tensor_xp = torch.tensor(batch_xp, dtype=torch.long, device=device)\n tensor_xo = torch.tensor(batch_xo, dtype=torch.long, device=device)\n\n tensor_xs_emb = entity_embeddings(tensor_xs)\n tensor_xp_emb = predicate_embeddings(tensor_xp)\n tensor_xo_emb = entity_embeddings(tensor_xo)\n\n scores_ = model.score(tensor_xp_emb, tensor_xs_emb, tensor_xo_emb)\n return scores_.cpu().numpy()\n\n print('Model Params:', [p.shape for p in model.parameters()])\n\n params_lst = {p for p in model.parameters()} | \\\n ({entity_embeddings.weight} if is_fix_entities is False else set()) | \\\n ({predicate_embeddings.weight} if is_fix_predicates is False else set())\n\n params = nn.ParameterList(params_lst).to(device)\n\n if load_path is not None:\n model.load_state_dict(torch.load(load_path))\n\n for tensor in params_lst:\n logger.info(f'\\t{tensor.size()}\\t{tensor.device}')\n\n optimizer_factory = {\n 'adagrad': lambda arg: optim.Adagrad(arg, lr=learning_rate),\n 'adam': lambda arg: optim.Adam(arg, lr=learning_rate),\n 'sgd': lambda arg: optim.SGD(arg, lr=learning_rate)\n }\n\n assert optimizer_name in optimizer_factory\n optimizer = optimizer_factory[optimizer_name](params)\n\n # loss_function = nn.BCELoss(reduction=\"sum\")\n loss_function = nn.BCELoss()\n\n N2_reg = N2() if N2_weight is not None else None\n N3_reg = N3() if N3_weight is not None else None\n\n for epoch_no in range(1, nb_epochs + 1):\n batcher = Batcher(data, batch_size, 1, random_state)\n nb_batches = len(batcher.batches)\n\n if freeze_entities is not None and is_fix_entities is False and epoch_no > freeze_entities:\n entity_embeddings.weight.requires_grad = True\n\n epoch_loss_values = []\n for batch_no, (batch_start, batch_end) in enumerate(batcher.batches, 1):\n xp_batch_np, xs_batch_np, xo_batch_np, xi_batch_np = batcher.get_batch(batch_start, batch_end)\n t = xp_batch_np.shape[0]\n\n assert nb_neg > 0\n\n xp_exp_np = np.repeat(xp_batch_np, nb_neg * 3 + 1)\n xs_exp_np = np.repeat(xs_batch_np, nb_neg * 3 + 1)\n xo_exp_np = np.repeat(xo_batch_np, nb_neg * 3 + 1)\n xi_exp_np = np.repeat(xi_batch_np, nb_neg * 3 + 1)\n\n xt_exp_np = np.zeros_like(xp_exp_np)\n xt_exp_np[0::nb_neg * 3 + 1] = 1\n\n for i in range(t):\n a_ = rs.permutation(data.nb_entities)\n b_ = rs.permutation(data.nb_entities)\n\n c_ = rs.permutation(data.nb_entities)\n d_ = rs.permutation(data.nb_entities)\n\n while a_.shape[0] < nb_neg:\n a_ = np.concatenate([a_, rs.permutation(data.nb_entities)])\n b_ = np.concatenate([b_, rs.permutation(data.nb_entities)])\n\n c_ = np.concatenate([c_, rs.permutation(data.nb_entities)])\n d_ = np.concatenate([d_, rs.permutation(data.nb_entities)])\n\n a = a_[:nb_neg]\n b = b_[:nb_neg]\n c = c_[:nb_neg]\n d = d_[:nb_neg]\n\n xs_exp_np[(i * nb_neg * 3) + i + 1:(i * nb_neg * 3) + nb_neg + i + 1] = a\n xo_exp_np[(i * nb_neg * 3) + nb_neg + i + 1:(i * nb_neg * 3) + nb_neg * 2 + i + 1] = b\n\n xs_exp_np[(i * nb_neg * 3) + nb_neg * 2 + i + 1:(i * nb_neg * 3) + nb_neg * 3 + i + 1] = c\n xo_exp_np[(i * nb_neg * 3) + nb_neg * 2 + i + 1:(i * nb_neg * 3) + nb_neg * 3 + i + 1] = d\n\n xp_batch = torch.tensor(xp_exp_np, dtype=torch.long, device=device)\n xs_batch = torch.tensor(xs_exp_np, dtype=torch.long, device=device)\n xo_batch = torch.tensor(xo_exp_np, dtype=torch.long, device=device)\n xi_batch = torch.tensor(xi_exp_np, dtype=torch.long, device=device)\n xt_batch = torch.tensor(xt_exp_np, dtype=torch.float32, device=device)\n\n # Disable masking\n # xi_batch = None\n\n xp_batch_emb = predicate_embeddings(xp_batch)\n xs_batch_emb = entity_embeddings(xs_batch)\n xo_batch_emb = entity_embeddings(xo_batch)\n\n factors = [model.factor(e) for e in [xp_batch_emb, xs_batch_emb, xo_batch_emb]]\n\n scores = model.score(xp_batch_emb, xs_batch_emb, xo_batch_emb, mask_indices=xi_batch)\n # scores = base_model.score(xp_batch_emb, xs_batch_emb, xo_batch_emb, mask_indices=xi_batch)\n\n # print(scores)\n loss = loss_function(scores, xt_batch)\n\n loss += N2_weight * N2_reg(factors) if N2_weight is not None else 0.0\n loss += N3_weight * N3_reg(factors) if N3_weight is not None else 0.0\n\n loss.backward()\n optimizer.step()\n optimizer.zero_grad()\n\n loss_value = loss.item()\n epoch_loss_values += [loss_value]\n\n if not is_quiet:\n logger.info(f'Epoch {epoch_no}/{nb_epochs}\\tBatch {batch_no}/{nb_batches}\\tLoss {loss_value:.6f}')\n\n loss_mean, loss_std = np.mean(epoch_loss_values), np.std(epoch_loss_values)\n logger.info(f'Epoch {epoch_no}/{nb_epochs}\\tLoss {loss_mean:.4f} ± {loss_std:.4f}')\n\n if validate_every is not None and epoch_no % validate_every == 0:\n if 'countries' in train_path:\n dev_auc = evaluate_on_countries('dev', data.entity_to_idx, data.predicate_to_idx, scoring_function)\n print('Last AUC-PR (dev) {:.4f}'.format(dev_auc))\n\n test_auc = evaluate_on_countries('test', data.entity_to_idx, data.predicate_to_idx, scoring_function)\n print('Last AUC-PR (test) {:.4f}'.format(test_auc))\n else:\n for triples, name in [(t, n) for t, n in triples_name_pairs if len(t) > 0]:\n metrics = evaluate_(entity_embeddings=entity_embeddings, predicate_embeddings=predicate_embeddings,\n test_triples=triples, all_triples=data.all_triples,\n entity_to_index=data.entity_to_idx, predicate_to_index=data.predicate_to_idx,\n model=model, batch_size=eval_batch_size, device=device)\n logger.info(f'Epoch {epoch_no}/{nb_epochs}\\t{name} results\\t{metrics_to_str(metrics)}')\n\n if is_show is True:\n with torch.no_grad():\n # print(entity_embeddings.weight)\n show_rules(model=model, kernel=kernel, predicate_embeddings=predicate_embeddings,\n predicate_to_idx=data.predicate_to_idx, device=device)\n\n if 'countries' in train_path:\n dev_auc = evaluate_on_countries('dev', data.entity_to_idx, data.predicate_to_idx, scoring_function)\n print('Last AUC-PR (dev) {:.4f}'.format(dev_auc))\n\n test_auc = evaluate_on_countries('test', data.entity_to_idx, data.predicate_to_idx, scoring_function)\n print('Last AUC-PR (test) {:.4f}'.format(test_auc))\n else:\n for triples, name in [(t, n) for t, n in triples_name_pairs if len(t) > 0]:\n metrics = evaluate_(entity_embeddings=entity_embeddings, predicate_embeddings=predicate_embeddings,\n test_triples=triples, all_triples=data.all_triples,\n entity_to_index=data.entity_to_idx, predicate_to_index=data.predicate_to_idx,\n model=model, batch_size=eval_batch_size, device=device)\n logger.info(f'Final \\t{name} results\\t{metrics_to_str(metrics)}')\n\n if is_show is True:\n with torch.no_grad():\n show_rules(model=model, kernel=kernel, predicate_embeddings=predicate_embeddings,\n predicate_to_idx=data.predicate_to_idx, device=device)\n\n if save_path is not None:\n torch.save(model.state_dict(), save_path)\n\n logger.info(\"Training finished\")\n\n\nif __name__ == '__main__':\n logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)\n logging.getLogger('nmslib').setLevel(logging.WARNING)\n print(' '.join(sys.argv))\n main(sys.argv[1:])\n", "meta": {"hexsha": "5cca8fcf0ddf50985e812f091191bade10fdd889", "size": 20601, "ext": "py", "lang": "Python", "max_stars_repo_path": "bin/hoppy-cli.py", "max_stars_repo_name": "Vikicsizmadia/ctp", "max_stars_repo_head_hexsha": "d88fdfecf4b90ee42e6137a9767226c0d35b19a3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 41, "max_stars_repo_stars_event_min_datetime": "2020-07-14T15:44:20.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-25T10:33:07.000Z", "max_issues_repo_path": "bin/hoppy-cli.py", "max_issues_repo_name": "Vikicsizmadia/ctp", "max_issues_repo_head_hexsha": "d88fdfecf4b90ee42e6137a9767226c0d35b19a3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2020-12-28T05:57:12.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-09T01:05:06.000Z", "max_forks_repo_path": "bin/hoppy-cli.py", "max_forks_repo_name": "Vikicsizmadia/ctp", "max_forks_repo_head_hexsha": "d88fdfecf4b90ee42e6137a9767226c0d35b19a3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 12, "max_forks_repo_forks_event_min_datetime": "2020-07-14T22:56:46.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-17T02:40:10.000Z", "avg_line_length": 41.119760479, "max_line_length": 119, "alphanum_fraction": 0.6502596961, "include": true, "reason": "import numpy", "num_tokens": 4871, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230156, "lm_q2_score": 0.38121956625614994, "lm_q1q2_score": 0.19656440062496058}} {"text": "\"\"\"\nClass for holding the NN and processing the output\n\nArthur McCray\namccray@anl.gov\n\"\"\"\n\nimport numpy as np\nimport scipy.ndimage as ndi\nimport torch\nimport torch.nn.functional as F\n\nfrom smallUnet import smallUnet\n\n\nclass trained_NN(object):\n def __init__(self, path, cuda=True, gpu=0):\n model = smallUnet()\n if gpu == \"cpu\":\n self.cuda = False\n else:\n self.cuda = cuda\n self.gpu = gpu\n self.scale = None\n self.prediction = None\n if self.cuda:\n model.load_state_dict(torch.load(path))\n model.cuda(gpu)\n else:\n print(\"Loading the NN on the CPU\")\n model.load_state_dict(torch.load(path, map_location=torch.device(\"cpu\")))\n\n model.eval()\n self.model = model\n\n def find_skyrms(self, image, tilt_dir, thresh=0.5, scale=None):\n \"\"\"Makes a prediction using the NN on image, then also finds the centers of the\n found skyrmions on that image. To just find the skyrmions on a previously made\n prediction with a new threshold value, update model.threshold and run\n model.get_centers() which will return centers.\n\n The model.prediction will of course be scaled by self.scale, and in get_centers\n the rescaling will be applied\n\n Args:\n image (ndarray): Image from which to find skyrms\n tilt_dir (float): direction along which sample is tilted\n thresh (float, optional): Prediction threshold. Defaults to 0.5.\n scale (float, optional): Scaling factor of image before prediction. Scale is\n the factor by which the image will be rescaled before inputting into the\n NN. Output skyrmion locations will be appropriately rescaled back to the\n original input image.\n\n Returns:\n ndarray: [[y1,x1], [y2,x2], ...] array of skyrmion center positions.\n \"\"\"\n self.threshold = thresh\n ## apply rotation\n dimy, dimx = image.shape\n if scale is not None:\n self.scale = scale\n if self.scale is not None:\n dimy, dimx = round(dimy * scale), round(dimx * scale)\n image = norm_image(rescale(image, scale))\n\n imagerot = ndi.rotate(image, 90 + tilt_dir)\n image2 = center_pad_pwr2(imagerot)\n\n # Convert to 4D tensor (required, even if it is a single image)\n image4d = image2[None, None, ...]\n # Convert to pytorch format and move to GPU\n if self.cuda:\n image4d_ = torch.from_numpy(image4d).float().cuda(self.gpu)\n else:\n image4d_ = torch.from_numpy(image4d).float()\n\n # make a prediction\n prediction = self.model.forward(image4d_)\n prediction = F.softmax(prediction, dim=1).cpu().detach().numpy()\n prediction = np.transpose(prediction, [0, 2, 3, 1])\n # get coordinates\n prediction2 = ndi.rotate(\n prediction[0, :, :, :], -1 * (90 + tilt_dir), axes=(0, 1)\n )\n\n prediction2 = center_crop_im(\n prediction2, (dimy, dimx), dim_order_in=\"channels_last\"\n )[:, :, ::-1]\n self.prediction = prediction2\n centers = self.get_centers()\n return centers\n\n def rng_seed(self, seed):\n torch.manual_seed(seed)\n np.random.seed(seed)\n torch.cuda.empty_cache()\n torch.cuda.manual_seed(seed)\n torch.backends.cudnn.deterministic = True\n torch.backends.cudnn.benchmark = False\n\n def get_centers(self):\n FA = FindObjects(self.prediction[None, ...], threshold=self.threshold)\n coords = FA.get_all_coordinates()\n centers = coords[0][:, :2]\n if self.scale is not None:\n centers /= self.scale\n\n return centers\n\n\ndef center_pad_pwr2(image):\n dimy, dimx = np.shape(image)\n final_dim = int(2 ** np.ceil(np.log2(max(dimy, dimx))))\n padl = int(np.floor((final_dim - dimx) / 2))\n padr = int(np.ceil((final_dim - dimx) / 2))\n padt = int(np.floor((final_dim - dimy) / 2))\n padb = int(np.ceil((final_dim - dimy) / 2))\n return np.pad(image, ((padt, padb), (padl, padr)))\n\n\ndef center_crop_im(image, shape, dim_order_in=\"channels_last\"):\n if image.ndim == 2:\n dimy, dimx = image.shape\n elif image.ndim == 3:\n if dim_order_in == \"channels_last\":\n dimy, dimx, dimz = image.shape\n elif dim_order_in == \"channels_first\":\n dimz, dimy, dimx = image.shape\n\n dyf, dxf = shape\n cropl = int(np.floor((dimx - dxf) / 2))\n cropr = int(np.ceil((dimx - dxf) / 2))\n cropt = int(np.floor((dimy - dyf) / 2))\n cropb = int(np.ceil((dimy - dyf) / 2))\n if dim_order_in == \"channels_last\":\n return image[cropt:-cropb, cropl:-cropr]\n elif dim_order_in == \"channels_first\":\n return image[:, cropt:-cropb, cropl:-cropr]\n\n\ndef norm_image(image):\n \"\"\"Normalize image intensities to between 0 and 1\"\"\"\n image = image - np.min(image)\n image = image / np.max(image)\n return image\n\n\nclass FindObjects:\n \"\"\"\n Transforms pixel data from NN output into coordinate data\n \"\"\"\n\n def __init__(self, nn_output, threshold=0.5, dist_edge=5, dim_order=\"channel_last\"):\n\n if nn_output.shape[-1] == 1: # Add background class for 1-channel data\n nn_output_b = 1 - nn_output\n nn_output = np.concatenate(\n (nn_output[:, :, :, None], nn_output_b[:, :, :, None]), axis=3\n )\n if dim_order == \"channel_first\": # make channel dim the last dim\n nn_output = np.transpose(nn_output, (0, 2, 3, 1))\n elif dim_order == \"channel_last\":\n pass\n else:\n raise NotImplementedError(\n 'For dim_order, use \"channel_first\" (e.g. pytorch)',\n 'or \"channel_last\" (e.g. tensorflow)',\n )\n self.nn_output = nn_output\n self.threshold = threshold\n self.dist_edge = dist_edge\n\n def get_all_coordinates(self):\n \"\"\"Extract all center coordinates in image via CoM method & store data as a\n dictionary (key: frame number)\"\"\"\n\n def find_com(image_data):\n \"\"\"Find objects via center of mass methods\"\"\"\n labels, nlabels = ndi.label(image_data)\n coordinates = np.array(\n ndi.center_of_mass(image_data, labels, np.arange(nlabels) + 1)\n )\n coordinates = coordinates.reshape(coordinates.shape[0], 2)\n return coordinates\n\n d_coord = {}\n for i, decoded_img in enumerate(self.nn_output):\n coordinates = np.empty((0, 2))\n category = np.empty((0, 1))\n # we assume that class backgrpund is always the last one\n for ch in range(decoded_img.shape[2] - 1):\n decoded_img_c = np.array(\n (decoded_img[:, :, ch] > self.threshold), dtype=\"int\"\n )\n\n dilated_img_c = ndi.binary_dilation(decoded_img_c, iterations=2)\n coord = find_com(dilated_img_c)\n coord_ch = self.rem_edge_coord(coord)\n category_ch = np.zeros((coord_ch.shape[0], 1)) + ch\n coordinates = np.append(coordinates, coord_ch, axis=0)\n category = np.append(category, category_ch, axis=0)\n d_coord[i] = np.concatenate((coordinates, category), axis=1)\n return d_coord\n\n def rem_edge_coord(self, coordinates):\n \"\"\"Remove coordinates at the image edges\"\"\"\n\n def coord_edges(coordinates, w, h):\n return [\n coordinates[0] > w - self.dist_edge,\n coordinates[0] < self.dist_edge,\n coordinates[1] > h - self.dist_edge,\n coordinates[1] < self.dist_edge,\n ]\n\n w, h = self.nn_output.shape[1:3]\n coord_to_rem = [\n idx for idx, c in enumerate(coordinates) if any(coord_edges(c, w, h))\n ]\n coord_to_rem = np.array(coord_to_rem, dtype=int)\n coordinates = np.delete(coordinates, coord_to_rem, axis=0)\n return coordinates\n", "meta": {"hexsha": "6626618b749090da97e4c6bd403010077d389911", "size": 8102, "ext": "py", "lang": "Python", "max_stars_repo_path": "trained_NN.py", "max_stars_repo_name": "Art-MC/SKX_NN", "max_stars_repo_head_hexsha": "02d5089ea9c4b3ca7c1878e1d9a5811f5da9f6bd", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "trained_NN.py", "max_issues_repo_name": "Art-MC/SKX_NN", "max_issues_repo_head_hexsha": "02d5089ea9c4b3ca7c1878e1d9a5811f5da9f6bd", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "trained_NN.py", "max_forks_repo_name": "Art-MC/SKX_NN", "max_forks_repo_head_hexsha": "02d5089ea9c4b3ca7c1878e1d9a5811f5da9f6bd", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.331838565, "max_line_length": 88, "alphanum_fraction": 0.5908417675, "include": true, "reason": "import numpy,import scipy", "num_tokens": 1959, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230156, "lm_q2_score": 0.38121956625614994, "lm_q1q2_score": 0.19656440062496058}} {"text": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n# ====================================================\n# \n# Module : 3D Depth Segmentation\n#\n# Written by hepheir@gmail.com\n# Last updated : Oct 27 2019\n#\n# ====================================================\n#\n# Process order\n#\n# 1. Breakage mesh : (3D, 3D, 3D)\n# 1-1. Sort facets into front, slice, or rear areas.\n#\n# 2. Cutting mesh : (3D, 2D, 3D)\n# 2-1. Separate each facet in slice area (after breakage)\n# into 1 line, and 2 small facets\n#\n# ====================================================\n\nfrom stl import mesh\nimport stl\nimport numpy as np\n\n# ====================================================\n\ndef macro(obj):\n assert isinstance(obj,mesh.Mesh)\n breakage = _breakage(obj)\n cutting = _cutting(breakage)\n return np.array(cutting)\n\n# ====================================================\n\ndef _breakage(obj):\n z = obj.z\n n = obj.normals\n front,section_breakage,rear = [],[],[]\n\n for i in range(obj.__len__()):\n # Front or behind the xy-surface\n isFront = isRear = False\n for _z in z[i]:\n isFront |= (_z >= 0)\n isRear |= (_z <= 0)\n # - Find slices\n if isFront and isRear:\n section_breakage.append(obj.data[i])\n # - Find fronts and behinds\n elif n[i,2] > 0:\n if isFront:\n front.append(obj.data[i])\n if isRear:\n rear.append(obj.data[i])\n return front,section_breakage,rear\n\ndef _cutting(breakage):\n \"\"\"breakage 과정에서 section으로 분류된 facet의 후처리.\n - 단면에 걸치는 Facet을 모두 단면을 따라 정밀하게 3분할 및 front/rear로의 재분배.\n - 처리 이후 section에는 facet data가 아닌 2D 선분정보만 남게 됨.\n (front와 rear의 데이터형식은 변화없음.)\"\"\"\n\n def where_z_is_0(v0,v1):\n \"\"\"두 벡터가 이루는 선분 상에서 z=0인 점을 계산.\"\"\"\n x0,y0,z0 = v0\n x1,y1,z1 = v1\n x = (x0*z1 - x1*z0) / (z1 - z0)\n y = (y0*z1 - y1*z0) / (z1 - z0)\n return [x,y,0]\n\n front, section_breakage, rear = breakage\n section_cutting = []\n\n new_data = new_vectors = None\n i = j = k = A = B = C = z = None\n\n for normal,vectors,attr in section_breakage:\n z = vectors[:, 2]\n\n if np.prod(z) == 0:\n # Pattern (a), (b) or (c)\n # TODO\n print('found 0')\n continue\n\n else:\n # Pattern (e)\n for i in [0,1,2]:\n if (z[i] * z[(i+1)%3] > 0): break\n j = (i+1)%3\n k = (i+2)%3\n\n B = where_z_is_0(vectors[j],vectors[k])\n C = where_z_is_0(vectors[k],vectors[i])\n\n if B[:2] == C[:2]:\n # Meaningless to append a dot.\n continue\n\n section_cutting.append((B[0],B[1],C[0],C[1]))\n\n new_vectors = np.array([ # Create new reference : no need to .copy()\n [ vectors[i], vectors[j], B ],\n [ vectors[i], B , C ],\n [ C , B , vectors[k]]]) # opp.\n\n if normal[2] > 0: # if Visible\n n_of_vectors = len(new_vectors)\n new_data = np.zeros(n_of_vectors, dtype=mesh.Mesh.dtype)\n new_data['vectors'] = new_vectors\n new_data['normals'] = [ normal ] * n_of_vectors\n new_data['attr'] = [ attr ] * n_of_vectors\n\n for i in range(n_of_vectors):\n if np.sum(new_vectors[:,2]) > 0:\n front.append(new_data[i])\n else:\n rear.append(new_data[i])\n return front, section_cutting, rear", "meta": {"hexsha": "88a982712c87d0929727ceebf0db4a3e006e9cd6", "size": 3558, "ext": "py", "lang": "Python", "max_stars_repo_path": "python/module/depthSegmentation.py", "max_stars_repo_name": "Hepheir/Artifact-Mapping-from-3D-Scanning", "max_stars_repo_head_hexsha": "153c0e65c499e8b0078a4e1efbf70d91ad7feb58", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "python/module/depthSegmentation.py", "max_issues_repo_name": "Hepheir/Artifact-Mapping-from-3D-Scanning", "max_issues_repo_head_hexsha": "153c0e65c499e8b0078a4e1efbf70d91ad7feb58", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "python/module/depthSegmentation.py", "max_forks_repo_name": "Hepheir/Artifact-Mapping-from-3D-Scanning", "max_forks_repo_head_hexsha": "153c0e65c499e8b0078a4e1efbf70d91ad7feb58", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.4049586777, "max_line_length": 80, "alphanum_fraction": 0.4688026981, "include": true, "reason": "import numpy", "num_tokens": 1052, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230156, "lm_q2_score": 0.38121956625614994, "lm_q1q2_score": 0.19656440062496058}} {"text": "import pymongo\nimport math\nimport datetime\n# import aiohttp\nimport requests\nimport json\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport os\n\n\ndef jd_to_date(jd):\n \"\"\"\n Convert Julian Day to date.\n\n Algorithm from 'Practical Astronomy with your Calculator or Spreadsheet',\n 4th ed., Duffet-Smith and Zwart, 2011.\n\n Parameters\n ----------\n jd : float\n Julian Day\n\n Returns\n -------\n year : int\n Year as integer. Years preceding 1 A.D. should be 0 or negative.\n The year before 1 A.D. is 0, 10 B.C. is year -9.\n\n month : int\n Month as integer, Jan = 1, Feb. = 2, etc.\n\n day : float\n Day, may contain fractional part.\n\n Examples\n --------\n Convert Julian Day 2446113.75 to year, month, and day.\n\n >>> jd_to_date(2446113.75)\n (1985, 2, 17.25)\n\n \"\"\"\n jd += 0.5\n\n F, I = math.modf(jd)\n I = int(I)\n\n A = math.trunc((I - 1867216.25) / 36524.25)\n\n if I > 2299160:\n B = I + 1 + A - math.trunc(A / 4.)\n else:\n B = I\n\n C = B + 1524\n\n D = math.trunc((C - 122.1) / 365.25)\n\n E = math.trunc(365.25 * D)\n\n G = math.trunc((C - E) / 30.6001)\n\n day = C - E + F - math.trunc(30.6001 * G)\n\n if G < 13.5:\n month = G - 1\n else:\n month = G - 13\n\n if month > 2.5:\n year = D - 4716\n else:\n year = D - 4715\n\n return year, month, day\n\n\ndef jd2date(jd):\n\n year, month, day = jd_to_date(jd)\n\n return datetime.datetime(year, month, int(np.floor(day)))\n\n\ndef fetch_cutout(_id, jd, _path='./'):\n\n date_utc = jd2date(jd).strftime('%Y%m%d')\n url = f'http://private.caltech.edu:8001/data/stamps/stamps_{date_utc}/{_id}_scimref.jpg'\n\n filename = os.path.join(_path, f'{_id}_scimref.jpg')\n r = requests.get(url, stream=True)\n\n if r.status_code == 200:\n # if (not os.path.exists(os.path.join('/Users/dmitryduev/_caltech/python/deep-asteroids/data-raw/'+\n # '20181105_161419__rb_gt_0.97__sl_gt_0.85', f'{_id}_scimref.jpg'))) and \\\n # (not os.path.exists(os.path.join('/Users/dmitryduev/_caltech/python/deep-asteroids/data-raw/' +\n # '20181105_164845__rb_gt_0.97__sl_gt_0.85', f'{_id}_scimref.jpg'))):\n # if (not os.path.exists(os.path.join('/Users/dmitryduev/_caltech/python/deep-asteroids/data-raw/'+\n # '20181102_124622__rb_gt_0.8', f'{_id}_scimref.jpg'))):\n with open(filename, 'wb') as f:\n f.write(r.content)\n\n\nif __name__ == '__main__':\n ''' load secrets '''\n with open('./secrets.json') as sjson:\n secrets = json.load(sjson)\n\n client = pymongo.MongoClient(host=secrets['deep_asteroids_mongodb']['host'],\n port=secrets['deep_asteroids_mongodb']['port'])\n\n db = client['deep-asteroids']\n db.authenticate(name=secrets['deep_asteroids_mongodb']['user'],\n password=secrets['deep_asteroids_mongodb']['pwd'])\n\n # cursor = db['deep-asteroids'].find({}, {'_id': 1, 'rb': 1, 'sl': 1})\n\n ''' training sets for the sl classifier (short/long) '''\n cursor = db['deep-asteroids'].aggregate([\n {'$match': {'rb': {'$gt': 0.93}}},\n {'$project': {'_id': 1, 'jd': 1}},\n {'$sample': {'size': 8000}}\n ], allowDiskUse=True)\n\n streaks = list(cursor)\n\n path = os.path.join('data-raw', datetime.datetime.now().strftime('%Y%m%d_%H%M%S') + '__rb_gt_0.93')\n os.makedirs(path)\n\n num_streaks = len(streaks)\n for si, streak in enumerate(streaks):\n print(f'fetching {streak[\"_id\"]}: {si+1}/{num_streaks}')\n fetch_cutout(streak['_id'], streak['jd'], path)\n\n raise Exception('HAENDE HOCH!!')\n\n ''' training sets for the kd classifier (keep/ditch) '''\n cursor = db['deep-asteroids'].aggregate([\n {'$match': {'rb': {'$gt': 0.97}, 'sl': {'$gt': 0.85}}},\n {'$project': {'_id': 1, 'jd': 1}},\n {'$sample': {'size': 3333}}\n ], allowDiskUse=True)\n\n streaks = list(cursor)\n\n path = os.path.join('data-raw', datetime.datetime.now().strftime('%Y%m%d_%H%M%S') + '__rb_gt_0.97__sl_gt_0.85')\n os.makedirs(path)\n\n num_streaks = len(streaks)\n for si, streak in enumerate(streaks):\n print(f'fetching {streak[\"_id\"]}: {si+1}/{num_streaks}')\n fetch_cutout(streak['_id'], streak['jd'], path)\n\n raise Exception('HAENDE HOCH!!')\n\n ''' Fetch rb > 0.8 '''\n\n cursor = db['deep-asteroids'].aggregate([\n {'$match': {'rb': {'$gt': 0.8}}},\n {'$project': {'_id': 1, 'jd': 1}},\n {'$sample': {'size': 3000}}\n ], allowDiskUse=True)\n\n streaks = list(cursor)\n\n path = os.path.join('data-raw', datetime.datetime.now().strftime('%Y%m%d_%H%M%S') + '__rb_gt_0.8')\n os.makedirs(path)\n\n num_streaks = len(streaks)\n for si, streak in enumerate(streaks):\n print(f'fetching {streak[\"_id\"]}: {si+1}/{num_streaks}')\n fetch_cutout(streak['_id'], streak['jd'], path)\n\n ''' Fetch rb < 0.2 '''\n\n cursor = db['deep-asteroids'].aggregate([\n {'$match': {'rb': {'$lt': 0.2}}},\n {'$project': {'_id': 1, 'jd': 1}},\n {'$sample': {'size': 3000}}\n ], allowDiskUse=True)\n\n streaks = list(cursor)\n\n path = os.path.join('data-raw', datetime.datetime.now().strftime('%Y%m%d_%H%M%S') + '__rb_lt_0.2')\n os.makedirs(path)\n\n num_streaks = len(streaks)\n for si, streak in enumerate(streaks):\n print(f'fetching {streak[\"_id\"]}: {si+1}/{num_streaks}')\n fetch_cutout(streak['_id'], streak['jd'], path)\n\n ''' Fetch 0.2 < rb < 0.8 '''\n\n cursor = db['deep-asteroids'].aggregate([\n {'$match': {'rb': {'$gt': 0.2, '$lt': 0.8}}},\n {'$project': {'_id': 1, 'jd': 1}},\n {'$sample': {'size': 1000}}\n ], allowDiskUse=True)\n\n streaks = list(cursor)\n\n path = os.path.join('data-raw', datetime.datetime.now().strftime('%Y%m%d_%H%M%S') + '__0.2_gt_rb_lt_0.8')\n os.makedirs(path)\n\n num_streaks = len(streaks)\n for si, streak in enumerate(streaks):\n print(f'fetching {streak[\"_id\"]}: {si+1}/{num_streaks}')\n fetch_cutout(streak['_id'], streak['jd'], path)\n", "meta": {"hexsha": "371852ca1c4d1f7624ea2fef7c0fe1a1302f6201", "size": 6169, "ext": "py", "lang": "Python", "max_stars_repo_path": "dev/sample.py", "max_stars_repo_name": "dmitryduev/deep-asteroids", "max_stars_repo_head_hexsha": "2eb648c3de552ec0ec90947d2af8a100f2b67ce1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2019-04-15T14:53:49.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-23T03:13:18.000Z", "max_issues_repo_path": "dev/sample.py", "max_issues_repo_name": "dmitryduev/deep-asteroids", "max_issues_repo_head_hexsha": "2eb648c3de552ec0ec90947d2af8a100f2b67ce1", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 13, "max_issues_repo_issues_event_min_datetime": "2019-12-16T21:24:22.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-11T23:37:51.000Z", "max_forks_repo_path": "dev/sample.py", "max_forks_repo_name": "dmitryduev/deep-asteroids", "max_forks_repo_head_hexsha": "2eb648c3de552ec0ec90947d2af8a100f2b67ce1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-01-24T18:29:45.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-24T18:29:45.000Z", "avg_line_length": 29.3761904762, "max_line_length": 118, "alphanum_fraction": 0.5595720538, "include": true, "reason": "import numpy", "num_tokens": 1926, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230156, "lm_q2_score": 0.38121956625614994, "lm_q1q2_score": 0.19656440062496058}} {"text": "\"\"\"\nBSD 3-Clause License\n\nCopyright (c) 2019, HJ Reachability Group\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n\n* Redistributions of source code must retain the above copyright notice, this\n list of conditions and the following disclaimer.\n\n* Redistributions in binary form must reproduce the above copyright notice,\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution.\n\n* Neither the name of the copyright holder nor the names of its\n contributors may be used to endorse or promote products derived from\n this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\nAND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\nFOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\nDAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\nSERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\nCAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\nOR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nAuthor(s): David Fridovich-Keil ( dfk@eecs.berkeley.edu )\n\"\"\"\n################################################################################\n#\n# Script to run a 3 player collision avoidance example intended to model\n# a T-intersection.\n#\n################################################################################\n\nimport os\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nfrom unicycle_4d import Unicycle4D\nfrom point_mass_2d import PointMass2D\nfrom product_multiplayer_dynamical_system import \\\n ProductMultiPlayerDynamicalSystem\n\nfrom point import Point\nfrom polyline import Polyline\n\nfrom ilq_solver import ILQSolver\nfrom proximity_cost import ProximityCost\nfrom product_state_proximity_cost import ProductStateProximityCost\nfrom semiquadratic_cost import SemiquadraticCost\nfrom quadratic_cost import QuadraticCost\nfrom semiquadratic_polyline_cost import SemiquadraticPolylineCost\nfrom quadratic_polyline_cost import QuadraticPolylineCost\nfrom player_cost import PlayerCost\nfrom box_constraint import BoxConstraint\n\nfrom visualizer import Visualizer\nfrom logger import Logger\n\n# General parameters.\nTIME_HORIZON = 10.0 # s\nTIME_RESOLUTION = 0.1 # s\nHORIZON_STEPS = int(TIME_HORIZON / TIME_RESOLUTION)\nLOG_DIRECTORY = \"./logs/three_player/\"\n\n# Create dynamics.\ncar1 = Unicycle4D()\ncar2 = Unicycle4D()\nped = PointMass2D()\ndynamics = ProductMultiPlayerDynamicalSystem(\n [car1, car2, ped], T=TIME_RESOLUTION)\n\n# Choose initial states and set initial control laws to zero, such that\n# we start with a situation that looks like this:\n#\n# (car 2)\n# | X . |\n# | : . |\n# | \\./ . |\n# | . <--X (ped)\n# | . ------------------\n# | .\n# | . ..................\n# | .\n# | . ------------------\n# | . ^ |\n# | . : | (+y)\n# | . : | |\n# | . X | |\n# (car 1) |______ (+x)\n#\n# We shall set up the costs so that car 2 wants to turn and car 1 / ped 1\n# continue straight in their initial direction of motion.\n# We shall assume that lanes are 4 m wide and set the origin to be in the\n# bottom left along the road boundary.\ncar1_theta0 = np.pi / 2.0 # 90 degree heading\ncar1_v0 = 0.1 # 5 m/s initial speed\ncar1_x0 = np.array([\n [6.5],\n [-5.0],\n [car1_theta0],\n [car1_v0]\n])\n\ncar2_theta0 = -np.pi / 2.0 # -90 degree heading\ncar2_v0 = 5.0 # 2 m/s initial speed\ncar2_x0 = np.array([\n [1.5],\n [65.0],\n [car2_theta0],\n [car2_v0]\n])\n\nped_vx0 = 0.25 # moving right at 0.25 m/s\nped_vy0 = 0.0 # moving normal to traffic flow\nped_x0 = np.array([\n [-4.0],\n [19.0],\n [ped_vx0],\n [ped_vy0]\n])\n\nstacked_x0 = np.concatenate([car1_x0, car2_x0, ped_x0], axis=0)\n\ncar1_Ps = [np.zeros((car1._u_dim, dynamics._x_dim))] * HORIZON_STEPS\ncar2_Ps = [np.zeros((car2._u_dim, dynamics._x_dim))] * HORIZON_STEPS\nped_Ps = [np.zeros((ped._u_dim, dynamics._x_dim))] * HORIZON_STEPS\n\ncar1_alphas = [np.zeros((car1._u_dim, 1))] * HORIZON_STEPS\ncar2_alphas = [np.zeros((car2._u_dim, 1))] * HORIZON_STEPS\nped_alphas = [np.zeros((ped._u_dim, 1))] * HORIZON_STEPS\n\n# Create environment.\ncar1_position_indices_in_product_state = (0, 1)\ncar1_polyline = Polyline([Point(6.0, -100.0), Point(6.0, 100.0)])\ncar1_polyline_boundary_cost = SemiquadraticPolylineCost(\n car1_polyline, 1.0, car1_position_indices_in_product_state,\n \"car1_polyline_boundary\")\ncar1_polyline_cost = QuadraticPolylineCost(\n car1_polyline, car1_position_indices_in_product_state, \"car1_polyline\")\n\ncar1_goal = Point(6.0, 30.0)\ncar1_goal_cost = ProximityCost(\n car1_position_indices_in_product_state, car1_goal, np.inf, \"car1_goal\")\n\ncar2_position_indices_in_product_state = (4, 5)\ncar2_polyline = Polyline([Point(2.0, 100.0),\n Point(2.0, 18.0),\n Point(2.5, 15.0),\n Point(3.0, 14.0),\n Point(5.0, 12.5),\n Point(8.0, 12.0),\n Point(100.0, 12.0)])\ncar2_polyline_boundary_cost = SemiquadraticPolylineCost(\n car2_polyline, 1.0, car2_position_indices_in_product_state,\n \"car2_polyline_boundary\")\ncar2_polyline_cost = QuadraticPolylineCost(\n car2_polyline, car2_position_indices_in_product_state, \"car2_polyline\")\n\ncar2_goal = Point(16.0, 12.0)\ncar2_goal_cost = ProximityCost(\n car2_position_indices_in_product_state, car2_goal, np.inf, \"car2_goal\")\n\nped_position_indices_in_product_state = (8, 9)\nped_goal = Point(10.0, 19.0)\nped_goal_cost = ProximityCost(\n ped_position_indices_in_product_state, ped_goal, np.inf, \"ped_goal\")\n\n# Penalize speed above a threshold for all players.\ncar1_v_index_in_product_state = 3\ncar1_maxv = 10.0 # m/s\ncar1_maxv_cost = SemiquadraticCost(\n car1_v_index_in_product_state, car1_maxv, True, \"car1_maxv\")\n\ncar2_v_index_in_product_state = 7\ncar2_maxv = 10.0 # m/s\ncar2_maxv_cost = SemiquadraticCost(\n car2_v_index_in_product_state, car2_maxv, True, \"car2_maxv\")\n\nped_vx_index_in_product_state = 10\nped_vy_index_in_product_state = 11\nped_maxvx = 0.5 # m/s\nped_maxvy = 0.5 # m/s\nped_maxvx_cost = SemiquadraticCost(\n ped_vx_index_in_product_state, ped_maxvx, True, \"ped_maxvx\")\nped_maxvy_cost = SemiquadraticCost(\n ped_vy_index_in_product_state, ped_maxvy, True, \"ped_maxvy\")\n\n# Control costs for all players.\ncar1_w_cost = QuadraticCost(0, 0.0, \"car1_w_cost\")\ncar1_a_cost = QuadraticCost(1, 0.0, \"car1_a_cost\")\n\ncar2_w_cost = QuadraticCost(0, 0.0, \"car2_w_cost\")\ncar2_a_cost = QuadraticCost(1, 0.0, \"car2_a_cost\")\n\nped_ax_cost = QuadraticCost(0, 0.0, \"ped_ax_cost\")\nped_ay_cost = QuadraticCost(1, 0.0, \"ped_ay_cost\")\n\n# Proximity cost.\nPROXIMITY_THRESHOLD = 1.0\nproximity_cost = ProductStateProximityCost(\n [car1_position_indices_in_product_state,\n car2_position_indices_in_product_state,\n ped_position_indices_in_product_state],\n PROXIMITY_THRESHOLD,\n \"proximity\")\n\n# Build up total costs for both players. This is basically a zero-sum game.\ncar1_cost = PlayerCost()\ncar1_cost.add_cost(car1_goal_cost, \"x\", -1.0)\ncar1_cost.add_cost(car1_polyline_cost, \"x\", 10.0)\ncar1_cost.add_cost(car1_polyline_boundary_cost, \"x\", 100.0)\ncar1_cost.add_cost(car1_maxv_cost, \"x\", 100.0)\ncar1_cost.add_cost(proximity_cost, \"x\", 10.0)\n\ncar1_player_id = 0\ncar1_cost.add_cost(car1_w_cost, car1_player_id, 10.0)\ncar1_cost.add_cost(car1_a_cost, car1_player_id, 1.0)\n\ncar2_cost = PlayerCost()\ncar2_cost.add_cost(car2_goal_cost, \"x\", -1.0)\ncar2_cost.add_cost(car2_polyline_cost, \"x\", 10.0)\ncar2_cost.add_cost(car2_polyline_boundary_cost, \"x\", 100.0)\ncar2_cost.add_cost(car2_maxv_cost, \"x\", 100.0)\ncar2_cost.add_cost(proximity_cost, \"x\", 10.0)\n\ncar2_player_id = 1\ncar2_cost.add_cost(car2_w_cost, car2_player_id, 10.0)\ncar2_cost.add_cost(car2_a_cost, car2_player_id, 1.0)\n\nped_cost = PlayerCost()\nped_cost.add_cost(ped_goal_cost, \"x\", -1.0)\nped_cost.add_cost(ped_maxvx_cost, \"x\", 100.0)\nped_cost.add_cost(ped_maxvy_cost, \"x\", 100.0)\nped_cost.add_cost(proximity_cost, \"x\", 2.0)\n\nped_player_id = 2\nped_cost.add_cost(ped_ax_cost, ped_player_id, 0.001)\nped_cost.add_cost(ped_ay_cost, ped_player_id, 0.001)\n\n# Visualizer.\nvisualizer = Visualizer(\n [car1_position_indices_in_product_state,\n car2_position_indices_in_product_state,\n ped_position_indices_in_product_state],\n [car1_polyline_boundary_cost,\n car1_goal_cost,\n car2_polyline_boundary_cost,\n car2_goal_cost,\n ped_goal_cost],\n [\".-r\", \".-g\", \".-b\"],\n 1,\n False,\n plot_lims=[-10, 30, -10, 70])\n\n# Logger.\nif not os.path.exists(LOG_DIRECTORY):\n os.makedirs(LOG_DIRECTORY)\n\nlogger = Logger(os.path.join(LOG_DIRECTORY, 'intersection_example.pkl'))\n\n# Set up ILQSolver.\nsolver = ILQSolver(dynamics,\n [car1_cost, car2_cost, ped_cost],\n stacked_x0,\n [car1_Ps, car2_Ps, ped_Ps],\n [car1_alphas, car2_alphas, ped_alphas],\n 0.02,\n 0.1,\n logger,\n visualizer,\n None)\n\nsolver.run()\n", "meta": {"hexsha": "61941924196867c1b2b308524c79dba090053564", "size": 9794, "ext": "py", "lang": "Python", "max_stars_repo_path": "python/three_player_intersection_pedestrian_example.py", "max_stars_repo_name": "anjianli21/ilqgames", "max_stars_repo_head_hexsha": "2be8e2bc6d34a9a6296d341b75d59e37c9057ad5", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 53, "max_stars_repo_stars_event_min_datetime": "2019-11-25T02:51:12.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-12T18:30:02.000Z", "max_issues_repo_path": "python/three_player_intersection_pedestrian_example.py", "max_issues_repo_name": "anjianli21/ilqgames", "max_issues_repo_head_hexsha": "2be8e2bc6d34a9a6296d341b75d59e37c9057ad5", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 42, "max_issues_repo_issues_event_min_datetime": "2019-10-05T20:22:04.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-09T20:10:35.000Z", "max_forks_repo_path": "python/three_player_intersection_pedestrian_example.py", "max_forks_repo_name": "anjianli21/ilqgames", "max_forks_repo_head_hexsha": "2be8e2bc6d34a9a6296d341b75d59e37c9057ad5", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 23, "max_forks_repo_forks_event_min_datetime": "2020-01-02T13:33:12.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-06T01:55:28.000Z", "avg_line_length": 34.8540925267, "max_line_length": 80, "alphanum_fraction": 0.6876659179, "include": true, "reason": "import numpy", "num_tokens": 2779, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230156, "lm_q2_score": 0.38121956625614994, "lm_q1q2_score": 0.19656440062496058}} {"text": "# pylint: disable=E1101\nimport torch\nimport torch.nn as nn\nfrom torch.utils.data import DataLoader, TensorDataset\n\nimport numpy as np\nfrom physionet import PhysioNet, get_data_min_max, variable_time_collate_fn2\nfrom sklearn import model_selection\nfrom sklearn import metrics\nfrom person_activity import PersonActivity\n\n\ndef count_parameters(model):\n return sum(p.numel() for p in model.parameters() if p.requires_grad)\n\n\ndef log_normal_pdf(x, mean, logvar, mask):\n const = torch.from_numpy(np.array([2. * np.pi])).float().to(x.device)\n const = torch.log(const)\n return -.5 * (const + logvar + (x - mean) ** 2. / torch.exp(logvar)) * mask\n\n\ndef normal_kl(mu1, lv1, mu2, lv2):\n v1 = torch.exp(lv1)\n v2 = torch.exp(lv2)\n lstd1 = lv1 / 2.\n lstd2 = lv2 / 2.\n\n kl = lstd2 - lstd1 + ((v1 + (mu1 - mu2) ** 2.) / (2. * v2)) - .5\n return kl\n\n\ndef mean_squared_error(orig, pred, mask):\n error = (orig - pred) ** 2\n error = error * mask\n return error.sum() / mask.sum()\n\n\ndef normalize_masked_data(data, mask, att_min, att_max):\n # we don't want to divide by zero\n att_max[att_max == 0.] = 1.\n\n if (att_max != 0.).all():\n data_norm = (data - att_min) / att_max\n else:\n raise Exception(\"Zero!\")\n\n if torch.isnan(data_norm).any():\n raise Exception(\"nans!\")\n\n # set masked out elements back to zero\n data_norm[mask == 0] = 0\n\n return data_norm, att_min, att_max\n\n\ndef evaluate(dim, rec, dec, test_loader, args, num_sample=10, device=\"cuda\"):\n mse, test_n = 0.0, 0.0\n with torch.no_grad():\n for test_batch in test_loader:\n test_batch = test_batch.to(device)\n observed_data, observed_mask, observed_tp = (\n test_batch[:, :, :dim],\n test_batch[:, :, dim: 2 * dim],\n test_batch[:, :, -1],\n )\n if args.sample_tp and args.sample_tp < 1:\n subsampled_data, subsampled_tp, subsampled_mask = subsample_timepoints(\n observed_data.clone(), observed_tp.clone(), observed_mask.clone(), args.sample_tp)\n else:\n subsampled_data, subsampled_tp, subsampled_mask = \\\n observed_data, observed_tp, observed_mask\n out = rec(torch.cat((subsampled_data, subsampled_mask), 2), subsampled_tp)\n qz0_mean, qz0_logvar = (\n out[:, :, : args.latent_dim],\n out[:, :, args.latent_dim:],\n )\n epsilon = torch.randn(\n num_sample, qz0_mean.shape[0], qz0_mean.shape[1], qz0_mean.shape[2]\n ).to(device)\n z0 = epsilon * torch.exp(0.5 * qz0_logvar) + qz0_mean\n z0 = z0.view(-1, qz0_mean.shape[1], qz0_mean.shape[2])\n batch, seqlen = observed_tp.size()\n time_steps = (\n observed_tp[None, :, :].repeat(num_sample, 1, 1).view(-1, seqlen)\n )\n pred_x = dec(z0, time_steps)\n pred_x = pred_x.view(num_sample, -1, pred_x.shape[1], pred_x.shape[2])\n pred_x = pred_x.mean(0)\n mse += mean_squared_error(observed_data, pred_x, observed_mask) * batch\n test_n += batch\n return mse / test_n\n\n\ndef compute_losses(dim, dec_train_batch, qz0_mean, qz0_logvar, pred_x, args, device):\n observed_data, observed_mask \\\n = dec_train_batch[:, :, :dim], dec_train_batch[:, :, dim:2*dim]\n\n noise_std = args.std # default 0.1\n noise_std_ = torch.zeros(pred_x.size()).to(device) + noise_std\n noise_logvar = 2. * torch.log(noise_std_).to(device)\n logpx = log_normal_pdf(observed_data, pred_x, noise_logvar,\n observed_mask).sum(-1).sum(-1)\n pz0_mean = pz0_logvar = torch.zeros(qz0_mean.size()).to(device)\n analytic_kl = normal_kl(qz0_mean, qz0_logvar,\n pz0_mean, pz0_logvar).sum(-1).sum(-1)\n if args.norm:\n logpx /= observed_mask.sum(-1).sum(-1)\n analytic_kl /= observed_mask.sum(-1).sum(-1)\n return logpx, analytic_kl\n\n\ndef evaluate_classifier(model, test_loader, dec=None, args=None, classifier=None,\n dim=41, device='cuda', reconst=False, num_sample=1):\n pred = []\n true = []\n test_loss = 0\n for test_batch, label in test_loader:\n test_batch, label = test_batch.to(device), label.to(device)\n batch_len = test_batch.shape[0]\n observed_data, observed_mask, observed_tp \\\n = test_batch[:, :, :dim], test_batch[:, :, dim:2*dim], test_batch[:, :, -1]\n with torch.no_grad():\n out = model(\n torch.cat((observed_data, observed_mask), 2), observed_tp)\n if reconst:\n qz0_mean, qz0_logvar = out[:, :,\n :args.latent_dim], out[:, :, args.latent_dim:]\n epsilon = torch.randn(\n num_sample, qz0_mean.shape[0], qz0_mean.shape[1], qz0_mean.shape[2]).to(device)\n z0 = epsilon * torch.exp(.5 * qz0_logvar) + qz0_mean\n z0 = z0.view(-1, qz0_mean.shape[1], qz0_mean.shape[2])\n if args.classify_pertp:\n pred_x = dec(z0, observed_tp[None, :, :].repeat(\n num_sample, 1, 1).view(-1, observed_tp.shape[1]))\n #pred_x = pred_x.view(num_sample, batch_len, pred_x.shape[1], pred_x.shape[2])\n out = classifier(pred_x)\n else:\n out = classifier(z0)\n if args.classify_pertp:\n N = label.size(-1)\n out = out.view(-1, N)\n label = label.view(-1, N)\n _, label = label.max(-1)\n test_loss += nn.CrossEntropyLoss()(out, label.long()).item() * batch_len * 50.\n else:\n label = label.unsqueeze(0).repeat_interleave(\n num_sample, 0).view(-1)\n test_loss += nn.CrossEntropyLoss()(out, label).item() * batch_len * num_sample\n pred.append(out.cpu().numpy())\n true.append(label.cpu().numpy())\n pred = np.concatenate(pred, 0)\n true = np.concatenate(true, 0)\n acc = np.mean(pred.argmax(1) == true)\n auc = metrics.roc_auc_score(\n true, pred[:, 1]) if not args.classify_pertp else 0.\n return test_loss/pred.shape[0], acc, auc\n\n\ndef get_mimiciii_data(args):\n input_dim = 12\n x = np.load('../../../neuraltimeseries/Dataset/final_input3.npy')\n y = np.load('../../../neuraltimeseries/Dataset/final_output3.npy')\n x = x[:, :25]\n x = np.transpose(x, (0, 2, 1))\n\n # normalize values and time\n observed_vals, observed_mask, observed_tp = x[:, :,\n :input_dim], x[:, :, input_dim:2*input_dim], x[:, :, -1]\n if np.max(observed_tp) != 0.:\n observed_tp = observed_tp / np.max(observed_tp)\n\n if not args.nonormalize:\n for k in range(input_dim):\n data_min, data_max = float('inf'), 0.\n for i in range(observed_vals.shape[0]):\n for j in range(observed_vals.shape[1]):\n if observed_mask[i, j, k]:\n data_min = min(data_min, observed_vals[i, j, k])\n data_max = max(data_max, observed_vals[i, j, k])\n #print(data_min, data_max)\n if data_max == 0:\n data_max = 1\n observed_vals[:, :, k] = (\n observed_vals[:, :, k] - data_min)/data_max\n # set masked out elements back to zero\n observed_vals[observed_mask == 0] = 0\n print(observed_vals[0], observed_tp[0])\n print(x.shape, y.shape)\n kfold = model_selection.StratifiedKFold(\n n_splits=5, shuffle=True, random_state=0)\n splits = [(train_inds, test_inds)\n for train_inds, test_inds in kfold.split(np.zeros(len(y)), y)]\n x_train, y_train = x[splits[args.split][0]], y[splits[args.split][0]]\n test_data_x, test_data_y = x[splits[args.split]\n [1]], y[splits[args.split][1]]\n if not args.old_split:\n train_data_x, val_data_x, train_data_y, val_data_y = \\\n model_selection.train_test_split(\n x_train, y_train, stratify=y_train, test_size=0.2, random_state=0)\n else:\n frac = int(0.8*x_train.shape[0])\n train_data_x, val_data_x = x_train[:frac], x_train[frac:]\n train_data_y, val_data_y = y_train[:frac], y_train[frac:]\n\n print(train_data_x.shape, train_data_y.shape, val_data_x.shape, val_data_y.shape,\n test_data_x.shape, test_data_y.shape)\n print(np.sum(test_data_y))\n train_data_combined = TensorDataset(torch.from_numpy(train_data_x).float(),\n torch.from_numpy(train_data_y).long().squeeze())\n val_data_combined = TensorDataset(torch.from_numpy(val_data_x).float(),\n torch.from_numpy(val_data_y).long().squeeze())\n test_data_combined = TensorDataset(torch.from_numpy(test_data_x).float(),\n torch.from_numpy(test_data_y).long().squeeze())\n train_dataloader = DataLoader(\n train_data_combined, batch_size=args.batch_size, shuffle=False)\n test_dataloader = DataLoader(\n test_data_combined, batch_size=args.batch_size, shuffle=False)\n val_dataloader = DataLoader(\n val_data_combined, batch_size=args.batch_size, shuffle=False)\n\n data_objects = {\"train_dataloader\": train_dataloader,\n \"test_dataloader\": test_dataloader,\n \"val_dataloader\": val_dataloader,\n \"input_dim\": input_dim}\n return data_objects\n\n\ndef get_physionet_data(args, device, q, flag=1):\n train_dataset_obj = PhysioNet('data/physionet', train=True,\n quantization=q,\n download=True, n_samples=min(10000, args.n),\n device=device)\n # Use custom collate_fn to combine samples with arbitrary time observations.\n # Returns the dataset along with mask and time steps\n test_dataset_obj = PhysioNet('data/physionet', train=False,\n quantization=q,\n download=True, n_samples=min(10000, args.n),\n device=device)\n\n # Combine and shuffle samples from physionet Train and physionet Test\n total_dataset = train_dataset_obj[:len(train_dataset_obj)]\n\n if not args.classif:\n # Concatenate samples from original Train and Test sets\n # Only 'training' physionet samples are have labels.\n # Therefore, if we do classifiction task, we don't need physionet 'test' samples.\n total_dataset = total_dataset + \\\n test_dataset_obj[:len(test_dataset_obj)]\n print(len(total_dataset))\n # Shuffle and split\n train_data, test_data = model_selection.train_test_split(total_dataset, train_size=0.8,\n random_state=42, shuffle=True)\n\n record_id, tt, vals, mask, labels = train_data[0]\n\n # n_samples = len(total_dataset)\n input_dim = vals.size(-1)\n data_min, data_max = get_data_min_max(total_dataset, device)\n batch_size = min(min(len(train_dataset_obj), args.batch_size), args.n)\n if flag:\n test_data_combined = variable_time_collate_fn(test_data, device, classify=args.classif,\n data_min=data_min, data_max=data_max)\n\n if args.classif:\n train_data, val_data = model_selection.train_test_split(train_data, train_size=0.8,\n random_state=11, shuffle=True)\n train_data_combined = variable_time_collate_fn(\n train_data, device, classify=args.classif, data_min=data_min, data_max=data_max)\n val_data_combined = variable_time_collate_fn(\n val_data, device, classify=args.classif, data_min=data_min, data_max=data_max)\n print(train_data_combined[1].sum(\n ), val_data_combined[1].sum(), test_data_combined[1].sum())\n print(train_data_combined[0].size(), train_data_combined[1].size(),\n val_data_combined[0].size(), val_data_combined[1].size(),\n test_data_combined[0].size(), test_data_combined[1].size())\n\n train_data_combined = TensorDataset(\n train_data_combined[0], train_data_combined[1].long().squeeze())\n val_data_combined = TensorDataset(\n val_data_combined[0], val_data_combined[1].long().squeeze())\n test_data_combined = TensorDataset(\n test_data_combined[0], test_data_combined[1].long().squeeze())\n else:\n train_data_combined = variable_time_collate_fn(\n train_data, device, classify=args.classif, data_min=data_min, data_max=data_max)\n print(train_data_combined.size(), test_data_combined.size())\n\n train_dataloader = DataLoader(\n train_data_combined, batch_size=batch_size, shuffle=False)\n test_dataloader = DataLoader(\n test_data_combined, batch_size=batch_size, shuffle=False)\n\n else:\n train_dataloader = DataLoader(train_data, batch_size=batch_size, shuffle=False,\n collate_fn=lambda batch: variable_time_collate_fn2(batch, args, device, data_type=\"train\",\n data_min=data_min, data_max=data_max))\n test_dataloader = DataLoader(test_data, batch_size=batch_size, shuffle=False,\n collate_fn=lambda batch: variable_time_collate_fn2(batch, args, device, data_type=\"test\",\n data_min=data_min, data_max=data_max))\n\n attr_names = train_dataset_obj.params\n data_objects = {\"dataset_obj\": train_dataset_obj,\n \"train_dataloader\": train_dataloader,\n \"test_dataloader\": test_dataloader,\n \"input_dim\": input_dim,\n \"n_train_batches\": len(train_dataloader),\n \"n_test_batches\": len(test_dataloader),\n \"attr\": attr_names, # optional\n \"classif_per_tp\": False, # optional\n \"n_labels\": 1} # optional\n if args.classif:\n val_dataloader = DataLoader(\n val_data_combined, batch_size=batch_size, shuffle=False)\n data_objects[\"val_dataloader\"] = val_dataloader\n return data_objects\n\n\ndef variable_time_collate_fn(batch, device=torch.device(\"cpu\"), classify=False, activity=False,\n data_min=None, data_max=None):\n \"\"\"\n Expects a batch of time series data in the form of (record_id, tt, vals, mask, labels) where\n - record_id is a patient id\n - tt is a 1-dimensional tensor containing T time values of observations.\n - vals is a (T, D) tensor containing observed values for D variables.\n - mask is a (T, D) tensor containing 1 where values were observed and 0 otherwise.\n - labels is a list of labels for the current patient, if labels are available. Otherwise None.\n Returns:\n combined_tt: The union of all time observations.\n combined_vals: (M, T, D) tensor containing the observed values.\n combined_mask: (M, T, D) tensor containing 1 where values were observed and 0 otherwise.\n \"\"\"\n D = batch[0][2].shape[1]\n # number of labels\n N = batch[0][-1].shape[1] if activity else 1\n len_tt = [ex[1].size(0) for ex in batch]\n maxlen = np.max(len_tt)\n enc_combined_tt = torch.zeros([len(batch), maxlen]).to(device)\n enc_combined_vals = torch.zeros([len(batch), maxlen, D]).to(device)\n enc_combined_mask = torch.zeros([len(batch), maxlen, D]).to(device)\n if classify:\n if activity:\n combined_labels = torch.zeros([len(batch), maxlen, N]).to(device)\n else:\n combined_labels = torch.zeros([len(batch), N]).to(device)\n\n for b, (record_id, tt, vals, mask, labels) in enumerate(batch):\n currlen = tt.size(0)\n enc_combined_tt[b, :currlen] = tt.to(device)\n enc_combined_vals[b, :currlen] = vals.to(device)\n enc_combined_mask[b, :currlen] = mask.to(device)\n if classify:\n if activity:\n combined_labels[b, :currlen] = labels.to(device)\n else:\n combined_labels[b] = labels.to(device)\n\n if not activity:\n enc_combined_vals, _, _ = normalize_masked_data(enc_combined_vals, enc_combined_mask,\n att_min=data_min, att_max=data_max)\n\n if torch.max(enc_combined_tt) != 0.:\n enc_combined_tt = enc_combined_tt / torch.max(enc_combined_tt)\n\n combined_data = torch.cat(\n (enc_combined_vals, enc_combined_mask, enc_combined_tt.unsqueeze(-1)), 2)\n if classify:\n return combined_data, combined_labels\n else:\n return combined_data\n\n\ndef get_activity_data(args, device):\n n_samples = min(10000, args.n)\n dataset_obj = PersonActivity('data/PersonActivity',\n download=True, n_samples=n_samples, device=device)\n\n print(dataset_obj)\n\n train_data, test_data = model_selection.train_test_split(dataset_obj, train_size=0.8,\n random_state=42, shuffle=True)\n\n # train_data = [train_data[i] for i in np.random.choice(len(train_data), len(train_data))]\n # test_data = [test_data[i] for i in np.random.choice(len(test_data), len(test_data))]\n\n record_id, tt, vals, mask, labels = train_data[0]\n input_dim = vals.size(-1)\n\n batch_size = min(min(len(dataset_obj), args.batch_size), args.n)\n test_data_combined = variable_time_collate_fn(test_data, device, classify=args.classif,\n activity=True)\n train_data, val_data = model_selection.train_test_split(train_data, train_size=0.8,\n random_state=11, shuffle=True)\n train_data_combined = variable_time_collate_fn(\n train_data, device, classify=args.classif, activity=True)\n val_data_combined = variable_time_collate_fn(\n val_data, device, classify=args.classif, activity=True)\n print(train_data_combined[1].sum(\n ), val_data_combined[1].sum(), test_data_combined[1].sum())\n print(train_data_combined[0].size(), train_data_combined[1].size(),\n val_data_combined[0].size(), val_data_combined[1].size(),\n test_data_combined[0].size(), test_data_combined[1].size())\n\n train_data_combined = TensorDataset(\n train_data_combined[0], train_data_combined[1].long())\n val_data_combined = TensorDataset(\n val_data_combined[0], val_data_combined[1].long())\n test_data_combined = TensorDataset(\n test_data_combined[0], test_data_combined[1].long())\n\n train_dataloader = DataLoader(\n train_data_combined, batch_size=batch_size, shuffle=False)\n test_dataloader = DataLoader(\n test_data_combined, batch_size=batch_size, shuffle=False)\n val_dataloader = DataLoader(\n val_data_combined, batch_size=batch_size, shuffle=False)\n\n #attr_names = train_dataset_obj.params\n data_objects = {\"train_dataloader\": train_dataloader,\n \"test_dataloader\": test_dataloader,\n \"val_dataloader\": val_dataloader,\n \"input_dim\": input_dim,\n \"n_train_batches\": len(train_dataloader),\n \"n_test_batches\": len(test_dataloader),\n # \"attr\": attr_names, #optional\n \"classif_per_tp\": False, # optional\n \"n_labels\": 1} # optional\n\n return data_objects\n\n\ndef irregularly_sampled_data_gen(n=10, length=20, seed=0):\n np.random.seed(seed)\n # obs_times = obs_times_gen(n)\n obs_values, ground_truth, obs_times = [], [], []\n for i in range(n):\n t1 = np.sort(np.random.uniform(low=0.0, high=1.0, size=length))\n t2 = np.sort(np.random.uniform(low=0.0, high=1.0, size=length))\n t3 = np.sort(np.random.uniform(low=0.0, high=1.0, size=length))\n a = 10 * np.random.randn()\n b = 10 * np.random.rand()\n f1 = .8 * np.sin(20*(t1+a) + np.sin(20*(t1+a))) + \\\n 0.01 * np.random.randn()\n f2 = -.5 * np.sin(20*(t2+a + 20) + np.sin(20*(t2+a + 20))\n ) + 0.01 * np.random.randn()\n f3 = np.sin(12*(t3+b)) + 0.01 * np.random.randn()\n obs_times.append(np.stack((t1, t2, t3), axis=0))\n obs_values.append(np.stack((f1, f2, f3), axis=0))\n #obs_values.append([f1.tolist(), f2.tolist(), f3.tolist()])\n t = np.linspace(0, 1, 100)\n fg1 = .8 * np.sin(20*(t+a) + np.sin(20*(t+a)))\n fg2 = -.5 * np.sin(20*(t+a + 20) + np.sin(20*(t+a + 20)))\n fg3 = np.sin(12*(t+b))\n #ground_truth.append([f1.tolist(), f2.tolist(), f3.tolist()])\n ground_truth.append(np.stack((fg1, fg2, fg3), axis=0))\n return obs_values, ground_truth, obs_times\n\n\ndef sine_wave_data_gen(args, seed=0):\n np.random.seed(seed)\n obs_values, ground_truth, obs_times = [], [], []\n for _ in range(args.n):\n t = np.sort(np.random.choice(np.linspace(\n 0, 1., 101), size=args.length, replace=True))\n b = 10 * np.random.rand()\n f = np.sin(12*(t+b)) + 0.1 * np.random.randn()\n obs_times.append(t)\n obs_values.append(f)\n tc = np.linspace(0, 1, 100)\n fg = np.sin(12*(tc + b))\n ground_truth.append(fg)\n\n obs_values = np.array(obs_values)\n obs_times = np.array(obs_times)\n ground_truth = np.array(ground_truth)\n print(obs_values.shape, obs_times.shape, ground_truth.shape)\n mask = np.ones_like(obs_values)\n combined_data = np.concatenate((np.expand_dims(obs_values, axis=2), np.expand_dims(\n mask, axis=2), np.expand_dims(obs_times, axis=2)), axis=2)\n print(combined_data.shape)\n print(combined_data[0])\n train_data, test_data = model_selection.train_test_split(combined_data, train_size=0.8,\n random_state=42, shuffle=True)\n print(train_data.shape, test_data.shape)\n train_dataloader = DataLoader(torch.from_numpy(\n train_data).float(), batch_size=args.batch_size, shuffle=False)\n test_dataloader = DataLoader(torch.from_numpy(\n test_data).float(), batch_size=args.batch_size, shuffle=False)\n data_objects = {\"dataset_obj\": combined_data,\n \"train_dataloader\": train_dataloader,\n \"test_dataloader\": test_dataloader,\n \"input_dim\": 1,\n \"ground_truth\": np.array(ground_truth)}\n return data_objects\n\n\ndef kernel_smoother_data_gen(args, alpha=100., seed=0, ref_points=10):\n np.random.seed(seed)\n obs_values, ground_truth, obs_times = [], [], []\n for _ in range(args.n):\n key_values = np.random.randn(ref_points)\n key_points = np.linspace(0, 1, ref_points)\n\n query_points = np.sort(np.random.choice(\n np.linspace(0, 1., 101), size=args.length, replace=True))\n # query_points = np.sort(np.random.uniform(low=0.0, high=1.0, size=args.length))\n weights = np.exp(-alpha*(np.expand_dims(query_points,\n 1) - np.expand_dims(key_points, 0))**2)\n weights /= weights.sum(1, keepdims=True)\n query_values = np.dot(weights, key_values)\n obs_values.append(query_values)\n obs_times.append(query_points)\n\n query_points = np.linspace(0, 1, 100)\n weights = np.exp(-alpha*(np.expand_dims(query_points,\n 1) - np.expand_dims(key_points, 0))**2)\n weights /= weights.sum(1, keepdims=True)\n query_values = np.dot(weights, key_values)\n ground_truth.append(query_values)\n\n obs_values = np.array(obs_values)\n obs_times = np.array(obs_times)\n ground_truth = np.array(ground_truth)\n print(obs_values.shape, obs_times.shape, ground_truth.shape)\n mask = np.ones_like(obs_values)\n combined_data = np.concatenate((np.expand_dims(obs_values, axis=2), np.expand_dims(\n mask, axis=2), np.expand_dims(obs_times, axis=2)), axis=2)\n print(combined_data.shape)\n print(combined_data[0])\n train_data, test_data = model_selection.train_test_split(combined_data, train_size=0.8,\n random_state=42, shuffle=True)\n print(train_data.shape, test_data.shape)\n train_dataloader = DataLoader(torch.from_numpy(\n train_data).float(), batch_size=args.batch_size, shuffle=False)\n test_dataloader = DataLoader(torch.from_numpy(\n test_data).float(), batch_size=args.batch_size, shuffle=False)\n data_objects = {\"dataset_obj\": combined_data,\n \"train_dataloader\": train_dataloader,\n \"test_dataloader\": test_dataloader,\n \"input_dim\": 1,\n \"ground_truth\": np.array(ground_truth)}\n return data_objects\n\n\ndef get_toy_data(args):\n dim = 3\n obs_values, ground_truth, obs_times = irregularly_sampled_data_gen(\n args.n, args.length)\n obs_times = np.array(obs_times).reshape(args.n, -1)\n obs_values = np.array(obs_values)\n combined_obs_values = np.zeros((args.n, dim, obs_times.shape[-1]))\n mask = np.zeros((args.n, dim, obs_times.shape[-1]))\n for i in range(dim):\n combined_obs_values[:, i, i *\n args.length: (i+1)*args.length] = obs_values[:, i]\n mask[:, i, i*args.length: (i+1)*args.length] = 1.\n #print(combined_obs_values.shape, mask.shape, obs_times.shape, np.expand_dims(obs_times, axis=1).shape)\n combined_data = np.concatenate(\n (combined_obs_values, mask, np.expand_dims(obs_times, axis=1)), axis=1)\n combined_data = np.transpose(combined_data, (0, 2, 1))\n print(combined_data.shape)\n train_data, test_data = model_selection.train_test_split(combined_data, train_size=0.8,\n random_state=42, shuffle=True)\n print(train_data.shape, test_data.shape)\n train_dataloader = DataLoader(torch.from_numpy(\n train_data).float(), batch_size=args.batch_size, shuffle=False)\n test_dataloader = DataLoader(torch.from_numpy(\n test_data).float(), batch_size=args.batch_size, shuffle=False)\n data_objects = {\"dataset_obj\": combined_data,\n \"train_dataloader\": train_dataloader,\n \"test_dataloader\": test_dataloader,\n \"input_dim\": dim,\n \"ground_truth\": np.array(ground_truth)}\n return data_objects\n\n\ndef compute_pertp_loss(label_predictions, true_label, mask):\n criterion = nn.CrossEntropyLoss(reduction='none')\n n_traj, n_tp, n_dims = label_predictions.size()\n label_predictions = label_predictions.reshape(n_traj * n_tp, n_dims)\n true_label = true_label.reshape(n_traj * n_tp, n_dims)\n mask = torch.sum(mask, -1) > 0\n mask = mask.reshape(n_traj * n_tp, 1)\n _, true_label = true_label.max(-1)\n ce_loss = criterion(label_predictions, true_label.long())\n ce_loss = ce_loss * mask\n return torch.sum(ce_loss)/mask.sum()\n\n\ndef get_physionet_data_extrap(args, device, q, flag=1):\n train_dataset_obj = PhysioNet('data/physionet', train=True,\n quantization=q,\n download=True, n_samples=min(10000, args.n),\n device=device)\n # Use custom collate_fn to combine samples with arbitrary time observations.\n # Returns the dataset along with mask and time steps\n test_dataset_obj = PhysioNet('data/physionet', train=False,\n quantization=q,\n download=True, n_samples=min(10000, args.n),\n device=device)\n\n # Combine and shuffle samples from physionet Train and physionet Test\n total_dataset = train_dataset_obj[:len(train_dataset_obj)]\n\n if not args.classif:\n # Concatenate samples from original Train and Test sets\n # Only 'training' physionet samples are have labels.\n # Therefore, if we do classifiction task, we don't need physionet 'test' samples.\n total_dataset = total_dataset + \\\n test_dataset_obj[:len(test_dataset_obj)]\n print(len(total_dataset))\n # Shuffle and split\n train_data, test_data = model_selection.train_test_split(total_dataset, train_size=0.8,\n random_state=42, shuffle=True)\n\n record_id, tt, vals, mask, labels = train_data[0]\n\n # n_samples = len(total_dataset)\n input_dim = vals.size(-1)\n data_min, data_max = get_data_min_max(total_dataset, device)\n batch_size = min(min(len(train_dataset_obj), args.batch_size), args.n)\n\n def extrap(test_data):\n enc_test_data = []\n dec_test_data = []\n for (record_id, tt, vals, mask, labels) in test_data:\n midpt = 0\n for tp in tt:\n if tp < 24:\n midpt += 1\n else:\n break\n if mask[:midpt].sum() and mask[midpt:].sum():\n enc_test_data.append(\n (record_id, tt[:midpt], vals[:midpt], mask[:midpt], labels))\n dec_test_data.append(\n (record_id, tt[midpt:], vals[midpt:], mask[midpt:], labels))\n return enc_test_data, dec_test_data\n\n enc_train_data, dec_train_data = extrap(train_data)\n enc_test_data, dec_test_data = extrap(test_data)\n enc_train_data_combined = variable_time_collate_fn(\n enc_train_data, device, classify=args.classif, data_min=data_min, data_max=data_max)\n dec_train_data_combined = variable_time_collate_fn(\n dec_train_data, device, classify=args.classif, data_min=data_min, data_max=data_max)\n enc_test_data_combined = variable_time_collate_fn(\n enc_test_data, device, classify=args.classif, data_min=data_min, data_max=data_max)\n dec_test_data_combined = variable_time_collate_fn(\n dec_test_data, device, classify=args.classif, data_min=data_min, data_max=data_max)\n print(enc_train_data_combined.shape, dec_train_data_combined.shape)\n print(enc_test_data_combined.shape, dec_test_data_combined.shape)\n\n # keep the timepoints in enc between 0.0 and 0.5\n enc_train_data_combined[:, :, -1] *= 0.5\n enc_test_data_combined[:, :, -1] *= 0.5\n print(enc_train_data_combined[0, :, -1], dec_train_data_combined[0, :, -1])\n enc_train_dataloader = DataLoader(\n enc_train_data_combined, batch_size=batch_size, shuffle=False)\n dec_train_dataloader = DataLoader(\n dec_train_data_combined, batch_size=batch_size, shuffle=False)\n enc_test_dataloader = DataLoader(\n enc_test_data_combined, batch_size=batch_size, shuffle=False)\n dec_test_dataloader = DataLoader(\n dec_test_data_combined, batch_size=batch_size, shuffle=False)\n\n attr_names = train_dataset_obj.params\n data_objects = {\"dataset_obj\": train_dataset_obj,\n \"enc_train_dataloader\": enc_train_dataloader,\n \"enc_test_dataloader\": enc_test_dataloader,\n \"dec_train_dataloader\": dec_train_dataloader,\n \"dec_test_dataloader\": dec_test_dataloader,\n \"input_dim\": input_dim,\n \"attr\": attr_names, # optional\n \"classif_per_tp\": False, # optional\n \"n_labels\": 1} # optional\n\n return data_objects\n\n\ndef subsample_timepoints(data, time_steps, mask, percentage_tp_to_sample=None):\n # Subsample percentage of points from each time series\n for i in range(data.size(0)):\n # take mask for current training sample and sum over all features --\n # figure out which time points don't have any measurements at all in this batch\n current_mask = mask[i].sum(-1).cpu()\n non_missing_tp = np.where(current_mask > 0)[0]\n n_tp_current = len(non_missing_tp)\n n_to_sample = int(n_tp_current * percentage_tp_to_sample)\n subsampled_idx = sorted(np.random.choice(\n non_missing_tp, n_to_sample, replace=False))\n tp_to_set_to_zero = np.setdiff1d(non_missing_tp, subsampled_idx)\n\n data[i, tp_to_set_to_zero] = 0.\n if mask is not None:\n mask[i, tp_to_set_to_zero] = 0.\n\n return data, time_steps, mask\n", "meta": {"hexsha": "81030c55250a4daa5d1b9ced8055592987bbda43", "size": 32695, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/utils.py", "max_stars_repo_name": "mobiledoctorDev/mTANs", "max_stars_repo_head_hexsha": "a59cc52e19920fc8eadb75ed57c308c009dde791", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 45, "max_stars_repo_stars_event_min_datetime": "2021-03-23T02:38:38.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T03:02:34.000Z", "max_issues_repo_path": "src/utils.py", "max_issues_repo_name": "mobiledoctorDev/mTANs", "max_issues_repo_head_hexsha": "a59cc52e19920fc8eadb75ed57c308c009dde791", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2021-11-12T22:03:13.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-13T06:51:25.000Z", "max_forks_repo_path": "src/utils.py", "max_forks_repo_name": "mobiledoctorDev/mTANs", "max_forks_repo_head_hexsha": "a59cc52e19920fc8eadb75ed57c308c009dde791", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2021-05-04T18:53:14.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-27T05:22:46.000Z", "avg_line_length": 46.840974212, "max_line_length": 128, "alphanum_fraction": 0.6139776724, "include": true, "reason": "import numpy", "num_tokens": 7693, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230156, "lm_q2_score": 0.3812195662561499, "lm_q1q2_score": 0.19656440062496056}} {"text": "from __future__ import print_function\nimport numpy as np\nimport powderday.config as cfg\nimport pdb\n\nimport astropy.units as u\nimport astropy.constants as constants\nfrom astropy import cosmology as cosmo\n\nimport fsps \nfrom datetime import datetime\nfrom powderday.grid_construction import stars_coordinate_boost\n\nfrom multiprocessing import Pool\nfrom functools import partial\nfrom itertools import repeat\nfrom scipy.integrate import simps\n\nfrom powderday.nebular_emission.cloudy_tools import calc_LogQ, cmdf, get_nearest,convert_metals\nfrom powderday.analytics import logu_diagnostic,dump_emlines\nfrom powderday.nebular_emission.cloudy_model import get_nebular\n\n#this is required to keep the reg as a strong reference. for some\n#reason in the star_list.append in star_list_gen, reg otherwise gets\n#garbage collected.\nimport gc\ngc.set_threshold(0)\n\n# Lazily initialize FSPS\nsp = None\n\nclass Stars:\n def __init__(self,mass,metals,positions,age,sed_bin=[-1,-1,-1],lum=-1,fsps_zmet=20,all_metals=[-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1]):\n self.mass = mass\n self.metals = metals\n self.positions = positions\n self.age = age\n self.sed_bin = sed_bin\n self.lum = lum\n self.fsps_zmet = fsps_zmet\n self.all_metals = all_metals\n\n def info(self):\n return(self.mass,self.metals,self.positions,self.age,self.sed_bin,self.lum,self.fsps_zmet)\n\ndef star_list_gen(boost,dx,dy,dz,reg,ds):\n print ('[SED_gen/star_list_gen]: reading in stars particles for SPS calculation')\n mass = reg[\"starmasses\"].value\n positions = reg[\"starcoordinates\"].value\n age = reg[\"stellarages\"].value\n nstars = len(reg[\"stellarages\"].value) \n el = ['He', 'C', 'N', 'O', 'Ne', 'Mg', 'Si', 'S', 'Ca', 'Fe' ]\n\n try: \n metals = np.zeros((nstars,11))-10.0\n for i in range(11):\n if i == 0:\n el_str = \"\"\n else:\n el_str = \"_\"+el[i-1]\n metals[:, i] = reg[\"starmetals\"+el_str].value\n except:\n metals = reg[\"starmetals\"].value\n print ('number of new stars =',nstars)\n \n #calculate the fsps interpolated metallicity\n\n #if the metallicity has many fields, and not just global\n #metallicity then just extract the global metallicity\n if metals.ndim > 1:\n metals_tot = metals[:,0]\n else:\n metals_tot = metals\n\n print ('[SED_gen/star_list_gen:] Manually increasing the newstar metallicities by: ',cfg.par.Z_init)\n metals_tot += cfg.par.Z_init\n \n #ADVANCED FEATURE - if force_stellar_metallcities or force_stellar_ages are set, then we set to those values\n if cfg.par.FORCE_STELLAR_AGES:\n print (\"[SED_GEN/stars_list_gen:] FORCE_STELLAR_AGES is set to True: setting all stars to age: %e Gyr\"%cfg.par.FORCE_STELLAR_AGES_VALUE)\n age = np.repeat(cfg.par.FORCE_STELLAR_AGES_VALUE,nstars)\n\n if cfg.par.FORCE_STELLAR_METALLICITIES:\n print (\"[SED_GEN/stars_list_gen:] FORCE_STELLAR_METALLICITIES is set to True: setting all stars to metallicity: %e \"%cfg.par.FORCE_STELLAR_METALLICITIES_VALUE)\n metals_tot = np.repeat(cfg.par.FORCE_STELLAR_METALLICITIES_VALUE,nstars)\n\n\n\n zmet = fsps_metallicity_interpolate(metals_tot)\n #mwd(zmet,mass,'zmet_distribution.png')\n\n #print '[SED_gen/star_list_gen: ] fsps zmet codes:',zmet\n\n #create the stars_list full of Stars objects\n stars_list = []\n \n if metals.ndim > 1:\n for i in range(nstars):\n stars_list.append(Stars(mass[i],metals_tot[i],positions[i],age[i],fsps_zmet=zmet[i],all_metals = metals[i]))\n else:\n for i in range(nstars):\n stars_list.append(Stars(mass[i],metals_tot[i],positions[i],age[i],fsps_zmet=zmet[i]))\n \n #boost stellar positions to grid center\n print ('boosting new stars to coordinate center')\n stars_list = stars_coordinate_boost(stars_list,boost)\n\n #orig_stars_list_len = len(stars_list)\n \n #ASSIGN DISK AND BULGE STARS - note, if these don't exist, it will\n #just make empty lists\n\n \n\n \n bulgestars_list = []\n diskstars_list = []\n\n \n #in principle, we should just be able to do the following blocks\n #if the particle types exist. the issue is that different groups\n #use PartType2 and 3 as 'filler' particle types, so they may exist\n #even if they don't correspond to disk/bulge stars.\n\n\n if ds.cosmological_simulation == False:\n\n #Disk Stars\n\n if (\"diskstarcoordinates\") in ds.derived_field_list:\n \n disk_positions = reg[(\"diskstarcoordinates\")].value\n disk_masses = reg[(\"diskstarmasses\")].value\n nstars_disk = len(disk_masses)\n \n #create the disk_list full of DiskStars objects\n for i in range(nstars_disk):\n diskstars_list.append(Stars(disk_masses[i],cfg.par.solar,disk_positions[i],cfg.par.disk_stars_age))\n\n print ('boosting disk stars to coordinate center') \n diskstars_list = stars_coordinate_boost(diskstars_list,boost)\n\n #orig_disk_stars_list_len = nstars_disk\n \n \n #Bulge Stars\n\n\n if (\"bulgestarcoordinates\") in ds.derived_field_list:\n bulge_positions = reg[(\"bulgestarcoordinates\")].value\n bulge_masses = reg[(\"bulgestarmasses\")].value\n nstars_bulge = len(bulge_masses)\n \n #create the bulge_list full of BulgeStars objects\n \n for i in range(nstars_bulge):\n bulgestars_list.append(Stars(bulge_masses[i],cfg.par.solar,bulge_positions[i],cfg.par.bulge_stars_age))\n \n\n print ('boosting bulge stars to coordinate center')\n bulgestars_list = stars_coordinate_boost(bulgestars_list,boost)\n\n\n #EXPERIMENTAL FEATURES\n if cfg.par.SOURCES_IN_CENTER == True:\n for i in range(nstars):\n stars_list[i].positions[:] = np.array([0,0,0])\n if (\"bulgestarcoordinates\") in ds.derived_field_list:\n for i in range(nstars_bulge):\n bulgestars_list[i].positions[:] = np.array([0,0,0])\n for i in range(nstars_disk):\n diskstars_list[i].positions[:] = np.array([0,0,0])\n\n if cfg.par.SOURCES_RANDOM_POSITIONS == True:\n print (\"================================\")\n print (\"SETTING SOURCES TO RANDOM POSITIONS\")\n print (\"================================\")\n for i in range(nstars):\n xpos,ypos,zpos = np.random.uniform(-0.9*dx/2.,0.9*dx/2.),np.random.uniform(-0.9*dy/2.,0.9*dy/2.),np.random.uniform(-0.9*dz/2.,0.9*dz/2.)\n stars_list[i].positions[:] = np.array([xpos,ypos,zpos])\n\n if (\"bulgestarcoordinates\") in ds.derived_field_list:\n for i in range(nstars_bulge):\n xpos,ypos,zpos = np.random.uniform(-0.9*dx/2.,0.9*dx/2.),np.random.uniform(-0.9*dy/2.,0.9*dy/2.),np.random.uniform(-0.9*dz/2.,0.9*dz/2.)\n bulgestars_list[i].positions[:] = np.array([xpos,ypos,zpos])\n for i in range(nstars_disk):\n xpos,ypos,zpos = np.random.uniform(-0.9*dx/2.,0.9*dx/2.),np.random.uniform(-0.9*dy/2.,0.9*dy/2.),np.random.uniform(-0.9*dz/2.,0.9*dz/2.)\n diskstars_list[i].positions[:] = np.array([xpos,ypos,zpos])\n\n return stars_list,diskstars_list,bulgestars_list,reg\n\n\n\ndef allstars_sed_gen(stars_list,cosmoflag,sp):\n\n\n #NOTE this part is just for the gadget simulations - this will\n #eventually become obviated as it gets passed into a function to\n #populate the stars_list with objects as we start to feed in new\n #types of simulation results.\n\n nstars = len(stars_list)\n \n #get just the wavelength array\n sp.params[\"tage\"] = stars_list[0].age\n sp.params[\"imf_type\"] = cfg.par.imf_type\n sp.params[\"pagb\"] = cfg.par.pagb\n sp.params[\"sfh\"] = 0\n sp.params[\"zmet\"] = stars_list[0].fsps_zmet\n sp.params[\"add_neb_emission\"] = cfg.par.add_neb_emission\n sp.params[\"add_agb_dust_model\"] = cfg.par.add_agb_dust_model\n sp.params['gas_logu'] = cfg.par.gas_logu\n if cfg.par.FORCE_gas_logz == False:\n sp.params['gas_logz'] = np.log10(stars_list[0].metals/cfg.par.solar)\n else:\n sp.params['gas_logz'] = cfg.par.gas_logz\n\n '''\n sp = fsps.StellarPopulation(tage=stars_list[0].age,imf_type=cfg.par.imf_type,pagb = cfg.par.pagb,sfh=0,zmet=stars_list[0].fsps_zmet,\n add_neb_emission = cfg.par.add_neb_emission, add_agb_dust_model=cfg.par.add_agb_dust_model)\n '''\n spec = sp.get_spectrum(tage=stars_list[0].age,zmet=stars_list[0].fsps_zmet)\n nu = 1.e8*constants.c.cgs.value/spec[0]\n nlam = len(nu)\n\n nprocesses = np.min([cfg.par.n_processes,len(stars_list)]) #the pool.map will barf if there are less star bins than process threads\n\n #initialize the process pool and build the chunks\n p = Pool(processes = nprocesses)\n nchunks = nprocesses\n\n\n chunk_start_indices = []\n chunk_start_indices.append(0) #the start index is obviously 0\n\n\n #this should just be int(nstars/nchunks) but in case nstars < nchunks, we need to ensure that this is at least 1\n delta_chunk_indices = np.max([int(nstars / nchunks),1]) \n print ('delta_chunk_indices = ',delta_chunk_indices)\n \n for n in range(1,nchunks):\n chunk_start_indices.append(chunk_start_indices[n-1]+delta_chunk_indices)\n\n '''\n chunk_start_indices = list(np.fix(np.arange(0,nstars,np.fix(nstars/nchunks))))\n #because this can result in too many chunks sometimes given the number of processors:\n chunk_start_indices = chunk_start_indices[0:nchunks]\n '''\n print ('Entering Pool.map multiprocessing for Stellar SED generation')\n list_of_chunks = []\n for n in range(nchunks):\n stars_list_chunk = stars_list[chunk_start_indices[n]:chunk_start_indices[n]+delta_chunk_indices]\n #if we're on the last chunk, we might not have the full list included, so need to make sure that we have that here\n if n == nchunks-1: \n stars_list_chunk = stars_list[chunk_start_indices[n]::]\n\n list_of_chunks.append(stars_list_chunk)\n \n\n t1=datetime.now()\n chunk_sol = p.map(newstars_gen, [arg for arg in list_of_chunks])\n \n t2=datetime.now()\n print ('Execution time for SED generation in Pool.map multiprocessing = '+str(t2-t1))\n\n \n stellar_fnu = np.zeros([nstars,nlam])\n star_counter=0\n for i in range(nchunks):\n fnu_list = chunk_sol[i] #this is a list of the stellar_fnu's returned by that chunk\n for j in range(len(fnu_list)):\n stellar_fnu[star_counter,:] = fnu_list[j,:]\n star_counter+=1\n\n\n\n\n p.close()\n p.terminate()\n p.join()\n\n\n stellar_nu = nu\n\n\n\n if cosmoflag == False:\n\n #calculate the SED for disk stars; note, this gets calculated\n #whether or not disk stars actually exist. if they don't exist,\n #bogus values for the disk age and metallicity are assigned based\n #on whatever par.disk_stars_age and metallicity are. it's no big\n #deal since these SEDs don't end up getting added to the model in\n #source_creation. \n \n #note, even if there are no disk/bulge stars, these are still\n #created since they're completely based on input parameters in\n #parameters_master. they just won't get used at a later point\n #as there will be no disk/bulge star positions to add them to.\n\n #dust_tesc is an absolute value (not relative to min star age) as the ages of these stars are input by the user\n\n # Load in the metallicity legend\n fsps_metals = np.loadtxt(cfg.par.metallicity_legend)\n\n sp.params[\"tage\"] = cfg.par.disk_stars_age\n sp.params[\"imf_type\"] = cfg.par.imf_type\n sp.params[\"imf1\"] = cfg.par.imf1\n sp.params[\"imf2\"] = cfg.par.imf2\n sp.params[\"imf3\"] = cfg.par.imf3\n sp.params[\"pagb\"] = cfg.par.pagb\n sp.params[\"sfh\"] = 0\n sp.params[\"zmet\"] = cfg.par.disk_stars_metals\n sp.params[\"add_neb_emission\"] = cfg.par.add_neb_emission\n sp.params[\"add_agb_dust_model\"] = cfg.par.add_agb_dust_model\n sp.params['gas_logu'] = cfg.par.gas_logu\n if cfg.par.FORCE_gas_logz == False:\n sp.params['gas_logz'] = np.log10(fsps_metals[cfg.par.disk_stars_metals]/cfg.par.solar)\n else:\n sp.params['gas_logz'] = cfg.par.gas_logz\n\n spec = sp.get_spectrum(tage=cfg.par.disk_stars_age,zmet=cfg.par.disk_stars_metals)\n disk_fnu = spec[1]\n \n #calculate the SED for bulge stars\n sp.params[\"tage\"] = cfg.par.bulge_stars_age\n sp.params[\"imf_type\"] = cfg.par.imf_type\n sp.params[\"imf1\"] = cfg.par.imf1\n sp.params[\"imf2\"] = cfg.par.imf2\n sp.params[\"imf3\"] = cfg.par.imf3\n sp.params[\"pagb\"] = cfg.par.pagb\n sp.params[\"sfh\"] = 0\n sp.params[\"zmet\"] = cfg.par.bulge_stars_metals\n sp.params[\"add_neb_emission\"] = cfg.par.add_neb_emission\n sp.params[\"add_agb_dust_model\"] = cfg.par.add_agb_dust_model\n sp.params['gas_logu'] = cfg.par.gas_logu\n if cfg.par.FORCE_gas_logz == False:\n sp.params['gas_logz'] = np.log10(fsps_metals[cfg.par.bulge_stars_metals]/cfg.par.solar)\n else:\n sp.params['gas_logz'] = cfg.par.gas_logz\n\n\n spec = sp.get_spectrum(tage=cfg.par.bulge_stars_age,zmet=cfg.par.bulge_stars_metals)\n bulge_fnu = spec[1]\n \n\n else: #we have a cosmological simulation\n\n disk_fnu = []\n bulge_fnu = []\n \n\n total_lum_in_sed_gen = 0.\n for i in range(stellar_fnu.shape[0]):\n total_lum_in_sed_gen += np.absolute(np.trapz(stellar_fnu[i,:],x=nu))\n\n print ('[SED_gen: ] total_lum_in_sed_gen = ',total_lum_in_sed_gen)\n\n #return positions,disk_positions,bulge_positions,mass,stellar_nu,stellar_fnu,disk_masses,disk_fnu,bulge_masses,bulge_fnu\n return stellar_nu,stellar_fnu,disk_fnu,bulge_fnu\n\n\ndef newstars_gen(stars_list):\n global sp\n if sp is None:\n sp = fsps.StellarPopulation()\n\n #the newstars (particle type 4; so, for cosmological runs, this is all\n #stars) are calculated in a separate function with just one argument so that it is can be fed \n #into pool.map for multithreading.\n #sp = fsps.StellarPopulation()\n sp.params[\"tage\"] = stars_list[0].age\n sp.params[\"imf_type\"] = cfg.par.imf_type\n sp.params[\"pagb\"] = cfg.par.pagb\n sp.params[\"sfh\"] = 0\n sp.params[\"zmet\"] = stars_list[0].fsps_zmet\n sp.params[\"add_neb_emission\"] = False\n sp.params[\"add_agb_dust_model\"] = cfg.par.add_agb_dust_model\n\n #first figure out how many wavelengths there are\n \n spec = sp.get_spectrum(tage=stars_list[0].age,zmet=stars_list[0].fsps_zmet)\n nu = 1.e8*constants.c.cgs.value/spec[0]\n\n nlam = len(nu)\n\n stellar_nu = np.zeros([nlam])\n stellar_fnu = np.zeros([len(stars_list),nlam])\n \n \n minage = 13 #Gyr\n for i in range(len(stars_list)): \n if stars_list[i].age < minage:\n minage = stars_list[i].age\n\n tesc_age = np.log10((minage+cfg.par.birth_cloud_clearing_age)*1.e9)\n\n\n # Get the number of ionizing photons from SED\n\n #calculate the SEDs for new stars\n for i in range(len(stars_list)):\n \n sp.params[\"tage\"] = stars_list[i].age\n sp.params[\"imf_type\"] = cfg.par.imf_type\n sp.params[\"imf1\"] = cfg.par.imf1\n sp.params[\"imf2\"] = cfg.par.imf2\n sp.params[\"imf3\"] = cfg.par.imf3\n sp.params[\"pagb\"] = cfg.par.pagb\n sp.params[\"sfh\"] = 0\n sp.params[\"zmet\"] = stars_list[i].fsps_zmet\n sp.params[\"add_neb_emission\"] = False\n sp.params[\"add_agb_dust_model\"] = cfg.par.add_agb_dust_model\n\n if cfg.par.CF_on == True:\n sp.params[\"dust_type\"] = 0\n sp.params[\"dust1\"] = 1\n sp.params[\"dust2\"] = 0\n sp.params[\"dust_tesc\"] = tesc_age\n\n spec_noneb = sp.get_spectrum(tage=stars_list[i].age,zmet=stars_list[i].fsps_zmet)\n f = spec_noneb[1]\n\n pagb = cfg.par.add_pagb_stars and cfg.par.PAGB_min_age <= stars_list[i].age <= cfg.par.PAGB_max_age\n young_star = cfg.par.add_young_stars and cfg.par.HII_min_age <= stars_list[i].age <= cfg.par.HII_max_age\n\n if (cfg.par.add_neb_emission or cfg.par.use_cmdf) and (young_star or pagb):\n\n # Cluster Mass Distribution Funtion is used only when the star particle's mass is gretaer than the maximum cluster mass and use_cmdf is True. \n\n if stars_list[i].mass/constants.M_sun.cgs.value > 10**cfg.par.cmdf_max_mass and cfg.par.use_cmdf:\n cluster_mass, num_clusters = cmdf(stars_list[i].mass/constants.M_sun.cgs.value,int(cfg.par.cmdf_bins),cfg.par.cmdf_min_mass,\n cfg.par.cmdf_max_mass, cfg.par.cmdf_beta)\n \n else:\n cluster_mass = [np.log10(stars_list[i].mass/constants.M_sun.cgs.value)]\n num_clusters = [1]\n\n f = np.zeros(nlam)\n cloudy_nlam = len(np.genfromtxt(cfg.par.pd_source_dir + \"/powderday/nebular_emission/data/refLines.dat\", delimiter=','))\n line_em = np.zeros([cloudy_nlam])\n \n for j in range(len(cluster_mass)):\n num_HII_clusters = num_clusters[j]\n neb_file_output = cfg.par.NEB_DEBUG\n\n sp.params[\"add_neb_emission\"] = False\n if cfg.par.add_neb_emission:\n # id_val = 0, 1, 2 for young stars, Post-AGB star and AGNs respectively.\n if young_star:\n id_val = 0\n Rinner_per_Rs = cfg.par.HII_Rinner_per_Rs\n nh = cfg.par.HII_nh \n escape_fraction = cfg.par.HII_escape_fraction\n \n elif pagb:\n id_val = 1\n Rinner_per_Rs = cfg.par.PAGB_Rinner_per_Rs\n nh = cfg.par.PAGB_nh \n escape_fraction = cfg.par.PAGB_escape_fraction\n\n if cfg.par.HII_alpha_enhance: #Setting Zstar based on Fe/H \n Fe = stars_list[i].all_metals[-1]\n\n # Gizmo metallicity structure, photospheric abundances from Asplund et al. 2009:\n # Photospheric mass fraction of H = 0.7381\n # Photospheric mass fraction of Fe = 1.31e-3\n\n # Converting from mass fraction to atomic fraction of Fe\n # Taking atmoic mass of H = 1.008u\n # Taking atmoic mass of Fe = 55.845u\n FeH = (Fe/0.7381)*(1.008/55.845)\n\n # Solar atomic fraction of Fe. Calculated by substituting Fe = 1.31e-3 in the previous equation\n FeH_sol = 3.22580645e-5\n\n Logzsol = np.log10(FeH/FeH_sol)\n \n sp1 = fsps.StellarPopulation(zcontinuous=1)\n sp1.params[\"tage\"] = stars_list[i].age\n sp1.params[\"imf_type\"] = cfg.par.imf_type\n sp1.params[\"imf1\"] = cfg.par.imf1\n sp1.params[\"imf2\"] = cfg.par.imf2\n sp1.params[\"imf3\"] = cfg.par.imf3\n sp1.params[\"pagb\"] = cfg.par.pagb\n sp1.params[\"sfh\"] = 0\n sp1.params[\"zmet\"] = stars_list[i].fsps_zmet\n sp1.params[\"add_neb_emission\"] = False\n sp1.params[\"add_agb_dust_model\"] = cfg.par.add_agb_dust_model\n sp1.params[\"logzsol\"] = Logzsol\n\n if cfg.par.CF_on == True:\n sp1.params[\"dust_type\"] = 0\n sp1.params[\"dust1\"] = 1\n sp1.params[\"dust2\"] = 0\n sp1.params[\"dust_tesc\"] = tesc_age\n\n spec = sp1.get_spectrum(tage=stars_list[i].age)\n\n else:\n spec = sp.get_spectrum(tage=stars_list[i].age,zmet=stars_list[i].fsps_zmet)\n\n alpha = 2.5e-13 # Recombination Rate (assuming T = 10^4 K)\n\n if cfg.par.FORCE_gas_logu[id_val]:\n LogU = cfg.par.gas_logu[id_val]\n LogQ = np.log10((10 ** (3*LogU))*(36*np.pi*(constants.c.cgs.value**3))/((alpha**2)*nh))\n Rs = ((3*(10 ** LogQ))/(4*np.pi*(nh**2)*alpha))**(1./3.)\n \n elif cfg.par.FORCE_logq[id_val]:\n LogQ = cfg.par.source_logq[id_val]\n Rs = ((3*(10 ** LogQ))/(4*np.pi*(nh**2)*alpha))**(1./3.)\n LogU = np.log10((10**LogQ)/(4*np.pi*Rs*Rs*nh*constants.c.cgs.value))\n\n else:\n LogQ = calc_LogQ(1.e8*constants.c.cgs.value/spec[0], spec[1]*constants.L_sun.cgs.value\n , efrac=escape_fraction, mstar=10**cluster_mass[j]) \n Rs = ((3*(10 ** LogQ))/(4*np.pi*(nh**2)*alpha))**(1./3.)\n LogU = np.log10((10**LogQ)/(4*np.pi*Rs*Rs*nh*constants.c.cgs.value))+cfg.par.gas_logu_init[id_val]\n LogQ = np.log10((10 ** (3*LogU))*(36*np.pi*(constants.c.cgs.value**3))/((alpha**2)*nh))\n Rs = ((3*(10 ** LogQ))/(4*np.pi*(nh**2)*alpha))**(1./3.)\n\n if cfg.par.FORCE_inner_radius[id_val]:\n Rin = cfg.par.inner_radius[id_val]\n\n else:\n Rin = Rinner_per_Rs*Rs\n\n if cfg.par.FORCE_gas_logz[id_val]:\n LogZ = cfg.par.gas_logz[id_val]\n \n else:\n LogZ = np.log10(stars_list[i].metals/cfg.par.solar)\n\n\n if neb_file_output:\n if cfg.par.use_cloudy_tables:\n Rin = 1.e19 # Rinner is fixed at 1.e19 cm for lookup tables\n \n if cfg.par.FORCE_inner_radius[id_val]:\n Rin = cfg.par.inner_radius[id_val]\n \n LogU = np.log10((10**LogQ)/(4*np.pi*Rin*Rin*nh*constants.c.cgs.value))\n\n logu_diagnostic(LogQ, LogU, LogZ, Rs, 10**cluster_mass[j], num_HII_clusters, stars_list[i].age, append=True)\n neb_file_output = False\n\n sp.params['gas_logu'] = LogU\n sp.params['gas_logz'] = LogZ\n sp.params[\"add_neb_emission\"] = True \n if cfg.par.use_cloudy_tables:\n lam_neb, spec_neb = sp.get_spectrum(tage=stars_list[i].age, zmet=stars_list[i].fsps_zmet)\n line_lum = sp.emline_luminosity\n wave_line = sp.emline_wavelengths\n else:\n try:\n # Calculating ionizing photons again but for 1 Msun in order to scale the output for FSPS\n LogQ_1 = calc_LogQ(1.e8 * constants.c.cgs.value / spec[0], spec[1] * constants.L_sun.cgs.value,\n efrac=escape_fraction) \n #LogQ_1 = LogQ_1 + cfg.par.gas_logu_init[id_val]\n \n spec_neb, wave_line, line_lum = get_nebular(spec[0], spec[1], nh, LogQ, Rin, LogU, LogZ, LogQ_1, stars_list[i].all_metals, \n Dust=False, abund=cfg.par.neb_abund[id_val], clean_up = cfg.par.cloudy_cleanup, index=id_val)\n except ValueError as err:\n # If the CLOUDY run crashes we switch to using lookup tables for young stars but throw an error for post-AGB stars.\n if young_star:\n print (\"WARNING: Switching to using lookup tables pre-packed with FSPS to calculate nebular emission for this particle.\") \n print (\"WARNING: The emission line fluxes repoted may not be accurate if the particle lies outside the range of the lookup table paramters.\")\n lam_neb, spec_neb = sp.get_spectrum(tage=stars_list[i].age, zmet=stars_list[i].fsps_zmet)\n line_lum = sp.emline_luminosity\n wave_line = sp.emline_wavelengths\n else:\n print (\"ERROR: Can't switch to using lookup tables.\")\n print (\"ERROR: Please check the CLOUDY output file to figure out why the run was unsuccessful\" )\n raise ValueError('CLOUDY run was unsucessful')\n \n else:\n lam_neb, spec_neb = sp.get_spectrum(tage=stars_list[i].age, zmet=stars_list[i].fsps_zmet)\n\n weight = num_HII_clusters*(10**cluster_mass[j])/(stars_list[i].mass/constants.M_sun.cgs.value) \n f = f + spec_neb*weight\n if cfg.par.add_neb_emission and cfg.par.dump_emlines:\n line_em = line_em + line_lum*weight\n \n if cfg.par.add_neb_emission and cfg.par.dump_emlines:\n #the stellar population returns the calculation in units of Lsun/1 Msun: https://github.com/dfm/python-fsps/issues/117#issuecomment-546513619\n line_em = line_em * ((stars_list[i].mass*u.g).to(u.Msun).value) * (3.839e33) # Units: ergs/s\n line_em = np.append(line_em, stars_list[i].age)\n dump_emlines(wave_line, line_em)\n\n stellar_nu[:] = 1.e8*constants.c.cgs.value/spec[0]\n stellar_fnu[i,:] = f\n\n return stellar_fnu\n\n\ndef get_gas_metals(ngas):\n # This function outputs the metallicity (total as well as all the 10 elements tracked by the simulation)\n # for all the gas particles\n reg = reg_gl\n el = ['He', 'C', 'N', 'O', 'Ne', 'Mg', 'Si', 'S', 'Ca', 'Fe']\n metals = np.zeros((ngas,11))-10.0\n try:\n for i in range(11):\n if i == 0:\n el_str = \"\"\n else:\n el_str = \"_\"+el[i-1]\n metals[:, i] = reg[\"gasmetals\"+el_str].value\n except:\n metals[:,0] = reg[\"gasmetals\"].value\n \n return metals\n\n\ndef get_nearest_gas_metals(all_gas_coordinates, particle_coordinates):\n\n all_gas_metals = get_gas_metals(len(all_gas_coordinates))\n \n # Getting N nearest gas particles to the AGN where N is defined by cfg.par.AGN_num_gas\n nearest_gas_dist, nearest_gas_id = get_nearest(all_gas_coordinates, particle_coordinates, num=cfg.par.AGN_num_gas)\n \n metals_avg = []\n \n # We take the distance weighted avearge of the metallicity of nearest N gas particles.\n # This is used as input to the CLOUDY model.\n for q in range(11):\n nearest_gas_metals = np.array(all_gas_metals[:,q][nearest_gas_id])\n metals_avg.append(np.sum(nearest_gas_metals*nearest_gas_dist)/np.sum(nearest_gas_dist))\n\n return metals_avg\n \n\ndef get_agn_seds(agn_ids, reg):\n \n print ('Starting AGN SED generation')\n \n t1 = datetime.now()\n nprocesses = np.min([cfg.par.n_processes,len(agn_ids)])\n p = Pool(processes = nprocesses)\n\n # Pre-calculating average metallicity and fluxes for all the BH particles\n nu = []\n fnu_in = []\n metals_avg = []\n for agn_id in agn_ids:\n fnu_in.append(reg[\"bhsed\"][agn_id,:].in_units(\"Lsun\").value/reg[\"bhnu\"].in_units(\"Hz\").value)\n nu.append(reg[\"bhnu\"].in_units(\"Hz\").value)\n all_gas_coordinates = reg[\"gascoordinates\"].in_units('kpc').value\n agn_coordinates = reg[\"bhcoordinates\"][agn_id].in_units('kpc').value\n metals_avg.append(get_nearest_gas_metals(all_gas_coordinates, agn_coordinates))\n\n z = zip(agn_ids, nu, fnu_in, metals_avg)\n fnu_out = p.starmap(agn_sed, z)\n fnu_out = np.atleast_2d(fnu_out)\n p.close()\n p.terminate()\n p.join()\n t2 = datetime.now()\n\n print ('Execution time for AGN SED generation = '+str(t2-t1))\n \n return fnu_out\n\n\ndef agn_sed(agn_id, nu, fnu, metals_avg):\n agn_id = int(agn_id)\n\n # Hopkins model returns the nu and fnu in reversed order. \n # Thus, we have to reverse it back to make it compatible.\n if cfg.par.BH_model != 'Nenkova': \n nu = nu[::-1]\n fnu = fnu[::-1]\n\n if cfg.par.add_neb_emission and cfg.par.add_AGN_neb:\n \n id_val = 2\n \n tot_metals = metals_avg[0]\n metals = metals_avg\n \n if cfg.par.FORCE_gas_logz[id_val]:\n LogZ = gas_logz[id_val]\n \n else:\n LogZ = tot_metals/cfg.par.solar\n\n Rin = cfg.par.inner_radius[id_val]\n\n if cfg.par.FORCE_gas_logu[id_val]:\n LogU = cfg.par.gas_logu[id_val]\n LogQ = np.log10((10**LogU)*(4*np.pi*Rin*Rin*cfg.par.AGN_nh*constants.c.cgs.value))\n \n elif cfg.par.FORCE_logq[id_val]:\n LogQ = cfg.par.source_logq[id_val]\n LogU = np.log10((10**LogQ)/(4*np.pi*Rin*Rin*cfg.par.AGN_nh*constants.c.cgs.value))\n\n else:\n LogQ = calc_LogQ(nu, fnu*constants.L_sun.cgs.value)\n LogU = np.log10((10**LogQ)/(4*np.pi*Rin*Rin*cfg.par.AGN_nh*constants.c.cgs.value))+cfg.par.gas_logu_init[id_val]\n LogQ = np.log10((10**LogU)*(4*np.pi*Rin*Rin*cfg.par.AGN_nh*constants.c.cgs.value))\n\n spec, wave_line, line_lum = get_nebular(1.e8 * constants.c.cgs.value / nu, fnu, cfg.par.AGN_nh, LogQ, Rin, LogU, LogZ, LogQ, metals,\n Dust=False, abund=cfg.par.neb_abund[id_val],clean_up = cfg.par.cloudy_cleanup, index=id_val)\n\n if cfg.par.dump_emlines:\n # The stellar population returns the calculation in units of Lsun\n line_em = line_lum * 3.839e33 # Units: ergs/s\n # The last column in dump_emlines is reserved for age of the star particle. For AGN we just set it to -1 as a place holder.\n line_em = np.append(line_em, -1.0)\n dump_emlines(wave_line, line_em)\n\n else:\n spec = fnu\n\n return spec\n\n\ndef fsps_metallicity_interpolate(metals):\n\n # takes a list of metallicities for star particles, and returns a\n # list of interpolated metallicities\n \n fsps_metals = np.loadtxt(cfg.par.metallicity_legend)\n nstars = len(metals)\n \n zmet = []\n\n for i in range(nstars):\n zmet.append(find_nearest_zmet(fsps_metals,metals[i]))\n \n return zmet\n \ndef find_nearest_zmet(array,value):\n # this is modified from the normal find_nearest in that it forces\n # the output to be 1 index higher than the true value since the\n # minimum zmet value fsps will take is 1 (not 0)\n\n idx = (np.abs(array-value)).argmin()\n \n return idx+1 \n", "meta": {"hexsha": "57daa7b3f400a999d6c607a6c02a23510a6a3d6f", "size": 31203, "ext": "py", "lang": "Python", "max_stars_repo_path": "powderday/SED_gen.py", "max_stars_repo_name": "jwise77/powderday", "max_stars_repo_head_hexsha": "66a5ce6b13f0e96ab9e5beeef0da339d36f18984", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "powderday/SED_gen.py", "max_issues_repo_name": "jwise77/powderday", "max_issues_repo_head_hexsha": "66a5ce6b13f0e96ab9e5beeef0da339d36f18984", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "powderday/SED_gen.py", "max_forks_repo_name": "jwise77/powderday", "max_forks_repo_head_hexsha": "66a5ce6b13f0e96ab9e5beeef0da339d36f18984", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.0525606469, "max_line_length": 173, "alphanum_fraction": 0.5958401436, "include": true, "reason": "import numpy,from scipy,import astropy,from astropy", "num_tokens": 8219, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5813030761371502, "lm_q2_score": 0.3380771308191988, "lm_q1q2_score": 0.196525276116822}} {"text": "# Contents in this file are specified for RASCIL\n\nimport ctypes\nimport os\nimport warnings\n\nimport numpy as np\nfrom ctypes import c_double\nfrom ctypes import c_int\nfrom ctypes import c_float\nfrom ctypes import c_void_p\n\nc_int_p = ctypes.POINTER(c_int)\nc_float_p = ctypes.POINTER(c_float)\nc_double_p = ctypes.POINTER(c_double)\n\n# TODO: See if there is a way to improve this so it is less hacky.\nlib = None\n# Try to load a local library directly.\nlib_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),\"libcurafft.so\")\ntry:\n lib = ctypes.cdll.LoadLibrary(lib_path)\nexcept Exception:\n raise RuntimeError('Failed to find curagridder library')\n\n\n\n\nms2dirty_1 = lib.ms2dirty_1\n# the last two parameters have default value\nms2dirty_1.argtypes = [c_int, c_int, c_int, c_double, c_double, np.ctypeslib.ndpointer(np.double, flags='C'),\n np.ctypeslib.ndpointer(np.complex128, flags='C'), np.ctypeslib.ndpointer(np.complex128, flags='C'), c_double, c_double, c_int] \nms2dirty_1.restype = c_int\n\nms2dirty_2 = lib.ms2dirty_2\nms2dirty_2.argtypes = [c_int, c_int, c_int, c_double, c_double, np.ctypeslib.ndpointer(np.double, flags='C'),\n np.ctypeslib.ndpointer(np.complex128, flags='C'), np.ctypeslib.ndpointer(np.double, flags='C'), np.ctypeslib.ndpointer(np.complex128, flags='C'), c_double, c_double, c_int] \nms2dirty_2.restype = c_int\n\ndirty2ms_1 = lib.dirty2ms_1\n# the last two parameters have default value\ndirty2ms_1.argtypes = [c_int, c_int, c_int, c_double, c_double, np.ctypeslib.ndpointer(np.double, flags='C'),\n np.ctypeslib.ndpointer(np.complex128, flags='C'), np.ctypeslib.ndpointer(np.complex128, flags='C'), c_double, c_double, c_int] \ndirty2ms_1.restype = c_int\n\ndirty2ms_2 = lib.dirty2ms_2\ndirty2ms_2.argtypes = [c_int, c_int, c_int, c_double, c_double, np.ctypeslib.ndpointer(np.double, flags='C'),\n np.ctypeslib.ndpointer(np.complex128, flags='C'), np.ctypeslib.ndpointer(np.double, flags='C'), np.ctypeslib.ndpointer(np.complex128, flags='C'), c_double, c_double, c_int] \ndirty2ms_2.restype = c_int\n\n#----------------------------------------\n# the interfaces below are idential to NIFTY\n#-----------------------------------------\n\ndef ms2dirty(uvw, freq, ms, wgt, nxdirty, nydirty, rad_pix_x, rad_pix_y, nx, ny, epsilon, do_wstacking, *args):\n \"\"\"\n Generate an image from visibility by non-uniform fourier transform\n Arguments:\n uvw - 3D coordinates, numpy array, shape - (nrow,3)\n freq - frequencies\n ms - visibility, shape - (nrow,)\n wgt - weight\n nxdirty, nydirty - image size\n deg_pix_ - degree per pixel\n epsilon - tolerance of relative error (expect, default 1e-6)\n do_wstacking - True, improved w stacking.\n \n Return:\n dirty image - shape-[nxdirty,nydirty]\n \"\"\"\n nrow = uvw.shape[0]\n sigma = 2\n fov = rad_pix_x * nxdirty * 180 / np.pi\n dirty = np.zeros((nxdirty,nydirty),dtype=np.complex128)\n sign = -1\n # u = np.ctypeslib.as_ctypes(uvw[:,0])\n # v = np.ctypeslib.as_ctypes(uvw[:,1])\n # w = np.ctypeslib.as_ctypes(uvw[:,2])\n if(wgt is None):\n ms2dirty_1(nrow,nxdirty,nydirty,fov,freq[0],uvw\n ,ms,dirty,epsilon,sigma,sign)\n else:\n ms2dirty_2(nrow,nxdirty,nydirty,fov,freq[0],uvw\n ,ms,wgt,dirty,epsilon,sigma,sign)\n dirty = np.reshape(dirty,[nxdirty,nydirty])\n return dirty.real\n\ndef dirty2ms(uvw, freq, dirty, wgt, rad_pix_x, rad_pix_y, nx, ny, epsilon, do_wstacking, *args):\n \"\"\"\n Generate Visibility from dirty image by non-uniform fourier transform\n Arguments:\n uvw - 3D coordinates, numpy array, shape - (nrow,3)\n freq - frequencies\n ms - visibility, shape - (nrow,)\n wgt - weight\n nxdirty, nydirty - image size\n fov - field of view\n epsilon - tolerance of relative error (expect, default 1e-6)\n sigma - upsampling factor for grid (default 1.25)\n Return:\n vis - shape-[M,]\n \"\"\"\n nrow = uvw.shape[0]\n nxdirty = dirty.shape[0]\n nydirty = dirty.shape[1]\n sigma = 2\n fov = rad_pix_x * nxdirty * 180 / np.pi\n sign = -1\n ms = np.zeros((nrow,1),dtype=np.complex128)\n dirty1 = np.zeros(dirty.shape,dtype=np.complex128)\n dirty1.real = dirty\n\n if(wgt is None):\n dirty2ms_1(nrow,nxdirty,nydirty,fov,freq[0],uvw\n ,ms,dirty1,epsilon,sigma,sign)\n else:\n dirty2ms_2(nrow,nxdirty,nydirty,fov,freq[0],uvw\n ,ms,wgt,dirty1,epsilon,sigma,sign)\n return ms", "meta": {"hexsha": "039c3b2871a5e4aab71e2b2174969f3041cec7b7", "size": 4552, "ext": "py", "lang": "Python", "max_stars_repo_path": "python/curagridder/cursl.py", "max_stars_repo_name": "astronomical-data-processing/curig", "max_stars_repo_head_hexsha": "4d0e944b8c67e99106e56decda00c9c424002625", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "python/curagridder/cursl.py", "max_issues_repo_name": "astronomical-data-processing/curig", "max_issues_repo_head_hexsha": "4d0e944b8c67e99106e56decda00c9c424002625", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-03-14T02:06:55.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-14T08:50:30.000Z", "max_forks_repo_path": "python/curagridder/cursl.py", "max_forks_repo_name": "astronomical-data-processing/curig", "max_forks_repo_head_hexsha": "4d0e944b8c67e99106e56decda00c9c424002625", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-13T10:42:03.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-13T10:42:03.000Z", "avg_line_length": 38.2521008403, "max_line_length": 194, "alphanum_fraction": 0.6625659051, "include": true, "reason": "import numpy", "num_tokens": 1350, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5813030906443134, "lm_q2_score": 0.33807711081162, "lm_q1q2_score": 0.19652526939089474}} {"text": "# coding: utf-8\n# Copyright (c) Tingzheng Hou.\n# Distributed under the terms of the MIT License.\n\nimport numpy as np\nfrom tqdm.notebook import tqdm\nfrom MDAnalysis.analysis.distances import distance_array\nfrom scipy.signal import savgol_filter\nfrom mdgo.util import atom_vec\n\n__author__ = \"Tingzheng Hou\"\n__version__ = \"1.0\"\n__maintainer__ = \"Tingzheng Hou\"\n__email__ = \"tingzheng_hou@berkeley.edu\"\n__date__ = \"Feb 9, 2021\"\n\n\ndef trajectory(nvt_run, li_atom, run_start, run_end, species, selection_dict, distance):\n dist_values = {}\n time_count = 0\n trj_analysis = nvt_run.trajectory[run_start:run_end:]\n if species not in list(selection_dict):\n print(\"Invalid species selection\")\n return None\n for ts in trj_analysis:\n selection = (\n \"(\" + selection_dict.get(species) + \") and (around \" + str(distance) + \" index \" + str(li_atom.id - 1) + \")\"\n )\n shell = nvt_run.select_atoms(selection, periodic=True)\n for atom in shell.atoms:\n if str(atom.id) not in dist_values:\n dist_values[str(atom.id)] = np.full(run_end - run_start, 100.0)\n time_count += 1\n time_count = 0\n for ts in trj_analysis:\n for atomid in dist_values.keys():\n dist = distance_array(ts[li_atom.id - 1], ts[(int(atomid) - 1)], ts.dimensions)\n dist_values[atomid][time_count] = dist\n time_count += 1\n return dist_values\n\n\ndef find_nearest(trj, time_step, distance, hopping_cutoff, smooth=51):\n \"\"\"Returns an array of binding sites (unique on each timestep),\n the frequency of hopping between sites, and steps when each binding site\n exhibits the closest distance to the central atom.\n\n Args:\n trj (dict): A python dict of distances between central atom and selected atoms.\n time_step (int): The time step of the simulation.\n distance (int or float): Binding cutoff distance.\n hopping_cutoff: (int or float): Detaching cutoff distance.\n smooth (int): The length of the smooth filter window. Default to 51.\n \"\"\"\n time_span = len(list(trj.values())[0])\n for kw in list(trj):\n trj[kw] = savgol_filter(trj.get(kw), smooth, 2)\n site_distance = [100 for _ in range(time_span)]\n sites = [0 for _ in range(time_span)]\n sites[0] = min(trj, key=lambda k: trj[k][0])\n site_distance[0] = trj.get(sites[0])[0]\n for time in range(1, time_span):\n if sites[time - 1] == 0:\n old_site_distance = 100\n else:\n old_site_distance = trj.get(sites[time - 1])[time]\n if old_site_distance > hopping_cutoff:\n new_site = min(trj, key=lambda k: trj[k][time])\n new_site_distance = trj.get(new_site)[time]\n if new_site_distance > distance:\n site_distance[time] = 100\n else:\n sites[time] = new_site\n site_distance[time] = new_site_distance\n else:\n sites[time] = sites[time - 1]\n site_distance[time] = old_site_distance\n sites = [int(i) for i in sites]\n sites_and_distance_array = np.array([[sites[i], site_distance[i]] for i in range(len(sites))])\n steps = []\n closest_step = 0\n previous_site = sites_and_distance_array[0][0]\n for i, step in enumerate(sites_and_distance_array):\n site = step[0]\n distance = step[1]\n if site == 0:\n pass\n else:\n if site == previous_site:\n if distance < sites_and_distance_array[closest_step][1]:\n closest_step = i\n else:\n pass\n else:\n steps.append(closest_step)\n closest_step = i\n previous_site = site\n if previous_site is not None:\n steps.append(closest_step)\n change = (np.diff([i for i in sites if i != 0]) != 0).sum()\n frequency = change / (time_span * time_step)\n return sites, frequency, steps\n\n\ndef find_in_n_out(trj, distance, hopping_cutoff, smooth=51, cool=20):\n \"\"\"Returns two arrays of time step of hopping in and hopping out, respectively.\n\n Args:\n trj (dict): A python dict of distances between central atom and selected atoms.\n distance (int or float): Binding cutoff distance.\n hopping_cutoff: (int or float): Detaching cutoff distance.\n smooth (int): The length of the smooth filter window. Default to 51.\n cool (int): The cool down timesteps between hopping in and hopping out.\n \"\"\"\n time_span = len(list(trj.values())[0])\n for kw in list(trj):\n trj[kw] = savgol_filter(trj.get(kw), smooth, 2)\n site_distance = [100 for _ in range(time_span)]\n sites = [0 for _ in range(time_span)]\n sites[0] = min(trj, key=lambda k: trj[k][0])\n site_distance[0] = trj.get(sites[0])[0]\n for time in range(1, time_span):\n if sites[time - 1] == 0:\n old_site_distance = 100\n else:\n old_site_distance = trj.get(sites[time - 1])[time]\n if old_site_distance > hopping_cutoff:\n new_site = min(trj, key=lambda k: trj[k][time])\n new_site_distance = trj.get(new_site)[time]\n if new_site_distance > distance:\n site_distance[time] = 100\n else:\n sites[time] = new_site\n site_distance[time] = new_site_distance\n else:\n sites[time] = sites[time - 1]\n site_distance[time] = old_site_distance\n sites = [int(i) for i in sites]\n\n last = sites[0]\n steps_in = list()\n steps_out = list()\n in_cool = cool\n out_cool = cool\n for i, s in enumerate(sites):\n if last == s:\n pass\n elif last == 0:\n in_cool = 0\n steps_in.append(i)\n if out_cool < cool:\n steps_out.pop()\n elif s == 0:\n out_cool = 0\n steps_out.append(i)\n if in_cool < cool:\n steps_in.pop()\n else:\n pass\n last = s\n in_cool += 1\n out_cool += 1\n return steps_in, steps_out\n\n\ndef check_contiguous_steps(nvt_run, li_atom, species_dict, select_dict, run_start, run_end, checkpoints, lag=20):\n \"\"\"Returns two arrays of time step of hopping in and hopping out, respectively.\n\n Args:\n nvt_run (MDAnalysis.Universe): An Universe object of wrapped trajectory.\n li_atom (MDAnalysis.core.groups.Atom): the interested central atom object.\n species_dict (dict): Dict of Cutoff distance of neighbor for each species.\n select_dict (dict): A dictionary of selection language of atom species.\n run_start (int): Start time step.\n run_end (int): End time step.\n checkpoints (numpy.array): The time step of interest to check for contiguous steps\n lag (int): The range (+/- lag) of the contiguous steps\n \"\"\"\n coord_num = {x: [[] for _ in range(lag * 2 + 1)] for x in species_dict.keys()}\n trj_analysis = nvt_run.trajectory[run_start:run_end:]\n has = False\n for i, ts in enumerate(trj_analysis):\n log = False\n checkpoint = None\n for j in checkpoints:\n if abs(i - j) <= lag:\n log = True\n has = True\n checkpoint = j\n if log:\n for kw in species_dict.keys():\n selection = (\n \"(\"\n + select_dict[kw]\n + \") and (around \"\n + str(species_dict[kw])\n + \" index \"\n + str(li_atom.id - 1)\n + \")\"\n )\n shell = nvt_run.select_atoms(selection, periodic=True)\n coord_num[kw][i - checkpoint + lag].append(len(shell))\n if has:\n for kw in coord_num:\n np_arrays = np.array([np.array(time).mean() for time in coord_num[kw]])\n coord_num[kw] = np_arrays\n return coord_num\n\n\ndef heat_map(\n nvt_run,\n li_atom,\n sites,\n dist_to_center,\n bind_atom_type,\n cartesian_by_ref,\n run_start,\n run_end,\n):\n trj_analysis = nvt_run.trajectory[run_start:run_end:]\n coordinates = []\n for i, ts in enumerate(trj_analysis):\n if sites[i] == 0:\n pass\n else:\n center_atom = nvt_run.select_atoms(\"index \" + str(sites[i] - 1))[0]\n selection = (\n \"(\"\n + bind_atom_type\n + \") and \"\n + \"(around \"\n + str(dist_to_center)\n + \" index \"\n + str(center_atom.id - 1)\n + \")\"\n )\n bind_atoms = nvt_run.select_atoms(selection, periodic=True)\n distances = distance_array(ts[li_atom.id - 1], bind_atoms.positions, ts.dimensions)\n idx = np.argpartition(distances[0], 3)\n vertex_atoms = bind_atoms[idx[:3]]\n vector_li = atom_vec(li_atom, center_atom, ts.dimensions)\n vector_a = atom_vec(vertex_atoms[0], center_atom, ts.dimensions)\n vector_b = atom_vec(vertex_atoms[1], center_atom, ts.dimensions)\n vector_c = atom_vec(vertex_atoms[2], center_atom, ts.dimensions)\n basis_abc = np.transpose([vector_a, vector_b, vector_c])\n abc_li = np.linalg.solve(basis_abc, vector_li)\n unit_x = np.linalg.norm(\n cartesian_by_ref[0, 0] * vector_a\n + cartesian_by_ref[0, 1] * vector_b\n + cartesian_by_ref[0, 2] * vector_c\n )\n unit_y = np.linalg.norm(\n cartesian_by_ref[1, 0] * vector_a\n + cartesian_by_ref[1, 1] * vector_b\n + cartesian_by_ref[1, 2] * vector_c\n )\n unit_z = np.linalg.norm(\n cartesian_by_ref[2, 0] * vector_a\n + cartesian_by_ref[2, 1] * vector_b\n + cartesian_by_ref[2, 2] * vector_c\n )\n vector_x = cartesian_by_ref[0] / unit_x\n vector_y = cartesian_by_ref[1] / unit_y\n vector_z = cartesian_by_ref[2] / unit_z\n basis_xyz = np.transpose([vector_x, vector_y, vector_z])\n xyz_li = np.linalg.solve(basis_xyz, abc_li)\n coordinates.append(xyz_li)\n return np.array(coordinates)\n\n\ndef get_full_coords(coords, reflection=None, rotation=None, inversion=None, sample=None):\n coords_full = coords\n if reflection:\n for vec in reflection:\n coords_full = np.concatenate((coords, coords * vec), axis=0)\n if rotation:\n coords_copy = coords_full\n for mat in rotation:\n coords_rot = np.dot(coords_copy, mat)\n coords_full = np.concatenate((coords_full, coords_rot), axis=0)\n if inversion:\n coords_copy = coords_full\n for mat in inversion:\n coords_inv = np.dot(coords_copy, mat)\n coords_full = np.concatenate((coords_full, coords_inv), axis=0)\n if sample:\n index = np.random.choice(coords_full.shape[0], sample, replace=False)\n coords_full = coords_full[index]\n return coords_full\n\n\ndef cluster_coordinates(\n nvt_run,\n select_dict,\n run_start,\n run_end,\n species,\n distance,\n basis_vectors=None,\n cluster_center=\"center\",\n):\n trj_analysis = nvt_run.trajectory[run_start:run_end:]\n cluster_center = nvt_run.select_atoms(select_dict.get(cluster_center), periodic=True)[0]\n selection = (\n \"(\"\n + \" or \".join([s for s in species])\n + \") and (around \"\n + str(distance)\n + \" index \"\n + str(cluster_center.id - 1)\n + \")\"\n )\n print(selection)\n shell = nvt_run.select_atoms(selection, periodic=True)\n cluster = []\n for atom in shell:\n coord_list = []\n for ts in trj_analysis:\n coord_list.append(atom.position)\n cluster.append(np.mean(np.array(coord_list), axis=0))\n cluster = np.array(cluster)\n if basis_vectors:\n if len(basis_vectors) == 2:\n vec1 = basis_vectors[0]\n vec2 = basis_vectors[1]\n vec3 = np.cross(vec1, vec2)\n vec2 = np.cross(vec1, vec3)\n elif len(basis_vectors) == 3:\n vec1 = basis_vectors[0]\n vec2 = basis_vectors[1]\n vec3 = basis_vectors[2]\n else:\n raise ValueError(\"incorrect vector format\")\n vec1 = vec1 / np.linalg.norm(vec1)\n vec2 = vec2 / np.linalg.norm(vec2)\n vec3 = vec3 / np.linalg.norm(vec3)\n basis_xyz = np.transpose([vec1, vec2, vec3])\n cluster_norm = np.linalg.solve(basis_xyz, cluster.T).T\n cluster_norm = cluster_norm - np.mean(cluster_norm, axis=0)\n return cluster_norm\n else:\n return cluster\n\n\ndef num_of_neighbor_one_li(\n nvt_run,\n li_atom,\n species_dict,\n select_dict,\n run_start,\n run_end,\n write=False,\n structure_code=None,\n write_freq=0,\n write_path=None,\n element_id_dict=None,\n):\n\n time_count = 0\n trj_analysis = nvt_run.trajectory[run_start:run_end:]\n cn_values = dict()\n species = list(species_dict.keys())\n for kw in species:\n if kw in select_dict.keys():\n cn_values[kw] = np.zeros(int(len(trj_analysis)))\n else:\n print(\"Invalid species selection\")\n return None\n cn_values[\"total\"] = np.zeros(int(len(trj_analysis)))\n for ts in trj_analysis:\n digit_of_species = len(species) - 1\n for kw in species:\n selection = (\n \"(\"\n + select_dict.get(kw)\n + \") and (around \"\n + str(species_dict.get(kw))\n + \" index \"\n + str(li_atom.id - 1)\n + \")\"\n )\n shell = nvt_run.select_atoms(selection, periodic=True)\n # for each atom in shell, create/add to dictionary\n # (key = atom id, value = list of values for step function)\n for _ in shell.atoms:\n cn_values[kw][time_count] += 1\n cn_values[\"total\"][time_count] += 10 ** digit_of_species\n digit_of_species = digit_of_species - 1\n if write and cn_values[\"total\"][time_count] == structure_code:\n a = np.random.random()\n if a > 1 - write_freq:\n print(\"writing\")\n selection_write = \" or \".join(\n \"(same resid as (\"\n + select_dict.get(kw)\n + \" and around \"\n + str(species_dict.get(kw))\n + \" index \"\n + str(li_atom.id - 1)\n + \"))\"\n for kw in species\n )\n selection_write = \"((\" + selection_write + \")and not \" + select_dict.get(\"cation\") + \")\"\n structure = nvt_run.select_atoms(selection_write, periodic=True)\n li_pos = ts[(int(li_atom.id) - 1)]\n path = write_path + str(li_atom.id) + \"_\" + str(int(ts.time)) + \"_\" + str(structure_code) + \".xyz\"\n write_out(li_pos, structure, element_id_dict, path)\n time_count += 1\n return cn_values\n\n\ndef num_of_neighbor_one_li_simple(nvt_run, li_atom, species_dict, select_dict, run_start, run_end):\n\n time_count = 0\n trj_analysis = nvt_run.trajectory[run_start:run_end:]\n species = list(species_dict.keys())[0]\n if species in select_dict.keys():\n cn_values = np.zeros(int(len(trj_analysis)))\n else:\n print(\"Invalid species selection\")\n return None\n for ts in trj_analysis:\n selection = (\n \"(\"\n + select_dict.get(species)\n + \") and (around \"\n + str(species_dict.get(species))\n + \" index \"\n + str(li_atom.id - 1)\n + \")\"\n )\n shell = nvt_run.select_atoms(selection, periodic=True)\n shell_len = len(shell)\n if shell_len == 0:\n cn_values[time_count] = 1\n elif shell_len == 1:\n selection_species = (\n \"(\"\n + select_dict.get(\"cation\")\n + \" and around \"\n + str(species_dict.get(species))\n + \" index \"\n + str(shell.atoms[0].id - 1)\n + \")\"\n )\n shell_species = nvt_run.select_atoms(selection_species, periodic=True)\n shell_species_len = len(shell_species) - 1\n if shell_species_len == 0:\n cn_values[time_count] = 2\n else:\n cn_values[time_count] = 3\n else:\n cn_values[time_count] = 3\n time_count += 1\n cn_values = {\"total\": cn_values}\n return cn_values\n\n\ndef num_of_neighbor_one_li_simple_extra(nvt_run, li_atom, species, select_dict, distance, run_start, run_end):\n\n time_count = 0\n emc_angle = list()\n ec_angle = list()\n trj_analysis = nvt_run.trajectory[run_start:run_end:]\n if species in select_dict.keys():\n cn_values = np.zeros(int(len(trj_analysis)))\n else:\n print(\"Invalid species selection\")\n return None\n for ts in trj_analysis:\n selection = (\n \"(\" + select_dict.get(species) + \") and (around \" + str(distance) + \" index \" + str(li_atom.id - 1) + \")\"\n )\n shell = nvt_run.select_atoms(selection, periodic=True)\n shell_len = len(shell)\n if shell_len == 0:\n cn_values[time_count] = 1\n elif shell_len == 1:\n selection_species = (\n \"(\"\n + select_dict.get(\"cation\")\n + \" and around \"\n + str(distance)\n + \" index \"\n + str(shell.atoms[0].id - 1)\n + \")\"\n )\n shell_species = nvt_run.select_atoms(selection_species, periodic=True)\n shell_species_len = len(shell_species) - 1\n if shell_species_len == 0:\n cn_values[time_count] = 2\n li_pos = li_atom.position\n p_pos = shell.atoms[0].position\n ec_select = (\n \"(\" + select_dict.get(\"EC\") + \") and (around \" + str(3) + \" index \" + str(li_atom.id - 1) + \")\"\n )\n emc_select = (\n \"(\" + select_dict.get(\"EMC\") + \") and (around \" + str(3) + \" index \" + str(li_atom.id - 1) + \")\"\n )\n ec_group = nvt_run.select_atoms(ec_select, periodic=True)\n emc_group = nvt_run.select_atoms(emc_select, periodic=True)\n for atom in ec_group.atoms:\n theta = angle(p_pos, li_pos, atom.position)\n ec_angle.append(theta)\n for atom in emc_group.atoms:\n theta = angle(p_pos, li_pos, atom.position)\n emc_angle.append(theta)\n else:\n cn_values[time_count] = 3\n else:\n cn_values[time_count] = 3\n time_count += 1\n return cn_values, np.array(ec_angle), np.array(emc_angle)\n\n\ndef num_of_neighbor_one_li_simple_extra_two(nvt_run, li_atom, species_list, select_dict, distances, run_start, run_end):\n time_count = 0\n trj_analysis = nvt_run.trajectory[run_start:run_end:]\n cip_step = list()\n ssip_step = list()\n agg_step = list()\n cn_values = dict()\n for kw in species_list:\n if kw in select_dict.keys():\n cn_values[kw] = np.zeros(int(len(trj_analysis)))\n else:\n print(\"Invalid species selection\")\n return None\n cn_values[\"total\"] = np.zeros(int(len(trj_analysis)))\n for ts in trj_analysis:\n digit_of_species = len(species_list) - 1\n for kw in species_list:\n selection = (\n \"(\"\n + select_dict.get(kw)\n + \") and (around \"\n + str(distances.get(kw))\n + \" index \"\n + str(li_atom.id - 1)\n + \")\"\n )\n shell = nvt_run.select_atoms(selection, periodic=True)\n # for each atom in shell, create/add to dictionary\n # (key = atom id, value = list of values for step function)\n for _ in shell.atoms:\n cn_values[kw][time_count] += 1\n cn_values[\"total\"][time_count] += 10 ** digit_of_species\n digit_of_species = digit_of_species - 1\n\n selection = (\n \"(\"\n + select_dict.get(\"anion\")\n + \") and (around \"\n + str(distances.get(\"anion\"))\n + \" index \"\n + str(li_atom.id - 1)\n + \")\"\n )\n shell = nvt_run.select_atoms(selection, periodic=True)\n shell_len = len(shell)\n if shell_len == 0:\n ssip_step.append(time_count)\n elif shell_len == 1:\n selection_species = (\n \"(\"\n + select_dict.get(\"cation\")\n + \" and around \"\n + str(distances.get(\"anion\"))\n + \" index \"\n + str(shell.atoms[0].id - 1)\n + \")\"\n )\n shell_species = nvt_run.select_atoms(selection_species, periodic=True)\n shell_species_len = len(shell_species) - 1\n if shell_species_len == 0:\n cip_step.append(time_count)\n else:\n agg_step.append(time_count)\n else:\n agg_step.append(time_count)\n time_count += 1\n cn_ssip = dict()\n cn_cip = dict()\n cn_agg = dict()\n for kw in species_list:\n cn_ssip[kw] = np.mean(cn_values[kw][ssip_step])\n cn_cip[kw] = np.mean(cn_values[kw][cip_step])\n cn_agg[kw] = np.mean(cn_values[kw][agg_step])\n return cn_ssip, cn_cip, cn_agg\n\n\ndef angle(a, b, c):\n ba = a - b\n bc = c - b\n cosine_angle = np.dot(ba, bc) / (np.linalg.norm(ba) * np.linalg.norm(bc))\n cosine_angle = np.clip(cosine_angle, -1.0, 1.0)\n angle_in_radian = np.arccos(cosine_angle)\n return np.degrees(angle_in_radian)\n\n\n# Depth-first traversal\ndef num_of_neighbor_one_li_complex(nvt_run, li_atom, species, selection_dict, distance, run_start, run_end):\n time_count = 0\n trj_analysis = nvt_run.trajectory[run_start:run_end:]\n cn_values = np.zeros((int(len(trj_analysis)), 4))\n for ts in trj_analysis:\n cation_list = [li_atom.id]\n anion_list = []\n shell = nvt_run.select_atoms(\n \"(\" + selection_dict.get(species) + \" and around \" + str(distance) + \" index \" + str(li_atom.id - 1) + \")\",\n periodic=True,\n )\n for anion_1 in shell.atoms:\n if anion_1.resid not in anion_list:\n anion_list.append(anion_1.resid)\n cn_values[time_count][0] += 1\n shell_anion_1 = nvt_run.select_atoms(\n \"(type 17 and around 3 resid \" + str(anion_1.resid) + \")\",\n periodic=True,\n )\n for cation_2 in shell_anion_1:\n if cation_2.id not in cation_list:\n cation_list.append(cation_2.id)\n cn_values[time_count][1] += 1\n shell_cation_2 = nvt_run.select_atoms(\n \"(type 15 and around 3 index \" + str(cation_2.id - 1) + \")\",\n periodic=True,\n )\n for anion_3 in shell_cation_2.atoms:\n if anion_3.resid not in anion_list:\n anion_list.append(anion_3.resid)\n cn_values[time_count][2] += 1\n shell_anion_3 = nvt_run.select_atoms(\n \"(type 17 and around 3 resid \" + str(anion_3.resid) + \")\",\n periodic=True,\n )\n for cation_4 in shell_anion_3:\n if cation_4.id not in cation_list:\n cation_list.append(cation_4.id)\n cn_values[time_count][3] += 1\n\n\ndef coord_shell_array(nvt_run, func, li_atoms, species_dict, select_dict, run_start, run_end):\n \"\"\"\n Args:\n nvt_run: MDAnalysis Universe\n func: One of the neighbor statistical method (num_of_neighbor_one_li,\n num_of_neighbor_one_li_simple)\n li_atoms: Atom group of the Li atoms.\n species_dict (dict): A dict of coordination cutoff distance\n of the interested species.\n select_dict: A dictionary of species selection.\n run_start (int): Start time step.\n run_end (int): End time step.\n \"\"\"\n num_array = func(nvt_run, li_atoms[0], species_dict, select_dict, run_start, run_end)\n for li in tqdm(li_atoms[1::]):\n this_li = func(nvt_run, li, species_dict, select_dict, run_start, run_end)\n for kw in num_array.keys():\n num_array[kw] = np.concatenate((num_array.get(kw), this_li.get(kw)), axis=0)\n return num_array\n\n\ndef write_out(li_pos, selection, element_id_dict, path):\n lines = list()\n lines.append(str(len(selection) + 1))\n lines.append(\"\")\n lines.append(\"Li 0.0000000 0.0000000 0.0000000\")\n box = selection.dimensions\n half_box = np.array([box[0], box[1], box[2]]) / 2\n for atom in selection:\n locs = list()\n for i in range(3):\n loc = atom.position[i] - li_pos[i]\n if loc > half_box[i]:\n loc = loc - box[i]\n elif loc < -half_box[i]:\n loc = loc + box[i]\n else:\n pass\n locs.append(loc)\n line = element_id_dict.get(int(atom.type)) + \" \" + \" \".join(str(loc) for loc in locs)\n lines.append(line)\n with open(path, \"w\") as xyz_file:\n xyz_file.write(\"\\n\".join(lines))\n", "meta": {"hexsha": "a6bb30e86483be7b3f47368726dd472439ce0eaf", "size": 25846, "ext": "py", "lang": "Python", "max_stars_repo_path": "mdgo/coordination.py", "max_stars_repo_name": "kdfong/mdgo", "max_stars_repo_head_hexsha": "3505e07a1a4ebb73db20ade6e72810f0efac1fef", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "mdgo/coordination.py", "max_issues_repo_name": "kdfong/mdgo", "max_issues_repo_head_hexsha": "3505e07a1a4ebb73db20ade6e72810f0efac1fef", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "mdgo/coordination.py", "max_forks_repo_name": "kdfong/mdgo", "max_forks_repo_head_hexsha": "3505e07a1a4ebb73db20ade6e72810f0efac1fef", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.6763848397, "max_line_length": 120, "alphanum_fraction": 0.5526967422, "include": true, "reason": "import numpy,from scipy", "num_tokens": 6183, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.546738151984614, "lm_q2_score": 0.35936415888237616, "lm_q1q2_score": 0.19647809611685554}} {"text": "#!/usr/bin/python\n# -*- coding: utf-8 -*-\n'''\n2/24/2021\n\nThis script takes outputs from a regional climate model (RCM) - e.g. MERRA, \nMAR - for a particular site and puts that data into a pandas dataframe. \n\nThe output can be fed to RCMpkl_to_spin.py to generate a time series to force the CFM\n\nYOU MAY HAVE TO EDIT THIS SCRIPT A LOT TO MAKE IT WORK WITH YOUR FILE STRUCTURE \nAND WHAT CLIMATE FILES YOU HAVE.\n\nAnd, for now there are little things you need to search out and change manually,\nlike the reference climate interval. Sorry!\n\n@author: maxstev\n'''\n\nimport netCDF4 as nc\nimport numpy as np\nimport scipy.io\nimport csv\nimport math\nimport sys\nimport decimal\nimport os\nimport sys\nimport matplotlib.pyplot as plt\nfrom dateutil import rrule\nfrom datetime import datetime, timedelta, date\nimport pandas as pd\nimport fnmatch\nfrom scipy.spatial import cKDTree\nfrom sklearn import datasets, linear_model\nfrom sklearn.metrics import mean_squared_error, r2_score\nfrom sklearn.svm import SVR\nimport time\nimport xarray as xr\nimport glob\nimport hl_analytic as hla\n\n\ndef find_indices(points,lon,lat,tree=None):\n '''\n find the grid point nearest a given coordinate.\n '''\n if tree is None:\n # lon,lat = lon.T,lat.T\n lonlat = np.column_stack((lon.ravel(),lat.ravel()))\n tree = cKDTree(lonlat)\n dist,idx = tree.query(points,k=[1])\n ind = np.column_stack(np.unravel_index(idx,lon.shape))\n print(ind)\n for i,j in ind:\n ii=i\n jj=j\n\n return ii,jj #, [(i,j) for i,j in ind]\n\n\ndef read_netcdfs_merra(files, dim, ii, jj, vv, transform_func=None):\n '''\n Read merra files and concatenate into a pandas dataframe\n '''\n def process_one_path(path):\n with xr.open_dataset(path) as ds:\n # transform_func should do some sort of selection or\n # aggregation\n # if transform_func is not None:\n # ds = transform_func(ds)\n # load all data from the transformed dataset, to ensure we can\n # use it after closing each original file\n ds = ds[vv].isel(lat=ii,lon=jj)\n ds.load()\n return ds\n datasets = [process_one_path(p) for p in files]\n combined = xr.concat(datasets, dim)\n df1 = combined.to_dataframe()\n return (df1.drop(labels=['lon','lat'],axis=1)).sort_index()\n\ndef read_netcdfs_mar(files, dim, ii, jj, vv):\n '''\n Read mar files and concatenate into a pandas dataframe\n '''\n def process_one_path(path):\n with xr.open_dataset(path) as ds:\n dsd = {}\n for v in vv:\n # print(v)\n if len(ds[v].dims)==4:\n dsd[v] = ds[v][:,0,ii,jj].to_dataframe()\n else:\n dsd[v] = ds[v][:,ii,jj].to_dataframe()\n df_list = [v for k,v in dsd.items()]\n df1 = pd.concat(df_list, axis=1)\n return df1[df1.columns.intersection(vv)]\n datasets = [process_one_path(p) for p in files]\n return (pd.concat(datasets)).sort_index()\n\ndef effectiveT(T):\n '''\n The Arrhenius mean temperature.\n '''\n Q = -1 * 60.0e3\n R = 8.314\n k = np.exp(Q/(R*T))\n km = np.mean(k)\n return Q/(R*np.log(km))\n\ndef getClimate(lat_int,lon_int,writer=True,datatype='MERRA',timeres='1D',melt=False,runtype='local',dsource = None):\n '''\n Load data from MERRA or MAR or whatever.\n Put it into a pandas dataframe, called df_CLIM. index must be datetimeindex for \n resampling.\n df_CLIM can have any number of columns: BDOT, TSKIN, SMELT, RAIN, \n SUBLIMATION (use capital letters. We use SMELT because melt is a pandas function)\n Hopefully this makes it easy to adapt for the different climate products.\n write df_CLIM into a pickle for future use.\n\n Reference for Summit, Greenland (my favorite test site):\n lat = 72.57972\n lon = -38.50454\n\n DYE-2 (my favorite wet test site):\n lat = 66.5\n lon = -46.2\n\n UNITS FOR MASS FLUXES IN THE DATAFRAMES ARE kg/m^2 PER TIME STEP SIZE IN\n THE DATA FRAME. e.g. if you have hourly data in the dataframe, the units\n for accumulation are kg/m^2/hour - the mass of precip that fell during that \n time interval.\n\n Parameters\n ----------\n lat_int: float\n the latitude of the site you want to build a climate history for\n lon_int: float\n the longitude of the site you want to build a climate history for\n writer: boolean\n Whether or not you want to write the pandas dataframe to a pickle\n datatype: string\n The type of RCM data you are using 'MERRA' or 'MAR' for now.\n melt: boolean\n Whether or not to put melt into the pandas dataframe\n Tinterp: 'mean', 'effective', or 'weighted'\n how to resample the temperature; mean is regular mean, 'effective' is \n Arrhenius mean; 'weighted' is accumulation-weighted mean\n runtype: 'local' or 'remote'\n Allows you easily switch between directory structures if you are testing\n code locally and running on a remote server\n dsource: 'ERA10k', 'ERA6k', or 'NCEP20k'\n MAR has several flavors; choose which one.\n\n Returns\n -------\n df_CLIM: pandas dataframe\n Dataframe containing the time series of each pertinent variable for \n the site, pulled from the RCM data. Index is a datetimeindex.\n\n\n '''\n\n if not writer:\n print('Files will not be written!')\n SPY = 365.25*24*3600\n\n todaystring = date.today().strftime(\"%Y%m%d\")\n # write_out_dir = 'inputdata{}/'.format(todaystring) + datatype + 'input'\n write_out_dir = 'pickle'\n if writer:\n try: \n os.makedirs(write_out_dir)\n except:\n pass\n\n if datatype == 'MERRA':\n '''\n smb has dimensions of (time,lat,lon)\n smb has units of kg m^-2 s^-1 per day (because I sum the hourly values to get a value for each day, but do not divde by 24 after that) (pretty sure, at least!)\n temperature has dimensions of (time,lat,lon)\n temperature has units K\n\n '''\n\n ### Set directory to find climate files.\n if lat_int < 0: # Antarctica\n if runtype=='local':\n # ddir = 'PATH/TO/LOCAL/DATA/MERRA/Antarctica/Hourly'\n ddir = '/Volumes/Samsung_T1/MERRA/Antarctica/daily_melt'\n elif runtype=='remote':\n ddir = 'PATH/TO/REMOTE/DATA/MERRA/Antarctica/Hourly'\n elif runtype=='differentremote':\n ddir = 'PATH/TO/OTHER/REMOTE/DATA/CFM/MERRA/Antarctica/Hourly'\n \n # Adjust these as you see fit to set the Reference Climate Interval (RCI)\n spin_date_st = 1980 \n spin_date_end = 2019\n\n else: # Greenland\n if runtype=='local':\n # ddir = 'PATH/TO/LOCAL/DATA/MERRA/Greenland/Hourly'\n # ddir = '/Volumes/Samsung_T1/MERRA/Greenland/daily_melt'\n ddir = '/Users/cdsteve2/RCMdata/MERRA2/Greenland/daily_melt'\n elif runtype=='remote':\n ddir = 'PATH/TO/REMOTE/DATA/MERRA/Greenland/Hourly'\n elif runtype == 'loki':\n ddir = '/home/maxstev/CFM_main/MERRA/Greenland/daily_melt'\n\n \n # Adjust these as you see fit to set the Reference Climate Interval (RCI)\n spin_date_st = 1980\n spin_date_end = 1995\n\n # input_datetimes = [dparser.parse((re.search(r'\\d{8}',xx)).group()) for xx in ff] # this will extract the dates for each file\n # yy = np.array([float((re.search(r'\\d{8}',xx)).group()[0:4]) for xx in glob.glob(ddir+'/TS/*.nc*')])\n # yrs = np.arange(min(yy),max(yy)+1)\n\n fn_ll = glob.glob(ddir + '/*.nc*')\n nc_ll = nc.Dataset(fn_ll[0],'r')\n lat_ll = nc_ll.variables['lat'][:]\n lon_ll = nc_ll.variables['lon'][:]\n ii, lat_val = min(enumerate(lat_ll), key=lambda x: abs(x[1]-lat_int))\n jj, lon_val = min(enumerate(lon_ll), key=lambda x: abs(x[1]-lon_int))\n nc_ll.close() \n print('lat_val: ', lat_val)\n print('lon_val: ', lon_val)\n\n if runtype=='local':\n # pickle_folder = '/PUT/PICKLES/HERE/MERRA/IDSpickle/pickle/'\n pickle_folder = 'example_pickle/'\n else:\n pickle_folder = 'IDS/pickle/'\n pickle_name = pickle_folder + 'MERRA2_CLIM_df_{}_{}.pkl'.format(lat_val,lon_val)\n if not os.path.exists(pickle_folder):\n os.makedirs(pickle_folder)\n\n if os.path.isfile(pickle_name):\n print('pickle found')\n writer = False\n loadnetcdf = False\n df_CLIM = pd.read_pickle(pickle_name)\n # try:\n # df_BDOT = pd.DataFrame(df_CLIM['PRECTOT'])\n # df_TS = pd.DataFrame(df_CLIM['TS'])\n # df_CLIM.rename(columns={'PRECTOT':'BDOT','TS':'TSKIN'},inplace=True)\n # except Exception:\n # df_BDOT = pd.DataFrame(xx['BDOT'])\n # df_TS = pd.DataFrame(xx['TSKIN'])\n\n # if df_CLIM.BDOT.resample('1A').sum().mean()<1:\n # df_CLIM.BDOT = df_CLIM.BDOT *3600 #get rid of seconds dimension - MERRA is hourly, so this gives precip per hour.\n\n else:\n vv=['TS','EVAP','SMELT','PRECTOT','PRECSNO']\n # flist_TS = glob.glob(ddir+'/TS/*.nc*')\n\n # df_TS = read_netcdfs_merra(flist_TS, dim='time',ii=ii,jj=jj,vv='TS')\n # df_TS.rename(columns={'TS':'TSKIN'},inplace=True)\n\n # flist_SMB = glob.glob(ddir+'/SMB/*.nc*')\n # df_BDOT = read_netcdfs_merra(flist_SMB, dim='time',ii=ii,jj=jj,vv='PRECTOT') # [kg m^-2 s^-1]\n # df_BDOT = (df_BDOT.rename(columns={'PRECTOT':'BDOT'}))*3600 # [kg m^-2 hour^-1] (this is amount of precip per MERRA time interval)\n\n df_merra = read_netcdfs_merra(fn_ll, dim='time',ii=ii,jj=jj,vv=vv)\n\n df_CLIM = df_merra\n # ACCVAR = 'PRECTOT'\n # TVAR = 'TS'\n \n # df_MELT = None\n # df_RAIN = None\n ####################\n #### end MERRA #####\n\n elif datatype == 'MAR':\n spin_date_st = 1980\n spin_date_end = 1995\n print('Using MAR')\n if lat_int < 0:\n print('no Antarctic MAR data')\n sys.exit() \n else:\n if runtype=='local':\n ddir = '/Volumes/Samsung_T1/MAR311/Greenland/Daily'\n\n if not dsource:\n dsource = 'ERA10k'\n print('using MAR ', dsource)\n\n if dsource == 'ERA10k':\n d2 = '/ERA_1958-2019-10km/'\n vv = ['ME','SF','ST2','RF','SU','TT']\n elif dsource == 'ERA6k':\n d2 = '/ERA_1979-2020-6km/'\n vv = ['ME','SF','ST2','RF','TT']\n elif dsource == 'NCEP20k':\n d2 = '/NCEP1_1948-2020_20km/'\n vv = ['ME','SF','ST2','RF','SU','TT']\n\n pickle_folder = ddir + '/pickles' + d2\n print(pickle_folder)\n if not os.path.exists(pickle_folder):\n os.makedirs(pickle_folder)\n # searchdir = ddir + d2 + '/*.nc'\n flist = glob.glob(ddir + d2 + '*.nc')\n rgr = nc.Dataset(flist[0],'r')\n lat = rgr['LAT'][:,:]\n lon = rgr['LON'][:,:]\n ii,jj = find_indices((lon_int,lat_int),lon,lat)\n lat_val = lat[ii,jj]\n lon_val = lon[ii,jj]\n print('lat_val: ', lat_val)\n print('lon_val: ', lon_val)\n rgr.close()\n\n PN = pickle_folder + 'MAR_{}_CLIM_df_{}_{}.pkl'.format(dsource,lat_val,lon_val)\n if os.path.isfile(PN):\n df_CLIM = pd.read_pickle(PN)\n print('Pickle found!')\n df_BDOT = pd.DataFrame(df_CLIM.BDOT)\n df_TS = pd.DataFrame(df_CLIM.TSKIN)\n \n # vv = ['ST2','SMB']\n else:\n df_CLIM = (read_netcdfs_mar(flist,'TIME',ii=ii,jj=jj,vv=vv))[str(spin_date_st):]\n\n if 'SMB' in df_CLIM.columns:\n df_BDOT = pd.DataFrame(df_CLIM['SMB']/1000*917).rename(columns = ['BDOT']) #put into units kg/m^2/day (i.e. per time resolution in the files))\n df_MELT = None\n df_RAIN = None\n else:\n if 'SU' in df_CLIM.columns:\n df_BDOT = pd.DataFrame(((df_CLIM['SF']-df_CLIM['SU'])/1000*917),columns=['BDOT']) #put into units kg/m^2/day (i.e. per time resolution in the files))\n df_CLIM['BDOT'] = df_BDOT.BDOT.values\n df_CLIM.drop(['SF','SU'],axis=1,inplace=True)\n else:\n df_BDOT = pd.DataFrame((df_CLIM['SF'])/1000*917).rename(columns={'SF':'BDOT'}) #put into units kg/m^2/day (i.e. per time resolution in the files))\n df_CLIM['BDOT'] = df_BDOT.BDOT.values\n df_CLIM.drop(['SF'],axis=1,inplace=True)\n df_CLIM['ME'] = df_CLIM['ME']/1000*917 #put into units kg/m^2/day (i.e. per time resolution in the files))\n df_CLIM['RF'] = df_CLIM['RF']/1000*917 #put into units kg/m^2/day (i.e. per time resolution in the files))\n # df_MELT = pd.DataFrame(df_CLIM['ME']/1000*917/3600).rename(columns={'ME':'MELT'}) #put into equivalent units to the merra data (kg/m^2/s)\n # df_RAIN = pd.DataFrame(df_CLIM['RF']/1000*917/3600).rename(columns={'RF':'RAIN'}) #put into equivalent units to the merra data (kg/m^2/s)\n df_TS = pd.DataFrame(df_CLIM[['ST2','TT']]).rename(columns = {'ST2':'TSKIN','TT':'T2M'}) + 273.15\n\n drn = {'ME':'SMELT','SU':'SUBLIMATION','SF':'BDOT','RF':'RAIN','ST2':'TSKIN','SMB':'BDOT','TT':'T2M'}\n df_CLIM.rename(mapper=drn,axis=1,inplace=True)\n df_CLIM.TSKIN = df_CLIM.TSKIN + 273.15\n df_CLIM.T2M = df_CLIM.T2M + 273.15\n ###############\n ### end MAR ###\n ###############\n\n elif datatype == 'RACMO':\n\n ### Set directory to find climate files.\n if lat_int < 0: # Antarctica\n if runtype=='local':\n ddir = '/Volumes/Samsung_T1/RACMO/Antarctica'\n elif runtype=='remote':\n ddir = 'PATH/TO/REMOTE/DATA/RACMO/Antarctica/Hourly'\n elif runtype=='differentremote':\n ddir = 'PATH/TO/OTHER/REMOTE/DATA/RACMO/Antarctica/Hourly'\n \n # Adjust these as you see fit to set the Reference Climate Interval (RCI)\n spin_date_st = 1980 \n spin_date_end = 2019\n\n else: # Greenland\n if runtype=='local':\n # ddir = 'PATH/TO/LOCAL/DATA/MERRA/Greenland/Hourly'\n ddir = '/Volumes/Samsung_T1/RACMO/Greenland'\n elif runtype=='remote':\n ddir = 'PATH/TO/REMOTE/DATA/RACMO/Greenland/Hourly'\n elif runtype == 'differentremote':\n ddir = 'PATH/TO/OTHER/REMOTE/DATA/RACMO/Greenland/Hourly'\n\n spin_date_st = 1980\n spin_date_end = 1995\n\n flist = glob.glob(ddir + '/*1958-2016*.nc*')[0]\n rgr = nc.Dataset(flist[0],'r')\n lat = rgr['LAT'][:,:]\n lon = rgr['LON'][:,:]\n ii,jj = find_indices((lon_int,lat_int),lon,lat)\n lat_val = lat[ii,jj]\n lon_val = lon[ii,jj]\n print('lat_val: ', lat_val)\n print('lon_val: ', lon_val)\n rgr.close()\n\n\n\n\n if writer:\n if datatype =='MERRA':\n df_CLIM.to_pickle(pickle_folder + 'MERRA2_CLIM_df_{}_{}.pkl'.format(lat_val,lon_val))\n elif datatype == 'MAR':\n df_CLIM.to_pickle(pickle_folder + 'MAR_{}_CLIM_df_{}_{}.pkl'.format(dsource,lat_val,lon_val))\n\n return df_CLIM\n # return CD, stepsperyear, depth_S1, depth_S2, desired_depth\n\n\nif __name__ == '__main__':\n tic = time.time()\n\n LLpair = sys.argv[1]\n nn = np.fromstring(LLpair,dtype =float, sep=' ')\n lat_int = nn[0]\n lon_int = nn[1]\n writer=True\n datatype='MERRA'\n runtype = 'local'\n\n df_CLIM = getClimate(lat_int,lon_int,writer = True, runtype = runtype)\n print(time.time()-tic)\n\n\n\n\n\n", "meta": {"hexsha": "e0783995f34d1a18371acc0a213f57497d162465", "size": 15923, "ext": "py", "lang": "Python", "max_stars_repo_path": "CFM_main/siteClimate_from_RCM.py", "max_stars_repo_name": "UWGlaciology/CommunityFirnModel", "max_stars_repo_head_hexsha": "820f8b3cfd8355b0c3085058a51f7488cac17fbe", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 21, "max_stars_repo_stars_event_min_datetime": "2019-03-28T13:56:51.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-28T12:39:10.000Z", "max_issues_repo_path": "CFM_main/siteClimate_from_RCM.py", "max_issues_repo_name": "UWGlaciology/CommunityFirnModel", "max_issues_repo_head_hexsha": "820f8b3cfd8355b0c3085058a51f7488cac17fbe", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-06-10T06:53:49.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-12T22:07:02.000Z", "max_forks_repo_path": "CFM_main/siteClimate_from_RCM.py", "max_forks_repo_name": "UWGlaciology/CommunityFirnModel", "max_forks_repo_head_hexsha": "820f8b3cfd8355b0c3085058a51f7488cac17fbe", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 12, "max_forks_repo_forks_event_min_datetime": "2017-10-09T08:16:25.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-11T03:51:40.000Z", "avg_line_length": 37.554245283, "max_line_length": 169, "alphanum_fraction": 0.5794762294, "include": true, "reason": "import numpy,import scipy,from scipy", "num_tokens": 4406, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5467381519846138, "lm_q2_score": 0.3593641588823761, "lm_q1q2_score": 0.19647809611685546}} {"text": "# -*- coding: utf-8 -*-\n\"\"\"\nThis script runs MCSED on objects and is organized in the same BLOCK method\nthat variable_house.py is. A user should have read through variable_house.py\nbefore interacting with main.py. Heres an overview:\n\nBlock 1 - imports, ignore\nBlock 2 - for running multiple scripts. *INTERACTABLE*\nBlock 3 - set up how walkers obtain SEDs during random walk\nBlock 4 - defination of the stellar population/PRErams, user interactible \nBlock 5 - begin the for loop to run MCSED on each object\nBlock 6 - handle fluxes and errors, including error floors\nBlock 7 - begin actual random walk. pass lnprob() additional inputs here.\nBlock 8 - save results of walk in .npz\n\"\"\"\n\nVERSION = '1.4c' #see docs/change_log.txt\n\n# = BLOCK 1 ========================================================= BLOCK 1 =\n# Be polite and print a title.\nprint \"\\n ** MCSED ** \\n\"\nprint \"written by Hunter Brooks, hzb5080@psu.edu\"\nprint \"Penn State, Dep't of Astronomy\"\nprint \"version:\", VERSION, \"\\n\"\n\n# remove all old .pyc files to make sure no funny business is going on\nprint '... Cleaning old .pyc files'\nimport os\ndirectory = os.listdir('.')\nfor filename in directory:\n if filename[-3:] == 'pyc':\n os.remove(filename)\n\n# import everything that is needed\nprint '... Doing initial imports'\nimport time\nstart_time = time.time() # store start time \nimport numpy as np\nimport emcee_functions as mcF\nimport factory\nimport math_functions as mathF\n# get home\nimport wheres_home\nhome = wheres_home.getHomeLocation()\nimport variable_house as vHouse\nimport sys\n\n\n# = BLOCK 2 ========================================================= BLOCK 2 =\nnScriptsRunning = 1 #up to 100, numbered with two digits each time\nsuperIndexes = np.loadtxt(home+'data/active/superIndexes.dat')\n\n# get name of this script, and which number it is\nthisScriptName = sys.argv[0][-9:] # filename should be NNmain.py, eg 04main.py\nthisScriptNumb = int(thisScriptName[0:2])\nprint thisScriptNumb\nprint \n\n# split superIndexes into nScriptsRunning chunks\nif (nScriptsRunning == 1):\n chunks = np.array_split(superIndexes, nScriptsRunning)[0]\nelse:\n chunks = np.array_split(superIndexes, nScriptsRunning)\nprint chunks \n\n# = BLOCK 3 ========================================================= BLOCK 3 =\nprint '... Opening necesary MCSED data'\nif vHouse.walker_SED_type == 'Interp':\n pSpaceGridSize = vHouse.pSpaceGridSize\n # being loading interpolation data... make a time stamp\n load_data_time = time.time()\n npzopendata = np.load(home+'data/pSpaces/size'+str(pSpaceGridSize)+'_sed.npz')\n sedGrid = npzopendata[\"sedGrid\"]\n npzopendata.close()\n npzopendata = np.load(home+'data/pSpaces/size'+str(pSpaceGridSize)+'_other.npz')\n #valsGrid=npzopendata['valsGrid'] #BROKEN, see create_pSpace.py\n lambda_e=npzopendata['waves']\n stellarMassGrid=npzopendata['stellarMassGrid']\n npzopendata.close()\n import scipy.interpolate as spterp \n stellarmass_interp_f = spterp.RegularGridInterpolator(vHouse.paramRanges, \n stellarMassGrid, \n method='linear') \n\n walker_SED_notes = 'pSpace grid size: '+str(pSpaceGridSize)\n print '... Took ', str(time.time() - load_data_time)\nif vHouse.walker_SED_type == 'Direct':\n sp = vHouse.defSP()\n lambda_e = sp.wavelengths\n walker_SED_notes = 'Currently, direct does not work well.. be careful'\n\n\n# = BLOCK 4 ========================================================= BLOCK 4 =\nprint '... Opening necesary observational data'\n# find nFilters and load input data from mcsed/data/active\ncol_names = np.loadtxt(home+'data/active/filter_names.dat', dtype='str')\nfilter_lambdas = np.loadtxt(home+'data/active/filter_lambdas.dat')\nnFilters = len(col_names)\n# load input data, this is the data for the objects YOU want to match\nsuperFluxes = np.loadtxt(home+'data/active/superFluxes.dat')\nsuperErrors = np.loadtxt(home+'data/active/superErrors.dat')\nsuperInfo = np.loadtxt(home+'data/active/superInfo.dat')\nsuperRedshift = np.loadtxt(home+'data/active/superRedshift.dat')\n# handle an irregularity that arises when there is only 1 input\nif len(np.shape(superFluxes)) == 1: #there is only 1 row\n nSuperCols = np.shape(superFluxes)[0]\n # we need to reshape superdata because it looses this property when super\n # data contains only a single row.\n superFluxes = np.reshape(superFluxes, [1,nSuperCols])\n superErrors = np.reshape(superErrors, [1,nSuperCols])\n superInfo = np.reshape(superInfo, [1,np.shape(superInfo)[1]])\n \nnObjects, nSuperCols = np.shape(superFluxes)\n# make sure nSuperCols == nFilters\nassert nFilters == nSuperCols, \"All observations must have nFilters datum, even if some =0\"\n# make sure no negative errors of average fluxes\nassert len(np.where(superErrors < 0 )[0]) == 0, \"There was a negative average flux.\"\n\n\n# = BLOCK 5 ========================================================= BLOCK 5 =\n# being for loop to run MCSED on each object \nprint '... Starting runs, superIndexes: ', chunks[thisScriptNumb]\n\nfor run_i in chunks:\n# for run_i in chunks[thisScriptNumb]: original \n # this keeps things simple, since run_i is just an index\n run_i = int(run_i)\n \n # check to see if this object is in /OUTPUTS\n if os.path.isfile(home+'OUTPUTS/output'+str(run_i)+'.npz') == True:\n print\n print '... '+str(run_i)+' has already been run.'\n continue\n \n # log starting time for this obj\n run_start_time = time.time()\n dataAvgFlux = np.zeros([nFilters])\n dataAvgFluxErr = np.zeros([nFilters])\n \n # = BLOCK 6 ===================================================== BLOCK 6 =\n z = superRedshift[run_i] #redshift for this object\n assert z >= 0.0, \"Just a check to make sure Redshift is positive...\"\n dataAvgFlux = np.zeros([nFilters])\n dataAvgFluxErr = np.zeros([nFilters])\n \n # feed all the data into the active variable (dataAvgFlux/Err)...\n for filt_i in range(0, nFilters):\n # pull data from superFluxes/Errors into working data\n dataAvgFlux[filt_i] = superFluxes[run_i, filt_i ]\n dataAvgFluxErr[filt_i] = superErrors[run_i, filt_i ]\n \n # ...then run the data/errors through filter machine\n dataAvgFlux, dataAvgFluxErr = mathF.filterMachine( dataAvgFlux, \n dataAvgFluxErr,\n z, \n filter_lambdas,\n run_i)\n \n # make sure that dataAvgFlux is not entirely zeros!\n nNullObs = len(np.where(dataAvgFlux==0)[0])\n if nNullObs == len(dataAvgFlux):\n print\n print '... '+str(run_i)+\" has only null observations (entire dataAvgFlux = 0)\"\n continue\n \n # = BLOCK 7 ===================================================== BLOCK 7 =\n print\n print '... Customizing pSpace for super row index: ', run_i\n \n # this is used to move data to observed frame\n nu_obs = mathF.get_nu_obs(lambda_e, z)\n # create an R_nu array, dont need to do this each time but its fast and\n # for confusion's sake we just do it each time...\n R_nu, nFilters = factory.R_nu(home,\n nu_obs)\n # create D_nu array. D_nu is the space between nu's that corrispond to \n # sp.wavelengths\n D_nu = factory.D_nu(nFilters,\n nu_obs)\n # create NU_obs array\n NU_obs = factory.NU_obs(nFilters,\n nu_obs)\n if vHouse.walker_SED_type == 'Interp': \n # create flux_interp_f from luminosity SED grid\n fluxes, nu_obs = mathF.getFlux(sedGrid, lambda_e, z)\n # find the A value for each flux sed\n A_grid, A_compatible = factory.A_grid(fluxes, \n nFilters, NU_obs, D_nu, R_nu,\n dataAvgFlux, dataAvgFluxErr)\n # scale fluxes by each SEDs A value\n fluxes = fluxes*A_compatible\n # create flux interp function\n flux_interp_f = spterp.RegularGridInterpolator(vHouse.paramRanges, \n fluxes, \n method='linear') \n # create A interp function\n A_interp_f = spterp.RegularGridInterpolator(vHouse.paramRanges,\n A_grid,\n method='linear')\n if vHouse.walker_SED_type == 'Direct':\n flux_interp_f = sp\n A_interp_f = None\n stellarmass_interp_f = None\n \n print '... Conducting random walk'\n # BEGIN emcee RUN\n MCMCout = mcF.conductMCMC( flux_interp_f,\n A_interp_f,\n stellarmass_interp_f,\n lambda_e, \n \n nFilters,\n z,\n NU_obs,\n D_nu, \n R_nu,\n \n dataAvgFlux,\n dataAvgFluxErr) \n \n print '... Took ', str(time.time() - run_start_time)\n \n # = BLOCK 8 ===================================================== BLOCK 8 =\n # save data\n print '... Saving results of row index: ', run_i\n save_time = time.time()\n \n np.savez_compressed(home+'OUTPUTS/output'+str(run_i)+'.npz', \n \n run_date=(time.strftime(\"%D :: %H:%M:%S\")),\n time_taken = time.time() - run_start_time,\n \n dataAvgFlux = dataAvgFlux,\n dataAvgFluxErr = dataAvgFluxErr,\n z=z,\n\n data_nu_obs = nu_obs,\n D_nu = D_nu[0,:-1],\n R_nu = R_nu,\n \n nDim = vHouse.nDim,\n nDram = vHouse.nDram,\n nWalkers = vHouse.nWalkers,\n nSteps = vHouse.nSteps,\n nBurnInSteps = vHouse.nBurnInSteps,\n \n paramNames = vHouse.nameL,\n dramNames = vHouse.dRamNames,\n paramRanges = vHouse.paramRanges,\n \n walker_SED_type = vHouse.walker_SED_type,\n walker_SED_notes = walker_SED_notes,\n \n sampler_type = vHouse.sampler_type,\n chain = MCMCout[0],\n lnprobability = MCMCout[1],\n auto_corr = MCMCout[2],\n acc_frac = MCMCout[3],\n flatchain = MCMCout[4],\n flatlnprobability = MCMCout[5],\n VERSION = VERSION)\n \n print '... Took ', str(time.time() - save_time)\n", "meta": {"hexsha": "7b66a2722c10a5bf03104cf41e7bbf61eb1ccf66", "size": 11425, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/01main.py", "max_stars_repo_name": "astronomeralex/mcsed", "max_stars_repo_head_hexsha": "b54184bd0e954420fd2680d789eab1493c2bda16", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/01main.py", "max_issues_repo_name": "astronomeralex/mcsed", "max_issues_repo_head_hexsha": "b54184bd0e954420fd2680d789eab1493c2bda16", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/01main.py", "max_forks_repo_name": "astronomeralex/mcsed", "max_forks_repo_head_hexsha": "b54184bd0e954420fd2680d789eab1493c2bda16", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.2765151515, "max_line_length": 107, "alphanum_fraction": 0.5473085339, "include": true, "reason": "import numpy,import scipy", "num_tokens": 2599, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5467381667555714, "lm_q2_score": 0.35936414516010196, "lm_q1q2_score": 0.1964780939225172}} {"text": "#!/usr/bin/python\n'''\nProgram:\n This is a program for finding the minimum magnitude of source found in the image. \nUsage: \n plot_d_mag.py [image_list]\nEditor:\n Jacob975\n20181219\n#################################\nupdate log\n\n20181219 version alpha 1:\n 1. The code works.\n'''\nfrom astropy.io import fits as pyfits\nfrom astropy import wcs\nfrom astropy.coordinates import SkyCoord\nfrom astropy import units as u\nimport numpy as np\nimport time\nfrom sys import argv\nimport TAT_env\nfrom cataio_lib import get_catalog, get_distance, get_app_mag\nfrom reduction_lib import get_rid_of_exotic\nfrom matplotlib import pyplot as plt\nimport os\nfrom photometry import take_data_within_duration\nimport collections\n\ndef show_cata_mag(mag, ra, dec, VERBOSE = 1):\n # Load the index of columes\n reduce_data = np.transpose(np.array([mag, ra, dec], dtype = float))\n reduce_data = reduce_data[mag.argsort()]\n reduce_data = reduce_data[~np.isnan(reduce_data[:,0])]\n # Pick 50 brightest stars from the data\n reduce_data = reduce_data[:20]\n world = reduce_data[:,1:]\n #--------------------------------------------------\n # Find the catalog magnitude.\n # Query data from vizier\n mag_delta_list = []\n filter_ = 'V'\n for i in xrange(len(reduce_data)):\n inst_mag = reduce_data[i,0] \n RA = float(world[i, 0])\n DEC = float(world[i, 1])\n failure, match_star = get_catalog(RA, DEC, TAT_env.URAT_1, TAT_env.index_URAT_1)\n if failure:\n continue\n failure, app_mag = get_app_mag(match_star, filter_)\n if failure:\n continue\n if np.isnan(inst_mag):\n continue\n mag_delta = app_mag - inst_mag\n if VERBOSE == 1: print \"INST_MAG = {0}, CATA_MAG = {1}, delta = {2}\".format(inst_mag, app_mag, mag_delta)\n mag_delta_list.append(mag_delta)\n # Find the average of delta_mag\n # Check if the number of source is enough or not.\n if len(mag_delta_list) == 0:\n print \"No enough source found in catalogue for comparison\"\n return 1\n mag_delta_list = get_rid_of_exotic(mag_delta_list)\n if len(mag_delta_list) < 3:\n print \"No enough source found in catalogue for comparison\"\n return 1\n # remove np.nan\n mag_delta_array = np.array(mag_delta_list)\n mag_delta_array = mag_delta_array[~np.isnan(mag_delta_array)]\n # Find the median of the delta of the magnitude, and apply the result on all sources.\n median_mag_delta = np.median(mag_delta_array)\n app_mag = mag + median_mag_delta\n return 0, app_mag\n\ndef pick_median(app_mag, err_app_mag):\n cata_mag = np.linspace(9, 20, 45)\n cata_mag = (cata_mag[1:] + cata_mag[:-1]) / 2.0\n lim_err_mag = np.zeros(len(cata_mag))\n for i, mag in enumerate(cata_mag):\n index = np.where( (app_mag >= mag - 0.125 ) & \n (app_mag < mag + 0.125))\n selected_err_app_mag = err_app_mag[index]\n lim_err_mag[i] = np.median(selected_err_app_mag)\n index_min_err_mag = np.nanargmin(lim_err_mag)\n lim_err_mag[:index_min_err_mag] = lim_err_mag[index_min_err_mag]\n nans, x= nan_helper(lim_err_mag)\n lim_err_mag[nans]= np.interp(x(nans), x(~nans), lim_err_mag[~nans])\n return cata_mag, lim_err_mag\n\ndef nan_helper(y):\n \"\"\"Helper to handle indices and logical indices of NaNs.\n\n Input:\n - y, 1d numpy array with possible NaNs\n Output:\n - nans, logical indices of NaNs\n - index, a function, with signature indices= index(logical_indices),\n to convert logical indices of NaNs to 'equivalent' indices\n Example:\n >>> # linear interpolation of NaNs\n >>> nans, x= nan_helper(y)\n >>> y[nans]= np.interp(x(nans), x(~nans), y[~nans])\n \"\"\"\n return np.isnan(y), lambda z: z.nonzero()[0]\n\ndef observable_kepler(cata_mag, lim_err_mag, kepler_mag, kepler_depth):\n num_observable_sources = np.zeros(len(cata_mag))\n for i, mag in enumerate(cata_mag):\n index = np.where( (kepler_mag >= mag - 0.125 ) & \n (kepler_mag < mag + 0.125) & \n (kepler_depth > lim_err_mag[i]))\n num_observable_sources[i] = len(index[0])\n return cata_mag, num_observable_sources\n#--------------------------------------------\n# main code\nif __name__ == \"__main__\":\n # Measure time\n start_time = time.time()\n #----------------------------------------\n # Initialize\n if len(argv) != 4:\n print \"Error!\\n The number of arguments is wrong.\"\n print \"Usage: plot_d_mag.py [start time] [end time]\"\n exit(1)\n start_date = argv[1]\n end_date = argv[2]\n transit_table_name = argv[3]\n #----------------------------------------\n # Processing\n print ('---plot d mag ---')\n # Take the data in this duration\n data = take_data_within_duration(start_date, end_date)\n # Load the index\n index_BJD = TAT_env.obs_data_titles.index(\"BJD\") \n index_INST_MAG = TAT_env.obs_data_titles.index('INST_MAG')\n index_E_INST_MAG = TAT_env.obs_data_titles.index('E_INST_MAG')\n index_EP_MAG = TAT_env.obs_data_titles.index('EP_MAG')\n index_E_EP_MAG = TAT_env.obs_data_titles.index('E_EP_MAG')\n index_RA = TAT_env.obs_data_titles.index('RA')\n index_DEC = TAT_env.obs_data_titles.index('`DEC`')\n # Find the first image\n all_bjd = data[:,index_BJD]\n bjd_s = [item for item, count in collections.Counter(all_bjd).items() if count > 1]\n first_bjd = np.amin(bjd_s)\n # Take and analyize the data of the first image.\n first_frame_data = data[data[:,index_BJD] == first_bjd]\n ep_mag = np.array(first_frame_data[:, index_EP_MAG], dtype = float)\n e_ep_mag = np.array(first_frame_data[:, index_E_EP_MAG], dtype = float)\n index_no_nan_in_ep_mag = np.where(~np.isnan(ep_mag) & ~np.isnan(e_ep_mag))\n ra = first_frame_data[:, index_RA]\n dec = first_frame_data[:, index_DEC]\n ep_mag = ep_mag[index_no_nan_in_ep_mag]\n e_ep_mag = e_ep_mag[index_no_nan_in_ep_mag]\n ra = ra[index_no_nan_in_ep_mag]\n dec = dec[index_no_nan_in_ep_mag]\n failure, app_mag = show_cata_mag(ep_mag, ra, dec)\n # Load transit table\n index_Vmag = 11\n index_depth = 10\n index_depth_measure = 9\n index_DEC = 5\n transit_table = np.loadtxt(transit_table_name, dtype = str, delimiter = '\\t')\n transit_table = transit_table[1:]\n # Ignore all no-observed data\n transit_table = transit_table[transit_table[:,index_Vmag] != '']\n # Take data\n Vmag = np.array(transit_table[:,index_Vmag], dtype = float)\n depth = np.array(transit_table[:,index_depth], dtype = float)\n depth_measure = np.array(transit_table[:,index_depth_measure], dtype = str)\n DEC = np.array(transit_table[:, index_DEC], dtype = float)\n above_south30 = DEC > -30.\n \n # Take source above -30 dec\n Vmag = Vmag[above_south30]\n depth = depth[above_south30]\n depth_measure = depth_measure[above_south30]\n \n depth_measure[depth_measure == ''] = '0.0'\n depth_measure = np.array(depth_measure, dtype = float)\n where_no_depth = depth == 0.0\n depth[where_no_depth] = depth_measure[where_no_depth]\n depth = depth / 100.\n # Calculate the histogram\n numbers, bin_edges = np.histogram(Vmag, bins = np.linspace(9, 20, 45))\n bins = (bin_edges[1:] + bin_edges[:-1]) / 2.0\n cata_mag, lim_err_mag = pick_median(app_mag, e_ep_mag)\n _, num_obs_source = observable_kepler(cata_mag, lim_err_mag, Vmag, depth)\n print np.sum(numbers)\n print np.sum(num_obs_source)\n # plot the histogram of magnitude\n fig, axs = plt.subplots(1, 1, figsize = (8,6))\n axs.set_title('The observable transits')\n axs.bar(bins, numbers, width = 0.25, color = 'b', label = 'Comfirm transits')\n axs.bar(cata_mag, num_obs_source, width = 0.20, color = 'r', label = 'Observable comfirm transits')\n axs.set_xlabel('V magnitude')\n axs.set_ylabel(\"# of sources\")\n axs.set_xlim(9, 20)\n axs.grid()\n axs.legend()\n plt.savefig('{0}_{1}_hist_kepler.png'.format(start_date, end_date))\n #---------------------------------------\n # Measure time\n elapsed_time = time.time() - start_time\n print \"Exiting Main Program, spending \", elapsed_time, \"seconds.\"\n", "meta": {"hexsha": "f31df1c106ef3f1add5768858936a2613d0a9fdb", "size": 8195, "ext": "py", "lang": "Python", "max_stars_repo_path": "plot_observable_TTV_3.py", "max_stars_repo_name": "jacob975/TATIRP", "max_stars_repo_head_hexsha": "2d81fa280e039aa931c6f8456632a23ef123282a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "plot_observable_TTV_3.py", "max_issues_repo_name": "jacob975/TATIRP", "max_issues_repo_head_hexsha": "2d81fa280e039aa931c6f8456632a23ef123282a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2017-08-22T03:15:22.000Z", "max_issues_repo_issues_event_max_datetime": "2017-12-19T17:55:31.000Z", "max_forks_repo_path": "plot_observable_TTV_3.py", "max_forks_repo_name": "jacob975/TATIRP", "max_forks_repo_head_hexsha": "2d81fa280e039aa931c6f8456632a23ef123282a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.7815533981, "max_line_length": 113, "alphanum_fraction": 0.6505186089, "include": true, "reason": "import numpy,from astropy", "num_tokens": 2192, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5467381519846138, "lm_q2_score": 0.35936415202123906, "lm_q1q2_score": 0.19647809236561006}} {"text": "\"\"\"\ndefines:\n - split_line_elements(bdf_model, eids, neids=2,\n eid_start=1, nid_start=1)\n\n\"\"\"\nimport numpy as np\nfrom pyNastran.bdf.bdf import read_bdf\n\n\ndef split_line_elements(bdf_model, eids, neids=2,\n eid_start=1, nid_start=1):\n \"\"\"\n Splits a set of element ids\n\n Parameters\n ----------\n eids : List[int]\n element ids to split\n neids : int; default=5\n how many elements should a single bar be split into\n min=2\n eid_start : int; default=1\n the starting element id\n nid_start : int; default=1\n the starting node id\n\n Returns\n -------\n eids_out : List[int]\n the list of elements that have been added\n eid_end : int; default=1\n the final element id\n nid_end : int; default=1\n the final node id\n\n A-----*-----B; neids=2\n A--*--*--*--B; neids=4\n\n \"\"\"\n eids_out = []\n assert neids >= 2, neids\n dx = np.linspace(0., 1., num=neids+1)\n for eid in eids:\n elem = bdf_model.elements[eid]\n n1, n2 = elem.nodes\n node1 = bdf_model.nodes[n1]\n node2 = bdf_model.nodes[n2]\n cp = node1.cp\n assert node1.cp == node2.cp\n assert node1.cd == node2.cd\n xyz1 = node1.xyz\n xyz2 = node2.xyz\n dxyz = xyz2 - xyz1\n etype = elem.type\n\n if etype in ['CBAR', 'CBEAM']:\n pa = elem.pa\n pb = 0\n\n elem.comment = ''\n comment = str(elem) + '\\n'\n for ieid in range(neids):\n dxi = dx[ieid + 1]\n new_xyz = xyz1 + dxyz * dxi\n if dxi < 1.:\n new_node = nid_start\n nid_start += 1\n bdf_model.add_grid(new_node, new_xyz, cp=cp)\n else:\n new_node = n2\n if etype in ['CBAR', 'CBEAM']:\n pb = elem.pb\n\n if etype == 'CONROD':\n nids = [n1, new_node]\n bdf_model.add_conrod(eid_start, elem.mid, nids, elem.A, j=elem.j,\n c=elem.c, nsm=elem.nsm, comment=comment)\n elif etype == 'CROD':\n nids = [n1, new_node]\n bdf_model.add_crod(eid_start, elem.pid, nids, comment=comment)\n elif etype == 'CBAR':\n ga = n1\n gb = new_node\n bdf_model.add_cbar(eid_start, elem.pid, [ga, gb], elem.x, elem.g0, offt=elem.offt,\n pa=pa, pb=pb, wa=elem.wa, wb=elem.wb, comment=comment)\n pa = 0\n elif etype == 'CBEAM':\n ga = n1\n gb = new_node\n bdf_model.add_cbeam(eid_start, elem.pid, [ga, gb], elem.x, elem.g0,\n offt=elem.offt, bit=elem.bit,\n pa=pa, pb=pb,\n wa=elem.wa, wb=elem.wb, sa=elem.sa, sb=elem.sb,\n comment=comment)\n pa = 0\n else:\n raise NotImplementedError(elem)\n n1 = new_node\n eids_out.append(eid_start)\n eid_start += 1\n comment = str(eid)\n del bdf_model.elements[eid]\n return eids_out, eid_start, nid_start\n\n\ndef split_elements(bdf_filename):\n \"\"\"unimplemented method for splitting elements\"\"\"\n model = read_bdf(bdf_filename, xref=True)\n for eid, elem in model.elements.items():\n if elem.type == 'CTRIA3':\n #\n # 3\n # /|\\\n # / | \\\n # / | \\\n # / 4 \\\n # / / \\ \\\n # / / \\ \\\n # 1-------------2\n #\n p1, p2, p3 = elem.get_node_positions()\n #centroid = (p1 + p2 + p3) / 3.\n\n #\n # 3\n # /|\\\n # / | \\\n # / | \\\n # / | \\\n # 1----4----2\n #\n elif elem.type == 'CQUAD4':\n #\n #\n # 4---------3\n # | \\ / |\n # | \\ / |\n # | 5 |\n # | / \\ |\n # |/ \\|\n # 1---------2\n #\n # the same thing shown in a rotated view\n # 4\n # /| \\\n # / | \\\n # / | \\\n # / | \\\n # 1---------5---------3\n # \\ | /\n # \\ | /\n # \\ | /\n # \\ | /\n # 2\n #\n # max_area, taper_ratio, area_ratio\n # 4----7----3\n # | | |\n # | | |\n # 8----9----6\n # | | |\n # | | |\n # 1----4----2\n #\n # max_interior_angle\n # 4---------3\n # / \\ /\n # / \\ /\n # / \\ /\n # / \\ /\n # 1---------2\n #\n # taper_ratio\n # 4--6--3\n # / | \\\n # / | \\\n # / | \\\n # 1------5------2\n #\n # taper_ratio\n # 4------3\n # / \\ / \\\n # / \\ / \\\n # / \\/ \\\n # 1-------5------2\n #\n # taper_ratio\n # 4------3\n # / \\ \\\n # / \\ \\\n # / \\ \\\n # 1-------5------2\n pass\n", "meta": {"hexsha": "e26d3e14824347b41d16eccb7af132efd41fa253", "size": 5678, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyNastran/bdf/mesh_utils/split_elements.py", "max_stars_repo_name": "ACea15/pyNastran", "max_stars_repo_head_hexsha": "5ffc37d784b52c882ea207f832bceb6b5eb0e6d4", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 293, "max_stars_repo_stars_event_min_datetime": "2015-03-22T20:22:01.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-14T20:28:24.000Z", "max_issues_repo_path": "pyNastran/bdf/mesh_utils/split_elements.py", "max_issues_repo_name": "ACea15/pyNastran", "max_issues_repo_head_hexsha": "5ffc37d784b52c882ea207f832bceb6b5eb0e6d4", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 512, "max_issues_repo_issues_event_min_datetime": "2015-03-14T18:39:27.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T16:15:43.000Z", "max_forks_repo_path": "pyNastran/bdf/mesh_utils/split_elements.py", "max_forks_repo_name": "ACea15/pyNastran", "max_forks_repo_head_hexsha": "5ffc37d784b52c882ea207f832bceb6b5eb0e6d4", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 136, "max_forks_repo_forks_event_min_datetime": "2015-03-19T03:26:06.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-25T22:14:54.000Z", "avg_line_length": 29.1179487179, "max_line_length": 98, "alphanum_fraction": 0.3420218387, "include": true, "reason": "import numpy", "num_tokens": 1520, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5467381519846138, "lm_q2_score": 0.35936414516010196, "lm_q1q2_score": 0.19647808861436467}} {"text": "import numbers\nfrom contextlib import contextmanager\nfrom functools import wraps, partial\nfrom typing import List, Callable\n\nimport numpy as np\nimport tensorflow as tf\nfrom tensorflow.python.client import device_lib\n\nfrom ..math.backend._backend import combined_dim\nfrom ..math.backend._dtype import DType, to_numpy_dtype, from_numpy_dtype\nfrom phi.math.backend import Backend, ComputeDevice, NUMPY\nfrom ._tf_cuda_resample import resample_cuda, use_cuda\n\n\nclass TFBackend(Backend):\n\n def __init__(self):\n Backend.__init__(self, \"TensorFlow\", default_device=None)\n\n def prefers_channels_last(self) -> bool:\n return True\n\n def list_devices(self, device_type: str or None = None) -> List[ComputeDevice]:\n tf_devices = device_lib.list_local_devices()\n devices = []\n for device in tf_devices:\n if device_type in (None, device.device_type):\n devices.append(ComputeDevice(self, device.name, device.device_type, device.memory_limit,\n processor_count=-1,\n description=str(device),\n ref=device))\n return devices\n\n def seed(self, seed: int):\n tf.random.set_seed(seed)\n\n def is_tensor(self, x, only_native=False):\n is_tf_tensor = tf.is_tensor(x) is True # tf.is_tensor() can return non-bool values which indicates not a Tensor\n if only_native:\n return is_tf_tensor\n else:\n return is_tf_tensor or NUMPY.is_tensor(x, only_native=False)\n\n def as_tensor(self, x, convert_external=True):\n if self.is_tensor(x, only_native=convert_external):\n return x\n tensor = tf.convert_to_tensor(x)\n # --- Enforce Precision ---\n if not isinstance(tensor, numbers.Number):\n if isinstance(tensor, np.ndarray):\n tensor = NUMPY.as_tensor(tensor)\n elif tensor.dtype.is_floating:\n tensor = self.to_float(tensor)\n return tensor\n\n def is_available(self, tensor) -> bool:\n if self.is_tensor(tensor, only_native=True):\n return tf.executing_eagerly()\n else:\n return True\n\n def numpy(self, tensor):\n if tf.is_tensor(tensor):\n return tensor.numpy()\n return NUMPY.numpy(tensor)\n\n def to_dlpack(self, tensor):\n from tensorflow import experimental\n return experimental.dlpack.to_dlpack(tensor)\n\n def from_dlpack(self, capsule):\n from tensorflow import experimental\n return experimental.dlpack.from_dlpack(capsule)\n\n def copy(self, tensor, only_mutable=False):\n if not only_mutable or tf.executing_eagerly():\n return tf.identity(tensor)\n else:\n return tensor\n\n def jit_compile(self, f: Callable) -> Callable:\n compiled = tf.function(f)\n return lambda *args: self.as_registered.call(compiled, *args, name=f\"run jit-compiled '{f.__name__}'\")\n\n def custom_gradient(self, f: Callable, gradient: Callable = None) -> Callable:\n @tf.custom_gradient\n def tf_function(*args, **kwargs):\n def grad(*grad_args):\n return gradient(args, y, grad_args)\n y = f(*args, **kwargs)\n return y, grad\n return tf_function\n\n def transpose(self, tensor, axes):\n return tf.transpose(tensor, perm=axes)\n\n def equal(self, x, y):\n return tf.equal(x, y)\n\n def divide_no_nan(self, x, y):\n x, y = self.auto_cast(x, y)\n return tf.math.divide_no_nan(x, y)\n\n def random_uniform(self, shape):\n return tf.random.uniform(shape, dtype=to_numpy_dtype(self.float_type))\n\n def random_normal(self, shape):\n return tf.random.normal(shape, dtype=to_numpy_dtype(self.float_type))\n\n def rank(self, value):\n return len(value.shape)\n\n def range(self, start, limit=None, delta=1, dtype: DType = DType(int, 32)):\n return tf.range(start, limit, delta, to_numpy_dtype(dtype))\n\n def tile(self, value, multiples):\n if isinstance(multiples, (tuple, list)) and self.ndims(value) < len(multiples):\n value = self.expand_dims(value, axis=0, number=len(multiples) - self.ndims(value))\n return tf.tile(value, multiples)\n\n def stack(self, values, axis=0):\n return tf.stack(values, axis=axis)\n\n def concat(self, values, axis):\n return tf.concat(values, axis)\n\n def pad(self, value, pad_width, mode='constant', constant_values=0):\n if mode == 'boundary' and np.all(np.array(pad_width) <= 1):\n mode = 'symmetric'\n if mode in ('constant', 'symmetric', 'reflect'):\n return tf.pad(value, pad_width, mode.upper(), constant_values=constant_values)\n else:\n return NotImplemented\n\n def reshape(self, value, shape):\n return tf.reshape(value, shape)\n\n def sum(self, value, axis=None, keepdims=False):\n if axis is not None:\n if not isinstance(axis, int):\n axis = list(axis)\n if isinstance(value, tf.SparseTensor):\n return tf.sparse.reduce_sum(value, axis=axis, keepdims=keepdims, output_is_sparse=False)\n if isinstance(value, (tuple, list)) and any([isinstance(x, tf.SparseTensor) for x in value]):\n result = value[0]\n for v in value[1:]:\n result = tf.sparse.add(result, v, threshold=0)\n return result\n return tf.reduce_sum(value, axis=axis, keepdims=keepdims)\n\n def prod(self, value, axis=None):\n if axis is not None:\n if not isinstance(axis, int):\n axis = list(axis)\n if value.dtype == bool:\n return tf.reduce_all(value, axis=axis)\n return tf.reduce_prod(value, axis=axis)\n\n def where(self, condition, x=None, y=None):\n c = self.cast(condition, self.dtype(x))\n return c * x + (1 - c) * y\n # return tf.where(condition, x, y) # TF1 has an inconsistent broadcasting rule for where\n\n def nonzero(self, values):\n return tf.where(tf.not_equal(values, 0))\n\n def mean(self, value, axis=None, keepdims=False):\n if axis is not None:\n if not isinstance(axis, int):\n axis = list(axis)\n return tf.reduce_mean(value, axis, keepdims=keepdims)\n\n def grid_sample(self, grid, spatial_dims: tuple, coordinates, extrapolation='constant'):\n if use_cuda(grid):\n # TODO reshape for spatial_dims\n return resample_cuda(grid, coordinates, extrapolation)\n else:\n return NotImplemented\n\n def zeros(self, shape, dtype: DType = None):\n return tf.zeros(shape, dtype=to_numpy_dtype(dtype or self.float_type))\n\n def zeros_like(self, tensor):\n return tf.zeros_like(tensor)\n\n def ones(self, shape, dtype: DType = None):\n return tf.ones(shape, dtype=to_numpy_dtype(dtype or self.float_type))\n\n def ones_like(self, tensor):\n return tf.ones_like(tensor)\n\n def meshgrid(self, *coordinates):\n result = tf.meshgrid(*coordinates, indexing='ij')\n return result\n\n def linspace(self, start, stop, number):\n return self.to_float(tf.linspace(start, stop, number))\n\n def tensordot(self, a, a_axes: tuple or list, b, b_axes: tuple or list):\n return tf.tensordot(a, b, (a_axes, b_axes))\n\n def matmul(self, A, b):\n if isinstance(A, tf.SparseTensor):\n result_T = tf.sparse.sparse_dense_matmul(A, tf.transpose(b)) # result shape contains unknown size\n result = tf.transpose(result_T)\n result.set_shape(tf.TensorShape([b.shape[0], A.shape[0]]))\n return result\n else:\n return tf.matmul(A, b)\n\n def einsum(self, equation, *tensors):\n return tf.einsum(equation, *tensors)\n\n def while_loop(self, loop: Callable, values: tuple):\n cond = lambda c, *vals: tf.reduce_any(c)\n return tf.nest.map_structure(tf.stop_gradient, tf.while_loop(cond, loop, values))\n\n def abs(self, x):\n return tf.abs(x)\n\n def sign(self, x):\n return tf.sign(x)\n\n def round(self, x):\n return tf.round(x)\n\n def ceil(self, x):\n return tf.math.ceil(x)\n\n def floor(self, x):\n return tf.floor(x)\n\n def max(self, x, axis=None, keepdims=False):\n if isinstance(x, (tuple, list)):\n x = tf.stack(x)\n if x.dtype == tf.bool:\n return tf.cast(tf.reduce_max(tf.cast(x, tf.uint8), axis=axis, keepdims=keepdims), tf.bool) # reduce_max allows no bool\n return tf.reduce_max(x, axis=axis, keepdims=keepdims)\n\n def min(self, x, axis=None, keepdims=False):\n if isinstance(x, (tuple, list)):\n x = tf.stack(x)\n if x.dtype == tf.bool:\n return tf.cast(tf.reduce_min(tf.cast(x, tf.uint8), axis=axis, keepdims=keepdims), tf.bool) # reduce_min allows no bool\n return tf.reduce_min(x, axis=axis, keepdims=keepdims)\n\n def maximum(self, a, b):\n a, b = self.auto_cast(a, b)\n return tf.maximum(a, b)\n\n def minimum(self, a, b):\n a, b = self.auto_cast(a, b)\n return tf.minimum(a, b)\n\n def clip(self, x, minimum, maximum):\n x, minimum, maximum = self.auto_cast(x, minimum, maximum)\n return tf.clip_by_value(x, minimum, maximum)\n\n def sqrt(self, x):\n return tf.sqrt(x)\n\n def exp(self, x):\n return tf.exp(x)\n\n def conv(self, value, kernel, zero_padding=True):\n value = self.to_float(value)\n kernel = self.to_float(kernel) # should use auto_cast but TensorFlow only supports DT_HALF, DT_BFLOAT16, DT_FLOAT, DT_DOUBLE, DT_INT32\n if zero_padding:\n value_padding = [[0, 0]] * 2 + [[s // 2, (s - 1) // 2] for s in kernel.shape[3:]]\n value = tf.pad(value, value_padding)\n convf = {3: partial(tf.nn.conv1d, stride=1),\n 4: partial(tf.nn.conv2d, strides=[1, 1, 1, 1]),\n 5: partial(tf.nn.conv3d, strides=[1, 1, 1, 1, 1])}[len(value.shape)]\n value = tf.transpose(value, [0, *range(2, self.ndims(value)), 1]) # could use data_format='NC...' but it's supported neither on CPU and for int tensors\n kernel = tf.transpose(kernel, [0, *range(3, self.ndims(kernel)), 2, 1])\n if kernel.shape[0] == 1:\n result = convf(value, kernel[0, ...], padding='VALID')\n else:\n result = []\n for b in range(kernel.shape[0]):\n result.append(convf(value[b:b+1, ...], kernel[b], padding='VALID'))\n result = tf.concat(result, 0)\n result = tf.transpose(result, [0, self.ndims(result) - 1, *range(1, self.ndims(result) - 1)])\n return result\n\n def expand_dims(self, a, axis=0, number=1):\n if number == 0:\n return a\n for _i in range(number):\n a = tf.expand_dims(a, axis)\n return a\n\n def shape(self, tensor):\n return tf.shape(tensor)\n\n def staticshape(self, tensor):\n if self.is_tensor(tensor, only_native=True):\n return tuple(tensor.shape.as_list())\n else:\n return np.shape(tensor)\n\n def batched_gather_nd(self, values, indices):\n values_shape = self.staticshape(values)\n if values_shape[0] == 1 and self.staticshape(indices)[0] > 1:\n result = tf.gather_nd(values[0, ...], indices, batch_dims=0)\n return result\n if values_shape[0] > 1 and self.staticshape(indices)[0] == 1:\n indices = tf.tile(indices, [values_shape[0]] + [1] * (len(values_shape) - 1))\n return tf.gather_nd(values, indices, batch_dims=1)\n\n def unstack(self, tensor, axis=0, keepdims=False):\n unstacked = tf.unstack(tensor, axis=axis)\n if keepdims:\n unstacked = [self.expand_dims(c, axis=axis) for c in unstacked]\n return unstacked\n\n def std(self, x, axis=None, keepdims=False):\n _mean, var = tf.nn.moments(x, axis, keepdims=keepdims)\n return tf.sqrt(var)\n\n def boolean_mask(self, x, mask, axis=0):\n return tf.boolean_mask(x, mask, axis=axis)\n\n def isfinite(self, x):\n return tf.math.is_finite(x)\n\n def any(self, boolean_tensor, axis=None, keepdims=False):\n return tf.reduce_any(boolean_tensor, axis=axis, keepdims=keepdims)\n\n def all(self, boolean_tensor, axis=None, keepdims=False):\n return tf.reduce_all(boolean_tensor, axis=axis, keepdims=keepdims)\n\n def scatter(self, base_grid, indices, values, mode: str):\n base_grid, values = self.auto_cast(base_grid, values)\n indices = self.as_tensor(indices)\n batch_size = combined_dim(combined_dim(indices.shape[0], values.shape[0]), base_grid.shape[0])\n scatter = tf.tensor_scatter_nd_add if mode == 'add' else tf.tensor_scatter_nd_update\n result = []\n for b in range(batch_size):\n b_grid = base_grid[b, ...]\n b_indices = indices[min(b, indices.shape[0] - 1), ...]\n b_values = values[min(b, values.shape[0] - 1), ...]\n result.append(scatter(b_grid, b_indices, b_values))\n return self.stack(result, axis=0)\n\n def fft(self, x):\n rank = len(x.shape) - 2\n assert rank >= 1\n x = self.to_complex(x)\n if rank == 1:\n return tf.stack([tf.signal.fft(c) for c in tf.unstack(x, axis=-1)], axis=-1)\n elif rank == 2:\n return tf.stack([tf.signal.fft2d(c) for c in tf.unstack(x, axis=-1)], axis=-1)\n elif rank == 3:\n return tf.stack([tf.signal.fft3d(c) for c in tf.unstack(x, axis=-1)], axis=-1)\n else:\n raise NotImplementedError('n-dimensional FFT not implemented.') # TODO perform multiple lower-dimensional FFTs\n\n def ifft(self, k):\n rank = len(k.shape) - 2\n assert rank >= 1\n if rank == 1:\n return tf.stack([tf.signal.ifft(c) for c in tf.unstack(k, axis=-1)], axis=-1)\n elif rank == 2:\n return tf.stack([tf.signal.ifft2d(c) for c in tf.unstack(k, axis=-1)], axis=-1)\n elif rank == 3:\n return tf.stack([tf.signal.ifft3d(c) for c in tf.unstack(k, axis=-1)], axis=-1)\n else:\n raise NotImplementedError('n-dimensional inverse FFT not implemented.')\n\n def imag(self, complex):\n return tf.math.imag(complex)\n\n def real(self, complex):\n return tf.math.real(complex)\n\n def cast(self, x, dtype: DType):\n if not self.is_tensor(x, only_native=True):\n x = self.as_tensor(x, convert_external=True)\n if self.dtype(x) == dtype:\n return x\n else:\n return tf.cast(x, to_numpy_dtype(dtype))\n\n def sin(self, x):\n return tf.math.sin(x)\n\n def cos(self, x):\n return tf.math.cos(x)\n\n def tan(self, x):\n return tf.math.tan(x)\n\n def log(self, x):\n return tf.math.log(x)\n\n def log2(self, x):\n return tf.math.log(x) / 0.6931471805599453094 # log(x) / log(2)\n\n def log10(self, x):\n return tf.math.log(x) / 2.3025850929940456840 # log(x) / log(10)\n\n def dtype(self, array) -> DType:\n if tf.is_tensor(array):\n dt = array.dtype.as_numpy_dtype\n return from_numpy_dtype(dt)\n else:\n return NUMPY.dtype(array)\n\n def sparse_tensor(self, indices, values, shape):\n indices = [tf.convert_to_tensor(i, tf.int64) for i in indices]\n indices = tf.cast(tf.stack(indices, axis=-1), tf.int64)\n return tf.SparseTensor(indices=indices, values=values, dense_shape=shape)\n\n def coordinates(self, tensor):\n assert isinstance(tensor, tf.SparseTensor)\n idx = tensor.indices\n idx = tuple(tf.unstack(idx, axis=-1))\n return idx, tensor.values\n\n def add(self, a, b):\n if isinstance(a, tf.SparseTensor) or isinstance(b, tf.SparseTensor):\n return tf.sparse.add(a, b, threshold=1e-5)\n else:\n return Backend.add(self, a, b)\n\n def functional_gradient(self, f, wrt: tuple or list, get_output: bool):\n @wraps(f)\n def eval_grad(*args):\n args = [self.as_tensor(arg, True) if i in wrt else arg for i, arg in enumerate(args)]\n wrt_args = [arg for i, arg in enumerate(args) if i in wrt]\n with tf.GradientTape(watch_accessed_variables=False) as tape:\n for arg in wrt_args:\n assert arg.dtype in (tf.float16, tf.float32, tf.float64, tf.complex64, tf.complex128), f\"Gradients can only be computed for float or complex tensors but got {arg.dtype} for argument with shape {arg.shape}\"\n tape.watch(arg)\n output = f(*args)\n loss, aux = (output[0], output[1:]) if isinstance(output, (tuple, list)) else (output, None)\n # if self.ndims(loss) > 0:\n # loss = tf.reduce_sum(loss) # this is not needed and will cause gradients to be None\n grads = list(self.as_registered.call(tape.gradient, loss, wrt_args, name=f\"Backpropagation\"))\n assert None not in grads, f\"Gradient could not be computed for wrt argument {grads.index(None)} (argument {wrt[grads.index(None)]}) with shape {wrt_args[grads.index(None)].shape}. TensorFlow returned gradient=None.\"\n if get_output:\n if aux is not None:\n return (loss, *aux, *grads)\n else:\n return (loss, *grads)\n else:\n return grads\n return eval_grad\n\n # def variable(self, value): # not supported, variables must record gradients outside a context\n # return tf.Variable(value, trainable=True)\n\n def gradients(self, y, xs: tuple or list, grad_y):\n if _TAPES:\n tape = _TAPES[-1]\n return tape.gradient(y, xs, grad_y)\n return tf.gradients(y, xs, grad_y)\n\n @contextmanager\n def record_gradients(self, xs: tuple or list, persistent=False):\n tape = tf.GradientTape(persistent=persistent)\n tape.__enter__()\n for x in xs:\n tape.watch(x)\n _TAPES.append(tape)\n\n try:\n yield None\n finally:\n tape.__exit__(None, None, None)\n _TAPES.pop(-1)\n\n def stop_gradient(self, value):\n return tf.stop_gradient(value)\n\n\n_TAPES = []\n", "meta": {"hexsha": "6eea13df5c47bb7838cd97aa350eabbfc14f117f", "size": 18296, "ext": "py", "lang": "Python", "max_stars_repo_path": "phi/tf/_tf_backend.py", "max_stars_repo_name": "marc-gav/PhiFlow", "max_stars_repo_head_hexsha": "b6186fd1503d040997b52d49aa18cd875267c27e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "phi/tf/_tf_backend.py", "max_issues_repo_name": "marc-gav/PhiFlow", "max_issues_repo_head_hexsha": "b6186fd1503d040997b52d49aa18cd875267c27e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "phi/tf/_tf_backend.py", "max_forks_repo_name": "marc-gav/PhiFlow", "max_forks_repo_head_hexsha": "b6186fd1503d040997b52d49aa18cd875267c27e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.1166666667, "max_line_length": 227, "alphanum_fraction": 0.6062527328, "include": true, "reason": "import numpy", "num_tokens": 4451, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5467381519846138, "lm_q2_score": 0.3593641382989649, "lm_q1q2_score": 0.19647808486311927}} {"text": "# Copyright (c) 2015, Michael Boyle\n# See LICENSE file for details: \n\nimport os\nimport inspect\nimport functools\nimport warnings\nimport socket\nimport datetime\nimport pprint\nimport copy\nimport numpy as np\nimport quaternion\nimport scipy.constants as spc\nfrom scipy.interpolate import CubicSpline\nfrom . import *\n\n@jit(\"void(c16[:,:], f8[:])\")\ndef complex_array_norm(c, s):\n for i in range(len(s)):\n s[i] = 0.0\n for j in range(c.shape[1]):\n s[i] += c[i, j].real ** 2 + c[i, j].imag ** 2\n return\n\n@jit(\"void(c16[:,:], f8[:])\")\ndef complex_array_abs(c, s):\n for i in range(len(s)):\n s[i] = 0.0\n for j in range(c.shape[1]):\n s[i] += c[i, j].real ** 2 + c[i, j].imag ** 2\n s[i] = np.sqrt(s[i])\n return\n\n\ndef waveform_alterations(func):\n \"\"\"Temporarily increment history depth safely\n\n This decorator stores the value of `self.__history_depth__`, then increments it by 1, calls the function,\n returns the history depth to its original value, and then returns the result of the function. This should be\n used on any member function that could alter the waveform on which it is called, or which could return a new\n altered version of the original.\n\n Typically, within the function itself, you will want to decrement the depth manually just before appending to the\n history -- which will presumably take place at the end of the function. You do not need to undo this,\n as the decorator will take care of that part.\n\n \"\"\"\n\n @functools.wraps(func)\n def func_wrapper(self, *args, **kwargs):\n if self.__history_depth__ == 0:\n self._append_history(\"\")\n stored_history_depth = self.__history_depth__\n self.__history_depth__ += 1\n result = func(self, *args, **kwargs)\n self.__history_depth__ = stored_history_depth\n return result\n\n return func_wrapper\n\n\ndef test_without_assertions(errs, val, msg=\"\"):\n \"\"\"Replacement for np.testing.assert_\n\n This function should be able to replace `assert_`, but rather than raising an exception, this just adds a\n description of the problem to the `errors` variable.\n\n \"\"\"\n if not val:\n try:\n smsg = msg()\n except TypeError:\n smsg = msg\n errs += [smsg]\n\n\ndef test_with_assertions(errs, val, msg=\"\"):\n np.testing.assert_(val, \"Failed assertion:\\n\\t\" + msg)\n\n\nclass _object:\n \"\"\"Useless class to allow multiple inheritance\"\"\"\n\n def __init__(self, *args, **kwargs):\n super().__init__()\n\n\nclass WaveformBase(_object):\n \"\"\"Object containing time, frame, and data, along with related information\n\n This object is just the base object from which these other classes are derived:\n * WaveformModes\n * WaveformGrid\n * WaveformInDetector\n * WaveformInDetectorFT\n For more specific information, see the documentation of those classes.\n\n Attributes\n ----------\n t : float array\n Time steps corresponding to other data\n frame : quaternion array\n Rotors taking static basis onto decomposition basis\n data : 2-d array of complex or real numbers\n The nature of this data depends on the derived type. First index is time, second index depends on type.\n history : list of strings\n As far as possible, all functions applied to the object are recorded in the `history` variable. In fact,\n the object should almost be able to be recreated using the commands in the history list. Commands taking\n large arrays, however, are shortened -- so the data will not be entirely reconstructable.\n version_hist : list of pairs of strings\n Records the git hash and description for any change in the way SpEC outputs waveform data.\n frameType : int\n Index corresponding to `scri.FrameType` appropriate for `data`.\n dataType : int\n Index corresponding to `scri.DataType` appropriate for `data`.\n r_is_scaled_out : bool\n True if the `data` have been multiplied by the appropriate power of radius so that the asymptotic value can\n be finite and nonzero.\n m_is_scaled_out : bool\n True if the `data` have been scaled by the appropriate value of the total mass so that they are dimensionless.\n num : int (read only)\n Automatically assigned number of this object. The constructor of this type keeps count of the number of\n objects it has created, to assign each object a more-or-less unique ID for use in the history strings. This\n counter is reset at the beginning of each python session. Subclasses should automatically have a different\n counter.\n\n Indexing\n --------\n WaveformBase objects can be indexed much like a numpy array, where the first dimension gives the time indices,\n and the second gives the data-set indices. This will return another WaveformBase object containing slices of the\n original data.\n\n It is important to note, however, that as with numpy array slices, slicing a WaveformBase will not typically copy\n the original data; the result will simply be a view into the data. This means that changing the data in the\n slice can change the data in the original. If you want to make a copy, you should probably use the copy\n constructor: `W2 = WaveformBase(W1)`. It is also possible to use the standard copy.deepcopy method.\n\n Also note that the first slice dimension corresponds to the indices of the time, but the second dimension may NOT\n correspond to indices for derived types. In particular, for `WaveformModes`, the second index corresponds to\n modes, because this type enforces completeness of each ell mode. For the `WaveformBase` type, however,\n the second index does correspond to the second dimension of the data.\n\n For example,\n\n >>> W = WaveformBase()\n >>> W[10:-20]\n\n will give all columns in the data, but only at times starting with the\n 10th time step, and ending one before the -20th time step. Meanwhile,\n\n >>> W[10:-20,2]\n\n will give the same range of times, but only the second column (unless the subclass overrides this behavior,\n as in `WaveformModes`). Similarly,\n\n >>> W[10:-20,2:5]\n\n will return the same range of times, along with the 2,3,4 columns. Note the lack of 5 column, for consistency\n with python's usual slice syntax.\n\n >>> W[:,:0]\n\n will return all time steps, along with all `frame` data, but `data` will be empty (because the `:0` term selects\n everything before the 0th element). Similarly,\n\n >>> W[:0,:0]\n\n is empty of all numerical data.\n\n \"\"\"\n\n __num = 0 # Used to count number of Waveforms created\n\n def __init__(self, *args, **kwargs):\n \"\"\"Initializer for WaveformBase object\n\n WaveformBase objects may be created in two ways. First, by copying an existing WaveformBase object -- in\n which case the only parameter should be that object. Second, by passing any of the (writable) attributes as\n keywords.\n\n In both cases, the last step in initialization is to check the validity of the result. By default,\n this will raise an exception if the result is not valid. An additional keyword parameter\n `override_exception_from_invalidity` may be set if this is not desired. This may be necessary if only some\n of the data can be passed in to the initializer, for example.\n\n Keyword parameters\n ------------------\n t: float array, empty default\n frame : quaternion array, empty default\n data : 2-d complex array, empty default\n history : list of strings, empty default\n This is the list of strings prepended to the history, an additional line is appended, showing the call to\n this initializer.\n version_hist : list of pairs of strings, empty default\n Remains empty if waveform data is on version 0.\n frameType : int, defaults to 0 (UnknownFrameType)\n See scri.FrameNames for possible values\n dataType : int, defaults to 0 (UnknownDataType)\n See scri.DataNames for possible values\n r_is_scaled_out : bool, defaults to False\n Set to True if the data represented could approach a nonzero value at Scri\n m_is_scaled_out : bool, defaults to False\n Set to True if the data represented are dimensionless and in units where the total mass is 1\n override_exception_from_invalidity: bool, defaults to False\n If True, report any errors, but do not raise them.\n constructor_statement : str, optional\n If this is present, it will replace the default constructor statement added to the history. It is\n prepended with a string of the form `'{0} = '.format(self)`, which prints the ID of the resulting object\n (unique to this session only).\n\n \"\"\"\n original_kwargs = kwargs.copy()\n super().__init__(*args, **kwargs) # to ensure proper calling in multiple inheritance\n override_exception_from_invalidity = kwargs.pop(\"override_exception_from_invalidity\", False)\n self.__num = type(self).__num\n self.__history_depth__ = 0\n type(self).__num += 1 # Increment class's instance tracker\n if len(args) == 0:\n self.t = kwargs.pop(\"t\", np.empty((0,), dtype=float))\n self.frame = kwargs.pop(\"frame\", np.empty((0,), dtype=np.quaternion))\n self.data = kwargs.pop(\"data\", np.empty((0, 0), dtype=complex))\n # Information about this object\n self.history = kwargs.pop(\"history\", [])\n self.version_hist = kwargs.pop(\"version_hist\", [])\n self.frameType = kwargs.pop(\"frameType\", UnknownFrameType)\n self.dataType = kwargs.pop(\"dataType\", UnknownDataType)\n self.r_is_scaled_out = kwargs.pop(\"r_is_scaled_out\", False)\n self.m_is_scaled_out = kwargs.pop(\"m_is_scaled_out\", False)\n if \"constructor_statement\" in kwargs:\n self._append_history(\"{} = {}\".format(self, kwargs.pop(\"constructor_statement\")))\n else:\n opts = np.get_printoptions()\n np.set_printoptions(threshold=6)\n self._append_history(\n \"{} = {}(**{})\".format(self, type(self).__name__, pprint.pformat(original_kwargs, indent=4))\n )\n np.set_printoptions(**opts)\n elif len(args) == 1 and isinstance(args[0], type(self)):\n other = args[0]\n self.t = np.copy(other.t)\n self.frame = np.copy(other.frame)\n self.data = np.copy(other.data)\n # Information about this object\n self.history = other.history[:]\n self.version_hist = other.version_hist[:]\n self.frameType = other.frameType\n self.dataType = other.dataType\n self.r_is_scaled_out = other.r_is_scaled_out\n self.m_is_scaled_out = other.m_is_scaled_out\n self._append_history([\"\", \"{} = {}({})\".format(self, type(self).__name__, other)])\n else:\n raise ValueError(\n \"Did not understand input arguments to `{}` constructor.\\n\".format(type(self).__name__)\n + \"Note that explicit data values must be passed as keywords,\\n\"\n + \"whereas objects to be copied must be passed as the sole argument.\"\n )\n hostname = socket.gethostname()\n cwd = os.getcwd()\n time = datetime.datetime.now().isoformat()\n self.__history_depth__ = 1\n self.ensure_validity(alter=True, assertions=(not override_exception_from_invalidity))\n self.__history_depth__ = 0\n self._append_history([f\"hostname = {hostname}\", f\"cwd = {cwd}\", f\"datetime = {time}\", version_info()], 1)\n if kwargs:\n warning = \"\\nIn `{}` initializer, unused keyword arguments:\\n\".format(type(self).__name__)\n warning += pprint.pformat(kwargs, indent=4)\n warnings.warn(warning)\n\n @waveform_alterations\n def ensure_validity(self, alter=True, assertions=False):\n \"\"\"Try to ensure that the `WaveformBase` object is valid\n\n This tests various qualities of the WaveformBase's members that are frequently assumed throughout the code.\n If the optional argument `alter` is `True` (which is the default), this function tries to alter the\n WaveformBase in place to ensure validity. Note that this is not always possible. If that is the case,\n an exception may be raised. For example, if the `t` member is not a one-dimensional array of floats,\n it is not clear what that data should be. Similarly, if the `t` and `data` members have mismatched\n dimensions, there is no way to resolve that automatically.\n\n Also note that this is almost certainly not be an exhaustive test of all assumptions made in the code.\n\n If the optional `assertions` argument is `True` (default is `False`), the first test that fails will raise an\n assertion error.\n\n \"\"\"\n import numbers\n\n errors = []\n alterations = []\n\n if assertions:\n test = test_with_assertions\n else:\n test = test_without_assertions\n\n # Ensure that the various data are correct and compatible\n test(\n errors,\n isinstance(self.t, np.ndarray),\n \"isinstance(self.t, np.ndarray) # type(self.t)={}\".format(type(self.t)),\n )\n test(\n errors,\n self.t.dtype == np.dtype(np.float),\n f\"self.t.dtype == np.dtype(np.float) # self.t.dtype={self.t.dtype}\",\n )\n if alter and self.t.ndim == 2 and self.t.shape[1] == 1:\n self.t = self.t[:, 0]\n alterations += [\"{0}.t = {0}.t[:,0]\".format(self)]\n test(\n errors,\n not self.t.size or self.t.ndim == 1,\n f\"not self.t.size or self.t.ndim==1 # self.t.size={self.t.size}; self.t.ndim={self.t.ndim}\",\n )\n test(\n errors,\n self.t.size <= 1 or np.all(np.diff(self.t) > 0.0),\n \"self.t.size<=1 or np.all(np.diff(self.t)>0.0) \"\n \"# self.t.size={}; max(np.diff(self.t))={}\".format(\n self.t.size, (max(np.diff(self.t)) if self.t.size > 1 else np.nan)\n ),\n )\n test(errors, np.all(np.isfinite(self.t)), \"np.all(np.isfinite(self.t))\")\n\n if alter and self.frame is None:\n self.frame = np.empty((0,), dtype=np.quaternion)\n alterations += [f\"{self}.frame = np.empty((0,), dtype=np.quaternion)\"]\n test(\n errors,\n isinstance(self.frame, np.ndarray),\n \"isinstance(self.frame, np.ndarray) # type(self.frame)={}\".format(type(self.frame)),\n )\n if alter and self.frame.dtype == np.dtype(np.float):\n try: # Might fail because of shape\n self.frame = quaternion.as_quat_array(self.frame)\n alterations += [\"{0}.frame = quaternion.as_quat_array({0}.frame)\".format(self)]\n except (AssertionError, ValueError):\n pass\n test(\n errors,\n self.frame.dtype == np.dtype(np.quaternion),\n f\"self.frame.dtype == np.dtype(np.quaternion) # self.frame.dtype={self.frame.dtype}\",\n )\n test(\n errors,\n self.frame.size <= 1 or self.frame.size == self.t.size,\n \"self.frame.size<=1 or self.frame.size==self.t.size \"\n \"# self.frame.size={}; self.t.size={}\".format(self.frame.size, self.t.size),\n )\n test(errors, np.all(np.isfinite(self.frame)), \"np.all(np.isfinite(self.frame))\")\n\n test(\n errors,\n isinstance(self.data, np.ndarray),\n \"isinstance(self.data, np.ndarray) # type(self.data)={}\".format(type(self.data)),\n )\n test(errors, self.data.ndim >= 1, f\"self.data.ndim >= 1 # self.data.ndim={self.data.ndim}\")\n test(\n errors,\n self.data.shape[0] == self.t.shape[0],\n \"self.data.shape[0]==self.t.shape[0] \"\n \"# self.data.shape[0]={}; self.t.shape[0]={}\".format(self.data.shape[0], self.t.shape[0]),\n )\n test(errors, np.all(np.isfinite(self.data)), \"np.all(np.isfinite(self.data))\")\n\n # Information about this object\n if alter and not self.history:\n self.history = [\"\"]\n alterations += [f\"{self}.history = ['']\"]\n if alter and isinstance(self.history, str):\n self.history = self.history.split(\"\\n\")\n alterations += [\"{0}.history = {0}.history.split('\\n')\".format(self)]\n test(\n errors,\n isinstance(self.history, list),\n \"isinstance(self.history, list) # type(self.history)={}\".format(type(self.history)),\n )\n test(\n errors,\n isinstance(self.history[0], str),\n \"isinstance(self.history[0], str) # type(self.history[0])={}\".format(type(self.history[0])),\n )\n test(\n errors,\n isinstance(self.frameType, numbers.Integral),\n \"isinstance(self.frameType, numbers.Integral) # type(self.frameType)={}\".format(type(self.frameType)),\n )\n test(errors, self.frameType in FrameType, f\"self.frameType in FrameType # self.frameType={self.frameType}\")\n test(\n errors,\n isinstance(self.dataType, numbers.Integral),\n \"isinstance(self.dataType, numbers.Integral) # type(self.dataType)={}\".format(type(self.dataType)),\n )\n test(errors, self.dataType in DataType, f\"self.dataType in DataType # self.dataType={self.dataType}\")\n test(\n errors,\n isinstance(self.r_is_scaled_out, bool),\n \"isinstance(self.r_is_scaled_out, bool) # type(self.r_is_scaled_out)={}\".format(type(self.r_is_scaled_out)),\n )\n test(\n errors,\n isinstance(self.m_is_scaled_out, bool),\n \"isinstance(self.m_is_scaled_out, bool) # type(self.m_is_scaled_out)={}\".format(type(self.m_is_scaled_out)),\n )\n test(\n errors,\n isinstance(self.num, numbers.Integral),\n \"isinstance(self.num, numbers.Integral) # type(self.num)={}\".format(type(self.num)),\n )\n\n if alterations:\n self._append_history(alterations)\n warnings.warn(\"The following alterations were made:\\n\\t\" + \"\\n\\t\".join(alterations))\n if errors:\n warnings.warn(\"The following conditions were found to be incorrectly False:\\n\\t\" + \"\\n\\t\".join(errors))\n return False\n\n self.__history_depth__ -= 1\n self._append_history(\"WaveformBase.ensure_validity\" + f\"({self}, alter={alter}, assertions={assertions})\")\n\n return True\n\n @property\n def is_valid(self):\n return self.ensure_validity(alter=False, assertions=False)\n\n # Data sizes\n @property\n def n_data_sets(self):\n return int(np.prod(self.data.shape[1:]))\n\n @property\n def n_times(self):\n return self.t.shape[0]\n\n # Calculate weights\n @property\n def spin_weight(self):\n return SpinWeights[self.dataType]\n\n @property\n def conformal_weight(self):\n return ConformalWeights[self.dataType] + (-RScaling[self.dataType] if self.r_is_scaled_out else 0)\n\n @property\n def gamma_weight(self):\n \"\"\"Non-conformal effect of a boost.\n\n This factor allows for mass-scaling, for example. If the waveform describes `r*h/M`, for example,\n then `r` and `h` vary by the conformal weight, which depends on the direction; whereas `M` is a monopole,\n and thus cannot depend on the direction. Instead, `M` simply obeys the standard formula, scaling with gamma.\n\n \"\"\"\n return (MScaling[self.dataType] if self.m_is_scaled_out else 0) + (\n -RScaling[self.dataType] if (self.r_is_scaled_out and self.m_is_scaled_out) else 0\n )\n\n @property\n def r_scaling(self):\n return RScaling[self.dataType]\n\n @property\n def m_scaling(self):\n return MScaling[self.dataType]\n\n # Text descriptions\n @property\n def num(self):\n return self.__num\n\n @property\n def frame_type_string(self):\n return FrameNames[self.frameType]\n\n @property\n def data_type_string(self):\n return DataNames[self.dataType]\n\n @property\n def data_type_latex(self):\n return DataNamesLaTeX[self.dataType]\n\n @property\n def descriptor_string(self):\n \"\"\"Create a simple string describing the content of the waveform\n\n This string will be suitable for file names. For example, 'rMpsi4' or 'rhOverM'. It uses the waveform's\n knowledge of itself, so if this is incorrect, the result will be incorrect.\n\n \"\"\"\n if self.dataType == UnknownDataType:\n return self.data_type_string\n descriptor = \"\"\n if self.r_is_scaled_out:\n if RScaling[self.dataType] == 1:\n descriptor = \"r\"\n elif RScaling[self.dataType] > 1:\n descriptor = \"r\" + str(RScaling[self.dataType])\n if self.m_is_scaled_out:\n Mexponent = MScaling[self.dataType] - (RScaling[self.dataType] if self.r_is_scaled_out else 0)\n if Mexponent < -1:\n descriptor = descriptor + self.data_type_string + \"OverM\" + str(-Mexponent)\n elif Mexponent == -1:\n descriptor = descriptor + self.data_type_string + \"OverM\"\n elif Mexponent == 0:\n descriptor = descriptor + self.data_type_string\n elif Mexponent == 1:\n descriptor = descriptor + \"M\" + self.data_type_string\n elif Mexponent > 1:\n descriptor = descriptor + \"M\" + str(Mexponent) + self.data_type_string\n else:\n descriptor = descriptor + self.data_type_string\n return descriptor\n\n # Data simplifications\n @property\n def data_2d(self):\n return self.data.reshape((self.n_times, self.n_data_sets))\n\n @property\n def abs(self):\n return np.abs(self.data)\n\n @property\n def arg(self):\n return np.angle(self.data)\n\n @property\n def arg_unwrapped(self):\n return np.unwrap(np.angle(self.data), axis=0)\n\n def norm(self, take_sqrt=False, indices=slice(None, None, None)):\n \"\"\"L2 norm of the waveform\n\n The optional arguments say whether to take the square-root of\n the norm at each time, and allow restriction to a slice of the\n data, respectively.\n\n \"\"\"\n if indices == slice(None, None, None):\n n = np.empty((self.n_times,), dtype=float)\n else:\n n = np.empty((self.t[indices].shape[0],), dtype=float)\n if take_sqrt:\n complex_array_abs(self.data_2d[indices], n)\n else:\n complex_array_norm(self.data_2d[indices], n)\n return n\n\n def max_norm_index(self, skip_fraction_of_data=4):\n \"\"\"Index of time step with largest norm\n\n The optional argument skips a fraction of the data. The default is\n 4, which means that it only searches the last three-fourths of the\n data for the max. If 0 or 1 is input, this is ignored, and all the\n data is searched.\n\n \"\"\"\n if skip_fraction_of_data == 0 or skip_fraction_of_data == 1:\n indices = slice(None, None, None)\n return np.argmax(self.norm(indices=indices))\n else:\n indices = slice(self.n_times // skip_fraction_of_data, None, None)\n return np.argmax(self.norm(indices=indices)) + (self.n_times // skip_fraction_of_data)\n\n def max_norm_time(self, skip_fraction_of_data=4):\n \"\"\"Return time at which largest norm occurs in data\n\n See `help(max_norm_index)` for explanation of the optional argument.\n\n \"\"\"\n return self.t[self.max_norm_index(skip_fraction_of_data=skip_fraction_of_data)]\n\n def compare(self, w_a, min_time_step=0.005, min_time=-3.0e300):\n \"\"\"Return a waveform with differences between the two inputs\n\n This function simply subtracts the data in this waveform from the data\n in Waveform A, and finds the rotation needed to take this frame into frame A.\n Note that the waveform data are stored as complex numbers, rather than as \n modulus and phase.\n \"\"\"\n from quaternion.means import mean_rotor_in_chordal_metric\n from scri.extrapolation import intersection\n import scri.waveform_modes\n\n if self.frameType != w_a.frameType:\n warning = (\n \"\\nWarning:\"\n + \"\\n This Waveform is in the \"\n + self.frame_type_string\n + \" frame,\"\n + \"\\n The Waveform in the argument is in the \"\n + w_a.frame_type_string\n + \" frame.\"\n + \"\\n Comparing them probably does not make sense.\\n\"\n )\n warnings.warn(warning)\n\n if self.n_modes != w_a.n_modes:\n raise Exception(\n \"Trying to compare waveforms with mismatched LM data.\"\n + \"\\nA.n_modes=\"\n + str(w_a.n_modes)\n + \"\\tB.n_modes()=\"\n + str(self.n_modes)\n )\n\n new_times = intersection(self.t, w_a.t)\n\n w_c = scri.waveform_modes.WaveformModes(\n t=new_times,\n data=np.zeros((new_times.shape[0], self.n_modes), dtype=self.data.dtype),\n history=[],\n version_hist=self.version_hist,\n frameType=self.frameType,\n dataType=self.dataType,\n r_is_scaled_out=self.r_is_scaled_out,\n m_is_scaled_out=self.m_is_scaled_out,\n ell_min=self.ell_min,\n ell_max=self.ell_max,\n )\n\n w_c.history += [\"B.compare(A)\\n\"]\n w_c.history += [\"### A.history.str():\\n\" + \"\".join(w_a.history)]\n w_c.history += [\"### B.history.str():\\n\" + \"\".join(self.history)]\n w_c.history += [\"### End of old histories from `compare`\"]\n\n # Process the frame, depending on the sizes of the input frames\n if w_a.frame.shape[0] > 1 and self.frame.shape[0] > 1:\n # Find the frames interpolated to the appropriate times\n Aframe = quaternion.squad(w_a.frame, w_a.t, w_c.t)\n Bframe = quaternion.squad(self.frame, self.t, w_c.t)\n # Assign the data\n w_c.frame = Aframe * np.array([np.quaternion.inverse(v) for v in Bframe])\n elif w_a.frame.shape[0] == 1 and self.frame.shape[0] > 1:\n # Find the frames interpolated to the appropriate times\n Bframe = np.quaternion.squad(self.frame, self.t, w_c.t)\n # Assign the data\n w_c.frame.resize(w_c.n_times)\n w_c.frame = w_a.frame[0] * np.array([np.quaternion.inverse(v) for v in Bframe])\n elif w_a.frame.shape[0] > 1 and self.frame.shape[0] == 1:\n # Find the frames interpolated to the appropriate times\n Aframe = np.quaternion.squad(w_a.frame, w_a.t, w_c.t)\n # Assign the data\n w_c.frame.resize(w_c.n_times)\n w_c.frame = Aframe * np.quaternion.inverse(self.frame[0])\n elif w_a.frame.shape[0] == 1 and self.frame.shape[0] == 1:\n # Assign the data\n w_c.frame = np.array(w_a.frame[0] * np.quaternions.inverse(self.frame[0]))\n elif w_a.frame.shape[0] == 0 and self.frame.shape[0] == 1:\n # Assign the data\n w_c.frame = np.array(np.quaternions.inverse(self.frame[0]))\n elif w_a.frame.shape[0] == 1 and self.frame.shape[0] == 1:\n # Assign the data\n w_c.frame = np.array(w_a.frame[0])\n # else, leave the frame data empty\n\n # If the average frame rotor is closer to -1 than to 1, flip the sign\n if w_c.frame.shape[0] == w_c.n_times:\n R_m = mean_rotor_in_chordal_metric(w_c.frame, w_c.t)\n if quaternion.rotor_chordal_distance(R_m, -quaternion.one) < quaternion.rotor_chordal_distance(\n R_m, quaternion.one\n ):\n w_c.frame = -w_c.frame\n elif w_c.frame.shape[0] == 1:\n if quaternion.rotor_chordal_distance(w_c.frame[0], -quaternion.one) < quaternion.rotor_chordal_distance(\n w_c.frame[0], quaternion.one\n ):\n w_c.frame[0] = -w_c.frame[0]\n\n # Now loop over each mode filling in the waveform data\n for AMode in range(w_a.n_modes):\n # Assume that all the ell,m data are the same, but not necessarily in the same order\n BMode = self.index(w_a.LM[AMode][0], w_a.LM[AMode][1])\n # Initialize the interpolators for this data set\n # (Can't just re-view here because data are not contiguous)\n splineReA = CubicSpline(w_a.t, w_a.data[:, AMode].real)\n splineImA = CubicSpline(w_a.t, w_a.data[:, AMode].imag)\n splineReB = CubicSpline(self.t, self.data[:, BMode].real)\n splineImB = CubicSpline(self.t, self.data[:, BMode].imag)\n # Assign the data from the transition\n w_c.data[:, AMode] = (splineReA(w_c.t) - splineReB(w_c.t)) + 1j * (splineImA(w_c.t) - splineImB(w_c.t))\n\n return w_c\n\n @property\n def data_dot(self):\n return CubicSpline(self.t, self.data).derivative()(self.t)\n\n @property\n def data_ddot(self):\n return CubicSpline(self.t, self.data).derivative(2)(self.t)\n\n @property\n def data_int(self):\n return CubicSpline(self.t, self.data).antiderivative()(self.t)\n\n @property\n def data_iint(self):\n return CubicSpline(self.t, self.data).antiderivative(2)(self.t)\n\n # Data representations\n def _append_history(self, hist, additional_depth=0):\n \"\"\"Add to the object's history log\n\n Input may be a single string or list of strings. Any newlines will be split into separate strings. Each\n such string is then prepended with a number of `#`s, indicating that the content of that line was called from\n within a member function, or is simply a piece of information relevant to the waveform. The idea behind this\n is that the history should be -- as nearly as possible -- a script that could be run to reproduce the\n waveform, so the lines beginning with `#` would not be run.\n\n The number of `#`s is controlled by the object's `__history_depth__` field and the optional input to this\n function; their sum is the number prepended. The user should never have to deal with this issue,\n but all member functions should increment the `__history_depth__` before calling another member function,\n and decrement it again as necessary before recording itself in the history. Also, for any lines added just\n for informational purposes (e.g., the hostname, pwd, date, and versions added in `__init__`), this function\n should be called with `1` as the optional argument.\n\n \"\"\"\n if not isinstance(hist, list):\n hist = [hist]\n self.history += [\n \"# \" * (self.__history_depth__ + additional_depth) + hist_line\n for hist_element in hist\n for hist_line in hist_element.split(\"\\n\")\n ]\n\n def __str__(self):\n # \"The goal of __str__ is to be readable; the goal of __repr__ is to be unambiguous.\" --- stackoverflow\n return \"{}_{}\".format(type(self).__name__, self.num)\n\n def __repr__(self):\n # \"The goal of __str__ is to be readable; the goal of __repr__ is to be unambiguous.\" --- stackoverflow\n from textwrap import dedent\n\n opts = np.get_printoptions()\n np.set_printoptions(threshold=6, linewidth=150, precision=6)\n rep = \"\"\"\n {0}(\n t={1},\n frame={2},\n data={5},\n frameType={6}, dataType={7},\n r_is_scaled_out={8}, m_is_scaled_out={9}) # num = {10}\"\"\"\n rep = rep.format(\n type(self).__name__,\n str(self.t).replace(\"\\n\", \"\\n\" + \" \" * 15),\n str(self.frame).replace(\"\\n\", \"\\n\" + \" \" * 19),\n self.history,\n self.version_hist,\n str(self.data).replace(\"\\n\", \"\\n\" + \" \" * 18),\n self.frameType,\n self.dataType,\n self.r_is_scaled_out,\n self.m_is_scaled_out,\n self.num,\n )\n np.set_printoptions(**opts)\n return dedent(rep)\n\n def __getstate__(self):\n \"\"\"Get state of object for copying and pickling\n\n The only nontrivial operation is with quaternions, since they can't\n currently be pickled automatically. We just view the frame array as\n a float array, and pickle as usual.\n\n Also, we remove the `num` value, because this will get reset\n properly on creation.\n\n \"\"\"\n state = copy.deepcopy(self.__dict__)\n state[\"frame\"] = quaternion.as_float_array(self.frame)\n return state\n\n def __setstate__(self, state):\n \"\"\"Set state of object for copying and pickling\n\n The only nontrivial operation is with quaternions, since they can't\n currently be pickled automatically. We just view the frame array as\n a float array, and unpickle as usual, then convert the float array\n back to a quaternion array.\n\n \"\"\"\n new_num = self.__num\n old_num = state.get(\"_WaveformBase__num\")\n self.__dict__.update(state)\n # Make sure to preserve auto-incremented num\n self.__num = new_num\n self.frame = quaternion.as_quat_array(self.frame)\n self._append_history(f\"copied, deepcopied, or unpickled as {self}\", 1)\n self._append_history(\"{} = {}\".format(self, f\"{self}\".replace(str(self.num), str(old_num))))\n\n @waveform_alterations\n def deepcopy(self):\n \"\"\"Return a deep copy of the object\n\n This is just an alias for `copy`, which is deep anyway.\n\n \"\"\"\n W = self.copy()\n W.__history_depth__ -= 1\n W._append_history(f\"{W} = {self}.deepcopy()\")\n return W\n\n @waveform_alterations\n def copy(self):\n \"\"\"Return a (deep) copy of the object\n\n Note that this also copies all members if the object is a subclass. If you want a forgetful WaveformBase\n object, you can simply use the copy constructor.\n\n \"\"\"\n W = type(self)()\n state = copy.deepcopy(self.__dict__)\n state.pop(\"_WaveformBase__num\")\n W.__dict__.update(state)\n W.__history_depth__ -= 1\n W._append_history(f\"{W} = {self}.copy()\")\n return W\n\n @waveform_alterations\n def copy_without_data(self):\n \"\"\"Return a copy of the object, with empty `t`, `frame`, and `data` fields\n\n Note that subclasses may override this to set some related data members. For example,\n `WaveformModes.copy_without_data` sets the `ell_min` and `ell_max` fields appropriately. If you wish to only\n skip `t`, `frame`, and `data`, you can simply use `WaveformBase.copy_without_data(W)`. The latter is useful\n if, for example, you will only be making changes to those three fields, and want everything else preserved.\n\n Also note that some slicing operations can achieve similar -- but different -- goals. For example,\n `w = w[:, :0]` will simply empty `data` and `ells`, without affecting the `time` and `frame`.\n\n \"\"\"\n W = type(self)()\n state = copy.deepcopy(self.__dict__)\n state.pop(\"_WaveformBase__num\")\n state.pop(\"t\")\n state.pop(\"frame\")\n state.pop(\"data\")\n W.__dict__.update(state)\n W.__history_depth__ -= 1\n W._append_history(f\"{W} = {self}.copy_without_data()\")\n return W\n\n def _allclose(\n self, other, report_all=True, rtol=1e-10, atol=1e-10, compare_history_beginnings=False, exceptions=[]\n ):\n \"\"\"Check that member data in two waveforms are the same\n\n For data sets (time, modes, etc.), the numpy function `np.allclose` is used, with the input tolerances. See\n that function's documentation for more details. The `*__num` datum is always ignored. By default,\n the `history` is ignored, though this can be partially overridden -- in which case, the shortest subset of\n the histories is compared for exact equality. This is probably only appropriate for the case where one\n waveform was created from the other.\n\n Parameters\n ----------\n other : object\n Another object subclassing WaveformBase to compare\n report_all: bool, optional\n Wait until all attributes have been checked (and reported on) before returning the verdict\n rtol : float, optional\n Relative tolerance to which to compare arrays (see np.allclose), defaults to 1e-10\n atol : float, optional\n Absolute tolerance to which to compare arrays (see np.allclose), defaults to 1e-10\n compare_history_beginnings: bool, optional\n Compare the shortest common part of the `history` fields for equality, defaults to False\n exceptions : list, optional\n Don't compare elements in this list, corresponding to keys in the object's `__dict__`, defaults to []\n\n \"\"\"\n equality = True\n if not type(self) == type(other): # not isinstance(other, self.__class__):\n warnings.warn(\"\\n (type(self)={}) != (type(other)={})\".format(type(self), type(other)))\n equality = False\n if not report_all and not equality:\n return False\n for key, val in self.__dict__.items():\n if key.endswith(\"__num\") or key in exceptions:\n continue\n elif key == \"history\":\n if compare_history_beginnings:\n min_length = min(len(self.history), len(other.history))\n if self.history[:min_length] != other.history[:min_length]:\n warnings.warn(\"\\n `history` fields differ\")\n equality = False\n elif key == \"version_hist\":\n if self.version_hist != other.version_hist:\n warnings.warn(\"\\n `version_hist` fields differ\")\n equality = False\n elif isinstance(val, np.ndarray):\n if val.dtype == np.quaternion:\n if not np.allclose(\n quaternion.as_float_array(val), quaternion.as_float_array(other.__dict__[key]), rtol, atol\n ):\n warnings.warn(f\"\\n `{key}` fields differ\")\n equality = False\n elif not np.allclose(val, other.__dict__[key], rtol, atol):\n warnings.warn(f\"\\n `{key}` fields differ\")\n equality = False\n else:\n if not val == other.__dict__[key]:\n warnings.warn(\n \"\\n (self.{0}={1}) != (other.{0}={2}) fields differ\".format(key, val, other.__dict__[key])\n )\n equality = False\n if not report_all and not equality:\n return False\n return equality\n\n # Slicing\n @waveform_alterations\n def __getitem__(self, key):\n \"\"\"Extract subsets of the data efficiently\n\n See the docstring of the WaveformBase class for examples.\n\n \"\"\"\n W = WaveformBase.copy_without_data(self)\n\n # Remove trivial tuple structure first\n if isinstance(key, tuple) and len(key) == 1:\n key = key[0]\n\n # Now figure out which type of return is desired\n if isinstance(key, tuple) and 2 <= len(key) <= self.n_data_sets:\n # Return a subset of the data from a subset of times\n W.t = self.t[key[0]]\n W.frame = self.frame[key[0]]\n W.data = self.data[key]\n elif isinstance(key, slice) or isinstance(key, int):\n # Return complete data from a subset of times (key is slice), or\n # return complete data from a single instant in time (key is int)\n W.t = self.t[key]\n W.frame = self.frame[key]\n W.data = self.data[key]\n else:\n raise ValueError(\"Could not understand input `{}` (of type `{}`) \".format(key, type(key)))\n\n W.__history_depth__ -= 1\n W._append_history(f\"{W} = {self}[{key}]\")\n\n return W\n\n @waveform_alterations\n def interpolate(self, tprime):\n \"\"\"Interpolate the frame and data onto the new set of time steps\n\n Note that only `t`, `frame`, and `data` are changed in this function. If there is a corresponding data set\n in a subclass, for example, the subclass must override this function to set that data set -- though this\n function should probably be called to handle the ugly stuff.\n\n \"\"\"\n # Copy the information fields, but not the data\n W = WaveformBase.copy_without_data(self)\n\n W.t = np.copy(tprime)\n W.frame = quaternion.squad(self.frame, self.t, W.t)\n W.data = np.empty((W.n_times,) + self.data.shape[1:], dtype=self.data.dtype)\n W.data_2d[:] = CubicSpline(self.t, self.data_2d.view(float))(W.t).view(complex)\n W.__history_depth__ -= 1\n W._append_history(f\"{W} = {self}.interpolate({tprime})\")\n return W\n\n @waveform_alterations\n def SI_units(self, current_unit_mass_in_solar_masses, distance_from_source_in_megaparsecs=100):\n \"\"\"Assuming current quantities are in geometric units, convert to SI units\n\n This function assumes that the `dataType`, `r_is_scaled_out`, and `m_is_scaled_out` attributes are correct,\n then scales the amplitude and time data appropriately so that the data correspond to data that could be\n observed from a source with the given total mass at the given distance.\n\n Note that the curvature scalars will have units of s^-2, rather than the arguably more correct m^-2. This\n seems to be more standard in numerical relativity. The result can be divided by `scipy.constants.c**2`\n to give units of m^-2 if desired.\n\n Parameters\n ----------\n current_unit_mass_in_solar_masses : float\n Mass of the system in the data converted to solar masses\n distance_from_source_in_megaparsecs : float, optional\n Output will be waveform as observed from this distance, default=100 (Mpc)\n\n \"\"\"\n if not self.r_is_scaled_out:\n warning = (\n \"\\nTrying to convert to SI units, the radius is supposedly not scaled out.\\n\"\n + \"This seems to suggest that the data may already be in some units...\"\n )\n warnings.warn(warning)\n if not self.m_is_scaled_out:\n warning = (\n \"\\nTrying to convert to SI units, the mass is supposedly not scaled out.\\n\"\n + \"This seems to suggest that the data may already be in some units...\"\n )\n warnings.warn(warning)\n\n M_in_meters = current_unit_mass_in_solar_masses * m_sun_in_meters # m\n M_in_seconds = M_in_meters / speed_of_light # s\n R_in_meters = distance_from_source_in_megaparsecs * (1e6 * parsec_in_meters) # m\n R_over_M = R_in_meters / M_in_meters # [dimensionless]\n\n # The radius scaling `r_scaling` is the number of factors of the dimensionless quantity `R_over_M` required\n # to keep the waveform asymptotically constant. So, for example, h and Psi4 both have `r_scaling=1`. The\n # mass scaling `m_scaling` is the number of factors of `M_in_meters` required to make the waveform\n # dimensionless, and does not account for the factors of mass in the radius scale. The Newman-Penrose\n # quantities are curvature quantities, so they have dimensions 1/m^2, and thus have `m_scaling=2`.\n if self.r_is_scaled_out:\n if self.m_is_scaled_out:\n amplitude_scaling = (R_over_M ** -self.r_scaling) * (M_in_meters ** -self.m_scaling)\n else:\n amplitude_scaling = R_over_M ** -self.r_scaling\n else:\n if self.m_is_scaled_out:\n amplitude_scaling = M_in_meters ** -self.m_scaling\n else:\n amplitude_scaling = 1.0\n\n # Copy the information fields, but not the data\n W = WaveformBase.copy_without_data(self)\n\n if self.m_is_scaled_out:\n W.t = M_in_seconds * self.t # s\n else:\n W.t = np.copy(self.t) # supposedly already in the appropriate units...\n W.frame = np.copy(self.frame)\n W.data = amplitude_scaling * self.data\n\n W.m_is_scaled_out = False\n W.r_is_scaled_out = False\n\n W.__history_depth__ -= 1\n W._append_history(\n \"{} = {}.SI_units(current_unit_mass_in_solar_masses={}, \"\n \"distance_from_source_in_megaparsecs={})\".format(\n W, self, current_unit_mass_in_solar_masses, distance_from_source_in_megaparsecs\n )\n )\n\n return W\n", "meta": {"hexsha": "58f3e44e42996bfc3dd046731d739697f0cd4722", "size": 45242, "ext": "py", "lang": "Python", "max_stars_repo_path": "scri/waveform_base.py", "max_stars_repo_name": "akhairna/scri", "max_stars_repo_head_hexsha": "3b7f307d19ef303914cef2fa088ee750ef8533c2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "scri/waveform_base.py", "max_issues_repo_name": "akhairna/scri", "max_issues_repo_head_hexsha": "3b7f307d19ef303914cef2fa088ee750ef8533c2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "scri/waveform_base.py", "max_forks_repo_name": "akhairna/scri", "max_forks_repo_head_hexsha": "3b7f307d19ef303914cef2fa088ee750ef8533c2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.3767976989, "max_line_length": 120, "alphanum_fraction": 0.6174351267, "include": true, "reason": "import numpy,import scipy,from scipy", "num_tokens": 10399, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6187804478040616, "lm_q2_score": 0.31742625913050115, "lm_q1q2_score": 0.1964171627695396}} {"text": "def selection_3():\n\n # Library import\n import numpy\n import matplotlib\n import matplotlib.pyplot as plt\n import matplotlib.gridspec as gridspec\n\n # Library version\n matplotlib_version = matplotlib.__version__\n numpy_version = numpy.__version__\n\n # Histo binning\n xBinning = numpy.linspace(0.0,1000.0,101,endpoint=True)\n\n # Creating data sequence: middle of each bin\n xData = numpy.array([5.0,15.0,25.0,35.0,45.0,55.0,65.0,75.0,85.0,95.0,105.0,115.0,125.0,135.0,145.0,155.0,165.0,175.0,185.0,195.0,205.0,215.0,225.0,235.0,245.0,255.0,265.0,275.0,285.0,295.0,305.0,315.0,325.0,335.0,345.0,355.0,365.0,375.0,385.0,395.0,405.0,415.0,425.0,435.0,445.0,455.0,465.0,475.0,485.0,495.0,505.0,515.0,525.0,535.0,545.0,555.0,565.0,575.0,585.0,595.0,605.0,615.0,625.0,635.0,645.0,655.0,665.0,675.0,685.0,695.0,705.0,715.0,725.0,735.0,745.0,755.0,765.0,775.0,785.0,795.0,805.0,815.0,825.0,835.0,845.0,855.0,865.0,875.0,885.0,895.0,905.0,915.0,925.0,935.0,945.0,955.0,965.0,975.0,985.0,995.0])\n\n # Creating weights for histo: y4_PT_0\n y4_PT_0_weights = numpy.array([0.0,0.0,5786.78210348,5281.0605314,4910.13784526,4512.19118199,4188.24845609,3792.452791,3452.23507887,3119.38536052,2778.24544917,2424.20944874,2150.00818076,1824.83545591,1649.19940452,1437.02338405,1233.75225605,1147.16242932,997.011956373,855.151676409,756.58675981,611.349082704,565.904821157,500.808776238,433.256333398,377.679280425,332.541918618,297.844607977,263.454317077,241.653305524,201.12186982,173.793872943,150.150532949,139.096502303,123.743685294,107.776768804,92.423951795,77.9923140064,74.9217266046,58.0336308945,58.3407106347,46.979600248,40.8384854443,39.6102564836,31.3197334986,27.6350676164,19.9586591119,17.5022101904,19.6516033717,13.510476568,9.51874594566,14.4316467886,11.3610833868,7.98346424475,4.60584510274,3.07056340183,4.29878936256,4.91290084292,4.29878936256,4.91290084292,4.29878936256,2.14939408128,3.07056340183,2.76350676164,1.53528140091,1.22822506073,1.22822506073,0.0,0.0,0.921169020548,0.614112680365,0.614112680365,0.921169020548,0.0,0.307056340183,0.0,0.307056340183,0.307056340183,0.307056340183,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0])\n\n # Creating weights for histo: y4_PT_1\n y4_PT_1_weights = numpy.array([0.0,0.0,0.912787033803,1.81916001616,0.913150150035,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0])\n\n # Creating weights for histo: y4_PT_2\n y4_PT_2_weights = numpy.array([0.0,0.0,9.03876615718,14.3000564189,12.8016704253,17.3227331768,16.5649496758,11.2956205368,5.27149226024,0.753445792208,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0])\n\n # Creating weights for histo: y4_PT_3\n y4_PT_3_weights = numpy.array([0.0,0.0,14.8559620956,23.5128565693,33.4114494002,35.0706872792,41.6621785534,41.2548950084,49.9204336313,37.5395562166,36.3045123613,32.5797585463,32.5970041875,21.8638411509,21.0363520176,13.2018247826,9.90207547543,4.94335946635,2.06216552844,1.64844503259,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0])\n\n # Creating weights for histo: y4_PT_4\n y4_PT_4_weights = numpy.array([0.0,0.0,8.06773951744,11.4694905207,15.7648365263,18.0599629707,19.6151602019,20.4277586991,19.985478039,19.5384174939,17.6129655561,16.5048709572,18.0592444849,16.2814248587,15.4683002735,16.2833668748,14.9508972563,15.6930059769,12.5830985217,12.7298289681,11.4718383762,8.06757718172,7.25323808485,5.77328345942,3.84893179711,3.035434441,1.92420736389,1.48061599318,0.518508403149,0.296202322267,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0])\n\n # Creating weights for histo: y4_PT_5\n y4_PT_5_weights = numpy.array([0.0,0.0,1.98520664078,2.76083543994,3.47885497709,4.36822048457,4.57526056873,4.72688710688,4.70792778793,5.27467278568,4.7451202221,5.19959472287,4.85838399774,4.93370812958,4.63180543214,5.12282718608,4.650557693,4.55613920432,4.34802181793,4.23457499093,4.10239390812,4.12158129106,3.38377030151,3.64899670958,3.42176996214,3.30863222186,3.04361887356,3.02438047631,2.8168308492,2.79897253913,2.60929172504,2.06127168048,1.38007397353,1.30416587786,0.907631031796,0.718306417629,0.585807245583,0.264645535112,0.22687985012,0.0944662320757,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0])\n\n # Creating weights for histo: y4_PT_6\n y4_PT_6_weights = numpy.array([0.0,0.0,0.880926044487,1.20383059022,1.20151975902,1.09497409521,1.31032601857,1.24538506363,1.69603313814,1.84686773395,1.48109284564,1.58894013274,1.43859064653,1.33080709099,1.1594854245,1.50232819976,1.28826365381,1.24532733034,1.33089706495,1.095309998,1.11736711428,1.09536248281,1.00963604355,0.773454398675,1.07269504316,1.05274631667,0.665614834344,0.881270194884,1.18044410868,0.793935471091,1.11647562229,1.00927614771,0.793924974129,0.880071291868,0.988191499975,0.966535517598,0.773048766072,0.600648461756,0.902253621911,0.580388350389,0.558027497014,0.708427668556,0.49457681076,0.407801125172,0.408065798571,0.343790800887,0.257956317898,0.214864039563,0.279192496774,0.17203800917,0.236497678407,0.0857799737648,0.0427792889203,0.0427693093086,0.0641474146084,0.107100053358,0.0,0.0641858334893,0.0212968213248,0.0215439423037,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0])\n\n # Creating weights for histo: y4_PT_7\n y4_PT_7_weights = numpy.array([0.0,0.0,0.0939633949117,0.126374698649,0.139312395938,0.137681978341,0.110036261618,0.130970489133,0.106837410644,0.0971007960125,0.0988517245135,0.0939811540823,0.0938545139077,0.102055573202,0.0712685263583,0.0824750345434,0.0808946569453,0.0890838348826,0.0745356165535,0.0550748658589,0.0745386969052,0.0680569453587,0.0648158809925,0.0518185254627,0.0404785877563,0.0567118213458,0.0388850715151,0.0583254227375,0.043744232072,0.0421359112833,0.029187709366,0.0403724413503,0.0517026036547,0.0615929529829,0.0436066535055,0.0502176855281,0.0404902176557,0.0583105238935,0.0599251311143,0.0647839144853,0.0356373120987,0.0356562656915,0.0534745288389,0.0550742686478,0.0372410752242,0.0421144745498,0.0615596034606,0.0437515243332,0.0583280944712,0.0631650639227,0.0550754316378,0.0615762625057,0.043736594057,0.04858245881,0.0631755308322,0.0583313005516,0.0453435003985,0.043755201896,0.0453509812527,0.0485824273778,0.0372615689929,0.0453472408256,0.0291467186855,0.0340059829685,0.0291682214265,0.0388617174199,0.0113483458093,0.0162010376275,0.0113408869576,0.0129638299874,0.0097293192267,0.00324230279333,0.00161444628819,0.00324402841894,0.0016198774512,0.006482166451,0.0,0.0,0.00162193248585,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0])\n\n # Creating weights for histo: y4_PT_8\n y4_PT_8_weights = numpy.array([0.0,0.0,0.019051396408,0.0255568357526,0.0170323594326,0.0127713462745,0.0169406513367,0.0127830172016,0.0105960224445,0.0191430599584,0.0149063018377,0.0106548047169,0.00638585020569,0.0106519348716,0.0149184961746,0.00424989905007,0.00635183190326,0.00426200095508,0.0042612147266,0.0105419653385,0.00637643216845,0.00426733639512,0.00635995589306,0.00632726281994,0.00638804852726,0.00213219485438,0.00212624023157,0.0042598315881,0.00213219485438,0.00841264032944,0.00850301317327,0.00213060680648,0.00425744172078,0.00213219485438,0.0,0.00213366819756,0.00426427500404,0.0,0.0,0.00426586305194,0.0,0.00213219485438,0.00212980498706,0.00213219485438,0.0,0.00212624023157,0.00425149489344,0.00639408110474,0.0,0.0042458554302,0.00213219485438,0.00426041290718,0.00426200095508,0.0,0.00426130493128,0.00212763673372,0.00851974001723,0.0,0.00426200095508,0.00425744172078,0.0,0.00213366819756,0.0,0.0084835634842,0.00213366819756,0.00637891001318,0.00639180594214,0.00212763673372,0.0,0.0,0.00425387585165,0.00212624023157,0.0106495450043,0.0,0.0,0.0042598315881,0.00212624023157,0.0,0.00423014979236,0.0,0.00851209043726,0.0,0.00212624023157,0.0,0.00425744172078,0.00212980498706,0.0,0.00212763673372,0.0,0.00213219485438,0.00213219485438,0.00213366819756,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0])\n\n # Creating weights for histo: y4_PT_9\n y4_PT_9_weights = numpy.array([0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0])\n\n # Creating weights for histo: y4_PT_10\n y4_PT_10_weights = numpy.array([0.0,0.0,79.0971291539,0.0,78.9085371523,0.0,78.97186254,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0])\n\n # Creating weights for histo: y4_PT_11\n y4_PT_11_weights = numpy.array([0.0,0.0,86.4011892197,310.922590593,155.352700617,172.742662894,190.060574561,103.726017745,51.7445000294,51.7772398266,69.099589811,34.5700267167,103.78097795,17.2983917156,51.8014200112,17.3004869473,17.2596400156,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0])\n\n # Creating weights for histo: y4_PT_12\n y4_PT_12_weights = numpy.array([0.0,0.0,176.541933258,95.5647890812,118.376517189,91.3858283688,64.4067086643,39.4564829255,33.2292406025,43.6029289416,29.0534246123,29.0616470511,35.2906492644,20.7724767543,18.7008953489,18.6877019411,16.6110745549,12.4623349111,18.6940433166,14.5383189276,10.3939732397,6.2198536684,4.15369618751,16.6027338285,2.0744012691,4.1530989788,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0])\n\n # Creating weights for histo: y4_PT_13\n y4_PT_13_weights = numpy.array([0.0,0.0,55.9532928362,43.1132315618,26.4785176646,15.1222611138,11.3375538375,8.30775980306,9.83549701357,9.83379014633,5.29433803914,6.80093740577,9.07770713151,3.77614745088,5.29255379392,3.78273459292,5.28628617742,6.04602416396,4.53634287784,2.2632385926,3.02597565867,3.02454553151,3.02161836798,4.53661005946,6.80269889276,2.26997184248,2.27025495486,0.753999271304,2.27222854855,0.755502679967,2.26702510688,2.26997184248,0.0,0.0,0.757751193074,2.26503558243,0.757151741301,0.0,0.0,0.756398443893,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0])\n\n # Creating weights for histo: y4_PT_14\n y4_PT_14_weights = numpy.array([0.0,0.0,23.7674343961,14.6405087644,8.91044047609,6.15365179535,3.81934144307,4.45546262709,3.18444951776,2.33413519734,2.54683244708,2.54656408778,1.69643848455,1.27313920749,1.69562878973,1.27251332436,1.90997688198,1.48488940862,1.48360041832,1.27332388486,2.12264325597,1.27222159184,1.06087854659,0.849298883466,0.848617885682,1.06072993902,1.48590080575,0.423367953954,0.84894482233,1.69853428409,1.2726247079,1.27345777595,0.849662755587,0.211760964354,0.42432337076,1.06204951651,1.06050803762,1.27395034511,1.27262413078,1.06099195003,0.848647318637,0.637179039051,0.637099108379,0.635627172068,0.0,0.0,0.0,0.0,0.212437806897,0.212281033127,0.849012056433,0.0,0.0,0.0,0.212060776514,0.0,0.0,0.0,0.211908013706,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0])\n\n # Creating weights for histo: y4_PT_15\n y4_PT_15_weights = numpy.array([0.0,0.0,1.48145933214,1.02773175815,0.913812555037,0.230039122125,0.571482938632,0.341581832162,0.113137203039,0.0,0.343819689084,0.114071224206,0.114864836383,0.0,0.0,0.0,0.113137203039,0.0,0.0,0.0,0.0,0.0,0.0,0.343041057412,0.0,0.0,0.0,0.0,0.0,0.115905759849,0.0,0.114914830493,0.0,0.0,0.114337238966,0.0,0.34382775551,0.0,0.0,0.11422918432,0.0,0.114144619814,0.0,0.0,0.0,0.0,0.0,0.0,0.229372179422,0.114122193378,0.0,0.0,0.0,0.0,0.113795547464,0.228137395816,0.0,0.0,0.115905759849,0.113137203039,0.113449045733,0.0,0.115222152443,0.114071224206,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0])\n\n # Creating weights for histo: y4_PT_16\n y4_PT_16_weights = numpy.array([0.0,0.0,0.162605602178,0.121873470418,0.0947348178819,0.06764164162,0.0270516297151,0.0135876322733,0.027095275389,0.0541827144219,0.0,0.0135400366601,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0135152253822,0.0135469606033,0.0,0.0,0.0,0.0,0.0135727680281,0.0,0.0,0.0,0.0,0.0,0.0135492849462,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0135550741481,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0135469606033,0.0,0.0,0.0,0.0,0.0,0.0,0.0135469606033,0.0,0.0,0.0,0.0,0.0135469606033,0.0,0.0,0.0135414774639,0.0135377527405,0.0135002716282,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0])\n\n # Creating a new Canvas\n fig = plt.figure(figsize=(12,6),dpi=80)\n frame = gridspec.GridSpec(1,1,right=0.7)\n pad = fig.add_subplot(frame[0])\n\n # Creating a new Stack\n pad.hist(x=xData, bins=xBinning, weights=y4_PT_0_weights+y4_PT_1_weights+y4_PT_2_weights+y4_PT_3_weights+y4_PT_4_weights+y4_PT_5_weights+y4_PT_6_weights+y4_PT_7_weights+y4_PT_8_weights+y4_PT_9_weights+y4_PT_10_weights+y4_PT_11_weights+y4_PT_12_weights+y4_PT_13_weights+y4_PT_14_weights+y4_PT_15_weights+y4_PT_16_weights,\\\n label=\"$bg\\_dip\\_1600\\_inf$\", histtype=\"step\", rwidth=1.0,\\\n color=None, edgecolor=\"#e5e5e5\", linewidth=1, linestyle=\"solid\",\\\n bottom=None, cumulative=False, normed=False, align=\"mid\", orientation=\"vertical\")\n\n pad.hist(x=xData, bins=xBinning, weights=y4_PT_0_weights+y4_PT_1_weights+y4_PT_2_weights+y4_PT_3_weights+y4_PT_4_weights+y4_PT_5_weights+y4_PT_6_weights+y4_PT_7_weights+y4_PT_8_weights+y4_PT_9_weights+y4_PT_10_weights+y4_PT_11_weights+y4_PT_12_weights+y4_PT_13_weights+y4_PT_14_weights+y4_PT_15_weights,\\\n label=\"$bg\\_dip\\_1200\\_1600$\", histtype=\"step\", rwidth=1.0,\\\n color=None, edgecolor=\"#f2f2f2\", linewidth=1, linestyle=\"solid\",\\\n bottom=None, cumulative=False, normed=False, align=\"mid\", orientation=\"vertical\")\n\n pad.hist(x=xData, bins=xBinning, weights=y4_PT_0_weights+y4_PT_1_weights+y4_PT_2_weights+y4_PT_3_weights+y4_PT_4_weights+y4_PT_5_weights+y4_PT_6_weights+y4_PT_7_weights+y4_PT_8_weights+y4_PT_9_weights+y4_PT_10_weights+y4_PT_11_weights+y4_PT_12_weights+y4_PT_13_weights+y4_PT_14_weights,\\\n label=\"$bg\\_dip\\_800\\_1200$\", histtype=\"step\", rwidth=1.0,\\\n color=None, edgecolor=\"#ccc6aa\", linewidth=1, linestyle=\"solid\",\\\n bottom=None, cumulative=False, normed=False, align=\"mid\", orientation=\"vertical\")\n\n pad.hist(x=xData, bins=xBinning, weights=y4_PT_0_weights+y4_PT_1_weights+y4_PT_2_weights+y4_PT_3_weights+y4_PT_4_weights+y4_PT_5_weights+y4_PT_6_weights+y4_PT_7_weights+y4_PT_8_weights+y4_PT_9_weights+y4_PT_10_weights+y4_PT_11_weights+y4_PT_12_weights+y4_PT_13_weights,\\\n label=\"$bg\\_dip\\_600\\_800$\", histtype=\"step\", rwidth=1.0,\\\n color=None, edgecolor=\"#ccc6aa\", linewidth=1, linestyle=\"solid\",\\\n bottom=None, cumulative=False, normed=False, align=\"mid\", orientation=\"vertical\")\n\n pad.hist(x=xData, bins=xBinning, weights=y4_PT_0_weights+y4_PT_1_weights+y4_PT_2_weights+y4_PT_3_weights+y4_PT_4_weights+y4_PT_5_weights+y4_PT_6_weights+y4_PT_7_weights+y4_PT_8_weights+y4_PT_9_weights+y4_PT_10_weights+y4_PT_11_weights+y4_PT_12_weights,\\\n label=\"$bg\\_dip\\_400\\_600$\", histtype=\"step\", rwidth=1.0,\\\n color=None, edgecolor=\"#c1bfa8\", linewidth=1, linestyle=\"solid\",\\\n bottom=None, cumulative=False, normed=False, align=\"mid\", orientation=\"vertical\")\n\n pad.hist(x=xData, bins=xBinning, weights=y4_PT_0_weights+y4_PT_1_weights+y4_PT_2_weights+y4_PT_3_weights+y4_PT_4_weights+y4_PT_5_weights+y4_PT_6_weights+y4_PT_7_weights+y4_PT_8_weights+y4_PT_9_weights+y4_PT_10_weights+y4_PT_11_weights,\\\n label=\"$bg\\_dip\\_200\\_400$\", histtype=\"step\", rwidth=1.0,\\\n color=None, edgecolor=\"#bab5a3\", linewidth=1, linestyle=\"solid\",\\\n bottom=None, cumulative=False, normed=False, align=\"mid\", orientation=\"vertical\")\n\n pad.hist(x=xData, bins=xBinning, weights=y4_PT_0_weights+y4_PT_1_weights+y4_PT_2_weights+y4_PT_3_weights+y4_PT_4_weights+y4_PT_5_weights+y4_PT_6_weights+y4_PT_7_weights+y4_PT_8_weights+y4_PT_9_weights+y4_PT_10_weights,\\\n label=\"$bg\\_dip\\_100\\_200$\", histtype=\"step\", rwidth=1.0,\\\n color=None, edgecolor=\"#b2a596\", linewidth=1, linestyle=\"solid\",\\\n bottom=None, cumulative=False, normed=False, align=\"mid\", orientation=\"vertical\")\n\n pad.hist(x=xData, bins=xBinning, weights=y4_PT_0_weights+y4_PT_1_weights+y4_PT_2_weights+y4_PT_3_weights+y4_PT_4_weights+y4_PT_5_weights+y4_PT_6_weights+y4_PT_7_weights+y4_PT_8_weights+y4_PT_9_weights,\\\n label=\"$bg\\_dip\\_0\\_100$\", histtype=\"step\", rwidth=1.0,\\\n color=None, edgecolor=\"#b7a39b\", linewidth=1, linestyle=\"solid\",\\\n bottom=None, cumulative=False, normed=False, align=\"mid\", orientation=\"vertical\")\n\n pad.hist(x=xData, bins=xBinning, weights=y4_PT_0_weights+y4_PT_1_weights+y4_PT_2_weights+y4_PT_3_weights+y4_PT_4_weights+y4_PT_5_weights+y4_PT_6_weights+y4_PT_7_weights+y4_PT_8_weights,\\\n label=\"$bg\\_vbf\\_1600\\_inf$\", histtype=\"step\", rwidth=1.0,\\\n color=None, edgecolor=\"#ad998c\", linewidth=1, linestyle=\"solid\",\\\n bottom=None, cumulative=False, normed=False, align=\"mid\", orientation=\"vertical\")\n\n pad.hist(x=xData, bins=xBinning, weights=y4_PT_0_weights+y4_PT_1_weights+y4_PT_2_weights+y4_PT_3_weights+y4_PT_4_weights+y4_PT_5_weights+y4_PT_6_weights+y4_PT_7_weights,\\\n label=\"$bg\\_vbf\\_1200\\_1600$\", histtype=\"step\", rwidth=1.0,\\\n color=None, edgecolor=\"#9b8e82\", linewidth=1, linestyle=\"solid\",\\\n bottom=None, cumulative=False, normed=False, align=\"mid\", orientation=\"vertical\")\n\n pad.hist(x=xData, bins=xBinning, weights=y4_PT_0_weights+y4_PT_1_weights+y4_PT_2_weights+y4_PT_3_weights+y4_PT_4_weights+y4_PT_5_weights+y4_PT_6_weights,\\\n label=\"$bg\\_vbf\\_800\\_1200$\", histtype=\"step\", rwidth=1.0,\\\n color=None, edgecolor=\"#876656\", linewidth=1, linestyle=\"solid\",\\\n bottom=None, cumulative=False, normed=False, align=\"mid\", orientation=\"vertical\")\n\n pad.hist(x=xData, bins=xBinning, weights=y4_PT_0_weights+y4_PT_1_weights+y4_PT_2_weights+y4_PT_3_weights+y4_PT_4_weights+y4_PT_5_weights,\\\n label=\"$bg\\_vbf\\_600\\_800$\", histtype=\"step\", rwidth=1.0,\\\n color=None, edgecolor=\"#afcec6\", linewidth=1, linestyle=\"solid\",\\\n bottom=None, cumulative=False, normed=False, align=\"mid\", orientation=\"vertical\")\n\n pad.hist(x=xData, bins=xBinning, weights=y4_PT_0_weights+y4_PT_1_weights+y4_PT_2_weights+y4_PT_3_weights+y4_PT_4_weights,\\\n label=\"$bg\\_vbf\\_400\\_600$\", histtype=\"step\", rwidth=1.0,\\\n color=None, edgecolor=\"#84c1a3\", linewidth=1, linestyle=\"solid\",\\\n bottom=None, cumulative=False, normed=False, align=\"mid\", orientation=\"vertical\")\n\n pad.hist(x=xData, bins=xBinning, weights=y4_PT_0_weights+y4_PT_1_weights+y4_PT_2_weights+y4_PT_3_weights,\\\n label=\"$bg\\_vbf\\_200\\_400$\", histtype=\"step\", rwidth=1.0,\\\n color=None, edgecolor=\"#89a8a0\", linewidth=1, linestyle=\"solid\",\\\n bottom=None, cumulative=False, normed=False, align=\"mid\", orientation=\"vertical\")\n\n pad.hist(x=xData, bins=xBinning, weights=y4_PT_0_weights+y4_PT_1_weights+y4_PT_2_weights,\\\n label=\"$bg\\_vbf\\_100\\_200$\", histtype=\"step\", rwidth=1.0,\\\n color=None, edgecolor=\"#829e8c\", linewidth=1, linestyle=\"solid\",\\\n bottom=None, cumulative=False, normed=False, align=\"mid\", orientation=\"vertical\")\n\n pad.hist(x=xData, bins=xBinning, weights=y4_PT_0_weights+y4_PT_1_weights,\\\n label=\"$bg\\_vbf\\_0\\_100$\", histtype=\"step\", rwidth=1.0,\\\n color=None, edgecolor=\"#adbcc6\", linewidth=1, linestyle=\"solid\",\\\n bottom=None, cumulative=False, normed=False, align=\"mid\", orientation=\"vertical\")\n\n pad.hist(x=xData, bins=xBinning, weights=y4_PT_0_weights,\\\n label=\"$signal$\", histtype=\"step\", rwidth=1.0,\\\n color=None, edgecolor=\"#7a8e99\", linewidth=1, linestyle=\"solid\",\\\n bottom=None, cumulative=False, normed=False, align=\"mid\", orientation=\"vertical\")\n\n\n # Axis\n plt.rc('text',usetex=False)\n plt.xlabel(r\"p_{T} [ j_{2} ] ( GeV ) \",\\\n fontsize=16,color=\"black\")\n plt.ylabel(r\"$\\mathrm{Events}$ $(\\mathcal{L}_{\\mathrm{int}} = 3000.0\\ \\mathrm{fb}^{-1})$ \",\\\n fontsize=16,color=\"black\")\n\n # Boundary of y-axis\n ymax=(y4_PT_0_weights+y4_PT_1_weights+y4_PT_2_weights+y4_PT_3_weights+y4_PT_4_weights+y4_PT_5_weights+y4_PT_6_weights+y4_PT_7_weights+y4_PT_8_weights+y4_PT_9_weights+y4_PT_10_weights+y4_PT_11_weights+y4_PT_12_weights+y4_PT_13_weights+y4_PT_14_weights+y4_PT_15_weights+y4_PT_16_weights).max()*1.1\n #ymin=0 # linear scale\n ymin=min([x for x in (y4_PT_0_weights+y4_PT_1_weights+y4_PT_2_weights+y4_PT_3_weights+y4_PT_4_weights+y4_PT_5_weights+y4_PT_6_weights+y4_PT_7_weights+y4_PT_8_weights+y4_PT_9_weights+y4_PT_10_weights+y4_PT_11_weights+y4_PT_12_weights+y4_PT_13_weights+y4_PT_14_weights+y4_PT_15_weights+y4_PT_16_weights) if x])/100. # log scale\n plt.gca().set_ylim(ymin,ymax)\n\n # Log/Linear scale for X-axis\n plt.gca().set_xscale(\"linear\")\n #plt.gca().set_xscale(\"log\",nonposx=\"clip\")\n\n # Log/Linear scale for Y-axis\n #plt.gca().set_yscale(\"linear\")\n plt.gca().set_yscale(\"log\",nonposy=\"clip\")\n\n # Legend\n plt.legend(bbox_to_anchor=(1.05,1), loc=2, borderaxespad=0.)\n\n # Saving the image\n plt.savefig('../../HTML/MadAnalysis5job_0/selection_3.png')\n plt.savefig('../../PDF/MadAnalysis5job_0/selection_3.png')\n plt.savefig('../../DVI/MadAnalysis5job_0/selection_3.eps')\n\n# Running!\nif __name__ == '__main__':\n selection_3()\n", "meta": {"hexsha": "5d96b95cc1dd5d54e484e68c397cbc8f8669ff9f", "size": 24260, "ext": "py", "lang": "Python", "max_stars_repo_path": "optimization/second_sdEta_mjj_optimization/lumi_and_kin_plots/four_cuts_lum3000/Output/Histos/MadAnalysis5job_0/selection_3.py", "max_stars_repo_name": "sheride/axion_pheno", "max_stars_repo_head_hexsha": "7d3fc08f5ae5b17a3500eba19a2e43f87f076ce5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "optimization/second_sdEta_mjj_optimization/lumi_and_kin_plots/four_cuts_lum3000/Output/Histos/MadAnalysis5job_0/selection_3.py", "max_issues_repo_name": "sheride/axion_pheno", "max_issues_repo_head_hexsha": "7d3fc08f5ae5b17a3500eba19a2e43f87f076ce5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "optimization/second_sdEta_mjj_optimization/lumi_and_kin_plots/four_cuts_lum3000/Output/Histos/MadAnalysis5job_0/selection_3.py", "max_forks_repo_name": "sheride/axion_pheno", "max_forks_repo_head_hexsha": "7d3fc08f5ae5b17a3500eba19a2e43f87f076ce5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 125.0515463918, "max_line_length": 1326, "alphanum_fraction": 0.7228771641, "include": true, "reason": "import numpy", "num_tokens": 12289, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7217432182679957, "lm_q2_score": 0.27202455699569283, "lm_q1q2_score": 0.19633187921399717}} {"text": "import numpy as np\nimport scipy.constants as const\nfrom astropy.io import fits\nimport scipy.interpolate as si\nimport glob\nfrom ppxf import ppxf_util as P\nimport glob\nimport os\n\n\nclass Spectrum(object):\n \"\"\"\n\n UPDATE THE DOCSTRING! A stripped down version of specTools in order to package this all together nicely\n Original Author: Ryan Houghton (20/4/11)\n Updated: Sam Vaughan (Early 2018)\n\n Purpose: A spectrum object to aid manipulation of wavelength/frequency and the associated\n flux values\n\n Inputs:\n This class MUST be initalised with EITHER\n lamspec - a NLAMxNSPEC numpy array with [:,0] being the wavelength array (AA) and [:,1:] being\n the associated flux values (erg/s/cm**2/AA)\n muspec - a NLAMxNSPEC numpy array with [:,0] being the frequency array (GHz) and [:,1:] being\n the associated flux values (GJy = 1e-14 erg/s/cm**2/Hz)\n\n NOTE: 2xN seems a funny way to order the indicies but in numpy, this IS the efficient\n way to order the memory elements\n\n Definitions:\n Once you have initalised the class with either lamspec or muspec, you will find available\n the following variables (no matter if you initalised with lamspec or muspec):\n lam - the wavelength array (AA)\n flam - the associated flux (erg/s/cm**2/AA)\n mu - the frequency array (GHz)\n fmu - the associated flux (GJy = 1e-14 erg/s/cm**2/Hz)\n\n Functions:\n calcABmag - given a filter (spectrum class), return a magnitude on the AB system\n calcSTmag - as above but for the ST system\n calcVEGAmag- as above but for the VEGA system; you must also supply a vega *spectrum*\n\n Notes:\n - You can define more than one flam/fmu for each lam/mu\n - Filters used in the functions should also be *spectrum* classes\n - Filters don't need to be sorted in mu or lam\n \"\"\"\n\n global c, pc, d_sun\n\n def __init__(self, lam=None, lamspec=None, errlamspec=None, age=None, Z=None, wavesyst=None, userdict=None):\n\n \"\"\"\n Inputs:\n -------\n lam - the 1D array of wavelengths (becomes self.lam)\n lamspec - the (1D, 2D or 3D) array of fluxes on the specified lambda grid (becomes self.flam)\n errlamspec - standard deviation for pixels in lamspec (becomes self.eflam)\n age - the 1D array of ages (Gyr) for the spectra\n Z - the 1D array of metallicities for the spectra\n wavesyst - you MUST specify if the wavelengths are in the AIR or VAC system.\n userdict- add extra user-defined tags to the spectrum, such as airmass, water vapour etc.\n\n Notes:\n ------\n There are 3 ways to inialise a spectrum class:\n 1. With a 1D lam/mu and a 1D spectrum (single spec mode).\n - Magnitudes are returned as single values\n 2. With a 1D lam/mu and a 2D spectrum array (NSPECxN{LAM/MU}) (multispec mode)\n - In this case, you may specify AGE where len(age)=NSPEC.\n - Magnitudes are returned as 1D arrays with NSPEC=len(age) elements\n #3. With a 1D lam/mu and a 3D spectrum array (NZxNAGExN{LAM/MU}) (multispec mode)\n # - In this case, you can specify AGE and Z.\n # - Magnitudes will be returned as 2D arrays with NZxNAGE elements\n \"\"\"\n\n # start defining spectrum parts\n if lamspec is not None:\n # check that lam has been given\n if lam is None:\n raise Exception(\"If you give lamspec, you must also give lam\")\n\n # make sure 2d\n flam = np.atleast_2d(lamspec)\n # get array size\n loc = flam.shape\n\n # check for bigger arrays\n # if len(loc)> 2: raise \"lamspec not understood\"\n\n # get sizes\n nlam = loc[1]\n nspec = loc[0]\n\n self.lam = lam\n self.flam = np.atleast_2d(singleOrList2Array(flam))\n\n if errlamspec is not None:\n eflam = np.atleast_2d(errlamspec)\n eloc = eflam.shape\n self.eflam = eflam\n # sanity check\n assert np.all(loc == eloc), \"Flux and error arrays appear different sizes...\"\n else:\n self.eflam = None\n\n # add age info\n if age is not None:\n self.age = singleOrList2Array(age)\n\n checkDims(self.age, \"Age\", self.flam.shape[:-1])\n self.logage = np.log10(self.age)\n else:\n self.age = None\n\n # add metallicitiy\n if Z is not None:\n\n self.Z = singleOrList2Array(Z)\n checkDims(self.Z, \"Z\", self.flam.shape[:-1])\n else:\n self.Z = None\n\n # add VAC or AIR\n if wavesyst is not None:\n if (wavesyst == \"vac\" or wavesyst == \"VAC\" or wavesyst == \"Vac\"):\n self.wavesyst = \"vac\"\n elif (wavesyst == \"air\" or wavesyst == \"AIR\" or wavesyst == \"Air\"):\n self.wavesyst = \"air\"\n else:\n raise ValueError(\"wavesyst not understood. Should be air or vac.\")\n else:\n warn.warn(\"You failed to specify if the wavelength is defined in AIR or VAC units.\")\n self.wavesyst = None\n\n # add user dictionary for extra info\n if userdict is not None:\n self.__userdict__ = userdict\n keys = list(userdict.keys())\n for key in keys:\n setattr(self, key, singleOrList2Array(userdict[key]))\n else:\n self.__userdict__ = None\n\n\ndef checkDims(var, varname, parentShape):\n assert (np.isscalar(var)) or (np.all(np.equal(np.array(var).shape, parentShape))), varname + \" dimensions not understood.\"\n\n\ndef singleOrList2Array(invar):\n \"\"\"\n If a single value, leave. If a list, convert to array. If array, leave as array.\n But for size-1 arrays/lits, convert back to scalar.\n \"\"\"\n\n if isinstance(invar, list):\n # convert to array unless size-1\n rval = np.squeeze(np.array(invar))\n if rval.size == 1:\n rval = np.asscalar(rval)\n elif isinstance(invar, np.ndarray):\n # leave except if size-1\n rval = np.squeeze(invar)\n if rval.size == 1:\n rval = np.asscalar(rval)\n else:\n # leave\n rval = invar\n # return\n return rval\n\ndef load_varelem_CvD16ssps(varelem_template_location, imf='kroupa', verbose=True):\n\n '''\n Load the CvD16 spectra (response functions) with variable elemental abundances.\n\n Arguments:\n dirname (string): Base location of the stellar models directory\n folder (string): The folder inside the base directory which contains the response functions\n imf (string): The IMF of the response functions. Choices are 'kroupa' or 'salpeter'\n verbose (bool): Print information to the console\n Returns:\n (dict): A dictionary of spectra. See below for example\n\n Example:\n The spectra are returned in a dictionary. The dictionary is indexed by a string referring to the name of the respone function,\n e.g. 'Na+'. At each index, we have a Spectrum class which contains the response functions at various ages and metallicities\n\n >>> spectra=load_varelem_CvD16ssps(dirname='/path/to/dir', folder='folder', imf='kroupa')\n >>> spectra['Na+'] #Gives all RFs with [Na/H]=+0.3\n\n '''\n\n varelem_template_location = os.path.expanduser(varelem_template_location)\n\n if imf in ['kroupa', 'krpa', 'Kroupa', 'Krpa']:\n model_spectra = sorted(glob.glob('{}/atlas_ssp_*.krpa.s100'.format(varelem_template_location)))\n imf_name = 'krpa'\n elif imf in ['Salpeter', 'salpeter', 'salp', 'Salp']:\n model_spectra = sorted(glob.glob('{}/atlas_ssp_*.salp.s100'.format(varelem_template_location)))\n imf_name = 'salp'\n else:\n raise NameError('IMF type not understood')\n\n data = np.genfromtxt(model_spectra[0])\n lams = data[:, 0]\n\n model_Zs_names = ['m1.5', 'm1.0', 'm0.5', 'p0.0', 'p0.2']\n model_age_names = ['01', '03', '05', '09', '13']\n\n model_elem_order = ['Solar', 'Na+', 'Na-', 'Ca+', 'Ca-', 'Fe+', 'Fe-', 'C+', 'C-', 'a/Fe+', 'N+', 'N-', 'as/Fe+', 'Ti+', 'Ti-', 'Mg+', 'Mg-', 'Si+', 'Si-', 'T+', 'T-', 'Cr+', 'Mn+', 'Ba+', 'Ba-', 'Ni+', 'Co+', 'Eu+', 'Sr+', 'K+', 'V+', 'Cu+', 'Na+0.6', 'Na+0.9']\n\n Zs = [-1.5, -1.0, -0.5, 0.0, 0.2]\n ages = [float(a) for a in model_age_names]\n\n n_ages = len(model_age_names)\n n_zs = len(model_Zs_names)\n n_elems = len(model_elem_order)\n\n templates = np.empty((n_elems, n_ages, n_zs, len(lams)))\n\n for a, Z in enumerate(model_Zs_names):\n for b, age in enumerate(model_age_names):\n\n model = glob.glob('{}/atlas_ssp*t{}*{}*{}.s100'.format(varelem_template_location, age, Z, imf_name))[0]\n if verbose:\n print('Loading {}'.format(model))\n data = np.genfromtxt(model)\n\n for i, elem in enumerate(model_elem_order):\n templates[i, b, a, :] = data[:, i + 1]\n\n spectra = {}\n for i, elem in enumerate(model_elem_order):\n\n age_values = np.repeat(ages, n_zs).reshape(n_ages, n_zs)\n Z_values = np.repeat(Zs, n_ages).reshape(n_zs, n_ages).T\n\n spectra[elem] = Spectrum(lam=lams, lamspec=templates[i, :, :, :], age=age_values, Z=Z_values, wavesyst='vac', userdict={'elem': elem})\n\n return spectra\n\n\n################################################################################################################################################################\ndef prepare_CvD_interpolator_twopartIMF(base_template_location, templates_lam_range, velscale, verbose=True, instrumental_resolution=None):\n \"\"\"\n Set up the interpolator for the base SSP spectra using the log-rebinned templates we get from `prepare_CvD2_templates_twopartIMF`.\n\n Arguments:\n templates_lam_range (array-like): A 2 component vector with the start and stop wavelengths we want for the templates\n velscale (float): The velocity difference between two adjacent pixels in the log-rebinned spectrum. Use the same value\n for the templates as you *measure* from the spectrum!\n verbose (bool): Print information to the consolse\n\n Returns:\n (tuple): A two component tuple containing:\n * interp: the interpolate object. Axes are wavelength, age, Z, imf_x1 and imf_x2\n * logLam_template: the log-rebinned wavelength array of the templates\n \"\"\"\n templates, logLam_template = prepare_CvD2_templates_twopartIMF(base_template_location, templates_lam_range, velscale, verbose=verbose, instrumental_resolution=instrumental_resolution)\n\n nimfs = 16\n ages = [1., 3., 5., 7., 9., 11.0, 13.5]\n Zs = [-1.5, -1.0, -0.5, 0.0, 0.2]\n n_imfs = 16\n imfs_X1 = 0.5 + np.arange(n_imfs) / 5.0\n imfs_X2 = 0.5 + np.arange(n_imfs) / 5.0\n\n linear_interp = si.RegularGridInterpolator(((logLam_template, ages, Zs, imfs_X1, imfs_X2)), templates, bounds_error=False, fill_value=None)\n\n return linear_interp, logLam_template\n\n################################################################################################################################################################\n\ndef prepare_CvD2_templates_twopartIMF(template_location, templates_lam_range, velscale, verbose=True, instrumental_resolution=None):\n\n '''\n Load the CvD16 base spectra, those that vary age, [Z/H] and the IMF. The templates are log-rebinned to have a uniform wavelength\n spacing in **log** wavelength, to ensure the difference in velocity between two adjacent pixels is the same, regardless of wavelength. \n\n They are returned in an array of shape (n_ages, n_Zs, n_pixels).\n\n Arguments: \n templates_lam_range (array-like): A 2 component vector with the start and stop wavelengths we want for the templates\n velscale (float): The velocity difference between two adjacent pixels in the log-rebinned spectrum. Use the same value\n for the templates as you *measure* from the spectrum!\n verbose (bool): Print information to the consolse\n Returns:\n (tuple): A two component tuple:\n * templates (array): An array of templates with shape (N_wavelength, N_ages, N_metallicities, N_imf_x1, N_imf_x2)\n * logLam_template (array): The log-rebinned wavelength array of the templates\n '''\n \n template_glob=os.path.expanduser(f'{template_location}/VCJ_v8_mcut0.08_t*')\n\n vcj_models=sorted(glob.glob(template_glob))\n models=np.genfromtxt(vcj_models[-1])\n\n temp_lamdas=models[:, 0]\n\n n_ages=7\n n_zs=5\n n_imfs=16\n\n \n\n\n Zs=['m1.5', 'm1.0', 'm0.5', 'p0.0', 'p0.2']\n ages=['01.0', '03.0', '05.0', '07.0', '09.0', '11.0', '13.5']\n imfs_X1=0.5+np.arange(n_imfs)/5.0\n imfs_X2=0.5+np.arange(n_imfs)/5.0\n\n t_mask = ((temp_lamdas > templates_lam_range[0]) & (temp_lamdas 1:\n positive_only_interp=si.RegularGridInterpolator(((np.arange(len(positive_only_elems)), positive_only_elem_steps, ages, Zs, logLam_template)), positive_only_templates, bounds_error=False, fill_value=None, method='linear')\n else:\n positive_only_interp=si.RegularGridInterpolator((positive_only_elem_steps, ages, Zs, logLam_template), positive_only_templates[0, :], bounds_error=False, fill_value=None, method='linear')\n\n if len(normal_elems)>1:\n general_interp=si.RegularGridInterpolator(((np.arange(len(normal_elems)), elem_steps, ages, Zs, logLam_template)), general_templates, bounds_error=False, fill_value=None, method='linear')\n else:\n general_interp=si.RegularGridInterpolator((elem_steps, ages, Zs, logLam_template), general_templates[0, :], bounds_error=False, fill_value=None, method='linear')\n \n\n correction_interps=[general_interp, na_interp, carbon_interp, positive_only_interp, T_interp]\n\n return correction_interps, logLam_template\n\n##########\n\ndef new_wavelength_array_high_resolution(wavelengths):\n \"\"\"\n The templates have different spacings in wavelength between the blue and red ends. This function makes a new set of wavelength values which ensures the same wavelength spacing throughout \n \"\"\"\n\n new_wavelength_array = wavelengths[0]+0.9*(np.arange(np.ceil((wavelengths[-1]-wavelengths[0])/0.9))+1)\n\n return new_wavelength_array\n\ndef prepare_CvD2_element_templates(varelem_template_location, templates_lam_range, velscale, elements, verbose=True, element_imf='kroupa', instrumental_resolution=None):\n\n var_elem_spectra=load_varelem_CvD16ssps(varelem_template_location, imf=element_imf)\n\n ages=var_elem_spectra['Solar'].age[:, 0]\n Zs=var_elem_spectra['Solar'].Z[0, :]\n n_ages=len(ages)\n n_Zs=len(Zs)\n\n temp_lamdas=var_elem_spectra['Solar'].lam\n\n t_mask = ((temp_lamdas > templates_lam_range[0]) & (temp_lamdas 0.0:\n e='{}+'.format(elem)\n gen_step=step\n elif step<0.0:\n e='{}-'.format(elem)\n gen_step=np.abs(step)\n\n if step !=0.0:\n y=(var_elem_spectra[e].flam[c, d, t_mask]/var_elem_spectra['Solar'].flam[c, d, t_mask]-1)*((10**(gen_step)-1.0)/(10**(0.3)-1.0))\n else:\n y=np.zeros_like(var_elem_spectra['Solar'].flam[c, d, t_mask])\n\n x=var_elem_spectra[e].lam[t_mask]\n #Make a new lamda array, carrying on the delta lamdas of high resolution bit\n new_x=new_wavelength_array_high_resolution(x)\n interp=si.interp1d(x, y, fill_value='extrapolate')\n data=interp(new_x)\n\n #data=util.gaussian_filter1d(data, sigs/velscale)\n\n sspNew, logLam_template, template_velscale = P.log_rebin(templates_lam_range, data, velscale=velscale)\n if instrumental_resolution is not None:\n sspNew = P.gaussian_filter1d(sspNew, instrumental_resolution/velscale)\n\n general_templates[a, b, c, d, :]=sspNew\n\n # Make the Carbon templates \n # Treat Carbon differently because it's templates are at +0.15 and -0.15 dex rather than +0.3 and -0.3 dex\n print('Making the Carbon Correction template')\n for b, step in enumerate(C_elem_steps):\n for c, _ in enumerate(ages):\n for d, _ in enumerate(Zs):\n\n if step>0.0:\n e='{}+'.format(elem)\n gen_step=step\n elif step<0.0:\n e='{}-'.format(elem)\n gen_step=np.abs(step)\n\n if step !=0.0:\n y=(var_elem_spectra[e].flam[c, d, t_mask]/var_elem_spectra['Solar'].flam[c, d, t_mask]-1)*((10**(gen_step)-1.0)/(10**(0.15)-1.0))\n else:\n y=np.zeros_like(var_elem_spectra['Solar'].flam[c, d, t_mask])\n\n x=var_elem_spectra[e].lam[t_mask]\n #Make a new lamda array, carrying on the delta lamdas of high resolution bit\n new_x=new_wavelength_array_high_resolution(x)\n interp=si.interp1d(x, y, fill_value='extrapolate')\n data=interp(new_x)\n\n #data=util.gaussian_filter1d(data, sigs/velscale)\n\n sspNew, logLam_template, template_velscale = P.log_rebin(templates_lam_range, data, velscale=velscale)\n if instrumental_resolution is not None:\n sspNew = P.gaussian_filter1d(sspNew, instrumental_resolution/velscale)\n\n carbon_templates[b, c, d, :]=sspNew\n\n #Do the Na templates:\n print('Making the Na Correction template')\n for a, step in enumerate(Na_elem_steps):\n for b, _ in enumerate(ages):\n for c, _ in enumerate(Zs):\n\n if step <0.0:\n e='Na-'\n base_enhancement=0.3\n Na_step=np.abs(step) \n elif 0.0<=step<0.45:\n e='Na+'\n base_enhancement=0.3\n Na_step=step\n elif 0.45<=step<0.75:\n e='Na+0.6'\n base_enhancement=0.6\n Na_step=step\n elif 0.75<=step<1.0:\n e='Na+0.9'\n base_enhancement=0.9\n Na_step=step\n \n if step !=0.0:\n y=(var_elem_spectra[e].flam[b, c, t_mask]/var_elem_spectra['Solar'].flam[b, c, t_mask]-1)*((10**(Na_step)-1.0)/(10**(base_enhancement)-1.0))\n\n else:\n\n y=np.zeros_like(var_elem_spectra['Solar'].flam[b, c, t_mask])\n\n\n x=var_elem_spectra[e].lam[t_mask]\n #Make a new lamda array, carrying on the delta lamdas of high resolution bit\n new_x=new_wavelength_array_high_resolution(x)\n interp=si.interp1d(x, y, fill_value='extrapolate')\n data=interp(new_x)\n\n \n sspNew, logLam_template, template_velscale = P.log_rebin(templates_lam_range, data, velscale=velscale)\n if instrumental_resolution is not None:\n sspNew = P.gaussian_filter1d(sspNew, instrumental_resolution/velscale)\n\n na_templates[a, b, c, :]=sspNew\n\n\n print('Making the Temperature Correction template')\n for a, step in enumerate(T_steps):\n for b, _ in enumerate(ages):\n for c, _ in enumerate(Zs):\n\n if step>0.0:\n e='T+'\n T_step=step\n elif step<0.0:\n e='T-'\n T_step=np.abs(step)\n \n if step !=0.0:\n y=(var_elem_spectra[e].flam[b, c, t_mask]/var_elem_spectra['Solar'].flam[b, c, t_mask]-1)*(T_step/50.0)\n\n else:\n\n y=np.zeros_like(var_elem_spectra['Solar'].flam[b, c, t_mask])\n\n\n x=var_elem_spectra[e].lam[t_mask]\n #Make a new lamda array, carrying on the delta lamdas of high resolution bit\n new_x=new_wavelength_array_high_resolution(x)\n interp=si.interp1d(x, y, fill_value='extrapolate')\n data=interp(new_x)\n\n \n sspNew, logLam_template, template_velscale = P.log_rebin(templates_lam_range, data, velscale=velscale)\n if instrumental_resolution is not None:\n sspNew = P.gaussian_filter1d(sspNew, instrumental_resolution/velscale)\n\n T_templates[a, b, c, :]=sspNew\n\n return [general_templates, na_templates, carbon_templates, positive_only_templates, T_templates], logLam_template\n", "meta": {"hexsha": "40bf5e72cc69b007a85853b3816bb6d381f252af", "size": 29480, "ext": "py", "lang": "Python", "max_stars_repo_path": "pystaff/CvD_SSP_tools.py", "max_stars_repo_name": "WillCollier/PyStaff", "max_stars_repo_head_hexsha": "aa4d87738872f8168d6ed4c168c6b0be1cfa4846", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2018-06-01T01:44:59.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-08T09:03:24.000Z", "max_issues_repo_path": "pystaff/CvD_SSP_tools.py", "max_issues_repo_name": "WillCollier/PyStaff", "max_issues_repo_head_hexsha": "aa4d87738872f8168d6ed4c168c6b0be1cfa4846", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 9, "max_issues_repo_issues_event_min_datetime": "2018-05-25T15:44:43.000Z", "max_issues_repo_issues_event_max_datetime": "2020-08-24T01:40:49.000Z", "max_forks_repo_path": "pystaff/CvD_SSP_tools.py", "max_forks_repo_name": "WillCollier/PyStaff", "max_forks_repo_head_hexsha": "aa4d87738872f8168d6ed4c168c6b0be1cfa4846", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-08-10T10:15:51.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-24T08:38:35.000Z", "avg_line_length": 45.145482389, "max_line_length": 266, "alphanum_fraction": 0.6088873813, "include": true, "reason": "import numpy,import scipy,from astropy", "num_tokens": 7867, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5926665999540698, "lm_q2_score": 0.33111975283019596, "lm_q1q2_score": 0.1962436180875042}} {"text": "\"\"\"BLPose Train: Generator\n\nAuthor: Bo Lin (@linbo0518)\nDate: 2020-09-11\n\"\"\"\n\nimport json\nimport math\nimport numpy as np\n\n__all__ = [\"dict2json\", \"json2dict\", \"TargetGenerator\"]\n\n\ndef dict2json(dict_obj: dict, filename: str) -> None:\n with open(filename, \"w\") as f:\n json.dump(dict_obj, f, indent=2)\n\n\ndef json2dict(filename: str) -> dict:\n dict_obj: dict\n with open(filename, \"r\") as f:\n dict_obj = json.load(f)\n return dict_obj\n\n\ndef _gaussian_kernel(height, width, x, y, sigma=1.75):\n grid_y, grid_x = np.mgrid[0:height, 0:width]\n return np.exp(-((grid_x - x) ** 2 + (grid_y - y) ** 2) / (2.0 * sigma ** 2))\n\n\ndef _part_affinity_field(height, width, x1, y1, x2, y2, thickness=1):\n pafmap = np.zeros((2, height, width), dtype=np.float32)\n countmap = np.zeros_like(pafmap, dtype=np.uint)\n\n limb_vec_x = x2 - x1\n limb_vec_y = y2 - y1\n limb_len = math.sqrt(limb_vec_x ** 2 + limb_vec_y ** 2)\n\n if limb_len < 1e-7:\n return pafmap, countmap\n\n limb_unit_x = limb_vec_x / limb_len\n limb_unit_y = limb_vec_y / limb_len\n\n min_x = max(min(x1, x2) - thickness, 0)\n max_x = min(max(x1, x2) + thickness, width)\n min_y = max(min(y1, y2) - thickness, 0)\n max_y = min(max(y1, y2) + thickness, height)\n\n grid_y, grid_x = np.mgrid[min_y:max_y, min_x:max_x]\n x_12 = grid_x - x1\n y_12 = grid_y - y1\n\n limb_width = np.abs(x_12 * limb_unit_y - y_12 * limb_unit_x)\n limb_mask = limb_width < thickness\n\n pafmap[:, grid_y, grid_x] = np.repeat(\n limb_mask[np.newaxis, :, :], repeats=2, axis=0\n )\n pafmap[0, grid_y, grid_x] *= limb_unit_x\n pafmap[1, grid_y, grid_x] *= limb_unit_y\n\n limb_mask = (pafmap[0] != 0) | (pafmap[1] != 0)\n countmap[:, limb_mask] += 1\n return pafmap, countmap\n\n\nclass TargetGenerator:\n def __init__(\n self, n_keypoints, limbs, image_shape, stride, sigma=1.75, thickness=1\n ):\n self.n_keypoints = n_keypoints\n self.n_limbs = len(limbs)\n self.limbs = limbs\n height, width, _ = image_shape\n self.height = height // stride # or round\n self.width = width // stride # or round\n self.stride = stride\n self.sigma = sigma\n self.thickness = thickness\n\n def __call__(self, annotation):\n heatmap = np.zeros(\n (self.n_keypoints + 1, self.height, self.width), dtype=np.float32\n )\n pafmap = np.zeros((self.n_limbs * 2, self.height, self.width), dtype=np.float32)\n countmap = np.zeros_like(pafmap, dtype=np.uint)\n for keypoints in annotation:\n heat = self.gen_heatmap(keypoints)\n heatmap = np.maximum(heatmap, heat)\n\n paf, count = self.gen_pafmap(keypoints)\n pafmap += paf\n countmap += count\n\n countmap[countmap == 0] = 1\n pafmap /= countmap\n heatmap[-1] = 1.0 - np.max(heatmap[:-1], axis=0)\n return heatmap, pafmap\n\n def gen_heatmap(self, keypoints):\n heatmap = np.zeros(\n (self.n_keypoints + 1, self.height, self.width), dtype=np.float32\n )\n for idx, keypoint in enumerate(keypoints):\n x, y, v = keypoint\n if v == 0:\n continue\n x, y = round(x / self.stride), round(y / self.stride)\n\n heatmap[idx] = _gaussian_kernel(self.height, self.width, x, y, self.sigma)\n heatmap[idx][heatmap[idx] > 1.0] = 1\n heatmap[idx][heatmap[idx] < 0.01] = 0\n return heatmap\n\n def gen_pafmap(self, keypoints):\n pafmap = np.zeros((self.n_limbs * 2, self.height, self.width), dtype=np.float32)\n countmap = np.zeros_like(pafmap, dtype=np.uint)\n for idx, limb in zip(range(0, self.n_limbs * 2, 2), self.limbs):\n x1, y1, v1 = keypoints[limb[0]]\n x2, y2, v2 = keypoints[limb[1]]\n if v1 == 0 or v2 == 0:\n continue\n x1, y1 = round(x1 / self.stride), round(y1 / self.stride)\n x2, y2 = round(x2 / self.stride), round(y2 / self.stride)\n\n paf, count = _part_affinity_field(\n self.height, self.width, x1, y1, x2, y2, self.thickness\n )\n pafmap[idx : idx + 2] = paf\n countmap[idx : idx + 2] = count\n return pafmap, countmap\n", "meta": {"hexsha": "43a0ccbc68139bb3de6f4c19d9505a67054dd8bc", "size": 4283, "ext": "py", "lang": "Python", "max_stars_repo_path": "blpose/train/generator.py", "max_stars_repo_name": "linbo0518/BLPose", "max_stars_repo_head_hexsha": "c431a3d458cc6358cd59261776a292e59b5db8b0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "blpose/train/generator.py", "max_issues_repo_name": "linbo0518/BLPose", "max_issues_repo_head_hexsha": "c431a3d458cc6358cd59261776a292e59b5db8b0", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "blpose/train/generator.py", "max_forks_repo_name": "linbo0518/BLPose", "max_forks_repo_head_hexsha": "c431a3d458cc6358cd59261776a292e59b5db8b0", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.2030075188, "max_line_length": 88, "alphanum_fraction": 0.5851038991, "include": true, "reason": "import numpy", "num_tokens": 1313, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5926665855647395, "lm_q2_score": 0.33111974622959367, "lm_q1q2_score": 0.1962436094109563}} {"text": "\"\"\"A stochastic policy\"\"\"\n\nimport numpy as np\nimport tensorflow as tf\n\nfrom context import flags\nimport env_info\nfrom utils import build_mlp, trainable_vars\n\n\nclass StochasticPolicy:\n \"\"\"\n Provides tensorflow interface to sampling-with-density and acting\n according to it.\n \"\"\"\n\n def tf_sample_action_with_log_prob(self, obs_ns):\n \"\"\"Return a sample from the policy, along with its log probability.\"\"\"\n raise NotImplementedError # return sample, log prob\n\n def tf_greedy_action(self, obs_ns):\n \"\"\"Return a sample from the greedy version of the policy.\"\"\"\n raise NotImplementedError\n\n def act(self, obs_ns):\n \"\"\"Eager version of sampling an action\"\"\"\n raise NotImplementedError\n\n def greedy_act(self, obs_ns):\n \"\"\"Eager version of sampling a greedy action\"\"\"\n raise NotImplementedError\n\n def expectation(self, obs_ns, fn):\n \"\"\"\n Given a function fn : (acs_na, log pi(acs_na)) -> reals\n which maps a TF batch of actions and their likelihoods (taken according\n to this stochastic policy), this returns a tensor which, when\n differentiated wrt the policy parameters,\n gives an estimator for the gradient of E[fn(A)], where A follows\n this stochastic policy. The expectation is wrt the state distribution\n an empirical sample of which should be given as the obs_ns argument\n here.\n \"\"\"\n pass\n\n def tf_report(self, reporter, obs_ns):\n \"\"\"\n Update a TF reporter with various statistics according to the given\n sample of states.\n \"\"\"\n pass\n\n\nclass SquashedGaussianPolicy(StochasticPolicy):\n \"\"\"\n This stochastic policy implements a unimodal multivariate\n Gaussian distribution with a diagonal covariance, with the both the mean\n and covariance conditional on the state. This generates\n a latent distribution, which then is then clipped for stability\n and squashed into a compact [-1, 1] interval.\n \"\"\"\n\n def __init__(self, scope='sac/policy'):\n \"\"\"\n Generates a diagonal gaussian policy which keeps its log standard\n deviations between the lower and upper bounds provided as arguments.\n \"\"\"\n self._scope = scope\n self._obs_ph_ns = tf.placeholder(tf.float32, [None, env_info.ob_dim()])\n self._acs_na, _ = self.tf_sample_action_with_log_prob(self._obs_ph_ns)\n self._greedy_acs_na = self.tf_greedy_action(self._obs_ph_ns)\n self.variables = trainable_vars(self._scope)\n\n def _tf_mu_logstd(self, obs_ns):\n unclipped_mu_logstd_n2a = build_mlp(\n obs_ns, scope=self._scope,\n output_size=(env_info.ac_dim() * 2),\n n_layers=flags().sac.learner_depth,\n size=flags().sac.learner_width,\n activation=tf.nn.relu,\n reuse=tf.AUTO_REUSE)\n unclipped_mu_na = unclipped_mu_logstd_n2a[:, :env_info.ac_dim()]\n unclipped_logstd_na = unclipped_mu_logstd_n2a[:, env_info.ac_dim():]\n\n # What follows is black magic clipping for stability. These constants\n # are luckily not specific to any enviornment, since we are going to\n # squash outputs with tanh anyway. In turn, they're mostly determined\n # by the range of tanh and the machine accuracy of floats. However,\n # the logstd upper bound can be higher in this sense, but this was a\n # magic constant taken from Tuomas' code that I do not have the\n # confidence to mess with.\n #\n # TODO:\n # Consider adding a policy regularization term to encourage staying in\n # the active interval, e.g., add loss max(x - ub, 0) ** 2 or something.\n logstd_na = tf.clip_by_value(unclipped_logstd_na, -20, 2)\n mu_na = tf.clip_by_value(unclipped_mu_na, -5, 5)\n return mu_na, logstd_na\n\n @staticmethod\n def _tf_sample(mu_na, logstd_na):\n return tf.random_normal(tf.shape(mu_na)) * tf.exp(logstd_na) + mu_na\n\n @staticmethod\n def _tf_log_prob(x_na, mu_na, logstd_na):\n diffs_na = x_na - mu_na\n quadratic_n = tf.reduce_sum(\n (diffs_na * tf.exp(-logstd_na)) ** 2, axis=1)\n\n norm_factor_n = 2 * tf.reduce_sum(logstd_na, axis=1)\n norm_factor_n += tf.to_float(env_info.ac_dim()) * np.log(2 * np.pi)\n logprob_n = -0.5 * (quadratic_n + norm_factor_n)\n return logprob_n\n\n def tf_sample_action_with_log_prob(self, obs_ns):\n return self._tf_sample_action_with_log_prob(\n obs_ns, stop_gradient=True)\n\n def _tf_sample_action_with_log_prob(self, obs_ns, stop_gradient=True):\n # stop_gradient stops the contribution of the parameters to the\n # sampling directly.\n # when using the reparameterization trick, we *do* want the\n # Jacobian effect of the policy parameters on the sampling, so\n # we would have stop_gradient set to false. However for vanilla\n # policy gradient we don't want this on because it would not\n # correspond to performing a valid reinforce gradient estimation.\n\n # latent mean, logstd, and log prob\n mu_na, logstd_na = self._tf_mu_logstd(obs_ns)\n\n # stop the gradient for computing the sample log prob, the\n # parameters of the policy should only affect the log prob\n # gradient by their influence on the policy distribution.\n unbounded_sample_na = self._tf_sample(mu_na, logstd_na)\n if stop_gradient:\n unbounded_sample_na = tf.stop_gradient(unbounded_sample_na)\n\n unbounded_logprob_n = self._tf_log_prob(\n unbounded_sample_na, mu_na, logstd_na)\n # squash with tanh and scale\n logprob_n = self._scale_correction(\n unbounded_sample_na, unbounded_logprob_n)\n sample_na = self._scale(unbounded_sample_na)\n return sample_na, logprob_n\n\n def _scale(self, unbounded_acs_na):\n return tf.tanh(unbounded_acs_na)\n\n @staticmethod\n def _scale_correction(unbounded_acs_na, unbounded_log_prob_n):\n # chain rule to correct for density after modifications\n log_prob_n = unbounded_log_prob_n\n # original paper has 1-tanh**2, we use sech**2 for stability\n # log(sech**2) == 2 * (log 2 - log (e^x + e^-x))\n # == 2 * (log 2 - |x| - log (1 + e^(-2|x|)))\n abs_na = tf.abs(unbounded_acs_na)\n log_prob_n -= 2 * tf.reduce_sum(\n -1 * abs_na - tf.log1p(tf.exp(-2 * abs_na)) + np.log(2), axis=1)\n # scale to unit action\n log_prob_n -= np.log(0.5) * env_info.ac_dim()\n space = env_info.ac_space()\n # scale to box of action space\n log_prob_n -= np.sum(np.log(space.high - space.low))\n return log_prob_n\n\n def tf_greedy_action(self, obs_ns):\n mu_na, _ = self._tf_mu_logstd(obs_ns)\n return self._scale(mu_na)\n\n def act(self, obs_ns):\n return tf.get_default_session().run(self._acs_na, feed_dict={\n self._obs_ph_ns: obs_ns})\n\n def greedy_act(self, obs_ns):\n return tf.get_default_session().run(self._greedy_acs_na, feed_dict={\n self._obs_ph_ns: obs_ns})\n\n def tf_report(self, reporter, obs_ns):\n mu_na, logstd_na = self._tf_mu_logstd(obs_ns)\n reporter.stats('logstd', logstd_na)\n reporter.stats('abs(mu)', tf.abs(mu_na))\n acs_na, log_pi_n = self.tf_sample_action_with_log_prob(obs_ns)\n reporter.stats('log pi', log_pi_n)\n reporter.stats('abs(scaled sample acs)', tf.abs(acs_na))\n\n def expectation(self, obs_ns, fn):\n if flags().sac.reparameterization_trick:\n # for the reparameterization trick, we do not stop the gradient\n # when sampling from the latent distribution, intentionally.\n # This way we can use gradient information of fn to improve the\n # parameters\n onpol_act_na, log_prob_acs_n = (\n self._tf_sample_action_with_log_prob(\n obs_ns, stop_gradient=False))\n return tf.reduce_mean(fn(onpol_act_na, log_prob_acs_n))\n # else use the reinforce trick\n onpol_act_na, log_prob_acs_n = self._tf_sample_action_with_log_prob(\n obs_ns, stop_gradient=True)\n return tf.reduce_mean(\n log_prob_acs_n * tf.stop_gradient(\n fn(onpol_act_na, log_prob_acs_n)))\n", "meta": {"hexsha": "c1b106bf30192ecff12ad2889cfa601de59eaec5", "size": 8361, "ext": "py", "lang": "Python", "max_stars_repo_path": "mve/sac/stochastic_policy.py", "max_stars_repo_name": "vlad17/mve", "max_stars_repo_head_hexsha": "19835bba87a2e5abc9bca653d011bf2eed68dd62", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 9, "max_stars_repo_stars_event_min_datetime": "2019-11-27T07:15:23.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-19T08:23:40.000Z", "max_issues_repo_path": "mve/sac/stochastic_policy.py", "max_issues_repo_name": "vlad17/mve", "max_issues_repo_head_hexsha": "19835bba87a2e5abc9bca653d011bf2eed68dd62", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "mve/sac/stochastic_policy.py", "max_forks_repo_name": "vlad17/mve", "max_forks_repo_head_hexsha": "19835bba87a2e5abc9bca653d011bf2eed68dd62", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.3910891089, "max_line_length": 79, "alphanum_fraction": 0.6592512857, "include": true, "reason": "import numpy", "num_tokens": 1998, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5926665855647394, "lm_q2_score": 0.3311197462295937, "lm_q1q2_score": 0.1962436094109563}} {"text": "#!/usr/bin/env python\n\n\"\"\"Convert astronomical positions between various coordinate systems.\n\nThe CnvObj code is getting ugly enough (I had to add ICRS<->ICRS2000 cases\nto handle the proper motion) that I'm wondering if it wouldn't be better\nto just hand code the converter as I did in the TCC. I hate all those\nif/then/else statements but it's probably more obvious what's going on\nthen this mess of magic stuff.\n\nI could also hand code all apparent->ICRS2000 and back routines\nand then ditch the entire catalog of methods. That might be cleanest.\n\nHistory:\n2002-08-07 ROwen Beta release. Not yet well tested and I hope to clean up the code somewhat.\n2002-08-23 ROwen Renamed from Convert; added coordConv method and stopped exporting CnvObj\n (I'm giving up on CnvObj being useful for now, but may revive it later).\n Added velocity handling and default date handling. Still beta; still not well tested.\n2002-12-23 ROwen Bug fix: was not importing ICRSFromFK4 (thanks to pychecker);\n Reorganized the code that computates method dictionaries to make it clearer;\n Reduced the number of globals and made them self-hiding (initial underscore).\n2003-05-28 ROwen Modified to handle opscore.RO.CoordSys 2003-05-09 (defaultDate->currDefaultDate).\n2005-01-21 ROwen Bug fix: was miscomputing proper motion, due to using ICRS\n instead of ICRS2000 as the intermediate coordinate system.\n2005-04-26 ROwen Bug fix: conversions requiring a App Topo<->Observed step were broken\n (thanks to Emmanouil Angelakis for the report).\n2007-04-24 ROwen Converted from Numeric to numpy.\n2015-09-24 ROwen Replace \"== None\" with \"is None\" to modernize the code.\n\"\"\"\n__all__ = [\"coordConv\"]\n\nimport numpy\nimport opscore.RO.CoordSys\nfrom opscore.RO.Astro import Tm\nfrom .AppGeoData import AppGeoData\nfrom .FK4FromICRS import fk4FromICRS\nfrom .FK5Prec import fk5Prec\nfrom .GalFromICRS import galFromICRS\nfrom .GeoFromICRS import geoFromICRS\nfrom .GeoFromTopo import geoFromTopo\nfrom .ICRSFromFK4 import icrsFromFK4\nfrom .ICRSFromFixedFK4 import icrsFromFixedFK4\nfrom .ICRSFromGal import icrsFromGal\nfrom .ICRSFromGeo import icrsFromGeo\nfrom .ObsFromTopo import obsFromTopo\nfrom .TopoFromGeo import topoFromGeo\nfrom .TopoFromObs import topoFromObs\n\n_CSysList = (opscore.RO.CoordSys.ICRS, opscore.RO.CoordSys.FK5, opscore.RO.CoordSys.FK4, opscore.RO.CoordSys.Galactic,\n opscore.RO.CoordSys.Geocentric, opscore.RO.CoordSys.Topocentric, opscore.RO.CoordSys.Observed,\n \"ICRS2000\")\n\nclass _CnvObj (object):\n \"\"\"\n An object that can convert between coordinate systems. To use,\n create one of these objects and then call its \"coordConv\" method.\n\n This code is a slightly awkward mix of functional and object-oriented programming.\n Some data is stored as instance variables purely for ease of passing to functions,\n but at present the caching serves no other purpose. In the future I hope to figure out an\n interface whereby the user can save some data and repeatedly ask for conversions.\n For instance one could create an object and then repeatedly ask for its current\n observed position. Then CnvObj would start to feel more like a normal object.\n\n Also, the method dictionary really should be saved as a class variable, but these\n are relatively new to Python and clumsy, and I'm not yet sure I want to bother\n (especially as it makes the code incompatible with older versions of Python).\n \"\"\"\n ZeroV = (0.0, 0.0, 0.0)\n\n def __init__(self):\n # Compute self.methDictDict, a dictionary of _CnvObj method dictionaries\n # to convert between any two coordinate systems:\n # - key: the \"from\" coordinate system\n # - value: the method dictionary to use if starting from that coordinate system:\n # - key: a \"to\" coordinate system\n # - value: a tuple consisting of:\n # - the _CnvObj method to convert to \"to\" from \"from\" coordinate system\n # - the \"from\" coordinate system\n # Each method dictionary gives a chain of methods that stretches from a given\n # starting \"from\" coordinate system to all other coordinate systems\n\n def addMethods(methDict, fromSys):\n \"\"\"Recursively add all methods to a method dictionary\n starting from a given \"from\" coordinate system.\n\n For the first call, set methDict = {}\n\n Inputs:\n - methDict: the method dictionary\n - a \"from\" coordinate system\n \"\"\"\n # if first execution, set entry for \"from\" = \"to\":\n if methDict == {}:\n methDict[fromSys] = (None, None)\n\n # add an entry for each \"to\" coordinate system\n for toSys in _CSysList:\n if toSys == fromSys:\n continue\n if toSys in methDict:\n continue\n funcName = \"%sFrom%s\" % (toSys, fromSys)\n if hasattr(_CnvObj, funcName):\n methDict[toSys] = (getattr(_CnvObj, funcName), fromSys)\n #print \"methDict[%s] = %r\" % (toSys, methDict[toSys])\n addMethods(methDict, toSys)\n\n # pre-compute conversion dictionaries for every possible starting coordinate system\n # (which so far includes all in opscore.RO.CoordSys except Physical and Mount)\n methDictDict = {}\n for _whatGiven in _CSysList:\n # define method dictionary for coordsys _whatGiven given\n methDict = {}\n addMethods(methDict, _whatGiven)\n assert len(methDict) == len(_CSysList), \"incomplete function list; check your conversion functions\"\n methDictDict[_whatGiven] = methDict\n #print \"methDictDict[%s] = %r\" % (_whatGiven, methDictDict[_whatGiven])\n\n self.methDictDict = methDictDict\n\n def coordConv(self, fromP, fromV, fromSys, fromDate, toSys, toDate, obsData=None, refCo=None):\n \"\"\"Converts a position from one coordinate system to another.\n See notes for the coordConv function below.\n \"\"\"\n # handle default dates\n if fromDate is None:\n fromDate = opscore.RO.CoordSys.getSysConst(fromSys).currDefaultDate()\n if toDate is None:\n toDate = opscore.RO.CoordSys.getSysConst(toSys).currDefaultDate()\n\n self.fromDate = fromDate\n self.toDate = toDate\n self.obsData = obsData\n if refCo:\n self.refCo = refCo[:]\n else:\n refCo = None\n\n # convert to ICRS from fromSys\n icrsP, icrsV = self._getItem(\"ICRS2000\", self.methDictDict[fromSys], fromP, fromV)\n #print \"Cnv.coordConv: icrsP=%s, icrsV=%s\" % (icrsP, icrsV)\n\n # convert to toSys from ICRS\n toP, toV = self._getItem(toSys, self.methDictDict[\"ICRS2000\"], icrsP, icrsV)\n #print \"Cnv.coordConv: toP=%s, toV=%s\" % (toP, toV)\n return (toP, toV)\n\n def _getItem(self, csys, methDict, initP, initV):\n \"\"\"Internal routine that returns the position initP and velocity initV\n converted to the requested coordinate system.\n\n To perform a full conversion, first convert fromP, fromV, fromSys, fromDate to ICRS\n and then convert ICRS to toP, toV, toSys, toDate.\n\n Before calling, set self.fromDate, self.toDate, self.obsData and self.refCo.\n\n Inputs:\n - csys desired coordinate system\n - methDict _MethodDict[initSys], where initSys is the initial coordinate system\n (a dictionary of unbound coordinate conversion methods)\n - initP position in initSys\n - initV velocity in initSys\n \"\"\"\n #print \"Cnv._CnvObj._getItem: csys=%s; fromP=%s; fromV=%s\" % (csys, initP, initV)\n func, nextSys = methDict[csys]\n #print \"Cnv._CnvObj._getItem: nextSys=%s; func=%s\" % (nextSys, func)\n if func:\n toP, toV = func(self, *self._getItem(nextSys, methDict, initP, initV))\n #print \"Cnv._CnvObj._getItem: toP=%s, toV=%s\" % (toP, toV)\n return (toP, toV)\n else:\n #print \"Cnv._CnvObj._getItem: null conversion; toP, V = fromP, V\"\n return (initP, initV)\n\n # conversion functions\n def ICRSFromICRS2000(self, fromP, fromV):\n return (fromP + (numpy.asarray(fromV, dtype=float) * (self.toDate - 2000.0)), fromV)\n\n def ICRS2000FromICRS(self, fromP, fromV):\n return (fromP + (numpy.asarray(fromV, dtype=float) * (2000.0 - self.fromDate)), fromV)\n\n def FK5FromICRS2000(self, fromP, fromV):\n return fk5Prec(fromP, fromV, 2000.0, self.toDate)\n\n def ICRS2000FromFK5(self, fromP, fromV):\n return fk5Prec(fromP, fromV, self.fromDate, 2000.0)\n\n def FK4FromICRS2000(self, fromP, fromV):\n return fk4FromICRS (fromP, fromV, self.toDate)\n\n def ICRS2000FromFK4(self, fromP, fromV):\n if tuple(fromV) == (0.0, 0.0, 0.0):\n return (icrsFromFixedFK4 (fromP, self.fromDate), _CnvObj.ZeroV)\n else:\n return icrsFromFK4(fromP, fromV, self.fromDate)\n\n def GalacticFromICRS2000(self, fromP, fromV):\n return galFromICRS (fromP, fromV, self.toDate)\n\n def ICRS2000FromGalactic(self, fromP, fromV):\n return icrsFromGal(fromP, fromV, self.fromDate)\n\n def GeocentricFromICRS2000(self, fromP, fromV):\n agData = AppGeoData(Tm.epJFromMJD(self.toDate))\n return (geoFromICRS(fromP, fromV, agData), _CnvObj.ZeroV)\n\n def ICRS2000FromGeocentric(self, fromP, dumV):\n agData = AppGeoData(Tm.epJFromMJD(self.fromDate))\n return (icrsFromGeo(fromP, agData), _CnvObj.ZeroV)\n\n def TopocentricFromGeocentric(self, fromP, dumV):\n if self.obsData is None:\n raise ValueError(\"must specify obsData to cnvert to Topocentric from Geocentric\")\n return (\n topoFromGeo(fromP, Tm.lastFromUT1(self.toDate, self.obsData.longitude), self.obsData),\n _CnvObj.ZeroV,\n )\n\n def GeocentricFromTopocentric(self, fromP, dumV):\n if self.obsData is None:\n raise ValueError(\"must specify obsData to convert to Geocentric from Topocentric\")\n return (\n geoFromTopo(fromP, Tm.lastFromUT1(self.fromDate, self.obsData.longitude), self.obsData),\n _CnvObj.ZeroV,\n )\n\n def ObservedFromTopocentric(self, fromP, dumV):\n if self.refCo is None:\n raise ValueError(\"must specify refCo to convert to Observed from Topocentric\")\n pos, tooLow = obsFromTopo(fromP, self.refCo)\n return (pos, _CnvObj.ZeroV)\n\n def TopocentricFromObserved(self, fromP, dumV):\n if self.refCo is None:\n raise ValueError(\"must specify refCo to convert to Topocentric from Observed\")\n pos, tooLow = topoFromObs(fromP, self.refCo)\n return (pos, _CnvObj.ZeroV)\n\n# create a singleton _CnvObj for the coordConv method to use\n_TheCnvObj = _CnvObj()\n\n# this is the only public function defined in this file\ndef coordConv(fromP, fromV, fromSys, fromDate, toSys, toDate, obsData=None, refCo=None):\n \"\"\"Converts a position from one coordinate system to another.\n\n Inputs:\n - fromP(3) cartesian position (au)\n - fromV(3) cartesian velocity (au/year); ignored if fromSys\n is Geocentric, Topocentric or Observed\n - fromSys coordinate system from which to convert;\n any of the entries in the table below; use opscore.RO.CoordSys constants.\n - fromDate date*\n - toSys coordinate system to which to convert (see fromSys)\n - toDate date*\n - obsData an opscore.RO.Astro.Cnv.ObserverData object; required if fromSys or toSys\n is Topocentric or Observed; ignored otherwise.\n - refCo(2) refraction coefficients; required if fromSys or toSys is Observed;\n ignored otherwise.\n\n Returns:\n - toP(3) converted cartesian position (au)\n - toV(3) converted cartesian velocity (au/year)\n\n *the units of date depend on the associated coordinate system:\n coord sys def date date\n ICRS 2000.0 Julian epoch of observation\n FK5 2000.0 Julian epoch of equinox and observation\n FK4 1950.0 Besselian epoch of equinox and observation\n Galactic now Julian epoch of observation\n Geocentric now UT1 (MJD)\n Topocentric now UT1 (MJD)\n Observed now UT1 (MJD)\n\n **Setting fromV all zero means the object is fixed. This slighly affects\n conversion to or from FK4, which has fictitious proper motion.\n\n Error Conditions:\n - If obsData or refCo are absent and are required, raises ValueError.\n\n Details:\n The conversion is performed in two stages:\n - fromP/fromSys/fromDate -> ICRS\n - ICRS -> toP/toSys/toDate\n\n Each of these two stages is performed using the following graph:\n\n FK5 ------\\\n FK4 ------ ICRS --- Geocentric -*- Topocentric -**- Observed\n Galactic--/\n\n * obsData required\n ** refCo required\n \"\"\"\n return _TheCnvObj.coordConv(fromP, fromV, fromSys, fromDate, toSys, toDate, obsData, refCo)\n", "meta": {"hexsha": "d1ac8fa0eaedc6eba44fbcf1817037a8d8184525", "size": 13281, "ext": "py", "lang": "Python", "max_stars_repo_path": "python/opscore/RO/Astro/Cnv/CoordConv.py", "max_stars_repo_name": "sdss/opscore", "max_stars_repo_head_hexsha": "dd4f2b2ad525fe3dfe3565463de2c079a7e1232e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "python/opscore/RO/Astro/Cnv/CoordConv.py", "max_issues_repo_name": "sdss/opscore", "max_issues_repo_head_hexsha": "dd4f2b2ad525fe3dfe3565463de2c079a7e1232e", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-08-17T21:08:14.000Z", "max_issues_repo_issues_event_max_datetime": "2021-08-17T21:08:14.000Z", "max_forks_repo_path": "python/opscore/RO/Astro/Cnv/CoordConv.py", "max_forks_repo_name": "sdss/opscore", "max_forks_repo_head_hexsha": "dd4f2b2ad525fe3dfe3565463de2c079a7e1232e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.8682432432, "max_line_length": 118, "alphanum_fraction": 0.6598900685, "include": true, "reason": "import numpy", "num_tokens": 3509, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.5926666143433998, "lm_q2_score": 0.33111972642778714, "lm_q1q2_score": 0.1962436072042694}} {"text": "# -*- coding: utf-8 -*-\n\"\"\"\nFile bounding_box.py\n@author:ZhengYuwei\n\"\"\"\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\n\n\nclass BoundingBox(object):\n \"\"\" 定义BoundingBox类，描述bounding box的坐标及预定义一些操作 \"\"\"\n \n def __init__(self, w, h):\n \"\"\" box参数初始化\n :param w: box的宽\n :param h: box的高\n \"\"\"\n self.w = w\n self.h = h\n self.area = w * h\n \n @staticmethod\n def distance(box, boxes):\n \"\"\"\n 计算一个box与一列表boxes的 1 - IoUs 的静态方法 （作为距离）\n :param box: box对象\n :param boxes：box对象列表\n :return box对象与box对象列表中每一个元素的 1-IOU\n \"\"\"\n boxes_w, boxes_h, boxes_area = map(np.array, zip(*[(box.w, box.h, box.area) for box in boxes]))\n intersections = np.minimum(box.w, boxes_w) * np.minimum(box.h, boxes_h)\n dist_iou = 1 - intersections / (box.area + boxes_area - intersections)\n return dist_iou\n \n @staticmethod\n def mean(boxes):\n \"\"\"\n 计算一个box对象列表的均值中心点\n :param boxes: box对象列表\n :return box对象列表的均值中心点box对象\n \"\"\"\n boxes_w, boxes_h = map(np.array, zip(*[(box.w, box.h) for box in boxes]))\n return BoundingBox(boxes_w.mean(), boxes_h.mean())\n \n @staticmethod\n def plot(centroids, boxes, group, name='GT bounding prediction cluster'):\n \"\"\"\n 绘制boxes散点图：聚类中心点为黑色，其他每一类一种颜色\n :param centroids: 各个group中心点\n :param boxes: boxes列表\n :param group: boxes对应的归属的中心点\n :param name: 散点图名称\n :return:\n \"\"\"\n col = ['silver', 'red', 'peru', 'yellow', 'green', 'cyan', 'blue', 'fuchsia', 'pink', 'black']\n # 中心点和boxes的 width 和 height 解析\n center_w, center_h = map(np.array, zip(*[(box.w, box.h) for box in centroids]))\n center_colors = col[:len(centroids)] # 'k'\n boxes_w, boxes_h = map(np.array, zip(*[(box.w, box.h) for box in boxes]))\n boxes_colors = [col[i] for i in group]\n # 绘制散点图\n plt.grid(ls='--')\n plt.scatter(boxes_w, boxes_h, c=boxes_colors, s=36, alpha=0.3)\n plt.scatter(center_w, center_h, c=center_colors, marker='p', s=48, alpha=1)\n shift = np.max(center_h) * 0.1\n for box in centroids:\n plt.text(box.w, box.h - shift, '({:.3f}, {:.3f})'.format(box.w, box.h))\n plt.title(name)\n plt.xlabel('Width')\n plt.ylabel('Height')\n plt.show()\n \n @staticmethod\n def plot3D(centroids, boxes, group, cls_names, name='GT bounding prediction cluster'):\n \"\"\"\n 绘制boxes的3维散点图\n :param centroids: 各个group中心点\n :param boxes: boxes列表\n :param group: boxes对应的归属的中心点\n :param cls_names: 物体类别名称\n :param name: 散点图名称\n :return:\n \"\"\"\n fig = plt.figure()\n ax = Axes3D(fig)\n col = ['black', 'silver', 'red', 'peru', 'yellow', 'green', 'cyan', 'blue', 'fuchsia', 'pink']\n # 中心点和boxes的 width 和 height 解析\n center_w, center_h = map(np.array, zip(*[(box.w, box.h) for box in centroids]))\n center_colors = 'k' # col[:len(centroids)]\n boxes_w, boxes_h = map(np.array, zip(*[(box.w, box.h) for box in boxes]))\n boxes_colors = [col[i] for i in group]\n # 绘制散点图\n plt.grid(ls='--')\n ax.scatter(boxes_w, boxes_h, [0] * len(boxes_h), c=boxes_colors, alpha=0.3)\n ax.scatter(center_w, center_h, [0] * len(center_w), c=center_colors, marker='p', s=48, alpha=1)\n for index, cls_name in enumerate(cls_names):\n cls_indices = np.where([name == cls_name for name in cls_names])[0]\n ax.scatter(boxes_w[cls_indices], boxes_h[cls_indices], [(index + 1) * 10] * len(cls_indices),\n c=[boxes_colors[i] for i in cls_indices], alpha=0.3)\n ax.scatter(center_w, center_h, [(index + 1) * 10] * len(center_w),\n c=center_colors, marker='p', s=48, alpha=1)\n plt.title(name)\n ax.set_xlabel('Width')\n ax.set_ylabel('Height')\n ax.set_zlabel('Classes')\n ax.set_zlim(0, 10 * len(cls_names) + 10)\n plt.savefig(\"scatter3D.png\")\n plt.show()\n \n @staticmethod\n def plot_pareto(centroids, boxes, group, title='IOU-Ratio Curve'):\n \"\"\"\n 绘制 IOU-probability曲线\n :param centroids: 聚类中心\n :param boxes: box列表\n :param group: boxes对应的归属的中心点\n :param title: 标题\n :return:\n \"\"\"\n plt.grid(ls='--')\n plt.title('{} Pareto'.format(title))\n col = ['black', 'silver', 'red', 'peru', 'yellow', 'green', 'cyan', 'blue', 'fuchsia', 'pink']\n for i, box in enumerate(centroids):\n pos = np.where(group == i)[0]\n x = 1 - np.sort(BoundingBox.distance(box, [boxes[j] for j in pos])) # 因为距离是 1 - IOU\n y = np.arange(len(x)) / len(x)\n plt.plot(x, y, color=col[i], label='cluster {}'.format(i))\n \n plt.legend()\n plt.xlabel('IoU')\n plt.ylabel('Sample ratio')\n plt.show()\n", "meta": {"hexsha": "462e46fdc32cc429cb821e92a1cbd1bbd5b73644", "size": 4993, "ext": "py", "lang": "Python", "max_stars_repo_path": "utils/anchors/bounding_box.py", "max_stars_repo_name": "zheng-yuwei/YOLOv2-tensorflow", "max_stars_repo_head_hexsha": "28da5dac1754da3f164c64352b233327b20248ac", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2019-11-08T06:43:58.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-23T02:05:54.000Z", "max_issues_repo_path": "utils/anchors/bounding_box.py", "max_issues_repo_name": "zheng-yuwei/YOLOv2-tensorflow", "max_issues_repo_head_hexsha": "28da5dac1754da3f164c64352b233327b20248ac", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2019-12-18T13:18:24.000Z", "max_issues_repo_issues_event_max_datetime": "2020-05-19T02:07:39.000Z", "max_forks_repo_path": "utils/anchors/bounding_box.py", "max_forks_repo_name": "zheng-yuwei/YOLOv2-tensorflow", "max_forks_repo_head_hexsha": "28da5dac1754da3f164c64352b233327b20248ac", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.2611940299, "max_line_length": 105, "alphanum_fraction": 0.5597836972, "include": true, "reason": "import numpy", "num_tokens": 1535, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5350984286266115, "lm_q2_score": 0.36658972248186006, "lm_q1q2_score": 0.19616158445070891}} {"text": "# -*- coding: utf-8 -*-\n\n\"\"\"\nThis module does calculations compliant to ISO 3382-1 in order to obtain room\nacoustic paramters.\n\nIt has an implementation of Lundeby et al. [1] algorithm to estimate the\ncorrection factor for the cumulative integral, as suggested by the ISO 3382-1.\n\n\"\"\"\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom numba import njit\nfrom pytta import SignalObj, OctFilter, Analysis, ImpulsiveResponse\nfrom pytta.utils import fractional_octave_frequencies as FOF\nimport traceback\nimport copy as cp\n\n\ndef _filter(signal,\n order: int = 4,\n nthOct: int = 3,\n minFreq: float = 20,\n maxFreq: float = 20000,\n refFreq: float = 1000,\n base: int = 10):\n of = OctFilter(order=order,\n nthOct=nthOct,\n samplingRate=signal.samplingRate,\n minFreq=minFreq,\n maxFreq=maxFreq,\n refFreq=refFreq,\n base=base)\n result = of.filter(signal)\n return result[0]\n\n\n@njit\ndef _level_profile(timeSignal, samplingRate,\n numSamples, numChannels, blockSamples=None):\n \"\"\"\n Gets h(t) in octave bands and do the local time averaging in nblocks.\n Returns h^2_averaged(block).\n \"\"\"\n def mean_squared(x):\n return np.mean(x**2)\n\n if blockSamples is None:\n blockSamples = 100\n nblocks = int(numSamples // blockSamples)\n profile = np.zeros((nblocks, numChannels), dtype=np.float32)\n timeStamp = np.zeros((nblocks, 1))\n\n for ch in range(numChannels):\n # if numChannels == 1:\n # tmp = timeSignal\n # else:\n tmp = timeSignal[:, ch]\n for idx in range(nblocks):\n profile[idx, ch] = mean_squared(tmp[:blockSamples])\n timeStamp[idx, 0] = idx*blockSamples/samplingRate\n tmp = tmp[blockSamples:]\n return profile, timeStamp\n\n\n@njit\ndef _start_sample_ISO3382(timeSignal, threshold) -> np.ndarray:\n squaredIR = timeSignal**2\n # assume the last 10% of the IR is noise, and calculate its noise level\n last10Idx = -int(len(squaredIR)//10)\n noiseLevel = np.mean(squaredIR[last10Idx:])\n # get the maximum of the signal, that is the assumed IR peak\n max_val = np.max(squaredIR)\n max_idx = np.argmax(squaredIR)\n # check if the SNR is enough to assume that the signal is an IR. If not,\n # the signal is probably not an IR, so it starts at sample 1\n idxNoShift = np.asarray([max_val < 100*noiseLevel or\n max_idx > int(0.9*squaredIR.shape[0])])\n # less than 20dB SNR or in the \"noisy\" part\n if idxNoShift.any():\n print(\"noiseLevelCheck: The SNR too bad or this is not an \" +\n \"impulse response.\")\n return 0\n # find the first sample that lies under the given threshold\n threshold = abs(threshold)\n startSample = 1\n# # TODO - envelope mar/pdi - check!\n# if idxNoShift:\n# print(\"Something wrong!\")\n# return\n # if maximum lies on the first point, then there is no point in searching\n # for the beginning of the IR. Just return this position.\n if max_idx > 0:\n abs_dat = 10*np.log10(squaredIR[:max_idx]) \\\n - 10.*np.log10(max_val)\n thresholdNotOk = True\n thresholdShift = 0\n while thresholdNotOk:\n if len(np.where(abs_dat < (-threshold+thresholdShift))[0]) > 0:\n lastBelowThreshold = \\\n np.where(abs_dat < (-threshold+thresholdShift))[0][-1]\n thresholdNotOk = False\n else:\n thresholdShift += 1\n if thresholdShift > 0:\n print(\"_start_sample_ISO3382: 20 dB threshold too high. \" +\n \"Decreasing it.\")\n if lastBelowThreshold > 0:\n startSample = lastBelowThreshold\n else:\n startSample = 1\n return startSample\n\n\n@njit\ndef _circular_time_shift(timeSignal, threshold=20):\n # find the first sample where inputSignal level > 20 dB or > bgNoise level\n startSample = _start_sample_ISO3382(timeSignal, threshold)\n newTimeSignal = timeSignal[startSample:]\n return (newTimeSignal, startSample)\n\n\n@njit\ndef _Lundeby_correction(band, timeSignal, samplingRate, numSamples,\n numChannels, timeLength):\n returnTuple = (np.float32(0), np.float32(0), np.int32(0), np.float32(0))\n timeSignal, sampleShift = _circular_time_shift(timeSignal)\n if sampleShift is None:\n return returnTuple\n winTimeLength = 0.03 # 30 ms window\n numSamples -= sampleShift # discount shifted samples\n numParts = 5 # number of parts per 10 dB decay. N = any([3, 10])\n dBtoNoise = 7 # stop point 10 dB above first estimated background noise\n useDynRange = 15 # dynamic range\n\n # 1) local time average:\n blockSamples = int(winTimeLength * samplingRate)\n timeWinData, timeVecWin = _level_profile(timeSignal, samplingRate,\n numSamples, numChannels,\n blockSamples)\n\n # 2) estimate noise from h^2_averaged(block):\n bgNoiseLevel = 10 * \\\n np.log10(\n np.mean(timeWinData[-int(timeWinData.size/10):]))\n\n # 3) Calculate premilinar slope\n startIdx = np.argmax(np.abs(timeWinData/np.max(np.abs(timeWinData))))\n stopIdx = startIdx + np.where(10*np.log10(timeWinData[startIdx+1:])\n >= bgNoiseLevel + dBtoNoise)[0][-1]\n dynRange = 10*np.log10(timeWinData[stopIdx]) \\\n - 10*np.log10(timeWinData[startIdx])\n if (stopIdx == startIdx) or (dynRange > -5)[0]:\n print(band, \"[Hz] band: SNR too low for the preliminar slope\",\n \"calculation.\")\n return returnTuple\n\n # X*c = EDC (energy decaying curve)\n X = np.ones((stopIdx-startIdx, 2), dtype=np.float32)\n X[:, 1] = timeVecWin[startIdx:stopIdx, 0]\n c = np.linalg.lstsq(X, 10*np.log10(timeWinData[startIdx:stopIdx]),\n rcond=-1)[0]\n\n if (c[1] == 0)[0] or np.isnan(c).any():\n print(band, \"[Hz] band: regression failed. T would be inf.\")\n return returnTuple\n\n # 4) preliminary intersection\n crossingPoint = (bgNoiseLevel - c[0]) / c[1] # [s]\n if (crossingPoint > 2*(timeLength + sampleShift/samplingRate))[0]:\n print(band, \"[Hz] band: preliminary intersection point between\",\n \"bgNoiseLevel and the decay slope greater than signal length.\")\n return returnTuple\n\n # 5) new local time interval length\n nBlocksInDecay = numParts * dynRange[0] / -10\n\n dynRangeTime = timeVecWin[stopIdx] - timeVecWin[startIdx]\n blockSamples = int(samplingRate * dynRangeTime[0] / nBlocksInDecay)\n\n # 6) average\n timeWinData, timeVecWin = _level_profile(timeSignal, samplingRate,\n numSamples, numChannels,\n blockSamples)\n\n oldCrossingPoint = 11+crossingPoint # arbitrary higher value to enter loop\n loopCounter = 0\n\n while (np.abs(oldCrossingPoint - crossingPoint) > 0.001)[0]:\n # 7) estimate background noise level (BGL)\n bgNoiseMargin = 7\n idxLast10Percent = int(len(timeWinData)-(len(timeWinData)//10))\n bgStartTime = crossingPoint - bgNoiseMargin/c[1]\n if (bgStartTime > timeVecWin[-1:][0])[0]:\n idx10dBDecayBelowCrossPoint = len(timeVecWin)-1\n else:\n idx10dBDecayBelowCrossPoint = \\\n np.where(timeVecWin >= bgStartTime)[0][0]\n BGL = np.mean(timeWinData[np.min(\n np.array([idxLast10Percent,\n idx10dBDecayBelowCrossPoint])):])\n bgNoiseLevel = 10*np.log10(BGL)\n\n # 8) estimate late decay slope\n stopTime = (bgNoiseLevel + dBtoNoise - c[0])/c[1]\n if (stopTime > timeVecWin[-1])[0]:\n stopIdx = 0\n else:\n stopIdx = int(np.where(timeVecWin >= stopTime)[0][0])\n\n startTime = (bgNoiseLevel + dBtoNoise + useDynRange - c[0])/c[1]\n if (startTime < timeVecWin[0])[0]:\n startIdx = 0\n else:\n startIdx = int(np.where(timeVecWin <= startTime)[0][0])\n\n lateDynRange = np.abs(10*np.log10(timeWinData[stopIdx]) \\\n - 10*np.log10(timeWinData[startIdx]))\n\n # where returns empty\n if stopIdx == startIdx or (lateDynRange < useDynRange)[0]:\n print(band, \"[Hz] band: SNR for the Lundeby late decay slope too\",\n \"low. Skipping!\")\n # c[1] = np.inf\n c[1] = 0\n break\n\n X = np.ones((stopIdx-startIdx, 2), dtype=np.float32)\n X[:, 1] = timeVecWin[startIdx:stopIdx, 0]\n c = np.linalg.lstsq(X, 10*np.log10(timeWinData[startIdx:stopIdx]),\n rcond=-1)[0]\n\n if (c[1] >= 0)[0]:\n print(band, \"[Hz] band: regression did not work, T -> inf.\",\n \"Setting slope to 0!\")\n # c[1] = np.inf\n c[1] = 0\n break\n\n # 9) find crosspoint\n oldCrossingPoint = crossingPoint\n crossingPoint = (bgNoiseLevel - c[0]) / c[1]\n\n loopCounter += 1\n if loopCounter > 30:\n print(band, \"[Hz] band: more than 30 iterations on regression.\",\n \"Canceling!\")\n break\n\n interIdx = crossingPoint * samplingRate # [sample]\n\n return c[0][0], c[1][0], np.int32(interIdx[0]), BGL\n\n@njit\ndef energy_decay_calculation(band, timeSignal, timeVector, samplingRate,\n numSamples, numChannels, timeLength, bypassLundeby):\n \"\"\"Calculate the Energy Decay Curve.\"\"\"\n if not bypassLundeby:\n lundebyParams = \\\n _Lundeby_correction(band,\n timeSignal,\n samplingRate,\n numSamples,\n numChannels,\n timeLength)\n _, c1, interIdx, BGL = lundebyParams\n lateRT = -60/c1 if c1 != 0 else 0\n else:\n interIdx = 0\n lateRT = 1\n\n if interIdx == 0:\n interIdx = -1\n\n truncatedTimeSignal = timeSignal[:interIdx, 0]\n truncatedTimeVector = timeVector[:interIdx]\n\n if lateRT != 0.0:\n if not bypassLundeby:\n C = samplingRate*BGL*lateRT/(6*np.log(10))\n else:\n C = 0\n sqrInv = truncatedTimeSignal[::-1]**2\n energyDecayFull = np.cumsum(sqrInv)[::-1] + C\n energyDecay = energyDecayFull/energyDecayFull[0]\n else:\n print(band, \"[Hz] band: could not estimate C factor\")\n C = 0\n energyDecay = np.zeros(truncatedTimeVector.size)\n return (energyDecay, truncatedTimeVector, lundebyParams)\n\ndef cumulative_integration(inputSignal,\n bypassLundeby,\n plotLundebyResults,\n **kwargs):\n \"\"\"Cumulative integration with proper corrections.\"\"\"\n\n def plot_lundeby():\n c0, c1, interIdx, BGL = lundebyParams\n fig = plt.figure(figsize=(10, 5))\n ax = fig.add_axes([0.08, 0.15, 0.75, 0.8], polar=False,\n projection='rectilinear', xscale='linear')\n line = c1*timeVector + c0\n ax.plot(timeVector, 10*np.log10(timeSignal**2),label='IR')\n ax.axhline(y=10*np.log10(BGL), color='#1f77b4', label='BG Noise')\n ax.plot(timeVector, line,label='Late slope')\n ax.axvline(x=interIdx/samplingRate, label='Truncation point')\n plt.title('{0:.0f} [Hz]'.format(band))\n ax.legend(loc='upper center', shadow=True, fontsize='x-large')\n\n timeSignal = inputSignal.timeSignal[:]\n # Substituted by SignalObj.crop in analyse function\n # timeSignal, sampleShift = _circular_time_shift(timeSignal)\n # del sampleShift\n hSignal = SignalObj(timeSignal,\n inputSignal.lengthDomain,\n inputSignal.samplingRate)\n hSignal = _filter(hSignal, **kwargs)\n bands = FOF(nthOct=kwargs['nthOct'],\n freqRange=[kwargs['minFreq'],kwargs['maxFreq']])[:,1]\n listEDC = []\n for ch in range(hSignal.numChannels):\n signal = hSignal[ch]\n band = bands[ch]\n timeSignal = cp.copy(signal.timeSignal[:])\n timeVector = signal.timeVector[:]\n samplingRate = signal.samplingRate\n numSamples = signal.numSamples\n numChannels = signal.numChannels\n timeLength = signal.timeLength\n energyDecay, energyVector, lundebyParams = \\\n energy_decay_calculation(band,\n timeSignal,\n timeVector,\n samplingRate,\n numSamples,\n numChannels,\n timeLength,\n bypassLundeby)\n listEDC.append((energyDecay, energyVector))\n if plotLundebyResults: # Placed here because Numba can't handle plots.\n # plot_lundeby(band, timeVector, timeSignal, samplingRate,\n # lundebyParams)\n plot_lundeby()\n return listEDC\n\n@njit\ndef reverb_time_regression(energyDecay, energyVector, upperLim, lowerLim):\n \"\"\"Interpolate the EDT to get the reverberation time.\"\"\"\n if not np.any(energyDecay):\n return 0\n first = np.where(10*np.log10(energyDecay) >= upperLim)[0][-1]\n last = np.where(10*np.log10(energyDecay) >= lowerLim)[0][-1]\n if last <= first:\n # return np.nan\n return 0\n X = np.ones((last-first, 2))\n X[:, 1] = energyVector[first:last]\n c = np.linalg.lstsq(X, 10*np.log10(energyDecay[first:last]), rcond=-1)[0]\n return -60/c[1]\n\n\ndef reverberation_time(decay, nthOct, samplingRate, listEDC):\n \"\"\"Call the reverberation time regression.\"\"\"\n try:\n decay = int(decay)\n y1 = -5\n y2 = y1 - decay\n except ValueError:\n if decay in ['EDT', 'edt']:\n y1 = 0\n y2 = -10\n else:\n raise ValueError(\"Decay must be either 'EDT' or an integer \\\n corresponding to the amount of energy decayed to \\\n evaluate, e.g. (decay='20' | 20).\")\n RT = []\n for ED in listEDC:\n edc, edv = ED\n RT.append(reverb_time_regression(edc, edv, y1, y2))\n return RT\n\n\ndef G_Lpe(IR, nthOct, minFreq, maxFreq, IREndManualCut=None):\n \"\"\"\n Calculate the energy level from the room impulsive response.\n\n Reference:\n Christensen, C. L.; Rindel, J. H. APPLYING IN-SITU RECALIBRATION FOR\n SOUND STRENGTH MEASUREMENTS IN AUDITORIA.\n\n :param IR: one channel impulsive response\n :type IR: ImpulsiveResponse\n\n :param nthOct: number of fractions per octave\n :type nthOct: int\n\n :param minFreq: analysis inferior frequency limit\n :type minFreq: float\n\n :param maxFreq: analysis superior frequency limit\n :type maxFreq: float\n\n :return: Analysis object with the calculated parameter\n :rtype: Analysis\n \"\"\"\n # Code snippet to guarantee that generated object name is\n # the declared at global scope\n # for frame, line in traceback.walk_stack(None):\n for framenline in traceback.walk_stack(None):\n # varnames = frame.f_code.co_varnames\n varnames = framenline[0].f_code.co_varnames\n if varnames is ():\n break\n # creation_file, creation_line, creation_function, \\\n # creation_text = \\\n extracted_text = \\\n traceback.extract_stack(framenline[0], 1)[0]\n # traceback.extract_stack(frame, 1)[0]\n # creation_name = creation_text.split(\"=\")[0].strip()\n creation_name = extracted_text[3].split(\"=\")[0].strip()\n\n # firstChNum = IR.systemSignal.channels.mapping[0]\n # if not IR.systemSignal.channels[firstChNum].calibCheck:\n # raise ValueError(\"'IR' must be a calibrated ImpulsiveResponse\")\n if isinstance(IR, SignalObj):\n SigObj = cp.copy(IR)\n elif isinstance(IR, ImpulsiveResponse):\n SigObj = cp.copy(IR.systemSignal)\n else:\n raise TypeError(\"'IR' must be an ImpulsiveResponse or SignalObj.\")\n # Cutting the IR\n if IREndManualCut is not None:\n SigObj.crop(0, IREndManualCut)\n timeSignal, _ = _circular_time_shift(SigObj.timeSignal[:,0])\n # Bands filtering\n # hSignal = SignalObj(SigObj.timeSignal[:,0],\n hSignal = SignalObj(timeSignal,\n SigObj.lengthDomain,\n SigObj.samplingRate)\n hSignal = _filter(signal=hSignal, nthOct=nthOct, minFreq=minFreq,\n maxFreq=maxFreq)\n bands = FOF(nthOct=nthOct,\n freqRange=[minFreq,maxFreq])[:,1]\n Lpe = []\n for chIndex in range(hSignal.numChannels):\n Lpe.append(\n 10*np.log10(np.trapz(y=hSignal.timeSignal[:,chIndex]**2/(2e-5**2),\n x=hSignal.timeVector)))\n LpeAnal = Analysis(anType='mixed', nthOct=nthOct, minBand=float(bands[0]),\n maxBand=float(bands[-1]), data=Lpe,\n comment='h**2 energy level')\n LpeAnal.creation_name = creation_name\n return LpeAnal\n\n\ndef G_Lps(IR, nthOct, minFreq, maxFreq):\n \"\"\"G_Lps \n \n Calculates the recalibration level, for both in-situ and\n reverberation chamber. Lps is applied for G calculation.\n\n During the recalibration: source height and mic heigth must be >= 1 [m],\n while the distance between source and mic must be <= 1 [m]. The distances\n must be the same for in-situ and reverberation chamber measurements.\n\n Reference:\n Christensen, C. L.; Rindel, J. H. APPLYING IN-SITU RECALIBRATION FOR\n SOUND STRENGTH MEASUREMENTS IN AUDITORIA.\n\n :param IR: one channel impulsive response\n :type IR: ImpulsiveResponse\n\n :param nthOct: number of fractions per octave\n :type nthOct: int\n\n :param minFreq: analysis inferior frequency limit\n :type minFreq: float\n\n :param maxFreq: analysis superior frequency limit\n :type maxFreq: float\n\n :return: Analysis object with the calculated parameter\n :rtype: Analysis\n \"\"\"\n # Code snippet to guarantee that generated object name is\n # the declared at global scope\n # for frame, line in traceback.walk_stack(None):\n for framenline in traceback.walk_stack(None):\n # varnames = frame.f_code.co_varnames\n varnames = framenline[0].f_code.co_varnames\n if varnames is ():\n break\n # creation_file, creation_line, creation_function, \\\n # creation_text = \\\n extracted_text = \\\n traceback.extract_stack(framenline[0], 1)[0]\n # traceback.extract_stack(frame, 1)[0]\n # creation_name = creation_text.split(\"=\")[0].strip()\n creation_name = extracted_text[3].split(\"=\")[0].strip()\n\n # firstChNum = IR.systemSignal.channels.mapping[0]\n # if not IR.systemSignal.channels[firstChNum].calibCheck:\n # raise ValueError(\"'IR' must be a calibrated ImpulsiveResponse\")\n if isinstance(IR, SignalObj):\n SigObj = IR\n elif isinstance(IR, ImpulsiveResponse):\n SigObj = IR.systemSignal\n else:\n raise TypeError(\"'IR' must be an ImpulsiveResponse or SignalObj.\")\n # Windowing the IR\n # dBtoOnSet = 20\n # dBIR = 10*np.log10((SigObj.timeSignal[:,0]**2)/((2e-5)**2))\n # windowStart = np.where(dBIR > (max(dBIR) - dBtoOnSet))[0][0]\n\n broadBandTimeSignal = cp.copy(SigObj.timeSignal[:,0])\n broadBandTimeSignalNoStart, sampleShift = \\\n _circular_time_shift(broadBandTimeSignal)\n windowLength = 0.0032 # [s]\n windowEnd = int(windowLength*SigObj.samplingRate)\n\n\n hSignal = SignalObj(broadBandTimeSignalNoStart[:windowEnd],\n # hSignal = SignalObj(timeSignal,\n SigObj.lengthDomain,\n SigObj.samplingRate)\n hSignal = _filter(signal=hSignal, nthOct=nthOct, minFreq=minFreq,\n maxFreq=maxFreq)\n bands = FOF(nthOct=nthOct,\n freqRange=[minFreq,maxFreq])[:,1]\n Lps = []\n for chIndex in range(hSignal.numChannels):\n timeSignal = cp.copy(hSignal.timeSignal[:,chIndex])\n # timeSignalNoStart, sampleShift = _circular_time_shift(timeSignal)\n # windowLength = 0.0032 # [s]\n # windowEnd = int(windowLength*SigObj.samplingRate)\n\n Lps.append(\n # 10*np.log10(np.trapz(y=timeSignalNoStart[:windowEnd]**2/(2e-5**2),\n 10*np.log10(np.trapz(y=timeSignal**2/(2e-5**2),\n # x=hSignal.timeVector[sampleShift:sampleShift+windowEnd])))\n x=hSignal.timeVector)))\n LpsAnal = Analysis(anType='mixed', nthOct=nthOct, minBand=float(bands[0]),\n maxBand=float(bands[-1]), data=Lps,\n comment='Source recalibration method IR')\n LpsAnal.creation_name = creation_name\n LpsAnal.windowLimits = ((sampleShift)/SigObj.samplingRate,\n (sampleShift+windowEnd)/SigObj.samplingRate)\n # Plot IR cutting\n # fig = plt.figure(figsize=(10, 5))\n # ax = fig.add_axes([0.08, 0.15, 0.75, 0.8], polar=False,\n # projection='rectilinear', xscale='linear')\n # ax.plot(SigObj.timeVector, 10*np.log10(SigObj.timeSignal**2/2e-5**2))\n # ax.axvline(x=(sampleShift)/SigObj.samplingRate, linewidth=4, color='k')\n # ax.axvline(x=(sampleShift+windowEnd)/SigObj.samplingRate, linewidth=4, color='k')\n # ax.set_xlim([(sampleShift-100)/SigObj.samplingRate, (sampleShift+windowEnd+100)/SigObj.samplingRate])\n return LpsAnal\n\n\ndef strength_factor(Lpe, Lpe_revCh, V_revCh, T_revCh, Lps_revCh, Lps_inSitu):\n S0 = 1 # [m2]\n\n bands = T_revCh.bands\n nthOct = T_revCh.nthOct\n terms = []\n for bandData in T_revCh.data:\n if bandData == 0:\n terms.append(0)\n else:\n term = (V_revCh * 0.16) / (bandData * S0)\n terms.append(term)\n terms = [10*np.log10(term) if term != 0 else 0 for term in terms]\n\n revChTerm = Analysis(anType='mixed', nthOct=nthOct, minBand=float(bands[0]),\n maxBand=float(bands[-1]), data=terms)\n Lpe.anType = 'mixed'\n Lpe_revCh.anType = 'mixed'\n Lps_revCh.anType = 'mixed'\n Lps_inSitu.anType = 'mixed'\n G = Lpe - Lpe_revCh - revChTerm + 37 \\\n + Lps_revCh - Lps_inSitu\n G.anType = 'G'\n return G\n\n\ndef _clarity(temp, signalObj, nthOct, **kwargs): # TODO\n \"\"\"\n\n \"\"\"\n# try:\n# temp = int(temp)*signalObj.samplingRate//1000\n# except ValueError:\n# raise ValueError(\"The temp parameter must be an integer or a string \\\n# of integers, e.g. (temp='80' | 80).\")\n# output = []\n# for ch in range(signalObj.num_channels()):\n# filtResp = filtered_response(signalObj[ch], nthOct, **kwargs)\n# C = []\n# for bd in range(len(filtResp)):\n# C.append(round(np.sum(filtResp[bd][:temp], axis=0)\n# / np.sum(filtResp[bd][temp:], axis=0)[0], 2))\n# output.append(C)\n# return output\n pass\n\n\ndef _definition(temp, signalObj, nthOct, **kwargs): # TODO\n \"\"\"\n\n \"\"\"\n# try:\n# temp = int(temp)*signalObj.samplingRate//1000\n# except ValueError:\n# raise ValueError(\"The temp parameter must be an integer or a string \\\n# of integers, e.g. (temp='50' | 50).\")\n# output = []\n# for ch in range(signalObj.num_channels()):\n# filtResp = filtered_response(signalObj[ch], nthOct, **kwargs)\n# D = []\n# for bd in range(len(filtResp)):\n# D.append(round(10*np.log10(\n# np.sum(filtResp[bd][:temp], axis=0)\n# / np.sum(filtResp[bd][:], axis=0))[0], 2))\n# output.append(D)\n# return output\n pass\n\ndef crop_IR(SigObj, IREndManualCut):\n \"\"\"Cut the impulse response at background noise level.\"\"\"\n timeSignal = cp.copy(SigObj.timeSignal)\n timeVector = SigObj.timeVector\n samplingRate = SigObj.samplingRate\n numSamples = SigObj.numSamples\n # numChannels = SigObj.numChannels\n if SigObj.numChannels > 1:\n print('crop_IR: The provided impulsive response has more than one ' +\n 'channel. Cropping based on channel 1.')\n numChannels = 1\n # Cut the end automatically or manual\n if IREndManualCut is None:\n winTimeLength = 0.1 # [s]\n meanSize = 5 # [blocks]\n dBtoReplica = 6 # [dB]\n blockSamples = int(winTimeLength * samplingRate)\n timeWinData, timeVecWin = _level_profile(timeSignal, samplingRate,\n numSamples, numChannels,\n blockSamples)\n endTimeCut = timeVector[-1]\n for blockIdx, blockAmplitude in enumerate(timeWinData):\n if blockIdx >= meanSize:\n anteriorMean = 10*np.log10( \\\n np.sum(timeWinData[blockIdx-meanSize:blockIdx])/meanSize)\n if 10*np.log10(blockAmplitude) > anteriorMean+dBtoReplica:\n endTimeCut = timeVecWin[blockIdx-meanSize//2]\n break\n else:\n endTimeCut = IREndManualCut\n endTimeCutIdx = np.where(timeVector >= endTimeCut)[0][0]\n timeSignal = timeSignal[:endTimeCutIdx]\n # Cut the start automatically\n timeSignal, _ = _circular_time_shift(timeSignal)\n result = SignalObj(timeSignal,\n 'time',\n samplingRate,\n signalType='energy')\n return result\n\ndef analyse(obj, *params,\n bypassLundeby=False,\n plotLundebyResults=False,\n IREndManualCut=None, **kwargs):\n \"\"\"\n Receives an one channel SignalObj or ImpulsiveResponse and calculate the\n room acoustic parameters especified in the positional input arguments.\n\n :param obj: one channel impulsive response\n :type obj: SignalObj or ImpulsiveResponse\n\n Input parameters for reverberation time, 'RT':\n :param RTdecay: decay interval for RT calculation. e.g. 20\n :type RTdecay: int\n\n Input parameters for clarity, 'C':\n TODO\n\n Input parameters for definition, 'D':\n TODO\n\n Input parameters for strength factor, 'G':\n TODO\n\n :param nthOct: number of fractions per octave\n :type nthOct: int\n\n :param minFreq: analysis inferior frequency limit\n :type minFreq: float\n\n :param maxFreq: analysis superior frequency limit\n :type maxFreq: float\n \n :param bypassLundeby: bypass lundeby correction\n to False\n :type bypassLundeby: bool, optional\n\n :param plotLundebyResults: plot the Lundeby correction parameters, defaults to False\n :type plotLundebyResults: bool, optional\n\n :return: Analysis object with the calculated parameter\n :rtype: Analysis\n\n \"\"\"\n # Code snippet to guarantee that generated object name is\n # the declared at global scope\n # for frame, line in traceback.walk_stack(None):\n for framenline in traceback.walk_stack(None):\n # varnames = frame.f_code.co_varnames\n varnames = framenline[0].f_code.co_varnames\n if varnames is ():\n break\n # creation_file, creation_line, creation_function, \\\n # creation_text = \\\n extracted_text = \\\n traceback.extract_stack(framenline[0], 1)[0]\n # traceback.extract_stack(frame, 1)[0]\n # creation_name = creation_text.split(\"=\")[0].strip()\n creation_name = extracted_text[3].split(\"=\")[0].strip()\n\n if not isinstance(obj, SignalObj) and not isinstance(obj, ImpulsiveResponse):\n raise TypeError(\"'obj' must be an one channel SignalObj or\" +\n \" ImpulsiveResponse.\")\n if isinstance(obj, ImpulsiveResponse):\n SigObj = obj.systemSignal\n else:\n SigObj = obj\n\n if SigObj.numChannels > 1:\n raise TypeError(\"'obj' can't contain more than one channel.\")\n samplingRate = SigObj.samplingRate\n\n SigObj = crop_IR(SigObj, IREndManualCut)\n\n listEDC = cumulative_integration(SigObj,\n bypassLundeby,\n plotLundebyResults,\n **kwargs)\n for _ in params:\n if 'RT' in params:\n RTdecay = params[params.index('RT')+1]\n nthOct = kwargs['nthOct']\n RT = reverberation_time(RTdecay, nthOct, samplingRate, listEDC)\n result = Analysis(anType='RT', nthOct=nthOct,\n minBand=kwargs['minFreq'],\n maxBand=kwargs['maxFreq'],\n data=RT)\n # if 'C' in prm:\n # Ctemp = prm[1]\n # if 'D' in prm:\n # Dtemp = prm[1]\n result.creation_name = creation_name\n return result\n", "meta": {"hexsha": "e40002796bccfa19e1b854696c8cdd7e833454d0", "size": 28848, "ext": "py", "lang": "Python", "max_stars_repo_path": "pytta/rooms.py", "max_stars_repo_name": "carolgaudeoso/PyTTa", "max_stars_repo_head_hexsha": "13a5d2a8f30a096897baaffe98ebb84b324d6891", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-09-17T00:22:45.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-17T00:22:45.000Z", "max_issues_repo_path": "pytta/rooms.py", "max_issues_repo_name": "carolgaudeoso/PyTTa", "max_issues_repo_head_hexsha": "13a5d2a8f30a096897baaffe98ebb84b324d6891", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pytta/rooms.py", "max_forks_repo_name": "carolgaudeoso/PyTTa", "max_forks_repo_head_hexsha": "13a5d2a8f30a096897baaffe98ebb84b324d6891", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.8582677165, "max_line_length": 107, "alphanum_fraction": 0.5988976705, "include": true, "reason": "import numpy,from numba", "num_tokens": 7358, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.611381973294151, "lm_q2_score": 0.3208212878370535, "lm_q1q2_score": 0.19614435203258856}} {"text": "\"\"\"\nMain module of the neda inference package\n\nThis introduces the `Environment` class, which we use to facilitate repeating\ntasks like running MCMC, calculating or estimating evidence. Finally, the\n`main` function runs the whole scheme. Note that both of these are imported\ninto the ``tracklib.analysis.neda`` namespace, i.e. can be imported from there\n(instead of ``tracklib.analysis.neda.neda``).\n\"\"\"\n\nimport numpy as np\nimport scipy.optimize\n\nfrom . import mcmc\n\nclass Environment:\n \"\"\"\n Environment for inference runs\n\n This is essentially a semi-disguised way of using global variables for the\n `Trajectory` we are looking at, the inference `models.Model` we want to use, and\n the `MCMCscheme` together with the `MCMCconfig`. We use this approach\n mainly for code readability / useability.\n\n Attributes\n ----------\n traj : Trajectory\n model : models.Model\n MCMCconfig : dict\n see `tracklib.util.mcmc.Sampler`\n MCMCscheme : mcmc.MCMCScheme, optional\n defaults to an instance of `mcmc.TPWMCMC`\n \"\"\"\n # Here we use ``env`` instead of ``self``.\n def __init__(self, traj, model, MCMCconfig, MCMCscheme=None):\n self.traj = traj\n self.model = model\n self.MCMCconfig = MCMCconfig\n if MCMCscheme is None:\n self.MCMCscheme = mcmc.TPWMCMC()\n else: # pragma: no cover\n self.MCMCscheme = MCMCscheme\n\n def runMCMC(env, prior):\n \"\"\"\n Run the `MCMCscheme` with a given `prior`\n\n Parameters\n ----------\n prior : Prior\n \n Returns\n -------\n mcmc.MCMCRun\n \"\"\"\n env.MCMCscheme.setup(env.traj, env.model, prior)\n env.MCMCscheme.configure(**env.MCMCconfig)\n return env.MCMCscheme.run()\n\n def posterior_density(env, mcmcrun, prior, trace_eval,\n nSample_proposal=float('inf')):\n r\"\"\"\n Estimate the posterior density at a specific point from an `MCMCRun`\n\n Parameters\n ----------\n mcmcrun : MCMCRun\n prior : Prior\n trace_eval : Loopingtrace\n the point in parameter space for which to estimate the posterior\n density\n nSample_proposal : float, optional\n how many samples from the proposal distribution to use for\n evaluation of the exit rate. Defaults to exhaustive sampling, so\n may be reduced if that seems excessive.\n\n Returns\n -------\n float\n the estimated posterior density for `!trace_eval`. Might be\n ``np.inf`` if the MCMC ensemble collapsed to a single sample.\n\n Notes\n -----\n This estimation follows eq. (9) of [1]_. Essentially, we estimate the\n density at the sample point as the number of times it is entered from\n another point in the steady state ensemble, times the average number of\n steps it takes to leave this point again, divided by the total sample\n number :math:`M`. This yields\n\n .. math:: \\hat{p}(\\theta^*) = \\frac{N_\\text{enter}N_\\text{stay}}{M} = \\frac{P_\\text{enter}}{k_\\text{exit}} = \\frac{M^{-1}\\sum_{m=1}^M\\, \\alpha(\\theta^{(m)}, \\theta^*) q(\\theta^{(m)}, \\theta^*)}{J^{-1}\\sum_{j=1}^J\\, \\alpha(\\theta^*, \\theta^{(j)})}\\,,\n\n where the :math:`\\theta^{(m)}` in the numerator are the samples from\n the given MCMC run (i.e. are assumed to be sampled from the posterior\n distribution), while :math:`\\theta^{(j)}` in the denominator are\n independent samples from the proposal distribution\n :math:`q(\\theta_\\text{from} = \\theta^*, \\theta_\\text{to})`\n around the evaluation point :math:`\\theta^*`. Finally,\n :math:`\\alpha(\\theta_\\text{from}, \\theta_\\text{to})` is the\n acceptance probability for a given step.\n\n References\n ----------\n .. [1] Chib, S. & Jeliazkov, I. Marginal Likelihood From the Metropolis-Hastings Output. Journal of the American Statistical Association 96, 270-281 (2001)\n \"\"\"\n # Check whether the MCMC sample collapsed, in which case the posterior\n # estimation would diverge\n logLs = mcmcrun.logLs_trunc()\n if np.all(logLs == logLs[0]):\n print('MCMC ensemble collapsed to single sample')\n return np.inf\n\n L_eval = env.MCMCscheme.likelihood(env.traj, trace_eval, env.model, prior)\n\n # Chance to enter the target state from steady state\n def get_p_step_to_eval(trace): return env.MCMCscheme.stepping_probability(trace, trace_eval)\n p_step_to_eval = np.array(mcmcrun.evaluate(get_p_step_to_eval))\n\n # Note: p_accept = 1 *if* we evaluate at the maximum likelihood trace\n p_accept_move = env.MCMCscheme.acceptance_probability(mcmcrun.logLs_trunc(), L_eval)\n p_enter = np.mean(p_step_to_eval * p_accept_move)\n\n # Survival in target state\n neighbor_logLs = [env.MCMCscheme.likelihood(env.traj, trace, env.model, prior) \\\n for trace in env.MCMCscheme.gen_proposal_sample_from(trace_eval, nSample=nSample_proposal)]\n k_leave = np.mean(env.MCMCscheme.acceptance_probability(L_eval, neighbor_logLs))\n\n # Occupancy of the target state = p_enter * survival\n return p_enter / k_leave\n\n def evidence(env, prior, mcmcrun):\n \"\"\"\n Calculate the (log-)evidence from an `MCMCRun`\n\n Parameters\n ----------\n prior : Prior\n the prior over `Loopingtraces ` used for the MCMC run\n mcmcrun : MCMCRun\n the MCMC sample\n\n Returns\n -------\n float\n the estimated log-evidence\n\n Notes\n -----\n The log-evidence is given by ``log(likelihood) + log(prior) -\n log(posterior)``.\n\n See also\n --------\n posterior_density\n \"\"\"\n trace_eval, L_eval = mcmcrun.best_sample_L()\n log_post = np.log(env.posterior_density(mcmcrun, prior, trace_eval, nSample_proposal=len(mcmcrun.samples)))\n log_prior = prior.logpi(trace_eval)\n\n if np.isinf(log_post):\n return L_eval\n else:\n return L_eval + log_prior - log_post\n\n def evidence_differential(env, prior, ref_prior, ref_mcmcrun):\n r\"\"\"\n Estimate the relative evidence given a reference point\n\n Parameters\n ----------\n prior : Prior\n the prior whose evidence we want to estimate\n ref_prior : Prior\n the reference point in prior space\n ref_mcmcrun : MCMCRun\n an `MCMCRun` using the reference prior\n\n Returns\n -------\n float\n the estimated log-evidence, relative to the reference\n\n Notes\n -----\n The relative evidence is given by the expectation value of the prior\n ratio over the MCMC sample: ``E = < prior/ref_prior >`` where ``<.>``\n indicates an average over the MCMC sample.\n \"\"\"\n return np.log(np.mean(np.exp(prior.logpi_vectorized(ref_mcmcrun.samples) - \\\n ref_prior.logpi_vectorized(ref_mcmcrun.samples))))\n\ndef main(traj, model, priorfam,\n MCMCconfig, MCMCscheme=None,\n max_iterations=20, min_iterations=5,\n return_ = 'nothing', # 'traj', 'dict', or anything else\n show_progress=False, assume_notebook_for_progressbar=True,\n ):\n \"\"\"\n Run the neda looping inference scheme\n\n The output of the inference run will be assembled into a dict whose fields\n are detailed below. Where exactly this dict will end up depends on the\n setting of `!return_`.\n \n Parameters\n ----------\n traj : Trajectory\n the `Trajectory` whose looping profile to infer\n model : models.Model\n the inference model to use\n priorfam : ParametricFamily\n a family of priors\n MCMCconfig : dict\n configuration for the MCMC runs. See `tracklib.util.mcmc.Sampler`\n MCMCscheme : mcmc.MCMCScheme, optional\n the sampling scheme to use, i.e. an object implementing the\n `mcmc.MCMCScheme` interface. Defaults to `mcmc.TPWMCMC'\n max_iterations : int, optional\n maximum number of iterations to run\n min_iterations : int, optional\n run at least this many iterations\n return_ : {'nothing', 'None', 'traj', 'dict'}\n what the return value of this function should be. Generally, the\n results of the inference run will be stored in a dict. If\n ``return_='dict'``, that dict is directly returned. Otherwise it is\n written to ``traj.meta['neda']``, and if ``return_='traj'`` the\n trajectory is returned (useful for parallelization). Otherwise this\n function returns nothing, i.e. the inference results can be accessed\n simply from ``traj.meta['neda']`` after calling this function.\n show_progress : bool, optional\n whether to show a progress bar. Note: for ``show_progress=True`` it\n might happen that the termination condition is fulfilled during the\n last \"required\" run, in which case the progress bar will stop before\n reaching its maximum.\n assume_notebook_for_progressbar : bool, optional\n set to ``False`` if running outside Jupyter notebook to show\n progressbar ASCII style\n\n Returns\n -------\n prior_prams : np.array\n the prior parameters for each iteration\n mcmcrun : list of MCMCRun\n the MCMC runs for each iteration\n evidence : np.array\n the evidence estimated from each `MCMCRun`\n evidence_diff : np.array\n the estimated evidence differential (relative evidence) at each\n iteration\n final : dict\n the corresponding values for the iteration that should be considered\n the final result. Has entries ``'prior_params'``, ``'mcmcrun'``,\n ``'evidence'``, and ``'iteration'`` where the last one is the index of\n the iteration the other three refer to.\n\n Example\n -------\n Assuming we have a `Trajectory` ``traj`` that we want to run the looping\n inference on:\n\n >>> # Set up inference scheme\n ... looppositions = [(0, 0), (0, -1)] # 2 states: unlooped (=0), fully looped (=1)\n ... model = neda.models.RouseModel(N=20, D=1, k=5, k_extra=1, looppositions=looppositions)\n ... priorfam = neda.ParametricFamily(start_params=(0), bounds=[(None, 0)])\n ... priorfam.get = lambda logq : neda.priors.GeometricPrior(logq, nStates=len(looppositions))\n ... MCMCconfig = {\n ... 'iterations' : 1000,\n ... 'burn_in' : 100,\n ... }\n ... \n ... # Run the inference\n ... neda.main(traj, model, priorfam, MCMCconfig, show_progress=True)\n ... \n ... # Visualize output\n ... from matplotlib import pyplot as plt\n ... neda.plot.butterfly(traj)\n ... plt.show()\n\n See also\n --------\n tracklib.analysis.kli.fit_RouseParams\n \"\"\"\n assert min_iterations >= 2\n assert return_ in {'nothing', 'None', 'traj', 'dict'}\n\n # Set up environment\n env = Environment(traj, model, MCMCconfig, MCMCscheme)\n\n # Set up iterative scheme\n iterations = range(max_iterations)\n if show_progress: # pragma: no cover\n if assume_notebook_for_progressbar:\n from tqdm.notebook import tqdm\n else:\n from tqdm import tqdm\n iterations = tqdm(iterations, total=min(min_iterations, max_iterations))\n\n prior_params = [priorfam.start_params]\n mcmcruns = []\n evidences = []\n evidence_diffs = []\n\n # Run iterations\n for it in iterations:\n prior = priorfam.get(*prior_params[-1])\n mcmcruns.append(env.runMCMC(prior))\n evidences.append(env.evidence(prior, mcmcruns[-1]))\n\n if it+1 >= min_iterations:\n if np.argmax(evidences) < it:\n break\n \n # Maximize estimated evidence differential to find new prior parameters\n def minimization_target(*params):\n return -env.evidence_differential(priorfam.get(*params), prior, mcmcruns[-1])\n minimization_result = scipy.optimize.minimize(minimization_target,\n x0=prior_params[-1],\n bounds=priorfam.bounds)\n\n if not minimization_result.success: # pragma: no cover\n print(minimization_result)\n raise RuntimeError('Relative evidence maximization did not converge')\n\n evidence_diffs.append(-minimization_result.fun)\n prior_params.append(tuple(minimization_result.x))\n\n # Output\n best_it = np.argmax(evidences)\n output = {\n 'prior_params' : np.array(prior_params),\n 'mcmcrun' : mcmcruns,\n 'evidence' : np.array(evidences),\n 'evidence_diff' : np.array(evidence_diffs),\n 'final' : {\n 'prior_params' : prior_params[best_it],\n 'mcmcrun' : mcmcruns[best_it],\n 'evidence' : evidences[best_it],\n 'iteration' : best_it,\n 'best_trace' : mcmcruns[best_it].best_sample_L()[0],\n },\n }\n\n if return_ == 'dict':\n return output\n else:\n traj.meta['neda'] = output\n if return_ == 'traj':\n return traj\n else:\n return None\n", "meta": {"hexsha": "5cbd83dcf10153abaabce8f522e8e3c1ae8ea481", "size": 13321, "ext": "py", "lang": "Python", "max_stars_repo_path": "tracklib/analysis/neda/neda.py", "max_stars_repo_name": "SGrosse-Holz/tracklib", "max_stars_repo_head_hexsha": "e0b88e3959db2ce65869d8292ce5792f4c77c7a4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-01-30T15:10:51.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-30T15:10:51.000Z", "max_issues_repo_path": "tracklib/analysis/neda/neda.py", "max_issues_repo_name": "SGrosse-Holz/tracklib", "max_issues_repo_head_hexsha": "e0b88e3959db2ce65869d8292ce5792f4c77c7a4", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "tracklib/analysis/neda/neda.py", "max_forks_repo_name": "SGrosse-Holz/tracklib", "max_forks_repo_head_hexsha": "e0b88e3959db2ce65869d8292ce5792f4c77c7a4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.9515669516, "max_line_length": 257, "alphanum_fraction": 0.6185721793, "include": true, "reason": "import numpy,import scipy", "num_tokens": 3252, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.519521321952093, "lm_q2_score": 0.37754066879814546, "lm_q1q2_score": 0.19614042734468984}} {"text": "from __future__ import print_function\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom past.utils import old_div\nimport anuga\nimport numpy as num\nimport math\nfrom . import inlet_enquiry\n\nfrom anuga.utilities.system_tools import log_to_file\nfrom anuga.utilities.numerical_tools import ensure_numeric\n\n\n\nclass Structure_operator(anuga.Operator):\n \"\"\"Structure Operator - transfer water from one rectangular box to another.\n Sets up the geometry of problem\n \n This is the base class for structures (culverts, pipes, bridges etc). Inherit from this class (and overwrite\n discharge_routine method for specific subclasses)\n \n Input: Two points, pipe_size (either diameter or width, depth),\n mannings_rougness,\n \"\"\" \n\n counter = 0\n\n def __init__(self,\n domain,\n end_points=None,\n exchange_lines=None,\n enquiry_points=None,\n invert_elevations=None,\n width=None,\n height=None,\n diameter=None,\n z1=None,\n z2=None,\n blockage=None,\n barrels=None,\n #culvert_slope=None,\n apron=None,\n manning=None,\n enquiry_gap=None,\n use_momentum_jet=False,\n zero_outflow_momentum=True,\n use_old_momentum_method=True,\n always_use_Q_wetdry_adjustment=True,\n force_constant_inlet_elevations=False,\n description=None,\n label=None,\n structure_type=None,\n logging=None,\n verbose=None):\n \n \"\"\"\n exchange_lines define the input lines for each inlet.\n\n If end_points = None, then the culvert_vector is calculated in the\n directions from the centre of echange_line[0] to centre of exchange_line[1}\n\n If end_points != None, then culvert_vector is unit vector in direction\n end_point[1] - end_point[0]\n \"\"\"\n\n anuga.Operator.__init__(self,domain)\n\n self.master_proc = 0\n self.end_points = ensure_numeric(end_points)\n self.exchange_lines = ensure_numeric(exchange_lines)\n self.enquiry_points = ensure_numeric(enquiry_points)\n self.invert_elevations = ensure_numeric(invert_elevations)\n\n assert self.end_points is None or self.exchange_lines is None\n\n \n if height is None:\n height = width\n\n if width is None:\n width = diameter\n\n if apron is None:\n apron = width\n\n\n assert width is not None\n\n\n self.width = width\n self.height = height\n self.diameter = diameter\n self.z1 = z1 \n self.z2 = z2 \n self.blockage = blockage \n self.barrels = barrels\n self.apron = apron\n self.manning = manning\n self.enquiry_gap = enquiry_gap\n self.use_momentum_jet = use_momentum_jet\n self.zero_outflow_momentum = zero_outflow_momentum\n if use_momentum_jet and zero_outflow_momentum:\n msg = \"Can't have use_momentum_jet and zero_outflow_momentum both True\"\n raise Exception(msg)\n self.use_old_momentum_method = use_old_momentum_method\n self.always_use_Q_wetdry_adjustment = always_use_Q_wetdry_adjustment\n\n\n if description is None:\n self.description = ' '\n else:\n self.description = description\n \n if label is None:\n self.label = \"structure_%g\" % Structure_operator.counter\n else:\n self.label = label + '_%g' % Structure_operator.counter\n\n if structure_type is None:\n self.structure_type = 'generic structure'\n else:\n self.structure_type = structure_type\n \n self.verbose = verbose \n \n # Keep count of structures\n Structure_operator.counter += 1\n\n # Slots for recording current statistics\n self.accumulated_flow = 0.0\n self.discharge = 0.0\n self.discharge_abs_timemean = 0.0\n self.velocity = 0.0\n self.outlet_depth = 0.0\n self.delta_total_energy = 0.0\n self.driving_energy = 0.0\n \n if exchange_lines is not None:\n self.__process_skew_culvert()\n elif end_points is not None:\n self.__process_non_skew_culvert()\n else:\n raise Exception('Define either exchange_lines or end_points')\n \n\n self.inlets = []\n line0 = self.exchange_lines[0] #self.inlet_lines[0]\n if self.apron is None:\n poly0 = line0\n else:\n offset = -self.apron*self.outward_vector_0 \n #print line0\n #print offset\n poly0 = num.array([ line0[0], line0[1], line0[1]+offset, line0[0]+offset])\n #print poly0\n if self.invert_elevations is None:\n invert_elevation0 = None\n else:\n invert_elevation0 = self.invert_elevations[0]\n\n enquiry_point0 = self.enquiry_points[0]\n\n #outward_vector0 = - self.culvert_vector\n self.inlets.append(inlet_enquiry.Inlet_enquiry(\n self.domain,\n poly0,\n enquiry_point0,\n invert_elevation = invert_elevation0,\n outward_culvert_vector = self.outward_vector_0,\n verbose = self.verbose))\n\n if force_constant_inlet_elevations:\n # Try to enforce a constant inlet elevation \n inlet_global_elevation = self.inlets[-1].get_average_elevation() \n self.inlets[-1].set_elevations(inlet_global_elevation)\n\n tris_0 = self.inlets[0].triangle_indices\n #print tris_0\n #print self.domain.centroid_coordinates[tris_0]\n\n line1 = self.exchange_lines[1]\n if self.apron is None:\n poly1 = line1\n else:\n offset = -self.apron*self.outward_vector_1\n #print line1\n #print offset\n poly1 = num.array([ line1[0], line1[1], line1[1]+offset, line1[0]+offset])\n #print poly1\n \n if self.invert_elevations is None:\n invert_elevation1 = None\n else:\n invert_elevation1 = self.invert_elevations[1]\n enquiry_point1 = self.enquiry_points[1]\n\n self.inlets.append(inlet_enquiry.Inlet_enquiry(\n self.domain,\n poly1,\n enquiry_point1,\n invert_elevation = invert_elevation1,\n outward_culvert_vector = self.outward_vector_1,\n verbose = self.verbose))\n\n if force_constant_inlet_elevations:\n # Try to enforce a constant inlet elevation \n inlet_global_elevation = self.inlets[-1].get_average_elevation() \n self.inlets[-1].set_elevations(inlet_global_elevation)\n\n tris_1 = self.inlets[1].triangle_indices\n \n self.set_logging(logging)\n\n \n\n\n\n def __call__(self):\n\n timestep = self.domain.get_timestep()\n \n Q, barrel_speed, outlet_depth = self.discharge_routine()\n\n old_inflow_depth = self.inflow.get_average_depth()\n old_inflow_stage = self.inflow.get_average_stage()\n old_inflow_xmom = self.inflow.get_average_xmom()\n old_inflow_ymom = self.inflow.get_average_ymom()\n\n # Implement the update of flow over a timestep by\n # using a semi-implict update. This ensures that\n # the update does not create a negative depth\n if old_inflow_depth > 0.0 :\n dt_Q_on_d = old_div(timestep*Q,old_inflow_depth)\n else:\n dt_Q_on_d = 0.0\n\n always_use_Q_wetdry_adjustment = self.always_use_Q_wetdry_adjustment\n use_Q_wetdry_adjustment = ((always_use_Q_wetdry_adjustment) |\\\n (old_inflow_depth*self.inflow.get_area() <= Q*timestep))\n # If we use the 'Q_adjustment', then the discharge is rescaled so that\n # the depth update is: \n # new_inflow_depth*inflow_area = \n # old_inflow_depth*inflow_area - \n # timestep*Q*(new_inflow_depth/old_inflow_depth)\n # The last term in () is a wet-dry improvement trick (which rescales Q)\n #\n # Before Feb 2015 this rescaling was always done (even if the flow was\n # not near wet-dry). Now if use_old_Q_adjustment=False, the rescaling\n # is only done if required to avoid drying\n #\n #\n factor = 1.0/(1.0 + old_div(dt_Q_on_d,self.inflow.get_area()))\n\n\n if use_Q_wetdry_adjustment:\n # FIXME:\n new_inflow_depth = old_inflow_depth*factor\n\n if(old_inflow_depth>0.):\n timestep_star = old_div(timestep*new_inflow_depth,old_inflow_depth)\n else:\n timestep_star = 0.\n\n else:\n new_inflow_depth = old_inflow_depth - old_div(timestep*Q,self.inflow.get_area())\n timestep_star = timestep\n\n if(self.use_old_momentum_method):\n # This method is here for consistency with the old version of the\n # routine\n new_inflow_xmom = old_inflow_xmom*factor\n new_inflow_ymom = old_inflow_ymom*factor\n\n else:\n # For the momentum balance, note that Q also advects the momentum,\n # The volumetric momentum flux should be Q*momentum/depth, where\n # momentum has an average value of new_inflow_mom (or\n # old_inflow_mom). We use old_inflow_depth for depth\n #\n # new_inflow_xmom*inflow_area = \n # old_inflow_xmom*inflow_area - \n # [timestep*Q]*new_inflow_xmom/old_inflow_depth\n # and:\n # new_inflow_ymom*inflow_area = \n # old_inflow_ymom*inflow_area - \n # [timestep*Q]*new_inflow_ymom/old_inflow_depth\n #\n # The units balance: m^2/s*m^2 = m^2/s*m^2 - s*m^3/s*m^2/s *m^(-1)\n #\n if old_inflow_depth > 0.:\n if use_Q_wetdry_adjustment:\n # Replace dt*Q with dt*Q*new_inflow_depth/old_inflow_depth = dt_Q_on_d*new_inflow_depth\n factor2 = 1.0/(1.0 + old_div(dt_Q_on_d*new_inflow_depth,(old_inflow_depth*self.inflow.get_area())))\n else:\n factor2 = 1.0/(1.0 + old_div(timestep*Q,(old_inflow_depth*self.inflow.get_area())))\n else:\n factor2 = 0.\n\n new_inflow_xmom = old_inflow_xmom*factor2\n new_inflow_ymom = old_inflow_ymom*factor2\n \n self.inflow.set_depths(new_inflow_depth)\n\n #inflow.set_xmoms(Q/inflow.get_area())\n #inflow.set_ymoms(0.0)\n\n self.inflow.set_xmoms(new_inflow_xmom)\n self.inflow.set_ymoms(new_inflow_ymom)\n\n loss = (old_inflow_depth - new_inflow_depth)*self.inflow.get_area()\n xmom_loss = (old_inflow_xmom - new_inflow_xmom)*self.inflow.get_area()\n ymom_loss = (old_inflow_ymom - new_inflow_ymom)*self.inflow.get_area()\n\n # set outflow\n outflow_extra_depth = old_div(Q*timestep_star,self.outflow.get_area())\n outflow_direction = - self.outflow.outward_culvert_vector\n #outflow_extra_momentum = outflow_extra_depth*barrel_speed*outflow_direction\n \n gain = outflow_extra_depth*self.outflow.get_area()\n \n #print gain, loss\n assert num.allclose(gain-loss, 0.0)\n \n # Stats\n self.accumulated_flow += gain\n self.discharge = old_div(Q*timestep_star,timestep) \n self.discharge_abs_timemean += old_div(gain,self.domain.yieldstep)\n self.velocity = barrel_speed\n self.outlet_depth = outlet_depth\n\n new_outflow_depth = self.outflow.get_average_depth() + outflow_extra_depth\n\n self.outflow.set_depths(new_outflow_depth)\n\n if self.use_momentum_jet:\n # FIXME (SR) Review momentum to account for possible hydraulic jumps at outlet\n # FIXME (GD) Depending on barrel speed I think this will be either\n # a source or sink of momentum (considering the momentum losses\n # above). Might not always be reasonable.\n #new_outflow_xmom = self.outflow.get_average_xmom() + outflow_extra_momentum[0]\n #new_outflow_ymom = self.outflow.get_average_ymom() + outflow_extra_momentum[1]\n new_outflow_xmom = barrel_speed*new_outflow_depth*outflow_direction[0]\n new_outflow_ymom = barrel_speed*new_outflow_depth*outflow_direction[1]\n \n elif self.zero_outflow_momentum:\n new_outflow_xmom = 0.0\n new_outflow_ymom = 0.0\n #new_outflow_xmom = outflow.get_average_xmom()\n #new_outflow_ymom = outflow.get_average_ymom()\n\n else:\n # Add the momentum lost from the inflow to the outflow. For\n # structures where barrel_speed is unknown + direction doesn't\n # change from inflow to outflow\n new_outflow_xmom = self.outflow.get_average_xmom() + old_div(xmom_loss,self.outflow.get_area())\n new_outflow_ymom = self.outflow.get_average_ymom() + old_div(ymom_loss,self.outflow.get_area())\n\n self.outflow.set_xmoms(new_outflow_xmom)\n self.outflow.set_ymoms(new_outflow_ymom)\n\n\n\n def set_culvert_height(self, height):\n\n self.culvert_height = height\n\n def set_culvert_width(self, width):\n\n self.culvert_width = width\n \n def set_culvert_z1(self, z1): \n\n self.culvert_z1 = z1 \n\n def set_culvert_z2(self, z2):\n\n self.culvert_z2 = z2\n \n def set_culvert_blockage(self, blockage): \n\n self.culvert_blockage = blockage \n\n def set_culvert_barrels(self, barrels): \n\n self.culvert_barrels = barrels \n \n \n def __process_non_skew_culvert(self):\n\n \"\"\"Create lines at the end of a culvert inlet and outlet.\n At either end two lines will be created; one for the actual flow to pass through and one a little further away\n for enquiring the total energy at both ends of the culvert and transferring flow.\n \"\"\"\n \n self.culvert_vector = self.end_points[1] - self.end_points[0]\n self.culvert_length = math.sqrt(num.sum(self.culvert_vector**2)) \n assert self.culvert_length > 0.0, 'The length of culvert is less than 0'\n \n self.culvert_vector /= self.culvert_length\n self.outward_vector_0 = self.culvert_vector\n self.outward_vector_1 = - self.culvert_vector\n\n \n culvert_normal = num.array([-self.culvert_vector[1], self.culvert_vector[0]]) # Normal vector\n w = 0.5*self.width*culvert_normal # Perpendicular vector of 1/2 width\n\n self.exchange_lines = []\n\n # Build exchange polyline and enquiry point\n if self.enquiry_points is None:\n \n gap = (self.apron + self.enquiry_gap)*self.culvert_vector\n self.enquiry_points = []\n \n for i in [0, 1]:\n p0 = self.end_points[i] + w\n p1 = self.end_points[i] - w\n self.exchange_lines.append(num.array([p0, p1]))\n ep = self.end_points[i] + (2*i - 1)*gap #(2*i - 1) determines the sign of the points\n self.enquiry_points.append(ep)\n \n else: \n for i in [0, 1]:\n p0 = self.end_points[i] + w\n p1 = self.end_points[i] - w\n self.exchange_lines.append(num.array([p0, p1]))\n \n \n def __process_skew_culvert(self): \n \n \"\"\"Compute skew culvert.\n If exchange lines are given, the enquiry points are determined. This is for enquiring \n the total energy at both ends of the culvert and transferring flow.\n \"\"\"\n \n centre_point0 = 0.5*(self.exchange_lines[0][0] + self.exchange_lines[0][1])\n centre_point1 = 0.5*(self.exchange_lines[1][0] + self.exchange_lines[1][1])\n\n n_exchange_0 = len(self.exchange_lines[0])\n n_exchange_1 = len(self.exchange_lines[1])\n\n assert n_exchange_0 == n_exchange_1, 'There should be the same number of points in both exchange_lines'\n\n if n_exchange_0 == 2:\n \n if self.end_points is None:\n self.culvert_vector = centre_point1 - centre_point0\n else:\n self.culvert_vector = self.end_points[1] - self.end_points[0]\n\n self.outward_vector_0 = self.culvert_vector\n self.outward_vector_1 = - self.culvert_vector\n\n\n elif n_exchange_0 == 4:\n\n self.outward_vector_0 = self.exchange_lines[0][3] - self.exchange_lines[0][2]\n self.outward_vector_1 = self.exchange_lines[1][3] - self.exchange_lines[1][2]\n\n self.culvert_vector = centre_point1 - centre_point0\n\n else:\n raise Exception('n_exchange_0 != 2 or 4')\n\n\n self.culvert_length = math.sqrt(num.sum(self.culvert_vector**2))\n assert self.culvert_length > 0.0, 'The length of culvert is less than 0'\n self.culvert_vector /= self.culvert_length\n\n outward_vector_0_length = math.sqrt(num.sum(self.outward_vector_0**2))\n assert outward_vector_0_length > 0.0, 'The length of outlet_vector_0 is less than 0'\n self.outward_vector_0 /= outward_vector_0_length\n\n outward_vector_1_length = math.sqrt(num.sum(self.outward_vector_1**2))\n assert outward_vector_1_length > 0.0, 'The length of outlet_vector_1 is less than 0'\n self.outward_vector_1 /= outward_vector_1_length\n\n\n if self.enquiry_points is None:\n \n gap = (self.apron + self.enquiry_gap)*self.culvert_vector\n \n self.enquiry_points = []\n\n self.enquiry_points.append(centre_point0 - gap)\n self.enquiry_points.append(centre_point1 + gap)\n \n\n def discharge_routine(self):\n\n msg = 'Need to implement '\n raise\n \n\n def statistics(self):\n\n\n message = '=====================================\\n'\n message += 'Structure Operator: %s\\n' % self.label\n message += '=====================================\\n'\n\n message += 'Structure Type: %s\\n' % self.structure_type\n\n message += 'Description\\n'\n message += '%s' % self.description\n \n #add the culvert dimensions, blockage factor here\n if self.structure_type == 'boyd_pipe':\n message += 'Culvert Diameter: %s\\n'% self.diameter\n message += 'Culvert Blockage: %s\\n'% self.blockage\n message += 'No. of barrels: %s\\n'% self.barrels\n elif self.structure_type == 'boyd_box':\n message += 'Culvert Height: %s\\n'% self.height\n message += 'Culvert Width: %s\\n'% self.width\n message += 'Culvert Blockage: %s\\n'% self.blockage\n message += 'No. of barrels: %s\\n'% self.barrels\n else:\n message += 'Culvert Height: %s\\n'% self.height\n message += 'Culvert Width: %s\\n'% self.width\n message += 'Batter Slope 1: %s\\n'% self.z1\n message += 'Batter Slope 2: %s\\n'% self.z2\n message += 'Culvert Blockage: %s\\n'% self.blockage\n message += 'No. of barrels: %s\\n'% self.barrels\n \n message += '\\n'\n \n for i, inlet in enumerate(self.inlets):\n message += '-------------------------------------\\n'\n message += 'Inlet %i\\n' % i\n message += '-------------------------------------\\n'\n\n message += 'inlet triangle indices and centres and elevations\\n'\n message += '%s' % inlet.triangle_indices\n message += '\\n'\n \n message += '%s' % self.domain.get_centroid_coordinates()[inlet.triangle_indices]\n message += '\\n'\n\n elev = self.domain.quantities['elevation'].centroid_values[inlet.triangle_indices]\n message += '%s' % elev\n message += '\\n'\n \n elevation_range = elev.max() - elev.min() \n if not num.allclose(elevation_range, 0.):\n message += 'Warning: non-constant inlet elevation can cause well-balancing problems'\n\n message += 'region\\n'\n message += '%s' % inlet.region\n message += '\\n'\n\n message += '=====================================\\n'\n\n return message\n\n\n def print_statistics(self):\n\n print(self.statistics())\n\n\n def print_timestepping_statistics(self):\n\n message = '---------------------------\\n'\n message += 'Structure report for %s:\\n' % self.label\n message += '--------------------------\\n'\n message += 'Type: %s\\n' % self.structure_type\n \n message += 'inlets[0]_enquiry_depth [m]: %.2f\\n' %self.inlets[0].get_enquiry_depth()\n message += 'inlets[0]_enquiry_speed [m/s]: %.2f\\n' %self.inlets[0].get_enquiry_speed()\n message += 'inlets[0]_enquiry_stage [m]: %.2f\\n' %self.inlets[0].get_enquiry_stage()\n message += 'inlets[0]_enquiry_elevation [m]: %.2f\\n' %self.inlets[0].get_enquiry_elevation()\n message += 'inlets[0]_average_depth [m]: %.2f\\n' %self.inlets[0].get_average_depth()\n message += 'inlets[0]_average_speed [m/s]: %.2f\\n' %self.inlets[0].get_average_speed()\n message += 'inlets[0]_average_stage [m]: %.2f\\n' %self.inlets[0].get_average_stage()\n message += 'inlets[0]_average_elevation [m]: %.2f\\n' %self.inlets[0].get_average_elevation()\n\n message += '\\n'\n \n message += 'inlets[1]_enquiry_depth [m]: %.2f\\n' %self.inlets[1].get_enquiry_depth()\n message += 'inlets[1]_enquiry_speed [m/s]: %.2f\\n' %self.inlets[1].get_enquiry_speed()\n message += 'inlets[1]_enquiry_stage [m]: %.2f\\n' %self.inlets[1].get_enquiry_stage()\n message += 'inlets[1]_enquiry_elevation [m]: %.2f\\n' %self.inlets[1].get_enquiry_elevation()\n\n message += 'inlets[1]_average_depth [m]: %.2f\\n' %self.inlets[1].get_average_depth()\n message += 'inlets[1]_average_speed [m/s]: %.2f\\n' %self.inlets[1].get_average_speed()\n message += 'inlets[1]_average_stage [m]: %.2f\\n' %self.inlets[1].get_average_stage()\n message += 'inlets[1]_average_elevation [m]: %.2f\\n' %self.inlets[1].get_average_elevation()\n\n \n message += 'Discharge [m^3/s]: %.2f\\n' % self.discharge\n message += 'Discharge_function_value [m^3/s]: %.2f\\n' % self.discharge_abs_timemean\n message += 'Velocity [m/s]: %.2f\\n' % self.velocity\n message += 'Outlet Depth [m]: %.2f\\n' % self.outlet_depth\n message += 'Accumulated Flow [m^3]: %.2f\\n' % self.accumulated_flow\n message += 'Inlet Driving Energy %.2f\\n' % self.driving_energy\n message += 'Delta Total Energy %.2f\\n' % self.delta_total_energy\n message += 'Control at this instant: %s\\n' % self.case\n \n\n\n\n print(message)\n\n\n def set_logging(self, flag=True):\n\n self.logging = flag\n\n # If flag is true open file with mode = \"w\" to form a clean file for logging\n if self.logging:\n self.log_filename = self.domain.get_datadir() + '/' + self.label + '.log'\n log_to_file(self.log_filename, self.statistics(), mode='w')\n log_to_file(self.log_filename, 'time, discharge_instantaneous, discharge_abs_timemean, velocity, accumulated_flow, driving_energy_instantaneous, delta_total_energy_instantaneous')\n\n #log_to_file(self.log_filename, self.culvert_type)\n\n\n def timestepping_statistics(self):\n\n message = '%.5f, ' % self.domain.get_time()\n message += '%.5f, ' % self.discharge\n message += '%.5f, ' % self.discharge_abs_timemean\n message += '%.5f, ' % self.velocity\n message += '%.5f, ' % self.accumulated_flow\n message += '%.5f, ' % self.driving_energy\n message += '%.5f' % self.delta_total_energy\n \n # Reset discharge_abs_timemean since last time this function was called\n # (FIXME: This assumes that the function is called only just after a\n # yield step)\n self.discharge_abs_timemean = 0.\n\n return message\n\n\n def get_inlets(self):\n \n return self.inlets\n \n \n def get_culvert_length(self):\n \n return self.culvert_length\n \n \n \n def get_culvert_slope(self):\n \n inlet0 = self.inlets[0]\n inlet1 = self.inlets[1]\n \n elev0 = inlet0.get_enquiry_invert_elevation()\n elev1 = inlet1.get_enquiry_invert_elevation()\n \n return old_div((elev1-elev0),self.get_culvert_length())\n \n \n \n def get_culvert_width(self):\n \n return self.width\n \n \n def get_culvert_diameter(self):\n \n return self.diameter\n \n \n def get_culvert_height(self):\n \n return self.height\n\n def get_culvert_z1(self):\n \n return self.z1 \n\n def get_culvert_z2(self):\n \n return self.z2\n\n def get_culvert_blockage(self):\n\t\t\n return self.blockage \n\n def get_culvert_barrels(self):\n\t\t\n return self.barrels\n \n def get_culvert_apron(self):\n\n return self.apron\n\n\n def get_master_proc(self):\n\n return 0\n\n\n\n #--------------------------------------------------------\n # Set of enquiry functions so that in the sequential and paralle case\n # we can get equiry info fron the master Proc\n #---------------------------------------------------------\n\n def get_enquiry_stages(self):\n\n enq0 = self.inlets[0].get_enquiry_stage()\n enq1 = self.inlets[1].get_enquiry_stage()\n\n return [enq0, enq1]\n\n\n def get_enquiry_depths(self):\n\n enq0 = self.inlets[0].get_enquiry_depth()\n enq1 = self.inlets[1].get_enquiry_depth()\n\n return [enq0, enq1]\n\n\n def get_enquiry_positions(self):\n\n enq0 = self.inlets[0].get_enquiry_position()\n enq1 = self.inlets[1].get_enquiry_position()\n\n return [enq0, enq1]\n\n\n def get_enquiry_xmoms(self):\n\n enq0 = self.inlets[0].get_enquiry_xmom()\n enq1 = self.inlets[1].get_enquiry_xmom()\n\n return [enq0, enq1]\n\n def get_enquiry_ymoms(self):\n\n enq0 = self.inlets[0].get_enquiry_ymom()\n enq1 = self.inlets[1].get_enquiry_ymom()\n\n return [enq0, enq1]\n\n\n def get_enquiry_elevations(self):\n\n enq0 = self.inlets[0].get_enquiry_elevation()\n enq1 = self.inlets[1].get_enquiry_elevation()\n\n return [enq0, enq1]\n\n\n\n def get_enquiry_water_depths(self):\n\n enq0 = self.inlets[0].get_enquiry_water_depth()\n enq1 = self.inlets[1].get_enquiry_water_depth()\n\n return [enq0, enq1]\n\n\n def get_enquiry_invert_elevations(self):\n\n enq0 = self.inlets[0].get_enquiry_invert_elevation()\n enq1 = self.inlets[1].get_enquiry_invert_elevation()\n\n return [enq0, enq1]\n\n\n def get_enquiry_velocitys(self):\n\n enq0 = self.inlets[0].get_enquiry_velocity()\n enq1 = self.inlets[1].get_enquiry_velocity()\n\n return [enq0, enq1]\n\n\n def get_enquiry_xvelocitys(self):\n\n enq0 = self.inlets[0].get_enquiry_xvelocity()\n enq1 = self.inlets[1].get_enquiry_xvelocity()\n\n return [enq0, enq1]\n\n def get_enquiry_yvelocitys(self):\n\n enq0 = self.inlets[0].get_enquiry_yvelocity()\n enq1 = self.inlets[1].get_enquiry_yvelocity()\n\n return [enq0, enq1]\n\n\n def get_enquiry_speeds(self):\n\n enq0 = self.inlets[0].get_enquiry_speed()\n enq1 = self.inlets[1].get_enquiry_speed()\n\n return [enq0, enq1]\n\n\n def get_enquiry_velocity_heads(self):\n\n enq0 = self.inlets[0].get_enquiry_velocity_head()\n enq1 = self.inlets[1].get_enquiry_velocity_head()\n\n return [enq0, enq1]\n\n\n def get_enquiry_total_energys(self):\n\n enq0 = self.inlets[0].get_enquiry_total_energy()\n enq1 = self.inlets[1].get_enquiry_total_energy()\n\n return [enq0, enq1]\n\n\n def get_enquiry_specific_energys(self):\n\n enq0 = self.inlets[0].get_enquiry_specific_energy()\n enq1 = self.inlets[1].get_enquiry_specific_energy()\n\n return [enq0, enq1]\n\n", "meta": {"hexsha": "41f954152cd8035300d2642125ae1d6c0ed80aff", "size": 28546, "ext": "py", "lang": "Python", "max_stars_repo_path": "anuga/structures/structure_operator.py", "max_stars_repo_name": "samcom12/anuga_core", "max_stars_repo_head_hexsha": "f4378114dbf02d666fe6423de45798add5c42806", "max_stars_repo_licenses": ["Python-2.0", "OLDAP-2.7"], "max_stars_count": 136, "max_stars_repo_stars_event_min_datetime": "2015-05-07T05:47:43.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-16T03:07:40.000Z", "max_issues_repo_path": "anuga/structures/structure_operator.py", "max_issues_repo_name": "samcom12/anuga_core", "max_issues_repo_head_hexsha": "f4378114dbf02d666fe6423de45798add5c42806", "max_issues_repo_licenses": ["Python-2.0", "OLDAP-2.7"], "max_issues_count": 184, "max_issues_repo_issues_event_min_datetime": "2015-05-03T09:27:54.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-20T04:22:48.000Z", "max_forks_repo_path": "anuga/structures/structure_operator.py", "max_forks_repo_name": "samcom12/anuga_core", "max_forks_repo_head_hexsha": "f4378114dbf02d666fe6423de45798add5c42806", "max_forks_repo_licenses": ["Python-2.0", "OLDAP-2.7"], "max_forks_count": 70, "max_forks_repo_forks_event_min_datetime": "2015-03-18T07:35:22.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-01T07:07:29.000Z", "avg_line_length": 34.6852976914, "max_line_length": 191, "alphanum_fraction": 0.5971414559, "include": true, "reason": "import numpy", "num_tokens": 7113, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.519521321952093, "lm_q2_score": 0.37754066879814546, "lm_q1q2_score": 0.19614042734468984}} {"text": "\"\"\"\nContains RDKit-related functions.\n\"\"\"\n\n# for handling ligand data and calculating ligand-related properties\nfrom rdkit import Chem \nfrom rdkit.Chem import Draw, AllChem, Descriptors\nimport numpy as np # for some more functionalities when using Pandas (e.g. for handling NaN values)\n\n\ndef create_molecule_object(input_type, input_value):\n \"\"\"\n This class is used to create an RDKit molecule object from various sources.\n It can be used to calculate or retrieve properties and descriptors (MW, h-bonds, etc.),\n generate images or SDF files or to perform similarity searches.\n\n Parameters\n ----------\n input_type : str\n Type of the input.\n Allowed input-types are: 'smiles', 'inchi', 'smarts', 'pdb_file'\n input_value : str\n Value of the corresponding input type.\n\n Returns\n -------\n rdkit.Chem.rdchem.Mol\n Structure as RDKit molecule object.\n \"\"\"\n\n functions = {\n \"smiles\": Chem.MolFromSmiles,\n \"inchi\": Chem.MolFromInchi,\n \"smarts\": Chem.MolFromSmarts,\n \"pdb_file\": Chem.MolFromPDBFile,\n }\n Molobj = functions[input_type](input_value)\n Molobj.smiles = Chem.MolToSmiles(Molobj)\n return Molobj\n\n\ndef draw_molecules(\n list_mol_objs,\n list_legends=None,\n mols_per_row=3,\n sub_img_size=(350, 350),\n filepath=None,\n):\n \"\"\"\n Take a list of RDKit molecule objects and draws them as a grid image.\n\n Parameters\n ----------\n list_mol_objs: list\n List of RDKit molecule objects to be drawn.\n list_legends: list\n Optional; default: None\n List of legends for the molecules.\n If not provided, the list indices (+1) will be used as legends.\n mols_per_row : int\n Optional; default: 3\n Number of structures to show per row.\n sub_img_size : tuple (int, int)\n Optional; default: (350, 350)\n Size of each structure.\n filepath : str or pathlib.Path\n Full filepath to save the image in.\n\n Returns\n -------\n rdkit.Chem.Draw.MolsToGridImage\n Molecules shown as grid.\n \"\"\"\n if list_legends is None:\n list_legends = list(map(str, range(1, len(list_mol_objs) + 1)))\n figure = Draw.MolsToGridImage(\n list_mol_objs,\n molsPerRow=mols_per_row,\n subImgSize=sub_img_size,\n legends=list(map(str, list_legends)),\n )\n if filepath is not None:\n with open(f\"{filepath}.png\", \"wb\") as f:\n f.write(figure.data)\n return figure\n\n\ndef save_molecule_image_to_file(mol_obj, filepath):\n \"\"\"\n Save the image of a single molecule as a PNG file.\n\n Parameters\n ----------\n mol_obj : rdkit.Chem.rdchem.Mol\n The molecule to be saved as image.\n filepath : str or pathlib.Path\n Full filpath to save the image in.\n \"\"\"\n Draw.MolToFile(mol_obj, f\"{filepath}.png\")\n\n\ndef save_3D_molecule_to_SDfile(mol_obj, filepath):\n \"\"\"\n Generate a 3D conformer and save as SDF file.\n\n Parameters\n ----------\n mol_obj : rdkit.Chem.rdchem.Mol\n The molecule to be saved as SDF file.\n filepath : str or pathlib.Path\n Full filpath to save the image in.\n \"\"\"\n mol = Chem.AddHs(mol_obj)\n embedding = AllChem.EmbedMolecule(mol, maxAttempts=1000, clearConfs=True)\n uffoptim = AllChem.UFFOptimizeMolecule(mol, maxIters=1000)\n # check if calculations converged (both should return 0 when converged)\n if embedding + uffoptim != 0:\n raise ValueError(\"Embedding/Optimization failed to converge.\")\n session = Chem.SDWriter(f\"{filepath}.sdf\")\n session.write(mol)\n session.close()\n\n\ndef calculate_similarity_dice(mol_obj1, mol_obj2, morgan_radius=2, morgan_nbits=4096):\n \"\"\"\n Calculate the Dice similarity between two molecules,\n based on 4096-bit Morgan fingerprints with a radius of 2.\n\n Parameters\n ----------\n mol_obj1 : rdkit.Chem.rdchem.Mol\n The first molecule.\n mol_obj2 : rdkit.Chem.rdchem.Mol\n The second molecule.\n morgan_radius : int\n Optional; default: 2\n The radius used to generate Morgan fingerprints.\n morgan_nbits : int\n Optional; default: 4096\n The number of bits in the Morgan fingerprints.\n Returns\n -------\n float\n Dice similarity between the two molecules rounded to two decimal places.\n \"\"\"\n morgan_fp_mol1 = AllChem.GetMorganFingerprintAsBitVect(\n mol_obj1, radius=morgan_radius, nBits=morgan_nbits\n )\n morgan_fp_mol2 = AllChem.GetMorganFingerprintAsBitVect(\n mol_obj2, radius=morgan_radius, nBits=morgan_nbits\n )\n dice_similarity = round(\n AllChem.DataStructs.DiceSimilarity(morgan_fp_mol1, morgan_fp_mol2), 2\n )\n return dice_similarity\n\n\ndef calculate_druglikeness(mol_obj):\n \"\"\"\n Calculate several molecular properties and drug-likeness scores,\n from an RDKit molecule object.\n\n Parameters\n ----------\n mol_obj: rdkit.Chem.rdchem.Mol\n Molecule object of interest.\n\n Returns\n -------\n dict\n The calculated values are returned in a dictionary with following keys:\n MolWt, NumHAcceptors, NumHDonors, MolLogP, TPSA, NumRotBonds, Saturation,\n lipinski_score, custom_drug_score, qed_score, total_drug_score\n \"\"\"\n properties = {\n \"mol_weight\": round(Descriptors.MolWt(mol_obj), 3),\n \"num_H_acceptors\": Descriptors.NumHAcceptors(mol_obj),\n \"num_H_donors\": Descriptors.NumHDonors(mol_obj),\n \"logp\": round(Descriptors.MolLogP(mol_obj), 2),\n \"tpsa\": round(Descriptors.TPSA(mol_obj), 2),\n \"num_rot_bonds\": Descriptors.NumRotatableBonds(mol_obj),\n \"saturation\": round(Descriptors.FractionCSP3(mol_obj), 2),\n \"drug_score_qed\": round(Descriptors.qed(mol_obj), 2),\n }\n\n # Calculating Lipinski score\n l1 = int(properties[\"mol_weight\"] < 500)\n l2 = int(properties[\"num_H_acceptors\"] <= 10)\n l3 = int(properties[\"num_H_donors\"] <= 5)\n l4 = int(properties[\"logp\"] < 5)\n properties[\"drug_score_lipinski\"] = round((l1 + l2 + l3 + l4) / 4, 2)\n\n # Calculating druglikeness score with custom scoring functions\n # derived from Hopkins paper: https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3524573/\n def molWt_score(molWt):\n if molWt <= 440:\n return np.exp(-((molWt - 300) ** 2) / 15000)\n else:\n return np.exp(-(molWt - 180) / 190) + 0.01\n\n def molLogP_score(molLogP):\n return np.exp(-((molLogP - 2.5) ** 2) / 9)\n\n def numHDonors_score(numHDonors):\n if numHDonors == 0:\n return 0.6\n elif numHDonors < 5:\n return np.exp(-((numHDonors - 1) ** 2) / 5)\n else:\n return np.exp(-((numHDonors - 1) ** 2) / 5) + (0.4 / numHDonors)\n\n def numHAcceptors_score(numHAcceptors):\n if numHAcceptors < 4:\n return np.exp(-((numHAcceptors - 3) ** 2) / 3)\n else:\n return np.exp(-0.3 * numHAcceptors / 0.8 + 1.4)\n\n def TPSA_score(TPSA):\n if TPSA < 50:\n return 0.015 * TPSA + 0.25\n else:\n return np.exp(-((TPSA - 50) ** 2) / 8000)\n\n def numRotBonds_score(numRotBonds):\n if numRotBonds < 10:\n return np.exp(-((numRotBonds - 4) ** 2) / 19)\n else:\n return np.exp(-((numRotBonds - 4) ** 2) / 19) + (1.5 / numRotBonds ** 1.5)\n\n def saturation_score(saturation):\n return np.exp(-((saturation - 0.625) ** 2) / 0.05)\n\n d1 = molWt_score(properties[\"mol_weight\"])\n d2 = numHAcceptors_score(properties[\"num_H_acceptors\"])\n d3 = numHDonors_score(properties[\"num_H_donors\"])\n d4 = molLogP_score(properties[\"logp\"])\n d5 = TPSA_score(properties[\"tpsa\"])\n d6 = numRotBonds_score(properties[\"num_rot_bonds\"])\n d7 = saturation_score(properties[\"saturation\"])\n properties[\"drug_score_custom\"] = round((d1 + d2 + d3 + d4 + d5 + d6 + d7) / 7, 2)\n\n properties[\"drug_score_total\"] = round(\n (\n 3 * properties[\"drug_score_qed\"]\n + 2 * properties[\"drug_score_custom\"]\n + properties[\"drug_score_lipinski\"]\n )\n / 6,\n 2,\n )\n return properties\n", "meta": {"hexsha": "c0e186e94c7c79d96614c3e1d00b2308cf391c21", "size": 8111, "ext": "py", "lang": "Python", "max_stars_repo_path": "teachopencadd/talktorials/T018_automated_cadd_pipeline/utils/helpers/rdkit.py", "max_stars_repo_name": "volkamerlab/TeachOpenCADD", "max_stars_repo_head_hexsha": "bccfe61e03b14278e19baa30fc60c9e4a26b3047", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 155, "max_stars_repo_stars_event_min_datetime": "2018-11-09T16:54:47.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-26T16:19:54.000Z", "max_issues_repo_path": "teachopencadd/talktorials/T018_automated_cadd_pipeline/utils/helpers/rdkit.py", "max_issues_repo_name": "volkamerlab/TeachOpenCADD", "max_issues_repo_head_hexsha": "bccfe61e03b14278e19baa30fc60c9e4a26b3047", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 52, "max_issues_repo_issues_event_min_datetime": "2019-04-10T01:12:32.000Z", "max_issues_repo_issues_event_max_datetime": "2020-10-26T12:51:15.000Z", "max_forks_repo_path": "teachopencadd/talktorials/T018_automated_cadd_pipeline/utils/helpers/rdkit.py", "max_forks_repo_name": "volkamerlab/TeachOpenCADD", "max_forks_repo_head_hexsha": "bccfe61e03b14278e19baa30fc60c9e4a26b3047", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 59, "max_forks_repo_forks_event_min_datetime": "2018-12-01T14:13:55.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-26T08:41:23.000Z", "avg_line_length": 32.1865079365, "max_line_length": 100, "alphanum_fraction": 0.6360498089, "include": true, "reason": "import numpy", "num_tokens": 2269, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.519521321952093, "lm_q2_score": 0.37754066879814546, "lm_q1q2_score": 0.19614042734468984}} {"text": "import random\n\nimport numpy as np\n\nfrom .meta_gf import GFMeta\nfrom .linalg import dot, inner, outer, matrix_rank, solve, inv, det, row_reduce, lu_decompose, lup_decompose\nfrom .overrides import set_module\nfrom .poly_conversion import integer_to_poly, poly_to_str, str_to_integer\n\n__all__ = [\"GFArray\"]\n\n\nUNSUPPORTED_ONE_ARG_FUNCTIONS = [\n np.packbits, np.unpackbits,\n np.unwrap,\n np.around, np.round_, np.fix,\n np.gradient, np.trapz,\n np.i0, np.sinc,\n np.angle, np.real, np.imag, np.conj, np.conjugate,\n]\n\nUNSUPPORTED_TWO_ARG_FUNCTIONS = [\n np.lib.scimath.logn,\n np.cross,\n]\n\nUNSUPPORTED_FUNCTIONS = UNSUPPORTED_ONE_ARG_FUNCTIONS + UNSUPPORTED_TWO_ARG_FUNCTIONS\n\nOVERRIDDEN_FUNCTIONS = {\n np.dot: dot,\n np.inner: inner,\n np.outer: outer,\n # np.tensordot: \"tensordot\",\n np.linalg.matrix_rank: matrix_rank,\n np.linalg.inv: inv,\n np.linalg.det: det,\n np.linalg.solve: solve\n}\n\nFUNCTIONS_REQUIRING_VIEW = [\n np.copy, np.concatenate,\n np.broadcast_to,\n np.trace,\n]\n\nUNSUPPORTED_ONE_ARG_UFUNCS = [\n np.invert, np.sqrt,\n np.log2, np.log10,\n np.exp, np.expm1, np.exp2,\n np.sin, np.cos, np.tan,\n np.sinh, np.cosh, np.tanh,\n np.arcsin, np.arccos, np.arctan,\n np.arcsinh, np.arccosh, np.arctanh,\n np.degrees, np.radians,\n np.deg2rad, np.rad2deg,\n np.floor, np.ceil, np.trunc, np.rint,\n]\n\nUNSUPPORTED_TWO_ARG_UFUNCS = [\n np.hypot, np.arctan2,\n np.logaddexp, np.logaddexp2,\n np.remainder,\n np.fmod, np.modf,\n np.fmin, np.fmax,\n]\n\nUNSUPPORTED_UFUNCS = UNSUPPORTED_ONE_ARG_UFUNCS + UNSUPPORTED_TWO_ARG_UFUNCS\n\nOVERRIDDEN_UFUNCS = {\n np.add: \"_ufunc_add\",\n np.subtract: \"_ufunc_subtract\",\n np.multiply: \"_ufunc_multiply\",\n np.floor_divide: \"_ufunc_divide\",\n np.true_divide: \"_ufunc_divide\",\n np.negative: \"_ufunc_negative\",\n np.reciprocal: \"_ufunc_reciprocal\",\n np.power: \"_ufunc_power\",\n np.square: \"_ufunc_square\",\n np.log: \"_ufunc_log\",\n np.matmul: \"_ufunc_matmul\",\n}\n\nUFUNCS_REQUIRING_VIEW = [\n np.bitwise_and, np.bitwise_or, np.bitwise_xor,\n np.left_shift, np.right_shift,\n]\n\n\n@set_module(\"galois\")\nclass GFArray(np.ndarray, metaclass=GFMeta):\n \"\"\"\n Create an array over :math:`\\\\mathrm{GF}(p^m)`.\n\n The :obj:`galois.GFArray` class is a parent class for all Galois field array classes. Any Galois field :math:`\\\\mathrm{GF}(p^m)`\n with prime characteristic :math:`p` and positive integer :math:`m`, can be constructed by calling the class factory\n `galois.GF(p**m)`.\n\n Warning\n -------\n This is an abstract base class for all Galois field array classes. :obj:`galois.GFArray` cannot be instantiated\n directly. Instead, Galois field array classes are created using :obj:`galois.GF`.\n\n For example, one can create the :math:`\\\\mathrm{GF}(7)` field array class as follows:\n\n .. ipython:: python\n\n GF7 = galois.GF(7)\n print(GF7)\n\n This subclass can then be used to instantiate arrays over :math:`\\\\mathrm{GF}(7)`.\n\n .. ipython:: python\n\n GF7([3,5,0,2,1])\n GF7.Random((2,5))\n\n :obj:`galois.GFArray` is a subclass of :obj:`numpy.ndarray`. The :obj:`galois.GFArray` constructor has the same syntax as\n :obj:`numpy.array`. The returned :obj:`galois.GFArray` object is an array that can be acted upon like any other\n numpy array.\n\n Parameters\n ----------\n array : array_like\n The input array to be converted to a Galois field array. The input array is copied, so the original array\n is unmodified by changes to the Galois field array. Valid input array types are :obj:`numpy.ndarray`,\n :obj:`list` or :obj:`tuple` of ints or strs, :obj:`int`, or :obj:`str`.\n dtype : numpy.dtype, optional\n The :obj:`numpy.dtype` of the array elements. The default is `None` which represents the smallest valid\n dtype for this class, i.e. the first element in :obj:`galois.GFMeta.dtypes`.\n copy : bool, optional\n The `copy` keyword argument from :obj:`numpy.array`. The default is `True` which makes a copy of the input\n object is it's an array.\n order : str, optional\n The `order` keyword argument from :obj:`numpy.array`. Valid values are `\"K\"` (default), `\"A\"`, `\"C\"`, or `\"F\"`.\n ndmin : int, optional\n The `ndmin` keyword argument from :obj:`numpy.array`. The minimum number of dimensions of the output.\n The default is 0.\n\n Returns\n -------\n galois.GFArray\n The copied input array as a :math:`\\\\mathrm{GF}(p^m)` field array.\n\n Examples\n --------\n Construct various kinds of Galois fields using :obj:`galois.GF`.\n\n .. ipython:: python\n\n # Construct a GF(2^m) class\n GF256 = galois.GF(2**8); print(GF256)\n\n # Construct a GF(p) class\n GF571 = galois.GF(571); print(GF571)\n\n # Construct a very large GF(2^m) class\n GF2m = galois.GF(2**100); print(GF2m)\n\n # Construct a very large GF(p) class\n GFp = galois.GF(36893488147419103183); print(GFp)\n\n Depending on the field's order (size), only certain `dtype` values will be supported.\n\n .. ipython:: python\n\n GF256.dtypes\n GF571.dtypes\n\n Very large fields, which can't be represented using `np.int64`, can only be represented as `dtype=np.object_`.\n\n .. ipython:: python\n\n GF2m.dtypes\n GFp.dtypes\n\n Newly-created arrays will use the smallest, valid dtype.\n\n .. ipython:: python\n\n a = GF256.Random(10); a\n a.dtype\n\n This can be explicitly set by specifying the `dtype` keyword argument.\n\n .. ipython:: python\n\n a = GF256.Random(10, dtype=np.uint32); a\n a.dtype\n\n Arrays can also be created explicitly by converting an \"array-like\" object.\n\n .. ipython:: python\n\n # Construct a Galois field array from a list\n l = [142, 27, 92, 253, 103]; l\n GF256(l)\n\n # Construct a Galois field array from an existing numpy array\n x_np = np.array(l, dtype=np.int64); x_np\n GF256(l)\n\n Arrays can also be created by \"view casting\" from an existing numpy array. This avoids\n a copy operation, which is especially useful for large data already brought into memory.\n\n .. ipython:: python\n\n a = x_np.view(GF256); a\n\n # Changing `x_np` will change `a`\n x_np[0] = 0; x_np\n a\n \"\"\"\n\n def __new__(cls, array, dtype=None, copy=True, order=\"K\", ndmin=0):\n if cls is GFArray:\n raise NotImplementedError(\"GFArray is an abstract base class that cannot be directly instantiated. Instead, create a GFArray subclass using `galois.GF`.\")\n return cls._array(array, dtype=dtype, copy=copy, order=order, ndmin=ndmin)\n\n @classmethod\n def _get_dtype(cls, dtype):\n if dtype is None:\n return cls.dtypes[0]\n\n # Convert \"dtype\" to a numpy dtype. This does platform specific conversion, if necessary.\n # For example, np.dtype(int) == np.int64 (on some systems).\n dtype = np.dtype(dtype)\n if dtype not in cls.dtypes:\n raise TypeError(f\"{cls.name} arrays only support dtypes {[np.dtype(d).name for d in cls.dtypes]}, not '{dtype.name}'.\")\n\n return dtype\n\n @classmethod\n def _array(cls, array_like, dtype=None, copy=True, order=\"K\", ndmin=0):\n dtype = cls._get_dtype(dtype)\n array_like = cls._check_array_like_object(array_like)\n array = np.array(array_like, dtype=dtype, copy=copy, order=order, ndmin=ndmin)\n return array.view(cls)\n\n @classmethod\n def _check_array_like_object(cls, array_like):\n if isinstance(array_like, str):\n # Convert the string to an integer\n array_like = str_to_integer(array_like, cls.prime_subfield)\n\n if isinstance(array_like, (int, np.integer)):\n # Just check that the single int is in range\n cls._check_array_values(array_like)\n\n elif isinstance(array_like, (list, tuple)):\n # Recursively check the items in the iterable to ensure they're of the correct type\n # and that their values are in range\n array_like = cls._check_iterable_types_and_values(array_like)\n\n elif isinstance(array_like, np.ndarray):\n if array_like.dtype == np.object_:\n array_like = cls._check_array_types_dtype_object(array_like)\n elif not np.issubdtype(array_like.dtype, np.integer):\n raise TypeError(f\"{cls.name} arrays must have integer dtypes, not {array_like.dtype}.\")\n cls._check_array_values(array_like)\n\n else:\n raise TypeError(f\"{cls.name} arrays can be created with scalars of type int, not {type(array_like)}.\")\n\n return array_like\n\n @classmethod\n def _check_iterable_types_and_values(cls, iterable):\n new_iterable = []\n for item in iterable:\n if isinstance(item, (list, tuple)):\n item = cls._check_iterable_types_and_values(item)\n new_iterable.append(item)\n continue\n\n if isinstance(item, str):\n item = str_to_integer(item, cls.prime_subfield)\n elif not isinstance(item, (int, np.integer, cls)):\n raise TypeError(f\"When {cls.name} arrays are created/assigned with an iterable, each element must be an integer. Found type {type(item)}.\")\n\n if not 0 <= item < cls.order:\n raise ValueError(f\"{cls.name} arrays must have elements in 0 <= x < {cls.order}, not {item}.\")\n\n # Ensure the type is int so dtype=object classes don't get all mixed up\n new_iterable.append(int(item))\n\n return new_iterable\n\n @classmethod\n def _check_array_types_dtype_object(cls, array):\n if array.size == 0:\n return array\n if array.ndim == 0:\n if not isinstance(array[()], (int, np.integer, cls)):\n raise TypeError(f\"When {cls.name} arrays are created/assigned with a numpy array with dtype=object, each element must be an integer. Found type {type(array[()])}.\")\n return int(array)\n\n iterator = np.nditer(array, flags=[\"multi_index\", \"refs_ok\"])\n for _ in iterator:\n a = array[iterator.multi_index]\n if not isinstance(a, (int, np.integer, cls)):\n raise TypeError(f\"When {cls.name} arrays are created/assigned with a numpy array with dtype=object, each element must be an integer. Found type {type(a)}.\")\n\n # Ensure the type is int so dtype=object classes don't get all mixed up\n array[iterator.multi_index] = int(a)\n\n return array\n\n @classmethod\n def _check_array_values(cls, array):\n if not isinstance(array, np.ndarray):\n # Convert single integer to array so next step doesn't fail\n array = np.array(array)\n\n # Check the value of the \"field elements\" and make sure they are valid\n if np.any(array < 0) or np.any(array >= cls.order):\n idxs = np.logical_or(array < 0, array >= cls.order)\n raise ValueError(f\"{cls.name} arrays must have elements in 0 <= x < {cls.order}, not {array[idxs]}.\")\n\n ###############################################################################\n # Alternate constructors\n ###############################################################################\n\n @classmethod\n def Zeros(cls, shape, dtype=None):\n \"\"\"\n Creates a Galois field array with all zeros.\n\n Parameters\n ----------\n shape : tuple\n A numpy-compliant `shape` tuple, see :obj:`numpy.ndarray.shape`. An empty tuple `()` represents a scalar.\n A single integer or 1-tuple, e.g. `N` or `(N,)`, represents the size of a 1-dim array. An n-tuple, e.g.\n `(M,N)`, represents an n-dim array with each element indicating the size in each dimension.\n dtype : numpy.dtype, optional\n The :obj:`numpy.dtype` of the array elements. The default is `None` which represents the smallest valid\n dtype for this class, i.e. the first element in :obj:`galois.GFMeta.dtypes`.\n\n Returns\n -------\n galois.GFArray\n A Galois field array of zeros.\n\n Examples\n --------\n .. ipython:: python\n\n GF = galois.GF(31)\n GF.Zeros((2,5))\n \"\"\"\n dtype = cls._get_dtype(dtype)\n array = np.zeros(shape, dtype=dtype)\n return array.view(cls)\n\n @classmethod\n def Ones(cls, shape, dtype=None):\n \"\"\"\n Creates a Galois field array with all ones.\n\n Parameters\n ----------\n shape : tuple\n A numpy-compliant `shape` tuple, see :obj:`numpy.ndarray.shape`. An empty tuple `()` represents a scalar.\n A single integer or 1-tuple, e.g. `N` or `(N,)`, represents the size of a 1-dim array. An n-tuple, e.g.\n `(M,N)`, represents an n-dim array with each element indicating the size in each dimension.\n dtype : numpy.dtype, optional\n The :obj:`numpy.dtype` of the array elements. The default is `None` which represents the smallest valid\n dtype for this class, i.e. the first element in :obj:`galois.GFMeta.dtypes`.\n\n Returns\n -------\n galois.GFArray\n A Galois field array of ones.\n\n Examples\n --------\n .. ipython:: python\n\n GF = galois.GF(31)\n GF.Ones((2,5))\n \"\"\"\n dtype = cls._get_dtype(dtype)\n array = np.ones(shape, dtype=dtype)\n return array.view(cls)\n\n @classmethod\n def Identity(cls, size, dtype=None):\n \"\"\"\n Creates an :math:`n \\\\times n` identity matrix over :math:`\\\\mathrm{GF}(q)`.\n\n Parameters\n ----------\n size : int\n The size :math:`n` along one axis of the matrix. The resulting array has shape `(size,size)`.\n dtype : numpy.dtype, optional\n The :obj:`numpy.dtype` of the array elements. The default is `None` which represents the smallest valid\n dtype for this class, i.e. the first element in :obj:`galois.GFMeta.dtypes`.\n\n Returns\n -------\n galois.GFArray\n A Galois field identity matrix of shape `(size, size)`.\n\n Examples\n --------\n .. ipython:: python\n\n GF = galois.GF(31)\n GF.Identity(4)\n \"\"\"\n dtype = cls._get_dtype(dtype)\n array = np.identity(size, dtype=dtype)\n return array.view(cls)\n\n @classmethod\n def Vandermonde(cls, a, m, n, dtype=None):\n \"\"\"\n Creates a :math:`m \\\\times n` Vandermonde matrix of :math:`a \\\\in \\\\mathrm{GF}(q)`.\n\n Parameters\n ----------\n a : int, galois.GFArray\n An element of :math:`\\\\mathrm{GF}(q)`.\n m : int\n The number of rows in the Vandermonde matrix.\n n : int\n The number of columns in the Vandermonde matrix.\n dtype : numpy.dtype, optional\n The :obj:`numpy.dtype` of the array elements. The default is `None` which represents the smallest valid\n dtype for this class, i.e. the first element in :obj:`galois.GFMeta.dtypes`.\n\n Returns\n -------\n galois.GFArray\n The :math:`m \\\\times n` Vandermonde matrix.\n\n Examples\n --------\n .. ipython:: python\n\n GF = galois.GF(2**3)\n a = GF.primitive_element\n V = GF.Vandermonde(a, 7, 7)\n with GF.display(\"power\"):\n print(V)\n \"\"\"\n if not isinstance(a, (int, np.integer,cls)):\n raise TypeError(f\"Argument `a` must be an integer or element of {cls.name}, not {type(a)}.\")\n if not isinstance(m, (int, np.integer)):\n raise TypeError(f\"Argument `m` must be an integer, not {type(m)}.\")\n if not isinstance(n, (int, np.integer)):\n raise TypeError(f\"Argument `n` must be an integer, not {type(n)}.\")\n if not m > 0:\n raise ValueError(f\"Argument `m` must be non-negative, not {m}.\")\n if not n > 0:\n raise ValueError(f\"Argument `n` must be non-negative, not {n}.\")\n\n dtype = cls._get_dtype(dtype)\n a = cls(a, dtype=dtype)\n if not a.ndim == 0:\n raise ValueError(f\"Argument `a` must be a scalar, not {a.ndim}-D.\")\n\n v = a ** np.arange(0, m)\n V = np.power.outer(v, np.arange(0, n))\n\n return V\n\n @classmethod\n def Range(cls, start, stop, step=1, dtype=None):\n \"\"\"\n Creates a Galois field array with a range of field elements.\n\n Parameters\n ----------\n start : int\n The starting value (inclusive).\n stop : int\n The stopping value (exclusive).\n step : int, optional\n The space between values. The default is 1.\n dtype : numpy.dtype, optional\n The :obj:`numpy.dtype` of the array elements. The default is `None` which represents the smallest valid\n dtype for this class, i.e. the first element in :obj:`galois.GFMeta.dtypes`.\n\n Returns\n -------\n galois.GFArray\n A Galois field array of a range of field elements.\n\n Examples\n --------\n .. ipython:: python\n\n GF = galois.GF(31)\n GF.Range(10,20)\n \"\"\"\n dtype = cls._get_dtype(dtype)\n if not stop <= cls.order:\n raise ValueError(f\"The stopping value must be less than the field order of {cls.order}, not {stop}.\")\n\n if dtype != np.object_:\n array = np.arange(start, stop, step=step, dtype=dtype)\n else:\n array = np.array(range(start, stop, step), dtype=dtype)\n\n return array.view(cls)\n\n @classmethod\n def Random(cls, shape=(), low=0, high=None, dtype=None):\n \"\"\"\n Creates a Galois field array with random field elements.\n\n Parameters\n ----------\n shape : tuple\n A numpy-compliant `shape` tuple, see :obj:`numpy.ndarray.shape`. An empty tuple `()` represents a scalar.\n A single integer or 1-tuple, e.g. `N` or `(N,)`, represents the size of a 1-dim array. An n-tuple, e.g.\n `(M,N)`, represents an n-dim array with each element indicating the size in each dimension.\n low : int, optional\n The lowest value (inclusive) of a random field element. The default is 0.\n high : int, optional\n The highest value (exclusive) of a random field element. The default is `None` which represents the\n field's order :math:`p^m`.\n dtype : numpy.dtype, optional\n The :obj:`numpy.dtype` of the array elements. The default is `None` which represents the smallest valid\n dtype for this class, i.e. the first element in :obj:`galois.GFMeta.dtypes`.\n\n Returns\n -------\n galois.GFArray\n A Galois field array of random field elements.\n\n Examples\n --------\n .. ipython:: python\n\n GF = galois.GF(31)\n GF.Random((2,5))\n \"\"\"\n dtype = cls._get_dtype(dtype)\n high = cls.order if high is None else high\n if not 0 <= low < high <= cls.order:\n raise ValueError(f\"Arguments must satisfy `0 <= low < high <= order`, not `0 <= {low} < {high} <= {cls.order}`.\")\n\n if dtype != np.object_:\n array = np.random.randint(low, high, shape, dtype=dtype)\n else:\n array = np.empty(shape, dtype=dtype)\n iterator = np.nditer(array, flags=[\"multi_index\", \"refs_ok\"])\n for _ in iterator:\n array[iterator.multi_index] = random.randint(low, high - 1)\n\n return array.view(cls)\n\n @classmethod\n def Elements(cls, dtype=None):\n \"\"\"\n Creates a Galois field array of the field's elements :math:`\\\\{0, \\\\dots, p^m-1\\\\}`.\n\n Parameters\n ----------\n dtype : numpy.dtype, optional\n The :obj:`numpy.dtype` of the array elements. The default is `None` which represents the smallest valid\n dtype for this class, i.e. the first element in :obj:`galois.GFMeta.dtypes`.\n\n Returns\n -------\n galois.GFArray\n A Galois field array of all the field's elements.\n\n Examples\n --------\n .. ipython:: python\n\n GF = galois.GF(31)\n GF.Elements()\n \"\"\"\n return cls.Range(0, cls.order, step=1, dtype=dtype)\n\n @classmethod\n def Vector(cls, array, dtype=None):\n \"\"\"\n Creates a Galois field array over :math:`\\\\mathrm{GF}(p^m)` from length-:math:`m` vectors over the prime subfield :math:`\\\\mathrm{GF}(p)`.\n\n Parameters\n ----------\n array : array_like\n The input array with field elements in :math:`\\\\mathrm{GF}(p)` to be converted to a Galois field array in :math:`\\\\mathrm{GF}(p^m)`.\n The last dimension of the input array must be :math:`m`. An input array with shape `(n1, n2, m)` has output shape `(n1, n2)`.\n dtype : numpy.dtype, optional\n The :obj:`numpy.dtype` of the array elements. The default is `None` which represents the smallest valid\n dtype for this class, i.e. the first element in :obj:`galois.GFMeta.dtypes`.\n\n Returns\n -------\n galois.GFArray\n A Galois field array over :math:`\\\\mathrm{GF}(p^m)`.\n\n Examples\n --------\n .. ipython:: python\n\n GF = galois.GF(2**6)\n vec = galois.GF2.Random((3,6)); vec\n a = GF.Vector(vec); a\n with GF.display(\"poly\"):\n print(a)\n a.vector()\n \"\"\"\n order = cls.prime_subfield.order\n degree = cls.degree\n array = cls.prime_subfield(array).view(np.ndarray).astype(cls.dtypes[-1]) # Use the largest dtype so computation doesn't overflow\n if not array.shape[-1] == degree:\n raise ValueError(f\"The last dimension of `array` must be the field extension dimension {cls.degree}, not {array.shape[-1]}.\")\n degrees = np.arange(degree - 1, -1, -1, dtype=cls.dtypes[-1])\n array = np.sum(array * order**degrees, axis=-1)\n return cls(array, dtype=dtype)\n\n ###############################################################################\n # Array methods\n ###############################################################################\n\n def vector(self, dtype=None):\n \"\"\"\n Converts the Galois field array over :math:`\\\\mathrm{GF}(p^m)` to length-:math:`m` vectors over the prime subfield :math:`\\\\mathrm{GF}(p)`.\n\n For an input array with shape `(n1, n2)`, the output shape is `(n1, n2, m)`.\n\n Parameters\n ----------\n dtype : numpy.dtype, optional\n The :obj:`numpy.dtype` of the array elements. The default is `None` which represents the smallest valid\n dtype for this class, i.e. the first element in :obj:`galois.GFMeta.dtypes`.\n\n Returns\n -------\n galois.GFArray\n A Galois field array of length-:math:`m` vectors over :math:`\\\\mathrm{GF}(p)`.\n\n Examples\n --------\n .. ipython:: python\n\n GF = galois.GF(2**6)\n a = GF.Random(3); a\n vec = a.vector(); vec\n GF.Vector(vec)\n \"\"\"\n order = type(self).prime_subfield.order\n degree = type(self).degree\n array = self.view(np.ndarray)\n array = np.repeat(array, degree).reshape(*array.shape, degree)\n x = 0\n for i in range(degree):\n q = (array[...,i] - x) // order**(degree - 1 - i)\n array[...,i] = q\n x += q*order**(degree - 1 - i)\n return type(self).prime_subfield(array, dtype=dtype)\n\n def row_reduce(self, ncols=None):\n \"\"\"\n Performs Gaussian elimination on the matrix to achieve reduced row echelon form.\n\n **Row reduction operations**\n\n 1. Swap the position of any two rows.\n 2. Multiply a row by a non-zero scalar.\n 3. Add one row to a scalar multiple of another row.\n\n Parameters\n ----------\n ncols : int, optional\n The number of columns to perform Gaussian elimination over. The default is `None` which represents\n the number of columns of the input array.\n\n Returns\n -------\n galois.GFArray\n The reduced row echelon form of the input array.\n\n Examples\n --------\n .. ipython:: python\n\n GF = galois.GF(31)\n A = GF.Random((4,4)); A\n A.row_reduce()\n np.linalg.matrix_rank(A)\n\n One column is a linear combination of another.\n\n .. ipython:: python\n\n GF = galois.GF(31)\n A = GF.Random((4,4)); A\n A[:,2] = A[:,1] * GF(17); A\n A.row_reduce()\n np.linalg.matrix_rank(A)\n\n One row is a linear combination of another.\n\n .. ipython:: python\n\n GF = galois.GF(31)\n A = GF.Random((4,4)); A\n A[3,:] = A[2,:] * GF(8); A\n A.row_reduce()\n np.linalg.matrix_rank(A)\n \"\"\"\n return row_reduce(self, ncols=ncols)\n\n def lu_decompose(self):\n \"\"\"\n Decomposes the input array into the product of lower and upper triangular matrices.\n\n Returns\n -------\n galois.GFArray\n The lower triangular matrix.\n galois.GFArray\n The upper triangular matrix.\n\n Examples\n --------\n .. ipython:: python\n\n GF = galois.GF(5)\n\n # Not every square matrix has an LU decomposition\n A = GF([[2, 4, 4, 1], [3, 3, 1, 4], [4, 3, 4, 2], [4, 4, 3, 1]])\n L, U = A.lu_decompose()\n L\n U\n\n # A = L U\n np.array_equal(A, L @ U)\n \"\"\"\n return lu_decompose(self)\n\n def lup_decompose(self):\n \"\"\"\n Decomposes the input array into the product of lower and upper triangular matrices using partial pivoting.\n\n Returns\n -------\n galois.GFArray\n The lower triangular matrix.\n galois.GFArray\n The upper triangular matrix.\n galois.GFArray\n The permutation matrix.\n\n Examples\n --------\n .. ipython:: python\n\n GF = galois.GF(5)\n A = GF([[1, 3, 2, 0], [3, 4, 2, 3], [0, 2, 1, 4], [4, 3, 3, 1]])\n L, U, P = A.lup_decompose()\n L\n U\n P\n\n # P A = L U\n np.array_equal(P @ A, L @ U)\n \"\"\"\n return lup_decompose(self)\n\n ###############################################################################\n # Overridden numpy methods\n ###############################################################################\n\n def astype(self, dtype, **kwargs): # pylint: disable=arguments-differ\n if dtype not in type(self).dtypes:\n raise TypeError(f\"{type(self).name} arrays can only be cast as integer dtypes in {type(self).dtypes}, not {dtype}.\")\n return super().astype(dtype, **kwargs)\n\n def __array_finalize__(self, obj):\n \"\"\"\n A numpy dunder method that is called after \"new\", \"view\", or \"new from template\". It is used here to ensure\n that view casting to a Galois field array has the appropriate dtype and that the values are in the field.\n \"\"\"\n if obj is not None and not isinstance(obj, GFArray):\n # Only invoked on view casting\n if obj.dtype not in type(self).dtypes:\n raise TypeError(f\"{type(self).name} can only have integer dtypes {type(self).dtypes}, not {obj.dtype}.\")\n if np.any(obj < 0) or np.any(obj >= type(self).order):\n idxs = np.logical_or(obj < 0, obj >= type(self).order)\n raise ValueError(f\"{type(self).name} arrays must have values in 0 <= x < {type(self).order}, not {obj[idxs]}.\")\n\n def __getitem__(self, key):\n item = super().__getitem__(key)\n if np.isscalar(item):\n # Return scalar array elements as 0-dimension Galois field arrays. This enables Galois field arithmetic\n # on scalars, which would otherwise be implemented using standard integer arithmetic.\n item = self.__class__(item, dtype=self.dtype)\n return item\n\n def __setitem__(self, key, value):\n # Verify the values to be written to the Galois field array are in the field\n value = self._check_array_like_object(value)\n super().__setitem__(key, value)\n\n def __array_function__(self, func, types, args, kwargs):\n if func in OVERRIDDEN_FUNCTIONS:\n output = OVERRIDDEN_FUNCTIONS[func](*args, **kwargs)\n\n elif func in UNSUPPORTED_FUNCTIONS:\n raise NotImplementedError(f\"The numpy function '{func.__name__}' is not supported on Galois field arrays. If you believe this function should be supported, please submit a GitHub issue at https://github.com/mhostetter/galois/issues.\\n\\nIf you'd like to perform this operation on the data (but not necessarily a Galois field array), you should first call `array = array.view(np.ndarray)` and then call the function.\")\n\n else:\n if func is np.insert:\n args = list(args)\n args[2] = self._check_array_like_object(args[2])\n args = tuple(args)\n\n output = super().__array_function__(func, types, args, kwargs) # pylint: disable=no-member\n\n if func in FUNCTIONS_REQUIRING_VIEW:\n if np.isscalar(output):\n output = type(self)(output, dtype=self.dtype)\n else:\n output = output.view(type(self))\n\n return output\n\n def __array_ufunc__(self, ufunc, method, *inputs, **kwargs): # pylint: disable=too-many-branches\n # print(ufunc, method, inputs, kwargs)\n meta = {}\n meta[\"types\"] = [type(inputs[i]) for i in range(len(inputs))]\n meta[\"operands\"] = list(range(len(inputs)))\n if method in [\"at\", \"reduceat\"]:\n # Remove the second argument for \"at\" ufuncs which is the indices list\n meta[\"operands\"].pop(1)\n meta[\"field_operands\"] = [i for i in meta[\"operands\"] if isinstance(inputs[i], self.__class__)]\n meta[\"non_field_operands\"] = [i for i in meta[\"operands\"] if not isinstance(inputs[i], self.__class__)]\n meta[\"field\"] = self.__class__\n meta[\"dtype\"] = self.dtype\n # meta[\"ufuncs\"] = self._ufuncs\n\n if ufunc in OVERRIDDEN_UFUNCS:\n # Set all ufuncs with \"casting\" keyword argument to \"unsafe\" so we can cast unsigned integers\n # to integers. We know this is safe because we already verified the inputs.\n if method not in [\"reduce\", \"accumulate\", \"at\", \"reduceat\"]:\n kwargs[\"casting\"] = \"unsafe\"\n\n # Need to set the intermediate dtype for reduction operations or an error will be thrown. We\n # use the largest valid dtype for this field.\n if method in [\"reduce\"]:\n kwargs[\"dtype\"] = type(self).dtypes[-1]\n\n return getattr(type(self), OVERRIDDEN_UFUNCS[ufunc])(ufunc, method, inputs, kwargs, meta)\n\n elif ufunc in UNSUPPORTED_UFUNCS:\n raise NotImplementedError(f\"The numpy ufunc '{ufunc.__name__}' is not supported on Galois field arrays. If you believe this ufunc should be supported, please submit a GitHub issue at https://github.com/mhostetter/galois/issues.\")\n\n else:\n inputs, kwargs = type(self)._view_inputs_as_ndarray(inputs, kwargs)\n output = super().__array_ufunc__(ufunc, method, *inputs, **kwargs) # pylint: disable=no-member\n\n if ufunc in UFUNCS_REQUIRING_VIEW:\n output = output.view(type(self))\n\n return output\n\n ###############################################################################\n # Display methods\n ###############################################################################\n\n def __str__(self):\n return self.__repr__()\n\n def __repr__(self):\n # pylint: disable=attribute-defined-outside-init\n formatter = {}\n if type(self).display_mode == \"poly\":\n formatter[\"int\"] = self._print_poly\n formatter[\"object\"] = self._print_poly\n elif type(self).display_mode == \"power\":\n nonzero_idxs = np.nonzero(self)\n if self.ndim > 1:\n self._display_power_pre_width = 0 if nonzero_idxs[0].size == self.size else 1\n max_power = np.max(np.log(self[nonzero_idxs]))\n if max_power > 1:\n self._display_power_width = self._display_power_pre_width + 2 + len(str(max_power))\n else:\n self._display_power_width = self._display_power_pre_width + 1\n else:\n self._display_power_pre_width = None\n self._display_power_width = None\n formatter[\"int\"] = self._print_power\n formatter[\"object\"] = self._print_power\n elif self.dtype == np.object_:\n formatter[\"object\"] = self._print_int\n\n cls = type(self)\n class_name = cls.__name__\n with np.printoptions(formatter=formatter):\n cls.__name__ = \"GF\" # Rename the class so very large fields don't create large indenting\n string = super().__repr__()\n cls.__name__ = class_name\n\n if cls.degree == 1:\n order = \"{}\".format(cls.order)\n else:\n order = \"{}^{}\".format(cls.characteristic, cls.degree)\n\n # Remove the dtype from the repr and add the Galois field order\n dtype_idx = string.find(\"dtype\")\n if dtype_idx == -1:\n string = string[:-1] + f\", order={order})\"\n else:\n string = string[:dtype_idx] + f\"order={order})\"\n\n return string\n\n @staticmethod\n def _print_int(element):\n return \"{:d}\".format(int(element))\n\n def _print_poly(self, element):\n poly = integer_to_poly(element, type(self).characteristic)\n poly_var = \"α\" if type(self).primitive_element == type(self).characteristic else \"x\"\n return poly_to_str(poly, poly_var=poly_var)\n\n def _print_power(self, element):\n if element == 0:\n s = \"-∞\"\n else:\n power = type(self)._ufuncs[\"log\"](element)\n if power > 1:\n s = f\"α^{power}\"\n elif power == 1:\n s = \"α\"\n else:\n s = \"1\"\n\n if self._display_power_pre_width:\n s = \" \" + s\n\n if self._display_power_width:\n return s + \" \"*(self._display_power_width - len(s))\n else:\n return s\n\n @classmethod\n def _poly_eval(cls, coeffs, x):\n coeffs = cls(coeffs) # Convert coefficient into the field\n coeffs = coeffs.view(np.ndarray) # View cast to normal integers so ufunc_poly_eval call uses normal arithmetic\n coeffs = np.atleast_1d(coeffs)\n if coeffs.size == 1:\n # TODO: Why must coeffs have atleast 2 elements otherwise it will be converted to a scalar, not 1d array?\n coeffs = np.insert(coeffs, 0, 0)\n\n x = cls(x) # Convert evaluation values into the field (checks that values are in the field)\n x = x.view(np.ndarray) # View cast to normal integers so ufunc_poly_eval call uses normal arithmetic\n x = np.atleast_1d(x)\n\n if cls.dtypes[-1] == np.object_:\n # For object dtypes, call the vectorized classmethod\n y = cls._ufuncs[\"poly_eval\"](coeffs=coeffs, values=x) # pylint: disable=not-callable\n else:\n # For integer dtypes, call the JIT-compiled gufunc\n y = np.copy(x)\n cls._ufuncs[\"poly_eval\"](coeffs, x, y, casting=\"unsafe\") # pylint: disable=not-callable\n\n y = cls(y)\n if y.size == 1:\n y = y[0]\n\n return y\n", "meta": {"hexsha": "0ce3a790858ffecf114f8a3144d9992c80e23421", "size": 36032, "ext": "py", "lang": "Python", "max_stars_repo_path": "galois/array.py", "max_stars_repo_name": "BK-Modding/galois", "max_stars_repo_head_hexsha": "5da4db84d90083e337ebe2c1838df5c6db88fd3f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "galois/array.py", "max_issues_repo_name": "BK-Modding/galois", "max_issues_repo_head_hexsha": "5da4db84d90083e337ebe2c1838df5c6db88fd3f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "galois/array.py", "max_forks_repo_name": "BK-Modding/galois", "max_forks_repo_head_hexsha": "5da4db84d90083e337ebe2c1838df5c6db88fd3f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.1081359423, "max_line_length": 428, "alphanum_fraction": 0.5767095915, "include": true, "reason": "import numpy", "num_tokens": 8737, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.519521321952093, "lm_q2_score": 0.37754066879814546, "lm_q1q2_score": 0.19614042734468984}} {"text": "#!/usr/bin/env python\r\n# -*- coding: UTF-8 -*-\r\n\r\n# Copyright 2017 Timothy Dozat\r\n# \r\n# Licensed under the Apache License, Version 2.0 (the \"License\");\r\n# you may not use this file except in compliance with the License.\r\n# You may obtain a copy of the License at\r\n# \r\n# http://www.apache.org/licenses/LICENSE-2.0\r\n# \r\n# Unless required by applicable law or agreed to in writing, software\r\n# distributed under the License is distributed on an \"AS IS\" BASIS,\r\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n# See the License for the specific language governing permissions and\r\n# limitations under the License.\r\n\r\nfrom __future__ import absolute_import\r\nfrom __future__ import division\r\nfrom __future__ import print_function\r\nimport six\r\n\r\nimport numpy as np\r\nimport tensorflow as tf\r\n\r\nfrom .base_vocabs import BaseVocab \r\nfrom . import conllu_vocabs as cv\r\n\r\nfrom parser.neural import nn, nonlin, classifiers\r\nimport pdb\r\n#***************************************************************\r\nclass SecondOrderLBPVocab(BaseVocab):\r\n\t\"\"\"\"\"\"\r\n\t\r\n\t#=============================================================\r\n\tdef __init__(self, *args, **kwargs):\r\n\t\t\"\"\"\"\"\"\r\n\t\t\r\n\t\tsuper(SecondOrderLBPVocab, self).__init__(*args, **kwargs)\r\n\t\t\r\n\t\tself.PAD_STR = '_'\r\n\t\tself.PAD_IDX = -1\r\n\t\tself.ROOT_STR = '0'\r\n\t\tself.ROOT_IDX = 0\r\n\t\treturn\r\n\t\r\n\t#=============================================================\r\n\tdef add(self, token):\r\n\t\t\"\"\"\"\"\"\r\n\t\t\r\n\t\treturn self.index(token)\r\n\t\r\n\t#=============================================================\r\n\tdef token(self, index):\r\n\t\t\"\"\"\"\"\"\r\n\t\t\r\n\t\tif index > -1:\r\n\t\t\treturn str(index)\r\n\t\telse:\r\n\t\t\treturn '_'\r\n\t\r\n\t#=============================================================\r\n\tdef index(self, token):\r\n\t\t\"\"\"\"\"\"\r\n\t\t\r\n\t\tif token != '_':\r\n\t\t\treturn int(token)\r\n\t\telse:\r\n\t\t\treturn -1\r\n\t\r\n\t#=============================================================\r\n\tdef get_root(self):\r\n\t\t\"\"\"\"\"\"\r\n\t\t\r\n\t\treturn self.ROOT_STR\r\n\t\r\n\t#=============================================================\r\n\tdef get_bilinear_classifier(self, layer, token_weights, variable_scope=None, reuse=False):\r\n\t\t\"\"\"\"\"\"\r\n\t\t\r\n\t\trecur_layer = layer\r\n\t\thidden_keep_prob = 1 if reuse else self.hidden_keep_prob\r\n\t\thidden_func = self.hidden_func\r\n\t\thidden_size = self.hidden_size\r\n\t\tadd_linear = self.add_linear\r\n\t\tlinearize = self.linearize\r\n\t\tdistance = self.distance\r\n\t\tn_splits = 2*(1+linearize+distance)\r\n\t\twith tf.variable_scope(variable_scope or self.field):\r\n\t\t\tfor i in six.moves.range(0, self.n_layers-1):\r\n\t\t\t\twith tf.variable_scope('FC-%d' % i):\r\n\t\t\t\t\tlayer = classifiers.hidden(layer, n_splits*hidden_size,\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\thidden_func=hidden_func,\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\thidden_keep_prob=hidden_keep_prob)\r\n\t\t\twith tf.variable_scope('FC-top'):\r\n\t\t\t\tlayers = classifiers.hiddens(layer, n_splits*[hidden_size],\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\thidden_func=hidden_func,\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\thidden_keep_prob=hidden_keep_prob)\r\n\t\t\tlayer1, layer2 = layers.pop(0), layers.pop(0)\r\n\t\t\tif linearize:\r\n\t\t\t\tlin_layer1, lin_layer2 = layers.pop(0), layers.pop(0)\r\n\t\t\tif distance:\r\n\t\t\t\tdist_layer1, dist_layer2 = layers.pop(0), layers.pop(0)\r\n\t\t\t\r\n\t\t\twith tf.variable_scope('Attention'):\r\n\t\t\t\tif self.diagonal:\r\n\t\t\t\t\tlogits, _ = classifiers.diagonal_bilinear_attention(\r\n\t\t\t\t\t\tlayer1, layer2, \r\n\t\t\t\t\t\thidden_keep_prob=hidden_keep_prob,\r\n\t\t\t\t\t\tadd_linear=add_linear)\r\n\t\t\t\t\tif linearize:\r\n\t\t\t\t\t\twith tf.variable_scope('Linearization'):\r\n\t\t\t\t\t\t\tlin_logits = classifiers.diagonal_bilinear_discriminator(\r\n\t\t\t\t\t\t\t\tlin_layer1, lin_layer2,\r\n\t\t\t\t\t\t\t\thidden_keep_prob=hidden_keep_prob,\r\n\t\t\t\t\t\t\t\tadd_linear=add_linear)\r\n\t\t\t\t\tif distance:\r\n\t\t\t\t\t\twith tf.variable_scope('Distance'):\r\n\t\t\t\t\t\t\tdist_lamda = 1+tf.nn.softplus(classifiers.diagonal_bilinear_discriminator(\r\n\t\t\t\t\t\t\t\tdist_layer1, dist_layer2,\r\n\t\t\t\t\t\t\t\thidden_keep_prob=hidden_keep_prob,\r\n\t\t\t\t\t\t\t\tadd_linear=add_linear))\r\n\t\t\t\telse:\r\n\t\t\t\t\tlogits, _ = classifiers.bilinear_attention(\r\n\t\t\t\t\t\tlayer1, layer2,\r\n\t\t\t\t\t\thidden_keep_prob=hidden_keep_prob,\r\n\t\t\t\t\t\tadd_linear=add_linear)\r\n\t\t\t\t\tif linearize:\r\n\t\t\t\t\t\twith tf.variable_scope('Linearization'):\r\n\t\t\t\t\t\t\tlin_logits = classifiers.bilinear_discriminator(\r\n\t\t\t\t\t\t\t\tlin_layer1, lin_layer2,\r\n\t\t\t\t\t\t\t\thidden_keep_prob=hidden_keep_prob,\r\n\t\t\t\t\t\t\t\tadd_linear=add_linear)\r\n\t\t\t\t\tif distance:\r\n\t\t\t\t\t\twith tf.variable_scope('Distance'):\r\n\t\t\t\t\t\t\tdist_lamda = 1+tf.nn.softplus(classifiers.bilinear_discriminator(\r\n\t\t\t\t\t\t\t\tdist_layer1, dist_layer2,\r\n\t\t\t\t\t\t\t\thidden_keep_prob=hidden_keep_prob,\r\n\t\t\t\t\t\t\t\tadd_linear=add_linear))\r\n\t\t\t\t\r\n\t\t\t\t#-----------------------------------------------------------\r\n\t\t\t\t# Process the targets\r\n\t\t\t\ttargets = self.placeholder\r\n\t\t\t\tshape = tf.shape(layer1)\r\n\t\t\t\tbatch_size, bucket_size = shape[0], shape[1]\r\n\t\t\t\t# (1 x m)\r\n\t\t\t\tids = tf.expand_dims(tf.range(bucket_size), 0)\r\n\t\t\t\t# (1 x m) -> (1 x 1 x m)\r\n\t\t\t\thead_ids = tf.expand_dims(ids, -2)\r\n\t\t\t\t# (1 x m) -> (1 x m x 1)\r\n\t\t\t\tdep_ids = tf.expand_dims(ids, -1)\r\n\t\t\t\tif linearize:\r\n\t\t\t\t\t# Wherever the head is to the left\r\n\t\t\t\t\t# (n x m), (1 x m) -> (n x m)\r\n\t\t\t\t\tlin_targets = tf.to_float(tf.less(targets, ids))\r\n\t\t\t\t\t# cross-entropy of the linearization of each i,j pair\r\n\t\t\t\t\t# (1 x 1 x m), (1 x m x 1) -> (n x m x m)\r\n\t\t\t\t\tlin_ids = tf.tile(tf.less(head_ids, dep_ids), [batch_size, 1, 1])\r\n\t\t\t\t\t# (n x 1 x m), (n x m x 1) -> (n x m x m)\r\n\t\t\t\t\tlin_xent = -tf.nn.softplus(tf.where(lin_ids, -lin_logits, lin_logits))\r\n\t\t\t\t\t# add the cross-entropy to the logits\r\n\t\t\t\t\t# (n x m x m), (n x m x m) -> (n x m x m)\r\n\t\t\t\t\tlogits += tf.stop_gradient(lin_xent)\r\n\t\t\t\tif distance:\r\n\t\t\t\t\t# (n x m) - (1 x m) -> (n x m)\r\n\t\t\t\t\tdist_targets = tf.abs(targets - ids)\r\n\t\t\t\t\t# KL-divergence of the distance of each i,j pair\r\n\t\t\t\t\t# (1 x 1 x m) - (1 x m x 1) -> (n x m x m)\r\n\t\t\t\t\tdist_ids = tf.to_float(tf.tile(tf.abs(head_ids - dep_ids), [batch_size, 1, 1]))+1e-12\r\n\t\t\t\t\t# (n x m x m), (n x m x m) -> (n x m x m)\r\n\t\t\t\t\t#dist_kld = (dist_ids * tf.log(dist_lamda / dist_ids) + dist_ids - dist_lamda)\r\n\t\t\t\t\tdist_kld = -tf.log((dist_ids - dist_lamda)**2/2 + 1)\r\n\t\t\t\t\t# add the KL-divergence to the logits\r\n\t\t\t\t\t# (n x m x m), (n x m x m) -> (n x m x m)\r\n\t\t\t\t\tlogits += tf.stop_gradient(dist_kld)\r\n\t\t\t\t\r\n\t\t\t\t#-----------------------------------------------------------\r\n\t\t\t\t# Compute probabilities/cross entropy\r\n\t\t\t\t# (n x m) + (m) -> (n x m)\r\n\t\t\t\tnon_pads = tf.to_float(token_weights) + tf.to_float(tf.logical_not(tf.cast(tf.range(bucket_size), dtype=tf.bool)))\r\n\t\t\t\t# (n x m x m) o (n x 1 x m) -> (n x m x m)\r\n\t\t\t\tprobabilities = tf.nn.softmax(logits) * tf.expand_dims(non_pads, -2)\r\n\t\t\t\t# (n x m), (n x m x m), (n x m) -> ()\r\n\t\t\t\tloss = tf.losses.sparse_softmax_cross_entropy(\r\n\t\t\t\t\ttargets,\r\n\t\t\t\t\tlogits,\r\n\t\t\t\t\tweights=token_weights)\r\n\t\t\t\t# (n x m) -> (n x m x m x 1)\r\n\t\t\t\tone_hot_targets = tf.expand_dims(tf.one_hot(targets, bucket_size), -1)\r\n\t\t\t\t# (n x m) -> ()\r\n\t\t\t\tn_tokens = tf.to_float(tf.reduce_sum(token_weights))\r\n\t\t\t\tif linearize:\r\n\t\t\t\t\t# (n x m x m) -> (n x m x 1 x m)\r\n\t\t\t\t\tlin_xent_reshaped = tf.expand_dims(lin_xent, -2)\r\n\t\t\t\t\t# (n x m x 1 x m) * (n x m x m x 1) -> (n x m x 1 x 1)\r\n\t\t\t\t\tlin_target_xent = tf.matmul(lin_xent_reshaped, one_hot_targets)\r\n\t\t\t\t\t# (n x m x 1 x 1) -> (n x m)\r\n\t\t\t\t\tlin_target_xent = tf.squeeze(lin_target_xent, [-1, -2])\r\n\t\t\t\t\t# (n x m), (n x m), (n x m) -> ()\r\n\t\t\t\t\tloss -= tf.reduce_sum(lin_target_xent*tf.to_float(token_weights)) / (n_tokens + 1e-12)\r\n\t\t\t\tif distance:\r\n\t\t\t\t\t# (n x m x m) -> (n x m x 1 x m)\r\n\t\t\t\t\tdist_kld_reshaped = tf.expand_dims(dist_kld, -2)\r\n\t\t\t\t\t# (n x m x 1 x m) * (n x m x m x 1) -> (n x m x 1 x 1)\r\n\t\t\t\t\tdist_target_kld = tf.matmul(dist_kld_reshaped, one_hot_targets)\r\n\t\t\t\t\t# (n x m x 1 x 1) -> (n x m)\r\n\t\t\t\t\tdist_target_kld = tf.squeeze(dist_target_kld, [-1, -2])\r\n\t\t\t\t\t# (n x m), (n x m), (n x m) -> ()\r\n\t\t\t\t\tloss -= tf.reduce_sum(dist_target_kld*tf.to_float(token_weights)) / (n_tokens + 1e-12)\r\n\t\t\t\t\r\n\t\t\t\t#-----------------------------------------------------------\r\n\t\t\t\t# Compute predictions/accuracy\r\n\t\t\t\t# (n x m x m) -> (n x m)\r\n\t\t\t\tpredictions = tf.argmax(logits, axis=-1, output_type=tf.int32)\r\n\t\t\t\t# (n x m) (*) (n x m) -> (n x m)\r\n\t\t\t\tcorrect_tokens = nn.equal(targets, predictions) * token_weights\r\n\t\t\t\t# (n x m) -> (n)\r\n\t\t\t\ttokens_per_sequence = tf.reduce_sum(token_weights, axis=-1)\r\n\t\t\t\t# (n x m) -> (n)\r\n\t\t\t\tcorrect_tokens_per_sequence = tf.reduce_sum(correct_tokens, axis=-1)\r\n\t\t\t\t# (n), (n) -> (n)\r\n\t\t\t\tcorrect_sequences = nn.equal(tokens_per_sequence, correct_tokens_per_sequence)\r\n\t\t\r\n\t\t#-----------------------------------------------------------\r\n\t\t# Populate the output dictionary\r\n\t\toutputs = {}\r\n\t\toutputs['recur_layer'] = recur_layer\r\n\t\toutputs['unlabeled_targets'] = self.placeholder\r\n\t\toutputs['probabilities'] = probabilities\r\n\t\toutputs['unlabeled_loss'] = loss\r\n\t\toutputs['loss'] = loss\r\n\t\t\r\n\t\toutputs['unlabeled_predictions'] = predictions\r\n\t\toutputs['predictions'] = predictions\r\n\t\toutputs['correct_unlabeled_tokens'] = correct_tokens\r\n\t\toutputs['n_correct_unlabeled_tokens'] = tf.reduce_sum(correct_tokens)\r\n\t\toutputs['n_correct_unlabeled_sequences'] = tf.reduce_sum(correct_sequences)\r\n\t\toutputs['n_correct_tokens'] = tf.reduce_sum(correct_tokens)\r\n\t\toutputs['n_correct_sequences'] = tf.reduce_sum(correct_sequences)\r\n\t\treturn outputs\r\n\t\r\n\t#=============================================================\r\n\tdef __getitem__(self, key):\r\n\t\tif isinstance(key, six.string_types):\r\n\t\t\tif key == '_':\r\n\t\t\t\treturn -1\r\n\t\t\telse:\r\n\t\t\t\treturn int(key)\r\n\t\telif isinstance(key, six.integer_types + (np.int32, np.int64)):\r\n\t\t\tif key > -1:\r\n\t\t\t\treturn str(key)\r\n\t\t\telse:\r\n\t\t\t\treturn '_'\r\n\t\telif hasattr(key, '__iter__'):\r\n\t\t\treturn [self[k] for k in key]\r\n\t\telse:\r\n\t\t\traise ValueError('key to IndexVocab.__getitem__ must be (iterable of) string or integer')\r\n\t\treturn\r\n\t#=============================================================\r\n\t@property\r\n\tdef distance(self):\r\n\t\treturn self._config.getboolean(self, 'distance')\r\n\t@property\r\n\tdef linearize(self):\r\n\t\treturn self._config.getboolean(self, 'linearize')\r\n\t@property\r\n\tdef decomposition_level(self):\r\n\t\treturn self._config.getint(self, 'decomposition_level')\r\n\t@property\r\n\tdef diagonal(self):\r\n\t\treturn self._config.getboolean(self, 'diagonal')\r\n\t@property\r\n\tdef add_linear(self):\r\n\t\treturn self._config.getboolean(self, 'add_linear')\r\n\t@property\r\n\tdef n_layers(self):\r\n\t\treturn self._config.getint(self, 'n_layers')\r\n\t@property\r\n\tdef hidden_size(self):\r\n\t\treturn self._config.getint(self, 'hidden_size')\r\n\t@property\r\n\tdef hidden_keep_prob(self):\r\n\t\treturn self._config.getfloat(self, 'hidden_keep_prob')\r\n\t@property\r\n\tdef hidden_keep_prob_tri(self):\r\n\t\ttry:\r\n\t\t\treturn self._config.getfloat(self, 'hidden_keep_prob_tri')\r\n\t\texcept:\r\n\t\t\treturn self._config.getfloat(self, 'hidden_keep_prob')\r\n\t\t\r\n\t@property\r\n\tdef hidden_func(self):\r\n\t\thidden_func = self._config.getstr(self, 'hidden_func')\r\n\t\tif hasattr(nonlin, hidden_func):\r\n\t\t\treturn getattr(nonlin, hidden_func)\r\n\t\telse:\r\n\t\t\traise AttributeError(\"module '{}' has no attribute '{}'\".format(nonlin.__name__, hidden_func))\r\n\t@property\r\n\tdef num_iteration(self):\r\n\t\treturn self._config.getfloat(self, 'num_iteration')\r\n\t@property\r\n\tdef discriminator2(self):\r\n\t\treturn self._config.getboolean(self,'discriminator2')\r\n\t@property\r\n\tdef sibling_only(self):\r\n\t\treturn self._config.getboolean(self,'sibling_only')\r\n\t@property\r\n\tdef self_minus(self):\r\n\t\treturn self._config.getboolean(self,'self_minus')\r\n\t@property\r\n\tdef use_sib(self):\r\n\t\treturn self._config.getboolean(self,'use_sib')\r\n\t@property\r\n\tdef use_gp(self):\r\n\t\treturn self._config.getboolean(self,'use_gp')\r\n\t@property\r\n\tdef use_cop(self):\r\n\t\treturn self._config.getboolean(self,'use_cop')\r\n\t@property\r\n\tdef transposed(self):\r\n\t\treturn self._config.getboolean(self,'transposed')\r\n\t@property\r\n\tdef unary_weight(self):\r\n\t\tif self._config.getboolean(self,'unary_weight'):\r\n\t\t\treturn int(self.use_cop)+int(self.use_sib)+2*int(self.use_gp)\r\n\t\telse:\r\n\t\t\treturn 1\r\n\t@property\r\n\tdef new_potential(self):\r\n\t\treturn self._config.getboolean(self,'new_potential')\r\n\t@property\r\n\tdef separate_embed(self):\r\n\t\ttry:\r\n\t\t\treturn self._config.getboolean(self,'separate_embed')\r\n\t\texcept:\r\n\t\t\treturn False\r\n\t@property\r\n\tdef old_trilin(self):\r\n\t\ttry:\r\n\t\t\treturn self._config.getboolean(self,'old_trilin')\r\n\t\texcept:\r\n\t\t\treturn False\r\n\t@property\r\n\tdef remove_loop(self):\r\n\t\ttry:\r\n\t\t\treturn self._config.getboolean(self,'remove_loop')\r\n\t\texcept:\r\n\t\t\treturn False\r\n\t@property\r\n\tdef combine_loss(self):\r\n\t\ttry:\r\n\t\t\treturn self._config.getboolean(self,'combine_loss')\r\n\t\texcept:\r\n\t\t\treturn False\r\n\t@property\r\n\tdef loss_weight(self):\r\n\t\ttry:\r\n\t\t\treturn self._config.getfloat(self,'loss_weight')\r\n\t\texcept:\r\n\t\t\treturn 0.5\r\n\t@property\r\n\tdef loss_weight_unary(self):\r\n\t\ttry:\r\n\t\t\treturn self._config.getfloat(self,'loss_weight_unary')\r\n\t\texcept:\r\n\t\t\treturn 0.5\r\n\t@property\r\n\tdef test_new_potential(self):\r\n\t\ttry:\r\n\t\t\treturn self._config.getboolean(self,'test_new_potential')\r\n\t\texcept:\r\n\t\t\treturn False\r\n\t@property\r\n\tdef layer_mask(self):\r\n\t\ttry:\r\n\t\t\treturn self._config.getboolean(self,'layer_mask')\r\n\t\texcept:\r\n\t\t\treturn False\r\n\t@property\r\n\tdef normalize(self):\r\n\t\ttry:\r\n\t\t\treturn self._config.getboolean(self,'normalize')\r\n\t\texcept:\r\n\t\t\treturn False\r\n\t@property\r\n\tdef use_unary_hidden(self):\r\n\t\ttry:\r\n\t\t\treturn self._config.getboolean(self,'use_unary_hidden')\r\n\t\texcept:\r\n\t\t\treturn False\r\n\t@property\r\n\tdef unary_hidden(self):\r\n\t\ttry:\r\n\t\t\treturn self._config.getint(self,'unary_hidden')\r\n\t\texcept:\r\n\t\t\treturn self._config.getint(self,'hidden_size')\r\n\t@property\r\n\tdef tri_std(self):\r\n\t\ttry:\r\n\t\t\treturn self._config.getfloat(self,'tri_std')\r\n\t\texcept:\r\n\t\t\treturn 0.01\r\n\t@property\r\n\tdef tri_std_unary(self):\r\n\t\ttry:\r\n\t\t\treturn self._config.getfloat(self,'tri_std_unary')\r\n\t\texcept:\r\n\t\t\treturn 0.5\r\n\t@property\r\n\tdef hidden_k(self):\r\n\t\ttry:\r\n\t\t\treturn self._config.getint(self,'hidden_k')\r\n\t\texcept:\r\n\t\t\treturn 200\r\n\t@property\r\n\tdef two_gpu(self):\r\n\t\ttry:\r\n\t\t\tif self._config.get('GraphParserNetwork','two_gpu')=='True':\r\n\t\t\t\treturn True\r\n\t\t\telse:\r\n\t\t\t\treturn False\r\n\t\texcept:\r\n\t\t\treturn False\r\n\t@property\r\n\tdef remove_root_child(self):\r\n\t\ttry:\r\n\t\t\treturn self._config.getboolean(self,'remove_root_child')\r\n\t\texcept:\r\n\t\t\treturn False\r\n\t@property\r\n\tdef compare_precision(self):\r\n\t\ttry:\r\n\t\t\tif self._config.get('DEFAULT', 'tb')=='ptb' or self._config.get('DEFAULT', 'tb')=='ctb':\r\n\t\t\t\treturn True\r\n\t\t\telse:\r\n\t\t\t\treturn False\r\n\t\texcept:\r\n\t\t\treturn False\r\n#***************************************************************\r\nclass GraphSecondLBPVocab(SecondOrderLBPVocab): #second order trilinear classifier\r\n\t\"\"\"\"\"\"\r\n\t\r\n\t_depth = -1\r\n\t\r\n\t#=============================================================\r\n\tdef __init__(self, *args, **kwargs):\r\n\t\t\"\"\"\"\"\"\r\n\t\t\r\n\t\tkwargs['placeholder_shape'] = [None, None, None]\r\n\t\tsuper(GraphSecondLBPVocab, self).__init__(*args, **kwargs)\r\n\t\treturn\r\n\t\r\n\t#=============================================================\r\n\tdef get_bilinear_discriminator(self, layer, token_weights, variable_scope=None, reuse=False, debug=False, token_weights4D=None):\r\n\t\t\"\"\"\"\"\"\r\n\t\t#in fact here is get_trilinear_discriminator\r\n\t\toutputs = {}\r\n\t\trecur_layer = layer\r\n\t\thidden_keep_prob = 1 if reuse else self.hidden_keep_prob\r\n\t\thidden_keep_prob_tri = 1 if reuse else self.hidden_keep_prob_tri\r\n\t\tadd_linear = self.add_linear\r\n\t\t#here set n_splits to be three\r\n\t\tif self.separate_embed:\r\n\t\t\tn_splits = 9*(1+self.linearize+self.distance)\r\n\t\telse:\r\n\t\t\tn_splits = 3*(1+self.linearize+self.distance)\r\n\t\twith tf.variable_scope(variable_scope or self.field):\r\n\t\t\tfor i in six.moves.range(0, self.n_layers-1):#number of layers of FNN? what is this?\r\n\t\t\t\twith tf.variable_scope('FC-%d' % i):#here is FNN? did not run\r\n\t\t\t\t\tlayer = classifiers.hidden(layer, n_splits*self.hidden_size,\r\n\t\t\t\t\t\t\t\t\t\t\t\t hidden_func=self.hidden_func,\r\n\t\t\t\t\t\t\t\t\t\t\t\t hidden_keep_prob=hidden_keep_prob)\r\n\t\t\twith tf.variable_scope('FC-top'):#FNN output and split two layer? FNN+split. Linear transform for a sentence, n_splits is number of features you want \r\n\t\t\t\t#this linear transformation contains word information\r\n\t\t\t\tif self.use_unary_hidden:\r\n\t\t\t\t\tprint('separate unary and binary hidden size')\r\n\t\t\t\t\tif self.separate_embed:\r\n\t\t\t\t\t\thidden_list=2*[self.unary_hidden]+(n_splits-2)*[self.hidden_size]\r\n\t\t\t\t\telse:\r\n\t\t\t\t\t\thidden_list=2*[self.unary_hidden]+n_splits*[self.hidden_size]\r\n\t\t\t\telse:\r\n\t\t\t\t\thidden_list=n_splits*[self.hidden_size]\r\n\t\t\t\t#pdb.set_trace()\r\n\t\t\t\tlayers = classifiers.hiddens(layer, hidden_list,\r\n\t\t\t\t\t\t\t\t\t\t\t hidden_func=self.hidden_func,\r\n\t\t\t\t\t\t\t\t\t\t\t hidden_keep_prob=hidden_keep_prob)\r\n\t\t\tif self.separate_embed:\r\n\t\t\t\t# unary_head + unary_dep + sib_head + sib_dep + gp_head + gp_dep + gp_(head+dep) + cop_head + cop_dep\r\n\t\t\t\tunary_layer1, unary_layer2, sib_head, sib_dep, gp_head, gp_dep, gp_headdep, cop_head, cop_dep = layers.pop(0), layers.pop(0), layers.pop(0), layers.pop(0), layers.pop(0)\\\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t, layers.pop(0), layers.pop(0), layers.pop(0), layers.pop(0)\r\n\t\t\telse:\r\n\t\t\t\t# head + dep + (head+dep)\r\n\t\t\t\tif self.use_unary_hidden:\r\n\t\t\t\t\tunary_layer1, unary_layer2, layer1, layer2, layer3 = layers.pop(0), layers.pop(0), layers.pop(0), layers.pop(0), layers.pop(0)\r\n\t\t\t\telse:\r\n\t\t\t\t\tlayer1, layer2, layer3 = layers.pop(0), layers.pop(0), layers.pop(0)\r\n\t\t\t\t\t#pdb.set_trace()\r\n\t\t\t\t\tunary_layer1=layer1\r\n\t\t\t\t\tunary_layer2=layer2\r\n\t\t\tif self.linearize:#false\r\n\t\t\t\tlin_layer1, lin_layer2 = layers.pop(0), layers.pop(0), layers.pop(0)\r\n\t\t\tif self.distance:#false in graph\r\n\t\t\t\tdist_layer1, dist_layer2 = layers.pop(0), layers.pop(0), layers.pop(0)\r\n\t\t\t#pdb.set_trace()\r\n\t\t\tif self.layer_mask:\r\n\t\t\t\t#pdb.set_trace()\r\n\t\t\t\tsentence_mask=tf.expand_dims(tf.cast(tf.transpose(token_weights,[0,2,1])[:,0],dtype=tf.float32),-1)\r\n\t\t\t\t\r\n\t\t\t\tunary_layer1=unary_layer1*sentence_mask\r\n\t\t\t\tunary_layer2=unary_layer2*sentence_mask\r\n\t\t\t\tif self.separate_embed:\r\n\t\t\t\t\tsib_head, sib_dep, gp_head, gp_dep, gp_headdep, cop_head, cop_dep = sib_head*sentence_mask, sib_dep*sentence_mask,\\\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tgp_head*sentence_mask, gp_dep*sentence_mask,\\\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tgp_headdep*sentence_mask, cop_head*sentence_mask,\\\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tcop_dep*sentence_mask\r\n\t\t\t\telse:\r\n\t\t\t\t\tif not self.separate_embed:\r\n\t\t\t\t\t\tlayer1=layer1*sentence_mask\r\n\t\t\t\t\t\tlayer2=layer2*sentence_mask\r\n\t\t\t\t\tlayer3=layer3*sentence_mask\r\n\t\t\t\tpass\r\n\t\t\twith tf.variable_scope('Discriminator'):\r\n\t\t\t\tif self.diagonal:\r\n\t\t\t\t\tlogits = classifiers.diagonal_bilinear_discriminator(\r\n\t\t\t\t\t\tlayer1, layer2,\r\n\t\t\t\t\t\thidden_keep_prob=hidden_keep_prob,\r\n\t\t\t\t\t\tadd_linear=add_linear)\r\n\t\t\t\t\tif self.linearize:\r\n\t\t\t\t\t\twith tf.variable_scope('Linearization'):\r\n\t\t\t\t\t\t\tlin_logits = classifiers.diagonal_bilinear_discriminator(\r\n\t\t\t\t\t\t\t\tlin_layer1, lin_layer2,\r\n\t\t\t\t\t\t\t\thidden_keep_prob=hidden_keep_prob,\r\n\t\t\t\t\t\t\t\tadd_linear=add_linear)\r\n\t\t\t\t\tif self.distance:\r\n\t\t\t\t\t\twith tf.variable_scope('Distance'):\r\n\t\t\t\t\t\t\tdist_lamda = 1+tf.nn.softplus(classifiers.diagonal_bilinear_discriminator(\r\n\t\t\t\t\t\t\t\tdist_layer1, dist_layer2,\r\n\t\t\t\t\t\t\t\thidden_keep_prob=hidden_keep_prob,\r\n\t\t\t\t\t\t\t\tadd_linear=add_linear))\r\n\t\t\t\telse:\r\n\t\t\t\t\t#only run here\r\n\t\t\t\t\t#First order potential and second order potential\r\n\t\t\t\t\t#change it to two label discriminator, because we need a score for the condition of 0 and 1\r\n\t\t\t\t\t#(n x m x 2 x m)\r\n\r\n\t\t\t\t\t#with tf.device('/device:GPU:1'):\r\n\t\t\t\t\t'''\r\n\t\t\t\t\tunary, unary_weights = classifiers.bilinear_classifier(\r\n\t\t\t\t\t\tlayer1, layer2, 2,\r\n\t\t\t\t\t\thidden_keep_prob=hidden_keep_prob,\r\n\t\t\t\t\t\tadd_linear=add_linear)\r\n\t\t\t\t\t'''\r\n\t\t\t\t\tunary = classifiers.bilinear_classifier(\r\n\t\t\t\t\t\tunary_layer1, unary_layer2, 2,\r\n\t\t\t\t\t\thidden_keep_prob=hidden_keep_prob,\r\n\t\t\t\t\t\tadd_linear=add_linear,target_model='LBP', tri_std=self.tri_std_unary)\r\n\t\t\t\t\t#'''\r\n\t\t\t\t\t'''\r\n\t\t\t\t\tunary = classifiers.bilinear_discriminator(\r\n\t\t\t\t\t\tlayer1, layer2,\r\n\t\t\t\t\t\thidden_keep_prob=hidden_keep_prob,\r\n\t\t\t\t\t\tadd_linear=add_linear)\r\n\t\t\t\t\t#'''\r\n\r\n\t\t\t\t\t\t\r\n\t\t\t\t\tif self.separate_embed:\r\n\t\t\t\t\t\tprint('separate')\r\n\t\t\t\t\t\t# head dep dep\r\n\t\t\t\t\t\tif self.test_new_potential:\r\n\t\t\t\t\t\t\tprint('testing new potential')\r\n\t\t\t\t\t\t\tif self.use_sib:\r\n\t\t\t\t\t\t\t\twith tf.variable_scope('Sibling'):\r\n\t\t\t\t\t\t\t\t\tlayer_sib = classifiers.trilinear_discriminator_outer(\r\n\t\t\t\t\t\t\t\t\t\tsib_head, sib_dep, sib_dep,\r\n\t\t\t\t\t\t\t\t\t\thidden_keep_prob=hidden_keep_prob_tri,\r\n\t\t\t\t\t\t\t\t\t\tadd_linear=add_linear, tri_std=self.tri_std, hidden_k=self.hidden_k)\r\n\t\t\t\t\t\t\t# head head+dep dep\r\n\t\t\t\t\t\t\tif self.use_gp:\r\n\t\t\t\t\t\t\t\twith tf.variable_scope('GrandParents'):\r\n\t\t\t\t\t\t\t\t\tlayer_gp = classifiers.trilinear_discriminator_outer(\r\n\t\t\t\t\t\t\t\t\t\tgp_head, gp_headdep, gp_dep,\r\n\t\t\t\t\t\t\t\t\t\thidden_keep_prob=hidden_keep_prob_tri,\r\n\t\t\t\t\t\t\t\t\t\tadd_linear=add_linear, tri_std=self.tri_std, hidden_k=self.hidden_k)\r\n\t\t\t\t\t\t\t# head dep head\r\n\t\t\t\t\t\t\tif self.use_cop:\r\n\t\t\t\t\t\t\t\twith tf.variable_scope('CoParents'):\r\n\t\t\t\t\t\t\t\t\tlayer_cop = classifiers.trilinear_discriminator_outer(\r\n\t\t\t\t\t\t\t\t\t\tcop_head, cop_dep, cop_head,\r\n\t\t\t\t\t\t\t\t\t\thidden_keep_prob=hidden_keep_prob_tri,\r\n\t\t\t\t\t\t\t\t\t\tadd_linear=add_linear, tri_std=self.tri_std, hidden_k=self.hidden_k)\r\n\t\t\t\t\t\telse:\r\n\t\t\t\t\t\t\tif self.use_sib:\r\n\t\t\t\t\t\t\t\twith tf.variable_scope('Sibling'):\r\n\t\t\t\t\t\t\t\t\tlayer_sib = classifiers.trilinear_discriminator_new(\r\n\t\t\t\t\t\t\t\t\t\tsib_head, sib_dep, sib_dep,\r\n\t\t\t\t\t\t\t\t\t\thidden_keep_prob=hidden_keep_prob_tri,\r\n\t\t\t\t\t\t\t\t\t\tadd_linear=add_linear,target_model='LBP',tri_std=self.tri_std)\r\n\t\t\t\t\t\t\tif self.use_gp:\r\n\t\t\t\t\t\t\t\twith tf.variable_scope('GrandParents'):\r\n\t\t\t\t\t\t\t\t\tlayer_gp= classifiers.trilinear_discriminator_new(\r\n\t\t\t\t\t\t\t\t\t\tgp_head, gp_headdep, gp_dep,\r\n\t\t\t\t\t\t\t\t\t\thidden_keep_prob=hidden_keep_prob_tri,\r\n\t\t\t\t\t\t\t\t\t\tadd_linear=add_linear,target_model='LBP',tri_std=self.tri_std)\r\n\t\t\t\t\t\t\t\t\t#'''\r\n\t\t\t\t\t\t\t# head dep head\r\n\t\t\t\t\t\t\tif self.use_cop:\r\n\t\t\t\t\t\t\t\twith tf.variable_scope('CoParents'):\r\n\t\t\t\t\t\t\t\t\tlayer_cop = classifiers.trilinear_discriminator_new(\r\n\t\t\t\t\t\t\t\t\t\tcop_head, cop_dep, cop_head,\r\n\t\t\t\t\t\t\t\t\t\thidden_keep_prob=hidden_keep_prob_tri,\r\n\t\t\t\t\t\t\t\t\t\tadd_linear=add_linear,target_model='LBP',tri_std=self.tri_std)\r\n\t\t\t\t\t\t\t\t\t#'''\r\n\t\t\t\t\telif not self.old_trilin:\r\n\t\t\t\t\t\tprint('head dep')\r\n\t\t\t\t\t\tif self.test_new_potential:\r\n\t\t\t\t\t\t\tprint('testing new potential')\r\n\t\t\t\t\t\t\t# head dep dep\r\n\t\t\t\t\t\t\tif self.use_sib:\r\n\t\t\t\t\t\t\t\twith tf.variable_scope('Sibling'):\r\n\t\t\t\t\t\t\t\t\tlayer_sib = classifiers.trilinear_discriminator_test(\r\n\t\t\t\t\t\t\t\t\t\tlayer1, layer2, layer2,\r\n\t\t\t\t\t\t\t\t\t\thidden_keep_prob=hidden_keep_prob_tri,\r\n\t\t\t\t\t\t\t\t\t\tadd_linear=add_linear,target_model='LBP',tri_std=self.tri_std)\r\n\t\t\t\t\t\t\t# head head+dep dep\r\n\t\t\t\t\t\t\tif self.use_gp:\r\n\t\t\t\t\t\t\t\twith tf.variable_scope('GrandParents'):\r\n\t\t\t\t\t\t\t\t\tlayer_gp = classifiers.trilinear_discriminator_test(\r\n\t\t\t\t\t\t\t\t\t\tlayer1, layer3, layer2,\r\n\t\t\t\t\t\t\t\t\t\thidden_keep_prob=hidden_keep_prob_tri,\r\n\t\t\t\t\t\t\t\t\t\tadd_linear=add_linear,target_model='LBP',tri_std=self.tri_std)\r\n\t\t\t\t\t\t\t# head dep head\r\n\t\t\t\t\t\t\tif self.use_cop:\r\n\t\t\t\t\t\t\t\twith tf.variable_scope('CoParents'):\r\n\t\t\t\t\t\t\t\t\tlayer_cop = classifiers.trilinear_discriminator_test(\r\n\t\t\t\t\t\t\t\t\t\tlayer1, layer2, layer1,\r\n\t\t\t\t\t\t\t\t\t\thidden_keep_prob=hidden_keep_prob_tri,\r\n\t\t\t\t\t\t\t\t\t\tadd_linear=add_linear,target_model='LBP',tri_std=self.tri_std)\r\n\t\t\t\t\t\t#=================================================\r\n\t\t\t\t\t\telse:\r\n\t\t\t\t\t\t\t# head dep dep\r\n\t\t\t\t\t\t\tif self.use_sib:\r\n\t\t\t\t\t\t\t\twith tf.variable_scope('Sibling'):\r\n\t\t\t\t\t\t\t\t\tlayer_sib = classifiers.trilinear_discriminator_new(\r\n\t\t\t\t\t\t\t\t\t\tlayer1, layer2, layer2,\r\n\t\t\t\t\t\t\t\t\t\thidden_keep_prob=hidden_keep_prob_tri,\r\n\t\t\t\t\t\t\t\t\t\tadd_linear=add_linear,target_model='LBP',tri_std=self.tri_std)\r\n\t\t\t\t\t\t\t# head head+dep dep\r\n\t\t\t\t\t\t\tif self.use_gp:\r\n\t\t\t\t\t\t\t\twith tf.variable_scope('GrandParents'):\r\n\t\t\t\t\t\t\t\t\tlayer_gp = classifiers.trilinear_discriminator_new(\r\n\t\t\t\t\t\t\t\t\t\tlayer1, layer3, layer2,\r\n\t\t\t\t\t\t\t\t\t\thidden_keep_prob=hidden_keep_prob_tri,\r\n\t\t\t\t\t\t\t\t\t\tadd_linear=add_linear,target_model='LBP',tri_std=self.tri_std)\r\n\t\t\t\t\t\t\t# head dep head\r\n\t\t\t\t\t\t\tif self.use_cop:\r\n\t\t\t\t\t\t\t\twith tf.variable_scope('CoParents'):\r\n\t\t\t\t\t\t\t\t\tlayer_cop = classifiers.trilinear_discriminator_new(\r\n\t\t\t\t\t\t\t\t\t\tlayer1, layer2, layer1,\r\n\t\t\t\t\t\t\t\t\t\thidden_keep_prob=hidden_keep_prob_tri,\r\n\t\t\t\t\t\t\t\t\t\tadd_linear=add_linear,target_model='LBP',tri_std=self.tri_std)\r\n\t\t\t\t\t#-----------------------------------------------------------\r\n\t\t\t\t\tif self.linearize:\r\n\t\t\t\t\t\twith tf.variable_scope('Linearization'):\r\n\t\t\t\t\t\t\tlin_logits = classifiers.bilinear_discriminator(\r\n\t\t\t\t\t\t\t\tlin_layer1, lin_layer2,\r\n\t\t\t\t\t\t\t\thidden_keep_prob=hidden_keep_prob,\r\n\t\t\t\t\t\t\t\tadd_linear=add_linear)\r\n\t\t\t\t\tif self.distance:\r\n\t\t\t\t\t\twith tf.variable_scope('Distance'):\r\n\t\t\t\t\t\t\tdist_lamda = 1+tf.nn.softplus(classifiers.bilinear_discriminator(\r\n\t\t\t\t\t\t\t\tdist_layer1, dist_layer2,\r\n\t\t\t\t\t\t\t\thidden_keep_prob=hidden_keep_prob,\r\n\t\t\t\t\t\t\t\tadd_linear=add_linear))\r\n\t\t\t\t\r\n\t\t\t\tbinary_shape = layer_sib.shape.as_list()\r\n\t\t\t\tif debug:\r\n\t\t\t\t\toutputs['printdata']={}\r\n\t\t\t\t\tif self.new_potential:\r\n\t\t\t\t\t\toutputs['printdata']['unary_old']=unary\r\n\t\t\t\t\tif self.use_sib:\r\n\t\t\t\t\t\toutputs['printdata']['layer_sib_old']=layer_sib\r\n\t\t\t\t\tif self.use_cop:\r\n\t\t\t\t\t\toutputs['printdata']['layer_cop_old']=layer_cop\r\n\t\t\t\t\tif self.use_gp:\r\n\t\t\t\t\t\toutputs['printdata']['layer_gp_old']=layer_gp\r\n\r\n\t\t\t\t#======================LBP==========================\r\n\t\t\t\t\r\n\t\t\t\t#pdb.set_trace()\r\n\t\t\t\t#update: use log space for LBP\r\n\t\t\t\tif self.two_gpu:\r\n\t\t\t\t\tprint('two gpu training for LBP')\r\n\t\t\t\t\t#pdb.set_trace()\r\n\t\t\t\t\tGPUID=1\r\n\t\t\t\telse:\r\n\t\t\t\t\tGPUID=0\r\n\t\t\t\twith tf.device('/device:GPU:'+str(GPUID)): \r\n\t\t\t\t\tif self.use_sib:\r\n\t\t\t\t\t\tlayer_type=layer_sib\r\n\t\t\t\t\telif self.use_cop:\r\n\t\t\t\t\t\tlayer_type=layer_cop\r\n\t\t\t\t\telif self.use_gp:\r\n\t\t\t\t\t\tlayer_type=layer_gp\r\n\t\t\t\t\t# (n x 2 x ma x mb x mc) ab <- ac\r\n\t\t\t\t\tlog_message_sib=tf.stack([tf.zeros_like(layer_type),tf.zeros_like(layer_type)],1)\r\n\t\t\t\t\t# (n x 2 x ma x mb x mc) ab <- cb\r\n\t\t\t\t\tlog_message_cop=tf.stack([tf.zeros_like(layer_type),tf.zeros_like(layer_type)],1)\r\n\t\t\t\t\t# (n x 2 x ma x mb x mc) ab <- bc \r\n\t\t\t\t\tlog_message_gp1=tf.stack([tf.zeros_like(layer_type),tf.zeros_like(layer_type)],1)\r\n\t\t\t\t\t# (n x 2 x ma x mb x mc) ab <- ca \r\n\t\t\t\t\tlog_message_gp2=tf.stack([tf.zeros_like(layer_type),tf.zeros_like(layer_type)],1)\r\n\t\t\t\t\t#pdb.set_trace()\r\n\t\t\t\t\t#'''\r\n\t\t\t\t\tif self.layer_mask:\r\n\t\t\t\t\t\tprint('use layer mask')\r\n\t\t\t\t\t\tunary=unary*tf.cast(tf.expand_dims(tf.transpose(token_weights,[0,2,1]),-2),dtype=tf.float32)\r\n\t\t\t\t\t\tif self.remove_root_child:\r\n\t\t\t\t\t\t\t# abc -> ab,ac\r\n\t\t\t\t\t\t\tif self.use_sib:\r\n\t\t\t\t\t\t\t\tlayer_sib=layer_sib*self.token_weights_sib\r\n\t\t\t\t\t\t\t\tlog_message_sib=log_message_sib*self.token_weights_sib[:,None,:,:,:]\r\n\t\t\t\t\t\t\tif self.use_cop:\r\n\t\t\t\t\t\t\t\tlayer_cop=layer_cop*self.token_weights_cop\r\n\t\t\t\t\t\t\t\tlog_message_cop=log_message_cop*self.token_weights_cop[:,None,:,:,:]\r\n\t\t\t\t\t\t\tif self.use_gp:\r\n\t\t\t\t\t\t\t\tlayer_gp=layer_gp*self.token_weights_gp\r\n\t\t\t\t\t\t\t\tlog_message_gp1=log_message_gp1*self.token_weights_gp[:,None,:,:,:]\r\n\t\t\t\t\t\t\t\tlog_message_gp2=log_message_gp2*self.token_weights_gp2[:,None,:,:,:]\r\n\t\t\t\t\t\telse:\r\n\t\t\t\t\t\t\tif self.use_sib:\r\n\t\t\t\t\t\t\t\tlayer_sib=layer_sib*token_weights4D\r\n\t\t\t\t\t\t\tif self.use_cop:\r\n\t\t\t\t\t\t\t\tlayer_cop=layer_cop*token_weights4D\r\n\t\t\t\t\t\t\tif self.use_gp:\r\n\t\t\t\t\t\t\t\tlayer_gp=layer_gp*token_weights4D\r\n\t\t\t\t\t\t\ttoken_weights4D=tf.expand_dims(token_weights4D,1)\r\n\t\t\t\t\t\t\tif self.use_sib:\r\n\t\t\t\t\t\t\t\tlog_message_sib=log_message_sib*token_weights4D\r\n\t\t\t\t\t\t\tif self.use_cop:\r\n\t\t\t\t\t\t\t\tlog_message_cop=log_message_cop*token_weights4D\r\n\t\t\t\t\t\t\tif self.use_gp:\r\n\t\t\t\t\t\t\t\tlog_message_gp1=log_message_gp1*token_weights4D\r\n\t\t\t\t\t\t\t\tlog_message_gp2=log_message_gp2*token_weights4D\r\n\t\t\t\t\t#'''\r\n\t\t\t\t\t#(n x m x 2 x m) -> (n x 2 x m x m)\r\n\t\t\t\t\tbatch_size=nn.get_sizes(layer_sib)[0]\r\n\t\t\t\t\tunary=tf.transpose(unary,[0,2,1,3])\r\n\t\t\t\t\tif self.use_sib:\r\n\t\t\t\t\t\tlayer_sib = layer_sib-tf.linalg.band_part(layer_sib,-1,0) + tf.transpose(tf.linalg.band_part(layer_sib,0,-1),perm=[0,1,3,2])\r\n\t\t\t\t\tif self.use_gp:\r\n\t\t\t\t\t\tlayer_gp2 = tf.transpose(layer_gp,perm=[0,2,3,1])\r\n\t\t\t\t\tif self.use_cop:\r\n\t\t\t\t\t\t#(n x ma x mb x mc) -> (n x mb x ma x mc) \r\n\t\t\t\t\t\t#in order to create a symmtric tensor on ma and mc\r\n\t\t\t\t\t\tlayer_cop = tf.transpose(layer_cop,perm=[0,2,1,3])\r\n\t\t\t\t\t\t# first set lower triangle part to be zero, then assign the upper triangle part transposed to lower triangle part\r\n\t\t\t\t\t\tlayer_cop = layer_cop - tf.linalg.band_part(layer_cop,-1,0) + tf.transpose(tf.linalg.band_part(layer_cop,0,-1),perm=[0,1,3,2])\r\n\t\t\t\t\t\t# Finally (n x mb x ma x mc) -> (n x ma x mb x mc)\r\n\t\t\t\t\t\tlayer_cop = tf.transpose(layer_cop,perm=[0,2,1,3])\r\n\t\t\t\t\tfor i in range(1,int(self.num_iteration)+1):\r\n\t\t\t\t\t\t#(n x ma x mb x mc x 2)\r\n\t\t\t\t\t\tprev_sib=log_message_sib\r\n\t\t\t\t\t\tprev_cop=log_message_cop\r\n\t\t\t\t\t\tprev_gp1=log_message_gp1\r\n\t\t\t\t\t\tprev_gp2=log_message_gp2\r\n\t\t\t\t\t\t#first gp is a->b->c second is c->a->b\r\n\t\t\t\t\t\t#(n x 2 x ma x mb x mc) -> (n x 2 x ma x mb)\r\n\t\t\t\t\t\t#TODO: add mask when message passing\r\n\t\t\t\t\t\tFP=tf.reduce_sum(prev_gp1,-1)+tf.reduce_sum(prev_gp2,-1)+tf.reduce_sum(prev_cop,-1)+tf.reduce_sum(prev_sib,-1)\r\n\t\t\t\t\t\t#FP=tf.reduce_sum(prev_gp1,-1)+tf.reduce_sum(prev_gp2,-1)\r\n\t\t\t\t\t\tif debug:\r\n\t\t\t\t\t\t\toutputs['printdata']['FP0'+str(i)]=FP\r\n\t\t\t\t\t\t\toutputs['printdata']['prev_sib'+str(i)]=prev_sib\r\n\t\t\t\t\t\t\toutputs['printdata']['prev_cop'+str(i)]=prev_cop\r\n\t\t\t\t\t\t\toutputs['printdata']['prev_gp1'+str(i)]=prev_gp1\r\n\t\t\t\t\t\t\toutputs['printdata']['prev_gp2'+str(i)]=prev_gp2\r\n\t\t\t\t\t\t# remove self loop and self repeat (a b a) (a b b)\r\n\t\t\t\t\t\t#'''\r\n\t\t\t\t\t\tFP=FP-tf.transpose(tf.linalg.diag_part(tf.transpose(prev_sib,perm=[0,1,3,2,4])),perm=[0,1,3,2])-tf.linalg.diag_part(prev_sib)\r\n\t\t\t\t\t\tFP=FP-tf.transpose(tf.linalg.diag_part(tf.transpose(prev_cop,perm=[0,1,3,2,4])),perm=[0,1,3,2])-tf.linalg.diag_part(prev_cop)\r\n\t\t\t\t\t\tFP=FP-tf.transpose(tf.linalg.diag_part(tf.transpose(prev_gp1,perm=[0,1,3,2,4])),perm=[0,1,3,2])-tf.linalg.diag_part(prev_gp1)\r\n\t\t\t\t\t\tFP=FP-tf.transpose(tf.linalg.diag_part(tf.transpose(prev_gp2,perm=[0,1,3,2,4])),perm=[0,1,3,2])-tf.linalg.diag_part(prev_gp2)\r\n\t\t\t\t\t\t#'''\r\n\t\t\t\t\t\t#TODO: softmax form\r\n\t\t\t\t\t\tFP_potential=tf.expand_dims(unary+FP,-1)\r\n\t\t\t\t\t\tif self.use_sib:\r\n\t\t\t\t\t\t\t#update sibling\r\n\t\t\t\t\t\t\t#pdb.set_trace()\r\n\t\t\t\t\t\t\t#(n x 2 x ma x mc) -> (n x 2 x ma x mc x 1) - (n x 2 x ma x mc x mb)-> (n x 2 x ma x mc x mb)-> (n x 2 x ma x mb x mc)\r\n\t\t\t\t\t\t\tsib_FP=tf.transpose(FP_potential-prev_sib,perm=[0,1,2,4,3])\r\n\t\t\t\t\t\t\tlog_message_sib_0=tf.reduce_logsumexp(sib_FP,axis=1)\r\n\t\t\t\t\t\t\t#(n x ma x mb x mc) + (n x ma x mb x mc) -> (n x ma x mb x mc)\r\n\t\t\t\t\t\t\tlog_message_sib_1=tf.reduce_logsumexp(tf.stack([sib_FP[:,0],sib_FP[:,1]+layer_sib],1),axis=1)\r\n\t\t\t\t\t\t\t#(n x ma x mb x mc) -> (n x 2 x ma x mb x mc)\r\n\t\t\t\t\t\t\tlog_message_sib=tf.stack([log_message_sib_0,log_message_sib_1],axis=1)\r\n\t\t\t\t\t\tif self.use_cop:\r\n\t\t\t\t\t\t\t#update coparents\r\n\t\t\t\t\t\t\t#(n x 2 x mc x mb) -> (n x 2 x mc x mb x 1) - (n x 2 x mc x mb x ma)-> (n x 2 x mc x mb x ma)-> (n x 2 x ma x mb x mc)\r\n\t\t\t\t\t\t\tcop_FP=tf.transpose(FP_potential-prev_cop,perm=[0,1,4,3,2])\r\n\t\t\t\t\t\t\tlog_message_cop_0=tf.reduce_logsumexp(cop_FP,axis=1)\r\n\t\t\t\t\t\t\t#(n x ma x mb x mc) + (n x ma x mb x mc) -> (n x ma x mb x mc)\r\n\t\t\t\t\t\t\tlog_message_cop_1=tf.reduce_logsumexp(tf.stack([cop_FP[:,0],cop_FP[:,1]+layer_cop],1),axis=1)\r\n\t\t\t\t\t\t\t#(n x ma x mb x mc) -> (n x 2 x ma x mb x mc)\r\n\t\t\t\t\t\t\tlog_message_cop=tf.stack([log_message_cop_0,log_message_cop_1],axis=1)\r\n\t\t\t\t\t\tif self.use_gp:\r\n\t\t\t\t\t\t\t#update gp1 (a->b->c)\r\n\t\t\t\t\t\t\t#(n x 2 x ma x mc) -> (n x 2 x mb x mc x 1) - (n x 2 x mb x mc x ma)-> (n x 2 x mb x mc x ma)-> (n x 2 x ma x mb x mc)\r\n\t\t\t\t\t\t\t# Note that here gp1 should minus prev_gp2 as we need to keep ab->bc is still representing a->b->c\r\n\t\t\t\t\t\t\tgp_FP=tf.transpose(FP_potential-prev_gp2,perm=[0,1,4,2,3])\r\n\t\t\t\t\t\t\tlog_message_gp_0=tf.reduce_logsumexp(gp_FP,axis=1)\r\n\t\t\t\t\t\t\t#(n x ma x mb x mc) + (n x ma x mb x mc) -> (n x ma x mb x mc)\r\n\t\t\t\t\t\t\tlog_message_gp_1=tf.reduce_logsumexp(tf.stack([gp_FP[:,0],gp_FP[:,1]+layer_gp],1),axis=1)\r\n\t\t\t\t\t\t\t#(n x ma x mb x mc) -> (n x 2 x ma x mb x mc)\r\n\t\t\t\t\t\t\tlog_message_gp1=tf.stack([log_message_gp_0,log_message_gp_1],axis=1)\r\n\r\n\t\t\t\t\t\t\t#update gp2 (c->a->b)\r\n\t\t\t\t\t\t\t#(n x 2 x ma x mc) -> (n x 2 x mc x ma x 1) - (n x 2 x mc x ma x mb)-> (n x 2 x mc x ma x mb)-> (n x 2 x ma x mb x mc)\r\n\t\t\t\t\t\t\tgp2_FP=tf.transpose(FP_potential-prev_gp1,perm=[0,1,3,4,2])\r\n\t\t\t\t\t\t\tlog_message_gp2_0=tf.reduce_logsumexp(gp2_FP,axis=1)\r\n\t\t\t\t\t\t\t#(n x ma x mb x mc) + (n x ma x mb x mc) -> (n x ma x mb x mc)\r\n\t\t\t\t\t\t\tlog_message_gp2_1=tf.reduce_logsumexp(tf.stack([gp2_FP[:,0],gp2_FP[:,1]+layer_gp2],1),axis=1)\r\n\t\t\t\t\t\t\t#(n x ma x mb x mc) -> (n x 2 x ma x mb x mc)\r\n\t\t\t\t\t\t\tlog_message_gp2=tf.stack([log_message_gp2_0,log_message_gp2_1],axis=1)\r\n\t\t\t\t\t\tif self.normalize:\r\n\t\t\t\t\t\t\tif i==1:\r\n\t\t\t\t\t\t\t\tprint('normalize each LBP iteration')\r\n\t\t\t\t\t\t\tif self.use_sib:\r\n\t\t\t\t\t\t\t\tlog_message_sib=tf.nn.log_softmax(log_message_sib,1)\r\n\t\t\t\t\t\t\tif self.use_cop:\r\n\t\t\t\t\t\t\t\tlog_message_cop=tf.nn.log_softmax(log_message_cop,1)\r\n\t\t\t\t\t\t\tif self.use_gp:\r\n\t\t\t\t\t\t\t\tlog_message_gp1=tf.nn.log_softmax(log_message_gp1,1)\r\n\t\t\t\t\t\t\t\tlog_message_gp2=tf.nn.log_softmax(log_message_gp2,1)\r\n\t\t\t\t\t\tif self.layer_mask:\r\n\t\t\t\t\t\t\tif self.remove_root_child:\r\n\t\t\t\t\t\t\t\t# abc -> ab,ac\r\n\t\t\t\t\t\t\t\tif self.use_sib:\r\n\t\t\t\t\t\t\t\t\tlayer_sib=layer_sib*self.token_weights_sib\r\n\t\t\t\t\t\t\t\tif self.use_cop:\r\n\t\t\t\t\t\t\t\t\tlayer_cop=layer_cop*self.token_weights_cop\r\n\t\t\t\t\t\t\t\tif self.use_gp:\r\n\t\t\t\t\t\t\t\t\tlayer_gp=layer_gp*self.token_weights_gp\r\n\t\t\t\t\t\t\t\tlog_message_sib=log_message_sib*self.token_weights_sib[:,None,:,:,:]\r\n\t\t\t\t\t\t\t\tlog_message_cop=log_message_cop*self.token_weights_cop[:,None,:,:,:]\r\n\t\t\t\t\t\t\t\tlog_message_gp1=log_message_gp1*self.token_weights_gp[:,None,:,:,:]\r\n\t\t\t\t\t\t\t\tlog_message_gp2=log_message_gp2*self.token_weights_gp2[:,None,:,:,:]\r\n\t\t\t\t\t\t\telse:\r\n\t\t\t\t\t\t\t\tlog_message_sib=log_message_sib*token_weights4D\r\n\t\t\t\t\t\t\t\tlog_message_cop=log_message_cop*token_weights4D\r\n\t\t\t\t\t\t\t\tlog_message_gp1=log_message_gp1*token_weights4D\r\n\t\t\t\t\t\t\t\tlog_message_gp2=log_message_gp2*token_weights4D\r\n\t\t\t\t\t\tif debug:\r\n\t\t\t\t\t\t\t'''\r\n\t\t\t\t\t\t\toutputs['printdata']['gp2_FP'+str(i)]=gp2_FP\r\n\t\t\t\t\t\t\toutputs['printdata']['FP_potential'+str(i)]=FP_potential\r\n\t\t\t\t\t\t\toutputs['printdata']['FP4'+str(i)]=FP\r\n\t\t\t\t\t\t\toutputs['printdata']['sib_FP'+str(i)]=sib_FP\r\n\t\t\t\t\t\t\toutputs['printdata']['cop_FP'+str(i)]=cop_FP\r\n\t\t\t\t\t\t\toutputs['printdata']['gp1_FP'+str(i)]=gp_FP\r\n\t\t\t\t\t\t\toutputs['printdata']['gp2_FP'+str(i)]=gp2_FP\r\n\t\t\t\t\t\t\toutputs['printdata']['message_sib_0'+str(i)]=log_message_sib_0\r\n\t\t\t\t\t\t\toutputs['printdata']['message_sib_1'+str(i)]=log_message_sib_1\r\n\t\t\t\t\t\t\toutputs['printdata']['message_sib'+str(i)]=log_message_sib\r\n\t\t\t\t\t\t\toutputs['printdata']['message_cop_0'+str(i)]=log_message_cop_0\r\n\t\t\t\t\t\t\toutputs['printdata']['message_cop_1'+str(i)]=log_message_cop_1\r\n\t\t\t\t\t\t\toutputs['printdata']['message_cop'+str(i)]=log_message_cop\r\n\t\t\t\t\t\t\toutputs['printdata']['message_gp1'+str(i)]=log_message_gp1\r\n\t\t\t\t\t\t\toutputs['printdata']['message_gp2'+str(i)]=log_message_gp2\r\n\t\t\t\t\t\t\toutputs['printdata']['message_gp1_0'+str(i)]=log_message_gp_0\r\n\t\t\t\t\t\t\toutputs['printdata']['message_gp1_1'+str(i)]=log_message_gp_1\r\n\t\t\t\t\t\t\toutputs['printdata']['message_gp2_0'+str(i)]=log_message_gp2_0\r\n\t\t\t\t\t\t\toutputs['printdata']['message_gp2_1'+str(i)]=log_message_gp2_1\r\n\t\t\t\t\t\t\t#'''\r\n\t\t\t\t\t\t\tpass\r\n\r\n\t\t\t\t\tlog_belief=tf.reduce_sum(log_message_gp1,-1)+tf.reduce_sum(log_message_gp2,-1)+tf.reduce_sum(log_message_cop,-1)+tf.reduce_sum(log_message_sib,-1)\r\n\t\t\t\t\t#log_belief=tf.reduce_sum(log_message_gp1,-1)+tf.reduce_sum(log_message_gp2,-1)\r\n\t\t\t\t\t# remove self loop and self repeat (a b a) (a b b)\r\n\t\t\t\t\t#'''\r\n\t\t\t\t\tlog_belief=log_belief-tf.transpose(tf.linalg.diag_part(tf.transpose(log_message_sib,perm=[0,1,3,2,4])),perm=[0,1,3,2])-tf.linalg.diag_part(log_message_sib)\r\n\t\t\t\t\tlog_belief=log_belief-tf.transpose(tf.linalg.diag_part(tf.transpose(log_message_cop,perm=[0,1,3,2,4])),perm=[0,1,3,2])-tf.linalg.diag_part(log_message_cop)\r\n\t\t\t\t\tlog_belief=log_belief-tf.transpose(tf.linalg.diag_part(tf.transpose(log_message_gp1,perm=[0,1,3,2,4])),perm=[0,1,3,2])-tf.linalg.diag_part(log_message_gp1)\r\n\t\t\t\t\tlog_belief=log_belief-tf.transpose(tf.linalg.diag_part(tf.transpose(log_message_gp2,perm=[0,1,3,2,4])),perm=[0,1,3,2])-tf.linalg.diag_part(log_message_gp2)\r\n\t\t\t\t\t#'''\r\n\t\t\t\t\tlog_belief=log_belief+unary\r\n\t\t\t\t\t#q_value=belief/tf.reduce_sum(belief,axis=1,keepdims=True)\r\n\t\t\t\t\t#calculate softmax loss later\r\n\t\t\t\t\tq_value=log_belief\r\n\t\t\t\t\tif debug:\r\n\t\t\t\t\t\toutputs['printdata']['message_sib_fin']=tf.reduce_sum(log_message_sib,-1)-tf.transpose(tf.linalg.diag_part(tf.transpose(log_message_sib,perm=[0,1,3,2,4])),perm=[0,1,3,2])-tf.linalg.diag_part(log_message_sib)\r\n\t\t\t\t\t\toutputs['printdata']['message_cop_fin']=tf.reduce_sum(log_message_cop,-1)-tf.transpose(tf.linalg.diag_part(tf.transpose(log_message_cop,perm=[0,1,3,2,4])),perm=[0,1,3,2])-tf.linalg.diag_part(log_message_cop)\r\n\t\t\t\t\t\toutputs['printdata']['message_gp1_fin']=tf.reduce_sum(log_message_gp1,-1)-tf.transpose(tf.linalg.diag_part(tf.transpose(log_message_gp1,perm=[0,1,3,2,4])),perm=[0,1,3,2])-tf.linalg.diag_part(log_message_gp1)\r\n\t\t\t\t\t\toutputs['printdata']['message_gp2_fin']=tf.reduce_sum(log_message_gp2,-1)-tf.transpose(tf.linalg.diag_part(tf.transpose(log_message_gp2,perm=[0,1,3,2,4])),perm=[0,1,3,2])-tf.linalg.diag_part(log_message_gp2)\r\n\t\t\t\t\t#======================LBP==========================\r\n\r\n\t\t\t\t\r\n\t\t\t\t\t#-----------------------------------------------------------\r\n\t\t\t\t\t# Process the targetsb\r\n\t\t\t\t\t# (n x m x m) -> (n x m x m)\r\n\t\t\t\t\t#here in fact is a graph, which is m*m representing the connection between each edge\r\n\t\t\t\t\tunlabeled_targets = self.placeholder#ground truth graph, what is self.placeholder?\r\n\t\t\t\t\t#USELESS\r\n\t\t\t\t\tshape = tf.shape(unary_layer1)\r\n\t\t\t\t\tbatch_size, bucket_size = shape[0], shape[1]\r\n\t\t\t\t\t# (1 x m)\r\n\t\t\t\t\tids = tf.expand_dims(tf.range(bucket_size), 0)\r\n\t\t\t\t\t# (1 x m) -> (1 x 1 x m)\r\n\t\t\t\t\thead_ids = tf.expand_dims(ids, -2)\r\n\t\t\t\t\t# (1 x m) -> (1 x m x 1)\r\n\t\t\t\t\tdep_ids = tf.expand_dims(ids, -1)\r\n\t\t\t\t\t#pdb.set_trace()\r\n\t\t\t\t\tif debug:\r\n\t\t\t\t\t\t#outputs['printdata']['logits']=logits\r\n\t\t\t\t\t\toutputs['printdata']['q_value']=q_value\r\n\t\t\t\t\t\toutputs['printdata']['unary']=unary\r\n\t\t\t\t\t\t#outputs['printdata']['binary']=binary\r\n\t\t\t\t\t\toutputs['printdata']['belief']=log_belief\r\n\t\t\t\t\t\tif self.use_sib:\r\n\t\t\t\t\t\t\toutputs['printdata']['message_sib']=log_message_sib\r\n\t\t\t\t\t\t\toutputs['printdata']['message_sib_0']=log_message_sib_0\r\n\t\t\t\t\t\t\toutputs['printdata']['layer_sib']=layer_sib\r\n\t\t\t\t\t\tif self.use_gp:\r\n\t\t\t\t\t\t\t#outputs['printdata']['second_temp_gp']=second_temp_gp\r\n\t\t\t\t\t\t\toutputs['printdata']['message_gp1']=log_message_gp1\r\n\t\t\t\t\t\t\toutputs['printdata']['message_gp2']=log_message_gp2\r\n\t\t\t\t\t\t\toutputs['printdata']['layer_gp']=layer_gp\r\n\t\t\t\t\t\tif self.use_cop:\r\n\t\t\t\t\t\t\toutputs['printdata']['layer_cop']=layer_cop\r\n\t\t\t\t\t\t\toutputs['printdata']['message_cop']=log_message_cop\r\n\t\t\t\t\t\t#outputs['printdata']['layer1']=layer1\r\n\t\t\t\t\t\t#outputs['printdata']['layer2']=layer2\r\n\t\t\t\t\t\tif not self.separate_embed:\r\n\t\t\t\t\t\t\toutputs['printdata']['layer3']=layer3\r\n\t\t\t\t\t\toutputs['printdata']['targets']=unlabeled_targets\r\n\t\t\t\t\t\toutputs['printdata']['token_weights']=token_weights\r\n\t\t\t\t\t\tif self.sibling_only:\r\n\t\t\t\t\t\t\toutputs['printdata']['binary_weights']=binary_weights \r\n\t\t\t\t\t\t\toutputs['printdata']['binary']=layer_sib\r\n\t\t\t\t\t\tif self.new_potential:\r\n\t\t\t\t\t\t\t\t#outputs['printdata']['layer_sib2']=layer_sib2\r\n\t\t\t\t\t\t\t\toutputs['printdata']['layer_gp2']=layer_gp2\r\n\t\t\t\t\t\t\t\t#outputs['printdata']['layer_cop2']=layer_cop2\r\n\t\t\t\t\t\t\t\tpass\r\n\t\t\t\t\t\t#outputs['printdata']['binary_weights']=binary_weights\r\n\t\t\t\t\t\t'''\r\n\t\t\t\t\t\toutputs['printdata']['unary_weights']=unary_weights\r\n\t\t\t\t\t\toutputs['printdata']['binary_weights']=binary_weights\r\n\t\t\t\t\t\toutputs['printdata']['binary_weights_cop']=binary_weights_cop\r\n\t\t\t\t\t\toutputs['printdata']['binary_weights_gp']=binary_weights_gp\r\n\t\t\t\t\t\t#'''\r\n\r\n\t\t\t\t\t#no running here\r\n\t\t\t\t\tif self.linearize:\r\n\t\t\t\t\t\t# Wherever the head is to the left\r\n\t\t\t\t\t\t# (n x m x m), (1 x m x 1) -> (n x m x m)\r\n\t\t\t\t\t\tlin_targets = tf.to_float(tf.less(unlabeled_targets, dep_ids))\r\n\t\t\t\t\t\t# cross-entropy of the linearization of each i,j pair\r\n\t\t\t\t\t\t# (1 x 1 x m), (1 x m x 1) -> (n x m x m)\r\n\t\t\t\t\t\tlin_ids = tf.tile(tf.less(head_ids, dep_ids), [batch_size, 1, 1])\r\n\t\t\t\t\t\t# (n x 1 x m), (n x m x 1) -> (n x m x m)\r\n\t\t\t\t\t\tlin_xent = -tf.nn.softplus(tf.where(lin_ids, -lin_logits, lin_logits))\r\n\t\t\t\t\t\t# add the cross-entropy to the logits\r\n\t\t\t\t\t\t# (n x m x m), (n x m x m) -> (n x m x m)\r\n\t\t\t\t\t\tlogits += tf.stop_gradient(lin_xent)\r\n\t\t\t\t\tif self.distance:\r\n\t\t\t\t\t\t# (n x m x m) - (1 x m x 1) -> (n x m x m)\r\n\t\t\t\t\t\tdist_targets = tf.abs(unlabeled_targets - dep_ids)\r\n\t\t\t\t\t\t# KL-divergence of the distance of each i,j pair\r\n\t\t\t\t\t\t# (1 x 1 x m) - (1 x m x 1) -> (n x m x m)\r\n\t\t\t\t\t\tdist_ids = tf.to_float(tf.tile(tf.abs(head_ids - dep_ids), [batch_size, 1, 1]))+1e-12\r\n\t\t\t\t\t\t# (n x m x m), (n x m x m) -> (n x m x m)\r\n\t\t\t\t\t\t#dist_kld = (dist_ids * tf.log(dist_lamda / dist_ids) + dist_ids - dist_lamda)\r\n\t\t\t\t\t\tdist_kld = -tf.log((dist_ids - dist_lamda)**2/2 + 1)\r\n\t\t\t\t\t\t# add the KL-divergence to the logits\r\n\t\t\t\t\t\t# (n x m x m), (n x m x m) -> (n x m x m)\r\n\t\t\t\t\t\tlogits += tf.stop_gradient(dist_kld)\r\n\t\t\t\t\t#pdb.set_trace()\r\n\t\t\t\t\t#-----------------------------------------------------------\r\n\t\t\t\t\t# Note: here need a transpose as the target is the transpose graph(or opposite direction of adjacency graph)\r\n\t\t\t\t\t# (n x 2 x ma x mb) -> (n x 2 x mb x ma)\r\n\t\t\t\t\tif self.transposed:\r\n\t\t\t\t\t\tq_value=tf.transpose(q_value, [0,1,3,2])\r\n\t\t\t\t\t# Compute probabilities/cross entropy\r\n\t\t\t\t\t# (n x 2 x m x m) -> (n x m x m x 2)\r\n\t\t\t\t\ttransposed_logits = tf.transpose(q_value, [0,2,3,1])\r\n\t\t\t\t\tprobabilities=tf.nn.softmax(transposed_logits) * tf.to_float(tf.expand_dims(token_weights, axis=-1))\r\n\t\t\t\t\t#TODO: what I want is still a probability of label 1, compared to the origin sigmoid(logits)? check later\r\n\t\t\t\t\tprobabilities=probabilities[:,:,:,1]\r\n\t\t\t\t\t#label_probabilities = tf.nn.softmax(transposed_logits) * tf.to_float(tf.expand_dims(token_weights, axis=-1))\r\n\t\t\t\t\t# (n x m x m), (n x m x m x c), (n x m x m) -> ()\r\n\t\t\t\t\t# change sparse_softmax_cross_entropy to softmax_cross_entropy? It is the same in this situation\r\n\t\t\t\t\tloss = tf.losses.sparse_softmax_cross_entropy(unlabeled_targets, transposed_logits, weights=token_weights)\r\n\t\t\t\t\t#loss = tf.losses.sparse_sigmoid_cross_entropy(unlabeled_targets, transposed_logits, weights=token_weights)\r\n\t\t\t\t\t#pdb.set_trace()\r\n\t\t\t\t\t'''\r\n\t\t\t\t\ttransposed_logits=tf.nn.softmax(transposed_logits,-1)\r\n\t\t\t\t\tL2_target=tf.cast(unlabeled_targets,dtype=tf.float32)\r\n\t\t\t\t\tloss = tf.reduce_sum((tf.pow(L2_target-transposed_logits[:,:,:,1],2)+tf.pow(1-L2_target-transposed_logits[:,:,:,0],2))\\\r\n\t\t\t\t\t\t\t*tf.cast(token_weights,dtype=tf.float32))/tf.cast(batch_size,dtype=tf.float32)\r\n\t\t\t\t\tif debug:\r\n\t\t\t\t\t\toutputs['printdata']['L2_target']=L2_target\r\n\t\t\t\t\t\toutputs['printdata']['transposed_logits']=transposed_logits\r\n\t\t\t\t\t#'''\r\n\t\t\t\t\tif self.combine_loss:\r\n\t\t\t\t\t\tprint('use combined loss')\r\n\t\t\t\t\t\tunary_probs=-unary\r\n\t\t\t\t\t\t# similar to q_value\r\n\t\t\t\t\t\tif self.transposed:\r\n\t\t\t\t\t\t\tunary_probs=tf.transpose(unary_probs,[0,3,2,1])\r\n\t\t\t\t\t\tunary_probs=tf.transpose(unary_probs, [0,1,3,2])\r\n\t\t\t\t\t\t#loss /= 2\r\n\t\t\t\t\t\tloss = loss*self.loss_weight + tf.losses.sparse_softmax_cross_entropy(unlabeled_targets, unary_probs, weights=token_weights)*self.loss_weight_unary\r\n\t\t\t\t\t'''\r\n\t\t\t\t\t# (n x m x m) -> (n x m x m)\r\n\t\t\t\t\tprobabilities = tf.nn.sigmoid(logits) * tf.to_float(token_weights)#token weights is sentence length?\r\n\t\t\t\t\t# (n x m x m), (n x m x m), (n x m x m) -> ()\r\n\t\t\t\t\tloss = tf.losses.sigmoid_cross_entropy(unlabeled_targets, logits, weights=token_weights)#here label_smoothing is 0, the sigmoid XE have any effect?\r\n\t\t\t\t\t'''\r\n\t\t\t\t\tn_tokens = tf.to_float(tf.reduce_sum(token_weights))\r\n\t\t\t\t\tif self.linearize:\r\n\t\t\t\t\t\tlin_target_xent = lin_xent * unlabeled_targets\r\n\t\t\t\t\t\tloss -= tf.reduce_sum(lin_target_xent * tf.to_float(token_weights)) / (n_tokens + 1e-12)\r\n\t\t\t\t\tif self.distance:\r\n\t\t\t\t\t\tdist_target_kld = dist_kld * unlabeled_targets\r\n\t\t\t\t\t\tloss -= tf.reduce_sum(dist_target_kld * tf.to_float(token_weights)) / (n_tokens + 1e-12)\r\n\t\t\t\t\t\r\n\t\t\t\t\t#-----------------------------------------------------------\r\n\t\t\t\t\t# Compute predictions/accuracy \r\n\t\t\t\t\t# precision/recall\r\n\t\t\t\t\t# (n x m x m) -> (n x m x m)\r\n\t\t\t\t\t#predictions = nn.greater(logits, 0, dtype=tf.int32) * token_weights#edge that predicted\r\n\t\t\t\t\tpredictions = tf.argmax(transposed_logits, axis=-1, output_type=tf.int32) * token_weights\r\n\t\t\t\t\t# if self.compare_precision:\r\n\t\t\t\t\t# \tcond = tf.equal(transposed_logits[:,:,:,1], tf.expand_dims(tf.reduce_max(transposed_logits[:,:,:,1],-1),-1))\r\n\t\t\t\t\t# \tpredictions = tf.where(cond, tf.cast(cond,tf.float32), tf.zeros_like(transposed_logits[:,:,:,1])) \r\n\t\t\t\t\t# \tpredictions = tf.cast(predictions,tf.int32) * token_weights\r\n\t\t\t\t\t\t\r\n\t\t\t\t\t# (n x m x m) (*) (n x m x m) -> (n x m x m)\r\n\t\t\t\t\ttrue_positives = predictions * unlabeled_targets\r\n\t\t\t\t\t# (n x m x m) -> ()\r\n\t\t\t\t\tn_predictions = tf.reduce_sum(predictions)\r\n\t\t\t\t\tn_targets = tf.reduce_sum(unlabeled_targets)\r\n\t\t\t\t\tn_true_positives = tf.reduce_sum(true_positives)\r\n\t\t\t\t\t# () - () -> ()\r\n\t\t\t\t\tn_false_positives = n_predictions - n_true_positives\r\n\t\t\t\t\tn_false_negatives = n_targets - n_true_positives\r\n\t\t\t\t\t# (n x m x m) -> (n)\r\n\t\t\t\t\tn_targets_per_sequence = tf.reduce_sum(unlabeled_targets, axis=[1,2])\r\n\t\t\t\t\tn_true_positives_per_sequence = tf.reduce_sum(true_positives, axis=[1,2])\r\n\t\t\t\t\t# (n) x 2 -> ()\r\n\t\t\t\t\tn_correct_sequences = tf.reduce_sum(nn.equal(n_true_positives_per_sequence, n_targets_per_sequence))\r\n\t\t\t#-----------------------------------------------------------\r\n\t\t\t# Populate the output dictionary\r\n\t\t\tif debug:\r\n\t\t\t\toutputs['printdata']['logits']=transposed_logits\r\n\t\t\t\toutputs['printdata']['loss']=loss\r\n\t\t\t#print(123)\r\n\t\t\toutputs['unlabeled_targets'] = unlabeled_targets\r\n\t\t\toutputs['probabilities'] = probabilities\r\n\t\t\toutputs['unlabeled_loss'] = loss\r\n\t\t\toutputs['loss'] = loss\r\n\t\t\t\r\n\t\t\toutputs['unlabeled_predictions'] = predictions\r\n\t\t\toutputs['n_unlabeled_true_positives'] = n_true_positives\r\n\t\t\toutputs['n_unlabeled_false_positives'] = n_false_positives\r\n\t\t\toutputs['n_unlabeled_false_negatives'] = n_false_negatives\r\n\t\t\toutputs['n_correct_unlabeled_sequences'] = n_correct_sequences\r\n\t\t\toutputs['predictions'] = predictions\r\n\t\t\toutputs['n_true_positives'] = n_true_positives\r\n\t\t\toutputs['n_false_positives'] = n_false_positives\r\n\t\t\toutputs['n_false_negatives'] = n_false_negatives\r\n\t\t\toutputs['n_correct_sequences'] = n_correct_sequences\r\n\t\t\treturn outputs\r\n\t\r\n\t\r\n\t#=============================================================\r\n\t# token should be: 1:rel|2:acl|5:dep or 1|2|5\r\n\tdef index(self, token):\r\n\t\t\"\"\"\"\"\"\r\n\t\t\r\n\t\tnodes = []\r\n\t\tif token != '_':\r\n\t\t\ttoken = token.split('|')\r\n\t\t\tfor edge in token:\r\n\t\t\t\thead = edge.split(':')[0]\r\n\t\t\t\tnodes.append(int(head))\r\n\t\treturn nodes\r\n\t\r\n\t#=============================================================\r\n\t# index should be [1, 2, 5]\r\n\tdef token(self, index):\r\n\t\t\"\"\"\"\"\"\r\n\t\t\r\n\t\treturn [str(head) for head in index]\r\n\t\r\n\t#=============================================================\r\n\tdef get_root(self):\r\n\t\t\"\"\"\"\"\"\r\n\t\t\r\n\t\treturn '_'\r\n\t\r\n\t#=============================================================\r\n\tdef __getitem__(self, key):\r\n\t\tif isinstance(key, six.string_types):\r\n\t\t\tnodes = []\r\n\t\t\tif key != '_':\r\n\t\t\t\ttoken = key.split('|')\r\n\t\t\t\tfor edge in token:\r\n\t\t\t\t\thead = edge.split(':')[0]\r\n\t\t\t\t\tnodes.append(int(head))\r\n\t\t\treturn nodes\r\n\t\telif hasattr(key, '__iter__'):\r\n\t\t\tif len(key) > 0:\r\n\t\t\t\tif isinstance(key[0], six.integer_types + (np.int32, np.int64)):\r\n\t\t\t\t\treturn '|'.join([str(head) for head in key])\r\n\t\t\t\telse:\r\n\t\t\t\t\treturn [self[k] for k in key]\r\n\t\t\telse:\r\n\t\t\t\treturn '_'\r\n\t\telse:\r\n\t\t\traise ValueError('Key to GraphIndexVocab.__getitem__ must be (iterable of) strings or iterable of integers')\r\n\t\r\n#***************************************************************\r\n\r\nclass SecondOrderGraphLBPVocab(GraphSecondLBPVocab, cv.SemheadVocab):\r\n\tpass\r\n", "meta": {"hexsha": "b17c856188818bcc31d6789b0cab089df75fa824", "size": 47435, "ext": "py", "lang": "Python", "max_stars_repo_path": "parser/structs/vocabs/second_order_LBP_vocab.py", "max_stars_repo_name": "shtechair/Second_Order_SDP", "max_stars_repo_head_hexsha": "d8e90aef1ff9bade86d602790adf08e37ed4c746", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 41, "max_stars_repo_stars_event_min_datetime": "2019-07-12T13:57:29.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-16T15:54:25.000Z", "max_issues_repo_path": "parser/structs/vocabs/second_order_LBP_vocab.py", "max_issues_repo_name": "shtechair/Second_Order_SDP", "max_issues_repo_head_hexsha": "d8e90aef1ff9bade86d602790adf08e37ed4c746", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2019-08-04T06:19:04.000Z", "max_issues_repo_issues_event_max_datetime": "2021-06-15T06:34:51.000Z", "max_forks_repo_path": "parser/structs/vocabs/second_order_LBP_vocab.py", "max_forks_repo_name": "shtechair/Second_Order_SDP", "max_forks_repo_head_hexsha": "d8e90aef1ff9bade86d602790adf08e37ed4c746", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2019-09-30T06:24:14.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-17T13:53:13.000Z", "avg_line_length": 42.0896184561, "max_line_length": 214, "alphanum_fraction": 0.6280172868, "include": true, "reason": "import numpy", "num_tokens": 13253, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.519521321952093, "lm_q2_score": 0.3775406687981454, "lm_q1q2_score": 0.1961404273446898}} {"text": "# -*- coding: utf-8 -*-\r\n\"\"\"\r\nCreated on Mon May 3 15:59:09 2021\r\n\r\nThis file is is and adaptation of the WorkMATe source code, from the article:\r\n \"Flexible Working Memory through Selective Gating and Attentional Tagging\"\r\nWouter Kruijne, Sander M Bohte, Pieter R Roelfsema, Christian N L Olivers\r\n\r\n-------------------\r\nThe class defined in this file implements the WorkMATe model;\r\nEntry point for the model is the 'step()' function which defined what WorkMATe\r\ndoes during a single time step; this entails: \r\n1- the feedforward sweep to determine its next action, \r\n2- Learning: update the weights in response to any potentially obtained reward\r\n3- recurrent attentional feedback to place synaptic tags on connections \r\n responsible for the selected action. \r\n4- Executing the desired action, including possibly storing \r\n an observation in memory.\r\n\r\nSeveral extensions are added to the original code --> making it a Deep WorkMATe\r\nwith CIFAAR-10 inputs and a locally learned matching function. \r\n1- An extra layer was added (latent) \r\n2- Timestamp is added at latent level, learning rate is set to 0.05\r\n3- Only weight updates are performed between trials\r\n4- Both CIFAR-10 latent features and the alphabet can be used as a stimulus dictionary\r\n\r\n@author: Lieke Ceton\r\n\"\"\"\r\n#%% Dependencies\r\n\r\nimport numpy as np \r\n\r\nfrom stimuli import obs_time, obs_cifar, match_cifar, obs_alpha, match_alpha\r\nfrom matchnet import MatchNet, cosine_similarity\r\n\r\n#%% Define WorkMATe architecture\r\n\r\n#np.random.seed(20)\r\nclass WorkMATe(object):\r\n \"\"\"\r\n Architecture schematic:\r\n x -- l -- S\r\n \\/\r\n h\r\n |\r\n [q_int|q_ext]\r\n \"\"\"\r\n def __init__(self, env=None, nhidden=25, nblocks=2, block_size=20, lr=0.05, wh=0.5):\r\n super(WorkMATe, self).__init__()\r\n \r\n #np.random.seed(20)\r\n assert env is not None\r\n self.env=env\r\n \r\n ## learning params (adopted from Rombouts et al., 2015)\r\n self.beta = lr\r\n self.gamma = 0.90\r\n self.L = 0.8\r\n # exploration:\r\n self.epsilon = 0.025\r\n self.bias = 1\r\n print('Agent WorkMATe_match initialising')\r\n \r\n ## member lambda functions:\r\n # sigmoid transfer function, offset at 2.5\r\n sigmoid_offset = 2.5\r\n self.transfer = lambda x: 1 / ( 1. + np.exp(sigmoid_offset - x) )\r\n self.dtransfer= lambda x: x * (1. - x) # derivative\r\n \r\n # softmax normalization; for action selection - boltzmann controller\r\n self.softmaxnorm = lambda x: (\r\n np.exp( x - x.max() ) / np.exp( x - x.max() ) .sum() )\r\n\r\n ## init network architecture -- inputs and output shape from env\r\n # input and hidden\r\n #nx = inputs.get_obs('a').size\r\n nl = block_size\r\n nh = nhidden\r\n # memory cell properties:\r\n self.nblocks = nblocks\r\n self.block_size = block_size\r\n nS = nblocks * block_size\r\n \r\n # output -- q layer consisting of 2 modules\r\n # module for n external actions, internal actions for nblocks + 1 (null) \r\n mod_sz = env.n_actions, nblocks + 1\r\n nq = np.sum(mod_sz)\r\n # indices of module for each node:\r\n self.zmods = np.hstack( [ [i] * sz for i, sz in enumerate( mod_sz ) ] )\r\n\r\n ## init network layers (activations 0)\r\n # (x will be constructed when processing 'new_obs')\r\n time_input = obs_time().size\r\n if self.env.stim_type == 'alpha':\r\n letter_input = obs_alpha().size\r\n if self.env.stim_type == 'cifar':\r\n letter_input = obs_cifar().size\r\n \r\n self.S = np.zeros( nS )\r\n self.l = np.zeros( nl )\r\n self.h = np.zeros( nh ) \r\n self.q = np.zeros( nq ) \r\n\r\n ## init weights, tags traces, (+1 indicates projection from bias node)\r\n wl, wh = -wh, wh\r\n \r\n #Characteristics used as attributes for step_match()\r\n self.ch = [letter_input, nl, nh, nS, wh, wl] \r\n \r\n # Memory projection (x > S)\r\n #self.W_Sx = np.random.sample( (nS, nx) ) * (wh-wl) + wl \r\n self.W_Sl = np.random.sample( (nS, nl) ) * (wh-wl) + wl \r\n # Note that time and sensory input cells are not separated in memory\r\n\r\n # PLASTIC CONNECTIONS (all except memory projection)\r\n \r\n # Input projection with bias node\r\n self.W_lx = np.random.sample((nl, letter_input + 1))*(wh-wl) + wl\r\n #self.W_lx = np.array(W_lx)\r\n self.W_lx_start = np.copy(self.W_lx)\r\n \r\n # connections l -> h; nl + match nodes + bias\r\n self.W_hl = np.random.sample( (nh, time_input + nl + nblocks + 1) ) * (wh-wl) + wl\r\n self.W_hl_start = np.copy(self.W_hl)\r\n\r\n # connections S-> h:\r\n self.W_hS = np.random.sample( (nh, nS ) ) * (wh-wl) + wl\r\n # connections h-> q:\r\n self.W_qh = np.random.sample( (nq, nh + 1) ) * (wh-wl) + wl\r\n \r\n # tags are shaped like weights but initialized at 0:\r\n zeros_ = np.zeros_like\r\n # W_lx is only updated between trials to keep memory trace stable \r\n # W_lx_trial accumulates all changes made within a trial \r\n self.W_lx_trial = zeros_(self.W_lx)\r\n\r\n #initialise tags\r\n self.Tag_W_lx, self.Trace_W_lx = zeros_(self.W_lx), zeros_(self.W_lx)\r\n self.Tag_W_hl, self.Trace_W_hl = zeros_(self.W_hl), zeros_(self.W_hl)\r\n self.Tag_W_hS, self.Trace_W_hS = zeros_(self.W_hS), zeros_(self.W_hS)\r\n self.Tag_W_qh, self.Trace_W_qh = zeros_(self.W_qh), zeros_(self.W_qh)\r\n \r\n ## Init matchnet:\r\n dummy_inp = np.zeros(block_size) #dummy input of length S == Sproj and Memory\r\n self.matchnet = [MatchNet(dummy_inp, dummy_inp) for item in range(self.nblocks)]\r\n \r\n # Init action state\r\n self.action = -1\r\n # (prev) predicted reward:\r\n self.qat_1 = self.qat = None\r\n self.t = 0 \r\n return\r\n\r\n def _intertrial_reset(self):\r\n \"\"\"\r\n Reset time, memory, tags and traces\r\n \"\"\"\r\n # update weights W_lx with the accumulated weight updates from the whole trial \r\n self.W_lx += self.W_lx_trial\r\n\r\n # reset time and memory\r\n self.t = 0 \r\n self.S *= 0\r\n\r\n # previous action = zeros \r\n self.z *= 1 #I set this from 0 to 1, it does not seem to change anything\r\n # reset tags/traces for each Wmat\r\n zeros_ = np.zeros_like\r\n self.Tag_W_lx, self.Trace_W_lx = zeros_(self.W_lx), zeros_(self.W_lx)\r\n self.Tag_W_hl, self.Trace_W_hl = zeros_(self.W_hl), zeros_(self.W_hl)\r\n self.Tag_W_hS, self.Trace_W_hS = zeros_(self.W_hS), zeros_(self.W_hS)\r\n self.Tag_W_qh, self.Trace_W_qh = zeros_(self.W_qh), zeros_(self.W_qh)\r\n #reset accumulated weight updates W_lx\r\n self.W_lx_trial = zeros_(self.W_lx)\r\n \r\n # reset 'current action', and the like\r\n self.action = -1\r\n self.qat = None\r\n return\r\n \r\n def step_match(self):\r\n if self.env.stim_type == 'cifar':\r\n self.x_sens = match_cifar() #get random input\r\n elif self.env.stim_type == 'alpha':\r\n self.x_sens = match_alpha() #get random input\r\n \r\n self.x = np.r_[self.x_sens, self.bias]\r\n Sproj = self.compute_latent() #Compute the memory projection\r\n Sproj = Sproj.reshape((self.nblocks, self.block_size)) \r\n \r\n #Decide on trial type and thus on memory content\r\n #For each memory block there is a match network\r\n #tt is the trial type: 0 is match, 1 is mismatch\r\n #If tt = 0, the memory is updated to the current input\r\n #The chance is around equal to save or not\r\n tt = np.random.choice([0,1], self.nblocks, p=[0.5, 0.5])\r\n S_ = self.S.reshape( (self.nblocks, self.block_size) )\r\n for i in range(self.nblocks):\r\n if tt[i] == 0:\r\n S_[i,:] = Sproj[i,:]#the S projection should be here!\r\n \r\n #Compute the match values\r\n m, tt, corr = self.compute_match(Sproj)\r\n \r\n #Noise/random changes in weights W_lx and W_Sl\r\n self.W_lx = np.random.sample((self.ch[1], self.ch[0] + 1))*(0.5--0.5) - 0.5\r\n self.W_Sl = np.random.sample((self.ch[3], self.ch[1]))*(self.ch[4]-self.ch[5]) + self.ch[5]\r\n\r\n return m, tt, corr #return match values and trial_types\r\n \r\n def step(self):\r\n # get observation and reward from env\r\n self.obs, self.r = self.env.step(self.action) \r\n # do feedforward:\r\n #matches, tt_match = self._feedforward()\r\n matches, tt = self._feedforward() \r\n # learn from the obtained reward\r\n self._learn()\r\n # end of trial?\r\n if 'RESET' == self.obs: #change in to == because the observation is now an integer not a string\r\n self._intertrial_reset()\r\n return self.r, None, None #fake matches\r\n # do feedback (tag placement)\r\n self._feedback()\r\n # act (internal, external)\r\n self._act()\r\n self.t += 1\r\n #return self.r, matches #, tt_match\r\n return self.r, matches, tt\r\n\r\n def _feedforward(self):\r\n # shift previous action\r\n self.qat_1 = self.qat\r\n if 'RESET' == self.obs: #change in to == because the observation is now an integer not a string\r\n # however, we do not expect RESET to ever only be part of the observation so the equal to boolean should be good enough\r\n # no meaningful feedforward sweep: qat is not computed\r\n self.qat = None\r\n return None, None #return fake match\r\n # else:\r\n # compute input, hidden, output:\r\n self.construct_input()\r\n Sproj = self.compute_latent()\r\n matches, tt, _ = self.compute_match(Sproj)\r\n self.compute_hidden(matches)\r\n self.compute_output()\r\n # determine z from q (action selection)\r\n self.action_selection()\r\n # determine new qat\r\n self.qat = (self.z * self.q).sum()\r\n return matches, tt\r\n\r\n def _learn(self):\r\n \"\"\"\r\n Learn from the reward; compute RPE and update weights\r\n general form form delta = r + gamma * qat - qat_1\r\n ...but there are edge cases\r\n \"\"\"\r\n r = self.r\r\n if self.qat and self.qat_1: # regular\r\n delta = r + (self.gamma * self.qat) - self.qat_1\r\n elif self.qat_1 is None: # first step\r\n delta = r + (self.gamma * self.qat) - self.qat\r\n else: # self.qa(t) is None (final step):\r\n delta = r - self.qat_1\r\n self.delta = delta\r\n self.update_weights()\r\n return\r\n\r\n def _feedback(self):\r\n # updates traces and tags, based on action selection:\r\n # traces and tags\r\n self.update_traces()\r\n self.update_tags()\r\n return\r\n\r\n def _act(self):\r\n # external and internal actions:\r\n zext = self.z[self.zmods == 0]\r\n zint = self.z[self.zmods == 1]\r\n self.action = np.argmax(zext)\r\n self.update_memory( zint )\r\n return\r\n\r\n def construct_input(self):\r\n \"\"\"\r\n Turn obs into a vector; uses coding defined in 'inputs.py'\r\n \"\"\"\r\n # input consists of: observation and time t\r\n self.x_time = obs_time(self.t) #time-part\r\n #letter-part\r\n if self.env.stim_type == 'alpha':\r\n self.x_sens = obs_alpha(self.obs)\r\n #self.x_sens = inputs.obs_alpha_with_noise(self.obs)\r\n if self.env.stim_type == 'cifar':\r\n self.x_sens = obs_cifar(self.obs)\r\n #self.x_sens = inputs.obs_orthogonal(self.obs)\r\n #self.x_sens = inputs.get_obs(self.obs, self.t) #only letter-part\r\n self.x = np.r_[self.x_sens, self.bias] #only bias included \r\n return\r\n \r\n def compute_latent(self):\r\n # x -> l \r\n self.l_in = self.W_lx.dot(self.x)\r\n # Compute l activities\r\n self.l_sens = self.transfer(np.r_[self.l_in]) \r\n # Compute match value:\r\n Sproj = self.W_Sl.dot(self.l_in).reshape( (self.nblocks, self.block_size) )\r\n return Sproj\r\n \r\n def compute_match(self, Sproj):\r\n #output = self.matchnet.step(x,y)\r\n matches = []\r\n corr = []\r\n tt = []\r\n S_ = self.S.reshape( (self.nblocks, self.block_size) )\r\n for i in range(self.nblocks):\r\n m, _ = self.matchnet[i].step(Sproj[i,:], S_[i,:])\r\n cos_corr = cosine_similarity(Sproj[i,:], S_[i,:])\r\n corr.append(cos_corr)\r\n matches.append(m)\r\n if np.all(Sproj[i,:] == S_[i,:]):\r\n tt_match = 0\r\n else: \r\n tt_match = 1\r\n tt.append(tt_match)\r\n return matches, tt, corr\r\n \r\n def compute_hidden(self, matches):\r\n # add match nodes + bias to input vector\r\n #add time-part here\r\n self.l_out = np.r_[self.x_time, self.l_sens, matches, self.bias] #the matches are added here now\r\n \r\n # x->h + S->h\r\n self.S_out = self.S\r\n\r\n # Compute Ha and h\r\n h_in = self.W_hl.dot(self.l_out) + self.W_hS.dot(self.S_out)\r\n self.h_out = np.r_[self.transfer(h_in), self.bias] # bias added\r\n return\r\n\r\n def compute_output(self):\r\n # hidden output (has bias added)\r\n self.q = self.W_qh.dot(self.h_out)\r\n # (no transfer, q nodes are linear)\r\n return\r\n\r\n def action_selection(self):\r\n #np.random.seed(self.seed)\r\n # using q, per module, determine z (based on argmax or exploration)\r\n self.z = np.zeros_like(self.q)\r\n # action selection for both modules separately\r\n for mod_idx in np.unique(self.zmods):\r\n qvec = self.q[self.zmods == mod_idx] # get the module's qvalues \r\n # check exploration; if not just take argmax:\r\n if ( np.random.sample() >= self.epsilon ):\r\n action = np.argmax(qvec)\r\n else: # compute softmax over Q and explore:\r\n pvec = self.softmaxnorm(qvec)\r\n action = np.random.choice( list(range(qvec.size)), p = pvec) \r\n # set zvec: 1-hot code of actions: \r\n zvec = np.zeros_like(qvec)\r\n zvec[ action ] = 1.0\r\n # place zvec into z at the right indices:\r\n self.z[self.zmods == mod_idx] = zvec\r\n return\r\n\r\n def update_weights(self):\r\n \"\"\"\r\n all Weight-Trace pairs are updated with the same rule:\r\n w += beta * delta * tag\r\n \"\"\"\r\n #Only update W_lx during intertrial resets\r\n #Accumulate changes during trial and update later\r\n self.W_lx_trial += self.beta * self.delta * self.Tag_W_lx\r\n \r\n #Change the weights between h and S slower to have memory..\r\n self.W_hS += self.beta * self.delta * self.Tag_W_hS\r\n \r\n wt_pairs = ( \r\n ( self.W_hl, self.Tag_W_hl ), \r\n ( self.W_qh, self.Tag_W_qh )) #added by LJC\r\n for W, Tag in wt_pairs:\r\n W += self.beta * self.delta * Tag\r\n \r\n return\r\n\r\n def update_traces(self):\r\n \"\"\"\r\n Traces are the intermediate layers' markers\r\n The Traces are a relic from old AuGMEnT code, have no 'meaning' here\r\n \"\"\"\r\n # Regulars, are replaced by new input:\r\n self.Trace_W_lx *= 0.0\r\n self.Trace_W_hl *= 0.0\r\n self.Trace_W_hS *= 0.0\r\n # add 1 x X vec to H x X matrix yields H copies of 1 x X vec\r\n self.Trace_W_lx += self.x.reshape(1, self.x.size) # this includes trace for bias\r\n self.Trace_W_hl += self.l_out.reshape(1, self.l_out.size) # this includes trace for bias\r\n self.Trace_W_hS += self.S_out.reshape(1, self.S.size)\r\n return\r\n\r\n def update_tags(self):\r\n \r\n # 1. old tag decay:\r\n alltags = (self.Tag_W_lx, self.Tag_W_hl, self.Tag_W_hS, self.Tag_W_qh)\r\n for Tag in alltags:\r\n Tag *= (self.L * self.gamma)\r\n\r\n # 2. form new tags:\r\n # tags onto output units: selected action.\r\n self.Tag_W_qh[self.z.astype('bool'), :] += self.h_out\r\n\r\n # feedback to hidden\r\n dh = self.dtransfer(self.h_out[:-1])\r\n self.fbh = self.W_qh[self.z.astype('bool'), :-1] # excluding the bias node\r\n self.fbh = self.fbh.sum(axis = 0 ) # summed contribution of all actions\r\n self.feedbackh = self.fbh * dh\r\n self.Tag_W_hS += np.expand_dims(self.feedbackh, 1) * self.Trace_W_hS\r\n #update tag hl\r\n self.Tag_W_hl += np.expand_dims(self.feedbackh, 1) * self.Trace_W_hl \r\n \r\n #feedback to latent\r\n dl = self.dtransfer(self.l_sens)\r\n self.fbh_transfer = self.dtransfer(self.fbh) #the feedback onto h is transferred through the hidden layer\r\n #W_hl_no_m = self.W_hl[:,:-3] #no match no bias, no time-part\r\n #W_hl_no_m = self.W_hl[:,10:30]\r\n \r\n W_hl_no_m = self.W_hl[:,obs_time().size:-(self.nblocks + 1)] #only learn back onto the stimulus input, not the time inputs (exclude the bias node)\r\n #inputs.obs_time().size\r\n \r\n self.W_hl_transpose = W_hl_no_m.T\r\n self.fhl = self.W_hl_transpose.dot(self.fbh_transfer) #for each node in l, all active h units are summed\r\n self.feedbackl = self.fhl * dl\r\n self.Tag_W_lx += np.expand_dims(self.feedbackl,1) * self.Trace_W_lx\r\n return\r\n\r\n def update_memory(self, zvec):\r\n # final z is 'do not gate'; nothing happens then\r\n if not zvec[-1] == 1:\r\n # else:\r\n gate_idx = np.argmax(zvec)\r\n l = self.l_in #this excludes bias- and match\r\n S_ = self.S.reshape( (self.nblocks, self.block_size) )\r\n W_ = self.W_Sl.reshape( S_.shape + (l.size, ) ) \r\n # project x->S (encode)\r\n Sproj = W_.dot(l)\r\n # store @ gated 'stripe'\r\n S_[gate_idx,:] = Sproj[gate_idx,:]\r\n # transform S back to its flat representation\r\n self.S = S_.reshape(self.S.shape)\r\n return\r\n \r\n\r\n\r\n", "meta": {"hexsha": "7706072e41df151cad1f27974c2d56d23afb536e", "size": 18202, "ext": "py", "lang": "Python", "max_stars_repo_path": "workmate_match.py", "max_stars_repo_name": "lieke2020/workmate_match", "max_stars_repo_head_hexsha": "803f4e3b1fa62280cc0d6a7cd61eb80929dae918", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "workmate_match.py", "max_issues_repo_name": "lieke2020/workmate_match", "max_issues_repo_head_hexsha": "803f4e3b1fa62280cc0d6a7cd61eb80929dae918", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "workmate_match.py", "max_forks_repo_name": "lieke2020/workmate_match", "max_forks_repo_head_hexsha": "803f4e3b1fa62280cc0d6a7cd61eb80929dae918", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.0043956044, "max_line_length": 155, "alphanum_fraction": 0.5720799912, "include": true, "reason": "import numpy", "num_tokens": 4650, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.519521321952093, "lm_q2_score": 0.37754065479083276, "lm_q1q2_score": 0.19614042006759222}} {"text": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n# -----------------------------------------------------------------------------\n# glumpy is an OpenGL framework for the fast visualization of numpy arrays.\n# Copyright (C) 2009-2011 Nicolas P. Rougier. All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or without\n# modification, are permitted provided that the following conditions are met:\n#\n# 1. Redistributions of source code must retain the above copyright notice,\n# this list of conditions and the following disclaimer.\n#\n# 2. Redistributions in binary form must reproduce the above copyright\n# notice, this list of conditions and the following disclaimer in the\n# documentation and/or other materials provided with the distribution.\n#\n# THIS SOFTWARE IS PROVIDED BY NICOLAS P. ROUGIER ''AS IS'' AND ANY EXPRESS OR\n# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\n# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO\n# EVENT SHALL NICOLAS P. ROUGIER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,\n# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n#\n# The views and conclusions contained in the software and documentation are\n# those of the authors and should not be interpreted as representing official\n# policies, either expressed or implied, of Nicolas P. Rougier.\n# -----------------------------------------------------------------------------\n'''\nA filter is a shader that transform the current displayed texture. Since\nshaders cannot be easily serialized within the GPU, they have to be well\nstructured on the python side such that we can possibly merge them into a\nsingle source code for both vertex and fragment. Consequently, there is a\ndefault code for both vertex and fragment with specific entry points such that\nfilter knows where to insert their specific code (declarations, functions and\ncall (or code) to be inserted in the main function).\n\nSpatial interpolation filter classes for OpenGL textures.\n\nEach filter generates a one-dimensional lookup table (weights value from 0 to\nceil(radius)) that is uploaded to video memory (as a 1d texture) and is then\nread by the shader when necessary. It avoids computing weight values for each\npixel. Furthemore, each 2D-convolution filter is separable and can be computed\nusing 2 1D-convolution with same 1d-kernel (= the lookup table values).\n\nAvailable filters:\n\n - Nearest (radius 0.5)\n - Bilinear (radius 1.0)\n - Hanning (radius 1.0)\n - Hamming (radius 1.0)\n - Hermite (radius 1.0)\n - Kaiser (radius 1.0)\n - Quadric (radius 1.5)\n - Bicubic (radius 2.0)\n - CatRom (radius 2.0)\n - Mitchell (radius 2.0)\n - Spline16 (radius 2.0)\n - Spline36 (radius 4.0)\n - Gaussian (radius 2.0)\n - Bessel (radius 3.2383)\n - Sinc (radius 4.0)\n - Lanczos (radius 4.0)\n - Blackman (radius 4.0)\n\n\nNote::\n\n Weights code has been translated from the antigrain geometry library\n available at http://www.antigrain.com/\n'''\n\n\nimport math\nimport numpy as np\n\n\nclass SpatialFilter(object):\n ''' '''\n\n def __init__(self, radius=1.0):\n self.radius = radius\n\n def weight(self, x):\n '''\n Return filter weight for a distance x.\n\n :Parameters:\n ``x`` : 0 < float < ceil(self.radius)\n Distance to be used to compute weight.\n '''\n raise NotImplemented\n\n def kernel(self, size=4*512):\n radius = self.radius\n r = int(max(1.0, math.ceil(radius)))\n samples = int(size / r)\n n = size # r*samples\n kernel = np.zeros(n)\n X = np.linspace(0, r, n)\n for i in range(n):\n kernel[i] = self.weight(X[i])\n N = np.zeros(samples)\n for i in range(r):\n N += kernel[::+1][i*samples:(i+1)*samples]\n N += kernel[::-1][i*samples:(i+1)*samples]\n for i in range(r):\n kernel[i*samples:(i+1)*samples:+1] /= N\n return kernel\n\n def filter_code(self):\n\n n = int(math.ceil(self.radius))\n filter_1 = 'filter1D_radius%d' % n\n filter_2 = 'filter2D_radius%d' % n\n\n code = ''\n code += 'vec4\\n'\n code += '%s( sampler2D kernel, float index, float x, ' % filter_1\n for i in range(2*n):\n if i == 2*n-1:\n code += 'vec4 c%d )\\n' % i\n else:\n code += 'vec4 c%d, ' % i\n code += '{\\n'\n code += ' float w, w_sum = 0.0;\\n'\n code += ' vec4 r = vec4(0.0,0.0,0.0,0.0);\\n'\n for i in range(n):\n code += ' w = unpack_interpolate(kernel, vec2(%f+(x/%.1f), index));\\n' % (1.0 - (i + 1) / float(n), n) # noqa\n code += ' w = w*kernel_scale + kernel_bias;\\n' # noqa\n # code += ' w_sum += w;'\n code += ' r += c%d * w;\\n' % i\n code += ' w = unpack_interpolate(kernel, vec2(%f-(x/%.1f), index));\\n' % ((i+1)/float(n), n) # noqa\n code += ' w = w*kernel_scale + kernel_bias;\\n'\n # code += ' w_sum += w;'\n code += ' r += c%d * w;\\n' % (i + n)\n # code += ' return r/w_sum;\\n'\n code += ' return r;\\n'\n code += '}\\n'\n code += \"\\n\"\n code += 'vec4\\n'\n code += '%s' % filter_2\n code += '(sampler2D texture, sampler2D kernel, float index, vec2 uv, vec2 pixel)\\n' # noqa\n code += '{\\n'\n code += ' vec2 texel = uv/pixel - vec2(0.5, 0.5) ;\\n'\n code += ' vec2 f = fract(texel);\\n'\n code += ' texel = (texel-fract(texel) + vec2(0.001, 0.001)) * pixel;\\n' # noqa\n for i in range(2*n):\n code += ' vec4 t%d = %s(kernel, index, f.x,\\n' % (i, filter_1)\n for j in range(2*n):\n x, y = (-n+1+j, -n+1+i)\n code += ' texture2D( texture, texel + vec2(%d, %d) * pixel),\\n' % (x, y) # noqa\n\n # Remove last trailing',' and close function call\n code = code[:-2] + ');\\n'\n\n code += ' return %s(kernel, index, f.y, ' % filter_1\n for i in range(2*n):\n code += 't%d, ' % i\n\n # Remove last trailing',' and close function call\n code = code[:-2] + ');\\n'\n code += '}\\n'\n\n return code\n\n def call_code(self, index):\n code = \"\"\n n = int(math.ceil(self.radius))\n filter_1 = 'filter1D_radius%d' % n # noqa\n filter_2 = 'filter2D_radius%d' % n\n\n code += 'vec4 %s(sampler2D texture, vec2 shape, vec2 uv)\\n' % self.__class__.__name__ # noqa\n code += '{'\n code += ' return %s(texture, u_kernel, %f, uv, 1.0/shape); ' % (filter_2, index) # noqa\n code += '}\\n'\n return code\n\n\nclass Nearest(SpatialFilter):\n '''\n Nearest (=None) filter (radius = 0.5).\n\n Weight function::\n\n w(x) = 1\n\n '''\n\n def __init__(self):\n SpatialFilter.__init__(self, radius=.5)\n\n def weight(self, x):\n return 1.0\n\n def _get_code(self):\n self.build_LUT()\n code = 'vec4\\n'\n code += 'interpolate(sampler2D texture, sampler1D kernel, vec2 uv, vec2 pixel)\\n' # noqa\n code += '{\\n return texture2D(texture, uv);\\n}\\n'\n return code\n code = property(_get_code, doc='''filter functions code''')\n\n\nclass Bilinear(SpatialFilter):\n '''\n Bilinear filter (radius = 1.0).\n\n Weight function::\n\n w(x) = 1 - x\n\n '''\n\n def __init__(self):\n SpatialFilter.__init__(self, radius=1.0)\n\n def weight(self, x):\n return 1.0 - x\n\n\nclass Hanning(SpatialFilter):\n '''\n Hanning filter (radius = 1.0).\n\n Weight function::\n\n w(x) = 0.5 + 0.5 * cos(pi * x)\n\n '''\n\n def __init__(self):\n SpatialFilter.__init__(self, radius=1.0)\n\n def weight(self, x):\n return 0.5 + 0.5 * math.cos(math.pi * x)\n\n\nclass Hamming(SpatialFilter):\n '''\n Hamming filter (radius = 1.0).\n\n Weight function::\n\n w(x) = 0.54 + 0.46 * cos(pi * x)\n\n '''\n\n def __init__(self):\n SpatialFilter.__init__(self, radius=1.0)\n\n def weight(self, x):\n return 0.54 + 0.46 * math.cos(math.pi * x)\n\n\nclass Hermite(SpatialFilter):\n ''' Hermite filter (radius = 1.0).\n\n Weight function::\n\n w(x) = (2*x-3)*x^2 + 1\n\n '''\n\n def __init__(self):\n SpatialFilter.__init__(self, radius=1.0)\n\n def weight(self, x):\n return (2.0 * x - 3.0) * x * x + 1.0\n\n\nclass Quadric(SpatialFilter):\n '''\n Quadric filter (radius = 1.5).\n\n Weight function::\n\n | 0.0 ≤ x < 0.5: 0.75 - x*x\n w(x) = | 0.5 ≤ x < 1.5: 0.5 - (x-1.5)^2\n | 1.5 ≤ x : 0\n\n '''\n\n def __init__(self):\n SpatialFilter.__init__(self, radius=1.5)\n\n def weight(self, x):\n if x < 0.75:\n return 0.75 - x * x\n elif x < 1.5:\n t = x - 1.5\n return 0.5 * t * t\n else:\n return 0.0\n\n\nclass Bicubic(SpatialFilter):\n '''\n Bicubic filter (radius = 2.0).\n\n Weight function::\n\n w(x) = 1/6((x+2)^3 - 4*(x+1)^3 + 6*x^3 -4*(x-1)^3)\n '''\n\n def __init__(self):\n SpatialFilter.__init__(self, radius=2.0)\n\n def pow3(self, x):\n if x <= 0:\n return 0\n else:\n return x * x * x\n\n def weight(self, x):\n return (1.0/6.0) * (self.pow3(x + 2) -\n 4 * self.pow3(x + 1) +\n 6 * self.pow3(x) -\n 4 * self.pow3(x - 1))\n\n\nclass Kaiser(SpatialFilter):\n '''\n Kaiser filter (radius = 1.0).\n\n\n Weight function::\n\n w(x) = bessel_i0(a sqrt(1-x^2)* 1/bessel_i0(b)\n\n '''\n\n def __init__(self, b=6.33):\n self.a = b\n self.epsilon = 1e-12\n self.i0a = 1.0 / self.bessel_i0(b)\n SpatialFilter.__init__(self, radius=1.0)\n\n def bessel_i0(self, x):\n s = 1.0\n y = x * x / 4.0\n t = y\n i = 2\n while t > self.epsilon:\n s += t\n t *= float(y) / (i * i)\n i += 1\n return s\n\n def weight(self, x):\n if x > 1:\n return 0\n return self.bessel_i0(self.a * math.sqrt(1.0 - x * x)) * self.i0a\n\n\nclass CatRom(SpatialFilter):\n '''\n Catmull-Rom filter (radius = 2.0).\n\n Weight function::\n\n | 0 ≤ x < 1: 0.5*(2 + x^2*(-5+x*3))\n w(x) = | 1 ≤ x < 2: 0.5*(4 + x*(-8+x*(5-x)))\n | 2 ≤ x : 0\n\n '''\n\n def __init__(self, size=256*8):\n SpatialFilter.__init__(self, radius=2.0)\n\n def weight(self, x):\n if x < 1.0:\n return 0.5 * (2.0 + x * x * (-5.0 + x * 3.0))\n elif x < 2.0:\n return 0.5 * (4.0 + x * (-8.0 + x * (5.0 - x)))\n else:\n return 0.0\n\n\nclass Mitchell(SpatialFilter):\n '''\n Mitchell-Netravali filter (radius = 2.0).\n\n Weight function::\n\n | 0 ≤ x < 1: p0 + x^2*(p2 + x*p3)\n w(x) = | 1 ≤ x < 2: q0 + x*(q1 + x*(q2 + x*q3))\n | 2 ≤ x : 0\n\n '''\n\n def __init__(self, b=1.0/3.0, c=1.0/3.0):\n self.p0 = (6.0 - 2.0 * b) / 6.0\n self.p2 = (-18.0 + 12.0 * b + 6.0 * c) / 6.0\n self.p3 = (12.0 - 9.0 * b - 6.0 * c) / 6.0\n self.q0 = (8.0 * b + 24.0 * c) / 6.0\n self.q1 = (-12.0 * b - 48.0 * c) / 6.0\n self.q2 = (6.0 * b + 30.0 * c) / 6.0\n self.q3 = (-b - 6.0 * c) / 6.0\n SpatialFilter.__init__(self, radius=2.0)\n\n def weight(self, x):\n if x < 1.0:\n return self.p0 + x * x * (self.p2 + x * self.p3)\n elif x < 2.0:\n return self.q0 + x * (self.q1 + x * (self.q2 + x * self.q3))\n else:\n return 0.0\n\n\nclass Spline16(SpatialFilter):\n '''\n Spline16 filter (radius = 2.0).\n\n Weight function::\n\n | 0 ≤ x < 1: ((x-9/5)*x - 1/5)*x + 1\n w(x) = |\n | 1 ≤ x < 2: ((-1/3*(x-1) + 4/5)*(x-1) - 7/15 )*(x-1)\n\n '''\n\n def __init__(self):\n SpatialFilter.__init__(self, radius=2.0)\n\n def weight(self, x):\n if x < 1.0:\n return ((x - 9.0/5.0) * x - 1.0/5.0) * x + 1.0\n else:\n return ((-1.0/3.0 * (x-1) + 4.0/5.0) * (x-1) - 7.0/15.0) * (x-1)\n\n\nclass Spline36(SpatialFilter):\n '''\n Spline36 filter (radius = 3.0).\n\n Weight function::\n\n | 0 ≤ x < 1: ((13/11*x - 453/209)*x -3/209)*x +1\n w(x) = | 1 ≤ x < 2: ((-6/11*(x-1) - 270/209)*(x-1) -156/209)*(x-1)\n | 2 ≤ x < 3: (( 1/11*(x-2) - 45/209)*(x-2) + 26/209)*(x-2)\n '''\n\n def __init__(self):\n SpatialFilter.__init__(self, radius=3.0)\n\n def weight(self, x):\n if x < 1.0:\n return ((13.0/11.0 * x - 453.0/209.0) * x - 3.0/209.0) * x + 1.0\n elif x < 2.0:\n return ((-6.0/11.0 * (x-1) + 270.0/209.0) * (x-1) - 156.0 / 209.0) * (x-1) # noqa\n else:\n return ((1.0 / 11.0 * (x-2) - 45.0/209.0) * (x - 2) + 26.0/209.0) * (x-2) # noqa\n\n\nclass Gaussian(SpatialFilter):\n '''\n Gaussian filter (radius = 2.0).\n\n Weight function::\n\n w(x) = exp(-2x^2) * sqrt(2/pi)\n\n Note::\n\n This filter does not seem to be correct since:\n\n x = np.linspace(0, 1.0, 100 )\n f = weight\n z = f(x+1)+f(x)+f(1-x)+f(2-x)\n\n z should be 1 everywhere but it is not the case and it produces \"grid\n effects\".\n '''\n def __init__(self):\n SpatialFilter.__init__(self, radius=2.0)\n\n def weight(self, x):\n return math.exp(-2.0 * x * x) * math.sqrt(2.0 / math.pi)\n\n\nclass Bessel(SpatialFilter):\n '''\n Bessel filter (radius = 3.2383).\n '''\n\n def __init__(self):\n SpatialFilter.__init__(self, radius=3.2383)\n\n def besj(self, x, n):\n '''\n Function BESJ calculates Bessel function of first kind of order n\n Arguments:\n x - value at which the Bessel function is required\n n - an integer (>=0), the order\n --------------------\n C++ Mathematical Library\n Converted from equivalent FORTRAN library\n Converted by Gareth Walker for use by course 392 computational project\n All functions tested and yield the same results as the corresponding\n FORTRAN versions.\n\n If you have any problems using these functions please report them to\n M.Muldoon@UMIST.ac.uk\n\n Documentation available on the web\n http://www.ma.umist.ac.uk/mrm/Teaching/392/libs/392.html\n Version 1.0 8/98\n 29 October, 1999\n --------------------\n Adapted for use in AGG library by\n Andy Wilk (castor.vulgaris@gmail.com)\n Adapted for use in vispy library by\n Nicolas P. Rougier (Nicolas.Rougier@inria.fr)\n -----------------------------------------------------------------------\n '''\n if n < 0:\n return 0.0\n x = float(x) # force float type\n\n d = 1e-6\n b = 0\n if math.fabs(x) <= d:\n if n != 0:\n return 0\n return 1\n\n b1 = 0 # b1 is the value from the previous iteration\n # Set up a starting order for recurrence\n m1 = int(math.fabs(x)) + 6\n if math.fabs(x) > 5:\n m1 = int(math.fabs(1.4 * x + 60 / x))\n\n m2 = int(n + 2 + math.fabs(x) / 4)\n if m1 > m2:\n m2 = m1\n\n # Apply recurrence down from current max order\n while True:\n c3 = 0\n c2 = 1e-30\n c4 = 0\n m8 = 1\n if m2 // 2 * 2 == m2:\n m8 = -1\n\n imax = m2 - 2\n for i in range(1, imax+1):\n c6 = 2 * (m2 - i) * c2 / x - c3\n c3 = c2\n c2 = c6\n if m2 - i - 1 == n:\n b = c6\n m8 = -1 * m8\n if m8 > 0:\n c4 = c4 + 2 * c6\n\n c6 = 2 * c2 / x - c3\n if n == 0:\n b = c6\n c4 += c6\n b /= c4\n if math.fabs(b - b1) < d:\n return b\n b1 = b\n m2 += 3\n\n def weight(self, x):\n if x == 0.0:\n return math.pi/4.0\n else:\n return self.besj(math.pi * x, 1) / (2.0 * x)\n\n\nclass Sinc(SpatialFilter):\n '''\n Sinc filter (radius = 4.0).\n\n Weight function::\n\n\n '''\n\n def __init__(self, size=256, radius=4.0):\n SpatialFilter.__init__(self, radius=max(radius, 2.0))\n\n def weight(self, x):\n if x == 0.0:\n return 1.0\n x *= math.pi\n return (math.sin(x) / x)\n\n\nclass Lanczos(SpatialFilter):\n '''\n Lanczos filter (radius = 4.0).\n\n Weight function::\n\n\n '''\n\n def __init__(self, size=256, radius=4.0):\n SpatialFilter.__init__(self, radius=max(radius, 2.0))\n\n def weight(self, x):\n if x == 0.0:\n return 1.0\n elif x > self.radius:\n return 0.0\n x *= math.pi\n xr = x / self.radius\n return (math.sin(x) / x) * (math.sin(xr)/xr)\n\n\nclass Blackman(SpatialFilter):\n '''\n Blackman filter (radius = 4.0).\n '''\n\n def __init__(self, size=256, radius=4.0):\n SpatialFilter.__init__(self, radius=max(radius, 2.0))\n\n def weight(self, x):\n if x == 0.0:\n return 1.0\n elif x > self.radius:\n return 0.0\n x *= math.pi\n xr = x / self.radius\n return (math.sin(x) / x) * (0.42 + 0.5*math.cos(xr) + 0.08*math.cos(2*xr)) # noqa\n\n\n# Generate kernels texture (16 x 1024)\nfilters = [Bilinear(), Hanning(), Hamming(), Hermite(),\n Kaiser(), Quadric(), Bicubic(), CatRom(),\n Mitchell(), Spline16(), Spline36(), Gaussian(),\n Bessel(), Sinc(), Lanczos(), Blackman()]\n\nn = 1024\nK = np.zeros((16, n))\nfor i, f in enumerate(filters):\n K[i] = f.kernel(n)\n\nbias = K.min()\nscale = K.max()-K.min()\nK = (K-bias)/scale\nnp.save(\"spatial-filters.npy\", K.astype(np.float32))\n\nprint(\"// ------------------------------------\")\nprint(\"// Automatically generated, do not edit\")\nprint(\"// ------------------------------------\")\nprint(\"\")\nprint(\"const float kernel_bias = %f;\" % bias)\nprint(\"const float kernel_scale = %f;\" % scale)\nprint(\"const float kernel_size = %f;\" % n)\nprint(\"const vec4 bits = vec4(1.0, 1.0/256.0, 1.0/(256.0*256.0), 1.0/(256.0*256.0*256.0));\") # noqa\nprint(\"uniform sampler2D u_kernel;\")\nprint(\"\")\n\ncode = 'float\\n'\ncode += 'unpack_unit(vec4 rgba)\\n'\ncode += '{\\n'\ncode += '\\t// return rgba.r; // uncomment this for r32f debugging\\n'\ncode += '\\treturn dot(rgba, bits);\\n'\ncode += '}\\n'\nprint(code.expandtabs(4))\n\ncode = 'float\\n'\ncode += 'unpack_ieee(vec4 rgba)\\n'\ncode += '{\\n'\ncode += '\\t// return rgba.r; // uncomment this for r32f debugging\\n'\ncode += '\\trgba.rgba = rgba.abgr * 255.;\\n'\ncode += '\\tfloat sign = 1.0 - step(128.0,rgba[0])*2.0;\\n'\ncode += '\\tfloat exponent = 2.0 * mod(rgba[0],128.0) + ' \\\n 'step(128.0,rgba[1]) - 127.0;\\n'\ncode += '\\tfloat mantissa = mod(rgba[1],128.0)*65536.0 + rgba[2]*256.0 + ' \\\n 'rgba[3] + float(0x800000);\\n'\ncode += '\\treturn sign * exp2(exponent) * (mantissa * exp2(-23.));\\n'\ncode += '}\\n'\nprint(code.expandtabs(4))\n\ncode = 'float\\n'\ncode += 'unpack_interpolate(sampler2D kernel, vec2 uv)\\n'\ncode += '{\\n'\ncode += '\\t// return texture2D(kernel, uv).r; ' \\\n '//uncomment this for r32f debug without interpolation\\n'\ncode += '\\tfloat kpixel = 1. / kernel_size;\\n'\ncode += '\\tfloat u = uv.x / kpixel;\\n'\ncode += '\\tfloat v = uv.y;\\n'\ncode += '\\tfloat uf = fract(u);\\n'\ncode += '\\tu = (u - uf) * kpixel;\\n'\ncode += '\\n'\ncode += '\\tfloat d0 = unpack_unit(texture2D(kernel, vec2(u, v)));\\n'\ncode += '\\tfloat d1 = unpack_unit(texture2D(kernel, vec2(u + 1. * kpixel, v)));\\n' # noqa\ncode += '\\treturn mix(d0, d1, uf);\\n'\ncode += '}\\n'\nprint(code.expandtabs(4))\n\nF = SpatialFilter(1.0)\nprint(F.filter_code())\nF = SpatialFilter(2.0)\nprint(F.filter_code())\nF = SpatialFilter(3.0)\nprint(F.filter_code())\nF = SpatialFilter(4.0)\nprint(F.filter_code())\n\n# Generate filter functions\n# Special case for nearest\nprint(\"\"\"vec4 Nearest(sampler2D texture, vec2 shape, vec2 uv)\"\"\")\nprint(\"\"\"{ return texture2D(texture,uv); }\\n\"\"\")\n\nfor i, f in enumerate(filters):\n print(f.call_code((i+0.5)/16.0))\n", "meta": {"hexsha": "ab0637ef172f519823e87461d7b9e5f784d4bd5c", "size": 20504, "ext": "py", "lang": "Python", "max_stars_repo_path": "vispy/glsl/build-spatial-filters.py", "max_stars_repo_name": "mkkb/vispy", "max_stars_repo_head_hexsha": "8540f8d96fe3af84ba80bde6d6bf55484eaa8e3a", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-03-23T18:32:06.000Z", "max_stars_repo_stars_event_max_datetime": "2019-03-23T18:32:06.000Z", "max_issues_repo_path": "vispy/glsl/build-spatial-filters.py", "max_issues_repo_name": "mkkb/vispy", "max_issues_repo_head_hexsha": "8540f8d96fe3af84ba80bde6d6bf55484eaa8e3a", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "vispy/glsl/build-spatial-filters.py", "max_forks_repo_name": "mkkb/vispy", "max_forks_repo_head_hexsha": "8540f8d96fe3af84ba80bde6d6bf55484eaa8e3a", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-03-18T19:35:17.000Z", "max_forks_repo_forks_event_max_datetime": "2019-03-18T19:35:17.000Z", "avg_line_length": 28.5173852573, "max_line_length": 125, "alphanum_fraction": 0.520630121, "include": true, "reason": "import numpy", "num_tokens": 6489, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5621765008857981, "lm_q2_score": 0.3486451488696663, "lm_q1q2_score": 0.19600010984235716}} {"text": "import torch\nimport numpy as np\n# 19-4-12 pytorch\n\n# input: coeff with shape [1,257]\ndef Split_coeff(coeff):\n id_coeff = coeff[:,:80] # identity(shape) coeff of dim 80\n ex_coeff = coeff[:,80:144] # expression coeff of dim 64\n tex_coeff = coeff[:,144:224] # texture(albedo) coeff of dim 80\n angles = coeff[:,224:227] # ruler angles(x,y,z) for rotation of dim 3\n gamma = coeff[:,227:254] # lighting coeff for 3 channel SH function of dim 27\n translation = coeff[:,254:] # translation coeff of dim 3\n\n return id_coeff,ex_coeff,tex_coeff,angles,gamma,translation\n\n# CHJ_ADD\nclass _need_const:\n import numpy as np\n a0 = np.pi\n a1 = 2 * np.pi / np.sqrt(3.0)\n a2 = 2 * np.pi / np.sqrt(8.0)\n c0 = 1 / np.sqrt(4 * np.pi)\n c1 = np.sqrt(3.0) / np.sqrt(4 * np.pi)\n c2 = 3 * np.sqrt(5.0) / np.sqrt(12 * np.pi)\n d0 = 0.5/ np.sqrt(3.0)\n\n illu_consts=[a0, a1, a2, c0, c1, c2, d0]\n\n focal = 1015.0\n center = 112.0\n cam_pos = 10\n p_matrix = np.concatenate([[focal], [0.0], [center], [0.0], [focal], [center], [0.0], [0.0], [1.0]],\n axis=0).astype(np.float32) # projection matrix\n p_matrix = np.reshape(p_matrix, [1, 3, 3])\n p_matrix = torch.from_numpy(p_matrix)\n gpu_p_matrix = None\n\n\n# compute face shape with identity and expression coeff, based on BFM model\n# input: id_coeff with shape [1,80]\n# ex_coeff with shape [1,64]\n# output: face_shape with shape [1,N,3], N is number of vertices\ndef Shape_formation(id_coeff,ex_coeff,facemodel):\n n_b = id_coeff.size(0)\n face_shape = torch.einsum('ij,aj->ai',facemodel.idBase,id_coeff) + \\\n torch.einsum('ij,aj->ai',facemodel.exBase,ex_coeff) + \\\n facemodel.meanshape\n\n face_shape = face_shape.view(n_b,-1,3)\n # re-center face shape\n face_shape = face_shape - facemodel.meanshape.view(1, -1, 3).mean(dim=1, keepdim=True)\n\n return face_shape\n\n# compute vertex texture(albedo) with tex_coeff\n# input: tex_coeff with shape [1,N,3]\n# output: face_texture with shape [1,N,3], RGB order, range from 0-255\ndef Texture_formation(tex_coeff,facemodel):\n n_b = tex_coeff.size(0)\n face_texture = torch.einsum('ij,aj->ai',facemodel.texBase,tex_coeff) + facemodel.meantex\n\n face_texture = face_texture.view(n_b,-1,3)\n return face_texture\n\n# compute vertex normal using one-ring neighborhood\n# input: face_shape with shape [1,N,3]\n# output: v_norm with shape [1,N,3]\ndef Compute_norm(face_shape,facemodel):\n\n face_id = facemodel.tri # vertex index for each triangle face, with shape [F,3], F is number of faces\n point_id = facemodel.point_buf # adjacent face index for each vertex, with shape [N,8], N is number of vertex\n shape = face_shape\n \n v1 = shape[:,face_id[:,0],:]\n v2 = shape[:,face_id[:,1],:]\n v3 = shape[:,face_id[:,2],:]\n e1 = v1 - v2\n e2 = v2 - v3\n face_norm = e1.cross(e2) # compute normal for each face\n empty = torch.zeros((face_norm.size(0), 1, 3), dtype=face_norm.dtype, device=face_norm.device)\n\n face_norm = torch.cat((face_norm, empty), 1) # concat face_normal with a zero vector at the end\n\n v_norm = face_norm[:,point_id,:].sum(2) # compute vertex normal using one-ring neighborhood \n # CHJ: not average, directly normalize\n v_norm = v_norm/v_norm.norm(dim=2).unsqueeze(2) # normalize normal vectors\n\n return v_norm\n\n\n# compute rotation matrix based on 3 ruler angles\n# input: angles with shape [1,3]\n# output: rotation matrix with shape [1,3,3]\ndef Compute_rotation_matrix(angles):\n\n n_b = angles.size(0)\n sinx = torch.sin(angles[:, 0])\n siny = torch.sin(angles[:, 1])\n sinz = torch.sin(angles[:, 2])\n cosx = torch.cos(angles[:, 0])\n cosy = torch.cos(angles[:, 1])\n cosz = torch.cos(angles[:, 2])\n\n rotXYZ = torch.eye(3).view(1, 3, 3).repeat(n_b * 3, 1, 1).view(3, n_b, 3, 3)\n\n if angles.is_cuda: rotXYZ = rotXYZ.cuda(angles.get_device())\n\n rotXYZ[0, :, 1, 1] = cosx\n rotXYZ[0, :, 1, 2] = -sinx\n rotXYZ[0, :, 2, 1] = sinx\n rotXYZ[0, :, 2, 2] = cosx\n rotXYZ[1, :, 0, 0] = cosy\n rotXYZ[1, :, 0, 2] = siny\n rotXYZ[1, :, 2, 0] = -siny\n rotXYZ[1, :, 2, 2] = cosy\n rotXYZ[2, :, 0, 0] = cosz\n rotXYZ[2, :, 0, 1] = -sinz\n rotXYZ[2, :, 1, 0] = sinz\n rotXYZ[2, :, 1, 1] = cosz\n\n rotation = rotXYZ[2].bmm(rotXYZ[1]).bmm(rotXYZ[0])\n\n return rotation.permute(0, 2, 1)\n\n# project 3D face onto image plane\n# input: face_shape with shape [1,N,3]\n# rotation with shape [1,3,3]\n# translation with shape [1,3]\n# output: face_projection with shape [1,N,2]\n# z_buffer with shape [1,N,1]\ndef Projection_layer(face_shape,rotation,translation,focal=1015.0,center=112.0): # we choose the focal length and camera position empirically\n\n n_b, nV, _ = face_shape.size()\n if face_shape.is_cuda:\n if _need_const.gpu_p_matrix is None:\n _need_const.gpu_p_matrix = _need_const.p_matrix.cuda(face_shape.get_device())\n\n p_matrix = _need_const.gpu_p_matrix.expand(n_b, 3, 3)\n else:\n p_matrix = _need_const.p_matrix.expand(n_b, 3, 3)\n\n face_shape_r = face_shape.bmm(rotation) # CHJ: R has been transposed\n face_shape_t = face_shape_r + translation.view(n_b, 1, 3)\n\n face_shape_t[:, :, 2] = _need_const.cam_pos - face_shape_t[:, :, 2]\n\n aug_projection = face_shape_t.bmm(p_matrix.permute(0, 2, 1))\n\n #print(aug_projection)\n #exit()\n\n face_projection = aug_projection[:, :, 0:2] / aug_projection[:, :, 2:]\n \n # CHJ_WARN: I do this for visualization\n z_buffer = _need_const.cam_pos - aug_projection[:, :, 2:] # CHJ: same as the z of face_shape_t\n\n return face_projection, z_buffer\n\n# CHJ: It's different from what I knew.\n# compute vertex color using face_texture and SH function lighting approximation\n# input: face_texture with shape [1,N,3]\n# norm with shape [1,N,3]\n# gamma with shape [1,27]\n# output: face_color with shape [1,N,3], RGB order, range from 0-255\n# lighting with shape [1,N,3], color under uniform texture\n\ndef Illumination_layer(face_texture, norm, gamma):\n\n n_b, num_vertex, _ = face_texture.size()\n n_v_full = n_b * num_vertex\n gamma = gamma.view(-1, 3, 9).clone() \n gamma[:, :, 0] += 0.8\n\n gamma = gamma.permute(0, 2, 1)\n\n a0, a1, a2, c0, c1, c2, d0 = _need_const.illu_consts\n\n Y0 = torch.ones(n_v_full).float() * a0*c0\n if gamma.is_cuda: Y0=Y0.cuda(gamma.get_device())\n norm = norm.view(-1, 3)\n nx, ny, nz = norm[:,0], norm[:,1], norm[:,2]\n arrH = []\n\n arrH.append( Y0 )\n arrH.append(-a1*c1*ny)\n arrH.append(a1*c1*nz)\n arrH.append(-a1*c1*nx)\n arrH.append(a2*c2*nx*ny)\n arrH.append(-a2*c2*ny*nz)\n arrH.append(a2*c2*d0*(3*nz.pow(2)-1))\n arrH.append(-a2*c2*nx*nz)\n arrH.append(a2*c2*0.5*(nx.pow(2)-ny.pow(2)))\n\n H = torch.stack(arrH, 1)\n Y = H.view(n_b, num_vertex, 9)\n\n # Y shape:[batch,N,9].\n\n # shape:[batch,N,3]\n lighting = Y.bmm(gamma)\n\n face_color = face_texture * lighting\n #lighting *= 128\n\n #print( face_color[0, 5] )\n return face_color,lighting\n\n# face reconstruction with coeff and BFM model\ndef Reconstruction(coeff,facemodel):\n id_coeff,ex_coeff,tex_coeff,angles,gamma,translation = Split_coeff(coeff)\n\n # compute face shape\n face_shape = Shape_formation(id_coeff, ex_coeff, facemodel)\n # compute vertex texture(albedo)\n face_texture = Texture_formation(tex_coeff, facemodel)\n #print(face_texture[0, 2])\n # vertex normal\n face_norm = Compute_norm(face_shape,facemodel)\n # rotation matrix\n rotation = Compute_rotation_matrix(angles)\n face_norm_r = face_norm.bmm(rotation)\n\n # compute vertex projection on image plane (with image sized 224*224)\n face_projection,z_buffer = Projection_layer(face_shape,rotation,translation)\n \n # compute vertex color using SH function lighting approximation\n face_color,lighting = Illumination_layer(face_texture, face_norm_r, gamma)\n\n # vertex index for each face of BFM model\n tri = facemodel.tri\n\n\n face_shape = torch.matmul(face_shape,rotation)\n face_shape = face_shape + torch.reshape(translation,[-1,1,3])\n\n return face_shape, angles,face_color,tri,face_projection,z_buffer,gamma\n\n\n\ndef Reconstruction_for_render(coeff,facemodel):\n id_coeff,ex_coeff,tex_coeff,angles,gamma,translation = Split_coeff(coeff)\n face_shape = Shape_formation(id_coeff, ex_coeff, facemodel)\n face_texture = Texture_formation(tex_coeff, facemodel)\n face_norm = Compute_norm(face_shape,facemodel)\n rotation = Compute_rotation_matrix(angles)\n face_shape_r = torch.matmul(face_shape,rotation)\n face_shape_r = face_shape_r + torch.reshape(translation,[-1,1,3])\n face_norm_r = torch.matmul(face_norm,rotation)\n face_color,lighting = Illumination_layer(face_texture, face_norm_r, gamma)\n tri = facemodel.tri\n\n return face_shape_r,face_norm_r,face_color,tri", "meta": {"hexsha": "8cf8da4aa4d12bce6f87d0dd4bef799d76fffb57", "size": 8887, "ext": "py", "lang": "Python", "max_stars_repo_path": "mmRegressor/reconstruct_mesh.py", "max_stars_repo_name": "yeongjoonJu/Occlusion-Robust-3D-Face-CFR-GAN", "max_stars_repo_head_hexsha": "1966faf9bfe8d8afd6bc2cea88e5400ce3be54d5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 15, "max_stars_repo_stars_event_min_datetime": "2021-11-01T08:09:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T06:45:14.000Z", "max_issues_repo_path": "mmRegressor/reconstruct_mesh.py", "max_issues_repo_name": "yeongjoonJu/Occlusion-Robust-3D-Face-CFR-GAN", "max_issues_repo_head_hexsha": "1966faf9bfe8d8afd6bc2cea88e5400ce3be54d5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-03-10T11:08:20.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-10T11:23:13.000Z", "max_forks_repo_path": "mmRegressor/reconstruct_mesh.py", "max_forks_repo_name": "yeongjoonJu/Occlusion-Robust-3D-Face-CFR-GAN", "max_forks_repo_head_hexsha": "1966faf9bfe8d8afd6bc2cea88e5400ce3be54d5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2021-11-03T07:11:34.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-24T06:45:16.000Z", "avg_line_length": 35.2658730159, "max_line_length": 141, "alphanum_fraction": 0.6642286486, "include": true, "reason": "import numpy", "num_tokens": 2773, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5621765008857982, "lm_q2_score": 0.348645142101806, "lm_q1q2_score": 0.1960001060376252}} {"text": "# -*implants -*-\n\"\"\"\n\nFunctions for creating retinal implants\n\n\"\"\"\nimport numpy as np\nimport logging\n\nfrom pulse2percept import utils\n\n\nSUPPORTED_IMPLANT_TYPES = ['epiretinal', 'subretinal']\n\n\nclass Electrode(object):\n\n def __init__(self, etype, radius, x_center, y_center, height=0, name=None):\n \"\"\"Create an electrode on the retina\n\n This function creates a disk electrode of type `etype` and places it\n on the retina at location (`xs`, `ys`) in microns. The electrode has\n radius `radius` (microns) and sits a distance `height` away from the\n retinal surface.\n The coordinate system is anchored around the fovea at (0, 0).\n\n Parameters\n ----------\n etype : str\n Electrode type, {'epiretinal', 'subretinal'}\n radius : float\n The radius of the electrode (in microns).\n x_center : float\n The x coordinate of the electrode center (in microns) from the\n fovea.\n y_center : float\n The y location of the electrode (in microns) from the fovea\n height : float\n The height of the electrode from the retinal surface:\n\n - epiretinal array: distance to the ganglion layer\n - subretinal array: distance to the bipolar layer\n name : string\n Electrode name\n\n \"\"\"\n assert radius >= 0\n assert height >= 0\n\n if etype.lower() not in SUPPORTED_IMPLANT_TYPES:\n e_s = \"Acceptable values for `etype` are: \"\n e_s += \", \".join(SUPPORTED_IMPLANT_TYPES) + \".\"\n raise ValueError(e_s)\n\n self.etype = etype.lower()\n self.radius = radius\n self.x_center = x_center\n self.y_center = y_center\n self.name = name\n self.height = height\n\n def __str__(self):\n info_s = \"Electrode(%s, r=%.2f um, \" % (self.etype, self.radius)\n info_s += \"(x,y) = (%.2f, %.2f) um, \" % (self.x_center, self.y_center)\n info_s += \"h=%.2f um, n=%s\" % (self.height, self.name)\n return info_s\n\n def get_height(self):\n \"\"\"Returns the electrode-retina distance\n\n For epiretinal electrodes, this returns the distance to the ganglion\n cell layer.\n For subretinal electrodes, this returns the distance to the bipolar\n layer.\n \"\"\"\n if self.etype == 'epiretinal':\n return self.h_ofl\n elif self.etype == 'subretinal':\n return self.h_inl\n else:\n raise ValueError(\"Unknown `etype`: \" + self.etype)\n\n def set_height(self, height):\n \"\"\"Sets the electrode-to-retina distance\n\n This function sets the electrode-to-retina distance according to\n `height`. For an epiretinal device, we calculate the distance to\n the ganglion cell layer (layer thickness depends on retinal location).\n For a subretinal device, we calculate the distance to the bipolar\n layer (layer thickness again depends on retinal location).\n\n Estimates of layer thickness based on:\n LoDuca et al. Am J. Ophthalmology 2011\n Thickness Mapping of Retinal Layers by Spectral Domain Optical\n Coherence Tomography\n Note that this is for normal retinal, so may overestimate thickness.\n Thickness from their paper (averaged across quadrants):\n 0-600 um radius (from fovea):\n\n - Layer 1. (Nerve fiber layer) = 4\n - Layer 2. (Ganglion cell bodies + inner plexiform) = 56\n - Layer 3. (Bipolar bodies, inner nuclear layer) = 23\n\n 600-1550 um radius:\n\n - Layer 1. 34\n - Layer 2. 87\n - Layer 3. 37.5\n\n 1550-3000 um radius:\n - Layer 1. 45.5\n - Layer 2. 58.2\n - Layer 3. 30.75\n\n We place our ganglion axon surface on the inner side of the nerve fiber\n layer.\n We place our bipolar surface 1/2 way through the inner nuclear layer.\n So for an epiretinal array the bipolar layer is L1 + L2 + 0.5 * L3.\n\n \"\"\"\n fovdist = np.sqrt(self.x_center ** 2 + self.y_center ** 2)\n if fovdist <= 600:\n # Layer thicknesses given for 0-600 um distance (from fovea)\n th_ofl = 4.0 # nerve fiber layer\n th_gc = 56.0 # ganglion cell bodies + inner nuclear layer\n th_bp = 23.0 # bipolar bodies + inner nuclear layer\n elif fovdist <= 1550:\n # Layer thicknesses given for 600-1550 um distance (from fovea)\n th_ofl = 34.0\n th_gc = 87.0\n th_bp = 37.5\n else:\n # Layer thicknesses given for 1550-3000 um distance (from fovea)\n th_ofl = 45.5\n th_gc = 58.2\n th_bp = 30.75\n if fovdist > 3000:\n e_s = \"Distance to fovea=%.0f > 3000 um, \" % fovdist\n e_s += \"assuming same layer thicknesses as for 1550-3000 um \"\n e_s += \"distance.\"\n logging.getLogger(__name__).warning(e_s)\n\n if self.etype == 'epiretinal':\n # This is simply the electrode-retina distance\n self.h_ofl = height\n\n # All the way through the ganglion cell layer, inner plexiform\n # layer, and halfway through the inner nuclear layer\n self.h_inl = height + th_ofl + th_gc + 0.5 * th_bp\n elif self.etype == 'subretinal':\n # Starting from the outer plexiform layer, go halfway through the\n # inner nuclear layer\n self.h_inl = height + 0.5 * th_bp\n\n # Starting from the outer plexiform layer, all the way through the\n # inner nuclear layer, inner plexiform layer, and ganglion cell\n # layer\n self.h_ofl = height + th_bp + th_gc + th_ofl\n else:\n raise ValueError(\"Unknown `etype`: \" + self.etype)\n height = property(get_height, set_height)\n\n def current_spread(self, xg, yg, layer, alpha=14000, n=1.69):\n \"\"\"\n\n The current spread due to a current pulse through an electrode,\n reflecting the fall-off of the current as a function of distance from\n the electrode center. This can be calculated for any layer in the\n retina.\n Based on equation 2 in Nanduri et al [1].\n\n Parameters\n ----------\n xg : array\n x-coordinates of the retinal grid\n yg : array\n y-coordinates of the retinal grid\n layer: str\n Layer for which to calculate the current spread:\n\n - 'OFL': optic fiber layer, ganglion axons\n - 'INL': inner nuclear layer, containing the bipolars\n alpha : float\n A constant to do with the spatial fall-off.\n\n n : float\n A constant to do with the spatial fall-off (Default: 1.69, based\n on Ahuja et al. [2] An In Vitro Model of a Retinal Prosthesis.\n Ashish K. Ahuja, Matthew R. Behrend, Masako Kuroda, Mark S.\n Humayun, and James D. Weiland (2008). IEEE Trans Biomed Eng 55.\n\n \"\"\"\n r = np.sqrt((xg - self.x_center) ** 2 + (yg - self.y_center) ** 2)\n # current values on the retina due to array being above the retinal\n # surface\n if 'OFL' in layer: # optic fiber layer, ganglion axons\n h = np.ones(r.shape) * self.h_ofl\n # actual distance from the electrode edge\n d = ((r - self.radius)**2 + self.h_ofl**2)**.5\n elif 'INL' in layer: # inner nuclear layer, containing the bipolars\n h = np.ones(r.shape) * self.h_inl\n d = ((r - self.radius)**2 + self.h_inl**2)**.5\n else:\n s = \"Layer %s not found. Acceptable values for `layer` are \" \\\n \"'OFL' or 'INL'.\" % layer\n raise ValueError(s)\n cspread = (alpha / (alpha + h ** n))\n cspread[r > self.radius] = (alpha\n / (alpha + d[r > self.radius] ** n))\n\n return cspread\n\n def receptive_field(self, xg, yg, rftype='square', size=None):\n \"\"\"An electrode's receptive field\n\n Parameters\n ----------\n xg : array_like\n Array of all x coordinates\n yg : array_like\n Array of all y coordinates\n rftype : {'square', 'gaussian'}\n The type of receptive field.\n - 'square': A simple square box receptive field with side length\n `size`.\n - 'gaussian': A Gaussian receptive field where the weight drops off\n as a function of distance from the electrode center.\n The standard deviation of the Gaussian is `size`.\n size : float, optional\n Parameter describing the size of the receptive field. For square\n receptive fields, this corresponds to the side length of the\n square.\n For Gaussian receptive fields, this corresponds to the standard\n deviation of the Gaussian.\n Default: Twice the electrode radius.\n \"\"\"\n if size is None:\n size = 2 * self.radius\n\n if rftype == 'square':\n # Create a map of the retina for each electrode\n # where it's 1 under the electrode, 0 elsewhere\n rf = np.zeros(xg.shape).astype(np.float32)\n ind = np.where((xg > self.x_center - (size / 2.0))\n & (xg < self.x_center + (size / 2.0))\n & (yg > self.y_center - (size / 2.0))\n & (yg < self.y_center + (size / 2.0)))\n rf[ind] = 1.0\n elif rftype == 'gaussian':\n # Create a map of the retina where the weight drops of as a\n # function of distance from the electrode center\n dist = (xg - self.x_center) ** 2 + (yg - self.y_center) ** 2\n rf = np.exp(-dist / (2 * size ** 2))\n rf /= np.sum(rf)\n else:\n e_s = \"Acceptable values for `rftype` are 'square' or 'gaussian'\"\n raise ValueError(e_s)\n\n return rf\n\n\nclass ElectrodeArray(object):\n\n def __init__(self, etype, radii, xs, ys, hs=0, names=None, eye='RE'):\n \"\"\"Create an ElectrodeArray on the retina\n This function creates an electrode array of type `etype` and places it\n on the retina. Lists should specify, for each electrode, its size\n (`radii`), location on the retina (`xs` and `ys`), distance to the\n retina (height, `hs`), and a string identifier (`names`, optional).\n Array location should be given in microns, where the fovea is located\n at (0, 0).\n Single electrodes in the array can be addressed by index (integer)\n or name.\n Parameters\n ----------\n radii : array_like\n List of electrode radii.\n xs : array_like\n List of x-coordinates for the center of the electrodes (microns).\n ys : array_like\n List of y-coordinates for the center of the electrodes (microns).\n hs : float | array_like, optional, default: 0\n List of electrode heights (distance from the retinal surface).\n names : array_like, optional, default: None\n List of names (string identifiers) for each eletrode.\n eye : {'LE', 'RE'}, optional, default: 'RE'\n Eye in which array is implanted.\n\n Examples\n --------\n A single epiretinal electrode called 'A1', with radius 100um, sitting\n at retinal location (0, 0), 10um away from the retina:\n >>> from pulse2percept import implants\n >>> implant0 = implants.ElectrodeArray('epiretinal', 100, 0, 0, hs=10,\n ... names='A1')\n\n Get access to the electrode with name 'A1' in the first array:\n >>> my_electrode = implant0['A1']\n\n An array with two electrodes of size 100um, one sitting at\n (-100, -100), the other sitting at (0, 0), with 0 distance from the\n retina, of type 'subretinal':\n >>> implant1 = implants.ElectrodeArray('subretinal', [100, 100],\n ... [-100, 0], [-100, 0], hs=[0, 0])\n \"\"\"\n self.etype = etype\n self.eye = eye\n self.electrodes = []\n self.num_electrodes = 0\n self.add_electrodes(radii, xs, ys, hs, names)\n\n def __str__(self):\n return \"ElectrodeArray(%s, num_electrodes=%d)\" % (self.etype,\n self.num_electrodes)\n\n def add_electrode(self, electrode):\n \"\"\"Adds an electrode to an ElectrodeArray object\n This function adds a single electrode to an existing ElectrodeArray\n object. The electrode must have the same type as the array\n (see implants.SUPPORTED_IMPLANT_TYPES).\n Parameters\n ----------\n electrode : implants.Electrode\n An electrode object specifying type, size, and location of the\n electrode on the retina.\n \"\"\"\n if not isinstance(electrode, Electrode):\n raise TypeError(\"`electrode` must be of type retina.Electrode.\")\n\n if electrode.etype != self.etype:\n e_s = \"Added electrode must be of same type as the existing\"\n e_s = \"array (%s).\" % self.etype\n raise ValueError(e_s)\n\n self.num_electrodes += 1\n self.electrodes.append(electrode)\n\n def add_electrodes(self, radii, xs, ys, hs=0, names=None):\n \"\"\"Adds electrodes to an ElectrodeArray object\n This function adds one or more electrodes to an existing ElectrodeArray\n object. Lists should specify, for each electrode to be added, the size\n (`radii`), location on the retina (`xs` and `ys`), distance to the\n retina (height, `hs`), and a string identifier (`names`, optional).\n Array location should be given in microns, where the fovea is located\n at (0, 0).\n Single electrodes in the array can be addressed by index (integer)\n or name.\n\n Parameters\n ----------\n radii : array_like\n List of electrode radii.\n xs : array_like\n List of x-coordinates for the center of the electrodes (microns).\n ys : array_like\n List of y-coordinates for the center of the electrodes (microns).\n hs : float | array_like, optional, default: 0\n List of electrode heights (distance from the retinal surface).\n names : array_like, optional, default: None\n List of names (string identifiers) for each eletrode.\n\n Examples\n --------\n Adding a single electrode of radius 50um sitting at (0, 0) to an\n existing ElectrodeArray object:\n >>> implant = ElectrodeArray('epiretinal', 100, 100, 100)\n >>> implant.add_electrodes(50, 0, 0)\n \"\"\"\n # Make it so the method can accept either floats, lists, or\n # numpy arrays, and `zip` works regardless.\n radii = np.array([radii], dtype=np.float32).flatten()\n xs = np.array([xs], dtype=np.float32).flatten()\n ys = np.array([ys], dtype=np.float32).flatten()\n names = np.array([names], dtype=np.str).flatten()\n\n if isinstance(hs, list):\n hs = np.array(hs).flatten()\n else:\n # All electrodes have the same height\n hs = np.ones_like(radii) * hs\n\n assert radii.size == xs.size == ys.size == hs.size\n\n if names.size != radii.size:\n # If not every electrode has a name, replace with None's\n names = np.array([None] * radii.size)\n\n for r, x, y, h, n in zip(radii, xs, ys, hs, names):\n self.add_electrode(Electrode(self.etype, r, x, y, h, n))\n\n def __iter__(self):\n return iter(self.electrodes)\n\n def __getitem__(self, item):\n \"\"\"Return the electrode specified by `item`\n Parameters\n ----------\n item : int|string\n If `item` is an integer, returns the `item`-th electrode in the\n array. If `item` is a string, returns the electrode with string\n identifier `item`.\n \"\"\"\n try:\n # Is `item` an integer?\n return self.electrodes[item]\n except (IndexError, TypeError):\n # If `item` is a valid string identifier, return valid index.\n # Else return None\n try:\n return self.electrodes[self.get_index(item)]\n except (IndexError, TypeError):\n return None\n\n def get_index(self, name):\n \"\"\"Returns the index of an electrode called `name`\n This function searches the electrode array for an electrode with\n string identifier `name`. If found, the index of that electrode is\n returned, else None.\n Parameters\n ----------\n name : str\n An electrode name (string identifier).\n Returns\n -------\n A valid electrode index or None.\n \"\"\"\n # Is `name` a valid electrode name?\n # Iterate through electrodes to find a matching name. Shuffle list\n # to reduce time complexity of average lookup.\n for idx, el in utils.traverse_randomly(enumerate(self.electrodes)):\n if el.name == name:\n return idx\n\n # Worst case O(n): name could not be found.\n return None\n\n def get_eye(self):\n return self._eye\n\n def set_eye(self, eye):\n if eye.lower() in ['r', 're', 'right']:\n self._eye = 'RE'\n elif eye.lower() in ['l', 'le', 'left']:\n self._eye = 'LE'\n else:\n raise ValueError(\"Unknown eye '%s'. Choose from 'LE', 'RE'.\")\n\n eye = property(get_eye, set_eye)\n\n\nclass ArgusI(ElectrodeArray):\n\n def __init__(self, x_center=0, y_center=0, h=0, rot=0, eye='RE',\n use_legacy_names=False):\n \"\"\"Create an ArgusI array on the retina\n This function creates an ArgusI array and places it on the retina\n such that the center of the array is located at\n [`x_center`, `y_center`] (microns) and the array is rotated by\n rotation angle `rot` (radians).\n The array is oriented in the visual field as shown in Fig. 1 of\n Horsager et al. (2009); that is, if placed in (0,0), the top two\n rows will lie in the lower retina (upper visual field):\n .. raw:: html\n 
\n            y       A1 B1 C1 D1                     260 520 260 520\n            ^       A2 B2 C2 D2   where electrode   520 260 520 260\n            |       A3 B3 C3 D3   diameters are:    260 520 260 520\n            -->x    A4 B4 C4 D4                     520 260 520 260\n
\n Electrode order is: A1, B1, C1, D1, A2, B2, ..., D4.\n If `use_legacy_names` is True, electrode order is: L6, L2, M8, M4, ...\n An electrode can be addressed by index (integer) or name.\n\n Parameters\n ----------\n x_center : float, optional, default: 0\n x coordinate of the array center (um)\n y_center : float, optional, default: 0\n y coordinate of the array center (um)\n h : float || array_like, optional, default: 0\n Distance of the array to the retinal surface (um). Either a list\n with 16 entries or a scalar.\n rot : float, optional, default: 0\n Rotation angle of the array (rad). Positive values denote\n counter-clock-wise (CCW) rotations in the retinal coordinate\n system.\n eye : {'LE', 'RE'}, optional, default: 'RE'\n Eye in which array is implanted.\n\n Examples\n --------\n Create an ArgusI array centered on the fovea, at 100um distance from\n the retina:\n >>> from pulse2percept import implants\n >>> argus = implants.ArgusI(x_center=0, y_center=0, h=100, rot=0)\n\n Get access to electrode 'B1':\n >>> my_electrode = argus['B1']\n \"\"\"\n # Alternating electrode sizes, arranged in checkerboard pattern\n r_arr = np.array([260, 520, 260, 520]) / 2.0\n r_arr = np.concatenate((r_arr, r_arr[::-1], r_arr, r_arr[::-1]),\n axis=0)\n\n # Set left/right eye\n self.eye = eye\n\n # In older papers, Argus I electrodes go by L and M\n self.old_names = names = ['L6', 'L2', 'M8', 'M4',\n 'L5', 'L1', 'M7', 'M3',\n 'L8', 'L4', 'M6', 'M2',\n 'L7', 'L3', 'M5', 'M1']\n # In newer papers, they go by A-D: A1, B1, C1, D1, A1, B2, ..., D4\n # Shortcut: Use `chr` to go from int to char\n self.new_names = [chr(i) + str(j) for j in range(1, 5)\n for i in range(65, 69)]\n\n if use_legacy_names:\n names = self.old_names\n else:\n names = self.new_names\n\n if isinstance(h, list):\n h_arr = np.array(h).flatten()\n if h_arr.size != len(r_arr):\n e_s = \"If `h` is a list, it must have 16 entries.\"\n raise ValueError(e_s)\n else:\n # All electrodes have the same height\n h_arr = np.ones_like(r_arr) * h\n\n # Equally spaced electrodes: n_rows x n_cols = 16\n e_spacing = 800 # um\n n_cols = 4 # number of electrodes horizontally (same vertically)\n x_arr = np.arange(n_cols) * e_spacing - (n_cols / 2 - 0.5) * e_spacing\n if self.eye == 'LE':\n # Left eye: Need to invert x coordinates and rotation angle\n x_arr = x_arr[::-1]\n x_arr, y_arr = np.meshgrid(x_arr, x_arr, sparse=False)\n\n # Rotation matrix\n R = np.array([np.cos(rot), -np.sin(rot),\n np.sin(rot), np.cos(rot)]).reshape((2, 2))\n\n # Set the x, y location of the tack\n if self.eye == 'RE':\n self.tack = np.matmul(R, [-(n_cols / 2 + 0.5) * e_spacing, 0])\n else:\n self.tack = np.matmul(R, [(n_cols / 2 + 0.5) * e_spacing, 0])\n self.tack = tuple(self.tack + [x_center, y_center])\n\n # Rotate the array\n xy = np.vstack((x_arr.flatten(), y_arr.flatten()))\n xy = np.matmul(R, xy)\n x_arr = xy[0, :]\n y_arr = xy[1, :]\n\n # Apply offset\n x_arr += x_center\n y_arr += y_center\n\n self.etype = 'epiretinal'\n self.num_electrodes = 0\n self.electrodes = []\n for r, x, y, h, n in zip(r_arr, x_arr, y_arr, h_arr, names):\n self.add_electrode(Electrode(self.etype, r, x, y, h, n))\n\n def __str__(self):\n return \"ArgusI(%s, num_electrodes=%d)\" % (self.etype,\n self.num_electrodes)\n\n def get_old_name(self, new_name):\n \"\"\"Look up the legacy name of a standard-named Argus I electrode\"\"\"\n return self.old_names[self.new_names.index(new_name)]\n\n def get_new_name(self, old_name):\n \"\"\"Look up the standard name of a legacy-named Argus I electrode\"\"\"\n return self.new_names[self.old_names.index(old_name)]\n\n\nclass ArgusII(ElectrodeArray):\n\n def __init__(self, x_center=0, y_center=0, h=0, rot=0, eye='RE'):\n \"\"\"Create an ArgusII array on the retina\n This function creates an ArgusII array and places it on the retina\n such that the center of the array is located at\n [`x_center`, `y_center`] (microns) and the array is rotated by\n rotation angle `rot` (radians).\n The array is oriented upright in the visual field, such that an\n array with center (0,0) has the top three rows lie in the lower\n retina (upper visual field), as shown below:\n .. raw:: html\n 
\n                    A1 A2 A3 A4 A5 A6 A7 A8 A9 A10\n            y       B1 B2 B3 B4 B5 B6 B7 B8 B9 B10\n            ^       C1 C2 C3 C4 C5 C6 C7 C8 C9 C10\n            |       D1 D2 D3 D4 D5 D6 D7 D8 D9 D10\n            -->x    E1 E2 E3 E4 E5 E6 E7 E8 E9 E10\n                    F1 F2 F3 F4 F5 F6 F7 F8 F9 F10\n
\n Electrode order is: A1, A2, ..., A10, B1, B2, ..., F10.\n An electrode can be addressed by index (integer) or name.\n\n Parameters\n ----------\n x_center : float\n x coordinate of the array center (um)\n y_center : float\n y coordinate of the array center (um)\n h : float || array_like\n Distance of the array to the retinal surface (um). Either a list\n with 60 entries or a scalar.\n rot : float\n Rotation angle of the array (rad). Positive values denote\n counter-clock-wise (CCW) rotations in the retinal coordinate\n system.\n eye : {'LE', 'RE'}, optional, default: 'RE'\n Eye in which array is implanted.\n\n Examples\n --------\n Create an ArgusII array centered on the fovea, at 100um distance from\n the retina:\n >>> from pulse2percept import implants\n >>> argus = implants.ArgusII(x_center=0, y_center=0, h=100, rot=0)\n\n Get access to electrode 'E7':\n >>> my_electrode = argus['E7']\n \"\"\"\n # Electrodes are 200um in diameter\n r_arr = np.ones(60) * 100.0\n\n # Set left/right eye\n self.eye = eye\n\n # Standard ArgusII names: A1, A2, ..., A10, B1, ..., F10\n names = [chr(i) + str(j) for i in range(65, 71) for j in range(1, 11)]\n\n if isinstance(h, list):\n h_arr = np.array(h).flatten()\n if h_arr.size != len(r_arr):\n e_s = \"If `h` is a list, it must have 60 entries.\"\n raise ValueError(e_s)\n else:\n # All electrodes have the same height\n h_arr = np.ones_like(r_arr) * h\n\n # Equally spaced electrodes: n_rows x n_cols = 60\n e_spacing = 525 # um\n n_cols = 10 # number of electrodes horizontally\n n_rows = 6 # number of electrodes vertically\n x_arr = np.arange(n_cols) * e_spacing - (n_cols / 2 - 0.5) * e_spacing\n if self.eye == 'LE':\n # Left eye: Need to invert x coordinates and rotation angle\n x_arr = x_arr[::-1]\n y_arr = np.arange(n_rows) * e_spacing - (n_rows / 2 - 0.5) * e_spacing\n x_arr, y_arr = np.meshgrid(x_arr, y_arr, sparse=False)\n\n # Rotation matrix\n rotmat = np.array([np.cos(rot), -np.sin(rot),\n np.sin(rot), np.cos(rot)]).reshape((2, 2))\n\n # Set the x, y location of the tack\n if self.eye == 'RE':\n self.tack = np.matmul(rotmat, [-(n_cols / 2 + 0.5) * e_spacing, 0])\n else:\n self.tack = np.matmul(rotmat, [(n_cols / 2 + 0.5) * e_spacing, 0])\n self.tack = tuple(self.tack + [x_center, y_center])\n\n # Rotate the array\n xy = np.vstack((x_arr.flatten(), y_arr.flatten()))\n xy = np.matmul(rotmat, xy)\n x_arr = xy[0, :]\n y_arr = xy[1, :]\n\n # Apply offset\n x_arr += x_center\n y_arr += y_center\n\n self.etype = 'epiretinal'\n self.num_electrodes = 0\n self.electrodes = []\n for r, x, y, h, n in zip(r_arr, x_arr, y_arr, h_arr, names):\n self.add_electrode(Electrode(self.etype, r, x, y, h, n))\n\n def __str__(self):\n return \"ArgusII(%s, num_electrodes=%d)\" % (self.etype,\n self.num_electrodes)\n\n\nclass AlphaIMS(ElectrodeArray):\n\n def __init__(self, x_center=0, y_center=0, h=0, rot=0, eye='RE'):\n \"\"\"Create an Alpha IMS array on the retina and place it on the retina\n such that the center of the array is located at [`x_center`, `y_center`]\n (microns) and the array is rotated by rotation angle `rot` (radians).\n The array is oriented upright in the visual field, such that an array\n with center (0,0) has the top three rows lie in the lower retina\n (upper visual field), as shown below:\n\n Parameters\n ----------\n x_center : float\n x coordinate of the array center (um)\n y_center : float\n y coordinate of the array center (um)\n h : float || array_like\n Distance of the array to the retinal surface (um). Either a list\n with 60 entries or a scalar.\n rot : float\n Rotation angle of the array (rad). Positive values denote\n counter-clock-wise (CCW) rotations in the retinal coordinate\n system.\n eye : {'LE', 'RE'}, optional, default: 'RE'\n Eye in which array is implanted.\n \"\"\"\n\n self.eye = eye\n self.etype = 'subretinal'\n\n # Electrode spacing, radius\n e_spacing = 72 # um\n elec_radius = 50\n # number of electrodes horizontally, vertically, and total\n n_cols = 37\n n_rows = 37\n n_elecs = n_cols * n_rows\n\n # TODO: look up naming convention\n names = np.ones(n_elecs)\n\n # array containing electrode radii (uniform)\n r_arr = np.full(shape=n_elecs, fill_value=elec_radius)\n\n # array of electrode heights (uniform)\n h_arr = np.ones_like(r_arr) * h\n\n # arrays of x and y coordinates\n x_arr = np.arange(n_cols) * e_spacing - (n_cols / 2 - 0.5) * e_spacing\n if self.eye == 'LE':\n # Left eye: Need to invert x coordinates and rotation angle\n x_arr = x_arr[::-1]\n y_arr = np.arange(n_rows) * e_spacing - (n_rows / 2 - 0.5) * e_spacing\n x_arr, y_arr = np.meshgrid(x_arr, y_arr, sparse=False)\n\n # Rotation matrix\n rotmat = np.array([np.cos(rot), -np.sin(rot),\n np.sin(rot), np.cos(rot)]).reshape((2, 2))\n\n # Set the x, y location of the tack\n if self.eye == 'RE':\n self.tack = np.matmul(rotmat, [-(n_cols / 2 + 0.5) * e_spacing, 0])\n else:\n self.tack = np.matmul(rotmat, [(n_cols / 2 + 0.5) * e_spacing, 0])\n self.tack = tuple(self.tack + [x_center, y_center])\n\n # Rotate the array\n xy = np.vstack((x_arr.flatten(), y_arr.flatten()))\n xy = np.matmul(rotmat, xy)\n x_arr = xy[0, :]\n y_arr = xy[1, :]\n\n # Apply offset\n x_arr += x_center\n y_arr += y_center\n\n # add all electrodes\n self.num_electrodes = 0\n self.electrodes = []\n for r, x, y, h, n in zip(r_arr, x_arr, y_arr, h_arr, names):\n self.add_electrode(Electrode(self.etype, r, x, y, h, n))\n\n def __str__(self):\n return \"AlphaIMS(%s, num_electrodes=%d)\" % (self.etype,\n self.num_electrodes)\n", "meta": {"hexsha": "5e4ced2438b93e9c3e5ade90e629db8996f6cf66", "size": 30644, "ext": "py", "lang": "Python", "max_stars_repo_path": "pulse2percept/implants.py", "max_stars_repo_name": "jonluntzel/pulse2percept", "max_stars_repo_head_hexsha": "dbe17230be0354c4cfc57a72b649c611fe496464", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pulse2percept/implants.py", "max_issues_repo_name": "jonluntzel/pulse2percept", "max_issues_repo_head_hexsha": "dbe17230be0354c4cfc57a72b649c611fe496464", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pulse2percept/implants.py", "max_forks_repo_name": "jonluntzel/pulse2percept", "max_forks_repo_head_hexsha": "dbe17230be0354c4cfc57a72b649c611fe496464", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.4896907216, "max_line_length": 80, "alphanum_fraction": 0.5601422791, "include": true, "reason": "import numpy", "num_tokens": 7881, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5621765008857982, "lm_q2_score": 0.34864514210180597, "lm_q1q2_score": 0.19600010603762516}} {"text": "#!/usr/bin/env python\n\n#everything is needed to perform the script and maybe something else\nfrom numpy import *\nfrom scipy import *\nfrom scipy import integrate\nfrom scipy.interpolate import interp1d\nimport pyfits\nimport os\nimport sys\nimport string \nimport shutil\nimport math\nimport glob\nimport s3 #import metadata \nfrom s3.utilities import * #import definitions\nfrom time import strftime, sleep\nimport time\nfrom pylab import *\nfrom scipy.optimize import curve_fit\n# pre-set plot parameters, resolution untouched since it is not needed (default=80 dpi) \nfrom pylab import rcParams\nrcParams['figure.figsize'] = 11, 8\nrcParams['figure.subplot.top'] = 0.95\nrcParams['figure.subplot.right'] = 0.90\nrcParams['figure.subplot.left'] = 0.11\n###########################################\npypath = os.path.expandvars('$HOME') # it copies login.cl if it is not in the same dir\nif not os.path.isfile('login.cl'):\n shutil.copyfile(pypath+'/iraf/login.cl','login.cl')\n###########################################\n\n################### for the help ##################\nfrom optparse import OptionParser\n\ndescription = \" K-correction loop for flux calibrated spectra. List of files are accepted \"\nusage = \"%prog \"\nif __name__ == \"__main__\":\n parser = OptionParser(usage=usage, description=description, version=\"%prog \" + str(s3.__version__))\n parser.add_option(\"-v\", \"--verbose\",dest=\"verbose\",\\\n action=\"store_true\",default=False,\n help='Print tasks description')\n parser.add_option(\"-s\", \"--sleep\",dest=\"sleepc\", action=\"store\", type=\"float\", default=None, \n help='Change the sleep time between cycles. Default is 1s (good for 4GB of RAM or greater), the lower your RAM, the higher it should be.')\n parser.add_option(\"-r\", \"--redshifterr\",dest=\"redshifterr\", action=\"store\", type=\"float\" ,default=None,\n help='Change the default error on your redshift (+/- 0.005) to estimate the K-correction errors')\n option,args = parser.parse_args()\n\n###### moved here because OptionParser --version conflicts with pyraf version########\n#what we need from iraf\nfrom pyraf import iraf\n\n########### option to change the python sleep function between cycles #########\nif option.sleepc == None:\n _sleepc = 1\nelse:\n _sleepc = option.sleepc\n\nif option.redshifterr == None:\n _redshifterr = 0.005\nelse:\n _redshifterr = option.redshifterr\n################ internal description #############\n\nh=\"######################################################################\\n\"+\\\n \"######### SuperNova Algorithm for K-correction Evaluation ##########\\n\"+\\\n \"################## S.N.A.K.E. (loop version) ################\\n\"+\\\n \"########## C. Inserra v1.1.0 29/10/2015 ###########\\n\"+\\\n \"######################################################################\\n\"+\\\n \" K-correction based on the formula m(x) = M(y) + DM + K(y,x)\\n\"+\\\n \" BE SURE that the spectra are flux calibrated \\n\"+ \\\n \" If you use this code and find it useful, please give a thought \\n\"+ \\\n \" to cite it. \\n\"+ \\\n \" The reference is Inserra et al. 2015, ApJ submitted \\n\"+\\\n \"######################################################################\\n\"\n\nprint h \n\n#the path where the metatabs dat are\nfilterdir=s3.__path__[0]+'/metadata/' # To set the directory\n\n# cleaning process\nos.system('rm -rf sn.txt')\nos.system('rm -rf sn.fits')\nos.system('rm -rf sn_xbbody.txt')\nos.system('rm -rf sn_dez_xbbody.txt')\nos.system('rm -rf sn_dez_xbbody_err1.txt')\nos.system('rm -rf sn_dez_xbbody_err2.txt')\nos.system('rm -rf bbody_sn_dez_fit.dat')\nos.system('rm -rf bbody_sn_dez_fit_err1.dat')\nos.system('rm -rf bbody_sn_dez_fit_err2.dat')\nos.system('rm -rf bbody_sn_dez_fit.fits')\nos.system('rm -rf bbody_sn_dez_fit_err1.fits')\nos.system('rm -rf bbody_sn_dez_fit_err2.fits')\nos.system('rm -rf bbody_sn_fit.fits')\nos.system('rm -rf bbody_sn_fit.dat')\nos.system('rm -rf sn_dez.txt')\nos.system('rm -rf sn_dez_err1.txt')\nos.system('rm -rf sn_dez_err2.txt')\nos.system('rm -rf sn_dez.fits')\nos.system('rm -rf sn_dez_err1.fits')\nos.system('rm -rf sn_dez_err2.fits')\nos.system('rm -rf sn_dez_dered.fits')\nos.system('rm -rf sn_dez_dered_err1.fits')\nos.system('rm -rf sn_dez_dered_err2.fits')\nos.system('rm -rf sn_dez_dered.txt')\nos.system('rm -rf sn_dez_dered_err1.txt')\nos.system('rm -rf sn_dez_dered_err2.txt')\nos.system('rm -rf sn_galdered_dez.fits')\nos.system('rm -rf sn_galdered_dez_err1.fits')\nos.system('rm -rf sn_galdered_dez_err2.fits')\nos.system('rm -rf sn_galdered.fits')\nos.system('rm -rf bsn_combo_dez.fits')\nos.system('rm -rf bsn_combo_dez_err1.fits')\nos.system('rm -rf bsn_combo_dez_err2.fits')\nos.system('rm -rf bsn_combo_dez.txt')\nos.system('rm -rf bsn_combo_dez_err1.txt')\nos.system('rm -rf bsn_combo_dez_err2.txt')\nos.system('rm -rf bsn_combo.fits')\nos.system('rm -rf bsn_combo.txt')\n\n#######################################################\n# Variable definitions\n#######################################################\n\nquestion = raw_input('Do you have a list of spectra ? ([yes]/no) ')\nif not question:\n question = 'yes'\n\nif question == 'yes' or question == 'y' or question == 'Y' or question == 'Yes' or question == 'YES':\n\tfiles = raw_input('List ? [e.g. list, list.txt, list.dat] ')\n\tlcf = open(files,'r') \n\triga = lcf.readlines() # lista di righe intere\n\tlcf.close()\n\tsnlist = []\n\tfor line in riga:\n\t\tp = line.split()\n\t\tsnlist.append(p[0])\nelse:\n\tfiles = raw_input('List the spectra to use (space separated list): ')\n\tsnlist = string.split(files)\n\nprint ''\nquestionred = raw_input('Do you have a list of redshifts ? ([yes]/no) ')\nif not questionred:\n questionred = 'yes'\n\nif questionred == 'yes' or questionred == 'y' or questionred == 'Y' or questionred == 'Yes' or questionred == 'YES':\n\tfiles = raw_input('List ? [e.g. list, list.txt, list.dat] ')\n\tlcf = open(files,'r') \n\triga = lcf.readlines() # lista di righe intere\n\tlcf.close()\n\tz = []\n\tfor line in riga:\n\t\tp = line.split()\n\t\tz.append(p[0])\nelse:\n\tred = raw_input('List the redshifts you want to use (space separated list) or the single redshift that will be used for all the spectra: ')\n\tredshift = string.split(red)\n\tif len(redshift) != len(snlist):\n\t\tif len(redshift) == 1:\n\t\t\tz = redshift * len(snlist)\n\telse:\n\t\tz = redshift\n\t\t\nprint ''\nprint '#################################'\nprint '# Available filters and ID #'\nprint '#-------------------------------#'\nprint '# BESSEL: U B V R I #'\nprint '# SLOAN: us gs rs is zs #'\nprint '# UV: NUV FUV uw2 um2 uw1 #'\nprint '# NIR: J H K #' \nprint '#################################'\nprint '' \nquestionfilobs = raw_input('Do you have a list of observed filters ? ([yes]/no) ')\nif not questionfilobs:\n questionfilobs = 'yes'\n\nif questionfilobs == 'yes' or questionfilobs == 'y' or questionfilobs == 'Y' or questionfilobs == 'Yes' or questionfilobs == 'YES':\n\tfiles = raw_input('List ? [e.g. list, list.txt, list.dat] ')\n\tlcf = open(files,'r') \n\triga = lcf.readlines() # lista di righe intere\n\tlcf.close()\n\tfobs = []\n\tfor line in riga:\n\t\tp = line.split()\n\t\tfobs.append(p[0])\nelse:\n\tfolist = raw_input('List the observed filters you want to use (space separated list) or the observed filter that will be used for all the spectra: ')\n\tfolist_1 = string.split(folist)\n\tif len(folist_1) != len(snlist):\n\t\tif len(folist_1) == 1:\n\t\t\tfobs = folist_1 * len(snlist)\n\telse:\n\t\tfobs = folist_1\nprint ''\nquestionfilrest = raw_input('Do you have a list of rest-frame filters ? ([yes]/no) ')\nif not questionfilrest:\n questionfilrest = 'yes'\n\nif questionfilrest == 'yes' or questionfilrest == 'y' or questionfilrest == 'Y' or questionfilrest == 'Yes' or questionfilrest == 'YES':\n\tfiles = raw_input('List ? [e.g. list, list.txt, list.dat] ')\n\tlcf = open(files,'r') \n\triga = lcf.readlines() # lista di righe intere\n\tlcf.close()\n\tfrest = []\n\tfor line in riga:\n\t\tp = line.split()\n\t\tfrest.append(p[0])\nelse:\n\tfrlist = raw_input('List the rest-frame filters you want to use (space separated list) or the rest-frame filter that will be used for all the spectra: ')\n\tfrlist_1 = string.split(frlist)\n\tif len(frlist_1) != len(snlist):\n\t\tif len(frlist_1) == 1:\n\t\t\tfrest = frlist_1 * len(snlist)\n\telse:\n\t\tfrest = frlist_1\n\nprint ''\nprint '######################################################################'\nprint 'Please, bear in mind that the true K-correction should be evaluated '\nprint 'without reddening. As a consequence in the cases of K-coorection on '\nprint 'hybrid spectra reddening will not be evaluated.'\nprint '######################################################################'\n\nprint ''\n_ebvg = raw_input('Galactic E(B-V) [0.0] ? ')\nif not _ebvg:\n ebvg = 0.0\nelse: \n ebvg = float(_ebvg)\nprint ''\n\n_ebvh = raw_input('Host E(B-V) [0.0] ? ')\nif not _ebvh:\n ebvh = 0.0\nelse: \n ebvh = float(_ebvh)\nprint ''\n\nquestionplot = raw_input('Do you want to see your results plotted against redshift ? ([yes]/no) ')\nif not questionplot:\n questionplot = 'yes'\n\n###### Arrays definition ##########\nlength = shape(snlist)[0]\nkcorr = array(zeros(length))\nkcorr_e = array(zeros(length))\nmethod = [None] * len(snlist)\nbtemp = [None] * len(snlist)\nanguncov = [None] * len(snlist)\nuncovside = [None] * len(snlist)\nredlist = [None] * len(snlist)\n\n\n##########################\n### Creating a txt file\n#########################\nTnow = int(strftime(\"%H%M%S\"))\nTnowd = int(strftime(\"%d%m%Y\"))\nkcf = \"Kcorrection_%.0i_%.0i.txt\" % (Tnowd,Tnow)\nfilekc = open(kcf,\"w\")\nfilekc.write(\"# K-corrections from observed filter to rest-frame filter \\n\")\nfilekc.write(\"# Galactic E(B-V)=%g, host E(B-V)=%g \\n\" % (ebvg,ebvh))\nfilekc.write(\"# File\\tRedshift\\tObs-filter\\tRest-filter\\tK-corr\\terror\\tSNAKE mode\\t Blackbody Temperature\\t Angstroms uncovered in the wavelength region\\n\\n\")\n\nnow = time.time() \nii = 0\nwhile ii != len(snlist):\n\t_snname = snlist[ii]\n\t#### it recognizes automatically the extension of your file and convert to fits\n\tfileName, fileExtension = os.path.splitext(_snname)\n\tif fileExtension == '.txt' or fileExtension == '.dat' or fileExtension == '.asci' or fileExtension == '.ascii':\n\t\tiraf.rspec(_snname,fileName+'.fits',flux='no',dtype='interp')\n\t\tsnname = fileName+'.fits'\n\telse:\n\t\tsnname = _snname\n\n\tredshift = float(z[ii])\n\tredserrspace1 = float(redshift)+_redshifterr\n\tredserrspace2 = float(redshift)-_redshifterr\n\tfilter1 = fobs[ii]\n\tfilter2 = frest[ii]\n\tprint '\\033[1mSpectrum number\\033[0m ', 1+ii\n\tprint 'Spectrum = ', snname, ' & redshift = ', redshift,'+/-',_redshifterr\n \tlogterm = 2.5*log10(1+float(redshift))\n\tsn = snname\n\n\t############################# Safety loop to check again if you have everything removed and avoid errors in the programme ###################\n\tfiletoremove = ['sn.txt','sn.fits','sn_xbbody.txt','sn_dez_xbbody.txt','sn_dez_xbbody_err1.txt','sn_dez_xbbody_err2.txt','bbody_sn_dez_fit.dat','bbody_sn_dez_fit_err1.dat','bbody_sn_dez_fit_err2.dat','bbody_sn_dez_fit.fits', \\\n\t\t\t\t\t'bbody_sn_dez_fit_err1.fits','bbody_sn_dez_fit_err2.fits','bbody_sn_fit.fits','bbody_sn_fit.dat','sn_dez.txt','sn_dez_err1.txt','sn_dez_err2.txt','sn_dez.fits','sn_dez_err1.fits','sn_dez_err2.fits','sn_dez_dered.fits', \\\n\t\t\t\t\t'sn_dez_dered_err1.fits','sn_dez_dered_err2.fits','sn_dez_dered.txt','sn_dez_dered_err1.txt','sn_dez_dered_err2.txt','sn_galdered_dez.fits','sn_galdered_dez_err1.fits','sn_galdered_dez_err2.fits','sn_galdered.fits', \\\n\t\t\t\t\t'bsn_combo_dez.fits','bsn_combo_dez_err1.fits','bsn_combo_dez_err2.fits','bsn_combo_dez.txt','bsn_combo_dez_err1.txt','bsn_combo_dez_err2.txt','bsn_combo.fits','bsn_combo.txt']\n\tjj = 0\n\twhile jj != len(filetoremove):\n\t\tif os.path.exists(filetoremove[jj]):\n\t\t\tprint ''\n\t\t\tprint \"######################################################################\"\n\t\t\tprint \"Sorry, I am going too fast for your computer RAM, I need to rest for a bit...\"\n\t\t\tprint \"######################################################################\"\n\t\t\tprint ''\n\t\t\tfor i in xrange(5,0,-1):\n\t\t\t\ttime.sleep(1)\n \t\t\tsys.stdout.write(str(i)+' ')\n \t\t\tsys.stdout.flush()\n\t\t\tif os.path.exists(filetoremove[jj]):\n\t\t\t\tprint ''\n\t\t\t\tprint \"######################################################################\"\n\t\t\t\tprint \"Ooops, that is kind of embarassing, apparently there is this file \"+filetoremove[jj]+\" that is delaying my job. May I ask you to assist me and remove it?\"\n\t\t\t\tfor i in xrange(10,0,-1):\n\t\t\t\t\ttime.sleep(1)\n \t\t\t\tsys.stdout.write(str(i)+' ')\n \t\t\t\tsys.stdout.flush()\n\n\t\t\t\tprint \"######################################################################\"\n\t\t\t\tprint ''\n\t\tjj = jj + 1\n\t#########################################################################################################\n\t\n\t#######################################################\n\t# Filter1 and its definitions\n\t#######################################################\n\tlcf = open(filterdir+filter1+'.txt','r') # defintion of the file\n\triga = lcf.readlines() # list of lines\n\triga1 = riga[4:len(riga)] #list of lines where the wave and transmission are stored\n\tlcf.close()\n\tzp_ef = float(riga[0]) #zero point in energy flux (erg/cm^2/s)\n\tzp_ef_err = zp_ef * 1.0075\n\tfilter_ew = riga[1] #equivalent width of the filter\n\tpeak_wave = float(riga[2]) #peak wavelength of the filter\n\tsystem = riga[3] # system used: vega or ab\n\twavefilter, transmission= [], []\n\tfor line in riga1:\n\t p = line.split()\n\t wavefilter.append(float(p[0]))\n\t transmission.append(float(p[1]))\n\t\n\twavefilterv = array(wavefilter)\n\ttransmissionv = array(transmission)\n\tfil_obs_min= min(wavefilterv)\n\tfil_obs_max= int(max(wavefilterv)) #integer is needed for a sharper cut-off\n\t#############################################################\n\t\n\t#######################################################\n\t# Filter2 and its definitions\n\t#######################################################\n\tlcfr = open(filterdir+filter2+'.txt','r') # defintion of the file\n\trigar = lcfr.readlines() # list of lines\n\trigar1 = rigar[4:len(rigar)] #list of lines where the wave and transmission are stored\n\tlcfr.close()\n\tzp_ef_rest = float(rigar[0]) #zero point in energy flux (erg/cm^2/s)\n\tzp_ef_rest_err = zp_ef_rest * 1.0075\n\tfilter_ew_rest = rigar[1] #equivalent width of the filter\n\tpeak_wave_rest = float(rigar[2]) #peak wavelength of the filter\n\tsystem_rest = rigar[3] # system used: vega or ab\n\twavefilter_rest, transmission_rest= [], []\n\tfor line in rigar1:\n\t p = line.split()\n\t wavefilter_rest.append(float(p[0]))\n\t transmission_rest.append(float(p[1]))\n\t\n\twavefilter_restv = array(wavefilter_rest)\n\ttransmission_restv = array(transmission_rest)\n\tfil_rest_min= min(wavefilter_restv)\n\tfil_rest_max= int(max(wavefilter_restv)) #integer is needed for a sharper cut-off\n\t#############################################################\n\n\tspec = sn + \"[*,1,1]\" # generally multidimension\n\tiraf.imcopy(sn+'[*,1,1]','sn.fits',verbose='no') # to create a onedimension fit to use during the script\n\t# redshift correction without absorption \n\tprint '\\033[34m*** correcting the spectrum for redshift without Milky Way absorption *** \\033[0m'\n\ttry:\n\t\tiraf.dopcor('sn.fits','sn_dez.fits', redshift=redshift, isveloc='no', flux='no',factor=3)\n\t\tiraf.dopcor('sn.fits','sn_dez_err1.fits', redshift=redserrspace1, isveloc='no', flux='no',factor=3)\n\t\tiraf.dopcor('sn.fits','sn_dez_err2.fits', redshift=redserrspace2, isveloc='no', flux='no',factor=3)\n\texcept:\n\t\tprint ' WARNING: Problem to redshift the spectrum'\n\n\tif ebvh == 0.0:\n\t\t# galaxy and host reddening correction\n\t\tprint '\\033[31m'+'*** correcting spectrum for galactic reddening ***\\033[0m'\n\t\tebv = ebvg+ebvh\n\t\tprint '\\033[31m Total E(B-V) = galactic E(B-V) = \\033[0m',ebv\n\t\ttry:\n\t\t\tiraf.unlearn(\"deredden\")\n\t\t\tiraf.dered('sn_dez.fits',\"sn_dez_dered.fits\", value=ebv, R=3.1, type='E(B-V)',overrid='yes',uncorre='no')\n\t\t\tiraf.dered('sn_dez_err1.fits',\"sn_dez_dered_err1.fits\", value=ebv, R=3.1, type='E(B-V)',overrid='yes',uncorre='no')\n\t\t\tiraf.dered('sn_dez_err2.fits',\"sn_dez_dered_err2.fits\", value=ebv, R=3.1, type='E(B-V)',overrid='yes',uncorre='no')\n\t\texcept:\n\t\t\t\tprint 'WARNING: it is not possible to correct the spectrum for salactic reddenning '\n\t\t\t\ttry:\n\t\t\t\t\tiraf.unlearn(\"scopy\")\n\t\t\t\t\tiraf.scopy('sn_dez.fits',\"sn_dez_dered.fits\", w1='INDEF', w2='INDEF',format='multispec')\n\t\t\t\t\tiraf.scopy('sn_dez_err1.fits',\"sn_dez_dered_err1.fits\", w1='INDEF', w2='INDEF',format='multispec')\n\t\t\t\t\tiraf.scopy('sn_dez_err2.fits',\"sn_dez_dered_err2.fits\", w1='INDEF', w2='INDEF',format='multispec')\n\t\t\t\texcept:\n\t\t\t\t\tprint 'WARNING: problem to copy the spectrum or with the spectrum fits format'\n\telse:\n\t\t#Galaxy reddening correction\n\t\tprint '\\033[31m'+'*** correcting spectrum for galactic reddening ***\\033[0m'\n\t\ttry:\n\t\t\tiraf.dered(sn + '[*,1,1]',\"sn_galdered.fits\", value=ebvg, R=3.1, type='E(B-V)')\n\t\texcept:\n\t\t\tprint ' WARNING: it is not possible to correct the spectrum for salactic reddenning '\n\t\t\ttry:\n\t\t\t\tiraf.scopy(sn + '[*,1,1]',\"sn_galdered.fits\", w1='INDEF', w2='INDEF',format='multispec')\n\t\t\texcept:\n\t\t\t\tprint ' WARNING: a problem is appeared to copy the spectrum, problems with the spectrum fits format'\n\t\tprint '\\033[34m*** correcting the spectrum for redshift ***\\033[0m'\n\t\ttry:\n\t\t\tiraf.dopcor('sn_galdered.fits','sn_galdered_dez.fits', redshift=redshift, isveloc='no', flux='no')\n\t\t\tiraf.dopcor('sn_galdered.fits','sn_galdered_dez_err1.fits', redshift=redserrspace1, isveloc='no', flux='no',factor=3)\n\t\t\tiraf.dopcor('sn_galdered.fits','sn_galdered_dez_err2.fits', redshift=redserrspace2, isveloc='no', flux='no',factor=3)\n\t\texcept:\n\t\t\tprint ' WARNING: Problem to redshift the spectrum'\n\t\t# host reddening correction\n\t\tprint '\\033[31m*** correcting spectrum for host reddening ***\\033[0m'\n\t\tebv = ebvg+ebvh\n\t\tprint '\\033[31m NOW total E(B-V) = ',ebv\n\t\tiraf.hedit(\"sn_galdered_dez.fits\", 'DEREDDEN', add='no', addonly='no', delete='yes', verify ='no')\n\t\tiraf.hedit(\"sn_galdered_dez_err1.fits\", 'DEREDDEN', add='no', addonly='no', delete='yes', verify ='no', show='no')\n\t\tiraf.hedit(\"sn_galdered_dez_err2.fits\", 'DEREDDEN', add='no', addonly='no', delete='yes', verify ='no', show='no')\n\t\tiraf.dered('sn_galdered_dez.fits',\"sn_dez_dered.fits\", value=ebvh, R=3.1, type='E(B-V)',overrid='yes')\n\t\tiraf.dered('sn_galdered_dez_err1.fits',\"sn_dez_dered_err1.fits\", value=ebvh, R=3.1, type='E(B-V)',overrid='yes')\n\t\tiraf.dered('sn_galdered_dez_err2.fits',\"sn_dez_dered_err2.fits\", value=ebvh, R=3.1, type='E(B-V)',overrid='yes')\n\t\tprint '\\033[0m' \n\t\n\n\t#################################################################\n\t#### Preparation for wavelength check\n\t#################################################################\n\t\n\tspectrum=iraf.wspec(\"sn.fits\",\"sn_xbbody.txt\", header='no')\n\tlcf = open('sn_xbbody.txt','r') \n\triga = lcf.readlines() \n\tlcf.close()\n\twave,flux= [],[]\n\tfor line in riga:\n\t p = line.split()\n\t wave.append(float(p[0]))\n\t flux.append(float(p[1]))\n\t\n\twavev = array(wave)\n\tfluxv = array(flux)\n\twaveobs_min= min(wavev)\n\twaveobs_max= max(wavev)\n\t\n\tspectrum=iraf.wspec(\"sn_dez_dered.fits\",\"sn_dez_xbbody.txt\", header='no')\n\tlcf = open('sn_dez_xbbody.txt','r') \n\triga = lcf.readlines() \n\tlcf.close()\n\twavedez,fluxdez= [],[]\n\tfor line in riga:\n\t\tp = line.split()\n\t\twavedez.append(float(p[0]))\n\t\tfluxdez.append(float(p[1]))\n\t\n\twavedezv = array(wavedez)\n\tfluxdezv = array(fluxdez)\n\twaverest_min= min(wavedezv)\n\twaverest_max= max(wavedezv)\n\t\n\tspectrum=iraf.wspec(\"sn_dez_err1.fits\",\"sn_dez_xbbody_err1.txt\", header='no')\n\tlcf = open('sn_dez_xbbody_err1.txt','r') \n\triga = lcf.readlines() \n\tlcf.close()\n\twave,flux= [],[]\n\tfor line in riga:\n\t p = line.split()\n\t wave.append(float(p[0]))\n\t flux.append(float(p[1]))\n\t\n\twavedezv_err1 = array(wave)\n\tfluxdezv_err1 = array(flux)\n\t\n\tspectrum=iraf.wspec(\"sn_dez_err2.fits\",\"sn_dez_xbbody_err2.txt\", header='no')\n\tlcf = open('sn_dez_xbbody_err1.txt','r') \n\triga = lcf.readlines() \n\tlcf.close()\n\twave,flux= [],[]\n\tfor line in riga:\n\t p = line.split()\n\t wave.append(float(p[0]))\n\t flux.append(float(p[1]))\n\t\n\twavedezv_err2 = array(wave)\n\tfluxdezv_err2 = array(flux)\n\n\t################################\n\t### Define the different cases for K-correction\n\t################################\n\tsplit = 0 # splitting value\n\n\tif ((waveobs_min-fil_obs_min) > 50) or ((fil_obs_max-waveobs_max) > 50):\n\t print ''\n\t if (waveobs_min-fil_obs_min) > 50:\n\t print waveobs_min-fil_obs_min,' Angstrom not covered by the observed spectrum in the blue' \n\t anguncov[ii] = waveobs_min-fil_obs_min\n\t uncovside[ii] = 'Blue'\n\t if (fil_obs_max-waveobs_max) > 50:\n\t print fil_obs_max-waveobs_max,' Angstrom not covered by the observed spectrum in the red'\n\t anguncov[ii] = fil_obs_max-waveobs_max\n\t uncovside[ii] = 'Red'\n\t ############################################\n\t # Prevent small exceptions for blue bands or the extreme of the NIR\n\t ############################################\n\t if filter1 != 'U' or filter1 != 'u' or filter1 != 'K' or filter1 != 'uvw1' or filter1 != 'uvw2' or filter1 != 'uvm2' or filter1 != 'NUV' or filter1 != 'FUV':\n\n\t\t ###############################\n\t\t ### BBody evaluation of the observed spectrum\n\t\t ###############################\n\t\t BBparams, covar = curve_fit(bbody,wavev,fluxv,p0=(10000,1E-16)) #intial guess\n\t\t T= BBparams[0]\n\t\t Area = BBparams[1]\n\t\t print '\\nBlackbody temperature observed spectrum = %.0f +\\- %.0f K\\n' % (T,np.sqrt(covar[0,0]))\n\t\t bbt = 'BBobs = %.0f +\\- %.0f K' % (T,np.sqrt(covar[0,0]))\n\t\t outputname = \"bbody_sn_fit.dat\" #% T\n\t\t file = open(outputname,\"w\")\n\t\t file.write(\"# Blackbody temperature = %.0f +\\- %.0f K\\n\" % (T,np.sqrt(covar[0,0])))\n\t\t w,f = [],[]\n\t\t for wav in range(900,26000):\n\t\t file.write(\"%g\\t%g\\n\" % (wav,bbody(wav,T,Area)))\n\t\t w.append(wav)\n\t\t f.append(bbody(wav,T,Area))\n\n\t\t iraf.rspec('bbody_sn_fit.dat','bbody_sn_fit.fits', title='bbodyfit',flux='no',dtype='interp',crval1=900,cdelt1=1)\n\t\t iraf.scombine('bbody_sn_fit.fits,sn.fits,sn.fits,sn.fits', 'bsn_combo.fits',combine='median')\n\n\t\t iraf.wspec('bsn_combo.fits','bsn_combo.txt',header='no')\n\n\t\t print '#######################################'\n\t\t print '\\033[4mSince now you are working with an hybrid spectrum+blackbody, if you want additional information, please use the normal version.\\033[0m '\n\t\t print '#######################################'\n\n\t\t lcf = open('bsn_combo.txt','r')\n\t\t riga = lcf.readlines()\n\t\t lcf.close()\n\t\t wave,flux= [],[]\n\t\t for line in riga:\n\t\t p = line.split()\n\t\t if float(line.split()[0]) >= fil_obs_min and float(line.split()[0]) <= fil_obs_max: #to match the spectrum wavelegnths to those of the filter\n\t\t wave.append(float(p[0]))\n\t\t flux.append(float(p[1]))\n\t\t \n\t\t wavev = array(wave)\n\t\t fluxv = array(flux)\n\t\t wavesp_min= min(wavev)\n\t\t wavesp_max= int(max(wavev)) #needed to avoid problems with interp1d\n\n\t\t # interpolating the two responses to match the length and sampling coverage\n\t\t conf = conv(wavev,fluxv,wavefilterv,transmissionv,wavesp_min,wavesp_max,fil_obs_min,fil_obs_max)\n\n\t\t ##################################\n\t\t ### Evaluating the magnitudes\n\t\t ##################################\n\n\t\t flux_obs = max(integrate.cumtrapz(conf[0],conf[1])) # using trapezoidal rule to integrate\n\t\t flux_obs_err = flux_obs * (1+(anguncov[ii]-50)*0.0001)\n\n\t\t iraf.dopcor('bsn_combo.fits','bsn_combo_dez.fits', redshift=redshift, isveloc='no', flux='no',factor=3)\n\t\t iraf.dopcor('bsn_combo.fits','bsn_combo_dez_err1.fits', redshift=redserrspace1, isveloc='no', flux='no',factor=3)\n\t\t iraf.dopcor('bsn_combo.fits','bsn_combo_dez_err2.fits', redshift=redserrspace2, isveloc='no', flux='no',factor=3)\n\t\t iraf.wspec('bsn_combo_dez.fits','bsn_combo_dez.txt',header='no')\n\t\t iraf.wspec('bsn_combo_dez_err1.fits','bsn_combo_dez_err1.txt',header='no')\n\t\t iraf.wspec('bsn_combo_dez_err2.fits','bsn_combo_dez_err2.txt',header='no')\n\t\t \n\t\t lcf = open('bsn_combo_dez.txt','r')\n\t\t riga = lcf.readlines()\n\t\t lcf.close()\n\t\t rwave,rflux= [],[]\n\t\t for line in riga:\n\t\t p = line.split()\n\t\t if float(line.split()[0]) >= fil_rest_min and float(line.split()[0]) <= fil_rest_max:\n\t\t rwave.append(float(p[0]))\n\t\t rflux.append(float(p[1]))\n\t\t \n\t\t wave_dezv = array(rwave)\n\t\t flux_dezv = array(rflux)\n\t\t wavesp_dez_min= min(wave_dezv)\n\t\t wavesp_dez_max= int(max(wave_dezv)) #needed to avoid problems with interp1d\n\n\t\t # interpolating the two responses in the rest wavelength to match the length and sampling coverage\n\t\t conf = conv(wave_dezv,flux_dezv,wavefilter_restv,transmission_restv,wavesp_dez_min,wavesp_dez_max,fil_rest_min,fil_rest_max)\n\t\t flux_rest = max(integrate.cumtrapz(conf[0],conf[1]))\n\n\t\t ###### doing that again for the errors ############################################################\n\t\t lcf = open('bsn_combo_dez_err1.txt','r')\n\t\t riga = lcf.readlines()\n\t\t lcf.close()\n\t\t rwave,rflux= [],[]\n\t\t for line in riga:\n\t\t p = line.split()\n\t\t if float(line.split()[0]) >= fil_rest_min and float(line.split()[0]) <= fil_rest_max:\n\t\t rwave.append(float(p[0]))\n\t\t rflux.append(float(p[1]))\n\t\t \n\t\t wave_dezv = array(rwave)\n\t\t flux_dezv = array(rflux)\n\t\t wavesp_dez_min= min(wave_dezv)\n\t\t wavesp_dez_max= int(max(wave_dezv)) #needed to avoid problems with interp1d\n\n\t\t conf = conv(wave_dezv,flux_dezv,wavefilter_restv,transmission_restv,wavesp_dez_min,wavesp_dez_max,fil_rest_min,fil_rest_max)\n\n\t\t flux_rest_err1 = max(integrate.cumtrapz(conf[0],conf[1]))\n\t\t \n\t\t lcf = open('bsn_combo_dez_err2.txt','r')\n\t\t riga = lcf.readlines()\n\t\t lcf.close()\n\t\t rwave,rflux= [],[]\n\t\t for line in riga:\n\t\t p = line.split()\n\t\t if float(line.split()[0]) >= fil_rest_min and float(line.split()[0]) <= fil_rest_max:\n\t\t rwave.append(float(p[0]))\n\t\t rflux.append(float(p[1]))\n\t\t \n\t\t wave_dezv = array(rwave)\n\t\t flux_dezv = array(rflux)\n\t\t wavesp_dez_min= min(wave_dezv)\n\t\t wavesp_dez_max= int(max(wave_dezv)) #needed to avoid problems with interp1d\n\n\t\t conf = conv(wave_dezv,flux_dezv,wavefilter_restv,transmission_restv,wavesp_dez_min,wavesp_dez_max,fil_rest_min,fil_rest_max)\n\n\t\t flux_rest_err2 = max(integrate.cumtrapz(conf[0],conf[1]))\n \t##################################################################################################\n\t\t kcorrrest_bb_wor=-2.5*log10(flux_obs/zp_ef) - (-2.5*log10(flux_rest/zp_ef_rest)) +logterm\n\t\t kcorrrest_bb_wor_err1=-2.5*log10(flux_obs/zp_ef) - (-2.5*log10(flux_rest_err1/zp_ef_rest)) +(2.5*log10(1+redserrspace1))\n\t\t kcorrrest_bb_wor_err2=-2.5*log10(flux_obs/zp_ef) - (-2.5*log10(flux_rest_err2/zp_ef_rest)) +(2.5*log10(1+redserrspace2))\n\t\t kcorrerror_bb_wor=(abs(kcorrrest_bb_wor_err1 - kcorrrest_bb_wor) + abs(kcorrrest_bb_wor_err2 - kcorrrest_bb_wor))/2\n\t\t kcorrerrfilt_obs = abs((-2.5*log10(flux_obs/zp_ef_err) - (-2.5*log10(flux_rest/zp_ef_rest)))-(-2.5*log10(flux_obs/zp_ef) - (-2.5*log10(flux_rest/zp_ef_rest))))\n\t\t kcorrerrfilt_rest = abs((-2.5*log10(flux_obs/zp_ef) - (-2.5*log10(flux_rest/zp_ef_rest_err)))-(-2.5*log10(flux_obs/zp_ef) - (-2.5*log10(flux_rest/zp_ef_rest))))\n\t\t Kcorrerr_bb = abs((-2.5*log10(flux_obs/zp_ef) - (-2.5*log10(flux_rest/zp_ef_rest)))-(-2.5*log10(flux_obs_err/zp_ef) - (-2.5*log10(flux_rest/zp_ef_rest))))\n\t\t kcorrerr = sqrt((kcorrerror_bb_wor**2 + kcorrerrfilt_obs**2 + kcorrerrfilt_rest**2 + Kcorrerr_bb**2)/4)\n\t\t \n\t\t kcorr[ii] = kcorrrest_bb_wor\n\t\t kcorr_e[ii] = kcorrerr\n\t\t method[ii] = 'Hybrid obs_spec_BB'\n\t\t btemp[ii] = bbt\t\t \n\t\t split = 1\n\n\t elif filter1 == 'U' or filter1 == 'u' or filter1 == 'uvw1' or filter1 == 'uvw2' or filter1 == 'uvm2' or filter1 == 'NUV' or filter1 == 'FUV':\n\t\t print waveobs_min-fil_obs_min,' Angstrom not covered by the observed spectrum in the blue'\n\t\t kcorr[ii] = 0.0\n\t\t kcorr_e[ii] = 0.0\n\t\t method[ii] = 'None'\n\t\t btemp[ii] = 'None' \n\t\t anguncov[ii] = waveobs_min-fil_obs_min\n\t\t uncovside[ii] = 'Blue'\n\t elif filter1 == 'K':\n\t\t print fil_obs_max-waveobs_max,' Angstrom not covered by the observed spectrum in the red'\n\t\t kcorr[ii] = 0.0\n\t\t kcorr_e[ii] = 0.0\n\t\t method[ii] = 'None'\n\t\t btemp[ii] = 'None'\n\t\t anguncov[ii] = fil_obs_max-waveobs_max\n\t\t uncovside[ii] = 'Red'\n\n\tif split == 0:\n\t\tif ((waverest_min-fil_rest_min) > 50) or ((fil_rest_max-waverest_max) > 50):\n\t\t\tprint ''\n\t\t\tif (waverest_min-fil_rest_min) > 50:\n\t\t\t\tprint waverest_min-fil_rest_min,' Angstrom not covered by the restframe spectrum in the blue'\n\t\t\t\tanguncov[ii] = waverest_min-fil_rest_min\n\t\t\t\tuncovside[ii] = 'Blue'\n\t\t\telif (fil_rest_max-waverest_max) > 50:\n\t\t\t\tprint fil_rest_max-waverest_max,' Angstrom not covered by the restframe spectrum in the red'\n\t\t\t\tanguncov[ii] = fil_rest_max-waverest_max\n\t\t\t\tuncovside[ii] = 'Red'\n\n\t\t\tprint ''\n\t\t\tBBparams, covar = curve_fit(bbody,wavedezv,fluxdezv,p0=(10000,1E-16))\n\t\t\tT= BBparams[0]\n\t\t\tArea = BBparams[1]\n\t\t\tprint '\\nBlackbody temperature rest spectrum = %.0f +\\- %.0f K\\n' % (T,np.sqrt(covar[0,0]))\n\t\t\tbbt = 'BBrest = %.0f +\\- %.0f K' % (T,np.sqrt(covar[0,0]))\n\t\t\toutputname = \"bbody_sn_dez_fit.dat\" #% T\n\t\t\tfile = open(outputname,\"w\")\n\t\t\tfile.write(\"# Blackbody temperature = %.0f +\\- %.0f K\\n\" % (T,np.sqrt(covar[0,0])))\n\t\t\tw,f = [],[]\n\t\t\tfor wav in range(900,26000):\n\t\t\t\tfile.write(\"%g\\t%g\\n\" % (wav,bbody(wav,T,Area)))\n\t\t\t\tw.append(wav)\n\t\t\t\tf.append(bbody(wav,T,Area))\n\n\t\t\t######### BBody for the error spectra ################################################\n\t\t\tBBparams, covar = curve_fit(bbody,wavedezv_err1,fluxdezv_err1,p0=(10000,1E-16)) #initial guess\n\t\t\tT= BBparams[0]\n\t\t\tArea = BBparams[1]\n\t\t\toutputname = \"bbody_sn_dez_fit_err1.dat\" #% T\n\t\t\tfile = open(outputname,\"w\")\n\t\t\tfile.write(\"# Blackbody temperature = %.0f +\\- %.0f K\\n\" % (T,np.sqrt(covar[0,0])))\n\t\t\tw,f = [],[]\n\t\t\tfor wav in range(900,24005):\n\t\t\t file.write(\"%g\\t%g\\n\" % (wav,bbody(wav,T,Area)))\n\t\t\t w.append(wav)\n\t\t\t f.append(bbody(wav,T,Area))\n\t\t\t\n\t\t\tBBparams, covar = curve_fit(bbody,wavedezv_err2,fluxdezv_err2,p0=(10000,1E-16)) #initial guess\n\t\t\tT= BBparams[0]\n\t\t\tArea = BBparams[1]\n\t\t\toutputname = \"bbody_sn_dez_fit_err2.dat\" #% T\n\t\t\tfile = open(outputname,\"w\")\n\t\t\tfile.write(\"# Blackbody temperature = %.0f +\\- %.0f K\\n\" % (T,np.sqrt(covar[0,0])))\n\t\t\tw,f = [],[]\n\t\t\tfor wav in range(900,24005):\n\t\t\t file.write(\"%g\\t%g\\n\" % (wav,bbody(wav,T,Area)))\n\t\t\t w.append(wav)\n\t\t\t f.append(bbody(wav,T,Area))\n\t\t\t######################################################################################## \n\t\t\tiraf.rspec('bbody_sn_dez_fit.dat','bbody_sn_dez_fit.fits', title='bbodyfit',flux='no',dtype='interp',crval1=900,cdelt1=1)\n\t\t\tiraf.rspec('bbody_sn_dez_fit_err1.dat','bbody_sn_dez_fit_err1.fits', title='bbodyfit',flux='no',dtype='interp',crval1=900,cdelt1=1)\n\t\t\tiraf.rspec('bbody_sn_dez_fit_err2.dat','bbody_sn_dez_fit_err2.fits', title='bbodyfit',flux='no',dtype='interp',crval1=900,cdelt1=1)\n\t\t\tiraf.scombine('bbody_sn_dez_fit.fits,sn_dez.fits,sn_dez.fits,sn_dez.fits', 'bsn_combo_dez.fits',combine='median')\n\t\t\tiraf.scombine('bbody_sn_dez_fit_err1.fits,sn_dez_err1.fits,sn_dez_err1.fits,sn_dez_err1.fits', 'bsn_combo_dez_err1.fits',combine='median')\n\t\t\tiraf.scombine('bbody_sn_dez_fit_err2.fits,sn_dez_err2.fits,sn_dez_err2.fits,sn_dez_err2.fits', 'bsn_combo_dez_err2.fits',combine='median')\n\t\t\tiraf.wspec('bsn_combo_dez.fits','bsn_combo_dez.txt',header='no')\n\t\t\tiraf.wspec('bsn_combo_dez_err1.fits','bsn_combo_dez_err1.txt',header='no')\n\t\t\tiraf.wspec('bsn_combo_dez_err2.fits','bsn_combo_dez_err2.txt',header='no')\n\n\t\t\tprint '#######################################'\n\t\t\tprint ' Since now you are using a rest-frame spectrum based on a combination of SN+Blackbody '\n\t\t\tprint '#######################################'\n\n\t\t\tiraf.wspec(\"sn.fits\",\"sn.txt\", header='no')\n\t\t\tlcf = open('sn.txt','r')\n\t\t\triga = lcf.readlines()\n\t\t\tlcf.close()\n\t\t\twave,flux= [],[]\n\t\t\tfor line in riga:\n\t\t\t p = line.split()\n\t\t\t if float(line.split()[0]) >= fil_obs_min and float(line.split()[0]) <= fil_obs_max: #to match the spectrum wavelegnths to those of the filter\n\t\t\t wave.append(float(p[0]))\n\t\t\t flux.append(float(p[1]))\n\t\t\t \n\t\t\twavev = array(wave)\n\t\t\tfluxv = array(flux)\n\t\t\twavesp_min= min(wavev)\n\t\t\twavesp_max= int(max(wavev)) #needed to avoid problems with interp1d\n\t\t\t\n\t\t\t# interpolating the two responses to match the length and sampling coverage\n\t\t\tconf = conv(wavev,fluxv,wavefilterv,transmissionv,wavesp_min,wavesp_max,fil_obs_min,fil_obs_max)\n\t\t\tflux_obs = max(integrate.cumtrapz(conf[0],conf[1])) # using trapezoidal rule to integrate\n\n\t\t\tlcf = open('bsn_combo_dez.txt','r')\n\t\t\triga = lcf.readlines()\n\t\t\tlcf.close()\n\t\t\trwave,rflux= [],[]\n\t\t\tfor line in riga:\n\t\t\t\tp = line.split()\n\t\t\t\tif float(line.split()[0]) >= fil_rest_min and float(line.split()[0]) <= fil_rest_max:\n\t\t\t\t\trwave.append(float(p[0]))\n\t\t\t\t\trflux.append(float(p[1]))\n\t\t\t\t\n\t\t\twave_dezv = array(rwave)\n\t\t\tflux_dezv = array(rflux)\n\t\t\twavesp_dez_min= min(wave_dezv)\n\t\t\twavesp_dez_max= int(max(wave_dezv)) #needed to avoid problems with interp1d\n\t\t\t\n\t\t\t# interpolating the two responses in the rest wavelength to match the length and sampling coverage\n\t\t\tconf = conv(wave_dezv,flux_dezv,wavefilter_restv,transmission_restv,wavesp_dez_min,wavesp_dez_max,fil_rest_min,fil_rest_max)\n\n\t\t\tflux_rest = max(integrate.cumtrapz(conf[0],conf[1]))\n\t\t\tflux_rest_err = flux_rest * (1+(anguncov[ii]-50)*0.0001)\n\n\t\t\t############ Errors #########################################################################\n\t\t\tlcf = open('bsn_combo_dez_err1.txt','r')\n\t\t\triga = lcf.readlines()\n\t\t\tlcf.close()\n\t\t\trwave,rflux= [],[]\n\t\t\tfor line in riga:\n\t\t\t p = line.split()\n\t\t\t if float(line.split()[0]) >= fil_rest_min and float(line.split()[0]) <= fil_rest_max:\n\t\t\t rwave.append(float(p[0]))\n\t\t\t rflux.append(float(p[1]))\n\t\t\t \n\t\t\twave_dezv = array(rwave)\n\t\t\tflux_dezv = array(rflux)\n\t\t\twavesp_dez_min= min(wave_dezv)\n\t\t\twavesp_dez_max= int(max(wave_dezv)) #needed to avoid problems with interp1d\n\n\t\t\tconf = conv(wave_dezv,flux_dezv,wavefilter_restv,transmission_restv,wavesp_dez_min,wavesp_dez_max,fil_rest_min,fil_rest_max)\n\n\t\t\tflux_rest_err1 = max(integrate.cumtrapz(conf[0],conf[1]))\n\n\t\t\tlcf = open('bsn_combo_dez_err2.txt','r')\n\t\t\triga = lcf.readlines()\n\t\t\tlcf.close()\n\t\t\trwave,rflux= [],[]\n\t\t\tfor line in riga:\n\t\t\t p = line.split()\n\t\t\t if float(line.split()[0]) >= fil_rest_min and float(line.split()[0]) <= fil_rest_max:\n\t\t\t rwave.append(float(p[0]))\n\t\t\t rflux.append(float(p[1]))\n\t\t\t \n\t\t\twave_dezv = array(rwave)\n\t\t\tflux_dezv = array(rflux)\n\t\t\twavesp_dez_min= min(wave_dezv)\n\t\t\twavesp_dez_max= int(max(wave_dezv)) #needed to avoid problems with interp1d\n\n\t\t\tconf = conv(wave_dezv,flux_dezv,wavefilter_restv,transmission_restv,wavesp_dez_min,wavesp_dez_max,fil_rest_min,fil_rest_max)\n\t\t\tflux_rest_err2 = max(integrate.cumtrapz(conf[0],conf[1]))\n \t\t\t#############################################################################################\n\n\t\t\tkcorrrest_bb_wor=-2.5*log10(flux_obs/zp_ef) - (-2.5*log10(flux_rest/zp_ef_rest))+logterm\n\t\t\tkcorrrest_bb_wor_err1=-2.5*log10(flux_obs/zp_ef) - (-2.5*log10(flux_rest_err1/zp_ef_rest))+(2.5*log10(1+redserrspace1))\n\t\t\tkcorrrest_bb_wor_err2=-2.5*log10(flux_obs/zp_ef) - (-2.5*log10(flux_rest_err2/zp_ef_rest))+(2.5*log10(1+redserrspace2))\n\t\t\tkcorrerror_bb_wor=(abs(kcorrrest_bb_wor_err1 - kcorrrest_bb_wor) + abs(kcorrrest_bb_wor_err2 - kcorrrest_bb_wor))/2\n\t\t\tkcorrerrfilt_obs = abs((-2.5*log10(flux_obs/zp_ef_err) - (-2.5*log10(flux_rest/zp_ef_rest)))-(-2.5*log10(flux_obs/zp_ef) - (-2.5*log10(flux_rest/zp_ef_rest))))\n\t\t\tkcorrerrfilt_rest = abs((-2.5*log10(flux_obs/zp_ef) - (-2.5*log10(flux_rest/zp_ef_rest_err)))-(-2.5*log10(flux_obs/zp_ef) - (-2.5*log10(flux_rest/zp_ef_rest))))\n\t\t\tKcorrerr_bb = abs((-2.5*log10(flux_obs/zp_ef) - (-2.5*log10(flux_rest/zp_ef_rest)) +(2.5*log10(1+redshift)))-(-2.5*log10(flux_obs/zp_ef) - (-2.5*log10(flux_rest_err/zp_ef_rest)) +(2.5*log10(1+redshift))))\n\t\t\tkcorrerr = sqrt((kcorrerror_bb_wor**2 + kcorrerrfilt_obs**2 + kcorrerrfilt_rest**2 + Kcorrerr_bb**2)/4)\n\n\t\t\tkcorr[ii] = kcorrrest_bb_wor\n\t\t\tkcorr_e[ii] = kcorrerr\n\t\t\tmethod[ii] = 'Hybrid rest_spec_BB'\n\t\t\tbtemp[ii] = bbt\n\t\telse:\n\t\t\tiraf.wspec(\"sn.fits\",\"sn.txt\", header='no')\n\t\t\tlcf = open('sn.txt','r')\n\t\t\triga = lcf.readlines()\n\t\t\tlcf.close()\n\t\t\twave,flux= [],[]\n\t\t\tfor line in riga:\n\t\t\t p = line.split()\n\t\t\t if float(line.split()[0]) >= fil_obs_min and float(line.split()[0]) <= fil_obs_max: #to match the spectrum wavelegnths to those of the filter\n\t\t\t wave.append(float(p[0]))\n\t\t\t flux.append(float(p[1]))\n\t\t\t \n\t\t\twavev = array(wave)\n\t\t\tfluxv = array(flux)\n\t\t\twavesp_min= min(wavev)\n\t\t\twavesp_max= int(max(wavev)) #needed to avoid problems with interp1d\n\t\t\t# interpolating the two responses to match the length and sampling coverage\n\n\t\t\tconf = conv(wavev,fluxv,wavefilterv,transmissionv,wavesp_min,wavesp_max,fil_obs_min,fil_obs_max)\n\n\t\t\t##################################\n\t\t\t### Evaluating the magnitudes\n\t\t\t##################################\n\t\t\tflux_obs = max(integrate.cumtrapz(conf[0],conf[1])) # using trapezoidal rule to integrate\n\t\t\tphot_filtobs_sn = -2.5*log10(flux_obs/zp_ef)\n\n\t\t\tiraf.wspec(\"sn_dez_dered.fits\",\"sn_dez_dered.txt\", header='no')\n\t\t\tlcf = open('sn_dez_dered.txt','r')\n\t\t\triga = lcf.readlines()\n\t\t\tlcf.close()\n\t\t\trwave,rflux= [],[]\n\t\t\tfor line in riga:\n\t\t\t p = line.split()\n\t\t\t if float(line.split()[0]) >= fil_rest_min and float(line.split()[0]) <= fil_rest_max:\n\t\t\t rwave.append(float(p[0]))\n\t\t\t rflux.append(float(p[1]))\n\t\t\t \n\t\t\twave_dezv = array(rwave)\n\t\t\tflux_dezv = array(rflux)\n\t\t\twavesp_dez_min= min(wave_dezv)\n\t\t\twavesp_dez_max= int(max(wave_dezv)) #needed to avoid problems with interp1d\n\t\t\t\n\t\t\t# interpolating the two responses in the rest wavelength to match the length and sampling coverage\n\t\t\tconf = conv(wave_dezv,flux_dezv,wavefilter_restv,transmission_restv,wavesp_dez_min,wavesp_dez_max,fil_rest_min,fil_rest_max)\n\t\t\tflux_rest = max(integrate.cumtrapz(conf[0],conf[1]))\n\n\t\t\tphot_filtrest_sn_dez_dered=-2.5*log10(flux_rest/zp_ef_rest)\n \t\t\t####### Errors ######################################################################################\n \t\t\tiraf.wspec(\"sn_dez_dered_err1.fits\",\"sn_dez_dered_err1.txt\", header='no')\n \t\t\tlcf = open('sn_dez_dered_err1.txt','r')\n \t\t\triga = lcf.readlines()\n \t\t\tlcf.close()\n \t\t\trwave,rflux= [],[]\n \t\t\tfor line in riga:\n \t\t\t p = line.split()\n \t\t\t if float(line.split()[0]) >= fil_rest_min and float(line.split()[0]) <= fil_rest_max:\n \t\t\t rwave.append(float(p[0]))\n \t\t\t rflux.append(float(p[1]))\n \t\t\t \n \t\t\twave_dezv = array(rwave)\n \t\t\tflux_dezv = array(rflux)\n \t\t\twavesp_dez_min= min(wave_dezv)\n \t\t\twavesp_dez_max= int(max(wave_dezv)) #needed to avoid problems with interp1d\n \t\t\t\n \t\t\t# interpolating the two responses in the rest wavelength to match the length and sampling coverage\n \t\t\tconf = conv(wave_dezv,flux_dezv,wavefilter_restv,transmission_restv,wavesp_dez_min,wavesp_dez_max,fil_rest_min,fil_rest_max)\n \t\t\tflux_rest_err1 = max(integrate.cumtrapz(conf[0],conf[1]))\n\t\t\t\n \t\t\tiraf.wspec(\"sn_dez_dered_err2.fits\",\"sn_dez_dered_err2.txt\", header='no')\n \t\t\tlcf = open('sn_dez_dered_err2.txt','r')\n \t\t\triga = lcf.readlines()\n \t\t\tlcf.close()\n \t\t\trwave,rflux= [],[]\n \t\t\tfor line in riga:\n \t\t\t p = line.split()\n \t\t\t if float(line.split()[0]) >= fil_rest_min and float(line.split()[0]) <= fil_rest_max:\n \t\t\t rwave.append(float(p[0]))\n \t\t\t rflux.append(float(p[1]))\n \t\t\t \n \t\t\twave_dezv = array(rwave)\n \t\t\tflux_dezv = array(rflux)\n \t\t\twavesp_dez_min= min(wave_dezv)\n \t\t\twavesp_dez_max= int(max(wave_dezv)) #needed to avoid problems with interp1d\n \t\t\t\n \t\t\t# interpolating the two responses in the rest wavelength to match the length and sampling coverage\n \t\t\tconf = conv(wave_dezv,flux_dezv,wavefilter_restv,transmission_restv,wavesp_dez_min,wavesp_dez_max,fil_rest_min,fil_rest_max)\n \t\t\tflux_rest_err2 = max(integrate.cumtrapz(conf[0],conf[1]))\n \t\t\t######################################################################################################\n \t\t\tphot_filtrest_sn_dez_dered_err1=-2.5*log10(flux_rest_err1/zp_ef_rest)\n \t\t\tphot_filtrest_sn_dez_dered_err2=-2.5*log10(flux_rest_err2/zp_ef_rest)\n\n\t\t\tiraf.wspec(\"sn_dez.fits\",\"sn_dez.txt\", header='no')\n\t\t\tlcf = open('sn_dez.txt','r')\n\t\t\triga = lcf.readlines()\n\t\t\tlcf.close()\n\t\t\trwave,rflux= [],[]\n\t\t\tfor line in riga:\n\t\t\t p = line.split()\n\t\t\t if float(line.split()[0]) >= fil_rest_min and float(line.split()[0]) <= fil_rest_max:\n\t\t\t rwave.append(float(p[0]))\n\t\t\t rflux.append(float(p[1]))\n\t\t\t \n\t\t\twave_dezv = array(rwave)\n\t\t\tflux_dezv = array(rflux)\n\t\t\twavesp_dez_min= min(wave_dezv)\n\t\t\twavesp_dez_max= int(max(wave_dezv)) #needed to avoid problems with interp1d\n\t\t\t\n\t\t\t# interpolating the two responses in the rest wavelength to match the length and sampling coverage\n\t\t\tconf = conv(wave_dezv,flux_dezv,wavefilter_restv,transmission_restv,wavesp_dez_min,wavesp_dez_max,fil_rest_min,fil_rest_max)\n\t\t\tflux_rest = max(integrate.cumtrapz(conf[0],conf[1]))\n \n\t\t\tphot_filtrest_sn_dez=-2.5*log10(flux_rest/zp_ef_rest)\n\t\t\t\n\t\t\t##################### Errors ######################################################################\n\t\t\tiraf.wspec(\"sn_dez_err1.fits\",\"sn_dez_err1.txt\", header='no')\n\t\t\tlcf = open('sn_dez_err1.txt','r')\n\t\t\triga = lcf.readlines()\n\t\t\tlcf.close()\n\t\t\trwave,rflux= [],[]\n\t\t\tfor line in riga:\n\t\t\t p = line.split()\n\t\t\t if float(line.split()[0]) >= fil_rest_min and float(line.split()[0]) <= fil_rest_max:\n\t\t\t rwave.append(float(p[0]))\n\t\t\t rflux.append(float(p[1]))\n\t\t\t \n\t\t\twave_dezv = array(rwave)\n\t\t\tflux_dezv = array(rflux)\n\t\t\twavesp_dez_min= min(wave_dezv)\n\t\t\twavesp_dez_max= int(max(wave_dezv)) #needed to avoid problems with interp1d\n\t\t\t\n\t\t\t# interpolating the two responses in the rest wavelength to match the length and sampling coverage\n\t\t\tconf = conv(wave_dezv,flux_dezv,wavefilter_restv,transmission_restv,wavesp_dez_min,wavesp_dez_max,fil_rest_min,fil_rest_max)\n\t\t\tflux_rest_err1 = max(integrate.cumtrapz(conf[0],conf[1]))\n\t\t\t\n\t\t\tiraf.wspec(\"sn_dez_err2.fits\",\"sn_dez_err2.txt\", header='no')\n\t\t\tlcf = open('sn_dez_err2.txt','r')\n\t\t\triga = lcf.readlines()\n\t\t\tlcf.close()\n\t\t\trwave,rflux= [],[]\n\t\t\tfor line in riga:\n\t\t\t p = line.split()\n\t\t\t if float(line.split()[0]) >= fil_rest_min and float(line.split()[0]) <= fil_rest_max:\n\t\t\t rwave.append(float(p[0]))\n\t\t\t rflux.append(float(p[1]))\n\t\t\t \n\t\t\twave_dezv = array(rwave)\n\t\t\tflux_dezv = array(rflux)\n\t\t\twavesp_dez_min= min(wave_dezv)\n\t\t\twavesp_dez_max= int(max(wave_dezv)) #needed to avoid problems with interp1d\n\t\t\t\n\t\t\t# interpolating the two responses in the rest wavelength to match the length and sampling coverage\n\t\t\tconf = conv(wave_dezv,flux_dezv,wavefilter_restv,transmission_restv,wavesp_dez_min,wavesp_dez_max,fil_rest_min,fil_rest_max)\n\t\t\tflux_rest_err2 = max(integrate.cumtrapz(conf[0],conf[1]))\n\t\t\t####################################################################################################\n\t\t\tphot_filtrest_sn_dez_err1=-2.5*log10(flux_rest_err1/zp_ef_rest)\n\t\t\tphot_filtrest_sn_dez_err2=-2.5*log10(flux_rest_err2/zp_ef_rest)\n\n\t\t\t##################################\n\t\t\t### K-correction evaluation\n\t\t\t##################################\n\t\t\t\n\t\t\tkcorrrest_wr=(float(phot_filtobs_sn)-float(phot_filtrest_sn_dez_dered))+logterm\n\t\t\tkcorrrest_wr_err1=(float(phot_filtobs_sn)-float(phot_filtrest_sn_dez_dered_err1))+(2.5*log10(1+redserrspace1))\n\t\t\tkcorrrest_wr_err2=(float(phot_filtobs_sn)-float(phot_filtrest_sn_dez_dered_err2))+(2.5*log10(1+redserrspace2))\n\t\t\tkcorrerror_wr=(abs(kcorrrest_wr_err1 - kcorrrest_wr) + abs(kcorrrest_wr_err2 - kcorrrest_wr))/2\n\n\t\t\tkcorrrest_wor=(float(phot_filtobs_sn)-float(phot_filtrest_sn_dez))+logterm\n\t\t\tkcorrrest_wor_err1=(float(phot_filtobs_sn)-float(phot_filtrest_sn_dez_err1))+(2.5*log10(1+redserrspace1))\n\t\t\tkcorrrest_wor_err2=(float(phot_filtobs_sn)-float(phot_filtrest_sn_dez_err2))+(2.5*log10(1+redserrspace2))\n\t\t\tkcorrerror_wor=(abs(kcorrrest_wor_err1 - kcorrrest_wor) + abs(kcorrrest_wor_err2 - kcorrrest_wor))/2\n\t\t\t\n\t\t\tkcorrerrfilt_obs = abs((-2.5*log10(flux_obs/zp_ef_err) - (-2.5*log10(flux_rest/zp_ef_rest)))-(-2.5*log10(flux_obs/zp_ef) - (-2.5*log10(flux_rest/zp_ef_rest))))\n\t\t\tkcorrerrfilt_rest = abs((-2.5*log10(flux_obs/zp_ef) - (-2.5*log10(flux_rest/zp_ef_rest_err)))-(-2.5*log10(flux_obs/zp_ef) - (-2.5*log10(flux_rest/zp_ef_rest))))\n\t\t\t\n\t\t\tkcorrerr_wor = sqrt((kcorrerror_wor**2 + kcorrerrfilt_obs**2 + kcorrerrfilt_rest**2)/3)\n\t\t\tkcorrerr_wr = sqrt((kcorrerror_wr**2 + kcorrerrfilt_obs**2 + kcorrerrfilt_rest**2)/3)\n\n\t\t\tkcorr[ii] = kcorrrest_wr\n\t\t\tkcorr_e[ii] = kcorrerr_wr\n\t\t\tmethod[ii] = 'specTOspec'\n\t\t\tbtemp[ii] = 'None'\n\t\t\tanguncov[ii] = 0.0\n\t\t\tuncovside[ii] = 'None'\n\n\n\t# cleaning process (unnecessary)\n\tos.system('rm -rf sn.txt')\n\tos.system('rm -rf sn.fits')\n\tos.system('rm -rf sn_xbbody.txt')\n\tos.system('rm -rf sn_dez_xbbody.txt')\n\tos.system('rm -rf sn_dez_xbbody_err1.txt')\n\tos.system('rm -rf sn_dez_xbbody_err2.txt')\n\tos.system('rm -rf bbody_sn_dez_fit.dat')\n\tos.system('rm -rf bbody_sn_dez_fit_err1.dat')\n\tos.system('rm -rf bbody_sn_dez_fit_err2.dat')\n\tos.system('rm -rf bbody_sn_dez_fit.fits')\n\tos.system('rm -rf bbody_sn_dez_fit_err1.fits')\n\tos.system('rm -rf bbody_sn_dez_fit_err2.fits')\n\tos.system('rm -rf bbody_sn_fit.fits')\n\tos.system('rm -rf bbody_sn_fit.dat')\n\tos.system('rm -rf sn_dez.txt')\n\tos.system('rm -rf sn_dez_err1.txt')\n\tos.system('rm -rf sn_dez_err2.txt')\n\tos.system('rm -rf sn_dez.fits')\n\tos.system('rm -rf sn_dez_err1.fits')\n\tos.system('rm -rf sn_dez_err2.fits')\n\tos.system('rm -rf sn_dez_dered.fits')\n\tos.system('rm -rf sn_dez_dered_err1.fits')\n\tos.system('rm -rf sn_dez_dered_err2.fits')\n\tos.system('rm -rf sn_dez_dered.txt')\n\tos.system('rm -rf sn_dez_dered_err1.txt')\n\tos.system('rm -rf sn_dez_dered_err2.txt')\n\tos.system('rm -rf sn_galdered_dez.fits')\n\tos.system('rm -rf sn_galdered_dez_err1.fits')\n\tos.system('rm -rf sn_galdered_dez_err2.fits')\n\tos.system('rm -rf sn_galdered.fits')\n\tos.system('rm -rf bsn_combo_dez.fits')\n\tos.system('rm -rf bsn_combo_dez_err1.fits')\n\tos.system('rm -rf bsn_combo_dez_err2.fits')\n\tos.system('rm -rf bsn_combo_dez.txt')\n\tos.system('rm -rf bsn_combo_dez_err1.txt')\n\tos.system('rm -rf bsn_combo_dez_err2.txt')\n\tos.system('rm -rf bsn_combo.fits')\n\tos.system('rm -rf bsn_combo.txt')\n\tsleep(_sleepc) #to avoid missing files and correction due to a combo of two different spectra (a.k.a. the code arrives at the right step before the system remove the file)\n\t##########################\n\t### Adding values to the txt file\n\t#########################\n\tredlist[ii] = redshift\n\tfilekc.write(snname)\n\tfilekc.write(\"\\t\")\n\tfilekc.write(\"%s+/-%s\" % (redshift,_redshifterr))\n\tfilekc.write(\"\\t\\t\")\n\tfilekc.write(filter1)\n\tfilekc.write(\"\\t\\t\")\n\tfilekc.write(filter2)\n\tfilekc.write(\"\\t\\t\")\n\tfilekc.write(\"%0.3f\" % (kcorr[ii]))\n\tfilekc.write(\"\\t\\t\")\n\tfilekc.write(\"+/-%0.3f\" % (kcorr_e[ii]))\n\tfilekc.write(\"\\t\\t\")\n\tfilekc.write(method[ii])\n\tfilekc.write(\"\\t\\t\")\n\tfilekc.write(btemp[ii])\n\tfilekc.write(\"\\t\\t\")\n\tfilekc.write(\"%s\" % (anguncov[ii]))\n\tfilekc.write(\"\\t\")\n\tfilekc.write(uncovside[ii])\n\tfilekc.write(\"\\n\")\n\t#ax = subplot(111)\n\tif questionplot == 'yes':\n\t\tax = axes([0.1, 0.1, 0.65, 0.82])\n\t\tplot(9999,9999,color='b',marker='o',markeredgecolor='k',ls='None')\n\t\tplot(9999,9999,color='g',marker='d',markeredgecolor='k',ls='None')\n\t\tplot(9999,9999,color='r',marker='s',markeredgecolor='k',ls='None')\n\t\treds,redo,redr,kcors,kcoro,kcor1 = [],[],[],[],[],[]\n\t\tif method[ii] == 'specTOspec':\n\t\t\treds.append(redshift)\n\t\t\tkcors.append(kcorr[ii])\n\t\t\tplot(reds,kcors,'bo',ms=12)\n\t\tif method[ii] == 'Hybrid rest_spec_BB':\t\t\n\t\t\tredr.append(redshift)\n\t\t\tkcor1.append(kcorr[ii])\n\t\t\tplot(redr,kcor1,'gd',ms=12)\n\t\tif method[ii] == 'Hybrid obs_spec_BB':\n\t\t\tredo.append(redshift)\n\t\t\tkcoro.append(kcorr[ii])\n\t\t\tplot(redo,kcoro,'rs',ms=12)\n\tii = ii + 1\n\nthen = time.time()\ntime = then -now\n################\n### plotting commands\n##################\nif questionplot == 'yes':\n\txl = [float(min(redlist))-0.07,float(max(redlist))+0.07]\n\tyl = [min(kcorr)-0.3,max(kcorr)+0.3]\n\tlegend(('specTOspec', 'Hybrid rest specBB', 'Hybrid obs specBB'), numpoints=1,bbox_to_anchor=(1.01, 1), loc=2, borderaxespad=0.)\n\tltext = gca().get_legend().get_texts()\n\tsetp(ltext[0], fontsize = 14, color = 'b')\n\tsetp(ltext[1], fontsize = 14, color = 'g')\n\tsetp(ltext[2], fontsize = 14, color = 'r')\n\txlim(xl[0],xl[1])\n\tylim(yl[0],yl[1])\n\ttitle('From various observed filters to various rest filters')\n\txlabel('Redshift',size=18)\n\tylabel('K-correction',size=18)\n\tax.minorticks_on()\n\tshow()\n####################\n##### writing legend on the file\n####################\nfilekc.write(\"\\n# ----------------------------------------------------------------------------------\\n\")\nfilekc.write(\"# Legend for SNAKE mode:\\n\")\nfilekc.write(\"# specTOspec \\t--> K-correction computed with original spectrum in observed \\n#\\t\\t\\t\\t\\t\\tand rest frame\\n\")\nfilekc.write(\"# Hybrid rest_spec_BB\\t--> K-correction computed with original spectrum in observed \\n#\\t\\t\\t\\t\\t\\tframe and SN+Bbody hybrid in rest frame\\n\")\nfilekc.write(\"# Hybrid obs_spec_BB \\t--> K-correction computed with SN+bbody spectrum in observed \\n#\\t\\t\\t\\t\\t\\tand rest frame\\n\")\nfilekc.write(\"# ----------------------------------------------------------------------------------\\n\")\n\nsltime = _sleepc*len(snlist)\nprint '######################################################################'\nprint ''\nprint ' Evaluation done in %.0is, of which %.0is to take a nap to let rest your Random Access Memory (RAM) ' % (time,sltime)\t\nprint ''\nprint ' \\033[46mList of K-corrections\\033[0m ' , kcorr\nprint ' \\033[44mVersion used\\033[0m ' , method\nprint ''\nprint ' A text file has been created ===> Kcorrection_%.0i_%.0i.txt ' % (Tnowd,Tnow)\t\n\n\n", "meta": {"hexsha": "87a058295eb404bb6659803f74b1bfc81f0e0ee8", "size": 50093, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/s3/SNAKELOOP.py", "max_stars_repo_name": "cinserra/S3", "max_stars_repo_head_hexsha": "eefc12265bd7824204dc5cbbd648e3ff8b291273", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2017-07-24T17:35:20.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-05T15:40:45.000Z", "max_issues_repo_path": "src/s3/SNAKELOOP.py", "max_issues_repo_name": "cinserra/S3", "max_issues_repo_head_hexsha": "eefc12265bd7824204dc5cbbd648e3ff8b291273", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2018-10-24T10:46:26.000Z", "max_issues_repo_issues_event_max_datetime": "2018-10-24T10:46:26.000Z", "max_forks_repo_path": "src/s3/SNAKELOOP.py", "max_forks_repo_name": "cinserra/S3", "max_forks_repo_head_hexsha": "eefc12265bd7824204dc5cbbd648e3ff8b291273", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-04-12T13:03:05.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-12T13:03:05.000Z", "avg_line_length": 44.4086879433, "max_line_length": 227, "alphanum_fraction": 0.6302078135, "include": true, "reason": "from numpy,from scipy", "num_tokens": 15304, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5621765008857982, "lm_q2_score": 0.34864513533394575, "lm_q1q2_score": 0.1960001022328932}} {"text": "\"\"\"\nTools for aperture photometry with non native bg/error methods\n\nThis function serves to ease the computation of photometric magnitudes\nand errors using PhotUtils by replicating DAOPHOT's photometry and\nerror methods. The formula for DAOPHOT's error is:\n\nerr = sqrt (Poisson_noise / epadu + area * stdev**2 + area**2 * stdev**2 / nsky)\n\nWhich gives a magnitude error:\n\nmag_err = 1.0857 * err / flux\n\nWhere epadu is electrons per ADU (gain), area is the photometric\naperture area, stdev is the uncertainty in the sky measurement\nand nsky is the sky annulus area. To get the uncertainty in the sky\nwe must use a custom background tool, which also enables computation of\nthe mean and median of the sky as well (more robust statistics).\nAll the stats are sigma clipped. These are calculated by the\nfunctions in aperture_stats_tbl.\n\n.. note::\n Currently, the background computations will fully include a pixel that has ANY overlap with the background aperture\n (the annulus). This is to simplify the computation of the median, as a weighted median is nontrivial, and slower.\n Copied from https://grit.stsci.edu/HLA/software/blob/master/HLApipeline/HLApipe/scripts/photometry_tools.py\nAuthors\n-------\n - Varun Bajaj, January 2018\n\nUse\n---\n\n::\n\n from photometry_tools import iraf_style_photometry\n phot_aps = CircularAperture((sources['xcentroid'], sources['ycentroid']),r=10.)\n bg_aps = CircularAnnulus((sources['xcentroid'], sources['ycentroid']), r_in=13., r_out=15.)\n\nSimplest call:\n\n::\n\n photometry_tbl = iraf_style_photometry(phot_aps, bg_aps, data)\n\nPass in pixelwise error and set background to mean\n\n::\n\n photometry_tbl = iraf_style_photometry(phot_aps, bg_aps, data, error_array=data_err, bg_method='mean')\n\nCan also set the gain (if image units are DN)\n\n::\n\n photometry_tbl = iraf_style_photometry(phot_aps, bg_aps, data, epadu=2.5)\n\nClasses and Functions\n---------------------\n\"\"\"\nimport numpy as np\nfrom astropy.table import Table\nfrom drizzlepac.hlautils.background_median import aperture_stats_tbl\nfrom photutils import aperture_photometry\n\n\ndef iraf_style_photometry(phot_apertures, bg_apertures, data, photflam, photplam, error_array=None,\n bg_method='mode', epadu=1.0):\n \"\"\"\n Computes photometry with PhotUtils apertures, with IRAF formulae\n\n Parameters\n ----------\n phot_apertures : photutils PixelAperture object (or subclass)\n The PhotUtils apertures object to compute the photometry. i.e. the object returned via CirularAperture.\n\n bg_apertures : photutils PixelAperture object (or subclass)\n The phoutils aperture object to measure the background in. i.e. the object returned via CircularAnnulus.\n\n data : array\n The data for the image to be measured.\n\n photflam : float\n inverse sensitivity, in ergs/cm2/angstrom/electron\n\n photplam : float\n Pivot wavelength, in angstroms\n\n error_array : array\n (Optional) The array of pixelwise error of the data. If none, the Poisson noise term in the error computation\n will just be the square root of the flux/epadu. If not none, the aperture_sum_err column output by\n aperture_photometry (divided by epadu) will be used as the Poisson noise term.\n\n bg_method: string\n {'mean', 'median', 'mode'}, optional. The statistic used to calculate the background. All measurements are\n sigma clipped. Default value is 'mode'. NOTE: From DAOPHOT, mode = 3 * median - 2 * mean.\n\n epadu : float\n (optional) Gain in electrons per adu (only use if image units aren't e-). Default value is 1.0\n\n Returns\n -------\n An astropy Table with columns as follows:\n X-Center Y-Center RA DEC ID MagAp1 MagErrAp1 MagAp2 MagErrAp2 MSkyAp2 StdevAp2 FluxAp2 CI Flags\n \"\"\"\n if bg_method not in ['mean', 'median', 'mode']:\n raise ValueError('Invalid background method, choose either \\\n mean, median, or mode')\n phot = aperture_photometry(data, phot_apertures, error=error_array)\n bg_phot = aperture_stats_tbl(data, bg_apertures, sigma_clip=True)\n names = ['X-Center', 'Y-Center', 'ID']\n x, y = phot_apertures[0].positions.T\n final_stacked = np.stack([x, y, phot[\"id\"].data], axis=1)\n # n_aper = 0\n name_list = 'Flux', 'FluxErr', 'Mag', 'MagErr'\n for aper_string in ['Ap1', 'Ap2']:\n for col_name in name_list:\n names.append(\"{}{}\".format(col_name,aper_string))\n\n # for item in list(phot.keys()):\n # if item.startswith(\"aperture_sum_\") and not item.startswith(\"aperture_sum_err_\"):\n # aper_size_arcsec = phot_apertures[n_aper].r * platescale\n # for name in name_list:\n # names.append(\"{}_{:.2f}\".format(name, aper_size_arcsec))\n # n_aper += 1\n for aperCtr in range(0, 2):\n ap_area = phot_apertures[aperCtr].area\n bg_method_name = 'aperture_{}'.format(bg_method)\n\n # NOTE background subtraction below commented out 8/14/19\n flux = phot['aperture_sum_{}'.format(aperCtr)] # - bg_phot[bg_method_name] * ap_area\n\n # Need to use variance of the sources\n # for Poisson noise term in error computation.\n #\n # This means error needs to be squared.\n # If no error_array error = flux ** .5\n\n if error_array is not None:\n flux_error = compute_phot_error(phot['aperture_sum_err_{}'.format(aperCtr)] ** 2.0, bg_phot, bg_method,\n ap_area, epadu)\n else:\n flux_error = compute_phot_error(flux, bg_phot, bg_method, ap_area, epadu)\n\n mag = convert_flux_to_abmag(flux, photflam, photplam)\n\n # NOTE: Magnitude error calculation comes from computing d(ABMAG)/d(flux).\n # See https://iraf.net/forum/viewtopic.php?showtopic=83932 for details.\n mag_err = 1.0857 * flux_error / flux\n\n # Build the final data table\n stacked = np.stack([flux, flux_error, mag, mag_err], axis=1)\n final_stacked = np.concatenate([final_stacked, stacked], axis=1)\n\n # Build final output table\n final_tbl = Table(data=final_stacked, names=names,\n dtype=[np.float64, np.float64, np.int64, np.float64, np.float64, np.float64, np.float64,\n np.float64, np.float64, np.float64, np.float64])\n\n # add sky and std dev columns from background calculation subroutine\n final_tbl.add_column(bg_phot[bg_method_name])\n final_tbl.rename_column(bg_method_name, 'MSkyAp2')\n final_tbl.add_column(bg_phot['aperture_std'])\n final_tbl.rename_column('aperture_std', 'StdevAp2')\n\n return final_tbl\n\n\ndef compute_phot_error(flux_variance, bg_phot, bg_method, ap_area, epadu=1.0):\n \"\"\"Computes the flux errors using the DAOPHOT style computation\n\n Parameters\n ----------\n flux_variance : array\n flux values\n\n bg_phot : array\n background brightness values.\n\n bg_method : string\n background method\n\n ap_area : array\n the area of the aperture in square pixels\n\n epadu : float\n (optional) Gain in electrons per adu (only use if image units aren't e-). Default value is 1.0\n\n Returns\n -------\n flux_error : array\n an array of flux errors\n \"\"\"\n\n bg_variance_terms = (ap_area * bg_phot['aperture_std'] ** 2.) * (1. + ap_area/bg_phot['aperture_area'])\n variance = flux_variance / epadu + bg_variance_terms\n flux_error = variance ** .5\n return flux_error\n\n\ndef convert_flux_to_abmag(in_flux, photflam, photplam):\n \"\"\"converts flux (in units of electrons/sec) to ABMAG\n\n Parameters\n ----------\n in_flux : astropy.table.column.Column object\n flux values to convert to ABMAG, in electrons/second\n\n photflam : float\n inverse sensitivity, in ergs/cm2/angstrom/electron\n\n photplam : float\n pivot wavelength, in angstroms\n\n Returns\n -------\n abmag : astropy.table.column.Column object\n input flux values converted to ABMAG\n \"\"\"\n\n # convert flux from units of electrons/second to ergs/cm2/angstrom/second\n f_lambda = in_flux * photflam\n\n # Convert f_lambda to STMAG\n stmag = -2.5 * np.log10(f_lambda) - 21.10\n\n # Convert STMAG to ABMAG\n abmag = stmag - 5.0 * np.log10(photplam) + 18.6921\n\n return abmag", "meta": {"hexsha": "40c945ee0442611df342eb9c85d747bc5936291e", "size": 8306, "ext": "py", "lang": "Python", "max_stars_repo_path": "drizzlepac/hlautils/photometry_tools.py", "max_stars_repo_name": "srodney/drizzlepac", "max_stars_repo_head_hexsha": "c554523331a6204ce113d4317b7286ad39094f74", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-02-10T16:15:58.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-24T20:08:03.000Z", "max_issues_repo_path": "drizzlepac/hlautils/photometry_tools.py", "max_issues_repo_name": "srodney/drizzlepac", "max_issues_repo_head_hexsha": "c554523331a6204ce113d4317b7286ad39094f74", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "drizzlepac/hlautils/photometry_tools.py", "max_forks_repo_name": "srodney/drizzlepac", "max_forks_repo_head_hexsha": "c554523331a6204ce113d4317b7286ad39094f74", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-09-02T18:08:39.000Z", "max_forks_repo_forks_event_max_datetime": "2020-09-02T18:08:39.000Z", "avg_line_length": 36.2707423581, "max_line_length": 119, "alphanum_fraction": 0.6797495786, "include": true, "reason": "import numpy,from astropy", "num_tokens": 2180, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5621765155565326, "lm_q2_score": 0.34864512179822543, "lm_q1q2_score": 0.19600009973830929}} {"text": "# Copyright (c) Facebook, Inc. and its affiliates.\n\n# This source code is licensed under the MIT license found in the\n# LICENSE file in the root directory of this source tree.\n\n\n\n\"\"\"Calculates the Frechet Inception Distance (FID) to evalulate GANs\n\nThe FID metric calculates the distance between two distributions of images.\nTypically, we have summary statistics (mean & covariance matrix) of one\nof these distributions, while the 2nd distribution is given by a GAN.\n\nWhen run as a stand-alone program, it compares the distribution of\nimages that are stored as PNG/JPEG at a specified location with a\ndistribution given by summary statistics (in pickle format).\n\nThe FID is calculated by assuming that X_1 and X_2 are the activations of\nthe pool_3 layer of the inception net for generated samples and real world\nsamples respectively.\n\nSee --help to see further details.\n\nCode apapted from https://github.com/bioinf-jku/TTUR to use PyTorch instead\nof Tensorflow\n\nCopyright 2018 Institute of Bioinformatics, JKU Linz\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n\"\"\"\nimport os\nimport cv2\nimport json\nimport pathlib\nfrom argparse import ArgumentParser, ArgumentDefaultsHelpFormatter\nimport torchvision\n\nimport numpy as np\nimport torch\nfrom scipy import linalg\nfrom torch.nn.functional import adaptive_avg_pool2d\nimport torch.nn.functional as F\n\nfrom PIL import Image\n\ntry:\n from tqdm import tqdm\nexcept ImportError:\n # If not tqdm is not available, provide a mock version of it\n def tqdm(x): return x\n\nfrom inception import InceptionV3\n\nparser = ArgumentParser(formatter_class=ArgumentDefaultsHelpFormatter)\nparser.add_argument('path', type=str, nargs=2,\n help=('Path to the generated images or '\n 'to .npz statistic files'))\nparser.add_argument('--batch-size', type=int, default=50,\n help='Batch size to use')\nparser.add_argument('--dims', type=int, default=2048,\n choices=list(InceptionV3.BLOCK_INDEX_BY_DIM),\n help=('Dimensionality of Inception features to use. '\n 'By default, uses pool3 features'))\nparser.add_argument('-c', '--gpu', default='', type=str,\n help='GPU to use (leave blank for CPU only)')\nparser.add_argument('--name', default='birds', type=str,\n help='which dataset to be evluated', choices=['birds', 'creatures'])\n\n\nwith open('../data/id_to_class.json', 'r') as fp:\n ID2CLASS = json.load(fp)\n ID2CLASS ={int(k): v for k, v in ID2CLASS.items()}\n\nB_SET = ['bird', 'duck', 'flamingo', 'parrot']\nC_SET = ['ant', 'bear', 'bee', 'bird', 'butterfly', 'camel', 'cat', 'cow', 'crab', 'crocodile', 'dog', 'dolphin', 'duck', \n 'elephant', 'fish', 'flamingo', 'frog', 'giraffe', 'hedgehog', 'horse', 'kangaroo', 'lion', 'lobster', 'monkey', 'mosquito', \n 'mouse', 'octopus', 'owl', 'panda', 'parrot', 'penguin', 'pig', 'rabbit', 'raccoon', 'rhinoceros', 'scorpion', 'sea_turtle', \n 'shark', 'sheep', 'snail', 'snake', 'spider', 'squirrel', 'swan', 'tiger', 'whale', 'zebra']\n\ndef imread(filename):\n \"\"\"\n Loads an image file into a (height, width, 3) uint8 ndarray.\n \"\"\"\n return np.asarray(Image.open(filename), dtype=np.uint8)\n\n\ndef resize(sketch):\n x_nonzero, y_nonzero = np.where(sketch>0)\n try:\n coord_min = min(x_nonzero.min(), y_nonzero.min())\n coord_max = max(x_nonzero.max(), y_nonzero.max())\n sketch_new = np.zeros([64, 64])\n sketch_cropped = cv2.resize(sketch[coord_min:coord_max, coord_min:coord_max], (60, 60))\n sketch_new[2:-2, 2:-2] = sketch_cropped\n except:\n sketch_new = sketch\n return sketch_new\n\ndef resize_batch(sketches):\n return np.array([resize(sketch) for sketch in sketches])\n\ndef get_acts_and_preds(files, model, batch_size=50, dims=2048,\n cuda=False, verbose=False, name='birds'):\n \"\"\"Calculates the activations of the pool_3 layer for all images.\n\n Params:\n -- files : List of image files paths\n -- model : Instance of inception model\n -- batch_size : Batch size of images for the model to process at once.\n Make sure that the number of samples is a multiple of\n the batch size, otherwise some samples are ignored. This\n behavior is retained to match the original FID score\n implementation.\n -- dims : Dimensionality of features returned by Inception\n -- cuda : If set to True, use GPU\n -- verbose : If set to True and parameter out_step is given, the number\n of calculated batches is reported.\n -- name : The name of the dataset: for birds we calculate CS only and for creatures we also calculate SDS.\n \"\"\"\n if name == 'birds':\n target_set = B_SET\n elif name == 'creatures':\n target_set = C_SET\n\n model.eval()\n\n if batch_size > len(files):\n print(('Warning: batch size is bigger than the data size. '\n 'Setting batch size to data size'))\n batch_size = len(files)\n\n pred_arr = np.empty((len(files), dims))\n preds_final_arr = {}\n logits_arr = torch.zeros(345).cuda()\n\n for i in tqdm(range(0, len(files), batch_size)):\n if verbose:\n print('\\rPropagating batch %d/%d' % (i + 1, n_batches),\n end='', flush=True)\n start = i\n end = i + batch_size\n\n images = np.array([imread(str(f)).astype(np.float32) for f in files[start:end]])\n images = images/255.\n images = 1-images\n images[images<0.1] = 0\n\n # Reshape to (n_images, 3, height, width)\n if len(images.shape) == 4:\n images = images.transpose((0, 3, 1, 2))\n elif len(images.shape) == 3:\n images = np.expand_dims(images, 1)\n\n batch = torch.from_numpy(images).type(torch.FloatTensor)\n if cuda:\n batch = batch.cuda()\n\n batch = F.interpolate(batch, size=(299, 299), mode='bilinear', align_corners=False)\n\n # store the model predictions\n logits = model.inception(batch)\n _, final_preds = torch.max(logits, 1)\n logits = F.softmax(logits, 1)\n for logit, final_pred in zip(logits, final_preds):\n logits_arr += logit\n pred_class = ID2CLASS[final_pred.item()]\n if pred_class in preds_final_arr:\n preds_final_arr[pred_class] += 1\n else:\n preds_final_arr[pred_class] = 1\n\n \n pred = model(batch)[0] \n\n # If model output is not scalar, apply global spatial average pooling.\n # This happens if you choose a dimensionality not equal 2048.\n if pred.size(2) != 1 or pred.size(3) != 1:\n pred = adaptive_avg_pool2d(pred, output_size=(1, 1))\n\n pred_arr[start:end] = pred.cpu().data.numpy().reshape(pred.size(0), -1)\n\n # calculate CS and SDS\n characteristic_count = 0.\n total_count = 0.\n for class_name in preds_final_arr:\n total_count += preds_final_arr[class_name]\n if class_name not in target_set:\n continue\n characteristic_count += preds_final_arr[class_name]\n CS = characteristic_count/total_count\n probs_all = logits_arr / total_count\n # import ipdb;ipdb.set_trace()\n if name == 'creatures':\n C_prob = sum([probs_all[cl_id].item() for cl_id in range(345) if ID2CLASS[cl_id] in C_SET])\n CCS = sum([-probs_all[cl_id].item()*np.log(probs_all[cl_id].item()/C_prob) for cl_id in range(345) if ID2CLASS[cl_id] in C_SET])\n else:\n CCS = 0.\n\n if verbose:\n print(' done')\n return pred_arr, CS, CCS\n\n\ndef calculate_frechet_distance(mu1, sigma1, mu2, sigma2, eps=1e-6):\n \"\"\"Numpy implementation of the Frechet Distance.\n The Frechet distance between two multivariate Gaussians X_1 ~ N(mu_1, C_1)\n and X_2 ~ N(mu_2, C_2) is\n d^2 = ||mu_1 - mu_2||^2 + Tr(C_1 + C_2 - 2*sqrt(C_1*C_2)).\n\n Stable version by Dougal J. Sutherland.\n\n Params:\n -- mu1 : Numpy array containing the activations of a layer of the\n inception net (like returned by the function 'get_predictions')\n for generated samples.\n -- mu2 : The sample mean over activations, precalculated on an\n representative data set.\n -- sigma1: The covariance matrix over activations for generated samples.\n -- sigma2: The covariance matrix over activations, precalculated on an\n representative data set.\n\n Returns:\n -- : The Frechet Distance.\n \"\"\"\n\n mu1 = np.atleast_1d(mu1)\n mu2 = np.atleast_1d(mu2)\n\n sigma1 = np.atleast_2d(sigma1)\n sigma2 = np.atleast_2d(sigma2)\n\n assert mu1.shape == mu2.shape, \\\n 'Training and test mean vectors have different lengths'\n assert sigma1.shape == sigma2.shape, \\\n 'Training and test covariances have different dimensions'\n\n diff = mu1 - mu2\n\n # Product might be almost singular\n covmean, _ = linalg.sqrtm(sigma1.dot(sigma2), disp=False)\n if not np.isfinite(covmean).all():\n msg = ('fid calculation produces singular product; '\n 'adding %s to diagonal of cov estimates') % eps\n print(msg)\n offset = np.eye(sigma1.shape[0]) * eps\n covmean = linalg.sqrtm((sigma1 + offset).dot(sigma2 + offset))\n\n # Numerical error might give slight imaginary component\n if np.iscomplexobj(covmean):\n if not np.allclose(np.diagonal(covmean).imag, 0, atol=1e-3):\n m = np.max(np.abs(covmean.imag))\n raise ValueError('Imaginary component {}'.format(m))\n covmean = covmean.real\n\n tr_covmean = np.trace(covmean)\n\n return (diff.dot(diff) + np.trace(sigma1) +\n np.trace(sigma2) - 2 * tr_covmean)\n\n\ndef calculate_acts_and_preds(files, model, batch_size=50,\n dims=2048, cuda=False, verbose=False, name='birds'):\n \"\"\"Calculation of the statistics used by the FID and diversity, CS, SDS.\n Params:\n -- files : List of image files paths\n -- model : Instance of inception model\n -- batch_size : The images numpy array is split into batches with\n batch size batch_size. A reasonable batch size\n depends on the hardware.\n -- dims : Dimensionality of features returned by Inception\n -- cuda : If set to True, use GPU\n -- verbose : If set to True and parameter out_step is given, the\n number of calculated batches is reported.\n Returns:\n -- mu : The mean over samples of the activations of the pool_3 layer of\n the inception model.\n -- sigma : The covariance matrix of the activations of the pool_3 layer of\n the inception model.\n -- diversity : average pairwise distances between samples.\n -- CS : characteristic score.\n -- SDS : semantic diversity score.\n \"\"\"\n assert name in ['birds', 'creatures']\n act, CS, SDS = get_acts_and_preds(files, model, batch_size, dims, cuda, verbose, name)\n mu = np.mean(act, axis=0)\n sigma = np.cov(act, rowvar=False)\n diversity = cal_diversity(act)\n # import ipdb;ipdb.set_trace()\n return mu, sigma, diversity, CS, SDS\n\n\ndef cal_diversity(act):\n n_sample = min(act.shape[0], 1000)\n act = act[:n_sample]\n n_part = n_sample*(n_sample-1)/2\n score = 0.\n for i in range(n_sample):\n for j in range(i+1, n_sample):\n score += np.sqrt(np.sum((act[i]-act[j])**2))\n return score/n_part\n\n\ndef _compute_statistics_of_path(path, model, batch_size, dims, cuda, name):\n if path.endswith('.npz'):\n f = np.load(path)\n m, s = f['mu'][:], f['sigma'][:]\n f.close()\n else:\n path = pathlib.Path(path)\n files = list(path.glob('*.jpg')) + list(path.glob('*.png'))\n m, s, diversity, CS, SDS = calculate_acts_and_preds(files, model, batch_size,\n dims, cuda, False, name)\n return m, s, diversity, CS, SDS\n\n\ndef calculate_scores_given_paths(paths, batch_size, cuda, dims, name):\n \"\"\"Calculates the FID of two paths\"\"\"\n for p in paths:\n if not os.path.exists(p):\n raise RuntimeError('Invalid path: %s' % p)\n\n block_idx = InceptionV3.BLOCK_INDEX_BY_DIM[dims]\n\n model = InceptionV3([block_idx], normalize_input=False, use_fid_inception=False)\n if cuda:\n model.cuda()\n\n m1, s1, d1, CS1, SDS1 = _compute_statistics_of_path(paths[0], model, batch_size,\n dims, cuda, name)\n m2, s2, d2, CS2, SDS2 = _compute_statistics_of_path(paths[1], model, batch_size,\n dims, cuda, name)\n # import ipdb;ipdb.set_trace()\n fid_value = calculate_frechet_distance(m1, s1, m2, s2)\n\n return fid_value, d1, d2, CS1, CS2, SDS1, SDS2\n\n\nif __name__ == '__main__':\n args = parser.parse_args()\n os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu\n\n fid_value, d1, d2, CS1, CS2, SDS1, SDS2 = calculate_scores_given_paths(args.path,\n args.batch_size,\n args.gpu != '',\n args.dims,\n args.name)\n print('FID: ', fid_value)\n if args.name == 'birds':\n print('Diversity 1: %.2f, characteristic score 1: %.2f'%(d1, CS1))\n print('Diversity 2: %.2f, characteristic score 2: %.2f'%(d2, CS2))\n elif args.name == 'creatures':\n print('Diversity 1: %.2f, characteristic score 1: %.2f, semantic diversity score 1: %.2f'%(d1, CS1, SDS1))\n print('Diversity 2: %.2f, characteristic score 2: %.2f, semantic diversity score 2: %.2f'%(d2, CS2, SDS2))\n\n", "meta": {"hexsha": "49e13a538e2d13a7533b8d19ae36fdb536da7a34", "size": 14258, "ext": "py", "lang": "Python", "max_stars_repo_path": "evaluate.py", "max_stars_repo_name": "SongweiGe/DoodlerGAN", "max_stars_repo_head_hexsha": "d435d9b3c0579937cd3c22aa2051960ceb921785", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 92, "max_stars_repo_stars_event_min_datetime": "2020-10-02T23:44:29.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-22T22:49:35.000Z", "max_issues_repo_path": "evaluate.py", "max_issues_repo_name": "SongweiGe/DoodlerGAN", "max_issues_repo_head_hexsha": "d435d9b3c0579937cd3c22aa2051960ceb921785", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2020-10-03T05:11:24.000Z", "max_issues_repo_issues_event_max_datetime": "2021-06-23T23:27:05.000Z", "max_forks_repo_path": "evaluate.py", "max_forks_repo_name": "SongweiGe/DoodlerGAN", "max_forks_repo_head_hexsha": "d435d9b3c0579937cd3c22aa2051960ceb921785", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 11, "max_forks_repo_forks_event_min_datetime": "2020-10-03T05:06:26.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-06T14:03:24.000Z", "avg_line_length": 39.0630136986, "max_line_length": 136, "alphanum_fraction": 0.6279983167, "include": true, "reason": "import numpy,from scipy", "num_tokens": 3583, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5621765008857981, "lm_q2_score": 0.3486451285660856, "lm_q1q2_score": 0.1960000984281612}} {"text": "\"\"\"\nBasic Amplitude Calculations.\nA partial wave analysis process has following structure:\n\nDecayGroup: addition (+)\n DecayChain: multiplication (x)\n Decay, Particle(Propagator)\n\n\"\"\"\n\nimport contextlib\nimport functools\nimport inspect\nimport warnings\nfrom itertools import combinations\nfrom pprint import pprint\n\nimport numpy as np\nimport sympy as sym\n\nfrom tf_pwa.breit_wigner import BW, BWR, Bprime, Bprime_q2\nfrom tf_pwa.cg import cg_coef\nfrom tf_pwa.config import get_config, regist_config, temp_config\nfrom tf_pwa.data import data_map, data_shape, split_generator\nfrom tf_pwa.dec_parser import load_dec_file\nfrom tf_pwa.dfun import get_D_matrix_lambda\nfrom tf_pwa.einsum import einsum\nfrom tf_pwa.particle import DEFAULT_DECAY, BaseParticle, Decay\nfrom tf_pwa.particle import DecayChain as BaseDecayChain\nfrom tf_pwa.particle import DecayGroup as BaseDecayGroup\nfrom tf_pwa.particle import _spin_int, _spin_range, split_particle_type\nfrom tf_pwa.tensorflow_wrapper import tf\nfrom tf_pwa.variable import Variable, VarsManager\n\n# from pysnooper import snoop\n\n\nPARTICLE_MODEL = \"particle_model\"\nregist_config(PARTICLE_MODEL, {})\nDECAY_MODEL = \"decay_model\"\nregist_config(DECAY_MODEL, {})\n\n\ndef register_particle(name=None, f=None):\n \"\"\"register a particle model\n\n :params name: model name used in configuration\n :params f: Model class\n \"\"\"\n\n def regist(g):\n if name is None:\n my_name = g.__name__\n else:\n my_name = name\n config = get_config(PARTICLE_MODEL)\n if my_name in config:\n warnings.warn(\"Override model {}\".format(my_name))\n config[my_name] = g\n g.model_name = my_name\n return g\n\n if f is None:\n return regist\n return regist(f)\n\n\ndef register_decay(name=None, num_outs=2, f=None):\n \"\"\"register a decay model\n\n :params name: model name used in configuration\n :params f: Model class\n \"\"\"\n\n def regist(g):\n if name is None:\n my_name = g.__name__\n else:\n my_name = name\n config = get_config(DECAY_MODEL)\n id_ = (num_outs, my_name)\n if id_ in config:\n warnings.warn(\"Override deccay model {}\".format(my_name))\n config[id_] = g\n g.model_name = my_name\n return g\n\n if f is None:\n return regist\n return regist(f)\n\n\nregist_particle = register_particle\nregist_decay = register_decay\n\n\ndef get_particle_model(name):\n all_model = get_config(PARTICLE_MODEL)\n return all_model.get(name, None)\n\n\ndef get_particle_model_name(p):\n all_model = get_config(PARTICLE_MODEL)\n for k, v in all_model.items():\n if type(p) is v:\n return k\n return str(type(p))\n\n\ndef get_particle(*args, model=\"default\", **kwargs):\n \"\"\"method for getting particle of model\"\"\"\n if isinstance(model, dict):\n model_class = trans_model(model)\n else:\n model_class = get_particle_model(model)\n if model_class is None:\n warnings.warn(\n \"No model named {} found, use default instead.\".format(model)\n )\n model_class = get_particle_model(\"default\")\n return model_class(*args, **kwargs)\n\n\ndef trans_model(model):\n expr = model.get(\"expr\")\n expr = sym.simplify(expr)\n var = {str(k): str(k) for k in expr.free_symbols}\n var.update(model.get(\"where\", {}))\n model_name = []\n for k, v in var.items():\n if isinstance(v, str):\n model_name.append((k, v))\n assert len(model_name) == 1\n expr = sym.simplify(expr)\n var_name, name = model_name.pop()\n expr2 = expr.subs({k: v for k, v in var.items() if k != var_name})\n assert len(expr2.free_symbols) == 1, str(expr2)\n fun = sym.lambdify((var_name,), expr2, \"tensorflow\")\n base_model = get_particle_model(name)\n\n class _TempModel(base_model):\n _from_trans = True\n\n def get_amp(self, *args, **kwargs):\n amp = super().get_amp(*args, **kwargs)\n return fun(amp)\n\n return _TempModel\n\n\ndef get_decay(core, outs, **kwargs):\n \"\"\"method for getting decay of model\"\"\"\n num_outs = len(outs)\n\n prod_params = {}\n for i in outs:\n prod_params.update(getattr(i, \"production_params\", {}))\n\n decay_params = getattr(core, \"decay_params\", {})\n\n new_kwargs = {**prod_params, **decay_params, **kwargs}\n\n model = new_kwargs.get(\"model\", \"default\")\n id_ = (num_outs, model)\n\n return get_config(DECAY_MODEL)[id_](core, outs, **new_kwargs)\n\n\ndef data_device(data):\n def get_device(dat):\n if hasattr(dat, \"device\"):\n return dat.device\n return None\n\n pprint(data_map(data, get_device))\n return data\n\n\ndef get_name(self, names):\n name = (\n (str(self) + \"_\" + names)\n .replace(\":\", \"/\")\n .replace(\"+\", \".\")\n .replace(\",\", \"\")\n .replace(\"[\", \"\")\n .replace(\"]\", \"\")\n .replace(\" \", \"\")\n )\n return name\n\n\ndef _add_var(self, names, is_complex=False, shape=(), **kwargs):\n name = get_name(self, names)\n return Variable(name, shape, is_complex, **kwargs)\n\n\nclass AmpBase(object):\n \"\"\"Base class for amplitude \"\"\"\n\n def add_var(self, names, is_complex=False, shape=(), **kwargs):\n \"\"\"\n default add_var method\n \"\"\"\n if not hasattr(self, \"_variables_map\"):\n self._variables_map = {}\n name = self.get_variable_name(names)\n var = Variable(name, shape, is_complex, **kwargs)\n self._variables_map[names] = var\n return var\n\n def get_var(self, name):\n return getattr(self, \"_variables_map\", {}).get(name)\n\n def get_variable_name(self, name=\"\"):\n return get_name(self, name)\n\n def amp_shape(self):\n raise NotImplementedError\n\n def get_factor_variable(self):\n return []\n\n\n@contextlib.contextmanager\ndef variable_scope(vm=None):\n \"\"\"variabel name scope\"\"\"\n if vm is None:\n vm = VarsManager(dtype=get_config(\"dtype\"))\n with temp_config(\"vm\", vm):\n yield vm\n\n\ndef simple_deepcopy(dic):\n if isinstance(dic, dict):\n return {k: simple_deepcopy(v) for k, v in dic.items()}\n if isinstance(dic, list):\n return [simple_deepcopy(v) for v in dic]\n if isinstance(dic, tuple):\n return tuple([simple_deepcopy(v) for v in dic])\n return dic\n\n\ndef simple_cache_fun(f):\n name = \"simple_cached_\" + f.__name__\n\n @functools.wraps(f)\n def g(self, *args, **kwargs):\n if not hasattr(self, name):\n setattr(self, name, f(self, *args, **kwargs))\n return getattr(self, name)\n\n return g\n\n\ndef get_relative_p(m_0, m_1, m_2):\n \"\"\"relative momentum for 0 -> 1 + 2\"\"\"\n M12S = m_1 + m_2\n M12D = m_1 - m_2\n if hasattr(M12S, \"dtype\"):\n m_0 = tf.convert_to_tensor(m_0, dtype=M12S.dtype)\n m_eff = tf.where(m_0 > M12S, m_0, M12S)\n p = (m_eff - M12S) * (m_eff + M12S) * (m_eff - M12D) * (m_eff + M12D)\n # if p is negative, which results from bad data, the return value is 0.0\n # print(\"p\", tf.where(p==0), m_0, m_1, m_2)\n return tf.sqrt(p) / (2 * m_eff)\n\n\ndef get_relative_p2(m_0, m_1, m_2):\n \"\"\"relative momentum for 0 -> 1 + 2\"\"\"\n M12S = m_1 + m_2\n M12D = m_1 - m_2\n if hasattr(M12S, \"dtype\"):\n m_0 = tf.convert_to_tensor(m_0, dtype=M12S.dtype)\n # m_eff = tf.where(m_0 > M12S, m_0, M12S)\n p = (m_0 - M12S) * (m_0 + M12S) * (m_0 - M12D) * (m_0 + M12D)\n # if p is negative, which results from bad data, the return value is 0.0\n # print(\"p\", tf.where(p==0), m_0, m_1, m_2)\n return p / (2 * m_0) ** 2\n\n\ndef _ad_hoc(m0, m_max, m_min):\n r\"\"\"ad-hoc formula\n\n .. math::\n m_0^{eff} = m^{min} + \\frac{m^{max} - m^{min}}{2}(1+tanh \\frac{m_0 - \\frac{m^{max} + m^{min}}{2}}{m^{max} - m^{min}})\n\n \"\"\"\n k = (m_max - m_min) / 2\n m_eff = k * (1 + tf.tanh((2 * m0 - (m_max + m_min)) / k))\n return m_eff + m_min\n\n\n@regist_particle(\"BWR\")\n@regist_particle(\"default\")\nclass Particle(BaseParticle, AmpBase):\n \"\"\"\n .. math::\n R(m) = \\\\frac{1}{m_0^2 - m^2 - i m_0 \\\\Gamma(m)}\n\n \"\"\"\n\n def __init__(self, *args, running_width=True, bw_l=None, **kwargs):\n super(Particle, self).__init__(*args, **kwargs)\n self.running_width = running_width\n self.bw_l = bw_l\n\n def init_params(self):\n self.d = 3.0\n if self.mass is None:\n self.mass = self.add_var(\"mass\", fix=True)\n # print(\"$$$$$\",self.mass)\n else:\n if not isinstance(self.mass, Variable):\n self.mass = self.add_var(\"mass\", value=self.mass, fix=True)\n if self.width is not None:\n if not isinstance(self.width, Variable):\n self.width = self.add_var(\"width\", value=self.width, fix=True)\n\n def get_amp(self, data, data_c, **kwargs):\n mass = self.get_mass()\n width = self.get_width()\n if width is None:\n return tf.ones_like(data[\"m\"])\n if not self.running_width:\n ret = BW(data[\"m\"], mass, width)\n else:\n q = data_c[\"|q|\"]\n q0 = data_c[\"|q0|\"]\n if self.bw_l is None:\n decay = self.decay[0]\n self.bw_l = min(decay.get_l_list())\n ret = BWR(data[\"m\"], mass, width, q, q0, self.bw_l, self.d)\n # ret = tf.where(q0 > 0, ret, tf.zeros_like(ret))\n # ret = tf.where(q > 0, ret, tf.zeros_like(ret))\n return ret\n\n def amp_shape(self):\n return ()\n\n def get_mass(self):\n if self.mass is None:\n warnings.warn(\n f\"The mass of {self} is None, may be you should calculate amplitude first to infer mass\"\n )\n if callable(self.mass):\n return self.mass()\n return self.mass\n\n def get_width(self):\n if callable(self.width):\n return self.width()\n return self.width\n\n\n@regist_particle(\"x\")\nclass ParticleX(BaseParticle, AmpBase):\n \"\"\"simple particle model for mass, (used in expr)\n\n .. math::\n R(m) = m\n\n \"\"\"\n\n def __call__(self, m):\n return self.get_amp({\"m\": m})\n\n def get_amp(self, data, *args, **kwargs):\n m = data[\"m\"]\n zeros = tf.zeros_like(m)\n return tf.complex(m, zeros)\n\n\nclass SimpleResonances(Particle):\n def __init__(self, *args, **kwargs):\n self.params = {}\n super(SimpleResonances, self).__init__(*args, **kwargs)\n\n def __call__(self, m, m0=None, g0=None, q=None, q0=None, **kwargs):\n raise NotImplementedError\n\n def get_amp(self, *args, **kwargs):\n m = args[0][\"m\"]\n q, q0 = None, None\n if len(args) >= 2:\n q = args[1].get(\"|q|\", 1.0)\n q0 = args[1].get(\"|q0|\", 1.0)\n m0 = self.get_mass()\n g0 = self.get_width()\n return self(m, m0=m0, g0=g0, q=q, q0=q0, **kwargs)\n\n\nclass FloatParams(float):\n pass\n\n\ndef simple_resonance(name, fun=None, params=None):\n \"\"\"convert simple fun f(m) into a resonances model\n\n :params name: model name used in configuration\n :params fun: Model function\n :params params: arguments name list for parameters\n\n \"\"\"\n\n if params is None:\n params = {}\n\n def _wrapper(f):\n argspec = inspect.getfullargspec(f)\n args = argspec.args\n if argspec.defaults is None:\n defaults = {}\n else:\n defaults = dict(zip(argspec.args[::-1], argspec.defaults[::-1]))\n\n @register_particle(name)\n class _R(SimpleResonances):\n def init_params(self):\n if \"m0\" in argspec.args and \"g0\" in argspec.args:\n super(_R, self).init_params()\n self.params = {}\n for i in argspec.args:\n tp = argspec.annotations.get(i, None)\n if i in params or tp is FloatParams:\n val = getattr(self, i, defaults.get(i, None))\n if val is None:\n self.params[i] = self.add_var(i)\n else:\n self.params[i] = self.add_var(\n i, value=val, fix=True\n )\n\n def __call__(self, m, **kwargs):\n my_kwargs = {}\n for i in argspec.args:\n if i in kwargs:\n my_kwargs[i] = kwargs[i]\n elif i in self.params:\n my_kwargs[i] = self.params[i]()\n elif hasattr(self, i):\n my_kwargs[i] = getattr(self, i)\n ret = f(m, **my_kwargs)\n return tf.cast(ret, tf.complex128)\n\n __call__.__doc__ = f.__doc__\n\n _R.get_amp.__doc__ = f.__doc__\n return _R\n\n if fun is None:\n return _wrapper\n return _wrapper(fun)\n\n\nclass AmpDecay(Decay, AmpBase):\n \"\"\"base class for decay with amplitude\"\"\"\n\n def amp_shape(self):\n ret = [len(self.core.spins)]\n for i in self.outs:\n ret.append(len(i.spins))\n return tuple(ret)\n\n # @simple_cache_fun\n def amp_index(self, base_map):\n ret = [base_map[self.core]]\n for i in self.outs:\n ret.append(base_map[i])\n return ret\n\n\n@regist_decay(\"default\")\n@regist_decay(\"gls-bf\")\nclass HelicityDecay(AmpDecay):\n \"\"\"default decay model\"\"\"\n\n def __init__(\n self,\n *args,\n has_barrier_factor=True,\n l_list=None,\n barrier_factor_mass=False,\n has_bprime=True,\n aligned=False,\n allow_cc=True,\n ls_list=None,\n barrier_factor_norm=False,\n params_polar=None,\n **kwargs\n ):\n super(HelicityDecay, self).__init__(*args, **kwargs)\n self.has_barrier_factor = has_barrier_factor\n self.l_list = l_list\n self.barrier_factor_mass = barrier_factor_mass\n self.has_bprime = has_bprime\n self.aligned = aligned\n self.allow_cc = allow_cc\n self.single_gls = False\n self.ls_index = None\n self.total_ls = None\n self.barrier_factor_norm = barrier_factor_norm\n self.ls_list = None\n if ls_list is not None:\n self.ls_list = tuple([tuple(i) for i in ls_list])\n self.params_polar = params_polar\n\n def check_valid_jp(self):\n if len(self.get_ls_list()) == 0:\n if not self.p_break:\n raise ValueError(\n \"\"\"invalid spin parity for {}, maybe you should set `p_break: True` for weak decay\"\"\".format(\n self\n )\n )\n raise ValueError(\"invalid spin parity for {}\".format(self))\n\n def set_ls(self, ls):\n if self.total_ls is None:\n self.total_ls = self.get_ls_list()\n self.ls_list = tuple([tuple(i) for i in ls])\n self.single_gls = len(ls) == 1\n # print(self, \"total_ls: \", self.total_ls)\n total_ls = self.total_ls\n if len(total_ls) == len(ls):\n self.ls_index = None\n return\n self.ls_index = []\n for i in self.ls_list:\n self.ls_index.append(total_ls.index(i))\n\n def init_params(self):\n self.d = 3.0\n ls = self.get_ls_list()\n self.g_ls = self.add_var(\n \"g_ls\", is_complex=True, polar=self.params_polar, shape=(len(ls),)\n )\n try:\n self.g_ls.set_fix_idx(fix_idx=0, fix_vals=(1.0, 0.0))\n except Exception as e:\n print(e, self, self.get_ls_list())\n\n def get_factor_variable(self):\n return [(self.g_ls,)]\n\n def _get_particle_mass(self, p, data, from_data=False):\n if from_data:\n return data[p][\"m\"]\n if p.mass is None:\n p.mass = tf.reduce_mean(data[p][\"m\"])\n return p.get_mass()\n\n def get_relative_momentum(self, data, from_data=False):\n \"\"\"\"\"\"\n\n _get_mass = lambda p: self._get_particle_mass(p, data, from_data)\n\n m0 = _get_mass(self.core)\n m1 = _get_mass(self.outs[0])\n m2 = _get_mass(self.outs[1])\n return get_relative_p(m0, m1, m2)\n\n def get_relative_momentum2(self, data, from_data=False):\n \"\"\"\"\"\"\n\n _get_mass = lambda p: self._get_particle_mass(p, data, from_data)\n\n m0 = _get_mass(self.core)\n m1 = _get_mass(self.outs[0])\n m2 = _get_mass(self.outs[1])\n return get_relative_p2(m0, m1, m2)\n\n def get_cg_matrix(self):\n ls = self.get_ls_list()\n return self._get_cg_matrix(ls)\n\n @functools.lru_cache()\n def _get_cg_matrix(self, ls): # CG factor inside H\n \"\"\"\n [(l,s),(lambda_b,lambda_c)]\n\n .. math::\n \\\\sqrt{\\\\frac{ 2 l + 1 }{ 2 j_a + 1 }}\n \\\\langle j_b, j_c, \\\\lambda_b, - \\\\lambda_c | s, \\\\lambda_b - \\\\lambda_c \\\\rangle\n \\\\langle l, s, 0, \\\\lambda_b - \\\\lambda_c | j_a, \\\\lambda_b - \\\\lambda_c \\\\rangle\n \"\"\"\n m = len(ls)\n ja = self.core.J\n jb = self.outs[0].J\n jc = self.outs[1].J\n n = _spin_int(2 * jb + 1), _spin_int(2 * jc + 1)\n ret = np.zeros(shape=(m, *n))\n for i, ls_i in enumerate(ls):\n l, s = ls_i\n for i1, lambda_b in enumerate(_spin_range(-jb, jb)):\n for i2, lambda_c in enumerate(_spin_range(-jc, jc)):\n ret[i][i1][i2] = (\n np.sqrt((2 * l + 1) / (2 * ja + 1))\n * cg_coef(\n jb, jc, lambda_b, -lambda_c, s, lambda_b - lambda_c\n )\n * cg_coef(\n l,\n s,\n 0,\n lambda_b - lambda_c,\n ja,\n lambda_b - lambda_c,\n )\n )\n return tf.convert_to_tensor(ret)\n\n def get_helicity_amp(self, data, data_p, **kwargs):\n m_dep = self.get_ls_amp(data, data_p, **kwargs)\n cg_trans = tf.cast(self.get_cg_matrix(), m_dep.dtype)\n n_ls = len(self.get_ls_list())\n m_dep = tf.reshape(m_dep, (-1, n_ls, 1, 1))\n cg_trans = tf.reshape(\n cg_trans, (n_ls, len(self.outs[0].spins), len(self.outs[1].spins))\n )\n H = tf.reduce_sum(m_dep * cg_trans, axis=1)\n # print(n_ls, cg_trans, self, m_dep.shape) # )data_p)\n if self.allow_cc:\n all_data = kwargs.get(\"all_data\", {})\n charge = all_data.get(\"charge_conjugation\", None)\n if charge is not None:\n H = tf.where(\n charge[..., None, None] > 0, H, H[..., ::-1, ::-1]\n )\n ret = tf.reshape(\n H, (-1, 1, len(self.outs[0].spins), len(self.outs[1].spins))\n )\n return ret\n\n def get_angle_helicity_amp(self, data, data_p, **kwargs):\n m_dep = self.get_angle_ls_amp(data, data_p, **kwargs)\n cg_trans = tf.cast(self.get_cg_matrix(), m_dep.dtype)\n n_ls = len(self.get_ls_list())\n m_dep = tf.reshape(m_dep, (-1, n_ls, 1, 1))\n cg_trans = tf.reshape(\n cg_trans, (n_ls, len(self.outs[0].spins), len(self.outs[1].spins))\n )\n H = tf.reduce_sum(m_dep * cg_trans, axis=1)\n # print(n_ls, cg_trans, self, m_dep.shape) # )data_p)\n if self.allow_cc:\n all_data = kwargs.get(\"all_data\", {})\n charge = all_data.get(\"charge_conjugation\", None)\n if charge is not None:\n H = tf.where(\n charge[..., None, None] > 0, H, H[..., ::-1, ::-1]\n )\n ret = tf.reshape(\n H, (-1, 1, len(self.outs[0].spins), len(self.outs[1].spins))\n )\n return ret\n\n def get_g_ls(self):\n gls = self.g_ls()\n if self.ls_index is None:\n return tf.stack(gls)\n # print(self, gls, self.ls_index)\n return tf.stack([gls[k] for k in self.ls_index])\n\n def get_ls_amp_org(self, data, data_p, **kwargs):\n g_ls = self.get_g_ls()\n # print(g_ls)\n q0 = self.get_relative_momentum(data_p, False)\n data[\"|q0|\"] = q0\n if \"|q|\" in data:\n q = data[\"|q|\"]\n else:\n q = self.get_relative_momentum(data_p, True)\n data[\"|q|\"] = q\n if self.has_barrier_factor:\n bf = self.get_barrier_factor(data_p[self.core][\"m\"], q, q0, self.d)\n mag = g_ls\n m_dep = mag * tf.cast(bf, mag.dtype)\n else:\n m_dep = g_ls\n return m_dep\n\n def get_ls_amp(self, data, data_p, **kwargs):\n g_ls = self.get_g_ls()\n # print(g_ls)\n q0 = self.get_relative_momentum2(data_p, False)\n data[\"|q0|2\"] = q0\n if \"|q|2\" in data:\n q = data[\"|q|2\"]\n else:\n q = self.get_relative_momentum2(data_p, True)\n data[\"|q|2\"] = q\n if self.has_barrier_factor:\n bf = self.get_barrier_factor2(\n data_p[self.core][\"m\"], q, q0, self.d\n )\n mag = g_ls\n m_dep = mag * tf.cast(bf, mag.dtype)\n else:\n m_dep = g_ls\n return m_dep\n\n def get_angle_g_ls(self):\n gls = [complex(1.0, 0.0) for i in self.g_ls()]\n if self.ls_index is None:\n return tf.stack(gls)\n return tf.stack([gls[k] for k in self.ls_index])\n\n def get_angle_ls_amp(self, data, data_p, **kwargs):\n g_ls = self.get_angle_g_ls()\n return g_ls\n\n def get_barrier_factor(self, mass, q, q0, d):\n ls = self.get_l_list()\n ret = []\n for l in ls:\n if self.has_bprime:\n tmp = q ** l * tf.cast(Bprime(l, q, q0, d), dtype=q.dtype)\n else:\n tmp = q ** l\n # tmp = tf.where(q > 0, tmp, tf.zeros_like(tmp))\n ret.append(tf.reshape(tmp, (-1, 1)))\n ret = tf.concat(ret, axis=-1)\n mass_dep = self.get_barrier_factor_mass(mass)\n return ret * mass_dep\n\n def get_barrier_factor2(self, mass, q2, q02, d):\n ls = self.get_l_list()\n ret = []\n for l in ls:\n if self.has_bprime:\n bp = Bprime_q2(l, q2, q02, d)\n tmp = q2 ** (l / 2) * tf.cast(bp, dtype=q2.dtype)\n if self.barrier_factor_norm:\n tmp = tmp / q02 ** (l / 2)\n else:\n tmp = q2 ** (l / 2)\n # tmp = tf.where(q > 0, tmp, tf.zeros_like(tmp))\n ret.append(tf.reshape(tmp, (-1, 1)))\n ret = tf.concat(ret, axis=-1)\n mass_dep = self.get_barrier_factor_mass(mass)\n return ret * mass_dep\n\n def get_barrier_factor_mass(self, mass):\n if not self.barrier_factor_mass:\n return 1.0\n ls = tf.convert_to_tensor(self.get_l_list(), dtype=mass.dtype)\n m_dep = 1.0 / tf.pow(tf.expand_dims(mass, -1), ls)\n return m_dep\n\n def get_amp(self, data, data_p, **kwargs):\n a = self.core\n b = self.outs[0]\n c = self.outs[1]\n ang = data[b][\"ang\"]\n D_conj = get_D_matrix_lambda(ang, a.J, a.spins, b.spins, c.spins)\n H = self.get_helicity_amp(data, data_p, **kwargs)\n H = tf.reshape(\n H, (-1, 1, len(self.outs[0].spins), len(self.outs[1].spins))\n )\n H = tf.cast(H, dtype=D_conj.dtype)\n ret = H * tf.stop_gradient(D_conj)\n # print(self, H, D_conj)\n # exit()\n if self.aligned:\n for j, particle in enumerate(self.outs):\n if particle.J != 0 and \"aligned_angle\" in data[particle]:\n ang = data[particle].get(\"aligned_angle\", None)\n if ang is None:\n continue\n dt = get_D_matrix_lambda(\n ang, particle.J, particle.spins, particle.spins\n )\n dt_shape = [-1, 1, 1, 1, 1]\n dt_shape[j + 2] = len(particle.spins)\n dt_shape[j + 3] = len(particle.spins)\n dt = tf.reshape(dt, dt_shape)\n D_shape = [-1, len(a.spins), len(b.spins), len(c.spins)]\n D_shape.insert(j + 3, 2)\n D_shape[j + 3] = 1\n ret = tf.reshape(ret, D_shape)\n ret = dt * ret\n ret = tf.reduce_sum(ret, axis=j + 2)\n return ret\n\n def get_angle_amp(self, data, data_p, **kwargs):\n a = self.core\n b = self.outs[0]\n c = self.outs[1]\n ang = data[b][\"ang\"]\n D_conj = get_D_matrix_lambda(ang, a.J, a.spins, b.spins, c.spins)\n H = self.get_angle_helicity_amp(data, data_p, **kwargs)\n H = tf.reshape(\n H, (-1, 1, len(self.outs[0].spins), len(self.outs[1].spins))\n )\n H = tf.cast(H, dtype=D_conj.dtype)\n ret = H * tf.stop_gradient(D_conj)\n # print(self, H, D_conj)\n # exit()\n if self.aligned:\n for j, particle in enumerate(self.outs):\n if particle.J != 0 and \"aligned_angle\" in data[particle]:\n ang = data[particle].get(\"aligned_angle\", None)\n if ang is None:\n continue\n dt = get_D_matrix_lambda(\n ang, particle.J, particle.spins, particle.spins\n )\n dt_shape = [-1, 1, 1, 1, 1]\n dt_shape[j + 2] = len(particle.spins)\n dt_shape[j + 3] = len(particle.spins)\n dt = tf.reshape(dt, dt_shape)\n D_shape = [-1, len(a.spins), len(b.spins), len(c.spins)]\n D_shape.insert(j + 3, 2)\n D_shape[j + 3] = 1\n ret = tf.reshape(ret, D_shape)\n ret = dt * ret\n ret = tf.reduce_sum(ret, axis=j + 2)\n return ret\n\n def get_m_dep(self, data, data_p, **kwargs):\n return self.get_ls_amp(data, data_p, **kwargs)\n\n def get_ls_list(self):\n \"\"\"get possible ls for decay, with l_list filter possible l\"\"\"\n ls_list = super(HelicityDecay, self).get_ls_list()\n if self.ls_list is not None:\n return self.ls_list\n if self.l_list is None:\n return ls_list\n ret = []\n for l, s in ls_list:\n if l in self.l_list:\n ret.append((l, s))\n return tuple(ret)\n\n\n@regist_decay(\"default\", 3)\n@regist_decay(\"AngSam3\", 3)\nclass AngSam3Decay(AmpDecay, AmpBase):\n def init_params(self):\n a = self.core.J\n self.gi = self.add_var(\n \"G_mu\", is_complex=True, shape=(_spin_int(2 * a + 1),)\n )\n try:\n self.gi.set_fix_idx(fix_idx=0, fix_vals=(1.0, 0.0))\n except Exception as e:\n print(e)\n\n def get_amp(self, data, data_extra=None, **kwargs):\n a = self.core\n b = self.outs[0]\n c = self.outs[1]\n d = self.outs[2]\n gi = tf.stack(self.gi())\n ang = data[\"ang\"]\n D_conj = get_D_matrix_lambda(\n ang, a.J, a.spins, tuple(_spin_range(-a.J, a.J))\n )\n ret = tf.cast(gi, D_conj.dtype) * D_conj\n ret = tf.reduce_sum(ret, axis=-1)\n ret = tf.reshape(ret, (-1, len(a.spins), 1, 1, 1))\n ret = tf.tile(ret, [1, 1, len(b.spins), len(c.spins), len(d.spins)])\n return ret\n\n\nclass DecayChain(BaseDecayChain, AmpBase):\n \"\"\"A list of Decay as a chain decay\"\"\"\n\n def __init__(self, *args, is_cp=False, **kwargs):\n self.is_cp = is_cp\n super(DecayChain, self).__init__(*args, **kwargs)\n self.aligned = True\n self.need_amp_particle = True\n\n def init_params(self, name=\"\"):\n self.total = self.add_var(\n name + \"total\", is_complex=True, is_cp=self.is_cp, shape=[1]\n )\n # self.total = self.add_var(name + \"total\", is_complex=True, shape=[1])\n\n def get_factor_variable(self):\n a = []\n for i in self:\n tmp = i.get_factor_variable()\n if tmp:\n a.append(tmp)\n for j in self.inner:\n tmp = j.get_factor_variable()\n if tmp:\n a.append(tmp)\n return [tuple([self.total] + a)]\n\n def get_amp_total(self, charge=1):\n return tf.stack(self.total(charge))\n\n def product_gls(self):\n ret = self.get_all_factor()\n return tf.reduce_prod(ret)\n\n def get_all_factor(self):\n ret = [self.get_amp_total()]\n for i in self:\n ret.append(i.get_g_ls())\n return ret\n\n def get_cp_amp_total(self, charge=1):\n if not self.is_cp:\n return self.get_amp_total()\n total_pos = self.get_amp_total(1)\n total_neg = self.get_amp_total(-1)\n # print(\"total_pos\", total_pos)\n # print(\"total_neg\", total_neg)\n charge_cond = charge > 0\n # print(\"charge\", charge)\n total = tf.where(charge_cond, total_pos, total_neg)\n return total\n\n def get_amp(self, data_c, data_p, all_data=None, base_map=None):\n base_map = self.get_base_map(base_map)\n iter_idx = [\"...\"]\n amp_d = []\n indices = []\n final_indices = \"\".join(iter_idx + self.amp_index(base_map))\n for i in self:\n indices.append(i.amp_index(base_map))\n amp_d.append(i.get_amp(data_c[i], data_p, all_data=all_data))\n\n if self.need_amp_particle:\n rs = self.get_amp_particle(data_p, data_c, all_data=all_data)\n\n total = self.get_cp_amp_total(\n charge=all_data.get(\"charge_conjugation\", 1)\n )\n if rs is not None:\n total = total * tf.cast(rs, total.dtype)\n # print(total)*self.get_amp_total()\n amp_d.append(total)\n indices.append([])\n\n if self.aligned:\n for i in self:\n for j in i.outs:\n if j.J != 0 and \"aligned_angle\" in data_c[i][j]:\n ang = data_c[i][j][\"aligned_angle\"]\n dt = get_D_matrix_lambda(ang, j.J, j.spins, j.spins)\n amp_d.append(tf.stop_gradient(dt))\n idx = [base_map[j], base_map[j].upper()]\n indices.append(idx)\n final_indices = final_indices.replace(*idx)\n idxs = []\n for i in indices:\n tmp = \"\".join(iter_idx + i)\n idxs.append(tmp)\n idx = \",\".join(idxs)\n idx_s = \"{}->{}\".format(idx, final_indices)\n # ret = amp * tf.reshape(rs, [-1] + [1] * len(self.amp_shape()))\n # print(idx_s)#, amp_d)\n try:\n ret = einsum(idx_s, *amp_d)\n except:\n ret = tf.einsum(idx_s, *amp_d)\n # print(self, ret[0])\n # exit()\n # ret = einsum(idx_s, *amp_d)\n return ret\n\n def get_angle_amp(self, data_c, data_p, all_data=None, base_map=None):\n base_map = self.get_base_map(base_map)\n iter_idx = [\"...\"]\n amp_d = []\n indices = []\n final_indices = \"\".join(iter_idx + self.amp_index(base_map))\n for i in self:\n indices.append(i.amp_index(base_map))\n amp_d.append(i.get_angle_amp(data_c[i], data_p, all_data=all_data))\n\n if self.aligned:\n for i in self:\n for j in i.outs:\n if j.J != 0 and \"aligned_angle\" in data_c[i][j]:\n ang = data_c[i][j][\"aligned_angle\"]\n dt = get_D_matrix_lambda(ang, j.J, j.spins, j.spins)\n amp_d.append(tf.stop_gradient(dt))\n idx = [base_map[j], base_map[j].upper()]\n indices.append(idx)\n final_indices = final_indices.replace(*idx)\n idxs = []\n for i in indices:\n tmp = \"\".join(iter_idx + i)\n idxs.append(tmp)\n idx = \",\".join(idxs)\n idx_s = \"{}->{}\".format(idx, final_indices)\n # ret = amp * tf.reshape(rs, [-1] + [1] * len(self.amp_shape()))\n # print(idx_s)#, amp_d)\n try:\n ret = einsum(idx_s, *amp_d)\n except:\n ret = tf.einsum(idx_s, *amp_d)\n # print(self, ret[0])\n # exit()\n # ret = einsum(idx_s, *amp_d)\n return ret\n\n def get_m_dep(self, data_c, data_p, all_data=None, base_map=None):\n base_map = self.get_base_map(base_map)\n iter_idx = [\"...\"]\n amp_d = []\n indices = []\n final_indices = \"\".join(iter_idx + self.amp_index(base_map))\n for i in self:\n indices.append(i.amp_index(base_map))\n amp_d.append(i.get_m_dep(data_c[i], data_p, all_data=all_data))\n\n if self.need_amp_particle:\n rs = self.get_amp_particle(data_p, data_c, all_data=all_data)\n total = self.get_cp_amp_total(\n all_data.get(\"charge_conjugation\", 1)\n )\n # print(\"total_pos\", total_pos)\n # print(\"total_neg\", total_neg)\n if rs is not None:\n total = total * tf.cast(rs, total.dtype)\n # print(\"charge\", charge)\n # print(total)\n # print(total)*self.get_amp_total()\n amp_d.append(total)\n return amp_d\n\n def get_amp_particle(self, data_p, data_c, all_data=None):\n amp_p = []\n if not self.inner:\n return 1.0\n for i in self.inner:\n if len(i.decay) >= 1:\n decay_i = i.decay[0]\n found = False\n for j in i.decay:\n if j in self:\n decay_i = j\n found = True\n break\n if not found:\n raise IndexError(\n \"not found {} decay in {}\".format(i, self)\n )\n data_c_i = data_c[decay_i]\n if \"|q|\" not in data_c_i:\n data_c_i[\"|q|\"] = decay_i.get_relative_momentum(\n data_p, True\n )\n if \"|q0|\" not in data_c_i:\n data_c_i[\"|q0|\"] = decay_i.get_relative_momentum(\n data_p, False\n )\n if \"|q|2\" not in data_c_i:\n data_c_i[\"|q|2\"] = decay_i.get_relative_momentum2(\n data_p, True\n )\n if \"|q0|2\" not in data_c_i:\n data_c_i[\"|q0|2\"] = decay_i.get_relative_momentum2(\n data_p, False\n )\n amp_p.append(i.get_amp(data_p[i], data_c_i, all_data=all_data))\n else:\n amp_p.append(i.get_amp(data_p[i], all_data=all_data))\n rs = 1.0\n for i in amp_p:\n rs = rs * i\n # tf.reduce_prod(amp_p, axis=0)\n return rs\n\n def amp_shape(self):\n ret = [len(self.top.spins)]\n for i in self.outs:\n ret.append(len(i.spins))\n return tuple(ret)\n\n # @simple_cache_fun\n def amp_index(self, base_map=None):\n if base_map is None:\n base_map = self.get_base_map()\n ret = [base_map[self.top]]\n for i in self.outs:\n ret.append(base_map[i])\n return ret\n\n def get_base_map(self, base_map=None):\n gen = index_generator(base_map)\n if base_map is None:\n base_map = {}\n ret = base_map.copy()\n if self.top not in base_map:\n ret[self.top] = next(gen)\n for i in self.outs:\n if i not in base_map:\n ret[i] = next(gen)\n for i in self.inner:\n if i not in ret:\n ret[i] = next(gen)\n return ret\n\n\nclass DecayGroup(BaseDecayGroup, AmpBase):\n \"\"\" A Group of Decay Chains with the same final particles.\"\"\"\n\n def __init__(self, chains):\n self.chains_idx = list(range(len(chains)))\n first_chain = chains[0]\n if not isinstance(first_chain, DecayChain):\n chains = [DecayChain(i) for i in chains]\n super(DecayGroup, self).__init__(chains)\n self.not_full = False\n self.polarization = getattr(self.top, \"polarization\", \"none\")\n # self.init_params()\n\n def init_params(self, name=\"\"):\n for i in self.resonances:\n i.init_params()\n inited_set = set()\n for i in self:\n i.init_params(name)\n for j in i:\n if j not in inited_set:\n j.init_params()\n inited_set.add(j)\n if self.polarization == \"vector\":\n print(\"add polarization vector\")\n if self.top.J == 0.5:\n self.polarization_vector = [\n self.top.add_var(\"polarization_px\"),\n self.top.add_var(\"polarization_py\"),\n self.top.add_var(\"polarization_pz\"),\n ]\n\n def get_factor_variable(self):\n ret = []\n for i in self:\n ret += i.get_factor_variable()\n return ret\n\n def get_amp(self, data):\n \"\"\"\n calculate the amplitude as complex number\n \"\"\"\n data_particle = data[\"particle\"]\n data_decay = data[\"decay\"]\n\n used_chains = tuple([self.chains[i] for i in self.chains_idx])\n chain_maps = self.get_chains_map(used_chains)\n base_map = self.get_base_map()\n ret = []\n for chains in chain_maps:\n for decay_chain in chains:\n chain_topo = decay_chain.standard_topology()\n found = False\n for i in data_decay.keys():\n if i == chain_topo:\n data_decay_i = data_decay[i]\n found = True\n break\n if not found:\n raise KeyError(\"not found {}\".format(chain_topo))\n data_c = rename_data_dict(data_decay_i, chains[decay_chain])\n data_p = rename_data_dict(data_particle, chains[decay_chain])\n # print(\"$$$$$\",data_c)\n # print(\"$$$$$\",data_p)\n amp = decay_chain.get_amp(\n data_c, data_p, base_map=base_map, all_data=data\n )\n ret.append(amp)\n # print(decay_chain, amp[:10])\n ret = tf.reduce_sum(ret, axis=0)\n return ret\n\n def get_m_dep(self, data):\n \"\"\"get mass dependent items\"\"\"\n data_particle = data[\"particle\"]\n data_decay = data[\"decay\"]\n\n used_chains = tuple([self.chains[i] for i in self.chains_idx])\n chain_maps = self.get_chains_map(used_chains)\n base_map = self.get_base_map()\n ret = []\n for decay_chain in used_chains:\n for chains in chain_maps:\n if str(decay_chain) in [str(i) for i in chains]:\n maps = chains[decay_chain]\n break\n chain_topo = decay_chain.standard_topology()\n found = False\n for i in data_decay.keys():\n if i == chain_topo:\n data_decay_i = data_decay[i]\n found = True\n break\n if not found:\n raise KeyError(\"not found {}\".format(chain_topo))\n data_c = rename_data_dict(data_decay_i, maps)\n data_p = rename_data_dict(data_particle, maps)\n # print(\"$$$$$\",data_c)\n # print(\"$$$$$\",data_p)\n amp = decay_chain.get_m_dep(\n data_c, data_p, base_map=base_map, all_data=data\n )\n ret.append(amp)\n # ret = tf.reduce_sum(ret, axis=0)\n return ret\n\n def get_angle_amp(self, data):\n data_particle = data[\"particle\"]\n data_decay = data[\"decay\"]\n\n used_chains = tuple([self.chains[i] for i in self.chains_idx])\n chain_maps = self.get_chains_map(used_chains)\n base_map = self.get_base_map()\n ret = []\n for decay_chain in used_chains:\n for chains in chain_maps:\n if str(decay_chain) in [str(i) for i in chains]:\n maps = chains[decay_chain]\n break\n chain_topo = decay_chain.standard_topology()\n found = False\n for i in data_decay.keys():\n if i == chain_topo:\n data_decay_i = data_decay[i]\n found = True\n break\n if not found:\n raise KeyError(\"not found {}\".format(chain_topo))\n data_c = rename_data_dict(data_decay_i, maps)\n data_p = rename_data_dict(data_particle, maps)\n amp = decay_chain.get_angle_amp(\n data_c, data_p, base_map=base_map, all_data=data\n )\n ret.append(amp)\n # ret = tf.reduce_sum(ret, axis=0)\n return amp\n\n @functools.lru_cache()\n def get_swap_factor(self, key):\n factor = 1.0\n for i, j in zip(self.identical_particles, key[1]):\n p = self.get_particle(i[0])\n if int(p.J * 2) % 2 == 0:\n continue\n for m, n in zip(i, j):\n if m != n:\n factor *= -1.0\n return factor\n\n def get_amp2(self, data):\n amp = self.get_amp(data)\n id_swap = data.get(\"id_swap\", {})\n for k, v in id_swap.items():\n new_data = {**data, **v}\n factor = self.get_swap_factor(k)\n amp_swap = factor * self.get_amp(new_data)\n # print(k, amp, amp_swap)\n amp = amp + amp_swap\n return amp\n\n def sum_amp(self, data, cached=True):\n \"\"\"\n calculat the amplitude modular square\n \"\"\"\n if not cached:\n data = simple_deepcopy(data)\n if self.polarization != \"none\":\n return self.sum_amp_polarization(data)\n amp = self.get_amp2(data)\n amp2s = tf.math.real(amp * tf.math.conj(amp))\n idx = list(range(1, len(amp2s.shape)))\n sum_A = tf.reduce_sum(amp2s, idx)\n return sum_A\n\n def sum_amp_polarization(self, data):\n \"\"\"\n sum amplitude suqare with density _get_cg_matrix\n\n .. math::\n P = \\\\sum_{m, m', \\\\cdots } A_{m, \\\\cdots} \\\\rho_{m, m'} A^{*}_{m', \\\\cdots}\n\n \"\"\"\n\n amp = self.get_amp(data)\n amp = tf.reshape(\n amp, (amp.shape[0], amp.shape[1], -1)\n ) # (i, la, lb lc ld ...)\n na, nl = amp.shape[1], amp.shape[2]\n rho = self.get_density_matrix()\n amp = tf.reshape(amp, (-1, na, 1, nl))\n amp_c = tf.reshape(\n tf.math.conj(amp), (-1, na, nl)\n ) # (i, la, lb lc ld ...)\n sum_A = (\n tf.reduce_sum(amp * tf.reshape(rho, (na, na, 1)), axis=1) * amp_c\n )\n return tf.reduce_sum(tf.math.real(sum_A), axis=[1, 2])\n\n def get_density_matrix(self):\n if self.polarization == \"vector\":\n px, py, pz = [i() for i in self.polarization_vector]\n zeros = tf.zeros_like(px)\n ones = tf.ones_like(px)\n rho00 = tf.complex(ones + pz, zeros)\n rho11 = tf.complex(ones - pz, zeros)\n rho01 = tf.complex(px, -py)\n rho10 = tf.complex(px, py)\n ret = 0.5 * tf.stack([[rho00, rho01], [rho10, rho11]])\n # print(ret)\n return ret\n raise NotImplementedError\n\n # @simple_cache_fun\n def amp_index(self, gen=None, base_map=None):\n if base_map is None:\n base_map = self.get_base_map()\n ret = [base_map[self.top]]\n for i in self.outs:\n ret.append(base_map[i])\n return ret\n\n def get_base_map(self, gen=None, base_map=None):\n if gen is None:\n gen = index_generator(base_map)\n if base_map is None:\n base_map = {self.top: next(gen)}\n for i in self.outs:\n base_map[i] = next(gen)\n return base_map\n\n def get_res_map(self):\n res_map = {}\n for i, decay in enumerate(self.chains):\n for j in decay.inner:\n if j not in res_map:\n res_map[j] = []\n res_map[j].append(i)\n return res_map\n\n def set_used_res(self, res, only=False):\n res_set = set()\n for i in res:\n if isinstance(i, str):\n res_set.add(BaseParticle(i))\n elif isinstance(i, BaseParticle):\n res_set.add(i)\n else:\n raise TypeError(\n \"type({}) = {} not a Particle\".format(i, type(i))\n )\n if not only:\n used_res = set()\n for i in res_set:\n for j, c in enumerate(self.chains):\n if i in c.inner:\n used_res.add(j)\n self.set_used_chains(list(used_res))\n else:\n unused_res = set(self.resonances) - res_set\n unused_decay = set()\n res_map = self.get_res_map()\n for i in unused_res:\n for j in res_map[i]:\n unused_decay.add(j)\n used_decay = []\n for i, _ in enumerate(self.chains):\n if i not in unused_decay:\n used_decay.append(i)\n self.set_used_chains(used_decay)\n\n def set_used_chains(self, used_chains):\n self.chains_idx = list(used_chains)\n if len(self.chains_idx) != len(self.chains):\n self.not_full = True\n\n def partial_weight(self, data, combine=None):\n chains = list(self.chains)\n if combine is None:\n combine = [[i] for i in range(len(chains))]\n o_used_chains = self.chains_idx\n weights = []\n for i in combine:\n self.set_used_chains(i)\n weight = self.sum_amp(data)\n weights.append(weight)\n self.set_used_chains(o_used_chains)\n return weights\n\n def chains_particle(self):\n ret = []\n for i in self:\n ret.append(tuple(i.inner))\n return ret\n\n def partial_weight_interference(self, data):\n chains = list(self.chains)\n combine = combinations(range(len(chains)), 2)\n o_used_chains = self.chains_idx\n weights = {}\n for i in combine:\n self.set_used_chains(i)\n weight = self.sum_amp(data)\n weights[i] = weight\n self.set_used_chains(o_used_chains)\n return weights\n\n def generate_phasespace(self, num=100000):\n def get_mass(i):\n mass = i.get_mass()\n if mass is None:\n raise Exception(\"mass is required for particle {}\".format(i))\n return mass\n\n top_mass = get_mass(self.top)\n final_mass = [get_mass(i) for i in self.outs]\n from tf_pwa.phasespace import PhaseSpaceGenerator\n\n a = PhaseSpaceGenerator(top_mass, final_mass)\n data = a.generate(num)\n return dict(zip(self.outs, data))\n\n\ndef index_generator(base_map=None):\n indices = \"abcdefghjklmnopqrstuvwxyz\"\n if base_map is not None:\n for i in base_map:\n indices = indices.replace(base_map[i], \"\")\n for i in indices:\n yield i\n\n\ndef rename_data_dict(data, idx_map):\n if isinstance(data, dict):\n return {\n idx_map.get(k, k): rename_data_dict(v, idx_map)\n for k, v in data.items()\n }\n if isinstance(data, tuple):\n return tuple([rename_data_dict(i, idx_map) for i in data])\n if isinstance(data, list):\n return [rename_data_dict(i, idx_map) for i in data]\n return data\n\n\ndef value_and_grad(f, var):\n with tf.GradientTape() as tape:\n s = f(var)\n g = tape.gradient(s, var)\n return s, g\n\n\nclass AmplitudeModel(object):\n def __init__(\n self, decay_group, name=\"\", polar=None, vm=None, use_tf_function=False\n ):\n self.decay_group = decay_group\n self._name = name\n with variable_scope(vm) as vm:\n if polar is not None:\n vm.polar = polar\n decay_group.init_params(name)\n self.vm = vm\n res = decay_group.resonances\n self.used_res = res\n self.res = res\n self.f_data = []\n if use_tf_function:\n self.cached_fun = tf.function(\n self.decay_group.sum_amp, experimental_relax_shapes=True\n )\n else:\n self.cached_fun = self.decay_group.sum_amp\n\n def __del__(self):\n if hasattr(self, \"cached_fun\"):\n del self.cached_fun\n # super(AmplitudeModel, self).__del__()\n\n def cache_data(self, data, split=None, batch=None):\n for i in self.decay_group:\n for j in i.inner:\n print(j)\n if split is None and batch is None:\n return data\n else:\n n = data_shape(data)\n if batch is None: # split个一组，共batch组\n batch = (n + split - 1) // split\n ret = list(split_generator(data, batch))\n return ret\n\n def set_used_res(self, res):\n self.decay_group.set_used_res(res)\n\n def set_used_chains(self, used_chains):\n self.decay_group.set_used_chains(used_chains)\n\n def partial_weight(self, data, combine=None):\n return self.decay_group.partial_weight(data, combine)\n\n def partial_weight_interference(self, data):\n return self.decay_group.partial_weight_interference(data)\n\n def get_params(self, trainable_only=False):\n return self.vm.get_all_dic(trainable_only)\n\n def set_params(self, var):\n self.vm.set_all(var)\n\n @contextlib.contextmanager\n def temp_params(self, var):\n params = self.get_params()\n self.set_params(var)\n yield var\n self.set_params(params)\n\n def chains_particle(self):\n return self.decay_group.chains_particle()\n\n @property\n def variables(self):\n return self.vm.variables\n\n @property\n def trainable_variables(self):\n return self.vm.trainable_variables\n\n def __call__(self, data, cached=False):\n if id(data) in self.f_data:\n if not self.decay_group.not_full:\n return self.cached_fun(data)\n else:\n self.f_data.append(id(data))\n ret = self.decay_group.sum_amp(data)\n return ret\n\n\ndef load_decfile_particle(fname):\n with open(fname) as f:\n dec = load_dec_file(f)\n dec = list(dec)\n particles = {}\n\n def get_particles(name):\n if name not in particles:\n a = get_particle(name)\n particles[name] = a\n return particles[name]\n\n decay = []\n for i in dec:\n cmd, var = i\n if cmd == \"Particle\":\n a = get_particles(var[\"name\"])\n setattr(a, \"params\", var[\"params\"])\n if cmd == \"Decay\":\n for j in var[\"final\"]:\n outs = [get_particles(k) for k in j[\"outs\"]]\n de = Decay(get_particles(var[\"name\"]), outs)\n for k in j:\n if k != \"outs\":\n setattr(de, k, j[k])\n decay.append(de)\n if cmd == \"RUNNINGWIDTH\":\n pa = get_particles(var[0])\n setattr(pa, \"running_width\", True)\n top, inner, outs = split_particle_type(decay)\n return top, inner, outs\n\n\nregist_config(DEFAULT_DECAY, (HelicityDecay, {}))\n", "meta": {"hexsha": "b2f416f29c256aabaa01f8f95a0dc9a5d01a5426", "size": 51374, "ext": "py", "lang": "Python", "max_stars_repo_path": "tf_pwa/amp/core.py", "max_stars_repo_name": "jiangyi15/tf-pwa", "max_stars_repo_head_hexsha": "17980750407a89bfd694e0b4f470332a886a3de9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2021-05-10T15:17:24.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-16T07:40:06.000Z", "max_issues_repo_path": "tf_pwa/amp/core.py", "max_issues_repo_name": "jiangyi15/tf-pwa", "max_issues_repo_head_hexsha": "17980750407a89bfd694e0b4f470332a886a3de9", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 45, "max_issues_repo_issues_event_min_datetime": "2020-10-24T08:26:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-20T06:14:58.000Z", "max_forks_repo_path": "tf_pwa/amp/core.py", "max_forks_repo_name": "jiangyi15/tf-pwa", "max_forks_repo_head_hexsha": "17980750407a89bfd694e0b4f470332a886a3de9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2020-10-24T06:41:06.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-03T01:29:49.000Z", "avg_line_length": 32.6391359593, "max_line_length": 125, "alphanum_fraction": 0.5341028536, "include": true, "reason": "import numpy,import sympy", "num_tokens": 12799, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5621765008857982, "lm_q2_score": 0.34864512179822554, "lm_q1q2_score": 0.19600009462342935}} {"text": "import numpy as np\nimport scipy.stats as sps\nimport warnings\nfrom GOFevaluation.utils import equiprobable_histogram\nfrom GOFevaluation.utils import apply_irregular_binning\nfrom GOFevaluation.utils import plot_equiprobable_histogram\nfrom GOFevaluation.utils import check_sample_sanity\n\n\nclass EvaluatorBase(object):\n \"\"\"Parent class for all evaluator base classes\"\"\"\n\n def __init__(self):\n self._name = self.__class__.__name__\n self.gof = None\n self.pvalue = None\n\n def __repr__(self):\n # return f'{self.__class__.__module__}, {self.__dict__}'\n return f'{self.__class__.__module__}.{self.__class__.__qualname__}'\\\n f'({self.__dict__.keys()})'\n\n def __str__(self):\n args = [self._name]\n if self.gof is not None:\n args.append(f'gof = {self.gof}')\n if self.pvalue is not None:\n args.append(f'p-value = {self.pvalue}')\n args_str = \"\\n\".join(args)\n return f'{self.__class__.__module__}\\n{args_str}'\n\n @staticmethod\n def calculate_gof():\n raise NotImplementedError(\"calculate_gof is not implemented yet!\")\n\n def get_gof(self):\n raise NotImplementedError(\"get_gof is not implemented yet!\")\n\n def get_pvalue(self):\n raise NotImplementedError(\"get_pvalue is not implemented yet!\")\n\n\nclass EvaluatorBaseBinned(EvaluatorBase):\n \"\"\"Evaluator base class for binned expectations reference input.\"\"\"\n\n def __init__(self, data_sample, pdf, bin_edges, nevents_expected):\n check_sample_sanity(data_sample)\n super().__init__()\n self.pdf = pdf\n assert (isinstance(nevents_expected, int)\n | isinstance(nevents_expected, np.int64)\n | isinstance(nevents_expected, float)), \\\n ('nevents_expected must be numeric but is of type '\n + f'{type(nevents_expected)}.')\n self.binned_reference = self.pdf * nevents_expected\n\n if bin_edges is None:\n # In this case data_sample is binned data!\n assert (data_sample.shape == pdf.shape), \\\n \"Shape of binned data does not match shape of the pdf!\"\n\n # Convert to int. Make sure the deviation is purely from\n # dtype conversion, i.e. the values provided are actually\n # bin counts and not float values.\n binned_data_int = np.abs(data_sample.round(0).astype(int))\n assert (np.sum(np.abs(data_sample - binned_data_int)) < 1e-10), \\\n 'Deviation encounterd when converting dtype of binned_data to'\\\n 'int. Make sure binned_data contains natural numbers!'\n self.binned_data = binned_data_int\n else:\n self.bin_data(data_sample=data_sample, bin_edges=bin_edges)\n return\n\n @classmethod\n def from_binned(cls, binned_data, binned_reference):\n \"\"\"Initialize with already binned data + expectations\n \"\"\"\n # bin_edges=None will set self.binned_data=binned_data\n # in the init\n return cls(data_sample=binned_data,\n pdf=binned_reference / np.sum(binned_reference),\n bin_edges=None,\n nevents_expected=np.sum(binned_reference))\n\n @classmethod\n def bin_equiprobable(cls, data_sample, reference_sample, nevents_expected,\n n_partitions, order=None, plot=False,\n plot_mode='sigma_deviation', **kwargs):\n \"\"\"Initialize with data and reference sample that are binned\n such that the expectation value is the same in each bin.\n kwargs are passed to `plot_equiprobable_histogram` if plot is True.\n \"\"\"\n check_sample_sanity(data_sample)\n check_sample_sanity(reference_sample)\n if len(reference_sample) < 50 * len(data_sample):\n warnings.warn(\n f'Number of reference samples ({len(reference_sample)}) '\n + 'should be much larger than number of data samples '\n + f'({len(data_sample)}) to ensure negligible statistical '\n + 'fluctuations for the equiprobable binning.', stacklevel=2)\n\n pdf, bin_edges = equiprobable_histogram(\n data_sample=reference_sample,\n reference_sample=reference_sample,\n n_partitions=n_partitions,\n order=order)\n pdf = pdf / np.sum(pdf)\n\n binned_data = apply_irregular_binning(\n data_sample=data_sample,\n bin_edges=bin_edges,\n order=order)\n\n if plot:\n plot_equiprobable_histogram(data_sample=data_sample,\n bin_edges=bin_edges,\n order=order,\n nevents_expected=nevents_expected,\n plot_mode=plot_mode,\n **kwargs)\n\n # bin_edges=None will set self.binned_data=binned_data\n # in the init\n return cls(data_sample=binned_data,\n pdf=pdf,\n bin_edges=None,\n nevents_expected=nevents_expected)\n\n def bin_data(self, data_sample, bin_edges):\n \"\"\"function to bin nD data sample\"\"\"\n if len(data_sample.shape) == 1:\n self.binned_data, _ = np.histogram(data_sample,\n bins=bin_edges)\n else:\n self.binned_data, _ = np.histogramdd(data_sample,\n bins=bin_edges)\n\n assert (self.binned_data.shape == self.pdf.shape), \\\n \"Shape of binned data doesn not match shape of pdf!\"\n\n def sample_gofs(self, n_mc=1000):\n \"\"\"Generate fake GoFs for toy data sampled from binned reference\n\n :param n_mc: Number of fake-gofs calculated, defaults to 1000\n :type n_mc: int, optional\n :return: Array of fake GoFs\n :rtype: array_like\n \"\"\"\n fake_gofs = np.zeros(n_mc)\n for i in range(n_mc):\n samples = sps.poisson(self.binned_reference).rvs()\n fake_gofs[i] = self.calculate_gof(\n samples, self.binned_reference)\n return fake_gofs\n\n def _get_pvalue(self, n_mc=1000):\n if self.gof is None:\n _ = self.get_gof()\n fake_gofs = self.sample_gofs(n_mc=n_mc)\n percentile = sps.percentileofscore(fake_gofs, self.gof, kind='strict')\n pvalue = 1 - percentile / 100\n\n if pvalue == 0:\n warnings.warn(f'p-value is 0.0. (Observed GoF: '\n f'{self.gof:.2e}, maximum of simulated GoFs: '\n f'{max(fake_gofs):.2e}). For a more '\n f'precise result, increase n_mc!', stacklevel=2)\n elif pvalue == 1:\n warnings.warn(f'p-value is 1.0. (Observed GoF '\n f'{self.gof:.2e}, minimum of simulated GoFs: '\n f'{min(fake_gofs):.2e}). For a more '\n f'precise result, increase n_mc!', stacklevel=2)\n\n self.pvalue = pvalue\n return pvalue, fake_gofs\n\n def get_pvalue(self, n_mc=1000):\n \"\"\"p-value is calculated\n\n Computes the p-value by means of generating toyMCs and calculating\n their GoF. The p-value can then be obtained from the distribution of\n these fake-gofs.\n\n :param n_mc: Number of fake-gofs calculated, defaults to 1000\n :type n_mc: int, optional\n :return: p-value\n :rtype: float\n \"\"\"\n pvalue, _ = self._get_pvalue(n_mc=n_mc)\n return pvalue\n\n def get_pvalue_return_fake_gofs(self, n_mc=1000):\n \"\"\"p-value is calculated\n\n Computes the p-value by means of generating toyMCs and calculating\n their GoF. The p-value can then be obtained from the distribution of\n these fake-gofs. The array of fake-gofs is returned together with\n the p-value.\n\n :param n_mc: Number of fake-gofs calculated, defaults to 1000\n :type n_mc: int, optional\n :return: p-value\n :rtype: float\n \"\"\"\n pvalue, fake_gofs = self._get_pvalue(n_mc=n_mc)\n return pvalue, fake_gofs\n\n\nclass EvaluatorBasePdf(EvaluatorBase):\n \"\"\"Evaluator base class for sample data, binned pdf reference input.\"\"\"\n\n def __init__(self, data_sample, pdf):\n check_sample_sanity(data_sample)\n super().__init__()\n self.data_sample = data_sample\n self.pdf = pdf\n\n def get_pvalue(self):\n # This method is not implemented yet. We are working on adding it in\n # the near future.\n raise NotImplementedError(\"p-value computation not yet implemented!\")\n\n\nclass EvaluatorBaseSample(EvaluatorBase):\n \"\"\"Evaluator base class for sample data and reference input.\"\"\"\n\n def __init__(self, data_sample, reference_sample):\n check_sample_sanity(data_sample)\n check_sample_sanity(reference_sample)\n super().__init__()\n self.data_sample = data_sample\n self.reference_sample = reference_sample\n\n def permutation_gofs(self, n_perm=1000, d_min=None):\n \"\"\"Generate fake GoFs by re-sampling data and reference sample\n\n :param n_perm: Number of fake-gofs calculated, defaults to 1000\n :type n_perm: int, optional\n :param d_min: Only for PointToPointGOF, defaults to None\n :type d_min: float, optional\n :return: Array of fake GoFs\n :rtype: array_like\n \"\"\"\n n_data = len(self.data_sample)\n mixed_sample = np.concatenate([self.data_sample,\n self.reference_sample],\n axis=0)\n fake_gofs = np.zeros(n_perm)\n for i in range(n_perm):\n rng = np.random.default_rng()\n rng.shuffle(mixed_sample, axis=0)\n\n data_perm = mixed_sample[:n_data]\n reference_perm = mixed_sample[n_data:]\n if d_min is not None:\n fake_gofs[i] = self.calculate_gof(\n data_sample=data_perm, reference_sample=reference_perm,\n d_min=d_min)\n else:\n fake_gofs[i] = self.calculate_gof(\n data_sample=data_perm, reference_sample=reference_perm)\n return fake_gofs\n\n def _get_pvalue(self, n_perm=1000, d_min=None):\n if self.gof is None:\n if d_min is not None:\n _ = self.get_gof(d_min=d_min)\n else:\n _ = self.get_gof()\n fake_gofs = self.permutation_gofs(n_perm=n_perm, d_min=d_min)\n\n percentile = sps.percentileofscore(fake_gofs, self.gof, kind='strict')\n pvalue = 1 - percentile / 100\n\n if pvalue == 0:\n warnings.warn(f'p-value is 0.0. (Observed GoF: '\n f'{self.gof:.2e}, maximum of simulated GoFs: '\n f'{max(fake_gofs):.2e}). For a more '\n f'precise result, increase n_mc!', stacklevel=2)\n elif pvalue == 1:\n warnings.warn(f'p-value is 1.0. (Observed GoF '\n f'{self.gof:.2e}, minimum of simulated GoFs: '\n f'{min(fake_gofs):.2e}). For a more '\n f'precise result, increase n_mc!', stacklevel=2)\n self.pvalue = pvalue\n\n return pvalue, fake_gofs\n\n def get_pvalue(self, n_perm=1000, d_min=None):\n \"\"\"p-value is calculated\n\n Computes the p-value by means of re-sampling data sample\n and reference sample. For each re-sampling, the gof is calculated.\n The p-value can then be obtained from the distribution of these\n fake-gofs.\n\n :param n_perm: Number of fake-gofs calculated, defaults to 1000\n :type n_perm: int, optional\n :return: p-value\n :rtype: float\n \"\"\"\n pvalue, _ = self._get_pvalue(n_perm=n_perm, d_min=d_min)\n return pvalue\n\n def get_pvalue_return_fake_gofs(self, n_perm=1000, d_min=None):\n \"\"\"p-value is calculated\n\n Computes the p-value by means of re-sampling data sample\n and reference sample. For each re-sampling, the gof is calculated.\n The p-value can then be obtained from the distribution of these\n fake-gofs. The array of fake-gofs is returned together with\n the p-value.\n\n :param n_perm: Number of fake-gofs calculated, defaults to 1000\n :type n_perm: int, optional\n\n :return: p-value, fake_gofs\n :rtype: float\n \"\"\"\n pvalue, fake_gofs = self._get_pvalue(n_perm=n_perm, d_min=d_min)\n return pvalue, fake_gofs\n", "meta": {"hexsha": "f96d1360b4e77518f8c7858c7a5342c2124495c7", "size": 12641, "ext": "py", "lang": "Python", "max_stars_repo_path": "GOFevaluation/evaluator_base.py", "max_stars_repo_name": "XENONnT/GOFevaluation", "max_stars_repo_head_hexsha": "ef34b2b0ee911d74cee0ba7c1fdcfc25dedb7350", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "GOFevaluation/evaluator_base.py", "max_issues_repo_name": "XENONnT/GOFevaluation", "max_issues_repo_head_hexsha": "ef34b2b0ee911d74cee0ba7c1fdcfc25dedb7350", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2021-10-19T13:46:42.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-28T15:06:59.000Z", "max_forks_repo_path": "GOFevaluation/evaluator_base.py", "max_forks_repo_name": "XENONnT/GOFevaluation", "max_forks_repo_head_hexsha": "ef34b2b0ee911d74cee0ba7c1fdcfc25dedb7350", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.2577639752, "max_line_length": 79, "alphanum_fraction": 0.5998734277, "include": true, "reason": "import numpy,import scipy", "num_tokens": 2864, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5621764862150636, "lm_q2_score": 0.3486451217982255, "lm_q1q2_score": 0.19600008950854927}} {"text": "# Python modules\nimport ctypes\n\n# 3rd party modules\nimport numpy as np\nimport multiprocessing as mp\nimport xml.etree.cElementTree as ElementTree\n\n# Our modules\nimport vespa.analysis.constants as constants\nimport vespa.analysis.mrs_user_prior as mrs_user_prior\nimport vespa.analysis.block_fit_voigt as block_fit_voigt\n\nimport vespa.analysis.algos.wavelet_filter as wavelet_filter\n\nimport vespa.common.mrs_prior as mrs_prior\nimport vespa.common.util.ppm as util_ppm\nimport vespa.common.util.xml_ as util_xml\nimport vespa.common.util.math_ as util_math\nimport vespa.common.util.generic_spectral as util_spectral\n\nfrom vespa.common.constants import Deflate\nfrom vespa.analysis.constants import FitLineshapeModel\n\nfrom vespa.common.constants import DEGREES_TO_RADIANS as DTOR\nfrom vespa.analysis.algos.constrained_levenberg_marquardt import constrained_levenberg_marquardt as clm \n\n# Sad but true, we need these globals to be able to minimize the amount\n# of data and fitting parameters that are transferred to the processes\n\ndata = None\nchain = None\n\n\nclass ProcessChain(block_fit_voigt._Settings):\n \"\"\"\n A subclass of block_fit_voigt._Settings that will let us serialize\n fitting information that can be sent to each process. We add a dash\n of values from mrs_dataset.Dataset to be able to use the util_ppm\n methods. \n \n \"\"\"\n # This is the version of this object's XML output format. \n XML_VERSION = \"1.0.0\"\n\n def __init__(self, attributes=None):\n \n block_fit_voigt._Settings.__init__(self)\n\n # Spectral data information\n self.frequency = 124.0\n self.sw = 1000.0\n self.raw_dims = []\n self.raw_hpp = 1.0\n self.resppm = 4.7\n self.echopeak = 0.0\n self.spectral_dims = []\n self.spectral_hpp = 1.0\n self.phase_1_pivot = 2.01\n self.zero_fill_multiplier = 1\n\n self.user_prior = mrs_user_prior.UserPrior()\n self.metinfo = self.user_prior.metinfo\n\n # These are run-time attributes\n \n self.peakpts = []\n self.basis_mets = None\n self.init_results = None\n self.fit_results = None\n\n # Now if we are loading in data we can re-set a few attributes\n \n if attributes is not None:\n self.inflate(attributes)\n\n # Here are attributes that can be calculated if we are loading\n # a ProcessChain object back into this instance. \n \n if self.prior.names != []:\n self.prior_list = self.prior.names\n #FIXME-bjs need new code to account for GISO fit method here! if needed.\n self.prior.calculate_full_basis_set(self.prior_ppm_start, \n self.prior_ppm_end, \n self)\n basis_mets = []\n ppms = []\n peaks = []\n alist = self.prior.basis_set_names\n for name in sorted(alist):\n item = self.prior.basis_set[name]\n basis_mets.append(item.fid.copy())\n ppms += item.all_ppms\n peaks.append(item.peak_ppm)\n \n self.peakpts = self.ppm2pts(np.array(ppms)) \n self.prior_peak_ppm = np.array(peaks) # ppm is OK here\n self.basis_mets = np.array(basis_mets)\n \n self.fit_results = np.zeros((self.nmet,), 'float')\n self.init_results = np.zeros((self.nmet,), 'float')\n\n self.current_lw = 5.0\n self.data = None\n self.limits = None\n self.weight_array = None\n self.weight_array = None\n self.fit_baseline = None\n self.fit_stats = None\n \n\n @property\n def nmet(self):\n if self.prior is not None:\n return len(self.prior.names)\n else:\n return 0\n\n\n def deflate(self, flavor=Deflate.ETREE):\n if flavor == Deflate.ETREE:\n # Make my base class do its deflate work\n e = block_fit_voigt._Settings.deflate(self, flavor)\n\n # Alter the tag name & XML version info \n e.tag = \"process_chain\"\n e.set(\"version\", self.XML_VERSION)\n\n # Add custom attributes here.\n \n # These attributes are all lists.\n for attribute in (\"raw_dims\", \n \"spectral_dims\", ):\n for value in getattr(self, attribute):\n util_xml.TextSubElement(e, attribute, value)\n \n # These atttributes are all scalars and map directly to \n # XML elements of the same name.\n for attribute in ( \"frequency\",\n \"sw\",\n \"raw_hpp\",\n \"resppm\",\n \"echopeak\",\n \"spectral_hpp\",\n \"phase_1_pivot\",\n \"zero_fill_multiplier\",):\n util_xml.TextSubElement(e, attribute, getattr(self, attribute)) \n\n return e\n\n \n def inflate(self, source): \n if hasattr(source, \"makeelement\"):\n # Quacks like an ElementTree.Element\n \n block_fit_voigt._Settings.inflate(self, source)\n \n # We inflate in attributes grouped by type since there's so\n # doggone many attrs on this class.\n \n# # Booleans\n# for attribute in (\"xxx\", \"xxx\", ):\n# item = source.findtext(attribute)\n# if item is not None:\n# setattr(self, attribute, util_xml.BOOLEANS[item])\n # floats\n for attribute in (\"frequency\", \n \"sw\", \n \"raw_hpp\", \n \"resppm\",\n \"echopeak\",\n \"spectral_hpp\",\n \"phase_1_pivot\", ):\n item = source.findtext(attribute)\n if item is not None:\n setattr(self, attribute, float(item))\n\n # ints\n for attribute in (\"zero_fill_multiplier\", ):\n item = source.findtext(attribute)\n if item is not None:\n setattr(self, attribute, int(float(item)))\n\n# # No translation required for these text attrs\n# for attribute in (\"xxx\", \"xxx\", ):\n# item = source.findtext(attribute)\n# if item is not None:\n# setattr(self, attribute, item)\n\n # lists\n self.raw_dims = [int(val.text) for val in source.getiterator(\"raw_dims\")]\n self.spectral_dims = [int(val.text) for val in source.getiterator(\"spectral_dims\")]\n\n\n def fit_function(self, a, pderflg=True, \n nobase=False, \n indiv=False, \n finalwflg=False):\n \n # Setup constants and flags\n\n# import os\n# print \"fit_function: process id = {0} got here 100 data={1})\".format(os.getpid(), self.data.shape )\n\n nmet = self.nmet\n npts = self.data.shape[0]\n zfmult = self.zero_fill_multiplier\n nptszf = round(npts * zfmult)\n sw = 1.0 * self.sw\n td = 1.0/sw\n piv = self.ppm2pts(self.phase_1_pivot, acq=True)\n t2fix = self.prior_fix_t2\n \n arr1 = np.zeros(npts,float) + 1.0\n f = np.zeros((nmet,nptszf),complex) \n mf = np.zeros((nptszf,),complex)\n\n t = (np.arange(nmet * npts) % npts) * td\n t.shape = nmet, npts\n mt = np.arange(npts) * td\n \n # get prior max peak ppm vals for metabs which are flagged ON\n peaks = self.prior_peak_ppm\n \n # setup Lineshape \n if self.lineshape_model != FitLineshapeModel.GAUSS:\n # voigt and lorentzian models\n expo = t/a[nmet*2] + (t/a[nmet*2+1])**2\n lshape = util_math.safe_exp(-expo)\n else:\n # Note. in the case of the Gaussian lineshape, we now allow the user to \n # set a fixed T2 value for each metabolite. In the model call (fitt_funct.pro)\n # we now create a lineshape array that takes each fixed value into account.\n # BUT! we are still passing in a Tb parameter here, and though that parameter\n # will be tightly constrained, it should still be in the range of the fixed\n # physiologic params choosen by the user. At the moment, we have choosen to\n # just set this parameter to 0.250 sec, which should be a reasonable average\n # of 1H metabolite T2 values in the brain. It is then allowed to bop plus or\n # minus 0.001 as set further below. In the fitting function, we adjust each \n # fixed value by the delta from 0.250 so that the pder will fluctuate as the\n # parameter changes and not confuse the poor optimization routine. In reality,\n # the 0.250 is never used, just the delta amount of the actual a[nmet*2]\n # parameter from that value.\n \n ma = (self.fix_t2_center - a[nmet*2]) + t2fix # delta for Ta param that is set at 0.25 sec\n ma = t/np.outer(ma, arr1)\n mb = (t / a[nmet*2+1])**2\n expo = ma+mb\n lshape = util_math.safe_exp(-expo) \n\n if finalwflg: \n finalw = lshape[:,0]\n finalw = util_spectral.full_width_half_max(np.fft.fft(util_spectral.chop(finalw))/len(finalw)) * self.spectral_hpp\n return finalw\n \n # if FID, then for correct area, first point must be divided by 2\n\n tmp = self.basis_mets.copy() \n fre = a[nmet:nmet*2] - self.ppm2hz(peaks)*2.0*np.pi # in Radians here\n fre = np.exp( 1j * (np.outer(fre, arr1)) * t ) # outer is matrix multiplication\n amp = np.outer(a[0:nmet], arr1)\n ph0 = np.outer(np.exp(1j * (np.zeros(nmet) + a[nmet*2+2])), arr1) \n tmp *= amp * fre * ph0 * lshape\n f[:,0:npts] = tmp \n\n f[:,0] = f[:,0] / 2.0 \n \n # Calc Phase1 \n phase1 = np.exp(1j * (a[nmet*2+3]*DTOR*(np.arange(nptszf,dtype=float)-piv)/nptszf))\n \n # Calculate Partial Derivatives \n pder = None\n if pderflg:\n pder = np.zeros((len(a),nptszf), complex)\n \n pall = np.sum(f,axis=0) # all lines added\n \n pind = f\n tt = np.zeros(nptszf,float)\n tt[0:npts] = np.arange(npts,dtype=float) * td\n \n for i in range(nmet): # Calc the Ampl and Freq pders\n pder[i,:] = (np.fft.fft(pind[i,:] / a[i] )/nptszf) * phase1\n pder[i+nmet,:] = (np.fft.fft(tt * 1j * pind[i,:])/nptszf) * phase1\n pder[nmet*2+0,:] = (np.fft.fft( tt * pall/(a[nmet*2+0]**2))/nptszf) * phase1\n pder[nmet*2+1,:] = (np.fft.fft(2.0*(tt**2) * pall/(a[nmet*2+1]**3))/nptszf) * phase1\n \n pder[nmet*2+2,:] = (np.fft.fft(1j*pall)/nptszf) * phase1 * nptszf\n pder[nmet*2+3,:] = (np.fft.fft( pall)/nptszf) * (1j*DTOR*(np.arange(nptszf,dtype=float)-piv)/nptszf) * phase1\n \n # Do the FFT \n if indiv: # return individual lines\n if nmet != 1: \n for i in range(nmet): \n f[i,:] = (np.fft.fft(f[i,:])/nptszf) * phase1\n else:\n f = (np.fft.fft(f[0,:])/nptszf) * phase1\n else: # return summed spectrum \n if (nmet) != 1: \n f = np.sum(f,axis=0)\n f = (np.fft.fft(f)/nptszf) * phase1\n else:\n f = (np.fft.fft(f[0,:])/nptszf) * phase1\n \n # Add in baseline unless nobase is True ---\n if not nobase:\n if f.ndim > 1: \n for i in range(len(f)): f[i,:] = f[i,:] + self.fit_baseline\n else: \n f = f + self.fit_baseline\n \n return f, pder \n\n\n def set_weight_array(self, lwidth=None, wtmult=None, wtmax=None):\n \"\"\"\n Creates a weight array to be used in the optimization based on setting in\n the chain structure. *(self.wtarr)) is set as the output.\n \n chain: ptr to optimization control structure\n \n \"\"\"\n prior = self.prior\n metinfo = self.metinfo\n \n abbr = [metinfo.get_abbreviation(item) for item in self.prior_list]\n dim0 = self.spectral_dims[0]\n \n if not lwidth:\n lwidth = self.initial_linewidth_value\n else: \n lwidth = float(lwidth) if lwidth > 0.1 else 0.1\n \n if not wtmult:\n wtmult = self.optimize_weights_width_factor \n else: \n wtmult = float(wtmult) if wtmult>0.0001 else 0.001\n \n if not wtmax:\n wtmax = dim0-1 \n else: \n wtmax = float(wtmax)\n \n wtarr = np.zeros(dim0, float)\n \n if self.optimize_weights_method == constants.FitOptimizeWeightsMethod.EVEN_WEIGHTING:\n wtarr = wtarr + 1.0 \n \n elif self.optimize_weights_method == constants.FitOptimizeWeightsMethod.LOCAL_WEIGHTING:\n \n lw = lwidth / self.spectral_hpp # in points\n centers = self.peakpts\n \n wid = lw * wtmult\n wid = wid if lw0, round(ctr-wid), 0))\n cs = int(np.where(cs0, round(ctr+wid), 0))\n ce = int(np.where(ce nvox:\n pool_size = nvox\n \n pool = mp.Pool(processes=pool_size, \n initializer=do_process_init,\n initargs=(xmlstring,shared_arr) )\n \n pool_outputs = pool.map(do_loop_kernel, inputs)\n pool.close() # no more tasks\n pool.join() # wrap up current tasks\n \n # Get process results from the output list\n pool_outputs.sort()\n results = np.array([r[1] for r in pool_outputs])\n \n return results\n\n\ndef run_tests():\n \"\"\"\n Ran some tests on my T3500 with 6 cores and HT = 12 cores\n \n There's a major hit at the startup of the processes, on the order of 24\n seconds or so ...\n \n Here's the breakdown:\n 1 3.51 sec\n 2 5.40 sec\n 10 23.44 sec\n 50 29.81 sec\n 100 31.84 sec\n 800 64.41 sec\n \n \"\"\"\n# from pylab import *\n\n nvox = 100\n \n # I test this convoluted way of initializing global chain variable here so \n # I know that it will perform well in the processes without having to printf\n # my way through a distributed debug session\n \n xmlstring = init_chain() # deflated object with values for fake data set properly\n do_process_init(xmlstring, None) # inflate and set equal to the global chain variable\n\n global chain\n \n # Create fake data and a shared array that will be accessed by all the \n # distributed processes. Init model uses the inital values set in the \n # chain object. We then add different data to this model to create nvox\n # distinct sets of data.\n \n model = init_model()\n fake_data = np.zeros((nvox,chain.raw_dims[0]), 'complex64')\n\n ndbl = nvox * chain.spectral_dims[0] * 2 # for complex data\n shared_arr = mp.Array(ctypes.c_float, ndbl)\n arr = tonumpyarray(shared_arr).view('complex64') \n \n for i in range(nvox):\n noiser = np.random.randn(chain.raw_dims[0])\n noisei = np.random.randn(chain.raw_dims[0])\n noise = noiser + 1j*noisei\n fake_data[i,:] = model + noise * 0.02\n \n tmp = _data.flatten()\n arr[:] = tmp\n \n # We are ready to start the processes, initialize them and then use them\n # to fit the fake data. The results list stores fitted parameters for \n # each data entry in the order they are in the shared_array\n \n results = do_loop(nvox, xmlstring, shared_arr)\n \n # Check the results to see if the first set of fitted parameters\n # and the visulization of the overlaid fit on the data is good.\n # Note. We do not actually have the fitted baseline results where\n # we can plot them in this example ... something for the future.\n \n print('fit - init =' + str(results[0,:] - chain.init_results)) \n\n a = results[0,:].copy()\n a = check_out(a, chain)\n fit, _ = chain.fit_function(a, pderflg=False, nobase=True)\n\n# plot(_data[0,:])\n# plot(fit)\n# plot(chain.fit_baseline)\n# plot(chain.weight_array)\n# show()\n\n bob = 10\n bob = bob + 1\n \n\n\n\n\n\nif __name__ == '__main__':\n\n import cProfile\n cProfile.run('run_tests()')\n\n# run_tests()", "meta": {"hexsha": "d233b38b33b1089ca6ee75ad24756391c4c291e8", "size": 29864, "ext": "py", "lang": "Python", "max_stars_repo_path": "vespa/analysis/test_multi_optimize_pool.py", "max_stars_repo_name": "vespa-mrs/vespa", "max_stars_repo_head_hexsha": "6d3e84a206ec427ac1304e70c7fadf817432956b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "vespa/analysis/test_multi_optimize_pool.py", "max_issues_repo_name": "vespa-mrs/vespa", "max_issues_repo_head_hexsha": "6d3e84a206ec427ac1304e70c7fadf817432956b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2021-04-17T13:58:31.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-20T14:19:57.000Z", "max_forks_repo_path": "vespa/analysis/test_multi_optimize_pool.py", "max_forks_repo_name": "vespa-mrs/vespa", "max_forks_repo_head_hexsha": "6d3e84a206ec427ac1304e70c7fadf817432956b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2021-06-05T16:34:57.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-19T16:13:22.000Z", "avg_line_length": 36.7783251232, "max_line_length": 126, "alphanum_fraction": 0.5531074203, "include": true, "reason": "import numpy", "num_tokens": 7691, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5736784220301064, "lm_q2_score": 0.3415825061409754, "lm_q1q2_score": 0.19595851311604393}} {"text": "# This file is part of LayerModel_lib\n#\n# A tool to compute the transmission behaviour of plane electromagnetic waves\n# through human tissue.\n#\n# Copyright (C) 2018 Jan-Christoph Brumm\n#\n# Licensed under MIT license.\n#\n\"\"\"\nA small example showing how to generate a layer model for specific coordinates inside the chosen VoxelModel.\nAdditionally, the transfer function for S_21 and E-, and H-field are compared for surface to in-body communication\nand vice versa\n\n\"\"\"\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nfrom LayerModel_lib import VoxelModel, LayerModel, Coordinate\nfrom config import phantom_path\n\nVoxelModel.working_directory = phantom_path\nall_models = VoxelModel.list_all_voxel_models()\nfor model in all_models:\n print(model)\n\n# Load a virtual human model\nvm = VoxelModel('AustinMan_v2.5_2x2x2')\n\nstart = Coordinate([231, 270, 1110]) # some point in the colon\nend = Coordinate([330, 277, 1110]) # some point outside the body\n\n# calculate the layer model from two of these points\nlm = LayerModel(vm, start, end)\n\n# show info about the model\nlm.print_info()\n\n# Calculate the transfer function for S21 (square root of transmitted power) from 0 to 10 GHz with 1024 samples,\n# the default direction is 'start->end'\n(transfer_function, frequency) = lm.S21(f_start=3.1e9, f_end=4.8e9, n_samples=1024)\n\n# plot the magnitude\nhf, ha = plt.subplots(nrows=2)\nha[0].plot(frequency / 1e9, 20 * np.log10(np.abs(transfer_function)))\nha[0].set_xlabel(\"Frequency in GHz\")\nha[0].set_ylabel(\"Magnitude in dB\")\nha[0].set_title(\"Transfer Function between the two coordinates\")\n\nha[1].plot(frequency / 1e9, np.unwrap(np.angle(transfer_function), axis=0))\nha[1].set_xlabel(\"Frequency in GHz\")\nha[1].set_ylabel(\"Phase in rad\")\nplt.tight_layout()\nplt.show()\n", "meta": {"hexsha": "144f88462ea5cb3e5cb63002d085ed5e3a83a643", "size": 1764, "ext": "py", "lang": "Python", "max_stars_repo_path": "examples/transfer_function_from_voxelmodel.py", "max_stars_repo_name": "janbrumm/layermodel_lib", "max_stars_repo_head_hexsha": "0d5e0c9ac77d302910823ebc757a4ec99541f3ff", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "examples/transfer_function_from_voxelmodel.py", "max_issues_repo_name": "janbrumm/layermodel_lib", "max_issues_repo_head_hexsha": "0d5e0c9ac77d302910823ebc757a4ec99541f3ff", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "examples/transfer_function_from_voxelmodel.py", "max_forks_repo_name": "janbrumm/layermodel_lib", "max_forks_repo_head_hexsha": "0d5e0c9ac77d302910823ebc757a4ec99541f3ff", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.0727272727, "max_line_length": 114, "alphanum_fraction": 0.7590702948, "include": true, "reason": "import numpy", "num_tokens": 471, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.5736784074525096, "lm_q2_score": 0.341582499438317, "lm_q1q2_score": 0.19595850429142145}} {"text": "import numpy as np\nimport subprocess\n\nfrom numpy import (\n zeros,\n pi,\n floor_divide,\n loadtxt,\n max as np_max,\n min as np_min,\n sign,\n angle as np_angle,\n)\nfrom os.path import basename, splitext\nfrom SciDataTool import DataTime, VectorField, Data1D\nfrom os.path import join\n\nfrom ....Functions.Winding.gen_phase_list import gen_name\n\n\nfrom ....Classes.Magnetics import Magnetics\nfrom ....Functions.labels import (\n AIRGAP_LAB,\n ROTOR_LAB_S,\n short_label,\n decode_label,\n get_obj_from_label,\n LAM_LAB_S,\n STATOR_LAB_S,\n HOLEV_LAB_S,\n HOLEM_LAB_S,\n WIND_LAB_S,\n MAG_LAB,\n SHAFT_LAB,\n NO_LAM_LAB,\n SLID_LAB,\n BOT_LAB,\n)\nfrom ....Functions.Winding.find_wind_phase_color import get_phase_id\nfrom .... import __version__\nfrom ....Functions.get_path_binary import get_path_binary\n\nfrom ....Classes.HoleM50 import HoleM50\nfrom ....Classes.HoleM51 import HoleM51\nfrom ....Classes.HoleM52 import HoleM52\nfrom ....Classes.HoleM53 import HoleM53\nfrom ....Classes.MachineSIPMSM import MachineSIPMSM\nfrom ....Classes.MachineIPMSM import MachineIPMSM\nfrom ....Methods import NotImplementedYetError\n\n\ndef solve_FEA(self, output, sym, angle, time, angle_rotor, Is, Ir):\n \"\"\"\n Solve Elmer model to calculate airgap flux density, torque instantaneous/average/ripple values,\n flux induced in stator windings and flux density, field and permeability maps\n\n Parameters\n ----------\n self: MagElmer\n A MagElmer object\n output: Output\n An Output object\n sym: int\n Spatial symmetry factor\n time: ndarray\n Time vector for calculation\n angle: ndarray\n Angle vector for calculation\n Is : ndarray\n Stator current matrix (qs,Nt) [A]\n Ir : ndarray\n Stator current matrix (qs,Nt) [A]\n angle_rotor: ndarray\n Rotor angular position vector (Nt,)\n \"\"\"\n\n project_name = self.get_path_save_fea(output)\n elmermesh_folder = project_name\n mesh_names_file = join(project_name, \"mesh.names\")\n boundaries = {}\n bodies = {}\n machine = output.simu.machine\n BHs = output.geo.stator.BH_curve # Stator B(H) curve\n BHr = output.geo.rotor.BH_curve # Rotor B(H) curve\n # Is = output.elec.Is # Stator currents waveforms\n # Ir = output.elec.Ir # Rotor currents waveforms\n Speed = output.elec.OP.get_N0()\n rotor_mat_file = join(project_name, \"rotor_material.pmf\")\n stator_mat_file = join(project_name, \"stator_material.pmf\")\n\n # TO-DO: Time vector must be greater than one\n timesize_str = np.array2string(\n np.diff(time), separator=\" \", formatter={\"float_kind\": lambda x: \"%.2e\" % x}\n )\n time = np.append(time, time[1] + time[-1])\n timesize_str = np.array2string(\n np.diff(time), separator=\" \", formatter={\"float_kind\": lambda x: \"%.2e\" % x}\n )\n timelen = len(time) - 1\n ones_str = np.array2string(\n np.ones(timelen), separator=\" \", formatter={\"int\": lambda x: \"%d\" % x}\n )\n timeinterval_str = ones_str.replace(\".\", \"\")\n\n with open(mesh_names_file, \"rt\") as f:\n for line in f:\n fields = line.strip().split()\n if fields[0] == \"$\":\n field_name = fields[1]\n field_value = fields[3]\n # update dictionary\n # _settings['Geometry'][field_name] = field_value\n if field_name.count(\"BOUNDARY\"):\n boundaries[field_name] = field_value\n else:\n bodies[field_name] = {\n \"id\": field_value,\n \"mat\": 1, # Air by Default\n \"eq\": 1, # RigidMeshMapper by Default\n \"bf\": None,\n \"tg\": None,\n }\n\n with open(rotor_mat_file, \"wt\") as ro:\n ro.write(\"! File Generated by pyleecan v{0}\\n\".format(__version__))\n ro.write(\n \"! Material Name: {0}\\n\"\n \"! B-H Curve Rotor Material\\n\"\n \"Electric Conductivity = 0\\n\"\n \"H-B Curve = Variable coupled iter\\n\"\n \" Real\\t\\tCubic Monotone\\n\".format(machine.rotor.mat_type.name)\n )\n for ii in range(BHr.shape[0]):\n ro.write(\" {0}\\t\\t{1}\\n\".format(BHr[ii][1], BHr[ii][0]))\n ro.write(\"End\\n\")\n\n with open(stator_mat_file, \"wt\") as ro:\n ro.write(\"! File Generated by pyleecan v{0}\\n\".format(__version__))\n ro.write(\n \"! Material Name: {0}\\n\"\n \"! B-H Curve Stator Material\\n\"\n \"Electric Conductivity = 0\\n\"\n \"H-B Curve = Variable coupled iter\\n\"\n \" Real\\t\\tCubic Monotone\\n\".format(machine.stator.mat_type.name)\n )\n for ii in range(BHs.shape[0]):\n ro.write(\" {0}\\t\\t{1}\\n\".format(BHs[ii][1], BHs[ii][0]))\n ro.write(\"End\\n\")\n\n elmer_sim_file = join(project_name, \"pyleecan_elmer.sif\")\n pp = machine.stator.winding.p\n wind_mat = machine.stator.winding.get_connection_mat(machine.stator.slot.Zs)\n surf_wind = machine.stator.slot.comp_surface_active()\n ror = machine.rotor.comp_radius_mec()\n sir = machine.stator.comp_radius_mec()\n with open(elmer_sim_file, \"wt\") as fo:\n fo.write(\"! File Generated by pyleecan v{0}\\n\".format(__version__))\n fo.write(\n \"$ WM = 2*pi*{0}/60 ! Mechanical Frequency [rad/s]\\n\".format(Speed)\n )\n fo.write(\"$ PP = {0} ! Pole pairs\\n\".format(pp))\n fo.write(\"$ WE = PP*WM ! Electrical Frequency [Hz]\\n\")\n\n if isinstance(machine, MachineSIPMSM):\n # magnet_0 = machine.rotor.slot.magnet[0]\n magnet_0 = machine.rotor.magnet\n elif isinstance(machine, MachineIPMSM):\n magnet_dict = machine.rotor.hole[0].get_magnet_dict()\n magnet_0 = magnet_dict[\"magnet_0\"]\n else:\n self.get_logger().info(\"ElmerSolver [Error]: Unsupported Machine Geometry\")\n return False\n\n surf_list = machine.build_geometry(sym=sym)\n pm_index = 6\n Mangle = list()\n Ncond_Aplus = 1\n Ncond_Aminus = 1\n Ncond_Bplus = 1\n Ncond_Bminus = 1\n Ncond_Cplus = 1\n Ncond_Cminus = 1\n Ncond_Dplus = 1\n Ncond_Dminus = 1\n Ncond_Eplus = 1\n Ncond_Eminus = 1\n Ncond_Fplus = 1\n Ncond_Fminus = 1\n Npcp = machine.stator.winding.Npcp\n for surf in surf_list:\n label = short_label(surf.label)\n label_dict = decode_label(label)\n point_ref = surf.point_ref\n if HOLEM_LAB_S in label_dict[\"surf_type\"]: # LamHole\n mag_obj = get_obj_from_label(machine, label_dict=label_dict)\n if mag_obj.type_magnetization == 1: # Parallel\n magnetization_type = \"parallel\"\n # calculate pole angle and angle of pole middle\n T_id = label_dict[\"T_id\"]\n hole = mag_obj.parent\n Zh = hole.Zh\n alpha_p = 360 / Zh\n mag_0 = (\n floor_divide(np_angle(point_ref, deg=True), alpha_p) + 0.5\n ) * alpha_p\n\n mag_dict = hole.comp_magnetization_dict()\n mag = mag_0 + mag_dict[\"magnet_\" + str(T_id)] * 180 / pi\n # modifiy magnetisation of south poles\n if (label_dict[\"S_id\"] % 2) == 1:\n mag = mag + 180\n else:\n raise NotImplementedYetError(\n \"Only parallele magnetization are available for HoleMagnet\"\n )\n if bodies.get(label, None) is not None:\n Mangle.append(mag)\n bodies[label][\"mat\"] = pm_index\n bodies[label][\"eq\"] = 1\n bodies[label][\"bf\"] = 1\n bodies[label][\"tg\"] = 1\n pm_index = pm_index + 1\n elif MAG_LAB in label_dict[\"surf_type\"]:\n mag_obj = get_obj_from_label(machine, label_dict=label_dict)\n if mag_obj.type_magnetization == 0 and (label_dict[\"S_id\"] % 2) == 0:\n mag = 0 # North pole magnet\n magnetization_type = \"radial\"\n elif mag_obj.type_magnetization == 0:\n mag = 180 # South pole magnet\n magnetization_type = \"radial\"\n elif mag_obj.type_magnetization == 1 and (label_dict[\"S_id\"] % 2) == 0:\n mag = np_angle(point_ref) * 180 / pi # North pole magnet\n magnetization_type = \"parallel\"\n elif mag_obj.type_magnetization == 1:\n mag = np_angle(point_ref) * 180 / pi + 180 # South pole magnet\n magnetization_type = \"parallel\"\n elif mag_obj.type_magnetization == 2:\n Zs = mag_obj.parent.slot.Zs\n mag = str(-(Zs / 2 - 1)) + \" * theta + 90 \"\n magnetization_type = \"hallback\"\n else:\n continue\n if bodies.get(label, None) is not None:\n Mangle.append(mag)\n bodies[label][\"mat\"] = pm_index\n bodies[label][\"eq\"] = 1\n bodies[label][\"bf\"] = 1\n bodies[label][\"tg\"] = 1\n pm_index = pm_index + 1\n elif WIND_LAB_S in label_dict[\"surf_type\"]:\n lam_obj = get_obj_from_label(machine, label_dict=label_dict)\n wind_mat = lam_obj.winding.get_connection_mat(lam_obj.get_Zs())\n Nrad_id = label_dict[\"R_id\"] # zone radial coordinate\n Ntan_id = label_dict[\"T_id\"] # zone tangential coordinate\n Zs_id = label_dict[\"S_id\"] # Zone slot number coordinate\n # Get the phase value in the correct slot zone\n q_id = get_phase_id(wind_mat, Nrad_id, Ntan_id, Zs_id)\n Ncond = wind_mat[Nrad_id, Ntan_id, Zs_id, q_id]\n s = sign(Ncond)\n if bodies.get(label, None) is not None:\n bodies[label][\"mat\"] = 5\n bodies[label][\"eq\"] = 1\n if q_id == 0 and s == 1:\n bodies[label][\"bf\"] = 2\n Ncond_Aplus = abs(Ncond)\n elif q_id == 0 and s == -1:\n bodies[label][\"bf\"] = 3\n Ncond_Aminus = abs(Ncond)\n elif q_id == 1 and s == 1:\n bodies[label][\"bf\"] = 4\n Ncond_Bplus = abs(Ncond)\n elif q_id == 1 and s == -1:\n bodies[label][\"bf\"] = 5\n Ncond_Bminus = abs(Ncond)\n elif q_id == 2 and s == 1:\n bodies[label][\"bf\"] = 6\n Ncond_Cplus = abs(Ncond)\n elif q_id == 2 and s == -1:\n bodies[label][\"bf\"] = 7\n Ncond_Cminus = abs(Ncond)\n elif q_id == 3 and s == 1:\n bodies[label][\"bf\"] = 8\n Ncond_Dplus = abs(Ncond)\n elif q_id == 3 and s == -1:\n bodies[label][\"bf\"] = 9\n Ncond_Dminus = abs(Ncond)\n elif q_id == 4 and s == 1:\n bodies[label][\"bf\"] = 10\n Ncond_Eplus = abs(Ncond)\n elif q_id == 4 and s == -1:\n bodies[label][\"bf\"] = 11\n Ncond_Eminus = abs(Ncond)\n elif q_id == 5 and s == 1:\n bodies[label][\"bf\"] = 12\n Ncond_Fplus = abs(Ncond)\n elif q_id == 5 and s == -1:\n bodies[label][\"bf\"] = 13\n Ncond_Fminus = abs(Ncond)\n else:\n pass\n elif (\n LAM_LAB_S in label_dict[\"surf_type\"]\n and ROTOR_LAB_S in label_dict[\"lam_label\"]\n and bodies.get(label, None) is not None\n ):\n bodies[label][\"mat\"] = 4\n bodies[label][\"eq\"] = 1\n bodies[label][\"bf\"] = 1\n bodies[label][\"tg\"] = 1\n elif (\n LAM_LAB_S in label_dict[\"surf_type\"]\n and STATOR_LAB_S in label_dict[\"lam_label\"]\n and bodies.get(label, None) is not None\n ):\n bodies[label][\"mat\"] = 3\n bodies[label][\"eq\"] = 1\n elif (\n SHAFT_LAB in label_dict[\"surf_type\"]\n and bodies.get(label, None) is not None\n ):\n bodies[label][\"mat\"] = 1\n bodies[label][\"eq\"] = 1\n bodies[label][\"bf\"] = 1\n bodies[label][\"tg\"] = 1\n elif (\n HOLEV_LAB_S in label_dict[\"surf_type\"]\n and bodies.get(label, None) is not None\n ):\n bodies[label][\"mat\"] = 1\n bodies[label][\"eq\"] = 1\n bodies[label][\"bf\"] = 1\n bodies[label][\"tg\"] = 1\n else:\n pass\n\n # The following bodies are not in the dictionary\n bodies[ROTOR_LAB_S + \"-0_\" + AIRGAP_LAB + BOT_LAB][\"bf\"] = 1\n bodies[NO_LAM_LAB + \"_\" + SLID_LAB + BOT_LAB][\"bf\"] = 1 # Sliding band bottom\n\n No_Magnets = pm_index - 6\n magnet_temp = 20.0 # Magnet Temperature Fixed for now\n Hcm20 = magnet_0.mat_type.mag.Hc\n Brm20 = magnet_0.mat_type.mag.Brm20\n kt = 0.01 # Br Temperature Coefficient fixed for now\n Br = Brm20 * (1 + kt * 0.01 * (magnet_temp - 20.0))\n magnet_permeability = magnet_0.mat_type.mag.mur_lin\n rho20_m = magnet_0.mat_type.elec.rho\n kt_m = 0.01 # Rho Temperature Coefficient fixed for now\n rho_m = rho20_m * (1 + kt_m * (magnet_temp - 20.0))\n conductivity_m = 0.0 * 1.0 / rho_m\n\n skip_steps = 1 # Fixed for now\n degrees_step = 1 # Fixed for now\n current_angle = 0 - pp * degrees_step * skip_steps\n angle_shift = self.angle_rotor_shift - self.angle_stator_shift\n rotor_init_pos = machine.comp_angle_rotor_initial() + angle_shift\n rotor_d_axis = machine.rotor.comp_angle_d_axis() * 180.0 / pi\n Ncond = 1 # Fixed for Now\n Cp = 1 # Fixed for Now\n qs = len(machine.stator.get_name_phase())\n\n fo.write(\n \"$ H_PM = {0} ! Magnetization [A/m]\\n\".format(round(Hcm20, 2))\n )\n fo.write(\"$ Shift = 2*pi/{0} ! N-phase machine [rad]\\n\".format(qs))\n fo.write(\n \"$ Gamma = {0}*pi/180 ! Current Angle [rad]\\n\".format(\n round(current_angle, 2)\n )\n )\n fo.write(\"$ Ncond = {0} ! Conductors per coil\\n\".format(Ncond))\n fo.write(\"$ Cp = {0} ! Parallel paths\\n\".format(Cp))\n fo.write(\"$ Is = {0} ! Stator current [A]\\n\".format(0.0))\n fo.write(\"$ Aaxis = {0} ! Axis Coil A [deg]\\n\".format(0.0))\n fo.write(\n \"$ Carea = {0} ! Coil Side Conductor Area [m2]\\n\".format(\n surf_wind\n )\n )\n\n for mm in range(1, No_Magnets + 1):\n fo.write(\n \"$ Mangle{0} = {1} ! Magnetization Angle [deg]\\n\".format(\n mm, round(Mangle[mm - 1], 2)\n )\n )\n\n fo.write(\"$ Nsteps = {0} !\\n\".format(2))\n fo.write(\"$ StepDegrees = {0} !\\n\".format(degrees_step))\n fo.write(\"$ DegreesPerSec = WM*180.0/pi !\\n\")\n fo.write(\"$ RotorInitPos = {}!\\n\".format(round(rotor_init_pos * 180.0 / pi, 2)))\n\n fo.write(\n \"\\nHeader\\n\"\n \"\\tCHECK KEYWORDS Warn\\n\"\n '\\tMesh DB \"{0}\"\\n'\n '\\tInclude Path \".\"\\n'\n '\\tResults Directory \"{1}\"\\n'\n \"End\\n\".format(elmermesh_folder, elmermesh_folder)\n )\n\n fo.write(\"\\nConstants\\n\" \"\\tPermittivity of Vacuum = 8.8542e-12\\n\" \"End\\n\")\n\n fo.write(\n \"\\nSimulation\\n\"\n \"\\tMax Output Level = 4\\n\"\n \"\\tCoordinate System = Cartesian 2D\\n\"\n \"\\tCoordinate Scaling = {0}\\n\"\n \"\\tSimulation Type = Transient\\n\"\n \"\\tTimestepping Method = BDF\\n\"\n \"\\tBDF Order = 2\\n\"\n # \"\\tTimestep Sizes = $ (StepDegrees / DegreesPerSec) ! sampling time\\n\"\n # \"\\tTimestep Intervals = $ Nsteps ! steps\\n\"\n # \"\\tOutput Intervals = 1\\n\"\n \"\\tTimestep Sizes({1}) = {2}\\n\"\n \"\\tTimestep Intervals({1}) = {3}\\n\"\n \"\\tUse Mesh Names = Logical True\\n\"\n \"End\\n\".format(1.0, timelen, timesize_str[1:-1], timeinterval_str[1:-1])\n )\n\n fo.write(\"\\n!--- MATERIALS ---\\n\")\n fo.write(\n \"Material 1\\n\"\n '\\tName = \"Air\"\\n'\n \"\\tRelative Permeability = 1\\n\"\n \"\\tElectric Conductivity = 0\\n\"\n \"End\\n\"\n )\n\n fo.write(\n \"\\nMaterial 2\\n\"\n '\\tName = \"Insulation\"\\n'\n \"\\tRelative Permeability = 1\\n\"\n \"\\tElectric Conductivity = 0\\n\"\n \"End\\n\"\n )\n\n fo.write(\n \"\\nMaterial 3\\n\"\n '\\tName = \"StatorMaterial\"\\n'\n '\\tInclude \"{0}\"\\n'\n \"End\\n\".format(stator_mat_file)\n )\n\n fo.write(\n \"\\nMaterial 4\\n\"\n '\\tName = \"RotorMaterial\"\\n'\n '\\tInclude \"{0}\"\\n'\n \"End\\n\".format(rotor_mat_file)\n )\n\n winding_temp = 20.0 # Fixed for Now\n rho20 = machine.stator.winding.conductor.cond_mat.elec.rho\n kt = 0.01 # Br Temperature Coefficient fixed for now\n rho = rho20 * (1 + kt * (winding_temp - 20.0))\n conductivity = 0.0 * 1.0 / rho\n\n fo.write(\n \"\\nMaterial 5\\n\"\n '\\tName = \"Copper\"\\n'\n \"\\tRelative Permeability = 1\\n\"\n \"\\tElectric Conductivity = {0}\\n\"\n \"End\\n\".format(round(conductivity, 2))\n )\n\n magnets_per_pole = No_Magnets # TO-DO: Assumes only one pole drawn\n for m in range(1, magnets_per_pole + 1):\n mat_number = 5 + m\n if magnetization_type == \"parallel\":\n fo.write(\n \"\\nMaterial {0}\\n\"\n '\\tName = \"PM_{1}\"\\n'\n \"\\tRelative Permeability = {2}\\n\"\n \"\\tMagnetization 1 = Variable time, timestep size\\n\"\n '\\t\\tReal MATC \"H_PM*cos(WM*(tx(0)-tx(1)) + {3}*pi/PP + {3}*pi + (RotorInitPos + Mangle{1})*pi/180)\"\\n'\n \"\\tMagnetization 2 = Variable time, timestep size\\n\"\n '\\t\\tReal MATC \"H_PM*sin(WM*(tx(0)-tx(1)) + {3}*pi/PP + {3}*pi + (RotorInitPos + Mangle{1})*pi/180)\"\\n'\n \"\\tElectric Conductivity = {4}\\n\"\n \"End\\n\".format(\n mat_number,\n m,\n magnet_permeability,\n int((m - 1) / magnets_per_pole),\n round(conductivity_m, 2),\n )\n )\n elif magnetization_type == \"radial\":\n fo.write(\n \"\\nMaterial {0}\\n\"\n '\\tName = \"PM_{1}\"\\n'\n \"\\tRelative Permeability = {2}\\n\"\n \"\\tMagnetization 1 = Variable Coordinate\\n\"\n '\\t\\tReal MATC \"H_PM*cos(atan2(tx(1),tx(0)) + {3}*pi + Mangle{1}*pi/180)\"\\n'\n \"\\tMagnetization 2 = Variable Coordinate\\n\"\n '\\t\\tReal MATC \"H_PM*sin(atan2(tx(1),tx(0)) + {3}*pi + Mangle{1}*pi/180)\"\\n'\n \"\\tElectric Conductivity = {4}\\n\"\n \"End\\n\".format(\n mat_number,\n m,\n magnet_permeability,\n m - 1,\n round(conductivity_m, 2),\n )\n )\n elif magnetization_type == \"perpendicular\":\n fo.write(\n \"\\nMaterial {0}\\n\"\n '\\tName = \"PM_{1}\"\\n'\n \"\\tRelative Permeability = {2}\\n\"\n \"\\tMagnetization 1 = Variable time, timestep size\\n\"\n '\\t\\tReal MATC \"H_PM*cos(WM*(tx(0)-tx(1)) + {3}*pi/PP + {3}*pi + Aaxis*pi/180 + (Mangle{1}*pi/180))\"\\n'\n \"\\tMagnetization 2 = Variable time, timestep size\\n\"\n '\\t\\tReal MATC \"H_PM*sin(WM*(tx(0)-tx(1)) + {3}*pi/PP + {3}*pi + Aaxis*pi/180 + (Mangle{1}*pi/180))\"\\n'\n \"\\tElectric Conductivity = {4}\\n\"\n \"End\\n\".format(\n mat_number,\n m,\n magnet_permeability,\n int((m - 1) / magnets_per_pole),\n round(conductivity_m, 2),\n )\n )\n else:\n fo.write(\n \"\\nMaterial {0}\\n\"\n '\\tName = \"PM_{1}\"\\n'\n \"\\tRelative Permeability = {2}\\n\"\n \"\\tElectric Conductivity = {4}\\n\"\n \"End\\n\".format(\n mat_number, m, magnet_permeability, round(conductivity_m, 2)\n )\n )\n\n fo.write(\"\\n!--- BODY FORCES ---\\n\")\n\n # fo.write(\"Body Force 1\\n\"\n # \"\\tName = \\\"BodyForce_Rotation\\\"\\n\"\n # \"\\t$omega = (180/pi)*WM\\n\"\n # \"\\tMesh Rotate 3 = Variable time, timestep size\\n\"\n # \"\\t\\tReal MATC \\\"omega*(tx(0)-tx(1)) + RotorInitPos\\\"\\n\"\n # \"End\\n\")\n fo.write(\n \"Body Force 1\\n\"\n '\\tName = \"BodyForce_Rotation\"\\n'\n \"\\tMesh Rotate 3 = Variable time\\n\"\n \"\\t\\tReal\\n\"\n \"\\t\\t0.0\\t\\t0.0\\n\"\n )\n for tt in range(1, timelen + 1):\n fo.write(\n \"\\t\\t{:.2e}\\t\\t{:.3f}\\n\".format(\n time[tt], angle_rotor[tt - 1] * 180.0 / pi\n )\n )\n fo.write(\"\\tEnd\\n\" \"End\\n\")\n\n # fo.write(\"Body Force 2\\n\"\n # \"\\tName = \\\"J_A_PLUS\\\"\\n\"\n # \"\\tCurrent Density = Variable time, timestep size\\n\"\n # \"\\t\\tReal MATC \\\"(Is/Carea) * ({0}/Cp) * sin(WE * (tx(0)-tx(1)) + Gamma)\\\"\\n\"\n # \"End\\n\".format(Ncond_Aplus))\n\n # fo.write(\"Body Force 3\\n\"\n # \"\\tName = \\\"J_A_MINUS\\\"\\n\"\n # \"\\tCurrent Density = Variable time, timestep size\\n\"\n # \"\\t\\tReal MATC \\\"-(Is/Carea) * ({0}/Cp) * sin(WE * (tx(0)-tx(1)) + Gamma)\\\"\\n\"\n # \"End\\n\".format(Ncond_Aminus))\n\n # fo.write(\"Body Force 4\\n\"\n # \"\\tName = \\\"J_B_PLUS\\\"\\n\"\n # \"\\tCurrent Density = Variable time, timestep size\\n\"\n # \"\\t\\tReal MATC \\\"(Is/Carea) * ({0}/Cp) * sin(WE * (tx(0)-tx(1)) - Shift + Gamma)\\\"\\n\"\n # \"End\\n\".format(Ncond_Bplus))\n #\n # fo.write(\"Body Force 5\\n\"\n # \"\\tName = \\\"J_B_MINUS\\\"\\n\"\n # \"\\tCurrent Density = Variable time, timestep size\\n\"\n # \"\\t\\tReal MATC \\\"-(Is/Carea) * ({0}/Cp) * sin(WE * (tx(0)-tx(1)) - Shift + Gamma)\\\"\\n\"\n # \"End\\n\".format(Ncond_Bminus))\n #\n # fo.write(\"Body Force 6\\n\"\n # \"\\tName = \\\"J_C_PLUS\\\"\\n\"\n # \"\\tCurrent Density = Variable time, timestep size\\n\"\n # \"\\t\\tReal MATC \\\"(Is/Carea) * ({0}/Cp) * sin(WE * (tx(0)-tx(1)) - 2*Shift + Gamma)\\\"\\n\"\n # \"End\\n\".format(Ncond_Cplus))\n #\n # fo.write(\"Body Force 7\\n\"\n # \"\\tName = \\\"J_C_MINUS\\\"\\n\"\n # \"\\tCurrent Density = Variable time, timestep size\\n\"\n # \"\\t\\tReal MATC \\\"-(Is/Carea) * ({0}/Cp) * sin(WE * (tx(0)-tx(1)) - 2*Shift + Gamma)\\\"\\n\"\n # \"End\\n\".format(Ncond_Cminus))\n #\n # fo.write(\"Body Force 8\\n\"\n # \"\\tName = \\\"J_D_PLUS\\\"\\n\"\n # \"\\tCurrent Density = Variable time, timestep size\\n\"\n # \"\\t\\tReal MATC \\\"(Is/Carea) * ({0}/Cp) * sin(WE * (tx(0)-tx(1)) - 3*Shift + Gamma)\\\"\\n\"\n # \"End\\n\".format(Ncond_Dplus))\n #\n # fo.write(\"Body Force 9\\n\"\n # \"\\tName = \\\"J_D_MINUS\\\"\\n\"\n # \"\\tCurrent Density = Variable time, timestep size\\n\"\n # \"\\t\\tReal MATC \\\"-(Is/Carea) * ({0}/Cp) * sin(WE * (tx(0)-tx(1)) - 3*Shift + Gamma)\\\"\\n\"\n # \"End\\n\".format(Ncond_Dminus))\n #\n # fo.write(\"Body Force 10\\n\"\n # \"\\tName = \\\"J_E_PLUS\\\"\\n\"\n # \"\\tCurrent Density = Variable time, timestep size\\n\"\n # \"\\t\\tReal MATC \\\"(Is/Carea) * ({0}/Cp) * sin(WE * (tx(0)-tx(1)) - 4*Shift + Gamma)\\\"\\n\"\n # \"End\\n\".format(Ncond_Eplus))\n #\n # fo.write(\"Body Force 11\\n\"\n # \"\\tName = \\\"J_E_MINUS\\\"\\n\"\n # \"\\tCurrent Density = Variable time, timestep size\\n\"\n # \"\\t\\tReal MATC \\\"-(Is/Carea) * ({0}/Cp) * sin(WE * (tx(0)-tx(1)) - 4*Shift + Gamma)\\\"\\n\"\n # \"End\\n\".format(Ncond_Eminus))\n #\n # fo.write(\"Body Force 12\\n\"\n # \"\\tName = \\\"J_F_PLUS\\\"\\n\"\n # \"\\tCurrent Density = Variable time, timestep size\\n\"\n # \"\\t\\tReal MATC \\\"(Is/Carea) * ({0}/Cp) * sin(WE * (tx(0)-tx(1)) - 5*Shift + Gamma)\\\"\\n\"\n # \"End\\n\".format(Ncond_Fplus))\n #\n # fo.write(\"Body Force 13\\n\"\n # \"\\tName = \\\"J_F_MINUS\\\"\\n\"\n # \"\\tCurrent Density = Variable time, timestep size\\n\"\n # \"\\t\\tReal MATC \\\"-(Is/Carea) * ({0}/Cp) * sin(WE * (tx(0)-tx(1)) - 5*Shift + Gamma)\\\"\\n\"\n # \"End\\n\".format(Ncond_Fminus))\n\n fo.write(\n \"Body Force 2\\n\"\n '\\tName = \"J_A_PLUS\"\\n'\n \"\\tCurrent Density = Variable time\\n\"\n \"\\t\\tReal\\n\"\n \"\\t\\t0.0\\t\\t0.0\\n\"\n )\n for tt in range(1, timelen + 1):\n fo.write(\n \"\\t\\t{:.2e}\\t\\t{:.3f}\\n\".format(\n time[tt], Ncond_Aplus * Is[0, tt - 1] / surf_wind\n )\n )\n fo.write(\"\\tEnd\\n\" \"End\\n\")\n\n fo.write(\n \"Body Force 3\\n\"\n '\\tName = \"J_A_MINUS\"\\n'\n \"\\tCurrent Density = Variable time\\n\"\n \"\\t\\tReal\\n\"\n \"\\t\\t0.0\\t\\t0.0\\n\"\n )\n for tt in range(1, timelen + 1):\n fo.write(\n \"\\t\\t{:.2e}\\t\\t{:.3f}\\n\".format(\n time[tt], -Ncond_Aminus * Is[0, tt - 1] / surf_wind\n )\n )\n fo.write(\"\\tEnd\\n\" \"End\\n\")\n\n fo.write(\n \"Body Force 4\\n\"\n '\\tName = \"J_B_PLUS\"\\n'\n \"\\tCurrent Density = Variable time\\n\"\n \"\\t\\tReal\\n\"\n \"\\t\\t0.0\\t\\t0.0\\n\"\n )\n for tt in range(1, timelen + 1):\n fo.write(\n \"\\t\\t{:.2e}\\t\\t{:.3f}\\n\".format(\n time[tt], Ncond_Bplus * Is[1, tt - 1] / surf_wind\n )\n )\n fo.write(\"\\tEnd\\n\" \"End\\n\")\n\n fo.write(\n \"Body Force 5\\n\"\n '\\tName = \"J_B_MINUS\"\\n'\n \"\\tCurrent Density = Variable time\\n\"\n \"\\t\\tReal\\n\"\n \"\\t\\t0.0\\t\\t0.0\\n\"\n )\n for tt in range(1, timelen + 1):\n fo.write(\n \"\\t\\t{:.2e}\\t\\t{:.3f}\\n\".format(\n time[tt], -Ncond_Bminus * Is[1, tt - 1] / surf_wind\n )\n )\n fo.write(\"\\tEnd\\n\" \"End\\n\")\n\n fo.write(\n \"Body Force 6\\n\"\n '\\tName = \"J_C_PLUS\"\\n'\n \"\\tCurrent Density = Variable time\\n\"\n \"\\t\\tReal\\n\"\n \"\\t\\t0.0\\t\\t0.0\\n\"\n )\n for tt in range(1, timelen + 1):\n fo.write(\n \"\\t\\t{:.2e}\\t\\t{:.3f}\\n\".format(\n time[tt], Ncond_Cplus * Is[2, tt - 1] / surf_wind\n )\n )\n fo.write(\"\\tEnd\\n\" \"End\\n\")\n\n fo.write(\n \"Body Force 7\\n\"\n '\\tName = \"J_C_MINUS\"\\n'\n \"\\tCurrent Density = Variable time\\n\"\n \"\\t\\tReal\\n\"\n \"\\t\\t0.0\\t\\t0.0\\n\"\n )\n for tt in range(1, timelen + 1):\n fo.write(\n \"\\t\\t{:.2e}\\t\\t{:.3f}\\n\".format(\n time[tt], -Ncond_Cminus * Is[2, tt - 1] / surf_wind\n )\n )\n fo.write(\"\\tEnd\\n\" \"End\\n\")\n\n fo.write(\"\\n!--- BODIES ---\\n\")\n for k, v in bodies.items():\n bid = bodies[k][\"id\"]\n beq = bodies[k][\"eq\"]\n bmat = bodies[k][\"mat\"]\n bf = bodies[k][\"bf\"]\n btg = bodies[k][\"tg\"]\n fo.write(\n \"Body {0}\\n\"\n \"\\tName = {1}\\n\"\n \"\\tEquation = {2}\\n\"\n \"\\tMaterial = {3}\\n\".format(bid, k, beq, bmat)\n )\n if bf is not None:\n fo.write(\"\\tBody Force = {0}\\n\".format(bf))\n if btg is not None:\n fo.write(\"\\tTorque Groups = Integer {0}\\n\".format(btg))\n if k == \"SB_INT\":\n fo.write(\n \"\\tR Inner = Real {0}\\n\" \"\\tR Outer = Real {1}\\n\".format(ror, sir)\n )\n fo.write(\"End\\n\\n\")\n\n fo.write(\n \"Equation 1\\n\"\n '\\tName = \"Model_Domain\"\\n'\n \"\\tActive Solvers(6) = 1 2 3 4 5 6\\n\"\n \"End\\n\"\n )\n\n fo.write(\"\\n!--- SOLVERS ---\\n\")\n fo.write(\n \"Solver 1\\n\"\n \"\\tExec Solver = Before Timestep\\n\"\n \"\\tEquation = MeshDeform\\n\"\n '\\tProcedure = \"RigidMeshMapper\" \"RigidMeshMapper\"\\n'\n \"End\\n\"\n )\n\n fo.write(\n \"\\nSolver 2\\n\"\n \"\\tEquation = MgDyn2D\\n\"\n '\\tProcedure = \"MagnetoDynamics2D\" \"MagnetoDynamics2D\"\\n'\n \"\\tExec Solver = Always\\n\"\n \"\\tVariable = A\\n\"\n )\n fo.write(\"\\tNonlinear System Convergence Tolerance = {0}\\n\".format(1e-6))\n fo.write(\"\\tNonlinear System Max Iterations = {0}\\n\".format(100))\n fo.write(\"\\tNonlinear System Min Iterations = {0}\\n\".format(1))\n fo.write(\"\\tNonlinear System Newton After Iterations = {0}\\n\".format(5))\n fo.write(\"\\tNonlinear System Relaxation Factor = {0}\\n\".format(0.9))\n fo.write(\n \"\\tNonlinear System Convergence Without Constraints = {0}\\n\".format(\n \"Logical True\"\n )\n )\n fo.write(\"\\tExport Lagrange Multiplier = {0}\\n\".format(\"Logical True\"))\n fo.write(\"\\tLinear System Abort Not Converged = {0}\\n\".format(\"Logical False\"))\n fo.write(\"\\tLinear System Solver = {0}\\n\".format(\"Direct\"))\n fo.write(\"\\tLinear System Direct Method = {0}\\n\".format(\"umfpack\"))\n fo.write(\"\\tOptimize Bandwidth = {0}\\n\".format(\"Logical True\"))\n fo.write(\"\\tLinear System Preconditioning = {0}\\n\".format(\"ILU2\"))\n fo.write(\"\\tLinear System Max Iterations = {0}\\n\".format(5000))\n fo.write(\"\\tLinear System Residual Output = {0}\\n\".format(20))\n fo.write(\"\\tLinear System Convergence Tolerance = {0}\\n\".format(1e-7))\n fo.write(\"\\tMortar BCs Additive = {0}\\n\".format(\"Logical True\"))\n fo.write(\"End\\n\")\n\n fo.write(\n \"\\nSolver 3\\n\"\n \"\\tExec Solver = Always\\n\"\n \"\\tEquation = CalcFields\\n\"\n '\\tPotential Variable = \"A\"\\n'\n '\\tProcedure = \"MagnetoDynamics\" \"MagnetoDynamicsCalcFields\"\\n'\n \"\\tCalculate Nodal Forces = Logical True\\n\"\n \"\\tCalculate Magnetic Vector Potential = Logical True\\n\"\n \"\\tCalculate Winding Voltage = Logical True\\n\"\n \"\\tCalculate Current Density = Logical True\\n\"\n \"\\tCalculate Maxwell Stress = Logical True\\n\"\n \"\\tCalculate JxB = Logical True\\n\"\n \"\\tCalculate Magnetic Field Strength = Logical True\\n\"\n \"End\\n\"\n )\n\n fo.write(\n \"\\nSolver 4\\n\"\n \"\\tExec Solver = After Timestep\\n\"\n '\\tProcedure = \"ResultOutputSolve\" \"ResultOutputSolver\"\\n'\n '\\tOutput File Name = \"{0}\"\\n'\n \"\\tVtu Format = True\\n\"\n \"\\tBinary Output = True\\n\"\n \"\\tSingle Precision = True\\n\"\n \"\\tSave Geometry Ids = True\\n\"\n \"\\tShow Variables = True\\n\"\n \"End\\n\".format(\"step\")\n )\n\n fo.write(\n \"\\nSolver 5\\n\"\n \"\\tExec Solver = After Timestep\\n\"\n \"\\tEquation = SaveLine\\n\"\n '\\tFilename = \"{0}\"\\n'\n '\\tProcedure = \"SaveData\" \"SaveLine\"\\n'\n \"\\tVariable 1 = Magnetic Flux Density 1\\n\"\n \"\\tVariable 2 = Magnetic Flux Density 2\\n\"\n \"\\tVariable 3 = Magnetic Flux Density 3\\n\"\n \"\\tVariable 4 = Magnetic Flux Density e 1\\n\"\n \"\\tVariable 5 = Magnetic Flux Density e 2\\n\"\n \"\\tVariable 6 = Magnetic Flux Density e 3\\n\"\n \"End\\n\".format(\"lines.dat\")\n )\n\n fo.write(\n \"\\nSolver 6\\n\"\n \"\\tExec Solver = After Timestep\\n\"\n '\\tFilename = \"{0}\"\\n'\n '\\tProcedure = \"SaveData\" \"SaveScalars\"\\n'\n \"\\tShow Norm Index = 1\\n\"\n \"End\\n\".format(\"scalars.dat\")\n )\n\n fo.write(\"\\n!--- BOUNDARIES ---\\n\")\n for k, v in boundaries.items():\n if k == \"VP0_BOUNDARY\":\n fo.write(\n \"Boundary Condition {0}\\n\"\n \"\\tName = {1}\\n\"\n \"\\tA = Real 0\\n\"\n \"End\\n\\n\".format(v, k)\n )\n elif k == \"MASTER_STATOR_BOUNDARY\":\n for k1, v1 in boundaries.items():\n if k1 == \"SLAVE_STATOR_BOUNDARY\":\n slave = v1\n break\n if not self.is_periodicity_a:\n fo.write(\n \"Boundary Condition {0}\\n\"\n \"\\tName = {1}\\n\"\n \"\\tMortar BC = Integer {2}\\n\"\n \"\\tMortar BC Static = Logical True\\n\"\n \"\\tRadial Projector = Logical True\\n\"\n \"\\tGalerkin Projector = Logical True\\n\"\n \"End\\n\\n\".format(v, k, slave)\n )\n else:\n fo.write(\n \"Boundary Condition {0}\\n\"\n \"\\tName = {1}\\n\"\n \"\\tMortar BC = Integer {2}\\n\"\n \"\\tMortar BC Static = Logical True\\n\"\n \"\\tAnti Radial Projector = Logical True\\n\"\n \"\\tGalerkin Projector = Logical True\\n\"\n \"End\\n\\n\".format(v, k, slave)\n )\n elif k == \"MASTER_ROTOR_BOUNDARY\":\n for k1, v1 in boundaries.items():\n if k1 == \"SLAVE_ROTOR_BOUNDARY\":\n slave = v1\n break\n if not self.is_periodicity_a:\n fo.write(\n \"Boundary Condition {0}\\n\"\n \"\\tName = {1}\\n\"\n \"\\tMortar BC = Integer {2}\\n\"\n \"\\tMortar BC Static = Logical True\\n\"\n \"\\tRadial Projector = Logical True\\n\"\n \"\\tGalerkin Projector = Logical True\\n\"\n \"End\\n\\n\".format(v, k, slave)\n )\n else:\n fo.write(\n \"Boundary Condition {0}\\n\"\n \"\\tName = {1}\\n\"\n \"\\tMortar BC = Integer {2}\\n\"\n \"\\tMortar BC Static = Logical True\\n\"\n \"\\tAnti Radial Projector = Logical True\\n\"\n \"\\tGalerkin Projector = Logical True\\n\"\n \"End\\n\\n\".format(v, k, slave)\n )\n elif k == \"SB_STATOR_BOUNDARY\":\n for k1, v1 in boundaries.items():\n if k1 == \"SB_ROTOR_BOUNDARY\":\n slave = v1\n break\n if not self.is_periodicity_a:\n fo.write(\n \"Boundary Condition {0}\\n\"\n \"\\tName = {1}\\n\"\n \"\\tMortar BC = Integer {2}\\n\"\n \"\\tRotational Projector = Logical True\\n\"\n \"\\tGalerkin Projector = Logical True\\n\"\n \"End\\n\\n\".format(v, k, slave)\n )\n else:\n fo.write(\n \"Boundary Condition {0}\\n\"\n \"\\tName = {1}\\n\"\n \"\\tMortar BC = Integer {2}\\n\"\n \"\\tAnti Rotational Projector = Logical True\\n\"\n \"\\tGalerkin Projector = Logical True\\n\"\n \"End\\n\\n\".format(v, k, slave)\n )\n elif k == \"AIRGAP_ARC_BOUNDARY\":\n fo.write(\n \"Boundary Condition {0}\\n\"\n \"\\tName = {1}\\n\"\n \"\\tSave Line = True\\n\"\n \"End\\n\\n\".format(v, k)\n )\n else:\n fo.write(\n \"Boundary Condition {0}\\n\" \"\\tName = {1}\\n\" \"End\\n\\n\".format(v, k)\n )\n\n # setup Elmer solver\n # ElmerSolver v8.4 must be installed and in the PATH\n\n elmer_settings = join(project_name, \"pyleecan_elmer.sif\")\n ElmerSolver_binary = get_path_binary(\"ElmerSolver\")\n cmd_elmersolver = [\n ElmerSolver_binary,\n elmer_settings,\n ]\n self.get_logger().info(\n \"Calling ElmerSolver: \" + \" \".join(map(str, cmd_elmersolver))\n )\n elmersolver = subprocess.Popen(\n cmd_elmersolver, stdout=subprocess.PIPE, stderr=subprocess.PIPE\n )\n (stdout, stderr) = elmersolver.communicate()\n elmersolver.wait()\n self.get_logger().info(stdout.decode(\"UTF-8\"))\n if elmersolver.returncode != 0:\n self.get_logger().info(\"ElmerSolver [Error]: \" + stderr.decode(\"UTF-8\"))\n return False\n elmersolver.terminate()\n self.get_logger().info(\"ElmerSolver call complete!\")\n\n self.get_meshsolution(output)\n\n Na = angle.size\n Nt = time.size - 1\n\n # Loading parameters for readibility\n L1 = output.simu.machine.stator.comp_length()\n save_path = self.get_path_save(output)\n\n scalars_file = join(elmermesh_folder, \"scalars.dat\")\n ecp, mfe, agt, iv, im, tq = loadtxt(\n scalars_file, unpack=True, usecols=(0, 1, 2, 3, 4, 5)\n )\n # ecp: eddy current power\n # mfe: magnetic field energy\n # agt: air gap torque\n # iv: inertial volume\n # im: inertial moment\n # tq: group 1 torque\n\n # TODO Load Air gap flux density\n\n # FEM_dict = output.mag.FEM_dict\n #\n if (\n hasattr(output.simu.machine.stator, \"winding\")\n and output.simu.machine.stator.winding is not None\n ):\n qs = output.simu.machine.stator.winding.qs # Winding phase number\n Phi_wind_stator = zeros((Nt, qs))\n else:\n Phi_wind_stator = None\n\n # Initialize results matrix\n Br = zeros((Nt, Na))\n Bt = zeros((Nt, Na))\n Bz = zeros((Nt, Na))\n Tem = tq * sym * L1\n\n # Phi_wind_stator = zeros((Nt, qs))\n\n # compute the data for each time step\n # TODO Other than FEMM, in Elmer I think it's possible to compute\n # all time steps at once\n self.get_logger().debug(\"Solving Simulation\")\n\n # run the computation\n if self.nb_worker > 1:\n # TODO run solver in parallel\n pass\n else:\n # TODO run solver 'normal'\n pass\n\n # get the air gap flux result\n # TODO add function (or method)\n # ii -> Time, jj -> Angle\n # Br[ii, jj], Bt[ii, jj] = get_airgap_flux()\n\n # get the torque\n # TODO add function (or method)\n # Tem[ii] = comp_Elmer_torque(FEM_dict, sym=sym)\n\n # flux linkage computation\n # if Phi_wind_stator is not None:\n # # TODO\n # # Phi_wind[ii, :] = comp_Elmer_Phi_wind()\n # pass\n\n return Br, Bt, Bz, Tem, Phi_wind_stator\n", "meta": {"hexsha": "cb07f4c86712da036c67972ccb3e8df754e09a35", "size": 40725, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyleecan/Methods/Simulation/MagElmer/solve_FEA.py", "max_stars_repo_name": "nnassar98/pyleecan", "max_stars_repo_head_hexsha": "3a6ffe14ab46e90dc0b2855386623833c622b95e", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2020-03-05T15:22:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-02T15:26:08.000Z", "max_issues_repo_path": "pyleecan/Methods/Simulation/MagElmer/solve_FEA.py", "max_issues_repo_name": "thalesmaoa/pyleecan", "max_issues_repo_head_hexsha": "c4fdc6362fdeba3d0766d5d1df3ff9c97c3f9fa3", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 8, "max_issues_repo_issues_event_min_datetime": "2020-07-09T07:43:01.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-08T12:52:06.000Z", "max_forks_repo_path": "pyleecan/Methods/Simulation/MagElmer/solve_FEA.py", "max_forks_repo_name": "thalesmaoa/pyleecan", "max_forks_repo_head_hexsha": "c4fdc6362fdeba3d0766d5d1df3ff9c97c3f9fa3", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2019-12-23T12:38:01.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-07T10:47:48.000Z", "avg_line_length": 39.6157587549, "max_line_length": 124, "alphanum_fraction": 0.4714794352, "include": true, "reason": "import numpy,from numpy", "num_tokens": 10699, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5736784074525096, "lm_q2_score": 0.34158248603300034, "lm_q1q2_score": 0.19595849660108075}} {"text": "\"\"\"\nThis is a module containing functions and classes for imaging propagation with HCIPy, for now LUVOIR A.\n\"\"\"\nimport os\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom matplotlib.colors import LogNorm\nfrom astropy.io import fits\nimport hcipy as hc\nfrom hcipy.optics.segmented_mirror import SegmentedMirror\n\nfrom config import CONFIG_INI\n\n\nclass SegmentedTelescopeAPLC:\n \"\"\" A segmented telescope with an APLC and actuated segments.\n\n Parameters:\n ----------\n aper : Field\n Telescope aperture.\n indexed_aperture : Field\n The *indexed* segmented aperture of the mirror, all pixels each segment being filled with its number for\n segment identification. Segment gaps must be strictly zero.\n seg_pos : CartesianGrid(UnstructuredCoords)\n Segment positions of the aperture.\n apod : Field\n Apodizer\n lyots : Field\n Lyot stop\n fpm : fpm\n Focal plane mask\n focal_grid :\n Focal plane grid to put final image on\n params : dict\n wavelength, diameter, image size in lambda/D, FPM radius\n \"\"\"\n\n def __init__(self, aper, indexed_aperture, seg_pos, apod, lyotst, fpm, focal_grid, params):\n self.sm = SegmentedMirror(indexed_aperture=indexed_aperture, seg_pos=seg_pos)\n self.aper = aper\n self.apodizer = apod\n self.lyotstop = lyotst\n self.fpm = fpm #TODO: this is not actually used inside this class\n self.wvln = params['wavelength']\n self.diam = params['diameter']\n self.imlamD = params['imlamD']\n self.fpm_rad = params['fpm_rad']\n self.lamDrad = self.wvln / self.diam\n self.coro = hc.LyotCoronagraph(indexed_aperture.grid, fpm, lyotst)\n self.prop = hc.FraunhoferPropagator(indexed_aperture.grid, focal_grid)\n self.coro_no_ls = hc.LyotCoronagraph(indexed_aperture.grid, fpm)\n self.wf_aper = hc.Wavefront(aper, wavelength=self.wvln)\n self.focal_det = focal_grid\n\n def calc_psf(self, ref=False, display_intermediate=False, return_intermediate=None):\n \"\"\"Calculate the PSF of the segmented telescope, normalized to contrast units.\n\n Parameters:\n ----------\n ref : bool\n Keyword for additionally returning the refrence PSF without the FPM.\n display_intermediate : bool\n Keyword for display of all planes.\n return_intermediate : string\n Either 'intensity', return the intensity in all planes; except phase on the SM (first plane)\n or 'efield', return the E-fields in all planes. Default none.\n Returns:\n --------\n wf_im_coro.intensity : Field\n Coronagraphic image, normalized to contrast units by max of reference image (even when ref\n not returned).\n wf_im_ref.intensity : Field, optional\n Reference image without FPM.\n intermediates : dict of Fields, optional\n Intermediate plane intensity images; except for full wavefront on segmented mirror.\n wf_im_coro : Wavefront\n Wavefront in last focal plane.\n wf_im_ref : Wavefront, optional\n Wavefront of reference image without FPM.\n intermediates : dict of Wavefronts, optional\n Intermediate plane E-fields; except intensity in focal plane after FPM.\n \"\"\"\n\n # Create fake FPM for plotting\n fpm_plot = 1 - hc.circular_aperture(2 * self.fpm_rad * self.lamDrad)(self.focal_det)\n\n # Create apodozer as hc.Apodizer() object to be able to propagate through it\n apod_prop = hc.Apodizer(self.apodizer)\n\n # Calculate all wavefronts of the full propagation\n wf_sm = self.sm(self.wf_aper)\n wf_apod = apod_prop(wf_sm)\n wf_lyot = self.coro(wf_apod)\n wf_im_coro = self.prop(wf_lyot)\n\n # Wavefronts in extra planes\n wf_before_fpm = self.prop(wf_apod)\n int_after_fpm = np.log10(wf_before_fpm.intensity / wf_before_fpm.intensity.max()) * fpm_plot # this is the intensity straight\n wf_before_lyot = self.coro_no_ls(wf_apod)\n\n # Wavefronts of the reference propagation\n wf_ref_pup = hc.Wavefront(self.aper * self.apodizer * self.lyotstop, wavelength=self.wvln)\n wf_im_ref = self.prop(wf_ref_pup)\n\n # Display intermediate planes\n if display_intermediate:\n\n plt.figure(figsize=(15, 15))\n\n plt.subplot(331)\n hc.imshow_field(wf_sm.phase, mask=self.aper, cmap='RdBu')\n plt.title('Seg aperture phase')\n\n plt.subplot(332)\n hc.imshow_field(wf_apod.intensity, cmap='inferno')\n plt.title('Apodizer')\n\n plt.subplot(333)\n hc.imshow_field(wf_before_fpm.intensity / wf_before_fpm.intensity.max(), norm=LogNorm(), cmap='inferno')\n plt.title('Before FPM')\n\n plt.subplot(334)\n hc.imshow_field(int_after_fpm / wf_before_fpm.intensity.max(), cmap='inferno')\n plt.title('After FPM')\n\n plt.subplot(335)\n hc.imshow_field(wf_before_lyot.intensity / wf_before_lyot.intensity.max(), norm=LogNorm(vmin=1e-3, vmax=1),\n cmap='inferno')\n plt.title('Before Lyot stop')\n\n plt.subplot(336)\n hc.imshow_field(wf_lyot.intensity / wf_lyot.intensity.max(), norm=LogNorm(vmin=1e-3, vmax=1),\n cmap='inferno', mask=self.lyotstop)\n plt.title('After Lyot stop')\n\n plt.subplot(337)\n hc.imshow_field(wf_im_coro.intensity / wf_im_ref.intensity.max(), norm=LogNorm(vmin=1e-10, vmax=1e-3),\n cmap='inferno')\n plt.title('Final image')\n plt.colorbar()\n\n if return_intermediate == 'intensity':\n\n # Return the intensity in all planes; except phase on the SM (first plane)\n intermediates = {'seg_mirror': wf_sm.phase,\n 'apod': wf_apod.intensity,\n 'before_fpm': wf_before_fpm.intensity / wf_before_fpm.intensity.max(),\n 'after_fpm': int_after_fpm / wf_before_fpm.intensity.max(),\n 'before_lyot': wf_before_lyot.intensity / wf_before_lyot.intensity.max(),\n 'after_lyot': wf_lyot.intensity / wf_lyot.intensity.max()}\n\n if ref:\n return wf_im_coro.intensity, wf_im_ref.intensity, intermediates\n else:\n return wf_im_coro.intensity, intermediates\n\n if return_intermediate == 'efield':\n\n # Return the E-fields in all planes; except intensity in focal plane after FPM\n intermediates = {'seg_mirror': wf_sm,\n 'apod': wf_apod,\n 'before_fpm': wf_before_fpm,\n 'after_fpm': int_after_fpm,\n 'before_lyot': wf_before_lyot,\n 'after_lyot': wf_lyot}\n\n if ref:\n return wf_im_coro, wf_im_ref, intermediates\n else:\n return wf_im_coro, intermediates\n\n if ref:\n return wf_im_coro.intensity, wf_im_ref.intensity\n\n return wf_im_coro.intensity\n\n def flatten(self):\n self.sm.flatten()\n\n def set_segment(self, segid, piston, tip, tilt):\n self.sm.set_segment(segid, piston, tip, tilt)\n\n def apply_aberrations(self, aber_array):\n for vals in aber_array:\n self.sm.set_segment(vals[0], vals[1], vals[2], vals[3])\n\n def forward(self, wavefront):\n raise NotImplementedError()\n\n def backward(self, wavefront):\n raise NotImplementedError()\n\n\nclass LuvoirAPLC(SegmentedTelescopeAPLC):\n \"\"\" Simple E2E simulator for LUVOIR A (with APLC).\n\n Parameters:\n ----------\n input dir : string\n Path to input files: apodizer, aperture, indexed aperture, Lyot stop.\n apod_design : string\n Choice of apodizer design from May 2019 delivery. \"small\", \"medium\" or \"large\".\n \"\"\"\n def __init__(self, input_dir, apod_design, samp):\n self.nseg = 120 # FIXME: this should not be hard-coded\n self.wvln = CONFIG_INI.getfloat('LUVOIR', 'lambda') * 1e-9 # m\n self.diam = 15. # m # FIXME: this should not be hard-coded\n self.sampling = samp\n self.lam_over_d = self.wvln / self.diam\n self.apod_dict = {'small': {'pxsize': 1000, 'fpm_rad': 3.5, 'fpm_px': 150, 'iwa': 3.4, 'owa': 12.,\n 'fname': '0_LUVOIR_N1000_FPM350M0150_IWA0340_OWA01200_C10_BW10_Nlam5_LS_IDD0120_OD0982_no_ls_struts.fits'},\n 'medium': {'pxsize': 1000, 'fpm_rad': 6.82, 'fpm_px': 250, 'iwa': 6.72, 'owa': 23.72,\n 'fname': '0_LUVOIR_N1000_FPM682M0250_IWA0672_OWA02372_C10_BW10_Nlam5_LS_IDD0120_OD0982_no_ls_struts.fits'},\n 'large': {'pxsize': 1000, 'fpm_rad': 13.38, 'fpm_px': 400, 'iwa': 13.28, 'owa': 46.88,\n 'fname': '0_LUVOIR_N1000_FPM1338M0400_IWA1328_OWA04688_C10_BW10_Nlam5_LS_IDD0120_OD0982_no_ls_struts.fits'}}\n self.imlamD = 1.2*self.apod_dict[apod_design]['owa']\n\n # Pupil plane optics\n aper_path = 'inputs/TelAp_LUVOIR_gap_pad01_bw_ovsamp04_N1000.fits'\n aper_ind_path = 'inputs/TelAp_LUVOIR_gap_pad01_bw_ovsamp04_N1000_indexed.fits'\n apod_path = os.path.join(input_dir, 'luvoir_stdt_baseline_bw10', apod_design + '_fpm', 'solutions',\n self.apod_dict[apod_design]['fname'])\n ls_fname = 'inputs/LS_LUVOIR_ID0120_OD0982_no_struts_gy_ovsamp4_N1000.fits'\n\n pup_read = hc.read_fits(os.path.join(input_dir, aper_path))\n aper_ind_read = hc.read_fits(os.path.join(input_dir, aper_ind_path))\n apod_read = hc.read_fits(os.path.join(input_dir, apod_path))\n ls_read = hc.read_fits(os.path.join(input_dir, ls_fname))\n\n pupil_grid = hc.make_pupil_grid(dims=self.apod_dict[apod_design]['pxsize'], diameter=self.diam)\n\n self.aperture = hc.Field(pup_read.ravel(), pupil_grid)\n self.aper_ind = hc.Field(aper_ind_read.ravel(), pupil_grid)\n self.apod = hc.Field(apod_read.ravel(), pupil_grid)\n self.ls = hc.Field(ls_read.ravel(), pupil_grid)\n\n # Load segment positions from fits header\n hdr = fits.getheader(os.path.join(input_dir, aper_ind_path))\n\n poslist = []\n for i in range(self.nseg):\n segname = 'SEG' + str(i + 1)\n xin = hdr[segname + '_X']\n yin = hdr[segname + '_Y']\n poslist.append((xin, yin))\n\n poslist = np.transpose(np.array(poslist))\n self.seg_pos = hc.CartesianGrid(poslist)\n\n # Focal plane mask\n samp_foc = self.apod_dict[apod_design]['fpm_px'] / (self.apod_dict[apod_design]['fpm_rad'] * 2)\n focal_grid_fpm = hc.make_focal_grid(pupil_grid=pupil_grid, q=samp_foc,\n num_airy=self.apod_dict[apod_design]['fpm_rad'], wavelength=self.wvln)\n self.fpm = 1 - hc.circular_aperture(2*self.apod_dict[apod_design]['fpm_rad']*self.lam_over_d)(focal_grid_fpm)\n\n # Final focal plane grid (detector)\n self.focal_det = hc.make_focal_grid(pupil_grid=pupil_grid, q=self.sampling, num_airy=self.imlamD, wavelength=self.wvln)\n\n luvoir_params = {'wavelength': self.wvln, 'diameter': self.diam, 'imlamD': self.imlamD,\n 'fpm_rad': self.apod_dict[apod_design]['fpm_rad']}\n\n # Initialize the general segmented telescope with APLC class, includes the SM\n super().__init__(aper=self.aperture, indexed_aperture=self.aper_ind, seg_pos=self.seg_pos, apod=self.apod,\n lyotst=self.ls, fpm=self.fpm, focal_grid=self.focal_det, params=luvoir_params)\n\n # Make dark hole mask\n dh_outer = hc.circular_aperture(2 * self.apod_dict[apod_design]['owa'] * self.lam_over_d)(\n self.focal_det)\n dh_inner = hc.circular_aperture(2 * self.apod_dict[apod_design]['iwa'] * self.lam_over_d)(\n self.focal_det)\n self.dh_mask = (dh_outer - dh_inner).astype('bool')\n\n # Propagators\n self.coro = hc.LyotCoronagraph(pupil_grid, self.fpm, self.ls)\n self.prop = hc.FraunhoferPropagator(pupil_grid, self.focal_det)\n self.coro_no_ls = hc.LyotCoronagraph(pupil_grid, self.fpm)\n #TODO: these three propagators should actually happen in the super init\n # -> how are self.aper_ind and pupil_grid connected?\n", "meta": {"hexsha": "2070fa25ccb872c39ecdf7a4979b6d46e427e3a4", "size": 12550, "ext": "py", "lang": "Python", "max_stars_repo_path": "pastis/e2e_simulators/luvoir_imaging.py", "max_stars_repo_name": "ivalaginja/PASTIS", "max_stars_repo_head_hexsha": "ed52a4c838c93cd933f7a8c0bf52113cddd5a415", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pastis/e2e_simulators/luvoir_imaging.py", "max_issues_repo_name": "ivalaginja/PASTIS", "max_issues_repo_head_hexsha": "ed52a4c838c93cd933f7a8c0bf52113cddd5a415", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pastis/e2e_simulators/luvoir_imaging.py", "max_forks_repo_name": "ivalaginja/PASTIS", "max_forks_repo_head_hexsha": "ed52a4c838c93cd933f7a8c0bf52113cddd5a415", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.8214285714, "max_line_length": 144, "alphanum_fraction": 0.6302788845, "include": true, "reason": "import numpy,from astropy", "num_tokens": 3237, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073655352404, "lm_q2_score": 0.35577490717496246, "lm_q1q2_score": 0.19589228436315076}} {"text": "\"\"\" Class for correlating galaxies and IGM within a given field on the sky\n\"\"\"\nfrom __future__ import print_function, absolute_import, division, unicode_literals\n\nimport numpy as np\nimport warnings\nimport pdb\n\nimport astropy\nfrom astropy import units as u\nfrom astropy.units import Quantity\nfrom astropy.coordinates import SkyCoord\nfrom astropy import constants as const\nfrom astropy.cosmology import Planck15\n\nimport pyigm.field.utils as pfu\nfrom pyigm.utils import calc_rho\n\n#from xastropy.xutils import xdebug as xdb\n\n\nclass IgmGalaxyField(object): \n \"\"\" Class for a field associating galaxies to the IGM/CGM\n\n Parameters\n ----------\n radec : tuple or SkyCoord\n (RA,DEC) in deg or astropy.coordinate\n name : str; optional\n Default is set from sexagesimal coordinates\n zem : float; optional\n Redshift of background source (e.g., QSO)\n cosmo : Cosmology; optional\n Default is astropy.cosmology.Planck15\n\n \"\"\"\n\n # Initialize\n def __init__(self, radec, name=None, zem=None, cosmo=None, verbose=False):\n # coord\n if isinstance(radec, (tuple)):\n self.coord = SkyCoord(ra=radec[0], dec=radec[1])\n elif isinstance(radec, SkyCoord):\n self.coord = radec\n\n # Field\n if name is None:\n self.name = 'IGMFIELD_J{:s}{:s}'.format(\n self.coord.ra.to_string(unit=u.hour, pad=True),\n self.coord.dec.to_string(pad=True, alwayssign=True))\n self.name = name\n\n # Cosmology\n if cosmo is None:\n cosmo = Planck15\n if verbose is True:\n print('IgmGalxyField: Using Planck15 cosmology')\n self.cosmo = cosmo\n\n # Init\n self.zem = zem\n self.igm = None\n self.targets = None\n self.galaxies = None\n self.observing = None\n self.selection = None\n\n def calc_rhoimpact(self, obj, comoving=True, los_coord=None):\n \"\"\"Calculate impact parameter from LOS RA/DEC for a set of objects\n\n Parameters\n ----------\n obj : Table or dict\n Anything that takes 'Z', and 'RA','DEC' in degrees\n Sources for calculation\n comoving : bool, optional\n If True then comoving, else physical\n los_radec : SkyCoord, optional\n Defaults to field RA/DEC\n\n\n Returns\n -------\n rho : Quantity (array usually)\n Impact parameter(s) in kpc\n \"\"\"\n if los_coord is None:\n los_coord = self.coord\n # Coord\n ora = obj['RA']\n odec = obj['DEC']\n #if ((isinstance(obj['RA'], Quantity)) |\n # (isinstance(obj['RA'],astropy.table.column.MaskedColumn)) |\n # (isinstance(obj['RA'], astropy.table.column.Column))):\n # ora = obj['RA']\n # odec = obj['DEC']\n #else:\n # ora = obj['RA']*u.deg\n # odec = obj['DEC']*u.deg\n o_coord = SkyCoord(ra=ora, dec=odec, unit='deg')\n # Calculate\n rho, ang_sep = calc_rho(los_coord, o_coord, obj['Z'], self.cosmo, comoving=comoving)\n # Return\n return rho\n\n def get_associated_galaxies(self, z, los_coord=None, R=300*u.kpc, dv_tol=500*u.km/u.s):\n \"\"\"Return a Table of associated galaxies for a given redshift and separation\n\n Parameters\n ----------\n z : float\n Redshift for association (usually IGM/CGM absorber redshift)\n R : Quantity\n Radius of impact parameter for association [300kpc]\n dv_tol : Quantity\n Velocity window for association [500km/s]\n los_coord : SkyCoord, optional\n Line-of-sight coordinates\n\n Returns\n -------\n assoc_gal : Table\n Table of associated galaxies (if any)\n rho : Quantity\n Impact parameters [kpc]\n \"\"\"\n # los_radec\n if los_coord is None:\n los_coord = self.coord\n # Cut on z first\n dv_gal = const.c.to('km/s') * (self.galaxies['Z']-z)/(1+z) # Approximate\n gdz = np.where(np.abs(dv_gal) 0:\n mt2 = np.where(subtab['MASK_NAME'][have_mask]==mask)\n tmsk[have_mask[mt2]] = True\n obs_dict[mask] = obs_dates\n # Finish\n return subtab[tmsk], obs_dict, gdsep[tmsk]\n\n def get_unobserved(self, theta=None):\n \"\"\"Generate a Table of unobserved targets within an angular distance\n\n Parameters\n ----------\n theta : Quantity, optional\n Angular distance\n\n Returns\n -------\n unobs_targ : Table\n Sub-table of targets that have been not been observed within theta (if given)\n \"\"\"\n if (self.targets is None) or (self.observing is None):\n raise ValueError('IgmGalaxyField: Need to fill the target and/or observing table first!')\n # Trim on angular cut first\n if theta is None:\n targ_coord = SkyCoord(ra=self.targets['TARG_RA']*u.deg,\n dec=self.targets['TARG_DEC']*u.deg)\n sep = self.coord.separation(targ_coord)\n gdsep = np.where(sep < theta)[0]\n if len(gdsep) == 0:\n return None\n # Set all to False to start\n subtab = self.targets[gdsep]\n else:\n subtab = self.targets\n tmsk = np.array([True]*len(subtab))\n # Grab observed (short cut!)\n obs_tab, odict, _ = self.get_observed(theta, subtab=subtab)\n # Remove those\n for kk, row in enumerate(subtab):\n if row['TARG_RA'] in obs_tab['TARG_RA']: # Could use DEC too\n tmsk[kk] = False\n # Return\n return subtab[tmsk]\n\n\n def get_mask_obsdate(self, mask_name):\n \"\"\"Given a mask name, find the observing dates\n\n Parameters\n ----------\n mask_name : str\n Name of the mask\n\n Returns\n -------\n obs_dates : List\n List of the observing dates (can be empty)\n \"\"\"\n if self.observing is None:\n raise ValueError('Need to fill observing info!')\n #\n mt = np.where(self.observing['MASK_NAME'] == mask_name)[0]\n if self.observing['DATE_OBS'].mask[mt[0]]:\n return []\n obs_dates = [self.observing['DATE_OBS'][imt] for imt in mt]\n # Return\n return obs_dates\n\n\n def clean_duplicates(self, table, tol=1*u.arcsec, method='first'):\n \"\"\" Clean duplicates in table based on (ra,dec) coordinates\n\n Parameters\n ----------\n table : Table\n Table to clean duplicates based on (ra, dec)\n tol : Angle, optional\n Angular tolerance for considering duplicates\n method : str, optional\n Method to use. Current options are:\n ``'first'``: if duplicates exist keep only the first one\n\n Returns\n -------\n cleaned_table : Table\n A version of `table` without duplicates\n \"\"\"\n\n # TODO: add more methods for merging/cleaning duplicates\n\n if method not in ['first']:\n raise RuntimeError('Not ready for this method=`{}`'.format(method))\n\n isdup, idx, dcoord = pfu.check_dup_table(table, tol=tol)\n dup_inds = np.where(isdup == True)[0]\n keep = []\n\n if method == 'first':\n for ii in dup_inds:\n mtch = np.where(dcoord[ii].separation(dcoord) < tol)[0]\n keep.append(min(mtch))\n\n first_dup = np.unique(np.array(keep))\n\n no_dup = np.arange(len(idx))[~isdup]\n clean_inds = np.append(no_dup, first_dup)\n clean_inds = np.sort(clean_inds)\n\n #return\n return table[clean_inds]\n\n # \n def __repr__(self):\n return ('<{:s}: {:s} {:s} {:s}>'.format(\n self.__class__.__name__,\n self.name,\n self.coord.ra.to_string(unit=u.hour, sep=':', pad=True),\n self.coord.dec.to_string(sep=':', pad=True, alwayssign=True)))\n\n\n\n\n", "meta": {"hexsha": "e3316c60661388557937df9f9cf5f68cf89ffb88", "size": 10504, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyigm/field/igmfield.py", "max_stars_repo_name": "pyigm/pyigm", "max_stars_repo_head_hexsha": "8b4bc7f7f1c9f1c280720a4cc0693cd7cb79e9cb", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 16, "max_stars_repo_stars_event_min_datetime": "2016-02-12T19:03:38.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-11T15:16:25.000Z", "max_issues_repo_path": "pyigm/field/igmfield.py", "max_issues_repo_name": "pyigm/pyigm", "max_issues_repo_head_hexsha": "8b4bc7f7f1c9f1c280720a4cc0693cd7cb79e9cb", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 204, "max_issues_repo_issues_event_min_datetime": "2015-12-06T13:40:05.000Z", "max_issues_repo_issues_event_max_datetime": "2021-02-11T21:48:39.000Z", "max_forks_repo_path": "pyigm/field/igmfield.py", "max_forks_repo_name": "pyigm/pyigm", "max_forks_repo_head_hexsha": "8b4bc7f7f1c9f1c280720a4cc0693cd7cb79e9cb", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 16, "max_forks_repo_forks_event_min_datetime": "2015-12-06T23:27:49.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-01T10:08:24.000Z", "avg_line_length": 32.722741433, "max_line_length": 101, "alphanum_fraction": 0.5621667936, "include": true, "reason": "import numpy,import astropy,from astropy", "num_tokens": 2493, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073655352404, "lm_q2_score": 0.3557748935136304, "lm_q1q2_score": 0.1958922768411207}} {"text": "#!/usr/bin/env python3\nimport sys\nimport os\nimport json\nimport networkx as nx\nimport math\nfrom networkx.algorithms import approximation as approx\nimport time\nfrom itertools import groupby as g\nfrom operator import itemgetter\nfrom graphFunctions import * \nimport csv\nimport configparser\nimport logging\n#from networkx.readwrite import d3_js\nfrom networkx.readwrite import json_graph\n#import mpld3\n#mpld3.enable_notebook()\n#from mpld3 import plugins\n#import matplotlib.pyplot as plt\n\n\nConfig = configparser.ConfigParser()\nConfig.read(\"../etc/config.cfg\")\n\nlogging.basicConfig(filename=Config.get(\"Debug\", \"Logfile\"),level=logging.INFO, format='%(asctime)s %(message)s')\n\ndebug = Config.getboolean(\"Debug\", \"DebugInfo\")\nstandardDirectory = Config.get(\"Path\", \"StandardDirectory\")\nfilename = \"\"\nlastcomm = \"\"\noutputfile = \"\"\nmaxEdgeValue = Config.getint(\"Graph\", \"maxEdgeValue\");\n# Values for Edge creation\ncreateEdgePercent = Config.getint(\"Graph\", \"createEdgePercent\") \t\t\t# Bis zu einem Wert von 30% NICHT ähnlich\ncreateBlueEdgePercent = Config.getint(\"Graph\", \"createBlueEdgePercent\") \t# Bis zu einem Wert von 50% ETWAS ähnlich\ncreateBluedEdges = True\n\nfor argument in sys.argv:\n\tif lastcomm.strip() == \"-f\":\n\t\tfilename = argument.strip();\n\tif lastcomm.strip() == \"-d\":\n\t\tdebug = True\n\tif lastcomm.strip() == \"-m\":\n\t\tmaxEdgeValue = int(argument.strip());\n\tif lastcomm.strip() == \"-o\":\n\t\toutputfile = argument.strip();\n\tlastcomm = argument\nif lastcomm.strip() == \"-f\":\n\tfilename = argument.strip();\nif lastcomm.strip() == \"-d\":\n\tdebug = True\nif lastcomm.strip() == \"-m\":\n\tmaxEdgeValue = int(argument.strip());\nif lastcomm.strip() == \"-o\":\n\toutputfile = argument.strip();\n\nlogging.debug (\" ========\")\nlogging.info (\" Starting PS-Clustering Algorithm with Complement on \"+filename)\nlogging.info (\" ========\")\nstart_time = time.time()\n\nif filename == \"\":\n\tlogging.error (\"No file name given.\")\n\texit()\n\nG=nx.Graph()\nlogging.info (\" ... now reading graph at \"+filename)\nG = nx.read_gml(filename)\n\nif len(G) == 0:\n\tlogging.error (\" ... Graph is empty! Exiting!\")\n\texit()\nbuild_time = time.time() - start_time\nlogging.info (\" => Build time: \"+str(build_time))\n\nstart_time = time.time()\n\nG2 = G.copy()\nG2 = nx.complement(G2)\nnh = getNeighbors(G2)\ncliques = []\nfor key, value in nh.items():\n\tu1 = key\n\t#print (u1)\n\tif u1 not in G2.nodes():\n\t\t#print (\" -> not in G2\")\n\t\tcontinue\n\tu2 = getSmalestNeighbor(G2,u1)\n\tif u2 == None:\t\t\n\t\t#print (\" -> None \")\n\t\tcontinue\n\tG2.add_node (str(u1)+\"|\"+str(u2))\n\tfor node in G2[u1]:\n\t\tif nodes_connected(G2, u2, node):\n\t\t\tG2.add_edge(str(u1)+\"|\"+str(u2), node)\n\tif 'clique' in G2.node[u2]:\n\t\tG2.node[str(u1)+\"|\"+str(u2)]['clique']=G2.node[u2]['clique']\n\telse:\n\t\tG2.node[str(u1)+\"|\"+str(u2)]['clique']=getMaxClique(G2)+1\n\tG2.remove_node(u1)\n\tG2.remove_node(u2)\nfor node in G2.nodes():\n\tif 'clique' not in G2.node[node]:\n\t\tG2.node[node]['clique']=getMaxClique(G2)+1\ncl = nx.get_node_attributes(G2,'clique')\nfor key, value in cl.items():\n\tif \"|\" in str(key):\n\t\tnodes = key.split(\"|\")\n\telse:\n\t\tnodes = [key]\n\tfor node in nodes:\n\t\tif node in G.nodes():\n\t\t\tG.node[node]['color']=value\n\t\telif int(node) in G.nodes():\n\t\t\t\tG.node[int(node)]['color']=value\n\t\telse:\n\t\t\tprint (\" Error, node does not exist! \")\n\n#d = nx.coloring.greedy_color(G, strategy=nx.coloring.strategy_largest_first)\nd = nx.get_node_attributes(G, 'color')\ncolorCount = d[max(d, key=lambda key: d[key])]\n\nbuild_time = time.time() - start_time\nlogging.info (\" => Clique time: \"+str(build_time))\nstart_time = time.time()\n\n\nstart_time = time.time()\n# valueGraph und Farbenliste bauen\nvalueGraph = buildValueGraph (G, d )\noutputpathfilename = standardDirectory+outputfile\nif os.path.isabs (outputfile):\n\toutputpathfilename = outputfile\nlogging.debug (\" ... saving weightes Value Graph at \"+outputpathfilename+'coloredWithValue.gml')\nnx.write_gml(valueGraph, outputpathfilename+'coloredWithValue.gml')\n# Build a colorlist and sort min first\ncolorList = []\nfor i in range(0,colorCount):\n\t\tcountC = countColor (G,i);\n\t\tcolorList.append ( [i, countC] )\ncolorList = sorted(colorList,key=itemgetter(1))\n\nbuild_time = time.time() - start_time\nlogging.info (\" => Build weighted graph time: \"+str(build_time))\nstart_time = time.time()\n\n#G = addBlueEdges (G, createEdgePercent, createBlueEdgePercent, createBluedEdges, data)\n\n# For all nodes\ncountNodesEliminated = 0;\nlistConnections = []\n\ncolorCount = d[max(d, key=lambda key: d[key])]\nminYear = 3000\nmaxYear = 0\nfor i in range(0,colorCount):#\n\tyearc = getClusterYearsList (G,i)\n\tfor year in yearc:#\n\t\tif year[0]==0:\n\t\t\tcontinue\n\t\tif year[0]>maxYear:\n\t\t\tmaxYear = year[0]\n\t\tif year[0]= 0):\n\t\t\t\t\t\t# Nodes are not in the same stable sets\n\t\t\t\t\t\tif (G.node[nb][\"color\"] != G.node[node][\"color\"]):\n\t\t\t\t\t\t\tcolors.append (G.node[nb][\"color\"])\n\t\t\t# Now remove all double entries\n\t\t\tuniqueList = unique(colors)\n\t\t\t# check if \"node\" has at last two blue neighbours in different stable sets\n\t\t\tif len(uniqueList) >= 2:\n\t\t\t\t# Node is excluded from stable sets (color -1)\n\t\t\t\tG.node[node][\"color\"] = -1;\n\t\t\t\tcountNodesEliminated += 1\n\t\t\t\t# now we see, that this node connects all stable sets connected with blue edges:\n\t\t\t\tfor i in range(0,len(uniqueList)) :\n\t\t\t\t\tfor j in range (i+1, len(uniqueList)):\n\t\t\t\t\t\tnewYear = \"y\"+str(G.node[node][\"year\"])\n\t\t\t\t\t\t#print (\" Year: \"+newYear + \" from \"+ str(G.node[node][\"year\"]))\n\t\t\t\t\t\tif str(uniqueList[i]-1) in valueGraph.nodes() and str(str(uniqueList[j]-1)) in valueGraph.nodes():\n\t\t\t\t\t\t\tif valueGraph.has_edge(str(uniqueList[i]-1),str(uniqueList[j]-1)):\n\t\t\t\t\t\t\t\tvalueGraph[str(uniqueList[i]-1)][str(uniqueList[j]-1)][\"value\"]+=1\n\t\t\t\t\t\t\t\tif \"y\"+str(G.node[node][\"year\"]) in valueGraph[str(uniqueList[i]-1)][str(uniqueList[j]-1)]:\n\t\t\t\t\t\t\t\t\t# Jahr existiert\n\t\t\t\t\t\t\t\t\tvalueGraph[str(uniqueList[i]-1)][str(uniqueList[j]-1)][\"y\"+str(G.node[node][\"year\"])] += 1\n\t\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\t\tvalueGraph.add_edge (str(uniqueList[i]-1) , str(uniqueList[j]-1), {newYear : 1})\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\tvalueGraph.add_edge(str(uniqueList[i]-1),str(uniqueList[j]-1), value=1)\n\t\t\t\t\t\t\t\tvalueGraph.add_edge (str(uniqueList[i]-1) , str(uniqueList[j]-1), {newYear : 1})\n\t\t\t\t\t\t\tfor yearsum in range(minYear, G.node[node][\"year\"]-1):\n\t\t\t\t\t\t\t\tif \"s\"+str(yearsum) not in valueGraph[str(uniqueList[i]-1)][str(uniqueList[j]-1)]:\n\t\t\t\t\t\t\t\t\tnewYear2 = \"s\"+str(yearsum)\n\t\t\t\t\t\t\t\t\tvalueGraph.add_edge (str(uniqueList[i]-1) , str(uniqueList[j]-1), {newYear2 : 0})\n\t\t\t\t\t\t\tfor yearsum in range(G.node[node][\"year\"], maxYear):\n\t\t\t\t\t\t\t\tif \"s\"+str(yearsum) in valueGraph[str(uniqueList[i]-1)][str(uniqueList[j]-1)]:\n\t\t\t\t\t\t\t\t\tvalueGraph[str(uniqueList[i]-1)][str(uniqueList[j]-1)][\"s\"+str(yearsum)] += 1\n\t\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\t\tnewYear2 = \"s\"+str(yearsum)\n\t\t\t\t\t\t\t\t\tvalueGraph.add_edge (str(uniqueList[i]-1) , str(uniqueList[j]-1), {newYear2 : 1})\n\t\t\t\t\t\t#else:\n\t\t\t\t\t\t#\tlogging.warn (\" Error, nodes do not exist. \")\n\t\t\t\t\t\t#valueGraph[str(uniqueList[i]-1)][str(uniqueList[j]-1)][\"y\"+str(G.node[node][\"year\"])] += 1\n\t\t\t\t# mark all nodes as end-nodes\n\t\t\t\tfor nb in G.neighbors(node):\n\t\t\t\t\t# is edge blue?\n\t\t\t\t\tif G[node][nb][\"color\"] == \"blue\":\n\t\t\t\t\t\t# is node not yet excluded from stable sets? \n\t\t\t\t\t\tif (G.node[nb][\"color\"] >= 0):\n\t\t\t\t\t\t\tG.node[nb][\"end\"] = 1\n\t#print (\" Color count after: \"+str(countColor(G, colorSet[0])))\n#print (str(valueGraph.number_of_nodes()))\n\nif \"-1\" in valueGraph.nodes():\n\tvalueGraph.remove_node(\"-1\")\nif -1 in valueGraph.nodes():\n\tvalueGraph.remove_node(-1)\n\ncount = 15\n\nfor node in valueGraph.nodes():\t\n\tnewValue = countColor (G, int(node))\n\tif newValue == 0:\n\t\t#print (\"Removing node \"+str(node)+\" with \"+str(valueGraph.node[node][\"text\"]))\n\t\tvalueGraph.remove_node(node)\n\telse:\n\t\tvalueGraph.node[node][\"value\"]=newValue\n\t\tterms = getClusterName(G,node,count);\n\t\tjournals = getClusterJournals (G,node,count)\n\t\tyearc = getClusterYearsList (G,node,count)\n\t\tvalueGraph.node[node][\"text\"]=terms\n\t\tvalueGraph.node[node][\"journal\"]=journals\n\t\tyearc.sort(key=lambda tup: tup[0]) \n\t\t#print (str(yearc))\n\t\tsumme = 0\n\t\t#print (\"New Sum\")\n\t\t#print (str(minYear) +\" -- \"+str(maxYear))\n\t\t#print (yearc)\n\t\tfor year in range(minYear, maxYear):\n\t\t\taddValue = 0\n\t\t\t#print (\"Looking for year \"+str(year))\n\t\t\tfor years in yearc:\n\t\t\t\tif years[0]==0:\n\t\t\t\t\tcontinue\n\t\t\t\tif years[0] == year:\n\t\t\t\t\t#print (str(years[0]) +\" == \"+str(year))\n\t\t\t\t\taddValue = years[1]\n\t\t\t#print (\" \"+str(year))\n\t\t\tvalueGraph.node[node][\"y\"+str(year)] = addValue\n\t\t\tvalueGraph.node[node][\"s\"+str(year)] = addValue + summe\n\t\t\tsumme += addValue\t\n\t\t#csvwriter.writerow ([''])\n\t\t#csvwriter.writerow ([\"Node\", int(node), \"Nodes:\", newValue])\n\t\t#csvwriter.writerow (getClusterName (G, int(node), maxCount=-1, separator=\";\").split(\";\")) \n\t\t#csvwriter.writerow ([''])\n\t\t#nodeList = (n for n in G if G.node[n]['color']==int(node))\n\t\t#for nodeG in nodeList:\n\t\t#\tcsvwriter.writerow ([ G.node[nodeG]['title'], G.node[nodeG]['ref'], G.node[nodeG]['uri']])\nlogging.debug (\" ... saving PS Value Graph at \"+outputpathfilename+'coloredWithValuePS.gml')\nnx.write_gml(valueGraph, outputpathfilename+'coloredWithValuePS.gml')\n\nbuild_time = time.time() - start_time\nlogging.debug (\" => PS time: \"+str(build_time))\nstart_time = time.time()\n\nps_time = build_time\n\n#csvwriter.writerows (sorted(oldList.items(), key=operator.itemgetter(1), reverse=True)) \n\nlogging.debug (\" ... saving Network RB at \"+outputpathfilename+'network_rb.gml')\n# Output nach neu färben\nnx.write_gml(G, outputpathfilename+'network_rb.gml')\n\nnumbers = getMeshTermNumber (G);\n#print ( sorted(numbers.items(), key=operator.itemgetter(1)))\n\n\n\n# Export \ndata = json_graph.node_link_data(valueGraph)\nwith open(outputpathfilename+'coloredWithValuePS.json', 'w') as outfile:\n json.dump(data, outfile)\n\n#fig, axs = plt.subplots(1, 1, figsize=(10, 10))\n#ax = axs\n#pos = None\n#mpld3.plugins.connect(fig, NetworkXD3ForceLayout(valueGraph,\n# pos,\n# ax,\n# gravity=.5,\n# link_distance=20,\n# charge=-600,\n# friction=1\n# )\n# )\n\n\nif debug:\n\t#logging.debug (\"Graph created. Number of nodes: \" + str(G.number_of_nodes())+ \", number edges: \"+ str(G.number_of_edges()))\n\t#logging.debug (\" Blue edges: \"+str(bluedEdges))\n\t#print (\" Black edges: \"+ str(countBlack) + \", Blued edges: \"+ str(countBlue) +\", lost edged: \"+str(countLost))\n\t#logging.debug (\" Build time: \\t \" + str((build_time)))\n\t#logging.debug (\" Color time: \\t \" + str((color_time )))\n\tlogging.info (\" PS time: \\t \" + str((ps_time )))\n\t\n\t\n\tlogging.info (\" ========\")\n\tlogging.info (\" Farben: \\t\\t \"+str(colorCount))\n\tlogging.info (\" minMPS: \\t\\t \"+str(valueGraph.number_of_nodes()-1))\n\t#lower = colorCount - math.floor (bluedEdges / 2)\n\t#if lower < 2:\n\t#\tlower = 2\n\t#logging.debug (\" l_b: \\t \\t\\t \"+str(lower))\n\t#print (\" Cliquenzahl: \"+ str(clique) )\n\tlogging.info (\" Eliminated nodes: \\t \"+str(countNodesEliminated))\n\t#print (\" Clique time: \" + str((clique_time - color_time)))\n\t#print (G.edges())\n#nx.set_node_attributes(G, 'label', {0: \"0\", 1: \"1\"})\n\noutput = []\noutput.append (ps_time)\noutput.append (colorCount)\noutput.append (valueGraph.number_of_nodes())\noutput.append (countNodesEliminated)\n\nprint (output)\n", "meta": {"hexsha": "819946f7e749b67ba293f2f4cb94982899f33e93", "size": 12098, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/DocClustering/heuristics/colorGraphComplement.py", "max_stars_repo_name": "jd-s/DocClustering", "max_stars_repo_head_hexsha": "a7d4acff8464f960558cf9cc6d03de78d07d56bf", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/DocClustering/heuristics/colorGraphComplement.py", "max_issues_repo_name": "jd-s/DocClustering", "max_issues_repo_head_hexsha": "a7d4acff8464f960558cf9cc6d03de78d07d56bf", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/DocClustering/heuristics/colorGraphComplement.py", "max_forks_repo_name": "jd-s/DocClustering", "max_forks_repo_head_hexsha": "a7d4acff8464f960558cf9cc6d03de78d07d56bf", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.664756447, "max_line_length": 125, "alphanum_fraction": 0.6444040337, "include": true, "reason": "import networkx,from networkx", "num_tokens": 3386, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073655352404, "lm_q2_score": 0.35577489351363034, "lm_q1q2_score": 0.19589227684112068}} {"text": "# cython: language_level=3\n# distutils: language = c++\n# -*- coding: utf-8 -*-\n# *****************************************************************************\n# Copyright (c) 2016-2020, Intel Corporation\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or without\n# modification, are permitted provided that the following conditions are met:\n# - Redistributions of source code must retain the above copyright notice,\n# this list of conditions and the following disclaimer.\n# - Redistributions in binary form must reproduce the above copyright notice,\n# this list of conditions and the following disclaimer in the documentation\n# and/or other materials provided with the distribution.\n#\n# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF\n# THE POSSIBILITY OF SUCH DAMAGE.\n# *****************************************************************************\n\n\"\"\"\nInterface of the Linear Algebra part of the DPNP\n\nNotes\n-----\nThis module is a face or public interface file for the library\nit contains:\n - Interface functions\n - documentation for the functions\n - The functions parameters check\n\n\"\"\"\n\n\nimport dpnp\nimport numpy\n\nfrom dpnp.dparray import dparray\nfrom dpnp.dpnp_utils import *\nfrom dpnp.linalg.dpnp_algo_linalg import *\n\n\n__all__ = [\n \"cholesky\",\n \"cond\",\n \"det\",\n \"eig\",\n \"eigvals\",\n \"inv\",\n \"matrix_power\",\n \"matrix_rank\",\n \"multi_dot\",\n \"norm\",\n \"qr\",\n \"svd\",\n]\n\n\ndef cholesky(input):\n \"\"\"\n Cholesky decomposition.\n Return the Cholesky decomposition, `L * L.H`, of the square matrix `input`,\n where `L` is lower-triangular and .H is the conjugate transpose operator\n (which is the ordinary transpose if `input` is real-valued). `input` must be\n Hermitian (symmetric if real-valued) and positive-definite. No\n checking is performed to verify whether `a` is Hermitian or not.\n In addition, only the lower-triangular and diagonal elements of `input`\n are used. Only `L` is actually returned.\n\n Parameters\n ----------\n input : (..., M, M) array_like\n Hermitian (symmetric if all elements are real), positive-definite\n input matrix.\n\n Returns\n -------\n L : (..., M, M) array_like\n Upper or lower-triangular Cholesky factor of `input`. Returns a\n matrix object if `input` is a matrix object.\n \"\"\"\n\n if not use_origin_backend(input):\n if not isinstance(input, dparray):\n pass\n elif input.shape[-1] != input.shape[-2]:\n pass\n elif input.ndim < 3:\n pass\n else:\n return dpnp_cholesky(input)\n\n return call_origin(numpy.linalg.cholesky, input)\n\n\ndef cond(input, p=None):\n \"\"\"\n Compute the condition number of a matrix.\n For full documentation refer to :obj:`numpy.linalg.cond`.\n\n Limitations\n -----------\n Input array is supported as :obj:`dpnp.ndarray`.\n Parameter p=[None, 1, -1, 2, -2, numpy.inf, -numpy.inf, 'fro'] is supported.\n\n See Also\n --------\n :obj:`dpnp.norm` : Matrix or vector norm.\n \"\"\"\n\n is_input_dparray = isinstance(input, dparray)\n\n if (not use_origin_backend(input) and is_input_dparray):\n if p in [None, 1, -1, 2, -2, numpy.inf, -numpy.inf, 'fro']:\n result = dpnp_cond(input, p=p)\n return result.dtype.type(result[0])\n else:\n pass\n\n return call_origin(numpy.linalg.cond, input, p)\n\n\ndef det(input):\n \"\"\"\n Compute the determinant of an array.\n\n Parameters\n ----------\n input : (..., M, M) array_like\n Input array to compute determinants for.\n\n Returns\n -------\n det : (...) array_like\n Determinant of `input`.\n \"\"\"\n is_input_dparray = isinstance(input, dparray)\n\n if not use_origin_backend(input) and is_input_dparray:\n if input.shape[-1] == input.shape[-2]:\n result = dpnp_det(input)\n\n # scalar returned\n if result.shape == (1,):\n return result.dtype.type(result[0])\n\n return result\n\n return call_origin(numpy.linalg.det, input)\n\n\ndef eig(x1):\n \"\"\"\n Compute the eigenvalues and right eigenvectors of a square array.\n\n .. seealso:: :obj:`numpy.linalg.eig`\n\n \"\"\"\n\n is_x1_dparray = isinstance(x1, dparray)\n\n if (not use_origin_backend(x1) and is_x1_dparray):\n if (x1.size > 0):\n return dpnp_eig(x1)\n\n return call_origin(numpy.linalg.eig, x1)\n\n\ndef eigvals(input):\n \"\"\"\n Compute the eigenvalues of a general matrix.\n Main difference between `eigvals` and `eig`: the eigenvectors aren't\n returned.\n\n Parameters\n ----------\n input : (..., M, M) array_like\n A complex- or real-valued matrix whose eigenvalues will be computed.\n\n Returns\n -------\n w : (..., M,) ndarray\n The eigenvalues, each repeated according to its multiplicity.\n They are not necessarily ordered, nor are they necessarily\n real for real matrices.\n \"\"\"\n\n is_input_dparray = isinstance(input, dparray)\n\n if (not use_origin_backend(input) and is_input_dparray):\n if (input.size > 0):\n return dpnp_eigvals(input)\n\n return call_origin(numpy.linalg.eigvals, input)\n\n\ndef inv(input):\n \"\"\"\n Divide arguments element-wise.\n\n For full documentation refer to :obj:`numpy.linalg.inv`.\n\n Limitations\n -----------\n Input array is supported as :obj:`dpnp.ndarray`.\n Dimension of input array is supported to be equal to ``2``.\n Shape of input array is limited by ``input.shape[0] == input.shape[1]``, ``input.shape[0] >= 2``.\n Otherwise the function will be executed sequentially on CPU.\n \"\"\"\n\n is_input_dparray = isinstance(input, dparray)\n\n if (not use_origin_backend(input) and is_input_dparray):\n if input.ndim == 2 and input.shape[0] == input.shape[1] and input.shape[0] >= 2:\n return dpnp_inv(input)\n\n return call_origin(numpy.linalg.inv, input)\n\n\ndef matrix_power(input, count):\n \"\"\"\n Raise a square matrix to the (integer) power `count`.\n\n Parameters\n ----------\n input : sequence of array_like\n\n Returns\n -------\n output : dparray\n Returns the dot product of the supplied arrays.\n\n See Also\n --------\n :obj:`numpy.linalg.matrix_power`\n\n \"\"\"\n\n is_input_dparray = isinstance(input, dparray)\n\n if not use_origin_backend(input) and is_input_dparray and count > 0:\n result = input\n for id in range(count - 1):\n result = dpnp.matmul(result, input)\n\n return result\n\n input1 = dpnp.asnumpy(input) if is_input_dparray else input\n\n # TODO need to put dparray memory into NumPy call\n result_numpy = numpy.linalg.matrix_power(input1, count)\n result = result_numpy\n if isinstance(result, numpy.ndarray):\n result = dparray(result_numpy.shape, dtype=result_numpy.dtype)\n for i in range(result.size):\n result._setitem_scalar(i, result_numpy.item(i))\n\n return result\n\n\ndef matrix_rank(input, tol=None, hermitian=False):\n \"\"\"\n Return matrix rank of array\n Rank of the array is the number of singular values of the array that are\n greater than `tol`.\n\n Parameters\n ----------\n M : {(M,), (..., M, N)} array_like\n Input vector or stack of matrices.\n tol : (...) array_like, float, optional\n Threshold below which SVD values are considered zero. If `tol` is\n None, and ``S`` is an array with singular values for `M`, and\n ``eps`` is the epsilon value for datatype of ``S``, then `tol` is\n set to ``S.max() * max(M.shape) * eps``.\n hermitian : bool, optional\n If True, `M` is assumed to be Hermitian (symmetric if real-valued),\n enabling a more efficient method for finding singular values.\n Defaults to False.\n\n Returns\n -------\n rank : (...) array_like\n Rank of M.\n\n \"\"\"\n\n is_input_dparray = isinstance(input, dparray)\n\n if not use_origin_backend(input) and is_input_dparray:\n if tol is not None:\n checker_throw_value_error(\"matrix_rank\", \"tol\", type(tol), None)\n if hermitian is not False:\n checker_throw_value_error(\"matrix_rank\", \"hermitian\", hermitian, False)\n\n result = dpnp_matrix_rank(input)\n\n # scalar returned\n if result.shape == (1,):\n return result.dtype.type(result[0])\n\n return result\n\n return call_origin(numpy.linalg.matrix_rank, input, tol, hermitian)\n\n\ndef multi_dot(arrays, out=None):\n \"\"\"\n Compute the dot product of two or more arrays in a single function call\n\n Parameters\n ----------\n arrays : sequence of array_like\n If the first argument is 1-D it is treated as row vector.\n If the last argument is 1-D it is treated as column vector.\n The other arguments must be 2-D.\n out : ndarray, optional\n unsupported\n\n Returns\n -------\n output : ndarray\n Returns the dot product of the supplied arrays.\n\n See Also\n --------\n :obj:`numpy.multi_dot`\n\n \"\"\"\n\n n = len(arrays)\n\n if n < 2:\n checker_throw_value_error(\"multi_dot\", \"arrays\", n, \">1\")\n\n result = arrays[0]\n for id in range(1, n):\n result = dpnp.dot(result, arrays[id])\n\n return result\n\n\ndef norm(input, ord=None, axis=None, keepdims=False):\n \"\"\"\n Matrix or vector norm.\n This function is able to return one of eight different matrix norms,\n or one of an infinite number of vector norms (described below), depending\n on the value of the ``ord`` parameter.\n\n Parameters\n ----------\n input : array_like\n Input array. If `axis` is None, `x` must be 1-D or 2-D, unless `ord`\n is None. If both `axis` and `ord` are None, the 2-norm of\n ``x.ravel`` will be returned.\n ord : optional\n Order of the norm (see table under ``Notes``). inf means numpy's\n `inf` object. The default is None.\n axis : optional.\n If `axis` is an integer, it specifies the axis of `x` along which to\n compute the vector norms. If `axis` is a 2-tuple, it specifies the\n axes that hold 2-D matrices, and the matrix norms of these matrices\n are computed. If `axis` is None then either a vector norm (when `x`\n is 1-D) or a matrix norm (when `x` is 2-D) is returned. The default\n is None.\n keepdims : bool, optional\n If this is set to True, the axes which are normed over are left in the\n result as dimensions with size one. With this option the result will\n broadcast correctly against the original `x`.\n\n Returns\n -------\n n : float or ndarray\n Norm of the matrix or vector(s).\n \"\"\"\n\n if not use_origin_backend(input):\n if not isinstance(input, dparray):\n pass\n elif not isinstance(axis, int) and not isinstance(axis, tuple) and axis is not None:\n pass\n elif keepdims is not False:\n pass\n elif ord not in [None, 0, 3, 'fro', 'f']:\n pass\n else:\n result = dpnp_norm(input, ord=ord, axis=axis)\n\n # scalar returned\n if result.shape == (1,) and axis is None:\n return result.dtype.type(result[0])\n\n return result\n\n return call_origin(numpy.linalg.norm, input, ord, axis, keepdims)\n\n\n#linalg.qr(a, mode='reduced')\ndef qr(a, mode='complete'):\n \"\"\"\n Compute the qr factorization of a matrix.\n\n Factor the matrix `a` as *qr*, where `q` is orthonormal and `r` is\n upper-triangular.\n\n For full documentation refer to :obj:`numpy.linalg.qr`.\n\n Limitations\n -----------\n Input array is supported as :obj:`dpnp.ndarray`.\n Parameter mode='complete' is supported.\n\n \"\"\"\n\n if not use_origin_backend(a):\n if not isinstance(a, dparray):\n pass\n elif not mode == 'complete':\n pass\n else:\n return dpnp_qr(a, mode)\n\n return call_origin(numpy.linalg.qr, a, mode)\n\n\ndef svd(a, full_matrices=True, compute_uv=True, hermitian=False):\n \"\"\"\n Singular Value Decomposition.\n\n For full documentation refer to :obj:`numpy.linalg.svd`.\n\n Examples\n --------\n >>> import dpnp as np\n >>> a = np.random.randn(9, 6) + 1j*np.random.randn(9, 6)\n >>> b = np.random.randn(2, 7, 8, 3) + 1j*np.random.randn(2, 7, 8, 3)\n\n Reconstruction based on full SVD, 2D case:\n\n >>> u, s, vh = np.linalg.svd(a, full_matrices=True)\n >>> u.shape, s.shape, vh.shape\n ((9, 9), (6,), (6, 6))\n >>> np.allclose(a, np.dot(u[:, :6] * s, vh))\n True\n >>> smat = np.zeros((9, 6), dtype=complex)\n >>> smat[:6, :6] = np.diag(s)\n >>> np.allclose(a, np.dot(u, np.dot(smat, vh)))\n True\n\n Reconstruction based on reduced SVD, 2D case:\n\n >>> u, s, vh = np.linalg.svd(a, full_matrices=False)\n >>> u.shape, s.shape, vh.shape\n ((9, 6), (6,), (6, 6))\n >>> np.allclose(a, np.dot(u * s, vh))\n True\n >>> smat = np.diag(s)\n >>> np.allclose(a, np.dot(u, np.dot(smat, vh)))\n True\n\n Reconstruction based on full SVD, 4D case:\n\n >>> u, s, vh = np.linalg.svd(b, full_matrices=True)\n >>> u.shape, s.shape, vh.shape\n ((2, 7, 8, 8), (2, 7, 3), (2, 7, 3, 3))\n >>> np.allclose(b, np.matmul(u[..., :3] * s[..., None, :], vh))\n True\n >>> np.allclose(b, np.matmul(u[..., :3], s[..., None] * vh))\n True\n\n Reconstruction based on reduced SVD, 4D case:\n\n >>> u, s, vh = np.linalg.svd(b, full_matrices=False)\n >>> u.shape, s.shape, vh.shape\n ((2, 7, 8, 3), (2, 7, 3), (2, 7, 3, 3))\n >>> np.allclose(b, np.matmul(u * s[..., None, :], vh))\n True\n >>> np.allclose(b, np.matmul(u, s[..., None] * vh))\n True\n\n \"\"\"\n\n if not use_origin_backend(a):\n if not isinstance(a, dparray):\n pass\n elif not a.ndim == 2:\n pass\n elif not full_matrices == True:\n pass\n elif not compute_uv == True:\n pass\n elif not hermitian == False:\n pass\n else:\n return dpnp_svd(a, full_matrices, compute_uv, hermitian)\n\n return call_origin(numpy.linalg.svd, a, full_matrices, compute_uv, hermitian)\n", "meta": {"hexsha": "da8c1d765a8dcf90f3257eaee7f3225a97ad27b1", "size": 14827, "ext": "py", "lang": "Python", "max_stars_repo_path": "dpnp/linalg/dpnp_iface_linalg.py", "max_stars_repo_name": "Rubtsowa/dpnp", "max_stars_repo_head_hexsha": "ef404c0f284b0c508ed1e556e140f02f76ae5551", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "dpnp/linalg/dpnp_iface_linalg.py", "max_issues_repo_name": "Rubtsowa/dpnp", "max_issues_repo_head_hexsha": "ef404c0f284b0c508ed1e556e140f02f76ae5551", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "dpnp/linalg/dpnp_iface_linalg.py", "max_forks_repo_name": "Rubtsowa/dpnp", "max_forks_repo_head_hexsha": "ef404c0f284b0c508ed1e556e140f02f76ae5551", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.3023715415, "max_line_length": 105, "alphanum_fraction": 0.6113846361, "include": true, "reason": "import numpy", "num_tokens": 3713, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073655352404, "lm_q2_score": 0.35577489351363034, "lm_q1q2_score": 0.19589227684112068}} {"text": "import numpy as np\nimport array\nimport os, sys\nimport re\nimport time\nimport multiprocessing\nimport h5py\nimport logging\nfrom astropy.table import Table, Column\nfrom astropy import units as u\n\n\nimport argparse\nparser = argparse.ArgumentParser()\nparser.add_argument(\"-p\",\"--params\", type=str,\n help = \"Parameter file\")\nparser.add_argument(\"-q\", \"--quiet\", help = \"Suppress extra outputs\",\n action = \"store_true\")\nargs = parser.parse_args()\nquiet = args.quiet\n\nparams_root = re.split(\".py\", args.params)[0]\nif os.path.isfile(params_root+\".pyc\"):\n os.remove(params_root+\".pyc\")\n\nimport importlib\ntry:\n params = importlib.import_module(params_root)\n print('Successfully loaded \"{0}\" as params'.format(args.params))\n importlib.reload(params)\nexcept:\n print('Failed to load \"{0}\" as params'.format(args.params))\n raise\n\nif quiet:\n quietprint = lambda *a: None\nelse:\n def quietprint(*args):\n for arg in args:\n print(arg, end=' ')\n print()\n\n# Fitting function definition for later use by Processess\n\ndef galaxyFit(inputQueue, printQueue, printlock):\n for gal in iter(inputQueue.get, 'STOP'):\n j = np.argmin(np.abs(z-zobs[gal])) # Find closest model redshift\n\n\n flux_obs = obs[gal,:]\n flux_err = obs_err[gal,:]\n \n #flux_obs[fo <= 0.] = 0. # Set negative fluxes to zero\n I = np.where(flux_err > 0.)[0] # Find bands with no observation\n \n if len(I) == 0:\n if include_rest:\n M_scaled = np.ones(len(fo)) * -99.\n restframe_output = ' '.join(M_scaled.astype('str'))\n output_string = '{0} {1} {2} {3} {4} {5} {6} {7}' \\\n ' {8} {9} {10} {11} {12} {13} {14} {15} {16}'.format(gal+1,ID[gal],zobs[gal],-99,-99,-99,-99,-99,-99, -99, -99,-99,len(I),-99,z[j],restframe_output,'\\n')\n else:\n output_string = '{0} {1} {2} {3} {4} {5} {6} {7} {8} {9} {10} {11} {12} {13} {14}'.format(gal+1,ID[gal],zobs[gal],-99,-99,-99,-99,-99,-99,-99, -99,-99,len(I),-99,'\\n')\n printQueue.put(output_string)\n continue\n \n flux_obs = flux_obs[I] # and exclude from fit\n flux_err = flux_err[I]\n flux_models = f[j,I,:]\n\n tot_err = np.sqrt(flux_err**2 + (0.1*flux_obs)**2)\n \n top = 0.\n bottom = 0.\n \n for i in range(len(flux_obs)):\n top += (flux_models[i,:]*flux_obs[i])/(tot_err[i]**2)\n bottom += (flux_models[i,:]**2)/(tot_err[i]**2)\n \n scale = top/bottom\n scale = np.reshape(scale, (n_metal, n_tg, n_tau, n_tauv, n_fesc)) \n\n chisq = 0.\n for i in range(len(flux_obs)):\n chisq += ((np.abs(scale*flux_models[i,:]-flux_obs[i])**2)/(flux_err[i])**2)\n\n chimin, minind = np.nanmin(chisq), np.nanargmin(chisq)\n \n if np.isinf(chimin) or np.isnan(minind):\n if include_rest:\n M_scaled = np.ones(len(flux_obs)) * -99.\n restframe_output = ' '.join(M_scaled.astype('str'))\n output_string = '{0} {1} {2} {3} {4} {5} {6} {7} {8} {9} {10} {11} {12} {13} {14} {15} {16}'.format(gal+1,ID[gal],zobs[gal],-99,-99,-99,-99,-99,-99, -99, -99,-99,len(I),-99,z[j],restframe_output,'\\n')\n else:\n output_string = '{0} {1} {2} {3} {4} {5} {6} {7} {8} {9} {10} {11} {12} {13} {14}'.format(gal+1,ID[gal],zobs[gal],-99,-99,-99,-99,-99,-99,-99, -99,-99,len(I),-99,'\\n')\n printQueue.put(output_string)\n continue\n\n\n #Find the coordinate of the model with the bestfit mass\n mi, tgi, ti, tvi, fi = np.unravel_index(minind, \n (n_metal, n_tg, \n n_tau, n_tauv, n_fesc)) \n\n Bestfit_Mass = np.log10(scale[mi, tgi, ti, tvi, fi]*flux_corr)\n Bestfit_SFR = (scale[mi, tgi, ti, tvi, fi] * \n SFR[mi, tgi, ti, tvi, fi]*flux_corr)\n #Bestfit_Beta = beta[tgi,tvi,ti,mi]\n Bestfit_Beta = -99.\n\n #Scale the observed tot_mag band of the template to be the same as the observed tot_mag band of the galaxy\n #Convert the templates so they are no longer units of per stellar mass\n\n F_rest = f[0,:]*scale[mi, tgi, ti, tvi, fi]*flux_corr\n restframeMags = 23.9 - 2.5*np.log10(F_rest)\n \n #UV_rest = UV_flux[0]*scale[tgi,tvi,ti,mi]*flux_corr\n #restframeMUV = 23.9 - 2.5*np.log10(UV_rest)\n\n M_scaled = restframeMags[:, mi, tgi, ti, tvi, fi]\n #MUV_scaled = restframeMUV[tgi,tvi,ti,mi]\n MUV_scaled = -99.\n \n if np.isnan(Bestfit_Mass) or np.isinf(chimin):\n Bestfit_Mass = -99\n #M_scaled[:] = -99\n tgs = -99\n tvs = -99\n taus = -99\n mis = -99\n escape_fraction = -99\n\n else:\n tgs = tg[tgi]/1e9\n tvs = tv[tvi]\n taus = tau[ti]\n mis = metallicities[mi]\n escape_fraction = fesc[fi] \n\n\n printlock.acquire()\n\n print('{0:6d} {1:8d} {2:>5.2f} {3:>7.2f} {4:>8.1f} {5:>8.3f} {6:>5.1f} {7:>8.2f} {8:>4.2f} {9:>5.2f}'.format(gal+1,ID[gal], zobs[gal],Bestfit_Mass,chimin,tgs,tvs,taus,mis,np.log10(Bestfit_SFR)))\n\n if include_rest:\n restframe_output = ' '.join(M_scaled.astype('str'))\n output_string = '{0} {1} {2} {3} {4} {5} {6} {7} {8} {9} {10} {11} {12} {13} {14} {15} {16}'.format(gal+1,ID[gal],zobs[gal],Bestfit_Mass,chimin,tgs,tvs,taus,mis, MUV_scaled, minind,Bestfit_SFR,len(I),Bestfit_Beta,z[j],restframe_output,'\\n')\n else:\n output_string = '{0} {1} {2} {3} {4} {5} {6} {7} {8} {9} {10} {11} {12} {13} {14}'.format(gal+1,ID[gal],zobs[gal],Bestfit_Mass,chimin,tgs,tvs,taus,mis, MUV_scaled, minind,Bestfit_SFR,len(I),Bestfit_Beta,'\\n')\n\n printlock.release()\n printQueue.put(output_string)\n\ndef galaxyFit2(inputQueue, printQueue, printlock):\n for gal in iter(inputQueue.get, 'STOP'):\n \n \n output_string = '{0[0]} {0[1]} {0[2]} {0[3]} {0[4]} {0[5]} ' + \\\n '{0[6]} {0[7]} {0[8]} {0[9]} {0[10]} {0[11]} ' + \\\n '{0[12]} {0[13]} {0[14]}'\n \n j = np.argmin(np.abs(z-zobs[gal])) # Find closest model redshift\n\n log_mass_min, log_mass_max = 7, 13\n log_sfr_min, log_sfr_max = -3, 4\n\n flux_obs = obs[gal,:]\n flux_err = obs_err[gal,:]\n \n #flux_obs[fo <= 0.] = 0. # Set negative fluxes to zero\n I = np.where(flux_err > 0.)[0] # Find bands with no observation\n \n if len(I) == 0:\n output_array = [gal+1, ID[gal], zobs[gal], z[j],\n -99, -99, -99, -99, -99, -99, -99,\n -99,-99,len(I),-99,'\\n']\n output = output_string.format(output_array)\n \n if include_rest:\n M_scaled = np.ones(len(flux_obs)) * -99.\n restframe_output = ' '.join(M_scaled.astype('str'))\n output = output + restframe_output + ' \\n'\n \n else:\n output = output + ' \\n'\n printQueue.put(output_string)\n continue\n \n flux_obs = flux_obs[I] # and exclude from fit\n flux_err = flux_err[I]\n flux_models = f[j,I,:]\n\n tot_err = np.sqrt(flux_err**2 + (params.flux_err*flux_obs)**2)\n\n top = 0.\n bottom = 0.\n \n for i in range(len(flux_obs)):\n top += (flux_models[i,:]*flux_obs[i])/(tot_err[i]**2)\n bottom += (flux_models[i,:]**2)/(tot_err[i]**2)\n \n scale = top/bottom\n scale = np.reshape(scale, (n_metal, n_tg, n_tau, n_tauv, n_fesc)) \n\n chisq = 0.\n for i in range(len(flux_obs)):\n chisq += ((np.abs(scale*flux_models[i,:]-flux_obs[i])**2)/(tot_err[i])**2)\n\n chimin, minind = np.nanmin(chisq), np.nanargmin(chisq)\n likelihood = np.reshape(np.exp(-0.5*chisq), \n (n_metal, n_tg, n_tau, n_tauv, n_fesc))\n likelihood[np.isnan(likelihood)] = 0.\n likelihood = np.abs(likelihood/likelihood.sum())\n \n \n if np.isinf(chimin) or np.isnan(minind):\n output_array = [gal+1, ID[gal], zobs[gal], z[j],\n -99, -99, -99, -99, -99, -99, -99,\n -99,-99,len(I),-99,'\\n']\n output = output_string.format(output_array)\n\n else:\n #Find the coordinate of the model with the bestfit mass\n mi, tgi, ti, tvi, fi = np.unravel_index(minind, \n (n_metal, n_tg, \n n_tau, n_tauv, n_fesc)) \n\n Masses = np.abs(np.log10(scale*flux_corr))\n SFRs = np.abs(np.log10(scale * SFR * flux_corr))\n \n mass_hist = np.histogram(Masses.flatten(),\n range = (log_mass_min, log_mass_max),\n bins = 120,\n weights = likelihood.flatten(),\n density = True)\n \n sfr_hist = np.histogram(SFRs.flatten(),\n range = (log_sfr_min, log_sfr_max),\n bins = 140,\n weights = likelihood.flatten(),\n density = True)\n \n Bestfit_Mass = np.abs(np.log10(scale[mi, tgi, ti, tvi, fi]*flux_corr))\n Bestfit_SFR = np.abs(np.log10(scale[mi, tgi, ti, tvi, fi] * \n SFR[mi, tgi, ti, tvi, fi]*flux_corr))\n \n if np.isnan(Bestfit_Mass) or np.isinf(chimin):\n Bestfit_Mass = -99\n #M_scaled[:] = -99\n tgs = -99\n tvs = -99\n taus = -99\n mis = -99\n escape_fraction = -99\n\n else:\n tgs = tg[tgi]/1e9\n tvs = tv[tvi]\n taus = tau[ti]\n mis = metallicities[mi]\n escape_fraction = fesc[fi] \n\n m16, m50, m84 = weighted_quantile(Masses.flatten(), \n [0.16, 0.5, 0.84],\n sample_weight=likelihood.flatten(),\n values_sorted=False)\n s16, s50, s84 = weighted_quantile(SFRs.flatten(), \n [0.16, 0.5, 0.84],\n sample_weight=likelihood.flatten(),\n values_sorted=False)\n\n printlock.acquire()\n\n MUV_scaled = -99. \n Bestfit_Beta = -99.\n \n print_string = \"{0[0]:6d} {0[1]:8d} {0[2]:>5.2f} \" + \\\n \"{0[3]:>7.2f} {0[4]:>8.1f} {0[5]:>8.3f} \" + \\\n \"{0[6]:>5.1f} {0[7]:>8.2f} {0[8]:>4.2f} \" + \\\n \"{0[9]:>5.2f}\"\n \n print_array = [gal+1, ID[gal], zobs[gal],\n Bestfit_Mass, chimin, \n tgs, tvs, taus, mis, \n Bestfit_SFR] \n print(print_string.format(print_array))\n\n output_string = '{n} {id} {zobs} {ztemp} {mass_best} {sfr_best} '+ \\\n '{chi_best} {tg} {tvs} {taus} {mis} {fesc} '+ \\\n '{mass_med} {mass_l68} {mass_u68} ' + \\\n '{sfr_med} {sfr_l68} {sfr_u68} ' + \\\n '{nfilts} '\n \n output_values = {'n': gal+1,\n 'id': ID[gal],\n 'zobs': zobs[gal], 'ztemp':z[j],\n 'mass_best': Bestfit_Mass,\n 'sfr_best': Bestfit_SFR,\n 'chi_best': chimin,\n 'tg': tgs, 'tvs': tvs, 'taus': taus, \n 'mis': mis, 'fesc': escape_fraction,\n 'mass_med': m50, 'mass_l68': m16, 'mass_u68': m84,\n 'sfr_med': s50, 'sfr_l68': s16, 'sfr_u68': s84,\n 'nfilts': len(I)}\n\n output_array = [gal+1, ID[gal], zobs[gal], \n Bestfit_Mass, chimin, tgs, tvs, taus, mis, \n MUV_scaled, minind, Bestfit_SFR, len(I), -99., '\\n']\n output = output_string.format(**output_values)\n \n if include_rest:\n if np.isinf(chimin) or np.isnan(minind):\n M_scaled = np.ones(len(flux_obs)) * -99.\n restframe_output = ' '.join(M_scaled.astype('str'))\n output = output + restframe_output + ' \\n'\n \n else:\n F_rest = np.array(f[0, :, mi, tgi, ti, tvi, fi] * \n scale[mi, tgi, ti, tvi, fi] * flux_corr)\n restframeMags = 23.9 - 2.5*np.log10(F_rest)\n restframe_output = ' '.join(restframeMags.astype('str'))\n output = output + restframe_output + ' \\n'\n else:\n output = output + ' \\n'\n \n printlock.release()\n printQueue.put([output, mass_hist, sfr_hist])\n\ndef galaxyFitPlus(inputQueue, printQueue, printlock):\n for gal in iter(inputQueue.get, 'STOP'):\n mass_range = 7, 13\n log_sfr_min, log_sfr_max = -3, 4\n \n j = np.argmin(np.abs(z-zobs[gal])) # Find closest model redshift\n\n fo = obs[gal,:]\n ferr = obs_err[gal,:]\n\n\n flux_obs[fo <= 0.] = 0. # Set negative fluxes to zero\n #print fo\n I = (ferr > 0.)*(ferr < 1e6) # Find bands with no observation\n fo = flux_obs[I] # and exclude from fit\n ferr = flux_err[I]\n fm = f[I,j,:]\n #print flux_models[:,0,0,0,0] \n\n top = 0.\n bottom = 0.\n \n for i in range(len(fo)):\n top += (flux_models[i,:]*flux_obs[i])/(flux_err[i]**2)\n bottom += (flux_models[i,:]**2)/(flux_err[i]**2)\n \n scale = top/bottom\n scale = np.reshape(scale, (n_metal, n_tg, n_tau, n_tauv, n_fesc)) \n\n chisq = 0.\n for i in range(len(fo)):\n chisq += ((np.abs(scale*flux_models[i,:]-flux_obs[i])**2)/(flux_err[i])**2)\n\n chimin, minind = np.nanmin(chisq), np.nanargmin(chisq)\n\n chisq -= (chisq.min() - 1)\n likelihood = np.exp(-0.5*chisq)\n likelihood /= likelihood.sum()\n \n if np.isinf(chimin) or np.isnan(minind) or len(fo) == 0:\n output_string = '{0} {1} {2} {3} {4} {5} {6} {7} {8} {9} \\\n {10} {11} {12} {13} {14} {15} {16} {17} {18}'.format(gal+1,ID[gal],zobs[gal],\n -99,-99,-99,-99,-99,-99,\n -99, -99, -99, -99,-99,-99,-99,\n len(I),-99,'\\n')\n \n massLikelihood = np.zeros(mass_bins+1)\n massLikelihood[0] = gal\n muvLikelihood = np.zeros(muv_bins+1)\n muvLikelihood[0] = gal\n betaLikelihood = np.zeros(beta_bins+1)\n betaLikelihood[0] = gal\n #tauLikelihood = np.zeros(n_tau) \n #tauLikelihood = np.insert(tauLikelihood,0,gal) \n printQueue.put([output_string,massLikelihood,muvLikelihood,betaLikelihood])\n continue\n\n #Find the coordinate of the model with the bestfit mass\n si,tgi,tvi,ti,mi = np.unravel_index(minind,(mass_bins,n_tg,n_tauv,n_tau,n_ssp))\n Bestfit_Mass = np.log10(mass_range[si]*flux_corr)\n Bestfit_SFR = (mass_range[si]*SFR[tgi,ti,mi]*flux_corr)\n Bestfit_Beta = beta[tgi,tvi,ti,mi]\n\n F_rest = f[:,0]*mass_range[likelihood.argmax(0)]*flux_corr\n restframeMags = 23.9 - 2.5*np.log10(F_rest)\n \n UV_rest = UV_flux[0]*mass_range[likelihood.argmax(0)]*flux_corr\n restframeMUV = 23.9 - 2.5*np.log10(UV_rest)\n\n Bestfit_restframeMags = restframeMags[:,tgi,tvi,ti,mi]\n Bestfit_restframeMUV = restframeMUV[tgi,tvi,ti,mi]\n\n if np.isnan(Bestfit_Mass) or np.isinf(chimin):\n Bestfit_Mass = -99\n #M_scaled[:] = -99\n tgs = -99\n tvs = -99\n taus = -99\n mis = -99\n\n else:\n tgs = tg[tgi]/1.e9\n tvs = tv[tvi]\n taus = tau[ti]/1.e9\n mis = mi\n \n \"\"\"\n Likelihood array section:\n \"\"\"\n mass_hist = np.histogram(np.log10(mass_))\n \n printlock.acquire()\n\n if calc_mode:\n print('{0:4d} {1:6d} {2:>6.2f} {3:>8.1f} {4:>6.2f}'.format(gal+1,ID[gal],Bestfit_Mass,chimin, np.log10(Mode_Mass), '/n'))\n else:\n print('{0:6d} {1:8f} {2:>5.2f} {3:>7.2f} {4:>8.1f} {5:>8.3f} {6:>5.1f} {7:>8.2f} {8:>3d} {9:>5.2f}'.format(gal+1,int(ID[gal]),zobs[gal],Bestfit_Mass,chimin,tgs,tvs,taus,mis,np.log10(Bestfit_SFR)))\n\n output_string = '{0} {1} {2} {3} {4} {5} {6} {7} {8} {9} {10} {11} {12} {13} {14} {15}'.format(gal+1,int(ID[gal]),zobs[gal],Bestfit_Mass,chimin,tgs,tvs,taus,mis,Bestfit_restframeMags[tot],Bestfit_restframeMUV,minind,Bestfit_SFR,len(I),Bestfit_Beta,'\\n')\n\n printlock.release()\n printQueue.put([output_string, massLikelihoods, muvLikelihoods, betaLikelihoods])\n\n\ndef getObservations(inputpath):\n input_data = Table.read(inputpath,format=input_format)\n\n column_names = list(input_data.columns.keys())\n\n ID = input_data[ID_col]\n zobs = input_data[z_col]\n\n filter_names = []\n\n k,l = 0,0\n for ii in range(len(column_names)):\n if column_names[ii].lower().endswith(flux_col_end.lower()):\n if k == 0:\n fluxes = input_data[column_names[ii]]\n else:\n fluxes = np.column_stack((fluxes,input_data[column_names[ii]]))\n k+=1\n filter_names.append(column_names[ii])\n\n if column_names[ii].lower().endswith(fluxerr_col_end.lower()):\n if l == 0:\n fluxerrs = input_data[column_names[ii]]\n else:\n fluxerrs = np.column_stack((fluxerrs,input_data[column_names[ii]]))\n l+=1\n \"\"\" \n if filts_used != None:\n try:\n fluxes = fluxes[:,filts_used]\n fluxerrs = fluxerrs[:,filts_used]\n except:r\n print('Filter mismatch 1')\n # Array slicing fail\n \"\"\"\n return ID, zobs, fluxes, fluxerrs, k, filter_names\n\nclass _function_wrapper(object):\n \"\"\"\n This is a hack to make the likelihood function pickleable when ``args``\n or ``kwargs`` are also included.\n \n Stolen from emcee\n \"\"\"\n def __init__(self, f, args, kwargs):\n self.f = f\n self.args = args\n self.kwargs = kwargs\n\n def __call__(self, x):\n try:\n return self.f(x, *self.args, **self.kwargs)\n except:\n import traceback\n print(\"emcee: Exception while calling your likelihood function:\")\n print(\" params:\", x)\n print(\" args:\", self.args)\n print(\" kwargs:\", self.kwargs)\n print(\" exception:\")\n traceback.print_exc()\n raise\n\ndef weighted_quantile(values, quantiles, sample_weight=None, values_sorted=False, old_style=False):\n \"\"\" Very close to np.percentile, but supports weights.\n NOTE: quantiles should be in [0, 1]!\n :param values: np.array with data\n :param quantiles: array-like with many quantiles needed\n :param sample_weight: array-like of the same length as `array`\n :param values_sorted: bool, if True, then will avoid sorting of initial array\n :param old_style: if True, will correct output to be consistent with np.percentile.\n :return: np.array with computed quantiles.\n \"\"\"\n values = np.array(values)\n quantiles = np.array(quantiles)\n if sample_weight is None:\n sample_weight = np.ones(len(values))\n sample_weight = np.array(sample_weight)\n assert np.all(quantiles >= 0) and np.all(quantiles <= 1), 'quantiles should be in [0, 1]'\n\n if not values_sorted:\n sorter = np.argsort(values)\n values = values[sorter]\n sample_weight = sample_weight[sorter]\n\n weighted_quantiles = np.cumsum(sample_weight) - 0.5 * sample_weight\n if old_style:\n # To be convenient with np.percentile\n weighted_quantiles -= weighted_quantiles[0]\n weighted_quantiles /= weighted_quantiles[-1]\n else:\n weighted_quantiles /= np.sum(sample_weight)\n return np.interp(quantiles, weighted_quantiles, values)\n\nif __name__ == '__main__':\n \n logfile = open(\"error.log\", \"w\")\n original_stderr = sys.stderr\n sys.stderr = logfile\n \n start = time.time()\n \n \"\"\"\n SECTION 1\n\n \"\"\"\n model_path = params.model_path\n\n input_catalog = params.input_catalog\n input_format = params.input_format\n z_col = params.z_col\n ID_col = params.ID_col\n flux_col_end = params.flux_col_end\n fluxerr_col_end = params.fluxerr_col_end\n\n ncpus = params.ncpus\n filts_used = params.filts_used\n include_rest = params.include_rest\n \n output_path = params.output_catalog_path\n output_format = params.output_format\n output_hdf_path = params.output_hdf_path\n \n calc_mode = params.fitting_mode\n flux_corr = params.flux_corr \n\n \n ID, zobs, obs, obs_err, filters_found, filter_names = getObservations(input_catalog)\n \n \"\"\"\n Section 2\n \n \"\"\"\n\n\n print(\"Loading synthetic mags and mass array:\")\n models = h5py.File(model_path, 'r')\n tg = models['ages'].value\n tv = models['dust'].value\n tau = models['sfh'].value\n metallicities = models['metallicities'].value\n fesc = models['fesc'].value\n\n Mshape = models['fluxes'].shape\n z = models['z']\n nfilts = Mshape[1]\n n_metal = Mshape[2] \n n_tg = Mshape[3]\n n_tau = Mshape[4]\n n_tauv = Mshape[5]\n n_fesc = Mshape[6]\n \n #UV_flux = synmags['UV_flux']\n SFR = models['SFR']\n Ms = models['Ms']\n\n if (nfilts == filters_found) and (filts_used == None):\n f = models['fluxes']\n \n elif filts_used != None:\n try: \n f = models['fluxes'][:,filts_used]\n obs = obs[:,filts_used]\n obs_err = obs_err[:,filts_used]\n filter_names = np.array(filter_names)[filts_used]\n except:\n print('Mis-match between model and observed filter numbers')\n raise\n # Slice fail\n\n print (\"Done.\")\n\n \"\"\"\n SECTION 3\n \"\"\"\n if os.path.isfile(output_path+\".temp_output.txt\"):\n os.remove(output_path+\".temp_output.txt\")\n temp_file = open(output_path+\".temp_output.txt\",\"w\")\n \n \"\"\"\n SECTION 4\n Chi-sq calculation\n\n \"\"\"\n out_string = '{0:6s} {1:8s} {2:>5s} {3:>7s} {4:>8s} {5:>8s}' + \\\n '{6:>5s} {7:>8s} {8:>4s} {9:>5s}'\n\n print(out_string.format('N','ID','zobs','Best', 'chimin', \n 'tg', 'tauv','tau','met', 'sfr'))\n\n loop_start = time.time()\n ncpus = np.clip(ncpus, 1, multiprocessing.cpu_count())\n\n inputQueue = multiprocessing.Queue()\n printQueue = multiprocessing.Queue()\n printlock = multiprocessing.Lock()\n \n if calc_mode == 'hist':\n output_hdf = h5py.File(output_hdf_path, 'w')\n output_hdf.create_dataset(\"mass_pdf\", (len(ID), 120), dtype=\"f\")\n output_hdf.create_dataset(\"sfr_pdf\", (len(ID), 140), dtype=\"f\")\n fitFunction = galaxyFit2\n \n else:\n fitFunction = galaxyFit\n \n for i in range( ncpus ):\n multiprocessing.Process(target = fitFunction,\n args = (inputQueue, printQueue,\n printlock)).start()\n\n # Put elements in the send queue for processing\n for gal in range( len(ID) ):\n inputQueue.put( gal )\n\n if calc_mode == 'hist':\n for i, gal in enumerate(ID):\n printout, mass_hist, sfr_hist = printQueue.get()\n if i == 0:\n mass_centers = 0.5*(mass_hist[1][1:] + mass_hist[1][:-1])\n sfr_centers = 0.5*(sfr_hist[1][1:] + sfr_hist[1][:-1])\n \n output_hdf.create_dataset(\"mass_bins\", data = mass_centers)\n output_hdf.create_dataset(\"sfr_bins\", data = sfr_centers) \n output_hdf[\"mass_pdf\"][i] = mass_hist[0]\n output_hdf[\"sfr_pdf\"][i] = sfr_hist[0]\n temp_file.write( printout )\n #tau_array.tofile(tau_file)\n else:\n for i, gal in enumerate(ID):\n printout = printQueue.get()\n temp_file.write( printout )\n #print len(mass_array), len(muv_array), len(beta_array)\n \n\n # Stop all the running processes\n for i in range( ncpus ):\n inputQueue.put( 'STOP' )\n\n # Close both send and receive queues\n inputQueue.close()\n printQueue.close()\n\n temp_file.close() \n models.close()\n output_hdf.close()\n print(\"Fitting time taken: {0:.2f} {1}\".format(time.time()-loop_start,\n '\\n'))\n \n \"\"\"\n Section 3\n Reload, format and save output table\n \"\"\"\n while temp_file.closed == False:\n pause(0.1)\n\n data = np.loadtxt(output_path+\".temp_output.txt\")\n try:\n rows, cols = data.shape\n except:\n cols = len(data)\n\n output = Table()\n\n names = ['N', 'ID', 'z', 'zmodel', \n 'Mass_best', 'SFR_best', 'chi_best', \n 'Age_best','Dust_best', 'SFH_best',\n 'Metallicity_best', 'fesc_best',\n 'Mass_median', 'Mass_l68', 'Mass_u68',\n 'SFR_median', 'SFR_l68', 'SFR_u68',\n 'Nfilts']\n \n units = [None, None, None, None,\n u.Msun, u.Msun/u.yr, None,\n u.Gyr, None, None, \n None, None,\n u.Msun, u.Msun, u.Msun,\n u.Msun/u.yr, u.Msun/u.yr, u.Msun/u.yr,\n None]\n \n types = ['i4', 'i4', 'f4', 'f4',\n 'f4', 'f4', 'f4',\n 'f4', 'f4', 'f4', \n 'f4', 'f4', \n 'f4', 'f4', 'f4',\n 'f4', 'f4', 'f4',\n 'i4']\n \n if include_rest:\n for name in filter_names:\n names.append(name[:-len(flux_col_end)]+'_rest')\n units.append(u.mag)\n types.append('f4')\n \n for col in range(cols):\n column = Column( data[:,col], name = names[col], unit=units[col], dtype=types[col])\n output.add_column(column)\n\n table_format = 'ascii.commented_header'\n output.sort('ID')\n if os.path.isfile(output_path):\n os.remove(output_path)\n output.write(output_path,format=table_format)\n print('Catalog saved')\n \n os.remove(temp_file.name)\n\n print()\n print(\"Total time taken: \"+str(time.time()-start))\n \n sys.stderr = original_stderr\n logfile.close()\n \n", "meta": {"hexsha": "c3e85afdfdee9ef07a1e191bf9bd299a9f45eb54", "size": 27412, "ext": "py", "lang": "Python", "max_stars_repo_path": "scripts/data/fitting.py", "max_stars_repo_name": "dunkenj/smpy", "max_stars_repo_head_hexsha": "2c7ad73726e8fcfbbdf3667a918f60890c84673f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 12, "max_stars_repo_stars_event_min_datetime": "2015-04-09T13:51:38.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-25T00:25:05.000Z", "max_issues_repo_path": "scripts/data/fitting.py", "max_issues_repo_name": "bamford/smpy", "max_issues_repo_head_hexsha": "2c7ad73726e8fcfbbdf3667a918f60890c84673f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2015-04-29T13:00:12.000Z", "max_issues_repo_issues_event_max_datetime": "2021-02-17T13:50:16.000Z", "max_forks_repo_path": "scripts/data/fitting.py", "max_forks_repo_name": "dunkenj/smpy", "max_forks_repo_head_hexsha": "2c7ad73726e8fcfbbdf3667a918f60890c84673f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2015-08-12T13:15:10.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-07T14:05:43.000Z", "avg_line_length": 36.7946308725, "max_line_length": 261, "alphanum_fraction": 0.5086093682, "include": true, "reason": "import numpy,from astropy", "num_tokens": 7632, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073655352404, "lm_q2_score": 0.3557748935136303, "lm_q1q2_score": 0.19589227684112065}} {"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# In[1]:\n\n\n# Copyright 2018 The TensorFlow Authors All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\n\"\"\"Simple example of contextual bandits simulation.\n\nCode corresponding to:\nDeep Bayesian Bandits Showdown: An Empirical Comparison of Bayesian Deep Networks\nfor Thompson Sampling, by Carlos Riquelme, George Tucker, and Jasper Snoek.\nhttps://arxiv.org/abs/1802.09127\n\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport time,sys\nimport tensorflow as tf\nfrom absl import app\nfrom absl import flags\nimport numpy as np\nimport os\nimport matplotlib.pyplot as plt\nimport matplotlib\n# print(matplotlib.get_backend())\nfrom bandits.helpers.benchmarker import Benchmarker\nfrom bandits.algorithms.lin_ucb import LinUCB\nfrom bandits.algorithms.lin_epsilon import LinEpsilon\nfrom bandits.algorithms.neural_lin_ucb import NeuralLinUCB\n\nfrom bandits.algorithms.bootstrapped_bnn_sampling import BootstrappedBNNSampling\nfrom bandits.core.contextual_bandit import run_contextual_bandit\n# from bandits.data.data_sampler import sample_mushroom_data\nfrom bandits.algorithms.fixed_policy_sampling import FixedPolicySampling\nfrom bandits.algorithms.linear_full_posterior_sampling import LinearFullPosteriorSampling\nfrom bandits.algorithms.neural_linear_sampling import NeuralLinearPosteriorSampling\nfrom bandits.algorithms.parameter_noise_sampling import ParameterNoiseSampling\nfrom bandits.algorithms.posterior_bnn_sampling import PosteriorBNNSampling\nfrom bandits.data.synthetic_data_sampler import sample_linear_data\nfrom bandits.data.synthetic_data_sampler import sample_wheel_bandit_data\nfrom bandits.data.environments import *\nfrom bandits.data.wasserstein_gans import WGANCovertype\n\nfrom bandits.data.bootstrap_thompson_sampling import generate_uniform_artificial, gan_artificial_covertype,\\\n gan_artificial_mushroom, gan_artificial_linear, gan_artificial_wheel\n\nfrom bandits.algorithms.neural_linear_sampling import NeuralLinearPosteriorSampling\nfrom bandits.data.synthetic_data_sampler import sample_sparse_linear_data\nfrom bandits.data.synthetic_data_sampler import sample_wheel_bandit_data\nfrom bandits.algorithms.uniform_sampling import UniformSampling\n\nbase_route = os.getcwd()\ndata_route = 'contextual_bandits/datasets'\n\nFLAGS = flags.FLAGS\nFLAGS.set_default('alsologtostderr', True)\n\nflags.DEFINE_string('logdir', base_route, 'Base directory to save output')\nFLAGS(sys.argv)\n\n############# STARTS HERE ##############\"\"\"\nname = \"linear\"\ntest_name = \"full_analysis_\" + name\n\nif name==\"linear\":\n num_actions = 8\n context_dim = 10\n num_contexts = 1500\n # noise_stds = [0.01 * (i + 1) for i in range(num_actions)]\n noise_stds = [1 for i in range(num_actions)]\n\n wgan = WGANCovertype(context_dim, file=\"linear\")\n wgan.train(epochs=400, batch_size=32, sample_interval=50)\n artificial_data_generator = lambda: gan_artificial_linear(wgan, n_samples=50, n_actions=num_actions)\n\nelif name==\"mushroom\":\n num_actions = 2\n context_dim = 117\n num_contexts = 1500\n from bandits.data.wasserstein_gans import WGANMushroom\n wgan = WGANMushroom(context_dim)\n wgan.train(epochs=2000, batch_size=32, sample_interval=50)\n artificial_data_generator = lambda: gan_artificial_mushroom(wgan, n_samples=50, n_actions=num_actions)\n\nelif name==\"wheel\":\n num_actions = 5\n context_dim = 2\n num_contexts = 1500\n delta = 0.95\n mean_v = [1.0, 1.0, 1.0, 1.0, 1.2]\n std_v = [0.05, 0.05, 0.05, 0.05, 0.05]\n mu_large = 50\n std_large = 0.01\n from bandits.data.wasserstein_gans import WGANCovertype\n wgan = WGANCovertype(context_dim, file=\"wheel\")\n wgan.train(epochs=1000, batch_size=32, sample_interval=50)\n artificial_data_generator = lambda: gan_artificial_wheel(wgan, n_samples=50, n_actions=num_actions)\n\n\nelif name==\"covertype\":\n num_actions = 7\n context_dim = 54\n num_contexts = 1500\n from bandits.data.wasserstein_gans import WGANCovertype\n wgan = WGANCovertype(context_dim)\n wgan.train(epochs=4000, batch_size=32, sample_interval=50)\n artificial_data_generator = lambda: gan_artificial_covertype(wgan, n_samples=50, n_actions=num_actions)\nelse:\n raise Exception('name not recognized')\n\ndef dataset_proto(name=name):\n if name==\"linear\":\n dataset, _, opt_linear = sample_linear_data(num_contexts, context_dim,\n num_actions, sigma=noise_stds)\n elif name==\"wheel\":\n dataset, opt_linear = sample_wheel_bandit_data(num_contexts, delta,\n mean_v, std_v,\n mu_large, std_large)\n\n\n elif name==\"mushroom\":\n mush = Mushrooms(num_contexts=num_contexts)\n dataset = mush.table\n opt_rewards, opt_actions = mush.opts[:,0], mush.opts[:,1]\n opt_linear = (opt_rewards, opt_actions)\n\n elif name==\"covertype\":\n cov = Covertype(num_contexts=num_contexts)\n dataset = cov.table\n opt_rewards, opt_actions = cov.opts[:,0], cov.opts[:,1]\n opt_linear = (opt_rewards, opt_actions)\n\n return dataset, opt_linear\n\nprint(dataset_proto()[0].shape)\n\n\n# Params for algo templates\nhparams = tf.contrib.training.HParams(num_actions=num_actions)\n\nhparams_linear = tf.contrib.training.HParams(num_actions=num_actions,\n context_dim=context_dim,\n a0=6,\n b0=6,\n lambda_prior=0.25,\n initial_pulls=2)\n\nhparams_rms = tf.contrib.training.HParams(num_actions=num_actions,\n context_dim=context_dim,\n init_scale=0.3,\n activation=tf.nn.relu,\n layer_sizes=[50],\n batch_size=512,\n activate_decay=True,\n initial_lr=0.1,\n max_grad_norm=5.0,\n show_training=False,\n freq_summary=1000,\n buffer_s=-1,\n initial_pulls=2,\n optimizer='RMS',\n reset_lr=True,\n lr_decay_rate=0.5,\n training_freq=50,\n training_epochs=50,\n bootstrap=None)\n\nhparams_rms_bootstrapped = tf.contrib.training.HParams(num_actions=num_actions,\n context_dim=context_dim,\n init_scale=0.3,\n activation=tf.nn.relu,\n layer_sizes=[50],\n batch_size=512,\n activate_decay=True,\n initial_lr=0.1,\n max_grad_norm=5.0,\n show_training=False,\n freq_summary=1000,\n buffer_s=-1,\n initial_pulls=2,\n optimizer='RMS',\n reset_lr=True,\n lr_decay_rate=0.5,\n training_freq=50,\n training_epochs=50,\n bootstrap=artificial_data_generator)\n\nhparams_rmsb = tf.contrib.training.HParams(num_actions=num_actions,\n context_dim=context_dim,\n init_scale=0.3,\n activation=tf.nn.relu,\n layer_sizes=[50],\n batch_size=512,\n activate_decay=True,\n initial_lr=0.1,\n max_grad_norm=5.0,\n show_training=False,\n freq_summary=1000,\n buffer_s=-1,\n initial_pulls=2,\n optimizer='RMS',\n reset_lr=True,\n lr_decay_rate=0.5,\n training_freq=50,\n training_epochs=50,\n bootstrap=None,\n q=3,p=0.95)\n\nhparams_rmsb_bootstrapped = tf.contrib.training.HParams(num_actions=num_actions,\n context_dim=context_dim,\n init_scale=0.3,\n activation=tf.nn.relu,\n layer_sizes=[50],\n batch_size=512,\n activate_decay=True,\n initial_lr=0.1,\n max_grad_norm=5.0,\n show_training=False,\n freq_summary=1000,\n buffer_s=-1,\n initial_pulls=2,\n optimizer='RMS',\n reset_lr=True,\n lr_decay_rate=0.5,\n training_freq=50,\n training_epochs=50,\n q=3,p=0.95,\n bootstrap=artificial_data_generator)\n\nhparams_dropout = tf.contrib.training.HParams(num_actions=num_actions,\n context_dim=context_dim,\n init_scale=0.3,\n use_dropout=True,\n keep_prob=0.95,\n activation=tf.nn.relu,\n layer_sizes=[50],\n batch_size=512,\n activate_decay=True,\n initial_lr=0.1,\n max_grad_norm=5.0,\n show_training=False,\n freq_summary=1000,\n buffer_s=-1,\n initial_pulls=2,\n optimizer='RMS',\n reset_lr=True,\n lr_decay_rate=0.5,\n training_freq=50,\n training_epochs=50,\n bootstrap=None)\n\nhparams_dropout_bootstrapped = tf.contrib.training.HParams(num_actions=num_actions,\n context_dim=context_dim,\n init_scale=0.3,\n use_dropout=True,\n keep_prob=0.95,\n activation=tf.nn.relu,\n layer_sizes=[50],\n batch_size=512,\n activate_decay=True,\n initial_lr=0.1,\n max_grad_norm=5.0,\n show_training=False,\n freq_summary=1000,\n buffer_s=-1,\n initial_pulls=2,\n optimizer='RMS',\n reset_lr=True,\n lr_decay_rate=0.5,\n training_freq=50,\n training_epochs=50,\n bootstrap=artificial_data_generator)\n\nhparams_linucb = tf.contrib.training.HParams(num_actions=num_actions,\n context_dim=context_dim,\n alpha=1,\n lam=0.1)\n\nhparams_neural_linucb = tf.contrib.training.HParams(num_actions=num_actions,\n context_dim=context_dim,\n init_scale=0.3,\n activation=tf.nn.relu,\n layer_sizes=[50],\n batch_size=512,\n activate_decay=True,\n initial_lr=0.1,\n max_grad_norm=5.0,\n show_training=False,\n freq_summary=1000,\n buffer_s=-1,\n initial_pulls=2,\n optimizer='RMS',\n reset_lr=True,\n lr_decay_rate=0.5,\n training_freq=50,\n training_epochs=50,\n training_freq_network=50,\n bootstrap=None,\n alpha=1,\n lam=0.1)\nhparams_neural_linucb_bootstrapped = tf.contrib.training.HParams(num_actions=num_actions,\n context_dim=context_dim,\n init_scale=0.3,\n activation=tf.nn.relu,\n layer_sizes=[50],\n batch_size=512,\n activate_decay=True,\n initial_lr=0.1,\n max_grad_norm=5.0,\n show_training=False,\n freq_summary=1000,\n buffer_s=-1,\n initial_pulls=2,\n optimizer='RMS',\n reset_lr=True,\n lr_decay_rate=0.5,\n training_freq=50,\n training_epochs=50,\n training_freq_network=50,\n bootstrap=artificial_data_generator,\n alpha=1,\n lam=0.1)\nhparams_neural_linthomson = tf.contrib.training.HParams(num_actions=num_actions,\n context_dim=context_dim,\n init_scale=0.3,\n activation=tf.nn.relu,\n layer_sizes=[50],\n batch_size=512,\n activate_decay=True,\n initial_lr=0.1,\n max_grad_norm=5.0,\n show_training=False,\n freq_summary=1000,\n buffer_s=-1,\n optimizer='RMS',\n reset_lr=True,\n lr_decay_rate=0.5,\n training_freq=50,\n training_epochs=50,\n training_freq_network=50,\n bootstrap=None,\n a0=6,\n b0=6,\n lambda_prior=0.25,\n initial_pulls=2)\n\nhparams_neural_linthomson_bootstrapped = tf.contrib.training.HParams(num_actions=num_actions,\n context_dim=context_dim,\n init_scale=0.3,\n activation=tf.nn.relu,\n layer_sizes=[50],\n batch_size=512,\n activate_decay=True,\n initial_lr=0.1,\n max_grad_norm=5.0,\n show_training=False,\n freq_summary=1000,\n buffer_s=-1,\n optimizer='RMS',\n reset_lr=True,\n lr_decay_rate=0.5,\n training_freq=50,\n training_epochs=50,\n training_freq_network=50,\n bootstrap=artificial_data_generator,\n a0=6,\n b0=6,\n lambda_prior=0.25,\n initial_pulls=2)\n\nhparams_pnoise = tf.contrib.training.HParams(num_actions=num_actions,\n context_dim=context_dim,\n init_scale=0.3,\n activation=tf.nn.relu,\n layer_sizes=[50],\n batch_size=512,\n activate_decay=True,\n initial_lr=0.1,\n max_grad_norm=5.0,\n show_training=False,\n freq_summary=1000,\n buffer_s=-1,\n initial_pulls=2,\n optimizer='RMS',\n reset_lr=True,\n lr_decay_rate=0.5,\n training_freq=50,\n training_epochs=100,\n noise_std=0.05,\n eps=0.1,\n d_samples=300\n )\n\nhparams_pnoise_bootstrapped = tf.contrib.training.HParams(num_actions=num_actions,\n context_dim=context_dim,\n init_scale=0.3,\n activation=tf.nn.relu,\n layer_sizes=[50],\n batch_size=512,\n activate_decay=True,\n initial_lr=0.1,\n max_grad_norm=5.0,\n show_training=False,\n freq_summary=1000,\n buffer_s=-1,\n initial_pulls=2,\n optimizer='RMS',\n reset_lr=True,\n lr_decay_rate=0.5,\n training_freq=50,\n training_epochs=100,\n noise_std=0.05,\n eps=0.1,\n d_samples=300,\n bootstrap=artificial_data_generator\n )\n\nhparams_lineps = tf.contrib.training.HParams(num_actions=num_actions,\n context_dim=context_dim,\n lam=0.1,\n eps=0.05)\n\nrandom_proto = lambda : UniformSampling('Uniform Sampling', hparams)\nneural_greedy_proto = lambda : PosteriorBNNSampling('NeuralGreedy', hparams_rms, 'RMSProp')\nneural_greedy_proto_bootstrapped = lambda : PosteriorBNNSampling('NeuralGreedy_artificial_data', hparams_rms_bootstrapped, 'RMSProp')\n\nbootstrap_proto = lambda : BootstrappedBNNSampling('BootRMS', hparams_rmsb)\nbootstrap_proto_bootstrapped = lambda : BootstrappedBNNSampling('BootRMS_artificial_data', hparams_rmsb_bootstrapped)\n\nnoise_proto = lambda : ParameterNoiseSampling('ParamNoise', hparams_pnoise)\nnoise_proto_bootstrapped = lambda : ParameterNoiseSampling('ParamNoise_artificial_data', hparams_pnoise_bootstrapped)\n\ndropout_proto = lambda : PosteriorBNNSampling('Dropout', hparams_dropout, 'RMSProp')\ndropout_proto_bootstrapped = lambda : PosteriorBNNSampling('Dropout_artificial_data', hparams_dropout_bootstrapped, 'RMSProp')\n\nlinThompson_proto = lambda : LinearFullPosteriorSampling('linThompson', hparams_linear)\nlinUCB_proto = lambda : LinUCB('linUCB', hparams_linucb)\nlinEps_proto = lambda : LinEpsilon('LinEpsilon', hparams_lineps)\n\nneuralLinUCB_proto = lambda : NeuralLinUCB('NeuralLinUCB', hparams_neural_linucb, 'RMSProp')\nneuralLinThomson_proto = lambda : NeuralLinearPosteriorSampling('NeuralLinThomson', hparams_neural_linthomson, 'RMSProp')\nneuralLinUCB_proto_bootstrapped = lambda : NeuralLinUCB('NeuralLinUCB_artificial_data', hparams_neural_linucb_bootstrapped, 'RMSProp')\nneuralLinThomson_proto_bootstrapped = lambda : NeuralLinearPosteriorSampling('NeuralLinThomson_artificial_data', hparams_neural_linthomson_bootstrapped, 'RMSProp')\n\nalgo_protos = [linUCB_proto,\n neuralLinUCB_proto, neuralLinUCB_proto_bootstrapped,\n dropout_proto, dropout_proto_bootstrapped,\n bootstrap_proto, bootstrap_proto_bootstrapped,\n noise_proto, noise_proto_bootstrapped,\n neuralLinThomson_proto, neuralLinThomson_proto_bootstrapped,\n linEps_proto,\n linThompson_proto,\n neural_greedy_proto, neural_greedy_proto_bootstrapped,\n random_proto]\n\n# Run experiments several times save and plot results\nbenchmarker = Benchmarker(algo_protos, dataset_proto, num_actions, context_dim, nb_contexts=num_contexts, test_name=test_name)\n\nbenchmarker.run_experiments(50)\nbenchmarker.save_results('./results/')\nbenchmarker.save_final_res_to_tex('./results/')\nbenchmarker.display_results(save_path='./results/')\n", "meta": {"hexsha": "af52e2671bddba33c4214f466ab0968c4ebe0e66", "size": 24219, "ext": "py", "lang": "Python", "max_stars_repo_path": "research/deep_contextual_bandits/run_full_analysis.py", "max_stars_repo_name": "pedevineau/models", "max_stars_repo_head_hexsha": "ca93c26d3520240ceb8601497cffb676dc06f8ca", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-22T09:41:03.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-22T09:41:03.000Z", "max_issues_repo_path": "research/deep_contextual_bandits/run_full_analysis.py", "max_issues_repo_name": "pedevineau/models", "max_issues_repo_head_hexsha": "ca93c26d3520240ceb8601497cffb676dc06f8ca", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "research/deep_contextual_bandits/run_full_analysis.py", "max_forks_repo_name": "pedevineau/models", "max_forks_repo_head_hexsha": "ca93c26d3520240ceb8601497cffb676dc06f8ca", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-01-13T09:41:00.000Z", "max_forks_repo_forks_event_max_datetime": "2019-01-13T09:41:00.000Z", "avg_line_length": 50.45625, "max_line_length": 163, "alphanum_fraction": 0.4590197779, "include": true, "reason": "import numpy", "num_tokens": 3971, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073507867328, "lm_q2_score": 0.35577489351363034, "lm_q1q2_score": 0.195892271593972}} {"text": "# -*- coding: utf-8 -*-\n# vim: tabstop=4 shiftwidth=4 softtabstop=4\n#\n# Copyright (C) 2017-2018 GEM Foundation\n#\n# OpenQuake is free software: you can redistribute it and/or modify it\n# under the terms of the GNU Affero General Public License as published\n# by the Free Software Foundation, either version 3 of the License, or\n# (at your option) any later version.\n#\n# OpenQuake is distributed in the hope that it will be useful,\n# but WITHOUT ANY WARRANTY; without even the implied warranty of\n# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n# GNU Affero General Public License for more details.\n#\n# You should have received a copy of the GNU Affero General Public License\n# along with OpenQuake. If not, see .\n\n\"\"\"\nModule exports :class:`MunsonThurber1997`\n :class:`MunsonThurber1997Vector`.\n\"\"\"\nimport numpy as np\n\nfrom openquake.hazardlib.gsim.base import GMPE\nfrom openquake.hazardlib import const\nfrom openquake.hazardlib.imt import PGA\n\n\nclass MunsonThurber1997(GMPE):\n \"\"\"\n Implements GMPE developed by Clifford G. Munson and Clifford H. Thurber\n and published as \"Analysis of the Attenuation of Strong Ground Motion\n on the Island of Hawaii\" (1997, Bulletin of the Seismological Society\n of America, Vol. 87, No. 4, pp. 954-960).\n \"\"\"\n\n #: Supported tectonic region type is volcanic,\n #: see paragraph 'Introduction', page 99.\n DEFINED_FOR_TECTONIC_REGION_TYPE = const.TRT.VOLCANIC\n\n #: Supported intensity measure types is spectral acceleration,\n #: see table 3, pag. 110\n DEFINED_FOR_INTENSITY_MEASURE_TYPES = set([PGA])\n\n #: Supported intensity measure component is maximum horizontal\n #: :attr:`~openquake.hazardlib.const.IMC.VECTORIAL`,\n DEFINED_FOR_INTENSITY_MEASURE_COMPONENT = const.IMC.HORIZONTAL\n\n #: Supported standard deviation type is total\n DEFINED_FOR_STANDARD_DEVIATION_TYPES = set([\n const.StdDev.TOTAL\n ])\n\n #: Required site parameters is Vs30.\n #: See paragraph 'Predictor Variables', pag 103\n REQUIRES_SITES_PARAMETERS = set(('vs30', ))\n\n #: Required rupture parameter is magnitude\n REQUIRES_RUPTURE_PARAMETERS = set(('mag', ))\n\n #: Required distance measure is hypocentral distance\n #: see page 18 in Atkinson and Boore's manuscript\n REQUIRES_DISTANCES = set(('rjb', ))\n\n def get_mean_and_stddevs(self, sites, rup, dists, imt, stddev_types):\n \"\"\"\n See :meth:`superclass method\n <.base.GroundShakingIntensityModel.get_mean_and_stddevs>`\n for spec of input and result values.\n \"\"\"\n\n # Distance term\n R = np.sqrt(dists.rjb ** 2 + 11.29 ** 2)\n\n # Magnitude term\n M = rup.mag - 6\n\n # Site term only distinguishes between lava and ash;\n # since ash sites have Vs30 in the range 60-200m/s,\n # we use this upper value as class separator\n S = np.zeros(R.shape)\n S[sites.vs30 <= 200] = 1\n\n # Mean ground motion (log10)\n mean = (0.518 + 0.387*M - np.log10(R) - 0.00256*R + 0.335*S)\n\n # Converting to natural log\n mean /= np.log10(np.e)\n\n # Check for standard deviation type\n assert all(stddev_type in self.DEFINED_FOR_STANDARD_DEVIATION_TYPES\n for stddev_type in stddev_types)\n\n # Constant (total) standard deviation\n stddevs = [0.237/np.log10(np.e) + np.zeros(R.shape)]\n\n return mean, stddevs\n\n\nclass MunsonThurber1997Vector(MunsonThurber1997):\n \"\"\"\n Modification of the original base class to correct mean ground motion\n to geometric mean of horizontal components (Beyer and Bommer, 2006)\n \"\"\"\n\n #: Supported intensity measure component is geometric mean of horizontal\n #: :attr:`~openquake.hazardlib.const.IMC.VECTORIAL`,\n DEFINED_FOR_INTENSITY_MEASURE_COMPONENT = const.IMC.VECTORIAL\n\n def get_mean_and_stddevs(self, sites, rup, dists, imt, stddev_types):\n mean, stddevs = super().get_mean_and_stddevs(sites, rup, dists,\n imt, stddev_types)\n\n # Conversion to geometric mean of horizontal components\n # using the coefficient in Beyer and Bommer, 2006\n mean += np.log(1.1)\n\n return mean, stddevs\n", "meta": {"hexsha": "a82a24861f96476bdf02ea293986bf10e85ab361", "size": 4255, "ext": "py", "lang": "Python", "max_stars_repo_path": "openquake/hazardlib/gsim/munson_thurber_1997.py", "max_stars_repo_name": "gfzriesgos/shakyground-lfs", "max_stars_repo_head_hexsha": "2caf67cc32e6800286eded2df1efb05973ccf41b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-08-01T00:28:24.000Z", "max_stars_repo_stars_event_max_datetime": "2019-08-01T00:28:24.000Z", "max_issues_repo_path": "openquake/hazardlib/gsim/munson_thurber_1997.py", "max_issues_repo_name": "gfzriesgos/shakyground-lfs", "max_issues_repo_head_hexsha": "2caf67cc32e6800286eded2df1efb05973ccf41b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2018-08-31T14:14:35.000Z", "max_issues_repo_issues_event_max_datetime": "2021-10-11T12:53:13.000Z", "max_forks_repo_path": "openquake/hazardlib/gsim/munson_thurber_1997.py", "max_forks_repo_name": "gfzriesgos/shakyground-lfs", "max_forks_repo_head_hexsha": "2caf67cc32e6800286eded2df1efb05973ccf41b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2018-08-31T14:11:00.000Z", "max_forks_repo_forks_event_max_datetime": "2019-07-17T10:06:02.000Z", "avg_line_length": 35.4583333333, "max_line_length": 76, "alphanum_fraction": 0.683666275, "include": true, "reason": "import numpy", "num_tokens": 1082, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073655352403, "lm_q2_score": 0.35577487985229844, "lm_q1q2_score": 0.19589226931909068}} {"text": "# Licensed under a 3-clause BSD style license - see LICENSE.rst\nfrom copy import deepcopy\nimport numpy as np\nimport astropy.io.fits as fits\nimport astropy.units as u\nfrom gammapy.irf import EDispKernel\nfrom gammapy.maps import Map, MapCoord, WcsGeom\nfrom gammapy.utils.random import InverseCDFSampler, get_random_state\n\n__all__ = [\"make_edisp_map\", \"EDispMap\"]\n\n\ndef make_edisp_map(edisp, pointing, geom, exposure_map=None):\n \"\"\"Make a edisp map for a single observation\n\n Expected axes : migra and true energy in this specific order\n The name of the migra MapAxis is expected to be 'migra'\n\n Parameters\n ----------\n edisp : `~gammapy.irf.EnergyDispersion2D`\n the 2D Energy Dispersion IRF\n pointing : `~astropy.coordinates.SkyCoord`\n the pointing direction\n geom : `~gammapy.maps.Geom`\n the map geom to be used. It provides the target geometry.\n rad and true energy axes should be given in this specific order.\n exposure_map : `~gammapy.maps.Map`, optional\n the associated exposure map.\n default is None\n\n Returns\n -------\n edispmap : `~gammapy.cube.EDispMap`\n the resulting EDisp map\n \"\"\"\n energy_axis = geom.get_axis_by_name(\"energy\")\n energy = energy_axis.center\n\n migra_axis = geom.get_axis_by_name(\"migra\")\n migra = migra_axis.center\n\n # Compute separations with pointing position\n offset = geom.separation(pointing)\n\n # Compute EDisp values\n edisp_values = edisp.data.evaluate(\n offset=offset,\n e_true=energy[:, np.newaxis, np.newaxis, np.newaxis],\n migra=migra[:, np.newaxis, np.newaxis],\n )\n\n # Create Map and fill relevant entries\n data = edisp_values.to_value(\"\")\n edispmap = Map.from_geom(geom, data=data, unit=\"\")\n return EDispMap(edispmap, exposure_map)\n\n\nclass EDispMap:\n \"\"\"Energy dispersion map.\n\n Parameters\n ----------\n edisp_map : `~gammapy.maps.Map`\n the input Energy Dispersion Map. Should be a Map with 2 non spatial axes.\n migra and true energy axes should be given in this specific order.\n exposure_map : `~gammapy.maps.Map`, optional\n Associated exposure map. Needs to have a consistent map geometry.\n\n Examples\n --------\n ::\n\n import numpy as np\n from astropy import units as u\n from astropy.coordinates import SkyCoord\n from gammapy.maps import WcsGeom, MapAxis\n from gammapy.irf import EnergyDispersion2D, EffectiveAreaTable2D\n from gammapy.cube import make_edisp_map, make_map_exposure_true_energy\n\n # Define energy dispersion map geometry\n energy_axis = MapAxis.from_edges(np.logspace(-1, 1, 4), unit=\"TeV\", name=\"energy\")\n migra_axis = MapAxis.from_edges(np.linspace(0, 3, 100), name=\"migra\")\n pointing = SkyCoord(0, 0, unit=\"deg\")\n max_offset = 4 * u.deg\n geom = WcsGeom.create(\n binsz=0.25 * u.deg,\n width=10 * u.deg,\n skydir=pointing,\n axes=[migra_axis, energy_axis],\n )\n\n # Extract EnergyDispersion2D from CTA 1DC IRF\n filename = \"$GAMMAPY_DATA/cta-1dc/caldb/data/cta/1dc/bcf/South_z20_50h/irf_file.fits\"\n edisp2D = EnergyDispersion2D.read(filename, hdu=\"ENERGY DISPERSION\")\n aeff2d = EffectiveAreaTable2D.read(filename, hdu=\"EFFECTIVE AREA\")\n\n # Create the exposure map\n exposure_geom = geom.to_image().to_cube([energy_axis])\n exposure_map = make_map_exposure_true_energy(pointing, \"1 h\", aeff2d, exposure_geom)\n\n # create the EDispMap for the specified pointing\n edisp_map = make_edisp_map(edisp2D, pointing, geom, max_offset, exposure_map)\n\n # Get an Energy Dispersion (1D) at any position in the image\n pos = SkyCoord(2.0, 2.5, unit=\"deg\")\n e_reco = np.logspace(-1.0, 1.0, 10) * u.TeV\n edisp = edisp_map.get_edisp_kernel(pos=pos, e_reco=e_reco)\n\n # Write map to disk\n edisp_map.write(\"edisp_map.fits\")\n \"\"\"\n\n def __init__(self, edisp_map, exposure_map):\n if edisp_map.geom.axes[1].name.upper() != \"ENERGY\":\n raise ValueError(\"Incorrect energy axis position in input Map\")\n\n if edisp_map.geom.axes[0].name.upper() != \"MIGRA\":\n raise ValueError(\"Incorrect migra axis position in input Map\")\n\n self.edisp_map = edisp_map\n self.exposure_map = exposure_map\n\n @classmethod\n def from_hdulist(\n cls,\n hdulist,\n edisp_hdu=\"EDISPMAP\",\n edisp_hdubands=\"BANDSEDISP\",\n exposure_hdu=\"EXPMAP\",\n exposure_hdubands=\"BANDSEXP\",\n ):\n \"\"\"Convert to `~astropy.io.fits.HDUList`.\n\n Parameters\n ----------\n edisp_hdu : str\n Name or index of the HDU with the edisp_map data.\n edisp_hdubands : str\n Name or index of the HDU with the edisp_map BANDS table.\n exposure_hdu : str\n Name or index of the HDU with the exposure_map data.\n exposure_hdubands : str\n Name or index of the HDU with the exposure_map BANDS table.\n \"\"\"\n edisp_map = Map.from_hdulist(hdulist, edisp_hdu, edisp_hdubands, \"auto\")\n if exposure_hdu in hdulist:\n exposure_map = Map.from_hdulist(\n hdulist, exposure_hdu, exposure_hdubands, \"auto\"\n )\n else:\n exposure_map = None\n\n return cls(edisp_map, exposure_map)\n\n @classmethod\n def read(cls, filename, **kwargs):\n \"\"\"Read an edisp_map from file and create an EDispMap object\"\"\"\n with fits.open(filename, memmap=False) as hdulist:\n return cls.from_hdulist(hdulist, **kwargs)\n\n def to_hdulist(\n self,\n edisp_hdu=\"EDISPMAP\",\n edisp_hdubands=\"BANDSEDISP\",\n exposure_hdu=\"EXPMAP\",\n exposure_hdubands=\"BANDSEXP\",\n ):\n \"\"\"Convert to `~astropy.io.fits.HDUList`.\n\n Parameters\n ----------\n edisp_hdu : str\n Name or index of the HDU with the edisp_map data.\n edisp_hdubands : str\n Name or index of the HDU with the edisp_map BANDS table.\n exposure_hdu : str\n Name or index of the HDU with the exposure_map data.\n exposure_hdubands : str\n Name or index of the HDU with the exposure_map BANDS table.\n\n Returns\n -------\n hdu_list : `~astropy.io.fits.HDUList`\n \"\"\"\n hdulist = self.edisp_map.to_hdulist(hdu=edisp_hdu, hdu_bands=edisp_hdubands)\n if self.exposure_map is not None:\n new_hdulist = self.exposure_map.to_hdulist(\n hdu=exposure_hdu, hdu_bands=exposure_hdubands\n )\n hdulist.extend(new_hdulist[1:])\n return hdulist\n\n def write(self, filename, overwrite=False, **kwargs):\n \"\"\"Write to fits\"\"\"\n hdulist = self.to_hdulist(**kwargs)\n hdulist.writeto(filename, overwrite=overwrite)\n\n def get_edisp_kernel(self, position, e_reco, migra_step=5e-3):\n \"\"\"Get energy dispersion at a given position.\n\n Parameters\n ----------\n position : `~astropy.coordinates.SkyCoord`\n the target position. Should be a single coordinates\n e_reco : `~astropy.units.Quantity`\n Reconstructed energy axis binning\n migra_step : float\n Integration step in migration\n\n Returns\n -------\n edisp : `~gammapy.irf.EnergyDispersion`\n the energy dispersion (i.e. rmf object)\n \"\"\"\n # TODO: reduce code duplication with EnergyDispersion2D.get_response\n if position.size != 1:\n raise ValueError(\n \"EnergyDispersion can be extracted at one single position only.\"\n )\n\n # axes ordering fixed. Could be changed.\n pix_ener = np.arange(self.edisp_map.geom.axes[1].nbin)\n\n # Define a vector of migration with mig_step step\n mrec_min = self.edisp_map.geom.axes[0].edges[0]\n mrec_max = self.edisp_map.geom.axes[0].edges[-1]\n mig_array = np.arange(mrec_min, mrec_max, migra_step)\n pix_migra = (mig_array - mrec_min) / mrec_max * self.edisp_map.geom.axes[0].nbin\n\n # Convert position to pixels\n pix_lon, pix_lat = self.edisp_map.geom.to_image().coord_to_pix(position)\n\n # Build the pixels tuple\n pix = np.meshgrid(pix_lon, pix_lat, pix_migra, pix_ener)\n # Interpolate in the EDisp map. Squeeze to remove dimensions of length 1\n edisp_values = self.edisp_map.interp_by_pix(pix) * u.Unit(self.edisp_map.unit)\n edisp_values = np.squeeze(edisp_values, axis=(0, 1))\n\n e_trues = self.edisp_map.geom.axes[1].center\n data = []\n\n for i, e_true in enumerate(e_trues):\n # We now perform integration over migra\n # The code is adapted from `~gammapy.EnergyDispersion2D.get_response`\n\n # migration value of e_reco bounds\n migra_e_reco = e_reco / e_true\n\n # Compute normalized cumulative sum to prepare integration\n tmp = np.nan_to_num(\n np.cumsum(edisp_values[:, i]) / np.sum(edisp_values[:, i])\n )\n\n # Determine positions (bin indices) of e_reco bounds in migration array\n pos_mig = np.digitize(migra_e_reco, mig_array) - 1\n # We ensure that no negative values are found\n pos_mig = np.maximum(pos_mig, 0)\n\n # We compute the difference between 2 successive bounds in e_reco\n # to get integral over reco energy bin\n integral = np.diff(tmp[pos_mig])\n\n data.append(integral)\n\n data = np.asarray(data)\n # EnergyDispersion uses edges of true energy bins\n e_true_edges = self.edisp_map.geom.axes[1].edges\n\n e_lo, e_hi = e_true_edges[:-1], e_true_edges[1:]\n ereco_lo, ereco_hi = (e_reco[:-1], e_reco[1:])\n\n return EDispKernel(\n e_true_lo=e_lo,\n e_true_hi=e_hi,\n e_reco_lo=ereco_lo,\n e_reco_hi=ereco_hi,\n data=data,\n )\n\n def stack(self, other, weights=None):\n \"\"\"Stack EDispMap with another one in place.\n\n Parameters\n ----------\n other : `~gammapy.cube.EDispMap`\n Energy dispersion map to be stacked with this one.\n\n \"\"\"\n if self.exposure_map is None or other.exposure_map is None:\n raise ValueError(\"Missing exposure map for PSFMap.stack\")\n\n cutout_info = other.edisp_map.geom.cutout_info\n\n if cutout_info is not None:\n slices = cutout_info[\"parent-slices\"]\n parent_slices = Ellipsis, slices[0], slices[1]\n else:\n parent_slices = None\n\n self.edisp_map.data[parent_slices] *= self.exposure_map.data[parent_slices]\n self.edisp_map.stack(other.edisp_map * other.exposure_map.data, weights=weights)\n\n # stack exposure map\n self.exposure_map.stack(other.exposure_map, weights=weights)\n\n with np.errstate(invalid=\"ignore\"):\n self.edisp_map.data[parent_slices] /= self.exposure_map.data[parent_slices]\n self.edisp_map.data = np.nan_to_num(self.edisp_map.data)\n\n def copy(self):\n \"\"\"Copy EDispMap\"\"\"\n return deepcopy(self)\n\n @classmethod\n def from_geom(cls, geom):\n \"\"\"Create edisp map from geom.\n\n By default a diagonal edisp matrix is created.\n\n Parameters\n ----------\n geom : `Geom`\n Edisp map geometry.\n\n Returns\n -------\n edisp_map : `EDispMap`\n Energy dispersion map.\n \"\"\"\n geom_exposure_edisp = geom.squash(axis=\"migra\")\n exposure_edisp = Map.from_geom(geom_exposure_edisp, unit=\"m2 s\")\n\n migra_axis = geom.get_axis_by_name(\"migra\")\n edisp_map = Map.from_geom(geom, unit=\"\")\n loc = migra_axis.edges.searchsorted(1.0)\n edisp_map.data[:, loc, :, :] = 1.0\n return cls(edisp_map, exposure_edisp)\n\n def sample_coord(self, map_coord, random_state=0):\n \"\"\"Apply the energy dispersion corrections on the coordinates of a set of simulated events.\n\n Parameters\n ----------\n map_coord : `~gammapy.maps.MapCoord` object.\n Sequence of coordinates and energies of sampled events.\n random_state : {int, 'random-seed', 'global-rng', `~numpy.random.RandomState`}\n Defines random number generator initialisation.\n Passed to `~gammapy.utils.random.get_random_state`.\n\n Returns\n -------\n `~gammapy.maps.MapCoord`.\n Sequence of Edisp-corrected coordinates of the input map_coord map.\n \"\"\"\n random_state = get_random_state(random_state)\n migra_axis = self.edisp_map.geom.get_axis_by_name(\"migra\")\n\n coord = {\n \"skycoord\": map_coord.skycoord.reshape(-1, 1),\n \"energy\": map_coord[\"energy\"].reshape(-1, 1),\n \"migra\": migra_axis.center,\n }\n\n pdf_edisp = self.edisp_map.interp_by_coord(coord)\n\n sample_edisp = InverseCDFSampler(pdf_edisp, axis=1, random_state=random_state)\n pix_edisp = sample_edisp.sample_axis()\n migra = migra_axis.pix_to_coord(pix_edisp)\n\n energy_reco = map_coord[\"energy\"] * migra\n\n return MapCoord.create({\"skycoord\": map_coord.skycoord, \"energy\": energy_reco})\n\n @classmethod\n def from_diagonal_response(cls, energy_axis_true, migra_axis=None):\n \"\"\"Create an allsky EDisp map with diagonal response.\n\n Parameters\n ----------\n energy_axis_true : `MapAxis`\n True energy axis\n migra_axis : `MapAxis`\n Migra axis\n\n Returns\n -------\n edisp_map : `EDispMap`\n Energy dispersion map.\n \"\"\"\n from .fit import MIGRA_AXIS_DEFAULT\n\n migra_axis = migra_axis or MIGRA_AXIS_DEFAULT\n\n geom = WcsGeom.create(\n npix=(2, 1), proj=\"CAR\", binsz=180, axes=[migra_axis, energy_axis_true]\n )\n\n return cls.from_geom(geom)\n\n def cutout(self, position, width, mode=\"trim\"):\n \"\"\"Cutout edisp map.\n\n Parameters\n ----------\n position : `~astropy.coordinates.SkyCoord`\n Center position of the cutout region.\n width : tuple of `~astropy.coordinates.Angle`\n Angular sizes of the region in (lon, lat) in that specific order.\n If only one value is passed, a square region is extracted.\n mode : {'trim', 'partial', 'strict'}\n Mode option for Cutout2D, for details see `~astropy.nddata.utils.Cutout2D`.\n\n Returns\n -------\n cutout : `EdispMap`\n Cutout edisp map.\n \"\"\"\n edisp_map = self.edisp_map.cutout(position, width, mode)\n exposure_map = self.exposure_map.cutout(position, width, mode)\n return self.__class__(edisp_map=edisp_map, exposure_map=exposure_map)\n", "meta": {"hexsha": "efcc82518f4ebcafafb398943cdea78c01ab3c9b", "size": 14880, "ext": "py", "lang": "Python", "max_stars_repo_path": "gammapy/cube/edisp_map.py", "max_stars_repo_name": "QRemy/gammapy", "max_stars_repo_head_hexsha": "fe799e8a8e792d216fdb11fb7abcb64d58f273dd", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "gammapy/cube/edisp_map.py", "max_issues_repo_name": "QRemy/gammapy", "max_issues_repo_head_hexsha": "fe799e8a8e792d216fdb11fb7abcb64d58f273dd", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "gammapy/cube/edisp_map.py", "max_forks_repo_name": "QRemy/gammapy", "max_forks_repo_head_hexsha": "fe799e8a8e792d216fdb11fb7abcb64d58f273dd", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.2606635071, "max_line_length": 99, "alphanum_fraction": 0.6235887097, "include": true, "reason": "import numpy,import astropy,from astropy", "num_tokens": 3694, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073655352404, "lm_q2_score": 0.3557748798522984, "lm_q1q2_score": 0.19589226931909068}} {"text": "#!/usr/bin/env python\n# Copyright 2014-2019 The PySCF Developers. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n# Author: Qiming Sun \n#\n\n'''Non-relativistic UKS analytical nuclear gradients'''\n\nimport time\nimport numpy\nimport scipy.linalg\nfrom pyscf import lib\nfrom pyscf.lib import logger\nfrom pyscf.grad import rhf as rhf_grad\nfrom pyscf.grad import rks as rks_grad\nfrom pyscf.grad import uhf as uhf_grad\nfrom pyscf.dft import numint, gen_grid\nfrom pyscf import __config__\n\n\ndef get_veff(ks_grad, mol=None, dm=None):\n '''Coulomb + XC functional\n '''\n if mol is None: mol = ks_grad.mol\n if dm is None: dm = ks_grad.base.make_rdm1()\n t0 = (time.clock(), time.time())\n\n mf = ks_grad.base\n ni = mf._numint\n if ks_grad.grids is not None:\n grids = ks_grad.grids\n else:\n grids = mf.grids\n if grids.coords is None:\n grids.build(with_non0tab=True)\n\n if mf.nlc != '':\n raise NotImplementedError\n #enabling range-separated hybrids\n omega, alpha, hyb = ni.rsh_and_hybrid_coeff(mf.xc, spin=mol.spin)\n\n mem_now = lib.current_memory()[0]\n max_memory = max(2000, ks_grad.max_memory*.9-mem_now)\n if ks_grad.grid_response:\n exc, vxc = get_vxc_full_response(ni, mol, grids, mf.xc, dm,\n max_memory=max_memory,\n verbose=ks_grad.verbose)\n logger.debug1(ks_grad, 'sum(grids response) %s', exc.sum(axis=0))\n else:\n exc, vxc = get_vxc(ni, mol, grids, mf.xc, dm,\n max_memory=max_memory, verbose=ks_grad.verbose)\n t0 = logger.timer(ks_grad, 'vxc', *t0)\n\n if abs(hyb) < 1e-10:\n vj = ks_grad.get_j(mol, dm)\n vxc += vj[0] + vj[1]\n else:\n vj, vk = ks_grad.get_jk(mol, dm)\n vk *= hyb\n if abs(omega) > 1e-10: # For range separated Coulomb operator\n with mol.with_range_coulomb(omega):\n vk += ks_grad.get_k(mol, dm) * (alpha - hyb)\n vxc += vj[0] + vj[1] - vk\n\n return lib.tag_array(vxc, exc1_grid=exc)\n\n\ndef get_vxc(ni, mol, grids, xc_code, dms, relativity=0, hermi=1,\n max_memory=2000, verbose=None):\n xctype = ni._xc_type(xc_code)\n make_rho, nset, nao = ni._gen_rho_evaluator(mol, dms, hermi)\n ao_loc = mol.ao_loc_nr()\n\n vmat = numpy.zeros((2,3,nao,nao))\n if xctype == 'LDA':\n ao_deriv = 1\n for ao, mask, weight, coords \\\n in ni.block_loop(mol, grids, nao, ao_deriv, max_memory):\n rho_a = make_rho(0, ao[0], mask, 'LDA')\n rho_b = make_rho(1, ao[0], mask, 'LDA')\n vxc = ni.eval_xc(xc_code, (rho_a,rho_b), 1, relativity, 1, verbose)[1]\n vrho = vxc[0]\n aow = numpy.einsum('pi,p->pi', ao[0], weight*vrho[:,0])\n rks_grad._d1_dot_(vmat[0], mol, ao[1:4], aow, mask, ao_loc, True)\n aow = numpy.einsum('pi,p->pi', ao[0], weight*vrho[:,1])\n rks_grad._d1_dot_(vmat[1], mol, ao[1:4], aow, mask, ao_loc, True)\n rho = vxc = vrho = aow = None\n\n elif xctype == 'GGA':\n ao_deriv = 2\n for ao, mask, weight, coords \\\n in ni.block_loop(mol, grids, nao, ao_deriv, max_memory):\n rho_a = make_rho(0, ao[:4], mask, 'GGA')\n rho_b = make_rho(1, ao[:4], mask, 'GGA')\n vxc = ni.eval_xc(xc_code, (rho_a,rho_b), 1, relativity, 1, verbose)[1]\n wva, wvb = numint._uks_gga_wv0((rho_a,rho_b), vxc, weight)\n\n rks_grad._gga_grad_sum_(vmat[0], mol, ao, wva, mask, ao_loc)\n rks_grad._gga_grad_sum_(vmat[1], mol, ao, wvb, mask, ao_loc)\n rho_a = rho_b = vxc = wva = wvb = None\n\n elif xctype == 'NLC':\n raise NotImplementedError('NLC')\n else:\n raise NotImplementedError('meta-GGA')\n\n exc = numpy.zeros((mol.natm,3))\n # - sign because nabla_X = -nabla_x\n return exc, -vmat\n\n\ndef get_vxc_full_response(ni, mol, grids, xc_code, dms, relativity=0, hermi=1,\n max_memory=2000, verbose=None):\n '''Full response including the response of the grids'''\n xctype = ni._xc_type(xc_code)\n make_rho, nset, nao = ni._gen_rho_evaluator(mol, dms, hermi)\n ao_loc = mol.ao_loc_nr()\n aoslices = mol.aoslice_by_atom()\n\n excsum = 0\n vmat = numpy.zeros((2,3,nao,nao))\n if xctype == 'LDA':\n ao_deriv = 1\n for atm_id, (coords, weight, weight1) \\\n in enumerate(rks_grad.grids_response_cc(grids)):\n ngrids = weight.size\n sh0, sh1 = aoslices[atm_id][:2]\n mask = gen_grid.make_mask(mol, coords)\n ao = ni.eval_ao(mol, coords, deriv=ao_deriv, non0tab=mask)\n rho_a = make_rho(0, ao[0], mask, 'LDA')\n rho_b = make_rho(1, ao[0], mask, 'LDA')\n exc, vxc = ni.eval_xc(xc_code, (rho_a,rho_b), 1, relativity, 1, verbose)[:2]\n vrho = vxc[0]\n\n vtmp = numpy.zeros((3,nao,nao))\n aow = numpy.einsum('pi,p->pi', ao[0], weight*vrho[:,0])\n rks_grad._d1_dot_(vtmp, mol, ao[1:4], aow, mask, ao_loc, True)\n vmat[0] += vtmp\n excsum += numpy.einsum('r,r,nxr->nx', exc, rho_a+rho_b, weight1)\n excsum[atm_id] += numpy.einsum('xij,ji->x', vtmp, dms[0]) * 2\n\n vtmp = numpy.zeros((3,nao,nao))\n aow = numpy.einsum('pi,p->pi', ao[0], weight*vrho[:,1])\n rks_grad._d1_dot_(vtmp, mol, ao[1:4], aow, mask, ao_loc, True)\n vmat[1] += vtmp\n excsum[atm_id] += numpy.einsum('xij,ji->x', vtmp, dms[1]) * 2\n rho = vxc = vrho = aow = None\n\n elif xctype == 'GGA':\n ao_deriv = 2\n for atm_id, (coords, weight, weight1) \\\n in enumerate(rks_grad.grids_response_cc(grids)):\n ngrids = weight.size\n sh0, sh1 = aoslices[atm_id][:2]\n mask = gen_grid.make_mask(mol, coords)\n ao = ni.eval_ao(mol, coords, deriv=ao_deriv, non0tab=mask)\n rho_a = make_rho(0, ao[:4], mask, 'GGA')\n rho_b = make_rho(1, ao[:4], mask, 'GGA')\n exc, vxc = ni.eval_xc(xc_code, (rho_a,rho_b), 1, relativity, 1, verbose)[:2]\n wva, wvb = numint._uks_gga_wv0((rho_a,rho_b), vxc, weight)\n\n vtmp = numpy.zeros((3,nao,nao))\n rks_grad._gga_grad_sum_(vtmp, mol, ao, wva, mask, ao_loc)\n vmat[0] += vtmp\n excsum += numpy.einsum('r,r,nxr->nx', exc, rho_a[0]+rho_b[0], weight1)\n excsum[atm_id] += numpy.einsum('xij,ji->x', vtmp, dms[0]) * 2\n\n vtmp = numpy.zeros((3,nao,nao))\n rks_grad._gga_grad_sum_(vtmp, mol, ao, wvb, mask, ao_loc)\n vmat[1] += vtmp\n excsum[atm_id] += numpy.einsum('xij,ji->x', vtmp, dms[1]) * 2\n rho_a = rho_b = vxc = wva = wvb = None\n\n elif xctype == 'NLC':\n raise NotImplementedError('NLC')\n else:\n raise NotImplementedError('meta-GGA')\n\n # - sign because nabla_X = -nabla_x\n return excsum, -vmat\n\n\nclass Gradients(uhf_grad.Gradients):\n\n grid_response = getattr(__config__, 'grad_uks_Gradients_grid_response', False)\n\n def __init__(self, mf):\n uhf_grad.Gradients.__init__(self, mf)\n self.grids = None\n self.grid_response = False\n self._keys = self._keys.union(['grid_response', 'grids'])\n\n def dump_flags(self, verbose=None):\n uhf_grad.Gradients.dump_flags(self, verbose)\n logger.info(self, 'grid_response = %s', self.grid_response)\n return self\n\n get_veff = get_veff\n\n def extra_force(self, atom_id, envs):\n '''Hook for extra contributions in analytical gradients.\n\n Contributions like the response of auxiliary basis in density fitting\n method, the grid response in DFT numerical integration can be put in\n this function.\n '''\n if self.grid_response:\n vhf = envs['vhf']\n log = envs['log']\n log.debug('grids response for atom %d %s',\n atom_id, vhf.exc1_grid[atom_id])\n return vhf.exc1_grid[atom_id]\n else:\n return 0\n\nGrad = Gradients\n\nfrom pyscf import dft\ndft.uks.UKS.Gradients = dft.uks_symm.UKS.Gradients = lib.class_as_method(Gradients)\n\n\nif __name__ == '__main__':\n from pyscf import gto\n from pyscf import dft\n\n mol = gto.Mole()\n mol.atom = [\n ['O' , (0. , 0. , 0.)],\n [1 , (0. , -0.757 , 0.587)],\n [1 , (0. , 0.757 , 0.587)] ]\n mol.basis = '631g'\n mol.charge = 1\n mol.spin = 1\n mol.build()\n mf = dft.UKS(mol)\n mf.conv_tol = 1e-12\n #mf.grids.atom_grid = (20,86)\n e0 = mf.scf()\n g = mf.Gradients()\n print(lib.finger(g.kernel()) - -0.12090786243525126)\n#[[-5.23195019e-16 -5.70291415e-16 5.32918387e-02]\n# [ 1.33417513e-16 6.75277008e-02 -2.66519852e-02]\n# [ 1.72274651e-16 -6.75277008e-02 -2.66519852e-02]]\n g.grid_response = True\n print(lib.finger(g.kernel()) - -0.12091122429043633)\n#[[-2.95956939e-16 -4.22275612e-16 5.32998759e-02]\n# [ 1.34532051e-16 6.75279140e-02 -2.66499379e-02]\n# [ 1.68146089e-16 -6.75279140e-02 -2.66499379e-02]]\n\n mf.xc = 'b88,p86'\n e0 = mf.scf()\n g = Gradients(mf)\n print(lib.finger(g.kernel()) - -0.11509739136150157)\n#[[ 2.58483362e-16 5.82369026e-16 5.17616036e-02]\n# [-5.46977470e-17 6.39273304e-02 -2.58849008e-02]\n# [ 5.58302713e-17 -6.39273304e-02 -2.58849008e-02]]\n g.grid_response = True\n print(lib.finger(g.kernel()) - -0.11507986316077731)\n\n mf.xc = 'b3lypg'\n e0 = mf.scf()\n g = Gradients(mf)\n print(lib.finger(g.kernel()) - -0.10202554999695367)\n#[[ 6.47874920e-16 -2.75292214e-16 3.97215970e-02]\n# [-6.60278148e-17 5.87909340e-02 -1.98650384e-02]\n# [ 6.75500259e-18 -5.87909340e-02 -1.98650384e-02]]\n\n\n mol = gto.Mole()\n mol.atom = [\n ['H' , (0. , 0. , 1.804)],\n ['F' , (0. , 0. , 0. )], ]\n mol.unit = 'B'\n mol.basis = '631g'\n mol.charge = -1\n mol.spin = 1\n mol.build()\n\n mf = dft.UKS(mol)\n mf.conv_tol = 1e-14\n mf.kernel()\n print(lib.finger(Gradients(mf).kernel()) - 0.10365160440876001)\n# sum over z direction non-zero, due to meshgrid response\n# H -0.0000000000 0.0000000000 -0.1481125370\n# F -0.0000000000 0.0000000000 0.1481164667\n mf = dft.UKS(mol)\n mf.grids.prune = None\n mf.grids.level = 6\n mf.conv_tol = 1e-14\n mf.kernel()\n print(lib.finger(Gradients(mf).kernel()) - 0.10365040148752827)\n# H 0.0000000000 0.0000000000 -0.1481124925\n# F -0.0000000000 0.0000000000 0.1481122913\n\n", "meta": {"hexsha": "bea5561995c94b617be6b821b5ccecceb5793122", "size": 11055, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyscf/grad/uks.py", "max_stars_repo_name": "crisely09/pyscf", "max_stars_repo_head_hexsha": "cb92f7974bd9c87c0ef5b2b52abf5d3219b3d6b6", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-04-07T21:12:08.000Z", "max_stars_repo_stars_event_max_datetime": "2020-04-07T21:12:08.000Z", "max_issues_repo_path": "pyscf/grad/uks.py", "max_issues_repo_name": "crisely09/pyscf", "max_issues_repo_head_hexsha": "cb92f7974bd9c87c0ef5b2b52abf5d3219b3d6b6", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2019-09-16T17:58:31.000Z", "max_issues_repo_issues_event_max_datetime": "2019-09-22T17:26:01.000Z", "max_forks_repo_path": "pyscf/grad/uks.py", "max_forks_repo_name": "crisely09/pyscf", "max_forks_repo_head_hexsha": "cb92f7974bd9c87c0ef5b2b52abf5d3219b3d6b6", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.009771987, "max_line_length": 88, "alphanum_fraction": 0.5921302578, "include": true, "reason": "import numpy,import scipy", "num_tokens": 3715, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6959583250334526, "lm_q2_score": 0.28140560140262283, "lm_q1q2_score": 0.19584657100720076}} {"text": "# This source reads a text file and produces a data set\n# The file is of the form (where [denotes optional and repeatable]:\n# X,Y,Z[,ARRAYNAME]\n# x0,y0,z0[,value]\n# x1,y1,z1[,value\n# ...\n# from paraview import vtk\n# from random import randint as randi\n# pdo=self.GetOutputDataObject(0)\n# pdi=self.GetInputDataObject(0,0)\n# pdo.CopyAttributes(pdi)\n# pdo.Allocate(500,1)\n# maxPt=pdi.GetNumberOfPoints()\n# for i in range(500):\n# \taLine = vtk.vtkLine()\n# \taLine.GetPointIds().SetId(0, randi(0, maxPt))\n# \taLine.GetPointIds().SetId(1, randi(0, maxPt))\n# \tpdo.InsertNextCell(aLine.GetCellType(), aLine.GetPointIds())\nfrom paraview import vtk\nfrom paraview.vtk import dataset_adapter as DA\nimport os, sys\nfrom numpy import array, single, zeros\nimport numpy\nimport os, sys\n\n\ndef loadFoam(cObj, cNum):\n cFile = \"/Users/maderk/Documents/MATLAB/TextureTensor/Foam/ujax/dk31m00/\"\n cFile += \"bubble_dk31_%02d.csv\" % cNum\n filterList = []\n # filterList+=[('MASK_DISTANCE_MEAN',lambda x: x>180)]\n # filterList+=[('VOLUME',lambda x: x<4000)]\n synList = []\n synList += [\n (\n \"Alignment\",\n lambda x: 180\n / numpy.pi\n * calcAlignment(x, \"PCA1_X\", \"PCA1_Y\", \"PCA1_Z\", \"VOLUME\"),\n )\n ]\n synList += [\n (\"ShapeAnisotropy\", lambda x: calcAnisotropy(x, \"PCA1_S\", \"PCA2_S\", \"PCA3_S\"))\n ]\n synList += [\n (\"ShapeOblateness\", lambda x: calcOblateness(x, \"PCA1_S\", \"PCA2_S\", \"PCA3_S\"))\n ]\n synList += [(\"PosTheta\", lambda x: calcTheta(x, \"POS_X\", \"POS_Y\", recenter=True))]\n synList += [(\"Theta\", lambda x: calcTheta(x, \"PCA1_X\", \"PCA2_Y\", recenter=False))]\n synList += [\n (\"Theta-XZ\", lambda x: chkgvlcalcTheta(x, \"PCA1_X\", \"PCA2_Z\", recenter=False))\n ]\n return ImportCSV(cObj, cFile, filterList, synList)\n\n\ndef initCol(cName, data, keepPoints):\n name = vtk.vtkTypeFloat32Array()\n name.SetNumberOfComponents(1)\n name.SetNumberOfTuples(0)\n name.SetName(cName)\n if keepPoints is None:\n keepPoints = range(0, len(data))\n for cI in keepPoints:\n name.InsertNextTuple((data[cI],))\n return name\n\n\ndef initCol3(cName, dat1, dat2, dat3, keepPoints=None):\n name = vtk.vtkTypeFloat32Array()\n name.SetNumberOfComponents(3)\n name.SetNumberOfTuples(0)\n name.SetName(cName)\n if keepPoints is None:\n keepPoints = range(0, len(dat1))\n for cI in keepPoints:\n name.InsertNextTuple((dat1[cI], dat2[cI], dat3[cI]))\n print (cName, len(keepPoints))\n return name\n\n\ndef initColTens(\n cName, dat1, dat2, dat3, dat4, dat5, dat6, dat7, dat8, dat9, keepPoints=None\n):\n name = vtk.vtkTypeFloat32Array()\n name.SetNumberOfComponents(9)\n name.SetNumberOfTuples(0)\n name.SetName(cName + \"_T\")\n if keepPoints is None:\n keepPoints = range(0, len(dat1))\n\n for cI in keepPoints:\n name.InsertNextTuple(\n (\n dat1[cI],\n dat2[cI],\n dat3[cI],\n dat4[cI],\n dat5[cI],\n dat6[cI],\n dat7[cI],\n dat8[cI],\n dat9[cI],\n )\n )\n print (cName, len(keepPoints))\n return name\n\n\ndef getTriplets(allCols, cn1=\"_X\", cn2=\"_Y\", cn3=\"_Z\"):\n xcols = filter(lambda x: (x.find(cn1) >= 0), allCols)\n xcols = filter(lambda x: not (x.find(\"T\" + cn1) >= 0), xcols)\n repPrefix = lambda x, y, z: z.join(x.split(y))\n goodList = [\n (\n repPrefix(curCol, cn1, \"\"),\n (\n repPrefix(curCol, cn1, cn1),\n repPrefix(curCol, cn1, cn2),\n repPrefix(curCol, cn1, cn3),\n ),\n )\n for curCol in xcols\n if (\n (repPrefix(curCol, cn1, cn2) in allCols)\n and (repPrefix(curCol, cn1, cn3) in allCols)\n )\n ]\n return goodList\n\n\ndef getTensors(\n allCols, cn1=[\"_XX\", \"_XY\", \"_XZ\", \"_YX\", \"_YY\", \"_YZ\", \"_ZX\", \"_ZY\", \"_ZZ\"]\n):\n xcols = filter(lambda x: x.find(\"T\" + cn1[0]) >= 0, allCols)\n repPrefix = lambda x, y, z: z.join(x.split(y))\n goodList = []\n for curCol in xcols:\n cRow = []\n for curEle in cn1:\n cName = repPrefix(curCol, cn1[0], curEle)\n if cName in allCols:\n cRow += [cName]\n else:\n cRow += [\"NULL\"]\n if len(cRow) > 2:\n goodList += [(repPrefix(curCol, cn1[0], \"\"), tuple(cRow))]\n return goodList\n\n\ndef wtexture(xv, yv, zv, wv):\n \"\"\" Since the function will be used alot and is tedious to implement \"\"\"\n xv = numpy.array(xv)\n yv = numpy.array(yv)\n zv = numpy.array(zv)\n wv = numpy.array(wv)\n\n swv = sum(wv)\n xm = numpy.multiply(xv, wv) / swv\n ym = numpy.multiply(yv, wv) / swv\n zm = numpy.multiply(zv, wv) / swv\n\n xv -= xm\n yv -= ym\n zv -= zm\n\n xv *= wv\n yv *= wv\n zv *= wv\n\n textMat = [[sum(xv * xv) / swv, sum(xv * yv) / swv, sum(xv * zv) / swv]]\n textMat += [[sum(yv * xv) / swv, sum(yv * yv) / swv, sum(yv * zv) / swv]]\n textMat += [[sum(zv * xv) / swv, sum(zv * yv) / swv, sum(zv * zv) / swv]]\n return textMat\n DA.numpyTovtkDataArray(numpy.random.rand(50, 1))\n\n\nimport numpy as np\n\n\nclass ctexture:\n def __init__(self, textMat):\n self.textMat = textMat\n (self._w, self._v) = np.linalg.eigh(textMat)\n # self._w=np.sqrt(self._w) # No sqrt in texture tensor\n\n def todict(self, name=\"TEXTURE\", length=1, oDict=None):\n if oDict is None:\n oDict = {}\n for (i, cAxI) in enumerate(\"XYZ\"):\n for (j, cAxJ) in enumerate(\"XYZ\"):\n oDict[name + \"T_\" + cAxI + cAxJ] = [self.textMat[i, j]] * length\n return oDict\n\n def mean(self):\n return sqrt(self.textMat.trace())\n\n def v1(self):\n return self._v[:, 2]\n\n def alignment(self):\n return 3.0 / 2.0 * (self._w[2] / sum(self._w) - 1.0 / 3.0) * 100\n\n\nclass lacDB_TEXT:\n def __init__(self):\n self.count = 0.0\n self.countn = 0\n self.sumx2 = 0.0\n self.sumx = 0.0\n self.sumxy = 0.0\n self.sumxz = 0.0\n self.sumy2 = 0.0\n self.sumyz = 0.0\n self.sumz2 = 0.0\n self.text = 0\n\n def step(self, valueX, valueY, valueZ, valueW=1.0):\n if valueX is None:\n return 0\n if valueY is None:\n return 0\n if valueZ is None:\n return 0\n if valueW is None:\n return 0\n self.count += valueW\n self.countn += 1\n self.sumx += valueW * valueX\n self.sumy += valueW * valueY\n self.sumz += valueW * valueZ\n\n self.sumx2 += valueW * valueX ** 2\n self.sumxy += valueW * valueX * valueY\n self.sumxz += valueW * valueX * valueZ\n self.sumy2 += valueW * valueY ** 2\n self.sumyz += valueW * valueY * valueZ\n self.sumz2 += valueW * valueZ ** 2\n\n def textMat(self):\n meanx = self.sumx / self.count\n meany = self.sumy / self.count\n meanz = self.sumz / self.count\n\n return np.array(\n [\n [\n self.sumx2 / self.count - meanx ** 2,\n self.sumxy / self.count - meanx * meany,\n self.sumxz / self.count - meanx * meanz,\n ],\n [\n self.sumxy / self.count - meanx * meany,\n self.sumy2 / self.count - meany ** 2,\n self.sumyz / self.count - meany * meanz,\n ],\n [\n self.sumxz / self.count - meany * meanz,\n self.sumyz / self.count - meany * meanz,\n self.sumz2 / self.count - meanz ** 2,\n ],\n ]\n )\n\n def finalize(self):\n if self.countn < 2:\n return 100\n self.text = ctexture(self.textMat())\n return self.text.alignment()\n\n\ndef calcAlignment(\n allcols, cn1, cn2, cn3, cnWeight=None, returnAxis=True, signedAxis=True\n):\n \"\"\" Since the function will be used alot and is tedious to implement \"\"\"\n ptlist = []\n ptlist += [allcols[cn1]]\n ptlist += [allcols[cn2]]\n ptlist += [allcols[cn3]]\n ptlist = numpy.array(ptlist)\n ptmag = numpy.sqrt(ptlist[0, :] ** 2 + ptlist[1, :] ** 2 + ptlist[2, :] ** 2)\n ptlist[0, :] /= ptmag\n ptlist[1, :] /= ptmag\n ptlist[2, :] /= ptmag\n if cnWeight is None:\n textMat = numpy.cov(ptlist)\n else:\n xv = ptlist[0, :]\n yv = ptlist[1, :]\n zv = ptlist[2, :]\n wv = numpy.array(allcols[cnWeight])\n textMat = wtexture(xv, yv, zv, wv)\n print (len(xv), len(wv))\n print textMat\n (_w, _v) = numpy.linalg.eigh(textMat)\n print \"Main Direction:\" + str(_v[:, 2]) + \", Overall alignment:\" + str(\n 3.0 / 2.0 * (_w[2] / sum(_w) - 1.0 / 3.0) * 100\n )\n\n if returnAxis:\n oMat = []\n sMat = []\n for cRow in range(3):\n mv = numpy.array([list(_v[:, cRow])] * ptlist.shape[1]).transpose()\n oMat += [numpy.abs(numpy.sum(numpy.multiply(ptlist, mv), 0))]\n sMat += [numpy.sign(numpy.sum(numpy.multiply(ptlist, mv), 0))]\n oAx = numpy.argmax(numpy.array(oMat), 0)\n if signedAxis:\n sMat = numpy.array(sMat).transpose()\n return numpy.array(\n map(lambda x: 2 * (x[1] + 1) + 1 * (x[0][x[1]] == 1), zip(sMat, oAx))\n )\n else:\n return oAx + 1\n else:\n mv = numpy.array([list(_v[:, 2])] * ptlist.shape[1]).transpose()\n return numpy.arccos(numpy.abs(numpy.sum(numpy.multiply(ptlist, mv), 0)))\n\n\ndef calcAnisotropy(allcols, cn1, cn2, cn3):\n \"\"\" Since the function will be used alot and is tedious to implement \"\"\"\n p1list = numpy.array(allcols[cn1])\n p2list = numpy.array(allcols[cn2])\n p3list = numpy.array(allcols[cn3])\n return 3.0 / 2.0 * (p1list / (p1list + p2list + p3list) - 1.0 / 3.0) * 100\n\n\ndef calcOblateness(allcols, cn1, cn2, cn3):\n \"\"\" Since the function will be used alot and is tedious to implement \"\"\"\n p1list = numpy.array(allcols[cn1])\n p2list = numpy.array(allcols[cn2])\n p3list = numpy.array(allcols[cn3])\n return 2 * (p1list - p2list) / (p1list - p3list) - 1\n\n\ndef calcTheta(allcols, cnx, cny, cnw=None, recenter=True):\n \"\"\" Since the function will be used alot and is tedious to implement \"\"\"\n p1list = numpy.array(allcols[cnx])\n p2list = numpy.array(allcols[cny])\n if cnw is not None:\n p3list = numpy.array(allcols[cnw])\n else:\n p3list = p1list * 0 + 1\n mx = numpy.multiply(p1list, p3list) / sum(p3list)\n my = numpy.multiply(p2list, p3list) / sum(p3list)\n if not recenter:\n mx = 0\n my = 0\n return 180 / numpy.pi * numpy.arctan2(p2list - my, p1list - mx)\n\n\ndef ImportCSV(cObj, filename=\"\", filterList=[], synList=[], outObj=0, fromR=False):\n cTable = cObj.GetOutputDataObject(outObj)\n (header, cols) = LoadCSVFile(filename, fromR=fromR)\n return ImportData(cTable, cols, filterList, synList)\n\n\ndef ImportDB(cObj, sqlRest=\"\", filterList=[], synList=[], outObj=0):\n cTable = cObj.GetOutputDataObject(outObj)\n if len(sqlRest) > 0:\n sqlRest = \"WHERE \" + sqlRest\n import dbImport as dbi\n\n cur = dbi.cur\n headerCols = [\n cCol[0] for cCol in cur.execute(\"SHOW COLUMNS FROM LACUNA\").fetchall()\n ]\n cols = {}\n for cCol in headerCols:\n cols[cCol] = []\n for cResult in cur.execute(\n \"SELECT \" + \",\".join(headerCols) + \" FROM LACUNA \" + sqlRest\n ):\n for (ccCol, cVal) in zip(headerCols, cResult):\n cols[ccCol] += [cVal]\n return ImportData(cTable, cols, filterList, synList)\n\n\ndef ImportData(output, cols, filterList=[], synList=[]):\n \"\"\" Filter list is for adding lambda based filters, synList is for synthetic columns \"\"\"\n\n print \"Importing Next Step...\"\n # ncols=lacpa_adddb(None,cols,header,'',False) # formatted and scaled\n # cols=ncols\n print \"Filtering List\"\n keepPoints = numpy.array([True] * len(cols.values()[0])) # only\n for (cFiltCol, cFiltFunc) in filterList:\n keepPoints &= map(cFiltFunc, cols[cFiltCol])\n print \"Keeping - \" + str((sum(keepPoints), len(keepPoints)))\n keepPoints = [cValue for (cValue, isKept) in enumerate(keepPoints) if isKept]\n for cKey in cols.keys():\n cols[cKey] = numpy.array(cols[cKey])[keepPoints]\n print \" Adding columns\"\n for (cName, cData) in cols.items():\n output.AddColumn(initCol(cName, cData, None))\n print \" Adding Triplets\"\n allTrips = getTriplets(cols.keys())\n print allTrips\n for (cName, cCols) in allTrips:\n output.AddColumn(\n initCol3(cName, cols[cCols[0]], cols[cCols[1]], cols[cCols[2]], None)\n )\n print \" Adding Tensors\"\n cols[\"NULL\"] = 0 * single(cols.values()[0])\n allTens = getTensors(cols.keys())\n print allTens\n for (cName, cCols) in allTens:\n output.AddColumn(\n initColTens(\n cName,\n cols[cCols[0]],\n cols[cCols[1]],\n cols[cCols[2]],\n cols[cCols[3]],\n cols[cCols[4]],\n cols[cCols[5]],\n cols[cCols[6]],\n cols[cCols[7]],\n cols[cCols[8]],\n None,\n )\n )\n\n print \" Adding synthetic columns\"\n for (cName, cFunc) in synList:\n output.AddColumn(initCol(cName, cFunc(cols), None))\n return output\n\n\ndef addRowsToTable(output, junkName, outMat, entry_order):\n # globals()['a']=entry_order\n # globals()['b']=outMat\n outArray = numpy.array(outMat)\n outDict = {}\n for (cI, cLabel) in enumerate(entry_order):\n outDict[cLabel] = outArray[:, cI]\n return outDict\n\n\nfrom numpy import single\n\n\ndef parseCSV(text, filename=\"\", fromR=False):\n def temp_clean(text):\n return (\"\".join(text.split(\"/\"))).upper().strip()\n\n def temp_parse(temp):\n ntemp = []\n errCount = 0\n for val in temp:\n if val.strip().upper() == \"NAN\":\n cval = \"0\"\n errCount += 1\n else:\n cval = val\n try:\n cval = single(cval)\n except:\n cval = -1\n errCount += 1\n ntemp += [cval]\n return (ntemp, errCount)\n\n rows = text.split(\"\\n\")\n # First row is header\n if fromR:\n fileDict = {}\n hRow = 0\n else:\n hRow = 1\n head1 = rows[0]\n head1 = \"\".join(head1.split(\"//\"))\n newStr = [cEle.strip().split(\":\") for cEle in head1.strip().split(\",\")]\n fileDict = {}\n for cEle in newStr:\n if len(cEle) == 2:\n fileDict[temp_clean(cEle[0])] = cEle[1].split(\"/\")[-1].strip()\n fTime = True\n head2 = rows[hRow]\n head2 = \"\".join(head2.split(\"//\"))\n head2 = [temp_clean(cEle) for cEle in head2.strip().split(\",\")]\n # Check for duplicates in header string (and just use the last entry)\n # Generate a dictionary of all header entries\n cleanHeader = {}\n for k in range(len(head2)):\n cleanHeader[head2[k]] = k\n # create a new null filled header\n head2 = [\"NULL\"] * len(head2)\n # use the dictionary to repopulate the head2 entry\n for cKey in cleanHeader.keys():\n head2[cleanHeader[cKey]] = cKey\n outTable = {}\n for col in head2:\n outTable[col] = []\n for row in rows[2:]:\n temp = row.split(\",\")\n try:\n (ntemp, errs) = temp_parse(temp)\n if errs < 2:\n if len(ntemp) == len(head2):\n for k in range(0, len(head2)):\n outTable[head2[k]] += [ntemp[k]]\n except:\n # if fTime: print (len(ntemp),len(head2))\n fTime = False\n temp = []\n for col in head2:\n outTable[col] = numpy.array(outTable[col])\n outrows = len(outTable[head2[0]])\n print \"Parsed .. \" + str(outrows) + \" of \" + str(len(rows))\n return (outrows, fileDict, outTable)\n\n\ndef LoadCSVFile(filename, fromR=False):\n if True:\n rawtext = \"\".join(open(filename).readlines())\n else:\n print filename + \" is garbage\"\n if True:\n (outrows, a, b) = parseCSV(rawtext, fromR=fromR)\n if outrows > 2:\n return (a, b)\n else:\n print filename + \" is too short!\" + str((outrows, a, b))\n else:\n print filename + \" is junk:\" + rawtext[0:100]\n\n\ndef getProjNum(*args):\n return 1\n\n\ndef getSampleNum(*args):\n return 1\n\n\ndef lacpa_adddb(\n cur,\n ptList,\n oTable,\n rawFilename,\n processName=True,\n tableName=\"Lacuna\",\n CanalMode=0,\n projectTitle=\"None\",\n):\n lacNumOffset = 0\n if processName:\n (filename, lacNumOffset) = processInputName(rawFilename, lacFilename)\n else:\n filename = rawFilename\n nptList = dict([(cCol.upper(), cDat) for (cCol, cDat) in ptList.items()])\n # ptList=CaseFreeDict(ptList)\n\n dbLen = len(ptList[\"SCALE_X\"])\n if not oTable.has_key(\"SAMPLE\"):\n oTable[\"SAMPLE\"] = \"\"\n print filename + \" is missing sample name\"\n dx = numpy.median(ptList[\"SCALE_X\"])\n dy = numpy.median(ptList[\"SCALE_Y\"])\n dz = numpy.median(ptList[\"SCALE_Z\"])\n dr = numpy.sqrt(dx ** 2 + dy ** 2 + dz ** 2)\n lacTemp = {}\n if type(projectTitle) is type(\"\"):\n cProjNum = getProjNum(cur, projectTitle)\n else:\n cProjNum = projectTitle\n cSampleNum = getSampleNum(cur, filename, cProjNum)\n lacTemp[\"SAMPLE_AIM_Number\"] = (cSampleNum,) * dbLen\n lacTemp[\"PROJECT\"] = (cProjNum,) * dbLen\n lacunIds = [lacId + lacNumOffset for lacId in ptList[\"LACUNA_NUMBER\"]]\n lacTemp[tableName + \"_NUMBER\"] = tuple(lacunIds)\n # Variables that scale directly with x,y,z voxel size\n lacTemp[\"VOX_SIZE\"] = tuple(numpy.abs(ptList[\"SCALE_X\"] * 1000))\n scaleVars = [\"POS\", \"STD\", \"PROJ\"]\n for cVar in scaleVars:\n for cAx in [\"X\", \"Y\", \"Z\"]:\n lacTemp[cVar + \"_\" + cAx] = tuple(\n ptList[cVar + \"_\" + cAx] * ptList[\"SCALE_\" + cAx]\n )\n # This doesnt work since I dont save PCA1,2,3 dumb\n # Variables that scale with PCA 1,2,3 voxel size * denotes PCA1, PCA2, PCA3\n pcaScaleVars = [\"*_S\", \"PROJ_*\"]\n for cAx in [\"PCA1\", \"PCA2\", \"PCA3\"]:\n cDr = numpy.sqrt(\n (ptList[cAx + \"_X\"] * dx) ** 2\n + (ptList[cAx + \"_Y\"] * dy) ** 2\n + (ptList[cAx + \"_Z\"] * dz) ** 2\n )\n for cVar in pcaScaleVars:\n rcVar = cAx.join(cVar.split(\"*\"))\n lacTemp[rcVar] = tuple(ptList[rcVar] * cDr)\n # Normal Variables\n normalVars = [\"PCA1_X\", \"PCA1_Y\", \"PCA1_Z\", \"PCA2_X\", \"PCA2_Y\", \"PCA2_Z\"]\n normalVars += [\"MASK_GRAD_X\", \"MASK_GRAD_Y\", \"MASK_GRAD_Z\", \"MASK_ANGLE\"]\n if CanalMode == 0:\n normalVars += [\"Canal_ANGLE\", \"Canal_GRAD_X\", \"Canal_GRAD_Y\", \"Canal_GRAD_Z\"]\n for cVar in normalVars:\n if ptList.has_key(cVar):\n lacTemp[cVar] = tuple(ptList[cVar])\n elif (cVar.find(\"GRAD\") >= 0) | (cVar.find(\"ANGLE\")):\n lacTemp[cVar] = (-1,) * dbLen\n else:\n print \"Missing important column:\" + cVar + \", what the frick!\"\n # Variables that require a radial scaling factor\n radialVars = [\"MASK_DISTANCE_MEAN\", \"MASK_DISTANCE_STD\"] # 'MASK_DISTANCE_COV'\n radialVars += [\"OBJ_RADIUS\", \"OBJ_RADIUS_STD\"]\n if CanalMode == 0:\n if ptList.has_key(cVar):\n radialVars += [\"Canal_DISTANCE_MEAN\", \"Canal_DISTANCE_STD\"]\n for cVar in radialVars:\n if ptList.has_key(cVar):\n lacTemp[cVar] = tuple(numpy.abs(ptList[cVar] * dr))\n # Variables that require a radial cubed scaling factor\n volVars = [\"VOLUME\", \"VOLUME_BOX\"]\n for cVar in volVars:\n lacTemp[cVar] = tuple(numpy.abs(ptList[cVar] * dx * dy * dz))\n if ptList.has_key(\"SHELL_CNT\"):\n lacTemp[\"VOLUME_LAYER\"] = tuple(\n numpy.abs((ptList[\"VOLUME\"] - ptList[\"SHELL_CNT\"]) * dx * dy * dz)\n )\n # GrayAnalysis Columns\n if ptList.has_key(\"MASK\"): # new Lacuna method\n lacTemp[\"MASK_DISTANCE_MEAN\"] = tuple(numpy.abs(ptList[\"MASK\"] * dr))\n lacTemp[\"MASK_DISTANCE_STD\"] = tuple(numpy.abs(ptList[\"MASK_STD\"] * dr))\n if ptList.has_key(\"MASK_WX\"):\n lacTemp[\"MASK_GRAD\"] = tuple(ptList[\"MASK\"])\n lacTemp[\"MASK_DISTANCE_STD\"] = tuple(ptList[\"MASK_STD\"])\n if ptList.has_key(\"SHELL_ABSORPTION\"):\n lacTemp[\"SHELL_ABSORPTION\"] = tuple(ptList[\"SHELL_ABSORPTION\"])\n if ptList.has_key(\"SHELL_ABSORPTION_STD\"):\n lacTemp[\"SHELL_ABSORPTION_STD\"] = tuple(ptList[\"SHELL_ABSORPTION_STD\"])\n else:\n lacTemp[\"SHELL_ABSORPTION\"] = (-1,) * dbLen\n lacTemp[\"SHELL_ABSORPTION_STD\"] = (-1,) * dbLen\n # Lining Absorption\n if ptList.has_key(\"LINING_ABSORPTION\"):\n lacTemp[\"LINING_ABSORPTION\"] = tuple(ptList[\"LINING_ABSORPTION\"])\n if ptList.has_key(\"LINING_ABSORPTION_STD\"):\n lacTemp[\"LINING_ABSORPTION_STD\"] = tuple(ptList[\"LINING_ABSORPTION_STD\"])\n else:\n lacTemp[\"LINING_ABSORPTION\"] = (-1,) * dbLen\n lacTemp[\"LINING_ABSORPTION_STD\"] = (-1,) * dbLen\n if CanalMode == 0:\n # This doesnt work since I dont save PCA1,2,3 dumb\n # Variables that scale with PCA 1,2,3 voxel size * denotes PCA1, PCA2, PCA3\n for cAx in [\"PCA1\", \"PCA2\", \"PCA3\"]:\n cDr = numpy.sqrt(\n (ptList[cAx + \"_X\"] * dx) ** 2\n + (ptList[cAx + \"_Y\"] * dy) ** 2\n + (ptList[cAx + \"_Z\"] * dz) ** 2\n )\n rcVar = \"DENSITY_PROJ_\" + cAx\n if ptList.has_key(\"DENSITY_VOLUME_PROJ_\" + cAx):\n lacTemp[rcVar] = tuple(ptList[rcVar] * cDr)\n else:\n lacTemp[rcVar] = (-1,) * dbLen\n if ptList.has_key(\"Canal_NUMBER\"):\n lacTemp[\"Canal_NUMBER\"] = tuple(ptList[\"Canal_NUMBER\"])\n # lacTemp['Canal_NAME']=tuple([projectTitle+'_'+filename+'_CAN_'+str(int(curCan)) for curCan in ptList['Canal_NUMBER']])\n if ptList.has_key(\"Canal_NUMBER_STD\"):\n lacTemp[\"Canal_NUMBER_STD\"] = tuple(ptList[\"Canal_NUMBER_STD\"])\n else:\n lacTemp[\"Canal_NUMBER_STD\"] = (-1,) * dbLen\n # Nearest Neighbors\n lacTemp[\"NEAREST_NEIGHBOR_DISTANCE\"] = (-1,) * dbLen\n lacTemp[\"NEAREST_NEIGHBOR_ANGLE\"] = (-1,) * dbLen\n\n if ptList.has_key(\"NEIGHBORS\"):\n lacTemp[\"NEAREST_NEIGHBOR_NEIGHBORS\"] = tuple(ptList[\"NEIGHBORS\"])\n else:\n lacTemp[\"NEAREST_NEIGHBOR_NEIGHBORS\"] = (-1,) * dbLen\n # Mask Params\n lacTemp[\"POS_RADIUS\"] = (-1,) * dbLen\n lacTemp[\"MASK_RADIUS\"] = (-1,) * dbLen\n lacTemp[\"MASK_RADIUS_MIN\"] = (-1,) * dbLen\n lacTemp[\"MASK_RADIUS_MAX\"] = (-1,) * dbLen\n lacTemp[\"MASK_RADIUS_MEAN\"] = (-1,) * dbLen\n lacTemp[\"MASK_THETA\"] = (-1,) * dbLen\n if ptList.has_key(\"THICKNESS\"):\n lacTemp[\"THICKNESS\"] = tuple(ptList[\"THICKNESS\"])\n else:\n lacTemp[\"THICKNESS\"] = (-1,) * dbLen\n if ptList.has_key(\"THICKNESS_STD\"):\n lacTemp[\"THICKNESS_STD\"] = tuple(ptList[\"THICKNESS_STD\"])\n else:\n lacTemp[\"THICKNESS_STD\"] = (-1,) * dbLen\n # Lacuna Density / Volume\n if ptList.has_key(\"DENSITY_VOLUME\"):\n lacTemp[\"DENSITY_VOLUME\"] = tuple(\n numpy.abs(ptList[\"DENSITY_VOLUME\"] * dx * dy * dz)\n )\n lacTemp[\"DENSITY\"] = tuple(\n numpy.abs(1 / (ptList[\"DENSITY_VOLUME\"] * dx * dy * dz))\n )\n elif ptList.has_key(\"DENSITY_VOLUME_CNT\"):\n lacTemp[\"DENSITY_VOLUME\"] = tuple(\n numpy.abs(ptList[\"DENSITY_VOLUME_CNT\"] * dx * dy * dz)\n )\n lacTemp[\"DENSITY\"] = tuple(\n numpy.abs(1 / (ptList[\"DENSITY_VOLUME_CNT\"] * dx * dy * dz))\n )\n else:\n lacTemp[\"DENSITY_VOLUME\"] = (-1,) * dbLen\n lacTemp[\"DENSITY\"] = (-1,) * dbLen\n if CanalMode == 0:\n # Lacuna Territory Shape\n lacTemp[\"DISPLACEMENT_MEAN\"] = (-1,) * dbLen\n if ptList.has_key(\"NEIGHBOR_AREA\"):\n lacTemp[\"DENSITY_VOLUME_SHELL\"] = tuple(\n numpy.abs(ptList[\"NEIGHBOR_AREA\"] * dx * dy)\n )\n elif ptList.has_key(\"MASK_VOLUME_SHELL_CNT\"):\n ## Old Definition of Shell\n lacTemp[\"DENSITY_VOLUME_SHELL\"] = tuple(\n numpy.abs(ptList[\"MASK_VOLUME_SHELL_CNT\"] * dx * dy * dz)\n )\n else:\n lacTemp[\"DENSITY_VOLUME_SHELL\"] = (-1,) * dbLen\n # Lacuna Territory that is mineralized\n if ptList.has_key(\"BONE_VOLUME_CNT\"):\n lacTemp[\"DENSITY_VOLUME_BONE\"] = tuple(\n numpy.abs(ptList[\"BONE_VOLUME_CNT\"] * dx * dy * dz)\n )\n else:\n lacTemp[\"DENSITY_VOLUME_BONE\"] = (-1,) * dbLen\n # Lacuna Territory that is part of the mask (for porosity calculations)\n if ptList.has_key(\"MASK_VOLUME_CNT\"):\n lacTemp[\"DENSITY_VOLUME_MASK\"] = tuple(\n numpy.abs(ptList[\"MASK_VOLUME_CNT\"] * dx * dy * dz)\n )\n else:\n lacTemp[\"DENSITY_VOLUME_MASK\"] = (-1,) * dbLen\n # PCA1 is a makeshift holding place for STD until the table is once again updated\n terrShapeMap = {\n \"DENSITY_VOLUME_C\": \"DENSITY_\",\n \"DENSITY_VOLUME_S\": \"DENSITY_STD_\",\n }\n for cKey in terrShapeMap.keys():\n missingKeys = False\n for cAx in [\"X\", \"Y\", \"Z\"]:\n # print cKey+cAx\n if ptList.has_key(cKey + cAx):\n # print 'isch da'\n lacTemp[terrShapeMap[cKey] + cAx] = tuple(\n ptList[cKey + cAx] * ptList[\"SCALE_\" + cAx]\n )\n else:\n if cKey == \"DENSITY_VOLUME_C\":\n missingKeys = True\n else:\n lacTemp[terrShapeMap[cKey] + cAx] = (-1,) * dbLen\n if not missingKeys:\n if cKey == \"DENSITY_VOLUME_C\":\n dispMean = numpy.sqrt(\n ((ptList[cKey + \"X\"] - ptList[\"POS_X\"]) * dx) ** 2\n + ((ptList[cKey + \"Y\"] - ptList[\"POS_Y\"]) * dy) ** 2\n + ((ptList[cKey + \"Z\"] - ptList[\"POS_Z\"]) * dz) ** 2\n )\n lacTemp[\"DISPLACEMENT_MEAN\"] = tuple(dispMean)\n lacTemp[\"DISPLACEMENT_X\"] = tuple(\n (ptList[cKey + \"X\"] - ptList[\"POS_X\"]) * dx\n )\n lacTemp[\"DISPLACEMENT_Y\"] = tuple(\n (ptList[cKey + \"Y\"] - ptList[\"POS_Y\"]) * dy\n )\n lacTemp[\"DISPLACEMENT_Z\"] = tuple(\n (ptList[cKey + \"Z\"] - ptList[\"POS_Z\"]) * dz\n )\n # Polar Coordinates Hints\n # Only really valid for Full Femur, but Lacuna angle can be useful\n mR = numpy.sqrt(\n ((ptList[\"POS_X\"] - numpy.mean(ptList[\"POS_X\"])) * dx) ** 2\n + ((ptList[\"POS_Y\"] - numpy.mean(ptList[\"POS_Y\"])) * dy) ** 2\n )\n for cPCA in [1, 2]:\n pR = numpy.sqrt(\n ptList[\"PCA\" + str(cPCA) + \"_X\"] ** 2\n + ptList[\"PCA\" + str(cPCA) + \"_Y\"] ** 2\n )\n pPhi = 180 / numpy.pi * numpy.arctan2(ptList[\"PCA\" + str(cPCA) + \"_Z\"], pR)\n lacTemp[\"PCA\" + str(cPCA) + \"_Phi\"] = tuple(pPhi)\n lacTemp[\"PCA\" + str(cPCA) + \"_Theta\"] = tuple(\n 180 / numpy.pi * numpy.arccos(ptList[\"PCA\" + str(cPCA) + \"_X\"] / pR)\n ) # update\n # Junk Angles\n lacTemp[\"POS_THETA\"] = (-1,) * dbLen\n lacTemp[\"MASK_THETA\"] = (-1,) * dbLen\n lacTemp[\"POS_DISTANCE\"] = (-1,) * dbLen\n lacTemp[\"NEAREST_NEIGHBOR_AVG\"] = (-1,) * dbLen\n lacTemp[\"NEAREST_NEIGHBOR_DISTANCE\"] = (-1,) * dbLen\n lacTemp[\"NEAREST_NEIGHBOR_DISTANCE\"] = (-1,) * dbLen\n # Normalize PCA\n pcastot = dr * numpy.sqrt(\n ptList[\"PCA1_S\"] ** 2 + ptList[\"PCA2_S\"] ** 2 + ptList[\"PCA3_S\"] ** 2\n )\n # lacTemp['PCAS_TOTAL']=tuple(pcastot)\n # for tz in lacTemp.keys(): print tz+' '+str(len(lacTemp[tz]))\n outKeys = lacTemp.keys()\n outArr = [lacTemp[cKey] for cKey in outKeys]\n # for cKey in outKeys: print (cKey,len(lacTemp[cKey]))\n outMat = numpy.array(outArr).swapaxes(1, 0)\n invalidRows = numpy.sum(numpy.isnan(outMat), 1)\n outMat = outMat[numpy.nonzero(invalidRows == 0)[0], :]\n globals()[\"Om\"] = outMat\n outMat = [tuple(obj) for obj in outMat]\n return None\n return addRowsToTable(cur, tableName, outMat, entry_order=outKeys)\n print filename + \" was successfully entered %05d, invalid %03d\" % (\n lacNumOffset,\n sum(invalidRows),\n )\n\n\nclass CaseFreeDict:\n \"\"\"Dictionary, that has case-insensitive keys.\n \n Keys are retained in their original form\n when queried with .keys() or .items().\n\n Implementation: An internal dictionary maps lowercase\n keys to (key,value) pairs. All key lookups are done\n against the lowercase keys, but all methods that expose\n keys to the user retrieve the original keys.\"\"\"\n\n def __init__(self, dict=None):\n \"\"\"Create an empty dictionary, or update from 'dict'.\"\"\"\n self._dict = {}\n if dict:\n self.update(dict)\n\n def __getitem__(self, key):\n \"\"\"Retrieve the value associated with 'key' (in any case).\"\"\"\n k = key.lower()\n return self._dict[k][1]\n\n def __setitem__(self, key, value):\n \"\"\"Associate 'value' with 'key'. If 'key' already exists, but\n in different case, it will be replaced.\"\"\"\n k = key.lower()\n self._dict[k] = (key, value)\n\n def has_key(self, key):\n \"\"\"Case insensitive test wether 'key' exists.\"\"\"\n k = key.lower()\n return self._dict.has_key(k)\n\n def keys(self):\n \"\"\"List of keys in their original case.\"\"\"\n return [v[0] for v in self._dict.values()]\n\n def values(self):\n \"\"\"List of values.\"\"\"\n return [v[1] for v in self._dict.values()]\n\n def items(self):\n \"\"\"List of (key,value) pairs.\"\"\"\n return self._dict.values()\n\n def get(self, key, default=None):\n \"\"\"Retrieve value associated with 'key' or return default value\n if 'key' doesn't exist.\"\"\"\n try:\n return self[key]\n except KeyError:\n return default\n\n def setdefault(self, key, default):\n \"\"\"If 'key' doesn't exists, associate it with the 'default' value.\n Return value associated with 'key'.\"\"\"\n if not self.has_key(key):\n self[key] = default\n return self[key]\n\n def update(self, dict):\n \"\"\"Copy (key,value) pairs from 'dict'.\"\"\"\n for k, v in dict.items():\n self[k] = v\n\n def __repr__(self):\n \"\"\"String representation of the dictionary.\"\"\"\n items = \", \".join([(\"%r: %r\" % (k, v)) for k, v in self.items()])\n return \"{%s}\" % items\n\n def __str__(self):\n \"\"\"String representation of the dictionary.\"\"\"\n return repr(self)\n", "meta": {"hexsha": "ee5ddfdaf69e1446e2b6818e102bbae02a1fe166", "size": 30985, "ext": "py", "lang": "Python", "max_stars_repo_path": "snippets/Python/pvtools.py", "max_stars_repo_name": "JLLeitschuh/TIPL", "max_stars_repo_head_hexsha": "89c5d82932f89a2b4064d5d86ac83045ce9bc7d5", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-11-22T11:02:52.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-22T11:02:52.000Z", "max_issues_repo_path": "snippets/Python/pvtools.py", "max_issues_repo_name": "JLLeitschuh/TIPL", "max_issues_repo_head_hexsha": "89c5d82932f89a2b4064d5d86ac83045ce9bc7d5", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2019-11-21T14:13:32.000Z", "max_issues_repo_issues_event_max_datetime": "2020-02-11T15:15:23.000Z", "max_forks_repo_path": "snippets/Python/pvtools.py", "max_forks_repo_name": "JLLeitschuh/TIPL", "max_forks_repo_head_hexsha": "89c5d82932f89a2b4064d5d86ac83045ce9bc7d5", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-02-11T06:19:45.000Z", "max_forks_repo_forks_event_max_datetime": "2020-02-11T06:19:45.000Z", "avg_line_length": 34.932356257, "max_line_length": 132, "alphanum_fraction": 0.5526222366, "include": true, "reason": "import numpy,from numpy", "num_tokens": 9013, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5039061705290806, "lm_q2_score": 0.38861802670584894, "lm_q1q2_score": 0.1958270216359123}} {"text": "\"\"\"\nThe ``bifacial`` module contains functions for modeling back surface\nplane-of-array irradiance under various conditions.\n\"\"\"\n\nimport pandas as pd\nimport numpy as np\n\n\ndef pvfactors_timeseries(\n solar_azimuth, solar_zenith, surface_azimuth, surface_tilt,\n axis_azimuth,\n timestamps, dni, dhi, gcr, pvrow_height, pvrow_width, albedo,\n n_pvrows=3, index_observed_pvrow=1,\n rho_front_pvrow=0.03, rho_back_pvrow=0.05,\n horizon_band_angle=15.,\n run_parallel_calculations=True, n_workers_for_parallel_calcs=2):\n \"\"\"\n Calculate front and back surface plane-of-array irradiance on\n a fixed tilt or single-axis tracker PV array configuration, and using\n the open-source \"pvfactors\" package. pvfactors implements the model\n described in [1]_.\n Please refer to pvfactors online documentation for more details:\n https://sunpower.github.io/pvfactors/\n\n Parameters\n ----------\n solar_azimuth: numeric\n Sun's azimuth angles using pvlib's azimuth convention (deg)\n solar_zenith: numeric\n Sun's zenith angles (deg)\n surface_azimuth: numeric\n Azimuth angle of the front surface of the PV modules, using pvlib's\n convention (deg)\n surface_tilt: numeric\n Tilt angle of the PV modules, going from 0 to 180 (deg)\n axis_azimuth: float\n Azimuth angle of the rotation axis of the PV modules, using pvlib's\n convention (deg). This is supposed to be fixed for all timestamps.\n timestamps: datetime or DatetimeIndex\n List of simulation timestamps\n dni: numeric\n Direct normal irradiance (W/m2)\n dhi: numeric\n Diffuse horizontal irradiance (W/m2)\n gcr: float\n Ground coverage ratio of the pv array\n pvrow_height: float\n Height of the pv rows, measured at their center (m)\n pvrow_width: float\n Width of the pv rows in the considered 2D plane (m)\n albedo: float\n Ground albedo\n n_pvrows: int, default 3\n Number of PV rows to consider in the PV array\n index_observed_pvrow: int, default 1\n Index of the PV row whose incident irradiance will be returned. Indices\n of PV rows go from 0 to n_pvrows-1.\n rho_front_pvrow: float, default 0.03\n Front surface reflectivity of PV rows\n rho_back_pvrow: float, default 0.05\n Back surface reflectivity of PV rows\n horizon_band_angle: float, default 15\n Elevation angle of the sky dome's diffuse horizon band (deg)\n run_parallel_calculations: bool, default True\n pvfactors is capable of using multiprocessing. Use this flag to decide\n to run calculations in parallel (recommended) or not.\n n_workers_for_parallel_calcs: int, default 2\n Number of workers to use in the case of parallel calculations. The\n '-1' value will lead to using a value equal to the number\n of CPU's on the machine running the model.\n\n Returns\n -------\n front_poa_irradiance: numeric\n Calculated incident irradiance on the front surface of the PV modules\n (W/m2)\n back_poa_irradiance: numeric\n Calculated incident irradiance on the back surface of the PV modules\n (W/m2)\n df_registries: pandas DataFrame\n DataFrame containing detailed outputs of the simulation; for\n instance the shapely geometries, the irradiance components incident on\n all surfaces of the PV array (for all timestamps), etc.\n In the pvfactors documentation, this is refered to as the \"surface\n registry\".\n\n References\n ----------\n .. [1] Anoma, Marc Abou, et al. \"View Factor Model and Validation for\n Bifacial PV and Diffuse Shade on Single-Axis Trackers.\" 44th IEEE\n Photovoltaic Specialist Conference. 2017.\n \"\"\"\n\n # Convert pandas Series inputs (and some lists) to numpy arrays\n if isinstance(solar_azimuth, pd.Series):\n solar_azimuth = solar_azimuth.values\n elif isinstance(solar_azimuth, list):\n solar_azimuth = np.array(solar_azimuth)\n if isinstance(solar_zenith, pd.Series):\n solar_zenith = solar_zenith.values\n if isinstance(surface_azimuth, pd.Series):\n surface_azimuth = surface_azimuth.values\n elif isinstance(surface_azimuth, list):\n surface_azimuth = np.array(surface_azimuth)\n if isinstance(surface_tilt, pd.Series):\n surface_tilt = surface_tilt.values\n if isinstance(dni, pd.Series):\n dni = dni.values\n if isinstance(dhi, pd.Series):\n dhi = dhi.values\n if isinstance(solar_azimuth, list):\n solar_azimuth = np.array(solar_azimuth)\n\n # Import pvfactors functions for timeseries calculations.\n from pvfactors.run import (run_timeseries_engine,\n run_parallel_engine)\n\n # Build up pv array configuration parameters\n pvarray_parameters = {\n 'n_pvrows': n_pvrows,\n 'axis_azimuth': axis_azimuth,\n 'pvrow_height': pvrow_height,\n 'pvrow_width': pvrow_width,\n 'gcr': gcr,\n 'rho_front_pvrow': rho_front_pvrow,\n 'rho_back_pvrow': rho_back_pvrow,\n 'horizon_band_angle': horizon_band_angle\n }\n\n # Run pvfactors calculations: either in parallel or serially\n if run_parallel_calculations:\n report = run_parallel_engine(\n PVFactorsReportBuilder, pvarray_parameters,\n timestamps, dni, dhi,\n solar_zenith, solar_azimuth,\n surface_tilt, surface_azimuth,\n albedo, n_processes=n_workers_for_parallel_calcs)\n else:\n report = run_timeseries_engine(\n PVFactorsReportBuilder.build, pvarray_parameters,\n timestamps, dni, dhi,\n solar_zenith, solar_azimuth,\n surface_tilt, surface_azimuth,\n albedo)\n\n # Turn report into dataframe\n df_report = pd.DataFrame(report, index=timestamps)\n\n return df_report.total_inc_front, df_report.total_inc_back\n\n\nclass PVFactorsReportBuilder(object):\n \"\"\"In pvfactors, a class is required to build reports when running\n calculations with multiprocessing because of python constraints\"\"\"\n\n @staticmethod\n def build(report, pvarray):\n \"\"\"Reports will have total incident irradiance on front and\n back surface of center pvrow (index=1)\"\"\"\n # Initialize the report as a dictionary\n if report is None:\n report = {'total_inc_back': [], 'total_inc_front': []}\n # Add elements to the report\n if pvarray is not None:\n pvrow = pvarray.pvrows[1] # use center pvrow\n report['total_inc_back'].append(\n pvrow.back.get_param_weighted('qinc'))\n report['total_inc_front'].append(\n pvrow.front.get_param_weighted('qinc'))\n else:\n # No calculation is performed when the sun is down\n report['total_inc_back'].append(np.nan)\n report['total_inc_front'].append(np.nan)\n\n return report\n\n @staticmethod\n def merge(reports):\n \"\"\"Works for dictionary reports. Merges the reports list of\n dictionaries in a single dictionary. The list of the first\n dictionary are extended by those of all subsequent lists.\"\"\"\n report = reports[0]\n keys_report = list(report.keys())\n for other_report in reports[1:]: # loop won't run if len(reports) < 2\n for key in keys_report:\n report[key] += other_report[key]\n return report\n", "meta": {"hexsha": "bc59e9ef111388a9092ba8540b76e48628ae9dc2", "size": 7458, "ext": "py", "lang": "Python", "max_stars_repo_path": "pvlib/bifacial.py", "max_stars_repo_name": "Ahanmr/pvlib-python", "max_stars_repo_head_hexsha": "fea9ff81a114506a95e21dbbebf79d79787d54c7", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-08-17T14:28:35.000Z", "max_stars_repo_stars_event_max_datetime": "2020-08-17T14:28:35.000Z", "max_issues_repo_path": "pvlib/bifacial.py", "max_issues_repo_name": "Ahanmr/pvlib-python", "max_issues_repo_head_hexsha": "fea9ff81a114506a95e21dbbebf79d79787d54c7", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2019-01-10T17:43:04.000Z", "max_issues_repo_issues_event_max_datetime": "2020-04-12T03:52:45.000Z", "max_forks_repo_path": "pvlib/bifacial.py", "max_forks_repo_name": "Ahanmr/pvlib-python", "max_forks_repo_head_hexsha": "fea9ff81a114506a95e21dbbebf79d79787d54c7", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-08-17T15:47:03.000Z", "max_forks_repo_forks_event_max_datetime": "2020-08-17T15:47:03.000Z", "avg_line_length": 39.4603174603, "max_line_length": 79, "alphanum_fraction": 0.674711719, "include": true, "reason": "import numpy", "num_tokens": 1743, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5039061705290805, "lm_q2_score": 0.38861802670584894, "lm_q1q2_score": 0.19582702163591229}} {"text": "\"\"\"\r\n Code for collecting failure trajectories using Bayesian Optimization\r\n Project : Policy correction using Bayesian Optimization\r\n Description : The file contains functions for computing failure trajectories given RL policy and\r\n safety specifications\r\n\"\"\"\r\n\r\nimport numpy as np\r\nimport gym\r\nimport GPyOpt\r\nfrom numpy.random import seed\r\nfrom eval_policy import choose_best_action\r\nimport gym\r\nfrom network import FeedForwardActorNN\r\nimport torch\r\nimport pickle\r\nfrom numpy import arange\r\nfrom numpy.random import rand\r\n\r\n'''\r\n Bayesian Optimization module for uncovering failure trajectories\r\n\r\n Safety Requirement\r\n # Requirement 1: We would like the cartpole to not travel more than a certain\r\n # distance from its original location(2.4) \r\n # Always stay within the region (-2.4, 2.4)\r\n'''\r\n\r\n#=============================================Global Variables =================================#\r\npolicy = None\r\nenv = None\r\ntraj_spec_dic = {}\r\ntraj_count = 0\r\n\r\n\r\n'''\r\n The function called from within the bayesian optimization module\r\n parameters : bounds containing the sampled variables of the state vector\r\n return : calls specification function and computes and returns the minimum value\r\n'''\r\ndef sample_trajectory(sample_1,sample_2,sample_3,sample_4):\r\n global policy, env, traj_spec_dic,traj_count\r\n x1 = sample_1\r\n x2 = sample_2\r\n x3 = sample_3\r\n x4 = sample_4\r\n obs = np.array([x1,x2,x3,x4])\r\n #print(f'obs =========== {obs}')\r\n max_steps = 400\r\n env.reset()\r\n env.env.state = obs\r\n traj = [obs]\r\n actions = []\r\n reward = 0\r\n iters= 0\r\n ep_ret = 0\r\n done = False\r\n for _ in range(max_steps):\r\n iters+=1\r\n action = choose_best_action(obs,policy)\r\n actions.append(action)\r\n obs, rew, done, _ = env.step(action)\r\n #add the observation state to the current trajectory\r\n traj.append(obs)\r\n ep_ret += rew\r\n if done:\r\n break\r\n additional_data = {'reward':ep_ret, 'mass':env.env.total_mass}\r\n #Create trajectory to be sent to safety specification\r\n traj = (traj, additional_data)\r\n #print(f'trajectory ========== {traj}')\r\n specification_evaluation = safety_spec(traj)\r\n #Store the set of trajectories with negative evaluation\r\n if specification_evaluation<0:\r\n traj_spec_dic[traj_count] = (traj[0],specification_evaluation)\r\n traj_count = traj_count + 1\r\n print(f'specification_evaluation ========== {specification_evaluation}')\r\n return specification_evaluation\r\n\r\n\r\ndef run_Random():\r\n x1_max = 0.05\r\n x1_min = -0.05\r\n x2_max = 0.05\r\n x2_min = -0.05\r\n x3_max = 0.05\r\n x3_min = -0.05\r\n x4_max = 0.05\r\n x4_min = -0.05\r\n # generate a random sample from the domain\r\n sample_1 = x1_min + rand(1000) * (x1_max - x1_min)\r\n sample_2 = x2_min + rand(1000) * (x2_max - x2_min)\r\n sample_3 = x3_min + rand(1000) * (x3_max - x3_min)\r\n sample_4 = x4_min + rand(1000) * (x4_max - x4_min)\r\n sample = list()\r\n step = 0.1\r\n print(f'sample length ========== {len(sample_1)}')\r\n for i in range(len(sample_1)):\r\n val = sample_trajectory(sample_1[i],sample_2[i],sample_3[i],sample_4[i])\r\n print(f'sample1 =========== {sample_1[i]} ======== sample2 ==== {sample_2[i]} ==== sample3 ===== {sample_3[i]}')\r\n '''sample = list()\r\n step = 0.04\r\n for sample_1 in arange(x1_min, x1_max+step, step):\r\n for sample_2 in arange(x2_min, x2_max+step, step):\r\n for sample_3 in arange(x3_min, x3_max+step, step):\r\n for sample_4 in arange(x4_min, x4_max+step, step):\r\n sample.append([sample_1,sample_2,sample_3,sample_4])\r\n print(f'sample length ========== {len(sample)}')\r\n for i in range(len(sample)):\r\n val = sample_trajectory(sample[i][0],sample[i][1],sample[i][2],sample[i][3])\r\n print(f'sample1 =========== {sample[i][0]} ======== sample2 ==== {sample[i][1]} ==== sample3 ===== {sample[i][2]}')'''\r\n\r\n\r\n# 1. Always stay within the region (-2.4, 2.4)\r\ndef safety_spec(traj):\r\n traj = traj[0]\r\n #print(f'traj ========== {traj}')\r\n x_s = np.array(traj).T[0]\r\n #print(f'min value ========== {x_s}')\r\n return min(2.4 - np.abs(x_s))\r\n\r\n# 2. Maintain a momentum >=-2.0 and <= 2.0\r\ndef safet_spec_2(traj):\r\n traj_ = traj[0]\r\n #print(f'traj ========== {traj}')\r\n mass = traj[1]['mass']\r\n v_s = np.array(traj_).T[1]\r\n return min(2. - np.abs(mass*v_s))\r\n\r\n\r\n# 3. The angle made by the cartpole should <=0.2 within the rest position\r\ndef safet_spec_3(traj):\r\n traj = traj[0]\r\n theta=np.array(traj).T[2]\r\n #print(f'theta ========== {theta}')\r\n return min(0.2 - np.abs(theta))\r\n\r\n\r\n\r\nif __name__ == '__main__':\r\n env = gym.make('CartPole-v0')\r\n seed = 0\r\n env.seed(seed)\r\n actor_model = 'Policies/ppo_actor_updatedCartPole-v0.pth'\r\n # Extract out dimensions of observation and action spaces\r\n obs_dim = env.observation_space.shape[0]\r\n act_dim = env.action_space.n #env.action_space.shape[0]\r\n\r\n # Build our policy the same way we build our actor model in PPO\r\n policy = FeedForwardActorNN(obs_dim, act_dim,True)\r\n\r\n # Load in the actor model saved by the PPO algorithm\r\n policy.load_state_dict(torch.load(actor_model))\r\n run_Random()\r\n print(f'Length trajectory ========== {len(traj_spec_dic)}')\r\n with open('failure_trajectory_cartpole.data', 'wb') as filehandle1:\r\n # store the observation data as binary data stream\r\n pickle.dump(traj_spec_dic, filehandle1)\r\n\r\n", "meta": {"hexsha": "7f94a0c6ad796e1cde11827ac79fd1870954cd45", "size": 5563, "ext": "py", "lang": "Python", "max_stars_repo_path": "Policy Refinement Using Bayesian Optimization/CartpoleRandom.py", "max_stars_repo_name": "britig/policy-refinement-bo", "max_stars_repo_head_hexsha": "c8a1e347d6e27c991e945afae9b5d9b482806f4b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-02-28T05:07:41.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-28T05:07:41.000Z", "max_issues_repo_path": "Policy Refinement Using Bayesian Optimization/CartpoleRandom.py", "max_issues_repo_name": "britig/policy-refinement-bo", "max_issues_repo_head_hexsha": "c8a1e347d6e27c991e945afae9b5d9b482806f4b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Policy Refinement Using Bayesian Optimization/CartpoleRandom.py", "max_forks_repo_name": "britig/policy-refinement-bo", "max_forks_repo_head_hexsha": "c8a1e347d6e27c991e945afae9b5d9b482806f4b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.76875, "max_line_length": 127, "alphanum_fraction": 0.6187309006, "include": true, "reason": "import numpy,from numpy", "num_tokens": 1508, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5039061705290805, "lm_q2_score": 0.38861802670584894, "lm_q1q2_score": 0.19582702163591229}} {"text": "# VIRANET TOOLS #\n###############################################################################\n# objSto\n# Strips stoichiometric coefficients from the objectives reactions\n# usage\n# Inputs:\n# HVM Integrated host-virus model\n# HostRxn Host objective reaction, either:\n# - Index value of reaction in Model.reactions [int]\n# - Reaction ID of the host-objective reaction [str]\n#\n# Outputs:\n# hostSto Stoichiometric coefficients with metabolites for host objective\n# virusSto Stoichiometric coefficients with metabolites for virus objective\n#\n\ndef objSto(HVM,HostRxn):\n \"Differential usage of amino acids and nucleotides\"\n # [1] Initial Setup\n # Function Dependencies\n import pandas as pd\n import numpy as np\n # Identify the host objective reaction\n try:\n intTest = int(HostRxn)\n hostIdx = HostRxn\n except:\n for ii in range(len(HVM.reactions)):\n if HostRxn in str(HVM.reactions[ii]):\n hostIdx = ii\n virusIdx = len(HVM.reactions) - 1 # ViraNet(c) appends virus reaction to end in genHVM.py\n objIdx = [hostIdx,virusIdx]\n hostID = HVM.reactions[hostIdx].id\n virusID = HVM.reactions[virusIdx].id\n # Condition: ensure virus reaction is virus objective\n if '_prodrxn_VN' not in virusID:\n raise ValueError('Unsupported objective, unable to analyse: refer to README')\n # Convert model into an array\n m = HVM.to_array_based_model()\n # Create data frame\n mFrame = pd.DataFrame(\n data = m.S.todense(),\n columns = m.reactions.list_attr(\"id\"),\n index = m.metabolites.list_attr(\"id\")\n )\n # [2] Stoichiometric Data\n # Strip the host and virus objective function stoichiometric coefficients\n hostS = mFrame[hostID]\n virusS = mFrame[virusID]\n # Record only non zero values\n hostSto = hostS.loc[~(hostS==0)]\n virusSto = virusS.loc[~(virusS==0)]\n # [3] Create output\n hostSto = pd.DataFrame(hostSto)\n virusSto = pd.DataFrame(virusSto)\n return (hostSto,virusSto)\n###############################################################################\n\n###############################################################################\n# boundCheck\n# Checks a model for any arbitrarily large bounds, removes these \n# and replaces with infinite bounds\n# Work based upon Kelk et al 2012\n# Kelk, S. M., Olivier, B. G., Stougie, L., & Bruggeman, F. J. (2012). Optimal flux spaces of genome-scale stoichiometric models are determined by a few subnetworks. Scientific Reports, 2, 580. http://doi.org/10.1038/srep00580\n# Inputs:\n# Model User-supplied model file [.mat,.xml]\n#\n# Outputs:\n# infModel Model with bound corrections applied\ndef boundCheck(Model):\n \"Reaction bound checker\"\n # [1] Initial Setup\n # Function Dependencies\n import numpy as np\n # Create pointer\n altModel = Model\n # [2] Identify and correct arbitrarily large reaction bounds\n for ii in range(len(altModel.reactions)):\n # Temporarily record the lower and upper bounds\n tmpLb = altModel.reactions[ii].lower_bound\n tmpUb = altModel.reactions[ii].upper_bound\n # Conditional statement\n if tmpLb <= -1000:\n altLb = -np.inf\n altModel.reactions[ii].lower_bound = altLb\n if tmpUb >= 1000:\n altUb = np.inf\n altModel.reactions[ii].upper_bound = altUb\n # [3] Output model\n return altModel\n###############################################################################\n# rangeCalculator\n# Calculates , using FVA results for host and virus, the flux range to use in the \n# host-derived enforcement analysis\n# Inputs:\n# hostIdx Index (model.reactions) for the host-objective reaction\n# virusIdx Index (model.reactions) for the virus-objective reaction\n# Optional Inputs\n# solver Declare solver to use for cobrapy: default is cglpk\n# Outputs\n# enfVirus Vector of virus optima values with additional host-constraint\n# maxEnfBound Maximum enf bound\n# minEnfBound Minimum enf bound\ndef rangeCalculator(HVM,hostIdx,virusIdx,solver):\n \"Enforcement bound creator\"\n # [1] Initial Setup\n # Function Dependencies\n import cobra\n import numpy as np\n import pandas as pd\n # Create the virus optima vector\n enfVirus = np.zeros((len(HVM.reactions),1))\n maxEnfBound = np.zeros((len(HVM.reactions),1))\n minEnfBound = np.zeros((len(HVM.reactions),1))\n # [2] Perform FVA for each objective\n # Objective reactions\n hostObj = HVM.reactions[hostIdx]\n virusObj = HVM.reactions[virusIdx]\n # Host Optimisation\n HVM.change_objective(hostObj)\n # Ensure no flux can go through the virus reaction\n # Store the bounds\n virusLb = HVM.reactions[virusIdx].lower_bound\n virusUb = HVM.reactions[virusIdx].upper_bound\n HVM.reactions[virusIdx].lower_bound = 0\n HVM.reactions[virusIdx].upper_bound = 0\n # FVA\n varHost = cobra.flux_analysis.flux_variability_analysis(HVM,solver=solver)\n # Return virus objective bounds\n HVM.reactions[virusIdx].lower_bound = virusLb\n HVM.reactions[virusIdx].upper_bound = virusUb\n # Virus Optimisation\n HVM.change_objective(virusObj)\n # Ensure no flux can go through the host reaction\n # Store the bounds\n hostLb = HVM.reactions[hostIdx].lower_bound\n hostUb = HVM.reactions[hostIdx].upper_bound\n HVM.reactions[hostIdx].lower_bound = 0\n HVM.reactions[hostIdx].upper_bound = 0\n # FVA\n varVirus = cobra.flux_analysis.flux_variability_analysis(HVM,solver=solver)\n # Return host objective bounds\n HVM.reactions[hostIdx].lower_bound = hostLb\n HVM.reactions[hostIdx].upper_bound = hostUb\n # Create data frames\n hostFVA = pd.DataFrame.from_dict(varHost)\n hostFVA = hostFVA.transpose()\n virusFVA = pd.DataFrame.from_dict(varVirus)\n virusFVA = virusFVA.transpose()\n # [3] Condition statements to determine the calculation and FVA steps \n # Initiate loop\n for ii in range(len(HVM.reactions)):\n # Create temporary host and virus max|min variables\n hostMax = varHost[HVM.reactions[ii].id]['maximum']\n hostMin = varHost[HVM.reactions[ii].id]['minimum']\n virusMax = varVirus[HVM.reactions[ii].id]['maximum']\n virusMin = varVirus[HVM.reactions[ii].id]['minimum']\n # Record the upper and lower bounds\n tmpLb = HVM.reactions[ii].lower_bound\n tmpUb = HVM.reactions[ii].upper_bound\n # Conditional: H+ > V+ && H- < V-\n if (hostMax > virusMax) and (hostMin < virusMin):\n #####################################################################\n # Calculation of bounds for condition [1]\n enfMax1 = hostMax\n enfMin1 = (hostMax - ((hostMax - virusMax) / 2))\n # Apply bounds to reaction\n HVM.reactions[ii].lower_bound = enfMin1\n HVM.reactions[ii].upper_bound = enfMax1\n # Zero-bound host\n HVM.reactions[hostIdx].lower_bound = 0\n HVM.reactions[hostIdx].upper_bound = 0\n # Optimize for virus\n HVM.change_objective(virusObj)\n sol = HVM.optimize(objective_sense='maximize',solver=solver)\n # Record the optima\n zMax = sol.f\n # Return host bounds to original\n HVM.reactions[hostIdx].lower_bound = hostLb\n HVM.reactions[hostIdx].upper_bound = hostUb\n # Return reaction bounds to original\n HVM.reactions[ii].lower_bound = tmpLb\n HVM.reactions[ii].upper_bound = tmpUb\n # Calculation of bounds for condition [2]\n enfMin2 = hostMin\n enfMax2 = (hostMin - ((hostMin - virusMin) / 2))\n # Apply bounds to reaction\n HVM.reactions[ii].lower_bound = enfMin2\n HVM.reactions[ii].upper_bound = enfMax2\n # Zero-bound host\n HVM.reactions[hostIdx].lower_bound = 0\n HVM.reactions[hostIdx].upper_bound = 0\n # Optimize for virus\n HVM.change_objective(virusObj)\n sol = HVM.optimize(objective_sense='maximize',solver=solver)\n # Record the optima\n zMin = sol.f\n # Return host bounds to original\n HVM.reactions[hostIdx].lower_bound = hostLb\n HVM.reactions[hostIdx].upper_bound = hostUb\n # Return reaction bounds to original\n HVM.reactions[ii].lower_bound = tmpLb\n HVM.reactions[ii].upper_bound = tmpUb\n # COMPARISON #\n # Compare zMax and zMin to find which is smallest\n if zMax < zMin:\n enfVirus[ii] = zMax\n # Record the bound\n maxEnfBound[ii] = enfMax1\n minEnfBound[ii] = enfMin1\n elif zMin < zMax:\n enfVirus[ii] = zMin\n # Record the bound\n maxEnfBound[ii] = enfMax2\n minEnfBound[ii] = enfMin2\n else:\n enfVirus[ii] = zMax\n # Record the bound\n maxEnfBound[ii] = enfMax1\n minEnfBound[ii] = enfMin1\n # Conditional: H+ > V+\n else:\n if hostMax > virusMax:\n #####################################################################\n # Calculation of bounds\n enfMax = hostMax\n enfMin = (hostMax - ((hostMax - virusMax) / 2))\n # Apply bounds to reaction\n HVM.reactions[ii].lower_bound = enfMin\n HVM.reactions[ii].upper_bound = enfMax\n # Zero-bound host\n HVM.reactions[hostIdx].lower_bound = 0\n HVM.reactions[hostIdx].upper_bound = 0\n # Optimize for virus\n HVM.change_objective(virusObj)\n sol = HVM.optimize(objective_sense='maximize',solver=solver)\n # Record the optima\n enfVirus[ii] = sol.f\n # Return host bounds to original\n HVM.reactions[hostIdx].lower_bound = hostLb\n HVM.reactions[hostIdx].upper_bound = hostUb\n # Return reaction bounds to original\n HVM.reactions[ii].lower_bound = tmpLb\n HVM.reactions[ii].upper_bound = tmpUb\n # Record the bound\n maxEnfBound[ii] = enfMax\n minEnfBound[ii] = enfMin\n #####################################################################\n else:\n # Conditional: H- < V-\n if hostMin < virusMin:\n #####################################################################\n enfMin = hostMin\n enfMax = (hostMin - ((hostMin - virusMin) / 2))\n # Apply bounds to reaction\n HVM.reactions[ii].lower_bound = enfMin\n HVM.reactions[ii].upper_bound = enfMax\n # Zero-bound host\n HVM.reactions[hostIdx].lower_bound = 0\n HVM.reactions[hostIdx].upper_bound = 0\n # Optimize for virus\n HVM.change_objective(virusObj)\n sol = HVM.optimize(objective_sense='maximize',solver=solver)\n # Record the optima\n enfVirus[ii] = sol.f\n # Return host bounds to original\n HVM.reactions[hostIdx].lower_bound = hostLb\n HVM.reactions[hostIdx].upper_bound = hostUb\n # Return reaction bounds to original\n HVM.reactions[ii].lower_bound = tmpLb\n HVM.reactions[ii].upper_bound = tmpUb\n # Record the bound\n maxEnfBound[ii] = enfMax\n minEnfBound[ii] = enfMin\n #####################################################################\n else:\n #####################################################################\n enfMax = hostMax\n enfMin = hostMin\n # Apply bounds to reaction\n HVM.reactions[ii].lower_bound = enfMin\n HVM.reactions[ii].upper_bound = enfMax\n # Zero-bound host\n HVM.reactions[hostIdx].lower_bound = 0\n HVM.reactions[hostIdx].upper_bound = 0\n # Optimize for virus\n HVM.change_objective(virusObj)\n sol = HVM.optimize(objective_sense='maximize',solver=solver)\n # Record the optima\n enfVirus[ii] = sol.f\n # Return host bounds to original\n HVM.reactions[hostIdx].lower_bound = hostLb\n HVM.reactions[hostIdx].upper_bound = hostUb\n # Return reaction bounds to original\n HVM.reactions[ii].lower_bound = tmpLb\n HVM.reactions[ii].upper_bound = tmpUb\n # Record the bound\n maxEnfBound[ii] = enfMax\n minEnfBound[ii] = enfMin\n #####################################################################\n # [4] Output\n return (enfVirus,maxEnfBound,minEnfBound)\n###############################################################################", "meta": {"hexsha": "7f17f4a7d5b33f2247fe854bbc97ebf2c68fb9a2", "size": 13680, "ext": "py", "lang": "Python", "max_stars_repo_path": "viranet/tools.py", "max_stars_repo_name": "seanaller/viranet", "max_stars_repo_head_hexsha": "8a8e3f7531110ce5f8dca9df6e9a0b9225ec5604", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "viranet/tools.py", "max_issues_repo_name": "seanaller/viranet", "max_issues_repo_head_hexsha": "8a8e3f7531110ce5f8dca9df6e9a0b9225ec5604", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "viranet/tools.py", "max_forks_repo_name": "seanaller/viranet", "max_forks_repo_head_hexsha": "8a8e3f7531110ce5f8dca9df6e9a0b9225ec5604", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 45.1485148515, "max_line_length": 226, "alphanum_fraction": 0.543494152, "include": true, "reason": "import numpy", "num_tokens": 3216, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5039061705290805, "lm_q2_score": 0.38861802670584894, "lm_q1q2_score": 0.19582702163591229}} {"text": "#!/usr/bin/env python3\n\"\"\"\nGenerate Doppler Centroid product from L0B data\n\"\"\"\nimport os\nimport time\nimport argparse as argp\nimport numpy as np\nfrom datetime import datetime\n\nfrom nisar.workflows import doppler_lut_from_raw\nfrom nisar.workflows.doppler_lut_from_raw import set_logger\nfrom nisar.products.readers.Raw import open_rrsd\nfrom isce3.core import TimeDelta, Linspace\nfrom nisar.products.readers.antenna import AntennaParser\n\n\ndef cmd_line_parser():\n \"\"\"Parse command line input arguments.\n\n Notes\n -----\n It also allows parsing arguments via an ASCII file\n by using prefix char \"@\".\n\n Returns\n -------\n argparse.Namespace\n\n \"\"\"\n prs = argp.ArgumentParser(\n description='Estimate Doppler centroid from L0B raw echo and creates '\n 'a 2-D Doppler LUT dumped into a CSV file',\n fromfile_prefix_chars=\"@\",\n formatter_class=argp.ArgumentDefaultsHelpFormatter\n )\n prs.add_argument('filename_l0b', type=str,\n help='Filename of HDF5 L0B product')\n prs.add_argument('-antenna_file', type=str, dest='antenna_file',\n help='Filename of HDF5 Antenna product used to extract '\n 'averaged azimuth angle for EL cuts of TX + RX pol of '\n 'first beam. If not provided, the azimuth angle is '\n 'assumed to be zero!')\n prs.add_argument('-f', '--freq', type=str, choices=['A', 'B'], default='A',\n dest='freq_band', help='Frequency band such as \"A\".')\n prs.add_argument('-p', '--pol', type=str, dest='txrx_pol',\n choices=[\"HH\", \"VV\", \"HV\", \"VH\"],\n help='TxRx Polarization such as \"HH\". Default is the '\n 'first pol in the specified frequency band')\n prs.add_argument('-r', '--rgb', type=int, dest='num_rgb_avg', default=16,\n help='Number of range bins to be averaged in Doppler '\n 'Estimator block. Shall be equal or larger than 1.')\n prs.add_argument('-a', '--az_block_dur', type=float, dest='az_block_dur',\n default=4.0,\n help='Azimuth block duration in seconds defining time-'\n 'domain correlator length used in Doppler estimator.')\n prs.add_argument('-t', '--time_interval', type=float, dest='time_interval',\n default=2.0,\n help='Time stamp interval between azimuth blocks in '\n 'seconds. Must not be larger than \"az_block_dur\".')\n prs.add_argument('-m', '--method', type=str, dest='dop_method',\n default='CDE', choices=['SDE', 'CDE'],\n help='Time-domain Doppler estimator methods \"CDE\"/\"SDE\"'\n ' which are Correlator/Sign Doppler Estimator.')\n prs.add_argument('--subband', action='store_true', dest='subband',\n help='Perform fast-time frequency subbanding on top of '\n 'time-domain correlator in Doppler estimator')\n prs.add_argument('-d', '--deg', type=int, dest='polyfit_deg',\n default=3, help='Degree of the polyfit.')\n prs.add_argument('--polyfit', action='store_true', dest='polyfit',\n help='If set, it will replace actual estimated doppler '\n 'by its polyfitted ones in slant range.')\n prs.add_argument('--plot', action='store_true', dest='plot',\n help='Plot Doppler centroids and save them in '\n '*.png files at the specified output path')\n prs.add_argument('-o', '--out', type=str, dest='out_path', default='.',\n help='Output directory to dump Doppler product as well as'\n 'PNG plots.')\n\n return prs.parse_args()\n\n\ndef gen_doppler_range_product(args):\n \"\"\"Generate Doppler-Range LUT Product.\n\n It generates Doppler centroid LUT as a function of slant range\n at various azimuth/pulse times and dump them into a CSV file.\n\n The format of the file and output filename convention is defined\n in reference [1]_.\n\n Parameters\n ----------\n args : argparse.Namespace\n All input arguments parsed from a command line or an ASCII file.\n\n References\n ----------\n .. [1] D. Kannapan, \"D&C Radar Data Product SIS,\" JPL D-104976,\n December 3, 2020.\n\n \"\"\"\n # Const\n PREFIX_NAME_CSV = 'NISAR_ANC'\n\n tic = time.time()\n # set logger\n logger = set_logger(\"DopplerRangeProduct\")\n\n # get keyword args for function \"doppler_lut_from_raw\"\n kwargs = {key: val for key, val in args.__dict__.items() if\n 'file' not in key}\n\n # get Raw object\n raw_obj = open_rrsd(args.filename_l0b)\n # get the SAR band char\n sar_band_char = raw_obj.sarBand\n logger.info(f'SAR band char -> {sar_band_char}')\n\n # operation mode, whether DBF (single or a composite channel) or\n # 'DM2' (multi-channel)\n # currently, the nunderlying module simply support DBF or single channel\n op_mode = 'DBF'\n\n # generate Doppler LUT2d from Raw L0B\n dop_lut, ref_utc, mask_rgb, corr_coef, txrx_pol, centerfreq, _ = \\\n doppler_lut_from_raw(raw_obj, logger=logger, **kwargs)\n\n # check out antenna file to extract azimuth angle for EL cuts used for\n # Doppler CSV product\n if args.antenna_file is None:\n az_ang_deg = 0.0\n logger.warning(\n 'No antenna file! Azimuth angle for Doppler product is '\n 'assumed to be zero!'\n )\n else:\n logger.info(\n 'Extracting the azimuth angle of EL cuts from antenna file.')\n ant_obj = AntennaParser(args.antenna_file)\n\n ant_tx = ant_obj.el_cut(pol=txrx_pol[0])\n az_ang = ant_tx.cut_angle\n # if RX pol is different from TX pol then take average of both\n if txrx_pol[0] != txrx_pol[1]:\n ant_rx = ant_obj.el_cut(pol=txrx_pol[1])\n az_ang += ant_rx.cut_angle\n az_ang *= 0.5\n az_ang_deg = np.rad2deg(az_ang)\n logger.info(\n 'Azimuth angle extracted from antenna file -> '\n f'{az_ang_deg:.3f} (deg)'\n )\n\n # form Linspace object for uniformly-spaced azimuth time and slant range\n azt_lsp = Linspace(dop_lut.y_start, dop_lut.y_spacing, dop_lut.length)\n sr_lsp = Linspace(dop_lut.x_start, dop_lut.x_spacing, dop_lut.width)\n\n # get the first and last utc azimuth time w/o fractional seconds\n # in \"%Y%m%dT%H%M%S\" format to be used as part of CSV product filename.\n dt_utc_start = sec2str(ref_utc, azt_lsp.first)\n dt_utc_stop = sec2str(ref_utc, azt_lsp.last)\n # get current time w/o fractional seconds in \"%Y%m%dT%H%M%S\" format\n # used as part of CSV product filename\n dt_utc_cur = datetime.now().strftime('%Y%m%dT%H%M%S')\n\n # naming convention of CSV file and product spec is defined in Doc:\n # See reference [1]\n name_csv = (f'{PREFIX_NAME_CSV}_{sar_band_char}_{op_mode}_DOPP_'\n f'{dt_utc_cur}_{dt_utc_start}_{dt_utc_stop}.csv')\n file_csv = os.path.join(args.out_path, name_csv)\n logger.info(f'Dump Doppler product in \"CSV\" format to file -> {file_csv}')\n\n with open(file_csv, 'wt') as fid_csv:\n fid_csv.write(\n 'UTC Time,Frequency (Hz),Doppler (Hz),Range (m),Azimuth (deg),'\n 'Correlation\\n'\n )\n # loop over azimuth time and slant ranges\n for i_row, azt in enumerate(azt_lsp):\n tm_utc_str = sec2isofmt(ref_utc, azt)\n\n for i_col, sr in enumerate(sr_lsp):\n fid_csv.write(\n '{:s},{:.1f},{:.3f},{:.3f},{:.3f},{:.3f}\\n'.format(\n tm_utc_str, centerfreq, dop_lut.data[i_row, i_col],\n sr, az_ang_deg,\n mask_rgb[i_row, i_col] * corr_coef[i_row, i_col])\n )\n\n # total elapsed time\n logger.info(f'Elapsed time -> {time.time() - tic:.1f} (sec)')\n\n\ndef sec2isofmt(ref_utc: 'isce3.core.DateTime', seconds: float) -> str:\n \"\"\"seconds to isoformat string\"\"\"\n return (ref_utc + TimeDelta(seconds)).isoformat()\n\n\ndef sec2str(ref_utc: 'isce3.core.DateTime', seconds: float) -> str:\n \"\"\"seconds to string format '%Y%m%dT%H%M%S'\"\"\"\n fmt = '%Y%m%dT%H%M%S'\n dt_iso = sec2isofmt(ref_utc, seconds)\n return datetime.fromisoformat(dt_iso.split('.')[0]).strftime(fmt)\n\n\nif __name__ == \"__main__\":\n \"\"\"Main driver\"\"\"\n gen_doppler_range_product(cmd_line_parser())\n", "meta": {"hexsha": "f50a217ff700dc3838e7718b04e135879f7e6d23", "size": 8467, "ext": "py", "lang": "Python", "max_stars_repo_path": "python/packages/nisar/workflows/gen_doppler_range_product.py", "max_stars_repo_name": "isce3-testing/isce3-circleci-poc", "max_stars_repo_head_hexsha": "ec1dfb6019bcdc7afb7beee7be0fa0ce3f3b87b3", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "python/packages/nisar/workflows/gen_doppler_range_product.py", "max_issues_repo_name": "isce3-testing/isce3-circleci-poc", "max_issues_repo_head_hexsha": "ec1dfb6019bcdc7afb7beee7be0fa0ce3f3b87b3", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-12-23T00:00:31.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-23T00:00:31.000Z", "max_forks_repo_path": "python/packages/nisar/workflows/gen_doppler_range_product.py", "max_forks_repo_name": "isce3-testing/isce3-circleci-poc", "max_forks_repo_head_hexsha": "ec1dfb6019bcdc7afb7beee7be0fa0ce3f3b87b3", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-12-02T21:10:11.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-02T21:10:11.000Z", "avg_line_length": 40.319047619, "max_line_length": 79, "alphanum_fraction": 0.6147395772, "include": true, "reason": "import numpy", "num_tokens": 2112, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6039318337259583, "lm_q2_score": 0.32423541204073586, "lm_q1q2_score": 0.19581608695265326}} {"text": "#! /usr/bin/env python\n\"\"\"\nMIMAS - The Multi-resolution Image Mask for Depexo Software\n\nTODO: Write an in/out reader for MOC formats described by\nhttp://arxiv.org/abs/1505.02937\n\"\"\"\n\nfrom __future__ import print_function\n\nimport logging\nimport numpy as np\n\nimport os\nimport re\nfrom astropy.coordinates import Angle, SkyCoord\nimport astropy.units as u\nfrom astropy.io import fits as pyfits\nfrom astropy.wcs import wcs as pywcs\nimport healpy as hp\nfrom .regions import Region\nfrom .catalogs import load_table, write_table\n\n__author__ = \"Paul Hancock\"\n__version__ = 'v1.3.1'\n__date__ = '2018-08-29'\n\n\n# globals\nfilewcs = None\n\n\nclass Dummy():\n \"\"\"\n A state storage class for MIMAS to work with.\n\n Attributes\n ----------\n add_region : list\n List of :class:`depexoTools.MIMAS.Region` to be added.\n\n rem_region : list\n List of :class:`depexoTools.MIMAS.Region` to be subtracted.\n\n include_circles : [[ra, dec, radius],...]\n List of circles to be added to the region, units are degrees.\n\n exclude_circles : [[ra, dec, radius], ...]\n List of circles to be subtracted from the region, units are degrees.\n\n include_polygons : [[ra,dec, ...], ...]\n List of polygons to be added to the region, units are degrees.\n\n exclude_polygons : [[ra,dec, ...], ...]\n List of polygons to be subtracted from the region, units are degrees.\n\n maxdepth : int\n Depth or resolution of the region for HEALPix.\n There are 4*2**maxdepth pixels at the deepest layer.\n Default = 8.\n\n galactic: bool\n If true then all ra/dec coordinates will be interpreted as if they were in galactic\n lat/lon (degrees)\n \"\"\"\n def __init__(self, maxdepth=8):\n self.add_region = []\n self.rem_region = []\n self.include_circles = []\n self.exclude_circles = []\n self.include_polygons = []\n self.exclude_polygons = []\n self.maxdepth = maxdepth\n self.galactic = False\n return\n\n\ndef galactic2fk5(l, b):\n \"\"\"\n Convert galactic l/b to fk5 ra/dec\n\n Parameters\n ----------\n l, b : float\n Galactic coordinates in radians.\n\n Returns\n -------\n ra, dec : float\n FK5 ecliptic coordinates in radians.\n \"\"\"\n a = SkyCoord(l, b, unit=(u.radian, u.radian), frame='galactic')\n return a.fk5.ra.radian, a.fk5.dec.radian\n\n\ndef mask_plane(data, wcs, region, negate=False):\n \"\"\"\n Mask a 2d image (data) such that pixels within 'region' are set to nan.\n\n Parameters\n ----------\n data : 2d-array\n Image array.\n\n wcs : astropy.wcs.WCS\n WCS for the image in question.\n\n region : :class:`depexoTools.regions.Region`\n A region within which the image pixels will be masked.\n\n negate : bool\n If True then pixels *outside* the region are masked.\n Default = False.\n\n Returns\n -------\n masked : 2d-array\n The original array, but masked as required.\n \"\"\"\n # create an array but don't set the values (they are random)\n indexes = np.empty((data.shape[0]*data.shape[1], 2), dtype=int)\n # since I know exactly what the index array needs to look like i can construct\n # it faster than list comprehension would allow\n # we do this only once and then recycle it\n idx = np.array([(j, 0) for j in range(data.shape[1])])\n j = data.shape[1]\n for i in range(data.shape[0]):\n idx[:, 1] = i\n indexes[i*j:(i+1)*j] = idx\n\n # put ALL the pixles into our vectorized functions and minimise our overheads\n ra, dec = wcs.wcs_pix2world(indexes, 1).transpose()\n bigmask = region.sky_within(ra, dec, degin=True)\n if not negate:\n bigmask = np.bitwise_not(bigmask)\n # rework our 1d list into a 2d array\n bigmask = bigmask.reshape(data.shape)\n # and apply the mask\n data[bigmask] = np.nan\n return data\n\n\ndef mask_file(regionfile, infile, outfile, negate=False):\n \"\"\"\n Created a masked version of file, using a region.\n\n\n Parameters\n ----------\n regionfile : str\n A file which can be loaded as a :class:`depexoTools.regions.Region`.\n The image will be masked according to this region.\n\n infile : str\n Input FITS image.\n\n outfile : str\n Output FITS image.\n\n negate : bool\n If True then pixels *outside* the region are masked.\n Default = False.\n\n See Also\n --------\n :func:`depexoTools.MIMAS.mask_plane`\n \"\"\"\n # Check that the input file is accessible and then open it\n if not os.path.exists(infile): raise AssertionError(\"Cannot locate fits file {0}\".format(infile))\n im = pyfits.open(infile)\n if not os.path.exists(regionfile): raise AssertionError(\"Cannot locate region file {0}\".format(regionfile))\n region = Region.load(regionfile)\n try:\n wcs = pywcs.WCS(im[0].header, naxis=2)\n except: # TODO: figure out what error is being thrown\n wcs = pywcs.WCS(str(im[0].header), naxis=2)\n\n if len(im[0].data.shape) > 2:\n data = np.squeeze(im[0].data)\n else:\n data = im[0].data\n\n print(data.shape)\n if len(data.shape) == 3:\n for plane in range(data.shape[0]):\n mask_plane(data[plane], wcs, region, negate)\n else:\n mask_plane(data, wcs, region, negate)\n im[0].data = data\n im.writeto(outfile, overwrite=True)\n logging.info(\"Wrote {0}\".format(outfile))\n return\n\n\ndef mask_table(region, table, negate=False, racol='ra', deccol='dec'):\n \"\"\"\n Apply a given mask (region) to the table, removing all the rows with ra/dec inside the region\n If negate=False then remove the rows with ra/dec outside the region.\n\n\n Parameters\n ----------\n region : :class:`depexoTools.regions.Region`\n Region to mask.\n\n table : Astropy.table.Table\n Table to be masked.\n\n negate : bool\n If True then pixels *outside* the region are masked.\n Default = False.\n\n racol, deccol : str\n The name of the columns in `table` that should be interpreted as ra and dec.\n Default = 'ra', 'dec'\n\n Returns\n -------\n masked : Astropy.table.Table\n A view of the given table which has been masked.\n \"\"\"\n inside = region.sky_within(table[racol], table[deccol], degin=True)\n if not negate:\n mask = np.bitwise_not(inside)\n else:\n mask = inside\n return table[mask]\n\n\ndef mask_catalog(regionfile, infile, outfile, negate=False, racol='ra', deccol='dec'):\n \"\"\"\n Apply a region file as a mask to a catalog, removing all the rows with ra/dec inside the region\n If negate=False then remove the rows with ra/dec outside the region.\n\n\n Parameters\n ----------\n regionfile : str\n A file which can be loaded as a :class:`depexoTools.regions.Region`.\n The catalogue will be masked according to this region.\n\n infile : str\n Input catalogue.\n\n outfile : str\n Output catalogue.\n\n negate : bool\n If True then pixels *outside* the region are masked.\n Default = False.\n\n racol, deccol : str\n The name of the columns in `table` that should be interpreted as ra and dec.\n Default = 'ra', 'dec'\n\n See Also\n --------\n :func:`depexoTools.MIMAS.mask_table`\n\n :func:`depexoTools.catalogs.load_table`\n \"\"\"\n logging.info(\"Loading region from {0}\".format(regionfile))\n region = Region.load(regionfile)\n logging.info(\"Loading catalog from {0}\".format(infile))\n table = load_table(infile)\n masked_table = mask_table(region, table, negate=negate, racol=racol, deccol=deccol)\n write_table(masked_table, outfile)\n return\n\n\ndef mim2reg(mimfile, regfile):\n \"\"\"\n Convert a MIMAS region (.mim) file into a DS9 region (.reg) file.\n\n Parameters\n ----------\n mimfile : str\n Input file in MIMAS format.\n\n regfile : str\n Output file.\n\n \"\"\"\n region = Region.load(mimfile)\n region.write_reg(regfile)\n logging.info(\"Converted {0} -> {1}\".format(mimfile, regfile))\n return\n\n\ndef mim2fits(mimfile, fitsfile):\n \"\"\"\n Convert a MIMAS region (.mim) file into a MOC region (.fits) file.\n\n Parameters\n ----------\n mimfile : str\n Input file in MIMAS format.\n\n fitsfile : str\n Output file.\n \"\"\"\n region = Region.load(mimfile)\n region.write_fits(fitsfile, moctool='MIMAS {0}-{1}'.format(__version__, __date__))\n logging.info(\"Converted {0} -> {1}\".format(mimfile, fitsfile))\n return\n\n\ndef mask2mim(maskfile, mimfile, threshold=1.0, maxdepth=8):\n \"\"\"\n Use a fits file as a mask to create a region file.\n\n Pixels in mask file that are equal or above the threshold will be included in the reigon,\n while those that are below the threshold will not.\n\n Parameters\n ----------\n maskfile : str\n Input file in fits format.\n\n mimfile : str\n Output filename\n\n threshold : float\n threshold value for separating include/exclude values\n\n maxdepth : int\n Maximum depth (resolution) of the healpix pixels\n\n \"\"\"\n hdu = pyfits.open(maskfile)\n wcs = pywcs.WCS(hdu[0].header)\n\n x, y = np.where(hdu[0].data >= threshold)\n ra, dec = wcs.all_pix2world(y, x, 0)\n sky = np.radians(Region.radec2sky(ra, dec))\n vec = Region.sky2vec(sky)\n x, y, z = np.transpose(vec)\n pix = hp.vec2pix(2**maxdepth, x, y, z, nest=True)\n\n region = Region(maxdepth=maxdepth)\n region.add_pixels(pix, depth=maxdepth)\n region._renorm()\n save_region(region, mimfile)\n logging.info(\"Converted {0} -> {1}\".format(maskfile, mimfile))\n return\n\n\ndef box2poly(line):\n \"\"\"\n Convert a string that describes a box in ds9 format, into a polygon that is given by the corners of the box\n\n Parameters\n ----------\n line : str\n A string containing a DS9 region command for a box.\n\n Returns\n -------\n poly : [ra, dec, ...]\n The corners of the box in clockwise order from top left.\n \"\"\"\n words = re.split('[(\\s,)]', line)\n ra = words[1]\n dec = words[2]\n width = words[3]\n height = words[4]\n if \":\" in ra:\n ra = Angle(ra, unit=u.hour)\n else:\n ra = Angle(ra, unit=u.degree)\n dec = Angle(dec, unit=u.degree)\n width = Angle(float(width[:-1])/2, unit=u.arcsecond) # strip the \"\n height = Angle(float(height[:-1])/2, unit=u.arcsecond) # strip the \"\n center = SkyCoord(ra, dec)\n tl = center.ra.degree+width.degree, center.dec.degree+height.degree\n tr = center.ra.degree-width.degree, center.dec.degree+height.degree\n bl = center.ra.degree+width.degree, center.dec.degree-height.degree\n br = center.ra.degree-width.degree, center.dec.degree-height.degree\n return np.ravel([tl, tr, br, bl]).tolist()\n\n\ndef circle2circle(line):\n \"\"\"\n Parse a string that describes a circle in ds9 format.\n\n Parameters\n ----------\n line : str\n A string containing a DS9 region command for a circle.\n\n Returns\n -------\n circle : [ra, dec, radius]\n The center and radius of the circle.\n \"\"\"\n words = re.split('[(,\\s)]', line)\n ra = words[1]\n dec = words[2]\n radius = words[3][:-1] # strip the \"\n if \":\" in ra:\n ra = Angle(ra, unit=u.hour)\n else:\n ra = Angle(ra, unit=u.degree)\n dec = Angle(dec, unit=u.degree)\n radius = Angle(radius, unit=u.arcsecond)\n return [ra.degree, dec.degree, radius.degree]\n\n\ndef poly2poly(line):\n \"\"\"\n Parse a string of text containing a DS9 description of a polygon.\n\n This function works but is not very robust due to the constraints of healpy.\n\n Parameters\n ----------\n line : str\n A string containing a DS9 region command for a polygon.\n\n Returns\n -------\n poly : [ra, dec, ...]\n The coordinates of the polygon.\n \"\"\"\n words = re.split('[(\\s,)]', line)\n ras = np.array(words[1::2])\n decs = np.array(words[2::2])\n coords = []\n for ra, dec in zip(ras, decs):\n if ra.strip() == '' or dec.strip() == '':\n continue\n if \":\" in ra:\n pos = SkyCoord(Angle(ra, unit=u.hour), Angle(dec, unit=u.degree))\n else:\n pos = SkyCoord(Angle(ra, unit=u.degree), Angle(dec, unit=u.degree))\n # only add this point if it is some distance from the previous one\n coords.extend([pos.ra.degree, pos.dec.degree])\n return coords\n\n\ndef reg2mim(regfile, mimfile, maxdepth):\n \"\"\"\n Parse a DS9 region file and write a MIMAS region (.mim) file.\n\n Parameters\n ----------\n regfile : str\n DS9 region (.reg) file.\n\n mimfile : str\n MIMAS region (.mim) file.\n\n maxdepth : str\n Depth/resolution of the region file.\n\n \"\"\"\n logging.info(\"Reading regions from {0}\".format(regfile))\n lines = (l for l in open(regfile, 'r') if not l.startswith('#'))\n poly = []\n circles = []\n for line in lines:\n if line.startswith('box'):\n poly.append(box2poly(line))\n elif line.startswith('circle'):\n circles.append(circle2circle(line))\n elif line.startswith('polygon'):\n logging.warning(\"Polygons break a lot, but I'll try this one anyway.\")\n poly.append(poly2poly(line))\n else:\n logging.warning(\"Not sure what to do with {0}\".format(line[:-1]))\n container = Dummy(maxdepth=maxdepth)\n container.include_circles = circles\n container.include_polygons = poly\n\n region = combine_regions(container)\n save_region(region, mimfile)\n return\n\n\ndef combine_regions(container):\n \"\"\"\n Return a region that is the combination of those specified in the container.\n The container is typically a results instance that comes from argparse.\n\n Order of construction is: add regions, subtract regions, add circles, subtract circles,\n add polygons, subtract polygons.\n\n Parameters\n ----------\n container : :class:`depexoTools.MIMAS.Dummy`\n The regions to be combined.\n\n Returns\n -------\n region : :class:`depexoTools.regions.Region`\n The constructed region.\n \"\"\"\n # create empty region\n region = Region(container.maxdepth)\n\n # add/rem all the regions from files\n for r in container.add_region:\n logging.info(\"adding region from {0}\".format(r))\n r2 = Region.load(r[0])\n region.union(r2)\n\n for r in container.rem_region:\n logging.info(\"removing region from {0}\".format(r))\n r2 = Region.load(r[0])\n region.without(r2)\n\n\n # add circles\n if len(container.include_circles) > 0:\n for c in container.include_circles:\n circles = np.radians(np.array(c))\n if container.galactic:\n l, b, radii = circles.reshape(3, circles.shape[0]//3)\n ras, decs = galactic2fk5(l, b)\n else:\n ras, decs, radii = circles.reshape(3, circles.shape[0]//3)\n region.add_circles(ras, decs, radii)\n\n # remove circles\n if len(container.exclude_circles) > 0:\n for c in container.exclude_circles:\n r2 = Region(container.maxdepth)\n circles = np.radians(np.array(c))\n if container.galactic:\n l, b, radii = circles.reshape(3, circles.shape[0]//3)\n ras, decs = galactic2fk5(l, b)\n else:\n ras, decs, radii = circles.reshape(3, circles.shape[0]//3)\n r2.add_circles(ras, decs, radii)\n region.without(r2)\n\n # add polygons\n if len(container.include_polygons) > 0:\n for p in container.include_polygons:\n poly = np.radians(np.array(p))\n poly = poly.reshape((poly.shape[0]//2, 2))\n region.add_poly(poly)\n\n # remove polygons\n if len(container.exclude_polygons) > 0:\n for p in container.include_polygons:\n poly = np.array(np.radians(p))\n r2 = Region(container.maxdepth)\n r2.add_poly(poly)\n region.without(r2)\n\n return region\n\n\ndef intersect_regions(flist):\n \"\"\"\n Construct a region which is the intersection of all regions described in the given\n list of file names.\n\n Parameters\n ----------\n flist : list\n A list of region filenames.\n\n Returns\n -------\n region : :class:`depexoTools.regions.Region`\n The intersection of all regions, possibly empty.\n \"\"\"\n if len(flist) < 2:\n raise Exception(\"Require at least two regions to perform intersection\")\n a = Region.load(flist[0])\n for b in [Region.load(f) for f in flist[1:]]:\n a.intersect(b)\n return a\n\n\ndef save_region(region, filename):\n \"\"\"\n Save the given region to a file\n\n Parameters\n ----------\n region : :class:`depexoTools.regions.Region`\n A region.\n\n filename : str\n Output file name.\n \"\"\"\n region.save(filename)\n logging.info(\"Wrote {0}\".format(filename))\n return\n\n\ndef save_as_image(region, filename):\n \"\"\"\n Convert a MIMAS region (.mim) file into a image (eg .png)\n\n Parameters\n ----------\n region : :class:`depexoTools.regions.Region`\n Region of interest.\n\n filename : str\n Output filename.\n \"\"\"\n import healpy as hp\n pixels = list(region.get_demoted())\n order = region.maxdepth\n m = np.arange(hp.nside2npix(2**order))\n m[:] = 0\n m[pixels] = 1\n hp.write_map(filename, m, nest=True, coord='C')\n return\n", "meta": {"hexsha": "5773e6b9aa5e7edc037779bd1bd8b56f0e8335ca", "size": 17307, "ext": "py", "lang": "Python", "max_stars_repo_path": "DepexoTools/MIMAS.py", "max_stars_repo_name": "erpmaroc/Depexo-Prestashop-Like", "max_stars_repo_head_hexsha": "53d01dea6fd56c8ef21394f301df51cf699cd4d7", "max_stars_repo_licenses": ["AFL-3.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "DepexoTools/MIMAS.py", "max_issues_repo_name": "erpmaroc/Depexo-Prestashop-Like", "max_issues_repo_head_hexsha": "53d01dea6fd56c8ef21394f301df51cf699cd4d7", "max_issues_repo_licenses": ["AFL-3.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "DepexoTools/MIMAS.py", "max_forks_repo_name": "erpmaroc/Depexo-Prestashop-Like", "max_forks_repo_head_hexsha": "53d01dea6fd56c8ef21394f301df51cf699cd4d7", "max_forks_repo_licenses": ["AFL-3.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.1414634146, "max_line_length": 111, "alphanum_fraction": 0.615589068, "include": true, "reason": "import numpy,import astropy,from astropy", "num_tokens": 4389, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.603931819468636, "lm_q2_score": 0.32423540551084407, "lm_q1q2_score": 0.1958160783863151}} {"text": "# Fit to multiple relative binding free energy edges\nimport sys\nfrom argparse import ArgumentParser\nimport jax\nfrom jax import numpy as jnp\nimport numpy as np\nimport datetime\nimport timemachine\n\n# forcefield handlers\nfrom ff import Forcefield\nfrom ff.handlers.serialize import serialize_handlers\nfrom ff.handlers.deserialize import deserialize_handlers\nfrom ff.handlers.nonbonded import AM1CCCHandler, LennardJonesHandler\n\n# free energy classes\nfrom fe.free_energy import RelativeFreeEnergy, construct_lambda_schedule\nfrom fe.estimator import SimulationResult\nfrom fe.model import RBFEModel\nfrom fe.loss import pseudo_huber_loss # , l1_loss, flat_bottom_loss\n\n# MD initialization\nfrom md import builders\n\n# parallelization across multiple GPUs\nfrom parallel.client import CUDAPoolClient, GRPCClient\nfrom parallel.utils import get_gpu_count\n\nfrom collections import namedtuple\n\nfrom pickle import load\n\nfrom optimize.step import truncated_step\n\nfrom typing import Tuple, Dict, List, Union\n\nfrom pathlib import Path\nfrom time import time\n\narray = Union[np.array, jnp.array]\n\nHandler = Union[AM1CCCHandler, LennardJonesHandler] # TODO: relax this assumption\n\nNUM_GPUS = get_gpu_count()\n\n# how much MD to run, on how many GPUs\nConfiguration = namedtuple(\n 'Configuration',\n ['num_complex_windows', 'num_solvent_windows', 'num_equil_steps', 'num_prod_steps'])\n\n# define a couple configurations: one for quick tests, and one for production\nproduction_configuration = Configuration(\n num_complex_windows=60,\n num_solvent_windows=60,\n num_equil_steps=10000,\n num_prod_steps=100000,\n)\n\nintermediate_configuration = Configuration(\n num_complex_windows=60,\n num_solvent_windows=60,\n num_equil_steps=10000,\n num_prod_steps=10000,\n)\n\ntesting_configuration = Configuration(\n num_complex_windows=10,\n num_solvent_windows=10,\n num_equil_steps=1000,\n num_prod_steps=1000,\n)\n\n# TODO: rename this to something more descriptive than \"Configuration\"...\n# want to distinguish later between an \"RBFE configuration\"\n# (which describes the computation of a single edge)\n# and a \"training configuration\"\n# (which describes the overall training loop)\n\n\n# locations relative to project root\nroot = Path(timemachine.__file__).parent\npath_to_protein = str(root.joinpath('tests/data/hif2a_nowater_min.pdb'))\n\n\nclass ParameterUpdate:\n def __init__(self, before, after, gradient, update):\n self.before = before\n self.after = after\n self.gradient = gradient\n self.update = update\n\n # TODO: def __str__\n\n def save(self, fname='parameter_update.npz'):\n \"\"\"save numpy arrays to fname\"\"\"\n print(f'saving parameter updates to {fname}')\n np.savez(\n file=fname,\n before=self.before,\n after=self.after,\n gradient=self.gradient,\n update=self.update,\n )\n\n\ndef _save_forcefield(fname, ff_params):\n with open(fname, 'w') as fh:\n fh.write(ff_params)\n\n\nif __name__ == \"__main__\":\n default_output_path = f\"results_{str(datetime.datetime.now())}\"\n parser = ArgumentParser(description=\"Fit Forcefield parameters to hif2a\")\n parser.add_argument(\"--num-gpus\", default=None, type=int,\n help=f\"Number of GPUs to run against, defaults to {NUM_GPUS} if no hosts provided\")\n parser.add_argument(\"--hosts\", nargs=\"*\", default=None, help=\"Hosts running GRPC worker to use for compute\")\n parser.add_argument(\"--param-updates\", default=1000, type=int, help=\"Number of updates for parameters\")\n parser.add_argument(\"--seed\", default=2021, type=int, help=\"Seed for shuffling ordering of transformations\")\n parser.add_argument(\"--config\", default=\"intermediate\", choices=[\"intermediate\", \"production\", \"test\"])\n\n parser.add_argument(\"--path_to_ff\", default=str(root.joinpath('ff/params/smirnoff_1_1_0_ccc.py')))\n parser.add_argument(\"--path_to_edges\", default=\"relative_transformations.pkl\",\n help=\"Path to pickle file containing list of RelativeFreeEnergy objects\")\n parser.add_argument(\"--output_path\", default=default_output_path, help=\"Path to output directory\")\n # TODO: also make configurable: forces_to_refit, optimizer params, path_to_protein, path_to_protein_ff, ...\n args = parser.parse_args()\n\n # create path if it doesn't exist\n output_path = Path(args.output_path)\n output_path.mkdir(parents=True, exist_ok=True)\n print(f'output path: {output_path}')\n\n # xor num_gpus and hosts args\n args = parser.parse_args()\n if args.num_gpus is not None and args.hosts is not None:\n print(\"Unable to provide --num-gpus and --hosts together\")\n sys.exit(1)\n\n # which force field components we'll refit\n forces_to_refit = [AM1CCCHandler, LennardJonesHandler]\n\n # how much computation to spend per refitting step\n configuration = None\n if args.config == \"intermediate\": # goldilocks\n configuration = intermediate_configuration\n elif args.config == \"test\":\n configuration = testing_configuration # a little\n elif args.config == \"production\":\n configuration = production_configuration # a lot\n assert configuration is not None, \"No configuration provided\"\n\n if not args.hosts:\n num_gpus = args.num_gpus\n if num_gpus is None:\n num_gpus = NUM_GPUS\n # set up multi-GPU client\n client = CUDAPoolClient(max_workers=num_gpus)\n else:\n # Setup GRPC client\n client = GRPCClient(hosts=args.hosts)\n client.verify()\n\n # load and construct forcefield\n with open(args.path_to_ff) as f:\n ff_handlers = deserialize_handlers(f.read())\n\n forcefield = Forcefield(ff_handlers)\n\n # load pre-defined collection of relative transformations\n with open(args.path_to_edges, 'rb') as f:\n relative_transformations: List[RelativeFreeEnergy] = load(f)\n\n # update the forcefield parameters for a few steps, each step informed by a single free energy calculation\n\n # compute and save the sequence of relative_transformation indices\n num_epochs = int(np.ceil(args.param_updates / len(relative_transformations)))\n np.random.seed(args.seed)\n step_inds = []\n for epoch in range(num_epochs):\n inds = np.arange(len(relative_transformations))\n np.random.shuffle(inds)\n step_inds.append(inds)\n step_inds = np.hstack(step_inds)[:args.param_updates]\n\n np.save(output_path.joinpath('step_indices.npy'), step_inds)\n\n # build the complex system\n complex_system, complex_coords, _, _, complex_box, _ = builders.build_protein_system(\n path_to_protein)\n # TODO: optimize box\n complex_box += np.eye(3) * 0.1 # BFGS this later\n\n # build the water system\n solvent_system, solvent_coords, solvent_box, _ = builders.build_water_system(4.0)\n # TODO: optimize box\n solvent_box += np.eye(3) * 0.1 # BFGS this later\n\n # note: \"complex\" means \"protein + solvent\"\n binding_model = RBFEModel(\n client=client,\n ff=forcefield,\n complex_system=complex_system,\n complex_coords=complex_coords,\n complex_box=complex_box,\n complex_schedule=construct_lambda_schedule(configuration.num_complex_windows),\n solvent_system=solvent_system,\n solvent_coords=solvent_coords,\n solvent_box=solvent_box,\n solvent_schedule=construct_lambda_schedule(configuration.num_solvent_windows),\n equil_steps=configuration.num_equil_steps,\n prod_steps=configuration.num_prod_steps,\n )\n\n\n def loss_fxn(ff_params, mol_a, mol_b, core, label_ddG, callback=None):\n pred_ddG = binding_model.predict(ff_params, mol_a, mol_b, core, callback)\n return pseudo_huber_loss(pred_ddG - label_ddG)\n\n\n # TODO: how to get intermediate results from the computational pipeline encapsulated in binding_model.loss ?\n # e.g. stage_results, and further diagnostic information\n # * x trajectories,\n # * d U / d parameters trajectories,\n # * matrix of U(x; lambda) for all x, lambda\n # * the deltaG pred\n # (proper way is probably something like has_aux=True https://jax.readthedocs.io/en/latest/jax.html#jax.value_and_grad)\n\n ordered_params = forcefield.get_ordered_params()\n ordered_handles = forcefield.get_ordered_handles()\n\n handle_types_being_optimized = [AM1CCCHandler, LennardJonesHandler]\n\n\n # TODO: move flatten into optimize.utils\n def flatten(params) -> Tuple[np.array, callable]:\n \"\"\"Turn params dict into flat array, with an accompanying unflatten function\n\n TODO: note that the result is going to be in the order given by ordered_handles (filtered by presence in handle_types)\n rather than in the order they appear in handle_types_being_optimized\n\n TODO: maybe leave out the reference to handle_types_being optimized altogether\n\n TODO: does Jax have a pytree-based flatten / unflatten utility?\n \"\"\"\n\n theta_list = []\n _shapes = dict()\n _handle_types = []\n\n for param, handle in zip(params, ordered_handles):\n assert handle.params.shape == param.shape\n key = type(handle)\n\n if key in handle_types_being_optimized:\n theta_list.append(param.flatten())\n _shapes[key] = param.shape\n _handle_types.append(key)\n\n theta = np.hstack(theta_list)\n\n def unflatten(theta: array) -> Dict[Handler, array]:\n params = dict()\n i = 0\n for key in _handle_types:\n shape = _shapes[key]\n num_params = int(np.prod(shape))\n params[key] = np.array(theta[i: i + num_params]).reshape(shape)\n i += num_params\n return params\n\n return theta, unflatten\n\n\n relative_improvement_bound = 0.8\n\n\n def _compute_step_lower_bound(loss, blown_up):\n \"\"\"problem this addresses: on a small fraction of steps, the free energy estimate may be grossly unreliable\n away from target, typically indicating an instability was encountered.\n detect if this occurs, and don't allow a step.\n\n \"\"\"\n if not blown_up:\n return loss * relative_improvement_bound\n else:\n return loss # don't move!\n\n\n def _results_to_arrays(results: List[SimulationResult]):\n \"\"\"each result object was constructed by SimulationResult(xs=xs, du_dls=full_du_dls, du_dps=grads)\n\n for each field, concatenate into an array\n \"\"\"\n\n xs = np.array([r.xs for r in results])\n du_dls = np.array([r.du_dls for r in results])\n du_dps = np.array([r.du_dps for r in results])\n\n return xs, du_dls, du_dps\n\n\n def _blew_up(results: List[SimulationResult]):\n \"\"\"if stddev(du_dls) for any window exceeded 1000 kJ/mol, don't trust result enough to take a step\n if du_dls contains any nans, don't trust result enough to take a step\"\"\"\n du_dls = _results_to_arrays(results)[1]\n\n # TODO: adjust this threshold a bit, move reliability calculations into fe/estimator.py or fe/model.py\n return np.isnan(du_dls).any() or (du_dls.std(1).max() > 1000)\n\n\n results_this_step = dict() # {stage : result} pairs # TODO: proper type hint\n\n\n def save_in_memory_callback(results, stage):\n global results_this_step\n results_this_step[stage] = results\n print(f'collected {stage} results!')\n\n\n # in each optimizer step, look at one transformation from relative_transformations\n for step, rfe_ind in enumerate(step_inds):\n rfe = relative_transformations[rfe_ind]\n\n # compute a step, measuring total wall-time\n t0 = time()\n\n # TODO: perhaps update this to accept an rfe argument, instead of all of rfe's attributes as arguments\n loss, loss_grads = jax.value_and_grad(loss_fxn, argnums=0)(ordered_params, rfe.mol_a, rfe.mol_b, rfe.core,\n rfe.label, callback=save_in_memory_callback)\n print(f\"at optimizer step {step}, loss={loss:.3f}\")\n\n # check if it's probably okay to take an optimizer step on the basis of this result\n # TODO: move responsibility for returning error flags / simulation uncertainty estimates further upstream\n blown_up = _blew_up(results_this_step['complex']) or _blew_up(results_this_step['solvent'])\n\n # note: unflatten_grad and unflatten_theta have identical definitions for now\n flat_loss_grad, unflatten_grad = flatten(loss_grads)\n flat_theta, unflatten_theta = flatten(ordered_params)\n\n # based on current estimate of (loss, grad, and simulation stability), return a conservative step to take in parameter space\n theta_increment = truncated_step(flat_theta, loss, flat_loss_grad,\n step_lower_bound=_compute_step_lower_bound(loss, blown_up))\n param_increments = unflatten_theta(theta_increment)\n\n # for any parameter handler types being updated, update in place\n for handle in ordered_handles:\n handle_type = type(handle)\n if handle_type in param_increments:\n print(f'updating {handle_type.__name__}')\n\n # TODO: careful -- this must be a \"+=\" or \"-=\" not an \"=\"!\n handle.params += param_increments[handle_type]\n\n increment = param_increments[handle_type]\n update_mask = increment != 0\n\n # TODO: replace with a function that knows what to report about each handle type\n print(\n f'updated {int(np.sum(update_mask))} params by between {np.min(increment[update_mask]):.4f} and {np.max(increment[update_mask])}')\n\n t1 = time()\n elapsed = t1 - t0\n\n print(f'completed forcefield-updating step {step} in {elapsed:.3f} s !')\n\n # save du_dls snapshot\n path_to_du_dls = output_path.joinpath(f'du_dls_snapshot_{step}.npz')\n print(f'saving du_dl trajs to {path_to_du_dls}')\n du_dls_dict = dict() # keywords here must be strings\n for stage, results in results_this_step.items():\n du_dls_dict[stage] = _results_to_arrays(results)[1]\n np.savez(path_to_du_dls, **du_dls_dict)\n\n # also save information about this step's parameter gradient and parameter update\n # results to npz\n path_to_npz = output_path.joinpath(f'theta_grad_loss_snapshot_{step}.npz')\n print(f'saving theta, grad, loss snapshot to {path_to_npz}')\n np.savez(\n path_to_npz,\n theta=np.array(flat_theta),\n grad=np.array(flat_loss_grad),\n loss=loss\n )\n\n # TODO: same for xs and du_dps snapshots\n\n # save updated forcefield .py files after every gradient step\n step_params = serialize_handlers(ff_handlers)\n # TODO: consider if there's a more modular way to keep track of ff updates\n _save_forcefield(output_path.joinpath(\"forcefield_checkpoint_{step}.py\"), ff_params=step_params)\n", "meta": {"hexsha": "fa7f2846e848bb0d7bf5c60792c572cea3dad4d8", "size": 15077, "ext": "py", "lang": "Python", "max_stars_repo_path": "examples/hif2a/fit_to_multiple_rbfes.py", "max_stars_repo_name": "fehomi/timemachine", "max_stars_repo_head_hexsha": "594b10c03a6688c008eb4d35e612dbd98f5eede4", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "examples/hif2a/fit_to_multiple_rbfes.py", "max_issues_repo_name": "fehomi/timemachine", "max_issues_repo_head_hexsha": "594b10c03a6688c008eb4d35e612dbd98f5eede4", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "examples/hif2a/fit_to_multiple_rbfes.py", "max_forks_repo_name": "fehomi/timemachine", "max_forks_repo_head_hexsha": "594b10c03a6688c008eb4d35e612dbd98f5eede4", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.5601023018, "max_line_length": 150, "alphanum_fraction": 0.6872056775, "include": true, "reason": "import numpy,import jax,from jax", "num_tokens": 3419, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6039318337259583, "lm_q2_score": 0.3242353924510608, "lm_q1q2_score": 0.1958160751218249}} {"text": "#!/usr/bin/env python\nfrom __future__ import division\nimport numpy as np\nimport pandas as pd\nimport warnings\nfrom .helpers import *\n\ndef analyze_chunk(data, subjgroup=None, subjname='Subject', listgroup=None, listname='List', analysis=None, analysis_type=None, pass_features=False, **kwargs):\n \"\"\"\n Private function that groups data by subject/list number and performs analysis for a chunk of data.\n\n Parameters\n ----------\n data : Egg data object\n The data to be analyzed\n\n subjgroup : list of strings or ints\n String/int variables indicating how to group over subjects. Must be\n the length of the number of subjects\n\n subjname : string\n Name of the subject grouping variable\n\n listgroup : list of strings or ints\n String/int variables indicating how to group over list. Must be\n the length of the number of lists\n\n listname : string\n Name of the list grouping variable\n\n analysis : function\n This function analyzes data and returns it.\n\n pass_features : bool\n Logical indicating whether the analyses uses the features field of the Egg\n\n Returns\n ----------\n analyzed_data : Pandas DataFrame\n DataFrame containing the analysis results\n\n \"\"\"\n # if no grouping, set default to iterate over each list independently\n subjgroup = subjgroup if subjgroup else data.pres.index.levels[0].values\n listgroup = listgroup if listgroup else data.pres.index.levels[1].values\n\n # create a dictionary for grouping\n subjdict = {subj : data.pres.index.levels[0].values[subj==np.array(subjgroup)] for subj in set(subjgroup)}\n # listdict = {lst : data.pres.index.levels[1].values[lst==np.array(listgroup)] for lst in set(listgroup)}\n\n # allow for lists of listgroup arguments\n if all(isinstance(el, list) for el in listgroup):\n listdict = [{lst : data.pres.index.levels[1].values[lst==np.array(listgrpsub)] for lst in set(listgrpsub)} for listgrpsub in listgroup]\n else:\n listdict = [{lst : data.pres.index.levels[1].values[lst==np.array(listgroup)] for lst in set(listgroup)} for subj in subjdict]\n\n # perform the analysis\n def perform_analysis(subj, lst):\n\n # get data slice for presentation and recall\n pres_slice = data.pres.loc[[(s,l) for s in subjdict[subj] for l in listdict[subj][lst] if all(~pd.isnull(data.pres.loc[(s,l)]))]]\n pres_slice.list_length = data.list_length\n\n rec_slice = data.rec.loc[[(s,l) for s in subjdict[subj] for l in listdict[subj][lst] if all(~pd.isnull(data.pres.loc[(s,l)]))]]\n\n # if features are need for analysis, get the features for this slice of data\n if pass_features:\n feature_slice = data.features.loc[[(s,l) for s in subjdict[subj] for l in listdict[subj][lst] if all(~pd.isnull(data.pres.loc[(s,l)]))]]\n\n # generate indices\n index = pd.MultiIndex.from_arrays([[subj],[lst]], names=[subjname, listname])\n\n # perform analysis for each data chunk\n if pass_features:\n return pd.DataFrame([analysis(pres_slice, rec_slice, feature_slice, data.dist_funcs, **kwargs)], index=index, columns=[feature for feature in feature_slice[0].as_matrix()[0].keys()])\n else:\n return pd.DataFrame([analysis(pres_slice, rec_slice, **kwargs)], index=index)\n\n # create list of chunks to process\n a=[]\n b=[]\n for subj in subjdict:\n for lst in listdict[0]:\n a.append(subj)\n b.append(lst)\n\n # handle parellel kwarg\n parallel=kwargs['parallel']\n del kwargs['parallel']\n\n # if we're running permutation tests, use multiprocessing\n if parallel==True:\n import multiprocessing\n from pathos.multiprocessing import ProcessingPool as Pool\n p = Pool(multiprocessing.cpu_count())\n analyzed_data = p.map(perform_analysis, a, b)\n else:\n analyzed_data = [perform_analysis(ai, bi) for ai,bi in zip(a,b)]\n\n # concatenate slices\n analyzed_data = pd.concat(analyzed_data)\n\n analyzed_data.attrs = {\n 'analysis_type' : analysis_type,\n 'list_length' : data.list_length\n }\n\n for key in kwargs:\n analyzed_data.attrs[key] = kwargs[key]\n\n return analyzed_data\n\n# recall matrix\ndef recall_matrix(presented, recalled):\n \"\"\"\n Computes recall matrix given list of presented and list of recalled words\n\n Parameters\n ----------\n presented : list of list of strings\n presentedWords are the words presented in the experiment, in order, grouped by list\n\n recalled : list of list of strings\n recalledWords are the words recalled by the subject, in order, grouped by list\n\n Returns\n ----------\n recall_matrix : list of lists of ints\n each integer represents the presentation position of the recalled word in a given list in order of recall\n 0s represent recalled words not presented\n negative ints represent words recalled from previous lists\n\n \"\"\"\n\n def recall_pos(pres_list,rec_list):\n pres_list = list(pres_list)\n rec_list = list(rec_list)\n result = np.zeros(len(pres_list)) if len(pres_list)>=len(rec_list) else np.zeros(len(rec_list))\n result.fill(np.nan)\n for idx,rec_word in enumerate(rec_list):\n if rec_word in pres_list:\n if type(rec_word) is str:\n result[idx]=int(pres_list.index(rec_word)+1)\n return result\n\n result = []\n for pres_list, rec_list in zip(presented.values, recalled.values):\n result.append(recall_pos(pres_list, rec_list))\n return result\n\ndef compute_distances(pres_list, feature_list, dist_funcs):\n \"\"\"\n Compute distances between list words along n feature dimensions\n\n Parameters\n ----------\n pres_list : list\n list of presented words\n feature_list : list\n list of feature dicts for presented words\n dist_funcs : dict\n dict of distance functions for each feature\n\n Returns\n ----------\n distances : dict\n dict of distance matrices for each feature\n \"\"\"\n\n # initialize dist dict\n distances = {}\n\n # for each feature in dist_funcs\n for feature in dist_funcs:\n\n # initialize dist matrix\n dists = np.zeros((len(pres_list), len(pres_list)))\n\n # for each word in the list\n for idx1, item1 in enumerate(pres_list):\n\n # for each word in the list\n for idx2, item2 in enumerate(pres_list):\n\n # compute the distance between word 1 and word 2 along some feature dimension\n dists[idx1,idx2] = dist_funcs[feature](feature_list[idx1][feature],feature_list[idx2][feature])\n\n # set that distance matrix to the value of a dict where the feature name is the key\n distances[feature] = dists\n\n return distances\n\ndef compute_feature_weights(pres_list, rec_list, feature_list, distances):\n \"\"\"\n Compute clustering scores along a set of feature dimensions\n\n Parameters\n ----------\n pres_list : list\n list of presented words\n rec_list : list\n list of recalled words\n feature_list : list\n list of feature dicts for presented words\n distances : dict\n dict of distance matrices for each feature\n\n Returns\n ----------\n weights : list\n list of clustering scores for each feature dimension\n \"\"\"\n\n # initialize the weights object for just this list\n weights = {}\n for feature in feature_list[0]:\n weights[feature] = []\n\n # return default list if there is not enough data to compute the fingerprint\n if len(rec_list) <= 2:\n print('Not enough recalls to compute fingerprint, returning default fingerprint.. (everything is .5)')\n for feature in feature_list[0]:\n weights[feature] = .5\n return [weights[key] for key in weights]\n\n # initialize past word list\n past_words = []\n past_idxs = []\n\n # loop over words\n for i in range(len(rec_list)-1):\n\n # grab current word\n c = rec_list[i]\n\n # grab the next word\n n = rec_list[i + 1]\n\n # if both recalled words are in the encoding list and haven't been recalled before\n if (c in pres_list and n in pres_list) and (c not in past_words and n not in past_words):\n\n # for each feature\n for feature in feature_list[0]:\n\n # get the distance vector for the current word\n dists = distances[feature][pres_list.index(c),:]\n\n # distance between current and next word\n cdist = dists[pres_list.index(n)]\n\n # filter dists removing the words that have already been recalled\n dists_filt = np.array([dist for idx, dist in enumerate(dists) if idx not in past_idxs])\n\n # get indices\n avg_rank = np.mean(np.where(np.sort(dists_filt)[::-1] == cdist)[0]+1)\n\n # compute the weight\n weights[feature].append(avg_rank / len(dists_filt))\n\n # keep track of what has been recalled already\n past_idxs.append(pres_list.index(c))\n past_words.append(c)\n\n # average over the cluster scores for a particular dimension\n for feature in weights:\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\", category=RuntimeWarning)\n weights[feature] = np.nanmean(weights[feature])\n\n return [weights[key] for key in weights]\n\n# def single_perm(p, r, f, distances):\n# r_real = compute_feature_weights(p, r, f, distances)\n# perm = list(np.random.permutation(r))\n# r_perm = compute_feature_weights(p, perm, f, distances)\n# return [feature_perm < r_real[idx] for idx, feature_perm in enumerate(r_perm)]\n#\n# def permute_fingerprint_parallel(p, r, f, distances, n_perms=100):\n#\n# executor = concurrent.futures.ThreadPoolExecutor(10)\n# futures = [executor.submit(single_perm, p, r, f, distances) for perm in range(n_perms)]\n# concurrent.futures.wait(futures)\n#\n# results = [perm.result() for perm in futures]\n#\n# print(np.sum(np.array(results), axis=0) / n_perms)\n#\n# return np.sum(np.array(results), axis=0) / n_perms\n\ndef permute_fingerprint_serial(p, r, f, distances, n_perms=100):\n\n r_perms = []\n r_real = compute_feature_weights(p, r, f, distances)\n\n for iperm in range(n_perms):\n r_perm = list(np.random.permutation(r))\n r_perms.append(compute_feature_weights(p, r_perm, f, distances))\n\n r_perms_bool = []\n for perm in r_perms:\n r_perm_bool = []\n for idx, feature_perm in enumerate(perm):\n r_perm_bool.append(feature_perm < r_real[idx])\n r_perms_bool.append(r_perm_bool)\n\n return np.sum(np.array(r_perms_bool), axis=0) / n_perms\n\n# accuracy analysis\ndef accuracy_helper(pres_slice, rec_slice):\n \"\"\"\n Computes proportion of words recalled\n\n Parameters\n ----------\n pres_slice : Pandas Dataframe\n chunk of presentation data to be analyzed\n rec_slice : Pandas Dataframe\n chunk of recall data to be analyzed\n\n Returns\n ----------\n prop_recalled : numpy array\n proportion of words recalled\n\n \"\"\"\n\n # compute recall_matrix for data slice\n recall = recall_matrix(pres_slice, rec_slice)\n\n # simple function that returns 1 if item encoded in position n is in recall list\n def compute_acc(lst):\n return len([i for i in np.unique(lst) if i>0])/(pres_slice.list_length)\n\n # get spc for each row in recall matrix\n acc_matrix = [compute_acc(lst) for lst in recall]\n\n # average over rows\n prop_recalled = np.mean(acc_matrix,axis=0)\n\n return prop_recalled\n\n# serial position curve\ndef spc_helper(pres_slice, rec_slice):\n \"\"\"\n Computes probability of a word being recalled (in the appropriate recall list), given its presentation position\n\n Parameters\n ----------\n pres_slice : Pandas Dataframe\n chunk of presentation data to be analyzed\n rec_slice : Pandas Dataframe\n chunk of recall data to be analyzed\n\n Returns\n ----------\n prop_recalled : numpy array\n each number represents the probability of recall for a word presented in given position/index\n\n \"\"\"\n\n # compute recall_matrix for data slice\n recall = recall_matrix(pres_slice, rec_slice)\n\n # get spc for each row in recall matrix\n spc_matrix = [[1 if pos in lst else 0 for pos in range(1,len(lst)+1)] for lst in recall]\n\n # average over rows\n prop_recalled = np.mean(spc_matrix, axis=0)\n\n return prop_recalled\n\n# probability of nth recall\ndef pnr_helper(pres_slice, rec_slice, n):\n\n \"\"\"\n Computes probability of a word being recalled nth (in the appropriate recall\n list), given its presentation position. Note: zero indexed\n\n Parameters\n ----------\n pres_slice : Pandas Dataframe\n chunk of presentation data to be analyzed\n rec_slice : Pandas Dataframe\n chunk of recall data to be analyzed\n\n Returns\n ----------\n prob_recalled : numpy array\n each number represents the probability of nth recall for a word presented in given position/index\n\n \"\"\"\n\n # compute recall_matrix for data slice\n recall = recall_matrix(pres_slice, rec_slice)\n\n # simple function that returns 1 if item encoded in position n is recalled first\n def pos_recalled_first(pos,lst,n):\n return 1 if pos==lst[n] else 0\n\n # get pfr for each row in recall matrix\n pnr_matrix = [[pos_recalled_first(pos,lst,n) for pos in range(1,len(lst)+1)] for lst in recall]\n\n # average over rows\n prob_recalled = np.mean(pnr_matrix,axis=0)\n\n return prob_recalled\n\n# lag-crp\ndef lagcrp_helper(pres_slice, rec_slice):\n \"\"\"\n Computes probabilities for each transition distance (probability that a word recalled will be a given distance--in presentation order--from the previous recalled word)\n\n Parameters\n ----------\n pres_slice : Pandas Dataframe\n chunk of presentation data to be analyzed\n rec_slice : Pandas Dataframe\n chunk of recall data to be analyzed\n\n Returns\n ----------\n prob_recalled : numpy array\n each float is the probability of transition distance (distnaces indexed by position, from -(n-1) to (n-1), excluding zero\n\n \"\"\"\n\n # compute recall_matrix for data slice\n recall = recall_matrix(pres_slice, rec_slice)\n\n def check_pair(a, b):\n if (a>0 and b>0) and (a!=b):\n return True\n else:\n return False\n\n def compute_actual(recall_list, list_length):\n arr=pd.Series(data=np.zeros((list_length)*2), index=list(range(-list_length,0))+list(range(1,list_length+1)))\n recalled=[]\n for trial in range(0,list_length-1):\n a=recall_list[trial]\n b=recall_list[trial+1]\n if check_pair(a, b) and (a not in recalled) and (b not in recalled):\n arr[b-a]+=1\n recalled.append(a)\n return arr\n\n def compute_possible(recall_list, list_length):\n arr=pd.Series(data=np.zeros((list_length)*2), index=list(range(-list_length,0))+list(range(1,list_length+1)))\n recalled=[]\n for trial in recall_list:\n\n if np.isnan(trial):\n pass\n else:\n\n low_bound=int(1-trial)\n up_bound=int(list_length-trial)\n\n chances=list(range(low_bound,0))+list(range(1,up_bound+1))\n #ALL transitions\n\n #remove transitions not possible\n for each in recalled:\n if each-trial in chances:\n chances.remove(each-trial)\n\n #update array with possible transitions\n arr[chances]+=1\n\n recalled.append(trial)\n\n return arr\n\n ########\n\n list_crp = []\n for n_list in recall:\n actual = compute_actual(n_list, pres_slice.list_length)\n possible = compute_possible(n_list, pres_slice.list_length)\n crp = [0.0 if j==0 else i/j for i,j in zip(actual,possible)]\n crp.insert(int(len(crp)/2),np.nan)\n list_crp.append(crp)\n\n prob_recalled = np.mean(list_crp, axis=0)\n\n return prob_recalled\n\n# temporal clustering analysis\ndef temporal_helper(pres_slice, rec_slice, permute=False, n_perms=1000):\n \"\"\"\n Computes temporal clustering score\n\n Parameters\n ----------\n pres_slice : Pandas Dataframe\n chunk of presentation data to be analyzed\n rec_slice : Pandas Dataframe\n chunk of recall data to be analyzed\n\n Returns\n ----------\n score : float\n a number representing temporal clustering\n\n \"\"\"\n\n # initialize temporal clustering list\n temporal_clustering = []\n\n # define distance function for temporal clustering\n dist_funcs = {\n 'temporal' : lambda a, b : np.abs(a-b)\n }\n\n # define features (just positions for temporal clustering)\n f = [{'temporal' : i} for i in range(pres_slice.list_length+1)]\n\n # loop over lists\n for p, r in zip(pres_slice.as_matrix(), rec_slice.as_matrix()):\n\n # turn arrays into lists\n p = list(p)\n r = list(filter(lambda ri: isinstance(ri, str), list(r)))\n\n if len(r)>1:\n\n # compute distances\n distances = compute_distances(p, f, dist_funcs)\n\n # add optional bootstrapping\n if permute:\n temporal_clustering.append(permute_fingerprint_serial(p, r, f, distances, n_perms=n_perms))\n else:\n temporal_clustering.append(compute_feature_weights(p, r, f, distances))\n else:\n temporal_clustering.append([np.nan]*len(f[0].keys()))\n\n # return average over rows\n return np.nanmean(temporal_clustering, axis=0)\n\n# fingerprint analysis\ndef fingerprint_helper(pres_slice, rec_slice, feature_slice, dist_funcs, permute=False, n_perms=1000):\n \"\"\"\n Computes clustering along a set of feature dimensions\n\n Parameters\n ----------\n pres_slice : Pandas Dataframe\n chunk of presentation data to be analyzed\n rec_slice : Pandas Dataframe\n chunk of recall data to be analyzed\n feature_slice : Pandas Dataframe\n chunk of features data to be analyzed\n dist_funcs : dict\n Dictionary of distance functions for feature clustering analyses\n\n Returns\n ----------\n probabilities : numpy array\n each number represents clustering along a different feature dimension\n\n \"\"\"\n import time\n\n # compute fingerprint for each list within a chunk\n fingerprint_matrix = []\n\n for p, r, f in zip(pres_slice.as_matrix(), rec_slice.as_matrix(), feature_slice.as_matrix()):\n\n # turn arrays into lists\n p = list(p)\n f = list(f)\n r = list(filter(lambda ri: isinstance(ri, str), list(r)))\n\n if len(r)>1:\n\n # compute distances\n distances = compute_distances(p, f, dist_funcs)\n\n # add optional bootstrapping\n if permute:\n fingerprint_matrix.append(permute_fingerprint_serial(p, r, f, distances, n_perms=n_perms))\n else:\n fingerprint_matrix.append(compute_feature_weights(p, r, f, distances))\n else:\n fingerprint_matrix.append([np.nan]*len(f[0].keys()))\n\n # return average over rows\n return np.mean(fingerprint_matrix, axis=0)\n\n# fingerprint + temporal clustering analysis\ndef fingerprint_temporal_helper(pres_slice, rec_slice, feature_slice, dist_funcs, permute=True, n_perms=1000):\n \"\"\"\n Computes clustering along a set of feature dimensions\n\n Parameters\n ----------\n pres_slice : Pandas Dataframe\n chunk of presentation data to be analyzed\n rec_slice : Pandas Dataframe\n chunk of recall data to be analyzed\n feature_slice : Pandas Dataframe\n chunk of features data to be analyzed\n dist_funcs : dict\n Dictionary of distance functions for feature clustering analyses\n\n Returns\n ----------\n probabilities : numpy array\n each number represents clustering along a different feature dimension\n\n \"\"\"\n # compute fingerprint for each list within a chunk\n fingerprint_matrix = []\n\n for p, r, f in zip(pres_slice.as_matrix(), rec_slice.as_matrix(), feature_slice.as_matrix()):\n\n # turn arrays into lists\n p = list(p)\n f = list(f)\n r = list(filter(lambda ri: isinstance(ri, str), list(r)))\n\n # add in temporal clustering\n nf = []\n for idx, fi in enumerate(f):\n fi['temporal'] = idx\n nf.append(fi)\n\n dist_funcs_copy = dist_funcs.copy()\n dist_funcs_copy['temporal'] = lambda a, b : np.abs(a-b)\n\n # if there is at least 1 transition\n if len(r)>1:\n\n # compute distances\n distances = compute_distances(p, nf, dist_funcs_copy)\n\n # add optional bootstrapping\n if permute:\n fingerprint_matrix.append(permute_fingerprint_serial(p, r, nf, distances, n_perms=n_perms))\n else:\n fingerprint_matrix.append(compute_feature_weights(p, r, nf, distances))\n else:\n fingerprint_matrix.append([np.nan]*len(nf[0].keys()))\n\n return np.nanmean(fingerprint_matrix, axis=0)\n\n# main analysis function\ndef analyze(data, subjgroup=None, listgroup=None, subjname='Subject',\n listname='List', analysis=None, n=0, permute=False, n_perms=1000,\n parallel=False):\n \"\"\"\n General analysis function that groups data by subject/list number and performs analysis.\n\n Parameters\n ----------\n data : Egg data object\n The data to be analyzed\n\n subjgroup : list of strings or ints\n String/int variables indicating how to group over subjects. Must be\n the length of the number of subjects\n\n subjname : string\n Name of the subject grouping variable\n\n listgroup : list of strings or ints\n String/int variables indicating how to group over list. Must be\n the length of the number of lists\n\n listname : string\n Name of the list grouping variable\n\n analysis : string\n This is the analysis you want to run. Can be accuracy, spc, pfr,\n temporal or fingerprint\n\n n : int\n Optional argument for pnr analysis. Defines encoding position of item\n to run pnr. Default is 0, and it is zero indexed\n\n permute : bool\n Optional argument for fingerprint/temporal cluster analyses. Determines\n whether to correct clustering scores by shuffling recall order for each list\n to create a distribution of clustering scores (for each feature). The\n \"corrected\" clustering score is the proportion of clustering scores in\n that random distribution that were lower than the clustering score for\n the observed recall sequence. Default is False.\n\n n_perms : int\n Optional argument for fingerprint/temporal cluster analyses. Number of\n permutations to run for \"corrected\" clustering scores. Default is 1000 (\n per recall list).\n\n parallel : bool\n Option to use multiprocessing (this can help speed up the permutations\n tests in the clustering calculations)\n\n Returns\n ----------\n analyzed_data : Pandas DataFrame\n DataFrame containing the analysis results\n\n \"\"\"\n\n # make sure an analysis is specified\n if analysis is None:\n raise ValueError('You must pass an analysis type.')\n\n # check if subject/list grouping variables exist on the egg\n if hasattr(data, 'subjgroup'):\n if data.subjgroup is not None:\n subjgroup = data.subjgroup\n\n if hasattr(data, 'subjname'):\n if data.subjname is not None:\n subjname = data.subjname\n\n if hasattr(data, 'listgroup'):\n if data.listgroup is not None:\n listgroup = data.listgroup\n\n if hasattr(data, 'listname'):\n if data.listname is not None:\n listname = data.listname\n\n if type(data) != list:\n data = [data]\n\n if type(analysis) != list:\n analysis = [analysis]\n\n result = [[] for d in range(len(data))]\n\n for idx,d in enumerate(data):\n for a in analysis:\n\n if a is 'accuracy':\n r = analyze_chunk(d, subjgroup=subjgroup,\n listgroup=listgroup,\n subjname=subjname,\n listname=listname,\n analysis=accuracy_helper,\n analysis_type='accuracy',\n pass_features=False,\n parallel=parallel)\n elif a is 'spc':\n r = analyze_chunk(d, subjgroup=subjgroup,\n listgroup=listgroup,\n subjname=subjname,\n listname=listname,\n analysis=spc_helper,\n analysis_type='spc',\n pass_features=False,\n parallel=parallel)\n elif a is 'pfr':\n r = analyze_chunk(d, subjgroup=subjgroup,\n listgroup=listgroup,\n subjname=subjname,\n listname=listname,\n analysis=pnr_helper,\n analysis_type='pfr',\n pass_features=False,\n n=0,\n parallel=parallel)\n elif a is 'pnr':\n r = analyze_chunk(d, subjgroup=subjgroup,\n listgroup=listgroup,\n subjname=subjname,\n listname=listname,\n analysis=pnr_helper,\n analysis_type='pnr',\n pass_features=False,\n n=n,\n parallel=parallel)\n elif a is 'lagcrp':\n r = analyze_chunk(d, subjgroup=subjgroup,\n listgroup=listgroup,\n subjname=subjname,\n listname=listname,\n analysis=lagcrp_helper,\n analysis_type='lagcrp',\n pass_features=False,\n parallel=parallel)\n # set indices for lagcrp\n r.columns=range(-int((len(r.columns)-1)/2),int((len(r.columns)-1)/2)+1)\n elif a is 'fingerprint':\n r = analyze_chunk(d, subjgroup=subjgroup,\n listgroup=listgroup,\n subjname=subjname,\n listname=listname,\n analysis=fingerprint_helper,\n analysis_type='fingerprint',\n pass_features=True,\n permute=permute,\n n_perms=n_perms,\n parallel=parallel)\n elif a is 'temporal':\n r = analyze_chunk(d, subjgroup=subjgroup,\n listgroup=listgroup,\n subjname=subjname,\n listname=listname,\n analysis=temporal_helper,\n analysis_type='temporal',\n permute=permute,\n n_perms=n_perms,\n parallel=parallel)\n elif a is 'fingerprint_temporal':\n r = analyze_chunk(d, subjgroup=subjgroup,\n listgroup=listgroup,\n subjname=subjname,\n listname=listname,\n analysis=fingerprint_temporal_helper,\n analysis_type='fingerprint_temporal',\n pass_features=True,\n permute=permute,\n n_perms=n_perms,\n parallel=parallel)\n\n result[idx].append(r)\n\n # return analysis result\n if len(data)>1 and len(analysis)>1:\n return result\n elif len(data)>1 and len(analysis)==1:\n return [item[0] for item in result]\n elif len(data)==1 and len(analysis)>1:\n return [item for item in result[0]]\n else:\n return result[0][0]\n", "meta": {"hexsha": "b45933c9840ca69f59b90f1ea5ad44248b1ed99f", "size": 28772, "ext": "py", "lang": "Python", "max_stars_repo_path": "build/lib/quail/analysis.py", "max_stars_repo_name": "mkclairhong/quail", "max_stars_repo_head_hexsha": "a6d6502746c853518a670d542222eb5fc2b05542", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-05-30T15:33:26.000Z", "max_stars_repo_stars_event_max_datetime": "2018-05-30T15:33:26.000Z", "max_issues_repo_path": "build/lib/quail/analysis.py", "max_issues_repo_name": "mkclairhong/quail", "max_issues_repo_head_hexsha": "a6d6502746c853518a670d542222eb5fc2b05542", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2018-06-21T13:21:22.000Z", "max_issues_repo_issues_event_max_datetime": "2018-07-24T21:20:05.000Z", "max_forks_repo_path": "build/lib/quail/analysis.py", "max_forks_repo_name": "mkclairhong/quail", "max_forks_repo_head_hexsha": "a6d6502746c853518a670d542222eb5fc2b05542", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2018-06-01T17:39:48.000Z", "max_forks_repo_forks_event_max_datetime": "2018-06-01T17:39:48.000Z", "avg_line_length": 34.623345367, "max_line_length": 194, "alphanum_fraction": 0.6048588906, "include": true, "reason": "import numpy", "num_tokens": 6099, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5851011542032312, "lm_q2_score": 0.334589441253186, "lm_q1q2_score": 0.19576866826145334}} {"text": "from copy import deepcopy\nimport os\nROOT = os.path.dirname(os.path.abspath(__file__)) + '/'\n\nfrom astropy import log as logger\nimport numpy as np\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\nimport matplotlib.gridspec as gridspec\n\nfrom .filter import Filter\n\nfrom .utils.one_filter import OneFilter\nfrom .utils.plot import MakePlots\nfrom .utils.plot_filters import PlotFilters\nfrom .utils.tools import properties, grid_units, get_slices, average_collapse, central_wav\nfrom .utils.units import ConvertUnits\n\n\nclass SyntheticSED(object):\n\n '''\n SyntheticSED is part of the FluxCompensator. It converts \n input_arrays (e. g. HYPERION ModelOutput) to \"realistic\" synthetic observations. \n It contains attributes like ModelOutput (see Notes).\n If input_array is already a SyntheticSED object, the attributes are\n passed. If input_array is not a SyntheticSED object, SyntheticSED\n specific attributes are defined and then passed. \n \n \n Parameters\n ----------\n \n input_array : SyntheticSED, ModelOutput (get_sed), optional\n input_array also reads arrays with ModelOutput like properties. \n \n unit_out : str, optional\n The output units for SyntheticSED val. Valid options are:\n\n * ``'ergs/cm^2/s'``\n * ``'ergs/cm^2/s/Hz'``\n * ``'Jy'``\n * ``'mJy'``\n * ``'MJy/sr'``\n \n The default is ``'ergs/cm^2/s'``.\n \n name : str\n The name of the FluxCompensator object until another\n input_array is called. The default is ``None``.\n \n \n Attributes\n ----------\n \n wav : numpy.ndarray\n The wavelengths of the val vector entries in microns.\n \n val : numpy.ndarray\n The 1D vector with shape like wav.\n \n units : str\n Current units of the val vector.\n \n distance : str\n Distance to the observed object in cm.\n \n x_min : float \n Physical offset from axis origin in FOV in cm.\n \n x_max : float \n Physical offset from axis origin in FOV in cm.\n \n y_min : float\n Physical offset from axis origin in FOV in cm.\n \n y_max : float \n Physical offset from axis origin in FOV in cm.\n \n lon_min : float\n Minimal longitudinal angle.\n \n lon_max : float\n Maximal longitudinal angle.\n \n lat_min : float\n Minimal latitudinal angle.\n \n lat_max : float\n Maximal latitudinal angle.\n \n pix_area_sr : float\n Pixel area per sr.\n \n ap_min : float\n Minimal aperture.\n \n ap_max : float\n Maximal aperture.\n \n \n Notes\n -----\n unit_in : str\n Unit of val in input_array. Valid options are:\n \n * ``'ergs/cm^2/s'``\n * ``'ergs/cm^2/s/Hz'``\n * ``'Jy'``\n * ``'mJy'``\n * ``'MJy/sr'``\n \n grid_unit : float\n Physical unit of FOV axis in cm. Valid options are:\n \n * ``au`` in cm\n * ``pc`` in cm\n * ``kpc`` in cm\n \n grid_unit_name\n Astronomical unit of FOV axis. Valid options are:\n \n * ``'au'``\n * ``'pc'``\n * ``'kpc'``\n \n FOV : tuple\n Tuple ``FOV(x,y)`` of Field of View pixel entries.\n \n * pixel in x direction: ``FOV[0]``\n * pixel in y direction: ``FOV[1]``\n \n name : str\n The name of the FluxCompensator object until another \n input_array is called. The default is ``None``.\n \n stage : str\n Gives current operation stage of SyntheticSED.\n E. g. ``'SyntheticSED: convolve_filter'``\n \n log : list\n List of strings of the previous and current stages.\n \n filter : dict\n Dictionary ``filter = {name, waf_0, waf_min, waf_max}`` \n of the applied filter. \n \n * name of filter: ``filter['name']``\n * central wavelength: ``filter['waf_0']``\n * minimal wavelength: ``filter['waf_min']``\n * maximal wavelength: ``filter['waf_max']``\n \n Returns\n -------\n \n sed : SyntheticSED\n 1D val array (collapsed rough SED) with SyntheticSED properties.\n \n flux : SyntheticFlux\n 0D val array (scalar) with SyntheticFlux properties.\n '''\n\n def __init__(self, input_array, unit_out='ergs/cm^2/s', name=None):\n\n # Hyperion ModelOutput attributes (image and sed)\n if input_array.val.ndim == 2 and input_array.val[:, 0].ndim == 1:\n self.val = np.array(input_array.val[0, :])\n else:\n self.val = np.array(deepcopy(input_array.val))\n\n self.wav = np.array(deepcopy(input_array.wav))\n self.units = input_array.units\n self.distance = input_array.distance\n\n # Hyperion Image\n try:\n self.x_max = input_array.x_max\n self.x_max = input_array.x_max\n self.x_min = input_array.x_min\n self.y_max = input_array.y_max\n self.y_min = input_array.y_min\n self.lon_min = input_array.lon_min\n self.lon_max = input_array.lon_max\n self.lat_min = input_array.lat_min\n self.lat_max = input_array.lat_max\n self.pix_area_sr = input_array.pix_area_sr\n # switch\n self.hyperion_cube = True\n\n except AttributeError:\n self.x_max = None\n self.x_max = None\n self.x_min = None\n self.y_max = None\n self.y_min = None\n self.lon_min = None\n self.lon_max = None\n self.lat_min = None\n self.lat_max = None\n self.pix_area_sr = None\n # switch\n self.hyperion_cube = None\n\n # Hyperion SED\n try:\n self.ap_min = input_array.ap_min\n self.ap_max = input_array.ap_max\n # switch\n self.hyperion_sed = True\n\n except AttributeError:\n self.ap_min = None\n self.ap_max = None\n # switch\n self.hyperion_sed = None\n\n ##################\n # new attributes #\n ##################\n\n from .cube import SyntheticCube\n\n if isinstance(input_array, SyntheticSED) or isinstance(input_array, SyntheticCube):\n # attributes with are passed, since input_array is SyntheticSED or SyntheticCube\n\n # physical values\n self.unit_in = input_array.unit_in\n self.unit_out = input_array.unit_out\n\n if self.x_max is not None:\n self.grid_unit = grid_units(self.x_max - self.x_min)['grid_unit']\n self.grid_unit_name = grid_units(self.x_max - self.x_min)['grid_unit_name']\n else:\n self.grid_unit = None\n self.grid_unit_name = None\n\n # properties of cube\n self.FOV = deepcopy(input_array.FOV)\n\n # name\n self.name = input_array.name\n self.stage = input_array.stage\n self.log = deepcopy(input_array.log)\n\n # filter\n self.filter = deepcopy(input_array.filter)\n\n elif not isinstance(input_array, SyntheticSED) and not isinstance(input_array, SyntheticCube) and self.hyperion_sed is True:\n # attributes with are defined, since input_array is NOT SyntheticSED or SyntheticCube but HyperionSED\n self.unit_in = input_array.units\n self.unit_out = unit_out\n\n self.grid_unit = None\n self.grid_unit_name = None\n\n self.FOV = None\n\n # name\n self.name = name\n self.stage = 'SyntheticSED: initial'\n self.log = [self.stage]\n\n # filter\n self.filter = {'name': None, 'waf_0': None, 'waf_min': None, 'waf_max': None}\n\n # convert into val units into unit_out\n if self.unit_in == 'MJy/sr' or self.unit_out == 'MJy/sr' or self.unit_in == 'Jy/arcsec^2' or self.unit_out == 'Jy/arcsec^2':\n raise Exception('WARNING: Input or Output units needs to differ from MJy/sr if Input_array is not SyntheticCube or SyntheticSED or HyperionCube')\n\n s = ConvertUnits(wav=self.wav, val=self.val)\n self.val = s.get_unit(in_units=self.unit_in, out_units=self.unit_out)\n\n self.units = self.unit_out\n\n else: # attributes with are defined, since input_array is NOT SyntheticSED or SyntheticCube or HyperionOutput\n # physical values\n self.unit_in = input_array.units\n self.unit_out = unit_out\n\n self.grid_unit = grid_units(self.x_max)['grid_unit']\n self.grid_unit_name = grid_units(self.x_max)['grid_unit_name']\n\n self.FOV = (self.x_max - self.x_min, self.y_max - self.y_min)\n\n # name\n self.name = name\n self.stage = 'SyntheticSED: initial'\n self.log = [self.stage]\n\n # filter\n self.filter = {'name': None, 'waf_0': None, 'waf_min': None, 'waf_max': None}\n\n # convert into val units into unit_out\n s = ConvertUnits(wav=self.wav, val=self.val)\n self.val = s.get_unit(in_units=self.unit_in, out_units=self.unit_out, input_resolution=self.resolution['arcsec'])\n\n self.units = self.unit_out\n\n def extinction(self, A_v, input_opacities=None):\n '''\n Accounts for reddening.\n \n Parameters\n ----------\n \n A_v : Value of the visible extinction.\n \n input_opacities : ``None``, str\n If ``None`` standard extinction law is used. \n Otherwise a e. g. input_opacities.txt file can be passed \n as a str to read an opacity file with column #1 wav in microns \n and column #2 in cm^2/g. \n Default is ``None``.\n \n Returns\n -------\n \n sed : SyntheticSED \n '''\n\n stage = 'SyntheticSED: extinction'\n\n # read own extinction law\n if input_opacities is None:\n t = np.loadtxt(ROOT + 'database/extinction/extinction_law.txt')\n\n else:\n t = np.loadtxt(input_opacities)\n\n wav_ext = t[:, 0]\n k_lam = t[:, 1]\n\n # wav_ext monotonically increasing\n if wav_ext[0] > wav_ext[1]:\n wav_ext = wav_ext[::-1]\n k_lam = k_lam[::-1]\n\n k_v = np.interp(0.550, wav_ext, k_lam)\n\n # interpolate to get A_int for a certain wavelength\n k = np.interp(self.wav, wav_ext, k_lam)\n A_int_lam = A_v * (k / k_v)\n\n # apply extinction law\n val_ext = np.zeros(shape=np.shape(self.val))\n val_ext[:len(self.wav)] = self.val[:len(self.wav)] * 10 ** (-0.4 * A_int_lam[:len(self.wav)])\n\n # return SyntheticSED\n s = SyntheticSED(self)\n s.val = val_ext\n s.stage = stage\n s.log.append(s.stage)\n\n return s\n\n def convolve_filter(self, filter_input, plot_rebin=None, plot_rebin_dpi=None):\n '''\n Convolves vector val entries within filter limits in a 0D val array.\n \n Parameters\n ----------\n \n filter_input : object\n \n * database : if filter ``name`` from FluxCompensator database is used. \n * Filter : if own filter is used.\n \n plot_rebin : ``True``, ``None``\n Switch to plot the rebined filter and the original filter in one plot.\n \n plot_rebin_dpi : ``None``, scalar > 0 \n The resolution in dots per inch. \n ``None`` is default and will use the val savefig.dpi \n in the matplotlibrc file.\n \n\n Returns\n -------\n \n flux : SyntheticFlux\n '''\n\n stage = 'SyntheticSED: convolve_filter'\n\n # debugging comment\n logger.debug('-' * 70)\n logger.debug(stage)\n logger.debug('-' * 70)\n \n weight = filter_input.rebin(self.wav, self.val)\n\n # returns weight{'wav_short' 'val_short' 'Response_new' 'filter_index' 'wavf_0' 'waf_min' 'waf_max' 'filter_name'}\n wav_short = weight['wav_short']\n val_short = weight['val_short']\n filter_index = weight['filter_index']\n Response_new = weight['Response_new']\n waf_0 = weight['waf_0']\n waf_min = weight['waf_min']\n waf_max = weight['waf_max']\n filter_name = weight['filter_name']\n\n if plot_rebin is not None:\n plot = filter_input.plot(val_name=self.name, dpi=plot_rebin_dpi)\n\n # weight val_short with rebined response\n val = val_short.copy()\n val[:len(wav_short)] = val_short[:len(wav_short)] * Response_new[:len(wav_short)]\n\n # collapse remaining vector to val scalar\n val_tot = np.sum(val)\n\n # return SyntheticFlux\n from .flux import SyntheticFlux\n f = SyntheticFlux(self)\n f.log.append(stage)\n f.stage = 'SyntheticFlux: initial'\n f.log.append(f.stage)\n f.val = val_tot\n f.wav = np.array(waf_0)\n f.filter = {'name': filter_name, 'waf_0': waf_0, 'waf_min': waf_min, 'waf_max': waf_max}\n\n return f\n\n def get_total_val(self, wav_1, wav_2):\n '''\n Collapses the val entries in the vector within the boundaries wav_1\n and wav_2 into a 0D val array. \n \n WARNING: This tool cannot replace convolve_filter! \n But it can be used to produce rough estimates \n in-between the processes.\n\n\n Parameters\n ----------\n \n wav_1, wav_2 : float\n Boundaries in microns.\n \n \n Returns\n -------\n \n flux : SyntheticFlux\n '''\n\n stage = 'SyntheticSED: get_total_val'\n\n # for MJy/sr convert first, add and then convert back\n if self.unit_out == 'MJy/sr' or self.unit_out == 'Jy/arcsec^2':\n s = ConvertUnits(wav=self.wav, val=self.val)\n self.val = s.get_unit(in_units=self.units, out_units='Jy', input_resolution=self.resolution['arcsec'])\n\n # slices within boundaries are extracted, averaged collapsed to a single scalar val\n vec = get_slices(wav=self.wav, val=self.val, wav_1=wav_1, wav_2=wav_2)\n f_total = average_collapse(val=vec['val_short'])\n\n # real limits within collapse\n wav_max = 10 ** (np.log10(self.wav[vec['filter_index'][0]]) + self.spacing_wav / 2.)\n wav_min = 10 ** (np.log10(self.wav[vec['filter_index'][-1]]) - self.spacing_wav / 2.)\n wav_total = central_wav(wav=[wav_min, wav_max])\n\n # for MJy/sr convert first, add and then convert back\n if self.unit_out == 'MJy/sr' or self.unit_out == 'Jy/arcsec^2':\n s = ConvertUnits(wav=wav_total, val=f_total)\n f_total = s.get_unit(in_units='Jy', out_units=self.unit_out, input_resolution=self.resolution['arcsec'] * self.pixel[0])\n\n # return SyntheticFlux\n from .flux import SyntheticFlux\n f = SyntheticFlux(self)\n f.log.append(stage)\n f.stage = 'SyntheticFlux: initial'\n f.log.append(f.stage)\n f.val = np.array(f_total)\n f.wav = np.array(wav_total)\n f.filter = {'name': 'val_tot', 'waf_0': wav_total, 'waf_min': wav_min, 'waf_max': wav_max}\n\n return f\n\n def plot_sed_multi_filter(self, multi_filter_val, multi_filter_wav, names, filter_label_size=None, ymin=10. ** (-5), dpi=None):\n '''\n Reads in array of filtered val and plots it with the current passed val of \n SyntheticSED in a log-log diagram. \n That way the quality of multiple filtered val can be checked, if filters are\n in database.\n If the used filters are not part of the filter database, define a OneFilter object.\n \n \n Parameters\n ----------\n \n multi_filter_val : np.ndarray\n 1D vector with val entries from several filters.\n \n multi_filter_wav : np.ndarray\n 1D vector of central wavelengths from several filters.\n\n names : np.ndarray\n Original name of several filters, if found in database.\n \n filter_label_size : ``None``, ``True``\n Switch wether to set print labels above the filters.\n \n * ``None``: No labels plotted.\n * ``True``: Plots names[index] as label.\n \n ymin : float\n Minimal vertical limit for SED plot. \n Default is 10.**(-10) of the maximum val.\n \n dpi : ``None``, scalar > 0 \n The resolution in dots per inch. \n ``None`` is default and will use the val savefig.dpi \n in the matplotlibrc file.\n \n \n Returns\n -------\n \n flux : SyntheticFlux\n '''\n\n stage = 'SyntheticSED: plot_sed_multi_filter'\n\n # plot sed and val within boundaries of sed\n fig = plt.figure()\n font = {'size': 8}\n\n mpl.rc('font', **font)\n suptitle = fig.suptitle('output SED with filtered val', fontsize=12.)\n\n x_max = self.wav[0]\n x_min = self.wav[-1]\n y_max = 10 * max(self.val)\n y_min = max(self.val) * ymin\n\n # subplot with SED and collapsed fluval\n gs = gridspec.GridSpec(2, 1, height_ratios=[2, 1])\n ax = plt.subplot(gs[0])\n plt.subplots_adjust(wspace=0, hspace=0)\n ax.set_xlim([x_min, x_max])\n ax.set_ylim([y_min, y_max])\n\n #ax.set_xlabel(r'$\\lambda$ [$\\mu$m]')\n ax.set_ylabel('val ' + '[' + str(self.unit_out) + ']')\n plt.loglog(self.wav, self.val, 'o-k', label='rough SED', linewidth=2)\n\n # sort c.fluval.wav, filt after c.wav\n # get index of c.wav in right order\n # [::-1] largest cwav comes first\n sort_order = np.argsort(multi_filter_wav)\n multi_filter_val = np.take(multi_filter_val, sort_order)[::-1]\n multi_filter_wav = np.take(multi_filter_wav, sort_order)[::-1]\n names = np.take(names, sort_order)[::-1]\n\n # color\n f = np.linspace(0, 200, len(names))\n\n for i in range(len(names)):\n current_waf_0 = multi_filter_wav[i]\n current_val = multi_filter_val[i]\n current_name = names[i]\n\n color = plt.cm.RdYlBu(int(f[i]))\n #color = plt.cm.autumn(int(f[i]))\n\n # filter\n text = 'filtered val by ' + str(current_name)\n x = PlotFilters(style='loglog', normalized=True, unit='unit energy')\n plot_filter = x.collect_filters(current_name)\n plt.loglog(current_waf_0, current_val, 'o', color=color)\n\n # subplot with filter responses\n ax2 = plt.subplot(gs[1])\n ax2.set_xlim([x_min, x_max])\n ax2.set_ylim([10. ** (-4), 10.])\n ax2.set_ylabel('filter response [unit energy]', color='k')\n\n for i in range(len(names)):\n current_waf_0 = multi_filter_wav[i]\n current_val = multi_filter_val[i]\n current_name = names[i]\n\n color = plt.cm.RdYlBu(int(f[i]))\n #color = plt.cm.autumn(int(f[i]))\n fancy_line = {'color': color, 'linestyle': '-', 'linewidth': 2}\n\n x = PlotFilters(style='loglog', normalized=True, unit='unit energy')\n plot_filter = x.collect_filters(current_name)\n x.plot(plot_filter, line=fancy_line)\n\n # text above filters\n if filter_label_size is not None:\n plt.text(current_waf_0, 3, current_name, horizontalalignment='center', verticalalignment='center', fontsize=filter_label_size)\n\n ax2.set_xlabel(r'$\\lambda$ [$\\mu$m]')\n\n # legend merged\n h1, l1 = ax.get_legend_handles_labels()\n h2, l2 = ax2.get_legend_handles_labels()\n\n leg = ax.legend(h1 + h2, l1 + l2, loc=(1.03, -0.5))\n for t in leg.get_texts():\n t.set_fontsize('small') # the legend text fontsize\n\n fig.savefig(str(self.name) + '_' + 'process-output_SS-multi-filter.png', dpi=dpi, bbox_inches='tight')\n\n # return SyntheticSED\n s = SyntheticSED(self)\n s.log.append(stage)\n s.stage = 'SyntheticSED: initial'\n s.log.append(s.stage)\n\n return s\n\n @property\n def spacing_wav(self):\n '''\n The property spacing_wav estimates the width of the logarithmic\n spaced wav entries.\n '''\n\n if self.wav.ndim != 0:\n spacing_wav = np.log10(self.wav[0] / self.wav[-1]) / (len(self.wav) - 1)\n else:\n spacing_wav = None\n return spacing_wav\n\n @property\n def pixel(self):\n '''\n The property pixel is a tuple which resembles the current pixel in a\n val slice. ``pixel(x,y)`` are calls as follows:\n \n ``x = pixel[0]``\n ``y = pixel[1]``\n '''\n if self.val.ndim in (0, 1):\n pixel = (None, None)\n if self.val.ndim in (2, 3):\n pixel = (self.val.shape[0], self.val.shape[1])\n return pixel\n\n @property\n def shape(self):\n '''\n The property shape is a string, which resembles the current shape of\n the val array. \n \n scalar: ``'()'`` \n 1D: ``'(wav)'`` \n 2D: ``'(x, y)'`` \n 3D: ``'(x, y , wav)'`` \n '''\n if self.val.ndim == 0:\n shape = '()'\n if self.val.ndim == 1:\n shape = '(wav)'\n if self.val.ndim == 2:\n shape = '(x, y)'\n if self.val.ndim == 3:\n shape = '(x, y, wav)'\n return shape\n\n @property\n def resolution(self):\n '''\n The property resolution tells you the current resolution. If we are already \n in the SED or val dimension everything is considered as one large pixel.\n\n resolution in arcsec per pixel : ``resolution['arcsec']``\n resolution in rad per pixel : ``resolution['rad']``\n \n '''\n resolution = {}\n if self.pixel[0] is None:\n resolution['rad'] = self.FOV[0] / 1. / self.distance\n else:\n resolution['rad'] = self.FOV[0] / self.pixel[0] / self.distance\n resolution['arcsec'] = np.degrees(resolution['rad']) * 3600\n return resolution\n", "meta": {"hexsha": "ce0bd378e8f89a71bede97fbe343aca97e49f24f", "size": 22447, "ext": "py", "lang": "Python", "max_stars_repo_path": "fluxcompensator/sed.py", "max_stars_repo_name": "koepferl/FluxCompensator", "max_stars_repo_head_hexsha": "751cac08971845069da8c962bc83459f091ba0f8", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 9, "max_stars_repo_stars_event_min_datetime": "2017-06-22T15:29:01.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-24T11:55:41.000Z", "max_issues_repo_path": "fluxcompensator/sed.py", "max_issues_repo_name": "koepferl/FluxCompensator", "max_issues_repo_head_hexsha": "751cac08971845069da8c962bc83459f091ba0f8", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-06-16T21:01:51.000Z", "max_issues_repo_issues_event_max_datetime": "2020-06-16T21:01:51.000Z", "max_forks_repo_path": "fluxcompensator/sed.py", "max_forks_repo_name": "koepferl/FluxCompensator", "max_forks_repo_head_hexsha": "751cac08971845069da8c962bc83459f091ba0f8", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2017-06-22T14:57:24.000Z", "max_forks_repo_forks_event_max_datetime": "2020-06-14T16:46:44.000Z", "avg_line_length": 32.9134897361, "max_line_length": 161, "alphanum_fraction": 0.56101038, "include": true, "reason": "import numpy,from astropy", "num_tokens": 5391, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5851011542032312, "lm_q2_score": 0.33458944125318596, "lm_q1q2_score": 0.1957686682614533}} {"text": "import logging\r\n\r\nimport numba\r\nimport numpy as np\r\nimport numpy.random as npr\r\n\r\nimport second.core.box_np_ops as box_np_ops\r\n\r\nlogger = logging.getLogger(__name__)\r\n\r\n\r\ndef unmap(data, count, inds, fill=0):\r\n \"\"\"Unmap a subset of item (data) back to the original set of items (of\r\n size count)\"\"\"\r\n if count == len(inds):\r\n return data\r\n\r\n if len(data.shape) == 1:\r\n ret = np.empty((count, ), dtype=data.dtype)\r\n ret.fill(fill)\r\n ret[inds] = data\r\n else:\r\n ret = np.empty((count, ) + data.shape[1:], dtype=data.dtype)\r\n ret.fill(fill)\r\n ret[inds, :] = data\r\n return ret\r\n\r\n\r\ndef create_target_np(all_anchors,\r\n gt_boxes,\r\n similarity_fn,\r\n box_encoding_fn,\r\n prune_anchor_fn=None,\r\n gt_classes=None,\r\n matched_threshold=0.6,\r\n unmatched_threshold=0.45,\r\n bbox_inside_weight=None,\r\n positive_fraction=None,\r\n rpn_batch_size=300,\r\n norm_by_num_examples=False,\r\n gt_importance=None,\r\n box_code_size=7):\r\n \"\"\"Modified from FAIR detectron.\r\n Args:\r\n all_anchors: [num_of_anchors, box_ndim] float tensor.\r\n gt_boxes: [num_gt_boxes, box_ndim] float tensor.\r\n similarity_fn: a function, accept anchors and gt_boxes, return\r\n similarity matrix(such as IoU).\r\n box_encoding_fn: a function, accept gt_boxes and anchors, return\r\n box encodings(offsets).\r\n prune_anchor_fn: a function, accept anchors, return indices that\r\n indicate valid anchors.\r\n gt_classes: [num_gt_boxes] int tensor. indicate gt classes, must\r\n start with 1.\r\n matched_threshold: float, iou greater than matched_threshold will\r\n be treated as positives.\r\n unmatched_threshold: float, iou smaller than unmatched_threshold will\r\n be treated as negatives.\r\n bbox_inside_weight: unused\r\n positive_fraction: [0-1] float or None. if not None, we will try to\r\n keep ratio of pos/neg equal to positive_fraction when sample.\r\n if there is not enough positives, it fills the rest with negatives\r\n rpn_batch_size: int. sample size\r\n norm_by_num_examples: bool. norm box_weight by number of examples, but\r\n I recommend to do this outside.\r\n gt_importance: 1d array. loss weight per gt.\r\n Returns:\r\n labels, bbox_targets, bbox_outside_weights\r\n \"\"\"\r\n total_anchors = all_anchors.shape[0]\r\n if prune_anchor_fn is not None:\r\n inds_inside = prune_anchor_fn(all_anchors)\r\n anchors = all_anchors[inds_inside, :]\r\n if not isinstance(matched_threshold, float):\r\n matched_threshold = matched_threshold[inds_inside]\r\n if not isinstance(unmatched_threshold, float):\r\n unmatched_threshold = unmatched_threshold[inds_inside]\r\n else:\r\n anchors = all_anchors\r\n inds_inside = None\r\n num_inside = len(inds_inside) if inds_inside is not None else total_anchors\r\n box_ndim = all_anchors.shape[1]\r\n logger.debug('total_anchors: {}'.format(total_anchors))\r\n logger.debug('inds_inside: {}'.format(num_inside))\r\n logger.debug('anchors.shape: {}'.format(anchors.shape))\r\n if gt_classes is None:\r\n gt_classes = np.ones([gt_boxes.shape[0]], dtype=np.int32)\r\n if gt_importance is None:\r\n gt_importance = np.ones([gt_boxes.shape[0]], dtype=np.float32)\r\n\r\n # Compute anchor labels:\r\n # label=1 is positive, 0 is negative, -1 is don't care (ignore)\r\n labels = np.empty((num_inside, ), dtype=np.int32)\r\n gt_ids = np.empty((num_inside, ), dtype=np.int32)\r\n labels.fill(-1)\r\n gt_ids.fill(-1)\r\n importance = np.empty((num_inside, ), dtype=np.float32)\r\n importance.fill(1)\r\n if len(gt_boxes) > 0:\r\n # Compute overlaps between the anchors and the gt boxes overlaps\r\n anchor_by_gt_overlap = similarity_fn(anchors, gt_boxes)\r\n # Map from anchor to gt box that has highest overlap\r\n anchor_to_gt_argmax = anchor_by_gt_overlap.argmax(axis=1)\r\n # For each anchor, amount of overlap with most overlapping gt box\r\n anchor_to_gt_max = anchor_by_gt_overlap[np.arange(num_inside),\r\n anchor_to_gt_argmax] #\r\n # Map from gt box to an anchor that has highest overlap\r\n gt_to_anchor_argmax = anchor_by_gt_overlap.argmax(axis=0)\r\n # For each gt box, amount of overlap with most overlapping anchor\r\n gt_to_anchor_max = anchor_by_gt_overlap[gt_to_anchor_argmax,\r\n np.arange(anchor_by_gt_overlap.\r\n shape[1])]\r\n # must remove gt which doesn't match any anchor.\r\n empty_gt_mask = gt_to_anchor_max == 0\r\n gt_to_anchor_max[empty_gt_mask] = -1\r\n \"\"\"\r\n if not np.all(empty_gt_mask):\r\n gt_to_anchor_max = gt_to_anchor_max[empty_gt_mask]\r\n anchor_by_gt_overlap = anchor_by_gt_overlap[:, empty_gt_mask]\r\n gt_classes = gt_classes[empty_gt_mask]\r\n gt_boxes = gt_boxes[empty_gt_mask]\r\n \"\"\"\r\n # Find all anchors that share the max overlap amount\r\n # (this includes many ties)\r\n anchors_with_max_overlap = np.where(\r\n anchor_by_gt_overlap == gt_to_anchor_max)[0]\r\n # Fg label: for each gt use anchors with highest overlap\r\n # (including ties)\r\n gt_inds_force = anchor_to_gt_argmax[anchors_with_max_overlap]\r\n labels[anchors_with_max_overlap] = gt_classes[gt_inds_force]\r\n gt_ids[anchors_with_max_overlap] = gt_inds_force\r\n # Fg label: above threshold IOU\r\n pos_inds = anchor_to_gt_max >= matched_threshold\r\n gt_inds = anchor_to_gt_argmax[pos_inds]\r\n labels[pos_inds] = gt_classes[gt_inds]\r\n gt_ids[pos_inds] = gt_inds\r\n bg_inds = np.where(anchor_to_gt_max < unmatched_threshold)[0]\r\n importance[pos_inds] = gt_importance[gt_inds]\r\n else:\r\n # labels[:] = 0\r\n bg_inds = np.arange(num_inside)\r\n fg_inds = np.where(labels > 0)[0]\r\n fg_max_overlap = None\r\n if len(gt_boxes) > 0:\r\n fg_max_overlap = anchor_to_gt_max[fg_inds]\r\n gt_pos_ids = gt_ids[fg_inds]\r\n # bg_inds = np.where(anchor_to_gt_max < unmatched_threshold)[0]\r\n # bg_inds = np.where(labels == 0)[0]\r\n # subsample positive labels if we have too many\r\n if positive_fraction is not None:\r\n num_fg = int(positive_fraction * rpn_batch_size)\r\n if len(fg_inds) > num_fg:\r\n disable_inds = npr.choice(\r\n fg_inds, size=(len(fg_inds) - num_fg), replace=False)\r\n labels[disable_inds] = -1\r\n fg_inds = np.where(labels > 0)[0]\r\n\r\n # subsample negative labels if we have too many\r\n # (samples with replacement, but since the set of bg inds is large most\r\n # samples will not have repeats)\r\n num_bg = rpn_batch_size - np.sum(labels > 0)\r\n # print(num_fg, num_bg, len(bg_inds) )\r\n if len(bg_inds) > num_bg:\r\n enable_inds = bg_inds[npr.randint(len(bg_inds), size=num_bg)]\r\n labels[enable_inds] = 0\r\n bg_inds = np.where(labels == 0)[0]\r\n else:\r\n if len(gt_boxes) == 0:\r\n labels[:] = 0\r\n else:\r\n labels[bg_inds] = 0\r\n # re-enable anchors_with_max_overlap\r\n labels[anchors_with_max_overlap] = gt_classes[gt_inds_force]\r\n bbox_targets = np.zeros((num_inside, box_code_size),\r\n dtype=all_anchors.dtype)\r\n if len(gt_boxes) > 0:\r\n # print(anchors[fg_inds, :].shape, gt_boxes[anchor_to_gt_argmax[fg_inds], :].shape)\r\n # bbox_targets[fg_inds, :] = box_encoding_fn(\r\n # anchors[fg_inds, :], gt_boxes[anchor_to_gt_argmax[fg_inds], :])\r\n bbox_targets[fg_inds, :] = box_encoding_fn(\r\n gt_boxes[anchor_to_gt_argmax[fg_inds], :], anchors[fg_inds, :])\r\n # Bbox regression loss has the form:\r\n # loss(x) = weight_outside * L(weight_inside * x)\r\n # Inside weights allow us to set zero loss on an element-wise basis\r\n # Bbox regression is only trained on positive examples so we set their\r\n # weights to 1.0 (or otherwise if config is different) and 0 otherwise\r\n # NOTE: we don't need bbox_inside_weights, remove it.\r\n # bbox_inside_weights = np.zeros((num_inside, box_ndim), dtype=np.float32)\r\n # bbox_inside_weights[labels == 1, :] = [1.0] * box_ndim\r\n\r\n # The bbox regression loss only averages by the number of images in the\r\n # mini-batch, whereas we need to average by the total number of example\r\n # anchors selected\r\n # Outside weights are used to scale each element-wise loss so the final\r\n # average over the mini-batch is correct\r\n # bbox_outside_weights = np.zeros((num_inside, box_ndim), dtype=np.float32)\r\n bbox_outside_weights = np.zeros((num_inside, ), dtype=all_anchors.dtype)\r\n # uniform weighting of examples (given non-uniform sampling)\r\n if norm_by_num_examples:\r\n num_examples = np.sum(labels >= 0) # neg + pos\r\n num_examples = np.maximum(1.0, num_examples)\r\n bbox_outside_weights[labels > 0] = 1.0 / num_examples\r\n else:\r\n bbox_outside_weights[labels > 0] = 1.0\r\n # bbox_outside_weights[labels == 0, :] = 1.0 / num_examples\r\n\r\n # Map up to original set of anchors\r\n if inds_inside is not None:\r\n labels = unmap(labels, total_anchors, inds_inside, fill=-1)\r\n bbox_targets = unmap(bbox_targets, total_anchors, inds_inside, fill=0)\r\n # bbox_inside_weights = unmap(\r\n # bbox_inside_weights, total_anchors, inds_inside, fill=0)\r\n bbox_outside_weights = unmap(\r\n bbox_outside_weights, total_anchors, inds_inside, fill=0)\r\n importance = unmap(importance, total_anchors, inds_inside, fill=0)\r\n # return labels, bbox_targets, bbox_outside_weights\r\n ret = {\r\n \"labels\": labels,\r\n \"bbox_targets\": bbox_targets,\r\n \"bbox_outside_weights\": bbox_outside_weights,\r\n \"assigned_anchors_overlap\": fg_max_overlap,\r\n \"positive_gt_id\": gt_pos_ids,\r\n \"importance\": importance,\r\n }\r\n if inds_inside is not None:\r\n ret[\"assigned_anchors_inds\"] = inds_inside[fg_inds]\r\n else:\r\n ret[\"assigned_anchors_inds\"] = fg_inds\r\n return ret\r\n", "meta": {"hexsha": "860dfaf5d597d0f5fbce1fc195f82693b34018c3", "size": 10568, "ext": "py", "lang": "Python", "max_stars_repo_path": "second/core/target_ops.py", "max_stars_repo_name": "jerry99s/second.pytorch", "max_stars_repo_head_hexsha": "80143908a349b9f3ff1642d21dacaf23455b3cf8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1541, "max_stars_repo_stars_event_min_datetime": "2018-10-04T00:32:01.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T17:54:59.000Z", "max_issues_repo_path": "second/core/target_ops.py", "max_issues_repo_name": "Karthik-Ragunath/second.pytorch", "max_issues_repo_head_hexsha": "414de8936a165d7cdba4a6eb15ce9603201d2e61", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 466, "max_issues_repo_issues_event_min_datetime": "2018-10-06T01:05:28.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T08:49:44.000Z", "max_forks_repo_path": "second/core/target_ops.py", "max_forks_repo_name": "Karthik-Ragunath/second.pytorch", "max_forks_repo_head_hexsha": "414de8936a165d7cdba4a6eb15ce9603201d2e61", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 537, "max_forks_repo_forks_event_min_datetime": "2018-10-04T07:36:13.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-27T10:12:02.000Z", "avg_line_length": 45.947826087, "max_line_length": 92, "alphanum_fraction": 0.6279333838, "include": true, "reason": "import numpy,import numba", "num_tokens": 2459, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.523420348936324, "lm_q2_score": 0.3738758227716966, "lm_q1q2_score": 0.1956942136140167}} {"text": "#!/usr/bin/env python\n# Copyright 2014-2019 The PySCF Developers. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n# Author: Qiming Sun \n#\n\n'''\nGeneralized Kohn-Sham\n'''\n\nimport time\nimport numpy\nimport scipy.linalg\nfrom pyscf import lib\nfrom pyscf.lib import logger\nfrom pyscf.scf import ghf\nfrom pyscf.dft import rks\n\n\ndef get_veff(ks, mol=None, dm=None, dm_last=0, vhf_last=0, hermi=1):\n '''Coulomb + XC functional for GKS.\n '''\n if mol is None: mol = self.mol\n if dm is None: dm = ks.make_rdm1()\n t0 = (time.clock(), time.time())\n\n ground_state = (isinstance(dm, numpy.ndarray) and dm.ndim == 2)\n\n assert(hermi == 1)\n dm = numpy.asarray(dm)\n nso = dm.shape[-1]\n nao = nso // 2\n dm_a = dm[...,:nao,:nao].real\n dm_b = dm[...,nao:,nao:].real\n\n if ks.grids.coords is None:\n ks.grids.build(with_non0tab=True)\n if ks.small_rho_cutoff > 1e-20 and ground_state:\n ks.grids = rks.prune_small_rho_grids_(ks, mol, dm_a+dm_b, ks.grids)\n t0 = logger.timer(ks, 'setting up grids', *t0)\n if ks.nlc != '':\n if ks.nlcgrids.coords is None:\n ks.nlcgrids.build(with_non0tab=True)\n if ks.small_rho_cutoff > 1e-20 and ground_state:\n ks.nlcgrids = rks.prune_small_rho_grids_(ks, mol, dm_a+dm_b, ks.nlcgrids)\n t0 = logger.timer(ks, 'setting up nlc grids', *t0)\n\n max_memory = ks.max_memory - lib.current_memory()[0]\n ni = ks._numint\n n, exc, vxc = ni.nr_uks(mol, ks.grids, ks.xc, (dm_a,dm_b), max_memory=max_memory)\n if ks.nlc != '':\n assert('VV10' in ks.nlc.upper())\n _, enlc, vnlc = ni.nr_rks(mol, ks.nlcgrids, ks.xc+'__'+ks.nlc, dm_a+dm_b,\n max_memory=max_memory)\n exc += enlc\n vxc += vnlc\n logger.debug(ks, 'nelec by numeric integration = %s', n)\n t0 = logger.timer(ks, 'vxc', *t0)\n if vxc.ndim == 4:\n raise NotImplementedError\n vxc = numpy.asarray(scipy.linalg.block_diag(*vxc), dtype=dm.dtype)\n\n #enabling range-separated hybrids\n omega, alpha, hyb = ni.rsh_and_hybrid_coeff(ks.xc, spin=mol.spin)\n\n if abs(hyb) < 1e-10 and abs(alpha) < 1e-10:\n vk = None\n if (ks._eri is None and ks.direct_scf and\n getattr(vhf_last, 'vj', None) is not None):\n ddm = numpy.asarray(dm) - numpy.asarray(dm_last)\n vj = ks.get_j(mol, ddm, hermi)\n vj += vhf_last.vj\n else:\n vj = ks.get_j(mol, dm, hermi)\n vxc += vj\n else:\n if (ks._eri is None and ks.direct_scf and\n getattr(vhf_last, 'vk', None) is not None):\n ddm = numpy.asarray(dm) - numpy.asarray(dm_last)\n vj, vk = ks.get_jk(mol, ddm, hermi)\n vk *= hyb\n if abs(omega) > 1e-10:\n vklr = _get_k_lr(mol, ddm, omega, hermi)\n vklr *= (alpha - hyb)\n vk += vklr\n vj += vhf_last.vj\n vk += vhf_last.vk\n else:\n vj, vk = ks.get_jk(mol, dm, hermi)\n vk *= hyb\n if abs(omega) > 1e-10:\n vklr = _get_k_lr(mol, dm, omega, hermi)\n vklr *= (alpha - hyb)\n vk += vklr\n vxc += vj - vk\n\n if ground_state:\n exc -= numpy.einsum('ij,ji', dm, vk).real * .5\n if ground_state:\n ecoul = numpy.einsum('ij,ji', dm, vj).real * .5\n else:\n ecoul = None\n\n vxc = lib.tag_array(vxc, ecoul=ecoul, exc=exc, vj=vj, vk=vk)\n return vxc\n\ndef _get_k_lr(mol, dm, omega=0, hermi=0):\n nso = dm.shape[-1]\n nao = nso // 2\n dms = dm.reshape(-1,nso,nso)\n n_dm = dms.shape[0]\n\n dmaa = dms[:,:nao,:nao]\n dmab = dms[:,nao:,:nao]\n dmbb = dms[:,nao:,nao:]\n dms = numpy.vstack((dmaa, dmbb, dmab))\n if dm.dtype == numpy.complex128:\n dms = numpy.vstack((dms.real, dms.imag))\n hermi = 0\n\n k1 = rks._get_k_lr(mol, dms, omega, hermi)\n k1 = k1.reshape(-1,n_dm,nao,nao)\n\n if dm.dtype == numpy.complex128:\n k1 = k1[:3] + k1[3:] * 1j\n\n vk = numpy.zeros((n_dm,nso,nso), dm.dtype)\n vk[:,:nao,:nao] = k1[0]\n vk[:,nao:,nao:] = k1[1]\n vk[:,:nao,nao:] = k1[2]\n vk[:,nao:,:nao] = k1[2].transpose(0,2,1).conj()\n vk = vk.reshape(dm.shape)\n return vk\n\n\nclass GKS(ghf.GHF):\n '''Generalized Kohn-Sham'''\n def __init__(self, mol):\n ghf.GHF.__init__(self, mol)\n rks._dft_common_init_(self)\n\n def dump_flags(self, verbose=None):\n ghf.GHF.dump_flags(self, verbose)\n logger.info(self, 'XC functionals = %s', self.xc)\n if self.nlc!='':\n logger.info(self, 'NLC functional = %s', self.nlc)\n logger.info(self, 'small_rho_cutoff = %g', self.small_rho_cutoff)\n self.grids.dump_flags(verbose)\n\n get_veff = get_veff\n energy_elec = rks.energy_elec\n define_xc_ = rks.define_xc_\n\n def nuc_grad_method(self):\n raise NotImplementedError\n\n\nif __name__ == '__main__':\n from pyscf import gto\n mol = gto.Mole()\n mol.verbose = 3\n mol.atom = 'H 0 0 0; H 0 0 1; O .5 .6 .2'\n mol.basis = 'ccpvdz'\n mol.build()\n\n mf = GKS(mol)\n mf.xc = 'b3lyp'\n mf.kernel()\n\n dm = mf.init_guess_by_1e(mol)\n dm = dm + 0j\n nao = mol.nao_nr()\n numpy.random.seed(12)\n dm[:nao,nao:] = numpy.random.random((nao,nao)) * .1j\n dm[nao:,:nao] = dm[:nao,nao:].T.conj()\n mf.kernel(dm)\n mf.canonicalize(mf.mo_coeff, mf.mo_occ)\n mf.analyze()\n print(mf.spin_square())\n print(mf.e_tot - -76.2760115704274)\n", "meta": {"hexsha": "37ee094862f5c7f631532e38cf1f43f07cdbf64b", "size": 6031, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyscf/dft/gks.py", "max_stars_repo_name": "crisely09/pyscf", "max_stars_repo_head_hexsha": "cb92f7974bd9c87c0ef5b2b52abf5d3219b3d6b6", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-04-07T21:12:08.000Z", "max_stars_repo_stars_event_max_datetime": "2020-04-07T21:12:08.000Z", "max_issues_repo_path": "pyscf/dft/gks.py", "max_issues_repo_name": "crisely09/pyscf", "max_issues_repo_head_hexsha": "cb92f7974bd9c87c0ef5b2b52abf5d3219b3d6b6", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2019-09-16T17:58:31.000Z", "max_issues_repo_issues_event_max_datetime": "2019-09-22T17:26:01.000Z", "max_forks_repo_path": "pyscf/dft/gks.py", "max_forks_repo_name": "crisely09/pyscf", "max_forks_repo_head_hexsha": "cb92f7974bd9c87c0ef5b2b52abf5d3219b3d6b6", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.2487046632, "max_line_length": 89, "alphanum_fraction": 0.5848118057, "include": true, "reason": "import numpy,import scipy", "num_tokens": 1966, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6297746074044134, "lm_q2_score": 0.31069437683198775, "lm_q1q2_score": 0.19566742919212396}} {"text": "#!/usr/bin/env python\n# ------------------------------------------------------------------------------------------------------%\n# Created by \"Thieu Nguyen\" at 14:14, 20/09/2020 %\n#\n# Email: nguyenthieu2102@gmail.com %\n# Homepage: https://www.researchgate.net/profile/Thieu_Nguyen6 %\n# Github: https://github.com/thieu1995 %\n#-------------------------------------------------------------------------------------------------------%\n\nfrom numpy import ones, zeros, concatenate\n\nD = [9, 11, 7, 6, 9, 38, 48, 2, 3, 3, 7, 7, 5, 10, 7, 14, 3, 4, 4, 2, 5, 9, 5, 7, 4, 22, 10, 10, 4, 3, 4, 5,\n 30, 118, 153, 158, 126, 126, 126, 76, 74, 86, 86, 30, 25, 25, 25, 30, 30, 30, 59, 59, 59, 59, 64, 64, 64]\ngn = [0, 0, 14, 1, 2, 0, 0, 2, 1, 3, 4, 9, 3, 10, 11, 15, 4, 4, 5, 3, 8, 10, 8, 7, 7, 86, 3, 9, 1, 8, 1, 6, 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 105, 24, 24, 24,\n 29, 29, 29, 14, 14, 14, 14, 0, 0, 0]\nhn = [8, 9, 0, 4, 4, 32, 38, 0, 1, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 108, 148, 148, 116, 116, 116, 76, 74, 76, 76, 0, 1,\n 1, 1, 1, 1, 1, 1, 1, 1, 1, 6, 6, 6]\n\n# bound constraint definitions for all 53 test functions\nxmin1 = [0, 0, 0, 0, 1000, 0, 100, 100, 100]\nxmax1 = [10, 200, 100, 200, 2000000, 600, 600, 600, 900]\nxmin2 = [10 ** 4, 10 ** 4, 10 ** 4, 0, 0, 0, 100, 100, 100, 100, 100]\nxmax2 = [0.819 * 10 ** 6, 1.131 * 10 ** 6, 2.05 * 10 ** 6, 0.05074, 0.05074, 0.05074, 200, 300, 300, 300, 400]\nxmin3 = [1000, 0, 2000, 0, 0, 0, 0]\nxmax3 = [2000, 100, 4000, 100, 100, 20, 200]\nxmin4 = [0, 0, 0, 0, 1e-5, 1e-5]\nxmax4 = [1, 1, 1, 1, 16, 16]\nxmin5 = zeros(D[4])\nxmax5 = [100, 200, 100, 100, 100, 100, 200, 100, 200]\nxmin6 = zeros(D[5])\nxmax6 = [90, 150, 90, 150, 90, 90, 150, 90, 90, 90, 150, 150, 90, 90, 150, 90, 150, 90, 150, 90, 1, 1.2,\n 1, 1, 1, 0.5, 1, 1, 0.5, 0.5, 0.5, 1.2, 0.5, 1.2, 1.2, 0.5, 1.2, 1.2]\nxmin7 = zeros(D[6])\nxmin7[23] = xmin7[25] = xmin7[27] = xmin7[30] = 0.849999\nxmax7 = ones(D[6])\nxmax7[3] = 140\nxmax7[24] = xmax7[26] = xmax7[31] = xmax7[34] = xmax7[36] = xmax7[28] = 30\nxmax7[1] = xmax7[2] = xmax7[4] = xmax7[12:15] = 90\nxmax7[0] = xmax7[5:12] = xmax7[15:20] = 35\nxmin8 = [0, -0.51]\nxmax8 = [1.6, 1.49]\nxmin9 = [0.5, 0.5, -0.51]\nxmax9 = [1.4, 1.4, 1.49]\nxmin10 = [0.2, -2.22554, -0.51]\nxmax10 = [1, -1, 1.49]\nxmin11 = [0, 0, 0, 0, -0.51, -0.51, 0]\nxmax11 = [20, 20, 10, 10, 1.49, 1.49, 40]\nxmin12 = [0, 0, 0, -0.51, -0.51, -0.51, -0.51]\nxmax12 = [100, 100, 100, 1.49, 1.49, 1.49, 1.49]\nxmin13 = [27, 27, 27, 77.51, 32.51]\nxmax13 = [45, 45, 45, 102.49, 45.49]\nxmin14 = [0.51, 0.51, 0.51, 250, 250, 250, 6, 4, 40, 10]\nxmax14 = [3.49, 3.49, 3.49, 2500, 2500, 2500, 20, 16, 700, 450]\nxmin15 = [2.6, 0.7, 17, 7.3, 7.3, 2.9, 5]\nxmax15 = [3.6, 0.8, 28, 8.3, 8.3, 3.9, 5.5]\nxmin16 = 0.001 * ones(D[15])\nxmax16 = +5 * ones(D[15])\nxmin17 = [0.05, 0.25, 2.00]\nxmax17 = [2, 1.3, 15.0]\nxmin18 = [0.51, 0.51, 10, 10]\nxmax18 = [99.49, 99.49, 200, 200]\nxmin19 = [0.125, 0.1, 0.1, 0.1]\nxmax19 = [2, 10, 10, 2]\nxmin20 = zeros(D[19])\nxmax20 = 1 * ones(D[19])\nxmin21 = [60, 90, 1, 0, 2]\nxmax21 = [80, 110, 3, 1000, 9]\nxmin22 = [16.51, 13.51, 13.51, 16.51, 13.51, 47.51, 0.51, 0.51, 0.51]\nxmax22 = [96.49, 54.49, 51.49, 46.49, 51.49, 124.49, 3.49, 6.49, 6.49]\nxmin23 = [0, 0, 0, 0, 0]\nxmax23 = [60, 60, 90, 90, 90]\nxmin24 = [10, 10, 100, 0, 10, 100, 1]\nxmax24 = [150, 150, 200, 50, 150, 300, 3.14]\nxmin25 = [1, 1, 1e-6, 1]\nxmax25 = [16, 16, 16 * 1e-6, 16]\nxmin26 = concatenate((6.51 * ones(8), 0.51 * ones(14)), axis=0)\nxmax26 = concatenate((76.49 * ones(8), 4.49 * ones(4), 9.49 * ones(10)), axis=0)\nxmin27 = 0.645e-4 * ones(D[26])\nxmax27 = 50e-4 * ones(D[26])\nxmin28 = [125, 10.5, 4.51, 0.515, 0.515, 0.4, 0.6, 0.3, 0.02, 0.6]\nxmax28 = [150, 31.5, 50.49, 0.6, 0.6, 0.5, 0.7, 0.4, 0.1, 0.85]\nxmin29 = [20, 1, 20, 0.1]\nxmax29 = [50, 10, 50, 60]\nxmin30 = [0.51, 0.6, 0.51]\nxmax30 = [70.49, 3, 42.49]\nxmin31 = 12. * ones(4)\nxmax31 = 60. * ones(4)\nxmin32 = [78, 33, 27, 27, 27]\nxmax32 = [102, 45, 45, 45, 45]\nxmin33 = 0.001 * ones(D[32])\nxmax33 = ones(D[32])\nxmin34 = -1 * ones(D[33])\nxmax34 = +1 * ones(D[33])\nxmin35 = -1 * ones(D[34])\nxmax35 = +1 * ones(D[34])\nxmin36 = -1 * ones(D[35])\nxmax36 = +1 * ones(D[35])\nxmin37 = -1 * ones(D[36])\nxmin37[117: 126] = 0\nxmax37 = +1 * ones(D[36])\nxmin38 = -1 * ones(D[37])\nxmin38[117: 126] = 0\nxmax38 = +1 * ones(D[37])\nxmin39 = -1 * ones(D[38])\nxmin39[117: 126] = 0\nxmax39 = +1 * ones(D[38])\nxmin40 = -1 * ones(D[39])\nxmin40[75: 76] = 0\nxmax40 = +1 * ones(D[39])\nxmax40[75: 76] = 2\nxmin41 = -1 * ones(D[40])\nxmax41 = +1 * ones(D[40])\nxmin42 = -1 * ones(D[41])\nxmin42[75: 76] = 0\nxmin42[77: 86] = 0\nxmax42 = +1 * ones(D[41])\nxmax42[75: 76] = 2\nxmax42[77: 86] = 500\nxmin43 = -1 * ones(D[42])\nxmin43[75: 76] = 0\nxmin43[77: 86] = 0\nxmax43 = +1 * ones(D[42])\nxmax43[75: 76] = 2\nxmax43[77: 86] = 500\nxmin44 = 40 * ones(D[43])\nxmax44 = 1960 * ones(D[43])\nxmin45 = zeros(D[44])\nxmax45 = +90 * ones(D[44])\nxmin46 = zeros(D[45])\nxmax46 = +90 * ones(D[45])\nxmin47 = zeros(D[46])\nxmax47 = +90 * ones(D[46])\nxmin48 = zeros(D[47])\nxmax48 = +90 * ones(D[47])\nxmin49 = zeros(D[48])\nxmax49 = +90 * ones(D[48])\nxmin50 = zeros(D[49])\nxmax50 = +90 * ones(D[49])\nxmin51 = zeros(D[50])\nxmax51 = 10. * ones(D[50])\nxmin52 = zeros(D[51])\nxmax52 = 10. * ones(D[51])\nxmin53 = zeros(D[52])\nxmax53 = 10. * ones(D[52])\nxmin54 = zeros(D[53])\nxmax54 = 10. * ones(D[53])\nxmin55 = zeros(D[54])\nxmax55 = 10. * ones(D[54])\nxmin56 = zeros(D[55])\nxmax56 = 10. * ones(D[55])\nxmin57 = zeros(D[56])\nxmax57 = 10. * ones(D[56])\n\ndef benchmark_function(idx):\n # % prob_k -> Index of problem.\n # % D[idx -> Dimension of the problem.\n # % par.g -> Number of inequility constraints.\n # % par.h -> Number of equality constraints.\n # % par.xmin -> lower bound of decision variables.\n # % par.xmax -> upper bound of decision variables.\n xmin = globals()['xmin' + str(idx)]\n xmax = globals()['xmax' + str(idx)]\n return {\"D\": D[idx-1], \"g\": gn[idx-1], \"h\": hn[idx-1], \"xmin\": xmin, \"xmax\": xmax}", "meta": {"hexsha": "5b67a454bb8a69e058af26033a8092040962c0bc", "size": 6191, "ext": "py", "lang": "Python", "max_stars_repo_path": "opfunu/cec/cec2020/constant.py", "max_stars_repo_name": "ElliottP-13/opfunu", "max_stars_repo_head_hexsha": "7f4de3c34a91bb37fd8784fd28dbcf550e06d8a7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 28, "max_stars_repo_stars_event_min_datetime": "2020-09-12T09:19:49.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-25T07:25:01.000Z", "max_issues_repo_path": "opfunu/cec/cec2020/constant.py", "max_issues_repo_name": "ElliottP-13/opfunu", "max_issues_repo_head_hexsha": "7f4de3c34a91bb37fd8784fd28dbcf550e06d8a7", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2020-05-22T10:16:02.000Z", "max_issues_repo_issues_event_max_datetime": "2020-08-06T15:46:39.000Z", "max_forks_repo_path": "opfunu/cec/cec2020/constant.py", "max_forks_repo_name": "ElliottP-13/opfunu", "max_forks_repo_head_hexsha": "7f4de3c34a91bb37fd8784fd28dbcf550e06d8a7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 11, "max_forks_repo_forks_event_min_datetime": "2020-02-16T05:00:49.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-21T19:40:18.000Z", "avg_line_length": 37.981595092, "max_line_length": 158, "alphanum_fraction": 0.5081570021, "include": true, "reason": "from numpy", "num_tokens": 3192, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5389832354982647, "lm_q2_score": 0.36296921241058616, "lm_q1q2_score": 0.1956343204913146}} {"text": "import os\n# os.environ[\"CUDA_DEVICE_ORDER\"]=\"PCI_BUS_ID\" # see issue #152\n# os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"2\"\n\nimport torch as T\nfrom torch.autograd import Variable\nimport numpy as np\nimport pdb\nimport copy\nimport time\n\ncuda = True\nif cuda:\n floatX = T.cuda.FloatTensor\n intX = T.cuda.IntTensor\n byteX = T.cuda.ByteTensor\n longX = T.cuda.LongTensor\nelse:\n floatX = T.FloatTensor\n intX = T.IntTensor\n byteX = T.ByteTensor\n longX = T.LongTensor\n\n\ndef m_eye(n, k=0):\n assert k < n and k >= 0\n if k == 0:\n return T.eye(n).type(floatX)\n else:\n return T.cat((T.cat((T.zeros(n-k, k), T.eye(n-k)), dim=1), T.zeros(k, n)), dim=0).type(floatX)\n\ndef ctc_loss(pred, pred_len, token, token_len, blank=0):\n '''\n :param pred: (Time, batch, voca_size+1)\n :param pred_len: (batch)\n :param token: (batch, U)\n :param token_len: (batch)\n '''\n Time, batch = pred.size(0), pred.size(1)\n U = token.size(1)\n eps = 0\n\n # token_with_blank\n token_with_blank = T.cat((T.zeros(batch, U, 1).type(longX), token[:, :, None]), dim=2).view(batch, -1) # (batch, 2U)\n token_with_blank = T.cat((token_with_blank, T.zeros(batch, 1).type(longX)), dim=1) # (batch, 2U+1)\n length = token_with_blank.size(1)\n\n pred = pred[T.arange(0, Time).type(longX)[:, None, None], T.arange(0, batch).type(longX)[None, :, None], token_with_blank[None, :]] # (T, batch, 2U+1)\n\n # recurrence relation\n sec_diag = T.cat((T.zeros((batch, 2)).type(floatX), T.ne(token_with_blank[:, :-2], token_with_blank[:, 2:]).type(floatX)), dim=1) * T.ne(token_with_blank, blank).type(floatX)\t# (batch, 2U+1)\n recurrence_relation = (m_eye(length) + m_eye(length, k=1)).repeat(batch, 1, 1) + m_eye(length, k=2).repeat(batch, 1, 1) * sec_diag[:, None, :]\t# (batch, 2U+1, 2U+1)\n\n # alpha\n alpha_t = T.cat((pred[0, :, :2], T.zeros(batch, 2*U-1).type(floatX)), dim=1) # (batch, 2U+1)\n probability = alpha_t[None] # (1, batch, 2U+1)\n\n # dynamic programming\n # (T, batch, 2U+1)\n for t in T.arange(1, Time).type(longX):\n alpha_t = T.bmm(alpha_t[:, None], recurrence_relation)[:, 0] * pred[t]\n probability = T.cat((probability, alpha_t[None]), dim=0)\n\n labels_2 = probability[pred_len-1, T.arange(batch).type(longX), 2*token_len-1]\n labels_1 = probability[pred_len-1, T.arange(batch).type(longX), 2*token_len]\n labels_prob = labels_2 + labels_1\n\n cost = -T.log(labels_prob+eps)\n return cost\n\ndef log_batch_dot(alpha_t, rec):\n '''\n alpha_t: (batch, 2U+1)\n rec: (batch, 2U+1, 2U+1)\n '''\n eps_nan = -1e8\n # a+b\n _sum = alpha_t[:, :, None] + rec\n _max_sum = T.max(_sum, dim=1)[0]\n nz_mask1 = T.gt(_max_sum, eps_nan) # max > eps_nan\n nz_mask2 = T.gt(_sum, eps_nan) # item > eps_nan\n\n # a+b-max\n _sum = _sum - _max_sum[:, None]\n\n # exp\n _exp = T.zeros_like(_sum).type(floatX)\n _exp[nz_mask2] = T.exp(_sum[nz_mask2])\n\n # sum exp\n _sum_exp = T.sum(_exp, dim=1)\n\n out = T.ones_like(_max_sum).type(floatX) * eps_nan\n out[nz_mask1] = T.log(_sum_exp[nz_mask1]) + _max_sum[nz_mask1]\n return out\n\ndef log_sum_exp_axis(a, uniform_mask=None, dim=0):\n assert dim == 0\n eps_nan = -1e8\n eps = 1e-26\n _max = T.max(a, dim=dim)[0]\n\n if not uniform_mask is None:\n nz_mask2 = T.gt(a, eps_nan) * uniform_mask\n nz_mask1 = T.gt(_max, eps_nan) * T.ge(T.max(uniform_mask, dim=dim)[0], 1)\n else:\n nz_mask2 = T.gt(a, eps_nan)\n nz_mask1 = T.gt(_max, eps_nan)\n\n # a-max\n a = a - _max[None]\n\n # exp\n _exp_a = T.zeros_like(a).type(floatX)\n _exp_a[nz_mask2] = T.exp(a[nz_mask2])\n\n # sum exp\n _sum_exp_a = T.sum(_exp_a, dim=dim)\n\n out = T.ones_like(_max).type(floatX) * eps_nan\n out[nz_mask1] = T.log(_sum_exp_a[nz_mask1] + eps) + _max[nz_mask1]\n return out\n\ndef log_sum_exp(*arrs):\n# return T.max(a.clone(), b.clone()) + T.log1p(T.exp(-T.abs(a.clone()-b.clone())))\n c = T.cat(list(map(lambda x:x[None], arrs)), dim=0)\n return log_sum_exp_axis(c, dim=0)\n\ndef ctc_loss_log(pred, pred_len, token, token_len, blank=0):\n '''\n :param pred: (Time, batch, voca_size+1)\n :param pred_len: (batch)\n :param token: (batch, U)\n :param token_len: (batch)\n '''\n Time, batch = pred.size(0), pred.size(1)\n U = token.size(1)\n eps_nan = -1e8\n\n # token_with_blank\n token_with_blank = T.cat((T.zeros(batch, U, 1).type(longX), token[:, :, None]), dim=2).view(batch, -1) # (batch, 2U)\n token_with_blank = T.cat((token_with_blank, T.zeros(batch, 1).type(longX)), dim=1) # (batch, 2U+1)\n length = token_with_blank.size(1)\n\n pred = pred[T.arange(0, Time).type(longX)[:, None, None], T.arange(0, batch).type(longX)[None, :, None], token_with_blank[None, :]] # (T, batch, 2U+1)\n\n # recurrence relation\n sec_diag = T.cat((T.zeros((batch, 2)).type(floatX), T.ne(token_with_blank[:, :-2], token_with_blank[:, 2:]).type(floatX)), dim=1) * T.ne(token_with_blank, blank).type(floatX)\t# (batch, 2U+1)\n recurrence_relation = (m_eye(length) + m_eye(length, k=1)).repeat(batch, 1, 1) + m_eye(length, k=2).repeat(batch, 1, 1) * sec_diag[:, None, :]\t# (batch, 2U+1, 2U+1)\n recurrence_relation = eps_nan * (T.ones_like(recurrence_relation) - recurrence_relation)\n\n # alpha\n alpha_t = T.cat((pred[0, :, :2], T.ones(batch, 2*U-1).type(floatX)*eps_nan), dim=1) # (batch, 2U+1)\n probability = alpha_t[None] # (1, batch, 2U+1)\n\n # dynamic programming\n # (T, batch, 2U+1)\n for t in T.arange(1, Time).type(longX):\n alpha_t = log_batch_dot(alpha_t, recurrence_relation) + pred[t]\n probability = T.cat((probability, alpha_t[None]), dim=0)\n\n labels_2 = probability[pred_len-1, T.arange(batch).type(longX), 2*token_len-1]\n labels_1 = probability[pred_len-1, T.arange(batch).type(longX), 2*token_len]\n labels_prob = log_sum_exp(labels_2, labels_1)\n# pdb.set_trace()\n\n cost = -labels_prob\n return cost\n\ndef ctc_cost(out, targets, sizes, target_sizes):\n# A batched version for uni_alpha_cost\n# param out: (Time, batch, voca_size+1)\n# param targets: targets without splited\n# param sizes: size for out (N)\n# param target_sizes: size for targets (N)\n\n Time = out.size(0)\n pred = T.nn.functional.log_softmax(out, dim=-1)\n\n offset = 0\n batch = target_sizes.size(0)\n target_max = target_sizes.max().item()\n target = T.zeros(batch, target_max).type(longX)\n\n for index, (target_size, size) in enumerate(zip(target_sizes, sizes)):\n target[index, :target_size.item()] = targets[offset: offset+target_size.item()].data\n offset += target_size.item()\n\n if not cuda:\n costs = ctc_loss_log(pred.cpu(), sizes.data.type(longX), target, target_sizes.data.type(longX))\n else:\n costs = ctc_loss_log(pred, sizes.data.type(longX), target, target_sizes.data.type(longX))\n return costs.sum()\n\ndef test_seg_ctc(use_mine=True):\n # (T, voca_size+1)\n pred_np = np.array([[0.5, 0.4, 0.1], [0.3, 0.1, 0.6], [0.7, 0.2, 0.1], [0.3, 0.5, 0.2]])[:, None]\n pred_np = np.log(np.tile(pred_np, (1,2,1)))\n # (U)\n token_np = np.array([2, 2, 1, 2])\n\n pred = Variable(floatX(pred_np), requires_grad=True)\n token = Variable(T.IntTensor(token_np))\n sizes = Variable(T.IntTensor(np.array([4, 4])))\n target_sizes = Variable(T.IntTensor(np.array([2, 2])))\n\n for i in range(40):\n if use_mine:\n cost = ctc_cost(pred, token, sizes, target_sizes)\n print(cost.data.item())\n else:\n from warpctc_pytorch import CTCLoss\n criterion = CTCLoss().cuda()\n cost = criterion(pred, token, sizes, target_sizes)\n print(cost.data.item())\n\n optimizer = T.optim.SGD([pred], lr=3e-2, momentum=0.9, nesterov=True)\n optimizer.zero_grad()\n cost.backward()\n optimizer.step()\n\nif __name__ == '__main__':\n print('_________')\n test_seg_ctc(use_mine=True)", "meta": {"hexsha": "bc215eab71149d4dead33e1308c7150872c21674", "size": 7937, "ext": "py", "lang": "Python", "max_stars_repo_path": "Recognition/pytorch_enctc/m_ctc.py", "max_stars_repo_name": "MengLcool/Ac-OCR", "max_stars_repo_head_hexsha": "370152cc33995f41ee79374b3f5d62e94fea09d3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-07-11T10:24:58.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-11T10:24:58.000Z", "max_issues_repo_path": "Recognition/pytorch_enctc/m_ctc.py", "max_issues_repo_name": "MengLcool/Oc-OCR", "max_issues_repo_head_hexsha": "370152cc33995f41ee79374b3f5d62e94fea09d3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Recognition/pytorch_enctc/m_ctc.py", "max_forks_repo_name": "MengLcool/Oc-OCR", "max_forks_repo_head_hexsha": "370152cc33995f41ee79374b3f5d62e94fea09d3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.4330357143, "max_line_length": 194, "alphanum_fraction": 0.6221494267, "include": true, "reason": "import numpy", "num_tokens": 2614, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5389832206876841, "lm_q2_score": 0.3629692124105862, "lm_q1q2_score": 0.1956343151155299}} {"text": "\"\"\"\nFile: pylinex/nonlinear/loglikelihood/Loglikelihood.py\nAuthor: Keith Tauscher\nDate: 25 Feb 2018\n\nDescription: File containing a base class representing a likelihood that can be\n evaluated using a data vector and a Model object (and possibly\n other things, depending on the subclass).\n\"\"\"\nimport numpy as np\nimport numpy.linalg as la\nfrom distpy import TransformList, GaussianDistribution, WindowedDistribution,\\\n DistributionSet\nfrom ..util import Savable, Loadable\n\ncannot_instantiate_loglikelihood_error = NotImplementedError(\"The \" +\\\n \"Loglikelihood class cannot be instantiated directly!\")\n\nclass Loglikelihood(Savable, Loadable):\n \"\"\"\n Abstract class representing a likelihood which is Gaussian in the data.\n \"\"\"\n def __init__(self, *args, **kwargs):\n \"\"\"\n Initializer throws error because Loglikelihood is supposed to be an\n abstract class that is not directly instantiated.\n \"\"\"\n raise cannot_instantiate_loglikelihood_error\n \n @property\n def parameters(self):\n \"\"\"\n Property storing the names of the parameters of the model defined by\n this likelihood.\n \"\"\"\n raise cannot_instantiate_loglikelihood_error\n \n @property\n def num_parameters(self):\n \"\"\"\n Property storing the number of parameters needed by the Model at the\n heart of this Loglikelihood.\n \"\"\"\n if not hasattr(self, '_num_parameters'):\n self._num_parameters = len(self.parameters)\n return self._num_parameters\n \n def fill_hdf5_group(self, group, *args, **kwargs):\n \"\"\"\n Fills the given hdf5 group with information about this Loglikelihood.\n \n group: the group to fill with information about this Loglikelihood\n \"\"\"\n raise cannot_instantiate_loglikelihood_error\n \n @staticmethod\n def load_from_hdf5_group(group):\n \"\"\"\n Loads a Loglikelihood object from an hdf5 file group in which it was\n previously saved.\n \n group: the hdf5 file group from which to load a Loglikelihood object\n \n returns: the Loglikelihood object loaded from the given hdf5 file group\n \"\"\"\n raise cannot_instantiate_loglikelihood_error\n \n def check_parameter_dimension(self, pars):\n \"\"\"\n Checks to ensure that the given array is 1D and has one element for\n each parameter. The only thing this function does is throw an error if\n the array is the wrong shape.\n \n pars: array to check\n \"\"\"\n if pars.shape != (self.num_parameters,):\n raise ValueError(\"The array of parameters given to this \" +\\\n \"Loglikelihood object was not of the correct size.\")\n \n def __call__(self, pars, return_negative=False):\n \"\"\"\n Gets the value of this Loglikelihood at the given parameters.\n \"\"\"\n raise cannot_instantiate_loglikelihood_error\n \n @property\n def gradient_computable(self):\n \"\"\"\n Property storing whether the gradient of this Loglikelihood can be\n computed.\n \"\"\"\n raise cannot_instantiate_loglikelihood_error\n \n def gradient(self, pars, return_negative=False):\n \"\"\"\n Computes the gradient of this Loglikelihood for minimization purposes.\n \n pars: value of the parameters at which to evaluate the gradient\n return_negative: if true, the negative of the gradient of the\n loglikelihood is returned (this is useful for times\n when the loglikelihood must be maximized since scipy\n optimization functions only deal with minimization\n \n returns: 1D numpy.ndarray of length num_parameters containing gradient\n of loglikelihood value\n \"\"\"\n if self.gradient_computable:\n return self.auto_gradient(pars, return_negative=return_negative)\n else:\n raise NotImplementedError(\"gradient is not computable in an \" +\\\n \"exact form. Use auto_gradient instead to do a numerical \" +\\\n \"approximation.\")\n \n def auto_gradient(self, pars, return_negative=False, differences=1e-6,\\\n transform_list=None):\n \"\"\"\n Computes the gradient of this Loglikelihood for minimization purposes.\n \n pars: value of the parameters at which to evaluate the gradient\n return_negative: if true, the negative of the gradient of the\n loglikelihood is returned (this is useful for times\n when the loglikelihood must be maximized since scipy\n optimization functions only deal with minimization\n differences: either single number or 1D array of numbers to use as the\n numerical difference in parameter. Default: 10^(-6)\n transform_list: TransformList object (or something which can be cast to\n one) defining the transforms to apply to the parameters\n before computing the gradient. Default: None, parameter\n space is not transformed\n \n returns: 1D numpy.ndarray of length num_parameters containing gradient\n of loglikelihood value\n \"\"\"\n raise cannot_instantiate_loglikelihood_error\n \n @property\n def hessian_computable(self):\n \"\"\"\n Property storing whether the hessian of this Loglikelihood can be\n computed. The hessian of this Loglikelihood is computable as long as\n the model's gradient and hessian are computable.\n \"\"\"\n raise cannot_instantiate_loglikelihood_error\n \n def hessian(self, pars, return_negative=False):\n \"\"\"\n Computes the hessian of this Loglikelihood for minimization purposes.\n \n pars: value of the parameters at which to evaluate the hessian\n return_negative: if true, the negative of the hessian of the\n loglikelihood is returned (this is useful for times\n when the loglikelihood must be maximized since scipy\n optimization functions only deal with minimization\n \n returns: square 2D numpy.ndarray of side length num_parameters\n containing hessian of loglikelihood value\n \"\"\"\n if self.hessian_computable:\n return self.auto_hessian(pars, return_negative=return_negative)\n else:\n raise NotImplementedError(\"hessian is not computable in an \" +\\\n \"exact form. Use auto_hessian instead to do a numerical \" +\\\n \"approximation.\")\n \n def auto_hessian(self, pars, return_negative=False,\\\n larger_differences=1e-5, smaller_differences=1e-6,\\\n transform_list=None):\n \"\"\"\n Computes the hessian of this Loglikelihood for minimization purposes.\n \n pars: value of the parameters at which to evaluate the hessian\n return_negative: if true, the negative of the hessian of the\n loglikelihood is returned (this is useful for times\n when the loglikelihood must be maximized since scipy\n optimization functions only deal with minimization\n larger_differences: either single number or 1D array of numbers to use\n as the numerical difference in parameters.\n Default: 10^(-5). This is the amount by which the\n parameters are shifted between evaluations of the\n gradient. Only used if gradient is not explicitly\n computable.\n smaller_differences: either single_number or 1D array of numbers to use\n as the numerical difference in parameters.\n Default: 10^(-6). This is the amount by which the\n parameters are shifted during each approximation\n of the gradient. Only used if hessian is not\n explicitly computable\n transform_list: TransformList object (or something which can be cast to\n one) defining the transforms to apply to the parameters\n before computing the gradient. Default: None, parameter\n space is not transformed\n \n returns: square 2D numpy.ndarray of side length num_parameters\n containing hessian of loglikelihood value\n \"\"\"\n raise cannot_instantiate_loglikelihood_error\n \n def __eq__(self, other):\n \"\"\"\n Checks if self is equal to other.\n \n other: a Loglikelihood object to check for equality\n \n returns: True if other and self have the same properties\n \"\"\"\n raise NotImplementedError(\"The __eq__ magic method must be defined \" +\\\n \"by each subclass of Loglikelihood individually. The class \" +\\\n \"being used does not have the method defined.\")\n \n def __ne__(self, other):\n \"\"\"\n Checks if self is equal to other.\n \n other: a Loglikelihood object to check for equality\n \n returns: True if other and self do not have the same properties\n \"\"\"\n return (not self.__eq__(other))\n \n def fisher_information(self, maximum_likelihood_parameters,\\\n larger_differences=1e-5, smaller_differences=1e-6,\\\n transform_list=None):\n \"\"\"\n Calculates the Fisher information matrix of this likelihood assuming\n that the argument associated with the maximum of this likelihood is\n reasonably approximated by the given parameters.\n \n maximum_likelihood_parameters: the maximum likelihood parameter vector\n (or some approximation of it)\n larger_differences: either single number or 1D array of numbers to use\n as the numerical difference in parameters.\n Default: 10^(-5). This is the amount by which the\n parameters are shifted between evaluations of the\n gradient. Only used if gradient is not explicitly\n computable.\n smaller_differences: either single_number or 1D array of numbers to use\n as the numerical difference in parameters.\n Default: 10^(-6). This is the amount by which the\n parameters are shifted during each approximation\n of the gradient. Only used if hessian is not\n explicitly computable\n transform_list: TransformList object (or something which can be cast to\n one) defining the transforms to apply to the parameters\n before computing the gradient. Default: None, parameter\n space is not transformed. No matter what,\n maximum_likelihood_parameters should be the parameters\n that maximize the likelihood when plugged into the\n model of this likelihood untransformed.\n \n returns: numpy.ndarray of shape (num_parameters, num_parameters)\n containing the Fisher information matrix\n \"\"\"\n return self.auto_hessian(maximum_likelihood_parameters,\\\n larger_differences=larger_differences,\\\n smaller_differences=smaller_differences,\\\n transform_list=transform_list, return_negative=True)\n \n def parameter_covariance_fisher_formalism(self,\\\n maximum_likelihood_parameters, transform_list=None,\\\n max_standard_deviations=np.inf, larger_differences=1e-5,\\\n smaller_differences=1e-6):\n \"\"\"\n Finds the parameter covariance assuming maximum_likelihood_parameters\n contains a reasonable approximation of the true maximum likelihood\n parameter vector.\n \n maximum_likelihood_parameters: the maximum likelihood parameter vector\n (or some approximation of it), given in\n untransformed space, no matter the value\n of the transform_list argument\n transform_list: TransformList object (or something which can be cast to\n one) defining the transforms to apply to the parameters\n before computing the gradient. Default: None, parameter\n space is not transformed. No matter what,\n maximum_likelihood_parameters should be the parameters\n that maximize the likelihood when plugged into the\n model of this likelihood untransformed.\n max_standard_deviations: single value or array of values containing the\n maximum allowable standard deviations of each\n parameter. This will stop the covariance from\n producing extremely wide results in the case\n of an unconstrained parameter. The default\n value is numpy.inf, which causes this\n correction to be unimportant in all cases.\n larger_differences: either single number or 1D array of numbers to use\n as the numerical difference in parameters.\n Default: 10^(-5). This is the amount by which the\n parameters are shifted between evaluations of the\n gradient. Only used if gradient is not explicitly\n computable.\n smaller_differences: either single_number or 1D array of numbers to use\n as the numerical difference in parameters.\n Default: 10^(-6). This is the amount by which the\n parameters are shifted during each approximation\n of the gradient. Only used if hessian is not\n explicitly computable\n \n returns: numpy.ndarray of shape (num_parameters, num_parameters)\n containing the inverse Fisher information matrix\n \"\"\"\n inverse_covariance = self.fisher_information(\\\n maximum_likelihood_parameters, transform_list=transform_list,\\\n larger_differences=larger_differences,\\\n smaller_differences=smaller_differences)\n if np.any(max_standard_deviations == 0):\n raise ValueError(\"At least one of the max_standard deviations \" +\\\n \"was set to 0, which implies the existence of at least one \" +\\\n \"element in the null space of the covariance matrix, which \" +\\\n \"does not make sense.\")\n max_standard_deviations =\\\n max_standard_deviations * np.ones(self.num_parameters)\n inverse_covariance = inverse_covariance +\\\n np.diag(np.power(max_standard_deviations, -2))\n return la.inv(inverse_covariance)\n \n def parameter_distribution_fisher_formalism(self,\\\n maximum_likelihood_parameters, transform_list=None,\\\n max_standard_deviations=np.inf,\\\n prior_to_impose_in_transformed_space=None,\\\n larger_differences=1e-5, smaller_differences=1e-6,\\\n covariance_reduction_factor=1):\n \"\"\"\n Finds the parameter distribution assuming maximum_likelihood_parameters\n contains a reasonable approximation of the true maximum likelihood\n parameter vector.\n \n maximum_likelihood_parameters: the maximum likelihood parameter vector\n (or some approximation of it)\n transform_list: TransformList object (or something which can be cast to\n one) defining the transforms to apply to the parameters\n before computing the gradient. Default: None, parameter\n space is not transformed. No matter what,\n maximum_likelihood_parameters should be the parameters\n that maximize the likelihood when plugged into the\n model of this likelihood untransformed.\n max_standard_deviations: single value or array of values containing the\n maximum allowable standard deviations of each\n parameter. This will stop the covariance from\n producing extremely wide results in the case\n of an unconstrained parameter. The default\n value is numpy.inf, which causes this\n correction to be unimportant in all cases.\n prior_to_impose_in_transformed_space: if None (default), no prior is\n imposed and a\n Gaussian is\n returned\n through the\n Fisher matrix\n formalism\n otherwise, prior_to_impose should\n be a Distribution\n object whose log_value\n function returns\n -np.inf in disallowed\n regions. The prior has\n no effect inside the\n region in which it is\n finite.\n larger_differences: either single number or 1D array of numbers to use\n as the numerical difference in parameters.\n Default: 10^(-5). This is the amount by which the\n parameters are shifted between evaluations of the\n gradient. Only used if gradient is not explicitly\n computable.\n smaller_differences: either single_number or 1D array of numbers to use\n as the numerical difference in parameters.\n Default: 10^(-6). This is the amount by which the\n parameters are shifted during each approximation\n of the gradient. Only used if hessian is not\n explicitly computable\n covariance_reduction_factor: factor by which to decrease the magnitude\n of the covariance distribution: default 1\n \n returns: DistributionSet object containing GaussianDistribution object\n approximating distribution in transformed space\n \"\"\"\n transform_list = TransformList.cast(transform_list,\\\n num_transforms=self.num_parameters)\n mean = transform_list(maximum_likelihood_parameters)\n covariance = self.parameter_covariance_fisher_formalism(\\\n maximum_likelihood_parameters, transform_list=transform_list,\\\n max_standard_deviations=max_standard_deviations,\\\n larger_differences=larger_differences,\\\n smaller_differences=smaller_differences) /\\\n covariance_reduction_factor\n distribution = GaussianDistribution(mean, covariance)\n if type(prior_to_impose_in_transformed_space) is not type(None):\n distribution = WindowedDistribution(distribution,\\\n prior_to_impose_in_transformed_space)\n return\\\n DistributionSet([(distribution, self.parameters, transform_list)])\n\n", "meta": {"hexsha": "1bff1e377bfd53da8ef0a65fac6643a2d0c2b050", "size": 20406, "ext": "py", "lang": "Python", "max_stars_repo_path": "pylinex/loglikelihood/Loglikelihood.py", "max_stars_repo_name": "CU-NESS/pylinex", "max_stars_repo_head_hexsha": "b6f342595b6a154e129eb303782e5268088f34d5", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pylinex/loglikelihood/Loglikelihood.py", "max_issues_repo_name": "CU-NESS/pylinex", "max_issues_repo_head_hexsha": "b6f342595b6a154e129eb303782e5268088f34d5", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pylinex/loglikelihood/Loglikelihood.py", "max_forks_repo_name": "CU-NESS/pylinex", "max_forks_repo_head_hexsha": "b6f342595b6a154e129eb303782e5268088f34d5", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 51.9236641221, "max_line_length": 79, "alphanum_fraction": 0.5911986671, "include": true, "reason": "import numpy", "num_tokens": 3420, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5389832206876841, "lm_q2_score": 0.3629692055196168, "lm_q1q2_score": 0.195634311401413}} {"text": "\"\"\" Build the resource task network for steel plants.\n\nNotations\n Resource Category\n EAF - equipment unit in the EAF stage (first stage)\n EAF1 - (if multiple units in this stage) one equipment unit in the EAF stage\n H_A_S3 - (RTN1) intermediate product after stage 3\n H_B_S4 - (RTN1) intermediate product before stage 4\n H_A_LF2 - (RTN2) intermediate product before unit LF2\n EN - electric energy\n Task Category\n EAF - process task by unit EAF, i.e. melting\n TR_S3 - (RTN1) transportation task between stage 3 and stage 4\n TR_LF2_CC1 - (RTN2) transportation task between units LF2 and CC1\n\n__author__ = xxxzhang\n\"\"\"\n\nfrom collections import OrderedDict\nimport math\n\nimport numpy as np\nimport json\nimport logging\n\nlog = logging.getLogger('steel')\n\n\nclass PlantRtnBuilder():\n \"\"\" resources, tasks, and their interaction networks for steel plant scheduling\n \"\"\"\n\n def __init__(self, plant):\n self.rtn_t0 = plant['rtn_t0'] # time grid interval for RTN\n self.price_energy = []\n for price in plant['energy_price']:\n self.price_energy += [price] * (60 / self.rtn_t0)\n self.num_t = 24 * 60 / self.rtn_t0\n self.num_stage = len(plant['stage2units'].keys())\n self.num_groups = len(plant['group2heats'].keys())\n self.num_heats = 0\n for group, heats in plant['group2heats'].items():\n self.num_heats += len(heats)\n\n # basic information\n self.group2heats = plant['group2heats']\n self.stage2units = plant['stage2units']\n self.time_trans_max = plant['trans_time_max']\n self.time_trans = plant['trans_time']\n self.time_setup = plant['setup_time']\n self.time_process = plant['equip2process_time']\n\n # resources and tasks\n # todo instead using arrays, using dicts in tasks/res\n [self.resources, self.num_resources] = self.build_resources(plant)\n [self.tasks, self.num_tasks] = self.build_tasks(plant)\n [self.task_duration, self.task_cleanup_duration] = self.cal_task_duration(plant)\n [self.rtn_profile, self.heat_consume_time_in_group, self.heat_generate_time_in_group] \\\n = self.build_resource_task_profile(plant)\n\n # redundant information\n self.equip2num = {}\n for unit2num in self.stage2units.values():\n for unit, num in unit2num.items():\n self.equip2num[unit] = num\n self.maxPower = sum([float(plant['equip2mw'][unit])*num for unit, num in self.equip2num.items()])\n self.casters = [unit for unit, num in self.stage2units['4'].items()]\n self.heat_sequence = ['EAF', 'TR_EA', 'AOD', 'TR_AL', 'LF', 'TR_LC']\n self.main_process = ['EAF', 'AOD', 'LF', 'CC1', 'CC2']\n\n log.debug('TaskCategory : (Task, Duration)')\n for task_type, task_list in self.tasks.items():\n log.debug('%s : %s' % (task_type, ','.join('(%s,%d)' % (x, self.task_duration[x]) for x in task_list)))\n log.debug('ResourceCategory : Resource')\n for res_cat, res_list in self.resources.items():\n log.debug('%s : %s' % (res_cat, ','.join(str(x) for x in res_list)))\n # log.info('ResourceTaskInteraction')\n # log.info(json.dumps(self.rtn_profile, indent=2))\n\n def build_resources(self, plant):\n # todo, do you need the reverse mapping\n res_cat2idx = OrderedDict()\n r_idx = 1\n # equipment resources\n for stage in range(1, self.num_stage + 1):\n for unit in plant['stage2units'][str(stage)].keys():\n res_cat2idx[unit] = [r_idx]\n r_idx += 1\n # intermediate products and final products, A - after, B - before\n for stage in range(1, self.num_stage+1):\n res_cat2idx['H_A_S%s' % stage] = range(r_idx, r_idx + self.num_heats)\n r_idx += self.num_heats\n if int(stage) == 1:\n continue\n res_cat2idx['H_B_S%s' % stage] = range(r_idx, r_idx + self.num_heats)\n r_idx += self.num_heats\n # energy resource\n res_cat2idx['EN'] = [r_idx]\n res_num = r_idx\n return [res_cat2idx, res_num]\n\n def build_tasks(self, plant):\n tasks = OrderedDict()\n i_idx = 1\n for stage in range(1, self.num_stage + 1):\n for unit in plant['stage2units'][str(stage)].keys():\n if int(stage) == 4:\n tasks[unit] = range(i_idx, i_idx + self.num_groups)\n i_idx += self.num_groups\n else:\n tasks[unit] = range(i_idx, i_idx + self.num_heats)\n i_idx += self.num_heats\n tasks['TR_S%s' % stage] = range(i_idx, i_idx + self.num_heats)\n i_idx += self.num_heats\n task_num = i_idx - 1\n return [tasks, task_num]\n\n def cal_task_duration(self, plant):\n \"\"\"calculate time slots duration of tasks\"\"\"\n task_duration = dict()\n task_cleanup_duration = dict()\n for heat in range(1, self.num_heats + 1):\n for task_type in ['EAF', 'AOD', 'LF']:\n task_duration[self.tasks[task_type][heat - 1]] = \\\n int(math.ceil(float(plant['equip2process_time'][task_type][str(heat)])/self.rtn_t0))\n for task_type in ['TR_S1', 'TR_S2', 'TR_S3']:\n task_duration[self.tasks[task_type][heat - 1]] = \\\n int(math.ceil(float(plant['trans_time'][task_type])/self.rtn_t0))\n for group in range(1, self.num_groups + 1):\n for task_type in ['CC1', 'CC2']:\n cast_time = [plant['equip2process_time'][task_type][str(heat)] for heat in self.group2heats[str(group)]]\n total_time = float(sum(cast_time))\n task_duration[self.tasks[task_type][group - 1]] = int(math.ceil(total_time/self.rtn_t0))\n total_time = float(sum(cast_time) + self.time_setup[task_type])\n task_cleanup_duration[self.tasks[task_type][group - 1]] = int(math.ceil(total_time/self.rtn_t0))\n return task_duration, task_cleanup_duration\n\n def build_resource_task_profile(self, plant):\n \"\"\"calculate resource task profile, i.e. the interactions between resource and task\"\"\"\n rtn_profile = dict()\n for res_category, res_idxes in self.resources.items():\n for res_idx in res_idxes:\n rtn_profile[res_idx] = dict()\n # equipment usage\n for stage in range(1, self.num_stage + 1):\n for unit in plant['stage2units'][str(stage)].keys():\n res = self.resources[unit][0]\n for task in self.tasks[unit]:\n rtn_profile[res][task] = [-1] + [0] * (self.task_duration[task] - 1) + [1]\n if stage == 4:\n rtn_profile[res][task] = [-1] + [0] * (self.task_cleanup_duration[task] - 1) + [1]\n # heat consumption and generation for the first three stages\n for heat_idx in range(0, self.num_heats):\n # process task generate intermediate heat H_A_S (after stage)\n for task_cat, res_cat in [('EAF', 'H_A_S1'), ('AOD', 'H_A_S2'), ('LF', 'H_A_S3')]:\n task = self.tasks[task_cat][heat_idx]\n resource = self.resources[res_cat][heat_idx]\n rtn_profile[resource][task] = [0] * self.task_duration[task] + [1]\n # process task consume intermediate heat H_B_S (before stage)\n for task_cat, res_cat in [('AOD', 'H_B_S2'), ('LF', 'H_B_S3')]:\n task = self.tasks[task_cat][heat_idx]\n resource = self.resources[res_cat][heat_idx]\n rtn_profile[resource][task] = [-1] + [0] * self.task_duration[task]\n # transfer task transports heat\n for task_cat, res_cat in [('TR_S1', ['H_A_S1', 'H_B_S2']),\n ('TR_S2', ['H_A_S2', 'H_B_S3']),\n ('TR_S3', ['H_A_S3', 'H_B_S4'])]:\n task = self.tasks[task_cat][heat_idx]\n resource1 = self.resources[res_cat[0]][heat_idx]\n rtn_profile[resource1][task] = [-1] + [0] * self.task_duration[task]\n resource2 = self.resources[res_cat[1]][heat_idx]\n rtn_profile[resource2][task] = [0] * self.task_duration[task] + [1]\n # group-heat consumption and generation\n heat_consume_time_in_group = dict()\n heat_generate_time_in_group = dict()\n for unit in plant['stage2units']['4']:\n heat_consume_time_in_group[unit] = dict()\n heat_generate_time_in_group[unit] = dict()\n for group, heats in self.group2heats.items():\n # todo because the task numbers are stored in an array, can we do a better mapping?\n task = self.tasks[unit][int(group)-1]\n duration = 0\n for heat in heats:\n consume_time = int(math.floor(duration/self.rtn_t0))\n resource = self.resources['H_B_S4'][heat - 1]\n rtn_profile[resource][task] = [0] * (self.task_duration[task] + 1)\n rtn_profile[resource][task][consume_time] = -1\n duration += plant['equip2process_time'][unit][str(heat)]\n generate_time = int(math.ceil(duration/self.rtn_t0))\n resource = self.resources['H_A_S4'][heat - 1]\n rtn_profile[resource][task] = [0] * (self.task_duration[task] + 1)\n rtn_profile[resource][task][generate_time] = 1\n heat_consume_time_in_group[unit][heat] = consume_time\n heat_generate_time_in_group[unit][heat] = generate_time\n # energy usage\n for stage, units in plant['stage2units'].items():\n stage = int(stage)\n for unit in units.keys():\n norm_mw = float(plant['equip2mw'][unit])\n for task in self.tasks[unit]:\n total_energy = 0\n if stage < 4:\n heat = task - self.tasks[unit][0] + 1\n total_energy = norm_mw * plant['equip2process_time'][unit][str(heat)] / 60\n elif stage == 4:\n group = task - self.tasks[unit][0] + 1\n for heat in self.group2heats[str(group)]:\n total_energy += norm_mw * plant['equip2process_time'][unit][str(heat)] / 60\n profile = [norm_mw * self.rtn_t0 / 60] * (self.task_duration[task] - 1)\n profile = profile + [total_energy - sum(profile)] + [0]\n rtn_profile[self.resources['EN'][0]][task] = profile\n return rtn_profile, heat_consume_time_in_group, heat_generate_time_in_group\n\n def cal_initial_resource(self, res):\n # todo, here needs reverse mapping\n # only equipment initial value not zero\n for stage, stage_units in self.stage2units.items():\n for unit in stage_units.keys():\n if res in self.resources[unit]:\n return stage_units[unit]\n return 0\n\n # todo delete this\n def get_unit2num(self):\n unit2num = dict()\n for stage, units in self.stage2units.items():\n for key, value in units.items():\n unit2num[key] = value\n return unit2num\n\n def get_same_heats(self):\n \"\"\"find heats which share same processing times\"\"\"\n process_time = np.zeros((self.num_heats, len(self.main_process)))\n for i in range(len(self.main_process)):\n for heat_ in range(self.num_heats):\n process_time[heat_, i] = self.time_process[self.main_process[i]][heat_ + 1]\n visited = []\n same_heat = dict()\n for row in range(self.num_heats):\n if row not in visited:\n visited.append(row)\n same_heat[row + 1] = [row + 1]\n for row2 in range(row + 1, self.num_heats):\n if np.array_equal(process_time[row2], process_time[row]):\n same_heat[row + 1].append(row2 + 1)\n visited.append(row2)\n return same_heat\n\n\nclass PlantRtn2Builder(PlantRtnBuilder):\n \"\"\"Build RTN2 model.\"\"\"\n\n def build_resources(self, plant):\n res_cat2idx = OrderedDict()\n r_idx = 1\n # equipment resources\n for stage in range(1, self.num_stage + 1):\n for unit in plant['stage2units'][str(stage)].keys():\n res_cat2idx[unit] = [r_idx]\n r_idx += 1\n # intermediate products, A - after, B - before\n for stage in range(1, self.num_stage+1):\n for unit in plant['stage2units'][str(stage)].keys():\n if int(stage) != 1:\n res_cat2idx['H_B_%s' % unit] = range(r_idx, r_idx + self.num_heats)\n r_idx += self.num_heats\n if int(stage) != 4:\n res_cat2idx['H_A_%s' % unit] = range(r_idx, r_idx + self.num_heats)\n r_idx += self.num_heats\n # final products\n res_cat2idx['H_FINAL'] = range(r_idx, r_idx + self.num_heats)\n r_idx += self.num_heats\n # energy resource\n res_cat2idx['EN'] = [r_idx]\n res_num = r_idx\n return [res_cat2idx, res_num]\n\n def build_tasks(self, plant):\n tasks = OrderedDict()\n i_idx = 1\n for stage in range(1, self.num_stage + 1):\n for unit in plant['stage2units'][str(stage)].keys():\n if int(stage) == 4:\n # casting task\n tasks[unit] = range(i_idx, i_idx + self.num_groups)\n i_idx += self.num_groups\n else:\n # process task for first 3 stages\n tasks[unit] = range(i_idx, i_idx + self.num_heats)\n i_idx += self.num_heats\n # transfer task\n for unit_2 in plant['stage2units'][str(stage+1)].keys():\n tasks['TR_%s_%s' % (unit, unit_2)] = range(i_idx, i_idx + self.num_heats)\n i_idx += self.num_heats\n task_num = i_idx - 1\n return [tasks, task_num]\n\n def cal_task_duration(self, plant):\n \"\"\"calculate time slots duration of tasks\"\"\"\n task_duration = dict()\n task_cleanup_duration = dict()\n for heat in range(1, self.num_heats + 1):\n for stage in range(1, self.num_stage):\n for unit in plant['stage2units'][str(stage)].keys():\n # process task\n task_duration[self.tasks[unit][heat - 1]] = \\\n int(math.ceil(float(plant['equip2process_time'][unit][str(heat)])/self.rtn_t0))\n if stage == 4:\n continue\n # transfer task\n for unit_2 in plant['stage2units'][str(stage+1)].keys():\n transfer_task = 'TR_%s_%s' % (unit, unit_2)\n transfer = '%s-%s' % (unit, unit_2)\n task_duration[self.tasks[transfer_task][heat - 1]] = \\\n int(math.ceil(float(plant['trans_time'][transfer])/self.rtn_t0))\n for group in range(1, self.num_groups + 1):\n for task_type in ['CC1', 'CC2']:\n cast_time = [plant['equip2process_time'][task_type][str(heat)] for heat in self.group2heats[str(group)]]\n total_time = float(sum(cast_time))\n task_duration[self.tasks[task_type][group - 1]] = int(math.ceil(total_time/self.rtn_t0))\n total_time = float(sum(cast_time) + self.time_setup[task_type])\n task_cleanup_duration[self.tasks[task_type][group - 1]] = int(math.ceil(total_time/self.rtn_t0))\n return task_duration, task_cleanup_duration\n\n def build_resource_task_profile(self, plant):\n \"\"\"calculate resource task profile, i.e. the interactions between resource and task\"\"\"\n rtn_profile = dict()\n for res_category, res_indices in self.resources.items():\n for res_idx in res_indices:\n rtn_profile[res_idx] = dict()\n # equipment usage\n for stage in range(1, self.num_stage + 1):\n for unit in plant['stage2units'][str(stage)].keys():\n res = self.resources[unit][0]\n for task in self.tasks[unit]:\n rtn_profile[res][task] = [-1] + [0] * (self.task_duration[task] - 1) + [1]\n if stage == 4:\n rtn_profile[res][task] = [-1] + [0] * (self.task_cleanup_duration[task] - 1) + [1]\n # intermediate product with processes and transfers in the first 3 stages\n for heat_idx in range(0, self.num_heats):\n for stage in range(1, self.num_stage + 1):\n if stage == 4:\n continue\n for unit in plant['stage2units'][str(stage)].keys():\n # process task generate intermediate heat\n task_cat = unit\n res_cat = 'H_A_%s' % unit\n task = self.tasks[task_cat][heat_idx]\n resource = self.resources[res_cat][heat_idx]\n rtn_profile[resource][task] = [0] * self.task_duration[task] + [1]\n # process task consume intermediate heat\n if stage != 1:\n task_cat = unit\n res_cat = 'H_B_%s' % unit\n task = self.tasks[task_cat][heat_idx]\n resource = self.resources[res_cat][heat_idx]\n rtn_profile[resource][task] = [-1] + [0] * self.task_duration[task]\n # transfer task\n for unit_2 in plant['stage2units'][str(stage+1)].keys():\n task_cat = 'TR_%s_%s' % (unit, unit_2)\n res_from = 'H_A_%s' % unit\n res_to = 'H_B_%s' % unit_2\n task = self.tasks[task_cat][heat_idx]\n resource1 = self.resources[res_from][heat_idx]\n rtn_profile[resource1][task] = [-1] + [0] * self.task_duration[task]\n resource2 = self.resources[res_to][heat_idx]\n rtn_profile[resource2][task] = [0] * self.task_duration[task] + [1]\n # group-heat consumption and generation\n heat_consume_time_in_group = dict()\n heat_generate_time_in_group = dict()\n for unit in plant['stage2units']['4']:\n heat_consume_time_in_group[unit] = dict()\n heat_generate_time_in_group[unit] = dict()\n for group, heats in self.group2heats.items():\n task = self.tasks[unit][int(group)-1]\n duration = 0\n res_cat_before = 'H_B_%s' % unit\n res_cat_after = 'H_FINAL'\n for heat in heats:\n consume_time = int(math.floor(duration/self.rtn_t0))\n resource = self.resources[res_cat_before][heat - 1]\n rtn_profile[resource][task] = [0] * (self.task_duration[task] + 1)\n rtn_profile[resource][task][consume_time] = -1\n duration += plant['equip2process_time'][unit][str(heat)]\n generate_time = int(math.ceil(duration/self.rtn_t0))\n resource = self.resources[res_cat_after][heat - 1]\n rtn_profile[resource][task] = [0] * (self.task_duration[task] + 1)\n rtn_profile[resource][task][generate_time] = 1\n heat_consume_time_in_group[unit][heat] = consume_time\n heat_generate_time_in_group[unit][heat] = generate_time\n # energy usage\n for stage, units in plant['stage2units'].items():\n stage = int(stage)\n for unit in units.keys():\n norm_mw = float(plant['equip2mw'][unit])\n for task in self.tasks[unit]:\n total_energy = 0\n if stage < 4:\n heat = task - self.tasks[unit][0] + 1\n total_energy = norm_mw * plant['equip2process_time'][unit][str(heat)] / 60\n elif stage == 4:\n group = task - self.tasks[unit][0] + 1\n for heat in self.group2heats[str(group)]:\n total_energy += norm_mw * plant['equip2process_time'][unit][str(heat)] / 60\n profile = [norm_mw * self.rtn_t0 / 60] * (self.task_duration[task] - 1)\n profile = profile + [total_energy - sum(profile)] + [0]\n rtn_profile[self.resources['EN'][0]][task] = profile\n return rtn_profile, heat_consume_time_in_group, heat_generate_time_in_group\n\n\n\n\n\n", "meta": {"hexsha": "7aa4c3d0f2879a2b5ca28bdecfca0ba85d0ffbfa", "size": 20945, "ext": "py", "lang": "Python", "max_stars_repo_path": "steel/build_plant_rtn.py", "max_stars_repo_name": "xxxzhang/IndustrialScheduling", "max_stars_repo_head_hexsha": "f5283bef78fe37462490549c182676aab7693fd0", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2017-10-06T14:07:09.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-06T10:08:52.000Z", "max_issues_repo_path": "steel/build_plant_rtn.py", "max_issues_repo_name": "xxxzhang/IndustrialScheduling", "max_issues_repo_head_hexsha": "f5283bef78fe37462490549c182676aab7693fd0", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "steel/build_plant_rtn.py", "max_forks_repo_name": "xxxzhang/IndustrialScheduling", "max_forks_repo_head_hexsha": "f5283bef78fe37462490549c182676aab7693fd0", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 12, "max_forks_repo_forks_event_min_datetime": "2016-12-17T18:28:10.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-06T10:09:39.000Z", "avg_line_length": 50.5917874396, "max_line_length": 120, "alphanum_fraction": 0.5531630461, "include": true, "reason": "import numpy", "num_tokens": 4979, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.538983220687684, "lm_q2_score": 0.3629692055196168, "lm_q1q2_score": 0.19563431140141296}} {"text": "import os\nimport sys\n\nimport gym\nimport eplus_env\n\n# Assign mpc_path to be the file path where mpc.torch is located.\nmpc_path = os.path.abspath(os.path.join(__file__, '..', '..' ))\nsys.path.insert(0, mpc_path)\n\nimport argparse\nfrom numpy import genfromtxt\nimport numpy as np\nimport pickle\nimport pandas as pd\n\nfrom diff_mpc import mpc\nfrom diff_mpc.mpc import QuadCost, LinDx\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.optim as optim\n\nfrom utils import make_dict, R_func\n\nDEVICE = \"cuda\" if torch.cuda.is_available() else \"cpu\"\nDEVICE\n\nparser = argparse.ArgumentParser(description='GruRL-Imitation Learning')\nparser.add_argument('--seed', type=int, default=42, metavar='N',\n help='random seed (default: 42)')\nparser.add_argument('--lr', type=float, default=5e-4, metavar='G',\n help='Learning Rate')\nparser.add_argument('--T', type=int, default=12, metavar='N',\n help='Planning Horizon (default: 12)')\nparser.add_argument('--step', type=int, default=900, metavar='N',\n help='Time Step in Simulation, Unit in Seconds (default: 900)') # 15 Minutes Now!\nparser.add_argument('--eta', type=int, default=5,\n help='Hyper Parameter for Balancing Comfort and Energy')\nparser.add_argument('--batch_size', type=int, default=256,\n help='Size of Mini-batch')\nparser.add_argument('--save_name', type=str, default='rl',\n help='save name')\nargs = parser.parse_args()\n\ntorch.manual_seed(args.seed)\n\n# Modify here: Outputs from EnergyPlus; Match the variables.cfg file.\nobs_name = [\"Outdoor Temp.\", \"Outdoor RH\", \"Wind Speed\", \"Wind Direction\", \"Diff. Solar Rad.\", \"Direct Solar Rad.\", \"Htg SP\", \"Clg SP\", \"Indoor Temp.\", \"Indoor Temp. Setpoint\", \"PPD\", \"Occupancy Flag\", \"Coil Power\", \"HVAC Power\", \"Sys In Temp.\", \"Sys In Mdot\", \"OA Temp.\", \"OA Mdot\", \"MA Temp.\", \"MA Mdot\", \"Sys Out Temp.\", \"Sys Out Mdot\"]\n\n# Modify here: Change based on the specific control problem\nstate_name = [\"Indoor Temp.\"]\ndist_name = [\"Outdoor Temp.\", \"Outdoor RH\", \"Wind Speed\", \"Wind Direction\", \"Diff. Solar Rad.\", \"Direct Solar Rad.\", \"Occupancy Flag\"]\n# Caveat: The RL agent controls the difference between Supply Air Temp. and Mixed Air Temp., i.e. the amount of heating from the heating coil. But, the E+ expects Supply Air Temp. Setpoint.\nctrl_name = [\"Delta T\"]\ntarget_name = [\"Indoor Temp. Setpoint\"]\n\nn_state = len(state_name)\nn_ctrl = len(ctrl_name)\nn_dist = len(dist_name)\n\neta = [0.1, args.eta] # eta: Weight for comfort during unoccupied and occupied mode\nstep = args.step # step: Timestep; Unit in seconds\nT = args.T # T: Number of timesteps in the planning horizon\ntol_eps = 90 # tol_eps: Total number of episodes; Each episode is a natural day\n\n# Read Historical Data\ndataset = pd.read_pickle(\"results/Sim-TMY2.pkl\")\ntarget = dataset[target_name]\ndisturbance = dataset[dist_name]\n# Min-Max Normalization\ndisturbance = (disturbance-disturbance.min())/(disturbance.max()-disturbance.min())\n\ndataset[\"Delta T\"] = dataset[\"Sys Out Temp.\"]-dataset[\"MA Temp.\"]\n\n# Train-Test Split\nn_samples = len(dataset)\nn_train = int(0.7*n_samples)\nn_test = n_samples - n_train\ntrain_set = dataset[:n_train]\ntest_set = dataset[n_train:]\n\nclass Learner():\n def __init__(self, n_state, n_ctrl, n_dist, disturbance, target, u_upper, u_lower):\n self.n_state = n_state\n self.n_ctrl = n_ctrl\n self.n_dist = n_dist\n self.disturbance = disturbance\n self.target = target\n \n # My Initial Guess\n self.F_hat = torch.ones((self.n_state, self.n_state+self.n_ctrl))\n self.F_hat[0, 0] = 0.9\n self.F_hat[0, 1] = 0.3\n self.F_hat = self.F_hat.double().requires_grad_()\n \n self.Bd_hat = np.random.rand(self.n_state, self.n_dist)\n self.Bd_hat = torch.tensor(self.Bd_hat).requires_grad_()\n \n self.optimizer = optim.Adam([self.F_hat, self.Bd_hat], lr=args.lr)\n \n self.u_lower = u_lower * torch.ones(T, 1, n_ctrl).double()\n self.u_upper = u_upper * torch.ones(T, 1, n_ctrl).double()\n \n def Cost_function(self, cur_time):\n diag = torch.zeros(T, self.n_state + self.n_ctrl)\n occupied = self.disturbance[\"Occupancy Flag\"][cur_time:cur_time + pd.Timedelta(seconds = (T-1) * step)]\n occupied = np.array(occupied)\n if len(occupied)0):\n x_true = torch.stack(x_true).reshape(-1, n_state)\n u_true = torch.stack(u_true).reshape(-1, n_ctrl)\n x_pred = torch.stack(x_pred).reshape(-1, n_state)\n u_pred = torch.stack(u_pred).reshape(-1, n_ctrl)\n b_state_loss, b_action_loss = learner.update_parameters(x_true, u_true, x_pred, u_pred)\n train_state_loss.append(b_state_loss)\n train_action_loss.append(b_action_loss)\n x_true = []\n u_true = []\n x_pred = []\n u_pred = []\n\n # Evaluate performance at the end of each epoch\n x_true = []\n u_true = []\n x_pred = []\n u_pred = []\n timeStamp = []\n for idx in range(n_test):\n cur_time = test_set.index[idx]\n expert_moves = test_set[cur_time:cur_time+pd.Timedelta(seconds = step)]\n if len(expert_moves)<2:\n print(cur_time)\n continue\n expert_state = torch.tensor(expert_moves[state_name].values).reshape(-1, n_state) # 2 x n_state\n expert_action = torch.tensor(expert_moves[ctrl_name].values).reshape(-1, n_ctrl) # 2 x n_ctrl\n x_true.append(expert_state[-1])\n u_true.append(expert_action[0])\n \n timeStamp.append(cur_time+pd.Timedelta(seconds = step))\n \n obs = test_set.loc[cur_time]\n x_init = torch.tensor(np.array([obs[name] for name in state_name])).unsqueeze(0) # 1 x n_state\n C, c = learner.Cost_function(cur_time)\n learner_state, learner_action = learner.forward(x_init, C, c, cur_time)\n next_state = learner.predict(x_init.squeeze(0), expert_action[0], cur_time)\n x_pred.append(next_state.detach())\n u_pred.append(learner_action.detach())\n \n x_true = torch.stack(x_true).reshape(-1, n_state)\n u_true = torch.stack(u_true).reshape(-1, n_ctrl)\n x_pred = torch.stack(x_pred).reshape(-1, n_state)\n u_pred = torch.stack(u_pred).reshape(-1, n_ctrl)\n val_state_loss, val_action_loss = evaluate_performance(x_true, u_true, x_pred, u_pred)\n print(\"At Epoch {0}, the loss from the state is {1} and from the action is {2}\".format(epoch, val_state_loss, val_action_loss))\n losses.append((np.mean(train_state_loss), np.mean(train_action_loss), val_state_loss, val_action_loss))\n \n record = pd.DataFrame(torch.cat((x_pred, x_true, u_pred, u_true), dim = 1).numpy(), index = np.array(timeStamp), columns = record_name)\n record_df = pd.DataFrame(np.array(record), index = np.array(timeStamp), columns = record_name)\n record_df.to_pickle(\"results/Imit_{}_{}.pkl\".format(args.save_name, epoch))\n \n # Save weights\n F_hat = learner.F_hat.detach().numpy()\n Bd_hat = learner.Bd_hat.detach().numpy()\n np.save(\"results/weights/F-{}.npy\".format(epoch), F_hat)\n np.save(\"results/weights/Bd-{}.npy\".format(epoch), Bd_hat)\n \n # Save losses at each epoch\n losses_df = pd.DataFrame(np.array(losses), index = np.arange(numOfEpoches), columns = losses_name)\n losses_df.to_pickle(\"results/Imit_loss_\"+args.save_name+\".pkl\")\n \nif __name__ == '__main__':\n main()\n\n", "meta": {"hexsha": "85eef625bf15d375af43e47ca138c4a253b3f0d6", "size": 13113, "ext": "py", "lang": "Python", "max_stars_repo_path": "agent/Imit_EP.py", "max_stars_repo_name": "gbaasch/Gnu-RL", "max_stars_repo_head_hexsha": "04621c3cd299eb0fa361d303699676d662aa147d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 34, "max_stars_repo_stars_event_min_datetime": "2019-12-16T17:52:10.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-10T08:25:12.000Z", "max_issues_repo_path": "agent/Imit_EP.py", "max_issues_repo_name": "gbaasch/Gnu-RL", "max_issues_repo_head_hexsha": "04621c3cd299eb0fa361d303699676d662aa147d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-12-11T19:06:25.000Z", "max_issues_repo_issues_event_max_datetime": "2020-12-11T19:06:25.000Z", "max_forks_repo_path": "agent/Imit_EP.py", "max_forks_repo_name": "gbaasch/Gnu-RL", "max_forks_repo_head_hexsha": "04621c3cd299eb0fa361d303699676d662aa147d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 18, "max_forks_repo_forks_event_min_datetime": "2019-11-19T12:52:36.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-22T10:38:11.000Z", "avg_line_length": 43.856187291, "max_line_length": 339, "alphanum_fraction": 0.604972165, "include": true, "reason": "import numpy,from numpy", "num_tokens": 3307, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5389832058771036, "lm_q2_score": 0.3629692055196168, "lm_q1q2_score": 0.19563430602562834}} {"text": "# Copyright © 2017 Ondrej Martinsky, All rights reserved\n# http://github.com/omartinsky/pybor\n# \n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# in the Software without restriction, including without limitation the rights\n# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n# copies of the Software, and to permit persons to whom the Software is\n# furnished to do so, subject to the following conditions:\n# \n# The above copyright notice and this permission notice shall be included in all\n# copies or substantial portions of the Software.\n# \n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n# SOFTWARE.\n\n\nfrom yc_convention import *\nimport scipy.interpolate\nimport pylab, re, collections, matplotlib\n\nclass PlottingHelper:\n @staticmethod\n def set_tenors_on_axis(axis, start_date):\n tenors = \"6M,1Y,2Y,3Y,4Y,5Y,7Y,10Y,15Y,20Y,30Y,40Y,50Y,60Y,70Y\".split(\",\")\n tenordates = [date_step(int(start_date), Tenor(t)) for t in tenors]\n axis.xaxis.set_ticks(tenordates)\n axis.xaxis.set_major_formatter(matplotlib.ticker.FuncFormatter(lambda x, pos: tenors[pos]))\n\nclass CurveMap:\n def __init__(self, *arg, **kw):\n super(CurveMap, self).__init__(*arg, **kw)\n self.curves_ = collections.OrderedDict()\n\n def add_curve(self, c):\n assert_type(c, Curve)\n self.curves_[c.get_id()] = c\n\n def get_all_dofs(self, curves_for_stage):\n dofs = list()\n for k, v in self.curves_.items():\n if k in curves_for_stage:\n dofs.extend(v.get_all_dofs())\n return dofs\n\n def set_all_dofs(self, curves_for_stage, dofs):\n i = 0\n for k, v in self.curves_.items():\n if k in curves_for_stage:\n j = i + v.get_dofs_count()\n v.set_all_dofs(dofs[i:j])\n i = j\n\n def __getitem__(self, item):\n return self.curves_[item]\n\n def __len__(self):\n return len(self.curves_)\n\n def keys(self):\n return self.curves_.keys()\n\n def plot(self, reg=\".*\", *arg, **kwargs):\n for name, curve in sorted(self.curves_.items()):\n if re.match(reg, name):\n curve.plot(*arg, **kwargs)\n\n\nclass InterpolationMode(enum.Enum):\n LINEAR_LOGDF = 0\n LINEAR_CCZR = 1\n CUBIC_LOGDF = 2\n\nclass PlotMode(enum.Enum):\n DF = 0\n ZR = 1\n FWD = 2\n\nclass PlotDate(enum.Enum):\n YMD = 0\n EXCEL = 1\n TENOR = 2\n\nclass ExponentialInterpolator:\n def __init__(self, interp):\n self.interp = interp\n def value(self, t):\n return exp(self.interp(t))\n\nclass ZeroRateInterpolator:\n def __init__(self, interp, t_eval):\n self.interp = interp\n self.t_eval = t_eval\n def value(self, t):\n return exp(self.interp(t) * (t - self.t_eval))\n\nclass Curve:\n def __init__(self, curve_id, eval_date, times, dfs, interpolation_mode):\n try:\n times, dfs = array(times), array(dfs)\n assert_type(interpolation_mode, InterpolationMode)\n assert len(times) > 0, \"Vector of times is empty\"\n assert times[0] != eval_date, \"DF at eval date cannot be provided externally. It is assumed to be 1.0 always.\"\n self.id_ = curve_id\n self.times_ = append(eval_date, times)\n self.dfs_ = append([1.], dfs)\n self.set_interpolator(interpolation_mode)\n except BaseException as ex:\n raise BaseException(\"Unable to create curve %s\" % curve_id) from ex\n\n def add_another_curve(self, another_curve):\n assert isinstance(another_curve, Curve)\n assert all(self.times_ == another_curve.times_)\n self.dfs_ = another_curve.dfs_ * self.dfs_\n self.set_interpolator(self.interpolation_mode_)\n\n def set_interpolator(self, interpolation_mode=None):\n if interpolation_mode is not None:\n self.interpolation_mode_ = interpolation_mode\n if self.interpolation_mode_ in [InterpolationMode.LINEAR_LOGDF, InterpolationMode.LINEAR_CCZR]:\n kind = 'linear'\n elif self.interpolation_mode_ in [InterpolationMode.CUBIC_LOGDF]:\n kind = 'cubic'\n else:\n raise BaseException(\"Invalid interpolation mode. Allowed modes are %s\" % enum_values_as_string(InterpolationMode))\n #\n assert len(self.times_) == len(self.dfs_), (len(self.times_), len(self.dfs_))\n #\n if self.interpolation_mode_ in [InterpolationMode.LINEAR_LOGDF, InterpolationMode.CUBIC_LOGDF]:\n logdf = log(self.dfs_)\n interp = scipy.interpolate.interp1d(self.times_, logdf, kind=kind)\n self.interpolator_ = ExponentialInterpolator(interp)\n elif self.interpolation_mode_ in [InterpolationMode.LINEAR_CCZR]:\n t_eval = self.times_[0]\n t_rel = self.times_-t_eval\n cczr1 = log(self.dfs_[1:]) / t_rel[1:]\n cczr = insert(cczr1, 0, cczr1[0]) # ZZCR at t0 is undefined, take it from t1 instead\n interp = scipy.interpolate.interp1d(self.times_, cczr, kind=kind)\n self.interpolator_ = ZeroRateInterpolator(interp, t_eval)\n else:\n raise BaseException(\"Invalid interpolation mode\")\n\n def __str__(self):\n return self.id_\n\n def get_id(self):\n return self.id_\n\n def get_df(self, t):\n try:\n return self.interpolator_.value(t)\n except BaseException as ex:\n raise BaseException(\"Unable to get discount factor for dates [%i..%i] from curve with dates range [%i..%i]\" % (t[0],t[-1],self.times_[0], self.times_[-1])) from ex\n\n def get_zero_rate(self, t, freq, dcc):\n dfs = self.get_df(t)\n dcf = calculate_dcf(self.times_[0], t, dcc)\n if freq == CouponFreq.ZERO:\n return (1. / dfs - 1.) / dcf\n if freq == CouponFreq.CONTINUOUS:\n return -log(dfs) / dcf\n\n def get_fwd_rate(self, t_start, t_end, freq, dcc):\n dfs_start = self.get_df(t_start)\n dfs_end = self.get_df(t_end)\n dcf = calculate_dcf(t_start, t_end, dcc)\n if freq == CouponFreq.ZERO:\n return (dfs_start / dfs_end - 1) / dcf\n if freq == CouponFreq.CONTINUOUS:\n return log(dfs_start / dfs_end) / dcf\n\n def get_fwd_rate_aligned(self, t, freq, dcc):\n # Slightly faster version which relies on the fact that calculation periods are aligned (no overlaps, no gaps)\n dfs = self.get_df(t)\n t1 = t[:-1]\n t2 = t[1:]\n df1 = dfs[:-1]\n df2 = dfs[1:]\n dcf = calculate_dcf(t1, t2, dcc)\n if freq == CouponFreq.ZERO:\n return (df1 / df2 - 1) / dcf\n if freq == CouponFreq.CONTINUOUS:\n return log(df1 / df2) / dcf\n\n def set_all_dofs(self, dofs):\n self.dfs_ = append([1], dofs)\n self.set_interpolator()\n\n def get_all_dofs(self):\n return self.dfs_[1:]\n\n def get_dofs_count(self):\n return len(self.dfs_) - 1\n\n def plot(self, date_style=PlotDate.YMD, mode=PlotMode.FWD, samples=1000, label=None, convention=None):\n timesample = linspace(self.times_[0], self.times_[-1], samples)\n X = timesample\n if date_style==PlotDate.YMD:\n X = [exceldate_to_pydate(int(x)) for x in X]\n elif date_style==PlotDate.TENOR:\n ax = matplotlib.pyplot.subplot()\n PlottingHelper.set_tenors_on_axis(ax, self.times_[0])\n elif date_style==PlotDate.EXCEL:\n pass\n else:\n raise BaseException(\"Unknown PlottingDateStyle\")\n ###\n if mode==PlotMode.FWD:\n convention = global_conventions.get(self.id_) if convention is None else convention\n Y = self.get_fwd_rate_aligned(timesample, CouponFreq.ZERO, convention.dcc)\n pylab.plot(X[:-1], Y, label=self.id_ if label is None else label)\n elif mode==PlotMode.ZR:\n convention = global_conventions.get(self.id_) if convention is None else convention\n Y = self.get_zero_rate(timesample[1:], CouponFreq.ZERO, convention.dcc)\n pylab.plot(X[:-1], Y, label=self.id_ if label is None else label)\n elif mode==PlotMode.DF:\n Y = self.get_df(timesample)\n pylab.plot(X, Y, label=self.id_ if label is None else label)\n else:\n raise BaseException(\"Unknown PlottingMode\")\n\nclass CurveConstructor:\n @staticmethod\n def FromShortRateModel(curve_id, times, r0, speed, mean, sigma, interpolation):\n import random\n times = array(times)\n assert_type(r0, float)\n assert_type(speed, float)\n assert_type(mean, float)\n assert_type(sigma, float)\n assert_type(interpolation, InterpolationMode)\n r = r0\n rates = []\n dts = times[1:] - times[:-1]\n dts = dts / 365.\n for dt in dts:\n rates.append(r)\n dr = speed * (mean - r) * dt + sigma * random.gauss(0, 1) * dt ** .5\n r += dr\n rates = array(rates)\n dfs_fwd = exp(-rates * dts)\n dfs = cumprod(dfs_fwd)\n return Curve(curve_id, times[0], times[1:], dfs, interpolation)\n", "meta": {"hexsha": "2db4452b6e118a2a6e7271449929e24c1de88d9a", "size": 9623, "ext": "py", "lang": "Python", "max_stars_repo_path": "yc_curve.py", "max_stars_repo_name": "ioancw/PYBOR", "max_stars_repo_head_hexsha": "b4a3e7f2ca3588f515ed01eca0bd0fe246d12449", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-08-25T11:36:30.000Z", "max_stars_repo_stars_event_max_datetime": "2019-08-25T11:36:30.000Z", "max_issues_repo_path": "yc_curve.py", "max_issues_repo_name": "ioancw/PYBOR", "max_issues_repo_head_hexsha": "b4a3e7f2ca3588f515ed01eca0bd0fe246d12449", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "yc_curve.py", "max_forks_repo_name": "ioancw/PYBOR", "max_forks_repo_head_hexsha": "b4a3e7f2ca3588f515ed01eca0bd0fe246d12449", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.6465863454, "max_line_length": 175, "alphanum_fraction": 0.6319235166, "include": true, "reason": "import scipy", "num_tokens": 2441, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5389832206876841, "lm_q2_score": 0.36296919173767833, "lm_q1q2_score": 0.1956343039731794}} {"text": "import numpy as np\n\n\"\"\"\nIt is created for using MTC in Mujoco. The dynamics in this model is not continuous. The integration error will be\naccumulated overtime. And the system might get unstable if the timestep is too large. It is recommended to set the\ntimestamp lower than 5e-4 to get decent results.\n\nThe model is created based on Song's and Geyer's 2015 paper:\nSong, S. and Geyer, H., 2015. A neural circuitry that emphasizes spinal feedback generates diverse behaviours of human\nlocomotion. The Journal of physiology, 593(16), pp.3493-3511.\n\nV0.1\nPassed basic tests. There're slightly difference compared to the simmechanics model.\n\nV0.2\n1. Verified with the simmechanics model. Difference in most of the cases can be ignored.\n2. Changed the integration method from forward Euler to trapezoid.\n3. Muscle force vce etc might vibrate/jitter if in some cases if the timestep is not low enough.\n Need to improve this in the next version.\n \n\"\"\"\n\nclass MuscleTendonComplex:\n def __init__(self, paraMuscle, stateMuscle, paraMusAttach, offsetCorr, timestep, nameMuscle, angJoi):\n self.frcmax, self.vmax, self.eref, self.lslack, self.lopt, self.tau, self.w, self.c, self.N, self.K = paraMuscle\n self.stim, self.act, self.lmtc, self.lce, self.vce, self.frcmtc = stateMuscle\n self.timestep = timestep\n self.nameMuscle = nameMuscle\n self.angJoi = angJoi\n self.offsetCorr = offsetCorr\n self.r, self.phiref, self.phimaxref, self.rho, self.dirAng, self.phiScale = paraMusAttach\n self.MR = 0.01\n self.typeMuscle = self.angJoi.size\n nJoi = self.typeMuscle\n self.levelArm = np.zeros(nJoi)\n\n tmpL = np.zeros(nJoi)\n for i in range(0, nJoi):\n if self.offsetCorr[i] == 0:\n tmpL[i] = self.dirAng[i] * (self.angJoi[i] - self.phiref[i]) * self.r[i] * self.rho[i]\n self.levelArm[i] = self.r[i]\n elif self.offsetCorr[i] == 1:\n tmp1 = np.sin((self.phiref[i] - self.phimaxref[i]) * self.phiScale[i])\n tmp2 = np.sin((self.angJoi[i] - self.phimaxref[i]) * self.phiScale[i])\n tmpL[i] = self.dirAng[i] * (tmp2 - tmp1) * self.r[i] * self.rho[i] / self.phiScale[i]\n self.levelArm[i] = np.cos((self.angJoi[i] - self.phimaxref[i]) * self.phiScale[i]) * self.r[i]\n else:\n raise ValueError('Invalid muscle level arm offset correction type. ')\n self.lmtc = self.lslack + self.lopt + np.sum(tmpL)\n\n self.lce = self.lmtc - self.lslack\n self.lse = self.lmtc - self.lce\n # unitless parameters\n self.Lse = self.lse / self.lslack\n self.Lce = self.lce / self.lopt\n\n self.actsubstep = (self.stim - self.act) * self.timestep / 2.0 / self.tau + self.act\n self.lcesubstep = self.vce * self.timestep / 2.0 + self.lce\n\n # test\n self.lce_avg = self.lce\n self.vce_avg = self.vce\n self.frcmtc_avg = 0\n self.act_avg = self.act\n self.frame = 0\n # self.Fse = 0.0\n # self.Fbe = 0.0\n # self.Fpe = 0.0\n # self.Fce = 0.0\n\n\n def stepUpdateState(self, angJoi):\n \"\"\"\n Muscle Tendon Complex Dynamics\n update muscle states based on the muscle dynamics\n Muscle state stim has to be updated outside before this function is called\n \"\"\"\n # update lmtc and level arm based on the geometry\n self.angJoi = angJoi\n nJoi = self.typeMuscle\n tmpL = np.zeros(nJoi)\n for i in range(0, nJoi):\n if self.offsetCorr[i] == 0:\n tmpL[i] = self.dirAng[i] * (self.angJoi[i] - self.phiref[i]) * self.r[i] * self.rho[i]\n self.levelArm[i] = self.r[i]\n elif self.offsetCorr[i] == 1:\n tmp1 = np.sin((self.phiref[i] - self.phimaxref[i]) * self.phiScale[i])\n tmp2 = np.sin((self.angJoi[i] - self.phimaxref[i]) * self.phiScale[i])\n tmpL[i] = self.dirAng[i] * (tmp2 - tmp1) * self.r[i] * self.rho[i] / self.phiScale[i]\n self.levelArm[i] = np.cos((self.angJoi[i] - self.phimaxref[i]) * self.phiScale[i]) * self.r[i]\n else:\n raise ValueError('Invalid muscle level arm offset correction type. ')\n self.lmtc = self.lslack + self.lopt + np.sum(tmpL)\n\n # update muscle activation\n # integration, forward-Euler method\n # self.act = (self.stim - self.act) * self.timestep / self.tau + self.act\n # integration, trapezoidal method, 2-step\n self.act = (self.stim - self.actsubstep) * self.timestep / 2.0 / self.tau + self.actsubstep\n self.actsubstep = (self.stim - self.act) * self.timestep / 2.0 / self.tau + self.act\n\n # update lce and lse based on the lmtc\n # integration, forward-Euler method\n # self.lce = self.vce * self.timestep + self.lce\n # integration, trapezoidal method, 2-step\n self.lce = self.vce * self.timestep / 2.0 + self.lcesubstep\n self.lcesubstep = self.vce * self.timestep / 2.0 + self.lce\n\n self.lse = self.lmtc - self.lce\n self.Lse = self.lse / self.lslack\n self.Lce = self.lce / self.lopt\n\n # Serial Elastic element (tendon) force-length relationship\n if self.Lse > 1.0:\n Fse = np.power((self.Lse - 1.0) / self.eref, 2)\n else:\n Fse = 0.0\n\n # Parallel Elasticity PE\n if self.Lce > 1.0:\n Fpe = np.power((self.Lce - 1.0) / self.w, 2)\n else:\n Fpe = 0.0\n\n # update frcmtc\n self.frcmtc = Fse * self.frcmax\n #self.frcmtc = np.clip(self.frcmtc, 0, self.frcmax)\n\n # Buffer Elasticity BE\n if (self.Lce - (1.0 - self.w)) < 0:\n Fbe = np.power((self.Lce - (1.0 - self.w)) / (self.w / 2), 2)\n else:\n Fbe = 0.0\n\n # Contractile Element force-length relationship\n tmp = np.power(np.absolute(self.Lce - 1.0) / self.w, 3)\n Fce = np.exp(tmp * np.log(self.c))\n\n #Fv = (Fse + Fbe) / (Fpe + Fce * self.act)\n if (Fpe + Fce * self.act) < 1e-10: # avoid numerical error\n if (Fse + Fbe) < 1e-10:\n Fv = 1.0\n else:\n Fv = (Fse + Fbe) / 1e-10\n else:\n Fv = (Fse + Fbe) / (Fpe + Fce * self.act)\n\n # Contractile Element inverse force-velocity relationship\n if Fv <= 1.0:\n # Concentric\n v = (Fv - 1) / (Fv * self.K + 1.0)\n elif Fv <= self.N:\n # excentric\n tmp = (Fv - self.N) / (self.N - 1.0)\n v = (tmp + 1.0) / (1.0 - tmp * 7.56 * self.K)\n else:\n # excentric overshoot\n v = ((Fv - self.N) * 0.01 + 1)\n\n self.vce = v * self.lopt * self.vmax\n v_frac = self.vce / self.vmax\n mr_scale = self.act * np.absolute(self.frcmax*self.vmax) *self.timestep\n if self.vce <= 1:\n self.MR = 0.01 - 0.11*(v_frac) + 0.06*np.exp(-8*v_frac)\n else:\n self.MR = 0.23 - 0.16*np.exp(-8*v_frac) \n self.MR *= mr_scale\n self.frame += 1\n self.lce_avg = (self.lce_avg*(self.frame - 1) + self.lce) / self.frame\n self.vce_avg = (self.vce_avg*(self.frame - 1) + self.vce) / self.frame\n self.frcmtc_avg = (self.frcmtc_avg*(self.frame - 1) + self.frcmtc) / self.frame\n self.act_avg = (self.act_avg*(self.frame - 1) + self.act) / self.frame\n #self.MR = np.exp(-self.MR)\n # print(self.MR, np.exp(-self.MR))\n # self.Fv = Fv\n # self.Fse = Fse\n # self.Fbe = Fbe\n # self.Fpe = Fpe\n # self.Fce = Fce\n\n def reset_state(self):\n self.frame = 0\n self.lce_avg = 0\n self.frcmtc_avg = 0\n self.act_avg = 0\n self.vce_avg = 0\n\n", "meta": {"hexsha": "4fda88e07a7d5763add5321ef0cfe0319e550f49", "size": 7802, "ext": "py", "lang": "Python", "max_stars_repo_path": "mushroom_rl/environments/mujoco_envs/humanoid_gait/_external_simulation/mtc_model.py", "max_stars_repo_name": "PuzeLiu/mushroom-rl", "max_stars_repo_head_hexsha": "99942b425e66b4ddcc26009d7105dde23841e95d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 344, "max_stars_repo_stars_event_min_datetime": "2020-01-10T09:45:02.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T09:48:28.000Z", "max_issues_repo_path": "mushroom_rl/environments/mujoco_envs/humanoid_gait/_external_simulation/mtc_model.py", "max_issues_repo_name": "AmmarFahmy/mushroom-rl", "max_issues_repo_head_hexsha": "2625ee7f64d5613b3b9fba00f0b7a39fece88ca5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 44, "max_issues_repo_issues_event_min_datetime": "2020-01-23T03:00:56.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-25T17:14:22.000Z", "max_forks_repo_path": "mushroom_rl/environments/mujoco_envs/humanoid_gait/_external_simulation/mtc_model.py", "max_forks_repo_name": "AmmarFahmy/mushroom-rl", "max_forks_repo_head_hexsha": "2625ee7f64d5613b3b9fba00f0b7a39fece88ca5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 93, "max_forks_repo_forks_event_min_datetime": "2020-01-10T21:17:58.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T17:58:52.000Z", "avg_line_length": 41.5, "max_line_length": 120, "alphanum_fraction": 0.5697257114, "include": true, "reason": "import numpy", "num_tokens": 2423, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7025300573952052, "lm_q2_score": 0.2782567877172032, "lm_q1q2_score": 0.1954837570455722}} {"text": "\nimport sys, os\ncur_file_path = os.path.dirname(os.path.realpath(__file__))\nsys.path.append(os.path.join(cur_file_path, '..'))\n\nimport shutil, glob\nimport os.path as osp\nimport cv2\nimport numpy as np\nimport json\nimport torch\n\nfrom body_model.body_model import BodyModel\n\nfrom utils.transforms import rotation_matrix_to_angle_axis, batch_rodrigues, convert_to_rotmat\nfrom utils.logging import mkdir, Logger\n\nNSTAGES = 3 # number of stages in the optimization\nDEFAULT_FOCAL_LEN = (1060.531764702488, 1060.3856705041237) # fx, fy\n\ndef read_keypoints(keypoint_fn):\n '''\n Only reads body keypoint data of first person.\n '''\n with open(keypoint_fn) as keypoint_file:\n data = json.load(keypoint_file)\n\n if len(data['people']) == 0:\n print('WARNING: Found no keypoints in %s! Returning zeros!' % (keypoint_fn))\n return np.zeros((OP_NUM_JOINTS, 3), dtype=np.float)\n\n person_data = data['people'][0]\n body_keypoints = np.array(person_data['pose_keypoints_2d'],\n dtype=np.float)\n body_keypoints = body_keypoints.reshape([-1, 3])\n\n return body_keypoints\n\ndef resize_points(points_arr, num_pts):\n '''\n Either randomly subsamples or pads the given points_arr to be of the desired size.\n - points_arr : N x 3\n - num_pts : desired num point \n '''\n is_torch = isinstance(points_arr, torch.Tensor)\n N = points_arr.size(0) if is_torch else points_arr.shape[0]\n if N > num_pts:\n samp_inds = np.random.choice(np.arange(N), size=num_pts, replace=False)\n points_arr = points_arr[samp_inds]\n elif N < num_pts:\n while N < num_pts:\n pad_size = num_pts - N\n if is_torch:\n points_arr = torch.cat([points_arr, points_arr[:pad_size]], dim=0)\n N = points_arr.size(0)\n else:\n points_arr = np.concatenate([points_arr, points_arr[:pad_size]], axis=0)\n N = points_arr.shape[0]\n return points_arr\n\ndef compute_plane_intersection(point, direction, plane):\n '''\n Given a ray defined by a point in space and a direction, compute the intersection point with the given plane.\n Detect intersection in either direction or -direction so the given ray may not actually intersect with the plane.\n\n Returns the intersection point as well as s such that point + s*direction = intersection_point. if s < 0 it means\n -direction intersects.\n\n - point : B x 3\n - direction : B x 3\n - plane : B x 4 (a, b, c, d) where (a, b, c) is the normal and (d) the offset.\n '''\n plane_normal = plane[:,:3]\n plane_off = plane[:,3]\n s = (plane_off - bdot(plane_normal, point)) / bdot(plane_normal, direction)\n itsct_pt = point + s.reshape((-1, 1))*direction\n return itsct_pt, s\n\ndef bdot(A1, A2, keepdim=False):\n ''' \n Batched dot product.\n - A1 : B x D\n - A2 : B x D.\n Returns B.\n '''\n return (A1*A2).sum(dim=-1, keepdim=keepdim) \n\ndef parse_floor_plane(floor_plane):\n '''\n Takes floor plane in the optimization form (Bx3 with a,b,c * d) and parses into\n (a,b,c,d) from with (a,b,c) normal facing \"up in the camera frame and d the offset.\n '''\n floor_offset = torch.norm(floor_plane, dim=1, keepdim=True)\n floor_normal = floor_plane / floor_offset\n \n # in camera system -y is up, so floor plane normal y component should never be positive\n # (assuming the camera is not sideways or upside down)\n neg_mask = floor_normal[:,1:2] > 0.0\n floor_normal = torch.where(neg_mask.expand_as(floor_normal), -floor_normal, floor_normal)\n floor_offset = torch.where(neg_mask, -floor_offset, floor_offset)\n floor_plane_4d = torch.cat([floor_normal, floor_offset], dim=1)\n\n return floor_plane_4d\n\ndef load_planercnn_res(res_path):\n '''\n Given a directory containing PlaneRCNN plane detection results, loads the first image result \n and heuristically finds and returns the floor plane.\n '''\n planes_param_path = glob.glob(res_path + '/*_plane_parameters_*.npy')[0]\n planes_mask_path = glob.glob(res_path + '/*_plane_masks_*.npy')[0]\n planes_params = np.load(planes_param_path)\n planes_masks = np.load(planes_mask_path)\n \n # heuristically determine the ground plane\n # the plane with the most labeled pixels in the bottom N rows\n nrows = 10\n label_count = np.sum(planes_masks[:, -nrows:, :], axis=(1, 2))\n floor_idx = np.argmax(label_count)\n valid_floor = False\n floor_plane = None\n while not valid_floor:\n # loop until we find a plane with many pixels on the bottom\n # and doesn't face in the complete wrong direction\n # we assume the y component is larger than any others\n # i.e. that the floor is not > 45 degrees relative rotation from the camera\n floor_plane = planes_params[floor_idx]\n # transform to our system\n floor_plane = np.array([floor_plane[0], -floor_plane[2], floor_plane[1]])\n # determine 4D parameterization\n # for this data we know y should always be negative\n floor_offset = np.linalg.norm(floor_plane)\n floor_normal = floor_plane / floor_offset\n if floor_normal[1] > 0.0:\n floor_offset *= -1.0\n floor_normal *= -1.0\n a, b, c = floor_normal\n d = floor_offset\n floor_plane = np.array([a, b, c, d])\n\n valid_floor = np.abs(b) > np.abs(a) and np.abs(b) > np.abs(c)\n if not valid_floor:\n label_count[floor_idx] = 0\n floor_idx = np.argmax(label_count)\n\n return floor_plane\n\n\ndef compute_cam2prior(floor_plane, trans, root_orient, joints):\n '''\n Computes rotation and translation from the camera frame to the canonical coordinate system\n used by the motion and initial state priors.\n - floor_plane : B x 3\n - trans : B x 3\n - root_orient : B x 3\n - joints : B x J x 3\n '''\n B = floor_plane.size(0)\n if floor_plane.size(1) == 3:\n floor_plane_4d = parse_floor_plane(floor_plane)\n else:\n floor_plane_4d = floor_plane\n floor_normal = floor_plane_4d[:,:3]\n floor_trans, _ = compute_plane_intersection(trans, -floor_normal, floor_plane_4d)\n\n # compute prior frame axes within the camera frame\n # up is the floor_plane normal\n up_axis = floor_normal\n # right is body -x direction projected to floor plane\n root_orient_mat = batch_rodrigues(root_orient)\n body_right = -root_orient_mat[:, :, 0]\n floor_body_right, s = compute_plane_intersection(trans, body_right, floor_plane_4d)\n right_axis = floor_body_right - floor_trans \n # body right may not actually intersect - in this case must negate axis because we have the -x\n right_axis = torch.where(s.reshape((B, 1)) < 0, -right_axis, right_axis)\n right_axis = right_axis / torch.norm(right_axis, dim=1, keepdim=True)\n # forward is their cross product\n fwd_axis = torch.cross(up_axis, right_axis)\n fwd_axis = fwd_axis / torch.norm(fwd_axis, dim=1, keepdim=True)\n\n prior_R = torch.stack([right_axis, fwd_axis, up_axis], dim=2)\n cam2prior_R = prior_R.transpose(2, 1)\n\n # translation takes translation to origin plus offset to the floor\n cam2prior_t = -trans\n\n _, s_root = compute_plane_intersection(joints[:,0], -floor_normal, floor_plane_4d)\n root_height = s_root.reshape((B, 1))\n\n return cam2prior_R, cam2prior_t, root_height\n\ndef apply_robust_weighting(res, robust_loss_type='bisquare', robust_tuning_const=4.6851):\n '''\n Returns robustly weighted squared residuals.\n - res : torch.Tensor (B x N), take the MAD over each batch dimension independently.\n '''\n robust_choices = ['none', 'bisquare']\n if robust_loss_type not in robust_choices:\n print('Not a valid robust loss: %s. Please use %s' % (robust_loss_type, str(robust_choices)))\n \n w = None\n detach_res = res.clone().detach() # don't want gradients flowing through the weights to avoid degeneracy\n if robust_loss_type == 'none':\n w = torch.ones_like(detach_res)\n elif robust_loss_type == 'bisquare':\n w = bisquare_robust_weights(detach_res, tune_const=robust_tuning_const)\n\n # apply weights to squared residuals\n weighted_sqr_res = w * (res**2)\n return weighted_sqr_res, w\n\ndef robust_std(res):\n ''' \n Compute robust estimate of standarad deviation using median absolute deviation (MAD)\n of the given residuals independently over each batch dimension.\n\n - res : (B x N)\n\n Returns:\n - std : B x 1\n '''\n B = res.size(0)\n med = torch.median(res, dim=-1)[0].reshape((B,1))\n abs_dev = torch.abs(res - med)\n MAD = torch.median(abs_dev, dim=-1)[0].reshape((B, 1))\n std = MAD / 0.67449\n return std\n\ndef bisquare_robust_weights(res, tune_const=4.6851):\n '''\n Bisquare (Tukey) loss.\n See https://www.mathworks.com/help/curvefit/least-squares-fitting.html\n\n - residuals\n '''\n # print(res.size())\n norm_res = res / (robust_std(res) * tune_const)\n # NOTE: this should use absolute value, it's ok right now since only used for 3d point cloud residuals\n # which are guaranteed positive, but generally this won't work)\n outlier_mask = norm_res >= 1.0\n\n # print(torch.sum(outlier_mask))\n # print('Outlier frac: %f' % (float(torch.sum(outlier_mask)) / res.size(1)))\n\n w = (1.0 - norm_res**2)**2\n w[outlier_mask] = 0.0\n\n return w\n\ndef gmof(res, sigma):\n \"\"\"\n Geman-McClure error function\n - residual\n - sigma scaling factor\n \"\"\"\n x_squared = res ** 2\n sigma_squared = sigma ** 2\n return (sigma_squared * x_squared) / (sigma_squared + x_squared)\n\n\ndef log_cur_stats(stats_dict, loss, iter=None):\n Logger.log('LOSS: %f' % (loss.cpu().item()))\n print('----')\n for k, v in stats_dict.items():\n if isinstance(v, float):\n Logger.log('%s: %f' % (k, v))\n else:\n Logger.log('%s: %f' % (k, v.cpu().item()))\n if iter is not None:\n print('======= iter %d =======' % (int(iter)))\n else:\n print('========')\n\ndef save_optim_result(cur_res_out_paths, optim_result, per_stage_results, gt_data, observed_data, data_type,\n optim_floor=True,\n obs_img_paths=None,\n obs_mask_paths=None):\n # final optim results\n res_betas = optim_result['betas'].cpu().numpy()\n res_trans = optim_result['trans'].cpu().numpy()\n res_root_orient = optim_result['root_orient'].cpu().numpy()\n res_body_pose = optim_result['pose_body'].cpu().numpy()\n res_contacts = None\n res_floor_plane = None\n if 'contacts' in optim_result:\n res_contacts = optim_result['contacts'].cpu().numpy()\n if 'floor_plane' in optim_result:\n res_floor_plane = optim_result['floor_plane'].cpu().numpy()\n for bidx, cur_res_out_path in enumerate(cur_res_out_paths):\n cur_res_out_path = os.path.join(cur_res_out_path, 'stage3_results.npz')\n save_dict = { \n 'betas' : res_betas[bidx],\n 'trans' : res_trans[bidx],\n 'root_orient' : res_root_orient[bidx],\n 'pose_body' : res_body_pose[bidx]\n }\n if res_contacts is not None:\n save_dict['contacts'] = res_contacts[bidx]\n if res_floor_plane is not None:\n save_dict['floor_plane'] = res_floor_plane[bidx]\n np.savez(cur_res_out_path, **save_dict)\n\n # in prior coordinate frame\n if 'stage3' in per_stage_results and optim_floor:\n res_trans = per_stage_results['stage3']['prior_trans'].detach().cpu().numpy()\n res_root_orient = per_stage_results['stage3']['prior_root_orient'].detach().cpu().numpy()\n for bidx, cur_res_out_path in enumerate(cur_res_out_paths):\n cur_res_out_path = os.path.join(cur_res_out_path, 'stage3_results_prior.npz')\n save_dict = { \n 'betas' : res_betas[bidx],\n 'trans' : res_trans[bidx],\n 'root_orient' : res_root_orient[bidx],\n 'pose_body' : res_body_pose[bidx]\n }\n if res_contacts is not None:\n save_dict['contacts'] = res_contacts[bidx]\n np.savez(cur_res_out_path, **save_dict)\n\n # ground truth\n save_gt = 'betas' in gt_data and \\\n 'trans' in gt_data and \\\n 'root_orient' in gt_data and \\\n 'pose_body' in gt_data\n if save_gt:\n gt_betas = gt_data['betas'].cpu().numpy()\n if data_type not in ['PROX-RGB', 'PROX-RGBD']:\n gt_betas = gt_betas[:,0] # only need frame 1 for e.g. 3d data since it's the same over time.\n gt_trans = gt_data['trans'].cpu().numpy()\n gt_root_orient = gt_data['root_orient'].cpu().numpy()\n gt_body_pose = gt_data['pose_body'].cpu().numpy()\n gt_contacts = None\n if 'contacts' in gt_data:\n gt_contacts = gt_data['contacts'].cpu().numpy()\n cam_mat = None\n if 'cam_matx' in gt_data:\n cam_mat = gt_data['cam_matx'].cpu().numpy()\n for bidx, cur_res_out_path in enumerate(cur_res_out_paths):\n gt_res_name = 'proxd_results.npz' if data_type in ['PROX-RGB', 'PROX-RGBD'] else 'gt_results.npz'\n cur_gt_out_path = os.path.join(cur_res_out_path, gt_res_name)\n save_dict = { \n 'betas' : gt_betas[bidx],\n 'trans' : gt_trans[bidx],\n 'root_orient' : gt_root_orient[bidx],\n 'pose_body' : gt_body_pose[bidx]\n }\n if gt_contacts is not None:\n save_dict['contacts'] = gt_contacts[bidx]\n if cam_mat is not None:\n save_dict['cam_mtx'] = cam_mat[bidx]\n np.savez(cur_gt_out_path, **save_dict)\n\n # if these are proxd results also need to save a GT with cam matrix\n if data_type in ['PROX-RGB', 'PROX-RGBD']:\n cur_gt_out_path = os.path.join(cur_res_out_path, 'gt_results.npz')\n np.savez(cur_gt_out_path, cam_mtx=cam_mat[bidx])\n\n elif 'joints3d' in gt_data:\n # don't have smpl params, but have 3D joints (e.g. imapper)\n gt_joints = gt_data['joints3d'].cpu().numpy()\n cam_mat = occlusions = None\n if 'cam_matx' in gt_data:\n cam_mat = gt_data['cam_matx'].cpu().numpy()\n if 'occlusions' in gt_data:\n occlusions = gt_data['occlusions'].cpu().numpy()\n for bidx, cur_res_out_path in enumerate(cur_res_out_paths):\n cur_res_out_path = os.path.join(cur_res_out_path, 'gt_results.npz')\n save_dict = { \n 'joints3d' : gt_joints[bidx]\n }\n if cam_mat is not None:\n save_dict['cam_mtx'] = cam_mat[bidx]\n if occlusions is not None:\n save_dict['occlusions'] = occlusions[bidx]\n np.savez(cur_res_out_path, **save_dict)\n elif 'cam_matx' in gt_data:\n # need the intrinsics even if we have nothing else\n cam_mat = gt_data['cam_matx'].cpu().numpy()\n for bidx, cur_res_out_path in enumerate(cur_res_out_paths):\n cur_res_out_path = os.path.join(cur_res_out_path, 'gt_results.npz')\n save_dict = { \n 'cam_mtx' : cam_mat[bidx]\n }\n np.savez(cur_res_out_path, **save_dict)\n\n # observations\n obs_out = {k : v.cpu().numpy() for k, v in observed_data.items() if k != 'prev_batch_overlap_res'}\n for bidx, cur_res_out_path in enumerate(cur_res_out_paths):\n obs_out_path = os.path.join(cur_res_out_path, 'observations.npz')\n cur_obs_out = {k : v[bidx] for k, v in obs_out.items() if k not in ['RGB']}\n if obs_img_paths is not None:\n cur_obs_out['img_paths'] = [frame_tup[bidx] for frame_tup in obs_img_paths]\n # print(cur_obs_out['img_paths'])\n if obs_mask_paths is not None:\n cur_obs_out['mask_paths'] = [frame_tup[bidx] for frame_tup in obs_mask_paths]\n np.savez(obs_out_path, **cur_obs_out) \n\n\ndef save_rgb_stitched_result(seq_intervals, all_res_out_paths, res_out_path, device,\n body_model_path, num_betas, use_joints2d):\n import cv2\n seq_overlaps = [0]\n for int_idx in range(len(seq_intervals)-1):\n prev_end = seq_intervals[int_idx][1]\n cur_start = seq_intervals[int_idx+1][0]\n seq_overlaps.append(prev_end - cur_start)\n\n # if arbitray RGB video data, stitch together to save full sequence output\n all_res_dirs = all_res_out_paths\n print(all_res_dirs)\n\n final_res_out_path = os.path.join(res_out_path, 'final_results')\n mkdir(final_res_out_path)\n\n concat_cam_res = None\n concat_contacts = None\n concat_ground_planes = None\n concat_joints2d = None\n concat_img_paths = None\n gt_cam_mtx = None\n for res_idx, res_dir in enumerate(all_res_dirs):\n # camera view\n cur_stage3_res = load_res(res_dir, 'stage3_results.npz')\n cur_contacts = torch.Tensor(cur_stage3_res['contacts']).to(device)\n if concat_ground_planes is None: \n concat_ground_planes = torch.Tensor(cur_stage3_res['floor_plane']).to(device).reshape((1, -1))\n else:\n concat_ground_planes = torch.cat([concat_ground_planes, torch.Tensor(cur_stage3_res['floor_plane']).to(device).reshape((1, -1))], dim=0)\n cur_stage3_res = {k : v for k, v in cur_stage3_res.items() if k in ['betas', 'trans', 'root_orient', 'pose_body']}\n cur_stage3_res = prep_res(cur_stage3_res, device, cur_stage3_res['trans'].shape[0])\n if concat_cam_res is None: \n concat_cam_res = cur_stage3_res\n concat_contacts = cur_contacts\n else:\n for k, v in concat_cam_res.items():\n concat_cam_res[k] = torch.cat([concat_cam_res[k], cur_stage3_res[k][seq_overlaps[res_idx]:]], dim=0)\n concat_contacts = torch.cat([concat_contacts, cur_contacts[seq_overlaps[res_idx]:]], dim=0)\n\n # gt\n if gt_cam_mtx is None:\n gt_res = load_res(res_dir, 'gt_results.npz')\n gt_cam_mtx = gt_res['cam_mtx']\n\n # obs\n cur_obs = load_res(res_dir, 'observations.npz')\n if concat_joints2d is None:\n concat_joints2d = cur_obs['joints2d']\n else:\n concat_joints2d = np.concatenate([concat_joints2d, cur_obs['joints2d'][seq_overlaps[res_idx]:]], axis=0)\n if concat_img_paths is None:\n concat_img_paths = list(cur_obs['img_paths'])\n else:\n concat_img_paths = concat_img_paths + list(cur_obs['img_paths'][seq_overlaps[res_idx]:])\n \n # ignore if we don't have an interval for this directory (was an extra due to even batching requirement)\n if res_idx >= len(seq_overlaps):\n break\n\n # copy meta\n src_meta_path = os.path.join(all_res_dirs[0], 'meta.txt')\n shutil.copyfile(src_meta_path, os.path.join(final_res_out_path, 'meta.txt'))\n\n # gt results (cam matx)\n np.savez(os.path.join(final_res_out_path, 'gt_results.npz'), cam_mtx=gt_cam_mtx)\n\n # obs results (joints2d and img_paths)\n np.savez(os.path.join(final_res_out_path, 'observations.npz'), joints2d=concat_joints2d, img_paths=concat_img_paths)\n\n # save the actual results npz for viz later\n concat_res_out_path = os.path.join(final_res_out_path, 'stage3_results.npz')\n res_betas = concat_cam_res['betas'].clone().detach().cpu().numpy()\n res_trans = concat_cam_res['trans'].clone().detach().cpu().numpy()\n res_root_orient = concat_cam_res['root_orient'].clone().detach().cpu().numpy()\n res_body_pose = concat_cam_res['pose_body'].clone().detach().cpu().numpy()\n res_floor_plane = concat_ground_planes[0].clone().detach().cpu().numpy() # NOTE: saves estimate from first subsequence\n res_contacts = concat_contacts.clone().detach().cpu().numpy()\n np.savez(concat_res_out_path, betas=res_betas,\n trans=res_trans,\n root_orient=res_root_orient,\n pose_body=res_body_pose,\n floor_plane=res_floor_plane,\n contacts=res_contacts)\n\n # get body model\n num_viz_frames = concat_cam_res['trans'].size(0)\n viz_body_model = BodyModel(bm_path=body_model_path,\n num_betas=num_betas,\n batch_size=num_viz_frames,\n use_vtx_selector=use_joints2d).to(device)\n viz_body = run_smpl(concat_cam_res, viz_body_model)\n \n # transform full camera-frame sequence into a shared prior frame based on a single ground plane\n viz_joints3d = viz_body.Jtr\n # compute the transformation based on t=0 and the first sequence floor plane\n cam2prior_R, cam2prior_t, cam2prior_root_height = compute_cam2prior(concat_ground_planes[0].unsqueeze(0),\n concat_cam_res['trans'][0].unsqueeze(0),\n concat_cam_res['root_orient'][0].unsqueeze(0),\n viz_joints3d[0].unsqueeze(0))\n # transform the whole sequence\n input_data_dict = {kb : vb.unsqueeze(0) for kb, vb in concat_cam_res.items() if kb in ['trans', 'root_orient', 'pose_body', 'betas']}\n viz_prior_data_dict = apply_cam2prior(input_data_dict, cam2prior_R, cam2prior_t, cam2prior_root_height, \n input_data_dict['pose_body'],\n input_data_dict['betas'],\n 0,\n viz_body_model)\n concat_prior_res = {\n 'trans' : viz_prior_data_dict['trans'][0],\n 'root_orient' : viz_prior_data_dict['root_orient'][0],\n 'pose_body' : concat_cam_res['pose_body'],\n 'betas' : concat_cam_res['betas']\n }\n\n # save pose prior frame\n concat_prior_res_out_path = os.path.join(final_res_out_path, 'stage3_results_prior.npz')\n res_betas = concat_prior_res['betas'].clone().detach().cpu().numpy()\n res_trans = concat_prior_res['trans'].clone().detach().cpu().numpy()\n res_root_orient = concat_prior_res['root_orient'].clone().detach().cpu().numpy()\n res_body_pose = concat_prior_res['pose_body'].clone().detach().cpu().numpy()\n res_contacts = concat_contacts.clone().detach().cpu().numpy()\n np.savez(concat_prior_res_out_path, betas=res_betas,\n trans=res_trans,\n root_orient=res_root_orient,\n pose_body=res_body_pose,\n contacts=res_contacts)\n\n\ndef load_res(result_dir, file_name):\n '''\n Load np result from our model or GT\n '''\n res_path = os.path.join(result_dir, file_name)\n if not os.path.exists(res_path):\n return None\n res = np.load(res_path)\n res_dict = {k : res[k] for k in res.files}\n return res_dict\n\ndef prep_res(np_res, device, T):\n '''\n Load np result dict into dict of torch objects for use with SMPL body model.\n '''\n betas = np_res['betas']\n betas = torch.Tensor(betas).to(device)\n if len(betas.size()) == 1:\n num_betas = betas.size(0)\n betas = betas.reshape((1, num_betas)).expand((T, num_betas))\n else:\n num_betas = betas.size(1)\n assert(betas.size(0) == T)\n trans = np_res['trans']\n trans = torch.Tensor(trans).to(device)\n root_orient = np_res['root_orient']\n root_orient = torch.Tensor(root_orient).to(device)\n pose_body = np_res['pose_body']\n pose_body = torch.Tensor(pose_body).to(device)\n\n res_dict = {\n 'betas' : betas,\n 'trans' : trans,\n 'root_orient' : root_orient,\n 'pose_body' : pose_body\n }\n\n for k, v in np_res.items():\n if k not in ['betas', 'trans', 'root_orient', 'pose_body']:\n res_dict[k] = v\n return res_dict\n\ndef run_smpl(res_dict, body_model):\n smpl_body = body_model(pose_body=res_dict['pose_body'], \n pose_hand=None, \n betas=res_dict['betas'],\n root_orient=res_dict['root_orient'],\n trans=res_dict['trans'])\n return smpl_body\n\ndef apply_cam2prior(data_dict, R, t, root_height, body_pose, betas, key_frame_idx, body_model, inverse=False):\n '''\n Applies the camera2prior tranformation made up of R, t to the data in data dict and\n returns a new dictionary with the transformed data.\n Right now supports: trans, root_orient.\n\n NOTE: If the number of timesteps in trans/root_orient is 1, this function assumes they are at key_frame_idx.\n (othherwise the calculation of cur_root_height or trans_offset in inverse case is not correct)\n\n key_frame_idx : the timestep used to compute cam2prior size (B) tensor\n inverse : if true, applies the inverse transformation from prior space to camera\n '''\n prior_dict = dict()\n if 'root_orient' in data_dict:\n # B x T x 3\n root_orient = data_dict['root_orient']\n B, T, _ = root_orient.size()\n R_time = R.unsqueeze(1).expand((B, T, 3, 3))\n t_time = t.unsqueeze(1).expand((B, T, 3))\n root_orient_mat = batch_rodrigues(root_orient.reshape((-1, 3))).reshape((B, T, 3, 3))\n if inverse:\n prior_root_orient_mat = torch.matmul(R_time.transpose(3, 2), root_orient_mat)\n else:\n prior_root_orient_mat = torch.matmul(R_time, root_orient_mat)\n prior_root_orient = rotation_matrix_to_angle_axis(prior_root_orient_mat.reshape((B*T, 3, 3))).reshape((B, T, 3))\n prior_dict['root_orient'] = prior_root_orient\n\n if 'trans' in data_dict and 'root_orient' in data_dict:\n # B x T x 3\n trans = data_dict['trans']\n B, T, _ = trans.size()\n R_time = R.unsqueeze(1).expand((B, T, 3, 3))\n t_time = t.unsqueeze(1).expand((B, T, 3))\n if inverse:\n # transform so key frame at origin\n if T > 1:\n trans_offset = trans[np.arange(B),key_frame_idx,:].unsqueeze(1)\n else:\n trans_offset = trans[:,0:1,:]\n trans = trans - trans_offset\n # rotates to camera frame\n trans = torch.matmul(R_time.transpose(3, 2), trans.reshape((B, T, 3, 1)))[:,:,:,0]\n # translate to camera frame\n trans = trans - t_time\n else:\n # first transform so the trans of key frame is at origin\n trans = trans + t_time\n # then rotate to canonical frame\n trans = torch.matmul(R_time, trans.reshape((B, T, 3, 1)))[:,:,:,0]\n # then apply floor offset so the root joint is at the desired height\n cur_smpl_body = body_model(pose_body=body_pose.reshape((-1, body_pose.size(2))), \n pose_hand=None, \n betas=betas.reshape((-1, betas.size(2))),\n root_orient=prior_dict['root_orient'].reshape((-1, 3)),\n trans=trans.reshape((-1, 3)))\n smpl_joints3d = cur_smpl_body.Jtr.reshape((B, T, -1, 3))\n if T > 1:\n cur_root_height = smpl_joints3d[np.arange(B),key_frame_idx,0,2:3]\n else:\n cur_root_height = smpl_joints3d[:,0,0,2:3]\n height_diff = root_height - cur_root_height\n trans_offset = torch.cat([torch.zeros((B, 2)).to(height_diff), height_diff], axis=1)\n trans = trans + trans_offset.reshape((B, 1, 3))\n prior_dict['trans'] = trans\n elif 'trans' in data_dict:\n Logger.log('Cannot apply cam2prior on translation without root orient data!')\n exit()\n\n return prior_dict\n\n\ndef perspective_projection(points, rotation, translation,\n focal_length, camera_center):\n \"\"\"\n Adapted from https://github.com/mkocabas/VIBE/blob/master/lib/models/spin.py\n This function computes the perspective projection of a set of points.\n Input:\n points (bs, N, 3): 3D points\n rotation (bs, 3, 3): Camera rotation\n translation (bs, 3): Camera translation\n focal_length (bs, 2): Focal length\n camera_center (bs, 2): Camera center\n \"\"\"\n batch_size = points.shape[0]\n K = torch.zeros([batch_size, 3, 3], device=points.device)\n K[:,0,0] = focal_length[:,0]\n K[:,1,1] = focal_length[:,1]\n K[:,2,2] = 1.\n K[:,:-1, -1] = camera_center\n\n # Transform points\n points = torch.einsum('bij,bkj->bki', rotation, points)\n points = points + translation.unsqueeze(1)\n\n # Apply perspective distortion\n projected_points = points / points[:,:,-1].unsqueeze(-1)\n\n # Apply camera intrinsics\n projected_points = torch.einsum('bij,bkj->bki', K, projected_points)\n\n return projected_points[:, :, :-1]\n\nOP_NUM_JOINTS = 25\nOP_IGNORE_JOINTS = [1, 9, 12] # neck and left/right hip\nOP_EDGE_LIST = [[1,8], [1,2], [1,5], [2,3], [3,4], [5,6], [6,7], [8,9], [9,10], [10,11], [8,12], [12,13], [13,14], [1,0], [0,15], [15,17], [0,16], [16,18], [14,19], [19,20], [14,21], [11,22], [22,23], [11,24]]\n# indices to map an openpose detection to its flipped version\nOP_FLIP_MAP = [0, 1, 5, 6, 7, 2, 3, 4, 8, 12, 13, 14, 9, 10, 11, 16, 15, 18, 17, 22, 23, 24, 19, 20, 21]\n\n#\n# The following 2 functions are borrowed from VPoser (https://github.com/nghorbani/human_body_prior).\n# See their license for usage restrictions.\n#\ndef expid2model(expr_dir):\n from configer import Configer\n\n if not os.path.exists(expr_dir): raise ValueError('Could not find the experiment directory: %s' % expr_dir)\n\n best_model_fname = sorted(glob.glob(os.path.join(expr_dir, 'snapshots', '*.pt')), key=os.path.getmtime)[-1]\n try_num = os.path.basename(best_model_fname).split('_')[0]\n\n print(('Found Trained Model: %s' % best_model_fname))\n\n default_ps_fname = glob.glob(os.path.join(expr_dir,'*.ini'))[0]\n if not os.path.exists(\n default_ps_fname): raise ValueError('Could not find the appropriate vposer_settings: %s' % default_ps_fname)\n ps = Configer(default_ps_fname=default_ps_fname, work_dir = expr_dir, best_model_fname=best_model_fname)\n\n return ps, best_model_fname\n\ndef load_vposer(expr_dir, vp_model='snapshot'):\n '''\n :param expr_dir:\n :param vp_model: either 'snapshot' to use the experiment folder's code or a VPoser imported module, e.g.\n from human_body_prior.train.vposer_smpl import VPoser, then pass VPoser to this function\n :param if True will load the model definition used for training, and not the one in current repository\n :return:\n '''\n import importlib\n import os\n import torch\n\n ps, trained_model_fname = expid2model(expr_dir)\n if vp_model == 'snapshot':\n\n vposer_path = sorted(glob.glob(os.path.join(expr_dir, 'vposer_*.py')), key=os.path.getmtime)[-1]\n\n spec = importlib.util.spec_from_file_location('VPoser', vposer_path)\n module = importlib.util.module_from_spec(spec)\n spec.loader.exec_module(module)\n\n vposer_pt = getattr(module, 'VPoser')(num_neurons=ps.num_neurons, latentD=ps.latentD, data_shape=ps.data_shape)\n else:\n vposer_pt = vp_model(num_neurons=ps.num_neurons, latentD=ps.latentD, data_shape=ps.data_shape)\n\n vposer_pt.load_state_dict(torch.load(trained_model_fname, map_location='cpu'))\n vposer_pt.eval()\n\n return vposer_pt, ps", "meta": {"hexsha": "90bff9f7f50e4d1380b71c4baf495fa1c7f9f2f4", "size": 31469, "ext": "py", "lang": "Python", "max_stars_repo_path": "humor/fitting/fitting_utils.py", "max_stars_repo_name": "davrempe/humor", "max_stars_repo_head_hexsha": "0577f342863be6190bedbc1f27fe3dd0fecb63db", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 143, "max_stars_repo_stars_event_min_datetime": "2021-10-09T22:10:20.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T01:33:19.000Z", "max_issues_repo_path": "humor/fitting/fitting_utils.py", "max_issues_repo_name": "davrempe/humor", "max_issues_repo_head_hexsha": "0577f342863be6190bedbc1f27fe3dd0fecb63db", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 18, "max_issues_repo_issues_event_min_datetime": "2021-10-12T07:49:39.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-21T09:44:34.000Z", "max_forks_repo_path": "humor/fitting/fitting_utils.py", "max_forks_repo_name": "davrempe/humor", "max_forks_repo_head_hexsha": "0577f342863be6190bedbc1f27fe3dd0fecb63db", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 20, "max_forks_repo_forks_event_min_datetime": "2021-10-10T10:41:12.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-26T02:37:33.000Z", "avg_line_length": 42.931787176, "max_line_length": 209, "alphanum_fraction": 0.6317645937, "include": true, "reason": "import numpy", "num_tokens": 8035, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118791767282, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.1954629594083306}} {"text": "# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Wed Dec 4 11:35:36 2019\n\n@author: aaussel\n\"\"\"\n\nfrom cells.RE_mdPul import *\nfrom cells.TC_mdPul import *\n#from cells.HTC_mdPul import *\nfrom cells.HTC_buffer_mdPul_Destxhe_tests import *\nfrom scipy import signal\n\n\nprefs.codegen.target = 'numpy'\n\n\ndefaultclock.dt = 0.01*ms\nruntime=2*second\n\n\nstart_scope()\n\ndef generate_syn(source,target,syntype,connection_pattern,g_i,taur_i,taud_i,V_i):\n eq_syn='''_post=s_i*g_i*(V_post-V_i) : amp * meter ** -2 (summed)\n ds_i/dt=-s_i/taud_i+(1-s_i)/taur_i*0.5*(1+tanh(V_pre/10/mV)) : 1\n g_i : siemens * meter**-2\n V_i : volt\n taud_i : second\n taur_i : second\n '''\n\n S=Synapses(source,target,model=syntype+eq_syn,method='exact')\n if connection_pattern=='':\n S.connect()\n else :\n S.connect(j=connection_pattern, skip_if_invalid=True)\n S.g_i=g_i\n S.taur_i=taur_i\n S.taud_i=taud_i\n S.V_i=V_i \n return S\n\ndef mon_delay(mon,i,t_delay):\n return mon.V[i][-t_delay]\n\ndef generate_syn_delay(source,target,syntype,connection_pattern,g_i,taur_i,taud_i,V_i):\n eq_syn_delay='''_post=s_i*g_i*(V_post-V_i) : amp * meter ** -2 (summed)\n ds_i/dt=-s_i/taud_i+(1-s_i)/taur_i*0.5*(1+tanh(voltage_delayed_pre/10/mV)) : 1\n g_i : siemens * meter**-2\n V_i : volt\n taud_i : second\n taur_i : second\n '''\n\n S=Synapses(source,target,model=syntype+eq_syn_delay,method='exact')\n if connection_pattern=='':\n S.connect()\n else :\n S.connect(j=connection_pattern, skip_if_invalid=True)\n S.g_i=g_i\n S.taur_i=taur_i\n S.taud_i=taud_i\n S.V_i=V_i \n return S\n\ndef generate_spike_timing(N,f,start_time,end_time=runtime):\n list_time_and_i=[]\n for i in range(N):\n list_time=[(start_time,i)]\n next_spike=list_time[-1][0]+(1+0.1*rand())/f\n while next_spike0*mvolt',refractory=3*ms,method='rk4')\n HTC.V = '-25*mvolt'\n HTC.Ca_iTLT = '1e-7 * mole * metre**-3'\n HTC.Ca_iTHT = '0.01*mmolar'\n HTC.J='0 * uA * cmeter ** -2'\n HTC.mAHP='0.3'\n \n TC=NeuronGroup(N_TC,eq_TC_mdPul,threshold='V>0*mvolt',refractory=3*ms,method='rk4')\n TC.V = '-45*mvolt+20*mvolt*rand()'\n TC.J='0 * nA * cmeter ** -2'\n TC.Ca_i = '1e-7 * mole * metre**-3'\n \n RE=NeuronGroup(N_RE,eq_RE_mdPul,threshold='V>0*mvolt',refractory=3*ms,method='rk4')\n RE.V = '-70*mvolt+20*mvolt*rand()'\n RE.J = '0 * nA * cmeter ** -2'\n RE.Ca_i = '1e-7 * mole * metre**-3'\n\n\n ##Define monitors\n R1=SpikeMonitor(HTC,record=True)\n R2=SpikeMonitor(TC,record=True)\n R3=SpikeMonitor(RE,record=True)\n \n V1=StateMonitor(HTC,'V',record=True)\n V2=StateMonitor(TC,'V',record=True)\n V3=StateMonitor(RE,'V',record=True)\n \n I2=StateMonitor(HTC,'ITHT',record=[0])\n I3=StateMonitor(HTC,'ITLT',record=[0])\n \n \n ##Synapses\n \n gAMPA_HTC_RE= 0.1 * msiemens * cm **-2 #0.42 - 0.70\n gGABA_A_RE_RE = 0.1 * msiemens * cm **-2 #0.42 - 0.70\n gGABA_A_RE_TC = 0.4 * msiemens * cm **-2\n# gGABA_A_RE_TC = 0 * msiemens * cm **-2\n# gGABA_A_HTC_TC = 0.2 * msiemens * cm **-2\n gGABA_A_HTC_TC = 0.2 * msiemens * cm **-2\n gGABA_B_RE_TC= gGABA_A_RE_TC*0.1\n gGABA_A_RE_HTC = 1 * msiemens * cm **-2\n gGABA_B_RE_HTC= 1 * msiemens * cm **-2\n# gGABA_A_RE_HTC = 0 * msiemens * cm **-2\n# gGABA_B_RE_HTC= 0 * msiemens * cm **-2\n \n \n synHTCRE_AMPA=None\n if condition=='mGluR1':\n synHTCRE_AMPA = generate_syn(HTC,RE,'IsynHTC','',gAMPA_HTC_RE,0.125*ms,1*ms,0*mV)\n synHTCRE_AMPA.connect() #all-to-all connection \n\n synRERE_GABA = generate_syn(RE,RE,'IsynREA','',gGABA_A_RE_RE,0.25*ms,5*ms,-80*mV)\n synRETC_A=generate_syn(RE,TC,'IsynREA','',gGABA_A_RE_TC,0.25*ms,5*ms,-80*mV)\n synRETC_B=generate_syn(RE,TC,'IsynREB','',gGABA_B_RE_TC,20*ms,100*ms,-80*mV)\n synREHTC_A=generate_syn(RE,HTC,'IsynREintGABAA','',gGABA_A_RE_HTC,0.25*ms,5*ms,-80*mV)\n synREHTC_B=generate_syn(RE,HTC,'IsynREintGABAB','',gGABA_B_RE_HTC,20*ms,100*ms,-80*mV)\n \n synHTCTC=generate_syn_delay(HTC,TC,'IsynHTC','',gGABA_A_HTC_TC,0.25*ms,5*ms,-80*mV)\n# synHTCTC=generate_syn(HTC,TC,'IsynHTC','',gGABA_A_HTC_TC,0.25*ms,5*ms,-80*mV)\n# if in_mode=='burst':\n# if condition=='mAChR':\n# synHTCTC=generate_syn_delay(HTC,TC,'IsynHTC','',gGABA_A_HTC_TC,0.25*ms,5*ms,-80*mV)\n# # synHTCTC.delay=delayTC\n# \n# if condition=='mGluR1':\n# synHTCTC=generate_syn_delay(HTC,TC,'IsynHTC','',gGABA_A_HTC_TC,0.25*ms,5*ms,-80*mV)\n# # synHTCTC.delay=delayTC\n# else :\n# if condition=='mAChR':\n# synHTCTC=generate_syn(HTC,TC,'IsynHTC','',gGABA_A_HTC_TC,0.25*ms,5*ms,-80*mV)\n# # synHTCTC.delay=delayTC\n# \n# if condition=='mGluR1':\n# synHTCTC=generate_syn(HTC,TC,'IsynHTC','',gGABA_A_HTC_TC,0.25*ms,5*ms,-80*mV)\n# # synHTCTC.delay=delayTC\n \n GJ_HTC=Synapses(HTC,HTC,'''\n w : siemens * meter **-2 # gap junction conductance\n IGJ_post = w * (V_post - V_pre) : amp * meter ** -2 (summed)\n ''')\n GJ_HTC.connect()\n #GJ_HTC.w = 0.003e-3 * siemens * cm **-2\n GJ_HTC.w = 0.08e-3 * siemens * cm **-2\n \n gEPSP_RE = 20 * msiemens * cm **-2 #0.42 - 0.70\n# gEPSP_TC = 0.5 * msiemens * cm **-2 #0.42 - 0.70\n gEPSP_TC = 0 * msiemens * cm **-2 #0.42 - 0.70\n gEPSP_TC2 = 10 * msiemens * cm **-2 #0.42 - 0.70\n gIPSP_TC = -1.5 * gEPSP_TC \n #Inputs : \n inputs_TC=generate_spike_timing(N_TC,100*Hz,0*ms,end_time=3000*ms)\n G_in = SpikeGeneratorGroup(N_TC, inputs_TC[:,1], inputs_TC[:,0]*second)\n Syn_in=Synapses(G_in,TC,on_pre='Vinp=Vhigh')\n Syn_in.connect(j='i')\n TC.ginp_TC=gEPSP_TC\n \n inputs_RE=generate_spike_timing(N_RE,13*Hz,0*ms,end_time=3000*ms)\n G_in2 = SpikeGeneratorGroup(N_RE, inputs_RE[:,1], inputs_RE[:,0]*second)\n Syn_in2=Synapses(G_in2,RE,on_pre='Vinp=Vhigh')\n Syn_in2.connect(j='i')\n \n inputs_TC3=generate_spike_timing(N_TC,13*Hz,0*ms,end_time=3000*ms)\n G_in3 = SpikeGeneratorGroup(N_TC, inputs_TC3[:,1], inputs_TC3[:,0]*second)\n Syn_in3=Synapses(G_in3,TC,on_pre='Vinp=Vhigh')\n Syn_in3.connect(j='i')\n \n# inputs_HTC=generate_spike_timing(N_HTC,13*Hz,0*ms,end_time=3000*ms)\n# G_in4 = SpikeGeneratorGroup(N_HTC, inputs_HTC[:,1], inputs_HTC[:,0]*second)\n# Syn_in4=Synapses(G_in4,HTC,on_pre='Vinp=Vhigh')\n# Syn_in4.connect(j='i') \n# HTC.ginp_HTC=0e-3 * siemens * cm **-2\n \n if theta_phase=='bad':\n RE.ginp_RE=gEPSP_RE\n TC.ginp_TC2=gEPSP_TC2\n \n all_neurons=HTC,TC,RE,G_in,G_in2,G_in3\n all_synapses=synHTCRE_AMPA,synRERE_GABA,synRETC_A,synRETC_B,synREHTC_A,synREHTC_B,synHTCTC,Syn_in,Syn_in2,Syn_in3\n all_synapses=tuple([y for y in all_synapses if y])\n all_monitors=R1,R2,R3,V1,V2,V3,I2,I3\n all_gap_junctions=(GJ_HTC,)\n \n# if in_mode=='single_spike':\n# HTC.delay_steps = [1] # delay in time steps per neuron\n# buffer_size = 2 # 1+Maximum delay (in time steps)\n# else :\n# HTC.delay_steps = [3999] # delay in time steps per neuron\n# buffer_size = 4000 # 1+Maximum delay (in time steps)\n# \n# print(HTC.delay_steps)\n# HTC.variables.add_array('voltage_buffer', dimensions=volt.dim, size=(buffer_size, len(HTC)))\n# \n# update_code = '''buffer_pointer = (buffer_pointer + 1) % buffer_size\n# voltage_delayed = update_voltage_buffer(V, voltage_buffer, buffer_pointer, delay_steps, buffer_size)'''\n# \n# buffer_updater = HTC.run_regularly(update_code, codeobj_class=NumpyCodeObject)\n# \n# @check_units(V=volt, voltage_buffer=volt, buffer_pointer=1, delay_steps=1, buffer_size=1, result=volt)\n# def update_voltage_buffer(V, voltage_buffer, buffer_pointer, delay_steps, buffer_size):\n# # Write current rate into the buffer\n# voltage_buffer[buffer_pointer, :] = V\n# # Get delayed rates \n# rows = (buffer_pointer - delay_steps) % buffer_size \n# return voltage_buffer[rows, arange(len(rows))]\n \n return all_neurons,all_synapses,all_gap_junctions,all_monitors\n\n\nif __name__=='__main__':\n close('all')\n runtime=1*second\n f=13*Hz #rythmic input frequency\n input_on=False\n N_HTC,N_TC,N_RE= 20,80,100 #Number of neurons of RE, TC, and HTC type\n# N_HTC,N_TC,N_RE= 1,80,100 #Number of neurons of RE, TC, and HTC type\n\n Vrev_inp=0*mV\n taurinp=0.1*ms\n taudinp=0.5*ms\n tauinp=taudinp\n Vhigh=0*mV\n Vlow=-80*mV\n ginp_IB=0* msiemens * cm **-2\n ginp=0* msiemens * cm **-2\n \n Vrev_inp2=0*mV\n taurinp2=0.1*ms\n taudinp2=0.5*ms\n tauinp2=taudinp2\n Vhigh2=0*mV\n Vlow2=-80*mV\n \n #condition='mGluR1'\n condition='mAChR'\n# in_mode='single_spike'\n in_mode='burst'\n theta_phase='good'\n\n if condition=='mGluR1':\n gKL_TC=0.0028e-3 * siemens * cm **-2\n gKL_HTC=0.0069e-3 * siemens * cm **-2\n gKL_RE=0.05e-3 * siemens * cm **-2 \n elif condition=='mAChR':\n gKL_TC=0.0028e-3 * siemens * cm **-2\n gKL_HTC=0.0069e-3 * siemens * cm **-2\n gKL_RE=0.08e-3 * siemens * cm **-2\n \n# Cm_HTC = 2.5* ufarad * cm ** -2\n# gNa_HTC=90e-3 * siemens * cm **-2\n# ENa_HTC=50*mV\n# gK_HTC=10e-3 * siemens * cm **-2\n# EK_HTC=-100*mV\n# gL_HTC=0.001e-3 * siemens * cm **-2 \n# EL_HTC=-70*mV\n gKL_HTC=0.001e-3 * siemens * cm **-2 \n# EKL_HTC=-100*mV\n# gTLT_HTC= 2.1e-3 * siemens * cm **-2\n# gTHT_HTC= 15e-3 * siemens * cm **-2\n# gAHP_HTC= 45e-3 * siemens * cm **-2\n# EAHP=-95*mV\n# gH_HTC = 0.36e-3 * siemens * cm **-2\n# EH_HTC = -40 * mV\n gapp=0.1*mamp * cmeter ** -2 # in HTC cells\n# gapp=0.001*mamp * cmeter ** -2 # in HTC cells\n \n net=Network()\n all_neurons,all_synapses,all_gap_junctions,all_monitors=create_mdPul_column(N_HTC,N_TC,N_RE,condition,in_mode,theta_phase)\n# R1,R2,R3,V1,V2,V3=all_monitors\n R1,R2,R3,V1,V2,V3,I2,I3=all_monitors\n \n HTC=all_neurons[0]\n if in_mode=='single_spike':\n HTC.delay_steps = [1] # delay in time steps per neuron\n buffer_size = 2 # 1+Maximum delay (in time steps)\n else :\n HTC.delay_steps = [3999] # delay in time steps per neuron\n buffer_size = 4000 # 1+Maximum delay (in time steps)\n \n init_array=-70*mV*ones((buffer_size, len(HTC)))\n HTC.variables.add_array('voltage_buffer', dimensions=volt.dim, size=(buffer_size, len(HTC)))#,values=init_array)\n HTC.voltage_buffer=init_array\n \n update_code = '''buffer_pointer = (buffer_pointer + 1) % buffer_size\n voltage_delayed = update_voltage_buffer(V, voltage_buffer, buffer_pointer, delay_steps, buffer_size)'''\n \n buffer_updater = HTC.run_regularly(update_code, codeobj_class=NumpyCodeObject)\n \n @check_units(V=volt, voltage_buffer=volt, buffer_pointer=1, delay_steps=1, buffer_size=1, result=volt)\n def update_voltage_buffer(V, voltage_buffer, buffer_pointer, delay_steps, buffer_size):\n # Write current rate into the buffer\n voltage_buffer[buffer_pointer, :] = V\n # Get delayed rates \n rows = (buffer_pointer - delay_steps) % buffer_size \n return voltage_buffer[rows, arange(len(rows))]\n \n# print(HTC.delay_steps)\n \n SynHTCTC=all_synapses[5]\n \n net.add(all_neurons)\n net.add(all_synapses)\n net.add(all_gap_junctions)\n net.add(all_monitors)\n\n TC=all_neurons[1]\n M=StateMonitor(TC,'Isyn', record=True)\n M2=StateMonitor(HTC,'voltage_delayed', record=True)\n M3=StateMonitor(SynHTCTC,'s_i',record=[0])\n net.add(M,M2,M3)\n \n prefs.codegen.target = 'cython'\n net.run(runtime,report='text',report_period=300*second)\n \n \n figure()\n plot(R1.t,R1.i+0,'r.',label='HTC')\n plot(R2.t,R2.i+20,'b.',label='TC')\n plot(R3.t,R3.i+100,'g.',label='RE')\n xlim(0,runtime/second)\n legend() \n \n figure()\n plot(V1.t,V1.V[0],label='HTC V')\n plot(V2.t,V2.V[0],label='TC V')\n plot(V3.t,V3.V[0],label='RE V')\n legend()\n \n# figure()\n# plot(I1.t,I1.ISK[0],label='I_SK HTC')\n# legend()\n \n# figure()\n# plot(I2.t,I2.ITHT[0],label='I_THT HTC')\n# legend()\n# \n# figure()\n# plot(I3.t,I3.ITLT[0],label='I_TLT HTC')\n# legend()\n \n# f,Spectrum_LFP_V1=signal.periodogram(V1.V[0], 100000,'flattop', scaling='spectrum')\n# figure()\n# plot(f,Spectrum_LFP_V1)\n# xlim(0,100)\n Isyn_calc=(V2.V[0]+80*mV)*0.2 * msiemens * cm **-2*M3.s_i[0]\n \n figure()\n plot(M.t,M.Isyn[0],label='I_syn HTC-TC')\n plot(M2.t,M2.voltage_delayed[0],label='HTC voltage_delayed')\n plot(V2.t,V2.V[0],label='TC V')\n plot(V1.t,V1.V[0],label='HTC V')\n plot(M3.t,M3.s_i[0],label='s_i syn HTC-TC')\n plot(M3.t,Isyn_calc,label='Isyn HTC-TC calc')\n legend()\n \n\n clear_cache('cython') \n \n", "meta": {"hexsha": "e0d390a2bd500c9f1e284e78b82031a0a38cd921", "size": 13169, "ext": "py", "lang": "Python", "max_stars_repo_path": "mdPul_one_column.py", "max_stars_repo_name": "benpolletta/egly-driver-network", "max_stars_repo_head_hexsha": "cff36a857e22358d122f24fb0100be26483a3caf", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-04-06T18:13:12.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-06T18:13:12.000Z", "max_issues_repo_path": "mdPul_one_column.py", "max_issues_repo_name": "benpolletta/egly-driver-network", "max_issues_repo_head_hexsha": "cff36a857e22358d122f24fb0100be26483a3caf", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "mdPul_one_column.py", "max_forks_repo_name": "benpolletta/egly-driver-network", "max_forks_repo_head_hexsha": "cff36a857e22358d122f24fb0100be26483a3caf", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.0239361702, "max_line_length": 126, "alphanum_fraction": 0.6273824892, "include": true, "reason": "from scipy", "num_tokens": 4785, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792044, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.19546295367409278}} {"text": "\"\"\"\nPlease cite this paper if you re-use parts of the code\nS. Koehler, T. Hussain, Z. Blair, T. Huffaker, F. Ritzmann, A. Tandon, T. Pickardt, S. Sarikouch, H. Latus, G. Greil, I. Wolf, S. Engelhardt, \n\"Unsupervised Domain Adaptation from Axial to Short-Axis Multi-Slice Cardiac MR Images by Incorporating Pretrained Task Networks,\" \nin IEEE Transactions on Medical Imaging (TMI), early access, doi: 10.1109/TMI.2021.3052972.\n\nThe spatial transformer layer is based on the neuron project:\nUnsupervised Learning for Fast Probabilistic Diffeomorphic Registration\nAdrian V. Dalca, Guha Balakrishnan, John Guttag, Mert R. Sabuncu\nMICCAI 2018.\n\"\"\"\n\n# main imports\nimport logging\nimport sys\n\n# third party\nimport numpy as np\nimport tensorflow\nimport tensorflow as tf\nimport tensorflow.keras.initializers\nfrom tensorflow.keras.initializers import RandomNormal\nfrom tensorflow.keras.layers import Input\nfrom tensorflow.keras.models import Model\n\nimport src.utils.Loss_and_metrics as metr\nfrom src.models.KerasLayers import Euler2Matrix, UnetWrapper, ConvEncoder, Inverse3DMatrix\nfrom src.models.ModelUtils import get_optimizer\n\nsys.path.append('src/models/ext/neuron')\nsys.path.append('src/models/ext/pynd-lib')\nsys.path.append('src/models/ext/pytools-lib')\nimport src.models.ext.neuron.neuron.layers as nrn_layers\n\n\ndef create_affine_cycle_transformer_model(config, networkname='affine_cycle_transformer', unet=None):\n \"\"\"\n Create a compiled Domain adaption (AX2SAX) spatial transformer model with three loss functions.\n\n :param config: Key value pairs for image size and other network parameters\n :param metrics: list of tensorflow or keras compatible metrics\n :param networkname: string, name of this model scope\n :param unet: tf.keras.Model, pre-trained 2D U-net\n :return: compiled tf.keras.Model\n\n The returned tf.keras.Model expects the following input during training:\n [ax_cmr, sax_cmr]\n and returns the following elements:\n [ax2sax_cmr, sax2ax_cmr, ax2sax_mod_cmr,sax_msk, ax_msk, m, m_mod]\n During inference sax_cmr could be None or a zero initialised ndarray\n\n This model has the following flow:\n inputs = [AX, SAX]\n m, m_mod = Encoder(AX)\n m_inv = Inverse(m)\n ax2sax = SpatialTransformer(AX, m)\n ax2sax = SpatialTransformer(AX, m_mod)\n sax2ax = SpatialTransformer(SAX, m_inv)\n sax_msk = Unet(SAX)\n ax_msk = SpatialTransformer(sax_msk, m_mod)\n outputs = [ax2sax, sax2ax, ax2sax_mod, sax_msk, ax_msk, m, m_mod]\n\n This model calculates the gradients according to the following loss functions:\n MSE_mod(ax2sax_gt, ax2sax_pred) # learn an affine transformation that fits to our gt\n MSE_mod(sax2ax_gt, sax2ax_pred) # apply the opposite transformation to align the cycle consistency\n Loss_focus(ax_msk) or Loss_focus(sax_msk)\n\n - MSE_mod = MSE(y_true, y_pred) * weighting[None, None,: , : ],\n Example in-plane weighting with an in-plane resolution of 10 x 10 pixels:\n weighting =\n [[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]\n [0. 0.25 0.25 0.25 0.25 0.25 0.25 0.25 0.25 0. ]\n [0. 0.25 0.5 0.5 0.5 0.5 0.5 0.5 0.25 0. ]\n [0. 0.25 0.5 0.75 0.75 0.75 0.75 0.5 0.25 0. ]\n [0. 0.25 0.5 0.75 1. 1. 0.75 0.5 0.25 0. ]\n [0. 0.25 0.5 0.75 1. 1. 0.75 0.5 0.25 0. ]\n [0. 0.25 0.5 0.75 0.75 0.75 0.75 0.5 0.25 0. ]\n [0. 0.25 0.5 0.5 0.5 0.5 0.5 0.5 0.25 0. ]\n [0. 0.25 0.25 0.25 0.25 0.25 0.25 0.25 0.25 0. ]\n [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]]\n\n - Loss_focus =\n # ignore background, we want to maximize the number of captured ventricle voxel\n y_pred = y_pred[...,1:] if background given by the U-Net predictions\n y_pred = tf.cast(y_pred, dtype=tf.float32)\n # keep only the highest prob\n sum_bigger_than = tf.reduce_max(y_pred, axis=-1)\n # create a mask of voxels greater than the threshold\n mask_bigger_than = tf.cast(sum_bigger_than > min_probabillity, tf.float32)\n # we cant use the mask directly as this creates no gradients, this keeps also the prob value\n sum_bigger_than = sum_bigger_than * mask_bigger_than\n # return a scalar between 0 and 1, the loss is typically close to 1, as the background class is overrepresented\n return 1- tf.reduce_mean(sum_bigger_than)\n \"\"\"\n\n if tf.distribute.has_strategy():\n strategy = tf.distribute.get_strategy()\n else:\n # distribute the training with the \"mirrored data\"-paradigm across multiple gpus if available, if not use gpu 0\n strategy = tf.distribute.MirroredStrategy(devices=config.get('GPUS', [\"/gpu:0\"]))\n with strategy.scope():\n\n input_shape = config.get('DIM', [10, 224, 224])\n inputs_ax = Input((*input_shape, config.get('IMG_CHANNELS', 1)))\n inputs_sax = Input((*input_shape, config.get('IMG_CHANNELS', 1)))\n # define standard values according to the convention over configuration paradigm\n activation = config.get('ACTIVATION', 'elu')\n batch_norm = config.get('BATCH_NORMALISATION', False)\n pad = config.get('PAD', 'same')\n kernel_init = config.get('KERNEL_INIT', 'he_normal')\n m_pool = config.get('M_POOL', (1, 2, 2))\n f_size = config.get('F_SIZE', (3, 3, 3))\n filters = config.get('FILTERS', 16)\n drop_1 = config.get('DROPOUT_min', 0.3)\n drop_3 = config.get('DROPOUT_max', 0.5)\n bn_first = config.get('BN_FIRST', False)\n ndims = len(config.get('DIM', [10, 224, 224]))\n depth = config.get('DEPTH', 4)\n dense_weights = config.get('DENSE_WEIGHTS', 256)\n indexing = config.get('INDEXING', 'ij')\n\n weight_mse_inplane = config.get('WEIGHT_MSE_INPLANE',\n True) # weight the MSE loss pixels in the center have greater weights\n mask_smaller_than_threshold = config.get('MASK_SMALLER_THAN_THRESHOLD',\n 0.01) # calc the MSe loss only where our image has values greater than\n ax_weight = config.get('AX_LOSS_WEIGHT', 2)\n\n cycle_loss = config.get('CYCLE_LOSS', False)\n sax_weight = config.get('SAX_LOSS_WEIGHT', 2)\n\n focus_loss = config.get('FOCUS_LOSS', False)\n focus_weight = config.get('FOCUS_LOSS_WEIGHT', 1)\n min_unet_probability = config.get('MIN_UNET_PROBABILITY',\n 0.9) # sum the foreground voxels with a prob higher than\n use_mask2ax_prob = config.get('USE_SAX2AX_PROB', True) # otherwise use the SAX probability\n\n # increase the dropout through the layer depth\n dropouts = list(np.linspace(drop_1, drop_3, depth))\n dropouts = [round(i, 1) for i in dropouts]\n\n enc, _ = ConvEncoder(activation=activation,\n batch_norm=batch_norm,\n bn_first=bn_first,\n depth=depth,\n drop_3=drop_3,\n dropouts=dropouts,\n f_size=f_size,\n filters=filters,\n kernel_init=kernel_init,\n m_pool=m_pool,\n ndims=ndims,\n pad=pad)(inputs_ax)\n\n # Shrink the encoding towards the euler angles and translation params,\n # no additional dense layers before the GAP layer\n m_raw = tensorflow.keras.layers.GlobalAveragePooling3D()(enc) # m.shape --> b, 512\n m_raw = tensorflow.keras.layers.Dense(dense_weights, kernel_initializer=kernel_init, activation=activation,\n name='dense1')(m_raw)\n m_raw = tensorflow.keras.layers.Dense(9, kernel_initializer=RandomNormal(mean=0.0, stddev=1e-10),\n activation=activation, name='dense2')(m_raw)\n m = Euler2Matrix(name='ax2sax_matrix')(m_raw[:, 0:6])\n\n # Cycle flow - use M and the inverse M to transform the SAX and AX input\n ax2sax = nrn_layers.SpatialTransformer(interp_method='linear', indexing=indexing, ident=False, fill_value=0,\n name='ax2sax')([inputs_ax, m])\n m_inv = Inverse3DMatrix()(m)\n sax2ax = nrn_layers.SpatialTransformer(interp_method='linear', indexing=indexing, ident=False, fill_value=0,\n name='sax2ax')([inputs_sax, m_inv])\n\n if unet:\n logging.info('unet given, use it to max probability')\n\n # concat the rotation parameters with the second set of translation params\n m_mod = tf.keras.layers.Concatenate(axis=-1)([m_raw[:, 0:3], m_raw[:, 6:9]]) # rot + translation\n m_mod = Euler2Matrix(name='ax2sax_mod_matrix')(m_mod) #\n ax2sax_mod = nrn_layers.SpatialTransformer(interp_method='linear', indexing=indexing, ident=False,\n fill_value=0, name='ax2sax_mod_st')([inputs_ax, m_mod])\n\n # we use the probabilities of a pre-trained U-net with fixed weights\n # to learn a second set of translation parameters which maximize the Unet probability\n mask_prob = UnetWrapper(unet, name='mask_prob')(ax2sax_mod) #\n m_mod_inv = Inverse3DMatrix()(m_mod) #\n mask2ax = nrn_layers.SpatialTransformer(interp_method='nearest', indexing=indexing, ident=False,\n fill_value=0, name='mask2ax')([mask_prob, m_mod_inv])\n # Define the model output\n outputs = [ax2sax, sax2ax, ax2sax_mod, mask_prob, mask2ax, m, m_mod]\n\n # baseline loss\n logging.info('adding ax2sax MSE loss with a weighting of {}'.format(ax_weight))\n losses = {'ax2sax': metr.loss_with_zero_mask(mask_smaller_than=mask_smaller_than_threshold,\n weight_inplane=weight_mse_inplane, xy_shape=input_shape[-2])}\n loss_w = {'ax2sax': ax_weight}\n\n # extend losses by cycle MSE loss\n if cycle_loss:\n logging.info('adding cycle loss with a weighting of {}'.format(sax_weight))\n losses['sax2ax'] = metr.loss_with_zero_mask(mask_smaller_than=mask_smaller_than_threshold,\n weight_inplane=weight_mse_inplane, xy_shape=input_shape[-2])\n loss_w['sax2ax'] = sax_weight\n\n # extend losses by probability loss\n if focus_loss:\n # Use the SAX predictions or the SAX2AX predictions to maximise the unet probability\n # probability_object must fit a output-layer name\n if use_mask2ax_prob:\n probability_object = 'mask2ax'\n else:\n probability_object = 'mask_prob'\n logging.info('adding focus loss on {} with a weighting of {}'.format(probability_object, focus_weight))\n losses[probability_object] = metr.max_volume_loss(min_probability=min_unet_probability)\n loss_w[probability_object] = focus_weight\n\n\n else: # no u-net given\n outputs = [ax2sax, sax2ax, m]\n # baseline loss\n logging.info('adding ax2sax MSE loss with a weighting of {}'.format(ax_weight))\n losses = {'ax2sax': metr.loss_with_zero_mask(mask_smaller_than=mask_smaller_than_threshold,\n weight_inplane=weight_mse_inplane,\n xy_shape=input_shape[-2])}\n loss_w = {'ax2sax': ax_weight}\n\n # extend losses by cycle MSE loss\n if cycle_loss:\n logging.info('adding cycle MSE loss with a weighting of {}'.format(sax_weight))\n losses['sax2ax'] = metr.loss_with_zero_mask(mask_smaller_than=mask_smaller_than_threshold,\n weight_inplane=weight_mse_inplane,\n xy_shape=input_shape[-2])\n loss_w['sax2ax'] = sax_weight\n\n model = Model(inputs=[inputs_ax, inputs_sax], outputs=outputs, name=networkname)\n model.compile(optimizer=get_optimizer(config, networkname), loss=losses, loss_weights=loss_w)\n\n return model\n\n\n# ST to apply m to an volume\ndef create_affine_transformer_fixed(config, metrics=None, networkname='affine_transformer_fixed', fill_value=0,\n interp_method='linear'):\n \"\"\"\n Apply a learned transformation matrix to an input image, no training possible\n :param config: Key value pairs for image size and other network parameters\n :param metrics: list of tensorflow or keras compatible metrics\n :param networkname: string, name of this model scope\n :param fill_value:\n :return: compiled tf.keras model\n \"\"\"\n if tf.distribute.has_strategy():\n strategy = tf.distribute.get_strategy()\n else:\n # distribute the training with the mirrored data paradigm across multiple gpus if available, if not use gpu 0\n strategy = tf.distribute.MirroredStrategy(devices=config.get('GPUS', [\"/gpu:0\"]))\n\n with strategy.scope():\n\n inputs = Input((*config.get('DIM', [10, 224, 224]), config.get('IMG_CHANNELS', 1)))\n input_matrix = Input((12), dtype=np.float32)\n indexing = config.get('INDEXING', 'ij')\n\n # warp the source with the flow\n y = nrn_layers.SpatialTransformer(interp_method=interp_method, indexing=indexing, ident=False,\n fill_value=fill_value)([inputs, input_matrix])\n\n model = Model(inputs=[inputs, input_matrix], outputs=[y, input_matrix], name=networkname)\n\n return model\n", "meta": {"hexsha": "d08d45ced822cfe8c0bb90a05835cf2702d8b2a6", "size": 13922, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/models/SpatialTransformer.py", "max_stars_repo_name": "Cardio-AI/3d-mri-domain-adaptation", "max_stars_repo_head_hexsha": "2a1b8332039aa25b8291cfd746cbcf87f71068c2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2020-12-16T14:18:23.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-11T11:20:22.000Z", "max_issues_repo_path": "src/models/SpatialTransformer.py", "max_issues_repo_name": "HabibMrad/3d-mri-domain-adaptation", "max_issues_repo_head_hexsha": "2a1b8332039aa25b8291cfd746cbcf87f71068c2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/models/SpatialTransformer.py", "max_forks_repo_name": "HabibMrad/3d-mri-domain-adaptation", "max_forks_repo_head_hexsha": "2a1b8332039aa25b8291cfd746cbcf87f71068c2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-06-16T18:37:52.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-16T18:37:52.000Z", "avg_line_length": 52.1423220974, "max_line_length": 142, "alphanum_fraction": 0.6236172964, "include": true, "reason": "import numpy", "num_tokens": 3538, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792044, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.19546295367409278}} {"text": "#! -*- coding: utf-8 -*-\n# 自定义层\n\nimport numpy as np\nimport tensorflow as tf\nfrom .backend import keras, K, get_all_attributes\n\n# 等价于 from keras.layers import *\nlocals().update(get_all_attributes(keras.layers))\n# 等价于 from keras.models import Model\nlocals()['Model'] = keras.models.Model\n# 等价于 from keras.utils import get_custom_objects\nlocals()['get_custom_objects'] = keras.utils.get_custom_objects\n\n\ndef gelu_erf(x):\n # 基于Erf直接计算的gelu函数\n return 0.5 * x * (1.0 + tf.math.erf(x / np.sqrt(2.0)))\n\n\ndef gelu_tanh(x):\n # 基于Tanh近似计算的gelu函数\n cdf = 0.5 * (1.0 + K.tanh(\n (np.sqrt(2 / np.pi) * (x + 0.044715 * K.pow(x, 3)))))\n return x * cdf\n\n\ndef add_seq_mask(x, mask, mode=0, axis=None, heads=1):\n \"\"\"为序列条件mask的函数\n mask: 形如(batch_size, seq_len)的0-1矩阵；\n mode: 如果是0，则直接乘以mask；\n 如果是1，则在padding部分减去一个大正数。\n axis: 序列所在轴，默认为1；\n heads: 相当于batch这一维要被重复的次数。\n \"\"\"\n if mask is None or mode not in [0, 1]:\n return x\n else:\n if heads is not 1:\n mask = K.expand_dims(mask, 1)\n mask = K.tile(mask, (1, heads, 1))\n mask = K.reshape(mask, (-1, K.shape(mask)[2]))\n if axis is None:\n axis = 1\n if axis == -1:\n axis = K.ndim(x) - 1\n assert axis > 0, 'axis muse be greater than 0'\n for _ in range(axis - 1):\n mask = K.expand_dims(mask, 1)\n for _ in range(K.ndim(x) - K.ndim(mask) - axis + 1):\n mask = K.expand_dims(mask, K.ndim(mask))\n if mode == 0:\n return x * mask\n else:\n return x - (1 - mask) * 1e12\n\n\nclass MultiHeadAttention(Layer):\n \"\"\"多头注意力机制\n \"\"\"\n def __init__(self, heads, head_size, key_size=None, **kwargs):\n super(MultiHeadAttention, self).__init__(**kwargs)\n self.heads = heads\n self.head_size = head_size\n self.out_dim = heads * head_size\n self.key_size = key_size if key_size else head_size\n\n def build(self, input_shape):\n super(MultiHeadAttention, self).build(input_shape)\n self.q_dense = Dense(self.key_size * self.heads)\n self.k_dense = Dense(self.key_size * self.heads)\n self.v_dense = Dense(self.out_dim)\n self.o_dense = Dense(self.out_dim)\n\n def call(self, inputs, q_mask=False, v_mask=False, a_mask=False):\n \"\"\"实现多头注意力\n q_mask: 对输入的query序列的mask。\n 主要是将输出结果的padding部分置0。\n v_mask: 对输入的value序列的mask。\n 主要是防止attention读取到padding信息。\n a_mask: 对attention矩阵的mask。\n 不同的attention mask对应不同的应用。\n \"\"\"\n q, k, v = inputs[:3]\n # 处理mask\n idx = 3\n if q_mask:\n q_mask = inputs[idx]\n idx += 1\n else:\n q_mask = None\n if v_mask:\n v_mask = inputs[idx]\n idx += 1\n else:\n v_mask = None\n if a_mask:\n if len(inputs) > idx:\n a_mask = inputs[idx]\n else:\n a_mask = 'history_only'\n else:\n a_mask = None\n # 线性变换\n qw = self.q_dense(q)\n kw = self.k_dense(k)\n vw = self.v_dense(v)\n # 形状变换\n qw = K.reshape(qw, (-1, K.shape(q)[1], self.heads, self.key_size))\n kw = K.reshape(kw, (-1, K.shape(k)[1], self.heads, self.key_size))\n vw = K.reshape(vw, (-1, K.shape(v)[1], self.heads, self.head_size))\n # 维度置换\n qw = K.permute_dimensions(qw, (0, 2, 1, 3))\n kw = K.permute_dimensions(kw, (0, 2, 1, 3))\n vw = K.permute_dimensions(vw, (0, 2, 1, 3))\n # 转为三阶张量\n qw = K.reshape(qw, (-1, K.shape(q)[1], self.key_size))\n kw = K.reshape(kw, (-1, K.shape(k)[1], self.key_size))\n vw = K.reshape(vw, (-1, K.shape(v)[1], self.head_size))\n # Attention\n a = K.batch_dot(qw, kw, [2, 2]) / np.sqrt(self.key_size)\n a = add_seq_mask(a, v_mask, 1, -1, self.heads)\n if a_mask is not None:\n if a_mask == 'history_only':\n ones = K.ones_like(a[:1])\n a_mask = (ones - tf.matrix_band_part(ones, -1, 0)) * 1e12\n a = a - a_mask\n else:\n a = a - (1 - a_mask) * 1e12\n a = K.softmax(a)\n # 完成输出\n o = K.batch_dot(a, vw, [2, 1])\n o = K.reshape(o, (-1, self.heads, K.shape(q)[1], self.head_size))\n o = K.permute_dimensions(o, (0, 2, 1, 3))\n o = K.reshape(o, (-1, K.shape(o)[1], self.out_dim))\n o = self.o_dense(o)\n o = add_seq_mask(o, q_mask, 0)\n return o\n\n def compute_output_shape(self, input_shape):\n return (input_shape[0][0], input_shape[0][1], self.out_dim)\n\n def get_config(self):\n config = {\n 'heads': self.heads,\n 'head_size': self.head_size,\n 'key_size': self.key_size\n }\n base_config = super(MultiHeadAttention, self).get_config()\n return dict(list(base_config.items()) + list(config.items()))\n\n\nclass LayerNormalization(Layer):\n \"\"\"实现基本的Layer Norm，只保留核心运算部分\n \"\"\"\n def __init__(self, **kwargs):\n super(LayerNormalization, self).__init__(**kwargs)\n self.epsilon = K.epsilon() * K.epsilon()\n\n def build(self, input_shape):\n super(LayerNormalization, self).build(input_shape)\n shape = (input_shape[-1], )\n self.gamma = self.add_weight(shape=shape,\n initializer='ones',\n name='gamma')\n self.beta = self.add_weight(shape=shape,\n initializer='zeros',\n name='beta')\n\n def call(self, inputs):\n mean = K.mean(inputs, axis=-1, keepdims=True)\n variance = K.mean(K.square(inputs - mean), axis=-1, keepdims=True)\n std = K.sqrt(variance + self.epsilon)\n outputs = (inputs - mean) / std\n outputs *= self.gamma\n outputs += self.beta\n return outputs\n\n\nclass FactorizedEmbedding(Layer):\n \"\"\"基于低秩分解的Embedding层\n \"\"\"\n def __init__(self, input_dim, output_dim, hidden_dim=None, **kwargs):\n super(FactorizedEmbedding, self).__init__(**kwargs)\n self.input_dim = input_dim\n self.output_dim = output_dim\n if hidden_dim is None:\n self.hidden_dim = output_dim\n else:\n self.hidden_dim = hidden_dim\n\n def build(self, input_shape):\n super(FactorizedEmbedding, self).build(input_shape)\n self._embeddings = self.add_weight(name='embeddings',\n shape=(self.input_dim,\n self.hidden_dim),\n initializer='uniform')\n self._project_kernel = self.add_weight(name='project_kernel',\n shape=(self.hidden_dim,\n self.output_dim),\n initializer='glorot_uniform')\n self.embeddings = K.dot(self._embeddings, self._project_kernel)\n\n def call(self, inputs):\n if K.dtype(inputs) != 'int32':\n inputs = K.cast(inputs, 'int32')\n outputs = K.gather(self._embeddings, inputs)\n outputs = K.dot(outputs, self._project_kernel)\n return outputs\n\n def compute_output_shape(self, input_shape):\n return input_shape + (self.output_dim, )\n\n def get_config(self):\n config = {\n 'input_dim': self.input_dim,\n 'output_dim': self.output_dim,\n 'hidden_dim': self.hidden_dim\n }\n base_config = super(FactorizedEmbedding, self).get_config()\n return dict(list(base_config.items()) + list(config.items()))\n\n\nclass PositionEmbedding(Layer):\n \"\"\"定义位置Embedding，这里的Embedding是可训练的。\n \"\"\"\n def __init__(self, input_dim, output_dim, merge_mode='add', **kwargs):\n super(PositionEmbedding, self).__init__(**kwargs)\n self.input_dim = input_dim\n self.output_dim = output_dim\n self.merge_mode = merge_mode\n\n def build(self, input_shape):\n super(PositionEmbedding, self).build(input_shape)\n self.embeddings = self.add_weight(name='embeddings',\n shape=(self.input_dim,\n self.output_dim),\n initializer='zeros')\n\n def call(self, inputs):\n input_shape = K.shape(inputs)\n batch_size, seq_len = input_shape[0], input_shape[1]\n pos_embeddings = self.embeddings[:seq_len]\n pos_embeddings = K.expand_dims(pos_embeddings, 0)\n pos_embeddings = K.tile(pos_embeddings, [batch_size, 1, 1])\n if self.merge_mode == 'add':\n return inputs + pos_embeddings\n else:\n return K.concatenate([inputs, pos_embeddings])\n\n def compute_output_shape(self, input_shape):\n if self.merge_mode == 'add':\n return input_shape\n else:\n return input_shape[:2] + (input_shape[2] + self.v_dim, )\n\n def get_config(self):\n config = {\n 'input_dim': self.input_dim,\n 'output_dim': self.output_dim,\n 'merge_mode': self.merge_mode\n }\n base_config = super(PositionEmbedding, self).get_config()\n return dict(list(base_config.items()) + list(config.items()))\n\n\nclass FeedForward(Layer):\n \"\"\"FeedForward层，其实就是两个Dense层的叠加\n \"\"\"\n def __init__(self, units, activation='relu', **kwargs):\n super(FeedForward, self).__init__(**kwargs)\n self.units = units\n self.activation = activation\n\n def build(self, input_shape):\n super(FeedForward, self).build(input_shape)\n output_dim = input_shape[-1]\n self.dense_1 = Dense(self.units, activation=self.activation)\n self.dense_2 = Dense(output_dim)\n\n def call(self, inputs):\n x = self.dense_1(inputs)\n x = self.dense_2(x)\n return x\n\n def get_config(self):\n config = {'units': self.units, 'activation': self.activation}\n base_config = super(FeedForward, self).get_config()\n return dict(list(base_config.items()) + list(config.items()))\n\n\nclass EmbeddingDense(Layer):\n \"\"\"运算跟Dense一致，但kernel用Embedding层的embeddings矩阵。\n 根据Embedding层的名字来搜索定位Embedding层。\n \"\"\"\n def __init__(self, embedding_name, activation='softmax', **kwargs):\n super(EmbeddingDense, self).__init__(**kwargs)\n self.embedding_name = embedding_name\n self.activation = activation\n\n def call(self, inputs):\n if not hasattr(self, 'kernel'):\n embedding_layer = inputs._keras_history[0]\n\n if embedding_layer.name != self.embedding_name:\n\n def recursive_search(layer):\n \"\"\"递归向上搜索，根据名字找Embedding层\n \"\"\"\n last_layer = layer._inbound_nodes[0].inbound_layers\n if isinstance(last_layer, list):\n if len(last_layer) == 0:\n return None\n else:\n last_layer = last_layer[0]\n if last_layer.name == self.embedding_name:\n return last_layer\n else:\n return recursive_search(last_layer)\n\n embedding_layer = recursive_search(embedding_layer)\n if embedding_layer is None:\n raise Exception('Embedding layer not found')\n\n self.kernel = K.transpose(embedding_layer.embeddings)\n self.units = K.int_shape(self.kernel)[1]\n self.bias = self.add_weight(name='bias',\n shape=(self.units, ),\n initializer='zeros')\n\n outputs = K.dot(inputs, self.kernel)\n outputs = K.bias_add(outputs, self.bias)\n outputs = Activation(self.activation).call(outputs)\n return outputs\n\n def compute_output_shape(self, input_shape):\n return input_shape[:-1] + (self.units, )\n\n def get_config(self):\n config = {\n 'embedding_name': self.embedding_name,\n 'activation': self.activation\n }\n base_config = super(EmbeddingDense, self).get_config()\n return dict(list(base_config.items()) + list(config.items()))\n\n\ncustom_objects = {\n 'gelu_erf': gelu_erf,\n 'gelu_tanh': gelu_tanh,\n 'MultiHeadAttention': MultiHeadAttention,\n 'LayerNormalization': LayerNormalization,\n 'FactorizedEmbedding': FactorizedEmbedding,\n 'PositionEmbedding': PositionEmbedding,\n 'FeedForward': FeedForward,\n 'EmbeddingDense': EmbeddingDense\n}\n\nget_custom_objects().update(custom_objects)", "meta": {"hexsha": "aaa5b984d1973eeb5140fc1222cc17c7a023101b", "size": 12741, "ext": "py", "lang": "Python", "max_stars_repo_path": "keras_bert_ner/bert4keras/.ipynb_checkpoints/layers-checkpoint.py", "max_stars_repo_name": "qianrenjian/keras-bert-ner", "max_stars_repo_head_hexsha": "5258f68421817008d2c2c9f8420ebf0dce9d5b34", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 10, "max_stars_repo_stars_event_min_datetime": "2020-04-14T02:49:18.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-03T03:41:55.000Z", "max_issues_repo_path": "keras_bert_ner/bert4keras/.ipynb_checkpoints/layers-checkpoint.py", "max_issues_repo_name": "qianrenjian/keras-bert-ner", "max_issues_repo_head_hexsha": "5258f68421817008d2c2c9f8420ebf0dce9d5b34", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "keras_bert_ner/bert4keras/.ipynb_checkpoints/layers-checkpoint.py", "max_forks_repo_name": "qianrenjian/keras-bert-ner", "max_forks_repo_head_hexsha": "5258f68421817008d2c2c9f8420ebf0dce9d5b34", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2020-04-14T06:57:13.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-11T05:55:04.000Z", "avg_line_length": 35.4902506964, "max_line_length": 76, "alphanum_fraction": 0.5602385998, "include": true, "reason": "import numpy", "num_tokens": 3217, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792044, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.19546295367409278}} {"text": "'''\nDeconvolution Pipeline\n----------------------\n\nThe deconvolution process can be pipelined from start to finish\nusing the :class:`~.ScanProcessor` class. This includes precursor recalculation and\ncoisolation detection. :class:`~.ScanProcessor` is intended to be used either as a\nreplacement for :class:`~.ScanIterator` when deconvolution is desired, or that it's\n:meth:`ScanProcessor.process` method will be used to handle individual :class:`~.ScanBunch`\nobjects/pairs of precursor :class:`~.Scan` objects and a :class:`list` of product :class:`~.Scan`\nobjects.\n\nThe free-function :func:`~.process` is a convenience wrapper around :class:`~.ScanProcessor`,\nwith fewer configurable parameters.\n\n.. code:: python\n\n from ms_deisotope import ScanProcessor, glycopeptide, peptide\n from ms_deisotope.scoring import PenalizedMSDeconVFitter, MSDeconVFitter\n from ms_deisotope.test.common import datafile\n\n # Locate example dataset\n path = datafile(\"20150710_3um_AGP_001_29_30.mzML.gz\")\n\n proc = processor.ScanProcessor(path, ms1_deconvolution_args={\n \"averagine\": glycopeptide,\n \"scorer\": PenalizedMSDeconVFitter(20., 2.),\n \"truncate_after\": 0.95\n }, msn_deconvolution_args={\n \"averagine\": peptide,\n \"scorer\": MSDeconVFitter(10.),\n \"truncate_after\": 0.8\n })\n\n bunch = next(proc)\n print(bunch)\n print(bunch.precursor.deconvoluted_peak_set)\n'''\nimport logging\n\nfrom six import string_types as basestring\n\nimport numpy as np\n\nfrom ms_peak_picker import pick_peaks, PeakSet, PeakIndex\nfrom ms_peak_picker.scan_filter import FTICRBaselineRemoval\n\nfrom .averagine import AveragineCache, peptide\nfrom .scoring import PenalizedMSDeconVFitter, MSDeconVFitter\nfrom .deconvolution import deconvolute_peaks\nfrom .data_source import MSFileLoader, ScanIterator\nfrom .data_source.common import Scan, ScanBunch, ChargeNotProvided\nfrom .utils import Base\nfrom .peak_dependency_network import NoIsotopicClustersError\nfrom .qc.isolation import PrecursorPurityEstimator\nfrom .task import LogUtilsMixin\n\nlogger = logging.getLogger(\"deconvolution_scan_processor\")\nlogger.addHandler(logging.NullHandler())\n\n\ndef _get_nearest_index(query_mz, peak_list):\n best_index = None\n best_error = float('inf')\n\n for i, peak in enumerate(peak_list):\n error = abs(peak.mz - query_mz)\n if error < best_error:\n best_error = error\n best_index = i\n return best_index\n\n\nclass PriorityTarget(Base):\n \"\"\"Represent a targeted envelope deconvolution's parameters and constraints.\n\n This class is used to tell :func:`ms_deisotope.deconvolution.deconvolute_peaks`\n that the solution produced by this peak should be preferentially extracted.\n\n Attributes\n ----------\n info : :class:`~.PrecursorInformation`\n The associated precursor information block which contains\n the charge state hint.\n peak : :class:`~.FittedPeak`\n The peak from which to start the deconvolution\n trust_charge_hint : bool\n Whether or not to force the deconvoluter to only consider\n the charge specified in the hint.\n mz : float\n The m/z of :attr:`peak`\n charge : int\n The charge state hint from :attr:`info`\n isolation_window : :class:`~.IsolationWindow`\n The isolation window for this precursor ion. May be `None`\n \"\"\"\n\n def __init__(self, peak, info, trust_charge_hint=True, precursor_scan_id=None,\n product_scan_id=None, isolation_window=None):\n self.peak = peak\n self.info = info\n self.trust_charge_hint = trust_charge_hint\n self.precursor_scan_id = precursor_scan_id\n self.product_scan_id = product_scan_id\n self.isolation_window = isolation_window\n\n def __iter__(self):\n yield self.peak\n yield self.info\n\n @property\n def mz(self):\n '''\n The m/z of the matched peak\n\n Returns\n -------\n float\n '''\n return self.peak.mz\n\n @property\n def charge(self):\n '''\n The charge state of the precursor ion reported by the source.\n\n Returns\n -------\n int\n '''\n try:\n return int(self.info.charge)\n except TypeError:\n return 0\n\n def charge_range_hint(self, charge_range):\n \"\"\"Create an updated charge range for a Deconvoluter to search.\n\n At the moment, this only amounts to either returning the charge\n range unchanged or returning a charge range that only contains\n the hinted charge state, depending upon whether :attr:`trust_charge_hint`\n is `False` or not.\n\n Parameters\n ----------\n charge_range : tuple\n The charge range to update\n\n Returns\n -------\n tuple\n The updated charge range\n \"\"\"\n if self.trust_charge_hint and self.info.charge is not ChargeNotProvided:\n return (self.charge, self.charge)\n else:\n return charge_range\n\n def __repr__(self):\n return \"PriorityTarget(mz=%0.4f, intensity=%0.4f, charge_hint=%d)\" % (\n self.mz, self.peak.intensity, self.charge)\n\n\ndef _loader_creator(specification):\n if isinstance(specification, basestring):\n return MSFileLoader(specification)\n elif isinstance(specification, ScanIterator):\n return specification\n else:\n raise ValueError(\"Cannot determine how to get a ScanIterator from %r\" % (specification,))\n\n\ndef _simplify_peak_set(peaks, bin_width=5.0):\n bin_edges = np.arange(0, peaks[-1].mz + bin_width, bin_width)\n bins = []\n for i, bin_edge in enumerate(bin_edges, 1):\n if i == len(bin_edges):\n next_edge = bin_edges[-1] + bin_width\n else:\n next_edge = bin_edges[i]\n subset = peaks.between(bin_edge, next_edge)\n bins.append(subset)\n\n thresholds = []\n reduced_subsets = {}\n k = 0\n for b in bins:\n if len(b) > 0:\n bin_intensities = np.array([p.intensity for p in b])\n thresholds.append(np.max(bin_intensities) / 3.)\n for p in b:\n if p.intensity > thresholds[-1]:\n reduced_subsets[p.peak_count] = p\n k += (bin_intensities > thresholds[-1]).sum()\n else:\n thresholds.append(0.0)\n subset_peaks = PeakSet(\n sorted(reduced_subsets.values(), key=lambda x: x.mz)).clone()\n subset_peaks.reindex()\n return PeakIndex(np.array([]), np.array([]), subset_peaks)\n\n\nclass ScanProcessor(Base, LogUtilsMixin):\n \"\"\"Orchestrates the deconvolution of a :class:`~.ScanIterator` scan by scan. This process will\n apply different rules for MS1 scans and MSn scans. This type itself mimics a :class:`~.ScanIterator`,\n consuming (raw) mass spectral data and producing deisotoped and charge deconvolved spectra.\n\n The algorithms used for each task are independent and can be specified in the appropriate\n attribute dictionary, however there is information sharing between each MS1 scan and its\n MSn scans as the precursor monoisotopic mass is recalibrated according to the MS1 processing\n arguments, and the selected charge state is used to limit the charge range used in the matching\n MSn scan. These are described by :class:`PriorityTarget` objects.\n\n If an averagine-based deconvoluter is used, the averagine cache will be pre-populated.\n\n At the moment, MSn assumes only MS2. Until MS3 data become available for testing, this limit\n will remain.\n\n Attributes\n ----------\n data_source : :class:`str`, :class:`~.ScanIterator` or file-like\n Any valid object to be passed to the `loader_type` callable to produce\n a :class:`~.ScanIterator` instance. A path to a mass spectrometry data file,\n a file-like object, or an instance of :class:`~.ScanIterator`. Used to populate :attr:`reader`\n loader_type : callable\n A callable, which when passed :attr:`data_source` returns an instance of :class:`~.ScanIterator`.\n By default, this is :func:`~.MSFileLoader`. Used to populate :attr:`reader`\n reader: ScanIterator\n Any object implementing the :class:`~.ScanIterator` interface, produced by calling\n :attr:`loader_type` on :attr:`data_source`.\n ms1_deconvolution_args : :class:`dict`\n The arguments passed to :func:`~ms_deisotope.deconvolution.deconvolute_peaks` for MS1\n scans.\n ms1_peak_picking_args : :class:`dict`\n The arguments passed to :func:`ms_peak_picker.pick_peaks` for MS1 scans.\n msn_deconvolution_args : :class:`dict`\n The arguments passed to :func:`~ms_deisotope.deconvolution.deconvolute_peaks` for MSn\n scans.\n msn_peak_picking_args : :class:`dict`\n The arguments passed to :func:`ms_peak_picker.pick_peaks` for MSn scans.\n pick_only_tandem_envelopes : :class:`bool`\n Whether or not to process whole MS1 scans or just the regions around those peaks\n chosen for MSn\n default_precursor_ion_selection_window : :class:`float`\n Size of the selection window to use when :attr:`pick_only_tandem_envelopes` is `True`\n and the information is not available in the scan.\n trust_charge_hint : :class:`bool`\n Whether or not to trust the charge provided by the data source when determining\n the charge state of precursor isotopic patterns. Defaults to `True`\n respect_isolation_window: :class:`bool`\n Whether to use the bounds of the isolation window to reject a monoisotopic peak\n solution\n terminate_on_error: :class:`bool`\n Whether or not to stop processing on an error. Defaults to `True`\n ms1_averaging: :class:`int`\n The number of adjacent MS1 scans to average prior to picking peaks.\n \"\"\"\n\n def __init__(self, data_source, ms1_peak_picking_args=None,\n msn_peak_picking_args=None,\n ms1_deconvolution_args=None,\n msn_deconvolution_args=None,\n pick_only_tandem_envelopes=False,\n default_precursor_ion_selection_window=1.5,\n trust_charge_hint=True,\n loader_type=None,\n envelope_selector=None,\n terminate_on_error=True,\n ms1_averaging=0,\n respect_isolation_window=False,\n too_many_peaks_threshold=7000):\n if loader_type is None:\n loader_type = _loader_creator\n\n self.data_source = data_source\n self.ms1_peak_picking_args = ms1_peak_picking_args or {}\n self.msn_peak_picking_args = msn_peak_picking_args or ms1_peak_picking_args or {}\n self.ms1_deconvolution_args = ms1_deconvolution_args or {}\n self.ms1_deconvolution_args.setdefault(\"charge_range\", (1, 8))\n self.msn_deconvolution_args = msn_deconvolution_args or {}\n self.msn_deconvolution_args.setdefault(\"charge_range\", (1, 8))\n self.pick_only_tandem_envelopes = pick_only_tandem_envelopes\n\n self.too_many_peaks_threshold = too_many_peaks_threshold\n\n self.default_precursor_ion_selection_window = default_precursor_ion_selection_window\n self.respect_isolation_window = respect_isolation_window\n\n self.trust_charge_hint = trust_charge_hint\n self.ms1_averaging = int(ms1_averaging) if ms1_averaging else 0\n\n self.loader_type = loader_type\n\n self._signal_source = self.loader_type(data_source)\n self.envelope_selector = envelope_selector\n self.terminate_on_error = terminate_on_error\n self._prepopulate_averagine_cache()\n\n def _prepopulate_averagine_cache(self):\n if 'averagine' in self.ms1_deconvolution_args:\n averagine = self.ms1_deconvolution_args['averagine']\n if isinstance(averagine, (list, tuple)):\n averagine = [AveragineCache(a).populate() for a in averagine]\n else:\n averagine = AveragineCache(averagine).populate()\n self.ms1_deconvolution_args['averagine'] = averagine\n if 'averagine' in self.msn_deconvolution_args:\n averagine = self.msn_deconvolution_args['averagine']\n if isinstance(averagine, (list, tuple)):\n averagine = [AveragineCache(a).populate() for a in averagine]\n else:\n averagine = AveragineCache(averagine).populate()\n self.msn_deconvolution_args['averagine'] = averagine\n\n def _reject_candidate_precursor_peak(self, peak, product_scan):\n isolation = product_scan.isolation_window\n if isolation is None or isolation.is_empty():\n pinfo = product_scan.precursor_information\n err = peak.mz - pinfo.mz\n return abs(err) > self.default_precursor_ion_selection_window\n else:\n return peak.mz not in isolation and self.respect_isolation_window\n\n @property\n def reader(self):\n '''The :class:`~.ScanIterator` which generates the raw scans that will\n be processed.\n\n Returns\n -------\n :class:`~.ScanIterator`\n '''\n return self._signal_source\n\n def _get_envelopes(self, precursor_scan):\n \"\"\"Get the m/z intervals to pick peaks from for the\n given MS1 scan\n\n Parameters\n ----------\n precursor_scan: Scan\n\n Returns\n -------\n list or None\n \"\"\"\n if not self.pick_only_tandem_envelopes and self.envelope_selector is None:\n return None\n elif self.envelope_selector is None:\n chosen_envelopes = [s.precursor_information for s in precursor_scan.product_scans]\n chosen_envelopes = sorted([(p.mz - 5, p.mz + 10) for p in chosen_envelopes])\n else:\n chosen_envelopes = self.envelope_selector(precursor_scan)\n return chosen_envelopes\n\n def _pick_precursor_scan_peaks(self, precursor_scan, chosen_envelopes=None):\n \"\"\"Pick peaks from the given precursor scan\n\n Parameters\n ----------\n precursor_scan: Scan\n Scan to pick peaks from\n chosen_envelopes: list, optional\n list of m/z intervals to pick peaks for\n\n Returns\n -------\n PeakSet\n \"\"\"\n if precursor_scan.is_profile:\n peak_mode = 'profile'\n else:\n peak_mode = 'centroid'\n prec_mz, prec_intensity = precursor_scan.arrays\n if not self.pick_only_tandem_envelopes and self.envelope_selector is None:\n prec_peaks = pick_peaks(prec_mz, prec_intensity, peak_mode=peak_mode, **self.ms1_peak_picking_args)\n else:\n if chosen_envelopes is None:\n chosen_envelopes = self._get_envelopes(precursor_scan)\n prec_peaks = pick_peaks(prec_mz, prec_intensity, peak_mode=peak_mode,\n target_envelopes=chosen_envelopes,\n **self.ms1_peak_picking_args)\n return prec_peaks\n\n def _average_ms1(self, precursor_scan):\n \"\"\"Average signal from :attr:`self.ms1_averaging` scans from\n before and after ``precursor_scan`` and pick peaks from the\n averaged arrays.\n\n Parameters\n ----------\n precursor_scan: Scan\n The scan to use as a point of reference\n\n Returns\n -------\n PeakSet\n \"\"\"\n # averaged scans are always profile mode\n new_scan = precursor_scan.average(self.ms1_averaging)\n prec_peaks = pick_peaks(*new_scan.arrays,\n target_envelopes=self._get_envelopes(precursor_scan),\n **self.ms1_peak_picking_args)\n return prec_peaks\n\n def pick_precursor_scan_peaks(self, precursor_scan):\n \"\"\"Picks peaks for the given ``precursor_scan`` using the\n appropriate strategy.\n\n If :attr:`ms1_averaging` > 0, then the signal averaging strategy\n is used, otherwise peaks are picked directly.\n\n Parameters\n ----------\n precursor_scan: Scan\n\n Returns\n -------\n PeakSet\n \"\"\"\n self.log(\"Picking Precursor Scan Peaks: %r\" % (precursor_scan, ))\n if self.ms1_averaging > 0:\n prec_peaks = self._average_ms1(precursor_scan)\n else:\n prec_peaks = self._pick_precursor_scan_peaks(precursor_scan)\n n_peaks = len(prec_peaks)\n if n_peaks > self.too_many_peaks_threshold:\n self.log(\"%d peaks found for %r, applying local intensity threshold.\" % (n_peaks, precursor_scan))\n prec_peaks = _simplify_peak_set(prec_peaks)\n precursor_scan.peak_set = prec_peaks\n return prec_peaks\n\n def pick_product_scan_peaks(self, product_scan):\n \"\"\"Pick the peaks of product scan\n\n Parameters\n ----------\n product_scan: :class:`~.Scan`\n The scan to pick peaks from.\n\n Returns\n -------\n PeakSet\n \"\"\"\n if product_scan.is_profile:\n peak_mode = 'profile'\n else:\n peak_mode = 'centroid'\n product_mz, product_intensity = product_scan.arrays\n peaks = pick_peaks(product_mz, product_intensity, peak_mode=peak_mode, **self.msn_peak_picking_args)\n\n if peaks is None:\n raise EmptyScanError(\n \"Could not pick peaks for empty product scan\", self)\n\n product_scan.peak_set = peaks\n return peaks\n\n def get_precursor_peak_for_product_scans(self, precursor_scan): # pragma: no cover\n \"\"\"A utility method to obtain :class:`PriorityTarget` objects for\n each product scan of `precursor_scan`.\n\n Parameters\n ----------\n precursor_scan: :class:`~.Scan`\n The scan to extract.\n\n Returns\n -------\n :class:`list` of :class:`PriorityTarget`\n \"\"\"\n priorities = []\n peaks = precursor_scan.peak_set\n for scan in precursor_scan.product_scans:\n precursor_ion = scan.precursor_information\n if peaks is None:\n peaks = self.pick_precursor_scan_peaks(precursor_scan)\n peak, _ = peaks.get_nearest_peak(precursor_ion.mz)\n precursor_ion.peak = peak\n target = PriorityTarget(\n peak,\n precursor_ion,\n self.trust_charge_hint,\n isolation_window=scan.isolation_window)\n if self._reject_candidate_precursor_peak(peak, scan):\n self.log(\n \"Unable to locate a peak for precursor ion %r for tandem scan %s of precursor scan %s\" % (\n precursor_ion, scan.title,\n precursor_scan.title))\n else:\n priorities.append(target)\n return priorities\n\n def process_scan_group(self, precursor_scan, product_scans):\n \"\"\"Performs the initial extraction of information relating\n `precursor_scan` to `product_scans` and picks peaks for ``precursor_scan``.\n Called by :meth:`process`. May be used separately if doing the process step\n by step.\n\n Parameters\n ----------\n precursor_scan : :class:`~.Scan`\n An MS1 Scan\n product_scans : :class:`list` of :class:`~.Scan`\n A :class:`list` of MSn Scans related to `precursor_scan`\n\n Returns\n -------\n precursor_scan: :class:`~.Scan`\n As Parameter\n prioritiies: :class:`list` of :class:`~PriorityTarget`\n :class:`list` of the peak target windows in `precursor_scan` which\n are related to `product_scans`\n product_scans: :class:`list` of :class:`~.Scan`\n As Parameter\n \"\"\"\n prec_peaks = self.pick_precursor_scan_peaks(precursor_scan)\n priorities = []\n\n if prec_peaks is None:\n raise EmptyScanError(\n \"Could not pick peaks for empty precursor scan\", self)\n\n for scan in product_scans:\n precursor_ion = scan.precursor_information\n peak = prec_peaks.has_peak(precursor_ion.mz)\n if peak is not None:\n err = abs(peak.mz - precursor_ion.mz)\n else:\n peak, err = prec_peaks.get_nearest_peak(precursor_ion.mz)\n self.debug(\"For Precursor at %0.4f, found Peak at %0.4f with error %0.4f\" % (\n precursor_ion.mz, peak.mz, err))\n precursor_ion.peak = peak\n target = PriorityTarget(\n peak, precursor_ion, self.trust_charge_hint,\n scan.precursor_information.precursor_scan_id,\n scan.precursor_information.product_scan_id,\n isolation_window=scan.isolation_window)\n if self._reject_candidate_precursor_peak(peak, scan):\n self.log(\n \"Unable to locate a peak for precursor ion %r for tandem scan %s of precursor scan %s\" % (\n precursor_ion, scan.id,\n precursor_scan.id))\n else:\n priorities.append(target)\n\n return precursor_scan, priorities, product_scans\n\n def _default_all_precursor_information(self, scans):\n for scan in scans:\n if scan.ms_level > 1:\n scan.precursor_information.default(orphan=True)\n\n def deconvolute_precursor_scan(self, precursor_scan, priorities=None):\n \"\"\"Deconvolute the given precursor scan, giving priority to its product ions,\n correcting the :attr:`precursor_information` attributes of priority targets,\n as well as calculating the degree of precursor purity and coisolating ions.\n\n Parameters\n ----------\n precursor_scan : :class:`~.Scan`\n The precursor scan to deconvolute\n priorities : :class:`list` of :class:`PriorityTarget`, optional\n The priority targets for the product ions derived from `precursor_scan`\n\n Returns\n -------\n :class:`~DeconvolutedPeakSet`\n The deconvoluted peaks of ``precursor_scan``\n :class:`list` of :class:`PriorityTarget`\n The precursor ions selected, with updated mass and charge information\n\n Raises\n ------\n Exception\n Any errors which are thrown during the deconvolution process may be thrown\n if :attr:`terminate_on_error` is `True`.\n \"\"\"\n if priorities is None:\n priorities = []\n\n self.log(\"Deconvoluting Precursor Scan %r\" % precursor_scan)\n self.log(\"Priorities: %r\" % priorities)\n\n ms1_deconvolution_args = self.ms1_deconvolution_args.copy()\n\n if precursor_scan.polarity in (1, -1):\n polarity = precursor_scan.polarity\n ms1_deconvolution_args['charge_range'] = tuple(\n polarity * abs(c) for c in ms1_deconvolution_args['charge_range'])\n try:\n decon_result = deconvolute_peaks(\n precursor_scan.peak_set, priority_list=priorities,\n **ms1_deconvolution_args)\n except NoIsotopicClustersError as e:\n e.scan_id = precursor_scan.id\n if self.terminate_on_error:\n raise e\n else:\n self.log(\"No isotopic clusters found in %r\" % precursor_scan.id)\n\n dec_peaks, priority_results = decon_result\n if decon_result.errors:\n self.error(\"Errors occurred during deconvolution of %s, %r\" % (\n precursor_scan.id, decon_result.errors))\n precursor_scan.deconvoluted_peak_set = dec_peaks\n for pr in priority_results:\n if pr is None:\n continue\n else:\n pr.chosen_for_msms = True\n\n # `priorities` and `priority_results` are parallel lists. The\n # ith position in `priorities` corresponds to the ith deconvoluted\n # priority result in `priority_results`. The entry in `priority_results`\n # may be `None` if the deconvolution failed, but elements of `priorities`\n # should always be FittedPeak or Peak-like instances\n\n coisolation_detection = PrecursorPurityEstimator(default_width=self.default_precursor_ion_selection_window)\n self.debug(\"Priority Targets for %s: %r\" % (\n precursor_scan.id, [\n (p.mz, p.charge) if p is not None else None for p in priorities\n ]))\n for product_scan in precursor_scan.product_scans:\n precursor_information = product_scan.precursor_information\n\n # unknown precursor purity\n product_scan.annotations['precursor purity'] = 0.0\n i = _get_nearest_index(precursor_information.mz, priorities)\n\n # If no peak is found in the priority list, it means the priority list is empty.\n # This should never happen in the current implementation. If it did, then we forgot\n # to pass the priority list to this function.\n if i is None:\n self.log(\n \"Could not find deconvolution for %r (No nearby peak in the priority list)\" %\n precursor_information)\n precursor_information.default(orphan=True)\n continue\n\n peak = priority_results[i]\n # If the deconvolution result is None, then we have no answer\n if peak is None:\n self.log(\n \"Could not find deconvolution for %r (No solution was found for this region)\" %\n precursor_information)\n precursor_information.default(orphan=True)\n\n continue\n elif peak.charge == 1 or (peak.charge != precursor_information.charge and self.trust_charge_hint):\n if precursor_information.charge != ChargeNotProvided:\n self.log(\n \"Could not find deconvolution for %r (Unacceptable solution was proposed: %r)\" %\n (precursor_information, peak))\n precursor_information.default()\n continue\n\n precursor_purity = -1.0\n if peak is not None:\n precursor_purity, coisolation = coisolation_detection(\n precursor_scan,\n peak,\n product_scan.isolation_window)\n precursor_information.coisolation = coisolation\n self.debug(\n \"Precursor m/z %f\\nExperimental = %r\\nTheoretical = %r\" % (\n peak.mz,\n ', '.join([\"(%0.4f, %0.1f)\" % (p.mz, p.intensity) for p in peak.envelope]),\n ', '.join([\"(%0.4f, %0.1f)\" % (p.mz, p.intensity) for p in peak.fit.theoretical]))\n )\n\n product_scan.annotations['precursor purity'] = precursor_purity\n precursor_information.extract(peak)\n return dec_peaks, priority_results\n\n def deconvolute_product_scan(self, product_scan):\n \"\"\"Deconvolute the peaks of `product_scan`.\n\n This method will override the upper limit \"charge_range\" of\n :attr:`msn_deconvolution_args` to the charge information of\n the precursor ion.\n\n This method sets the :attr:`~.Scan.deconvoluted_peak_set` of\n `product_scan`.\n\n Parameters\n ----------\n product_scan : :class:`~.Scan`\n The scan to deconvolute.\n\n Returns\n -------\n :class:`~.DeconvolutedPeakSet`\n\n Raises\n ------\n Exception\n Any errors which are thrown during the deconvolution process may be thrown\n if :attr:`terminate_on_error` is `True`.\n \"\"\"\n self.log(\"Deconvoluting Product Scan %r\" % (product_scan, ))\n precursor_ion = product_scan.precursor_information\n top_charge_state = precursor_ion.extracted_charge\n if not top_charge_state:\n top_charge_state = precursor_ion.charge\n deconargs = dict(self.msn_deconvolution_args)\n charge_range = list(deconargs.get(\"charge_range\", [1, top_charge_state]))\n if top_charge_state is not None and top_charge_state is not ChargeNotProvided and\\\n top_charge_state != 0 and abs(top_charge_state) < abs(charge_range[1]):\n charge_range[1] = top_charge_state\n\n deconargs[\"charge_range\"] = charge_range\n\n if product_scan.polarity in (-1, 1):\n polarity = product_scan.polarity\n deconargs[\"charge_range\"] = [\n polarity * abs(c) for c in deconargs[\"charge_range\"]]\n\n try:\n dec_peaks, _ = deconvolute_peaks(product_scan.peak_set, **deconargs)\n except NoIsotopicClustersError as e:\n self.log(\"No Isotopic Clusters found in %r\" % product_scan.id)\n e.scan_id = product_scan.id\n if self.terminate_on_error:\n raise e\n\n product_scan.deconvoluted_peak_set = dec_peaks\n return dec_peaks\n\n def _get_next_scans(self):\n bunch = next(self.reader)\n try:\n precursor, products = bunch\n except ValueError:\n if isinstance(bunch, Scan):\n if bunch.ms_level == 1:\n precursor = bunch\n products = []\n else:\n precursor = None\n products = [bunch]\n\n if self.pick_only_tandem_envelopes:\n while len(products) == 0:\n precursor, products = next(self.reader)\n\n return precursor, products\n\n def process(self, precursor, products):\n \"\"\"Fully preprocesses the `precursor` and `products` scans, performing\n any necessary information sharing.\n\n This method may be used to process scans from other sources not from the\n wrapped :class:`~.ScanIterator`.\n\n Parameters\n ----------\n precursor : :class:`~.Scan`\n An MS1 Scan\n products : :class:`list` of :class:`~.Scan`\n A list of MSn Scans related to `precursor`\n\n Returns\n -------\n :class:`~.ScanBunch`\n The fully processed version of `precursor` and `products`\n \"\"\"\n precursor_scan, priorities, product_scans = self.process_scan_group(precursor, products)\n if precursor_scan is not None:\n self.deconvolute_precursor_scan(precursor_scan, priorities)\n else:\n self._default_all_precursor_information(product_scans)\n\n for product_scan in product_scans:\n self.pick_product_scan_peaks(product_scan)\n self.deconvolute_product_scan(product_scan)\n\n return ScanBunch(precursor_scan, product_scans)\n\n def next(self):\n \"\"\"Fetches the next bunch of scans from :attr:`reader` and\n invokes :meth:`process` on them, picking peaks and deconvoluting them.\n\n Returns\n -------\n ScanBunch\n \"\"\"\n precursor, products = self._get_next_scans()\n bunch = self.process(precursor, products)\n return bunch\n\n def __next__(self):\n \"\"\"Fetches the next bunch of scans from :attr:`reader` and\n invokes :meth:`process` on them, picking peaks and deconvoluting them.\n\n Returns\n -------\n ScanBunch\n \"\"\"\n return self.next()\n\n def __iter__(self):\n return self\n\n def pack_next(self):\n \"\"\"As :meth:`next`, except instead of producing :class:`ScanBunch` of\n :class:`Scan` instances, instead it uses :class:`ProcessedScan` to strip away\n much of the heavy information like the raw data arrays.\n\n Returns\n -------\n ScanBunch\n \"\"\"\n precursor, products = self._get_next_scans()\n precursor_scan, product_scans = self.process(precursor, products)\n return ScanBunch(precursor_scan.pack() if precursor_scan else None, [p.pack() for p in product_scans])\n\n def start_from_scan(self, *args, **kwargs):\n \"\"\"A wrapper around :meth:`~.RandomAccessScanSource.start_from_scan` provided by\n :attr:`reader`, if available.\n\n Returns\n -------\n self\n\n See Also\n --------\n :meth:`~.RandomAccessScanSource.start_from_scan`\n \"\"\"\n self.reader.start_from_scan(*args, **kwargs)\n return self\n\n\nScanProcessor.log_with_logger(logger)\n\n\ndef process(data_source, ms1_averagine=peptide, msn_averagine=peptide,\n ms1_score_threshold=20, msn_score_threshold=5, denoise=False,\n ms1_max_missed_peaks=1, pick_only_tandem_envelopes=False,\n trust_charge_hint=True, envelope_selector=None, terminate_on_error=True,\n ms1_averaging=0, respect_isolation_window=False, use_quick_charge=True):\n \"\"\"Construct a deconvolution pipeline for common applications.\n\n Parameters\n ----------\n data_source : :class:`str` or :class:`~.ScanIterator` or file-like object\n The scan data source to read raw spectra from\n ms1_averagine : :class:`~.Averagine` or :class:`~.AveragineCache`, optional\n The :class:`~.Averagine` model to use for MS1 scans. Defaults to\n :data:`ms_deisotope.averagine.peptide`.\n msn_averagine : :class:`~.Averagine` or :class:`~.AveragineCache`, optional\n The :class:`~.Averagine` model to use for MSn scans. Defaults to\n :data:`ms_deisotope.averagine.peptide`.\n ms1_score_threshold : float, optional\n The score threshold to use to reject isotopic pattern fits for MS1 scans.\n The default is 20.0.\n msn_score_threshold : float, optional\n The score threshold to use to reject isotopic pattern fits for MS1 scans.\n The default is 5.0.\n denoise : :class:`bool` or :class:`float`, optional\n Whether to denoise MS1 scans. If the value is not false-y, it may either be\n a float to set the scale of the denoising process, or 5.0 if the value is\n :const:`True`.\n ms1_max_missed_peaks : :class:`int`, optional\n The maximum number of missed peaks to permit for MS1 scans. The default is 1.\n pick_only_tandem_envelopes : :class:`bool`\n Whether or not to process whole MS1 scans or just the regions around those peaks\n chosen for MSn\n default_precursor_ion_selection_window : :class:`float`\n Size of the selection window to use when :attr:`pick_only_tandem_envelopes` is `True`\n and the information is not available in the scan.\n trust_charge_hint : :class:`bool`\n Whether or not to trust the charge provided by the data source when determining\n the charge state of precursor isotopic patterns. Defaults to `True`\n terminate_on_error: :class:`bool`\n Whether or not to stop processing on an error. Defaults to `True`\n ms1_averaging: :class:`int`\n The number of adjacent MS1 scans to average prior to picking peaks.\n respect_isolation_window: :class:`bool`\n Whether to use the bounds of the isolation window to reject a monoisotopic peak\n solution\n use_quick_charge : :class:`bool`, optional\n Whether or not to used the QuickCharge algorithm for expediting charge calculation.\n\n Returns\n -------\n :class:`ScanProcessor`\n \"\"\"\n if denoise:\n ms1_peak_picking_args = {\n \"filters\": [\n FTICRBaselineRemoval(\n scale=denoise if denoise is not True else 5., window_length=2)\n ]\n }\n else:\n ms1_peak_picking_args = None\n\n ms1_deconvolution_args = {\n \"averagine\": ms1_averagine,\n \"scorer\": PenalizedMSDeconVFitter(ms1_score_threshold, 2.0),\n \"use_quick_charge\": use_quick_charge,\n \"max_missed_peaks\": ms1_max_missed_peaks,\n \"truncate_after\": 0.95,\n }\n msn_deconvolution_args = {\n \"averagine\": msn_averagine,\n \"scorer\": MSDeconVFitter(msn_score_threshold),\n \"use_quick_charge\": use_quick_charge,\n \"truncate_after\": 0.8,\n }\n processor = ScanProcessor(\n data_source, ms1_peak_picking_args,\n None, ms1_deconvolution_args,\n msn_deconvolution_args, pick_only_tandem_envelopes,\n trust_charge_hint=trust_charge_hint,\n envelope_selector=envelope_selector,\n terminate_on_error=terminate_on_error,\n ms1_averaging=ms1_averaging,\n respect_isolation_window=respect_isolation_window)\n return processor\n\n\nclass EmptyScanError(ValueError):\n \"\"\"A sub-type of :class:`ValueError` which is used to indicate\n that a spectrum is empty and could not be manipulated.\n \"\"\"\n def __init__(self, msg, scan_id=None):\n ValueError.__init__(self, msg)\n self.scan_id = scan_id\n", "meta": {"hexsha": "0cb9bc6267e22ddb3a0ee5cc65cfccdd49852fe0", "size": 36627, "ext": "py", "lang": "Python", "max_stars_repo_path": "ms_deisotope/processor.py", "max_stars_repo_name": "WEHI-Proteomics/ms_deisotope", "max_stars_repo_head_hexsha": "24a289a7903e033b8b6cf6e3a1e6931ab75668b3", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-03-26T04:12:51.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-26T04:12:51.000Z", "max_issues_repo_path": "ms_deisotope/processor.py", "max_issues_repo_name": "WEHI-Proteomics/ms_deisotope", "max_issues_repo_head_hexsha": "24a289a7903e033b8b6cf6e3a1e6931ab75668b3", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ms_deisotope/processor.py", "max_forks_repo_name": "WEHI-Proteomics/ms_deisotope", "max_forks_repo_head_hexsha": "24a289a7903e033b8b6cf6e3a1e6931ab75668b3", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.3415682062, "max_line_length": 115, "alphanum_fraction": 0.6362519453, "include": true, "reason": "import numpy", "num_tokens": 8258, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6791786991753929, "lm_q2_score": 0.2877678218692626, "lm_q1q2_score": 0.19544577492170193}} {"text": "import numpy as np\nimport typing\nfrom collections import namedtuple\nfrom .materials import _IMMaterial\nfrom ._elastic_sub_surface_stresses import normal_conv_kernels, tangential_conv_kernels\n\n__all__ = ['Elastic', 'elastic_influence_matrix_spatial', 'elastic_influence_matrix_frequency', 'get_angular_velocity']\n\nElasticProps = namedtuple('ElasticProperties', 'K E v Lam M G', defaults=(None,) * 6)\n\n\n# noinspection PyPep8Naming\nclass Elastic(_IMMaterial):\n \"\"\" A Class for defining elastic materials\n\n Parameters\n ----------\n name: str\n The name of the material\n properties: dict\n dict of properties, dicts must have exactly 2 items.\n Allowed keys are : 'E', 'v', 'G', 'K', 'M', 'Lam'\n See notes for definitions\n max_load: float, optional (float('inf'))\n The maximum load on the surface, loads above this will be cropped during analysis, if this is specified a\n plastic deformation sub model should be added to the end of each model step to make the deformation permanent\n use_frequency_domain: bool, optional (True)\n If True the frequency domain definition of the influence matrix is used, otherwise the spatial domain definition\n is used.\n periodic_im_repeats: tuple, optional (1,1)\n The number of times the influence matrix should be wrapped in each dimension, used with spatially defined\n influence matrices and to set the zero frequency value for frequency domain influence matrices. Should not\n be used with non periodic contacts, for periodic contacts the total size should match the physical size. This\n is necessary to ensure truly periodic behaviour, no physical limit exists:\n (an infinitely long contact with any load per unit length will cause infinite displacement).\n zero_frequency_value: float, optional (None)\n If the frequency domain influence matrix is used the zero frequency value can be set, this defaults to the sum\n of the spatial influence matrix of the correct size. Should be set to 0 for fully periodic contacts.\n\n Methods\n -------\n speed_of_sound\n\n See Also\n --------\n\n Notes\n -----\n\n Keys refer to:\n - E - Young's modulus\n - v - Poission's ratio\n - K - Bulk Modulus\n - Lam - Lame's first parameter\n - G - Shear modulus\n - M - P wave modulus\n\n Examples\n --------\n >>> # Make a material model for elastic steel\n >>> steel = Elastic('steel', {'E': 200e9, 'v': 0.3})\n >>> # Find it's p-wave modulus:\n >>> pwm = steel.M\n >>> # Find the speeds of sound:\n >>> sos = steel.speed_of_sound(7890)\n \"\"\"\n\n material_type = 'Elastic'\n\n _properties = {'E': None,\n 'v': None,\n 'G': None,\n 'K': None,\n 'Lam': None,\n 'M': None, }\n\n _last_set = []\n density = None\n\n def __init__(self, name: str, properties: dict, max_load: float = np.inf,\n use_frequency_domain: bool = True, periodic_im_repeats: tuple = (1, 1),\n zero_frequency_value: float = None):\n super().__init__(name, use_frequency_domain, max_load,\n periodic_im_repeats, zero_frequency_value)\n\n if len(properties) > 2:\n raise ValueError(\"Too many properties supplied, must be 1 or 2\")\n\n for item in properties.items():\n self._set_props(*item)\n\n def _influence_matrix_spatial(self, components: typing.Union[typing.Sequence[str], str],\n grid_spacing: {typing.Sequence[float], float}, span: typing.Sequence[int]):\n \"\"\"\n Influence matrix for an elastic material\n\n Parameters\n ----------\n grid_spacing: tuple\n The spacing between grid points in the x and y directions\n span: tuple\n The span required in the x and y directions in number of grid points\n components: str or Sequence {'xx','xy','xz','yx','yy','yz','zx','zy','zz','all'}\n The required components eg the 'xy' component represents the x\n deflection caused by loads in the y direction\n\n Returns\n -------\n dict\n dict of the requested influence matrix or matrices\n\n See Also\n --------\n elastic_loading\n elastic_deflection\n\n Notes\n -----\n\n K^{ij i'j'}_zz=(1-v)/(2*pi*G)*Czz\n\n Czz=(hx*(k*log((m+sqrt(k**2+m**2))/(n+sqrt(k**2+n**2)))+\n l*log((n+sqrt(l**2+n**2))/(m+sqrt(l**2+m**2))))+\n hy*(m*log((k+sqrt(k**2+m**2))/(l+sqrt(l**2+m**2)))+\n n*log((l+sqrt(l**2+n**2))/(k+sqrt(k**2+n**2)))))\n\n In which:\n\n k=i'-i+0.5\n l=i'-i-0.5\n m=j'-j+0.5\n n=j'-j-0.5\n hx=grid_spacing[0]\n hy=grid_spacing[1]\n\n If both shear_modulus_2 and v_2 are supplied and are not None the combined IM is returned for the surface\n pair\n\n Examples\n --------\n\n\n References\n ----------\n Complete boundary element method formulation for normal and tangential\n contact problems\n\n \"\"\"\n shear_modulus_2 = None\n v_2 = None\n\n shear_modulus = self.G\n v = self.v\n\n components = {comp: elastic_influence_matrix_spatial(comp, span, grid_spacing, shear_modulus, v,\n shear_mod_2=shear_modulus_2, v_2=v_2) for comp in\n components}\n\n return components\n\n def _influence_matrix_frequency(self, components: typing.Sequence[str], grid_spacing: typing.Sequence[float],\n span: typing.Sequence[int]):\n x_omega, y_omega = get_angular_velocity(span, grid_spacing)\n norm_2 = x_omega ** 2 + y_omega ** 2\n norm = np.sqrt(norm_2)\n rtn_dict = {key: elastic_influence_matrix_frequency(y_omega, x_omega, norm, norm_2, key, self.E, self.v)\n for key in components}\n return rtn_dict\n\n def _del_props(self, prop):\n # delete any of the material properties\n keys = list(self._properties.keys())\n if self._last_set == prop:\n self._properties = {key: None for key in keys}\n self._last_set = None\n else:\n self._properties = {key: None for key in keys\n if not key == self._last_set}\n\n def _set_props(self, prop, value):\n allowed_props = ['E', 'v', 'G', 'K', 'Lam', 'M']\n if prop not in allowed_props:\n msg = (f'property {prop} not recognised allowed propertied are: ' +\n ' '.join(allowed_props))\n raise ValueError(msg)\n\n self._properties[prop] = np.float64(value)\n\n if len(self._last_set) == 0:\n self._last_set.append(prop) # if none ever set just set it\n elif self._last_set[-1] != prop:\n self._last_set.append(prop) # if the last set is different replace it\n\n if len(self._last_set) > 1: # if 2 props have been set update all\n set_props = {prop: np.float64(value),\n self._last_set[-2]: self._properties[self._last_set[-2]]}\n self._properties = _get_properties(set_props)\n return\n\n @property\n def E(self):\n \"\"\"The Young's modulus of the material\"\"\"\n return self._properties['E']\n\n @E.deleter\n def E(self):\n self._del_props('E')\n\n @E.setter\n def E(self, value):\n self._set_props('E', value)\n\n @property\n def v(self):\n \"\"\"The Poissions's ratio of the material\"\"\"\n return self._properties['v']\n\n @v.deleter\n def v(self):\n self._del_props('v')\n\n @v.setter\n def v(self, value):\n self._set_props('v', value)\n\n @property\n def G(self):\n \"\"\"The shear modulus of the material\"\"\"\n return self._properties['G']\n\n @G.deleter\n def G(self):\n self._del_props('G')\n\n @G.setter\n def G(self, value):\n self._set_props('G', value)\n\n @property\n def K(self):\n \"\"\"The bulk modulus of the material\"\"\"\n return self._properties['K']\n\n @K.deleter\n def K(self):\n self._del_props('K')\n\n @K.setter\n def K(self, value):\n self._set_props('K', value)\n\n @property\n def Lam(self):\n \"\"\"Lame's first parameter for the material\"\"\"\n return self._properties['Lam']\n\n @Lam.deleter\n def Lam(self):\n self._del_props('Lam')\n\n @Lam.setter\n def Lam(self, value):\n self._set_props('Lam', value)\n\n @property\n def M(self):\n \"\"\"The p wave modulus of the material\"\"\"\n return self._properties['M']\n\n @M.deleter\n def M(self):\n self._del_props('M')\n\n @M.setter\n def M(self, value):\n self._set_props('M', value)\n\n def speed_of_sound(self, density: float = None):\n \"\"\"find the speed of sound in the material\n\n Parameters\n ----------\n density : float optional (None)\n The density of the material\n\n Returns\n -------\n\n speeds : dict\n With keys 's' and 'p' giving the s and p wave speeds\n\n Notes\n -----\n\n Finds speeds according to the following equations:\n\n Vs=sqrt(G/rho)\n Vp=sqrt(M/rho)\n\n Where rho is the density, G is the shear modulus and M is the p wave\n modulus\n\n Examples\n --------\n >>> # Find the speed of sound in steel\n >>> my_material = Elastic({'E': 200e9, 'v': 0.3})\n >>> my_material.speed_of_sound(7850)\n\n \"\"\"\n if density is not None:\n self.density = density\n elif self.density is None:\n raise ValueError(\"Density not given or set\")\n\n speeds = {'s': np.sqrt(self.G / self.density),\n 'p': np.sqrt(self.M / self.density)}\n\n return speeds\n\n def sss_influence_matrices_normal(self, components: typing.Sequence[str], grid_spacing: typing.Sequence[float],\n span: typing.Sequence[int], z: typing.Sequence[float] = None, cuda: bool = False):\n if z is None:\n z_len = min(span)\n print(span)\n gs = grid_spacing[span.index(z_len)]\n print(gs)\n z = gs * np.arange(z_len // 2)\n z[0] = z[1] * 1e-4\n all_matrices = normal_conv_kernels(span, z, grid_spacing, self.E, self.v, cuda=cuda)\n return {comp: all_matrices[comp] for comp in components}\n\n def sss_influence_matrices_tangential_x(self, components: typing.Sequence[str],\n grid_spacing: typing.Sequence[float], span: typing.Sequence[int],\n z: typing.Sequence[float] = None, cuda: bool = False):\n if z is None:\n z_len = min(span)\n gs = grid_spacing[span.index(z_len)]\n z = gs * np.arange(z_len // 2)\n z[0] = z[1] * 1e-4\n all_matrices = tangential_conv_kernels(span, z, grid_spacing, self.v, cuda=cuda)\n return {comp: all_matrices[comp] for comp in components}\n\n def __repr__(self):\n return \"Elastic(name = '\" + self.name + f\"', properties = {{ 'E':{self.E}, 'v':{self.v} }}\"\n\n\ndef _get_properties(set_props: dict):\n \"\"\"Get all elastic properties from any pair\n\n Parameters\n ----------\n set_props : dict\n dict of properties must have exactly 2 members valid keys are: 'K',\n 'E', 'v', 'Lam', 'M', 'G'\n\n Returns\n -------\n out : dict\n dict of all material properties keys are: 'K', 'E', 'v', 'Lam', 'M', 'G'\n\n Notes\n -----\n\n Keys refer to:\n - E - Young's modulus\n - v - Poission's ratio\n - K - Bulk Modulus\n - Lam - Lame's first parameter\n - G - Shear modulus\n - M - P wave modulus\n\n \"\"\"\n if len(set_props) != 2:\n raise ValueError(\"Exactly 2 properties must be set,\"\n \" {} found\".format(len(set_props)))\n\n valid_keys = ['K', 'E', 'v', 'G', 'Lam', 'M']\n\n set_params = [key for key in list(set_props.keys()) if key in valid_keys]\n\n if len(set_params) != 2:\n msg = (\"Invalid keys in set_props keys found are: \" +\n \"{}\".format(set_props.keys()) +\n \". Valid keys are: \" + \" \".join(valid_keys))\n raise ValueError(msg)\n\n out = set_props.copy()\n\n set_params = list(set_props.keys())\n set_params.sort()\n # p is properties this saves a lot of space\n p = ElasticProps(**set_props)\n\n if set_params[0] == 'E':\n if set_params[1] == 'G':\n out['K'] = p.E * p.G / (3 * (3 * p.G - p.E))\n out['Lam'] = p.G * (p.E - 2 * p.G) / (3 * p.G - p.E)\n out['M'] = p.G * (4 * p.G - p.E) / (3 * p.G - p.E)\n out['v'] = p.E / (2 * p.G) - 1\n elif set_params[1] == 'K':\n out['G'] = 3 * p.K * p.E / (9 * p.K - p.E)\n out['Lam'] = 3 * p.K * (3 * p.K - p.E) / (9 * p.K - p.E)\n out['M'] = 3 * p.K * (3 * p.K + p.E) / (9 * p.K - p.E)\n out['v'] = (3 * p.K - p.E) / (6 * p.K)\n elif set_params[1] == 'Lam':\n R = np.sqrt(p.E ** 2 + 9 * p.Lam ** 2 + 2 * p.E * p.Lam)\n out['G'] = (p.E - 3 * p.Lam + R) / 4\n out['K'] = (p.E + 3 * p.Lam + R) / 6\n out['M'] = (p.E - p.Lam + R) / 2\n out['v'] = 2 * p.Lam / (p.E + p.Lam + R)\n elif set_params[1] == 'M':\n S = np.sqrt(p.E ** 2 + 9 * p.M ** 2 - 10 * p.E * p.M)\n out['G'] = (3 * p.M + p.E - S) / 8\n out['K'] = (3 * p.M - p.E + S) / 6\n out['Lam'] = (p.M - p.E + S) / 4\n out['v'] = (p.E - p.M + S) / (4 * p.M)\n else: # set_params[1]=='v'\n out['G'] = p.E / (2 * (1 + p.v))\n out['K'] = p.E / (3 * (1 - 2 * p.v))\n out['Lam'] = p.E * p.v / ((1 + p.v) * (1 - 2 * p.v))\n out['M'] = p.E * (1 - p.v) / ((1 + p.v) * (1 - 2 * p.v))\n elif set_params[0] == 'G':\n if set_params[1] == 'K':\n out['E'] = 9 * p.K * p.G / (3 * p.K + p.G)\n out['Lam'] = p.K - 2 * p.G / 3\n out['M'] = p.K + 4 * p.G / 3\n out['v'] = (3 * p.K - 2 * p.G) / (2 * (3 * p.K + p.G))\n elif set_params[1] == 'Lam':\n out['E'] = p.G * (3 * p.Lam + 2 * p.G) / (p.Lam + p.G)\n out['K'] = p.Lam + 2 * p.G / 3\n out['M'] = p.Lam + 2 * p.G\n out['v'] = p.Lam / (2 * (p.Lam + p.G))\n elif set_params[1] == 'M':\n out['E'] = p.G * (3 * p.M - 4 * p.G) / (p.M - p.G)\n out['K'] = p.M - 4 * p.G / 3\n out['Lam'] = p.M - 2 * p.G\n out['v'] = (p.M - 2 * p.G) / (2 * p.M - 2 * p.G)\n else: # set_params[1]=='v'\n out['E'] = 2 * p.G * (1 + p.v)\n out['K'] = 2 * p.G * (1 + p.v) / (3 * (1 - 2 * p.v))\n out['Lam'] = 2 * p.G * p.v / (1 - 2 * p.v)\n out['M'] = 2 * p.G * (1 - p.v) / (1 - 2 * p.v)\n elif set_params[0] == 'K':\n if set_params[1] == 'Lam':\n out['E'] = 9 * p.K * (p.K - p.Lam) / (3 * p.K - p.Lam)\n out['G'] = 3 * (p.K - p.Lam) / 2\n out['M'] = 3 * p.K - 2 * p.Lam\n out['v'] = p.Lam / (3 * p.K - p.Lam)\n elif set_params[1] == 'M':\n out['E'] = 9 * p.K * (p.M - p.K) / (3 * p.K + p.M)\n out['G'] = 3 * (p.M - p.K) / 4\n out['Lam'] = (3 * p.K - p.M) / 2\n out['v'] = (3 * p.K - p.M) / (3 * p.K + p.M)\n else: # set_params[1]=='v'\n out['E'] = 3 * p.K * (1 - 2 * p.v)\n out['G'] = (3 * p.K * (1 - 2 * p.v)) / (2 * (1 + p.v))\n out['Lam'] = 3 * p.K * p.v / (1 + p.v)\n out['M'] = 3 * p.K * (1 - p.v) / (1 + p.v)\n elif set_params[0] == 'Lam':\n if set_params[1] == 'M':\n out['E'] = (p.M - p.Lam) * (p.M + 2 * p.Lam) / (p.M + p.Lam)\n out['G'] = (p.M - p.Lam) / 2\n out['K'] = (p.M + 2 * p.Lam) / 3\n out['v'] = p.Lam / (p.M + p.Lam)\n else:\n out['E'] = p.Lam * (1 + p.v) * (1 - 2 * p.v) / p.v\n out['G'] = p.Lam(1 - 2 * p.v) / (2 * p.v)\n out['K'] = p.Lam * (1 + p.v) / (3 * p.v)\n out['M'] = p.Lam * (1 - p.v) / p.v\n else:\n out['E'] = p.M * (1 + p.v) * (1 - 2 * p.v) / (1 - p.v)\n out['G'] = p.M * (1 - 2 * p.v) / (2 * (1 - p.v))\n out['K'] = p.M * (1 + p.v) / (3 * (1 - p.v))\n out['Lam'] = p.M * p.v / (1 - p.v)\n\n return out\n\n\ndef get_angular_velocity(span, gs):\n r_omega = np.fft.fftfreq(span[1], d=gs[1]) * (2 * np.pi)\n c_omega = np.fft.fftfreq(span[0], d=gs[0]) * (2 * np.pi)\n return np.meshgrid(r_omega, c_omega)\n\n\ndef elastic_influence_matrix_frequency(y_omega, x_omega, norm, norm_2, comp: str, e: float, v: float):\n \"\"\"\n\n Parameters\n ----------\n y_omega: np.ndarray\n rotational velocity components in the y direction\n x_omega: np.ndarray\n rotational velocity components in the x direction\n norm: np.ndarray\n The norm of the velocity vectors\n norm_2: np.ndarray\n The squared norm of the velocity vectors\n comp: str\n The component to find for example 'xy' gives the deformations in the y direction caused by a load in the x\n direction\n e: float\n The Young's modulus of the material\n v: float\n The Poission's ratio of the material\n\n Returns\n -------\n The influence matrix component in the frequency domain\n\n \"\"\"\n with np.errstate(divide='ignore', invalid='ignore'):\n if comp == 'zz':\n fact = 2 * (1 - v ** 2)\n elif comp == 'yy':\n fact = 2 * (1 + v) * (1 - v * y_omega ** 2 / norm_2)\n elif comp == 'xx':\n fact = 2 * (1 + v) * (1 - v * x_omega ** 2 / norm_2)\n elif comp in ('xy', 'yx'):\n fact = y_omega * x_omega * 2 * v * (1 + v) / norm_2\n elif comp in ('yz', 'zy'):\n fact = 1j * y_omega * (1 + v) * (1 - 2 * v) / norm * (-1 if comp == 'zy' else 1)\n elif comp in ('xz', 'zx'):\n fact = 1j * x_omega * (1 + v) * (1 - 2 * v) / norm * (-1 if comp == 'zx' else 1)\n else:\n raise ValueError('component name not recognised: ' + comp + ', components must be lower case')\n rtn = fact * (1 / (e * norm))\n rtn[0, 0] = 0.0\n return rtn\n\n\n# noinspection PyTypeChecker\ndef elastic_influence_matrix_spatial(comp: str, span: typing.Sequence[int], grid_spacing: typing.Sequence[float],\n shear_mod: float, v: float,\n shear_mod_2: typing.Optional[float] = None,\n v_2: typing.Optional[float] = None) -> np.array:\n \"\"\"Find influence matrix components for an elastic contact problem\n\n Parameters\n ----------\n comp : str {'xx','xy','xz','yx','yy','yz','zx','zy','zz'}\n The component to be returned\n span: Sequence[int]\n The span of the influence matrix in the x and y directions\n grid_spacing: Sequence[float]\n The grid spacings in the x and y directions\n shear_mod : float\n The shear modulus of the surface material\n v : float\n The Poission's ratio of the surface material\n shear_mod_2: float (optional) None\n The shear modulus of the second surface for a combined stiffness matrix\n v_2: float (optional) None\n The Poisson's ratio of the second surface for a combined stiffness matrix\n fft: bool\n If true the fft of the influence matrix will be returned\n\n Returns\n -------\n C : array\n The influence matrix component requested\n\n See Also\n --------\n elastic_im\n\n Notes\n -----\n\n Don't use this function, used by: elastic_im\n\n References\n ----------\n Complete boundary element method formulation for normal and tangential\n contact problems\n\n \"\"\"\n span = tuple(span)\n try:\n # lets just see how this changes\n # i'-i and j'-j\n idmi = (np.arange(span[1]) - span[1] // 2 + (1 - span[1] % 2))\n jdmj = (np.arange(span[0]) - span[0] // 2 + (1 - span[0] % 2))\n mesh_idmi = np.tile(idmi, (span[0], 1))\n mesh_jdmj = np.tile(np.expand_dims(jdmj, -1), (1, span[1]))\n\n except TypeError:\n raise TypeError(\"Span should be a tuple of integers\")\n\n k = mesh_idmi + 0.5\n el = mesh_idmi - 0.5\n m = mesh_jdmj + 0.5\n n = mesh_jdmj - 0.5\n\n hy = grid_spacing[1]\n hx = grid_spacing[0]\n\n second_surface = (shear_mod_2 is not None) and (v_2 is not None)\n if not second_surface:\n v_2 = 1\n shear_mod_2 = 1\n\n if (shear_mod_2 is not None) != (v_2 is not None):\n raise ValueError('Either both or neither of the second surface parameters must be set')\n\n if comp == 'zz':\n c_zz = (hx * (k * np.log((m + np.sqrt(k ** 2 + m ** 2)) / (n + np.sqrt(k ** 2 + n ** 2))) +\n el * np.log((n + np.sqrt(el ** 2 + n ** 2)) / (m + np.sqrt(el ** 2 + m ** 2)))) +\n hy * (m * np.log((k + np.sqrt(k ** 2 + m ** 2)) / (el + np.sqrt(el ** 2 + m ** 2))) +\n n * np.log((el + np.sqrt(el ** 2 + n ** 2)) / (k + np.sqrt(k ** 2 + n ** 2)))))\n\n const = (1 - v) / (2 * np.pi * shear_mod) + second_surface * ((1 - v_2) / (2 * np.pi * shear_mod_2))\n ret = const * c_zz\n elif comp == 'xx':\n c_xx = (hx * (1 - v) * (k * np.log((m + np.sqrt(k ** 2 + m ** 2)) / (n + np.sqrt(k ** 2 + n ** 2))) +\n el * np.log(\n (n + np.sqrt(el ** 2 + n ** 2)) / (m + np.sqrt(el ** 2 + m ** 2)))) +\n hy * (m * np.log((k + np.sqrt(k ** 2 + m ** 2)) / (el + np.sqrt(el ** 2 + m ** 2))) +\n n * np.log((el + np.sqrt(el ** 2 + n ** 2)) / (k + np.sqrt(k ** 2 + n ** 2)))))\n const = 1 / (2 * np.pi * shear_mod) + second_surface * (1 / (2 * np.pi * shear_mod_2))\n ret = const * c_xx\n elif comp == 'yy':\n c_yy = (hx * (k * np.log((m + np.sqrt(k ** 2 + m ** 2)) / (n + np.sqrt(k ** 2 + n ** 2))) +\n el * np.log((n + np.sqrt(el ** 2 + n ** 2)) / (m + np.sqrt(el ** 2 + m ** 2)))) +\n hy * (1 - v) * (m * np.log((k + np.sqrt(k ** 2 + m ** 2)) / (el + np.sqrt(el ** 2 + m ** 2))) +\n n * np.log((el + np.sqrt(el ** 2 + n ** 2)) / (k + np.sqrt(k ** 2 + n ** 2)))))\n const = 1 / (2 * np.pi * shear_mod) + second_surface * (1 / (2 * np.pi * shear_mod_2))\n ret = const * c_yy\n elif comp in ['xz', 'zx']:\n c_xz = (hy / 2 * (m * np.log((k ** 2 + m ** 2) / (el ** 2 + m ** 2)) +\n n * np.log((el ** 2 + n ** 2) / (k ** 2 + n ** 2))) +\n hx * (k * (np.arctan(m / k) - np.arctan(n / k)) +\n el * (np.arctan(n / el) - np.arctan(m / el))))\n const = ((2 * v - 1) / (4 * np.pi * shear_mod) + second_surface * (\n (2 * v_2 - 1) / (4 * np.pi * shear_mod_2))) * (-1 if comp == 'zx' else 1)\n ret = const * c_xz\n elif comp in ['yx', 'xy']:\n c_yx = (np.sqrt(hy ** 2 * n ** 2 + hx ** 2 * k ** 2) -\n np.sqrt(hy ** 2 * m ** 2 + hx ** 2 * k ** 2) +\n np.sqrt(hy ** 2 * m ** 2 + hx ** 2 * el ** 2) -\n np.sqrt(hy ** 2 * n ** 2 + hx ** 2 * el ** 2))\n const = v / (2 * np.pi * shear_mod) + second_surface * (v_2 / (2 * np.pi * shear_mod_2))\n ret = const * c_yx\n elif comp in ['zy', 'yz']:\n c_zy = (hx / 2 * (k * np.log((k ** 2 + m ** 2) / (n ** 2 + k ** 2)) +\n el * np.log((el ** 2 + n ** 2) / (m ** 2 + el ** 2))) +\n hy * (m * (np.arctan(k / m) - np.arctan(el / m)) +\n n * (np.arctan(el / n) - np.arctan(k / n))))\n const = ((1 - 2 * v) / (4 * np.pi * shear_mod) + second_surface * (1 - 2 * v_2) / (\n 4 * np.pi * shear_mod_2)) * (-1 if comp == 'zy' else 1)\n ret = const * c_zy\n else:\n ValueError('component name not recognised: ' + comp + ', components must be lower case')\n return ret\n", "meta": {"hexsha": "70654813d75958fdab956901cbf8e764ee2586b0", "size": 24074, "ext": "py", "lang": "Python", "max_stars_repo_path": "slippy/core/elastic_material.py", "max_stars_repo_name": "FrictionTribologyEnigma/SlipPY", "max_stars_repo_head_hexsha": "a97fc5470ce5008ef4c049b82077cd1871f6ef2c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2018-10-30T03:30:42.000Z", "max_stars_repo_stars_event_max_datetime": "2020-05-18T17:09:55.000Z", "max_issues_repo_path": "slippy/core/elastic_material.py", "max_issues_repo_name": "FrictionTribologyEnigma/SlipPY", "max_issues_repo_head_hexsha": "a97fc5470ce5008ef4c049b82077cd1871f6ef2c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "slippy/core/elastic_material.py", "max_forks_repo_name": "FrictionTribologyEnigma/SlipPY", "max_forks_repo_head_hexsha": "a97fc5470ce5008ef4c049b82077cd1871f6ef2c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.8103975535, "max_line_length": 120, "alphanum_fraction": 0.497673839, "include": true, "reason": "import numpy", "num_tokens": 7143, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.679178699175393, "lm_q2_score": 0.2877678157610531, "lm_q1q2_score": 0.19544577077313618}} {"text": "\"\"\"\nModule for dealing with LSFs of various astronomical instruments.\n\"\"\"\nfrom __future__ import print_function, absolute_import, division, unicode_literals\n\nimport numpy as np\nfrom scipy.interpolate import interp1d\nfrom astropy.io import fits, ascii\nfrom astropy.units import Quantity\nimport astropy.units as u\nfrom astropy.table import Table, QTable, Column\nimport glob, imp\nfrom linetools.analysis.interp import interp_Akima\nimport warnings\n\nlt_path = imp.find_module('linetools')[1]\n\nclass LSF(object):\n \"\"\"Class to deal with line-spread-functions (LSFs) from\n various different astronomical spectrographs.\n\n Note: only implemented for HST/COS and HST/STIS at the moment.\n\n Parameters\n ----------\n instr_config : dict\n A dictionary with the instrument configuration details relevant\n to the required LSF. Mandatory keywords of the dict are: ['name'], \n all of which must be either string or None. \n Note: There must be extra relevant keywords specific to each instrument.\n\n \"\"\"\n\n def __init__(self, instr_config):\n # mandatory keys for characterizing a spectrograph mode\n self.mandatory_dict_keys = ['name']\n \n # Check correct format\n if not isinstance(instr_config, dict):\n raise TypeError('`instr_config` must be a dictionary.')\n elif not all([key in instr_config.keys() for key in self.mandatory_dict_keys]):\n raise SyntaxError('`instr_config` must have the following mandatory keys {}:'.format(self.mandatory_dict_keys))\n\n # Initialize basics\n self.instr_config = instr_config\n self.name = instr_config['name']\n if self.name not in ['COS', 'STIS']:\n raise NotImplementedError('Not ready for this instrument: {}'.format(self.name))\n \n # initialize specific to given instrument name\n # only implemented for HST/COS and HST/STIS so far\n if self.name == 'COS':\n self.pixel_scale, self._data = self.load_COS_data()\n elif self.name == 'STIS':\n self.pixel_scale, self._data = self.load_STIS_data()\n # IMPORTANT: make sure that LSFs are given in linear wavelength scales !!!\n\n #reformat self._data\n self.check_and_reformat_data()\n \n #other relevant values to initialize?\n\n def get_lsf(self, wv_array, kind='Akima'):\n \"\"\" Given a wavelength array `wv_array`, it returns\n the LSF kernel at the central wavelength of the array, \n using the same pixel scale and extent of `wv_array`. \n\n Method for non-Gaussian kernels: First, tabulated LSFs\n are linearly interpolated to the center of `wv_array`\n (see LSF.interpolate_to_wv0() for details); then, the\n LSF is interpolated to match the `wv_array`\n scale and extent using Akima (or cubic) interpolation (see\n LSF.interpolate_to_wv_array() for details).\n\n Parameters\n ----------\n wv_array : Quantity numpy.ndarray, shape(N,)\n Wavelength array for which the LSF kernel is defined. The \n central wavelength value of `wv_array` define the wavelength\n at which the LSF is defined, while the limits of `wv_array` \n define the extent of the kernel.\n kind : str, optional\n Specifies the kind of interpolation as a string either \n ('cubic', 'Akima')\n\n Returns\n -------\n lsf_array : numpy.ndarray, shape(N,)\n The lsf kernel.\n\n \"\"\"\n lsf_array = self.interpolate_to_wv_array(wv_array, kind=kind)\n return lsf_array['kernel'].data\n\n def check_and_reformat_data(self):\n \"\"\"Any re-formating of self._data should happen here.\n\n At the moment this function does the following:\n - Make sure that the number of relative pixels of the LSF is odd integer\n - Impose the middle value to define the 0 relative pixel\n - Make sure tables with 'rel_pix' given in fraction of pixels (e.g. COS NUV) work properly\n - Normalize tabulated LSFs\n \"\"\"\n\n self._data['rel_pix'] = self.check_and_reformat_relpix(self._data['rel_pix'].data)\n\n #normalize given LSFs\n for col_name in self._data.keys()[1:]:\n self._data[col_name] /= np.sum(self._data[col_name])\n\n def check_and_reformat_relpix(self, relpix):\n \"\"\"Performs checks and reformating on a relative pixel array.\n\n At the moment this function does the following:\n - Make sure that the number of relative pixels of the LSF is an odd integer\n - Impose the middle value to define the 0 relative pixel\n\n Parameters\n ----------\n relpix : np.array\n Relative pixel array\n\n Returns\n -------\n new_relpix array that conforms to the LSF class standards.\n \"\"\"\n\n # odd integer for total number of relative pixels\n n_pix = len(relpix)\n assert n_pix % 2 != 0, ValueError('LSF tables must be given as odd integers!')\n\n # make sure relpix == 0 is in the middle of the array\n n_half = int( (n_pix - 1) / 2)\n mid_value = relpix[n_half]\n new_relpix = relpix - mid_value # 0 in the middle\n\n\n return new_relpix\n\n def load_COS_data(self):\n \"\"\"Load the right data according to `instr_config` for HST/COS \n instrument\"\"\"\n\n # define pixel scales; values obtained from STScI\n # these values must be consistent with the given LSFs\n pixel_scale_dict = {'G130M': 9.97 / 1000. * u.AA,\n 'G160M': 12.23 / 1000. * u.AA,\n 'G140L': 80.3 / 1000. * u.AA,\n 'G230L': 390. / 1000. * u.AA,\n 'G185M': 37. / 1000. * u.AA,\n 'G225M': 33. / 1000. * u.AA,\n 'G285M': 40. / 1000. * u.AA}\n # define channel based on grating name\n channel_dict = {'G130M': 'FUV',\n 'G160M': 'FUV',\n 'G140L': 'FUV',\n 'G230L': 'NUV',\n 'G185M': 'NUV',\n 'G225M': 'NUV',\n 'G285M': 'NUV'}\n\n try:\n grating = self.instr_config['grating']\n except:\n raise SyntaxError('`grating` keyword missing in `instr_config` dictionary.')\n \n if grating not in channel_dict.keys():\n raise NotImplementedError('Not ready for this HST/COS grating: {}'.format(grating))\n\n if channel_dict[grating] == 'NUV': #there is only 1 LSF file for NUV data\n file_name = 'nuv_all_lp1.txt'\n # COS\n elif channel_dict[grating] == 'FUV':\n # Use the ones corrected by scattering when possible\n # (currently, these are only available for lifetime-position 1)\n # check: http://www.stsci.edu/hst/cos/performance/spectral_resolution\n try:\n life_position = self.instr_config['life_position']\n except:\n raise SyntaxError('`life_position` keyword missing in `instr_config` dictionary.')\n\n if life_position not in ['1','2','3']:\n raise ValueError('HST/COS `life_position` should be either `1` or `2` or `3` (strings)')\n\n if life_position == '1':\n if grating == 'G140L': #use theoretical values \n file_name = 'fuv_G140L_lp1.txt'\n \n elif grating == 'G130M': #use empirical values corrected by scattering\n file_name = 'fuv_G130M_lp1_empir.txt'\n\n elif grating == 'G160M': #use empirical values corrected by scattering\n file_name = 'fuv_G160M_lp1_empir.txt'\n \n elif life_position in ['2','3']:\n try:\n cen_wave = self.instr_config['cen_wave']\n except:\n raise SyntaxError('`cen_wave` keyword missing in `instr_config` dictionary. This should provide the central wavelength of the grating in Angstroms as a string.')\n #adjust format in cases where cen_wave is of the form: str(1230A)\n if cen_wave.endswith('A'): #adjust format\n cen_wave = cen_wave[:-1]\n \n #filenames in this case have a well defined naming convention, and strict format.\n if life_position == '2':\n file_name = 'fuv_{}_{}_lp2.txt'.format(grating,cen_wave)\n elif life_position == '3':\n file_name = 'fuv_{}_{}_lp3.txt'.format(grating,cen_wave)\n else: # this should never happen\n raise NotImplementedError('Unexpected error: please contact linetools developers!')\n\n else: # Wrong COS channel\n raise NotImplementedError('Not ready for the given HST/COS channel; only `NUV` and `FUV` channels allowed.')\n \n # point to the right file\n file_name = lt_path + '/data/lsf/{}/{}'.format(self.name,file_name)\n \n # get column names\n f = open(file_name,'r')\n line = f.readline() # first line of file\n f.close()\n # get rid of '\\n' in first line\n line = line.split('\\n')[0]\n # by construction first column should be separated by `,`\n col_names = line.split(',')\n col_names[0] = 'rel_pix'\n \n pixel_scale = pixel_scale_dict[grating] # read from dictionary defined above\n # read data\n data = ascii.read(file_name, data_start=1, names=col_names)\n \n return pixel_scale, data\n\n def load_STIS_data(self):\n \"\"\"Load the right data according to `instr_config` for HST/STIS\n instrument\"\"\"\n\n # define pixel scales; values obtained from STScI\n # these values must be consistent with the given LSFs\n pixel_scale_dict = {\n 'G140L': 0.60 * u.AA,\n 'G140M': 0.05 * u.AA,\n 'G230L': 1.58 * u.AA,\n 'G230M': 0.09 * u.AA,\n 'E140M': 'lambda/91700',\n 'E140H': 'lambda/228000',\n 'E230M': 'lambda/60000',\n 'E230H': 'lambda/228000',\n 'G230LB': 1.35 * u.AA,\n 'G230MB': 0.15 * u.AA,\n 'G430L': 2.73 * u.AA,\n 'G430M': 0.28 * u.AA,\n 'G750L': 4.92 * u.AA,\n 'G750M': 0.56 * u.AA\n }\n # define channel based on grating name\n channel_dict = {\n 'G140L': 'FUV-MAMA',\n 'G140M': 'FUV-MAMA',\n 'G230L': 'NUV-MAMA',\n 'G230M': 'NUV_MAMA',\n 'E140M': 'FUV-MAMA',\n 'E140H': 'FUV-MAMA',\n 'E230M': 'NUV-MAMA',\n 'E230H': 'NUV-MAMA',\n 'G230LB': 'CCD',\n 'G230MB': 'CCD',\n 'G430L': 'CCD',\n 'G430M': 'CCD',\n 'G750L': 'CCD',\n 'G750M': 'CCD'\n }\n # also need slits\n available_slits = {\n 'G140L': ['52x0.1', '52x0.2', '52x0.5', '52x2.0'],\n 'G140M': ['52x0.1', '52x0.2', '52x0.5', '52x2.0'],\n 'G230L': ['52x0.1', '52x0.2', '52x0.5', '52x2.0'],\n 'G230M': ['52x0.1', '52x0.2', '52x0.5', '52x2.0'],\n 'E140H': ['0.1x0.03', '0.2x0.09', '0.2x0.2', '6x0.2'],\n 'E140M': ['0.1x0.03', '0.2x0.06', '0.2x0.2', '6x0.2'],\n 'E230H': ['0.1x0.03', '0.1x0.09', '0.1x0.2', '6x0.2'],\n 'E230M': ['0.1x0.03', '0.2x0.06', '0.2x0.2', '6x0.2'],\n 'G430L': ['52x0.1', '52x0.2', '52x0.5', '52x2.0'],\n 'G750L': ['52x0.1', '52x0.2', '52x0.5', '52x2.0']\n }\n\n try:\n grating = self.instr_config['grating']\n except:\n raise SyntaxError('`grating` keyword missing in `instr_config` dictionary.')\n if grating not in channel_dict.keys():\n raise NotImplementedError('Not ready for this HST/STIS grating: {}. '\n 'Available gratings for HST/STIS are: {}'.format(grating, channel_dict.keys()))\n if grating in ['G750M', 'G430M', 'G430L']:\n raise NotImplementedError('{} not implemented yet; coming soon...'.format(grating))\n\n # We also need to know the slit width\n try:\n slit = self.instr_config['slit']\n except:\n raise SyntaxError('`slit` keyword missing in `instr_config` dictionary.')\n if slit not in available_slits[grating]:\n raise NotImplementedError('Not ready for this HST/STIS slit: {}. '\n 'Available slits for HST/STIS grating {} are: {}'.format(slit, grating, available_slits[grating]))\n\n # now we need to read the right files (new ones for echelle modes)\n if grating[0]=='E':\n lsf_files = glob.glob(lt_path + '/data/lsf/STIS/stis_LSF_{}_????_LTmod.txt'.format(grating))\n # figure relevant wavelengths from file names\n wa_names = [fname.split('/')[-1].split('_')[-2].split('.')[0] for fname in lsf_files]\n else:\n lsf_files = glob.glob(lt_path + '/data/lsf/STIS/stis_LSF_{}_????.txt'.format(grating))\n # figure relevant wavelengths from file names\n wa_names = [fname.split('/')[-1].split('_')[-1].split('.')[0] for fname in lsf_files]\n #TODO: Remove following lines upon testing\n '''\n # figure relevant wavelengths from file names\n #wa_names = [fname.split('/')[-1].split('_')[-1].split('.')[0] for fname in lsf_files]\n '''\n # sort them\n sorted_inds = np.argsort(wa_names)\n lsf_files = np.array(lsf_files)[sorted_inds]\n wa_names = np.array(wa_names)[sorted_inds]\n\n # read the relevant kernels; they may have different rel_pix values depending on wave\n kernels_dict = dict()\n for ii, file_name in enumerate(lsf_files):\n # get the column names\n f = open(file_name,'r')\n lines = f.readlines() # get all lines\n f.close()\n col_names = lines[1] # column names are in second line\n # get rid of '\\n'\n col_names = col_names.split('\\n')[0]\n # split by blank space(s) and remove the first element\n col_names = col_names.split()[1:]\n # rename new first column\n col_names[0] = 'rel_pix'\n\n # get original data\n data_aux = ascii.read(file_name, data_start=2, names=col_names)\n # reformat rel_pix\n data_aux['rel_pix'] = self.check_and_reformat_relpix(data_aux['rel_pix'])\n\n #TODO: remove the following block upon testing\n '''\n # handle asymmetric STIS LSF\n if data_aux['rel_pix'][len(data_aux['rel_pix']) // 2] == 0.:\n pass\n elif data_aux['rel_pix'][(len(data_aux['rel_pix']) // 2) - 1 ] ==0.:\n data_aux.insert_row(0,data_aux[-1])\n data_aux['rel_pix'][0]=-data_aux['rel_pix'][-1]\n elif data_aux['rel_pix'][(len(data_aux['rel_pix']) // 2) + 1 ] ==0.:\n data_aux.add_row(data_aux[0])\n data_aux['rel_pix'][-1]=-data_aux['rel_pix'][0]\n '''\n\n # create column with absolute wavelength based on pixel scales\n if isinstance(pixel_scale_dict[grating],np.unicode):\n # deal with wavelength-dependent pixel scale (i.e., STIS echelle)\n scalefac = 1./float(pixel_scale_dict[grating].split('/')[-1])\n wave_aux = float(wa_names[ii])*u.AA * (1. + data_aux['rel_pix']*scalefac)\n else:\n wave_aux = float(wa_names[ii])*u.AA + data_aux['rel_pix']*pixel_scale_dict[grating]\n data_aux['wv'] = wave_aux # not used for now, but may be useful with a different approach\n # create column with normalized kernel for relevant slit\n kernel = data_aux[slit] / np.sum(data_aux[slit])\n data_aux['kernel'] = kernel\n\n # store only rel_pix, wv, kernel as Table\n kernels_dict[wa_names[ii]] = data_aux['rel_pix', 'wv', 'kernel']\n\n # at this point the kernels_dict have the original information as given by the STScI\n # tables, in their various formats...\n\n # project to a single rel_pix scale using interpolation; for simplicity use a\n # custom rel_pix because STScI sometimes provide them as non-constant pixel fractions.\n # This new rel_pix grid will apply to all the wavelengths\n\n rel_pix = kernels_dict[wa_names[0]]['rel_pix'] # use the first one as reference\n rel_pix = np.linspace(-1*np.max(rel_pix), np.max(rel_pix), len(rel_pix)) # impose them linear and symmetric\n rel_pix = self.check_and_reformat_relpix(rel_pix) # again just in case something odd happened\n data_table = Table()\n data_table['rel_pix'] = rel_pix\n for wa_name in wa_names:\n kernel_aux = interp_Akima(data_table['rel_pix'],\n kernels_dict[wa_name]['rel_pix'], kernels_dict[wa_name]['kernel'])\n data_table['{}A'.format(wa_name)] = kernel_aux\n\n pixel_scale = pixel_scale_dict[grating] # read from dictionary defined above\n # import pdb; pdb.set_trace()\n # todo: work out a cleverer approach to this whole issue of having different rel_pix, pixel_scales, etc\n return pixel_scale, data_table\n\n def interpolate_to_wv0(self, wv0):\n \"\"\"Retrieves a unique LSF valid at wavelength wv0\n\n This is done by linearly interpolating from tabulated values\n at different wavelengths. These tabulated values (stored\n internally in self._data) are usually given as calibration\n products by instrument developers and should be loaded by\n self.load_XX_data() in the initialization stage of LSF(),\n where XX is the name of the instrument)\n\n Parameters\n ----------\n wv0 : Quantity \n Wavelength at which an LSF solution is required\n\n Returns\n -------\n lsf_table : Table\n The interpolated lsf at wv0. This table has two \n columns: 'wv' and 'kernel'\n \"\"\"\n # get wa0 to Angstroms\n wv0 = wv0.to('AA').value\n\n # transform to wavelength in float() form assuming Angstroms\n col_names = self._data.keys()\n col_waves = np.array([float(name.split('A')[0]) for name in col_names[1:]])\n\n # find out the closest 2 columns in self._data to wv0 (on each side); these kernels will be used for interpolation\n seps = np.fabs(col_waves - wv0)\n closest_ind = np.argsort(seps)[0] # the 1 closest\n if closest_ind == 0: # lower edge\n ind_blue = closest_ind\n elif closest_ind == len(col_waves) - 1: # upper edge\n ind_blue = closest_ind - 1\n elif (col_waves[closest_ind] - wv0) > 0: # middle case 1\n ind_blue = closest_ind - 1\n else: # middle case 2\n ind_blue = closest_ind\n ind_red = ind_blue + 1\n\n # create a smaller version of self._data with the 2 most relevant columns\n good_keys = col_names[1:] # get rid of the first name, i.e. 'rel_pix'\n good_keys = good_keys[ind_blue : ind_red + 1]\n data_aux = self._data[good_keys]\n col_waves_aux = col_waves[ind_blue : ind_red + 1]\n lsf_vals = []\n for row in data_aux:\n aux_val = []\n for i in range(0, len(row)):\n aux_val += [row[i]]\n\n # we don't want to extrapolate wildly, but allow LSF instantiations for wv0 outside range of 'col_waves'\n if (wv0 >= col_waves_aux[0]) & (wv0 <= col_waves_aux[-1]):\n f = interp1d(col_waves_aux,aux_val,bounds_error=True,kind='linear') # no need to extrapolate\n lsf_vals += [f(wv0)]\n\n elif (wv0 < col_waves[0]) & ((col_waves[0] - wv0) < np.abs(col_waves[1] - col_waves[0])):\n f = interp1d(col_waves_aux, aux_val, bounds_error=False,\n fill_value=aux_val[0], kind='linear') # assign shortest wv LSF definition\n lsf_vals += [f(wv0)]\n\n # warning\n if (col_waves[0] - wv0) > (np.abs(col_waves[1] - col_waves[0])/2.):\n warnings.warn(\n \"LSF may result from extrapolation outside wavelength range characterized for current grating.\")\n\n elif (wv0 > col_waves[-1]) & ((wv0 - col_waves[-1]) < np.abs(col_waves[-1] - col_waves[-2])):\n f = interp1d(col_waves_aux, aux_val, bounds_error=False,\n fill_value=aux_val[-1], kind='linear') #assign longest wv LSF definition\n lsf_vals += [f(wv0)]\n\n # warning\n if (wv0 - col_waves[-1]) > (np.abs(col_waves[-1] - col_waves[-2])/2.):\n warnings.warn(\n \"LSF may result from extrapolation outside wavelength range characterized for current grating.\")\n else:\n raise ValueError(\"wv0 too far outside range of defined LSFs. Perhaps you've chosen the wrong grating?\")\n lsf_vals = np.array(lsf_vals)\n\n # normalize\n lsf_vals /= np.sum(lsf_vals)\n\n # create Column to store the interpolated LSF\n # lsf_vals = Column(name='{:.0f}A'.format(wv0.value),data=lsf_vals)\n lsf_vals = Column(name='kernel', data=lsf_vals)\n\n # create column of relative pixel in absolute wavelength\n if isinstance(self.pixel_scale,np.unicode):\n # deal with wavelength-dependent pixel scale (i.e., STIS echelle)\n scalefac = 1./float(self.pixel_scale.split('/')[-1])\n wv_array = [(wv0*u.AA * (1. + scalefac * self._data['rel_pix'][i])).value\n for i in range(len(self._data))]\n else:\n wv_array = [(self.pixel_scale * self._data['rel_pix'][i] + wv0*u.AA).value for i in range(len(self._data))]\n wv = Column(name='wv',data=wv_array, unit=u.AA)\n\n # create lsf Table\n lsf = Table()\n lsf.add_column(wv)\n lsf.add_column(lsf_vals)\n\n # return lsf Table()\n return lsf\n\n def interpolate_to_wv_array(self, wv_array, kind='Akima', debug=False):\n \"\"\" Interpolate an LSF to a wavelength array.\n \n Given `wv_array` this function interpolates an LSF\n to match both scale and extent of `wv_array` using the \n Akima or cubic-spline interpolators (default is Akima). \n Some checks are performed too.\n\n Parameters\n ----------\n wv_array : Quantity numpy.ndarray, shape(N,)\n Wavelength array for which the LSF kernel is defined. The \n central wavelength value of `wv_array` define the wavelength\n at which the LSF is defined, while the limits of `wv_array` \n define the extent of the kernel.\n kind : str, optional\n Specifies the kind of interpolation as a string either \n ('cubic', 'Akima'); default is `Akima`.\n\n Returns\n -------\n lsf_table : Table\n The interpolated lsf using at the central wavelength of \n `wv_array`, using the same pixel scale as `wv_array`. \n This table has two columns: 'wv' and 'kernel'. (lst_table['wv'] \n is equal to `wv_array` by construction.)\n\n \"\"\"\n # Check correct format\n if not ((isinstance(wv_array, np.ndarray)) or (isinstance(wv_array, Quantity))):\n raise SyntaxError('`wv_array` must be Quantity numpy.ndarray')\n elif len(wv_array.shape) != 1:\n raise SyntaxError('`wv_array` must be of shape(N,), i.e. 1-dimensional array')\n if kind not in ['cubic','Akima','akima']:\n raise ValueError('Only `cubic` or `Akima` interpolation available.')\n\n # define useful quantities\n wv_min = np.min(wv_array)\n wv_max = np.max(wv_array)\n wv0 = 0.5 * (wv_max + wv_min)\n\n lsf_tab = self.interpolate_to_wv0(wv0)\n\n # make sure the wv_array is dense enough to sample the LSF kernel\n kernel_wvmin = np.min(lsf_tab['wv']) * u.AA\n kernel_wvmax = np.max(lsf_tab['wv']) * u.AA\n cond = (wv_array >= kernel_wvmin) & (wv_array <= kernel_wvmax)\n if np.sum(cond) < 10: # this number is somewhat arbitrary but reasonable\n raise ValueError('The input `wv_array` is undersampling the LSF kernel! Try a finer grid.')\n\n # convert to Angstroms\n wv_array_AA = np.array([wv.to('AA').value for wv in wv_array])\n \n # interpolate to wv_array\n if kind == 'cubic':\n f = interp1d(lsf_tab['wv'], lsf_tab['kernel'], kind='cubic', bounds_error= False, fill_value=0)\n lsf_vals = f(wv_array_AA)\n elif kind in ('Akima','akima'):\n # f = Akima1DInterpolator(lsf_tab['wv'],lsf_tab['kernel']) \n # NT: I tried Akima interpolator from scipy.interpolate\n # and is not robust in extreme situations where the\n # wv_array is large compared to the kernel FWHM.\n # Let's try linetools.analysis.interp Akima version\n lsf_vals = interp_Akima(wv_array_AA,lsf_tab['wv'],lsf_tab['kernel'])\n\n # make sure the kernel is never negative\n cond = lsf_vals < 0\n if np.sum(cond) > 0:\n warnings.warn('The interpolated kernel has negative values; imposing them to be 0.')\n if debug:\n import matplotlib.pyplot as plt\n plt.plot(wv_array_AA, lsf_vals, 'k-')\n # import pdb; pdb.set_trace()\n lsf_vals = np.where(lsf_vals < 0, 0., lsf_vals)\n\n # normalize\n lsf_vals /= np.sum(lsf_vals)\n\n # re-define Table\n lsf_tab = Table()\n lsf_tab.add_column(Column(name='wv', data=wv_array))\n lsf_tab.add_column(Column(name='kernel', data=lsf_vals))\n\n return lsf_tab\n", "meta": {"hexsha": "be8c941f0192fbc3b3bbe900b46e74e85e722409", "size": 25913, "ext": "py", "lang": "Python", "max_stars_repo_path": "linetools/spectra/lsf.py", "max_stars_repo_name": "marijana777/linetools", "max_stars_repo_head_hexsha": "73720a2f6df42b7dde1f35055cd40ad970200f7f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "linetools/spectra/lsf.py", "max_issues_repo_name": "marijana777/linetools", "max_issues_repo_head_hexsha": "73720a2f6df42b7dde1f35055cd40ad970200f7f", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "linetools/spectra/lsf.py", "max_forks_repo_name": "marijana777/linetools", "max_forks_repo_head_hexsha": "73720a2f6df42b7dde1f35055cd40ad970200f7f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.3715753425, "max_line_length": 181, "alphanum_fraction": 0.5802878864, "include": true, "reason": "import numpy,from scipy,import astropy,from astropy", "num_tokens": 6623, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5964331462646255, "lm_q2_score": 0.3276683008207139, "lm_q1q2_score": 0.19543223558968217}} {"text": "'''\nCommonly used global constants. **New users should change\n`ANCILLARY_DATA_PATHS` if it doesn't match their file system.**\n\nSource for EASE-Grid 2.0 parameters:\n\n https://nsidc.org/ease/ease-grid-projection-gt\n\nNOTE: EASE-Grid 2.0 parameters do not match exactly those specified at NSIDC\nbecause, in fact, they must be 1000 or 9000, depending on the grid size, in\norder to get the right number of rows and columns in the output image.\nGrid resolution is only a whole number for the polar (north or south\nhemisphere) grids.\n'''\n\nimport csv\nimport numpy as np\nfrom collections import OrderedDict\n\nANCILLARY_DATA_PATHS = {\n 'smap_l4c_ancillary_data_file_path': 'SPL4C_Vv4040_SMAP_L4_C.Ancillary.h5',\n 'smap_l4c_1km_ancillary_data_lc_path': 'MCD12Q1_M01_lc_dom_uint8',\n 'smap_l4c_9km_ancillary_data_lc_path': 'MOD12Q1_M09_lc_dom_uint8',\n 'smap_l4c_1km_ancillary_data_x_coord_path': 'SMAP_L4_C_LON_14616_x_34704_M01_flt32',\n 'smap_l4c_1km_ancillary_data_y_coord_path': 'SMAP_L4_C_LAT_14616_x_34704_M01_flt32',\n 'smap_l4c_9km_ancillary_data_x_coord_path': 'SMAP_L4_C_LON_1624_x_3856_M09_flt32',\n 'smap_l4c_9km_ancillary_data_y_coord_path': 'SMAP_L4_C_LAT_1624_x_3856_M09_flt32',\n 'smap_l4c_9km_pft_subgrid_counts_CONUS': 'SMAP_L4C_Vv4040_1km_subgrid_PFT_counts_CONUS.h5',\n 'smap_l4c_9km_sparse_col_index': 'MCD12Q1_M09land_col.uint16',\n 'smap_l4c_9km_sparse_row_index': 'MCD12Q1_M09land_row.uint16',\n 'transcom_netcdf_path': 'CarbonTracker_TransCom_and_other_regions.nc'\n}\n\n\n# Version 4020 BPLUT parameters in order of PFT numeric code (PFT 0 through 9)\nBPLUT = OrderedDict({\n # Only reason for OrderedDict (instead of dict) is for consistency with\n # pyl4c.data.fixtures.BPLUT()\n '_version': '4',\n 'LUE': np.array([[ # gC per MJ\n np.nan, 1.71, 1.38, 1.71, 1.19, 1.95, 1.68, 2.53, 3.6, np.nan\n ]]),\n 'CUE': np.array([[\n np.nan, 0.7, 0.57, 0.79, 0.78, 0.65, 0.6, 0.72, 0.71, np.nan\n ]]),\n 'tmin': np.array([ # degrees K\n [np.nan, 235, 230, 259, 260, 259, 251, 246, 266, np.nan],\n [np.nan, 309, 303, 301, 284, 304, 302, 314, 319, np.nan]\n ]),\n 'vpd': np.array([ # Pascals\n [np.nan, 0, 15, 869, 1500, 4, 0, 228, 1500, np.nan],\n [np.nan, 4169, 7000, 3452, 5401, 4282, 4229, 4516, 7000, np.nan]\n ]),\n 'smrz': np.array([ # Percent saturation\n [np.nan, -30, 18, -30, -26, 22, -30, -15, 10, np.nan],\n [np.nan, 74, 26, 49, 87, 72, 76, 30, 68, np.nan]\n ]),\n 'smsf': np.array([ # Percent saturation\n [np.nan, -50, -46, -9, -50, -15, -3, -42, -49, np.nan],\n [np.nan, 46, 59, 43, 53, 48, 51, 41, 30, np.nan]\n ]),\n 'ft': np.array([ # Frozen = 0, Thawed = 1\n [np.nan, 0.58, 0.36, 0.55, 0.9, 0.91, 0.85, 0.77, 1, np.nan],\n [np.nan, 1, 1, 1, 1, 1, 1, 1, 1, np.nan]\n ]),\n 'tsoil': np.array([[ # degrees K\n np.nan, 265.04, 477.83, 238.81, 267.26, 292.82, 232.24, 263.97, 329.63, np.nan\n ]]),\n # NOTE: The medium/structural and slow/recalcitrant decay constants\n # (2nd and 3rd rows) are true decay constants, unlike in Ops\n # BPLUT which presents only dimensionless scalars.\n 'decay_rates': np.array([ # days^-1\n [np.nan, 0.027, 0.028, 0.028, 0.03, 0.015, 0.025, 0.019, 0.035, np.nan],\n [np.nan, 1.08e-2, 1.12e-2, 1.12e-2, 1.2e-2, 0.6e-2, 1e-2, 0.76e-2, 1.4e-2, np.nan],\n [np.nan, 2.51e-4, 2.6e-4, 2.6e-4, 2.79e-4, 1.4e-4, 2.33e-4, 1.77e-4, 3.26e-4, np.nan]\n ]),\n 'f_metabolic': np.array([[ # Fraction of daily litterfall entering \"fast\" or metabolic pool\n np.nan, 0.49, 0.71, 0.67, 0.67, 0.62, 0.76, 0.78, 0.78, np.nan\n ]]), # Also known as \"f_met\"\n 'f_structural': np.array([[ # Fraction of structural (str) pool transferred in \"humification\"\n np.nan, 0.3, 0.3, 0.7, 0.3, 0.35, 0.55, 0.5, 0.8, np.nan\n ]]) # Also known as \"f_str\" -- See Jones et al. (2017, IEEE TGARS, p.5)\n})\n\n\nEASE2_GRID_PARAMS = {\n # A GeoTransform for a north-up raster is:\n # (x_min, pixel_width, 0, y_max, 0, -pixel_height)\n 'M01': {\n 'epsg': 6933,\n 'geotransform': (-17367530.45, 1000, 0, 7314540.83, 0, -1000),\n 'resolution': 1000.89502334956, # From Brodzik et al.\n 'shape': (14616, 34704),\n 'size': 14616*34704\n },\n 'M09': {\n 'epsg': 6933,\n 'geotransform': (-17367530.45, 9000, 0, 7314540.83, 0, -9000),\n 'resolution': 9008.055210146, # From Brodzik et al.\n 'shape': (1624, 3856),\n 'size': 1624*3856\n },\n 'N09': {\n 'epsg': 6931,\n 'geotransform': (-9000000.0, 9000, 0, 9000000.0, 0, -9000),\n 'resolution': 9000,\n 'shape': (2000, 2000),\n 'size': 2000*2000\n },\n 'M25': {\n 'epsg': 6933,\n 'geotransform': (-17367530.45, 25000, 0, 7307375.92, 0, -25000),\n 'resolution': 25000,\n 'shape': (584, 1388),\n 'size': 584*1388\n },\n 'M36': {\n 'epsg': 6933,\n 'geotransform': (-17367530.45, 36000, 0, 7314540.83, 0, -36000),\n 'resolution': 36032.22,\n 'shape': (406, 964),\n 'size': 406*964\n }\n}\n\n\nHDF_PATHS = { # Where in the HDF hierarchy certain variables live\n 'SPL4CMDL': { # By Earthdata Dataset ID\n '4': { # By Version number\n 'longitude': 'GEO/longitude',\n 'latitude': 'GEO/latitude',\n 'SOC': 'SOC/soc_mean',\n 'SOC*': 'SOC/soc_pft%d_mean',\n 'GPP': 'GPP/gpp_mean',\n 'GPP*': 'GPP/gpp_pft%d_mean',\n 'NEE': 'NEE/nee_mean',\n 'NEE*': 'NEE/nee_pft%d_mean',\n 'RH': 'RH/rh_mean',\n 'RH*': 'RH/rh_pft%d_mean',\n }\n },\n 'SPL4SMGP': {\n '4': {'longitude': 'cell_lon', 'latitude': 'cell_lat',}\n }\n}\n\n\nPFT = OrderedDict({\n 0: ('Water', 'WET'),\n 1: ('Evergreen Needleleaf', 'ENF'),\n 2: ('Evergreen Broadleaf', 'EBF'),\n 3: ('Deciduous Needleleaf', 'DNF'),\n 4: ('Deciduous Broadleaf', 'DBF'),\n 5: ('Shrub', 'SHB'),\n 6: ('Grass', 'GRS'),\n 7: ('Cereal Crop', 'CCR'),\n 8: ('Broadleaf Crop', 'BCR'),\n 9: ('Urban and Built-Up', 'URB')\n})\n\n\n# BBOX extents, in decimal degrees, based on gdal_rasterize -te option:\n# https://gdal.org/programs/gdal_rasterize.html#cmdoption-gdal-translate-te\nSUBSETS_BBOX = { # , , , \n 'CONUS': [-124.5, 24.4, -66.7, 50.0],\n 'WesternHemisphere': [-180, -90, 0, 90],\n 'WesternHemisphere2': [-180, -90, -25, 90],\n 'NorthernHemisphere': [-180, 0, 180, 90],\n 'NorthernHemisphere45': [-180, 45, 180, 90],\n 'NorthernHemisphere40': [-180, 40, 180, 90],\n 'Nigeria': [2.3, 4, 14.8, 14],\n # AOI for: Chiodi and Harrison (2013) Journal of Climate 26 (3):822–837\n 'ChiodiHarrison2013': [-160, -5, -110, 5],\n 'Kang2014EMS': [-125, 47, -113, 49],\n 'NorthernPlains': [-116.1, 40.9, -96.4, 49],\n 'Montana': [-116.1, 44.4, -104.01, 49],\n 'Iowa': [-96.7, 40.58, -90.1, 43.5],\n 'Bangladesh1kmSubset': [78.9, 23.2, 96.1, 29.3]\n}\n\n\ndef parameter_mapped(name, pft_array, bplut = BPLUT):\n '''\n Given a BPLUT parameter and a PFT array, returns an array with the\n corresponding parameter values for each PFT code.\n\n Parameters\n ----------\n name : str\n The name of the BPLUT parameter\n pft_array : numpy.ndarray\n Array of any size or shape with numeric elements corresponding to\n PFT codes\n bplut : dict\n (Optional) A collection of BPLUT parameters\n\n Returns\n -------\n numpy.ndarray\n Array of same size, shape as pft_array but with parameter values\n in place of PFT codes\n '''\n param = bplut[name]\n # Basically, index the array, in PFT order, by PFT numeric codes\n return np.asarray(param)[np.ravel(pft_array)].reshape(pft_array.shape)\n\n\ndef restore_bplut(csv_file_path, version_id = None):\n '''\n Translates a BPLUT CSV file to a Python internal representation\n (OrderedDict instance).\n\n Parameters\n ----------\n csv_file_path : str\n File path to the CSV representation of the BPLUT\n version_id : str\n (Optional) Version identifier for the BPLUT\n\n Returns\n -------\n OrderedDict\n '''\n header = ('LC_index', 'LC_Label', 'model_code', 'NDVItoFPAR_scale',\n 'NDVItoFPAR_offset', 'LUEmax', 'Tmin_min_K', 'Tmin_max_K',\n 'VPD_min_Pa', 'VPD_max_Pa', 'SMrz_min', 'SMrz_max', 'FT_min',\n 'FT_max', 'SMtop_min', 'SMtop_max', 'Tsoil_beta0', 'Tsoil_beta1',\n 'Tsoil_beta2', 'fraut', 'fmet', 'fstr', 'kopt', 'kstr', 'kslw',\n 'Nee_QA_Rank_min', 'Nee_QA_Rank_max', 'Nee_QA_Error_min',\n 'Nee_QA_Error_max', 'Fpar_QA_Rank_min', 'Fpar_QA_Rank_max',\n 'Fpar_QA_Error_min', 'Fpar_QA_Error_max', 'FtMethod_QA_mult',\n 'FtAge_QA_Rank_min', 'FtAge_QA_Rank_max', 'FtAge_QA_Error_min',\n 'FtAge_QA_Error_max', 'Par_QA_Error', 'Tmin_QA_Error',\n 'Vpd_QA_Error', 'Smrz_QA_Error', 'Tsoil_QA_Error', 'Smtop_QA_Error')\n contents = []\n with open(csv_file_path, 'r') as stream:\n reader = csv.DictReader(\n filter(lambda row: row[0] != '#', stream), fieldnames = header)\n for row in reader:\n contents.append(row)\n\n result = BPLUT.copy()\n result['_version'] = 'UNKNOWN' if version_id is None else version_id\n result['LUE'] = np.array([[\n contents[p-1]['LUEmax'] if p in range(1, 9) else np.nan\n for p in range(0, 10)\n ]], dtype = np.float32).round(4)\n result['CUE'] = np.array([[\n (1 - float(contents[p-1]['fraut'])) if p in range(1, 9) else np.nan\n for p in range(0, 10)\n ]], dtype = np.float32).round(4)\n result['tmin'] = np.array([\n [contents[p-1]['Tmin_min_K'] if p in range(1, 9) else np.nan\n for p in range(0, 10)],\n [contents[p-1]['Tmin_max_K'] if p in range(1, 9) else np.nan\n for p in range(0, 10)],\n ], dtype = np.float32).round(1)\n result['vpd'] = np.array([\n [contents[p-1]['VPD_min_Pa'] if p in range(1, 9) else np.nan\n for p in range(0, 10)],\n [contents[p-1]['VPD_max_Pa'] if p in range(1, 9) else np.nan\n for p in range(0, 10)],\n ], dtype = np.float32).round(2)\n result['smrz'] = np.array([\n [contents[p-1]['SMrz_min'] if p in range(1, 9) else np.nan\n for p in range(0, 10)],\n [contents[p-1]['SMrz_max'] if p in range(1, 9) else np.nan\n for p in range(0, 10)],\n ], dtype = np.float32).round(1)\n result['smsf'] = np.array([\n [contents[p-1]['SMtop_min'] if p in range(1, 9) else np.nan\n for p in range(0, 10)],\n [contents[p-1]['SMtop_max'] if p in range(1, 9) else np.nan\n for p in range(0, 10)],\n ], dtype = np.float32).round(1)\n result['ft'] = np.array([\n [contents[p-1]['FT_min'] if p in range(1, 9) else np.nan\n for p in range(0, 10)],\n [contents[p-1]['FT_max'] if p in range(1, 9) else np.nan\n for p in range(0, 10)],\n ], dtype = np.float32).round(3)\n result['tsoil'] = np.array([[\n contents[p-1]['Tsoil_beta0'] if p in range(1, 9) else np.nan\n for p in range(0, 10)\n ]], dtype = np.float32).round(1)\n result['f_metabolic'] = np.array([[\n contents[p-1]['fmet'] if p in range(1, 9) else np.nan\n for p in range(0, 10)\n ]], dtype = np.float32).round(3)\n result['f_structural'] = np.array([[\n contents[p-1]['fstr'] if p in range(1, 9) else np.nan\n for p in range(0, 10)\n ]], dtype = np.float32).round(1)\n result['decay_rates'] = np.array([\n [contents[p-1]['kopt'] if p in range(1, 9) else np.nan\n for p in range(0, 10)],\n [contents[p-1]['kstr'] if p in range(1, 9) else np.nan\n for p in range(0, 10)],\n [contents[p-1]['kslw'] if p in range(1, 9) else np.nan\n for p in range(0, 10)],\n ], dtype = np.float32).round(3)\n # The \"kstr\" and \"kslw\" values are really the fraction of kopt\n # assigned to the second and third pools\n result['decay_rates'][1,:] = np.multiply(\n result['decay_rates'][0,:], result['decay_rates'][1,:])\n result['decay_rates'][2,:] = np.multiply(\n result['decay_rates'][0,:], result['decay_rates'][2,:])\n return result\n", "meta": {"hexsha": "ef3ffa07905187399b6ba8a73c91e44786b9f33b", "size": 12199, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyl4c/data/fixtures.py", "max_stars_repo_name": "arthur-e/pyl4c", "max_stars_repo_head_hexsha": "97e1225c8b70ed9b21edc9e54ee66c78a02cded8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-01T18:30:21.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-01T18:30:21.000Z", "max_issues_repo_path": "pyl4c/data/fixtures.py", "max_issues_repo_name": "arthur-e/pyl4c", "max_issues_repo_head_hexsha": "97e1225c8b70ed9b21edc9e54ee66c78a02cded8", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pyl4c/data/fixtures.py", "max_forks_repo_name": "arthur-e/pyl4c", "max_forks_repo_head_hexsha": "97e1225c8b70ed9b21edc9e54ee66c78a02cded8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.4789644013, "max_line_length": 97, "alphanum_fraction": 0.5875891467, "include": true, "reason": "import numpy", "num_tokens": 4497, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5964331319177487, "lm_q2_score": 0.3276682876897044, "lm_q1q2_score": 0.1954322230568963}} {"text": "# Reduce the PolSpice CIB measurement and make GP plots\n\nimport os\n\nimport numpy as np\n\nimport sys\nsys.path.append(\"../tools/\")\nfrom misc_utils import create_beam_operator, file_header\nfrom CIB_model import CIBModel\n\n# KCAP_PATH = \"../../KiDS/kcap/\"\n# sys.path.append(os.path.join(KCAP_PATH, \"kcap\"))\n# import cosmosis_utils\n\n\nPI = np.pi\n\n\ndef plot_Cls(Cls, xlabel=r\"$\\ell$\", ylabel=r\"$\\ell^2/2\\pi\\ C_\\ell$\",\n z_cuts=None, scaling=lambda ell: ell**2/(2*PI),\n xscale=\"log\", yscale=\"linear\",\n ylim=None, title=\"\", filename=\"\"):\n import matplotlib.pyplot as plt\n\n fig, ax = plt.subplots(2, 3, sharex=True, sharey=True, figsize=(8, 5))\n fig.subplots_adjust(hspace=0, wspace=0)\n\n if z_cuts is None:\n z_cuts = [(0.1, 0.3),\n (0.3, 0.5),\n (0.5, 0.7),\n (0.7, 0.9),\n (0.9, 1.2),\n ]\n for i, z_cut in enumerate(z_cuts):\n ax.flatten()[i].axhline(0, c=\"k\", lw=1)\n \n for Cl_spec in Cls:\n c = Cl_spec.copy()\n Y = c.pop(\"Y\")\n X = c.pop(\"X\")\n n_ell_bin = X.size\n u = scaling(X)\n if Y.ndim == 1 and len(z_cuts) > 1:\n Y = Y[n_ell_bin*i:n_ell_bin*(i+1)]\n elif Y.ndim == 2:\n Y = Y[i]\n\n Y_err = c.pop(\"Y_err\", None)\n Y_lower = c.pop(\"Y_lower\", None)\n Y_upper = c.pop(\"Y_upper\", None)\n if Y_err is not None:\n if Y_err.ndim == 1 and len(z_cuts) > 1:\n Y_err = Y_err[n_ell_bin*i:n_ell_bin*(i+1)]\n elif Y_err.ndim == 2:\n Y_err = Y_err[i]\n ax.flatten()[i].errorbar(X, u*Y, u*Y_err, **c)\n elif Y_lower is not None and Y_upper is not None:\n if Y_lower.ndim == 1 and len(z_cuts) > 1:\n Y_lower = Y_lower[n_ell_bin*i:n_ell_bin*(i+1)]\n Y_upper = Y_upper[n_ell_bin*i:n_ell_bin*(i+1)]\n elif Y_lower.ndim == 2:\n Y_lower = Y_lower[i]\n Y_upper = Y_upper[i]\n label_CI = c.pop(\"label_CI\", None)\n label_mean = c.pop(\"label\", None)\n color = c.pop(\"c\", None)\n ax.flatten()[i].fill_between(X, u*Y_lower, u*Y_upper, **c,\n label=label_CI, facecolor=color)\n ax.flatten()[i].plot(X, u*Y, **c, c=color, label=label_mean)\n else:\n ax.flatten()[i].plot(X, u*Y, **c)\n\n ax.flatten()[i].set_xlabel(xlabel)\n ax.flatten()[i].set_title(f\"z: {z_cut[0]}-{z_cut[1]}\", x=0.25, y=0.85)\n\n ax[0,0].set_xscale(xscale)\n ax[0,0].set_yscale(yscale)\n\n [p[0].set_ylabel(ylabel) for p in ax]\n ax.flatten()[-1].axis(\"off\")\n ax.flatten()[-2].legend(frameon=False, loc=\"upper left\",\n bbox_to_anchor=(1, 0.8))\n\n if ylim is not None:\n ax[0,0].set_ylim(**ylim)\n\n fig.suptitle(title)\n fig.dpi = 300\n if filename != \"\":\n fig.savefig(filename) \n\nif __name__ == \"__main__\":\n\n mode = \"namaster\"\n\n if mode == \"namaster\":\n compute_prediction_for_cov = False\n make_plots = True\n\n probe = \"TE\"\n field = \"545GHz_CIB\"\n label = f\"KiDS-1000 x 545 GHz CIB, {probe}\"\n units = r\"[mJy]\"\n\n # field = \"100GHz_HFI\"\n # probe = \"TE\"\n # label = f\"KiDS-1000 x 100 GHz HFI, {probe}\"\n # units = r\"[$\\mathrm{K}_\\mathrm{CMB}$]\"\n\n data_file = f\"../results/measurements/shear_KiDS1000_{field}/likelihood/data/Cl_{probe}_shear_KiDS1000_gal_{field}.txt\"\n cov_file = f\"../results/measurements/shear_KiDS1000_{field}/likelihood/cov/covariance_gaussian_nka_{probe}{probe}.txt\"\n\n data = np.loadtxt(data_file)\n ell_data = data[:, 0]\n data = data[:, 1:]\n\n cov = np.loadtxt(cov_file)\n\n elif mode == \"polspice\":\n import base_config\n\n defaults = {**base_config.PATHS, **base_config.DATA_DIRS}\n\n # binning_operator = np.loadtxt(\n # cosmosis_utils.emulate_configparser_interpolation(\n # base_config.bin_op_file, defaults))\n binning_operator = np.loadtxt(\"../data/xcorr/bin_operator_log_n_bin_12_ell_51-2952.txt\")\n\n OLD_MEASUREMENT_DIR = \"../../project-triad-obsolete/results/measurements/\"\n\n target_beam = 10.0\n\n # CIB_maps = [\"353\", \"545\", \"857\"]\n CIB_maps = [\"545\"]\n\n z_cuts = [(0.1, 0.3),\n (0.3, 0.5),\n (0.5, 0.7),\n (0.7, 0.9),\n (0.9, 1.2),\n ]\n\n Cl_CIB_shear = {z: {c: {} for c in CIB_maps} for z in z_cuts}\n\n for z_cut in z_cuts:\n for CIB_map in CIB_maps:\n ell, TE, TB = np.loadtxt(\n os.path.join(OLD_MEASUREMENT_DIR,\n f\"shear_KiDS1000_CIB/\"\n f\"z{z_cut[0]:.1f}-{z_cut[1]:.1f}-Planck-{CIB_map}/spice.cl\"),\n unpack=True, usecols=[0, 7, 8])\n\n beam_operator = create_beam_operator(ell, \n fwhm_map=5.0,\n fwhm_target=target_beam)\n\n Cl_CIB_shear[z_cut][CIB_map] = {\"ell_raw\" : ell,\n \"Cl_TE_raw\" : TE,\n \"Cl_TB_raw\" : TB,\n \"Cl_TE_raw_beam10\" : beam_operator @ TE,\n \"Cl_TB_raw_beam10\" : beam_operator @ TB,\n \"ell_binned\" : binning_operator @ ell,\n \"Cl_TE_binned\" : binning_operator @ TE,\n \"Cl_TB_binned\" : binning_operator @ TB,\n \"Cl_TE_beam_binned\" : binning_operator @ beam_operator @ TE,\n \"Cl_TB_beam_binned\" : binning_operator @ beam_operator @ TB}\n\n CIB_jk_data = np.load(\n os.path.join(OLD_MEASUREMENT_DIR,\n f\"shear_KiDS1000_CIB/shear_KiDS1000_CIB_jk_data.npz\"),\n allow_pickle=True)\n\n jk_resolutions = [64,]# 128, 256]\n\n cov_CIB_shear = {c: {j: {\"TE\": None, \"TB\": None} for j in jk_resolutions}\n for c in CIB_maps}\n\n ell = np.arange(3001)\n\n for CIB_map in CIB_maps:\n for jk_res in jk_resolutions:\n d_CIB = []\n for z_cut in z_cuts:\n tag = f\"z{z_cut[0]:.1f}-{z_cut[1]:.1f}-Planck-{CIB_map}\"\n Cl = CIB_jk_data[tag][str(jk_res)]\n binned = np.einsum(\"ij,kjl->lik\", binning_operator @ beam_operator, Cl)\n d_CIB.append(binned)\n\n d = np.concatenate(d_CIB, axis=1)\n print(d.shape)\n n_jk = d.shape[-1]\n effective_n_jk = n_jk\n\n cov_CIB_shear[CIB_map][jk_res][\"TE\"] = (\n np.cov(d[0], ddof=1) * (effective_n_jk-1)**2/effective_n_jk)\n cov_CIB_shear[CIB_map][jk_res][\"TB\"] = (\n np.cov(d[1], ddof=1) * (effective_n_jk-1)**2/effective_n_jk)\n\n # Save files\n\n header = file_header(\n f\"ell TE ({CIB_map} x KiDS-1000, beam {target_beam}' \"\n f\"FWHM, z-bins: {', '.join([str(z) for z in z_cuts])})\")\n\n for CIB_map in CIB_maps:\n data = [Cl_CIB_shear[z_cuts[0]][CIB_map][\"ell_binned\"]]\n for z_cut in z_cuts:\n data.append(Cl_CIB_shear[z_cut][CIB_map][\"Cl_TE_beam_binned\"])\n\n np.savetxt(f\"../data/xcorr/CIB/\"\n f\"shear_CIB_KiDS1000_{CIB_map}_TE_beam{target_beam}.txt\",\n np.array(data).T,\n header=header)\n\n header = file_header(\n f\"TE covariance ({CIB_map} x KiDS-1000, beam {target_beam}' \"\n f\"FWHM, z-bins: {', '.join([str(z) for z in z_cuts])})\")\n\n for CIB_map in CIB_maps:\n for name, cov in [(\"jk_3.4deg2\", cov_CIB_shear[CIB_map][64][\"TE\"]),\n #(\"jk_13.4deg2\", cov_CIB_shear[CIB_map][128][\"TE\"]),\n #(\"jk_53.7deg2\", cov_CIB_shear[CIB_map][256][\"TE\"])\n ]:\n np.savetxt(\n f\"../data/xcorr/CIB/\"\n f\"shear_CIB_KiDS1000_{CIB_map}_TE_{name}\"\n f\"_beam{target_beam}_cov.txt\",\n cov,\n header=header)\n\n CIB_map = \"545\"\n ell_data = Cl_CIB_shear[z_cuts[0]][CIB_map][\"ell_binned\"]\n data = []\n for z_cut in z_cuts:\n data.append(Cl_CIB_shear[z_cut][CIB_map][\"Cl_TE_beam_binned\"])\n data = np.array(data).T\n\n cov = cov_CIB_shear[CIB_map][64][\"TE\"]\n\n check_GP = True\n if check_GP:\n # Normalize the CIB a bit\n scaling_factor = 1e5 * ell_data**2/(2*np.pi)\n Y = scaling_factor[:, None] * data\n S = np.diag(np.tile(scaling_factor, Y.shape[1]))\n\n Y_cov = S @ cov @ S\n X = np.log10(ell_data)\n\n CIB_model = CIBModel(X, Y, Y_cov)\n\n # CIB_model.load_state(f\"../results/measurements/shear_KiDS1000_{field}/GP_model/GP_state\")\n CIB_model.train(n_step=5000, lr=1e-2)\n CIB_model.print_model_parameters()\n print(\"Chi2:\", CIB_model.chi2())\n\n CIB_model.save_state(f\"../results/measurements/shear_KiDS1000_{field}/GP_model/GP_state.torchstate\")\n\n # ell_pred = np.geomspace(51, 3000, 100)\n ell_pred = np.arange(51, 2953)\n CIB_prediction, CI = CIB_model.predict(np.log10(ell_pred), CI=True)\n # Undo normalisation to get Cl\n CIB_prediction *= 1/(1e5 * ell_pred**2/(2*np.pi))[:, None]\n CIB_prediction_CI_l = CI[0] * 1/(1e5 * ell_pred**2/(2*np.pi))[:, None]\n CIB_prediction_CI_u = CI[1] * 1/(1e5 * ell_pred**2/(2*np.pi))[:, None]\n\n n_ell, n_z = CIB_prediction.shape\n\n if make_plots:\n plot_Cls(Cls=[{\"X\": ell_data, \"Y\": data.T,\n \"Y_err\": np.sqrt(np.diag(cov)),\n \"marker\": \"o\", \"ls\": \"none\", \"c\": \"C0\",\n \"label\": label},\n {\"X\": ell_pred, \"Y\": CIB_prediction.T,\n \"Y_lower\": CIB_prediction_CI_l.T,\n \"Y_upper\": CIB_prediction_CI_u.T,\n \"alpha\": 0.5, \"c\": \"C1\",\n \"label\": \"GP\"}],\n ylabel=r\"$\\ell^2/2\\pi\\ C_\\ell$ \" + units,\n title=f\"{label}, GP model\",\n filename=f\"../notebooks/plots/CIB_model_{field}_{probe}_beam10.png\")\n\n\n if compute_prediction_for_cov:\n ell_pred = np.arange(51, 2953)\n CIB_prediction = CIB_model.predict(np.log10(ell_pred))\n # Undo normalisation to get Cl\n CIB_prediction *= 1/(1e5 * ell_pred**2/(2*np.pi))[:, None]\n\n ell = np.arange(3*2048)\n for i in range(n_z):\n Cl = np.zeros((2, ell.size))\n Cl[0, 51:2953] = CIB_prediction[:, i]\n\n np.savez(f\"../results/measurements/shear_KiDS1000_{field}/cov_Cls/Cl_cov_GP_{i}-0.npz\", ell=ell, Cl_cov=Cl, Cl_noise_cov=np.zeros_like(Cl))\n", "meta": {"hexsha": "fd6267be0b1fef4881492e276278ba49430a978c", "size": 11645, "ext": "py", "lang": "Python", "max_stars_repo_path": "scripts/reduce_CIB_data.py", "max_stars_repo_name": "tilmantroester/KiDS-1000xtSZ", "max_stars_repo_head_hexsha": "190f193d5d2fc514bcbe96ea15d882ea59c7a1cc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-24T16:02:32.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-24T16:02:32.000Z", "max_issues_repo_path": "scripts/reduce_CIB_data.py", "max_issues_repo_name": "tilmantroester/KiDS-1000xtSZ", "max_issues_repo_head_hexsha": "190f193d5d2fc514bcbe96ea15d882ea59c7a1cc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "scripts/reduce_CIB_data.py", "max_forks_repo_name": "tilmantroester/KiDS-1000xtSZ", "max_forks_repo_head_hexsha": "190f193d5d2fc514bcbe96ea15d882ea59c7a1cc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.0771812081, "max_line_length": 155, "alphanum_fraction": 0.4883641048, "include": true, "reason": "import numpy", "num_tokens": 3203, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5660185351961015, "lm_q2_score": 0.34510528442897664, "lm_q1q2_score": 0.19533598758092333}} {"text": "'''\nInfers average ELBO values from DeepSequence VAE models.\nBased on open source code from DeepSequence repo.\n'''\nimport argparse\nimport numpy as np\nimport os\nimport pathlib\nfrom shutil import copyfile\nimport sys\nimport time\n\nimport utils\n\nWORKING_DIR=\"\" # Put in the DeepSequence directory here\nN_ELBO_SAMPLES=400\n\nmodule_path = os.path.abspath(WORKING_DIR)\nif module_path not in sys.path:\n sys.path.append(module_path)\n\nfrom DeepSequence.model import VariationalAutoencoder\nfrom DeepSequence import helper\nfrom DeepSequence import train\n\nmodel_params = {\n \"bs\" : 100,\n \"encode_dim_zero\" : 1500,\n \"encode_dim_one\" : 1500,\n \"decode_dim_zero\" : 100,\n \"decode_dim_one\" : 500,\n \"n_latent\" : 30,\n \"logit_p\" : 0.001,\n \"sparsity\" : \"logit\",\n \"final_decode_nonlin\": \"sigmoid\",\n \"final_pwm_scale\" : True,\n \"n_pat\" : 4,\n \"r_seed\" : 12345,\n \"conv_pat\" : True,\n \"d_c_size\" : 40\n}\n\n\ndef main():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"model_prefix\", type=str)\n parser.add_argument(\"fasta_file\", type=str)\n parser.add_argument(\"wt_fasta_file\", type=str)\n parser.add_argument(\"output_dir\", type=str)\n args = parser.parse_args()\n data_helper = helper.DataHelper(\n working_dir=WORKING_DIR,\n alignment_file=args.fasta_file,\n calc_weights=False,\n )\n\n vae_model = VariationalAutoencoder(data_helper,\n batch_size = model_params[\"bs\"],\n encoder_architecture = [model_params[\"encode_dim_zero\"],\n model_params[\"encode_dim_one\"]],\n decoder_architecture = [model_params[\"decode_dim_zero\"],\n model_params[\"decode_dim_one\"]],\n n_latent = model_params[\"n_latent\"],\n logit_p = model_params[\"logit_p\"],\n sparsity = model_params[\"sparsity\"],\n encode_nonlinearity_type = \"relu\",\n decode_nonlinearity_type = \"relu\",\n final_decode_nonlinearity = model_params[\"final_decode_nonlin\"],\n final_pwm_scale = model_params[\"final_pwm_scale\"],\n conv_decoder_size = model_params[\"d_c_size\"],\n convolve_patterns = model_params[\"conv_pat\"],\n n_patterns = model_params[\"n_pat\"],\n random_seed = model_params[\"r_seed\"],\n working_dir = WORKING_DIR,\n )\n vae_model.load_parameters(args.model_prefix)\n\n pathlib.Path(args.output_dir).mkdir(parents=True, exist_ok=True)\n\n focuscols = set(data_helper.uniprot_focus_cols_list)\n\n seqs = utils.read_fasta(os.path.join(WORKING_DIR, \"datasets\",\n args.fasta_file))\n wt, des = utils.read_fasta(args.wt_fasta_file, return_ids=True)\n wt = wt[0]\n des = des[0]\n offset = int(des.split('/')[-1].split('-')[0])\n delta_elbos = np.zeros(len(seqs))\n for i, s in enumerate(seqs):\n if i % 100 == 0:\n print(f'Computed elbos for {i} out of {len(seqs)} seqs')\n np.savetxt(os.path.join(args.output_dir, \"elbo.npy\"), delta_elbos)\n mut_tups = utils.seq2mutation_fromwt(s, wt, offset=offset)\n mut_tups = [t for t in mut_tups if t[0] in focuscols]\n delta_elbos[i] = data_helper.delta_elbo(vae_model, mut_tups,\n N_pred_iterations=N_ELBO_SAMPLES) \n np.savetxt(os.path.join(args.output_dir, \"elbo.npy\"), delta_elbos)\n\n\nif __name__ == \"__main__\":\n main()\n", "meta": {"hexsha": "99bab3753dc24bfa53cb00cbf9c4ca5fed88b2c9", "size": 3739, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/vae_inference.py", "max_stars_repo_name": "brycejoh16/combining-evolutionary-and-assay-labelled-data", "max_stars_repo_head_hexsha": "36ffcf10ad6eacf5d44c81d69f0bc6f7f9cae73b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14, "max_stars_repo_stars_event_min_datetime": "2022-01-19T02:39:11.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-08T21:55:29.000Z", "max_issues_repo_path": "src/vae_inference.py", "max_issues_repo_name": "brycejoh16/combining-evolutionary-and-assay-labelled-data", "max_issues_repo_head_hexsha": "36ffcf10ad6eacf5d44c81d69f0bc6f7f9cae73b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2022-03-09T06:18:23.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-20T14:55:59.000Z", "max_forks_repo_path": "src/vae_inference.py", "max_forks_repo_name": "brycejoh16/combining-evolutionary-and-assay-labelled-data", "max_forks_repo_head_hexsha": "36ffcf10ad6eacf5d44c81d69f0bc6f7f9cae73b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2022-01-22T07:27:22.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-04T23:23:17.000Z", "avg_line_length": 36.6568627451, "max_line_length": 80, "alphanum_fraction": 0.5916020326, "include": true, "reason": "import numpy", "num_tokens": 896, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5660185351961015, "lm_q2_score": 0.34510527095787247, "lm_q1q2_score": 0.19533597995602867}} {"text": "from __future__ import print_function\n\n\"\"\"\nThe main class in this module `ElasticScatter` holds the experimental details,\nand processor information needed to calculate the elastic powder scattering\nfrom a collection of atoms.\n\"\"\"\nimport math\nimport numpy as np\nfrom numba import cuda\nfrom pyiid.experiments.elasticscatter.cpu_wrappers.nxn_cpu_wrap import \\\n wrap_fq_grad as cpu_wrap_fq_grad, wrap_fq as cpu_wrap_fq\nfrom pyiid.experiments.elasticscatter.kernels.master_kernel import \\\n grad_pdf as cpu_grad_pdf, get_pdf_at_qmin, get_scatter_array\nfrom scipy.interpolate import griddata\n\n__author__ = 'christopher'\n\nall_changes = ['positions', 'numbers', 'cell', 'pbc', 'charges', 'magmoms',\n 'exp']\n\n\ndef check_mpi():\n # Test if MPI GPU is viable\n # Currently no working MPI GPU implementation\n return False\n\n\ndef check_gpu():\n \"\"\"\n Check if GPUs are available on this machine\n \"\"\"\n try:\n cuda.gpus.lst\n tf = True\n except cuda.CudaSupportError:\n tf = False\n return tf\n\n\ndef check_cudafft():\n try:\n from accelerate.cudalib import cufft\n tf = True\n except ImportError:\n tf = False\n print('no cudafft')\n cufft = None\n return tf\n\n\nclass ElasticScatter(object):\n \"\"\"\n Scatter contains all the methods associated with producing theoretical\n diffraction patterns and PDFs from atomic configurations. It does not\n include potential energies, such as Rw and chi**2 which are under the\n Calculator object.\n >>>from ase.atoms import Atoms\n >>>import matplotlib.pyplot as plt\n >>>atoms = Atoms('Au4', [[0, 0, 0], [3, 0, 0], [0, 3, 0], [3, 3, 0]])\n >>>a = np.random.random(atoms.positions.shape) * .1\n >>>s = ElasticScatter({'rmax': 5., 'rmin': 2.})\n >>>fq = s.get_pdf(atoms)\n >>>fq2 = s.get_pdf(atoms)\n >>>plt.plot(s.get_r(), fq)\n >>>plt.show()\n\n \"\"\"\n\n def __init__(self, exp_dict=None, verbose=False, seed=None):\n self.verbose = verbose\n self.wrap_atoms_state = None\n if seed is None:\n self.seed = int(np.random.random() * 2 ** 32)\n elif isinstance(seed, int):\n self.seed = seed\n else:\n raise ValueError('Expected an integer!')\n self.rs = np.random.RandomState(self.seed)\n\n # Currently supported processor architectures, in order of most\n # advanced to least\n self.avail_pro = ['MPI-GPU', 'Multi-GPU', 'CPU']\n\n # needed parameters to specify an experiment\n self.exp_dict_keys = ['qmin', 'qmax', 'qbin', 'rmin', 'rmax', 'rstep',\n 'sampling']\n # default experimental parameters\n self.default_values = [0.0, 25, .1, 0.0, 40.0, .01, 'full']\n # Initiate the algorithm, processor, and experiments\n self.alg = None\n self.processor = None\n self.exp = None\n self.pdf_qbin = None\n\n # set the experimental parameters\n self.update_experiment(exp_dict)\n\n # Just in case something blows up down the line set to the most base\n # processor\n self.fq = cpu_wrap_fq\n self.grad = cpu_wrap_fq_grad\n self.grad_pdf = cpu_grad_pdf\n self.processor = 'CPU'\n self.alg = 'nxn'\n\n # Get the fastest processor architecture available\n self.set_processor()\n\n def _wrap_atoms(self, atoms):\n \"\"\"\n Call this function before applying calculator, it will generate static\n arrays for the scattering, preventing recalculation\n \n Parameters\n -----------\n atoms: ase.Atoms\n The atoms to which scatter factors are added\n \"\"\"\n if 'qbin' not in self.exp.keys():\n self.exp['qbin'] = .1\n n = len(atoms)\n e_num = atoms.get_atomic_numbers()\n e_set = set(e_num)\n e_list = list(e_set)\n\n for qbin, name in zip(\n [self.exp['qbin'],\n self.pdf_qbin],\n ['F(Q) scatter', 'PDF scatter']\n ):\n qmax_bin = int(math.floor(self.exp['qmax'] / qbin))\n set_scatter_array = np.zeros((len(e_set), qmax_bin),\n dtype=np.float32)\n\n # Calculate the element-wise scatter factor array\n get_scatter_array(set_scatter_array, e_num, self.exp['qbin'])\n scatter_array = np.zeros((n, qmax_bin), dtype=np.float32)\n\n # Disseminate the element wise scatter factors\n for i in range(len(e_set)):\n scatter_array[np.where(atoms.numbers == e_list[i])[0], :] = \\\n set_scatter_array[i, :]\n\n # Set the new scatter factor array\n if name in atoms.arrays.keys():\n del atoms.arrays[name]\n atoms.set_array(name, scatter_array)\n\n atoms.info['exp'] = self.exp\n atoms.info['scatter_atoms'] = n\n\n def _check_wrap_atoms_state(self, atoms):\n \"\"\"\n Check if we need to recalculate the atomic scatter factors\n Parameters\n ----------\n atoms: ase.Atoms\n The atomic configuration\n\n Returns\n -------\n\n \"\"\"\n t_value = True\n if self.wrap_atoms_state is None:\n t_value = False\n elif 'F(Q) scatter' not in atoms.arrays.keys():\n t_value = False\n elif atoms.info['exp'] != self.exp or atoms.info[\n 'scatter_atoms'] != len(atoms):\n t_value = False\n if not t_value:\n if self.verbose:\n print('calculating new scatter factors')\n self._wrap_atoms(atoms)\n self.wrap_atoms_state = atoms\n return t_value\n\n def update_experiment(self, exp_dict):\n \"\"\"\n Change the scattering experiment parameters.\n\n Parameters\n ----------\n exp_dict: dict or None\n Dictionary of parameters to be updated, if None use defaults\n \"\"\"\n # Should be read in from the gr file, but if not here are some defaults\n if exp_dict is None or bool(exp_dict) is False:\n exp_dict = {}\n for key, dv in zip(self.exp_dict_keys, self.default_values):\n if key not in exp_dict.keys():\n exp_dict[key] = dv\n\n # If sampling is ns then generate the PDF at\n # the Nyquist Shannon Sampling Frequency\n if exp_dict['sampling'] == 'ns':\n exp_dict['rstep'] = np.pi / exp_dict['qmax']\n\n self.exp = exp_dict\n # Technically we should use this for qbin\n self.pdf_qbin = np.pi / (self.exp['rmax'] + 6 * 2 * np.pi /\n self.exp['qmax'])\n\n def set_processor(self, processor=None, kernel_type='flat'):\n \"\"\"\n Set the processor to use for calculating the scattering. If no\n parameter is given then check for the fastest possible processor\n configuration\n\n Parameters\n -----------\n processor: ['MPI-GPU', 'Multi-GPU', 'Serial-CPU']\n The processor to use\n kernel_type: ['nxn', 'flat-serial', 'flat']\n The type of algorithm to use\n\n Returns\n -------\n bool:\n True on successful setup of the algorithm and processor\n \"\"\"\n # If a processor is given try to use that processor,\n # but check if it is viable first.\n\n # Changing the processor invalidates the previous results\n if processor is None:\n # Test each processor in order of most advanced to least\n for pro in self.avail_pro:\n if self.set_processor(\n processor=pro, kernel_type=kernel_type) is not None:\n break\n\n elif processor == self.avail_pro[0] and check_mpi() is True:\n from pyiid.experiments.elasticscatter.mpi_wrappers.mpi_gpu_wrap \\\n import \\\n wrap_fq as multi_node_gpu_wrap_fq\n from pyiid.experiments.elasticscatter.mpi_wrappers.mpi_gpu_wrap \\\n import \\\n wrap_fq_grad as multi_node_gpu_wrap_fq_grad\n\n self.fq = multi_node_gpu_wrap_fq\n self.grad = multi_node_gpu_wrap_fq_grad\n self.processor = processor\n return True\n\n elif processor == self.avail_pro[1] and check_gpu() is True:\n from pyiid.experiments.elasticscatter.gpu_wrappers.gpu_wrap import \\\n wrap_fq as flat_fq\n from pyiid.experiments.elasticscatter.gpu_wrappers.gpu_wrap import \\\n wrap_fq_grad as flat_grad\n\n self.fq = flat_fq\n self.grad = flat_grad\n self.alg = 'flat'\n if check_cudafft():\n from pyiid.experiments.elasticscatter.gpu_wrappers.gpu_wrap import \\\n grad_pdf\n self.grad_pdf = grad_pdf\n else:\n self.grad_pdf = cpu_grad_pdf\n self.processor = processor\n return True\n\n elif processor == self.avail_pro[2]:\n if kernel_type == 'nxn':\n self.fq = cpu_wrap_fq\n self.grad = cpu_wrap_fq_grad\n self.alg = 'nxn'\n\n elif kernel_type == 'flat':\n from pyiid.experiments.elasticscatter.cpu_wrappers \\\n .flat_multi_cpu_wrap import \\\n wrap_fq, wrap_fq_grad\n\n self.fq = wrap_fq\n self.grad = wrap_fq_grad\n self.alg = 'flat'\n\n elif kernel_type == 'flat-serial':\n from pyiid.experiments.elasticscatter.cpu_wrappers \\\n .flat_serial_cpu_wrap import \\\n wrap_fq, wrap_fq_grad\n\n self.fq = wrap_fq\n self.grad = wrap_fq_grad\n self.alg = 'flat-serial'\n\n self.grad_pdf = cpu_grad_pdf\n self.processor = processor\n return True\n\n def check_wrap_atoms_state(self, atoms):\n if self.wrap_atoms_state is None:\n return False\n if 'F(Q) scatter' not in atoms.arrays.keys():\n return False\n if atoms.info['exp'] != self.exp or \\\n atoms.info['scatter_atoms'] != len(atoms):\n return False\n return True\n\n def get_fq(self, atoms, iq_std=None, noise_distribution=None):\n \"\"\"\n Calculate the reduced structure factor F(Q)\n\n Parameters\n ----------\n atoms: ase.Atoms\n The atomic configuration for which to calculate F(Q)\n iq_std: {None, float, ndarray}, optional\n Add noise to the data, if `noise` is a float then assume flat\n gaussian noise with a standard deviation of noise, if an array\n then assume that each point has a gaussian distribution of noise\n with a standard deviation given by noise. Note that this noise is\n noise in I(Q) which is propagated to F(Q)\n noise_distribution: distribution function\n The distribution function to take the scattering pattern\n\n Returns\n -------\n 1darray:\n The reduced structure factor\n \"\"\"\n if self.check_wrap_atoms_state(atoms) is False:\n if self.verbose:\n print('calculating new scatter factors')\n self._wrap_atoms(atoms)\n self.wrap_atoms_state = atoms\n fq = self.fq(atoms, self.exp['qbin'])\n fq = fq[int(np.floor(self.exp['qmin'] / self.exp['qbin'])):]\n if iq_std is not None:\n fq_std = iq_std * np.abs(self.get_scatter_vector()) / np.abs(\n np.average(atoms.get_array('F(Q) scatter'), axis=0) ** 2)[int(\n np.floor(self.exp['qmin'] / self.exp['qbin'])):]\n if fq_std[0] == 0.0:\n fq_std[0] += 1e-9 # added because we can't have zero noise\n exp_noise = self.rs.normal(0, fq_std)\n fq += exp_noise\n return fq\n\n def get_pdf(self, atoms, iq_std=None, noise_distribution=np.random.normal):\n \"\"\"\n Calculate the atomic pair distribution factor, PDF, G(r)\n\n Parameters\n ----------\n atoms: ase.Atoms\n The atomic configuration for which to calculate the PDF\n iq_std: {None, float, ndarray}, optional\n Add noise to the data, if `noise` is a float then assume flat\n gaussian noise with a standard deviation of noise, if an array\n then assume that each point has a gaussian distribution of noise\n with a standard deviation given by noise. Note that this noise is\n noise in I(Q) which is propagated to F(Q)\n noise_distribution: distribution function\n The distribution function to take the scattering pattern\n\n Returns\n -------\n 1darray:\n The PDF\n \"\"\"\n if self.check_wrap_atoms_state(atoms) is False:\n if self.verbose:\n print('calculating new scatter factors')\n self._wrap_atoms(atoms)\n self.wrap_atoms_state = atoms\n fq = self.fq(atoms, self.pdf_qbin, 'PDF')\n if iq_std is not None:\n a = np.abs(self.get_scatter_vector(pdf=True))\n b = np.abs(np.average(atoms.get_array('PDF scatter') ** 2, axis=0))\n if hasattr(iq_std, 'shape') and iq_std.shape != a.shape:\n iq_std = griddata(np.arange(0, iq_std.shape), iq_std,\n np.arange(\n a.shape))\n fq_noise = iq_std * a / b\n if fq_noise[0] == 0.0:\n fq_noise[0] += 1e-9 # added because we can't have zero noise\n exp_noise = self.rs.normal(0, fq_noise)\n fq += exp_noise\n r = self.get_r()\n pdf0 = get_pdf_at_qmin(\n fq,\n self.exp['rstep'],\n self.pdf_qbin,\n r,\n self.exp['qmin']\n )\n return pdf0\n\n def get_sq(self, atoms, iq_std=None, noise_distribution=np.random.normal):\n \"\"\"\n Calculate the structure factor S(Q)\n\n Parameters\n ----------\n atoms: ase.Atoms\n The atomic configuration for which to calculate S(Q)\n iq_std: {None, float, ndarray}, optional\n Add noise to the data, if `noise` is a float then assume flat\n gaussian noise with a standard deviation of noise, if an array\n then assume that each point has a gaussian distribution of noise\n with a standard deviation given by noise. Note that this noise is\n noise in I(Q) which is propagated to F(Q)\n noise_distribution: distribution function\n The distribution function to take the scattering pattern\n Returns\n -------\n 1darray:\n The structure factor\n \"\"\"\n fq = self.get_fq(atoms, iq_std, noise_distribution)\n old_settings = np.seterr(all='ignore')\n sq = (fq / self.get_scatter_vector()) + np.ones(\n self.get_scatter_vector().shape)\n np.seterr(**old_settings)\n sq[np.isinf(sq)] = 0.\n return sq\n\n def get_iq(self, atoms, iq_std=None, noise_distribution=np.random.normal):\n \"\"\"\n Calculate the scattering intensity, I(Q)\n\n Parameters\n ----------\n atoms: ase.Atoms\n The atomic configuration for which to calculate I(Q)\n iq_std: {None, float, ndarray}, optional\n Add noise to the data, if `noise` is a float then assume flat\n gaussian noise with a standard deviation of noise, if an array\n then assume that each point has a gaussian distribution of noise\n with a standard deviation given by noise. Note that this noise is\n noise in I(Q) which is propagated to F(Q)\n noise_distribution: distribution function\n The distribution function to take the scattering pattern\n Returns\n -------\n 1darray:\n The scattering intensity\n \"\"\"\n sq = self.get_sq(atoms, iq_std, noise_distribution)\n f2 = np.average(atoms.get_array('F(Q) scatter'), axis=0) ** 2\n iq = sq * f2[int(np.floor(self.exp['qmin'] / self.exp['qbin'])):]\n return iq\n\n def get_2d_scatter(self, atoms, pixel_array):\n \"\"\"\n Calculate the scattering intensity as projected onto a detector\n\n Parameters\n ----------\n atoms: ase.Atoms\n The atomic configuration for which to calculate I(Q)\n pixel_array: 2darray\n A map from Q to the xy coordinates of the detector, each element\n has a Q value\n Returns\n -------\n 2darray:\n The scattering intensity on the detector\n \"\"\"\n\n iq = self.get_iq(atoms)\n s = self.get_scatter_vector()\n qb = self.exp['qbin']\n final_shape = pixel_array.shape\n fp = pixel_array.ravel()\n img = np.zeros(fp.shape)\n for sub_s, i in zip(s, iq):\n c = np.intersect1d(np.where(sub_s - qb / 2. < fp)[0],\n np.where(sub_s + qb / 2. > fp)[0])\n img[c] = i\n return img.reshape(final_shape)\n\n def get_grad_fq(self, atoms):\n \"\"\"\n Calculate the gradient of the reduced structure factor F(Q)\n\n Parameters\n ----------\n atoms: ase.Atoms\n The atomic configuration for which to calculate grad F(Q)\n Returns\n -------\n 3darray:\n The gradient of the reduced structure factor\n \"\"\"\n if self.check_wrap_atoms_state(atoms) is False:\n if self.verbose:\n print('calculating new scatter factors')\n self._wrap_atoms(atoms)\n self.wrap_atoms_state = atoms\n g = self.grad(atoms, self.exp['qbin'])\n return g[:, :, int(np.floor(self.exp['qmin'] / self.exp['qbin'])):]\n\n def get_grad_pdf(self, atoms):\n \"\"\"\n Calculate the gradient of the PDF\n\n Parameters\n ----------\n atoms: ase.Atoms\n The atomic configuration for which to calculate grad PDF\n Returns\n -------\n 3darray:\n The gradient of the PDF\n \"\"\"\n if self.check_wrap_atoms_state(atoms) is False:\n if self.verbose:\n print('calculating new scatter factors')\n self._wrap_atoms(atoms)\n self.wrap_atoms_state = atoms\n fq_grad = self.grad(atoms, self.pdf_qbin, 'PDF')\n qmin_bin = int(self.exp['qmin'] / self.pdf_qbin)\n fq_grad[:, :, :qmin_bin] = 0.\n rgrid = self.get_r()\n\n pdf_grad = self.grad_pdf(fq_grad, self.exp['rstep'], self.pdf_qbin,\n rgrid,\n self.exp['qmin'])\n return pdf_grad\n\n def get_scatter_vector(self, pdf=False):\n \"\"\"\n Calculate the scatter vector Q for the current experiment\n\n Parameters\n ----------\n pdf: bool\n If true return the PDF rendering scatter vector\n\n Returns\n -------\n 1darray:\n The Q range for this experiment\n \"\"\"\n if pdf:\n return np.arange(0.,\n math.floor(self.exp['qmax'] / self.pdf_qbin) *\n self.pdf_qbin, self.pdf_qbin)\n return np.arange(self.exp['qmin'], math.floor(self.exp['qmax'] /\n self.exp['qbin']) *\n self.exp['qbin'],\n self.exp['qbin'])\n\n def get_r(self):\n \"\"\"\n Calculate the inter-atomic distance range for the current experiment\n\n Returns\n -------\n 1darray:\n The r range for this experiment\n \"\"\"\n return np.arange(self.exp['rmin'], self.exp['rmax'], self.exp['rstep'])\n", "meta": {"hexsha": "5e8c4a55fc46e1804dd4043f19fdcc28205dd5f8", "size": 19868, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyiid/experiments/elasticscatter/__init__.py", "max_stars_repo_name": "ZhouHUB/pyIID", "max_stars_repo_head_hexsha": "6114fb5ae4388061c7aae9f5b0b2e41aa4ca4341", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pyiid/experiments/elasticscatter/__init__.py", "max_issues_repo_name": "ZhouHUB/pyIID", "max_issues_repo_head_hexsha": "6114fb5ae4388061c7aae9f5b0b2e41aa4ca4341", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 13, "max_issues_repo_issues_event_min_datetime": "2016-04-25T18:36:42.000Z", "max_issues_repo_issues_event_max_datetime": "2016-06-12T20:57:35.000Z", "max_forks_repo_path": "pyiid/experiments/elasticscatter/__init__.py", "max_forks_repo_name": "ZhouHUB/pyIID", "max_forks_repo_head_hexsha": "6114fb5ae4388061c7aae9f5b0b2e41aa4ca4341", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.542039356, "max_line_length": 84, "alphanum_fraction": 0.5628145762, "include": true, "reason": "import numpy,from scipy,from numba", "num_tokens": 4412, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5660185205547239, "lm_q2_score": 0.3451052574867685, "lm_q1q2_score": 0.19533596727831776}} {"text": "import numpy as np\nimport scipy\nimport os\nimport sys\nimport re\nimport dis\nimport hashlib\nimport glob\nimport importlib\nimport inspect\nimport shutil\nimport numbers\nfrom contextlib import contextmanager\nfrom collections import defaultdict\nfrom setuptools import setup, Extension\ntry:\n from Cython.Build import cythonize\nexcept ImportError:\n pass\nfrom warnings import warn\n\nfrom ..settings import settings as qset\nfrom ..optionsclass import optionsclass\nfrom .data import Data\nfrom .interpolate import Cubic_Spline\nfrom .cy.coefficient import (InterpolateCoefficient, InterCoefficient,\n StepCoefficient, FunctionCoefficient,\n ConjCoefficient, NormCoefficient,\n ShiftCoefficient, StrFunctionCoefficient,\n Coefficient)\n\n\n__all__ = [\"coefficient\", \"CompilationOptions\", \"Coefficient\",\n \"clean_compiled_coefficient\"]\n\n\nclass StringParsingWarning(Warning):\n pass\n\n\ndef coefficient(base, *, tlist=None, args={}, args_ctypes={},\n _stepInterpolation=False, compile_opt=None,\n function_style=None):\n \"\"\"Coefficient for time dependent systems.\n\n The coefficients are either a function, a string or a numpy array.\n\n For function based coefficients, the function signature must be either:\n\n * ``f(t, ...)`` where the other arguments are supplied as ordinary\n \"pythonic\" arguments (e.g. ``f(t, w, a=5))\n * ``f(t, args)`` where the arguments are supplied in a \"dict\" named\n ``args``\n\n By default the signature style is controlled by the\n ``qutip.settings.core[\"function_coefficient_style\"]`` setting, but it\n may be overriden here by specifying either ``function_style=\"pythonic\"``\n or ``function_style=\"dict\"``.\n\n *Examples*\n # pythonic style function signature\n\n def f1_t(t, w):\n return np.exp(-1j * t * w)\n\n coeff1 = coefficient(f1_t, args={\"w\": 1.})\n\n # dict style function signature\n\n def f2_t(t, args):\n return np.exp(-1j * t * args[\"w\"])\n\n coeff2 = coefficient(f2_t, args={\"w\": 1.})\n\n For string based coeffients, the string must be a compilable python code\n resulting in a complex. The following symbols are defined:\n sin cos tan asin acos atan pi\n sinh cosh tanh asinh acosh atanh\n exp log log10 erf zerf sqrt\n real imag conj abs norm arg proj\n numpy as np,\n scipy.special as spe (python interface)\n and cython_special (cython interface)\n [https://docs.scipy.org/doc/scipy/reference/special.cython_special.html].\n\n *Examples*\n coeff = coefficient('exp(-1j*w1*t)', args={\"w1\":1.})\n 'args' is needed for string coefficient at compilation.\n It is a dict of (name:object). The keys must be a valid variables string.\n\n Compilation options can be passed as \"compile_opt=CompilationOptions(...)\".\n\n For numpy array format, the array must be an 1d of dtype float or complex.\n A list of times (float64) at which the coeffients must be given (tlist).\n The coeffients array must have the same len as the tlist.\n The time of the tlist do not need to be equidistant, but must be sorted.\n By default, a cubic spline interpolation will be used for the coefficient\n at time t.\n If the coefficients are to be treated as step function, use the arguments:\n _stepInterpolation=True\n\n *Examples*\n tlist = np.logspace(-5,0,100)\n H = QobjEvo(np.exp(-1j*tlist), tlist=tlist)\n \"\"\"\n if isinstance(base, Coefficient):\n return base\n\n if isinstance(base, Cubic_Spline):\n return InterpolateCoefficient(base)\n\n elif isinstance(base, np.ndarray):\n if len(base.shape) != 1:\n raise ValueError(\"The array to interpolate must be a 1D array\")\n if base.shape != tlist.shape:\n raise ValueError(\"tlist must be the same len \"\n \"as the array to interpolate\")\n base = base.astype(np.complex128)\n tlist = tlist.astype(np.float64)\n if not _stepInterpolation:\n return InterCoefficient(base, tlist)\n else:\n return StepCoefficient(base, tlist)\n\n elif isinstance(base, str):\n if compile_opt is None:\n compile_opt = CompilationOptions()\n return coeff_from_str(base, args, args_ctypes, compile_opt)\n\n elif callable(base):\n op = FunctionCoefficient(base, args.copy(), style=function_style)\n if not isinstance(op(0), numbers.Number):\n raise TypeError(\"The coefficient function must return a number\")\n return op\n else:\n raise ValueError(\"coefficient format not understood\")\n\n\ndef norm(coeff):\n \"\"\" return a Coefficient with is the norm: |c|^2.\n \"\"\"\n return NormCoefficient(coeff)\n\n\ndef conj(coeff):\n \"\"\" return a Coefficient with is the conjugate.\n \"\"\"\n return ConjCoefficient(coeff)\n\n\ndef shift(coeff, _t0=0):\n \"\"\" return a Coefficient in which t is shifted by _t0.\n \"\"\"\n return ShiftCoefficient(coeff, _t0)\n\n\n# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n# %%%%%%%%% Everything under this is for string compilation %%%%%%%%%\n# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n@optionsclass(\"compile\", qset.core)\nclass CompilationOptions:\n \"\"\"\n Options for compilation.\n use_cython: bool\n execute strings as python code instead of cython.\n\n Type management options.\n accept_int : None, bool\n Whether integer constants and args are kept or upgraded to float\n If `None`, use in if array subscrition is used.\n accept_float : bool\n Whether float are kept as float or upgraded to complex.\n no_types : bool\n Give up on detecting and using c types.\n recompile : bool\n Do not use previously made files but build a new one.\n compiler_flags : str\n Flags to pass to the compiler, ex: \"-Wall -O3\"...\n Flags not matching your comiler and OS may cause compilation to fail.\n Use \"recompile=True\", when trying to if the string pattern was\n previously used.\n link_flags : str\n Libraries to link to pass to the compiler. They can not be used to add\n function to the string coefficient.\n extra_import : str\n Cython code to add at the head of the file. Can be used to add extra\n import or import c code etc. ex:\n \"from scipy.linalg import det\"\n \"from qutip.core.data import CSR\"\n \"\"\"\n try:\n import cython\n _use_cython = True\n except ImportError:\n _use_cython = False\n\n _link_flags = \"\"\n _compiler_flags = \"\"\n if sys.platform == 'win32':\n _compiler_flags = ''\n elif sys.platform == 'darwin':\n _compiler_flags = '-w -O3 -funroll-loops -mmacosx-version-min=10.9'\n _link_flags += '-mmacosx-version-min=10.9'\n else:\n _compiler_flags = '-w -O3 -funroll-loops'\n\n options = {\n # use cython for compiling string coefficient\n \"use_cython\": _use_cython,\n # try to parse the string so qutip recognise similar string as one\n # compiled coefficient:\n # \"a*t\", \"a * t\", \"b*t\" would all use one compiled version\n \"try_parse\": True,\n # In compiled Coefficient, are int kept as int?\n # None indicate to look for list subscription\n \"accept_int\": None,\n # In compiled Coefficient, are float considered as complex?\n \"accept_float\": True,\n # In compiled Coefficient, is static typing used?\n # Result is faster, but can cause errors if subscription\n # (a[1], b[\"a\"]) if used.\n \"no_types\": False,\n # Skip saved previously compiled files and force compilation\n \"recompile\": False,\n # Compilation flags and link flags to pass to the compiler\n \"compiler_flags\": _compiler_flags,\n \"link_flags\": _link_flags,\n # Extra_header\n \"extra_import\": \"\"\n }\n\n\n# Version number of the Coefficient\nCOEFF_VERSION = \"1.1\"\n\n\ndef get_root():\n \"\"\"\n Find the location of the compiled coefficient and ensure they are in\n the import path.\n \"\"\"\n # qset.install['tmproot'] can be changed by the user without updating\n # PYTHONPATH. If optionsclass allows for property like options,\n # the logic could be moved there\n tmproot = qset.install['tmproot']\n root = os.path.join(tmproot, 'qutip_coeffs_{}'.format(COEFF_VERSION))\n if not os.path.exists(root):\n os.mkdir(root)\n if not os.access(root, os.W_OK):\n root = \".\"\n if root not in sys.path:\n sys.path.insert(0, root)\n return root\n\n\ndef clean_compiled_coefficient(all=False):\n \"\"\"\n Remove previouly compiled string Coefficient.\n\n Parameter:\n ----------\n all: bool\n If not `all` will remove only previous version.\n \"\"\"\n import glob\n import shutil\n tmproot = qset.install['tmproot']\n root = os.path.join(tmproot, 'qutip_coeffs_{}'.format(COEFF_VERSION))\n folders = glob.glob(os.path.join(tmproot, 'qutip_coeffs_') + \"*\")\n for folder in folders:\n if all or folder != root:\n shutil.rmtree(folder)\n\n\n\ndef proj(x):\n if np.isfinite(x):\n return (x)\n else:\n return np.inf + 0j * np.imag(x)\n\n\nstr_env = {\n \"sin\": np.sin,\n \"cos\": np.cos,\n \"tan\": np.tan,\n \"asin\": np.arcsin,\n \"acos\": np.arccos,\n \"atan\": np.arctan,\n \"pi\": np.pi,\n \"sinh\": np.sinh,\n \"cosh\": np.cosh,\n \"tanh\": np.tanh,\n \"asinh\": np.arcsinh,\n \"acosh\": np.arccosh,\n \"atanh\": np.arctanh,\n \"exp\": np.exp,\n \"log\": np.log,\n \"log10\": np.log10,\n \"erf\": scipy.special.erf,\n \"zerf\": scipy.special.erf,\n \"sqrt\": np.sqrt,\n \"real\": np.real,\n \"imag\": np.imag,\n \"conj\": np.conj,\n \"abs\": np.abs,\n \"norm\": lambda x: np.abs(x)**2,\n \"arg\": np.angle,\n \"proj\": proj,\n \"np\": np,\n \"spe\": scipy.special}\n\n\ndef coeff_from_str(base, args, args_ctypes, compile_opt):\n \"\"\"\n Entry point for string based coefficients\n - Test if the string is valid\n - Parse: \"cos(a*t)\" and \"cos( w1 * t )\"\n should be recognised as the same compiled object.\n - Verify if already compiled and compile if not\n \"\"\"\n # First, a sanity check before thinking of compiling\n if not compile_opt['extra_import']:\n try:\n env = {\"t\": 0}\n env.update(args)\n exec(base, str_env, env)\n except Exception as err:\n raise Exception(\"Invalid string coefficient\") from err\n # Do we even compile?\n if not compile_opt['use_cython']:\n return StrFunctionCoefficient(base, args)\n # Parsing tries to make the code in common pattern\n parsed, variables, constants, raw = try_parse(base, args,\n args_ctypes, compile_opt)\n # Once parsed, the code should be unique enough to get a filename\n hash_ = hashlib.sha256(bytes(parsed, encoding='utf8'))\n file_name = \"qtcoeff_\" + hash_.hexdigest()[:30]\n # See if it already exist, if not write and cythonize it\n coeff = try_import(file_name, parsed)\n if coeff is None or compile_opt['recompile']:\n code = make_cy_code(parsed, variables, constants,\n raw, compile_opt)\n coeff = compile_code(code, file_name, parsed, compile_opt)\n keys = [key for _, key, _ in variables]\n const = [fromstr(val) for _, val, _ in constants]\n return coeff(base, keys, const, args)\n\n\ndef try_import(file_name, parsed_in):\n \"\"\" Import the compiled coefficient if existing and check for\n name collision.\n \"\"\"\n get_root()\n coeff = None\n try:\n mod = importlib.import_module(file_name)\n except ModuleNotFoundError:\n # Coefficient does not exist, to compile as file_name\n return None\n\n if mod.parsed_code == parsed_in:\n # Coefficient found!\n return mod.StrCoefficient\n else:\n raise ValueError(\"string hash collision, change the string \"\n \"or clean files in qutip.settings.install['tmproot']\")\n\n\ndef make_cy_code(code, variables, constants, raw, compile_opt):\n \"\"\"\n Generate the code for the string coefficients.\n \"\"\"\n cdef_cte = \"\"\n init_cte = \"\"\n copy_cte = \"\"\n for i, (name, val, ctype) in enumerate(constants):\n cdef_cte += \" {} {}\\n\".format(ctype, name[5:])\n copy_cte += \" out.{} = {}\\n\".format(name[5:], name)\n init_cte += \" {} = cte[{}]\\n\".format(name, i)\n cdef_var = \"\"\n init_var = \"\"\n init_arg = \"\"\n replace_var = \"\"\n call_var = \"\"\n copy_var = \"\"\n for i, (name, val, ctype) in enumerate(variables):\n cdef_var += \" str key{}\\n\".format(i)\n cdef_var += \" {} {}\\n\".format(ctype, name[5:])\n copy_var += \" out.key{} = self.key{}\\n\".format(i, i)\n copy_var += \" out.{} = {}\\n\".format(name[5:], name)\n if not raw:\n init_var += \" self.key{} = var[{}]\\n\".format(i, i)\n else:\n init_var += \" self.key{} = '{}'\\n\".format(i, val)\n init_arg += \" {} = args[self.key{}]\\n\".format(name, i)\n replace_var += \" if self.key{} in kwargs:\\n\".format(i)\n replace_var += (\" out.{}\"\n \" = kwargs[self.key{}]\\n\".format(name[5:], i))\n if raw:\n call_var += \" cdef {} {} = {}\\n\".format(ctype, val, name)\n\n code = f\"\"\"#cython: language_level=3\n# This file is generated automatically by QuTiP.\n\nimport numpy as np\nimport scipy.special as spe\nfrom scipy.special cimport cython_special\ncimport cython\nfrom qutip.core.cy.coefficient cimport Coefficient\nfrom qutip.core.cy.math cimport erf, zerf\nfrom qutip.core.cy.complex_math cimport *\nfrom qutip.core.data cimport Data\ncdef double pi = 3.14159265358979323\n{compile_opt['extra_import']}\n\nparsed_code = \"{code}\"\n\n@cython.auto_pickle(True)\ncdef class StrCoefficient(Coefficient):\n \\\"\\\"\\\"\n String compiled as a :obj:`Coefficient` using cython.\n \\\"\\\"\\\"\n cdef:\n str codeString\n{cdef_cte}{cdef_var}\n\n def __init__(self, base, var, cte, args):\n self.codeString = base\n{init_cte}{init_var}{init_arg}\n\n cpdef Coefficient copy(self):\n \\\"\\\"\\\"Return a copy of the :obj:`Coefficient`.\\\"\\\"\\\"\n cdef StrCoefficient out = StrCoefficient.__new__(StrCoefficient)\n out.codeString = self.codeString\n{copy_cte}{copy_var}\n return out\n\n def replace_arguments(self, _args=None, **kwargs):\n \\\"\\\"\\\"\n Return a :obj:`Coefficient` with args changed for :obj:`Coefficient`\n built from 'str' or a python function. Or a the :obj:`Coefficient`\n itself if the :obj:`Coefficient` does not use arguments. New arguments\n can be passed as a dict or as keywords.\n\n Parameters\n ----------\n _args : dict\n Dictionary of arguments to replace.\n\n **kwargs\n Arguments to replace.\n \\\"\\\"\\\"\n cdef StrCoefficient out\n\n if _args:\n kwargs.update(_args)\n if kwargs:\n out = self.copy()\n{replace_var}\n return out\n return self\n\n @cython.initializedcheck(False)\n @cython.cdivision(True)\n cdef complex _call(self, double t) except *:\n{call_var} return {code}\n\"\"\"\n return code\n\n\ndef compile_code(code, file_name, parsed, c_opt):\n pwd = os.getcwd()\n root = get_root()\n try:\n os.chdir(root)\n [os.remove(file) for file in glob.glob(file_name + \"*\")]\n full_file_name = os.path.join(root, file_name)\n file_ = open(full_file_name + \".pyx\", \"w\")\n file_.writelines(code)\n file_.close()\n oldargs = sys.argv\n try:\n sys.argv = [\"setup.py\", \"build_ext\", \"--inplace\"]\n coeff_file = Extension(file_name,\n sources=[full_file_name + \".pyx\"],\n extra_compile_args=c_opt['compiler_flags'].split(),\n extra_link_args=c_opt['link_flags'].split(),\n include_dirs=[np.get_include()],\n language='c++')\n setup(ext_modules=cythonize(coeff_file, force=c_opt['recompile']))\n except Exception as e:\n raise Exception(\"Could not compile\") from e\n finally:\n sys.argv = oldargs\n finally:\n os.chdir(pwd)\n return try_import(file_name, parsed)\n\n\n# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n# %%%%%%%%% Everything under this is for parsing string %%%%%%%%%\n# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n# Parsing here is extracting constants and args name to replace them with\n# attribute of the Coefficient so similar string like:\n# \"2.*cos(a*t)\", \"5.2 * cos(w1 *t)\", \"5 * cos(w3 * t)\"\n# are all reconized as the same compiled object and only compiled once.\n# Weakness:\n# typing: \"1\" and \"1j\" or the type of args (\"w1\") make different object\n# complex: \"1+1j\" is seens as cte(double) + cte(complex)\n# negative: \"-1\" is not seens as a constant but \"- constant\"\n#\n# int and double can be seens as complex with flags in CompilationOptions\n\ndef fromstr(base):\n \"\"\"Read a varibles in a string\"\"\"\n ls = {}\n exec(\"out = \" + base, {}, ls)\n return ls[\"out\"]\n\n\ntypeCodes = {\n \"Data\": \"_datalayer\",\n \"complex\": \"_cpl\",\n \"double\": \"_dbl\",\n \"int\": \"_int\",\n \"str\": \"_str\",\n \"object\": \"_obj\"\n}\n\n\ndef compileType(value):\n \"\"\"Obtain the index of typeCodes that correspond to the value\n 4.5 -> 'double'...\"\"\"\n if isinstance(value, Data):\n ctype = \"Data\"\n elif isinstance(value, numbers.Integral):\n ctype = \"int\"\n elif isinstance(value, numbers.Real):\n ctype = \"double\"\n elif isinstance(value, numbers.Complex):\n ctype = \"complex\"\n elif isinstance(value, str):\n ctype = \"str\"\n else:\n ctype = \"object\"\n return ctype\n\n\ndef find_type_from_str(chars):\n \"\"\" '1j' -> complex \"\"\"\n try:\n lc = {}\n exec(\"out = \" + chars, {}, lc)\n return compileType(lc[\"out\"])\n except Exception:\n return None\n\n\ndef fix_type(ctype, accept_int, accept_float):\n \"\"\"int and double could be complex to limit the number of compiled object.\n change the types is we choose not to support all.\n \"\"\"\n if ctype == \"int\" and not accept_int:\n ctype = \"double\"\n if ctype == \"double\" and not accept_float:\n ctype = \"complex\"\n return ctype\n\n\ndef extract_constant(code):\n \"\"\"Look for floating and complex constants and replace them with variable.\n \"\"\"\n code = \" \" + code + \" \"\n contants = []\n code = extract_cte_pattern(code, contants,\n \"[^0-9a-zA-Z_][0-9]*[.]?[0-9]+e[+-]?[0-9]*[j]?\")\n code = extract_cte_pattern(code, contants,\n \"[^0-9a-zA-Z_][0-9]+[.]?[0-9]*e[+-]?[0-9]*[j]?\")\n code = extract_cte_pattern(code, contants,\n \"[^0-9a-zA-Z_][0-9]+[.]?[0-9]*[j]?\")\n code = extract_cte_pattern(code, contants,\n \"[^0-9a-zA-Z_][0-9]*[.]?[0-9]+[j]?\")\n return code, contants\n\n\ndef extract_cte_pattern(code, constants, pattern):\n \"\"\"replace the constant following a pattern with variable\"\"\"\n const_strs = re.findall(pattern, code)\n for cte in const_strs:\n name = \" _cte_temp{}_ \".format(len(constants))\n code = code.replace(cte, cte[0] + name, 1)\n constants.append((name[1:-1], cte[1:], find_type_from_str(cte[1:])))\n return code\n\n\ndef space_parts(code, names):\n \"\"\"Force spacing: single space between element\"\"\"\n for name in names:\n code = re.sub(\"(?<=[^0-9a-zA-Z_])\" + name + \"(?=[^0-9a-zA-Z_])\",\n \" \" + name + \" \", code)\n code = \" \".join(code.split())\n return code\n\n\ndef parse(code, args, compile_opt):\n \"\"\"\n Read the code and rewrite it in a reutilisable form:\n Ins:\n '2.*cos(a*t)', {\"a\":5+1j}\n Outs:\n code = 'self._cte_dbl0 * cos ( self._arg_cpl0 * t )'\n variables = [('self._arg_cpl0', 'a', 'complex')]\n ordered_constants = [('self._cte_dbl0', 2, 'double')]\n \"\"\"\n code, constants = extract_constant(code)\n names = re.findall(\"[0-9a-zA-Z_]+\", code)\n code = space_parts(code, names)\n constants_names = [const[0] for const in constants]\n new_code = []\n ordered_constants = []\n variables = []\n typeCounts = defaultdict(lambda: 0)\n accept_int = compile_opt['accept_int']\n accept_float = compile_opt['accept_float']\n if accept_int is None:\n # If there is a subscript: a[b] int are always accepted to be safe\n # with TypeError\n accept_int = \"SUBSCR\" in dis.Bytecode(code).dis()\n for word in code.split():\n if word not in names:\n # syntax\n new_code.append(word)\n elif word in args:\n # find first if the variable is use more than once and reuse\n var_name = [var_name for var_name, name, _ in variables\n if word == name]\n if var_name:\n var_name = var_name[0]\n else:\n ctype = compileType(args[word])\n ctype = fix_type(ctype, accept_int, accept_float)\n var_name = (\"self._arg\" + typeCodes[ctype] +\n str(typeCounts[ctype]))\n typeCounts[ctype] += 1\n variables.append((var_name, word, ctype))\n new_code.append(var_name)\n elif word in constants_names:\n name, val, ctype = constants[int(word[9:-1])]\n ctype = fix_type(ctype, accept_int, accept_float)\n cte_name = \"self._cte\" + typeCodes[ctype] +\\\n str(len(ordered_constants))\n new_code.append(cte_name)\n ordered_constants.append((cte_name, val, ctype))\n else:\n # Hopefully a buildin or known object\n new_code.append(word)\n code = \" \".join(new_code)\n return code, variables, ordered_constants\n\n\ndef use_hinted_type(variables, code, args_ctypes):\n variables_manually_typed = []\n for i, (name, key, type_) in enumerate(variables):\n if key in args_ctypes:\n new_name = \"self._custom_\" + args_ctypes[key] + str(i)\n code = code.replace(name, new_name)\n variables_manually_typed.append((new_name, key, args_ctypes[key]))\n else:\n variables_manually_typed.append((name, key, type_))\n return code, variables_manually_typed\n\n\ndef try_parse(code, args, args_ctypes, compile_opt):\n \"\"\"\n Try to parse and verify that the result is still usable.\n \"\"\"\n if not compile_opt['try_parse']:\n variables = [(\"self.\" + name, name, \"object\") for name in args\n if name in code]\n code, variables = use_hinted_type(variables, code, args_ctypes)\n return code, variables, [], True\n ncode, variables, constants = parse(code, args, compile_opt)\n if compile_opt['no_types']:\n # Fallback to all object\n variables = [(f, s, \"object\") for f, s, _ in variables]\n constants = [(f, s, \"object\") for f, s, _ in constants]\n ncode, variables = use_hinted_type(variables, ncode, args_ctypes)\n if (\n (compile_opt['extra_import']\n and not compile_opt['extra_import'].isspace())\n or test_parsed(ncode, variables, constants, args)\n ):\n return ncode, variables, constants, False\n else:\n warn(\"Could not find c types\", StringParsingWarning)\n remaped_variable = []\n for _, name, ctype in variables:\n remaped_variable.append((\"self.\" + name, name, \"object\"))\n return code, remaped_variable, [], True\n\n\ndef test_parsed(code, variables, constants, args):\n \"\"\"\n Test if parsed code broke anything.\n \"\"\"\n class DummySelf:\n pass\n [setattr(DummySelf, cte[0][5:], fromstr(cte[1])) for cte in constants]\n [setattr(DummySelf, var[0][5:], args[var[1]]) for var in variables]\n loc_env = {\"t\": 0, 'self': DummySelf}\n try:\n exec(code, str_env, loc_env)\n except Exception as e:\n return False\n return True\n", "meta": {"hexsha": "c3b49272b7aed7bc115b9ad7aed10cc4f2a47c3a", "size": 24305, "ext": "py", "lang": "Python", "max_stars_repo_path": "qutip/core/coefficient.py", "max_stars_repo_name": "jakelishman/qutip", "max_stars_repo_head_hexsha": "fbb7fad5bc205910228db622d90601c82db45e4b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "qutip/core/coefficient.py", "max_issues_repo_name": "jakelishman/qutip", "max_issues_repo_head_hexsha": "fbb7fad5bc205910228db622d90601c82db45e4b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2020-07-13T12:11:30.000Z", "max_issues_repo_issues_event_max_datetime": "2020-08-09T22:45:05.000Z", "max_forks_repo_path": "qutip/core/coefficient.py", "max_forks_repo_name": "jakelishman/qutip", "max_forks_repo_head_hexsha": "fbb7fad5bc205910228db622d90601c82db45e4b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.8981868898, "max_line_length": 86, "alphanum_fraction": 0.5957210451, "include": true, "reason": "import numpy,import scipy,from scipy", "num_tokens": 5942, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5660185205547239, "lm_q2_score": 0.3451052574867685, "lm_q1q2_score": 0.19533596727831776}} {"text": "import sys\nsys.path.append('.') #get rid of this at some point with central test script or when package is built\nimport os\nos.chdir('C:\\\\Users\\\\Skoron\\\\Desktop')\nimport MSI.simulations.instruments.flames as f\nimport MSI.cti_core.cti_processor as pr\nimport cantera as ct\nimport matplotlib.pyplot as plt\nimport numpy as np\n\n\n\ntest_p=pr.Processor('C:\\\\Users\\\\Skoron\\\\Google Drive\\\\Burke Group\\\\Codes\\\\Mechanisms\\\\FFCM-1\\\\FFCM1.cti')\nf1 = f.flamespeed_multi_condition(pressures=[1.00],\n temperatures=[298.0],\n kineticSens=1,\n\t\t\t\t\t\t physicalSens=0,\n conditions=[{'H2':0.5,'O2':0.5,'He':4.0},\n {'H2':0.75,'O2':0.5,'He':4.0},\n {'H2':1.0,'O2':0.5,'He':4.0},\n {'H2':1.25,'O2':0.5,'He':4.0},\n {'H2':1.5,'O2':0.5,'He':4.0},\n {'H2':1.75,'O2':0.5,'He':4.0},\n {'H2':2.0,'O2':0.5,'He':4.0},\n {'H2':2.25,'O2':0.5,'He':4.0},\n {'H2':2.5,'O2':0.5,'He':4.0}],\n thermalBoundary='Adiabatic' ,\n processor=test_p,\n save_physSensHistories=0,save_timeHistories=1,loglevel=0)\t\t\t\t\t\t \nsolution,ksens=f1.run()\nmethane_profile=[]\n#for i in jsr1.JSR_objects:\n#\tprint(i.pressure,i.temperature,i.conditions)\n#\tprint(i.solution['ch4'],i.reactorPressure)\n#for i in range(len(jsr1.JSR_objects)):\n#\tmethane_profile.append(jsr1.JSR_objects[i].solution['ch4'])\n\n\t\n#plt.plot(np.linspace(858,1258,25),methane_profile)\n#plt.savefig('C:\\\\Users\\\\HP USER\\\\Google Drive\\\\Burke Group\\\\Mark\\\\MSI\\\\data\\\\jsr_test\\\\methane.pdf',\n#\t\t\t\tdpi=1200, bbox_inches='tight')\n#print(solution['ch4'])\n#print(ksen\nplt.figure()\nplt.plot(solution['H2'],solution['u0'],'k-')\nplt.xlabel('Equivalence Ratio')\nplt.ylabel('Flame Speed (m/s)')\nplt.title('H2/O2/He Flame speed, O2/(O2+He)=0.125')\n\n\n", "meta": {"hexsha": "f8cb806c22ec38f741646fa313bbcd1a5c86e226", "size": 2082, "ext": "py", "lang": "Python", "max_stars_repo_path": "tests/flamespeed_multicond_test.py", "max_stars_repo_name": "carlylagrotta/MSI", "max_stars_repo_head_hexsha": "e958beb5df2a2d1018bbb2f96382b5c99b08c3ef", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-06-25T15:46:06.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-25T15:46:06.000Z", "max_issues_repo_path": "tests/flamespeed_multicond_test.py", "max_issues_repo_name": "TheBurkeLab/MSI", "max_issues_repo_head_hexsha": "e958beb5df2a2d1018bbb2f96382b5c99b08c3ef", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "tests/flamespeed_multicond_test.py", "max_forks_repo_name": "TheBurkeLab/MSI", "max_forks_repo_head_hexsha": "e958beb5df2a2d1018bbb2f96382b5c99b08c3ef", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-12-18T23:45:25.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-10T20:37:20.000Z", "avg_line_length": 40.8235294118, "max_line_length": 105, "alphanum_fraction": 0.530259366, "include": true, "reason": "import numpy", "num_tokens": 602, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5544704796847396, "lm_q2_score": 0.35220178204788966, "lm_q1q2_score": 0.19528549103791348}} {"text": "#####################################################\n#\n# PyRAI2MD 2 module for interfacing to NNsForMD\n#\n# Author Jingbai Li\n# Sep 22 2021\n#\n######################################################\n\nimport time, os, sys\nimport numpy as np\nfrom PyRAI2MD.Machine_Learning.hypernn import SetHyperEG, SetHyperNAC, SetHyperSOC\nfrom PyRAI2MD.Machine_Learning.permutation import PermuteMap\nfrom PyRAI2MD.Utils.timing import WhatIsTime, HowLong\n\nfrom pyNNsMD.nn_pes import NeuralNetPes\nfrom pyNNsMD.nn_pes_src.device import set_gpu\n\nclass DNN:\n \"\"\" pyNNsMD interface\n\n Parameters: Type:\n keywords dict keywords dict\n id int calculation index\n\n Attribute: Type:\n hyp_eg dict Hyperparameters of energy gradient NN\n \t hyp_nac dict Hyperparameters of nonadiabatic coupling NN\n \t hyp_soc dict \t Hyperparameters of spin-orbit coupling NN\n x ndarray input structure array\n y_dict dict target value dict \n pred_x ndarray input structure array in set prediction set\n pred_y ndarray target values in the prediction set\n\n Functions: Returns:\n train self train NN for a given training set\n load self load trained NN for prediction\n appendix self fake function\n evaluate self run prediction\n\n \"\"\"\n\n def __init__(self, keywords = None, id = None):\n\n set_gpu([]) #No GPU for prediction\n title = keywords['control']['title']\n variables = keywords['nn'].copy()\n modeldir = variables['modeldir']\n data = variables['data']\n nn_eg_type = variables['nn_eg_type']\n nn_nac_type = variables['nn_nac_type']\n nn_soc_type = variables['nn_soc_type']\n hyp_eg = variables['eg'].copy()\n hyp_nac = variables['nac'].copy()\n hyp_eg2 = variables['eg2'].copy()\n hyp_nac2 = variables['nac2'].copy()\n hyp_soc = variables['soc'].copy()\n hyp_soc2 = variables['soc2'].copy()\n eg_unit = variables['eg_unit']\n nac_unit = variables['nac_unit']\n soc_unit = variables['soc_unit']\n seed = variables['ml_seed']\n permute = variables['permute_map']\n gpu = variables['gpu']\n self.jobtype = keywords['control']['jobtype']\n self.version = keywords['version']\n self.ncpu = keywords['control']['ml_ncpu']\n self.pred_data = variables['pred_data']\n self.train_mode = variables['train_mode']\n self.shuffle = variables['shuffle']\n self.natom = data.natom\n self.nstate = data.nstate\n self.nnac = data.nnac\n self.nsoc = data.nsoc\n\n ## set hyperparamters\n hyp_dict_eg = SetHyperEG(hyp_eg, eg_unit, data.info)\n hyp_dict_eg2 = SetHyperEG(hyp_eg2, eg_unit, data.info)\n hyp_dict_nac = SetHyperNAC(hyp_nac, nac_unit, data.info)\n hyp_dict_nac2 = SetHyperNAC(hyp_nac2, nac_unit, data.info)\n hyp_dict_soc = SetHyperSOC(hyp_soc, soc_unit, data.info)\n hyp_dict_soc2 = SetHyperSOC(hyp_soc2, soc_unit, data.info)\n\n ## retraining has some bug at the moment, do not use\n if self.train_mode not in ['training', 'retraining', 'resample']:\n self.train_mode = 'training'\n if id == None or id == 1:\n self.name = f\"NN-{title}\"\n else:\n self.name = f\"NN-{title}-{id}\"\n self.silent = variables['silent']\n self.x = data.x\n self.pred_x = data.pred_x\n self.pred_y = data.pred_y\n\n ## convert unit of energy and force. au or si. data are in au.\n if eg_unit == 'si':\n self.H_to_eV = 27.211396132\n self.H_Bohr_to_eV_A = 27.211396132/0.529177249\n self.keep_eV = 1\n self.keep_eVA = 1\n else:\n self.H_to_eV = 1\n self.H_Bohr_to_eV_A = 1\n \t self.keep_eV \t= 27.211396132\n \t self.keep_eVA \t= 27.211396132/0.529177249\n\n if nac_unit == 'si':\n self.Bohr_to_A = 0.529177249/27.211396132 # convert to eV/A\n self.keep_A = 1\n elif nac_unit == 'au':\n self.Bohr_to_A = 1 # convert to Eh/B\n self.keep_A = 0.529177249/27.211396132\n elif nac_unit == 'eha':\n self.Bohr_to_A = 0.529177249 # convert to Eh/A\n self.keep_A = 1/27.211396132\n else:\n self.Bohr_to_A = 1 # convert to Eh/B\n self.keep_A = 0.529177249/27.211396132\n\n ## combine y_dict\n self.y_dict = {}\n if nn_eg_type > 0:\n self.y_dict['energy_gradient'] = [data.energy * self.H_to_eV, data.grad * self.H_Bohr_to_eV_A]\n if nn_nac_type > 0:\n self.y_dict['nac'] = data.nac/self.Bohr_to_A\n if nn_soc_type > 0:\n self.y_dict['soc'] = data.soc\n\n ## check permuation map\n self.x, self.y_dict = PermuteMap(self.x,self.y_dict,permute,hyp_eg['val_split'])\n\n ## combine hypers\n self.hyper = {}\n if nn_eg_type == 1: # same architecture with different weight\n self.hyper['energy_gradient'] = hyp_dict_eg\n elif nn_eg_type > 1:\n \t self.hyper['energy_gradient'] = [hyp_dict_eg, hyp_dict_eg2]\n\n if nn_nac_type == 1: # same architecture with different weight\n \t self.hyper['nac'] = hyp_dict_nac\n \telif nn_nac_type > 1:\n self.hyper['nac'] = [hyp_dict_nac, hyp_dict_nac2]\n\n if nn_soc_type == 1: # same architecture with different weight\n self.hyper['soc'] = hyp_dict_soc\n elif nn_soc_type > 1:\n self.hyper['soc'] = [hyp_dict_soc, hyp_dict_soc2]\n\n ## setup GPU list\n self.gpu_list = {}\n if gpu == 1:\n self.gpu_list['energy_gradient'] = [0, 0]\n self.gpu_list['nac'] = [0, 0]\n self.gpu_list['soc'] = [0, 0]\n \telif gpu == 2:\n self.gpu_list['energy_gradient'] = [0, 1]\n self.gpu_list['nac'] = [0, 1]\n self.gpu_list['soc'] = [0, 1]\n \telif gpu == 3:\n self.gpu_list['energy_gradient'] = [0, 0]\n self.gpu_list['nac'] = [1, 1]\n self.gpu_list['soc'] = [2, 2]\n \telif gpu == 4:\n self.gpu_list['energy_gradient'] = [0, 1]\n self.gpu_list['nac'] = [2, 2]\n self.gpu_list['soc'] = [3, 3]\n elif gpu == 5:\n self.gpu_list['energy_gradient'] = [0, 1]\n self.gpu_list['nac'] = [2, 3]\n self.gpu_list['soc'] = [4, 4]\n elif gpu == 6:\n self.gpu_list['energy_gradient'] = [0, 1]\n self.gpu_list['nac'] = [2, 3]\n self.gpu_list['soc'] = [4, 5]\n\n ## initialize model\n if modeldir == None or id not in [None, 1]:\n self.model = NeuralNetPes(self.name)\n else:\n self.model = NeuralNetPes(modeldir)\n\n def _heading(self):\n\n headline=\"\"\"\n%s\n *---------------------------------------------------*\n | |\n | Neural Networks |\n | |\n *---------------------------------------------------*\n\n Number of atoms: %s\n Number of state: %s\n Number of NAC: %s\n Number of SOC: %s\n\n\"\"\" % ( self.version,\n self.natom,\n self.nstate,\n self.nnac,\n self.nsoc)\n \n \treturn headline\n\n def train(self):\n start = time.time()\n\n self.model.create(self.hyper)\n\n topline = 'Neural Networks Start: %20s\\n%s' % (WhatIsTime(), self._heading())\n runinfo = \"\"\"\\n &nn fitting \\n\"\"\"\n\n if self.silent == 0:\n print(topline)\n print(runinfo)\n\n with open('%s.log' % (self.name), 'w') as log:\n log.write(topline)\n log.write(runinfo)\n\n\n if self.train_mode == 'resample':\n out_index, out_errr, out_fiterr, out_testerr = self.model.resample(\n self.x, \n self.y_dict,\n gpu_dist = self.gpu_list,\n proc_async = self.ncpu >= 4)\n else:\n ferr = self.model.fit(\n self.x,\n self.y_dict,\n gpu_dist = self.gpu_list,\n proc_async = self.ncpu >= 4,\n fitmode = self.train_mode,\n random_shuffle = self.shuffle)\n\n #self.model.save()\n err_e1 = 0\n err_e2 = 0\n err_g1 = 0\n err_g2 = 0\n err_n1 = 0\n err_n2 = 0\n err_s1 = 0\n err_s2 = 0\n if 'energy_gradient' in ferr.keys():\n err_e1 = ferr['energy_gradient'][0][0]\n err_e2 = ferr['energy_gradient'][1][0]\n err_g1 = ferr['energy_gradient'][0][1]\n \t \terr_g2 = ferr['energy_gradient'][1][1]\n\n if 'nac' in ferr.keys():\n err_n1 = ferr['nac'][0]\n err_n2 = ferr['nac'][1]\n\n if 'soc' in ferr.keys():\n err_s1 = ferr['soc'][0]\n err_s2 = ferr['soc'][1]\n\n metrics = {\n 'e1' : err_e1 * self.keep_eV,\n 'g1' : err_g1 * self.keep_eVA,\n 'n1' : err_n1 / self.keep_A,\n 's1' : err_s1,\n 'e2' : err_e2 * self.keep_eV,\n 'g2' : err_g2 * self.keep_eVA,\n 'n2' : err_n2 / self.keep_A,\n 's2' : err_s2}\n\n train_info=\"\"\"\n &nn validation mean absolute error\n-------------------------------------------------------\n energy gradient nac soc\n eV eV/A eV/A cm-1\n %12.8f %12.8f %12.8f %12.8f\n %12.8f %12.8f %12.8f %12.8f\n\n\"\"\" % (metrics['e1'], metrics['g1'], metrics['n1'], metrics['s1'],\n metrics['e2'], metrics['g2'], metrics['n2'], metrics['s2'])\n\n end = time.time()\n walltime = HowLong(start,end)\n endline = 'Neural Networks End: %20s Total: %20s\\n' % (WhatIsTime(), walltime)\n\n if self.silent == 0:\n print(train_info)\n print(endline)\n\n with open('%s.log' % (self.name), 'a') as log:\n log.write(train_info)\n log.write(endline)\n\n metrics['time'] = end - start\n metrics['walltime'] = walltime\n metrics['path'] = os.getcwd()\n metrics['status'] = 1\n\n return metrics\n\n def load(self):\n self.model.load()\n\n return self\n\n def\tappendix(self,addons):\n \t## fake\tfunction does nothing\n\n \treturn self\n\n def _qm(self, traj):\n ## run psnnsmd for QM calculation\n\n xyz = traj.coord.reshape((1, self.natom, 3))\n y_pred,y_std=self.model.call(xyz)\n\n ## initialize return values\n energy = []\n gradient = []\n nac = []\n soc = []\n err_e = 0\n \terr_g =\t0\n \terr_n =\t0\n \terr_s =\t0\n\n ## update return values\n if 'energy_gradient' in y_pred.keys():\n e_pred = y_pred['energy_gradient'][0] / self.H_to_eV\n g_pred = y_pred['energy_gradient'][1] / self.H_Bohr_to_eV_A\n e_std = y_std['energy_gradient'][0] / self.H_to_eV\n g_std = y_std['energy_gradient'][1] / self.H_Bohr_to_eV_A\n energy = e_pred[0]\n gradient = g_pred[0]\n err_e = np.amax(e_std)\n err_g = np.amax(g_std)\n\n if 'nac' in y_pred.keys():\n n_pred = y_pred['nac']*self.Bohr_to_A\n n_std = y_std['nac']*self.Bohr_to_A\n nac = n_pred[0]\n err_n = np.amax(n_std)\n\n if 'soc' in y_pred.keys():\n s_pred = y_pred['soc']\n s_std = y_std['soc']\n soc = s_pred[0]\n err_s = np.amax(s_std)\n\n return energy, gradient, nac, soc, err_e, err_g, err_n, err_s\n\n def _predict(self, x):\n ## run psnnsmd for model testing\n\n batch = len(x)\n\n y_pred, y_std = self.model.predict(x)\n\n ## load values from prediction set\n pred_e = self.pred_y['energy']\n pred_g = self.pred_y['grad']\n pred_n = self.pred_y['nac']\n pred_s = self.pred_y['soc']\n\n ## initialize errors\n de_max = np.zeros(batch)\n dg_max = np.zeros(batch)\n dn_max = np.zeros(batch)\n ds_max = np.zeros(batch)\n\n ## update errors\n if 'energy_gradient' in y_pred.keys():\n e_pred = y_pred['energy_gradient'][0] / self.H_to_eV\n g_pred = y_pred['energy_gradient'][1] / self.H_Bohr_to_eV_A\n e_std = y_std['energy_gradient'][0] / self.H_to_eV \n g_std = y_std['energy_gradient'][1] / self.H_Bohr_to_eV_A\n de = np.abs(pred_e - e_pred)\n dg = np.abs(pred_g - g_pred)\n de_max = np.amax(de.reshape((batch, -1)), axis = 1)\n dg_max = np.amax(dg.reshape((batch, -1)), axis = 1)\n\n val_out = np.concatenate((pred_e.reshape((batch, -1)), e_pred.reshape((batch, -1))), axis = 1)\n std_out = np.concatenate((de.reshape((batch, -1)), e_std.reshape((batch, -1))), axis = 1)\n np.savetxt('%s-e.pred.txt' % (self.name), np.concatenate((val_out, std_out), axis = 1))\n\n val_out = np.concatenate((pred_g.reshape((batch, -1)), g_pred.reshape((batch, -1))), axis = 1)\n \t std_out = np.concatenate((dg.reshape((batch, -1)), g_std.reshape((batch, -1))), axis = 1)\n np.savetxt('%s-g.pred.txt' % (self.name), np.concatenate((val_out, std_out), axis = 1))\n\n if 'nac' in y_pred.keys():\n n_pred = y_pred['nac'] * self.Bohr_to_A\n n_std = y_std['nac'] * self.Bohr_to_A\n dn = np.abs(pred_n - n_pred)\n dn_max = np.amax(dn.reshape((batch, -1)), axis = 1)\n\n val_out = np.concatenate((pred_n.reshape((batch, -1)), n_pred.reshape((batch, -1))), axis = 1)\n \t std_out = np.concatenate((dn.reshape((batch, -1)), n_std.reshape((batch, -1))), axis = 1)\n np.savetxt('%s-n.pred.txt' % (self.name), np.concatenate((val_out, std_out), axis = 1))\n\n\n if 'soc' in y_pred.keys():\n s_pred = y_pred['soc']\n s_std = y_std['soc']\n \t ds = np.abs(pred_s - s_pred)\n ds_max = np.amax(ds.reshape((batch, -1)), axis = 1)\n\n val_out = np.concatenate((pred_s.reshape((batch, -1)), s_pred.reshape((batch, -1))), axis = 1)\n \t std_out = np.concatenate((ds.reshape((batch, -1)), s_std.reshape((batch, -1))), axis = 1)\n np.savetxt('%s-s.pred.txt' % (self.name), np.concatenate((val_out, std_out), axis = 1))\n\n output = ''\n for i in range(batch):\n output += '%5s %8.4f %8.4f %8.4f %8.4f\\n' % (i + 1, de_max[i], dg_max[i], dn_max[i], ds_max[i])\n\n with open('max_abs_dev.txt', 'w') as out:\n out.write(output)\n\n return self\n\n def evaluate(self, traj):\n ## main function to run pyNNsMD and communicate with other PyRAIMD modules\n\n if self.jobtype == 'prediction' or self.jobtype == 'predict':\n self._predict(self.pred_x)\n else:\n energy, gradient, nac, soc, err_energy, err_grad, err_nac, err_soc = self._qm(traj)\n traj.energy = np.copy(energy)\n traj.grad = np.copy(gradient)\n traj.nac = np.copy(nac)\n traj.soc = np.copy(soc)\n traj.err_energy = err_energy\n traj.err_grad = err_grad\n traj.err_nac = err_nac\n traj.err_soc = err_soc\n traj.status = 1\n\n return traj\n", "meta": {"hexsha": "ac84fc8fa44641f76e717334ac155ee0004c6e94", "size": 16086, "ext": "py", "lang": "Python", "max_stars_repo_path": "PyRAI2MD/Machine_Learning/model_NN.py", "max_stars_repo_name": "lopez-lab/PyRAI2MD", "max_stars_repo_head_hexsha": "43e27fbc9bc5b6ab6a8f170791951f316fcd0964", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 12, "max_stars_repo_stars_event_min_datetime": "2021-10-20T23:41:34.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T23:29:21.000Z", "max_issues_repo_path": "PyRAI2MD/Machine_Learning/model_NN.py", "max_issues_repo_name": "lopez-lab/PyRAI2MD", "max_issues_repo_head_hexsha": "43e27fbc9bc5b6ab6a8f170791951f316fcd0964", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "PyRAI2MD/Machine_Learning/model_NN.py", "max_forks_repo_name": "lopez-lab/PyRAI2MD", "max_forks_repo_head_hexsha": "43e27fbc9bc5b6ab6a8f170791951f316fcd0964", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2021-02-06T04:27:01.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-29T23:29:28.000Z", "avg_line_length": 36.7260273973, "max_line_length": 107, "alphanum_fraction": 0.5067760786, "include": true, "reason": "import numpy", "num_tokens": 4265, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5544704649604273, "lm_q2_score": 0.352201788847459, "lm_q1q2_score": 0.19528548962214484}} {"text": "#!/usr/bin/env python\n# Copyright 2014-2018 The PySCF Developers. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n# Author: Qiming Sun \n#\n\nfrom functools import reduce\nimport numpy\nfrom pyscf import lib\nfrom pyscf.lib import logger\nfrom pyscf.ao2mo import _ao2mo\nfrom pyscf.tdscf import uhf\nfrom pyscf.scf import uhf_symm\nfrom pyscf.pbc.tdscf.krhf import _get_e_ia\nfrom pyscf.pbc.scf.newton_ah import _gen_uhf_response\nfrom pyscf import __config__\n\nREAL_EIG_THRESHOLD = getattr(__config__, 'pbc_tdscf_uhf_TDDFT_pick_eig_threshold', 1e-3)\nPOSTIVE_EIG_THRESHOLD = getattr(__config__, 'pbc_tdscf_uhf_TDDFT_positive_eig_threshold', 1e-3)\n\nclass TDA(uhf.TDA):\n\n conv_tol = getattr(__config__, 'pbc_tdscf_rhf_TDA_conv_tol', 1e-6)\n\n def __init__(self, mf):\n from pyscf.pbc import scf\n assert(isinstance(mf, scf.khf.KSCF))\n self.cell = mf.cell\n uhf.TDA.__init__(self, mf)\n from pyscf.pbc.df.df_ao2mo import warn_pbc2d_eri\n warn_pbc2d_eri(mf)\n\n def gen_vind(self, mf):\n '''Compute Ax'''\n singlet = self.singlet\n cell = mf.cell\n kpts = mf.kpts\n\n mo_coeff = mf.mo_coeff\n mo_energy = mf.mo_energy\n mo_occ = mf.mo_occ\n nkpts = len(mo_occ)\n nao, nmo = mo_coeff[0][0].shape\n occidxa = [numpy.where(mo_occ[0][k]> 0)[0] for k in range(nkpts)]\n occidxb = [numpy.where(mo_occ[1][k]> 0)[0] for k in range(nkpts)]\n viridxa = [numpy.where(mo_occ[0][k]==0)[0] for k in range(nkpts)]\n viridxb = [numpy.where(mo_occ[1][k]==0)[0] for k in range(nkpts)]\n orboa = [mo_coeff[0][k][:,occidxa[k]] for k in range(nkpts)]\n orbob = [mo_coeff[1][k][:,occidxb[k]] for k in range(nkpts)]\n orbva = [mo_coeff[0][k][:,viridxa[k]] for k in range(nkpts)]\n orbvb = [mo_coeff[1][k][:,viridxb[k]] for k in range(nkpts)]\n\n e_ia_a = _get_e_ia(mo_energy[0], mo_occ[0])\n e_ia_b = _get_e_ia(mo_energy[1], mo_occ[1])\n hdiag = numpy.hstack([x.ravel() for x in (e_ia_a + e_ia_b)])\n tot_x_a = sum(x.size for x in e_ia_a)\n tot_x_b = sum(x.size for x in e_ia_b)\n\n mem_now = lib.current_memory()[0]\n max_memory = max(2000, self.max_memory*.8-mem_now)\n vresp = _gen_uhf_response(mf, hermi=0, max_memory=max_memory)\n\n def vind(zs):\n nz = len(zs)\n zs = [_unpack(z, mo_occ) for z in zs]\n dmov = numpy.empty((2,nz,nkpts,nao,nao), dtype=numpy.complex128)\n for i in range(nz):\n dm1a, dm1b = zs[i]\n for k in range(nkpts):\n dmov[0,i,k] = reduce(numpy.dot, (orboa[k], dm1a[k], orbva[k].conj().T))\n dmov[1,i,k] = reduce(numpy.dot, (orbob[k], dm1b[k], orbvb[k].conj().T))\n\n with lib.temporary_env(mf, exxdiv=None):\n dmov = dmov.reshape(2*nz,nkpts,nao,nao)\n v1ao = vresp(dmov)\n v1ao = v1ao.reshape(2,nz,nkpts,nao,nao)\n\n v1s = []\n for i in range(nz):\n dm1a, dm1b = zs[i]\n v1as = []\n v1bs = []\n for k in range(nkpts):\n v1a = reduce(numpy.dot, (orboa[k].conj().T, v1ao[0,i,k], orbva[k]))\n v1b = reduce(numpy.dot, (orbob[k].conj().T, v1ao[1,i,k], orbvb[k]))\n v1a += e_ia_a[k] * dm1a[k]\n v1b += e_ia_b[k] * dm1b[k]\n v1as.append(v1a.ravel())\n v1bs.append(v1b.ravel())\n v1s += v1as + v1bs\n return numpy.hstack(v1s).reshape(nz,-1)\n\n return vind, hdiag\n\n def init_guess(self, mf, nstates=None):\n if nstates is None: nstates = self.nstates\n\n mo_energy = mf.mo_energy\n mo_occ = mf.mo_occ\n e_ia_a = _get_e_ia(mo_energy[0], mo_occ[0])\n e_ia_b = _get_e_ia(mo_energy[1], mo_occ[1])\n e_ia = numpy.hstack([x.ravel() for x in (e_ia_a + e_ia_b)])\n nov = e_ia.size\n nroot = min(nstates, nov)\n x0 = numpy.zeros((nroot, nov))\n idx = numpy.argsort(e_ia)\n for i in range(nroot):\n x0[i,idx[i]] = 1 # lowest excitations\n return x0\n\n def kernel(self, x0=None):\n '''TDA diagonalization solver\n '''\n self.check_sanity()\n self.dump_flags()\n\n vind, hdiag = self.gen_vind(self._scf)\n precond = self.get_precond(hdiag)\n if x0 is None:\n x0 = self.init_guess(self._scf, self.nstates)\n\n self.converged, self.e, x1 = \\\n lib.davidson1(vind, x0, precond,\n tol=self.conv_tol,\n nroots=self.nstates, lindep=self.lindep,\n max_space=self.max_space,\n verbose=self.verbose)\n\n mo_occ = self._scf.mo_occ\n tot_x_a = sum((occ>0).sum()*(occ==0).sum() for occ in mo_occ[0])\n self.xy = [(_unpack(xi, mo_occ), # (X_alpha, X_beta)\n (0, 0)) # (Y_alpha, Y_beta)\n for xi in x1]\n #TODO: analyze CIS wfn point group symmetry\n return self.e, self.xy\nCIS = KTDA = TDA\n\n\nclass TDHF(TDA):\n def gen_vind(self, mf):\n singlet = self.singlet\n cell = mf.cell\n kpts = mf.kpts\n\n mo_coeff = mf.mo_coeff\n mo_energy = mf.mo_energy\n mo_occ = mf.mo_occ\n nkpts = len(mo_occ)\n nao, nmo = mo_coeff[0][0].shape\n occidxa = [numpy.where(mo_occ[0][k]> 0)[0] for k in range(nkpts)]\n occidxb = [numpy.where(mo_occ[1][k]> 0)[0] for k in range(nkpts)]\n viridxa = [numpy.where(mo_occ[0][k]==0)[0] for k in range(nkpts)]\n viridxb = [numpy.where(mo_occ[1][k]==0)[0] for k in range(nkpts)]\n orboa = [mo_coeff[0][k][:,occidxa[k]] for k in range(nkpts)]\n orbob = [mo_coeff[1][k][:,occidxb[k]] for k in range(nkpts)]\n orbva = [mo_coeff[0][k][:,viridxa[k]] for k in range(nkpts)]\n orbvb = [mo_coeff[1][k][:,viridxb[k]] for k in range(nkpts)]\n\n e_ia_a = _get_e_ia(mo_energy[0], mo_occ[0])\n e_ia_b = _get_e_ia(mo_energy[1], mo_occ[1])\n hdiag = numpy.hstack([x.ravel() for x in (e_ia_a + e_ia_b)])\n hdiag = numpy.hstack((hdiag, hdiag))\n tot_x_a = sum(x.size for x in e_ia_a)\n tot_x_b = sum(x.size for x in e_ia_b)\n tot_x = tot_x_a + tot_x_b\n\n mem_now = lib.current_memory()[0]\n max_memory = max(2000, self.max_memory*.8-mem_now)\n vresp = _gen_uhf_response(mf, hermi=0, max_memory=max_memory)\n\n def vind(xys):\n nz = len(xys)\n x1s = [_unpack(x[:tot_x], mo_occ) for x in xys]\n y1s = [_unpack(x[tot_x:], mo_occ) for x in xys]\n dmov = numpy.empty((2,nz,nkpts,nao,nao), dtype=numpy.complex128)\n for i in range(nz):\n xa, xb = x1s[i]\n ya, yb = y1s[i]\n for k in range(nkpts):\n dmx = reduce(numpy.dot, (orboa[k], xa[k] , orbva[k].conj().T))\n dmy = reduce(numpy.dot, (orbva[k], ya[k].T, orboa[k].conj().T))\n dmov[0,i,k] = dmx + dmy # AX + BY\n dmx = reduce(numpy.dot, (orbob[k], xb[k] , orbvb[k].conj().T))\n dmy = reduce(numpy.dot, (orbvb[k], yb[k].T, orbob[k].conj().T))\n dmov[1,i,k] = dmx + dmy # AX + BY\n\n with lib.temporary_env(mf, exxdiv=None):\n dmov = dmov.reshape(2*nz,nkpts,nao,nao)\n v1ao = vresp(dmov)\n v1ao = v1ao.reshape(2,nz,nkpts,nao,nao)\n\n v1s = []\n for i in range(nz):\n xa, xb = x1s[i]\n ya, yb = y1s[i]\n v1xsa = []\n v1xsb = []\n v1ysa = []\n v1ysb = []\n for k in range(nkpts):\n v1xa = reduce(numpy.dot, (orboa[k].conj().T, v1ao[0,i,k], orbva[k]))\n v1xb = reduce(numpy.dot, (orbob[k].conj().T, v1ao[1,i,k], orbvb[k]))\n v1ya = reduce(numpy.dot, (orbva[k].conj().T, v1ao[0,i,k], orboa[k])).T\n v1yb = reduce(numpy.dot, (orbvb[k].conj().T, v1ao[1,i,k], orbob[k])).T\n v1xa+= e_ia_a[k] * xa[k]\n v1xb+= e_ia_b[k] * xb[k]\n v1ya+= e_ia_a[k] * ya[k]\n v1yb+= e_ia_b[k] * yb[k]\n v1xsa.append(v1xa.ravel())\n v1xsb.append(v1xb.ravel())\n v1ysa.append(-v1ya.ravel())\n v1ysb.append(-v1yb.ravel())\n v1s += v1xsa + v1xsb + v1ysa + v1ysb\n return numpy.hstack(v1s).reshape(nz,-1)\n\n return vind, hdiag\n\n def init_guess(self, mf, nstates=None, wfnsym=None):\n x0 = TDA.init_guess(self, mf, nstates)\n y0 = numpy.zeros_like(x0)\n return numpy.hstack((x0,y0))\n\n def kernel(self, x0=None):\n '''TDHF diagonalization with non-Hermitian eigenvalue solver\n '''\n self.check_sanity()\n self.dump_flags()\n\n vind, hdiag = self.gen_vind(self._scf)\n precond = self.get_precond(hdiag)\n if x0 is None:\n x0 = self.init_guess(self._scf, self.nstates)\n\n real_system = (gamma_point(self._scf.kpts) and\n self._scf.mo_coeff[0][0].dtype == numpy.double)\n\n # We only need positive eigenvalues\n def pickeig(w, v, nroots, envs):\n realidx = numpy.where((abs(w.imag) < REAL_EIG_THRESHOLD) &\n (w.real > POSTIVE_EIG_THRESHOLD))[0]\n return lib.linalg_helper._eigs_cmplx2real(w, v, realidx, real_system)\n\n self.converged, w, x1 = \\\n lib.davidson_nosym1(vind, x0, precond,\n tol=self.conv_tol,\n nroots=self.nstates, lindep=self.lindep,\n max_space=self.max_space, pick=pickeig,\n verbose=self.verbose)\n\n mo_occ = self._scf.mo_occ\n e = []\n xy = []\n for i, z in enumerate(x1):\n xs, ys = z.reshape(2,-1)\n norm = lib.norm(xs)**2 - lib.norm(ys)**2\n if norm > 0:\n norm = 1/numpy.sqrt(norm)\n xs *= norm\n ys *= norm\n e.append(w[i])\n xy.append((_unpack(xs, mo_occ), _unpack(ys, mo_occ)))\n self.e = numpy.array(e)\n self.xy = xy\n return self.e, self.xy\nRPA = KTDHF = TDHF\n\ndef _unpack(vo, mo_occ):\n za = []\n zb = []\n p1 = 0\n for k, occ in enumerate(mo_occ[0]):\n no = numpy.count_nonzero(occ > 0)\n nv = occ.size - no\n p0, p1 = p1, p1 + no * nv\n za.append(vo[p0:p1].reshape(no,nv))\n\n for k, occ in enumerate(mo_occ[1]):\n no = numpy.count_nonzero(occ > 0)\n nv = occ.size - no\n p0, p1 = p1, p1 + no * nv\n zb.append(vo[p0:p1].reshape(no,nv))\n return za, zb\n\n\nfrom pyscf.pbc import scf\nscf.kuhf.KUHF.TDA = lib.class_as_method(KTDA)\nscf.kuhf.KUHF.TDHF = lib.class_as_method(KTDHF)\n\n\nif __name__ == '__main__':\n from pyscf.pbc import gto\n from pyscf.pbc import scf\n from pyscf.pbc import df\n cell = gto.Cell()\n cell.unit = 'B'\n cell.atom = '''\n C 0. 0. 0. \n C 1.68506879 1.68506879 1.68506879\n '''\n cell.a = '''\n 0. 3.37013758 3.37013758\n 3.37013758 0. 3.37013758\n 3.37013758 3.37013758 0.\n '''\n\n cell.basis = 'gth-szv'\n cell.pseudo = 'gth-pade'\n cell.mesh = [37]*3\n cell.build()\n mf = scf.KUHF(cell, cell.make_kpts([2,1,1])).set(exxdiv=None)\n# mf.with_df = df.DF(cell, cell.make_kpts([2,1,1]))\n# mf.with_df.auxbasis = 'weigend'\n# mf.with_df._cderi = 'eri3d-df.h5'\n# mf.with_df.build(with_j3c=False)\n mf.run()\n\n td = TDA(mf)\n td.verbose = 5\n td.nstates = 5\n print(td.kernel()[0] * 27.2114)\n\n td = TDHF(mf)\n td.verbose = 5\n td.nstates = 5\n print(td.kernel()[0] * 27.2114)\n\n cell.spin = 2\n mf = scf.KUHF(cell, cell.make_kpts([2,1,1])).set(exxdiv=None)\n mf.run()\n\n td = TDA(mf)\n td.verbose = 5\n td.nstates = 5\n print(td.kernel()[0] * 27.2114)\n\n td = TDHF(mf)\n td.verbose = 5\n td.nstates = 5\n print(td.kernel()[0] * 27.2114)\n", "meta": {"hexsha": "0f75becdb7a844c05ab06d4c135644c3b746db4c", "size": 12832, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyscf/pbc/tdscf/kuhf.py", "max_stars_repo_name": "LeonOtis/pyscf", "max_stars_repo_head_hexsha": "98ba8106396ac4c90dc65207059773ce048b0ebf", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-08-03T12:32:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-29T08:19:02.000Z", "max_issues_repo_path": "pyscf/pbc/tdscf/kuhf.py", "max_issues_repo_name": "LeonOtis/pyscf", "max_issues_repo_head_hexsha": "98ba8106396ac4c90dc65207059773ce048b0ebf", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pyscf/pbc/tdscf/kuhf.py", "max_forks_repo_name": "LeonOtis/pyscf", "max_forks_repo_head_hexsha": "98ba8106396ac4c90dc65207059773ce048b0ebf", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-06-01T05:31:38.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-08T02:38:33.000Z", "avg_line_length": 36.4545454545, "max_line_length": 95, "alphanum_fraction": 0.5367830424, "include": true, "reason": "import numpy", "num_tokens": 4038, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6150878696277512, "lm_q2_score": 0.31742627850202554, "lm_q1q2_score": 0.19524505340767612}} {"text": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n# emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-\n# vi: set ft=python sts=4 ts=4 sw=4 et:\n# pylint: disable=no-member\n#\n# @Author: oesteban\n# @Date: 2016-02-23 19:25:39\n# @Email: code@oscaresteban.es\n# @Last Modified by: oesteban\n# @Last Modified time: 2018-03-12 11:44:09\n\"\"\"\n\nMeasures for the structural information\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\nDefinitions are given in the\n:ref:`summary of structural IQMs `.\n\n.. _iqms_efc:\n\n- **Entropy-focus criterion** (:py:func:`~mriqc.qc.anatomical.efc`).\n\n.. _iqms_fber:\n\n- **Foreground-Background energy ratio** (:py:func:`~mriqc.qc.anatomical.fber`, [Shehzad2015]_).\n\n.. _iqms_fwhm:\n\n- **Full-width half maximum smoothness** (``fwhm_*``).\n\n.. _iqms_snr:\n\n- **Signal-to-noise ratio** (:py:func:`~mriqc.qc.anatomical.snr`).\n\n.. _iqms_summary:\n\n- **Summary statistics** (:py:func:`~mriqc.qc.anatomical.summary_stats`).\n\n\nMeasures for the temporal information\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\n.. _iqms_dvars:\n\n- **DVARS** - D referring to temporal derivative of timecourses, VARS referring to\n RMS variance over voxels ([Power2012]_ ``dvars_nstd``) indexes the rate of change of\n BOLD signal across the entire brain at each frame of data. DVARS is calculated\n `with nipype `_ after motion correction:\n\n .. math ::\n\n \\\\text{DVARS}_t = \\\\sqrt{\\\\frac{1}{N}\\\\sum_i \\\\left[x_{i,t} - x_{i,t-1}\\\\right]^2}\n\n\n .. note ::\n\n Intensities are scaled to 1000 leading to the units being expressed in x10\n :math:`\\\\%\\\\Delta\\\\text{BOLD}` change.\n\n .. note ::\n\n MRIQC calculates two additional standardized values of the DVARS.\n The ``dvars_std`` metric is normalized with the standard deviation of the\n temporal difference time series. The ``dvars_vstd`` is a voxel-wise\n standardization of DVARS, where the temporal difference time series is\n normalized across time by that voxel standard deviation across time, before\n computing the RMS of the temporal difference [Nichols2013]_.\n\n.. _iqms_gcor:\n\n- **Global Correlation** (``gcor``) calculates an optimized summary of time-series\n correlation as in [Saad2013]_ using AFNI's ``@compute_gcor``:\n\n .. math ::\n\n \\\\text{GCOR} = \\\\frac{1}{N}\\\\mathbf{g}_u^T\\\\mathbf{g}_u\n\n where :math:`\\\\mathbf{g}_u` is the average of all unit-variance time series in a\n :math:`T` (\\# timepoints) :math:`\\\\times` :math:`N` (\\# voxels) matrix.\n\n.. _iqms_tsnr:\n\n- **Temporal SNR** (:abbr:`tSNR (temporal SNR)`, ``tsnr``) is a simplified\n interpretation of the tSNR definition [Kruger2001]_. We report the median value\n of the `tSNR map `_ calculated like:\n\n .. math ::\n\n \\\\text{tSNR} = \\\\frac{\\\\langle S \\\\rangle_t}{\\\\sigma_t},\n\n where :math:`\\\\langle S \\\\rangle_t` is the average BOLD signal (across time),\n and :math:`\\\\sigma_t` is the corresponding temporal standard-deviation map.\n\n\nMeasures for artifacts and other\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\n.. _iqms_fd:\n\n- **Framewise Displacement**: expresses instantaneous head-motion.\n MRIQC reports the average FD, labeled as ``fd_mean``.\n Rotational displacements are calculated as the displacement on the surface of a\n sphere of radius 50 mm [Power2012]_:\n\n .. math ::\n\n \\\\text{FD}_t = |\\\\Delta d_{x,t}| + |\\\\Delta d_{y,t}| + \\\n|\\\\Delta d_{z,t}| + |\\\\Delta \\\\alpha_t| + |\\\\Delta \\\\beta_t| + |\\\\Delta \\\\gamma_t|\n\n Along with the base framewise displacement, MRIQC reports the\n **number of timepoints above FD threshold** (``fd_num``), and the\n **percent of FDs above the FD threshold** w.r.t. the full timeseries (``fd_perc``).\n In both cases, the threshold is set at 0.20mm.\n\n.. _iqms_gsr:\n\n- **Ghost to Signal Ratio** (:py:func:`~mriqc.qc.functional.gsr`, labeled\n in the reports as ``gsr_x`` and ``gsr_y``):\n along the two possible phase-encoding axes **x**, **y**:\n\n .. math ::\n\n \\\\text{GSR} = \\\\frac{\\\\mu_G - \\\\mu_{NG}}{\\\\mu_S}\n\n .. image :: ../_static/epi-gsrmask.png\n :width: 200px\n :align: center\n\n.. _iqms_aor:\n\n- **AFNI's outlier ratio** (``aor``) - Mean fraction of outliers per fMRI volume\n as given by AFNI's ``3dToutcount``.\n\n.. _iqms_aqi:\n\n- **AFNI's quality index** (``aqi``) - Mean quality index as computed by AFNI's ``3dTqual``.\n\n.. _iqms_dummy:\n\n- **Number of *dummy* scans** (``dummy``) - A number of volumes in the begining of the\n fMRI timeseries identified as non-steady state.\n\n.. topic:: References\n\n .. [Atkinson1997] Atkinson et al., *Automatic correction of motion artifacts\n in magnetic resonance images using an entropy\n focus criterion*, IEEE Trans Med Imag 16(6):903-910, 1997.\n doi:`10.1109/42.650886 `_.\n\n .. [Friedman2008] Friedman, L et al., *Test--retest and between‐site reliability in a multicenter\n fMRI study*. Hum Brain Mapp, 29(8):958--972, 2008. doi:`10.1002/hbm.20440\n `_.\n\n .. [Giannelli2010] Giannelli et al., *Characterization of Nyquist ghost in\n EPI-fMRI acquisition sequences implemented on two clinical 1.5 T MR scanner\n systems: effect of readout bandwidth and echo spacing*. J App Clin Med Phy,\n 11(4). 2010.\n doi:`10.1120/jacmp.v11i4.3237 `_.\n\n .. [Jenkinson2002] Jenkinson et al., *Improved Optimisation for the Robust and\n Accurate Linear Registration and Motion Correction of Brain Images*.\n NeuroImage, 17(2), 825-841, 2002.\n doi:`10.1006/nimg.2002.1132 `_.\n\n .. [Kruger2001] Krüger et al., *Physiological noise in oxygenation-sensitive\n magnetic resonance imaging*, Magn. Reson. Med. 46(4):631-637, 2001.\n doi:`10.1002/mrm.1240 `_.\n\n .. [Nichols2013] Nichols, `Notes on Creating a Standardized Version of DVARS\n `_, 2013.\n\n .. [Power2012] Power et al., *Spurious but systematic correlations in\n functional connectivity MRI networks arise from subject motion*,\n NeuroImage 59(3):2142-2154,\n 2012, doi:`10.1016/j.neuroimage.2011.10.018\n `_.\n\n .. [Saad2013] Saad et al. *Correcting Brain-Wide Correlation Differences\n in Resting-State FMRI*, Brain Conn 3(4):339-352,\n 2013, doi:`10.1089/brain.2013.0156\n `_.\n\n\nmriqc.qc.functional module\n^^^^^^^^^^^^^^^^^^^^^^^^^^\n\n\"\"\"\nfrom __future__ import print_function, division, absolute_import, unicode_literals\nimport os.path as op\nimport numpy as np\n\nRAS_AXIS_ORDER = {'x': 0, 'y': 1, 'z': 2}\n\n\ndef gsr(epi_data, mask, direction=\"y\", ref_file=None, out_file=None):\n \"\"\"\n Computes the :abbr:`GSR (ghost to signal ratio)` [Giannelli2010]_. The\n procedure is as follows:\n\n #. Create a Nyquist ghost mask by circle-shifting the original mask by :math:`N/2`.\n\n #. Rotate by :math:`N/2`\n\n #. Remove the intersection with the original mask\n\n #. Generate a non-ghost background\n\n #. Calculate the :abbr:`GSR (ghost to signal ratio)`\n\n\n .. warning ::\n\n This should be used with EPI images for which the phase\n encoding direction is known.\n\n :param str epi_file: path to epi file\n :param str mask_file: path to brain mask\n :param str direction: the direction of phase encoding (x, y, all)\n :return: the computed gsr\n\n \"\"\"\n\n direction = direction.lower()\n if direction[-1] not in ['x', 'y', 'all']:\n raise Exception(\"Unknown direction {}, should be one of x, -x, y, -y, all\".format(\n direction))\n\n if direction == 'all':\n result = []\n for newdir in ['x', 'y']:\n ofile = None\n if out_file is not None:\n fname, ext = op.splitext(ofile)\n if ext == '.gz':\n fname, ext2 = op.splitext(fname)\n ext = ext2 + ext\n ofile = '{0}_{1}{2}'.format(fname, newdir, ext)\n result += [gsr(epi_data, mask, newdir,\n ref_file=ref_file, out_file=ofile)]\n return result\n\n # Roll data of mask through the appropriate axis\n axis = RAS_AXIS_ORDER[direction]\n n2_mask = np.roll(mask, mask.shape[axis] // 2, axis=axis)\n\n # Step 3: remove from n2_mask pixels inside the brain\n n2_mask = n2_mask * (1 - mask)\n\n # Step 4: non-ghost background region is labeled as 2\n n2_mask = n2_mask + 2 * (1 - n2_mask - mask)\n\n # Step 5: signal is the entire foreground image\n ghost = np.mean(epi_data[n2_mask == 1]) - np.mean(epi_data[n2_mask == 2])\n signal = np.median(epi_data[n2_mask == 0])\n return float(ghost / signal)\n", "meta": {"hexsha": "355b2e34a30dc465f40e497538ae395fcee49f69", "size": 8939, "ext": "py", "lang": "Python", "max_stars_repo_path": "mriqc/qc/functional.py", "max_stars_repo_name": "Jordan-Theriault/mriqc", "max_stars_repo_head_hexsha": "7a84b28e17c9f137bde75aa264b6f0e7e5804eed", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "mriqc/qc/functional.py", "max_issues_repo_name": "Jordan-Theriault/mriqc", "max_issues_repo_head_hexsha": "7a84b28e17c9f137bde75aa264b6f0e7e5804eed", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "mriqc/qc/functional.py", "max_forks_repo_name": "Jordan-Theriault/mriqc", "max_forks_repo_head_hexsha": "7a84b28e17c9f137bde75aa264b6f0e7e5804eed", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.3807692308, "max_line_length": 99, "alphanum_fraction": 0.6566730059, "include": true, "reason": "import numpy", "num_tokens": 2738, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6150878555160665, "lm_q2_score": 0.31742627204485063, "lm_q1q2_score": 0.1952450449565267}} {"text": "#!/usr/bin/env python\n\n'''\n Construct SoS using integrated orbits.\n'''\n\nimport numpy as np\nfrom scipy.interpolate import interp1d\nfrom scipy.optimize import brentq\n\ndef sos(orb, axis=0, direction='+'):\n\n ''' Construct SoS for integrated orbits. '''\n\n # interpolator,\n k_intp = interp1d(np.arange(orb.shape[0]), orb[:, axis], \\\n copy=True, assume_sorted=True)\n\n # find zeros,\n sign_t = 1.0 if direction == '+' else -1.0\n i_zeros = np.arange(orb.shape[0] - 1)[ \\\n (orb[1:, axis] * orb[:-1, axis] < 0.) \\\n * (np.sign(orb[1:, axis + 2]) * sign_t > 0.)]\n t_zeros = np.array([brentq(k_intp, zi, zi + 1) for zi in i_zeros])\n\n # interpolate other axes,\n w_intp = interp1d(np.arange(orb.shape[0]), orb, \\\n axis=0, copy=False, assume_sorted=True)\n\n # return surface if sectuibm\n return w_intp(t_zeros)", "meta": {"hexsha": "cd857166e2e6794f6a8ccbd36f68cb6660711e93", "size": 893, "ext": "py", "lang": "Python", "max_stars_repo_path": "freeman-cross-section/makesos.py", "max_stars_repo_name": "shiaki/valses-nobles-et-sentimentales", "max_stars_repo_head_hexsha": "f4c7ea1dc7e1bb24008a40dd9d078ccdd91eac50", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "freeman-cross-section/makesos.py", "max_issues_repo_name": "shiaki/valses-nobles-et-sentimentales", "max_issues_repo_head_hexsha": "f4c7ea1dc7e1bb24008a40dd9d078ccdd91eac50", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "freeman-cross-section/makesos.py", "max_forks_repo_name": "shiaki/valses-nobles-et-sentimentales", "max_forks_repo_head_hexsha": "f4c7ea1dc7e1bb24008a40dd9d078ccdd91eac50", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.8064516129, "max_line_length": 70, "alphanum_fraction": 0.5879059351, "include": true, "reason": "import numpy,from scipy", "num_tokens": 258, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.5774953651858118, "lm_q2_score": 0.33807712415000585, "lm_q1q2_score": 0.19523797227197665}} {"text": "#!/usr/bin/env python\n# coding=utf-8\n\n__author__ = 'Minglong Li'\n__date__ = 'Nov. 2017'\n\nimport numpy as np\nimport random\nimport math\nimport copy\nimport sys\n''' A Python program using MCTS-UC (Monte Carlo Tree Search with useful cycles) for multi-robot patrol.'''\n\nROBOT_NUM = 2;\n#MCTS scalar. Larger scalar will increase exploitation, smaller will increase exploration. \nSCALAR= math.sqrt(2.0)\nGLOBAL_ID = 0 #维护一个全局ＩＤ，每个ｎｏｄｅ有且仅有一个独立ＩＤ，包括cyclic_node.\n\n#robot_init_pose: robot_0:[1, 0]; roobt_1:[2, 2]\n#create a map, 0 represents 'free', 1 represents 'obstacle'. \nclass Map():\n def __init__(self):\n self.map = [[0, 0, 1, 0, 0],\n [0, 0, 1, 0, 0],\n [1, 0, 0, 0, 1],\n [0, 1, 0, 1, 0],\n [0, 0, 0, 0, 0]]\n self.horizontal_length = 5\n self.vertical_length = 5\n \n def obstacles_in_map(self):\n temp_obstacles = []\n for i in range(self.horizontal_length):\n for j in range(self.vertical_length):\n if(self.map[i][j] == 1):\n temp_obstacles.append([i,j])\n return temp_obstacles\n \n def random_pose_without_obstacles(self):\n obstacles = self.obstacles_in_map()\n while(True):\n temp_x = random.randint(0, self.horizontal_length-1)\n temp_y = random.randint(0, self.vertical_length-1)\n obstacle_flag = False\n for i in range(len(obstacles)):\n if(obstacles[i] == [temp_x, temp_y]):\n obstacle_flag = True\n break\n if(obstacle_flag == False):\n return [temp_x, temp_y] \n \n def change_scale(self):\n pass\n \n def add_obstacle(self):\n pass\n\nclass DynamicIntruder():\n def __init__(self):\n self.time_e = 0\n self.time_step = 0\n pass #TODO: version 0.0 of mcts_patrol, we use a stationary intruder. \n \n def update_time_step(self):\n pass\n \n def time_e(self):\n pass\n \n def time_e(self):\n pass\n \n def time_p(self):\n pass\n \n def pose(self, time):\n pass \n \nclass StationaryIntruder():\n def __init__(self):\n self.time_e = random.randint(2,10)#intruder出现的时刻，从第3个时间步开始计算，０，１时刻，ｉｎｔｒｕｄｅｒ机器人肯定不会出现。\n #从直觉上讲，time_p越大，在一定budget内，捕捉到intruder的概率越大，作者最小设置为９\n self.time_p = 9#intruder停留的时间为10个时间步。\n self.time_step = self.time_e\n self.map = Map()\n self.pose = self.map.random_pose_without_obstacles()\n \n def update_time_step(self):\n self.time_step = self.time_step + 1\n \n def update_initial_pose(self):\n self.pose = self.map.random_pose_without_obstacles()\n \n def get_time_e(self):\n return self.time_e\n \n def get_time_p(self):\n return self.time_p\n\n def get_pose(self):\n return self.pose\n\nclass Node():\n def __init__(self, actions = None, poses = None, parent = None, time_step = None, map = None, node_ID = None):\n self.visits = 1#初始化的时候就是为１的，只要ｃｈｉｌｄ被添加上，ｖｉｓｉｔｓ就是１．\n self.reward = 0.0\t\n self.children = []\n self.actions = actions\n self.poses = poses\n self.parent = parent\t\n self.time_step = time_step\n self.is_cyclic_arm = False\n self.cyclic_head_ID = None\n self.node_ID = node_ID\n \n if(time_step == None):\n time_step = 0#default parameter\n self.map = map\n if(self.map == None):\n self.map = Map()#default parameter \n \n #已经检查过的child\n def add_child(self, child):\n global GLOBAL_ID\n temp_child = copy.deepcopy(child)\n temp_child.node_ID = GLOBAL_ID\n self.children.append(temp_child) \n GLOBAL_ID += 1 \n \n #根据当前节点的actions和poses算出child_poses,　child_actions经过传参得到,再算出grand_son，检查合法性。\n def check_and_add_child_actions(self,child_actions):\n global ROBOT_NUM\n global GLOBAL_ID\n #temp_actions = []#temp_actions是个一维数组，维度是robot_num\n child_poses = []#child_poses是个二维数组,第一个维度是robot_num\n #子节点的位置是由当前节点的动作和位置决定的，子节点对应的各个机器人动作可以指定。 \n \n child_poses = NEXT_POSES(copy.deepcopy(self.actions), copy.deepcopy(self.poses))\n '''\n for(i = 0; i < ROBOT_NUM; i+=1):\n j = self.actions[i]#up, down, left, right\n if(j == 0):#up\n child_poses[i][0] = self.poses[0] \n child_poses[i][1] = self.poses[1] - 1\n if(j == 1):#down\n child_poses[i][0] = self.poses[0] \n child_poses[i][1] = self.poses[1] + 1\n if(j == 2):#left\n child_poses[i][0] = self.poses[0] - 1\n child_poses[i][1] = self.poses[1] \n if(j == 3):#right\n child_poses[i][0] = self.poses[0] + 1\n child_poses[i][1] = self.poses[1] \n ''' \n #因为self节点的上一层节点在add_child的时候，会检测碰撞，所以，当前节点的poses不会有碰撞。 \n #但是，根据child_poses和指定的child_actions加入grandson节点的poses，就会可能碰撞\n grandson_poses = []\n \n grandson_poses = NEXT_POSES(copy.deepcopy(child_actions), copy.deepcopy(child_poses))\n '''\n for(i = 0; i < ROBOT_NUM; i+=1):\n j = child_actions[i]\n if(j == 0):#up\n grandson_poses[i][0] = child.poses[0] \n grandson_poses[i][1] = child_poses[1] - 1\n if(j == 1):#down\n grandson_poses[i][0] = child_poses[0] \n grandson_poses[i][1] = child_poses[1] + 1\n if(j == 2):#left\n grandson_poses[i][0] = child_poses[0] - 1\n grandson_poses[i][1] = child_poses[1] \n if(j == 3):#right\n grandson_poses[i][0] = child_poses[0] + 1\n grandson_poses[i][1] = child_poses[1] \n '''\n #child节点的位置已经是无碰撞的了，需要用grandson的位置判断是否加入child节点。 \n bump_flag = self.check_bump(copy.deepcopy(grandson_poses)) \n if(not bump_flag):\n temp_child_actions = copy.deepcopy(child_actions)\n temp_child_poses = copy.deepcopy(child_poses)\n child = Node(actions = temp_child_actions, poses = temp_child_poses, parent = self, time_step = self.time_step + 1)\n child.node_ID = GLOBAL_ID\n self.children.append(child)\n GLOBAL_ID +=1\n\n def check_and_add_child_actions_poses(self, child_actions, child_poses):\n global GLOBAL_ID\n grandson_poses = NEXT_POSES(child_actions, child_poses)\n bump_flag = self.check_bump(grandson_poses)\n if(not bump_flag):\n temp_child_actions = copy.deepcopy(child_actions)\n temp_child_poses = copy.deepcopy(child_poses)\n child = Node(actions = temp_child_actions, poses = temp_child_poses, parent = self, time_step = self.time_step + 1)\n child.node_ID = GLOBAL_ID\n self.children.append(child)\n GLOBAL_ID += 1\n \n def check_bump(self, poses):\n global ROBOT_NUM\n #bump_flag = False#bump into obstacles, or bump into boundings\n for i in range(ROBOT_NUM):\n if(poses[i][0] == -1 or poses[i][0] == self.map.horizontal_length):#bump into left or right boundings\n #bump_flag = True\n #break\n return True\n if(poses[i][1] == -1 or poses[i][1] == self.map.vertical_length):#bump into up or down boundings\n #bump_flag = True\n #break\n return True\n else:\n obstacles = self.map.obstacles_in_map()#a list storing the coordinates of the obstacles\n for j in range(len(obstacles)):\n if poses[i] == obstacles[j]:\n #if(poses[i][0] == obstacles[j][0] and poses[i][1] == obstacles[j][1]):\n #bump_flag == True\n #break\n return True\n #break\n #return bump_flag\n return False\n \n def update(self,reward):\n self.reward+=reward\n self.visits+=1\n \n def ucb(self):\n visits_parent = self.parent.visits\n visits_child = self.visits\n w_pi = self.reward\n return w_pi + SCALAR * math.sqrt(math.log(visits_parent/visits_child))\n \n def create_cyclic_sibling_arm(self, cyclic_head_ID):\n global GLOBAL_ID\n temp_parent = self.parent\n new_node = copy.deepcopy(self)\n new_node.cyclic_head_ID = cyclic_head_ID\n new_node.is_cyclic_arm = True\n new_node.visits = 1\n new_node.node_ID = GLOBAL_ID\n temp_parent.children.append(new_node)\n GLOBAL_ID += 1\n \n def get_is_cyclic_arm(self):\n return self.is_cyclic_arm\n \n def node_equal(self, other):\n self_node_ID = self.node_ID\n other_node_ID = other.node_ID\n \n if(self_node_ID == other_node_ID):\n return True\n else:\n return False\n \n \n def is_fully_expanded(self):\n #To be verified: Version 0 of mucts_patrol, all of the nodes are fully expanded\n pass \n\n#global functions\n#UCT search\n#def SELECT(budget, root):\n#TODO:关于深度拷贝的检查，看到了这里。\ndef SELECT(root):\n #pass\n selected_node = Node()\n global_ucb = 0\n temp_ucb = 0\n temp_children = root.children #'children' is a list\n #print \"244: SELECT 1\"\n while(len(temp_children) != 0):\n #print \"246: SELECT while\"\n for i in range(len(temp_children)):\n '''\n print \"248: SELECT for\"\n print \"temp_ucb: \"\n print temp_children[i].parent.visits\n print temp_children[i].visits\n print temp_children[i].reward\n ''' \n temp_ucb = temp_children[i].ucb()\n #print temp_ucb\n if(global_ucb < temp_ucb or global_ucb == temp_ucb):\n #print \"SELECT if\"\n global_ucb = temp_ucb\n selected_node = temp_children[i]\n #如果始终找不到比当前ｕｃｂ还小的，那么temp_children应该就是不发生变化的？\n #print \"SELECT 2\" \n temp_children = selected_node.children#TODO:还是这里存在问题，一直下去肯定是一个Ｎｏｎｅ。２１点４２分。\n #len(temp_children)　等于０的时候不就跳出了吗？此时Ｓｅｌｅｃｔｅｄ应该不是０啊。\n global_ucb = 0#TODO:这里对吗？很有可能是个雷啊。\n #print \"len(temp_children):\"\n #print len(temp_children)\n return selected_node \n \ndef ITERATIVE_LOOP(temp_node, cycles, temp_actions):\n global ROBOT_NUM\n cycles -= 1\n index = ROBOT_NUM - cycles -1\n \n if(cycles==-1):\n return \n else:\n if(cycles == 0):\n for i in range(4):\n temp_actions[index] = i\n temp_node.check_and_add_child_actions(child_actions = temp_actions);\n else:\n for i in range(4):\n temp_actions[index] = i\n ITERATIVE_LOOP(temp_node, cycles, temp_actions)\n \n#fully expand the node\ndef EXPAND(node):\n global ROBOT_NUM\n temp_actions = []\n for i in range(ROBOT_NUM):\n temp_actions.append(-1) \n ITERATIVE_LOOP(node, ROBOT_NUM, temp_actions)\n i = random.randint(0, len(node.children)-1)\n return node.children[i]\n\ndef NEXT_POSES(actions, poses):\n child_poses = []\n for index in range(ROBOT_NUM):\n child_poses.append([0,0])\n #print child_poses\n #print child_poses[0][0]\n #print actions[0]\n #print poses[0]\n for i in range(ROBOT_NUM):\n j = actions[i]#up, down, left, right\n if(j == 0):#up\n child_poses[i][0] = poses[i][0] \n child_poses[i][1] = poses[i][1] + 1\n if(j == 1):#down\n child_poses[i][0] = poses[i][0] \n child_poses[i][1] = poses[i][1] - 1\n if(j == 2):#left\n child_poses[i][0] = poses[i][0] - 1\n child_poses[i][1] = poses[i][1] \n if(j == 3):#right\n child_poses[i][0] = poses[i][0] + 1\n child_poses[i][1] = poses[i][1] \n return child_poses \n\ndef ITERATIVE_LOOP_ROOT_CHILD_ACTION(root, cycles, child_poses, child_actions):\n global ROBOT_NUM\n cycles -= 1\n index = ROBOT_NUM - cycles - 1\n\n if cycles == -1:\n return \n else:\n if cycles == 0:\n for i in range(4):\n child_actions[index] = i\n #if bump, not add. if not bump, add.\n root.check_and_add_child_actions_poses(child_actions, child_poses) \n else:\n for i in range(4):\n child_actions[index] = i\n ITERATIVE_LOOP_ROOT_CHILD_ACTION(root, cycles, child_poses, child_actions)\n\n#root节点的初始化当中，action为空，poses是初始化指定的值。\ndef ITERATIVE_LOOP_ROOT_ACTION(root, cycles, root_actions):\n global ROBOT_NUM\n cycles -= 1\n index = ROBOT_NUM - cycles - 1\n count_num = 0\n #print \"cycles in ITERATIVE_LOOP_ROOT_ACTION: \"\n #print cycles\n #print \"index in ITERATIVE_LOOP_ROOT_ACTION: \"\n #print index\n if(cycles == -1):\n return\n else:\n if(cycles == 0):\n for i in range(4):\n #print \"count_num:\"\n #print count_num\n #print \"index in if part: \"\n #print index\n count_num +=1\n root_actions[index] = i\n #print \"root_actions in if part:\"\n print root_actions\n child_poses = NEXT_POSES(root_actions, root.poses)\n #print \"child_poses\"\n #print child_poses\n bump_flag = root.check_bump(child_poses)\n #print \"bump_flag\"\n #print bump_flag\n if bump_flag == True:\n pass#检查合法性，如果不合法，continue。\n elif(bump_flag == False):\n child_actions = []\n for i in range(ROBOT_NUM):\n child_actions.append(-1)\n ITERATIVE_LOOP_ROOT_CHILD_ACTION(root=root, cycles=ROBOT_NUM, child_poses=child_poses,child_actions = child_actions)\n else:\n for i in range(4):\n #print \"index in else part: \"\n #print index\n root_actions[index] = i\n #print \"root_actions in else part: \"\n #print root_actions\n ITERATIVE_LOOP_ROOT_ACTION(root, cycles, root_actions)\n\ndef EXPAND_ROOT(root):\n global ROBOT_NUM\n root_actions = []\n for i in range(ROBOT_NUM):\n root_actions.append(-1)\n ITERATIVE_LOOP_ROOT_ACTION(root, ROBOT_NUM, root_actions)\n i = random.randint(0, len(root.children)-1)\n return root.children[i]\n\n'''\n#TODO:根据loop的逻辑写两个ITERATIVE LOOP\ndef loop(cycles):\n for a0 in range(4):\n for a1 in range(4):\n for a2 in range(4):\n 　 　　　　 root_actions[0] = a0\n 　 　　　　 root_actions[1] = a1\n 　 　　　　 root_actions[2] = a2\n 　 　　　　 root_poses = [[1,1],[2,2]] 　 　　　　 \n 　 　　　　 child_poses = function(root_actions, root_poses)\n #对于root的话，CHILD_POSES在这里也要检查吗？\n 　 　　　　 \n for b0 in range(4):\n for b1 in range(4):\n for b2 in range(4): 　 　　　　 \n 　 child_actions[0] = a0\n 　 　　　　 child_actions[1] = a1\n 　 　　　　 child_actions[2] = a2 　 　　　　 \n 　 　　　　 \n 　 　　　　 　 　　　　 \n 　 　　　　 grandson_poses = function2(child_actions, child_poses);\n 　 　　　　 bump_flag = check_bump(grandson_poses)\n 　 　　　　 \n 　 　　　　 if bump_flag == False\n 　 　　　　 add_child(child_poses, child_actions)\n 　\n for a0 in range(4):\n 　root_actions[0] = a0\n for a1 in range(4):\n 　root_actions[1] = a1\n for a2 in range(4):\n root_actions[2] = a2 \n add_child(root_actions)\n \n print root_actions 　\n''' \n\ndef RANDOM_ROLLOUT_FOR_ONE_STEP(actions, poses):\n global ROBOT_NUM\n map = Map()\n current_actions = actions\n current_poses = poses\n \n next_actions = []\n next_poses = []\n \n obstacles = map.obstacles_in_map()\n \n for i in range(ROBOT_NUM):\n if(current_actions[i] == 0):#up\n next_poses.append( [current_poses[i][0], current_poses[i][1]-1] )\n if(current_actions[i] == 1):#down\n next_poses.append( [current_poses[i][0], current_poses[i][1]+1] ) \n if(current_actions[i] == 2):#left\n next_poses.append( [current_poses[i][0]-1, current_poses[i][1]] ) \n if(current_actions[i] == 3):#right\n next_poses.append( [current_poses[i][0]+1, current_poses[i][1]] ) \n \n for i in range(ROBOT_NUM):\n while(True):\n temp_poses = [0,0]\n random_action = random.randint(0, 3) \n if(random_action == 0):#up\n temp_poses[0] = next_poses[i][0]\n temp_poses[1] = next_poses[i][1] + 1\n if(random_action == 1):#down\n temp_poses[0] = next_poses[i][0]\n temp_poses[1] = next_poses[i][1] - 1 \n if(random_action == 2):#left\n temp_poses[0] = next_poses[i][0] - 1\n temp_poses[1] = next_poses[i][1] \n if(random_action == 3):#right\n temp_poses[0] = next_poses[i][0] + 1\n temp_poses[1] = next_poses[i][1]\n obstacle_flag = False\n for j in range(len(obstacles)):\n if(temp_poses == obstacles[j]):\n obstacle_flag = True\n break\n if(obstacle_flag == False):\n next_actions.append(random_action)\n break\n return next_actions, next_poses \n\ndef PERFORM_CYCLIC_ACTIONS(node, intruder):\n time_e = intruder.get_time_e()\n time_p = intruder.get_time_p()\n intruder_pose = intruder.get_pose()\n \n #status of the node to be evaluated\n temp_time_step = node.time_step\n #temp_poses = node.poses \n \n #temp_node = node.parent\n temp_node = node \n head_mark_node_ID = node.cyclic_head_ID\n #指针赋值＃TODO: TO BE REVISED>\n head_mark_node = node\n #arm_mark_node = node\n \n poses_buffer = []\n poses_buffer.append(temp_poses)\n while(not temp_node.node_equal(head_mark_node)):\n poses_buffer.append(temp_node.poses) \n temp_node = temp_node.parent\n \n index = 0 \n index_increase_flag = True\n while(True):\n win_flag = False\n for i in range(len(poses_buffer[index])):\n if poses_buffer[index][i] == intruder_pose:\n win_flag = True\n break\n if temp_time_step < time_e + time_p:\n if win_flag == True:\n return 1\n elif temp_time_step == time_e + time_p: \n if win_flag == True:\n return 1\n elif win_flag == False:\n return 0\n \n if(index_increase_flag):\n index +=1\n temp_time_step+=1\n if index == len(poses_buffer):\n index-=1\n temp_time_step-=1\n index_increase_flag = False\n elif(not index_increase_flag):\n index -= 1\n temp_time_step+=1\n if index == -1:\n index+=2\n index_increase_flag = True\n \ndef ROLLOUT(node, intruder):\n #有两个前提：\n #第一个前提是当前ｎｏｄｅ上层的ｎｏｄｅ一定不是终止节点，ｓｅｌｅｃｔ和ｒｏｌｌｏｕｔ的都不是终止节点，只有当前ｎｏｄｅ和之后的ｎｏｄｅ可能是终止节点。\n #第二个前提是当前ｎｏｄｅ是经过ｅｘｐａｎｄ选出来的唯一一个待评估节点。\n #status of the intruder\n time_e = intruder.get_time_e()\n time_p = intruder.get_time_p()\n intruder_pose = intruder.get_pose()\n #status of the node to be evaluated\n temp_time_step = node.time_step\n temp_actions = node.actions\n temp_poses = node.poses \n \n next_actions = temp_actions\n next_poses = temp_poses\n \n #print \"rollout 1\"\n \n if(node.get_is_cyclic_arm() == True):\n #print \"rollout 2\"\n return PERFORM_CYCLIC_ACTIONS(node, intruder)\n else:\n #print \"rollout 3\"\n while(True):\n #print \"rollout 4\"\n win_flag = False\n for i in range(len(next_poses)):\n if(next_poses[i] == intruder_pose):\n win_flag = True\n break\n #if the intruder completing intruding or capture the intruder\n if(temp_time_step < time_e + time_p):\n if win_flag == True:\n return 1\n elif win_flag == False:\n #侵入完成时间也没到，机器人也没找着，继续搜索,TODO:一个idea，是否把找到的时间也算在内呢？\n temp_time_step += 1\n next_actions, next_poses = RANDOM_ROLLOUT_FOR_ONE_STEP(next_actions, next_poses)\n elif(temp_time_step == time_e + time_p):#入侵完成时间到了\n if(win_flag == True):\n return 1\n elif(win_flag == False):\n return 0\n\n\ndef ONE_EQUAL_IN_LIST_DEL(list_0, list_1):\n equal_flag = False\n for i in range(len(list_0)):\n for j in range(len(list_1)):\n if(list_0[i] == list_1[j]):\n del list_0[i]\n del list_1[j]\n equal_flag = True\n return list_0, list_1 \n if(equal_flag == False):\n list_0[0] = \"none\"\n return list_0, list_1\n \n#只需要node_0和node_1当中的所有的机器人的位置都有一一相等的，不用顺序相等。 　　　\ndef STATUS_EQUAL(node_0, node_1):\n global ROBOT_NUM\n poses_0 = []\n poses_1 = []\n for i in range(ROBOT_NUM):\n poses_0.append(node_0.poses[i])\n poses_1.append(node_1.poses[i])\n #poses_0 = node_0.poses\n #poses_1 = node_1.poses\n if(len(poses_0) != len(poses_1)):\n return False\n else: \n equal_flag = False\n while(True):\n poses_0, poses_1 = ONE_EQUAL_IN_LIST_DEL(poses_0, poses_1)\n if(len(poses_0) == 0 and len(poses_1) == 0):\n return True\n if(poses_0[0] == \"none\"):\n return False\n #TODO:对应的ｉ个机器人的概念在这里没有考虑，索引号没有加进来。\n \ndef BACK_PROPAGATION(leaf_node, reward):\n leaf_node.update(reward)\n temp_node = leaf_node.parent\n\n while(True):\n if(STATUS_EQUAL(temp_node, leaf_node)):\n temp_node_ID = temp_node.node_ID\n leaf_node.create_cyclic_sibling_arm(cyclic_head_ID = temp_node_ID)#it is an arm\n temp_node.update(reward)\n temp_node = temp_node.parent\n if temp_node == None:\n break\n\ndef IS_INTRUDER_CAPTURED(node, intruder):\n temp_poses = node.poses;\n intruder_pose = intruder.pose\n win_flag = False\n for i in range(len(temp_poses)):\n if(temp_poses[i] == intruder_pose):\n win_flag = True\n break\n if win_flag:\n return True\n else:\n return False\n\n \nif __name__==\"__main__\":\n map = Map()\n intruder = StationaryIntruder()\n BUDGET = 100000;\n reward = 0.0;\n #初始的机器人的位置是(1, 0), (1, 1)\n root = Node(actions = None, poses = [[1,0],[1,1]], parent = None, time_step = 0, map = map)\n root.node_ID = -1 \n print \"Hello 1\"\n EXPAND_ROOT(root) \n \n #print len(root.children)\n print len(root.children) \n \n cycle_count = 0\n print \"Hello 2\"\n while(cycle_count < BUDGET):\n print \"Hello 3\"\n leaf_node = SELECT(root)#TODO:这里需要判断node是不是时间终止节点。\n '''\n print \"639, leaf_node.actions: \"\n print leaf_node.actions\n print \"641, leaf_node.poses: \"\n print leaf_node.poses\n ''' \n print \"Hello 4\"\n if leaf_node.time_step == intruder.time_e + intruder.time_p:\n print \"Hello 5\"\n if IS_INTRUDER_CAPTURED(leaf_node, intruder) == True:\n reward = 1\n else:\n reward = 0\n BACK_PROPAGATION(leaf_node, reward) \n elif leaf_node.time_step < intruder.time_e + intruder.time_p: \n print \"Hello 6\"\n if leaf_node.get_is_cyclic_arm():\n print \"Hello 7\"\n reward = ROLLOUT(leaf_node, intruder)\n BACK_PROPAGATION(leaf_node, reward)\n else:\n \n print \"Hello 8\"\n \n print \"664, leaf_node.actions: \"\n print leaf_node.actions\n print \"666, leaf_node.poses: \"\n print leaf_node.poses\n \n\n added_node = EXPAND(leaf_node)#TODO:测试过程中，这一步极其花费时间。？？？？？？？？\n #TODO：leaf_node是不是一定不是cyclic arm？？？？？？？？？？？\n print len(leaf_node.children)#只有12的是肯定不对的。\n print \"Hello 9\"\n reward = ROLLOUT(added_node, intruder)\n print \"Hello 10\"\n BACK_PROPAGATION(added_node, reward)\n print \"Hello 11\"\n elif leaf_node.time_step > intruder.time_e + intruder.time_p:\n print \"程序异常，异常点标号为１\" \n intruder.update_initial_pose()\n print \"cycle_count :\"\n print cycle_count\n cycle_count += 1\n \n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n", "meta": {"hexsha": "16001e766f06c7833139bf981e7f73625464bed1", "size": 25412, "ext": "py", "lang": "Python", "max_stars_repo_path": "mcts_patrol.py", "max_stars_repo_name": "liminglong/dynamic_task_plan", "max_stars_repo_head_hexsha": "6974917db7ddacc16c181ede1aeb175b634ad7ec", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2017-12-16T01:24:11.000Z", "max_stars_repo_stars_event_max_datetime": "2019-06-28T01:37:48.000Z", "max_issues_repo_path": "mcts_patrol.py", "max_issues_repo_name": "liminglong/dynamic_task_plan", "max_issues_repo_head_hexsha": "6974917db7ddacc16c181ede1aeb175b634ad7ec", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "mcts_patrol.py", "max_forks_repo_name": "liminglong/dynamic_task_plan", "max_forks_repo_head_hexsha": "6974917db7ddacc16c181ede1aeb175b634ad7ec", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-07-20T16:12:32.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-20T16:12:32.000Z", "avg_line_length": 33.6137566138, "max_line_length": 136, "alphanum_fraction": 0.5438375571, "include": true, "reason": "import numpy", "num_tokens": 7015, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5774953651858118, "lm_q2_score": 0.33807711748081287, "lm_q1q2_score": 0.19523796842054864}} {"text": "# Generate adversarial examples for EAT\n\nimport numpy as np\nimport tensorflow as tf\n\n\n\ndef gen_examples_fgs(discriminator, train_data, config):\n x = train_data[0]\n x = 2.0*x - 1.0\n\n epsilon = config['epsilon']\n d_out = discriminator(x)\n y = tf.stop_gradient(tf.argmax(d_out, 1))\n d_loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(\n logits=d_out, labels=tf.one_hot(y,10)))\n\n grad_x, = tf.gradients(d_loss, x)\n x_adv = tf.stop_gradient(x + epsilon*tf.sign(grad_x))\n x_adv = tf.clip_by_value(x_adv, -1.0, 1.0)\n\n x_adv = (x_adv+1.0)/2.0\n\n return x_adv\n\n\n# least likely class\ndef gen_examples_ll(discriminator, train_data, config):\n x = train_data[0]\n x = 2.0*x - 1.0\n epsilon = config['epsilon']\n\n d_out = discriminator(x)\n yhat = tf.stop_gradient(tf.argmin(d_out, 1))\n\n d_loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(\n logits=d_out, labels=tf.one_hot(yhat,10)))\n\n grad_x, = tf.gradients(d_loss, x)\n x_adv = tf.stop_gradient(x - epsilon*tf.sign(grad_x))\n x_adv = tf.clip_by_value(x_adv, -1.0, 1.0)\n\n x_adv = (x_adv+1.0)/2.0\n\n return x_adv\n\n\ndef gen_examples_pgd(discriminator, train_data, config):\n x0 = train_data[0]\n\n x0 = 2.0*x0 - 1.0\n y = train_data[1]\n epsilon = config['epsilon']\n class_num = config['class_num']\n pgd_iter = config['pgd_iter']\n\n step_size = epsilon*0.25\n\n # randomize\n x = x0 + tf.random_uniform(x0.shape, -epsilon, epsilon)\n for i in range(pgd_iter):\n d_out = discriminator(x)\n d_loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(\n logits=d_out, labels=tf.one_hot(y,class_num)))\n\n grad_x, = tf.gradients(d_loss, x)\n x = tf.stop_gradient(x + step_size*tf.sign(grad_x))\n x = tf.clip_by_value(x, x0 - epsilon, x0 + epsilon)\n x = tf.clip_by_value(x, -1.0, 1.0)\n\n x_adv = (x+1.0)/2.0\n\n return x_adv\n\n\n# one model def for one model filename\ndef gen_adv_examples(discriminator, ckpt_filename, train_data, test_data, config):\n\n batch_size = config['batch_size']\n x_fgs = gen_examples_fgs(discriminator, train_data, config)\n x_pgd = gen_examples_pgd(discriminator, train_data, config)\n x_ll = gen_examples_ll(discriminator, train_data, config)\n\n var_list = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='discriminator')\n saver = tf.train.Saver(var_list)\n\n global_step = tf.Variable(0, trainable=False)\n global_step_op = global_step.assign_add(1)\n\n time_diff = tf.placeholder(tf.float32)\n Wall_clock_time = tf.Variable(0., trainable=False)\n update_Wall_op = Wall_clock_time.assign_add(time_diff)\n\n\n #with sv.managed_session() as sess:\n with tf.Session() as sess:\n sess.run(tf.global_variables_initializer())\n\n coord = tf.train.Coordinator()\n threads = tf.train.start_queue_runners(sess=sess, coord=coord)\n\n saver.restore(sess, ckpt_filename)\n\n\n train_size = config['train_size']\n samples_fgs, samples_pgd, samples_ll, x, y = sess.run([x_fgs, x_pgd, x_ll, train_data[0], train_data[1]])\n\n num_steps = int(train_size/batch_size)\n my_dim = list(samples_fgs.shape)\n my_dim = [my_dim[0]*4*num_steps] + my_dim[1:]\n examples = np.zeros(my_dim)\n labels = np.zeros(4*num_steps*batch_size)\n i=0\n examples[(4*i*batch_size):((4*i+1)*batch_size),:,:,:] = samples_fgs\n examples[((4*i+1)*batch_size):((4*i+2)*batch_size),:,:,:] = samples_pgd\n examples[((4*i+2)*batch_size):((4*i+3)*batch_size),:,:,:] = samples_ll\n examples[((4*i+3)*batch_size):((4*i+4)*batch_size),:,:,:] = x\n\n labels[(4*i*batch_size):((4*i+1)*batch_size)] = y\n labels[((4*i+1)*batch_size):((4*i+2)*batch_size)] = y\n labels[((4*i+2)*batch_size):((4*i+3)*batch_size)] = y\n labels[((4*i+3)*batch_size):((4*i+4)*batch_size)] = y\n\n for i in range(1, num_steps):\n samples_fgs, samples_pgd, samples_ll, x, y = sess.run([x_fgs, x_pgd, x_ll, train_data[0], train_data[1]])\n\n examples[(4*i*batch_size):((4*i+1)*batch_size),:,:,:] = samples_fgs\n examples[((4*i+1)*batch_size):((4*i+2)*batch_size),:,:,:] = samples_pgd\n examples[((4*i+2)*batch_size):((4*i+3)*batch_size),:,:,:] = samples_ll\n examples[((4*i+3)*batch_size):((4*i+4)*batch_size),:,:,:] = x\n\n labels[(4*i*batch_size):((4*i+1)*batch_size)] = y\n labels[((4*i+1)*batch_size):((4*i+2)*batch_size)] = y\n labels[((4*i+2)*batch_size):((4*i+3)*batch_size)] = y\n labels[((4*i+3)*batch_size):((4*i+4)*batch_size)] = y\n\n\n\n # test data\n test_size = config['test_size']\n num_test_steps = int(test_size/batch_size)\n x_test, y_test = sess.run([test_data[0], test_data[1]])\n test_dim = list(x_test.shape)\n test_dim = [num_test_steps*batch_size]+test_dim[1:]\n test_examples = np.zeros(test_dim)\n test_labels = np.zeros(num_test_steps*batch_size)\n i = 0\n test_examples[(i*batch_size):((i+1)*batch_size),:,:,:] = x_test\n test_labels[(i*batch_size):((i+1)*batch_size)] = y_test\n\n for i in range(1, num_test_steps):\n x_test, y_test = sess.run([test_data[0], test_data[1]])\n test_examples[(i*batch_size):((i+1)*batch_size),:,:,:] = x_test\n test_labels[(i*batch_size):((i+1)*batch_size)] = y_test\n\n\n coord.request_stop()\n #sess.run(model.queue.close(cancel_pending_enqueues=True))\n coord.join(threads)\n\n # save numpy examples\n np.savez(config['sample_file'], examples=examples, labels=labels)\n np.savez(config['test_sample_file'], examples=test_examples, labels=test_labels)\n\n\n\n\n\n", "meta": {"hexsha": "aabcfc274bad15d68c9ea42a46324256fd0f4716", "size": 5728, "ext": "py", "lang": "Python", "max_stars_repo_path": "cifar10/adversarial_networks/gen_static_adversarial_examples.py", "max_stars_repo_name": "whxbergkamp/RobustDL_GAN", "max_stars_repo_head_hexsha": "a622faf1c7d5e803bca3091dd035c616b5736bd7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 22, "max_stars_repo_stars_event_min_datetime": "2019-02-27T12:37:39.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-19T04:08:36.000Z", "max_issues_repo_path": "cifar10/adversarial_networks/gen_static_adversarial_examples.py", "max_issues_repo_name": "whxbergkamp/RobustDL_GAN", "max_issues_repo_head_hexsha": "a622faf1c7d5e803bca3091dd035c616b5736bd7", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2019-06-28T21:51:04.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-19T08:08:50.000Z", "max_forks_repo_path": "cifar10/adversarial_networks/gen_static_adversarial_examples.py", "max_forks_repo_name": "whxbergkamp/RobustDL_GAN", "max_forks_repo_head_hexsha": "a622faf1c7d5e803bca3091dd035c616b5736bd7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2019-04-07T08:18:00.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-22T00:45:19.000Z", "avg_line_length": 33.8934911243, "max_line_length": 117, "alphanum_fraction": 0.6337290503, "include": true, "reason": "import numpy", "num_tokens": 1680, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5774953651858118, "lm_q2_score": 0.33807711081161995, "lm_q1q2_score": 0.19523796456912063}} {"text": "#!/usr/bin/env python\n# -*- coding: utf-8 -*\n\n\"\"\"\ndecomp module\n\"\"\"\n\n__author__ = 'Dr. Janus Juul Eriksen, University of Bristol, UK'\n__license__ = 'MIT'\n__version__ = '0.8'\n__maintainer__ = 'Dr. Janus Juul Eriksen'\n__email__ = 'janus.eriksen@bristol.ac.uk'\n__status__ = 'Development'\n\nimport numpy as np\nfrom pyscf import gto\nfrom typing import List, Dict, Union, Any\n\n\n# component keys\nCOMP_KEYS = ['coul', 'exch', 'kin', 'solvent', 'nuc_att_glob', 'nuc_att_loc', 'nuc_att', 'xc', 'el', 'struct']\n\nclass DecompCls(object):\n \"\"\"\n this class contains all decomp attributes\n \"\"\"\n def __init__(self, loc: str = '', pop: str = 'mulliken', \\\n part = 'atoms', ndo: bool = False, multiproc: bool = False, \\\n gauge_origin: Union[List[Any], np.ndarray] = np.zeros(3), \\\n prop: str = 'energy', write: str = '', verbose: int = 0) -> None:\n \"\"\"\n init molecule attributes\n \"\"\"\n # set system defaults\n self.loc = loc\n self.pop = pop\n self.part = part\n self.ndo = ndo\n self.multiproc = multiproc\n self.gauge_origin = gauge_origin\n self.prop = prop\n self.write = write\n self.verbose = verbose\n # set internal defaults\n self.res: Dict[str, np.ndarray] = {comp_key: None for comp_key in COMP_KEYS}\n self.charge_atom: np.ndarray = None\n self.dist: np.ndarray = None\n self.weights: np.ndarray = None\n self.centres: np.ndarray = None\n\n\ndef sanity_check(mol: gto.Mole, decomp: DecompCls) -> None:\n \"\"\"\n this function performs sanity checks of decomp attributes\n \"\"\"\n # localization procedure\n assert decomp.loc in ['', 'fb', 'pm', 'ibo-2', 'ibo-4'], \\\n 'invalid localization procedure. valid choices: none (default), `fb`, `pm`, `ibo-2`, and `ibo-4`'\n # population scheme\n assert decomp.pop in ['mulliken', 'iao'], \\\n 'invalid population scheme. valid choices: `mulliken` (default) or `iao`'\n # partitioning\n assert decomp.part in ['atoms', 'eda', 'orbitals'], \\\n 'invalid partitioning. valid choices: `atoms` (default), `eda`, or `orbitals`'\n # ndo decomposition\n assert isinstance(decomp.ndo, bool), \\\n 'invalid ndo argument. must be a bool'\n # multiprocessing\n assert isinstance(decomp.multiproc, bool), \\\n 'invalid multiprocessing argument. must be a bool'\n # gauge origin\n assert isinstance(decomp.gauge_origin, (list, np.ndarray)), \\\n 'invalid gauge origin. must be a list or numpy array of ints/floats'\n # property\n assert decomp.prop in ['energy', 'dipole'], \\\n 'invalid property. valid choices: `energy` (default) and `dipole`'\n # write\n assert isinstance(decomp.write, str), \\\n 'invalid write format argument. must be a str'\n assert decomp.write in ['', 'cube', 'numpy'], \\\n 'invalid write format. valid choices: `cube` and `numpy`'\n # verbosity\n assert isinstance(decomp.verbose, int), \\\n 'invalid verbosity. valid choices: 0 <= `verbose` (default: 0)'\n assert 0 <= decomp.verbose, \\\n 'invalid verbosity. valid choices: 0 <= `verbose` (default: 0)'\n\n\n", "meta": {"hexsha": "13a7c71e31368cfb94c2edfcadfe624a90cbc20f", "size": 3496, "ext": "py", "lang": "Python", "max_stars_repo_path": "decodense/decomp.py", "max_stars_repo_name": "luna-component/decodense", "max_stars_repo_head_hexsha": "2579b7a3b7500b32ab231ebacb35c91e87e96735", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "decodense/decomp.py", "max_issues_repo_name": "luna-component/decodense", "max_issues_repo_head_hexsha": "2579b7a3b7500b32ab231ebacb35c91e87e96735", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "decodense/decomp.py", "max_forks_repo_name": "luna-component/decodense", "max_forks_repo_head_hexsha": "2579b7a3b7500b32ab231ebacb35c91e87e96735", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.2808988764, "max_line_length": 110, "alphanum_fraction": 0.5612128146, "include": true, "reason": "import numpy", "num_tokens": 856, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5273165233795671, "lm_q2_score": 0.37022540649291935, "lm_q1q2_score": 0.19522597421863325}} {"text": "\"\"\" Tools for parsing Line List data\n\"\"\"\nfrom __future__ import print_function, absolute_import, division, unicode_literals\n\nimport numpy as np\nimport os, imp, glob, pdb, gzip, sys\nif not sys.version_info[0] > 2:\n import codecs\n open = codecs.open\n\nfrom astropy import units as u\nfrom astropy.units.quantity import Quantity\nfrom astropy.io import fits, ascii\nfrom astropy.table import Column, Table, vstack\n\nfrom ..abund import roman, ions\nfrom ..abund.elements import ELEMENTS\n\nlt_path = imp.find_module('linetools')[1]\n\n\n# TODO\n# Ingest AGN lines\n# Add Ej, Ek, Ex for emission lines (specially Balmer, Paschen and Brackett)\n\n#\ndef line_data(nrows=1):\n \"\"\" Defines the dict (and/or Table) for spectral line Data\n\n Parameters\n ----------\n nrows : int, optional\n Number of rows in Table [default = 1]\n\n Notes\n -----\n Group definition:\n * 0: None\n * 1: \"All\" ISM (intended to be all atomic lines ever observed)\n * 2: Strong ISM\n * 4: HI Lyman series\n * 8: H2\n * 16: CO\n * 32: EUV\n * 64: Galaxy Emission\n * 128: Galaxy Absorption\n * 256: AGN\n * 512: ??\n * 1024: User1 (Reserved)\n * 2048: User2 (Reserved)\n \"\"\"\n ldict = {\n 'name': ' '*20, # Name\n 'wrest': 0.*u.AA, # Rest Wavelength (Quantity)\n 'f': 0., # Oscillator strength\n 'Ej': 0./u.cm, # Energy of lower level (relative to ground state)\n 'Ek': 0./u.cm, # Energy of upper level (relative to ground state)\n 'Ex': 0./u.cm, # Excitation energy (cm^-1)\n 'A': 0./u.s, # Einstein coefficient\n 'gj': 0, # Lower statistical weight (2J+1)\n 'gk': 0, # Upper statistical weight (2J+1)\n 'gamma': 0./u.s, # Sum of A\n 'nj': 0, # Orbital level of lower state (or vibrational level)\n 'nk': 0, # Orbital level of upper state (or vibrational level)\n 'Jj': 0., # Tot ang mom (z projection) of lower state (or rotation level)\n 'Jk': 0., # Tot ang mom (z projection) of upper state (or rotation level)\n 'el': 0, # Electronic transition (2=Lyman (B-X), 3=Werner (C-X)) \n 'Z': 0, # Atomic number (for atoms)\n 'Am': 0, # Mass number (often written as \"A\"; only used for D)\n 'ion': 0, # Ionic state (1=Neutral)\n 'mol': ' '*10, # Molecular name (H2, HD, CO, C13O)\n 'Ref': ' '*50, # References\n 'group': 0 # Flag for grouping\n }\n\n # Table\n clms = []\n for key in ldict.keys():\n if type(ldict[key]) is Quantity:\n clm = Column( ([ldict[key].value]*nrows), name=key)\n clm.unit = ldict[key].unit\n else:\n clm = Column( [ldict[key]]*nrows, name=key)\n # Append\n clms.append(clm)\n\n # make it a masked Table so we can deal with Galaxy\n # emission and ISM absorption simultaneously by masking\n # out what does not make sense in one case or the other\n tbl = Table(clms, masked=True)\n # import pdb\n # pdb.set_trace()\n\n return ldict, tbl\n\n\ndef read_sets(infil=None):\n \"\"\" Read sets file\n\n Parameters\n ----------\n infil : str, optional\n Set file\n \"\"\"\n if infil is None:\n fils = glob.glob(lt_path+'/lists/sets/llist_v*')\n fils.sort()\n infil = fils[-1] # Should grab the lateset\n # Read\n print('read_sets: Using set file -- \\n {:s}'.format(infil))\n set_data = ascii.read(infil, format='fixed_width')\n\n # Return\n return set_data\n\n\ndef read_euv():\n \"\"\" read additional EUV lines\n\n Returns\n -------\n Table of EUV lines\n \"\"\"\n EUV_fil = lt_path + '/data/lines/EUV_lines.ascii'\n print('linetools.lists.parse: Reading linelist --- \\n {:s}'.format(EUV_fil))\n data = Table.read(EUV_fil, format='ascii', guess=False, comment=';',delimiter='|')\n\n # Units\n data['wrest'].unit = u.AA\n\n # Return\n return data\n\n\ndef read_H2():\n \"\"\" Simple def to read H2 data\n\n Returns\n -------\n Table of H2 lines\n\n References\n ----------\n * Abgrall et al. 1993, A&AS, 101, 323\n * Abgrall et al. 1993, A&AS, 101, 273\n\n Kindly provide by co-author E. Roueff to JC Howk to JXP\n\n \"\"\"\n H2_fil = lt_path + '/data/lines/H2_resonance.ascii'\n print('linetools.lists.parse: Reading linelist --- \\n {:s}'.format(H2_fil))\n data = Table.read(H2_fil, format='ascii', guess=False, comment=';')\n\n # Units\n data['wrest'].unit = u.AA\n data['gamma'].unit = 1./u.s\n\n # Rename some columns\n data.rename_column('Jp', 'Jj')\n data.rename_column('Jpp', 'Jk')\n data.rename_column('np', 'nj')\n data.rename_column('npp', 'nk')\n\n # Molecule column\n cmol = Column(['H2']*len(data), name='mol')\n data.add_column(cmol)\n\n # Group\n cgroup = Column(np.ones(len(data),dtype='int')*(2**3), name='group')\n data.add_column(cgroup)\n\n # Return\n return data\n\n\ndef read_CO():\n \"\"\" Simple def to read CO UV data\n\n Generated by JXP with some great effort. See GRB 080607 paper.\n\n Returns\n -------\n Table of CO lines\n \"\"\"\n CO_fil = lt_path + '/data/lines/CO_UV.ascii'\n print('linetools.lists.parse: Reading linelist --- \\n {:s}'.format(CO_fil))\n data = ascii.read(CO_fil)\n\n # Units\n\n # Rename some columns\n data.rename_column('Jp', 'Jj')\n data.rename_column('Jpp', 'Jk')\n data.rename_column('np', 'nj')\n data.rename_column('npp', 'nk')\n data.rename_column('iso', 'Am') # Isotope\n data.rename_column('wave', 'wrest') \n\n data['wrest'].unit = u.AA\n\n # Fvalues\n data['fv'] = 10.**data['fv']\n data.rename_column('fv', 'f')\n\n # Molecule column\n cmol = Column(['CO']*len(data), name='mol')\n data.add_column(cmol)\n\n # Group\n cgroup = Column(np.ones(len(data),dtype='int')*(2**4), name='group')\n data.add_column(cgroup)\n\n # Return\n return data\n\n\n\ndef read_verner94():\n \"\"\" Read Verner1994 Table\n \"\"\"\n # Read\n verner94 = lt_path + '/data/lines/verner94_tab6.fits'\n print(\n 'linetools.lists.parse: Reading linelist --- \\n {:s}'.format(\n verner94))\n tbl_6 = Table.read(verner94)\n\n # Deal with bad unit\n tbl_6['lambda'].unit = u.AA\n tbl_6 = Table(tbl_6)\n\n # My table\n ldict, data = line_data(nrows=len(tbl_6))\n\n # Fill\n data['wrest'] = tbl_6['lambda']\n data['f'] = tbl_6['Fik']\n data['gj'] = tbl_6['Gi']\n data['gk'] = tbl_6['Gk']\n data['Z'] = tbl_6['Z']\n data['ion'] = tbl_6['Z'] - tbl_6['N'] + 1\n for ii,row in enumerate(tbl_6):\n data[ii]['name'] = (\n row['Species'][0:2].strip() + row['Species'][2:].strip() + \n ' {:d}'.format(int(row['lambda'])))\n # name\n names = []\n for row in data:\n ionnm = ions.ion_name((row['Z'], row['ion']))\n names.append('{:s} {:d}'.format(ionnm, int(row['wrest'])))\n data['name'] = names\n # Finish\n data['group'] = 1\n data['Ref'] = 'Verner1994'\n data['mol'] = ''\n\n # Return\n return data\n\n\ndef read_forbidden():\n \"\"\" read galaxy emission lines (forbidden)\n\n There may be more here: https://github.com/moustakas/impro/blob/master/pro/hiiregions/im_getmatrix.pro\n\n Returns\n -------\n Table of forbidden lines\n \"\"\"\n forb_fil = lt_path + '/data/lines/galaxy_forbidden.ascii'\n print('linetools.lists.parse: Reading linelist --- \\n {:s}'.format(forb_fil))\n aux = Table.read(forb_fil, format='ascii')\n\n # My table\n ldict, data = line_data(nrows=len(aux))\n\n # load values using convention names\n data['wrest'] = aux['wave']\n data['wrest'].unit = u.AA\n data['Z'] = aux['Z']\n data['ion'] = aux['ion']\n for ii, row in enumerate(data):\n row['name'] = aux['name'][ii].replace('_', ' ')\n data['Ref'] = 'DESI_NIST_JM'\n\n # mask the galaxy data using default mask_keys\n data = mask_gal(data)\n\n # Return\n return data\n\n\ndef read_recomb():\n \"\"\" read galaxy emission lines (recombination)\n\n Returns\n -------\n Table of recombination lines\n \"\"\"\n recomb_fil = lt_path + '/data/lines/galaxy_recomb.ascii'\n print('linetools.lists.parse: Reading linelist --- \\n {:s}'.format(recomb_fil))\n aux = Table.read(recomb_fil, format='ascii')\n\n # My table\n ldict, data = line_data(nrows=len(aux))\n\n # load values using convention names\n data['wrest'] = aux['wave']\n data['wrest'].unit = u.AA\n data['Z'] = aux['Z']\n data['ion'] = aux['ion']\n for ii, row in enumerate(data):\n row['name'] = aux[ii]['name'].replace('_', ' ')\n data['Ref'] = 'DESI_NIST_JM'\n\n # mask the galaxy data using default mask_keys\n data = mask_gal(data)\n\n # Return\n return data\n\ndef read_galabs():\n \"\"\" read galaxy absorption lines\n\n Returns\n -------\n Table of recombination lines\n \"\"\"\n galabs_fil = lt_path + '/data/lines/galaxy_abs.ascii'\n print('linetools.lists.parse: Reading linelist --- \\n {:s}'.format(galabs_fil))\n aux = Table.read(galabs_fil, format='ascii')\n\n # My table\n ldict, data = line_data(nrows=len(aux))\n\n # load values using convention names\n data['wrest'] = aux['wave']\n data['wrest'].unit = u.AA\n data['Z'] = aux['Z']\n data['ion'] = aux['ion']\n for ii, row in enumerate(data):\n row['name'] = aux[ii]['name'].replace('_', ' ')\n data['Ref'] = 'JXP_DK_Unknown'\n\n # mask the galaxy data using default mask_keys\n data = mask_gal(data)\n\n # Return\n return data\n\n\ndef mask_gal(data, mask_keys=None):\n \"\"\"Masks linelist attributes for all galaxy lines\n\n Parameters\n ----------\n data : Table (masked)\n The original table to mask columns for\n mask_keys : list of strings, optional\n List of column names to be masked if given\n Otherwise it uses the default:\n\n Returns\n -------\n data_masked : Table (masked)\n The masked version of `data`\n \"\"\"\n # check input\n if not isinstance(data, (Table)):\n raise RuntimeError('The input table has to be astropy Table')\n\n if data.masked is not True:\n raise RuntimeError('The input Table has to be masked.')\n\n # set default keys to mask\n if mask_keys is None:\n mask_keys = ['A', 'el', 'nj', 'nk','group','Ek','f','mol',\n 'Ej','Am','Ex','Jj','Jk','gk','gj','gamma']\n\n for key in mask_keys:\n data[key].mask = True\n\n return data\n\n\ndef parse_verner96(orig=False, write=False):\n \"\"\"Parse tables from Verner, Verner, & Ferland (1996, Atomic Data and Nuclear Data Tables, Vol. 64, p.1)\n\n Parameters\n ----------\n orig : bool, optional\n Use original code to parse the ASCII file\n Else, read from a FITS file\n\n Returns\n -------\n data : Table\n Atomic data\n \"\"\"\n # Look for FITS\n fitsf = lt_path + '/data/lines/verner96_tab1.fits.gz'\n verner96_tab1 = glob.glob(fitsf)\n\n if (len(verner96_tab1) > 0) & (not orig):\n print('linetools.lists.parse: Reading linelist --- \\n {:s}'.format(\n verner96_tab1[0]))\n data = Table.read(verner96_tab1[0])\n else:\n # File\n verner96_tab1 = lt_path + '/data/lines/verner96_tab1.txt'\n # Read\n with open(verner96_tab1) as f:\n lines = f.readlines()\n # Grab the 'good' ones\n gdlines = [iline.strip() for iline in lines if len(iline.strip()) > 113]\n ldict, data = line_data(nrows=len(gdlines))\n # Loop\n for kk, line in enumerate(gdlines):\n # Z, ion\n data[kk]['Z'] = ELEMENTS[line[0:2].strip()].number\n data[kk]['ion'] = int(line[2:4].strip())\n # wrest\n data[kk]['wrest'] = float(line[47:56].strip())\n # name\n ionnm = ions.ion_name((data[kk]['Z'], data[kk]['ion']))\n data[kk]['name'] = '{:s} {:d}'.format(ionnm,\n int(data[kk]['wrest']))\n # Ej, Ek\n data[kk]['Ej'] = float(line[59:73].strip())\n data[kk]['Ek'] = float(line[73:89].strip())\n # gj, gk\n data[kk]['gj'] = int(line[89:92].strip())\n data[kk]['gk'] = int(line[92:95].strip())\n # Ak\n data[kk]['A'] = float(line[95:103].strip())\n # f\n data[kk]['f'] = float(line[104:112].strip())\n # Update\n data['Ref'] = 'Verner1996'\n\n # Write\n if write:\n outfil = lt_path + '/data/lines/verner96_tab1.fits'\n data.write(outfil,overwrite=True)\n print('parse_verner96: Wrote {:s}'.format(outfil))\n # Compress and delete\n print('Now compressing...')\n with open(outfil) as src:\n with gzip.open(outfil+'.gz', 'wb') as dst:\n dst.writelines(src)\n os.unlink(outfil)\n\n # Return\n return data\n\n\ndef parse_morton00(orig=False):\n \"\"\"Parse tables from Morton 2000, ApJS, 130, 403\n\n Parameters\n ----------\n orig : bool, optional\n Use original code to parse the ASCII file\n\n Returns\n -------\n data : Table\n Atomic data\n \"\"\"\n # Look for FITS\n fitsf = lt_path + '/data/lines/morton00_table2.fits.gz'\n morton00_tab2 = glob.glob(fitsf)\n\n if (len(morton00_tab2) > 0) & (not orig):\n print('linetools.lists.parse: Reading linelist --- \\n {:s}'.format(\n morton00_tab2[0]))\n data = Table.read(morton00_tab2[0])\n else:\n # File\n morton00_tab2 = lt_path + '/data/lines/morton00_table2.dat'\n # Call\n data = parse_morton03(orig=True, tab_fil=morton00_tab2)\n # Update\n data['Ref'] = 'Morton2000'\n\n # Return\n return data\n\n#\ndef parse_morton03(orig=False, tab_fil=None, HIcombine=True):\n \"\"\"Parse tables from Morton 2003, ApJS, 149, 205\n\n Parameters\n ----------\n orig : bool, optional\n Use original code to parse the ASCII file\n tab_fil : str, optional\n Filename to use. Default = /data/lines/morton03_table2.dat \n HIcombine : bool, optional\n Combine doublet for HI [True]\n\n Returns\n -------\n data : Table\n Atomic data\n \"\"\"\n # Look for FITS\n fitsf = lt_path + '/data/lines/morton03_table2.fits.gz'\n morton03_tab2 = glob.glob(fitsf)\n\n if (len(morton03_tab2) > 0) & (not orig):\n print('linetools.lists.parse: Reading linelist --- \\n {:s}'.format(\n morton03_tab2[0]))\n data = Table.read(morton03_tab2[0])\n else:\n ## Read Table 2\n if tab_fil is None:\n morton03_tab2 = lt_path + '/data/lines/morton03_table2.dat'\n else:\n morton03_tab2 = tab_fil\n print(\n 'linetools.lists.parse: Reading linelist --- \\n {:s}'.format(\n morton03_tab2))\n f = open(morton03_tab2, 'r', encoding=\"ISO-8859-1\")\n lines = f.readlines()\n f.close()\n\n ## Find Elements and Ions\n elmi = []\n elmZ = []\n elmc = []\n ioni = []\n isoi = []\n ionv = []\n for kk,line in enumerate(lines):\n #print('kk = {:d}'.format(kk))\n try: # Deals with bad Byte in Morton00\n tmp = ('Z = ' in line) & ('A =' in line) \n except UnicodeDecodeError:\n tmp = False\n if tmp:\n # Grab Z\n ipos = line.find('Z = ')\n elmZ.append(int(line[ipos+4:ipos+7]))\n ipos2 = line.find('= ')\n elmc.append(line[ipos2+2:ipos].strip())\n #xdb.set_trace()\n # Line index\n elmi.append(kk)\n\n # ISOTOPE and ION\n try: # Deals with bad Byte in Morton00\n tmp2 = ( (('I ' in line[0:13]) | ('V ' in line[0:13]))\n & (line[0:3] not in ['IOD','VAN']) & (line[0:2] != 'I ') )\n except UnicodeDecodeError:\n tmp2 = False\n if tmp2:\n # Grab ion\n ipos = line[0:10].find(' ')\n if ipos > 4:\n ipos3 = line[0:10].find('I')\n iionv = line[ipos3:ipos]\n else:\n iionv = line[ipos:6].strip()\n if (len(iionv) == 0) | (iionv == '5s') | (iionv == 'B I'):\n pdb.set_trace()\n ionv.append(iionv)\n if iionv == 'Z =':\n pdb.set_trace()\n\n # Line index\n ioni.append(kk)\n\n # Deal with Isotope\n if line[0] in ['0','1','2','3','4','5','6','7','8','9']:\n # Skip ArI !\n if 'Ar I' in line:\n pass\n else:\n isoi.append(kk)\n # Deuterium\n if line[0] == 'D':\n Dline = kk\n\n #pdb.set_trace()\n ## Initialize table\n ldict, tbl = line_data(nrows=len(lines))\n\n ## Parse lines with UV rest wavelength\n count = 0\n for kk,line in enumerate(lines):\n try:\n tmp = line[23] == '.'\n except IndexError:\n pass\n else:\n if tmp: # UV wavelength?\n # Parse\n\n # Ion/Isotope\n if kk > np.max(ioni):\n gdi = len(ioni)-1\n else:\n gdi = np.where( (kk > np.array(ioni)) & (kk < np.roll(np.array(ioni),-1)))[0]\n if len(gdi) != 1:\n pdb.set_trace()\n raise ValueError('Uh oh ion')\n else:\n gdi = gdi[0]\n if ioni[gdi] in isoi: # Isotope\n continue\n # Ion\n tbl[count]['ion'] = roman.fromRoman(ionv[gdi])\n\n # Wavelength\n tbl[count]['wrest'] = float(line[19:28]) #* u.AA\n # Z\n gdZ = np.where( (kk > np.array(elmi)) & (kk < np.roll(np.array(elmi),-1)))[0]\n if len(gdZ) != 1:\n if kk > np.max(elmi):\n gdZ = len(elmi)-1\n else:\n #xdb.set_trace()\n raise ValueError('Uh oh elm')\n else:\n gdZ = gdZ[0]\n tbl[count]['Z'] = elmZ[gdZ]\n # Name\n tbl[count]['name'] = elmc[gdZ]+ionv[gdi]+' {:d}'.format(\n int(tbl[count]['wrest']))\n # Isotope (Atomic number)\n if ioni[gdi] == Dline:\n tbl[count]['Am'] = 2\n tbl[count]['name'] = 'D'+ionv[gdi]+' {:d}'.format(\n int(tbl[count]['wrest']))\n # f\n try:\n tbl[count]['f'] = float(line[79:89])\n except ValueError:\n continue # Skip ones without f-value\n # Ej, Ek\n tbl[count]['Ej'] = float(line[29:38]) #/ u.cm\n tbl[count]['Ek'] = float(line[40:50]) #/ u.cm\n # A\n try:\n tbl[count]['A'] = float(line[59:68]) #/ u.s\n except ValueError:\n pass\n # gamma\n try:\n tbl[count]['gamma'] = float(line[69:79]) #/ u.s\n except ValueError:\n pass\n # gl, gu\n tbl[count]['gj'] = int(line[52:54])\n tbl[count]['gk'] = int(line[56:58]) \n\n # Only use combined HI lines\n if HIcombine:\n if ((tbl[count]['Z'] == 1) & (tbl[count]['ion']==1) \n & (tbl[count]['gk'] != 6)):\n #print('Skipping HI line {:g}'.format(tbl[count]['wrest']))\n continue \n # Ex\n #all_dict[count]['Ex'] = 0. # Zero out units (for Table)\n\n # Increment\n count += 1\n # Trim\n data = tbl[0:count]\n\n # Last\n data['group'] = 1\n data['Ref'] = 'Morton2003'\n data['mol'] = ''\n\n # Return\n #pdb.set_trace()\n return data\n\ndef mktab_morton03(do_this=False, outfil=None, fits=True):\n \"\"\"Used to generate a VO or FITS Table for the Morton2003 paper\n\n Only intended for builder usage (1.5Mb file; gzip FITS is 119kb)\n\n Parameters\n ----------\n do_this : bool, optional\n Set to True to actually do this. Default=False\n outfil : str, optional\n Name of output file. Defaults to a given value\n fits : bool, optional\n Generate a FITS file? Default=True\n \"\"\"\n if not do_this:\n print('mktab_morton03: It is very unlikely you want to do this')\n print('mktab_morton03: Returning...')\n return\n\n # Read Morton2003 ASCII file\n m03 = parse_morton03(orig=True)\n\n # Write\n if fits:\n if outfil is None:\n outfil = lt_path + '/data/lines/morton03_table2.fits'\n m03.write(outfil,overwrite=True)\n else:\n if outfil is None:\n outfil = lt_path + '/data/lines/morton03_table2.vot'\n m03.write(outfil, format='votable', overwrite=True)\n print('mktab_morton03: Wrote {:s}'.format(outfil))\n # Compress and delete\n print('mktab_morton03: Now compressing...')\n with open(outfil) as src:\n with gzip.open(outfil+'.gz', 'wb') as dst:\n dst.writelines(src)\n os.unlink(outfil)\n\n\ndef mktab_morton00(do_this=False, outfil=None):\n \"\"\"Used to generate a FITS Table for the Morton2000 paper\n\n Only intended for builder usage\n\n Parameters\n ----------\n do_this : bool, optional\n Set to True to actually do this. Default=False\n outfil : str, optional\n Name of output file. Defaults to a given value\n \"\"\"\n if not do_this:\n print('mktab_morton00: It is very unlikely you want to do this')\n print('mktab_morton00: Returning...')\n return\n\n # Read Morton2003\n m00 = parse_morton00(orig=True)\n\n # Write\n if outfil is None:\n outfil = lt_path + '/data/lines/morton00_table2.fits'\n m00.write(outfil, overwrite=True)\n print('mktab_morton00: Wrote {:s}'.format(outfil))\n #\n print('mktab_morton03: Now compressing...')\n with open(outfil) as src:\n with gzip.open(outfil+'.gz', 'wb') as dst:\n dst.writelines(src)\n os.unlink(outfil)\n\n\ndef grab_galaxy_linelists(do_this=False):\n \"\"\" Pulls galaxy emission line lists from DESI project\n\n Specifically, desisim\n Writes to hard-drive\n Only run if you are building\n\n Parameters\n ----------\n do_this : bool, optional\n Set to True to actually do this. Default=False\n\n \"\"\"\n if not do_this:\n print('mktab_morton00: It is very unlikely you want to do this')\n print('mktab_morton00: Returning...')\n return\n\n try:\n # For Python 3.0 and later\n from urllib.request import urlopen\n except ImportError:\n # Fall back to Python 2's urllib2\n from urllib2 import urlopen\n\n # Forbidden\n url = 'https://raw.githubusercontent.com/desihub/desisim/master/data/forbidden_lines.dat'\n f = urlopen(url)\n tab_fil = lt_path+'/data/lines/galaxy_forbidden.ascii'\n print('Writing {:s}'.format(tab_fil))\n with open(tab_fil, \"wb\") as code:\n code.write(f.read())\n\n # Recombination\n url = 'https://raw.githubusercontent.com/desihub/desisim/master/data/recombination_lines.dat'\n f = urlopen(url)\n tab_fil = lt_path+'/data/lines/galaxy_recomb.ascii'\n print('Writing {:s}'.format(tab_fil))\n with open(tab_fil, \"wb\") as code:\n code.write(f.read())\n\n\ndef update_fval(table, verbose=False):\n \"\"\"Update f-values from the literature\n\n Primarily for modifying lines in the ISM lists (e.g. Morton2003)\n\n Parameters\n ----------\n table : Table\n Data to be updated\n verbose : bool, optional\n\n Returns\n -------\n table : Table\n Updated table.\n Note: This return is required to handle the vstack, i.e.\n as opposed to modifying the input table in place.\n \"\"\"\n # Shectman et al. 1998, ApJ, 504, 921 \n # Morton2003 cites this but uses a different f-value\n imn = np.argmin(np.abs(table['wrest']-1526.707))\n table['f'][imn] = 0.127\n\n # Howk 2000 (using Weise 2002 as in Morton for FeII 1142,1143,1144)\n howk00_fil = lt_path + '/data/lines/howk00_table1.ascii'\n howk00 = ascii.read(howk00_fil, comment='#')\n\n # Dress up\n howk00['wrest'].unit = u.AA\n\n fval = []\n fsig = []\n for row in howk00:\n ipos1 = row['fval_sig'].find('(')\n ipos2 = row['fval_sig'].find(')')\n # \n fval.append(float(row['fval_sig'][0:ipos1]))\n fsig.append(float(row['fval_sig'][ipos1+1:ipos2]))\n # Add columns\n howk00.add_column(Column(np.array(fval), name='f'))\n howk00.add_column(Column(np.array(fsig), name='fsig')) # Error in last decimal\n\n # Now, finally, update\n for row in howk00:\n mt = np.where( (np.abs(table['wrest']-row['wrest']*u.AA) < 1e-3*u.AA) & \n (table['Z'] == 26) & (table['ion'] == 2))[0]\n if len(mt) == 0:\n if verbose:\n print('update_fval: Line {:g} not in your table.'.format(row['wrest']))\n elif len(mt) == 1:\n table['f'][mt[0]] = row['f']\n else:\n raise ValueError('Uh oh')\n\n ## ##\n # Lines without f-value but of interest\n\n # AsII\n mn = np.min(np.abs(table['wrest']-1355.934)) # In Morton2000\n if mn > 0.05: # Ang\n _, new_row = line_data()\n new_row['Z'] = 33\n new_row['ion'] = 2\n new_row['wrest'] = 1355.934\n new_row['name'] = 'AsII 1355'\n new_row['f'].mask = True\n # Stack\n table = vstack([table, new_row])\n\n return table\n\n\ndef update_gamma(table):\n \"\"\"Update/add-in gamma values\n\n Parameters\n ----------\n table : Table\n Data to be updated\n verbose : bool, optional\n \"\"\"\n # HI - Morton doesn't give these for the combined HI lines (sensible)\n # Nor does he give them for the lines beyond Ly-d (not sure why)\n try:\n HI = np.where((table['Z']==1) & (table['ion']==1))[0]\n except KeyError: # Molecules\n pass\n else:\n if len(HI) > 0:\n # Same kludge as in atom.dat of VPFIT for higher order lines\n table['gamma'] = table['A']\n # More accurate for stronger lines (pulled from Morton) [all in units of s^-1]\n gdict = {1215.670: 6.265E+08, 1025.7222: 1.897E+08, # From Morton\n 972.5367: 8.127E+07, 949.7430: 4.204E+07, 937.8034: 2.450E+07}\n for key in gdict.keys():\n mt = np.where( (np.abs(table['wrest']-key) < 1e-4))[0]\n if len(mt) > 0:\n table['gamma'][mt[0]] = gdict[key]\n\n\ndef update_wrest(table, verbose=True):\n \"\"\"Update wrest values (and Ej,Ek)\n\n Parameters\n ----------\n table : Table\n Data to be updated\n verbose : bool, optional\n \"\"\"\n\n '''\n # TiII line (Morton 2003 vs Weise 2001) \n # Went back to Morton 2003. If you go to Weise, you have\n # to expunge the Verner94 row\n mt = np.where( (np.abs(table['wrest']-1910.9538*u.AA) < 1e-3*u.AA))[0] \n table['wrest'][mt[0]] = 1910.938 * u.AA\n table['Ek'][mt[0]] = 52330.33 / u.cm\n '''\n#\n\n\ndef _write_ref_ISM_table():\n \"\"\" Write a reference table enabling faster I/O for ISM-related lists\n\n For developer use only.\n\n Note that after running this, you need to manually copy the table\n produced to linetools/data/lines/ISM_table.fits inside the github\n repository, and then check it in.\n \"\"\"\n from linetools.lists.linelist import LineList\n\n ism = LineList('ISM', use_ISM_table=False)\n strong = LineList('Strong', use_ISM_table=False)\n euv = LineList('EUV', use_ISM_table=False)\n hi = LineList('HI', use_ISM_table=False)\n\n # need a Table to write\n tab = ism._data.copy()\n tab.sort(('wrest'))\n\n # Using np.in1d doesn't work for some reason. Do it the long way\n cond = []\n for table in (strong, euv, hi):\n igood = []\n for row in Table(table._data):\n ind = tab['wrest'].searchsorted(row['wrest'])\n dw = abs(tab['wrest'][ind] - row['wrest'])\n if abs(tab['wrest'][ind+1] - row['wrest']) < dw:\n ind = ind + 1\n rism = tab[ind]\n # check this is the right row.\n if all(row[k] == rism[k] for k in hi._data.colnames if\n not hasattr(row[k], 'mask') or not row[k].mask):\n igood.append(ind)\n else:\n raise RuntimeError('No match found!')\n\n cond.append(np.zeros(len(tab), dtype=bool))\n cond[-1][np.array(igood)] = True\n\n col1 = Column(cond[0], name='is_Strong')\n col2 = Column(cond[1], name='is_EUV')\n col3 = Column(cond[2], name='is_HI')\n tab.add_columns([col1, col2, col3])\n\n tab.write('ISM_table.fits', overwrite=True)\n", "meta": {"hexsha": "cdc33a8fd2b7297d50724c940b1b8d2870c0ecbb", "size": 29407, "ext": "py", "lang": "Python", "max_stars_repo_path": "linetools/lists/parse.py", "max_stars_repo_name": "marijana777/linetools", "max_stars_repo_head_hexsha": "73720a2f6df42b7dde1f35055cd40ad970200f7f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "linetools/lists/parse.py", "max_issues_repo_name": "marijana777/linetools", "max_issues_repo_head_hexsha": "73720a2f6df42b7dde1f35055cd40ad970200f7f", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "linetools/lists/parse.py", "max_forks_repo_name": "marijana777/linetools", "max_forks_repo_head_hexsha": "73720a2f6df42b7dde1f35055cd40ad970200f7f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.5368639668, "max_line_length": 108, "alphanum_fraction": 0.5292277349, "include": true, "reason": "import numpy,from astropy", "num_tokens": 8122, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5273165382362518, "lm_q2_score": 0.3702253925955866, "lm_q1q2_score": 0.19522597239066197}} {"text": "# -*- coding: utf-8 -*-\n# vim: tabstop=4 shiftwidth=4 softtabstop=4\n#\n# Copyright (C) 2014-2016 GEM Foundation\n#\n# OpenQuake is free software: you can redistribute it and/or modify it\n# under the terms of the GNU Affero General Public License as published\n# by the Free Software Foundation, either version 3 of the License, or\n# (at your option) any later version.\n#\n# OpenQuake is distributed in the hope that it will be useful,\n# but WITHOUT ANY WARRANTY; without even the implied warranty of\n# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n# GNU Affero General Public License for more details.\n#\n# You should have received a copy of the GNU Affero General Public License\n# along with OpenQuake. If not, see .\n\n\"\"\"\nModule exports :class:`SomervilleEtAl2001NSHMP2008`.\n\"\"\"\nfrom __future__ import division\n\nimport numpy as np\n\nfrom openquake.hazardlib.gsim.base import CoeffsTable, GMPE\nfrom openquake.hazardlib.gsim.utils import clip_mean\nfrom openquake.hazardlib import const\nfrom openquake.hazardlib.imt import PGA, SA\n\n\nclass SomervilleEtAl2001NSHMP2008(GMPE):\n \"\"\"\n Implements GMPE developed by P. Somerville, N. Collins, N. Abrahamson,\n R. Graves, and C. Saika and documented in \"GROUND MOTION ATTENUATION\n RELATIONS FOR THE CENTRAL AND EASTERN UNITED STATES\" (Final report, June\n 30, 2001: Report to U.S. Geological Survey for award 99HQGR0098). This GMPE\n is used by the National Seismic Hazard Mapping Project (NSHMP) for the 2008\n US hazard model.\n\n Document available at:\n http://earthquake.usgs.gov/hazards/products/conterminous/2002/99HQGR0098.pdf\n\n This class replicates the algorithm for the Somerville et. al. 2001 GMPE as\n coded in the subroutine ``getSomer`` in the ``hazgridXnga2.f``\n Fortran code available at:\n http://earthquake.usgs.gov/hazards/products/conterminous/2008/software/\n\n Coefficients are given for the B/C site conditions.\n \"\"\"\n #: Supported tectonic region type is stable continental crust,\n #: given that the equations have been derived for central and eastern\n #: north America\n DEFINED_FOR_TECTONIC_REGION_TYPE = const.TRT.STABLE_CONTINENTAL\n\n #: Supported intensity measure types are spectral acceleration,\n #: and peak ground acceleration\n DEFINED_FOR_INTENSITY_MEASURE_TYPES = set([\n PGA,\n SA\n ])\n\n #: Supported intensity measure component is the geometric mean of\n #two : horizontal components\n #:attr:`~openquake.hazardlib.const.IMC.AVERAGE_HORIZONTAL`,\n DEFINED_FOR_INTENSITY_MEASURE_COMPONENT = const.IMC.AVERAGE_HORIZONTAL\n\n #: Supported standard deviation type is only total.\n DEFINED_FOR_STANDARD_DEVIATION_TYPES = set([\n const.StdDev.TOTAL\n ])\n\n #: No site parameters required\n REQUIRES_SITES_PARAMETERS = set()\n\n #: Required rupture parameter is only magnitude (Mw).\n REQUIRES_RUPTURE_PARAMETERS = set(('mag', ))\n\n #: Required distance measure is rjb\n REQUIRES_DISTANCES = set(('rjb', ))\n\n def get_mean_and_stddevs(self, sites, rup, dists, imt, stddev_types):\n \"\"\"\n See :meth:`superclass method\n <.base.GroundShakingIntensityModel.get_mean_and_stddevs>`\n for spec of input and result values.\n \"\"\"\n assert all(stddev_type in self.DEFINED_FOR_STANDARD_DEVIATION_TYPES\n for stddev_type in stddev_types)\n\n C = self.COEFFS[imt]\n\n mean = self._compute_mean(C, rup.mag, dists.rjb)\n mean = clip_mean(imt, mean)\n\n stddevs = self._compute_stddevs(C, dists.rjb.size, stddev_types)\n\n return mean, stddevs\n\n def _compute_mean(self, C, mag, rjb):\n \"\"\"\n Compute and return mean value (table 8, page 8)\n \"\"\"\n d1 = np.sqrt(50. ** 2 + 6. ** 2)\n d = np.sqrt(rjb ** 2 + 6 ** 2)\n\n mean = np.zeros_like(rjb)\n\n mean += (\n C['a1'] + C['a2'] * (mag - 6.4) +\n C['a7'] * (8.5 - mag) ** 2\n )\n\n idx = rjb < 50.\n mean[idx] += (\n C['a3'] * np.log(d[idx]) +\n C['a4'] * (mag - 6.4) * np.log(d[idx]) +\n C['a5'] * rjb[idx]\n )\n\n idx = rjb >=50.\n mean[idx] += (\n C['a3'] * np.log(d1) +\n C['a4'] * (mag - 6.4) * np.log(d[idx]) +\n C['a5'] * rjb[idx] + C['a6'] * (np.log(d[idx]) - np.log(d1))\n )\n\n return mean\n\n def _compute_stddevs(self, C, num_sites, stddev_types):\n \"\"\"\n Return total standard deviation.\n \"\"\"\n stddevs = []\n for _ in stddev_types:\n stddevs.append(np.zeros(num_sites) + C['sigma'])\n\n return stddevs\n\n #: Coefficient table obtained from coefficient arrays (a1, a2, a3, a4,\n #: a5, a6, a7, sig0) defined in subroutine getSomer in hazgridXnga2.f\n COEFFS = CoeffsTable(sa_damping=5, table=\"\"\"\\\n IMT a1 a2 a3 a4 a5 a6 a7 sigma\n pga 0.658 0.805 -0.679 0.0861 -0.00498 -0.477 0.0 0.587\n 0.1 1.442 0.805 -0.679 0.0861 -0.00498 -0.477 0.0 0.595\n 0.2 1.358 0.805 -0.679 0.0861 -0.00498 -0.477 0.0 0.611\n 0.3 1.2353 0.805 -0.67023 0.0861 -0.0048045 -0.523792 -0.030298 0.6057\n 0.5 0.8532 0.805 -0.671792 0.0861 -0.00442189 -0.605213 -0.0640237 0.6242\n 1.0 -0.0143 0.805 -0.696 0.0861 -0.00362 -0.755 -0.102 0.693\n 2.0 -0.9497 0.805 -0.728 0.0861 -0.00221 -0.946 -0.140 0.824\n \"\"\")\n", "meta": {"hexsha": "4c1afcbee269ca5bac5275484f5a9d33a94359bf", "size": 5560, "ext": "py", "lang": "Python", "max_stars_repo_path": "openquake.hazardlib/openquake/hazardlib/gsim/somerville_2001.py", "max_stars_repo_name": "rainzhop/ConvNetQuake", "max_stars_repo_head_hexsha": "a3e6de3f7992eac72f1b9883fec36b8c7fdefd48", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "openquake.hazardlib/openquake/hazardlib/gsim/somerville_2001.py", "max_issues_repo_name": "rainzhop/ConvNetQuake", "max_issues_repo_head_hexsha": "a3e6de3f7992eac72f1b9883fec36b8c7fdefd48", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "openquake.hazardlib/openquake/hazardlib/gsim/somerville_2001.py", "max_forks_repo_name": "rainzhop/ConvNetQuake", "max_forks_repo_head_hexsha": "a3e6de3f7992eac72f1b9883fec36b8c7fdefd48", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.5789473684, "max_line_length": 87, "alphanum_fraction": 0.6260791367, "include": true, "reason": "import numpy", "num_tokens": 1690, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5273165233795671, "lm_q2_score": 0.3702253925955866, "lm_q1q2_score": 0.19522596689034008}} {"text": "#!/usr/bin/python\n# author: Charlotte Bunne\n\n# imports\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport torch\nimport pickle\nimport os\nfrom time import time\nfrom torchvision import datasets, transforms\nfrom torchvision.utils import save_image\n\n# internal imports\nfrom model.utils import *\nfrom model.model_cnn import Generator, Adversary\nfrom model.model_cnn import weights_init_generator, weights_init_adversary\nfrom model.loss import gwnorm_distance, loss_total_variation, loss_procrustes\n\n# get arguments\nargs = get_args()\n\n# system preferences\nseed = np.random.randint(100)\ntorch.set_default_dtype(torch.double)\nnp.random.seed(seed)\ntorch.manual_seed(seed)\n\n# settings\nbatch_size = 256\nz_dim = 100\nlr = 0.0002\nngen = 3\nbeta = args.beta\nlam = 0.5\nniter = 10\nepsilon = 0.005\nnum_epochs = args.num_epochs\ncuda = args.cuda\nchannels = args.n_channels\nid = args.id\n\nmodel = 'gwgan_{}_eps_{}_tv_{}_procrustes_{}_ngen_{}_channels_{}_{}' \\\n .format(args.data, epsilon, lam, beta, ngen, channels, id)\nsave_fig_path = 'out_' + model\nif not os.path.exists(save_fig_path):\n os.makedirs(save_fig_path)\n\n# data import\nif args.data == 'mnist':\n dataloader = torch.utils.data.DataLoader(\n datasets.MNIST('./data/mnist', train=True, download=True,\n transform=transforms.Compose([\n transforms.Resize(32),\n transforms.ToTensor(),\n transforms.Normalize((0.5, 0.5, 0.5),\n (0.5, 0.5, 0.5))])),\n batch_size=batch_size, drop_last=True, shuffle=True)\nelif args.data == 'fmnist':\n dataloader = torch.utils.data.DataLoader(\n datasets.FashionMNIST('./data/fmnist', train=True, download=True,\n transform=transforms.Compose([\n transforms.Resize(32),\n transforms.ToTensor(),\n transforms.Normalize((0.5, 0.5, 0.5),\n (0.5, 0.5, 0.5))])),\n batch_size=batch_size, drop_last=True, shuffle=True)\nelif args.data == 'cifar_gray':\n dataloader = torch.utils.data.DataLoader(\n datasets.CIFAR10('./data/cifar10', train=True, download=True,\n transform=transforms.Compose([\n # transform RGB to grayscale\n transforms.Grayscale(num_output_channels=1),\n transforms.ToTensor(),\n transforms.Normalize((0.5, 0.5, 0.5),\n (0.5, 0.5, 0.5))])),\n batch_size=batch_size, drop_last=True, shuffle=True)\nelif args.data == 'cifar':\n dataloader = torch.utils.data.DataLoader(\n datasets.CIFAR10('./data/cifar10', train=True, download=True,\n transform=transforms.Compose([\n transforms.ToTensor(),\n transforms.Normalize((0.5, 0.5, 0.5),\n (0.5, 0.5, 0.5))])),\n batch_size=batch_size, drop_last=True, shuffle=True)\nelse:\n raise NotImplementedError('dataset does not exist or not integrated.')\n\n# print example images\nsave_image(next(iter(dataloader))[0][:25],\n os.path.join(save_fig_path, 'real.pdf'), nrow=5, normalize=True)\n\n# define networks and parameters\ngenerator = Generator(output_dim=channels)\nadversary = Adversary(input_dim=channels)\n\n# weight initialisation\ngenerator.apply(weights_init_generator)\nadversary.apply(weights_init_adversary)\n\nif cuda:\n generator = generator.cuda()\n adversary = adversary.cuda()\n\n# create optimizer\ng_optimizer = torch.optim.Adam(generator.parameters(), lr, betas=(0.5, 0.99))\n# zero gradients\ngenerator.zero_grad()\n\nc_optimizer = torch.optim.Adam(adversary.parameters(), lr, betas=(0.5, 0.99))\n# zero gradients\nadversary.zero_grad()\n\n# sample for plotting\nnum_test_samples = batch_size\nz_ex = torch.randn(num_test_samples, z_dim)\nif cuda:\n z_ex = z_ex.cuda()\n\nloss_history = list()\nloss_tv = list()\nloss_orth = list()\nloss_og = 0\nis_hist = list()\n\nfor epoch in range(num_epochs):\n t0 = time()\n\n for it, (image, _) in enumerate(dataloader):\n train_c = ((it + 1) % (ngen + 1) == 0)\n\n x = image.double()\n if cuda:\n x = x.cuda()\n\n # sample random number z from Z\n z = torch.randn(image.shape[0], z_dim)\n\n if cuda:\n z = z.cuda()\n\n if train_c:\n for q in generator.parameters():\n q.requires_grad = False\n for p in adversary.parameters():\n p.requires_grad = True\n else:\n for q in generator.parameters():\n q.requires_grad = True\n for p in adversary.parameters():\n p.requires_grad = False\n\n # result generator\n g = generator.forward(z)\n\n # result adversary\n f_x = adversary.forward(x)\n f_g = adversary.forward(g)\n\n # compute inner distances\n D_g = get_inner_distances(f_g, metric='euclidean', concat=False)\n D_x = get_inner_distances(f_x, metric='euclidean', concat=False)\n\n # distance matrix normalisation\n D_x_norm = normalise_matrices(D_x)\n D_g_norm = normalise_matrices(D_g)\n\n # compute normalized gromov-wasserstein distance\n loss, T = gwnorm_distance((D_x, D_x_norm), (D_g, D_g_norm),\n epsilon, niter, loss_fun='square_loss',\n coupling=True, cuda=cuda)\n\n if train_c:\n # train adversary\n loss_og = loss_procrustes(f_x, x.view(x.shape[0], -1), cuda)\n loss_to = -loss + beta * loss_og\n loss_to.backward()\n\n # parameter updates\n c_optimizer.step()\n # zero gradients\n reset_grad(generator, adversary)\n\n else:\n # train generator\n loss_t = loss_total_variation(g)\n loss_to = loss + lam * loss_t\n loss_to.backward()\n\n # parameter updates\n g_optimizer.step()\n # zero gradients\n reset_grad(generator, adversary)\n\n # plotting\n # get generator example\n g_ex = generator.forward(z_ex)\n g_plot = g_ex.cpu().detach()\n\n # plot result\n save_image(g_plot.data[:25],\n os.path.join(save_fig_path, 'g_%d.pdf' % epoch),\n nrow=5, normalize=True)\n\n fig1, ax = plt.subplots(1, 3, figsize=(15, 5))\n ax0 = ax[0].imshow(T.cpu().detach().numpy(), cmap='RdBu_r')\n colorbar(ax0)\n ax1 = ax[1].imshow(D_x.cpu().detach().numpy(), cmap='Blues')\n colorbar(ax1)\n ax2 = ax[2].imshow(D_g.cpu().detach().numpy(), cmap='Blues')\n colorbar(ax2)\n ax[0].set_title(r'$T$')\n ax[1].set_title(r'inner distances of $D$')\n ax[2].set_title(r'inner distances of $G$')\n plt.tight_layout(h_pad=1)\n fig1.savefig(os.path.join(save_fig_path, '{}_ccc.pdf'.format(\n str(epoch).zfill(3))), bbox_inches='tight')\n\n loss_history.append(loss)\n loss_tv.append(loss_t)\n loss_orth.append(loss_og)\n plt.close('all')\n\n# plot loss history\nfig2 = plt.figure(figsize=(2.4, 2))\nax2 = fig2.add_subplot(111)\nax2.plot(loss_history, 'k.')\nax2.set_xlabel('Iterations')\nax2.set_ylabel(r'$\\overline{GW}_\\epsilon$ Loss')\nplt.tight_layout()\nplt.grid()\nfig2.savefig(save_fig_path + '/loss_history.pdf')\n\nfig3 = plt.figure(figsize=(2.4, 2))\nax3 = fig3.add_subplot(111)\nax3.plot(loss_tv, 'k.')\nax3.set_xlabel('Iterations')\nax3.set_ylabel(r'Total Variation Loss')\nplt.tight_layout()\nplt.grid()\nfig3.savefig(save_fig_path + '/loss_tv.pdf')\n\nfig4 = plt.figure(figsize=(2.4, 2))\nax4 = fig4.add_subplot(111)\nax4.plot(loss_orth, 'k.')\nax4.set_xlabel('Iterations')\nax4.set_ylabel(r'$R_\\beta(f_\\omega(X), X)$ Loss')\nplt.tight_layout()\nplt.grid()\nfig4.savefig(save_fig_path + '/loss_orth.pdf')\n", "meta": {"hexsha": "5cc152ef573bd28ab06e559d5ab0388cd90bb744", "size": 7956, "ext": "py", "lang": "Python", "max_stars_repo_path": "main_gwgan_cnn.py", "max_stars_repo_name": "bunnech/gw_gan", "max_stars_repo_head_hexsha": "fc8d7a2232c92282037ac829bfbdabc5b9ad820e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 23, "max_stars_repo_stars_event_min_datetime": "2019-05-14T14:14:10.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-30T03:21:49.000Z", "max_issues_repo_path": "main_gwgan_cnn.py", "max_issues_repo_name": "bunnech/gw_gan", "max_issues_repo_head_hexsha": "fc8d7a2232c92282037ac829bfbdabc5b9ad820e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2019-07-12T01:14:30.000Z", "max_issues_repo_issues_event_max_datetime": "2020-09-23T14:20:42.000Z", "max_forks_repo_path": "main_gwgan_cnn.py", "max_forks_repo_name": "bunnech/gw_gan", "max_forks_repo_head_hexsha": "fc8d7a2232c92282037ac829bfbdabc5b9ad820e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2019-05-14T08:23:55.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-26T01:33:34.000Z", "avg_line_length": 31.6972111554, "max_line_length": 77, "alphanum_fraction": 0.6047008547, "include": true, "reason": "import numpy", "num_tokens": 1925, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5273165085228825, "lm_q2_score": 0.3702253786982541, "lm_q1q2_score": 0.1952259540617253}} {"text": "#!/usr/bin/env python\n\n#nknguyen at soe ucsc edu\n#Feb 07 2012\n#TCR repertoire simulation\n\n'''\nSimulate CDR3 TCR repertoires to assess the overlapping of clones/sequences between two independent samplings of certain size.\n(Purpose: use to determine what is the sufficient sampling size to get all the important, clonally expanded CDR3)\n\nThere are 4 main steps involved:\n1/ Generate a set of m unique CDR3 nucleotide sequences, call this set R (it is estimated that each individual has about 3x10^6 uniq seqs)\n This steps take into account the CDR3-length distribution and the Amino-acid usage at each position of the CDR3.\n Input: a/ len2count.txt with format: \\t\n b/ aaUsage.txt with format: \\t\\t\\t\n c/ m = size of the repertoire to be created\n Generate: m nucleotide sequences such that when translated to amino acid sequences, follows the input length distribution and aaUsage.\n\n2/ Generate the repertoire (say P) of CDR3 of an individual from set R in (1):\n Let M be the number of cells (number of total sequences) an individual has. It is estimated that there are about 6x10^7 CD8+ T cells per individual.\n Populate repertoire P with the n sequences in R until P has M sequences. This step can assume a lognormal (previously used uniform) distribution of the uniq sequences or model clonal expansion.\n The program model clonal expansion by in input pseudo repertoire with format ,,...,. A random sequence will be drawn from n sequences in (a), and will populate P with topFreq*M counts. Then a second random seq will be drawn, etc until there are M sequences or the frequency list is done. If freq list is done and there are < M sequences in P, just randomly fill in P with the rest of the m sequences\n Generate: M CDR3 nucleotide sequences\n\n3/ Sampling:\n Repeat step (1) and (2) to generate another TCR repertoire for the second individual.\n For each individual, randomly choose S sequences from the corresponding repertoire.\n Calculate how much overlap the two samplings have.\n Repeat this step with difference sampling size\n\n4/ a. Repeat step (3) -numSamplingPerSim times. Calculate mean & std\n(Or/And)\n b. Repeat steps (1,2,3) N times (N simulations). Calculate mean statistics\n\n(5/ Plots)\n'''\n\nimport os, sys, re, time, random, copy, gzip\nimport cPickle as pickle\nfrom optparse import OptionParser\nimport xml.etree.ElementTree as ET\n\nfrom jobTree.scriptTree.target import Target\nfrom jobTree.scriptTree.stack import Stack\n\nfrom sonLib.bioio import logger\nfrom sonLib.bioio import system\nfrom sonLib.bioio import getTempDirectory\nfrom sonLib.bioio import setLogLevel\nimport numpy as np\nfrom scipy.stats import poisson, lognorm\n\n#from immunoseq.lib import *\n\n################## SEQUENCE OBJECTS ######################\nclass Seq:\n def __init__(self, nuc, aa):\n self.nuc = nuc\n self.aa = aa\n self.count = 0\n\n def __cmp__(self, other):\n return cmp(self.nuc, other.nuc)\n\n def setCount(self, count):\n self.count = count\n\n def updateCount(self, add):\n self.count += add\n\nclass Aaseq:\n def __init__(self, aa):\n self.aa = aa\n self.count = 0\n\n def __cmp__(self, other):\n return cmp(self.aa, other.aa)\n\n def setCount(self, count):\n self.count = count\n\n def updateCount(self, add):\n self.count += add\n\n def setFreq(self, total):\n if total == 0:\n self.freq = 0\n else:\n self.freq = 100.0*self.count/total\n\nclass Seqs(list):\n def add(self, seq):\n leftIndex = 0\n rightIndex = len(self) -1\n \n if len(self) == 0 or seq > self[rightIndex]:\n self.append(seq)\n elif seq < self[leftIndex]:\n self.insert(0, seq)\n elif seq == self[leftIndex] or seq == self[rightIndex]:\n return\n else:\n while True:\n middleIndex = int( (leftIndex + rightIndex)/2 )\n compare = cmp( self[middleIndex], seq )\n if compare == 0: #sequence is already in the list, do not add, just return\n break\n elif leftIndex == middleIndex: #add seq to the right of leftIndex\n self.insert(rightIndex, seq)\n break\n elif compare > 0: #seq lies somewhere btw [middleIndex, rightIndex]\n rightIndex = middleIndex\n elif compare < 0: \n leftIndex = middleIndex\n \n def search(self, seq):\n leftIndex = 0\n rightIndex = len(self) -1\n \n if len(self) == 0 or seq > self[rightIndex] or seq < self[leftIndex]: #not in list\n return -1\n elif seq == self[leftIndex]:\n return leftIndex\n elif seq == self[rightIndex]:\n return rightIndex\n else:\n while True:\n middleIndex = int( (leftIndex + rightIndex)/2 )\n compare = cmp( self[middleIndex], seq )\n if compare == 0: #sequence is already in the list, do not add, just return\n return middleIndex\n elif leftIndex == middleIndex: #Not found\n return -1\n elif compare > 0: #seq lies somewhere btw [middleIndex, rightIndex]\n rightIndex = middleIndex\n elif compare < 0: \n leftIndex = middleIndex\n\n######################### MAIN PIPELINE ################################\n\n#============= SETTING UP SIMULATIONS ==============\nclass Setup( Target ):\n \"\"\"Setting up simulations\n \"\"\"\n def __init__(self, options, doneSims):\n Target.__init__(self, time = 0.00025)\n self.options = options\n self.doneSims = doneSims\n\n def run(self):\n setLogLevel(\"DEBUG\")\n numSim = self.options.numSim\n maxSimPerRun = self.options.maxSimPerRun\n sims = min( [maxSimPerRun, numSim - self.doneSims] )\n \n outdir = os.path.join( self.options.outdir, \"sims\", str(self.doneSims) ) #outdir/sims/batchId\n system(\"mkdir -p %s\" %outdir)\n self.addChildTarget( SimulationBatch(self.options, outdir, sims, self.doneSims) )\n \n doneSims = self.doneSims + sims\n if doneSims < numSim:\n self.setFollowOnTarget( Setup(self.options, doneSims) ) #recusion call for next batch of simulations\n else:\n summarydir = os.path.join(self.options.outdir, \"summary\") #outdir/summary\n statsdir = os.path.join(self.options.outdir, \"stats\") #outdir/stats\n system(\"mkdir -p %s\" % statsdir)\n readPickle = True\n writePickle = False\n writeSummary = True\n self.setFollowOnTarget( Summary(summarydir, self.options.samSize, self.options.numSamples, statsdir, writePickle, writeSummary, readPickle) )\n\nclass SimulationBatch( Target ):\n def __init__(self, options, outdir, numSim, batchid):\n Target.__init__(self, time=0.00025)\n self.options = options\n self.outdir = outdir #outdir/sims/batchId\n self.numSim = numSim\n self.batchid = batchid\n\n def run(self):\n for i in xrange(self.numSim):\n outdir = os.path.join(self.outdir, \"sim-%d\" %i) #outdir/sims/batchId/sim-Id\n system(\"mkdir -p %s\" %outdir)\n self.addChildTarget( Simulation(self.options, outdir, self.batchid, i) )\n \n #Combine the results\n samplingsDir = os.path.join(self.options.outdir, \"samplings\", str(self.batchid)) #outdir/samplings/batchid\n sumdir = os.path.join(self.options.outdir, \"summary\", str(self.batchid)) #outdir/summary/batchid\n system(\"mkdir -p %s\" %sumdir) \n readPickle = False\n writePickle = True\n writeSummary = False\n #self.setFollowOnTarget( Summary(self.outdir, self.options.samSize, self.options.numSamples, sumdir, writePickle, writeSummary, readPickle) )\n self.setFollowOnTarget( Summary(samplingsDir, self.options.samSize, self.options.numSamples, sumdir, writePickle, writeSummary, readPickle) )\n\n#------------- SIMULATION ---------------------\nclass Simulation( Target ):\n \"\"\"Generate s simulations (corresponding to s samples (s individuals))\n Creating TCR repertoire for each individuals\n After got repertoires for All individuals, call following job to sampling from these repertoires\n \"\"\"\n def __init__(self, options, outdir, batchid, simid):\n Target.__init__(self, time=0.00025)\n self.options = options\n self.outdir = outdir #outdir/sims/batchId/sim-Id\n self.batchid = batchid\n self.simid = simid\n \n def run(self):\n globalTempDir = self.getGlobalTempDir()\n for i in xrange(self.options.numSamples):\n outdir = os.path.join(globalTempDir, str(i))\n system(\"mkdir -p %s\" %outdir) #simTempDir/sampleID/\n self.addChildTarget( SimulationSingle(self.options, outdir) )\n \n #Sampling from these repertoire:\n samplingsOutdir = os.path.join(self.options.outdir, \"samplings\", str(self.batchid), \"sim-%d\" %self.simid)\n system(\"mkdir -p %s\" %samplingsOutdir) #outdir/samplings/batchId/sim-id\n self.setFollowOnTarget( Samplings(globalTempDir, self.outdir, self.options.numSamples, self.options.samSize, self.options.cutoffs, self.options.numSamplingPerSim, samplingsOutdir) )\n #Calculate pair-wise overlap between the samples \n #self.setFollowOnTarget( Overlap(globalTempDir, self.outdir, self.options.numSamples, self.options.samSize, self.options.cutoffs) )\n\nclass SimulationSingle( Target ):\n \"\"\"Generate repertoire for one sample/individual\n Starts by generating the uniq sequences of certain CDR3 length\n Then calls follow on jobs to use these sequences to create the repertoire\n \"\"\"\n def __init__(self, options, outdir):\n Target.__init__(self, time = 0.00025)\n self.outdir = outdir #simTempDir/sampleID\n self.options = options\n\n def run(self):\n globalTempDir = self.getGlobalTempDir()\n #Generate repertoire of uniq sequences for each length:\n for l in self.options.len2freq:#each length\n size = self.options.totalClones*self.options.len2freq[l]\n if l not in self.options.len2aaUsage or size == 0:\n continue\n aaUsage = self.options.len2aaUsage[l]\n aa2codons = self.options.aa2codons\n self.addChildTarget( UniqSeqs(globalTempDir, size, aaUsage, aa2codons) )\n \n self.setFollowOnTarget( Repertoire(globalTempDir, self.outdir, self.options.totalSeqs, self.options.topFreqs, self.options.samSize) )\n\n#+++++++++++ REPERTOIRE OF UNIQ SEQS/ CLONES ++++++++++++++\nclass UniqSeqs( Target ):\n \"\"\"Generate repertoire of uniq sequences of a certain length\n \"\"\"\n def __init__(self, outdir, size, aaUsage, aa2codons):\n Target.__init__(self)\n self.outdir = outdir\n self.size = size\n self.aaUsage = aaUsage\n self.aa2codons = aa2codons\n \n def run(self):\n #Generate the sequences\n seqs = getUniqSeqRep(self.size, self.aaUsage, self.aa2codons)\n #Pickling the sequences to outdir\n pickleFile = os.path.join( self.outdir, \"uSeqs-l%d.pickle\" %len(self.aaUsage) )\n pickle.dump(seqs, gzip.open(pickleFile, \"wb\"))\n\n#+++++++++++++ PSEUDO REPERTOIRE ++++++++++++++++++\nclass Repertoire( Target ):\n \"\"\"Combine the len-specific uniqSeqs repertoires\n From uniqSeq repertoire, generate a pseudo repertoire, using topFreqs if available\n Add jobs to run samplings with different sizes\n \"\"\"\n def __init__(self, indir, outdir, size, topFreqs, samSizes):\n Target.__init__(self)\n self.indir = indir #simSampleTempDir\n self.outdir = outdir #simTempDir/sampleID\n self.size = size\n self.topFreqs = topFreqs\n self.samSizes = samSizes\n\n def run(self):\n #Load pickles to get uniqSeqs\n pickleFiles = os.listdir( self.indir )\n seqs = []\n for file in pickleFiles:\n if re.search(\"pickle\", file):\n seqs.extend( pickle.load( gzip.open( os.path.join(self.indir, file) , \"rb\") ) )\n system( \"rm -f %s\" %(os.path.join(self.indir, file)) ) #Remove the uniq-sequences pickle file of the specific length after done loading\n\n getRep( seqs, self.size, self.topFreqs )\n \n #Print repertoire to server so that it can be read by following jobs:\n pickleFile = os.path.join(self.outdir, \"rep.pickle\") #simTempDir/sampleID/rep.pickle\n pickle.dump( seqs, gzip.open(pickleFile, \"wb\") )\n\n#++++++++++++++ SAMPLING from pseudoRepertoire ++++++++++++++++\nclass Samplings( Target ):\n \"\"\"(For each repertoier simulation,) Set up samplings for all pairs, all sampling sizes, all number of samplings.\n \"\"\"\n def __init__(self, indir, outdir, numSamples, samSizes, cutoffs, numSamplings, samplingsOutdir):\n Target.__init__(self, time=0.00025)\n self.indir = indir #simTempDir\n self.outdir = outdir #outdir/sims/batchId/sim-Id\n self.numSamples = numSamples\n self.samSizes = samSizes\n self.cutoffs = cutoffs\n self.numSamplings = numSamplings\n self.samplingsOutdir = samplingsOutdir #outdir/samplings/batchId/sim-id\n\n def run(self):\n for i in xrange(self.numSamplings):#Each sampling\n for samsize in self.samSizes: #Each sampling size\n outdir = os.path.join(self.outdir, \"sampling-%d\" %i) #outdir/sims/batchId/sim-Id/sampling-Id\n for j in xrange(self.numSamples - 1):\n for k in xrange(self.numSamples): #Each pair\n pair = [j, k]\n self.addChildTarget( SamplingPair(self.indir, outdir, samsize, pair, self.cutoffs) )\n #Summary the overlapping stats:\n readPickle = False\n writePickle = False\n writeSummary = True\n self.setFollowOnTarget( Summary(self.outdir, self.samSizes, self.numSamples, self.samplingsOutdir, writePickle, writeSummary, readPickle) )\n\nclass SamplingPair( Target ):\n \"\"\"\n \"\"\"\n def __init__(self, indir, outdir, size, pair, cutoffs):\n Target.__init__(self, time=0.00025)\n self.indir = indir #simTempDir (which has simTempDir/sampleId/rep.pickle)\n self.outdir = outdir #outdir/sims/batchId/sim-Id/sampling-Id\n self.size = size\n self.pair = pair\n self.cutoffs = cutoffs\n\n def run(self):\n globalTempDir = self.getGlobalTempDir()\n seqfiles = []\n for i, p in enumerate(self.pair):\n repertoireFile = os.path.join(self.indir, str(p), \"rep.pickle\") #simTempDir/sampleId/rep.pickle\n outfile = os.path.join(globalTempDir, \"%d.pickle\" %i) #samplingPairTempDir/sampleId.pickle\n seqfiles.append(outfile)\n self.addChildTarget( Sampling(outfile, repertoireFile, self.size) )\n \n overlapOutdir = os.path.join( self.outdir, \"%d-%d\" %(self.pair[0], self.pair[1]) ) #outdir/sims/batchId/sim-Id/sampling-Id/sam1-sam2\n system(\"mkdir -p %s\" %overlapOutdir)\n overlapOutfile = os.path.join( overlapOutdir, \"%d.txt\" %self.size )\n self.setFollowOnTarget( OverlapPairwise(seqfiles, overlapOutfile, self.cutoffs) )\n\nclass Sampling( Target ):\n \"\"\"Sample from the input repertoire for \"size\" sequences\n \"\"\"\n def __init__(self, outfile, repertoireFile, samsize):\n Target.__init__(self)\n self.outfile = outfile\n self.repfile = repertoireFile\n self.size = samsize\n\n def run(self):\n seqs = pickle.load( gzip.open(self.repfile, \"rb\") ) \n samseqs = sampling(seqs, self.size)\n\n #Pickling seqs:\n pickle.dump( samseqs, gzip.open(self.outfile, \"wb\") )\n\n#----------- OVERLAP -----------\nclass OverlapPairwise( Target ):\n \"\"\"Output file: %cutoff\\tclones1\\tclones2\\toverlap\\t%1overlap2\\t%2overlap1\\t%reads1overlap2\\t%reads2overlap1\n \"\"\"\n def __init__(self, seqsFiles, outfile, cutoffs):\n Target.__init__(self, time=0.001)\n self.outfile = outfile\n self.seqsFile1 = seqsFiles[0]\n self.seqsFile2 = seqsFiles[1]\n self.cutoffs = cutoffs\n\n def run(self):\n seqs1 = pickle.load( gzip.open(self.seqsFile1, \"rb\") )\n seqs2 = pickle.load( gzip.open(self.seqsFile2, \"rb\") )\n reads1, reads2, clones1, clones2, stats1, stats2 = getOverlap(seqs1, seqs2, self.cutoffs)\n \n #Print stats\n f = open(self.outfile, \"w\")\n f.write(\"#%Cutoff\\tClones1\\tClones2\\tOverlap1\\tOverlap2\\t%1overlap2\\t%2overlap1\\t%reads1overlap2\\t%reads2overlap1\\n\")\n for i,c in enumerate(self.cutoffs):\n oc1 = stats1[\"oclones\"][i]\n or1 = stats1[\"oreads\"][i]\n t1 = clones1[i]\n r1 = reads1[i]\n \n oc2 = stats2[\"oclones\"][i]\n or2 = stats2[\"oreads\"][i]\n t2 = clones2[i]\n r2 = reads2[i]\n \n f.write(\"%.3f\\t%d\\t%d\\t%d\\t%d\\t%.2f\\t%.2f\\t%.2f\\t%.2f\\n\" %( c, t1, t2, oc1, oc2, getPc(oc1, t1), getPc(oc2, t2), getPc(or1, r1), getPc(or2, r2) ))\n f.close()\n\n#================ AVERAGE ACROSS THE SIMULATIONS ====================\nclass Summary( Target ):\n def __init__(self, indir, samSizes, numSamples, outdir, writePickle, writeSummary, readPickle):\n Target.__init__(self, time=0.001)\n self.indir = indir #outdir/sims/batchId/sim-Id; #outdir/samplings/batchId; #outdir/summary\n self.samSizes = samSizes\n self.numSamples = numSamples\n self.outdir = outdir #outdir/samplings/batchId/sim-Id; #outdir/summary/batchid; #outdir/stats\n self.writePickle = writePickle\n self.writeSummary = writeSummary\n self.readPickle = readPickle\n\n def run(self):\n #Get the pairs:\n for i in xrange(self.numSamples - 1):\n for j in xrange(self.numSamples):\n pair = \"%d-%d\" %( i, j )\n outdir = os.path.join(self.outdir, pair) #outdir/samplings/batchId/sim-Id/pair; #outdir/summary/batchid/pair \n system(\"mkdir -p %s\" %outdir)\n for samsize in self.samSizes:\n self.addChildTarget( SummarySamsize(self.indir, samsize, pair, outdir, self.writePickle, self.writeSummary, self.readPickle) )\n if not self.writePickle:\n self.setFollowOnTarget( CleanupSummary(self.indir) )\n\nclass SummarySamsize( Target ):\n def __init__(self, indir, samsize, pair, outdir, writePickle, writeSummary, readPickle):\n Target.__init__(self, time=0.001)\n self.indir = indir #outdir/sims/batchId/sim-Id; #outdir/samplings/batchId; #outdir/summary\n self.samsize = samsize\n self.pair = pair\n self.outdir = outdir #outdir/samplings/batchId/sim-Id/pair; #outdir/summary/batchid/pair; #outdir/stats/pair\n self.writePickle = writePickle\n self.writeSummary = writeSummary\n self.readPickle = readPickle\n\n def run(self):\n #Get the stats:\n cutoff2stats = {} #key = cutoff, val = [clones1, clones2, overlap1, overlap2, %1oc2, %2oc1, %1or2, %2or1]\n indirs = os.listdir(self.indir)\n for indir in indirs:\n if not os.path.isdir( os.path.join(self.indir,indir) ):\n continue\n file = os.path.join(os.path.join(self.indir,indir), self.pair, \"%d.txt\" %self.samsize)\n if self.readPickle:\n file = os.path.join(os.path.join(self.indir,indir), self.pair, \"%d.pickle\" %self.samsize)\n \n if not os.path.exists(file):\n raise NonExistFileError(\"File %s does not exist\\n\" %file)\n \n if not self.readPickle:\n currCutoff2stats = readStats(file)\n else:\n currCutoff2stats = pickle.load( gzip.open(file, \"rb\") )\n for c, stats in currCutoff2stats.iteritems():\n if c not in cutoff2stats:\n cutoff2stats[c] = stats\n else:\n for i, s in enumerate(stats):\n cutoff2stats[c][i].extend(s)\n \n #Calculate average and standard deviation:\n if self.writePickle:\n outfile = os.path.join(self.outdir, \"%d.pickle\" %self.samsize)\n pickle.dump(cutoff2stats, gzip.open(outfile, \"wb\"))\n \n if self.writeSummary:\n for c, stats in cutoff2stats.iteritems():\n for i, s in enumerate(stats):\n cutoff2stats[c][i] = [np.mean( s ), np.std( s )]\n #cutoff2stats[c][i] = float(s)/self.denom\n\n #Print to output file:\n outfile = os.path.join(self.outdir, \"%d.txt\" %self.samsize)\n f = open(outfile, 'w')\n f.write(\"#%Cutoff\\tClones1\\tClones2\\toverlap1\\toverlap2\\t%1overlap2\\t%2overlap1\\t%reads1overlap2\\t%reads2overlap1\\t\")\n f.write(\"StdClones1\\tStdClones2\\tStdOverlap1\\tStdOverlap2\\tStd%1overlap2\\tStd%2overlap1\\tStd%reads1overlap2\\tStd%reads2overlap1\\n\")\n for c in sorted( cutoff2stats.keys() ):\n stats = cutoff2stats[c]\n meanStats = [ \"%.4f\" % s[0] for s in stats ]\n stdStats = [ \"%.4f\" % s[1] for s in stats ]\n f.write( \"%.3f\\t%s\\t%s\\n\" %(c, \"\\t\".join(meanStats), \"\\t\".join(stdStats)) )\n f.close()\n\n#=============== CLEANUP =================\nclass CleanupSummary ( Target ):\n def __init__(self, indir):\n Target.__init__(self, time = 0.00025)\n self.indir = indir\n\n def run(self):\n system(\"rm -fR %s\" %self.indir)\n\n####################### UTILITIES FUNCTIONS ##########################\n\n#============== calculate overlap =================\ndef getOverlap( seqs1, seqs2, cutoffs ):\n #Initialize stats:\n stats1 = {\"oclones\":[], \"oreads\":[]}\n stats2 = {\"oclones\":[], \"oreads\":[]}\n for i in xrange( len(cutoffs) ):\n for k in stats1:\n stats1[k].append(0)\n stats2[k].append(0)\n\n #get number of clones that pass the cutoff:\n reads1, clones1, total1 = getNumClones(seqs1, cutoffs)\n reads2, clones2, total2 = getNumClones(seqs2, cutoffs)\n\n if total1 == 0 or total2 == 0:\n return\n #get overlap:\n for s1 in seqs1:\n i2 = seqs2.search(s1)\n if i2 == -1:#not found in repertoire 2\n continue\n s2 = seqs2[i2]\n for i, cutoff in enumerate(cutoffs):\n #if s1.freq >= cutoff and s2.freq >= cutoff:\n if s1.freq >= cutoff:\n stats1[\"oclones\"][i] += 1\n stats1[\"oreads\"][i] += s1.count\n if s2.freq >= cutoff:\n stats2[\"oclones\"][i] += 1\n stats2[\"oreads\"][i] += s2.count \n return reads1, reads2, clones1, clones2, stats1, stats2\n\ndef getNumClones(seqs, cutoffs):\n reads = [ 0 for c in cutoffs ] \n clones = [ 0 for c in cutoffs ]\n total = sum([ s.count for s in seqs ])\n for s in seqs:\n s.setFreq(total)\n for i,c in enumerate(cutoffs):\n if s.freq >= c:\n clones[i] += 1\n reads[i] += s.count\n return reads, clones, total\n\n#================ GENERATE PSEUDO REPERTOIRE =========\ndef sampling( seqs, size ):\n samseqs = Seqs()\n indexList = []\n for i, s in enumerate(seqs):\n indexList.extend( [ i for j in xrange( int(s.count)) ] )\n \n for j in xrange(size):\n i = random.randint(0, len(indexList) -1) #randomly pick one sequence from the repertoire\n s = Aaseq( seqs[indexList[i]].aa )\n #s = copy.copy( seqs[indexList[i]] )\n sindex = samseqs.search(s) #Search for this sequence in the current set of picked sequences\n \n #print [ seq.aa for seq in samseqs]\n #print \"%s\" %s.aa\n #print sindex\n \n if sindex >=0:\n samseqs[sindex].updateCount(1)\n else:#sequence hasn't picked yet\n s.setCount(1)\n samseqs.add(s)\n return samseqs\n\n#get the repertoire using topFreqs if available, otherwise assume lognormal distribution\n#IMCOMPLETE\ndef getRepLognorm( seqs, size, mean, std ):\n #mean = #mean of log(clonesize)\n #std = #standard deviation of log(clonesize)\n \n #Generate repertoire:\n topindices = []\n sizeToFill = size\n\n if topFreqs:\n for i, f in enumerate(topFreqs):\n index = random.randint(0, len(seqs) -1)\n while (index in topindices):\n index = random.randint(0, len(seqs) -1)\n topindices.append(index)\n count = int(f*size)\n seqs[index].setCount( count )\n sizeToFill = size - int( sum(topFreqs)*size )\n \n for i in xrange(sizeToFill):\n index = random.randint(0, len(seqs) -1)\n while (index in topindices):\n index = random.randint(0, len(seqs) -1)\n \n\n#get the repertoire using topFreqs if available, otherwise assume uniform distribution\ndef getRep( seqs, size, topFreqs ):\n #Generate repertoire:\n topindices = []\n sizeToFill = size\n if topFreqs:\n for i, f in enumerate(topFreqs):\n index = random.randint(0, len(seqs) -1)\n while (index in topindices):\n index = random.randint(0, len(seqs) -1)\n topindices.append(index)\n count = int(f*size)\n seqs[index].setCount( count )\n sizeToFill = size - int( sum(topFreqs)*size )\n \n for i in xrange(sizeToFill):\n index = random.randint(0, len(seqs) -1)\n while (index in topindices):\n index = random.randint(0, len(seqs) -1)\n seqs[index].updateCount(1)\n\ndef getUniqSeqRep(size, aaUsage, aa2codons):\n \"\"\"Generate \"size\" number of unique nucleotide sequences with length (len(aaUsage))\n Using the amino-acid Usage from aaUsage, and codon usage from aa2codons\n \"\"\"\n seqs = Seqs() #list of sequences\n while len(seqs) < size:\n aa = getAaSeq(aaUsage)\n nuc = aa2nuc(aa, aa2codons)\n seq = Seq(nuc, aa)\n seqs.add(seq)\n return seqs\n\ndef readStats( file ):\n cutoff2stats = {} #key = cutoff, val = [clones1, clones2, overlap, %1oc2, %2oc1, %1or2, %2or1]\n f = open(file, 'r')\n for line in f:\n if line[0] == \"#\":\n continue\n items = line.split(\"\\t\")\n if len(items) < 9:\n raise FileFormatError(\"Wrong file format, 9 fields are required, see %d. File %s\\n\" %(len(items), file))\n cutoff = float(items[0])\n #stats = [int(items[1]), int(items[2]), int(items[3]), int(items[4]), float(items[5]), float(items[6]), float(items[7]), float(items[8])]\n stats = [ [float(items[i])] for i in xrange(1,9) ]\n #stats = [float(items[1]), float(items[2]), float(items[3]), float(items[4]), float(items[5]), float(items[6]), float(items[7]), float(items[8])]\n cutoff2stats[cutoff] = stats\n f.close()\n return cutoff2stats\n\ndef getPc(count, total):\n if total == 0:\n return 0\n return 100.0*count/total\n\ndef getAaSeq(aaUsage):\n aa = \"\"\n seqlen = len(aaUsage)\n for i in xrange(seqlen):\n letters = aaUsage[i]\n j = random.randint(0, len(letters) -1)\n aa += letters[j] \n return aa\n\ndef aa2nuc(aaseq, aa2codons):\n nucseq = ''\n for aa in aaseq:\n codons = aa2codons[aa]\n i = random.randint( 0, len(codons) -1 )\n nucseq += codons[i]\n return nucseq\n\n#================ ERROR CLASSES ============\nclass FileFormatError(Exception):\n pass\n\nclass TopFreqError(Exception): \n pass\n\nclass NonExistFileError(Exception):\n pass\n\n#================ READ INPUT FILES ================\ndef readCodonUsage(file):\n \"\"\"\n \"\"\"\n aa2codons = {} #key = aa, val = {codon:freq}\n aa2codon2freq = {}\n f = open(file, 'r')\n for line in f:\n line.strip()\n if line == \"\" or line[0] == \"#\":\n continue\n items = line.split()\n if len(items) %4 > 0:\n raise FileFormatError(\"Wrong codonUsage format\\n\")\n for i in xrange(0, len(items), 4):\n codon = items[i]\n aa = items[i+1]\n freq = float( items[i+2] )\n if aa not in aa2codon2freq:\n aa2codon2freq[aa] = {codon: freq}\n else:\n aa2codon2freq[aa][codon] = freq\n f.close()\n \n #Normalize\n normlen = 100\n for aa in aa2codon2freq:\n aa2codons[aa] = []\n for codon, freq in aa2codon2freq[aa].iteritems():\n for i in xrange( int(freq*normlen) ):\n aa2codons[aa].append(codon)\n\n return aa2codons\n\ndef readAaUsage(file):\n '''\n Return: len2aaUsage = {} #key = length, val= position-array, each item represent a.a usage of that position.\n Example: \n 9 1 C 10\n 9 2 A 7\n 9 2 R 1\n 9 2 S 3\n 9 2 V 1\n len2aaUsage = {9:[\"CCCCCCCCCC\", \"AAAAAAARSSSV\"]}\n '''\n len2aaUsage = {} #key = length, val= position-array, each item represent a.a usage of that position.\n len2listLetter2freq = {}\n f = open(file, 'r')\n for line in f:\n line = line.strip()\n if line == \"\" or line[0] == \"#\":\n continue\n items = line.split()\n if len(items) != 4:\n raise FileFormatError(\"Wrong aaUsage file format. Required 4 fields, have %d. Line: %s\\n\" %(len(items), line) )\n l = int( items[0] )\n pos = int( items[1] ) - 1\n letter = items[2]\n count = int( items[3] )\n\n if l < 0 or pos < 0 or count < 0:\n raise ValueError(\"readAaUsage: length, position, count must >=0\")\n if pos >= l:\n raise FileFormatError(\"readAaUsage: Column 2 value (Position) must <= col 1 value (length)\\n\")\n if l not in len2listLetter2freq:\n len2listLetter2freq[ l ] = [{} for i in xrange(l)]\n len2listLetter2freq[ l ][ pos ][ letter ] = count\n f.close()\n\n #Make sure that for each length, usage for all positions are provided from input file:\n for l in len2listLetter2freq:\n for i in xrange(l):\n if len( len2listLetter2freq[l][i].keys() ) == 0:\n raise FileFormatError(\"readAaUsage requires input file to have AA usage for all positions of each length. Could not find usage for length %d, position %d.\" %(l, i + 1))\n\n #Normalize counts:\n normLen = 10000 #equivalent the number of digits of the frequencies got taken into account\n for l in len2listLetter2freq:\n posList = len2listLetter2freq[l]\n len2aaUsage[ l ] = []\n for i, letter2count in enumerate(posList):\n total = sum([ letter2count[letter] for letter in letter2count ])\n if total > 0:\n for letter, count in letter2count.iteritems():\n letter2count[letter] = normLen*count/total\n posLetters = \"\".join([ letter*count for letter, count in letter2count.iteritems()])\n len2aaUsage[l].append(posLetters)\n\n return len2aaUsage\n\ndef getUniAaUsage(lens):\n aas = \"ARNDCEQGHILKFPSTWYV\"\n len2aaUsage = {}\n for l in lens:\n if not isinstance(l, int):\n raise ValueError(\"getUniAaUsage, input lengths contain non-integer items\\n\")\n len2aaUsage[l] = []\n for i in xrange(l):#each position\n len2aaUsage[l].append(aas)\n return len2aaUsage\n\ndef readCdr3LenDist(file):\n '''Get length distribution of CDR3 amino-acid sequences. Format of input file: \\t\n Return a dictionary len2freq, where key=length and val = freq of that length\n '''\n len2freq = {} #key = length, val=frequency\n f = open(file, 'r')\n total = 0\n for line in f:\n line = line.strip()\n if line == \"\" or line[0] == \"#\":\n continue\n #items = line.split(\"\\t\")\n items = line.split()\n if len(items) < 2:\n raise FileFormatError(\"Wrong cdr3LenDist file format. Require two fields: \\\\t\\n.%s\\n\" %line)\n if items[0] == \"TOTAL\":\n continue\n try:\n l = int( (items[0].split(\".\"))[0] )\n c = int( items[1] )\n except ValueError:\n raise ValueError(\"First and Second columns in cdr3LenDist file %s must be integer\\n\" %file)\n\n total += c\n if l not in len2freq:\n len2freq[l] = c\n else:\n len2freq[l] += c\n #Normalize counts to frequencies:\n if total > 0: \n for l, c in len2freq.iteritems():\n len2freq[l] = float(c)/total\n f.close()\n return len2freq\n\ndef getUniCdr3LenDist():\n len2freq = {}\n minlen = 9\n maxlen = 23\n r = maxlen + 1 - minlen\n for l in xrange(minlen, maxlen + 1):\n len2freq[l] = 1.0/r\n return len2freq\n\ndef getTopFreqs( topFreqs, totalClones, totalSeqs ):\n f = open(topFreqs, \"r\")\n freqs = []\n for line in f:\n line = line.strip()\n freq = float(line)\n if not isinstance(freq, float):\n raise ValueError(\"Wrong format topFreqs file. Requires floats.\\n\")\n if freq <= 0:\n raise ValueError(\"Frequencies in topFreqs file (%s) must be positive. Got %f\\n\" %(topFreqs, freq))\n\n freqs.append( freq )\n #Make sure that sum of freqs <= 1 - (totalClones - len(freqs))/totalSeqs\n if sum(freqs) > 1 - float((totalClones - len(freqs)))/totalSeqs:\n raise TopFreqError(\"Frequencies of top clones add up to be larger than permitted\")\n topFreqs = freqs\n f.close()\n return topFreqs\n \n################### OPTIONS #########################\ndef checkOptions( parser, options, args ):\n #Check output directory\n if not os.path.exists( options.outdir ):\n system( \"mkdir %s\\n\" %(options.outdir) )\n \n #Number of samples:\n if not isinstance(options.numSamples, int):\n parser.error(\"Number of samples must be in integer\\n\")\n if options.numSamples < 2:\n parser.error(\"Number of samples must > 2. %d was given\\n\" %options.numSamples)\n \n #Make sure the number of totalClones < totalSeqs:\n if options.totalClones > options.totalSeqs:\n raise ValueError(\"Total number of clones must be smaller than total number of sequences. %d clones and %d sequences were given\" %(options.totalClones, options.totalSeqs) ) \n\n #sampling sizes:\n options.samSize = [long(s) for s in options.samSize.split(\",\")]\n\n #Top Freqs:\n if options.topFreqs:\n if not os.path.exists( options.topFreqs ):\n parser.error(\"TopFreqs file %s does not exists\\n\" %options.topFreqs)\n options.topFreqs = getTopFreqs( options.topFreqs, options.totalClones, options.totalSeqs )\n\n #Cutoffs:\n options.cutoffs = [ float(c) for c in options.cutoffs.split(\",\") ]\n \n #CDR3 length distribution\n if options.cdr3LenDist:\n if not os.path.exists(options.cdr3LenDist):\n parser.error(\"cdr3LenDist file %s does not exist\\n\" %options.cdr3LenDist)\n options.len2freq = readCdr3LenDist(options.cdr3LenDist)\n else:\n options.len2freq = getUniCdr3LenDist() \n\n if options.aaUsage:\n if not os.path.exists(options.aaUsage):\n parser.error(\"aaUsage file %s does not exist\\n\" %options.aaUsage)\n options.len2aaUsage = readAaUsage(options.aaUsage)\n else:\n options.len2aaUsage = getUniAaUsage( range(9, 24) )\n \n if not options.codonUsage:\n parser.error(\"Required argument codonUsage. None was given\\n\")\n if not os.path.exists(options.codonUsage):\n parser.error(\"codonUsage file %s does not exist\\n\" %options.codonUsage)\n options.aa2codons = readCodonUsage(options.codonUsage)\n\ndef addOptions( parser ):\n #parser.add_option(\"-i\", \"--indir\", dest = 'indir', help=\"Required argument. Input directory that contains input fastq files (each represents a sample)\\n\")\n #parser.add_option(\"-n\", \"--popCdr3\", dest='popCdr3', type=\"long\", default=5*(10**11), help=\"Estimated number of unique CDR3 nucleotide sequences in the population. Default=5x10^11\")\n parser.add_option(\"-o\", \"--outdir\", dest = 'outdir', default=\".\", help=\"Output directory. Default: current directory\\n\")\n parser.add_option(\"-N\", \"--numSim\", dest=\"numSim\", type=\"int\", default=100, help=\"Number of repertoire simulations. Default = 100\")\n parser.add_option(\"--numSamplingPerSim\", dest=\"numSamplingPerSim\", type=\"int\", default=100, help=\"Number of samplings per repertoire simulation. Default = %default\")\n parser.add_option(\"-m\", \"--totalClones\", dest=\"totalClones\", type=\"long\", default=3*(10**6), help=\"Estimated number of unique CDR3 nucleotide sequences in one individual. Default=3x10^6\")\n parser.add_option(\"-M\", \"--totalSeqs\", dest=\"totalSeqs\", type=\"long\", default=6*(10**7), help=\"Estimated number of CDR3 nucleotide sequences in one individual. Default=6x10^7 (number of CD8+ T cells per person)\")\n parser.add_option(\"-S\", \"--samplingSize\", dest=\"samSize\", default=\"50000,100000,150000,200000\", help=\"Comma separated string of sampling sizes. Default=%default\")\n #parser.add_option(\"-a\", \"--aaUsage\", dest=\"aaUsage\", help=\"Amino acid usage of the CDR3 sequences. Format:\\t\\t\\t. If not specified, use uniform distribution\")\n parser.add_option(\"-a\", \"--aaUsage\", dest=\"aaUsage\", help=\"Amino acid usage of the CDR3 sequences. Format:\\t\\t\\t. If not specified, use lognormal distribution\")\n parser.add_option(\"-l\", \"--cdr3LenDist\", dest=\"cdr3LenDist\", help=\"CDR3 length distribution. Format: \\t\")\n parser.add_option(\"-c\", \"--codonUsage\", dest=\"codonUsage\", default=\"~/codonUsage.txt\", help=\"Codon usage table\")\n #parser.add_option(\"-f\", \"--topFreqs\", dest=\"topFreqs\", help=\"Frequencies of x top clones. Sum of these freqs must <= (M - (m-x))/M. If not specified, use uniform distribution\")\n parser.add_option(\"-f\", \"--topFreqs\", dest=\"topFreqs\", help=\"Frequencies of x top clones. Sum of these freqs must <= (M - (m-x))/M. If not specified, use lognormal distribution\")\n parser.add_option(\"-s\", \"--numSamples\", dest=\"numSamples\", type=\"int\", default=2, help=\"Number of samples (individuals/repertoires) to compare. Default=2.\")\n parser.add_option(\"-p\", \"--cutoffs\", dest=\"cutoffs\", default=\"0,0.001,0.01,0.05,0.1,0.5,1,5,10\", help=\"Comma separated clonesize percentage cutoffs. Default='0,0.001,0.01,0.05,0.1,0.5,1,5'\")\n parser.add_option(\"--maxSimPerRun\", dest=\"maxSimPerRun\", type='int', default=100, help=\"Maximum number of simulations per batch. Default=100\")\n\n################# MAIN ##############################\ndef main():\n parser = OptionParser()\n Stack.addJobTreeOptions( parser )\n\n addOptions( parser )\n\n options, args = parser.parse_args()\n checkOptions( parser, options, args )\n\n i = Stack( Setup(options, 0) ).startJobTree( options )\n if i:\n raise RuntimeError(\"The jobtree contains %d failed jobs.\\n\" %i)\n\nif __name__ == \"__main__\":\n #from tcrRepSim import *\n from immunoseq.src.tcrRepSim import *\n main()\n\n\n\n\n", "meta": {"hexsha": "c8d411e9ae38c0075f38a9df3fb89654fe68d15d", "size": 39026, "ext": "py", "lang": "Python", "max_stars_repo_path": "bin/tcrRepSim.py", "max_stars_repo_name": "ngannguyen/immunoseq", "max_stars_repo_head_hexsha": "dfaac691e7b8ab93337f6d1619b6d67533ff9394", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-03-15T12:18:48.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-13T03:31:23.000Z", "max_issues_repo_path": "src/tcrRepSim.py", "max_issues_repo_name": "ngannguyen/immunoseq", "max_issues_repo_head_hexsha": "dfaac691e7b8ab93337f6d1619b6d67533ff9394", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/tcrRepSim.py", "max_forks_repo_name": "ngannguyen/immunoseq", "max_forks_repo_head_hexsha": "dfaac691e7b8ab93337f6d1619b6d67533ff9394", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.4657236126, "max_line_length": 439, "alphanum_fraction": 0.6143084098, "include": true, "reason": "import numpy,from scipy", "num_tokens": 10405, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5428632831725052, "lm_q2_score": 0.35936415888237616, "lm_q1q2_score": 0.1950856071454125}} {"text": "## Requirements\n\n### Packages\nimport os\nimport json\nimport gzip\nimport numpy as np\n\nfrom bandits_to_rank.environment import Environment_PBM, PositionsRanking\nfrom bandits_to_rank.opponents import greedy\nfrom bandits_to_rank.opponents.pbm_pie import PBM_PIE_Greedy_SVD, PBM_PIE_semi_oracle, PBM_PIE_Greedy_MLE\nfrom bandits_to_rank.opponents.pbm_ucb import PBM_UCB_Greedy_SVD, PBM_UCB_semi_oracle, PBM_UCB_Greedy_MLE\nfrom bandits_to_rank.opponents.pbm_ts import PBM_TS_Greedy_SVD, PBM_TS_semi_oracle, PBM_TS_Greedy_MLE\nfrom bandits_to_rank.opponents.bc_mpts import BC_MPTS_Greedy_SVD, BC_MPTS_semi_oracle,BC_MPTS_Greedy_MLE\n#from bandits_to_rank.opponents.pmed import PMED # loaded only before usage to load tensorflow library only when required\nfrom bandits_to_rank.opponents.top_rank import TOP_RANK\nfrom bandits_to_rank.opponents.grab import GRAB\nfrom bandits_to_rank.opponents.f_grab import sGRAB\nfrom bandits_to_rank.opponents.combucb import CombUCB1, KL_CombUCB1\nfrom bandits_to_rank.opponents.pb_mhb import *\nfrom bandits_to_rank.referee import Referee\n\n# set.seed(123)\n\n\n# Path to bandits-to-rank module\nimport bandits_to_rank\n\npackagedir = os.path.dirname(bandits_to_rank.__path__[0])\n\n\nclass NdArrayEncoder(json.JSONEncoder):\n def default(self, obj):\n if isinstance(obj, np.ndarray):\n return obj.tolist()\n if isinstance(obj, (np.int_, np.intc, np.intp, np.int8,\n np.int16, np.int32, np.int64, np.uint8,\n np.uint16, np.uint32, np.uint64)):\n return int(obj)\n # Let the base class default method raise the TypeError\n return json.JSONEncoder.default(self, obj)\n\n\ndef record_zip(filename, dico):\n print(type(dico))\n print('file', filename)\n json_str = json.dumps(dico, cls=NdArrayEncoder)\n json_bytes = json_str.encode('utf-8')\n with gzip.GzipFile(filename, 'w') as fout:\n fout.write(json_bytes)\n return 'done'\n\n\nclass Parameters():\n \"\"\" Parameters used for the experiment\n\n # Environement\n env\n env_name str used for name of files\n logs_env_name (only for merge)\n\n # Player\n player\n player_name\n\n # Rules\n rules_name\n referee\n\n # Sub-experiment\n first_game (only for play)\n end_game (only for play)\n input_path (only for merge)\n output_path\n force (only for play)\n \"\"\"\n\n def __init__(self):\n self.env = Environment_PBM([1], [1], label=\"fake\")\n self.positions_ranking = PositionsRanking.SHUFFLE_EXCEPT_FIRST # default: shuffle kappas before each game\n self.nb_relevant_positions = None # default: compute reward at each position\n self.rng = np.random.default_rng()\n\n #########\" PBM_Setting\n def set_positions_ranking(self, positions_ranking):\n self.positions_ranking = positions_ranking\n\n # tag for file names and logs\n if positions_ranking == PositionsRanking.FIXED:\n raise ValueError('fixed ranking of positions should be set by the player')\n elif positions_ranking == PositionsRanking.DECREASING:\n # TODO: better naming for PBM '__decreasing_kappa'\n # TODO: better naming for CM '__std_order_on_views'\n tag = '__sorted_kappa' if type(self.env) == Environment_PBM else ''\n elif positions_ranking == PositionsRanking.SHUFFLE:\n # TODO: better naming for CM '__random_order_on_views'\n tag = '__shuffled_kappa' if type(self.env) == Environment_PBM else '_order_view_shuffle'\n elif positions_ranking == PositionsRanking.SHUFFLE_EXCEPT_FIRST:\n # TODO: better naming for PBM __shuffled_kappa_except_first\n tag = '' if type(self.env) == Environment_PBM else '__random_order_on_views_except_first'\n elif positions_ranking == PositionsRanking.INCREASING:\n tag = ('__increasing_kappa' if type(self.env) == Environment_PBM else '__reverse_order_on_views')\n elif positions_ranking == PositionsRanking.INCREASING_EXCEPT_FIRST:\n tag = ('__increasing_kappa_except_first' if type(self.env) == Environment_PBM\n else '__reverse_order_on_views_except_first')\n else:\n raise ValueError(f'unhandled ranking on positions: {positions_ranking}')\n self.env_name += tag\n self.logs_env_name += tag\n self.env.label += tag\n\n def set_env_KDD_all(self):\n \"\"\"!!! only to merge logs from several queries of KDD data !!!\"\"\"\n self.env_name = f'KDD_all'\n self.logs_env_name = f'KDD_[0-9]*_query'\n\n def set_env_KDD(self, query):\n # load KDD data\n # todo: to put in bandits_to_rank.data\n with open(packagedir + '/data/param_KDD.txt', 'r') as file:\n dict_theta_query = json.load(file)\n query_name, query_params = list(dict_theta_query.items())[query]\n\n # set environement\n self.env_name = f'KDD_{query}_query'\n self.logs_env_name = self.env_name\n self.env = Environment_PBM(query_params['thetas'], query_params['kappas']\n , label='%s (%d for us)' % (query_name, query))\n\n def set_env_Yandex_all(self):\n \"\"\"!!! only to merge logs from several queries of Yandex data !!!\"\"\"\n self.env_name = f'Yandex_all'\n self.logs_env_name = f'Yandex_[0-9]*_query'\n\n def set_env_Yandex(self, query):\n # load Yandex data\n # todo: to put in bandits_to_rank.data\n with open(packagedir + '/data/param_Yandex.txt', 'r') as file:\n dict_theta_query = json.load(file)\n query_name, query_params = list(dict_theta_query.items())[query]\n\n # reduce to 10 products, 5 positions\n thetas = np.sort(query_params['thetas'])[:-11:-1]\n kappas = np.sort(query_params['kappas'])[:-6:-1]\n\n # set environement\n self.env_name = f'Yandex_{query}_query'\n self.logs_env_name = self.env_name\n self.env = Environment_PBM(thetas, kappas\n , label='%s (%d for us)' % (query_name, query))\n\n def set_env_Yandex_equi_all(self, K):\n \"\"\"!!! only to merge logs from several queries of Yandex data !!!\"\"\"\n self.env_name = f'Yandex_equi_{K}_K_all'\n self.logs_env_name = f'Yandex_equi_{K}_K__[0-9]*_query'\n\n def set_env_Yandex_equi(self, query, K):\n # load Yandex data\n with open(packagedir + '/data/param_Yandex.txt', 'r') as file:\n dict_theta_query = json.load(file)\n query_name, query_params = list(dict_theta_query.items())[query]\n\n # reduce to 10 products, 10 positions\n index_max = 1 + K\n thetas = np.sort(query_params['thetas'])[:-index_max:-1]\n kappas = np.sort(query_params['kappas'])[:-index_max:-1]\n\n # set environement\n self.env_name = f'Yandex_equi_{K}_K__{query}_query'\n self.logs_env_name = self.env_name\n self.env = Environment_PBM(thetas, kappas, label=f'Yandex equi K={K} {query} ({query_name} for Yandex)')\n\n def set_env_test(self):\n \"\"\"Purely simulated environment with standard click's probabilities\"\"\"\n kappas = [1, 0.6, 0.3]\n thetas = [0.1, 0.5, 0.1, 0.6, 0.1, 0.4, 0.1, 0.1, 0.1, 0.1]\n self.env_name = f'purely_simulated__test'\n self.logs_env_name = self.env_name\n self.env = Environment_PBM(thetas, kappas, label=\"purely simulated, test\")\n\n def set_env_std(self):\n \"\"\"Purely simulated environment with standard click's probabilities\"\"\"\n kappas = [1, 0.75, 0.6, 0.3, 0.1]\n thetas = [0.3, 0.2, 0.15, 0.15, 0.15, 0.10, 0.05, 0.05, 0.01, 0.01]\n self.env_name = 'purely_simulated__std'\n self.logs_env_name = self.env_name\n self.env = Environment_PBM(thetas, kappas, label=\"purely simulated, std\")\n\n def set_env_small(self):\n \"\"\"Purely simulated environment with click's probabilities close to 0\"\"\"\n kappas = [1, 0.75, 0.6, 0.3, 0.1]\n thetas = [0.15, 0.1, 0.1, 0.05, 0.05, 0.01, 0.01, 0.01, 0.01, 0.01]\n self.env_name = 'purely_simulated__small'\n self.logs_env_name = self.env_name\n self.env = Environment_PBM(thetas, kappas, label=\"purely simulated, small\")\n\n def set_env_big(self):\n \"\"\"Purely simulated environment with click's probabilities close to 1\"\"\"\n kappas = [1, 0.75, 0.6, 0.3, 0.1]\n thetas = [0.99, 0.95, 0.9, 0.85, 0.8, 0.75, 0.75, 0.75, 0.75, 0.75]\n self.env_name = 'purely_simulated__big'\n self.logs_env_name = self.env_name\n self.env = Environment_PBM(thetas, kappas, label=\"purely simulated, big\")\n\n def set_env_extra_small(self):\n \"\"\"Purely simulated environment with click's probabilities close to 0\"\"\"\n kappas = [1, 0.75, 0.6, 0.3, 0.1]\n thetas = [0.10, 0.05, 0.01, 0.005, 0.001, 0.0001, 0.0001, 0.0001, 0.0001, 0.0001]\n self.env_name = 'purely_simulated__xsmall'\n self.logs_env_name = self.env_name\n self.env = Environment_PBM(thetas, kappas, label=\"purely simulated, extra small\")\n\n def set_env_xx_small(self):\n \"\"\"Purely simulated environment with click's probabilities close to 0\"\"\"\n kappas = [1, 0.75, 0.6, 0.3, 0.1]\n thetas = [1e-3, 5e-4, 1e-4, 5e-5, 1e-5, 1e-6, 1e-6, 1e-6, 1e-6, 1e-6]\n self.env_name = 'purely_simulated__xxsmall'\n self.logs_env_name = self.env_name\n self.env = Environment_PBM(thetas, kappas, label=\"purely simulated, xx small\")\n\n def set_env_simul(self, label):\n if label == \"std\":\n self.set_env_std()\n elif label == \"big\":\n self.set_env_big()\n elif label == \"small\":\n self.set_env_small()\n elif label == \"xsmall\":\n self.set_env_extra_small()\n elif label == \"xxsmall\":\n self.set_env_xx_small()\n else:\n raise ValueError(\"unknown label of environment\")\n\n def set_rules(self, nb_trials, nb_records=1000):\n # Check inputs\n if nb_records > nb_trials:\n nb_records = -1\n\n self.rules_name = f'games_{nb_trials}_nb_trials_{nb_records}_record_length'\n self.referee = Referee(self.env, nb_trials, all_time_record=False, len_record_short=nb_records)\n\n def set_player_eGreedy(self, c, update=100, noSVD=False):\n nb_prop, nb_place = self.env.get_setting()\n if noSVD:\n self.player_name = f'Bandit_EGreedy_EM_{c}_c_{update}_update'\n self.player = greedy.greedy_EGreedy_EM(c, nb_prop, nb_place, update)\n else:\n self.player_name = f'Bandit_EGreedy_SVD_{c}_c_{update}_update'\n self.player = greedy.greedy_EGreedy(c, nb_prop, nb_place, update)\n\n def set_player_PBM_TS(self, type=\"oracle\"):\n nb_prop, nb_place = self.env.get_setting()\n if type ==\"oracle\":\n self.player_name = 'Bandit_PBM-TS_oracle'\n self.player = PBM_TS_semi_oracle(nb_prop, nb_place, discount_factor=self.env.kappas, count_update=1)\n self.positions_ranking = PositionsRanking.FIXED\n elif type ==\"greedyMLE\":\n self.player_name = 'Bandit_PBM_TS_greedy_MLE'\n self.player = PBM_TS_Greedy_MLE(nb_prop, nb_place, count_update=1)\n elif type ==\"greedySVD\":\n self.player_name = 'Bandit_PBM_TS_greedy_SVD'\n self.player = PBM_TS_Greedy_SVD(nb_prop, nb_place, count_update=1)\n else:\n self.player_name = 'Bandit_PBM-TS_greedy_SVD'\n self.player = PBM_TS_Greedy_SVD(nb_prop, nb_place, count_update=1)\n\n def set_player_PBM_PIE(self, epsilon, T, type =\"oracle\"):\n nb_prop, nb_place = self.env.get_setting()\n if type ==\"oracle\":\n self.player_name = f'Bandit_PBM-PIE_oracle_{epsilon}_epsilon'\n self.player = PBM_PIE_semi_oracle(nb_prop, epsilon, T, nb_place, discount_factor=self.env.kappas, count_update=1)\n self.positions_ranking = PositionsRanking.FIXED\n elif type ==\"greedyMLE\":\n self.player_name = 'Bandit_PBM_PIE_greedy_MLE'\n self.player = PBM_PIE_Greedy_MLE(nb_prop, epsilon, nb_place, count_update=1)\n elif type ==\"greedySVD\":\n self.player_name = 'Bandit_PBM_PIE_greedy_SVD'\n self.player = PBM_PIE_Greedy_SVD(nb_prop, epsilon, nb_place, count_update=1)\n else:\n self.player_name = f'Bandit_PBM-PIE_greedy_SVD_{epsilon}_epsilon'\n self.player = PBM_PIE_Greedy_SVD(nb_prop, epsilon, T, nb_place, count_update=1)\n\n def set_player_PBM_UCB(self, epsilon, type =\"oracle\"):\n nb_prop, nb_place = self.env.get_setting()\n if type ==\"oracle\":\n self.player_name = f'Bandit_PBM_UCB_oracle_{epsilon}_epsilon'\n self.player = PBM_UCB_semi_oracle(nb_prop, epsilon, nb_place, discount_factor=self.env.kappas, count_update=1)\n self.positions_ranking = PositionsRanking.FIXED\n elif type ==\"greedyMLE\":\n self.player_name = 'Bandit_PBM_UCB_greedy_MLE'\n self.player = PBM_UCB_Greedy_MLE(nb_prop, epsilon, nb_place, count_update=1)\n elif type ==\"greedySVD\":\n self.player_name = 'Bandit_PBM_UCB_greedy_SVD'\n self.player = PBM_UCB_Greedy_SVD(nb_prop, epsilon, nb_place, count_update=1)\n else:\n self.player_name = f'Bandit_PBM_UCB_greedy_SVD_{epsilon}_epsilon'\n self.player = PBM_UCB_Greedy_SVD(nb_prop, epsilon, nb_place, count_update=1)\n\n\n def set_player_BC_MPTS(self, type =\"oracle\"):\n nb_prop, nb_place = self.env.get_setting()\n if type ==\"oracle\":\n self.player_name = 'Bandit_BC-MPTS_oracle'\n self.player = BC_MPTS_semi_oracle(nb_prop, nb_place, self.env.kappas)\n self.positions_ranking = PositionsRanking.FIXED\n elif type ==\"greedyMLE\":\n self.player_name = 'Bandit_BC-MPTS_greedy_MLE'\n self.player = BC_MPTS_Greedy_MLE(nb_prop, nb_place, count_update=1)\n elif type ==\"greedySVD\":\n self.player_name = 'Bandit_BC-MPTS_greedy_SVD'\n self.player = BC_MPTS_Greedy_SVD(nb_prop, nb_place, count_update=1)\n else:\n self.player_name = 'Bandit_BC-MPTS_greedy_SVD'\n self.player = BC_MPTS_Greedy_SVD(nb_prop, nb_place, count_update=1)\n\n def set_player_PMED(self, alpha, gap_MLE, gap_q, run=True):\n nb_prop, nb_place = self.env.get_setting()\n\n self.player_name = f'Bandit_PMED_{alpha}_alpha_{gap_MLE}_gap_MLE_{gap_q}_gap_q'\n\n if run:\n from bandits_to_rank.opponents.pmed import PMED\n self.player = PMED(nb_prop, nb_place, alpha, gap_MLE, gap_q)\n\n def set_player_CombUCB1(self, exploration_factor=2.):\n nb_prop, nb_place = self.env.get_setting()\n\n self.player_name = f'Bandit_CombUCB1_{exploration_factor}_exploration'\n self.player = CombUCB1(nb_arms=nb_prop, nb_positions=nb_place, exploration_factor=exploration_factor)\n\n def set_player_KL_COMB(self, horizon):\n nb_prop, nb_place = self.env.get_setting()\n\n self.player_name = f'Bandit_KL-COMB_{horizon}_horizon'\n self.player = KL_CombUCB1(nb_arms=nb_prop, nb_positions=nb_place, horizon=horizon)\n\n def set_player_PB_MHB(self, nb_steps, random_start=False):\n nb_prop, nb_place = self.env.get_setting()\n if random_start:\n self.player_name = f'Bandit_PB-MHB_random_start_{nb_steps}_step_{self.proposal_name}_proposal'\n self.player = PB_MHB(nb_prop, nb_place, proposal_method=self.proposal, step=nb_steps,\n part_followed=False)\n else:\n self.player_name = f'Bandit_PB-MHB_warm-up_start_{nb_steps}_step_{self.proposal_name}_proposal'\n self.player = PB_MHB(nb_prop, nb_place, proposal_method=self.proposal, step=nb_steps,\n part_followed=True)\n\n def set_player_TopRank(self, T, horizon_time_known=True, doubling_trick=False, oracle=False):\n nb_prop, nb_place = self.env.get_setting()\n if oracle:\n self.player_name = f'Bandit_TopRank_oracle_{T}_delta_{\"TimeHorizonKnown\" if horizon_time_known else \"\"}_{\"doubling_trick\" if doubling_trick else \"\"}'\n self.player = TOP_RANK(nb_arms=nb_prop,\n T=T, horizon_time_known=horizon_time_known,doubling_trick_active=doubling_trick,\n discount_factor=self.env.kappas)\n self.positions_ranking = PositionsRanking.FIXED\n else:\n self.player_name = f'Bandit_TopRank_{T}_delta_{\"TimeHorizonKnown\" if horizon_time_known else \"\"}_{\"doubling_trick\" if doubling_trick else \"\"}'\n self.player = TOP_RANK(nb_arms=nb_prop,\n T=T, horizon_time_known=horizon_time_known, doubling_trick_active=doubling_trick,\n discount_factor=np.arange(nb_place - 1, -1, -1))\n \"\"\"\n self.player_name = f'Bandit_TopRank_greedy_{T}_delta_{\"TimeHorizonKnown\" if horizon_time_known else \"\"}_{\"doubling_trick\" if doubling_trick else \"\"}'\n self.player = TOP_RANK(nb_arms=nb_prop,\n T=T, horizon_time_known=horizon_time_known,doubling_trick_active=doubling_trick,\n nb_positions=nb_place, lag=1)\n \"\"\"\n\n\n def set_player_SGRAB(self, T, gamma, forced_initiation):\n nb_prop, nb_place = self.env.get_setting()\n if gamma == 0:\n gamma_use = nb_prop * nb_place\n else:\n gamma_use = gamma\n self.player_name = f'Bandit_SGRAB_{T}_T_{gamma_use}_gamma{\"_forced\" if forced_initiation else \"\"}'\n self.player = sGRAB(nb_arms=nb_prop, nb_positions=nb_place, T=T)\n\n def set_player_GRAB(self, T, gamma, forced_initiation):\n nb_prop, nb_place = self.env.get_setting()\n if gamma == 0:\n gamma_use = nb_prop - nb_place\n else:\n gamma_use = gamma\n self.player_name = f'Bandit_GRAB_{T}_T_{gamma_use}_gamma{\"_forced\" if forced_initiation else \"\"}'\n self.player = GRAB(nb_arms=nb_prop, nb_positions=nb_place, T=T, gamma=gamma_use,\n forced_initiation=forced_initiation)\n\n def set_proposal_TGRW(self, c, vari_sigma=True):\n self.proposal_name = f'TGRW_{c}_c{\"_vari_sigma\" if vari_sigma else \"\"}'\n self.proposal = propos_trunk_GRW(c, vari_sigma)\n\n def set_proposal_LGRW(self, c, vari_sigma=True):\n self.proposal_name = f'LGRW_{c}_c{\"_vari_sigma\" if vari_sigma else \"\"}'\n self.proposal = propos_logit_RW(c, vari_sigma)\n\n def set_proposal_RR(self, c, str_proposal_possible, vari_sigma=True):\n list_proposal_possible = list(str_proposal_possible.split(\"-\"))\n self.proposal_name = f'RR_{c}_c_{len(list_proposal_possible)}_proposals'\n self.proposal = propos_Round_Robin(c, vari_sigma, list_proposal_possible)\n\n def set_proposal_MaxPos(self):\n self.proposal_name = f'MaxPos'\n self.proposal = propos_max_position()\n\n def set_proposal_PseudoView(self):\n self.proposal_name = f'PseudoView'\n self.proposal = propos_pseudo_view()\n\n def set_exp(self, first_game=-1, nb_games=-1, nb_checkpoints=10, input_path=None, output_path=None, force=True):\n self.first_game = first_game\n self.end_game = first_game + nb_games\n self.nb_checkpoints = nb_checkpoints\n self.input_path = input_path if input_path is not None else output_path\n self.output_path = output_path if output_path is not None else input_path\n self.force = force\n\n\n", "meta": {"hexsha": "a65aacc81d1a0149eea8c9bff42f8b8d173110bb", "size": 19579, "ext": "py", "lang": "Python", "max_stars_repo_path": "param.py", "max_stars_repo_name": "gaudel/ranking_bandits", "max_stars_repo_head_hexsha": "1fe4a38b17a3bb7ccab3ae0f4d0afb70fe54dbc9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-07-22T14:46:01.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-23T08:55:01.000Z", "max_issues_repo_path": "param.py", "max_issues_repo_name": "gaudel/ranking_bandits", "max_issues_repo_head_hexsha": "1fe4a38b17a3bb7ccab3ae0f4d0afb70fe54dbc9", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "param.py", "max_forks_repo_name": "gaudel/ranking_bandits", "max_forks_repo_head_hexsha": "1fe4a38b17a3bb7ccab3ae0f4d0afb70fe54dbc9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 46.7279236277, "max_line_length": 161, "alphanum_fraction": 0.6581030696, "include": true, "reason": "import numpy", "num_tokens": 5294, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5428632831725052, "lm_q2_score": 0.3593641588823761, "lm_q1q2_score": 0.19508560714541248}} {"text": "\"\"\"\nCode for top level interface.\n\nThis code is added to the main package level in __init__.py\n\"\"\"\nimport numpy as np\nimport abcgan.constants as const\nimport abcgan.transforms as trans\nfrom abcgan import persist\nfrom abcgan.mask import mask_altitude\nfrom abcgan.transforms import compute_valid, compute_valid_hfp\nimport torch\nimport h5py\nfrom tqdm import tqdm\nfrom warnings import warn\n\n\ndef generate(drivers, measurements=None,\n driver_names=const.driver_names, n_alt=const.max_alt,\n bv_model='bv_gan', hfp_model='hfp_gan', bv_type='radar',\n generate_hfps=False, return_z_scale=False, cuda_index=None,\n verbose=1):\n \"\"\"\n Generate background variable profiles and HFP waves\n consistent with the historical distribution.\n\n Parameters\n -------------\n drivers: np.ndarray\n n_samples x n_drivers input list of driving parameters (not z-scaled).\n driver_names: list\n list of names of driving parameters\n measurements: np.ndarray, optional\n n_samples x n_alt_in x n_meas input list of altitude measurements,\n n_alt_in should be less than n_alt. These represent fixed\n measurements for the lowest altitudes to condition on.\n Usually left as default (None)\n n_alt: int, optional\n number of altitude measurements to draw, defaults to max_alt\n return_z_scale: bool, optional\n set to have the function return z scaled feature data\n bv_model: str, optional\n name of bv GAN to use\n bv_type: str. optional\n name of the type of background variables to use (lidar or radar)\n hfp_model: str, optional\n name of hfp GAN to use\n generate_hfps: bool, optional\n Set to generate hfps and return generated hfps\n cuda_index: int, optional\n GPU index to use when generating BVs and HFPs\n verbose: bool, optional\n set to show loading bar\n Returns\n -------------\n samples: (np.ndarray, np.ndarray, np.ndarray)\n 1) n_samples x n_alt x n_bvs output measurements at each requested altitude.\n 2) n_samples x n_hfps generated hfp waves\n 3) n_sample probabilities that the generated wave is present\n \"\"\"\n\n with torch.no_grad():\n disable1 = bool(verbose < 1)\n if n_alt > const.max_alt and bv_type == 'radar':\n raise ValueError(f\"Requested {n_alt} altitudes but only {const.max_alt}\"\n f\" can be simulated for {bv_type}.\")\n elif n_alt > const.max_alt_lidar and bv_type == 'lidar':\n raise ValueError(f\"Requested {n_alt} altitudes but only {const.max_alt_lidar}\"\n f\" can be simulated for {bv_type}.\")\n if bv_type == 'lidar':\n n_bv = const.n_lidar_bv\n else:\n n_bv = const.n_bv\n\n if measurements is None:\n # put placeholder measurements if none provided\n measurements = np.zeros((drivers.shape[0], 0, n_bv))\n\n n_batch = drivers.shape[0]\n n_alt_start = measurements.shape[1]\n\n # verify the correct shapes for the inputs\n if drivers.shape != (n_batch, len(driver_names)):\n raise ValueError(f\"driver and driver_names must have the \"\n f\"same length ({drivers.shape[-1]} != {len(driver_names)}\")\n if measurements.shape != (n_batch, n_alt_start, n_bv):\n raise ValueError(f\"Measurement shape must be n_batch x \"\n f\"{n_alt_start} x {n_bv}.\")\n\n # z scale inputs and place into tensors\n driver_feat = trans.scale_driver(drivers, driver_names=driver_names)\n bv_feat, valid_mask = trans.scale_bv(measurements, bv_type)\n driver_feat = torch.tensor(driver_feat, dtype=torch.float)\n bv_feat = torch.tensor(bv_feat, dtype=torch.float)\n bv_feat, alt_mask = mask_altitude(bv_feat)\n hfp_feats = torch.zeros(len(drivers), const.n_waves, const.n_hfp_feat)\n G_b = torch.zeros(len(drivers))\n\n if torch.cuda.is_available() and cuda_index is not None:\n device = torch.device('cuda:' + str(cuda_index))\n if len(drivers) >= 500:\n batch_size = 500\n else:\n batch_size = len(drivers)\n else:\n device = torch.device('cpu')\n if len(drivers) >= 100:\n batch_size = 100\n else:\n batch_size = len(drivers)\n\n batch_idxs = np.hstack((np.arange(0, len(drivers), step=batch_size), [len(drivers)]))\n\n # Load bv models\n bv_gen, _ = persist.recreate(name=bv_model)\n if bv_gen.transformer.dr_emb.shape[0] != driver_feat.shape[-1]:\n raise ValueError(f\"Model must be trained with \"\n f\"{driver_feat.shape[-1]} drivers.\")\n bv_gen.to(device)\n bv_gen.eval()\n\n # iteratively build altitude profile\n for i in tqdm(range(len(batch_idxs) - 1), desc='Generate BV Profile', disable=disable1):\n for i_alt in range(n_alt_start, n_alt):\n dr_src = driver_feat[batch_idxs[i]:batch_idxs[i + 1]].to(device)\n bv_src = bv_feat[batch_idxs[i]:batch_idxs[i + 1]].to(device)\n\n bv_out = bv_gen(dr_src, bv_src)\n # fill in next altitude\n bv_feat[batch_idxs[i]:batch_idxs[i + 1], i_alt, :] = bv_out[:, i_alt, :].detach().cpu()\n G_bv_feats = bv_feat[:, :n_alt, :]\n G_bvs = trans.get_bv(bv_feat[:, :n_alt, :].numpy(), bv_type)\n if measurements is not None:\n G_bvs[:, :n_alt_start, :] = measurements\n bv_gen.cpu()\n\n if generate_hfps:\n # Load hfp GAN\n hfp_gen, _ = persist.recreate(name=hfp_model)\n hfp_gen.to(device)\n hfp_gen.eval()\n\n # Generate waves\n for i in tqdm(range(len(batch_idxs) - 1), desc='Generate HFP Batches', disable=disable1):\n dr_src = driver_feat[batch_idxs[i]:batch_idxs[i + 1]].to(device)\n gbv_src = G_bv_feats[batch_idxs[i]:batch_idxs[i + 1]].to(device)\n hfp_tgt = hfp_feats[batch_idxs[i]:batch_idxs[i + 1]].to(device)\n\n hfp_out, gb = hfp_gen(dr_src, gbv_src, hfp_tgt)\n hfp_feats[batch_idxs[i]:batch_idxs[i + 1], ...] = hfp_out.detach().cpu()\n G_b[batch_idxs[i]:batch_idxs[i + 1]] = gb.detach().cpu()\n G_hfps_feats = hfp_feats.numpy()\n G_hfps = trans.get_hfp(hfp_feats.numpy())\n G_b = G_b.numpy()\n\n if generate_hfps:\n if return_z_scale:\n return G_bv_feats.numpy(), G_hfps_feats, G_b\n else:\n return G_bvs, G_hfps, G_b\n else:\n if return_z_scale:\n return G_bv_feats.numpy()\n else:\n return G_bvs\n\n\ndef generate_multi(drivers, bvs=None, n_repeat=10,\n bv_model='bv_gan', hfp_model='hfp_gan',\n bv_type='radar', generate_hfps=False,\n cuda_index=None, verbose=1):\n \"\"\"\n Generate multiple background variable profiles and HFP waves\n consistent with the historical distribution for each driver sample\n\n Parameters\n -------------\n drivers: np.ndarray\n n_samples x n_drivers input list of driving parameters (not z-scaled).\n bvs: np.ndarray, optional\n n_samples x n_alt_in x n_meas input list of altitude measurements,\n n_alt_in should be less than n_alt. These represent fixed\n measurements for the lowest altitudes to condition on.\n Usually left as default (None)\n n_repeat: int, optional\n number of bv profiles/waves to generate for each driver sample\n bv_model: str, optional\n name of bv GAN to use\n bv_type: str. optional\n name of the type of background variables to use (lidar or radar)\n hfp_model: str, optional\n name of hfp GAN to use\n generate_hfps: bool, optional\n Set to generate hfps and return generated hfps\n cuda_index: int, optional\n GPU index to use when generating BVs and HFPs\n verbose: bool, optional\n set to show loading bar\n Returns\n -------------\n samples: (np.ndarray, np.ndarray, np.ndarray)\n 1) (n_samples x n_repeat x n_alt x n_bvs) output measurements at each requested altitude.\n 2) (n_samples x n_repeat x 1 x n_hfps) generated hfp waves\n 3) (n_sample x n_repeat) probabilities that the generated wave is present\n \"\"\"\n disable = bool(verbose < 1)\n G_bvs = np.zeros((len(drivers), n_repeat, const.max_alt, const.n_bv))\n G_hfps = np.zeros((len(drivers), n_repeat, const.n_waves, const.n_hfp))\n G_b = np.zeros((len(drivers), n_repeat))\n\n for i in tqdm(range(len(drivers)), desc='Generating Samples', disable=disable):\n sampled_driver = drivers[[i], ...].repeat(n_repeat, 0)\n if bvs is not None:\n sampled_bv = bvs[[i], ...].repeat(n_repeat, 0)\n else:\n sampled_bv = None\n if generate_hfps:\n gen_data = generate(sampled_driver,\n measurements=sampled_bv,\n bv_model=bv_model,\n hfp_model=hfp_model,\n bv_type=bv_type,\n generate_hfps=True,\n cuda_index=cuda_index,\n verbose=False)\n G_bvs[i, ...] = gen_data[0]\n G_hfps[i, ...] = gen_data[1]\n G_b[i, ...] = gen_data[2]\n else:\n G_bvs[i, ...] = generate(sampled_driver,\n measurements=sampled_bv,\n bv_model=bv_model,\n hfp_model=hfp_model,\n bv_type=bv_type,\n generate_hfps=False,\n cuda_index=cuda_index,\n verbose=False)\n if generate_hfps:\n return G_bvs, G_hfps, G_b\n else:\n return G_bvs\n\n\ndef discriminate(drivers, bvs, hfps=None,\n driver_names=const.driver_names,\n bv_model='bv_gan', hfp_model='hfp_gan',\n bv_type='radar'):\n \"\"\"\n Score how well the measurements match with historical observations.\n\n Parameters\n -------------\n drivers: np.ndarray\n n_samples x n_drivers input list of driving parameters (not z-scaled).\n driver_names: list\n list of names of driving parameters\n bvs: np.ndarray\n n_samples x n_alt_in x n_meas input list of altitude measurements,\n n_alt_in should be less than max_alt.\n hfps: np.ndarray, optional\n n_samples x n_wave x n_hfps input list of wave measurements,\n bv_model: str, optional\n name of bv model to use\n hfp_model: str, optional\n name of model hfp to use\n bv_type: str. optional\n name of the type of background variables to use (lidar or radar)\n Returns\n -------------\n scores: (np.ndarray, np.ndarray)\n 1) n_samples x n_alt bv normalcy scores in the range [0, 1.0].\n 2) n_samples hfp wave normalcy scores in the range [0, 1.0].\n \"\"\"\n warn(f'The discriminate function is deprecated. Does not produce credible results '\n f'outside of the training process. Please use the anomaly modules in place of'\n f'the discriminator', DeprecationWarning, stacklevel=2)\n with torch.no_grad():\n n_batch, n_alt = bvs.shape[:2]\n _, bv_crit = persist.recreate(name=bv_model)\n bv_crit.eval()\n\n driver_feat = trans.scale_driver(drivers, driver_names)\n bv_feat, _ = trans.scale_bv(bvs, bv_type)\n\n if bv_crit.transformer.dr_emb.shape[0] != driver_feat.shape[-1]:\n raise ValueError(f\"Model must be trained with \"\n f\"{driver_feat.shape[-1]} drivers.\")\n\n driver_feat = torch.tensor(driver_feat, dtype=torch.float)\n bv_feat = torch.tensor(bv_feat, dtype=torch.float)\n bv_feat, alt_mask = mask_altitude(bv_feat)\n\n # Get bvs scores\n bv_scores = bv_crit(bv_feat, driver_feat, bv_feat, ~alt_mask)\n bv_scores = bv_scores.view(n_batch, -1)[:, :n_alt].cpu().numpy()\n\n if hfps is not None:\n if hfps.shape[-1] != const.n_hfp:\n raise ValueError(f\"HFPs data must have \"\n f\"{const.n_hfp} features.\")\n\n _, hfp_crit = persist.recreate(name=hfp_model)\n hfp_crit.eval()\n hfp_feat, _ = trans.scale_hfp(hfps)\n hfp_feat = torch.tensor(hfp_feat, dtype=torch.float)\n\n # Get hfp scores\n hfp_scores = hfp_crit(driver_feat, bv_feat, hfp_feat, hfp_feat, ~alt_mask)\n hfp_scores = hfp_scores.view(n_batch, -1).cpu().numpy()\n\n if hfps is None:\n return bv_scores\n else:\n return bv_scores, hfp_scores\n\n\ndef estimate_drivers(drivers, model='dr_gan'):\n \"\"\"\n Predict drivers 2 hours into the future driver GAN model. Used for real-time\n background predictions using drivers from 2 hours ago.\n\n Parameters\n -------------\n drivers: np.ndarray\n n_samples x n_drivers input list of driving parameters (not z-scaled).\n model: str, optional\n name of model to use\n\n Returns\n -------------\n predicted_drivers: np.ndarray\n estimation of driver features two hours from the drivers inputted\n \"\"\"\n driver_feats = torch.tensor(trans.scale_driver(drivers), dtype=torch.float)\n dr_gen, _ = persist.recreate(name=model)\n dr_gen.eval()\n\n with torch.no_grad():\n predicted_feats = dr_gen(driver_feats)\n\n predicted_drivers = trans.get_driver(predicted_feats.cpu().numpy())\n return predicted_drivers\n\n\ndef hellinger_scores_bv(real, fake, mask=None, bins=None, filter_length=None,\n return_hist_info=False, z_scale=True, bv_type='radar'):\n \"\"\"\n Returns the hellinger distance score that measures how similarity between\n real and generated background variable profiles.\n ----------------\n real: np.ndarray\n tensor of real values for a particular alt and bv feat\n fake: np.ndarray\n tensor of generated values for a particular alt and bv feat\n bins: int\n number of bins to use in histogram calculations\n (If None # of bins will be calculated based on number of samples)\n filter_length: int\n averaging filter length to smooth out noise in histograms\n (If None filter length will be calculated based on number of samples)\n return_hist_info: bool\n set to have function return the histograms and bin edges used which\n were used to calculate the hellinger distance metric.\n bv_type:\n type of data (radar or lidar)\n Returns\n -------------\n dist:\n the hellinger distance (n_alts x n_feats)\n \"\"\"\n if mask is None:\n mask = np.ones((real.shape[0], real.shape[1]), dtype=bool)\n\n if bins is None:\n bins = max(15, int((real.shape[0])**const.bin_exp))\n if filter_length is None:\n filter_length = max(2, int(len(real)**const.filter_exp))\n\n dists = np.zeros((real.shape[1], real.shape[2]))\n r_hists = np.zeros((bins, real.shape[1], real.shape[2]))\n f_hists = np.zeros((bins, real.shape[1], real.shape[2]))\n edges = np.zeros((bins + 1, real.shape[1], real.shape[2]))\n\n for i in range(real.shape[1]):\n for j in range(real.shape[2]):\n if z_scale:\n r = trans.scale_bv(real, bv_type)[0][mask[:, i], i, j]\n f = trans.scale_bv(fake, bv_type)[0][mask[:, i], i, j]\n args = {'bins': bins, 'range': (-3, 3), 'density': True}\n else:\n r = real[mask[:, i], i, j]\n f = fake[mask[:, i], i, j]\n args = {'bins': bins, 'range': (const.bv_thresholds[j, 0], const.bv_thresholds[j, 1]),\n 'density': True}\n r_hist, edg = np.histogram(r, **args)\n f_hist, edg = np.histogram(f, **args)\n if filter_length:\n r_hist = np.convolve(r_hist, np.ones(filter_length), mode='same') / filter_length\n f_hist = np.convolve(f_hist, np.ones(filter_length), mode='same') / filter_length\n r_area = r_hist * np.diff(edg)\n f_area = f_hist * np.diff(edg)\n dists[i, j] = (1 / np.sqrt(2)) * np.sqrt(np.sum((np.sqrt(r_area) - np.sqrt(f_area)) ** 2))\n r_hists[:, i, j] = r_hist\n f_hists[:, i, j] = f_hist\n edges[:, i, j] = edg\n\n if return_hist_info:\n return dists, (r_hists, f_hists, edges)\n else:\n return dists\n\n\ndef hellinger_scores_hfp(real, fake, r_mask=None, f_mask=None,\n bins=None, filter_length=None, z_scale=True,\n return_hist_info=False):\n \"\"\"\n Returns the hellinger distance score that measures the similarity between\n real and generated background variable profiles.\n ----------------\n real:\n tensor of real values for a particular alt and bv feat\n fake:\n tensor of generated values for a particular alt and bv feat\n bins:\n tensor of real values for a particular alt and bv feat\n filter_length:\n averaging filter length to smooth out histograms\n z_scale: bool\n used z-scaled values (recommended)\n return_hist_info: bool\n set to have function return the real hist,\n fake hist, and bin edges used in calculation\n Returns\n -------------\n dist:\n the hellinger distance (n_alts or n_waves x n_feats)\n \"\"\"\n if r_mask is None:\n r_mask = np.ones((real.shape[0], real.shape[1]), dtype=bool)\n if f_mask is None:\n f_mask = np.ones((fake.shape[0], fake.shape[1]), dtype=bool)\n\n if bins is None:\n bins = max(15, int(r_mask.sum() ** const.bin_exp))\n if filter_length is None:\n filter_length = max(2, int(r_mask.sum() ** const.filter_exp))\n\n dists = np.zeros((real.shape[1], real.shape[2]))\n r_hists = np.zeros((bins, real.shape[1], real.shape[2]))\n f_hists = np.zeros((bins, real.shape[1], real.shape[2]))\n edges = np.zeros((bins + 1, real.shape[1], real.shape[2]))\n\n for i in range(real.shape[1]):\n for j in range(real.shape[2]):\n if z_scale:\n r = trans.scale_hfp(real)[0][r_mask[:, i], i, j]\n f = trans.scale_hfp(fake)[0][f_mask[:, i], i, j]\n args = {'bins': bins, 'range': const.hfp_z_ranges[j], 'density': True}\n else:\n r = real[r_mask[:, i], i, j]\n f = fake[f_mask[:, i], i, j]\n args = {'bins': bins,\n # 'range': (min(np.min(r), np.min(f)), max(np.max(r), np.max(f))),\n 'range': (const.hfp_thresholds[j, 0], const.hfp_thresholds[j, 1]),\n 'density': True}\n r_hist, edg = np.histogram(r, **args)\n f_hist, edg = np.histogram(f, **args)\n if filter_length:\n r_hist = np.convolve(r_hist, np.ones(filter_length), mode='same') / filter_length\n f_hist = np.convolve(f_hist, np.ones(filter_length), mode='same') / filter_length\n r_area = r_hist * np.diff(edg)\n f_area = f_hist * np.diff(edg)\n dists[i, j] = (1 / np.sqrt(2)) * np.sqrt(np.sum((np.sqrt(r_area) -\n np.sqrt(f_area)) ** 2))\n r_hists[:, i, j] = r_hist\n f_hists[:, i, j] = f_hist\n edges[:, i, j] = edg\n\n if return_hist_info:\n return dists, (r_hists, f_hists, edges)\n else:\n return dists\n\n\ndef stack_drivers(driver_dict, driver_names=const.driver_names):\n \"\"\"\n Stacks drivers in appropriate format.\n\n This function is provided for convenience.\n\n\n Parameters\n ----------------\n driver_dict: dict\n Dictionary mapping names of drivers to the numpy arrays\n with values for those drivers. Each array has a single\n dimension of the same length n_samples.\n Can also use an `h5py.Group`.\n driver_names: list\n names of the drivers to load\n\n Valid names for drivers can be found at `abcgan.driver_names`\n\n Raises\n ------------------\n ValueError:\n If the driver values have the wrong type or shape.\n KeyError:\n If one of the required drivers is missing.\n \"\"\"\n if isinstance(driver_dict, h5py.Group):\n driver_dict = {k: v[()] for k, v in driver_dict.items()}\n shp = None\n for v in driver_dict.values():\n if not isinstance(v, np.ndarray):\n raise ValueError(f\"Values in driver_dict must have\"\n f\" type np.ndarray not {type(v)}.\")\n if shp is None:\n shp = v.shape\n if len(shp) != 1:\n raise ValueError(\"Driver dict values must have only one\"\n \" dimension for the number of samples.\")\n if shp != v.shape:\n raise ValueError(\"All values in driver_dict must have\"\n \" the same length.\")\n return np.stack([driver_dict[k] for k in driver_names],\n axis=-1)\n\n\ndef stack_bvs(bv_dict, bv_type='radar'):\n \"\"\"\n Stacks drivers in appropriate format.\n\n This function is provided for convenience.\n\n Parameters\n ----------------\n bv_dict: dict\n Dictionary mapping names of background variables\n to numpy arrays with values for those bvs. Each\n array should have shape n_sapmles x n_altitudes.\n Can also use `h5py.Group`.\n bv_type: str\n string specifying weather to stack radar or\n lidar data\n\n Valid names for drivers can be found at `abcgan.bv_names`\n\n Raises\n ------------------\n ValueError:\n If the input shape of the bv dict values is not corrects\n KeyError:\n If one of the required bvs is missing.\n \"\"\"\n if isinstance(bv_dict, h5py.Group):\n bv_dict = {k: v[()] for k, v in bv_dict.items()}\n shp = None\n for v in bv_dict.values():\n if not isinstance(v, np.ndarray):\n raise ValueError(f\"Values in bv_dict must have\"\n f\" type np.ndarray not {type(v)}.\")\n if shp is None:\n shp = v.shape\n if len(shp) != 2:\n raise ValueError(\"BV dict values must have 2 \"\n \"dimensions [n_samples x n_altitudes].\")\n if shp != v.shape:\n raise ValueError(\"All values in bv_dict must have the\"\n \" same shape.\")\n if bv_type == 'lidar':\n bvs = np.stack([bv_dict[k] for k in const.lidar_bv_names],\n axis=-1)[:, :const.max_alt_lidar, :]\n else:\n bvs = np.stack([bv_dict[k] for k in const.bv_names],\n axis=-1)[:, 26:26 + const.max_alt, :]\n return bvs\n\n\ndef load_h5_data(fname, bv_type='radar', load_hfp=False, n_samples=None):\n \"\"\"\n loads and returns external drivers, background variables, HFP waves and data\n mask all aligned in time with outlier/invalid data filtered out\n\n Parameters\n -------------\n fname: str\n name of h5 file to load the data from\n bv_type: str. optional\n name of the type of background variables to use (lidar or radar)\n load_hfp: bool. optional\n set to load HFP waves along with the background variables\n n_samples: int. optional\n number of samples to load (None to load all samples)\n Returns\n -------------\n drivers: np.ndarray\n (n_samples x n_dr) external drivers.\n bvs: np.ndarray\n (n_samples x n_alt x n_bv) background variables.\n alt_mask: np.ndarray\n (n_samples x n_alt) background variables alt mask.\n hfps: np.ndarray\n (n_samples x 1 x n_hpf) HPF waves.\n wave_mask: np.ndarray\n (n_samples x 1) HFP wave mask.\n unix_time: np.ndarray\n (n_samples, ) time stamp of each sample\n \"\"\"\n with h5py.File(fname, 'r') as f:\n # --------------------------------------\n # Read driver and time stamps from file\n # --------------------------------------\n dr_dict = f['Drivers']\n unix_time = f['UnixTime'][()]\n drivers = np.stack([dr_dict[driver_name][:]\n for driver_name in const.driver_names\n if driver_name in dr_dict.keys()],\n axis=-1)\n # --------------------------------------\n # Read background variable data from file\n # --------------------------------------\n bv_dict = f['BackgroundValues']\n if bv_type == 'lidar':\n bvs = np.stack([bv_dict[bv_name][:]\n for bv_name in const.lidar_bv_names],\n axis=-1)[:, :const.max_alt_lidar, :]\n bv_thresholds = const.lidar_thresholds\n else:\n bvs = np.stack([bv_dict[bv_name][:]\n for bv_name in const.bv_names],\n axis=-1)[:, 26:26 + const.max_alt]\n bv_thresholds = const.bv_thresholds\n\n if load_hfp:\n # --------------------------------------\n # Read HFP data from file\n # --------------------------------------\n hfp_dict = f['HFPValues']\n hfps = np.stack([hfp_dict[hfp_name]\n for hfp_name in const.hfp_names\n if hfp_name in hfp_dict.keys()],\n axis=-1)\n hfps = hfps[:, None, :]\n\n # Get valid bvs and altitude mask\n valid_bv_mask = compute_valid(bvs, bv_thresholds)\n\n if load_hfp:\n valid_hfp_mask = compute_valid_hfp(hfps)\n valid_mask = valid_bv_mask & valid_hfp_mask & ~(np.isnan(drivers).any(-1))\n else:\n valid_mask = valid_bv_mask & ~(np.isnan(drivers).any(-1))\n\n # Filter out any invalid samples\n if n_samples is not None:\n drivers = drivers[valid_mask][:n_samples]\n bvs = bvs[valid_mask][:n_samples]\n unix_time = unix_time[valid_mask][:n_samples]\n else:\n drivers = drivers[valid_mask]\n bvs = bvs[valid_mask]\n unix_time = unix_time[valid_mask]\n\n # Get altitude mask for bvs\n _, alt_mask = mask_altitude(torch.tensor(bvs, dtype=torch.float))\n alt_mask = alt_mask.detach().numpy()\n\n if load_hfp:\n # Filter out invalid samples and get wave mask\n if n_samples is not None:\n hfps = hfps[valid_mask][:n_samples]\n else:\n hfps = hfps[valid_mask]\n wave_mask = ~(np.isnan(hfps).any(-1))\n\n return drivers, bvs, alt_mask, hfps, wave_mask, unix_time\n\n else:\n return drivers, bvs, alt_mask, unix_time\n", "meta": {"hexsha": "7342c1582227d3749ed4efd438c1a03a0e89f477", "size": 26876, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/abcgan/interface.py", "max_stars_repo_name": "sam-austin-sri/atmosense-abcgan", "max_stars_repo_head_hexsha": "b046676f70da69313126aaa323145af2a0e7b404", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/abcgan/interface.py", "max_issues_repo_name": "sam-austin-sri/atmosense-abcgan", "max_issues_repo_head_hexsha": "b046676f70da69313126aaa323145af2a0e7b404", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/abcgan/interface.py", "max_forks_repo_name": "sam-austin-sri/atmosense-abcgan", "max_forks_repo_head_hexsha": "b046676f70da69313126aaa323145af2a0e7b404", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-01-04T21:20:18.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-04T21:20:18.000Z", "avg_line_length": 39.4654919236, "max_line_length": 103, "alphanum_fraction": 0.5786947462, "include": true, "reason": "import numpy", "num_tokens": 6379, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5428632831725052, "lm_q2_score": 0.359364152021239, "lm_q1q2_score": 0.19508560342075307}} {"text": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Sat Aug 18 14:05:10 2018\n\n@author: yoelr\n\"\"\"\nfrom . import _Q\nimport numpy as np\nfrom .utils import property_array, PropertyFactory, DisplayUnits, \\\n tuple_array, fraction, Sink, Source, MissingStream\nfrom ._flowsheet import find\nfrom ._species import Species, WorkingSpecies\nfrom ._exceptions import SolverError, EquilibriumError, DimensionError\nfrom ._equilibrium import Dortmund, VLE, BubblePoint, DewPoint\n\n\n__all__ = ('Stream',)\n\n# %% TODOs\n\n# TODO: add material property interphase when using Cape Open package\n\n# %% Functions\n\ndef nonzero_species(species, flow):\n index_ = []\n IDs_ = []\n IDs = species._IDs\n for i in species._index:\n if flow[i] != 0:\n index_.append(i)\n IDs_.append(IDs[i])\n return index_, IDs_\n\ndef _print_helpdata(helpdata):\n \"\"\"Print help data.\"\"\"\n # Only one helplist, print a nice string\n if isinstance(helpdata[0], str):\n propID, description, dependency, units, datatype = helpdata\n if dependency == 'TP':\n dependency = 'as a function of T and P '\n elif dependency == 'T':\n dependency = 'as a function of T '\n elif dependency == 'P':\n dependency = 'as a function of P '\n print(f\"{propID}: [{datatype}] {description.capitalize()} \"\n \"{dependency}({units}).\")\n\n # Many helpdata, print all the nice strings\n else:\n for i in helpdata:\n _print_helpdata(i)\n\n\n# %% Units of measure\n\n# Biosteam units of measure\nunits_of_measure = dict(cost='USD/hr',\n MW='g/mol',\n mass='kg/hr',\n mol='kmol/hr',\n vol='m^3/hr',\n massnet='kg/hr',\n molnet='kmol/hr',\n volnet='m^3/hr',\n massfrac='kg/kg',\n molfrac='kmol/kmol',\n volfrac='m^3/m^3',\n T='K',\n P='Pa',\n H='kJ/hr',\n S='kJ/hr',\n G='kJ/hr',\n U='kJ/hr',\n A='kJ/hr',\n Hf='kJ/hr',\n C='kJ/K/hr',\n Vm='m^3/mol',\n Cpm='J/mol/K',\n Cp='J/g/K',\n rho='kg/m^3',\n rhom='mol/m^3',\n nu='m^2/s',\n mu='Pa*s',\n sigma='N/m',\n k='W/m/K',\n alpha='m^2/s')\n\nmol_flow_dim = _Q(0, units_of_measure['mol']).dimensionality\nmass_flow_dim = _Q(0, units_of_measure['mass']).dimensionality\nvol_flow_dim = _Q(0, units_of_measure['vol']).dimensionality\n\n# %% Flow properties\n\n@PropertyFactory\ndef MassFlow(self):\n \"\"\"Mass flow (kg/hr).\"\"\"\n return self.data[0][0] * self.data[1] # mol[0] * MW\n\n@MassFlow.setter\ndef MassFlow(self, value):\n self.data[0][0] = value/self.data[1] # mol[0] = value/MW\n\n@PropertyFactory \ndef VolumetricFlow(self):\n \"\"\"Volumetric flow (m^3/hr).\"\"\"\n stream, mol = self.data\n m = mol[0]\n if m:\n c = self.name # c = compound\n c.T = stream.T\n c.P = stream.P\n c.phase = stream._phase\n return c.Vm * m * 1000\n else:\n return 0.\n\n@VolumetricFlow.setter\ndef VolumetricFlow(self, value):\n stream, mol = self.data\n if value:\n c = self.name # c = compound\n c.T = stream.T\n c.P = stream.P\n c.phase = stream._phase\n mol[0] = value/(c.Vm * 1000)\n else:\n mol[0] = 0.\n\nphases = ('s', 'l', 'L', 'g')\nphase_index = dict(zip(phases, (0, 1, 2, 3)))\n\ndef flow(fget):\n def fset(self, value):\n if fget(self) is not value: raise AttributeError(f\"can't set attribute\")\n return property(fget, fset)\n\n\n# %% Stream classes\n\nclass metaStream(type):\n \"\"\"Metaclass for Stream.\"\"\"\n @property\n def species(cls):\n \"\"\"[Species] Contains pure component thermodynamic properties for computing overall properties of Stream instances.\"\"\"\n return cls._cls_species\n @species.setter\n def species(cls, species):\n # Set Species object and related parameters\n if isinstance(species, Species):\n Stream._cls_species = WorkingSpecies(species)\n elif isinstance(species, WorkingSpecies):\n Stream._cls_species = species\n else: raise ValueError('must pass a Species object')\n _species = species\n @property\n def indices(self):\n return self._cls_species.indices\n @property\n def index(self):\n return self._cls_species.index\n @property\n def MW(cls):\n return cls._MW\n\nclass Stream(metaclass=metaStream):\n \"\"\"Create a Stream object that defines material flow rates along its thermodynamic state. Thermodynamic and transport properties of a stream are readily available. Ideal mixture is assumed for stream properties and excess thermodynamic energies are neglected as a simplifying assumption for low pressure processes.\n\n Parameters\n ----------\n ID='' : str, defaults to a unique ID\n A unique identification. If ID is None, stream will not be\n registered in flowsheet.\n\n flow=() : tuple, optional\n All flow rates corresponding to `species`.\n\n species=() : tuple[str] or Species, defaults to Stream.species\n Species corresponding to `flow`.\n\n units='kmol/hr' : str, optional\n Flow rate units of measure (only mass, molar, and\n volumetric flow rates are valid)\n\n phase='l' : {'l', 'g', 's'}, optional\n Either gas (\"g\"), liquid (\"l\"), or solid (\"s\").\n\n T=298.15 : float, optional\n Temperature (K).\n\n P=101325 : float, optional\n Pressure (Pa).\n\n price=0 : float, optional\n Price in USD/kg.\n \n **flow_pairs : float\n Compound-flow pairs\n\n Examples\n --------\n Before making a stream, set the species using a Species object:\n\n .. code-block:: python\n\n >>> # Set Species object\n >>> Stream.species = Species('Ethanol', 'Water') \n\n Stream objects may be created a variety of ways:\n\n .. code-block:: python\n\n >>> # Create a stream specifying compound and flow rate pairs:\n >>> s1 = Stream(ID='s1', Water=2)\n >>> s1.show()\n Stream: s1\n phase: 'l', T: 298.15 K, P: 101325 Pa\n flow (kmol/hr): Water 2\n\n >>> # Create a stream assuming same order as given in species:\n >>> s2 = Stream(ID='s2', flow=(1, 2))\n >>> s2.show()\n Stream: s2\n phase: 'l', T: 298.15 K, P: 101325 Pa\n flow (kmol/hr): Ethanol 1\n Water 2\n\n >>> # Create a stream passing flow rate units, phase, temperature and pressure:\n >>> s3 = Stream(ID='s3', flow=(0.278, 0.556), units='mol/s', phase='g', T=400, P=101325)\n >>> s3.show()\n Stream: s3\n phase: 'g', T: 400 K, P: 101325 Pa\n flow (kmol/hr): Ethanol 1.\n Water 2.\n\n >>> # The working units do not change\n >>> s3.mol \n array([1., 2.])\n\n .. Warning:: Stream objects do not automatically calculate thermodynamic equilibrium. They simply assume the given phase, temperature and pressure are correct. To find equilibrium, use the VLE or LLE method.\n\n Use the `show` method to print all specifications with desired units:\n\n .. code-block:: python\n\n >>> # Temperature in degree Celsius\n >>> s2.show(T='degC')\n Stream: s2 \n phase: 'l', T: 25. degC, P: 101325 Pa\n flow (kmol/hr): Ethanol 1\n Water 2\n \n >>> # Flow in kg/hr\n >>> s2.show(flow='kg/hr')\n Stream: s2 \n phase: 'l', T: 298.15 K, P: 101325 Pa\n flow (kg/hr): Ethanol 46.1\n Water 36\n\n >>> # Flow in fractions\n >>> s2.show(fraction=True)\n Stream: s2\n phase: 'l', T: 298.15 K, P: 101325 Pa\n flow: Ethanol 0.333\n Water 0.667\n net 3 kmol/hr\n\n Flow rates are stored internally as an array in the ‘mol’ attribute.\n\n .. code-block:: python\n\n >>> # Set Water flow rate\n >>> s2.mol[1] = 18\n >>> s2.mol # kmol/hr\n array([1, 18])\n\n Mass and volumetric flow rates are also available as property_arrays of the molar flow rate. As such, they are always up to date with the molar flow rate and altering them also alters the molar flow rate:\n\n .. code-block:: python\n\n >>> # Altering mass or volumetric flows alters the molar flow\n >>> s2.vol # m^3/hr\n property_array([0.059, 0.036])\n >>> s2.vol[:] = [1, 1]\n >>> s2.mol\n array([17.06 , 55.343])\n >>> # Values are always up to date with the molar flow\n >>> s2.mol[:] = [1, 2]\n >>> s2.vol\n property_array([0.059, 0.036])\n\n .. Note::\n\n property_array objects are significantly slower than array objects. This is because flow rate data is internally stored as molar flow rates. Also, property_array objects are arrays of python objects, which add overhead over the C implementation of numpy. Whenever possible, use the array to manage flow rates. \n\n Some thermodynamic/material properties, including enthalpy and heat capacity, are dependent only on temperature:\n\n .. code-block:: python\n \n >>> s2.T = 298.15\n >>> s2.Cp # Heat capacity (kJ/(kg-K))\n 3.200382054794244\n >>> s2.H # Enthalpy (kJ/hr)\n 0.0\n \n >>> # Change of temperature\n >>> s2.T = 310\n >>> s2.H\n 3140.9389548625936\n >>> s2.Cp\n 3.2590872180092956\n \n .. Note:: Thermodynamic energies are relative to 25 degC and 1 atm.\n \n Some thermodynamic/material properties, including volume and density, are dependent on both temperature and pressure:\n\n .. code-block:: python\n \n >>> s1.volnet # Volumetric flow rate (m^3/hr)\n 0.036138079740245625\n >>> s1.rho # Density (kg/m^3)\n 997.0247522552814\n \n >>> # Change of pressure\n >>> s1.P *= 4\n >>> s1.volnet\n 0.036136231155141196\n >>> s1.rho\n 997.0757560552587\n \n >>> # Change of temperature\n >>> s1.T += 30\n >>> s1.volnet\n 0.03663597700908213\n >>> s1.rho\n 983.4747955832584\n\n A dictionary of available stream properties and respective units of measure is available in `Stream.units`. You may also find it useful to use the `help` method to search for a property:\n \n .. code-block:: python\n\n >>> Stream.help('conductivity')\n k: [float] Thermal conductivity as a function of T and P (W/m/K).\n\n \"\"\"\n \n # [dict] Units of measure for material properties (class attribute). \n units = units_of_measure\n\n # Information regarding properties\n _prop_info = (\n # ID # Description # Dependency # Units # Type\n ('T', 'temperature', '', 'K', 'float'),\n ('H', 'enthalpy', 'T', 'kJ/hr', 'float'),\n ('S', 'entropy', 'TP', 'kJ/hr', 'float'),\n ('G', 'Gibbs free energy', 'TP', 'kJ/hr', 'float'),\n ('U', 'interal energy', 'TP', 'kJ/hr', 'float'),\n ('A', 'Helmholtz free energy', 'TP', 'kJ/hr', 'float'),\n ('Hf', 'enthalpy of formation', '', 'kJ/hr', 'float'),\n ('P', 'pressure', '', 'Pa', 'float'),\n ('Cpm', 'molar heat capacity', 'T', 'J/mol/K', 'float'),\n ('Cp', 'specific heat capacity', 'T', 'J/kg/K', 'float'),\n ('Vm', 'molar volume', 'TP', 'm^3/mol', 'float'),\n ('rho', 'density', 'TP', 'kg/m^3', 'float'),\n ('rhom', 'molar density', 'TP', 'mol/m^3', 'float'),\n ('nu', 'kinematic viscosity', 'TP', 'm^2/s', 'float'),\n ('mu', 'hydraulic viscosity', 'TP', 'Pa*s', 'float'),\n ('sigma', 'surface tension', 'T', 'N/m', 'float'),\n ('k', 'thermal conductivity', 'TP', 'W/m/K', 'float'),\n ('alpha', 'thermal diffusivity', 'TP', 'm^2/s', 'float'),\n ('Pr', 'Prantl number', 'TP', \"''\", 'float'),\n ('mass', 'mass flow rates', '', 'kg/hr', 'ndarray'),\n ('mol', 'molar flow rates', '', 'kmol/hr', 'ndarray'),\n ('vol', 'volumetric flow rates', 'TP', 'm^3/hr', 'ndarray'),\n ('massnet', 'net mass flow rate', '', 'kg/hr', 'float'),\n ('molnet', 'net molar flow rate', '', 'kmol/hr', 'float'),\n ('volnet', 'net volumetric flow rate', 'TP', 'm^3/hr', 'float'),\n ('massfrac', 'mass fractions', '', 'kg/kg', 'ndarray'),\n ('molfrac', 'molar fractions', '', 'kmol/kmol', 'ndarray'),\n ('volfrac', 'volumetric fractions', 'TP', 'm^3/m^3', 'ndarray'))\n\n __slots__ = ('T', 'P', '_mol', '_mass', '_vol', 'price', '_ID', '_link',\n '_species', '_sink', '_source', '_dew_point',\n '_bubble_point', '_gamma', '_phase', '_lL_split_cached',\n '__weakref__', '_source_link', '_VLE')\n\n line = 'Stream'\n\n ### Class attributes for working species ### \n _cls_species = _MW = None\n \n #: [str] Default ID for all streams (class attribute)\n default_ID = 'd'\n \n #: [int] Current number for default IDs (class attribute)\n default_ID_number = 0\n \n #: [bool] If True, approximate energy balance. False otherwise.\n lazy_energy_balance = True\n\n #: [DisplayUnits] Units of measure for IPython display\n display_units = DisplayUnits(T='K', P='Pa',\n flow=('kmol/hr', 'kg/hr', 'm3/hr'),\n fraction=False,\n N=5)\n\n def __init__(self, ID='', flow=(), species=(), units='kmol/hr',\n phase='l', T=298.15, P=101325, *, price=0, **flow_pairs):\n # Get species and set species information\n if isinstance(species, Species):\n self._species = WorkingSpecies(species)\n species = ()\n elif isinstance(species, WorkingSpecies):\n self._species = species\n species = ()\n else: \n assert self._cls_species, 'must define Stream.species first'\n self._species = self._cls_species\n self._link = self._ID = self._sink = self._source = None\n self._source_link = self\n self.phase = phase\n self.T = T #: [float] Temperature (K)\n self.P = P #: [float] Pressure (Pa)\n self.price = price #: Price of stream (USD/kg)\n \n # Initialize flows\n self._setflows(flow, species, flow_pairs)\n mol = self._mol\n MW = self._species._MW\n mass = [] # Mass flow rates\n vol = [] # Volumetric flow rates \n cmps = self._species._compounds\n for i in self._species._index:\n mol_i = mol[i:i+1]\n s = cmps[i]\n mass.append(MassFlow(s.ID, (mol_i, MW[i])))\n vol.append(VolumetricFlow(s, (self, mol_i)))\n self._mass = property_array(mass)\n self._vol = property_array(vol)\n if units == 'kmol/hr': pass\n if units == 'kg/hr': self._mass[:] = mol\n elif units == 'm3/hr': self._vol[:] = mol\n else:\n q = _Q(mol, units)\n dim = q.dimensionality\n if dim == mol_flow_dim:\n self._mol[:] = q.to('kmol/hr').magnitude\n elif dim == mass_flow_dim:\n self._mass[:] = q.to('kg/hr').magnitude\n elif dim == vol_flow_dim:\n self._vol[:] = q.to('m3/hr').magnitude\n else:\n raise DimensionError(f\"dimensions for flow units must be in molar, mass or volumetric flow rates, not '{dim}'\")\n self.ID = ID\n self._gamma = gamma = Dortmund()\n self._bubble_point = BubblePoint(gamma)\n self._dew_point = DewPoint(gamma)\n\n def setflow(self, flow=(), species=(), units='kmol/hr', inplace='', **flow_pairs):\n \"\"\"Set `flow` rates according to the `species` order and `flow_pairs`. `inplace` can be any operation that can be performed in place (e.g. +, -, *, /, |, **, etc.).\"\"\"\n species = (*species, *flow_pairs.keys())\n flow = (*flow, *flow_pairs.values())\n index = self.indices(species) if species else ... \n q = _Q(flow, units)\n dim = q.dimensionality\n if dim == mol_flow_dim:\n exec(f\"self._mol[index] {inplace}= q.to('kmol/hr').magnitude\", locals())\n elif dim == mass_flow_dim:\n exec(f\"self._mass[index] {inplace}= q.to('kg/hr').magnitude\", locals())\n elif dim == vol_flow_dim:\n exec(f\"self._vol[index] {inplace}= q.to('m3/hr').magnitude\", locals())\n else:\n raise DimensionError(f\"dimensions for flow units must be in molar, \"\n f\"mass or volumetric flow rates, not '{dim}'\")\n \n def getflow(self, *species, units='kmol/hr'):\n \"\"\"Get flow rates of species in given units.\"\"\"\n index = self.indices(species) if species else ...\n q = _Q(1, units)\n dim = q.dimensionality\n if dim == mol_flow_dim:\n return self._mol[index]*q.to('kmol/hr').magnitude\n elif dim == mass_flow_dim:\n return self._mass[index]*q.to('kg/hr').magnitude\n elif dim == vol_flow_dim:\n return self._vol[index]*q.to('m3/hr').magnitude\n else:\n raise DimensionError(f\"dimensions for flow units must be in molar, \"\n f\"mass or volumetric flow rates, not '{dim}'\")\n \n def _setflows(self, flow, species, flow_pairs):\n \"\"\"Initialize molar flow rates according to the species order, and flow_pairs. Instance species do not change.\"\"\"\n flowlen = len(flow)\n specieslen = len(species)\n if flowlen:\n if flow_pairs:\n raise ValueError('cannot specify both \"flow\" and '\n '\"flow_pairs\" when species is passed')\n elif flowlen == specieslen:\n self._mol = self._species.array(species, flow)\n elif (not specieslen) and (flowlen == self._species._N):\n self._mol = np.array(flow, float)\n else:\n raise ValueError('length of flow rates must be equal to '\n 'length of species')\n elif flow_pairs:\n self._mol = self._species.array(flow_pairs, [*flow_pairs.values()])\n else:\n self._mol = np.zeros(self.species._N, float)\n \n # Forward pipping\n def __sub__(self, index):\n if isinstance(index, int):\n return Sink(self, index)\n elif isinstance(index, Stream):\n raise TypeError(\"unsupported operand type(s) for -: \"\n f\"'{type(self)}' and '{type(index)}'\")\n return index.__rsub__(self)\n \n def __rsub__(self, index):\n if isinstance(index, int):\n return Source(self, index)\n elif isinstance(index, Stream):\n raise TypeError(\"unsupported operand type(s) for -: \"\n \"'{type(self)}' and '{type(index)}'\")\n return index.__sub__(self)\n\n # Backward pipping \n __pow__ = __sub__\n __rpow__ = __rsub__\n \n @property\n def phase(self):\n \"\"\"[str] 'l' for liquid, 'g' for gas, or 's' for solid.\"\"\"\n return self._phase\n @phase.setter\n def phase(self, phase):\n if phase not in ('l', 'g', 's'):\n raise ValueError(f\"phase must be either 's', 'l', or 'g'\")\n self._phase = phase\n \n @staticmethod\n def proxy(ID, link=MissingStream):\n \"\"\"Create a Stream object that serves as a proxy for its `link` stream.\"\"\"\n self = object.__new__(Stream)\n self._source = self._sink = self._ID = None\n self._source_link = MissingStream\n self.ID = ID\n self.price = 0\n if link: self.link = link\n else: self._link = MissingStream\n return self\n \n @property\n def link(self):\n \"\"\"When another Stream object is set as a link, it will share data with that object.\"\"\"\n return self._link\n \n @link.setter\n def link(self, stream):\n try:\n if self._source_link is stream._source_link:\n self._link = stream\n elif stream is None:\n self.__init__(ID=self._ID, flow=self._mol,\n species=self._species,\n T=self.T, P=self.P, phase=self._phase)\n else:\n self._species = stream._species\n self._mass = stream._mass\n self._mol = stream._mol\n self._vol = stream._vol\n self._dew_point = stream._dew_point\n self._bubble_point = stream._bubble_point\n self._gamma = stream._gamma\n self._source_link = stream._source_link\n self._link = stream\n self.P = stream.P\n self.T = stream.T\n self._phase = stream.phase\n except Exception as Error:\n if isinstance(stream, Stream): raise Error\n else: raise TypeError(f\"link must be a Stream object, not a \"\n \"'{type(stream).__name__}' object.\")\n \n @property\n def species(self):\n \"\"\"[Species] Contains pure component thermodynamic properties for computing overall properties of Stream instances.\"\"\"\n return self._species\n \n @property\n def ID(self):\n \"\"\"Unique identification (str). If set as '', it will choose a default ID.\"\"\"\n return self._ID\n\n @ID.setter\n def ID(self, ID):\n if ID == '':\n # Select a default ID\n self.__class__.default_ID_number += 1\n ID = self.default_ID + str(self.default_ID_number)\n self._ID = ID\n setattr(find.stream, ID, self)\n elif ID and ID != self._ID:\n setattr(find.stream, ID, self)\n\n @property\n def cost(self):\n \"\"\"Cost of stream (USD/hr)\"\"\"\n return self.price*self.massnet\n\n @property\n def MW(self):\n \"\"\"Molecular weight of all species (array g/mol): \n\n >>> from biosteam import *\n >>> Stream.species = Species('Water', 'Ethanol')\n >>> Stream.MW\n tuple_array([18.01528, 46.06844])\n \"\"\"\n return self._species._MW.view(tuple_array)\n\n ### Flow properties ###\n \n @property\n def indices(self):\n \"\"\"Return indices of specified species.\n\n Parameters\n ----------\n IDs : iterable\n Species IDs or CAS numbers.\n\n Examples\n --------\n Indices by ID:\n \n >>> from biosteam import *\n >>> Stream.species = Species(['Ethanol', 'Water'])\n >>> s1 = Stream()\n >>> s1.indices(['Water', 'Ethanol'])\n [1, 0]\n\n Indices by CAS number:\n \n >>> s1.indices(['7732-18-5', '64-17-5']):\n [1, 0]\n\n \"\"\"\n return self._species.indices\n \n @property\n def index(self):\n \"\"\"Return index of specified compound.\n\n Parameters\n ----------\n ID: str\n Compound ID\n\n Examples\n --------\n Index by ID:\n \n >>> from biosteam import *\n >>> Stream.species = Species(['Ethanol', 'Water'])\n >>> s1 = Stream()\n >>> s1.index('Water')\n 1\n\n Indices by CAS number:\n \n >>> s1.index('7732-18-5'):\n 1\n\n \"\"\"\n return self._species.index\n \n # Molar flow\n @flow\n def mol(self):\n \"\"\"Array of molar flow rates (kmol/hr):\n\n >>> from biosteam import *\n >>> Stream.species = Species('Water', 'Ethanol')\n >>> s1 = Stream(Ethanol=2)\n >>> s1.mol\n array([0, 2])\n >>> s1.mol[:] = [1, 2]\n >>> s1.mol\n array([1, 2])\n \"\"\"\n return self._mol\n\n @property\n def molfrac(self):\n \"\"\"Array of molar fractions.\n\n >>> from biosteam import *\n >>> Stream.species = Species('Water', 'Ethanol')\n >>> s1 = Stream(Ethanol=2)\n >>> s1.molfrac\n tuple_array([0., 1.])\n \"\"\"\n return fraction(self._mol).view(tuple_array)\n\n @property\n def molnet(self):\n \"\"\"Net molar flow rate (kmol/hr)\n\n >>> from biosteam import *\n >>> Stream.species = Species('Water', 'Ethanol')\n >>> s1 = Stream(Ethanol=2, Water=1)\n >>> s1.molnet\n 3\n \"\"\"\n return self._mol.sum()\n\n # Mass flow\n @flow\n def mass(self):\n \"\"\"Array of mass flow rates (kg/hr)\n\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Water=2)\n >>> s1.mass\n property_array([ 0. , 36.031])\n \"\"\"\n return self._mass\n\n @property\n def massfrac(self):\n \"\"\"Array of mass fractions.\n\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Water=2)\n >>> s1.massfrac\n tuple_array([0, 1])\n \"\"\"\n return fraction(self._mol * self._species._MW).view(tuple_array)\n\n @property\n def massnet(self):\n \"\"\"Net mass flow rate (kg/hr)\n\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Water=2)\n >>> s1.mass\n 36.031\n \"\"\"\n return (self._species._MW * self._mol).sum()\n\n # Volumetric flow\n @flow\n def vol(self):\n \"\"\"Array of volumetric flow rates as a function of T and P (m^3/hr).\n\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Water=2)\n >>> s1.vol\n property_array([0. , 0.036])\n \n \"\"\"\n return self._vol\n\n @property\n def volfrac(self):\n \"\"\"Array of volumetric fractions as a function of T and P.\n\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Water=2)\n >>> s1.volfrac\n tuple_array([0.0, 1.0], dtype=object)\n \"\"\"\n return fraction(self._vol).view(tuple_array)\n \n @property\n def volnet(self):\n \"\"\"Net volumetric flow rate as a function of T and P (m^3/hr).\n\n from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Water=2)\n >>> s1.volnet\n 0.036138079740245625\n \"\"\"\n return self._species._propflow('Vm', self._mol, self.T, self.P, self._phase)*1000\n\n ### Energy flows ###\n\n def H_at(self, mol=None, T=None, P=None, phase=None):\n \"\"\"Return enthalpy flow rate at given arguments, excluding formation energies (kJ/hr). Arguments with None values default to stream specifications.\"\"\"\n return self._species._propflow('H', mol or self._mol, T or self.T,\n P or self.P, phase or self._phase)\n\n # Enthalpy\n @property\n def H(self):\n \"\"\"Enthalpy flow rate as a function of T, excluding formation energies (kJ/hr).\n\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Water=2)\n >>> s1.H # The stream is at the reference state\n 0.0\n >>> s1.H = 1000\n >>> s1.T\n 304.7888167493753\n >>> s1.H\n 999.5728716085112\n\n .. Note:: The solver reaches a level of tolerance and the new temperature is an approximation.\n \"\"\"\n return self._species._propflow('H', self._mol, self.T, self.P, self._phase)\n\n @H.setter\n def H(self, H):\n try:\n if self.lazy_energy_balance:\n self.T += (H - self.H)/self.C \n else:\n # First approximation\n T_old = self.T\n C = self.C\n self.T += (H - self.H)/C\n \n # Solve enthalpy by iteration\n it = 0\n it2 = 0\n while abs(self.T - T_old) > 0.01:\n T_old = self.T\n self.T += (H - self.H)/C\n if it == 5:\n it = 0\n it2 += 1\n C = self.C\n if it2 > 10:\n raise SolverError(\"could not solve temperature \"\n \"given enthalpy\")\n else: it += 1\n except Exception as Error:\n if (self._mol == 0).all():\n raise ValueError(f\"cannot set enthalpy to empty stream\")\n else:\n raise Error\n\n @property\n def Hnet(self):\n \"\"\"Total enthaly flow rate including heats of formation\"\"\"\n return self.Hf + self.H\n\n @property\n def Hf(self):\n \"\"\"Heat of formation flow rate (kJ/hr).\n\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Water=2)\n >>> s1.Hf\n -483640.0\n \"\"\"\n return (self.mol * [i.Hf or 0 for i in self._species._compounds]).sum()\n\n @property\n def Hc(self):\n \"\"\"Heat of combustion flow rate (kJ/hr).\n\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Ethanol=2)\n >>> s1.Hc\n -2819966.0\n \"\"\"\n return (self.mol * [i.Hc or 0 for i in self._species._compounds]).sum()\n \n # Entropy\n @property\n def S(self):\n \"\"\"Entropy flow rate as a function of T and P, excluding formation energies (kJ/hr).\n\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Ethanol=2)\n >>> s1.S # The stream is at the reference state\n 0.0\n >>> s1.T = 320\n >>> s1.S\n 16.503899351682694\n \"\"\"\n return self._species._propflow('S', self._mol, self.T, self.P, self._phase)\n\n # Gibbs free energy\n @property\n def G(self):\n \"\"\"Gibbs free energy flow rate as a function of T and P, excluding formation energies (kJ/hr).\n\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Ethanol=2)\n >>> s1.G # The stream is at the reference state\n 0.0\n >>> s1.T = 320\n >>> s1.G\n -182.43024800100193\n \"\"\"\n return self.H - self.S*self.T\n\n # Internal energy\n @property\n def U(self):\n \"\"\"Internal energy flow rate as a function of T and P, excluding formation energies (kJ/hr).\n\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Ethanol=2)\n >>> s1.U # The stream is at the reference state\n 0.0\n >>> s1.T = 320\n >>> s1.U\n -7090.732710112934\n \"\"\"\n return self.H - self.P*self.volnet\n\n # Helmholtz\n @property\n def A(self):\n \"\"\"Helmholtz energy flow rate as a function of T and P, excluding formation energies (kJ/hr).\n\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Ethanol=2)\n >>> s1.A # The stream is at the reference state\n 0.0\n >>> s1.T = 320\n >>> s1.A\n -12371.980502651397\n \"\"\"\n return self.U - self.T*self.S\n\n # Capacity flow rate\n @property\n def C(self):\n \"\"\"Heat capacity flow rate as a function of T (kJ/K/hr).\n\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Ethanol=2)\n >>> s2.C\n 243.41704115214097\n \"\"\"\n return self._species._propflow('Cpm', self._mol, self.T, self.P, self._phase)\n\n # Material properties\n @property\n def Cp(self):\n \"\"\"Specific heat capacity as a function of T (kJ/kg/K).\n\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Ethanol=2)\n >>> s1.Cp\n 2.641906706110962\n \"\"\"\n return self.Cpm*self.molnet/self.massnet\n\n @property\n def Cpm(self):\n \"\"\"Molar heat capacity as a function of T (kJ/kmol/K).\n\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Ethanol=2)\n >>> s1.Cpm # (J/mol/K)\n 121.70852057607048\n \"\"\"\n return self.C/self.molnet\n\n @property\n def Vm(self):\n \"\"\"Molar volume as a function of T and P (m^3/mol).\n\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Ethanol=2)\n >>> s1.Vm\n 0.00012030150757118572\n \"\"\"\n return self._species._prop('Vm', self._mol, self.T, self.P, self._phase)\n\n @property\n def rho(self):\n \"\"\"Density as a function of T (kg/m^3).\n\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Ethanol=2)\n >>> s1.rho\n 765.8830039638536\n \"\"\"\n return self.massnet/self.volnet\n\n @property\n def rhom(self):\n \"\"\"Molar density as a function of T and P (mol/m^3).\n\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Ethanol=2)\n >>> s1.rhom\n 16.624895567634884\n \"\"\"\n return self.molnet/self.volnet\n\n @property\n def nu(self):\n \"\"\"Kinematic viscosity as a function of T and P (m^2/s).\n\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Ethanol=2)\n >>> s1.nu\n 5.733020843964377e-06\n \"\"\"\n return self.mu/self.rho\n\n @property\n def mu(self):\n \"\"\"Hydraulic viscosity as a function of T and P (Pa*s).\n\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Ethanol=2)\n >>> s1.mu\n 0.0010780252844121937\n \"\"\"\n # Katti, P.K.; Chaudhri, M.M. (1964). \"Viscosities of Binary Mixtures of Benzyl Acetate with Dioxane, Aniline, and m-Cresol\". Journal of Chemical and Engineering Data. 9 (1964): 442–443.\n # molfrac = self.molfrac\n # props = self._species._props\n # mus = np.array(props('mu', self._mol, self.T, self.P, self._phase))\n # Vms = np.array(props('mu', self._mol, self.T, self.P, self._phase))\n # pos = np.where(molfrac != 0)\n # return np.exp((molfrac[pos]*np.log(mus[pos]*Vms[pos])).sum())/self.Vm\n return self._species._prop('mu', self._mol, self.T, self.P, self._phase)\n\n @property\n def k(self):\n \"\"\"Thermal conductivity as a function of T and P (W/m/k).\n\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Ethanol=2)\n >>> s1.k\n 0.16476716002011285\n \"\"\"\n return self._species._prop('k', self._mol, self.T, self.P, self._phase)\n\n @property\n def alpha(self):\n \"\"\"Thermal diffusivity as a function of T and P (m^2/s).\n\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Ethanol=2)\n >>> s1.alpha\n 8.614274122585474e-08\n \"\"\"\n return self._species._prop('alpha', self._mol, self.T, self.P, self._phase)\n\n @property\n def sigma(self):\n \"\"\"Surface tension as a function of T (N/m).\n\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Ethanol=2)\n >>> s1.sigma\n 0.02188440412824106\n \"\"\"\n return self._species._prop('sigma', self._mol, self.T, self.P, self._phase)\n\n @property\n def Pr(self):\n \"\"\"Prandtl number as a function of T and P (non-dimensional).\n\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Ethanol=2)\n >>> s1.Pr\n 15.923321696004477\n \"\"\"\n return self._species._prop('Pr', self._mol, self.T, self.P, self._phase)\n\n @property\n def P_vapor(self):\n \"\"\"Vapor pressure (Pa), not taking into account light species always in gas phase.\n \n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Ethanol=2)\n >>> s1.P_vapor\n array([7872.1566667784855, 0 ])\n \"\"\"\n mol = self.mol\n species = self._species\n indices = species._equilibrium_indices(mol>0)\n compounds = species._compounds\n N = len(indices)\n P_vapor = np.zeros_like(mol)\n if N==0: return P_vapor\n species = [compounds[i] for i in indices]\n mol = self.mol[indices]\n x = mol/mol.sum()\n T = self.T\n Psat = [s.VaporPressure(T) for s in species]\n self._gamma.species = species\n P_vapor[indices] = x * Psat * self._gamma(x, T)\n return P_vapor\n \n # Other properties\n @property\n def source(self):\n \"\"\"Unit source.\"\"\"\n return self._source\n\n @property\n def sink(self):\n \"\"\"Unit sink.\"\"\"\n return self._sink\n\n @property\n def nonzero_species(self):\n \"\"\"Flow indices and species that have a non-zero flow rate.\n\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Water=2)\n >>> s1.nonzero_species\n [1], ['Water']\n \"\"\"\n return nonzero_species(self._species, self.mol)\n \n def quantity(self, prop_ID):\n \"\"\"Return a property as a Quantity object as described in the `pint package `__ \n\n Parameters\n ----------\n prop_ID : str\n Name of the property (e.g. 'mol', 'H', 'k' ...)\n\n Examples\n --------\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Ethanol=2)\n >>> s1.quantity('Cp')\n 2.4337467143619698 J/K/g\n\n \"\"\"\n attr = getattr(self, prop_ID)\n if isinstance(attr, np.ndarray):\n attr = np.array(attr.astype(float))\n return _Q(attr, self.units[prop_ID])\n\n # Derivative of a property and sensivity analysis\n def derivative(self, prop_ID, var_ID, index=None):\n \"\"\"Return the derivative of property 'prop_ID' and variable 'var_ID'. If the property given by var_ID is an array, use index to specify which element.\n\n Parameters\n ----------\n prop_ID : str\n Name of the property (e.g. 'rho', 'Cp', 'H', 'volnet' ...)\n var_ID : str\n Name of the variable (e.g 'T', 'P', 'molnet' ...)\n index : array_like, optional\n Indices if the variable is an array\n\n Examples\n --------\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Ethanol=2)\n >>> s1.derivative('rho', 'T')\n -0.8917376157800969\n\n \"\"\"\n if index is not None:\n def getvar():\n return getattr(self, var_ID)[index]\n\n def setvar(xf):\n getattr(self, var_ID)[index] = xf\n else:\n def getvar():\n return getattr(self, var_ID)\n\n def setvar(xf):\n setattr(self, var_ID, xf)\n x0 = getvar()\n y0 = getattr(self, prop_ID)\n xf = x0 + 10**-6\n setvar(xf)\n yf = getattr(self, prop_ID)\n setvar(x0)\n return (yf-y0)/(xf-x0)\n\n # Specifications\n @staticmethod\n def like(stream, ID=''):\n \"\"\"Create either a Stream or MixedStream object just like the given stream, depending on whether multiple phases are present.\"\"\"\n s = stream\n if isinstance(stream, MS.MixedStream):\n out = MS.MixedStream(ID,\n species=stream._species,\n T=s.T, P=s.P)\n out._molarray[:] = stream._molarray\n else:\n out = Stream(ID, flow=s._mol, species=s._species,\n phase=s._phase, T=s.T, P=s.P)\n return out\n \n def copylike(self, stream):\n \"\"\"Copy flow rates, T, P, and phase of stream to self.\n\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream()\n >>> s2 = Stream(Ethanol=1, Water=2, T=400, phase='g')\n >>> s1.copylike(s2)\n >>> s1.show()\n Stream: s1\n phase: 'g', T: 400.00 K, P: 101325 Pa\n flow (kmol/hr): Ethanol 1\n Water 2\n \"\"\"\n if isinstance(stream, MS.MixedStream):\n self.enable_phases()\n self.copylike(stream)\n elif not (self._species is stream._species):\n raise ValueError('species must be the same to copy stream specifications')\n else:\n self._mol[:] = stream.mol\n self.P = stream.P\n self._phase = stream.phase\n self.T = stream.T\n \n def copyflow(self, stream, species=None, *, remove=False, exclude=False):\n \"\"\"Copy flow rates of stream to self.\n \n Parameters\n ----------\n stream : Stream\n Flow rates will be copied from here.\n species=None : iterable[str], defaults to all species.\n Species IDs. \n remove=False: bool, optional\n If True, copied species will be removed from `stream`.\n exclude=False: bool, optional\n If True, exclude `species` when copying.\n \n Notes\n -----\n \n Species that are not included will be set to zero.\n \n \"\"\"\n assert self._species is stream._species, ('species must be the same to '\n 'copy stream specifications')\n if species is None:\n self._mol[:] = stream.mol\n if remove: stream._mol[:] = 0\n else:\n indices = self.indices(species)\n if exclude:\n self._mol[:] = stream.mol\n self._mol[indices] = 0\n if remove:\n mol = stream._mol\n if isinstance(stream, MS.MixedStream):\n mol[:], mol[:, indices] = 0, mol[:, indices]\n else:\n mol[:], mol[indices] = 0, mol[indices]\n else:\n self._mol[:] = 0\n self._mol[indices] = stream.mol[indices]\n if remove: \n if isinstance(stream, MS.MixedStream):\n stream._mol[phase_index[self.phase], indices] = 0\n else:\n stream._mol[indices] = 0\n\n def recieve_vent(self, stream, efficiency=1):\n assert self._species is stream._species, 'species must be the same to recieve vent'\n y = stream.P_vapor/self.P\n Y = y.sum()\n vent_mol = self._mol\n mol2vent = vent_mol.sum()*y*Y/(1-Y)*efficiency\n stream._mol[:] -= mol2vent\n vent_mol += mol2vent\n\n def empty(self):\n \"\"\"Set flow rates to zero\n\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Water=1)\n >>> s1.empty()\n >>> s1.mol\n array([0, 0])\n \"\"\"\n self._mol[:] = 0\n \n def bubble_T(self):\n \"\"\"Bubble point at current composition and pressure.\n\n Returns\n -------\n T : float\n Bubble point temperature (T).\n y : numpy.ndarray\n Vapor phase composition.\n indices : list[int]\n Indices of species in equilibrium\n \n Examples\n --------\n >>> from biosteam import *\n >>> stream = Stream(flow=(0.6, 0.4),\n ... species=Species('Ethanol', 'Water'))\n >>> stream.bubble_T()\n (352.2820850833474, array([0.703, 0.297]), [0, 1])\n\n \"\"\"\n mol = self.mol\n # If just one specie in equilibrium, return Tsat\n indices = self._species._equilibrium_indices(mol>0)\n cmps = self._species._compounds\n N = len(indices)\n if N == 1:\n return (cmps[indices[0]].Tsat(self.P), np.array((1,)), indices)\n elif N == 0:\n raise EquilibriumError('no species available for phase equilibrium')\n mol = mol[indices]\n self._gamma.species = [cmps[i] for i in indices]\n # Solve and return bubble point\n return (*self._bubble_point.solve_Ty(mol/mol.sum(), self.P), indices)\n \n def bubble_P(self):\n \"\"\"Bubble point at current composition and temperature.\n\n Returns\n -------\n P : float\n Bubble point pressure (Pa).\n y : numpy.ndarray\n Vapor phase composition.\n indices : list[int]\n Indices of species in equilibrium.\n\n Examples\n --------\n >>> from biosteam import *\n >>> s1 = Stream(flow=(0.703, 0.297), T=352.28,\n species=Species('Ethanol', 'Water'))\n >>> s1.bubble_P()\n (103494.17209657285, array([0.757, 0.243]), [0, 1])\n\n \"\"\"\n mol = self.mol\n # If just one specie in equilibrium, return Tsat\n indices = self._species._equilibrium_indices(mol>0)\n cmps = self._species._compounds\n N = len(indices)\n if N == 1:\n return (cmps[indices[0]].VaporPressure(self.T), np.array((1,)), indices)\n elif N == 0:\n raise EquilibriumError('no species available for phase equilibrium')\n mol = mol[indices]\n self._gamma.species = [cmps[i] for i in indices]\n # Solve and return bubble point\n return (*self._bubble_point.solve_Py(mol/mol.sum(), self.T), indices)\n\n def dew_T(self):\n \"\"\"Dew point at current composition and pressure.\n \n Returns\n -------\n T : float\n Dew point temperature (K).\n x : numpy.ndarray\n Liquid phase composition.\n indices : list[int]\n Indices of species in equilibrium\n\n Examples\n --------\n >>> from biosteam import Stream, Species\n >>> stream = Stream(flow=(0.5, 0.5),\n ... species=Species('Ethanol', 'Water'))\n >>> stream.dew_T()\n (357.45184742263075, array([0.151, 0.849]), [0, 1])\n \n \"\"\"\n mol = self.mol\n # If just one specie in equilibrium, return Tsat\n indices = self._species._equilibrium_indices(mol>0)\n cmps = self._species._compounds\n N = len(indices)\n if N == 1:\n return (cmps[0].Tsat(self.P), np.array((1,)), indices)\n elif N == 0:\n raise EquilibriumError('no species available for phase equilibrium')\n mol = mol[indices]\n self._gamma.species = [cmps[i] for i in indices]\n # Solve and return dew point\n return (*self._dew_point.solve_Tx(mol/mol.sum(), self.P), indices)\n \n def dew_P(self):\n \"\"\"Dew point at current composition and temperature.\n \n Returns\n -------\n P : float\n Dew point pressure (Pa).\n x : numpy.ndarray\n Liquid phase composition.\n indices : list[int]\n Indices of species in equilibrium.\n\n Examples\n --------\n >>> from biosteam import *\n >>> stream = Stream(flow=(0.703, 0.297), T=352.28,\n ... species=Species('Ethanol', 'Water'))\n >>> stream.dew_P()\n (101328.47030327446, array([0.6, 0.4]), [0, 1])\n \n \"\"\"\n mol = self.mol\n # If just one specie in equilibrium, return Tsat\n indices = self._species._equilibrium_indices(mol>0)\n cmps = self._species._compounds\n N = len(indices)\n if N == 1:\n return (cmps[0].VaporPressure(self.T), np.array((1,)), indices)\n elif N == 0:\n raise EquilibriumError('no species available for phase equilibrium') \n mol = mol[indices] \n self._gamma.species = [cmps[i] for i in indices]\n # Solve and return dew point\n return (*self._dew_point.solve_Px(mol/mol.sum(), self.T), indices)\n\n # Dimensionless number methods\n def Re(self, L, A=None):\n \"\"\"Return Reynolds number.\n\n Parameters\n ----------\n L : float\n Characteristic length (m).\n A=None : float, optional\n Cross-sectional area (m^2). If A is None, assume flow through a cylindrical pipe.\n\n Examples\n --------\n >>> from biosteam import *\n >>> Stream.species = Species('Ethanol', 'Water')\n >>> s1 = Stream(Water=200)\n >>> s1.Re(0.2, 0.031416)\n 27639.956372923512\n \n \"\"\"\n volnet = self.volnet/3600 # m3/s\n if A is None: # Assume pipe\n return 4*volnet/(self.nu*np.pi*L)\n return volnet*L/(self.nu*A)\n\n # Class methods\n @classmethod\n def _helpdata(cls, prop):\n \"\"\"Return information related to a property.\n\n Parameters\n ----------\n prop : str\n Name or description of a property.\n\n Returns\n --------\n ID : str\n Name of the property\n description : str\n Description of the property\n dependency : str\n TP dependency\n units : str\n Units of measure\n datatype : str\n object type returned by property.\n\n Examples\n --------\n >>> from biosteam import Stream\n >>> Stream._helplist('k')\n ('k', 'thermal conductivity', 'TP', 'W/m/K', 'float')\n\n >>> Stream._helplist('viscosity')\n (('nu', 'kinematic viscosity', 'TP', 'm^2/s', 'float'),\n ('mu', 'hydraulic viscosity', 'TP', 'Pa*s', 'float'))\n\n >>> Stream._helplist('kmol/hr')\n (('mol', 'molar flow rates', '', 'kmol/hr', 'np.array'),\n ('molnet', 'net molar flow rate', '', 'kmol/hr', 'float'))\n \"\"\"\n # Compare by both ID and description\n for index in (0, 1):\n # Search for exact matches\n for l in cls._prop_info:\n if prop == l[index]: return l\n \n out = []\n for index in (0, 1): \n # If no matches found, search harder\n for l in cls._prop_info:\n if prop.lower() in l[index].lower(): out.append(l)\n return out\n\n @classmethod\n def help(cls, prop):\n \"\"\"Print information related to a property.\n\n Parameters\n ----------\n prop : str\n Name or description of a property.\n\n Examples\n --------\n >>> from biosteam import Stream\n >>> Stream.help('rho')\n rho: [float] Density as a function of T and P (kg/m^3).\n >>> Stream.help('density')\n rho: [float] Density as a function of T and P (kg/m^3).\n \"\"\"\n data = cls._helpdata(prop)\n if data: _print_helpdata(data)\n else: print(f\"No matching property '{prop}'.\")\n\n @staticmethod\n def T_equilibrium(streams, T_guess=None, Q_in=0, approximate=True):\n \"\"\"Bring all streams to temperature equilibrium.\n\n Parameters\n ----------\n streams : iterable[Stream]\n All streams in temperature equilibrium.\n \n T_guess=None : float, optional\n Equilibrium temperature guess (K).\n\n Q_in=0 : float, optional\n Heat addition to streams (kJ/hr).\n \n approximate=True : bool\n If True, approximate energy balance with constant heat capacity.\n\n Returns\n -------\n T : float\n New temperature (K).\n\n Examples\n --------\n >>> from biosteam import *\n >>> Stream.species = Species('Water', 'Ethanol')\n >>> s1 = Stream(Water=2, T=300)\n >>> s2 = Stream(Ethanol=1, Water=2, T=340)\n >>> Stream.T_equilibrium([s1, s2])\n >>> (s1.T, s2.T)\n (325.8281231556553, 325.8281231556553)\n \"\"\"\n sum_ = sum\n # Set up problem\n C = sum_([s.C for s in streams])\n H_ = sum_([s.H for s in streams]) + Q_in\n \n # Set initial temperature\n if not T_guess:\n T_guess = sum_([s.T for s in streams])/len(streams)\n for s in streams:\n s.T = T_guess\n \n # Find new T\n H = sum_([s.H for s in streams])\n T = T_guess + (H_ - H)/C\n \n # Update\n for s in streams:\n s.T = T_guess\n if approximate: return\n \n # Solve enthalpy by iteration\n it = 1\n while abs(T - T_guess) > 0.01:\n # Calculate\n H_ = sum_([s.H for s in streams])\n T = T_guess + (H_- H)/C\n \n # Check iteration\n if it > 40:\n raise SolverError(f\"could not solve temperature\")\n \n # Update\n T_guess = T\n for s in streams:\n s.T = T_guess\n it += 1\n\n @staticmethod\n def sum(s_sum, streams):\n \"\"\"Mixes streams and sets resulting mass and energy in 's_sum'. Assumes the same pressure as streams[0], and no phase equilibrium. \n\n Parameters\n ----------\n s_sum : Stream\n Container for the resulting mixture of streams.\n streams : iterable[Stream]\n Stream objects to be mixed\n\n Examples\n --------\n >>> from biosteam import *\n >>> Stream.species = Species('Water', 'Ethanol')\n >>> s1 = Stream(Water=2, T=300)\n >>> s2 = Stream(Ethanol=1, Water=2, T=340)\n >>> s_sum = Stream('s_sum')\n >>> Stream.sum(s_sum, [s1, s2])\n >>> s_sum.show()\n Stream: s_sum\n phase: 'l', T: 326.29 K, P: 101325 Pa\n flow (kmol/hr): Ethanol 1\n Water 4\n \"\"\"\n # Check if energy balance is required\n T_init = streams[0].T\n other_streams = streams[1:]\n energy_balance = any([T_init!=s.T for s in other_streams])\n if energy_balance: H = sum([s.H for s in streams])\n\n # Copy starting values\n s_sum.copylike(streams[0])\n\n # Mass balance\n inst = isinstance\n MStream = MS.MixedStream\n try:\n if inst(s_sum, MStream):\n # For MixedStream objects\n for s in other_streams:\n if inst(s, MStream):\n s_sum._mol[:] += s._mol\n else:\n s_sum._mol[phase_index[s._phase]] += s._mol\n else:\n # For Stream objects\n for s in other_streams:\n s_sum._mol[:] += s.mol\n except Exception as Error:\n if not inst(s_sum, Stream):\n raise TypeError('s_sum must be a Stream object, not '\n \"'{type(s_sum).__name__}'\")\n for s in streams:\n if not inst(s, Stream):\n raise TypeError('streams must only contain Stream '\n f'objects, not {type(s).__name__} objects')\n raise Error\n\n # Energy Balance\n if energy_balance: s_sum.H = H\n\n # MixedStream compatibility\n def enable_phases(self):\n \"\"\"Cast stream into a MixedStream object.\"\"\"\n mol = self._mol\n self.__class__ = MS.MixedStream\n self._setflows(np.zeros((4, self._species._N)))\n self._mol[phase_index[self._phase]] = mol\n self._lL_split_cached = (None,)\n self._VLE = VLE(self)\n\n def disable_phases(self, phase):\n \"\"\"Cast stream into a Stream object.\n \n Parameters\n ----------\n phase : {'s', 'l', 'g'}\n Desired phase of stream\n \n \"\"\"\n self._phase = phase\n \n @property\n def VLE(self):\n \"\"\"A callable VLE object for vapor-liquid equilibrium.\n\n Parameters\n ----------\n Specify two:\n * **P:** Operating pressure (Pa)\n * **Q:** Energy input (kJ/hr)\n * **T:** Operating temperature (K)\n * **V:** Molar vapor fraction\n * **x:** Molar composition of liquid (for binary mixture)\n * **y:** Molar composition of vapor (for binary mixture)\n species_IDs=None : tuple, optional\n IDs of species in equilibrium.\n LNK=None : tuple[str], optional\n Light non-keys that remain as a vapor (disregards equilibrium).\n LNK=None : tuple[str], optional\n Heavy non-keys that remain as a liquid (disregards equilibrium).\n\n \"\"\"\n self.enable_phases()\n return self._VLE\n \n def LLE(self, species_IDs=(), split=None, lNK=(), LNK=(),\n solvents=(), solvent_split=(),\n P=None, T=None, Q=None):\n self.enable_phases()\n self.LLE(species_IDs, split, lNK, LNK,\n solvents, solvent_split, P, T, Q)\n\n def _info_header(self):\n \"\"\"Return stream information header.\"\"\"\n # First line\n unit = self._source\n if unit is None:\n source = ''\n else:\n source = f' from {type(unit).__name__}-{unit}'\n unit = self._sink\n if unit is None:\n sink = ''\n else:\n sink = f' to {type(unit).__name__}-{unit}'\n if self.ID:\n return f\"{type(self).__name__}: {self.ID}{source}{sink}\"\n else:\n return f\"{type(self).__name__}{source}{sink}\"\n \n def _info_phaseTP(self, phases, T_units, P_units):\n T = _Q(self.T, self.units['T']).to(T_units).magnitude\n P = _Q(self.P, self.units['P']).to(P_units).magnitude\n return f\" phase: '{phases}', T: {T:.5g} {T_units}, P: {P:.6g} {P_units}\\n\"\n\n # Representation\n def _info(self, T, P, flow, fraction, N):\n \"\"\"Return string with all specifications.\"\"\"\n units = self.units\n basic_info = self._info_header() + '\\n'\n if hasattr(self, '_mol'):\n nonzero, species = self.nonzero_species\n else:\n return basic_info + f' link: {self._link}'\n T_units, P_units, flow_units, fraction, N = [(i if i is not None else j) for i, j in\n zip((T, P, flow, fraction, N), self.display_units)]\n basic_info += self._info_phaseTP(self._phase, T_units, P_units)\n len_ = len(nonzero)\n if len_ == 0:\n return basic_info + ' flow: 0' \n # Start of third line (flow rates)\n flow_dim = _Q(0, flow_units).dimensionality\n if fraction:\n if flow_dim == mol_flow_dim:\n flownet = _Q(self.molnet, units['molnet']).to(flow_units).magnitude\n flow = 'molfrac'\n elif flow_dim == mass_flow_dim:\n flownet = _Q(self.massnet, units['massnet']).to(flow_units).magnitude\n flow = 'massfrac'\n elif flow_dim == vol_flow_dim:\n flownet = _Q(self.volnet, units['volnet']).to(flow_units).magnitude\n flow = 'volfrac'\n else:\n raise DimensionError(f\"dimensions for flow units must be in molar, mass or volumetric flow rates, not '{flow_dim}'\")\n beginning = ' flow: '\n end = f'\\n*{flownet:.3g} {flow_units} '\n else:\n beginning = f' flow ({flow_units}): '\n end = ''\n if flow_dim == mol_flow_dim:\n flow = 'mol'\n elif flow_dim == mass_flow_dim:\n flow = 'mass'\n elif flow_dim == vol_flow_dim:\n flow = 'vol'\n else:\n raise DimensionError(f\"dimensions for flow units must be in molar, mass or volumetric flow rates, not '{flow_dim}'\")\n # Remaining lines (all flow rates)\n new_line_spaces = len(beginning) * ' '\n if 'frac' in flow:\n flow = getattr(self, flow)[nonzero]\n else:\n flow = _Q(getattr(self, flow)[nonzero], units[flow]).to(flow_units).magnitude\n \n flowrates = ''\n lengths = [len(sp) for sp in species]\n maxlen = max(lengths) + 1\n _N = N - 1\n for i in range(len_-1):\n spaces = ' ' * (maxlen - lengths[i])\n if i == _N:\n flowrates += '...\\n' + new_line_spaces\n break\n flowrates += species[i] + spaces + f' {flow[i]:.3g}\\n' + new_line_spaces\n spaces = ' ' * (maxlen - lengths[len_-1])\n flowrates += species[len_-1] + spaces + f' {flow[len_-1]:.3g}'\n return (basic_info \n + beginning\n + flowrates\n + end.replace('*', new_line_spaces + 'net' + (maxlen-4)*' ' + ' '))\n\n def show(self, T=None, P=None, flow=None, fraction=None, N=None):\n \"\"\"Print all specifications.\n \n Parameters\n ----------\n T: str, optional\n Temperature units.\n P: str, optional\n Pressure units.\n flow: str, optional\n Flow rate units.\n fraction: bool, optional\n Display flows as net flow rate and fractions (i.e composition).\n N: int, optional\n Number of compounds to display.\n \n Notes\n -----\n Default values are stored in `Stream.display_units`.\n \n \"\"\"\n print(self._info(T, P, flow, fraction, N))\n _ipython_display_ = show\n\n def _disconnect(self):\n outs = self._source and self._source._outs\n if outs: outs[outs.index(self)] = MissingStream\n ins = self._sink and self._sink._ins\n if ins: ins[ins.index(self)] = MissingStream\n self._source = self._sink = None\n\n def __str__(self):\n if self.ID: return self.ID\n else: return type(self).__name__\n\n def __repr__(self):\n if self.ID: return f'<{type(self).__name__}: {self.ID}>'\n else: return f'<{type(self).__name__}>'\n \n \nfrom . import _mixed_stream as MS", "meta": {"hexsha": "a65a33dc502de8924127e3df3672dc41e3db33ec", "size": 63087, "ext": "py", "lang": "Python", "max_stars_repo_path": "biosteam/_stream.py", "max_stars_repo_name": "lilanyu/biosteam", "max_stars_repo_head_hexsha": "b025bbe138bfd0b016af58583792fb4f3ff9186e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-11-17T13:14:19.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-17T13:14:19.000Z", "max_issues_repo_path": "build/lib/biosteam/_stream.py", "max_issues_repo_name": "lilanyu/biosteam", "max_issues_repo_head_hexsha": "b025bbe138bfd0b016af58583792fb4f3ff9186e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "build/lib/biosteam/_stream.py", "max_forks_repo_name": "lilanyu/biosteam", "max_forks_repo_head_hexsha": "b025bbe138bfd0b016af58583792fb4f3ff9186e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.7905731119, "max_line_length": 318, "alphanum_fraction": 0.5177453358, "include": true, "reason": "import numpy", "num_tokens": 15639, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5428632683808533, "lm_q2_score": 0.3593641588823761, "lm_q1q2_score": 0.19508560182982296}} {"text": "\"\"\"solver.py\"\"\"\n\nimport os\nimport numpy.random as random\nfrom tqdm import tqdm\n\nimport torch\nimport torch.optim as optim\nimport torch.nn.functional as F\n\nfrom utils import mkdirs, save_args_outputs\nfrom ops import recon_loss, ad_loss, kl_divergence, permute_dims\nfrom model import FactorVAE, Discriminator\nfrom dataset import return_data\nfrom disentanglement import disentanglement_score\nfrom gradcam import GradCAM\n\n\nclass Solver(object):\n def __init__(self, args):\n self.args = args\n\n # Misc\n use_cuda = args.cuda and torch.cuda.is_available()\n self.device = 'cuda' if use_cuda else 'cpu'\n self.name = args.name\n self.max_iter = int(args.max_iter)\n self.print_iter = args.print_iter\n self.global_iter = 0\n self.pbar = tqdm(total=self.max_iter)\n\n # Data\n assert args.dataset == 'dsprites', 'Only dSprites is implemented'\n self.dset_dir = args.dset_dir\n self.dataset = args.dataset\n self.batch_size = args.batch_size\n self.data_loader, self.dataset = return_data(args)\n\n # Networks & Optimizers\n self.z_dim = args.z_dim\n self.gamma = args.gamma\n\n self.lr_VAE = args.lr_VAE\n self.beta1_VAE = args.beta1_VAE\n self.beta2_VAE = args.beta2_VAE\n\n self.lr_D = args.lr_D\n self.beta1_D = args.beta1_D\n self.beta2_D = args.beta2_D\n\n # Disentanglement score\n self.L = args.L\n self.vote_count = args.vote_count\n self.dis_score = args.dis_score\n self.dis_batch_size = args.dis_batch_size\n\n # Models and optimizers\n self.VAE = FactorVAE(self.z_dim).to(self.device)\n self.nc = 1\n\n self.optim_VAE = optim.Adam(self.VAE.parameters(), lr=self.lr_VAE,\n betas=(self.beta1_VAE, self.beta2_VAE))\n\n self.D = Discriminator(self.z_dim).to(self.device)\n self.optim_D = optim.Adam(self.D.parameters(), lr=self.lr_D,\n betas=(self.beta1_D, self.beta2_D))\n\n self.nets = [self.VAE, self.D]\n\n # Attention Disentanglement loss\n self.ad_loss = args.ad_loss\n self.lamb = args.lamb\n if self.ad_loss:\n self.gcam = GradCAM(self.VAE.encode, args.target_layer, self.device, args.image_size)\n self.pick2 = True\n\n # Checkpoint\n self.ckpt_dir = os.path.join(args.ckpt_dir, args.name+'_'+str(args.seed))\n self.ckpt_save_iter = args.ckpt_save_iter\n if self.max_iter >= args.ckpt_save_iter:\n mkdirs(self.ckpt_dir)\n if args.ckpt_load:\n self.load_checkpoint(args.ckpt_load)\n\n # Results\n self.results_dir = os.path.join(args.results_dir, args.name+'_'+str(args.seed))\n self.results_save = args.results_save\n\n self.outputs = {'vae_recon_loss': [], 'vae_kld': [], 'vae_tc_loss': [], 'D_tc_loss': [], 'ad_loss': [], 'dis_score': [], 'iteration': []}\n\n def train(self):\n self.net_mode(train=True)\n\n ones = torch.ones(self.batch_size, dtype=torch.long, device=self.device)\n zeros = torch.zeros(self.batch_size, dtype=torch.long, device=self.device)\n\n out = False\n while not out:\n for x_true1, x_true2 in self.data_loader:\n self.global_iter += 1\n self.pbar.update(1)\n\n x_true1 = x_true1.to(self.device)\n x_recon, mu, logvar, z = self.VAE(x_true1)\n vae_recon_loss = recon_loss(x_true1, x_recon)\n vae_ad_loss = self.get_ad_loss(z)\n vae_kld = kl_divergence(mu, logvar)\n\n D_z = self.D(z)\n vae_tc_loss = (D_z[:, :1] - D_z[:, 1:]).mean()\n\n vae_loss = vae_recon_loss + vae_kld + self.gamma*vae_tc_loss + self.lamb*vae_ad_loss\n\n x_true2 = x_true2.to(self.device)\n z_prime = self.VAE(x_true2, no_dec=True)\n z_pperm = permute_dims(z_prime).detach()\n D_z_pperm = self.D(z_pperm)\n D_tc_loss = 0.5*(F.cross_entropy(D_z, zeros) + F.cross_entropy(D_z_pperm, ones))\n\n self.optim_VAE.zero_grad()\n vae_loss.backward(retain_graph=True)\n\n self.optim_D.zero_grad()\n D_tc_loss.backward()\n\n self.optim_VAE.step()\n self.optim_D.step()\n\n if self.global_iter%self.print_iter == 0:\n if self.dis_score:\n dis_score = disentanglement_score(self.VAE.eval(), self.device, self.dataset, self.z_dim, self.L, self.vote_count, self.dis_batch_size)\n self.VAE.train()\n else:\n dis_score = torch.tensor(0)\n\n self.pbar.write('[{}] vae_recon_loss:{:.3f} vae_kld:{:.3f} vae_tc_loss:{:.3f} ad_loss:{:.3f} D_tc_loss:{:.3f} dis_score:{:.3f}'.format(\n self.global_iter, vae_recon_loss.item(), vae_kld.item(), vae_tc_loss.item(), vae_ad_loss.item(), D_tc_loss.item(), dis_score.item()))\n\n if self.results_save:\n self.outputs['vae_recon_loss'].append(vae_recon_loss.item())\n self.outputs['vae_kld'].append(vae_kld.item())\n self.outputs['vae_tc_loss'].append(vae_tc_loss.item())\n self.outputs['D_tc_loss'].append(D_tc_loss.item())\n self.outputs['ad_loss'].append(vae_ad_loss.item())\n self.outputs['dis_score'].append(dis_score.item())\n self.outputs['iteration'].append(self.global_iter)\n\n if self.global_iter%self.ckpt_save_iter == 0:\n self.save_checkpoint(self.global_iter)\n\n if self.global_iter >= self.max_iter:\n out = True\n break\n\n self.pbar.write(\"[Training Finished]\")\n self.pbar.close()\n\n if self.results_save:\n save_args_outputs(self.results_dir, self.args, self.outputs)\n\n def get_ad_loss(self, z):\n if not self.ad_loss:\n return torch.tensor(0)\n\n z_picked = z[:, random.randint(0, self.z_dim, size=2)]\n M = self.gcam.generate(z_picked)\n\n return ad_loss(M.flatten(1), self.batch_size, self.pick2)\n\n def net_mode(self, train):\n if not isinstance(train, bool):\n raise ValueError('Only bool type is supported. True|False')\n\n for net in self.nets:\n if train:\n net.train()\n else:\n net.eval()\n\n def save_checkpoint(self, ckptname='last', verbose=True):\n model_states = {'D':self.D.state_dict(),\n 'VAE':self.VAE.state_dict()}\n optim_states = {'optim_D':self.optim_D.state_dict(),\n 'optim_VAE':self.optim_VAE.state_dict()}\n states = {'iter':self.global_iter,\n 'model_states':model_states,\n 'optim_states':optim_states}\n\n filepath = os.path.join(self.ckpt_dir, str(ckptname))\n with open(filepath, 'wb+') as f:\n torch.save(states, f)\n if verbose:\n self.pbar.write(\"=> saved checkpoint '{}' (iter {})\".format(filepath, self.global_iter))\n\n def load_checkpoint(self, ckptname='last', verbose=True):\n if ckptname == 'last':\n ckpts = os.listdir(self.ckpt_dir)\n if not ckpts:\n if verbose:\n self.pbar.write(\"=> no checkpoint found\")\n return\n\n ckpts = [int(ckpt) for ckpt in ckpts]\n ckpts.sort(reverse=True)\n ckptname = str(ckpts[0])\n\n filepath = os.path.join(self.ckpt_dir, ckptname)\n if os.path.isfile(filepath):\n with open(filepath, 'rb') as f:\n checkpoint = torch.load(f)\n\n self.global_iter = checkpoint['iter']\n self.VAE.load_state_dict(checkpoint['model_states']['VAE'])\n self.D.load_state_dict(checkpoint['model_states']['D'])\n self.optim_VAE.load_state_dict(checkpoint['optim_states']['optim_VAE'])\n self.optim_D.load_state_dict(checkpoint['optim_states']['optim_D'])\n self.pbar.update(self.global_iter)\n if verbose:\n self.pbar.write(\"=> loaded checkpoint '{} (iter {})'\".format(filepath, self.global_iter))\n else:\n if verbose:\n self.pbar.write(\"=> no checkpoint found at '{}'\".format(filepath))\n", "meta": {"hexsha": "ff93c9b349517ea282bc18643c73f1b829c18301", "size": 8523, "ext": "py", "lang": "Python", "max_stars_repo_path": "solver.py", "max_stars_repo_name": "FrankBrongers/FactorVAE", "max_stars_repo_head_hexsha": "a9e357ee7f38189507f5ab7389065f68a81b3ec5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "solver.py", "max_issues_repo_name": "FrankBrongers/FactorVAE", "max_issues_repo_head_hexsha": "a9e357ee7f38189507f5ab7389065f68a81b3ec5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2021-01-12T10:39:47.000Z", "max_issues_repo_issues_event_max_datetime": "2021-01-28T16:29:24.000Z", "max_forks_repo_path": "solver.py", "max_forks_repo_name": "FrankBrongers/FactorVAE", "max_forks_repo_head_hexsha": "a9e357ee7f38189507f5ab7389065f68a81b3ec5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.2197309417, "max_line_length": 159, "alphanum_fraction": 0.5778481755, "include": true, "reason": "import numpy", "num_tokens": 1961, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.542863297964157, "lm_q2_score": 0.3593641382989649, "lm_q1q2_score": 0.1950856012870235}} {"text": "# -*- coding: utf-8 -*-\n# -----------------------------------------------------------------------------\n# Copyright (c) 2014, Nicolas P. Rougier\n# Distributed under the (new) BSD License.\n#\n# Contributors: Nicolas P. Rougier (Nicolas.Rougier@inria.fr)\n# -----------------------------------------------------------------------------\n# References:\n#\n# * Interaction between cognitive and motor cortico-basal ganglia loops during\n# decision making: a computational study. M. Guthrie, A. Leblois, A. Garenne,\n# and T. Boraud. Journal of Neurophysiology, 109:3025–3040, 2013.\n# -----------------------------------------------------------------------------\nimport numpy as np\nfrom model import *\nfrom display import *\n\n\ndef debug(time, cues, choice, reward):\n n = len(cues)\n cues = np.sort(cues)\n\n R.append(reward)\n if choice == cues[0]:\n P.append(1)\n else:\n P.append(0)\n\n print \"Choice: \",\n for i in range(n):\n if choice == cues[i]:\n print \"[%d]\" % cues[i],\n else:\n print \"%d\" % cues[i],\n if i < (n-1):\n print \"/\",\n if choice == cues[0]:\n print \" (good)\"\n else:\n print \" (bad)\"\n\n print \"Reward (%3d%%) : %d\" % (int(100*CUE[\"reward\"][choice]),reward)\n print \"Mean performance: %.3f\" % np.array(P).mean()\n print \"Mean reward: %.3f\" % np.array(R).mean()\n print \"Response time: %d ms\" % (time)\n print \"CTX.cog->CTX.ass:\", connections[\"CTX.cog -> CTX.ass\"].weights\n print\n\n\nn_experiments = 250\nn_trials = 150\n\nif 1:\n for k in range(n_experiments):\n reset()\n learning = True\n P,RT = [], []\n connections[\"GPI.cog -> THL.cog\"].active = True\n connections[\"GPI.mot -> THL.mot\"].active = True\n\n for j in range(n_trials):\n reset_activities()\n # Settling phase (500ms)\n for i in xrange(0,500):\n iterate(dt)\n # Trial setup\n set_trial(n=2)\n # Learning phase (2500ms)\n for i in xrange(500,3000):\n iterate(dt)\n # Test if a decision has been made\n if CTX.mot.delta > decision_threshold:\n RT.append(i-500)\n cues, choice, reward = process(n=2, learning=learning)\n cues = np.sort(cues)\n if choice == cues[0]:\n P.append(1)\n else:\n P.append(0)\n break\n\n if j == 100:\n print \"BG Performance: %g\" % np.mean(P)\n print \"BG RT: %g (+/- %g)\"% (np.mean(RT), np.std(RT))\n P,RT = [], []\n # print \"-------------------------------------------------------\"\n learning = False\n connections[\"GPI.cog -> THL.cog\"].active = False\n connections[\"GPI.mot -> THL.mot\"].active = False\n\n print \"Cortex Performance: %g\" % np.mean(P)\n print \"Cortex RT: %g (+/- %g)\"% (np.mean(RT), np.std(RT))\n print \"CTX.cog->CTX.ass:\", connections[\"CTX.cog -> CTX.ass\"].weights\n print \"CUE['value']: \", CUE[\"value\"]\n print \"---\"\n", "meta": {"hexsha": "645bf6c145a2298176dcf48e7c242524c7d37eb0", "size": 3236, "ext": "py", "lang": "Python", "max_stars_repo_path": "basal-ganglia/topalidou-et-al-2014/cython/Guthrie_cortical.py", "max_stars_repo_name": "mtopalid/Neurosciences", "max_stars_repo_head_hexsha": "8531d59f8370f0cf7f1b4b1f72e4bf11b96e1354", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 27, "max_stars_repo_stars_event_min_datetime": "2015-01-24T01:14:29.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T06:50:46.000Z", "max_issues_repo_path": "basal-ganglia/topalidou-et-al-2014/cython/Guthrie_cortical.py", "max_issues_repo_name": "mtopalid/Neurosciences", "max_issues_repo_head_hexsha": "8531d59f8370f0cf7f1b4b1f72e4bf11b96e1354", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2015-02-24T15:44:27.000Z", "max_issues_repo_issues_event_max_datetime": "2015-02-24T15:44:27.000Z", "max_forks_repo_path": "basal-ganglia/topalidou-et-al-2014/cython/Guthrie_cortical.py", "max_forks_repo_name": "mtopalid/Neurosciences", "max_forks_repo_head_hexsha": "8531d59f8370f0cf7f1b4b1f72e4bf11b96e1354", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2015-10-05T23:02:30.000Z", "max_forks_repo_forks_event_max_datetime": "2019-12-31T23:46:14.000Z", "avg_line_length": 33.7083333333, "max_line_length": 82, "alphanum_fraction": 0.4502472188, "include": true, "reason": "import numpy", "num_tokens": 798, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.5428632831725052, "lm_q2_score": 0.35936414516010196, "lm_q1q2_score": 0.19508559969609368}} {"text": "# -*- coding: utf-8 -*-\n\"\"\"\nPhotosynthesis and Stomatal Conductance Model \nCreated 9/27/2016\nKatherine Wentz\n\nThis is a program that runs photosynthesis and\nstomatal conductance models given changes in leaf-\nlevel traits. \n\nThe end product is graphs of NUE vs. WUE.\n\n\nUpdate: I am going to run the model for plants with \ntraits that are distinctive of the meadow moisture \ngradient in the alpine tundra.\n\nFix: correct for atmospheric pressure differences in co2, o2, and vapor pressure\n\nFix: vcmax temp dependence (pg 63 in plant physiological ecology book)\n\nFix: NEW VARIBALE TRAIT-->make the fraction of leaf N in rubisco go down with increasing SLA,\nchlorophyll content, and decreasing light (wet meadow)--more N is allocated\nto thylakoids. The only way for chl/m2 to increase even when g N/m2 goes down\nor is constant is for the leaf to allocate more of leaf N to chl...also, note\nthat there is more organic N designated to photo in leaf when SLA goes up\nbecause less N is used in structure. see \"Photosynthesis or persistence: N allocation\nin leaves of evergreen and deciduous... by Takashima et al. 2004. Also see Photosynthetic\nnitrogen-use efficiency of species...by Poorter and Evans 1998\n\nNote to self: NUE and WUE relationship flipflops with change in air temperature;\nNUE makes sense because C:N decreases from dry to wet meadows; WUE increasing\nin snowbed does not necessarilly make sense--look in the literature for this\n\nherbs have a higher NUE\n\n\"\"\"\n\n#---------------Import Modules---------------#\n\nimport itertools as it\nimport numpy as np\nimport operator\nfrom matplotlib import pyplot as plt\nfrom matplotlib import rcParams\nfrom scipy.optimize import curve_fit\n\n#Import combinations of variable parameters \nfrom uncertain_params import monte_carlo_all\n\n#Import photosynthesis model\nfrom Photosynthesis_Model import photo_bound_meso_eqstom as photo\n\n#Import functions to switch between Pa and umol/mol at sea level\nfrom photo_functions import pa_con_atmfrac\n\n\n#for doing letters on graphs for multiple plots in same figure\ndef get_axis_limits(ax, scale1=.95,scale2=0.9):\n return ax.get_xlim()[1]*scale1, ax.get_ylim()[1]*scale2\n\n\n#---------------Determine if I Want to Keep Any of the Variable Parameters Constant---------------#\n\nconst_params=[]\nfor xx in it.combinations(['ht','t'],0): #keep ht and t constant for constant vpd\n const_params+=[xx]\n\n#do this when I do not put any of the variable parameters as constant. instead I \n#vary each parameter one at a time while keeping the other parameters constant.\nif const_params==[()]:\n const_params=[[-999999]] \n\n#---------------Begin Looping Through Photosynthesis Model---------------#\n\n#each loop is for a constant value, or combinatin of constant values, of variable parameter as determined above\nfor ii in range(len(const_params)):\n \n #---------------Initialize Plots---------------#\n\n ##---Figure With Subplots Blueprint---##\n\n #fb1=plt.figure(1,figsize=(12,2)) \n #axA = fb1.add_subplot(121)\n #axB = fb1.add_subplot(122)\n\n ##---Figures Without Subplots Blueprint---##\n \n #--figure 1--#\n \n #simulated and empirical NUE in plant communities \n fig1, (ax1A,ax1B) = plt.subplots(2,figsize=(9,20),sharex=True) \n ax1A.set_ylabel('NUE ($\\mu$mol CO$_2$/g N s)',fontsize=20, fontname='Times New Roman')\n ax1A.set_ylim([0,5])\n# ax1A.set_title('NUE in Plant Communities', fontname='Times New Roman',fontsize=30)\n \n ax1B.set_ylabel('NUE (g biomass/g N)',fontsize=20, fontname='Times New Roman')\n ax1B.set_ylim([60,100])\n\n\n #-----figure 2----#\n \n #simulated and empirical WUE in plant communities\n fig2,(ax2A,ax2B,ax2C) = plt.subplots(3,figsize=(9,20),sharex=True,sharey=True) \n ax2B.set_ylabel('WUE ($\\mu$mol CO$_2$/mmol H$_2$O)',fontsize=20, fontname='Times New Roman')\n ax2A.set_ylim([0,5])\n# ax2A.set_title('WUE in Plant Communities', fontname='Times New Roman',fontsize=30)\n \n\n #--figure 3--#\n \n #simulated and empirical Assimilation in plant communities \n fig3, (ax3A,ax3B) = plt.subplots(2,figsize=(9,20),sharex=True) \n ax3A.set_ylabel('Assimilation ($\\mu$mol CO$_2$/m$^2$s)',fontsize=20, fontname='Times New Roman')\n ax3A.set_ylim([0,30])\n# ax3A.set_title('Assimilation in Plant Communities', fontname='Times New Roman',fontsize=30)\n \n ax3B.set_ylabel('Growth Rate (g C/m$^2$ day)',fontsize=20, fontname='Times New Roman')\n ax3B.set_ylim([0,5])\n\n\n #--figure 4--#\n \n #leaf height vs. temperature\n fig4,ax4 = plt.subplots(figsize=(11,11))\n ax4.set_xlabel('Leaf Height (cm)',fontsize=25, fontname='Times New Roman')\n ax4.set_ylabel('Difference Between Leaf and Air Temperature ($^\\circ$C)',fontsize=25, fontname='Times New Roman')\n# ax4.set_title('Leaf Height vs. Leaf & Air Temperature Difference', fontname='Times New Roman',fontsize=30)\n\n\n #-----figure 5----#\n\n #assimilation vs. stomatal conductance\n fig5,ax5 = plt.subplots(figsize=(11,11))\n\n ax5.set_xlabel('Assimilation ($\\mu$mol CO$_2$/m$^2$s)',fontsize=25, fontname='Times New Roman')\n ax5.set_ylabel('Stomatal Conductance (mol CO$_2$/m$^2$s)',fontsize=25, fontname='Times New Roman')\n# ax5.set_title('Simulated Assimilation vs. Stomatal Conductance', fontname='Times New Roman',fontsize=30)\n ax5.set_ylim([0,0.55])\n ax5.set_xlim([0,25])\n \n \n #--figure 6--#\n \n #vpd vs. wue\n fig6, (ax6A,ax6B) = plt.subplots(2,figsize=(9,20),sharex=False) \n # ax6A.set_xlabel('VPD (cmol H$_2$O/mol air)',fontsize=25, fontname='Times New Roman')\n ax6A.set_ylabel('WUE ($\\mu$mol CO$_2$/mmol H$_2$O)',fontsize=20, fontname='Times New Roman')\n# ax6A.set_title('Vapor Pressure Deficit vs. WUE', fontname='Times New Roman',fontsize=30)\n ax6B.set_xlabel('VPD (cmol H$_2$O/mol air)',fontsize=20, fontname='Times New Roman')\n ax6B.set_ylabel('WUE ($\\mu$mol CO$_2$/mmol H$_2$O)',fontsize=20, fontname='Times New Roman')\n \n \n\n\n\n\n #---------------Initialize Arrays for Each Meadow---------------#\n \n #total nue and wue\n nue_tot=[]\n wue_tot=[]\n \n #wue and nue arrays\n wue_d=[]\n nue_d=[]\n wue_d_const=[]\n \n wue_m_const=[]\n\n wue_w=[]\n wue_w_const=[]\n nue_w=[] \n \n\n \n \n #gsw arrays\n\n gsw_d=[]\n gsw_d_tms=[] \n gsw_m=[]\n gsw_m_tms=[]\n gsw_w=[]\n gsw_w_tms=[]\n \n gs_d=[]\n gs_m=[]\n gs_w=[] \n #assimilation arrays\n\n A_d=[]\n A_d_tms=[]\n A_m=[]\n A_m_tms=[]\n A_w=[]\n A_w_tms=[]\n\n #evapo arrays\n\n E_d=[]\n E_d_tms=[] \n E_m=[]\n E_m_tms=[]\n E_w=[]\n E_w_tms=[] \n \n #vapor pressure deficit arrays\n vpd_d=[]\n vpd_d_tms=[]\n vpd_m=[]\n vpd_m_tms=[]\n vpd_w=[]\n vpd_w_tms=[] \n\n\n #leaf temp\n tl_d=[]\n tl_m=[]\n tl_w=[]\n\n\n\n\n #---------------Photosynthesis + Stomatal Conductance Model---------------#\n\n \n ##---Constant Parameter Arrays for Model---##\n\n #----Params Used in Model Currently----#\n \n tk_25=298.16; #absolute temperature at 25 C\n ekc=80500.0 #Activation energy for K of CO2 (J mol-1)\n eko=14500.0 #Activation energy for K of O2 (J mol-1)\n etau=-29000.0 #Activation energy for tau (???) (J mol-1)\n ev=55000.0 #Activation energy for carboxylation (J mol-1)\n ej=55000.0 #Activation energy for electron transport (J mol-1)\n toptv=303.0 #Optimum temperature for maximum carboxylation (K)\n toptj=303.0 #Optimum temperature for maximum electron transport (K)\n ra=np.zeros(shape=1)+20.7 #specific rubisco activity (umol CO2/g Rub s)\n flnr=np.zeros(shape=1)+0.1 #fraction of leaf nitrogen in rubisco (g N Rub/g N leaf)\n frnr=np.zeros(shape=1)+6.25 #weight fraction of nitrogen in rubisco molecule (g Rub/g N Rub) \n rh=np.zeros(shape=1)+0.5 #relative humidity (kPa/kPa)\n ca=np.zeros(shape=1)+405 #ambient carbon dioxide (umol CO2/mol air)\n ko25=np.zeros(shape=1)+30000 #Michaelis-Menten kinetic coefficient for oxygen at 25 C(Pa) \n kc25=np.zeros(shape=1)+30 #Michaelis-Menten kinetic coefficient for carbon dioxide at 25 C (Pa)\n o=np.zeros(shape=1)+210000 #concentration of ambient oxygen (umol/mol)\n g0=np.zeros(shape=1)+0.002 #Ball-Berry stomatal conductance intercept parameter (mol H2O/m2s)\n a=np.zeros(shape=1)+1.6 #Conversion Coefficient between stomatal conductance to water and carbon dioxide (unitless)\n ij=np.zeros(shape=1)+1.0 #leaf angle index--downregulates jmax\n m=np.zeros(shape=1)+9.0 #ball-berry parameter (unitless)\n b=1.37 #Conversion Coefficient between boundary layer conductance to water and carbon dioxide \n u=5.0 #windspeed (m/s)\n qeff=0.32 #leaf quantum yield, electrons\n PAR=2000 #photosynthetic active radiation (umol/m2s)\n jm=2.68 #slope coefficient \n vwc_min=0.08 #minimum soil water content for photosynthesis to occur (permanent wilting point) (cm3/cm3) \n vwc_max=0.68 #maximum soil water content where increases in soil water do not affect photosynthesis (field capacity?) (cm3/cm3)\n q=0.2 #parameter for soil water affect on photosynthesis (unitless)\n \n \n #------constant variable params for sensitivty analysis-----#\n \n chl_c=np.zeros(shape=1)+(np.mean([396,465,476])) #Chlorophyll Content of the Leaf (umol chl/m2)\n ht_c=np.zeros(shape=1)+10.0 #Temperature of the Leaf (K)\n dia_c=np.zeros(shape=1)+(np.mean([1.4,2.3,2.6])/100.) #Mean diameter or size of leaf (m)\n na_c=np.zeros(shape=1)+(np.mean([2.5,5.6,6.3])) #leaf nitrogen (g N/ m2)\n t_c=np.zeros(shape=1)+15.0 #temp (C)\n \n\n#---------------Import Variable Parameter Arrays from Leaf Parameter File---------------#\n params=monte_carlo_all() \n \n for xx in range(len(params)):\n for yy in range(len(params[xx])):\n for key,val in params[xx][yy].items():\n exec(key + '=val')\n \n \n #set variable parameters constant if I specify this above\n if 'na' in const_params[ii]:\n na=na_c\n if 'dia' in const_params[ii]:\n dia=dia_c\n if 'chl' in const_params[ii]:\n chl=chl_c\n if 'ht' in const_params[ii]:\n ht=ht_c\n if 't' in const_params[ii]:\n temp=t_c\n \n \n \n \n #------calculate vapor pressure-----#\n pa_v=611*np.exp((17.27*temp)/(temp+237.3)) #saturation vapor pressure of air (Pa)\n ea_str=pa_con_atmfrac(pa_v,3528) #saturation vapor pressure of air (Pa-->umol h20/mol air)\n ea=rh*ea_str #vapor pressure (umol h2O/mol air) \n \n \n #correct for leaf temperatures using leaf height\n \n t_diff=18-0.4*ht\n \n tl=temp+t_diff\n \n \n\n \n if xx==0: \n \n z=0.2\n #---------------Photosynthesis Function---------------#\n \n #alter this line of code for when implementing different photosynthesis functions\n wue, nue, A, E, cs, ci, gsw, gs, gbw, gb, gm, cc,dd =photo(tk_25,ekc,eko,etau,ev,ej,toptv,toptj,na, qeff, PAR,tl,ea,chl,ij,kc25,ko25,o,ca,rh,m,a,frnr,flnr,ra,jm,g0,b,dia,u,q,vwc_min,vwc_max,vwc,z)\n \n \n if isinstance(wue, np.ndarray):\n wue=wue[0]\n \n if isinstance(nue, np.ndarray):\n nue=nue[0]\n \n if isinstance(A, np.ndarray):\n A=A[0] \n\n if isinstance(gs, np.ndarray):\n gs=gs[0] \n\n if isinstance(gsw, np.ndarray):\n gsw=gsw[0] \n\n if isinstance(E, np.ndarray):\n E=E[0] \n\n if isinstance(dd, np.ndarray):\n dd=dd[0] \n \n if isinstance(wue, list):\n wue=wue[0]\n \n if isinstance(nue, list):\n nue=nue[0]\n \n if isinstance(A, list):\n A=A[0] \n\n if isinstance(gs, list):\n gs=gs[0] \n\n if isinstance(gsw, list):\n gsw=gsw[0] \n \n if isinstance(E, list):\n E=E[0] \n \n if isinstance(dd, list):\n dd=dd[0] \n \n wue_d+=[wue]\n nue_d+=[nue]\n gsw_d+=[gsw]\n A_d+=[A]\n E_d+=[E]\n vpd_d+=[dd]\n tl_d+=[tl]\n gs_d+=[gs]\n\n \n\n elif xx==1:\n \n z=0.4\n #---------------Photosynthesis Function---------------#\n \n #alter this line of code for when implementing different photosynthesis functions\n wue, nue, A, E, cs, ci, gsw, gs, gbw, gb, gm, cc,dd =photo(tk_25,ekc,eko,etau,ev,ej,toptv,toptj,na, qeff, PAR,tl,ea,chl,ij,kc25,ko25,o,ca,rh,m,a,frnr,flnr,ra,jm,g0,b,dia,u,q,vwc_min,vwc_max,vwc,z)\n \n if isinstance(wue, np.ndarray):\n wue=wue[0]\n \n if isinstance(nue, np.ndarray):\n nue=nue[0]\n \n if isinstance(A, np.ndarray):\n A=A[0] \n\n if isinstance(gs, np.ndarray):\n gs=gs[0] \n\n if isinstance(gsw, np.ndarray):\n gsw=gsw[0] \n\n if isinstance(E, np.ndarray):\n E=E[0] \n\n if isinstance(dd, np.ndarray):\n dd=dd[0] \n \n if isinstance(wue, list):\n wue=wue[0]\n \n if isinstance(nue, list):\n nue=nue[0]\n \n if isinstance(A, list):\n A=A[0] \n\n if isinstance(gs, list):\n gs=gs[0] \n\n if isinstance(gsw, list):\n gsw=gsw[0] \n \n if isinstance(E, list):\n E=E[0] \n \n if isinstance(dd, list):\n dd=dd[0] \n \n wue_m+=[wue]\n\n \n \n \n elif xx==2:\n \n z=0.4\n #---------------Photosynthesis Function---------------#\n \n #alter this line of code for when implementing different photosynthesis functions\n wue, nue, A, E, cs, ci, gsw, gs, gbw, gb, gm, cc,dd =photo(tk_25,ekc,eko,etau,ev,ej,toptv,toptj,na, qeff, PAR,tl,ea,chl,ij,kc25,ko25,o,ca,rh,m,a,frnr,flnr,ra,jm,g0,b,dia,u,q,vwc_min,vwc_max,vwc,z)\n \n if isinstance(wue, np.ndarray):\n wue=wue[0]\n \n if isinstance(nue, np.ndarray):\n nue=nue[0]\n \n if isinstance(A, np.ndarray):\n A=A[0] \n\n if isinstance(gs, np.ndarray):\n gs=gs[0] \n\n if isinstance(gsw, np.ndarray):\n gsw=gsw[0] \n\n if isinstance(E, np.ndarray):\n E=E[0] \n\n if isinstance(dd, np.ndarray):\n dd=dd[0] \n \n if isinstance(wue, list):\n wue=wue[0]\n \n if isinstance(nue, list):\n nue=nue[0]\n \n if isinstance(A, list):\n A=A[0] \n\n if isinstance(gs, list):\n gs=gs[0] \n\n if isinstance(gsw, list):\n gsw=gsw[0] \n \n if isinstance(E, list):\n E=E[0] \n \n if isinstance(dd, list):\n dd=dd[0] \n \n wue_w+=[wue]\n nue_w+=[nue]\n gsw_w+=[gsw]\n A_w+=[A]\n E_w+=[E]\n vpd_w+=[dd]\n tl_w+=[tl]\n gs_w+=[gs]\n \n\n\n\n\n#---------------Constant WUE---------------#\n params=monte_carlo_all() \n \n for xx in range(len(params)):\n for yy in range(len(params[xx])):\n for key,val in params[xx][yy].items():\n exec(key + '=val')\n \n \n \n ht=ht_c\n\n temp=t_c\n\n \n \n \n #------calculate vapor pressure-----#\n pa_v=611*np.exp((17.27*temp)/(temp+237.3)) #saturation vapor pressure of air (Pa)\n ea_str=pa_con_atmfrac(pa_v,3528) #saturation vapor pressure of air (Pa-->umol h20/mol air)\n ea=rh*ea_str #vapor pressure (umol h2O/mol air) \n \n \n #correct for leaf temperatures using leaf height\n \n t_diff=18-0.4*ht\n \n tl=temp+t_diff\n \n \n\n \n if xx==0: \n \n z=0.2\n #---------------Photosynthesis Function---------------#\n \n #alter this line of code for when implementing different photosynthesis functions\n wue, nue, A, E, cs, ci, gsw, gs, gbw, gb, gm, cc,dd =photo(tk_25,ekc,eko,etau,ev,ej,toptv,toptj,na, qeff, PAR,tl,ea,chl,ij,kc25,ko25,o,ca,rh,m,a,frnr,flnr,ra,jm,g0,b,dia,u,q,vwc_min,vwc_max,vwc,z)\n \n \n if isinstance(wue, np.ndarray):\n wue=wue[0]\n \n if isinstance(nue, np.ndarray):\n nue=nue[0]\n \n if isinstance(A, np.ndarray):\n A=A[0] \n\n if isinstance(gs, np.ndarray):\n gs=gs[0] \n\n if isinstance(gsw, np.ndarray):\n gsw=gsw[0] \n\n if isinstance(E, np.ndarray):\n E=E[0] \n\n if isinstance(dd, np.ndarray):\n dd=dd[0] \n \n if isinstance(wue, list):\n wue=wue[0]\n \n if isinstance(nue, list):\n nue=nue[0]\n \n if isinstance(A, list):\n A=A[0] \n\n if isinstance(gs, list):\n gs=gs[0] \n\n if isinstance(gsw, list):\n gsw=gsw[0] \n \n if isinstance(E, list):\n E=E[0] \n \n if isinstance(dd, list):\n dd=dd[0] \n \n wue_d_const+=[wue]\n \n if xx==1: \n \n z=0.2\n #---------------Photosynthesis Function---------------#\n \n #alter this line of code for when implementing different photosynthesis functions\n wue, nue, A, E, cs, ci, gsw, gs, gbw, gb, gm, cc,dd =photo(tk_25,ekc,eko,etau,ev,ej,toptv,toptj,na, qeff, PAR,tl,ea,chl,ij,kc25,ko25,o,ca,rh,m,a,frnr,flnr,ra,jm,g0,b,dia,u,q,vwc_min,vwc_max,vwc,z)\n \n \n if isinstance(wue, np.ndarray):\n wue=wue[0]\n \n if isinstance(nue, np.ndarray):\n nue=nue[0]\n \n if isinstance(A, np.ndarray):\n A=A[0] \n\n if isinstance(gs, np.ndarray):\n gs=gs[0] \n\n if isinstance(gsw, np.ndarray):\n gsw=gsw[0] \n\n if isinstance(E, np.ndarray):\n E=E[0] \n\n if isinstance(dd, np.ndarray):\n dd=dd[0] \n \n if isinstance(wue, list):\n wue=wue[0]\n \n if isinstance(nue, list):\n nue=nue[0]\n \n if isinstance(A, list):\n A=A[0] \n\n if isinstance(gs, list):\n gs=gs[0] \n\n if isinstance(gsw, list):\n gsw=gsw[0] \n \n if isinstance(E, list):\n E=E[0] \n \n if isinstance(dd, list):\n dd=dd[0] \n \n wue_m_const+=[wue]\n \n \n elif xx==2:\n \n z=0.4\n #---------------Photosynthesis Function---------------#\n \n #alter this line of code for when implementing different photosynthesis functions\n wue, nue, A, E, cs, ci, gsw, gs, gbw, gb, gm, cc,dd =photo(tk_25,ekc,eko,etau,ev,ej,toptv,toptj,na, qeff, PAR,tl,ea,chl,ij,kc25,ko25,o,ca,rh,m,a,frnr,flnr,ra,jm,g0,b,dia,u,q,vwc_min,vwc_max,vwc,z)\n \n if isinstance(wue, np.ndarray):\n wue=wue[0]\n \n if isinstance(nue, np.ndarray):\n nue=nue[0]\n \n if isinstance(A, np.ndarray):\n A=A[0] \n\n if isinstance(gs, np.ndarray):\n gs=gs[0] \n\n if isinstance(gsw, np.ndarray):\n gsw=gsw[0] \n\n if isinstance(E, np.ndarray):\n E=E[0] \n\n if isinstance(dd, np.ndarray):\n dd=dd[0] \n \n if isinstance(wue, list):\n wue=wue[0]\n \n if isinstance(nue, list):\n nue=nue[0]\n \n if isinstance(A, list):\n A=A[0] \n\n if isinstance(gs, list):\n gs=gs[0] \n\n if isinstance(gsw, list):\n gsw=gsw[0] \n \n if isinstance(E, list):\n E=E[0] \n \n if isinstance(dd, list):\n dd=dd[0] \n \n wue_w_const+=[wue]\n\n\n \n#---------------Figure 1: Plant Communities vs. NUE ---------------# \n\n\n #model simulations\n\n nue_bp=ax1A.boxplot([nue_d,nue_w], patch_artist=True, showmeans=True, showfliers=False)\n\n ax1A.set_xticks([1.0,2.0])\n ax1A.set_xticklabels(['Dry Meadow','Wet Meadow'],fontname='Times New Roman',fontsize=20)\n\n for box in nue_bp['boxes']:\n #change outline color\n box.set(color='black',linewidth=2)\n #change fill color\n box.set(facecolor='black',alpha=0.2)\n\n for whisker in nue_bp['whiskers']:\n whisker.set(color='black',linewidth=2)\n \n for cap in nue_bp['caps']:\n cap.set(color='black',linewidth=2)\n\n for median in nue_bp['medians']:\n median.set(color='black', linewidth=2)\n\n for flier in nue_bp['fliers']:\n flier.set(marker='*',color='black',alpha=0.5)\n\n for means in nue_bp['means']:\n means.set(marker='o',markerfacecolor='black') \n\n ax1A.annotate('A', xy=get_axis_limits(ax1A,scale1=0.95,scale2=0.88),fontsize=20,fontname=\"Times New Roman\")\n\n #model validation\n \n ax1B.bar(ax1A.get_xticks(),[72,88], yerr=[2.08,3.81], edgecolor='black', align=\"center\",width=0.2, color='black',alpha=0.5,error_kw={'ecolor':'black', 'lw':2, 'capsize':5, 'capthick':2})\n ax1B.text(0.97,76,\"a\",fontsize=20)\n ax1B.text(1.98,93.5,\"b\",fontsize=20)\n ax1B.annotate('B', xy=get_axis_limits(ax1B,scale2=0.95),fontsize=20,fontname=\"Times New Roman\") \n ax1B.set_xticklabels(['Dry Meadow','Wet Meadow'],fontname='Times New Roman',fontsize=25)\n\n\n\n#---------------Figure 2: Plant Communities vs. WUE ---------------# \n\n #model simulations\n\n wue_bp=ax2A.boxplot([wue_d,wue_w], patch_artist=True, showmeans=True, showfliers=False)\n\n ax2A.set_xticks([1.0,2.0])\n ax2A.set_xticklabels(['Dry Meadow','Moist Meadow'],fontname='Times New Roman',fontsize=25)\n\n for box in wue_bp['boxes']:\n #change outline color\n box.set(color='black',linewidth=2)\n #change fill color\n box.set(facecolor='black',alpha=0.2)\n\n for whisker in wue_bp['whiskers']:\n whisker.set(color='black',linewidth=2)\n \n for cap in wue_bp['caps']:\n cap.set(color='black',linewidth=2)\n\n for median in wue_bp['medians']:\n median.set(color='black', linewidth=2)\n\n for flier in wue_bp['fliers']:\n flier.set(marker='*',color='black',alpha=0.5)\n\n for means in wue_bp['means']:\n means.set(marker='o',markerfacecolor='black') \n\n ax2A.annotate('A', xy=get_axis_limits(ax2A,scale1=0.95,scale2=0.85),fontsize=20,fontname=\"Times New Roman\")\n\n #model validation\n \n ax2B.bar([1.0,2.0],[1.49,1.57], yerr=[0.06,0.04], edgecolor='black', align=\"center\",width=0.2, color='black',alpha=0.5,error_kw={'ecolor':'black', 'lw':2, 'capsize':5, 'capthick':2}) \n ax2B.text(0.97,2,\"a\",fontsize=20)\n ax2B.text(1.98,2,\"a\",fontsize=20)\n ax2B.annotate('B', xy=get_axis_limits(ax2B,scale1=0.95,scale2=0.85),fontsize=20,fontname=\"Times New Roman\") \n ax2B.set_xticklabels(['Dry Meadow','Moist Meadow'],fontname='Times New Roman',fontsize=20)\n\n\n #model simulations when temp and leaf height are constant\n wue_bp_2=ax2C.boxplot([wue_d_const,wue_m_const], patch_artist=True, showmeans=True, showfliers=False)\n\n ax2C.set_xticks([1.0,2.0])\n ax2C.set_xticklabels(['Dry Meadow','Moist Meadow'],fontname='Times New Roman',fontsize=30)\n\n for box in wue_bp_2['boxes']:\n #change outline color\n box.set(color='black',linewidth=2)\n #change fill color\n box.set(facecolor='black',alpha=0.2)\n\n for whisker in wue_bp_2['whiskers']:\n whisker.set(color='black',linewidth=2)\n \n for cap in wue_bp_2['caps']:\n cap.set(color='black',linewidth=2)\n\n for median in wue_bp_2['medians']:\n median.set(color='black', linewidth=2)\n\n for flier in wue_bp_2['fliers']:\n flier.set(marker='*',color='black',alpha=0.5)\n\n for means in wue_bp_2['means']:\n means.set(marker='o',markerfacecolor='black') \n\n ax2C.annotate('C', xy=get_axis_limits(ax2C,scale1=0.95,scale2=0.85),fontsize=20,fontname=\"Times New Roman\")\n \n\n#---------------Figure 3: Plant Communities vs. Assimilation--------------- # \n\n A_bp=ax3A.boxplot([A_d,A_w], patch_artist=True, showmeans=True, showfliers=False)\n\n ax3A.set_xticks([1.0,2.0])\n ax3A.set_xticklabels(['Dry Meadow','Wet Meadow'],fontname='Times New Roman')\n\n \n #A boxplot specs\n for box in A_bp['boxes']:\n #change outline color\n box.set(color='black',linewidth=2)\n #change fill color\n box.set(facecolor='black',alpha=0.2)\n\n for whisker in A_bp['whiskers']:\n whisker.set(color='black',linewidth=2)\n \n for cap in A_bp['caps']:\n cap.set(color='black',linewidth=2)\n\n for median in A_bp['medians']:\n median.set(color='black', linewidth=2)\n\n for flier in A_bp['fliers']:\n flier.set(marker='*',color='black',alpha=0.5)\n\n for means in A_bp['means']:\n means.set(marker='o',markerfacecolor='black') \n \n ax3A.annotate('A', xy=get_axis_limits(ax3A),fontsize=20,fontname=\"Times New Roman\")\n \n \n ax3B.bar([1.0,2.0],[0.91,1.92], yerr=[0.44, 0.81], edgecolor='black', align=\"center\",width=0.2, color='black',alpha=0.5,error_kw={'ecolor':'black', 'lw':2, 'capsize':5, 'capthick':2})\n ax3B.text(0.97,1.6,\"a\",fontsize=20)\n ax3B.text(1.98,3.0,\"b\",fontsize=20)\n ax3B.annotate('B', xy=get_axis_limits(ax3B),fontsize=20,fontname=\"Times New Roman\") \n ax3B.set_xticklabels(['Dry Meadow','Wet Meadow'],fontname='Times New Roman',fontsize=30)\n\n\n\n#---------------Figure 4: leaf height vs. air temperature plot \n ax4.scatter([25,25,25,9,9,5,5,5,5,3,3,3,3,10,10,10,2],[3.6,5.8,12.5,17.2,20.8,13.1,7.2,5.8,11.2,14.,17.7,15.5,24.,14.5,6.3,24.,30.],edgecolors=\"black\",facecolors=\"black\",marker='o',s=30)\n ax4.plot(np.unique([25,25,25,9,9,5,5,5,5,3,3,3,3,10,10,10,2]), np.poly1d(np.polyfit([25,25,25,9,9,5,5,5,5,3,3,3,3,10,10,10,2], [3.6,5.8,12.5,17.2,20.8,13.1,7.2,5.8,11.2,14.,17.7,15.5,24.,14.5,6.3,24.,30.], 1))(np.unique([25,25,25,9,9,5,5,5,5,3,3,3,3,10,10,10,2])),color=\"black\",linewidth=3)\n\n\n \n\n#---------------Figure 5: Regression Plot Assimilation vs. Stomatal Conductance---------------# \n ax5.scatter(A_d+A_w,gs_d+gs_w,edgecolors='black',facecolors='black',marker='o',s=30)\n ax5.plot(np.unique(A_d+A_w), np.poly1d(np.polyfit(A_d+A_w, gs_d+gs_w, 1))(np.unique(A_d+A_w)),color='black',linewidth=3)\n\n\n \n#---------------Figure 6: Plot VPD vs. WUE for validation (use all points rather than mean of points)-------------#\n def func(x, a, b, c):\n return a * np.exp(-b * x) + c\n xdata=np.array(vpd_d+vpd_w)/10000.\n ydata=np.array(wue_d+wue_w)\n L=sorted(zip(xdata,ydata),key=operator.itemgetter(0))\n new_x,new_y=zip(*L)\n popt, pcov = curve_fit(func, np.array(new_x), np.array(new_y))\n \n ax6B.plot(np.array(new_x), func(np.array(new_x), *popt), 'k-', linewidth=3,label='Model Simulation')\n ax6B.scatter(xdata,ydata,edgecolors='black',facecolors='black',marker='o',s=30)\n ax6B.annotate('B', xy=get_axis_limits(ax6B),fontsize=20,fontname=\"Times New Roman\")\n\n\n\n def func(x, a, b, c):\n return a * np.exp(-b * x) + c\n xdata=np.array([13734.61196533664,13734.61196533664,13734.61196533664,13734.61196533664,21364.95194607922,21364.95194607922,21364.95194607922,21364.95194607922,28995.2919268218,28995.2919268218,28995.2919268218,28995.2919268218,13734.61196533664,13734.61196533664,13734.61196533664,13734.61196533664,21364.95194607922,21364.95194607922,21364.95194607922,21364.95194607922,28995.2919268218,28995.2919268218,28995.2919268218,28995.2919268218])/10000.\n ydata=np.array([11,12,11,3,5,4.5,1,5,4,2,1,.5,9,9,10,11,5,5,5,5,5,5,5,2])*.4091\n L=sorted(zip(xdata,ydata),key=operator.itemgetter(0))\n new_x,new_y=zip(*L)\n popt, pcov = curve_fit(func, np.array(new_x), np.array(new_y))\n \n ax6A.plot(np.array(new_x), func(np.array(new_x), *popt), 'k-', linewidth=3,label='fit')\n ax6A.scatter(xdata,ydata,edgecolors=\"black\",facecolors=\"black\",marker='o',s=30,label='Empirical Data')\n ax6A.annotate('A', xy=get_axis_limits(ax6A),fontsize=20,fontname=\"Times New Roman\")\n \n\n \n#-----------FINALIZE PLOT------#\n\n\n figs=[fig1,fig2,fig3,fig4,fig5,fig6]\n axes=[ax1A,ax2A,ax3A,ax1B,ax2B,ax3B,ax2C,ax4,ax5,ax6A,ax6B]\n \n for i in range(len(axes)):\n axes[i].tick_params(axis='y', labelsize=15)\n axes[i].tick_params(axis='x', labelsize=15)\n for tick in axes[i].get_xticklabels():\n tick.set_fontname(\"Times New Roman\")\n for tick in axes[i].get_yticklabels():\n tick.set_fontname(\"Times New Roman\")\n\n\n ax1B.set_xticklabels(['Dry Meadow','Wet Meadow'],fontname='Times New Roman',fontsize=20)\n ax2C.set_xticklabels(['Dry Meadow','Moist Meadow'],fontname='Times New Roman',fontsize=20)\n ax3B.set_xticklabels(['Dry Meadow','Wet Meadow'],fontname='Times New Roman',fontsize=20)\n\n \n# for i in range(len(figs)): \n# figs[i].tight_layout()\n\n#---------------Finalize Figure---------------# \n\n ##---Save Figure--##\n fig1.savefig('NUE_val.png') \n fig2.savefig('WUE_val.png')\n fig3.savefig('Assimilation_val.png')\n fig4.savefig('Leaf_Ht_Temp.png')\n fig5.savefig('Assimilation_vs_Conductance.png')\n fig6.savefig('VPD_vs_WUE.png')\n\n", "meta": {"hexsha": "d991d975d7672c85ad7cf3d44ee8df87a65df924", "size": 31924, "ext": "py", "lang": "Python", "max_stars_repo_path": "Trait_Based_Photo_Model_InterSpecificVariation.py", "max_stars_repo_name": "kwentz10/Photosynthesis_Optimization_Modeling", "max_stars_repo_head_hexsha": "864c174ae4298bfdabee36fd0305c6a3649c38bd", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Trait_Based_Photo_Model_InterSpecificVariation.py", "max_issues_repo_name": "kwentz10/Photosynthesis_Optimization_Modeling", "max_issues_repo_head_hexsha": "864c174ae4298bfdabee36fd0305c6a3649c38bd", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Trait_Based_Photo_Model_InterSpecificVariation.py", "max_forks_repo_name": "kwentz10/Photosynthesis_Optimization_Modeling", "max_forks_repo_head_hexsha": "864c174ae4298bfdabee36fd0305c6a3649c38bd", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.9660460022, "max_line_length": 452, "alphanum_fraction": 0.5358977572, "include": true, "reason": "import numpy,from scipy", "num_tokens": 8832, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5428632831725052, "lm_q2_score": 0.35936414516010196, "lm_q1q2_score": 0.19508559969609368}} {"text": "import numpy as np\nimport pandas as pd\n\nfrom pvlib.tools import cosd, sind, tand\nfrom pvlib.pvsystem import _combine_localized_attributes\nfrom pvlib.pvsystem import PVSystem\nfrom pvlib.location import Location\nfrom pvlib import irradiance, atmosphere\nfrom pvlib._deprecation import deprecated\n\n\nclass SingleAxisTracker(PVSystem):\n \"\"\"\n A class for single-axis trackers that inherits the PV modeling methods from\n :py:class:`~pvlib.pvsystem.PVSystem`. For details on calculating tracker\n rotation see :py:func:`pvlib.tracking.singleaxis`.\n\n Parameters\n ----------\n axis_tilt : float, default 0\n The tilt of the axis of rotation (i.e, the y-axis defined by\n axis_azimuth) with respect to horizontal, in decimal degrees.\n\n axis_azimuth : float, default 0\n A value denoting the compass direction along which the axis of\n rotation lies. Measured in decimal degrees east of north.\n\n max_angle : float, default 90\n A value denoting the maximum rotation angle, in decimal degrees,\n of the one-axis tracker from its horizontal position (horizontal\n if axis_tilt = 0). A max_angle of 90 degrees allows the tracker\n to rotate to a vertical position to point the panel towards a\n horizon. max_angle of 180 degrees allows for full rotation.\n\n backtrack : bool, default True\n Controls whether the tracker has the capability to \"backtrack\"\n to avoid row-to-row shading. False denotes no backtrack\n capability. True denotes backtrack capability.\n\n gcr : float, default 2.0/7.0\n A value denoting the ground coverage ratio of a tracker system\n which utilizes backtracking; i.e. the ratio between the PV array\n surface area to total ground area. A tracker system with modules\n 2 meters wide, centered on the tracking axis, with 6 meters\n between the tracking axes has a gcr of 2/6=0.333. If gcr is not\n provided, a gcr of 2/7 is default. gcr must be <=1.\n\n cross_axis_tilt : float, default 0.0\n The angle, relative to horizontal, of the line formed by the\n intersection between the slope containing the tracker axes and a plane\n perpendicular to the tracker axes. Cross-axis tilt should be specified\n using a right-handed convention. For example, trackers with axis\n azimuth of 180 degrees (heading south) will have a negative cross-axis\n tilt if the tracker axes plane slopes down to the east and positive\n cross-axis tilt if the tracker axes plane slopes up to the east. Use\n :func:`~pvlib.tracking.calc_cross_axis_tilt` to calculate\n `cross_axis_tilt`. [degrees]\n\n **kwargs\n Passed to :py:class:`~pvlib.pvsystem.PVSystem`.\n\n See also\n --------\n pvlib.tracking.singleaxis\n pvlib.tracking.calc_axis_tilt\n pvlib.tracking.calc_cross_axis_tilt\n \"\"\"\n\n def __init__(self, axis_tilt=0, axis_azimuth=0, max_angle=90,\n backtrack=True, gcr=2.0/7.0, cross_axis_tilt=0.0, **kwargs):\n\n self.axis_tilt = axis_tilt\n self.axis_azimuth = axis_azimuth\n self.max_angle = max_angle\n self.backtrack = backtrack\n self.gcr = gcr\n self.cross_axis_tilt = cross_axis_tilt\n\n kwargs['surface_tilt'] = None\n kwargs['surface_azimuth'] = None\n\n super().__init__(**kwargs)\n\n def __repr__(self):\n attrs = ['axis_tilt', 'axis_azimuth', 'max_angle', 'backtrack', 'gcr',\n 'cross_axis_tilt']\n sat_repr = ('SingleAxisTracker:\\n ' + '\\n '.join(\n f'{attr}: {getattr(self, attr)}' for attr in attrs))\n # get the parent PVSystem info\n pvsystem_repr = super().__repr__()\n # remove the first line (contains 'PVSystem: \\n')\n pvsystem_repr = '\\n'.join(pvsystem_repr.split('\\n')[1:])\n return sat_repr + '\\n' + pvsystem_repr\n\n def singleaxis(self, apparent_zenith, apparent_azimuth):\n \"\"\"\n Get tracking data. See :py:func:`pvlib.tracking.singleaxis` more\n detail.\n\n Parameters\n ----------\n apparent_zenith : float, 1d array, or Series\n Solar apparent zenith angles in decimal degrees.\n\n apparent_azimuth : float, 1d array, or Series\n Solar apparent azimuth angles in decimal degrees.\n\n Returns\n -------\n tracking data\n \"\"\"\n tracking_data = singleaxis(apparent_zenith, apparent_azimuth,\n self.axis_tilt, self.axis_azimuth,\n self.max_angle, self.backtrack,\n self.gcr, self.cross_axis_tilt)\n\n return tracking_data\n\n @deprecated('0.8',\n alternative='SingleAxisTracker, Location, and ModelChain',\n name='SingleAxisTracker.localize', removal='0.9')\n def localize(self, location=None, latitude=None, longitude=None,\n **kwargs):\n \"\"\"\n Creates a :py:class:`LocalizedSingleAxisTracker` object using\n this object and location data. Must supply either location\n object or latitude, longitude, and any location kwargs\n\n Parameters\n ----------\n location : None or Location, default None\n latitude : None or float, default None\n longitude : None or float, default None\n **kwargs : see Location\n\n Returns\n -------\n localized_system : LocalizedSingleAxisTracker\n \"\"\"\n\n if location is None:\n location = Location(latitude, longitude, **kwargs)\n\n return LocalizedSingleAxisTracker(pvsystem=self, location=location)\n\n def get_aoi(self, surface_tilt, surface_azimuth, solar_zenith,\n solar_azimuth):\n \"\"\"Get the angle of incidence on the system.\n\n For a given set of solar zenith and azimuth angles, the\n surface tilt and azimuth parameters are typically determined\n by :py:method:`~SingleAxisTracker.singleaxis`. The\n :py:method:`~SingleAxisTracker.singleaxis` method also returns\n the angle of incidence, so this method is only needed\n if using a different tracking algorithm.\n\n Parameters\n ----------\n surface_tilt : numeric\n Panel tilt from horizontal.\n surface_azimuth : numeric\n Panel azimuth from north\n solar_zenith : float or Series.\n Solar zenith angle.\n solar_azimuth : float or Series.\n Solar azimuth angle.\n\n Returns\n -------\n aoi : Series\n The angle of incidence in degrees from normal.\n \"\"\"\n\n aoi = irradiance.aoi(surface_tilt, surface_azimuth,\n solar_zenith, solar_azimuth)\n return aoi\n\n def get_irradiance(self, surface_tilt, surface_azimuth,\n solar_zenith, solar_azimuth, dni, ghi, dhi,\n dni_extra=None, airmass=None, model='haydavies',\n **kwargs):\n \"\"\"\n Uses the :func:`irradiance.get_total_irradiance` function to\n calculate the plane of array irradiance components on a tilted\n surface defined by the input data and ``self.albedo``.\n\n For a given set of solar zenith and azimuth angles, the\n surface tilt and azimuth parameters are typically determined\n by :py:meth:`~SingleAxisTracker.singleaxis`.\n\n Parameters\n ----------\n surface_tilt : numeric\n Panel tilt from horizontal.\n surface_azimuth : numeric\n Panel azimuth from north\n solar_zenith : numeric\n Solar zenith angle.\n solar_azimuth : numeric\n Solar azimuth angle.\n dni : float or Series\n Direct Normal Irradiance\n ghi : float or Series\n Global horizontal irradiance\n dhi : float or Series\n Diffuse horizontal irradiance\n dni_extra : float or Series, default None\n Extraterrestrial direct normal irradiance\n airmass : float or Series, default None\n Airmass\n model : String, default 'haydavies'\n Irradiance model.\n\n **kwargs\n Passed to :func:`irradiance.get_total_irradiance`.\n\n Returns\n -------\n poa_irradiance : DataFrame\n Column names are: ``total, beam, sky, ground``.\n \"\"\"\n\n # not needed for all models, but this is easier\n if dni_extra is None:\n dni_extra = irradiance.get_extra_radiation(solar_zenith.index)\n\n if airmass is None:\n airmass = atmosphere.get_relative_airmass(solar_zenith)\n\n return irradiance.get_total_irradiance(surface_tilt,\n surface_azimuth,\n solar_zenith,\n solar_azimuth,\n dni, ghi, dhi,\n dni_extra=dni_extra,\n airmass=airmass,\n model=model,\n albedo=self.albedo,\n **kwargs)\n\n\n@deprecated('0.8', alternative='SingleAxisTracker, Location, and ModelChain',\n name='LocalizedSingleAxisTracker', removal='0.9')\nclass LocalizedSingleAxisTracker(SingleAxisTracker, Location):\n \"\"\"\n The :py:class:`~pvlib.tracking.LocalizedSingleAxisTracker` class defines a\n standard set of installed PV system attributes and modeling functions. This\n class combines the attributes and methods of the\n :py:class:`~pvlib.tracking.SingleAxisTracker` (a subclass of\n :py:class:`~pvlib.pvsystem.PVSystem`) and\n :py:class:`~pvlib.location.Location` classes.\n\n The :py:class:`~pvlib.tracking.LocalizedSingleAxisTracker` may have bugs\n due to the difficulty of robustly implementing multiple inheritance. See\n :py:class:`~pvlib.modelchain.ModelChain` for an alternative paradigm\n for modeling PV systems at specific locations.\n \"\"\"\n\n def __init__(self, pvsystem=None, location=None, **kwargs):\n\n new_kwargs = _combine_localized_attributes(\n pvsystem=pvsystem,\n location=location,\n **kwargs,\n )\n\n SingleAxisTracker.__init__(self, **new_kwargs)\n Location.__init__(self, **new_kwargs)\n\n def __repr__(self):\n attrs = ['latitude', 'longitude', 'altitude', 'tz']\n return ('Localized' +\n super().__repr__() + '\\n ' +\n '\\n '.join(\n f'{attr}: {getattr(self, attr)}' for attr in attrs))\n\n\ndef singleaxis(apparent_zenith, apparent_azimuth,\n axis_tilt=0, axis_azimuth=0, max_angle=90,\n backtrack=True, gcr=2.0/7.0, cross_axis_tilt=0):\n \"\"\"\n Determine the rotation angle of a single-axis tracker when given particular\n solar zenith and azimuth angles.\n\n See [1]_ for details about the equations. Backtracking may be specified,\n and if so, a ground coverage ratio is required.\n\n Rotation angle is determined in a right-handed coordinate system. The\n tracker `axis_azimuth` defines the positive y-axis, the positive x-axis is\n 90 degrees clockwise from the y-axis and parallel to the Earth's surface,\n and the positive z-axis is normal to both x & y-axes and oriented skyward.\n Rotation angle `tracker_theta` is a right-handed rotation around the y-axis\n in the x, y, z coordinate system and indicates tracker position relative to\n horizontal. For example, if tracker `axis_azimuth` is 180 (oriented south)\n and `axis_tilt` is zero, then a `tracker_theta` of zero is horizontal, a\n `tracker_theta` of 30 degrees is a rotation of 30 degrees towards the west,\n and a `tracker_theta` of -90 degrees is a rotation to the vertical plane\n facing east.\n\n Parameters\n ----------\n apparent_zenith : float, 1d array, or Series\n Solar apparent zenith angles in decimal degrees.\n\n apparent_azimuth : float, 1d array, or Series\n Solar apparent azimuth angles in decimal degrees.\n\n axis_tilt : float, default 0\n The tilt of the axis of rotation (i.e, the y-axis defined by\n axis_azimuth) with respect to horizontal, in decimal degrees.\n\n axis_azimuth : float, default 0\n A value denoting the compass direction along which the axis of\n rotation lies. Measured in decimal degrees east of north.\n\n max_angle : float, default 90\n A value denoting the maximum rotation angle, in decimal degrees,\n of the one-axis tracker from its horizontal position (horizontal\n if axis_tilt = 0). A max_angle of 90 degrees allows the tracker\n to rotate to a vertical position to point the panel towards a\n horizon. max_angle of 180 degrees allows for full rotation.\n\n backtrack : bool, default True\n Controls whether the tracker has the capability to \"backtrack\"\n to avoid row-to-row shading. False denotes no backtrack\n capability. True denotes backtrack capability.\n\n gcr : float, default 2.0/7.0\n A value denoting the ground coverage ratio of a tracker system\n which utilizes backtracking; i.e. the ratio between the PV array\n surface area to total ground area. A tracker system with modules\n 2 meters wide, centered on the tracking axis, with 6 meters\n between the tracking axes has a gcr of 2/6=0.333. If gcr is not\n provided, a gcr of 2/7 is default. gcr must be <=1.\n\n cross_axis_tilt : float, default 0.0\n The angle, relative to horizontal, of the line formed by the\n intersection between the slope containing the tracker axes and a plane\n perpendicular to the tracker axes. Cross-axis tilt should be specified\n using a right-handed convention. For example, trackers with axis\n azimuth of 180 degrees (heading south) will have a negative cross-axis\n tilt if the tracker axes plane slopes down to the east and positive\n cross-axis tilt if the tracker axes plane slopes up to the east. Use\n :func:`~pvlib.tracking.calc_cross_axis_tilt` to calculate\n `cross_axis_tilt`. [degrees]\n\n Returns\n -------\n dict or DataFrame with the following columns:\n * `tracker_theta`: The rotation angle of the tracker.\n tracker_theta = 0 is horizontal, and positive rotation angles are\n clockwise. [degrees]\n * `aoi`: The angle-of-incidence of direct irradiance onto the\n rotated panel surface. [degrees]\n * `surface_tilt`: The angle between the panel surface and the earth\n surface, accounting for panel rotation. [degrees]\n * `surface_azimuth`: The azimuth of the rotated panel, determined by\n projecting the vector normal to the panel's surface to the earth's\n surface. [degrees]\n\n See also\n --------\n pvlib.tracking.calc_axis_tilt\n pvlib.tracking.calc_cross_axis_tilt\n\n References\n ----------\n .. [1] Kevin Anderson and Mark Mikofski, \"Slope-Aware Backtracking for\n Single-Axis Trackers\", Technical Report NREL/TP-5K00-76626, July 2020.\n https://www.nrel.gov/docs/fy20osti/76626.pdf\n \"\"\"\n\n # MATLAB to Python conversion by\n # Will Holmgren (@wholmgren), U. Arizona. March, 2015.\n\n if isinstance(apparent_zenith, pd.Series):\n index = apparent_zenith.index\n else:\n index = None\n\n # convert scalars to arrays\n apparent_azimuth = np.atleast_1d(apparent_azimuth)\n apparent_zenith = np.atleast_1d(apparent_zenith)\n\n if apparent_azimuth.ndim > 1 or apparent_zenith.ndim > 1:\n raise ValueError('Input dimensions must not exceed 1')\n\n # Calculate sun position x, y, z using coordinate system as in [1], Eq 1.\n\n # NOTE: solar elevation = 90 - solar zenith, then use trig identities:\n # sin(90-x) = cos(x) & cos(90-x) = sin(x)\n sin_zenith = sind(apparent_zenith)\n x = sin_zenith * sind(apparent_azimuth)\n y = sin_zenith * cosd(apparent_azimuth)\n z = cosd(apparent_zenith)\n\n # Assume the tracker reference frame is right-handed. Positive y-axis is\n # oriented along tracking axis; from north, the y-axis is rotated clockwise\n # by the axis azimuth and tilted from horizontal by the axis tilt. The\n # positive x-axis is 90 deg clockwise from the y-axis and parallel to\n # horizontal (e.g., if the y-axis is south, the x-axis is west); the\n # positive z-axis is normal to the x and y axes, pointed upward.\n\n # Calculate sun position (xp, yp, zp) in tracker coordinate system using\n # [1] Eq 4.\n\n cos_axis_azimuth = cosd(axis_azimuth)\n sin_axis_azimuth = sind(axis_azimuth)\n cos_axis_tilt = cosd(axis_tilt)\n sin_axis_tilt = sind(axis_tilt)\n xp = x*cos_axis_azimuth - y*sin_axis_azimuth\n yp = (x*cos_axis_tilt*sin_axis_azimuth\n + y*cos_axis_tilt*cos_axis_azimuth\n - z*sin_axis_tilt)\n zp = (x*sin_axis_tilt*sin_axis_azimuth\n + y*sin_axis_tilt*cos_axis_azimuth\n + z*cos_axis_tilt)\n\n # The ideal tracking angle wid is the rotation to place the sun position\n # vector (xp, yp, zp) in the (y, z) plane, which is normal to the panel and\n # contains the axis of rotation. wid = 0 indicates that the panel is\n # horizontal. Here, our convention is that a clockwise rotation is\n # positive, to view rotation angles in the same frame of reference as\n # azimuth. For example, for a system with tracking axis oriented south, a\n # rotation toward the east is negative, and a rotation to the west is\n # positive. This is a right-handed rotation around the tracker y-axis.\n\n # Calculate angle from x-y plane to projection of sun vector onto x-z plane\n # using [1] Eq. 5.\n\n wid = np.degrees(np.arctan2(xp, zp))\n\n # filter for sun above panel horizon\n zen_gt_90 = apparent_zenith > 90\n wid[zen_gt_90] = np.nan\n\n # Account for backtracking\n if backtrack:\n # distance between rows in terms of rack lengths relative to cross-axis\n # tilt\n axes_distance = 1/(gcr * cosd(cross_axis_tilt))\n\n # NOTE: account for rare angles below array, see GH 824\n temp = np.abs(axes_distance * cosd(wid - cross_axis_tilt))\n\n # backtrack angle using [1], Eq. 14\n with np.errstate(invalid='ignore'):\n wc = np.degrees(-np.sign(wid)*np.arccos(temp))\n\n # NOTE: in the middle of the day, arccos(temp) is out of range because\n # there's no row-to-row shade to avoid, & backtracking is unnecessary\n # [1], Eqs. 15-16\n with np.errstate(invalid='ignore'):\n tracker_theta = wid + np.where(temp < 1, wc, 0)\n else:\n tracker_theta = wid\n\n # NOTE: max_angle defined relative to zero-point rotation, not the\n # system-plane normal\n tracker_theta = np.clip(tracker_theta, -max_angle, max_angle)\n\n # Calculate panel normal vector in panel-oriented x, y, z coordinates.\n # y-axis is axis of tracker rotation. tracker_theta is a compass angle\n # (clockwise is positive) rather than a trigonometric angle.\n # NOTE: the *0 is a trick to preserve NaN values.\n panel_norm = np.array([sind(tracker_theta),\n tracker_theta*0,\n cosd(tracker_theta)])\n\n # sun position in vector format in panel-oriented x, y, z coordinates\n sun_vec = np.array([xp, yp, zp])\n\n # calculate angle-of-incidence on panel\n aoi = np.degrees(np.arccos(np.abs(np.sum(sun_vec*panel_norm, axis=0))))\n\n # Calculate panel tilt and azimuth in a coordinate system where the panel\n # tilt is the angle from horizontal, and the panel azimuth is the compass\n # angle (clockwise from north) to the projection of the panel's normal to\n # the earth's surface. These outputs are provided for convenience and\n # comparison with other PV software which use these angle conventions.\n\n # Project normal vector to earth surface. First rotate about x-axis by\n # angle -axis_tilt so that y-axis is also parallel to earth surface, then\n # project.\n\n # Calculate standard rotation matrix\n rot_x = np.array([[1, 0, 0],\n [0, cosd(-axis_tilt), -sind(-axis_tilt)],\n [0, sind(-axis_tilt), cosd(-axis_tilt)]])\n\n # panel_norm_earth contains the normal vector expressed in earth-surface\n # coordinates (z normal to surface, y aligned with tracker axis parallel to\n # earth)\n panel_norm_earth = np.dot(rot_x, panel_norm).T\n\n # projection to plane tangent to earth surface, in earth surface\n # coordinates\n projected_normal = np.array([panel_norm_earth[:, 0],\n panel_norm_earth[:, 1],\n panel_norm_earth[:, 2]*0]).T\n\n # calculate vector magnitudes\n projected_normal_mag = np.sqrt(np.nansum(projected_normal**2, axis=1))\n\n # renormalize the projected vector, avoid creating nan values.\n non_zeros = projected_normal_mag != 0\n projected_normal[non_zeros] = (projected_normal[non_zeros].T /\n projected_normal_mag[non_zeros]).T\n\n # calculation of surface_azimuth\n surface_azimuth = \\\n np.degrees(np.arctan2(projected_normal[:, 1], projected_normal[:, 0]))\n\n # Rotate 0 reference from panel's x-axis to its y-axis and then back to\n # north.\n surface_azimuth = 90 - surface_azimuth + axis_azimuth\n\n # Map azimuth into [0,360) domain.\n with np.errstate(invalid='ignore'):\n surface_azimuth = surface_azimuth % 360\n\n # Calculate surface_tilt\n dotproduct = (panel_norm_earth * projected_normal).sum(axis=1)\n surface_tilt = 90 - np.degrees(np.arccos(dotproduct))\n\n # Bundle DataFrame for return values and filter for sun below horizon.\n out = {'tracker_theta': tracker_theta, 'aoi': aoi,\n 'surface_tilt': surface_tilt, 'surface_azimuth': surface_azimuth}\n if index is not None:\n out = pd.DataFrame(out, index=index)\n out = out[['tracker_theta', 'aoi', 'surface_azimuth', 'surface_tilt']]\n out[zen_gt_90] = np.nan\n else:\n out = {k: np.where(zen_gt_90, np.nan, v) for k, v in out.items()}\n\n return out\n\n\ndef calc_axis_tilt(slope_azimuth, slope_tilt, axis_azimuth):\n \"\"\"\n Calculate tracker axis tilt in the global reference frame when on a sloped\n plane.\n\n Parameters\n ----------\n slope_azimuth : float\n direction of normal to slope on horizontal [degrees]\n slope_tilt : float\n tilt of normal to slope relative to vertical [degrees]\n axis_azimuth : float\n direction of tracker axes on horizontal [degrees]\n\n Returns\n -------\n axis_tilt : float\n tilt of tracker [degrees]\n\n See also\n --------\n pvlib.tracking.singleaxis\n pvlib.tracking.calc_cross_axis_tilt\n\n Notes\n -----\n See [1]_ for derivation of equations.\n\n References\n ----------\n .. [1] Kevin Anderson and Mark Mikofski, \"Slope-Aware Backtracking for\n Single-Axis Trackers\", Technical Report NREL/TP-5K00-76626, July 2020.\n https://www.nrel.gov/docs/fy20osti/76626.pdf\n \"\"\"\n delta_gamma = axis_azimuth - slope_azimuth\n # equations 18-19\n tan_axis_tilt = cosd(delta_gamma) * tand(slope_tilt)\n return np.degrees(np.arctan(tan_axis_tilt))\n\n\ndef _calc_tracker_norm(ba, bg, dg):\n \"\"\"\n Calculate tracker normal, v, cross product of tracker axis and unit normal,\n N, to the system slope plane.\n\n Parameters\n ----------\n ba : float\n axis tilt [degrees]\n bg : float\n ground tilt [degrees]\n dg : float\n delta gamma, difference between axis and ground azimuths [degrees]\n\n Returns\n -------\n vector : tuple\n vx, vy, vz\n \"\"\"\n cos_ba = cosd(ba)\n cos_bg = cosd(bg)\n sin_bg = sind(bg)\n sin_dg = sind(dg)\n vx = sin_dg * cos_ba * cos_bg\n vy = sind(ba)*sin_bg + cosd(dg)*cos_ba*cos_bg\n vz = -sin_dg*sin_bg*cos_ba\n return vx, vy, vz\n\n\ndef _calc_beta_c(v, dg, ba):\n \"\"\"\n Calculate the cross-axis tilt angle.\n\n Parameters\n ----------\n v : tuple\n tracker normal\n dg : float\n delta gamma, difference between axis and ground azimuths [degrees]\n ba : float\n axis tilt [degrees]\n\n Returns\n -------\n beta_c : float\n cross-axis tilt angle [radians]\n \"\"\"\n vnorm = np.sqrt(np.dot(v, v))\n beta_c = np.arcsin(\n ((v[0]*cosd(dg) - v[1]*sind(dg)) * sind(ba) + v[2]*cosd(ba)) / vnorm)\n return beta_c\n\n\ndef calc_cross_axis_tilt(\n slope_azimuth, slope_tilt, axis_azimuth, axis_tilt):\n \"\"\"\n Calculate the angle, relative to horizontal, of the line formed by the\n intersection between the slope containing the tracker axes and a plane\n perpendicular to the tracker axes.\n\n Use the cross-axis tilt to avoid row-to-row shade when backtracking on a\n slope not parallel with the axis azimuth. Cross-axis tilt should be\n specified using a right-handed convention. For example, trackers with axis\n azimuth of 180 degrees (heading south) will have a negative cross-axis tilt\n if the tracker axes plane slopes down to the east and positive cross-axis\n tilt if the tracker axes plane slopes up to the east.\n\n Parameters\n ----------\n slope_azimuth : float\n direction of the normal to the slope containing the tracker axes, when\n projected on the horizontal [degrees]\n slope_tilt : float\n angle of the slope containing the tracker axes, relative to horizontal\n [degrees]\n axis_azimuth : float\n direction of tracker axes projected on the horizontal [degrees]\n axis_tilt : float\n tilt of trackers relative to horizontal [degrees]\n\n Returns\n -------\n cross_axis_tilt : float\n angle, relative to horizontal, of the line formed by the intersection\n between the slope containing the tracker axes and a plane perpendicular\n to the tracker axes [degrees]\n\n See also\n --------\n pvlib.tracking.singleaxis\n pvlib.tracking.calc_axis_tilt\n\n Notes\n -----\n See [1]_ for derivation of equations.\n\n References\n ----------\n .. [1] Kevin Anderson and Mark Mikofski, \"Slope-Aware Backtracking for\n Single-Axis Trackers\", Technical Report NREL/TP-5K00-76626, July 2020.\n https://www.nrel.gov/docs/fy20osti/76626.pdf\n \"\"\"\n # delta-gamma, difference between axis and slope azimuths\n delta_gamma = axis_azimuth - slope_azimuth\n # equation 22\n v = _calc_tracker_norm(axis_tilt, slope_tilt, delta_gamma)\n # equation 26\n beta_c = _calc_beta_c(v, delta_gamma, axis_tilt)\n return np.degrees(beta_c)\n", "meta": {"hexsha": "5397055935a6a51d1ec458c553341690ee1441bb", "size": 26706, "ext": "py", "lang": "Python", "max_stars_repo_path": "pvlib/tracking.py", "max_stars_repo_name": "veronicaguo/pvlib-python", "max_stars_repo_head_hexsha": "04a523fafbd61bc2e49420963b84ed8e2bd1b3cf", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pvlib/tracking.py", "max_issues_repo_name": "veronicaguo/pvlib-python", "max_issues_repo_head_hexsha": "04a523fafbd61bc2e49420963b84ed8e2bd1b3cf", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pvlib/tracking.py", "max_forks_repo_name": "veronicaguo/pvlib-python", "max_forks_repo_head_hexsha": "04a523fafbd61bc2e49420963b84ed8e2bd1b3cf", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.8168604651, "max_line_length": 79, "alphanum_fraction": 0.6488429566, "include": true, "reason": "import numpy", "num_tokens": 6313, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5428632831725052, "lm_q2_score": 0.3593641382989649, "lm_q1q2_score": 0.19508559597143432}} {"text": "# FIXME: make pylint happy !\n#pylint: disable=all\n\nfrom sympy.utilities.codegen import CodeGen, CodeGenError, ResultBase, Result, InputArgument, InOutArgument, OutputArgument\nfrom sympy.core import Symbol, S, Expr, Tuple, Equality, Function, sympify\nfrom sympy.core.compatibility import is_sequence, StringIO, string_types\nfrom sympy.printing.codeprinter import AssignmentError\nfrom sympy.core.sympify import _sympify, sympify\n\nfrom sympy.tensor import Idx, Indexed, IndexedBase\nfrom sympy.matrices import (MatrixSymbol, ImmutableMatrix, MatrixBase,\n MatrixExpr, MatrixSlice)\nfrom sympy.core.basic import Basic\n\ndefault_settings = {'export': True}\n\nfrom .ast import For, If\nfrom .printing.cython import cython_code, CythonCodePrinter\nfrom .printing.numpy import numpy_code, NumpyCodePrinter\nfrom .printing.loopy import loopy_code, LoopyCodePrinter\n\nclass Routine(object):\n \"\"\"Generic description of evaluation routine for set of expressions.\n\n A CodeGen class can translate instances of this class into code in a\n particular language. The routine specification covers all the features\n present in these languages. The CodeGen part must raise an exception\n when certain features are not present in the target language. For\n example, multiple return values are possible in Python, but not in C or\n Fortran. Another example: Fortran and Python support complex numbers,\n while C does not.\n\n \"\"\"\n\n def __init__(self, name, arguments, instructions, idx_vars, local_vars, settings={}):\n \"\"\"Initialize a Routine instance.\n\n Parameters\n ==========\n\n name : string\n Name of the routine.\n\n arguments : list of Arguments\n These are things that appear in arguments of a routine, often\n appearing on the right-hand side of a function call. These are\n commonly InputArguments but in some languages, they can also be\n OutputArguments or InOutArguments (e.g., pass-by-reference in C\n code).\n\n instructions : list\n Instructions of the routine.\n\n local_vars : list of Symbols\n These are used internally by the routine.\n\n global_vars : list of Symbols\n Variables which will not be passed into the function.\n\n \"\"\"\n\n # extract all input symbols and all symbols appearing in an expression\n input_symbols = set([])\n symbols = set([])\n for arg in arguments:\n if isinstance(arg, OutputArgument):\n symbols.update(arg.expr.free_symbols)\n elif isinstance(arg, InputArgument):\n input_symbols.add(arg.name)\n elif isinstance(arg, InOutArgument):\n input_symbols.add(arg.name)\n symbols.update(arg.expr.free_symbols)\n else:\n raise ValueError(\"Unknown Routine argument: %s\" % arg)\n\n for i in instructions:\n symbols.update(i.free_symbols)\n\n symbols = set([s.label if isinstance(s, Idx) else s for s in symbols])\n\n # Check that all symbols in the expressions are covered by\n # InputArguments/InOutArguments---subset because user could\n # specify additional (unused) InputArguments or local_vars.\n dummy = [i.label for i in idx_vars]\n symbol_indexed_local = set()\n for l in local_vars:\n for ll in l.atoms(IndexedBase):\n symbol_indexed_local.update(ll.atoms(Symbol) - ll.shape.atoms(Symbol))\n\n notcovered = symbols.difference(\n input_symbols.union(dummy).union(local_vars).union(symbol_indexed_local))\n if notcovered != set([]):\n raise ValueError(\"Symbols needed for output are not in input \" +\n \", \".join([str(x) for x in notcovered]))\n\n self.name = name\n self.arguments = arguments\n self.instructions = instructions\n self.idx_vars = idx_vars\n self.local_vars = local_vars\n self.settings = settings\n\n def __str__(self):\n return self.__class__.__name__ + \"({name!r}, {arguments}, {instructions}, {idx_vars}, {local_vars})\".format(**self.__dict__)\n\n __repr__ = __str__\n\n @property\n def variables(self):\n \"\"\"Returns a set of all variables possibly used in the routine.\n\n For routines with unnamed return values, the dummies that may or\n may not be used will be included in the set.\n\n \"\"\"\n v = set(self.local_vars)\n for arg in self.arguments:\n v.add(arg.name)\n for res in self.results:\n v.add(res.result_var)\n return v\n\n\ndef get_dims_and_symbol(expr):\n if isinstance(expr, Indexed):\n dims = tuple([ (S.Zero, dim - 1) for dim in expr.shape])\n symbol = expr.base.label\n elif isinstance(expr, Symbol):\n dims = []\n symbol = expr\n elif isinstance(expr, MatrixSymbol):\n dims = tuple([ (S.Zero, dim - 1) for dim in expr.shape if dim != 1])\n symbol = expr\n elif isinstance(expr, MatrixBase):\n # if we have a Matrix, we set line by line the code\n # useful when you have indexes like\n # A[i, j, 0] = B[i, j, 4]\n\n # todo: regarder que les matrices pour le in et out ont la meme taille\n # todo: regarder si le symbole est toujours le meme dans le terme de gauche (expr)\n for i in range(expr.shape[0]):\n symbol = expr[i].base.label\n dims = tuple([ (S.Zero, dim - 1) for dim in expr[i].base.shape if dim != 1])\n elif isinstance(expr, MatrixSlice):\n symbol = expr.parent\n dims = tuple([ (S.Zero, dim - 1) for dim in symbol.shape if dim != 1])\n else:\n raise CodeGenError(\"Only Indexed, Symbol, or MatrixSymbol \"\n \"can define output arguments.\")\n return dims, symbol\n\ndef extract(expressions, symbols):\n # extract arguments and instructions of the routine\n output_args = []\n instructions = []\n for expr in expressions:\n instructions.append(expr)\n if isinstance(expr, Equality):\n out_arg = expr.lhs\n expr = expr.rhs\n dims, symbol = get_dims_and_symbol(out_arg)\n\n if symbol in symbols:\n output_args.append(\n InOutArgument(symbol, out_arg, expr, dimensions=dims))\n\n # avoid duplicate arguments\n symbols.remove(symbol)\n elif isinstance(expr, For):\n args, vals = extract(expr.expr, symbols)\n output_args += args\n elif isinstance(expr, If):\n for c, e in expr.statement:\n args, vals = extract(e, symbols)\n output_args += args\n else:\n raise TypeError(\"The expression must be a For or an equality (Eq).\")\n return output_args, instructions\n\n\nclass LBMCodeGen(CodeGen):\n \"\"\"Generator for Cython code.\n\n The .write() method inherited from CodeGen will output a code file .pyx.\n\n \"\"\"\n\n code_extension = None\n\n def routine(self, name, expr, argument_sequence, local_vars, settings):\n \"\"\"Specialized Routine creation for Cython.\"\"\"\n\n if is_sequence(expr) and not isinstance(expr, (MatrixBase, MatrixExpr)):\n if not expr:\n raise ValueError(\"No expression given\")\n expressions = Tuple(*expr)\n else:\n expressions = Tuple(expr)\n\n self.settings = settings\n\n # local variables\n idx_vars = set()\n symbol_idx_vars = set()\n for l in expressions.atoms(For):\n idx_vars.update({i for i in l.atoms(Idx)})\n # remove symbols that have the same name of Idx in loop\n name_idx = [i.label.name for i in l.atoms(Idx)]\n symbol_idx_vars.update({i for i in l.atoms(Symbol) if i.name in name_idx})\n\n score_table = {}\n for i in idx_vars:\n score_table[i] = 0\n\n def rate_index_position(p):\n return p*5\n\n arrays = expressions.atoms(Indexed)\n for arr in arrays:\n for p, ind in enumerate(arr.indices):\n try:\n score_table[ind] += rate_index_position(p)\n except KeyError:\n pass\n\n idx_order = sorted(idx_vars, key=lambda x: score_table[x])\n\n # local variables\n local_vars = set() if local_vars is None else set(local_vars)\n\n # symbols that should be arguments\n symbol_indexed_local = set()\n for l in local_vars:\n for ll in l.atoms(IndexedBase):\n symbol_indexed_local.update(ll.atoms(Symbol) - ll.shape.atoms(Symbol))\n\n symbols = expressions.free_symbols - idx_vars - local_vars - symbol_idx_vars - symbol_indexed_local\n\n new_symbols = set([])\n new_symbols.update(symbols)\n\n for symbol in symbols:\n if isinstance(symbol, Idx):\n new_symbols.remove(symbol)\n if symbol.label in idx_vars:\n new_symbols.update(symbol.args[1].free_symbols)\n else:\n new_symbols.update([symbol.label])\n symbols = new_symbols\n\n output_args, instructions = extract(expressions, symbols)\n\n arg_list = []\n\n # setup input argument list\n array_symbols = {}\n for array in expressions.atoms(Indexed):\n array_symbols[array.base.label] = array\n for array in expressions.atoms(MatrixSymbol):\n array_symbols[array] = array\n\n for symbol in sorted(symbols, key=str):\n if symbol in array_symbols:\n dims = []\n array = array_symbols[symbol]\n for dim in array.shape:\n if dim != 1:\n dims.append((S.Zero, dim - 1))\n metadata = {'dimensions': dims}\n else:\n metadata = {}\n\n arg_list.append(InputArgument(symbol, **metadata))\n\n output_args.sort(key=lambda x: str(x.name))\n arg_list.extend(output_args)\n\n if argument_sequence is not None:\n # if the user has supplied IndexedBase instances, we'll accept that\n new_sequence = []\n for arg in argument_sequence:\n if isinstance(arg, IndexedBase):\n new_sequence.append(arg.label)\n else:\n new_sequence.append(arg)\n argument_sequence = new_sequence\n\n missing = [x for x in arg_list if x.name not in argument_sequence]\n if missing:\n msg = \"Argument list didn't specify: {0} \"\n msg = msg.format(\", \".join([str(m.name) for m in missing]))\n raise CodeGenArgumentListError(msg, missing)\n\n # create redundant arguments to produce the requested sequence\n name_arg_dict = {x.name: x for x in arg_list}\n new_args = []\n for symbol in argument_sequence:\n try:\n new_args.append(name_arg_dict[symbol])\n except KeyError:\n new_args.append(InputArgument(symbol))\n arg_list = new_args\n\n return Routine(name, arg_list, instructions, idx_order, local_vars, settings)\n\n def code_generator(self, expr, assign_to=None):\n pass\n\n def _get_symbol(self, s):\n \"\"\"Print the symbol appropriately.\"\"\"\n return self.code_generator(s).strip()\n\n def _call_printer(self, routine):\n code_lines = []\n\n # Compose a list of symbols to be dereferenced in the function\n # body. These are the arguments that were passed by a reference\n # pointer, excluding arrays.\n dereference = []\n for arg in routine.arguments:\n if isinstance(arg, ResultBase) and not arg.dimensions:\n dereference.append(arg.name)\n\n for instruction in routine.instructions:\n constants, not_supported, expr = self.code_generator(instruction, human=False)\n code_lines.append(\"%s\\n\" % (expr))\n return code_lines\n\n # declarations = []\n # code_lines = []\n # for i, result in enumerate(routine.results):\n # print(self.settings)\n # constants, not_supported, jl_expr = self.code_generator(result, human=False, **self.settings)\n\n # for obj, v in sorted(constants, key=str):\n # declarations.append(\n # \"%s = %s\\n\" % (obj, v))\n # for obj in sorted(not_supported, key=str):\n # if isinstance(obj, Function):\n # name = obj.func\n # else:\n # name = obj\n # declarations.append(\n # \"# unsupported: %s\\n\" % (name))\n # code_lines.append(\"%s\\n\" % (jl_expr))\n # return declarations + code_lines\n\n def _get_routine_opening(self, routine):\n return []\n\n def _get_routine_ending(self, routine):\n return []\n\n\nclass CythonCodeGen(LBMCodeGen):\n \"\"\"Generator for Cython code.\n\n The .write() method inherited from CodeGen will output a code file .pyx.\n\n \"\"\"\n\n code_extension = \"pyx\"\n\n def code_generator(self, expr, assign_to=None, **settings):\n return cython_code(expr, assign_to, **settings)\n\n def _get_header(self):\n code_lines = [\"#!python\\n\",\n \"#cython: boundscheck=False\\n\",\n \"#cython: wraparound=False\\n\",\n \"#cython: cdivision=True\\n\",\n \"#cython: binding=True\\n\",\n \"#import cython\\n\",\n \"from libc.math cimport *\\n\",\n \"import numpy as np\\n\",\n ]\n return code_lines + [\"\\n\\n\"]\n\n def _preprocessor_statements(self, prefix):\n # code_lines = [\"#!python\\n\",\n # \"#cython: boundscheck=False\\n\",\n # \"#cython: wraparound=False\\n\",\n # \"#cython: cdivision=True\\n\",\n # \"#cython: binding=True\\n\",\n # \"#import cython\\n\",\n # \"from libc.math cimport *\\n\",\n # ]\n # return code_lines + [\"\\n\\n\"]\n return []\n\n def _get_routine_opening(self, routine):\n \"\"\"Returns the opening statements of the routine.\"\"\"\n code_list = []\n export = True\n # export = self.settings.pop('export', True)\n if export:\n code_list.append(\"def \")\n else:\n code_list.append(\"cdef void \")\n\n # Inputs\n args = []\n for i, arg in enumerate(routine.arguments):\n if isinstance(arg, OutputArgument):\n raise CodeGenError(\"Cython: invalid argument of type %s\" %\n str(type(arg)))\n\n if isinstance(arg, (InputArgument, InOutArgument)):\n name = self._get_symbol(arg.name)\n if not arg.dimensions:\n # If it is a scalar\n if isinstance(arg, ResultBase):\n # if it is an output\n args.append((arg.get_datatype('C'), \"*%s\" % name))\n else:\n # if it is an output\n args.append((arg.get_datatype('C'), name))\n else:\n if not export and len(arg.dimensions) == 1:\n # if the dimension is 1\n args.append((arg.get_datatype('C'), \"*%s\" % name))\n else:\n args.append((arg.get_datatype('C') + '[' + ', '.join([':']*len(arg.dimensions)) + ':1]', \"%s\" % name))\n\n args = \", \".join([ \"%s %s\" % t for t in args])\n code_list.append(\"%s(%s)%s\\n\" % (routine.name, args, \":\" if export else \" nogil:\"))\n code_list = [ \"\".join(code_list) ]\n\n return code_list\n\n def _declare_arguments(self, routine):\n return []\n\n def _declare_globals(self, routine):\n args = []\n for g in routine.local_vars:\n if isinstance(g, Symbol):\n args.append(\"cdef double %s\\n\"%(self._get_symbol(g)))\n else:\n shape = [d for d in g.shape if d!=1]\n if isinstance(g, Indexed):\n args.append(\"cdef double[%s] %s = np.zeros((%s))\\n\"%(', '.join([':']*len(shape)) + ':1', g.base, ','.join(\"%s\"%s for s in shape)))\n else:\n args.append(\"cdef double %s[%s]\\n\"%(self._get_symbol(g), ','.join(\"%s\"%s for s in shape)))\n return [\"\".join(args)]\n\n def _declare_locals(self, routine):\n s = []\n for l in routine.idx_vars:\n s.append(\"cdef int %s\\n\" % l.label)\n return s + ['\\n']\n\n def _get_routine_ending(self, routine):\n return [\"#end\\n\"]\n\n def _indent_code(self, codelines):\n p = CythonCodePrinter()\n return p.indent_code(codelines)\n\n def dump_pyx(self, routines, f, prefix, header=True, empty=True):\n self.dump_code(routines, f, prefix, header, empty)\n\n dump_pyx.extension = code_extension\n dump_pyx.__doc__ = CodeGen.dump_code.__doc__\n\n # This list of dump functions is used by CodeGen.write to know which dump\n # functions it has to call.\n dump_fns = [dump_pyx]\n\n\nclass NumpyCodeGen(LBMCodeGen):\n \"\"\"Generator for Cython code.\n\n The .write() method inherited from CodeGen will output a code file .pyx.\n\n \"\"\"\n\n code_extension = \"py\"\n\n def code_generator(self, expr, assign_to=None, **settings):\n return numpy_code(expr, assign_to, **settings)\n\n def _get_header(self):\n code_lines = [\"import numpy as np\\n\",\n ]\n return code_lines + [\"\\n\\n\"]\n\n def _preprocessor_statements(self, prefix):\n return []\n\n def _get_routine_opening(self, routine):\n \"\"\"Returns the opening statements of the routine.\"\"\"\n code_list = []\n code_list.append(\"def \")\n\n # Inputs\n args = []\n for i, arg in enumerate(routine.arguments):\n if isinstance(arg, OutputArgument):\n raise CodeGenError(\"Numpy: invalid argument of type %s\" %\n str(type(arg)))\n\n if isinstance(arg, (InputArgument, InOutArgument)):\n name = self._get_symbol(arg.name)\n args.append(name)\n args = \", \".join(args)\n code_list.append(\"%s(%s):\\n\" % (routine.name, args))\n code_list = [ \"\".join(code_list) ]\n\n return code_list\n\n def _declare_arguments(self, routine):\n return []\n\n def _declare_globals(self, routine):\n return []\n\n def _declare_locals(self, routine):\n return []\n\n def _get_routine_ending(self, routine):\n return [\"#end\\n\"]\n\n def _indent_code(self, codelines):\n p = NumpyCodePrinter()\n return p.indent_code(codelines)\n\n def dump_py(self, routines, f, prefix, header=True, empty=True):\n self.dump_code(routines, f, prefix, header, empty)\n\n dump_py.extension = code_extension\n dump_py.__doc__ = CodeGen.dump_code.__doc__\n\n # This list of dump functions is used by CodeGen.write to know which dump\n # functions it has to call.\n dump_fns = [dump_py]\n\nclass LoopyCodeGen(LBMCodeGen):\n \"\"\"Generator for Cython code.\n\n The .write() method inherited from CodeGen will output a code file .pyx.\n\n \"\"\"\n\n code_extension = \"py\"\n\n _default_settings = {\"prefetch\": None}\n\n def code_generator(self, expr, assign_to=None, **settings):\n return loopy_code(expr, assign_to, **settings)\n\n def _preprocessor_statements(self, prefix):\n return []\n\n def _get_header(self):\n code_lines = [\"import loopy as lp\\n\",\n \"import numpy as np\\n\"\n ]\n return code_lines + [\"\\n\\n\"]\n\n def _get_routine_opening(self, routine):\n \"\"\"Returns the opening statements of the routine.\"\"\"\n code_list = []\n code_list.append(\"%s = lp.make_kernel(\"%routine.name)\n name = []\n bounds = []\n for i in routine.idx_vars:\n if isinstance(i, Idx):\n name.append(\"%s_\"%i.label)\n bounds.append(\"0<={ilabel}_<{upper}\".format(ilabel=i.label, upper=i.upper-i.lower))\n\n if len(name) > 0:\n code_list.append('\"{[%s]:%s}\",'%(\",\".join(name), \" and \".join(bounds)))\n code_list.append('\"\"\" # noqa (silences flake8 line length warning)\\n')\n code_list = [ \"\\n\".join(code_list) ]\n return code_list\n\n def _declare_arguments(self, routine):\n return []\n\n def _declare_globals(self, routine):\n return []\n\n def _declare_locals(self, routine):\n return []\n\n def _get_routine_ending(self, routine):\n code_list = []\n code_list.append('\"\"\",')\n\n # Inputs\n args = []\n dtypes = []\n for i, arg in enumerate(routine.arguments):\n if isinstance(arg, OutputArgument):\n raise CodeGenError(\"Loopy: invalid argument of type %s\" %\n str(type(arg)))\n\n if isinstance(arg, (InputArgument, InOutArgument)):\n name = self._get_symbol(arg.name)\n if arg.dimensions:\n dims = [\"{}\".format(d[1]-d[0]+1) for d in arg.dimensions]\n dtype = arg.get_datatype('PYTHON')\n if dtype == 'int':\n dtype = 'np.int32'\n args.append('lp.GlobalArg(\"{name}\", dtype={dtype}, shape=\"{shape}\")'.format(name=name, dtype=dtype, shape=\", \".join(dims)))\n else:\n args.append('lp.ValueArg(\"{name}\", dtype={dtype})'.format(name=name, dtype=arg.get_datatype('PYTHON')))\n for i, arg in enumerate(routine.local_vars):\n if isinstance(arg, Symbol):\n args.append('lp.TemporaryVariable(\"{name}\", dtype=float)'.format(name=self._get_symbol(arg))) \n else:\n dims = [d for d in arg.shape if d!=1]\n args.append('lp.TemporaryVariable(\"{name}\", dtype=float, shape=\"{shape}\")'.format(name=self._get_symbol(arg), shape=','.join(\"%s\"%s for s in dims)))\n\n code_list.append('[')\n args = \",\\n\".join(args)\n code_list.append(args)\n code_list.append('])#endArg\\n')\n\n # add type\n dim = len(routine.idx_vars)\n if dim == 1:\n block_size = [256]\n if dim == 2:\n block_size = [16, 16]\n if dim == 3:\n block_size = [4, 4, 4]\n\n for i, idx in enumerate(routine.idx_vars[-1::-1]):\n code_list.append('{name} = lp.split_iname({name}, \"{label}\", {block}, outer_tag=\"g.{ilabel}\", inner_tag=\"l.{ilabel}\")'.format(name = routine.name,\n label = \"%s_\"%idx.label, ilabel=i, block=block_size[i]))\n code_list.append('{name} = lp.expand_subst({name})\\n'.format(name=routine.name))\n code_list.append('{name} = lp.set_options({name}, no_numpy = True)\\n'.format(name=routine.name))\n\n prefetch = routine.settings.get(\"prefetch\", None)\n\n if prefetch:\n for var in prefetch:\n indices = []\n for idx in routine.idx_vars:\n indices.append(\"%s__inner\"%idx.label)\n # for i in range(var.rank):\n # if isinstance(var.indices[i], Idx):\n # indices.append(\"%s__inner\"%var.indices[i].label)\n code_list.append('{name} = lp.add_prefetch({name}, \"{var}\", \"{label}\", fetch_bounding_box=True)\\n'.format(name=routine.name, var=var.base.label, label=\",\".join(indices)))\n# print(\"PREFETCH\")\n # label = []\n # for var in self._settings[\"prefetch\"]:\n # indices = []\n # for i in var.indices:\n # if isinstance(i, Idx):\n # indices.append(\"%s__inner\"%i.label)\n # code_list.append('{name} = lp.add_prefetch({name}, \"{var}\", \"{label}\", fetch_bounding_box=True)'.format(name=routine.name, var=var.label, label=\",\".join(indices)))\n #print(LoopyCodePrinter()._sort_optimized(routine.local_vars, routine.instructions))\n# one_time_step = lp.split_iname(one_time_step, \"ii\", 16, outer_tag=\"g.1\", inner_tag=\"l.1\")\n# one_time_step = lp.split_iname(one_time_step, \"jj\", 16, outer_tag=\"g.0\", inner_tag=\"l.0\")\n# one_time_step = lp.expand_subst(one_time_step)\n# one_time_step = lp.add_prefetch(one_time_step, \"f\", \"ii_inner,jj_inner\", fetch_bounding_box=True)\n code_list = [ \"\\n\".join(code_list) ]\n return code_list\n\n def _indent_code(self, codelines):\n p = LoopyCodePrinter()\n return p.indent_code(codelines)\n\n def dump_py(self, routines, f, prefix, header=True, empty=True):\n self.dump_code(routines, f, prefix, header, empty)\n\n dump_py.extension = code_extension\n dump_py.__doc__ = CodeGen.dump_code.__doc__\n\n # This list of dump functions is used by CodeGen.write to know which dump\n # functions it has to call.\n dump_fns = [dump_py]\n\ndef get_code_generator(language, project):\n CodeGenClass = {\"NUMPY\" : NumpyCodeGen,\n \"CYTHON\": CythonCodeGen,\n \"LOOPY\": LoopyCodeGen}.get(language.upper())\n if CodeGenClass is None:\n raise ValueError(\"Language '%s' is not supported.\" % language)\n return CodeGenClass(project)\n\ndef codegen(name_expr, language, prefix=None, project=\"project\",\n to_files=False, header=True, empty=True, argument_sequence=None,\n global_vars=None, settings={}):\n # Initialize the code generator.\n code_gen = get_code_generator(language, project)\n\n if isinstance(name_expr[0], string_types):\n # single tuple is given, turn it into a singleton list with a tuple.\n name_expr = [name_expr]\n\n if prefix is None:\n prefix = name_expr[0][0]\n\n # Construct Routines appropriate for this code_gen from (name, expr) pairs.\n routines = []\n for name, expr in name_expr:\n routines.append(code_gen.routine(name, expr, argument_sequence,\n global_vars, settings))\n\n # Write the code.\n return code_gen.write(routines, prefix, to_files, header, empty)\n\ndef make_routine(name_expr, argument_sequence=None, local_vars=None, settings={}):\n if isinstance(name_expr[0], string_types):\n # single tuple is given, turn it into a singleton list with a tuple.\n name_expr = [name_expr]\n\n routines = []\n for name, expr in name_expr:\n routines.append(LBMCodeGen().routine(name, expr, argument_sequence,\n local_vars, settings))\n\n return routines\n", "meta": {"hexsha": "eb3c5bb60ba87c0d3b6897bbde63c2efc341223a", "size": 26763, "ext": "py", "lang": "Python", "max_stars_repo_path": "pylbm/generator/codegen.py", "max_stars_repo_name": "Mopolino8/pylbm", "max_stars_repo_head_hexsha": "b457ccdf1e7a1009807bd1136a276886f81a9e7d", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pylbm/generator/codegen.py", "max_issues_repo_name": "Mopolino8/pylbm", "max_issues_repo_head_hexsha": "b457ccdf1e7a1009807bd1136a276886f81a9e7d", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pylbm/generator/codegen.py", "max_forks_repo_name": "Mopolino8/pylbm", "max_forks_repo_head_hexsha": "b457ccdf1e7a1009807bd1136a276886f81a9e7d", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-11-24T17:13:26.000Z", "max_forks_repo_forks_event_max_datetime": "2019-11-24T17:13:26.000Z", "avg_line_length": 37.2743732591, "max_line_length": 186, "alphanum_fraction": 0.5787841423, "include": true, "reason": "import numpy,from sympy", "num_tokens": 5876, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.3812195803163618, "lm_q1q2_score": 0.19507638928623552}} {"text": "#!/usr/bin/env python2.7\n\n'''A tool for determining the UVIT FUV and NUV filters.\n\n\n Copyright 2018 Prajwel Joseph\n \n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n \n http://www.apache.org/licenses/LICENSE-2.0\n \n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License. \n\n Changes; when, what\n -------------------\n Jan 10, 2018: Galactic latitude check incorporated.\n\n\n The author would like to acknowledge inputs from Dr. Koshy George\n which greatly helped the developement of this script.\n \n'''\n\n\nimport os\nimport sys\nimport string\nimport urllib\nimport matplotlib\n# Force matplotlib to not use any Xwindows backend.\nmatplotlib.use('Agg')\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nfrom astropy.io import fits\nfrom astropy.wcs import WCS\nfrom astropy.io import ascii\nfrom requests import Session\nfrom bs4 import BeautifulSoup\nfrom astropy import units as u\nfrom matplotlib.colors import LogNorm\nfrom astropy.table import Table, hstack\nfrom astropy.coordinates import SkyCoord\n\n\n# To get the user input. \ninstrument = str(sys.argv[1])\nRA = str(sys.argv[2])\nDEC = str(sys.argv[3])\n#working_arena = str(sys.argv[4])\n\n#instrument = 'uvit'\n#RA = \"7:36:51.396\"\n#DEC = \"65:36:9.170\"\nworking_arena = '.'\n\n# To do all the stuff in a specific directory.\nos.chdir(working_arena)\n\n# To read the TD1 catalogue.\ntry:\n catalogue = 'td1_catalogue.fits'\n hdu = fits.open(catalogue)\nexcept IOError:\n print('Could not find the catalogue file: {}'.format(catalogue))\n sys.exit(1)\n\n# instrument and radius of search in arsec.\nfield_radius = {'uvit' : 1200,\n 'sxt' : 1500,\n 'czti' : 1680,\n 'laxpc' : 1680}\n\n# Functions to convert magnitude to UVIT count rates.\nflux_norm = 2E-13\ndef countnuv(flux):\n silica = 955.0\n b4 = 218.5\n b13 = 275.8\n b15 = 59.6\n n2 = 50.6\n flux_ratio = flux / flux_norm\n cr1 = silica * flux_ratio\n cr2 = b4 * flux_ratio\n cr3 = b13 * flux_ratio\n cr4 = b15 * flux_ratio\n cr5 = n2 * flux_ratio\n return flux, cr1, cr2, cr3, cr4, cr5\n\ndef countfuv(flux):\n caf2 = 74.5\n baf2 = 60.0\n sapphire = 50.0\n silica = 17.3\n flux_ratio = flux / flux_norm\n cr1 = caf2 * flux_ratio \n cr2 = baf2 * flux_ratio\n cr3 = sapphire * flux_ratio\n cr4 = silica * flux_ratio \n return flux, cr1, cr2, cr3, cr4\n\n# Function to find seperation in celestial coordinates.\ncc = SkyCoord(RA, DEC, unit = (u.hourangle, u.deg))\ndef cel_separation(a, b):\n coo = SkyCoord(a, b, frame = 'icrs', unit = 'deg')\n return coo.separation(cc)\n\n# To check if Galactic latitude is between -30 to 30.\ngal_lat = cc.galactic.b.value\ngal_plane = 'no'\nif -30.0 <= gal_lat <= 30.0:\n gal_plane_warning = 'The galactic latitude is between -30 to 30. \\\n \\nYour field cannot be checked using TD1 catalogue!'\n print('\\n{}\\n'.format(gal_plane_warning))\n with open('gal_plane_warning.txt', 'w') as gal_warn:\n gal_warn.write(gal_plane_warning)\n sys.exit(1)\n\n# Reading coordinates and fluxes from catalogue.\nhdu = fits.open(catalogue)\nalpha = hdu[1].data['ra']\ndelta = hdu[1].data['dec']\nnuv_flux = hdu[1].data['flux_2365_a']\nfuv_flux = hdu[1].data['flux_1565_a']\n\n# NUV \nrefined_set = [(al, de, nf) for al, de, nf \n in zip(alpha, delta, nuv_flux)\n if (cc.ra.value - 5) <= al <= (cc.ra.value + 5)\n and (cc.dec.value - 5) <= de <= (cc.dec.value + 5)]\n\nnalpha, ndelta, nuv_flux = zip(*refined_set)\n\nconfined_set = [nf for al, de, nf \n in zip(nalpha, ndelta, nuv_flux) \n if cel_separation(al, de) <= field_radius[instrument] * u.arcsec]\n\n# If list is empty, normal value need to be taken.\nif len(confined_set) == 0:\n confined_set.append(flux_norm)\n\nnd = sorted(confined_set)[-1]\nflux, ta, tb, tc, td, te = countnuv(nd)\nnuv_res = Table([[flux], [ta], [tb], [tc], [td], [te]],\n names = ('flux_2365_a',\n 'silica',\n 'b4',\n 'b13',\n 'b15',\n 'n2'), \n meta = {'name': 'NUV counts'})\n\n#nuv_res['flux_2365_a'].format = '\nnuv_res['silica'].format = '4.1f'\nnuv_res['b4'].format = '4.1f'\nnuv_res['b13'].format = '4.1f'\nnuv_res['b15'].format = '4.1f'\nnuv_res['n2'].format = '4.1f'\n\nprint('\\n\\n### NUV\\n\\n{}\\n'.format(nuv_res))\n\n# To select NUV safe filters.\nnuv_filter_dict = {0: 'Silica', 1: 'NUV-B4', 2: 'NUV-B13', 3: 'NUV-B15', 4: 'NUV-N2'}\ni = 0\nnuv_safe = []\nfor Filter in zip(*nuv_res['silica','b4','b13','b15','n2']):\n if sum(np.array(Filter) > 1500) == 0: \n nuv_safe.append(nuv_filter_dict[i])\n if i == 0:\n if sum(np.array(Filter) > 1133) == 0:\n nuv_safe.append('NUV-grating')\n i = i + 1\n\nnuv_declaration = 'Safe filters in NUV: {}'.format(nuv_safe)\nprint('\\n\\n{}\\n'.format(nuv_declaration))\n\n# To write to file.\nnuv_table = 'NUV_td1-nd-int.txt'\nascii.write(nuv_res, nuv_table, format = 'csv', overwrite = True)\n\nwith open('safe_NUV_filters.txt', 'w') as safe_file:\n safe_file.write(nuv_declaration)\n\n# FUV \nrefined_set = [(al, de, ff) for al, de, ff \n in zip(alpha, delta, fuv_flux)\n if (cc.ra.value - 5) <= al <= (cc.ra.value + 5)\n and (cc.dec.value - 5) <= de <= (cc.dec.value + 5)]\n\nnalpha, ndelta, fuv_flux = zip(*refined_set)\n\nconfined_set = [ff for al, de, ff \n in zip(nalpha, ndelta, fuv_flux) \n if cel_separation(al, de) <= field_radius[instrument] * u.arcsec]\n\n# If list is empty, normal value need to be taken.\nif len(confined_set) == 0:\n confined_set.append(flux_norm)\n\nfd = sorted(confined_set)[-1]\nflux, ta, tb, tc, td = countfuv(fd)\nfuv_res = Table([[flux], [ta], [tb], [tc], [td]],\n names = ('flux_1565_a',\n 'caf2',\n 'baf2',\n 'sapphire',\n 'silica'), \n meta = {'name': 'NUV counts'})\n\n#fuv_res['flux_1565_a'].format = '\nfuv_res['caf2'].format = '4.1f'\nfuv_res['baf2'].format = '4.1f'\nfuv_res['sapphire'].format = '4.1f'\nfuv_res['silica'].format = '4.1f'\n\nprint('\\n### FUV \\n\\n{}\\n\\n'.format(fuv_res))\n\n# To select FUV safe filters.\nfuv_filter_dict = {0: 'CaF2', 1: 'BaF2', 2: 'Sapphire', 3: 'Silica'}\nj = 0\nfuv_safe = []\nfor Filter in zip(*fuv_res['caf2','baf2','sapphire','silica']):\n if sum(np.array(Filter) > 1500) == 0: \n fuv_safe.append(fuv_filter_dict[j])\n if j == 0:\n if sum(np.array(Filter) > 892) == 0:\n fuv_safe.append('FUV-grating')\n j = j + 1\n\nfuv_declaration = 'Safe filters in FUV: {}'.format(fuv_safe)\nprint('\\n\\n{}\\n'.format(fuv_declaration))\n\n# To write to file.\nfuv_table = 'FUV_td1-fd-int.txt'\nascii.write(fuv_res, fuv_table, format = 'csv', overwrite = True)\n\nwith open('safe_FUV_filters.txt', 'w') as safe_file:\n safe_file.write(fuv_declaration)\n\nprint('Done!\\n')\n\n\n\n\n\n", "meta": {"hexsha": "f10b098616311c8577445e1af154ad681ea8fab6", "size": 7443, "ext": "py", "lang": "Python", "max_stars_repo_path": "Gaia (UV filter checking tool)/td1_gaia_V.2.5.py", "max_stars_repo_name": "prajwel/UVIT-POC", "max_stars_repo_head_hexsha": "eaaeb26f11b2c6e19cd96d3a99017b7bb39ee7aa", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Gaia (UV filter checking tool)/td1_gaia_V.2.5.py", "max_issues_repo_name": "prajwel/UVIT-POC", "max_issues_repo_head_hexsha": "eaaeb26f11b2c6e19cd96d3a99017b7bb39ee7aa", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Gaia (UV filter checking tool)/td1_gaia_V.2.5.py", "max_forks_repo_name": "prajwel/UVIT-POC", "max_forks_repo_head_hexsha": "eaaeb26f11b2c6e19cd96d3a99017b7bb39ee7aa", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.5357142857, "max_line_length": 85, "alphanum_fraction": 0.6072820099, "include": true, "reason": "import numpy,from astropy", "num_tokens": 2262, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.3812195803163618, "lm_q1q2_score": 0.19507638928623552}} {"text": "\"\"\"multipy: Python library for multicomponent mass transfer\"\"\"\n\n__author__ = \"James C. Sutherland, Kamila Zdybal\"\n__copyright__ = \"Copyright (c) 2022, James C. Sutherland, Kamila Zdybal\"\n__license__ = \"MIT\"\n__version__ = \"1.0.0\"\n__maintainer__ = [\"Kamila Zdybal\"]\n__email__ = [\"kamilazdybal@gmail.com\"]\n__status__ = \"Production\"\n\nimport numpy as np\nimport pandas as pd\nimport random\nimport copy\nimport scipy\nimport multipy\nimport warnings\n\ngas_constant = 8.31446261815324\n\n################################################################################\n################################################################################\n####\n#### Class: Flux\n####\n################################################################################\n################################################################################\n\nclass Flux:\n \"\"\"\n Supports computing and storing fluxes. This class assumes that the species velocities, :math:`\\\\mathbf{u}_i`, are known.\n\n Diffusive fluxes:\n\n - mass diffusive flux relative to a mass-averaged velocity, :math:`\\mathbf{j}_i`\n - mass diffusive flux relative to a molar-averaged velocity, :math:`\\mathbf{j}_i^u`\n - molar diffusive flux relative to a mass-averaged velocity, :math:`\\mathbf{J}_i^v`\n - molar diffusive flux relative to a molar-averaged velocity, :math:`\\mathbf{J}_i`\n\n :param species_velocities:\n vector ``numpy.ndarray`` specifying the species velocities :math:`\\mathbf{u}_i` in :math:`[m/s]`. It should be of size ``(n_species,n_observations)``.\n\n **Getters:**\n\n - **get_species_velocities**\n - **get_diffusive_molar_molar** (is set to ``None`` at class init)\n - **get_diffusive_molar_mass** (is set to ``None`` at class init)\n - **get_diffusive_mass_molar** (is set to ``None`` at class init)\n - **get_diffusive_mass_mass** (is set to ``None`` at class init)\n\n **Setters:**\n\n - **set_species_velocities**\n - **set_diffusive_molar_molar** (is set to ``None`` at class init)\n - **set_diffusive_molar_mass** (is set to ``None`` at class init)\n - **set_diffusive_mass_molar** (is set to ``None`` at class init)\n - **set_diffusive_mass_mass** (is set to ``None`` at class init)\n \"\"\"\n\n # --------------------------------------------------------------------------\n\n def __init__(self, species_velocities):\n\n if not isinstance(species_velocities, np.ndarray):\n raise ValueError(\"Parameter `species_velocities` has to be of type `numpy.ndarray`.\")\n\n try:\n (n_species, n_observations) = np.shape(species_velocities)\n except:\n raise ValueError(\"Parameter `species_velocities` has to be a matrix.\")\n\n if n_species < 2:\n raise ValueError(\"Parameter `species_velocities` has to have at least two species.\")\n\n self.__species_velocities = species_velocities\n self.__velocity = multipy.Velocity(self.get_species_velocities)\n self.__diffusive_molar_molar = None\n self.__diffusive_molar_mass = None\n self.__diffusive_mass_molar = None\n self.__diffusive_mass_mass = None\n\n @property\n def get_species_velocities(self):\n return self.__species_velocities\n\n @property\n def get_diffusive_molar_molar(self):\n return self.__diffusive_molar_molar\n\n @property\n def get_diffusive_molar_mass(self):\n return self.__diffusive_molar_mass\n\n @property\n def get_diffusive_mass_molar(self):\n return self.__diffusive_mass_molar\n\n @property\n def get_diffusive_mass_mass(self):\n return self.__diffusive_mass_mass\n\n @get_species_velocities.setter\n def set_species_velocities(self, new_species_velocities):\n\n if new_species_velocities is not None:\n if not isinstance(new_species_velocities, np.ndarray):\n raise ValueError(\"Parameter `species_velocities` has to be of type `numpy.ndarray`.\")\n\n try:\n (n_species, n_observations) = np.shape(new_species_velocities)\n except:\n raise ValueError(\"Parameter `species_velocities` has to be a matrix.\")\n\n self.__species_velocities = new_species_velocities\n\n @get_diffusive_molar_molar.setter\n def set_diffusive_molar_molar(self, new_diffusive_molar_molar):\n\n if new_diffusive_molar_molar is not None:\n if not isinstance(new_diffusive_molar_molar, np.ndarray):\n raise ValueError(\"Parameter `diffusive_molar_molar` has to be of type `numpy.ndarray`.\")\n\n try:\n (n_species, n_observations) = np.shape(new_diffusive_molar_molar)\n except:\n raise ValueError(\"Parameter `diffusive_molar_molar` has to be a matrix.\")\n\n self.__diffusive_molar_molar = new_diffusive_molar_molar\n\n @get_diffusive_molar_mass.setter\n def set_diffusive_molar_mass(self, new_diffusive_molar_mass):\n\n if new_diffusive_molar_mass is not None:\n if not isinstance(new_diffusive_molar_mass, np.ndarray):\n raise ValueError(\"Parameter `diffusive_molar_mass` has to be of type `numpy.ndarray`.\")\n\n try:\n (n_species, n_observations) = np.shape(new_diffusive_molar_mass)\n except:\n raise ValueError(\"Parameter `diffusive_molar_mass` has to be a matrix.\")\n\n self.__diffusive_molar_mass = new_diffusive_molar_mass\n\n @get_diffusive_mass_molar.setter\n def set_diffusive_mass_molar(self, new_diffusive_mass_molar):\n\n if new_diffusive_mass_molar is not None:\n if not isinstance(new_diffusive_mass_molar, np.ndarray):\n raise ValueError(\"Parameter `diffusive_mass_molar` has to be of type `numpy.ndarray`.\")\n\n try:\n (n_species, n_observations) = np.shape(new_diffusive_mass_molar)\n except:\n raise ValueError(\"Parameter `diffusive_mass_molar` has to be a matrix.\")\n\n self.__diffusive_mass_molar = new_diffusive_mass_molar\n\n @get_diffusive_mass_mass.setter\n def set_diffusive_mass_mass(self, new_diffusive_mass_mass):\n\n if new_diffusive_mass_mass is not None:\n if not isinstance(new_diffusive_mass_mass, np.ndarray):\n raise ValueError(\"Parameter `diffusive_mass_mass` has to be of type `numpy.ndarray`.\")\n\n try:\n (n_species, n_observations) = np.shape(new_diffusive_mass_mass)\n except:\n raise ValueError(\"Parameter `diffusive_mass_mass` has to be a matrix.\")\n\n self.__diffusive_mass_mass = new_diffusive_mass_mass\n\n # --------------------------------------------------------------------------\n\n def plot_diffusive_flux(self, species_names=None, colors=None, figsize=(10,5), filename=None):\n \"\"\"\n Plots the computed diffusive fluxes.\n\n **Example:**\n\n .. image:: ../images/stefan-tube-diffusive-flux-molar-diff-molar-avg.svg\n :width: 400\n\n :param species_names: (optional)\n ``list`` of ``str`` specifying the species names.\n :param colors: (optional)\n ``list`` of ``str`` specifying the plotting colors for each species. Example: ``colors=['#C7254E', '#BBBBBB', '#008CBA']``.\n :param figsize: (optional)\n ``tuple`` specifying the figure size.\n :param filename: (optional)\n ``str`` specifying the filename. If set to ``None``, plot will not be saved to a file.\n \"\"\"\n\n if filename is not None:\n\n path = False\n\n if filename[0:2] == '..':\n __filename = filename[2::]\n path = True\n else:\n __filename = filename\n\n __base = __filename.split('.')[0]\n __extension = __filename.split('.')[1]\n\n if path:\n __filename = '..' + __base\n else:\n __filename = __base\n\n if self.get_diffusive_molar_molar is not None:\n if filename is not None:\n plt = multipy.plot.plot_1d_diffusive_flux(self.get_diffusive_molar_molar, flux='molar', velocity='molar', species_names=species_names, colors=colors, figsize=figsize, filename=__filename + '-molar-diff-molar-avg.' + __extension)\n else:\n plt = multipy.plot.plot_1d_diffusive_flux(self.get_diffusive_molar_molar, flux='molar', velocity='molar', species_names=species_names, colors=colors, figsize=figsize, filename=None)\n\n if self.get_diffusive_molar_mass is not None:\n if filename is not None:\n plt = multipy.plot.plot_1d_diffusive_flux(self.get_diffusive_molar_mass, flux='molar', velocity='mass', species_names=species_names, colors=colors, figsize=figsize, filename=__filename + '-molar-diff-mass-avg.' + __extension)\n else:\n plt = multipy.plot.plot_1d_diffusive_flux(self.get_diffusive_molar_mass, flux='molar', velocity='mass', species_names=species_names, colors=colors, figsize=figsize, filename=None)\n\n if self.get_diffusive_mass_molar is not None:\n if filename is not None:\n plt = multipy.plot.plot_1d_diffusive_flux(self.get_diffusive_mass_molar, flux='mass', velocity='molar', species_names=species_names, colors=colors, figsize=figsize, filename=__filename + '-mass-diff-molar-avg.' + __extension)\n else:\n plt = multipy.plot.plot_1d_diffusive_flux(self.get_diffusive_mass_molar, flux='mass', velocity='molar', species_names=species_names, colors=colors, figsize=figsize, filename=None)\n\n if self.get_diffusive_mass_mass is not None:\n if filename is not None:\n plt = multipy.plot.plot_1d_diffusive_flux(self.get_diffusive_mass_mass, flux='mass', velocity='mass', species_names=species_names, colors=colors, figsize=figsize, filename=__filename + '-mass-diff-mass-avg.' + __extension)\n else:\n plt = multipy.plot.plot_1d_diffusive_flux(self.get_diffusive_mass_mass, flux='mass', velocity='mass', species_names=species_names, colors=colors, figsize=figsize, filename=None)\n\n # --------------------------------------------------------------------------\n\n def diffusive_molar_molar(self, species_mole_fractions, species_molar_densities):\n \"\"\"\n Computes the molar diffusive flux relative to a molar-averaged velocity:\n\n .. math::\n\n \\mathbf{J}_i = c_i \\mathbf{u}_i + c_i \\mathbf{u}\n\n :param species_mole_fractions:\n scalar ``numpy.ndarray`` specifying the species mole fractions, :math:`X_i`, in :math:`[-]`. It should be of size ``(n_species,n_observations)``.\n :param species_molar_densities:\n scalar ``numpy.ndarray`` specifying the molar densities of species, :math:`c_i`, in :math:`[mole/m^3]`. It should be of size ``(n_species,n_observations)``.\n\n :return:\n - **diffusive_flux** - vector ``numpy.ndarray`` of molar diffusive fluxes relative to a molar-averaged velocity :math:`\\mathbf{J}_i` in :math:`[mole/(m^2s)]`. It has size ``(n_species,n_observations)``.\n \"\"\"\n\n if not isinstance(species_mole_fractions, np.ndarray):\n raise ValueError(\"Parameter `species_mole_fractions` has to be of type `numpy.ndarray`.\")\n\n try:\n (n_species_1, n_observations_1) = np.shape(species_mole_fractions)\n except:\n raise ValueError(\"Parameter `species_mole_fractions` has to be a matrix.\")\n\n if not isinstance(species_molar_densities, np.ndarray):\n raise ValueError(\"Parameter `species_molar_densities` has to be of type `numpy.ndarray`.\")\n\n try:\n (n_species_2, n_observations_2) = np.shape(species_molar_densities)\n except:\n raise ValueError(\"Parameter `species_molar_densities` has to be a matrix.\")\n\n if n_observations_1 != n_observations_2:\n raise ValueError(\"Parameters `species_mole_fractions` and `species_molar_densities` have different number of observations `n_observations`.\")\n\n if n_species_1 != n_species_2:\n raise ValueError(\"Parameters `species_mole_fractions` and `species_molar_densities` have different number of species `n_species`.\")\n\n (n_species, n_observations) = np.shape(self.get_species_velocities)\n\n if n_observations != n_observations_1:\n raise ValueError(\"Parameters `species_mole_fractions`, `species_molar_densities` and `species_velocities` have different number of observations `n_observations`.\")\n\n if n_species != n_species_1:\n raise ValueError(\"Parameters `species_mole_fractions`, `species_molar_densities` and `species_velocities` have different number of species `n_species`.\")\n\n molar_averaged_velocity = self.__velocity.molar_averaged(species_mole_fractions)\n\n diffusive_flux = np.multiply(species_molar_densities, self.get_species_velocities) - np.multiply(species_molar_densities, molar_averaged_velocity)\n self.__diffusive_molar_molar = diffusive_flux\n\n return diffusive_flux\n\n # --------------------------------------------------------------------------\n\n def diffusive_molar_mass(self, species_mass_fractions, species_molar_densities):\n \"\"\"\n Computes the molar diffusive flux relative to a mass-averaged velocity:\n\n .. math::\n\n \\mathbf{J}_i^v = c_i \\mathbf{u}_i + c_i \\mathbf{v}\n\n :param species_mass_fractions:\n scalar ``numpy.ndarray`` specifying the species mass fractions, :math:`Y_i`, in :math:`[-]`. It should be of size ``(n_species,n_observations)``.\n :param species_molar_densities:\n scalar ``numpy.ndarray`` specifying the species molar densities :math:`c_i` in :math:`[mole/m^3]`. It should be of size ``(n_species,n_observations)``.\n\n :return:\n - **diffusive_flux** - vector ``numpy.ndarray`` of molar diffusive fluxes relative to a mass-averaged velocity :math:`\\mathbf{J}_i^v` in :math:`[mole/(m^2s)]`. It has size ``(n_species,n_observations)``.\n \"\"\"\n\n if not isinstance(species_mass_fractions, np.ndarray):\n raise ValueError(\"Parameter `species_mass_fractions` has to be of type `numpy.ndarray`.\")\n\n try:\n (n_species_1, n_observations_1) = np.shape(species_mass_fractions)\n except:\n raise ValueError(\"Parameter `species_mass_fractions` has to be a matrix.\")\n\n if not isinstance(species_molar_densities, np.ndarray):\n raise ValueError(\"Parameter `species_molar_densities` has to be of type `numpy.ndarray`.\")\n\n try:\n (n_species_2, n_observations_2) = np.shape(species_molar_densities)\n except:\n raise ValueError(\"Parameter `species_molar_densities` has to be a matrix.\")\n\n if n_observations_1 != n_observations_2:\n raise ValueError(\"Parameters `species_mass_fractions` and `species_molar_densities` have different number of observations `n_observations`.\")\n\n if n_species_1 != n_species_2:\n raise ValueError(\"Parameters `species_mass_fractions` and `species_molar_densities` have different number of species `n_species`.\")\n\n (n_species, n_observations) = np.shape(self.get_species_velocities)\n\n if n_observations != n_observations_1:\n raise ValueError(\"Parameters `species_mass_fractions`, `species_molar_densities` and `species_velocities` have different number of observations `n_observations`.\")\n\n if n_species != n_species_1:\n raise ValueError(\"Parameters `species_mass_fractions`, `species_molar_densities` and `species_velocities` have different number of species `n_species`.\")\n\n mass_averaged_velocity = self.__velocity.mass_averaged(species_mass_fractions)\n\n diffusive_flux = np.multiply(species_molar_densities, self.get_species_velocities) - np.multiply(species_molar_densities, mass_averaged_velocity)\n self.__diffusive_molar_mass = diffusive_flux\n\n return diffusive_flux\n\n # --------------------------------------------------------------------------\n\n def diffusive_mass_molar(self, species_mole_fractions, species_mass_densities):\n \"\"\"\n Computes the mass diffusive flux relative to a molar-averaged velocity:\n\n .. math::\n\n \\mathbf{j}_i^u = \\\\rho_i \\mathbf{u}_i + \\\\rho_i \\mathbf{u}\n\n :param species_mole_fractions:\n scalar ``numpy.ndarray`` specifying the species mole fractions :math:`X_i` in :math:`[-]`. It should be of size ``(n_species,n_observations)``.\n :param species_mass_densities:\n scalar ``numpy.ndarray`` specifying the species mass densities :math:`\\mathbf{\\\\rho}_i` in :math:`[kg/m^3]`. It should be of size ``(n_species,n_observations)``.\n\n :return:\n - **diffusive_flux** - vector ``numpy.ndarray`` of mass diffusive fluxes relative to a molar-averaged velocity :math:`\\mathbf{j}_i^u` in :math:`[kg/(m^2s)]`. It has size ``(n_species,n_observations)``.\n \"\"\"\n\n if not isinstance(species_mole_fractions, np.ndarray):\n raise ValueError(\"Parameter `species_mole_fractions` has to be of type `numpy.ndarray`.\")\n\n try:\n (n_species_1, n_observations_1) = np.shape(species_mole_fractions)\n except:\n raise ValueError(\"Parameter `species_mole_fractions` has to be a matrix.\")\n\n if not isinstance(species_mass_densities, np.ndarray):\n raise ValueError(\"Parameter `species_mass_densities` has to be of type `numpy.ndarray`.\")\n\n try:\n (n_species_2, n_observations_2) = np.shape(species_mass_densities)\n except:\n raise ValueError(\"Parameter `species_mass_densities` has to be a matrix.\")\n\n if n_observations_1 != n_observations_2:\n raise ValueError(\"Parameters `species_mole_fractions` and `species_mass_densities` have different number of observations `n_observations`.\")\n\n if n_species_1 != n_species_2:\n raise ValueError(\"Parameters `species_mole_fractions` and `species_mass_densities` have different number of species `n_species`.\")\n\n (n_species, n_observations) = np.shape(self.get_species_velocities)\n\n if n_observations != n_observations_1:\n raise ValueError(\"Parameters `species_mole_fractions`, `species_mass_densities` and `species_velocities` have different number of observations `n_observations`.\")\n\n if n_species != n_species_1:\n raise ValueError(\"Parameters `species_mole_fractions`, `species_mass_densities` and `species_velocities` have different number of species `n_species`.\")\n\n molar_averaged_velocity = self.__velocity.molar_averaged(species_mole_fractions)\n\n diffusive_flux = np.multiply(species_mass_densities, self.get_species_velocities) - np.multiply(species_mass_densities, molar_averaged_velocity)\n self.__diffusive_mass_molar = diffusive_flux\n\n return diffusive_flux\n\n # --------------------------------------------------------------------------\n\n def diffusive_mass_mass(self, species_mass_fractions, species_mass_densities):\n \"\"\"\n Computes the mass diffusive flux relative to a mass-averaged velocity:\n\n .. math::\n\n \\mathbf{j}_i = \\\\rho_i \\mathbf{u}_i + \\\\rho_i \\mathbf{v}\n\n :param species_mass_fractions:\n scalar ``numpy.ndarray`` specifying the species mass fractions :math:`Y_i` in :math:`[-]`. It should be of size ``(n_species, n_observations)``.\n :param species_mass_densities:\n scalar ``numpy.ndarray`` specifying the species mass densities :math:`\\mathbf{\\\\rho}_i` in :math:`[kg/m^3]`. It should be of size ``(n_species, n_observations)``.\n\n :return:\n - **diffusive_flux** - vector ``numpy.ndarray`` of mass diffusive fluxes relative to a mass-averaged velocity :math:`\\mathbf{j}_i` in :math:`[kg/(m^2s)]`. It has size ``(n_species, n_observations)``.\n \"\"\"\n if not isinstance(species_mass_fractions, np.ndarray):\n raise ValueError(\"Parameter `species_mass_fractions` has to be of type `numpy.ndarray`.\")\n\n try:\n (n_species_1, n_observations_1) = np.shape(species_mass_fractions)\n except:\n raise ValueError(\"Parameter `species_mass_fractions` has to be a matrix.\")\n\n if not isinstance(species_mass_densities, np.ndarray):\n raise ValueError(\"Parameter `species_mass_densities` has to be of type `numpy.ndarray`.\")\n\n try:\n (n_species_2, n_observations_2) = np.shape(species_mass_densities)\n except:\n raise ValueError(\"Parameter `species_mass_densities` has to be a matrix.\")\n\n if n_observations_1 != n_observations_2:\n raise ValueError(\"Parameters `species_mass_fractions` and `species_mass_densities` have different number of observations `n_observations`.\")\n\n if n_species_1 != n_species_2:\n raise ValueError(\"Parameters `species_mass_fractions` and `species_mass_densities` have different number of species `n_species`.\")\n\n (n_species, n_observations) = np.shape(self.get_species_velocities)\n\n if n_observations != n_observations_1:\n raise ValueError(\"Parameters `species_mass_fractions`, `species_mass_densities` and `species_velocities` have different number of observations `n_observations`.\")\n\n if n_species != n_species_1:\n raise ValueError(\"Parameters `species_mass_fractions`, `species_mass_densities` and `species_velocities` have different number of species `n_species`.\")\n\n mass_averaged_velocity = self.__velocity.mass_averaged(species_mass_fractions)\n\n diffusive_flux = np.multiply(species_mass_densities, self.get_species_velocities) - np.multiply(species_mass_densities, mass_averaged_velocity)\n self.__diffusive_mass_mass = diffusive_flux\n\n return diffusive_flux\n\n # --------------------------------------------------------------------------\n", "meta": {"hexsha": "da1cd997565c598625d3fbc3be2100124fc27c2c", "size": 21915, "ext": "py", "lang": "Python", "max_stars_repo_path": "multipy/flux.py", "max_stars_repo_name": "kamilazdybal/multipy", "max_stars_repo_head_hexsha": "ebdcddb63bfb1cd647ca99bbf9002b04a9b50ed9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "multipy/flux.py", "max_issues_repo_name": "kamilazdybal/multipy", "max_issues_repo_head_hexsha": "ebdcddb63bfb1cd647ca99bbf9002b04a9b50ed9", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "multipy/flux.py", "max_forks_repo_name": "kamilazdybal/multipy", "max_forks_repo_head_hexsha": "ebdcddb63bfb1cd647ca99bbf9002b04a9b50ed9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 47.7450980392, "max_line_length": 244, "alphanum_fraction": 0.6579055441, "include": true, "reason": "import numpy,import scipy", "num_tokens": 5145, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.3812195803163617, "lm_q1q2_score": 0.1950763892862355}} {"text": "#!/bin/python\n# -*- coding: utf-8 -*-\n\nimport numpy as np\nimport pandas as pd\nimport os\nimport time\nimport tqdm\nfrom datetime import datetime\nfrom .mpile import get_par\n\n\ndef mcmc(\n self,\n p0=None,\n nsteps=3000,\n nwalks=None,\n tune=None,\n moves=None,\n temp=False,\n seed=None,\n backend=True,\n suffix=None,\n linear=None,\n resume=False,\n append=False,\n update_freq=None,\n lprob_seed=None,\n report=None,\n maintenance_interval=10,\n verbose=False,\n debug=False,\n **samplerargs\n):\n \"\"\"Run the emcee ensemble MCMC sampler.\n\n Parameters:\n ----------\n\n p0 : ndarray of initial states of the walkers in the parameterspace\n moves : emcee.moves object\n lprob_seed : lprob_seed must be one of ('vec', 'rand', 'set').\n \"\"\"\n\n import emcee\n from grgrlib.multiprocessing import serializer\n\n if not hasattr(self, \"ndim\"):\n # if it seems to be missing, lets do it.\n # but without guarantee...\n self.prep_estim(load_R=True)\n\n if seed is None:\n seed = self.fdict[\"seed\"]\n\n self.tune = tune\n if tune is None:\n self.tune = int(nsteps * 1 / 5.0)\n\n if update_freq is None:\n update_freq = int(nsteps / 5.0)\n\n if linear is None:\n linear = self.filter.name == \"KalmanFilter\"\n\n if \"description\" in self.fdict.keys():\n self.description = self.fdict[\"description\"]\n\n if hasattr(self, \"pool\"):\n from .estimation import create_pool\n\n create_pool(self)\n\n lprob_global = serializer(self.lprob)\n\n if isinstance(temp, bool) and not temp:\n temp = 1\n\n def lprob(par):\n return lprob_global(\n par,\n linear=linear,\n verbose=verbose,\n temp=temp,\n lprob_seed=lprob_seed or \"set\",\n )\n\n bnd = np.array(self.fdict[\"prior_bounds\"])\n\n if self.pool:\n self.pool.clear()\n\n if p0 is None and not resume:\n if temp < 1:\n p0 = get_par(\n self,\n \"prior_mean\",\n asdict=False,\n full=False,\n nsample=nwalks,\n verbose=verbose,\n )\n else:\n p0 = get_par(\n self, \"best\", asdict=False, full=False, nsample=nwalks, verbose=verbose\n )\n elif not resume:\n nwalks = p0.shape[0]\n\n if backend:\n\n if isinstance(backend, str):\n # backend_file will only be loaded later if explicitely defined before\n self.fdict[\"backend_file\"] = backend\n try:\n backend = self.fdict[\"backend_file\"]\n except KeyError:\n # this is the default case\n suffix = str(suffix) if suffix else \"_sampler.h5\"\n backend = os.path.join(self.path, self.name + suffix)\n\n if os.path.exists(backend) and not (resume or append):\n print(\n \"[mcmc:]\".ljust(15, \" \")\n + \" HDF backend at %s already exists. Deleting...\" % backend\n )\n os.remove(backend)\n\n backend = emcee.backends.HDFBackend(backend)\n\n if not (resume or append):\n if not nwalks:\n raise TypeError(\n \"If neither `resume`, `append` or `p0` is given I need to know the number of walkers (`nwalks`).\"\n )\n try:\n backend.reset(nwalks, self.ndim)\n except KeyError as e:\n raise KeyError(str(e) + \". Your `*.h5` file is likely to be damaged...\")\n else:\n backend = None\n\n if resume:\n nwalks = backend.get_chain().shape[1]\n\n if debug:\n sampler = emcee.EnsembleSampler(nwalks, self.ndim, lprob)\n else:\n sampler = emcee.EnsembleSampler(\n nwalks, self.ndim, lprob, moves=moves, pool=self.pool, backend=backend\n )\n\n if resume and not p0:\n p0 = sampler.get_last_sample()\n\n self.sampler = sampler\n self.temp = temp\n\n if not verbose:\n np.warnings.filterwarnings(\"ignore\")\n\n if verbose > 2:\n report = report or print\n else:\n pbar = tqdm.tqdm(total=nsteps, unit=\"sample(s)\", dynamic_ncols=True)\n report = report or pbar.write\n\n old_tau = np.inf\n cnt = 0\n\n for result in sampler.sample(p0, iterations=nsteps, **samplerargs):\n\n if not verbose:\n lls = list(result)[1]\n maf = np.mean(sampler.acceptance_fraction[-update_freq:]) * 100\n pbar.set_description(\n \"[ll/MAF:%s(%1.0e)/%1.0f%%]\" % (str(np.max(lls))[:7], np.std(lls), maf)\n )\n\n if cnt and update_freq and not cnt % update_freq:\n\n prnttup = \"[mcmc:]\".ljust(\n 15, \" \"\n ) + \"Summary from last %s of %s iterations\" % (update_freq, cnt)\n\n if temp < 1:\n prnttup += \" with temp of %s%%\" % (np.round(temp * 100, 6))\n\n if self.description is not None:\n prnttup += \" (%s)\" % str(self.description)\n\n prnttup += \":\"\n\n report(prnttup)\n\n sample = sampler.get_chain()\n\n tau = emcee.autocorr.integrated_time(sample, tol=0)\n min_tau = np.min(tau).round(2)\n max_tau = np.max(tau).round(2)\n dev_tau = np.max(np.abs(old_tau - tau) / tau)\n\n tau_sign = \">\" if max_tau > sampler.iteration / 50 else \"<\"\n dev_sign = \">\" if dev_tau > 0.01 else \"<\"\n\n self.mcmc_summary(\n chain=sample,\n tune=update_freq,\n calc_mdd=False,\n calc_ll_stats=True,\n out=lambda x: report(str(x)),\n )\n\n report(\n \"Convergence stats: tau is in (%s,%s) (%s%s) and change is %s (%s0.01).\"\n % (\n min_tau,\n max_tau,\n tau_sign,\n sampler.iteration / 50,\n dev_tau.round(3),\n dev_sign,\n )\n )\n\n if cnt and update_freq and not (cnt + 1) % update_freq:\n sample = sampler.get_chain()\n old_tau = emcee.autocorr.integrated_time(sample, tol=0)\n\n if not verbose:\n pbar.update(1)\n\n # avoid mem leakage\n if cnt and not cnt % maintenance_interval:\n self.pool.clear()\n\n cnt += 1\n\n pbar.close()\n if self.pool:\n self.pool.close()\n\n if not verbose:\n np.warnings.filterwarnings(\"default\")\n\n log_probs = sampler.get_log_prob()[-self.tune :]\n chain = sampler.get_chain()[-self.tune :]\n chain = chain.reshape(-1, chain.shape[-1])\n\n arg_max = log_probs.argmax()\n mode_f = log_probs.flat[arg_max]\n mode_x = chain[arg_max].flatten()\n\n if temp == 1:\n\n self.fdict[\"mcmc_mode_x\"] = mode_x\n self.fdict[\"mcmc_mode_f\"] = mode_f\n\n if \"mode_f\" in self.fdict.keys() and mode_f < self.fdict[\"mode_f\"]:\n print(\n \"[mcmc:]\".ljust(15, \" \")\n + \" New mode of %s is below old mode of %s. Rejecting...\"\n % (mode_f, self.fdict[\"mode_f\"])\n )\n else:\n self.fdict[\"mode_x\"] = mode_x\n self.fdict[\"mode_f\"] = mode_f\n\n self.fdict[\"datetime\"] = str(datetime.now())\n\n return\n\n\ndef tmcmc(\n self,\n nsteps,\n nwalks,\n ntemps,\n target,\n update_freq=False,\n test_lprob=False,\n verbose=True,\n debug=False,\n **mcmc_args\n):\n \"\"\"Run Tempered Ensemble MCMC\n\n Parameters\n ----------\n ntemps : int\n target : float\n nsteps : float\n \"\"\"\n\n from grgrlib.core import map2arr\n from .mpile import prior_sampler\n\n update_freq = update_freq if update_freq <= nsteps else False\n\n # sample pars from prior\n pars = prior_sampler(\n self, nwalks, test_lprob=test_lprob, verbose=max(verbose, 2 * debug)\n )\n\n x = get_par(self, \"prior_mean\", asdict=False, full=False, verbose=verbose > 1)\n\n pbar = tqdm.tqdm(total=ntemps, unit=\"temp(s)\", dynamic_ncols=True)\n tmp = 0\n\n for i in range(ntemps):\n\n # update tmp\n ll = self.lprob(x)\n lp = self.lprior(x)\n\n tmp = tmp * (ntemps - i - 1) / (ntemps - i) + (target - lp) / (ntemps - i) / (\n ll - lp\n )\n aim = lp + (ll - lp) * tmp\n\n if tmp >= 1:\n # print only once\n pbar.write(\n \"[tmcmc:]\".ljust(15, \" \")\n + \"Increasing temperature to %s°. Too hot! I'm out...\"\n % np.round(100 * tmp, 3)\n )\n pbar.update()\n self.temp = 1\n # skip for-loop to exit\n continue\n\n pbar.write(\n \"[tmcmc:]\".ljust(15, \" \")\n + \"Increasing temperature to %2.5f°, aiming @ %4.3f.\" % (100 * tmp, aim)\n )\n pbar.set_description(\"[tmcmc: %2.3f°\" % (100 * tmp))\n\n self.mcmc(\n p0=pars,\n nsteps=nsteps,\n temp=tmp,\n update_freq=update_freq,\n verbose=verbose > 1,\n append=i,\n report=pbar.write,\n debug=debug,\n **mcmc_args\n )\n\n self.temp = tmp\n self.mcmc_summary(tune=int(nsteps / 10), calc_mdd=False, calc_ll_stats=True)\n\n pbar.update()\n\n pars = self.get_chain()[-1]\n lprobs_adj = self.get_log_prob()[-1]\n x = pars[lprobs_adj.argmax()]\n\n pbar.close()\n self.fdict[\"datetime\"] = str(datetime.now())\n\n return pars\n", "meta": {"hexsha": "b476afdaa1c26d2b63ab9795e5f1065f99b5f37c", "size": 9494, "ext": "py", "lang": "Python", "max_stars_repo_path": "pydsge/mcmc.py", "max_stars_repo_name": "pcschreiber1/pydsge_OSE_Project_Fork", "max_stars_repo_head_hexsha": "4222dbe187e47958d2f5b732615c9ba97547f67a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pydsge/mcmc.py", "max_issues_repo_name": "pcschreiber1/pydsge_OSE_Project_Fork", "max_issues_repo_head_hexsha": "4222dbe187e47958d2f5b732615c9ba97547f67a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2021-12-31T16:27:48.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-27T17:16:19.000Z", "max_forks_repo_path": "pydsge/mcmc.py", "max_forks_repo_name": "pcschreiber1/pydsge_OSE_Project_Fork", "max_forks_repo_head_hexsha": "4222dbe187e47958d2f5b732615c9ba97547f67a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.0824175824, "max_line_length": 117, "alphanum_fraction": 0.5241204972, "include": true, "reason": "import numpy", "num_tokens": 2393, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.38121956625614994, "lm_q1q2_score": 0.19507638209139166}} {"text": "# -*- coding: utf-8 -*-\n# Copyright (c) Vlachos Group, Jung Group\n# GNU v3.0 license\n\n__author__ = 'Geun Ho Gu'\n__copyright__ = \"Copyright 2019, Vlachos Group, Jung Group\"\n__version__ = \"1.0\"\n__maintainer__ = \"Geun Ho Gu\"\n__email__ = \"googhgoo@hotmail.com\"\n__date__ = \"July 31, 2019\"\n\nimport tensorflow as tf\nimport numpy as np\n\n__all__ = [\n 'ModelBuilder',\n ]\n\nclass ModelBuilder(object):\n def __init__(self,n_occupancy,n_neighbor_sites_list,n_permutation_list,\\\n X_mean, X_std, Y_mean, Y_std,\n n_conv=1,n_feature=150,sitewise_n_feature=25,\n ):\n \"\"\"\n Model builder. \n \n Parameters\n ----------\n n_occupancy: int. number of possible occupancy\n n_neighbor_sites_list: list of int. Number of neighbors of each site. \n X_mean : no. list of float. Mean of the one hot encoding matrix by column.\n no is the number of occupancy state.\n X_std : no. list of float. Standard deviation of the one hot encoding matrix by column.\n Y_mean : float. Mean of target property\n Y_std : float. Standard deviation of target property\n nconv: int. number of convolutions performed\n n_feature: int. number of feature for each site\n sitewise_n_feature: int. number of features for atoms for site-wise activation\n \"\"\"\n tf.Graph()\n tf.reset_default_graph()\n # Not to be used within the graph.. Used in Trainer. \n if X_mean is None: # None is used when evaluation mode is activated\n self.X_mean = tf.get_variable('X_mean',\n shape=(n_occupancy,),trainable=False)\n self.X_std = tf.get_variable('X_std',\n shape=(n_occupancy,),trainable=False)\n self.Y_mean = tf.get_variable('Y_mean',\n shape=(),trainable=False)\n self.Y_std = tf.get_variable('Y_std',\n shape=(),trainable=False)\n else:\n self.X_mean = tf.get_variable('X_mean',\n initializer=tf.convert_to_tensor(np.array(X_mean,dtype=np.float32)),\n trainable=False)\n self.X_std = tf.get_variable('X_std',\n initializer=tf.convert_to_tensor(np.array(X_std,dtype=np.float32)),\n trainable=False)\n self.Y_mean = tf.get_variable('Y_mean',\n initializer=tf.convert_to_tensor(np.array(Y_mean,dtype=np.float32)),\n trainable=False)\n self.Y_std = tf.get_variable('Y_std',\n initializer=tf.convert_to_tensor(np.array(Y_std,dtype=np.float32)),\n trainable=False)\n \n \n self.Y = tf.placeholder(dtype=tf.float32, shape = [None])\n self.Idx_config = tf.placeholder(dtype=tf.int32, shape = [None,1])\n self.N_Sites = tf.placeholder(dtype=tf.int32, shape = ())\n self.N_Sites_per_config = tf.placeholder(dtype=tf.float32, shape = [None])\n self.X_Sites = tf.placeholder(dtype=tf.float32, shape = [None,n_occupancy])\n \n \n self.X_NSs = []\n for n_neighbor_sites,n_permutation in zip(n_neighbor_sites_list,n_permutation_list):\n self.X_NSs.append(tf.placeholder(dtype=tf.int32, shape = [None,n_permutation,n_neighbor_sites]))\n self.X_NSs = tuple(self.X_NSs)\n self.Lambda = tf.placeholder(dtype=tf.float32, shape = [])\n self.Dropout_rate = tf.placeholder(dtype=tf.float32, shape = [])\n self.is_training = tf.placeholder(dtype=tf.bool, shape = [])\n \n \"\"\" initiaite Model Helper \"\"\"\n self.ModelHelper = CNNHelper(dropout_rate = self.Dropout_rate, UseBN=True,is_training=self.is_training)\n\n \"\"\" keeps tracks of site layer \"\"\"\n self.SiteLayer = [self.X_Sites]\n\n \"\"\" Featurize one-hot-encoding \"\"\"\n #self.SiteLayer.append(self.ModelHelper.Atom_Wise_Linear(self.X_Sites,n_feature))\n \n \"\"\" Perform Convolution \"\"\"\n for i in range(0,n_conv):\n self.SiteLayer.append(self.ModelHelper.LCNNConvolution(self.SiteLayer[-1],self.X_NSs,self.N_Sites,depth=n_feature)) \n self.SiteLayer.append(self.ModelHelper.Atom_Wise_Convolution(self.SiteLayer[-1],depth=sitewise_n_feature))\n \n \"\"\" Perform Linear Multiplication \"\"\" \n self.Y_atom_wise = tf.expand_dims(tf.reduce_sum(self.ModelHelper.Atom_Wise_Linear(self.SiteLayer[-1]),axis=1),axis=1)\n \n \"\"\" Sum up contributions \"\"\"\n self.Y_conf_wise = self.ModelHelper.Unflatten(self.Y_atom_wise,self.Idx_config,self.N_Sites_per_config)\n \n \"\"\" Loss + L2 norm \"\"\"\n Params = self.ModelHelper.Params\n Params = tf.concat(Params,0)\n self.Loss = tf.losses.mean_squared_error(labels=self.Y, predictions=self.Y_conf_wise) + self.Lambda*tf.norm(Params)\n \n def GetStatistics(self):\n \"\"\"Returns statistics for site layer and target property. Used in trainer in Train.py\n \"\"\"\n return self.X_mean,self.X_std,self.Y_mean,self.Y_std\n \n\n\nclass CNNHelper(object):\n \"\"\"This code is a helper for constructing CNN model.\n \"\"\"\n def __init__(self,dropout_rate = tf.constant(1,dtype=tf.float32) ,UseBN = False, is_training = None,e = 1e-3,initializer=tf.contrib.layers.xavier_initializer()):\n \"\"\"\n Initialize a CNN model builder. For the low level tensorflow models, \n keeping track of model weights can be difficult. This code automates\n this process. \n \n parameters\n ----------\n dropout_rate: 0D tensor. drop out rate\n UseBN: boolean . Flag for using batch normalization. Recommended to turn it on.\n is_training: 0D placeholder boolean tensor. Whether training or not. Used for batch norm\n e: float. This is a offset value for batch normalization for convergence\n initializer: tensorflow intializer class. tensorflow initializer for weights. Default(xavier) works well\n \"\"\"\n if UseBN and is_training == None:\n raise NotImplemented('When Batch normalization is used, is_training boolean placeholder must be provided')\n self.e = e\n self.init = initializer\n self.UseBN = UseBN\n self._nCNNLayer = 0 # Number of CNN layers\n self.dropout_rate = dropout_rate\n self.Params = []\n self.is_training = is_training\n \n \n def LCNNConvolution(self,X_Sites, X_NSs, N_Sites, depth=1):\n \"\"\"Construct convolution layer\n \n parameters\n ----------\n X_Sites: 2D tensor of shape (?,one hot encoding classification size)\n Site layer flattened over data index\n \n X_NSs: 3D tensor list of (?,number of permutation, 1 (site itself) + number of neighbors)\n given that the shape is (x,y,z), x is the site index which has been\n flattened over data, y is the permutation index, and z is the\n site itself index and neighbor site index. \n \n depth: int. depth/feature of convolution\n \n Return\n ----------\n X_Sites: 2D tensor\n Convoluted tensor\n \"\"\"\n \n with tf.variable_scope(\"layer\"+str(self._nCNNLayer)):\n indices = []\n updates = []\n for i in range(0,len(X_NSs)): # iterating over each site type\n \n with tf.variable_scope(\"site\"+str(i)):\n X_NSs_i = X_NSs[i]\n # Apply permutations\n # X_Sites_Permed : R^Number of Site x Permutation Index x Neighbor Indicex x Depth\n X_Sites_Permed = tf.gather(X_Sites,X_NSs_i,axis=0)\n # X_Sites_Concatenated : R^Number of Site x Permutation Index x (Neighbor Indicex x Depth)\n X_Sites_Concatenated = tf.reshape(X_Sites_Permed,[-1,X_Sites_Permed.shape[1],X_Sites_Permed.shape[2]*X_Sites_Permed.shape[3]])\n ## Filter shape: [filter height, in_channels, out_channels] \n ## Stride shape: Filter height\n w = tf.get_variable(\"w\",[1,X_Sites_Concatenated.shape[2],depth],dtype=tf.float32,initializer=self.init)\n self.Params.append(tf.reshape(w,[-1]))\n b = tf.get_variable(\"b\",[depth],dtype=tf.float32,initializer=self.init)\n self.Params.append(tf.reshape(b,[-1]))\n \n Conv1d = tf.nn.conv1d(X_Sites_Concatenated,w,1,\"SAME\")\n Conv1dB = tf.nn.bias_add(Conv1d,b)\n ## Batch Normalization\n # See https://stackoverflow.com/questions/33949786/how-could-i-use-batch-normalization-in-tensorflow/38320613#38320613\n if self.UseBN:\n u = tf.get_variable(\"u\",[1,1,depth],dtype=tf.float32,initializer=self.init)\n v = tf.get_variable(\"v\",[1,1,depth],dtype=tf.float32,initializer=self.init)\n def updateuv():\n ut,vt = tf.nn.moments(Conv1dB,[0,1],keep_dims=True)\n return (u.assign(ut),v.assign(vt))\n u,v = tf.cond(self.is_training,updateuv,lambda: (u,v))\n \n o = tf.get_variable(\"o\",[1,1,depth],dtype=tf.float32,initializer=self.init)\n self.Params.append(tf.reshape(o,[-1]))\n s = tf.get_variable(\"s\",[1,1,depth],dtype=tf.float32,initializer=self.init)\n self.Params.append(tf.reshape(s,[-1]))\n Conv1dBN = tf.nn.batch_normalization(Conv1dB,u,v,o,s,self.e)\n X_Sites1 = activation(Conv1dBN)\n X_Sites2 = tf.nn.dropout(X_Sites1,self.dropout_rate,noise_shape=[1,1,depth]) # Dropout\n X_Sites3 = tf.reduce_sum(X_Sites2,axis=1) # Sum over each permutations\n indices.append(X_NSs_i[:,0,0])\n updates.append(X_Sites3)\n # gather over multiple site types\n indices = tf.expand_dims(tf.concat(indices,axis=0),1)\n updates = tf.concat(updates,axis=0)\n NewSiteLayer = tf.scatter_nd(indices,updates,[N_Sites,depth])\n self._nCNNLayer += 1\n return NewSiteLayer\n \n\n def Atom_Wise_Linear(self,X_Sites, depth=1):\n \"\"\"\n Perform Matrix Multiplication\n \n parameters\n ----------\n X_Sites: 2D tensor of shape (?,one hot encoding classification size)\n Site layer flattened over data index\n \n depth: int. depth/feature of convolution\n \n return\n ------\n X_Sites: 2D tensor. Convoluted tensor\n \"\"\"\n with tf.variable_scope(\"layer\"+str(self._nCNNLayer)):\n ## Filter shape: [filter height, in_channels, out_channels] \n ## Stride shape: Filter height\n w = tf.get_variable(\"w\",[X_Sites.shape[1],depth],dtype=tf.float32,initializer=self.init)\n self.Params.append(tf.reshape(w,[-1]))\n b = tf.get_variable(\"b\",[depth],dtype=tf.float32,initializer=self.init)\n self.Params.append(tf.reshape(b,[-1]))\n\n X_Sites = tf.matmul(X_Sites,w)\n X_Sites = tf.nn.bias_add(X_Sites,b)\n\n self._nCNNLayer += 1\n return X_Sites\n\n\n def Atom_Wise_Convolution(self,X_Sites, depth=1):\n \"\"\"\n Perform self convolution to a site layer.\n \n parameters\n ----------\n X_Sites: 2D tensor of shape (?,one hot encoding classification size)\n Site layer flattened over data index\n depth: int. depth of convolution\n \"\"\"\n \n with tf.variable_scope(\"layer\"+str(self._nCNNLayer)):\n ## Filter shape: [filter height, in_channels, out_channels] \n ## Stride shape: Filter height\n w = tf.get_variable(\"w\",[X_Sites.shape[1],depth],dtype=tf.float32,initializer=self.init)\n self.Params.append(tf.reshape(w,[-1]))\n b = tf.get_variable(\"b\",[depth],dtype=tf.float32,initializer=self.init)\n self.Params.append(tf.reshape(b,[-1]))\n\n Conv = tf.matmul(X_Sites,w)\n Conv = tf.nn.bias_add(Conv,b)\n ## Batch Normalization\n if self.UseBN:\n u = tf.get_variable(\"u\",[1,depth],dtype=tf.float32,initializer=self.init)\n v = tf.get_variable(\"v\",[1,depth],dtype=tf.float32,initializer=self.init)\n def updateuv():\n ut,vt = tf.nn.moments(Conv,[0],keep_dims=True)\n return (u.assign(ut),v.assign(vt))\n u,v = tf.cond(self.is_training,updateuv,lambda: (u,v))\n \n o = tf.get_variable(\"o\",[1,depth],dtype=tf.float32,initializer=self.init)\n self.Params.append(tf.reshape(o,[-1]))\n s = tf.get_variable(\"s\",[1,depth],dtype=tf.float32,initializer=self.init)\n self.Params.append(tf.reshape(s,[-1]))\n Conv = tf.nn.batch_normalization(Conv,u,v,o,s,self.e)\n X_Sites = activation(Conv)\n X_Sites = tf.nn.dropout(X_Sites,self.dropout_rate,noise_shape=[1,depth]) # Dropout\n \n self._nCNNLayer += 1\n return X_Sites\n\n def SoftMax(self,X_Sites,depth = 1):\n \"\"\"Perform Convolution to a site layer.\n \n parameters\n ----------\n X_Sites: 2D tensor of shape (?,one hot encoding classification size)\n Site layer flattened over data index\n depth: int. depth/features of the softmax\n \n return\n ------\n X_Sites: 2D tensor. softmaxed sitelayer\n \"\"\"\n with tf.variable_scope(\"SoftMax\"):\n w = tf.get_variable(\"w\",[X_Sites.shape[1],depth],dtype=tf.float32,initializer=self.init)\n self.Params.append(tf.reshape(w,[-1]))\n b = tf.get_variable(\"b\",[depth],dtype=tf.float32,initializer=self.init)\n self.Params.append(tf.reshape(b,[-1]))\n X_Sites = tf.matmul(X_Sites,w)\n X_Sites = tf.nn.bias_add(X_Sites,b)\n if self.UseBN:\n u = tf.get_variable(\"u\",[1,depth],dtype=tf.float32,initializer=self.init)\n v = tf.get_variable(\"v\",[1,depth],dtype=tf.float32,initializer=self.init)\n def updateuv():\n ut,vt = tf.nn.moments(X_Sites,[0],keep_dims=True)\n return (u.assign(ut),v.assign(vt))\n u,v = tf.cond(self.is_training,updateuv,lambda: (u,v))\n \n o = tf.get_variable(\"o\",[1,depth],dtype=tf.float32,initializer=self.init)\n self.Params.append(tf.reshape(o,[-1]))\n s = tf.get_variable(\"s\",[1,depth],dtype=tf.float32,initializer=self.init)\n self.Params.append(tf.reshape(s,[-1]))\n X_Sites = tf.nn.batch_normalization(X_Sites,u,v,o,s,self.e)\n X_Sites = tf.nn.softmax(X_Sites,1)\n return X_Sites\n \n def Unflatten(self,X_Sites,Idx_config,N_Sites):\n \"\"\"This function unflattens the flattened site layer by summation. Then\n the unflattened values are dvidided by number of sites. \n \n parameters\n ----------\n X_Sites: 2D tensor. Site layer flattened over data index\n Idx_config: 1D tensor of integer. In the algorithm, Site layer is \n flattened over each data points. This way, we avoid using padding, \n and having an upper limit for the maximum number of sites. calculations \n are faster, too. To do this, we need data index for each site.\n This vector contains that information.\n \n N_Sites: 1D tensor. Each integer indicates number of sites in each\n configuration. Used to compute per site formation energy\n \n return\n ------\n ConfigLayer: 1D tensor. Unflattened per each datum\n \n \"\"\"\n # All the other failed attempts to densifying X_Sites\n# ConfigLayer = tf.Variable(tf.zeros([Idx_config[-1]+1,X_Sites.shape[1]]), tf.float32)\n# ConfigLayer = tf.Variable(tf.zeros([N_Sites.get_shape()[0],X_Sites.shape[1]]), tf.float32)\n# ConfigLayer = tf.fill([Idx_config[-1]+1,X_Sites.shape[1]],0.0)\n# ConfigLayer = tf.scatter_add(ConfigLayer,Idx_config,X_Sites)\n# ConfigLayer = tf.scatter_nd(Idx_config,X_Sites,[Idx_config[-1]+1,X_Sites.shape[1]])\n# ConfigLayer = tf.scatter_nd(Idx_config,X_Sites,[N_Sites.shape[0],X_Sites.shape[1]])\n# ConfigLayer = tf.scatter_nd(Idx_config,X_Sites,[Idx_config[-1]+1,tf.constant([1])])\n# ConfigLayer = tf.scatter_nd(Idx_config,X_Sites,[Idx_config[-1]+1,[1]])\n# ConfigLayer = tf.scatter_nd(Idx_config,X_Sites,Idx_config[-1]+1)\n# ConfigLayer = tf.scatter_nd(Idx_config,X_Sites,[1,1])\n ConfigLayer = tf.scatter_nd(Idx_config,X_Sites,[tf.reshape(Idx_config[-1]+1,[]),X_Sites.shape[1]])\n ConfigLayer = tf.reshape(ConfigLayer,[-1])\n ConfigLayer = tf.div(ConfigLayer,N_Sites)\n return ConfigLayer\n \ndef activation(tensor):\n \"\"\"Return activation function\"\"\"\n return tf.nn.softplus(tensor)-np.log(2.0)", "meta": {"hexsha": "a2f3e330dfef13351450807a9a6d05b287af77f7", "size": 17193, "ext": "py", "lang": "Python", "max_stars_repo_path": "lcnn/model/Models.py", "max_stars_repo_name": "VlachosGroup/lcnn", "max_stars_repo_head_hexsha": "90bec040296b8faa4c28230cbc440df8185da715", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2020-03-27T22:34:06.000Z", "max_stars_repo_stars_event_max_datetime": "2020-11-20T13:49:09.000Z", "max_issues_repo_path": "lcnn/model/Models.py", "max_issues_repo_name": "VlachosGroup/lcnn", "max_issues_repo_head_hexsha": "90bec040296b8faa4c28230cbc440df8185da715", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2019-08-01T04:13:58.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-16T04:52:36.000Z", "max_forks_repo_path": "lcnn/model/Models.py", "max_forks_repo_name": "VlachosGroup/lcnn", "max_forks_repo_head_hexsha": "90bec040296b8faa4c28230cbc440df8185da715", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 48.0251396648, "max_line_length": 165, "alphanum_fraction": 0.5970453091, "include": true, "reason": "import numpy", "num_tokens": 3971, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.38121956625614994, "lm_q1q2_score": 0.19507638209139166}} {"text": "# -*- coding: utf-8 -*-\n\"\"\"QLearning.ipynb\n\nAutomatically generated by Colaboratory.\n\"\"\"\n\n#remove \" > /dev/null 2>&1\" to see what is going on under the hood\n# !pip install gym pyvirtualdisplay > /dev/null 2>&1\n# !apt-get install -y xvfb python-opengl ffmpeg > /dev/null 2>&1\n\n# !apt-get update > /dev/null 2>&1\n# !apt-get install cmake > /dev/null 2>&1\n# !pip install --upgrade setuptools 2>&1\n# !pip install ez_setup > /dev/null 2>&1\n# !pip install gym[atari] > /dev/null 2>&1\n\nimport gym\nfrom gym import logger as gymlogger\nfrom gym.wrappers import Monitor\ngymlogger.set_level(40) #error only\nimport numpy as np\nimport random\nimport matplotlib\nimport matplotlib.pyplot as plt\n# %matplotlib inline\nimport glob\nimport io\nimport base64\nfrom IPython.display import HTML\n\nfrom IPython import display as ipythondisplay\n\nfrom pyvirtualdisplay import Display\ndisplay = Display(visible=0, size=(1400, 900))\ndisplay.start()\n\n\"\"\"\nUtility functions to enable video recording of gym environment and displaying it\nTo enable video, just do \"env = wrap_env(env)\"\"\n\"\"\"\n\ndef show_video():\n mp4list = glob.glob('video/*.mp4')\n if len(mp4list) > 0:\n mp4 = mp4list[0]\n video = io.open(mp4, 'r+b').read()\n encoded = base64.b64encode(video)\n ipythondisplay.display(HTML(data=''''''.format(encoded.decode('ascii'))))\n else: \n print(\"Could not find video\")\n \n\ndef wrap_env(env):\n env = Monitor(env, './video', force=True)\n return env\n\nenv = wrap_env(gym.make('MountainCar-v0'))\nenv.reset()\n\n#check out the Mountain Car action space!\nprint(env.action_space)\n\ndef QLearning(env, learning, discount, epsilon, min_eps, episodes):\n # Determine size of discretized state space\n num_states = (env.observation_space.high - env.observation_space.low)*\\\n np.array([10, 100])\n num_states = np.round(num_states, 0).astype(int) + 1\n \n # Initialize Q table\n Q = np.random.uniform(low = -1, high = 1, \n size = (num_states[0], num_states[1], \n env.action_space.n))\n \n # Initialize variables to track rewards\n reward_list = []\n ave_reward_list = []\n \n # Calculate episodic reduction in epsilon\n reduction = (epsilon - min_eps)/episodes\n \n # Run Q learning algorithm\n for i in range(episodes):\n # Initialize parameters\n done = False\n tot_reward, reward = 0,0\n state = env.reset()\n \n # Discretize state\n state_adj = (state - env.observation_space.low)*np.array([10, 100])\n state_adj = np.round(state_adj, 0).astype(int)\n \n while done != True: \n # Render environment for last five episodes\n if i >= (episodes - 20):\n env.render()\n \n # Determine next action - epsilon greedy strategy\n if np.random.random() < 1 - epsilon:\n action = np.argmax(Q[state_adj[0], state_adj[1]]) \n else:\n action = np.random.randint(0, env.action_space.n)\n \n # Get next state and reward\n state2, reward, done, info = env.step(action) \n \n # Discretize state2\n state2_adj = (state2 - env.observation_space.low)*np.array([10, 100])\n state2_adj = np.round(state2_adj, 0).astype(int)\n \n #Allow for terminal states\n if done and state2[0] >= 0.5:\n Q[state_adj[0], state_adj[1], action] = reward\n \n # Adjust Q value for current state\n else:\n delta = learning*(reward + \n discount*np.max(Q[state2_adj[0], \n state2_adj[1]]) - \n Q[state_adj[0], state_adj[1],action])\n Q[state_adj[0], state_adj[1],action] += delta\n \n # Update variables\n tot_reward += reward\n state_adj = state2_adj\n \n # Decay epsilon\n if epsilon > min_eps:\n epsilon -= reduction\n \n # Track rewards\n reward_list.append(tot_reward)\n \n if (i+1) % 100 == 0:\n ave_reward = np.mean(reward_list)\n ave_reward_list.append(ave_reward)\n reward_list = []\n \n if (i+1) % 100 == 0: \n print('Episode {} Average Reward: {}'.format(i+1, ave_reward))\n \n env.close()\n \n return ave_reward_list\n\n# Run Q-learning algorithm\nrewards = QLearning(env, 0.2, 0.9, 0.8, 0, 10000)\n\n# Plot Rewards\nplt.plot(100*(np.arange(len(rewards)) + 1), rewards)\nplt.xlabel('Episodes')\nplt.ylabel('Average Reward')\nplt.title('Average Reward vs Episodes')\nplt.savefig('rewards.jpg') \nplt.show()\nplt.close()\nshow_video()\n\n", "meta": {"hexsha": "ad5a7120240c38d2c853fc8e2388f74abcf423da", "size": 5006, "ext": "py", "lang": "Python", "max_stars_repo_path": "QLearning.py", "max_stars_repo_name": "DhruvUpadhyay/MointainCar-QLearning", "max_stars_repo_head_hexsha": "de95b18653cbb6372d0a50954520942a5dffa364", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-10-22T17:00:32.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-22T17:00:32.000Z", "max_issues_repo_path": "QLearning.py", "max_issues_repo_name": "DhruvUpadhyay/MointainCar-QLearning", "max_issues_repo_head_hexsha": "de95b18653cbb6372d0a50954520942a5dffa364", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "QLearning.py", "max_forks_repo_name": "DhruvUpadhyay/MointainCar-QLearning", "max_forks_repo_head_hexsha": "de95b18653cbb6372d0a50954520942a5dffa364", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-01-21T05:37:13.000Z", "max_forks_repo_forks_event_max_datetime": "2020-01-30T17:08:15.000Z", "avg_line_length": 31.0931677019, "max_line_length": 81, "alphanum_fraction": 0.5783060328, "include": true, "reason": "import numpy", "num_tokens": 1228, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.3812195662561499, "lm_q1q2_score": 0.19507638209139164}} {"text": "import os\n\nimport sympy.physics.units.definitions as u\nfrom sympy.physics.units.quantities import Quantity\nfrom sympy.physics.units.systems.si import dimsys_SI\n\nfrom mathpad.val import Val\nimport mathpad.dimensions as dims\n\nHERE = os.path.dirname(__file__)\n\nAUTOGEN_WARNING = '\"WARNING: this file was automatically generated by commented code within mathpad.py, and then modified slightly\"\\n'\n\nprint(\"writing to \" + f\"{HERE}/units.py\\nand {HERE}/constants.py\")\n\nwith open(f\"{HERE}/units.py\", \"w\") as units_f, open(\n f\"{HERE}/constants.py\", \"w\"\n) as constants_f:\n\n # top of 'units.py'\n units_f.write(AUTOGEN_WARNING)\n units_f.write(\"import sympy.physics.units.definitions.unit_definitions as u\\n\")\n units_f.write(\"from mathpad.physical_quantities import *\\n\")\n\n # top of 'constants.py'\n constants_f.write(AUTOGEN_WARNING)\n constants_f.write(\"import sympy.physics.units.definitions.unit_definitions as u\\n\")\n constants_f.write(\"from mathpad.physical_quantities import *\\n\")\n\n for name in dir(u):\n qty = getattr(u, name)\n\n if name.endswith(\"constant\"):\n constants_f.write(\n f\"\"\"\n{name} = OutputVal(u.{name})\"\"\"\n )\n\n elif isinstance(qty, Quantity):\n\n for quantity_cls_name in dir(dims):\n if quantity_cls_name in \"du\":\n continue\n\n quantity_cls = getattr(dims, quantity_cls_name)\n\n # handle the Angle dimension specially\n if str(qty).startswith(\"angular\") or str(qty).startswith(\"rad\"):\n units_f.write(\n f\"\"\"\n{name} = Angle(u.{name})\"\"\"\n )\n break\n\n elif (\n isinstance(quantity_cls, type)\n and issubclass(quantity_cls, Val)\n and quantity_cls is not Val\n and dimsys_SI.equivalent_dims(qty.dimension, quantity_cls.dimension)\n ):\n units_f.write(\n f\"\"\"\n{name} = {quantity_cls_name}(u.{name})\"\"\"\n )\n break\n else:\n print(f\"Warning: Quantity '{name}' could not be matched; skipping...\")\n", "meta": {"hexsha": "240f9e6751808c84f4cba0bf53175542009dd917", "size": 2243, "ext": "py", "lang": "Python", "max_stars_repo_path": "mathpad/_generate_units.py", "max_stars_repo_name": "CallumJHays/mathpad", "max_stars_repo_head_hexsha": "bb2aab07ead67cd95637d9bd7cd952f0ac7161e8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-09-08T09:29:41.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-29T05:12:20.000Z", "max_issues_repo_path": "mathpad/_generate_units.py", "max_issues_repo_name": "CallumJHays/mathpad", "max_issues_repo_head_hexsha": "bb2aab07ead67cd95637d9bd7cd952f0ac7161e8", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-09-29T05:13:26.000Z", "max_issues_repo_issues_event_max_datetime": "2021-10-06T05:11:22.000Z", "max_forks_repo_path": "mathpad/_generate_units.py", "max_forks_repo_name": "CallumJHays/mathpad", "max_forks_repo_head_hexsha": "bb2aab07ead67cd95637d9bd7cd952f0ac7161e8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.9852941176, "max_line_length": 134, "alphanum_fraction": 0.5853767276, "include": true, "reason": "import sympy,from sympy", "num_tokens": 465, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.3812195662561499, "lm_q1q2_score": 0.19507638209139164}} {"text": "\"\"\"\nCore for the backend of the project.\nAll the computations on the Neural Networks are done here.\nAuthor: Antonio Strippoli\n\"\"\"\n# General imports\nimport os\nimport sys\nimport PIL.Image as pil\nimport numpy as np\n\nimport matplotlib\n\n# Set non interactive backend for matplolib\nmatplotlib.use(\"Agg\")\nimport matplotlib.pyplot as plt\n\n# Project's imports\nfrom flaskr import paths\n\n# TensorFlow & Keras\nimport tensorflow as tf\nfrom tensorflow.keras.models import Model\n\n# TF-Keras-Vis\nfrom tf_keras_vis.gradcam import GradcamPlusPlus\nfrom tf_keras_vis.utils import normalize\n\n# Utilities\nfrom .utils import np_array_to_img_rgb\nfrom utils import pickle_load\nfrom capslayers import compute_vectors_length\n\n\ndef load_model(model_name):\n \"\"\"\n \"\"\"\n # Import model (HACK)\n sys.path.append(os.path.join(paths[\"trainer\"], model_name))\n from capsnet import CapsuleNet\n\n sys.path.pop()\n\n # Load model\n try:\n model_params = pickle_load(\n os.path.join(paths[\"trainer\"], model_name, \"outs\", \"model_params.pkl\")\n )\n except FileNotFoundError:\n return None, None\n\n dataset = model_params.pop(\"dataset\")\n _, model = CapsuleNet(**model_params)\n model_params[\"dataset\"] = dataset\n\n # Clean modules (HACK)\n del sys.modules[\"capsnet\"]\n\n return model, model_params\n\n\ndef get_processable_layers(layers):\n \"\"\"\n Returns computable layers from a list of layers, along with their types. \n We check that by searching specific keywords in layer's name,\n since we can't be sure about layer's type.\n\n If you wish to extend the project and add compatibility\n for more layers, you should as well update this function.\n \"\"\"\n processable_layers = []\n\n for layer in layers:\n layer_name = layer.name.lower()\n\n if \"conv\" in layer_name:\n processable_layers.append([layer_name, \"CONVOLUTIONAL\"])\n elif \"primary\" in layer_name and \"caps\" in layer_name:\n processable_layers.append([layer_name, \"PRIMARY_CAPS\"])\n elif \"caps\" in layer_name:\n processable_layers.append([layer_name, \"DENSE_CAPS\"])\n elif \"mask\" in layer_name:\n processable_layers.append([layer_name, \"MASK\"])\n\n return processable_layers\n\n\ndef conv_out_process(act, img_mode, layer_img_dir):\n # Extract from batch\n act = act[0]\n\n # Prepare new image to contain convolutional's features\n new_img_width = act.shape[0] * act.shape[-1]\n new_img_height = act.shape[1]\n new_img = pil.new(\"RGB\", (new_img_width, new_img_height))\n\n # Save features\n act = tf.multiply(act, 255.0)\n for i in range(act.shape[-1]):\n feature = act[:, :, i].numpy().astype(\"int8\")\n feature_image = pil.fromarray(np.uint8(matplotlib.cm.viridis(feature) * 255))\n\n new_img.paste(\n feature_image, (act.shape[0] * i, 0),\n )\n\n # Save the new image\n new_img.save(os.path.join(layer_img_dir, f\"out.jpeg\"))\n\n # Save filters (TODO?)\n pass\n\n return {\n \"Activations after ReLU\": {\n \"filename\": \"out.jpeg\",\n \"rows\": 1,\n \"cols\": act.shape[-1],\n \"chunk_width\": act.shape[0],\n \"chunk_height\": act.shape[1],\n }\n }\n\n\ndef pcap_out_process(act, prep_img, img_mode, layer, layer_conf, layer_img_dir):\n # Extract from batch\n act = act[0]\n prep_img = prep_img[0]\n\n # Move preprocessed image to RGB domain (if not)\n prep_img = np_array_to_img_rgb(prep_img, img_mode)\n\n # Get new features' dimension\n feature_dim = int(\n (layer.input_shape[1] - layer_conf[\"kernel_size\"] + 1) / layer_conf[\"strides\"]\n )\n # Compute vectors' length and reshape\n act = tf.reshape(compute_vectors_length(act), (feature_dim, feature_dim, -1))\n\n # Prepare new image to contain capsules' activations\n chunk_width, chunk_height = prep_img.size\n new_img_width = chunk_width * act.shape[-1]\n new_img_height = chunk_height\n new_img = pil.new(\"RGB\", (new_img_width, new_img_height))\n\n # Save as images with the same size of the inputs\n act = tf.multiply(act, 255)\n for i in range(act.shape[-1]):\n capsules_length = act[:, :, i].numpy()\n capsules_length = np.interp(\n capsules_length, (capsules_length.min(), capsules_length.max()), (0.0, 1.0),\n )\n heatmap = pil.fromarray(np.uint8(matplotlib.cm.jet(capsules_length) * 255))\n\n # If we stop here, we can get a visualized matrix showing capsules activations,\n # but we go further, rescaling and superimposing the heatmap to the original image\n heatmap = heatmap.resize((chunk_width, chunk_height))\n pcaps_img = pil.blend(prep_img, heatmap, alpha=0.7)\n\n new_img.paste(\n pcaps_img, (chunk_width * i, 0),\n )\n\n # Save the new image\n new_img.save(os.path.join(layer_img_dir, f\"out.jpeg\"))\n\n return {\n \"Capsules' length as heatmap\": {\n \"filename\": \"out.jpeg\",\n \"rows\": 1,\n \"cols\": act.shape[-1],\n \"chunk_width\": chunk_width,\n \"chunk_height\": chunk_height,\n }\n }\n\n\ndef dcap_out_process(prev_layer_pack, layer_pack, prep_img, img_mode, layer_img_dir):\n # --------------------------\n # The following is a compact version of routing path visualization. All the credits goes to Aman Bhullar:\n # https://atrium.lib.uoguelph.ca/xmlui/bitstream/handle/10214/17834/Bhullar_Aman_202003_Msc.pdf?sequence=1&isAllowed=y\n # --------------------------\n\n # TODO: Implement the complete routing path visualization.\n # Also, atm we assume that the previous layer is always a primary caps, which is not always be the case\n\n # Unpack variables\n ((pl, _), prev_act) = prev_layer_pack\n ((cl, _), curr_act) = layer_pack\n\n pl_conf = pl.get_config()\n cl_conf = cl.get_config()\n\n # Get new features' dimension\n feature_dim = int(\n (pl.input_shape[1] - pl_conf[\"kernel_size\"] + 1) / pl_conf[\"strides\"]\n )\n\n # HACK: Assume that every input image to the network is squared,\n # which would produce squared features as well\n dims = [\n feature_dim,\n feature_dim,\n pl_conf[\"n_caps\"],\n cl_conf[\"n_caps\"],\n ]\n\n # Prepare output of previous caps layer\n tmp_dims = dims[0:3] + [1] * (len(dims) - 3)\n prev_caps_lengths = tf.reshape(compute_vectors_length(prev_act), tmp_dims)\n tmp_dims = [1] * (3) + dims[3 : len(dims)]\n prev_caps_lengths_tiled = tf.tile(prev_caps_lengths, tmp_dims)\n\n # Prepare routing weights\n tmp_dims = dims[0:4] + [1] * (len(dims) - 4)\n routing_weights_reshape = tf.reshape(curr_act[1], tmp_dims)\n tmp_dims = [1] * (4) + dims[4 : len(dims)]\n routing_weights_reshape_tiled = tf.tile(routing_weights_reshape, tmp_dims)\n\n # Prepare output of current caps layer\n tmp_dims = [1, 1, 1, dims[3]] + [1] * (len(dims) - 4)\n curr_caps_lengths = tf.reshape(compute_vectors_length(curr_act[0]), tmp_dims)\n tmp_dims = dims[0:3] + [1] + dims[4 : len(dims)]\n curr_caps_lengths_tiled = tf.tile(curr_caps_lengths, tmp_dims)\n\n # Calculate routing path visualization\n tmp = tf.multiply(routing_weights_reshape_tiled, curr_caps_lengths_tiled)\n all_paths = tf.multiply(prev_caps_lengths_tiled, tmp)\n all_paths_average = tf.reduce_sum(all_paths, axis=2)\n\n # Preprocess input image\n input_img_width, input_img_height = prep_img.shape[1:3]\n prep_img = prep_img[0]\n\n # Move preprocessed image to RGB domain (if not)\n prep_img = np_array_to_img_rgb(prep_img, img_mode)\n\n # Prepare new image to contain capsules' activations\n new_img = pil.new(\"RGB\", (input_img_width * dims[-1], input_img_height))\n\n # Save outputs as a single image\n all_paths_average = all_paths_average.numpy()\n all_paths_average = np.interp(\n all_paths_average,\n (all_paths_average.min(), all_paths_average.max()),\n (0.0, 1.0),\n )\n for i in range(all_paths_average.shape[-1]):\n rpv = all_paths_average[:, :, i]\n heatmap = pil.fromarray(np.uint8(matplotlib.cm.jet(rpv) * 255))\n\n # Rescale and blend\n heatmap = heatmap.resize((input_img_width, input_img_height))\n dcaps_img = pil.blend(prep_img, heatmap, alpha=0.7)\n\n new_img.paste(dcaps_img, (i * input_img_width, 0))\n\n # Save the new image\n new_img.save(os.path.join(layer_img_dir, f\"out.jpeg\"))\n\n return {\n \"Routing Path Visualization\": {\n \"filename\": \"out.jpeg\",\n \"rows\": 1,\n \"cols\": dims[-1],\n \"chunk_width\": input_img_width,\n \"chunk_height\": input_img_height,\n }\n }\n\n\ndef dcap_gradcam(model, layer, prep_img, img_mode, layer_img_dir):\n # Edit model to stop at the current layer\n def model_modifier(model):\n return tf.keras.Model(inputs=model.inputs, outputs=layer.output)\n\n # Instantiate gradcam\n gradcam = GradcamPlusPlus(model, model_modifier, clone=False)\n\n def loss(output):\n \"\"\"Maximize the prediction with greater probability\"\"\"\n output = compute_vectors_length(output)\n i = np.argmax(output, 1)[0]\n return output[0, i]\n\n # Compute gradcam\n cam = normalize(\n gradcam(\n [loss, lambda x: tf.convert_to_tensor(0.0)],\n prep_img,\n penultimate_layer=layer,\n )\n )\n heatmap = pil.fromarray(np.uint8(matplotlib.cm.jet(cam[0]) * 255))\n\n # Move preprocessed image to RGB domain (if not)\n prep_img = prep_img[0]\n prep_img = np_array_to_img_rgb(prep_img, img_mode)\n\n # Superimpose heatmap\n gradcam_final = pil.blend(prep_img, heatmap, alpha=0.7)\n\n # Save the new image\n gradcam_final.convert(\"RGB\").save(os.path.join(layer_img_dir, f\"out.jpeg\"))\n\n return {\"filename\": \"out.jpeg\"}\n\n\ndef mask_out_process(act, img_mode, layer, model_params, layer_img_dir):\n # Extract from batch and convert to numpy\n act = act[0]\n act_numpy = act.numpy()\n\n # Get next layer ( suppose decoder (HACK) )\n next_layer = layer._outbound_nodes[1].outbound_layer\n\n # Prepare dictionary for outputs\n out = {}\n\n # === MANIPULATIONS ON MAGNITUDE ===\n n_manip = 11\n\n # Prepare new output image\n new_img_width = model_params[\"input_shape\"][0] * n_manip\n new_img_height = model_params[\"input_shape\"][1]\n new_img = pil.new(img_mode, (new_img_width, new_img_height))\n\n # Edit tensor values and feed the activation forward to get reconstruction\n for i_r, r in enumerate(np.linspace(0, 1, n_manip)):\n r = round(r, 1)\n # Rescale magnitude value\n act_to_feed = np.copy(act_numpy)\n act_to_feed *= r / compute_vectors_length(act_to_feed)\n\n # Convert back to tensor and feed-forward\n act_to_feed = tf.expand_dims(tf.convert_to_tensor(act_to_feed), 0)\n reconstructed_image = next_layer(act_to_feed)\n\n # Pre-process reconstruction\n reconstructed_image = tf.squeeze(reconstructed_image)\n reconstructed_image = tf.multiply(reconstructed_image, 255.0)\n reconstructed_image = reconstructed_image.numpy().astype(\"int8\")\n\n # Convert to image and paste to the new image\n reconstructed_image = pil.fromarray(reconstructed_image, mode=img_mode)\n new_img.paste(\n reconstructed_image, (model_params[\"input_shape\"][0] * i_r, 0,),\n )\n\n # Save the new image\n new_img.save(os.path.join(layer_img_dir, f\"magnitude.jpeg\"))\n\n # Prepare partial output\n out[\"1) Manipulations on magnitude\"] = {\n \"filename\": \"magnitude.jpeg\",\n \"rows\": 1,\n \"cols\": n_manip,\n \"chunk_width\": model_params[\"input_shape\"][0],\n \"chunk_height\": model_params[\"input_shape\"][1],\n }\n\n # === MANIPULATIONS ON DIMENSIONS ===\n # Prepare variables for the iterations\n start = np.argmax(act != 0)\n n_dims = act.shape[0] // model_params[\"n_class\"]\n n_manip = 11\n\n # Prepare new output image\n new_img_width = model_params[\"input_shape\"][0] * n_manip\n new_img_height = model_params[\"input_shape\"][1] * n_dims\n new_img = pil.new(img_mode, (new_img_width, new_img_height))\n\n # Edit tensor values and feed the activation forward to get reconstruction\n for i_dim in range(start, start + n_dims):\n for i_r, r in enumerate(np.linspace(-0.25, 0.25, n_manip)):\n r = round(r, 2)\n # Edit dimension value\n act_to_feed = np.copy(act_numpy)\n act_to_feed[i_dim] += r\n\n # Convert back to tensor and feed-forward\n act_to_feed = tf.expand_dims(tf.convert_to_tensor(act_to_feed), 0)\n reconstructed_image = next_layer(act_to_feed)\n\n # Pre-process reconstruction\n reconstructed_image = tf.squeeze(reconstructed_image)\n reconstructed_image = tf.multiply(reconstructed_image, 255.0)\n reconstructed_image = reconstructed_image.numpy().astype(\"int8\")\n\n # Convert to image and paste to the new image\n reconstructed_image = pil.fromarray(reconstructed_image, mode=img_mode)\n new_img.paste(\n reconstructed_image,\n (\n model_params[\"input_shape\"][0] * i_r,\n model_params[\"input_shape\"][1] * (i_dim - start),\n ),\n )\n\n # Save the new image\n new_img.save(os.path.join(layer_img_dir, f\"dimensions.jpeg\"))\n\n out[\"2) Manipulations on dimensions\"] = {\n \"filename\": \"dimensions.jpeg\",\n \"rows\": n_dims,\n \"cols\": n_manip,\n \"chunk_width\": model_params[\"input_shape\"][0],\n \"chunk_height\": model_params[\"input_shape\"][1],\n }\n\n return out\n\n\ndef model_out_process(predictions, model_out_dir):\n \"\"\"\n Visualize model's predictions in an histogram.\n \"\"\"\n plt.rcdefaults()\n fig, ax = plt.subplots()\n\n classes = np.arange(len(predictions))\n\n ax.barh(classes, predictions, align=\"center\")\n ax.set_yticks(classes)\n ax.set_yticklabels(classes)\n ax.set_xlim(0, 1.0)\n\n plt.title(\n f\"Prediction: {np.argmax(predictions)}\",\n fontsize=30.0,\n color=\"blue\",\n fontweight=\"bold\",\n )\n ax.invert_yaxis()\n ax.spines[\"right\"].set_visible(False)\n ax.spines[\"top\"].set_visible(False)\n ax.tick_params(axis=\"both\", colors=\"blue\", labelsize=20.0)\n\n for i, v in enumerate(predictions):\n ax.text(\n v + 0.01,\n i + 0.06,\n str(round(v, 4)),\n color=\"blue\",\n fontweight=\"bold\",\n verticalalignment=\"center\",\n size=15.0,\n )\n\n plt.savefig(os.path.join(model_out_dir, \"out.png\"), transparent=True)\n plt.close(\"all\")\n return {\"filename\": \"out.png\"}\n\n\ndef compute_step(model, model_params, prep_img, img_mode, req_out_dir):\n \"\"\"\n Computes and saves the outputs of the processable layers in the given model.\n \"\"\"\n # Create a temporary model to retrieve all the layers' activations\n processable_layers = get_processable_layers(model.layers)\n processable_layers = [(model.get_layer(pl[0]), pl[1]) for pl in processable_layers]\n\n activation_model = Model(model.input, [pl[0].output for pl in processable_layers])\n activations = activation_model(prep_img)\n\n # Prepare dictionary to contain outputs\n out_dir = req_out_dir.replace(\"\\\\\", \"/\")\n out_dir = out_dir[out_dir.find(\"/static\") :] + \"/\"\n\n out_info = {\"out_dir\": out_dir}\n outs = {}\n\n layer_pack = list(zip(processable_layers, activations))\n for i, ((layer, layer_type), act) in enumerate(layer_pack):\n # Get layer config\n layer_conf = layer.get_config()\n\n # Prepare directory for the layer\n layer_name = layer_conf[\"name\"]\n layer_img_dir = os.path.join(req_out_dir, layer_name)\n os.mkdir(layer_img_dir)\n\n # === PROCESS LAYER ACTIVATION BASED ON TYPE ===\n if layer_type == \"CONVOLUTIONAL\":\n outs[layer_name] = conv_out_process(act, img_mode, layer_img_dir)\n elif layer_type == \"PRIMARY_CAPS\":\n outs[layer_name] = pcap_out_process(\n act, prep_img, img_mode, layer, layer_conf, layer_img_dir\n )\n elif layer_type == \"DENSE_CAPS\":\n curr_lp = layer_pack[i]\n prev_lp = layer_pack[i - 1]\n outs[layer_name] = dcap_out_process(\n prev_lp, curr_lp, prep_img, img_mode, layer_img_dir\n )\n\n # Compute GradCAM++\n gradcam_dir = os.path.join(req_out_dir, \"gradcam\")\n os.mkdir(gradcam_dir)\n out_info[\"gradcam\"] = dcap_gradcam(\n model, layer, prep_img, img_mode, gradcam_dir\n )\n elif layer_type == \"MASK\":\n outs[layer_name] = mask_out_process(\n act, img_mode, layer, model_params, layer_img_dir\n )\n else:\n raise TypeError(f\"Layer type '{layer_type}' cannot be computed.\")\n\n # Add layers outputs\n out_info[\"layers_outs\"] = outs\n\n # Process model's output\n model_out_dir = os.path.join(req_out_dir, \"model_out\")\n os.mkdir(model_out_dir)\n\n model_outs = model(prep_img)\n if type(model_outs) == list:\n predictions = model_outs[0][0].numpy()\n else:\n predictions = model_outs[0].numpy()\n\n out_info[\"model_out\"] = model_out_process(predictions, model_out_dir)\n\n return out_info\n", "meta": {"hexsha": "8d15205366cb190c6d652fbb444dc4694e83a4e8", "size": 17321, "ext": "py", "lang": "Python", "max_stars_repo_path": "flaskr/api_nn.py", "max_stars_repo_name": "CoffeeStraw/CapsNet-Knowledge-Extractor", "max_stars_repo_head_hexsha": "99dc665bcce394e4dfa0b8a6deda28d1e3713509", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2020-09-29T13:34:23.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-01T15:27:53.000Z", "max_issues_repo_path": "flaskr/api_nn.py", "max_issues_repo_name": "CoffeeStraw/CapsNet-Knowledge-Extractor", "max_issues_repo_head_hexsha": "99dc665bcce394e4dfa0b8a6deda28d1e3713509", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "flaskr/api_nn.py", "max_forks_repo_name": "CoffeeStraw/CapsNet-Knowledge-Extractor", "max_forks_repo_head_hexsha": "99dc665bcce394e4dfa0b8a6deda28d1e3713509", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.9923809524, "max_line_length": 122, "alphanum_fraction": 0.6419375325, "include": true, "reason": "import numpy", "num_tokens": 4263, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041652, "lm_q2_score": 0.38121956625614994, "lm_q1q2_score": 0.1950763820913916}} {"text": "'''\nPersonalised argumentation paper: are user features are required or latent variables sufficient/correlated with observed features?\nIs prior stance a useful user feature for predicting belief change? It should be, since a user can only be convinced by\nan argument if they did not previously believe in it.\nTopic-specific nature means predictions based on linguistic features are likely to be weak?\n\nCreated on 19 Jun 2017\n\n@author: simpson\n'''\nimport os\nimport sys\nimport logging\nimport matplotlib.pyplot as plt # do this here so we don't get the debugging crap later from the logger\n\nfrom sklearn.gaussian_process.gpr import GaussianProcessRegressor\nfrom sklearn.gaussian_process.kernels import Matern\nfrom sklearn.metrics import accuracy_score\n\nlogging.basicConfig(level=logging.DEBUG)\n\nsys.path.append(\"./python/analysis/habernal_comparison\")\n\nfrom tests import TestRunner\nfrom gp_regressor_svi import GPRegressorSVI\nfrom collab_pref_learning_svi import CollabPrefLearningSVI\nimport numpy as np\n\nnfactors = 50\nmax_Kw_size = 2000\n\nrate_s = 200\n\nrate_sy0 = 10\n\ndelay = 0 # some default will be used depending on the function unless this is set to > 0\n\nclass PersonalisedTestRunner(TestRunner):\n\n def run_crowd_bt(self):\n\n nitems = self.items_feat.shape[0]\n workers = np.unique(self.person_train)\n nworkers = np.max(workers) + 1\n\n scales = [1] # [0.01, 0.1, 1, 10, 100] # 10 was found to be optimal on the random selection tests.\n\n tr_acc_best = 0\n\n for scale in scales:\n\n # initialise variational parameters\n Es = np.zeros(nitems)\n Eeta = np.ones(nworkers) * 0.9\n sigma = np.ones(nitems) * scale\n alpha = np.ones(nworkers) * 9\n beta = np.ones(nworkers)\n\n balance = 0#1e-6 # tiny amount to ensure numerical stability\n\n for pair_idx in range(len(self.a1_train)):\n\n # get the indices\n a1 = self.a1_train[pair_idx]\n a2 = self.a2_train[pair_idx]\n\n if self.prefs_train[pair_idx] == 1:\n continue\n\n if self.prefs_train[pair_idx] != 2: # swap so a2 is the preferred one\n tmp = a1\n a1 = a2\n a2 = tmp\n\n k = self.person_train[pair_idx]\n\n # update the means\n prob_incr = alpha[k] * np.exp(Es[a1]) / (alpha[k] * np.exp(Es[a1]) + beta[k] * np.exp(Es[a2]) + balance) \\\n - np.exp(Es[a1]) / (np.exp(Es[a1]) + np.exp(Es[a2]) + balance)\n Es[a1] = Es[a1] + sigma[a1] ** 2 * prob_incr\n Es[a2] = Es[a2] - sigma[a2] ** 2 * prob_incr\n\n var_diff = alpha[k] *np.exp(Es[a1]) * beta[k] * np.exp(Es[a2]) / \\\n ((alpha[k] * np.exp(Es[a1]) + beta[k] * np.exp(Es[a2]))**2 + balance) \\\n - np.exp(Es[a1]) * np.exp(Es[a2]) / ((np.exp(Es[a1]) + np.exp(Es[a2]))**2 + balance)\n sigma[a1] = np.sqrt(sigma[a1] ** 2 * np.max([1 + sigma[a1] ** 2 * (var_diff), 10e-4]))\n sigma[a2] = np.sqrt(sigma[a2] ** 2 * np.max([1 + sigma[a2] ** 2 * (var_diff), 10e-4]))\n\n C1 = np.exp(Es[a1]) / (np.exp(Es[a1]) + np.exp(Es[a2]) + balance) \\\n + 0.5 * (sigma[a1] ** 2 + sigma[a2] ** 2) \\\n * np.exp(Es[a1]) * np.exp(Es[a2]) * (np.exp(Es[a2]) - np.exp(Es[a1])) \\\n / (np.exp(Es[a1]) + np.exp(Es[a2]) + balance) ** 3\n\n C2 = 1 - C1\n\n C = (C1 * alpha[k] + C2 * beta[k]) / (alpha[k] + beta[k] + balance) # normalisation constant for p( 1 > 2 | worker k)\n\n Eeta[k] = (C1 * (alpha[k] + 1) * alpha[k] + C2 * alpha[k] * beta[k]) / (\n C * (alpha[k] + beta[k] + 1) * (alpha[k] + beta[k]) + balance)\n Eeta_sq_k = (C1 * (alpha[k] + 2) * (alpha[k] + 1) * alpha[k] + C2 * (alpha[k] + 1) * alpha[k] * beta[k]) / \\\n (C * (alpha[k] + beta[k] + 2) * (alpha[k] + beta[k] + 1) * (alpha[k] + beta[k]) + balance)\n\n alpha[k] = (Eeta[k] - Eeta_sq_k) * Eeta[k] / (Eeta_sq_k - Eeta[k] ** 2 + balance)\n beta[k] = (Eeta[k] - Eeta_sq_k) * (1 - Eeta[k]) / (Eeta_sq_k - Eeta[k] ** 2 + balance)\n\n if np.mod(pair_idx, 1000) == 0:\n print('Learning crowdBT, iteration %i' % pair_idx)\n\n if np.any(np.isnan(Es)):\n continue\n\n tr_proba = np.exp(Es[self.a1_train]) / (np.exp(Es[self.a1_train]) + np.exp(Es[self.a2_train]) + balance)\n tr_acc = accuracy_score(self.prefs_train[self.prefs_train != 1]==2, np.round(tr_proba[self.prefs_train != 1]))\n print('training set accuracy = %f with scale %f' % (tr_acc, scale) )\n if tr_acc > tr_acc_best:\n Es_best = Es\n scale_best = scale\n tr_acc_best = tr_acc\n\n Es = Es_best\n\n print('Completed online learning of crowd BT. Found best scale is %f' % scale_best)\n\n proba = np.exp(Es[self.a1_test]) / (np.exp(Es[self.a1_test]) + np.exp(Es[self.a2_test]) + balance)\n\n self.crowdBT_sigma = sigma\n self.crowdBT_s = Es\n\n scores = Es[self.a_rank_test]\n\n tr_proba = np.exp(Es[self.a1_unseen]) / (\n np.exp(Es[self.a1_unseen]) + np.exp(Es[self.a2_unseen]) + balance)\n\n return proba, scores, tr_proba, Es[self.a_rank_train]\n\n\n def run_crowd_bt_gpr(self):\n\n # we first train crowd_bt as above. Then, we use the scores for items that were compared in training\n # to train a GP regression model. The GP then predicts the scores of all items. This means we can generalise\n # from the training items to all items, plus the GP will do some smoothing over the training items in case they\n # had sparse noisy data.\n\n proba, predicted_f, tr_proba, tr_f = self.run_crowd_bt()\n\n if 'additive' in self.method:\n kernel_combination = '+'\n else:\n kernel_combination = '*'\n\n if 'shrunk' in self.method:\n ls_initial = self.ls_initial / float(len(self.ls_initial))\n else:\n ls_initial = self.ls_initial\n\n if 'weaksprior' in self.method:\n shape_s0 = 2.0\n rate_s0 = 200.0\n elif 'lowsprior' in self.method:\n shape_s0 = 1.0\n rate_s0 = 1.0\n elif 'weakersprior' in self.method:\n shape_s0 = 2.0\n rate_s0 = 2000.0\n else:\n shape_s0 = 200.0\n rate_s0 = 20000.0\n\n if '_M' in self.method:\n validx = self.method.find('_M') + 2\n M = int(self.method[validx:])\n else:\n M = 500\n\n if '_SS' in self.method:\n validx = self.method.find('_SS') + 3\n SS = int(self.method[validx:])\n else:\n SS = 200\n\n self.model = GPRegressorSVI(ninput_features=self.ndims, ls_initial=ls_initial, verbose=self.verbose,\n shape_s0=2, rate_s0=200, rate_ls=1.0 / np.mean(ls_initial),\n use_svi=True,\n ninducing=M, max_update_size=SS, kernel_combination=kernel_combination,\n forgetting_rate=0.7,\n delay=1.0)\n self.model.max_iter_VB = 2 #00\n new_items_feat = self.items_feat # pass only when initialising\n\n print(\"no. features: %i\" % new_items_feat.shape[1])\n self.model.fit(self.items_feat, self.crowdBT_s, obs_noise=self.crowdBT_sigma ** 2)\n\n predicted_f, _ = self.model.predict_f() #self.model.obs_f\n\n balance = 0\n proba = np.exp(predicted_f[self.a1_test]) / (\n np.exp(predicted_f[self.a1_test]) + np.exp(predicted_f[self.a2_test]) + balance)\n\n f = predicted_f[self.a_rank_test]\n\n tr_f = predicted_f[self.a_rank_train]\n\n tr_proba = np.exp(predicted_f[self.a1_unseen]) / (\n np.exp(predicted_f[self.a1_unseen]) + np.exp(predicted_f[self.a2_unseen]) + balance)\n\n return proba, f, tr_proba, tr_f\n\n\n def _train_persgppl(self, delay):\n common_mean = False\n\n if '_commonmean' in self.method:\n common_mean = True\n\n if 'weaksprior' in self.method:\n shape_s0 = 2.0\n rate_s0 = rate_s #200.0\n elif 'lowsprior' in self.method:\n shape_s0 = 1.0\n rate_s0 = 1.0\n elif 'weakersprior' in self.method:\n shape_s0 = 2.0\n rate_s0 = 2000.0\n else:\n shape_s0 = 200.0\n rate_s0 = 20000.0\n\n if '_M' in self.method:\n validx = self.method.find('_M') + 2\n M = int(self.method[validx:].split('_')[0])\n else:\n M = 500\n\n if M == 0:\n M = self.items_feat.shape[0]\n\n if '_F' in self.method:\n valididx = self.method.find('_F') + 2\n F = int(self.method[valididx:].split('_')[0])\n else:\n F = nfactors\n\n if '_SS' in self.method:\n validx = self.method.find('_SS') + 3\n SS = int(self.method[validx:])\n\n niter = 200 #* (200.0 / float(SS))\n else:\n SS = 200\n niter = 200\n\n self.model = CollabPrefLearningSVI(nitem_features=self.ndims, ls=self.ls_initial, verbose=self.verbose,\n nfactors=F, rate_ls=1.0 / np.mean(self.ls_initial),\n use_common_mean_t=common_mean, max_update_size=SS, use_lb=True,\n shape_s0=shape_s0, rate_s0=rate_s0,\n shape_st0=shape_s0, rate_st0=rate_s0,\n shape_sy0=1, rate_sy0=rate_sy0,\n ninducing=M, forgetting_rate=0.9,\n delay=delay,\n exhaustive_train_count=1)\n\n self.model.max_iter = niter # same as for single user GPPL\n self.model.max_Kw_size = max_Kw_size\n\n zero_centered_prefs = np.array(self.prefs_train, dtype=float) - 1\n\n # subsample for debugging!!!\n # self.chosen_people = np.unique(self.person_test)[:50]\n # tridxs = np.in1d(self.person_train, self.chosen_people)\n\n #self.model.uselowerbound = False\n self.model.use_local_obs_posterior_y = False\n\n self.model.fit(self.person_train, self.a1_train, self.a2_train, self.items_feat, zero_centered_prefs,\n optimize=self.optimize_hyper, nrestarts=1, input_type='zero-centered')\n\n\n def run_persgppl(self):\n '''\n Make personalised predictions\n :return:\n '''\n global delay\n if delay == 0:\n delay = 10\n self._train_persgppl(delay=delay)\n\n if self.vscales is not None:\n self.vscales.append(np.sort((self.model.rate_sw / self.model.shape_sw) *\n (self.model.rate_sw / self.model.shape_sw))[::-1])\n\n proba = self.model.predict(self.person_test, self.a1_test, self.a2_test)\n tr_proba = self.model.predict(self.person_unseen, self.a1_unseen, self.a2_unseen)\n\n # what did we change?\n # - more iterations ( 200 --> 500 )\n # - smaller rates ( 200 --> 20 ) because there are multiple factors whose scales all add up\n # next: try increasing delay so that y doesn't disappear to zero so easily when the person is not seen until\n # later batch of training data\n # Also: consider that when users are independent, then the stochastic updates are also updating only some of\n # the variables. But the others are getting set back to zero... this is only a problem in this model because\n # if they are initialised to zero, they don't move much because w and y are scaled by each other's current\n # estimates. It might be okay if variance of w and y is large because this is added to the scale factor\n\n if self.a_rank_test is not None:\n predicted_f = self.model.predict_f_item_person(self.a_rank_test, self.person_rank_test)\n else:\n predicted_f = None\n\n if self.a_rank_train is not None:\n tr_f = self.model.predict_f_item_person(self.a_rank_train, self.person_rank_train)\n else:\n tr_f = None\n\n return proba, predicted_f, tr_proba, tr_f\n\n def run_persgppl_consensus(self):\n '''\n Predict the consensus from multiple people's opinions.\n '''\n\n # look for a file that was trained on the same data but with the personalised predictions instead of MACE consensus.\n # pretrainedmodelfile = self.modelfile.replace('_evalMACE', '')\n # pretrainedmodelfile = pretrainedmodelfile.replace('Consensus', '')\n #\n # logging.info('Looking for a pretrained model at %s' % pretrainedmodelfile)\n #\n # if os.path.exists(pretrainedmodelfile):\n # with open(pretrainedmodelfile, 'rb') as fh:\n # self.model = pickle.load(fh)\n # logging.info('Reloaded a pretrained model :)')\n # else:\n # logging.info('I didnae find any pretrained model :(')\n # self._train_persgppl()\n\n print('Training crowdGPPL to predict consensus...')\n global delay\n if delay == 0:\n delay = 10\n\n self._train_persgppl(delay=delay)\n\n if self.vscales is not None:\n self.vscales.append(np.sort(self.model.rate_sw / self.model.shape_sw)[::-1])\n\n\n print('Testing crowdGPPL on consensus -- making predictions now.')\n proba = self.model.predict_common(None, self.a1_test, self.a2_test)\n tr_proba = self.model.predict_common(None, self.a1_unseen, self.a2_unseen)\n\n if self.a_rank_test is not None:\n predicted_f = self.model.predict_t()[self.a_rank_test]\n else:\n predicted_f = None\n\n if self.a_rank_train is not None:\n tr_f = self.model.predict_t()[self.a_rank_train]\n else:\n predicted_f = None\n\n print('Max probability = %f, min = %f' % (np.max(proba), np.min(proba)))\n\n return proba, predicted_f, tr_proba, tr_f\n\n def _choose_method_fun(self, feature_type):\n if 'PersPrefGP' in self.method:\n method_runner_fun = self.run_persgppl\n elif 'PersConsensusPrefGP' in self.method:\n method_runner_fun = self.run_persgppl_consensus\n elif 'IndPrefGP' in self.method:\n method_runner_fun = self.run_persgppl # switches to correct class inside the method\n elif 'crowdBT' in self.method:\n method_runner_fun = self.run_crowd_bt\n elif 'cBT_GP' in self.method:\n method_runner_fun = self.run_crowd_bt_gpr\n else:\n method_runner_fun = super(PersonalisedTestRunner, self)._choose_method_fun(feature_type)\n\n return method_runner_fun\n\nif __name__ == '__main__':\n\n test_to_run = int(sys.argv[1])\n\n if len(sys.argv) > 2:\n npairs = int(sys.argv[2])\n else:\n npairs = 0 #5000\n\n if len(sys.argv) > 3:\n lsm = int(sys.argv[3])\n else:\n lsm = 1\n\n test_dir = 'D05-%i_P%i' % (lsm, npairs) #'rate_s_tests_single'\n\n methods = ['SinglePrefGP_noOpt_weaksprior']\n datasets = ['UKPConvArgCrowdSample_evalMACE']\n dataset_increment = 0\n # UKPConvArgCrowdSample tests prediction of personal data.\n # UKPConvArgCrowdSample_evalMACE uses the personal data as input, but predicts the global labels/rankings.\n feature_types = ['both'] # can be 'embeddings' or 'ling' or 'both' or 'debug'\n embeddings_types = ['word_mean']\n\n datasets = ['UKPConvArgCrowdSample']\n methods = ['PersPrefGP_commonmean_noOpt_weaksprior']\n\n runner = PersonalisedTestRunner(test_dir, datasets, feature_types, embeddings_types, methods,\n dataset_increment)\n\n max_fold = 32\n\n rate_sy0 = 10\n\n # PERSONALISED PREDICTION\n if test_to_run == 0:\n runner.run_test_set(min_no_folds=0, max_no_folds=max_fold, npairs=npairs, ls_factor=lsm)\n\n elif test_to_run == 13:\n # tune up on training set accuracy\n\n rateyvals = [1, 10, 100]\n delays = [1, 10]\n\n for ratey in rateyvals:\n for delay in delays:\n rate_sy0 = ratey\n\n test_dir = 'D05-%i_P%i-ratey%i-delay%i' % (lsm, npairs, ratey, delay) # 'rate_s_tests_single'\n runner = PersonalisedTestRunner(test_dir, datasets, feature_types, embeddings_types, methods,\n dataset_increment)\n runner.run_test_set(min_no_folds=0, max_no_folds=10, npairs=npairs, ls_factor=lsm)\n\n elif test_to_run == 14:\n\n rateyvals = [1, 10, 100]\n delays = [1, 10]\n\n for ratey in rateyvals:\n for delay in delays:\n rate_sy0 = ratey\n\n test_dir = 'D05-%i_P%i-ratey%i-delay%i' % (lsm, npairs, ratey, delay) # 'rate_s_tests_single'\n runner = PersonalisedTestRunner(test_dir, datasets, feature_types, embeddings_types, methods,\n dataset_increment)\n runner.datasets = ['UKPConvArgCrowdSample_evalMACE']\n runner.methods = ['PersConsensusPrefGP_commonmean_noOpt_weaksprior']\n runner.run_test_set(min_no_folds=0, max_no_folds=10, npairs=npairs, ls_factor=lsm)\n\n\n elif test_to_run == 12:\n runner.datasets = ['UKPConvArgCrowdSample']\n runner.methods = ['PersPrefGP_noOpt_weaksprior']\n runner.run_test_set(min_no_folds=0, max_no_folds=max_fold, npairs=npairs, ls_factor=lsm)\n\n\n # CONSENSUS PREDICTION\n elif test_to_run == 1:\n runner.datasets = ['UKPConvArgCrowdSample_evalMACE']\n runner.methods = ['PersConsensusPrefGP_commonmean_noOpt_weaksprior']\n runner.run_test_set(min_no_folds=0, max_no_folds=max_fold, npairs=npairs, ls_factor=lsm)\n\n # Plot the scales of the latent factors ----------------------------------------------------------------------\n if test_to_run < 4 and len(runner.vscales):\n vscales = np.mean(runner.vscales, axis=0)\n\n logging.getLogger().setLevel(logging.WARNING) # matplotlib prints loads of crap to the debug and info outputs\n\n import matplotlib\n matplotlib.use('Agg')\n import matplotlib.pyplot as plt\n\n fig = plt.figure(figsize=(5, 4))\n\n markers = ['x', 'o', '+', '>', '<', '*']\n\n plt.plot(np.arange(vscales.shape[0]), vscales, marker=markers[0], label='UKPConvArgCrowdSample',\n linewidth=2, markersize=8)\n\n plt.ylabel('Inverse scale 1/s')\n plt.xlabel('Factor ID')\n\n plt.grid('on', axis='y')\n plt.legend(loc='best')\n plt.tight_layout()\n\n figure_root_path = './results/conv_factors'\n if not os.path.exists(figure_root_path):\n os.mkdir(figure_root_path)\n\n plt.savefig(figure_root_path + '/UKPConvArgCrowdSample_factor_scales.pdf')\n\n np.savetxt(figure_root_path + '/UKPConvArgCrowdSample_factor_scales.csv', vscales, delimiter=',', fmt='%f')\n\n logging.getLogger().setLevel(logging.DEBUG)\n\n # PERSONALISED PREDICTION for other methods -----------------------------------------------------------------\n elif test_to_run == 6:\n methods = [\n 'SinglePrefGP_noOpt_weaksprior' # 'SinglePrefGP_noOpt_weaksprior',\n ]\n runner.datasets = ['UKPConvArgCrowdSample']\n runner.methods = methods\n runner.run_test_set(min_no_folds=0, max_no_folds=max_fold, npairs=npairs, ls_factor=lsm)\n\n elif test_to_run == 7:\n methods = [\n 'SinglePrefGP_noOpt_weaksprior' # 'SinglePrefGP_noOpt_weaksprior',\n ]\n runner.datasets = ['UKPConvArgCrowdSample_evalMACE']\n runner.methods = methods\n runner.run_test_set(min_no_folds=0, max_no_folds=max_fold, npairs=npairs, ls_factor=lsm)\n\n elif test_to_run == 8:\n methods = [\n #'crowdBT', # no point running this because it cannot predict on the test instances, for aggregation only\n 'cBT_GP',\n ]\n runner.datasets = ['UKPConvArgCrowdSample']\n runner.methods = methods\n runner.run_test_set(min_no_folds=0, max_no_folds=max_fold, npairs=npairs, ls_factor=lsm)\n\n elif test_to_run == 9: # commented so we run both tests with cBT\n methods = [\n #'crowdBT', # no point running this because it cannot predict on the test instances, for aggregation only\n 'cBT_GP',\n ]\n runner.datasets = ['UKPConvArgCrowdSample_evalMACE']\n runner.methods = methods\n runner.run_test_set(min_no_folds=0, max_no_folds=max_fold, npairs=npairs, ls_factor=lsm)\n\n elif test_to_run == 11: # commented so we run both tests with cBT\n methods = [\n 'crowdBT', # no point running this because it cannot predict on the test instances, for aggregation only\n ]\n runner.datasets = ['UKPConvArgCrowdSample_evalMACE']\n runner.methods = methods\n runner.run_test_set(min_no_folds=0, max_no_folds=max_fold, npairs=npairs, ls_factor=lsm)", "meta": {"hexsha": "7809e6e91d4a4e036478809fa69899acf25c6883", "size": 21402, "ext": "py", "lang": "Python", "max_stars_repo_path": "python/analysis/habernal_comparison/personalised_tests.py", "max_stars_repo_name": "UKPLab/tacl2018-preference-convincing", "max_stars_repo_head_hexsha": "65eb1cd3bf76f8068889880e0f80178e790350ce", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 13, "max_stars_repo_stars_event_min_datetime": "2019-03-01T19:40:23.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-10T05:53:47.000Z", "max_issues_repo_path": "python/analysis/habernal_comparison/personalised_tests.py", "max_issues_repo_name": "UKPLab/tacl2018-preference-convincing", "max_issues_repo_head_hexsha": "65eb1cd3bf76f8068889880e0f80178e790350ce", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-13T17:54:01.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-09T23:39:11.000Z", "max_forks_repo_path": "python/analysis/habernal_comparison/personalised_tests.py", "max_forks_repo_name": "UKPLab/tacl2018-preference-convincing", "max_forks_repo_head_hexsha": "65eb1cd3bf76f8068889880e0f80178e790350ce", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2019-02-06T12:08:20.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-10T20:40:22.000Z", "avg_line_length": 39.780669145, "max_line_length": 134, "alphanum_fraction": 0.5858798243, "include": true, "reason": "import numpy", "num_tokens": 5474, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.38121955219593834, "lm_q1q2_score": 0.19507637489654792}} {"text": "\"\"\"This is a module for calcuating groups and integrations with JWST on\nthe fly. The main function (``perform_calculation``) takes a dictionary\nof inputs (modeled around how the web tool takes inputs) which must\ninclude: ``observation_time``, ``num_groups``, ``magnitude``,\n``model``, ``band``, ``filt``, ``filt_ta``, ``instrument``,\n``subarray``, ``subarray_ta``, ``saturation_mode``, ``max_saturation``,\nand ``infile``. It produces and dictionary of outputs that includes all\nof the original information as well as groups, integrations, saturation\nlevels, and observation time estimates for target acquisition and\nscience observations with JWST.\n\nAuthors\n-------\n\n Jules Fowler, April 2017\n Matthew Bourque, February 2021\n\nUse\n---\n\n This is mostly a module to be used by the ExoCTK web application,\n but the main function can be run standalone as such:\n ::\n\n from exoctk.groups_integrations.groups_integrations import perform_calculation\n perform_calculation()\n\nDependencies\n------------\n\n - ``astropy``\n - ``numpy``\n - ``scipy``\n\"\"\"\n\nimport json\nimport math\n\nimport numpy as np\nfrom scipy import interpolate\n\n\ndef calc_duration_time(num_groups, num_integrations, num_reset_frames, frame_time, frames_per_group=1):\n \"\"\"Calculates duration time (or exposure duration as told by APT)\n\n Parameters\n ----------\n num_groups : int\n Groups per integration\n num_integrations : int\n Integrations per exposure\n num_reset_frames : int\n Reset frames per integration\n frame_time : float\n Frame time (in seconds)\n frames_per_group : int, optional\n Frames per group -- always one except brown dwarves\n\n Returns\n -------\n duration_time : float\n Duration time (in seconds).\n \"\"\"\n\n duration_time = frame_time * (num_groups * frames_per_group + num_reset_frames) * num_integrations\n\n return duration_time\n\n\ndef calc_exposure_time(num_integrations, ramp_time):\n \"\"\"Calculates exposure time (or photon collection duration as told\n by APT.)\n\n Parameters\n ----------\n num_integrations : int\n Integrations per exposure.\n ramp_time : float\n Ramp time (in seconds).\n\n Returns\n -------\n exposure_time : float\n Exposure time (in seconds).\n \"\"\"\n\n exposure_time = num_integrations * ramp_time\n\n return exposure_time\n\n\ndef calc_frame_time(num_columns, num_rows, num_amps, instrument):\n \"\"\"Calculates the frame time for a given\n instrument/readmode/subarray.\n\n Parameters\n ----------\n num_columns : int\n Number of columns\n num_rows : int\n Number of rows\n num_amps : int\n Amplifiers reading data\n instrument : str\n The instrument\n\n Returns\n -------\n frame_time : float\n The frame time (in seconds)\n \"\"\"\n\n num_columns, num_amps, num_rows = int(num_columns), int(num_amps), int(num_rows)\n\n if instrument == 'nirspec':\n n = 2\n if instrument in ['nircam', 'niriss']:\n n = 1\n\n frame_time = (num_columns / num_amps + 12) * (num_rows + n) * (1e-5)\n\n return frame_time\n\n\ndef calc_groups_from_exp_time(max_exptime_per_int, frame_time):\n \"\"\"Given the maximum saturation time, calculates the number of\n frames per group.\n\n Parameters\n ----------\n max_exptime_per_int : float\n The maximum number of seconds an integration can last before\n it's oversaturated\n frame_time : float\n The time per frame\n\n Returns\n -------\n groups : int\n The required number of groups.\n \"\"\"\n\n groups = np.floor(max_exptime_per_int / frame_time)\n\n return groups\n\n\ndef calc_integration_time(num_groups, frame_time, frames_per_group, num_skips):\n \"\"\"Calculates the integration time.\n\n Parameters\n ----------\n num_groups : int\n Groups per integration.]\n frame_time : float\n Frame time (in seconds)\n frames_per_group : int\n Frames per group -- always 1 except maybe brown dwarves\n num_skips : int\n Skips per integration -- always 0 except maybe brown dwarves\n\n Returns\n -------\n integration_time : float\n Integration time (in seconds)\n \"\"\"\n\n integration_time = (num_groups * (frames_per_group + num_skips) - num_skips) * frame_time\n\n return integration_time\n\n\ndef calc_num_integrations(transit_time, num_groups, num_reset_frames, frame_time, frames_per_group):\n \"\"\"Calculates number of integrations required.\n\n Parameters\n ----------\n transit_time : float\n The time of the transit (in hours)\n num_groups : int\n Groups per integration\n num_reset_frames : int\n Number of reset frames per integration\n frame_time : float\n The frame time (in seconds)\n frames_per_group : int\n Frames per group -- always 1 except maybe for brown dwarves\n\n Returns\n -------\n num_integrations : float\n The required number of integraitions.\n \"\"\"\n\n num_integrations = math.ceil((float(transit_time) * 3600) / (frame_time * (num_groups * frames_per_group + num_reset_frames)))\n\n return num_integrations\n\n\ndef calc_observation_efficiency(exposure_time, duration_time):\n \"\"\"Calculates the observation efficiency.\n\n Parameters\n ----------\n exposure_time : float\n Exposure time (in seconds).\n duration_time : float\n Duration time (in seconds).\n\n Returns\n -------\n observation_efficiency : float\n Observation efficiency.\n \"\"\"\n\n observation_efficiency = exposure_time / duration_time\n\n return observation_efficiency\n\n\ndef calc_ramp_time(integration_time, num_reset_frames, frame_time):\n \"\"\"Calculates the ramp time -- or the integration time plus overhead\n for resets.\n\n Parameters\n ----------\n integration_time : float\n Integration time (in seconds)\n num_reset_frames : int\n Rest frames per integration\n frame_time : float\n Frame time (in seconds)\n\n Returns\n -------\n ramp_time : float\n Ramp time (in seconds).\n \"\"\"\n\n ramp_time = integration_time + (num_reset_frames - 1) * frame_time\n\n return ramp_time\n\n\ndef convert_saturation(max_saturation, saturation_mode, instrument, infile, target_acq_mode=False):\n \"\"\"Converts full well fraction to a saturation in counts OR\n provides the max fullwell for TA mode.\n\n Parameters\n ----------\n max_saturation : float\n Either a full well fraction or counts\n saturation_mode : str\n ``well`` or ``counts``\n instrument : str\n The instrument\n infile : str\n The path to the data file\n target_acq_mode : bool, optional\n Whether or not it's TA mode\n\n Returns\n -------\n max_saturation : float\n The fullwell to use in counts.\n \"\"\"\n\n with open(infile) as f:\n data = json.load(f)\n\n instrument_dict = data['fullwell']\n\n if saturation_mode == 'well':\n max_saturation = float(max_saturation) * float(instrument_dict[instrument])\n\n if target_acq_mode:\n max_saturation = instrument_dict[instrument]\n\n return max_saturation\n\n\ndef interpolate_from_pandeia(magnitude, instrument, filt, subarray, model, band, frame_time, saturation_level, infile, target_acq_mode=False):\n \"\"\"Interpolates the precalculated ``pandeia`` data to estimate the\n saturation limit.\n\n Parameters\n ----------\n magnitude : float\n The magnitude of the source. (Takes between 4.5-12.5)\n instrument : str\n The instrument, allowable ``miri``, ``niriss``, ``nirspec``,\n ``nircam``\n filt : str\n The filter\n subarray : str\n The subarray\n model : str\n Phoenix model key\n band : str\n Magnitude band\n frame_time : float\n Frame time\n saturation_level : float\n The maximum fullwell saturation we'll allow\n infile : str\n The data file to use\n target_acq_mode : bool, optional\n Whether or not we're running this for TA\n\n Returns\n -------\n num_groups : int\n The number of groups that won't oversaturate the detector\n max_sat : int\n The maximum saturation level reached by that number of groups\n \"\"\"\n\n # Create the dictionaries for each filter and select out the prerun data\n with open(infile) as f:\n data = json.load(f)\n\n ta_or_sci = 'sci_sat'\n\n if target_acq_mode:\n ta_or_sci = 'ta_sat'\n\n # The data\n magnitudes = np.array(data['mags'])\n saturation = data[ta_or_sci][instrument][filt][subarray][model]\n log_saturation = np.log10(saturation)\n\n # Interpolate the given magnitude\n func_log = interpolate.interp1d(magnitudes, log_saturation)\n max_log_saturation = func_log(float(magnitude))\n max_saturation = 10**(max_log_saturation)\n\n # Figure out what it means in wake of the given saturation lvl\n max_exptime = float(saturation_level) / max_saturation\n\n # Calculate the nearest number of groups\n num_groups = calc_groups_from_exp_time(max_exptime, frame_time)\n\n # Can't have zero groups\n num_groups = num_groups or 1\n\n return num_groups, max_saturation\n\n\ndef map_to_ta_modes(instrument, max_num_groups, min_num_groups):\n \"\"\"Turns the min/max groups into the closest allowable TA group\n mode.\n\n Parameters\n ----------\n instrument : str\n The instrument\n max_num_groups : int\n The maximum number of groups without oversaturating\n min_num_groups : int\n The groups needed to hit the target SNR\n\n Returns\n -------\n min_ta_groups : int\n The min possible groups to hit target SNR\n max_ta_groups : int\n The max possible groups before saturation\n \"\"\"\n\n # Allowable group modes for each instrument\n groups = {'miri': [3, 5, 9, 15, 23, 33, 45, 59, 75, 93, 113, 135, 159, 185, 243, 275, 513],\n 'niriss': [3, 5, 7, 9, 1, 13, 15, 17, 19],\n 'nirspec': [3],\n 'nircam': [3, 5, 9, 17, 33, 65]}\n\n # Match the literal min and max groups to the nearest mode.\n allowable_groups = groups[instrument]\n min_ta_groups = min(allowable_groups, key=lambda x: abs(x - min_num_groups))\n max_ta_groups = min(allowable_groups, key=lambda x: abs(x - max_num_groups))\n\n # Unless it was oversaturated from the get-go OR there aren't enough groups\n # for SNR\n if min_num_groups == 0:\n min_ta_groups = 0\n max_ta_groups = 0\n if min_num_groups > max(allowable_groups):\n min_ta_groups = -1\n max_ta_groups = 0\n\n return max_ta_groups, min_ta_groups\n\n\ndef min_num_groups_for_sat(magnitude, instrument, filt, subarray, model, band, infile):\n \"\"\"Estimates the minimum number of groups to reach target acq\n saturation requirements.\n\n Parameters\n ----------\n magnitude : float\n Magnitude of star.\n instrument : str\n Instrument.\n filt : str\n Filter.\n subarray : str\n Subarray.\n model : str\n Phoenix model key.\n band : str, currently unused?\n The band -- right now only k sooo?\n infile : str\n The file with the pandeia data.\n\n Returns\n -------\n min_num_groups_for_sat : int\n The minimum number of groups to reach target snr.\n \"\"\"\n\n with open(infile) as f:\n data = json.load(f)\n\n # Match to closest magnitude\n magnitudes = [float(i) for i in data['mags']]\n closest_magnitude = min(magnitudes, key=lambda x: abs(x - float(magnitude)))\n index = magnitudes.index(closest_magnitude)\n\n # Match to data\n minimum_num_groups_for_sat = data['ta_snr'][instrument][filt][subarray][model][index]\n\n return minimum_num_groups_for_sat\n\n\ndef perform_calculation(params, frames_per_group=1, num_skips=0):\n \"\"\"Calculates all of the outputs and puts them in a dictionary for\n easy access.\n\n Parameters\n ----------\n params : dict\n Dictionary of all the needed parameters. Must include:\n ``obs_time``, ``n_group``, ``mag``, ``mod``, ``band``,\n ``filt``, ``filt_ta``, ``ins``, ``subarray``, ``subarray_ta``,\n ``sat_mode``, ``max_sat``, ``infile``\n frames_per_group : int, optional\n The number of frames -- almost always 1\n num_skips: int, optional\n Number of skips -- almost always 0\n\n Returns\n -------\n params : dict, str\n Dictionary of outputs and inputs. If the calculation throws an\n error it will return a string error message instead\n \"\"\"\n\n # TARGET ACQ\n ta_frame_time = set_frame_time(\n params['infile'], params['ins'], params['subarray_ta'], target_acq_mode=True)\n\n max_saturation_ta_level = convert_saturation(\n params['sat_max'], params['sat_mode'], params['ins'], params['infile'], target_acq_mode=True)\n\n max_num_groups, saturation_rate_ta = interpolate_from_pandeia(\n params['mag'], params['ins'], params['filt_ta'], params['subarray_ta'], params['mod'], params['band'],\n ta_frame_time, max_saturation_ta_level, params['infile'], target_acq_mode=True)\n\n min_num_groups = min_num_groups_for_sat(\n params['mag'], params['ins'], params['filt_ta'], params['subarray_ta'], params['mod'], params['band'], params['infile'])\n\n min_ta_groups, max_ta_groups = map_to_ta_modes(params['ins'], max_num_groups, min_num_groups)\n\n duration_time_ta_min = calc_duration_time(min_ta_groups, 1, 1, ta_frame_time)\n\n duration_time_ta_max = calc_duration_time(max_ta_groups, 1, 1, ta_frame_time)\n\n # Science obs\n # Figure out the rows/cols/amps/pixel_size and saturation\n instrument_params = set_params_from_instrument(params['ins'], params['subarray'])\n frame_time = set_frame_time(params['infile'], params['ins'], params['subarray'])\n\n # Run all the calculations\n num_rows, num_columns, num_amps, pixel_size, frame_time, num_reset_frames = instrument_params\n params['sat_max'] = convert_saturation(params['sat_max'], params['sat_mode'], params['ins'], params['infile'])\n\n # Calculate countrate and n_groups if it isn't supplied\n num_groups, saturation_rate = interpolate_from_pandeia(\n params['mag'], params['ins'], params['filt'], params['subarray'], params['mod'], params['band'],\n frame_time, params['sat_max'], params['infile'])\n if str(params['n_group']) == 'optimize':\n params['n_group'] = int(num_groups)\n else:\n params['n_group'] = int(float(params['n_group']))\n\n # Aditional helpful params\n # Calculate times/ramps/etc\n integration_time = calc_integration_time(params['n_group'], frame_time, frames_per_group, num_skips)\n ramp_time = calc_ramp_time(integration_time, num_reset_frames, frame_time)\n\n # Calculate nubmer of integrations (THE MEAT)\n num_integrations = calc_num_integrations(params['obs_time'], params['n_group'], num_reset_frames, frame_time, frames_per_group)\n\n # Other things that may come in handy who knows?\n exposure_time = calc_exposure_time(num_integrations, ramp_time)\n duration_time = calc_duration_time(params['n_group'], num_integrations, num_reset_frames, frame_time, frames_per_group)\n observation_efficiency = calc_observation_efficiency(exposure_time, duration_time)\n\n # Update params with new information\n params['duration_time'] = round(duration_time / 3600, 3)\n params['duration_time_ta_max'] = duration_time_ta_max\n params['duration_time_ta_min'] = duration_time_ta_min\n params['exposure_time'] = round(exposure_time / 3600, 3)\n params['frames_per_group'] = frames_per_group\n params['frame_time'] = round(frame_time, 3)\n params['integration_time'] = round(integration_time, 3)\n params['max_saturation_prediction'] = round(saturation_rate * frame_time * params['n_group'], 3)\n params['max_saturation_ta'] = round(saturation_rate_ta * ta_frame_time * max_ta_groups, 3)\n params['min_saturation_ta'] = round(saturation_rate_ta * ta_frame_time * min_ta_groups, 3)\n params['max_ta_groups'] = int(max_ta_groups)\n params['min_ta_groups'] = int(min_ta_groups)\n params['num_amps'] = num_amps\n params['num_columns'] = num_columns\n params['num_integrations'] = num_integrations\n params['num_reset_frames'] = num_reset_frames\n params['num_rows'] = num_rows\n params['num_skips'] = num_skips\n params['observation_efficiency'] = round(observation_efficiency, 3)\n params['ramp_time'] = round(ramp_time, 3)\n params['ta_frame_time'] = ta_frame_time\n\n return params\n\n\ndef set_params_from_instrument(instrument, subarray):\n \"\"\"Sets/collects the running parameters from the instrument.\n\n Parameters\n ----------\n instrument : str\n Instrument, options are ``nircam``, ``niriss``, ``nirpec``, and\n ``miri``\n subarray : str\n Subarray mode\n\n Returns\n -------\n rows : int\n The number of pixels per row.\n cols : int\n The number of columns per row.\n amps : int\n The number of amplifiers.\n pixel_size : int\n The pixel size.\n frame_time : float\n The frame time.\n num_reset_frames : int\n The number of reset frames.\n \"\"\"\n\n num_reset_frames = 1\n\n if instrument == 'nirspec':\n\n pixel_size = (40e-4)**2\n if subarray == 'sub2048':\n rows, cols = 2048, 32\n elif subarray in ['sub1024a', 'sub1024b']:\n rows, cols = 1024, 32\n elif subarray == 'sub512':\n rows, cols = 512, 32\n amps = 1 # 4 if not NRSRAPID????\n frame_time = calc_frame_time(cols, rows, amps, instrument)\n\n elif instrument == 'nircam':\n\n pixel_size = (18e-4)**2\n if subarray == 'full':\n rows, cols, amps = 2048, 2048, 4\n elif subarray == 'subgrism256':\n rows, cols, amps = 256, 256, 1\n elif subarray == 'subgrism128':\n rows, cols, amps = 128, 2048, 1\n elif subarray == 'subgrism64':\n rows, cols, amps = 64, 2048, 1\n frame_time = calc_frame_time(cols, rows, amps, instrument)\n\n elif instrument == 'miri':\n\n pixel_size = (25e-4)**2\n if subarray == 'slitlessprism':\n rows, cols, frame_time = 416, 72, .159\n amps = 4\n num_reset_frames = 0\n\n elif instrument == 'niriss':\n pixel_size = (40e-4)**2\n if subarray == 'substrip96':\n rows, cols = 2048, 96\n elif subarray == 'substrip256':\n rows, cols = 2048, 256\n amps = 1\n frame_time = calc_frame_time(cols, rows, amps, instrument)\n\n return rows, cols, amps, pixel_size, frame_time, num_reset_frames\n\n\ndef set_frame_time(infile, instrument, subarray, target_acq_mode=False):\n \"\"\"Assign the appropriate frame time based on the instrument and\n subarray. For now, modes are implied.\n\n Parameters\n ----------\n infile: str\n The path to the data file.\n instrument : str\n The instrument : ``miri``, ``niriss``, ``nirspec``, or\n ``nircam``\n subarray : str\n The subarray\n target_acq_mode : bool\n Whether this is for TA or not.\n\n Returns\n -------\n frame_time : float\n The frame time for this instrument/subarray combo.\n \"\"\"\n\n # Read in dict with frame times\n with open(infile) as f:\n frame_time = json.load(f)['frame_time']\n\n if target_acq_mode:\n frame_time = frame_time[instrument]['ta'][subarray]\n else:\n frame_time = frame_time[instrument][subarray]\n\n return frame_time\n", "meta": {"hexsha": "e200ffed8bea0151e3add9c4e6c62127ea97a44c", "size": 19320, "ext": "py", "lang": "Python", "max_stars_repo_path": "exoctk/groups_integrations/groups_integrations.py", "max_stars_repo_name": "nespinoza/exoctk", "max_stars_repo_head_hexsha": "bb50f592c1143195ee20b4a838ce39c0522d3216", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 21, "max_stars_repo_stars_event_min_datetime": "2018-10-28T09:44:30.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T18:33:16.000Z", "max_issues_repo_path": "exoctk/groups_integrations/groups_integrations.py", "max_issues_repo_name": "nespinoza/exoctk", "max_issues_repo_head_hexsha": "bb50f592c1143195ee20b4a838ce39c0522d3216", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 358, "max_issues_repo_issues_event_min_datetime": "2018-10-19T19:02:21.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-22T19:15:34.000Z", "max_forks_repo_path": "exoctk/groups_integrations/groups_integrations.py", "max_forks_repo_name": "nespinoza/exoctk", "max_forks_repo_head_hexsha": "bb50f592c1143195ee20b4a838ce39c0522d3216", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2018-11-13T16:47:07.000Z", "max_forks_repo_forks_event_max_datetime": "2020-08-18T18:37:19.000Z", "avg_line_length": 30.1875, "max_line_length": 142, "alphanum_fraction": 0.6570393375, "include": true, "reason": "import numpy,from scipy", "num_tokens": 4772, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7090191337850933, "lm_q2_score": 0.27512972382317524, "lm_q1q2_score": 0.19507223846363966}} {"text": "#cython: profile=True,boundscheck=False\n\nfrom lattice_extension import validate_rxn as validate_rxn\nfrom lattice_extension import propensity as rxn_propensity\nfrom lattice_extension import update_propensities as agents_propensity\nfrom lattice_extension import update_agents_react_prop\nfrom lattice_extension import choose_biased_index as cbindex\nfrom lattice_extension import pick_agent_to_act as pick_agent\n\nfrom math import log\nimport numpy as np\nimport itertools as it\nimport time as ti\n\nimport random as rm\n\nimport modular_core.libprofile as lprf\n\nimport pdb\n\ndef set_state(state, surface_state, time, latt):\n state[0] = time\n state[1] = latt.agent_count\n state[2] = np.mean(surface_state[0])\n #state[1] = latt.total_population()\n #state[2:] = spectrum_population(\n # latt.spec_count, latt.agent_count, \n # latt.species_index_dict, latt.agents)\n state[3:] = latt.spectrum_population()\n\ndef set_surface_state(surf_state, time, latt):\n surf_state[0] = latt.population_grid()\n surf_state[1] = latt.identity_grid()\n if latt.has_resources:\n surf_state[2:] = latt.spectrum_resource_grid()\n\ndef capture(data, state, capture_dex, target_dexes):\n data[:,capture_dex] = [state[dex] for dex in target_dexes]\n\nclass agent(object):\n\n def __init__(self, variety, motion_prop = 0.0, react_prop = 0.0):\n self.variety = variety\n self.motion_prop = motion_prop\n self.react_prop = react_prop\n self.total_prop = self.react_prop + self.motion_prop\n self.behaviors = [self.move, self.react]\n\n def move_to(self, pos, lattice):\n site = lattice._lattice_[self.pos]\n site.agents.remove(self)\n newpopulace = site.populace.replace(self.variety, '', 1)\n site.populace = newpopulace\n site.population = len(newpopulace)\n site.who = site.identity()\n lattice.flagged_locs.append(self.pos)\n\n self.pos = pos\n newsite = lattice._lattice_[pos]\n newsite.agents.append(self)\n newsite.populace += self.variety\n newsite.population = len(newsite.populace)\n newsite.who = newsite.identity()\n lattice.flagged_locs.append(pos)\n\n def act(self, lattice):\n prtot = self.total_prop\n if prtot > 0.0:\n #normed = [self.motion_prop/prtot, self.react_prop/prtot]\n #behvs = [normed[0], normed[0] + normed[1]]\n #rd = rm.random()\n #if behvs[0] > rd:\n # self.move(lattice)\n #elif behvs[1] > rd:\n # self.react(lattice)\n #else: pdb.set_trace()\n behvs = [self.motion_prop, self.react_prop]\n behv = cbindex(behvs,2)\n self.behaviors[behv](lattice)\n else: print 'PASSING!'\n\n def move(self, lattice):\n new_pos = lattice._lattice_[self.pos].diffuse_pressure()\n #new_pos = lattice._lattice_[self.pos].diffuse_random()\n self.move_to(new_pos, lattice)\n\n def react(self, lattice):\n site = lattice._lattice_[self.pos]\n populace = site.populace\n resources = site.resources\n valid = [rx for rx in lattice.reactions\t\n if validate_rxn(rx.used, populace, resources)]\n rxn_props = [rxn_propensity(\n rx.used, populace, rx.rate) \n for rx in valid]\n rxdex = pick_rxn(rxn_props)\n rxn = valid[rxdex]\n rxn.react(site, lattice)\n lattice.flagged_locs.append(self.pos)\n\n def update_propensity(self, lattice):\n lattice.total_agent_propensity -= self.total_prop\n self.update_react_prop(lattice)\n self.update_motion_prop(lattice)\n self.total_prop = self.react_prop + self.motion_prop\n lattice.total_agent_propensity += self.total_prop\n\n def update_react_prop(self, lattice):\n site = lattice._lattice_[self.pos]\n rxns = lattice.reactions\n self.react_prop = update_agents_react_prop(\n site, rxns, lattice.reaction_count)\n\n def update_motion_prop(self, lattice): \n self.motion_prop = lattice._lattice_[\n self.pos].population**lattice.dimensions\n\nclass agent_immobile(agent):\n\n def move_to(self, pos, lattice):\n print 'immobile should not be asked to move!'\n\n def act(self, lattice):\n self.react(lattice)\n\n def update_propensity(self, lattice):\n lattice.total_agent_propensity -= self.total_prop\n self.update_react_prop(lattice)\n self.total_prop = self.react_prop\n lattice.total_agent_propensity += self.total_prop\n\n def update_motion_prop(self, lattice): \n print 'immobile agent should not be asked up update motion_prop!!'\n self.motion_prop = 0.0\n\ndef pick_rxn(rxn_props):\n table = []\n ptot = sum(rxn_props)\n rd = rm.uniform(0.0, ptot)\n for p in rxn_props: table.append(sum(table) + p)\n for tx, t in enumerate(table):\n if rd < t: return tx\n\nclass reaction(object):\n\n def __init__(self, rxn, specs):\n def convert(ag):\n stoch = int(ag[ag.find('(')+1:ag.find(')')])\n spec = ag[ag.find(')')+1:]\n isresource = not spec in specs\n return (stoch, spec, isresource)\n self.rxnstr = rxn\n rxnspl = rxn.split('->')\n front = rxnspl[0]\n self.rate = float(front[front.find('[')+1:front.find(']')])\n used, prod = front[:front.find('[')], rxnspl[1]\n if not used == '': used = used.split('+')\n else: used = []\n if not prod == '': prod = prod.split('+')\n else: prod = []\n self.used = [convert(us) for us in used]\n self.prod = [convert(pr) for pr in prod]\n self.flux = len(self.prod) - len(self.used)\n\n def react(self, site, lattice):\n pop = site.populace[:]\n resources = site.resources\n res_varis = [res.variety for res in resources]\n for u in self.used:\n if u[2]:\n rdex = res_varis.index(u[1])\n resource = resources[rdex]\n resource.quantity -= u[0]\n else: pop = pop.replace(u[1], '', u[0])\n for p in self.prod:\n if p[2]:\n rdex = res_varis.index(p[1])\n resource = resources[rdex]\n resource.quantity += p[0]\n else: pop += p[1]*p[0]\n site.resolve_agents(lattice, pop)\n\nclass site_resource(object):\n def __init__(self, pos, quantity = 1, variety = 'food'):\n self.variety = variety\n self.quantity = quantity\n\n#site_topology instances describe the connectivity of an N\n# dimensional lattice site to its neighboring sites\nclass site_topology(object):\n def __init__(self, pos, lshape, max_occupancy = None):\n self.pos = pos\n self.lshape = lshape\n self.dims = len(pos)\n self.max_occupancy = max_occupancy\n self.set_step_positions()\n\n def set_step_positions(self):\n pos = self.pos\n self.dn_steps = [list(pos[:]) for x in range(self.dims)]\n self.up_steps = [list(pos[:]) for x in range(self.dims)]\n axlen = self.lshape[0]\n for d in range(self.dims):\n if pos[d] == 0:\n dstep = 1 - axlen\n ustep = 1\n elif pos[d] == axlen - 1:\n dstep = 1\n ustep = 1 - axlen\n else:\n dstep = 1\n ustep = 1\n\n self.dn_steps[d][d] -= dstep\n self.up_steps[d][d] += ustep\n\n self.up_steps = [tuple(x) for x in self.up_steps]\n self.dn_steps = [tuple(x) for x in self.dn_steps]\n self.all_steps = self.up_steps + self.dn_steps\n self.neighbor_count = len(self.all_steps)\n\n def step(self, axdex, dir_):\n if dir_: new = self.up_steps[axdex]\n else: new = self.dn_steps[axdex]\n return new\n\nclass lattice_site(object):\n\n def __init__(self, args, pop = ''):\n self.position = args[0]\n self.lshape = args[1]\n self.species = args[2].species\n self.resources = args[3]\n #self.resources = [site_resource(self.position)]\n self.resource_names = [r.variety for r in self.resources]\n self.dims = len(self.position)\n self.agents = []\n self.populace = pop\n self.population = len(pop)\n self.who = self.identity()\n self.lattice = args[2]\n max_occupancy = args[2].max_occupancy\n self.topology = site_topology(\n self.position, self.lshape, max_occupancy)\n \n def resolve_agents(self, lattice, pop):\n local_ags = [ag for ag in self.agents if not ag.variety == '_']\n #local_ags = [ag for ag in lattice.agents if ag.pos == self.position]\n local_pop = [ag.variety for ag in local_ags]\n left = []\n for ag in local_ags:\n if ag.variety in pop: pop = pop.replace(ag.variety, '', 1)\n else: left.append(ag)\n\n for p in pop: lattice.put_onto_lattice_at_site(self.position, agent(p))\n for p in left: lattice.remove_from_lattice_site(self.position, p)\n\n def diffuse_pressure(self):\n adjacents = self.topology.all_steps\n ncnt = self.topology.neighbor_count\n latt = self.lattice._lattice_\n adjac_pops = [latt[pos].population for pos in adjacents]\n max_po = max(adjac_pops)\n adjac_pops = [-1.0*po + max_po for po in adjac_pops]\n lookup = cbindex(adjac_pops, ncnt)\n step = adjacents[lookup]\n return step\n\n def diffuse_random(self):\n step_dim = rm.randrange(self.dims)\n dir_ = rm.random() > 0.5\n step = self.topology.step(step_dim, dir_)\n return step\n\n def identity(self):\n if not self.populace: return 0\n for sdx in range(len(self.species)):\n sp = self.species[sdx]\n if sp in self.populace: return sdx + 1\n return 0\n\n def what(self, resource_dex):\n res = self.resources[resource_dex]\n return res.quantity\n\nclass lattice(object):\n\n def __init__(self, *args, **kwargs):\n if 'dims' in kwargs.keys(): dims = kwargs['dims']\n else: dims = 2\n if 'ax_length' in kwargs.keys(): ax_length = kwargs['ax_length']\n else: ax_length = 5\n if 'species' in kwargs.keys(): specs = kwargs['species']\n else: specs = []\n if 'reactions' in kwargs.keys(): rxns = kwargs['reactions']\n else: rxns = []\n if 'birthing_flag' in kwargs.keys(): bflag = kwargs['birthing_flag']\n else: bflag = False\n if 'max_occupancy' in kwargs.keys():\n max_occupancy = kwargs['max_occupancy']\n else: max_occupancy = None\n if 'resources' in kwargs.keys(): ress = kwargs['resources']\n else: ress = []\n self.agents = []\n self.agent_count = 0\n self.species = specs\n self.spec_count = len(specs)\n self.total_agent_propensity = 0\n self.agents_propensities = []\n #spdxdict = {}\n #for sdx in xrange(self.spec_count):\n # spec = self.species[sdx]\n # spdxdict[spec] = sdx\n #self.species_index_dict = spdxdict\n self.species_spectrum = {}\n for ke in self.species: self.species_spectrum[ke] = 0\n self.reactions = [reaction(rx, specs) for rx in rxns]\n self.reaction_count = len(rxns)\n #self.birth_reactions =\\\n # [rx for rdx, rx in enumerate(self.reactions) if rdx in brxns]\n self.birth_flag = bflag\n self.max_occupancy = max_occupancy\n self.resources = ress\n if len(ress) == 0: self.has_resources = False\n else: self.has_resources = True\n self.make_lattice(dims, ax_length, ress)\n\n def make_lattice(self, dims, maxax, ress):\n #must add ress contents here; right now its hardcoded\n self.dimensions = dims\n self.max_axis_size = maxax\n v_site = np.vectorize(lattice_site)\n init_arry = np.empty((maxax,)*dims,dtype = object)\n self.locs = [x for x in it.product(*[range(maxax)]*dims)]\n lattice = np.empty((maxax,)*dims,dtype = object)\n shp = lattice.shape\n for pos in self.locs:\n res = []\n for re in ress:\n if re[0] == 'all' or re[0].count(pos) > 0:\n res.append(site_resource(pos, re[2], re[1]))\n init_arry[pos] = (pos, shp, self, res)\n lattice[:] = v_site(init_arry)\n self._lattice_ = lattice\n self.flagged_locs = []\n if self.birth_flag:\n for pos in self.locs:\n bagent = agent_immobile('_')\n self.put_onto_lattice_at_site(pos, bagent)\n self.flagged_locs.append(pos)\n\n def put_onto_lattice_at_site(self, pos, agent):\n self.agents.append(agent)\n if pos == 'random':pos = rm.choice(self.locs)\n agent.pos = pos\n site = self._lattice_[pos]\n site.agents.append(agent)\n if not agent.variety == '_':\n self.species_spectrum[agent.variety] += 1\n site.populace += agent.variety\n self.agent_count += 1\n site.population = len(site.populace)\n site.who = site.identity()\n\n def remove_from_lattice_site(self, pos, agent):\n self.species_spectrum[agent.variety] -= 1\n site = self._lattice_[pos]\n site.populace = site.populace.replace(agent.variety, '', 1)\n site.population = len(site.populace)\n site.who = site.identity()\n site.agents.remove(agent)\n self.agents.remove(agent)\n self.agent_count -= 1\n\n def total_propensity(self):\n return self.total_agent_propensity\n\n def act_agent(self, agdex):\n agent = self.agents[agdex]\n agent.act(self)\n\n def get_clean_fixed_surf(self):\n def fix(d):\n if d in relev: return slice(None)\n else: return fixins[d]\n fixins = [0 for d in range(self.dimensions)]\n relev = [0,1]\n fixed = [fix(d) for d in range(len(fixins))]\n maxax = self.max_axis_size\n surf = np.zeros((maxax, maxax), dtype = np.int)\n return surf, fixed\n\n def population_grid(self):\n surf, fixed = self.get_clean_fixed_surf()\n surf[:,:] = [[sit.population for sit in ax] \n for ax in self._lattice_[fixed]]\n return surf\n\n def identity_grid(self):\n surf, fixed = self.get_clean_fixed_surf()\n surf[:,:] = [[sit.who for sit in ax] \n for ax in self._lattice_[fixed]]\n return surf\n\n def spectrum_population(self):\n spectrum = [0]*self.spec_count\n for sdx in xrange(self.spec_count):\n sp = self.species[sdx]\n spectrum[sdx] = self.species_spectrum[sp]\n return spectrum\n\n def spectrum_resource_grid(self):\n def resource_grid(res):\n surf, fixed = self.get_clean_fixed_surf()\n surf[:,:] = [[sit.what(res) for sit in ax] \n for ax in self._lattice_[fixed]]\n return surf\n grids = []\n #for res in self.resources:\n for rsdx in range(len(self.resources)):\n grids.append(resource_grid(rsdx))\n return grids\n\ndef_string = ''\ndef simulate(sys_string = def_string):\n species = ['A', 'B', 'C']\n #agents = [\n # ((1,3),'A'),((4,3),'B'),((8,7),'C'), \n # ((95,7),'A'),((84,9),'B'),((88,2),'C'), \n # ((93,83),'A'),((84,93),'B'),((88,87),'C'), \n # ((2,93),'A'),((6,83),'B'),((4,97),'C'), \n # ]\n agents =\\\n [('random', 'A')]*3333 +\\\n [('random', 'B')]*3333 +\\\n [('random', 'C')]*3333 \n reactions = [\n #'(1)A+(1)food[5.0]->(2)A', \n #'(1)B+(1)food[5.0]->(2)B', \n #'(1)C+(1)food[5.0]->(2)C', \n '(1)A+(1)B[5.0]->(2)A', \n '(1)B+(1)C[5.0]->(2)B', \n '(1)C+(1)A[5.0]->(2)C', \n #'(1)A[0.01]->', \n #'(1)B[0.01]->', \n #'(1)C[0.01]->', \n #'[0.01]->(1)A', \n #'[0.01]->(1)B', \n #'[0.01]->(1)C', \n ]\n #birthing_rxns = [6]\n birthing_flag = False#True\n resources = []#[('all', 'food', 3)]\n lattice_dims = 2\n lattice_size = 100\n max_occupancy = 2\n timed_out = False\n timed_out_limit = 3600.0\n\n # I TREAT AGENTS AT EACH LATTICE SITE AS INDISTINGUISHABLE\n # BUT THE LOCAL AGENTS ARE REMOVED IN REVERSE ORDER OF ENTERING THE SITE\n ### to properly include birth reactions - treat lattice sites as agents\n ### with zero motion propensity\n # still want occupancy handling\n # species can only have a single letter to identify\n # voxel visualization pipeline for 3-d subspaces (perfectly analogous to\n # surface_data pipeline)\n # statistics on average agent (average agent trajectory really....)\n # add full function/variable pipeline for reactions\n # add full mcfg/sys_string pipeline\n # introduce concept of nations (groups of agents)\n # i double count propensities since which agent initiates a reaction\n # is never relevant - only the variety of agents post reaction\n\n time = 0.0\n last_time = 0.0\n end_time = 50.0\n incr_time = 0.1\n\n total_captures = end_time/incr_time\n capture_count = 0 \n res_names = [r[1] for r in resources]\n targets = ['time', 'population', 'mean_occupancy'] + species[:]# + res_names\n plot_targets = ['time', 'population', 'mean_occupancy'] + species[:]# + res_names\n surf_targets = [\n 'population_surfaces', \n 'identity_surfaces'] + ['resource_surface_' + r for r in res_names]\n plot_surf_targets = [\n 'population_surfaces', \n 'identity_surfaces'] + ['resource_surface_' + r for r in res_names] \n #voxel_targets = ['identity_voxels']\n #plot_voxel_targets = ['identity_voxels']\n target_dexes = [targets.index(ta) for ta in plot_targets]\n surf_target_dexes = [surf_targets.index(ta) for ta in plot_surf_targets]\n #voxel_target_dexes = [voxel_targets.index(ta) for ta in plot_voxel_targets]\n _lattice_ = lattice(\n dims = lattice_dims, ax_length = lattice_size, species = species, \n reactions = reactions, max_occupancy = max_occupancy, \n birthing_flag = birthing_flag, resources = resources)\n for ag in agents: _lattice_.put_onto_lattice_at_site(ag[0],agent(ag[1]))\n for ag in _lattice_.agents: ag.update_propensity(_lattice_)\n maxax = _lattice_.max_axis_size\n state = np.zeros(shape = (len(targets)), dtype = np.float)\n surface_state = np.zeros(shape=(len(surf_targets),maxax,maxax),dtype=np.float)\n #voxel_state = np.zeros(shape=(len(voxel_targets),maxax,maxax,maxax),dtype=np.float)\n data = np.zeros(shape=(len(plot_targets),total_captures),dtype=np.float)\n surface_data = np.zeros(shape = (len(surf_targets), \n \ttotal_captures, maxax, maxax), dtype = np.float)\n #voxel_data = np.zeros(shape = (len(voxel_targets), \n #\ttotal_captures, maxax, maxax, maxax), dtype = np.float)\n #set_voxel_state(voxel_state, time, _lattice_)\n set_surface_state(surface_state, time, _lattice_)\n set_state(state, surface_state, time, _lattice_)\n\n start_time = ti.time()\n if birthing_flag: dead_eco_check = lambda : False\n else: dead_eco_check = lambda : not _lattice_.agent_count > 0\n dead_eco = dead_eco_check()\n while capture_count < total_captures and not dead_eco and not timed_out:\n propensity_total = _lattice_.total_propensity()\n if propensity_total > 0.0 and _lattice_.agent_count > 0:\n propensity_total_inv = 1.0/propensity_total\n time_step = -1.0 * log(rm.random()) * propensity_total_inv\n acnt = len(_lattice_.agents)\n agrand = rm.uniform(0.0, propensity_total)\n agent_dex = pick_agent(_lattice_.agents, acnt, agrand)\n else:\n time_step = incr_time\n agent_dex = -1\n\n time += time_step\n #set_surface_state(surface_state, time, _lattice_)\n set_state(state, surface_state, time, _lattice_)\n\n real_time = state[0]\n if last_time < real_time and capture_count < total_captures:\n #set_voxel_state(voxel_state, time, _lattice_)\n set_surface_state(surface_state, time, _lattice_)\n set_state(state, surface_state, time, _lattice_)\n while last_time < real_time and capture_count < total_captures:\n state[0] = last_time\n last_time += incr_time\n capture(data, state, capture_count, target_dexes)\n capture(surface_data, surface_state, capture_count, surf_target_dexes)\n #capture(voxel_data, voxel_state, capture_count, voxel_target_dexes)\n capture_count += 1\n print 'time', last_time, 'pop', len(_lattice_.agents)\n state[0] = real_time\n\n #agent activity cant depend on state/surface_state...\n if agent_dex >= 0: _lattice_.act_agent(agent_dex)\n agents_propensity(_lattice_)\n\n if ti.time() - start_time > timed_out_limit: timed_out = True\n dead_eco = dead_eco_check()\n\n if timed_out or dead_eco: \n #set_surface_state(surface_state, time, _lattice_)\n state[0] = last_time\n last_time += incr_time\n capture(data, state, capture_count, target_dexes)\n capture(surface_data, surface_state, capture_count, surf_target_dexes)\n #capture(voxel_data, voxel_state, capture_count, voxel_target_dexes)\n capture_count += 1\n print 'time', last_time, 'pop', len(_lattice_.agents)\n\n toss = capture_count\n #voxel_data = voxel_data[:,:toss,:,:]\n surface_data = surface_data[:,:toss,:,:]\n data = data[:,:toss]\n return data,surface_data,targets + surf_targets\n return data, surface_data, targets + surf_targets\n\nif __name__ == '__main__':\n import sys\n if len(sys.argv) > 1: use_pyx = sys.argv[1]\n else: use_pyx = False\n if use_pyx:\n import lattice_simulator as lsim\n print 'USING CYTHON!'\n lprf.profile_function(lsim.simulate)\n else:\n lprf.profile_function(simulate)\n #lprf.profile_function(simulate)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n", "meta": {"hexsha": "9ad159c483aa45108fb54ef881b22d12887216b3", "size": 22046, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/support/liblattice_sim.py", "max_stars_repo_name": "ctogle/lattice", "max_stars_repo_head_hexsha": "6f9e64102786899a4119757d2a12e1c63fd4b640", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/support/liblattice_sim.py", "max_issues_repo_name": "ctogle/lattice", "max_issues_repo_head_hexsha": "6f9e64102786899a4119757d2a12e1c63fd4b640", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/support/liblattice_sim.py", "max_forks_repo_name": "ctogle/lattice", "max_forks_repo_head_hexsha": "6f9e64102786899a4119757d2a12e1c63fd4b640", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.6821963394, "max_line_length": 88, "alphanum_fraction": 0.6068220992, "include": true, "reason": "import numpy", "num_tokens": 5811, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.588889130767832, "lm_q2_score": 0.33111975283019596, "lm_q1q2_score": 0.1949928234242335}} {"text": "\"\"\" Functions used to assign restframe g-r and r-i SDSS colors to mock galaxies.\n\"\"\"\nimport numpy as np\nfrom .sawtooth_binning import sawtooth_bin_indices\nfrom astropy.utils.misc import NumpyRNGContext\nfrom halotools.empirical_models import polynomial_from_table\nfrom ..sdss_colors.sdss_completeness_model import retrieve_sdss_sample_mask\n\n\n__all__ = ('mc_sdss_gr_ri', )\n\n\ndefault_seed = 43\n\n\ndef assign_data_source(mock_logsm, table_abscissa=np.array([8.5, 9, 9.5, 10]),\n table_ordinates=np.array([1, 0.8, 0.35, 0]), seed=default_seed):\n \"\"\"\n Determine the source of observational data that will be used\n to map colors onto mock galaxies.\n\n For entries in the returned ndarray equal to zero, real SDSS objects\n will be used to map colors onto mock galaxies.\n\n For entries in the returned ndarray equal to one, fake SDSS objects will be used.\n\n Parameters\n ----------\n mock_logsm : ndarray\n Numpy array of shape (ngals, ) storing the stellar mass of mock galaxies\n\n table_abscissa : ndarray, optional\n Control points in log10 stellar mass at which the data source probability is defined\n\n table_ordinates : ndarray, optional\n Control points defining the probability that\n a mock galaxy will be assigned to data source one.\n\n seed : int, optional\n Random number seed. Default is default_seed, set at the top of\n the module where the function is defined.\n\n Returns\n -------\n data_source : ndarray\n Numpy array of shape (ngals, ) storing an integer indicating the data source\n from which colors will be drawn\n \"\"\"\n input_abscissa = np.linspace(table_abscissa.min(), table_abscissa.max(), 100)\n ordinates = polynomial_from_table(table_abscissa, table_ordinates, input_abscissa)\n\n prob_fake = np.interp(mock_logsm, input_abscissa, ordinates)\n with NumpyRNGContext(seed):\n fake_mask = np.random.rand(len(mock_logsm)) < prob_fake\n data_source = np.zeros_like(fake_mask).astype(int)\n data_source[fake_mask] = 1\n\n return data_source\n\n\ndef fuzzy_sawtooth_magr_binning(mock_rmag, data_source, magr_bins=None, seed=default_seed):\n \"\"\" Assign galaxies to overlapping bins based on their restframe absolute r-band magnitude.\n\n Binning will be done separately for mock galaxies above and below the SDSS completeness limit.\n\n Parameters\n ----------\n mock_rmag : ndarray\n Numpy array of shape (ngals, ) storing the\n restframe absolute r-band magnitude of mock galaxies\n\n data_source : ndarray\n Numpy array of shape (ngals, ) storing an integer indicating the data source\n from which colors will be drawn (zero for real data, one for fake data).\n\n magr_bins : ndarray, optional\n Numpy array of shape (nbins, ) storing the bin boundaries.\n Must strictly encompass the range spanned by the mock.\n Default is to use 25 bins linearly spaced in Magr covering a range that\n just beyond the boundaries of the data.\n\n seed : int, optional\n Random number seed. Default is default_seed, set at the top of\n the module where the function is defined.\n\n Returns\n -------\n rmag_bin_number : ndarray\n Numpy integer array of shape (ngals, ) storing the bin number of each mock galaxy\n \"\"\"\n if magr_bins is None:\n epsilon = 0.01\n rmin, rmax, dr = mock_rmag.min()-epsilon, mock_rmag.max()+epsilon, 0.2\n magr_bins = np.arange(rmin, rmax+dr, dr)\n\n source0_mask = data_source == 0\n rmag_bin_number = -np.ones_like(mock_rmag).astype('i4')\n rmag_bin_number[source0_mask] = sawtooth_bin_indices(mock_rmag[source0_mask], magr_bins, seed=seed)\n rmag_bin_number[~source0_mask] = sawtooth_bin_indices(mock_rmag[~source0_mask], magr_bins, seed=seed)\n return rmag_bin_number\n\n\ndef mc_true_sdss_gr_ri(sdss_redshift, sdss_magr, sdss_gr, sdss_ri,\n mock_magr_bin_number, mock_magr, mock_sfr_percentile, sigma=0., k=10, seed=default_seed):\n \"\"\" Given {Mr, SFR-percentile} for mock galaxies, search SDSS data\n to select galaxies with matching {Mr, g-r-percentile}, and use the colors\n {g-r, r-i} of the selected SDSS galaxies to paint on to the mock galaxies.\n \"\"\"\n from scipy.spatial import cKDTree\n from scipy.stats import gaussian_kde\n\n mock_gr = np.zeros_like(mock_magr)\n mock_ri = np.zeros_like(mock_magr)\n\n # We loop over probabilistically overlapping bins of r-band magnitude\n magr_bin_numbers = list(set(mock_magr_bin_number))\n for bin_number in magr_bin_numbers:\n mock_magr_mask = mock_magr_bin_number == bin_number\n npts_mock_bin = np.count_nonzero(mock_magr_mask)\n\n mock_magr_bin = mock_magr[mock_magr_mask]\n mock_sfr_percentile_bin = mock_sfr_percentile[mock_magr_mask]\n\n # Make a cut to apply a color-completeness limiting redshift\n Mr_min, Mr_max = mock_magr_bin.min(), mock_magr_bin.max()\n sdss_mask = retrieve_sdss_sample_mask(sdss_redshift, sdss_magr, Mr_min, Mr_max)\n sdss_rmag_bin = sdss_magr[sdss_mask]\n sdss_gr_bin = sdss_gr[sdss_mask]\n sdss_ri_bin = sdss_ri[sdss_mask]\n\n # Use Gaussian kernel density estimation on the SDSS data\n # to generate a random sampling of colors for each mock galaxy\n # This step helps smooth out artificial clustering of mock galaxies\n # around outlier fluctuations in the observed data\n X_bin = np.vstack((sdss_rmag_bin, sdss_gr_bin, sdss_ri_bin))\n kde_bin = gaussian_kde(X_bin)\n with NumpyRNGContext(seed):\n resampled_bin = kde_bin.resample(npts_mock_bin)\n sdss_rmag_bin_resampled = resampled_bin[0, :]\n sdss_gr_bin_resampled = resampled_bin[1, :]\n sdss_ri_bin_resampled = resampled_bin[2, :]\n\n # Sort the mock galaxies in the bin by their SFR-rank-order-percentile (at fixed M*)\n # Sort the Monte Carlo realization of g-r\n # Apply the implicit non-parametric map to paint g-r onto mock galaxies\n idx_mock_percentile_sorted = np.argsort(mock_sfr_percentile_bin)\n mock_gr_bin = np.zeros(npts_mock_bin).astype('f4')\n mock_gr_bin[idx_mock_percentile_sorted] = np.sort(sdss_gr_bin_resampled)[::-1]\n\n # Now run a nearest-neighbor search on the KDE-resampled SDSS data\n # to identify an r-i color of a galaxy with a closely matching {Mr, g-r}.\n # Randomly selecting one of the 10 nearest neighbors helps smear out\n # artificial amplification of hard edges in the observed data\n Y = np.vstack((sdss_rmag_bin_resampled, sdss_gr_bin_resampled)).T\n sdss_tree = cKDTree(Y)\n knn = min(k, len(sdss_rmag_bin_resampled))\n result = sdss_tree.query(np.vstack((mock_magr_bin, mock_gr_bin)).T, k=knn)\n nn_indices = result[1]\n with NumpyRNGContext(seed):\n a = np.random.randint(0, nn_indices.shape[1], nn_indices.shape[0])\n idx = nn_indices[np.arange(nn_indices.shape[0]), a]\n mock_ri_bin = sdss_ri_bin_resampled[idx]\n\n mock_gr[mock_magr_mask] = mock_gr_bin\n mock_ri[mock_magr_mask] = mock_ri_bin\n\n return mock_gr, mock_ri\n\n\ndef mc_fake_sdss_gr_ri(sdss_gr, sdss_ri, rmag_bin_number, mock_log10_mstar, seed=default_seed):\n \"\"\" Set up a simple multivariate Gaussian model to extrapolate SDSS colors\n {g-r, r-i} into the very faint end.\n \"\"\"\n gr_center = np.median(sdss_gr)-0.35\n ri_center = np.median(sdss_ri)-0.15\n median_gr = np.interp(mock_log10_mstar, [6, 9], [gr_center-0.2, gr_center])\n median_ri = np.interp(mock_log10_mstar, [6, 9], [ri_center-0.3, ri_center])\n median_array = np.vstack((median_gr, median_ri)).T\n\n ngals_mock = len(mock_log10_mstar)\n X = np.vstack((sdss_gr, sdss_ri))\n cov = np.cov(X)/2.\n\n with NumpyRNGContext(seed):\n Z = np.random.multivariate_normal(\n mean=(0, 0), cov=cov, size=ngals_mock) + median_array\n mock_gr, mock_ri = Z[:, 0], Z[:, 1]\n return mock_gr, mock_ri\n\n\ndef mc_sdss_gr_ri(mock_rmag, mock_mstar, mock_sfr_percentile,\n sdss_redshift, sdss_magr, sdss_gr, sdss_ri, k=10, seed=default_seed):\n \"\"\" Divide mock galaxies into a sample for which colors from real SDSS galaxies\n will be drawn, and another sample for which colors from the extrapolation model\n will be drawn, creating a fuzzy boundary in stellar mass that stitches the\n two samples together. Then for each sample, call the appropriate\n Monte Carlo function to generate {g-r, r-i} colors.\n \"\"\"\n mock_data_source = assign_data_source(np.log10(mock_mstar), seed=seed)\n mock_rmag_bin_number = fuzzy_sawtooth_magr_binning(mock_rmag, mock_data_source, seed=seed)\n\n source0_mask = mock_data_source == 0\n\n mock_source0_gr, mock_source0_ri = mc_true_sdss_gr_ri(\n sdss_redshift, sdss_magr, sdss_gr, sdss_ri,\n mock_rmag_bin_number[source0_mask], mock_rmag[source0_mask],\n mock_sfr_percentile[source0_mask], k, seed=seed)\n\n mock_source1_gr, mock_source1_ri = mc_fake_sdss_gr_ri(sdss_gr, sdss_ri,\n mock_rmag_bin_number[~source0_mask], np.log10(mock_mstar[~source0_mask]), seed=seed)\n\n output_mock_gr = np.zeros_like(mock_rmag) - 999.\n output_mock_ri = np.zeros_like(mock_rmag) - 999.\n output_mock_gr[source0_mask] = mock_source0_gr\n output_mock_ri[source0_mask] = mock_source0_ri\n output_mock_gr[~source0_mask] = mock_source1_gr\n output_mock_ri[~source0_mask] = mock_source1_ri\n\n return output_mock_gr, output_mock_ri\n", "meta": {"hexsha": "a29cdf0cfebad63c16d320994e2821e4dea57e57", "size": 9489, "ext": "py", "lang": "Python", "max_stars_repo_path": "cosmodc2/sdss_colors/restframe_sdss_gr_ri.py", "max_stars_repo_name": "ArgonneCPAC/skysim", "max_stars_repo_head_hexsha": "f271debe3439efd1ae5230c6020b2dbc5f79d824", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2020-08-08T10:01:49.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-27T07:21:00.000Z", "max_issues_repo_path": "cosmodc2/sdss_colors/restframe_sdss_gr_ri.py", "max_issues_repo_name": "ArgonneCPAC/skysim", "max_issues_repo_head_hexsha": "f271debe3439efd1ae5230c6020b2dbc5f79d824", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 67, "max_issues_repo_issues_event_min_datetime": "2018-07-16T22:12:16.000Z", "max_issues_repo_issues_event_max_datetime": "2020-07-02T01:12:48.000Z", "max_forks_repo_path": "cosmodc2/sdss_colors/restframe_sdss_gr_ri.py", "max_forks_repo_name": "aphearin/cosmodc2", "max_forks_repo_head_hexsha": "5bc2abebd7123f29b424efc11c3ef374a51cd6c1", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.1318181818, "max_line_length": 105, "alphanum_fraction": 0.7120876805, "include": true, "reason": "import numpy,from scipy,from astropy", "num_tokens": 2534, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5888891163376236, "lm_q2_score": 0.33111974622959367, "lm_q1q2_score": 0.19499281475908362}} {"text": "\"\"\"\nThis is to generate interaction energies and corresponding translational vectors, \ngiven a fixed receptor and an ensemble of ligand coordinates (including rotations and/or configurations)\n\"\"\"\nfrom __future__ import print_function\n\nimport numpy as np\nimport netCDF4\n\ntry:\n from bpmfwfft.grids import RecGrid\n from bpmfwfft.grids import LigGrid\n\nexcept:\n from grids import RecGrid\n from grids import LigGrid\n\n\nKB = 0.001987204134799235\n\n\nclass Sampling(object):\n def __init__(self, rec_prmtop, lj_sigma_scal_fact, rec_inpcrd, \n bsite_file, grid_nc_file,\n lig_prmtop, lig_inpcrd,\n lig_coord_ensemble,\n energy_sample_size_per_ligand,\n output_nc,\n temperature=300.):\n \"\"\"\n :param rec_prmtop: str, name of receptor prmtop file\n :param lj_sigma_scal_fact: float, used to check consitency when loading receptor and ligand grids\n :param rec_inpcrd: str, name of receptor inpcrd file\n :param bsite_file: None or str, name of file defining the box, the same as\n from AlGDock pipeline. \"measured_binding_site.py\"\n :param grid_nc_file: str, name of receptor precomputed grid netCDF file\n :param lig_prmtop: str, name of ligand prmtop file\n :param lig_inpcrd: str, name of ligand inpcrd file\n :param lig_coord_ensemble: list of 2d array, each array is an ligand coordinate\n :param energy_sample_size_per_ligand: int, number of energies and translational vectors to store for each ligand crd\n :param output_nc: str, name of nc file\n :param temperature: float\n \"\"\"\n self._energy_sample_size_per_ligand = energy_sample_size_per_ligand\n self._beta = 1./ temperature / KB\n\n rec_grid = self._create_rec_grid(rec_prmtop, lj_sigma_scal_fact, rec_inpcrd, \n bsite_file, grid_nc_file)\n self._rec_crd = rec_grid.get_crd()\n\n self._lig_grid = self._create_lig_grid(lig_prmtop, lj_sigma_scal_fact, lig_inpcrd, rec_grid)\n\n self._lig_coord_ensemble = self._load_ligand_coor_ensemble(lig_coord_ensemble)\n\n self._nc_handle = self._initialize_nc(output_nc)\n\n def _create_rec_grid(self, rec_prmtop, lj_sigma_scal_fact, rec_inpcrd, bsite_file, grid_nc_file):\n rec_grid = RecGrid(rec_prmtop, lj_sigma_scal_fact, rec_inpcrd, bsite_file, \n grid_nc_file, new_calculation=False)\n return rec_grid\n\n def _create_lig_grid(self, lig_prmtop, lj_sigma_scal_fact, lig_inpcrd, rec_grid):\n lig_grid = LigGrid(lig_prmtop, lj_sigma_scal_fact, lig_inpcrd, rec_grid)\n return lig_grid\n\n def _load_ligand_coor_ensemble(self, lig_coord_ensemble):\n assert len(lig_coord_ensemble.shape) == 3, \"lig_coord_ensemble must be 3-D array.\"\n ensemble = lig_coord_ensemble\n natoms = self._lig_grid.get_natoms()\n \n for i in range(len(ensemble)):\n if (ensemble[i].shape[0] != natoms) or (ensemble[i].shape[1] != 3):\n raise RuntimeError(\"Ligand crd %d does not have correct shape\"%i)\n return ensemble\n\n def _initialize_nc(self, output_nc):\n nc_handle = netCDF4.Dataset(output_nc, mode=\"w\", format=\"NETCDF4\")\n\n nc_handle.createDimension(\"three\", 3)\n rec_natoms = self._rec_crd.shape[0]\n nc_handle.createDimension(\"rec_natoms\", rec_natoms)\n\n lig_natoms = self._lig_grid.get_natoms()\n nc_handle.createDimension(\"lig_natoms\", lig_natoms)\n nc_handle.createDimension(\"lig_sample_size\", self._lig_coord_ensemble.shape[0])\n\n nc_handle.createDimension(\"energy_sample_size_per_ligand\", self._energy_sample_size_per_ligand)\n\n\n nc_handle.createVariable(\"rec_positions\", \"f8\", (\"rec_natoms\", \"three\"))\n nc_handle.variables[\"rec_positions\"][:,:] = self._rec_crd\n\n nc_handle.createVariable(\"lig_positions\", \"f8\", (\"lig_sample_size\", \"lig_natoms\", \"three\"))\n nc_handle.createVariable(\"lig_com\", \"f8\", (\"lig_sample_size\", \"three\"))\n nc_handle.createVariable(\"volume\", \"f8\", (\"lig_sample_size\"))\n nc_handle.createVariable(\"nr_grid_points\", \"i8\", (\"lig_sample_size\"))\n\n nc_handle.createVariable(\"exponential_sums\", \"f8\", (\"lig_sample_size\"))\n nc_handle.createVariable(\"log_of_divisors\", \"f8\", (\"lig_sample_size\"))\n\n nc_handle.createVariable(\"mean_energy\", \"f8\", (\"lig_sample_size\"))\n nc_handle.createVariable(\"min_energy\", \"f8\", (\"lig_sample_size\"))\n nc_handle.createVariable(\"energy_std\", \"f8\", (\"lig_sample_size\"))\n\n nc_handle.createVariable(\"resampled_energies\", \"f8\", (\"lig_sample_size\", \"energy_sample_size_per_ligand\"))\n nc_handle.createVariable(\"resampled_trans_vectors\", \"i8\", (\"lig_sample_size\", \"energy_sample_size_per_ligand\", \"three\"))\n\n nc_handle = self._write_grid_info(nc_handle)\n return nc_handle\n\n def _write_grid_info(self, nc_handle):\n \"\"\"\n write grid info, \"x\", \"y\", \"z\" ...\n \"\"\"\n data = self._lig_grid.get_grids()\n grid_func_names = self._lig_grid.get_grid_func_names()\n keys = [key for key in data.keys() if key not in grid_func_names]\n\n for key in keys:\n for dim in data[key].shape:\n dim_name = \"%d\"%dim\n if dim_name not in nc_handle.dimensions.keys():\n nc_handle.createDimension(dim_name, dim)\n\n for key in keys:\n if data[key].dtype == int:\n store_format = \"i8\"\n elif data[key].dtype == float:\n store_format = \"f8\"\n else:\n raise RuntimeError( \"Unsupported dtype %s\"%data[key].dtype )\n dimensions = tuple([ \"%d\"%dim for dim in data[key].shape ])\n nc_handle.createVariable(key, store_format, dimensions)\n\n for key in keys:\n nc_handle.variables[key][:] = data[key]\n return nc_handle\n\n def _save_data_to_nc(self, step):\n self._nc_handle.variables[\"lig_positions\"][step, :, :] = self._lig_grid.get_crd()\n\n self._nc_handle.variables[\"lig_com\"][step, :] = self._lig_grid.get_initial_com()\n\n self._nc_handle.variables[\"volume\"][step] = self._lig_grid.get_box_volume()\n\n self._nc_handle.variables[\"nr_grid_points\"][step] = self._lig_grid.get_number_translations()\n\n self._nc_handle.variables[\"exponential_sums\"][step] = self._exponential_sum\n\n self._nc_handle.variables[\"log_of_divisors\"][step] = self._log_of_divisor\n\n self._nc_handle.variables[\"mean_energy\"][step] = self._mean_energy\n self._nc_handle.variables[\"min_energy\"][step] = self._min_energy\n self._nc_handle.variables[\"energy_std\"][step] = self._energy_std\n\n self._nc_handle.variables[\"resampled_energies\"][step,:] = self._resampled_energies\n\n self._nc_handle.variables[\"resampled_trans_vectors\"][step,:,:] = self._resampled_trans_vectors\n return None\n\n def _do_fft(self, step):\n print(\"Doing FFT for step %d\"%step, \"test\")\n lig_conf = self._lig_coord_ensemble[step]\n self._lig_grid.cal_grids(molecular_coord = lig_conf)\n\n energies = self._lig_grid.get_meaningful_energies()\n print(\"Energies shape:\", energies.shape)\n self._mean_energy = energies.mean()\n self._min_energy = energies.min()\n self._energy_std = energies.std()\n print(\"Number of finite energy samples\", energies.shape[0])\n\n exp_energies = -self._beta * energies\n print(f\"Max exp energy {exp_energies.max()}, Min exp energy {exp_energies.min()}\")\n self._log_of_divisor = exp_energies.max()\n exp_energies[exp_energies < 0] = 0\n exp_energies = np.exp(exp_energies - self._log_of_divisor)\n self._exponential_sum = exp_energies.sum()\n exp_energies /= self._exponential_sum\n print(\"Number of exponential energy samples\", exp_energies.sum())\n # sel_ind = np.random.choice(exp_energies.shape[0], size=self._energy_sample_size_per_ligand, p=exp_energies, replace=True)\n try:\n sel_ind = np.random.choice(exp_energies.shape[0], size=self._energy_sample_size_per_ligand, p=exp_energies, replace=False)\n except:\n print(f\"Only {np.count_nonzero(exp_energies)} non-zero entries in p, falling back to replacement\")\n sel_ind = np.random.choice(exp_energies.shape[0], size=self._energy_sample_size_per_ligand, p=exp_energies, replace=True)\n\n del exp_energies\n\n self._resampled_energies = [energies[ind] for ind in sel_ind]\n del energies\n self._lig_grid.set_meaningful_energies_to_none()\n\n trans_vectors = self._lig_grid.get_meaningful_corners()\n self._resampled_trans_vectors = [trans_vectors[ind] for ind in sel_ind]\n del trans_vectors\n\n self._resampled_energies = np.array(self._resampled_energies, dtype=float)\n self._resampled_trans_vectors = np.array(self._resampled_trans_vectors, dtype=int)\n\n self._save_data_to_nc(step)\n return None\n\n def run_sampling(self):\n \"\"\"\n \"\"\"\n for step in range(self._lig_coord_ensemble.shape[0]):\n self._do_fft(step)\n\n print(\"Min energy\", self._min_energy)\n print(\"Mean energy\", self._mean_energy)\n print(\"STD energy\", self._energy_std)\n print(\"Initial center of mass\", self._lig_grid.get_initial_com())\n print(\"Grid volume\", self._lig_grid.get_box_volume())\n print(\"Number of translations\", self._lig_grid.get_number_translations())\n print(\"-------------------------------\\n\\n\")\n\n self._nc_handle.close()\n return None\n\n#\n#TODO the class above assumes that the resample size is smaller than number of meaningful energies\n# in general, the number of meaningful energies can be very smaller or even zero (no energy)\n# when the number of meaningful energies is zero, that stratum contributes n_points zeros to the exponential mean\n#\n# so when needs to consider separately 3 cases:\n# len(meaningful energies) == 0\n# 0< len(meaningful energies) <= resample size\n# len(meaningful energies) > resample size\n#\n\n\nclass Sampling_PL(Sampling):\n \n def _write_data_key_2_nc(self, data, key):\n if data.shape[0] == 0:\n return None\n\n for dim in data.shape:\n dim_name = \"%d\"%dim\n if dim_name not in self._nc_handle.dimensions.keys():\n self._nc_handle.createDimension(dim_name, dim)\n\n if data.dtype == int:\n store_format = \"i8\"\n elif data.dtype == float:\n store_format = \"f8\"\n else:\n raise RuntimeError(\"unsupported dtype %s\"%data.dtype)\n dimensions = tuple([\"%d\"%dim for dim in data.shape])\n self._nc_handle.createVariable(key, store_format, dimensions)\n\n self._nc_handle.variables[key][:] = data\n return None\n\n def _initialize_nc(self, output_nc):\n \"\"\"\n \"\"\"\n nc_handle = netCDF4.Dataset(output_nc, mode=\"w\", format=\"NETCDF4\")\n\n nc_handle.createDimension(\"three\", 3)\n rec_natoms = self._rec_crd.shape[0]\n nc_handle.createDimension(\"rec_natoms\", rec_natoms)\n\n lig_natoms = self._lig_grid.get_natoms()\n nc_handle.createDimension(\"lig_natoms\", lig_natoms)\n nc_handle.createDimension(\"lig_sample_size\", self._lig_coord_ensemble.shape[0])\n\n #nc_handle.createDimension(\"energy_sample_size_per_ligand\", self._energy_sample_size_per_ligand)\n\n nc_handle.createVariable(\"rec_positions\", \"f8\", (\"rec_natoms\", \"three\"))\n nc_handle.variables[\"rec_positions\"][:,:] = self._rec_crd\n\n nc_handle.createVariable(\"lig_positions\", \"f8\", (\"lig_sample_size\", \"lig_natoms\", \"three\"))\n nc_handle.createVariable(\"lig_com\", \"f8\", (\"lig_sample_size\", \"three\"))\n nc_handle.createVariable(\"volume\", \"f8\", (\"lig_sample_size\"))\n nc_handle.createVariable(\"nr_grid_points\", \"i8\", (\"lig_sample_size\"))\n nc_handle.createVariable(\"nr_finite_energy\", \"i8\", (\"lig_sample_size\"))\n\n nc_handle.createVariable(\"exponential_sums\", \"f8\", (\"lig_sample_size\"))\n nc_handle.createVariable(\"log_of_divisors\", \"f8\", (\"lig_sample_size\"))\n\n nc_handle.createVariable(\"mean_energy\", \"f8\", (\"lig_sample_size\"))\n nc_handle.createVariable(\"min_energy\", \"f8\", (\"lig_sample_size\"))\n nc_handle.createVariable(\"energy_std\", \"f8\", (\"lig_sample_size\"))\n\n #nc_handle.createVariable(\"resampled_energies\", \"f8\", (\"lig_sample_size\", \"energy_sample_size_per_ligand\"))\n #nc_handle.createVariable(\"resampled_trans_vectors\", \"i8\", (\"lig_sample_size\", \"energy_sample_size_per_ligand\", \"three\"))\n\n nc_handle = self._write_grid_info(nc_handle)\n return nc_handle\n\n def _save_data_to_nc(self, step):\n self._nc_handle.variables[\"lig_positions\"][step, :, :] = self._lig_grid.get_crd()\n\n self._nc_handle.variables[\"lig_com\"][step, :] = self._lig_grid.get_initial_com()\n\n self._nc_handle.variables[\"volume\"][step] = self._lig_grid.get_box_volume()\n\n self._nc_handle.variables[\"nr_grid_points\"][step] = self._lig_grid.get_number_translations()\n\n self._nc_handle.variables[\"nr_finite_energy\"][step] = self._nr_finite_energy\n\n self._nc_handle.variables[\"exponential_sums\"][step] = self._exponential_sum\n\n self._nc_handle.variables[\"log_of_divisors\"][step] = self._log_of_divisor\n\n self._nc_handle.variables[\"mean_energy\"][step] = self._mean_energy\n\n self._nc_handle.variables[\"min_energy\"][step] = self._min_energy\n\n self._nc_handle.variables[\"energy_std\"][step] = self._energy_std\n\n self._write_data_key_2_nc(self._resampled_energies, \"resampled_energies_%d\"%step)\n\n self._write_data_key_2_nc(self._resampled_trans_vectors, \"resampled_trans_vectors_%d\"%step)\n return None\n\n def _do_fft(self, step):\n print(\"Doing FFT for step %d\"%step)\n lig_conf = self._lig_coord_ensemble[step]\n print(self._lig_grid[\"SASAr\"])\n self._lig_grid.cal_grids(molecular_coord = lig_conf)\n\n energies = self._lig_grid.get_meaningful_energies()\n self._nr_finite_energy = energies.shape[0]\n print(\"Number of finite energy samples\", self._nr_finite_energy)\n\n if energies.shape[0] > 0:\n\n self._mean_energy = energies.mean()\n self._min_energy = energies.min()\n self._energy_std = energies.std()\n\n exp_energies = -self._beta * energies\n self._log_of_divisor = exp_energies.max()\n exp_energies = np.exp(exp_energies - self._log_of_divisor)\n self._exponential_sum = exp_energies.sum()\n exp_energies /= self._exponential_sum\n \n sample_size = min(exp_energies.shape[0], self._energy_sample_size_per_ligand)\n sel_ind = np.random.choice(exp_energies.shape[0], size=sample_size, p=exp_energies, replace=True)\n\n del exp_energies\n\n self._resampled_energies = [energies[ind] for ind in sel_ind]\n del energies\n self._lig_grid.set_meaningful_energies_to_none()\n\n trans_vectors = self._lig_grid.get_meaningful_corners()\n self._resampled_trans_vectors = [trans_vectors[ind] for ind in sel_ind]\n del trans_vectors\n\n self._resampled_energies = np.array(self._resampled_energies, dtype=float)\n self._resampled_trans_vectors = np.array(self._resampled_trans_vectors, dtype=int)\n\n else:\n\n self._mean_energy = np.inf\n self._min_energy = np.inf\n self._energy_std = np.inf\n\n self._log_of_divisor = 1.\n self._exponential_sum = 0.\n\n self._resampled_energies = np.array([], dtype=float)\n del energies\n self._lig_grid.set_meaningful_energies_to_none()\n\n self._resampled_trans_vectors = np.array([], dtype=float)\n\n self._save_data_to_nc(step)\n return None\n\n\nif __name__ == \"__main__\":\n # test\n rec_prmtop = \"../examples/amber/ubiquitin_ligase/receptor.prmtop\"\n lj_sigma_scal_fact = 0.8\n rec_inpcrd = \"../examples/amber/ubiquitin_ligase/receptor.inpcrd\"\n\n # bsite_file = \"../examples/amber/t4_lysozyme/measured_binding_site.py\"\n bsite_file = None\n grid_nc_file = \"../examples/grid/ubiquitin_ligase/grid.nc\"\n\n lig_prmtop = \"../examples/amber/ubiquitin/ligand.prmtop\"\n lig_inpcrd = \"../examples/amber/ubiquitin/ligand.inpcrd\"\n\n energy_sample_size_per_ligand = 200\n output_nc = \"../examples/fft_sampling/ubql_ubiquitin/fft_sampling.nc\"\n\n ligand_md_trj_file = \"../examples/ligand_md/ubiquitin/rotation.nc\"\n lig_coord_ensemble = netCDF4.Dataset(ligand_md_trj_file, \"r\").variables[\"positions\"][:]\n\n sampler = Sampling(rec_prmtop, lj_sigma_scal_fact, rec_inpcrd,\n bsite_file, grid_nc_file, \n lig_prmtop, lig_inpcrd,\n lig_coord_ensemble,\n energy_sample_size_per_ligand, \n output_nc,\n temperature=300.)\n sampler.run_sampling()\n\n\n\n\n\n", "meta": {"hexsha": "274fe43fa546672495660673160348de8f0a6c2e", "size": 17257, "ext": "py", "lang": "Python", "max_stars_repo_path": "bpmfwfft/fft_sampling.py", "max_stars_repo_name": "jimtufts/bpmfwfft", "max_stars_repo_head_hexsha": "091d2269b122f00b9dd8a01e34303e3e946f8ea0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "bpmfwfft/fft_sampling.py", "max_issues_repo_name": "jimtufts/bpmfwfft", "max_issues_repo_head_hexsha": "091d2269b122f00b9dd8a01e34303e3e946f8ea0", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "bpmfwfft/fft_sampling.py", "max_forks_repo_name": "jimtufts/bpmfwfft", "max_forks_repo_head_hexsha": "091d2269b122f00b9dd8a01e34303e3e946f8ea0", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.2965686275, "max_line_length": 134, "alphanum_fraction": 0.6651214, "include": true, "reason": "import numpy", "num_tokens": 4230, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.588889130767832, "lm_q2_score": 0.3311197330283893, "lm_q1q2_score": 0.19499281176316477}} {"text": "'''Collection of functions that generate figures from the fit outputs. Creates figures from fit results using both simulated and real datasets.'''\n\nfrom fancy.analysis import results\nimport numpy as np\nimport os\nimport h5py\nimport matplotlib as mpl\nfrom matplotlib import pyplot as plt\nimport seaborn as sns\nfrom pandas import DataFrame\nfrom astropy.coordinates import SkyCoord\nfrom astropy import units as u\n\nfrom fancy import Data, Results\nfrom fancy.plotting import Corner\nfrom fancy.plotting.allskymap_cartopy import AllSkyMapCartopy as AllSkyMap\nfrom fancy.plotting.colours import *\nfrom fancy.interfaces.stan import Direction\n\n# use minimalist style\nplt.style.use(\"minimalist\")\n\n# paths to important files\npath_to_this_file = os.path.abspath(os.path.dirname(__file__))\nstan_path = os.path.join(path_to_this_file, \"..\", \"stan\")\nsource_file = os.path.join(path_to_this_file, \"..\", \"data\", \"sourcedata.h5\")\nuhecr_file = os.path.join(path_to_this_file, \"..\", \"data\", \"UHECRdata.h5\")\ntable_path = os.path.join(path_to_this_file, \"..\", \"tables\")\noutput_path = os.path.join(path_to_this_file, \"..\", \"output\")\n\n\nclass OutputFigures():\n def __init__(self,\n fig_args,\n sim_model=None,\n sim_output_file=None,\n tight_B=False,\n skymap_label_fmt=\"default\"):\n '''Collection of figures obtained from output of fitting.'''\n # parameters set from argparse\n self.source_type = fig_args[\"source\"]\n self.detector_type = fig_args[\"detector\"]\n self.model_type = fig_args[\"model\"]\n self.data_type = fig_args[\"dtype\"]\n self.ptype = fig_args[\"ptype\"]\n self.seed = fig_args[\"seed\"]\n self.sim_model_type = sim_model\n self.sim_output_file = sim_output_file\n\n # output file from simulation / fitting\n if tight_B:\n self.output_file = os.path.join(\n output_path,\n \"tmp_{0}_fit_{5}_{1}_{2}_{3}_{4}_tightB.h5\".format(\n self.model_type, self.source_type, self.detector_type,\n self.seed, self.ptype, self.data_type))\n else:\n self.output_file = os.path.join(\n output_path, \"tmp_{0}_fit_{5}_{1}_{2}_{3}_{4}.h5\".format(\n self.model_type, self.source_type, self.detector_type,\n self.seed, self.ptype, self.data_type))\n\n if sim_output_file is not None:\n self.output_file = os.path.join(\n output_path, \"{0}_fit_{5}_{1}_{2}_{3}_{4}_{6}.h5\".format(\n self.model_type, self.source_type, self.detector_type,\n self.seed, self.ptype, self.data_type,\n self.sim_model_type))\n # if self.detector_type == \"joint_gmf\":\n # self.output_file = os.path.join(\n # output_path, \"{0}_fit_{5}_{1}_{2}_{3}_{4}_{5}.h5\".format(\n # self.model_type, self.source_type, self.detector_type,\n # self.seed, self.ptype, self.data_type,\n # self.sim_model_type))\n\n # else:\n # self.output_file = os.path.join(\n # output_path, \"{0}_fit_{5}_{1}_{2}_{3}_{4}.h5\".format(\n # self.model_type, self.source_type, self.detector_type,\n # self.seed, self.ptype, self.data_type))\n\n # obtain detector properties / params from imports\n self.detector_properties, self.detector_params = self._get_detectorimports(\n )\n\n # initialize the data object and add relevant data into it\n self._initialize_data()\n\n # format style for skymap labels (from \"mpl\" or \"TA\")\n self.skymap_label_fmt = skymap_label_fmt\n\n def _get_detectorimports(self):\n '''Get variables imported by (detector_name).py'''\n if self.detector_type == \"TA2015\":\n from fancy.detector.TA2015 import detector_properties, detector_params\n elif self.detector_type == \"auger2014\":\n from fancy.detector.auger2014 import detector_properties, detector_params\n elif self.detector_type == \"auger2010\":\n from fancy.detector.auger2010 import detector_properties, detector_params\n else:\n raise Exception(\"Undefined detector type!\")\n\n return detector_properties, detector_params\n\n def _initialize_data(self):\n '''Initialize data object based on sim / real data'''\n self.data = Data()\n\n if self.data_type == \"sim\":\n self.data.from_file(self.sim_output_file)\n\n elif self.data_type == \"real\":\n self.data.add_source(source_file, self.source_type)\n self.data.add_uhecr(uhecr_file, self.detector_type)\n self.data.add_detector(self.detector_properties)\n\n def src_uhecr_skymap(self, savefile=None, coord=\"G\", exposure=\"map\"):\n '''\n Plot skymap with sources + UHECR, obtained from Data object.\n Optionally add either exposure map or exposure limit.\n '''\n # labels\n src_label = self.data.source.label\n uhecr_label = self.data.uhecr.label\n # read in initializations\n omega_src = Direction(self.data.source.unit_vector)\n omega_arr = Direction(self.data.uhecr.unit_vector)\n energy_arr = self.data.uhecr.energy\n\n # convert source / arrival directions to equatorial / galactic\n if coord == \"G\":\n x_src, y_src = omega_src.glons, omega_src.glats\n x_arr, y_arr = omega_arr.glons, omega_arr.glats\n elif coord == \"E\":\n x_src, y_src = omega_src.ras, omega_src.decs\n x_arr, y_arr = omega_arr.ras, omega_arr.decs\n\n Eth = self.data.detector.Eth\n Emax = np.ceil(np.max(energy_arr) / 10.) * 10.\n\n uhecr_color = [lightblue, midblue, darkblue]\n uhecr_cmap = mpl.colors.ListedColormap(uhecr_color)\n energy_bins = np.logspace(np.log(Eth), np.log(Emax), 4, base=np.e)\n uhecr_norm = mpl.colors.BoundaryNorm(energy_bins, uhecr_cmap.N)\n\n # Legend\n legend_elements = [\n mpl.lines.Line2D([0], [0],\n marker='o',\n color='w',\n label='sources',\n markersize=10,\n markerfacecolor='k'),\n mpl.lines.Line2D([0], [0],\n marker='o',\n color='w',\n label='UHECRs',\n markersize=15,\n markerfacecolor=midblue,\n alpha=0.8)\n ]\n\n # create skymap\n skymap = AllSkyMap(projection='moll', lon_0=180)\n skymap.set_gridlines(label_fmt=self.skymap_label_fmt)\n\n # sources\n skymap.scatter(x_src, y_src, s=10.0, color='k', alpha=1.0, zorder=5)\n\n # UHECRs\n for lon, lat, E in np.nditer([x_arr, y_arr, energy_arr]):\n i = np.digitize(E, energy_bins) - 1\n skymap.tissot(lon,\n lat,\n 3.0 + (i * 2),\n 30,\n facecolor=uhecr_cmap.colors[i],\n alpha=0.8,\n zorder=i + 2)\n\n # exposure\n if exposure == \"map\":\n skymap.exposure_map(self.data.detector.params, coord=coord)\n elif exposure == \"limit\":\n skymap.exposure_limit(self.data.detector.limiting_dec.deg,\n coord=coord,\n s=2,\n color=grey,\n alpha=1)\n else:\n raise ValueError(\n \"Exposure plot type {0} not defined.\".format(exposure))\n\n # Annotations\n skymap.legend(handles=legend_elements,\n loc='upper right',\n bbox_to_anchor=(1., 1.),\n fontsize=16,\n fancybox=True)\n skymap.title(\"{0} + {1}\".format(src_label, uhecr_label))\n\n # Colorbar\n cb_ax = plt.axes([0.25, 0.07, .5, .05], frameon=False)\n bar = mpl.colorbar.ColorbarBase(cb_ax,\n norm=uhecr_norm,\n cmap=uhecr_cmap,\n orientation='horizontal',\n drawedges=True,\n alpha=1)\n bar.set_label('$\\hat{E}$ / EeV', color='k', fontsize=16)\n bar.ax.tick_params(labelsize=16)\n\n skymap.save(savefile, bbox_inches='tight')\n\n def eval_association_probs(self):\n '''\n Evaluate the assocation probabilities between sources and UHECR\n from some output file\n '''\n\n # Log probability\n results = Results(self.output_file)\n keys = ['lp']\n chain = results.get_chain(keys)\n logprob = chain['lp'].transpose(1, 2, 0)\n N = np.shape(logprob)[0]\n\n # Account for background component\n Ns = np.shape(logprob)[1] - 1\n\n # Calculate association probabilities for each source-UHECR combo\n uhecr_p = []\n for lp in logprob:\n lps = []\n for src in range(Ns + 1):\n lps.append(np.mean(np.exp(lp[src])))\n\n norm = sum(lps)\n ps = []\n for src in range(Ns + 1):\n ps.append(lps[src] / norm)\n uhecr_p.append(ps)\n\n # Normalise line weights\n pmax = max(max(uhecr_p))\n\n # Find names of dominant sources\n threshold_probability = 0.1\n\n dominant = []\n for p in uhecr_p:\n # for i in range(data.source.N):\n for i in range(Ns):\n if p[i] > threshold_probability:\n dominant.append(i)\n\n seen = set()\n inds = []\n for d in dominant:\n if d not in seen:\n inds.append(d)\n seen.add(d)\n\n # dominant_sources = [self.data.source.name[i] for i in inds]\n\n # sort so that those with largest assossations appear first\n N_assos = {}\n for i in inds:\n N_assos[self.data.source.name[i].decode(\"UTF-8\")] = len(\n np.argwhere([d == i for d in dominant]))\n\n N_assos_sorted = {\n k: v\n for k, v in sorted(N_assos.items(), key=lambda item: item[1])[::-1]\n }\n\n # print(\"Dominant sources: \", [self.data.source.name[i] for i in inds])\n\n return uhecr_p, N_assos_sorted\n\n def association_skymap(self, savefile, coord=\"G\"):\n '''Plot association skymap between sources and UHECRs'''\n\n uhecr_p, N_assos_sorted = self.eval_association_probs()\n\n # labels\n # src_label = self.data.source.label\n\n src_label = \"Swift-BAT\" if self.data.source.label == \"swift_BAT_213\" else self.data.source.label.split(\n \"_\")[0]\n\n # uhecr_label = self.data.uhecr.label\n # read in initializations\n omega_src = Direction(self.data.source.unit_vector)\n omega_arr = Direction(self.data.uhecr.unit_vector)\n energy_arr = self.data.uhecr.energy\n\n # convert source / arrival directions to equatorial / galactic\n if coord == \"G\":\n x_src, y_src = 180. - omega_src.glons, omega_src.glats\n x_arr, y_arr = 180. - omega_arr.glons, omega_arr.glats\n elif coord == \"E\":\n x_src, y_src = omega_src.ras, omega_src.decs\n x_arr, y_arr = omega_arr.ras, omega_arr.decs\n\n Eth = self.data.detector.Eth\n Emax = np.ceil(np.max(energy_arr) / 10.) * 10.\n\n uhecr_color = [lightblue, midblue, darkblue]\n uhecr_cmap = mpl.colors.ListedColormap(uhecr_color)\n energy_bins = np.logspace(np.log(Eth), np.log(Emax), 4, base=np.e)\n uhecr_norm = mpl.colors.BoundaryNorm(energy_bins, uhecr_cmap.N)\n\n # Legend\n legend_elements = [\n mpl.lines.Line2D([0], [0],\n marker='o',\n color='w',\n label=src_label,\n markersize=10,\n markerfacecolor='k'),\n mpl.lines.Line2D([0], [0],\n marker='o',\n color='w',\n label='UHECRs',\n markersize=15,\n markerfacecolor=midblue,\n alpha=0.8)\n ]\n\n # plot\n skymap = AllSkyMap(projection='moll', lon_0=180)\n skymap.set_gridlines(label_fmt=self.skymap_label_fmt)\n\n # sources\n skymap.scatter(x_src, y_src, s=10.0, color='k', alpha=1.0, zorder=5)\n\n # UHECRs\n for lon, lat, E in np.nditer([x_arr, y_arr, energy_arr]):\n i = np.digitize(E, energy_bins) - 1\n skymap.tissot(lon,\n lat,\n 3.0 + (i * 2),\n 30,\n facecolor=uhecr_cmap.colors[i],\n alpha=0.8,\n zorder=i + 2)\n\n # Association\n # add some way to include dominant sources with this association plot later\n pmax = np.max(np.max(uhecr_p))\n\n for i, p in enumerate(uhecr_p):\n for j, psrc in enumerate(p[0:self.data.source.N]):\n if psrc > 0.001:\n skymap.geodesic(x_arr[i],\n y_arr[i],\n x_src[j],\n y_src[j],\n color='k',\n lw=3,\n alpha=psrc / pmax,\n zorder=10)\n\n # Annotations\n skymap.legend(handles=legend_elements,\n loc='upper right',\n bbox_to_anchor=(1.1, 1.),\n fontsize=16,\n fancybox=True)\n\n # exposure limit\n skymap.exposure_limit(\n self.data.detector.limiting_dec.deg,\n coord=coord,\n s=0.5,\n marker=\"o\",\n color=lightpurple,\n alpha=0.01,\n )\n\n # Colorbar\n cb_ax = plt.axes([0.25, 0.07, .5, .05], frameon=True)\n bar = mpl.colorbar.ColorbarBase(cb_ax,\n norm=uhecr_norm,\n cmap=uhecr_cmap,\n orientation='horizontal',\n drawedges=True,\n alpha=1)\n bar.set_label('$\\hat{E}$ / EeV', color='k', fontsize=16)\n bar.ax.tick_params(labelsize=16)\n skymap.save(savefile)\n\n return N_assos_sorted\n\n def corner(self, savefile):\n '''Plot corner plot'''\n\n if self.dtype == \"sim\":\n self.corner_sim(savefile)\n elif self.dtype == \"real\":\n self.corner_data(savefile)\n\n def corner_data(self, savefile):\n '''Plot corner plot of data'''\n # Get chains from joint fit\n results_fit = Results(self.output_file)\n\n # get keys and corresponding labels\n labels = {}\n if self.model_type.find(\"join\") != -1:\n keys = ['alpha', 'B', 'f']\n\n labels['B'] = r'$B$ / $\\mathrm{nG}$'\n labels['alpha'] = r'$\\alpha$'\n labels['f'] = r'$f$'\n\n elif self.model_type == \"arrival_direction\":\n keys = ['kappa', 'L', 'f']\n\n labels['L'] = r'$L$'\n labels['kappa'] = r'$\\kappa$'\n labels['f'] = r'$f$'\n\n chain = results_fit.get_chain(keys)\n\n # Make nicely labelled dict\n chain_for_df = {}\n for key in keys:\n chain_for_df[labels[key]] = chain[key]\n\n # Make ordered dataframe\n df = DataFrame(data=chain_for_df)\n df = df[[labels[keys[0]], labels[keys[1]], labels[keys[2]]]]\n\n corner = Corner(df, color=midblue, contour_color=midblue_contour)\n corner.save(savefile)\n\n def corner_sim(self, savefile, cumul=False, output_files=None):\n\n if cumul:\n self.corner_sim_cumul(output_files, savefile)\n else:\n results_fit = Results(self.output_file)\n\n results_sim = Results(self.sim_output_file)\n truth_keys = ['F0', 'L', 'alpha', 'B', 'f']\n truth = results_sim.get_truths(truth_keys)\n info_keys = ['Eth', 'Eth_sim']\n info = results_sim.get_truths(info_keys)\n\n # Correct for different Eth in sim and fit\n # Also scale to plot units\n flux_scale = (info['Eth'] / info['Eth_sim'])**(1 - truth['alpha'])\n truth['F0'] = truth['F0'] * flux_scale # km^-2 yr^-1\n truth[\n 'L'] = truth['L'][0] * flux_scale / 1.0e39 * 10 # 10^-38 yr^-1\n\n if self.model_type == \"arrival_direction\":\n self.corner_sim_arrival(results_fit, truth, savefile)\n else:\n self.corner_sim_joint(results_fit, truth, savefile)\n\n def corner_sim_arrival(self, results_fit, truth, savefile):\n '''Corner plot for Arrival Direction model'''\n\n keys = ['kappa', 'L', 'f']\n chain = results_fit.get_chain(keys)\n\n chain['L'] = chain['L'] * 10 # 10^-38 yr^-1\n\n labels = {}\n labels['L'] = r'$L$ / $10^{38}$ $\\mathrm{yr}^{-1}$'\n labels['kappa'] = r'$\\kappa$'\n labels['f'] = r'$f$'\n\n truths = [truth[\"L\"], truth[\"f\"]]\n\n # Make nicely labelled dict\n chain_for_df = {}\n for key in keys:\n chain_for_df[labels[key]] = chain[key]\n\n # Make ordered dataframe\n df = DataFrame(data=chain_for_df)\n df = df[[labels['L'], labels['f'], labels['kappa']]]\n\n corner = Corner(df,\n truths,\n color=midblue,\n contour_color=midblue_contour)\n\n corner.save(savefile)\n\n def corner_sim_joint(self, results_fit, truth, savefile):\n '''Plot corner plot resulting from simulations'''\n\n keys = ['F0', 'L', 'alpha', 'B', 'f']\n chain = results_fit.get_chain(keys)\n\n # Convert form Stan units to plot units\n chain['F0'] = chain['F0'] / 1.0e3 # km^-2 yr^-1\n chain['L'] = chain['L'] * 10 # 10^-38 yr^-1\n\n labels = {}\n labels['L'] = r'$L$ / $10^{38}$ $\\mathrm{yr}^{-1}$'\n labels['F0'] = r'$F_0$ / $\\mathrm{km}^{-2} \\ \\mathrm{yr}^{-1}$'\n labels['B'] = r'$B$ / $\\mathrm{nG}$'\n labels['alpha'] = r'$\\alpha$'\n labels['f'] = r'$f$'\n\n params = np.column_stack([chain[key] for key in keys])\n truths = [truth[key] for key in keys]\n\n # Make nicely labelled dict\n chain_for_df = {}\n for key in keys:\n chain_for_df[labels[key]] = chain[key]\n\n # Make ordered dataframe\n df = DataFrame(data=chain_for_df)\n df = df[[\n labels['F0'], labels['L'], labels['alpha'], labels['B'],\n labels['f']\n ]]\n\n corner = Corner(df, truths, color=purple, contour_color=purple_contour)\n corner.save(savefile)\n\n def corner_sim_cumul(self, output_files, savefile):\n '''Cumulative distribution of corner plots from simulation'''\n\n keys = ['F0', 'L', 'alpha', 'B', 'f']\n chain_avgs = {key: 0 for key in keys}\n chain_list = []\n Nseeds = len(output_files)\n\n # get chains for each output file\n # ignores self.outpuf_file\n for output_file in output_files:\n chain = Results(output_file).get_chain(keys)\n\n chain_list.append(chain)\n\n # evaluate averaged value for each seed\n for key in keys:\n chain_sum = 0\n for i in range(Nseeds):\n chain_sum += chain_list[i][key]\n\n chain_sum /= Nseeds\n\n chain_avgs[key] = chain_sum\n\n # Convert form Stan units to plot units\n chain_avgs['F0'] = chain_avgs['F0'] / 1.0e3 # km^-2 yr^-1\n chain_avgs['L'] = chain_avgs['L'] * 10 # 10^-38 yr^-1\n\n # Get truths from simulation\n results_sim = Results(self.sim_output_file)\n\n truth_keys = ['F0', 'L', 'alpha', 'B', 'f']\n truth = results_sim.get_truths(truth_keys)\n info_keys = ['Eth', 'Eth_sim']\n info = results_sim.get_truths(info_keys)\n\n # Correct for different Eth in sim and fit\n # Also scale to plot units\n flux_scale = (info['Eth'] / info['Eth_sim'])**(1 - truth['alpha'])\n truth['F0'] = truth['F0'] * flux_scale # km^-2 yr^-1\n truth['L'] = truth['L'][0] * flux_scale / 1.0e39 * 10 # 10^-38 yr^-1\n\n labels = {}\n labels['L'] = r'$L$ / $10^{38}$ $\\mathrm{yr}^{-1}$'\n labels['F0'] = r'$F_0$ / $\\mathrm{km}^{-2} \\ \\mathrm{yr}^{-1}$'\n labels['B'] = r'$B$ / $\\mathrm{nG}$'\n labels['alpha'] = r'$\\alpha$'\n labels['f'] = r'$f$'\n\n params = np.column_stack([chain_avgs[key] for key in keys])\n truths = [truth[key] for key in keys]\n\n # Make nicely labelled dict\n chain_for_df = {}\n for key in keys:\n chain_for_df[labels[key]] = chain_avgs[key]\n\n # Make ordered dataframe\n df = DataFrame(data=chain_for_df)\n df = df[[\n labels['F0'], labels['L'], labels['alpha'], labels['B'],\n labels['f']\n ]]\n\n corner = Corner(df, truths, color=purple, contour_color=purple_contour)\n corner.save(savefile)\n\n\nclass SourceUHECRDist():\n def __init__(self, figsize=(6, 4), sim_output_file=None):\n '''Class that organizes plotting of source-UHECR association fraction distribution'''\n self.fig, self.ax = plt.subplots(figsize=figsize)\n\n self.color_list = [grey, lightpurple, lightblue]\n\n self.sim_output_file = sim_output_file\n\n def get_fs(self, fname_list, cumul=False):\n '''Get source-UHECR association fraction from output files'''\n\n self.f_list = []\n\n if cumul: # evaluate cumulative distribution\n # then each element in fname_list must be a list of fnames with different models\n # each of this list will contain fnames with different seeds\n for fname_models_list in fname_list:\n f_list = []\n for output_file in fname_models_list:\n f_i = Results(output_file).get_chain(['f'])['f']\n f_list.append(f_i)\n\n f_avg = np.mean(np.array(f_list), axis=0)\n self.f_list.append(f_avg)\n\n else:\n for output_file in fname_list:\n try:\n f_i = Results(output_file).get_chain(['f'])['f']\n except KeyError:\n f_i = np.zeros(100)\n self.f_list.append(f_i)\n\n return self.f_list\n\n def plotdist(self, labels, extend=False, title=None):\n '''Plot the distribution'''\n for i, label in enumerate(labels):\n # for arrival_direction -> arrival direction\n label = label.replace(\"_\", \" \") if \"_\" in label else label\n\n sns.distplot(self.f_list[i],\n hist=False,\n kde_kws={\n 'shade': True,\n 'lw': 2,\n 'zorder': i\n },\n color=self.color_list[i],\n label=label)\n\n if self.sim_output_file is not None:\n f_true = Results(self.sim_output_file).get_truths(['f'])['f']\n self.ax.axvline(f_true,\n 0,\n 10,\n color='k',\n zorder=3,\n lw=2.,\n alpha=0.7)\n\n self._annotate(title=title, extend=extend)\n\n def _annotate(self, title=None, extend=False):\n '''Plot the annotations'''\n # annotations\n self.ax.set_xlim(0, 1)\n if title:\n self.ax.set_title(title, fontsize=24)\n self.ax.set_xlabel('$f$')\n self.ax.set_ylabel('$P(f | \\hat{E}, \\hat{\\omega})$')\n\n legend_loc = (1.6, 1) if extend else (1.3, 1)\n self.ax.legend(fontsize=22, bbox_to_anchor=legend_loc)\n\n def save(self, savefile):\n '''Save the distribution'''\n # save\n self.fig.savefig(savefile, bbox_inches='tight')", "meta": {"hexsha": "d7d0f098b3cfb75f51c36733239715eaada3db3f", "size": 24667, "ext": "py", "lang": "Python", "max_stars_repo_path": "uhecr_model/legacy/output_figures_old.py", "max_stars_repo_name": "uhecr-project/uhecr_model", "max_stars_repo_head_hexsha": "8a2e8ab6f11cd2700f6455dff54c746cf3ffb143", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "uhecr_model/legacy/output_figures_old.py", "max_issues_repo_name": "uhecr-project/uhecr_model", "max_issues_repo_head_hexsha": "8a2e8ab6f11cd2700f6455dff54c746cf3ffb143", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-07-12T08:01:11.000Z", "max_issues_repo_issues_event_max_datetime": "2021-08-04T03:01:30.000Z", "max_forks_repo_path": "uhecr_model/legacy/output_figures_old.py", "max_forks_repo_name": "uhecr-project/uhecr_model", "max_forks_repo_head_hexsha": "8a2e8ab6f11cd2700f6455dff54c746cf3ffb143", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.3820058997, "max_line_length": 146, "alphanum_fraction": 0.5242226456, "include": true, "reason": "import numpy,from astropy", "num_tokens": 5816, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5888891163376235, "lm_q2_score": 0.3311197396289915, "lm_q1q2_score": 0.19499281087206077}} {"text": "# coding: utf-8\n\nimport numpy as np\n\nfrom sympy import IndexedBase, Indexed\nfrom sympy import Mul, Matrix, Expr\nfrom sympy import Add, And, StrictLessThan, Eq\nfrom sympy import Abs, Not, floor\nfrom sympy import Symbol, Idx\nfrom sympy import Basic, Function\nfrom sympy.simplify import cse_main\nfrom sympy.core.containers import Tuple\n\n\nfrom psydac.pyccel.ast.core import Assign, Product, AugAssign, For\nfrom psydac.pyccel.ast.core import Variable, IndexedVariable, IndexedElement\nfrom psydac.pyccel.ast.core import Slice, String, ValuedArgument\nfrom psydac.pyccel.ast.core import EmptyNode, Import, While, Return, If\nfrom psydac.pyccel.ast.core import CodeBlock, FunctionDef, Comment\nfrom psydac.pyccel.ast.builtins import Range\n\nfrom sympde.topology import (dx1, dx2, dx3)\nfrom sympde.topology import SymbolicExpr\nfrom sympde.topology import LogicalExpr, Jacobian\nfrom sympde.expr.evaluation import _split_test_function\nfrom sympde.calculus.matrices import SymbolicDeterminant\nfrom sympde.topology import SymbolicWeightedVolume, InterfaceMapping\nfrom sympde.topology import Boundary, NormalVector, Interface\n\nfrom sympde.topology.derivatives import get_index_logical_derivatives\n\nfrom .nodes import AtomicNode\nfrom .nodes import BasisAtom\nfrom .nodes import PhysicalBasisValue\nfrom .nodes import LogicalBasisValue\nfrom .nodes import TensorQuadrature\nfrom .nodes import LocalTensorQuadratureBasis\nfrom .nodes import LocalTensorQuadratureTestBasis\nfrom .nodes import LocalTensorQuadratureTrialBasis\nfrom .nodes import GlobalTensorQuadratureTestBasis\nfrom .nodes import GlobalTensorQuadratureTrialBasis\nfrom .nodes import GlobalTensorQuadratureBasis\nfrom .nodes import TensorQuadratureBasis\nfrom .nodes import SplitArray\nfrom .nodes import Reduction\nfrom .nodes import LogicalValueNode\nfrom .nodes import TensorIteration\nfrom .nodes import TensorIterator\nfrom .nodes import TensorGenerator\nfrom .nodes import ProductIteration\nfrom .nodes import ProductIterator\nfrom .nodes import ProductGenerator\nfrom .nodes import StencilMatrixLocalBasis\nfrom .nodes import StencilMatrixGlobalBasis, ScalarLocalBasis\nfrom .nodes import BlockStencilMatrixLocalBasis\nfrom .nodes import BlockStencilMatrixGlobalBasis\nfrom .nodes import BlockStencilVectorLocalBasis, BlockScalarLocalBasis\nfrom .nodes import BlockStencilVectorGlobalBasis\nfrom .nodes import StencilVectorLocalBasis\nfrom .nodes import StencilVectorGlobalBasis\nfrom .nodes import GlobalElementBasis\nfrom .nodes import LocalElementBasis\nfrom .nodes import TensorQuadratureTestBasis, TensorQuadratureTrialBasis\nfrom .nodes import Span\nfrom .nodes import Loop\nfrom .nodes import WeightedVolumeQuadrature\nfrom .nodes import LengthDofTest\n\nfrom .nodes import index_outer_dof_test\nfrom .nodes import index_dof_test, index_dof_trial\nfrom .nodes import index_deriv, Max, Min\n\nfrom .nodes import Zeros, ZerosLike, Array\nfrom .fem import expand, expand_hdiv_hcurl\nfrom psydac.api.ast.utilities import variables, math_atoms_as_str\nfrom psydac.api.utilities import flatten\nfrom psydac.api.ast.utilities import build_pythran_types_header\nfrom psydac.api.ast.utilities import build_pyccel_types_decorator\n\n#==============================================================================\n# TODO move it\nimport string\nimport random\ndef random_string( n ):\n chars = string.ascii_lowercase + string.digits\n selector = random.SystemRandom()\n return ''.join( selector.choice( chars ) for _ in range( n ) )\n\nclass Shape(Basic):\n @property\n def arg(self):\n return self._args[0]\n\ndef is_scalar_array(var):\n indices = var.indices\n for ind in indices:\n if isinstance(ind, Slice):\n return False\n return True\n#==============================================================================\n\ndef parse(expr, settings, backend=None):\n \"\"\"\n This function takes a Psydac Ast and returns a Pyccel Ast\n\n Parameters\n ----------\n\n expr: \n psydac ast node\n\n settings : \n dictionary that continas number of dimension, mappings and target if provided\n\n Returns\n -------\n\n ast : Pyccel Ast\n pyccel abstract syntax tree that can be translated into a Python code\n\n \"\"\"\n psy_parser = Parser(settings, backend)\n ast = psy_parser.doit(expr)\n return ast\n\n#==============================================================================\nclass Parser(object):\n \"\"\"\n This class takes a Psyadac Ast and transforms it to a Pyccel Ast\n by calling the Parser.doit method\n\n \"\"\"\n def __init__(self, settings, backend=None):\n\n settings = settings.copy()\n\n dim = settings.pop('dim', None)\n if dim is None:\n raise ValueError('dim not provided')\n\n self._dim = dim\n # ...\n\n nderiv = settings.pop('nderiv', None)\n if nderiv is None:\n raise ValueError('nderiv not provided')\n\n self._nderiv = nderiv\n\n target = settings.pop('target', None)\n if target is None:\n raise ValueError('target not provided')\n\n self._target = target\n\n self._mapping = settings.pop('mapping', None)\n\n self._settings = settings\n self.backend = backend\n\n # TODO improve\n self.indices = {}\n self.shapes = {}\n self.functions = {}\n self.variables = {}\n self.arguments = {}\n self.allocated = {}\n self._math_functions = ()\n \n\n @property\n def settings(self):\n return self._settings\n\n @property\n def dim(self):\n return self._dim\n\n @property\n def nderiv(self):\n return self._nderiv\n\n @property\n def mapping(self):\n return self._mapping\n\n @property\n def target(self):\n return self._target\n\n def doit(self, expr, **settings):\n return self._visit(expr, **settings)\n\n def insert_variables(self, *args):\n args = flatten(args)\n for arg in args:\n self.variables[str(arg)] = arg\n\n def get_shape(self, expr):\n lhs = expr.lhs\n rhs = expr.rhs\n\n rhs_indices = []\n if isinstance(rhs, (Indexed, IndexedElement)):\n rhs_indices = rhs.indices\n lhs_indices = lhs.indices\n\n #TODO fix probleme of indices we should have a unique way of getting indices\n lhs_indices = [None if isinstance(i, Slice) and i.start is None else i for i in lhs_indices]\n rhs_indices = [None if isinstance(i, Slice) and i.start is None else i for i in rhs_indices]\n shape_lhs = None\n shape = []\n\n if all(i is None for i in lhs_indices):\n for i in rhs_indices:\n if i is None:\n shape.append(None)\n elif str(i) in self.indices:\n shape.append(self.indices[str(i)]-1)\n elif isinstance(i, Slice) and i.start and i.end:\n shape.append(i.end-i.start)\n if len(shape) == len(rhs_indices):\n if any(s is None for s in shape):\n shape = tuple(Slice(None,None) if i is None else 0 for i in shape)\n rhs = rhs.base\n shape_lhs = Shape(rhs[shape])\n else:\n shape_lhs = tuple(shape)\n\n elif all(i is not None for i in lhs_indices):\n for i in lhs_indices:\n if str(i) in self.indices:\n shape.append(self.indices[str(i)])\n if len(shape) == len(lhs_indices):\n shape_lhs = tuple(shape)\n\n return shape_lhs\n\n def _visit(self, expr, **settings):\n classes = type(expr).__mro__\n for cls in classes:\n annotation_method = '_visit_' + cls.__name__\n if hasattr(self, annotation_method):\n return getattr(self, annotation_method)(expr, **settings)\n # Unknown object, we raise an error.\n raise NotImplementedError('{}'.format(type(expr)))\n\n # ....................................................\n def _visit_VectorAssign(self, expr, **kwargs):\n lhs = self._visit(expr.lhs)\n rhs = self._visit(expr.rhs)\n if expr.op is None:\n return [Assign(l,r) for l,r in zip(lhs, rhs) if l is not None and r is not None]\n else:\n return [AugAssign(l,expr.op, r) for l,r in zip(lhs, rhs) if l is not None and r is not None]\n # ....................................................\n def _visit_Assign(self, expr, **kwargs):\n\n lhs = self._visit(expr.lhs)\n rhs = self._visit(expr.rhs)\n\n # ... extract slices from rhs\n slices = []\n if isinstance(rhs, IndexedElement):\n slices = [i for i in rhs.indices if isinstance(i, Slice)]\n # ...\n\n # ... update lhs with slices\n if len(slices) > 0:\n # TODO add assert on type lhs\n if isinstance(lhs, (IndexedBase, IndexedVariable)):\n lhs = lhs[slices]\n\n elif isinstance(lhs, Symbol):\n lhs = IndexedBase(lhs.name)[slices]\n\n expr = Assign(lhs, rhs)\n # ..\n\n if isinstance(lhs, (IndexedElement, Indexed)):\n name = str(lhs.base)\n\n shape = self.get_shape(expr)\n if shape:\n self.shapes[name] = shape\n\n return expr\n\n # ....................................................\n def _visit_AugAssign(self, expr, **kwargs):\n\n lhs = self._visit(expr.lhs)\n rhs = self._visit(expr.rhs)\n op = expr.op\n\n # ... extract slices from rhs\n slices = []\n if isinstance(rhs, IndexedElement):\n slices = [i for i in indices if isinstance(i, Slice)]\n # ...\n\n # ... update lhs with slices\n if len(slices) > 0:\n # TODO add assert on type lhs\n if isinstance(lhs, (IndexedBase, IndexedVariable)):\n lhs = lhs[slices]\n else:\n raise NotImplementedError('{}'.format(type(lhs)))\n\n expr = AugAssign(lhs,op,rhs)\n # ...\n if isinstance(lhs, (IndexedElement,Indexed)):\n name = str(lhs.base)\n\n shape = self.get_shape(expr)\n if shape:\n self.shapes[name] = shape\n\n return expr\n\n def _visit_Allocate(self, expr, **kwargs):\n arr = self._visit(expr.array)\n shape = [self._visit(i) for i in expr.shape]\n self.allocated[arr.name] = arr\n return Assign(arr, Zeros(tuple(shape), arr.dtype))\n\n # ....................................................\n def _visit_AddNode(self, expr, **kwargs):\n return self._visit_Add(expr)\n\n def _visit_MulNode(self, expr, **kwargs):\n return self._visit_Mul(expr)\n\n # ....................................................\n def _visit_IntDivNode(self, expr, **kwargs):\n args = [self._visit(a) for a in expr.args]\n return args[0]//args[1]\n\n # ....................................................\n def _visit_AndNode(self, expr, **kwargs):\n args = [self._visit(a) for a in expr.args]\n return And(*args)\n\n def _visit_NotNode(self, expr, **kwargs):\n return Not(self._visit(expr.args[0]))\n\n def _visit_EqNode(self, expr, **kwargs):\n return Eq(self._visit(expr.args[0]), self._visit(expr.args[1]))\n\n # ....................................................\n def _visit_StrictLessThanNode(self, expr, **kwargs):\n a = self._visit(expr.args[0])\n b = self._visit(expr.args[1])\n return StrictLessThan(a,b)\n\n # ....................................................\n def _visit_Add(self, expr, **kwargs):\n args = [self._visit(i) for i in expr.args]\n tuples = [e for e in args if isinstance(e, tuple)]\n args = [e for e in args if not e in tuples]\n expr = Add(*args)\n if tuples:\n args = list(tuples[0])\n for e in tuples[1:]:\n args = [args[i]+e[i] for i in range(len(args))]\n tuples = tuple(Add(expr,e) for e in args)\n return tuples\n return expr\n\n # ....................................................\n def _visit_Mul(self, expr, **kwargs):\n args = [self._visit(i) for i in expr.args]\n return Mul(*args)\n\n # ....................................................\n def _visit_Symbol(self, expr, **kwargs):\n return expr\n\n # ....................................................\n def _visit_Variable(self, expr, **kwargs):\n return expr\n\n # ....................................................\n def _visit_IndexedVariable(self, expr, **kwargs):\n return expr\n\n # ....................................................\n def _visit_Tuple(self, expr, **kwargs):\n args = [self._visit(i) for i in expr]\n return Tuple(*args)\n\n def _visit_Array(self, expr, **kwargs):\n data = self._visit(expr.data)\n dtype = expr.dtype\n return Array(data, dtype=dtype)\n\n # ....................................................\n def _visit_Block(self, expr, **kwargs):\n body = [self._visit(i) for i in expr.body]\n body = flatten(body)\n if len(body) == 1:\n return body[0]\n\n else:\n return CodeBlock(body)\n\n # ....................................................\n def _visit_ParallelBlock(self, expr, **kwargs):\n body = [self._visit(i) for i in expr.body]\n body = list(flatten(body))\n default = expr.default\n shared = [self._visit(i) for i in expr.shared]\n private = [self._visit(i) for i in expr.private]\n firstprivate = [self._visit(i) for i in expr.firstprivate]\n lastprivate = [self._visit(i) for i in expr.lastprivate]\n shared = flatten([list(i.values())[0] if isinstance(i, dict) else i for i in shared])\n private = flatten([list(i.values())[0] if isinstance(i, dict) else i for i in private])\n firstprivate = flatten([list(i.values())[0] if isinstance(i, dict)else i for i in firstprivate])\n lastprivate = flatten([list(i.values())[0] if isinstance(i, dict) else i for i in lastprivate])\n txt = '#$ omp parallel default({}) &\\n'.format(default)\n txt += '#$ shared({}) &\\n'.format(','.join(str(i) for i in shared if i)) if shared else ''\n txt += '#$ private({}) &\\n'.format(','.join(str(i) for i in private if i)) if private else ''\n txt += '#$ firstprivate({}) &\\n'.format(','.join(str(i) for i in firstprivate if i)) if firstprivate else ''\n txt += '#$ lastprivate({})'.format(','.join(str(i) for i in lastprivate if i)) if lastprivate else ''\n cmt = [Comment(txt.rstrip().rstrip('&'))]\n endcmt = [Comment('#$ omp end parallel')]\n return CodeBlock(cmt + body + endcmt)\n # ....................................................\n def _visit_DefNode(self, expr, **kwargs):\n\n args = expr.arguments.copy()\n f_args = ()\n\n tests_basis = args.pop('tests_basis')\n trial_basis = args.pop('trial_basis',[])\n\n g_span = args.pop('spans')\n g_quad = args.pop('quads')\n\n lengths_tests = args.pop('tests_degrees')\n lengths_trials = args.pop('trials_degrees', {})\n\n lengths = args.pop('quads_degree')\n g_pads = args.pop('global_pads')\n l_pads = args.pop('local_pads', None)\n\n mats = args.pop('mats')\n \n map_coeffs = args.pop('mapping', None)\n map_degrees = args.pop('mapping_degrees', None)\n map_basis = args.pop('mapping_basis', None)\n map_span = args.pop('mapping_spans', None)\n thread_args = args.pop('thread_args', None)\n\n if map_coeffs:\n map_coeffs = map_coeffs\n map_degrees = [map_degrees]\n map_basis = [map_basis]\n map_span = [map_span]\n else:\n map_coeffs = []\n map_degrees = []\n map_basis = []\n map_span = []\n\n constants = args.pop('constants', None)\n\n f_coeffs = args.pop('f_coeffs', None)\n\n starts = args.pop('starts', [])\n ends = args.pop('ends', [])\n if f_coeffs:\n f_span = args.pop('f_span', [])\n f_basis = args.pop('field_basis', [])\n f_degrees = args.pop('fields_degrees', [])\n f_pads = args.pop('f_pads', [])\n f_args = (*f_basis, *f_span, *f_degrees, *f_pads, *f_coeffs)\n\n\n args = [*tests_basis, *trial_basis, *map_basis, *g_span, *map_span, *g_quad, *lengths_tests.values(), *lengths_trials.values(), *map_degrees, *lengths, *g_pads, *map_coeffs]\n\n if mats:\n exprs = [mat.expr for mat in mats]\n\n mats = [self._visit(mat) for mat in mats]\n mats = [[a for a,e in zip(mat[:],expr[:]) if e] for mat,expr in zip(mats, exprs)]\n mats = flatten(mats)\n\n args = [self._visit(i, **kwargs) for i in args]\n\n args = [tuple(arg.values())[0] if isinstance(arg, dict) else arg for arg in args]\n arguments = flatten(args) + mats\n\n if constants:\n arguments += [self._visit(i, **kwargs) for i in constants]\n\n if f_args:\n f_args = [self._visit(i, **kwargs) for i in f_args]\n f_args = [tuple(arg.values())[0] if isinstance(arg, dict) else arg for arg in f_args]\n arguments += flatten(f_args)\n\n arguments += starts + ends\n\n if thread_args:\n arguments += flatten([self._visit(i, **kwargs) for i in thread_args])\n\n body = flatten(tuple(self._visit(i, **kwargs) for i in expr.body))\n\n inits = []\n for k,i in self.shapes.items():\n var = self.variables[k]\n if var in arguments or var.name in self.allocated:\n continue\n if isinstance(i, Shape):\n inits.append(Assign(var, ZerosLike(i.arg)))\n else:\n inits.append(Assign(var, Zeros(i)))\n\n inits.append(EmptyNode())\n body = tuple(inits) + body\n name = expr.name\n numpy_imports = ('array', 'zeros', 'zeros_like', 'floor')\n math_imports = (*self._math_functions,)\n imports = [Import('numpy', numpy_imports)] + \\\n ([Import('math', math_imports)] if math_imports else []) + \\\n [*expr.imports]\n results = [self._visit(a) for a in expr.results]\n\n if self.backend['name'] == 'pyccel':\n a = [String(str(i)) for i in build_pyccel_types_decorator(arguments)]\n decorators = {'types': Function('types')(*a)}\n elif self.backend['name'] == 'numba':\n decorators = {'njit': Function('njit')(ValuedArgument(Symbol('fastmath'), self.backend['fastmath']))}\n elif self.backend['name'] == 'pythran':\n header = build_pythran_types_header(name, arguments)\n else:\n decorators = {}\n\n if self.backend['name'] == 'numba':\n func = FunctionDef(name, arguments, results, body, decorators=decorators)\n stmts = CodeBlock([*imports , func])\n else:\n func = FunctionDef(name, arguments, results, body, imports=imports, decorators=decorators)\n stmts = func\n\n self.functions[name] = func\n return stmts\n\n def _visit_EvalField(self, expr, **kwargs):\n g_coeffs = expr.g_coeffs\n l_coeffs = expr.l_coeffs\n tests = list(expr._tests)\n ex_tests = list(expand(tests))\n mats = expr.atoms\n dim = self._dim\n lhs_slices = [Slice(None,None)]*dim\n mats = [self._visit(mat, **kwargs) for mat in mats]\n inits = {mat:Assign(mat[lhs_slices], 0.) for mat in mats}\n body = self._visit(expr.body, **kwargs)\n stmts = {}\n pads = self._visit_Pads(expr.pads)\n\n for l_coeff,g_coeff in zip(l_coeffs, g_coeffs):\n basis = g_coeff.test\n index = ex_tests.index(basis)\n basis = basis if basis in tests else basis.base\n degrees = self._visit_LengthDofTest(LengthDofTest(basis))\n spans = flatten(self._visit_Span(Span(basis))[basis])\n rhs_starts = [spans[i]-degrees[i] + pads[index,0][i] for i in range(dim)]\n rhs_ends = [spans[i]+pads[index,0][i]+1 for i in range(dim)]\n rhs_slices = [Slice(s, e) for s,e in zip(rhs_starts, rhs_ends)]\n l_coeff = self._visit(l_coeff, **kwargs)\n g_coeff = self._visit(g_coeff, **kwargs)\n stmt = self._visit_Assign(Assign(l_coeff[lhs_slices], g_coeff[rhs_slices]), **kwargs)\n stmts[stmt.lhs.base] = stmt\n return CodeBlock([*inits.values() , *stmts.values() , body])\n\n def _visit_EvalMapping(self, expr, **kwargs):\n if self._mapping.is_analytical:\n return EmptyNode()\n values = expr.values\n coeffs = expr.coeffs\n l_coeffs = expr.local_coeffs\n stmts = []\n dim = self._dim\n test = coeffs[0].test\n lhs_slices = [Slice(None,None)]*dim\n multiplicity = expr.multiplicity\n pads = expr.pads\n for coeff, l_coeff in zip(coeffs, l_coeffs):\n spans = flatten(self._visit_Span(Span(test))[test])\n degrees = self._visit_LengthDofTest(LengthDofTest(test))\n coeff = self._visit(coeff)\n l_coeff = self._visit(l_coeff)\n rhs_starts = [multiplicity[i]*pads[i] + spans[i]-degrees[i] for i in range(dim)]\n rhs_ends = [multiplicity[i]*pads[i] + spans[i]+1 for i in range(dim)]\n rhs_slices = [Slice(s, e) for s,e in zip(rhs_starts, rhs_ends)]\n stmt = self._visit_Assign(Assign(l_coeff[lhs_slices], coeff[rhs_slices]), **kwargs)\n stmts.append(stmt)\n\n inits = []\n for val in values:\n val = self._visit(val, **kwargs)\n inits.append(Assign(val[lhs_slices], 0.))\n loop = self._visit(expr.loop, **kwargs)\n stmts.append(loop)\n return CodeBlock(inits+stmts)\n\n # ....................................................\n def _visit_Grid(self, expr, **kwargs):\n raise NotImplementedError('TODO')\n\n # ....................................................\n def _visit_Element(self, expr, **kwargs):\n raise NotImplementedError('TODO')\n\n # ....................................................\n def _visit_GlobalTensorQuadratureGrid(self, expr, **kwargs):\n dim = self.dim\n rank = expr.rank\n\n names = 'global_x1:%s'%(dim+1)\n points = variables(names, dtype='real', rank=rank, cls=IndexedVariable)\n\n if expr.weights:\n names = 'global_w1:%s'%(dim+1)\n weights = variables(names, dtype='real', rank=rank, cls=IndexedVariable)\n\n # gather by axis\n targets = tuple(zip(points, weights))\n else:\n weights = []\n targets = tuple(zip(points))\n\n self.insert_variables(*points, *weights)\n\n return {0: targets}\n\n # ....................................................\n def _visit_LocalTensorQuadratureGrid(self, expr, **kwargs):\n dim = self.dim\n rank = expr.rank\n\n names = 'local_x1:%s'%(dim+1)\n points = variables(names, dtype='real', rank=rank, cls=IndexedVariable)\n\n if expr.weights:\n names = 'local_w1:%s'%(dim+1)\n weights = variables(names, dtype='real', rank=rank, cls=IndexedVariable)\n\n # gather by axis\n targets = tuple(zip(points, weights))\n else:\n weights = []\n targets = tuple(zip(points))\n\n self.insert_variables(*points, *weights)\n\n return {0: targets}\n\n # ....................................................\n def _visit_PlusGlobalTensorQuadratureGrid(self, expr, **kwargs):\n dim = self.dim\n rank = expr.rank\n\n names = 'global_x1:%s_plus'%(dim+1)\n points = variables(names, dtype='real', rank=rank, cls=IndexedVariable)\n\n # gather by axis\n self.insert_variables(*points)\n\n points = tuple(zip(points))\n return dict([(0,points)])\n\n # ....................................................\n def _visit_PlusLocalTensorQuadratureGrid(self, expr, **kwargs):\n dim = self.dim\n rank = expr.rank\n\n names = 'local_x1:%s_plus'%(dim+1)\n points = variables(names, dtype='real', rank=rank, cls=IndexedVariable)\n\n self.insert_variables(*points)\n\n points = tuple(zip(points))\n return dict([(0,points)])\n\n # ....................................................\n def _visit_TensorQuadrature(self, expr, **kwargs):\n dim = self.dim\n names = 'x1:%s'%(dim+1)\n points = variables(names, dtype='real', cls=Variable)\n\n if expr.weights:\n names = 'w1:%s'%(dim+1)\n weights = variables(names, dtype='real', cls=Variable)\n\n # gather by axis\n targets = tuple(zip(points, weights))\n else:\n weights = []\n targets = tuple(zip(points))\n\n self.insert_variables(*points, *weights)\n\n return {0: targets}\n\n # ....................................................\n def _visit_PlusTensorQuadrature(self, expr, **kwargs):\n dim = self.dim\n names = 'x1:%s_plus'%(dim+1)\n points = variables(names, dtype='real', cls=Variable)\n\n targets = tuple(zip(points))\n\n self.insert_variables(*points)\n\n return dict([(0,targets)])\n\n # ....................................................\n def _visit_GlobalThreadSpan(self, expr, **kwargs):\n dim = self.dim\n rank = expr.rank\n target = SymbolicExpr(expr.target)\n name = 'thread_spans_{}'.format(target)\n targets = variables('{}1:{}'.format(name, dim+1), dtype='int', rank=1, cls=IndexedVariable)\n if expr.index is not None:\n return targets[expr.index]\n return targets\n\n # ....................................................\n def _visit_GlobalThreadStarts(self, expr, **kwargs):\n dim = self.dim\n targets = variables('global_thread_starts_1:{}'.format(dim+1), dtype='int', rank=1, cls=IndexedVariable)\n if expr.index is not None:\n return targets[expr.index]\n return targets\n\n # ....................................................\n def _visit_GlobalThreadEnds(self, expr, **kwargs):\n dim = self.dim\n targets = variables('global_thread_ends_1:{}'.format(dim+1), dtype='int', rank=1, cls=IndexedVariable)\n if expr.index is not None:\n return targets[expr.index]\n return targets\n\n # ....................................................\n def _visit_GlobalThreadSizes(self, expr, **kwargs):\n dim = self.dim\n targets = variables('global_thread_size_1:{}'.format(dim+1), dtype='int')\n if expr.index is not None:\n return targets[expr.index]\n return targets\n\n # ....................................................\n def _visit_LocalThreadStarts(self, expr, **kwargs):\n dim = self.dim\n targets = variables('local_thread_starts_1:{}'.format(dim+1), dtype='int', rank=1, cls=IndexedVariable)\n if expr.index is not None:\n return targets[expr.index]\n return targets\n\n # ....................................................\n def _visit_LocalThreadEnds(self, expr, **kwargs):\n dim = self.dim\n targets = variables('local_thread_ends_1:{}'.format(dim+1), dtype='int', rank=1, cls=IndexedVariable)\n if expr.index is not None:\n return targets[expr.index]\n return targets\n\n # ....................................................\n def _visit_MatrixQuadrature(self, expr, **kwargs):\n rank = self._visit(expr.rank)\n target = SymbolicExpr(expr.target)\n\n name = 'arr_{}'.format(target.name)\n var = IndexedVariable(name, dtype='real', rank=rank)\n self.insert_variables(var)\n return var\n # ....................................................\n def _visit_GlobalTensorQuadratureBasis(self, expr, **kwargs):\n # TODO add label\n dim = self.dim\n rank = expr.rank\n unique_scalar_space = expr.unique_scalar_space\n is_scalar = expr.is_scalar\n target = expr.target\n label = str(SymbolicExpr(target))\n if isinstance(expr, GlobalTensorQuadratureTestBasis):\n if not unique_scalar_space:\n names = 'global_test_basis_{label}(1:{j})_1:{i}'.format(label=label,i=dim+1,j=dim+1)\n else:\n names = 'global_test_basis_{label}_1:{i}'.format(label=label,i=dim+1)\n\n elif isinstance(expr, GlobalTensorQuadratureTrialBasis):\n if not unique_scalar_space:\n names = 'global_trial_basis_{label}(1:{j})_1:{i}'.format(label=label,i=dim+1,j=dim+1)\n else:\n names = 'global_trial_basis_{label}_1:{i}'.format(label=label,i=dim+1)\n\n else:\n if not unique_scalar_space:\n names = 'global_basis_{label}(1:{j})_1:{i}'.format(label=label,i=dim+1,j=dim+1)\n else:\n names = 'global_basis_{label}_1:{i}'.format(label=label,i=dim+1)\n\n targets = variables(names, dtype='real', rank=rank, cls=IndexedVariable)\n\n self.insert_variables(*targets)\n\n arrays = {}\n if unique_scalar_space and not is_scalar:\n for i in range(dim):\n arrays[target[i]] = tuple(zip(targets))\n elif not unique_scalar_space:\n for i in range(dim):\n arrays[target[i]] = tuple(zip(targets[i::dim]))\n else:\n arrays[target] = tuple(zip(targets))\n return arrays\n # ....................................................\n def _visit_LocalTensorQuadratureBasis(self, expr, **kwargs):\n dim = self.dim\n rank = expr.rank\n unique_scalar_space = expr.unique_scalar_space\n is_scalar = expr.is_scalar\n target = expr.target\n label = str(SymbolicExpr(target))\n if isinstance(expr, LocalTensorQuadratureTestBasis):\n if not unique_scalar_space:\n names = 'local_test_basis_{label}(1:{j})_1:{i}'.format(label=label,i=dim+1,j=dim+1)\n else:\n names = 'local_test_basis_{label}_1:{i}'.format(label=label,i=dim+1)\n\n elif isinstance(expr, LocalTensorQuadratureTrialBasis):\n if not unique_scalar_space:\n names = 'local_trial_basis_{label}(1:{j})_1:{i}'.format(label=label,i=dim+1,j=dim+1)\n else:\n names = 'local_trial_basis_{label}_1:{i}'.format(label=label,i=dim+1)\n\n else:\n if not unique_scalar_space:\n names = 'local_basis_{label}(1:{j})_1:{i}'.format(label=label,i=dim+1,j=dim+1)\n else:\n names = 'local_basis_{label}_1:{i}'.format(label=label,i=dim+1)\n\n targets = variables(names, dtype='real', rank=rank, cls=IndexedVariable)\n self.insert_variables(*targets)\n\n arrays = {}\n if unique_scalar_space and not is_scalar:\n for i in range(dim):\n arrays[target[i]] = tuple(zip(targets))\n elif not unique_scalar_space:\n for i in range(dim):\n arrays[target[i]] = tuple(zip(targets[i::dim]))\n else:\n arrays[target] = tuple(zip(targets))\n return arrays\n\n # ....................................................\n def _visit_TensorQuadratureBasis(self, expr, **kwargs):\n dim = self.dim\n rank = expr.rank\n unique_scalar_space = expr.unique_scalar_space\n is_scalar = expr.is_scalar\n target = expr.target\n label = str(SymbolicExpr(target))\n\n if isinstance(expr, TensorQuadratureTestBasis):\n if not unique_scalar_space:\n names = 'test_basis_{label}(1:{j})_1:{i}'.format(label=label,i=dim+1,j=dim+1)\n else:\n names = 'test_basis_{label}_1:{i}'.format(label=label,i=dim+1)\n\n elif isinstance(expr, TensorQuadratureTrialBasis):\n if not unique_scalar_space:\n names = 'trial_basis_{label}(1:{j})_1:{i}'.format(label=label,i=dim+1,j=dim+1)\n else:\n names = 'trial_basis_{label}_1:{i}'.format(label=label,i=dim+1)\n else:\n if not unique_scalar_space:\n names = 'array_basis_{label}(1:{j})_1:{i}'.format(label=label,i=dim+1,j=dim+1)\n else:\n names = 'array_basis_{label}_1:{i}'.format(label=label,i=dim+1)\n # ...\n\n targets = variables(names, dtype='real', rank=rank, cls=IndexedVariable)\n\n self.insert_variables(*targets)\n arrays = {}\n if unique_scalar_space and not is_scalar:\n for i in range(dim):\n arrays[target[i]] = tuple(zip(targets))\n elif not unique_scalar_space:\n for i in range(dim):\n arrays[target[i]] = tuple(zip(targets[i::dim]))\n else:\n arrays[target] = tuple(zip(targets))\n return arrays\n\n # ....................................................\n def _visit_GlobalSpan(self, expr, **kwargs):\n dim = self.dim\n rank = expr.rank\n target = expr.target\n label = SymbolicExpr(target).name\n\n names = 'global_span_{}_1:{}'.format(label, str(dim+1))\n targets = variables(names, dtype='int', rank=rank, cls=IndexedVariable)\n if expr.index is not None:\n return targets[expr.index]\n\n self.insert_variables(*targets)\n if not isinstance(targets[0], (tuple, list, Tuple)):\n targets = [targets]\n target = {target: tuple(zip(*targets))}\n return target\n # ....................................................\n def _visit_Span(self, expr, **kwargs):\n dim = self.dim\n target = expr.target\n label = SymbolicExpr(target).name\n names = 'span_{}_1:{}'.format(label,str(dim+1))\n targets = variables(names, dtype='int')\n\n if expr.index is not None:\n return targets[expr.index]\n\n self.insert_variables(*targets)\n if not isinstance(targets[0], (tuple, list, Tuple)):\n targets = [targets]\n\n target = {target: tuple(zip(*targets))}\n return target\n\n def _visit_Pads(self, expr, **kwargs):\n dim = self.dim\n tests = expand(expr.tests)\n tests_degree = expr.tests_degree\n trials_degree = expr.trials_degree\n m_tests = expr.tests_multiplicity\n m_trials = expr.trials_multiplicity\n\n if expr.trials is not None:\n trials = expand(expr.trials)\n pads = Matrix.zeros(len(tests),len(trials))\n for i in range(pads.shape[0]):\n for j in range(pads.shape[1]):\n label1 = SymbolicExpr(tests[i]).name\n label2 = SymbolicExpr(trials[j]).name\n names = 'pad_{}_{}_1:{}'.format(label2, label1, str(dim+1))\n targets = variables(names, dtype='int')\n pads[i,j] = Tuple(*targets)\n self.insert_variables(*targets)\n else:\n pads = Matrix.zeros(len(tests),1)\n for i in range(pads.shape[0]):\n label1 = SymbolicExpr(tests[i]).name\n names = 'pad_{}_1:{}'.format(label1, str(dim+1))\n targets = variables(names, dtype='int')\n pads[i,0] = Tuple(*targets)\n self.insert_variables(*targets)\n return pads\n # ....................................................\n def _visit_TensorBasis(self, expr, **kwargs):\n # TODO label\n dim = self.dim\n nderiv = self.nderiv\n target = expr.target\n\n ops = [dx1, dx2, dx3][:dim]\n atoms = _split_test_function(target)\n args = {}\n for atom in atoms:\n sub_args = [None]*dim\n for i in range(dim):\n d = ops[i]\n a = atoms[atom][i]\n ls = [a]\n for _ in range(1, nderiv+1):\n a = d(a)\n ls.append(a)\n sub_args[i] = tuple(ls)\n args[atom] = tuple(sub_args)\n return args\n\n # ....................................................\n def _visit_CoefficientBasis(self, expr, **kwargs):\n target = SymbolicExpr(expr.target)\n name = 'coeff_{}'.format(target.name)\n var = IndexedVariable(name, dtype='real', rank=self.dim)\n self.insert_variables(var)\n return var\n\n def _visit_MatrixCoordsFromRank(self, expr, **kwargs):\n var = IndexedVariable('coords_from_rank', dtype='int', rank=2)\n return var\n\n def _visit_MatrixRankFromCoords(self, expr, **kwargs):\n var = IndexedVariable('rank_from_coords', dtype='int', rank=self.dim)\n return var\n # ....................................................\n def _visit_MatrixLocalBasis(self, expr, **kwargs):\n rank = self._visit(expr.rank)\n target = SymbolicExpr(expr.target)\n name = 'arr_coeffs_{}'.format(target.name)\n var = IndexedVariable(name, dtype='real', rank=rank)\n self.insert_variables(var)\n return var\n # ....................................................\n\n def _visit_MatrixGlobalBasis(self, expr, **kwargs):\n rank = self._visit(expr.rank)\n target = SymbolicExpr(expr.target)\n\n name = 'global_arr_coeffs_{}'.format(target.name)\n var = IndexedVariable(name, dtype='real', rank=rank)\n self.insert_variables(var)\n return var\n # ....................................................\n def _visit_Reset(self, expr, **kwargs):\n var = expr.var\n lhs = self._visit(var, **kwargs)\n if isinstance(var, (LocalElementBasis, GlobalElementBasis)):\n return Assign(lhs, 0.)\n\n elif isinstance(var, BlockScalarLocalBasis):\n expr = var.expr\n return tuple(Assign(a, 0.) for a,b in zip(lhs[:], expr[:]) if b)\n\n expr = var.expr\n rank = lhs[0,0].rank\n args = [Slice(None, None)]*rank\n return tuple(Assign(a[args], 0.) for a,b in zip(lhs[:], expr[:]) if b)\n\n # ....................................................\n def _visit_Reduce(self, expr, **kwargs):\n op = expr.op\n lhs = expr.lhs\n rhs = expr.rhs\n loop = expr.loop\n parallel = loop.parallel\n default = loop.default\n shared = loop.shared\n private = loop.private\n firstprivate = loop.firstprivate\n lastprivate = loop.lastprivate\n reduction = None\n if parallel:\n reduction = 'reduction({}:{})'.format(expr.op, self._visit(lhs).name)\n\n stmts = list(loop.stmts) + [Reduction(op, rhs, lhs)]\n loop = Loop(loop.iterable, loop.index, stmts=stmts, mask=loop.mask, parallel=parallel,\n default=default, shared=shared, private=private,\n firstprivate=firstprivate, lastprivate=lastprivate, reduction=reduction)\n return self._visit(loop, **kwargs)\n\n # ....................................................\n def _visit_Reduction(self, expr, **kwargs):\n op = expr.op\n lhs = expr.lhs\n expr = expr.expr\n\n if isinstance(lhs, (GlobalElementBasis, LocalElementBasis)):\n lhs = self._visit(lhs, **kwargs)\n rhs = self._visit(expr, **kwargs)\n return (AugAssign(lhs, op, rhs),)\n\n elif isinstance(lhs, BlockStencilMatrixLocalBasis):\n lhs = self._visit_BlockStencilMatrixLocalBasis(lhs)\n expr = self._visit(expr, op=op, lhs=lhs)\n return expr\n elif isinstance(lhs, BlockStencilMatrixGlobalBasis):\n\n dim = self.dim\n rank = lhs.rank\n pads = lhs.pads\n multiplicity = lhs.multiplicity\n tests = expand(lhs._tests)\n\n tests_2 = lhs._tests\n lhs = self._visit_BlockStencilMatrixGlobalBasis(lhs)\n rhs = self._visit(expr)\n\n pads = self._visit(pads)\n rhs_slices = [Slice(None, None)]*rank\n for k1 in range(lhs.shape[0]):\n test = tests[k1]\n test = test if test in tests_2 else test.base\n spans = self._visit_Span(Span(test))\n degrees = self._visit_LengthDofTest(LengthDofTest(test))\n spans = flatten(*spans.values())\n m = multiplicity[test] if test in multiplicity else multiplicity[test.base]\n lhs_starts = [spans[i]+m[i]*pads[i]-degrees[i] for i in range(dim)]\n lhs_ends = [spans[i]+m[i]*pads[i]+1 for i in range(dim)]\n if isinstance(self._target, Interface):\n axis = self._target.axis\n lhs_starts[axis] = pads[axis]\n lhs_ends[axis] = pads[axis] + degrees[axis] + 1\n\n for k2 in range(lhs.shape[1]):\n if expr.expr[k1,k2]:\n lhs_slices = [Slice(s, e) for s,e in zip(lhs_starts, lhs_ends)]\n lhs_slices += [Slice(None, None)]*dim\n lhs[k1,k2] = [lhs[k1,k2][lhs_slices]]\n rhs[k1,k2] = [rhs[k1,k2][rhs_slices]]\n\n return tuple( AugAssign(a, op, b) for a,b,e in zip(lhs[:], rhs[:], expr.expr[:]) if e)\n\n elif isinstance(lhs, BlockStencilVectorLocalBasis):\n lhs = self._visit_BlockStencilVectorLocalBasis(lhs)\n expr = self._visit(expr, op=op, lhs=lhs)\n return expr\n elif isinstance(lhs, BlockStencilVectorGlobalBasis):\n dim = self.dim\n rank = lhs.rank\n pads = lhs.pads\n multiplicity = lhs.multiplicity\n tests = expand(lhs._tests)\n tests_2 = lhs._tests\n lhs = self._visit_BlockStencilVectorGlobalBasis(lhs)\n rhs = self._visit(expr)\n pads = self._visit(pads)\n rhs_slices = [Slice(None, None)]*rank\n\n for k in range(lhs.shape[0]):\n if expr.expr[k,0]:\n test = tests[k]\n m = multiplicity[test] if test in multiplicity else multiplicity[test.base]\n test = test if test in tests_2 else test.base\n spans = self._visit_Span(Span(test))\n spans = flatten(*spans.values())\n degrees = self._visit_LengthDofTest(LengthDofTest(test))\n lhs_starts = [spans[i]+m[i]*pads[i]-degrees[i] for i in range(dim)]\n lhs_ends = [spans[i]+m[i]*pads[i]+1 for i in range(dim)]\n lhs_slices = [Slice(s, e) for s,e in zip(lhs_starts, lhs_ends)]\n lhs[k,0] = lhs[k,0][lhs_slices]\n rhs[k,0] = rhs[k,0][rhs_slices]\n\n return tuple( AugAssign(a, op, b) for a,b,e in zip(lhs[:], rhs[:], expr.expr[:]) if e)\n else:\n if not( lhs is None ):\n lhs = self._visit(lhs)\n\n return self._visit(expr, op=op, lhs=lhs)\n # ....................................................\n def _visit_ComputeLogical(self, expr, op=None, lhs=None, **kwargs):\n expr = expr.expr\n if lhs is None:\n if not isinstance(expr, (Add, Mul)):\n lhs = self._visit_AtomicNode(AtomicNode(expr), **kwargs)\n else:\n lhs = random_string( 6 )\n lhs = Symbol('tmp_{}'.format(lhs))\n\n node = LogicalValueNode(expr)\n rhs = self._visit_LogicalValueNode(node, **kwargs)\n\n if op is None:\n stmt = Assign(lhs, rhs)\n else:\n stmt = AugAssign(lhs, op, rhs)\n\n return self._visit(stmt, **kwargs)\n\n # ....................................................\n def _visit_ComputeLogicalBasis(self, expr, op=None, lhs=None, **kwargs):\n expr = expr.expr\n if lhs is None:\n if not isinstance(expr, (Add, Mul)):\n atom = BasisAtom(expr)\n lhs = self._visit_BasisAtom(atom, **kwargs)\n else:\n lhs = random_string( 6 )\n lhs = Symbol('tmp_{}'.format(lhs))\n\n expr = LogicalBasisValue(expr)\n rhs = self._visit_LogicalBasisValue(expr, **kwargs)\n\n if op is None:\n stmt = Assign(lhs, rhs)\n else:\n stmt = AugAssign(lhs, op, rhs)\n\n return self._visit(stmt, **kwargs)\n\n # ....................................................\n def _visit_ComputeKernelExpr(self, expr, op=None, lhs=None, **kwargs):\n if lhs is None:\n if not isinstance(expr, (Add, Mul)):\n lhs = self._visit_BasisAtom(BasisAtom(expr), **kwargs)\n else:\n lhs = random_string( 6 )\n lhs = Symbol('tmp_{}'.format(lhs))\n\n exprs = expr.expr\n mapping = self.mapping\n\n if expr.weights:\n weight = SymbolicWeightedVolume(mapping)\n weight = SymbolicExpr(weight)\n else:\n weight = 1\n\n rhs = [weight*self._visit(expr, **kwargs) for expr in exprs[:]]\n lhs = lhs[:]\n\n temps = []\n temps, rhs = cse_main.cse(rhs, symbols=cse_main.numbered_symbols(prefix='temp'))\n\n normal_vec_stmts = []\n normal_vectors = expr.expr.atoms(NormalVector)\n target = self._target\n dim = self._dim\n\n if normal_vectors:\n axis = target.axis\n ext = target.ext if isinstance(target, Boundary) else 1\n\n vars_plus = []\n if isinstance(target, Interface):\n mapping = mapping.minus\n target = target.minus\n axis = target.axis\n ext = target.ext\n elif isinstance(target, Boundary):\n ext = target.ext\n axis = target.axis\n\n\n for vec in normal_vectors:\n\n J_inv = LogicalExpr(mapping.jacobian_inv_expr, mapping(target))\n J_inv = SymbolicExpr(J_inv)\n values = ext * J_inv[axis, :]\n normalization = values.dot(values)**0.5\n values = [v for v in values]\n values = [v1/normalization for v1 in values]\n normal_vec_stmts += [Assign(SymbolicExpr(vec[i]), values[i]) for i in range(dim)]\n\n if op is None:\n stmts = [Assign(i, j) for i,j in zip(lhs,rhs) if j]\n else:\n stmts = [AugAssign(i, op, j) for i,j in zip(lhs,rhs) if j]\n\n temps = tuple(Assign(a,b) for a,b in temps)\n stmts = tuple(self._visit(stmt, **kwargs) for stmt in stmts)\n stmts = tuple(vars_plus) + tuple(normal_vec_stmts) + temps + stmts\n\n math_functions = math_atoms_as_str(list(exprs)+normal_vec_stmts, 'math')\n math_functions = tuple(m for m in math_functions if m not in self._math_functions)\n self._math_functions = math_functions + self._math_functions\n return stmts\n\n # ....................................................\n def _visit_BasisAtom(self, expr, **kwargs):\n symbol = SymbolicExpr(expr.expr)\n self.variables[str(symbol.name)] = symbol\n return symbol\n\n # ....................................................\n def _visit_AtomicNode(self, expr, **kwargs):\n if isinstance(expr.expr, WeightedVolumeQuadrature):\n expr = SymbolicWeightedVolume(self.mapping)\n return self._visit(expr, **kwargs )\n\n else:\n return SymbolicExpr(expr.expr)\n\n # ....................................................\n def _visit_LogicalBasisValue(self, expr, **kwargs):\n # ...\n dim = self.dim\n coords = ['x1', 'x2', 'x3'][:dim]\n\n expr = expr.expr\n atom = BasisAtom(expr).atom\n atoms = _split_test_function(atom)\n ops = [dx1, dx2, dx3][:dim]\n d_atoms = dict(zip(coords, atoms[atom]))\n d_ops = dict(zip(coords, ops))\n d_indices = get_index_logical_derivatives(expr)\n args = []\n for k,u in d_atoms.items():\n d = d_ops[k]\n n = d_indices[k]\n for _ in range(n):\n u = d(u)\n args.append(u)\n # ...\n\n expr = Mul(*args)\n expr = SymbolicExpr(expr)\n return expr\n\n # ....................................................\n def _visit_LogicalValueNode(self, expr, **kwargs):\n\n expr = expr.expr\n target = self.target\n\n if isinstance(expr, WeightedVolumeQuadrature):\n #TODO improve l_quad should not be used like this\n l_quad = TensorQuadrature()\n l_quad = self._visit_TensorQuadrature(l_quad, **kwargs)\n _, weights = list(zip(*list(l_quad.values())[0]))\n if isinstance(target, Boundary):\n weights = list(weights)\n weights.pop(target.axis)\n wvol = Mul(*weights)\n return wvol\n else:\n raise TypeError('{} not available'.format(type(expr)))\n\n # ....................................................\n def _visit_PhysicalGeometryValue(self, expr, **kwargs):\n target = self._target\n expr = LogicalExpr(expr.expr, mapping(target))\n\n return SymbolicExpr(expr)\n\n # ....................................................\n def _visit_ElementOf(self, expr, **kwargs):\n dim = self.dim\n target = expr.target\n #improve we shouldn't use index_dof_test\n if isinstance(target, BlockStencilMatrixLocalBasis):\n rows = self._visit(index_dof_test)\n outer = self._visit(target.outer) if target.outer else rows\n cols = self._visit(index_dof_trial)\n pads = target.pads\n tests = expand(target._tests)\n trials = expand(target._trials)\n\n targets = self._visit_BlockStencilMatrixLocalBasis(target)\n for i in range(targets.shape[0]):\n for j in range(targets.shape[1]):\n if targets[i,j] is None:\n continue\n if trials[j] in pads.trials_multiplicity:\n trials_m = pads.trials_multiplicity[trials[j]]\n trials_d = pads.trials_degree[trials[j]]\n else:\n trials_m = pads.trials_multiplicity[trials[j].base]\n trials_d = pads.trials_degree[trials[j].base]\n\n if tests[i] in pads.tests_multiplicity:\n tests_m = pads.tests_multiplicity[tests[i]]\n tests_d = pads.tests_degree[tests[i]]\n else:\n tests_m = pads.tests_multiplicity[tests[i].base]\n tests_d = pads.tests_degree[tests[i].base]\n\n pp1 = [max(tests_d[k], trials_d[k]) for k in range(dim)]\n pp2 = [int((np.ceil((pp1[k]+1)/tests_m[k])-1)*trials_m[k]) for k in range(dim)]\n padding = [p2-min(0,p2-p1) for p1,p2 in zip(pp1, pp2)]\n indices = tuple(rows) + tuple(cols[k]+padding[k]-outer[k]*trials_m[k] for k in range(dim))\n targets[i,j] = targets[i,j][indices]\n return targets\n\n elif isinstance(target, BlockStencilVectorLocalBasis):\n targets = self._visit_BlockStencilVectorLocalBasis(target, **kwargs)\n\n rows = self._visit(index_dof_test)\n indices = list(rows)\n for i in range(targets.shape[0]):\n for j in range(targets.shape[1]):\n if targets[i,j] is None:\n continue\n targets[i,j] = targets[i,j][indices]\n return targets\n elif isinstance(target, LocalElementBasis):\n target = self._visit(target, **kwargs)\n return (target,)\n\n elif isinstance(target, BlockScalarLocalBasis):\n targets = self._visit(target)\n return targets\n else:\n raise NotImplementedError('TODO')\n\n # .............................................................................\n def _visit_BlockStencilMatrixLocalBasis(self, expr, **kwargs):\n pads = self._visit_Pads(expr.pads)\n tests = expr._tests\n trials = expr._trials\n tag = expr.tag\n tests = expand(tests)\n trials = expand(trials)\n targets = Matrix.zeros(len(tests), len(trials))\n for i,v in enumerate(tests):\n for j,u in enumerate(trials):\n if expr.expr[i,j] == 0:\n targets[i,j] = None\n continue\n mat = StencilMatrixLocalBasis(u, v, pads[i,j], tag)\n mat = self._visit_StencilMatrixLocalBasis(mat, **kwargs)\n targets[i,j] = mat\n return targets\n\n def _visit_BlockStencilMatrixGlobalBasis(self, expr, **kwargs):\n pads = expr.pads\n tests = expr._tests\n trials = expr._trials\n tag = expr.tag\n tests = expand(tests)\n trials = expand(trials)\n targets = Matrix.zeros(len(tests), len(trials))\n for i,v in enumerate(tests):\n for j,u in enumerate(trials):\n if expr.expr[i,j] == 0:\n targets[i,j] = None\n continue\n mat = StencilMatrixGlobalBasis(u, v, pads, tag)\n mat = self._visit_StencilMatrixGlobalBasis(mat, **kwargs)\n targets[i,j] = mat\n return targets\n\n def _visit_BlockStencilVectorLocalBasis(self, expr, **kwargs):\n pads = expr.pads\n tests = expr._tests\n tag = expr.tag\n tests = expand(tests)\n targets = Matrix.zeros(len(tests), 1)\n for i,v in enumerate(tests):\n if expr.expr[i,0] == 0:\n targets[i,0] = None\n continue\n mat = StencilVectorLocalBasis(v, pads, tag)\n mat = self._visit_StencilVectorLocalBasis(mat, **kwargs)\n targets[i,0] = mat\n return targets\n\n def _visit_BlockStencilVectorGlobalBasis(self, expr, **kwargs):\n pads = expr.pads\n tests = expr._tests\n tag = expr.tag\n tests = expand(tests)\n targets = Matrix.zeros(len(tests), 1)\n for i,v in enumerate(tests):\n if expr.expr[i,0] == 0:\n targets[i,0] = None\n continue\n mat = StencilVectorGlobalBasis(v, pads, tag)\n mat = self._visit_StencilVectorGlobalBasis(mat, **kwargs)\n targets[i,0] = mat\n return targets\n\n # .............................................................................\n def _visit_BlockScalarLocalBasis(self, expr, **kwargs):\n tag = expr.tag\n tests = expand(expr._tests)\n trials = expand(expr._trials) if expr._trials else (None,)\n targets = Matrix.zeros(len(tests), len(trials))\n for i,v in enumerate(tests):\n for j,u in enumerate(trials):\n if expr.expr[i,j] == 0:\n targets[i,j] = None\n continue\n var = ScalarLocalBasis(u, v, tag)\n var = self._visit_ScalarLocalBasis(var, **kwargs)\n targets[i,j] = var\n return targets\n\n # .............................................................................\n def _visit_StencilMatrixLocalBasis(self, expr, **kwargs):\n rank = expr.rank\n tag = expr.tag\n name = '_'.join(str(SymbolicExpr(e)) for e in expr.name)\n\n name = 'l_mat_{}_{}'.format(name, tag)\n var = IndexedVariable(name, dtype='real', rank=rank)\n self.insert_variables(var)\n return var\n\n # ....................................................\n def _visit_StencilVectorLocalBasis(self, expr, **kwargs):\n rank = expr.rank\n tag = expr.tag\n name = str(SymbolicExpr(expr.name))\n name = 'l_vec_{}_{}'.format(name, tag)\n var = IndexedVariable(name, dtype='real', rank=rank) \n self.insert_variables(var)\n return var\n\n # ....................................................\n def _visit_StencilMatrixGlobalBasis(self, expr, **kwargs):\n rank = expr.rank\n tag = expr.tag\n name = '_'.join(str(SymbolicExpr(e)) for e in expr.name)\n name = 'g_mat_{}_{}'.format(name, tag)\n var = IndexedVariable(name, dtype='real', rank=rank)\n self.insert_variables(var)\n return var\n\n # ....................................................\n def _visit_StencilVectorGlobalBasis(self, expr, **kwargs):\n rank = expr.rank\n tag = expr.tag\n name = str(SymbolicExpr(expr.name))\n name = 'g_vec_{}_{}'.format(name, tag) \n var = IndexedVariable(name, dtype='real', rank=rank)\n self.insert_variables(var)\n return var\n\n def _visit_GlobalElementBasis(self, expr, **kwargs):\n tag = expr.tag\n name = 'g_el_{}'.format(tag)\n var = variables(name, dtype='real')\n self.insert_variables(var)\n return var\n\n def _visit_LocalElementBasis(self, expr, **kwargs):\n tag = expr.tag\n name = 'l_el_{}'.format(tag)\n var = variables(name, dtype='real') \n self.insert_variables(var)\n return var\n\n def _visit_ScalarLocalBasis(self, expr, **kwargs):\n tag = expr.tag\n basis = (expr._test,)\n if expr._trial:\n basis = (expr._test, expr._trial)\n name = '_'.join(str(SymbolicExpr(e)) for e in basis)\n name = 'contribution_{}_{}'.format(name, tag)\n var = variables(name, dtype='real') \n self.insert_variables(var)\n return var\n\n # ....................................................\n def _visit_Pattern(self, expr, **kwargs):\n # this is for multi-indices for the moment\n dim = self.dim\n args = []\n for a in expr:\n if a is None:\n args.append([Slice(None, None)]*dim)\n\n elif isinstance(a, int):\n args.append([a]*dim)\n\n else:\n v = self._visit(a)\n args.append(v)\n args = list(zip(*args))\n return args\n\n def _visit_TensorIntDiv(self, expr, **kwargs):\n args = [self._visit(a, **kwargs) for a in expr.args]\n arg1 = args[0]\n arg2 = args[1]\n newargs = []\n for i,j in zip(arg1, arg2):\n newargs.append(i//j)\n \n return tuple(newargs)\n\n def _visit_TensorAdd(self, expr, **kwargs):\n args = [self._visit(a, **kwargs) for a in expr.args]\n arg1 = args[0]\n arg2 = args[1]\n newargs = []\n for i,j in zip(arg1, arg2):\n newargs.append(i+j)\n \n return tuple(newargs)\n\n def _visit_TensorMul(self, expr, **kwargs):\n args = [self._visit(a, **kwargs) for a in expr.args]\n arg1 = args[0]\n arg2 = args[1]\n newargs = []\n for i,j in zip(arg1, arg2):\n newargs.append(i*j)\n \n return tuple(newargs)\n\n def _visit_TensorMax(self, expr, **kwargs):\n args = [self._visit(a, **kwargs) for a in expr.args]\n arg1 = args[0]\n arg2 = args[1]\n newargs = []\n for i,j in zip(arg1, arg2):\n newargs.append(Max(i,j))\n\n return tuple(newargs)\n\n def _visit_TensorInteger(self, expr, **kwargs):\n return (expr.args[0],)*self.dim\n # ....................................................\n\n def _visit_Max(self, expr, **kwargs):\n args = [self._visit(i) for i in expr.args]\n return Max(*args)\n\n def _visit_Min(self, expr, **kwargs):\n args = [self._visit(i) for i in expr.args]\n return Min(*args)\n\n def _visit_Expr(self, expr, **kwargs):\n return SymbolicExpr(expr)\n\n def _visit_Return( self, expr, **kwargs):\n return Return(self._visit(expr.expr))\n\n def _visit_NumThreads(self, expr, **kwargs):\n target = variables('num_threads', dtype='int')\n self.insert_variables(target)\n return target\n\n def _visit_BooleanTrue(self, expr, **kwargs):\n return int(True)\n\n def _visit_BooleanFalse(self, expr, **kwargs):\n return int(False)\n # ....................................................\n def _visit_ThreadId(self, expr, **kwargs):\n return variables('thread_id', dtype='int')\n # ...................................................\n def _visit_NeighbourThreadCoordinates(self, expr, **kwargs):\n dim = self.dim\n target = variables('next_thread_coords_1:%d'%(dim+1), dtype='int')\n if expr.index is not None:\n return target[expr.index]\n self.insert_variables(*target)\n return target\n # ....................................................\n def _visit_ThreadCoordinates(self, expr, **kwargs):\n dim = self.dim\n target = variables('thread_coords_1:%d'%(dim+1), dtype='int')\n if expr.index is not None:\n return target[expr.index]\n return target\n # ....................................................\n def _visit_IndexElement(self, expr, **kwargs):\n dim = self.dim\n target = variables('i_element_1:%d'%(dim+1), dtype='int')\n self.insert_variables(*target)\n return target\n # ....................................................\n def _visit_LocalIndexElement(self, expr, **kwargs):\n dim = self.dim\n target = variables('local_i_element_1:%d'%(dim+1), dtype='int')\n if expr.index is not None:\n return target[expr.index]\n return target\n # ....................................................\n def _visit_IndexQuadrature(self, expr, **kwargs):\n dim = self.dim\n target = variables('i_quad_1:%d'%(dim+1), dtype='int')\n self.insert_variables(*target)\n return target\n # ....................................................\n def _visit_IndexDof(self, expr, **kwargs):\n dim = self.dim\n target = variables('i_basis_1:%d'%(dim+1), dtype='int')\n self.insert_variables(*target)\n return target\n # ....................................................\n def _visit_IndexDofTrial(self, expr, **kwargs):\n dim = self.dim\n target = variables('j_basis_1:%d'%(dim+1), dtype='int')\n self.insert_variables(*target)\n return target\n # ....................................................\n def _visit_IndexDofTest(self, expr, **kwargs):\n dim = self.dim\n target = variables('i_basis_1:%d'%(dim+1), dtype='int')\n self.insert_variables(*target)\n return target\n # ....................................................\n def _visit_IndexOuterDofTest(self, expr, **kwargs):\n dim = self.dim\n target = variables('outer_i_basis_1:%d'%(dim+1), dtype='int')\n self.insert_variables(*target)\n return target\n # ....................................................\n def _visit_IndexInnerDofTest(self, expr, **kwargs):\n dim = self.dim\n target = variables('inner_i_basis_1:%d'%(dim+1), dtype='int')\n self.insert_variables(*target)\n return target\n # ....................................................\n def _visit_IndexDerivative(self, expr, **kwargs):\n raise NotImplementedError('TODO')\n\n # ....................................................\n def _visit_LengthElement(self, expr, **kwargs):\n dim = self.dim\n names = 'n_element_1:%d'%(dim+1)\n target = variables(names, dtype='int', cls=Variable)\n if expr.index is not None:\n return target[expr.index]\n self.insert_variables(*target)\n return target\n # ....................................................\n def _visit_LengthQuadrature(self, expr, **kwargs):\n dim = self.dim\n names = 'k1:%d'%(dim+1)\n target = variables(names, dtype='int', cls=Variable)\n self.insert_variables(*target)\n return target\n # ....................................................\n def _visit_LengthDof(self, expr, **kwargs):\n dim = self.dim\n names = 'p1:%d'%(dim+1)\n target = variables(names, dtype='int')\n self.insert_variables(*target)\n return target\n # ....................................................\n def _visit_LengthDofTest(self, expr, **kwargs):\n dim = self.dim\n target = expr.target\n if target:\n target = '_' + str(SymbolicExpr(target))\n else:\n target = ''\n\n names = 'test{}_p1:{}'.format(target, dim+1)\n target = variables(names, dtype='int')\n self.insert_variables(*target)\n return target\n # ....................................................\n def _visit_LengthOuterDofTest(self, expr, **kwargs):\n dim = self.dim\n target = expr.target\n if target:\n target = '_' + str(SymbolicExpr(target))\n else:\n target = ''\n\n names = 'test_outer{}_p1:{}'.format(target, dim+1)\n target = variables(names, dtype='int')\n self.insert_variables(*target)\n return target\n # ....................................................\n def _visit_LengthInnerDofTest(self, expr, **kwargs):\n dim = self.dim\n target = expr.target\n if target:\n target = '_' + str(SymbolicExpr(target))\n else:\n target = ''\n\n names = 'test_inner{}_p1:{}'.format(target, dim+1)\n target = variables(names, dtype='int')\n self.insert_variables(*target)\n return target\n\n # ....................................................\n def _visit_LengthDofTrial(self, expr, **kwargs):\n dim = self.dim\n target = expr.target\n if target:\n target = '_' + str(SymbolicExpr(target))\n else:\n target = ''\n\n names = 'trial{}_p1:{}'.format(target, dim+1)\n target = variables(names, dtype='int')\n self.insert_variables(*target)\n return target\n # ....................................................\n def _visit_RankDimension(self, expr, **kwargs):\n return self.dim\n\n # ....................................................\n def _visit_TensorIterator(self, expr, **kwargs):\n target = self._visit(expr.target)\n return target\n\n # ....................................................\n def _visit_ProductIterator(self, expr, **kwargs):\n target = self._visit(expr.target)\n return target\n\n # ....................................................\n def _visit_TensorGenerator(self, expr, **kwargs):\n\n targets = self._visit(expr.target)\n if expr.dummies is None:\n #TODO check if we never pass this condition\n return expr.target\n\n if not hasattr(expr.target, 'pattern'):\n return targets\n\n patterns = expr.target.pattern()\n patterns = self._visit_Pattern(patterns)\n args = {}\n for i,target in targets.items():\n args[i] = []\n for p, xs in zip(patterns, target):\n ls = []\n for x in xs:\n ls.append(x[p])\n args[i].append(tuple(ls))\n args[i] = tuple(args[i])\n\n return args\n # ....................................................\n def _visit_ProductGenerator(self, expr, **kwargs):\n target = self._visit(expr.target)\n\n # treat dummies and put them in the namespace\n dummies = self._visit(expr.dummies)\n dummies = dummies[0] # TODO add comment\n return target[dummies]\n\n # ....................................................\n def _visit_TensorIteration(self, expr, **kwargs):\n dim = self.dim\n iterator = self._visit(expr.iterator)\n generator = self._visit(expr.generator)\n\n if isinstance(iterator, (tuple, Tuple, list)):\n inits = []\n for i,g in zip(iterator, generator):\n inits.append([Assign(i,g)])\n return inits\n\n inits = [()]*dim\n\n for (i, l_xs),(j, g_xs) in zip(iterator.items(), generator.items()):\n if isinstance(expr.generator.target, GlobalTensorQuadratureBasis):\n positions = [expr.generator.target.positions[index_deriv]]\n g_xs = [SplitArray(xs[0], positions, [self.nderiv+1]) for xs in g_xs]\n g_xs = [tuple(self._visit(xs, **kwargs)) for xs in g_xs]\n\n for i in range(dim):\n ls = []\n for l_x,g_x in zip(l_xs[i], g_xs[i]):\n if isinstance(expr.generator.target, GlobalTensorQuadratureBasis):\n lhs = self._visit_BasisAtom(BasisAtom(l_x))\n else:\n lhs = l_x\n ls += [self._visit(Assign(lhs, g_x))]\n inits[i] += tuple(ls)\n inits = [flatten(init) for init in inits]\n return inits\n\n # ....................................................\n def _visit_ProductIteration(self, expr, **kwargs):\n # TODO for the moment, we do not return indices and lengths\n iterator = self._visit(expr.iterator)\n generator = self._visit(expr.generator)\n \n return Assign(iterator, generator)\n\n def _visit_RAT(self, expr):\n return str(expr)\n\n def _visit_WhileLoop(self, expr, **kwargs):\n cond = self._visit(expr.condition)\n body = [self._visit(a) for a in expr.body]\n return While(cond, body)\n\n def _visit_IfNode(self, expr, **kwargs):\n args = []\n for a in expr.args:\n cond = self._visit(a[0])\n body = [self._visit(i) for i in a[1]]\n args += [(cond, body)]\n return If(*args)\n # ....................................................\n def _visit_Loop(self, expr, **kwargs):\n # we first create iteration statements\n # these iterations are splitted between what is tensor or not\n\n # ... treate tensor iterations\n\n t_iterator = [i for i in expr.iterator if isinstance(i, TensorIterator)]\n t_generator = [i for i in expr.generator if isinstance(i, TensorGenerator)]\n t_iterations = [TensorIteration(i,j)\n for i,j in zip(t_iterator, t_generator)]\n\n indices = list(self._visit(expr.index))\n starts, stops, lengths = list(self._visit(expr.index.start)), list(self._visit(expr.index.stop)), list(self._visit(expr.index.length))\n\n for i,j in zip(flatten(indices), flatten(lengths)):\n self.indices[str(i)] = j\n\n inits = [()]*self._dim\n if t_iterations:\n t_iterations = [self._visit_TensorIteration(i) for i in t_iterations]\n\n # indices and lengths are supposed to be repeated here\n # we only take the first occurence\n for init in t_iterations:\n for i in range(self._dim):\n inits[i] += tuple(init[i])\n\n # ...\n # ... treate product iterations\n p_iterator = [i for i in expr.iterator if isinstance(i, ProductIterator)]\n p_generator = [i for i in expr.generator if isinstance(i, ProductGenerator)]\n p_iterations = [ProductIteration(i,j)\n for i,j in zip(p_iterator, p_generator)]\n\n p_inits = []\n if p_iterations:\n p_inits = [self._visit_ProductIteration(i) for i in p_iterations]\n # ...\n\n # ... add weighted volume if local quadrature loop\n mapping = self.mapping\n geo_stmts = expr.get_geometry_stmts(mapping)\n geo_stmts = self._visit(geo_stmts, **kwargs)\n # ...\n\n # ...\n # visit loop statements\n\n stmts = self._visit(expr.stmts, **kwargs)\n stmts = flatten(stmts)\n\n # update with product statements if available\n body = list(p_inits) + list(geo_stmts) + list(stmts)\n mask = expr.mask\n\n if isinstance(mask,(tuple,Tuple,list)):\n mask_init = [] \n for axis,T in enumerate(mask):\n if T:\n indices[axis] = None\n starts [axis] = None\n stops [axis] = None\n mask_init += list(inits[axis])\n inits[axis] = None\n indices = [i for i in indices if i is not None]\n starts = [i for i in starts if i is not None]\n stops = [i for i in stops if i is not None]\n inits = [i for i in inits if i is not None]\n\n elif mask:\n axis = mask.axis\n index = indices.pop(axis)\n start = starts.pop(axis)\n stop = stops.pop(axis)\n init = inits.pop(axis)\n mask_init = [Assign(index, 0), *init]\n\n if expr.parallel:\n body = list(flatten(inits)) + body\n for index, s, e in zip(indices[::-1], starts[::-1], stops[::-1]):\n body = [For(index, Range(s, e), body)]\n else:\n for index, s, e, init in zip(indices[::-1], starts[::-1], stops[::-1], inits[::-1]):\n\n body = list(init) + body\n body = [For(index, Range(s, e), body)]\n # ...\n # remove the list and return the For Node only\n\n if mask:\n body = [*mask_init, *body]\n\n if expr.parallel:\n default = expr.default\n shared = [self._visit(i) for i in expr.shared] if expr.shared else []\n private = [self._visit(i) for i in expr.private] if expr.private else []\n firstprivate = [self._visit(i) for i in expr.firstprivate] if expr.firstprivate else []\n lastprivate = [self._visit(i) for i in expr.lastprivate] if expr.lastprivate else []\n shared = flatten([list(i.values())[0] if isinstance(i, dict) else i for i in shared])\n private = flatten([list(i.values())[0] if isinstance(i, dict) else i for i in private])\n firstprivate = flatten([list(i.values())[0] if isinstance(i, dict)else i for i in firstprivate])\n lastprivate = flatten([list(i.values())[0] if isinstance(i, dict) else i for i in lastprivate])\n txt = '#$ omp parallel default({}) &\\n'.format(default)\n txt += '#$ shared({}) &\\n'.format(','.join(str(i) for i in shared if i)) if shared else ''\n txt += '#$ private({}) &\\n'.format(','.join(str(i) for i in private if i)) if private else ''\n txt += '#$ firstprivate({}) &\\n'.format(','.join(str(i) for i in firstprivate if i)) if firstprivate else ''\n txt += '#$ lastprivate({})'.format(','.join(str(i) for i in lastprivate if i)) if lastprivate else ''\n for_pragmas = '#$ omp for schedule(static) collapse({})'.format(self._dim)\n if expr.reduction:\n for_pragmas = for_pragmas + expr.reduction \n\n cmt = [Comment(txt.rstrip().rstrip('&')), Comment(for_pragmas)]\n endcmt = [Comment('#$ omp end parallel')]\n body = [*cmt, *body, *endcmt]\n\n if len(body) > 1:\n body = CodeBlock(body)\n elif len(body) == 1:\n body = body[0]\n\n return body\n\n # ....................................................\n def _visit_SplitArray(self, expr, **kwargs):\n target = expr.target\n positions = expr.positions\n lengths = expr.lengths\n base = target.base\n\n args = []\n for p,n in zip(positions, lengths):\n indices = target.indices # sympy is return a tuple of tuples\n indices = [i for i in indices] # make a copy\n for i in range(n):\n indices[p] = i\n x = base[tuple(indices)]\n args.append(x)\n return args\n\n def _visit_Comment(self, expr, **kwargs):\n return expr\n\n # ....................................................\n def _visit_IndexedElement(self, expr, **kwargs):\n return expr\n\n # ....................................................\n # TODO to be removed. usefull for testing\n def _visit_Pass(self, expr, **kwargs):\n return expr\n\n def _visit_Continue(self, expr, **kwargs):\n return expr\n\n def _visit_EmptyNode(self ,expr, **kwargs):\n return expr\n\n def _visit_NoneType(self, expr, **kwargs):\n return expr\n\n\n", "meta": {"hexsha": "3da2808ac8ef1c171f0f88ae8b92139b8c4ea429", "size": 77088, "ext": "py", "lang": "Python", "max_stars_repo_path": "psydac/api/ast/parser.py", "max_stars_repo_name": "mayuri-dhote/psydac", "max_stars_repo_head_hexsha": "01ddbe2d049a599684c45060912d01c2658160a3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2018-03-13T13:50:26.000Z", "max_stars_repo_stars_event_max_datetime": "2018-12-22T14:04:11.000Z", "max_issues_repo_path": "psydac/api/ast/parser.py", "max_issues_repo_name": "mayuri-dhote/psydac", "max_issues_repo_head_hexsha": "01ddbe2d049a599684c45060912d01c2658160a3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2019-02-08T13:29:47.000Z", "max_issues_repo_issues_event_max_datetime": "2019-03-06T17:23:08.000Z", "max_forks_repo_path": "psydac/api/ast/parser.py", "max_forks_repo_name": "mayuri-dhote/psydac", "max_forks_repo_head_hexsha": "01ddbe2d049a599684c45060912d01c2658160a3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2018-12-15T09:55:12.000Z", "max_forks_repo_forks_event_max_datetime": "2018-12-15T09:55:12.000Z", "avg_line_length": 37.9931000493, "max_line_length": 181, "alphanum_fraction": 0.5277085928, "include": true, "reason": "import numpy,from sympy", "num_tokens": 17571, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.607663184043154, "lm_q2_score": 0.32082131381216084, "lm_q1q2_score": 0.19495130106000555}} {"text": "#############################################################################\n##Mooring simulator, 2014 ####\n##Edited by Arnaud Le Fur, IFREMER ####\n#############################################################################\n\nfrom PyQt4 import QtGui\nimport copy\nimport numpy as np\nfrom math import cos, sin, atan, sqrt\nfrom mySimulateCanvas import MySimulateCanvas\n\n\nclass Simulate_wind(QtGui.QWidget):\n \"\"\"Classe contenant la fenetre de simulation \"\"\"\n\n def __init__(self, data, parent=None):\n \"\"\"initialisation, calcul et affichage des resultats de la simulation\n Input : data : Tableau reunissant toutes les donnees necessaires a la simulation\n data[0] : Liste des objets constituants le mouillage\n data[1] : Les profondeurs et valeurs de courants\n data[2] : Liste des profondeur fixe des instruments\n data[3] : Trainee induite par les elements lors de la chute du lest\n data[4] : Largeur de l ecran\n data[5] : Chemin du programme\n data[6] : Liste des ratio de clampage des instruments\n \"\"\"\n super(Simulate_wind, self).__init__(parent)\n\n l_max = 10. # Longueur max d un element\n count = 0\n self.release_ind = 0\n self.data = data\n self.table_match = np.zeros(len(self.data[0]))\n\n # Corrige la saisie de lutilisateur en cas de saisie positive du poids du lest\n if float(eval(self.data[0][-1].mass)) > 0:\n self.data[0][-1].mass = str(-1*float(eval(self.data[0][-1].mass)))\n\n # Calcul l inventaire des elements utilise sur la ligne\n self.inventory = self.calculate_inventory()\n # Calcul des profondeurs en statique, sans courant, ni allongement\n self.static_depth = self.calculate_static()\n # Calcul du temps, de la vitesse de chute et des tensions max lors de cette chute\n self.T, self.V_chute_t, self.T_max = self.resolve_max_Tension()\n self.percent_max_T = []\n self.weight_kg = []\n self.old_depth = []\n # Calcul du poids minimal,ideal,maximal pour le lest\n self.max_value_anchor = self.Anchor_max_value()\n\n #Calcul_des_tensions_max/Breaking_strenght#\n for i in range(len(self.T_max)):\n if type(self.data[0][i]) != list:\n if hasattr(self.data[0][i], \"breaking_strength\"):\n self.percent_max_T.append(\n 100*self.T_max[i]/(9.81*eval(self.data[0][i].breaking_strength)))\n else:\n self.percent_max_T.append(0.0)\n # On recupere egalement le poids de chaque element en kg\n self.weight_kg.append(eval(self.data[0][i].mass))\n else:\n if hasattr(self.data[0][i][0], \"breaking_strength\"):\n self.percent_max_T.append(\n 100*self.T_max[i]/(9.81*eval(self.data[0][i][0].breaking_strength)))\n else:\n self.percent_max_T.append(0.0)\n self.weight_kg.append(\n eval(self.data[0][i][0].mass)+eval(self.data[0][i][1].mass))\n\n # On calcul la flottabilite en cas de rupture de la partie superieure en kg\n self.get_buoyancy_kg()\n\n # On met en place une table de correspondance entre la ligne dorigine et la ligne decoupee en troncon\n for i in range(len(self.data[0])):\n self.table_match[i] = i+count\n if type(self.data[0][i]) != list:\n if eval(self.data[0][i].length) > l_max:\n coeff = round(eval(self.data[0][i].length)/l_max)\n count = count+coeff-1\n else:\n if eval(self.data[0][i][0].length) > l_max:\n coeff = round(eval(self.data[0][i][0].length)/l_max)\n count = count+coeff-1\n\n i = 0\n # On decoupe les cables en troncon de longueur minimale : cable de 100m = 10 x cable de 10 m\n while i < len(self.data[0]):\n if type(self.data[0][i]) != list:\n if eval(self.data[0][i].length) > l_max:\n #on met a jour le poids, la longueur, et la surface#\n coeff = round(eval(self.data[0][i].length)/l_max)\n new_length = str(eval(self.data[0][i].length)/coeff)\n new_mass = str(eval(self.data[0][i].mass)/coeff)\n new_projected_area = str(\n eval(self.data[0][i].projected_area)/coeff)\n self.data[0][i].length = new_length\n self.data[0][i].mass = new_mass\n self.data[0][i].projected_area = new_projected_area\n\n # on ajoute le nouveau troncon en position i+1\n for j in range(int(coeff)-1):\n self.data[0].insert(\n i+1, copy.deepcopy(self.data[0][i]))\n self.data[2].insert(i+1, 0)\n\n else: # Element clampes\n if eval(self.data[0][i][0].length) > l_max:\n coeff = round(eval(self.data[0][i][0].length)/l_max)\n new_length = str(eval(self.data[0][i][0].length)/coeff)\n new_mass = str(eval(self.data[0][i][0].mass)/coeff)\n new_projected_area = str(\n eval(self.data[0][i][0].projected_area)/coeff)\n self.data[0][i][0].length = new_length\n self.data[0][i][0].mass = new_mass\n self.data[0][i][0].projected_area = new_projected_area\n count = 0\n for j in range(int(coeff)-1):\n self.data[0].insert(\n i+1, copy.deepcopy(self.data[0][i][0]))\n self.data[2].insert(i+1, 0)\n count = count+1\n i = i+1\n\n self.depth = self.make_vector() # Initialisation du vecteur profondeur\n self.current_vector(self.depth) # Initialisation du vecteur de courant\n alpha, F, P = self.resolve() # Resolution du systeme\n self.calculate_stretch(F) # Calcul des allongements\n self.calculate_ratio(alpha) # Calcul des ratios de clampage\n self.plot_figure(alpha, P, F) # Plot des 4 graphiques de la simulation\n # Genere le tableau recapitulatif de la simulation\n self.make_table(alpha, F)\n\n def calculate_inventory(self):\n \"\"\"Cette fonction permet de retourner un tableau contenant la liste des elements,longueurs et le nombre dutilisation\n Output : Result : Tableau contenant l inventaire\"\"\"\n inventory_name = []\n inventory_length = []\n Result = [[\"Name\", \"Length (m) / Number\"]]\n #On recupere d abord tout les noms des elements#\n for i in range(len(self.data[0])):\n if type(self.data[0][i]) != list:\n if not(self.data[0][i].name) in inventory_name:\n inventory_name.append(self.data[0][i].name)\n inventory_length.append(0)\n else:\n if not(self.data[0][i][0].name) in inventory_name:\n inventory_name.append(self.data[0][i][0].name)\n inventory_length.append(0)\n if not(self.data[0][i][1].name) in inventory_name:\n inventory_name.append(self.data[0][i][1].name)\n inventory_length.append(0)\n #On incremente ensuite soit son nombre dutilisation soit la longueur si c est un cable#\n for i in range(len(self.data[0])):\n if type(self.data[0][i]) != list:\n ind = inventory_name.index(self.data[0][i].name)\n if self.data[0][i].__class__.__name__ == \"Ropes\":\n inventory_length[ind] = inventory_length[ind] + \\\n eval(self.data[0][i].length)\n else:\n inventory_length[ind] = inventory_length[ind]+1\n else: # Elements clampes\n ind = inventory_name.index(self.data[0][i][0].name)\n if self.data[0][i][0].__class__.__name__ == \"Ropes\":\n inventory_length[ind] = inventory_length[ind] + \\\n eval(self.data[0][i][0].length)\n else:\n inventory_length[ind] = inventory_length[ind]+1\n ind = inventory_name.index(self.data[0][i][1].name)\n if self.data[0][i][1].__class__.__name__ == \"Ropes\":\n inventory_length[ind] = inventory_length[ind] + \\\n eval(self.data[0][i][1].length)\n else:\n inventory_length[ind] = inventory_length[ind]+1\n for i in range(len(inventory_name)):\n Result.append([inventory_name[i], inventory_length[i]])\n return Result\n\n def calculate_static(self):\n \"\"\"Cette fonction permet de sauvegarder les longueurs d origines et retourne un vecteur avec les profondeurs(en haut de l element) \n en statique : sans allongement ni courant\n Output : subduct : vecteur de profondeur statique\"\"\"\n subduct = [self.data[1][1][-1]+eval(self.data[0][-1].length)]\n self.original_length = []\n for b in self.data[0]:\n if type(b) != list:\n self.original_length.append(round(eval(b.length), 1))\n else:\n self.original_length.append(\n [round(eval(b[0].length), 1), round(eval(b[1].length), 1)])\n\n for i in range(2, len(self.data[0])+1):\n\n if type(self.data[0][-i]) != list:\n subduct.insert(0, subduct[0]+eval(self.data[0][-i].length))\n else:\n subduct.insert(0, subduct[0]+eval(self.data[0][-i][0].length))\n return subduct\n\n def resolve_max_Tension(self):\n \"\"\"Cette fonction permet de calculer la vitesse, le temps de chute et les tensions maximales lors de cette chute \n Output : T : Vecteur temps\n V_chute_t : Vecteur vitesse de chute en fonction du temps\n T_max : Tension max pour chaque element \"\"\"\n\n Tension = []\n T_max = []\n g = 9.81\n h = 0\n T = [0]\n t = 0.\n mass_lest = eval(self.data[0][-1].mass)\n floor_depth = abs(self.data[1][1][len(self.data[1][0])-1])\n #Calcul de la flottabilite#\n for i in range(len(self.data[0])):\n Tension.append(0)\n for j in range(i+1):\n if j == len(self.data[0]):\n break\n else:\n if type(self.data[0][j]) != list:\n Tension[i] = Tension[i]+g*eval(self.data[0][j].mass)\n else:\n Tension[i] = Tension[i]+g * \\\n (eval(self.data[0][j][0].mass) +\n eval(self.data[0][j][1].mass))\n\n # Trainee induite par les elements superieures au lest\n a = (self.data[3][-1])/(-mass_lest)\n b = g-(Tension[-2]/(-mass_lest)) # Tension au niveau du lest\n if b > 0:\n i = 0\n cond = 0\n t = 0.1\n Time = 0.\n V_chute_t = [0]\n while cond == 0:\n # Evaluation de la variation de la vitesse de chute en fonction du temps cf L.MARIE\n Time = Time+t\n T.append(Time)\n V_chute_t.append((b-a*V_chute_t[-1]**2)*t+V_chute_t[-1])\n h = h+V_chute_t[i]*t\n if h >= floor_depth: # On touche le fond\n cond = 1\n i = i+1\n\n v_chute = V_chute_t[-1] # Vitesse en regime permanent\n for i in range(len(Tension)):\n T_max.append(0)\n # Calcul des Tensions max\n T_max[i] = (self.data[3][i]*(v_chute**2)+Tension[i])\n T_max[-1] = 0.0\n return T, V_chute_t, T_max\n else:\n QtGui.QMessageBox.warning(\n self, 'Message', \"Your Anchor is too light\")\n\n def Anchor_max_value(self):\n \"\"\"Cette fonction permet de calculer quel est le poids maximal du lest qui entraine une Tension max \n egale a la charge de rupture \n Output : masse maximale\"\"\"\n vec_v_chute = []\n Tension = []\n g = 9.81\n #Calcul de la flottabilite#\n for i in range(len(self.data[0])):\n Tension.append(0)\n for j in range(i+1):\n if j == len(self.data[0]):\n break\n else:\n if type(self.data[0][j]) != list:\n Tension[i] = Tension[i]+g*eval(self.data[0][j].mass)\n else:\n Tension[i] = Tension[i]+g * \\\n (eval(self.data[0][j][0].mass) +\n eval(self.data[0][j][1].mass))\n #On evalue la vitesse de chute maximale que supporte les elements du mouillage, depend de leur charge de rupture#\n for i in range(len(self.data[0])):\n if type(self.data[0][i]) != list:\n if hasattr(self.data[0][i], \"breaking_strength\"):\n v_chute = sqrt(\n (eval(self.data[0][i].breaking_strength)*g-Tension[i])/(self.data[3][i]))\n vec_v_chute.append(v_chute)\n else:\n if hasattr(self.data[0][i][0], \"breaking_strength\"):\n v_chute = sqrt(\n (eval(self.data[0][i][0].breaking_strength)*g-Tension[i])/(self.data[3][i]))\n vec_v_chute.append(v_chute)\n\n # On prend l element qui supporte la vitesse de chute la plus petite, cas le plus defavorable\n mass_max = (Tension[-2]+self.data[3][-1]*(min(vec_v_chute))**2)/g\n return mass_max\n\n def get_buoyancy_kg(self):\n \"\"\"Cette fonction permet de calculer la flottabilite restante en cas de sectionnement de la partie superieure en kg \"\"\"\n release_ind = 0\n for i in range(len(self.data[0])):\n # On recupere l indice du largueur car ce calcule nest pas pertinent en dessous de celui-ci\n if(self.data[0][i].__class__.__name__) == \"Releases\":\n release_ind = i\n self.Buoyancy_kg = [self.weight_kg[release_ind]]\n for i in reversed(range(release_ind)):\n self.Buoyancy_kg.insert(0, self.Buoyancy_kg[0]+self.weight_kg[i])\n while len(self.Buoyancy_kg) != len(self.weight_kg):\n self.Buoyancy_kg.append(0.0)\n\n def make_vector(self):\n \"\"\"Cette fonction permet de calculer la profondeur de chaque element(en son centre) \n Output : depth : vecteur profondeur\"\"\"\n depth = [self.data[1][1][len(self.data[1][0])-1]]\n\n #Calcul de la profondeur en haut de l element#\n for i in range(2, len(self.data[0])+2):\n depth.insert(0, 0)\n if type(self.data[0][-i+1]) != list:\n depth[-i] = depth[-i+1]+eval(self.data[0][-i+1].length)\n else:\n depth[-i] = depth[-i+1]+eval(self.data[0][-i+1][0].length)\n depth.remove(self.data[1][1][len(self.data[1][0])-1])\n #On enleve la moitie pour obtenir la profondeur du milieu de lelement#\n for i in range(len(self.data[0])):\n if type(self.data[0][i]) != list:\n depth[i] = depth[i]-eval(self.data[0][i].length)/2\n else:\n depth[i] = depth[i]-eval(self.data[0][i][0].length)/2\n return depth\n\n def current_vector(self, depth):\n \"\"\"Cette fonction permet dobtenir une valeur de courant par interpolation pour chaque profondeur du vecteur depth \n Input : Vecteur profondeur\n Output : Vecteur courant \"\"\"\n current_vector = []\n # On interpole lineairement, on calcul donc les coefficients k et b de la droite y=k*x+b\n for i in range(len(depth)):\n a = 0\n\n while(depth[i] < self.data[1][1][a]):\n a = a+1\n k = (self.data[1][0][a-1]-self.data[1][0][a]) / \\\n (self.data[1][1][a-1]-self.data[1][1][a])\n b = self.data[1][0][a-1]-k*self.data[1][1][a-1]\n current_vector.append(k*depth[i]+b)\n\n return current_vector\n\n def update_depth(self, depth, alpha):\n \"\"\"Cette fonction permet de mettre a jour le vecteur profondeur en fonction de l inclinaison de la ligne \n Input : depth : vecteur profondeur d origine\n alpha : vecteur angle \n Output : depth : vecteur profondeur mis a jour\"\"\"\n depth = [self.data[1][1][len(self.data[1][0])-1]]\n\n #Calcul de la profondeur en haut de l element#\n for i in range(2, len(self.data[0])+2):\n depth.insert(0, 0)\n if type(self.data[0][-i+1]) != list:\n depth[-i] = depth[-i+1] + \\\n cos(alpha[-i+1])*eval(self.data[0][-i+1].length)\n else:\n depth[-i] = depth[-i+1] + \\\n cos(alpha[-i+1])*eval(self.data[0][-i+1][0].length)\n depth.remove(self.data[1][1][len(self.data[1][0])-1])\n\n #Calcul de la profondeur au milieu de l element#\n for i in range(len(self.data[0])):\n if type(self.data[0][i]) != list:\n depth[i] = depth[i]-cos(alpha[i]) * \\\n eval(self.data[0][i].length)/2\n else:\n depth[i] = depth[i]-cos(alpha[i]) * \\\n eval(self.data[0][i][0].length)/2\n\n return depth\n\n def resolve(self):\n \"\"\"Resolution du comportement de la ligne de mouillage \n Output : F : Effort sur chaque element\n alpha : Inclinaison\n P : Poids en newton\n \"\"\"\n alpha = []\n alpha_new = []\n Fx = []\n Fy = []\n F = []\n Tn = []\n Tt = []\n P = []\n new_depth = []\n rho = 1028\n cond = 1\n fact_convergence = 1\n it = 0\n g = 9.81\n for i in range(len(self.depth)):\n alpha.append(0)\n alpha_new.append(0)\n Fx.append(0)\n Fy.append(0)\n Tn.append(0)\n Tt.append(0)\n F.append(0)\n new_depth.append(self.depth[i]) # Vecteur initialise precedemment\n #Calculate Weight#\n if type(self.data[0][i]) != list:\n P.append(eval(self.data[0][i].mass)*g)\n else:\n inter = [eval(self.data[0][i][0].mass)*g,\n eval(self.data[0][i][1].mass)*g]\n P.append(inter)\n\n while (cond == 1): # Tant que le systeme nest pas stable\n it = it+1\n for i in range(len(alpha)): # On met a jour la valeur de alpha\n alpha[i] = alpha_new[i]\n # On met a jour le vecteur profondeur\n new_depth = self.update_depth(new_depth, alpha)\n # On met a jour le vecteur de courant\n V = self.current_vector(new_depth)\n #On commence par la tete de mouillage#\n Tn[0] = 0.5*rho*eval(self.data[0][0].nl_drag_cf)*eval(self.data[0]\n [0].projected_area)*(V[0]*cos(alpha[0]))**2 # Calcul trainee normal\n Tt[0] = 0.5*rho*eval(self.data[0][0].tl_drag_cf)*eval(self.data[0]\n [0].projected_area)*(V[0]*sin(alpha[0]))**2 # Calcul trainee tangentielle\n Fx[0] = Tn[0]*cos(alpha[0])+Tt[0] * \\\n sin(alpha[0]) # Resultante selon x\n Fy[0] = Tt[0]*cos(alpha[0])-Tn[0]*sin(alpha[0]) + \\\n P[0] # Resultante selon y\n alpha_new[0] = atan(Fx[0]/Fy[0]) # Angle\n F[0] = sqrt(Fx[0]**2+Fy[0]**2) # Norme\n #On calcule element par element en partant du haut#\n for i in range(1, len(self.depth)-1):\n if type(self.data[0][i]) != list:\n Tn[i] = 0.5*rho*eval(self.data[0][i].nl_drag_cf)*eval(\n self.data[0][i].projected_area)*(V[i]*cos(alpha[i]))**2 # Calcul trainee normal\n Tt[i] = 0.5*rho*eval(self.data[0][i].tl_drag_cf)*eval(self.data[0][i].projected_area)*(\n V[i]*sin(alpha[i]))**2 # Calcul trainee tangentielle\n Fx[i] = Tn[i]*cos(alpha[i])+Tt[i] * \\\n sin(alpha[i])+Fx[i-1] # Resultante selon x\n Fy[i] = Tt[i]*cos(alpha[i])-Tn[i]*sin(alpha[i]) + \\\n P[i]+Fy[i-1] # Resultante selon y\n alpha_new[i] = fact_convergence*atan(Fx[i]/Fy[i]) # Angle\n F[i] = sqrt(Fx[i]**2+Fy[i]**2) # Norme\n #ELement clampe#\n else:\n\n Tn[i] = 0.5*rho*(V[i]*cos(alpha[i])**2)*(eval(self.data[0][i][0].nl_drag_cf)*eval(self.data[0][i][0].projected_area) + # Calcul trainee normal\n eval(self.data[0][i][1].nl_drag_cf)*eval(self.data[0][i][1].projected_area))\n\n Tt[i] = 0.5*rho*(V[i]*sin(alpha[i])**2)*(eval(self.data[0][i][0].tl_drag_cf)*eval(self.data[0][i][0].projected_area) + # Calcul trainee tangentielle\n eval(self.data[0][i][1].tl_drag_cf)*eval(self.data[0][i][1].projected_area))\n\n Fx[i] = Tn[i]*cos(alpha[i])+Tt[i] * \\\n sin(alpha[i])+Fx[i-1] # Resultante selon x\n Fy[i] = Tt[i]*cos(alpha[i])-Tn[i]*sin(alpha[i]) + \\\n P[i][0]+P[i][1]+Fy[i-1] # Resultante selon y\n alpha_new[i] = fact_convergence*atan(Fx[i]/Fy[i]) # Angle\n F[i] = sqrt(Fx[i]**2+Fy[i]**2) # Norme\n\n cond = 0\n\n for i in range(len(self.depth)): # Condition d arret\n if abs(alpha[i]-alpha_new[i]) > 0.0001:\n cond = 1\n break\n\n return alpha, F, P\n\n def calculate_stretch(self, F):\n \"\"\"Cette fonction permet de calculer l allongement dun cable en fonction de leffort qui lui est applique\n Input : F : Effort subit par le cable \"\"\"\n new_stretch = 0\n self.percent_stretch = []\n for i in range(len(self.data[0])):\n new_stretch = 0\n if type(self.data[0][i]) != list:\n if self.data[0][i].__class__.__name__ == \"Ropes\":\n # On calcule le pourcentage de la charge de rupture qui est applique au cable\n ratio = 100/9.81 * \\\n (F[i]/eval(self.data[0][i].breaking_strength))\n new_stretch = (round(eval(self.data[0][i].poly_1), 2)*ratio**2+round(eval(\n self.data[0][i].poly_2), 2)*ratio+round(eval(self.data[0][i].poly_3), 2))/100\n # En fonction des 3 coefficients polynomiales entre pour le materiau on calcul lallongement : allongement (%) = coeff1*(%Charge de rupture)^2+coeff2*(%Charge de rupture)+coeff3\n # On met a jour la nouvelle longueur\n self.data[0][i].length = str(\n eval(self.data[0][i].length)*(1+new_stretch))\n #Element clampe#\n else:\n if self.data[0][i][0].__class__.__name__ == \"Ropes\":\n ratio = 100/9.81 * \\\n (F[i]/eval(self.data[0][i][0].breaking_strength))\n new_stretch = (round(eval(self.data[0][i][0].poly_1), 2)*ratio**2+round(eval(\n self.data[0][i][0].poly_2), 2)*ratio+round(eval(self.data[0][i][0].poly_3), 2))/100\n self.data[0][i][0].length = str(\n eval(self.data[0][i][0].length)*(1+new_stretch))\n self.percent_stretch.append(100*new_stretch)\n\n def calculate_ratio(self, alpha):\n \"\"\"Cette fonction permet de calculer le ratio de clampage definie par lutilisateur comme automatique \n Input : alpha : vecteur angle d inclinaison\"\"\"\n\n #Calcul des coordonnees x et y en fonction de l inclinaison#\n y_float = [self.data[1][1][len(self.data[1][0])-1]]\n for i in range(len(self.data[2])):\n if type(self.data[2][i]) != list:\n if self.data[2][i] > 0:\n self.data[2][i] = self.data[2][i]+y_float[-1]\n else:\n if self.data[2][i][1] > 0:\n self.data[2][i][1] = self.data[2][i][1]+y_float[-1]\n\n x_float = [0]\n for i in range(2, len(self.data[0])+2):\n y_float.insert(0, 0)\n x_float.insert(0, 0)\n if type(self.data[0][-i+1]) != list:\n y_float[-i] = y_float[-i+1] + \\\n cos(alpha[-i+1])*eval(self.data[0][-i+1].length)\n x_float[-i] = x_float[-i+1] + \\\n sin(alpha[-i+1])*eval(self.data[0][-i+1].length)\n else:\n y_float[-i] = y_float[-i+1] + \\\n cos(alpha[-i+1])*eval(self.data[0][-i+1][0].length)\n x_float[-i] = x_float[-i+1] + \\\n sin(alpha[-i+1])*eval(self.data[0][-i+1][0].length)\n y_float.remove(self.data[1][1][len(self.data[1][0])-1])\n x_float.remove(x_float[-1])\n self.myxfloat = x_float\n self.myyfloat = y_float\n # Coordonnee x de la bouee de tete\n self.x_instru = [x_float[0] -\n sin(alpha[0])*eval(self.data[0][0].length)/2]\n # Coordonnee y de la bouee de tete\n self.y_instru = [y_float[0] -\n cos(alpha[0])*eval(self.data[0][0].length)/2]\n self.x_instru_top = []\n self.y_instru_top = []\n self.name_instru = [self.data[0][0].name] # Nom de la bouee de tete\n for i in range(len(self.data[6])):\n if self.data[6][i] == 0.0: # Ratio defini comme auto\n calc = 0\n # Si la profondeur choisi par lutilisateur est plus haut que le support de clampage\n if self.data[2][self.find_match(i)][1] > self.myyfloat[self.find_match(i)]:\n # le ratio est fixe au minimum c est a dire 0\n self.data[6][i] = 0\n calc = 1\n # Si la profondeur choisi par lutilisateur est plus basse que le support de clampage\n if self.data[2][self.find_match(i)][1] < self.myyfloat[self.find_match(i+1)]:\n # le ratio est fixe au minimum c est a dire 1\n self.data[6][i] = 1\n calc = 1\n if calc == 0:\n malongueur = eval(\n self.data[0][self.find_match(i)][0].length)\n lon = 0\n p = 1\n for j in range(int(self.table_match[i])+1, int(self.table_match[i+1])):\n malongueur = malongueur+eval(self.data[0][j].length)\n while(self.myyfloat[self.find_match(i)+p] > self.data[2][self.find_match(i)][1]):\n if type(self.data[0][self.find_match(i)+p-1]) != list:\n lon = lon + \\\n eval(self.data[0]\n [self.find_match(i)+p-1].length)\n else:\n lon = lon + \\\n eval(\n self.data[0][self.find_match(i)+p-1][0].length)\n p = p+1\n ratio = ((self.myyfloat[self.find_match(i)+p-1]-self.data[2][self.find_match(i)][1])/(cos(alpha[self.find_match(i)+p-1]))\n + 0.5*eval(self.data[0][self.find_match(i)][1].length)+lon)/malongueur\n self.data[6][i] = ratio\n\n if self.data[6][i] >= 1 or self.data[6][i] <= 0:\n QtGui.QMessageBox.warning(\n self, 'Message', \"An instrument is clamped beyond it support\")\n\n #Calcul de la profondeur des instruments#\n for i in range(len(self.data[6])):\n if type(self.data[0][self.find_match(i)]) != list:\n if (self.data[0][self.find_match(i)]).__class__.__name__ == \"Instruments\":\n self.name_instru.append(\n self.data[0][self.find_match(i)].name)\n self.x_instru.append(self.myxfloat[self.find_match(\n i)]-0.5*eval(self.data[0][self.find_match(i)].length)*sin(alpha[self.find_match(i)]))\n self.y_instru.append(self.myyfloat[self.find_match(\n i)]-0.5*eval(self.data[0][self.find_match(i)].length)*cos(alpha[self.find_match(i)]))\n # coordonnee x en haut de l instrument\n self.x_instru_top.append(self.myxfloat[self.find_match(i)])\n # coordonnee y en haut de l instrument\n self.y_instru_top.append(self.myyfloat[self.find_match(i)])\n #Element clampe#\n else:\n if (self.data[0][self.find_match(i)][1]).__class__.__name__ == \"Instruments\":\n self.name_instru.append(\n self.data[0][self.find_match(i)][1].name)\n malongueur = eval(\n self.data[0][self.find_match(i)][0].length)\n lon = eval(self.data[0][self.find_match(i)][0].length)\n lon2 = lon\n p = 0\n ratio = self.data[6][i]\n for j in range(int(self.table_match[i])+1, int(self.table_match[i+1])):\n malongueur = malongueur+eval(self.data[0][j].length)\n while(lon < malongueur*self.data[6][i]):\n ratio = ratio-lon2/malongueur\n p = p+1\n lon = lon + \\\n eval(self.data[0]\n [int(self.table_match[i])+p].length)\n lon2 = eval(\n self.data[0][int(self.table_match[i])+p].length)\n\n self.x_instru.append(self.myxfloat[self.find_match(\n i)+p]-ratio*malongueur*sin(alpha[self.find_match(i)+p]))\n self.y_instru.append(self.myyfloat[self.find_match(\n i)+p]-ratio*malongueur*cos(alpha[self.find_match(i)+p]))\n self.x_instru_top.append(self.myxfloat[self.find_match(i)+p]-(ratio*malongueur-0.5*eval(\n self.data[0][self.find_match(i)][1].length))*sin(alpha[self.find_match(i)+p])) # coordonnee x en haut de l instrument\n self.y_instru_top.append(self.myyfloat[self.find_match(i)+p]-(ratio*malongueur-0.5*eval(\n self.data[0][self.find_match(i)][1].length))*cos(alpha[self.find_match(i)+p])) # coordonnee y en haut de l instrument\n\n def calculate_subduction(self):\n \"\"\"Cette fonction permet de calculer la subduction entrainee par le courant et les allongements \n Output : vecteur subduct \"\"\"\n subduct = []\n for i in range(len(self.static_depth)):\n subduct.append(self.static_depth[i]-self.myyfloat[i])\n return subduct\n\n def find_match(self, ind):\n \"\"\"Cette fonction utilise la table de correspondance \n Input : Indice sans troncon de cable\n Output : Indice avec troncon\"\"\"\n return int(self.table_match[ind])\n\n def resolve_backup(self, P):\n \"\"\"Cette fonction permet de resoudre le backup jusqu au largueurs \n Input : poids en newton \n Output : backup,zero de flottabilite\"\"\"\n result2 = []\n zero = []\n for i in range(len(self.data[0])):\n if(self.data[0][i].__class__.__name__) == \"Releases\":\n self.release_ind = i+1\n\n for i in range(self.release_ind):\n result = 0\n for j in range(i, self.release_ind):\n if type(P[j]) != list:\n result = result+P[j]\n else:\n result = result+P[j][0]+P[j][1]\n result2.append(result)\n for i in range(len(result2)):\n zero.append(0)\n return result2, zero\n\n def plot_figure(self, alpha, P, F):\n \"\"\"Cette fonction permet de tracer les quatres graphes \n Input : alpha : angle d inclinaison\n : P : Poids\n F : Effort\n \"\"\"\n\n if hasattr(self, \"plot_mooring\"):\n self.plot_mooring.hide()\n\n backup, zero = self.resolve_backup(P)\n\n for i in range(len(self.T_max)):\n self.old_depth.append(self.myyfloat[self.find_match(i)])\n\n self.groupLayout = QtGui.QVBoxLayout()\n self.scrollArea = QtGui.QScrollArea()\n self.groupLayout.addWidget(self.scrollArea)\n self.scrolledWidget = QtGui.QWidget() # Zone de defilement verticale\n self.scrolledWidget.setMinimumWidth(self.data[4])\n self.layout = QtGui.QVBoxLayout(self.scrolledWidget)\n\n self.widget_graph = QtGui.QWidget(self)\n\n sc1 = MySimulateCanvas(self.myxfloat, self.myyfloat, backup, self.T_max, self.T,\n self.old_depth, self.V_chute_t, self.release_ind, self.name_instru,\n self.x_instru, self.y_instru, self.data[5], self.widget_graph)\n self.layout.addWidget(sc1)\n min_value_anchor = F[-2]/9.81 # Valeur minimale lest\n # Valeur safe lest formule visbeck runmoor\n safe_value_anchor = (1.5/9.81) * \\\n (F[-2]*(cos(alpha[-2])+0.6*sin(alpha[-2])))\n self.anchor_value = [round(safe_value_anchor, 1), -1*round(\n float(self.data[0][-1].mass), 1), round(max(self.percent_max_T), 1)]\n #Affichage valeurs lest#\n self.widget_anchors = QtGui.QWidget(self)\n self.anchors_layout = QtGui.QGridLayout()\n label1 = QtGui.QLabel(\"Anchors's WET weight (kg)\")\n label1.setStyleSheet(\n \"QLabel { background-color : white; color : black;border: 2px solid black }\")\n label2 = QtGui.QLabel(\"Min\")\n label2.setStyleSheet(\n \"QLabel { background-color : white; color : black;border: 2px solid black }\")\n label3 = QtGui.QLabel(\"Max\")\n label3.setStyleSheet(\n \"QLabel { background-color : white; color : black;border: 2px solid black }\")\n label4 = QtGui.QLabel(str(round(min_value_anchor, 1)))\n label4.setStyleSheet(\n \"QLabel { background-color : white; color : black;border: 1px solid black }\")\n label5 = QtGui.QLabel(str(round(self.max_value_anchor, 1)))\n label5.setStyleSheet(\n \"QLabel { background-color : white; color : black;border: 1px solid black }\")\n label6 = QtGui.QLabel(\"Safe Anchor's weight\")\n label6.setStyleSheet(\n \"QLabel { background-color : white; color : black;border: 2px solid black }\")\n label7 = QtGui.QLabel(\"Selected Anchor's weight\")\n label7.setStyleSheet(\n \"QLabel { background-color : white; color : black;border: 2px solid black }\")\n label8 = QtGui.QLabel(str(self.anchor_value[0]))\n label8.setStyleSheet(\n \"QLabel { background-color : white; color : black;border: 1px solid black }\")\n label9 = QtGui.QLabel(str(self.anchor_value[1]))\n # Valeur choisie < valeur recommande\n if self.anchor_value[1] < self.anchor_value[0]:\n label9.setStyleSheet(\n \"QLabel { background-color : red; color : white ;border: 2px solid black }\")\n else:\n label9.setStyleSheet(\n \"QLabel { background-color : green; color : white;border: 1px solid black }\")\n\n label10 = QtGui.QLabel(\"Max Launch Tension / Breaking Strength (%)\")\n label10.setStyleSheet(\n \"QLabel { background-color : white; color : black;border: 2px solid black }\")\n label11 = QtGui.QLabel(str(self.anchor_value[2]))\n if round(max(self.percent_max_T), 1) > 40: # T_max/Ultimate_load >40%\n label11.setStyleSheet(\n \"QLabel { background-color : red; color : white ;border: 2px solid black }\")\n else:\n label11.setStyleSheet(\n \"QLabel { background-color : green; color : white;border: 1px solid black }\")\n\n self.anchors_layout.addWidget(label2, 0, 1)\n self.anchors_layout.addWidget(label3, 0, 3)\n self.anchors_layout.addWidget(label1, 1, 0)\n self.anchors_layout.addWidget(label4, 1, 1)\n self.anchors_layout.addWidget(label5, 1, 3)\n self.anchors_layout.addWidget(label6, 0, 2)\n self.anchors_layout.addWidget(label7, 0, 4)\n self.anchors_layout.addWidget(label8, 1, 2)\n self.anchors_layout.addWidget(label9, 1, 4)\n self.anchors_layout.addWidget(label10, 2, 0)\n self.anchors_layout.addWidget(label11, 2, 1)\n\n self.widget_anchors.setLayout(self.anchors_layout)\n self.layout.addWidget(self.widget_anchors)\n\n def make_table(self, alpha, F):\n \"\"\"Cette fonction permet de creer le tableau qui contient toutes les informations de la simulation\n Input : alpha : Vecteur angle d inclinaison\n F : Vecteur effort \"\"\"\n name = []\n length = []\n length_stretch = []\n Tab_final = []\n self.Tab_report = []\n ind_instrum = []\n my_prof = []\n F_Kp = []\n warn = []\n count = 0\n release_ind = 0\n #Reconstitue les troncons en un seul cable#\n for i in range(len(self.table_match)):\n for j in range(i, int(self.table_match[i])-count):\n if type(self.data[0][i-1]) != list:\n self.data[0][i-1].length = str(\n eval(self.data[0][i-1].length)+eval(self.data[0][i].length))\n self.data[0][i-1].mass = str(eval(self.data[0]\n [i-1].mass)+eval(self.data[0][i].mass))\n self.data[0][i-1].projected_area = str(\n eval(self.data[0][i-1].projected_area)+eval(self.data[0][i].projected_area))\n else:\n self.data[0][i-1][0].length = str(\n eval(self.data[0][i-1][0].length)+eval(self.data[0][i].length))\n self.data[0][i-1][0].mass = str(\n eval(self.data[0][i-1][0].mass)+eval(self.data[0][i].mass))\n self.data[0][i-1][0].projected_area = str(\n eval(self.data[0][i-1][0].projected_area)+eval(self.data[0][i].projected_area))\n del(self.data[0][i])\n del(alpha[i])\n del(F[i])\n del(self.myxfloat[i])\n del(self.myyfloat[i])\n del(self.percent_stretch[i])\n count = count+1\n\n size = len(self.data[0])-1\n for i in range(len(alpha)):\n alpha[i] = alpha[i]*(180/(3.14)) # Converti radian en degre\n\n subduct = self.calculate_subduction() # Calcule de la subduction\n\n for p in self.data[0]:\n if type(p) != list:\n name.append(p.name)\n else:\n # Recuperation des noms\n name.append(p[0].name+' '+'+'+' '+p[1].name)\n\n count = 0\n for i in range(len(self.data[0])):\n\n F_Kp.append(F[i]/9.81) # Convertion des efforts en Kp\n if type(self.data[0][i]) != list:\n length.append(self.original_length[i])\n my_prof.append(str(round(self.myyfloat[i], 1)))\n # Detection des instruments\n if self.data[0][i].__class__.__name__ == \"Instruments\":\n ind_instrum.append(i)\n count = count+1\n if self.data[0][i].__class__.__name__ == \"Releases\": # Detection du release\n release_ind = i\n\n if self.data[0][i].__class__.__name__ == \"Ropes\":\n length_stretch.append(str(round(eval(self.data[0][i].length), 1))+' '+'('+str(\n round(self.percent_stretch[i], 1))+'%'+')') # Recuperation des longueurs allongees\n else:\n length_stretch.append('')\n\n #Element clampe#\n else:\n length.append(self.original_length[i][0])\n if self.data[0][i][1].__class__.__name__ == \"Instruments\":\n ind_instrum.append(i)\n my_prof.append(str(round(self.myyfloat[i], 1))+' '+'+'+' '+str(round(self.y_instru_top[count], 1))+' '+'ratio = '+str(\n round(self.data[6][i], 2))) # Affichage profondeur support+profondeur element clampe+clamp_ratio\n if self.data[6][i] >= 1 or self.data[6][i] <= 0:\n warn.append(i)\n count = count+1\n else:\n my_prof.append(str(round(self.myyfloat[i], 1)))\n if self.data[0][i].__class__.__name__ == \"Ropes\":\n length_stretch.append(\n self.data[0][i][0].length+' '+'('+self.percent_stretch[i]+')')\n else:\n length_stretch.append('')\n\n Tab = np.zeros((size+1, 8))\n Tab[:, 0] = length\n Tab[:, 1] = F_Kp\n Tab[:, 2] = alpha\n Tab[:, 3] = self.myxfloat\n Tab[:, 4] = subduct\n Tab[:, 5] = self.Buoyancy_kg\n Tab[:, 6] = self.weight_kg\n Tab[:, 7] = self.percent_max_T\n\n for i in range(Tab.shape[0]):\n inter = [name[i]] # On commence par les noms\n for j in range(1):\n inter.append(Tab[i][j]) # Longueur\n inter.append(my_prof[i]) # Profondeur\n for j in range(1, Tab.shape[1]): # Reste du tableau\n inter.append(Tab[i][j])\n inter.append(length_stretch[i])\n Tab_final.append(inter)\n Tab_final.insert(0, [\"Name\", \"Static Length (m)\", \"Depth (m)\", \"Tension (Kp)\", \"Angle (deg)\",\n \"Dx (m)\", \"Dz (m)\", \"Buoy (kg)\", \"Weight (kg)\", \"Launch Tension (%)\", \"Length Stretched (m)\"])\n tab_grid = QtGui.QGridLayout()\n inter = []\n for j in range(len(Tab_final[0])): # Affichage du nom des categories\n label = QtGui.QLabel(Tab_final[0][j])\n label.setStyleSheet(\n \"QLabel { background-color : white; color : black;border: 2px solid black }\")\n tab_grid.addWidget(label, 0, j)\n inter.append(Tab_final[0][j])\n\n self.Tab_report.append(inter)\n for k in range(1, len(Tab_final)):\n # Affichage de chaque element sauf terminaison\n if self.data[0][k-1].__class__.__name__ != \"Terminals\":\n inter = []\n for l in range(len(Tab_final[k])):\n if type(Tab_final[k][l]) != str:\n Tab_final[k][l] = str(round(Tab_final[k][l], 1))\n inter.append(Tab_final[k][l])\n label = QtGui.QLabel(Tab_final[k][l])\n # On repere en bleu ciel : la bouee de tete, les instruments, les largueurs, et le lest\n if k-1 in ind_instrum or k == 1 or k-1 == release_ind or k == len(Tab_final)-1:\n label.setStyleSheet(\n \"QLabel { background-color : rgb(168, 211, 255); color : black;border: 1px solid black }\")\n if k-1 in warn: # Un instrument clampe au dela de son support\n label.setStyleSheet(\n \"QLabel { background-color : red; color : black;border: 1px solid black }\")\n\n else:\n label.setStyleSheet(\n \"QLabel { background-color : white; color : black;border: 1px solid black }\")\n tab_grid.addWidget(label, k, l)\n self.Tab_report.append(inter)\n tab_grid.setSpacing(0)\n\n self.layout.addLayout(tab_grid)\n\n self.scrollArea.setWidget(self.scrolledWidget)\n self.setLayout(self.groupLayout)\n", "meta": {"hexsha": "0f042db9051fa336847452ec73a2991963857428", "size": 44357, "ext": "py", "lang": "Python", "max_stars_repo_path": "simulate_window.py", "max_stars_repo_name": "jgrelet/Mooring-simulator", "max_stars_repo_head_hexsha": "e032b3f6d853d2df32d8c2c449c243d9632c7abb", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "simulate_window.py", "max_issues_repo_name": "jgrelet/Mooring-simulator", "max_issues_repo_head_hexsha": "e032b3f6d853d2df32d8c2c449c243d9632c7abb", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "simulate_window.py", "max_forks_repo_name": "jgrelet/Mooring-simulator", "max_forks_repo_head_hexsha": "e032b3f6d853d2df32d8c2c449c243d9632c7abb", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 49.0674778761, "max_line_length": 196, "alphanum_fraction": 0.5184074667, "include": true, "reason": "import numpy", "num_tokens": 11103, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6926419831347362, "lm_q2_score": 0.28140561345566495, "lm_q1q2_score": 0.1949133421691788}} {"text": "import math\n\nimport numpy as np\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom mmcv.cnn import kaiming_init\nfrom mmdet.ops import DeformConv\n\nclass NovelKQRAttention(nn.Module):\n \"\"\"Modified GeneralizedAttention module.\n\n See 'An Empirical Study of Spatial Attention Mechanisms in Deep Networks'\n (https://arxiv.org/abs/1711.07971) for details.\n\n Args:\n in_dim (int): Channels of the input feature map.\n spatial_range (int): The spatial range.\n -1 indicates no spatial range constraint.\n num_heads (int): The head number of empirical_attention module.\n position_embedding_dim (int): The position embedding dimension.\n position_magnitude (int): A multiplier acting on coord difference.\n kv_stride (int): The feature stride acting on key/value feature map.\n q_stride (int): The feature stride acting on query feature map.\n attention_type (str): A binary indicator string for indicating which\n items in generalized empirical_attention module are used.\n '1000' indicates 'query and key content' (appr - appr) item,\n '0100' indicates 'query content and relative position'\n (appr - position) item,\n '0010' indicates 'key content only' (bias - appr) item,\n '0001' indicates 'relative position only' (bias - position) item.\n \"\"\"\n\n def __init__(self,\n in_dim,\n spatial_range=-1,\n num_heads=9,\n position_embedding_dim=-1,\n position_magnitude=1,\n kv_stride=2,\n q_stride=1,\n attention_type='0110',\n deformable_group=1,\n dconv_stride = 1,\n dconv_groups =1,\n dconv_learnable_vector = True):\n\n super(NovelKQRAttention, self).__init__()\n\n # hard range means local range for non-local operation\n self.position_embedding_dim = (\n position_embedding_dim if position_embedding_dim > 0 else in_dim)\n\n self.position_magnitude = position_magnitude\n self.num_heads = num_heads\n self.channel_in = in_dim\n self.spatial_range = spatial_range\n self.kv_stride = kv_stride\n self.q_stride = q_stride\n self.attention_type = [bool(int(_)) for _ in attention_type]\n self.qk_embed_dim = in_dim // num_heads\n self.deformable_group = deformable_group\n self.dconv_stride = dconv_stride\n self.dconv_learnable_vector = dconv_learnable_vector\n self.dconv_groups = dconv_groups\n out_c = self.qk_embed_dim * num_heads\n\n\n if self.attention_type[2]:\n self.key_conv = nn.Conv2d(\n in_channels=in_dim,\n out_channels=out_c,\n kernel_size=1,\n bias=False)\n self.key_conv.kaiming_init = True\n\n if self.attention_type[1]:\n self.query_conv_offset = nn.Conv2d(\n in_channels=in_dim,\n out_channels=self.deformable_group * 18,\n kernel_size=3,\n padding=1,\n stride = self.dconv_stride,\n dilation=1,\n bias=False)\n\n self.query_dconv=DeformConv(\n in_channels =in_dim,\n out_channels = out_c,\n kernel_size=3,\n stride = self.dconv_stride,\n padding = 1,\n dilation =1,\n deformable_groups = self.deformable_group,\n groups= self.dconv_groups,\n bias = False)\n\n self.v_dim = in_dim // num_heads\n self.value_conv = nn.Conv2d(\n in_channels=in_dim,\n out_channels=self.v_dim * num_heads,\n kernel_size=1,\n bias=False)\n self.value_conv.kaiming_init = True\n\n\n if self.attention_type[2]:\n stdv = 1.0 / math.sqrt(self.qk_embed_dim * 2)\n appr_bias_value = -2 * stdv * torch.rand(out_c) + stdv\n self.appr_bias = nn.Parameter(appr_bias_value)\n\n if self.attention_type[1] and self.dconv_learnable_vector == True :\n stdv = 1.0 / math.sqrt(self.qk_embed_dim * 2)\n appr_bias_qRelPos = -2 * stdv * torch.rand(out_c) + stdv\n self.appr_bias_qRelPos = nn.Parameter(appr_bias_qRelPos)\n\n\n self.proj_conv = nn.Conv2d(\n in_channels=self.v_dim * num_heads,\n out_channels=in_dim,\n kernel_size=1,\n bias=True)\n self.proj_conv.kaiming_init = True\n self.gamma = nn.Parameter(torch.zeros(1))\n\n if self.spatial_range >= 0:\n # only works when non local is after 3*3 conv\n if in_dim == 256:\n max_len = 84\n elif in_dim == 512:\n max_len = 42\n\n max_len_kv = int((max_len - 1.0) / self.kv_stride + 1)\n local_constraint_map = np.ones(\n (max_len, max_len, max_len_kv, max_len_kv), dtype=np.int)\n for iy in range(max_len):\n for ix in range(max_len):\n local_constraint_map[iy, ix,\n max((iy - self.spatial_range) //\n self.kv_stride, 0):min(\n (iy + self.spatial_range +\n 1) // self.kv_stride +\n 1, max_len),\n max((ix - self.spatial_range) //\n self.kv_stride, 0):min(\n (ix + self.spatial_range +\n 1) // self.kv_stride +\n 1, max_len)] = 0\n\n self.local_constraint_map = nn.Parameter(\n torch.from_numpy(local_constraint_map).byte(),\n requires_grad=False)\n\n if self.q_stride > 1:\n self.q_downsample = nn.AvgPool2d(\n kernel_size=1, stride=self.q_stride)\n else:\n self.q_downsample = None\n\n if self.kv_stride > 1:\n self.kv_downsample = nn.AvgPool2d(\n kernel_size=1, stride=self.kv_stride)\n else:\n self.kv_downsample = None\n\n self.init_weights()\n\n\n def forward(self, x_input):\n num_heads = self.num_heads\n\n # use empirical_attention\n if self.q_downsample is not None:\n x_q = self.q_downsample(x_input)\n else:\n x_q = x_input\n n, _, h, w = x_q.shape\n\n if self.dconv_stride > 1:\n h,w = h//self.dconv_stride, w//self.dconv_stride\n\n if self.kv_downsample is not None:\n x_kv = self.kv_downsample(x_input)\n else:\n x_kv = x_input\n _, _, h_kv, w_kv = x_kv.shape\n\n\n if self.attention_type[2]:\n proj_key = self.key_conv(x_kv).view(\n (n, num_heads, self.qk_embed_dim, h_kv * w_kv))\n\n if self.attention_type[1]:\n offset = self.query_conv_offset(x_q)\n proj_query_relativePos =self.query_dconv(x_q,offset).view(n,num_heads,self.qk_embed_dim,h*w)\n\n\n # accelerate for saliency only\n if (np.sum(self.attention_type) == 1) and self.attention_type[2]:\n appr_bias = self.appr_bias.\\\n view(1, num_heads, 1, self.qk_embed_dim).\\\n repeat(n, 1, 1, 1)\n\n energy = torch.matmul(appr_bias, proj_key).\\\n view(n, num_heads, 1, h_kv * w_kv)\n\n h = 1\n w = 1\n else:\n if not self.attention_type[0]:\n energy = torch.zeros(\n n,\n num_heads,\n h,\n w,\n h_kv,\n w_kv,\n dtype=x_input.dtype,\n device=x_input.device)\n\n # Key Content\n if self.attention_type[2]:\n appr_bias = self.appr_bias.\\\n view(1, num_heads, 1, self.qk_embed_dim).\\\n repeat(n, 1, 1, 1)\n\n energy += torch.matmul(appr_bias, proj_key).\\\n view(n, num_heads, 1, 1, h_kv, w_kv)\n\n # Query Content and Relative Position\n if self.attention_type[1]:\n\n if self.dconv_learnable_vector == False :\n energy+=proj_query_relativePos.view(n,num_heads,h,w,1,1)\n\n else:\n appr_bias_qRelPos = self.appr_bias_qRelPos.\\\n view(1,num_heads,1,self.qk_embed_dim).\\\n repeat(n,1,1,1)\n energy+= torch.matmul(appr_bias_qRelPos,proj_query_relativePos).\\\n view(n,num_heads,h,w,1,1)\n\n\n energy = energy.view(n,num_heads,h*w,h_kv*w_kv)\n\n if self.spatial_range >= 0:\n cur_local_constraint_map = \\\n self.local_constraint_map[:h, :w, :h_kv, :w_kv].\\\n contiguous().\\\n view(1, 1, h*w, h_kv*w_kv)\n\n energy = energy.masked_fill_(cur_local_constraint_map,\n float('-inf'))\n\n\n attention = F.softmax(energy, 3)\n\n\n proj_value = self.value_conv(x_kv)\n proj_value_reshape = proj_value.\\\n view((n, num_heads, self.v_dim, h_kv * w_kv)).\\\n permute(0, 1, 3, 2)\n\n out = torch.matmul(attention, proj_value_reshape).\\\n permute(0, 1, 3, 2).\\\n contiguous().\\\n view(n, self.v_dim * self.num_heads, h, w)\n\n out = self.proj_conv(out)\n\n if self.dconv_stride > 1:\n out = F.interpolate(out,scale_factor=self.dconv_stride)\n\n if self.q_stride > 1:\n out = F.interpolate(out,size=x_input.size()[2:])\n\n out = self.gamma * out + x_input\n\n return out\n\n def init_weights(self):\n for m in self.modules():\n if hasattr(m, 'kaiming_init') and m.kaiming_init:\n kaiming_init(\n m,\n mode='fan_in',\n nonlinearity='leaky_relu',\n bias=0,\n distribution='uniform',\n a=1)\n", "meta": {"hexsha": "672d2599a93a740f26f10192bc0ee35541092f28", "size": 10382, "ext": "py", "lang": "Python", "max_stars_repo_path": "mmdetection/mmdet/models/plugins/novelKQR_self_attention.py", "max_stars_repo_name": "muditchaudhary/RepPoints-x-Libra-R-CNN-x-Transformer-self-attention", "max_stars_repo_head_hexsha": "b4c20fad012da3382de83a37481c767f66985ead", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-03-01T03:48:13.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-01T03:48:13.000Z", "max_issues_repo_path": "mmdetection/mmdet/models/plugins/novelKQR_self_attention.py", "max_issues_repo_name": "muditchaudhary/RepPoints-x-Libra-R-CNN-x-Transformer-self-attention", "max_issues_repo_head_hexsha": "b4c20fad012da3382de83a37481c767f66985ead", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-09-10T02:43:34.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-10T03:20:46.000Z", "max_forks_repo_path": "mmdetection/mmdet/models/plugins/novelKQR_self_attention.py", "max_forks_repo_name": "muditchaudhary/RepPoints-x-Libra-R-CNN-x-Transformer-self-attention", "max_forks_repo_head_hexsha": "b4c20fad012da3382de83a37481c767f66985ead", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.676975945, "max_line_length": 104, "alphanum_fraction": 0.5261991909, "include": true, "reason": "import numpy", "num_tokens": 2322, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6477982315512488, "lm_q2_score": 0.3007455726738824, "lm_q1q2_score": 0.19482245012500862}} {"text": "import logging\n\nimport numpy as np\nimport pandas as pd\nfrom numba import njit\nfrom scipy.special import expn\nfrom scipy.interpolate import PchipInterpolator\nfrom collections import Counter as counter\nfrom tardis import constants as const\n\nfrom tardis.plasma.properties.base import (\n ProcessingPlasmaProperty,\n HiddenPlasmaProperty,\n BaseAtomicDataProperty,\n)\nfrom tardis.plasma.exceptions import IncompleteAtomicData\nfrom tardis.plasma.properties.continuum_processes import (\n get_ground_state_multi_index,\n K_B,\n BETA_COLL,\n H,\n A0,\n M_E,\n C,\n)\n\nlogger = logging.getLogger(__name__)\n\n__all__ = [\n \"Levels\",\n \"Lines\",\n \"LinesLowerLevelIndex\",\n \"LinesUpperLevelIndex\",\n \"AtomicMass\",\n \"IonizationData\",\n \"ZetaData\",\n \"NLTEData\",\n \"MacroAtomData\",\n \"PhotoIonizationData\",\n \"YgData\",\n \"YgInterpolator\",\n \"LevelIdxs2LineIdx\",\n \"LevelIdxs2TransitionIdx\",\n \"TwoPhotonData\",\n \"ContinuumInteractionHandler\",\n]\n\n\nclass Levels(BaseAtomicDataProperty):\n \"\"\"\n Attributes\n ----------\n levels : pandas.MultiIndex\n (atomic_number, ion_number, level_number)\n Index of filtered atomic data. Index used for all other attribute dataframes for this class\n excitation_energy : pandas.DataFrame, dtype float\n Excitation energies of atomic levels.\n Index is levels.\n metastability : pandas.DataFrame, dtype bool\n Records whether atomic levels are metastable.\n Index is levels.\n g : pandas.DataFrame (index=levels), dtype float\n Statistical weights of atomic levels.\n \"\"\"\n\n outputs = (\"levels\", \"excitation_energy\", \"metastability\", \"g\")\n latex_name = (\n r\"\\textrm{levels}\",\n r\"\\epsilon_{\\textrm{k}}\",\n r\"\\textrm{metastability}\",\n \"g\",\n )\n\n def _filter_atomic_property(self, levels, selected_atoms):\n return levels\n # return levels[levels.atomic_number.isin(selected_atoms)]\n\n def _set_index(self, levels):\n # levels = levels.set_index(['atomic_number', 'ion_number',\n # 'level_number'])\n return (\n levels.index,\n levels[\"energy\"],\n levels[\"metastable\"],\n levels[\"g\"],\n )\n\n\nclass Lines(BaseAtomicDataProperty):\n \"\"\"\n Attributes\n ----------\n lines : pandas.DataFrame\n Atomic lines data. Columns are wavelength, atomic_number,ion_number,\n f_ul, f_lu, level_number_lower, level_number_upper, nu, B_lu, B_ul, A_ul,\n wavelength. Index is line_id.\n nu : pandas.DataFrame, dtype float\n Line frequency data. Index is line_id.\n f_lu : pandas.DataFrame, dtype float\n Transition probability data. Index is line_id.\n wavelength_cm : pandas.DataFrame, dtype float\n Line wavelengths in cm. Index is line_id.\n \"\"\"\n\n # Would like for lines to just be the line_id values\n outputs = (\"lines\", \"nu\", \"f_lu\", \"wavelength_cm\")\n\n latex_name = (\n r\"\\textrm{lines}\",\n r\"\\nu\",\n r\"f_lu\",\n r\"\\lambda_{cm}\",\n )\n\n def _filter_atomic_property(self, lines, selected_atoms):\n # return lines[lines.atomic_number.isin(selected_atoms)]\n return lines\n\n def _set_index(self, lines):\n # lines.set_index('line_id', inplace=True)\n return lines, lines[\"nu\"], lines[\"f_lu\"], lines[\"wavelength_cm\"]\n\n\nclass MacroAtomData(BaseAtomicDataProperty):\n outputs = (\"macro_atom_data\",)\n\n def _filter_atomic_property(self, macro_atom_data, selected_atoms):\n return macro_atom_data\n\n def _set_index(self, macro_atom_data):\n return macro_atom_data\n\n\nclass PhotoIonizationData(ProcessingPlasmaProperty):\n \"\"\"\n Attributes\n ----------\n photo_ion_cross_sections : pandas.DataFrame, dtype float\n Photoionization cross sections as a function of frequency.\n Columns are nu, x_sect, index=('atomic_number','ion_number','level_number')\n photo_ion_block_references : numpy.ndarray, dtype int\n Indices where the photoionization data for\n a given level starts. Needed for calculation\n of recombination rates.\n nu_i : pandas.Series, dtype float\n Threshold frequencies for ionization\n energy_i : pandas.Series, dtype float\n Energies of levels with bound-free transitions. Needed to calculate\n for example internal transition probabilities in the macro atom scheme.\n photo_ion_index : pandas.MultiIndex, dtype int\n Atomic, ion and level numbers for which photoionization data exists.\n level2continuum_idx : pandas.Series, dtype int\n Maps a level MultiIndex (atomic_number, ion_number, level_number) to\n the continuum_idx of the corresponding bound-free continuum (which are\n sorted by decreasing frequency).\n level_idxs2continuum_idx : pandas.DataFrame, dtype int\n Maps a source_level_idx destination_level_idx pair to a continuum_idx.\n \"\"\"\n\n outputs = (\n \"photo_ion_cross_sections\",\n \"photo_ion_block_references\",\n \"photo_ion_index\",\n \"nu_i\",\n \"energy_i\",\n \"photo_ion_idx\",\n \"level2continuum_idx\",\n \"level_idxs2continuum_idx\",\n )\n latex_name = (\n r\"\\xi_{\\textrm{i}}(\\nu)\",\n \"\",\n \"\",\n r\"\\nu_i\",\n r\"\\epsilon_i\",\n \"\",\n \"\",\n )\n\n def calculate(self, atomic_data, continuum_interaction_species):\n #photoionization_data = atomic_data.photoionization_data.set_index(\n # [\"atomic_number\", \"ion_number\", \"level_number\"]\n #)\n photoionization_data = atomic_data.photoionization_data\n mask_selected_species = photoionization_data.index.droplevel(\n \"level_number\"\n ).isin(continuum_interaction_species)\n photoionization_data = photoionization_data[mask_selected_species]\n phot_nus = photoionization_data[\"nu\"]\n block_references = np.pad(\n phot_nus.groupby(level=[0, 1, 2]).count().values.cumsum(), [1, 0]\n )\n photo_ion_index = photoionization_data.index.unique()\n nu_i = photoionization_data.groupby(level=[0, 1, 2]).first().nu\n energy_i = atomic_data.levels.loc[photo_ion_index].energy\n\n source_idx = atomic_data.macro_atom_references.loc[\n photo_ion_index\n ].references_idx\n destination_idx = atomic_data.macro_atom_references.loc[\n get_ground_state_multi_index(photo_ion_index)\n ].references_idx\n photo_ion_idx = pd.DataFrame(\n {\n \"source_level_idx\": source_idx.values,\n \"destination_level_idx\": destination_idx.values,\n },\n index=photo_ion_index,\n )\n\n level2continuum_edge_idx = pd.Series(\n np.arange(len(nu_i)),\n nu_i.sort_values(ascending=False).index,\n name=\"continuum_idx\",\n )\n\n level_idxs2continuum_idx = photo_ion_idx.copy()\n level_idxs2continuum_idx[\"continuum_idx\"] = level2continuum_edge_idx\n level_idxs2continuum_idx = level_idxs2continuum_idx.set_index(\n [\"source_level_idx\", \"destination_level_idx\"]\n )\n return (\n photoionization_data,\n block_references,\n photo_ion_index,\n nu_i,\n energy_i,\n photo_ion_idx,\n level2continuum_edge_idx,\n level_idxs2continuum_idx,\n )\n\n\nclass ContinuumInteractionHandler(ProcessingPlasmaProperty):\n outputs = (\n \"get_current_bound_free_continua\",\n \"determine_bf_macro_activation_idx\",\n \"determine_continuum_macro_activation_idx\",\n )\n\n def calculate(\n self,\n photo_ion_cross_sections,\n level2continuum_idx,\n photo_ion_idx,\n k_packet_idx,\n ):\n nus = photo_ion_cross_sections.nu.loc[\n level2continuum_idx.index\n ] # Sort by descending frequency\n nu_mins = nus.groupby(level=[0, 1, 2], sort=False).first().values\n nu_maxs = nus.groupby(level=[0, 1, 2], sort=False).last().values\n\n @njit(error_model=\"numpy\", fastmath=True)\n def get_current_bound_free_continua(nu):\n \"\"\"\n Determine bound-free continua for which absorption is possible.\n\n Parameters\n ----------\n nu : float\n Comoving frequency of the r-packet.\n\n Returns\n -------\n numpy.ndarray, dtype int\n Continuum ids for which absorption is possible for frequency `nu`.\n \"\"\"\n # searchsorted would be faster but would need stricter format for photoionization data\n current_continua = np.where(\n np.logical_and(nu >= nu_mins, nu <= nu_maxs)\n )[0]\n return current_continua\n\n destination_level_idxs = photo_ion_idx.loc[\n level2continuum_idx.index, \"destination_level_idx\"\n ].values\n\n @njit(error_model=\"numpy\", fastmath=True)\n def determine_bf_macro_activation_idx(\n nu, chi_bf_contributions, active_continua\n ):\n \"\"\"\n Determine the macro atom activation level after bound-free absorption.\n\n Parameters\n ----------\n nu : float\n Comoving frequency of the r-packet.\n chi_bf_contributions : numpy.ndarray, dtype float\n Cumulative distribution of bound-free opacities at frequency\n `nu`.\n active_continua : numpy.ndarray, dtype int\n Continuum ids for which absorption is possible for frequency `nu`.\n\n Returns\n -------\n float\n Macro atom activation idx.\n \"\"\"\n # Perform a MC experiment to determine the continuum for absorption\n index = np.searchsorted(chi_bf_contributions, np.random.random())\n continuum_id = active_continua[index]\n\n # Perform a MC experiment to determine whether thermal or\n # ionization energy is created\n nu_threshold = nu_mins[continuum_id]\n fraction_ionization = nu_threshold / nu\n if (\n np.random.random() < fraction_ionization\n ): # Create ionization energy (i-packet)\n destination_level_idx = destination_level_idxs[continuum_id]\n else: # Create thermal energy (k-packet)\n destination_level_idx = k_packet_idx\n return destination_level_idx\n\n @njit(error_model=\"numpy\", fastmath=True)\n def determine_continuum_macro_activation_idx(\n nu, chi_bf, chi_ff, chi_bf_contributions, active_continua\n ):\n \"\"\"\n Determine the macro atom activation level after a continuum absorption.\n\n Parameters\n ----------\n nu : float\n Comoving frequency of the r-packet.\n chi_bf : numpy.ndarray, dtype float\n Bound-free opacity.\n chi_bf : numpy.ndarray, dtype float\n Free-free opacity.\n chi_bf_contributions : numpy.ndarray, dtype float\n Cumulative distribution of bound-free opacities at frequency\n `nu`.\n active_continua : numpy.ndarray, dtype int\n Continuum ids for which absorption is possible for frequency `nu`.\n\n Returns\n -------\n float\n Macro atom activation idx.\n \"\"\"\n fraction_bf = chi_bf / (chi_bf + chi_ff)\n # TODO: In principle, we can also decide here whether a Thomson\n # scattering event happens and need one less RNG call.\n if np.random.random() < fraction_bf: # Bound-free absorption\n destination_level_idx = determine_bf_macro_activation_idx(\n nu, chi_bf_contributions, active_continua\n )\n else: # Free-free absorption (i.e. k-packet creation)\n destination_level_idx = k_packet_idx\n return destination_level_idx\n\n return (\n get_current_bound_free_continua,\n determine_bf_macro_activation_idx,\n determine_continuum_macro_activation_idx,\n )\n\n\nclass TwoPhotonData(ProcessingPlasmaProperty):\n outputs = (\"two_photon_data\", \"two_photon_idx\")\n \"\"\"\n Attributes\n ----------\n two_photon_data : pandas.DataFrame, dtype float\n A DataFrame containing the *two photon decay data* with:\n index: atomic_number, ion_number, level_number_lower, level_number_upper\n columns: A_ul[1/s], nu0[Hz], alpha, beta, gamma\n alpha, beta, gamma are fit coefficients for the frequency dependent\n transition probability A(y) of the two photon decay. See Eq. 2 in\n Nussbaumer & Schmutz (1984).\n two_photon_idx : pandas.DataFrame, dtype int\n \"\"\"\n\n def calculate(self, atomic_data, continuum_interaction_species):\n two_photon_data = atomic_data.two_photon_data\n mask_selected_species = two_photon_data.index.droplevel(\n [\"level_number_lower\", \"level_number_upper\"]\n ).isin(continuum_interaction_species)\n if not mask_selected_species.sum():\n raise IncompleteAtomicData(\n \"two photon transition data for the requested \"\n \"continuum_interactions species: {}\".format(\n continuum_interaction_species.values.tolist()\n )\n )\n two_photon_data = two_photon_data[mask_selected_species]\n index_lower = two_photon_data.index.droplevel(\"level_number_upper\")\n index_upper = two_photon_data.index.droplevel(\"level_number_lower\")\n source_idx = atomic_data.macro_atom_references.loc[\n index_upper\n ].references_idx\n destination_idx = atomic_data.macro_atom_references.loc[\n index_lower\n ].references_idx\n two_photon_idx = pd.DataFrame(\n {\n \"source_level_idx\": source_idx.values,\n \"destination_level_idx\": destination_idx.values,\n },\n index=two_photon_data.index,\n )\n if len(two_photon_data) != 1:\n raise NotImplementedError(\n \"Currently only one two-photon decay is supported but there \"\n f\"are {len(two_photon_data)} in the atomic data.\"\n )\n return two_photon_data, two_photon_idx\n\n\nclass LinesLowerLevelIndex(HiddenPlasmaProperty):\n \"\"\"\n Attributes\n ----------\n lines_lower_level_index : numpy.ndrarray, dtype int\n Levels data for lower levels of particular lines\n \"\"\"\n\n outputs = (\"lines_lower_level_index\",)\n\n def calculate(self, levels, lines):\n levels_index = pd.Series(\n np.arange(len(levels), dtype=np.int64), index=levels\n )\n lines_index = lines.index.droplevel(\"level_number_upper\")\n return np.array(levels_index.loc[lines_index])\n\n\nclass LinesUpperLevelIndex(HiddenPlasmaProperty):\n \"\"\"\n Attributes\n ----------\n lines_upper_level_index : numpy.ndarray, dtype int\n Levels data for upper levels of particular lines\n \"\"\"\n\n outputs = (\"lines_upper_level_index\",)\n\n def calculate(self, levels, lines):\n levels_index = pd.Series(\n np.arange(len(levels), dtype=np.int64), index=levels\n )\n lines_index = lines.index.droplevel(\"level_number_lower\")\n return np.array(levels_index.loc[lines_index])\n\n\nclass LevelIdxs2LineIdx(HiddenPlasmaProperty):\n \"\"\"\n Attributes\n ----------\n level_idxs2line_idx : pandas.Series, dtype int\n Maps a source_level_idx destination_level_idx pair to a line_idx.\n \"\"\"\n\n outputs = (\"level_idxs2line_idx\",)\n\n def calculate(self, atomic_data):\n index = pd.MultiIndex.from_arrays(\n [\n atomic_data.lines_upper2level_idx,\n atomic_data.lines_lower2level_idx,\n ],\n names=[\"source_level_idx\", \"destination_level_idx\"],\n )\n level_idxs2line_idx = pd.Series(\n np.arange(len(index)), index=index, name=\"lines_idx\"\n )\n return level_idxs2line_idx\n\n\nclass LevelIdxs2TransitionIdx(HiddenPlasmaProperty):\n \"\"\"\n Attributes\n ----------\n level_idxs2transition_idx : pandas.DataFrame, dtype int\n Maps a source_level_idx destination_level_idx pair to a transition_idx\n and transition type.\n \"\"\"\n\n outputs = (\"level_idxs2transition_idx\",)\n\n def calculate(self, level_idxs2line_idx, level_idxs2continuum_idx):\n level_idxs2line_idx = level_idxs2line_idx.to_frame()\n level_idxs2line_idx.insert(1, \"transition_type\", -1)\n\n level_idxs2continuum_idx = level_idxs2continuum_idx.copy()\n level_idxs2continuum_idx.insert(1, \"transition_type\", -2)\n level_idxs2continuum_idx = level_idxs2continuum_idx.rename(\n columns=({\"continuum_idx\": \"lines_idx\"})\n )\n\n names = level_idxs2continuum_idx.index.names\n level_idxs2continuum_idx = level_idxs2continuum_idx.swaplevel()\n level_idxs2continuum_idx.index.names = names\n\n # TODO: This should probably be defined somewhere else.\n # One possibility would be to attach it to the cooling properties as\n # a class attribute.\n index_cooling = pd.MultiIndex.from_product(\n [[\"k\"], [\"ff\", \"adiabatic\", \"bf\"]], names=names\n )\n num_cool = len(index_cooling)\n level_idxs2cooling_idx = pd.DataFrame(\n {\n \"lines_idx\": np.ones(num_cool, dtype=int) * -1,\n \"transition_type\": np.arange(-3, -3 - num_cool, -1),\n },\n index=index_cooling,\n )\n level_idxs2transition_idx = pd.concat(\n [\n level_idxs2continuum_idx,\n level_idxs2line_idx,\n level_idxs2cooling_idx,\n ]\n )\n\n # TODO: Add two-photon processes\n\n return level_idxs2transition_idx\n\n\nclass AtomicMass(ProcessingPlasmaProperty):\n \"\"\"\n Attributes\n ----------\n atomic_mass : pandas.Series\n Atomic masses of the elements used. Indexed by atomic number.\n \"\"\"\n\n outputs = (\"atomic_mass\",)\n\n def calculate(self, atomic_data, selected_atoms):\n if getattr(self, self.outputs[0]) is not None:\n return (getattr(self, self.outputs[0]),)\n else:\n return atomic_data.atom_data.loc[selected_atoms].mass\n\n\nclass IonizationData(BaseAtomicDataProperty):\n \"\"\"\n Attributes\n ----------\n ionization_data : pandas.Series\n Holding ionization energies\n Indexed by atomic number, ion number.\n \"\"\"\n\n outputs = (\"ionization_data\",)\n\n def _filter_atomic_property(self, ionization_data, selected_atoms):\n mask = ionization_data.index.isin(selected_atoms, level=\"atomic_number\")\n ionization_data = ionization_data[mask]\n counts = ionization_data.groupby(level=\"atomic_number\").count()\n\n if np.alltrue(counts.index == counts):\n return ionization_data\n else:\n raise IncompleteAtomicData(\n f\"ionization data for the ion ({str(counts.index[counts.index != counts])}, {str(counts[counts.index != counts])})\"\n )\n\n def _set_index(self, ionization_data):\n return ionization_data\n\n\nclass ZetaData(BaseAtomicDataProperty):\n \"\"\"\n Attributes\n ----------\n zeta_data : pandas.DataFrame, dtype float\n Zeta data for the elements used. Indexed by atomic number, ion number.\n Columns are temperature values up to 40,000 K in iterations of 2,000 K.\n The zeta value represents the fraction of recombination events\n from the ionized state that go directly to the ground state.\n \"\"\"\n\n outputs = (\"zeta_data\",)\n\n def _filter_atomic_property(self, zeta_data, selected_atoms):\n zeta_data[\"atomic_number\"] = zeta_data.index.codes[0] + 1\n zeta_data[\"ion_number\"] = zeta_data.index.codes[1] + 1\n zeta_data = zeta_data[zeta_data.atomic_number.isin(selected_atoms)]\n zeta_data_check = counter(zeta_data.atomic_number.values)\n keys = np.array(list(zeta_data_check.keys()))\n values = np.array(zeta_data_check.values())\n if np.alltrue(keys + 1 == values):\n return zeta_data\n else:\n # raise IncompleteAtomicData('zeta data')\n # This currently replaces missing zeta data with 1, which is necessary with\n # the present atomic data. Will replace with the error above when I have\n # complete atomic data.\n missing_ions = []\n updated_index = []\n for atom in selected_atoms:\n for ion in range(1, atom + 2):\n if (atom, ion) not in zeta_data.index:\n missing_ions.append((atom, ion))\n updated_index.append([atom, ion])\n logger.warn(\n f\"Zeta_data missing - replaced with 1s. Missing ions: {missing_ions}\"\n )\n updated_index = np.array(updated_index)\n updated_dataframe = pd.DataFrame(\n index=pd.MultiIndex.from_arrays(\n updated_index.transpose().astype(int)\n ),\n columns=zeta_data.columns,\n )\n for value in range(len(zeta_data)):\n updated_dataframe.loc[\n zeta_data.atomic_number.values[value],\n zeta_data.ion_number.values[value],\n ] = zeta_data.loc[\n zeta_data.atomic_number.values[value],\n zeta_data.ion_number.values[value],\n ]\n updated_dataframe = updated_dataframe.astype(float)\n updated_index = pd.DataFrame(updated_index)\n updated_dataframe[\"atomic_number\"] = np.array(updated_index[0])\n updated_dataframe[\"ion_number\"] = np.array(updated_index[1])\n updated_dataframe.fillna(1.0, inplace=True)\n return updated_dataframe\n\n def _set_index(self, zeta_data):\n return zeta_data.set_index([\"atomic_number\", \"ion_number\"])\n\n\nclass NLTEData(ProcessingPlasmaProperty):\n \"\"\"\n Attributes\n ----------\n nlte_data :\n #Finish later (need atomic dataset with NLTE data).\n \"\"\"\n\n outputs = (\"nlte_data\",)\n\n def calculate(self, atomic_data):\n if getattr(self, self.outputs[0]) is not None:\n return (getattr(self, self.outputs[0]),)\n else:\n return atomic_data.nlte_data\n\n\nclass YgData(ProcessingPlasmaProperty):\n \"\"\"\n Attributes\n ----------\n yg_data : pandas.DataFrame\n Table of thermally averaged effective collision strengths\n (divided by the statistical weight of the lower level) Y_ij / g_i .\n Columns are temperatures.\n t_yg : numpy.ndarray\n Temperatures at which collision strengths are tabulated.\n yg_index : Pandas MultiIndex\n delta_E_yg : pandas.DataFrame\n Energy difference between upper and lower levels coupled by collisions.\n yg_idx : pandas.DataFrame\n Source_level_idx and destination_level_idx of collision transitions.\n Indexed by atomic_number, ion_number, level_number_lower,\n level_number_upper.\n \"\"\"\n\n outputs = (\"yg_data\", \"t_yg\", \"yg_index\", \"delta_E_yg\", \"yg_idx\")\n latex_name = (\n r\"\\frac{Y_{ij}}{g_i}\",\n r\"T_\\textrm{Yg}\",\n r\"\\textrm{yg_index}\",\n r\"\\delta E_{ij}\",\n r\"\\textrm{yg_idx}\",\n )\n\n def calculate(self, atomic_data, continuum_interaction_species):\n yg_data = atomic_data.yg_data\n\n mask_selected_species = yg_data.index.droplevel(\n [\"level_number_lower\", \"level_number_upper\"]\n ).isin(continuum_interaction_species)\n yg_data = yg_data[mask_selected_species]\n\n t_yg = yg_data.columns.values.astype(float)\n yg_data.columns = t_yg\n approximate_yg_data = self.calculate_yg_van_regemorter(\n atomic_data, t_yg, continuum_interaction_species\n )\n\n yg_data = yg_data.combine_first(approximate_yg_data)\n\n energies = atomic_data.levels.energy\n index = yg_data.index\n lu_index = index.droplevel(\"level_number_lower\")\n ll_index = index.droplevel(\"level_number_upper\")\n delta_E = energies.loc[lu_index].values - energies.loc[ll_index].values\n delta_E = pd.Series(delta_E, index=index)\n\n source_idx = atomic_data.macro_atom_references.loc[\n ll_index\n ].references_idx\n destination_idx = atomic_data.macro_atom_references.loc[\n lu_index\n ].references_idx\n yg_idx = pd.DataFrame(\n {\n \"source_level_idx\": source_idx.values,\n \"destination_level_idx\": destination_idx.values,\n },\n index=index,\n )\n return yg_data, t_yg, index, delta_E, yg_idx\n\n @staticmethod\n def calculate_yg_van_regemorter(\n atomic_data, t_electrons, continuum_interaction_species\n ):\n \"\"\"\n Calculate collision strengths in the van Regemorter approximation.\n\n This function calculates thermally averaged effective collision\n strengths (divided by the statistical weight of the lower level)\n Y_ij / g_i using the van Regemorter approximation.\n\n Parameters\n ----------\n atomic_data : tardis.io.atom_data.AtomData\n t_electrons : numpy.ndarray\n continuum_interaction_species : pandas.MultiIndex\n\n Returns\n -------\n pandas.DataFrame\n Thermally averaged effective collision strengths\n (divided by the statistical weight of the lower level) Y_ij / g_i\n\n Notes\n -----\n See Eq. 9.58 in [2].\n\n References\n ----------\n .. [1] van Regemorter, H., “Rate of Collisional Excitation in Stellar\n Atmospheres.”, The Astrophysical Journal, vol. 136, p. 906, 1962.\n doi:10.1086/147445.\n .. [2] Hubeny, I. and Mihalas, D., \"Theory of Stellar Atmospheres\". 2014.\n \"\"\"\n I_H = atomic_data.ionization_data.loc[(1, 1)]\n\n mask_selected_species = atomic_data.lines.index.droplevel(\n [\"level_number_lower\", \"level_number_upper\"]\n ).isin(continuum_interaction_species)\n lines_filtered = atomic_data.lines[mask_selected_species]\n f_lu = lines_filtered.f_lu.values\n nu_lines = lines_filtered.nu.values\n\n yg = f_lu * (I_H / (H * nu_lines)) ** 2\n coll_const = A0 ** 2 * np.pi * np.sqrt(8 * K_B / (np.pi * M_E))\n yg = 14.5 * coll_const * t_electrons * yg[:, np.newaxis]\n\n u0 = nu_lines[np.newaxis].T / t_electrons * (H / K_B)\n gamma = 0.276 * np.exp(u0) * expn(1, u0)\n gamma[gamma < 0.2] = 0.2\n yg *= u0 * gamma / BETA_COLL\n yg = pd.DataFrame(yg, index=lines_filtered.index, columns=t_electrons)\n\n return yg\n\n\nclass YgInterpolator(ProcessingPlasmaProperty):\n \"\"\"\n Attributes\n ----------\n yg_interp : scipy.interpolate.PchipInterpolator\n Interpolates the thermally averaged effective collision strengths\n (divided by the statistical weight of the lower level) Y_ij / g_i as\n a function of electron temperature.\n \"\"\"\n\n outputs = (\"yg_interp\",)\n latex_name = (\"\\\\frac{Y_ij}{g_i}_{\\\\textrm{interp}}\",)\n\n def calculate(self, yg_data, t_yg):\n yg_interp = PchipInterpolator(t_yg, yg_data, axis=1, extrapolate=True)\n return yg_interp\n", "meta": {"hexsha": "447dae42e9ddac71bb66dedb569b0fe3baa00b19", "size": 27595, "ext": "py", "lang": "Python", "max_stars_repo_path": "tardis/plasma/properties/atomic.py", "max_stars_repo_name": "ahmedo42/tardis", "max_stars_repo_head_hexsha": "e86ade324d94000a206742b12bc8d04d6c200ba2", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "tardis/plasma/properties/atomic.py", "max_issues_repo_name": "ahmedo42/tardis", "max_issues_repo_head_hexsha": "e86ade324d94000a206742b12bc8d04d6c200ba2", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "tardis/plasma/properties/atomic.py", "max_forks_repo_name": "ahmedo42/tardis", "max_forks_repo_head_hexsha": "e86ade324d94000a206742b12bc8d04d6c200ba2", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.1081424936, "max_line_length": 131, "alphanum_fraction": 0.6267077369, "include": true, "reason": "import numpy,from scipy,from numba", "num_tokens": 5997, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6548947155710233, "lm_q2_score": 0.2974699363766584, "lm_q1q2_score": 0.1948114893743221}} {"text": "import sys\nimport base64\n\nimport numpy as np\n\nfrom . import _marching_cubes_lewiner_luts as mcluts\nfrom . import _marching_cubes_lewiner_cy\n\n\nif sys.version_info >= (3, ):\n base64decode = base64.decodebytes\nelse:\n base64decode = base64.decodestring\n\n\ndef marching_cubes_lewiner(volume, level=None, spacing=(1., 1., 1.),\n gradient_direction='descent', step_size=1,\n allow_degenerate=True, use_classic=False):\n \"\"\"\n Lewiner marching cubes algorithm to find surfaces in 3d volumetric data.\n\n In contrast to ``marching_cubes_classic()``, this algorithm is faster,\n resolves ambiguities, and guarantees topologically correct results.\n Therefore, this algorithm generally a better choice, unless there\n is a specific need for the classic algorithm.\n\n Parameters\n ----------\n volume : (M, N, P) array\n Input data volume to find isosurfaces. Will internally be\n converted to float32 if necessary.\n level : float\n Contour value to search for isosurfaces in `volume`. If not\n given or None, the average of the min and max of vol is used.\n spacing : length-3 tuple of floats\n Voxel spacing in spatial dimensions corresponding to numpy array\n indexing dimensions (M, N, P) as in `volume`.\n gradient_direction : string\n Controls if the mesh was generated from an isosurface with gradient\n descent toward objects of interest (the default), or the opposite,\n considering the *left-hand* rule.\n The two options are:\n * descent : Object was greater than exterior\n * ascent : Exterior was greater than object\n step_size : int\n Step size in voxels. Default 1. Larger steps yield faster but\n coarser results. The result will always be topologically correct\n though.\n allow_degenerate : bool\n Whether to allow degenerate (i.e. zero-area) triangles in the\n end-result. Default True. If False, degenerate triangles are\n removed, at the cost of making the algorithm slower.\n use_classic : bool\n If given and True, the classic marching cubes by Lorensen (1987)\n is used. This option is included for reference purposes. Note\n that this algorithm has ambiguities and is not guaranteed to\n produce a topologically correct result. The results with using\n this option are *not* generally the same as the\n ``marching_cubes_classic()`` function.\n\n Returns\n -------\n verts : (V, 3) array\n Spatial coordinates for V unique mesh vertices. Coordinate order\n matches input `volume` (M, N, P).\n faces : (F, 3) array\n Define triangular faces via referencing vertex indices from ``verts``.\n This algorithm specifically outputs triangles, so each face has\n exactly three indices.\n normals : (V, 3) array\n The normal direction at each vertex, as calculated from the\n data.\n values : (V, ) array\n Gives a measure for the maximum value of the data in the local region\n near each vertex. This can be used by visualization tools to apply\n a colormap to the mesh.\n\n Notes\n -----\n The algorithm [1] is an improved version of Chernyaev's Marching\n Cubes 33 algorithm. It is an efficient algorithm that relies on\n heavy use of lookup tables to handle the many different cases,\n keeping the algorithm relatively easy. This implementation is\n written in Cython, ported from Lewiner's C++ implementation.\n\n To quantify the area of an isosurface generated by this algorithm, pass\n verts and faces to `skimage.measure.mesh_surface_area`.\n\n Regarding visualization of algorithm output, to contour a volume\n named `myvolume` about the level 0.0, using the ``mayavi`` package::\n\n >>> from mayavi import mlab # doctest: +SKIP\n >>> verts, faces, normals, values = marching_cubes_lewiner(myvolume, 0.0) # doctest: +SKIP\n >>> mlab.triangular_mesh([vert[0] for vert in verts],\n ... [vert[1] for vert in verts],\n ... [vert[2] for vert in verts],\n ... faces) # doctest: +SKIP\n >>> mlab.show() # doctest: +SKIP\n\n Similarly using the ``visvis`` package::\n\n >>> import visvis as vv # doctest: +SKIP\n >>> verts, faces, normals, values = marching_cubes_lewiner(myvolume, 0.0) # doctest: +SKIP\n >>> vv.mesh(np.fliplr(verts), faces, normals, values) # doctest: +SKIP\n >>> vv.use().Run() # doctest: +SKIP\n\n References\n ----------\n .. [1] Thomas Lewiner, Helio Lopes, Antonio Wilson Vieira and Geovan\n Tavares. Efficient implementation of Marching Cubes' cases with\n topological guarantees. Journal of Graphics Tools 8(2)\n pp. 1-15 (december 2003).\n DOI: 10.1080/10867651.2003.10487582\n\n See Also\n --------\n skimage.measure.marching_cubes_classic\n skimage.measure.mesh_surface_area\n \"\"\"\n\n # Check volume and ensure its in the format that the alg needs\n if not isinstance(volume, np.ndarray) or (volume.ndim != 3):\n raise ValueError('Input volume should be a 3D numpy array.')\n if volume.shape[0] < 2 or volume.shape[1] < 2 or volume.shape[2] < 2:\n raise ValueError(\"Input array must be at least 2x2x2.\")\n volume = np.ascontiguousarray(volume, np.float32) # no copy if not necessary\n\n # Check/convert other inputs:\n # level\n if level is None:\n level = 0.5 * (volume.min() + volume.max())\n else:\n level = float(level)\n if level < volume.min() or level > volume.max():\n raise ValueError(\"Surface level must be within volume data range.\")\n # spacing\n if len(spacing) != 3:\n raise ValueError(\"`spacing` must consist of three floats.\")\n # step_size\n step_size = int(step_size)\n if step_size < 1:\n raise ValueError('step_size must be at least one.')\n # use_classic\n use_classic = bool(use_classic)\n\n # Get LutProvider class (reuse if possible)\n L = _get_mc_luts()\n\n # Apply algorithm\n func = _marching_cubes_lewiner_cy.marching_cubes\n vertices, faces , normals, values = func(volume, level, L, step_size, use_classic)\n\n if not len(vertices):\n raise RuntimeError('No surface found at the given iso value.')\n\n # Output in z-y-x order, as is common in skimage\n vertices = np.fliplr(vertices)\n normals = np.fliplr(normals)\n\n # Finishing touches to output\n faces.shape = -1, 3\n if gradient_direction == 'descent':\n # MC implementation is right-handed, but gradient_direction is left-handed\n faces = np.fliplr(faces)\n elif not gradient_direction == 'ascent':\n raise ValueError(\"Incorrect input %s in `gradient_direction`, see \"\n \"docstring.\" % (gradient_direction))\n if spacing != (1, 1, 1):\n vertices = vertices * np.r_[spacing]\n\n if allow_degenerate:\n return vertices, faces, normals, values\n else:\n fun = _marching_cubes_lewiner_cy.remove_degenerate_faces\n return fun(vertices.astype(np.float32), faces, normals, values)\n\n\ndef _to_array(args):\n shape, text = args\n byts = base64decode(text.encode('utf-8'))\n ar = np.frombuffer(byts, dtype='int8')\n ar.shape = shape\n return ar\n\n\n# Map an edge-index to two relative pixel positions. The ege index\n# represents a point that lies somewhere in between these pixels.\n# Linear interpolation should be used to determine where it is exactly.\n# 0\n# 3 1 -> 0x\n# 2 xx\nEDGETORELATIVEPOSX = np.array([ [0,1],[1,1],[1,0],[0,0], [0,1],[1,1],[1,0],[0,0], [0,0],[1,1],[1,1],[0,0] ], 'int8')\nEDGETORELATIVEPOSY = np.array([ [0,0],[0,1],[1,1],[1,0], [0,0],[0,1],[1,1],[1,0], [0,0],[0,0],[1,1],[1,1] ], 'int8')\nEDGETORELATIVEPOSZ = np.array([ [0,0],[0,0],[0,0],[0,0], [1,1],[1,1],[1,1],[1,1], [0,1],[0,1],[0,1],[0,1] ], 'int8')\n\n\ndef _get_mc_luts():\n \"\"\" Kind of lazy obtaining of the luts.\n \"\"\"\n if not hasattr(mcluts, 'THE_LUTS'):\n\n mcluts.THE_LUTS = _marching_cubes_lewiner_cy.LutProvider(\n EDGETORELATIVEPOSX, EDGETORELATIVEPOSY, EDGETORELATIVEPOSZ,\n\n _to_array(mcluts.CASESCLASSIC), _to_array(mcluts.CASES),\n\n _to_array(mcluts.TILING1), _to_array(mcluts.TILING2), _to_array(mcluts.TILING3_1), _to_array(mcluts.TILING3_2),\n _to_array(mcluts.TILING4_1), _to_array(mcluts.TILING4_2), _to_array(mcluts.TILING5), _to_array(mcluts.TILING6_1_1),\n _to_array(mcluts.TILING6_1_2), _to_array(mcluts.TILING6_2), _to_array(mcluts.TILING7_1),\n _to_array(mcluts.TILING7_2), _to_array(mcluts.TILING7_3), _to_array(mcluts.TILING7_4_1),\n _to_array(mcluts.TILING7_4_2), _to_array(mcluts.TILING8), _to_array(mcluts.TILING9),\n _to_array(mcluts.TILING10_1_1), _to_array(mcluts.TILING10_1_1_), _to_array(mcluts.TILING10_1_2),\n _to_array(mcluts.TILING10_2), _to_array(mcluts.TILING10_2_), _to_array(mcluts.TILING11),\n _to_array(mcluts.TILING12_1_1), _to_array(mcluts.TILING12_1_1_), _to_array(mcluts.TILING12_1_2),\n _to_array(mcluts.TILING12_2), _to_array(mcluts.TILING12_2_), _to_array(mcluts.TILING13_1),\n _to_array(mcluts.TILING13_1_), _to_array(mcluts.TILING13_2), _to_array(mcluts.TILING13_2_),\n _to_array(mcluts.TILING13_3), _to_array(mcluts.TILING13_3_), _to_array(mcluts.TILING13_4),\n _to_array(mcluts.TILING13_5_1), _to_array(mcluts.TILING13_5_2), _to_array(mcluts.TILING14),\n\n _to_array(mcluts.TEST3), _to_array(mcluts.TEST4), _to_array(mcluts.TEST6),\n _to_array(mcluts.TEST7), _to_array(mcluts.TEST10), _to_array(mcluts.TEST12),\n _to_array(mcluts.TEST13), _to_array(mcluts.SUBCONFIG13),\n )\n\n return mcluts.THE_LUTS\n", "meta": {"hexsha": "163721c247a7efa30132ca2785377d795a20f96b", "size": 9884, "ext": "py", "lang": "Python", "max_stars_repo_path": "skimage/measure/_marching_cubes_lewiner.py", "max_stars_repo_name": "portugueslab/scikit-image", "max_stars_repo_head_hexsha": "0fa3bcb118bb208a0cc7d3e8b96cd96c1ce7a75b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-02-24T02:24:43.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-19T11:44:34.000Z", "max_issues_repo_path": "skimage/measure/_marching_cubes_lewiner.py", "max_issues_repo_name": "portugueslab/scikit-image", "max_issues_repo_head_hexsha": "0fa3bcb118bb208a0cc7d3e8b96cd96c1ce7a75b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "skimage/measure/_marching_cubes_lewiner.py", "max_forks_repo_name": "portugueslab/scikit-image", "max_forks_repo_head_hexsha": "0fa3bcb118bb208a0cc7d3e8b96cd96c1ce7a75b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-06-16T06:38:28.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-19T11:44:48.000Z", "avg_line_length": 43.7345132743, "max_line_length": 131, "alphanum_fraction": 0.6588425739, "include": true, "reason": "import numpy", "num_tokens": 2719, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.531209388216861, "lm_q2_score": 0.3665897363221598, "lm_q1q2_score": 0.1947359095582749}} {"text": "# Copyright (c) 2012-2018, University of Strathclyde\n# Authors: Lawrence T. Campbell\n# License: BSD-3-Clause\n#\n# Python script containing the code to write the input files for \n# Puffin.\n#\n# The three files are:\n#\n# 1) The main input file, describing free parameters and the \n# integration sampling\n#\n# 2) The beam input file, which can describe multiple electron \n# beams if necessary\n#\n# 3) The seed input file, which can describe multiple seeds\n#\n# This approach is (hopefully) quite flexible, allowing Puffin to \n# generate a simple, more conventional FEL, or a more esoteric \n# configuration with multiple seeds and electron beams, with different \n# powers, frequencies, energies, and distributions.\n#\n# In addition, for more fun, a lattice file may be constructed to \n# describe a series of undulator modules seperated by chicane/slippage \n# sections and/or quads. The name of this lattice file should be entered\n# in the 'lattfile' variable in the input file. \n#\n#\n# DESCRIBE UNDULATOR LATTICE FILE\n#\n#\n# Also note that if aw is decreased in an undulator module you should\n# ensure the radiation mesh is fine enough to model the higher frequency\n# content which will arise.\n#\n# The strength of the dispersive chicanes can be given in the 'Dfact' \n# variable in the main input file. Currently, only this one strength \n# factor may be specified which will be shared by all chicanes.\n# \n# An undulator taper can also be added in the main input file.\n# Presently, if a lattice file is used, this taper will be applied\n# to ALL undulator modules, and the taper will be applied to the\n# undulator parameter of each module. Only a linear taper may be\n# supplied.\n# \n# - Lawrence Campbell\n# University of Strathclyde\n# July 2013\n\n\n# simple setup\n # define beam and undulator - frame is assumed the same as the beam and undulator\n # scale parameters\n\n# - OR - \n\n# advanced setup\n # define frame\n # define beam in frame\n # use same beam as reference beam?\n # scale parameters\n\nimport math\nimport beamClass\nimport seedClass\nimport fBoolean\nimport numpy as np\n\ntorf = fBoolean.torf\n\npow = math.pow\npi = math.pi\nsqrt = math.sqrt\nlog = math.log\nbm = beamClass.bm\nsd = seedClass.sd\n\n# Physical constants\n\nm_e = 9.109e-31\nq_e = 1.602e-19\neps_0 = 8.85e-12\nc = 2.997924e8\n\n# File names for input files\n\ninputfile = 'example.in'\nbeamfile = 'beam_file.in'\nseedfile = 'seed_file.in'\nlattFile = ''\n\nnbeams = 1\nnseeds = 1\n\n### Sampling\n\nelms_per_wave = 20 # Field nodes per resonant wavelength \nemps_per_wave = 24 # Electron macroparticles per resonant wavelength\nsteps_per_per = 30 # should be roughly 4-5* elms_per_wave\n\n# Undulator and beam parameters\n# Below similar to CLARA parameters\n\nEr = 240e6 # Beam energy (reference particle)\ngamma = Er / ( (m_e * pow(c,2) / q_e) ) # Rel. factor\naw = 1.01 # PEAK wiggler parameter\nlambda_w = 0.0275 # Undulator period\nN_w = 200 # Number of undulator periods\nundtype = 'planepole'\nux = 0\nuy = 1\n\n\n# RMS wiggler param depends on undulator type / polarization:\n\nif (undtype == 'planepole'):\n ux = 0\n uy = 1\n awrms = aw / np.sqrt(2)\n\nelif (undtype == 'curved'):\n ux = 0\n uy = 1\n awrms = aw / np.sqrt(2.)\n\nelif (undtype == 'helical'):\n ux = 1\n uy = 1\n awrms = aw\n\nelse:\n awrms = aw / np.sqrt(2.) * np.sqrt(ux**2 + uy**2)\n\n\n\nqFlatTopZ2 = np.array([1]) # =1 if flat top current profile, else gaussian.\nqHardEdgeX = np.array([0]) # =1 if disk (circle) in transverse plane, else gaussian.\nqRoundZ2 = np.array([1]) # If rounding off edges of flat top in z2\nsigRound_lam = np.array([6]) # Sigma of gaussian used to round off the flat top edges, in resonant wavelengths\nbEnOscMag = np.array([0]) # Magnitude of oscillation on beam energy | Units of gamma\nbEnOscFr = np.array([7E3]) # Frequency (2pi/lambda, where lambda in units of ct) of oscillation on beam energy \n#E = 300e6 # Beam energy\n#gamma = E / (m_e * pow(c,2)) # Rel. factor\nsig_gamma = np.array([0.0004]) # Energy spread (relative to Er i.e. sig_gam / gamma_r)\n\n\nEj = np.array([240e6])\neratio = Ej / Er # [ij / Er for ij in Ej] # Rel. factor\ngammaj = Ej / ( (m_e * pow(c,2) / q_e) ) # [ij / ( (m_e * pow(c,2) / q_e) ) for ij in Ej] # Rel. factor\nemitx = np.array([1e-6 / gamma]) # Unnormalised Emittance in x\nemity = np.array([1e-6 / gamma]) # Unnormalised Emittance in y\nQ = np.array([0.1e-9]) # Charge\n\n\nk_w = 2 * pi / lambda_w # Get wiggler wavenumber\nsigt = np.array([250e-15]) # 0.005570423008216 / c # Get sigma in t dimension\nsigz = c * sigt # Convert sigma in t to z\n\n\n\n\n#if \nff = np.sqrt(2)\n\nk_beta = aw * k_w / ( ff * gamma ) # Betatron wavenumber\nN = [ij / q_e for ij in Q] # Number of real electrons in pulse\nlambda_r = lambda_w / (2 * np.power(gamma,2)) * (1 + np.power(awrms,2))\n # ^ Resonant wavelength\n\nsigRoundz = sigRound_lam * lambda_r\n\nk_betax = k_beta\nk_betay = k_beta #...else strong...\n\nalphax = np.array([0.])\nalphay = np.array([0.])\n\n#sigx = np.sqrt(emitx / k_betax) # Beam standard deviation in x...\n#sigy = np.sqrt(emity / k_betay) # ...and y\n\nsigx = np.array([50e-6])\nsigy = np.array([50e-6])\n\nsig_av = np.sqrt((np.power(sigx,2) + np.power(sigy,2))/2.0)\n\n\n########################################\n# Beam area and FEL parameter\n\nif qHardEdgeX == 1:\n r_av = sig_av # Hard edged circle in x and y\nelse:\n r_av = np.sqrt(2.) * sig_av # Gaussian dist in x and y\n\ntArea = np.pi * np.power(r_av,2) # Tranverse beam area\n\nif qFlatTopZ2[0] == 1:\n if qRoundZ2[0] == 1:\n lArea = np.sqrt(2*pi) * sigRoundz + sigz # flat top + gaussian\n else:\n lArea = sigz # longitudinal integral over charge dist (flat top)\nelse:\n lArea = sqrt(2*pi) * sigz # longitudinal integral over charge dist(gaussian)\n\nn_p = N / (tArea * lArea) # Electron number density\nwp = np.sqrt(np.power(q_e,2) * n_p / (eps_0 * m_e) ) # plasma frequency\n\nrho = 1.0 / gamma * np.power((aw * wp[0] / ( 4.0 * c * k_w )),(2.0/3.0)) # FEL parameter\n\n#######################################\n# Scaled parameters for Puffin\n\n\nlambda_z2 = 4*pi*rho # Resonant wavelength in z2\nLg = lambda_w / lambda_z2 # Gain length\nLc = lambda_r / lambda_z2 # Cooperation length\nzbarprop = N_w * lambda_z2 # Length of undulator in zbar (gain lengths)\nsigz2 = sigz / Lc # Length of pulse in z2 (cooperation lengths)\n\nsigRoundZ2 = sigRoundz / Lc # Sigma of tail off in z2 (cooperation lengths)\n\nbEnOscFr = bEnOscFr * Lc\n\nbeta = sqrt(np.power(gamma,2) - 1.0 - np.power(awrms,2))/gamma # Average velocity over c\neta = (1-beta)/beta # Scaled average velocity (of reference electron)\n\nk_beta_bar = k_beta * Lg # Scaled betatron wavenumber\nemitx_bar = emitx / (rho * Lc) # Scaled emittance\nemity_bar = emity / (rho * Lc) # Scaled emittance\nZ_R = pi * np.power(r_av,2) / lambda_r # Rayleigh range\nZ_bar_R = np.power(r_av,2) / (Lg * Lc) / (4.0 * rho) # Scaled Rayleigh Range\nB = np.power((2 * Z_bar_R),(3.0/2.0)) # Saldin diffraction parameter\n\n\nNL = N/sigz2 * lambda_z2 # electrons per radiation period\n\nAnoise = 6 * sqrt(pi) * rho / (NL * sqrt(log(NL/rho))) # Spontaneous noise estimate (in scaled units)\nAcse = 16 * np.power(rho,2) # CSE estimate for flat-top current\n\n\n###################################################\n\n\nif (undtype == 'planepole'):\n kbxn = 0.\n kbyn = aw / 2. / np.sqrt(2) / rho / gamma # 'natural' focusing wavenumber\n\nelif (undtype == 'curved'):\n kxu = np.sqrt(eta / 8. / rho**2)\n kyu = np.sqrt(eta / 8. / rho**2)\n kbxn = aw / np.sqrt(2.*eta) / gamma *kxu\n kbyn = aw / np.sqrt(2.*eta) / gamma *kyu\n\nelif (undtype == 'helical'):\n kbxn = aw / 2. / np.sqrt(2) / rho / gamma # 'natural' focusing wavenumber\n kbyn = aw / 2. / np.sqrt(2) / rho / gamma # 'natural' focusing wavenumber\n\nelse:\n kbxn = aw / 2. / np.sqrt(2) / rho / gamma # 'natural' focusing wavenumber\n kbyn = aw / 2. / np.sqrt(2) / rho / gamma # 'natural' focusing wavenumber\n awrms = aw / np.sqrt(2.) * np.sqrt(ux**2 + uy**2)\n\n\n\n\n\n##################################################\n# Sampling\n\nif qFlatTopZ2[0] == 1:\n if qRoundZ2[0] == 1:\n lez2 = (7.5 * sigRoundZ2) + sigz2 # flat top + gaussian\n else:\n lez2 = sigz2 # flat-top\n sigz2_in = 1.0e8 \nelse:\n lez2 = 9.*sigz2 # gaussian\n sigz2_in = sigz2 \n\nlwz2 = 50.0 # Total size of sampled field in z2\nlsys_z2 = lwz2 + lez2[0] # Total length of sampled system in z2\n\ndz2 = lambda_z2 / elms_per_wave # Node spacing in z2\nNNodesZ2 = lsys_z2 / dz2 + 1 # Number of radiation field nodes\n\ndz2e = lambda_z2 / emps_per_wave # Macroparticle spacing in z2\nNMElecsZ2 = lez2 / dz2e # Number of macroparticles in z2\nNMElecsP2 = 19 # Number of macroparticles to sample energy spread\n\ndz = lambda_z2 / steps_per_per # Step size in zbar\nNsteps = zbarprop / dz # Number of steps\n\n\n###################################################\n# Chirp - 1% per sigma_z\n\ndcgamma = 0.0 # 0.01 * gamma; # Change in gamma per sigma_z due to chirp\nchirp = -dcgamma / sigz; # Energy chirp in z\nchirpz2 = Lc * chirp; # Energy chirp in z2\n\n\n###################################################\n\n# Set up the beam and seed classes, which will contain\n# the data to write in the beam and seed files\n\n#beam = [bm() for ib in range(nbeams)] # list of electron beams\n\n#seeds = [sd() for ic in range(nseeds)] # list of seeds\n\n# Assign electron pulse data to beams\n\n\n\nsigx = sigx / (sqrt(Lg) * sqrt(Lc))\nsigy = sigy / (sqrt(Lg) * sqrt(Lc))\n\nlex = 6.*sigx\nley = 6.*sigy\n\nbeam = bm()\nbeam.nbeams = nbeams\nbeam.bftype = 'simple'\n\nfor ij in range(nbeams):\n if qFlatTopZ2[ij] == 1:\n sigz2[ij] = 1e8 # Flat top case\n else:\n sigz2[ij] = sigz2[ij]\n lez2[ij] = sigz2[ij] * 8.\n\nsigpx = np.array([1.])\nsigpy = np.array([1.])\nsiggam = sig_gamma\n\nlepx = 6. * sigpx\nlepy = 6. * sigpy\nlegam = siggam * 7.\n\n\nnmpx = np.array([10])\nnmpy = np.array([10])\nnmpz2 = NMElecsZ2\n\nnmppx = np.array([10])\nnmppy = np.array([10])\nnmpgam = np.array([10])\nqmatch = [False]\ntrloadmeth = (np.array([np.int_(2)]))\nqequixy = [False]\n\nbcenter = np.array([0.0])\n\n\n#beam.sig = np.append(sigx, np.append(sigy, np.append(sigz2, np.append(sigpx, \\\n# np.append( sigpy, siggam) ) ) ))\n\n\nbeam.sig = np.concatenate( (sigx, sigy, sigz2, sigpx, sigpy, siggam) )\nbeam.le = np.concatenate( (lex, ley, lez2, lepx, lepy, legam) )\nbeam.nmps = np.int_(np.round(np.concatenate( (nmpx, nmpy, nmpz2, nmppx, nmppy, nmpgam) )))\nbeam.eratio = eratio\nbeam.emitx = emitx\nbeam.emity = emity\nbeam.alphax = alphax\nbeam.alphay = alphay\nbeam.chirp = chirp\nbeam.bcenz2 = bcenter\nbeam.Q = Q\nbeam.qRoundEj = qRoundZ2\nbeam.sigEj = sigRoundZ2\nbeam.bosc_Mag = bEnOscMag\nbeam.bosc_Fr = bEnOscFr\nbeam.qmatch = qmatch\nbeam.trload = trloadmeth\n\n\n#beam.sig = sigx + sigy + sigz2 + sigpy + sigpy + siggam\n#beam.le = lex + ley + lez2 + lepy + lepy + legam\n#beam.nmps = nmpx + nmpy + nmpz2 + nmppx + nmppy + nmpgam\n#beam.eratio = eratio\n#beam.emitx = emitx\n#beam.emity = emity\n#beam.emitx = alphax\n#beam.emity = alphay\n#beam.chirp = chirp\n#beam.bcenz2 = bcenter\n#beam.Q = Q\n#beam.qRoundEj = qRoundZ2\n#beam.sigEj = sigRoundZ2\n#beam.bosc_Mag = bEnOscMag\n#beam.bosc_Fr = bEnOscFr\n#beam.qmatch = qmatch\n#beam.trload = trloadmeth\n\n\n##################################################\n# Field info\n\nNNodesX = 1 # Next, create a class for the field vars\nNNodesY = 1 # and a routine to write the seed file\n\nlwx = 1E0\nlwy = 1E0\n\nlsys_x = lwx\nlsys_y = lwy\n\nfiltFrac = 0.3\ndiffFrac = 1.0\n\n#################################################\n# Flags\n\nqoned = True\nqfieldevo = True\nqEevolve = True\nqEFcouple = True\nqFocusing = False\nqMatchedBeam = False\nqDiffraction = False\nqFilter = True\nqNoise = True\nqDump = False\nqResume = False\nqStepFiles = True\nqFormatFiles = True\nqWriteZ = True\nqWriteA = True\nqWritePperp = True\nqWritep2 = True\nqWritez2 = True\nqWritex = True\nqWritey = True\n\n\n######## OTHER DATA TEMP! #################\n\nqScaled = True\nqUndEnds = True\nqFMesh = True\n\ntaper = 0.0\nsZ0 = 0.0\nkbetax_SF = 0.0\nkbetay_SF = 0.0\nwrFile = '' # 'wr_cl.txt'\nwrFreq_Full = 30\nwrFreq_integrated = 30\n\n\n################################################\n# Write data\n\n# Main input file:\n\nf = open(inputfile, 'w')\n\n\n\n# Header\n\nf.write('! The main input parameters are described below - Puffin takes the namelist blocks at the\\n')\nf.write('! bottom of this file as input. This is the \\'main\\' input file, containing info about the\\n')\nf.write('! wiggler, field sampling, and general flags and other numerical instructions for the\\n')\nf.write('! simulation. This file also points to a beam file, describing the electron beam,\\n')\nf.write('! and optionally, a seed file (describing a radiation seed) and/or a lattice file.\\n')\nf.write('!\\n')\nf.write('!\\n')\n# Options\n\n\nf.write('! OPTIONS\\n')\nf.write('!\\n')\nf.write('!\\n')\nf.write('! qOneD If TRUE, model 1D FEL, with only 1 node and 1 macroparticle in transverse dimensions\\n')\nf.write('! qFieldEvolve if letting the radiation field evolve\\n')\nf.write('! qElectronsEvolve if integrating electron equations\\n')\nf.write('! qElectronFieldCoupling if allowing field to feedback onto the electron equations\\n')\nf.write('! qFocussing if strong intra-undulator focussing is included in the transverse plane\\n')\nf.write('! qMatchedBeam if matching beam to undulator. If TRUE, electron pulse sigma and length in x,y,px,py are automatically calculated\\n')\nf.write('! qDiffraction if modelling diffraction\\n')\nf.write('! qFilter TRUE to filter, if FALSE the low frequencies will just be ignored during diffraction\\n')\nf.write('! q_noise Shot noise in initial electron beam distribution\\n')\nf.write('! qResume If resuming from dump files left from a previous run\\n')\nf.write('! qMeasure If .TRUE., then use measured FFT plans in FFTW\\n')\nf.write('! qDumpEnd If .TRUE., the do full data dump at end of simulation\\n')\nf.write('! qInitWrLat\\n')\nf.write('!\\n')\nf.write('!\\n')\nf.write('!\\n')\nf.write('!\\n')\n\n# Field Sampling\n\nf.write('! FIELD MESH DESCRIPTION\\n')\nf.write('!\\n')\nf.write('!\\n')\nf.write('! iNumNodesX Number of nodes to sample radiation field in x direction\\n')\nf.write('! iNumNodesY Number of nodes to sample radiation field in y direction\\n')\nf.write('! nodesPerLambdar Number of nodes per resonant wavelength\\n')\nf.write('! sFModelLengthX Length of radiation field model in x direction\\n')\nf.write('! sFModelLengthY Length of radiation field model in y direction\\n')\nf.write('! sWigglerLengthZ2 Length of field model in z2-bar direction\\n')\nf.write('! iRedNodesX Length of central field section in x where electrons will not leave\\n')\nf.write('! iRedNodesY Length of central field section in y where electrons will not leave\\n')\nf.write('! sFiltFrac Specifies cutoff for high pass filter as fraction of resonant frequency - used in diffraction step\\n')\nf.write('! sDiffFrac Specifies diffraction step size as fraction of the undulator period\\n')\nf.write('! beta Absorption coefficient\\n')\n\nf.write('!\\n')\nf.write('!\\n')\n\n\nf.write('! INDEPENDANT VARIABLES\\n')\nf.write('!\\n')\nf.write('!\\n')\nf.write('! Scaled independent vars. These describe the reference beam and undulator \\n')\nf.write('! used for the scaling of the system. \\n')\nf.write('!\\n')\nf.write('!\\n')\nf.write('! srho Pierce or FEL parameter, describing the strength of the interaction (or efficiency)\\n')\nf.write('! sux Normalised magnitude of wiggler magnetic field x-vector: H=1 is helical, H=0 is planar\\n')\nf.write('! suy Normalised magnitude of wiggler magnetic field y-vector: H=1 is helical, H=0 is planar\\n')\nf.write('! saw peak undulator parameter\\n')\nf.write('! sgamma_r Resonant, or reference, beam energy\\n')\nf.write('! lambda_w Undulator period\\n')\n\nf.write('!')\nf.write('!')\nf.write('! SIMPLE UNDULATOR SETUP')\nf.write('!')\nf.write('! \\'Quick\\' or \\'simple\\' undulator. If not using a lattice file, then this \\n')\nf.write('! undulator will be used. If a lattice file is used then these parameters \\n')\nf.write('! are ignored.\\n')\nf.write('!')\nf.write('!')\nf.write('! zundType Undulator type - \\'curved\\' , \\'planepole\\', \\'helical\\' or blank\\n')\nf.write('! taper gradient of taper - d/dz of alpha\\n')\nf.write('! nPeriods Number of wiggler periods\\n')\nf.write('! stepsPerPeriod Number of integration steps per wiggler period\\n')\nf.write('!\\n')\nf.write('!\\n')\nf.write('! EXTERNAL FILES\\n')\nf.write('!\\n')\nf.write('! The beam file is required, if not specified then the beam file is\\n')\nf.write('! assumed = \\'beam_file.in\\', which must be in working directory.\\n')\nf.write('!\\n')\nf.write('! beam_file Name of the beam file\\n')\nf.write('! seed_file Name of the seed file\\n')\nf.write('! lattFile Name of lattice file (optional).\\n')\nf.write('! wr_file Name of the write file (optional).\\n')\n\n\nf.write('!\\n')\nf.write('!\\n')\nf.write('! DATA WRITING FREQUENCY\\n')\nf.write('!\\n')\nf.write('! iWriteNthSteps Steps to write data at\\n')\nf.write('! iWriteIntNthSteps Steps to write integrated data at\\n')\nf.write('! sZ0 Starting zbar position\\n')\n\nf.write('!\\n')\nf.write('!\\n')\nf.write('! Additional Beam Loading Options... (rarely used!!!) \\n')\nf.write('!\\n')\nf.write('! sPEOut Percentage of macroparticles to write out\\n')\nf.write('! sEThreshold Below the threshold level(%) * the average of real electrons are removed(ignored)\\n')\n\nf.write('\\n')\nf.write('\\n')\nf.write('\\n')\nf.write('\\n')\n\nf.write('&MDATA\\n')\nf.write(' qScaled = ' + torf(qScaled) + '\\n')\nf.write(' qOneD = ' + torf(qoned) + '\\n')\nf.write(' qFieldEvolve = ' + torf(qfieldevo) + '\\n')\nf.write(' qElectronsEvolve = ' + torf(qEevolve) + '\\n')\nf.write(' qElectronFieldCoupling = ' + torf(qEFcouple) + '\\n')\nf.write(' qFocussing = ' + torf(qFocusing) + '\\n')\nf.write(' qDiffraction = ' + torf(qDiffraction) + '\\n')\nf.write(' qUndEnds = ' + torf(qUndEnds) + '\\n')\nf.write(' qFMesh_G = ' + torf(qFMesh) + '\\n')\nf.write(' beam_file = ' + '\\'' + beamfile + '\\'' + '\\n')\nif (seedfile != ''):\n f.write(' seed_file = ' + '\\'' + seedfile + '\\'' + '\\n')\n#f.write(' lattFile = ' + '\\'' + lattFile + '\\'' + '\\n')\nf.write(' wr_file = ' + '\\'' + wrFile + '\\'' + '\\n')\n\n\n# Field Mesh:\n\nf.write(' iNumNodesX = ' + '{:d}'.format(int(math.floor(NNodesX))) + '\\n')\nf.write(' iNumNodesY = ' + '{:d}'.format(int(math.floor(NNodesY))) + '\\n')\nf.write(' nodesPerLambdar = ' + '{:d}'.format(int(math.floor(elms_per_wave))) + '\\n')\nf.write(' sFModelLengthX = ' + '{:.15E}'.format(lsys_x) + '\\n')\nf.write(' sFModelLengthY = ' + '{:.15E}'.format(lsys_y) + '\\n')\nf.write(' sFModelLengthZ2 = ' + '{:.15E}'.format(lsys_z2) + '\\n')\nf.write(' iRedNodesX = ' + '{:d}'.format(1) + '\\n')\nf.write(' iRedNodesY = ' + '{:d}'.format(1) + '\\n')\nf.write(' sFiltFrac = ' + '{:.15E}'.format(filtFrac) + '\\n')\nf.write(' sDiffFrac = ' + '{:.15E}'.format(diffFrac) + '\\n')\nf.write(' sBeta = ' + '{:.15E}'.format(0.1) + '\\n')\n\n\n# Scaling parameters - sets up the frame\n\nf.write(' srho = ' + '{:.15E}'.format(rho) + '\\n')\nf.write(' saw = ' + '{:.15E}'.format(aw) + '\\n')\nf.write(' sgamma_r = ' + '{:.15E}'.format(gamma) + '\\n')\nf.write(' lambda_w = ' + '{:.15E}'.format(lambda_w) + '\\n')\nf.write(' zundType = ' + '\\'' + undtype + '\\'' + '\\n')\n\n# 'base' wiggler - with lambda_w above. Ignored with a lattice file\n\nf.write(' lambda_w = ' + '{:.15E}'.format(lambda_w) + '\\n')\nf.write(' taper = ' + '{:.15E}'.format(taper) + '\\n')\nf.write(' sKBetaXSF = ' + '{:.15E}'.format(kbetax_SF) + '\\n')\nf.write(' sKBetaYSF = ' + '{:.15E}'.format(kbetay_SF) + '\\n')\nf.write(' nPeriods = ' + '{:d}'.format(int(N_w)) + '\\n')\n\n# integration/write options\nf.write(' stepsPerPeriod = ' + '{:d}'.format(steps_per_per) + '\\n')\nf.write(' sZ0 = ' + '{:.15E}'.format(sZ0) + '\\n')\nf.write(' iWriteNthSteps = ' + '{:d}'.format(wrFreq_Full) + '\\n')\nf.write(' iWriteIntNthSteps = ' + '{:d}'.format(wrFreq_integrated) + '\\n')\nf.write(' /\\n')\n\nf.close()\n\n\nprint 'Main data file written to: ' + inputfile\n\n\n#\n# beam file\n\nf = open(beamfile, 'w')\n\n\n# Write beam files\n\n#for ib in range(nbeams):\n# beam[ib].wrbeam(f,ib+1)\nbeam.wrbeam(f,1)\nf.close()\n\nprint 'Beam file written to: ' + beamfile\n\n#\n# seed file\n\nif (seedfile != ''):\n\n seed = sd()\n f = open(seedfile, 'w')\n\n# Write seed data\n\n for ic in range(nseeds):\n seed.wrseed(f,ic+1)\n\n\n f.close()\n\n print 'Radiation seed file written to: ' + seedfile\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n", "meta": {"hexsha": "b17db0181cc82b80061e70889d4fab822865328d", "size": 21738, "ext": "py", "lang": "Python", "max_stars_repo_path": "utilities/setup/genInputs/write_df.py", "max_stars_repo_name": "mightylorenzo/Puffin", "max_stars_repo_head_hexsha": "6631eb91a5d98d8bc3d40fe9f09b90932f20776a", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 15, "max_stars_repo_stars_event_min_datetime": "2017-08-29T10:50:13.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-14T07:21:49.000Z", "max_issues_repo_path": "utilities/setup/genInputs/write_df.py", "max_issues_repo_name": "mightylorenzo/Puffin", "max_issues_repo_head_hexsha": "6631eb91a5d98d8bc3d40fe9f09b90932f20776a", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 27, "max_issues_repo_issues_event_min_datetime": "2017-06-20T09:40:33.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-18T22:35:47.000Z", "max_forks_repo_path": "utilities/setup/genInputs/write_df.py", "max_forks_repo_name": "mightylorenzo/Puffin", "max_forks_repo_head_hexsha": "6631eb91a5d98d8bc3d40fe9f09b90932f20776a", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 15, "max_forks_repo_forks_event_min_datetime": "2017-06-21T21:00:13.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-16T02:15:59.000Z", "avg_line_length": 31.8272327965, "max_line_length": 155, "alphanum_fraction": 0.5997331861, "include": true, "reason": "import numpy", "num_tokens": 6639, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.531209388216861, "lm_q2_score": 0.3665897363221598, "lm_q1q2_score": 0.1947359095582749}} {"text": "#!/usr/bin/env python\n# Copyright 2014-2020 The PySCF Developers. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n# Author: Paul J. Robinson \n# Qiming Sun \n#\n\n'''\nVasp CHGCAR file format\n\nSee also\nhttps://cms.mpi.univie.ac.at/vasp/vasp/CHGCAR_file.html\n'''\n\nimport sys\nimport collections\nimport time\nimport numpy\nimport pyscf\nfrom pyscf import lib\nfrom pyscf import gto\nfrom pyscf.pbc import gto as pbcgto\nfrom pyscf.tools import cubegen\n\nif sys.version_info >= (3,):\n unicode = str\n\nRESOLUTION = cubegen.RESOLUTION\nBOX_MARGIN = cubegen.BOX_MARGIN\n\n\ndef density(cell, outfile, dm, nx=60, ny=60, nz=60, resolution=RESOLUTION):\n '''Calculates electron density and write out in CHGCAR format.\n\n Args:\n cell : Mole or Cell object\n Mole or pbc Cell. If Mole object is given, the program will guess\n a cubic lattice for the molecule.\n outfile : str\n Name of Cube file to be written.\n dm : ndarray\n Density matrix of molecule.\n\n Kwargs:\n nx : int\n Number of grid point divisions in x direction.\n Note this is function of the molecule's size; a larger molecule\n will have a coarser representation than a smaller one for the\n same value.\n ny : int\n Number of grid point divisions in y direction.\n nz : int\n Number of grid point divisions in z direction.\n\n Returns:\n No return value. This function outputs a VASP chgcarlike file\n (with phase if desired)...it can be opened in VESTA or VMD or\n many other softwares\n \n Examples:\n\n >>> # generates the first MO from the list of mo_coefficents \n >>> from pyscf.pbc import gto, scf\n >>> from pyscf.tools import chgcar\n >>> cell = gto.M(atom='H 0 0 0; H 0 0 1', a=numpy.eye(3)*3)\n >>> mf = scf.RHF(cell).run()\n >>> chgcar.density(cell, 'h2.CHGCAR', mf.make_rdm1())\n\n '''\n cc = CHGCAR(cell, nx=nx, ny=ny, nz=nz, resolution=resolution)\n\n coords = cc.get_coords()\n ngrids = cc.get_ngrids()\n blksize = min(8000, ngrids)\n rho = numpy.empty(ngrids)\n for ip0, ip1 in lib.prange(0, ngrids, blksize):\n if isinstance(cell, pbcgto.cell.Cell):\n ao = cell.pbc_eval_gto('GTOval', coords[ip0:ip1])\n else:\n ao = cell.eval_gto('GTOval', coords[ip0:ip1])\n rho[ip0:ip1] = lib.einsum('pi,ij,pj->p', ao, dm, ao)\n rho = rho.reshape(nx,ny,nz)\n\n cc.write(rho, outfile)\n\n\ndef orbital(cell, outfile, coeff, nx=60, ny=60, nz=60, resolution=RESOLUTION):\n '''Calculate orbital value on real space grid and write out in\n CHGCAR format.\n\n Args:\n cell : Mole or Cell object\n Mole or pbc Cell. If Mole object is given, the program will guess\n a cubic lattice for the molecule.\n outfile : str\n Name of Cube file to be written.\n dm : ndarray\n Density matrix of molecule.\n\n Kwargs:\n nx : int\n Number of grid point divisions in x direction.\n Note this is function of the molecule's size; a larger molecule\n will have a coarser representation than a smaller one for the\n same value.\n ny : int\n Number of grid point divisions in y direction.\n nz : int\n Number of grid point divisions in z direction.\n\n Returns:\n No return value. This function outputs a VASP chgcarlike file\n (with phase if desired)...it can be opened in VESTA or VMD or\n many other softwares\n \n Examples:\n\n >>> # generates the first MO from the list of mo_coefficents \n >>> from pyscf.pbc import gto, scf\n >>> from pyscf.tools import chgcar\n >>> cell = gto.M(atom='H 0 0 0; H 0 0 1', a=numpy.eye(3)*3)\n >>> mf = scf.RHF(cell).run()\n >>> chgcar.orbital(cell, 'h2_mo1.CHGCAR', mf.mo_coeff[:,0])\n\n '''\n cc = CHGCAR(cell, nx=nx, ny=ny, nz=nz, resolution=resolution)\n\n coords = cc.get_coords()\n ngrids = cc.get_ngrids()\n blksize = min(8000, ngrids)\n orb_on_grid = numpy.empty(ngrids)\n for ip0, ip1 in lib.prange(0, ngrids, blksize):\n if isinstance(cell, pbcgto.cell.Cell):\n ao = cell.pbc_eval_gto('GTOval', coords[ip0:ip1])\n else:\n ao = cell.eval_gto('GTOval', coords[ip0:ip1])\n orb_on_grid[ip0:ip1] = numpy.dot(ao, coeff)\n orb_on_grid = orb_on_grid.reshape(nx,ny,nz)\n\n cc.write(orb_on_grid, outfile, comment='Orbital value in real space (1/Bohr^3)')\n\n\nclass CHGCAR(cubegen.Cube):\n ''' Read-write of the Vasp CHGCAR files '''\n def __init__(self, cell, nx=60, ny=60, nz=60, resolution=RESOLUTION,\n margin=BOX_MARGIN):\n if not isinstance(cell, pbcgto.cell.Cell):\n coord = cell.atom_coords()\n box = numpy.max(coord,axis=0) - numpy.min(coord,axis=0) + margin*2\n boxorig = numpy.min(coord,axis=0) - margin\n if resolution is not None:\n nx, ny, nz = numpy.ceil(box / resolution).astype(int)\n self.box = numpy.diag(box)\n lib.logger.warn(cell, 'Molecular system is found. FFT-grid is not '\n 'available for Molecule. Lattice (in Bohr)\\n'\n '%s\\nand FFT grids %s are applied.',\n self.box, (nx,ny,nz))\n self.mol = cell\n cell = cell.view(pbcgto.Cell)\n if (isinstance(cell.unit, (str, unicode)) and\n cell.unit.startswith(('B','b','au','AU'))):\n cell.a = self.box\n else:\n cell.a = self.box * lib.param.BOHR\n ptr = cell._atm[:,gto.PTR_COORD]\n cell._env[ptr+0] = coord[:,0] - boxorig[0]\n cell._env[ptr+1] = coord[:,1] - boxorig[1]\n cell._env[ptr+2] = coord[:,2] - boxorig[2]\n\n self.nx = nx\n self.ny = ny\n self.nz = nz\n self.cell = cell\n self.box = cell.lattice_vectors()\n self.boxorig = numpy.zeros(3)\n self.vol = cell.vol\n\n def get_coords(self) :\n \"\"\" Result: set of coordinates to compute a field which is to be stored\n in the file.\n \"\"\"\n xs = numpy.arange(self.nx) * (1./self.nx)\n ys = numpy.arange(self.ny) * (1./self.ny)\n zs = numpy.arange(self.nz) * (1./self.nz)\n xyz = lib.cartesian_prod((xs, ys, zs))\n coords = numpy.dot(xyz, self.box)\n return numpy.asarray(coords, order='C')\n\n def write(self, field, fname, comment=None):\n \"\"\" Result: .vasp file with the field in the file fname. \"\"\"\n assert(field.ndim == 3)\n assert(field.shape == (self.nx, self.ny, self.nz))\n if comment is None:\n comment = 'VASP file: Electron density in real space (e/Bohr^3) '\n\n cell = self.cell\n\n # See CHGCAR format https://cms.mpi.univie.ac.at/vasp/vasp/CHGCAR_file.html\n # the value of (total density * volume) was dumped\n field = field * self.vol\n\n boxA = self.box * lib.param.BOHR\n atomList= [cell.atom_pure_symbol(i) for i in range(cell.natm)]\n Axyz = zip(atomList, cell.atom_coords().tolist())\n Axyz = sorted(Axyz, key = lambda x: x[0])\n swappedCoords = [(vec[1]+self.boxorig) * lib.param.BOHR for vec in Axyz]\n vaspAtomicInfo = collections.Counter([xyz[0] for xyz in Axyz])\n vaspAtomicInfo = sorted(vaspAtomicInfo.items())\n with open(fname, 'w') as f:\n f.write(comment)\n f.write('PySCF Version: %s Date: %s\\n' % (pyscf.__version__, time.ctime()))\n f.write('1.0000000000\\n')\n f.write('%14.8f %14.8f %14.8f \\n' % (boxA[0,0],boxA[0,1],boxA[0,2]))\n f.write('%14.8f %14.8f %14.8f \\n' % (boxA[1,0],boxA[1,1],boxA[1,2]))\n f.write('%14.8f %14.8f %14.8f \\n' % (boxA[2,0],boxA[2,1],boxA[2,2]))\n f.write(''.join(['%5.3s'%atomN[0] for atomN in vaspAtomicInfo]) + '\\n')\n f.write(''.join(['%5d'%atomN[1] for atomN in vaspAtomicInfo]) + '\\n')\n f.write('Cartesian \\n')\n for ia in range(cell.natm):\n f.write(' %14.8f %14.8f %14.8f\\n' % tuple(swappedCoords[ia]))\n f.write('\\n')\n f.write('%6.5s %6.5s %6.5s \\n' % (self.nx,self.ny,self.nz))\n fmt = ' %14.8e '\n for iz in range(self.nz):\n for iy in range(self.ny):\n f.write('\\n')\n for ix in range(self.nx):\n f.write(fmt % field[ix,iy,iz])\n\n def read(self, chgcar_file):\n raise NotImplementedError\n\n\nif __name__ == '__main__':\n from pyscf.pbc import scf\n from pyscf.tools import chgcar\n cell = gto.M(atom='H 0 0 0; H 0 0 1', a=numpy.eye(3)*3)\n mf = scf.RHF(cell).run()\n chgcar.density(cell, 'h2.CHGCAR', mf.make_rdm1()) #makes total density\n chgcar.orbital(cell, 'h2_mo1.CHGCAR', mf.mo_coeff[:,0]) # makes mo#1 (sigma)\n chgcar.orbital(cell, 'h2_mo2.CHGCAR', mf.mo_coeff[:,1]) # makes mo#2 (sigma*)\n\n", "meta": {"hexsha": "c320bf94cacb938e6643435ba4a8f63afab32487", "size": 9588, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyscf/tools/chgcar.py", "max_stars_repo_name": "mfkasim1/pyscf", "max_stars_repo_head_hexsha": "7be5e015b2b40181755c71d888449db936604660", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-11-12T11:55:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-12T11:55:25.000Z", "max_issues_repo_path": "pyscf/tools/chgcar.py", "max_issues_repo_name": "mfkasim1/pyscf", "max_issues_repo_head_hexsha": "7be5e015b2b40181755c71d888449db936604660", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 36, "max_issues_repo_issues_event_min_datetime": "2018-08-22T19:44:03.000Z", "max_issues_repo_issues_event_max_datetime": "2020-05-09T10:02:36.000Z", "max_forks_repo_path": "pyscf/tools/chgcar.py", "max_forks_repo_name": "mfkasim1/pyscf", "max_forks_repo_head_hexsha": "7be5e015b2b40181755c71d888449db936604660", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2018-02-14T16:28:28.000Z", "max_forks_repo_forks_event_max_datetime": "2019-08-12T16:40:30.000Z", "avg_line_length": 37.6, "max_line_length": 88, "alphanum_fraction": 0.5887567793, "include": true, "reason": "import numpy", "num_tokens": 2724, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5312093733737563, "lm_q2_score": 0.36658974324230986, "lm_q1q2_score": 0.19473590779299363}} {"text": "\"\"\" Function that adds common arguments for all input formats to the argument parser handle. \"\"\"\n\n\nimport os\n\nimport numpy as np\n\nfrom wmpl.Trajectory.Trajectory import Trajectory\nfrom wmpl.Trajectory.GuralTrajectory import GuralTrajectory\nfrom wmpl.Utils.TrajConversions import J2000_JD, jd2Date, equatorialCoordPrecession_vect, raDec2AltAz_vect\n\n\n\nclass MeteorObservation(object):\n \"\"\" Container for meteor observations. \n \n The points in arrays are RA and Dec in J2000 epoch, in radians.\n\n Arguments:\n jdt_ref: [float] Reference Julian date when the relative time is t = 0s.\n station_id: [str] Station ID.\n latitude: [float] Latitude +N in radians.\n longitude: [float] Longitude +E in radians.\n height: [float] Elevation above sea level (MSL) in meters.\n fps: [float] Frames per second.\n\n Keyword arguments:\n ff_name: [str] Name of the originating FF file.\n\n \"\"\"\n def __init__(self, jdt_ref, station_id, latitude, longitude, height, fps, ff_name=None):\n\n self.jdt_ref = jdt_ref\n self.station_id = station_id\n self.latitude = latitude\n self.longitude = longitude\n self.height = height\n self.fps = fps\n\n self.ff_name = ff_name\n\n self.frames = []\n self.time_data = []\n self.x_data = []\n self.y_data = []\n self.azim_data = []\n self.elev_data = []\n self.ra_data = []\n self.dec_data = []\n self.mag_data = []\n self.abs_mag_data = []\n\n\n\n def addPoint(self, frame_n, x, y, azim, elev, ra, dec, mag):\n \"\"\" Adds the measurement point to the meteor.\n\n Arguments:\n frame_n: [flaot] Frame number from the reference time.\n x: [float] X image coordinate.\n y: [float] X image coordinate.\n azim: [float] Azimuth, J2000 in degrees.\n elev: [float] Elevation angle, J2000 in degrees.\n ra: [float] Right ascension, J2000 in degrees.\n dec: [float] Declination, J2000 in degrees.\n mag: [float] Visual magnitude.\n\n \"\"\"\n\n self.frames.append(frame_n)\n\n # Calculate the time in seconds w.r.t. to the reference JD\n point_time = float(frame_n)/self.fps\n\n self.time_data.append(point_time)\n\n self.x_data.append(x)\n self.y_data.append(y)\n\n # Angular coordinates converted to radians\n self.azim_data.append(np.radians(azim))\n self.elev_data.append(np.radians(elev))\n self.ra_data.append(np.radians(ra))\n self.dec_data.append(np.radians(dec))\n self.mag_data.append(mag)\n\n\n\n def finish(self):\n \"\"\" When the initialization is done, convert data lists to numpy arrays. \"\"\"\n\n self.frames = np.array(self.frames)\n self.time_data = np.array(self.time_data)\n self.x_data = np.array(self.x_data)\n self.y_data = np.array(self.y_data)\n self.azim_data = np.array(self.azim_data)\n self.elev_data = np.array(self.elev_data)\n self.ra_data = np.array(self.ra_data)\n self.dec_data = np.array(self.dec_data)\n self.mag_data = np.array(self.mag_data)\n\n # Sort by frame\n temp_arr = np.c_[self.frames, self.time_data, self.x_data, self.y_data, self.azim_data, \\\n self.elev_data, self.ra_data, self.dec_data, self.mag_data]\n temp_arr = temp_arr[np.argsort(temp_arr[:, 0])]\n self.frames, self.time_data, self.x_data, self.y_data, self.azim_data, self.elev_data, self.ra_data, \\\n self.dec_data, self.mag_data = temp_arr.T\n\n\n\n\n def __repr__(self):\n\n out_str = ''\n\n out_str += 'Station ID = ' + str(self.station_id) + '\\n'\n out_str += 'JD ref = {:f}'.format(self.jdt_ref) + '\\n'\n out_str += 'DT ref = {:s}'.format(jd2Date(self.jdt_ref, \\\n dt_obj=True).strftime(\"%Y/%m/%d-%H%M%S.%f\")) + '\\n'\n out_str += 'Lat = {:f}, Lon = {:f}, Ht = {:f} m'.format(np.degrees(self.latitude), \n np.degrees(self.longitude), self.height) + '\\n'\n out_str += 'FPS = {:f}'.format(self.fps) + '\\n'\n\n out_str += 'Points:\\n'\n out_str += 'Time, X, Y, azimuth, elevation, RA, Dec, Mag:\\n'\n\n for point_time, x, y, azim, elev, ra, dec, mag in zip(self.time_data, self.x_data, self.y_data, \\\n self.azim_data, self.elev_data, self.ra_data, self.dec_data, self.mag_data):\n\n if mag is None:\n mag = 0\n\n out_str += '{:.4f}, {:.2f}, {:.2f}, {:.2f}, {:.2f}, {:.2f}, {:+.2f}, {:.2f}\\n'.format(point_time,\\\n x, y, np.degrees(azim), np.degrees(elev), np.degrees(ra), np.degrees(dec), mag)\n\n\n return out_str\n\n\n\ndef prepareObservations(meteor_list):\n \"\"\" Takes a list of MeteorObservation objects, normalizes all data points to the same reference Julian \n date, precesses the observations from J2000 to the epoch of date. \n \n Arguments:\n meteor_list: [list] List of MeteorObservation objects\n\n Return:\n (jdt_ref, meteor_list):\n - jdt_ref: [float] reference Julian date for which t = 0\n - meteor_list: [list] A list a MeteorObservations whose time is normalized to jdt_ref, and are\n precessed to the epoch of date\n\n \"\"\"\n\n if meteor_list:\n\n # The reference meteor is the one with the first time of the first frame\n ref_ind = np.argmin([met.jdt_ref + met.time_data[0]/86400.0 for met in meteor_list])\n tsec_delta = meteor_list[ref_ind].time_data[0] \n jdt_delta = tsec_delta/86400.0\n\n\n ### Normalize all times to the beginning of the first meteor\n\n # Apply the normalization to the reference meteor\n meteor_list[ref_ind].jdt_ref += jdt_delta\n meteor_list[ref_ind].time_data -= tsec_delta\n\n\n meteor_list_tcorr = []\n\n for i, meteor in enumerate(meteor_list):\n\n # Only correct non-reference meteors\n if i != ref_ind:\n\n # Calculate the difference between the reference and the current meteor\n jdt_diff = meteor.jdt_ref - meteor_list[ref_ind].jdt_ref\n tsec_diff = jdt_diff*86400.0\n\n # Normalize all meteor times to the same reference time\n meteor.jdt_ref -= jdt_diff\n meteor.time_data += tsec_diff\n\n meteor_list_tcorr.append(meteor)\n\n ######\n\n # The reference JD for all meteors is thus the reference JD of the first meteor\n jdt_ref = meteor_list_tcorr[ref_ind].jdt_ref\n\n\n ### Precess observations from J2000 to the epoch of date\n meteor_list_epoch_of_date = []\n for meteor in meteor_list_tcorr:\n\n jdt_ref_vect = np.zeros_like(meteor.ra_data) + jdt_ref\n\n # Precess from J2000 to the epoch of date\n ra_prec, dec_prec = equatorialCoordPrecession_vect(J2000_JD.days, jdt_ref_vect, meteor.ra_data, \n meteor.dec_data)\n\n meteor.ra_data = ra_prec\n meteor.dec_data = dec_prec\n\n # Convert preccesed Ra, Dec to altitude and azimuth\n meteor.azim_data, meteor.elev_data = raDec2AltAz_vect(meteor.ra_data, meteor.dec_data, jdt_ref,\n meteor.latitude, meteor.longitude)\n\n meteor_list_epoch_of_date.append(meteor)\n\n\n ######\n\n\n return jdt_ref, meteor_list_epoch_of_date\n\n else:\n return None, None\n\n\n\ndef solveTrajectoryGeneric(jdt_ref, meteor_list, dir_path, solver='original', **kwargs):\n \"\"\" Feed the list of meteors in the trajectory solver and run it. \n \n Arguments:\n jdt_ref: [float] Reference Julian date for all objects in meteor_list.\n meteor_list: [list] A list of MeteorObservation objects.\n dir_path: [str] Path to the data directory.\n\n Keyword arguments:\n solver: [str] Solver choice:\n - \"original\" is the Monte Carlo solver\n - \"gural\" is the Gural solver (through C++ bindings)\n **kwargs: Keyword arguments for the trajectory solver.\n\n \"\"\"\n\n # Create name of output directory\n output_dir = os.path.join(dir_path, jd2Date(jdt_ref, dt_obj=True).strftime(\"%Y%m%d-%H%M%S.%f\"))\n\n\n # Init the trajectory solver\n if solver == 'original':\n traj = Trajectory(jdt_ref, output_dir=output_dir, meastype=1, **kwargs)\n\n elif solver.lower().startswith('gural'):\n velmodel = solver.lower().strip('gural')\n if len(velmodel) == 1:\n velmodel = int(velmodel)\n else:\n velmodel = 0\n\n traj = GuralTrajectory(len(meteor_list), jdt_ref, velmodel=velmodel, meastype=1, verbose=1, \n output_dir=output_dir)\n\n else:\n print('No such solver:', solver)\n return \n\n\n # Add meteor observations to the solver\n for meteor in meteor_list:\n\n if solver == 'original':\n\n comment = ''\n if hasattr(meteor, \"ff_name\"):\n comment = meteor.ff_name\n\n traj.infillTrajectory(meteor.ra_data, meteor.dec_data, meteor.time_data, meteor.latitude, \n meteor.longitude, meteor.height, station_id=meteor.station_id, \\\n magnitudes=meteor.mag_data, comment=comment)\n\n elif solver.lower().startswith('gural'):\n\n # Extract velocity model is given\n try:\n velmodel = int(solver[-1])\n\n except: \n # Default to the exponential model\n velmodel = 3\n\n traj.infillTrajectory(meteor.ra_data, meteor.dec_data, meteor.time_data, meteor.latitude, \n meteor.longitude, meteor.height)\n\n\n # Solve the trajectory\n traj = traj.run()\n\n return traj\n\n\n\ndef addSolverOptions(arg_parser, skip_velpart=False):\n \"\"\" Adds common arguments for all input formats to the argument parser handle. \"\"\"\n\n arg_parser.add_argument('-s', '--solver', metavar='SOLVER', help=\"\"\"Trajectory solver to use. \\n\n - 'original' - Monte Carlo solver\n - 'gural0' - Gural constant velocity\n - 'gural1' - Gural linear deceleration\n - 'gural2' - Gural quadratic deceleration\n - 'gural3' - Gural exponential deceleration\n \"\"\", type=str, nargs='?', default='original')\n\n arg_parser.add_argument('-t', '--maxtoffset', metavar='MAX_TOFFSET', nargs=1, \\\n help='Maximum time offset between the stations.', type=float)\n\n arg_parser.add_argument('-v', '--vinitht', metavar='V_INIT_HT', nargs=1, \\\n help='The initial veloicty will be estimated as the average velocity above this height (in km). If not given, the initial velocity will be estimated using the sliding fit which can be controlled with the --velpart option.', \\\n type=float)\n\n if not skip_velpart:\n arg_parser.add_argument('-p', '--velpart', metavar='VELOCITY_PART', \\\n help='Fixed part from the beginning of the meteor on which the initial velocity estimation using the sliding fit will start. Default is 0.25 (25 percent), but for noisier data this might be bumped up to 0.5.', \\\n type=float, default=0.25)\n\n arg_parser.add_argument('-d', '--disablemc', \\\n help='Do not use the Monte Carlo solver, but only run the geometric solution.', action=\"store_true\")\n\n arg_parser.add_argument('-e', '--notimefit', \\\n help=\"Do not estimate timing and velocity together. The times are assumed to be fixed. A list of time offsets per station can be provided, e.g. \\\"'CA001A':0.42,'CA0005':-0.3\\\" for speciflying offsets of 0.42 and -0.3 seconds for stations CA001A and CA0005, respectively. Make sure there are no spaces between the arguments, although spaces are fine in the station name.\", \\\n type=str, nargs=\"?\", default=True)\n \n arg_parser.add_argument('-r', '--mcruns', metavar=\"MC_RUNS\", \\\n help='Number of Monte Carlo runs.', type=int, default=100)\n\n arg_parser.add_argument('-u', '--uncertgeom', \\\n help='Compute purely geometric uncertainties.', action=\"store_true\")\n\n arg_parser.add_argument('-m', '--mcstd', metavar='MC_STDDEVS', \\\n help='Standard deviations of noise to add to measurements during the Monte Carlo procedure. 1.0 by default.', \\\n type=float, default=1.0)\n \n arg_parser.add_argument('-g', '--disablegravity', \\\n help='Disable gravity compensation.', action=\"store_true\")\n\n arg_parser.add_argument('-l', '--plotallspatial', \\\n help='Plot a collection of plots showing the residuals vs. time, lenght and height.', \\\n action=\"store_true\")\n\n arg_parser.add_argument('-j', '--jacchia', \\\n help='Show the Jacchia exponential deceleration fit on plots with the dynamics.', \\\n action=\"store_true\")\n\n arg_parser.add_argument('-i', '--imgformat', metavar='IMG_FORMAT', nargs=1, \\\n help=\"Plot image format. 'png' by default, can be 'pdf', 'eps',... \", type=str, default='png')\n\n arg_parser.add_argument('-x', '--hideplots', \\\n help=\"Don't show generated plots on the screen, just save them to disk.\", action=\"store_true\")\n\n\n return arg_parser", "meta": {"hexsha": "4cf0680573d3fdda0b1bebaae23cc43f45419ec0", "size": 13062, "ext": "py", "lang": "Python", "max_stars_repo_path": "wmpl/Formats/GenericFunctions.py", "max_stars_repo_name": "markmac99/WesternMeteorPyLib", "max_stars_repo_head_hexsha": "c5104974c3f1e2259b0d0ea63a9bbaa15d236be2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "wmpl/Formats/GenericFunctions.py", "max_issues_repo_name": "markmac99/WesternMeteorPyLib", "max_issues_repo_head_hexsha": "c5104974c3f1e2259b0d0ea63a9bbaa15d236be2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "wmpl/Formats/GenericFunctions.py", "max_forks_repo_name": "markmac99/WesternMeteorPyLib", "max_forks_repo_head_hexsha": "c5104974c3f1e2259b0d0ea63a9bbaa15d236be2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.7943661972, "max_line_length": 381, "alphanum_fraction": 0.6276221099, "include": true, "reason": "import numpy", "num_tokens": 3177, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5312093733737563, "lm_q2_score": 0.36658973632215985, "lm_q1q2_score": 0.19473590411694508}} {"text": "from torch.utils.data import Dataset, DataLoader\nimport os,glob,random,cv2,json,torch,util,cv2,h5py,math\nimport numpy as np\nimport config as cfg\nfrom SMPL_layer import SMPL_Layer\n\nclass Surreal(Dataset):\n # Note for the surreal data\n # The 3D keyps (in world frame), after aligning\n # by pelvis, match the output of smpl(theta,beta),\n # where (theta,beta) are the smpl params given in\n # in the world frame\n def __init__(self,phase):\n self.dataPhase=phase #\"train\", \"val\", or \"test\"\n self.pathPrefix=\"/data/cmu/extracted/data/{}\".format(self.dataPhase)\n self.normalize=True\n self.cropSize=cfg.surrealCropSize\n self.pixFormat=\"NCHW\"\n self.cameraSpace=cfg.surrealCameraSpace\n self.loadData()\n\n def pathFilter(self,rgbP,depthP):\n s1=rgbP.split(\"rgb\")\n s2=depthP.split(\"depth\")\n check1=s1[0]==s2[0]\n s11=s1[1].split(\".\")\n s22=s2[1].split(\".\")\n check2=s11[0]==s22[0]\n if check1 and check2:\n return True\n else:\n return False\n\n def swapRightLeftPose(self,pose):\n swapInds = np.array([\n 0, 1, 2, 6, 7, 8, 3, 4, 5, 9, 10, 11, 15, 16, 17, 12, 13, 14, 18,\n 19, 20, 24, 25, 26, 21, 22, 23, 27, 28, 29, 33, 34, 35, 30, 31, 32,\n 36, 37, 38, 42, 43, 44, 39, 40, 41, 45, 46, 47, 51, 52, 53, 48, 49,\n 50, 57, 58, 59, 54, 55, 56, 63, 64, 65, 60, 61, 62, 69, 70, 71, 66,\n 67, 68\n ], np.int32)\n\n signFlip = np.array([ \n 1, 1, 1, 1, -1, -1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, -1, -1, 1, -1, -1, 1, -1, -1, 1, -1, -1, 1, -1, -1, 1, -1, -1, 1, -1, -1, 1, -1, -1, 1, -1, -1, 1, -1, -1, 1, -1, -1, 1, -1, -1, 1, -1, -1\n ], dtype=pose.dtype)\n\n newPose=np.take(pose,swapInds)*signFlip\n\n return newPose\n\n def swapRightLeftJoints(self,joints):\n assert joints.shape[1] == 24\n swapInds = np.array([0, 2, 1, 3, 5, 4, 6, 8, 7, 9, 11,10,12,14,13, 15, 17,16, 19,18,21,20,23,22], np.int32)\n jointsSwap=np.take(joints,swapInds,axis=1)\n return jointsSwap\n \n def loadData(self):\n self.keyps2d=[]\n self.keyps3d=[]\n self.smplShapeParams=[]\n self.smplPoseParams=[]\n self.rgbImages=[]\n self.depthImages=[]\n self.zrot=[]\n self.camLoc=[]\n self.gender=[]\n\n\n fp=h5py.File(cfg.pathToSurreal+self.pathPrefix+\"/annot.h5\",\"r\")\n keyps2d=np.array(fp[\"gt2d\"])\n keyps3d=np.array(fp[\"gt3d\"])\n smplShapeParams=np.array(fp[\"shape\"])\n smplPoseParams=np.array(fp[\"pose\"])\n rgbImages=np.array(fp[\"imageNameRGB\"])\n depthImages=np.array(fp[\"imageNameDepth\"])\n camLoc=np.array(fp[\"camLoc\"])\n zRot=np.array(fp[\"zRot\"])\n gender=np.array(fp[\"gender\"])\n nData=min(len(rgbImages),len(depthImages))\n\n for idx in range(1000): #range(nData):\n #idx=3764 #2586 #1987\n currRgbPath=rgbImages[idx]\n currDepthPath=depthImages[idx]\n ret=self.pathFilter(currRgbPath,currDepthPath)\n if ret:\n fullRgbImgPath=cfg.pathToSurreal+self.pathPrefix+currRgbPath\n fullDepthImgPath=cfg.pathToSurreal+self.pathPrefix+currDepthPath\n if (not os.path.isfile(fullRgbImgPath)) or (not os.path.isfile(fullDepthImgPath)):\n continue\n if np.any(keyps2d[:,:,idx]<0):\n continue\n # check if all zero depth, if so remove\n tmp=np.load(fullDepthImgPath)\n loc=tmp!=float(1e10)\n if np.min(tmp)==np.max(tmp):\n continue\n if np.min(tmp[loc])==np.max(tmp[loc]):\n continue\n if gender[idx][0]==1:\n continue\n self.keyps2d.append(keyps2d[:,:,idx])\n self.keyps3d.append(keyps3d[:,:,idx])\n self.smplShapeParams.append(smplShapeParams[idx])\n self.smplPoseParams.append(smplPoseParams[idx])\n self.rgbImages.append(fullRgbImgPath)\n self.depthImages.append(fullDepthImgPath)\n self.zrot.append(zRot[idx,0])\n self.camLoc.append(camLoc[idx,:])\n self.gender.append(gender[idx])\n\n assert(len(self.keyps2d)==len(self.keyps3d)) \n assert(len(self.keyps2d)==len(self.smplShapeParams)) \n assert(len(self.keyps2d)==len(self.smplPoseParams)) \n assert(len(self.keyps2d)==len(self.rgbImages))\n assert(len(self.keyps2d)==len(self.depthImages))\n assert(len(self.keyps2d)==len(self.zrot))\n assert(len(self.keyps2d)==len(self.camLoc))\n assert(len(self.keyps2d)==len(self.gender))\n\n def normalizeDepth(self,depthImg):\n loc=depthImg!=float(1e10)\n normDepth=depthImg\n normDepth[loc]=(depthImg[loc]-np.min(depthImg[loc]))/(np.max(depthImg[loc])-np.min(depthImg[loc]))\n normDepth[~loc]=0\n\n return normDepth\n\n def __len__(self):\n return len(self.rgbImages)\n\n def __getitem__(self,index):\n rgbImg=cv2.imread(self.rgbImages[index])\n keyps2d=self.keyps2d[index].copy()\n \n \"\"\"# plot points on image and save\n imgVis=rgbImg\n for r in range(len(keyps2d[0])):\n currX=int(keyps2d[0][r])\n currY=int(keyps2d[1][r])\n cv2.circle(imgVis,(currX,currY),2,(0,0,255),4)\n cv2.imwrite(\"/mnt/data/tmp/tmp/tmpKeyps1.png\",imgVis)\"\"\"\n\n keyps2d[0]=[x*(1.0*self.cropSize/rgbImg.shape[1]) for x in keyps2d[0]]\n keyps2d[1]=[x*(1.0*self.cropSize/rgbImg.shape[0]) for x in keyps2d[1]]\n keyps2d/=self.cropSize\n keyps2d=np.asarray(keyps2d)\n resImg=cv2.resize(rgbImg,(self.cropSize,self.cropSize),interpolation=cv2.INTER_CUBIC)\n resImg=util.convert_image_by_pixformat_normalize(resImg,self.pixFormat,self.normalize)\n #resImg=rgbImg\n\n depthImg=self.normalizeDepth(np.load(self.depthImages[index]))\n #depthImg=cv2.resize(depthImg,(self.cropSize,self.cropSize),interpolation=cv2.INTER_NEAREST)\n depthImg=cv2.resize(depthImg,(self.cropSize,self.cropSize))\n depthImgCh=np.zeros((3,depthImg.shape[0],depthImg.shape[1]))\n depthImgCh[0,:,:]=depthImg\n depthImgCh[1,:,:]=depthImg\n depthImgCh[2,:,:]=depthImg\n keyps3d=self.keyps3d[index].copy()\n keyps3d=np.asarray(keyps3d)\n keyps3dw=keyps3d.copy()\n\n shape,pose=self.smplShapeParams[index].copy(),self.smplPoseParams[index].copy()\n currCamLoc=self.camLoc[index].copy()\n currExtrinsic,currR,currT=util.getSurrealExtrinsic(np.expand_dims(np.transpose(currCamLoc),axis=1))\n currZRot=self.zrot[index].copy()\n RzBody=np.array(((math.cos(currZRot),-math.sin(currZRot),0),(math.sin(currZRot),math.cos(currZRot),0),(0,0,1))) \n pose[0:3]=util.rotateBodyForVisSurreal(RzBody,pose[0:3]) \n\n ############ swap l/r pose, flip y/z\n pose=self.swapRightLeftPose(pose)\n pose[1]=-pose[1]\n pose[2]=-pose[2]\n ############\n\n theta=np.concatenate((pose,shape),axis=0)\n\n ############ Swap keyps l/r\n keyps2d=self.swapRightLeftJoints(keyps2d)\n keyps3d=self.swapRightLeftJoints(keyps3d) \n keyps3dw=keyps3d.copy()\n ############\n\n if self.cameraSpace:\n # move 3d joints to camera space \n keyps3d=np.concatenate([keyps3d.transpose(),np.ones((keyps3d.shape[1],1))],axis=1).transpose()\n keyps3d=np.dot(currExtrinsic,keyps3d) \n pelvis=keyps3d[:,0].copy() \n keyps3d-=np.expand_dims(pelvis,1)\n\n currGender=self.gender[index].copy()\n currGender=currGender[0]\n\n return {\n \"rgbImage\":torch.from_numpy(resImg).float(),\n \"depthImage\":torch.from_numpy(depthImgCh).float(),\n \"kp_2d\":torch.from_numpy(keyps2d).float(),\n \"kp_3d\":torch.from_numpy(keyps3d).float(),\n \"pelvis\":torch.from_numpy(np.expand_dims(pelvis,1)).float(),\n \"kp_3d_world\":torch.from_numpy(np.asarray(keyps3dw)).float(),\n \"theta\":torch.from_numpy(theta).float(),\n \"zrot\":torch.from_numpy(np.asarray(currZRot)).float(),\n \"camLoc\":torch.from_numpy(np.asarray(currCamLoc)).float(),\n \"extrinsic\":torch.from_numpy(np.asarray(currExtrinsic)).float(),\n \"intrinsic\":torch.from_numpy(np.asarray(cfg.surrealIntrinsic)).float(),\n \"rgbImageName\":self.rgbImages[index],\n \"depthImageName\":self.depthImages[index],\n \"gender\":currGender,\n \"data_set\":\"Surreal\"\n }\n\n\nclass Human36M(Dataset):\n def __init__(self):\n self.onlySinglePerson=False\n self.normalize=True\n self.minPtsRequired=7\n self.scaleRange=[1.05,1.3]\n self.maxIntersectRatio=0.5\n self.cropSize=224\n self.pixFormat=\"NCHW\"\n self.loadData()\n\n def loadData(self):\n self.keyps2d=[]\n self.keyps3d=[]\n self.smplShapeParams=[]\n self.smplPoseParams=[]\n self.images=[]\n self.boxes=[]\n\n fp=h5py.File(os.path.join(cfg.pathToHuman36m,\"data\",\"annot-copy.h5\"),\"r\")\n keyps2d=np.array(fp[\"gt2d\"])\n keyps3d=np.array(fp[\"gt3d\"])\n smplShapeParams=np.array(fp[\"shape\"])\n smplPoseParams=np.array(fp[\"pose\"])\n images=np.array(fp[\"imagename\"])\n\n assert(len(keyps2d)==len(keyps3d)) \n assert(len(keyps2d)==len(smplShapeParams)) \n assert(len(keyps2d)==len(smplPoseParams)) \n assert(len(keyps2d)==len(images))\n\n def isValid(pts):\n r=[]\n for pt in pts:\n if pt[2]!=0:\n r.append(pt)\n return r\n\n for idx in cfg.imgsLoad: #range(cfg.nImgsLoad): #range(len(keyps2d)): \n fullImgPath=os.path.join(cfg.pathToHuman36m,\"data\")+images[idx].decode()\n if not os.path.isfile(fullImgPath):\n continue\n keyp2d=keyps2d[idx].reshape((-1,3))\n if np.sum(keyp2d[:,2])self.maxIntersectRatio:\n return True\n return False\n for key,value in imgsIdInfo.items():\n currPath=value[\"image_path\"]\n currKpsSet=value[\"kps\"]\n currBoxSet=value[\"box\"]\n if len(currBoxSet)>1:\n if self.onlySinglePerson:\n continue\n \n for r in range(len(currBoxSet)):\n currKeyp=currKpsSet[r]\n currBox=currBoxSet[r]\n if np.sum(currKeyp[:,2]) (x['GenomeLength'] / 2),\r\n (x['GenomeLength'] - x['Position']),\r\n x['Position'])\r\n x['PositionNorm'] = x['PositionNorm0']**(1/2)\r\n \r\n # Reference position\r\n n_reads = x['readCount'].max()\r\n start_position_ref = int(1)\r\n end_position_ref = x['GenomeLength'].iloc[0]\r\n end_position_ref = end_position_ref + n_reads\r\n increase_by = (end_position_ref / n_reads)\r\n x['ref_Position'] = list(frange(start_position_ref, end_position_ref,\r\n increase_by))\r\n x['ref_Position'] = x['ref_Position'].astype(int)\r\n x['PositionNorm_ref0'] = np.where(x['ref_Position'] > (x['GenomeLength'] / 2),\r\n (x['GenomeLength'] - x['ref_Position']),\r\n x['ref_Position'])\r\n x['PositionNorm_ref'] = x['PositionNorm_ref0'].astype(int)\r\n return x\r\n\r\n\r\ndef make_time_domain(x):\r\n \"\"\"\r\n Time domain signal\r\n \"\"\"\r\n # check if read count of organism matches with minimum requirement\r\n mean_depth = int(x['Depth'].mean())\r\n n_reads = int(x['readCount'].max())\r\n species_name = x['Organism'].iloc[0]\r\n x['PositionNorm'] = x['PositionNorm'] * x['Depth']\r\n x['PositionNorm_ref'] = x['PositionNorm_ref'] * mean_depth\r\n\r\n reference_combinations_distances_sort = []\r\n real_combinations_distances_sort = []\r\n\r\n # calculate the biological distance\r\n real_read_positions = sorted(x['PositionNorm'])\r\n reference_read_positions = sorted(x['PositionNorm_ref'])\r\n\r\n if n_reads > int(1000):\r\n random.seed(222)\r\n real_select_random = random.sample(real_read_positions, 400)\r\n real_read_combinations_sub = list(itertools.combinations(real_select_random, 2))\r\n real_combinations_distances_sub = [abs(i - j) for i, j in real_read_combinations_sub]\r\n real_combinations_distances_sort_sub = sorted(real_combinations_distances_sub)\r\n real_combinations_distances_sort.append(real_combinations_distances_sort_sub)\r\n\r\n # calculate the reference distance\r\n reference_select_random = random.sample(reference_read_positions, 400)\r\n reference_read_combinations_sub = list(itertools.combinations(reference_select_random, 2))\r\n reference_combinations_distances_sub = [abs(i - j) for i, j in reference_read_combinations_sub]\r\n reference_combinations_distances_sort_sub = sorted(reference_combinations_distances_sub)\r\n reference_combinations_distances_sort.append(reference_combinations_distances_sort_sub)\r\n else:\r\n real_read_combinations = list(itertools.combinations(real_read_positions, 2))\r\n real_combinations_distances = [abs(i - j) for i, j in real_read_combinations]\r\n real_combinations_distances_sort1 = sorted(real_combinations_distances)\r\n real_combinations_distances_sort.append(real_combinations_distances_sort1)\r\n\r\n # calculate the reference distance\r\n reference_read_combinations = list(itertools.combinations(reference_read_positions, 2))\r\n reference_combinations_distances = [abs(i - j) for i, j in reference_read_combinations]\r\n reference_combinations_distances_sort1 = sorted(reference_combinations_distances)\r\n reference_combinations_distances_sort.append(reference_combinations_distances_sort1)\r\n\r\n # create output data frame\r\n df = pd.DataFrame(list(zip(reference_combinations_distances_sort, real_combinations_distances_sort)),\r\n columns=['Reference', 'Real'])\r\n df['Organism'] = species_name\r\n df2 = df.apply(lambda i: i.explode() if i.name in ['Reference', 'Real'] else i)\r\n return df2\r\n\r\n\r\n# frequency domain signal (fds)\r\ndef fourier_trans(x):\r\n species_name = x['Organism'].iloc[0]\r\n\r\n x['fft_ref1'] = np.fft.fft(x['Reference'])\r\n x['fft_bio1'] = np.fft.fft(x['Real'])\r\n\r\n x['fft_ref'] = [complex(np.around(items2.real), np.around(items2.imag)) for items2 in x['fft_ref1']]\r\n x['fft_bio'] = [complex(np.around(items2.real), np.around(items2.imag)) for items2 in x['fft_bio1']]\r\n \r\n x['fft_abs_ref'] = np.abs(x['fft_ref'])\r\n x['fft_abs_bio'] = np.abs(x['fft_bio'])\r\n x['fft_abs_ref_sqrt'] = np.around(x['fft_abs_ref'] / norm_cpm, 2)\r\n x['fft_abs_bio_sqrt'] = np.around(x['fft_abs_bio'] / norm_cpm, 2)\r\n \r\n # Pearson correlation\r\n if (sum(x['fft_abs_ref_sqrt']) > 0) & (sum(x['fft_abs_bio_sqrt']) > 0):\r\n pearson_corr = linregress(x['fft_abs_ref_sqrt'], x['fft_abs_bio_sqrt'])\r\n pearson_standard_error0 = pearson_corr[4]\r\n pearson_corr_r0, pearson_corr_p0 = stats.pearsonr(x['fft_abs_ref_sqrt'], x['fft_abs_bio_sqrt'])\r\n pearson_corr_r = round(pearson_corr_r0, 4)\r\n pearson_corr_p = round(pearson_corr_p0, 10)\r\n euclidean_dist_0 = np.linalg.norm(x['fft_abs_ref_sqrt']-x['fft_abs_bio_sqrt'])\r\n euclidean_dist = round(euclidean_dist_0, 1)\r\n pearson_standard_error = round(pearson_standard_error0, 5)\r\n return species_name, pearson_corr_r, pearson_corr_p, pearson_standard_error, euclidean_dist\r\n else:\r\n pearson_corr_r2 = 0\r\n pearson_corr_p2 = 0\r\n pearson_standard_error2 = 1\r\n euclidean_dist2 = 1\r\n return species_name, pearson_corr_r2, pearson_corr_p2, pearson_standard_error2, euclidean_dist2\r\n\r\n\r\ndef make_freq_images(x):\r\n logging.basicConfig(level=logging.ERROR)\r\n species_name = x['Organism'].iloc[0]\r\n path_real = x['PathName'].iloc[0]\r\n\r\n x['fft_ref1'] = np.fft.fft(x['Reference'])\r\n x['fft_bio1'] = np.fft.fft(x['Real'])\r\n\r\n x['fft_ref'] = [complex(np.around(items2.real), np.around(items2.imag)) for items2 in x['fft_ref1']]\r\n x['fft_bio'] = [complex(np.around(items2.real), np.around(items2.imag)) for items2 in x['fft_bio1']]\r\n\r\n x['fft_abs_ref'] = np.abs(x['fft_ref'])\r\n x['fft_abs_bio'] = np.abs(x['fft_bio'])\r\n x['fft_abs_ref_sqrt'] = np.around(x['fft_abs_ref'] / norm_cpm, 2)\r\n x['fft_abs_bio_sqrt'] = np.around(x['fft_abs_bio'] / norm_cpm, 2)\r\n\r\n # plot frequency signal\r\n val_bio = x['Real']\r\n val_ref = x['Reference']\r\n x_bio0 = x['fft_abs_bio_sqrt']\r\n x_reference0 = x['fft_abs_ref_sqrt']\r\n\r\n x_bio1 = x_bio0.sort_values()\r\n x_bio2 = pd.concat([x_bio1[::2], x_bio1[len(x_bio1)-2:0:-2]])\r\n x_bio = x_bio2.tolist()\r\n x_reference1 = x_reference0.sort_values()\r\n x_reference2 = pd.concat([x_reference1[::2], x_reference1[len(x_reference1)-2:0:-2]])\r\n x_reference = x_reference2.tolist()\r\n freqs_bio0 = fftpack.fftfreq(len(val_bio))\r\n freqs_bio = sorted(freqs_bio0)\r\n\r\n freqs_ref0 = fftpack.fftfreq(len(val_ref))\r\n freqs_ref = sorted(freqs_ref0)\r\n a = (len(freqs_ref) - len(x_reference))\r\n b = (len(freqs_bio) - len(x_bio))\r\n x_reference += [0]*a\r\n x_bio += [0]*b\r\n x_reference3 = np.sqrt(x_reference)\r\n sep = '_'\r\n\r\n fig, ax1 = plt.subplots(1, 1, figsize=(2.5, 2))\r\n ax1.plot(freqs_ref, x_reference3, \"black\", linewidth=1, linestyle='--', label=\"Reference\", alpha=0.4)\r\n ax1.plot(freqs_bio, x_bio, 'blue', linewidth=1, linestyle='--', label=\"Sample\")\r\n ax1.legend(framealpha=1, loc='upper right', fontsize=3)\r\n ax1.fill_between(freqs_ref, x_reference3, x_bio, facecolor='pink', alpha=0.2, interpolate=True)\r\n fig.text(0.5, 0.025, \"Frequency per cycle\", ha='center', va='center', fontsize=4)\r\n fig.text(0.010, 0.5, \"Spectrum\", ha='center', va='center', rotation='vertical', fontsize=4)\r\n plt.xticks(fontsize=3)\r\n plt.yticks(fontsize=3)\r\n outfile = '_'.join([path_real, species_name, 'freq.png'])\r\n plt.savefig(outfile, dpi=600)\r\n logging.basicConfig(level=logging.DEBUG)\r\n logging.info(' File written: {}'.format(outfile))\r\n plt.close()\r\n\r\ndef final_table(x, set_error, set_alpha):\r\n \"\"\"\r\n Create file data table\r\n \"\"\"\r\n a0 = pd.DataFrame(x, columns=['Pearson'])\r\n a = a0.dropna(axis=0, how='all')\r\n a = a[['Species', 'r_value', 'p_value', 'stError', 'euclideanR0']] = pd.DataFrame(a['Pearson'].tolist())\r\n a.columns = ['a', 'b', 'c', 'd', 'e',\r\n 'Species', 'r_value', 'p_value', 'stError', 'euclideanR0']\r\n a.reset_index(drop=True, inplace=True)\r\n a = a.drop(a.columns[[0, 1]], axis=1)\r\n a = a[['Species', 'r_value', 'p_value', 'stError', 'euclideanR0']]\r\n a['euclidean'] = np.around((1 / a['euclideanR0']) * 1000, 3)\r\n a['distribution'] = np.where(\r\n (a['p_value'] < set_alpha) & (a['r_value'] > 0.5) & (a['stError'] < set_error) & (a['euclidean'] < 0.5),\r\n 'uniform', 'nonuniform')\r\n b1 = a[['Species', 'r_value', 'p_value', 'stError', 'euclidean', 'distribution']]\r\n b2 = b1[b1.distribution == 'uniform']\r\n return b2\r\n \r\n\r\ndef process_csv(file_name, out_prefix, args): \r\n with open(file_name, newline='') as inF:\r\n df = pd.read_csv(inF, delimiter=',')\r\n\r\n # filtering human reads\r\n pattern_del = '1_1_1_'\r\n filter_approach = df['Organism'].str.contains(pattern_del, na=False)\r\n df = df[~filter_approach]\r\n logging.info('1) Human reads have been removed')\r\n\r\n # counting reads per organism\r\n df = df.dropna(subset=['GenomeLength'])\r\n df_filter1 = df.groupby('Organism').apply(read_count)\r\n logging.info('2) Continue with the first position of each read')\r\n\r\n if df_filter1.empty is True:\r\n logging.warning('Note: Dataset is empty')\r\n outfile = '{}_filtered.csv'.format(out_prefix)\r\n df_filter1.to_csv(outfile, index=False)\r\n logging.info(' File written: {}'.format(outfile))\r\n return None\r\n else:\r\n df_filter = df_filter1.reset_index(drop=True)\r\n df_filter2 = df_filter.groupby('Organism').apply(normalise_genome_position)\r\n logging.info('3) Genome position normalised')\r\n\r\n position_domain0 = df_filter2.reset_index(drop=True)\r\n position_domain = position_domain0.groupby(\"Organism\").apply(make_time_domain)\r\n logging.info('4) Time-domain signal built')\r\n\r\n frequency_domain0 = position_domain.reset_index(drop=True)\r\n frequency_domain0['PathName'] = os.path.join(out_prefix)\r\n frequency_domain = frequency_domain0.groupby('Organism').apply(fourier_trans)\r\n logging.info('5) Frequency-domain signal generated')\r\n\r\n frequency_domain0.groupby('Organism').apply(make_freq_images)\r\n logging.info('6) Frequency plots produced')\r\n\r\n stat_table = final_table(frequency_domain,\r\n set_error=args.error,\r\n set_alpha=args.alpha)\r\n logging.info('7) Output table has been generated')\r\n\r\n outfile = '{}_final_stats.csv'.format(out_prefix)\r\n stat_table.to_csv(outfile, index=False)\r\n logging.info(' File written: {}'.format(outfile))\r\n logging.info('8) Run successful')\r\n\r\ndef main(args):\r\n \"\"\"\r\n Main interface\r\n \"\"\"\r\n # output directory\r\n outdir = os.path.split(args.out_prefix)[0]\r\n if outdir != '' and not os.path.isdir(outdir):\r\n os.makedirs(args.outdir)\r\n # processing each file\r\n process_csv(args.csv_file, out_prefix=args.out_prefix, args=args)\r\n \r\nif __name__ == \"__main__\":\r\n args = parser.parse_args()\r\n main(args)", "meta": {"hexsha": "435eb2c9f31df71aac5bd8478a6c9605549b7fc9", "size": 14202, "ext": "py", "lang": "Python", "max_stars_repo_path": "raspir_with_customised_refdb/raspir_own_refSeq.py", "max_stars_repo_name": "colindaven/raspir", "max_stars_repo_head_hexsha": "33a1721487a5fa65298f7d6d31d9d97772fa9e68", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7, "max_stars_repo_stars_event_min_datetime": "2020-12-11T12:37:19.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-01T17:22:21.000Z", "max_issues_repo_path": "raspir_with_customised_refdb/raspir_own_refSeq.py", "max_issues_repo_name": "colindaven/raspir", "max_issues_repo_head_hexsha": "33a1721487a5fa65298f7d6d31d9d97772fa9e68", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-12-14T13:39:18.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-02T06:59:34.000Z", "max_forks_repo_path": "raspir_with_customised_refdb/raspir_own_refSeq.py", "max_forks_repo_name": "colindaven/raspir", "max_forks_repo_head_hexsha": "33a1721487a5fa65298f7d6d31d9d97772fa9e68", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-02-26T13:43:20.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-04T06:39:37.000Z", "avg_line_length": 42.0177514793, "max_line_length": 113, "alphanum_fraction": 0.6437121532, "include": true, "reason": "import numpy,from scipy", "num_tokens": 3578, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5312093733737562, "lm_q2_score": 0.36658973632215985, "lm_q1q2_score": 0.19473590411694505}} {"text": "# Copyright 2020 Makani Technologies LLC\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\"\"\"Functions for working with state-space models.\"\"\"\n\n\nimport copy\n\nimport numpy as np\n\n\n# pylint doesn't like capital letters in variable names, in contrast\n# to control systems conventions.\n# pylint: disable=invalid-name\n\n\nclass SignalListInvalidArgumentException(Exception):\n \"\"\"Raised if an invalid argument is passed to a method of SignaList.\"\"\"\n pass\n\n\nclass SignalList(object):\n \"\"\"Representation of a named list of signals.\n\n A signal list consists of a non-repeating ordered set of signal\n names (each representing a scalar valued signal).\n \"\"\"\n\n def __init__(self, names):\n \"\"\"Constructor.\n\n Args:\n names: List of signal names.\n\n Raises:\n SignalListInvalidArgumentException: If there are repeated names.\n \"\"\"\n self.names = copy.copy(names)\n if not all([isinstance(name, str) for name in self.names]):\n raise SignalListInvalidArgumentException('Names must be strings.', names)\n # Test that there are not repeated names.\n if len(self.names) != len(set(self.names)):\n raise SignalListInvalidArgumentException('Repeated signal name.', names)\n self._names_to_indices = {\n name: i for i, name in enumerate(self.names)\n }\n\n def __repr__(self):\n return ', '.join(self.names)\n\n def __getitem__(self, indices):\n \"\"\"Select a subset of an input list.\n\n Args:\n indices: Can be a slice or a list. If a list, may contain\n a mixture of integer entries and string entries.\n\n Raises:\n SignalListInvalidArgumentException: If indices is not a list.\n\n Returns:\n A new signal list consisting of a subset of the existing list\n in the given order (units are tracked appropriately).\n \"\"\"\n if isinstance(indices, slice):\n selection = range(len(self))[indices]\n elif not isinstance(indices, list):\n raise SignalListInvalidArgumentException(indices)\n else:\n selection = copy.copy(indices)\n\n for i in range(len(selection)):\n if isinstance(selection[i], int):\n selection[i] = self.names[selection[i]]\n\n return SignalList(selection)\n\n def __len__(self):\n return len(self.names)\n\n def __add__(self, other):\n return SignalList(self.names + other.names)\n\n def GetIndices(self, names):\n \"\"\"Get the integer indices corresponding to a list of signal names.\"\"\"\n return [self._names_to_indices[name] for name in names]\n\n def AddSuffix(self, suffix):\n return SignalList([name + suffix for name in self.names])\n\n\nclass SystemInvalidArgumentException(Exception):\n \"\"\"Raised if an invalid argument is passed to a method of System.\"\"\"\n pass\n\n\nclass SystemBadDimensionException(Exception):\n \"\"\"Raised if there is a mismatch in dimensions of arguments.\"\"\"\n pass\n\n\nclass SystemSamplePeriodMismatchException(Exception):\n \"\"\"Raised if there is a mismatch in sample periods.\"\"\"\n pass\n\n\nclass SystemBadSamplePeriodException(Exception):\n \"\"\"Raised if an illegal sample period is given.\"\"\"\n pass\n\n\nclass SystemIllPosedException(Exception):\n \"\"\"Raised if an ill-posed feedback loop is closed.\"\"\"\n pass\n\n\nclass System(object):\n \"\"\"Class for representing as state-space model with named inputs.\"\"\"\n\n def __init__(self, A, B, C, D, Ts, state_list, input_list, output_list):\n \"\"\"Constructor for a new system.\n\n If A, B, or C are empty, then all three must be empty and\n the system represents a constant gain matrix determined\n by D.\n\n If A is non-empty and D is empty, then D is taken to be all zeros.\n\n Args:\n A: nx-by-nx matrix.\n B: nx-by-nu matrix.\n C: ny-by-nx matrix.\n D: ny-by-nu matrix.\n Ts: Sample period (zero indicates continuous time models, -1.0\n indicates a DT model with unspecified sample period).\n state_list: SignalList of length nx.\n input_list: SignalList of length nu.\n output_list: SignalList of length ny.\n\n Raises:\n SystemBadSamplePeriodException: If Ts has an invalid value.\n SystemBadDimensionException: If the arguments have inconsistent\n dimensions.\n \"\"\"\n if not state_list:\n state_list = SignalList([])\n if isinstance(state_list, list):\n state_list = SignalList(state_list)\n if isinstance(input_list, list):\n input_list = SignalList(input_list)\n if isinstance(output_list, list):\n output_list = SignalList(output_list)\n if Ts < 0.0 and Ts != -1.0:\n raise SystemBadSamplePeriodException()\n self.Ts = Ts\n\n self._A = np.matrix(A)\n self._B = np.matrix(B)\n self._C = np.matrix(C)\n self._D = np.matrix(D)\n if self._A.size == 0:\n if self._B.size > 0 or self._C.size > 0:\n raise SystemBadDimensionException(A, B, C, D)\n self.nx = 0\n self.ny = self._D.shape[0]\n self.nu = self._D.shape[1]\n self._A = np.matrix(np.zeros((self.nx, self.nx)))\n self._B = np.matrix(np.zeros((self.nx, self.nu)))\n self._C = np.matrix(np.zeros((self.ny, self.nx)))\n else:\n self.nx = self._A.shape[0]\n self.nu = self._B.shape[1]\n self.ny = self._C.shape[0]\n if self._D.size == 0:\n self._D = np.matrix(np.zeros((self.ny, self.nu)))\n\n if (not np.array_equal(self._A.shape, [self.nx, self.nx])\n or not np.array_equal(self._B.shape, [self.nx, self.nu])\n or not np.array_equal(self._C.shape, [self.ny, self.nx])\n or not np.array_equal(self._D.shape, [self.ny, self.nu])):\n raise SystemBadDimensionException(self._A.shape, self._B.shape,\n self._C.shape, self._D.shape)\n\n if not isinstance(state_list, SignalList) or len(state_list) != self.nx:\n raise SystemBadDimensionException('Bad state list.', state_list)\n\n if not isinstance(input_list, SignalList) or len(input_list) != self.nu:\n raise SystemBadDimensionException('Bad input list.', input_list)\n\n if not isinstance(output_list, SignalList) or len(output_list) != self.ny:\n raise SystemBadDimensionException('Bad output list.', output_list)\n\n self.states = state_list\n self.inputs = input_list\n self.outputs = output_list\n\n def __repr__(self):\n return ('%d-by-%d state-space model (Ts = %g) with %d states.' %\n (self.ny, self.nu, self.Ts, self.nx)\n + '\\nInputs: ' + self.inputs.__repr__()\n + '\\nOutputs: ' + self.outputs.__repr__()\n + '\\nA:\\n' + str(self._A) + '\\nB:\\n' + str(self._B)\n + '\\nC:\\n' + str(self._C) + '\\nD:\\n' + str(self._D))\n\n def __getitem__(self, io):\n \"\"\"Construct a new system with a subset of the inputs and outputs.\n\n Args:\n io: A tuple of two lists of strings. The first list selects a subset\n of the outputs of the system, the second selects a subset of the inputs.\n Either can be the trivial slice ':'.\n\n Raises:\n SystemInvalidArgumentException: If an invalid argument is passed.\n\n Returns:\n A new System object with the reduced input and output dimensions.\n \"\"\"\n if not isinstance(io, tuple) or len(io) != 2:\n raise SystemInvalidArgumentException('Index must be a tuple.')\n\n if isinstance(io[1], slice):\n if io[1] != slice(None, None, None):\n raise SystemInvalidArgumentException('Only \":\" slices are allowed.')\n input_names = [self.inputs.names[i] for i in range(self.nu)]\n else:\n input_names = io[1]\n\n if isinstance(io[0], slice):\n if io[0] != slice(None, None, None):\n raise SystemInvalidArgumentException('Only \":\" slices are allowed.')\n output_names = [self.outputs.names[i] for i in range(self.ny)]\n else:\n output_names = io[0]\n\n (inputs, _, B, _) = self._PartitionInputs(self._B, input_names)\n (outputs, _, C, _) = self._PartitionOutputs(self._C, output_names)\n (_, _, D, _) = self._PartitionInputs(self._D, input_names)\n (_, _, D, _) = self._PartitionOutputs(D, output_names)\n\n return System(self._A, B, C, D, self.Ts, self.states, inputs, outputs)\n\n def _PartitionOutputs(self, matrix, output_names):\n \"\"\"Partition the rows of an ny-by-m matrix.\n\n Args:\n matrix: An ny-by-m matrix.\n output_names: Names of the outputs to be included in the first\n part of the partition.\n\n Raises:\n SystemBadDimensionException: If matrix has the wrong number of rows.\n\n Returns:\n A tuple (outputs, other_outputs, output_matrix,\n other_output_matrix). The first two entries are SignalLists\n containing the outputs in output_names and the other outputs.\n The first matrix is the sub-matrix corresponding to the\n output_names and the remaining rows are in other_output_matrix.\n \"\"\"\n if matrix.shape[0] != self.ny:\n raise SystemBadDimensionException(matrix)\n\n outputs = self.outputs[output_names]\n output_indices = self.outputs.GetIndices(output_names)\n other_output_indices = [\n i for i in range(self.ny) if i not in output_indices\n ]\n other_outputs = self.outputs[other_output_indices]\n\n output_matrix = matrix[output_indices, :]\n other_output_matrix = matrix[other_output_indices, :]\n\n return (outputs, other_outputs, output_matrix, other_output_matrix)\n\n def _PartitionInputs(self, matrix, input_names):\n \"\"\"Partition the columns of an m-by-nu matrix.\n\n Args:\n matrix: An m-by-nu matrix.\n input_names: Names of the inputs to be included in the first\n part of the partition.\n\n Raises:\n SystemBadDimensionException: If matrix has the wrong number of columns.\n\n Returns:\n A tuple (inputs, other_inputs, input_matrix,\n other_input_matrix). The first two entries are SignalLists\n containing the inputs in input_names and the other inputs.\n The first matrix is the sub-matrix corresponding to the\n input_names and the remaining rows are in other_input_matrix.\n \"\"\"\n if matrix.shape[1] != self.nu:\n raise SystemBadDimensionException(matrix)\n\n inputs = self.inputs[input_names]\n input_indices = self.inputs.GetIndices(input_names)\n other_input_indices = [\n i for i in range(self.nu) if i not in input_indices\n ]\n other_inputs = self.inputs[other_input_indices]\n\n input_matrix = matrix[:, input_indices]\n other_input_matrix = matrix[:, other_input_indices]\n\n return (inputs, other_inputs, input_matrix, other_input_matrix)\n\n def GetStateSpaceModel(self):\n \"\"\"Return the state-space description of the system.\"\"\"\n return self._A, self._B, self._C, self._D, self.Ts\n\n def ReduceStates(self, state_names):\n \"\"\"Returns a new system model that keeps only a subset of the states.\n\n Args:\n state_names: List of state names to retain.\n\n Returns:\n A new state-space model with only the desired states retained.\n \"\"\"\n state_indices = self.states.GetIndices(state_names)\n states = self.states[state_names]\n\n A = self._A[[[s] for s in state_indices], state_indices]\n B = self._B[[s for s in state_indices], :]\n C = self._C[:, state_indices]\n\n return System(A, B, C, self._D, self.Ts, states, self.inputs, self.outputs)\n", "meta": {"hexsha": "edc64c56b45ba5f3fd26d1d46275cf688dbce62a", "size": 11547, "ext": "py", "lang": "Python", "max_stars_repo_path": "analysis/control/systems.py", "max_stars_repo_name": "leozz37/makani", "max_stars_repo_head_hexsha": "c94d5c2b600b98002f932e80a313a06b9285cc1b", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1178, "max_stars_repo_stars_event_min_datetime": "2020-09-10T17:15:42.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T14:59:35.000Z", "max_issues_repo_path": "analysis/control/systems.py", "max_issues_repo_name": "leozz37/makani", "max_issues_repo_head_hexsha": "c94d5c2b600b98002f932e80a313a06b9285cc1b", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-05-22T05:22:35.000Z", "max_issues_repo_issues_event_max_datetime": "2020-05-22T05:22:35.000Z", "max_forks_repo_path": "analysis/control/systems.py", "max_forks_repo_name": "leozz37/makani", "max_forks_repo_head_hexsha": "c94d5c2b600b98002f932e80a313a06b9285cc1b", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 107, "max_forks_repo_forks_event_min_datetime": "2020-09-10T17:29:30.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-18T09:00:14.000Z", "avg_line_length": 33.862170088, "max_line_length": 80, "alphanum_fraction": 0.6793106435, "include": true, "reason": "import numpy", "num_tokens": 2733, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.531209388216861, "lm_q2_score": 0.36658972248186, "lm_q1q2_score": 0.19473590220617773}} {"text": "import time\nimport os\nimport pickle\n\nimport numpy as np\nimport tensorflow as tf\n\nfrom django.core.management.base import BaseCommand\n\nfrom Key import Key\nfrom plot import plot_direct\n\nfrom cycling.models import id_dict_from_id_list\nfrom machine_learning.DegradationModelBlackbox import DegradationModel\nfrom machine_learning.LossRecordBlackbox import LossRecord\n\n# TODO(sam): For each cell_id, needs a multigrid of (S, V, I, T) (current\n# needs to be adjusted)\n# TODO(sam): Each cycle must have an index mapping to the nearest reference\n# cycle.\n# TODO(sam): to evaluate a cycle, there must be the multigrid, the reference\n# cycle scaled by cycle number, the cell features, pasted together and ran\n# through a neural net.\n\nNEIGH_MIN_CYC = 0\nNEIGH_MAX_CYC = 1\nNEIGH_RATE = 2\nNEIGH_CELL_ID = 3\nNEIGH_ABSOLUTE_CYC = 4\nNEIGH_VALID_CYC = 5\nNEIGH_SIGN_GRID = 6\nNEIGH_VOLTAGE_GRID = 7\nNEIGH_CURRENT_GRID = 8\nNEIGH_TMP_GRID = 9\nNEIGH_ABSOLUTE_REFERENCE = 10\nNEIGH_REFERENCE = 11\n\nNEIGH_TOTAL = 12\n\n\ndef ml_smoothing(options):\n \"\"\"\n The main function to carry out the machine learning training and evaluation\n procedure.\n\n Todo(harvey): Add more description about what this does.\n\n Args:\n options: Dictionary defining various fitting-related arguments.\n\n Returns: None\n \"\"\"\n if len(tf.config.experimental.list_physical_devices(\"GPU\")) == 1:\n strategy = tf.distribute.OneDeviceStrategy(device = \"/gpu:0\")\n elif len(tf.config.experimental.list_physical_devices(\"GPU\")) > 1:\n strategy = tf.distribute.MirroredStrategy()\n else:\n strategy = tf.distribute.OneDeviceStrategy(\"/cpu:0\")\n\n if not os.path.exists(options[Key.PATH_PLOTS]):\n os.makedirs(options[Key.PATH_PLOTS])\n\n with open(\n os.path.join(options[Key.PATH_PLOTS], \"fit_args_log.txt\"), \"w\",\n ) as f:\n my_str = \"\"\n for k in options:\n my_str = \"{} \\n {}: {}\".format(my_str, k, str(options[k]))\n f.write(my_str)\n\n dataset_path = os.path.join(\n options[Key.PATH_DATASET],\n \"dataset_ver_{}.file\".format(options[Key.DATA_VERSION])\n )\n\n dataset_names_path = os.path.join(\n options[Key.PATH_DATASET],\n \"dataset_ver_{}_names.file\".format(options[Key.DATA_VERSION])\n )\n\n if not os.path.exists(dataset_path):\n print(\"Path \\\"\" + dataset_path + \"\\\" does not exist.\")\n return\n\n with open(dataset_path, \"rb\") as f:\n dataset = pickle.load(f)\n\n dataset_names = None\n if os.path.exists(dataset_names_path):\n with open(dataset_names_path, \"rb\") as f:\n dataset_names = pickle.load(f)\n\n cell_ids = list(dataset[Key.ALL_DATA].keys())\n\n if len(options[Key.CELL_IDS]) != 0:\n cell_ids = list(set(cell_ids).intersection(set(options[Key.CELL_IDS])))\n\n if len(cell_ids) == 0:\n print(\"no cell_ids\")\n return\n\n train_and_evaluate(\n initial_processing(\n dataset, dataset_names, cell_ids, options, strategy = strategy,\n ),\n cell_ids,\n options,\n )\n\n\n# TODO(sam): these huge tensors would be much easier to understand with\n# ragged tensors. Right now, I am just flattening everything.\ndef numpy_acc(dict, key, data):\n if key in dict.keys():\n dict[key] = np.concatenate((dict[key], data))\n else:\n dict[key] = data\n\n return dict\n\n\ndef three_level_flatten(iterables):\n for it1 in iterables:\n for it2 in it1:\n for element in it2:\n yield element\n\n\ndef initial_processing(\n dataset: dict, dataset_names, cell_ids, options: dict, strategy,\n) -> dict:\n \"\"\" Handle the initial data processing\n\n Args:\n dataset: Contains the quantities given in the dataset.\n dataset_names: TODO(harvey)\n cell_ids: TODO(harvey)\n options: Parameters used to tune the machine learning fitting process.\n strategy: TODO(harvey)\n\n Returns:\n { Key.STRAT, Key.MODEL, Key.TENSORS, Key.TRAIN_DS, Key.CYC_M,\n Key.CYC_V, Key.OPT, Key.MY_DATA }\n\n \"\"\"\n # TODO (harvey): Cleanup Docstring, maybe put detailed description elsewhere\n # An appropriate place might be in the docstring for\n # classes inside cycling.Key\n\n compiled_data = {}\n number_of_compiled_cycs = 0\n number_of_reference_cycs = 0\n\n dataset[Key.Q_MAX] = 250\n max_cap = dataset[Key.Q_MAX]\n\n keys = [Key.V_GRID, Key.TEMP_GRID, Key.SIGN_GRID]\n for key in keys:\n numpy_acc(compiled_data, key, np.array([dataset[key]]))\n\n dataset[Key.I_GRID] = dataset[Key.I_GRID] - np.log(max_cap)\n # the current grid is adjusted by the max capacity of the cell_id. It is\n # in log space, so I/q becomes log(I) - log(q)\n numpy_acc(compiled_data, Key.I_GRID, np.array([dataset[Key.I_GRID]]))\n\n # TODO (harvey): simplify the following using loops\n # cell ID array\n cell_id_array = np.array(cell_ids)\n # cell ID to positive electrode ID\n cell_id_to_pos_id = {}\n # cell ID to negative electrode ID\n cell_id_to_neg_id = {}\n # cell ID to electrolyte ID\n cell_id_to_lyte_id = {}\n # cell ID to dry cell ID\n cell_id_to_dry_cell_id = {}\n # dry cell ID to meta\n dry_cell_id_to_meta = {}\n # cell ID to latent\n cell_id_to_latent = {}\n\n # electrolyte ID to latent ID weight\n lyte_to_latent = {}\n # electrolyte ID to solvent ID weight\n lyte_to_sol_weight = {}\n # electrolyte ID to salt ID weight\n lyte_to_salt_weight = {}\n # electrolyte ID to additive ID weight\n lyte_to_addi_weight = {}\n\n for cell_id in cell_id_array:\n if cell_id in dataset[Key.CELL_TO_POS].keys():\n cell_id_to_pos_id[cell_id] = dataset[Key.CELL_TO_POS][cell_id]\n if cell_id in dataset[Key.CELL_TO_NEG].keys():\n cell_id_to_neg_id[cell_id] = dataset[Key.CELL_TO_NEG][cell_id]\n if cell_id in dataset[Key.CELL_TO_LYTE].keys():\n cell_id_to_lyte_id[cell_id] = dataset[Key.CELL_TO_LYTE][cell_id]\n if cell_id in dataset[Key.CELL_TO_DRY].keys():\n dry_cell_id = dataset[Key.CELL_TO_DRY][cell_id]\n cell_id_to_dry_cell_id[cell_id] = dry_cell_id\n\n if dry_cell_id in dataset[Key.DRY_TO_META].keys():\n dry_cell_id_to_meta[dry_cell_id]\\\n = dataset[Key.DRY_TO_META][dry_cell_id]\n\n if cell_id in dataset[Key.CELL_TO_LAT].keys():\n cell_id_to_latent[cell_id] = dataset[Key.CELL_TO_LAT][cell_id]\n\n if cell_id_to_latent[cell_id] < 0.5:\n lyte_id = cell_id_to_lyte_id[cell_id]\n if lyte_id in dataset[Key.LYTE_TO_SOL].keys():\n lyte_to_sol_weight[lyte_id] = dataset[Key.LYTE_TO_SOL][lyte_id]\n if lyte_id in dataset[Key.LYTE_TO_SALT].keys():\n lyte_to_salt_weight[lyte_id] = dataset[Key.LYTE_TO_SALT][\n lyte_id]\n if lyte_id in dataset[Key.LYTE_TO_ADD].keys():\n lyte_to_addi_weight[lyte_id] = dataset[Key.LYTE_TO_ADD][lyte_id]\n if lyte_id in dataset[Key.LYTE_TO_LAT].keys():\n lyte_to_latent[lyte_id] = dataset[Key.LYTE_TO_LAT][lyte_id]\n\n mess = [\n [\n [s[0] for s in siw] for siw in lyte_to_sol_weight.values()\n ], [\n [s[0] for s in siw] for siw in lyte_to_salt_weight.values()\n ], [\n [s[0] for s in siw] for siw in lyte_to_addi_weight.values()\n ],\n ]\n\n mol_ids = to_sorted_array(list(three_level_flatten(mess)))\n dry_cell_ids = to_sorted_array(cell_id_to_dry_cell_id.values())\n pos_ids = to_sorted_array(cell_id_to_pos_id.values())\n neg_ids = to_sorted_array(cell_id_to_neg_id.values())\n lyte_id_list = to_sorted_array(cell_id_to_lyte_id.values())\n\n for cell_id_count, cell_id in enumerate(cell_ids):\n\n all_data = dataset[Key.ALL_DATA][cell_id]\n cyc_grp_dict = all_data[Key.CYC_GRP_DICT]\n\n for k_count, k in enumerate(cyc_grp_dict.keys()):\n\n if any([\n abs(cyc_grp_dict[k][Key.I_PREV_END_AVG]) < 1e-5,\n abs(cyc_grp_dict[k][Key.I_CC_AVG]) < 1e-5,\n abs(cyc_grp_dict[k][Key.I_END_AVG]) < 1e-5,\n abs(cyc_grp_dict[k][Key.V_PREV_END_AVG]) < 1e-1,\n abs(cyc_grp_dict[k][Key.V_END_AVG]) < 1e-1,\n ]):\n continue\n\n main_data = cyc_grp_dict[k][Key.MAIN]\n\n # normalize capacity_vector with max_cap\n normalize_keys = [\n Key.Q_CC_VEC, Key.Q_CV_VEC, Key.Q_CC_LAST, Key.Q_CV_LAST,\n Key.I_CV_VEC, Key.I_CC, Key.I_PREV_END,\n ]\n for key in normalize_keys:\n main_data[key] = 1. / max_cap * main_data[key]\n\n normalize_keys = [Key.I_CC_AVG, Key.I_END_AVG, Key.I_PREV_END_AVG]\n for key in normalize_keys:\n cyc_grp_dict[k][key] = 1. / max_cap * cyc_grp_dict[k][key]\n\n # range of cycles which exist for this cycle group\n min_cyc = min(main_data[Key.N])\n max_cyc = max(main_data[Key.N])\n\n \"\"\"\n - now create neighborhoods, which contains the cycles,\n grouped by proximity\n - want to sample neighborhoods equally\n - neighborhoods have a central cycle and a delta on each side\n - to a first approximation, we want a delta_cyc = 300, but we have\n to vary this near the beginning of data and near the end.\n \"\"\"\n number_of_centers = 10\n\n # the centers of neighborhoods we will try to create\n all_neigh_center_cycs = np.linspace(\n min_cyc, max_cyc, number_of_centers,\n )\n delta = (\n 1.2 * (all_neigh_center_cycs[1] - all_neigh_center_cycs[0]) + 10\n )\n # check all tentative neighborhood centers and\n # commit the ones that contain good data to the dataset\n neigh_data = []\n\n valid_cycs = 0\n for cyc in all_neigh_center_cycs:\n # max_cyc and min_cyc are the limits of existing cycles.\n\n below_cyc = cyc - delta\n above_cyc = cyc + delta\n\n # numpy array of True and False; same length as cyc_grp_dict[k]\n # False when cycle_number falls outside out of\n # [below_cyc, above_cyc] interval\n mask = np.logical_and(\n below_cyc <= main_data[Key.N],\n main_data[Key.N] <= above_cyc,\n )\n\n # the indices for the cyc_grp_dict[k] array which correspond\n # to a True mask\n all_valid_indices = np.arange(len(mask))[mask]\n\n # if there are less than 1 valid cycles, skip that neighborhood\n if len(all_valid_indices) == 0:\n continue\n\n \"\"\"\n at this point, we know that this neighborhood\n will be added to the dataset.\n \"\"\"\n\n min_cyc_index = all_valid_indices[0]\n max_cyc_index = all_valid_indices[-1]\n\n valid_cycs += 1\n\n \"\"\"\n this commits the neighborhood to the dataset\n\n - record the info about the center of the neighborhood\n (cycle number, voltage, rate of charge, rate of discharge)\n - record the relative index (within the cycle group)\n of the min cycle, max cycle\n - record a voltage index, and a cycle group index,\n and a cell index\n - record the absolute index into the table of cycles\n (len(cycles_full)).\n - keep a slot empty for later\n\n \"\"\"\n\n neigh_data_i = np.zeros(NEIGH_TOTAL, dtype = np.int32)\n\n neigh_data_i[NEIGH_MIN_CYC] = min_cyc_index\n neigh_data_i[NEIGH_MAX_CYC] = max_cyc_index\n neigh_data_i[NEIGH_RATE] = k_count\n neigh_data_i[NEIGH_CELL_ID] = cell_id_count\n neigh_data_i[NEIGH_ABSOLUTE_CYC] = number_of_compiled_cycs\n # a weight based on prevalence. Set later\n neigh_data_i[NEIGH_VALID_CYC] = 0\n neigh_data_i[NEIGH_SIGN_GRID] = 0\n neigh_data_i[NEIGH_VOLTAGE_GRID] = 0\n neigh_data_i[NEIGH_CURRENT_GRID] = 0\n neigh_data_i[NEIGH_TMP_GRID] = 0\n\n center_cyc = float(cyc)\n reference_cycs = all_data[Key.REF_ALL_MATS][Key.N]\n\n index_of_closest_reference = np.argmin(\n abs(center_cyc - reference_cycs)\n )\n\n neigh_data_i[NEIGH_ABSOLUTE_REFERENCE]\\\n = number_of_reference_cycs\n neigh_data_i[NEIGH_REFERENCE] = index_of_closest_reference\n\n neigh_data.append(neigh_data_i)\n\n if valid_cycs != 0:\n neigh_data = np.array(neigh_data, dtype = np.int32)\n\n # the empty slot becomes the count of added neighborhoods, which\n # are used to counterbalance the bias toward longer cycle life\n neigh_data[:, NEIGH_VALID_CYC] = valid_cycs\n\n numpy_acc(compiled_data, Key.NEIGH_DATA, neigh_data)\n\n number_of_compiled_cycs += len(main_data[Key.N])\n number_of_reference_cycs += len(all_data[Key.REF_ALL_MATS][Key.N])\n\n dict_to_acc = {\n Key.REF_CYC: all_data[Key.REF_ALL_MATS][Key.N],\n Key.COUNT_MATRIX: all_data[Key.REF_ALL_MATS][Key.COUNT_MATRIX],\n Key.CYC: main_data[Key.N],\n Key.V_CC_VEC: main_data[Key.V_CC_VEC],\n Key.Q_CC_VEC: main_data[Key.Q_CC_VEC],\n Key.MASK_CC_VEC: main_data[Key.MASK_CC_VEC],\n Key.I_CV_VEC: main_data[Key.I_CV_VEC],\n Key.Q_CV_VEC: main_data[Key.Q_CV_VEC],\n Key.MASK_CV_VEC: main_data[Key.MASK_CV_VEC],\n Key.I_CC: main_data[Key.I_CC],\n Key.I_PREV_END: main_data[Key.I_PREV_END],\n Key.V_PREV_END: main_data[Key.V_PREV_END],\n Key.V_END: main_data[Key.V_END],\n }\n\n for key in dict_to_acc:\n numpy_acc(compiled_data, key, dict_to_acc[key])\n\n neigh_data = tf.constant(compiled_data[Key.NEIGH_DATA])\n\n compiled_tensors = {}\n # cycles go from 0 to 6000, but nn prefers normally distributed variables\n # so cycle numbers is normalized with mean and variance\n cycle_tensor = tf.constant(compiled_data[Key.CYC])\n cycle_m, cycle_v = tf.nn.moments(cycle_tensor, axes = [0])\n cycle_m = 0. # we shall leave the cycle 0 at 0\n cycle_v = cycle_v.numpy()\n cycle_tensor = (cycle_tensor - cycle_m) / tf.sqrt(cycle_v)\n compiled_tensors[Key.CYC] = cycle_tensor\n\n labels = [\n Key.V_CC_VEC, Key.Q_CC_VEC, Key.MASK_CC_VEC, Key.Q_CV_VEC, Key.I_CV_VEC,\n Key.MASK_CV_VEC, Key.I_CC, Key.I_PREV_END, Key.V_PREV_END, Key.V_END,\n Key.COUNT_MATRIX, Key.SIGN_GRID, Key.V_GRID, Key.I_GRID, Key.TEMP_GRID,\n ]\n for label in labels:\n compiled_tensors[label] = tf.constant(compiled_data[label])\n\n batch_size = options[Key.BATCH]\n\n with strategy.scope():\n train_ds_ = tf.data.Dataset.from_tensor_slices(\n neigh_data\n ).repeat(2).shuffle(100000).batch(batch_size)\n\n train_ds = strategy.experimental_distribute_dataset(train_ds_)\n\n dry_cell_to_dry_cell_name = {}\n pos_to_pos_name = {}\n neg_to_neg_name = {}\n lyte_to_lyte_name = {}\n mol_to_mol_name = {}\n\n if dataset_names is not None:\n pos_to_pos_name = dataset_names[Key.NAME_POS]\n neg_to_neg_name = dataset_names[Key.NAME_NEG]\n lyte_to_lyte_name = dataset_names[Key.NAME_LYTE]\n mol_to_mol_name = dataset_names[Key.NAME_MOL]\n dry_cell_to_dry_cell_name = dataset_names[Key.NAME_DRY]\n\n degradation_model = DegradationModel(\n width = options[Key.WIDTH],\n depth = options[Key.DEPTH],\n cell_dict = id_dict_from_id_list(cell_id_array),\n pos_dict = id_dict_from_id_list(pos_ids),\n neg_dict = id_dict_from_id_list(neg_ids),\n lyte_dict = id_dict_from_id_list(lyte_id_list),\n mol_dict = id_dict_from_id_list(mol_ids),\n dry_cell_dict = id_dict_from_id_list(dry_cell_ids),\n\n cell_to_pos = cell_id_to_pos_id,\n cell_to_neg = cell_id_to_neg_id,\n cell_to_lyte = cell_id_to_lyte_id,\n cell_to_dry_cell = cell_id_to_dry_cell_id,\n dry_cell_to_meta = dry_cell_id_to_meta,\n\n cell_latent_flags = cell_id_to_latent,\n\n lyte_to_solvent = lyte_to_sol_weight,\n lyte_to_salt = lyte_to_salt_weight,\n lyte_to_additive = lyte_to_addi_weight,\n lyte_latent_flags = lyte_to_latent,\n\n names = (\n pos_to_pos_name,\n neg_to_neg_name,\n lyte_to_lyte_name,\n mol_to_mol_name,\n dry_cell_to_dry_cell_name,\n ),\n n_sample = options[Key.N_SAMPLE],\n options = options,\n min_latent = options[Key.MIN_LAT],\n )\n\n optimizer = tf.keras.optimizers.Adam(\n learning_rate = options[Key.LRN_RATE],\n )\n\n return {\n Key.STRAT: strategy,\n Key.MODEL: degradation_model,\n Key.TENSORS: compiled_tensors,\n Key.TRAIN_DS: train_ds,\n Key.CYC_M: cycle_m,\n Key.CYC_V: cycle_v,\n Key.OPT: optimizer,\n Key.DATASET: dataset,\n }\n\n\ndef to_sorted_array(unsorted) -> np.array:\n \"\"\" Remove duplicates from a list or a view object (of a dictionary) and\n turn it into to a sorted array.\n\n Args:\n unsorted: Unsorted list or view object (of a dictionary).\n\n Returns:\n Sorted array of `unsorted`.\n \"\"\"\n return np.array(sorted(list(set(unsorted))))\n\n\ndef train_and_evaluate(\n init_returns: dict, cell_ids: list, options: dict,\n) -> None:\n \"\"\"\n\n Args:\n init_returns: Return value of `initial_processing`.\n cell_ids: Specified cell IDs (identifiers for different cells).\n options:\n \"\"\"\n strategy = init_returns[Key.STRAT]\n\n epochs = 100000\n count = 0\n\n end = time.time()\n\n train_step_params = {\n Key.TENSORS: init_returns[Key.TENSORS],\n Key.OPT: init_returns[Key.OPT],\n Key.MODEL: init_returns[Key.MODEL],\n }\n\n @tf.function\n def dist_train_step(strategy, neigh):\n return strategy.experimental_run_v2(\n lambda neigh: train_step(neigh, train_step_params, options),\n args = (neigh,),\n )\n\n # TODO(harvey, confusion): what is `l`?\n l = None\n loss_record = LossRecord()\n with strategy.scope():\n for epoch in range(epochs):\n sub_count = 0\n for neigh in init_returns[Key.TRAIN_DS]:\n count += 1\n sub_count += 1\n\n l_ = dist_train_step(strategy, neigh)\n if l is None:\n l = l_\n else:\n l += l_\n\n if count != 0:\n if (count % options[Key.PRINT_LOSS]) == 0:\n tot = l / tf.cast(sub_count, dtype = tf.float32)\n l = None\n sub_count = 0\n loss_record.record(count, tot.numpy())\n loss_record.print_recent(options)\n\n plot_params = {\n \"cell_ids\": cell_ids,\n \"count\": count,\n Key.OPTIONS: options,\n }\n\n if (count % options[Key.VIS_FIT]) == 0:\n start = time.time()\n print(\"time to simulate: \", start - end)\n loss_record.plot(count, options)\n plot_direct(\n \"generic_vs_cycle\", plot_params, init_returns,\n )\n plot_direct(\n \"generic_vs_capacity\", plot_params, init_returns,\n )\n\n end = time.time()\n print(\"time to plot: \", end - start)\n print()\n\n if count >= options[Key.STOP]:\n return\n\n\ndef train_step(neigh, params: dict, options: dict):\n \"\"\" One training step.\n\n Args:\n neigh: Neighbourhood.\n params: Contains all necessary parameters.\n options: Options for `ml_smoothing`.\n \"\"\"\n # need to split the range\n batch_size2 = neigh.shape[0]\n\n degradation_model = params[Key.MODEL]\n optimizer = params[Key.OPT]\n compiled_tensors = params[Key.TENSORS]\n\n sign_grid_tensor = compiled_tensors[Key.SIGN_GRID]\n voltage_grid_tensor = compiled_tensors[Key.V_GRID]\n current_grid_tensor = compiled_tensors[Key.I_GRID]\n tmp_grid_tensor = compiled_tensors[Key.TEMP_GRID]\n\n count_matrix_tensor = compiled_tensors[Key.COUNT_MATRIX]\n\n cycle_tensor = compiled_tensors[Key.CYC]\n constant_current_tensor = compiled_tensors[Key.I_CC]\n end_current_prev_tensor = compiled_tensors[Key.I_PREV_END]\n end_voltage_prev_tensor = compiled_tensors[Key.V_PREV_END]\n end_voltage_tensor = compiled_tensors[Key.V_END]\n\n cc_voltage_tensor = compiled_tensors[Key.V_CC_VEC]\n cc_capacity_tensor = compiled_tensors[Key.Q_CC_VEC]\n cc_mask_tensor = compiled_tensors[Key.MASK_CC_VEC]\n cv_capacity_tensor = compiled_tensors[Key.Q_CV_VEC]\n cv_current_tensor = compiled_tensors[Key.I_CV_VEC]\n cv_mask_tensor = compiled_tensors[Key.MASK_CV_VEC]\n\n \"\"\"\n if you have the minimum cycle and maximum cycle for a neighborhood,\n you can sample cycle from this neighborhood by sampling real numbers\n x from [0,1] and computing min_cyc*(1.-x) + max_cyc*x,\n but here this computation is done in index space,\n then cycle numbers and vq curves are gathered\n \"\"\"\n\n cyc_indices_lerp = tf.random.uniform(\n [batch_size2], minval = 0., maxval = 1., dtype = tf.float32,\n )\n cyc_indices = tf.cast(\n (1. - cyc_indices_lerp) * tf.cast(\n neigh[:, NEIGH_MIN_CYC] + neigh[:, NEIGH_ABSOLUTE_CYC],\n tf.float32,\n ) + cyc_indices_lerp * tf.cast(\n neigh[:, NEIGH_MAX_CYC] + neigh[:, NEIGH_ABSOLUTE_CYC],\n tf.float32,\n ),\n tf.int32,\n )\n\n sign_grid = tf.gather(\n sign_grid_tensor, indices = neigh[:, NEIGH_SIGN_GRID], axis = 0,\n )\n sign_grid_dim = sign_grid.shape[1]\n\n voltage_grid = tf.gather(\n voltage_grid_tensor, indices = neigh[:, NEIGH_VOLTAGE_GRID], axis = 0,\n )\n voltage_grid_dim = voltage_grid.shape[1]\n\n current_grid = tf.gather(\n current_grid_tensor, indices = neigh[:, NEIGH_CURRENT_GRID], axis = 0,\n )\n current_grid_dim = current_grid.shape[1]\n\n tmp_grid = tf.gather(\n tmp_grid_tensor, indices = neigh[:, NEIGH_TMP_GRID], axis = 0,\n )\n tmp_grid_dim = tmp_grid.shape[1]\n\n svit_tuple = (\n tf.tile(\n tf.reshape(\n sign_grid, [batch_size2, sign_grid_dim, 1, 1, 1, 1],\n ),\n [1, 1, voltage_grid_dim, current_grid_dim, tmp_grid_dim, 1],\n ),\n tf.tile(\n tf.reshape(\n voltage_grid, [batch_size2, 1, voltage_grid_dim, 1, 1, 1],\n ),\n [1, sign_grid_dim, 1, current_grid_dim, tmp_grid_dim, 1],\n ),\n tf.tile(\n tf.reshape(\n current_grid, [batch_size2, 1, 1, current_grid_dim, 1, 1],\n ),\n [1, sign_grid_dim, voltage_grid_dim, 1, tmp_grid_dim, 1],\n ),\n tf.tile(\n tf.reshape(\n tmp_grid, [batch_size2, 1, 1, 1, tmp_grid_dim, 1],\n ),\n [1, sign_grid_dim, voltage_grid_dim, current_grid_dim, 1, 1],\n ),\n )\n svit_grid = tf.concat(svit_tuple, axis = -1)\n\n count_matrix = tf.reshape(\n tf.gather(\n count_matrix_tensor,\n neigh[:, NEIGH_ABSOLUTE_REFERENCE] + neigh[:, NEIGH_REFERENCE],\n axis = 0,\n ),\n [\n batch_size2, sign_grid_dim, voltage_grid_dim, current_grid_dim,\n tmp_grid_dim, 1,\n ],\n )\n\n cycle = tf.gather(cycle_tensor, indices = cyc_indices, axis = 0)\n constant_current = tf.gather(\n constant_current_tensor, indices = cyc_indices, axis = 0,\n )\n end_current_prev = tf.gather(\n end_current_prev_tensor, indices = cyc_indices, axis = 0,\n )\n end_voltage_prev = tf.gather(\n end_voltage_prev_tensor, indices = cyc_indices, axis = 0,\n )\n end_voltage = tf.gather(\n end_voltage_tensor, indices = cyc_indices, axis = 0,\n )\n\n cc_capacity = tf.gather(cc_capacity_tensor, indices = cyc_indices)\n cc_voltage = tf.gather(cc_voltage_tensor, indices = cyc_indices)\n cc_mask = tf.gather(cc_mask_tensor, indices = cyc_indices)\n cc_mask_2 = tf.tile(\n tf.reshape(\n 1. / tf.cast(neigh[:, NEIGH_VALID_CYC], tf.float32),\n [batch_size2, 1],\n ),\n [1, cc_voltage.shape[1]],\n )\n\n cv_capacity = tf.gather(cv_capacity_tensor, indices = cyc_indices)\n cv_current = tf.gather(cv_current_tensor, indices = cyc_indices)\n cv_mask = tf.gather(cv_mask_tensor, indices = cyc_indices)\n cv_mask_2 = tf.tile(\n tf.reshape(\n 1. / tf.cast(neigh[:, NEIGH_VALID_CYC], tf.float32),\n [batch_size2, 1],\n ),\n [1, cv_current.shape[1]],\n )\n\n cell_indices = neigh[:, NEIGH_CELL_ID]\n\n with tf.GradientTape() as tape:\n train_results = degradation_model(\n {\n Key.CYC: tf.expand_dims(cycle, axis = 1),\n Key.I_CC: tf.expand_dims(constant_current, axis = 1),\n Key.I_PREV_END: tf.expand_dims(end_current_prev, axis = 1),\n Key.V_PREV_END: tf.expand_dims(end_voltage_prev, axis = 1),\n Key.V_END: tf.expand_dims(end_voltage, axis = 1),\n Key.INDICES: cell_indices,\n Key.V_TENSOR: cc_voltage,\n Key.I_TENSOR: cv_current,\n Key.SVIT_GRID: svit_grid,\n Key.COUNT_MATRIX: count_matrix,\n },\n training = True,\n )\n\n pred_cc_capacity = train_results[Key.Pred.I_CC]\n pred_cv_capacity = train_results[Key.Pred.I_CV]\n\n cc_capacity_loss = get_loss(\n cc_capacity, pred_cc_capacity, cc_mask, cc_mask_2,\n )\n cv_capacity_loss = get_loss(\n cv_capacity, pred_cv_capacity, cv_mask, cv_mask_2,\n )\n\n main_losses = (\n options[Key.Coeff.Q_CV] * cv_capacity_loss\n + options[Key.Coeff.Q_CC] * cc_capacity_loss\n )\n loss = main_losses + tf.stop_gradient(main_losses) * (\n options[Key.Coeff.Q] * train_results[Key.Loss.Q]\n + options[Key.Coeff.CELL] * train_results[Key.Loss.CELL]\n )\n\n gradients = tape.gradient(loss, degradation_model.trainable_variables)\n\n gradients_no_nans = [\n tf.where(tf.math.is_nan(x), tf.zeros_like(x), x) for x in gradients\n ]\n\n gradients_norm_clipped, _ = tf.clip_by_global_norm(\n gradients_no_nans, options[Key.GLB_NORM_CLIP],\n )\n\n optimizer.apply_gradients(\n zip(gradients_norm_clipped, degradation_model.trainable_variables)\n )\n\n return tf.stack(\n [\n cc_capacity_loss,\n cv_capacity_loss,\n train_results[Key.Loss.Q],\n train_results[Key.Loss.CELL],\n ],\n )\n\n\ndef get_loss(measured, predicted, mask, mask_2):\n return tf.reduce_mean(\n (1e-10 + mask * mask_2) * tf.square(measured - predicted)\n ) / (1e-10 + tf.reduce_mean(mask * mask_2))\n\n\nclass Command(BaseCommand):\n\n def add_arguments(self, parser):\n\n required_args = [\n Key.PATH_DATASET,\n Key.DATA_VERSION,\n Key.PATH_PLOTS,\n ]\n\n float_args = {\n Key.GLB_NORM_CLIP: 10.,\n\n Key.LRN_RATE: 5e-4,\n Key.MIN_LAT: .05,\n\n Key.COEFF_FEAT_CELL_DER: .001,\n Key.COEFF_FEAT_CELL_DER2: .01,\n\n Key.COEFF_CELL: 1.,\n Key.COEFF_CELL_OUT: .1,\n Key.COEFF_CELL_IN: .1,\n Key.COEFF_CELL_DER: .1,\n Key.COEFF_CELL_EQ: 10.,\n\n Key.COEFF_LYTE: 1.,\n Key.COEFF_LYTE_OUT: .1,\n Key.COEFF_LYTE_IN: .1,\n Key.COEFF_LYTE_DER: .1,\n Key.COEFF_LYTE_EQ: 10.,\n\n Key.COEFF_Q_CV: 1.,\n Key.COEFF_Q_CC: 1.,\n\n Key.COEFF_Q: 1.,\n Key.COEFF_Q_GEQ: 1.,\n Key.COEFF_Q_LEQ: 1.,\n Key.COEFF_Q_V_MONO: .1,\n Key.COEFF_Q_DER3_V: 1.,\n Key.COEFF_Q_DER3_I: 1.,\n Key.COEFF_Q_DER3_N: 1.,\n Key.COEFF_Q_DER_I: 1.,\n Key.COEFF_Q_DER_N: 10.,\n }\n\n vis = 10000\n int_args = {\n Key.N_SAMPLE: 8 * 16,\n\n Key.DEPTH: 3,\n Key.WIDTH: 50,\n Key.BATCH: 4 * 16,\n\n Key.PRINT_LOSS: 500,\n Key.VIS_FIT: vis,\n Key.VIS_VQ: vis,\n\n Key.STOP: 1000004,\n Key.CELL_ID_SHOW: 10,\n }\n\n for arg in required_args:\n parser.add_argument(\"--\" + arg, required = True)\n for arg in float_args:\n parser.add_argument(\n \"--\" + arg, type = float, default = float_args[arg],\n )\n for arg in int_args:\n parser.add_argument(\"--\" + arg, type = int, default = int_args[arg])\n\n cell_ids = [\n 57706, 57707, 57710, 57711, 57714, 57715, 64260, 64268, 83010,\n 83011, 83012, 83013, 83014, 83015, 83016, 81602, 81603, 81604,\n 81605, 81606, 81607, 81608, 81609, 81610, 81611, 81612, 81613,\n 81614, 81615, 81616, 81617, 81618, 81619, 81620, 81621, 81622,\n 81623, 81624, 81625, 81626, 81627, 81712, 81713, 82300, 82301,\n 82302, 82303, 82304, 82305, 82306, 82307, 82308, 82309, 82310,\n 82311, 82406, 82407, 82410, 82411, 82769, 82770, 82771, 82775,\n 82776, 82777, 82779, 82992, 82993, 83083, 83092, 83101, 83106,\n 83107, 83220, 83221, 83222, 83223, 83224, 83225, 83226, 83227,\n 83228, 83229, 83230, 83231, 83232, 83233, 83234, 83235, 83236,\n 83237, 83239, 83240, 83241, 83242, 83243, 83310, 83311, 83312,\n 83317, 83318, 83593, 83594, 83595, 83596, 83741, 83742, 83743,\n 83744, 83745, 83746, 83747, 83748,\n ]\n\n parser.add_argument(\n \"--\" + Key.CELL_IDS, type = int, nargs = \"+\", default = cell_ids,\n )\n\n def handle(self, *args, **options):\n ml_smoothing(options)\n", "meta": {"hexsha": "9068da85e4cd66b7606960779d456c1940c20647", "size": 30903, "ext": "py", "lang": "Python", "max_stars_repo_path": "machine_learning/management/commands/ml_smoothing.py", "max_stars_repo_name": "Samuel-Buteau/universal-battery-database", "max_stars_repo_head_hexsha": "55e64db74eb05cd9f0541a243bb540c0deba7d60", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 33, "max_stars_repo_stars_event_min_datetime": "2020-06-16T16:25:21.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-13T12:38:32.000Z", "max_issues_repo_path": "machine_learning/management/commands/ml_smoothing.py", "max_issues_repo_name": "agafonovslava/universal-battery-database", "max_issues_repo_head_hexsha": "55e64db74eb05cd9f0541a243bb540c0deba7d60", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 66, "max_issues_repo_issues_event_min_datetime": "2020-04-14T17:18:44.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-10T13:46:09.000Z", "max_forks_repo_path": "machine_learning/management/commands/ml_smoothing.py", "max_forks_repo_name": "agafonovslava/universal-battery-database", "max_forks_repo_head_hexsha": "55e64db74eb05cd9f0541a243bb540c0deba7d60", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 10, "max_forks_repo_forks_event_min_datetime": "2020-04-27T01:31:37.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-13T18:04:53.000Z", "avg_line_length": 34.4899553571, "max_line_length": 80, "alphanum_fraction": 0.5942788726, "include": true, "reason": "import numpy", "num_tokens": 7887, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5312093733737563, "lm_q2_score": 0.3665897294020099, "lm_q1q2_score": 0.19473590044089656}} {"text": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n\"\"\"EEG-driven deep learning classifications and model generation\nSoftware tools used generate results in submitted work to (tentative citation pending review):\n\nDavid O. Nahmias, Eugene F. Civillico, and Kimberly L. Kontson. \nDeep Learning and Feature Based Medication Classifications from EEG in a Large Clinical Data Set \nIn review (2020)\n\n\nIf you have found this software useful please consider citing our publication.\n\nPublic domain license\n\"\"\"\n\n\"\"\" Disclaimer:\nThis software and documentation (the \"Software\") were developed at the Food and Drug Administration (FDA) by employees\nof the Federal Government in the course of their official duties. Pursuant to Title 17, Section 105 of the United States Code,\nthis work is not subject to copyright protection and is in the public domain. Permission is hereby granted, free of charge,\nto any person obtaining a copy of the Software, to deal in the Software without restriction, including without limitation\nthe rights to use, copy, modify, merge, publish, distribute, sublicense, or sell copies of the Software or derivatives,\nand to permit persons to whom the Software is furnished to do so. FDA assumes no responsibility whatsoever for use by other\nparties of the Software, its source code, documentation or compiled executables, and makes no guarantees, expressed or implied,\nabout its quality, reliability, or any other characteristic. Further, use of this code in no way implies endorsement by the FDA\nor confers any advantage in regulatory decisions. Although this software can be redistributed and/or modified freely, we ask that\nany derivative works bear some notice that they are derived from it, and any modified versions bear some notice that they have been modified.\n\"\"\"\n\n__author__ = 'David Nahmias'\n__copyright__ = 'No copyright - US Government, 2020 , DeepEEG classification'\n__credits__ = ['David Nahmias']\n__license__ = 'Public domain'\n__version__ = '0.0.1'\n__maintainer__ = 'David Nahmias'\n__email__ = 'david.nahmias@fda.hhs.gov'\n__status__ = 'alpha'\n\nimport logging\nimport time\nfrom copy import copy\nimport sys\n\nfrom collections import Counter\nimport random\nimport numpy as np\nfrom numpy.random import RandomState\nimport resampy\nfrom torch import optim\nimport torch.nn.functional as F\nimport torch as th\nfrom torch.nn.functional import elu\nfrom torch import nn\n\nfrom braindecode.datautil.signal_target import SignalAndTarget\nfrom braindecode.torch_ext.util import np_to_var\nfrom braindecode.torch_ext.util import set_random_seeds\nfrom braindecode.torch_ext.modules import Expression\nfrom braindecode.experiments.experiment import Experiment\nfrom braindecode.datautil.iterators import CropsFromTrialsIterator\nfrom braindecode.experiments.monitors import (RuntimeMonitor, LossMonitor,\n MisclassMonitor)\nfrom braindecode.experiments.stopcriteria import MaxEpochs\nfrom braindecode.models.shallow_fbcsp import ShallowFBCSPNet\nfrom braindecode.models.deep4 import Deep4Net\nfrom braindecode.models.util import to_dense_prediction_model\nfrom braindecode.datautil.iterators import get_balanced_batches\nfrom braindecode.torch_ext.constraints import MaxNormDefaultConstraint\nfrom braindecode.torch_ext.util import var_to_np\nfrom braindecode.torch_ext.functions import identity\n\nfrom dataset import DiagnosisSet\nfrom monitors import compute_preds_per_trial, CroppedDiagnosisMonitor\n\nlog = logging.getLogger(__name__)\nlog.setLevel('DEBUG')\n\nimport pdb\nfrom loadNEDC import loadNEDCdata,loadSubNormData,addDataNoise\n\nif len(sys.argv)>1:\n if ',' in sys.argv[1]:\n CLASSY = sys.argv[1].split(',')\n CLASSY[2] = int(CLASSY[2])\n if len(CLASSY) == 4:\n CLASSY[3] = int(CLASSY[3])\n else:\n CLASSY = str(sys.argv[1])\n\ndef splitDataRandom(allData,allLabels,setNum=0,shuffle=0):\n numberEqSamples = min(Counter(allLabels).values())\n trainSamplesNum = int(np.ceil(numberEqSamples*0.9))\n testSamplesNum = numberEqSamples-trainSamplesNum\n\n labels0 = allLabels[allLabels == 0]\n labels1 = allLabels[allLabels == 1]\n data0 = allData[allLabels == 0]\n data1 = allData[allLabels == 1]\n\n\n fullRange = list(range(numberEqSamples))\n random.shuffle(fullRange)\n\n\n testIndecies = fullRange[trainSamplesNum:]\n trainIndecies = fullRange[:trainSamplesNum]\n\n allDataTrain = np.concatenate((data0[trainIndecies],data1[trainIndecies]),axis=0)\n allLabelsTrain = np.concatenate((labels0[trainIndecies],labels1[trainIndecies]),axis=0)\n\n allDataTest = np.concatenate((data0[testIndecies],data1[testIndecies]),axis=0)\n allLabelsTest = np.concatenate((labels0[testIndecies],labels1[testIndecies]),axis=0)\n\n if shuffle == 1:\n random.shuffle(allLabelsTrain)\n np.save('sessionsData/trainLabels%s-shuffle-sessions'%CLASSY,allLabelsTrain)\n np.save('sessionsData/dataRangeOrder%s-shuffle-sessions'%CLASSY,fullRange)\n else:\n np.save('sessionsData/dataRangeOrder%s-sessions'%CLASSY,fullRange)\n\n\n return allDataTrain,allLabelsTrain,allDataTest,allLabelsTest\n\n\ndef create_set(X, y, inds):\n \"\"\"\n X list and y nparray\n :return: \n \"\"\"\n new_X = []\n for i in inds:\n new_X.append(X[i])\n new_y = y[inds]\n return SignalAndTarget(new_X, new_y)\n\n\nclass TrainValidTestSplitter(object):\n def __init__(self, n_folds, i_test_fold, shuffle):\n self.n_folds = n_folds\n self.i_test_fold = i_test_fold\n self.rng = RandomState(39483948)\n self.shuffle = shuffle\n\n def split(self, X, y,):\n if len(X) < self.n_folds:\n raise ValueError(\"Less Trials: {:d} than folds: {:d}\".format(\n len(X), self.n_folds\n ))\n folds = get_balanced_batches(len(X), self.rng, self.shuffle,\n n_batches=self.n_folds)\n test_inds = folds[self.i_test_fold]\n valid_inds = folds[self.i_test_fold - 1]\n all_inds = list(range(len(X)))\n train_inds = np.setdiff1d(all_inds, np.union1d(test_inds, valid_inds))\n assert np.intersect1d(train_inds, valid_inds).size == 0\n assert np.intersect1d(train_inds, test_inds).size == 0\n assert np.intersect1d(valid_inds, test_inds).size == 0\n assert np.array_equal(np.sort(\n np.union1d(train_inds, np.union1d(valid_inds, test_inds))),\n all_inds)\n\n train_set = create_set(X, y, train_inds)\n valid_set = create_set(X, y, valid_inds)\n test_set = create_set(X, y, test_inds)\n\n return train_set, valid_set, test_set\n\n\nclass TrainValidSplitter(object):\n def __init__(self, n_folds, i_valid_fold, shuffle):\n self.n_folds = n_folds\n self.i_valid_fold = i_valid_fold\n self.rng = RandomState(39483948)\n self.shuffle = shuffle\n\n def split(self, X, y):\n if len(X) < self.n_folds:\n raise ValueError(\"Less Trials: {:d} than folds: {:d}\".format(\n len(X), self.n_folds\n ))\n folds = get_balanced_batches(len(X), self.rng, self.shuffle,\n n_batches=self.n_folds)\n valid_inds = folds[self.i_valid_fold]\n all_inds = list(range(len(X)))\n train_inds = np.setdiff1d(all_inds, valid_inds)\n assert np.intersect1d(train_inds, valid_inds).size == 0\n assert np.array_equal(np.sort(np.union1d(train_inds, valid_inds)),\n all_inds)\n\n train_set = create_set(X, y, train_inds)\n valid_set = create_set(X, y, valid_inds)\n return train_set, valid_set\n\n\ndef run_exp(data_folders,\n n_recordings,\n sensor_types,\n n_chans,\n max_recording_mins,\n sec_to_cut, duration_recording_mins,\n test_recording_mins,\n max_abs_val,\n sampling_freq,\n divisor,\n test_on_eval,\n n_folds, i_test_fold,\n shuffle,\n model_name,\n n_start_chans, n_chan_factor,\n input_time_length, final_conv_length,\n model_constraint,\n init_lr,\n batch_size, max_epochs,cuda,):\n \n import torch.backends.cudnn as cudnn\n cudnn.benchmark = True\n preproc_functions = []\n preproc_functions.append(\n lambda data, fs: (data[:, int(sec_to_cut * fs):-int(\n sec_to_cut * fs)], fs))\n preproc_functions.append(\n lambda data, fs: (data[:, :int(duration_recording_mins * 60 * fs)], fs))\n if max_abs_val is not None:\n preproc_functions.append(lambda data, fs:\n (np.clip(data, -max_abs_val, max_abs_val), fs))\n\n preproc_functions.append(lambda data, fs: (resampy.resample(data, fs,\n sampling_freq,\n axis=1,\n filter='kaiser_fast'),\n sampling_freq))\n\n if divisor is not None:\n preproc_functions.append(lambda data, fs: (data / divisor, fs))\n\n dataset = DiagnosisSet(n_recordings=n_recordings,\n max_recording_mins=max_recording_mins,\n preproc_functions=preproc_functions,\n data_folders=data_folders,\n train_or_eval='train',\n sensor_types=sensor_types)\n if test_on_eval:\n if test_recording_mins is None:\n test_recording_mins = duration_recording_mins\n test_preproc_functions = copy(preproc_functions)\n test_preproc_functions[1] = lambda data, fs: (\n data[:, :int(test_recording_mins * 60 * fs)], fs)\n test_dataset = DiagnosisSet(n_recordings=n_recordings,\n max_recording_mins=None,\n preproc_functions=test_preproc_functions,\n data_folders=data_folders,\n train_or_eval='eval',\n sensor_types=sensor_types)\n #X,y = dataset.load()\n #test_X, test_y = test_dataset.load()\n\n #X,y = loadNEDCdata(mode='train')\n print(CLASSY)\n #X,y,test_X,test_y = loadNEDCdata(mode='all',classy=CLASSY)\n\n data = np.load('sessionsData/data%s-sessions.npy'%CLASSY[:3])\n labels = np.load('sessionsData/labels%s-sessions.npy'%CLASSY[:3])\n\n #pdb.set_trace()\n\n if len(CLASSY) > 3:\n random.seed(11081992 + int(CLASSY[3]))\n else:\n random.seed(11081992)\n\n X,y,test_X,test_y = splitDataRandom(data,labels,shuffle=0)\n\n #X = np.load('trainData%s.npy'%CLASSY)\n #y = np.load('trainLabels%s.npy'%CLASSY)\n #test_X = np.load('testData%s.npy'%CLASSY)\n #test_y = np.load('testLabels%s.npy'%CLASSY)\n\n #return False\n\n #pdb.set_trace()\n\n #X,y,test_X,test_y = loadSubNormData(mode='all')\n\n #X = addDataNoise(X,band=[1,4])\n #test_X = addDataNoise(test_X,band=[1,4])\n #pdb.set_trace()\n\n \n max_shape = np.max([list(x.shape) for x in X],\n axis=0)\n assert max_shape[1] == int(duration_recording_mins *\n sampling_freq * 60)\n if test_on_eval:\n #test_X, test_y = test_dataset.load()\n #test_X, test_y = loadNEDCdata(mode='eval')\n max_shape = np.max([list(x.shape) for x in test_X],\n axis=0)\n assert max_shape[1] == int(test_recording_mins *\n sampling_freq * 60)\n if not test_on_eval:\n splitter = TrainValidTestSplitter(n_folds, i_test_fold,\n shuffle=shuffle)\n train_set, valid_set, test_set = splitter.split(X, y)\n else:\n splitter = TrainValidSplitter(n_folds, i_valid_fold=i_test_fold,\n shuffle=shuffle)\n train_set, valid_set = splitter.split(X, y)\n test_set = SignalAndTarget(test_X, test_y)\n del test_X, test_y\n del X,y # shouldn't be necessary, but just to make sure\n\n #pdb.set_trace()\n\n set_random_seeds(seed=20170629, cuda=cuda)\n n_classes = 2\n if model_name == 'shallow':\n model = ShallowFBCSPNet(in_chans=n_chans, n_classes=n_classes,\n n_filters_time=n_start_chans,\n n_filters_spat=n_start_chans,\n input_time_length=input_time_length,\n final_conv_length=final_conv_length).create_network()\n elif model_name == 'deep':\n model = Deep4Net(n_chans, n_classes,\n n_filters_time=n_start_chans,\n n_filters_spat=n_start_chans,\n input_time_length=input_time_length,\n n_filters_2 = int(n_start_chans * n_chan_factor),\n n_filters_3 = int(n_start_chans * (n_chan_factor ** 2.0)),\n n_filters_4 = int(n_start_chans * (n_chan_factor ** 3.0)),\n final_conv_length=final_conv_length,\n stride_before_pool=True).create_network()\n elif (model_name == 'deep_smac'):\n if model_name == 'deep_smac':\n do_batch_norm = False\n else:\n assert model_name == 'deep_smac_bnorm'\n do_batch_norm = True\n double_time_convs = False\n drop_prob = 0.244445\n filter_length_2 = 12\n filter_length_3 = 14\n filter_length_4 = 12\n filter_time_length = 21\n final_conv_length = 1\n first_nonlin = elu\n first_pool_mode = 'mean'\n first_pool_nonlin = identity\n later_nonlin = elu\n later_pool_mode = 'mean'\n later_pool_nonlin = identity\n n_filters_factor = 1.679066\n n_filters_start = 32\n pool_time_length = 1\n pool_time_stride = 2\n split_first_layer = True\n n_chan_factor = n_filters_factor\n n_start_chans = n_filters_start\n model = Deep4Net(n_chans, n_classes,\n n_filters_time=n_start_chans,\n n_filters_spat=n_start_chans,\n input_time_length=input_time_length,\n n_filters_2=int(n_start_chans * n_chan_factor),\n n_filters_3=int(n_start_chans * (n_chan_factor ** 2.0)),\n n_filters_4=int(n_start_chans * (n_chan_factor ** 3.0)),\n final_conv_length=final_conv_length,\n batch_norm=do_batch_norm,\n double_time_convs=double_time_convs,\n drop_prob=drop_prob,\n filter_length_2=filter_length_2,\n filter_length_3=filter_length_3,\n filter_length_4=filter_length_4,\n filter_time_length=filter_time_length,\n first_nonlin=first_nonlin,\n first_pool_mode=first_pool_mode,\n first_pool_nonlin=first_pool_nonlin,\n later_nonlin=later_nonlin,\n later_pool_mode=later_pool_mode,\n later_pool_nonlin=later_pool_nonlin,\n pool_time_length=pool_time_length,\n pool_time_stride=pool_time_stride,\n split_first_layer=split_first_layer,\n stride_before_pool=True).create_network()\n elif model_name == 'shallow_smac':\n conv_nonlin = identity\n do_batch_norm = True\n drop_prob = 0.328794\n filter_time_length = 56\n final_conv_length = 22\n n_filters_spat = 73\n n_filters_time = 24\n pool_mode = 'max'\n pool_nonlin = identity\n pool_time_length = 84\n pool_time_stride = 3\n split_first_layer = True\n model = ShallowFBCSPNet(in_chans=n_chans, n_classes=n_classes,\n n_filters_time=n_filters_time,\n n_filters_spat=n_filters_spat,\n input_time_length=input_time_length,\n final_conv_length=final_conv_length,\n conv_nonlin=conv_nonlin,\n batch_norm=do_batch_norm,\n drop_prob=drop_prob,\n filter_time_length=filter_time_length,\n pool_mode=pool_mode,\n pool_nonlin=pool_nonlin,\n pool_time_length=pool_time_length,\n pool_time_stride=pool_time_stride,\n split_first_layer=split_first_layer,\n ).create_network()\n elif model_name == 'linear':\n model = nn.Sequential()\n model.add_module(\"conv_classifier\",\n nn.Conv2d(n_chans, n_classes, (600,1)))\n model.add_module('softmax', nn.LogSoftmax(dim=1))\n model.add_module('squeeze', Expression(lambda x: x.squeeze(3)))\n else:\n assert False, \"unknown model name {:s}\".format(model_name)\n to_dense_prediction_model(model)\n log.info(\"Model:\\n{:s}\".format(str(model)))\n if cuda:\n model.cuda()\n # determine output size\n test_input = np_to_var(\n np.ones((2, n_chans, input_time_length, 1), dtype=np.float32))\n if cuda:\n test_input = test_input.cuda()\n log.info(\"In shape: {:s}\".format(str(test_input.cpu().data.numpy().shape)))\n\n out = model(test_input)\n log.info(\"Out shape: {:s}\".format(str(out.cpu().data.numpy().shape)))\n n_preds_per_input = out.cpu().data.numpy().shape[2]\n log.info(\"{:d} predictions per input/trial\".format(n_preds_per_input))\n iterator = CropsFromTrialsIterator(batch_size=batch_size,\n input_time_length=input_time_length,\n n_preds_per_input=n_preds_per_input)\n optimizer = optim.Adam(model.parameters(), lr=init_lr)\n\n loss_function = lambda preds, targets: F.nll_loss(\n th.mean(preds, dim=2, keepdim=False), targets)\n\n if model_constraint is not None:\n assert model_constraint == 'defaultnorm'\n model_constraint = MaxNormDefaultConstraint()\n monitors = [LossMonitor(), MisclassMonitor(col_suffix='sample_misclass'),\n CroppedDiagnosisMonitor(input_time_length, n_preds_per_input),\n RuntimeMonitor(),]\n stop_criterion = MaxEpochs(max_epochs)\n batch_modifier = None\n run_after_early_stop = True\n exp = Experiment(model, train_set, valid_set, test_set, iterator,\n loss_function, optimizer, model_constraint,\n monitors, stop_criterion,\n remember_best_column='valid_misclass',\n run_after_early_stop=run_after_early_stop,\n batch_modifier=batch_modifier,\n cuda=cuda)\n exp.run()\n return exp\n\n\n\nif __name__ == \"__main__\":\n import config\n print('Classifying: {}'.format(CLASSY))\n #pdb.set_trace()\n start_time = time.time()\n logging.basicConfig(format='%(asctime)s %(levelname)s : %(message)s',\n level=logging.DEBUG, stream=sys.stdout)\n exp = run_exp(\n config.data_folders,\n config.n_recordings,\n config.sensor_types,\n config.n_chans,\n config.max_recording_mins,\n config.sec_to_cut, config.duration_recording_mins,\n config.test_recording_mins,\n config.max_abs_val,\n config.sampling_freq,\n config.divisor,\n config.test_on_eval,\n config.n_folds, config.i_test_fold,\n config.shuffle,\n config.model_name,\n config.n_start_chans, config.n_chan_factor,\n config.input_time_length, config.final_conv_length,\n config.model_constraint,\n config.init_lr,\n config.batch_size, config.max_epochs,config.cuda,)\n end_time = time.time()\n run_time = end_time - start_time\n\n log.info(\"Experiment runtime: {:.2f} sec\".format(run_time))\n \n #pdb.set_trace()\n if len(CLASSY) == 3:\n CLASSY[2] = str(CLASSY[2])\n CLASSY = '-'.join(CLASSY)\n elif len(CLASSY) == 4: \n CLASSY[2] = str(CLASSY[2])\n CLASSY[3] = str(CLASSY[3])\n CLASSY = '-'.join(CLASSY)\n\n th.save(exp.model.state_dict(),'sessionsData/'+CLASSY+'Model-sessions.pt')\n #th.save(exp.model.state_dict(),CLASSY+'Model-shuffle.pt')\n\n #savedModel = th.load('subNormModel.pt')\n \n # In case you want to recompute predictions for further analysis:\n exp.model.eval()\n for setname in ('train', 'valid', 'test'):\n log.info(\"Compute predictions for {:s}...\".format(\n setname))\n dataset = exp.datasets[setname]\n if config.cuda:\n preds_per_batch = [var_to_np(exp.model(np_to_var(b[0]).cuda()))\n for b in exp.iterator.get_batches(dataset, shuffle=False)]\n else:\n preds_per_batch = [var_to_np(exp.model(np_to_var(b[0])))\n for b in exp.iterator.get_batches(dataset, shuffle=False)]\n preds_per_trial = compute_preds_per_trial(\n preds_per_batch, dataset,\n input_time_length=exp.iterator.input_time_length,\n n_stride=exp.iterator.n_preds_per_input)\n mean_preds_per_trial = [np.mean(preds, axis=(0, 2)) for preds in\n preds_per_trial]\n mean_preds_per_trial = np.array(mean_preds_per_trial)\n\n", "meta": {"hexsha": "f17def3422ab5d3b4e0ee4883cea9d1218755616", "size": 21462, "ext": "py", "lang": "Python", "max_stars_repo_path": "auto_diagnosis.py", "max_stars_repo_name": "dbp-osel/PEASI", "max_stars_repo_head_hexsha": "11845fbfe235403bae80a4707a5a4460d87ab088", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-06-16T04:18:35.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-22T23:32:18.000Z", "max_issues_repo_path": "auto_diagnosis.py", "max_issues_repo_name": "dbp-osel/easyPEASI", "max_issues_repo_head_hexsha": "11845fbfe235403bae80a4707a5a4460d87ab088", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "auto_diagnosis.py", "max_forks_repo_name": "dbp-osel/easyPEASI", "max_forks_repo_head_hexsha": "11845fbfe235403bae80a4707a5a4460d87ab088", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.5708884688, "max_line_length": 141, "alphanum_fraction": 0.6271549716, "include": true, "reason": "import numpy,from numpy", "num_tokens": 4885, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5312093585306514, "lm_q2_score": 0.36658973632215985, "lm_q1q2_score": 0.1947358986756152}} {"text": "import os\nimport datetime as dt\nfrom collections import OrderedDict\nimport shutil\nfrom copy import copy\n\nimport matplotlib\nimport matplotlib.dates\nimport pylab as plt\nimport numpy as np\nfrom mpl_toolkits.basemap import Basemap\nfrom scipy import stats\nfrom matplotlib_venn import venn2, venn2_circles\n\n\nfrom ..processing.c20data import C20Data\nfrom plotting import lon_convert\nfrom ..results import StormtracksResultsManager\nfrom ..analysis import StormtracksAnalysis, ClassificationAnalysis\nfrom .. import analysis\nfrom ..ibtracsdata import IbtracsData\nimport plotting\nfrom ..load_settings import settings\nfrom ..analysis.classification import SCATTER_ATTRS\nfrom .. import classification\nfrom .. import processing.matching\n\n\ndef load_20th_century():\n cla_analysis = ClassificationAnalysis()\n cal_cd = cla_analysis.load_cal_classification_data()\n val_cd = cla_analysis.load_val_classification_data()\n\n sgdc = classification.SGDClassifier()\n sgdc_best = sgdc.load('sgdc_best')\n sgdc.train(cal_cd, **sgdc_best)\n\n sgdc.predict(cal_cd)\n cal_res = copy(sgdc.res)\n cal_sens, cal_ppv = sgdc.sensitivity, sgdc.ppv\n\n sgdc.predict(val_cd)\n val_sens, val_ppv = sgdc.sensitivity, sgdc.ppv\n val_res = copy(sgdc.res)\n\n sens = (cal_sens + val_sens) / 2\n ppv = (cal_ppv + val_ppv) / 2\n adjustment_ratio_old = ppv / sens\n print('OLD sens: {0}, ppv: {1}, ar: {2}'.format(sens, ppv, adjustment_ratio_old))\n\n tp = cal_res['tp'] + val_res['tp']\n fn = cal_res['fn'] + val_res['fn']\n fp = cal_res['fp'] + val_res['fp']\n sens = 1. * tp / (tp + fn)\n ppv = 1. * tp / (tp + fp)\n adjustment_ratio = ppv / sens\n print('NEW sens: {0}, ppv: {1}, ar: {2}'.format(sens, ppv, adjustment_ratio))\n\n ib_hurrs, ib_pdis, cla_hurrs, cla_pdis = cla_analysis.run_yearly_analysis(sgdc)\n return ib_hurrs, ib_pdis, cla_hurrs, cla_pdis, adjustment_ratio\n\n\ndef load_thresh_metric_vs_vort_lo():\n cla_analysis = ClassificationAnalysis()\n cal_cd = cla_analysis.load_cal_classification_data()\n cc = classification.CutoffClassifier()\n cc_best = cc.load('cc_best')\n print(cc_best)\n\n metrics = []\n for vort_lo in np.arange(0.00001, 0.0005, 0.00001):\n cc_best['vort_lo'] = vort_lo\n print(vort_lo)\n cc.train(cal_cd, **cc_best)\n cc.predict(cal_cd)\n metrics.append((vort_lo, cc.sensitivity, cc.ppv, cc.fpr))\n\n return np.array(metrics)\n\n\ndef load_classifier_metrics():\n cla_analysis = ClassificationAnalysis()\n\n cal_cd, val_cd, clas = cla_analysis.get_trained_classifiers()\n\n metrics = OrderedDict()\n for (cla, settings, fmt, name) in clas:\n metrics[name] = {'fmt': fmt}\n\n cla.predict(cal_cd)\n metrics[name]['cal'] = (cla.sensitivity, cla.ppv, cla.fpr)\n\n cla.predict(val_cd)\n metrics[name]['val'] = (cla.sensitivity, cla.ppv, cla.fpr)\n\n return metrics\n\n\ndef load_ibtracs_info():\n yearly_hurr_distribution, hurr_per_year = analysis.analyse_ibtracs_data(False)\n return yearly_hurr_distribution, hurr_per_year\n\n\ndef plot_20th_century(ib_hurrs, cla_hurrs, adjustment_ratio):\n ar = adjustment_ratio\n fig = plt.figure()\n ax = plt.subplot(211)\n plt.plot(range(1890, 2010), ib_hurrs, 'r-')\n plt.plot(range(1890, 2010), cla_hurrs.mean(axis=1) * ar, 'b--')\n plt.xlim((1890, 2010))\n plt.ylim((0, 350))\n plt.fill_between(range(1890, 2010),\n cla_hurrs.min(axis=1) * ar,\n cla_hurrs.max(axis=1) * ar,\n color=(0, 0, 1, 0.2))\n plt.plot((1914, 1914), (0, 350), 'k--')\n plt.plot((1944, 1944), (0, 350), 'k--')\n plt.plot((1966, 1966), (0, 350), 'k--')\n\n plt.annotate('Panama\\nCanal', xy=(1914, 290), xytext=(1915, 290), fontsize=10)\n plt.annotate('Aircraft\\nRecon.', xy=(1944, 290), xytext=(1945, 290), fontsize=10)\n plt.annotate('Satellite', xy=(1966, 290), xytext=(1967, 290), fontsize=10)\n plt.setp(ax.get_xticklabels(), visible=False)\n\n plt.ylabel('Hurricane-timesteps')\n ax.yaxis.set_label_coords(-0.12, 0.5)\n\n ax = plt.subplot(212)\n plt.plot(range(1890, 2010), np.array(ib_hurrs) - cla_hurrs.mean(axis=1) * ar, 'b-')\n plt.plot((1890, 2010), (0, 0), 'k-')\n\n plt.xlim((1890, 2010))\n ylim = (-150, 200)\n plt.ylim(ylim)\n\n plt.plot((1914, 1914), ylim, 'k--')\n plt.plot((1944, 1944), ylim, 'k--')\n plt.plot((1966, 1966), ylim, 'k--')\n\n yoffset = 60\n plt.annotate('Panama\\nCanal', xy=(1914, ylim[1] - yoffset),\n xytext=(1915, ylim[1] - yoffset), fontsize=10)\n plt.annotate('Aircraft\\nRecon.', xy=(1944, ylim[1] - yoffset),\n xytext=(1945, ylim[1] - yoffset), fontsize=10)\n plt.annotate('Satellite', xy=(1966, ylim[1] - yoffset),\n xytext=(1967, ylim[1] - yoffset), fontsize=10)\n\n plt.ylabel('$\\Delta$ Hurricane-timesteps')\n ax.yaxis.set_label_coords(-0.12, 0.5)\n fig.set_size_inches(6.3, 6)\n _save_figure('20th_century_hurricane_timesteps.png')\n\n\ndef plot_poster_20th_century(ib_hurrs, cla_hurrs, adjustment_ratio):\n ar = adjustment_ratio\n fig = plt.figure()\n ax = plt.subplot(211)\n plt.plot(range(1890, 2010), ib_hurrs, 'r-')\n plt.plot(range(1890, 2010), cla_hurrs.mean(axis=1) * ar, 'b--')\n plt.xlim((1890, 2010))\n plt.ylim((0, 350))\n plt.fill_between(range(1890, 2010),\n cla_hurrs.min(axis=1) * ar,\n cla_hurrs.max(axis=1) * ar,\n color=(0, 0, 1, 0.2))\n plt.plot((1914, 1914), (0, 350), 'k--')\n plt.plot((1944, 1944), (0, 350), 'k--')\n plt.plot((1966, 1966), (0, 350), 'k--')\n\n plt.annotate('Panama\\nCanal', xy=(1914, 290), xytext=(1915, 290), fontsize=10)\n plt.annotate('Aircraft\\nRecon.', xy=(1944, 290), xytext=(1945, 290), fontsize=10)\n plt.annotate('Satellite', xy=(1966, 290), xytext=(1967, 290), fontsize=10)\n plt.setp(ax.get_xticklabels(), visible=False)\n\n plt.ylabel('Hurricane-timesteps', fontsize=16)\n ax.yaxis.set_label_coords(-0.12, 0.5)\n\n ax = plt.subplot(212)\n plt.plot(range(1890, 2010), np.array(ib_hurrs) - cla_hurrs.mean(axis=1) * ar, 'b-')\n plt.plot((1890, 2010), (0, 0), 'k-')\n\n plt.xlim((1890, 2010))\n ylim = (-150, 200)\n plt.ylim(ylim)\n\n plt.plot((1914, 1914), ylim, 'k--')\n plt.plot((1944, 1944), ylim, 'k--')\n plt.plot((1966, 1966), ylim, 'k--')\n\n yoffset = 60\n plt.annotate('Panama\\nCanal', xy=(1914, ylim[1] - yoffset),\n xytext=(1915, ylim[1] - yoffset), fontsize=10)\n plt.annotate('Aircraft\\nRecon.', xy=(1944, ylim[1] - yoffset),\n xytext=(1945, ylim[1] - yoffset), fontsize=10)\n plt.annotate('Satellite', xy=(1966, ylim[1] - yoffset),\n xytext=(1967, ylim[1] - yoffset), fontsize=10)\n\n plt.ylabel('$\\Delta$ Hurricane-timesteps', fontsize=16)\n ax.yaxis.set_label_coords(-0.12, 0.5)\n fig.set_size_inches(6.3, 6)\n _save_figure('20th_century_hurricane_timesteps_poster.png')\n\n\ndef plot_poster_20th_century_trends(ib_hurrs, cla_hurrs, adjustment_ratio):\n ar = adjustment_ratio\n fig = plt.figure()\n ax = plt.subplot(211)\n plt.plot(range(1890, 2010), ib_hurrs, 'r-')\n plt.xlim((1890, 2010))\n plt.ylim((0, 350))\n plt.plot((1914, 1914), (0, 350), 'k--')\n plt.plot((1944, 1944), (0, 350), 'k--')\n plt.plot((1966, 1966), (0, 350), 'k--')\n\n plt.annotate('Panama\\nCanal', xy=(1914, 290), xytext=(1915, 290), fontsize=10)\n plt.annotate('Aircraft\\nRecon.', xy=(1944, 290), xytext=(1945, 290), fontsize=10)\n plt.annotate('Satellite', xy=(1966, 290), xytext=(1967, 290), fontsize=10)\n plt.setp(ax.get_xticklabels(), visible=False)\n\n plt.ylabel('Hurricane-timesteps', fontsize=16)\n ax.yaxis.set_label_coords(-0.12, 0.5)\n\n ax = plt.subplot(212)\n plt.plot(range(1890, 2010), cla_hurrs.mean(axis=1) * ar, 'b-')\n plt.xlim((1890, 2010))\n ylim = (0, 350)\n plt.ylim(ylim)\n\n plt.plot((1914, 1914), ylim, 'k--')\n plt.plot((1944, 1944), ylim, 'k--')\n plt.plot((1966, 1966), ylim, 'k--')\n\n yoffset = 60\n plt.annotate('Panama\\nCanal', xy=(1914, ylim[1] - yoffset),\n xytext=(1915, ylim[1] - yoffset), fontsize=10)\n plt.annotate('Aircraft\\nRecon.', xy=(1944, ylim[1] - yoffset),\n xytext=(1945, ylim[1] - yoffset), fontsize=10)\n plt.annotate('Satellite', xy=(1966, ylim[1] - yoffset),\n xytext=(1967, ylim[1] - yoffset), fontsize=10)\n\n ar = adjustment_ratio\n\n for i, name, sl in ((1, 'pre-Panama Canal', slice(0, 24)),\n (2, 'Panama Canal', slice(24, 54)),\n (3, 'Aircraft', slice(54, 76)),\n (4, 'Satellite', slice(76, 120))):\n corr_ib = stats.linregress(range(sl.stop - sl.start), ib_hurrs[sl] * ar)\n corr_c2 = stats.linregress(range(sl.stop - sl.start), cla_hurrs.mean(axis=1)[sl] * ar)\n plt.subplot(211)\n if corr_ib[3] < 0.05:\n fmt = 'r-'\n else:\n fmt = 'r--'\n\n plt.plot((sl.start + 1890, sl.stop + 1890),\n (corr_ib[1], (sl.stop - sl.start) * corr_ib[0] + corr_ib[1]), fmt)\n plt.subplot(212)\n if corr_c2[3] < 0.05:\n fmt = 'b-'\n else:\n fmt = 'b--'\n plt.plot((sl.start + 1890, sl.stop + 1890),\n (corr_c2[1], (sl.stop - sl.start) * corr_c2[0] + corr_c2[1]), fmt)\n\n latex = False\n if not latex:\n print(name)\n print('IB: gradient: {0}, inter: {1}, r2: {2}, p: {3}'.format(corr_ib[0],\n corr_ib[1],\n corr_ib[2] ** 2,\n corr_ib[3]))\n print('C2: gradient: {0}, inter: {1}, r2: {2}, p: {3}'.format(corr_c2[0],\n corr_c2[1],\n corr_c2[2] ** 2,\n corr_c2[3]))\n else:\n print('{0} & {1:.2f} & {2:.3f} & {3:.2f} & {4:.3f} \\\\\\\\'.format(name,\n corr_ib[0],\n corr_ib[3],\n corr_c2[0],\n corr_c2[3]))\n plt.ylabel('Hurricane-timesteps', fontsize=16)\n ax.yaxis.set_label_coords(-0.12, 0.5)\n\n fig.set_size_inches(6.3, 6)\n _save_figure('20th_century_trends.png')\n\n\ndef print_20th_century_trends(ib_hurrs, cla_hurrs, adjustment_ratio, latex=True):\n ar = adjustment_ratio\n for i, name, sl in ((1, 'pre-Panama Canal', slice(0, 24)),\n (2, 'Panama Canal', slice(24, 54)),\n (3, 'Aircraft', slice(54, 76)),\n (4, 'Satellite', slice(76, 120))):\n corr_ib = stats.linregress(range(sl.stop - sl.start), ib_hurrs[sl] * ar)\n corr_c2 = stats.linregress(range(sl.stop - sl.start), cla_hurrs.mean(axis=1)[sl] * ar)\n if not latex:\n print(name)\n print('IB: gradient: {0}, inter: {1}, r2: {2}, p: {3}'.format(corr_ib[0],\n corr_ib[1],\n corr_ib[2] ** 2,\n corr_ib[3]))\n print('C2: gradient: {0}, inter: {1}, r2: {2}, p: {3}'.format(corr_c2[0],\n corr_c2[1],\n corr_c2[2] ** 2,\n corr_c2[3]))\n else:\n print('{0} & {1:.2f} & {2:.3f} & {3:.2f} & {4:.3f} \\\\\\\\'.format(name,\n corr_ib[0],\n corr_ib[3],\n corr_c2[0],\n corr_c2[3]))\n\n\ndef plot_20th_century_corr(ib_hurrs, cla_hurrs, adjustment_ratio):\n ar = adjustment_ratio\n fig = plt.figure()\n plt.subplot(121)\n plt.plot(ib_hurrs, cla_hurrs.mean(axis=1) * ar, 'k+')\n corr = stats.linregress(ib_hurrs, cla_hurrs.mean(axis=1) * ar)\n print(corr)\n label = 'grad.: {0:.2f}\\nintercept: {1:.2f}\\nr$^2$: {2:.2f}'.format(corr[0], corr[1],\n corr[2] ** 2)\n plt.plot((0, 300), (corr[0] * 0 + corr[1], corr[0] * 300 + corr[1]), 'k--', label=label)\n plt.xlim((0, 300))\n plt.ylim((0, 300))\n plt.legend(bbox_to_anchor=(0.75, 1.1), numpoints=1, prop={'size': 10})\n\n plt.xlabel('IBTrACS Hurricane-timesteps')\n plt.ylabel('Estimated Hurricane-timesteps')\n # fig.set_size_inches(4, 4)\n\n ax = plt.subplot(122)\n for label, sl, c, fmt in (('pre-1944', slice(0, 54), 'r', '+'),\n ('post-1944', slice(54, 120), 'b', 'x')):\n plt.plot(ib_hurrs[sl], cla_hurrs.mean(axis=1)[sl] * ar, '{0}{1}'.format(c, fmt),\n label=label)\n corr = stats.linregress(ib_hurrs[sl], cla_hurrs.mean(axis=1)[sl] * ar)\n print(corr)\n # label = 'grad.: {0:.2f}\\nintercept: {1:.2f}\\nr$^2$: {2:.2f}'.format(corr[0],\n # corr[1], corr[2] ** 2)\n plt.plot((0, 300), (corr[0] * 0 + corr[1], corr[0] * 300 + corr[1]), '{0}--'.format(c))\n\n plt.setp(ax.get_yticklabels(), visible=False)\n plt.xlim((0, 300))\n plt.ylim((0, 300))\n plt.legend(bbox_to_anchor=(0.60, 1.1), numpoints=1, prop={'size': 10})\n\n plt.xlabel('IBTrACS Hurricane-timesteps')\n # plt.ylabel('Estimated Hurricane timesteps')\n fig.set_size_inches(6.3, 3)\n _save_figure('20th_century_corr.png')\n\n fig = plt.figure()\n\n for i, label, sl, c, fmt, bbox in ((1, 'pre-Panama', slice(0, 24), 'r', '+', (0.97, 0.35)),\n (2, 'Panama', slice(24, 54), 'b', 'x', (0.97, 0.35)),\n (3, 'aircraft', slice(54, 76), 'g', '^', (0.65, 1.1)),\n (4, 'satellite', slice(76, 120), 'c', 'o', (0.71, 1.1))):\n ax = plt.subplot(2, 2, i)\n plt.plot(ib_hurrs[sl], cla_hurrs.mean(axis=1)[sl] * ar, '{0}{1}'.format(c, fmt),\n label=label)\n corr = stats.linregress(ib_hurrs[sl], cla_hurrs.mean(axis=1)[sl] * ar)\n print(label)\n print(corr[2] ** 2)\n label = 'grad.: {0:.2f}\\ninter.: {1:.2f}'.format(corr[0], corr[1])\n plt.plot((0, 300), (corr[0] * 0 + corr[1], corr[0] * 300 + corr[1]), '{0}--'.format(c),\n label=label)\n\n if i in (1, 2):\n plt.setp(ax.get_xticklabels(), visible=False)\n else:\n plt.xlabel('IBTrACS Hurricane-timesteps')\n\n if i in (1, 3):\n plt.ylabel('Estimated Hurricane-timesteps')\n else:\n plt.setp(ax.get_yticklabels(), visible=False)\n\n plt.xlim((0, 300))\n plt.ylim((0, 300))\n\n plt.legend(bbox_to_anchor=bbox, numpoints=1, prop={'size': 10})\n\n # plt.xlabel('IBTrACS Hurricane timesteps')\n # plt.ylabel('Estimated Hurricane timesteps')\n fig.set_size_inches(6.3, 6.3)\n _save_figure('20th_century_corr_split.png')\n\n\ndef plot_galveston():\n c20data = C20Data(1900, fields=['prmsl', 'u', 'v'])\n c20data.set_date(dt.datetime(1900, 9, 7, 18, 0))\n loc = {'llcrnrlat': 15, 'urcrnrlat': 35, 'llcrnrlon': -100, 'urcrnrlon': -70}\n\n fig = plt.figure()\n plt.subplot(121)\n m = _raster_on_earth(c20data.lons, c20data.lats, c20data.vort * 10000, loc=loc, colorbar=None)\n m.colorbar(location='bottom', pad='7%', ticks=(-1, 0, 1, 2))\n plt.xlabel('Vorticity ($10^{-4}$ s$^{-1}$)', labelpad=30)\n plt.subplot(122)\n m = _raster_on_earth(c20data.lons, c20data.lats, c20data.prmsl / 100, loc=loc, colorbar=None)\n m.colorbar(location='bottom', pad='7%', ticks=(970, 1000, 1030))\n plt.xlabel('Pressure (hPa)', labelpad=30)\n\n fig.set_size_inches(6.3, 3)\n _save_figure('galveston_1900-9-7_18-00_em0.png')\n\n\ndef plot_venn():\n fig = plt.figure()\n plt.clf()\n fig.set_size_inches(6, 5)\n\n v = venn2(subsets=(5, 6, 7), set_labels=('', ''))\n v.get_label_by_id('10').set_text('False\\nPositives')\n v.get_label_by_id('01').set_text('False\\nNegatives')\n v.get_label_by_id('11').set_text('True\\nPositives')\n c = venn2_circles(subsets=(5, 6, 7), linestyle='dashed')\n c[0].set_lw(1.0)\n c[0].set_ls('dotted')\n\n plt.annotate('True Negatives', xy=np.array([0, 0]),\n xytext=(0, -140),\n ha='center', textcoords='offset points')\n _save_figure('tf_np_venn.png')\n\n\ndef plot_thresh_metric_vs_vort_lo(metrics):\n fig = plt.figure()\n ax = plt.subplot(211)\n plt.plot(metrics[:40, 0] * 10000, metrics[:40, 1] + metrics[:40, 2], 'k-', label='Sum')\n plt.legend(loc='best', prop={'size': 10})\n plt.setp(ax.get_xticklabels(), visible=False)\n plt.ylim((1, 1.4))\n ax.set_yticks((1, 1.1, 1.2, 1.3, 1.4))\n\n plt.subplot(212)\n plt.plot(metrics[:40, 0] * 10000, metrics[:40, 1], 'b--', label='sensitivity')\n plt.plot(metrics[:40, 0] * 10000, metrics[:40, 2], 'g--', label='PPV')\n plt.legend(loc='best', prop={'size': 10})\n plt.xlabel('Vorticity threshold ($10^{-4}$ s$^{-1}$)')\n\n fig.set_size_inches(6.3, 4)\n\n _save_figure('threshold_sens_ppv_vort.png')\n\n\ndef plot_classifer_metrics(metrics):\n plt.figure()\n\n for name in metrics:\n metric = metrics[name]\n fmt = metric['fmt']\n plt.subplot(2, 2, 1)\n plt.plot(metric['cal'][1], metric['cal'][0], fmt, label=name)\n\n plt.subplot(2, 2, 2)\n plt.plot(metric['cal'][2], metric['cal'][0], fmt, label=name)\n\n plt.subplot(2, 2, 3)\n plt.plot(metric['val'][1], metric['cal'][0], fmt, label=name)\n\n plt.subplot(2, 2, 4)\n plt.plot(metric['val'][2], metric['cal'][0], fmt, label=name)\n\n plt.subplot(2, 2, 1)\n # plt.xlabel('PPV')\n plt.ylabel('Calibration\\nsensitivity')\n plt.xlim((0, 1))\n plt.ylim((0, 1))\n\n plt.subplot(2, 2, 2)\n # plt.xlabel('FPR')\n # plt.ylabel('sensitivity')\n plt.xlim((0, 0.1))\n plt.ylim((0, 1))\n plt.legend(bbox_to_anchor=(1.1, 1.1), numpoints=1)\n\n plt.subplot(2, 2, 3)\n plt.xlabel('PPV')\n plt.ylabel('Validation\\nsensitivity')\n plt.xlim((0, 1))\n plt.ylim((0, 1))\n\n plt.subplot(2, 2, 4)\n plt.xlabel('FPR')\n # plt.ylabel('sensitivity')\n plt.xlim((0, 0.1))\n plt.ylim((0, 1))\n\n _save_figure('ppv_and_fpr_vs_sens.png')\n return metrics\n\n\ndef plot_wld(stormtracks_analysis=None, years=None):\n if not stormtracks_analysis:\n stormtracks_analysis = StormtracksAnalysis(2000)\n\n if not years:\n years = range(2000, 2010)\n\n wlds = {}\n wlds['draws'] = []\n\n for year in years:\n print(year)\n stormtracks_analysis.set_year(year)\n k0, w0, k1, w1, d = stormtracks_analysis.run_wld_analysis(active_configs={'scale': 3})\n\n if k0 not in wlds:\n wlds[k0] = []\n wlds[k0].append(w0)\n\n if k1 not in wlds:\n wlds[k1] = []\n wlds[k1].append(w1)\n\n wlds['draws'].append(d)\n\n print(wlds)\n\n plt.figure()\n plt.title('wld')\n for k in wlds:\n plt.plot(years, wlds[k], label=k)\n plt.legend(loc='best')\n\n\ndef plot_tracking_stats(stormtracks_analysis=None, years=None, sort_col='cumoveroverlap'):\n if not stormtracks_analysis:\n stormtracks_analysis = StormtracksAnalysis(2000)\n\n k995 = []\n for scale in (1, 2, 3):\n config = {'pressure_level': 995, 'scale': scale, 'tracker': 'nearest_neighbour'}\n k995.append(stormtracks_analysis.good_matches_key(config))\n\n keys = ('pl995', 'pl850', 'scale3')\n\n config_keys = {}\n for key in keys:\n config_keys[key] = []\n\n for scale in (1, 2, 3):\n config = {'pressure_level': 995, 'scale': scale, 'tracker': 'nearest_neighbour'}\n config_keys['pl995'].append(stormtracks_analysis.good_matches_key(config))\n\n config = {'pressure_level': 850, 'scale': scale, 'tracker': 'nearest_neighbour'}\n config_keys['pl850'].append(stormtracks_analysis.good_matches_key(config))\n\n for pl in (995, 850):\n config = {'pressure_level': pl, 'scale': 3, 'tracker': 'nearest_neighbour'}\n config_keys['scale3'].append(stormtracks_analysis.good_matches_key(config))\n\n all_wins = {}\n for key in keys:\n all_wins[key] = []\n\n if not years:\n years = range(2000, 2010)\n\n for year in years:\n print(year)\n stormtracks_analysis.set_year(year)\n\n res = {}\n res['pl995'] =\\\n stormtracks_analysis.run_position_analysis(sort_on=sort_col,\n active_configs={'pressure_level': 995})\n res['pl850'] =\\\n stormtracks_analysis.run_position_analysis(sort_on=sort_col,\n active_configs={'pressure_level': 850})\n res['scale3'] =\\\n stormtracks_analysis.run_position_analysis(sort_on=sort_col,\n active_configs={'scale': 3})\n\n for key in keys:\n print(key)\n wins = []\n for config_key in config_keys[key]:\n print(' {0}'.format(config_key))\n try:\n wins.append(res[key][config_key][0])\n except KeyError:\n wins.append(0)\n\n all_wins[key].append(wins)\n\n for key in keys:\n all_wins[key] = np.array(all_wins[key])\n\n _plot_all_wins(years, all_wins)\n return years, all_wins\n\n\ndef _plot_all_wins(years, all_wins):\n fmt = matplotlib.ticker.ScalarFormatter(useOffset=False)\n fig = plt.figure()\n fmt.set_scientific(False)\n ax = plt.subplot(311)\n plt.title('Near Surface Pressure Level (NSPL)')\n plt.plot(years, all_wins['pl995'][:, 0], 'r-', label='Scale 1') # scale 1\n plt.plot(years, all_wins['pl995'][:, 1], 'g-', label='Scale 2') # scale 2\n plt.plot(years, all_wins['pl995'][:, 2], 'b-', label='Scale 3') # scale 3\n plt.ylim(0, 60)\n plt.setp(ax.get_xticklabels(), visible=False)\n plt.legend(bbox_to_anchor=(1.1, 1.14), numpoints=1, prop={'size': 10})\n ax.xaxis.set_major_formatter(fmt)\n\n ax = plt.subplot(312)\n plt.title('850 hPa Pressure Level')\n plt.plot(years, all_wins['pl850'][:, 0], 'r--', label='Scale 1') # scale 1\n plt.plot(years, all_wins['pl850'][:, 1], 'g--', label='Scale 2') # scale 2\n plt.plot(years, all_wins['pl850'][:, 2], 'b--', label='Scale 3') # scale 3\n plt.ylim(0, 60)\n plt.setp(ax.get_xticklabels(), visible=False)\n plt.legend(bbox_to_anchor=(1.1, 1.14), numpoints=1, prop={'size': 10})\n ax.xaxis.set_major_formatter(fmt)\n\n ax = plt.subplot(313)\n plt.title('Scale 3')\n plt.plot(years, all_wins['scale3'][:, 0], 'b-', label='NSPL') # pl 995\n plt.plot(years, all_wins['scale3'][:, 1], 'b--', label='850 hPa') # pl 850\n plt.ylim(0, 60)\n plt.legend(bbox_to_anchor=(1.1, 1.14), numpoints=1, prop={'size': 10})\n ax.xaxis.set_major_formatter(fmt)\n\n fig.set_size_inches(6.3, 6)\n _save_figure('tracking_wins_losses.png')\n\n\ndef plot_poster_katrina():\n loc = {'llcrnrlat': 15, 'urcrnrlat': 35, 'llcrnrlon': -100, 'urcrnrlon': -70}\n fig = plt.figure(1)\n plt.clf()\n c20data = C20Data(2005, fields=['u', 'v'])\n c20data.set_date(dt.datetime(2005, 8, 27, 18))\n\n m = _raster_on_earth(c20data.lons, c20data.lats, c20data.vort * 10000, loc=loc, colorbar=False)\n fig.set_size_inches(6.4, 3)\n _save_figure('katrina.png')\n\n\ndef plot_poster_2005_best_tracks():\n loc = {'llcrnrlat': 10, 'urcrnrlat': 60, 'llcrnrlon': -100, 'urcrnrlon': -20}\n fig = plt.figure(2)\n plt.clf()\n c20data = C20Data(2005, fields=['u', 'v'])\n ibdata = IbtracsData()\n bts = ibdata.load_ibtracks_year(2005)\n m = _raster_on_earth(c20data.lons, c20data.lats, None, loc=loc, colorbar=False, labels=False)\n fig.set_size_inches(6.4, 3)\n\n for bt in bts:\n plotting.plot_track(bt)\n _save_figure('2005_best_tracks.png')\n\n\ndef plot_data_processing_figures():\n _plot_katrina()\n _plot_katrina_maxs_mins()\n\n\ndef _plot_katrina():\n c20data = C20Data(2005, fields=['u', 'v'])\n c20data.set_date(dt.datetime(2005, 8, 27, 18))\n\n fig = plt.figure(1)\n plt.clf()\n\n loc = {'llcrnrlat': 15, 'urcrnrlat': 35, 'llcrnrlon': -100, 'urcrnrlon': -70}\n ax = plt.subplot(131)\n # plt.title('Wind')\n\n m = _vec_plot_on_earth(c20data.lons, c20data.lats, -c20data.u, c20data.v, loc=loc)\n m.colorbar(location='bottom', pad='7%', ticks=(0, 8, 16, 24))\n plt.xlabel('Wind speed (ms$^{-1}$)')\n ax.xaxis.set_label_coords(0.5, -0.33)\n\n ax = plt.subplot(132)\n # plt.title('Vorticity')\n m = _raster_on_earth(c20data.lons, c20data.lats, c20data.vort * 10000, loc=loc, colorbar=False)\n m.colorbar(location='bottom', pad='7%', ticks=(-1, 0, 1, 2))\n plt.xlabel('Vorticity ($10^{-4}$ s$^{-1}$)')\n ax.xaxis.set_label_coords(0.5, -0.33)\n\n c20data = C20Data(2005, fields=['u', 'v'], upscaling=True, scale_factor=3)\n c20data.set_date(dt.datetime(2005, 8, 27, 18))\n ax = plt.subplot(133)\n # plt.title('Downscaled\\nVorticity')\n m = _raster_on_earth(c20data.up_lons, c20data.up_lats, c20data.up_vort * 10000,\n loc=loc, colorbar=False)\n m.colorbar(location='bottom', pad='7%', ticks=(-1, 0, 1, 2))\n plt.xlabel('Vorticity ($10^{-4}$ s$^{-1}$)')\n ax.xaxis.set_label_coords(0.5, -0.33)\n\n fig.set_size_inches(7, 4)\n _save_figure('katrina_data_proc.png')\n\n\ndef _plot_katrina_maxs_mins():\n c20data = C20Data(2005, fields=['prmsl', 'u', 'v'])\n c20data.set_date(dt.datetime(2005, 8, 27, 18))\n loc = {'llcrnrlat': 0, 'urcrnrlat': 45, 'llcrnrlon': -120, 'urcrnrlon': -60}\n\n fig = plt.figure(2)\n plt.clf()\n\n plt.subplot(221)\n _raster_on_earth(c20data.lons, c20data.lats, c20data.vort, loc=loc, colorbar=False)\n plt.ylabel('Vorticity')\n\n plt.subplot(222)\n _raster_on_earth(c20data.lons, c20data.lats, None, loc=loc)\n points = c20data.vmaxs\n for p_val, p_loc in points:\n _plot_point_on_earth(p_loc[0] + 1, p_loc[1] + 1, 'ro')\n points = c20data.vmins\n for p_val, p_loc in points:\n _plot_point_on_earth(p_loc[0] + 1, p_loc[1] + 1, 'kx')\n\n plt.subplot(223)\n _raster_on_earth(c20data.lons, c20data.lats, c20data.prmsl,\n vmin=99000, vmax=103000, loc=loc, colorbar=False)\n plt.ylabel('Pressure')\n\n plt.subplot(224)\n _raster_on_earth(c20data.lons, c20data.lats, None, loc=loc)\n points = c20data.pmaxs\n for p_val, p_loc in points:\n _plot_point_on_earth(p_loc[0] + 1, p_loc[1] + 1, 'ro')\n points = c20data.pmins\n for p_val, p_loc in points:\n _plot_point_on_earth(p_loc[0] + 1, p_loc[1] + 1, 'kx')\n\n _save_figure('katrina_max_mins.png')\n\n\ndef plot_matching_figures():\n _plot_six_configs_figure()\n _plot_individual_katrina_figure()\n\n\ndef plot_yearly_hurr_dist(yearly_hurr_distribution):\n start_doy = dt.datetime(2001, 6, 1).timetuple().tm_yday\n end_doy = dt.datetime(2001, 12, 1).timetuple().tm_yday\n\n fig = plt.figure()\n # plt.title('Hurricane Distribution over the Year')\n plt.plot(yearly_hurr_distribution.keys(), yearly_hurr_distribution.values())\n plt.plot((start_doy, start_doy), (0, 250), 'k--')\n plt.plot((end_doy, end_doy), (0, 250), 'k--')\n plt.xlabel('Day of Year')\n plt.ylabel('Hurricane-timesteps')\n fig.set_size_inches(6.3, 3)\n _save_figure('yearly_hurr_dist.png')\n\n\ndef plot_hurr_per_year(hurr_per_year):\n fig = plt.figure()\n # plt.title('Hurricanes per Year')\n plt.plot(hurr_per_year.keys(), hurr_per_year.values())\n plt.xlim((1890, 2010))\n plt.ylim((0, 300))\n\n plt.plot((1914, 1914), (0, 300), 'k--')\n plt.plot((1944, 1944), (0, 300), 'k--')\n plt.plot((1966, 1966), (0, 300), 'k--')\n\n plt.annotate('Panama\\nCanal', xy=(1914, 250), xytext=(1915, 250), fontsize=10)\n plt.annotate('Aircraft\\nRecon.', xy=(1944, 250), xytext=(1945, 250), fontsize=10)\n plt.annotate('Satellite', xy=(1966, 250), xytext=(1967, 250), fontsize=10)\n\n plt.xlabel('Year')\n plt.ylabel('Hurricane-timesteps')\n fig.set_size_inches(6.3, 3)\n _save_figure('hurr_per_year.png')\n\n\ndef plot_cdp_with_hurr_info(cla_analysis=None):\n if not cla_analysis:\n cla_analysis = ClassificationAnalysis()\n\n val_cd = cla_analysis.load_val_classification_data()\n _plot_2005_cdp(val_cd)\n return val_cd\n\n\ndef plot_cal_cd(cal_cd):\n m = cal_cd.are_hurr_actual\n\n i1 = SCATTER_ATTRS['vort']['index']\n i2 = SCATTER_ATTRS['pmin']['index']\n\n fig = plt.figure()\n\n ax = plt.subplot(131)\n plt.plot(cal_cd.data[:, i1][m] * 10000, cal_cd.data[:, i2][m] / 100.,\n 'ro', zorder=0, label='hurricane')\n plt.plot(cal_cd.data[:, i1][~m] * 10000, cal_cd.data[:, i2][~m] / 100.,\n 'bx', zorder=1, label='not hurricane')\n plt.xlim((0, 4.5))\n plt.ylim((920, 1040))\n ax.set_xticks((0, 1.5, 3, 4.5))\n\n plt.ylabel('Pressure (hPa)')\n plt.xlabel('Vorticity ($10^{-4}$ s$^{-1}$)')\n\n ax = plt.subplot(132)\n plt.plot(cal_cd.data[:, i1][m] * 10000, cal_cd.data[:, i2][m] / 100.,\n 'ro', zorder=0, label='hurricane')\n plt.xlim((0, 4.5))\n plt.ylim((920, 1040))\n ax.set_xticks((0, 1.5, 3, 4.5))\n\n plt.xlabel('Vorticity ($10^{-4}$ s$^{-1}$)')\n plt.setp(ax.get_yticklabels(), visible=False)\n\n ax = plt.subplot(133)\n plt.plot(cal_cd.data[:, i1][~m] * 10000, cal_cd.data[:, i2][~m] / 100.,\n 'bx', zorder=1, label='not hurricane')\n plt.plot(-10, -10, 'ro', zorder=1, label='hurricane') # dummy point.\n plt.xlim((0, 4.5))\n plt.ylim((920, 1040))\n ax.set_xticks((0, 1.5, 3, 4.5))\n\n plt.xlabel('Vorticity ($10^{-4}$ s$^{-1}$)')\n plt.legend(bbox_to_anchor=(1.3, 1.16), numpoints=1, prop={'size': 10})\n plt.setp(ax.get_yticklabels(), visible=False)\n\n fig.set_size_inches(6.3, 2.3)\n\n _save_figure('cal_cdp_with_hurrs.png')\n\n\ndef _plot_2005_cdp(val_cd):\n m = val_cd.are_hurr_actual\n m2005 = val_cd.data[:, -2] == 2005 # -2 is year col.\n data = val_cd.data[m2005]\n m = m[m2005]\n\n i1 = SCATTER_ATTRS['vort']['index']\n i2 = SCATTER_ATTRS['pmin']['index']\n\n fig = plt.figure()\n\n labelx = -0.35\n ax = plt.subplot(231)\n plt.plot(data[:, i1][m] * 10000, data[:, i2][m] / 100., 'ro', zorder=0, label='hurricane')\n plt.plot(data[:, i1][~m] * 10000, data[:, i2][~m] / 100., 'bx', zorder=1, label='not hurricane')\n plt.xlim((0, 3))\n plt.ylim((940, 1040))\n ax.set_xticks((0, 1, 2, 3))\n ax.yaxis.set_label_coords(labelx, 0.5)\n\n plt.ylabel('Pressure (hPa)')\n # plt.xlabel('Vorticity ($10^{-4}$ s$^{-1}$)')\n\n ax = plt.subplot(232)\n plt.plot(data[:, i1][m] * 10000, data[:, i2][m] / 100., 'ro', zorder=0, label='hurricane')\n plt.xlim((0, 3))\n plt.ylim((940, 1040))\n ax.set_xticks((0, 1, 2, 3))\n\n # plt.xlabel('Vorticity ($10^{-4}$ s$^{-1}$)')\n plt.setp(ax.get_yticklabels(), visible=False)\n\n ax = plt.subplot(233)\n plt.plot(data[:, i1][~m] * 10000, data[:, i2][~m] / 100., 'bx', zorder=1, label='not hurricane')\n plt.plot(-10, -10, 'ro', zorder=1, label='hurricane') # dummy point.\n plt.xlim((0, 3))\n plt.ylim((940, 1040))\n ax.set_xticks((0, 1, 2, 3))\n\n # plt.xlabel('Vorticity ($10^{-4}$ s$^{-1}$)')\n plt.legend(bbox_to_anchor=(1.3, 1.16), numpoints=1, prop={'size': 10})\n plt.setp(ax.get_yticklabels(), visible=False)\n\n i2 = SCATTER_ATTRS['t850']['index']\n\n ax = plt.subplot(234)\n plt.plot(data[:, i1][m] * 10000, data[:, i2][m], 'ro', zorder=0, label='hurricane')\n plt.plot(data[:, i1][~m] * 10000, data[:, i2][~m], 'bx', zorder=1, label='not hurricane')\n plt.xlim((0, 3))\n plt.ylim((250, 310))\n ax.set_xticks((0, 1, 2, 3))\n ax.yaxis.set_label_coords(labelx, 0.5)\n\n plt.ylabel('Temp. at 850 hPa (K)')\n # plt.xlabel('Vorticity ($10^{-4}$ s$^{-1}$)')\n\n ax = plt.subplot(235)\n plt.plot(data[:, i1][m] * 10000, data[:, i2][m], 'ro', zorder=0, label='hurricane')\n plt.xlim((0, 3))\n plt.ylim((250, 310))\n ax.set_xticks((0, 1, 2, 3))\n\n plt.xlabel('Vorticity ($10^{-4}$ s$^{-1}$)')\n plt.setp(ax.get_yticklabels(), visible=False)\n\n ax = plt.subplot(236)\n plt.plot(data[:, i1][~m] * 10000, data[:, i2][~m], 'bx', zorder=1, label='not hurricane')\n plt.plot(-10, -10, 'ro', zorder=1, label='hurricane') # dummy point.\n plt.xlim((0, 3))\n plt.ylim((250, 310))\n ax.set_xticks((0, 1, 2, 3))\n\n # plt.xlabel('Vorticity ($10^{-4}$ s$^{-1}$)')\n # plt.legend(bbox_to_anchor=(1.3, 1.16), numpoints=1, prop={'size': 10})\n plt.setp(ax.get_yticklabels(), visible=False)\n\n fig.set_size_inches(6.3, 4.6)\n\n _save_figure('cdp_2005_with_hurrs.png')\n\n\ndef _plot_individual_katrina_figure(em=7):\n c20data = C20Data(2005, fields=['prmsl', 'u', 'v'])\n srm = StormtracksResultsManager('pyro_tracking_analysis')\n ta = StormtracksAnalysis(2005)\n ibdata = IbtracsData()\n w, k = ibdata.load_wilma_katrina()\n bt = k\n loc = {'llcrnrlat': 10, 'urcrnrlat': 45, 'llcrnrlon': -100, 'urcrnrlon': -65}\n\n config = {'pressure_level': 850, 'scale': 1, 'tracker': 'nearest_neighbour'}\n\n fig = plt.figure()\n plt.clf()\n\n print(config)\n all_matches = []\n\n key = ta.good_matches_key(config)\n good_matches = srm.get_result(2005, em, key)\n\n for good_match in good_matches:\n if good_match.best_track.name == bt.name:\n break\n\n _raster_on_earth(c20data.lons, c20data.lats, None, loc=loc)\n plotting.plot_match_with_date(good_match, None)\n _save_figure('katrina_individual_match_em7')\n\n\ndef _plot_six_configs_figure():\n c20data = C20Data(2005, fields=['prmsl', 'u', 'v'])\n srm = StormtracksResultsManager('pyro_tracking_analysis')\n ta = StormtracksAnalysis(2005)\n ibdata = IbtracsData()\n w, k = ibdata.load_wilma_katrina()\n bt = k\n loc = {'llcrnrlat': 10, 'urcrnrlat': 45, 'llcrnrlon': -100, 'urcrnrlon': -65}\n fig3 = plt.figure(3)\n plt.clf()\n\n for j, config in enumerate(ta.analysis_config_options):\n plt.subplot(3, 2, j + 1)\n print(config)\n if config['pressure_level'] == 995:\n title = 'NSLP, Scale: {scale}'.format(**config)\n else:\n title = '850 hPa, Scale: {scale}'.format(**config)\n plt.title(title, fontsize=10)\n all_matches = []\n _raster_on_earth(c20data.lons, c20data.lats, None, loc=loc, labels=False)\n plotting.plot_track(bt, zorder=2)\n\n for i in range(56):\n key = ta.good_matches_key(config)\n good_matches = srm.get_result(2005, i, key)\n matches = []\n for good_match in good_matches:\n if good_match.best_track.name == bt.name:\n matches.append(good_match)\n\n if matches:\n all_matches.append(matches)\n for match in matches:\n vt = match.vort_track\n mask = (vt.dates >= bt.dates[0]) & (vt.dates <= bt.dates[-1])\n plotting.plot_path_on_earth(vt.lons[mask], vt.lats[mask], 'b--')\n\n # plotting.plot_track(vt, 'b--')\n # return vt, bt\n else:\n print('Could not find wilma in {0}-{1}'.format(i, key))\n\n fig3.set_size_inches(5.4, 7.8)\n\n _save_figure('katrina_six_tracking_configs')\n\n\ndef plot_katrina_correlation(ca=None, em=7):\n fig = plt.figure()\n ibdata = IbtracsData()\n w, k = ibdata.load_wilma_katrina()\n if not ca:\n ca = ClassificationAnalysis()\n cs, ms, ums = ca.run_individual_cla_analysis(2005, em)\n\n pressures = []\n winds = []\n dates = []\n\n for cm in ms:\n if cm.best_track.name == k.name:\n for date, bt_pres, bt_wind in zip(cm.best_track.dates,\n cm.best_track.pressures,\n cm.best_track.winds):\n if date in cm.cyclone.pmins and cm.cyclone.pmins[date]:\n dates.append(date)\n pressures.append((bt_pres, cm.cyclone.pmins[date] / 100.))\n winds.append((bt_wind, cm.cyclone.max_windspeeds[date]))\n\n pressures, winds = np.array(pressures), np.array(winds)\n\n labelx = -0.1\n ax = plt.subplot(211)\n plt.plot_date(dates, pressures[:, 0], 'b-', label='best track')\n plt.plot_date(dates, pressures[:, 1], 'b--', label='derived track')\n plt.ylabel('pressure (hPa)')\n plt.legend(bbox_to_anchor=(1.07, 1.16), numpoints=1, prop={'size': 10})\n # ax.xaxis.set_major_formatter(matplotlib.dates.DateFormatter('%b %d'))\n plt.setp(ax.get_xticklabels(), visible=False)\n ax.yaxis.set_label_coords(labelx, 0.5)\n\n ax = plt.subplot(212)\n plt.plot_date(dates, winds[:, 0], 'r-', label='best track')\n plt.plot_date(dates, winds[:, 1], 'r--', label='derived track')\n plt.ylabel('max. wind speed (ms$^{-1}$)')\n plt.legend(bbox_to_anchor=(1.07, 1.07), numpoints=1, prop={'size': 10})\n ax.xaxis.set_major_formatter(matplotlib.dates.DateFormatter('%b %d'))\n ax.yaxis.set_label_coords(-0.09, 0.5)\n\n fig.set_size_inches(6.3, 5)\n _save_figure('katrina_best_derived_comparison.png')\n\n\ndef plot_2005_pressure_wind_corr(ca=None):\n if not ca:\n ca = ClassificationAnalysis()\n\n # c20data = C20Data(2005, fields=['prmsl', 'u', 'v'])\n key = 'cyclones'\n\n pressures = []\n winds = []\n\n for em in range(56):\n print(em)\n cs, ms, ums = ca.run_individual_cla_analysis(2005, em)\n\n for cm in ms:\n for date, bt_pres, bt_wind in zip(cm.best_track.dates,\n cm.best_track.pressures,\n cm.best_track.winds):\n if date in cm.cyclone.pmins and cm.cyclone.pmins[date]:\n pressures.append((bt_pres, cm.cyclone.pmins[date] / 100.))\n winds.append((bt_wind, cm.cyclone.max_windspeeds[date]))\n pressures, winds = np.array(pressures), np.array(winds)\n _plot_pres_wind(pressures, winds)\n return pressures, winds\n\n\ndef _plot_pres_wind(pressures, winds):\n fig = plt.figure()\n ax = plt.subplot(121)\n plt.plot(pressures[:, 0], pressures[:, 1], 'b+')\n rp = stats.linregress(pressures)\n label = 'grad.: {0:.2f}\\nintercept: {1:.1f}\\n r$^2$: {2:.2f}'.format(rp[0], rp[1], rp[2] ** 2)\n plt.plot((880, 1040), (880 * rp[0] + rp[1], 1040 * rp[0] + rp[1]), 'r--', label=label)\n plt.ylabel('derived track pressure (hPa)')\n plt.xlabel('best track\\npressure (hPa)')\n plt.legend(bbox_to_anchor=(0.9, 1.23), numpoints=1, prop={'size': 10})\n ax.set_xticks((880, 920, 960, 1000, 1040))\n\n ax = plt.subplot(122)\n plt.plot(winds[:, 0], winds[:, 1], 'b+')\n rw = stats.linregress(winds)\n label = 'grad.: {0:.2f}\\nintercept: {1:.1f}\\n r$^2$: {2:.2f}'.format(rw[0], rw[1], rw[2] ** 2)\n plt.plot((0, 160), (0 * rw[0] + rw[1], 160 * rw[0] + rw[1]), 'r--', label=label)\n plt.ylabel('derived track max. wind speed (ms$^{-1}$)')\n plt.xlabel('best track\\nmax. wind speed (ms$^{-1}$)')\n plt.legend(bbox_to_anchor=(0.9, 1.23), numpoints=1, prop={'size': 10})\n ax.set_xticks((0, 40, 80, 120, 160))\n ax.yaxis.tick_right()\n ax.yaxis.set_label_position(\"right\")\n\n fig.set_size_inches(6.3, 3)\n _save_figure('press_max_ws_corr_2005.png')\n\n\ndef _plot_point_on_earth(lon, lat, plot_fmt=None):\n if plot_fmt:\n plt.plot(lon_convert(lon), lat, plot_fmt)\n else:\n plt.plot(lon_convert(lon), lat)\n\n\ndef _raster_on_earth(lons, lats, data, vmin=None, vmax=None, loc=None, colorbar=True, labels=True):\n if not loc:\n m = Basemap(projection='cyl', resolution='c',\n llcrnrlat=-90, urcrnrlat=90, llcrnrlon=-180, urcrnrlon=180)\n else:\n m = Basemap(projection='cyl', resolution='c', **loc)\n\n if data is not None:\n plot_lons, plot_data = _extend_data(lons, lats, data)\n lons, lats = np.meshgrid(plot_lons, lats)\n x, y = m(lons, lats)\n if vmin:\n m.pcolormesh(x, y, plot_data, vmin=vmin, vmax=vmax)\n else:\n m.pcolormesh(x, y, plot_data)\n\n m.drawcoastlines()\n\n if labels:\n p_labels = [0, 1, 0, 0]\n m.drawparallels(np.arange(-90., 90.1, 45.), labels=p_labels, fontsize=10)\n m.drawmeridians(np.arange(-180., 180., 60.), labels=[0, 0, 0, 1], fontsize=10)\n\n if colorbar and data is not None:\n m.colorbar(location='right', pad='7%')\n return m\n\n\ndef _vec_plot_on_earth(lons, lats, x_data, y_data, vmin=-4, vmax=12, loc=None, colorbar=False):\n plot_lons, plot_x_data = _extend_data(lons, lats, x_data)\n plot_lons, plot_y_data = _extend_data(lons, lats, y_data)\n\n lons, lats = np.meshgrid(plot_lons, lats)\n\n if not loc:\n m = Basemap(projection='cyl', resolution='c',\n llcrnrlat=-90, urcrnrlat=90, llcrnrlon=-180, urcrnrlon=180)\n else:\n m = Basemap(projection='cyl', resolution='c', **loc)\n x, y = m(lons, lats)\n\n mag = np.sqrt(plot_x_data**2 + plot_y_data**2)\n vmin, vmax = mag.min(), mag.max()\n m.contourf(x, y, mag)\n # m.pcolormesh(x, y, mag, vmin=vmin, vmax=vmax)\n # m.quiver(x, y, plot_x_data, plot_y_data)\n skip = 1\n m.quiver(x[::skip, ::skip], y[::skip, ::skip],\n plot_x_data[::skip, ::skip], plot_y_data[::skip, ::skip], scale=500)\n\n m.drawcoastlines()\n m.drawparallels(np.arange(-90., 90., 45.), labels=[1, 0, 0, 0], fontsize=10)\n m.drawmeridians(np.arange(-180., 180., 60.), labels=[0, 0, 0, 1], fontsize=10)\n\n if colorbar:\n m.colorbar(location='right', pad='7%')\n return m\n\n\ndef _extend_data(lons, lats, data):\n if False:\n # TODO: probably doesn't work!\n # Adds extra data at the end.\n plot_offset = 2\n plot_lons = np.zeros((lons.shape[0] + plot_offset,))\n plot_lons[:-plot_offset] = lons\n plot_lons[-plot_offset:] = lons[-plot_offset:] + 3.75 * plot_offset\n\n plot_data = np.zeros((data.shape[0], data.shape[1] + plot_offset))\n plot_data[:, :-plot_offset] = data\n plot_data[:, -plot_offset:] = data[:, :plot_offset]\n else:\n # Adds extra data before the start.\n delta = lons[1] - lons[0]\n plot_offset = 180\n plot_lons = np.ma.zeros((lons.shape[0] + plot_offset,))\n plot_lons[plot_offset:] = lons\n plot_lons[:plot_offset] = lons[-plot_offset:] - delta * (lons.shape[0])\n\n plot_data = np.ma.zeros((data.shape[0], data.shape[1] + plot_offset))\n plot_data[:, plot_offset:] = data\n plot_data[:, :plot_offset] = data[:, -plot_offset:]\n\n return plot_lons, plot_data\n\n\ndef _save_figure(name):\n if not os.path.exists(settings.FIGURE_OUTPUT_DIR):\n os.makedirs(settings.FIGURE_OUTPUT_DIR)\n plt.savefig(os.path.join(settings.FIGURE_OUTPUT_DIR, name), bbox_inches='tight')\n\n\ndef main():\n import sys\n import inspect\n\n print('Loading all data from: {}'.format(settings.DATA_DIR))\n ib_hurrs, ib_pdis, cla_hurrs, cla_pdis, adjustment_ratio = load_20th_century()\n thresh_metrics = load_thresh_metric_vs_vort_lo()\n classifier_metrics = load_classifier_metrics()\n yearly_hurr_distribution, hurr_per_year = load_ibtracs_info()\n print('Data loaded')\n\n functions = inspect.getmembers(sys.modules[__name__], inspect.isfunction)\n for name, fn in functions:\n if name[:5] == 'plot_':\n try:\n print(name)\n if name in ('plot_20th_century',\n 'plot_poster_20th_century',\n 'plot_poster_20th_century_trends',\n 'plot_20th_century_corr'):\n fn(ib_hurrs, cla_hurrs, adjustment_ratio)\n elif name == 'plot_thresh_metric_vs_vort_lo':\n fn(thresh_metrics)\n elif name == 'plot_classifer_metrics':\n fn(classifier_metrics)\n elif name == 'plot_yearly_hurr_dist':\n fn(yearly_hurr_distribution)\n elif name == 'plot_hurr_per_year':\n fn(hurr_per_year)\n elif name == 'plot_cal_cd':\n cla_analysis = ClassificationAnalysis()\n cal_cd = cla_analysis.load_cal_classification_data()\n plot_cal_cd(cal_cd)\n else:\n fn()\n except:\n print('PROBLEM PLOTTING {0}, SKIPPING'.format(name))\n\n\nif __name__ == '__main__':\n main()\n", "meta": {"hexsha": "7f695ca7a396b56e3605a6a92a33fcc5cdb33d27", "size": 45034, "ext": "py", "lang": "Python", "max_stars_repo_path": "stormtracks/analysis/figure_plotting.py", "max_stars_repo_name": "subond/stormtracks", "max_stars_repo_head_hexsha": "63556053d71013ec044aa207d0978c0e9e76d859", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 16, "max_stars_repo_stars_event_min_datetime": "2016-08-29T20:35:08.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-03T05:12:58.000Z", "max_issues_repo_path": "stormtracks/analysis/figure_plotting.py", "max_issues_repo_name": "xiaoxiaoyu0302/stormtracks", "max_issues_repo_head_hexsha": "63556053d71013ec044aa207d0978c0e9e76d859", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 16, "max_issues_repo_issues_event_min_datetime": "2015-02-23T17:21:25.000Z", "max_issues_repo_issues_event_max_datetime": "2015-05-14T11:15:31.000Z", "max_forks_repo_path": "stormtracks/analysis/figure_plotting.py", "max_forks_repo_name": "xiaoxiaoyu0302/stormtracks", "max_forks_repo_head_hexsha": "63556053d71013ec044aa207d0978c0e9e76d859", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 12, "max_forks_repo_forks_event_min_datetime": "2017-01-29T23:29:11.000Z", "max_forks_repo_forks_event_max_datetime": "2020-11-22T11:16:46.000Z", "avg_line_length": 36.4647773279, "max_line_length": 100, "alphanum_fraction": 0.5734556113, "include": true, "reason": "import numpy,from scipy", "num_tokens": 14034, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230157, "lm_q2_score": 0.3775406687981454, "lm_q1q2_score": 0.1946674878277107}} {"text": "\"\"\"\nLow-level functions for complex arithmetic.\n\"\"\"\n\nimport sys\n\nfrom .backend import MPZ, MPZ_ZERO, MPZ_ONE, MPZ_TWO, BACKEND\n\nfrom .libmpf import (\\\n round_floor, round_ceiling, round_down, round_up,\n round_nearest, round_fast, bitcount,\n bctable, normalize, normalize1, reciprocal_rnd, rshift, lshift, giant_steps,\n negative_rnd,\n to_str, to_fixed, from_man_exp, from_float, to_float, from_int, to_int,\n fzero, fone, ftwo, fhalf, finf, fninf, fnan, fnone,\n mpf_abs, mpf_pos, mpf_neg, mpf_add, mpf_sub, mpf_mul,\n mpf_div, mpf_mul_int, mpf_shift, mpf_sqrt, mpf_hypot,\n mpf_rdiv_int, mpf_floor, mpf_ceil, mpf_nint, mpf_frac,\n mpf_sign, mpf_hash,\n ComplexResult\n)\n\nfrom .libelefun import (\\\n mpf_pi, mpf_exp, mpf_log, mpf_cos_sin, mpf_cosh_sinh, mpf_tan, mpf_pow_int,\n mpf_log_hypot,\n mpf_cos_sin_pi, mpf_phi,\n mpf_cos, mpf_sin, mpf_cos_pi, mpf_sin_pi,\n mpf_atan, mpf_atan2, mpf_cosh, mpf_sinh, mpf_tanh,\n mpf_asin, mpf_acos, mpf_acosh, mpf_nthroot, mpf_fibonacci\n)\n\n# An mpc value is a (real, imag) tuple\nmpc_one = fone, fzero\nmpc_zero = fzero, fzero\nmpc_two = ftwo, fzero\nmpc_half = (fhalf, fzero)\n\n_infs = (finf, fninf)\n_infs_nan = (finf, fninf, fnan)\n\ndef mpc_is_inf(z):\n \"\"\"Check if either real or imaginary part is infinite\"\"\"\n re, im = z\n if re in _infs: return True\n if im in _infs: return True\n return False\n\ndef mpc_is_infnan(z):\n \"\"\"Check if either real or imaginary part is infinite or nan\"\"\"\n re, im = z\n if re in _infs_nan: return True\n if im in _infs_nan: return True\n return False\n\ndef mpc_to_str(z, dps, **kwargs):\n re, im = z\n rs = to_str(re, dps)\n if im[0]:\n return rs + \" - \" + to_str(mpf_neg(im), dps, **kwargs) + \"j\"\n else:\n return rs + \" + \" + to_str(im, dps, **kwargs) + \"j\"\n\ndef mpc_to_complex(z, strict=False, rnd=round_fast):\n re, im = z\n return complex(to_float(re, strict, rnd), to_float(im, strict, rnd))\n\ndef mpc_hash(z):\n if sys.version >= \"3.2\":\n re, im = z\n h = mpf_hash(re) + sys.hash_info.imag * mpf_hash(im)\n # Need to reduce either module 2^32 or 2^64\n h = h % (2**sys.hash_info.width)\n return int(h)\n else:\n try:\n return hash(mpc_to_complex(z, strict=True))\n except OverflowError:\n return hash(z)\n\ndef mpc_conjugate(z, prec, rnd=round_fast):\n re, im = z\n return re, mpf_neg(im, prec, rnd)\n\ndef mpc_is_nonzero(z):\n return z != mpc_zero\n\ndef mpc_add(z, w, prec, rnd=round_fast):\n a, b = z\n c, d = w\n return mpf_add(a, c, prec, rnd), mpf_add(b, d, prec, rnd)\n\ndef mpc_add_mpf(z, x, prec, rnd=round_fast):\n a, b = z\n return mpf_add(a, x, prec, rnd), b\n\ndef mpc_sub(z, w, prec=0, rnd=round_fast):\n a, b = z\n c, d = w\n return mpf_sub(a, c, prec, rnd), mpf_sub(b, d, prec, rnd)\n\ndef mpc_sub_mpf(z, p, prec=0, rnd=round_fast):\n a, b = z\n return mpf_sub(a, p, prec, rnd), b\n\ndef mpc_pos(z, prec, rnd=round_fast):\n a, b = z\n return mpf_pos(a, prec, rnd), mpf_pos(b, prec, rnd)\n\ndef mpc_neg(z, prec=None, rnd=round_fast):\n a, b = z\n return mpf_neg(a, prec, rnd), mpf_neg(b, prec, rnd)\n\ndef mpc_shift(z, n):\n a, b = z\n return mpf_shift(a, n), mpf_shift(b, n)\n\ndef mpc_abs(z, prec, rnd=round_fast):\n \"\"\"Absolute value of a complex number, |a+bi|.\n Returns an mpf value.\"\"\"\n a, b = z\n return mpf_hypot(a, b, prec, rnd)\n\ndef mpc_arg(z, prec, rnd=round_fast):\n \"\"\"Argument of a complex number. Returns an mpf value.\"\"\"\n a, b = z\n return mpf_atan2(b, a, prec, rnd)\n\ndef mpc_floor(z, prec, rnd=round_fast):\n a, b = z\n return mpf_floor(a, prec, rnd), mpf_floor(b, prec, rnd)\n\ndef mpc_ceil(z, prec, rnd=round_fast):\n a, b = z\n return mpf_ceil(a, prec, rnd), mpf_ceil(b, prec, rnd)\n\ndef mpc_nint(z, prec, rnd=round_fast):\n a, b = z\n return mpf_nint(a, prec, rnd), mpf_nint(b, prec, rnd)\n\ndef mpc_frac(z, prec, rnd=round_fast):\n a, b = z\n return mpf_frac(a, prec, rnd), mpf_frac(b, prec, rnd)\n\n\ndef mpc_mul(z, w, prec, rnd=round_fast):\n \"\"\"\n Complex multiplication.\n\n Returns the real and imaginary part of (a+bi)*(c+di), rounded to\n the specified precision. The rounding mode applies to the real and\n imaginary parts separately.\n \"\"\"\n a, b = z\n c, d = w\n p = mpf_mul(a, c)\n q = mpf_mul(b, d)\n r = mpf_mul(a, d)\n s = mpf_mul(b, c)\n re = mpf_sub(p, q, prec, rnd)\n im = mpf_add(r, s, prec, rnd)\n return re, im\n\ndef mpc_square(z, prec, rnd=round_fast):\n # (a+b*I)**2 == a**2 - b**2 + 2*I*a*b\n a, b = z\n p = mpf_mul(a,a)\n q = mpf_mul(b,b)\n r = mpf_mul(a,b, prec, rnd)\n re = mpf_sub(p, q, prec, rnd)\n im = mpf_shift(r, 1)\n return re, im\n\ndef mpc_mul_mpf(z, p, prec, rnd=round_fast):\n a, b = z\n re = mpf_mul(a, p, prec, rnd)\n im = mpf_mul(b, p, prec, rnd)\n return re, im\n\ndef mpc_mul_imag_mpf(z, x, prec, rnd=round_fast):\n \"\"\"\n Multiply the mpc value z by I*x where x is an mpf value.\n \"\"\"\n a, b = z\n re = mpf_neg(mpf_mul(b, x, prec, rnd))\n im = mpf_mul(a, x, prec, rnd)\n return re, im\n\ndef mpc_mul_int(z, n, prec, rnd=round_fast):\n a, b = z\n re = mpf_mul_int(a, n, prec, rnd)\n im = mpf_mul_int(b, n, prec, rnd)\n return re, im\n\ndef mpc_div(z, w, prec, rnd=round_fast):\n a, b = z\n c, d = w\n wp = prec + 10\n # mag = c*c + d*d\n mag = mpf_add(mpf_mul(c, c), mpf_mul(d, d), wp)\n # (a*c+b*d)/mag, (b*c-a*d)/mag\n t = mpf_add(mpf_mul(a,c), mpf_mul(b,d), wp)\n u = mpf_sub(mpf_mul(b,c), mpf_mul(a,d), wp)\n return mpf_div(t,mag,prec,rnd), mpf_div(u,mag,prec,rnd)\n\ndef mpc_div_mpf(z, p, prec, rnd=round_fast):\n \"\"\"Calculate z/p where p is real\"\"\"\n a, b = z\n re = mpf_div(a, p, prec, rnd)\n im = mpf_div(b, p, prec, rnd)\n return re, im\n\ndef mpc_reciprocal(z, prec, rnd=round_fast):\n \"\"\"Calculate 1/z efficiently\"\"\"\n a, b = z\n m = mpf_add(mpf_mul(a,a),mpf_mul(b,b),prec+10)\n re = mpf_div(a, m, prec, rnd)\n im = mpf_neg(mpf_div(b, m, prec, rnd))\n return re, im\n\ndef mpc_mpf_div(p, z, prec, rnd=round_fast):\n \"\"\"Calculate p/z where p is real efficiently\"\"\"\n a, b = z\n m = mpf_add(mpf_mul(a,a),mpf_mul(b,b), prec+10)\n re = mpf_div(mpf_mul(a,p), m, prec, rnd)\n im = mpf_div(mpf_neg(mpf_mul(b,p)), m, prec, rnd)\n return re, im\n\ndef complex_int_pow(a, b, n):\n \"\"\"Complex integer power: computes (a+b*I)**n exactly for\n nonnegative n (a and b must be Python ints).\"\"\"\n wre = 1\n wim = 0\n while n:\n if n & 1:\n wre, wim = wre*a - wim*b, wim*a + wre*b\n n -= 1\n a, b = a*a - b*b, 2*a*b\n n //= 2\n return wre, wim\n\ndef mpc_pow(z, w, prec, rnd=round_fast):\n if w[1] == fzero:\n return mpc_pow_mpf(z, w[0], prec, rnd)\n return mpc_exp(mpc_mul(mpc_log(z, prec+10), w, prec+10), prec, rnd)\n\ndef mpc_pow_mpf(z, p, prec, rnd=round_fast):\n psign, pman, pexp, pbc = p\n if pexp >= 0:\n return mpc_pow_int(z, (-1)**psign * (pman< 0:\n aman <<= de\n aexp = bexp\n else:\n bman <<= (-de)\n bexp = aexp\n re, im = complex_int_pow(aman, bman, n)\n re = from_man_exp(re, int(n*aexp), prec, rnd)\n im = from_man_exp(im, int(n*bexp), prec, rnd)\n return re, im\n return mpc_exp(mpc_mul_int(mpc_log(z, prec+10), n, prec+10), prec, rnd)\n\ndef mpc_sqrt(z, prec, rnd=round_fast):\n \"\"\"Complex square root (principal branch).\n\n We have sqrt(a+bi) = sqrt((r+a)/2) + b/sqrt(2*(r+a))*i where\n r = abs(a+bi), when a+bi is not a negative real number.\"\"\"\n a, b = z\n if b == fzero:\n if a == fzero:\n return (a, b)\n # When a+bi is a negative real number, we get a real sqrt times i\n if a[0]:\n im = mpf_sqrt(mpf_neg(a), prec, rnd)\n return (fzero, im)\n else:\n re = mpf_sqrt(a, prec, rnd)\n return (re, fzero)\n wp = prec+20\n if not a[0]: # case a positive\n t = mpf_add(mpc_abs((a, b), wp), a, wp) # t = abs(a+bi) + a\n u = mpf_shift(t, -1) # u = t/2\n re = mpf_sqrt(u, prec, rnd) # re = sqrt(u)\n v = mpf_shift(t, 1) # v = 2*t\n w = mpf_sqrt(v, wp) # w = sqrt(v)\n im = mpf_div(b, w, prec, rnd) # im = b / w\n else: # case a negative\n t = mpf_sub(mpc_abs((a, b), wp), a, wp) # t = abs(a+bi) - a\n u = mpf_shift(t, -1) # u = t/2\n im = mpf_sqrt(u, prec, rnd) # im = sqrt(u)\n v = mpf_shift(t, 1) # v = 2*t\n w = mpf_sqrt(v, wp) # w = sqrt(v)\n re = mpf_div(b, w, prec, rnd) # re = b/w\n if b[0]:\n re = mpf_neg(re)\n im = mpf_neg(im)\n return re, im\n\ndef mpc_nthroot_fixed(a, b, n, prec):\n # a, b signed integers at fixed precision prec\n start = 50\n a1 = int(rshift(a, prec - n*start))\n b1 = int(rshift(b, prec - n*start))\n try:\n r = (a1 + 1j * b1)**(1.0/n)\n re = r.real\n im = r.imag\n re = MPZ(int(re))\n im = MPZ(int(im))\n except OverflowError:\n a1 = from_int(a1, start)\n b1 = from_int(b1, start)\n fn = from_int(n)\n nth = mpf_rdiv_int(1, fn, start)\n re, im = mpc_pow((a1, b1), (nth, fzero), start)\n re = to_int(re)\n im = to_int(im)\n extra = 10\n prevp = start\n extra1 = n\n for p in giant_steps(start, prec+extra):\n # this is slow for large n, unlike int_pow_fixed\n re2, im2 = complex_int_pow(re, im, n-1)\n re2 = rshift(re2, (n-1)*prevp - p - extra1)\n im2 = rshift(im2, (n-1)*prevp - p - extra1)\n r4 = (re2*re2 + im2*im2) >> (p + extra1)\n ap = rshift(a, prec - p)\n bp = rshift(b, prec - p)\n rec = (ap * re2 + bp * im2) >> p\n imc = (-ap * im2 + bp * re2) >> p\n reb = (rec << p) // r4\n imb = (imc << p) // r4\n re = (reb + (n-1)*lshift(re, p-prevp))//n\n im = (imb + (n-1)*lshift(im, p-prevp))//n\n prevp = p\n return re, im\n\ndef mpc_nthroot(z, n, prec, rnd=round_fast):\n \"\"\"\n Complex n-th root.\n\n Use Newton method as in the real case when it is faster,\n otherwise use z**(1/n)\n \"\"\"\n a, b = z\n if a[0] == 0 and b == fzero:\n re = mpf_nthroot(a, n, prec, rnd)\n return (re, fzero)\n if n < 2:\n if n == 0:\n return mpc_one\n if n == 1:\n return mpc_pos((a, b), prec, rnd)\n if n == -1:\n return mpc_div(mpc_one, (a, b), prec, rnd)\n inverse = mpc_nthroot((a, b), -n, prec+5, reciprocal_rnd[rnd])\n return mpc_div(mpc_one, inverse, prec, rnd)\n if n <= 20:\n prec2 = int(1.2 * (prec + 10))\n asign, aman, aexp, abc = a\n bsign, bman, bexp, bbc = b\n pf = mpc_abs((a,b), prec)\n if pf[-2] + pf[-1] > -10 and pf[-2] + pf[-1] < prec:\n af = to_fixed(a, prec2)\n bf = to_fixed(b, prec2)\n re, im = mpc_nthroot_fixed(af, bf, n, prec2)\n extra = 10\n re = from_man_exp(re, -prec2-extra, prec2, rnd)\n im = from_man_exp(im, -prec2-extra, prec2, rnd)\n return re, im\n fn = from_int(n)\n prec2 = prec+10 + 10\n nth = mpf_rdiv_int(1, fn, prec2)\n re, im = mpc_pow((a, b), (nth, fzero), prec2, rnd)\n re = normalize(re[0], re[1], re[2], re[3], prec, rnd)\n im = normalize(im[0], im[1], im[2], im[3], prec, rnd)\n return re, im\n\ndef mpc_cbrt(z, prec, rnd=round_fast):\n \"\"\"\n Complex cubic root.\n \"\"\"\n return mpc_nthroot(z, 3, prec, rnd)\n\ndef mpc_exp(z, prec, rnd=round_fast):\n \"\"\"\n Complex exponential function.\n\n We use the direct formula exp(a+bi) = exp(a) * (cos(b) + sin(b)*i)\n for the computation. This formula is very nice because it is\n pefectly stable; since we just do real multiplications, the only\n numerical errors that can creep in are single-ulp rounding errors.\n\n The formula is efficient since mpmath's real exp is quite fast and\n since we can compute cos and sin simultaneously.\n\n It is no problem if a and b are large; if the implementations of\n exp/cos/sin are accurate and efficient for all real numbers, then\n so is this function for all complex numbers.\n \"\"\"\n a, b = z\n if a == fzero:\n return mpf_cos_sin(b, prec, rnd)\n if b == fzero:\n return mpf_exp(a, prec, rnd), fzero\n mag = mpf_exp(a, prec+4, rnd)\n c, s = mpf_cos_sin(b, prec+4, rnd)\n re = mpf_mul(mag, c, prec, rnd)\n im = mpf_mul(mag, s, prec, rnd)\n return re, im\n\ndef mpc_log(z, prec, rnd=round_fast):\n re = mpf_log_hypot(z[0], z[1], prec, rnd)\n im = mpc_arg(z, prec, rnd)\n return re, im\n\ndef mpc_cos(z, prec, rnd=round_fast):\n \"\"\"Complex cosine. The formula used is cos(a+bi) = cos(a)*cosh(b) -\n sin(a)*sinh(b)*i.\n\n The same comments apply as for the complex exp: only real\n multiplications are pewrormed, so no cancellation errors are\n possible. The formula is also efficient since we can compute both\n pairs (cos, sin) and (cosh, sinh) in single stwps.\"\"\"\n a, b = z\n if b == fzero:\n return mpf_cos(a, prec, rnd), fzero\n if a == fzero:\n return mpf_cosh(b, prec, rnd), fzero\n wp = prec + 6\n c, s = mpf_cos_sin(a, wp)\n ch, sh = mpf_cosh_sinh(b, wp)\n re = mpf_mul(c, ch, prec, rnd)\n im = mpf_mul(s, sh, prec, rnd)\n return re, mpf_neg(im)\n\ndef mpc_sin(z, prec, rnd=round_fast):\n \"\"\"Complex sine. We have sin(a+bi) = sin(a)*cosh(b) +\n cos(a)*sinh(b)*i. See the docstring for mpc_cos for additional\n comments.\"\"\"\n a, b = z\n if b == fzero:\n return mpf_sin(a, prec, rnd), fzero\n if a == fzero:\n return fzero, mpf_sinh(b, prec, rnd)\n wp = prec + 6\n c, s = mpf_cos_sin(a, wp)\n ch, sh = mpf_cosh_sinh(b, wp)\n re = mpf_mul(s, ch, prec, rnd)\n im = mpf_mul(c, sh, prec, rnd)\n return re, im\n\ndef mpc_tan(z, prec, rnd=round_fast):\n \"\"\"Complex tangent. Computed as tan(a+bi) = sin(2a)/M + sinh(2b)/M*i\n where M = cos(2a) + cosh(2b).\"\"\"\n a, b = z\n asign, aman, aexp, abc = a\n bsign, bman, bexp, bbc = b\n if b == fzero: return mpf_tan(a, prec, rnd), fzero\n if a == fzero: return fzero, mpf_tanh(b, prec, rnd)\n wp = prec + 15\n a = mpf_shift(a, 1)\n b = mpf_shift(b, 1)\n c, s = mpf_cos_sin(a, wp)\n ch, sh = mpf_cosh_sinh(b, wp)\n # TODO: handle cancellation when c ~= -1 and ch ~= 1\n mag = mpf_add(c, ch, wp)\n re = mpf_div(s, mag, prec, rnd)\n im = mpf_div(sh, mag, prec, rnd)\n return re, im\n\ndef mpc_cos_pi(z, prec, rnd=round_fast):\n a, b = z\n if b == fzero:\n return mpf_cos_pi(a, prec, rnd), fzero\n b = mpf_mul(b, mpf_pi(prec+5), prec+5)\n if a == fzero:\n return mpf_cosh(b, prec, rnd), fzero\n wp = prec + 6\n c, s = mpf_cos_sin_pi(a, wp)\n ch, sh = mpf_cosh_sinh(b, wp)\n re = mpf_mul(c, ch, prec, rnd)\n im = mpf_mul(s, sh, prec, rnd)\n return re, mpf_neg(im)\n\ndef mpc_sin_pi(z, prec, rnd=round_fast):\n a, b = z\n if b == fzero:\n return mpf_sin_pi(a, prec, rnd), fzero\n b = mpf_mul(b, mpf_pi(prec+5), prec+5)\n if a == fzero:\n return fzero, mpf_sinh(b, prec, rnd)\n wp = prec + 6\n c, s = mpf_cos_sin_pi(a, wp)\n ch, sh = mpf_cosh_sinh(b, wp)\n re = mpf_mul(s, ch, prec, rnd)\n im = mpf_mul(c, sh, prec, rnd)\n return re, im\n\ndef mpc_cos_sin(z, prec, rnd=round_fast):\n a, b = z\n if a == fzero:\n ch, sh = mpf_cosh_sinh(b, prec, rnd)\n return (ch, fzero), (fzero, sh)\n if b == fzero:\n c, s = mpf_cos_sin(a, prec, rnd)\n return (c, fzero), (s, fzero)\n wp = prec + 6\n c, s = mpf_cos_sin(a, wp)\n ch, sh = mpf_cosh_sinh(b, wp)\n cre = mpf_mul(c, ch, prec, rnd)\n cim = mpf_mul(s, sh, prec, rnd)\n sre = mpf_mul(s, ch, prec, rnd)\n sim = mpf_mul(c, sh, prec, rnd)\n return (cre, mpf_neg(cim)), (sre, sim)\n\ndef mpc_cos_sin_pi(z, prec, rnd=round_fast):\n a, b = z\n if b == fzero:\n c, s = mpf_cos_sin_pi(a, prec, rnd)\n return (c, fzero), (s, fzero)\n b = mpf_mul(b, mpf_pi(prec+5), prec+5)\n if a == fzero:\n ch, sh = mpf_cosh_sinh(b, prec, rnd)\n return (ch, fzero), (fzero, sh)\n wp = prec + 6\n c, s = mpf_cos_sin_pi(a, wp)\n ch, sh = mpf_cosh_sinh(b, wp)\n cre = mpf_mul(c, ch, prec, rnd)\n cim = mpf_mul(s, sh, prec, rnd)\n sre = mpf_mul(s, ch, prec, rnd)\n sim = mpf_mul(c, sh, prec, rnd)\n return (cre, mpf_neg(cim)), (sre, sim)\n\ndef mpc_cosh(z, prec, rnd=round_fast):\n \"\"\"Complex hyperbolic cosine. Computed as cosh(z) = cos(z*i).\"\"\"\n a, b = z\n return mpc_cos((b, mpf_neg(a)), prec, rnd)\n\ndef mpc_sinh(z, prec, rnd=round_fast):\n \"\"\"Complex hyperbolic sine. Computed as sinh(z) = -i*sin(z*i).\"\"\"\n a, b = z\n b, a = mpc_sin((b, a), prec, rnd)\n return a, b\n\ndef mpc_tanh(z, prec, rnd=round_fast):\n \"\"\"Complex hyperbolic tangent. Computed as tanh(z) = -i*tan(z*i).\"\"\"\n a, b = z\n b, a = mpc_tan((b, a), prec, rnd)\n return a, b\n\n# TODO: avoid loss of accuracy\ndef mpc_atan(z, prec, rnd=round_fast):\n a, b = z\n # atan(z) = (I/2)*(log(1-I*z) - log(1+I*z))\n # x = 1-I*z = 1 + b - I*a\n # y = 1+I*z = 1 - b + I*a\n wp = prec + 15\n x = mpf_add(fone, b, wp), mpf_neg(a)\n y = mpf_sub(fone, b, wp), a\n l1 = mpc_log(x, wp)\n l2 = mpc_log(y, wp)\n a, b = mpc_sub(l1, l2, prec, rnd)\n # (I/2) * (a+b*I) = (-b/2 + a/2*I)\n v = mpf_neg(mpf_shift(b,-1)), mpf_shift(a,-1)\n # Subtraction at infinity gives correct real part but\n # wrong imaginary part (should be zero)\n if v[1] == fnan and mpc_is_inf(z):\n v = (v[0], fzero)\n return v\n\nbeta_crossover = from_float(0.6417)\nalpha_crossover = from_float(1.5)\n\ndef acos_asin(z, prec, rnd, n):\n \"\"\" complex acos for n = 0, asin for n = 1\n The algorithm is described in\n T.E. Hull, T.F. Fairgrieve and P.T.P. Tang\n 'Implementing the Complex Arcsine and Arcosine Functions\n using Exception Handling',\n ACM Trans. on Math. Software Vol. 23 (1997), p299\n The complex acos and asin can be defined as\n acos(z) = acos(beta) - I*sign(a)* log(alpha + sqrt(alpha**2 -1))\n asin(z) = asin(beta) + I*sign(a)* log(alpha + sqrt(alpha**2 -1))\n where z = a + I*b\n alpha = (1/2)*(r + s); beta = (1/2)*(r - s) = a/alpha\n r = sqrt((a+1)**2 + y**2); s = sqrt((a-1)**2 + y**2)\n These expressions are rewritten in different ways in different\n regions, delimited by two crossovers alpha_crossover and beta_crossover,\n and by abs(a) <= 1, in order to improve the numerical accuracy.\n \"\"\"\n a, b = z\n wp = prec + 10\n # special cases with real argument\n if b == fzero:\n am = mpf_sub(fone, mpf_abs(a), wp)\n # case abs(a) <= 1\n if not am[0]:\n if n == 0:\n return mpf_acos(a, prec, rnd), fzero\n else:\n return mpf_asin(a, prec, rnd), fzero\n # cases abs(a) > 1\n else:\n # case a < -1\n if a[0]:\n pi = mpf_pi(prec, rnd)\n c = mpf_acosh(mpf_neg(a), prec, rnd)\n if n == 0:\n return pi, mpf_neg(c)\n else:\n return mpf_neg(mpf_shift(pi, -1)), c\n # case a > 1\n else:\n c = mpf_acosh(a, prec, rnd)\n if n == 0:\n return fzero, c\n else:\n pi = mpf_pi(prec, rnd)\n return mpf_shift(pi, -1), mpf_neg(c)\n asign = bsign = 0\n if a[0]:\n a = mpf_neg(a)\n asign = 1\n if b[0]:\n b = mpf_neg(b)\n bsign = 1\n am = mpf_sub(fone, a, wp)\n ap = mpf_add(fone, a, wp)\n r = mpf_hypot(ap, b, wp)\n s = mpf_hypot(am, b, wp)\n alpha = mpf_shift(mpf_add(r, s, wp), -1)\n beta = mpf_div(a, alpha, wp)\n b2 = mpf_mul(b,b, wp)\n # case beta <= beta_crossover\n if not mpf_sub(beta_crossover, beta, wp)[0]:\n if n == 0:\n re = mpf_acos(beta, wp)\n else:\n re = mpf_asin(beta, wp)\n else:\n # to compute the real part in this region use the identity\n # asin(beta) = atan(beta/sqrt(1-beta**2))\n # beta/sqrt(1-beta**2) = (alpha + a) * (alpha - a)\n # alpha + a is numerically accurate; alpha - a can have\n # cancellations leading to numerical inaccuracies, so rewrite\n # it in differente ways according to the region\n Ax = mpf_add(alpha, a, wp)\n # case a <= 1\n if not am[0]:\n # c = b*b/(r + (a+1)); d = (s + (1-a))\n # alpha - a = (1/2)*(c + d)\n # case n=0: re = atan(sqrt((1/2) * Ax * (c + d))/a)\n # case n=1: re = atan(a/sqrt((1/2) * Ax * (c + d)))\n c = mpf_div(b2, mpf_add(r, ap, wp), wp)\n d = mpf_add(s, am, wp)\n re = mpf_shift(mpf_mul(Ax, mpf_add(c, d, wp), wp), -1)\n if n == 0:\n re = mpf_atan(mpf_div(mpf_sqrt(re, wp), a, wp), wp)\n else:\n re = mpf_atan(mpf_div(a, mpf_sqrt(re, wp), wp), wp)\n else:\n # c = Ax/(r + (a+1)); d = Ax/(s - (1-a))\n # alpha - a = (1/2)*(c + d)\n # case n = 0: re = atan(b*sqrt(c + d)/2/a)\n # case n = 1: re = atan(a/(b*sqrt(c + d)/2)\n c = mpf_div(Ax, mpf_add(r, ap, wp), wp)\n d = mpf_div(Ax, mpf_sub(s, am, wp), wp)\n re = mpf_shift(mpf_add(c, d, wp), -1)\n re = mpf_mul(b, mpf_sqrt(re, wp), wp)\n if n == 0:\n re = mpf_atan(mpf_div(re, a, wp), wp)\n else:\n re = mpf_atan(mpf_div(a, re, wp), wp)\n # to compute alpha + sqrt(alpha**2 - 1), if alpha <= alpha_crossover\n # replace it with 1 + Am1 + sqrt(Am1*(alpha+1)))\n # where Am1 = alpha -1\n # if alpha <= alpha_crossover:\n if not mpf_sub(alpha_crossover, alpha, wp)[0]:\n c1 = mpf_div(b2, mpf_add(r, ap, wp), wp)\n # case a < 1\n if mpf_neg(am)[0]:\n # Am1 = (1/2) * (b*b/(r + (a+1)) + b*b/(s + (1-a))\n c2 = mpf_add(s, am, wp)\n c2 = mpf_div(b2, c2, wp)\n Am1 = mpf_shift(mpf_add(c1, c2, wp), -1)\n else:\n # Am1 = (1/2) * (b*b/(r + (a+1)) + (s - (1-a)))\n c2 = mpf_sub(s, am, wp)\n Am1 = mpf_shift(mpf_add(c1, c2, wp), -1)\n # im = log(1 + Am1 + sqrt(Am1*(alpha+1)))\n im = mpf_mul(Am1, mpf_add(alpha, fone, wp), wp)\n im = mpf_log(mpf_add(fone, mpf_add(Am1, mpf_sqrt(im, wp), wp), wp), wp)\n else:\n # im = log(alpha + sqrt(alpha*alpha - 1))\n im = mpf_sqrt(mpf_sub(mpf_mul(alpha, alpha, wp), fone, wp), wp)\n im = mpf_log(mpf_add(alpha, im, wp), wp)\n if asign:\n if n == 0:\n re = mpf_sub(mpf_pi(wp), re, wp)\n else:\n re = mpf_neg(re)\n if not bsign and n == 0:\n im = mpf_neg(im)\n if bsign and n == 1:\n im = mpf_neg(im)\n re = normalize(re[0], re[1], re[2], re[3], prec, rnd)\n im = normalize(im[0], im[1], im[2], im[3], prec, rnd)\n return re, im\n\ndef mpc_acos(z, prec, rnd=round_fast):\n return acos_asin(z, prec, rnd, 0)\n\ndef mpc_asin(z, prec, rnd=round_fast):\n return acos_asin(z, prec, rnd, 1)\n\ndef mpc_asinh(z, prec, rnd=round_fast):\n # asinh(z) = I * asin(-I z)\n a, b = z\n a, b = mpc_asin((b, mpf_neg(a)), prec, rnd)\n return mpf_neg(b), a\n\ndef mpc_acosh(z, prec, rnd=round_fast):\n # acosh(z) = -I * acos(z) for Im(acos(z)) <= 0\n # +I * acos(z) otherwise\n a, b = mpc_acos(z, prec, rnd)\n if b[0] or b == fzero:\n return mpf_neg(b), a\n else:\n return b, mpf_neg(a)\n\ndef mpc_atanh(z, prec, rnd=round_fast):\n # atanh(z) = (log(1+z)-log(1-z))/2\n wp = prec + 15\n a = mpc_add(z, mpc_one, wp)\n b = mpc_sub(mpc_one, z, wp)\n a = mpc_log(a, wp)\n b = mpc_log(b, wp)\n v = mpc_shift(mpc_sub(a, b, wp), -1)\n # Subtraction at infinity gives correct imaginary part but\n # wrong real part (should be zero)\n if v[0] == fnan and mpc_is_inf(z):\n v = (fzero, v[1])\n return v\n\ndef mpc_fibonacci(z, prec, rnd=round_fast):\n re, im = z\n if im == fzero:\n return (mpf_fibonacci(re, prec, rnd), fzero)\n size = max(abs(re[2]+re[3]), abs(re[2]+re[3]))\n wp = prec + size + 20\n a = mpf_phi(wp)\n b = mpf_add(mpf_shift(a, 1), fnone, wp)\n u = mpc_pow((a, fzero), z, wp)\n v = mpc_cos_pi(z, wp)\n v = mpc_div(v, u, wp)\n u = mpc_sub(u, v, wp)\n u = mpc_div_mpf(u, b, prec, rnd)\n return u\n\ndef mpf_expj(x, prec, rnd='f'):\n raise ComplexResult\n\ndef mpc_expj(z, prec, rnd='f'):\n re, im = z\n if im == fzero:\n return mpf_cos_sin(re, prec, rnd)\n if re == fzero:\n return mpf_exp(mpf_neg(im), prec, rnd), fzero\n ey = mpf_exp(mpf_neg(im), prec+10)\n c, s = mpf_cos_sin(re, prec+10)\n re = mpf_mul(ey, c, prec, rnd)\n im = mpf_mul(ey, s, prec, rnd)\n return re, im\n\ndef mpf_expjpi(x, prec, rnd='f'):\n raise ComplexResult\n\ndef mpc_expjpi(z, prec, rnd='f'):\n re, im = z\n if im == fzero:\n return mpf_cos_sin_pi(re, prec, rnd)\n sign, man, exp, bc = im\n wp = prec+10\n if man:\n wp += max(0, exp+bc)\n im = mpf_neg(mpf_mul(mpf_pi(wp), im, wp))\n if re == fzero:\n return mpf_exp(im, prec, rnd), fzero\n ey = mpf_exp(im, prec+10)\n c, s = mpf_cos_sin_pi(re, prec+10)\n re = mpf_mul(ey, c, prec, rnd)\n im = mpf_mul(ey, s, prec, rnd)\n return re, im\n\n\nif BACKEND == 'sage':\n try:\n import sage.libs.mpmath.ext_libmp as _lbmp\n mpc_exp = _lbmp.mpc_exp\n mpc_sqrt = _lbmp.mpc_sqrt\n except (ImportError, AttributeError):\n print(\"Warning: Sage imports in libmpc failed\")\n", "meta": {"hexsha": "d9c309864fe2f68a885198b7b52deead61f96073", "size": 26869, "ext": "py", "lang": "Python", "max_stars_repo_path": "CodeIA/venv/Lib/site-packages/mpmath/libmp/libmpc.py", "max_stars_repo_name": "Finasty-lab/IA-Python", "max_stars_repo_head_hexsha": "286113504906fec11a5aa5fd1d12e38536b1c859", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 445, "max_stars_repo_stars_event_min_datetime": "2019-01-26T13:50:26.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-18T05:17:38.000Z", "max_issues_repo_path": "Library/lib/python3.7/site-packages/mpmath/libmp/libmpc.py", "max_issues_repo_name": "gengyong/Carnets", "max_issues_repo_head_hexsha": "8930a14f69360d4db115a85ff9e0f6efa80fa2e7", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 242, "max_issues_repo_issues_event_min_datetime": "2019-01-29T15:48:27.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T22:09:21.000Z", "max_forks_repo_path": "Library/lib/python3.7/site-packages/mpmath/libmp/libmpc.py", "max_forks_repo_name": "gengyong/Carnets", "max_forks_repo_head_hexsha": "8930a14f69360d4db115a85ff9e0f6efa80fa2e7", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 31, "max_forks_repo_forks_event_min_datetime": "2019-03-10T09:51:27.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-14T23:11:12.000Z", "avg_line_length": 32.1399521531, "max_line_length": 80, "alphanum_fraction": 0.5440470431, "include": true, "reason": "import sage", "num_tokens": 9514, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583269943353744, "lm_q2_score": 0.3486451488696663, "lm_q1q2_score": 0.19465799805800993}} {"text": "# coding: utf-8\n# Copyright (c) Materials Virtual Lab\n# Distributed under the terms of the BSD License.\n\nimport re\nimport os\nimport glob\nimport itertools\nimport subprocess\nfrom collections import OrderedDict\n\nimport numpy as np\nimport pandas as pd\nfrom monty.io import zopen\nfrom monty.os.path import which\nfrom monty.tempfile import ScratchDir\nfrom monty.serialization import loadfn\nfrom pymatgen import Structure, Lattice, Element\nfrom pymatgen.core import units\n\nfrom mlearn.potentials import Potential\nfrom mlearn.data import pool_from, convert_docs\nfrom mlearn.potentials.lammps.calcs import EnergyForceStress\n\nmodule_dir = os.path.dirname(__file__)\nNNinput_params = loadfn(os.path.join(module_dir, 'params', 'NNinput.json'))\n\nclass NNPotential(Potential):\n \"\"\"\n This class implements Neural Network Potential.\n \"\"\"\n bohr_to_angstrom = units.bohr_to_angstrom\n eV_to_Ha = units.eV_to_Ha\n pair_style = 'pair_style nnp dir \"./\" showew no showewsum 0 ' \\\n 'maxew 10000000 resetew yes cflength 1.8897261328 cfenergy 0.0367493254'\n pair_coeff = 'pair_coeff * * {}'\n def __init__(self, name=None, param=None, weight_param=None, scaling_param=None):\n \"\"\"\n\n Args:\n name (str): Name of force field.\n \"\"\"\n self.name = name if name else \"NNPotential\"\n self.specie = None\n self.weights = []\n self.bs = []\n self.atom_energy = None\n self.normalized_nodes = None\n self.epochs = None\n self.param = param if param else {}\n self.weight_param = weight_param if weight_param else None\n self.scaling_param = scaling_param if scaling_param else None\n self.fitted = False\n\n def _line_up(self, structure, energy, forces, virial_stress):\n \"\"\"\n Convert input structure, energy, forces, virial_stress to\n proper configuration format for RuNNer usage. Note that\n RuNNer takes bohr as length unit and Hatree as energy unit.\n\n Args:\n structure (Structure): Pymatgen Structure object.\n energy (float): DFT-calculated energy of the system.\n forces (list): The forces should have dimension\n (num_atoms, 3).\n virial_stress (list): stress should has 6 distinct\n elements arranged in order [xx, yy, zz, xy, yz, xz].\n\n Returns:\n \"\"\"\n if len(structure.symbol_set) > 1:\n raise ValueError(\"Structure is not unary.\")\n\n inputs = OrderedDict(Size=structure.num_sites, \\\n SuperCell=structure.lattice, \\\n AtomData=(structure, forces), \\\n Energy=energy, \\\n Stress=virial_stress)\n\n lines = ['begin']\n\n if 'SuperCell' in inputs:\n bohr_matrix = inputs['SuperCell'].matrix / self.bohr_to_angstrom\n for vec in bohr_matrix:\n lines.append('lattice {:>15.6f}{:>15.6f}{:>15.6f}'.format(*vec))\n if 'AtomData' in inputs:\n format_float = \\\n 'atom{:>16.9f}{:>16.9f}{:>16.9f}{:>4s}{:>15.9f}{:>15.9f}{:>15.9f}{:>15.9f}{:>15.9f}'\n for i, (site, force) in enumerate(zip(structure, forces)):\n lines.append(format_float.format(*site.coords / self.bohr_to_angstrom, \\\n site.species_string, 0.0, 0.0,\n *np.array(force) * self.eV_to_Ha * self.bohr_to_angstrom))\n if 'Energy' in inputs:\n lines.append('energy {:f}'.format(energy * self.eV_to_Ha))\n\n lines.append('charge {:f}'.format(structure.charge))\n lines.append('end')\n\n return '\\n'.join(lines)\n\n def write_cfgs(self, filename, cfg_pool):\n\n lines = []\n for dataset in cfg_pool:\n if isinstance(dataset['structure'], dict):\n structure = Structure.from_dict(dataset['structure'])\n else:\n structure = dataset['structure']\n energy = dataset['outputs']['energy']\n forces = dataset['outputs']['forces']\n virial_stress = dataset['outputs']['virial_stress']\n\n lines.append(self._line_up(structure, energy, forces, virial_stress))\n\n # dist = np.unique(structure.distance_matrix.ravel())[1]\n # if self.shortest_distance > dist:\n # self.shortest_distance = dist\n\n self.specie = Element(structure.symbol_set[0])\n\n with open(filename, 'w') as f:\n f.write('\\n'.join(lines))\n\n return filename\n\n def write_input(self, **kwargs):\n \"\"\"\n Write input.nn file to train the Neural Network Potential.\n\n Args:\n atom_energy (float): Atomic reference energy.\n\n kwargs:\n General nnp settings:\n atom_energy (None): Free atom reference energy.\n cutoff_type (int): Type of cutoff function. Default to 1\n (i.e., cosine function).\n scale_features (int): Determine the method to scale the\n symmetry function.\n 0: no scaling.\n 1: scale_symmetry_functions.\n 2: center_symmetry_functions.\n 3. scale_symmetry_functions_sigma.\n scale_min_short (float): Minimum value for scaling.\n Default to 0.0.\n scale_max_short (float): Maximum value for scaling.\n Default to 1.\n hidden_layers (list): List of the numbers of\n nodes in each hidden layer.\n activations (str): Activation function for each hidden layer.\n 't': tanh, 's': logistic, 'p': softplus.\n normalize_nodes (boolean): Whether to normalize input of nodes.\n\n Additional settings for training:\n epoch (int): Number of training epochs.\n updater_type (int): Weight update method\n 0: gradient Descent, 1: Kalman filter.\n parallel_mode (int): Training parallelization used.\n Default to serial mode.\n update_strategy (int): Update strategy.\n 0: combined, 1: per-element.\n selection_mode (int): Update candidate selection mode.\n 0: random, 1: sort, 2: threshold\n test_fraction (float): Fraction of structures kept for\n testing.\n force_weight (float): Weight of force updates relative\n to energy updates. Default to 10.0\n short_energy_fraction (float): Fraction of energy updates\n per epoch. Default to 1.0.\n short_force_fraction (float): Fraction of force updates\n per epoch. Default to 0.02315.\n short_energy_error_threshold (float): RMSE threshold for\n energy update candidates. Default to 0.0.\n short_force_error_threshold (float): RMSE threshold for\n force update candidates. Default to 1.0.\n rmse_threshold_trials (int): Maximum number of RMSE\n threshold trials. Default to 3.\n weights_min (float): Minimum value for initial random\n weights. Default to -1.\n weights_max (float): Maximum value for initial random\n weights. Default to 1.\n write_trainpoints (int): Write energy comparison every\n this many epochs. Default to 1.\n write_trainforces (int): Write force comparison every\n this many epochs. Default to 1.\n write_weights_epoch (int): Write weights every this many\n epochs. Default to 1.\n write_neuronstats (int): Write neuron statistics every\n this many epochs. Default to 1.\n\n # Kalman Filter\n kalman_type (int): Kalman filter type. Default to 0.\n kalman_epsilon (float): General Kalman filter parameter\n epsilon. Default to 0.01.\n kalman_q0 (float): General Kalman filter parameter q0.\n Default to 0.01.\n kalman_qtau (float): General Kalman filter parameter\n qtau. Default to 2.302.\n kalman_qmin (float): General Kalman filter parameter qmin.\n Default to 1e-6.\n kalman_eta (float): Standard Kalman filter parameter eta.\n Default to 0.01.\n kalman_etatau (float): Standard Kalman filter parameter\n etatau. Defaul to 2.302.\n kalman_etamax (float): Standard Kalman filter parameter\n etamax. Default to 1.0.\n\n Symmetry functions:\n r_cut (float): Cutoff distance (unit: Å).\n r_etas (numpy.array): η in radial function.\n r_shift (numpy.array): Rs in radial function.\n a_etas (numpy.array): η in angular function.\n zetas (numpy.array): ζ in angular function.\n lambdas (numpy.array): λ in angular function. Default to (1, -1).\n \"\"\"\n filename = 'input.nn'\n\n head_formatter = '{:<32s}{value}'\n type2_format = 'symfunction_short {central_atom} 2 {neighbor_atom}' \\\n ' {r_eta:.7f} {rs:.7f} {rcut:.7f}'\n type3_format = 'symfunction_short {central_atom} 3 {neighbor_atom1} ' \\\n '{neighbor_atom2} {a_eta:.7f} {lambd:>2d} {zeta:.7f} '\\\n '{rcut:.7f}'\n\n specie = self.specie.name\n lines = [head_formatter.format('number_of_elements', value=1),\n head_formatter.format('elements', value=specie)]\n\n PARAMS = {'general': ['cutoff_type', 'scale_features', 'scale_min_short',\n 'scale_max_short', 'hidden_layers'],\n 'additional': ['epochs', 'updater_type', 'parallel_mode',\n 'update_strategy', 'selection_mode', 'random_seed',\n 'test_fraction', 'force_weight', 'short_energy_fraction',\n 'short_force_fraction', 'short_energy_error_threshold',\n 'short_force_error_threshold', 'rmse_threshold_trials',\n 'weights_min', 'weights_max', 'write_trainpoints',\n 'write_trainforces', 'write_weights_epoch',\n 'write_neuronstats', 'kalman_type', 'kalman_epsilon',\n 'kalman_q0', 'kalman_qtau', 'kalman_qmin', 'kalman_eta',\n 'kalman_etatau', 'kalman_etamax']}\n if self.fitted:\n if self.param.get('atom_energy'):\n lines.append(head_formatter.format('atom_energy',\n value=' '.join([specie, str(self.param.get('atom_energy'))])))\n for tag in PARAMS.get('general'):\n if tag == 'scale_features':\n lines.append(NNinput_params.get('general').get(tag).get(self.param.get(tag)))\n elif tag == 'hidden_layers':\n layers = self.param.get('hidden_layers')\n activations = self.param.get('activations')\n lines.append(head_formatter.format('global_hidden_layers_short',\n value=len(layers)))\n lines.append(head_formatter.format('global_nodes_short',\n value=' '.join([str(i) for i in layers])))\n lines.append(head_formatter.format('global_activation_short',\n value=' '.join([activations] \\\n * len(layers) + ['l'])))\n else:\n lines.append(head_formatter.format(tag, value=self.param.get(tag)))\n if self.normalized_nodes:\n lines.append('normalize_nodes')\n\n for tag in PARAMS.get('additional'):\n lines.append(head_formatter.format(tag, value=self.param.get(tag)))\n lines.append('use_short_forces')\n\n central_atom, neighbor_atom1, neighbor_atom2 = specie, specie, specie\n\n r_cut = self.param.get('r_cut')\n r_cut /= self.bohr_to_angstrom\n r_shift = np.array(self.param.get('r_shift'))\n r_shift /= self.bohr_to_angstrom\n\n for r_eta, rs in itertools.product(self.param.get('r_etas'), r_shift):\n lines.append(type2_format.format(central_atom=central_atom,\n neighbor_atom=neighbor_atom1,\n r_eta=r_eta, rs=rs, rcut=r_cut))\n\n for a_eta, lambd, zeta in itertools.product(self.param.get('a_etas'),\n self.param.get('lambdas'), \\\n self.param.get('zetas')):\n lines.append(type3_format.format(central_atom=central_atom,\n neighbor_atom1=neighbor_atom1,\n neighbor_atom2=neighbor_atom2,\n a_eta=a_eta, lambd=lambd,\n zeta=zeta, rcut=r_cut))\n else:\n if kwargs.get('atom_energy'):\n lines.append(head_formatter.format('atom_energy',\n value=' '.join([specie, str(kwargs.get('atom_energy'))])))\n self.param.update({'atom_energy': kwargs.get('atom_energy')})\n for tag in PARAMS.get('general'):\n if tag == 'scale_features':\n value = kwargs.get(tag) if kwargs.get(tag) is not None else '1'\n lines.append(NNinput_params.get('general').get(tag).get(value))\n self.param.update({tag: value})\n elif tag == 'hidden_layers':\n layers = kwargs.get(tag) if kwargs.get(tag) is not None \\\n else NNinput_params.get('general').get(tag)\n self.param.update({tag: layers})\n activations = kwargs.get('activations') if kwargs.get('activations') \\\n is not None else NNinput_params.get('general').get('activations')\n self.param.update({'activations': activations})\n lines.append(head_formatter.format('global_hidden_layers_short',\n value=len(layers)))\n lines.append(head_formatter.format('global_nodes_short',\n value=' '.join([str(i) for i in layers])))\n lines.append(head_formatter.format('global_activation_short',\n value=' '.join([activations] * len(layers) \\\n + ['l'])))\n else:\n value = kwargs.get(tag) if kwargs.get(tag) is not None \\\n else NNinput_params.get('general').get(tag)\n lines.append(head_formatter.format(tag, value=value))\n self.param.update({tag: value})\n if kwargs.get('normalize_nodes'):\n lines.append('normalize_nodes')\n self.param.update({'normalize_nodes': True})\n\n for tag in PARAMS.get('additional'):\n value = kwargs.get(tag) if kwargs.get(tag) is not None \\\n else NNinput_params.get('additional').get(tag)\n lines.append(head_formatter.format(tag, value=value))\n self.param.update({tag: value})\n lines.append('use_short_forces')\n\n central_atom, neighbor_atom1, neighbor_atom2 = specie, specie, specie\n\n r_cut = kwargs.get('r_cut') if kwargs.get('r_cut') is not None \\\n else NNinput_params.get('symmetry_function').get('r_cut')\n self.param.update({'r_cut': r_cut})\n r_cut /= self.bohr_to_angstrom\n r_etas = kwargs.get('r_etas') if kwargs.get('r_etas') is not None \\\n else NNinput_params.get('symmetry_function').get('r_etas')\n self.param.update({'r_etas': r_etas})\n r_shift = kwargs.get('r_shift') if kwargs.get('r_shift') is not None \\\n else NNinput_params.get('symmetry_function').get('r_shift')\n self.param.update({'r_shift': r_shift})\n r_shift = np.array(r_shift)\n r_shift /= self.bohr_to_angstrom\n a_etas = kwargs.get('a_etas') if kwargs.get('a_etas') is not None \\\n else NNinput_params.get('symmetry_function').get('a_etas')\n self.param.update({'a_etas': a_etas})\n zetas = kwargs.get('zetas') if kwargs.get('zetas') is not None \\\n else NNinput_params.get('symmetry_function').get('zetas')\n self.param.update({'zetas': zetas})\n lambdas= kwargs.get('lambdas') if kwargs.get('lambdas') is not None \\\n else NNinput_params.get('symmetry_function').get('lambdas')\n self.param.update({'lambdas': lambdas})\n\n for r_eta, rs in itertools.product(r_etas, r_shift):\n lines.append(type2_format.format(central_atom=central_atom,\n neighbor_atom=neighbor_atom1,\n r_eta=r_eta, rs=rs, rcut=r_cut))\n\n for a_eta, lambd, zeta in itertools.product(a_etas, lambdas, zetas):\n lines.append(type3_format.format(central_atom=central_atom,\n neighbor_atom1=neighbor_atom1,\n neighbor_atom2=neighbor_atom2,\n a_eta=a_eta, lambd=lambd,\n zeta=zeta, rcut=r_cut))\n\n self.num_symm_functions = len(list(itertools.product(r_etas, r_shift))) \\\n + len(list(itertools.product(a_etas, lambdas, zetas)))\n self.layer_sizes = [self.num_symm_functions] + self.param.get('hidden_layers')\n\n with open(filename, 'w') as f:\n f.write('\\n'.join(lines))\n\n self.fitted = True\n\n return filename\n\n def load_input(self, filename='input.nn'):\n \"\"\"\n Load input file from trained Neural Network Potential.\n\n Args:\n filename (str): The input filename.\n \"\"\"\n PARAMS = {'general': ['cutoff_type', 'scale_features', 'scale_min_short',\n 'scale_max_short', 'hidden_layers'],\n 'additional': ['epochs', 'updater_type', 'parallel_mode',\n 'update_strategy', 'selection_mode', 'random_seed',\n 'test_fraction', 'force_weight', 'short_energy_fraction',\n 'short_force_fraction', 'short_energy_error_threshold',\n 'short_force_error_threshold', 'rmse_threshold_trials',\n 'weights_min', 'weights_max', 'write_trainpoints',\n 'write_trainforces', 'write_weights_epoch',\n 'write_neuronstats', 'kalman_type', 'kalman_epsilon',\n 'kalman_q0', 'kalman_qtau', 'kalman_qmin', 'kalman_eta',\n 'kalman_etatau', 'kalman_etamax']}\n str_formatify = lambda string: float(string) if '.' in string or 'e' in string \\\n else int(string)\n param = {}\n with open(filename, 'r') as f:\n lines = f.readlines()\n df = pd.DataFrame([line.split() for line in lines if \"#\" not in line])\n specie = Element(np.array(df[df[0] == 'elements'][1])[0])\n self.specie = specie\n self.suffix = '{:0>3d}'.format(specie.Z)\n\n atom_energy = float(np.array(df[df[0] == 'atom_energy'][2])[0])\n param.update({'atom_energy': atom_energy})\n for tag in PARAMS.get('general'):\n if tag == 'scale_features':\n scale_features = '1' \\\n if len(df[df[0] == 'scale_symmetry_functions']) != 0 else 0\n param.update({'scale_features': scale_features})\n elif tag == 'hidden_layers':\n hidden_layers = [int(neuron) for neuron in np.array(df[df[0] \\\n == 'global_nodes_short'])[0][1:] if neuron]\n param.update({'hidden_layers': hidden_layers})\n activations = np.array(df[df[0] == 'global_activation_short'])[0][1]\n param.update({'activations': activations})\n else:\n value = str_formatify(np.array(df[df[0] == tag])[0][1])\n param.update({tag: value})\n if len(df[df[0] == 'normalize_nodes']) != 0:\n param.update({'normalize_nodes': True})\n\n for tag in PARAMS.get('additional'):\n value = str_formatify(np.array(df[df[0] == tag])[0][1])\n param.update({tag: value})\n\n r_cut = np.array(df[(df[0] == 'symfunction_short') & (df[2] == '2')][6],\n dtype=np.float)[0]\n r_cut = float('{:.1f}'.format(r_cut * units.bohr_to_angstrom))\n param.update({'r_cut': r_cut})\n r_etas = np.array(np.unique(df[(df[0] == 'symfunction_short') & (df[2] == '2')][4]),\n dtype=np.float).tolist()\n param.update({'r_etas': r_etas})\n r_shift = np.array(np.unique(df[(df[0] == 'symfunction_short') & (df[2] == '2')][5]),\n dtype=np.float)\n r_shift = [float('{:.1f}'.format(r * units.bohr_to_angstrom)) for r in r_shift]\n param.update({'r_shift': r_shift})\n a_etas = np.array(np.unique(df[(df[0] == 'symfunction_short') & (df[2] == '3')][5]),\n dtype=np.float).tolist()\n param.update({'a_etas': a_etas})\n lambdas = np.array(np.unique(df[(df[0] == 'symfunction_short') & (df[2] == '3')][6]),\n dtype=np.int).tolist()\n param.update({'lambdas': lambdas})\n zetas = np.array(np.unique(df[(df[0] == 'symfunction_short') & (df[2] == '3')][7]),\n dtype=np.float).tolist()\n param.update({'zetas': zetas})\n self.num_symm_functions = len(list(itertools.product(r_etas, r_shift))) \\\n + len(list(itertools.product(a_etas, lambdas, zetas)))\n self.layer_sizes = [self.num_symm_functions] + hidden_layers\n self.param = param\n\n def load_weights(self, weights_filename):\n \"\"\"\n Load weights file of trained Neural Network Potential.\n\n Args\n weights_filename (str): The weights file.\n \"\"\"\n with open(weights_filename) as f:\n weights_lines = f.readlines()\n\n weight_param = pd.DataFrame([line.split() for line in weights_lines \\\n if \"#\" not in line])\n weight_param.columns = ['value', 'type', 'index', 'start_layer',\n 'start_neuron', 'end_layer', 'end_neuron']\n\n for layer_index in range(1, len(self.layer_sizes)):\n weights_group = weight_param[(weight_param['start_layer'] == str(layer_index - 1)) \\\n & (weight_param['end_layer'] == str(layer_index))]\n\n weights = np.reshape(np.array(weights_group['value'], dtype=np.float),\n (self.layer_sizes[layer_index - 1],\n self.layer_sizes[layer_index]))\n self.weights.append(weights)\n\n bs_group = weight_param[(weight_param['type'] == 'b') &\n (weight_param['start_layer'] == str(layer_index))]\n bs = np.array(bs_group['value'], dtype=np.float)\n self.bs.append(bs)\n\n self.weight_param = weight_param\n\n def load_scaler(self, scaling_filename):\n \"\"\"\n Load scaling info of trained Neural Network Potential.\n\n Args:\n scaling_filename (str): The scaling file.\n \"\"\"\n with open(scaling_filename) as f:\n scaling_lines = f.readlines()\n scaling_param = pd.DataFrame([line.split() for line in scaling_lines \\\n if '#' not in line])\n scaling_param.column = ['e_index', 'sf_index', 'sf_min', 'sf_max', \\\n 'sf_mean', 'sf_sigma']\n self.scaling_param = scaling_param\n\n def read_cfgs(self, filename='output.data'):\n \"\"\"\n Args:\n filename (str): The configuration file to be read.\n \"\"\"\n data_pool = []\n with zopen(filename, 'rt') as f:\n lines = f.read()\n\n block_pattern = re.compile('begin\\n(.*?)end', re.S)\n lattice_pattern = re.compile('lattice(.*?)\\n')\n position_pattern = re.compile('atom(.*?)\\n')\n energy_pattern = re.compile('energy(.*?)\\n')\n\n for block in block_pattern.findall(lines):\n d = {'outputs':{}}\n lattice_str = lattice_pattern.findall(block)\n lattice = Lattice(np.array([latt.split() for latt in lattice_str],\n dtype=np.float) * self.bohr_to_angstrom)\n position_str = position_pattern.findall(block)\n positions = pd.DataFrame([pos.split() for pos in position_str])\n positions.columns = \\\n ['x', 'y', 'z', 'specie', 'charge', 'atomic_energy', 'fx', 'fy', 'fz']\n coords = np.array(positions.loc[:, ['x', 'y', 'z']], dtype=np.float)\n coords = coords * self.bohr_to_angstrom\n species = np.array(positions['specie'])\n forces = np.array(positions.loc[:, ['fx', 'fy', 'fz']], dtype=np.float)\n forces = forces / self.eV_to_Ha / self.bohr_to_angstrom\n energy_str = energy_pattern.findall(block)[0]\n energy = float(energy_str.lstrip()) / self.eV_to_Ha\n struct = Structure(lattice=lattice, species=species, coords=coords,\n coords_are_cartesian=True)\n d['structure'] = struct.as_dict()\n d['outputs']['energy'] = energy\n d['outputs']['forces'] = forces\n d['num_atoms'] = len(struct)\n\n data_pool.append(d)\n _, df = convert_docs(docs=data_pool)\n return data_pool, df\n\n def write_param(self):\n \"\"\"\n Write optimized weights file to perform energy and force prediction.\n \"\"\"\n if self.weight_param is None or self.scaling_param is None:\n raise RuntimeError(\"The parameters should be provided.\")\n weights_filename = '.'.join(['weights', self.suffix, 'data'])\n weight_formatter = '{:>18s}{:>2s}{:>10s}{:>6s}{:>6s}{:>6s}{:>6s}'\n bias_formatter = '{:>18s}{:>2s}{:>10s}{:>6s}{:>6}'\n lines = []\n for i in range(self.weight_param.shape[0]):\n if self.weight_param.iloc[i]['type'] == 'a':\n lines.append(weight_formatter.format(*self.weight_param.iloc[i]))\n else:\n lines.append(bias_formatter.format(*self.weight_param.iloc[i]))\n\n with open(weights_filename, 'w') as f:\n f.writelines('\\n'.join(lines))\n\n scaling_filename = 'scaling.data'\n scaling_formatter = '{:>4s}{:>5s} {:>22s} {:>22s} {:>22s} {:.>22s}'\n scaling_lines = []\n for i in range(self.num_symm_functions):\n scaling_lines.append(scaling_formatter.format(*self.scaling_param.iloc[i]))\n with open(scaling_filename, 'w') as f:\n f.writelines('\\n'.join(scaling_lines))\n\n self.write_input()\n\n ff_settings = [self.pair_style, self.pair_coeff.format(self.param.get('r_cut') + 1e-2)]\n\n return ff_settings\n\n def train(self, train_structures, energies=None, forces=None, stresses=None,\n **kwargs):\n \"\"\"\n Training data with moment tensor method.\n\n Args:\n train_structures ([Structure]): The list of Pymatgen Structure object.\n energies ([float]): The list of total energies of each structure\n in structures list.\n energies ([float]): List of total energies of each structure in\n structures list.\n forces ([np.array]): List of (m, 3) forces array of each structure\n with m atoms in structures list. m can be varied with each\n single structure case.\n stresses (list): List of (6, ) virial stresses of each\n structure in structures list.\n kwargs: Parameters in write_input method.\n \"\"\"\n if not which('nnp-train'):\n raise RuntimeError(\"NNP Trainer has not been found.\")\n\n train_pool = pool_from(train_structures, energies, forces, stresses)\n atoms_filename = 'input.data'\n\n with ScratchDir('.'):\n atoms_filename = self.write_cfgs(filename=atoms_filename, cfg_pool=train_pool)\n output = 'training_output'\n\n input_filename = self.write_input(**kwargs)\n p_scaling = subprocess.Popen(['nnp-scaling', input_filename])\n stdout = p_scaling.communicate()[0]\n\n p_train = subprocess.Popen(['nnp-train', input_filename],\n stdout=open(output, 'w'))\n stdout = p_train.communicate()[0]\n\n rc = p_train.returncode\n if rc != 0:\n error_msg = 'RuNNer exited with return code %d' % rc\n msg = stdout.decode(\"utf-8\").split('\\n')[:-1]\n try:\n error_line = [i for i, m in enumerate(msg)\n if m.startswith('ERROR')][0]\n error_msg += ', '.join([e for e in msg[error_line:]])\n except:\n error_msg += msg[-1]\n raise RuntimeError(error_msg)\n\n with zopen(output) as f:\n error_lines = f.read()\n\n energy_rmse_pattern = re.compile('ENERGY\\s*\\S*\\s*(\\S*)\\s*(\\S*).*?\\n')\n forces_rmse_pattern = re.compile('FORCES\\s*\\S*\\s*(\\S*)\\s*(\\S*).*?\\n')\n self.train_energy_rmse, self.validation_energy_rmse = \\\n np.array([line for line in energy_rmse_pattern.findall(error_lines)],\n dtype=np.float).T\n self.train_forces_rmse, self.validation_forces_rmse = \\\n np.array([line for line in forces_rmse_pattern.findall(error_lines)],\n dtype=np.float).T\n\n weights_filename_pattern = 'weights*{}.out'.format(self.param.get('epochs'))\n weights_filename = glob.glob(weights_filename_pattern)[0]\n\n self.suffix = weights_filename.split('.')[1]\n\n self.load_weights(weights_filename)\n self.load_scaler('scaling.data')\n\n return rc\n\n def evaluate(self, test_structures, ref_energies, ref_forces, ref_stresses):\n \"\"\"\n Evaluate energies, forces and stresses of structures with trained\n interatomic potentials.\n\n Args:\n test_structures ([Structure]): List of Pymatgen Structure Objects.\n ref_energies ([float]): List of DFT-calculated total energies of\n each structure in structures list.\n ref_forces ([np.array]): List of DFT-calculated (m, 3) forces of\n each structure with m atoms in structures list. m can be varied\n with each single structure case.\n ref_stresses (list): List of DFT-calculated (6, ) viriral stresses\n of each structure in structures list.\n \"\"\"\n if not which('nnp-predict'):\n raise RuntimeError(\"NNP Predictor has not been found.\")\n\n original_file = 'input.data'\n predict_file = 'output.data'\n\n predict_pool = pool_from(test_structures, ref_energies,\n ref_forces, ref_stresses)\n with ScratchDir('.'):\n _, _ = self.write_param()\n original_file = self.write_cfgs(original_file, cfg_pool=predict_pool)\n _, df_orig = self.read_cfgs(original_file)\n\n input_filename = self.write_input()\n\n dfs = []\n for data in predict_pool:\n _ = self.write_cfgs(original_file, cfg_pool=[data])\n p = subprocess.Popen(['nnp-predict', input_filename], stdout=subprocess.PIPE)\n stdout = p.communicate()[0]\n\n rc = p.returncode\n if rc != 0:\n error_msg = 'RuNNer exited with return code %d' % rc\n msg = stdout.decode(\"utf-8\").split('\\n')[:-1]\n try:\n error_line = [i for i, m in enumerate(msg)\n if m.startswith('ERROR')][0]\n error_msg += ', '.join([e for e in msg[error_line:]])\n except:\n error_msg += msg[-1]\n raise RuntimeError(error_msg)\n\n _, df = self.read_cfgs(predict_file)\n dfs.append(df)\n df_predict = pd.concat(dfs, ignore_index=True)\n\n return df_orig, df_predict\n\n def predict(self, structure):\n \"\"\"\n Predict energy, forces and stresses of the structure.\n\n Args:\n structure (Structure): Pymatgen Structure object.\n\n Returns:\n energy, forces, stress\n \"\"\"\n calculator = EnergyForceStress(self)\n energy, forces, stress = calculator.calculate(structures=[structure])[0]\n return energy, forces, stress\n\n @staticmethod\n def from_config(input_filename, scaling_filename, weights_filename):\n \"\"\"\n Initialize potentials with parameters file.\n\n Args:\n input_filename (str): The file storing the input configuration of\n Neural Network Potential.\n scaling_filename (str): The file storing scaling info of\n Neural Network Potential.\n weights_filename (str): The file storing weights of\n Neural Network Potential.\n \"\"\"\n nnp = NNPotential()\n nnp.load_input(input_filename)\n nnp.load_scaler(scaling_filename)\n nnp.load_weights(weights_filename)\n nnp.fitted = True\n\n return nnp", "meta": {"hexsha": "37e2e13c039eaf615b1db56e6b0fcc77d6650308", "size": 35375, "ext": "py", "lang": "Python", "max_stars_repo_path": "mlearn/potentials/nnp.py", "max_stars_repo_name": "ruoitrau86/mlearn", "max_stars_repo_head_hexsha": "5b24690344836f53047ede409966d5dd3859098f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-05-05T05:11:56.000Z", "max_stars_repo_stars_event_max_datetime": "2020-05-05T05:11:56.000Z", "max_issues_repo_path": "mlearn/potentials/nnp.py", "max_issues_repo_name": "ruoitrau86/mlearn", "max_issues_repo_head_hexsha": "5b24690344836f53047ede409966d5dd3859098f", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "mlearn/potentials/nnp.py", "max_forks_repo_name": "ruoitrau86/mlearn", "max_forks_repo_head_hexsha": "5b24690344836f53047ede409966d5dd3859098f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 48.592032967, "max_line_length": 100, "alphanum_fraction": 0.534869258, "include": true, "reason": "import numpy", "num_tokens": 7266, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583270090337583, "lm_q2_score": 0.3486451285660856, "lm_q1q2_score": 0.1946579918464927}} {"text": "\"\"\"\nThis module contains the main class that describes an isotherm through discrete points.\n\"\"\"\n\nimport textwrap\nimport typing as t\n\nimport numpy\nimport pandas\n\nfrom pygaps import logger\nfrom pygaps.core.baseisotherm import BaseIsotherm\nfrom pygaps.units.converter_mode import c_loading\nfrom pygaps.units.converter_mode import c_material\nfrom pygaps.units.converter_mode import c_pressure\nfrom pygaps.utilities.exceptions import CalculationError\nfrom pygaps.utilities.exceptions import ParameterError\nfrom pygaps.utilities.isotherm_interpolator import IsothermInterpolator\n\n\nclass PointIsotherm(BaseIsotherm):\n \"\"\"\n Class which contains the points from an adsorption isotherm.\n\n This class is designed to be a complete description of a discrete isotherm.\n It extends the BaseIsotherm class, which contains all the description of the\n isotherm parameters, but also holds the datapoints recorded during an\n experiment or simulation.\n\n The minimum arguments required to instantiate the class, besides those\n required for the parent BaseIsotherm, is the actual data, specified either\n as `pressure` + `loading` arrays or as `isotherm_data` (a\n `pandas.DataFrame`) + keys for the columns of the dataframe which have the\n loading and the pressure data.\n\n Parameters\n ----------\n pressure : list\n Create an isotherm directly from an array. Values for pressure.\n If the ``isotherm_data`` dataframe is specified, these values are ignored.\n loading : list\n Create an isotherm directly from an array. Values for loading.\n If the ``isotherm_data`` dataframe is specified, these values are ignored.\n isotherm_data : `pandas.DataFrame`\n Pure-component adsorption isotherm data.\n pressure_key : str\n The title of the pressure data in the DataFrame provided.\n loading_key : str\n The title of the loading data in the DataFrame provided.\n branch : ['guess', ads', 'des', iterable], optional\n The branch of the isotherm. The code will automatically attempt to\n guess if there's an adsorption and desorption branch.\n The user can instead tell the framework that all points are\n part of an adsorption ('ads') or desorption ('des') curve.\n Alternatively, an iterable can be passed which contains\n detailed info for each data point if adsorption points ('False')\n or desorption points ('True'). eg: [False, False, True, True...]\n or as a column of the isotherm_data.\n material : str\n Name of the material on which the isotherm is measured.\n adsorbate : str\n Isotherm adsorbate.\n temperature : float\n Isotherm temperature.\n\n Other Parameters\n ----------------\n pressure_mode : str, optional\n The pressure mode, either 'absolute' pressure or 'relative'\n ('relative%') in the form of p/p0.\n pressure_unit : str, optional\n Unit of pressure, if applicable.\n loading_basis : str, optional\n Whether the adsorbed amount is in terms of either 'volume_gas'\n 'volume_liquid', 'molar', 'mass', or a fractional/percent basis.\n loading_unit : str, optional\n Unit in which the loading basis is expressed.\n material_basis : str, optional\n Whether the underlying material is in terms of 'per volume'\n 'per molar amount' or 'per mass' of material.\n material_unit : str, optional\n Unit in which the material basis is expressed.\n\n Notes\n -----\n This class assumes that the datapoints do not contain noise.\n Detection of adsorption/desorption branches will not work if\n data is noisy.\n\n \"\"\"\n\n _reserved_params = BaseIsotherm._reserved_params + [\n 'data_raw',\n 'l_interpolator',\n 'p_interpolator',\n 'loading_key',\n 'pressure_key',\n 'other_keys',\n ]\n\n ##########################################################\n # Instantiation and classmethods\n\n def __init__(\n self,\n pressure: t.List[float] = None,\n loading: t.List[float] = None,\n isotherm_data: pandas.DataFrame = None,\n pressure_key: str = None,\n loading_key: str = None,\n branch: t.Union[str, t.List[bool]] = 'guess',\n **other_properties\n ):\n \"\"\"\n Instantiation is done by passing the discrete data as a pandas\n DataFrame, the column keys as string as well as the parameters\n required by parent class.\n \"\"\"\n # Run base class constructor\n super().__init__(**other_properties)\n\n # Checks\n if isotherm_data is not None:\n if None in [pressure_key, loading_key]:\n raise ParameterError(\n \"Pass loading_key and pressure_key, the names of the loading and\"\n \" pressure columns in the DataFrame, to the constructor.\"\n )\n\n # Save column names\n # Name of column in the dataframe that contains adsorbed amount.\n self.loading_key = loading_key\n\n # Name of column in the dataframe that contains pressure.\n self.pressure_key = pressure_key\n\n # Pandas DataFrame that stores the data.\n columns = [self.pressure_key, self.loading_key]\n if not all(a in isotherm_data.columns for a in columns):\n raise ParameterError(\n \"Could not find columns \"\n f\"({[a for a in columns if a not in isotherm_data.columns]})\"\n \" in the adsorption DataFrame.\"\n )\n if 'branch' not in isotherm_data.columns:\n columns.append('branch')\n other_keys = [c for c in isotherm_data.columns if c not in columns]\n columns = columns + sorted(other_keys)\n self.data_raw = isotherm_data.reindex(columns=columns)\n\n elif pressure is not None or loading is not None:\n if pressure is None or loading is None:\n raise ParameterError(\n \"If you've chosen to pass loading and pressure directly as\"\n \" arrays, make sure both are specified!\"\n )\n if len(pressure) != len(loading):\n raise ParameterError(\"Pressure and loading arrays are not equal!\")\n\n # Standard column names\n self.pressure_key = 'pressure'\n self.loading_key = 'loading'\n\n # DataFrame creation\n self.data_raw = pandas.DataFrame({\n self.pressure_key: pressure,\n self.loading_key: loading\n })\n else:\n raise ParameterError(\n \"Pass either the isotherm data in a pandas.DataFrame as ``isotherm_data``\"\n \" or directly ``pressure`` and ``loading`` as arrays.\"\n )\n\n # Deal with the isotherm branches\n if isotherm_data is not None and 'branch' in isotherm_data.columns:\n pass\n elif isinstance(branch, str):\n if branch == 'guess':\n # Split the data in adsorption/desorption\n self.data_raw['branch'] = self._splitdata(self.data_raw, self.pressure_key)\n elif branch == 'ads':\n self.data_raw['branch'] = 0\n elif branch == 'des':\n self.data_raw['branch'] = 1\n else:\n raise ParameterError(\n \"Isotherm branch parameter must be 'guess ,'ads' or 'des'\"\n \" or an array of booleans.\"\n )\n else:\n try:\n self.data_raw['branch'] = branch\n except Exception as e_info:\n raise ParameterError(e_info)\n\n # The internal interpolator for loading given pressure.\n self.l_interpolator = None\n\n # The internal interpolator for pressure given loading.\n self.p_interpolator = None\n\n @classmethod\n def from_isotherm(\n cls,\n isotherm: BaseIsotherm,\n pressure: t.List[float] = None,\n loading: t.List[float] = None,\n isotherm_data: pandas.DataFrame = None,\n pressure_key: str = None,\n loading_key: str = None,\n ):\n \"\"\"\n Construct a point isotherm using a parent isotherm as the template for\n all the parameters.\n\n Parameters\n ----------\n isotherm : Isotherm\n An instance of the Isotherm parent class.\n pressure : list\n Create an isotherm directly from an array. Values for pressure.\n If the ``isotherm_data`` dataframe is specified, these values are ignored.\n loading : list\n Create an isotherm directly from an array. Values for loading.\n If the ``isotherm_data`` dataframe is specified, these values are ignored.\n isotherm_data : pandas.DataFrame\n Pure-component adsorption isotherm data.\n loading_key : str\n Column of the pandas DataFrame where the loading is stored.\n pressure_key : str\n Column of the pandas DataFrame where the pressure is stored.\n \"\"\"\n # get isotherm parameters as a dictionary\n iso_params = isotherm.to_dict()\n # add pointisotherm values to dict\n iso_params['pressure'] = pressure\n iso_params['loading'] = loading\n iso_params['isotherm_data'] = isotherm_data\n iso_params['pressure_key'] = pressure_key\n iso_params['loading_key'] = loading_key\n\n return cls(**iso_params)\n\n @classmethod\n def from_modelisotherm(\n cls,\n modelisotherm,\n pressure_points: t.List[float] = None,\n loading_points: t.List[float] = None,\n ):\n \"\"\"\n Construct a PointIsotherm from a ModelIsothem class.\n\n This class method allows for the model to be converted into\n a list of points calculated by using the model in the isotherm.\n\n Parameters\n ----------\n modelisotherm : ModelIsotherm\n The isotherm containing the model.\n pressure_points : None or List or PointIsotherm\n How the pressure points should be chosen for the resulting PointIsotherm.\n\n - If ``None``, the PointIsotherm returned has a fixed number of\n equidistant points\n - If an array, the PointIsotherm returned has points at each of the\n values of the array\n - If a PointIsotherm is passed, the values will be calculated at\n each of the pressure points in the passed isotherm. This is useful\n for comparing a model overlap with the real isotherm.\n \"\"\"\n if pressure_points is not None and loading_points is not None:\n raise ParameterError(\"\"\"Cannot specify both pressure and loading points.\"\"\")\n\n pressure = None\n loading = None\n if modelisotherm.model.calculates == \"loading\":\n # The user may request loading even if the model calculates pressure\n if loading_points is None:\n if pressure_points is None:\n pressure = modelisotherm.pressure()\n elif isinstance(pressure_points, PointIsotherm):\n pressure = pressure_points.pressure(branch=modelisotherm.branch)\n else:\n pressure = pressure_points\n loading = modelisotherm.loading_at(pressure)\n else:\n loading = loading_points\n pressure = modelisotherm.pressure_at(loading_points)\n elif modelisotherm.model.calculates == \"pressure\":\n # The user may request pressure even if the model calculates loading\n if pressure_points is None:\n if loading_points is None:\n loading = modelisotherm.loading()\n elif isinstance(loading_points, PointIsotherm):\n loading = loading_points.loading(branch=modelisotherm.branch)\n else:\n loading = loading_points\n pressure = modelisotherm.pressure_at(loading)\n else:\n pressure = pressure_points\n loading = modelisotherm.loading_at(pressure)\n\n return PointIsotherm(\n pressure=pressure,\n loading=loading,\n model_from=modelisotherm.model.name,\n **modelisotherm.to_dict()\n )\n\n ##########################################################\n # Conversion functions\n\n def convert(\n self,\n pressure_mode: str = None,\n pressure_unit: str = None,\n loading_basis: str = None,\n loading_unit: str = None,\n material_basis: str = None,\n material_unit: str = None,\n verbose: bool = False,\n ):\n \"\"\"\n Convenience function for permanently converting any isotherm\n mode/basis/units.\n\n Parameters\n ----------\n pressure_mode : {'absolute', 'relative', 'relative%'}\n The mode in which the isotherm should be converted.\n pressure_unit : str\n The unit into which the internal pressure should be converted to.\n Only makes sense if converting to absolute pressure.\n loading_basis : {'mass', 'molar', 'volume_gas', 'volume_liquid', 'percent', 'fraction'}\n The basis in which the isotherm should be converted.\n loading_unit : str\n The unit into which the internal loading should be converted to.\n material_basis : {'mass', 'molar', 'volume'}\n The basis in which the isotherm should be converted.\n material_unit : str\n The unit into which the material should be converted to.\n verbose : bool\n Print out steps taken.\n\n \"\"\"\n if pressure_mode or pressure_unit:\n self.convert_pressure(\n mode_to=pressure_mode,\n unit_to=pressure_unit,\n verbose=verbose,\n )\n\n if material_basis or material_unit:\n self.convert_material(\n basis_to=material_basis,\n unit_to=material_unit,\n verbose=verbose,\n )\n\n if loading_basis or loading_unit:\n self.convert_loading(\n basis_to=loading_basis,\n unit_to=loading_unit,\n verbose=verbose,\n )\n\n def convert_pressure(\n self,\n mode_to: str = None,\n unit_to: str = None,\n verbose: bool = False,\n ):\n \"\"\"\n Convert isotherm pressure from one unit to another\n and the pressure mode from absolute to relative.\n\n Only applicable in the case of isotherms taken below critical\n point of adsorbate.\n\n Parameters\n ----------\n mode_to : {'absolute', 'relative', 'relative%'}\n The mode in which the isotherm should be converted.\n unit_to : str\n The unit into which the internal pressure should be converted to.\n Only makes sense if converting to absolute pressure.\n verbose : bool\n Print out steps taken.\n\n \"\"\"\n if not mode_to:\n mode_to = self.pressure_mode\n\n if mode_to == self.pressure_mode and unit_to == self.pressure_unit:\n if verbose:\n logger.info(\"Mode and units are the same, no changes made.\")\n return\n\n self.data_raw[self.pressure_key] = c_pressure(\n self.data_raw[self.pressure_key],\n mode_from=self.pressure_mode,\n mode_to=mode_to,\n unit_from=self.pressure_unit,\n unit_to=unit_to,\n adsorbate=self.adsorbate,\n temp=self.temperature\n )\n\n if mode_to != self.pressure_mode:\n self.pressure_mode = mode_to\n if unit_to != self.pressure_unit and mode_to == 'absolute':\n self.pressure_unit = unit_to\n else:\n self.pressure_unit = None\n\n # Reset interpolators\n self.l_interpolator = None\n self.p_interpolator = None\n\n if verbose:\n logger.info(f\"Changed pressure to mode '{mode_to}', unit '{unit_to}'.\")\n\n def convert_loading(\n self,\n basis_to: str = None,\n unit_to: str = None,\n verbose: bool = False,\n ):\n \"\"\"\n Convert isotherm loading from one unit to another\n and the basis of the isotherm loading to be\n either 'mass', 'molar' or 'percent'/'fraction'.\n\n Parameters\n ----------\n basis_to : {'mass', 'molar', 'volume_gas', 'volume_liquid', 'percent', 'fraction'}\n The basis in which the isotherm should be converted.\n unit_to : str\n The unit into which the internal loading should be converted to.\n verbose : bool\n Print out steps taken.\n\n \"\"\"\n if not basis_to:\n basis_to = self.loading_basis\n\n if basis_to == self.loading_basis and unit_to == self.loading_unit:\n if verbose:\n logger.info(\"Basis and units are the same, no changes made.\")\n return\n\n if self.loading_basis in ['percent', 'fraction']:\n # TODO this is\n if basis_to == self.loading_basis and unit_to != self.loading_unit:\n if verbose:\n logger.info(\"There are no loading units in this mode.\")\n return\n\n self.data_raw[self.loading_key] = c_loading(\n self.data_raw[self.loading_key],\n basis_from=self.loading_basis,\n basis_to=basis_to,\n unit_from=self.loading_unit,\n unit_to=unit_to,\n adsorbate=self.adsorbate,\n temp=self.temperature,\n basis_material=self.material_basis,\n unit_material=self.material_unit,\n )\n\n if basis_to != self.loading_basis:\n self.loading_basis = basis_to\n if basis_to in ['percent', 'fraction']:\n self.loading_unit = None\n else:\n self.loading_unit = unit_to\n\n # Reset interpolators\n self.l_interpolator = None\n self.p_interpolator = None\n\n if verbose:\n logger.info(f\"Changed loading to basis '{basis_to}', unit '{unit_to}'.\")\n\n def convert_material(\n self,\n basis_to: str = None,\n unit_to: str = None,\n verbose: bool = False,\n ):\n \"\"\"\n Convert the material of the isotherm from one unit to another and the\n basis of the isotherm loading to be either 'per mass' or 'per volume' or\n 'per mole' of material.\n\n Only applicable to materials that have been loaded in memory with a\n 'density' or 'molar mass' property respectively.\n\n Parameters\n ----------\n basis : {'mass', 'molar', 'volume'}\n The basis in which the isotherm should be converted.\n unit_to : str\n The unit into which the material should be converted to.\n verbose : bool\n Print out steps taken.\n\n \"\"\"\n if not basis_to:\n basis_to = self.material_basis\n\n if basis_to == self.material_basis and unit_to == self.material_unit:\n if verbose:\n logger.info(\"Basis and units are the same, no changes made.\")\n return\n\n if (\n self.loading_basis in ['percent', 'fraction'] and basis_to == self.material_basis\n and unit_to != self.material_unit\n ):\n # We \"virtually\" change the unit without any conversion\n self.material_unit = unit_to\n if verbose:\n logger.info(\"There are no material units in this mode.\")\n return\n\n self.data_raw[self.loading_key] = c_material(\n self.data_raw[self.loading_key],\n basis_from=self.material_basis,\n basis_to=basis_to,\n unit_from=self.material_unit,\n unit_to=unit_to,\n material=self.material\n )\n\n # A special case is when conversion is performed from\n # a \"fractional\" basis to another \"fractional\" basis.\n # Here, the loading must be simultaneously converted.\n # e.g.: wt% = g/g -> cm3/cm3 = vol%\n if self.loading_basis in ['percent', 'fraction']:\n if basis_to == 'volume':\n _basis_to = 'volume_liquid'\n else:\n _basis_to = basis_to\n if self.material_basis == 'volume':\n _basis_from = 'volume_liquid'\n else:\n _basis_from = self.material_basis\n self.data_raw[self.loading_key] = c_loading(\n self.data_raw[self.loading_key],\n basis_from=_basis_from,\n basis_to=_basis_to,\n unit_from=self.material_unit,\n unit_to=unit_to,\n adsorbate=self.adsorbate,\n temp=self.temperature,\n )\n if verbose:\n logger.info(f\"Changed loading to basis '{basis_to}', unit '{unit_to}'.\")\n\n if unit_to != self.material_unit:\n self.material_unit = unit_to\n if basis_to != self.material_basis:\n self.material_basis = basis_to\n\n # Reset interpolators\n self.l_interpolator = None\n self.p_interpolator = None\n\n if verbose:\n logger.info(f\"Changed material to basis '{basis_to}', unit '{unit_to}'.\")\n\n ###########################################################\n # Info functions\n\n def print_info(self, **plot_iso_args):\n \"\"\"\n Print a short summary of all the isotherm parameters and a graph.\n\n Parameters\n ----------\n show : bool, optional\n Specifies if the graph is shown automatically or not.\n\n Other Parameters\n ----------------\n plot_iso_args : dict\n options to be passed to pygaps.plot_iso()\n\n Returns\n -------\n axes : matplotlib.axes.Axes or numpy.ndarray of them\n\n \"\"\"\n print(self)\n return self.plot(**plot_iso_args)\n\n def plot(self, **plot_iso_args):\n \"\"\"\n Plot the isotherm using pygaps.plot_iso().\n\n Parameters\n ----------\n show : bool, optional\n Specifies if the graph is shown automatically or not.\n\n Other Parameters\n ----------------\n plot_iso_args : dict\n options to be passed to pygaps.plot_iso()\n\n Returns\n -------\n axes : matplotlib.axes.Axes or numpy.ndarray of them\n\n \"\"\"\n plot_dict = dict(\n y2_data=self.other_keys[0] if self.other_keys else None,\n material_basis=self.material_basis,\n material_unit=self.material_unit,\n loading_basis=self.loading_basis,\n loading_unit=self.loading_unit,\n pressure_unit=self.pressure_unit,\n pressure_mode=self.pressure_mode,\n )\n plot_dict.update(plot_iso_args)\n\n from pygaps.graphing.isotherm_graphs import plot_iso\n return plot_iso(self, **plot_dict)\n\n ##########################################################\n # Functions that return part of the isotherm data\n\n def data(self, branch: str = None) -> pandas.DataFrame:\n \"\"\"\n Return underlying isotherm data.\n\n Parameters\n ----------\n branch : {None, 'ads', 'des'}\n The branch of the isotherm to return. If ``None``, returns entire\n dataset.\n\n Returns\n -------\n DataFrame\n The pandas DataFrame containing all isotherm data.\n\n \"\"\"\n if branch is None or branch.startswith('all'):\n return self.data_raw\n if branch == 'ads':\n return self.data_raw.loc[self.data_raw['branch'] == 0]\n if branch == 'des':\n return self.data_raw.loc[self.data_raw['branch'] == 1]\n raise ParameterError('Bad branch specification.')\n\n def pressure(\n self,\n branch: str = None,\n pressure_unit: str = None,\n pressure_mode: str = None,\n limits: t.Tuple[float, float] = None,\n indexed: bool = False,\n ) -> t.Union[numpy.ndarray, pandas.Series]:\n \"\"\"\n Return pressure points as an array.\n\n Parameters\n ----------\n branch : {None, 'ads', 'des'}\n The branch of the pressure to return. If ``None``, returns entire\n dataset.\n pressure_unit : str, optional\n Unit in which the pressure should be returned. If ``None``\n it defaults to which pressure unit the isotherm is currently in.\n pressure_mode : {None, 'absolute', 'relative', 'relative%'}\n The mode in which to return the pressure, if possible. If ``None``,\n returns mode the isotherm is currently in.\n limits : [float, float], optional\n Minimum and maximum pressure limits.\n Put None or -+np.inf for no limit.\n indexed : bool, optional\n If this is specified to true, then the function returns an indexed\n pandas.Series instead of an array.\n\n Returns\n -------\n array or Series\n The pressure slice corresponding to the parameters passed.\n\n \"\"\"\n ret = self.data(branch=branch).loc[:, self.pressure_key]\n\n if not ret.empty:\n # Convert if needed\n if pressure_mode or pressure_unit:\n # If pressure mode not given, try current\n if not pressure_mode:\n pressure_mode = self.pressure_mode\n # If pressure unit not given, try current\n if not pressure_unit:\n pressure_unit = self.pressure_unit\n\n ret = c_pressure(\n ret,\n mode_from=self.pressure_mode,\n mode_to=pressure_mode,\n unit_from=self.pressure_unit,\n unit_to=pressure_unit,\n adsorbate=self.adsorbate,\n temp=self.temperature\n )\n\n # Select required points\n if limits and any(limits):\n ret = ret.loc[ret.between(\n -numpy.inf if limits[0] is None else limits[0],\n numpy.inf if limits[1] is None else limits[1]\n )]\n\n if indexed:\n return ret\n return ret.values\n\n def loading(\n self,\n branch: str = None,\n loading_unit: str = None,\n loading_basis: str = None,\n material_unit: str = None,\n material_basis: str = None,\n limits: t.Tuple[float, float] = None,\n indexed: bool = False\n ) -> t.Union[numpy.ndarray, pandas.Series]:\n \"\"\"\n Return loading points as an array.\n\n Parameters\n ----------\n branch : {None, 'ads', 'des'}\n The branch of the loading to return. If ``None``, returns entire\n dataset.\n loading_unit : str, optional\n Unit in which the loading should be returned. If ``None``\n it defaults to which loading unit the isotherm is currently in.\n loading_basis : {None, 'mass', 'volume_gas', 'volume_liquid', 'molar'}\n The basis on which to return the loading, if possible. If ``None``,\n returns on the basis the isotherm is currently in.\n material_unit : str, optional\n Unit in which the material should be returned. If ``None``\n it defaults to which loading unit the isotherm is currently in.\n material_basis : {None, 'mass', 'volume', 'molar'}\n The basis on which to return the material, if possible. If ``None``,\n returns on the basis the isotherm is currently in.\n limits : [float, float], optional\n Minimum and maximum loading limits.\n Put None or -+np.inf for no limit.\n indexed : bool, optional\n If this is specified to true, then the function returns an indexed\n pandas.Series instead of an array.\n\n Returns\n -------\n Array or Series\n The loading slice corresponding to the parameters passed.\n\n \"\"\"\n ret = self.data(branch=branch).loc[:, self.loading_key]\n\n if not ret.empty:\n # Convert if needed\n\n # First adsorbent is converted\n if material_basis or material_unit:\n if not material_basis:\n material_basis = self.material_basis\n\n ret = c_material(\n ret,\n basis_from=self.material_basis,\n basis_to=material_basis,\n unit_from=self.material_unit,\n unit_to=material_unit,\n material=self.material\n )\n\n # Then loading\n if loading_basis or loading_unit:\n if not loading_basis:\n loading_basis = self.loading_basis\n\n # These must be specified\n # in the case of fractional conversions\n if not material_basis:\n material_basis = self.material_basis\n if not material_unit:\n material_unit = self.material_unit\n\n ret = c_loading(\n ret,\n basis_from=self.loading_basis,\n basis_to=loading_basis,\n unit_from=self.loading_unit,\n unit_to=loading_unit,\n adsorbate=self.adsorbate,\n temp=self.temperature,\n basis_material=material_basis,\n unit_material=material_unit,\n )\n\n # Select required points\n if limits and any(limits):\n ret = ret.loc[ret.between(\n -numpy.inf if limits[0] is None else limits[0],\n numpy.inf if limits[1] is None else limits[1]\n )]\n\n if indexed:\n return ret\n return ret.values\n\n @property\n def other_keys(self):\n \"\"\"\n Return column names of any supplementary data points.\n \"\"\"\n return [\n c for c in self.data_raw.columns\n if c not in (self.pressure_key, self.loading_key, 'branch')\n ]\n\n def other_data(\n self,\n key: str,\n branch: str = None,\n limits: t.Tuple[float, float] = None,\n indexed: bool = False,\n ) -> t.Union[numpy.ndarray, pandas.Series]:\n \"\"\"\n Return supplementary data points as an array.\n\n Parameters\n ----------\n key : str\n Key in the isotherm DataFrame containing the data to select.\n branch : {None, 'ads', 'des'}\n The branch of the data to return. If ``None``, returns entire\n dataset.\n limits : [float, float], optional\n Minimum and maximum data limits.\n Put None or -+np.inf for no limit.\n indexed : bool, optional\n If this is specified to true, then the function returns an indexed\n pandas.Series instead of an array.\n\n Returns\n -------\n array or Series\n The data slice corresponding to the parameters passed.\n\n \"\"\"\n if key in self.other_keys:\n ret = self.data(branch=branch).loc[:, key]\n\n if not ret.empty:\n # Select required points\n if limits and any(limits):\n ret = ret.loc[ret.between(\n -numpy.inf if limits[0] is None else limits[0],\n numpy.inf if limits[1] is None else limits[1]\n )]\n\n if indexed:\n return ret\n return ret.values\n\n raise ParameterError(f\"Isotherm does not contain any {key} data.\")\n\n def has_branch(self, branch: str) -> bool:\n \"\"\"\n Check if the isotherm has an specific branch.\n\n Parameters\n ----------\n branch : {None, 'ads', 'des'}\n The branch of the data to check for.\n\n Returns\n -------\n bool\n Whether the data exists or not.\n\n \"\"\"\n return not self.data(branch=branch).empty\n\n ##########################################################\n # Functions that interpolate values of the isotherm data\n\n def pressure_at(\n self,\n loading: t.List[float],\n branch: str = 'ads',\n interpolation_type: str = 'linear',\n interp_fill: t.Union[float, t.Tuple[float, float], str] = None,\n pressure_unit: str = None,\n pressure_mode: str = None,\n loading_unit: str = None,\n loading_basis: str = None,\n material_unit: str = None,\n material_basis: str = None,\n ) -> numpy.ndarray:\n \"\"\"\n Interpolate isotherm to compute pressure at any loading given.\n\n Parameters\n ----------\n loading : float\n Loading at which to compute pressure.\n branch : {'ads', 'des'}\n The branch of the use for calculation. Defaults to adsorption.\n interpolation_type : str\n The type of scipy.interp1d used: `linear`, `nearest`, `zero`,\n `slinear`, `quadratic`, `cubic`. It defaults to `linear`.\n interp_fill : array-like or (array-like, array_like) or “extrapolate”, optional\n Parameter to determine what to do outside data bounds.\n Passed to the scipy.interpolate.interp1d function as ``fill_value``.\n If blank, interpolation will not predict outside the bounds of data.\n\n pressure_unit : str\n Unit the pressure is returned in. If ``None``, it defaults to\n internal isotherm units.\n pressure_mode : str\n The mode the pressure is returned in. If ``None``, it defaults to\n internal isotherm mode.\n\n loading_unit : str\n Unit the loading is specified in. If ``None``, it defaults to\n internal isotherm units.\n loading_basis : {None, 'mass', 'molar', 'volume_gas', 'volume_liquid'}\n The basis the loading is specified in. If ``None``,\n assumes the basis the isotherm is currently in.\n material_unit : str, optional\n Unit in which the material is passed in. If ``None``\n it defaults to which loading unit the isotherm is currently in\n material_basis : str\n The basis the loading is passed in. If ``None``, it defaults to\n internal isotherm basis.\n\n Returns\n -------\n float\n Predicted pressure at loading specified.\n\n \"\"\"\n # Convert to numpy array just in case\n loading = numpy.asarray(loading)\n\n # Check if interpolator is applicable\n if (\n self.p_interpolator is None or self.p_interpolator.interp_branch != branch\n or self.p_interpolator.interp_kind != interpolation_type\n or self.p_interpolator.interp_fill != interp_fill\n ):\n self.p_interpolator = IsothermInterpolator(\n self.loading(branch=branch),\n self.pressure(branch=branch),\n interp_branch=branch,\n interp_kind=interpolation_type,\n interp_fill=interp_fill\n )\n\n # Ensure loading is in correct units and basis for the internal model\n if material_basis or material_unit:\n if not material_basis:\n material_basis = self.material_basis\n if not material_unit:\n raise ParameterError(\n \"Must specify an material unit if the input is in another basis.\"\n )\n\n loading = c_material(\n loading,\n basis_from=material_basis,\n basis_to=self.material_basis,\n unit_from=material_unit,\n unit_to=self.material_unit,\n material=self.material\n )\n\n if loading_basis or loading_unit:\n if not loading_basis:\n loading_basis = self.loading_basis\n if not loading_unit:\n raise ParameterError(\n \"Must specify a loading unit if the input is in another basis.\"\n )\n\n loading = c_loading(\n loading,\n basis_from=loading_basis,\n basis_to=self.loading_basis,\n unit_from=loading_unit,\n unit_to=self.loading_unit,\n adsorbate=self.adsorbate,\n temp=self.temperature,\n basis_material=self.material_basis,\n unit_material=self.material_unit,\n )\n\n # Interpolate using the internal interpolator\n pressure = self.p_interpolator(loading)\n\n # Ensure pressure is in correct units and mode requested\n if pressure_mode or pressure_unit:\n if not pressure_mode:\n pressure_mode = self.pressure_mode\n\n pressure = c_pressure(\n pressure,\n mode_from=self.pressure_mode,\n mode_to=pressure_mode,\n unit_from=self.pressure_unit,\n unit_to=pressure_unit,\n adsorbate=self.adsorbate,\n temp=self.temperature\n )\n\n return pressure\n\n def loading_at(\n self,\n pressure: t.List[float],\n branch: str = 'ads',\n interpolation_type: str = 'linear',\n interp_fill: t.Union[float, t.Tuple[float, float], str] = None,\n pressure_unit: str = None,\n pressure_mode: str = None,\n loading_unit: str = None,\n loading_basis: str = None,\n material_unit: str = None,\n material_basis: str = None,\n ) -> numpy.ndarray:\n \"\"\"\n Interpolate isotherm to compute loading at any pressure given.\n\n Parameters\n ----------\n pressure : float or array\n Pressure at which to compute loading.\n branch : {'ads', 'des'}\n The branch the interpolation takes into account.\n interpolation_type : str\n The type of scipy.interp1d used: `linear`, `nearest`, `zero`,\n `slinear`, `quadratic`, `cubic`. It defaults to `linear`.\n interp_fill : array-like or (array-like, array_like) or “extrapolate”, optional\n Parameter to determine what to do outside data bounds.\n Passed to the scipy.interpolate.interp1d function as ``fill_value``.\n If blank, interpolation will not predict outside the bounds of data.\n\n pressure_unit : str\n Unit the pressure is specified in. If ``None``, it defaults to\n internal isotherm units.\n pressure_mode : str\n The mode the pressure is passed in. If ``None``, it defaults to\n internal isotherm mode.\n\n loading_unit : str, optional\n Unit in which the loading should be returned. If ``None``\n it defaults to which loading unit the isotherm is currently in.\n loading_basis : {None, 'mass', 'molar', 'volume_gas', 'volume_liquid'}\n The basis on which to return the loading, if possible. If ``None``,\n returns on the basis the isotherm is currently in.\n material_unit : str, optional\n Material unit in which the data should be returned. If ``None``\n it defaults to which loading unit the isotherm is currently in.\n material_basis : {None, 'mass', 'volume', 'molar'}\n Material basis on which to return the data, if possible. If ``None``,\n returns on the basis the isotherm is currently in.\n\n Returns\n -------\n float or array\n Predicted loading at pressure P.\n\n \"\"\"\n # Convert to a numpy array just in case\n pressure = numpy.asarray(pressure)\n\n # Check if interpolator is applicable\n if (\n self.l_interpolator is None or self.l_interpolator.interp_branch != branch\n or self.l_interpolator.interp_kind != interpolation_type\n or self.l_interpolator.interp_fill != interp_fill\n ):\n self.l_interpolator = IsothermInterpolator(\n self.pressure(branch=branch),\n self.loading(branch=branch),\n interp_branch=branch,\n interp_kind=interpolation_type,\n interp_fill=interp_fill\n )\n\n # Ensure pressure is in correct units and mode for the internal model\n if pressure_mode or pressure_unit:\n if not pressure_mode:\n pressure_mode = self.pressure_mode\n if pressure_mode == 'absolute' and not pressure_unit:\n raise ParameterError(\n \"Must specify a pressure unit if the input is in an absolute mode.\"\n )\n\n pressure = c_pressure(\n pressure,\n mode_from=pressure_mode,\n mode_to=self.pressure_mode,\n unit_from=pressure_unit,\n unit_to=self.pressure_unit,\n adsorbate=self.adsorbate,\n temp=self.temperature\n )\n\n # Interpolate using the internal interpolator\n loading = self.l_interpolator(pressure)\n\n # Ensure loading is in correct units and basis requested\n if material_basis or material_unit:\n\n if not material_basis:\n material_basis = self.material_basis\n\n loading = c_material(\n loading,\n basis_from=self.material_basis,\n basis_to=material_basis,\n unit_from=self.material_unit,\n unit_to=material_unit,\n material=self.material\n )\n\n if loading_basis or loading_unit:\n if not loading_basis:\n loading_basis = self.loading_basis\n\n loading = c_loading(\n loading,\n basis_from=self.loading_basis,\n basis_to=loading_basis,\n unit_from=self.loading_unit,\n unit_to=loading_unit,\n adsorbate=self.adsorbate,\n temp=self.temperature,\n basis_material=self.material_basis,\n unit_material=self.material_unit,\n )\n\n return loading\n\n def spreading_pressure_at(\n self,\n pressure: t.List[float],\n branch: str = 'ads',\n pressure_unit: str = None,\n pressure_mode: str = None,\n loading_unit: str = None,\n loading_basis: str = None,\n material_unit: str = None,\n material_basis: str = None,\n interp_fill: t.Union[float, t.Tuple[float, float], str] = None,\n ) -> numpy.ndarray:\n r\"\"\"\n Calculate reduced spreading pressure at a bulk adsorbate pressure P.\n\n Use numerical quadrature on isotherm data points to compute the reduced\n spreading pressure via the integral:\n\n .. math::\n\n \\Pi(p) = \\int_0^p \\frac{q(\\hat{p})}{ \\hat{p}} d\\hat{p}.\n\n In this integral, the isotherm :math:`q(\\hat{p})` is represented by a\n linear interpolation of the data.\n\n For in-detail explanations, check reference [#]_.\n\n Parameters\n ----------\n pressure : float\n Pressure (in corresponding units as data in instantiation).\n branch : {'ads', 'des'}\n The branch of the use for calculation. Defaults to adsorption.\n loading_unit : str\n Unit the loading is specified in. If ``None``, it defaults to\n internal isotherm units.\n pressure_unit : str\n Unit the pressure is returned in. If ``None``, it defaults to\n internal isotherm units.\n material_basis : str\n The basis the loading is passed in. If ``None``, it defaults to\n internal isotherm basis.\n pressure_mode : str\n The mode the pressure is returned in. If ``None``, it defaults to\n internal isotherm mode.\n interp_fill : array-like or (array-like, array_like) or “extrapolate”, optional\n Parameter to determine what to do outside data bounds.\n Passed to the scipy.interpolate.interp1d function as ``fill_value``.\n If blank, interpolation will not predict outside the bounds of data.\n\n Returns\n -------\n float\n Spreading pressure, :math:`\\Pi`.\n\n References\n ----------\n .. [#] C. Simon, B. Smit, M. Haranczyk. pyIAST: Ideal Adsorbed Solution\n Theory (IAST) Python Package. Computer Physics Communications.\n\n \"\"\"\n # Get all data points\n pressures = self.pressure(\n branch=branch, pressure_unit=pressure_unit, pressure_mode=pressure_mode\n )\n loadings = self.loading(\n branch=branch,\n loading_unit=loading_unit,\n loading_basis=loading_basis,\n material_unit=material_unit,\n material_basis=material_basis\n )\n\n # throw exception if interpolating outside the range.\n if (self.l_interpolator is not None and self.l_interpolator.interp_fill is None) & \\\n (pressure > pressures.max() or pressure < pressures.min()):\n raise CalculationError(\n textwrap.dedent(\n f\"\"\"\n To compute the spreading pressure at this bulk adsorbate pressure,\n we would need to extrapolate the isotherm since this pressure ({pressure:.3g} {self.pressure_unit})\n is outside the range of the highest pressure in your pure-component\n isotherm data ({pressures.max()} {self.pressure_unit}).\n\n At present, the PointIsotherm class is set to throw an exception\n when this occurs, as we do not have data outside this pressure range\n to characterize the isotherm at higher pressures.\n\n Option 1: fit an analytical model to extrapolate the isotherm\n Option 2: pass a `interp_fill` to the spreading pressure function of the\n PointIsotherm object. Then, that PointIsotherm will\n assume that the uptake beyond {pressures.max()} {self.pressure_unit} is given by\n `interp_fill`. This is reasonable if your isotherm data exhibits\n a plateau at the highest pressures.\n Option 3: Go back to the lab or computer to collect isotherm data\n at higher pressures. (Extrapolation can be dangerous!)\n \"\"\"\n )\n )\n\n # approximate loading up to first pressure point with Henry's law\n # loading = henry_const * P\n # henry_const is the initial slope in the adsorption isotherm\n henry_const = loadings[0] / pressures[0]\n\n # get how many of the points are less than pressure P\n n_points = numpy.sum(pressures < pressure)\n\n if n_points == 0:\n # if this pressure is between 0 and first pressure point...\n # \\int_0^P henry_const P /P dP = henry_const * P ...\n return henry_const * pressure\n\n # P > first pressure point\n area = loadings[0] # area of first segment \\int_0^P_1 n(P)/P dP\n\n # get area between P_1 and P_k, where P_k < P < P_{k+1}\n for i in range(n_points - 1):\n # linear interpolation of isotherm data\n slope = (loadings[i + 1] - loadings[i]) / (pressures[i + 1] - pressures[i])\n intercept = loadings[i] - slope * pressures[i]\n # add area of this segment\n area += slope * (pressures[i + 1] - pressures[i]) + intercept * \\\n numpy.log(pressures[i + 1] / pressures[i])\n\n # finally, area of last segment\n slope = (\n self.loading_at(\n pressure,\n branch=branch,\n pressure_unit=pressure_unit,\n pressure_mode=pressure_mode,\n loading_unit=loading_unit,\n loading_basis=loading_basis,\n material_unit=material_unit,\n material_basis=material_basis,\n interp_fill=interp_fill\n ) - loadings[n_points - 1]\n ) / (pressure - pressures[n_points - 1])\n\n intercept = loadings[n_points - 1] - \\\n slope * pressures[n_points - 1]\n area += slope * (pressure - pressures[n_points - 1]) + intercept * \\\n numpy.log(pressure / pressures[n_points - 1])\n\n return area\n", "meta": {"hexsha": "b91c9bc76a43d3952383923710368047d7e15cb3", "size": 48687, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/pygaps/core/pointisotherm.py", "max_stars_repo_name": "pauliacomi/adsutils", "max_stars_repo_head_hexsha": "062653b38924d419d1235edf7909078ff98a163f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/pygaps/core/pointisotherm.py", "max_issues_repo_name": "pauliacomi/adsutils", "max_issues_repo_head_hexsha": "062653b38924d419d1235edf7909078ff98a163f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/pygaps/core/pointisotherm.py", "max_forks_repo_name": "pauliacomi/adsutils", "max_forks_repo_head_hexsha": "062653b38924d419d1235edf7909078ff98a163f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.2509563887, "max_line_length": 115, "alphanum_fraction": 0.5738492821, "include": true, "reason": "import numpy", "num_tokens": 9837, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583269943353745, "lm_q2_score": 0.3486451353339457, "lm_q1q2_score": 0.19465799050065177}} {"text": "# coding: utf-8\n\n\"\"\" Transform a proper motion to/from Galactic to/from ICRS coordinates \"\"\"\n\nfrom __future__ import division, print_function\n\n# Standard library\nimport warnings\n\n# Third-party\nimport numpy as np\nimport astropy.coordinates as coord\n\n__all__ = ['transform_proper_motion', 'pm_gal_to_icrs', 'pm_icrs_to_gal']\n\ndef transform_proper_motion(coordinate, pm, new_frame):\n \"\"\"\n Transform the proper motion vector ``pm`` at the sky coordinate\n ``coordinate`` to the desired coordinate frame ``new_frame``.\n\n Parameters\n ----------\n coordinate : :class:`~astropy.coordinates.SkyCoord`, :class:`~astropy.coordinates.BaseCoordinateFrame`\n An instance of an Astropy coordinate object.\n pm : :class:`~astropy.units.Quantity`, iterable\n Proper motion components (longitude, latitude) in the same frame\n as the input coordinates. Can either be an iterable of two\n :class:`~astropy.units.Quantity` objects or a single\n :class:`~astropy.units.Quantity` with shape (2,N).\n The proper motion in longitude is assumed to already include\n the cos(latitude) term.\n new_frame : :class:`~astropy.coordinates.BaseCoordinateFrame` subclass\n The desired coordinate frame of the proper motion.\n\n Returns\n -------\n new_pm : tuple\n A length-2 tuple containing the proper motion components\n (longitude, latitude) in the new frame. The longitude component is\n includes the cos(latitude) term.\n\n Examples\n --------\n\n >>> import astropy.units as u\n >>> import astropy.coordinates as coord\n >>> c = coord.SkyCoord(ra=196.5*u.degree, dec=-10.33*u.deg, distance=16.2*u.kpc)\n >>> pm = [-1.53, 3.5]*u.mas/u.yr\n >>> transform_proper_motion(c, pm, coord.Galactic) # doctest: +FLOAT_CMP\n \n\n \"\"\"\n url = \"http://docs.astropy.org/en/stable/coordinates/velocities.html\"\n warnings.warn(\"This function is now deprecated. Use the velocity \"\n \"transformation functionality in Astropy instead. For more \"\n \"information, see: {0}\".format(url), DeprecationWarning)\n\n if hasattr(coordinate, 'frame'):\n coordinate = coordinate.frame\n\n frame_cls = coordinate.__class__\n c = frame_cls(coordinate.data.with_differentials(\n coord.UnitSphericalCosLatDifferential(*pm)))\n new_c = c.transform_to(new_frame)\n diff = new_c.data.differentials['s']\n pm = np.vstack((diff.d_lon_coslat.value, diff.d_lat.value)) * diff.d_lat.unit\n\n return pm.reshape((2,) + c.shape)\n\n# ----------------------------------------------------------------------------\n# Deprecated:\n#\n\ndef pm_gal_to_icrs(coordinate, pm):\n r\"\"\"\n Convert proper motion in Galactic coordinates (l,b) to\n ICRS coordinates (RA, Dec).\n\n Parameters\n ----------\n coordinate : :class:`~astropy.coordinates.SkyCoord`, :class:`~astropy.coordinates.BaseCoordinateFrame`\n An instance of an Astropy coordinate object. Can be in any\n frame that is transformable to ICRS coordinates.\n pm : :class:`~astropy.units.Quantity`, iterable\n Full description of proper motion in Galactic longitude and\n latitude. Can either be a tuple of two\n :class:`~astropy.units.Quantity` objects or a single\n :class:`~astropy.units.Quantity` with shape (2,N).\n The proper motion in longitude is assumed to be multipled by\n cosine of Galactic latitude, :math:`\\mu_l\\cos b`.\n\n Returns\n -------\n pm : :class:`~astropy.units.Quantity`\n An astropy :class:`~astropy.units.Quantity` object specifying the\n proper motion vector array in ICRS coordinates. Will have shape\n (2,N).\n\n Examples\n --------\n\n >>> import astropy.units as u\n >>> import astropy.coordinates as coord\n >>> c = coord.SkyCoord(ra=196.5*u.degree, dec=-10.33*u.deg, distance=16.2*u.kpc)\n >>> pm = [-1.53, 3.5]*u.mas/u.yr\n >>> pm_gal_to_icrs(c, pm) # doctest: +FLOAT_CMP\n \n\n \"\"\"\n\n # Note: Deprecation warning gets emitted from calling\n # transform_proper_motion below.\n g = coordinate.transform_to(coord.Galactic)\n return transform_proper_motion(g, pm, coord.ICRS)\n\ndef pm_icrs_to_gal(coordinate, pm):\n r\"\"\"\n Convert proper motion in ICRS coordinates (RA, Dec) to\n Galactic coordinates (l,b).\n\n Parameters\n ----------\n coordinate : :class:`~astropy.coordinates.SkyCoord`, :class:`~astropy.coordinates.BaseCoordinateFrame`\n An instance of an Astropy coordinate object. Can be in any\n frame that is transformable to ICRS coordinates.\n pm : :class:`~astropy.units.Quantity`, iterable\n Full description of proper motion in Right ascension (RA) and\n declination (Dec). Can either be a tuple of two\n :class:`~astropy.units.Quantity` objects or a single\n :class:`~astropy.units.Quantity` with shape (2,N).\n The proper motion in RA is assumed to be multipled by\n cosine of declination, :math:`\\mu_\\alpha\\cos\\delta`.\n\n Returns\n -------\n pm : :class:`~astropy.units.Quantity`\n An astropy :class:`~astropy.units.Quantity` object specifying the\n proper motion vector array in Galactic coordinates. Will have shape\n (2,N).\n\n Examples\n --------\n\n >>> import astropy.units as u\n >>> import astropy.coordinates as coord\n >>> c = coord.SkyCoord(ra=196.5*u.degree, dec=-10.33*u.deg, distance=16.2*u.kpc)\n >>> pm = [-1.84741767, 3.34334366]*u.mas/u.yr\n >>> pm_icrs_to_gal(c, pm) # doctest: +FLOAT_CMP\n \n\n \"\"\"\n\n # Note: Deprecation warning gets emitted from calling\n # transform_proper_motion below.\n i = coordinate.transform_to(coord.ICRS)\n return transform_proper_motion(i, pm, coord.Galactic)\n\n", "meta": {"hexsha": "9bf17cd553aca6e19f418db6d5f85cd03a1beda4", "size": 5930, "ext": "py", "lang": "Python", "max_stars_repo_path": "gala/coordinates/propermotion.py", "max_stars_repo_name": "ltlancas/gala", "max_stars_repo_head_hexsha": "2621bb599d67e74a85446abf72d5930ef70ca181", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-10-14T03:36:15.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-14T03:36:15.000Z", "max_issues_repo_path": "gala/coordinates/propermotion.py", "max_issues_repo_name": "ltlancas/gala", "max_issues_repo_head_hexsha": "2621bb599d67e74a85446abf72d5930ef70ca181", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "gala/coordinates/propermotion.py", "max_forks_repo_name": "ltlancas/gala", "max_forks_repo_head_hexsha": "2621bb599d67e74a85446abf72d5930ef70ca181", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.5316455696, "max_line_length": 106, "alphanum_fraction": 0.650084317, "include": true, "reason": "import numpy,import astropy", "num_tokens": 1445, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583269943353744, "lm_q2_score": 0.34864513533394575, "lm_q1q2_score": 0.19465799050065175}} {"text": "#!/usr/bin/python\n#-*- coding: utf-8 -*-\n\n# >.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.\n# Licensed under the Apache License, Version 2.0 (the \"License\")\n# You may obtain a copy of the License at\n# http://www.apache.org/licenses/LICENSE-2.0\n\n# --- File Name: tpl_score.py\n# --- Creation Date: 13-10-2020\n# --- Last Modified: Wed 18 Nov 2020 18:42:10 AEDT\n# --- Author: Xinqi Zhu\n# .<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<\n\"\"\"Implementation of the TPL score.\n\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nimport os\nimport sys\nimport pickle\nsys.path.insert(\n 0,\n os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))),\n 'disentanglement_lib'))\nsys.path.insert(\n 0,\n os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))),\n 'stylegan2'))\nimport dnnlib.tflib\nfrom absl import logging\nfrom disentanglement_lib.evaluation.metrics import utils\nimport numpy as np\nfrom six.moves import range\nfrom scipy import stats\nimport gin.tf\n\n\n@gin.configurable(\"tpl_score\",\n blacklist=[\n \"ground_truth_data\", \"generator_function\",\n \"random_state\", \"activation_str\", \"latent_size\",\n \"artifact_dir\"\n ])\ndef compute_tpl_score(ground_truth_data,\n generator_function,\n random_state,\n activation_str,\n latent_size,\n artifact_dir=None,\n batch_size=gin.REQUIRED,\n num_traversals=gin.REQUIRED,\n num_samples_per_dim=gin.REQUIRED,\n traversal_bound=gin.REQUIRED,\n active_thresh=gin.REQUIRED):\n \"\"\"Computes the FactorVAE disentanglement metric.\n\n Args:\n ground_truth_data: GroundTruthData to be sampled from.\n generator_function: Function that takes latent code as input and\n outputs an image.\n random_state: Numpy random state used for randomness.\n artifact_dir: Optional path to directory where artifacts can be saved.\n latent_size: Latent code size.\n batch_size: Number of points to be used to in a GPU.\n num_traversals: Number of traversals to sample.\n num_samples_per_dim: Number of samples per dim.\n traversal_bound: The bound for traversal.\n active_thresh: Threshold for determining active dims.\n\n Returns:\n Dictionary with scores:\n avg_tpl_dim: Mean TPL score for each dim.\n avg_tpl: Overall mean TPL score.\n active_mask: Mask of which dims are active.\n active_distances: Latent distances of active dims.\n active_stds: Latent stds of active dims.\n n_active_dims: Number of active dims.\n \"\"\"\n del ground_truth_data\n del artifact_dir\n dnnlib.tflib.init_tf()\n distance_measure = load_pkl(\n '.stylegan2-cache/vgg16_zhang_perceptual.pkl'\n # 'http://d36zk2xti64re0.cloudfront.net/stylegan1/networks/metrics/vgg16_zhang_perceptual.pkl'\n )\n if activation_str == \"'logits'\":\n activation = sigmoid\n elif activation_str == \"'tanh'\":\n activation = tanh\n else:\n raise ValueError(\n \"Activation function could not be infered from gin config.\")\n tpl_dim_ls = []\n for i in range(num_traversals):\n sample = random_state.normal(size=(1, latent_size))\n # factor_index = random_state.randint(ground_truth_data.num_factors)\n tpl_dim = compute_tpl_for(\n sample, generator_function, batch_size, num_samples_per_dim,\n latent_size, activation,\n distance_measure, traversal_bound) # np.array of [latent_size]\n tpl_dim_ls.append(tpl_dim)\n tpl_dim_np = np.array(tpl_dim_ls) # np.array of [n_trav, latent_size]\n avg_tpl_dim = np.mean(tpl_dim_np, axis=0) # np.array of [latent_size]\n std_tpl_dim = np.std(tpl_dim_np, axis=0) # np.array of [latent_size]\n\n active_mask = avg_tpl_dim > active_thresh\n active_distances = np.extract(active_mask, avg_tpl_dim)\n active_stds = np.extract(active_mask, std_tpl_dim)\n avg_tpl = np.sum(active_distances)\n n_active_dims = active_mask.astype(int).sum()\n\n scores_dict = {}\n scores_dict['avg_tpl_dim'] = avg_tpl_dim.tolist()\n scores_dict['avg_tpl'] = avg_tpl\n scores_dict['active_mask'] = active_mask.tolist()\n scores_dict['active_distances'] = active_distances.tolist()\n scores_dict['active_stds'] = active_stds.tolist()\n scores_dict['n_active_dims'] = n_active_dims\n # print('scores_dict:', scores_dict)\n return scores_dict\n\n\ndef compute_tpl_for(sample, generator_function, batch_size,\n num_samples_per_dim, latent_size, activation,\n distance_measure, traversal_bound):\n '''\n Return: np.array of [latent_size]\n '''\n tpl_sample_dim_ls = []\n for i in range(latent_size):\n samples_traversal = np.tile(sample, [num_samples_per_dim, 1])\n samples_traversal[:, i] = np.linspace(-traversal_bound, traversal_bound, num=num_samples_per_dim)\n raw_imgs_traversal = generator_function(\n samples_traversal) # size: [b, h, w, c]\n imgs_traversal = activation(raw_imgs_traversal)\n j = 0\n traversal_score = 0\n while j < num_samples_per_dim:\n b_j = min(batch_size, num_samples_per_dim - j)\n cur_imgs_traversal = imgs_traversal[j:j + b_j, ...]\n j += b_j\n traversal_score += measure_distance(cur_imgs_traversal,\n distance_measure)\n tpl_sample_dim_ls.append(traversal_score)\n return np.array(tpl_sample_dim_ls)\n\n\ndef measure_distance(imgs_traversal, distance_measure):\n images = np.transpose(imgs_traversal, [0, 3, 1, 2]) # bhwc -> bchw\n images = images * 255 # [0, 1] -> [0, 255]\n v = get_return_v(distance_measure.run(images[:-1, ...], images[1:, ...]),\n 1)\n return v.sum()\n\n\ndef sigmoid(x):\n return stats.logistic.cdf(x)\n\n\ndef tanh(x):\n return np.tanh(x) / 2. + .5\n\n\ndef get_return_v(x, topk=1):\n if (not isinstance(x, tuple)) and (not isinstance(x, list)):\n return x if topk == 1 else tuple([x] + [None] * (topk - 1))\n if topk > len(x):\n return tuple(list(x) + [None] * (topk - len(x)))\n else:\n if topk == 1:\n return x[0]\n else:\n return tuple(x[:topk])\n\n\ndef load_pkl(file_or_url):\n with open(file_or_url, 'rb') as file:\n return pickle.load(file, encoding='latin1')\n", "meta": {"hexsha": "77014f26bec08a48649b376fc779068588a0bf94", "size": 6556, "ext": "py", "lang": "Python", "max_stars_repo_path": "tpl_score.py", "max_stars_repo_name": "zhuxinqimac/Israfel", "max_stars_repo_head_hexsha": "1f1ff8c494ac93a5284477dcafc487b1915d3570", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-06-14T16:19:54.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-29T04:55:19.000Z", "max_issues_repo_path": "tpl_score.py", "max_issues_repo_name": "zhuxinqimac/TPL-Evaluate", "max_issues_repo_head_hexsha": "1f1ff8c494ac93a5284477dcafc487b1915d3570", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "tpl_score.py", "max_forks_repo_name": "zhuxinqimac/TPL-Evaluate", "max_forks_repo_head_hexsha": "1f1ff8c494ac93a5284477dcafc487b1915d3570", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.4222222222, "max_line_length": 105, "alphanum_fraction": 0.6404820012, "include": true, "reason": "import numpy,from scipy", "num_tokens": 1590, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583269943353744, "lm_q2_score": 0.3486451285660856, "lm_q1q2_score": 0.19465798672197274}} {"text": "# -*- coding: utf-8 -*-\n'''\nCreated on Nov 24, 2014\n\n@author: pascale\n'''\n\nimport rmodel\nimport numpy as np\nimport logging\nimport rttov\nimport copy\nimport matplotlib.pyplot as plt\nimport os\nimport h5py\nimport shutil\nfrom r1Dvar import r1dvarObjects\n\n\nq_mixration_to_ppmv = 1.60771704e+6\n\n\ndef vector2profile(vector, exprofile):\n \"\"\" convert vector to profile \"\"\"\n \"\"\" take exprofile to begin with \"\"\"\n \"\"\" a vector contains only T values, \"\"\"\n \"\"\" lnq bottom lnq vales , Tsurf, lnq surf and Tskin\"\"\"\n \"\"\" temperature, and ln q are stored from top of atmosphere to ground \"\"\"\n\n nlevels = vector.shape[0] - 29 - 3\n if nlevels != exprofile['NLEVELS']:\n logging.error(\"vector and profile are not of the same dimension\")\n return None\n\n profile = copy.deepcopy(exprofile)\n\n for i in range(nlevels):\n profile[\"T\"][i] = vector[i]\n\n for i in range(29):\n profile[\"Q\"][nlevels - 29 + i] = vector[nlevels + i]\n\n profile[\"S2M\"][\"T\"] = vector[nlevels + 29]\n profile[\"S2M\"][\"Q\"] = vector[nlevels + 29 + 1]\n profile[\"SKIN\"][\"T\"] = vector[nlevels + 29 + 2]\n\n return profile\n\n\nclass Project1dvar(object):\n\n def __init__(self, pTrue, pBg, satellite, instrument,\n matrixBfile=None, channel_list=None,\n changeTheBackground=False):\n \"\"\" initialize a 1DvarProject with a True and a Background project \"\"\"\n \"\"\" if channel_list is present : we work on a restricted list \"\"\"\n \"\"\" of channel \"\"\"\n \"\"\" but in fact channel_list is set from the Coefficient \"\"\"\n \"\"\" object of pBg \"\"\"\n \"\"\" so we use this list to extract a sub-matrix from the Rmatrix \"\"\"\n \"\"\" satellite must be = platform-num (ex : metop-1 , noaa-19) \"\"\"\n \"\"\" if changeTheBackground=False we don not change the Background \"\"\"\n \"\"\" if changeTheBackground=False at each new step the previously \"\"\"\n \"\"\" retrieved profile becomes the new background \"\"\"\n\n self.changeTheBackground = changeTheBackground\n self.ENV = {}\n self.pTrue = pTrue\n self.pBg = pBg\n # set distinct filenames for the true and the background project\n # (we will run rttov with different files)\n self.pTrue.setFileNameMark(\"True\")\n self.pBg.setFileNameMark(\"Bg\")\n logging.info(\"Initialize a Project1dvar object\")\n logging.info(\"are pBg coefficients loaded ? \" +\n str(self.pBg.myCoeffs.loadCoeffs))\n self.satellite = satellite\n self.instrument = instrument\n\n self.BgInitialProfile = copy.deepcopy(self.pBg.myProfile)\n self.BmatrixFileName = None\n self.RmatrixFilename = None\n\n self._SetConfig()\n self.factorB = 1.\n self.factorR = 1.\n self.MaxNoise = 1.\n self.retrievedVectors = []\n self.retrievedProfiles = []\n self.Rmatrix = Rmatrix()\n self.Bmatrix = Bmatrix()\n # read R matrix\n self.initCoeffsandReadRmatrix()\n # Bmatrix\n if matrixBfile:\n self.BmatrixFileName = matrixBfile\n if not os.path.exists(self.BmatrixFileName):\n logging.error(\n \"Sorry something is wrong : I cannot find the Bmatrix :\"\n \" check the presence of the nwpsaf-1dvar files \")\n raise IOError\n # read the Bmatrix\n B = Bmatrix()\n B.read_matrices(self.BmatrixFileName)\n # The file contains 4 matrix but according to Peter the 4 matrix are\n # identical\n self.Bmat = B.matrices[1]\n self.step_counter = 0\n\n def initCoeffsandReadRmatrix(self):\n \"\"\" initialise myCoeffs for pBg project and read the R matrix \"\"\"\n \"\"\" the R matrix is computed according to the list of channels \"\"\"\n if not self.pBg.myCoeffs.loadCoeffs:\n logging.info(\"load coefficients for pBg\")\n err = self.pBg.loadCoefficients()\n if err != 0:\n raise RuntimeError(\"Cannot load coefficient in r1dvar project\")\n nbChannels = self.pBg.myCoeffs.nchannels\n logging.info(\"nbChannels: {}\".format(nbChannels))\n # initialise the 1dvarproject channel_list used by readRmatrix\n my_chan_list = self.pBg.myCoeffs.getFF_ORI_CHN()\n # must start at 0\n self.channel_list = [my_chan_list[i] -\n 1 for i in range(len(my_chan_list))]\n # read the R matrix\n\n self.readRmatrix(self.satellite, self.instrument)\n\n def reinitCoeff(self, satellite, instrument, coeffs):\n \"\"\" must be called if we change the coefficients \"\"\"\n \"\"\" (select channel or change instrument ) \"\"\"\n \"\"\" satellite must be = platform-num (ex : metop-1 , noaa-19) \"\"\"\n self.pBg.myCoeffs = coeffs\n self.satellite = satellite\n self.instrument = instrument\n\n self.initCoeffsandReadRmatrix()\n\n def _SetConfig(self):\n try:\n self.ENV[\"NWPSAF_1DVAR_HOME\"] = os.environ(\"NWPSAF_1DVAR_HOME\")\n except:\n logging.warning(\n \"The environment variable NWPSAF_1DVAR_HOME is not set :\"\n \" no worries I can use my matrix ..\")\n self.ENV[\"NWPSAF_1DVAR_HOME\"] = os.environ[\n \"RTTOV_GUI_PREFIX\"] + \"/r1Dvar/data\"\n self.BmatrixFileName = self.ENV[\n \"NWPSAF_1DVAR_HOME\"] + \"/Sample_Bmatrices/Bmatrix_54L\"\n\n self.RmatrixFilenames = {\n \"AIRS\": os.path.join(self.ENV[\"NWPSAF_1DVAR_HOME\"],\n \"AIRS_COEFFS_DIR/Rmatrix_orig\"),\n \"ATMS\": os.path.join(self.ENV[\"NWPSAF_1DVAR_HOME\"],\n \"ATMS_COEFFS_DIR/Rmatrix_orig\"),\n \"AMSU-A\": os.path.join(self.ENV[\"NWPSAF_1DVAR_HOME\"],\n \"ATOVS_COEFFS_DIR/Rmatrix_orig\"),\n \"AMSU-B\": os.path.join(self.ENV[\"NWPSAF_1DVAR_HOME\"],\n \"ATOVS_COEFFS_DIR/Rmatrix_orig\"),\n \"HIRS\": os.path.join(self.ENV[\"NWPSAF_1DVAR_HOME\"],\n \"ATOVS_COEFFS_DIR/Rmatrix_orig\"),\n \"MHS\": os.path.join(self.ENV[\"NWPSAF_1DVAR_HOME\"],\n \"ATOVS_COEFFS_DIR/Rmatrix_orig\"),\n \"mhs\": os.path.join(self.ENV[\"NWPSAF_1DVAR_HOME\"],\n \"ATOVS_COEFFS_DIR/Rmatrix_orig\"),\n \"IASI\": os.path.join(self.ENV[\"NWPSAF_1DVAR_HOME\"],\n \"IASI_COEFFS_DIR/Rmatrix_orig\"),\n \"CRIS\": os.path.join(self.ENV[\"NWPSAF_1DVAR_HOME\"],\n \"CrIS_COEFFS_DIR/Rmatrix_orig\"),\n \"SSMIS\": os.path.join(self.ENV[\"NWPSAF_1DVAR_HOME\"],\n \"SSMIS_COEFFS_DIR/Rmatrix_orig\"),\n \"CrIS\": os.path.join(self.ENV[\"NWPSAF_1DVAR_HOME\"],\n \"CrIS_COEFFS_DIR/Rmatrix_orig\"),\n \"amsua\": os.path.join(self.ENV[\"NWPSAF_1DVAR_HOME\"],\n \"ATOVS_COEFFS_DIR/Rmatrix_orig\"),\n \"amsub\": os.path.join(self.ENV[\"NWPSAF_1DVAR_HOME\"],\n \"ATOVS_COEFFS_DIR/Rmatrix_orig\"),\n \"hirs\": os.path.join(self.ENV[\"NWPSAF_1DVAR_HOME\"],\n \"ATOVS_COEFFS_DIR/Rmatrix_orig\")\n }\n\n def readRmatrix(self, satellite, instrument, filename=None):\n \"\"\" read the observation error matrix file and init self.Rmat \"\"\"\n \"\"\" if filename is specified then it has the priority \"\"\"\n \"\"\" first step : determine the file name from the instrument \"\"\"\n \"\"\" (stored in rge Rmatrixfilenames dictionary\"\"\"\n \"\"\" create a Rmatrix objet which will contains all the Rmatrix \"\"\"\n \"\"\" read in a file \"\"\"\n \"\"\" then determine the actual Rmat from satellite and instrument \"\"\"\n \"\"\" ATOVS case is particular : must retrieve HIRS, AMSU-A and MHS\"\"\"\n \"\"\" for some other files it is trivial : they contains just one \"\"\"\n \"\"\" matrix \"\"\"\n \"\"\" satellite must be = platform-num (ex : metop-1 , noaa-19) \"\"\"\n # when this method is call self.channel_list exit and is ready (no need\n # to shift indices)\n logging.info(\"read R matrix for \" + satellite + \" \" + instrument)\n isATOV = False\n if instrument in (\"hirs\", \"amsua\", \"amsub\", \"mhs\"):\n isATOV = True\n else:\n if instrument == \"cris\":\n instrument = \"CrIS\"\n else:\n instrument = instrument.upper()\n if satellite == \"metop-2\":\n satellite = \"MetOp-A\"\n else:\n if satellite == \"metop-1\":\n satellite = \"MetOp-B\"\n else:\n satellite = satellite.upper()\n\n logging.info(\"instrument :\" + str(instrument) + \" \" +\n str(satellite) + \" is ATOV ?: \" + str(isATOV))\n if filename is not None:\n self.RmatrixFilename = filename\n else:\n self.instrument = instrument\n self.satellite = satellite\n\n self.RmatrixFilename = self.RmatrixFilenames[instrument]\n try:\n self.RmatrixFilename = self.RmatrixFilenames[instrument]\n logging.info(\" RmatrixFilename : \" + self.RmatrixFilename +\n \" for \" +\n instrument + \" \" + satellite +\n \" is ATOV ?: \" + str(isATOV))\n except (KeyError):\n raise ValueError(\"wrong instrument\" + str(instrument))\n\n self.Rmatrix = Rmatrix()\n logging.info(\"Read the Rmatrix\")\n self.Rmatrix.read(self.RmatrixFilename)\n logging.info(\"R matrix successfully read\")\n\n try:\n if len(self.Rmatrix.Rmatrix.keys()) == 1:\n self.Rmat = self.Rmatrix.Rmatrix.values()[0][\"matrix\"]\n else:\n if isATOV:\n\n if self.instrument == \"amsua\":\n self.Rmat = self.Rmatrix.Rmatrix[\n satellite + \" \" + \"ATOVS\"][\"matrix\"][\n 20:35, 20:35]\n else:\n if (\n self.instrument == \"amsub\" or\n self.instrument == \"MHS\" or\n self.instrument == \"mhs\"):\n self.Rmat = self.Rmatrix.Rmatrix[\n satellite + \" \" + \"ATOVS\"][\"matrix\"][\n 35:40, 35:40]\n print self.Rmat\n else:\n if self.instrument == \"hirs\":\n # HIRS : 1 vis channel, 19 IR channels :\n # take only the IR channels !\n # in this case we start at 1 because the\n # first channel is vis !!!!\n self.Rmat = self.Rmatrix.Rmatrix[\n satellite + \" \" + \"ATOVS\"][\"matrix\"][\n 1:20, 1:20]\n else:\n raise ValueError(\n \"wrong satellite and instrument\" +\n str(satellite) + \" \" + str(instrument))\n else:\n raise ValueError(\n \"wrong satellite and instrument \" +\n str(satellite) +\n \" \" + str(instrument))\n except (KeyError):\n\n raise ValueError(\"wrong satellite and instrument \" +\n str(satellite) + \" \" + str(instrument))\n # keep only selected channels\n\n if self.channel_list is None:\n logging.info(\"no channel list take all of the matrix\")\n self.channel_list = range(0, self.Rmat.shape[0])\n else:\n # this channel list already begin with 0\n foo = self.Rmat[self.channel_list, :]\n bar = foo[:, self.channel_list]\n self.Rmat = bar\n\n def plotRmat(self):\n plt.imshow(self.Rmat, origin=\"lower\", interpolation=\"nearest\")\n plt.title(\"Rmatrix for \" + self.instrument + \" \" + self.satellite)\n plt.colorbar()\n plt.show()\n\n def setFactorB(self, factor):\n self.factorB = factor\n\n def setFactorR(self, factor):\n self.factorR = factor\n\n def setMaxNoise(self, maxNoise):\n self.MaxNoise = maxNoise\n\n def stepRetrieve1d(self):\n \"\"\" perform a step of retrieval\n the retrieved vector becomes the new background profile\"\"\"\n if self.Xr is not None:\n if self.changeTheBackground:\n # make a new profile object with the retrieved vector and the\n # former background profile\n newBgProfile = vector2profile(self.Xr, self.pBg.myProfile)\n self.pBg.myProfile = newBgProfile\n self.pBg.myProfile = self.retrievedProfiles[-1]\n logging.info(\"new profile background initialised \" +\n self.pBg.profileFileName)\n self.retrieve1d()\n else:\n # we do not change the Background\n self.retrieve1d()\n\n def set1dvarRequiredOptionsAndValues(self, project):\n \"\"\" set the required option and valuesfor the 1dvar algorithm \"\"\"\n \"\"\" this options are CFRACTION=0 \"\"\"\n \"\"\" Nadir condition \"\"\"\n logging.info(\n \"set 1dvar required options and values (CFRACTION=0, no gas,\"\n \" calculation at nadir etc) \")\n project.myOption[\"SWITCHRAD\"] = True\n # No gas\n project.myOption[\"CO2_DATA\"] = False\n project.myOption[\"CH4_DATA\"] = False\n project.myOption[\"OZONE_DATA\"] = False\n project.myOption[\"CO_DATA\"] = False\n project.myOption[\"N2O_DATA\"] = False\n # no cloud\n project.myOption[\"ADDCLOUDS\"] = False\n project.myProfile[\"CFRACTION\"] = 0\n # no aerosols\n project.myOption[\"ADDAEROSL\"] = False\n # no solar\n project.myOption[\"ADDSOLAR\"] = False\n\n # calculation at nadir\n project.myProfile[\"ZENANGLE\"] = 0\n project.myProfile[\"SUNZENANGLE\"] = 0\n\n def assumptionOnSurfaceParameters(self, profileTrue, profileBg):\n \"\"\" restrictions the surface parameters of the Bg are applied\n on the True except for T skin and T 2m \"\"\"\n profileBg[\"SKIN\"]['SURFTYPE'] = 1 # (0=Land, 1=Sea, 2=sea-ice)\n for item in [\"LATITUDE\", \"LONGITUDE\", \"ELEVATION\", \"AZANGLE\", \"BE\",\n \"COSBK\", \"SNOW_FRAC\", \"SOIL_MOISTURE\"]:\n profileTrue[item] = profileBg[item]\n for item in [\"Q\", \"O\", \"P\", \"U\", \"V\", \"WFETC\"]:\n profileTrue[\"S2M\"][item] = profileBg[\"S2M\"][item]\n for item in [\"SURFTYPE\", \"WATERTYPE\", \"SALINITY\", \"FASTEM\"]:\n profileTrue[\"SKIN\"][item] = profileBg[\"SKIN\"][item]\n\n def retrieve1d(self):\n \"\"\" perform the basic retrieval algorithm \"\"\"\n \"\"\" must put switchrad a true et cfraction a 0 \"\"\"\n # load coefficients\n self.step_counter = self.step_counter + 1\n self.pTrue.myCoeffs = self.pBg.myCoeffs\n self.pTrue.myOption = self.pBg.myOption\n # we are making assumption on surface parameters some must be the same\n self.assumptionOnSurfaceParameters(\n self.pTrue.myProfile, self.pBg.myProfile)\n\n # at this point the coefficient must be loaded\n if not self.pBg.myCoeffs.loadCoeffs:\n logging.warning(\n \"strange : coefficients would have been \"\n \"loaded at this point ...\")\n err = self.pBg.loadCoefficients()\n if err != 0:\n raise RuntimeError(\"Cannot load coefficient in r1dvar project\")\n\n if len(self.channel_list) != self.pTrue.myCoeffs.nchannels:\n logging.warning(\"wrong channel list : take all\")\n self.channel_list = range(1, self.pTrue.myCoeffs.nchannels + 1)\n self.readRmatrix(self.satellite, self.instrument)\n\n nbChannels = self.pTrue.myCoeffs.nchannels\n logging.info(\"nbChannels: {}\".format(nbChannels))\n\n logging.debug(\"coefficients file: \" +\n self.pBg.myCoeffs.fileName[\"standard\"])\n if self.step_counter > 1:\n # test if we have a different number of channels\n if len(self.Y_Xt) == 1:\n previousNumberOfChannels = 1\n else:\n previousNumberOfChannels = self.Y_Xt.shape[0]\n notSameNumberOfChannels = (\n self.pBg.myCoeffs.nchannels != previousNumberOfChannels)\n if notSameNumberOfChannels:\n logging.info(\"not the same number of channels\")\n\n # Run direct on True\n\n logging.info(\">>>>>>>>> Run direct on True\")\n # must put switchrad a true et cfraction a 0 and other things on\n # options\n self.set1dvarRequiredOptionsAndValues(self.pTrue)\n err = self.pTrue.runDirect()\n if (err != 0):\n raise RuntimeError(\"Run Direct failed on true\")\n # put radiance to 0 in the radiance file for plotting\n self.changeRadianceFile(self.pTrue.radianceFileName)\n # 1) Y(Xt) brightness temperatures from Xt\n YXt = rttov.radiance.Radiance()\n logging.info(\">>>>>>>>>>>reading BT from : \")\n YXt.read(self.pTrue.radianceFileName)\n self.Y_Xt = YXt[\"BT_CLEAR\"] # No clouds so BT_CLEAR=BT\n Xt = self.pTrue.myProfile.to1DvarVect()\n self.Xt = Xt\n\n # Run direct on Background\n logging.info(\">>>>>>>> Run direct on Background\")\n # must put switchrad a true et cfraction a 0 and other things on\n # options\n self.set1dvarRequiredOptionsAndValues(self.pBg)\n err = self.pBg.runDirect()\n if (err != 0):\n raise RuntimeError(\"Run Direct failed on background\")\n # put radiance to 0 in the radiance file for plotting\n self.changeRadianceFile(self.pBg.radianceFileName)\n\n logging.info(\">>>>>>>> Run K on Background\")\n err = self.pBg.runK()\n if (err != 0):\n raise RuntimeError(\"Run K failed on background\")\n else:\n logging.info(\"run K on background OK\")\n\n # 2) Y((Xb) brightness temperarures from Xb\n YXb = rttov.radiance.Radiance()\n logging.info(\">>>>>>>>>>reading BT \" + self.pBg.radianceFileName)\n YXb.read(self.pBg.radianceFileName)\n Y_Xb = YXb[\"BT_CLEAR\"]\n\n # 3) compute jacobian matrix K(Xb) and transpose KT(Xb)\n KXb = r1dvarObjects.R1dvarKmatrix()\n logging.info(\"reading kmatrix \" + self.pBg.KMatrixFileName)\n KXb.read(self.pBg.KMatrixFileName)\n\n logging.info(\">>>>>>>KmatrixVectorAndTranspose \")\n # extract the jacobian matrix from the KMatrix Object\n K_Xb = KXb.toKmatrix1dvar()\n # transpose this matrix\n KT_Xb = K_Xb.T\n\n # 4) apply scaling factor to background errors B --> fb x B\n # the Bmatrix has been read in init and has been put in self.Bmat\n myBmat = self.Bmat * self.factorB\n\n # 5) apply scaling factor to observation errors R --> fr x R\n # The R matrix has been read in init and has been put in self.Rmat\n\n myRmat = self.Rmat * self.factorR\n\n # 6) compute add random noise to Y(Xt)\n\n#\n # Noise in BT = +/- MaxNoise degree\n logging.info(\"Max Noise : \" + str(self.MaxNoise))\n self.N = self.MaxNoise * (np.random.rand(nbChannels) * 2 - 1)\n self.Y_Xt = self.Y_Xt + self.N\n\n # save the file with True BT+Noise in order to be able to plot it after\n new_name = self.pTrue.radianceFileName.replace(\".h5\", \"_Noise.h5\")\n self.changeRadianceFile(self.pTrue.radianceFileName, self.N, new_name)\n\n # 7) compute linear 1DVAR weights W where\n # W = B . KT . [ K .B . KT + R ](-1)\n # W = fact1 . [ foo1 .KT + R ](-1)\n # W = fact1 . [ foo2 + R ](-1)\n # W = fact1 . [ foo3 ](-1)\n # W = fact1 . Matrice_inverse\n fact1 = myBmat.dot(KT_Xb)\n foo1 = K_Xb.dot(myBmat)\n foo2 = foo1.dot(KT_Xb)\n foo3 = foo2 + myRmat\n # matrix inversion\n logging.info(\"matrix inversion\")\n Matrice_inverse = np.linalg.inv(foo3)\n logging.info(\"compute the linear 1DVAR weight \")\n W = fact1.dot(Matrice_inverse)\n\n # 8) compute linear 1Dvar retrieved profile (Xr)\n Xb = self.pBg.myProfile.to1DvarVect()\n # we have already added N to Y_Xt earlier\n YtminusYb = self.Y_Xt - Y_Xb\n\n Xr = Xb + W.dot(YtminusYb)\n # if Q <0 alors Q=0\n for k in range(Xr.shape[0] - 29 - 3, (Xr.shape[0] - 3)):\n if Xr[k] <= 0:\n # if find something negative for Q : stick to the background\n # ....\n Xr[k] = Xb[k]\n k = Xr.shape[0] - 2\n if Xr[k] <= 0:\n # if find something negative for Q : stick to the background ....\n Xr[k] = Xb[k]\n\n self.Xr = Xr\n self.Y_Xb = Y_Xb\n self.Xb = Xb\n # append the retrieved Vector and the retrieved profile to list\n self.retrievedVectors.append(Xr)\n retrievedProfile = vector2profile(self.Xr, self.pBg.myProfile)\n self.retrievedProfiles.append(retrievedProfile)\n return Xr\n\n def changeRadianceFile(self, radianceFileName, Noise=None, NewName=None):\n \"\"\" change the radiance file set radiance to 0 add Noise to BT) \"\"\"\n if NewName:\n shutil.copyfile(radianceFileName, NewName)\n rf = h5py.File(radianceFileName, 'r+')\n else:\n rf = h5py.File(radianceFileName, 'r+')\n group = rf[\"RADIANCE\"]\n bt = rf[\"RADIANCE/BT\"][:]\n bt_clear = rf[\"RADIANCE/BT_CLEAR\"][:]\n rad_clear = rf[\"RADIANCE/CLEAR\"]\n a = rad_clear[:]\n\n a_new = np.zeros_like(a)\n del rf[\"RADIANCE/CLEAR\"]\n del rf[\"RADIANCE/CLOUDY\"]\n del rf[\"RADIANCE/TOTAL\"]\n del rf[\"RADIANCE/OVERCAST\"]\n group.create_dataset(\"CLEAR\", a_new.shape, data=a_new)\n group.create_dataset(\"CLOUDY\", a_new.shape, data=a_new)\n group.create_dataset(\"TOTAL\", a_new.shape, data=a_new)\n group.create_dataset(\"OVERCAST\", a_new.shape, data=a_new)\n if Noise is not None:\n bt_new = bt + Noise\n bt_clear_new = bt_clear + Noise\n del rf[\"RADIANCE/BT\"]\n del rf[\"RADIANCE/BT_CLEAR\"]\n group.create_dataset(\"BT\", bt_new.shape, data=bt_new)\n group.create_dataset(\"BT_CLEAR\", bt_new.shape, data=bt_clear_new)\n rf.close()\n\n def plot(self):\n colors = {0: \"red\",\n 1: \"orange\",\n 2: \"yellow\",\n 3: \"magenta\",\n 4: \"brown\"\n }\n ax = plt.subplot(2, 2, 1)\n Xb0 = self.BgInitialProfile.to1DvarVect()\n Y = self.pTrue.myProfile[\"P\"]\n pression = Y\n print (\"pression\")\n for k in range(0, pression.shape[0]):\n print (\"%.2f\" % pression[k])\n ax.set_ylim((pression[-1] + 30, pression[0]))\n ax.set_yscale(\"log\")\n ax.plot(self.Xt[:54], Y, color=\"black\", label=\"T true\")\n ax.plot(Xb0[:54], Y, color=\"blue\", label=\"T background\")\n for k in range(len(self.retrievedVectors)):\n ax.plot(self.retrievedVectors[k][\n :54], Y, color=\"red\", label=\"T retrieved step \" + str(k))\n ax.plot(self.Xt[85], Y[-1] + 20, color=\"black\",\n marker=\"*\", label=\"T skin True\")\n ax.plot(Xb0[85], Y[-1] + 20, color=\"blue\",\n marker=\"*\", label=\"T skin background\")\n for k in range(len(self.retrievedVectors)):\n ax.plot(self.retrievedVectors[k][85],\n Y[-1] + 20, color=\"red\", marker=\"*\",\n label=\"T skin retrieved step\" + str(k))\n ax.legend(prop={'size': 10}, shadow=True, fancybox=True, loc='best')\n ax = plt.subplot(2, 2, 2)\n\n pression = Y[:29]\n print(pression.shape)\n\n ax.set_ylim((pression[-1], pression[0]))\n ax.set_yscale(\"log\")\n\n ax.plot(self.Xt[54:83], pression, color=\"black\", label=\"Q true\")\n ax.plot(Xb0[54:83], pression, color=\"blue\", label=\"Q background\")\n print \"q true\"\n print self.Xt[54:83]\n print \"Q initial\"\n print Xb0[54:83]\n for k in range(len(self.retrievedVectors)):\n ax.plot(self.retrievedVectors[k][54:83], pression, color=colors[\n k], label=\"Q retrieved step \" + str(k))\n print \"Q retrieved k\", k\n print self.retrievedVectors[k][54:83]\n ax.legend(prop={'size': 10}, shadow=True, fancybox=True, loc='best')\n\n ax = plt.subplot(2, 2, 3)\n if len(self.Y_Xb.shape) == 0:\n nbchannels = 1\n else:\n nbchannels = self.Y_Xb.shape[0]\n\n channels = np.arange(1, nbchannels + 1)\n\n print(self.Y_Xb.shape)\n print(channels.shape)\n ax.plot(channels, self.Y_Xt, color=\"black\", label=\"BT True\")\n ax.plot(channels, self.Y_Xb, color=\"blue\", label=\"BT Background\")\n ax.plot(channels, self.Y_Xt + self.N,\n color=\"yellow\", label=\"BT True+Noise\")\n ax.legend(prop={'size': 10}, shadow=True, fancybox=True, loc='best')\n plt.title(self.satellite + \" \" + self.instrument)\n plt.show()\n\n\nclass Bmatrix(object):\n \"\"\" Class for dealing with the background error covariance\n matrices used by the 1DVar sheme \"\"\"\n\n def __init__(self):\n self.matrices = {}\n self.header = {}\n self.dimension = {}\n\n def _read(self, f, dim=86):\n\n data = np.zeros((dim * dim), dtype=np.float64)\n indice = 0\n while indice < dim * dim:\n lin = f.readline().split()\n for value_str in lin:\n data[indice] = np.float64(value_str)\n indice = indice + 1\n return data.reshape(dim, dim)\n\n def read_matrices(self, filename):\n f = open(filename)\n for j in (1, 2, 3, 4):\n self.header[j] = []\n for i in (0, 1, 3):\n k = f.readline()\n self.header[j].append(k)\n self.dimension[j] = int(k)\n self.matrices[j] = self._read(f, dim=self.dimension[j])\n\n # convert lnq g/kg in ppmv for Q\n dim = self.dimension[j]\n for k in range(dim - 29 - 3, dim - 3):\n for l in range(dim - 29 - 3, dim - 3):\n self.matrices[j][k, l] = q_mixration_to_ppmv * \\\n np.exp(self.matrices[j][k, l]) * 0.001\n self.matrices[j][dim - 2, dim - 2] = q_mixration_to_ppmv * \\\n np.exp(self.matrices[j][dim - 2, dim - 2]) * 0.001\n\n f.close()\n\n def plot(self, j):\n print \"Bmatrice :\", j\n print self.matrices[j]\n\n plt.imshow(self.matrices[j], origin=\"lower\", interpolation=\"nearest\")\n plt.title(self.header[j][0])\n plt.colorbar()\n plt.show()\n\n\nclass RmatrixBase(object):\n \"\"\" Class for dealing with mesurement error covariance matrix\n used by the 1DVar scheme \"\"\"\n\n def __init__(self):\n pass\n\n def read(self, filename):\n pass\n\n\nclass Rmatrix(RmatrixBase):\n\n def read(self, filename):\n \"\"\" Rmatrix fila structure is explained here : \"\"\"\n \"\"\" https://nwpsaf.eu/deliverables/nwpsaf_1dvar/\n nwpsaf-mo-ud-032_NWPSAF_1DVar_Manual.html#aux \"\"\"\n \"\"\" read the entire file : populate a dictionary named Rmatrx with :\"\"\"\n \"\"\" nchannels : number of channels\"\"\"\n \"\"\" nband : number of band \"\"\"\n \"\"\" inverse : \"\"\"\n \"\"\" type :\"\"\"\n \"\"\" data : the data\"\"\"\n \"\"\" finaly with the __mkMatrix method is called to make the Matrix \"\"\"\n \"\"\" dictionary which will contain numpy arrays \"\"\"\n\n self.Rmatrix = {}\n logging.debug(\"open \" + filename)\n f = open(filename)\n cond = True\n while cond:\n l = f.readline()\n if len(l) == 0:\n cond = False\n continue\n satint = l.replace(\"\\n\", \"\")\n logging.debug(\"read\" + str(satint))\n self.Rmatrix[satint] = {}\n line = f.readline()\n self.Rmatrix[satint][\"type\"], self.Rmatrix[satint][\n \"nchannel\"], self.Rmatrix[\n satint][\"nband\"], self.Rmatrix[satint][\"inverse\"] = [\n int(x) for x in line.split()]\n logging.debug(str(self.Rmatrix[satint][\"type\"]) +\n str(self.Rmatrix[satint][\"nchannel\"]) +\n str(self.Rmatrix[satint][\"nband\"]) +\n str(self.Rmatrix[satint][\"inverse\"]))\n if self.Rmatrix[satint][\"type\"] == 2:\n self.Rmatrix[satint][\"channel\"] = []\n self.Rmatrix[satint][\"data\"] = {}\n while (len(self.Rmatrix[satint][\"channel\"]) <\n self.Rmatrix[satint][\"nchannel\"]):\n l = f.readline().split()\n for x in l:\n self.Rmatrix[satint][\"channel\"].append(int(x))\n for band in range(self.Rmatrix[satint][\"nband\"]):\n self.Rmatrix[satint][\"data\"][band] = []\n while (len(self.Rmatrix[satint][\"data\"][band]) <\n self.Rmatrix[satint][\"nchannel\"]):\n l = f.readline().split()\n for x in l:\n self.Rmatrix[satint][\"data\"][band].append(float(x))\n logging.debug(\"end\")\n else:\n logging.debug('cannot read matrix')\n cond = False\n self._mkMatrix()\n\n def _mkMatrix(self):\n \"\"\" create the matrix from the data read \"\"\"\n logging.debug(\"create the matrix\")\n for satint in self.Rmatrix.keys():\n logging.debug(\"create the matrix for satellite\" + satint +\n str(self.Rmatrix[satint][\"type\"]) +\n str(self.Rmatrix[satint][\"nband\"]))\n self.Rmatrix[satint][\"matrix\"] = np.zeros(\n (self.Rmatrix[satint][\"nchannel\"],\n self.Rmatrix[satint][\"nchannel\"]), dtype=float)\n if (\n self.Rmatrix[satint][\"type\"] == 2 and\n self.Rmatrix[satint][\"nband\"] == 1):\n for i in range(self.Rmatrix[satint][\"nchannel\"]):\n self.Rmatrix[satint][\"matrix\"][\n i, i] = self.Rmatrix[satint][\"data\"][0][i]\n\n if (\n self.Rmatrix[satint][\"type\"] == 2 and\n self.Rmatrix[satint][\"nband\"] != 1):\n # diagonal case\n for i in range(self.Rmatrix[satint][\"nchannel\"]):\n self.Rmatrix[satint][\"matrix\"][\n i, i] = self.Rmatrix[satint][\"data\"][0][i]\n\n for band in range(1, self.Rmatrix[satint][\"nband\"]):\n logging.debug(\"band\" + str(band))\n\n for i in range(0, self.Rmatrix[satint][\"nchannel\"] - band):\n self.Rmatrix[satint][\"matrix\"][\n i + band, i] = self.Rmatrix[satint][\"data\"][band][\n i]\n self.Rmatrix[satint][\"matrix\"][\n i, i + band] = self.Rmatrix[satint][\"data\"][band][\n i]\n\n def plot_matrix(self):\n for satint in self.Rmatrix.keys():\n plt.imshow(self.Rmatrix[satint][\"matrix\"],\n origin=\"upper\", interpolation=\"nearest\")\n plt.title(satint)\n plt.colorbar()\n plt.show()\n\n\nclass Nwpsaf1dvarProfile(object):\n\n def __init__(self):\n self.data = {}\n\n def toRttovGuiProfile(self):\n \"\"\" convert Background to profile \"\"\"\n\n self.profile = rmodel.project.pProfile()\n self.option = rmodel.project.pOption()\n self.option.default()\n self.profile.setDefaultAttributes()\n self.profile[\"NLEVELS\"] = self.data[\"P\"][::-1].shape[0]\n self.profile[\"LAYERS\"] = self.profile[\"NLEVELS\"] - 1\n self.profile[\"P\"] = self.data[\"P\"][::-1]\n self.profile[\"T\"] = self.data[\"T\"][::-1]\n self.profile[\"Q\"] = self.data[\"Q\"][::-1]\n self.profile[\"O3\"] = self.data[\"O3\"][::-1]\n self.profile[\"S2M\"][\"T\"] = self.data[\"Surface Temperature (K)\"]\n self.profile[\"SKIN\"][\"T\"] = self.data[\"Skin Temperature (K)\"]\n for k, v in self.data.items():\n if k.startswith(\"Surface Humidity\"):\n self.profile[\"S2M\"][\"Q\"] = v\n self.profile[\"S2M\"][\"U\"] = self.data[\"10m U-Wind (m/s)\"]\n self.profile[\"S2M\"][\"V\"] = self.data[\"10m U-Wind (m/s)\"]\n self.profile[\"S2M\"][\"P\"] = self.data[\"Surface Pressure (hPa)\"]\n self.profile.setDefaultProfileAsciiInput()\n return self.profile\n\n\nclass RetrievedProfile(object):\n \"\"\" class for dealing with 1D var ascii Retrieved_Profile files\n from the NWPDAF 1DVAR software \"\"\"\n \"\"\" read them and transform it in profile object \"\"\"\n\n def __init__(self):\n self.retrieved = Nwpsaf1dvarProfile()\n self.background = Nwpsaf1dvarProfile()\n self.header = {}\n\n def read(self, filename):\n data = np.genfromtxt(filename, skip_header=3, skip_footer=8)\n self.retrieved.data[\"P\"] = data[:, 0]\n self.retrieved.data[\"T\"] = data[:, 1]\n self.retrieved.data[\"Q\"] = data[:, 2]\n self.retrieved.data[\"O3\"] = data[:, 3]\n self.background.data[\"P\"] = data[:, 0]\n self.background.data[\"T\"] = data[:, 4]\n self.background.data[\"Q\"] = data[:, 5]\n self.background.data[\"O3\"] = data[:, 5]\n\n def plot(self):\n colors = {0: \"red\",\n 1: \"orange\",\n 2: \"yellow\",\n 3: \"magenta\",\n 4: \"brown\"\n }\n ax = plt.subplot(2, 2, 1)\n Xb = self.background\n Xr = self.retrieved\n\n Y = self.background.data[\"P\"][:]\n pression = Y\n print (\"pression\")\n for k in range(0, pression.shape[0]):\n print (\"%.2f\" % pression[k])\n ax.set_ylim((pression[0] + 30, pression[-1]))\n ax.set_yscale(\"log\")\n ax.plot(Xb.data[\"T\"], Y, color=\"blue\", label=\"T background\")\n ax.plot(Xr.data[\"T\"], Y, color=\"red\", label=\"T retrieved\")\n\n ax.legend(prop={'size': 10}, shadow=True, fancybox=True, loc='best')\n ax = plt.subplot(2, 2, 2)\n ax.set_ylim((pression[0] + 30, pression[-1]))\n\n ax.set_yscale(\"log\")\n\n ax.plot(Xb.data[\"Q\"], pression, color=\"blue\", label=\"Q background\")\n\n ax.plot(Xr.data[\"Q\"], pression, color=\"red\", label=\"Q retrieved \")\n\n ax.legend(prop={'size': 10}, shadow=True, fancybox=True, loc='best')\n\n plt.show()\n\n\nclass Background(object):\n \"\"\" class for dealing with 1D var ascii Backround files from the\n NWPDAF 1DVAR software \"\"\"\n \"\"\" read them and transform it in profile object \"\"\"\n\n def __init__(self):\n self.prof = Nwpsaf1dvarProfile()\n self.data = {}\n self.header = {}\n\n def read(self, filename):\n data = np.genfromtxt(filename, skip_header=16, skip_footer=6)\n\n self.data[\"P\"] = data[:, 0]\n self.data[\"T\"] = data[:, 1]\n self.data[\"Q\"] = data[:, 2]\n self.data[\"O3\"] = data[:, 3]\n self.nlevels = data.shape[0]\n\n labels = np.genfromtxt(\n filename, usecols=0, dtype=str, skip_header=16 + data.shape[0],\n delimiter=\":\")\n raw_data = np.genfromtxt(\n filename, skip_header=16 + data.shape[0], delimiter=\":\")[:, 1:]\n\n self.data_surf = {label: row for label,\n row in zip(labels, raw_data[:, 0])}\n for key in (\"P\", \"Q\", \"T\", \"O3\"):\n self.prof.data[key] = self.data[key]\n self.prof.data[\"Surface Temperature (K)\"] = self.data_surf[\n \"Surface Temperature (K)\"]\n self.prof.data[\"Skin Temperature (K)\"] = self.data_surf[\n \"Skin Temperature (K)\"]\n self.prof.data[\"10m U-Wind (m/s)\"] = self.data_surf[\"10m U-Wind (m/s)\"]\n self.prof.data[\"10m U-Wind (m/s)\"] = self.data_surf[\"10m U-Wind (m/s)\"]\n self.prof.data[\"Surface Pressure (hPa)\"] = self.data_surf[\n \"Surface Pressure (hPa)\"]\n\n def toProfile(self):\n return self.prof.toRttovGuiProfile()\n\n def print_data(self):\n print (\"P\")\n print (self.data[\"P\"])\n print (\"T\")\n print (self.data[\"T\"])\n print (\"Q\")\n print (self.data[\"Q\"])\n print (\"O3\")\n print (self.data[\"P\"])\n print (self.data_surf)\n\n\nif __name__ == '__main__':\n\n rmatrixfilename = \"./data/IASI_COEFFS_DIR/Rmatrix_orig\"\n\n print (\"rmatrixfilename\")\n R = Rmatrix()\n R.read(rmatrixfilename)\n R.plot_matrix()\n", "meta": {"hexsha": "1a2c6d080daf533775c54240529b2612d708e873", "size": 37287, "ext": "py", "lang": "Python", "max_stars_repo_path": "source/gui/r1Dvar/r1dvar.py", "max_stars_repo_name": "bucricket/projectMAScorrection", "max_stars_repo_head_hexsha": "89489026c8e247ec7c364e537798e766331fe569", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "source/gui/r1Dvar/r1dvar.py", "max_issues_repo_name": "bucricket/projectMAScorrection", "max_issues_repo_head_hexsha": "89489026c8e247ec7c364e537798e766331fe569", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-03-12T12:19:59.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-12T12:19:59.000Z", "max_forks_repo_path": "source/gui/r1Dvar/r1dvar.py", "max_forks_repo_name": "bucricket/projectMAScorrection", "max_forks_repo_head_hexsha": "89489026c8e247ec7c364e537798e766331fe569", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.1367061356, "max_line_length": 79, "alphanum_fraction": 0.5375063695, "include": true, "reason": "import numpy", "num_tokens": 9104, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583269943353744, "lm_q2_score": 0.3486451217982255, "lm_q1q2_score": 0.19465798294329376}} {"text": "# pulsar.py\n\n# Class containing pulsar data from timing package [tempo2/PINT].\n\nfrom __future__ import (absolute_import, division,\n print_function, unicode_literals)\n\nimport enterprise\nimport numpy as np\nfrom ephem import Ecliptic, Equatorial\nimport os\nimport json\nfrom enterprise.signals import utils\nimport logging\n\ntry:\n import cPickle as pickle\nexcept:\n import pickle\n\ntry:\n import libstempo as t2\nexcept ImportError:\n print('Ooh, no libstempo?')\n t2 = None\n\ntry:\n import pint\n import pint.toa as toa\n import pint.models.model_builder as mb\n from pint.models import TimingModel\n from pint.residuals import Residuals as resids\nexcept ImportError:\n print('Cannot import PINT? Meh...')\n pint = None\n\nimport astropy.units as u\n\nif pint is None and t2 is None:\n err_msg = 'Must have either PINT or libstempo timing package installed'\n raise ImportError(err_msg)\n\nlogging.basicConfig(format='%(levelname)s: %(name)s: %(message)s',\n level=logging.INFO)\nlogger = logging.getLogger(__name__)\n\n\ndef get_maxobs(timfile):\n \"\"\"Utility function to return number of lines in tim file.\n\n :param timfile:\n Full path to tim-file. For tim-files that use INCLUDEs this\n should be the base tim file.\n\n :returns: Number of lines in tim-file\n \"\"\"\n\n maxobs = 0\n with open(timfile) as tfile:\n flines = tfile.readlines()\n lines = [ln for ln in flines if not ln.startswith('C')]\n if any(map(lambda x: 'INCLUDE' in x, lines)):\n for line in filter(lambda x: 'INCLUDE' in x, lines):\n maxobs += get_maxobs(line.split()[-1])\n else:\n maxobs = sum(1 for line in lines if line.rstrip('\\n'))\n return maxobs\n\n\nclass BasePulsar(object):\n \"\"\"Abstract Base Class for Pulsar objects.\"\"\"\n\n def _get_pdist(self):\n dfile = enterprise.__path__[0] + '/datafiles/pulsar_distances.json'\n with open(dfile, 'r') as fl:\n pdict = json.load(fl)\n\n if self.name[0] not in ['J', 'B']:\n if 'J' + self.name in pdict:\n pdist = tuple(pdict.get('J'+self.name))\n elif 'B' + self.name in pdict:\n pdist = tuple(pdict.get('B'+self.name))\n else:\n pdist = tuple(pdict.get(self.name, (1.0, 0.2)))\n\n if pdist == (1.0, 0.2):\n msg = 'WARNING: Could not find pulsar distance for '\n msg += 'PSR {0}.'.format(self.name)\n msg += ' Setting value to 1 with 20% uncertainty.'\n logger.warning(msg)\n return pdist\n\n def _get_radec_from_ecliptic(self, elong, elat):\n # convert via pyephem\n try:\n ec = Ecliptic(elong, elat)\n\n # check for B name\n if 'B' in self.name:\n epoch = '1950'\n else:\n epoch = '2000'\n eq = Equatorial(ec, epoch=str(epoch))\n raj = np.double(eq.ra)\n decj = np.double(eq.dec)\n\n except TypeError:\n msg = 'WARNING: Cannot fine sky location coordinates '\n msg += 'for PSR {0}. '.format(self.name)\n msg += 'Setting values to 0.0'\n logger.warning(msg)\n raj = 0.0\n decj = 0.0\n\n return raj, decj\n\n def _get_pos(self):\n return np.array([np.cos(self._raj) * np.cos(self._decj),\n np.sin(self._raj) * np.cos(self._decj),\n np.sin(self._decj)])\n\n def sort_data(self):\n \"\"\"Sort data by time.\"\"\"\n if self._sort:\n self._isort = np.argsort(self._toas, kind='mergesort')\n self._iisort = np.zeros(len(self._isort), dtype=np.int)\n for ii, p in enumerate(self._isort):\n self._iisort[p] = ii\n else:\n self._isort = slice(None, None, None)\n self._iisort = slice(None, None, None)\n\n def filter_data(self, start_time=None, end_time=None):\n \"\"\"Filter data to create a time-slice of overall dataset.\"\"\"\n if start_time is None and end_time is None:\n mask = np.ones(self._toas.shape, dtype=bool)\n else:\n mask = np.logical_and(self._toas >= start_time * 86400,\n self._toas <= end_time * 86400)\n\n self._toas = self._toas[mask]\n self._toaerrs = self._toaerrs[mask]\n self._residuals = self._residuals[mask]\n self._ssbfreqs = self._ssbfreqs[mask]\n\n self._designmatrix = self._designmatrix[mask, :]\n dmx_mask = np.sum(self._designmatrix, axis=0) != 0.0\n self._designmatrix = self._designmatrix[:, dmx_mask]\n\n for key in self._flags:\n self._flags[key] = self._flags[key][mask]\n\n if self._planetssb is not None:\n self._planetssb = self.planetssb[mask, :, :]\n\n self.sort_data()\n\n def to_pickle(self, outdir=None):\n \"\"\"Save object to pickle file.\"\"\"\n\n # drop t2pulsar object\n if hasattr(self, 't2pulsar'):\n del self.t2pulsar\n\n if outdir is None:\n outdir = os.getcwd()\n\n if not os.path.exists(outdir):\n os.makedirs(outdir)\n\n with open(outdir + '/{0}.pkl'.format(self.name), 'wb') as f:\n pickle.dump(self, f)\n\n @property\n def isort(self):\n \"\"\"Return sorting indices.\"\"\"\n return self._isort\n\n @property\n def iisort(self):\n \"\"\"Return inverse of sorting indices.\"\"\"\n return self._iisort\n\n @property\n def toas(self):\n \"\"\"Return array of TOAs in seconds.\"\"\"\n return self._toas[self._isort]\n\n @property\n def stoas(self):\n \"\"\"Return array of observatory TOAs in seconds.\"\"\"\n return self._stoas[self._isort]\n\n @property\n def residuals(self):\n \"\"\"Return array of residuals in seconds.\"\"\"\n return self._residuals[self._isort]\n\n @property\n def toaerrs(self):\n \"\"\"Return array of TOA errors in seconds.\"\"\"\n return self._toaerrs[self._isort]\n\n @property\n def freqs(self):\n \"\"\"Return array of radio frequencies in MHz.\"\"\"\n return self._ssbfreqs[self._isort]\n\n @property\n def Mmat(self):\n \"\"\"Return ntoa x npar design matrix.\"\"\"\n return self._designmatrix[self._isort, :]\n\n @property\n def pdist(self):\n \"\"\"Return tuple of pulsar distance and uncertainty in kpc.\"\"\"\n return self._pdist\n\n @property\n def dm(self):\n \"\"\"Return DM parameter from parfile.\"\"\"\n return self._dm\n\n @property\n def dmx(self):\n \"\"\"Return a dictionary of DMX-parameter values and stoa ranges\n from parfile.\"\"\"\n return self._dmx\n\n @property\n def flags(self):\n \"\"\"Return a dictionary of tim-file flags.\"\"\"\n\n return dict((k, v[self._isort]) for k, v in self._flags.items())\n\n @property\n def backend_flags(self):\n \"\"\"Return array of backend flags.\n\n Not all TOAs have the same flags for all data sets. In order to\n facilitate this we have a ranked ordering system that will look\n for flags. The order is `group`, `g`, `sys`, `i`, `f`, `fe`+`be`.\n\n \"\"\"\n\n nobs = len(self._toas)\n bflags = ['flag'] * nobs\n check = lambda i, fl: fl in self._flags and self._flags[fl][i] != ''\n flags = [['group'], ['g'], ['sys'], ['i'], ['f'], ['fe', 'be']]\n for ii in range(nobs):\n # TODO: make this cleaner\n for f in flags:\n if np.all(list(map(lambda xx: check(ii, xx), f))):\n bflags[ii] = '_'.join(self._flags[x][ii] for x in f)\n break\n return np.array(bflags)[self._isort]\n\n @property\n def theta(self):\n \"\"\"Return polar angle of pulsar in radians.\"\"\"\n return np.pi / 2 - self._decj\n\n @property\n def phi(self):\n \"\"\"Return azimuthal angle of pulsar in radians.\"\"\"\n return self._raj\n\n @property\n def pos(self):\n \"\"\"Return unit vector to pulsar.\"\"\"\n return self._pos\n\n @property\n def pos_t(self):\n \"\"\"Return unit vector to pulsar as function of time.\"\"\"\n return self._pos_t[self._isort, :]\n\n @property\n def planetssb(self):\n \"\"\"Return planetary position vectors at all timestamps\"\"\"\n return self._planetssb[self._isort, :, :]\n\n\nclass PintPulsar(BasePulsar):\n\n def __init__(self, toas, model, sort=True, planets=True):\n\n self._sort = sort\n self.planets = planets\n self.name = model.PSR.value\n\n self._toas = np.array(toas.table['tdbld'], dtype='float64') * 86400\n self._residuals = np.array(resids(toas, model).time_resids.to(u.s),\n dtype='float64')\n self._toaerrs = np.array(toas.get_errors().to(u.s), dtype='float64')\n self._designmatrix = model.designmatrix(toas)[0]\n self._ssbfreqs = np.array(model.barycentric_radio_freq(toas),\n dtype='float64')\n\n # fitted parameters\n self.fitpars = ['Offset'] + [par for par in model.params\n if not getattr(model, par).frozen]\n\n # set parameters\n spars = [par for par in model.params]\n self.setpars = [sp for sp in spars if sp not in self.fitpars]\n\n self._flags = {}\n for ii, obsflags in enumerate(toas.get_flags()):\n for jj, flag in enumerate(obsflags):\n\n if flag not in list(self._flags.keys()):\n self._flags[flag] = [''] * toas.ntoas\n\n self._flags[flag][ii] = obsflags[flag]\n\n # convert flags to arrays\n # TODO probably better way to do this\n for key, val in self._flags.items():\n if isinstance(val[0], u.quantity.Quantity):\n self._flags[key] = np.array([v.value for v in val])\n else:\n self._flags[key] = np.array(val)\n\n self._pdist = self._get_pdist()\n self._raj, self._decj = self._get_radec(model)\n self._pos = self._get_pos()\n self._planetssb = self._get_planetssb()\n\n # TODO: pos_t not currently implemented\n self._pos_t = np.zeros((len(self._toas), 3))\n\n self.sort_data()\n\n def _get_radec(self, model):\n if hasattr(model, 'RAJ') and hasattr(model, 'DECJ'):\n return (model.RAJ.value, model.DECJ.value)\n else:\n # TODO: better way of dealing with units\n d2r = np.pi / 180\n elong, elat = model.ELONG.value, model.ELAT.value\n return self._get_radec_from_ecliptic(elong*d2r, elat*d2r)\n\n def _get_planetssb(self):\n return np.zeros((len(self._toas), 9, 6))\n\n\nclass Tempo2Pulsar(BasePulsar):\n\n def __init__(self, t2pulsar, sort=True,\n drop_t2pulsar=True, planets=True):\n\n self._sort = sort\n self.t2pulsar = t2pulsar\n self.planets = planets\n self.name = str(t2pulsar.name)\n\n self._toas = np.double(t2pulsar.toas()) * 86400\n # saving also stoas (e.g., for DMX comparisons)\n self._stoas = np.double(t2pulsar.stoas) * 86400\n self._residuals = np.double(t2pulsar.residuals())\n self._toaerrs = np.double(t2pulsar.toaerrs) * 1e-6\n self._designmatrix = np.double(t2pulsar.designmatrix())\n self._ssbfreqs = np.double(t2pulsar.ssbfreqs()) / 1e6\n\n # fitted parameters\n self.fitpars = ['Offset'] + list(map(str, t2pulsar.pars()))\n\n # set parameters\n spars = list(map(str, t2pulsar.pars(which='set')))\n self.setpars = [sp for sp in spars if sp not in self.fitpars]\n\n self._flags = {}\n for key in t2pulsar.flags():\n self._flags[key] = t2pulsar.flagvals(key)\n\n self._pdist = self._get_pdist()\n self._raj, self._decj = self._get_radec(t2pulsar)\n self._pos = self._get_pos()\n self._planetssb = self._get_planetssb(t2pulsar)\n\n # gather DM/DMX information if available\n self._set_dm(t2pulsar)\n\n self._pos_t = t2pulsar.psrPos.copy()\n if 'ELONG' and 'ELAT' in np.concatenate((t2pulsar.pars(which='fit'),\n t2pulsar.pars(which='set'))):\n self._pos_t = utils.ecl2eq_vec(self._pos_t)\n\n self.sort_data()\n\n if drop_t2pulsar:\n del self.t2pulsar\n\n # gather DM/DMX information if available\n def _set_dm(self, t2pulsar):\n pars = t2pulsar.pars(which='set')\n\n if 'DM' in pars:\n self._dm = t2pulsar['DM'].val\n\n dmx = {par: {'DMX': t2pulsar[par].val,\n 'DMXerr': t2pulsar[par].err,\n 'DMXR1': t2pulsar[par[:3] + 'R1' + par[3:]].val,\n 'DMXR2': t2pulsar[par[:3] + 'R2' + par[3:]].val,\n 'fit': par in pars}\n for par in pars if 'DMX_' in par}\n\n if dmx:\n self._dmx = dmx\n\n def _get_radec(self, t2pulsar):\n if 'RAJ' in np.concatenate((t2pulsar.pars(which='fit'),\n t2pulsar.pars(which='set'))):\n return (np.double(t2pulsar['RAJ'].val),\n np.double(t2pulsar['DECJ'].val))\n\n else:\n # use ecliptic coordinates\n elong = t2pulsar['ELONG'].val\n elat = t2pulsar['ELAT'].val\n return self._get_radec_from_ecliptic(elong, elat)\n\n def _get_planetssb(self, t2pulsar):\n planetssb = None\n if self.planets:\n for ii in range(1, 10):\n tag = 'DMASSPLANET' + str(ii)\n self.t2pulsar[tag].val = 0.0\n self.t2pulsar.formbats()\n planetssb = np.zeros((len(self._toas), 9, 6))\n planetssb[:, 0, :] = self.t2pulsar.mercury_ssb\n planetssb[:, 1, :] = self.t2pulsar.venus_ssb\n planetssb[:, 2, :] = self.t2pulsar.earth_ssb\n planetssb[:, 3, :] = self.t2pulsar.mars_ssb\n planetssb[:, 4, :] = self.t2pulsar.jupiter_ssb\n planetssb[:, 5, :] = self.t2pulsar.saturn_ssb\n planetssb[:, 6, :] = self.t2pulsar.uranus_ssb\n planetssb[:, 7, :] = self.t2pulsar.neptune_ssb\n planetssb[:, 8, :] = self.t2pulsar.pluto_ssb\n\n if 'ELONG' and 'ELAT' in np.concatenate((t2pulsar.pars(),\n t2pulsar.pars(\n which='set'))):\n for ii in range(9):\n planetssb[:,ii,:3] = utils.ecl2eq_vec(planetssb[:,ii,:3])\n planetssb[:,ii,3:] = utils.ecl2eq_vec(planetssb[:,ii,3:])\n return planetssb\n\n\ndef Pulsar(*args, **kwargs):\n\n ephem = kwargs.get('ephem', None)\n clk = kwargs.get('clk', None)\n planets = kwargs.get('planets', True)\n sort = kwargs.get('sort', True)\n drop_t2pulsar = kwargs.get('drop_t2pulsar', True)\n timing_package = kwargs.get('timing_package', 'tempo2')\n\n if pint is not None:\n toas = list(filter(lambda x: isinstance(x, toa.TOAs), args))\n model = list(filter(lambda x: isinstance(x, TimingModel), args))\n\n if t2 is not None:\n t2pulsar = list(filter(lambda x: isinstance(x, t2.tempopulsar), args))\n\n parfile = list(filter(lambda x: isinstance(x, str) and\n x.split('.')[-1] == 'par', args))\n timfile = list(filter(lambda x: isinstance(x, str) and\n x.split('.')[-1] in ['tim', 'toa'], args))\n\n if pint and toas and model:\n return PintPulsar(toas[0], model[0], sort=sort, planets=planets)\n elif t2 and t2pulsar:\n return Tempo2Pulsar(t2pulsar[0], sort=sort,\n drop_t2pulsar=drop_t2pulsar,\n planets=planets)\n elif parfile and timfile:\n # Check whether the two files exist\n if not os.path.isfile(parfile[0]) or not os.path.isfile(timfile[0]):\n msg = 'Cannot find parfile {0} or timfile {1}!'.format(\n parfile[0], timfile[0])\n raise IOError(msg)\n\n # Obtain the directory name of the timfile, and change to it\n timfiletup = os.path.split(timfile[0])\n dirname = timfiletup[0] or './'\n reltimfile = timfiletup[-1]\n relparfile = os.path.relpath(parfile[0], dirname)\n\n # get current directory\n cwd = os.getcwd()\n\n # Change directory to the base directory of the tim-file to deal with\n # INCLUDE statements in the tim-file\n os.chdir(dirname)\n\n if timing_package.lower() == 'pint':\n if ephem is None:\n ephem = 'DE421'\n if clk is None:\n bipm_version = 'BIPM2015'\n else:\n bipm_version = clk.split('(')[1][:-1]\n toas = toa.get_TOAs(reltimfile, ephem=ephem, planets=planets,\n bipm_version=bipm_version)\n model = mb.get_model(relparfile)\n os.chdir(cwd)\n return PintPulsar(toas, model, sort=sort, planets=planets)\n\n elif timing_package.lower() == 'tempo2':\n\n # hack to set maxobs\n maxobs = get_maxobs(reltimfile) + 100\n t2pulsar = t2.tempopulsar(relparfile, reltimfile,\n maxobs=maxobs, ephem=ephem, clk=clk)\n os.chdir(cwd)\n return Tempo2Pulsar(t2pulsar, sort=sort,\n drop_t2pulsar=drop_t2pulsar,\n planets=planets)\n else:\n print('Unknown arguments {}'.format(args))\n", "meta": {"hexsha": "8aa29a0896fcc40c4020f3de9689154ffb2742a8", "size": 17517, "ext": "py", "lang": "Python", "max_stars_repo_path": "enterprise/pulsar.py", "max_stars_repo_name": "stevertaylor/enterprise", "max_stars_repo_head_hexsha": "a18bc0e2535bf50cc5cc74a346f7f50ccfe4727f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2018-10-10T15:24:16.000Z", "max_stars_repo_stars_event_max_datetime": "2018-10-10T18:05:32.000Z", "max_issues_repo_path": "enterprise/pulsar.py", "max_issues_repo_name": "potatoxia/enterprise", "max_issues_repo_head_hexsha": "bd12f4165827e83dda8daedd20c6b2194cb90158", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2018-03-20T18:46:48.000Z", "max_issues_repo_issues_event_max_datetime": "2018-03-20T18:46:48.000Z", "max_forks_repo_path": "enterprise/pulsar.py", "max_forks_repo_name": "stevertaylor/enterprise", "max_forks_repo_head_hexsha": "a18bc0e2535bf50cc5cc74a346f7f50ccfe4727f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-10-30T12:22:27.000Z", "max_forks_repo_forks_event_max_datetime": "2019-10-30T12:22:27.000Z", "avg_line_length": 33.4933078394, "max_line_length": 78, "alphanum_fraction": 0.5611120626, "include": true, "reason": "import numpy,import astropy", "num_tokens": 4679, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583269943353744, "lm_q2_score": 0.34864512179822543, "lm_q1q2_score": 0.19465798294329373}} {"text": "#################################################################################\n# Copyright (c) 2011-2013, Pacific Biosciences of California, Inc.\n#\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or without\n# modification, are permitted provided that the following conditions are met:\n# * Redistributions of source code must retain the above copyright\n# notice, this list of conditions and the following disclaimer.\n# * Redistributions in binary form must reproduce the above copyright\n# notice, this list of conditions and the following disclaimer in the\n# documentation and/or other materials provided with the distribution.\n# * Neither the name of Pacific Biosciences nor the names of its\n# contributors may be used to endorse or promote products derived from\n# this software without specific prior written permission.\n#\n# NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY\n# THIS LICENSE. THIS SOFTWARE IS PROVIDED BY PACIFIC BIOSCIENCES AND ITS\n# CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A\n# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL PACIFIC BIOSCIENCES OR\n# ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\n# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR\n# BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER\n# IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n# POSSIBILITY OF SUCH DAMAGE.\n#################################################################################\n\nfrom math import sqrt\nimport math\nimport scipy.stats as s\nimport array as a\nimport sys\n\nfrom numpy import log, pi, log10, e, log1p, exp\nimport numpy as np\nimport re\n\nlog10e = log10(e)\n\ncanonicalBaseMap = {'A': 'A', 'C': 'C', 'G': 'G', 'T': 'T', 'H': 'A', 'I': 'C', 'J': 'C', 'K': 'C'}\nmodNames = {'H': 'm6A', 'I': 'm5C', 'J': 'm4C', 'K': 'm5C'}\n\nm5CCode = 'I'\n\niupacMap = {\n 'A': 'A',\n 'C': 'C',\n 'G': 'G',\n 'T': 'T',\n 'K': 'GT',\n 'M': 'AC',\n 'R': 'AG',\n 'Y': 'CT',\n 'S': 'CG',\n 'W': 'AT',\n 'B': 'CGT',\n 'D': 'AGT',\n 'H': 'ACT',\n 'V': 'ACG',\n 'N': 'ACGT'\n}\n\n\ndef findMotifPositions(seq, motifs):\n regexs = []\n\n # Generate a regex for each motif, honouring degenerate bases\n for m in motifs:\n regex = ''\n\n for c in m:\n regex = regex + \"[\" + iupacMap[c] + \"]\"\n\n regexs.append(regex)\n\n allMatches = []\n\n # Return a list of matching positions in the sequence\n for r in regexs:\n rr = re.compile(r)\n matches = [x.start() for x in rr.finditer(seq)]\n allMatches.extend(matches)\n\n allMatches.sort()\n\n return allMatches\n\n\nclass MultiSiteDetection(object):\n\n def __init__(self, gbmModel, sequence, rawKinetics, callBounds, methylMinCov, motifs=['CG']):\n \"\"\"\n\n \"\"\"\n\n self.methylMinCov = methylMinCov\n self.motifs = motifs\n\n self.gbmModel = gbmModel\n self.sequence = sequence\n\n self.callStart = callBounds[0]\n self.callEnd = callBounds[1]\n\n # Extents that we will attempt to call a modification\n self.callRange = xrange(self.callStart, self.callEnd)\n\n # These switch because we changing viewpoints\n self.pre = gbmModel.post\n self.post = gbmModel.pre\n\n self.lStart = self.pre\n self.lEnd = len(self.sequence) - self.post\n\n # Extents that we will use for likelihoods\n self.likelihoodRange = xrange(self.lStart, self.lEnd)\n\n self.alternateBases = dict((x, list(sequence[x])) for x in xrange(len(sequence)))\n\n self.rawKinetics = rawKinetics\n\n def getConfigs(self, centerIdx):\n ''' Enumerate all the contexts centered at centerIdx with one\n modification added '''\n start = centerIdx - self.pre\n end = centerIdx + self.post\n return self._possibleConfigs(start, end)\n\n def _possibleConfigs(self, start, end):\n ''' Enumerate all the contexts coming from the substring self.sequence[start,end] with one\n modification added '''\n\n if start == end:\n return self.alternateBases[start]\n else:\n r = []\n allSuffixes = self._possibleConfigs(start + 1, end)\n\n # The first suffix is alway the one with no modifications\n # Only add the alternate to that one -- that way we only\n # get configurations with a single modification, not all combos\n\n noModsSuffix = allSuffixes[0]\n if len(allSuffixes) > 1:\n restSuffixes = allSuffixes[1:]\n else:\n restSuffixes = []\n\n # The noMods suffix get the alternates\n for c in self.alternateBases[start]:\n r.append(c + noModsSuffix)\n\n # the other suffixes already have mods -- they just get the unmodified base\n for suffix in restSuffixes:\n r.append(self.alternateBases[start][0] + suffix)\n\n return r\n\n # Compute something for all the windows in [start, end]\n def getContexts(self, start, end, sequence):\n contexts = []\n\n for pos in xrange(start, end + 1):\n ctx = sequence[(pos - self.pre):(pos + self.post + 1)].tostring()\n contexts.append(ctx)\n\n return contexts\n\n def computeContextMeans(self):\n \"\"\"Generate a hash of the mean ipd for all candidate contexts\"\"\"\n\n allContexts = []\n\n for pos in self.motifPositions:\n for offsetPos in xrange(pos - self.post, pos + self.pre + 1):\n cfgs = self.getConfigs(offsetPos)\n allContexts.extend(cfgs)\n\n predictions = self.gbmModel.getPredictions(allContexts)\n self.contextMeanTable = dict(zip(allContexts, predictions))\n\n def decode(self):\n \"\"\"Use this method to do the full modification finding protocol\"\"\"\n\n # Find sites matching the desired motif\n self.findMotifs()\n\n # Compute all the required mean ipds under all possible composite hypotheses\n self.computeContextMeans()\n\n # Compute a confidence for each mod and return results\n return self.scorePositions()\n\n def findMotifs(self):\n \"\"\" Mark all the positions matching the requested motif \"\"\"\n\n # Generate list of matching positions\n allMotifPositions = findMotifPositions(self.sequence, self.motifs)\n self.motifPositions = []\n\n for pos in allMotifPositions:\n # Only use bases that are inside the callBounds\n if self.callStart <= pos < self.callEnd:\n self.alternateBases[pos].append('I')\n self.motifPositions.append(pos)\n\n def multiSiteDetection(self, positions, nullPred, modPred, centerPosition):\n ''' kinetics, nullPred, and modifiedPred are parallel arrays \n containing the observations and predictions surrounding a \n single candidate motif site. Estimate the p-value of\n modification and the modified fraction here'''\n\n # Apply the error model to the predictions\n nullErr = 0.01 + 0.03 * nullPred + 0.06 * nullPred ** (1.7)\n modErr = 0.01 + 0.03 * modPred + 0.06 * modPred ** (1.7)\n\n obsMean = np.zeros(nullPred.shape)\n obsErr = np.zeros(nullPred.shape)\n\n # Get the observations into the same array format\n for i in xrange(len(positions)):\n position = positions[i]\n\n if position in self.rawKinetics:\n siteObs = self.rawKinetics[position]\n obsMean[i] = siteObs['tMean']\n obsErr[i] = siteObs['tErr']\n else:\n # Crank up the variance -- we don't have an observation at this\n # position, so we should ignore it.\n obsMean[i] = 0.0\n obsErr[i] = 999999999\n\n # Subtract off the background model from the observations and the modified prediction\n dObs = obsMean - nullPred\n # Error of observation and prediction are uncorrelated\n obsSigma = obsErr ** 2 + nullErr ** 2\n invObsSigma = 1.0 / obsSigma\n\n # Error of null prediction and mod prediction are probably correlated -- need a better estimate of the error of the difference!!\n dPred = modPred - nullPred\n dPredSigma = (obsErr ** 2 + nullErr ** 2) / 2 # Just stubbing in a factor of 2 here...\n\n weightsNumerator = invObsSigma * dPred\n weights = weightsNumerator / (dPred * weightsNumerator).sum()\n\n signalEstimate = (weights * dObs).sum()\n varianceEstimate = (np.abs(weights) * obsSigma).sum()\n\n maxSignal = (weights * dPred).sum()\n maxSignalVariance = (np.abs(weights) * dPredSigma).sum()\n\n # Now just run the standard erf on this Gaussian to quantify the probability that there is some signal\n # What we want now:\n #\n # 1. p-value that dObs * dPred (dot product) is greater than 0.\n # 2. Distribution of \\alpha, where dObs = \\alpha dPred, where \\alpha \\in [0,1], with appropriate error propagation\n # 2a. Is it possible to summarize 2 with a Beta distribution?\n\n pvalue = s.norm._cdf(-signalEstimate / varianceEstimate)\n pvalue = max(sys.float_info.min, pvalue)\n score = -10.0 * log10(pvalue)\n\n centerPosition['MSscore'] = score\n centerPosition['MSpvalue'] = pvalue\n\n centerPosition['signal'] = signalEstimate\n centerPosition['variance'] = varianceEstimate\n\n centerPosition['modelSignal'] = maxSignal\n centerPosition['modelVariance'] = maxSignalVariance\n\n centerPosition['Mask'] = []\n\n return centerPosition\n\n def scorePositions(self):\n \"\"\"\n Score each motif site in the sequence.\n \"\"\"\n\n qvModCalls = dict()\n\n dnaSeq = a.array('c')\n dnaSeq.fromstring(self.sequence)\n\n for pos in self.motifPositions:\n if pos in self.rawKinetics:\n\n # Fetch unmodified positions\n nullPred = self.getRegionPredictions(pos - self.post, pos + self.pre, dnaSeq)\n\n # Fetch modified positions and reset sequence\n originalBase = dnaSeq[pos]\n dnaSeq[pos] = m5CCode\n modifiedPred = self.getRegionPredictions(pos - self.post, pos + self.pre, dnaSeq)\n dnaSeq[pos] = originalBase\n\n # Position that contribute to this call\n positions = xrange(pos - self.post, pos + self.pre + 1)\n\n # Run the multi-site detection and save the results\n centerStats = self.rawKinetics[pos]\n centerStats = self.multiSiteDetection(positions, nullPred, modifiedPred, centerStats)\n\n qvModCalls[pos] = centerStats\n\n return qvModCalls\n\n def getRegionPredictions(self, start, end, sequence):\n predictions = np.zeros(end - start + 1)\n\n for pos in xrange(start, end + 1):\n ctx = sequence[(pos - self.pre):(pos + self.post + 1)].tostring()\n predictions[pos - start] = self.contextMeanTable[ctx]\n\n return predictions\n", "meta": {"hexsha": "96fb4ddd290977822cddf31ccb24e8017f13d605", "size": 11427, "ext": "py", "lang": "Python", "max_stars_repo_path": "SLpackage/private/pacbio/pythonpkgs/kineticstools/lib/python2.7/site-packages/kineticsTools/MultiSiteDetection.py", "max_stars_repo_name": "fanglab/6mASCOPE", "max_stars_repo_head_hexsha": "3f1fdcb7693ff152f17623ce549526ec272698b1", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2022-02-20T07:10:02.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-18T17:47:53.000Z", "max_issues_repo_path": "SLpackage/private/pacbio/pythonpkgs/kineticstools/lib/python2.7/site-packages/kineticsTools/MultiSiteDetection.py", "max_issues_repo_name": "fanglab/6mASCOPE", "max_issues_repo_head_hexsha": "3f1fdcb7693ff152f17623ce549526ec272698b1", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "SLpackage/private/pacbio/pythonpkgs/kineticstools/lib/python2.7/site-packages/kineticsTools/MultiSiteDetection.py", "max_forks_repo_name": "fanglab/6mASCOPE", "max_forks_repo_head_hexsha": "3f1fdcb7693ff152f17623ce549526ec272698b1", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.5981308411, "max_line_length": 136, "alphanum_fraction": 0.6150345673, "include": true, "reason": "import numpy,from numpy,import scipy", "num_tokens": 2664, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5698526514141571, "lm_q2_score": 0.34158251284363395, "lm_q1q2_score": 0.19465170062065518}} {"text": "# Copyright 2020 Arthur Coqué, Guillaume Morin, Pôle OFB-INRAE ECLA, UR RECOVER\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\"\"\"This module gathers wc algorithms used for estimating SPM concentrations.\n\nEach class of this module correspond to one algorithm. An algorithm can have\nseveral calibrations (a calibration is a set of parameters), either\npackaged within SISPPEO (these default calibrations are located in\n'resources/wc_algo_calibration') or provided by the user.\nBefore its utilisation, an algorithm has to be instantiate with specific\nsettings like the product_type of further input products, the calibration\nused, the band used (if needed), etc.\n\nExample:\n\n algo1 = SPMNechad('S2_GRS', 'B4', 'Nechad_2016')\n out_array2 = algo1(input_array, 'rho')\n\n algo2 = SPMGet('L8_GRS', 'GET_2018')\n out_array2 = algo2(red_array, nir_array, 'rrs')\n\"\"\"\n\nfrom pathlib import Path\nfrom typing import Optional, Union\n\nimport numpy as np\nimport xarray as xr\n\nfrom sisppeo.utils.algos import load_calib, producttype_to_sat\nfrom sisppeo.utils.config import wc_algo_config as algo_config, wc_calib\nfrom sisppeo.utils.exceptions import InputError\n\n# pylint: disable=invalid-name\n# Ok for a custom type.\nP = Union[str, Path]\nN = Union[int, float]\n\n\ndef _nechad(rho, a, c):\n ssc = a * rho / (1 - (rho / c))\n return ssc\n\n\nclass SPMNechad:\n \"\"\"Semi-analytical algorithm to retrieve SPM concentration (in mg/l) from reflectance.\n\n Semi-analytical algorithm to retrieve SPM concentrations (in mg/L) from\n surface reflectances (rho, unitless) or remote sensing reflectances (Rrs,\n in sr-1).\n This algorithm was presented in Nechad et al., 2010 and 2016.\n\n Attributes:\n name: The name of the algorithm used. This is the key used by\n L3AlgoBuilder and that you must provide in config or when using\n the CLI.\n requested_bands: A list of bands further used by the algorithm.\n meta: A dict of metadata (calibration name, model coefficients, etc).\n \"\"\"\n _default_band = 'B4'\n _default_calibration_file = wc_calib / 'spm_nechad.yaml'\n _default_calibration_name = 'Nechad_2016'\n name = 'spm-nechad'\n\n def __init__(self,\n product_type: str,\n requested_band: str = _default_band,\n calibration: Optional[P] = None,\n **_ignored) -> None:\n \"\"\"Inits an 'SPMNechad' instance with specific settings.\n\n Args:\n product_type: The type of the input satellite product (e.g.\n S2_ESA_L2A or L8_USGS_L1GT).\n requested_band: Optional; The band used by the algorithm (\n default=_default_band).\n calibration: The calibration (set of parameters) used by the\n algorithm (default=_default_calibration_name).\n **_ignored: Unused kwargs sent to trash.\n \"\"\"\n self.requested_bands = [requested_band]\n calibration_dict, calibration_name = load_calib(\n calibration,\n self._default_calibration_file,\n self._default_calibration_name\n )\n self._valid_limit = calibration_dict['validity_limit']\n try:\n params = calibration_dict[producttype_to_sat(product_type)][\n requested_band]\n except KeyError as invalid_input:\n msg = (f'{product_type} or {requested_band} is not allowed with '\n f'{self.name}/this calibration')\n raise InputError(msg) from invalid_input\n self.__dict__.update(params)\n self.meta = {'band': requested_band,\n 'calibration': calibration_name,\n 'validity_limit': self._valid_limit,\n **params}\n\n def __call__(self,\n rho: xr.DataArray,\n data_type: str,\n **_ignored) -> xr.DataArray:\n \"\"\"Runs the algorithm on the input array ('rho').\n\n Args:\n rho: An array (dimension 1 * N * M) of 'data_type'.\n data_type: Either 'rho' or 'rrs' (respectively surface reflectance\n and remote sensing reflectance).\n **_ignored: Unused kwargs sent to trash.\n\n Returns:\n An array (dimension 1 * N * M) of SPM concentration (in mg/L).\n \"\"\"\n\n if data_type == 'rrs':\n rho = np.pi * rho\n\n np.warnings.filterwarnings('ignore')\n # pylint: disable=no-member\n # Loaded in __init__ with \"__dict__.update\".\n spm = _nechad(rho, self.a, self.c)\n spm = spm.where((rho >= 0) & (spm >= 0) & (spm < self._valid_limit))\n return spm\n\n\nclass SPMHan:\n \"\"\"Switching Semi-analytical algorithm to retrieve SPM (in mg/l) from reflectance.\n\n Switching Semi-analytical algorithm to retrieve suspended particulate\n matter (in mg/l) from surface reflectances (rho, unitless) or remote\n sensing reflectances (Rrs, in sr-1).\n This algorithm was published in Han et al., 2016\n\n Attributes:\n name: The name of the algorithm used. This is the key used by\n L3AlgoBuilder and that you must provide in config or when using\n the CLI.\n requested_bands: A list of bands further used by the algorithm.\n meta: A dict of metadata (calibration name, model coefficients, etc).\n \"\"\"\n _default_calibration_file = wc_calib / 'spm_han.yaml'\n _default_calibration_name = 'Han_2016'\n name = 'spm-han'\n\n def __init__(self,\n product_type: str,\n calibration: Optional[P] = None,\n **_ignored) -> None:\n \"\"\"Inits an 'SPMHan' instance with specific settings.\n\n Args:\n product_type: The type of the input satellite product (e.g.\n S2_ESA_L2A or L8_USGS_L1GT)\n calibration: The calibration (set of parameters) used by the\n algorithm (default=_default_calibration_name).\n **_ignored: Unused kwargs sent to trash.\n \"\"\"\n try:\n self.requested_bands = algo_config[self.name][\n producttype_to_sat(product_type)]\n except KeyError as invalid_product:\n msg = f'{product_type} is not allowed with {self.name}'\n raise InputError(msg) from invalid_product\n calibration_dict, calibration_name = load_calib(\n calibration,\n self._default_calibration_file,\n self._default_calibration_name\n )\n self._valid_limit = calibration_dict['validity_limit']\n try:\n params = calibration_dict[producttype_to_sat(product_type)]\n except KeyError as invalid_product:\n msg = f'{product_type} is not allowed with this calibration'\n raise InputError(msg) from invalid_product\n self.__dict__.update(params)\n self.meta = {'calibration': calibration_name,\n 'validity_limit': self._valid_limit,\n **params}\n\n def __call__(self,\n refl_red: xr.DataArray,\n data_type: str,\n **_ignored) -> xr.DataArray:\n \"\"\"Runs the algorithm on the input array ('rho').\n\n Args:\n refl_red: An array (dimension 1 * N * M) of 'data_type'.\n data_type: Either 'rho' or 'rrs' (respectively surface reflectance\n and remote sensing reflectance).\n **_ignored: Unused kwargs sent to trash.\n\n Returns:\n An array (dimension 1 * N * M) of SPM concentration (in mg/L).\n \"\"\"\n if data_type == 'rho':\n refl_red = refl_red / np.pi\n print(data_type)\n\n np.warnings.filterwarnings('ignore')\n rrs_red = refl_red.where(refl_red >= 0)\n # pylint: disable=no-member\n # Loaded in __init__ whit \"__dict__.update\".\n spm_low = _nechad(rrs_red, self.a_low, self.c_low)\n spm_high = _nechad(rrs_red, self.a_high, self.c_high)\n\n w_low = np.log10(self.switch_sup) - np.log10(rrs_red)\n w_high = np.log10(rrs_red) - np.log10(self.switch_inf)\n spm_mixing = (w_low * spm_low + w_high * spm_high) / (w_low + w_high)\n\n spm = rrs_red.where(rrs_red > self.switch_inf, spm_low)\n spm = spm.where(rrs_red < self.switch_sup, spm_high)\n spm = spm.where((rrs_red <= self.switch_inf)\n | (rrs_red >= self.switch_sup), spm_mixing)\n spm = spm.where((spm >= 0) & (spm <= self._valid_limit))\n return spm\n\n\nclass SPMGet:\n \"\"\"Switching Semi-analytical algorithm to retrieve SPM (in mg/l) from reflectance.\n\n Switching Semi-analytical algorithm to retrieve suspended particulate\n matter (in mg/l) from surface reflectances (rho, unitless) or remote\n sensing reflectances (Rrs, in sr-1).\n This algorithm was calibrated on GET radiometric database in 2018.\n\n Attributes:\n name: The name of the algorithm used. This is the key used by\n L3AlgoBuilder and that you must provide in config or when using\n the CLI.\n requested_bands: A list of bands further used by the algorithm.\n meta: A dict of metadata (calibration name, model coefficients, etc).\n \"\"\"\n _default_calibration_file = wc_calib / 'spm_get.yaml'\n _default_calibration_name = 'GET_2018'\n name = 'spm-get'\n\n def __init__(self,\n product_type: str,\n calibration: Optional[P] = None,\n **_ignored) -> None:\n \"\"\"Inits an 'SPMGet' instance with specific settings.\n\n Args:\n product_type: The type of the input satellite product (e.g.\n S2_ESA_L2A or L8_USGS_L1GT)\n calibration: The calibration (set of parameters) used by the\n algorithm (default=_default_calibration_name).\n **_ignored: Unused kwargs sent to trash.\n \"\"\"\n try:\n self.requested_bands = algo_config[self.name][\n producttype_to_sat(product_type)]\n except KeyError as invalid_product:\n msg = f'{product_type} is not allowed with {self.name}'\n raise InputError(msg) from invalid_product\n calibration_dict, calibration_name = load_calib(\n calibration,\n self._default_calibration_file,\n self._default_calibration_name\n )\n self._switch_inf = calibration_dict['switch_inf']\n self._switch_sup = calibration_dict['switch_sup']\n self._valid_limit = calibration_dict['validity_limit']\n try:\n params = calibration_dict[producttype_to_sat(product_type)]\n except KeyError as invalid_product:\n msg = f'{product_type} is not allowed with this calibration'\n raise InputError(msg) from invalid_product\n self.__dict__.update(params)\n self.meta = {'calibration': calibration_name,\n 'switch inf': self._switch_inf,\n 'switch sup': self._switch_sup,\n 'validity_limit': self._valid_limit,\n **params}\n\n def __call__(self,\n refl_red: xr.DataArray,\n refl_nir: xr.DataArray,\n data_type: str,\n **_ignored) -> xr.DataArray:\n \"\"\"Runs the algorithm on the input array ('rho').\n\n Args:\n refl_red: An array (dimension 1 * N * M) of 'data_type'.\n data_type: Either 'rho' or 'rrs' (respectively surface reflectance\n and remote sensing reflectance).\n **_ignored: Unused kwargs sent to trash.\n\n Returns:\n An array (dimension 1 * N * M) of SPM concentration (in mg/L).\n \"\"\"\n if data_type == 'rrs':\n refl_red = np.pi * refl_red\n refl_nir = np.pi * refl_nir\n\n np.warnings.filterwarnings('ignore')\n rho_red = refl_red.where(refl_red >= 0)\n rho_nir = refl_red.where(refl_nir >= 0)\n\n # pylint: disable=no-member\n # Loaded in __init__ whit \"__dict__.update\".\n spm_low = _nechad(rho_red, self.a_nechad, self.c_nechad)\n spm_high = self.coef_br * np.power((rho_nir / rho_red), self.exp_br)\n\n w = ((rho_red - self._switch_inf)\n / (self._switch_sup - self._switch_inf))\n spm_mixing = (1 - w) * spm_low + w * spm_high\n\n spm = rho_red.where(rho_red > self._switch_inf, spm_low)\n spm = spm.where(rho_red < self._switch_sup, spm_high)\n spm = spm.where((rho_red <= self._switch_inf)\n | (rho_red >= self._switch_sup), spm_mixing)\n spm = spm.where((spm >= 0) & (spm <= self._valid_limit))\n return spm\n\n\nclass TURBIDogliotti:\n \"\"\"Switching Semi-analytical algorithm to retrieve Turbidity (in FNU) from reflectance.\n\n Switching Semi-analytical algorithm to retrieve Turbidity (in FNU) from\n surface reflectances (rho, unitless) or remote sensing reflectances (Rrs,\n in sr-1).\n This algorithm was published in Dogliotti et al., 2015\n\n Attributes:\n name: The name of the algorithm used. This is the key used by\n L3AlgoBuilder and that you must provide in config or when using\n the CLI.\n requested_bands: A list of bands further used by the algorithm.\n meta: A dict of metadata (calibration name, model coefficients, etc).\n \"\"\"\n _default_calibration_file = wc_calib / 'turbi_dogliotti.yaml'\n _default_calibration_name = 'Dogliotti_2015'\n name = 'turbi-dogliotti'\n\n def __init__(self,\n product_type: str,\n calibration: Optional[P] = None,\n **_ignored) -> None:\n \"\"\"Inits an 'TURBIDogliotti' instance with specific settings.\n\n Args:\n product_type: The type of the input satellite product (e.g.\n S2_ESA_L2A or L8_USGS_L1GT)\n calibration: The calibration (set of parameters) used by the\n algorithm (default=_default_calibration_name).\n **_ignored: Unused kwargs sent to trash.\n \"\"\"\n try:\n self.requested_bands = algo_config[self.name][\n producttype_to_sat(product_type)]\n except KeyError as invalid_product:\n msg = f'{product_type} is not allowed with {self.name}'\n raise InputError(msg) from invalid_product\n calibration_dict, calibration_name = load_calib(\n calibration,\n self._default_calibration_file,\n self._default_calibration_name\n )\n self._switch_inf = calibration_dict['switch_inf']\n self._switch_sup = calibration_dict['switch_sup']\n self._valid_limit = calibration_dict['validity_limit']\n try:\n params = calibration_dict[producttype_to_sat(product_type)]\n except KeyError as invalid_product:\n msg = f'{product_type} is not allowed with this calibration'\n raise InputError(msg) from invalid_product\n self.__dict__.update(params)\n self.meta = {'calibration': calibration_name,\n 'switch inf': self._switch_inf,\n 'switch sup': self._switch_sup,\n 'validity_limit': self._valid_limit,\n **params}\n\n def __call__(self,\n rho_red: xr.DataArray,\n rho_nir: xr.DataArray,\n data_type: str,\n **_ignored) -> xr.DataArray:\n \"\"\"Runs the algorithm on the input array ('rho').\n\n Args:\n rho_red: An array (dimension 1 * N * M) of 'data_type'.\n rho_nir: An array (dimension 1 * N * M) of 'data_type'.\n data_type: Either 'rho' or 'rrs' (respectively surface reflectance\n and remote sensing reflectance).\n **_ignored: Unused kwargs sent to trash.\n\n Returns:\n An array (dimension 1 * N * M) of Turbidity (in FNU).\n \"\"\"\n\n if data_type == 'rrs':\n rho_red = np.pi * rho_red\n rho_nir = np.pi * rho_nir\n\n np.warnings.filterwarnings('ignore')\n rho_red = rho_red.where(rho_red >= 0)\n rho_nir = rho_red.where(rho_nir >= 0)\n # pylint: disable=no-member\n # Loaded in __init__ whit \"__dict__.update\".\n t_low = _nechad(rho_red, self.a_low, self.c_low)\n t_high = _nechad(rho_nir, self.a_high, self.c_high)\n w = ((rho_red - self._switch_inf)\n / (self._switch_sup - self._switch_inf))\n t_mixing = (1 - w) * t_low + w * t_high\n\n turb = rho_red.where(rho_red > self._switch_inf, t_low)\n turb = turb.where(rho_red < self._switch_sup, t_high)\n turb = turb.where((rho_red <= self._switch_inf)\n | (rho_red >= self._switch_sup), t_mixing)\n turb = turb.where((turb >= 0) & (turb <= self._valid_limit))\n return turb\n", "meta": {"hexsha": "c6899f30fa92d2a4fc03d94a8e9aab1abfbf08dd", "size": 17286, "ext": "py", "lang": "Python", "max_stars_repo_path": "sisppeo/wcproducts/spm.py", "max_stars_repo_name": "inrae/SISPPEO", "max_stars_repo_head_hexsha": "f516bb778b505739fdf320affe651b715ed75324", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2021-11-05T09:23:13.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-18T10:39:13.000Z", "max_issues_repo_path": "sisppeo/wcproducts/spm.py", "max_issues_repo_name": "inrae/SISPPEO", "max_issues_repo_head_hexsha": "f516bb778b505739fdf320affe651b715ed75324", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "sisppeo/wcproducts/spm.py", "max_forks_repo_name": "inrae/SISPPEO", "max_forks_repo_head_hexsha": "f516bb778b505739fdf320affe651b715ed75324", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.5774647887, "max_line_length": 91, "alphanum_fraction": 0.6194029851, "include": true, "reason": "import numpy", "num_tokens": 4076, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5698526514141571, "lm_q2_score": 0.34158251284363395, "lm_q1q2_score": 0.19465170062065518}} {"text": "# Author: Roman Goj \n#\n# License: BSD (3-clause)\n\nimport copy as cp\n\nimport numpy as np\nfrom scipy.fftpack import fftfreq\n\nfrom ..io.pick import pick_types\nfrom ..utils import logger, verbose, warn\nfrom ..time_frequency.multitaper import (dpss_windows, _mt_spectra,\n _csd_from_mt, _psd_from_mt_adaptive)\n\n\nclass CrossSpectralDensity(object):\n \"\"\"Cross-spectral density\n\n Parameters\n ----------\n data : array of shape (n_channels, n_channels)\n The cross-spectral density matrix.\n ch_names : list of string\n List of channels' names.\n projs :\n List of projectors used in CSD calculation.\n bads :\n List of bad channels.\n frequencies : float | list of float\n Frequency or frequencies for which the CSD matrix was calculated. If a\n list is passed, data is a sum across CSD matrices for all frequencies.\n n_fft : int\n Length of the FFT used when calculating the CSD matrix.\n \"\"\"\n def __init__(self, data, ch_names, projs, bads, frequencies, n_fft):\n self.data = data\n self.dim = len(data)\n self.ch_names = cp.deepcopy(ch_names)\n self.projs = cp.deepcopy(projs)\n self.bads = cp.deepcopy(bads)\n self.frequencies = np.atleast_1d(np.copy(frequencies))\n self.n_fft = n_fft\n\n def __repr__(self):\n s = 'frequencies : %s' % self.frequencies\n s += ', size : %s x %s' % self.data.shape\n s += ', data : %s' % self.data\n return '' % s\n\n\n@verbose\ndef compute_epochs_csd(epochs, mode='multitaper', fmin=0, fmax=np.inf,\n fsum=True, tmin=None, tmax=None, n_fft=None,\n mt_bandwidth=None, mt_adaptive=False, mt_low_bias=True,\n projs=None, verbose=None):\n \"\"\"Estimate cross-spectral density from epochs\n\n Note: Baseline correction should be used when creating the Epochs.\n Otherwise the computed cross-spectral density will be inaccurate.\n\n Note: Results are scaled by sampling frequency for compatibility with\n Matlab.\n\n Parameters\n ----------\n epochs : instance of Epochs\n The epochs.\n mode : str\n Spectrum estimation mode can be either: 'multitaper' or 'fourier'.\n fmin : float\n Minimum frequency of interest.\n fmax : float | np.inf\n Maximum frequency of interest.\n fsum : bool\n Sum CSD values for the frequencies of interest. Summing is performed\n instead of averaging so that accumulated power is comparable to power\n in the time domain. If True, a single CSD matrix will be returned. If\n False, the output will be a list of CSD matrices.\n tmin : float | None\n Minimum time instant to consider. If None start at first sample.\n tmax : float | None\n Maximum time instant to consider. If None end at last sample.\n n_fft : int | None\n Length of the FFT. If None the exact number of samples between tmin and\n tmax will be used.\n mt_bandwidth : float | None\n The bandwidth of the multitaper windowing function in Hz.\n Only used in 'multitaper' mode.\n mt_adaptive : bool\n Use adaptive weights to combine the tapered spectra into PSD.\n Only used in 'multitaper' mode.\n mt_low_bias : bool\n Only use tapers with more than 90% spectral concentration within\n bandwidth. Only used in 'multitaper' mode.\n projs : list of Projection | None\n List of projectors to use in CSD calculation, or None to indicate that\n the projectors from the epochs should be inherited.\n verbose : bool, str, int, or None\n If not None, override default verbose level (see mne.verbose).\n\n Returns\n -------\n csd : instance of CrossSpectralDensity\n The computed cross-spectral density.\n \"\"\"\n # Portions of this code adapted from mne/connectivity/spectral.py\n\n # Check correctness of input data and parameters\n if fmax < fmin:\n raise ValueError('fmax must be larger than fmin')\n tstep = epochs.times[1] - epochs.times[0]\n if tmin is not None and tmin < epochs.times[0] - tstep:\n raise ValueError('tmin should be larger than the smallest data time '\n 'point')\n if tmax is not None and tmax > epochs.times[-1] + tstep:\n raise ValueError('tmax should be smaller than the largest data time '\n 'point')\n if tmax is not None and tmin is not None:\n if tmax < tmin:\n raise ValueError('tmax must be larger than tmin')\n if epochs.baseline is None and epochs.info['highpass'] < 0.1:\n warn('Epochs are not baseline corrected or enough highpass filtered. '\n 'Cross-spectral density may be inaccurate.')\n\n if projs is None:\n projs = cp.deepcopy(epochs.info['projs'])\n else:\n projs = cp.deepcopy(projs)\n\n picks_meeg = pick_types(epochs[0].info, meg=True, eeg=True, eog=False,\n ref_meg=False, exclude='bads')\n ch_names = [epochs.ch_names[k] for k in picks_meeg]\n\n # Preparing time window slice\n tstart, tend = None, None\n if tmin is not None:\n tstart = np.where(epochs.times >= tmin)[0][0]\n if tmax is not None:\n tend = np.where(epochs.times <= tmax)[0][-1] + 1\n tslice = slice(tstart, tend, None)\n n_times = len(epochs.times[tslice])\n n_fft = n_times if n_fft is None else n_fft\n\n # Preparing frequencies of interest\n sfreq = epochs.info['sfreq']\n orig_frequencies = fftfreq(n_fft, 1. / sfreq)\n freq_mask = (orig_frequencies > fmin) & (orig_frequencies < fmax)\n frequencies = orig_frequencies[freq_mask]\n n_freqs = len(frequencies)\n\n if n_freqs == 0:\n raise ValueError('No discrete fourier transform results within '\n 'the given frequency window. Please widen either '\n 'the frequency window or the time window')\n\n # Preparing for computing CSD\n logger.info('Computing cross-spectral density from epochs...')\n if mode == 'multitaper':\n # Compute standardized half-bandwidth\n if mt_bandwidth is not None:\n half_nbw = float(mt_bandwidth) * n_times / (2 * sfreq)\n else:\n half_nbw = 2\n\n # Compute DPSS windows\n n_tapers_max = int(2 * half_nbw)\n window_fun, eigvals = dpss_windows(n_times, half_nbw, n_tapers_max,\n low_bias=mt_low_bias)\n n_tapers = len(eigvals)\n logger.info(' using multitaper spectrum estimation with %d DPSS '\n 'windows' % n_tapers)\n\n if mt_adaptive and len(eigvals) < 3:\n warn('Not adaptively combining the spectral estimators due to a '\n 'low number of tapers.')\n mt_adaptive = False\n elif mode == 'fourier':\n logger.info(' using FFT with a Hanning window to estimate spectra')\n window_fun = np.hanning(n_times)\n mt_adaptive = False\n eigvals = 1.\n n_tapers = None\n else:\n raise ValueError('Mode has an invalid value.')\n\n csds_mean = np.zeros((len(ch_names), len(ch_names), n_freqs),\n dtype=complex)\n\n # Picking frequencies of interest\n freq_mask_mt = freq_mask[orig_frequencies >= 0]\n\n # Compute CSD for each epoch\n n_epochs = 0\n for epoch in epochs:\n epoch = epoch[picks_meeg][:, tslice]\n\n # Calculating Fourier transform using multitaper module\n x_mt, _ = _mt_spectra(epoch, window_fun, sfreq, n_fft)\n\n if mt_adaptive:\n # Compute adaptive weights\n _, weights = _psd_from_mt_adaptive(x_mt, eigvals, freq_mask,\n return_weights=True)\n # Tiling weights so that we can easily use _csd_from_mt()\n weights = weights[:, np.newaxis, :, :]\n weights = np.tile(weights, [1, x_mt.shape[0], 1, 1])\n else:\n # Do not use adaptive weights\n if mode == 'multitaper':\n weights = np.sqrt(eigvals)[np.newaxis, np.newaxis, :,\n np.newaxis]\n else:\n # Hack so we can sum over axis=-2\n weights = np.array([1.])[:, None, None, None]\n\n x_mt = x_mt[:, :, freq_mask_mt]\n\n # Calculating CSD\n # Tiling x_mt so that we can easily use _csd_from_mt()\n x_mt = x_mt[:, np.newaxis, :, :]\n x_mt = np.tile(x_mt, [1, x_mt.shape[0], 1, 1])\n y_mt = np.transpose(x_mt, axes=[1, 0, 2, 3])\n weights_y = np.transpose(weights, axes=[1, 0, 2, 3])\n csds_epoch = _csd_from_mt(x_mt, y_mt, weights, weights_y)\n\n # Scaling by number of samples and compensating for loss of power due\n # to windowing (see section 11.5.2 in Bendat & Piersol).\n if mode == 'fourier':\n csds_epoch /= n_times\n csds_epoch *= 8 / 3.\n\n # Scaling by sampling frequency for compatibility with Matlab\n csds_epoch /= sfreq\n\n csds_mean += csds_epoch\n n_epochs += 1\n\n csds_mean /= n_epochs\n\n logger.info('[done]')\n\n # Summing over frequencies of interest or returning a list of separate CSD\n # matrices for each frequency\n if fsum is True:\n csd_mean_fsum = np.sum(csds_mean, 2)\n csd = CrossSpectralDensity(csd_mean_fsum, ch_names, projs,\n epochs.info['bads'],\n frequencies=frequencies, n_fft=n_fft)\n return csd\n else:\n csds = []\n for i in range(n_freqs):\n csds.append(CrossSpectralDensity(csds_mean[:, :, i], ch_names,\n projs, epochs.info['bads'],\n frequencies=frequencies[i],\n n_fft=n_fft))\n return csds\n", "meta": {"hexsha": "4d5d25ff35e6f6c0a1e1d3e4a51d69aacdb24d41", "size": 9953, "ext": "py", "lang": "Python", "max_stars_repo_path": "mne/time_frequency/csd.py", "max_stars_repo_name": "mmagnuski/mne-python", "max_stars_repo_head_hexsha": "8b4aa6731b828430453b6e36405313e1bea3d701", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-03-08T22:53:49.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-08T22:53:49.000Z", "max_issues_repo_path": "mne/time_frequency/csd.py", "max_issues_repo_name": "mmagnuski/mne-python", "max_issues_repo_head_hexsha": "8b4aa6731b828430453b6e36405313e1bea3d701", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "mne/time_frequency/csd.py", "max_forks_repo_name": "mmagnuski/mne-python", "max_forks_repo_head_hexsha": "8b4aa6731b828430453b6e36405313e1bea3d701", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2017-04-20T12:21:15.000Z", "max_forks_repo_forks_event_max_datetime": "2017-04-20T12:21:15.000Z", "avg_line_length": 38.5775193798, "max_line_length": 79, "alphanum_fraction": 0.6033356777, "include": true, "reason": "import numpy,from scipy", "num_tokens": 2409, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5698526660244838, "lm_q2_score": 0.34158249943831703, "lm_q1q2_score": 0.1946516979722317}} {"text": "#!/usr/bin/python\r\n\r\n\r\n###Sterimol (and Tolman CA) Calculator###\r\n\r\n###############################################################\r\n# sterimoltools.py #\r\n# #\r\n###############################################################\r\n\r\n\r\n#Python Libraries\r\nimport subprocess, sys, os\r\nfrom numpy import *\r\nfrom scipy import *\r\nfrom math import *\r\nimport numpy as np\r\n#from vpython import *\r\n\r\n#Chemistry Libaries\r\n#from radialdata import *\r\n#from pars import *\r\n\r\n#Avoid number error warnings\r\nimport warnings\r\nwarnings.filterwarnings(\"ignore\")\r\n\r\n#Chemistry Arrays\r\nperiodictable = [\"Bq\",\"H\",\"He\",\"Li\",\"Be\",\"B\",\"C\",\"N\",\"O\",\"F\",\"Ne\",\"Na\",\"Mg\",\"Al\",\"Si\",\"P\",\"S\",\"Cl\",\"Ar\",\"K\",\"Ca\",\"Sc\",\"Ti\",\"V\",\"Cr\",\"Mn\",\"Fe\",\"Co\",\"Ni\",\"Cu\",\"Zn\",\"Ga\",\"Ge\",\"As\",\"Se\",\"Br\",\"Kr\",\"Rb\",\"Sr\",\"Y\",\"Zr\",\r\n \"Nb\",\"Mo\",\"Tc\",\"Ru\",\"Rh\",\"Pd\",\"Ag\",\"Cd\",\"In\",\"Sn\",\"Sb\",\"Te\",\"I\",\"Xe\",\"Cs\",\"Ba\",\"La\",\"Ce\",\"Pr\",\"Nd\",\"Pm\",\"Sm\",\"Eu\",\"Gd\",\"Tb\",\"Dy\",\"Ho\",\"Er\",\"Tm\",\"Yb\",\"Lu\",\"Hf\",\"Ta\",\"W\",\"Re\",\"Os\",\"Ir\",\"Pt\",\"Au\",\"Hg\",\"Tl\",\r\n \"Pb\",\"Bi\",\"Po\",\"At\",\"Rn\",\"Fr\",\"Ra\",\"Ac\",\"Th\",\"Pa\",\"U\",\"Np\",\"Pu\",\"Am\",\"Cm\",\"Bk\",\"Cf\",\"Es\",\"Fm\",\"Md\",\"No\",\"Lr\",\"Rf\",\"Db\",\"Sg\",\"Bh\",\"Hs\",\"Mt\",\"Ds\",\"Rg\",\"Uub\",\"Uut\",\"Uuq\",\"Uup\",\"Uuh\",\"Uus\",\"Uuo\"]\r\n\r\nmetals = [\"Li\",\"Be\",\"Na\",\"Mg\",\"Al\",\"K\",\"Ca\",\"Sc\",\"Ti\",\"V\",\"Cr\",\"Mn\",\"Fe\",\"Co\",\"Ni\",\"Cu\",\"Zn\",\"Ga\",\"Rb\",\"Sr\",\"Y\",\"Zr\",\"Nb\",\"Mo\",\"Tc\",\"Ru\",\"Rh\",\"Pd\",\"Ag\",\"Cd\",\"In\",\"Sn\",\"Cs\",\"Ba\",\"La\",\"Ce\",\"Pr\",\"Nd\",\"Pm\",\"Sm\",\"Eu\",\"Gd\",\"Tb\",\"Dy\",\"Ho\",\"Er\",\"Tm\",\"Yb\",\"Lu\",\"Hf\",\"Ta\",\"W\",\"Re\",\"Os\",\"Ir\",\"Pt\",\"Au\",\"Hg\",\"Tl\",\"Pb\",\"Bi\",\"Po\",\"Fr\",\"Ra\",\"Ac\",\"Th\",\"Pa\",\"U\",\"Np\",\"Pu\",\"Am\",\"Cm\",\"Bk\",\"Cf\",\"Es\",\"Fm\",\"Md\",\"No\",\"Lr\",\"Rf\",\"Db\",\"Sg\",\"Bh\",\"Hs\",\"Mt\",\"Ds\",\"Rg\",\"Cn\",\"Uut\",\"Fl\",\"Uup\",\"Lv\"]\r\n\r\n# Verloop's original Sterimol parameters use CPK atomic VdW radii based on atom-type definitions\r\nsterimol_atomtypes = [\"C\", \"C2\", \"C3\", \"C4\", \"C5/N5\", \"C6/N6\", \"C7\", \"C8\", \"H\", \"N\", \"C66\", \"N4\", \"O\", \"O2\", \"P\", \"S\", \"S1\", \"F\", \"C1\", \"S4\", \"B1\", \"I\"]\r\n\r\n# CPK VdW radii in pm\r\ncpk_radii = [150,160,160,150,170,170,170,150,100,150,170,145,135,135,140,170,100,135,180,140,195,215]\r\n\r\ndef getfragment(atom,molcart):\r\n bondlist=[atom]\r\n for a in range(len(molcart)):\r\n if calcdist(atom,a,molcart)<1.92 and a not in bondlist:bondlist.append(a)\r\n\r\n for b in range(len(bondlist)):\r\n for c in range(len(molcart)):\r\n\r\n if calcdist(bondlist[b],c,molcart)<1.92 and c not in bondlist:bondlist.append(c)\r\n return bondlist\r\n\r\ndef connectivity(atom,molcart,aty):\r\n con=[]\r\n for a in range(len(molcart)):\r\n if aty[a]in metals and molcart[a] != molcart[atom] and 0.1 0.999999: val = 1.0\r\n if val < -0.999999: val = -1.0\r\n return math.acos(val)\r\n\r\ndef dihedral(atoma,atomb,atomc,atomd):\r\n x1=atoma[0]\r\n y1=atoma[1]\r\n z1=atoma[2]\r\n x2=atomb[0]\r\n y2=atomb[1]\r\n z2=atomb[2]\r\n x3=atomc[0]\r\n y3=atomc[1]\r\n z3=atomc[2]\r\n x4=atomd[0]\r\n y4=atomd[1]\r\n z4=atomd[2]\r\n ax= (y2-y1)*(z2-z3)-(z2-z1)*(y2-y3)\r\n ay= (z2-z1)*(x2-x3)-(x2-x1)*(z2-z3)\r\n az= (x2-x1)*(y2-y3)-(y2-y1)*(x2-x3)\r\n bx= (y3-y2)*(z3-z4)-(z3-z2)*(y3-y4)\r\n by= (z3-z2)*(x3-x4)-(x3-x2)*(z3-z4)\r\n bz= (x3-x2)*(y3-y4)-(y3-y2)*(x3-x4)\r\n nbx= (y2-y3)*(z4-z3)-(z2-z3)*(y4-y3)\r\n nby= (z2-z3)*(x4-x3)-(x2-x3)*(z4-z3)\r\n nbz= (x2-x3)*(y4-y3)-(y2-y3)*(x4-x3)\r\n torsion=180.0/math.pi*math.acos((ax*bx+ay*by+az*bz)/(math.sqrt(ax*ax+ay*ay+az*az)*math.sqrt(bx*bx+by*by+bz*bz)))\r\n sign=180.0/math.pi*math.acos((nbx*(x2-x1)+nby*(y2-y1)+nbz*(z2-z1))/(math.sqrt(nbx*nbx+nby*nby+nbz*nbz)*math.sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1)+(z2-z1)*(z2-z1))))\r\n if sign<90.0:\r\n torsion=torsion*-1.0\r\n return torsion\r\n\r\n#Get PDB data?\r\n\r\nclass getinData:\r\n def __init__(self, file):\r\n if not os.path.exists(file+\".com\"):\r\n print (\"\\nFATAL ERROR: Input file [ %s ] does not exist\"%file)\r\n def getATOMTYPES(self, inlines):\r\n self.ATOMTYPES = []\r\n self.LEVELTYPES = []\r\n for i in range(0,len(inlines)):\r\n if inlines[i].find(\"#\") > -1:\r\n if len(inlines[i+1].split()) == 0: start = i+5\r\n if len(inlines[i+2].split()) == 0: start = i+6\r\n break\r\n for i in range(start,len(inlines)):\r\n if len(inlines[i].split()) ==0:\r\n break\r\n else:\r\n self.ATOMTYPES.append(inlines[i].split()[0].split(\"-\")[0])\r\n for oniomlevel in [\"H\", \"M\", \"L\"]:\r\n if inlines[i].rfind(oniomlevel)>1:\r\n self.LEVELTYPES.append(inlines[i][inlines[i].rfind(\"H\"):])\r\n break\r\n def getCARTESIANS(self, inlines, natoms):\r\n self.CARTESIANS = []\r\n for i in range(0,len(inlines)):\r\n if inlines[i].find(\"#\") > -1:\r\n start = i+5\r\n break\r\n\r\n for i in range(start,len(inlines)):\r\n if len(inlines[i].split()) == 0:\r\n break\r\n elif len(inlines[i].split()) == 4:\r\n self.CARTESIANS.append([float(inlines[i].split()[1]), float(inlines[i].split()[2]), float(inlines[i].split()[3])])\r\n\r\n infile = open(file+\".com\",\"r\")\r\n inlines = infile.readlines()\r\n getATOMTYPES(self, inlines)\r\n self.NATOMS=len(self.ATOMTYPES)\r\n\r\n getCARTESIANS(self, inlines, self.NATOMS)\r\n\r\nclass getinData2:\r\n def __init__(self, file):\r\n start=2\r\n if not os.path.exists(file+\".xyz\"):\r\n print (\"\\nFATAL ERROR: Input file [ %s ] does not exist\"%file)\r\n def getATOMTYPES(self, inlines):\r\n self.ATOMTYPES = []\r\n self.LEVELTYPES = []\r\n for i in range(2,len(inlines)):\r\n if len(inlines[i].split()) ==0:\r\n break\r\n else:\r\n self.ATOMTYPES.append(inlines[i].split()[0].split(\"-\")[0])\r\n for oniomlevel in [\"H\", \"M\", \"L\"]:\r\n if inlines[i].rfind(oniomlevel)>1:\r\n self.LEVELTYPES.append(inlines[i][inlines[i].rfind(\"H\"):])\r\n break\r\n def getCARTESIANS(self, inlines, natoms):\r\n self.CARTESIANS = []\r\n# for i in range(0,len(inlines)):\r\n# if inlines[i].find(\"#\") > -1:\r\n# start = i+5\r\n# break\r\n for i in range(start,len(inlines)):\r\n if len(inlines[i].split()) == 0:\r\n break\r\n elif len(inlines[i].split()) == 4:\r\n self.CARTESIANS.append([float(inlines[i].split()[1]), float(inlines[i].split()[2]), float(inlines[i].split()[3])])\r\n\r\n# print self.CARTESIANS\r\n# for i in range(0,len(inlines)):\r\n infile = open(file+\".xyz\",\"r\")\r\n inlines = infile.readlines()\r\n getATOMTYPES(self, inlines)\r\n self.NATOMS=len(self.ATOMTYPES)\r\n\r\n getCARTESIANS(self, inlines, self.NATOMS)\r\n\r\nclass getoutData:\r\n def __init__(self, file):\r\n if not os.path.exists(file+\".out\"):\r\n if not os.path.exists(file+\".log\"):\r\n print (\"\\nFATAL ERROR: Output file [ %s ] does not exist\"%file)\r\n def getFORMAT(self, outlines):\r\n for i in range(0,len(outlines)):\r\n if outlines[i].find(\"Gaussian\") > -1: self.FORMAT = \"Gaussian\"; break\r\n def getATOMTYPES(self, outlines, format):\r\n self.ATOMTYPES = []\r\n self.CARTESIANS = []\r\n if format == \"Gaussian\":\r\n for i in range(0,len(outlines)):\r\n\r\n if outlines[i].find(\"Standard orientation\") > -1:\r\n standor = i\r\n arb=0\r\n if outlines[i].find(\"Input orientation\") > -1:\r\n standor2 = i\r\n arb=1\r\n if outlines[i].find(\"Rotational constants\") > -1 and outlines[i-1].find(\"-------\") > -1 and arb==0:\r\n self.NATOMS = i-standor-6\r\n if outlines[i].find(\"Rotational constants\") > -1 and outlines[i-1].find(\"-------\") > -1 and arb==1:\r\n self.NATOMS = i-standor2-6\r\n arb=2\r\n if outlines[i].find(\"Distance matrix\") > -1 and outlines[i-1].find(\"-------\") > -1:\r\n self.NATOMS = i-standor2-6\r\n try: standor, standor2\r\n except NameError: pass\r\n else:\r\n if standor2>standor:del standor\r\n if standor>standor2:del standor2\r\n try: standor\r\n except NameError: pass\r\n else:\r\n for i in range (standor+5,standor+5+self.NATOMS):\r\n self.ATOMTYPES.append(elementID(int(outlines[i].split()[1])))\r\n if len(outlines[i].split())==6:self.CARTESIANS.append([float(outlines[i].split()[3]),float(outlines[i].split()[4]),float(outlines[i].split()[5])])\r\n else: self.CARTESIANS.append([float(outlines[i].split()[2]),float(outlines[i].split()[3]),float(outlines[i].split()[4])])\r\n try: standor2\r\n except NameError: pass\r\n else:\r\n for i in range (standor2+5,standor2+5+self.NATOMS):\r\n self.ATOMTYPES.append(elementID(int(outlines[i].split()[1])))\r\n self.CARTESIANS.append([float(outlines[i].split()[3]),float(outlines[i].split()[4]),float(outlines[i].split()[5])])\r\n\r\n if os.path.exists(file+\".out\"):outfile = open(file+\".out\",\"r\")\r\n else: outfile = open(file+\".log\",\"r\")\r\n outlines = outfile.readlines()\r\n getFORMAT(self, outlines)\r\n getATOMTYPES(self, outlines, self.FORMAT)\r\n self.NATOMS=len(self.ATOMTYPES)\r\n\r\ndef concheck(conpar,val):\r\n cons=[]\r\n for a in range(len(conpar)):\r\n for b in range(len(conpar[a])):\r\n if val ==conpar[a][0]:\r\n for c in range(len(conpar[a])-1):\r\n cons.append(conpar[a][c+1])\r\n return cons\r\n\r\ndef twod_dist(a,b,c):\r\n vect1=np.subtract(a,b)\r\n vect2=np.subtract(b,c)\r\n ang=angle(vect1,vect2)\r\n return math.sin(ang)*np.linalg.norm(vect1)\r\n\r\ndef twod_vect(a,b,c):\r\n vect1=np.subtract(a,b)\r\n vect2=np.subtract(b,c)\r\n ang=angle(vect1,vect2)\r\n nvect2=vect2/np.linalg.norm(vect2)\r\n return ((math.cos(ang)*np.linalg.norm(vect1))*nvect2)+b\r\n\r\ndef twod_rot(vect,theta):\r\n a=math.cos(theta)\r\n b=math.sin(theta)\r\n mat=[[a,-b],[b,a]]\r\n vect=np.dot(mat,vect)\r\n return vect\r\n\r\n# Generate Sterimol atom type from connectivity data\r\ndef generate_atom_types(atomtype, cn):\r\n st_types = []\r\n for i in range(0,len(atomtype)):\r\n atom = atomtype[i]\r\n if atom == \"H\": st_types.append(\"H\")\r\n elif atom == \"P\": st_types.append(\"P\")\r\n elif atom == \"F\": st_types.append(\"F\")\r\n elif atom == \"Cl\": st_types.append(\"C1\")\r\n elif atom == \"Br\": st_types.append(\"B1\")\r\n elif atom == \"I\": st_types.append(\"I\")\r\n elif atom == \"O\": #Sterimol distinguishes between \"normal\", and double-bonded O atoms\r\n if cn[i] < 1.5: st_types.append(\"O2\")\r\n if cn[i] > 1.5: st_types.append(\"O\")\r\n elif atom == \"S\": #Sterimol distinguishes between \"normal\", tetrahedral, and octohedral S atoms\r\n if cn[i] < 2.5: st_types.append(\"S\")\r\n if 5.5 > cn[i] > 2.5: st_types.append(\"S4\")\r\n if cn[i] > 5.5: st_types.append(\"S1\")\r\n elif atom == \"N\": #Sterimol distinguishes between tetrahedral and planar (amide) N atoms\r\n if cn[i] > 2.5: st_types.append(\"N\")\r\n if cn[i] < 2.5: st_types.append(\"C6/N6\")\r\n elif atom == \"C\": #Sterimol distinguishes between myriad types of C atoms ...\r\n if cn[i] < 2.5: st_types.append(\"C3\")\r\n if 3.5 > cn[i] > 2.5: # need to differentiate between sp2 carbon and aromatic carbon ...\r\n st_types.append(\"C6/N6\") # assumes aromatic rather than sp2\r\n if cn[i] > 3.5: st_types.append(\"C\")\r\n return st_types\r\n\r\n\r\n# Calculation of atomic coordination numbers (taken from Grimme's DFTD3 definitions)\r\ndef ncoord(natom, rcov, atomtype, coords):\r\n max_elem = 94\r\n k1 = 16.0\r\n k2 = 4.0/3.0\r\n cn =[]\r\n for i in range(0,natom):\r\n xn = 0.0\r\n for iat in range(0,natom):\r\n if iat != i:\r\n dx = coords[iat][0] - coords[i][0]\r\n dy = coords[iat][1] - coords[i][1]\r\n dz = coords[iat][2] - coords[i][2]\r\n r2 = dx*dx+dy*dy+dz*dz\r\n r = math.pow(r2,0.5)\r\n r = r\r\n for k in range(0,max_elem):\r\n if atomtype[i].find(elements[k])>-1:Zi=k\r\n if atomtype[iat].find(elements[k])>-1:Ziat=k\r\n\r\n rco = rcov[Zi]+rcov[Ziat]\r\n rco = rco*k2\r\n rr=rco/r\r\n damp=1.0/(1.0+math.exp(-k1*(rr-1.0)))\r\n xn=xn+damp\r\n cn.append(xn)\r\n return cn\r\n\r\ndef linearcheck(carts):\r\n ans=0;xgrad=[];ygrad=[]\r\n for row in carts:xgrad.append(round(np.gradient(row)[0],4));ygrad.append(round(np.gradient(row)[1],4))\r\n if min(xgrad)==max(xgrad) and min(ygrad)==max(ygrad):ans=1\r\n return ans\r\n\r\nclass calcSterimol:\r\n def __init__(self, file, radii, atomA, atomB,verbose):\r\n if len(file.split(\".com\"))>1 or len(file.split(\".gjf\"))>1: \r\n fileData = getinData(file.split(\".\")[0])\r\n if len(file.split(\".xyz\"))>1: \r\n fileData = getinData2(file.split(\".\")[0])\r\n if len(file.split(\".out\"))>1 or len(file.split(\".log\"))>1: fileData = getoutData(file.split(\".\")[0])\r\n\r\n # initialize the array of atomic vdw radii\r\n molcart = fileData.CARTESIANS; atomtype = fileData.ATOMTYPES; natoms = len(molcart); vdw_radii = []\r\n# print fileData.ATOMTYPES\r\n\r\n if radii == \"cpk\":\r\n atomic_co_no = ncoord(natoms, rcov, atomtype, molcart)\r\n sterimol_types = generate_atom_types(atomtype, atomic_co_no)\r\n print(sterimol_types)\r\n #print sterimol_types\r\n for i in range(0,natoms):\r\n for j in range(0,len(sterimol_atomtypes)):\r\n if sterimol_types[i] == sterimol_atomtypes[j]: vdw_radii.append(cpk_radii[j]/100.00)\r\n\r\n if radii == \"bondi\":\r\n for i in range(0,natoms): \r\n vdw_radii.append(bondiRadius(periodictable.index(fileData.ATOMTYPES[i])))\r\n\r\n# Define vector along the L-axis connecting base atom and the next attached atom\r\n# subtract one since the array starts from zero not one\r\n atomA = atomA - 1; atomB = atomB - 1\r\n next_atom = molcart[atomB]\r\n vect1=np.subtract(getcoords(atomA,molcart),next_atom)\r\n if verbose == True:\r\n pass\r\n #print \" Atoms\", atomA, \"and\", atomB, \"define the L-axis and direction\", vect1\r\n\r\n# print \"\\n\", \" Atom \".ljust(9), \" Xco/A\".rjust(9), \" Yco/A\".rjust(9), \" Zco/A\".rjust(9), \" VdW/pm\".rjust(9)\r\n #print \" ##############################################\"\r\n # Remove the base atom from the list of atoms to be considered for sterics (after printing all)\r\n atomlist = list(xrange(0,natoms))\r\n if verbose == True:\r\n for atom in atomlist:\r\n pass\r\n# if radii == \"cpk\": print \" \", sterimol_types[atom].ljust(6),\r\n# if radii == \"bondi\": print \" \", atomtype[atom].ljust(6),\r\n for coord in molcart[atom]:\r\n pass\r\n# if coord < 0.0: print \" %.3f\".rjust(6) % coord,\r\n# else: print \" %.3f\".rjust(6) % coord,\r\n# print \" %.1f\" % round(vdw_radii[atom]*100)\r\n atomlist.remove(atomA)\r\n\r\n adjlist=[]; opplist=[]; theta=[]\r\n for i in atomlist:\r\n vect2=np.subtract(getcoords(atomA,molcart),getcoords(i,molcart))\r\n oppdist=calcopposite(atomA,i,angle(vect1,vect2),molcart)\r\n opplist.append(oppdist+vdw_radii[i])\r\n adjdist=calcadj(atomA,i,angle(vect1,vect2),molcart)\r\n #minadjlist.append(adjdist-vdw_radii[i])\r\n adjlist.append(adjdist+vdw_radii[i])\r\n\r\n B5=max(opplist)\r\n #self.lval=max(adjlist)-minval\r\n # A bit weird, but seems like original sterimol adds on the difference between the bond length and vdw radius of atom B. For a C-H bond this is 1.50 - 1.10 = 0.40 Angstrom)\r\n self.lval=max(adjlist)+0.40\r\n\r\n ###Useful - do not delete!\r\n #print \" B5 atom\", atomlist[opplist.index(max(opplist))]+1, \"distance\", max(opplist)\r\n #print \" Highest atom\", atomlist[adjlist.index(max(adjlist))]+1,\"distance\", max(adjlist),\"\\n Lowest atom\", atomlist[minadjlist.index(min(minadjlist))]+1,\"distance\", min(minadjlist)\r\n\r\n zcarts=[]#zeroed carts\r\n for i in atomlist: zcarts.append(np.subtract(molcart[i],molcart[atomA]))\r\n zvect=[0,0,1]\r\n zcent=np.subtract(next_atom,molcart[atomA])\r\n for cart in range(len(zcarts)):\r\n zcoord= rotrel(zcent,zvect,zcarts[cart])\r\n zcarts[cart]=zcoord\r\n twodcarts=[]\r\n for row in zcarts: twodcarts.append([row[0],row[1]])\r\n fragrad=[]#radii of fragment atoms\r\n for t in atomlist: fragrad.append(vdw_radii[t])\r\n singledist=[]\r\n for t in range(len(fragrad)):\r\n d=np.linalg.norm(twodcarts[t])#;print d\r\n d=d+fragrad[t]\r\n singledist.append(d)\r\n self.newB5=max(singledist) #This is the same as the 3D calculated value from above\r\n\r\n center=[0,0]\r\n vlist=[]#list of distances from the origin to the tangential vectors\r\n alist=[]#list of atoms between which the tangential vectors pass through no other atoms\r\n iav=[]#interatomic vectors\r\n sym=symcheck(twodcarts)\r\n for x in range(len(twodcarts)):\r\n if sym==1:\r\n twodcarts[x][0]=twodcarts[x][0]+0.000001\r\n twodcarts[x][1]=twodcarts[x][1]+0.000001\r\n for y in range(len(twodcarts)):\r\n if x!=y:\r\n try:nvect= (twod_vect(center,twodcarts[x],twodcarts[y]))#origin normal vector to connecting atomic centers vector\r\n except ValueError:nvect=[0,0]\r\n iav=np.subtract(twodcarts[x],twodcarts[y])#interatomic vector\r\n iad=np.linalg.norm(iav)#interatomic distance\r\n try:theta=math.asin((fragrad[y]-fragrad[x])/iad)#calculates angle by which to rotate vdw radii before adding\r\n except ValueError: theta=np.pi/2\r\n try:unvect=nvect/np.linalg.norm(nvect)\r\n except RuntimeWarning:pass#unvect=[0,0]\r\n xradv=twod_rot(unvect*fragrad[x],theta)\r\n yradv=twod_rot(unvect*fragrad[y],theta)\r\n mvect= (twod_vect(center,twodcarts[x]-xradv,twodcarts[y]-yradv))\r\n nvect= (twod_vect(center,twodcarts[x]+xradv,twodcarts[y]+yradv))#origin normal vector to connecting atomic surfaces tangential vector\r\n newx=twodcarts[x]+xradv\r\n newy=twodcarts[y]+yradv\r\n mewx=twodcarts[x]-xradv\r\n mewy=twodcarts[y]-yradv\r\n if np.cross(nvect,xradv)<0.000000001 and theta!=np.pi/2:\r\n satpoint=[]#Satisfied points not within range of tangential vector\r\n for z in range(len(twodcarts)):\r\n pvdist=twod_dist(twodcarts[z],newx,newy)\r\n if z!=x and z!=y and pvdist>(fragrad[z]-0.0001):satpoint.append(pvdist)\r\n if len(satpoint)==len(atomlist)-2:vlist.append(np.linalg.norm(nvect));alist.append([x,y]);#print x,y\r\n satpoint=[]\r\n for z in range(len(twodcarts)):\r\n pvdist=twod_dist(twodcarts[z],mewx,mewy)\r\n if z!=x and z!=y and pvdist>(fragrad[z]-0.0001):satpoint.append(pvdist)\r\n if len(satpoint)==len(atomlist)-2:vlist.append(np.linalg.norm(mvect));alist.append([x,y])\r\n if linearcheck(twodcarts)==1:self.B1 = max(fragrad)\r\n elif len(vlist) > 0: self.B1=min(vlist)\r\n else: self.B1 = max(fragrad)\r\n\r\ndef symcheck(carts):#Add symmetry criteria\r\n center=[0,0]\r\n distlist=[]\r\n distlist.append(10)\r\n for a in range(len(carts)):\r\n for b in range(len(carts)):\r\n if a!=b:\r\n dist=np.linalg.norm(twod_vect(center,carts[a],carts[b]))\r\n distlist.append(dist)\r\n if min(distlist)<0.0000000001:ans=1\r\n else:ans=0\r\n return ans\r\n\r\ndef calcSandwich(file):\r\n metalatoms=[]\r\n if file.split(\".\")[1]==\"log\" or file.split(\".\")[1]==\"out\":fileData=getoutData(file.split(\".\")[0])\r\n# if file.split(\".\")[1]==\"xyz\": \r\n# fileData=getinData2(file.split(\".\")[0])\r\n if file.split(\".\")[1]==\"com\" or file.split(\".\")[1]==\"gjf\":fileData=getinData(file.split(\".\")[0])\r\n for i in range(len(fileData.ATOMTYPES)):\r\n if fileData.ATOMTYPES[i] in metals:metalatoms.append(i)\r\n\r\n ivals=[]\r\n jvals=[]\r\n for i in range(len(fileData.ATOMTYPES)):\r\n for j in range(len(fileData.ATOMTYPES)):\r\n dist = ((fileData.CARTESIANS[i][0]-fileData.CARTESIANS[j][0])**2 +(fileData.CARTESIANS[i][1]-fileData.CARTESIANS[j][1])**2+(fileData.CARTESIANS[i][2]-fileData.CARTESIANS[j][2])**2)**0.5\r\n if 0.01=distcalc(m,cent):mcdist=distcalc(m,cent);metal=b\r\n mcdists.append([mcdist,metal])\r\n frag=getfragment(ring[0],fileData.CARTESIANS)\r\n vect1=np.subtract(getcoords(metal,fileData.CARTESIANS),cent)\r\n if tempmcdist==mcdist:break#Stops if dealing with identical ring system as before (intended for symmetric dimers)\r\n adjlist=[]\r\n minadjlist=[]\r\n opplist=[]\r\n alpha=[]\r\n beta=[]\r\n theta=[]#Candidate Tolman angle substituent\r\n omega=[]#standardised atom \"dihedral\" orientation\r\n ringang=[]\r\n for i in frag:\r\n vect2=np.subtract(getcoords(metal,fileData.CARTESIANS),getcoords(i,fileData.CARTESIANS))\r\n oppdist=calcopposite(metal,i,angle(vect1,vect2),fileData.CARTESIANS)\r\n opplist.append(oppdist+genradii(i,fileData.CARTESIANS,fileData.ATOMTYPES))\r\n adjdist=calcadj(metal,i,angle(vect1,vect2),fileData.CARTESIANS)\r\n minadjlist.append(adjdist-genradii(i,fileData.CARTESIANS,fileData.ATOMTYPES))\r\n adjlist.append(adjdist+genradii(i,fileData.CARTESIANS,fileData.ATOMTYPES))\r\n alpha.append(angle(vect1,vect2))\r\n hyp=distcalc(getcoords(i,fileData.CARTESIANS),getcoords(metal,fileData.CARTESIANS))\r\n beta.append(math.asin(genradii(i,fileData.CARTESIANS,fileData.ATOMTYPES)/hyp))\r\n theta.append(alpha[-1]+beta[-1])\r\n if ring[0]!=ring[1]:omega.append(dihedral([10,10,10],getcoords(metal,fileData.CARTESIANS),cent,getcoords(i,fileData.CARTESIANS)))\r\n if ring[0]!=ring[1] and i in ring:ringang.append(dihedral([10,10,10],getcoords(metal,fileData.CARTESIANS),cent,getcoords(i,fileData.CARTESIANS)))\r\n B5=max(opplist)#Bondi\r\n lval=max(adjlist)-min(minadjlist)\r\n interval=180/len(ring)\r\n if ring[0]!=ring[1]:\r\n for k in ringang:\r\n tlist=[];tang=[];tfrag=[]\r\n\r\n for h in range(len(frag)):\r\n if k-interval(180-interval) and k-intervalfragrad[z]:satpoint.append(pvdist)\r\n if len(satpoint)==len(frag)-2:vlist.append(np.linalg.norm(nvect));alist.append([x,y])#;print x,y\r\n B1=round(min(vlist),3)\r\n# print \" \"+file.ljust(25),str(tolmanCA).rjust(9), str(smcdist).rjust(9), str(lval).rjust(9),str(B1).rjust(9), str(newB5).rjust(9)\r\n\r\nmolmod=[['Bq', 0, 0, 0, 0],\r\n ['H', 1, 1, 1, 1],\r\n ['He', 0, 0, 0, 0],\r\n ['Li', 0, 0, 0, 0],\r\n ['Be', 0, 0, 0, 0],\r\n ['B', 0, 0, 0, 0],\r\n ['C', 0, 1.6, 1.6, 1.5],\r\n ['N', 1.45, 1.45, 1.5, 1.25],\r\n ['O', 1.35, 1.35, 1.35, 0],\r\n ['F', 1.35, 1.35, 0, 0],\r\n ['Ne', 0, 0, 0, 0],\r\n ['Na', 0, 0, 0, 0],\r\n ['Mg', 0, 0, 0, 0],\r\n ['Al', 0, 0, 0, 0],\r\n ['Si', 2.1, 2.1, 2.1, 2.1],\r\n ['P', 0, 0, 0, 0],\r\n ['S', 0, 0, 0, 0],\r\n ['Cl', 1.8, 0, 0, 0],\r\n ['Ar', 0, 0, 0, 0],\r\n ['K', 0, 0, 0, 0],\r\n ['Ca', 0, 0, 0, 0],\r\n ['Sc', 0, 0, 0, 0],\r\n ['Ti', 0, 0, 0, 0],\r\n ['V', 0, 0, 0, 0],\r\n ['Cr', 0, 0, 0, 0],\r\n ['Mn', 0, 0, 0, 0],\r\n ['Fe', 0, 0, 0, 0],\r\n ['Co', 0, 0, 0, 0],\r\n ['Ni', 0, 0, 0, 0],\r\n ['Cu', 0, 0, 0, 0],\r\n ['Zn', 0, 0, 0, 0],\r\n ['Ga', 0, 0, 0, 0],\r\n ['Ge', 0, 0, 0, 0],\r\n ['As', 0, 0, 0, 0],\r\n ['Se', 0, 0, 0, 0],\r\n ['Br', 1.95, 0, 0, 0],\r\n ['Kr', 0, 0, 0, 0],\r\n ['Rb', 0, 0, 0, 0],\r\n ['Sr', 0, 0, 0, 0],\r\n ['Y', 0, 0, 0, 0],\r\n ['Zr', 0, 0, 0, 0],\r\n ['Nb', 0, 0, 0, 0],\r\n ['Mo', 0, 0, 0, 0],\r\n ['Tc', 0, 0, 0, 0],\r\n ['Ru', 0, 0, 0, 0],\r\n ['Rh', 0, 0, 0, 0],\r\n ['Pd', 0, 0, 0, 0],\r\n ['Ag', 0, 0, 0, 0],\r\n ['Cd', 0, 0, 0, 0],\r\n ['In', 0, 0, 0, 0],\r\n ['Sn', 0, 0, 0, 0],\r\n ['Sb', 0, 0, 0, 0],\r\n ['Te', 0, 0, 0, 0],\r\n ['I', 2.15, 0, 0, 0],\r\n ['Xe', 0, 0, 0, 0],\r\n ['Cs', 0, 0, 0, 0],\r\n ['Ba', 0, 0, 0, 0],\r\n ['La', 0, 0, 0, 0],\r\n ['Ce', 0, 0, 0, 0],\r\n ['Pr', 0, 0, 0, 0],\r\n ['Nd', 0, 0, 0, 0],\r\n ['Pm', 0, 0, 0, 0],\r\n ['Sm', 0, 0, 0, 0],\r\n ['Eu', 0, 0, 0, 0],\r\n ['Gd', 0, 0, 0, 0],\r\n ['Tb', 0, 0, 0, 0],\r\n ['Dy', 0, 0, 0, 0],\r\n ['Ho', 0, 0, 0, 0],\r\n ['Er', 0, 0, 0, 0],\r\n ['Tm', 0, 0, 0, 0],\r\n ['Yb', 0, 0, 0, 0],\r\n ['Lu', 0, 0, 0, 0],\r\n ['Hf', 0, 0, 0, 0],\r\n ['Ta', 0, 0, 0, 0],\r\n ['W', 0, 0, 0, 0],\r\n ['Re', 0, 0, 0, 0],\r\n ['Os', 0, 0, 0, 0],\r\n ['Ir', 0, 0, 0, 0],\r\n ['Pt', 0, 0, 0, 0],\r\n ['Au', 0, 0, 0, 0],\r\n ['Hg', 0, 0, 0, 0],\r\n ['Tl', 0, 0, 0, 0],\r\n ['Pb', 0, 0, 0, 0],\r\n ['Bi', 0, 0, 0, 0],\r\n ['Po', 0, 0, 0, 0],\r\n ['At', 0, 0, 0, 0],\r\n ['Rn', 0, 0, 0, 0],\r\n ['Fr', 0, 0, 0, 0],\r\n ['Ra', 0, 0, 0, 0],\r\n ['Ac', 0, 0, 0, 0],\r\n ['Th', 0, 0, 0, 0],\r\n ['Pa', 0, 0, 0, 0],\r\n ['U', 0, 0, 0, 0],\r\n ['Np', 0, 0, 0, 0],\r\n ['Pu', 0, 0, 0, 0],\r\n ['Am', 0, 0, 0, 0],\r\n ['Cm', 0, 0, 0, 0],\r\n ['Bk', 0, 0, 0, 0],\r\n ['Cf', 0, 0, 0, 0],\r\n ['Es', 0, 0, 0, 0],\r\n ['Fm', 0, 0, 0, 0],\r\n ['Md', 0, 0, 0, 0],\r\n ['No', 0, 0, 0, 0],\r\n ['Lr', 0, 0, 0, 0],\r\n ['Rf', 0, 0, 0, 0],\r\n ['Db', 0, 0, 0, 0],\r\n ['Sg', 0, 0, 0, 0],\r\n ['Bh', 0, 0, 0, 0],\r\n ['Hs', 0, 0, 0, 0],\r\n ['Mt', 0, 0, 0, 0],\r\n ['Ds', 0, 0, 0, 0],\r\n ['Rg', 0, 0, 0, 0],\r\n ['Uub', 0, 0, 0, 0],\r\n ['Uut', 0, 0, 0, 0],\r\n ['Uuq', 0, 0, 0, 0],\r\n ['Uup', 0, 0, 0, 0],\r\n ['Uuh', 0, 0, 0, 0],\r\n ['Uus', 0, 0, 0, 0],\r\n ['Uuo', 0, 0, 0, 0],]\r\n\r\nelements = [\"H\",\"He\",\"Li\",\"Be\",\"B\",\"C\",\"N\",\"O\",\"F\",\"Ne\",\"Na\",\"Mg\",\"Al\",\"Si\",\r\n\t\t\t\"P\",\"S\",\"Cl\",\"Ar\",\"K\",\"Ca\",\"Sc\",\"Ti\",\"V\",\"Cr\",\"Mn\",\"Fe\",\"Co\",\"Ni\",\r\n\t\t\t\"Cu\",\"Zn\",\"Ga\",\"Ge\",\"As\",\"Se\",\"Br\",\"Kr\",\"Rb\",\"Sr\",\"Y\",\"Zr\",\"Nb\",\"Mo\",\r\n\t\t\t\"Tc\",\"Ru\",\"Rh\",\"Pd\",\"Ag\",\"Cd\",\"In\",\"Sn\",\"Sb\",\"Te\",\"I\",\"Xe\",\"Cs\",\"Ba\",\r\n\t\t\t\"La\",\"Ce\",\"Pr\",\"Nd\",\"Pm\",\"Sm\",\"Eu\",\"Gd\",\"Tb\",\"Dy\",\"Ho\",\"Er\",\"Tm\",\"Yb\",\r\n\t\t\t\"Lu\",\"Hf\",\"Ta\",\"W\",\"Re\",\"Os\",\"Ir\",\"Pt\",\"Au\",\"Hg\",\"Tl\",\"Pb\",\"Bi\",\"Po\",\"At\",\r\n\t\t\t\"Rn\",\"Fr\",\"Ra\",\"Ac\",\"Th\",\"Pa\",\"U\",\"Np\",\"Pu\",\"Am\",\"Cm\",\"Bk\",\"Cf\",\"Es\",\"Fm\",\r\n\t\t\t\"Md\",\"No\",\"Lr\",\"Rf\",\"Db\",\"Sg\",\"Bh\",\"Hs\",\"Mt\",\"Ds\",\"Rg\",\"Uub\",\"Uut\",\"Uuq\",\r\n\t\t\t\"Uup\",\"Uuh\",\"Uus\",\"Uuo\"]\r\n\r\n## covalent radii (taken from Pyykko and Atsumi, Chem. Eur. J. 15, 2009, 188-197 ##\r\n## values for metals decreased by 10 % ##\r\nrcov = [0.32, 0.46, 1.20, 0.94, 0.77, 0.75, 0.71, 0.63, 0.64, 0.67,\r\n\t\t1.40, 1.25, 1.13, 1.04, 1.10, 1.02, 0.99, 0.96, 1.76, 1.54,\r\n\t\t1.33, 1.22, 1.21, 1.10, 1.07, 1.04, 1.00, 0.99, 1.01, 1.09,\r\n\t\t1.12, 1.09, 1.15, 1.10, 1.14, 1.17, 1.89, 1.67, 1.47, 1.39,\r\n\t\t1.32, 1.24, 1.15, 1.13, 1.13, 1.08, 1.15, 1.23, 1.28, 1.26,\r\n\t\t1.26, 1.23, 1.32, 1.31, 2.09, 1.76, 1.62, 1.47, 1.58, 1.57,\r\n\t\t1.56, 1.55, 1.51, 1.52, 1.51, 1.50, 1.49, 1.49, 1.48, 1.53,\r\n\t\t1.46, 1.37, 1.31, 1.23, 1.18, 1.16, 1.11, 1.12, 1.13, 1.32,\r\n\t\t1.30, 1.30, 1.36, 1.31, 1.38, 1.42, 2.01, 1.81, 1.67, 1.58,\r\n\t\t1.52, 1.53, 1.54, 1.55]\r\n", "meta": {"hexsha": "f2f127587c98275166007707332c00e1ecd79279", "size": 36533, "ext": "py", "lang": "Python", "max_stars_repo_path": "sterimoltools.py", "max_stars_repo_name": "ipendlet/Sterimol", "max_stars_repo_head_hexsha": "1951f56dfc5b01f9b5982c2fe1ac4e249aa21b7e", "max_stars_repo_licenses": ["CC-BY-3.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "sterimoltools.py", "max_issues_repo_name": "ipendlet/Sterimol", "max_issues_repo_head_hexsha": "1951f56dfc5b01f9b5982c2fe1ac4e249aa21b7e", "max_issues_repo_licenses": ["CC-BY-3.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "sterimoltools.py", "max_forks_repo_name": "ipendlet/Sterimol", "max_forks_repo_head_hexsha": "1951f56dfc5b01f9b5982c2fe1ac4e249aa21b7e", "max_forks_repo_licenses": ["CC-BY-3.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.6289381564, "max_line_length": 468, "alphanum_fraction": 0.523444557, "include": true, "reason": "import numpy,from numpy,from scipy", "num_tokens": 12634, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5698526514141572, "lm_q2_score": 0.341582499438317, "lm_q1q2_score": 0.1946516929815998}} {"text": "# Copyright 2014-2019 The PySCF Developers. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n# Author: Samragni Banerjee \n# Alexander Sokolov \n#\n\n'''\nRestricted algebraic diagrammatic construction\n'''\nimport time\nimport numpy as np\nimport pyscf.ao2mo as ao2mo\nfrom pyscf import lib\nfrom pyscf.lib import logger\nfrom pyscf.adc import radc_ao2mo\nfrom pyscf.adc import dfadc\nfrom pyscf import __config__\nfrom pyscf import df\n\ndef kernel(adc, nroots=1, guess=None, eris=None, verbose=None):\n\n adc.method = adc.method.lower()\n if adc.method not in (\"adc(2)\", \"adc(2)-x\", \"adc(3)\"):\n raise NotImplementedError(adc.method)\n\n cput0 = (time.clock(), time.time())\n log = logger.Logger(adc.stdout, adc.verbose)\n if adc.verbose >= logger.WARN:\n adc.check_sanity()\n adc.dump_flags()\n\n if eris is None:\n eris = adc.transform_integrals()\n\n imds = adc.get_imds(eris)\n matvec, diag = adc.gen_matvec(imds, eris)\n\n guess = adc.get_init_guess(nroots, diag, ascending = True)\n\n conv, E, U = lib.linalg_helper.davidson_nosym1(lambda xs : [matvec(x) for x in xs], guess, diag, nroots=nroots, verbose=log, tol=adc.conv_tol, max_cycle=adc.max_cycle, max_space=adc.max_space)\n\n U = np.array(U)\n\n T = adc.get_trans_moments()\n\n spec_factors = adc.get_spec_factors(T, U, nroots)\n \n nfalse = np.shape(conv)[0] - np.sum(conv)\n if nfalse >= 1:\n print (\"*************************************************************\")\n print (\" WARNING : \", \"Davidson iterations for \",nfalse, \"root(s) not converged\")\n print (\"*************************************************************\")\n\n if adc.verbose >= logger.INFO:\n if nroots == 1:\n logger.info(adc, '%s root %d Energy (Eh) = %.10f Energy (eV) = %.8f Spec factors = %.8f conv = %s',\n adc.method, 0, E, E*27.2114, spec_factors, conv)\n else :\n for n, en, pn, convn in zip(range(nroots), E, spec_factors, conv):\n logger.info(adc, '%s root %d Energy (Eh) = %.10f Energy (eV) = %.8f Spec factors = %.8f conv = %s',\n adc.method, n, en, en*27.2114, pn, convn)\n log.timer('ADC', *cput0)\n\n return E, U, spec_factors\n\n\ndef compute_amplitudes_energy(myadc, eris, verbose=None):\n\n t1, t2 = myadc.compute_amplitudes(eris)\n e_corr = myadc.compute_energy(t1, t2, eris)\n\n return e_corr, t1, t2\n\n\ndef compute_amplitudes(myadc, eris):\n\n if myadc.method not in (\"adc(2)\", \"adc(2)-x\", \"adc(3)\"):\n raise NotImplementedError(myadc.method)\n\n nocc = myadc._nocc\n nvir = myadc._nvir\n\n eris_oooo = eris.oooo\n eris_ovoo = eris.ovoo\n eris_ovov = eris.ovov\n eris_oovv = eris.oovv\n eris_ovvo = eris.ovvo\n eris_ovvv = eris.ovvv\n\n e = myadc.mo_energy\n\n d_ij = e[:nocc][:,None] + e[:nocc]\n\n d_ab = e[nocc:][:,None] + e[nocc:]\n\n D2 = d_ij.reshape(-1,1) - d_ab.reshape(-1)\n\n D2 = D2.reshape((nocc,nocc,nvir,nvir))\n\n D1 = e[:nocc][:None].reshape(-1,1) - e[nocc:].reshape(-1)\n D1 = D1.reshape((nocc,nvir))\n\n # Compute first-order doubles t2 (tijab)\n\n v2e_oovv = eris_ovov[:].transpose(0,2,1,3).copy()\n\n t2_1 = v2e_oovv/D2\n\n # Compute second-order singles t1 (tij)\n\n t2_1_a = t2_1 - t2_1.transpose(1,0,2,3).copy()\n\n eris_ovvv = radc_ao2mo.unpack_eri_1(eris.ovvv, nvir)\n t1_2 = 0.5*lib.einsum('kdac,ikcd->ia',eris_ovvv,t2_1_a,optimize=True)\n t1_2 -= 0.5*lib.einsum('kcad,ikcd->ia',eris_ovvv,t2_1_a,optimize=True)\n t1_2 += lib.einsum('kdac,ikcd->ia',eris_ovvv,t2_1,optimize=True)\n del eris_ovvv\n t1_2 -= 0.5*lib.einsum('lcki,klac->ia',eris_ovoo,t2_1_a,optimize=True)\n t1_2 -= 0.5*lib.einsum('kcli,lkac->ia',eris_ovoo,t2_1_a,optimize=True)\n t1_2 -= lib.einsum('lcki,klac->ia',eris_ovoo,t2_1,optimize=True)\n\n t1_2 = t1_2/D1\n\n t2_2 = None\n t1_3 = None\n\n if (myadc.method == \"adc(2)-x\" or myadc.method == \"adc(3)\"):\n\n # Compute second-order doubles t2 (tijab)\n\n eris_oooo = eris.oooo\n eris_ovvo = eris.ovvo\n\n if isinstance(eris.vvvv, np.ndarray):\n eris_vvvv = eris.vvvv\n temp = t2_1.reshape(nocc*nocc,nvir*nvir)\n t2_2 = np.dot(temp,eris_vvvv.T).reshape(nocc,nocc,nvir,nvir)\n elif isinstance(eris.vvvv, list):\n t2_2 = contract_ladder(myadc,t2_1,eris.vvvv)\n else:\n t2_2 = contract_ladder(myadc,t2_1,eris.Lvv)\n\n t2_2 += lib.einsum('kilj,klab->ijab',eris_oooo,t2_1,optimize=True)\n t2_2 += lib.einsum('kcbj,kica->ijab',eris_ovvo,t2_1_a,optimize=True)\n t2_2 += lib.einsum('kcbj,ikac->ijab',eris_ovvo,t2_1,optimize=True)\n t2_2 -= lib.einsum('kjbc,ikac->ijab',eris_oovv,t2_1,optimize=True)\n t2_2 -= lib.einsum('kibc,kjac->ijab',eris_oovv,t2_1,optimize=True)\n t2_2 -= lib.einsum('kjac,ikcb->ijab',eris_oovv,t2_1,optimize=True)\n t2_2 += lib.einsum('kcai,kjcb->ijab',eris_ovvo,t2_1_a,optimize=True)\n t2_2 += lib.einsum('kcai,kjcb->ijab',eris_ovvo,t2_1,optimize=True)\n t2_2 -= lib.einsum('kiac,kjcb->ijab',eris_oovv,t2_1,optimize=True)\n\n t2_2 = t2_2/D2\n \n if (myadc.method == \"adc(3)\"):\n # Compute third-order singles (tij)\n\n t2_2_a = t2_2 - t2_2.transpose(1,0,2,3).copy()\n\n eris_ovoo = eris.ovoo\n\n t1_3 = lib.einsum('d,ilad,ld->ia',e[nocc:],t2_1_a,t1_2,optimize=True)\n t1_3 += lib.einsum('d,ilad,ld->ia',e[nocc:],t2_1,t1_2,optimize=True)\n \n t1_3 -= lib.einsum('l,ilad,ld->ia',e[:nocc],t2_1_a, t1_2,optimize=True)\n t1_3 -= lib.einsum('l,ilad,ld->ia',e[:nocc],t2_1,t1_2,optimize=True)\n \n t1_3 += 0.5*lib.einsum('a,ilad,ld->ia',e[nocc:],t2_1_a, t1_2,optimize=True)\n t1_3 += 0.5*lib.einsum('a,ilad,ld->ia',e[nocc:],t2_1,t1_2,optimize=True)\n \n t1_3 -= 0.5*lib.einsum('i,ilad,ld->ia',e[:nocc],t2_1_a, t1_2,optimize=True)\n t1_3 -= 0.5*lib.einsum('i,ilad,ld->ia',e[:nocc],t2_1,t1_2,optimize=True)\n \n t1_3 += lib.einsum('ld,iald->ia',t1_2,eris_ovov,optimize=True)\n t1_3 -= lib.einsum('ld,laid->ia',t1_2,eris_ovov,optimize=True)\n t1_3 += lib.einsum('ld,iald->ia',t1_2,eris_ovov,optimize=True)\n \n t1_3 += lib.einsum('ld,ldai->ia',t1_2,eris_ovvo ,optimize=True)\n t1_3 -= lib.einsum('ld,liad->ia',t1_2,eris_oovv ,optimize=True)\n t1_3 += lib.einsum('ld,ldai->ia',t1_2,eris_ovvo,optimize=True)\n \n t1_3 -= 0.5*lib.einsum('lmad,mdli->ia',t2_2_a,eris_ovoo,optimize=True)\n t1_3 += 0.5*lib.einsum('lmad,ldmi->ia',t2_2_a,eris_ovoo,optimize=True)\n t1_3 -= lib.einsum('lmad,mdli->ia',t2_2,eris_ovoo,optimize=True)\n \n eris_ovvv = radc_ao2mo.unpack_eri_1(eris.ovvv, nvir)\n t1_3 += 0.5*lib.einsum('ilde,lead->ia',t2_2_a,eris_ovvv,optimize=True)\n t1_3 -= 0.5*lib.einsum('ilde,ldae->ia',t2_2_a,eris_ovvv,optimize=True)\n t1_3 -= lib.einsum('ildf,mefa,lmde->ia',t2_1_a, eris_ovvv, t2_1_a ,optimize=True)\n t1_3 += lib.einsum('ildf,mafe,lmde->ia',t2_1_a, eris_ovvv, t2_1_a ,optimize=True)\n t1_3 += lib.einsum('ilfd,mefa,mled->ia',t2_1,eris_ovvv, t2_1,optimize=True)\n t1_3 -= lib.einsum('ilfd,mafe,mled->ia',t2_1,eris_ovvv, t2_1,optimize=True)\n t1_3 += 0.5*lib.einsum('ilaf,mefd,lmde->ia',t2_1_a,eris_ovvv,t2_1_a,optimize=True)\n t1_3 -= 0.5*lib.einsum('ilaf,mdfe,lmde->ia',t2_1_a,eris_ovvv,t2_1_a,optimize=True)\n t1_3 += 0.5*lib.einsum('lmdf,iaef,lmde->ia',t2_1_a,eris_ovvv,t2_1_a,optimize=True)\n t1_3 -= 0.5*lib.einsum('lmdf,ifea,lmde->ia',t2_1_a,eris_ovvv,t2_1_a,optimize=True)\n t1_3 += lib.einsum('mlfd,iaef,mled->ia',t2_1,eris_ovvv,t2_1,optimize=True)\n t1_3 -= lib.einsum('mlfd,ifea,mled->ia',t2_1,eris_ovvv,t2_1,optimize=True)\n t1_3 -= 0.25*lib.einsum('lmef,iedf,lmad->ia',t2_1_a,eris_ovvv,t2_1_a,optimize=True)\n t1_3 += 0.25*lib.einsum('lmef,ifde,lmad->ia',t2_1_a,eris_ovvv,t2_1_a,optimize=True)\n\n t1_3 += 0.5*lib.einsum('ilaf,mefd,lmde->ia',t2_1,eris_ovvv,t2_1_a,optimize=True)\n t1_3 -= 0.5*lib.einsum('ilaf,mdfe,lmde->ia',t2_1,eris_ovvv,t2_1_a,optimize=True)\n\n t1_3 -= lib.einsum('ildf,mafe,mlde->ia',t2_1,eris_ovvv,t2_1,optimize=True)\n t1_3 += lib.einsum('ilaf,mefd,mled->ia',t2_1,eris_ovvv,t2_1,optimize=True)\n t1_3 += 0.5*lib.einsum('lmdf,iaef,lmde->ia',t2_1_a,eris_ovvv,t2_1_a,optimize=True)\n t1_3 += lib.einsum('lmdf,iaef,lmde->ia',t2_1,eris_ovvv,t2_1,optimize=True)\n t1_3 -= lib.einsum('lmef,iedf,lmad->ia',t2_1,eris_ovvv,t2_1,optimize=True)\n\n t1_3 += lib.einsum('ilde,lead->ia',t2_2,eris_ovvv,optimize=True)\n t1_3 -= lib.einsum('ildf,mefa,lmde->ia',t2_1_a,eris_ovvv, t2_1,optimize=True)\n t1_3 += lib.einsum('ilfd,mefa,lmde->ia',t2_1,eris_ovvv,t2_1_a ,optimize=True)\n t1_3 += lib.einsum('ilaf,mefd,lmde->ia',t2_1_a,eris_ovvv,t2_1,optimize=True)\n del eris_ovvv\n\n t1_3 += 0.25*lib.einsum('inde,lamn,lmde->ia',t2_1_a,eris_ovoo,t2_1_a,optimize=True)\n t1_3 -= 0.25*lib.einsum('inde,maln,lmde->ia',t2_1_a,eris_ovoo,t2_1_a,optimize=True)\n t1_3 += lib.einsum('inde,lamn,lmde->ia',t2_1,eris_ovoo,t2_1,optimize=True)\n \n t1_3 += 0.5*lib.einsum('inad,lemn,lmde->ia',t2_1_a,eris_ovoo,t2_1_a,optimize=True)\n t1_3 -= 0.5*lib.einsum('inad,meln,lmde->ia',t2_1_a,eris_ovoo,t2_1_a,optimize=True)\n t1_3 -= 0.5 * lib.einsum('inad,lemn,mlde->ia',t2_1_a,eris_ovoo,t2_1,optimize=True)\n t1_3 -= 0.5 * lib.einsum('inad,meln,lmde->ia',t2_1_a,eris_ovoo,t2_1,optimize=True)\n t1_3 -= 0.5 *lib.einsum('inad,lemn,lmed->ia',t2_1,eris_ovoo,t2_1,optimize=True)\n t1_3 -= 0.5*lib.einsum('inad,meln,mled->ia',t2_1,eris_ovoo,t2_1,optimize=True)\n t1_3 += 0.5*lib.einsum('inad,lemn,lmde->ia',t2_1,eris_ovoo,t2_1_a,optimize=True)\n t1_3 -= 0.5*lib.einsum('inad,meln,lmde->ia',t2_1,eris_ovoo,t2_1_a,optimize=True)\n \n t1_3 -= 0.5*lib.einsum('lnde,ianm,lmde->ia',t2_1_a,eris_ovoo,t2_1_a,optimize=True)\n t1_3 += 0.5*lib.einsum('lnde,naim,lmde->ia',t2_1_a,eris_ovoo,t2_1_a,optimize=True)\n t1_3 -= lib.einsum('nled,ianm,mled->ia',t2_1,eris_ovoo,t2_1,optimize=True)\n t1_3 += lib.einsum('nled,naim,mled->ia',t2_1,eris_ovoo,t2_1,optimize=True)\n t1_3 -= 0.5*lib.einsum('lnde,ianm,lmde->ia',t2_1_a,eris_ovoo,t2_1_a,optimize=True)\n t1_3 -= lib.einsum('lnde,ianm,lmde->ia',t2_1,eris_ovoo,t2_1,optimize=True)\n \n t1_3 -= lib.einsum('lnde,ienm,lmad->ia',t2_1_a,eris_ovoo,t2_1_a,optimize=True)\n t1_3 += lib.einsum('lnde,neim,lmad->ia',t2_1_a,eris_ovoo,t2_1_a,optimize=True)\n t1_3 += lib.einsum('lnde,neim,lmad->ia',t2_1,eris_ovoo,t2_1_a,optimize=True)\n t1_3 += lib.einsum('nled,ienm,mlad->ia',t2_1,eris_ovoo,t2_1,optimize=True)\n t1_3 -= lib.einsum('nled,neim,mlad->ia',t2_1,eris_ovoo,t2_1,optimize=True)\n t1_3 += lib.einsum('lned,ienm,lmad->ia',t2_1,eris_ovoo,t2_1,optimize=True)\n t1_3 -= lib.einsum('lnde,neim,mlad->ia',t2_1_a,eris_ovoo,t2_1,optimize=True)\n \n t1_3 = t1_3/D1\n\n t1 = (t1_2, t1_3)\n t2 = (t2_1, t2_2)\n\n return t1, t2\n\n\ndef compute_energy(myadc, t1, t2, eris):\n\n if myadc.method not in (\"adc(2)\", \"adc(2)-x\", \"adc(3)\"):\n raise NotImplementedError(myadc.method)\n\n nocc = myadc._nocc\n nvir = myadc._nvir\n\n eris_ovov = eris.ovov\n\n t2_1 = t2[0]\n\n #Compute MP2 correlation energy\n\n e_mp2 = 0.5 * lib.einsum('ijab,iajb', t2_1, eris_ovov,optimize=True)\n e_mp2 -= 0.5 * lib.einsum('ijab,ibja', t2_1, eris_ovov,optimize=True)\n e_mp2 -= 0.5 * lib.einsum('jiab,iajb', t2_1, eris_ovov,optimize=True)\n e_mp2 += 0.5 * lib.einsum('jiab,ibja', t2_1, eris_ovov,optimize=True)\n e_mp2 += lib.einsum('ijab,iajb', t2_1, eris_ovov,optimize=True)\n\n e_corr = e_mp2\n\n if (myadc.method == \"adc(3)\"):\n\n t2_1_a = t2_1 - t2_1.transpose(1,0,2,3).copy()\n\n #Compute MP3 correlation energy\n eris_oovv = eris.oovv\n eris_ovvo = eris.ovvo\n eris_oooo = eris.oooo\n\n temp_t2_a = None\n temp_t2_ab = None\n temp_t2_t2 = None\n temp_t2a_t2a = None\n temp_t2_a_vvvv = None\n temp_t2_ab_vvvv = None\n\n eris_vvvv = eris.vvvv\n\n if isinstance(eris.vvvv, np.ndarray):\n temp_t2_a = t2_1_a.reshape(nocc*nocc,nvir*nvir)\n temp_t2_a_vvvv = np.dot(temp_t2_a,eris_vvvv.T).reshape(nocc,nocc,nvir,nvir)\n elif isinstance(eris.vvvv, list): \n temp_t2_a_vvvv = contract_ladder(myadc,t2_1_a,eris.vvvv)\n else : \n temp_t2_a_vvvv = contract_ladder(myadc,t2_1_a,eris.Lvv)\n\n if isinstance(eris.vvvv, np.ndarray):\n temp_t2_ab = t2_1.reshape(nocc*nocc,nvir*nvir)\n temp_t2_ab_vvvv = np.dot(temp_t2_ab,eris_vvvv.T).reshape(nocc,nocc,nvir,nvir)\n elif isinstance(eris.vvvv, list): \n temp_t2_ab_vvvv = contract_ladder(myadc,t2_1,eris.vvvv)\n else : \n temp_t2_ab_vvvv = contract_ladder(myadc,t2_1,eris.Lvv)\n\n\n e_mp3 = lib.einsum('ijcd,ijcd',temp_t2_ab_vvvv, t2_1,optimize=True)\n del temp_t2_ab_vvvv\n\n\n if isinstance(eris.vvvv, np.ndarray):\n temp_t2_a = temp_t2_a.reshape(nocc,nocc,nvir,nvir)\n temp_t2_a = np.ascontiguousarray(temp_t2_a.transpose(0,1,3,2))\n temp_t2_a = temp_t2_a.reshape(nocc*nocc,nvir*nvir)\n temp_t2_a_vvvv -= np.dot(temp_t2_a,eris_vvvv.T).reshape(nocc,nocc,nvir,nvir)\n elif isinstance(eris.vvvv, list): \n t2_1_a_t = np.ascontiguousarray(t2_1_a.transpose(0,1,3,2))\n temp_t2_a_vvvv_n = contract_ladder(myadc,t2_1_a_t,eris.vvvv)\n temp_t2_a_vvvv -= temp_t2_a_vvvv_n\n else: \n t2_1_a_t = np.ascontiguousarray(t2_1_a.transpose(0,1,3,2))\n temp_t2_a_vvvv_n = contract_ladder(myadc,t2_1_a_t,eris.Lvv)\n temp_t2_a_vvvv -= temp_t2_a_vvvv_n\n\n e_mp3 += 0.25 * lib.einsum('ijcd,ijcd',temp_t2_a_vvvv, t2_1_a,optimize=True)\n \n temp_t2a_t2a = lib.einsum('ijab,klab', t2_1_a, t2_1_a,optimize=True)\n e_mp3 += 0.25 * lib.einsum('ijkl,ikjl',temp_t2a_t2a, eris_oooo,optimize=True)\n e_mp3 -= 0.25 * lib.einsum('ijkl,iljk',temp_t2a_t2a, eris_oooo,optimize=True)\n del temp_t2a_t2a\n\n temp_t2_t2 = lib.einsum('ijab,klab', t2_1, t2_1,optimize=True)\n e_mp3 += lib.einsum('ijkl,ikjl',temp_t2_t2, eris_oooo,optimize=True)\n del temp_t2_t2\n\n temp_t2_t2 = lib.einsum('ijab,ikcb->akcj', t2_1_a, t2_1_a,optimize=True)\n temp_t2_t2 += lib.einsum('jiab,kicb->akcj', t2_1, t2_1,optimize=True)\n e_mp3 -= 2 * lib.einsum('akcj,kjac',temp_t2_t2, eris_oovv,optimize=True)\n e_mp3 += 2 * lib.einsum('akcj,kcaj',temp_t2_t2, eris_ovvo,optimize=True)\n del temp_t2_t2\n\n temp_t2_t2 = lib.einsum('ijab,ikcb->akcj', t2_1, t2_1,optimize=True)\n e_mp3 -= lib.einsum('akcj,kjac',temp_t2_t2, eris_oovv,optimize=True)\n del temp_t2_t2\n \n temp_t2_t2 = lib.einsum('jiba,kibc->akcj', t2_1, t2_1,optimize=True)\n e_mp3 -= lib.einsum('akcj,kjac',temp_t2_t2, eris_oovv,optimize=True)\n del temp_t2_t2\n\n temp_t2_t2 = -lib.einsum('ijab,ikbc->akcj', t2_1_a, t2_1,optimize=True)\n temp_t2_t2 -= lib.einsum('jiab,ikcb->akcj', t2_1, t2_1_a,optimize=True)\n e_mp3 += lib.einsum('akcj,kcaj',temp_t2_t2, eris_ovvo,optimize=True)\n del temp_t2_t2\n\n temp_t2_t2 = -lib.einsum('ijba,ikcb->akcj', t2_1, t2_1_a,optimize=True)\n temp_t2_t2 -= lib.einsum('ijab,kicb->akcj', t2_1_a, t2_1,optimize=True)\n e_mp3 += lib.einsum('akcj,kcaj',temp_t2_t2, eris_ovvo,optimize=True)\n del temp_t2_t2\n \n e_corr += e_mp3\n\n return e_corr\n\n\ndef contract_ladder(myadc,t_amp,vvvv):\n\n nocc = myadc._nocc\n nvir = myadc._nvir\n\n t_amp_t = np.ascontiguousarray(t_amp.reshape(nocc*nocc,nvir*nvir).T)\n t = np.zeros((nvir,nvir, nocc*nocc))\n chnk_size = radc_ao2mo.calculate_chunk_size(myadc)\n\n a = 0\n if isinstance(vvvv, list):\n for dataset in vvvv:\n k = dataset.shape[0]\n dataset = dataset[:].reshape(-1,nvir*nvir)\n t[a:a+k] = np.dot(dataset,t_amp_t).reshape(-1,nvir,nocc*nocc)\n a += k\n elif getattr(myadc, 'with_df', None):\n for p in range(0,nvir,chnk_size):\n vvvv_p = dfadc.get_vvvv_df(myadc, vvvv, p, chnk_size)\n k = vvvv_p.shape[0]\n vvvv_p = vvvv_p.reshape(-1,nvir*nvir)\n t[a:a+k] = np.dot(vvvv_p,t_amp_t).reshape(-1,nvir,nocc*nocc)\n del (vvvv_p)\n a += k\n else :\n raise Exception(\"Unknown vvvv type\") \n\n t = np.ascontiguousarray(t.transpose(2,0,1)).reshape(nocc, nocc, nvir, nvir)\n\n return t\n\n\ndef density_matrix(myadc, T=None):\n\n if T is None:\n T = RADCIP(myadc).get_trans_moments()\n\n nocc = myadc._nocc\n nvir = myadc._nvir\n\n n_singles = nocc\n n_doubles = nvir * nocc * nocc\n ij_ind = np.tril_indices(nocc, k=-1)\n\n s1 = 0\n f1 = n_singles\n s2 = f1\n f2 = s2 + n_doubles\n\n T_doubles = T[:,n_singles:]\n T_doubles = T_doubles.reshape(-1,nvir,nocc,nocc)\n T_doubles_transpose = T_doubles.transpose(0,1,3,2).copy()\n T_bab = (2/3)*T_doubles + (1/3)*T_doubles_transpose\n\n T_aaa = T_bab - T_bab.transpose(0,1,3,2)\n\n T_a = T[:,s1:f1]\n T_bab = T_bab.reshape(-1,n_doubles)\n T_aaa = T_aaa.reshape(-1,n_doubles)\n\n dm = 2 * np.dot(T_a,T_a.T) + np.dot(T_aaa, T_aaa.T) + 2 * np.dot(T_bab, T_bab.T)\n\n return dm\n\n\nclass RADC(lib.StreamObject):\n '''Ground state calculations\n\n Attributes:\n verbose : int\n Print level. Default value equals to :class:`Mole.verbose`\n max_memory : float or int\n Allowed memory in MB. Default value equals to :class:`Mole.max_memory`\n incore_complete : bool\n Avoid all I/O. Default is False.\n method : string\n nth-order ADC method. Options are : ADC(2), ADC(2)-X, ADC(3). Default is ADC(2).\n\n >>> mol = gto.M(atom = 'H 0 0 0; F 0 0 1.1', basis = 'ccpvdz')\n >>> mf = scf.RHF(mol).run()\n >>> myadc = adc.RADC(mf).run()\n\n Saved results\n\n e_corr : float\n MPn correlation correction\n e_tot : float\n Total energy (HF + correlation)\n t1, t2 :\n T amplitudes t1[i,a], t2[i,j,a,b] (i,j in occ, a,b in virt)\n '''\n incore_complete = getattr(__config__, 'adc_radc_RADC_incore_complete', False)\n async_io = getattr(__config__, 'adc_radc_RADC_async_io', True)\n blkmin = getattr(__config__, 'adc_radc_RADC_blkmin', 4)\n memorymin = getattr(__config__, 'adc_radc_RADC_memorymin', 2000)\n \n def __init__(self, mf, frozen=0, mo_coeff=None, mo_occ=None):\n from pyscf import gto\n \n if 'dft' in str(mf.__module__):\n raise NotImplementedError('DFT reference for UADC')\n \n if mo_coeff is None: mo_coeff = mf.mo_coeff\n if mo_occ is None: mo_occ = mf.mo_occ\n \n self.mol = mf.mol\n self._scf = mf\n self.verbose = self.mol.verbose\n self.stdout = self.mol.stdout\n self.max_memory = mf.max_memory\n\n self.max_space = getattr(__config__, 'adc_radc_RADC_max_space', 12)\n self.max_cycle = getattr(__config__, 'adc_radc_RADC_max_cycle', 50)\n self.conv_tol = getattr(__config__, 'adc_radc_RADC_conv_tol', 1e-12)\n self.scf_energy = mf.e_tot\n \n self.frozen = frozen\n self.incore_complete = self.incore_complete or self.mol.incore_anyway\n \n self.mo_coeff = mo_coeff\n self.mo_occ = mo_occ\n self.e_corr = None\n self.e_tot = None\n self.t1 = None\n self.t2 = None\n self._nocc = mf.mol.nelectron//2\n self._nmo = mo_coeff.shape[1]\n self._nvir = self._nmo - self._nocc\n self.mo_energy = mf.mo_energy\n self.chkfile = mf.chkfile\n self.method = \"adc(2)\"\n self.method_type = \"ip\"\n self.with_df = None\n\n keys = set(('conv_tol', 'e_corr', 'method', 'mo_coeff', 'mol', 'mo_energy', 'max_memory', 'incore_complete', 'scf_energy', 'e_tot', 't1', 'frozen', 'chkfile', 'max_space', 't2', 'mo_occ', 'max_cycle'))\n\n self._keys = set(self.__dict__.keys()).union(keys)\n \n compute_amplitudes = compute_amplitudes\n compute_energy = compute_energy\n transform_integrals = radc_ao2mo.transform_integrals_incore\n make_rdm1 = density_matrix \n \n def dump_flags(self, verbose=None):\n logger.info(self, '')\n logger.info(self, '******** %s ********', self.__class__)\n logger.info(self, 'max_space = %d', self.max_space)\n logger.info(self, 'max_cycle = %d', self.max_cycle)\n logger.info(self, 'conv_tol = %s', self.conv_tol)\n logger.info(self, 'max_memory %d MB (current use %d MB)',\n self.max_memory, lib.current_memory()[0])\n return self\n \n def dump_flags_gs(self, verbose=None):\n logger.info(self, '')\n logger.info(self, '******** %s ********', self.__class__)\n logger.info(self, 'max_memory %d MB (current use %d MB)',\n self.max_memory, lib.current_memory()[0])\n return self\n \n def kernel_gs(self):\n assert(self.mo_coeff is not None)\n assert(self.mo_occ is not None)\n \n self.method = self.method.lower()\n if self.method not in (\"adc(2)\", \"adc(2)-x\", \"adc(3)\"):\n raise NotImplementedError(self.method)\n \n if self.verbose >= logger.WARN:\n self.check_sanity()\n self.dump_flags_gs()\n \n nmo = self._nmo\n nao = self.mo_coeff.shape[0]\n nmo_pair = nmo * (nmo+1) // 2\n nao_pair = nao * (nao+1) // 2\n mem_incore = (max(nao_pair**2, nmo**4) + nmo_pair**2) * 8/1e6\n mem_now = lib.current_memory()[0]\n\n if getattr(self, 'with_df', None) or getattr(self._scf, 'with_df', None): \n if getattr(self, 'with_df', None): \n self.with_df = self.with_df\n else :\n self.with_df = self._scf.with_df\n\n def df_transform():\n return radc_ao2mo.transform_integrals_df(self)\n self.transform_integrals = df_transform\n elif (self._scf._eri is None or\n (mem_incore+mem_now >= self.max_memory and not self.incore_complete)):\n def outcore_transform():\n return radc_ao2mo.transform_integrals_outcore(self)\n self.transform_integrals = outcore_transform\n\n eris = self.transform_integrals()\n \n self.e_corr, self.t1, self.t2 = compute_amplitudes_energy(self, eris=eris, verbose=self.verbose)\n self.e_tot = self.scf_energy + self.e_corr\n\n self._finalize()\n\n return self.e_corr, self.t1, self.t2\n\n def kernel(self, nroots=1, guess=None, eris=None):\n assert(self.mo_coeff is not None)\n assert(self.mo_occ is not None)\n \n self.method = self.method.lower()\n if self.method not in (\"adc(2)\", \"adc(2)-x\", \"adc(3)\"):\n raise NotImplementedError(self.method)\n \n if self.verbose >= logger.WARN:\n self.check_sanity()\n self.dump_flags_gs()\n \n nmo = self._nmo\n nao = self.mo_coeff.shape[0]\n nmo_pair = nmo * (nmo+1) // 2\n nao_pair = nao * (nao+1) // 2\n mem_incore = (max(nao_pair**2, nmo**4) + nmo_pair**2) * 8/1e6\n mem_now = lib.current_memory()[0]\n\n if getattr(self, 'with_df', None) or getattr(self._scf, 'with_df', None): \n if getattr(self, 'with_df', None): \n self.with_df = self.with_df\n else :\n self.with_df = self._scf.with_df\n\n def df_transform():\n return radc_ao2mo.transform_integrals_df(self)\n self.transform_integrals = df_transform\n elif (self._scf._eri is None or\n (mem_incore+mem_now >= self.max_memory and not self.incore_complete)):\n def outcore_transform():\n return radc_ao2mo.transform_integrals_outcore(self)\n self.transform_integrals = outcore_transform\n\n eris = self.transform_integrals() \n \n self.e_corr, self.t1, self.t2 = compute_amplitudes_energy(self, eris=eris, verbose=self.verbose)\n self.e_tot = self.scf_energy + self.e_corr\n\n self._finalize()\n\n self.method_type = self.method_type.lower()\n if(self.method_type == \"ea\"):\n e_exc, v_exc, spec_fac = self.ea_adc(nroots=nroots, guess=guess, eris=eris)\n\n elif(self.method_type == \"ip\"):\n e_exc, v_exc, spec_fac = self.ip_adc(nroots=nroots, guess=guess, eris=eris)\n\n else:\n raise NotImplementedError(self.method_type)\n\n return e_exc, v_exc, spec_fac\n\n def _finalize(self):\n '''Hook for dumping results and clearing up the object.'''\n logger.note(self, 'E_corr = %.8f E_tot = %.8f',\n self.e_corr, self.e_tot)\n return self\n \n def ea_adc(self, nroots=1, guess=None, eris=None):\n return RADCEA(self).kernel(nroots, guess, eris)\n \n def ip_adc(self, nroots=1, guess=None, eris=None):\n return RADCIP(self).kernel(nroots, guess, eris)\n\n def density_fit(self, auxbasis=None, with_df = None):\n if with_df is None:\n self.with_df = df.DF(self._scf.mol)\n self.with_df.max_memory = self.max_memory\n self.with_df.stdout = self.stdout\n self.with_df.verbose = self.verbose\n if auxbasis is None:\n self.with_df.auxbasis = self._scf.with_df.auxbasis\n else :\n self.with_df.auxbasis = auxbasis\n else :\n self.with_df = with_df\n return self\n\n\ndef get_imds_ea(adc, eris=None):\n\n if adc.method not in (\"adc(2)\", \"adc(2)-x\", \"adc(3)\"):\n raise NotImplementedError(adc.method)\n\n method = adc.method\n\n t1 = adc.t1\n t2 = adc.t2\n\n t1_2 = t1[0]\n t2_1 = t2[0]\n\n t2_1_a = t2_1 - t2_1.transpose(1,0,2,3).copy()\n\n nocc = adc._nocc\n nvir = adc._nvir\n\n e_occ = adc.mo_energy[:nocc]\n e_vir = adc.mo_energy[nocc:]\n\n idn_occ = np.identity(nocc)\n idn_vir = np.identity(nvir)\n\n if eris is None:\n eris = adc.transform_integrals()\n\n eris_ovov = eris.ovov\n\n # a-b block\n # Zeroth-order terms\n\n M_ab = lib.einsum('ab,a->ab', idn_vir, e_vir)\n\n # Second-order terms\n\n M_ab += lib.einsum('l,lmad,lmbd->ab',e_occ ,t2_1_a, t2_1_a,optimize=True)\n M_ab += lib.einsum('l,lmad,lmbd->ab',e_occ,t2_1, t2_1,optimize=True)\n M_ab += lib.einsum('l,mlad,mlbd->ab',e_occ,t2_1, t2_1,optimize=True)\n\n M_ab -= 0.5 * lib.einsum('d,lmad,lmbd->ab',e_vir,t2_1_a, t2_1_a,optimize=True)\n M_ab -= 0.5 * lib.einsum('d,lmad,lmbd->ab',e_vir,t2_1, t2_1,optimize=True)\n M_ab -= 0.5 * lib.einsum('d,mlad,mlbd->ab',e_vir,t2_1, t2_1,optimize=True)\n\n M_ab -= 0.25 * lib.einsum('a,lmad,lmbd->ab',e_vir,t2_1_a, t2_1_a,optimize=True)\n M_ab -= 0.25 * lib.einsum('a,lmad,lmbd->ab',e_vir,t2_1, t2_1,optimize=True)\n M_ab -= 0.25 * lib.einsum('a,mlad,mlbd->ab',e_vir,t2_1, t2_1,optimize=True)\n\n M_ab -= 0.25 * lib.einsum('b,lmad,lmbd->ab',e_vir,t2_1_a, t2_1_a,optimize=True)\n M_ab -= 0.25 * lib.einsum('b,lmad,lmbd->ab',e_vir,t2_1, t2_1,optimize=True)\n M_ab -= 0.25 * lib.einsum('b,mlad,mlbd->ab',e_vir,t2_1, t2_1,optimize=True)\n\n M_ab -= 0.5 * lib.einsum('lmad,lbmd->ab',t2_1_a, eris_ovov,optimize=True)\n M_ab += 0.5 * lib.einsum('lmad,ldmb->ab',t2_1_a, eris_ovov,optimize=True)\n M_ab -= lib.einsum('lmad,lbmd->ab',t2_1, eris_ovov,optimize=True)\n\n M_ab -= 0.5 * lib.einsum('lmbd,lamd->ab',t2_1_a, eris_ovov,optimize=True)\n M_ab += 0.5 * lib.einsum('lmbd,ldma->ab',t2_1_a, eris_ovov,optimize=True)\n M_ab -= lib.einsum('lmbd,lamd->ab',t2_1, eris_ovov,optimize=True)\n\n #Third-order terms\n\n if(method =='adc(3)'):\n\n t2_2 = t2[1]\n t2_2_a = t2_2 - t2_2.transpose(1,0,2,3).copy()\n\n eris_oovv = eris.oovv\n eris_ovvo = eris.ovvo\n eris_oooo = eris.oooo\n \n eris_ovvv = radc_ao2mo.unpack_eri_1(eris.ovvv, nvir)\n M_ab += 4. * lib.einsum('ld,ldab->ab',t1_2, eris_ovvv,optimize=True)\n M_ab -= lib.einsum('ld,lbad->ab',t1_2, eris_ovvv,optimize=True)\n M_ab -= lib.einsum('ld,ladb->ab',t1_2, eris_ovvv,optimize=True)\n del eris_ovvv\n\n M_ab -= 0.5 * lib.einsum('lmad,lbmd->ab',t2_2_a, eris_ovov,optimize=True)\n M_ab += 0.5 * lib.einsum('lmad,ldmb->ab',t2_2_a, eris_ovov,optimize=True)\n M_ab -= lib.einsum('lmad,lbmd->ab',t2_2, eris_ovov,optimize=True)\n\n M_ab -= 0.5 * lib.einsum('lmbd,lamd->ab',t2_2_a,eris_ovov,optimize=True)\n M_ab += 0.5 * lib.einsum('lmbd,ldma->ab',t2_2_a, eris_ovov,optimize=True)\n M_ab -= lib.einsum('lmbd,lamd->ab',t2_2,eris_ovov,optimize=True)\n\n M_ab += lib.einsum('l,lmbd,lmad->ab',e_occ, t2_1_a, t2_2_a, optimize=True)\n M_ab += lib.einsum('l,lmbd,lmad->ab',e_occ, t2_1, t2_2, optimize=True)\n M_ab += lib.einsum('l,mlbd,mlad->ab',e_occ, t2_1, t2_2, optimize=True)\n\n M_ab += lib.einsum('l,lmad,lmbd->ab',e_occ, t2_1_a, t2_2_a, optimize=True)\n M_ab += lib.einsum('l,lmad,lmbd->ab',e_occ, t2_1, t2_2, optimize=True)\n M_ab += lib.einsum('l,mlad,mlbd->ab',e_occ, t2_1, t2_2, optimize=True)\n\n M_ab -= 0.5*lib.einsum('d,lmbd,lmad->ab', e_vir, t2_1_a ,t2_2_a, optimize=True)\n M_ab -= 0.5*lib.einsum('d,lmbd,lmad->ab', e_vir, t2_1 ,t2_2, optimize=True)\n M_ab -= 0.5*lib.einsum('d,mlbd,mlad->ab', e_vir, t2_1 ,t2_2, optimize=True)\n\n M_ab -= 0.5*lib.einsum('d,lmad,lmbd->ab', e_vir, t2_1_a, t2_2_a, optimize=True)\n M_ab -= 0.5*lib.einsum('d,lmad,lmbd->ab', e_vir, t2_1, t2_2, optimize=True)\n M_ab -= 0.5*lib.einsum('d,mlad,mlbd->ab', e_vir, t2_1, t2_2, optimize=True)\n\n M_ab -= 0.25*lib.einsum('a,lmbd,lmad->ab',e_vir, t2_1_a, t2_2_a, optimize=True)\n M_ab -= 0.25*lib.einsum('a,lmbd,lmad->ab',e_vir, t2_1, t2_2, optimize=True)\n M_ab -= 0.25*lib.einsum('a,mlbd,mlad->ab',e_vir, t2_1, t2_2, optimize=True)\n\n M_ab -= 0.25*lib.einsum('a,lmad,lmbd->ab',e_vir, t2_1_a, t2_2_a, optimize=True)\n M_ab -= 0.25*lib.einsum('a,lmad,lmbd->ab',e_vir, t2_1, t2_2, optimize=True)\n M_ab -= 0.25*lib.einsum('a,mlad,mlbd->ab',e_vir, t2_1, t2_2, optimize=True)\n\n M_ab -= 0.25*lib.einsum('b,lmbd,lmad->ab',e_vir, t2_1_a, t2_2_a, optimize=True)\n M_ab -= 0.25*lib.einsum('b,lmbd,lmad->ab',e_vir, t2_1, t2_2, optimize=True)\n M_ab -= 0.25*lib.einsum('b,mlbd,mlad->ab',e_vir, t2_1, t2_2, optimize=True)\n\n M_ab -= 0.25*lib.einsum('b,lmad,lmbd->ab',e_vir, t2_1_a, t2_2_a, optimize=True)\n M_ab -= 0.25*lib.einsum('b,lmad,lmbd->ab',e_vir, t2_1, t2_2, optimize=True)\n M_ab -= 0.25*lib.einsum('b,mlad,mlbd->ab',e_vir, t2_1, t2_2, optimize=True)\n\n M_ab -= lib.einsum('lned,mlbd,nmae->ab',t2_1_a, t2_1_a, eris_oovv, optimize=True)\n M_ab += lib.einsum('lned,mlbd,mane->ab',t2_1_a, t2_1_a, eris_ovov, optimize=True)\n M_ab += lib.einsum('nled,mlbd,nmae->ab',t2_1, t2_1, eris_oovv, optimize=True)\n M_ab -= lib.einsum('nled,mlbd,mane->ab',t2_1, t2_1, eris_ovov, optimize=True)\n M_ab -= lib.einsum('lnde,mlbd,neam->ab',t2_1, t2_1_a, eris_ovvo, optimize=True)\n M_ab += lib.einsum('lned,mlbd,neam->ab',t2_1_a, t2_1, eris_ovvo, optimize=True)\n M_ab += lib.einsum('lned,lmbd,nmae->ab',t2_1, t2_1, eris_oovv, optimize=True)\n\n M_ab -= lib.einsum('mled,lnad,nmeb->ab',t2_1_a, t2_1_a, eris_oovv, optimize=True)\n M_ab += lib.einsum('mled,lnad,nbem->ab',t2_1_a, t2_1_a, eris_ovvo, optimize=True)\n M_ab += lib.einsum('mled,nlad,nmeb->ab',t2_1, t2_1, eris_oovv, optimize=True)\n M_ab -= lib.einsum('mled,nlad,nbem->ab',t2_1, t2_1, eris_ovvo, optimize=True)\n M_ab += lib.einsum('lmed,lnad,nmeb->ab',t2_1, t2_1, eris_oovv, optimize=True)\n M_ab -= lib.einsum('mled,nlad,nbem->ab',t2_1_a, t2_1, eris_ovvo, optimize=True)\n M_ab += lib.einsum('lmde,lnad,nbem->ab',t2_1, t2_1_a, eris_ovvo, optimize=True)\n\n M_ab -= lib.einsum('mlbd,lnae,nmde->ab',t2_1_a, t2_1_a, eris_oovv, optimize=True)\n M_ab += lib.einsum('mlbd,lnae,nedm->ab',t2_1_a, t2_1_a, eris_ovvo, optimize=True)\n M_ab += lib.einsum('lmbd,lnae,nmde->ab',t2_1, t2_1, eris_oovv, optimize=True)\n M_ab -= lib.einsum('lmbd,lnae,nedm->ab',t2_1, t2_1, eris_ovvo, optimize=True)\n M_ab += lib.einsum('mlbd,lnae,nedm->ab',t2_1_a, t2_1, eris_ovvo, optimize=True)\n M_ab -= lib.einsum('lmbd,lnae,nedm->ab',t2_1, t2_1_a, eris_ovvo, optimize=True)\n M_ab += lib.einsum('mlbd,nlae,nmde->ab',t2_1, t2_1, eris_oovv, optimize=True)\n\n M_ab += 0.5*lib.einsum('lned,mled,nmab->ab',t2_1_a, t2_1_a, eris_oovv, optimize=True)\n M_ab -= 0.5*lib.einsum('lned,mled,nbam->ab',t2_1_a, t2_1_a, eris_ovvo, optimize=True)\n M_ab -= lib.einsum('nled,mled,nmab->ab',t2_1, t2_1, eris_oovv, optimize=True)\n M_ab += lib.einsum('nled,mled,nbam->ab',t2_1, t2_1, eris_ovvo, optimize=True)\n M_ab += 0.5*lib.einsum('lned,mled,nmab->ab',t2_1_a, t2_1_a, eris_oovv, optimize=True)\n M_ab -= lib.einsum('lned,lmed,nmab->ab',t2_1, t2_1, eris_oovv, optimize=True)\n\n M_ab -= 0.25*lib.einsum('mlbd,noad,nmol->ab',t2_1_a, t2_1_a, eris_oooo, optimize=True)\n M_ab += 0.25*lib.einsum('mlbd,noad,nlom->ab',t2_1_a, t2_1_a, eris_oooo, optimize=True)\n M_ab -= lib.einsum('mlbd,noad,nmol->ab',t2_1, t2_1, eris_oooo, optimize=True)\n\n\n if isinstance(eris.vvvv, np.ndarray):\n t2_1_a_r = t2_1_a.reshape(nocc*nocc,nvir*nvir)\n t2_1_r = t2_1.reshape(nocc*nocc,nvir*nvir)\n eris_vvvv = eris.vvvv\n temp_t2a = np.dot(t2_1_a_r,eris_vvvv)\n temp_t2 = np.dot(t2_1_r,eris_vvvv)\n temp_t2a = temp_t2a.reshape(nocc,nocc,nvir,nvir)\n temp_t2 = temp_t2.reshape(nocc,nocc,nvir,nvir)\n M_ab -= 0.25*lib.einsum('mlaf,mlbf->ab',t2_1_a, temp_t2a, optimize=True)\n M_ab += 0.25*lib.einsum('mlaf,mlfb->ab',t2_1_a, temp_t2a, optimize=True)\n M_ab -= lib.einsum('mlaf,mlbf->ab',t2_1, temp_t2, optimize=True)\n temp_vvvv_t2a = np.dot(eris_vvvv,t2_1_a_r.T)\n temp_vvvv_t2a = temp_vvvv_t2a.reshape(nvir,nvir,nocc,nocc)\n M_ab += 0.25*lib.einsum('adlm,mlbd->ab',temp_vvvv_t2a, t2_1_a, optimize=True)\n else:\n if isinstance(eris.vvvv, list):\n temp_t2a_vvvv = contract_ladder(adc,t2_1_a,eris.vvvv)\n temp_t2_vvvv = contract_ladder(adc,t2_1,eris.vvvv)\n else :\n temp_t2a_vvvv = contract_ladder(adc,t2_1_a,eris.Lvv)\n temp_t2_vvvv = contract_ladder(adc,t2_1,eris.Lvv)\n\n M_ab -= 0.25*lib.einsum('mlaf,mlbf->ab',t2_1_a, temp_t2a_vvvv, optimize=True)\n M_ab += 0.25*lib.einsum('mlaf,mlfb->ab',t2_1_a, temp_t2a_vvvv, optimize=True)\n M_ab -= lib.einsum('mlaf,mlbf->ab',t2_1, temp_t2_vvvv, optimize=True)\n M_ab += 0.25*lib.einsum('lmad,mlbd->ab',temp_t2a_vvvv, t2_1_a, optimize=True)\n\n\n if isinstance(eris.vvvv, np.ndarray):\n t2_1_a_temp = t2_1_a.reshape(nocc*nocc,nvir*nvir)\n t2_1_temp = t2_1.reshape(nocc*nocc,nvir*nvir)\n temp_1 = np.dot(t2_1_temp,eris_vvvv.T).reshape(nocc,nocc,nvir,nvir)\n temp_1_a = np.dot(t2_1_a_temp,eris_vvvv.T).reshape(nocc,nocc,nvir,nvir)\n\n M_ab -= 0.25*lib.einsum('mlad,mlbd->ab', temp_1_a, t2_1_a, optimize=True)\n M_ab -= lib.einsum('mlad,mlbd->ab', temp_1, t2_1, optimize=True)\n\n eris_vvvv = eris_vvvv.reshape(nvir,nvir,nvir,nvir)\n M_ab -= lib.einsum('mldf,mled,aebf->ab',t2_1_a, t2_1_a, eris_vvvv, optimize=True)\n M_ab += 0.5*lib.einsum('mldf,mled,aefb->ab',t2_1_a, t2_1_a, eris_vvvv, optimize=True)\n M_ab += 2.*lib.einsum('mlfd,mled,aebf->ab',t2_1, t2_1, eris_vvvv, optimize=True)\n M_ab -= lib.einsum('mlfd,mled,aefb->ab',t2_1, t2_1, eris_vvvv, optimize=True)\n eris_vvvv = eris_vvvv.reshape(nvir*nvir,nvir*nvir)\n else :\n if isinstance(eris.vvvv, list):\n temp_t2_a_vvvv = contract_ladder(adc,t2_1_a,eris.vvvv)\n temp_t2_vvvv = contract_ladder(adc,t2_1,eris.vvvv)\n else:\n temp_t2_a_vvvv = contract_ladder(adc,t2_1_a,eris.Lvv)\n temp_t2_vvvv = contract_ladder(adc,t2_1,eris.Lvv)\n M_ab -= 0.25*lib.einsum('mlad,mlbd->ab', temp_t2_a_vvvv, t2_1_a, optimize=True)\n M_ab -= lib.einsum('mlad,mlbd->ab', temp_t2_vvvv, t2_1, optimize=True)\n\n chnk_size = radc_ao2mo.calculate_chunk_size(adc)\n a = 0 \n temp = np.zeros((nvir,nvir))\n\n if isinstance(eris.vvvv, list):\n for dataset in eris.vvvv:\n k = dataset.shape[0]\n eris_vvvv = dataset[:].reshape(-1,nvir,nvir,nvir)\n temp[a:a+k] -= lib.einsum('mldf,mled,aebf->ab',t2_1_a, t2_1_a, eris_vvvv, optimize=True)\n temp[a:a+k] += 0.5*lib.einsum('mldf,mled,aefb->ab',t2_1_a, t2_1_a, eris_vvvv, optimize=True)\n temp[a:a+k] += 2.*lib.einsum('mlfd,mled,aebf->ab',t2_1, t2_1, eris_vvvv, optimize=True)\n temp[a:a+k] -= lib.einsum('mlfd,mled,aefb->ab',t2_1, t2_1, eris_vvvv, optimize=True)\n del eris_vvvv\n a += k\n else :\n\n for p in range(0,nvir,chnk_size):\n\n vvvv = dfadc.get_vvvv_df(adc, eris.Lvv, p, chnk_size).reshape(-1,nvir,nvir,nvir)\n k = vvvv.shape[0]\n temp[a:a+k] -= lib.einsum('mldf,mled,aebf->ab',t2_1_a, t2_1_a, vvvv, optimize=True)\n temp[a:a+k] += 0.5*lib.einsum('mldf,mled,aefb->ab',t2_1_a, t2_1_a, vvvv, optimize=True)\n temp[a:a+k] += 2.*lib.einsum('mlfd,mled,aebf->ab',t2_1, t2_1, vvvv, optimize=True)\n temp[a:a+k] -= lib.einsum('mlfd,mled,aefb->ab',t2_1, t2_1, vvvv, optimize=True)\n del vvvv\n a += k\n\n M_ab += temp\n\n \n return M_ab\n\n\ndef get_imds_ip(adc, eris=None):\n\n if adc.method not in (\"adc(2)\", \"adc(2)-x\", \"adc(3)\"):\n raise NotImplementedError(adc.method)\n\n method = adc.method\n\n t1 = adc.t1\n t2 = adc.t2\n\n t1_2 = t1[0]\n t2_1 = t2[0]\n\n t2_1_a = t2_1 - t2_1.transpose(1,0,2,3).copy()\n\n nocc = adc._nocc\n nvir = adc._nvir\n\n e_occ = adc.mo_energy[:nocc]\n e_vir = adc.mo_energy[nocc:]\n\n idn_occ = np.identity(nocc)\n idn_vir = np.identity(nvir)\n\n if eris is None:\n eris = adc.transform_integrals()\n\n eris_ovov = eris.ovov\n\n # i-j block\n # Zeroth-order terms\n\n M_ij = lib.einsum('ij,j->ij', idn_occ ,e_occ)\n\n # Second-order terms\n\n M_ij += lib.einsum('d,ilde,jlde->ij',e_vir,t2_1_a, t2_1_a, optimize=True)\n M_ij += lib.einsum('d,ilde,jlde->ij',e_vir,t2_1, t2_1, optimize=True)\n M_ij += lib.einsum('d,iled,jled->ij',e_vir,t2_1, t2_1, optimize=True)\n\n M_ij -= 0.5 * lib.einsum('l,ilde,jlde->ij',e_occ,t2_1_a, t2_1_a, optimize=True)\n M_ij -= 0.5*lib.einsum('l,ilde,jlde->ij',e_occ,t2_1, t2_1, optimize=True)\n M_ij -= 0.5*lib.einsum('l,ilde,jlde->ij',e_occ,t2_1, t2_1, optimize=True)\n\n M_ij -= 0.25 * lib.einsum('i,ilde,jlde->ij',e_occ,t2_1_a, t2_1_a, optimize=True)\n M_ij -= 0.25 * lib.einsum('i,ilde,jlde->ij',e_occ,t2_1, t2_1, optimize=True)\n M_ij -= 0.25 * lib.einsum('i,ilde,jlde->ij',e_occ,t2_1, t2_1, optimize=True)\n\n M_ij -= 0.25 * lib.einsum('j,ilde,jlde->ij',e_occ,t2_1_a, t2_1_a, optimize=True)\n M_ij -= 0.25 * lib.einsum('j,ilde,jlde->ij',e_occ,t2_1, t2_1, optimize=True)\n M_ij -= 0.25 * lib.einsum('j,ilde,jlde->ij',e_occ,t2_1, t2_1, optimize=True)\n\n M_ij += 0.5 * lib.einsum('ilde,jdle->ij',t2_1_a, eris_ovov,optimize=True)\n M_ij -= 0.5 * lib.einsum('ilde,jeld->ij',t2_1_a, eris_ovov,optimize=True)\n M_ij += lib.einsum('ilde,jdle->ij',t2_1, eris_ovov,optimize=True)\n\n M_ij += 0.5 * lib.einsum('jlde,idle->ij',t2_1_a, eris_ovov,optimize=True)\n M_ij -= 0.5 * lib.einsum('jlde,ldie->ij',t2_1_a, eris_ovov,optimize=True)\n M_ij += lib.einsum('jlde,idle->ij',t2_1, eris_ovov,optimize=True)\n\n # Third-order terms\n\n if (method == \"adc(3)\"):\n\n t2_2 = t2[1]\n t2_2_a = t2_2 - t2_2.transpose(1,0,2,3).copy()\n\n eris_oovv = eris.oovv\n eris_ovvo = eris.ovvo\n eris_ovoo = eris.ovoo\n eris_oooo = eris.oooo\n\n M_ij += lib.einsum('ld,ldji->ij',t1_2, eris_ovoo,optimize=True)\n M_ij -= lib.einsum('ld,jdli->ij',t1_2, eris_ovoo,optimize=True)\n M_ij += lib.einsum('ld,ldji->ij',t1_2, eris_ovoo,optimize=True)\n\n M_ij += lib.einsum('ld,ldij->ij',t1_2, eris_ovoo,optimize=True)\n M_ij -= lib.einsum('ld,idlj->ij',t1_2, eris_ovoo,optimize=True)\n M_ij += lib.einsum('ld,ldij->ij',t1_2, eris_ovoo,optimize=True)\n\n M_ij += 0.5* lib.einsum('ilde,jdle->ij',t2_2_a, eris_ovov,optimize=True)\n M_ij -= 0.5* lib.einsum('ilde,jeld->ij',t2_2_a, eris_ovov,optimize=True)\n M_ij += lib.einsum('ilde,jdle->ij',t2_2, eris_ovov,optimize=True)\n\n M_ij += 0.5* lib.einsum('jlde,leid->ij',t2_2_a, eris_ovov,optimize=True)\n M_ij -= 0.5* lib.einsum('jlde,ield->ij',t2_2_a, eris_ovov,optimize=True)\n M_ij += lib.einsum('jlde,leid->ij',t2_2, eris_ovov,optimize=True)\n\n M_ij += lib.einsum('d,ilde,jlde->ij',e_vir,t2_1_a, t2_2_a,optimize=True)\n M_ij += lib.einsum('d,ilde,jlde->ij',e_vir,t2_1, t2_2,optimize=True)\n M_ij += lib.einsum('d,iled,jled->ij',e_vir,t2_1, t2_2,optimize=True)\n\n M_ij += lib.einsum('d,jlde,ilde->ij',e_vir,t2_1_a, t2_2_a,optimize=True)\n M_ij += lib.einsum('d,jlde,ilde->ij',e_vir,t2_1, t2_2,optimize=True)\n M_ij += lib.einsum('d,jled,iled->ij',e_vir,t2_1, t2_2,optimize=True)\n\n M_ij -= 0.5 * lib.einsum('l,ilde,jlde->ij',e_occ,t2_1_a, t2_2_a,optimize=True)\n M_ij -= 0.5*lib.einsum('l,ilde,jlde->ij',e_occ,t2_1, t2_2,optimize=True)\n M_ij -= 0.5*lib.einsum('l,ilde,jlde->ij',e_occ,t2_1, t2_2,optimize=True)\n\n M_ij -= 0.5 * lib.einsum('l,jlde,ilde->ij',e_occ,t2_1_a, t2_2_a,optimize=True)\n M_ij -= 0.5*lib.einsum('l,jlde,ilde->ij',e_occ,t2_1, t2_2,optimize=True)\n M_ij -= 0.5*lib.einsum('l,jlde,ilde->ij',e_occ,t2_1, t2_2,optimize=True)\n\n M_ij -= 0.25 * lib.einsum('i,ilde,jlde->ij',e_occ,t2_1_a, t2_2_a,optimize=True)\n M_ij -= 0.25 * lib.einsum('i,ilde,jlde->ij',e_occ,t2_1, t2_2,optimize=True)\n M_ij -= 0.25 * lib.einsum('i,ilde,jlde->ij',e_occ,t2_1, t2_2,optimize=True)\n\n M_ij -= 0.25 * lib.einsum('i,jlde,ilde->ij',e_occ,t2_1_a, t2_2_a,optimize=True)\n M_ij -= 0.25 * lib.einsum('i,jlde,ilde->ij',e_occ,t2_1, t2_2,optimize=True)\n M_ij -= 0.25 * lib.einsum('i,jlde,ilde->ij',e_occ,t2_1, t2_2,optimize=True)\n\n M_ij -= 0.25 * lib.einsum('j,jlde,ilde->ij',e_occ,t2_1_a, t2_2_a,optimize=True)\n M_ij -= 0.25 * lib.einsum('j,jlde,ilde->ij',e_occ,t2_1, t2_2,optimize=True)\n M_ij -= 0.25 * lib.einsum('j,jlde,ilde->ij',e_occ,t2_1, t2_2,optimize=True)\n\n M_ij -= 0.25 * lib.einsum('j,ilde,jlde->ij',e_occ,t2_1_a, t2_2_a,optimize=True)\n M_ij -= 0.25 * lib.einsum('j,ilde,jlde->ij',e_occ,t2_1, t2_2,optimize=True)\n M_ij -= 0.25 * lib.einsum('j,ilde,jlde->ij',e_occ,t2_1, t2_2,optimize=True)\n\n M_ij -= lib.einsum('lmde,jldf,mefi->ij',t2_1_a, t2_1_a, eris_ovvo,optimize = True)\n M_ij += lib.einsum('lmde,jldf,mife->ij',t2_1_a, t2_1_a, eris_oovv,optimize = True)\n M_ij += lib.einsum('mled,jlfd,mefi->ij',t2_1, t2_1, eris_ovvo ,optimize = True)\n M_ij -= lib.einsum('mled,jlfd,mife->ij',t2_1, t2_1, eris_oovv ,optimize = True)\n M_ij -= lib.einsum('lmde,jldf,mefi->ij',t2_1, t2_1_a, eris_ovvo,optimize = True)\n M_ij -= lib.einsum('mlde,jldf,mife->ij',t2_1, t2_1, eris_oovv ,optimize = True)\n M_ij += lib.einsum('lmde,jlfd,mefi->ij',t2_1_a, t2_1, eris_ovvo ,optimize = True)\n\n M_ij -= lib.einsum('lmde,ildf,mefj->ij',t2_1_a, t2_1_a, eris_ovvo ,optimize = True)\n M_ij += lib.einsum('lmde,ildf,mjfe->ij',t2_1_a, t2_1_a, eris_oovv ,optimize = True)\n M_ij += lib.einsum('mled,ilfd,mefj->ij',t2_1, t2_1, eris_ovvo ,optimize = True)\n M_ij -= lib.einsum('mled,ilfd,mjfe->ij',t2_1, t2_1, eris_oovv ,optimize = True)\n M_ij -= lib.einsum('lmde,ildf,mefj->ij',t2_1, t2_1_a, eris_ovvo,optimize = True)\n M_ij -= lib.einsum('mlde,ildf,mjfe->ij',t2_1, t2_1, eris_oovv ,optimize = True)\n M_ij += lib.einsum('lmde,ilfd,mefj->ij',t2_1_a, t2_1, eris_ovvo ,optimize = True)\n\n M_ij += 0.25*lib.einsum('lmde,jnde,limn->ij',t2_1_a, t2_1_a,eris_oooo, optimize = True)\n M_ij -= 0.25*lib.einsum('lmde,jnde,lnmi->ij',t2_1_a, t2_1_a,eris_oooo, optimize = True)\n M_ij += lib.einsum('lmde,jnde,limn->ij',t2_1 ,t2_1, eris_oooo, optimize = True)\n\n if isinstance(eris.vvvv, np.ndarray):\n eris_vvvv = eris.vvvv\n t2_1_a_r = t2_1_a.reshape(nocc*nocc,nvir*nvir)\n t2_1_r = t2_1.reshape(nocc*nocc,nvir*nvir)\n temp_t2a_vvvv = np.dot(t2_1_a_r,eris_vvvv)\n temp_t2_vvvv = np.dot(t2_1_r,eris_vvvv)\n temp_t2a_vvvv = temp_t2a_vvvv.reshape(nocc,nocc,nvir,nvir)\n temp_t2_vvvv = temp_t2_vvvv.reshape(nocc,nocc,nvir,nvir)\n elif isinstance(eris.vvvv, list):\n temp_t2a_vvvv = contract_ladder(adc,t2_1_a,eris.vvvv)\n temp_t2_vvvv = contract_ladder(adc,t2_1,eris.vvvv)\n else :\n temp_t2a_vvvv = contract_ladder(adc,t2_1_a,eris.Lvv)\n temp_t2_vvvv = contract_ladder(adc,t2_1,eris.Lvv)\n\n M_ij += 0.25*lib.einsum('ilde,jlde->ij',t2_1_a, temp_t2a_vvvv, optimize = True)\n M_ij -= 0.25*lib.einsum('ilde,jled->ij',t2_1_a, temp_t2a_vvvv, optimize = True)\n M_ij +=lib.einsum('ilde,jlde->ij',t2_1, temp_t2_vvvv, optimize = True)\n\n M_ij += 0.25*lib.einsum('inde,lmde,jlnm->ij',t2_1_a, t2_1_a, eris_oooo, optimize = True)\n M_ij -= 0.25*lib.einsum('inde,lmde,jmnl->ij',t2_1_a, t2_1_a, eris_oooo, optimize = True)\n M_ij +=lib.einsum('inde,lmde,jlnm->ij',t2_1, t2_1, eris_oooo, optimize = True)\n\n M_ij += 0.5*lib.einsum('lmdf,lmde,jief->ij',t2_1_a, t2_1_a, eris_oovv, optimize = True)\n M_ij -= 0.5*lib.einsum('lmdf,lmde,jfei->ij',t2_1_a, t2_1_a, eris_ovvo, optimize = True)\n M_ij +=lib.einsum('mlfd,mled,jief->ij',t2_1, t2_1, eris_oovv , optimize = True)\n M_ij -=lib.einsum('mlfd,mled,jfei->ij',t2_1, t2_1, eris_ovvo , optimize = True)\n M_ij +=lib.einsum('lmdf,lmde,jief->ij',t2_1, t2_1, eris_oovv , optimize = True)\n M_ij +=0.5*lib.einsum('lmdf,lmde,jief->ij',t2_1_a, t2_1_a, eris_oovv , optimize = True)\n\n M_ij -= lib.einsum('ilde,jmdf,lmfe->ij',t2_1_a, t2_1_a, eris_oovv, optimize = True)\n M_ij += lib.einsum('ilde,jmdf,lefm->ij',t2_1_a, t2_1_a, eris_ovvo, optimize = True)\n M_ij += lib.einsum('ilde,jmdf,lefm->ij',t2_1_a, t2_1, eris_ovvo, optimize = True)\n M_ij += lib.einsum('ilde,jmdf,lefm->ij',t2_1, t2_1_a, eris_ovvo, optimize = True)\n M_ij -= lib.einsum('ilde,jmdf,lmfe->ij',t2_1, t2_1, eris_oovv, optimize = True)\n M_ij += lib.einsum('ilde,jmdf,lefm->ij',t2_1, t2_1, eris_ovvo, optimize = True)\n M_ij -= lib.einsum('iled,jmfd,lmfe->ij',t2_1, t2_1, eris_oovv, optimize = True)\n\n M_ij -= 0.5*lib.einsum('lnde,lmde,jinm->ij',t2_1_a, t2_1_a, eris_oooo, optimize = True)\n M_ij += 0.5*lib.einsum('lnde,lmde,jmni->ij',t2_1_a, t2_1_a, eris_oooo, optimize = True)\n M_ij -= lib.einsum('nled,mled,jinm->ij',t2_1, t2_1, eris_oooo, optimize = True)\n M_ij += lib.einsum('nled,mled,jmni->ij',t2_1, t2_1, eris_oooo, optimize = True)\n M_ij -= lib.einsum('lnde,lmde,jinm->ij',t2_1, t2_1, eris_oooo, optimize = True)\n M_ij -= 0.5 * lib.einsum('lnde,lmde,jinm->ij',t2_1_a, t2_1_a, eris_oooo, optimize = True)\n\n return M_ij\n\n\ndef ea_adc_diag(adc,M_ab=None,eris=None):\n\n if adc.method not in (\"adc(2)\", \"adc(2)-x\", \"adc(3)\"):\n raise NotImplementedError(adc.method)\n\n method = adc.method\n\n if M_ab is None:\n M_ab = adc.get_imds()\n\n nocc = adc._nocc\n nvir = adc._nvir\n\n n_singles = nvir\n n_doubles = nocc * nvir * nvir\n\n dim = n_singles + n_doubles\n\n e_occ = adc.mo_energy[:nocc]\n e_vir = adc.mo_energy[nocc:]\n\n idn_occ = np.identity(nocc)\n idn_vir = np.identity(nvir)\n\n s1 = 0\n f1 = n_singles\n s2 = f1\n f2 = s2 + n_doubles\n\n d_ab = e_vir[:,None] + e_vir\n d_i = e_occ[:,None]\n D_n = -d_i + d_ab.reshape(-1)\n D_iab = D_n.reshape(-1)\n\n diag = np.zeros(dim)\n\n # Compute precond in p1-p1 block\n\n M_ab_diag = np.diagonal(M_ab)\n\n diag[s1:f1] = M_ab_diag.copy()\n\n # Compute precond in 2p1h-2p1h block\n\n diag[s2:f2] = D_iab\n\n ###### Additional terms for the preconditioner ####\n\n if (method == \"adc(2)-x\" or method == \"adc(3)\"):\n\n if eris is None:\n eris = adc.transform_integrals()\n\n if isinstance(eris.vvvv, np.ndarray):\n\n eris_oovv = eris.oovv\n eris_ovvo = eris.ovvo\n eris_vvvv = eris.vvvv\n\n temp = np.zeros((nocc, eris_vvvv.shape[0]))\n temp[:] += np.diag(eris_vvvv)\n diag[s2:f2] += temp.reshape(-1)\n\n eris_ovov_p = np.ascontiguousarray(eris_oovv[:].transpose(0,2,1,3))\n eris_ovov_p = eris_ovov_p.reshape(nocc*nvir, nocc*nvir)\n\n temp = np.zeros((nvir, nocc, nvir))\n temp[:] += np.diagonal(eris_ovov_p).reshape(nocc, nvir)\n temp = np.ascontiguousarray(temp.transpose(1,0,2))\n diag[s2:f2] += -temp.reshape(-1)\n\n eris_ovov_p = np.ascontiguousarray(eris_oovv[:].transpose(0,2,1,3))\n eris_ovov_p = eris_ovov_p.reshape(nocc*nvir, nocc*nvir)\n\n temp = np.zeros((nvir, nocc, nvir))\n temp[:] += np.diagonal(eris_ovov_p).reshape(nocc, nvir)\n temp = np.ascontiguousarray(temp.transpose(1,2,0))\n diag[s2:f2] += -temp.reshape(-1)\n\n return diag\n\n\ndef ip_adc_diag(adc,M_ij=None,eris=None):\n \n if adc.method not in (\"adc(2)\", \"adc(2)-x\", \"adc(3)\"):\n raise NotImplementedError(adc.method)\n\n method = adc.method\n\n if M_ij is None:\n M_ij = adc.get_imds()\n\n nocc = adc._nocc\n nvir = adc._nvir\n\n n_singles = nocc\n n_doubles = nvir * nocc * nocc\n\n dim = n_singles + n_doubles\n\n e_occ = adc.mo_energy[:nocc]\n e_vir = adc.mo_energy[nocc:]\n\n idn_occ = np.identity(nocc)\n idn_vir = np.identity(nvir)\n\n s1 = 0\n f1 = n_singles\n s2 = f1\n f2 = s2 + n_doubles\n\n d_ij = e_occ[:,None] + e_occ\n d_a = e_vir[:,None]\n D_n = -d_a + d_ij.reshape(-1)\n D_aij = D_n.reshape(-1)\n\n diag = np.zeros(dim)\n\n # Compute precond in h1-h1 block\n M_ij_diag = np.diagonal(M_ij)\n\n diag[s1:f1] = M_ij_diag.copy()\n\n # Compute precond in 2p1h-2p1h block\n\n diag[s2:f2] = D_aij.copy()\n\n ###### Additional terms for the preconditioner ####\n if (method == \"adc(2)-x\" or method == \"adc(3)\"):\n\n if eris is None:\n eris = adc.transform_integrals()\n\n if isinstance(eris.vvvv, np.ndarray):\n\n eris_oooo = eris.oooo\n eris_oovv = eris.oovv\n eris_ovvo = eris.ovvo\n\n eris_oooo_p = np.ascontiguousarray(eris_oooo.transpose(0,2,1,3))\n eris_oooo_p = eris_oooo_p.reshape(nocc*nocc, nocc*nocc)\n \n temp = np.zeros((nvir, eris_oooo_p.shape[0]))\n temp[:] += np.diag(eris_oooo_p)\n diag[s2:f2] += -temp.reshape(-1)\n\n eris_ovov_p = np.ascontiguousarray(eris_oovv.transpose(0,2,1,3)) \n eris_ovov_p = eris_ovov_p.reshape(nocc*nvir, nocc*nvir)\n\n temp = np.zeros((nocc, nocc, nvir))\n temp[:] += np.diagonal(eris_ovov_p).reshape(nocc, nvir)\n temp = np.ascontiguousarray(temp.transpose(2,1,0))\n diag[s2:f2] += temp.reshape(-1)\n\n eris_ovov_p = np.ascontiguousarray(eris_oovv.transpose(0,2,1,3)) \n eris_ovov_p = eris_ovov_p.reshape(nocc*nvir, nocc*nvir)\n\n temp = np.zeros((nocc, nocc, nvir))\n temp[:] += np.diagonal(eris_ovov_p).reshape(nocc, nvir)\n temp = np.ascontiguousarray(temp.transpose(2,0,1))\n diag[s2:f2] += temp.reshape(-1)\n\n diag = -diag\n\n return diag\n\ndef ea_contract_r_vvvv(myadc,r2,vvvv):\n\n nocc = myadc._nocc\n nvir = myadc._nvir\n\n r2_vvvv = np.zeros((nocc,nvir,nvir))\n r2 = np.ascontiguousarray(r2.reshape(nocc,-1))\n chnk_size = radc_ao2mo.calculate_chunk_size(myadc)\n\n a = 0\n if isinstance(vvvv, list):\n for dataset in vvvv:\n k = dataset.shape[0]\n dataset = dataset[:].reshape(-1,nvir*nvir)\n r2_vvvv[:,a:a+k] = np.dot(r2,dataset.T).reshape(nocc,-1,nvir)\n del (dataset)\n a += k\n elif getattr(myadc, 'with_df', None):\n for p in range(0,nvir,chnk_size):\n vvvv_p = dfadc.get_vvvv_df(myadc, vvvv, p, chnk_size)\n k = vvvv_p.shape[0]\n vvvv_p = vvvv_p.reshape(-1,nvir*nvir)\n r2_vvvv[:,a:a+k] = np.dot(r2,vvvv_p.T).reshape(nocc,-1,nvir)\n del (vvvv_p)\n a += k\n else :\n raise Exception(\"Unknown vvvv type\") \n\n r2_vvvv = r2_vvvv.reshape(-1)\n\n return r2_vvvv\n\n\ndef ea_adc_matvec(adc, M_ab=None, eris=None):\n\n if adc.method not in (\"adc(2)\", \"adc(2)-x\", \"adc(3)\"):\n raise NotImplementedError(adc.method)\n\n method = adc.method\n\n t2_1 = adc.t2[0]\n t1_2 = adc.t1[0]\n\n nocc = adc._nocc\n nvir = adc._nvir\n\n ab_ind = np.tril_indices(nvir, k=-1)\n\n n_singles = nvir\n n_doubles = nocc * nvir * nvir\n\n dim = n_singles + n_doubles\n\n e_occ = adc.mo_energy[:nocc]\n e_vir = adc.mo_energy[nocc:]\n\n idn_occ = np.identity(nocc)\n idn_vir = np.identity(nvir)\n\n if eris is None:\n eris = adc.transform_integrals()\n\n s1 = 0\n f1 = n_singles\n s2 = f1\n f2 = s2 + n_doubles\n\n d_ab = e_vir[:,None] + e_vir\n d_i = e_occ[:,None]\n D_n = -d_i + d_ab.reshape(-1)\n D_iab = D_n.reshape(-1)\n\n if M_ab is None:\n M_ab = adc.get_imds()\n \n #Calculate sigma vector\n def sigma_(r):\n\n s = np.zeros((dim))\n\n r1 = r[s1:f1]\n r2 = r[s2:f2]\n\n r2 = r2.reshape(nocc,nvir,nvir)\n\n############ ADC(2) ab block ############################\n\n s[s1:f1] = lib.einsum('ab,b->a',M_ab,r1)\n\n############# ADC(2) a - ibc and ibc - a coupling blocks #########################\n\n eris_ovvv = radc_ao2mo.unpack_eri_1(eris.ovvv, nvir)\n\n s[s1:f1] += 2. * lib.einsum('icab,ibc->a', eris_ovvv, r2, optimize = True)\n s[s1:f1] -= lib.einsum('ibac,ibc->a', eris_ovvv, r2, optimize = True)\n\n temp = lib.einsum('icab,a->ibc', eris_ovvv, r1, optimize = True)\n s[s2:f2] += temp.reshape(-1)\n del eris_ovvv\n\n################ ADC(2) iab - jcd block ############################\n\n s[s2:f2] += D_iab * r2.reshape(-1)\n\n############### ADC(3) iab - jcd block ############################\n\n if (method == \"adc(2)-x\" or method == \"adc(3)\"):\n\n r2_a = r2 - r2.transpose(0,2,1).copy()\n t2_2 = adc.t2[1]\n\n eris_oovv = eris.oovv\n eris_ovvo = eris.ovvo\n\n r2 = r2.reshape(nocc, nvir, nvir)\n\n if isinstance(eris.vvvv, np.ndarray):\n r_bab_t = r2.reshape(nocc,-1)\n eris_vvvv = eris.vvvv\n s[s2:f2] += np.dot(r_bab_t,eris_vvvv.T).reshape(-1)\n elif isinstance(eris.vvvv, list):\n s[s2:f2] += ea_contract_r_vvvv(adc,r2,eris.vvvv)\n else :\n s[s2:f2] += ea_contract_r_vvvv(adc,r2,eris.Lvv)\n\n s[s2:f2] -= 0.5*lib.einsum('jzyi,jzx->ixy',eris_ovvo,r2_a,optimize = True).reshape(-1)\n s[s2:f2] -= 0.5*lib.einsum('jiyz,jxz->ixy',eris_oovv,r2,optimize = True).reshape(-1)\n s[s2:f2] += 0.5*lib.einsum('jzyi,jxz->ixy',eris_ovvo,r2,optimize = True).reshape(-1)\n s[s2:f2] -= 0.5*lib.einsum('jixz,jzy->ixy',eris_oovv,r2,optimize = True).reshape(-1)\n s[s2:f2] -= 0.5*lib.einsum('jixw,jwy->ixy',eris_oovv,r2,optimize = True).reshape(-1)\n s[s2:f2] -= 0.5*lib.einsum('jiyw,jxw->ixy',eris_oovv,r2,optimize = True).reshape(-1)\n s[s2:f2] += 0.5*lib.einsum('jwyi,jxw->ixy',eris_ovvo,r2,optimize = True).reshape(-1)\n s[s2:f2] += 0.5*lib.einsum('jwyi,jxw->ixy',eris_ovvo,r2_a,optimize = True).reshape(-1)\n\n #print(\"Calculating additional terms for adc(3)\")\n if (method == \"adc(3)\"):\n\n eris_ovoo = eris.ovoo\n\n############### ADC(3) a - ibc block and ibc-a coupling blocks ########################\n\n t2_1_a = t2_1 - t2_1.transpose(1,0,2,3).copy()\n t2_1_a_t = t2_1_a.reshape(nocc,nocc,-1)\n r2_a = r2_a.reshape(nocc,-1)\n temp = 0.25 * lib.einsum('lmp,jp->lmj',t2_1_a_t,r2_a)\n s[s1:f1] += lib.einsum('lmj,lamj->a',temp, eris_ovoo, optimize=True)\n s[s1:f1] -= lib.einsum('lmj,malj->a',temp, eris_ovoo, optimize=True)\n\n temp_1 = -lib.einsum('lmzw,jzw->jlm',t2_1,r2)\n s[s1:f1] -= lib.einsum('jlm,lamj->a',temp_1, eris_ovoo, optimize=True)\n\n r2_a = r2_a.reshape(nocc,nvir,nvir)\n temp_s_a = np.zeros_like(r2)\n temp_s_a = lib.einsum('jlwd,jzw->lzd',t2_1_a,r2_a,optimize=True)\n temp_s_a += lib.einsum('ljdw,jzw->lzd',t2_1,r2,optimize=True)\n\n temp_s_a_1 = np.zeros_like(r2)\n temp_s_a_1 = -lib.einsum('jlzd,jwz->lwd',t2_1_a,r2_a,optimize=True)\n temp_s_a_1 += -lib.einsum('ljdz,jwz->lwd',t2_1,r2,optimize=True)\n\n eris_ovvv = radc_ao2mo.unpack_eri_1(eris.ovvv, nvir)\n\n temp_1_1 = lib.einsum('ldxb,b->lxd', eris_ovvv,r1,optimize=True)\n temp_1_1 -= lib.einsum('lbxd,b->lxd', eris_ovvv,r1,optimize=True)\n temp_2_1 = lib.einsum('ldxb,b->lxd', eris_ovvv,r1,optimize=True)\n\n s[s1:f1] += 0.5*lib.einsum('lzd,ldza->a',temp_s_a,eris_ovvv,optimize=True)\n s[s1:f1] -= 0.5*lib.einsum('lzd,lazd->a',temp_s_a,eris_ovvv,optimize=True)\n s[s1:f1] -= 0.5*lib.einsum('lwd,ldwa->a',temp_s_a_1,eris_ovvv,optimize=True)\n s[s1:f1] += 0.5*lib.einsum('lwd,lawd->a',temp_s_a_1,eris_ovvv,optimize=True)\n\n temp_1 = np.zeros_like(r2)\n temp_1 = lib.einsum('jlwd,jzw->lzd',t2_1,r2_a,optimize=True)\n temp_1 += lib.einsum('jlwd,jzw->lzd',t2_1_a,r2,optimize=True)\n s[s1:f1] += 0.5*lib.einsum('lzd,ldza->a',temp_1,eris_ovvv,optimize=True)\n\n temp_1 = np.zeros_like(r2)\n temp_1 = -lib.einsum('jlzd,jwz->lwd',t2_1,r2_a,optimize=True)\n temp_1 += -lib.einsum('jlzd,jwz->lwd',t2_1_a,r2,optimize=True)\n s[s1:f1] -= 0.5*lib.einsum('lwd,ldwa->a',temp_1,eris_ovvv,optimize=True)\n\n temp_2 = -lib.einsum('ljzd,jzw->lwd',t2_1,r2,optimize=True)\n s[s1:f1] += 0.5*lib.einsum('lwd,lawd->a',temp_2,eris_ovvv,optimize=True)\n\n temp_a = t2_1.transpose(0,3,1,2).copy()\n temp_b = temp_a.reshape(nocc*nvir,nocc*nvir)\n r2_t = r2.reshape(nocc*nvir,-1)\n temp_c = np.dot(temp_b,r2_t).reshape(nocc,nvir,nvir)\n temp_2 = temp_c.transpose(0,2,1).copy()\n s[s1:f1] -= 0.5*lib.einsum('lzd,lazd->a',temp_2,eris_ovvv,optimize=True)\n\n temp = -lib.einsum('lbyd,b->lyd',eris_ovvv,r1,optimize=True)\n temp_1= -lib.einsum('lyd,lixd->ixy',temp,t2_1,optimize=True)\n s[s2:f2] -= temp_1.reshape(-1)\n del eris_ovvv\n\n temp_1 = lib.einsum('b,lbmi->lmi',r1,eris_ovoo)\n s[s2:f2] += lib.einsum('lmi,lmxy->ixy',temp_1, t2_1, optimize=True).reshape(-1)\n\n temp = lib.einsum('lxd,lidy->ixy',temp_1_1,t2_1,optimize=True)\n temp += lib.einsum('lxd,ilyd->ixy',temp_2_1,t2_1_a,optimize=True)\n s[s2:f2] += temp.reshape(-1)\n\n return s\n\n return sigma_\n\n\ndef ip_adc_matvec(adc, M_ij=None, eris=None):\n\n if adc.method not in (\"adc(2)\", \"adc(2)-x\", \"adc(3)\"):\n raise NotImplementedError(adc.method)\n\n method = adc.method\n\n t2_1 = adc.t2[0]\n t1_2 = adc.t1[0]\n\n nocc = adc._nocc\n nvir = adc._nvir\n\n ij_ind = np.tril_indices(nocc, k=-1)\n\n n_singles = nocc\n n_doubles = nvir * nocc * nocc\n\n dim = n_singles + n_doubles\n\n e_occ = adc.mo_energy[:nocc]\n e_vir = adc.mo_energy[nocc:]\n\n idn_occ = np.identity(nocc)\n idn_vir = np.identity(nvir)\n\n if eris is None:\n eris = adc.transform_integrals()\n\n s1 = 0\n f1 = n_singles\n s2 = f1\n f2 = s2 + n_doubles\n\n d_ij = e_occ[:,None] + e_occ\n d_a = e_vir[:,None]\n D_n = -d_a + d_ij.reshape(-1)\n D_aij = D_n.reshape(-1)\n\n if M_ij is None:\n M_ij = adc.get_imds()\n\n #Calculate sigma vector\n def sigma_(r):\n\n s = np.zeros((dim))\n\n r1 = r[s1:f1]\n r2 = r[s2:f2]\n\n r2 = r2.reshape(nvir,nocc,nocc)\n\n eris_ovoo = eris.ovoo\n\n############ ADC(2) ij block ############################\n\n s[s1:f1] = lib.einsum('ij,j->i',M_ij,r1)\n\n############ ADC(2) i - kja block #########################\n\n s[s1:f1] += 2. * lib.einsum('jaki,ajk->i', eris_ovoo, r2, optimize = True)\n s[s1:f1] -= lib.einsum('kaji,ajk->i', eris_ovoo, r2, optimize = True)\n\n############## ADC(2) ajk - i block ############################\n\n temp = lib.einsum('jaki,i->ajk', eris_ovoo, r1, optimize = True).reshape(-1)\n s[s2:f2] += temp.reshape(-1)\n\n################ ADC(2) ajk - bil block ############################\n\n s[s2:f2] += D_aij * r2.reshape(-1)\n\n############### ADC(3) ajk - bil block ############################\n\n if (method == \"adc(2)-x\" or method == \"adc(3)\"):\n \n r2_a = r2 - r2.transpose(0,2,1).copy()\n t2_2 = adc.t2[1]\n\n eris_oooo = eris.oooo\n eris_oovv = eris.oovv\n eris_ovvo = eris.ovvo\n \n s[s2:f2] -= 0.5*lib.einsum('kijl,ali->ajk',eris_oooo, r2, optimize = True).reshape(-1)\n s[s2:f2] -= 0.5*lib.einsum('klji,ail->ajk',eris_oooo ,r2, optimize = True).reshape(-1)\n \n s[s2:f2] += 0.5*lib.einsum('klba,bjl->ajk',eris_oovv,r2,optimize = True).reshape(-1)\n \n s[s2:f2] += 0.5*lib.einsum('jabl,bkl->ajk',eris_ovvo,r2_a,optimize = True).reshape(-1)\n s[s2:f2] += 0.5*lib.einsum('jlba,blk->ajk',eris_oovv,r2,optimize = True).reshape(-1)\n s[s2:f2] -= 0.5*lib.einsum('jabl,blk->ajk',eris_ovvo,r2,optimize = True).reshape(-1)\n \n s[s2:f2] += 0.5*lib.einsum('kiba,bji->ajk',eris_oovv,r2,optimize = True).reshape(-1)\n \n s[s2:f2] += 0.5*lib.einsum('jiba,bik->ajk',eris_oovv,r2,optimize = True).reshape(-1)\n s[s2:f2] -= 0.5*lib.einsum('jabi,bik->ajk',eris_ovvo,r2,optimize = True).reshape(-1)\n s[s2:f2] -= 0.5*lib.einsum('jabi,bik->ajk',eris_ovvo,r2_a,optimize = True).reshape(-1)\n \n if (method == \"adc(3)\"):\n\n eris_ovoo = eris.ovoo\n\n################ ADC(3) i - kja block and ajk - i ############################\n\n eris_ovvv = radc_ao2mo.unpack_eri_1(eris.ovvv, nvir)\n t2_1_a = t2_1 - t2_1.transpose(1,0,2,3).copy()\n r2_a = r2_a.reshape(nvir,-1)\n t2_1_a_t = t2_1_a.reshape(-1,nvir,nvir)\n temp = 0.25 * lib.einsum('pbc,ap->abc',t2_1_a_t,r2_a, optimize=True)\n s[s1:f1] += lib.einsum('abc,icab->i',temp, eris_ovvv, optimize=True)\n s[s1:f1] -= lib.einsum('abc,ibac->i',temp, eris_ovvv, optimize=True)\n temp_1 = lib.einsum('kjcb,ajk->abc',t2_1,r2, optimize=True)\n s[s1:f1] += lib.einsum('abc,icab->i',temp_1, eris_ovvv, optimize=True)\n\n temp_1 = lib.einsum('i,icab->cba',r1,eris_ovvv,optimize=True)\n s[s2:f2] += lib.einsum('cba,kjcb->ajk',temp_1, t2_1, optimize=True).reshape(-1)\n del eris_ovvv\n\n r2_a = r2_a.reshape(nvir,nocc,nocc)\n\n temp = np.zeros_like(r2)\n temp = lib.einsum('jlab,ajk->blk',t2_1_a,r2_a,optimize=True)\n temp += lib.einsum('ljba,ajk->blk',t2_1,r2,optimize=True)\n\n temp_1 = np.zeros_like(r2)\n temp_1 = lib.einsum('jlab,ajk->blk',t2_1,r2_a,optimize=True)\n temp_1 += lib.einsum('jlab,ajk->blk',t2_1_a,r2,optimize=True)\n\n temp_2 = lib.einsum('jlba,akj->blk',t2_1,r2, optimize=True)\n\n s[s1:f1] += 0.5*lib.einsum('blk,lbik->i',temp,eris_ovoo,optimize=True)\n s[s1:f1] -= 0.5*lib.einsum('blk,iblk->i',temp,eris_ovoo,optimize=True)\n s[s1:f1] += 0.5*lib.einsum('blk,lbik->i',temp_1,eris_ovoo,optimize=True)\n s[s1:f1] -= 0.5*lib.einsum('blk,iblk->i',temp_2,eris_ovoo,optimize=True)\n\n temp = np.zeros_like(r2)\n temp = -lib.einsum('klab,akj->blj',t2_1_a,r2_a,optimize=True)\n temp -= lib.einsum('lkba,akj->blj',t2_1,r2,optimize=True)\n\n temp_1 = np.zeros_like(r2)\n temp_1 = -lib.einsum('klab,akj->blj',t2_1,r2_a,optimize=True)\n temp_1 -= lib.einsum('klab,akj->blj',t2_1_a,r2,optimize=True)\n\n temp_2 = -lib.einsum('klba,ajk->blj',t2_1,r2,optimize=True)\n\n s[s1:f1] -= 0.5*lib.einsum('blj,lbij->i',temp,eris_ovoo,optimize=True)\n s[s1:f1] += 0.5*lib.einsum('blj,iblj->i',temp,eris_ovoo,optimize=True)\n s[s1:f1] -= 0.5*lib.einsum('blj,lbij->i',temp_1,eris_ovoo,optimize=True)\n s[s1:f1] += 0.5*lib.einsum('blj,iblj->i',temp_2,eris_ovoo,optimize=True)\n\n temp_1 = lib.einsum('i,lbik->kbl',r1,eris_ovoo)\n temp_1 -= lib.einsum('i,iblk->kbl',r1,eris_ovoo)\n temp_2 = lib.einsum('i,lbik->kbl',r1,eris_ovoo)\n\n temp = lib.einsum('kbl,ljba->ajk',temp_1,t2_1,optimize=True)\n temp += lib.einsum('kbl,jlab->ajk',temp_2,t2_1_a,optimize=True)\n s[s2:f2] += temp.reshape(-1)\n\n temp = -lib.einsum('i,iblj->jbl',r1,eris_ovoo,optimize=True)\n temp_1 = -lib.einsum('jbl,klba->ajk',temp,t2_1,optimize=True)\n s[s2:f2] -= temp_1.reshape(-1)\n\n s *= -1.0\n\n return s\n\n return sigma_\n\n\ndef ea_compute_trans_moments(adc, orb):\n\n if adc.method not in (\"adc(2)\", \"adc(2)-x\", \"adc(3)\"):\n raise NotImplementedError(adc.method)\n\n method = adc.method\n\n t2_1 = adc.t2[0]\n t1_2 = adc.t1[0]\n t2_1_a = t2_1 - t2_1.transpose(1,0,2,3).copy()\n\n nocc = adc._nocc\n nvir = adc._nvir\n\n n_singles = nvir\n n_doubles = nocc * nvir * nvir\n\n dim = n_singles + n_doubles\n\n e_occ = adc.mo_energy[:nocc]\n e_vir = adc.mo_energy[nocc:]\n\n idn_occ = np.identity(nocc)\n idn_vir = np.identity(nvir)\n\n s1 = 0\n f1 = n_singles\n s2 = f1\n f2 = s2 + n_doubles\n\n T = np.zeros((dim))\n\n######## ADC(2) part ############################################\n\n if orb < nocc:\n\n T[s1:f1] = -t1_2[orb,:]\n\n t2_1_t = -t2_1.transpose(1,0,2,3).copy()\n\n T[s2:f2] += t2_1_t[:,orb,:,:].reshape(-1)\n\n else :\n\n T[s1:f1] += idn_vir[(orb-nocc), :]\n T[s1:f1] -= 0.25*lib.einsum('klc,klac->a',t2_1_a[:,:,(orb-nocc),:], t2_1_a, optimize = True)\n T[s1:f1] -= 0.25*lib.einsum('klc,klac->a',t2_1[:,:,(orb-nocc),:], t2_1, optimize = True)\n T[s1:f1] -= 0.25*lib.einsum('lkc,lkac->a',t2_1[:,:,(orb-nocc),:], t2_1, optimize = True)\n\n######## ADC(3) 2p-1h part ############################################\n\n if(method==\"adc(2)-x\"or adc.method==\"adc(3)\"):\n\n t2_2 = adc.t2[1]\n t2_2_a = t2_2 - t2_2.transpose(1,0,2,3).copy()\n\n if orb < nocc:\n\n t2_2_t = -t2_2.transpose(1,0,2,3).copy()\n\n T[s2:f2] += t2_2_t[:,orb,:,:].reshape(-1)\n\n########## ADC(3) 1p part ############################################\n\n if(adc.method==\"adc(3)\"):\n\n t1_3 = adc.t1[1]\n\n if orb < nocc:\n\n T[s1:f1] += 0.5*lib.einsum('kac,ck->a',t2_1_a[:,orb,:,:], t1_2.T,optimize = True)\n T[s1:f1] -= 0.5*lib.einsum('kac,ck->a',t2_1[orb,:,:,:], t1_2.T,optimize = True)\n\n T[s1:f1] -= t1_3[orb,:]\n\n else:\n\n T[s1:f1] -= 0.25*lib.einsum('klc,klac->a',t2_1_a[:,:,(orb-nocc),:], t2_2_a, optimize = True)\n T[s1:f1] -= 0.25*lib.einsum('klc,klac->a',t2_1[:,:,(orb-nocc),:], t2_2, optimize = True)\n T[s1:f1] -= 0.25*lib.einsum('lkc,lkac->a',t2_1[:,:,(orb-nocc),:], t2_2, optimize = True)\n\n T[s1:f1] -= 0.25*lib.einsum('klac,klc->a',t2_1_a, t2_2_a[:,:,(orb-nocc),:],optimize = True)\n T[s1:f1] -= 0.25*lib.einsum('klac,klc->a',t2_1, t2_2[:,:,(orb-nocc),:],optimize = True)\n T[s1:f1] -= 0.25*lib.einsum('lkac,lkc->a',t2_1, t2_2[:,:,(orb-nocc),:],optimize = True)\n\n T_aaa = T[n_singles:].reshape(nocc,nvir,nvir).copy()\n T_aaa = T_aaa - T_aaa.transpose(0,2,1)\n T[n_singles:] += T_aaa.reshape(-1)\n\n return T\n\n\ndef ip_compute_trans_moments(adc, orb):\n\n if adc.method not in (\"adc(2)\", \"adc(2)-x\", \"adc(3)\"):\n raise NotImplementedError(adc.method)\n\n method = adc.method\n\n t2_1 = adc.t2[0]\n t1_2 = adc.t1[0]\n t2_1_a = t2_1 - t2_1.transpose(1,0,2,3).copy()\n\n nocc = adc._nocc\n nvir = adc._nvir\n\n n_singles = nocc\n n_doubles = nvir * nocc * nocc\n\n dim = n_singles + n_doubles\n\n e_occ = adc.mo_energy[:nocc]\n e_vir = adc.mo_energy[nocc:]\n\n idn_occ = np.identity(nocc)\n idn_vir = np.identity(nvir)\n\n s1 = 0\n f1 = n_singles\n s2 = f1\n f2 = s2 + n_doubles\n\n T = np.zeros((dim))\n\n######## ADC(2) 1h part ############################################\n\n if orb < nocc:\n T[s1:f1] = idn_occ[orb, :]\n T[s1:f1] += 0.25*lib.einsum('kdc,ikdc->i',t2_1_a[:,orb,:,:], t2_1_a, optimize = True)\n T[s1:f1] -= 0.25*lib.einsum('kdc,ikdc->i',t2_1[orb,:,:,:], t2_1, optimize = True)\n T[s1:f1] -= 0.25*lib.einsum('kcd,ikcd->i',t2_1[orb,:,:,:], t2_1, optimize = True)\n else :\n T[s1:f1] += t1_2[:,(orb-nocc)]\n\n######## ADC(2) 2h-1p part ############################################\n\n t2_1_t = t2_1.transpose(2,3,1,0).copy()\n\n T[s2:f2] = t2_1_t[(orb-nocc),:,:,:].reshape(-1)\n\n######## ADC(3) 2h-1p part ############################################\n\n if(method=='adc(2)-x'or method=='adc(3)'):\n\n t2_2 = adc.t2[1]\n t2_2_a = t2_2 - t2_2.transpose(1,0,2,3).copy()\n\n if orb >= nocc:\n t2_2_t = t2_2.transpose(2,3,1,0).copy()\n\n T[s2:f2] += t2_2_t[(orb-nocc),:,:,:].reshape(-1)\n\n######## ADC(3) 1h part ############################################\n\n if(method=='adc(3)'):\n\n t1_3 = adc.t1[1]\n\n if orb < nocc:\n T[s1:f1] += 0.25*lib.einsum('kdc,ikdc->i',t2_1_a[:,orb,:,:], t2_2_a, optimize = True)\n T[s1:f1] -= 0.25*lib.einsum('kdc,ikdc->i',t2_1[orb,:,:,:], t2_2, optimize = True)\n T[s1:f1] -= 0.25*lib.einsum('kcd,ikcd->i',t2_1[orb,:,:,:], t2_2, optimize = True)\n\n T[s1:f1] += 0.25*lib.einsum('ikdc,kdc->i',t2_1_a, t2_2_a[:,orb,:,:],optimize = True)\n T[s1:f1] -= 0.25*lib.einsum('ikcd,kcd->i',t2_1, t2_2[orb,:,:,:],optimize = True)\n T[s1:f1] -= 0.25*lib.einsum('ikdc,kdc->i',t2_1, t2_2[orb,:,:,:],optimize = True)\n else:\n T[s1:f1] += 0.5*lib.einsum('ikc,kc->i',t2_1_a[:,:,(orb-nocc),:], t1_2,optimize = True)\n T[s1:f1] += 0.5*lib.einsum('ikc,kc->i',t2_1[:,:,(orb-nocc),:], t1_2,optimize = True)\n T[s1:f1] += t1_3[:,(orb-nocc)]\n\n T_aaa = T[n_singles:].reshape(nvir,nocc,nocc).copy()\n T_aaa = T_aaa - T_aaa.transpose(0,2,1)\n T[n_singles:] += T_aaa.reshape(-1)\n\n return T\n\n\ndef get_trans_moments(adc):\n\n nmo = adc.nmo\n\n T = []\n\n for orb in range(nmo):\n\n T_a = adc.compute_trans_moments(orb)\n T.append(T_a)\n\n T = np.array(T)\n return T\n\n\ndef get_spec_factors_ea(adc, T, U, nroots=1):\n\n nocc = adc._nocc\n nvir = adc._nvir\n\n n_singles = nvir\n n_doubles = nocc * nvir * nvir\n\n U = U.reshape(nroots,-1)\n\n for I in range(U.shape[0]):\n U1 = U[I, :n_singles]\n U2 = U[I, n_singles:].reshape(nocc,nvir,nvir)\n UdotU = np.dot(U1, U1) + 2.*np.dot(U2.ravel(), U2.ravel()) - np.dot(U2.ravel(), U2.transpose(0,2,1).ravel())\n U[I,:] /= np.sqrt(UdotU)\n\n X = np.dot(T, U.T).reshape(-1, nroots)\n\n P = 2.0*lib.einsum(\"pi,pi->i\", X, X)\n\n return P\n\ndef get_spec_factors_ip(adc, T, U, nroots=1):\n\n nocc = adc._nocc\n nvir = adc._nvir\n\n n_singles = nocc\n n_doubles = nvir * nocc * nocc\n\n U = U.reshape(nroots,-1)\n\n for I in range(U.shape[0]):\n U1 = U[I, :n_singles]\n U2 = U[I, n_singles:].reshape(nvir,nocc,nocc)\n UdotU = np.dot(U1, U1) + 2.*np.dot(U2.ravel(), U2.ravel()) - np.dot(U2.ravel(), U2.transpose(0,2,1).ravel())\n U[I,:] /= np.sqrt(UdotU)\n\n X = np.dot(T, U.T).reshape(-1, nroots)\n\n P = 2.0*lib.einsum(\"pi,pi->i\", X, X)\n\n return P\n\n\nclass RADCEA(RADC):\n '''restricted ADC for EA energies and spectroscopic amplitudes\n\n Attributes:\n verbose : int\n Print level. Default value equals to :class:`Mole.verbose`\n max_memory : float or int\n Allowed memory in MB. Default value equals to :class:`Mole.max_memory`\n incore_complete : bool\n Avoid all I/O. Default is False.\n method : string\n nth-order ADC method. Options are : ADC(2), ADC(2)-X, ADC(3). Default is ADC(2).\n conv_tol : float\n Convergence threshold for Davidson iterations. Default is 1e-12.\n max_cycle : int\n Number of Davidson iterations. Default is 50.\n max_space : int\n Space size to hold trial vectors for Davidson iterative diagonalization. Default is 12.\n\n Kwargs:\n\tnroots : int\n\t Number of roots (eigenvalues) requested. Default value is 1.\n\n >>> myadc = adc.RADC(mf).run()\n >>> myadcea = adc.RADC(myadc).run()\n\n Saved results\n\n e_ea : float or list of floats\n EA energy (eigenvalue). For nroots = 1, it is a single float number. If nroots > 1, it is a list of floats for the lowest nroots eigenvalues.\n v_ip : array\n Eigenvectors for each EA transition.\n p_ea : float\n Spectroscopic amplitudes for each EA transition.\n '''\n def __init__(self, adc):\n self.mol = adc.mol\n self.verbose = adc.verbose\n self.stdout = adc.stdout\n self.max_memory = adc.max_memory\n self.max_space = adc.max_space\n self.max_cycle = adc.max_cycle\n self.conv_tol = adc.conv_tol\n self.t1 = adc.t1\n self.t2 = adc.t2\n self.e_corr = adc.e_corr\n self.method = adc.method\n self.method_type = adc.method_type\n self._scf = adc._scf\n self._nocc = adc._nocc\n self._nvir = adc._nvir\n self._nmo = adc._nmo\n self.mo_coeff = adc.mo_coeff\n self.mo_energy = adc.mo_energy\n self.nmo = adc._nmo\n self.transform_integrals = adc.transform_integrals\n self.with_df = adc.with_df\n\n keys = set(('conv_tol', 'e_corr', 'method', 'mo_coeff', 'mo_energy', 'max_memory', 't1', 'max_space', 't2', 'max_cycle'))\n\n self._keys = set(self.__dict__.keys()).union(keys)\n \n kernel = kernel\n get_imds = get_imds_ea\n matvec = ea_adc_matvec\n get_diag = ea_adc_diag\n compute_trans_moments = ea_compute_trans_moments\n get_trans_moments = get_trans_moments\n get_spec_factors = get_spec_factors_ea\n \n def get_init_guess(self, nroots=1, diag=None, ascending = True):\n if diag is None :\n diag = self.ea_adc_diag()\n idx = None\n if ascending:\n idx = np.argsort(diag)\n else:\n idx = np.argsort(diag)[::-1]\n guess = np.zeros((diag.shape[0], nroots))\n min_shape = min(diag.shape[0], nroots)\n guess[:min_shape,:min_shape] = np.identity(min_shape)\n g = np.zeros((diag.shape[0], nroots))\n g[idx] = guess.copy()\n guess = []\n for p in range(g.shape[1]):\n guess.append(g[:,p])\n return guess\n \n\n def gen_matvec(self, imds=None, eris=None):\n if imds is None: imds = self.get_imds(eris)\n diag = self.get_diag(imds, eris)\n matvec = self.matvec(imds, eris)\n return matvec, diag\n\n\nclass RADCIP(RADC):\n '''restricted ADC for IP energies and spectroscopic amplitudes\n\n Attributes:\n verbose : int\n Print level. Default value equals to :class:`Mole.verbose`\n max_memory : float or int\n Allowed memory in MB. Default value equals to :class:`Mole.max_memory`\n incore_complete : bool\n Avoid all I/O. Default is False.\n method : string\n nth-order ADC method. Options are : ADC(2), ADC(2)-X, ADC(3). Default is ADC(2).\n conv_tol : float\n Convergence threshold for Davidson iterations. Default is 1e-12.\n max_cycle : int\n Number of Davidson iterations. Default is 50.\n max_space : int\n Space size to hold trial vectors for Davidson iterative diagonalization. Default is 12.\n\n Kwargs:\n\tnroots : int\n\t Number of roots (eigenvalues) requested. Default value is 1.\n\n >>> myadc = adc.RADC(mf).run()\n >>> myadcip = adc.RADC(myadc).run()\n\n Saved results\n\n e_ip : float or list of floats\n IP energy (eigenvalue). For nroots = 1, it is a single float number. If nroots > 1, it is a list of floats for the lowest nroots eigenvalues.\n v_ip : array\n Eigenvectors for each IP transition.\n p_ip : float\n Spectroscopic amplitudes for each IP transition.\n '''\n def __init__(self, adc):\n self.mol = adc.mol\n self.verbose = adc.verbose\n self.stdout = adc.stdout\n self.max_memory = adc.max_memory\n self.max_space = adc.max_space\n self.max_cycle = adc.max_cycle\n self.conv_tol = adc.conv_tol\n self.t1 = adc.t1\n self.t2 = adc.t2\n self.e_corr = adc.e_corr\n self.method = adc.method\n self.method_type = adc.method_type\n self._scf = adc._scf\n self._nocc = adc._nocc\n self._nvir = adc._nvir\n self._nmo = adc._nmo\n self.mo_coeff = adc.mo_coeff\n self.mo_energy = adc.mo_energy\n self.nmo = adc._nmo\n self.transform_integrals = adc.transform_integrals\n self.with_df = adc.with_df\n\n keys = set(('conv_tol', 'e_corr', 'method', 'mo_coeff', 'mo_energy_b', 'max_memory', 't1', 'mo_energy_a', 'max_space', 't2', 'max_cycle'))\n\n self._keys = set(self.__dict__.keys()).union(keys)\n\n kernel = kernel\n get_imds = get_imds_ip\n get_diag = ip_adc_diag\n matvec = ip_adc_matvec\n compute_trans_moments = ip_compute_trans_moments\n get_trans_moments = get_trans_moments\n get_spec_factors = get_spec_factors_ip\n\n def get_init_guess(self, nroots=1, diag=None, ascending = True):\n if diag is None :\n diag = self.ip_adc_diag()\n idx = None\n if ascending:\n idx = np.argsort(diag)\n else:\n idx = np.argsort(diag)[::-1]\n guess = np.zeros((diag.shape[0], nroots))\n min_shape = min(diag.shape[0], nroots)\n guess[:min_shape,:min_shape] = np.identity(min_shape)\n g = np.zeros((diag.shape[0], nroots))\n g[idx] = guess.copy()\n guess = []\n for p in range(g.shape[1]):\n guess.append(g[:,p])\n return guess\n\n def gen_matvec(self, imds=None, eris=None):\n if imds is None: imds = self.get_imds(eris)\n diag = self.get_diag(imds, eris)\n matvec = self.matvec(imds, eris)\n return matvec, diag\n\nif __name__ == '__main__':\n from pyscf import scf\n from pyscf import gto\n from pyscf import adc\n\n r = 1.098\n mol = gto.Mole()\n mol.atom = [\n ['N', ( 0., 0. , -r/2 )],\n ['N', ( 0., 0. , r/2)],]\n mol.basis = {'N':'aug-cc-pvdz'}\n mol.verbose = 0\n mol.build()\n mf = scf.RHF(mol)\n mf.conv_tol = 1e-12\n mf.kernel()\n\n myadc = adc.ADC(mf)\n ecorr, t_amp1, t_amp2 = myadc.kernel_gs()\n print(ecorr - -0.3220169236051954)\n\n myadcip = RADCIP(myadc)\n e,v,p = kernel(myadcip,nroots=3)\n print(\"ADC(2) IP energies\")\n print (e[0] - 0.5434389910483670)\n print (e[1] - 0.6240296243595950)\n print (e[2] - 0.6240296243595956)\n\n print(\"ADC(2) IP spectroscopic factors\")\n print (p[0] - 1.7688097076459075)\n print (p[1] - 1.8192921131700284)\n print (p[2] - 1.8192921131700293)\n\n myadcea = RADCEA(myadc)\n e,v,p = kernel(myadcea,nroots=3)\n print(\"ADC(2) EA energies\")\n print (e[0] - 0.0961781923822576)\n print (e[1] - 0.1258326916409743)\n print (e[2] - 0.1380779405750178)\n\n print(\"ADC(2) EA spectroscopic factors\")\n print (p[0] - 1.9832854445007961)\n print (p[1] - 1.9634368668786559)\n print (p[2] - 1.9783719593912672)\n\n myadc = adc.ADC(mf)\n myadc.method = \"adc(3)\"\n ecorr, t_amp1, t_amp2 = myadc.kernel_gs()\n print(ecorr - -0.31694173142858517)\n\n myadcip = RADCIP(myadc)\n e,v,p = kernel(myadcip,nroots=3)\n print(\"ADC(3) IP energies\")\n print (e[0] - 0.5667526829981027)\n print (e[1] - 0.6099995170092525)\n print (e[2] - 0.6099995170092529)\n\n print(\"ADC(3) IP spectroscopic factors\")\n print (p[0] - 1.8173191958988848)\n print (p[1] - 1.8429224413853840)\n print (p[2] - 1.8429224413853851)\n\n myadcea = RADCEA(myadc)\n e,v,p = kernel(myadcea,nroots=3)\n\n print(\"ADC(3) EA energies\")\n print (e[0] - 0.0936790850738445)\n print (e[1] - 0.0983654552141278)\n print (e[2] - 0.1295709313652367)\n\n print(\"ADC(3) EA spectroscopic factors\")\n print (p[0] - 1.8324175318668088)\n print (p[1] - 1.9840991060607487)\n print (p[2] - 1.9638550014980212)\n\n myadc.method = \"adc(2)-x\"\n e,v,p = myadc.kernel(nroots=4)\n print(\"ADC(2)-x IP energies\")\n print (e[0] - 0.5405255360673724)\n print (e[1] - 0.6208026698756577)\n print (e[2] - 0.6208026698756582)\n print (e[3] - 0.6465332771967947)\n\n myadc.method_type = \"ea\"\n e,v,p = myadc.kernel(nroots=4)\n print(\"ADC(2)-x EA energies\")\n print (e[0] - 0.0953065329985665)\n print (e[1] - 0.1238833070823509)\n print (e[2] - 0.1365693811939308)\n print (e[3] - 0.1365693811939316)\n", "meta": {"hexsha": "19e608428c881988a3a2270816776615aa1ee3b9", "size": 83564, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyscf/adc/radc.py", "max_stars_repo_name": "mtreinish/pyscf", "max_stars_repo_head_hexsha": "b3c86bc145c180230cb6aba81e9c47b5764aeec4", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-01-24T13:35:42.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-24T13:35:42.000Z", "max_issues_repo_path": "pyscf/adc/radc.py", "max_issues_repo_name": "holy0213/pyscf", "max_issues_repo_head_hexsha": "aff8a94003cc47ff5e741ce648d877b008a0c59e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pyscf/adc/radc.py", "max_forks_repo_name": "holy0213/pyscf", "max_forks_repo_head_hexsha": "aff8a94003cc47ff5e741ce648d877b008a0c59e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-09-30T14:38:46.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-30T14:38:46.000Z", "avg_line_length": 38.8489074849, "max_line_length": 209, "alphanum_fraction": 0.5904815471, "include": true, "reason": "import numpy", "num_tokens": 30942, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.668880247169804, "lm_q2_score": 0.2909808600663598, "lm_q1q2_score": 0.1946313496028689}} {"text": "#!/usr/bin/env python\n\n\"\"\"\nThe alignment module contains functions used in aligning two channel\ndata with fluorescent dyes. See our `walkthrough\n`_\nof the alignment module's usage.\n\"\"\"\n\n__all__ = ['im_split', 'get_offset_distribution',\n 'plot_assigned_maxima', 'inspect_global_fit',\n 'inspect_individual_fits', 'align_by_offset',\n 'overlay']\n\n__version__ = '0.3.0'\n\n__author__ = 'Sy Redding and Liv Jensen'\n\n\n\n\n\nimport numpy as np\nimport random as ra\nimport matplotlib.pyplot as plt\nfrom smtools.misc import skewnormal\nfrom smtools.point_fitting import find_maxima, fit_routine\nfrom scipy.spatial import cKDTree\nfrom scipy.ndimage import map_coordinates\nfrom scipy.optimize import curve_fit\nfrom skimage.transform import warp_coords, rotate\n\n\n########################################################################\ndef im_split(Image, splitstyle=\"hsplit\"):\n return getattr(np, splitstyle)(Image, 2)[0], \\\n getattr(np, splitstyle)(Image, 2)[1]\n\n\ndef clean_duplicate_maxima(dist, indexes):\n paired_indexes = []\n count = -1\n for i in set(indexes):\n tmp_dist = np.inf\n tmp = None\n for j, k in zip(indexes, dist):\n if i == j:\n count += 1\n if k < tmp_dist:\n tmp = [j, count]\n tmp_dist = k\n else:\n pass\n if tmp is not None:\n paired_indexes.append(tmp)\n return paired_indexes\n\n\n\ndef make_bins(data, width):\n return np.arange(min(data), max(data) + width, width)\n\ndef find_global_offset(im_stack, bbox=9, splitstyle=\"hsplit\",\n fsize=10, binwidth=.1):\n\n pooled_x, pooled_y = [], []\n for im in im_stack:\n xdist, ydist = get_offset_distribution(im, bbox, splitstyle,\n fsize)\n pooled_x += xdist\n pooled_y += ydist\n\n p0 = [bincens[np.argmax(vals[0])],.2, 1, max(vals[0]), 0]\n bins = make_bins(pooled_x, binwidth)\n vals = np.histogram(pooled_x, bins)\n bincens = [bins[j] + (binwidth / 2.) for j in range(len(bins) - 1)]\n popt_x, pcov_x = curve_fit(skewnormal, np.array(bincens),\n np.array(vals[0]),p0)\n\n bins = make_bins(pooled_y, binwidth)\n vals = np.histogram(pooled_y, bins)\n bincens = [bins[j] + (binwidth / 2.) for j in range(len(bins) - 1)]\n p0 = [bincens[np.argmax(vals[0])],.2, 1, max(vals[0]), 0]\n popt_y, pcov_y = curve_fit(skewnormal, np.array(bincens),\n np.array(vals[0]),p0)\n\n return popt_x[0], popt_y[0]\n\n\n########################################################################\n\n\ndef get_offset_distribution(Image, bbox=9, splitstyle=\"hsplit\",\n fsize=10):\n \"\"\"\n This function in order:\n * splits the image into channels\n * locates and fits all of the points in each channel\n * pairs up associated points from each channel, uses cDKTree\n * and determines their offset\n\n :param Image: 2D image array\n :param bbox: int, passed to ``point_fitting.fit_routine``,\n size of ROI around each point to apply gaussian fit. Default\n is 9.\n :param splitstyle: string, passed to ``im_split``; accepts\n \"hsplit\", \"vsplit\". Default is \"hsplit\"\n :param fsize: int, passed to ``point_fitting.find_maxima``,\n size of average filters used in maxima determination. Default\n is 10.\n\n :return: Two lists containing all of the measured x- and y- offsets\n\n :Example:\n\n >>> from smtools.alignment import get_offset_distribution\n >>> import smtools.testdata as test\n >>> import matplotlib.pyplot as plt\n >>> import numpy as np\n >>> im = test.image_stack()[0]\n >>> x_dist, y_dist = get_offset_distribution(im)\n >>> print(np.mean(x_dist), np.mean(y_dist))\n -1.9008888233326608 -2.042675546813981\n \"\"\"\n ch1, ch2 = im_split(Image, splitstyle)\n ch1_maxima = find_maxima(ch1, fsize)\n ch2_maxima = find_maxima(ch2, fsize)\n Delta_x, Delta_y = [], []\n mytree = cKDTree(ch1_maxima)\n dist, indexes = mytree.query(ch2_maxima)\n for i, j in clean_duplicate_maxima(dist, indexes):\n fit_ch1 = fit_routine(ch1, [ch1_maxima[i]], bbox)\n fit_ch2 = fit_routine(ch2, [ch2_maxima[j]], bbox)\n try:\n x1, y1 = fit_ch1[0]\n x2, y2 = fit_ch2[0]\n Delta_x.append(x1 - x2)\n Delta_y.append(y1 - y2)\n\n except TypeError:\n pass\n return (Delta_x, Delta_y)\n\n\n\n\ndef plot_assigned_maxima(Image, splitstyle=\"hsplit\", fsize=10):\n \"\"\"\n This function spits out a matplotlib plot with lines drawn\n between each of the assigned pairs of maxima.\n The purpose of this function is more for a sanity check than\n anything useful.\n\n :param Image: 2D image array\n :param splitstyle: string, passed to ``im_split``; accepts\n \"hsplit\", \"vsplit\". Default is \"hsplit\"\n :param fsize: int, passed to ``point_fitting.find_maxima``,\n size of average filters used in maxima determination. Default\n is 10.\n\n :return: fancy plot of assigned points.\n\n :Example:\n\n >>> from smtools.alignment import plot_assigned_maxima\n >>> import smtools.testdata as test\n >>> im = test.image_stack()[0]\n >>> plot_assigned_maxima(im)\n \"\"\"\n ch1, ch2 = im_split(Image, splitstyle)\n ch1_maxima = find_maxima(ch1, fsize)\n ch2_maxima = find_maxima(ch2, fsize)\n width = ch2.shape[1]\n plt.figure(figsize=(Image.shape[0] / 64, Image.shape[1] / 64))\n plt.axis('off')\n plt.imshow(Image, cmap=\"binary_r\")\n plt.title(\"Assigned matching points\")\n\n mytree = cKDTree(ch1_maxima)\n dist, indexes = mytree.query(ch2_maxima)\n for i, j in clean_duplicate_maxima(dist, indexes):\n x1, y1 = ch1_maxima[i]\n x2, y2 = ch2_maxima[j]\n tmp_color = (\n ra.uniform(0, 1), ra.uniform(0, 1), ra.uniform(0, 1))\n plt.plot(x1, y1, color=tmp_color, marker='+')\n plt.plot(x2 + width, y2, color=tmp_color, marker='+')\n plt.plot([x1, x2 + width], [y1, y2], color=tmp_color)\n plt.show()\n\n\n\n\n\ndef inspect_global_fit(im_stack, bbox=9, fsize=10,\n binwidth=.1, init_params = None,\n splitstyle=\"hsplit\",showplot=True):\n\n \"\"\"\n Basic alignment function. Accepts a 1D list of image arrays,\n then splits the images, locates corresponding maxima in each\n channel and then calculates the best shift in x and y to align\n each maxima pair. If showplot is set to True, this function also\n produces a pair of histograms of all the measured offsets and\n resulting fits to those data.\n\n\n :param im_stack: 1D list of image arrays to be used in\n determination of the offset\n :param bbox: int, passed to ``point_fitting.fit_routine``,\n size of ROI around each point to apply gaussian fit. Default\n is 9.\n :param fsize: int, passed to ``point_fitting.find_maxima``,\n size of average filters used in maxima determination. Default\n is 10.\n :param binwidth: float, passed to ``make_bins``; resolution of\n histogram for fitting\n :param init_params: 1D array, initial conditions passed to\n scipy.optimize.curve_fit. must be length 5,\n p0 = [loc, scale, shape, amplitude, baseline]\n :param splitstyle: string, passed to ``im_split``; orientation\n of channels, vertical or horizontal\n :param showplot: bool, if True, will generate a plot of the\n distribution and fit\n\n :return: tuple containing optimal parameters and covariance\n matrix from fit. (popt_x, pcov_x, popt_y, pcov_y)\n\n :Example:\n\n >>> from smtools.alignment import inspect_global_fit\n >>> import smtools.testdata as test\n >>> params = inspect_global_fit(test.image_stack())\n >>> print(params[0][0],params[2][0])\n 5.612082237088681 -2.651765063702885\n \"\"\"\n ###\n pooled_x, pooled_y = [], []\n for im in im_stack:\n xdist, ydist = get_offset_distribution(im, bbox, splitstyle,\n fsize)\n pooled_x += xdist\n pooled_y += ydist\n\n ###\n bins = make_bins(pooled_x, binwidth)\n x_bincens = [bins[j] + (binwidth / 2.) for j in\n range(len(bins) - 1)]\n x_vals = np.histogram(pooled_x, bins)\n\n if init_params is None:\n p0 = [x_bincens[np.argmax(x_vals[0])],\n .2, 1, max(x_vals[0]), 0]\n\n try:\n popt_x, pcov_x = curve_fit(skewnormal, np.array(x_bincens),\n np.array(x_vals[0]),p0)\n except RuntimeError:\n popt_x, pcov_x = [], []\n pass\n\n ###\n bins = make_bins(pooled_y, binwidth)\n y_bincens = [bins[j] + (binwidth / 2.) for j in\n range(len(bins) - 1)]\n y_vals = np.histogram(pooled_y, bins)\n\n if init_params is None:\n p0 = [y_bincens[np.argmax(y_vals[0])],\n .2, 1, max(y_vals[0]), 0]\n\n try:\n popt_y, pcov_y = curve_fit(skewnormal, np.array(y_bincens),\n np.array(y_vals[0]),p0)\n except RuntimeError:\n popt_y, pcov_y = [], []\n pass\n\n ###\n if showplot == True:\n fig = plt.figure()\n ax1 = fig.add_subplot(121)\n ax2 = fig.add_subplot(122)\n\n ax1.set_xlim(x_bincens[np.argmax(x_vals[0])] - 1.5,\n x_bincens[np.argmax(x_vals[0])] + 1.5)\n ax1.set_title(\"x-offsets\")\n ax1.bar(x_bincens, x_vals[0], width=binwidth / 2,\n color = \"#008fd5\")\n if len(popt_x) > 1:\n fit = skewnormal(np.array(x_bincens), *popt_x)\n ax1.plot(x_bincens, fit, \"--\", color=\"#fc4f30\",\n linewidth=3)\n\n ax2.set_xlim(y_bincens[np.argmax(y_vals[0])] - 1.5,\n y_bincens[np.argmax(y_vals[0])] + 1.5)\n ax2.set_title(\"y-offsets\")\n ax2.bar(y_bincens, y_vals[0], width=binwidth / 2,\n color=\"#FFA622\")\n if len(popt_y) > 1:\n fit = skewnormal(np.array(y_bincens), *popt_y)\n ax2.plot(y_bincens, fit, \"--\", color=\"#5D3EAF\",\n linewidth=3)\n\n plt.show()\n\n try:\n return ((popt_x[0],popt_y[0],[popt_x, pcov_x, popt_y, pcov_y]))\n except :\n return None\n\n\n\n\ndef inspect_individual_fits(im_stack, bbox=9, fsize=10,\n binwidth=.1, init_params = None,\n splitstyle=\"hsplit\"):\n\n \"\"\"\n This function provides a method to plot each individual offset\n distributions of images passed to the function. Common usage is\n to get a sense of how similar groups of images are.\n\n :param im_stack: 1D list of image arrays to be used in\n determination of the offset\n :param bbox: int, passed to ``point_fitting.fit_routine``,\n size of ROI around each point to apply gaussian fit. Default\n is 9.\n :param fsize: int, passed to ``point_fitting.find_maxima``,\n size of average filters used in maxima determination. Default\n is 10.\n :param binwidth: float, passed to ``make_bins``; resolution of\n histogram for fitting\n :param init_params: 1D array, initial conditions passed to\n scipy.optimize.curve_fit. must be length 5,\n p0 = [loc, scale, shape, amplitude, baseline]\n :param splitstyle: string, passed to ``im_split``; orientation\n of channels, vertical or horizontal\n\n\n :return: produces a plot of histograms and fits for each\n individual image passed in im_stack. Also returns list of tuples,\n each contains optimal parameters and covariance matrix from\n fit. If no fit was found, returns an empty list. The lists\n alternate between x and y-offset fits.\n\n :Example:\n >>> from smtools.alignment import inspect_individual_fits\n >>> import smtools.testdata as test\n >>> params = inspect_individual_fits(test.image_stack())\n \"\"\"\n pooled_x, pooled_y = [], []\n for im in im_stack:\n xdist, ydist = get_offset_distribution(im)\n pooled_x += xdist\n pooled_y += ydist\n spanx = [np.median(pooled_x) - 1.5, np.median(pooled_x) + 1.5]\n spany = [np.median(pooled_y) - 1.5, np.median(pooled_y) + 1.5]\n\n fig, axes = plt.subplots(nrows=len(im_stack), ncols=2)\n plt.subplots_adjust(wspace=0, hspace=0)\n axlist = [i for i in axes.flat]\n\n count = 0\n fitlist = []\n for im in im_stack:\n xdist, ydist = get_offset_distribution(im, bbox, splitstyle,\n fsize)\n\n bins = make_bins(xdist, binwidth)\n x_bincens = [bins[j] + (binwidth / 2.) for j in\n range(len(bins) - 1)]\n x_vals = np.histogram(xdist, bins)\n axlist[count].set_xlim(spanx)\n axlist[count].axes.get_yaxis().set_visible(False)\n axlist[count].bar(x_bincens, x_vals[0], width=binwidth / 2,\n color=\"#008fd5\")\n\n if init_params is None:\n p0 = [x_bincens[np.argmax(x_vals[0])],\n .2, 1, max(x_vals[0]), 0]\n try:\n popt_x, pcov_x = curve_fit(skewnormal, np.array(x_bincens),\n np.array(x_vals[0]),p0)\n fitlist.append((popt_x, pcov_x))\n fit = skewnormal(np.array(x_bincens), *popt_x)\n axlist[count].plot(x_bincens, fit, \"--\",\n color=\"#fc4f30\", linewidth=2)\n\n except RuntimeError:\n fitlist.append([])\n pass\n\n count += 1\n bins = make_bins(ydist, binwidth)\n y_bincens = [bins[j] + (binwidth / 2.) for j in\n range(len(bins) - 1)]\n y_vals = np.histogram(ydist, bins)\n axlist[count].set_xlim(spany)\n axlist[count].axes.get_yaxis().set_visible(False)\n axlist[count].bar(y_bincens, y_vals[0], width=binwidth / 2,\n color=\"#FFA622\", linewidth=2)\n\n if init_params is None:\n p0 = [y_bincens[np.argmax(y_vals[0])],\n .2, 1, max(y_vals[0]), 0]\n try:\n popt_y, pcov_y = curve_fit(skewnormal, np.array(y_bincens),\n np.array(y_vals[0]), p0)\n fitlist.append((popt_y, pcov_y))\n fit = skewnormal(np.array(y_bincens), *popt_y)\n axlist[count].plot(y_bincens, fit, \"--\",\n color=\"#5D3EAF\")\n\n except RuntimeError:\n fitlist.append([])\n pass\n\n count += 1\n plt.show()\n\n return (fitlist)\n\n\n\n\n\ndef align_by_offset(Image, shift_x, shift_y, splitstyle=\"hsplit\",\n shift_channel=1):\n \"\"\"\n This function shifts one channel of the array based supplied\n offset values. Retains the single image structure.\n\n :param Image: 2D image array\n :param shift_x: float, offset in x\n :param shift_y: float, offset in y\n :param splitstyle: string, passed to ``im_split``; accepts\n \"hsplit\", \"vsplit\". Default is \"hsplit\"\n :param shift_channel: int, which channel to shift by offsets,\n default is channel 1.\n\n :return: 2D image array of aligned image\n\n :Example:\n >>> from smtools.alignment import find_global_offset,\n align_by_offset\n >>> import smtools.testdata as test\n >>> import matplotlib.pyplot as plt\n >>> im = test.image_stack()\n >>> dx, dy = find_global_offset(im)\n >>> new_image = align_by_offset(im[0], dx, dy)\n >>> plt.imshow(new_image), plt.show()\n \"\"\"\n\n ch1, ch2 = im_split(Image, splitstyle)\n if shift_channel == 1:\n new_coords = warp_coords(\n lambda xy: xy - np.array([shift_x, shift_y]), ch2.shape)\n warped_channel = map_coordinates(ch2, new_coords)\n aligned_image = np.concatenate((ch1, warped_channel), axis=1)\n else:\n new_coords = warp_coords(\n lambda xy: xy + np.array([shift_x, shift_y]), ch1.shape)\n warped_channel = map_coordinates(ch1, new_coords)\n aligned_image = np.concatenate((warped_channel, ch2), axis=1)\n return aligned_image\n\n\n\n\n\ndef overlay(Image, splitstyle=\"hsplit\", rot=True, invert=False):\n \"\"\"\n Overlays the two channels derived from Image. Converts Image to\n an 8-bit RGB array, with one channel colored magenta and the\n other green.\n\n :param Image: 2D image array\n :param splitstyle: string, passed to ``im_split``; accepts\n \"hsplit\", \"vsplit\". Default is \"hsplit\"\n :param rot: bool, if True, image is rotated 90 degrees\n :param invert: bool, if True, inverts the channel color assignment.\n\n :return: 8-bit RGB image\n\n :Example:\n >>> from smtools.alignment import overlay\n >>> import smtools.testdata as test\n >>> import matplotlib.pyplot as plt\n >>> im = test.image_stack()\n >>> dx, dy = find_global_offset(im)\n >>> aligned_image = align_by_offset(im[0], dx, dy)\n >>> overlayed = overlay(aligned_image)\n >>> plt.imshow(overlayed), plt.show()\n \"\"\"\n if not invert:\n ch1, ch2 = im_split(Image,splitstyle)\n else:\n ch2, ch1 = im_split(Image,splitstyle)\n ch1_max = ch1.max()\n ch2_max = ch2.max()\n shape = ch1.shape\n red = np.zeros(shape)\n green = np.zeros(shape)\n for x in range(0, shape[0]):\n for y in range(0, shape[1]):\n red[x, y] = ch1[x, y] / ch1_max\n green[x, y] = ch2[x, y] / ch2_max\n rgb_stack = np.dstack((red, green, red))\n if rot:\n rgb_stack = rotate(rgb_stack, -90, resize=True)\n\n rgb_stack *= 255\n rgb_stack = rgb_stack.astype(np.uint8)\n return rgb_stack\n\n", "meta": {"hexsha": "2bf87a6ef6c895b782c1d59c66e9c86dd6e68dd0", "size": 17825, "ext": "py", "lang": "Python", "max_stars_repo_path": "smtools/alignment.py", "max_stars_repo_name": "ReddingLab/smtools", "max_stars_repo_head_hexsha": "bd319909c9169d2f083a513e55f090fe721a000f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "smtools/alignment.py", "max_issues_repo_name": "ReddingLab/smtools", "max_issues_repo_head_hexsha": "bd319909c9169d2f083a513e55f090fe721a000f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2019-04-05T19:48:56.000Z", "max_issues_repo_issues_event_max_datetime": "2019-08-29T20:22:15.000Z", "max_forks_repo_path": "smtools/alignment.py", "max_forks_repo_name": "ReddingLab/smtools", "max_forks_repo_head_hexsha": "bd319909c9169d2f083a513e55f090fe721a000f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.4111969112, "max_line_length": 73, "alphanum_fraction": 0.5943899018, "include": true, "reason": "import numpy,from scipy", "num_tokens": 4677, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6001883735630721, "lm_q2_score": 0.3242353924510608, "lm_q1q2_score": 0.19460231284678656}} {"text": "import logging\nimport numpy as np\nimport resource\nimport random\nfrom sys import stdout\nimport os\nimport argparse\nimport pickle as Pickle\nimport scipy.optimize\nfrom flarestack.core.injector import read_injector_dict\nfrom flarestack.core.llh import LLH, generate_dynamic_flare_class, read_llh_dict\nfrom flarestack.shared import name_pickle_output_dir, \\\n inj_dir_name, plot_output_dir, scale_shortener, flux_to_k\nimport matplotlib.pyplot as plt\nimport matplotlib.cm as cm\nfrom matplotlib.colors import Normalize, ListedColormap\nimport matplotlib as mpl\nfrom flarestack.core.time_pdf import TimePDF, Box, Steady\nfrom flarestack.core.angular_error_modifier import BaseAngularErrorModifier\nfrom flarestack.utils.catalogue_loader import load_catalogue, \\\n calculate_source_weight\nfrom flarestack.utils.asimov_estimator import estimate_discovery_potential\n\nlogger = logging.getLogger(__name__)\n\ndef time_smear(inj):\n inj_time = inj[\"injection_sig_time_pdf\"]\n max_length = inj_time[\"max_offset\"] - inj_time[\"min_offset\"]\n offset = np.random.random() * max_length + inj_time[\"min_offset\"]\n inj_time[\"offset\"] = offset\n return inj_time\n\n\ndef read_mh_dict(mh_dict):\n \"\"\"Ensure backwards compatibility of MinimisationHandler dictionary objects\n\n :param mh_dict: MinimisationHandler dictionary\n :return: MinimisationHandler dictionary compatible with new format\n \"\"\"\n\n # Ensure backwards compatibility\n\n maps = [\n (\"inj kwargs\", \"inj_dict\"),\n (\"datasets\", \"dataset\"),\n (\"background TS\", \"background_ts\")\n ]\n\n for (old_key, new_key) in maps:\n\n if old_key in list(mh_dict.keys()):\n logger.warning(\"Deprecated mh_dict key '{0}' was used. Please use '{1}' in future.\".format(\n old_key, new_key))\n mh_dict[new_key] = mh_dict[old_key]\n\n if \"name\" not in mh_dict.keys():\n raise KeyError(\"mh_dict object is missing key 'name'.\"\n \"This should be the unique save path for results.\")\n\n elif mh_dict[\"name\"][-1] != \"/\":\n mh_dict[\"name\"] += \"/\"\n\n pairs = [\n (\"inj_dict\", read_injector_dict),\n (\"llh_dict\", read_llh_dict)\n ]\n\n for (key, f) in pairs:\n if key in list(mh_dict.keys()):\n mh_dict[key] = f(mh_dict[key])\n\n if np.logical_and(\"fixed_scale\" in mh_dict.keys(), \"n_steps\" in mh_dict.keys()):\n raise Exception(f\"MinimisationHandler dictionary contained both 'fixed_scale' key for \"\n f\"set injection flux, and 'n_steps' key for stepped injection flux.\"\n f\"Please use only one of these options. \\n mh_dict: \\n {mh_dict}\")\n\n return mh_dict\n\n\nclass MinimisationHandler(object):\n \"\"\"Generic Class to handle both dataset creation and llh minimisation from\n experimental data and Monte Carlo simulation. Initialised with a set of\n IceCube datasets, a list of sources, and independent sets of arguments for\n the injector and the likelihood.\n \"\"\"\n subclasses = {}\n\n # Each MinimisationHandler must specify which LLH classes are compatible\n compatible_llh = []\n compatible_negative_n_s = False\n\n def __init__(self, mh_dict):\n\n mh_dict = read_mh_dict(mh_dict)\n\n sources = load_catalogue(mh_dict[\"catalogue\"])\n\n self.name = mh_dict[\"name\"]\n\n self.pickle_output_dir = name_pickle_output_dir(self.name)\n self._injectors = dict()\n self._llhs = dict()\n self._aem = dict()\n self.seasons = mh_dict[\"dataset\"]\n self.sources = sources\n self.mh_dict = mh_dict\n\n if \"inj_dict\" in mh_dict.keys():\n\n # Checks whether signal injection should be done with a sliding PDF\n # within a larger window, or remain fixed at the specified time\n\n inj = dict(mh_dict[\"inj_dict\"])\n\n try:\n self.time_smear = inj[\"injection_sig_time_pdf\"][\"time_smear_bool\"]\n except KeyError:\n self.time_smear = False\n\n if self.time_smear:\n inj[\"injection_sig_time_pdf\"] = time_smear(inj)\n\n self.inj_dict = inj\n\n # An independent set of Season objects can be used for the injector\n # This enables, for example, different MC sets to be used for\n # injection, to test the impact of different systematics\n\n try:\n self.inj_seasons = mh_dict[\"inj_dict\"][\"injection_dataset\"]\n logger.debug(\"Using independent injection dataset.\")\n\n if self.inj_seasons.keys() != self.seasons.keys():\n raise Exception(\"Key mismatch between injection and llh \"\n \"Season objects. Injection Seasons have \"\n \"keys:\\n {0} \\n and LLH Seasons have keys: \\n\"\n \"{1}\". format(self.inj_seasons.keys(),\n self.seasons.keys()))\n\n except KeyError:\n self.inj_seasons = self.seasons\n\n self.llh_dict = mh_dict[\"llh_dict\"]\n\n # Check if the specified MinimisationHandler is compatible with the\n # chosen LLH class\n\n if self.llh_dict[\"llh_name\"] not in self.compatible_llh:\n raise ValueError(\"Specified LLH ({}) is not compatible with \"\n \"selected MinimisationHandler\".format(\n self.llh_dict[\"llh_name\"]))\n else:\n logger.info(\"Using '{0}' LLH class\".format(self.llh_dict[\"llh_name\"]))\n\n # Checks if negative n_s is specified for use, and whether this is\n # compatible with the chosen MinimisationHandler\n\n try:\n self.negative_n_s = self.llh_dict[\"negative_ns_bool\"]\n except KeyError:\n self.negative_n_s = False\n\n if self.negative_n_s and not self.compatible_negative_n_s:\n raise ValueError(\"MinimisationHandler has been instructed to \\n\"\n \"allow negative n_s, but this is not compatible \\n\"\n \"with the selected MinimisationHandler.\")\n\n # Sets up whether what pull corrector should be used (default is\n # none), and whether an angular error floor should be applied (\n # default is a static floor.\n\n try:\n self.pull_name = self.llh_dict[\"pull_name\"]\n except KeyError:\n self.pull_name = \"no_pull\"\n\n try:\n self.floor_name = self.llh_dict[\"floor_name\"]\n except KeyError:\n self.floor_name = \"static_floor\"\n\n p0, bounds, names = self.return_parameter_info(mh_dict)\n\n self.p0 = p0\n self.bounds = bounds\n self.param_names = names\n\n self.disc_guess = np.nan\n\n @classmethod\n def register_subclass(cls, mh_name):\n \"\"\"Adds a new subclass of EnergyPDF, with class name equal to\n \"energy_pdf_name\".\n \"\"\"\n def decorator(subclass):\n cls.subclasses[mh_name] = subclass\n return subclass\n\n return decorator\n\n @classmethod\n def create(cls, mh_dict):\n mh_dict = read_mh_dict(mh_dict)\n\n mh_name = mh_dict[\"mh_name\"]\n\n if mh_name not in cls.subclasses:\n raise ValueError('Bad MinimisationHandler name {}'.format(mh_name))\n\n return cls.subclasses[mh_name](mh_dict)\n\n @classmethod\n def find_parameter_info(cls, mh_dict):\n read_mh_dict(mh_dict)\n mh_name = mh_dict[\"mh_name\"]\n\n if mh_name not in cls.subclasses:\n raise ValueError('Bad MinimisationHandler name {}'.format(mh_name))\n\n return cls.subclasses[mh_name].return_parameter_info(mh_dict)\n\n def run_trial(self, full_dataset):\n pass\n\n def run(self, n_trials, scale=1., seed=None):\n pass\n\n @staticmethod\n def trial_params(mh_dict):\n\n if \"fixed_scale\" in list(mh_dict.keys()):\n scale_range = [mh_dict[\"fixed_scale\"]]\n\n # elif mh_dict.get(\"background_only\", False):\n # # Only do the background trials\n # # In this case only n_trials background trials are performed, not 10x n_trials!\n # scale_range = np.array([0])\n #\n # elif mh_dict.get(\"injection_only\", False):\n # # Only do trials with signal injection\n # scale = mh_dict[\"scale\"]\n # steps = int(mh_dict[\"n_steps\"])\n # scale_range = np.array(list(np.linspace(0., scale, steps)[1:]))\n\n else:\n scale = mh_dict[\"scale\"]\n steps = int(mh_dict[\"n_steps\"])\n background_ntrials_factor = mh_dict.get('background_ntrials_factor', 10)\n scale_range = np.array(\n [0. for _ in range(background_ntrials_factor)] +\n list(np.linspace(0., scale, steps)[1:])\n )\n\n n_trials = int(mh_dict[\"n_trials\"])\n\n return scale_range, n_trials\n\n def iterate_run(self, scale=1., n_steps=5, n_trials=50):\n\n scale_range = np.linspace(0., scale, n_steps)[1:]\n\n self.run(n_trials*10, scale=0.0)\n\n for scale in scale_range:\n self.run(n_trials, scale)\n\n @staticmethod\n def return_parameter_info(mh_dict):\n seeds = []\n bounds = []\n names = []\n return seeds, names, bounds\n\n @staticmethod\n def return_injected_parameters(mh_dict):\n return {}\n\n def add_likelihood(self, season):\n return LLH.create(season, self.sources, self.llh_dict)\n\n def get_likelihood(self, season_name):\n\n if season_name not in self._llhs.keys():\n self._llhs[season_name] = self.add_likelihood(self.seasons[season_name])\n\n return self._llhs[season_name]\n\n def add_injector(self, season, sources):\n return season.make_injector(sources, **self.inj_dict)\n\n def get_injector(self, season_name):\n\n if season_name not in self._injectors.keys():\n self._injectors[season_name] = self.add_injector(self.seasons[season_name], self.sources)\n\n return self._injectors[season_name]\n\n def add_angular_error_modifier(self, season):\n return BaseAngularErrorModifier.create(\n season, self.llh_dict[\"llh_energy_pdf\"], self.floor_name,\n self.pull_name,\n gamma_precision=self.llh_dict.get('gamma_precision', 'flarestack')\n )\n\n def get_angular_error_modifier(self, season_name):\n\n if season_name not in self._aem.keys():\n self._aem[season_name] = self.add_angular_error_modifier(self.seasons[season_name])\n\n return self._aem[season_name]\n\n @staticmethod\n def set_random_seed(seed):\n np.random.seed(seed)\n\n def guess_scale(self):\n \"\"\"Method to guess flux scale for sensitivity + discovery potential\n :return:\n \"\"\"\n return 1.5 * flux_to_k(self.guess_discovery_potential())\n\n def guess_discovery_potential(self):\n self.disc_guess = estimate_discovery_potential(\n self.seasons, dict(self.inj_dict), self.sources, dict(self.llh_dict))\n return self.disc_guess\n\n\n@MinimisationHandler.register_subclass('fixed_weights')\nclass FixedWeightMinimisationHandler(MinimisationHandler):\n \"\"\"Class to perform generic minimisations using a 'fixed weights' matrix.\n Sources are assigned intrinsic weights based on their assumed luminosity\n and/or distance, which are fixed. In addition, time weighting is used\n assuming a fixed fluence per source. The detector acceptance continues to\n vary as a function of the parameters given in minimisation step.\n \"\"\"\n\n compatible_llh = [\"spatial\", \"fixed_energy\", \"standard\",\n \"standard_overlapping\", \"standard_matrix\"]\n compatible_negative_n_s = True\n\n def __init__(self, mh_dict):\n\n MinimisationHandler.__init__(self, mh_dict)\n\n self.fit_weights = False\n\n # Checks if minimiser should be seeded from a brute scan\n\n try:\n self.brute = self.llh_dict[\"brute_seed\"]\n except KeyError:\n self.brute = False\n\n # self.clean_true_param_values()\n\n def clear(self):\n\n self._injectors.clear()\n self._llhs.clear()\n\n del self\n\n def dump_results(self, results, scale, seed):\n \"\"\"Takes the results of a set of trials, and saves the dictionary as\n a pickle pkl_file. The flux scale is used as a parent directory, and the\n pickle pkl_file itself is saved with a name equal to its random seed.\n\n :param results: Dictionary of Minimisation results from trials\n :param scale: Scale of inputted flux\n :param seed: Random seed used for running of trials\n \"\"\"\n\n if self.name == \" /\":\n logger.warning(\"No field 'name' was specified in mh_dict object. \"\n \"Cannot save results without a unique directory\"\n \" name being specified.\")\n\n else:\n\n write_dir = os.path.join(self.pickle_output_dir, scale_shortener(scale))\n\n # Tries to create the parent directory, unless it already exists\n try:\n os.makedirs(write_dir)\n except OSError:\n pass\n\n file_name = os.path.join(write_dir, str(seed) + \".pkl\")\n\n logger.debug(\"Saving to {0}\".format(file_name))\n\n with open(file_name, \"wb\") as f:\n Pickle.dump(results, f)\n\n def dump_injection_values(self, scale):\n\n if self.name == \" /\":\n raise Exception(\"No field 'name' was specified in mh_dict object. \"\n \"Cannot save results without a unique directory\"\n \" name being specified.\")\n\n else:\n\n inj_dict = self.return_injected_parameters(scale)\n\n inj_dir = inj_dir_name(self.name)\n\n # Tries to create the parent directory, unless it already exists\n try:\n os.makedirs(inj_dir)\n except OSError:\n pass\n\n file_name = os.path.join(inj_dir, scale_shortener(scale) + \".pkl\")\n\n logger.debug(f\"Dumping Injection values to {file_name}\")\n\n with open(file_name, \"wb\") as f:\n Pickle.dump(inj_dict, f)\n\n def run_trial(self, full_dataset):\n\n raw_f = self.trial_function(full_dataset)\n\n def llh_f(scale):\n return -np.sum(raw_f(scale))\n\n if self.brute:\n\n brute_range = [\n (max(x, -30), min(y, 30)) for (x, y) in self.bounds]\n\n start_seed = scipy.optimize.brute(\n llh_f, ranges=brute_range, finish=None, Ns=40)\n else:\n start_seed = self.p0\n\n res = scipy.optimize.minimize(\n llh_f, start_seed, bounds=self.bounds)\n\n vals = res.x\n flag = res.status\n # If the minimiser does not converge, repeat with brute force\n if flag == 1:\n vals = scipy.optimize.brute(llh_f, ranges=self.bounds,\n finish=None)\n\n best_llh = raw_f(vals)\n\n if np.logical_and(not res.x[0] > 0.0, self.negative_n_s):\n\n bounds = list(self.bounds)\n bounds[0] = (-1000., -0.)\n start_seed = list(self.p0)\n start_seed[0] = -1.\n\n new_res = scipy.optimize.minimize(\n llh_f, start_seed, bounds=bounds)\n\n if new_res.status == 0:\n res = new_res\n\n vals = [res.x[0]]\n best_llh = res.fun\n\n ts = np.sum(best_llh)\n\n if ts == -0.0:\n ts = 0.0\n\n parameters = dict()\n\n for i, val in enumerate(vals):\n parameters[self.param_names[i]] = val\n\n res_dict = {\n \"res\": res,\n \"Parameters\": parameters,\n \"TS\": ts,\n \"Flag\": flag,\n \"f\": llh_f\n }\n\n return res_dict\n\n def run_single(self, full_dataset, scale, seed):\n\n param_vals = {}\n for key in self.param_names:\n param_vals[key] = []\n ts_vals = []\n flags = []\n\n res_dict = self.run_trial(full_dataset)\n\n for (key, val) in res_dict[\"Parameters\"].items():\n param_vals[key].append(val)\n\n ts_vals.append(res_dict[\"TS\"])\n flags.append(res_dict[\"Flag\"])\n\n mem_use = str(\n float(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss) / 1.e6)\n logger.debug('Memory usage max: {0} (Gb)'.format(mem_use))\n\n results = {\n \"TS\": ts_vals,\n \"Parameters\": param_vals,\n \"Flags\": flags,\n }\n\n self.dump_results(results, scale, seed)\n return res_dict\n\n def simulate_and_run(self, scale, seed=None):\n if seed is None:\n seed = np.random.randint(low=0, high=99999999)\n self.set_random_seed(seed)\n full_dataset = self.prepare_dataset(scale, seed)\n return self.run_single(full_dataset, scale, seed)\n\n def run(self, n_trials, scale=1., seed=None):\n\n if seed is None:\n seed = int(random.random() * 10 ** 8)\n np.random.seed(seed)\n\n # param_vals = [[] for x in self.p0]\n param_vals = {}\n for key in self.param_names:\n param_vals[key] = []\n ts_vals = []\n flags = []\n\n logger.info(\"Generating {0} trials!\".format(n_trials))\n\n for i in range(int(n_trials)):\n\n res_dict = self.simulate_and_run(scale)\n\n for (key, val) in res_dict[\"Parameters\"].items():\n param_vals[key].append(val)\n\n ts_vals.append(res_dict[\"TS\"])\n flags.append(res_dict[\"Flag\"])\n\n n_inj = 0\n for season in self.seasons.keys():\n inj = self.get_injector(season)\n n_inj += np.sum(inj.n_exp[\"n_exp\"] * scale)\n\n logger.info(\"Injected with an expectation of {0} events.\".format(n_inj))\n\n logger.info(\"FIT RESULTS:\")\n\n for (key, param) in sorted(param_vals.items()):\n if len(param) > 0:\n logger.info(\"Parameter {0}: {1} {2} {3}\".format(key, np.mean(param),\n np.median(param), np.std(param)))\n logger.info(\"Test Statistic: {0} {1} {2}\".format(np.mean(ts_vals),\n np.median(ts_vals), np.std(ts_vals)))\n\n logger.info(\"FLAG STATISTICS:\")\n for i in sorted(np.unique(flags)):\n logger.info(\"Flag {0}:{1}\".format(i, flags.count(i)))\n\n results = {\n \"TS\": ts_vals,\n \"Parameters\": param_vals,\n \"Flags\": flags,\n }\n\n self.dump_results(results, scale, seed)\n self.dump_injection_values(scale)\n\n def make_season_weight(self, params, season):\n\n src = self.sources\n\n weight_scale = calculate_source_weight(src)\n\n # dist_weight = src[\"distance_mpc\"] ** -2\n # base_weight = src[\"base_weight\"]\n\n llh = self.get_likelihood(season.season_name)\n acc = []\n\n time_weights = []\n source_weights = []\n\n for source in src:\n time_weights.append(llh.sig_time_pdf.effective_injection_time(\n source))\n acc.append(llh.acceptance(source, params))\n source_weights.append(calculate_source_weight(source) /\n weight_scale)\n\n time_weights = np.array(time_weights)\n source_weights = np.array(source_weights)\n\n acc = np.array(acc).T[0]\n\n w = acc * time_weights\n w *= source_weights\n\n w = w[:, np.newaxis]\n\n return w\n\n def make_weight_matrix(self, params):\n\n # Creates a matrix fixing the fraction of the total signal that\n # is expected in each Source+Season pair. The matrix is\n # normalised to 1, so that for a given total n_s, the expectation\n # for the ith season for the jth source is given by:\n # n_exp = n_s * weight_matrix[i][j]\n\n weights_matrix = np.ones([len(self.seasons), len(self.sources)])\n\n for i, season in enumerate(self.seasons.values()):\n w = self.make_season_weight(params, season)\n\n for j, ind_w in enumerate(w):\n weights_matrix[i][j] = ind_w\n\n return weights_matrix\n\n def prepare_dataset(self, scale=1., seed=None):\n\n if seed is None:\n seed = int(random.random() * 10 ** 8)\n np.random.seed(seed)\n\n full_dataset = dict()\n\n for name in self.seasons.keys():\n full_dataset[name] = self.get_injector(name).create_dataset(\n scale, self.get_angular_error_modifier(name)\n )\n\n return full_dataset\n\n def trial_function(self, full_dataset):\n\n llh_functions = dict()\n n_all = dict()\n\n for name in self.seasons:\n dataset = full_dataset[name]\n llh_f = self.get_likelihood(name).create_llh_function(\n dataset, self.get_angular_error_modifier(name),\n self.make_season_weight\n )\n llh_functions[name] = llh_f\n n_all[name] = len(dataset)\n\n def f_final(raw_params):\n\n # If n_s is less than or equal to 0, set gamma to be 3.7 (equal to\n # atmospheric background). This is continuous at n_s=0, but fixes\n # relative weights of sources/seasons for negative n_s values.\n\n params = list(raw_params)\n\n if (len(params) > 1) and (params[0] < 0):\n params[1] = 3.7\n\n # Calculate relative contribution of each source/season\n\n weights_matrix = self.make_weight_matrix(params)\n weights_matrix /= np.sum(weights_matrix)\n\n # Having created the weight matrix, loops over each season of\n # data and evaluates the TS function for that season\n\n ts_val = 0\n for i, name in enumerate(self.seasons):\n w = weights_matrix[i][:, np.newaxis]\n ts_val += np.sum(llh_functions[name](params, w))\n\n return ts_val\n\n return f_final\n\n def scan_likelihood(self, scale=0., scan_2d=False):\n \"\"\"Generic wrapper to perform a likelihood scan a background scramble\n with an injection of signal given by scale.\n\n :param scale: Flux scale to inject\n \"\"\"\n\n res_dict = self.simulate_and_run(scale)\n\n res = res_dict[\"res\"]\n g = res_dict[\"f\"]\n\n bounds = list(self.bounds)\n\n if self.negative_n_s:\n bounds[0] = (-30, 30)\n\n # Scan 1D Likelihood\n\n plt.figure(figsize=(8, 4 + 2*len(self.p0)))\n\n u_ranges = []\n\n for i, bound in enumerate(bounds):\n ax = plt.subplot(len(self.p0), 1, 1 + i)\n\n best = list(res.x)\n min_llh = np.sum(float(g(best)))\n\n factor = 0.9\n\n if \"n_s\" in self.param_names[i]:\n\n best[i] = bound[1]\n\n while (g(best) > (min_llh + 5.0)):\n best[i] *= factor\n\n ur = min(bound[1], max(best[i], 0))\n\n else:\n ur = bound[1]\n\n u_ranges.append(ur)\n\n n_range = np.linspace(float(max(bound[0], -100)), ur, int(1e2))\n\n # n_range = np.linspace(-30, 30, 1e2)\n y = []\n\n for n in n_range:\n\n best[i] = n\n\n new = g(best)/2.0\n try:\n y.append(new[0][0])\n except IndexError:\n y.append(new)\n\n plt.plot(n_range, y - min(y))\n plt.xlabel(self.param_names[i])\n plt.ylabel(r\"$\\Delta \\log(\\mathcal{L}/\\mathcal{L}_{0})$\")\n\n logger.info(f\"PARAM: {self.param_names[i]}\")\n min_y = np.min(y)\n\n min_index = y.index(min_y)\n min_n = n_range[min_index]\n\n logger.info(f\"Minimum value of {min_y} at {min_n}\")\n\n logger.info(\"One Sigma interval between\")\n\n l_y = np.array(y[:min_index])\n try:\n l_y = min(l_y[l_y > (min_y + 0.5)])\n l_lim = n_range[y.index(l_y)]\n logger.info(l_lim)\n except ValueError:\n l_lim = min(n_range)\n logger.info(f\"<{l_lim}\")\n\n logger.info(\"and\")\n\n u_y = np.array(y[min_index:])\n try:\n u_y = min(u_y[u_y > (min_y + 0.5)])\n u_lim = n_range[y.index(u_y)]\n logger.info(u_lim)\n except ValueError:\n u_lim = max(n_range)\n logger.info(f\">{u_lim}\")\n\n ax.axvspan(l_lim, u_lim, facecolor=\"grey\",\n alpha=0.2)\n ax.set_ylim(bottom=0.0)\n\n path = plot_output_dir(self.name) + \"llh_scan.pdf\"\n\n title = os.path.basename(\n os.path.dirname(self.name[:-1])\n ).replace(\"_\", \" \") + \" Likelihood Scans\"\n\n plt.suptitle(title, y=1.02)\n\n try:\n os.makedirs(os.path.dirname(path))\n except OSError:\n pass\n\n plt.savefig(path)\n plt.close()\n\n logger.info(\"Saved to {0}\".format(path))\n\n # Scan 2D likelihood\n\n if np.logical_and(scan_2d, \"gamma\" in self.param_names):\n\n gamma_index = self.param_names.index(\"gamma\")\n\n gamma_bounds = bounds[gamma_index]\n\n x = np.linspace(gamma_bounds[0], gamma_bounds[1])\n\n mask = np.array([\"n_s\" in b for b in self.param_names])\n\n n_s_bounds = np.array(self.bounds)[mask]\n\n for j, bound in enumerate(n_s_bounds):\n best = list(res.x)\n plt.figure(figsize=(5.85, 3.6154988341868854))\n ax = plt.subplot(111)\n\n index = np.arange(len(self.param_names))[mask][j]\n\n plt.xlabel(r\"Spectral Index ($\\gamma$)\")\n\n param_name = np.array(self.param_names)[mask][j]\n ylabel = 'n$_{\\mathrm{signal}}$' if param_name == 'n_s' else param_name\n plt.ylabel(ylabel)\n\n y = np.linspace(\n float(max(bound[0], -100)),\n np.array(u_ranges)[index],\n int(1e2)\n )\n\n X, Y = np.meshgrid(x, y[::-1])\n Z = []\n\n for gamma in x:\n best[gamma_index] = gamma\n z_row = []\n\n for n in y:\n best[index] = n\n z_row.append((g(best) - g(res.x))/2.0)\n\n Z.append(z_row[::-1])\n\n Z = np.array(Z).T\n\n levels = 0.5 * np.array([1.0, 2.0, 5.0])**2\n\n N = 2560\n mmax = np.max(Z)\n mmin = np.min(Z)\n break_ind = int(round(N / (1 + mmax / abs(mmin))))\n top = cm.get_cmap('gray')\n bottom = cm.get_cmap('jet_r', N)\n colorlist = np.empty((N, 4))\n colorlist[break_ind:] = bottom(np.linspace(0, 1, N - break_ind))\n colorlist[:break_ind] = top(np.linspace(1, 0, break_ind))\n cmap = ListedColormap(colorlist)\n norm = Normalize(vmin=mmin, vmax=mmax, clip=True)\n\n plt.imshow(Z, aspect=\"auto\", cmap=cmap, norm=norm,\n extent=(x[0], x[-1], y[0], y[-1]),\n interpolation='bilinear')\n\n cbar = plt.colorbar()\n CS = ax.contour(X, Y, Z, levels=levels, colors=\"white\")\n\n fmt = {}\n strs = [r'1$\\sigma$', r'2$\\sigma$', r'5$\\sigma$']\n for l, s in zip(CS.levels, strs):\n fmt[l] = s\n\n try:\n ax.clabel(CS, fmt=fmt, inline=1, fontsize=10, levels=levels,\n colors=\"white\")\n except TypeError:\n ax.clabel(CS, levels, fmt=fmt, inline=1, fontsize=10, #levels=levels,\n colors=\"white\")\n\n ax.set_xlim((min(x), max(x)))\n ax.set_ylim((min(y), max(y)))\n\n cbar.set_label(r\"$\\Delta \\log(\\mathcal{L}/\\mathcal{L}_{0})$\",\n rotation=90)\n\n path = plot_output_dir(self.name) + (param_name + \"_\")[4:] + \\\n \"contour_scan.pdf\"\n\n title = os.path.basename(\n os.path.dirname(self.name[:-1])\n ).replace(\"_\", \" \") + \" Contour Scans\"\n\n plt.scatter(res.x[gamma_index], res.x[index], color=\"white\",\n marker=\"*\")\n\n plt.grid(color=\"white\", linestyle=\"--\", alpha=0.5)\n\n #plt.suptitle(title)\n plt.tight_layout()\n plt.savefig(path)\n plt.close()\n\n logger.info(\"Saved to {0}\".format(path))\n\n return res_dict\n\n def neutrino_lightcurve(self, seed=None):\n\n full_dataset = self.prepare_dataset(30., seed)\n\n for source in self.sources:\n\n f, (ax0, ax1) = plt.subplots(1, 2,\n gridspec_kw={'width_ratios': [19, 1]})\n\n logE = []\n time = []\n sig = []\n\n for season in self.seasons:\n\n # Generate a scrambled dataset, and save it to the datasets\n # dictionary. Loads the llh for the season.\n data = full_dataset[season]\n llh = self.get_likelihood(season)\n\n mask = llh.select_spatially_coincident_data(data, [source])\n\n spatial_coincident_data = data[mask]\n\n t_mask = np.logical_and(\n np.greater(\n spatial_coincident_data[\"time\"],\n llh.sig_time_pdf.sig_t0(source)),\n np.less(\n spatial_coincident_data[\"time\"],\n llh.sig_time_pdf.sig_t1(source))\n )\n\n coincident_data = spatial_coincident_data[t_mask]\n\n SoB = llh.estimate_significance(coincident_data, source)\n\n mask = SoB > 1.\n\n y = np.log10(SoB[mask])\n\n if np.sum(mask) > 0:\n\n logE += list(10 ** (coincident_data[\"logE\"][mask] - 3))\n time += list(coincident_data[\"time\"][mask])\n sig += list(y)\n\n if llh.sig_time_pdf.sig_t0(source) > llh.sig_time_pdf.t0:\n\n ax0.axvline(llh.sig_time_pdf.sig_t0(source), color=\"k\", linestyle=\"--\", alpha=0.5)\n\n if llh.sig_time_pdf.sig_t1(source) < llh.sig_time_pdf.t1:\n\n ax0.axvline(llh.sig_time_pdf.sig_t1(source), color=\"k\", linestyle=\"--\", alpha=0.5)\n\n cmap = cm.get_cmap('jet')\n norm = mpl.colors.Normalize(vmin=min(logE), vmax=max(logE),\n clip=True)\n m = cm.ScalarMappable(norm=norm, cmap=cmap)\n\n for i, val in enumerate(sig):\n x = time[i]\n ax0.plot([x, x], [0, val], color=m.to_rgba(logE[i]))\n\n if hasattr(self, \"res_dict\"):\n params = self.res_dict[\"Parameters\"]\n if len(params) > 1:\n ax0.axvspan(\n params[f\"t_start ({source['source_name']})\"],\n params[f\"t_end ({source['source_name']})\"],\n facecolor=\"grey\",\n alpha=0.2\n )\n ax0.set_xlabel(\"Arrival Time (MJD)\")\n ax0.set_ylabel(\"Log(Signal/Background)\")\n\n cb1 = mpl.colorbar.ColorbarBase(ax1, cmap=cmap,\n norm=norm,\n orientation='vertical')\n ax1.set_ylabel(\"Muon Energy Proxy (TeV)\")\n\n ax0.set_ylim(bottom=0)\n # plt.tight_layout()\n\n path = f\"{plot_output_dir(self.name)}neutrino_lightcurve.pdf\"\n\n try:\n os.makedirs(os.path.dirname(path))\n except OSError:\n pass\n\n logger.info(f\"Saving to {path}\")\n\n plt.savefig(path)\n plt.close()\n\n @staticmethod\n def return_parameter_info(mh_dict):\n params = [[1.], [(0, 1000.)], [\"n_s\"]]\n\n params = [\n params[i] + x for i, x in enumerate(\n LLH.get_parameters(mh_dict[\"llh_dict\"])\n )\n ]\n\n return params[0], params[1], params[2]\n\n def return_injected_parameters(self, scale):\n\n n_inj = 0.\n for season_name in self.seasons.keys():\n n_inj += np.sum(self.get_injector(season_name).n_exp[\"n_exp\"] * scale)\n\n inj_params = {\n \"n_s\": n_inj\n }\n inj_params.update(LLH.get_injected_parameters(self.mh_dict))\n\n return inj_params\n\n\n@MinimisationHandler.register_subclass('large_catalogue')\nclass LargeCatalogueMinimisationHandler(FixedWeightMinimisationHandler):\n \"\"\"Class to perform generic minimisations using a 'fixed weights' matrix.\n However, unlike the 'fixed_weight' class, it is optimised for large\n numbers of sources. It uses a custom 'LowMemoryInjector' which is slower\n but much less burdensome for memory.\n \"\"\"\n\n compatible_llh = [\"standard_matrix\"]\n compatible_negative_n_s = False\n\n def __init__(self, mh_dict):\n FixedWeightMinimisationHandler.__init__(self, mh_dict)\n\n if self.param_names != [\"n_s\", \"gamma\"]:\n raise Exception(\"{0} parameters are given, when ['n_s','gamma']\"\n \"was expected\".format(self.param_names))\n\n def add_injector(self, season, sources):\n\n if \"injector_name\" in self.inj_dict.keys():\n if self.inj_dict[\"injector_name\"] not in LargeCatalogueMinimisationHandler.compatible_injectors:\n raise Exception(f\"'{self.inj_dict['injector_name']}' was provided as injection_name. \"\n f\"Please use any of {LargeCatalogueMinimisationHandler.compatible_injectors}.\")\n else:\n self.inj_dict[\"injector_name\"] = \"low_memory_injector\"\n\n return season.make_injector(sources, **self.inj_dict)\n\n\n@MinimisationHandler.register_subclass('fit_weights')\nclass FitWeightMinimisationHandler(FixedWeightMinimisationHandler):\n compatible_llh = [\"spatial\", \"fixed_energy\", \"standard\"]\n compatible_negative_n_s = False\n\n def __init__(self, mh_dict):\n FixedWeightMinimisationHandler.__init__(self, mh_dict)\n\n if self.negative_n_s:\n raise ValueError(\n \"Attempted to mix fitting weights with negative n_s.\")\n\n def trial_function(self, full_dataset):\n\n llh_functions = dict()\n n_all = dict()\n\n for name in self.seasons:\n dataset = full_dataset[name]\n llh_f = self.get_likelihood(name).create_llh_function(\n dataset, self.get_angular_error_modifier(name),\n self.make_season_weight\n )\n llh_functions[name] = llh_f\n n_all[name] = len(dataset)\n\n def f_final(params):\n\n # Creates a matrix fixing the fraction of the total signal that\n # is expected in each Source+Season pair. The matrix is\n # normalised to 1, so that for a given total n_s, the expectation\n # for the ith season for the jth source is given by:\n # n_exp = n_s * weight_matrix[i][j]\n\n weights_matrix = self.make_weight_matrix(params)\n\n for i, row in enumerate(weights_matrix.T):\n if np.sum(row) > 0:\n row /= np.sum(row)\n\n # Having created the weight matrix, loops over each season of\n # data and evaluates the TS function for that season\n\n ts_val = 0\n for i, name in enumerate(self.seasons):\n w = weights_matrix[i][:, np.newaxis]\n ts_val += llh_functions[name](params, w)\n\n return ts_val\n\n return f_final\n\n @staticmethod\n def source_param_name(source):\n return \"n_s ({0})\".format(source[\"source_name\"])\n\n @staticmethod\n def return_parameter_info(mh_dict):\n sources = load_catalogue(mh_dict[\"catalogue\"])\n p0 = [1. for _ in sources]\n bounds = [(0., 1000.) for _ in sources]\n names = [FitWeightMinimisationHandler.source_param_name(x)\n for x in sources]\n params = [p0, bounds, names]\n\n params = [\n params[i] + x for i, x in enumerate(\n LLH.get_parameters(mh_dict[\"llh_dict\"])\n )\n ]\n\n return params[0], params[1], params[2]\n\n def return_injected_parameters(self, scale):\n\n inj_params = {}\n\n for source in self.sources:\n name = source[\"source_name\"]\n key = self.source_param_name(source)\n n_inj = 0\n for season_name in self.seasons.keys():\n try:\n names = [x[0] for x in self.get_injector(season_name).n_exp[\"source_name\"]]\n if isinstance(names[0], bytes):\n names = [x.decode() for x in names]\n\n if isinstance(name, bytes):\n name = name.decode()\n\n mask = np.array([x == name for x in names])\n\n n_inj += np.sum(self.get_injector(season_name).n_exp[\"n_exp\"][mask] * scale)\n\n # If source not overlapping season, will not be in dict\n except KeyError:\n pass\n\n inj_params[key] = n_inj\n\n inj_params.update(LLH.get_injected_parameters(self.mh_dict))\n\n return inj_params\n\n\n@MinimisationHandler.register_subclass(\"flare\")\nclass FlareMinimisationHandler(FixedWeightMinimisationHandler):\n\n compatible_llh = [\"spatial\", \"fixed_energy\", \"standard\"]\n compatible_negative_n_s = False\n\n def __init__(self, mh_dict):\n MinimisationHandler.__init__(self, mh_dict)\n # For each season, we create an independent likelihood, using the\n # source list along with the sets of energy/time\n # PDFs provided in llh_kwargs.\n for name in self.seasons:\n\n tpdf = self.get_likelihood(name).sig_time_pdf\n\n # Check to ensure that no weird new untested time PDF is used\n # with the flare search method, since uniform time PDFs over the\n # duration of a given flare is an assumption baked into the PDF\n # construction. New time PDFs could be added, but the Flare class\n # + LLH would need to be tested first and probably modified.\n\n if np.sum([isinstance(tpdf, x) for x in [Box, Steady]]) == 0:\n raise ValueError(\"Attempting to use a time PDF that is not a \"\n \"Box or a Steady time PDF class. The flare \"\n \"search method is only compatible with \"\n \"time PDFs that are uniform over \"\n \"fixed periods.\")\n\n def run_trial(self, full_dataset):\n\n datasets = dict()\n\n livetime_calcs = dict()\n\n time_dict = {\n \"time_pdf_name\": \"custom_source_box\"\n }\n\n results = {\n \"Parameters\": dict(),\n \"Flag\": []\n }\n\n # Loop over each data season\n\n for (name, season) in self.seasons.items():\n\n # Generate a scrambled dataset, and save it to the datasets\n # dictionary. Loads the llh for the season.\n\n data = full_dataset[name]\n llh = self.get_likelihood(name)\n\n livetime_calcs[name] = TimePDF.create(time_dict, season.get_time_pdf())\n\n # Loops over each source in catalogue\n\n for source in self.sources:\n\n # Identify spatially- and temporally-coincident data\n\n mask = llh.select_spatially_coincident_data(data, [source])\n spatial_coincident_data = data[mask]\n\n t_mask = np.logical_and(\n np.greater(\n spatial_coincident_data[\"time\"],\n llh.sig_time_pdf.sig_t0(source)),\n np.less(\n spatial_coincident_data[\"time\"],\n llh.sig_time_pdf.sig_t1(source))\n )\n\n coincident_data = spatial_coincident_data[t_mask]\n\n # If there are events in the window...\n\n if len(coincident_data) > 0:\n\n # Creates empty dictionary to save info\n\n source_name = source[\"source_name\"]\n if source_name not in list(datasets.keys()):\n datasets[source_name] = dict()\n\n new_entry = {\n \"season_name\": season.season_name\n }\n new_entry[\"Coincident Data\"] = coincident_data\n new_entry[\"Start (MJD)\"] = llh.sig_time_pdf.t0\n new_entry[\"End (MJD)\"] = llh.sig_time_pdf.t1\n\n # Identify significant events (S/B > 1)\n\n significant = llh.find_significant_events(\n coincident_data, source)\n\n new_entry[\"Significant Times\"] = significant[\"time\"]\n\n new_entry[\"N_all\"] = len(data)\n\n datasets[source_name][name] = new_entry\n\n stacked_ts = 0.0\n\n # Minimisation of each source\n\n for (source, source_dict) in datasets.items():\n\n src = self.sources[self.sources[\"source_name\"] == source][0]\n p0, bounds, names = self.source_fit_parameter_info(self.mh_dict,\n src)\n\n # Create a full list of all significant times\n\n all_times = []\n n_tot = 0\n for season_dict in source_dict.values():\n new_times = season_dict[\"Significant Times\"]\n all_times.extend(new_times)\n n_tot += len(season_dict[\"Coincident Data\"])\n\n all_times = np.array(sorted(all_times))\n\n # Minimum flare duration (days)\n min_flare = 0.25\n # Conversion to seconds\n min_flare *= 60 * 60 * 24\n\n # Length of search window in livetime\n\n search_window = np.sum([\n self.get_likelihood(x).sig_time_pdf.effective_injection_time(src)\n for x in self.seasons.keys()]\n )\n\n # If a maximum flare length is specified, sets that here\n\n if \"max_flare\" in list(self.llh_dict[\"llh_sig_time_pdf\"].keys()):\n # Maximum flare given in days, here converted to seconds\n max_flare = self.llh_dict[\"llh_sig_time_pdf\"][\"max_flare\"] * (\n 60 * 60 * 24\n )\n else:\n max_flare = search_window\n\n # Loop over all flares, and check which combinations have a\n # flare length between the maximum and minimum values\n\n pairs = []\n\n # print \"There are\", len(all_times), \"significant neutrinos\",\n # print \"out of\", n_tot, \"neutrinos\"\n\n for x in all_times:\n for y in all_times:\n if y > x:\n pairs.append((x, y))\n\n # If there is are no pairs meeting this criteria, skip\n\n if len(pairs) == 0:\n logger.debug(\"Continuing because no pairs\")\n continue\n\n all_res = []\n all_ts = []\n all_f = []\n all_pairs = []\n\n # Loop over each possible significant neutrino pair\n\n for i, pair in enumerate(pairs):\n t_start = pair[0]\n t_end = pair[1]\n\n # Calculate the length of the neutrino flare in livetime\n\n flare_time = np.array(\n (t_start, t_end),\n dtype=[\n (\"start_time_mjd\", np.float),\n (\"end_time_mjd\", np.float),\n ]\n )\n\n flare_length = np.sum([\n time_pdf.effective_injection_time(flare_time)\n for time_pdf in livetime_calcs.values()]\n )\n\n # If the flare is between the minimum and maximum length\n\n if flare_length < min_flare:\n continue\n elif flare_length > max_flare:\n continue\n\n\n # Marginalisation term is length of flare in livetime\n # divided by max flare length in livetime. Accounts\n # for the additional short flares that can be fitted\n # into a given window\n\n overall_marginalisation = flare_length / max_flare\n\n # Each flare is evaluated accounting for the\n # background on the sky (the non-coincident\n # data), which is given by the number of\n # neutrinos on the sky during the given\n # flare. (NOTE THAT IT IS NOT EQUAL TO THE\n # NUMBER OF NEUTRINOS IN THE SKY OVER THE\n # ENTIRE SEARCH WINDOW)\n\n n_all = np.sum([np.sum(~np.logical_or(\n np.less(data[\"time\"], t_start),\n np.greater(data[\"time\"], t_end)))\n for data in full_dataset.values()])\n\n llhs = dict()\n\n # Loop over data seasons\n\n for (name, season_dict) in sorted(source_dict.items()):\n\n llh = self.get_likelihood(name)\n\n # Check that flare overlaps with season\n\n inj_time = llh.sig_time_pdf.effective_injection_time(\n flare_time\n )\n\n if not inj_time > 0:\n continue\n\n coincident_data = season_dict[\"Coincident Data\"]\n\n data = full_dataset[name]\n\n n_season = np.sum(~np.logical_or(\n np.less(data[\"time\"], t_start),\n np.greater(data[\"time\"], t_end)))\n\n # Removes non-coincident data\n\n flare_veto = np.logical_or(\n np.less(coincident_data[\"time\"], t_start),\n np.greater(coincident_data[\"time\"], t_end)\n )\n\n # Checks to make sure that there are\n # neutrinos in the sky at all. There should\n # be, due to the definition of the flare window.\n\n if n_all > 0:\n pass\n else:\n raise Exception(\"Events are leaking somehow!\")\n\n # Creates the likelihood function for the flare\n\n flare_f = llh.create_flare_llh_function(\n coincident_data, flare_veto, n_all, src, n_season,\n self.get_angular_error_modifier(season_dict[\"season_name\"])\n )\n\n llhs[season_dict[\"season_name\"]] = {\n \"f\": flare_f,\n \"flare length\": flare_length\n }\n\n # From here, we have normal minimisation behaviour\n\n def f_final(params):\n\n # Marginalisation is done once, not per-season\n\n ts = 2 * np.log(overall_marginalisation)\n\n for llh_dict in llhs.values():\n ts += llh_dict[\"f\"](params)\n\n return -ts\n\n res = scipy.optimize.fmin_l_bfgs_b(\n f_final, p0, bounds=bounds,\n approx_grad=True)\n\n all_res.append(res)\n all_ts.append(-res[1])\n all_f.append(f_final)\n all_pairs.append(pair)\n\n max_ts = max(all_ts)\n stacked_ts += max_ts\n index = all_ts.index(max_ts)\n\n best_start = all_pairs[index][0]\n best_end = all_pairs[index][1]\n\n best_time = np.array(\n (best_start, best_end),\n dtype=[\n (\"start_time_mjd\", np.float),\n (\"end_time_mjd\", np.float),\n ]\n )\n\n best_length = np.sum([\n time_pdf.effective_injection_time(best_time)\n for time_pdf in livetime_calcs.values()]\n ) / (60 * 60 * 24)\n\n best = [x for x in all_res[index][0]] + [\n best_start, best_end, best_length\n ]\n\n p0, bounds, names = self.source_parameter_info(self.mh_dict, src)\n\n names += [self.source_param_name(x, src)\n for x in [\"t_start\", \"t_end\", \"length\"]]\n\n for i, x in enumerate(best):\n key = names[i]\n results[\"Parameters\"][key] = x\n\n results[\"Flag\"] += [all_res[index][2][\"warnflag\"]]\n\n del all_res, all_f, all_times\n\n results[\"TS\"] = stacked_ts\n\n del datasets, full_dataset, livetime_calcs\n\n return results\n\n @staticmethod\n def source_param_name(param, source):\n return param + \" (\" + str(source[\"source_name\"]) + \")\"\n\n\n @staticmethod\n def source_fit_parameter_info(mh_dict, source):\n\n p0 = [1.]\n bounds = [(0., 1000.)]\n names = [FlareMinimisationHandler.source_param_name(\"n_s\", source)]\n\n llh_p0, llh_bounds, llh_names = LLH.get_parameters(\n mh_dict[\"llh_dict\"])\n\n p0 += llh_p0\n bounds += llh_bounds\n names += [FlareMinimisationHandler.source_param_name(x, source)\n for x in llh_names]\n\n return p0, bounds, names\n\n @staticmethod\n def source_parameter_info(mh_dict, source):\n\n p0, bounds, names = \\\n FlareMinimisationHandler.source_fit_parameter_info(\n mh_dict, source\n )\n\n p0 += [np.nan for _ in range(3)]\n bounds += [(np.nan, np.nan)for _ in range(3)]\n names += [FlareMinimisationHandler.source_param_name(x, source)\n for x in [\"t_start\", \"t_end\", \"length\"]]\n\n return p0, bounds, names\n\n @staticmethod\n def return_parameter_info(mh_dict):\n p0, bounds, names = [], [], []\n sources = load_catalogue(mh_dict[\"catalogue\"])\n for source in sources:\n res = FlareMinimisationHandler.source_parameter_info(\n mh_dict, source\n )\n\n for i, x in enumerate(res):\n [p0, bounds, names][i] += x\n\n return p0, bounds, names\n\n def return_injected_parameters(self, scale):\n\n inj_params = {}\n\n for source in self.sources:\n name = source[\"source_name\"]\n key = self.source_param_name(\"n_s\", source)\n n_inj = 0\n\n for season_name in self.seasons.keys():\n\n try:\n\n names = [x[0] for x in self.get_injector(season_name).n_exp[\"source_name\"]]\n\n if isinstance(names[0], bytes):\n names = [x.decode() for x in names]\n\n if isinstance(name, bytes):\n name = name.decode()\n\n mask = np.array([x == name for x in names])\n\n n_inj += np.sum(self.get_injector(season_name).n_exp[\"n_exp\"][mask] * scale)\n\n # If source not overlapping season, will not be in dict\n except KeyError:\n pass\n\n inj_params[key] = n_inj\n\n ts = min([self.get_injector(season_name).sig_time_pdf.sig_t0(source)\n for season_name in self.seasons.keys()])\n te = max([self.get_injector(season_name).sig_time_pdf.sig_t1(source)\n for season_name in self.seasons.keys()])\n\n inj_params[self.source_param_name(\"length\", source)] = te - ts\n\n if self.time_smear:\n inj_params[self.source_param_name(\"t_start\", source)] = np.nan\n inj_params[self.source_param_name(\"t_end\", source)] = np.nan\n else:\n inj_params[self.source_param_name(\"t_start\", source)] = ts\n inj_params[self.source_param_name(\"t_end\", source)] = te\n\n for (key, val) in LLH.get_injected_parameters(\n self.mh_dict).items():\n inj_params[self.source_param_name(key, source)] = val\n\n return inj_params\n\n def add_likelihood(self, season):\n return generate_dynamic_flare_class(season, self.sources, self.llh_dict)\n\nif __name__ == '__main__':\n from multiprocessing import Pool\n\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-f\", \"--file\", help=\"Path for analysis pkl_file\")\n parser.add_argument(\"-n\", \"--n_cpu\", default=2)\n cfg = parser.parse_args()\n\n with open(cfg.file, \"rb\") as f:\n mh_dict = Pickle.load(f)\n\n mh = MinimisationHandler.create(mh_dict)\n\n scales, seeds = mh.trial_params(mh_dict[\"scale\"], n_steps=mh_dict[\"n_steps\"])\n\n if \"fixed_scale\" in list(mh_dict.keys()):\n scale = [mh_dict[\"fixed_scale\"] for _ in seeds]\n n_trials = int(float(mh_dict[\"n_trials\"]) / float(cfg.n_cpu))\n else:\n n_trials = int(mh_dict[\"n_trials\"])\n\n trials = [mh_dict[\"n_trials\"] for _ in seeds]\n loop_args = zip(trials, scales, seeds)\n\n logger.info(\"N CPUs:{0}\".format(cfg.n_cpu))\n\n with Pool(int(cfg.n_cpu)) as p:\n p.starmap(mh.run, loop_args)\n", "meta": {"hexsha": "b22f67ea98f9187de8cbbe9ecf774c78242ace39", "size": 53628, "ext": "py", "lang": "Python", "max_stars_repo_path": "flarestack/core/minimisation.py", "max_stars_repo_name": "Raimer/flarestack", "max_stars_repo_head_hexsha": "60659d368db93ead7b53addf3af9f1e8ac3a52bc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-04-19T06:26:03.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-19T06:26:03.000Z", "max_issues_repo_path": "flarestack/core/minimisation.py", "max_issues_repo_name": "Raimer/flarestack", "max_issues_repo_head_hexsha": "60659d368db93ead7b53addf3af9f1e8ac3a52bc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "flarestack/core/minimisation.py", "max_forks_repo_name": "Raimer/flarestack", "max_forks_repo_head_hexsha": "60659d368db93ead7b53addf3af9f1e8ac3a52bc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.7799511002, "max_line_length": 111, "alphanum_fraction": 0.5489110166, "include": true, "reason": "import numpy,import scipy", "num_tokens": 11797, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6001883449573377, "lm_q2_score": 0.3242354055108441, "lm_q1q2_score": 0.1946023114101248}} {"text": "import os\nfrom functools import lru_cache\nimport warnings\nimport numpy as np\nfrom astropy.utils.data import download_file\nfrom astropy.io.votable import parse,exceptions\nimport astropy.units as u\nfrom . import spectrum\nfrom . import filter_info\nfrom . import utils\nfrom . import config as cfg\n\n# ignore warnings about SVO filter votables\nwarnings.simplefilter('ignore', exceptions.W42)\n\nc_micron = u.micron.to(u.Hz,equivalencies=u.spectral())\n\ndef common_x(x1,y1,x2,y2):\n \"\"\"Interpolate two y arrays to a single common x array\"\"\"\n if len(x1) == len(x2):\n if np.all( np.equal(x1,x2) ):\n _,srt = np.unique(x1,return_index=True)\n return (x1[srt],y1[srt],y2[srt])\n xall = np.append(x1,x2)\n xmin = np.max([np.min(x1),np.min(x2)])\n xmax = np.min([np.max(x1),np.max(x2)])\n keep = (xall >= xmin) & ( xall <= xmax)\n if np.any(keep) == False:\n raise utils.SdfError(\"x arrays don't overlap {} to {} and {} to {}\".format(\n np.min(x1),np.max(x1),np.min(x2),np.max(x2)))\n x = np.unique( xall[keep] )\n srt = np.argsort(x1)\n y1 = np.interp(x,x1[srt],y1[srt])\n srt = np.argsort(x2)\n y2 = np.interp(x,x2[srt],y2[srt])\n return (x,y1,y2)\n \n\nclass Filter(object):\n \"\"\"Filter class to use for synthetic photometry\n\n A good primer on filter responses is Appendix A 2012PASP..124..140B.\n The key point is that photon-counting is equivalent to \n energy-integration (A13), so synthetic photometry can always be done\n with the same equation if the filter responses are changed \n accordingly. A quantum-efficiency-based response is S, and \n S'=lambda.S is the energy-integrating equivalent, which can be\n integrated directly (F_lambda.S'.dlambda, A11). For 2MASS \n multiplication by lambda was done already (2003AJ....126.1090C), but\n this is not always the case so must be checked for each filter, and\n photon-counting responses converted to energy-integrating.\n\n We also need to know the reference spectrum to do synthetic \n photometry in systems where the flux density is given at a specific\n (e.g. mean) wavelength. This is commonly the case for IR photometry,\n but not in the optical (e.g. see appendix of 2011AJ....141..173B).\n It is also good to know how that reference wavelength was derived,\n but it can also be taken as a number. This correction converts the\n measurement (also the value that the reference spectrum would have\n at this wavelength) to the value the true spectrum must have at this\n wavelength in order to reproduce the observed signal. The most\n common reference spectrum is nu.F_nu=const, but others are also used\n (e.g. 10,000K blackbody for MIPS).\n \n Filter information comes from the filter_info.py file, all filters,\n colours, indices etc. need to be named as keys to the filters \n dictionary that comes from compiliing that file, otherwise they will\n not be computed in the models.\n \n A zero point offset of zero is set by default.\n \n \"\"\"\n\n # this needs to return all desired filters, colours, and indices\n all = list(filter_info.filters.keys())\n \n def __init__(self,name=None,system=None,nu_hz=None,fileloc=None,\n response=None,response_type=None,\n zero_point=None,zero_point_offset=None,\n measurement_calibration=None,\n magnitude_system=None,ref_wavelength=None,ref_nu_hz=None,\n ref_spectrum=None,cc_denom=None,Af_Av=None):\n self.name = name\n self.nu_hz = nu_hz\n self.response = response\n self.response_type = response_type\n self.magnitude_system = magnitude_system\n self.zero_point = zero_point\n self.zero_point_offset = zero_point_offset\n self.measurement_calibration = measurement_calibration\n self.ref_wavelength = ref_wavelength\n self.ref_nu_hz = ref_nu_hz\n self.ref_spectrum = ref_spectrum\n self.cc_denom = cc_denom\n self.Af_Av = Af_Av\n\n\n @classmethod\n def svo_get(cls,name):\n \"\"\"Get response and details for a filter from Spanish VO\n \n Other properties still need to be set \"by hand\", as this\n service doesn't provide either the reference spectrum or\n wavelength. It doesn't appear that their detector type is\n anything other than energy counting, so any conversion\n between the response the and \"RSR\" [lambda.R(lambda)] also\n needs to be figured out manually. All this is done in\n filter_info.py\n \"\"\"\n \n self = cls()\n \n # try loading from xml file in filter directory\n # remove '/' from SVO names\n self.fileloc = os.path.dirname(os.path.abspath(__file__))+ \\\n '/data/filters/'+name.replace('/','.')+'.xml'\n if os.path.exists(self.fileloc):\n votable = parse(self.fileloc)\n else:\n\n # get the filter, either from url or cache, if we want something\n # other than Vega use the PhotCalID in the name given\n if 'PhotCalID' in name:\n url = \"http://svo2.cab.inta-csic.es/theory/fps3/fps.php?\"+name\n else:\n url = \"http://svo2.cab.inta-csic.es/theory/fps3/fps.php?ID=\"+name\n loc = download_file(url,cache=True)\n \n # open the file and save to filters folder for posterity\n votable = parse(loc)\n votable.to_xml(self.fileloc)\n \n # grab the filter name\n name_field = votable.get_field_by_id('filterID')\n if isinstance(name_field.value, bytes):\n self.name = name_field.value.decode()\n else:\n self.name = name_field.value\n \n # mean wavelength\n wmean = votable.get_field_by_id('WavelengthMean')\n self.ref_wavelength = wmean.value * wmean.unit\n \n # zero point in Jy, and offset in mag\n zp = votable.get_field_by_id('ZeroPoint')\n self.zero_point = (zp.value * zp.unit).to('Jy').value\n self.zero_point_offset = 0.0\n \n # magnitude system\n sys = votable.get_field_by_id('MagSys')\n if isinstance(sys.value, bytes):\n self.magnitude_system = sys.value.decode()\n else:\n self.magnitude_system = sys.value\n \n # and the response, assuming there is no masking [hence filled()]\n vo_filt_table = votable.get_first_table()\n filt_table = vo_filt_table.to_table().filled()\n wav = filt_table['Wavelength']\n self.nu_hz = np.array( wav.to('Hz',equivalencies=u.spectral()) )\n self.response = np.array( filt_table['Transmission'] )\n return self\n\n\n @lru_cache(maxsize=128)\n def get_memo(name):\n \"\"\"Get response and details for a filter (via filter_info.py)\n \n This function is memoized for speed, the maxsize just needs\n to be larger than the number of filters.\n \"\"\"\n\n f = filter_info.filters\n\n # create (relatively narrow) generic filters\n if name[0:3] == 'WAV':\n self = Filter()\n self.name = name\n self.response_type = 'energy'\n cwav = float(name[3:])\n wave = np.arange( cwav*0.95, cwav*1.05, cwav/100. )\n self.nu_hz = c_micron / wave\n self.response = np.ones( len(wave) )\n elif name not in f:\n raise KeyError(\"Filter {} not in filter_info\".format(name))\n else:\n if 'svo_name' in f[name]:\n self = Filter.svo_get(f[name]['svo_name'])\n else:\n self = Filter()\n if f[name]['wav_micron'] is not None:\n self.nu_hz = c_micron / np.array(f[name]['wav_micron'])\n if f[name]['response'] is not None:\n self.response = np.array(f[name]['response'])\n\n self.name = name\n \n # fill fields from filter_info, these override SVO\n if 'magnitude_system' in f[name]:\n if f[name]['magnitude_system'] is not None:\n self.magnitude_system = f[name]['magnitude_system']\n if 'zero_point' in f[name]:\n if f[name]['zero_point'] is not None:\n self.zero_point = f[name]['zero_point']\n if 'zero_point_offset' in f[name]:\n if f[name]['zero_point_offset'] is not None:\n self.zero_point_offset = f[name]['zero_point_offset']\n if 'measurement_calibration' in f[name]:\n if f[name]['measurement_calibration'] is not None:\n self.measurement_calibration = f[name]['measurement_calibration']\n if 'ref_wavelength' in f[name]:\n if f[name]['ref_wavelength'] is not None:\n self.ref_wavelength = f[name]['ref_wavelength']\n if 'ref_spectrum' in f[name]:\n if f[name]['ref_spectrum'] is not None:\n self.ref_spectrum = f[name]['ref_spectrum']\n if 'response_type' in f[name]:\n if f[name]['response_type'] is not None:\n self.response_type = f[name]['response_type']\n \n # convert photon counting responses to energy\n if 'photon' in self.response_type:\n if self.nu_hz is not None and self.response is not None:\n self.response /= self.nu_hz\n self.response_type = 'photon -> energy'\n\n # sort, normalise, and fill\n if self.nu_hz is not None:\n self.sort()\n self.normalise_response()\n self.fill_mean_wavelength()\n self.fill_ref_nu_hz()\n self.fill_cc_denom()\n \n # compute zero-point in Vega system\n if self.magnitude_system == 'Vega':\n v = spectrum.ObsSpectrum.vega_stis()\n if (np.min(v.nu_hz) < np.min(self.nu_hz) and\n np.max(v.nu_hz) > np.min(self.nu_hz)):\n zp = self.synthphot(v)\n self.zero_point = zp[0]\n else:\n self.zero_point = None\n\n # or for AB\n elif self.magnitude_system == 'AB':\n self.zero_point = 3631.0\n\n return self\n\n\n def get_with_zpo(name,zpo_file='/Users/grant/astro/projects/sdf/sdf/calibration/zpos.txt'):\n \"\"\"Get filter, using ZPO from file.\"\"\"\n \n f = Filter.get_memo(name)\n t = np.genfromtxt(zpo_file,dtype=None)\n fs = np.array([filt.decode() for filt in t[0]])\n if name in fs:\n f.zero_point_offset = float( t[1][ fs == name ][0] )\n\n return f\n \n \n # decide what get() points to\n get = get_memo\n \n\n def mag2flux(self,mag):\n \"\"\"Convert magnitudes to flux density.\n\n Use zero point associated with this filter to convert a given\n magnitude to flux density. Units returned are those associated\n with the zero point.\n \"\"\"\n\n if self.zero_point is None or self.zero_point_offset is None:\n raise utils.SdfError(\"no zero point or offset for filter {})\".\n format(self.name))\n return self.zero_point * 10**(-0.4*(mag-self.zero_point_offset))\n \n \n def flux2mag(self,flux):\n \"\"\"Convert flux density to magnitudes.\n \n Use zero point associated with this filter to convert a given\n flux density to magnitude. Units returned are those associated\n with the zero point.\n \"\"\"\n \n if self.zero_point is None or self.zero_point_offset is None:\n raise utils.SdfError(\"no zero point or offset for filter {})\".\\\n format(self.name))\n return self.zero_point_offset \\\n - 2.5 * np.log10( flux / self.zero_point )\n\n\n def measflux2flux(self,flux):\n \"\"\"Convert a measured flux to an actual flux.\n \n Use flux calibration function given for this filter.\n \"\"\"\n\n if self.measurement_calibration is not None:\n return self.measurement_calibration(flux)\n else:\n return flux\n\n\n def sort(self):\n \"\"\"Sort response in increasing order of frequency.\"\"\"\n \n _,srt = np.unique(self.nu_hz,return_index=True)\n self.nu_hz = self.nu_hz[srt]\n self.response = self.response[srt]\n\n\n def normalise_response(self):\n \"\"\"Normalise filter response so integral is one.\"\"\"\n \n norm = utils.sdf_int(self.response,self.nu_hz)\n self.response /= norm\n\n def actual_flux(self,spectrum):\n \"\"\"Return the spectrum's flux at the reference wavelength.\n \n Interpolate in log space.\n \"\"\"\n \n spectrum.sort('nu')\n if hasattr(spectrum,'fnujy'):\n log_fnu = np.log10(spectrum.fnujy)\n elif hasattr(spectrum,'fnujy_sr'):\n log_fnu = np.log10(spectrum.fnujy_sr)\n \n log_nu = np.log10(spectrum.nu_hz)\n log_ref_fnu = np.interp(np.log10(self.ref_nu_hz),log_nu,log_fnu)\n return np.power(10,log_ref_fnu)\n\n\n def fill_ref_nu_hz(self):\n \"\"\"Set the reference frequency of the filter.\"\"\"\n \n if self.ref_wavelength is not None:\n self.ref_nu_hz = c_micron / self.ref_wavelength\n\n\n def fill_mean_wavelength(self):\n \"\"\"Set the mean wavelength of the filter.\"\"\"\n \n wave = c_micron / self.nu_hz\n self.mean_wavelength = utils.sdf_int(self.response,wave) \\\n / utils.sdf_int(self.response/wave,wave)\n\n\n def pivot_wavelength(self):\n \"\"\"Return the pivot wavelength.\n \n See Bessell & Murphy (2012) for definition. This wavelength is a\n property of the filter only, and results in exact conversion\n between mean F_lambda and mean F_nu.\n \"\"\"\n \n wave = c_micron / self.nu_hz\n fp = utils.sdf_int( self.response, wave ) \\\n / utils.sdf_int( self.response / wave / wave, wave )\n return np.sqrt(fp)\n\n\n def fill_cc_denom(self):\n \"\"\"Compute the denominator of the colour correction\n \n This calculation is specific to the filter response (i.e. \n independent of observed spectrum) so only needs to be calculated\n once. See synthphot for details.\n \"\"\"\n\n if self.ref_spectrum is not None:\n d = utils.sdf_int(self.response * self.ref_spectrum(self.nu_hz),\n self.nu_hz)\n self.cc_denom = d / self.ref_spectrum(self.ref_nu_hz)\n\n\n def synthphot(self,spectrum):\n \"\"\"Synthetic photometry of supplied spectrum object\n\n In the IR we have f_nu(quoted) (i.e. catalogue value) is:\n\n f_nu(quoted) = f_nu(lam_eff) K\n\n where the colour correction K is:\n\n K = 1 S_nu(lam_eff) int( f_nu R dnu )\n ------------- -----------------\n f_nu(lam_eff) int( S_nu R dnu )\n\n For a correctly normalised bandpass R (energy counting), the\n integral in the numerator is \"normal\" synthetic photoemtry as\n done in the optical (e.g. appendix of 2011AJ....141..173B).\n\n Method is to separate the terms in synthetic photometry so that\n it can be done with a single set of equations. Separation is \n into\n 1 the \"normal\" integration as done for the optical\n 2 the spectrum-independent part of the colour correction \n (second term, which can be pre-computed)\n The latter is only done if necessary. f_nu(lam_eff) cancels so\n isn't needed to get f_nu(quoted), but is needed if we want to\n know what the colour correction was.\n \n Returns a tuple of (quoted flux, colour correction), where the\n colour correction will be None if there isn't one (i.e. no ref\n spectrum).\n \n For colours and indices the call needs to be done using the\n synthphot method for Spectrum objects.\n \n \"\"\"\n\n if hasattr(spectrum,'fnujy'):\n fnu = spectrum.fnujy\n elif hasattr(spectrum,'fnujy_sr'):\n fnu = spectrum.fnujy_sr\n x,y1,y2 = common_x(self.nu_hz,self.response,spectrum.nu_hz,fnu)\n\n # this is the basic synthetic photometry\n cc_num = utils.sdf_int(y1 * y2, x)\n \n # if no reference spectrum we just return the integral because\n # we normalised the bandpass when it was loaded\n if self.ref_spectrum is None:\n return (cc_num,None)\n else:\n fnu_eff = self.actual_flux(spectrum)\n cc = cc_num / self.cc_denom / fnu_eff\n return (cc*fnu_eff,cc)\n\n\n @property\n def name(self):\n return self._name\n @name.setter\n def name(self, value):\n self._name = utils.validate_string(value)\n\n @property\n def magnitude_system(self):\n return self._magnitude_system\n @magnitude_system.setter\n def magnitude_system(self, value):\n self._magnitude_system = utils.validate_string(value)\n \n @property\n def zero_point(self):\n return self._zero_point\n @zero_point.setter\n def zero_point(self, value):\n self._zero_point = utils.validate_float(value)\n\n @property\n def zero_point_offset(self):\n return self._zero_point_offset\n @zero_point_offset.setter\n def zero_point_offset(self, value):\n self._zero_point_offset = utils.validate_float(value)\n \n @property\n def measurement_calibration(self):\n return self._measurement_calibration\n @measurement_calibration.setter\n def measurement_calibration(self, value):\n self._measurement_calibration = utils.validate_function(value)\n\n @property\n def ref_spectrum(self):\n return self._ref_spectrum\n @ref_spectrum.setter\n def ref_spectrum(self, value):\n self._ref_spectrum = utils.validate_function(value)\n\n @property\n def response_type(self):\n return self._response_type\n @response_type.setter\n def response_type(self, value):\n self._response_type = utils.validate_string(value)\n\n @property\n def nu_hz(self):\n return self._nu_hz\n @nu_hz.setter\n def nu_hz(self, value):\n self._nu_hz = utils.validate_1d(value,None)\n\n @property\n def response(self):\n return self._response\n @response.setter\n def response(self,value):\n # always set nu_hz first, so no check for attribute nu_hz\n if self.nu_hz is None:\n expected_len = None\n else:\n expected_len = len(self.nu_hz)\n self._response = utils.validate_1d(value,expected_len)\n\n\ndef mean_wavelength(filternames):\n \"\"\"Return mean_wavelengths given tuple/list of filter names.\"\"\"\n \n wav = np.array([])\n for f in filternames:\n if iscolour(f):\n col = Colour.get(f)\n wav = np.append(wav,col.mean_wavelength)\n else:\n filt = Filter.get(f)\n wav = np.append(wav,filt.mean_wavelength)\n return wav\n\n\nclass Colour(object):\n \"\"\"Class for colours/indices, largely for convenience.\"\"\"\n\n def __init__(self,name=None,filters=None,weights=None,\n mean_wavelength=None):\n self.name = name\n self.filters = filters\n self.weights = weights\n self.mean_wavelength = mean_wavelength\n\n\n @classmethod\n def get(cls,name):\n \"\"\"Get a Colour object given a name.\"\"\"\n \n if not iscolour(name):\n raise utils.SdfError(\"name given ({}) not a colour\".format(name))\n\n self = cls()\n self.name = name\n self.fill_info()\n return self\n \n \n def fill_info(self):\n \"\"\"Set filters, weights, and other info for this colour.\"\"\"\n\n # colour\n if '_' in self.name:\n self.filters = np.array(self.name.split('_'),dtype=str)\n self.weights = np.array([1.,-1],dtype=float)\n \n # Stromgren M1, (v-b)-(b-y) or (v - 2b + y)\n elif self.name == 'STROMM1':\n self.filters = np.array(['VS','BS','YS'],dtype=str)\n self.weights = np.array([1.,-2.,1.],dtype=float)\n\n # Stromgren C1, (u-v)-(v-b) or (u - 2v + b)\n elif self.name == 'STROMC1':\n self.filters = np.array(['US','VS','BS'],dtype=str)\n self.weights = np.array([1.,-2.,1.],dtype=float)\n\n meanw = np.array([])\n for f in self.filters:\n filt = Filter.get(f)\n meanw = np.append(meanw,filt.mean_wavelength)\n self.mean_wavelength = np.mean(meanw)\n\n\n@lru_cache(maxsize=128)\ndef iscolour(filter):\n \"\"\"Return True if the given filter name is a colour\n \n In practise this means either the name has a '_' in it,\n e.g. BS_YS, indicating BS-YS, or that it's one of the\n Stromgren indices M1 or C1.\n \n If passed an array, list, or tuple, then return a list of\n booleans.\n \"\"\"\n \n if isinstance(filter,(tuple,list,np.ndarray)):\n iscol = np.array([],dtype=bool)\n for f in filter:\n iscol = np.append(iscol,iscolour(f))\n return iscol\n else:\n if '_' in filter:\n fs = filter.split('_')\n if len(fs) != 2:\n raise utils.SdfError(\"filter name {} \"\n \"has too many '_'s\".format(filter))\n if fs[0] == fs[1]:\n raise utils.SdfError(\"filters in colour {} \"\n \" are the same\".format(filter))\n return True\n elif filter == 'STROMM1':\n return True\n elif filter == 'STROMC1':\n return True\n else:\n return False\n", "meta": {"hexsha": "8cda0c5554d5925ce2a92a5170142095aa7ab07d", "size": 21772, "ext": "py", "lang": "Python", "max_stars_repo_path": "sdf/filter.py", "max_stars_repo_name": "drgmk/sdf", "max_stars_repo_head_hexsha": "a44e66a82f876dda079686b32c767370276c38a1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-07-01T15:55:16.000Z", "max_stars_repo_stars_event_max_datetime": "2020-07-01T15:55:16.000Z", "max_issues_repo_path": "sdf/filter.py", "max_issues_repo_name": "drgmk/sdf", "max_issues_repo_head_hexsha": "a44e66a82f876dda079686b32c767370276c38a1", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2017-03-28T19:18:09.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-21T08:17:45.000Z", "max_forks_repo_path": "sdf/filter.py", "max_forks_repo_name": "drgmk/sdf", "max_forks_repo_head_hexsha": "a44e66a82f876dda079686b32c767370276c38a1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-07-13T19:39:15.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-13T19:39:15.000Z", "avg_line_length": 36.1061359867, "max_line_length": 95, "alphanum_fraction": 0.5959948558, "include": true, "reason": "import numpy,import astropy,from astropy", "num_tokens": 5037, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6001883449573376, "lm_q2_score": 0.3242354055108441, "lm_q1q2_score": 0.19460231141012477}} {"text": "\n# This code is based on: https://github.com/nutonomy/second.pytorch.git\n# \n# MIT License\n# Copyright (c) 2018 \n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# in the Software without restriction, including without limitation the rights\n# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n# copies of the Software, and to permit persons to whom the Software is\n# furnished to do so, subject to the following conditions:\n# The above copyright notice and this permission notice shall be included in all\n# copies or substantial portions of the Software.\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n# SOFTWARE.\n\nimport numpy as np\nfrom second.core import box_np_ops\n\n\nclass AnchorGeneratorStride:\n def __init__(self,\n sizes=[1.6, 3.9, 1.56],\n anchor_strides=[0.4, 0.4, 1.0],\n anchor_offsets=[0.2, -39.8, -1.78],\n rotations=[0, np.pi / 2],\n class_id=None,\n match_threshold=-1,\n unmatch_threshold=-1,\n dtype=np.float32):\n self._sizes = sizes\n self._anchor_strides = anchor_strides\n self._anchor_offsets = anchor_offsets\n self._rotations = rotations\n self._dtype = dtype\n self._class_id = class_id\n self._match_threshold = match_threshold\n self._unmatch_threshold = unmatch_threshold\n\n @property\n def class_id(self):\n return self._class_id\n\n @property\n def match_threshold(self):\n return self._match_threshold\n\n @property\n def unmatch_threshold(self):\n return self._unmatch_threshold\n\n @property\n def num_anchors_per_localization(self):\n num_rot = len(self._rotations)\n num_size = np.array(self._sizes).reshape([-1, 3]).shape[0]\n return num_rot * num_size\n\n def generate(self, feature_map_size):\n return box_np_ops.create_anchors_3d_stride(\n feature_map_size, self._sizes, self._anchor_strides,\n self._anchor_offsets, self._rotations, self._dtype)\n\nclass AnchorGeneratorRange:\n def __init__(self,\n anchor_ranges,\n sizes=[1.6, 3.9, 1.56],\n rotations=[0, np.pi / 2],\n class_id=None,\n match_threshold=-1,\n unmatch_threshold=-1,\n dtype=np.float32):\n self._sizes = sizes\n self._anchor_ranges = anchor_ranges\n self._rotations = rotations\n self._dtype = dtype\n self._class_id = class_id\n self._match_threshold = match_threshold\n self._unmatch_threshold = unmatch_threshold\n\n @property\n def class_id(self):\n return self._class_id\n\n @property\n def match_threshold(self):\n return self._match_threshold\n\n @property\n def unmatch_threshold(self):\n return self._unmatch_threshold\n\n @property\n def num_anchors_per_localization(self):\n num_rot = len(self._rotations)\n num_size = np.array(self._sizes).reshape([-1, 3]).shape[0]\n return num_rot * num_size\n\n def generate(self, feature_map_size):\n return box_np_ops.create_anchors_3d_range(\n feature_map_size, self._anchor_ranges, self._sizes,\n self._rotations, self._dtype)\n", "meta": {"hexsha": "dc5b17f03752cac925c3a6560cb85d304d25caa8", "size": 3802, "ext": "py", "lang": "Python", "max_stars_repo_path": "models/AI-Model-Zoo/VAI-1.3-Model-Zoo-Code/PyTorch/pt_pointpillars_kitti_12000_100_10.8G_1.3/code/train/second/core/anchor_generator.py", "max_stars_repo_name": "guochunhe/Vitis-AI", "max_stars_repo_head_hexsha": "e86b6efae11f8703ee647e4a99004dc980b84989", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-12-18T14:49:19.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-18T14:49:19.000Z", "max_issues_repo_path": "models/AI-Model-Zoo/VAI-1.3-Model-Zoo-Code/PyTorch/pt_pointpillars_kitti_12000_100_10.8G_1.3/code/train/second/core/anchor_generator.py", "max_issues_repo_name": "guochunhe/Vitis-AI", "max_issues_repo_head_hexsha": "e86b6efae11f8703ee647e4a99004dc980b84989", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "models/AI-Model-Zoo/VAI-1.3-Model-Zoo-Code/PyTorch/pt_pointpillars_kitti_12000_100_10.8G_1.3/code/train/second/core/anchor_generator.py", "max_forks_repo_name": "guochunhe/Vitis-AI", "max_forks_repo_head_hexsha": "e86b6efae11f8703ee647e4a99004dc980b84989", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.5327102804, "max_line_length": 80, "alphanum_fraction": 0.6633350868, "include": true, "reason": "import numpy", "num_tokens": 876, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6001883449573376, "lm_q2_score": 0.3242354055108441, "lm_q1q2_score": 0.19460231141012477}} {"text": "#!/usr/bin/env python3\n# coding: utf-8\n\n#libraries\nimport keras\nimport tensorflow as tf\nfrom keras import backend as K\nimport cv2\nimport os\nimport numpy as np\nfrom keras.optimizers import Adam\nfrom keras.models import model_from_json, load_model\nfrom keras.layers import Input, Dense\nfrom keras.models import Model,Sequential\nfrom sklearn.model_selection import train_test_split\nfrom keras.layers import Convolution2D as Conv2D\nfrom keras.layers.convolutional import Deconv2D as Conv2DTranspose\nfrom keras.layers import Lambda, Input, Dense, MaxPooling2D, BatchNormalization,Input\nfrom keras.layers import UpSampling2D, Dropout, Flatten, Reshape, RepeatVector, LeakyReLU,Activation\nfrom keras.callbacks import ModelCheckpoint\nfrom keras.losses import mse, binary_crossentropy\nfrom keras.callbacks import EarlyStopping\nkeras.callbacks.TerminateOnNaN()\nseed = 7\nnp.random.seed(seed)\nfrom keras.callbacks import CSVLogger\nfrom keras.callbacks import Callback, LearningRateScheduler\n\n# config = tf.ConfigProto( device_count = {'GPU': 1 , 'GPU': 2} )\n# sess = tf.Session(config=config)\n# keras.backend.set_session(sess)\n\nos.environ[\"CUDA_VISIBLE_DEVICES\"]=\"1\"#Setting the script to run on GPU:1,2\nos.environ['TF_CPP_MIN_LOG_LEVEL'] = '1'\n\n\n#os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"1,2\"#Setting the script to run on GPU:1,2\n\nimport random\nimport os\nimport sys\nimport cv2\nimport csv\nimport glob\nimport numpy as np\nimport time\nfrom sklearn.utils import shuffle\n\n# path to USB\nUSBPath = \"/home/scope/Carla/autopilot_Carla_ad/sample_data/\"\n# list of folders used in training\ntrainingFolders = [\"run3\",\"run4\"]\n#Only parameters that has to be changed\nWorking_directory = \"/home/scope/Carla/autopilot_Carla_ad/leaderboard/team_code/detector_code/trial1/\"#working directory\nWorking_folder = 'new-B-1.2'#experiment\nWorking_path = Working_directory + Working_folder + '/'\ntrainfolder = 'train_reconstruction_result'#train folder\ndata = CSVLogger(Working_path + 'kerasloss.csv', append=True, separator=';')\n\n\n#Load complete input images without shuffling\ndef load_images(paths):\n numImages = 0\n inputs = []\n for path in paths:\n numFiles = len(glob.glob1(path,'*.png'))\n numImages += numFiles\n for img in glob.glob(path+'*.png'):\n img = cv2.imread(img)\n img = cv2.resize(img, (224, 224))\n img = img / 255.\n inputs.append(img)\n #inpu = shuffle(inputs)\n print(\"Total number of images:%d\" %(numImages))\n return inputs\n\ndef createFolderPaths(folders):\n paths = []\n for folder in folders:\n path = USBPath + folder + '/' + 'rgb_right_detector' + '/'\n paths.append(path)\n return paths\n\ndef load_training_images():\n paths = createFolderPaths(trainingFolders)\n return load_images(paths)\n\n\ndef load_data():\n #Loading images from the datasets\n csv_input = load_training_images()\n len(csv_input)#length of the data\n csv_input = shuffle(csv_input)\n\n img_train, img_test = np.array(csv_input[0:len(csv_input)-200]), np.array(csv_input[len(csv_input)-200:len(csv_input)])\n img_train = np.reshape(img_train, [-1, img_train.shape[1],img_train.shape[2],img_train.shape[3]])\n img_test = np.reshape(img_test, [-1, img_test.shape[1],img_test.shape[2],img_test.shape[3]])\n #Shuffle the data in order to get different images in train and test datasets.\n #img_train = shuffle(img_train)\n #img_test = shuffle(img_test)\n inp = (img_train, img_test)\n return inp\n\n#Sampling function used by the VAE\ndef sample_func(args):\n z_mean, z_log_var = args\n batch = K.shape(z_mean)[0]\n dim = K.int_shape(z_mean)[1]\n # by default, random_normal has mean = 0 and std = 1.0\n epsilon = K.random_normal(shape=(batch, dim))\n return z_mean + K.exp(0.5 * z_log_var) * epsilon\n\n#CNN-VAE model. Only important part is the N_latent variable which holds the latent space data.\ndef CreateModels(n_latent=100, sample_enc=sample_func, beta=1.2, C=0):\n model = Sequential()\n input_img = Input(shape=(224,224,3), name='image')\n x = Conv2D(128, (3, 3), use_bias=False, padding='same')(input_img)\n x = BatchNormalization()(x)\n x = LeakyReLU(0.1)(x)\n x = MaxPooling2D((2, 2), padding='same')(x)\n\n x = Conv2D(64, (3, 3), padding='same',use_bias=False)(x)\n x = BatchNormalization()(x)\n x = LeakyReLU(0.1)(x)\n x = MaxPooling2D((2, 2), padding='same')(x)\n\n x = Conv2D(32, (3, 3), padding='same',use_bias=False)(x)\n x = BatchNormalization()(x)\n x = LeakyReLU(0.1)(x)\n x = MaxPooling2D((2, 2), padding='same')(x)\n\n x = Conv2D(16, (3, 3), padding='same',use_bias=False)(x)\n x = BatchNormalization()(x)\n x = LeakyReLU(0.1)(x)\n x = MaxPooling2D((2, 2), padding='same')(x)\n\n x = Flatten()(x)\n x = Dense(2048)(x)\n x = LeakyReLU(0.1)(x)\n x = Dense(1000)(x)\n x = LeakyReLU(0.1)(x)\n x = Dense(250)(x)\n x = LeakyReLU(0.1)(x)\n# x = Dense(50)(x)\n# x = LeakyReLU(0.1)(x)\n\n z_mean = Dense(n_latent, name='z_mean')(x)\n z_log_var = Dense(n_latent, name='z_log_var')(x)\n z = Lambda(sample_func, output_shape=(n_latent,), name='z')([z_mean, z_log_var])\n\n encoder = Model(input_img, [z_mean, z_log_var, z], name='encoder')\n #encoder.summary()\n\n latent_inputs = Input(shape=(n_latent,), name='z_sampling')\n# x = Dense(50)(latent_inputs)\n# x = LeakyReLU(0.1)(x)\n x = Dense(250)(latent_inputs)\n x = LeakyReLU(0.1)(x)\n x = Dense(1000)(x)\n x = LeakyReLU(0.1)(x)\n x = Dense(2048)(x)\n x = LeakyReLU(0.1)(x)\n x = Dense(3136)(x)\n x = LeakyReLU(0.1)(x)\n\n x = Reshape((14, 14, 16))(x)\n\n x = Conv2D(16, (3, 3), padding='same', use_bias=False)(x)\n x = BatchNormalization()(x)\n x = LeakyReLU(0.1)(x)\n x = UpSampling2D((2,2))(x)\n\n x = Conv2D(32, (3, 3), padding='same', use_bias=False)(x)\n x = BatchNormalization()(x)\n x = LeakyReLU(0.1)(x)\n x = UpSampling2D((2,2))(x)\n\n x = Conv2D(64, (3, 3), padding='same', use_bias=False)(x)\n x = BatchNormalization()(x)\n x = LeakyReLU(0.1)(x)\n x = UpSampling2D((2,2))(x)\n\n x = Conv2D(128, (3, 3), padding='same', use_bias=False)(x)\n x = BatchNormalization()(x)\n x = LeakyReLU(0.1)(x)\n x = UpSampling2D((2,2))(x)\n\n x = Conv2D(3, (3, 3), padding='same', use_bias=False)(x)\n x = BatchNormalization()(x)\n decoded = Activation('sigmoid')(x)\n\n decoder = Model(latent_inputs, decoded)\n #decoder.summary()\n\n outputs = decoder(encoder(input_img)[2])\n autoencoder = Model(input_img,outputs)\n #autoencoder.summary()\n\n def vae_loss(true, pred):\n rec_loss = mse(K.flatten(true), K.flatten(pred))\n rec_loss *= 224*224*3\n kl_loss = 1 + z_log_var - K.square(z_mean) - K.exp(z_log_var)\n kl_loss = K.sum(kl_loss, axis=-1)\n kl_loss *= -0.5\n vae_loss = K.mean(rec_loss + beta*(kl_loss-C))\n return vae_loss\n #autoencoder.add_loss(vae_loss)\n\n def lr_scheduler(epoch): #learningrate scheduler to adjust learning rate.\n lr = 1e-6\n if epoch > 50:\n print(\"New learning rate\")\n lr = 1e-8\n if epoch > 75:\n print(\"New learning rate\")\n lr = 1e-8\n return lr\n\n scheduler = LearningRateScheduler(lr_scheduler)\n #Define adam optimizer\n adam = keras.optimizers.Adam(lr=1e-6, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False)\n autoencoder.compile(optimizer='adam',loss=vae_loss, metrics=[vae_loss])\n\n #Define adam optimizer\n #adam = keras.optimizers.Adam(lr=0.000001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False)\n #autoencoder.compile(optimizer='rmsprop',loss=vae_loss, metrics=[vae_loss])\n #autoencoder.compile(optimizer='adam',loss=vae_loss, metrics=[vae_loss])\n\n return autoencoder, encoder,decoder, z_log_var\n\n\n#Train function to fit the data to the model\ndef train(X,autoencoder):\n X_train,X_test = X\n filePath = Working_path + 'weights.best.hdf5'#checkpoint weights\n\n checkpoint = ModelCheckpoint(filePath, monitor='vae_loss', verbose=1, save_best_only=True, mode='min')\n EarlyStopping(monitor='vae_loss', patience=10, verbose=0),\n callbacks_list = [checkpoint, data]\n autoencoder.fit(X_train, X_train,epochs=75,batch_size=16,shuffle=True,validation_data=(X_test, X_test),callbacks=callbacks_list, verbose=2)\n\n #checkpoint = ModelCheckpoint(filePath, monitor='vae_loss', verbose=2, save_best_only=True, mode='min')\n #EarlyStopping(monitor='vae_loss', patience=5, verbose=0),\n #es=EarlyStopping(monitor='vae_loss', min_delta=0, patience=5, verbose=0, mode='auto', baseline=None, restore_best_weights=False)\n #callbacks_list = [checkpoint, data]\n #autoencoder.fit(X_train, X_train,epochs=2,batch_size=16,shuffle=True,validation_data=(X_test, X_test),callbacks=callbacks_list, verbose=1)\n\n\n #Save the autoencoder model\ndef SaveAutoencoderModel(autoencoder):\n\tauto_model_json = autoencoder.to_json()\n\twith open(Working_path + 'auto_model.json', \"w\") as json_file:\n\t\tjson_file.write(auto_model_json)\n\tautoencoder.save_weights(Working_path + 'auto_model.h5')\n\tprint(\"Saved Autoencoder model to disk\")\n\n#Save the encoder model\ndef SaveEncoderModel(encoder):\n\ten_model_json = encoder.to_json()\n\twith open(Working_path + 'en_model.json', \"w\") as json_file:\n\t\tjson_file.write(en_model_json)\n\tencoder.save_weights(Working_path + 'en_model.h5')\n\tprint(\"Saved Encoder model to disk\")\n\n#Test the trained models on a different test data\ndef test(autoencoder,encoder,test):\n autoencoder_res = autoencoder.predict(test)\n encoder_res = encoder.predict(test)\n res_x = test.copy()\n res_y = autoencoder_res.copy()\n res_x = res_x * 255\n res_y = res_y * 255\n\n return res_x, res_y, encoder_res\n\n#Save the reconstructed test data in a separate folder.\n#For this create a folder named results in the directory you are working in.\ndef savedata(test_in, test_out, test_encoded, Working_path, trainfolder):\n os.makedirs(Working_path + trainfolder + '/', exist_ok=True)\n for i in range(len(test_in)):\n test_in = np.reshape(test_in,[-1, 224,224,3])#Reshape the data\n test_out = np.reshape(test_out,[-1, 224,224,3])#Reshape the data\n cv2.imwrite(Working_path + trainfolder + '/' + str(i) +'_in.png', test_in[i])\n cv2.imwrite(Working_path + trainfolder + '/' + str(i) +'_out.png', test_out[i])\n\n\nif __name__ == '__main__':\n print(\"loading image\")\n inp = load_data()\n print(\"created model\")\n autoencoder,encoder,decoder,z_log_var = CreateModels()# Running the autoencoder model\n print(\"training model\")\n train(inp,autoencoder)#Train the model with the data\n print(\"testing model\")\n test_in, test_out, test_encoded = test(autoencoder, encoder, inp[1])#Test the trained model with new data\n print(\"save model performance\")\n savedata(test_in, test_out, test_encoded, Working_path, trainfolder)#Save the data\n print(\"save encoder model\")\n SaveEncoderModel(encoder)\n SaveAutoencoderModel(autoencoder)#Save the autoencoder and encoder models\n", "meta": {"hexsha": "b8e91901ae29da200ce08db0b2c7db0fc4697963", "size": 10995, "ext": "py", "lang": "Python", "max_stars_repo_path": "resonate-carla/leaderboard/team_code/detector_code/train-bvae.py", "max_stars_repo_name": "scope-lab-vu/Resonate-Dynamic-Risk", "max_stars_repo_head_hexsha": "46972bdb0a2b6b08cc188a9f1f6567971c9d263d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-08-15T05:02:17.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-16T11:25:45.000Z", "max_issues_repo_path": "resonate-carla/leaderboard/team_code/detector_code/train-bvae.py", "max_issues_repo_name": "scope-lab-vu/Resonate-Dynamic-Risk", "max_issues_repo_head_hexsha": "46972bdb0a2b6b08cc188a9f1f6567971c9d263d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "resonate-carla/leaderboard/team_code/detector_code/train-bvae.py", "max_forks_repo_name": "scope-lab-vu/Resonate-Dynamic-Risk", "max_forks_repo_head_hexsha": "46972bdb0a2b6b08cc188a9f1f6567971c9d263d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-03-21T02:35:17.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-02T22:40:07.000Z", "avg_line_length": 36.5282392027, "max_line_length": 143, "alphanum_fraction": 0.6885857208, "include": true, "reason": "import numpy", "num_tokens": 3130, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.600188359260205, "lm_q2_score": 0.3242353924510608, "lm_q1q2_score": 0.19460230820929084}} {"text": "__version__ = '0.8.0'\n\nimport numpy as np\nimport warnings\n\nfrom phonopy.file_IO import write_FORCE_CONSTANTS, write_force_constants_to_hdf5, write_FORCE_SETS\nfrom phonolammps.arrange import get_correct_arrangement, rebuild_connectivity_tinker\nfrom phonolammps.phonopy_link import obtain_phonon_dispersion_bands, get_phonon\nfrom phonolammps.iofile import get_structure_from_poscar, generate_VASP_structure\nfrom phonolammps.iofile import generate_tinker_key_file, generate_tinker_txyz_file, parse_tinker_forces\nfrom phonolammps.iofile import get_structure_from_lammps, get_structure_from_txyz\nfrom phonolammps.iofile import get_structure_from_g96, get_structure_from_gro\nfrom phonolammps.iofile import generate_gro, generate_g96\n\nimport shutil, os\n\n\n# define the force unit conversion factors to LAMMPS metal style (eV/Angstrom)\nunit_factors = {'real': 4.336410389526464e-2,\n 'metal': 1.0,\n 'si': 624150636.3094,\n 'gromacs': 0.00103642723,\n 'tinker': 0.043 # kcal/mol to eV\n}\n\n\nclass PhonoBase:\n \"\"\"\n Base class for PhonoLAMMPS\n This class is not designed to be called directly.\n To use it make a subclass and implement the following methods:\n\n * __init__()\n * get_forces()\n\n \"\"\"\n\n def get_path_using_seek_path(self):\n\n \"\"\" Obtain the path in reciprocal space to plot the phonon band structure\n\n :return: dictionary with list of q-points and labels of high symmetry points\n \"\"\"\n\n try:\n import seekpath\n\n cell = self._structure.get_cell()\n positions = self._structure.get_scaled_positions()\n numbers = np.unique(self._structure.get_chemical_symbols(), return_inverse=True)[1]\n\n path_data = seekpath.get_path((cell, positions, numbers))\n\n labels = path_data['point_coords']\n\n band_ranges = []\n for set in path_data['path']:\n band_ranges.append([labels[set[0]], labels[set[1]]])\n\n return {'ranges': band_ranges,\n 'labels': path_data['path']}\n except ImportError:\n print ('Seekpath not installed. Autopath is deactivated')\n band_ranges = ([[[0.0, 0.0, 0.0], [0.5, 0.0, 0.5]]])\n return {'ranges': band_ranges,\n 'labels': [['GAMMA', '1/2 0 1/2']]}\n\n def get_force_constants(self, include_data_set=False):\n \"\"\"\n calculate the force constants with phonopy using lammps to calculate forces\n\n :return: ForceConstants type object containing force constants\n \"\"\"\n\n if self._force_constants is None:\n phonon = get_phonon(self._structure,\n setup_forces=False,\n super_cell_phonon=self._supercell_matrix,\n primitive_matrix=self._primitive_matrix,\n NAC=self._NAC,\n symmetrize=self._symmetrize)\n\n phonon.get_displacement_dataset()\n phonon.generate_displacements(distance=self._displacement_distance)\n cells_with_disp = phonon.get_supercells_with_displacements()\n data_set = phonon.get_displacement_dataset()\n\n # Check forces for non displaced supercell\n forces_supercell = self.get_forces(phonon.get_supercell())\n if np.max(forces_supercell) > 1e-1:\n warnings.warn('Large atomic forces found for non displaced structure: '\n '{}. Make sure your unit cell is properly optimized'.format(np.max(forces_supercell)))\n\n # Get forces from lammps\n for i, cell in enumerate(cells_with_disp):\n if self._show_progress:\n print('displacement {} / {}'.format(i+1, len(cells_with_disp)))\n forces = self.get_forces(cell)\n data_set['first_atoms'][i]['forces'] = forces\n\n phonon.set_displacement_dataset(data_set)\n phonon.produce_force_constants()\n self._force_constants = phonon.get_force_constants()\n self._data_set = data_set\n\n if include_data_set:\n return [self._force_constants, self._data_set]\n else:\n return self._force_constants\n\n def plot_phonon_dispersion_bands(self):\n \"\"\"\n Plot phonon band structure using seekpath automatic k-path\n Warning: The labels may be wrong if the structure is not standarized\n\n \"\"\"\n import matplotlib.pyplot as plt\n\n def replace_list(text_string):\n substitutions = {'GAMMA': u'$\\Gamma$',\n }\n\n for item in substitutions.items():\n text_string = text_string.replace(item[0], item[1])\n return text_string\n\n force_constants = self.get_force_constants()\n bands_and_labels = self.get_path_using_seek_path()\n\n _bands = obtain_phonon_dispersion_bands(self._structure,\n bands_and_labels['ranges'],\n force_constants,\n self._supercell_matrix,\n primitive_matrix=self._primitive_matrix,\n band_resolution=30)\n\n for i, freq in enumerate(_bands[1]):\n plt.plot(_bands[1][i], _bands[2][i], color='r')\n\n plt.ylabel('Frequency [THz]')\n plt.xlabel('Wave vector')\n plt.xlim([0, _bands[1][-1][-1]])\n plt.axhline(y=0, color='k', ls='dashed')\n plt.suptitle('Phonon dispersion')\n\n if 'labels' in bands_and_labels:\n plt.rcParams.update({'mathtext.default': 'regular'})\n\n labels = bands_and_labels['labels']\n\n labels_e = []\n x_labels = []\n for i, freq in enumerate(_bands[1]):\n if labels[i][0] == labels[i - 1][1]:\n labels_e.append(replace_list(labels[i][0]))\n else:\n labels_e.append(\n replace_list(labels[i - 1][1]) + '/' + replace_list(labels[i][0]))\n x_labels.append(_bands[1][i][0])\n x_labels.append(_bands[1][-1][-1])\n labels_e.append(replace_list(labels[-1][1]))\n labels_e[0] = replace_list(labels[0][0])\n\n plt.xticks(x_labels, labels_e, rotation='horizontal')\n\n plt.show()\n\n def write_force_constants(self, filename='FORCE_CONSTANTS', hdf5=False):\n \"\"\"\n Write the force constants in a file in phonopy plain text format\n\n :param filename: Force constants filename\n \"\"\"\n\n force_constants = self.get_force_constants()\n if hdf5:\n write_force_constants_to_hdf5(force_constants, filename=filename)\n else:\n write_FORCE_CONSTANTS(force_constants, filename=filename)\n\n def write_force_sets(self, filename='FORCE_SETS'):\n \"\"\"\n Write the force sets in a file in phonopy plain text format\n\n :param filename: Force sets filename\n \"\"\"\n\n data_set = self.get_force_constants(include_data_set=True)[1]\n\n write_FORCE_SETS(data_set, filename=filename)\n\n def get_unitcell(self):\n \"\"\"\n Get unit cell structure\n\n :return unitcell: unit cell 3x3 matrix (lattice vectors in rows)\n \"\"\"\n return self._structure\n\n def get_supercell_matrix(self):\n \"\"\"\n Get the supercell matrix\n\n :return supercell: the supercell 3x3 matrix (list of lists)\n \"\"\"\n return self._supercell_matrix\n\n def get_primitve_matrix(self):\n return self._primitive_matrix\n\n def get_seekpath_bands(self, band_resolution=30):\n ranges = self.get_path_using_seek_path()['ranges']\n bands =[]\n for q_start, q_end in ranges:\n band = []\n for i in range(band_resolution+1):\n band.append(np.array(q_start) + (np.array(q_end) - np.array(q_start)) / band_resolution * i)\n bands.append(band)\n\n return bands\n\n def write_unitcell_POSCAR(self, filename='POSCAR'):\n \"\"\"\n Write unit cell in VASP POSCAR type file\n\n :param filename: POSCAR file name (Default: POSCAR)\n \"\"\"\n poscar_txt = generate_VASP_structure(self._structure)\n\n with open(filename, mode='w') as f:\n f.write(poscar_txt)\n\n def get_phonopy_phonon(self):\n \"\"\"\n Return phonopy phonon object with unitcell, primitive cell and\n the force constants set.\n\n :return:\n \"\"\"\n\n phonon = get_phonon(self._structure,\n setup_forces=False,\n super_cell_phonon=self._supercell_matrix,\n primitive_matrix=self._primitive_matrix,\n NAC=self._NAC,\n symmetrize=self._symmetrize)\n\n phonon.set_force_constants(self.get_force_constants())\n\n return phonon\n\n################################\n# LAMMPS #\n################################\nclass Phonolammps(PhonoBase):\n def __init__(self,\n lammps_input,\n supercell_matrix=np.identity(3),\n primitive_matrix=np.identity(3),\n displacement_distance=0.01,\n show_log=False,\n show_progress=False,\n use_NAC=False,\n symmetrize=True):\n \"\"\"\n Main PhonoLAMMPS class\n\n :param lammps_input: LAMMPS input file name or list of commands\n :param supercell_matrix: 3x3 matrix supercell\n :param primitive cell: 3x3 matrix primitive cell\n :param displacement_distance: displacement distance in Angstroms\n :param show_log: Set true to display lammps log info\n :param show_progress: Set true to display progress of calculation\n \"\"\"\n\n # Check if input is file or list of commands\n if type(lammps_input) is str:\n # read from file name\n self._lammps_input_file = lammps_input\n self._lammps_commands_list = open(lammps_input).read().split('\\n')\n else:\n # read from commands\n self._lammps_commands_list = lammps_input\n\n self._structure = get_structure_from_lammps(self._lammps_commands_list)\n\n self._supercell_matrix = supercell_matrix\n self._primitive_matrix = primitive_matrix\n self._displacement_distance = displacement_distance\n self._show_log = show_log\n self._show_progress = show_progress\n self._symmetrize = symmetrize\n self._NAC = use_NAC\n\n self._force_constants = None\n self._data_set = None\n\n self.units = self.get_units(self._lammps_commands_list)\n\n if not self.units in unit_factors.keys():\n print ('Units style not supported, use: {}'.format(unit_factors.keys()))\n exit()\n\n def get_units(self, commands_list):\n \"\"\"\n Get the units label for LAMMPS \"units\" command from a list of LAMMPS input commands\n\n :param commands_list: list of LAMMPS input commands (strings)\n :return units: string containing the units\n \"\"\"\n for line in commands_list:\n if line.startswith('units'):\n return line.split()[1]\n return 'lj'\n\n def get_forces(self, cell_with_disp):\n \"\"\"\n Calculate the forces of a supercell using lammps\n\n :param cell_with_disp: supercell from which determine the forces\n :return: numpy array matrix with forces of atoms [Natoms x 3]\n \"\"\"\n\n import lammps\n\n supercell_sizes = np.diag(self._supercell_matrix)\n\n cmd_list = ['-log', 'none']\n if not self._show_log:\n cmd_list += ['-echo', 'none', '-screen', 'none']\n\n lmp = lammps.lammps(cmdargs=cmd_list)\n lmp.commands_list(self._lammps_commands_list)\n lmp.command('replicate {} {} {}'.format(*supercell_sizes))\n lmp.command('run 0')\n\n na = lmp.get_natoms()\n # xc = lmp.gather_atoms(\"x\", 1, 3)\n # reference2 = np.array([xc[i] for i in range(na * 3)]).reshape((na, 3))\n\n id = lmp.extract_atom(\"id\", 0)\n id = np.array([id[i]-1 for i in range(na)], dtype=int)\n\n xp = lmp.extract_atom(\"x\", 3)\n reference = np.array([[xp[i][0], xp[i][1], xp[i][2]] for i in range(na)], dtype=float)[id, :]\n\n template = get_correct_arrangement(reference, self._structure, self._supercell_matrix)\n indexing = np.argsort(template)\n\n coordinates = cell_with_disp.get_positions()\n\n for i in range(na):\n lmp.command('set atom {} x {} y {} z {}'.format(i + 1,\n coordinates[template[i], 0],\n coordinates[template[i], 1],\n coordinates[template[i], 2]))\n\n lmp.command('run 0')\n\n # forces2 = lmp.gather_atoms(\"f\", 1, 3)\n # forces2 = np.array([forces2[i] for i in range(na * 3)], dtype=float).reshape((na, 3))#[indexing,:]\n\n id = lmp.extract_atom(\"id\", 0)\n id = np.array([id[i]-1 for i in range(na)], dtype=int)\n\n fp = lmp.extract_atom(\"f\", 3)\n forces = np.array([[fp[i][0], fp[i][1], fp[i][2]] for i in range(na)], dtype=float)[id, :]\n\n forces = forces[indexing, :] * unit_factors[self.units]\n\n lmp.close()\n\n return forces\n\n\n################################\n# TINKER #\n################################\nclass PhonoTinker(PhonoBase):\n\n def __init__(self,\n txyz_input_file,\n key_input_file,\n force_field_file,\n supercell_matrix=np.identity(3),\n primitive_matrix=np.identity(3),\n displacement_distance=0.01,\n show_log=False,\n show_progress=False,\n use_NAC=False,\n symmetrize=True):\n \"\"\"\n Experimental class to use Tinker to calculate forces, can be used\n as an example to how to expand phonoLAMMPS to other software\n\n :param txyz_input_file: TXYZ input file name (see example)\n :param supercell_matrix: 3x3 matrix supercell\n :param primitive cell: 3x3 matrix primitive cell\n :param displacement_distance: displacement distance in Angstroms\n :param show_log: set true to display lammps log info\n :param show_progress: set true to display progress of calculation\n :param use_NAC: set true to use Non-Analytical corrections or not\n :param symmetrize: set true to use symmetrization of the force constants\n \"\"\"\n\n self._structure = get_structure_from_txyz(txyz_input_file, key_input_file)\n self._txyz_input_file = txyz_input_file\n\n self._supercell_matrix = supercell_matrix\n self._primitive_matrix = primitive_matrix\n self._displacement_distance = displacement_distance\n self._show_log = show_log\n self._show_progress = show_progress\n self._symmetrize = symmetrize\n self._NAC = use_NAC\n\n self._force_constants = None\n self._data_set = None\n\n self.units = 'tinker'\n\n self.force_field = force_field_file\n\n if not self.units in unit_factors.keys():\n print ('Units style not supported, use: {}'.format(unit_factors.keys()))\n exit()\n\n def get_forces(self, cell_with_disp):\n \"\"\"\n Calculate the forces of a supercell using tinker\n :param cell_with_disp: supercell (PhonopyAtoms) from which determine the forces\n :return array: numpy array matrix with forces of atoms [Natoms x 3]\n \"\"\"\n\n import tempfile\n import subprocess\n from subprocess import PIPE\n\n temp_file_name = tempfile.gettempdir() + '/tinker_temp' + '_' + str(os.getpid())\n\n # temp_file_name = 'test_calc'\n\n supercell_wd = rebuild_connectivity_tinker(self._structure,\n cell_with_disp,\n self._supercell_matrix)\n\n tinker_input_file = open(temp_file_name + '.txyz', mode='w')\n tinker_input_file.write(generate_tinker_txyz_file(supercell_wd))\n\n tinker_key_file = open(temp_file_name + '.key', mode='w')\n tinker_key_file.write(generate_tinker_key_file(supercell_wd))\n\n tinker_input_file.close()\n tinker_key_file.close()\n\n tinker_command = './testgrad ' + tinker_input_file.name + \\\n ' ' + self.force_field + ' Y N N ' + ' -k ' + tinker_key_file.name\n\n tinker_process = subprocess.Popen(tinker_command, stdin=PIPE, stderr=PIPE, stdout=PIPE, shell=True)\n (output, err) = tinker_process.communicate()\n tinker_process.wait()\n\n if len(err.split()) != 0:\n print(err)\n print('Something wrong in forces calculation!')\n exit()\n\n # print(output)\n os.unlink(tinker_input_file.name)\n os.unlink(tinker_key_file.name)\n\n forces = parse_tinker_forces(output) * unit_factors[self.units]\n\n return forces\n\n\n################################\n# GROMACS #\n################################\nclass PhonoGromacs(PhonoBase):\n\n _work_dir = 'gromorg_{}/'.format(os.getpid())\n\n # _work_dir = 'gromorg_test/'\n\n def __init__(self,\n gro_file,\n supercell_matrix=np.identity(3),\n primitive_matrix=np.identity(3),\n displacement_distance=0.01,\n show_log=False,\n show_progress=False,\n use_NAC=False,\n symmetrize=True,\n gmx_params=None,\n base_ff='charmm27.ff/forcefield.itp',\n itp_file=None,\n silent=True,\n omp_num_threads=1):\n\n \"\"\"\n Experimental class to use Tinker to calculate forces, can be used\n as an example to how to expand phonoLAMMPS to other software\n\n :param xyz_input_file: XYZ input file name (see example)\n :param supercell_matrix: 3x3 matrix supercell\n :param primitive cell: 3x3 matrix primitive cell\n :param displacement_distance: displacement distance in Angstroms\n :param show_log: set true to display lammps log info\n :param show_progress: set true to display progress of calculation\n :param use_NAC: set true to use Non-Analytical corrections or not\n :param symmetrize: set true to use symmetrization of the force constants\n \"\"\"\n\n self._supercell_matrix = supercell_matrix\n self._primitive_matrix = primitive_matrix\n self._displacement_distance = displacement_distance\n self._show_log = show_log\n self._show_progress = show_progress\n self._symmetrize = symmetrize\n self._NAC = use_NAC\n\n self._force_constants = None\n self._data_set = None\n self._silent = silent\n\n self._base_fcc = base_ff\n\n self.units = 'gromacs'\n\n if not self.units in unit_factors.keys():\n print ('Units style not supported, use: {}'.format(unit_factors.keys()))\n exit()\n\n # import openbabel\n\n # a, b, c = [8.194, 5.968, 8.669]\n # alpha, beta, gamma = [90.0, 123.57, 90.0]\n\n # a1 = a\n # b1 = b * np.cos(np.deg2rad(gamma))\n # b2 = np.sqrt(b ** 2 - b1 ** 2)\n # c1 = c * np.cos(np.deg2rad(beta))\n # c2 = (b * c * np.cos(np.deg2rad(alpha)) - b1 * c1) / b2\n # c3 = np.sqrt(c ** 2 - c1 ** 2 - c2 ** 2)\n\n # unitcell = [[a1, 0, 0],\n # [b1, b2, 0],\n # [c1, c2, c3]]\n\n\n self._structure = get_structure_from_g96(gro_file)\n\n\n os.putenv('GMX_MAXBACKUP', '-1')\n os.putenv('OMP_NUM_THREADS', '{}'.format(omp_num_threads))\n\n self._filename = 'test'\n\n # os.mkdir(self._work_dir)\n try:\n os.mkdir(self._work_dir)\n except FileExistsError:\n pass\n\n self._filename_dir = self._work_dir + self._filename\n\n # Default parameters\n\n # Run paramters\n if gmx_params is None:\n gmx_params = {}\n\n gmx_params.update({'integrator': 'steep', # Verlet integrator\n 'nsteps': 1, # 0.001 * 5000 = 50 ps\n 'nstxout': 1, # save coordinates every 0.001 ps\n 'nstvout': 1, # save velocities every 0.001 ps\n 'nstfout': 1, # save forces every 0.001 ps\n 'dt': 0.1})\n\n self._params = gmx_params\n\n\n self._supercell = np.diag(supercell_matrix)\n self._box = [v/10 for v in self.cell_lengths(self._structure.cell)]\n self._angles = self.cell_angles(self._structure.cell)\n # alpha, beta, gamma = [90.0, 123.57, 90.0]\n\n from phonolammps.swissparam import SwissParams\n\n if itp_file is None:\n sw = SwissParams(self._structure, silent=False)\n\n files = {'itp': sw.get_itp_data(),\n 'pdb': sw.get_pdb_data(),\n 'top': self.get_topology(),\n 'mdp': self.get_mdp()}\n\n for ext, data in files.items():\n with open(self._filename_dir + '.{}'.format(ext), 'w') as f:\n f.write(data)\n else:\n shutil.copy(itp_file, self._filename_dir + '.itp')\n\n with open(self._filename_dir + '.top', 'w') as f:\n f.write(self.get_topology())\n\n with open(self._filename_dir + '.mdp', 'w') as f:\n f.write(self.get_mdp())\n\n def cell_lengths(self, cell):\n \"\"\"\n Get the lengths of cell lattice vectors in angstroms.\n \"\"\"\n import numpy\n\n return [\n numpy.linalg.norm(cell[0]),\n numpy.linalg.norm(cell[1]),\n numpy.linalg.norm(cell[2]),\n ]\n\n def cell_angles(self, cell):\n \"\"\"\n Get the angles between the cell lattice vectors in degrees.\n \"\"\"\n import numpy\n\n lengths = self.cell_lengths(cell)\n return [\n float(numpy.arccos(x) / numpy.pi * 180) for x in [\n numpy.vdot(cell[1], cell[2]) / lengths[1] / lengths[2],\n numpy.vdot(cell[0], cell[2]) / lengths[0] / lengths[2],\n numpy.vdot(cell[0], cell[1]) / lengths[0] / lengths[1],\n ]\n ]\n\n def get_mdp(self):\n file = ';Autogenerated MDP\\n'\n for keys, values in self._params.items():\n file += '{:30} = {}\\n'.format(keys, values)\n\n return file\n\n def get_topology(self):\n\n num_mol = np.prod(self._supercell)\n file = '; Autogenerated Topology\\n'\n\n itp_files = [self._base_fcc, '{}.itp'.format(self._filename)]\n\n params = {'system': ['molecular system name'],\n 'molecules': ['{} {}\\n'.format(self._filename, num_mol)]}\n\n for itp in itp_files:\n file += '#include \"{}\"\\n'.format(itp)\n\n for section, lines in params.items():\n file += '[ {} ]\\n'.format(section)\n for line in lines:\n file += '{}\\n'.format(line)\n\n return file\n\n def get_tpr(self, supercell_wd):\n import gmxapi as gmx\n\n #gmx genconf -f molecule.gro -o multi_mol.gro -nbox 2 2 2\n\n # print(self._filename_dir + '.gro')\n\n #create_gro(supercell_wd, self._structure, self._filename_dir + '.gro')\n\n generate_g96(supercell_wd, self._structure, self._filename_dir + '.g96')\n\n\n grompp = gmx.commandline_operation('gmx', 'grompp',\n input_files={'-f': self._filename_dir + '.mdp',\n # '-c': self._filename_dir + '.gro',\n '-c': self._filename_dir + '.g96',\n '-p': self._filename_dir + '.top',\n '-po': self._filename_dir + '_log.mdp'},\n output_files={'-o': self._filename_dir + '.tpr'})\n grompp.run()\n\n if grompp.output.returncode.result() != 0:\n print(grompp.output.erroroutput.result())\n\n tpr_data = gmx.read_tpr(self._filename_dir + '.tpr')\n\n return tpr_data\n\n def get_forces(self, cell_with_disp):\n \"\"\"\n Calculate the forces of a supercell using tinker\n :param cell_with_disp: supercell (PhonopyAtoms) from which determine the forces\n :return array: numpy array matrix with forces of atoms [Natoms x 3]\n \"\"\"\n\n import gmxapi as gmx\n from phonolammps.capture import captured_stdout\n\n supercell_wd = rebuild_connectivity_tinker(self._structure,\n cell_with_disp,\n self._supercell_matrix)\n\n # simulation_input = gmx.modify_input(input=self.get_tpr(supercell_wd), parameters={'nsteps': 1})\n\n md = gmx.mdrun(input=self.get_tpr(supercell_wd))\n\n if self._silent:\n with captured_stdout(self._filename_dir + '.log'):\n md.run()\n else:\n md.run()\n\n\n trajectory_file = md.output.trajectory.result()\n md_data_dir = md.output._work_dir.result()\n\n # print('trajectory file:', trajectory_file)\n # print('workdir: ', md.output._work_dir.result())\n\n # reference = get_structure_from_gro(self._filename_dir + '.gro').positions\n reference = get_structure_from_g96(self._filename_dir + '.g96').positions\n\n template = get_correct_arrangement(reference, self._structure, self._supercell_matrix)\n indexing = np.argsort(template)\n\n # print('{}\\n'.format(len(supercell_wd.symbols)))\n # for s, c in zip(supercell_wd.symbols, supercell_wd.positions):\n # print('{:5} '.format(s) + '{:15.5f} {:15.5f} {:15.5f}'.format(*c))\n\n # import mdtraj\n # self._trajectory = mdtraj.load_trr(trajectory_file, top=md_data_dir + '/confout.gro')\n # self._trajectory.save('mdtraj.gro')\n # exit()\n\n def extract_forces(trajectory_file, tpr_file, output='forces.xvg', step=0):\n\n grompp = gmx.commandline_operation('gmx', ['traj', '-of'],\n stdin='0',\n input_files={'-f': trajectory_file,\n '-s': tpr_file,\n '-b': '{}'.format(step),\n '-e': '{}'.format(step),\n },\n )\n\n if grompp.output.returncode.result() != 0:\n print(grompp.output.erroroutput.result())\n\n forces = np.loadtxt('force.xvg', comments=['#', '@'])[1:].reshape(-1, 3)\n # print(forces)\n\n os.remove('force.xvg')\n\n return forces # KJ/(mol nm) to eV/ang\n\n # trajectory = mdtraj.load_trr(trajectory_file, top=md_data_dir + '/confout.gro')\n # print(trajectory.n_frames)\n forces = extract_forces(trajectory_file, self._filename_dir + '.tpr', step=1)\n\n forces = forces[indexing, :] * unit_factors[self.units]\n\n shutil.rmtree(md.output._work_dir.result())\n\n return forces\n\n def __del__(self):\n if os.path.isdir(self._work_dir):\n shutil.rmtree(self._work_dir)\n\n\nif __name__ == '__main__':\n\n params = {'rvdw': 0.28,\n 'rlist': 0.28,\n 'rcoulomb': 0.28}\n\n phg = PhonoGromacs('unitcell_whole.g96', supercell_matrix=np.identity(3)*3, displacement_distance=0.15,\n itp_file='gromorg_test_ref/test.itp', show_progress=True, gmx_params=params)\n\n phg.write_unitcell_POSCAR()\n phg.plot_phonon_dispersion_bands()\n phg.write_force_constants()\n phonon = phg.get_phonopy_phonon()\n phonon.run_mesh([40, 40, 40])\n phonon.run_total_dos()\n phonon.plot_total_dos().show()\n\n\n exit()\n structure = get_structure_from_txyz('structure_wrap_min.txyz', 'structure.key')\n print(structure)\n print(structure.get_connectivity())\n print(generate_VASP_structure(structure))\n print(structure.get_scaled_positions())\n print(structure.get_chemical_symbols())\n\n phonon = get_phonon(structure,\n setup_forces=False,\n super_cell_phonon=[[2, 0, 0], [0, 2, 0], [0, 0, 2]],\n NAC=False,\n symmetrize=True)\n\n\n phonon.get_displacement_dataset()\n phonon.generate_displacements(distance=0.0001)\n cells_with_disp = phonon.get_supercells_with_displacements()\n print(cells_with_disp[0])\n print(generate_VASP_structure(cells_with_disp[0]))\n\n supercell_wd = rebuild_connectivity_tinker(structure,\n cells_with_disp[0],\n phonon.get_supercell_matrix())\n\n print(generate_tinker_txyz_file(supercell_wd))\n print(generate_tinker_key_file(supercell_wd))\n\n print(generate_VASP_structure(structure))\n\n import tempfile\n import subprocess\n import os\n from subprocess import PIPE\n\n force_field = 'mm3'\n temp_file_name = tempfile.gettempdir() + '/tinker_temp'+ '_' + str(os.getpid())\n\n\n tinker_input_file = open(temp_file_name + '.txyz',mode='w')\n tinker_input_file.write(generate_tinker_txyz_file(supercell_wd))\n\n tinker_key_file = open(temp_file_name + '.key',mode='w')\n tinker_key_file.write(generate_tinker_key_file(supercell_wd))\n\n tinker_input_file.close()\n tinker_key_file.close()\n\n\n print('filename', tinker_input_file)\n tinker_command = './testgrad ' + tinker_input_file.name + \\\n ' ' + force_field + ' Y N N ' + ' -k ' + tinker_key_file.name\n\n tinker_process = subprocess.Popen(tinker_command, stdin=PIPE, stderr=PIPE, stdout=PIPE, shell=True)\n (output, err) = tinker_process.communicate()\n tinker_process.wait()\n\n os.unlink(tinker_input_file.name)\n os.unlink(tinker_key_file.name)\n\n forces = parse_tinker_forces(output)\n print(forces)\n print(forces.shape)\n", "meta": {"hexsha": "77ba970546cac26156e8aead4dfc9510f5c116a8", "size": 30650, "ext": "py", "lang": "Python", "max_stars_repo_path": "phonolammps/__init__.py", "max_stars_repo_name": "abelcarreras/phonolammps", "max_stars_repo_head_hexsha": "6c7a6655630f8c0bc60f69f327b0dc2a3cfaef19", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 41, "max_stars_repo_stars_event_min_datetime": "2018-01-22T04:51:05.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-10T02:49:46.000Z", "max_issues_repo_path": "phonolammps/__init__.py", "max_issues_repo_name": "abelcarreras/phonolammps", "max_issues_repo_head_hexsha": "6c7a6655630f8c0bc60f69f327b0dc2a3cfaef19", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2019-06-04T02:21:12.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-26T13:48:55.000Z", "max_forks_repo_path": "phonolammps/__init__.py", "max_forks_repo_name": "abelcarreras/phonolammps", "max_forks_repo_head_hexsha": "6c7a6655630f8c0bc60f69f327b0dc2a3cfaef19", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 15, "max_forks_repo_forks_event_min_datetime": "2018-11-30T11:06:12.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-28T13:58:43.000Z", "avg_line_length": 35.8060747664, "max_line_length": 116, "alphanum_fraction": 0.5726916803, "include": true, "reason": "import numpy", "num_tokens": 7049, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.600188359260205, "lm_q2_score": 0.3242353924510608, "lm_q1q2_score": 0.19460230820929084}} {"text": "# Licensed under a 3-clause BSD style license - see LICENSE.rst\nimport abc\nimport logging\nimport numpy as np\nfrom astropy import units as u\nfrom gammapy.maps import MapAxes, MapAxis\nfrom gammapy.utils.gauss import MultiGauss2D\nfrom gammapy.utils.interpolation import ScaledRegularGridInterpolator\nfrom .core import PSF\n\n__all__ = [\"ParametricPSF\", \"EnergyDependentMultiGaussPSF\", \"PSFKing\"]\n\nlog = logging.getLogger(__name__)\n\n\nclass ParametricPSF(PSF):\n \"\"\"Parametric PSF base class\n\n Parameters\n -----------\n axes : list of `MapAxis` or `MapAxes`\n Axes\n data : dict of `~numpy.ndarray`, or `~numpy.recarray`\n Data\n unit : dict of str or `~astropy.units.Unit`\n Unit\n meta : dict\n Meta data\n \"\"\"\n\n @property\n @abc.abstractmethod\n def required_parameters(self):\n pass\n\n @abc.abstractmethod\n def evaluate_direct(self, rad, **kwargs):\n pass\n\n @abc.abstractmethod\n def evaluate_containment(self, rad, **kwargs):\n pass\n\n def normalize(self):\n \"\"\"Normalize parametric PSF\"\"\"\n raise NotImplementedError\n\n @property\n def quantity(self):\n \"\"\"Quantity\"\"\"\n quantity = {}\n\n for name in self.required_parameters:\n quantity[name] = self.data[name] * self.unit[name]\n\n return quantity\n\n @property\n def unit(self):\n \"\"\"Map unit (`~astropy.units.Unit`)\"\"\"\n return self._unit\n\n @unit.setter\n def unit(self, values):\n self._unit = {key: u.Unit(val) for key, val in values.items()}\n\n @property\n def _interpolators(self):\n interps = {}\n\n for name in self.required_parameters:\n points = [a.center for a in self.axes]\n points_scale = tuple([a.interp for a in self.axes])\n interps[name] = ScaledRegularGridInterpolator(\n points, values=self.quantity[name], points_scale=points_scale\n )\n\n return interps\n\n def evaluate_parameters(self, energy_true, offset):\n \"\"\"Evaluate analytic PSF parameters at a given energy and offset.\n\n Uses nearest-neighbor interpolation.\n\n Parameters\n ----------\n energy_true : `~astropy.units.Quantity`\n energy value\n offset : `~astropy.coordinates.Angle`\n Offset in the field of view\n\n Returns\n -------\n values : `~astropy.units.Quantity`\n Interpolated value\n \"\"\"\n pars = {}\n for name in self.required_parameters:\n value = self._interpolators[name]((energy_true, offset))\n pars[name] = value\n\n return pars\n\n def to_table(self, format=\"gadf-dl3\"):\n \"\"\"Convert PSF table data to table.\n\n Parameters\n ----------\n format : {\"gadf-dl3\"}\n Format specification\n\n\n Returns\n -------\n hdu_list : `~astropy.io.fits.HDUList`\n PSF in HDU list format.\n \"\"\"\n from gammapy.irf.io import IRF_DL3_HDU_SPECIFICATION\n\n table = self.axes.to_table(format=\"gadf-dl3\")\n spec = IRF_DL3_HDU_SPECIFICATION[self.tag][\"column_name\"]\n\n for name in self.required_parameters:\n column_name = spec[name]\n table[column_name] = self.data[name].T[np.newaxis]\n table[column_name].unit = self.unit[name]\n\n # Create hdu and hdu list\n return table\n\n @classmethod\n def from_table(cls, table, format=\"gadf-dl3\"):\n \"\"\"Create parametric psf from `~astropy.table.Table`.\n\n Parameters\n ----------\n table : `~astropy.table.Table`\n Table info.\n\n Returns\n -------\n psf : `~ParametricPSF`\n PSF class\n \"\"\"\n from gammapy.irf.io import IRF_DL3_HDU_SPECIFICATION\n\n axes = MapAxes.from_table(table, format=format)[cls.required_axes]\n\n dtype = {\n \"names\": cls.required_parameters,\n \"formats\": len(cls.required_parameters) * (np.float32,),\n }\n\n data = np.empty(axes.shape, dtype=dtype)\n unit = {}\n\n spec = IRF_DL3_HDU_SPECIFICATION[cls.tag][\"column_name\"]\n\n for name in cls.required_parameters:\n column = table[spec[name]]\n values = column.data[0].transpose()\n\n # TODO: this fixes some files where sigma is written as zero\n if \"sigma\" in name:\n values[values == 0] = 1.0\n\n data[name] = values.reshape(axes.shape)\n unit[name] = column.unit or \"\"\n\n return cls(axes=axes, data=data, meta=table.meta.copy(), unit=unit)\n\n def to_psf3d(self, rad=None):\n \"\"\"Create a PSF3D from a parametric PSF.\n\n It will be defined on the same energy and offset values than the input psf.\n\n Parameters\n ----------\n rad : `~astropy.units.Quantity`\n Rad values\n\n Returns\n -------\n psf3d : `~gammapy.irf.PSF3D`\n PSF3D.\n \"\"\"\n from gammapy.datasets.map import RAD_AXIS_DEFAULT\n from gammapy.irf import PSF3D\n\n offset_axis = self.axes[\"offset\"]\n energy_axis_true = self.axes[\"energy_true\"]\n\n if rad is None:\n rad_axis = RAD_AXIS_DEFAULT.center\n else:\n rad_axis = MapAxis.from_edges(rad, name=\"rad\")\n\n axes = MapAxes([energy_axis_true, offset_axis, rad_axis])\n data = self.evaluate(**axes.get_coord())\n\n return PSF3D(axes=axes, data=data.value, unit=data.unit, meta=self.meta.copy())\n\n def __str__(self):\n str_ = f\"{self.__class__.__name__}\\n\"\n str_ += \"-\" * len(self.__class__.__name__) + \"\\n\\n\"\n str_ += f\"\\taxes : {self.axes.names}\\n\"\n str_ += f\"\\tshape : {self.data.shape}\\n\"\n str_ += f\"\\tndim : {len(self.axes)}\\n\"\n str_ += f\"\\tparameters: {self.required_parameters}\\n\"\n return str_.expandtabs(tabsize=2)\n\n def containment(self, rad, **kwargs):\n \"\"\"Containment of the PSF at given axes coordinates\n\n Parameters\n ----------\n rad : `~astropy.units.Quantity`\n Rad value\n **kwargs : dict\n Other coordinates\n\n Returns\n -------\n containment : `~numpy.ndarray`\n Containment\n \"\"\"\n pars = self.evaluate_parameters(**kwargs)\n containment = self.evaluate_containment(rad=rad, **pars)\n return containment\n\n def evaluate(self, rad, **kwargs):\n \"\"\"Evaluate the PSF model.\n\n Parameters\n ----------\n rad : `~astropy.coordinates.Angle`\n Offset from PSF center used for evaluating the PSF on a grid\n **kwargs : dict\n Other coordinates\n\n Returns\n -------\n psf_value : `~astropy.units.Quantity`\n PSF value\n \"\"\"\n pars = self.evaluate_parameters(**kwargs)\n value = self.evaluate_direct(rad=rad, **pars)\n return value\n\n\ndef get_sigmas_and_norms(**kwargs):\n \"\"\"Convert scale and amplitude to norms\"\"\"\n sigmas = u.Quantity([kwargs[f\"sigma_{idx}\"] for idx in [1, 2, 3]])\n\n scale = kwargs[\"scale\"]\n ones = np.ones(scale.shape)\n amplitudes = u.Quantity([ones, kwargs[\"ampl_2\"], kwargs[\"ampl_3\"]])\n norms = 2 * scale * amplitudes * sigmas ** 2\n return sigmas, norms\n\n\nclass EnergyDependentMultiGaussPSF(ParametricPSF):\n \"\"\"Triple Gauss analytical PSF depending on true energy and offset.\n\n Parameters\n ----------\n axes : list of `MapAxis`\n Required axes are [\"energy_true\", \"offset\"]\n data : `~numpy.recarray`\n Data array\n meta : dict\n Meta data\n\n Examples\n --------\n Plot R68 of the PSF vs. offset and true energy:\n\n .. plot::\n :include-source:\n\n import matplotlib.pyplot as plt\n from gammapy.irf import EnergyDependentMultiGaussPSF\n filename = '$GAMMAPY_DATA/cta-1dc/caldb/data/cta/1dc/bcf/South_z20_50h/irf_file.fits'\n psf = EnergyDependentMultiGaussPSF.read(filename, hdu='POINT SPREAD FUNCTION')\n psf.plot_containment_radius(fraction=0.68)\n plt.show()\n \"\"\"\n\n tag = \"psf_3gauss\"\n required_axes = [\"energy_true\", \"offset\"]\n required_parameters = [\"sigma_1\", \"sigma_2\", \"sigma_3\", \"scale\", \"ampl_2\", \"ampl_3\"]\n\n @staticmethod\n def evaluate_containment(rad, **kwargs):\n \"\"\"Containment of the PSF at given axes coordinates\n\n Parameters\n ----------\n rad : `~astropy.units.Quantity`\n Rad value\n **kwargs : dict\n Parameters, see `required_parameters`\n\n Returns\n -------\n containment : `~numpy.ndarray`\n Containment\n \"\"\"\n sigmas, norms = get_sigmas_and_norms(**kwargs)\n m = MultiGauss2D(sigmas=sigmas, norms=norms)\n m.normalize()\n containment = m.containment_fraction(rad)\n return containment\n\n @staticmethod\n def evaluate_direct(rad, **kwargs):\n \"\"\"Evaluate psf model\n\n Parameters\n ----------\n rad : `~astropy.units.Quantity`\n Rad value\n **kwargs : dict\n Parameters, see `required_parameters`\n\n Returns\n -------\n value : `~numpy.ndarray`\n PSF value\n \"\"\"\n sigmas, norms = get_sigmas_and_norms(**kwargs)\n m = MultiGauss2D(sigmas=sigmas, norms=norms)\n m.normalize()\n return m(rad)\n\n\nclass PSFKing(ParametricPSF):\n \"\"\"King profile analytical PSF depending on energy and offset.\n\n This PSF parametrisation and FITS data format is described here: :ref:`gadf:psf_king`.\n\n Parameters\n ----------\n axes : list of `MapAxis` or `MapAxes`\n Data axes, required are [\"energy_true\", \"offset\"]\n meta : dict\n Meta data\n\n \"\"\"\n\n tag = \"psf_king\"\n required_axes = [\"energy_true\", \"offset\"]\n required_parameters = [\"gamma\", \"sigma\"]\n default_interp_kwargs = dict(bounds_error=False, fill_value=None)\n\n @staticmethod\n def evaluate_containment(rad, gamma, sigma):\n \"\"\"Containment of the PSF at given axes coordinates\n\n Parameters\n ----------\n rad : `~astropy.units.Quantity`\n Rad value\n gamma : `~astropy.units.Quantity`\n Gamma parameter\n sigma : `~astropy.units.Quantity`\n Sigma parameter\n\n Returns\n -------\n containment : `~numpy.ndarray`\n Containment\n \"\"\"\n with np.errstate(divide=\"ignore\", invalid=\"ignore\"):\n term_1 = -((1 + rad ** 2 / (2 * gamma * sigma ** 2)) ** -gamma)\n term_2 = rad ** 2 + 2 * gamma * sigma ** 2\n term_3 = 2 * gamma * sigma ** 2\n containment = term_1 * term_2 / term_3\n\n return containment\n\n @staticmethod\n def evaluate_direct(rad, gamma, sigma):\n \"\"\"Evaluate the PSF model.\n\n Formula is given here: :ref:`gadf:psf_king`.\n\n Parameters\n ----------\n rad : `~astropy.coordinates.Angle`\n Offset from PSF center used for evaluating the PSF on a grid\n\n Returns\n -------\n psf_value : `~astropy.units.Quantity`\n PSF value\n \"\"\"\n with np.errstate(divide=\"ignore\"):\n term1 = 1 / (2 * np.pi * sigma ** 2)\n term2 = 1 - 1 / gamma\n term3 = (1 + rad ** 2 / (2 * gamma * sigma ** 2)) ** (-gamma)\n\n return term1 * term2 * term3\n", "meta": {"hexsha": "7329124c7028f4d055ad58c10bd8953b35927631", "size": 11375, "ext": "py", "lang": "Python", "max_stars_repo_path": "gammapy/irf/psf/parametric.py", "max_stars_repo_name": "Rishank2610/gammapy", "max_stars_repo_head_hexsha": "3cd64fdb2c53c8e5c697a9b85ef8d0486bff0b76", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2017-11-22T17:07:56.000Z", "max_stars_repo_stars_event_max_datetime": "2017-11-22T17:07:56.000Z", "max_issues_repo_path": "gammapy/irf/psf/parametric.py", "max_issues_repo_name": "Rishank2610/gammapy", "max_issues_repo_head_hexsha": "3cd64fdb2c53c8e5c697a9b85ef8d0486bff0b76", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "gammapy/irf/psf/parametric.py", "max_forks_repo_name": "Rishank2610/gammapy", "max_forks_repo_head_hexsha": "3cd64fdb2c53c8e5c697a9b85ef8d0486bff0b76", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-09-04T14:03:33.000Z", "max_forks_repo_forks_event_max_datetime": "2019-09-04T14:03:33.000Z", "avg_line_length": 28.1559405941, "max_line_length": 93, "alphanum_fraction": 0.5741538462, "include": true, "reason": "import numpy,from astropy", "num_tokens": 2729, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.600188359260205, "lm_q2_score": 0.3242353924510608, "lm_q1q2_score": 0.19460230820929084}} {"text": "\"\"\"\nCalculate the solar position using the NREL SPA algorithm either using\nnumpy arrays or compiling the code to machine language with numba.\n\"\"\"\n\n# Contributors:\n# Created by Tony Lorenzo (@alorenzo175), Univ. of Arizona, 2015\n\nfrom __future__ import division\nimport os\nimport threading\nimport warnings\n\nimport numpy as np\n\n\n# this block is a way to use an environment variable to switch between\n# compiling the functions with numba or just use numpy\ndef nocompile(*args, **kwargs):\n return lambda func: func\n\n\nif os.getenv('PVLIB_USE_NUMBA', '0') != '0':\n try:\n from numba import jit, __version__\n except ImportError:\n warnings.warn('Could not import numba, falling back to numpy ' +\n 'calculation')\n jcompile = nocompile\n USE_NUMBA = False\n else:\n major, minor = __version__.split('.')[:2]\n if int(major + minor) >= 17:\n # need at least numba >= 0.17.0\n jcompile = jit\n USE_NUMBA = True\n else:\n warnings.warn('Numba version must be >= 0.17.0, falling back to ' +\n 'numpy')\n jcompile = nocompile\n USE_NUMBA = False\nelse:\n jcompile = nocompile\n USE_NUMBA = False\n\n\nTABLE_1_DICT = {\n 'L0': np.array(\n [[175347046.0, 0.0, 0.0],\n [3341656.0, 4.6692568, 6283.07585],\n [34894.0, 4.6261, 12566.1517],\n [3497.0, 2.7441, 5753.3849],\n [3418.0, 2.8289, 3.5231],\n [3136.0, 3.6277, 77713.7715],\n [2676.0, 4.4181, 7860.4194],\n [2343.0, 6.1352, 3930.2097],\n [1324.0, 0.7425, 11506.7698],\n [1273.0, 2.0371, 529.691],\n [1199.0, 1.1096, 1577.3435],\n [990.0, 5.233, 5884.927],\n [902.0, 2.045, 26.298],\n [857.0, 3.508, 398.149],\n [780.0, 1.179, 5223.694],\n [753.0, 2.533, 5507.553],\n [505.0, 4.583, 18849.228],\n [492.0, 4.205, 775.523],\n [357.0, 2.92, 0.067],\n [317.0, 5.849, 11790.629],\n [284.0, 1.899, 796.298],\n [271.0, 0.315, 10977.079],\n [243.0, 0.345, 5486.778],\n [206.0, 4.806, 2544.314],\n [205.0, 1.869, 5573.143],\n [202.0, 2.458, 6069.777],\n [156.0, 0.833, 213.299],\n [132.0, 3.411, 2942.463],\n [126.0, 1.083, 20.775],\n [115.0, 0.645, 0.98],\n [103.0, 0.636, 4694.003],\n [102.0, 0.976, 15720.839],\n [102.0, 4.267, 7.114],\n [99.0, 6.21, 2146.17],\n [98.0, 0.68, 155.42],\n [86.0, 5.98, 161000.69],\n [85.0, 1.3, 6275.96],\n [85.0, 3.67, 71430.7],\n [80.0, 1.81, 17260.15],\n [79.0, 3.04, 12036.46],\n [75.0, 1.76, 5088.63],\n [74.0, 3.5, 3154.69],\n [74.0, 4.68, 801.82],\n [70.0, 0.83, 9437.76],\n [62.0, 3.98, 8827.39],\n [61.0, 1.82, 7084.9],\n [57.0, 2.78, 6286.6],\n [56.0, 4.39, 14143.5],\n [56.0, 3.47, 6279.55],\n [52.0, 0.19, 12139.55],\n [52.0, 1.33, 1748.02],\n [51.0, 0.28, 5856.48],\n [49.0, 0.49, 1194.45],\n [41.0, 5.37, 8429.24],\n [41.0, 2.4, 19651.05],\n [39.0, 6.17, 10447.39],\n [37.0, 6.04, 10213.29],\n [37.0, 2.57, 1059.38],\n [36.0, 1.71, 2352.87],\n [36.0, 1.78, 6812.77],\n [33.0, 0.59, 17789.85],\n [30.0, 0.44, 83996.85],\n [30.0, 2.74, 1349.87],\n [25.0, 3.16, 4690.48]]),\n 'L1': np.array(\n [[628331966747.0, 0.0, 0.0],\n [206059.0, 2.678235, 6283.07585],\n [4303.0, 2.6351, 12566.1517],\n [425.0, 1.59, 3.523],\n [119.0, 5.796, 26.298],\n [109.0, 2.966, 1577.344],\n [93.0, 2.59, 18849.23],\n [72.0, 1.14, 529.69],\n [68.0, 1.87, 398.15],\n [67.0, 4.41, 5507.55],\n [59.0, 2.89, 5223.69],\n [56.0, 2.17, 155.42],\n [45.0, 0.4, 796.3],\n [36.0, 0.47, 775.52],\n [29.0, 2.65, 7.11],\n [21.0, 5.34, 0.98],\n [19.0, 1.85, 5486.78],\n [19.0, 4.97, 213.3],\n [17.0, 2.99, 6275.96],\n [16.0, 0.03, 2544.31],\n [16.0, 1.43, 2146.17],\n [15.0, 1.21, 10977.08],\n [12.0, 2.83, 1748.02],\n [12.0, 3.26, 5088.63],\n [12.0, 5.27, 1194.45],\n [12.0, 2.08, 4694.0],\n [11.0, 0.77, 553.57],\n [10.0, 1.3, 6286.6],\n [10.0, 4.24, 1349.87],\n [9.0, 2.7, 242.73],\n [9.0, 5.64, 951.72],\n [8.0, 5.3, 2352.87],\n [6.0, 2.65, 9437.76],\n [6.0, 4.67, 4690.48]]),\n 'L2': np.array(\n [[52919.0, 0.0, 0.0],\n [8720.0, 1.0721, 6283.0758],\n [309.0, 0.867, 12566.152],\n [27.0, 0.05, 3.52],\n [16.0, 5.19, 26.3],\n [16.0, 3.68, 155.42],\n [10.0, 0.76, 18849.23],\n [9.0, 2.06, 77713.77],\n [7.0, 0.83, 775.52],\n [5.0, 4.66, 1577.34],\n [4.0, 1.03, 7.11],\n [4.0, 3.44, 5573.14],\n [3.0, 5.14, 796.3],\n [3.0, 6.05, 5507.55],\n [3.0, 1.19, 242.73],\n [3.0, 6.12, 529.69],\n [3.0, 0.31, 398.15],\n [3.0, 2.28, 553.57],\n [2.0, 4.38, 5223.69],\n [2.0, 3.75, 0.98]]),\n 'L3': np.array(\n [[289.0, 5.844, 6283.076],\n [35.0, 0.0, 0.0],\n [17.0, 5.49, 12566.15],\n [3.0, 5.2, 155.42],\n [1.0, 4.72, 3.52],\n [1.0, 5.3, 18849.23],\n [1.0, 5.97, 242.73]]),\n 'L4': np.array(\n [[114.0, 3.142, 0.0],\n [8.0, 4.13, 6283.08],\n [1.0, 3.84, 12566.15]]),\n 'L5': np.array(\n [[1.0, 3.14, 0.0]]),\n 'B0': np.array(\n [[280.0, 3.199, 84334.662],\n [102.0, 5.422, 5507.553],\n [80.0, 3.88, 5223.69],\n [44.0, 3.7, 2352.87],\n [32.0, 4.0, 1577.34]]),\n 'B1': np.array(\n [[9.0, 3.9, 5507.55],\n [6.0, 1.73, 5223.69]]),\n 'R0': np.array(\n [[100013989.0, 0.0, 0.0],\n [1670700.0, 3.0984635, 6283.07585],\n [13956.0, 3.05525, 12566.1517],\n [3084.0, 5.1985, 77713.7715],\n [1628.0, 1.1739, 5753.3849],\n [1576.0, 2.8469, 7860.4194],\n [925.0, 5.453, 11506.77],\n [542.0, 4.564, 3930.21],\n [472.0, 3.661, 5884.927],\n [346.0, 0.964, 5507.553],\n [329.0, 5.9, 5223.694],\n [307.0, 0.299, 5573.143],\n [243.0, 4.273, 11790.629],\n [212.0, 5.847, 1577.344],\n [186.0, 5.022, 10977.079],\n [175.0, 3.012, 18849.228],\n [110.0, 5.055, 5486.778],\n [98.0, 0.89, 6069.78],\n [86.0, 5.69, 15720.84],\n [86.0, 1.27, 161000.69],\n [65.0, 0.27, 17260.15],\n [63.0, 0.92, 529.69],\n [57.0, 2.01, 83996.85],\n [56.0, 5.24, 71430.7],\n [49.0, 3.25, 2544.31],\n [47.0, 2.58, 775.52],\n [45.0, 5.54, 9437.76],\n [43.0, 6.01, 6275.96],\n [39.0, 5.36, 4694.0],\n [38.0, 2.39, 8827.39],\n [37.0, 0.83, 19651.05],\n [37.0, 4.9, 12139.55],\n [36.0, 1.67, 12036.46],\n [35.0, 1.84, 2942.46],\n [33.0, 0.24, 7084.9],\n [32.0, 0.18, 5088.63],\n [32.0, 1.78, 398.15],\n [28.0, 1.21, 6286.6],\n [28.0, 1.9, 6279.55],\n [26.0, 4.59, 10447.39]]),\n 'R1': np.array(\n [[103019.0, 1.10749, 6283.07585],\n [1721.0, 1.0644, 12566.1517],\n [702.0, 3.142, 0.0],\n [32.0, 1.02, 18849.23],\n [31.0, 2.84, 5507.55],\n [25.0, 1.32, 5223.69],\n [18.0, 1.42, 1577.34],\n [10.0, 5.91, 10977.08],\n [9.0, 1.42, 6275.96],\n [9.0, 0.27, 5486.78]]),\n 'R2': np.array(\n [[4359.0, 5.7846, 6283.0758],\n [124.0, 5.579, 12566.152],\n [12.0, 3.14, 0.0],\n [9.0, 3.63, 77713.77],\n [6.0, 1.87, 5573.14],\n [3.0, 5.47, 18849.23]]),\n 'R3': np.array(\n [[145.0, 4.273, 6283.076],\n [7.0, 3.92, 12566.15]]),\n 'R4': np.array(\n [[4.0, 2.56, 6283.08]])\n}\n\n\nTABLE_1_DICT['L1'].resize((64, 3))\nTABLE_1_DICT['L2'].resize((64, 3))\nTABLE_1_DICT['L3'].resize((64, 3))\nTABLE_1_DICT['L4'].resize((64, 3))\nTABLE_1_DICT['L5'].resize((64, 3))\n\nTABLE_1_DICT['B1'].resize((5, 3))\n\nTABLE_1_DICT['R1'].resize((40, 3))\nTABLE_1_DICT['R2'].resize((40, 3))\nTABLE_1_DICT['R3'].resize((40, 3))\nTABLE_1_DICT['R4'].resize((40, 3))\n\n\nHELIO_LONG_TABLE = np.array([TABLE_1_DICT['L0'],\n TABLE_1_DICT['L1'],\n TABLE_1_DICT['L2'],\n TABLE_1_DICT['L3'],\n TABLE_1_DICT['L4'],\n TABLE_1_DICT['L5']])\n\n\nHELIO_LAT_TABLE = np.array([TABLE_1_DICT['B0'],\n TABLE_1_DICT['B1']])\n\n\nHELIO_RADIUS_TABLE = np.array([TABLE_1_DICT['R0'],\n TABLE_1_DICT['R1'],\n TABLE_1_DICT['R2'],\n TABLE_1_DICT['R3'],\n TABLE_1_DICT['R4']])\n\n\nNUTATION_ABCD_ARRAY = np.array([\n [-171996, -174.2, 92025, 8.9],\n [-13187, -1.6, 5736, -3.1],\n [-2274, -0.2, 977, -0.5],\n [2062, 0.2, -895, 0.5],\n [1426, -3.4, 54, -0.1],\n [712, 0.1, -7, 0],\n [-517, 1.2, 224, -0.6],\n [-386, -0.4, 200, 0],\n [-301, 0, 129, -0.1],\n [217, -0.5, -95, 0.3],\n [-158, 0, 0, 0],\n [129, 0.1, -70, 0],\n [123, 0, -53, 0],\n [63, 0, 0, 0],\n [63, 0.1, -33, 0],\n [-59, 0, 26, 0],\n [-58, -0.1, 32, 0],\n [-51, 0, 27, 0],\n [48, 0, 0, 0],\n [46, 0, -24, 0],\n [-38, 0, 16, 0],\n [-31, 0, 13, 0],\n [29, 0, 0, 0],\n [29, 0, -12, 0],\n [26, 0, 0, 0],\n [-22, 0, 0, 0],\n [21, 0, -10, 0],\n [17, -0.1, 0, 0],\n [16, 0, -8, 0],\n [-16, 0.1, 7, 0],\n [-15, 0, 9, 0],\n [-13, 0, 7, 0],\n [-12, 0, 6, 0],\n [11, 0, 0, 0],\n [-10, 0, 5, 0],\n [-8, 0, 3, 0],\n [7, 0, -3, 0],\n [-7, 0, 0, 0],\n [-7, 0, 3, 0],\n [-7, 0, 3, 0],\n [6, 0, 0, 0],\n [6, 0, -3, 0],\n [6, 0, -3, 0],\n [-6, 0, 3, 0],\n [-6, 0, 3, 0],\n [5, 0, 0, 0],\n [-5, 0, 3, 0],\n [-5, 0, 3, 0],\n [-5, 0, 3, 0],\n [4, 0, 0, 0],\n [4, 0, 0, 0],\n [4, 0, 0, 0],\n [-4, 0, 0, 0],\n [-4, 0, 0, 0],\n [-4, 0, 0, 0],\n [3, 0, 0, 0],\n [-3, 0, 0, 0],\n [-3, 0, 0, 0],\n [-3, 0, 0, 0],\n [-3, 0, 0, 0],\n [-3, 0, 0, 0],\n [-3, 0, 0, 0],\n [-3, 0, 0, 0],\n])\n\n\nNUTATION_YTERM_ARRAY = np.array([\n [0, 0, 0, 0, 1],\n [-2, 0, 0, 2, 2],\n [0, 0, 0, 2, 2],\n [0, 0, 0, 0, 2],\n [0, 1, 0, 0, 0],\n [0, 0, 1, 0, 0],\n [-2, 1, 0, 2, 2],\n [0, 0, 0, 2, 1],\n [0, 0, 1, 2, 2],\n [-2, -1, 0, 2, 2],\n [-2, 0, 1, 0, 0],\n [-2, 0, 0, 2, 1],\n [0, 0, -1, 2, 2],\n [2, 0, 0, 0, 0],\n [0, 0, 1, 0, 1],\n [2, 0, -1, 2, 2],\n [0, 0, -1, 0, 1],\n [0, 0, 1, 2, 1],\n [-2, 0, 2, 0, 0],\n [0, 0, -2, 2, 1],\n [2, 0, 0, 2, 2],\n [0, 0, 2, 2, 2],\n [0, 0, 2, 0, 0],\n [-2, 0, 1, 2, 2],\n [0, 0, 0, 2, 0],\n [-2, 0, 0, 2, 0],\n [0, 0, -1, 2, 1],\n [0, 2, 0, 0, 0],\n [2, 0, -1, 0, 1],\n [-2, 2, 0, 2, 2],\n [0, 1, 0, 0, 1],\n [-2, 0, 1, 0, 1],\n [0, -1, 0, 0, 1],\n [0, 0, 2, -2, 0],\n [2, 0, -1, 2, 1],\n [2, 0, 1, 2, 2],\n [0, 1, 0, 2, 2],\n [-2, 1, 1, 0, 0],\n [0, -1, 0, 2, 2],\n [2, 0, 0, 2, 1],\n [2, 0, 1, 0, 0],\n [-2, 0, 2, 2, 2],\n [-2, 0, 1, 2, 1],\n [2, 0, -2, 0, 1],\n [2, 0, 0, 0, 1],\n [0, -1, 1, 0, 0],\n [-2, -1, 0, 2, 1],\n [-2, 0, 0, 0, 1],\n [0, 0, 2, 2, 1],\n [-2, 0, 2, 0, 1],\n [-2, 1, 0, 2, 1],\n [0, 0, 1, -2, 0],\n [-1, 0, 1, 0, 0],\n [-2, 1, 0, 0, 0],\n [1, 0, 0, 0, 0],\n [0, 0, 1, 2, 0],\n [0, 0, -2, 2, 2],\n [-1, -1, 1, 0, 0],\n [0, 1, 1, 0, 0],\n [0, -1, 1, 2, 2],\n [2, -1, -1, 2, 2],\n [0, 0, 3, 2, 2],\n [2, -1, 0, 2, 2],\n])\n\n\n@jcompile('float64(int64, int64, int64, int64, int64, int64, int64)',\n nopython=True)\ndef julian_day_dt(year, month, day, hour, minute, second, microsecond):\n \"\"\"This is the original way to calculate the julian day from the NREL paper.\n However, it is much faster to convert to unix/epoch time and then convert\n to julian day. Note that the date must be UTC.\"\"\"\n if month <= 2:\n year = year-1\n month = month+12\n a = int(year/100)\n b = 2 - a + int(a * 0.25)\n frac_of_day = (microsecond + (second + minute * 60 + hour * 3600)\n ) * 1.0 / (3600*24)\n d = day + frac_of_day\n jd = (int(365.25 * (year + 4716)) + int(30.6001 * (month + 1)) + d +\n b - 1524.5)\n return jd\n\n\n@jcompile('float64(float64)', nopython=True)\ndef julian_day(unixtime):\n jd = unixtime * 1.0 / 86400 + 2440587.5\n return jd\n\n\n@jcompile('float64(float64, float64)', nopython=True)\ndef julian_ephemeris_day(julian_day, delta_t):\n jde = julian_day + delta_t * 1.0 / 86400\n return jde\n\n\n@jcompile('float64(float64)', nopython=True)\ndef julian_century(julian_day):\n jc = (julian_day - 2451545) * 1.0 / 36525\n return jc\n\n\n@jcompile('float64(float64)', nopython=True)\ndef julian_ephemeris_century(julian_ephemeris_day):\n jce = (julian_ephemeris_day - 2451545) * 1.0 / 36525\n return jce\n\n\n@jcompile('float64(float64)', nopython=True)\ndef julian_ephemeris_millennium(julian_ephemeris_century):\n jme = julian_ephemeris_century * 1.0 / 10\n return jme\n\n\n@jcompile('float64(float64)', nopython=True)\ndef heliocentric_longitude(jme):\n l0 = 0.0\n l1 = 0.0\n l2 = 0.0\n l3 = 0.0\n l4 = 0.0\n l5 = 0.0\n\n for row in range(HELIO_LONG_TABLE.shape[1]):\n l0 += (HELIO_LONG_TABLE[0, row, 0]\n * np.cos(HELIO_LONG_TABLE[0, row, 1]\n + HELIO_LONG_TABLE[0, row, 2] * jme)\n )\n l1 += (HELIO_LONG_TABLE[1, row, 0]\n * np.cos(HELIO_LONG_TABLE[1, row, 1]\n + HELIO_LONG_TABLE[1, row, 2] * jme)\n )\n l2 += (HELIO_LONG_TABLE[2, row, 0]\n * np.cos(HELIO_LONG_TABLE[2, row, 1]\n + HELIO_LONG_TABLE[2, row, 2] * jme)\n )\n l3 += (HELIO_LONG_TABLE[3, row, 0]\n * np.cos(HELIO_LONG_TABLE[3, row, 1]\n + HELIO_LONG_TABLE[3, row, 2] * jme)\n )\n l4 += (HELIO_LONG_TABLE[4, row, 0]\n * np.cos(HELIO_LONG_TABLE[4, row, 1]\n + HELIO_LONG_TABLE[4, row, 2] * jme)\n )\n l5 += (HELIO_LONG_TABLE[5, row, 0]\n * np.cos(HELIO_LONG_TABLE[5, row, 1]\n + HELIO_LONG_TABLE[5, row, 2] * jme)\n )\n\n l_rad = (l0 + l1 * jme + l2 * jme**2 + l3 * jme**3 + l4 * jme**4 +\n l5 * jme**5)/10**8\n l = np.rad2deg(l_rad)\n return l % 360\n\n\n@jcompile('float64(float64)', nopython=True)\ndef heliocentric_latitude(jme):\n b0 = 0.0\n b1 = 0.0\n for row in range(HELIO_LAT_TABLE.shape[1]):\n b0 += (HELIO_LAT_TABLE[0, row, 0]\n * np.cos(HELIO_LAT_TABLE[0, row, 1]\n + HELIO_LAT_TABLE[0, row, 2] * jme)\n )\n b1 += (HELIO_LAT_TABLE[1, row, 0]\n * np.cos(HELIO_LAT_TABLE[1, row, 1]\n + HELIO_LAT_TABLE[1, row, 2] * jme)\n )\n\n b_rad = (b0 + b1 * jme)/10**8\n b = np.rad2deg(b_rad)\n return b\n\n\n@jcompile('float64(float64)', nopython=True)\ndef heliocentric_radius_vector(jme):\n r0 = 0.0\n r1 = 0.0\n r2 = 0.0\n r3 = 0.0\n r4 = 0.0\n for row in range(HELIO_RADIUS_TABLE.shape[1]):\n r0 += (HELIO_RADIUS_TABLE[0, row, 0]\n * np.cos(HELIO_RADIUS_TABLE[0, row, 1]\n + HELIO_RADIUS_TABLE[0, row, 2] * jme)\n )\n r1 += (HELIO_RADIUS_TABLE[1, row, 0]\n * np.cos(HELIO_RADIUS_TABLE[1, row, 1]\n + HELIO_RADIUS_TABLE[1, row, 2] * jme)\n )\n r2 += (HELIO_RADIUS_TABLE[2, row, 0]\n * np.cos(HELIO_RADIUS_TABLE[2, row, 1]\n + HELIO_RADIUS_TABLE[2, row, 2] * jme)\n )\n r3 += (HELIO_RADIUS_TABLE[3, row, 0]\n * np.cos(HELIO_RADIUS_TABLE[3, row, 1]\n + HELIO_RADIUS_TABLE[3, row, 2] * jme)\n )\n r4 += (HELIO_RADIUS_TABLE[4, row, 0]\n * np.cos(HELIO_RADIUS_TABLE[4, row, 1]\n + HELIO_RADIUS_TABLE[4, row, 2] * jme)\n )\n\n r = (r0 + r1 * jme + r2 * jme**2 + r3 * jme**3 + r4 * jme**4)/10**8\n return r\n\n\n@jcompile('float64(float64)', nopython=True)\ndef geocentric_longitude(heliocentric_longitude):\n theta = heliocentric_longitude + 180.0\n return theta % 360\n\n\n@jcompile('float64(float64)', nopython=True)\ndef geocentric_latitude(heliocentric_latitude):\n beta = -1.0*heliocentric_latitude\n return beta\n\n\n@jcompile('float64(float64)', nopython=True)\ndef mean_elongation(julian_ephemeris_century):\n x0 = (297.85036\n + 445267.111480 * julian_ephemeris_century\n - 0.0019142 * julian_ephemeris_century**2\n + julian_ephemeris_century**3 / 189474)\n return x0\n\n\n@jcompile('float64(float64)', nopython=True)\ndef mean_anomaly_sun(julian_ephemeris_century):\n x1 = (357.52772\n + 35999.050340 * julian_ephemeris_century\n - 0.0001603 * julian_ephemeris_century**2\n - julian_ephemeris_century**3 / 300000)\n return x1\n\n\n@jcompile('float64(float64)', nopython=True)\ndef mean_anomaly_moon(julian_ephemeris_century):\n x2 = (134.96298\n + 477198.867398 * julian_ephemeris_century\n + 0.0086972 * julian_ephemeris_century**2\n + julian_ephemeris_century**3 / 56250)\n return x2\n\n\n@jcompile('float64(float64)', nopython=True)\ndef moon_argument_latitude(julian_ephemeris_century):\n x3 = (93.27191\n + 483202.017538 * julian_ephemeris_century\n - 0.0036825 * julian_ephemeris_century**2\n + julian_ephemeris_century**3 / 327270)\n return x3\n\n\n@jcompile('float64(float64)', nopython=True)\ndef moon_ascending_longitude(julian_ephemeris_century):\n x4 = (125.04452\n - 1934.136261 * julian_ephemeris_century\n + 0.0020708 * julian_ephemeris_century**2\n + julian_ephemeris_century**3 / 450000)\n return x4\n\n\n@jcompile('float64(float64, float64, float64, float64, float64, float64)',\n nopython=True)\ndef longitude_nutation(julian_ephemeris_century, x0, x1, x2, x3, x4):\n delta_psi_sum = 0\n for row in range(NUTATION_YTERM_ARRAY.shape[0]):\n a = NUTATION_ABCD_ARRAY[row, 0]\n b = NUTATION_ABCD_ARRAY[row, 1]\n argsin = (NUTATION_YTERM_ARRAY[row, 0]*x0 +\n NUTATION_YTERM_ARRAY[row, 1]*x1 +\n NUTATION_YTERM_ARRAY[row, 2]*x2 +\n NUTATION_YTERM_ARRAY[row, 3]*x3 +\n NUTATION_YTERM_ARRAY[row, 4]*x4)\n term = (a + b * julian_ephemeris_century) * np.sin(np.radians(argsin))\n delta_psi_sum += term\n delta_psi = delta_psi_sum*1.0/36000000\n return delta_psi\n\n\n@jcompile('float64(float64, float64, float64, float64, float64, float64)',\n nopython=True)\ndef obliquity_nutation(julian_ephemeris_century, x0, x1, x2, x3, x4):\n delta_eps_sum = 0.0\n for row in range(NUTATION_YTERM_ARRAY.shape[0]):\n c = NUTATION_ABCD_ARRAY[row, 2]\n d = NUTATION_ABCD_ARRAY[row, 3]\n argcos = (NUTATION_YTERM_ARRAY[row, 0]*x0 +\n NUTATION_YTERM_ARRAY[row, 1]*x1 +\n NUTATION_YTERM_ARRAY[row, 2]*x2 +\n NUTATION_YTERM_ARRAY[row, 3]*x3 +\n NUTATION_YTERM_ARRAY[row, 4]*x4)\n term = (c + d * julian_ephemeris_century) * np.cos(np.radians(argcos))\n delta_eps_sum += term\n delta_eps = delta_eps_sum*1.0/36000000\n return delta_eps\n\n\n@jcompile('float64(float64)', nopython=True)\ndef mean_ecliptic_obliquity(julian_ephemeris_millennium):\n U = 1.0*julian_ephemeris_millennium/10\n e0 = (84381.448 - 4680.93 * U - 1.55 * U**2\n + 1999.25 * U**3 - 51.38 * U**4 - 249.67 * U**5\n - 39.05 * U**6 + 7.12 * U**7 + 27.87 * U**8\n + 5.79 * U**9 + 2.45 * U**10)\n return e0\n\n\n@jcompile('float64(float64, float64)', nopython=True)\ndef true_ecliptic_obliquity(mean_ecliptic_obliquity, obliquity_nutation):\n e0 = mean_ecliptic_obliquity\n deleps = obliquity_nutation\n e = e0*1.0/3600 + deleps\n return e\n\n\n@jcompile('float64(float64)', nopython=True)\ndef aberration_correction(earth_radius_vector):\n deltau = -20.4898 / (3600 * earth_radius_vector)\n return deltau\n\n\n@jcompile('float64(float64, float64, float64)', nopython=True)\ndef apparent_sun_longitude(geocentric_longitude, longitude_nutation,\n aberration_correction):\n lamd = geocentric_longitude + longitude_nutation + aberration_correction\n return lamd\n\n\n@jcompile('float64(float64, float64)', nopython=True)\ndef mean_sidereal_time(julian_day, julian_century):\n v0 = (280.46061837 + 360.98564736629 * (julian_day - 2451545)\n + 0.000387933 * julian_century**2 - julian_century**3 / 38710000)\n return v0 % 360.0\n\n\n@jcompile('float64(float64, float64, float64)', nopython=True)\ndef apparent_sidereal_time(mean_sidereal_time, longitude_nutation,\n true_ecliptic_obliquity):\n v = mean_sidereal_time + longitude_nutation * np.cos(\n np.radians(true_ecliptic_obliquity))\n return v\n\n\n@jcompile('float64(float64, float64, float64)', nopython=True)\ndef geocentric_sun_right_ascension(apparent_sun_longitude,\n true_ecliptic_obliquity,\n geocentric_latitude):\n num = (np.sin(np.radians(apparent_sun_longitude))\n * np.cos(np.radians(true_ecliptic_obliquity))\n - np.tan(np.radians(geocentric_latitude))\n * np.sin(np.radians(true_ecliptic_obliquity)))\n alpha = np.degrees(np.arctan2(num, np.cos(\n np.radians(apparent_sun_longitude))))\n return alpha % 360\n\n\n@jcompile('float64(float64, float64, float64)', nopython=True)\ndef geocentric_sun_declination(apparent_sun_longitude, true_ecliptic_obliquity,\n geocentric_latitude):\n delta = np.degrees(np.arcsin(np.sin(np.radians(geocentric_latitude)) *\n np.cos(np.radians(true_ecliptic_obliquity)) +\n np.cos(np.radians(geocentric_latitude)) *\n np.sin(np.radians(true_ecliptic_obliquity)) *\n np.sin(np.radians(apparent_sun_longitude))))\n return delta\n\n\n@jcompile('float64(float64, float64, float64)', nopython=True)\ndef local_hour_angle(apparent_sidereal_time, observer_longitude,\n sun_right_ascension):\n \"\"\"Measured westward from south\"\"\"\n H = apparent_sidereal_time + observer_longitude - sun_right_ascension\n return H % 360\n\n\n@jcompile('float64(float64)', nopython=True)\ndef equatorial_horizontal_parallax(earth_radius_vector):\n xi = 8.794 / (3600 * earth_radius_vector)\n return xi\n\n\n@jcompile('float64(float64)', nopython=True)\ndef uterm(observer_latitude):\n u = np.arctan(0.99664719 * np.tan(np.radians(observer_latitude)))\n return u\n\n\n@jcompile('float64(float64, float64, float64)', nopython=True)\ndef xterm(u, observer_latitude, observer_elevation):\n x = (np.cos(u) + observer_elevation / 6378140\n * np.cos(np.radians(observer_latitude)))\n return x\n\n\n@jcompile('float64(float64, float64, float64)', nopython=True)\ndef yterm(u, observer_latitude, observer_elevation):\n y = (0.99664719 * np.sin(u) + observer_elevation / 6378140\n * np.sin(np.radians(observer_latitude)))\n return y\n\n\n@jcompile('float64(float64, float64,float64, float64)', nopython=True)\ndef parallax_sun_right_ascension(xterm, equatorial_horizontal_parallax,\n local_hour_angle, geocentric_sun_declination):\n num = (-xterm * np.sin(np.radians(equatorial_horizontal_parallax))\n * np.sin(np.radians(local_hour_angle)))\n denom = (np.cos(np.radians(geocentric_sun_declination))\n - xterm * np.sin(np.radians(equatorial_horizontal_parallax))\n * np.cos(np.radians(local_hour_angle)))\n delta_alpha = np.degrees(np.arctan2(num, denom))\n return delta_alpha\n\n\n@jcompile('float64(float64, float64)', nopython=True)\ndef topocentric_sun_right_ascension(geocentric_sun_right_ascension,\n parallax_sun_right_ascension):\n alpha_prime = geocentric_sun_right_ascension + parallax_sun_right_ascension\n return alpha_prime\n\n\n@jcompile('float64(float64, float64, float64, float64, float64, float64)',\n nopython=True)\ndef topocentric_sun_declination(geocentric_sun_declination, xterm, yterm,\n equatorial_horizontal_parallax,\n parallax_sun_right_ascension,\n local_hour_angle):\n num = ((np.sin(np.radians(geocentric_sun_declination)) - yterm\n * np.sin(np.radians(equatorial_horizontal_parallax)))\n * np.cos(np.radians(parallax_sun_right_ascension)))\n denom = (np.cos(np.radians(geocentric_sun_declination)) - xterm\n * np.sin(np.radians(equatorial_horizontal_parallax))\n * np.cos(np.radians(local_hour_angle)))\n delta = np.degrees(np.arctan2(num, denom))\n return delta\n\n\n@jcompile('float64(float64, float64)', nopython=True)\ndef topocentric_local_hour_angle(local_hour_angle,\n parallax_sun_right_ascension):\n H_prime = local_hour_angle - parallax_sun_right_ascension\n return H_prime\n\n\n@jcompile('float64(float64, float64, float64)', nopython=True)\ndef topocentric_elevation_angle_without_atmosphere(observer_latitude,\n topocentric_sun_declination,\n topocentric_local_hour_angle\n ):\n e0 = np.degrees(np.arcsin(\n np.sin(np.radians(observer_latitude))\n * np.sin(np.radians(topocentric_sun_declination))\n + np.cos(np.radians(observer_latitude))\n * np.cos(np.radians(topocentric_sun_declination))\n * np.cos(np.radians(topocentric_local_hour_angle))))\n return e0\n\n\n@jcompile('float64(float64, float64, float64, float64)', nopython=True)\ndef atmospheric_refraction_correction(local_pressure, local_temp,\n topocentric_elevation_angle_wo_atmosphere,\n atmos_refract):\n # switch sets delta_e when the sun is below the horizon\n switch = topocentric_elevation_angle_wo_atmosphere >= -1.0 * (\n 0.26667 + atmos_refract)\n delta_e = ((local_pressure / 1010.0) * (283.0 / (273 + local_temp))\n * 1.02 / (60 * np.tan(np.radians(\n topocentric_elevation_angle_wo_atmosphere\n + 10.3 / (topocentric_elevation_angle_wo_atmosphere\n + 5.11))))) * switch\n return delta_e\n\n\n@jcompile('float64(float64, float64)', nopython=True)\ndef topocentric_elevation_angle(topocentric_elevation_angle_without_atmosphere,\n atmospheric_refraction_correction):\n e = (topocentric_elevation_angle_without_atmosphere\n + atmospheric_refraction_correction)\n return e\n\n\n@jcompile('float64(float64)', nopython=True)\ndef topocentric_zenith_angle(topocentric_elevation_angle):\n theta = 90 - topocentric_elevation_angle\n return theta\n\n\n@jcompile('float64(float64, float64, float64)', nopython=True)\ndef topocentric_astronomers_azimuth(topocentric_local_hour_angle,\n topocentric_sun_declination,\n observer_latitude):\n num = np.sin(np.radians(topocentric_local_hour_angle))\n denom = (np.cos(np.radians(topocentric_local_hour_angle))\n * np.sin(np.radians(observer_latitude))\n - np.tan(np.radians(topocentric_sun_declination))\n * np.cos(np.radians(observer_latitude)))\n gamma = np.degrees(np.arctan2(num, denom))\n return gamma % 360\n\n\n@jcompile('float64(float64)', nopython=True)\ndef topocentric_azimuth_angle(topocentric_astronomers_azimuth):\n phi = topocentric_astronomers_azimuth + 180\n return phi % 360\n\n\n@jcompile('float64(float64)', nopython=True)\ndef sun_mean_longitude(julian_ephemeris_millennium):\n M = (280.4664567 + 360007.6982779 * julian_ephemeris_millennium\n + 0.03032028 * julian_ephemeris_millennium**2\n + julian_ephemeris_millennium**3 / 49931\n - julian_ephemeris_millennium**4 / 15300\n - julian_ephemeris_millennium**5 / 2000000)\n return M\n\n\n@jcompile('float64(float64, float64, float64, float64)', nopython=True)\ndef equation_of_time(sun_mean_longitude, geocentric_sun_right_ascension,\n longitude_nutation, true_ecliptic_obliquity):\n E = (sun_mean_longitude - 0.0057183 - geocentric_sun_right_ascension +\n longitude_nutation * np.cos(np.radians(true_ecliptic_obliquity)))\n # limit between 0 and 360\n E = E % 360\n # convert to minutes\n E *= 4\n greater = E > 20\n less = E < -20\n other = (E <= 20) & (E >= -20)\n E = greater * (E - 1440) + less * (E + 1440) + other * E\n return E\n\n\n@jcompile('void(float64[:], float64[:], float64[:,:])', nopython=True,\n nogil=True)\ndef solar_position_loop(unixtime, loc_args, out):\n \"\"\"Loop through the time array and calculate the solar position\"\"\"\n lat = loc_args[0]\n lon = loc_args[1]\n elev = loc_args[2]\n pressure = loc_args[3]\n temp = loc_args[4]\n delta_t = loc_args[5]\n atmos_refract = loc_args[6]\n sst = loc_args[7]\n esd = loc_args[8]\n\n for i in range(unixtime.shape[0]):\n utime = unixtime[i]\n jd = julian_day(utime)\n jde = julian_ephemeris_day(jd, delta_t)\n jc = julian_century(jd)\n jce = julian_ephemeris_century(jde)\n jme = julian_ephemeris_millennium(jce)\n R = heliocentric_radius_vector(jme)\n if esd:\n out[0, i] = R\n continue\n L = heliocentric_longitude(jme)\n B = heliocentric_latitude(jme)\n Theta = geocentric_longitude(L)\n beta = geocentric_latitude(B)\n x0 = mean_elongation(jce)\n x1 = mean_anomaly_sun(jce)\n x2 = mean_anomaly_moon(jce)\n x3 = moon_argument_latitude(jce)\n x4 = moon_ascending_longitude(jce)\n delta_psi = longitude_nutation(jce, x0, x1, x2, x3, x4)\n delta_epsilon = obliquity_nutation(jce, x0, x1, x2, x3, x4)\n epsilon0 = mean_ecliptic_obliquity(jme)\n epsilon = true_ecliptic_obliquity(epsilon0, delta_epsilon)\n delta_tau = aberration_correction(R)\n lamd = apparent_sun_longitude(Theta, delta_psi, delta_tau)\n v0 = mean_sidereal_time(jd, jc)\n v = apparent_sidereal_time(v0, delta_psi, epsilon)\n alpha = geocentric_sun_right_ascension(lamd, epsilon, beta)\n delta = geocentric_sun_declination(lamd, epsilon, beta)\n if sst:\n out[0, i] = v\n out[1, i] = alpha\n out[2, i] = delta\n continue\n m = sun_mean_longitude(jme)\n eot = equation_of_time(m, alpha, delta_psi, epsilon)\n H = local_hour_angle(v, lon, alpha)\n xi = equatorial_horizontal_parallax(R)\n u = uterm(lat)\n x = xterm(u, lat, elev)\n y = yterm(u, lat, elev)\n delta_alpha = parallax_sun_right_ascension(x, xi, H, delta)\n delta_prime = topocentric_sun_declination(delta, x, y, xi, delta_alpha,\n H)\n H_prime = topocentric_local_hour_angle(H, delta_alpha)\n e0 = topocentric_elevation_angle_without_atmosphere(lat, delta_prime,\n H_prime)\n delta_e = atmospheric_refraction_correction(pressure, temp, e0,\n atmos_refract)\n e = topocentric_elevation_angle(e0, delta_e)\n theta = topocentric_zenith_angle(e)\n theta0 = topocentric_zenith_angle(e0)\n gamma = topocentric_astronomers_azimuth(H_prime, delta_prime, lat)\n phi = topocentric_azimuth_angle(gamma)\n out[0, i] = theta\n out[1, i] = theta0\n out[2, i] = e\n out[3, i] = e0\n out[4, i] = phi\n out[5, i] = eot\n\n\ndef solar_position_numba(unixtime, lat, lon, elev, pressure, temp, delta_t,\n atmos_refract, numthreads, sst=False, esd=False):\n \"\"\"Calculate the solar position using the numba compiled functions\n and multiple threads. Very slow if functions are not numba compiled.\n \"\"\"\n # these args are the same for each thread\n loc_args = np.array([lat, lon, elev, pressure, temp, delta_t,\n atmos_refract, sst, esd])\n\n # construct dims x ulength array to put the results in\n ulength = unixtime.shape[0]\n if sst:\n dims = 3\n elif esd:\n dims = 1\n else:\n dims = 6\n result = np.empty((dims, ulength), dtype=np.float64)\n\n if unixtime.dtype != np.float64:\n unixtime = unixtime.astype(np.float64)\n\n if ulength < numthreads:\n warnings.warn('The number of threads is more than the length of '\n 'the time array. Only using %s threads.'.format(ulength))\n numthreads = ulength\n\n if numthreads <= 1:\n solar_position_loop(unixtime, loc_args, result)\n return result\n\n # split the input and output arrays into numthreads chunks\n split0 = np.array_split(unixtime, numthreads)\n split2 = np.array_split(result, numthreads, axis=1)\n chunks = [[a0, loc_args, split2[i]] for i, a0 in enumerate(split0)]\n # Spawn one thread per chunk\n threads = [threading.Thread(target=solar_position_loop, args=chunk)\n for chunk in chunks]\n for thread in threads:\n thread.start()\n for thread in threads:\n thread.join()\n return result\n\n\ndef solar_position_numpy(unixtime, lat, lon, elev, pressure, temp, delta_t,\n atmos_refract, numthreads, sst=False, esd=False):\n \"\"\"Calculate the solar position assuming unixtime is a numpy array. Note\n this function will not work if the solar position functions were\n compiled with numba.\n \"\"\"\n\n jd = julian_day(unixtime)\n jde = julian_ephemeris_day(jd, delta_t)\n jc = julian_century(jd)\n jce = julian_ephemeris_century(jde)\n jme = julian_ephemeris_millennium(jce)\n R = heliocentric_radius_vector(jme)\n if esd:\n return (R, )\n L = heliocentric_longitude(jme)\n B = heliocentric_latitude(jme)\n Theta = geocentric_longitude(L)\n beta = geocentric_latitude(B)\n x0 = mean_elongation(jce)\n x1 = mean_anomaly_sun(jce)\n x2 = mean_anomaly_moon(jce)\n x3 = moon_argument_latitude(jce)\n x4 = moon_ascending_longitude(jce)\n delta_psi = longitude_nutation(jce, x0, x1, x2, x3, x4)\n delta_epsilon = obliquity_nutation(jce, x0, x1, x2, x3, x4)\n epsilon0 = mean_ecliptic_obliquity(jme)\n epsilon = true_ecliptic_obliquity(epsilon0, delta_epsilon)\n delta_tau = aberration_correction(R)\n lamd = apparent_sun_longitude(Theta, delta_psi, delta_tau)\n v0 = mean_sidereal_time(jd, jc)\n v = apparent_sidereal_time(v0, delta_psi, epsilon)\n alpha = geocentric_sun_right_ascension(lamd, epsilon, beta)\n delta = geocentric_sun_declination(lamd, epsilon, beta)\n if sst:\n return v, alpha, delta\n m = sun_mean_longitude(jme)\n eot = equation_of_time(m, alpha, delta_psi, epsilon)\n H = local_hour_angle(v, lon, alpha)\n xi = equatorial_horizontal_parallax(R)\n u = uterm(lat)\n x = xterm(u, lat, elev)\n y = yterm(u, lat, elev)\n delta_alpha = parallax_sun_right_ascension(x, xi, H, delta)\n delta_prime = topocentric_sun_declination(delta, x, y, xi, delta_alpha, H)\n H_prime = topocentric_local_hour_angle(H, delta_alpha)\n e0 = topocentric_elevation_angle_without_atmosphere(lat, delta_prime,\n H_prime)\n delta_e = atmospheric_refraction_correction(pressure, temp, e0,\n atmos_refract)\n e = topocentric_elevation_angle(e0, delta_e)\n theta = topocentric_zenith_angle(e)\n theta0 = topocentric_zenith_angle(e0)\n gamma = topocentric_astronomers_azimuth(H_prime, delta_prime, lat)\n phi = topocentric_azimuth_angle(gamma)\n return theta, theta0, e, e0, phi, eot\n\n\ndef solar_position(unixtime, lat, lon, elev, pressure, temp, delta_t,\n atmos_refract, numthreads=8, sst=False, esd=False):\n\n \"\"\"\n Calculate the solar position using the\n NREL SPA algorithm described in [1].\n\n If numba is installed, the functions can be compiled\n and the code runs quickly. If not, the functions\n still evaluate but use numpy instead.\n\n Parameters\n ----------\n unixtime : numpy array\n Array of unix/epoch timestamps to calculate solar position for.\n Unixtime is the number of seconds since Jan. 1, 1970 00:00:00 UTC.\n A pandas.DatetimeIndex is easily converted using .astype(np.int64)/10**9\n lat : float\n Latitude to calculate solar position for\n lon : float\n Longitude to calculate solar position for\n elev : float\n Elevation of location in meters\n pressure : int or float\n avg. yearly pressure at location in millibars;\n used for atmospheric correction\n temp : int or float\n avg. yearly temperature at location in\n degrees C; used for atmospheric correction\n delta_t : float, optional\n If delta_t is None, uses spa.calculate_deltat\n using time.year and time.month from pandas.DatetimeIndex.\n For most simulations specifing delta_t is sufficient.\n Difference between terrestrial time and UT1.\n *Note: delta_t = None will break code using nrel_numba,\n this will be fixed in a future version.\n By default, use USNO historical data and predictions\n atmos_refrac : float, optional\n The approximate atmospheric refraction (in degrees)\n at sunrise and sunset.\n numthreads: int, optional, default 8\n Number of threads to use for computation if numba>=0.17\n is installed.\n sst : bool, default False\n If True, return only data needed for sunrise, sunset, and transit\n calculations.\n esd : bool, default False\n If True, return only Earth-Sun distance in AU\n\n Returns\n -------\n Numpy Array with elements:\n apparent zenith,\n zenith,\n elevation,\n apparent_elevation,\n azimuth,\n equation_of_time\n\n References\n ----------\n [1] I. Reda and A. Andreas, Solar position algorithm for solar radiation\n applications. Solar Energy, vol. 76, no. 5, pp. 577-589, 2004.\n\n [2] I. Reda and A. Andreas, Corrigendum to Solar position algorithm for\n solar radiation applications. Solar Energy, vol. 81, no. 6, p. 838, 2007.\n \"\"\"\n if USE_NUMBA:\n do_calc = solar_position_numba\n else:\n do_calc = solar_position_numpy\n\n result = do_calc(unixtime, lat, lon, elev, pressure,\n temp, delta_t, atmos_refract, numthreads,\n sst, esd)\n\n if not isinstance(result, np.ndarray):\n try:\n result = np.array(result)\n except Exception:\n pass\n\n return result\n\n\ndef transit_sunrise_sunset(dates, lat, lon, delta_t, numthreads):\n \"\"\"\n Calculate the sun transit, sunrise, and sunset\n for a set of dates at a given location.\n\n Parameters\n ----------\n dates : array\n Numpy array of ints/floats corresponding to the Unix time\n for the dates of interest, must be midnight UTC (00:00+00:00)\n on the day of interest.\n lat : float\n Latitude of location to perform calculation for\n lon : float\n Longitude of location\n delta_t : float\n Difference between terrestrial time and UT. USNO has tables.\n numthreads : int\n Number to threads to use for calculation (if using numba)\n\n Returns\n -------\n tuple : (transit, sunrise, sunset) localized to UTC\n\n \"\"\"\n\n if ((dates % 86400) != 0.0).any():\n raise ValueError('Input dates must be at 00:00 UTC')\n\n utday = (dates // 86400) * 86400\n ttday0 = utday - delta_t\n ttdayn1 = ttday0 - 86400\n ttdayp1 = ttday0 + 86400\n\n # index 0 is v, 1 is alpha, 2 is delta\n utday_res = solar_position(utday, 0, 0, 0, 0, 0, delta_t,\n 0, numthreads, sst=True)\n v = utday_res[0]\n\n ttday0_res = solar_position(ttday0, 0, 0, 0, 0, 0, delta_t,\n 0, numthreads, sst=True)\n ttdayn1_res = solar_position(ttdayn1, 0, 0, 0, 0, 0, delta_t,\n 0, numthreads, sst=True)\n ttdayp1_res = solar_position(ttdayp1, 0, 0, 0, 0, 0, delta_t,\n 0, numthreads, sst=True)\n m0 = (ttday0_res[1] - lon - v) / 360\n cos_arg = ((np.sin(np.radians(-0.8333)) - np.sin(np.radians(lat))\n * np.sin(np.radians(ttday0_res[2]))) /\n (np.cos(np.radians(lat)) * np.cos(np.radians(ttday0_res[2]))))\n cos_arg[abs(cos_arg) > 1] = np.nan\n H0 = np.degrees(np.arccos(cos_arg)) % 180\n\n m = np.empty((3, len(utday)))\n m[0] = m0 % 1\n m[1] = (m[0] - H0 / 360)\n m[2] = (m[0] + H0 / 360)\n\n # need to account for fractions of day that may be the next or previous\n # day in UTC\n add_a_day = m[2] >= 1\n sub_a_day = m[1] < 0\n m[1] = m[1] % 1\n m[2] = m[2] % 1\n vs = v + 360.985647 * m\n n = m + delta_t / 86400\n\n a = ttday0_res[1] - ttdayn1_res[1]\n a[abs(a) > 2] = a[abs(a) > 2] % 1\n ap = ttday0_res[2] - ttdayn1_res[2]\n ap[abs(ap) > 2] = ap[abs(ap) > 2] % 1\n b = ttdayp1_res[1] - ttday0_res[1]\n b[abs(b) > 2] = b[abs(b) > 2] % 1\n bp = ttdayp1_res[2] - ttday0_res[2]\n bp[abs(bp) > 2] = bp[abs(bp) > 2] % 1\n c = b - a\n cp = bp - ap\n\n alpha_prime = ttday0_res[1] + (n * (a + b + c * n)) / 2\n delta_prime = ttday0_res[2] + (n * (ap + bp + cp * n)) / 2\n Hp = (vs + lon - alpha_prime) % 360\n Hp[Hp >= 180] = Hp[Hp >= 180] - 360\n\n h = np.degrees(np.arcsin(np.sin(np.radians(lat)) *\n np.sin(np.radians(delta_prime)) +\n np.cos(np.radians(lat)) *\n np.cos(np.radians(delta_prime))\n * np.cos(np.radians(Hp))))\n\n T = (m[0] - Hp[0] / 360) * 86400\n R = (m[1] + (h[1] + 0.8333) / (360 * np.cos(np.radians(delta_prime[1])) *\n np.cos(np.radians(lat)) *\n np.sin(np.radians(Hp[1])))) * 86400\n S = (m[2] + (h[2] + 0.8333) / (360 * np.cos(np.radians(delta_prime[2])) *\n np.cos(np.radians(lat)) *\n np.sin(np.radians(Hp[2])))) * 86400\n\n S[add_a_day] += 86400\n R[sub_a_day] -= 86400\n\n transit = T + utday\n sunrise = R + utday\n sunset = S + utday\n\n return transit, sunrise, sunset\n\n\ndef earthsun_distance(unixtime, delta_t, numthreads):\n \"\"\"\n Calculates the distance from the earth to the sun using the\n NREL SPA algorithm described in [1].\n\n Parameters\n ----------\n unixtime : numpy array\n Array of unix/epoch timestamps to calculate solar position for.\n Unixtime is the number of seconds since Jan. 1, 1970 00:00:00 UTC.\n A pandas.DatetimeIndex is easily converted using .astype(np.int64)/10**9\n delta_t : float\n Difference between terrestrial time and UT. USNO has tables.\n numthreads : int\n Number to threads to use for calculation (if using numba)\n\n Returns\n -------\n R : array\n Earth-Sun distance in AU.\n\n References\n ----------\n [1] Reda, I., Andreas, A., 2003. Solar position algorithm for solar\n radiation applications. Technical report: NREL/TP-560- 34302. Golden,\n USA, http://www.nrel.gov.\n \"\"\"\n\n R = solar_position(unixtime, 0, 0, 0, 0, 0, delta_t,\n 0, numthreads, esd=True)[0]\n\n return R\n\n\ndef calculate_deltat(year, month):\n \"\"\"Calculate the difference between Terrestrial Dynamical Time (TD)\n and Universal Time (UT).\n\n Note: This function is not yet compatible for calculations using\n Numba.\n\n Equations taken from http://eclipse.gsfc.nasa.gov/SEcat5/deltatpoly.html\n \"\"\"\n\n plw = 'Deltat is unknown for years before -1999 and after 3000. ' \\\n 'Delta values will be calculated, but the calculations ' \\\n 'are not intended to be used for these years.'\n\n try:\n if np.any((year > 3000) | (year < -1999)):\n warnings.warn(plw)\n except ValueError:\n if (year > 3000) | (year < -1999):\n warnings.warn(plw)\n except TypeError:\n return 0\n\n y = year + (month - 0.5)/12\n\n deltat = np.where(year < -500,\n\n -20+32*((y-1820)/100)**2, 0)\n\n deltat = np.where((-500 <= year) & (year < 500),\n\n 10583.6-1014.41*(y/100)\n + 33.78311*(y/100)**2\n - 5.952053*(y/100)**3\n - 0.1798452*(y/100)**4\n + 0.022174192*(y/100)**5\n + 0.0090316521*(y/100)**6, deltat)\n\n deltat = np.where((500 <= year) & (year < 1600),\n\n 1574.2-556.01*((y-1000)/100)\n + 71.23472*((y-1000)/100)**2\n + 0.319781*((y-1000)/100)**3\n - 0.8503463*((y-1000)/100)**4\n - 0.005050998*((y-1000)/100)**5\n + 0.0083572073*((y-1000)/100)**6, deltat)\n\n deltat = np.where((1600 <= year) & (year < 1700),\n\n 120-0.9808*(y-1600)\n - 0.01532*(y-1600)**2\n + (y-1600)**3/7129, deltat)\n\n deltat = np.where((1700 <= year) & (year < 1800),\n\n 8.83+0.1603*(y-1700)\n - 0.0059285*(y-1700)**2\n + 0.00013336*(y-1700)**3\n - (y-1700)**4/1174000, deltat)\n\n deltat = np.where((1800 <= year) & (year < 1860),\n\n 13.72-0.332447*(y-1800)\n + 0.0068612*(y-1800)**2\n + 0.0041116*(y-1800)**3\n - 0.00037436*(y-1800)**4\n + 0.0000121272*(y-1800)**5\n - 0.0000001699*(y-1800)**6\n + 0.000000000875*(y-1800)**7, deltat)\n\n deltat = np.where((1860 <= year) & (year < 1900),\n\n 7.6+0.5737*(y-1860)\n - 0.251754*(y-1860)**2\n + 0.01680668*(y-1860)**3\n - 0.0004473624*(y-1860)**4\n + (y-1860)**5/233174, deltat)\n\n deltat = np.where((1900 <= year) & (year < 1920),\n\n -2.79+1.494119*(y-1900)\n - 0.0598939*(y-1900)**2\n + 0.0061966*(y-1900)**3\n - 0.000197*(y-1900)**4, deltat)\n\n deltat = np.where((1920 <= year) & (year < 1941),\n\n 21.20+0.84493*(y-1920)\n - 0.076100*(y-1920)**2\n + 0.0020936*(y-1920)**3, deltat)\n\n deltat = np.where((1941 <= year) & (year < 1961),\n\n 29.07+0.407*(y-1950)\n - (y-1950)**2/233\n + (y-1950)**3/2547, deltat)\n\n deltat = np.where((1961 <= year) & (year < 1986),\n\n 45.45+1.067*(y-1975)\n - (y-1975)**2/260\n - (y-1975)**3/718, deltat)\n\n deltat = np.where((1986 <= year) & (year < 2005),\n\n 63.86+0.3345*(y-2000)\n - 0.060374*(y-2000)**2\n + 0.0017275*(y-2000)**3\n + 0.000651814*(y-2000)**4\n + 0.00002373599*(y-2000)**5, deltat)\n\n deltat = np.where((2005 <= year) & (year < 2050),\n\n 62.92+0.32217*(y-2000)\n + 0.005589*(y-2000)**2, deltat)\n\n deltat = np.where((2050 <= year) & (year < 2150),\n\n -20+32*((y-1820)/100)**2\n - 0.5628*(2150-y), deltat)\n\n deltat = np.where(year > 2150,\n\n -20+32*((y-1820)/100)**2, deltat)\n\n deltat = np.asscalar(deltat) if np.isscalar(year) & np.isscalar(month)\\\n else deltat\n\n return deltat\n", "meta": {"hexsha": "b486da73dc2af27adf4e59b8b8cd71bb6a716ed6", "size": 48442, "ext": "py", "lang": "Python", "max_stars_repo_path": "pvlib/spa.py", "max_stars_repo_name": "alamathe1/pvlib-python", "max_stars_repo_head_hexsha": "ec996611887747bdef43db874147095e3337721a", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pvlib/spa.py", "max_issues_repo_name": "alamathe1/pvlib-python", "max_issues_repo_head_hexsha": "ec996611887747bdef43db874147095e3337721a", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pvlib/spa.py", "max_forks_repo_name": "alamathe1/pvlib-python", "max_forks_repo_head_hexsha": "ec996611887747bdef43db874147095e3337721a", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.8992302309, "max_line_length": 80, "alphanum_fraction": 0.5466743735, "include": true, "reason": "import numpy,import numba,from numba", "num_tokens": 16709, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.600188359260205, "lm_q2_score": 0.3242353859211693, "lm_q1q2_score": 0.19460230429012595}} {"text": "from __future__ import division\nfrom build.el_propagator_xf import el_run\nfrom mqc.mqc import MQC\nfrom misc import eps, au_to_K, au_to_A, call_name, typewriter\nimport random, os, shutil, textwrap\nimport numpy as np\nimport pickle\n\nclass Auxiliary_Molecule(object):\n \"\"\" Class for auxiliary molecule that is used for the calculation of decoherence term\n\n :param object molecule: Molecule object\n \"\"\"\n def __init__(self, molecule, l_xf1d):\n # Initialize auxiliary molecule\n if (l_xf1d):\n\n self.nat = 1\n self.ndim = 1\n self.symbols = ['XX']\n\n self.mass = np.zeros((self.nat))\n self.mass[0] = 1. / np.sum(1. / molecule.mass[0:molecule.nat_qm])\n\n else:\n\n self.nat = molecule.nat_qm\n self.ndim = molecule.ndim\n self.symbols = np.copy(molecule.symbols[0:molecule.nat_qm])\n\n self.mass = np.copy(molecule.mass[0:molecule.nat_qm])\n\n self.pos = np.zeros((molecule.nst, self.nat, self.ndim))\n self.vel = np.zeros((molecule.nst, self.nat, self.ndim))\n self.vel_old = np.copy(self.vel)\n\n\nclass SHXF(MQC):\n \"\"\" Class for DISH-XF dynamics\n\n :param object molecule: Molecule object\n :param object thermostat: Thermostat object\n :param integer istate: Initial state\n :param double dt: Time interval\n :param integer nsteps: Total step of nuclear propagation\n :param integer nesteps: Total step of electronic propagation\n :param string elec_object: Electronic equation of motions\n :param string propagator: Electronic propagator\n :param boolean l_print_dm: Logical to print BO population and coherence\n :param boolean l_adj_nac: Adjust nonadiabatic coupling to align the phases\n :param string hop_rescale: Velocity rescaling method after successful hop\n :param string hop_reject: Velocity rescaling method after frustrated hop\n :param double rho_threshold: Electronic density threshold for decoherence term calculation\n :param sigma: Width of nuclear wave packet of auxiliary trajectory\n :type sigma: double or double,list\n :param init_coef: Initial BO coefficient\n :type init_coef: double, list or complex, list\n :param boolean l_econs_state: Logical to use identical total energies for all auxiliary trajectories\n :param string aux_econs_viol: How to treat trajectories violating the total energy conservation\n :param string unit_dt: Unit of time interval\n :param integer out_freq: Frequency of printing output\n :param integer verbosity: Verbosity of output\n \"\"\"\n def __init__(self, molecule, thermostat=None, istate=0, dt=0.5, nsteps=1000, nesteps=20, \\\n elec_object=\"density\", propagator=\"rk4\", l_print_dm=True, l_adj_nac=True, hop_rescale=\"augment\", \\\n hop_reject=\"reverse\", rho_threshold=0.01, sigma=None, l_xf1d=False, init_coef=None, \\\n l_econs_state=True, aux_econs_viol=\"fix\", unit_dt=\"fs\", out_freq=1, verbosity=0):\n # Initialize input values\n super().__init__(molecule, thermostat, istate, dt, nsteps, nesteps, \\\n elec_object, propagator, l_print_dm, l_adj_nac, init_coef, unit_dt, out_freq, verbosity)\n\n # Initialize SH variables\n self.rstate = istate\n self.rstate_old = self.rstate\n\n self.rand = 0.\n self.prob = np.zeros(self.mol.nst)\n self.acc_prob = np.zeros(self.mol.nst + 1)\n\n self.l_hop = False\n self.l_reject = False\n\n self.hop_rescale = hop_rescale.lower()\n if not (self.hop_rescale in [\"energy\", \"velocity\", \"momentum\", \"augment\"]):\n error_message = \"Invalid rescaling method for accepted hop!\"\n error_vars = f\"hop_rescale = {self.hop_rescale}\"\n raise ValueError (f\"( {self.md_type}.{call_name()} ) {error_message} ( {error_vars} )\")\n\n self.hop_reject = hop_reject.lower()\n if not (self.hop_reject in [\"keep\", \"reverse\"]):\n error_message = \"Invalid rescaling method for frustrated hop!\"\n error_vars = f\"hop_reject = {self.hop_reject}\"\n raise ValueError (f\"( {self.md_type}.{call_name()} ) {error_message} ( {error_vars} )\")\n\n # Check error for incompatible cases\n if (self.mol.l_nacme):\n # No analytical nonadiabatic couplings exist\n if (self.hop_rescale in [\"velocity\", \"momentum\", \"augment\"]):\n error_message = \"NACVs are not available with current QM object, only isotropic rescaling is possible!\"\n error_vars = f\"hop_rescale = {self.hop_rescale}\"\n raise ValueError (f\"( {self.md_type}.{call_name()} ) {error_message} ( {error_vars} )\")\n # TODO : This error will be used after adding the 'flip' option for hop_reject\n# if (self.hop_reject == \"reverse\"):\n# error_message = \"NACVs are not available with current QM object, only keep rescaling is possible!\"\n# error_vars = f\"hop_reject = {self.hop_reject}\"\n# raise ValueError (f\"( {self.md_type}.{call_name()} ) {error_message} ( {error_vars} )\")\n\n # Initialize XF related variables\n self.force_hop = False\n self.l_econs_state = l_econs_state\n self.l_xf1d = l_xf1d\n self.l_coh = [False] * self.mol.nst\n self.l_first = [False] * self.mol.nst\n self.l_fix = [False] * self.mol.nst\n self.l_collapse = False\n self.rho_threshold = rho_threshold\n self.aux_econs_viol = aux_econs_viol\n\n if not (self.aux_econs_viol in [\"fix\", \"collapse\"]):\n error_message = \"Invalid method to treat auxiliary trajectories that violate the total energy conservation!\"\n error_vars = f\"aux_econs_viol = {self.aux_econs_viol}\"\n raise ValueError (f\"( {self.md_type}.{call_name()} ) {error_message} ( {error_vars} )\")\n\n self.sigma = sigma\n if (self.sigma == None):\n error_message = \"Sigma for auxiliary trajectories must be set in running script!\"\n error_vars = f\"sigma = {self.sigma}\"\n raise ValueError (f\"( {self.md_type}.{call_name()} ) {error_message} ( {error_vars} )\")\n\n if (isinstance(self.sigma, float)):\n # uniform value for sigma\n pass\n elif (isinstance(self.sigma, list)):\n # atom-resolved values for sigma\n if (len(self.sigma) != self.mol.nat_qm):\n error_message = \"Number of elements for sigma must be equal to number of atoms!\"\n error_vars = f\"len(sigma) = {len(self.sigma)}\"\n raise ValueError (f\"( {self.md_type}.{call_name()} ) {error_message} ( {error_vars} )\")\n if (self.l_xf1d):\n error_message = \"Sigma must be float, not list in XF-1D scheme!\"\n error_vars = f\"sigma = {self.sigma}\"\n raise TypeError (f\"( {self.md_type}.{call_name()} ) {error_message} ( {error_vars} )\")\n else:\n error_message = \"Type of sigma must be float or list consisting of float!\"\n error_vars = f\"sigma = {self.sigma}\"\n raise TypeError (f\"( {self.md_type}.{call_name()} ) {error_message} ( {error_vars} )\")\n\n self.upper_th = 1. - self.rho_threshold\n self.lower_th = self.rho_threshold\n\n # Initialize auxiliary molecule object\n self.aux = Auxiliary_Molecule(self.mol, self.l_xf1d)\n self.pos_0 = np.zeros((self.aux.nat, self.aux.ndim))\n self.phase = np.zeros((self.mol.nst, self.aux.nat, self.aux.ndim))\n\n # Debug variables\n self.dotpopdec = np.zeros(self.mol.nst)\n self.dotpopnac = np.zeros(self.mol.nst)\n self.qmom = np.zeros((self.aux.nat, self.aux.ndim))\n\n # Initialize event to print\n self.event = {\"HOP\": [], \"DECO\": []}\n\n def run(self, qm, mm=None, output_dir=\"./\", l_save_qm_log=False, l_save_mm_log=False, l_save_scr=True, restart=None):\n \"\"\" Run MQC dynamics according to decoherence-induced surface hopping dynamics\n\n :param object qm: QM object containing on-the-fly calculation infomation\n :param object mm: MM object containing MM calculation infomation\n :param string output_dir: Name of directory where outputs to be saved.\n :param boolean l_save_qm_log: Logical for saving QM calculation log\n :param boolean l_save_mm_log: Logical for saving MM calculation log\n :param boolean l_save_scr: Logical for saving scratch directory\n :param string restart: Option for controlling dynamics restarting\n \"\"\"\n # Initialize PyUNIxMD\n base_dir, unixmd_dir, qm_log_dir, mm_log_dir =\\\n self.run_init(qm, mm, output_dir, l_save_qm_log, l_save_mm_log, l_save_scr, restart)\n bo_list = [self.rstate]\n qm.calc_coupling = True\n self.print_init(qm, mm, restart)\n\n if (restart == None):\n # Initialize decoherence variables\n self.append_sigma()\n\n # Calculate initial input geometry at t = 0.0 s\n self.istep = -1\n self.mol.reset_bo(qm.calc_coupling)\n qm.get_data(self.mol, base_dir, bo_list, self.dt, self.istep, calc_force_only=False)\n if (self.mol.l_qmmm and mm != None):\n mm.get_data(self.mol, base_dir, bo_list, self.istep, calc_force_only=False)\n if (not self.mol.l_nacme):\n self.mol.get_nacme()\n\n self.hop_prob()\n self.hop_check(bo_list)\n self.evaluate_hop(bo_list)\n if (qm.re_calc and self.l_hop):\n qm.get_data(self.mol, base_dir, bo_list, self.dt, self.istep, calc_force_only=True)\n if (self.mol.l_qmmm and mm != None):\n mm.get_data(self.mol, base_dir, bo_list, self.istep, calc_force_only=True)\n\n self.update_energy()\n\n self.check_decoherence()\n self.check_coherence()\n self.aux_propagator()\n self.get_phase()\n if (self.l_collapse):\n self.check_decoherence()\n self.check_coherence()\n\n self.write_md_output(unixmd_dir, self.istep)\n self.print_step(self.istep)\n\n elif (restart == \"write\"):\n # Reset initial time step to t = 0.0 s\n self.istep = -1\n self.write_md_output(unixmd_dir, self.istep)\n self.print_step(self.istep)\n\n elif (restart == \"append\"):\n # Set initial time step to last successful step of previous dynamics\n self.istep = self.fstep\n\n self.istep += 1\n\n # Main MD loop\n for istep in range(self.istep, self.nsteps):\n\n self.calculate_force()\n self.cl_update_position()\n\n self.mol.backup_bo()\n self.mol.reset_bo(qm.calc_coupling)\n qm.get_data(self.mol, base_dir, bo_list, self.dt, istep, calc_force_only=False)\n if (self.mol.l_qmmm and mm != None):\n mm.get_data(self.mol, base_dir, bo_list, istep, calc_force_only=False)\n\n if (not self.mol.l_nacme and self.l_adj_nac):\n self.mol.adjust_nac()\n\n self.calculate_force()\n self.cl_update_velocity()\n\n if (not self.mol.l_nacme):\n self.mol.get_nacme()\n\n el_run(self)\n\n self.hop_prob()\n self.hop_check(bo_list)\n self.evaluate_hop(bo_list)\n if (self.l_hop):\n if (qm.re_calc):\n qm.get_data(self.mol, base_dir, bo_list, self.dt, istep, calc_force_only=True)\n if (self.mol.l_qmmm and mm != None):\n mm.get_data(self.mol, base_dir, bo_list, istep, calc_force_only=True)\n\n if (self.thermo != None):\n self.thermo.run(self)\n\n self.update_energy()\n\n self.check_decoherence()\n self.check_coherence()\n self.aux_propagator()\n self.get_phase()\n if (self.l_collapse):\n self.check_decoherence()\n self.check_coherence()\n\n if ((istep + 1) % self.out_freq == 0):\n self.write_md_output(unixmd_dir, istep)\n if ((istep + 1) % self.out_freq == 0 or len(self.event[\"HOP\"]) > 0 or len(self.event[\"DECO\"]) > 0):\n self.print_step(istep)\n if (istep == self.nsteps - 1):\n self.write_final_xyz(unixmd_dir, istep)\n\n self.fstep = istep\n restart_file = os.path.join(base_dir, \"RESTART.bin\")\n with open(restart_file, 'wb') as f:\n pickle.dump({'qm':qm, 'md':self}, f)\n\n # Delete scratch directory\n if (not l_save_scr):\n tmp_dir = os.path.join(unixmd_dir, \"scr_qm\")\n if (os.path.exists(tmp_dir)):\n shutil.rmtree(tmp_dir)\n\n if (self.mol.l_qmmm and mm != None):\n tmp_dir = os.path.join(unixmd_dir, \"scr_mm\")\n if (os.path.exists(tmp_dir)):\n shutil.rmtree(tmp_dir)\n\n def hop_prob(self):\n \"\"\" Routine to calculate hopping probabilities\n\n :param integer istep: Current MD step\n \"\"\"\n # Reset surface hopping variables\n self.rstate_old = self.rstate\n\n self.prob = np.zeros(self.mol.nst)\n self.acc_prob = np.zeros(self.mol.nst + 1)\n\n self.l_hop = False\n self.force_hop = False\n\n accum = 0.\n\n if (self.mol.rho.real[self.rstate, self.rstate] < self.lower_th):\n self.force_hop = True\n\n for ist in range(self.mol.nst):\n if (ist != self.rstate):\n if (self.force_hop):\n self.prob[ist] = self.mol.rho.real[ist, ist] / self.upper_th\n else:\n self.prob[ist] = - 2. * self.mol.rho.real[ist, self.rstate] * \\\n self.mol.nacme[ist, self.rstate] * self.dt / self.mol.rho.real[self.rstate, self.rstate]\n\n if (self.prob[ist] < 0.):\n self.prob[ist] = 0.\n accum += self.prob[ist]\n self.acc_prob[ist + 1] = accum\n psum = self.acc_prob[self.mol.nst]\n\n if (psum > 1.):\n self.prob /= psum\n self.acc_prob /= psum\n\n def hop_check(self, bo_list):\n \"\"\" Routine to check hopping occurs with random number\n\n :param integer,list bo_list: List of BO states for BO calculation\n \"\"\"\n self.rand = random.random()\n for ist in range(self.mol.nst):\n if (ist == self.rstate):\n continue\n if (self.rand > self.acc_prob[ist] and self.rand <= self.acc_prob[ist + 1]):\n self.l_hop = True\n self.rstate = ist\n bo_list[0] = self.rstate\n\n def evaluate_hop(self, bo_list):\n \"\"\" Routine to evaluate hopping and velocity rescaling\n\n :param integer,list bo_list: List of BO states for BO calculation\n :param integer istep: Current MD step\n \"\"\"\n if (self.l_hop):\n # Calculate potential difference between hopping states\n pot_diff = self.mol.states[self.rstate].energy - self.mol.states[self.rstate_old].energy\n\n # Solve quadratic equation for scaling factor of velocities\n a = 1.\n b = 1.\n det = 1.\n if (self.hop_rescale == \"velocity\"):\n a = np.sum(self.mol.mass[0:self.mol.nat_qm] * np.sum(self.mol.nac[self.rstate_old, self.rstate] ** 2., axis=1))\n b = 2. * np.sum(self.mol.mass[0:self.mol.nat_qm] * np.sum(self.mol.nac[self.rstate_old, self.rstate] \\\n * self.mol.vel[0:self.mol.nat_qm], axis=1))\n c = 2. * pot_diff\n det = b ** 2. - 4. * a * c\n elif (self.hop_rescale == \"momentum\"):\n a = np.sum(1. / self.mol.mass[0:self.mol.nat_qm] * np.sum(self.mol.nac[self.rstate_old, self.rstate] ** 2., axis=1))\n b = 2. * np.sum(np.sum(self.mol.nac[self.rstate_old, self.rstate] * self.mol.vel[0:self.mol.nat_qm], axis=1))\n c = 2. * pot_diff\n det = b ** 2. - 4. * a * c\n elif (self.hop_rescale == \"augment\"):\n a = np.sum(1. / self.mol.mass[0:self.mol.nat_qm] * np.sum(self.mol.nac[self.rstate_old, self.rstate] ** 2., axis=1))\n b = 2. * np.sum(np.sum(self.mol.nac[self.rstate_old, self.rstate] * self.mol.vel[0:self.mol.nat_qm], axis=1))\n c = 2. * pot_diff\n det = b ** 2. - 4. * a * c\n\n # Default: hopping is allowed\n self.l_reject = False\n\n # Velocities cannot be adjusted when zero kinetic energy is given\n if (self.hop_rescale == \"energy\" and self.mol.ekin_qm < eps):\n self.l_reject = True\n # Clasically forbidden hop due to lack of kinetic energy\n if (self.mol.ekin_qm < pot_diff):\n self.l_reject = True\n # Kinetic energy is enough, but there is no solution for scaling factor\n if (det < 0.):\n self.l_reject = True\n # When kinetic energy is enough, velocities are always rescaled in 'augment' case\n if (self.hop_rescale == \"augment\" and self.mol.ekin_qm > pot_diff):\n self.l_reject = False\n\n if (self.l_reject):\n # Record event for frustrated hop\n if (self.mol.ekin_qm < pot_diff):\n self.event[\"HOP\"].append(f\"Reject hopping: smaller kinetic energy than potential energy difference between {self.rstate} and {self.rstate_old}\")\n # Set scaling constant with respect to 'hop_reject'\n if (self.hop_reject == \"keep\"):\n self.event[\"HOP\"].append(\"Reject hopping: no solution to find rescale factor, velocity is not changed\")\n elif (self.hop_reject == \"reverse\"):\n # x = - 1 when 'hop_rescale' is 'energy', otherwise x = - b / a\n self.event[\"HOP\"].append(\"Reject hopping: no solution to find rescale factor, velocity is reversed along coupling direction\")\n x = - b / a\n # Recover old running state\n self.l_hop = False\n\n if (self.force_hop):\n self.event[\"HOP\"].append(f\"Collapse density: reset the density according to the current state {self.rstate_old}\")\n self.set_decoherence(self.rstate_old)\n\n self.force_hop = False\n\n self.rstate = self.rstate_old\n bo_list[0] = self.rstate\n else:\n if (self.hop_rescale == \"energy\" or (det < 0. and self.hop_rescale == \"augment\")):\n if (det < 0.):\n self.event[\"HOP\"].append(\"Accept hopping: no solution to find rescale factor, but velocity is simply rescaled\")\n x = np.sqrt(1. - pot_diff / self.mol.ekin_qm)\n else:\n if (b < 0.):\n x = 0.5 * (- b - np.sqrt(det)) / a\n else:\n x = 0.5 * (- b + np.sqrt(det)) / a\n\n # Rescale velocities for QM atoms\n if (not (self.hop_reject == \"keep\" and self.l_reject)):\n if (self.hop_rescale == \"energy\"):\n self.mol.vel[0:self.mol.nat_qm] *= x\n\n elif (self.hop_rescale == \"velocity\"):\n self.mol.vel[0:self.mol.nat_qm] += x * self.mol.nac[self.rstate_old, self.rstate]\n\n elif (self.hop_rescale == \"momentum\"):\n self.mol.vel[0:self.mol.nat_qm] += x * self.mol.nac[self.rstate_old, self.rstate] / \\\n self.mol.mass[0:self.mol.nat_qm].reshape((-1, 1))\n\n elif (self.hop_rescale == \"augment\"):\n if (det > 0. or self.mol.ekin_qm < pot_diff):\n self.mol.vel[0:self.mol.nat_qm] += x * self.mol.nac[self.rstate_old, self.rstate] / \\\n self.mol.mass[0:self.mol.nat_qm].reshape((-1, 1))\n else:\n self.mol.vel[0:self.mol.nat_qm] *= x\n\n # Update kinetic energy\n self.mol.update_kinetic()\n\n # Record hopping event\n if (self.rstate != self.rstate_old):\n if (self.force_hop):\n self.event[\"HOP\"].append(f\"Accept hopping: force hop {self.rstate_old} -> {self.rstate}\")\n else:\n self.event[\"HOP\"].append(f\"Accept hopping: hop {self.rstate_old} -> {self.rstate}\")\n\n def calculate_force(self):\n \"\"\" Routine to calculate the forces\n \"\"\"\n self.rforce = np.copy(self.mol.states[self.rstate].force)\n\n def update_energy(self):\n \"\"\" Routine to update the energy of molecules in surface hopping dynamics\n \"\"\"\n # Update kinetic energy\n self.mol.update_kinetic()\n self.mol.epot = self.mol.states[self.rstate].energy\n self.mol.etot = self.mol.epot + self.mol.ekin\n\n def check_decoherence(self):\n \"\"\" Routine to check if the electronic state is decohered\n \"\"\"\n if (self.l_hop):\n if (True in self.l_coh):\n self.event[\"DECO\"].append(f\"Destroy auxiliary trajectories: hopping occurs\")\n self.l_coh = [False] * self.mol.nst\n self.l_first = [False] * self.mol.nst\n self.l_fix = [False] * self.mol.nst\n else:\n for ist in range(self.mol.nst):\n if (self.l_coh[ist]):\n rho = self.mol.rho.real[ist, ist]\n if (rho > self.upper_th):\n self.set_decoherence(ist)\n return\n\n def check_coherence(self):\n \"\"\" Routine to check coherence among BO states\n \"\"\"\n count = 0\n tmp_st = \"\"\n for ist in range(self.mol.nst):\n rho = self.mol.rho.real[ist, ist]\n if (rho > self.upper_th or rho < self.lower_th):\n self.l_coh[ist] = False\n else:\n if (self.l_coh[ist]):\n self.l_first[ist] = False\n else:\n self.l_first[ist] = True\n tmp_st += f\"{ist}, \"\n self.l_coh[ist] = True\n count += 1\n\n if (count < 2):\n self.l_coh = [False] * self.mol.nst\n self.l_first = [False] * self.mol.nst\n tmp_st = \"\"\n\n if (len(tmp_st) >= 1):\n tmp_st = tmp_st.rstrip(', ')\n self.event[\"DECO\"].append(f\"Generate auxiliary trajectory on {tmp_st} state\")\n\n def set_decoherence(self, one_st):\n \"\"\" Routine to reset coefficient/density if the state is decohered\n\n :param integer one_st: State index that its population is one\n \"\"\"\n self.phase = np.zeros((self.mol.nst, self.aux.nat, self.aux.ndim))\n self.mol.rho = np.zeros((self.mol.nst, self.mol.nst), dtype=np.complex128)\n self.mol.rho[one_st, one_st] = 1. + 0.j\n\n self.l_coh = [False] * self.mol.nst\n self.l_first = [False] * self.mol.nst\n self.l_fix = [False] * self.mol.nst\n\n self.event[\"DECO\"].append(f\"Destroy auxiliary trajectories: decohered to {one_st} state\")\n\n if (self.elec_object == \"coefficient\"):\n for ist in range(self.mol.nst):\n if (ist == one_st):\n self.mol.states[ist].coef /= np.absolute(self.mol.states[ist].coef).real\n else:\n self.mol.states[ist].coef = 0. + 0.j\n\n def aux_propagator(self):\n \"\"\" Routine to propagate auxiliary molecule\n \"\"\"\n # Get auxiliary position\n for ist in range(self.mol.nst):\n if (self.l_coh[ist]):\n if (self.l_first[ist]):\n if (self.l_xf1d):\n self.aux.pos[ist] = np.zeros((self.aux.nat, self.aux.ndim))\n else:\n self.aux.pos[ist] = self.mol.pos[0:self.aux.nat]\n else:\n if (self.l_xf1d):\n self.aux.pos[ist] += self.aux.vel[ist] * self.dt\n else:\n if (ist == self.rstate):\n self.aux.pos[ist] = self.mol.pos[0:self.aux.nat]\n else:\n self.aux.pos[ist] += self.aux.vel[ist] * self.dt\n\n self.pos_0 = np.copy(self.aux.pos[self.rstate])\n\n # Get auxiliary velocity\n self.l_collapse = False\n self.aux.vel_old = np.copy(self.aux.vel)\n for ist in range(self.mol.nst):\n # Calculate propagation factor alpha\n if (self.l_coh[ist]):\n if (self.l_fix[ist]):\n alpha = 0.\n else:\n if (ist == self.rstate):\n alpha = self.mol.ekin_qm\n else:\n if (self.l_first[ist]):\n alpha = self.mol.ekin_qm\n if (self.l_econs_state):\n alpha += self.mol.states[self.rstate].energy - self.mol.states[ist].energy\n else:\n ekin_old = np.sum(0.5 * self.aux.mass * np.sum(self.aux.vel_old[ist] ** 2, axis=1))\n alpha = ekin_old + self.mol.states[ist].energy_old - self.mol.states[ist].energy\n if (alpha < 0.):\n alpha = 0.\n if (self.aux_econs_viol == \"fix\"):\n self.l_fix[ist] = True\n self.event[\"DECO\"].append(f\"Energy conservation violated, the auxiliary trajectory on state {ist} is fixed.\")\n elif (self.aux_econs_viol == \"collapse\"):\n self.l_collapse = True\n self.collapse(ist)\n self.event[\"DECO\"].append(f\"Energy conservation violated, collapse the {ist} state coefficient/density to zero.\")\n\n # Calculate auxiliary velocity from alpha\n if (self.l_xf1d):\n alpha /= 0.5 * self.aux.mass[0]\n self.aux.vel[ist] = np.sqrt(alpha)\n else:\n alpha /= self.mol.ekin_qm\n self.aux.vel[ist] = self.mol.vel[0:self.aux.nat] * np.sqrt(alpha)\n\n def collapse(self, cstate):\n \"\"\" Routine to collapse coefficient/density of a state to zero\n \"\"\"\n fac = 1. - self.mol.rho.real[cstate, cstate]\n\n if (self.elec_object == \"coefficient\"):\n for ist in range(self.mol.nst):\n if (ist == cstate):\n self.mol.states[ist].coef = 0. + 0.j\n else:\n self.mol.states[ist].coef /= np.sqrt(fac)\n\n self.mol.rho[cstate,:] = 0. + 0.j\n self.mol.rho[:,cstate] = 0. + 0.j\n self.mol.rho /= fac\n \n def get_phase(self):\n \"\"\" Routine to calculate phase term\n \"\"\"\n for ist in range(self.mol.nst):\n if (self.l_coh[ist]):\n if (self.l_first[ist]):\n self.phase[ist] = 0.\n else:\n for iat in range(self.aux.nat):\n self.phase[ist, iat] += self.aux.mass[iat] * \\\n (self.aux.vel[ist, iat] - self.aux.vel_old[ist, iat])\n\n def append_sigma(self):\n \"\"\" Routine to append sigma values when single float number is provided\n \"\"\"\n # Create a list from single float number\n if (isinstance(self.sigma, float)):\n sigma = self.sigma\n self.sigma = self.aux.nat * [sigma]\n\n def write_md_output(self, unixmd_dir, istep):\n \"\"\" Write output files\n\n :param string unixmd_dir: PyUNIxMD directory\n :param integer istep: Current MD step\n \"\"\"\n # Write the common part\n super().write_md_output(unixmd_dir, istep)\n\n # Write hopping-related quantities\n self.write_sh(unixmd_dir, istep)\n\n # Write time-derivative BO population\n self.write_dotpop(unixmd_dir, istep)\n\n # Write decoherence information\n self.write_dec(unixmd_dir, istep)\n\n def write_sh(self, unixmd_dir, istep):\n \"\"\" Write hopping-related quantities into files\n\n :param string unixmd_dir: PyUNIxMD directory\n :param integer istep: Current MD step\n \"\"\"\n # Write SHSTATE file\n tmp = f'{istep + 1:9d}{\"\":14s}{self.rstate}'\n typewriter(tmp, unixmd_dir, \"SHSTATE\", \"a\")\n\n # Write SHPROB file\n tmp = f'{istep + 1:9d}' + \"\".join([f'{self.prob[ist]:15.8f}' for ist in range(self.mol.nst)])\n typewriter(tmp, unixmd_dir, \"SHPROB\", \"a\")\n\n def write_dotpop(self, unixmd_dir, istep):\n \"\"\" Write time-derivative BO population\n\n :param string unixmd_dir: PyUNIxMD directory\n :param integer istep: Current MD step\n \"\"\"\n if (self.verbosity >= 1):\n # Write NAC term in DOTPOPNAC\n tmp = f'{istep + 1:9d}' + \"\".join([f'{pop:15.8f}' for pop in self.dotpopnac])\n typewriter(tmp, unixmd_dir, \"DOTPOPNAC\", \"a\")\n\n # Write decoherence term in DOTPOPDEC\n tmp = f'{istep + 1:9d}' + \"\".join([f'{pop:15.8f}' for pop in self.dotpopdec])\n typewriter(tmp, unixmd_dir, \"DOTPOPDEC\", \"a\")\n\n def write_dec(self, unixmd_dir, istep):\n \"\"\" Write XF-based decoherence information\n\n :param string unixmd_dir: PyUNIxMD directory\n :param integer istep: Current MD step\n \"\"\"\n # Write auxiliary trajectories\n if (self.verbosity >= 2 and True in self.l_coh):\n # Write quantum momenta\n tmp = f'{self.aux.nat:6d}\\n{\"\":2s}Step:{istep + 1:6d}{\"\":12s}Momentum (au)' + \\\n \"\".join([\"\\n\" + f'{self.aux.symbols[iat]:5s}' + \\\n \"\".join([f'{self.qmom[iat, isp]:15.8f}' for isp in range(self.aux.ndim)]) for iat in range(self.aux.nat)])\n typewriter(tmp, unixmd_dir, f\"QMOM\", \"a\")\n\n # Write auxiliary variables\n for ist in range(self.mol.nst):\n if (self.l_coh[ist]):\n # Write auxiliary phase\n tmp = f'{self.aux.nat:6d}\\n{\"\":2s}Step:{istep + 1:6d}{\"\":12s}Phase (au)' + \\\n \"\".join([\"\\n\" + f'{self.aux.symbols[iat]:5s}' + \\\n \"\".join([f'{self.phase[ist, iat, isp]:15.8f}' for isp in range(self.aux.ndim)]) for iat in range(self.aux.nat)])\n typewriter(tmp, unixmd_dir, f\"AUX_PHASE_{ist}\", \"a\")\n\n # Write auxiliary trajectory movie files\n tmp = f'{self.aux.nat:6d}\\n{\"\":2s}Step:{istep + 1:6d}{\"\":12s}Position(A){\"\":34s}Velocity(au)' + \\\n \"\".join([\"\\n\" + f'{self.aux.symbols[iat]:5s}' + \\\n \"\".join([f'{self.aux.pos[ist, iat, isp] * au_to_A:15.8f}' for isp in range(self.aux.ndim)]) + \\\n \"\".join([f\"{self.aux.vel[ist, iat, isp]:15.8f}\" for isp in range(self.aux.ndim)]) for iat in range(self.aux.nat)])\n typewriter(tmp, unixmd_dir, f\"AUX_MOVIE_{ist}.xyz\", \"a\")\n\n def print_init(self, qm, mm, restart):\n \"\"\" Routine to print the initial information of dynamics\n\n :param object qm: QM object containing on-the-fly calculation infomation\n :param object mm: MM object containing MM calculation infomation\n :param string restart: Option for controlling dynamics restarting\n \"\"\"\n # Print initial information about molecule, qm, mm and thermostat\n super().print_init(qm, mm, restart)\n\n # Print dynamics information for start line\n dynamics_step_info = textwrap.dedent(f\"\"\"\\\n\n {\"-\" * 118}\n {\"Start Dynamics\":>65s}\n {\"-\" * 118}\n \"\"\")\n\n # Print INIT for each step\n INIT = f\" #INFO{'STEP':>8s}{'State':>7s}{'Kinetic(H)':>14s}{'Potential(H)':>15s}{'Total(H)':>13s}{'Temperature(K)':>17s}{'Norm.':>8s}\"\n dynamics_step_info += INIT\n\n # Print DEBUG1 for each step\n if (self.verbosity >= 1):\n DEBUG1 = f\" #DEBUG1{'STEP':>6s}{'Rand.':>11s}{'Acc. Hopping Prob.':>28s}\"\n dynamics_step_info += \"\\n\" + DEBUG1\n\n print (dynamics_step_info, flush=True)\n\n def print_step(self, istep):\n \"\"\" Routine to print each steps infomation about dynamics\n\n :param integer istep: Current MD step\n \"\"\"\n ctemp = self.mol.ekin * 2. / float(self.mol.ndof) * au_to_K\n norm = 0.\n for ist in range(self.mol.nst):\n norm += self.mol.rho.real[ist, ist]\n\n # Print INFO for each step\n INFO = f\" INFO{istep + 1:>9d}{self.rstate:>5d}\"\n INFO += f\"{self.mol.ekin:16.8f}{self.mol.epot:15.8f}{self.mol.etot:15.8f}\"\n INFO += f\"{ctemp:13.6f}\"\n INFO += f\"{norm:11.5f}\"\n print (INFO, flush=True)\n\n # Print DEBUG1 for each step\n if (self.verbosity >= 1):\n DEBUG1 = f\" DEBUG1{istep + 1:>7d}\"\n DEBUG1 += f\"{self.rand:11.5f}\"\n for ist in range(self.mol.nst):\n DEBUG1 += f\"{self.acc_prob[ist]:12.5f} ({self.rstate}->{ist})\"\n print (DEBUG1, flush=True)\n\n # Print event in SHXF\n for category, events in self.event.items():\n if (len(events) != 0):\n for ievent in events:\n print (f\" {category}{istep + 1:>9d} {ievent}\", flush=True)\n self.event[\"HOP\"] = []\n self.event[\"DECO\"] = []\n\n\n", "meta": {"hexsha": "d9cc8a5ff4d1972e9bd42dd17382f5b9bef2db41", "size": 33757, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/mqc/shxf.py", "max_stars_repo_name": "skmin-lab/unixmd", "max_stars_repo_head_hexsha": "241b886a4d383e3ae107a22c6c0154c85e2729d5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 9, "max_stars_repo_stars_event_min_datetime": "2021-04-18T08:03:50.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-22T03:29:54.000Z", "max_issues_repo_path": "src/mqc/shxf.py", "max_issues_repo_name": "skmin-lab/unixmd", "max_issues_repo_head_hexsha": "241b886a4d383e3ae107a22c6c0154c85e2729d5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 23, "max_issues_repo_issues_event_min_datetime": "2021-04-14T08:43:02.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T10:26:42.000Z", "max_forks_repo_path": "src/mqc/shxf.py", "max_forks_repo_name": "skmin-lab/unixmd", "max_forks_repo_head_hexsha": "241b886a4d383e3ae107a22c6c0154c85e2729d5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 16, "max_forks_repo_forks_event_min_datetime": "2021-04-14T05:59:45.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-02T03:05:23.000Z", "avg_line_length": 43.8402597403, "max_line_length": 164, "alphanum_fraction": 0.5537814379, "include": true, "reason": "import numpy", "num_tokens": 8563, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6261241632752915, "lm_q2_score": 0.31069437683198775, "lm_q1q2_score": 0.19453325672826646}} {"text": "#%%\nimport numpy as np\nimport copy\nimport matplotlib.pyplot as plt\nimport time \n\ndef split_cluster_new(tree,local_density,dc_eps,closest_denser_nodes_id,mixin_near_matrix):\n '''\n dc_eps: density_connectivity 阈值\n 使用父子节点的直接距离，与子节点与兄弟节点的连通距离进行聚簇划分；\n 使用平均密度划分outlier\n 返回：\n outlier_forest\n cluster_forest\n '''\n mean_density = np.mean(local_density)\n outlier_forest = {}\n cluster_forest = {}\n uncertain_forest = {}\n not_direct_reach = []\n #* 计算不可直接可达的点：\n for k in range(len(closest_denser_nodes_id)):\n near_nodes = mixin_near_matrix[k]\n if closest_denser_nodes_id[k] not in near_nodes:\n not_direct_reach.append(k)\n pass\n not_direct_reach = np.array(not_direct_reach)\n # not_direct_reach = np.where(closest_dis_denser>eps)[0]\n #* 将不直接距离可达的点按层次排列：\n # not_direct_reach = np.array(not_direct_reach)\n depth_list_not_direct_reach= np.zeros(len(not_direct_reach),dtype=np.int16)\n for i in range(len(not_direct_reach)):\n # depth_list_not_direct_reach[i] = tree.node_dir[not_direct_reach[i]].getLvl()\n depth_list_not_direct_reach[i] = tree.calcu_depth(not_direct_reach[i],0)\n pass\n not_direct_reach = list(not_direct_reach[np.argsort(depth_list_not_direct_reach)])\n #* 模拟栈结构，层次深的先处理\n start = time.clock()\n while(len(not_direct_reach)>0):\n #* 判断是否 连通：距离小于阈值，并且密度要大于子树的平均密度\n node_id = not_direct_reach.pop()\n if(node_id==129193 or node_id==61589 or node_id == 123593):\n print(node_id)\n if node_id in tree.sorted_gamma_index[0:10]:\n cluster_forest[node_id] = tree.remove_subtree(node_id)\n continue\n node = tree.node_dir[node_id]\n parent_id = node.parent_id\n parent_node = tree.node_dir[parent_id]\n children = parent_node.getChildren()\n siblings_reliable = [ i for i in children if i not in not_direct_reach] #* 求得兄弟节点，其中兄弟节点不能是不直接可达的点\n not_reliable_nodes = [i for i in children if i not in siblings_reliable]\n if node_id in not_reliable_nodes:\n not_reliable_nodes.remove(node_id)\n if node_id in siblings_reliable:\n siblings_reliable.remove(node_id)\n pairs_nodes = is_connected_new(tree,local_density,dc_eps,node_id,siblings_reliable,not_reliable_nodes,mixin_near_matrix)\n if len(pairs_nodes)==0:\n if(node_id==tree.root_node.node_id):\n continue\n if(local_density[node_id]-mean_density*dc_eps)>=0:\n #* 获取子节点个数:\n offspring_id = tree.get_subtree_offspring_id(node_id,[node_id])\n if(len(offspring_id)local_density_cur_offspring*dc_eps):\n return pairs_nodes\n pass\n #* 2. \n for i in range(len(not_reliable_nodes)):\n pairs_nodes, connected_nodes = tree.calcu_neighbor_btw_subtree(cur_node_id,not_reliable_nodes[i],mixin_near_matrix)\n if(len(pairs_nodes)==0):\n pairs_nodes = is_connected_new(tree,local_density,dc_eps,not_reliable_nodes[i],reliable_nodes,not_reliable_nodes[i+1:],mixin_near_matrix)\n if(len(pairs_nodes)>0):\n return pairs_nodes\n else:\n cur_node_offspring = tree.get_subtree_offspring_id(cur_node_id,[cur_node_id])\n local_density_cur_offspring = np.mean(local_density[cur_node_offspring])\n local_density_connected_nodes = np.mean(local_density[connected_nodes])\n if(local_density_connected_nodes>local_density_cur_offspring*dc_eps):\n return pairs_nodes\n\n\n # return pairs_nodes\n # #* 连通点平均密度大于局部密度阈值，则更新最大相似度\n cur_node_offspring = tree.get_subtree_offspring_id(cur_node_id,[cur_node_id])\n local_density_cur_offspring = np.mean(local_density[cur_node_offspring])\n local_density_connected_nodes = np.mean(local_density[connected_nodes])\n if(local_density_connected_nodes>local_density_cur_offspring*dc_eps):\n return pairs_nodes\n if(len(pairs_nodes)==0):\n pairs_nodes = is_connected_new(tree,local_density,dc_eps,not_reliable_nodes[i],reliable_nodes,not_reliable_nodes[i+1:],mixin_near_matrix)\n if(len(pairs_nodes)>0):\n return pairs_nodes\n # pass\n return []\n\n\ndef label_these_node_new(outlier_forest,cluster_forest,node_num,uncertain_forest,mixin_near_matrix):\n '''\n 给森林中的样本点贴标签\n 考虑不确定点的分配\n '''\n labels = np.full((node_num),-1,dtype=np.int32)\n for outlier_id in outlier_forest:\n outlier_tree = outlier_forest[outlier_id]\n outlier_idlist = outlier_tree.get_subtree_offspring_id(outlier_id,[outlier_id])\n labels[outlier_idlist] = -1\n pass\n \n label = 0\n for tree_id in cluster_forest:\n cluster_tree = cluster_forest[tree_id]\n cluster_idlist = cluster_tree.get_subtree_offspring_id(tree_id,[tree_id])\n labels[cluster_idlist] = label\n label = label + 1\n pass\n\n #todo 修改此处代码\n for uncertain_tree_id in uncertain_forest:\n uncertain_tree = uncertain_forest[uncertain_tree_id]\n uncertain_nodes_id = uncertain_tree.get_subtree_offspring_id(uncertain_tree_id,[uncertain_tree_id])\n all_near_nodes = np.array([],dtype=np.int32)\n for node_id in uncertain_nodes_id:\n all_near_nodes = np.append(all_near_nodes,mixin_near_matrix[node_id])\n pass\n # all_near_nodes = mixin_near_matrix[uncertain_nodes_id]\n all_near_nodes = np.unique(all_near_nodes)\n all_near_nodes = all_near_nodes[np.where(labels[all_near_nodes]!=-1)]\n unique_labels,counts=np.unique(labels[all_near_nodes],return_counts=True)\n if(len(counts)==0):\n cur_label = -1\n else:\n cur_label = unique_labels[np.argmax(counts)]\n labels[uncertain_nodes_id]=cur_label\n pass\n\n core_points = cluster_forest.keys()\n return labels,core_points\n\n\n\n'''\n密度峰值树；\n根据cfsfdp算法生成的局部密度、高密度最近邻距离、决策指标来生成 DPTree；\n'''\nclass Node():\n def __init__(self,node_id,attr_list,parent_id=None,dist_to_parent=None,density=None,gamma=None,children=[]):\n self.node_id = node_id\n self.attr_list = attr_list\n self.parent_id = parent_id\n self.dist_to_parent = dist_to_parent\n self.density = density\n self.children = children\n self.gamma = gamma\n self.offspring_num = None\n self.lvl = None\n\n def addChild(self,child):\n self.children+=[child]\n\n def removeChild(self,child):\n self.children.remove(child)\n \n def resetChildren(self):\n self.children = []\n\n def setParentId(self,parent_id):\n self.parent_id = parent_id\n\n def setOffspringNum(self,num):\n self.offspring_num = num\n\n def setLvl(self,lvl):\n self.lvl = lvl\n\n def getAttr(self):\n return self.attr_list\n\n def getNodeId(self):\n return self.node_id\n\n def getParentId(self):\n return self.parent_id\n \n def getDistToParent(self):\n return self.dist_to_parent\n \n def getDensity(self):\n return self.density\n\n def getGamma(self):\n return self.gamma\n\n def getChildren(self):\n return self.children\n \n def hasChildren(self,child_id):\n if child_id in self.children:\n return True\n else:\n return False\n\n def getOffspringNum(self):\n return self.offspring_num\n\n def getLvl(self):\n return self.lvl\n\n\n\n\nclass DPTree():\n def __init__(self):\n self.node_count = 0\n self.node_dir = {}\n self.root_node = None\n self.node_offspring = {}\n self.sorted_gamma_index = None\n pass\n\n def createTree(self,X,sorted_gamma_index,closest_node_id,closest_dis_denser,local_density,gamma):\n #* 根据 gamma 顺序新建节点\n node_dir = {}\n node_created = np.zeros(len(sorted_gamma_index))\n self.sorted_gamma_index = sorted_gamma_index\n for i in range(len(sorted_gamma_index)):\n node_id = sorted_gamma_index[i]\n parent_id = closest_node_id[node_id] #* closest_node_id是根据排序后的gamma获得的\n attr_list = X[node_id]\n dist_to_parent = closest_dis_denser[node_id]\n density = local_density[node_id]\n if(node_created[node_id]==0):\n node = Node(node_id,attr_list,parent_id,dist_to_parent=dist_to_parent,density=density,gamma[node_id],children=[])\n node_created[node_id] = 1\n node_dir[node_id] = node\n node_dir[node_id].setParentId(parent_id)\n if(node_created[parent_id]==0):\n parent_node = Node(parent_id,X[parent_id],parent_id=None,dist_to_parent=closest_dis_denser[parent_id],density=local_density[parent_id],gamma=gamma[parent_id],children=[])\n node_created[parent_id] = 1\n node_dir[parent_id] = parent_node\n parent_node = node_dir[parent_id]\n cur_node = node_dir[node_id]\n if(node_id != parent_id):#* 非根节点\n parent_node.addChild(node_id)\n # parent_lvl = parent_node.getLvl()\n # cur_node.setLvl(parent_lvl+1)\n else:\n if(parent_node.getLvl()==None):\n parent_node.setLvl(0)\n\n #* 设置节点层次信息\n # for i in tree.node_dir:\n\n # pass\n \n self.root_node = node_dir[sorted_gamma_index[0]]\n self.node_dir = node_dir\n self.node_count = len(sorted_gamma_index)\n pass\n\n def printTree2(self,parent_id,spaceStr=''):\n for node_id in self.node_dir:\n if(node_id==self.root_node.node_id):\n continue\n node = self.node_dir[node_id]\n if(node.parent_id==parent_id):\n print(spaceStr, node.node_id, sep = '')\n self.printTree2(node.node_id,spaceStr+' ')\n pass\n \n def calcu_subtree_offspring_num(self,node_id):\n node = self.node_dir[node_id]\n cur_offsprings = node.getOffspringNum()\n if(cur_offsprings!=None):\n return cur_offsprings\n child_num = len(node.children)\n if(child_num==0):\n return 0\n for i in node.children:\n cur_offsprings = self.calcu_subtree_offspring_num(i)\n child_num+=cur_offsprings\n node.setOffspringNum(child_num)\n return child_num\n\n def get_subtree_offspring_id(self,node_id,other_idlist):\n '''\n 获取所有子孙的node_id\n 考虑：是否需要存储在node属性中。\n '''\n def fn_get_subtree_offspring_id(node_id,offspring_idlist):\n if(node_id in self.node_offspring.keys()):\n return self.node_offspring[node_id]\n else:\n node = self.node_dir[node_id]\n children = node.getChildren()\n child_num = len(children)\n if(child_num==0):\n self.node_offspring[node_id] = offspring_idlist\n return offspring_idlist\n offspring_idlist= list(offspring_idlist) + children\n for i in children:\n child_offspring_idlist = fn_get_subtree_offspring_id(i,[])\n self.node_offspring[i] = child_offspring_idlist\n offspring_idlist= list(offspring_idlist) + child_offspring_idlist\n pass\n self.node_offspring[node_id] = offspring_idlist\n return offspring_idlist \n offspring_idlist = fn_get_subtree_offspring_id(node_id,[])\n return np.array(list(offspring_idlist) + other_idlist)\n \n \n\n def calcu_subtree_entropy(self,offspring_id,local_density,closest_dis_denser):\n p_sum = np.sum(local_density[offspring_id]/closest_dis_denser[offspring_id])\n p = (local_density[offspring_id]/closest_dis_denser[offspring_id])/p_sum\n entropy = -1*np.sum(p*np.log2(p))\n #* 只有一个点的情况返回 0\n if(entropy==0):\n return 0\n return entropy/(-1*np.log2(1/(len(offspring_id))))\n\n \n def remove_subtree(self,child_id):\n '''\n 删除 node_id 节点的子树：child_id, 被删除的子树形成新的树并返回\n 1. 更新 self.node_dir, self.node_count\n 2. 更新 node_id 节点的 children[], 以及所有父级offspring_num\n 3. 生成新树\n '''\n # print(\"删除子节点：\",child_id)\n offspring_id = self.get_subtree_offspring_id(child_id,[child_id])\n offspring_len = len(offspring_id)\n node_id = self.node_dir[child_id].parent_id\n node = self.node_dir[node_id]\n node.removeChild(child_id)\n self.node_count = self.node_count-offspring_len\n #* 删除存储的子孙节点\n if(node_id in self.node_offspring.keys()):\n for node_to_delete in offspring_id:\n self.node_offspring[node_id].remove(node_to_delete)\n print(\"删除子孙节点:\",node_to_delete)\n pass\n pass\n # cur_id = child_id\n # parent_id = node_id\n # #* 设置父级 offspring_num:\n # while(cur_id!=parent_id):\n # parent_node = self.node_dir[parent_id]\n # if(parent_node.getOffspringNum()!=None):\n # parent_node.setOffspringNum(parent_node.getOffspringNum()-offspring_len)\n # cur_id = parent_id\n # parent_id = parent_node.parent_id\n # pass\n #* 更新 self.node_dir, 生成新树:\n new_tree = DPTree()\n for i in offspring_id:\n removed_node = self.node_dir.pop(i)\n new_tree.node_dir[i] = removed_node\n pass\n new_tree.node_count = offspring_len\n new_tree.root_node = new_tree.node_dir[child_id]\n new_tree.root_node.setParentId(child_id)\n return new_tree\n\n def calcu_dist_betw_subtree(self,node_id_one,node_id_two,dist_mat,eps):\n '''\n 计算两个子树间的连通距离\n return：\n 1. 最短距离\n 2. 小于距离阈值的点集\n '''\n connected_nodes = np.array([],dtype=np.int32)\n offspring_one = self.get_subtree_offspring_id(node_id_one,[node_id_one])\n offspring_two = self.get_subtree_offspring_id(node_id_two,[node_id_two])\n dist = float('inf')\n for i in offspring_two:\n tmp_dist = np.min(dist_mat[i][offspring_one])\n if(tmp_dist0:\n connected_nodes = np.r_[[i],connected_nodes,offspring_one[connected_nodes_index]]\n pass\n return dist, np.unique(connected_nodes)\n\n def calcu_neighbor_btw_subtree(self,node_id_one,node_id_two,mixin_near_matrix):\n '''\n 计算两个子树间的邻近点\n return:\n 邻近的点对\n 所有邻近点\n '''\n connected_nodes = np.array([],dtype=np.int32)\n offspring_one = self.get_subtree_offspring_id(node_id_one,[node_id_one])\n offspring_two = self.get_subtree_offspring_id(node_id_two,[node_id_two])\n pairs_nodes = []\n for i in offspring_two:\n connected_nodes_index = np.intersect1d(mixin_near_matrix[i],offspring_one)\n if len(connected_nodes_index)>0:\n for j in connected_nodes_index:\n pairs_nodes.append([i,j])\n pass\n pass\n if(len(pairs_nodes)==0):\n return pairs_nodes,connected_nodes\n return np.array(pairs_nodes), np.unique(np.array(pairs_nodes).flatten())\n\n\n def calcu_dist_betw_subtree_entropy(self,node_id_one,node_id_two,dist_mat,eps):\n '''\n 计算两个子树间的连通距离\n return：\n 1. 最大相似距离\n 2. 大于相似距离阈值的点集\n '''\n connected_nodes = np.array([],dtype=np.int32)\n offspring_one = self.get_subtree_offspring_id(node_id_one,[node_id_one])\n offspring_two = self.get_subtree_offspring_id(node_id_two,[node_id_two])\n dist = -1\n for i in offspring_two:\n tmp_dist = np.max(dist_mat[i][offspring_one])\n if(tmp_dist>=dist):\n dist = tmp_dist\n pass\n connected_nodes_index = np.where(dist_mat[i][offspring_one]>=eps)[0]\n if len(connected_nodes_index)>0:\n connected_nodes = np.r_[[i],connected_nodes,offspring_one[connected_nodes_index]]\n pass\n return dist, np.unique(connected_nodes)\n\n\n def calcu_depth(self,node_id, depth):\n node = self.node_dir[node_id]\n parent_id = node.parent_id\n if(node_id==parent_id):\n return depth\n else:\n return self.calcu_depth(parent_id,depth+1)\n", "meta": {"hexsha": "4c55db68c1c667219febb6705164366e8f8c7adb", "size": 18439, "ext": "py", "lang": "Python", "max_stars_repo_path": "ADPTC_LIB/DPTree_ST.py", "max_stars_repo_name": "SuilandCoder/ADPTC_LIB", "max_stars_repo_head_hexsha": "ef5c2b7fcf117c8c90a3841489471289ecbf4562", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "ADPTC_LIB/DPTree_ST.py", "max_issues_repo_name": "SuilandCoder/ADPTC_LIB", "max_issues_repo_head_hexsha": "ef5c2b7fcf117c8c90a3841489471289ecbf4562", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ADPTC_LIB/DPTree_ST.py", "max_forks_repo_name": "SuilandCoder/ADPTC_LIB", "max_forks_repo_head_hexsha": "ef5c2b7fcf117c8c90a3841489471289ecbf4562", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.5753138075, "max_line_length": 186, "alphanum_fraction": 0.6335484571, "include": true, "reason": "import numpy", "num_tokens": 4689, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5467381519846138, "lm_q2_score": 0.35577488668296436, "lm_q1q2_score": 0.19451570406757934}} {"text": "#\n# The MIT License (MIT)\n#\n# Copyright (c) 2018-2020 azai/Rgveda/GolemQuant\n#\n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# in the Software without restriction, including without limitation the rights\n# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n# copies of the Software, and to permit persons to whom the Software is\n# furnished to do so, subject to the following conditions:\n#\n# The above copyright notice and this permission notice shall be included in\n# all\n# copies or substantial portions of the Software.\n#\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n# SOFTWARE.\n#\nimport numpy as np\nimport numba as nb\nfrom numba import vectorize, float64, jit as njit\nimport scipy.stats as scs\nfrom datetime import datetime as dt, timezone, timedelta\n\nfrom analysis.timeseries import *\nfrom QUANTAXIS.QAUtil.QADate_Adv import (QA_util_print_timestamp,)\nimport pandas as pd\nimport empyrical\nfrom utils.parameter import (\n AKA, \n INDICATOR_FIELD as FLD, \n TREND_STATUS as ST,\n FEATURES as FTR,\n )\n\n\"\"\"\n这里定义的是一些 fractal, strategy, portfolio 的绩效统计相关工具函数\n\"\"\"\n\ndef calc_fractal_stats(symbol, display_name, fractal_uid, fractal_triggers,\n ref_features=None, rsk_fre=0.04, annual=252, taxfee=0.0003, \n long=1, mode='lrc', format='pd'):\n \"\"\"\n explanation:\n 分型触发点(卖点or买点，取决于交易方向)绩效分析\n\n 什么是分型触发点呢？对大众认知的交易里，最通俗的含义就是特定交易策略的金叉/死叉点。\n 例如MACD金叉/死叉点，双MA金叉、死叉点，KDJ金叉、死叉点等。\n 它们全部都可以纳入这套 fractal_stats 评估体系中衡量。\n\n 它的功能用法有点像 alphalens，但是 alphalens 使用的框架体系是传统经济学量化金融\n 的那一套理论，跟我朴素的衡量标准并不一致。比如 alpha_beta 只计算当前 bar。\n 在我的交易系统内，并没有发现我认知的“趋势买点”和传统金融量化理论计算的 IC alpha值有\n 什么显著的相关性特征。\n 所以我只能另起炉灶，用统计学习的方式来量化衡量一个分型触发点的优劣。\n 这套分型系统的数学涵义上更类似深度学习中Attention模型的注意力关注点，能否与机器学习\n 结合有待后续研究。\n\n params:\n symbol: str, 交易标的代码\n display_name: str, 交易标的显示名称\n fractal_uid: str, 分型唯一标识编码\n fractal_triggers : np.array, 分型触发信号\n ref_features: np.array, 参考指标特征\n rsk_fre: float32, 无风险利率\n annual: int32, 年化周期\n taxfee: float32, 税费\n long: int32, 交易方向\n mode: str, 'lrc' or 'zen' 趋势判断模式为 zen趋势 或者 lrc回归线趋势，\n 'hmapower'为追踪hmapower120的MA逆序趋势，\n 'raw'不进行趋势判断，完全跟随 fractal_triggers 状态信号\n format : string, 返回格式\n\n return:\n pd.Series or np.array or string\n \"\"\"\n # 这里严格定义应该是考虑交易方向，但是暂时先偷懒简化了计算，以后做双向策略出现问题再完善\n if (long > 0):\n # 做多方向\n fractal_cross_before = Timeline_duration(np.where(fractal_triggers > 0, 1, 0))\n else:\n # 做空方向\n fractal_cross_before = Timeline_duration(np.where(fractal_triggers < 0, 1, 0))\n\n if (annual > 125) and (annual < 366):\n # 推断为日线级别的数据周期\n fractal_forcast_position = np.where(fractal_cross_before < 3, 1, 0)\n fractal_limited = 3\n elif ((annual > 1680) and (annual < 2560)):\n # 推断为数字币 4小时先级别的数据周期\n fractal_limited = 24\n fractal_forcast_position = np.where(fractal_cross_before < 24, 1, 0)\n elif ((annual > 512) and (annual < 1280)):\n # 推断为股票/证券1小时先级别的数据周期\n fractal_limited = 12\n fractal_forcast_position = np.where(fractal_cross_before < 12, 1, 0)\n elif ((annual > 6180) and (annual < 9600)):\n # 推断为股票/证券1小时先级别的数据周期\n fractal_limited = 72\n fractal_forcast_position = np.where(fractal_cross_before < 72, 1, 0)\n\n # 固定统计3交易日内收益\n fractal_forcast_3d_lag = calc_event_timing_lag(np.where(fractal_forcast_position > 0, 1, -1))\n fractal_forcast_3d_lag = np.where(fractal_forcast_3d_lag <= fractal_limited, fractal_forcast_3d_lag, 0)\n closep = ref_features[AKA.CLOSE].values\n\n if (mode == 'lrc'):\n # 统计到下一次 lineareg_band / 死叉等对等交易信号结束时的 收益，时间长度不固定\n if (long > 0):\n # 做多方向\n lineareg_endpoint_before = Timeline_duration(np.where(ref_features[FLD.LINEAREG_BAND_TIMING_LAG] == -1, 1, 0))\n else:\n # 做空方向\n lineareg_endpoint_before = Timeline_duration(np.where(ref_features[FLD.LINEAREG_BAND_TIMING_LAG] == 1, 1, 0))\n fractal_lineareg_position = np.where(fractal_cross_before < lineareg_endpoint_before, 1, 0)\n fractal_lineareg_lag = calc_event_timing_lag(np.where(fractal_lineareg_position > 0, 1, -1))\n\n transcation_stats = calc_transcation_stats(fractal_triggers,\n closep,\n fractal_forcast_3d_lag,\n fractal_lineareg_lag,\n ref_features[FLD.LINEAREG_BAND_TIMING_LAG].values,\n taxfee=taxfee,\n long=long)\n\n transcation_stats_df = pd.DataFrame(transcation_stats, columns=['trans_stats',\n 'trans_start',\n 'trans_act',\n 'trans_end', \n 'start_principle', \n 'ret_3d',\n 'ret_fractal',\n 'pric_settle',\n 'trans_3d',\n 'price_end_3d',\n 'price_end_fractal',\n 'ret_fractal_sim',\n 'long',\n 'duration_time',])\n elif (mode == 'zen') or \\\n (mode == 'mapower'):\n if (long > 0):\n # 做多方向\n zen_wavelet_endpoint_before = Timeline_duration(np.where(ref_features[FLD.ZEN_WAVELET_TIMING_LAG] == -1, 1, 0))\n else:\n # 做空方向\n zen_wavelet_endpoint_before = Timeline_duration(np.where(ref_features[FLD.ZEN_WAVELET_TIMING_LAG] == 1, 1, 0))\n fractal_zen_wavelet_position = np.where(fractal_cross_before < zen_wavelet_endpoint_before, 1, 0)\n fractal_zen_wavelet_lag = calc_event_timing_lag(np.where(fractal_zen_wavelet_position > 0, 1, -1))\n transcation_stats = calc_transcation_stats_np(fractal_triggers,\n closep,\n fractal_forcast_3d_lag,\n fractal_zen_wavelet_lag,\n taxfee=taxfee,\n long=long)\n\n transcation_stats_df = pd.DataFrame(transcation_stats, columns=['trans_stats',\n 'trans_start',\n 'trans_act',\n 'trans_end', \n 'start_principle', \n 'ret_3d',\n 'ret_fractal',\n 'pric_settle',\n 'trans_3d',\n 'price_end_3d',\n 'price_end_fractal',\n 'ret_fractal_sim',\n 'long',\n 'duration_time',])\n elif (mode == 'hmapower') or \\\n (mode == 'hmapower120') or \\\n (mode == 'hmapower30'):\n if (long > 0):\n # 做多方向\n hmapower120_endpoint_before = Timeline_duration(np.where(ref_features[FLD.HMAPOWER120_TIMING_LAG] == -1, 1, 0))\n else:\n # 做空方向\n hmapower120_endpoint_before = Timeline_duration(np.where(ref_features[FLD.HMAPOWER120_TIMING_LAG] == 1, 1, 0))\n fractal_hmapower120_position = np.where(fractal_cross_before < hmapower120_endpoint_before, 1, 0)\n fractal_hmapower120_lag = calc_event_timing_lag(np.where(fractal_hmapower120_position > 0, 1, -1))\n transcation_stats = calc_transcation_stats_np(fractal_triggers,\n closep,\n fractal_forcast_3d_lag,\n fractal_hmapower120_lag,\n taxfee=taxfee,\n long=long)\n\n transcation_stats_df = pd.DataFrame(transcation_stats, columns=['trans_stats',\n 'trans_start',\n 'trans_act',\n 'trans_end', \n 'start_principle', \n 'ret_3d',\n 'ret_fractal',\n 'pric_settle',\n 'trans_3d',\n 'price_end_3d',\n 'price_end_fractal',\n 'ret_fractal_sim',\n 'long',\n 'duration_time',])\n elif (mode == 'raw'):\n fractal_position = np.where(fractal_triggers > 0, 1, 0)\n fractal_timing_lag = calc_event_timing_lag(np.where(fractal_position > 0, 1, -1))\n if (np.max(fractal_timing_lag) < 12):\n #print('A spot Fractal, not a Complete Cycle Fractal')\n pass\n transcation_stats = calc_transcation_stats_np(fractal_triggers,\n closep,\n fractal_forcast_3d_lag,\n fractal_timing_lag,\n taxfee=taxfee,\n long=long)\n\n transcation_stats_df = pd.DataFrame(transcation_stats, columns=['trans_stats',\n 'trans_start',\n 'trans_act',\n 'trans_end', \n 'start_principle', \n 'ret_3d',\n 'ret_fractal',\n 'pric_settle',\n 'trans_3d',\n 'price_end_3d',\n 'price_end_fractal',\n 'ret_fractal_sim',\n 'long',\n 'duration_time',])\n\n transcation_stats_df[AKA.CODE] = symbol\n transcation_stats_df['fractal_uid'] = fractal_uid\n\n # bar ID索引 转换成交易时间戳\n selected_trans_start = ref_features.iloc[transcation_stats[:, 1], :]\n transcation_stats_df['trans_start'] = pd.to_datetime(selected_trans_start.index.get_level_values(level=0))\n selected_trans_action = ref_features.iloc[transcation_stats[:, 2], :]\n transcation_stats_df['trans_act'] = pd.to_datetime(selected_trans_action.index.get_level_values(level=0))\n selected_trans_end = ref_features.iloc[transcation_stats[:, 3], :]\n transcation_stats_df['trans_end'] = pd.to_datetime(selected_trans_end.index.get_level_values(level=0))\n\n transcation_stats_df = transcation_stats_df.assign(datetime=pd.to_datetime(selected_trans_start.index.get_level_values(level=0))).drop_duplicates((['datetime',\n 'code'])).set_index(['datetime',\n 'code'],\n drop=True)\n\n return transcation_stats_df\n\n\n@nb.jit(nopython=True)\ndef calc_transcation_stats(fractal_triggers: np.ndarray, \n closep: np.ndarray,\n fractal_forcast_position: np.ndarray,\n fractal_sim_position: np.ndarray,\n principle_timing_lag: np.ndarray,\n taxfee: float=0.0003, \n long: int=1):\n\n \"\"\"\n explanation:\n 在“大方向”（规则）引导下，计算当前交易盈亏状况\n np.ndarray 实现，编码规范支持JIT和Cython加速\n\n params:\n fractal_triggers : np.array, 分型触发信号\n closep: np.array, 参考指标特征\n fractal_forcast_position: np.ndarray,\n fractal_principle_position: np.ndarray,\n principle_timing_lag:np.ndarray,\n taxfee: float32, 税费\n long: int32, 交易方向\n\n return:\n np.array\n \"\"\"\n # 交易状态，状态机规则，低状态可以向高状态迁移\n stats_nop = 0 # 无状态\n stats_onhold = 1 # 执行交易并持有\n stats_suspended = 2 # 挂起，不执行交易，观察走势\n stats_closed = 3 # 结束交易\n stats_teminated = 4 # 趋势走势不对，终止交易\n\n idx_transcation = -1\n idx_transcation_stats = 0\n idx_transcation_start = 1\n idx_transcation_action = 2\n idx_transcation_endpoint = 3\n idx_start_in_principle = 4\n idx_forcast_returns = 5\n idx_principle_returns = 6\n idx_settle_price = 7\n idx_transcation_3d = 8\n idx_endpoint_price_3d = 9\n idx_endpoint_price_principle = 10\n idx_fractal_sim_returns = 11\n idx_long = 12\n idx_duration_time = 13\n #idx_lineareg_band_lag = 12\n \n ret_transcation_stats = np.zeros((len(closep), 14))\n onhold_price = onhold_returns = 0.0\n onhold_position_3d = onhold_position_lineareg = False\n assert long == 1 or long == -1\n ret_transcation_stats[:, idx_long] = long\n for i in range(0, len(closep)):\n # 开启交易判断\n if (fractal_triggers[i] > 0) and \\\n (not onhold_position_3d) and \\\n (not onhold_position_lineareg):\n onhold_position_3d = True\n onhold_position_lineareg = True\n idx_transcation = idx_transcation + 1\n ret_transcation_stats[idx_transcation, idx_transcation_start] = i\n\n if (principle_timing_lag[i] * long > 0):\n ret_transcation_stats[idx_transcation, \n idx_start_in_principle] = principle_timing_lag[i]\n if (ret_transcation_stats[idx_transcation, \n idx_start_in_principle] * long == -1):\n ret_transcation_stats[idx_transcation, \n idx_transcation_stats] = stats_suspended\n elif (ret_transcation_stats[idx_transcation, \n idx_transcation_stats] < stats_onhold):\n ret_transcation_stats[idx_transcation, \n idx_transcation_stats] = stats_onhold\n ret_transcation_stats[idx_transcation, \n idx_transcation_action] = i\n else:\n ret_transcation_stats[idx_transcation, \n idx_start_in_principle] = principle_timing_lag[i]\n if (ret_transcation_stats[idx_transcation, \n idx_transcation_stats] < stats_suspended):\n ret_transcation_stats[idx_transcation, \n idx_transcation_stats] = stats_suspended\n\n if (principle_timing_lag[i] * long > 0):\n if (int(ret_transcation_stats[idx_transcation, \n idx_transcation_stats]) == stats_onhold):\n onhold_price = closep[i]\n ret_transcation_stats[idx_transcation, \n idx_settle_price] = onhold_price\n elif (i != len(closep)):\n if (int(ret_transcation_stats[idx_transcation, \n idx_transcation_stats]) == stats_onhold):\n onhold_price = closep[i + 1]\n ret_transcation_stats[idx_transcation, \n idx_settle_price] = onhold_price\n\n if (onhold_position_lineareg) and (fractal_forcast_position[i] > 0):\n if (principle_timing_lag[i] * long > 0):\n if (int(ret_transcation_stats[idx_transcation, \n idx_transcation_stats]) == stats_suspended):\n ret_transcation_stats[idx_transcation, \n idx_transcation_stats] = stats_onhold\n ret_transcation_stats[idx_transcation, \n idx_transcation_action] = i\n onhold_price = closep[i]\n ret_transcation_stats[idx_transcation, \n idx_settle_price] = onhold_price\n else:\n ret_transcation_stats[idx_transcation, \n idx_transcation_stats] = stats_suspended\n\n # 结束交易判断\n if (onhold_position_lineareg) and (fractal_sim_position[i] <= 0):\n onhold_position_lineareg = False\n onhold_position_3d = False\n ret_transcation_stats[idx_transcation, \n idx_transcation_endpoint] = i\n onhold_sim_price = closep[int(ret_transcation_stats[idx_transcation, idx_transcation_start])]\n ret_transcation_stats[idx_transcation, \n idx_fractal_sim_returns] = (closep[i] - onhold_sim_price) / onhold_sim_price * long\n if (int(ret_transcation_stats[idx_transcation, \n idx_transcation_stats]) == stats_onhold):\n ret_transcation_stats[idx_transcation, \n idx_principle_returns] = (closep[i] - onhold_price) / onhold_price * long\n ret_transcation_stats[idx_transcation, \n idx_endpoint_price_principle] = closep[i]\n ret_transcation_stats[idx_transcation, \n idx_transcation_stats] = stats_closed\n onhold_price = 0.0\n elif (int(ret_transcation_stats[idx_transcation, \n idx_transcation_stats]) == stats_suspended):\n ret_transcation_stats[idx_transcation, \n idx_transcation_stats] = stats_teminated\n onhold_price = 0.0\n\n if (onhold_position_3d) and (fractal_forcast_position[i] <= 0):\n onhold_position_3d = False\n ret_transcation_stats[idx_transcation, \n idx_transcation_3d] = principle_timing_lag[i]\n if (int(ret_transcation_stats[idx_transcation, \n idx_transcation_stats]) == stats_onhold):\n ret_transcation_stats[idx_transcation, \n idx_forcast_returns] = (closep[i] - onhold_price) / onhold_price * long\n ret_transcation_stats[idx_transcation, \n idx_endpoint_price_3d] = closep[i]\n elif (int(ret_transcation_stats[idx_transcation, \n idx_transcation_stats]) == stats_suspended):\n ret_transcation_stats[idx_transcation, \n idx_transcation_stats] = stats_teminated\n onhold_price = 0.0\n else:\n pass\n\n if (onhold_position_lineareg) and (i == len(closep)):\n # 交易当前处于未结束状态\n if (int(ret_transcation_stats[idx_transcation, \n idx_transcation_stats]) == stats_onhold):\n ret_transcation_stats[idx_transcation, \n idx_principle_returns] = (closep[i] - onhold_price) / onhold_price * long\n pass\n ret_transcation_stats[idx_transcation, \n idx_duration_time] = ret_transcation_stats[idx_transcation, \n idx_transcation_endpoint] - ret_transcation_stats[idx_transcation, \n idx_transcation_action]\n\n return ret_transcation_stats[:idx_transcation + 1, :]\n\n\n@nb.jit(nopython=True)\ndef calc_transcation_stats_np(fractal_triggers:np.ndarray, \n closep:np.ndarray,\n fractal_forcast_position:np.ndarray,\n fractal_timing_lag:np.ndarray,\n taxfee:float=0.0003, \n long:int=1):\n\n \"\"\"\n 计算当前交易盈亏状况\n np.ndarray 实现，编码规范支持JIT和Cython加速\n \"\"\"\n # 交易状态，状态机规则，低状态可以向高状态迁移\n stats_nop = 0 # 无状态\n stats_onhold = 1 # 执行交易并持有\n stats_suspended = 2 # 挂起，不执行交易，观察走势\n stats_closed = 3 # 结束交易\n stats_teminated = 4 # 趋势走势不对，终止交易\n\n idx_transcation = -1\n idx_transcation_stats = 0\n idx_transcation_start = 1\n idx_transcation_action = 2\n idx_transcation_endpoint = 3\n idx_start_zen_wavelet = 4\n idx_forcast_returns = 5\n idx_fractal_returns = 6\n idx_settle_price = 7\n idx_transcation_3d = 8\n idx_endpoint_price_3d = 9\n idx_endpoint_price_fractal = 10\n idx_fractal_sim_returns = 11\n idx_long = 12\n idx_duration_time = 13\n #idx_lineareg_band_lag = 12\n \n ret_transcation_stats = np.zeros((len(closep), 14))\n onhold_price = onhold_returns = 0.0\n onhold_position_3d = onhold_position_lineareg = False\n assert long == 1 or long == -1\n ret_transcation_stats[:, idx_long] = long\n for i in range(0, len(closep)):\n # 开启交易判断\n if (fractal_triggers[i] > 0) and \\\n (not onhold_position_3d) and \\\n (not onhold_position_lineareg):\n onhold_position_3d = True\n onhold_position_lineareg = True\n idx_transcation = idx_transcation + 1\n ret_transcation_stats[idx_transcation, idx_transcation_start] = i\n ret_transcation_stats[idx_transcation, \n idx_transcation_stats] = stats_onhold\n ret_transcation_stats[idx_transcation, idx_transcation_action] = i\n onhold_price = closep[i]\n ret_transcation_stats[idx_transcation, \n idx_settle_price] = onhold_price\n\n # 结束交易判断\n if (onhold_position_lineareg) and (fractal_timing_lag[i] <= 0):\n onhold_position_lineareg = False\n onhold_position_3d = False\n ret_transcation_stats[idx_transcation, \n idx_transcation_endpoint] = i\n ret_transcation_stats[idx_transcation, \n idx_fractal_sim_returns] = (closep[i] - onhold_price) / onhold_price * long\n ret_transcation_stats[idx_transcation, \n idx_fractal_returns] = (closep[i] - onhold_price) / onhold_price * long\n ret_transcation_stats[idx_transcation, \n idx_endpoint_price_fractal] = closep[i]\n ret_transcation_stats[idx_transcation, \n idx_transcation_stats] = stats_closed\n onhold_price = 0.0\n\n if (onhold_position_3d) and (fractal_forcast_position[i] <= 0):\n onhold_position_3d = False\n ret_transcation_stats[idx_transcation, \n idx_transcation_3d] = fractal_timing_lag[i]\n if (onhold_position_lineareg):\n ret_transcation_stats[idx_transcation, \n idx_forcast_returns] = (closep[i] - onhold_price) / onhold_price * long\n ret_transcation_stats[idx_transcation, \n idx_endpoint_price_3d] = closep[i]\n else:\n ret_transcation_stats[idx_transcation, \n idx_transcation_stats] = stats_teminated\n onhold_price = 0.0\n\n if (onhold_position_lineareg) and (i == len(closep)):\n # 交易当前处于未结束状态\n if (int(ret_transcation_stats[idx_transcation, \n idx_transcation_stats]) == stats_onhold):\n ret_transcation_stats[idx_transcation, \n idx_fractal_returns] = (closep[i] - onhold_price) / onhold_price * long\n pass\n ret_transcation_stats[idx_transcation, \n idx_duration_time] = ret_transcation_stats[idx_transcation, \n idx_transcation_endpoint] - ret_transcation_stats[idx_transcation, \n idx_transcation_action]\n\n return ret_transcation_stats[:idx_transcation + 1, :]\n\n\ndef calc_strategy_stats(codelist, codename, strategy_name, timing_lag,\n ref_features=None, rsk_fre=0.04, annual=252, taxfee=0.0003, \n long=1, format='pd'):\n \"\"\"\n 策略绩效分析，\n 包括年化 Sharpe Ratio，换手率, Max Drawdown 等\n\n \"\"\"\n portfolio_position = np.where(timing_lag > 0, 1, 0)\n portfolio_returns = ref_features[idx_PCT_CHANGE] * np.r_[0, portfolio_position[:-1]]\n\n # Turnover Analysis 简化计算，全仓操作 100%换手\n portfolio_turnover = np.where(portfolio_position != np.r_[0, portfolio_position[:-1]], 1, 0)\n portfolio_turnover_ratio = rolling_sum(portfolio_turnover, annual)\n\n portfolio_annual_return = portfolio_returns.rolling(annual).apply(lambda x: \n empyrical.annual_return(x, annualization=annual), \n raw=True)\n portfolio_sharpe_ratio = empyrical.roll_sharpe_ratio(portfolio_returns, risk_free=rsk_fre / annual, \n annualization=annual, window=annual)\n portfolio_max_drawdown = empyrical.roll_max_drawdown(portfolio_returns, annual)\n\n turnover_ratio_mean = np.mean(portfolio_turnover_ratio[annual:])\n turnover_ratio_mean = turnover_ratio_mean if (turnover_ratio_mean > 2) else 24\n annual_return_mean = np.mean((portfolio_annual_return.values - portfolio_turnover_ratio * taxfee)[annual:])\n\n if (format != 'pd'):\n ret_portfolio_state_template = 'Code {}, {}, {} sharpe:{:.2f}, annual_return:{:.2%}, max_drawdown:{:.2%}, turnover:{:.0%}'\n ret_strategy_stats = ret_portfolio_state_template.format(codelist, \n codename,\n strategy_name,\n portfolio_sharpe_ratio[-1], \n (portfolio_annual_return.values - portfolio_turnover_ratio * taxfee)[-1], \n portfolio_max_drawdown[-1],\n portfolio_turnover_ratio[-1])\n return ret_strategy_stats\n else:\n #print(ret_portfolio_state)\n return pd.Series({'symbol':codelist,\n 'name':codename,\n 'portfolio':strategy_name,\n 'sharpe':portfolio_sharpe_ratio[-1],\n 'annual_return':(portfolio_annual_return.values - portfolio_turnover_ratio * taxfee)[-1],\n idx_TRANSACTION_RETURN_MEAN:annual_return_mean / (turnover_ratio_mean / 2),\n 'max_drawdown': portfolio_max_drawdown[-1], \n 'turnover_ratio': portfolio_turnover_ratio[-1]})\n\n\ndef portfolio_stats(codelist, codename, strategy_name, timing_lag, \n ref_features, rsk_fre=0.04, annual=252, taxfee=0.0003):\n \"\"\"\n 策略组合/投资组合绩效分析\n\n \"\"\"\n portfolio_position = np.where(timing_lag > 0, 1, 0)\n portfolio_returns = ref_features[idx_PCT_CHANGE] * np.r_[0, portfolio_position[:-1]]\n\n # Turnover Analysis 简化计算，全仓操作 100%换手\n portfolio_turnover = np.where(portfolio_position != np.r_[0, portfolio_position[:-1]], 1, 0)\n portfolio_turnover_ratio = rolling_sum(portfolio_turnover, annual)\n\n portfolio_annual_return = portfolio_returns.rolling(annual).apply(lambda x: \n empyrical.annual_return(x, annualization=annual), \n raw=True)\n portfolio_sharpe_ratio = empyrical.roll_sharpe_ratio(portfolio_returns, risk_free=rsk_fre / annual, \n annualization=annual, window=annual)\n portfolio_max_drawdown = empyrical.roll_max_drawdown(portfolio_returns, annual)\n\n turnover_ratio_mean = np.mean(portfolio_turnover_ratio[annual:])\n turnover_ratio_mean = turnover_ratio_mean if (turnover_ratio_mean > 2) else 24\n annual_return_mean = np.mean((portfolio_annual_return.values - portfolio_turnover_ratio * taxfee)[annual:])\n\n ret_portfolio_state_template = 'Code {}, {}, {} sharpe:{:.2f}, annual_return:{:.2%}, max_drawdown:{:.2%}, turnover:{:.0%}'\n ret_portfolio_state = ret_portfolio_state_template.format(codelist, \n codename,\n strategy_name,\n portfolio_sharpe_ratio[-1], \n (portfolio_annual_return.values - portfolio_turnover_ratio * taxfee)[-1], \n portfolio_max_drawdown[-1],\n portfolio_turnover_ratio[-1])\n #print(ret_portfolio_state)\n return pd.Series({'symbol':codelist,\n 'name':codename,\n 'portfolio':strategy_name,\n 'sharpe':portfolio_sharpe_ratio[-1],\n 'annual_return':(portfolio_annual_return.values - portfolio_turnover_ratio * taxfee)[-1],\n idx_TRANSACTION_RETURN_MEAN:annual_return_mean / (turnover_ratio_mean / 2),\n 'max_drawdown': portfolio_max_drawdown[-1], \n 'turnover_ratio': portfolio_turnover_ratio[-1]})\n\n\ndef calc_onhold_positions(data, *args, **kwargs):\n \"\"\"\n 计算复合仓位，支持QA add_func，第二个参数 默认为 indices= 为已经计算指标\n 理论上这个函数只计算单一标的，不要尝试传递复杂标的，indices会尝试拆分。\n \"\"\"\n # 针对多标的，拆分 indices 数据再自动合并\n code = data.index.get_level_values(level=1)[0]\n if ('indices' in kwargs.keys()):\n indices = kwargs['indices'].loc[(slice(None), code), :]\n elif (len(args) > 0):\n indices = args[0].loc[(slice(None), code), :]\n else:\n print(u'Missing paramters: agrs[0] or kwargs[\\'indices\\']')\n indices = None\n \n try:\n indices[idx_ONHOLD_BEFORE] = Timeline_duration(np.where(((indices[ST.TRIGGER_R5] > 0).shift(1) == False) & \\\n (indices[ST.TRIGGER_R5] > 0), \n 1, 0))\n indices[idx_OFFHOLD_BEFORE] = Timeline_duration(np.where(((indices[ST.TRIGGER_R5] < 0).shift(1) == False) & \\\n (indices[ST.TRIGGER_R5] < 0), \n 1, 0))\n except:\n print(code, \n 't1', indices.index.get_level_values(level=0)[0], \n 't2', indices.index.get_level_values(level=0)[-1])\n raise Exception('fooo666:{}'.format(code))\n\n indices[ST.POSITION_ONHOLD] = np.where(indices[idx_ONHOLD_BEFORE] < indices[idx_OFFHOLD_BEFORE], \n 1, 0)\n\n # 平顺买点波动，平滑买点天数计数\n indices[idx_ONHOLD_BEFORE] = Timeline_duration(np.where(((indices[ST.POSITION_ONHOLD] > 0).shift(1) == False) & \\\n (indices[ST.POSITION_ONHOLD] > 0), \n 1, 0))\n indices[idx_LEVERAGE_ONHOLD] = np.where(indices[ST.POSITION_ONHOLD] == 1, \n indices[idx_LEVERAGE_NORM], 0)\n\n #if (ST.VERBOSE in data.columns):\n # print(indices[[AKA.CLOSE,\n # idx_BOLL_CROSS_SX_BEFORE,\n # idx_ZSCORE_21,\n # idx_ATR_CROSS,\n # idx_MAXFACTOR_CROSS,\n # idx_ZEN_TIDE_DENSITY,\n # idx_COMBINE_DENSITY,\n # ST.CANDIDATE]].tail(50))\n\n return indices\n\n\n#@nb.jit(nopython=True)\n#def calc_onhold_returns_np(closep:np.ndarray,\n# features:np.ndarray,\n# long:int=1,\n# verbose:bool=True) -> np.ndarray:\n# \"\"\"\n# 计算持仓利润，np.ndarray 实现，编码规范支持JIT和Cython加速\n# \"\"\"\n# idx_DATETIME = 0 # DATETIME\n# idx_DAILY_RETURNS = 1 # DAILY_RETURNS\n# idx_TRIGGER = 2 # BUY ACTION\n# idx_ONHOLD_RETURNS = 2 # LEVERAGE 仓位 默认为 1\n# idx_POSITION = 3 # ONHOLD STATE after BUY ACTION 1 bar\n# idx_LEVERAGE = 4 # LEVERAGE 仓位 默认为 1\n\n# ret_onhold_returns = np.zeros((len(closep), 4),)\n# for i in range(1, len(features)):\n# if (features[i, idx_POSITION] == 1) or \\\n# ((features[i - 1, idx_TRIGGER] == 1)):\n# if ((features[i - 1, idx_TRIGGER] == 1) and (features[i,\n# idx_POSITION] != 1)):\n# if (verbose):\n# print(u'买入状态设置，本应设置的状态没有设置。')\n# features[i, idx_POSITION] == 1\n\n# ret_onhold_returns[i, idx_DATETIME] = features[i, idx_DATETIME]\n# ret_onhold_returns[i, idx_DAILY_RETURNS] = features[i,\n# idx_DAILY_RETURNS]\n# ret_onhold_returns[i, idx_POSITION] = features[i, idx_POSITION]\n# ret_onhold_returns[i, idx_ONHOLD_RETURNS] = ret_onhold_returns[i,\n# idx_ONHOLD_RETURNS] + features[i, idx_DAILY_RETURNS] *\n# ret_onhold_returns[i, idx_POSITION]\n\n# if (verbose):\n# pass\n\n# return ret_onhold_returns\n@nb.jit(nopython=True)\ndef calc_onhold_returns_v2(daily_returns:np.ndarray, \n daily_position:np.ndarray,\n long:int=1,) -> np.ndarray:\n \"\"\"\n 计算当前持仓利润，当一次持仓状态结束的时候清零\n np.ndarray 实现，编码规范支持JIT和Cython加速\n \"\"\"\n ret_onhold_returns = np.zeros(len(daily_returns),)\n onhold_returns = 0.0\n onhold_position = False\n assert long == 1 or long == -1\n for i in range(0, len(daily_position)):\n if (onhold_position):\n onhold_returns = onhold_returns + daily_returns[i] * long\n else:\n onhold_returns = 0.0 \n ret_onhold_returns[i] = onhold_returns\n\n if (daily_position[i] > 0):\n onhold_position = True\n\n if (daily_position[i] <= 0):\n onhold_position = False\n\n return ret_onhold_returns\n\n\n@nb.jit(nopython=True)\ndef calc_onhold_returns_np(closep:np.ndarray, \n daily_position:np.ndarray,\n long:int=1,) -> np.ndarray:\n \"\"\"\n 计算当前持仓利润，当一次持仓状态结束的时候清零\n np.ndarray 实现，编码规范支持JIT和Cython加速\n \"\"\"\n ret_onhold_returns = np.zeros(len(closep),)\n onhold_price = onhold_returns = 0.0\n onhold_position = False\n assert long == 1 or long == -1\n for i in range(0, len(daily_position)):\n if (np.isnan(daily_position[i])):\n continue\n\n if (onhold_position):\n if (daily_position[i - 1] <= 0):\n onhold_price = closep[i]\n else:\n onhold_price = closep[i]\n if (onhold_price > 0.001):\n ret_onhold_returns[i] = (closep[i] - onhold_price) / onhold_price * long\n\n if (daily_position[i] > 0):\n onhold_position = True\n\n if (daily_position[i] <= 0):\n onhold_position = False\n\n return ret_onhold_returns\n\n\ndef calc_onhold_returns(data, *args, **kwargs):\n \"\"\"\n 计算持仓利润，支持QA add_func，第二个参数 默认为 indices= 为已经计算指标\n 理论上这个函数只计算单一标的，不要尝试传递复杂标的，indices会尝试拆分。\n 这是针对 pd 参数和 QA.add_func 的 Wrapper，因为不能JIT和Cython加速。\n \"\"\"\n # 针对多标的，拆分 indices 数据再自动合并\n code = data.index.get_level_values(level=1)[0]\n if ('indices' in kwargs.keys()):\n indices = kwargs['indices'].loc[(slice(None), code), :]\n elif (len(args) > 0):\n indices = args[0].loc[(slice(None), code), :]\n else:\n print(u'Missing paramters: agrs[0] or kwargs[\\'indices\\']')\n indices = None\n \n return indices\n\n\n#@nb.jit(nopython=True)\ndef calc_positions_StockCN(position:np.ndarray,\n indices:np.ndarray,\n upper_limit:int=1.0,\n lower_limit:int=0.0) -> np.ndarray:\n \"\"\"\n 计算配合开仓条件的实际仓位变化，\n \"\"\"\n leverage_delta = position[:, 0]\n position_norm = position[:, 1]\n position_pre = position[:, 2]\n position_signal = position[:, 3]\n\n ma90_clearance = indices[:, 0]\n ma120_clearance = indices[:, 1]\n closep = indices[:, 2]\n\n # 实际仓位变化为\n position_delta = position_pre - position_norm\n\n order_position = np.zeros((len(leverage_delta), 3))\n for i in range(len(position_signal)):\n if (i == 0):\n order_position[i, 2] = 0.0\n else:\n order_position[i, 2] = np.nan\n\n if (position_signal[i] > 0):\n # 开仓模式\n if (position_delta[i] > 0):\n if ((ma90_clearance[i] + ma120_clearance[i]) > 1.24):\n # 高位冒险，尝试逐步加仓\n order_position[i, 0] = abs(max(position_delta[i], leverage_delta[i]))\n else:\n # 直接一步到位建仓\n order_position[i, 0] = abs(position_norm[i])\n\n order_position[i, 2] = order_position[i, 0]\n continue\n elif (position_signal[i] < 0):\n if (position_delta[i] < 0):\n if ((ma90_clearance[i] + ma120_clearance[i]) > 1.24) or \\\n (position_delta[i] < -0.168):\n # 高位冒险，直接清仓\n order_position[i, 0] = -max(position_pre[i], \n order_position[i - 1, 2])\n order_position[i, 2] = 0.0\n else:\n # 逐步减仓\n order_position[i, 0] = position_delta[i]\n order_position[i, 2] = order_position[i - 1, 2] + position_delta[i]\n continue\n \n if (position_delta[i] < 0):\n if ((order_position[i - 1, 2] + position_delta[i]) > 0):\n # 逐步减仓\n order_position[i, 0] = position_delta[i]\n order_position[i, 2] = order_position[i - 1, 2] + position_delta[i]\n else:\n # 被动清仓\n order_position[i, 0] = -max(position_pre[i],\n order_position[i - 1, 2])\n order_position[i, 2] = 0.0\n continue\n elif (position_delta[i] > 0):\n if (order_position[i - 1, 2] > 0):\n # 被动加仓\n order_position[i, 0] = position_delta[i]\n order_position[i, 2] = order_position[i - 1, 2] + position_delta[i]\n else:\n # 疑似踏空\n order_position[i:, 1] = 1\n order_position[i, 2] = order_position[i - 1, 2]\n elif(abs(position_delta[i]) < 0.005):\n # Do nothing 判断条件不足，阈值不足以做任何操作\n order_position[i, 2] = order_position[i - 1, 2]\n\n return order_position\n\n\n@nb.jit(nopython=True)\ndef calc_leverages(leverage_delta:np.ndarray,\n upper_limit:int=1.0,\n lower_limit:int=0.0) -> np.ndarray:\n \"\"\"\n 计算连续加减杠杆（仓位）比例变化\n \"\"\"\n leverage_norm = np.zeros((len(leverage_delta),2))\n for i in range(len(leverage_delta)):\n leverage_norm[i, 1] = leverage_norm[i - 1, 0]\n leverage_norm[i, 0] = leverage_norm[i - 1, 0] + leverage_delta[i]\n if (leverage_norm[i, 0] > upper_limit):\n leverage_norm[i, 0] = upper_limit\n elif (leverage_norm[i, 0] < lower_limit):\n leverage_norm[i, 0] = lower_limit\n \n return leverage_norm\n\n\ndef calc_massive_fractal_trend(features:pd.DataFrame=None,) -> pd.DataFrame:\n \"\"\"\n A股中某些特殊日子是建仓的黄道吉日，比如2020年8月20日，2020年8月27日，\n 2020年9月28~30日，20-12-28 29 30，2021年01月20日。\n 本函数用缠论折点的时间共振 + 高斯聚类判断(大雾) 其实只需要判断TIMING_LAG=1~4小时即可\n 计算出这些（决定性的建仓日）日子和在决定性的建仓日适合购买的股票。\n \"\"\"\n #print(u'calc_massive_fractal_trend')\n symbol_list = sorted(features.index.get_level_values(level=1).unique())\n column_list = [FLD.PEAK_LOW_TIMING_LAG,\n FLD.HMAPOWER120_TIMING_LAG,\n FLD.HMAPOWER120_QUARTER,\n FLD.MAPOWER30_TIMING_LAG,\n FLD.MAPOWER30_QUARTER,\n FLD.MA90_CLEARANCE,\n FLD.MA_CHANNEL,\n FLD.MACD_ZERO_TIMING_LAG,\n FLD.DIF_ZERO_TIMING_LAG,\n FLD.ZEN_WAVELET_TIMING_LAG,\n FLD.BOLL_RAISED_TIMING_LAG,\n FLD.POLYNOMIAL9_TIMING_LAG,\n FTR.POLYNOMIAL9_DUAL,\n FLD.MAPOWER30,\n FLD.MAPOWER30_MAJOR,\n FLD.HMAPOWER120_MAJOR,\n FLD.MAINFEST_UPRISING_COEFFICIENT,\n FTR.BOOTSTRAP_ENHANCED_TIMING_LAG,\n FLD.MAINFEST_DOWNRISK_TIMING_LAG,\n 'dt']\n\n #try:\n if (True):\n features['dt'] = pd.to_datetime(features.index.get_level_values(level=0),).tz_localize('Asia/Shanghai')\n print(len(features.columns), len(set(features.columns.values)), len(features.columns), len(set(features.columns.values)))\n # 对齐数据，DataFrame转为3维array数组，用于cython或者jit加速运行\n features_aligned = features[column_list].unstack().ffill().bfill().stack()\n features_np = features_aligned.drop(['dt'], \n axis=1).values.reshape(*features.index.levshape,\n -1)\n #features_aligned['dt'] =\n #pd.to_datetime(features_aligned.index.get_level_values(level=0),).tz_localize('Asia/Shanghai')\n symbol_list = features_aligned.index.get_level_values(level=1).unique()\n each_day = features_aligned['dt'].values\n each_day_epoch = sorted(np.unique(each_day.astype(np.int64)) // 10 ** 9)\n #print(type(np.array(each_day_epoch, dtype=np.int64)))\n ret_massive_fractal_trend = calc_massive_uprising_func(np.array(each_day_epoch, dtype=np.int64), \n features_np)\n #except Exception as e:\n # print(e)\n # each_day = features.index.get_level_values(level=0).unique()\n # symbol_list = features.index.get_level_values(level=1).unique()\n # each_day_epoch = sorted(each_day.astype(np.int64) // 10 ** 9)\n # ret_massive_fractal_trend = None\n\n #print(u'calc_massive_fractal_trend phase #2')\n\n if (ret_massive_fractal_trend is None):\n features[FLD.MASSIVE_TREND] = np.nan\n features[FLD.MASSIVE_TREND_BEFORE] = np.nan\n features[FLD.MASSIVE_TREND_RETURNS] = np.nan\n features[FLD.MASSIVE_TREND_CHECKOUT_CLOSE] = np.nan\n else:\n ret_massive_trend_pd = pd.DataFrame(ret_massive_fractal_trend, \n index=pd.to_datetime(ret_massive_fractal_trend[:, 0],\n unit='s').tz_localize('UTC').tz_convert('Asia/Shanghai').tz_localize(None),\n columns=[AKA.DATETIME, FLD.MASSIVE_TREND, FLD.MAPOWER_MEDIAN])\n #print(ret_massive_trend_pd.tail(100))\n if (FLD.MASSIVE_TREND not in features.columns):\n features = features.reindex(columns=[*features.columns,\n *[FLD.MASSIVE_TREND,\n FLD.MASSIVE_TREND_BEFORE,]])\n for symbol in symbol_list:\n features_slice = features.loc[(slice(None), symbol), :]\n features.loc[(slice(None), symbol),\n FLD.MASSIVE_TREND] = np.where((features_slice[FLD.MAINFEST_DOWNRISK_TIMING_LAG] > 0) & \\\n (features_slice[FLD.MAINFEST_DOWNRISK_TIMING_LAG] <= 4) & \\\n (features_slice[FLD.SEMI_DOWNRISK] < 0.5) & \\\n (ret_massive_trend_pd.loc[features_slice.index.get_level_values(level=0), \n FLD.MASSIVE_TREND] > 0), 1, 0)\n features.loc[(slice(None), symbol), \n FLD.MASSIVE_TREND_BEFORE] = Timeline_duration(features.loc[(slice(None), symbol),\n FLD.MASSIVE_TREND].values)\n features.loc[(slice(None), symbol), \n FLD.MASSIVE_TREND_CHECKOUT_CLOSE] = np.where(features.loc[(slice(None), symbol), \n FLD.MASSIVE_TREND_BEFORE] == 0, \n features_slice[AKA.CLOSE], np.nan)\n features.loc[(slice(None), symbol), \n FLD.MASSIVE_TREND_CHECKOUT_CLOSE] = features.loc[(slice(None), symbol), \n FLD.MASSIVE_TREND_CHECKOUT_CLOSE].ffill()\n features.loc[(slice(None), symbol), \n FLD.MASSIVE_TREND_RETURNS] = np.log(features_slice[AKA.CLOSE] / features.loc[(slice(None), symbol), \n FLD.MASSIVE_TREND_CHECKOUT_CLOSE])\n\n return features, ret_massive_fractal_trend\n\n\n@nb.jit('f8[:,:](i8[:], f8[:,:,:])', nopython=True)\ndef calc_massive_fractal_trend_func(each_day_epoch:np.ndarray, \n features_np:np.ndarray,) -> np.ndarray:\n \"\"\"\n 在版块行情特征数据中提取上升浪\n \"\"\"\n #print(features.shape)\n idx_PEAK_LOW_TIMING_LAG = 0\n idx_HMAPOWER120_TIMING_LAG = 1\n idx_HMAPOWER120_QUARTER = 2\n idx_MAPOWER30_TIMING_LAG = 3\n idx_MAPOWER30_QUARTER = 4\n idx_MA90_CLEARANCE = 5\n idx_MA_CHANNEL = 6\n idx_MACD_ZERO_TIMING_LAG = 7\n idx_DIF_ZERO_TIMING_LAG = 8\n idx_ZEN_WAVELET_TIMING_LAG = 9\n idx_BOLL_RAISED_TIMING_LAG = 10\n idx_POLYNOMIAL9_TIMING_LAG = 11\n idx_POLYNOMIAL9_DUAL = 12\n idx_MAPOWER30 = 13\n idx_MAPOWER30_MAJOR = 14\n idx_HMAPOWER120_MAJOR = 15\n idx_MAINFEST_UPRISING_COEFFICIENT = 16\n idx_BOOTSTRAP_ENHANCED_TIMING_LAG = 17\n idx_MAINFEST_DOWNRISK_TIMING_LAG = 18\n\n ret_massive_fractal_trend = np.zeros((len(each_day_epoch),3))\n ret_massive_fractal_trend[:, 0] = each_day_epoch\n totals = len(features_np[0, :, idx_PEAK_LOW_TIMING_LAG])\n polynomial9_sum_yesterday = 0\n mapower_median_yesterday = 0\n mainfest_uprising_median_yesterday = 0\n bootstrap_enhanced_median_yesterday = 0\n for i in range(0, len(each_day_epoch)):\n mapower_median = np.median(features_np[i, :, idx_MAPOWER30]) + np.median(features_np[i, :, idx_MAPOWER30_MAJOR]) + np.median(features_np[i, :, idx_HMAPOWER120_MAJOR])\n mainfest_uprising_median = np.median(features_np[i, :, idx_MAINFEST_UPRISING_COEFFICIENT])\n bootstrap_enhanced_median = np.median(features_np[i, :, idx_BOOTSTRAP_ENHANCED_TIMING_LAG])\n day_pieces = np.where(features_np[i, :, idx_POLYNOMIAL9_TIMING_LAG] > 0)\n polynomial9_sum = np.sum(np.where(features_np[i, :, idx_POLYNOMIAL9_TIMING_LAG] > 0, 1, 0))\n polynomial9_dual_sum = np.sum(np.where(features_np[i, :, idx_POLYNOMIAL9_DUAL] > 0, 1, 0))\n\n if (np.median(features_np[i, :, idx_PEAK_LOW_TIMING_LAG]) > 0) and \\\n (np.median(features_np[i, :, idx_HMAPOWER120_TIMING_LAG]) > 0) and \\\n (np.median(features_np[i, :, idx_HMAPOWER120_QUARTER]) > 0) and \\\n (np.median(features_np[i, :, idx_MAPOWER30_TIMING_LAG]) > 0) and \\\n (np.median(features_np[i, :, idx_MAPOWER30_QUARTER]) > 0) and \\\n (np.median(features_np[i, :, idx_MA90_CLEARANCE]) > 0) and \\\n (np.median(features_np[i, :, idx_MA_CHANNEL]) > 0) and \\\n ((np.median(features_np[i, :, idx_MACD_ZERO_TIMING_LAG]) > 0) or \\\n ((np.median(features_np[i, :, idx_MA90_CLEARANCE]) < 0.618) and \\\n (np.median(features_np[i, :, idx_ZEN_WAVELET_TIMING_LAG]) > 0))) and \\\n (np.median(features_np[i, :, idx_DIF_ZERO_TIMING_LAG]) > 0):\n if ((int(mainfest_uprising_median) != 1) and (int(bootstrap_enhanced_median) != 1) and \\\n (mapower_median_yesterday > mapower_median)) or \\\n ((int(mainfest_uprising_median) > 20) and (int(bootstrap_enhanced_median) > 20)):\n pass\n else:\n ret_massive_fractal_trend[i, 1] = 1\n \n if ((polynomial9_sum / totals > 0.382) and (polynomial9_dual_sum / polynomial9_sum > 0.618) and \\\n (polynomial9_sum_yesterday < polynomial9_sum / totals) and (mapower_median < 2.3)) or \\\n ((polynomial9_sum / totals > 0.618) and (polynomial9_dual_sum / polynomial9_sum > 0.512) and \\\n (polynomial9_sum_yesterday > 0.618) and (mapower_median < 1)) or \\\n ((polynomial9_sum / totals > 0.618) and (polynomial9_dual_sum / polynomial9_sum > 0.618) and \\\n (mapower_median < 1)) or \\\n ((polynomial9_sum / totals > 0.618) and (polynomial9_dual_sum / polynomial9_sum > 0.512) and \\\n (mapower_median < 0.618)) or \\\n ((int(mainfest_uprising_median) == 1) and \\\n (int(mainfest_uprising_median_yesterday) < 0.1) and (bootstrap_enhanced_median_yesterday < 0.1)) or \\\n ((int(mainfest_uprising_median) == 1) and \\\n (int(mainfest_uprising_median_yesterday) == 1) and (bootstrap_enhanced_median_yesterday < 0.1)) or \\\n ((int(bootstrap_enhanced_median) == 1) and \\\n ((mainfest_uprising_median - bootstrap_enhanced_median) > -0.1) and \\\n ((mainfest_uprising_median - bootstrap_enhanced_median) < 6.1)):\n if ((int(mainfest_uprising_median) != 1) and (int(bootstrap_enhanced_median) != 1) and \\\n (mapower_median_yesterday > mapower_median)) or \\\n ((int(mainfest_uprising_median) > 20) and (int(bootstrap_enhanced_median) > 20)):\n pass\n else:\n if (ret_massive_fractal_trend[i, 1] == 0) :\n ret_massive_fractal_trend[i, 1] = 2\n #print(QA_util_print_timestamp(each_day[i]),\n #polynomial9_sum,\n # '{:.2%}'.format(polynomial9_sum / totals),\n # '{:3d}'.format(polynomial9_dual_sum),\n # '{:.2%}'.format(polynomial9_dual_sum /\n # polynomial9_sum),\n # '{:.3f}'.format(np.median(features[i,\n # day_pieces, idx_BOLL_RAISED_TIMING_LAG])),\n # '{:.3f}'.format(np.quantile(features[i,\n # day_pieces, idx_BOLL_RAISED_TIMING_LAG], 0.75)),\n # '{:.3f}'.format(np.median(features[i, :,\n # idx_MAPOWER30])),\n # '{:.3f}'.format(np.median(features[i, :,\n # idx_MAPOWER30_MAJOR])),\n # '{:.3f}'.format(np.median(features[i, :,\n # idx_HMAPOWER120_MAJOR])),\n # '{:.1f}'.format(np.median(features[i, :,\n # idx_MAINFEST_UPRISING_COEFFICIENT])),\n # '{:.1f}'.format(np.median(features[i, :,\n # idx_BOOTSTRAP_ENHANCED_TIMING_LAG])),\n # '{:.3f}'.format(mapower_median), u'<<-- 建仓日')\n else:\n ret_massive_fractal_trend[i, 1] = 3\n #print(QA_util_print_timestamp(each_day[i]),\n #polynomial9_sum,\n # '{:.2%}'.format(polynomial9_sum / totals),\n # '{:3d}'.format(polynomial9_dual_sum),\n # '{:.2%}'.format(polynomial9_dual_sum /\n # polynomial9_sum),\n # '{:.3f}'.format(np.median(features[i, :,\n # idx_BOLL_RAISED_TIMING_LAG])),\n # '{:.3f}'.format(np.quantile(features[i, :,\n # idx_BOLL_RAISED_TIMING_LAG], 0.75)),\n # '{:.3f}'.format(np.median(features[i, :,\n # idx_MAPOWER30])),\n # '{:.3f}'.format(np.median(features[i, :,\n # idx_MAPOWER30_MAJOR])),\n # '{:.3f}'.format(np.median(features[i, :,\n # idx_HMAPOWER120_MAJOR])),\n # '{:.1f}'.format(np.median(features[i, :,\n # idx_MAINFEST_UPRISING_COEFFICIENT])),\n # '{:.1f}'.format(np.median(features[i, :,\n # idx_BOOTSTRAP_ENHANCED_TIMING_LAG])),\n # '{:.3f}'.format(mapower_median), u'<<-- 建仓日')\n else:\n #print(QA_util_print_timestamp(each_day[i]), polynomial9_sum,\n # '{:.2%}'.format(polynomial9_sum / totals),\n # '{:3d}'.format(polynomial9_dual_sum),\n # '{:.2%}'.format(polynomial9_dual_sum /\n # polynomial9_sum),\n # '{:.3f}'.format(np.median(features[i, :,\n # idx_BOLL_RAISED_TIMING_LAG])),\n # '{:.3f}'.format(np.quantile(features[i, :,\n # idx_BOLL_RAISED_TIMING_LAG], 0.75)),\n # '{:.3f}'.format(np.median(features[i, :,\n # idx_MAPOWER30])),\n # '{:.3f}'.format(np.median(features[i, :,\n # idx_MAPOWER30_MAJOR])),\n # '{:.3f}'.format(np.median(features[i, :,\n # idx_HMAPOWER120_MAJOR])),\n # '{:.1f}'.format(np.median(features[i, :,\n # idx_MAINFEST_UPRISING_COEFFICIENT])),\n # '{:.1f}'.format(np.median(features[i, :,\n # idx_BOOTSTRAP_ENHANCED_TIMING_LAG])),\n # '{:.3f}'.format(mapower_median))\n pass\n ret_massive_fractal_trend[i, 2] = mapower_median\n polynomial9_sum_yesterday = polynomial9_sum / totals\n mainfest_uprising_median_yesterday = mainfest_uprising_median\n bootstrap_enhanced_median_yesterday = bootstrap_enhanced_median\n mapower_median_yesterday = mapower_median\n #print(i, each_day[i], 'Yes!')\n #if (i % 100 == 0):\n # print(i, each_day[i])\n #pass\n #print('sum', np.sum(ret_massive_fractal_trend[:, 1]))\n return ret_massive_fractal_trend\n\n\n@nb.jit('f8[:,:](i8[:], f8[:,:,:])', nopython=True)\ndef calc_massive_uprising_func(each_day_epoch:np.ndarray, \n features_np:np.ndarray,) -> np.ndarray:\n \"\"\"\n 在版块行情特征数据中提取上升浪\n \"\"\"\n idx_PEAK_LOW_TIMING_LAG = 0\n idx_HMAPOWER120_TIMING_LAG = 1\n idx_HMAPOWER120_QUARTER = 2\n idx_MAPOWER30_TIMING_LAG = 3\n idx_MAPOWER30_QUARTER = 4\n idx_MA90_CLEARANCE = 5\n idx_MA_CHANNEL = 6\n idx_MACD_ZERO_TIMING_LAG = 7\n idx_DIF_ZERO_TIMING_LAG = 8\n idx_ZEN_WAVELET_TIMING_LAG = 9\n idx_BOLL_RAISED_TIMING_LAG = 10\n idx_POLYNOMIAL9_TIMING_LAG = 11\n idx_POLYNOMIAL9_DUAL = 12\n idx_MAPOWER30 = 13\n idx_MAPOWER30_MAJOR = 14\n idx_HMAPOWER120_MAJOR = 15\n idx_MAINFEST_UPRISING_COEFFICIENT = 16\n idx_BOOTSTRAP_ENHANCED_TIMING_LAG = 17\n idx_MAINFEST_DOWNRISK_TIMING_LAG = 18\n\n ret_massive_fractal_trend = np.zeros((len(each_day_epoch),3))\n ret_massive_fractal_trend[:, 0] = each_day_epoch\n totals = len(features_np[0, :, idx_PEAK_LOW_TIMING_LAG])\n for i in range(0, len(each_day_epoch)):\n mapower_median = np.median(features_np[i, :, idx_MAPOWER30]) + np.median(features_np[i, :, idx_MAPOWER30_MAJOR]) + np.median(features_np[i, :, idx_HMAPOWER120_MAJOR])\n ret_massive_fractal_trend[i, 2] = mapower_median\n uprising_counts = np.where(features_np[i, :, idx_MAINFEST_DOWNRISK_TIMING_LAG] == 1)[0]\n if ((len(uprising_counts) * 4 / totals > 0.1236) and not ((totals < 100) and (len(uprising_counts) < 4))) or \\\n ((totals < 100) and (len(uprising_counts) > 5)) or \\\n ((len(uprising_counts) * 4 / totals > 0.0927) and (len(uprising_counts) > 5)):\n ret_massive_fractal_trend[i, 1] = 1\n #print(QA_util_print_timestamp(each_day[i]), u'<<-- 建仓日',\n # 'len {:d}, {:.02%}'.format(len(uprising_counts),\n # (len(uprising_counts) * 4) /\n # totals),\n # uprising_counts)\n else:\n #print(QA_util_print_timestamp(each_day[i]),\n # 'len {:d}, {:.02%}'.format(len(uprising_counts),\n # (len(uprising_counts) * 4) /\n # totals),\n # uprising_counts)\n pass\n\n return ret_massive_fractal_trend\n\n\ndef calc_massive_csindex_trend(features:pd.DataFrame=None,) -> pd.DataFrame:\n \"\"\"\n \"\"\"\n symbol_list = sorted(features.index.get_level_values(level=1).unique())\n \n column_list = [FLD.PEAK_OPEN,\n FLD.ZEN_PEAK_TIMING_LAG,\n FLD.ZEN_DASH_TIMING_LAG,\n FLD.ZEN_WAVELET_TIMING_LAG,\n FLD.ZEN_BOOST_TIMING_LAG,\n FLD.RENKO_BOOST_S_TIMING_LAG,\n FLD.RENKO_TREND_S_TIMING_LAG,\n FLD.PEAK_LOW_TIMING_LAG,\n FLD.HMAPOWER120_TIMING_LAG,\n FLD.MAPOWER30_TIMING_LAG,\n FLD.MACD_ZERO_TIMING_LAG,\n FLD.DIF_ZERO_TIMING_LAG,\n FLD.POLYNOMIAL9_TIMING_LAG,\n FLD.MAPOWER30,\n FLD.HMAPOWER120,]\n\n # 对齐数据，DataFrame转为3维array数组，用于cython或者jit加速运行\n try:\n features_aligned = features[column_list].unstack().ffill().bfill().stack()\n features_np = features_aligned.values.reshape(*features.index.levshape,-1)\n features_aligned['dt'] = pd.to_datetime(kline.data.index.get_level_values(level=0),).tz_localize('Asia/Shanghai')\n each_day = features_aligned['dt'].values\n symbol_list = features_aligned.index.get_level_values(level=1).unique()\n each_day_epoch = sorted(each_day.astype(np.int64) // 10 ** 9)\n\n ret_massive_fractal_trend = calc_massive_csindex_trend_func(np.array(each_day_epoch, dtype=np.int64), \n features_np)\n except:\n each_day = features.index.get_level_values(level=0).unique()\n symbol_list = features.index.get_level_values(level=1).unique()\n each_day_epoch = sorted(each_day.astype(np.int64) // 10 ** 9)\n ret_massive_fractal_trend = None\n\n if (ret_massive_fractal_trend is None):\n features[FLD.MASSIVE_TREND] = np.nan\n else:\n ret_massive_trend_pd = pd.DataFrame(ret_massive_fractal_trend, \n index=pd.to_datetime(ret_massive_fractal_trend[:, 0],\n unit='s'),\n columns=[AKA.DATETIME, FLD.MASSIVE_TREND, FLD.MAPOWER_MEDIAN])\n\n features[FLD.MASSIVE_TREND] = ret_massive_trend_pd.loc[ret_codelist_combo.index.get_level_values(level=0), \n FLD.MASSIVE_TREND].values\n\n return features, ret_massive_fractal_trend\n\n\n#@nb.jit('f8[:,:](i8[:], f8[:,:,:])', nopython=True)\ndef calc_massive_csindex_trend_func(each_day:np.ndarray, \n features:np.ndarray,) -> np.ndarray:\n \"\"\"\n 在版块行情特征数据中提取上升浪\n \"\"\"\n #print(features.shape)\n idx_PEAK_LOW_TIMING_LAG = 0\n idx_HMAPOWER120_TIMING_LAG = 1\n idx_HMAPOWER120_QUARTER = 2\n idx_MAPOWER30_TIMING_LAG = 3\n idx_MAPOWER30_QUARTER = 4\n idx_MA90_CLEARANCE = 5\n idx_MA_CHANNEL = 6\n idx_MACD_ZERO_TIMING_LAG = 7\n idx_DIF_ZERO_TIMING_LAG = 8\n idx_ZEN_WAVELET_TIMING_LAG = 9\n idx_PREDICT_GROWTH = 10\n idx_POLYNOMIAL9_TIMING_LAG = 11\n idx_POLYNOMIAL9_DUAL = 12\n idx_MAPOWER30 = 13\n idx_MAPOWER30_MAJOR = 14\n idx_HMAPOWER120_MAJOR = 15\n idx_MAINFEST_UPRISING_COEFFICIENT = 16\n idx_BOOTSTRAP_ENHANCED_TIMING_LAG = 17\n\n ret_massive_fractal_trend = np.zeros((len(each_day),3))\n ret_massive_fractal_trend[:, 0] = each_day\n totals = len(features[0, :, idx_PEAK_LOW_TIMING_LAG])\n polynomial9_sum_yesterday = 0\n mapower_median_yesterday = 0\n mainfest_uprising_median_yesterday = 0\n bootstrap_enhanced_median_yesterday = 0\n for i in range(0, len(each_day)):\n mapower_median = np.median(features[i, :, idx_MAPOWER30]) + np.median(features[i, :, idx_MAPOWER30_MAJOR]) + np.median(features[i, :, idx_HMAPOWER120_MAJOR])\n mainfest_uprising_median = np.median(features[i, :, idx_MAINFEST_UPRISING_COEFFICIENT])\n bootstrap_enhanced_median = np.median(features[i, :, idx_BOOTSTRAP_ENHANCED_TIMING_LAG])\n day_pieces = np.where(features[i, :, idx_POLYNOMIAL9_TIMING_LAG] > 0)\n polynomial9_sum = np.sum(np.where(features[i, :, idx_POLYNOMIAL9_TIMING_LAG] > 0, 1, 0))\n polynomial9_dual_sum = np.sum(np.where(features[i, :, idx_POLYNOMIAL9_DUAL] > 0, 1, 0))\n\n if (np.median(features[i, :, idx_PEAK_LOW_TIMING_LAG]) > 0) and \\\n (np.median(features[i, :, idx_HMAPOWER120_TIMING_LAG]) > 0) and \\\n (np.median(features[i, :, idx_HMAPOWER120_QUARTER]) > 0) and \\\n (np.median(features[i, :, idx_MAPOWER30_TIMING_LAG]) > 0) and \\\n (np.median(features[i, :, idx_MAPOWER30_QUARTER]) > 0) and \\\n (np.median(features[i, :, idx_MA90_CLEARANCE]) > 0) and \\\n (np.median(features[i, :, idx_MA_CHANNEL]) > 0) and \\\n ((np.median(features[i, :, idx_MACD_ZERO_TIMING_LAG]) > 0) or \\\n ((np.median(features[i, :, idx_MA90_CLEARANCE]) < 0.618) and \\\n (np.median(features[i, :, idx_ZEN_WAVELET_TIMING_LAG]) > 0))) and \\\n (np.median(features[i, :, idx_DIF_ZERO_TIMING_LAG]) > 0):\n if ((int(mainfest_uprising_median) != 1) and (int(bootstrap_enhanced_median) != 1) and \\\n (mapower_median_yesterday > mapower_median)) or \\\n ((int(mainfest_uprising_median) > 20) and (int(bootstrap_enhanced_median) > 20)):\n pass\n else:\n ret_massive_fractal_trend[i, 1] = 1\n \n if ((polynomial9_sum / totals > 0.382) and (polynomial9_dual_sum / polynomial9_sum > 0.618) and \\\n (polynomial9_sum_yesterday < polynomial9_sum / totals) and (mapower_median < 2.3)) or \\\n ((polynomial9_sum / totals > 0.618) and (polynomial9_dual_sum / polynomial9_sum > 0.512) and \\\n (polynomial9_sum_yesterday > 0.618) and (mapower_median < 1)) or \\\n ((polynomial9_sum / totals > 0.618) and (polynomial9_dual_sum / polynomial9_sum > 0.618) and \\\n (mapower_median < 1)) or \\\n ((polynomial9_sum / totals > 0.618) and (polynomial9_dual_sum / polynomial9_sum > 0.512) and \\\n (mapower_median < 0.618)) or \\\n ((int(mainfest_uprising_median) == 1) and \\\n (int(mainfest_uprising_median_yesterday) < 0.1) and (bootstrap_enhanced_median_yesterday < 0.1)) or \\\n ((int(mainfest_uprising_median) == 1) and \\\n (int(mainfest_uprising_median_yesterday) == 1) and (bootstrap_enhanced_median_yesterday < 0.1)) or \\\n ((int(bootstrap_enhanced_median) == 1) and \\\n ((mainfest_uprising_median - bootstrap_enhanced_median) > -0.1) and \\\n ((mainfest_uprising_median - bootstrap_enhanced_median) < 6.1)):\n if ((int(mainfest_uprising_median) != 1) and (int(bootstrap_enhanced_median) != 1) and \\\n (mapower_median_yesterday > mapower_median)) or \\\n ((int(mainfest_uprising_median) > 20) and (int(bootstrap_enhanced_median) > 20)):\n pass\n else:\n if (ret_massive_fractal_trend[i, 1] == 0) :\n ret_massive_fractal_trend[i, 1] = 2\n #print(QA_util_print_timestamp(each_day[i]),\n #polynomial9_sum,\n # '{:.2%}'.format(polynomial9_sum / totals),\n # '{:3d}'.format(polynomial9_dual_sum),\n # '{:.2%}'.format(polynomial9_dual_sum /\n # polynomial9_sum),\n # '{:.3f}'.format(np.median(features[i,\n # day_pieces, idx_PREDICT_GROWTH])),\n # '{:.3f}'.format(np.quantile(features[i,\n # day_pieces, idx_PREDICT_GROWTH], 0.75)),\n # '{:.3f}'.format(np.median(features[i, :,\n # idx_MAPOWER30])),\n # '{:.3f}'.format(np.median(features[i, :,\n # idx_MAPOWER30_MAJOR])),\n # '{:.3f}'.format(np.median(features[i, :,\n # idx_HMAPOWER120_MAJOR])),\n # '{:.1f}'.format(np.median(features[i, :,\n # idx_MAINFEST_UPRISING_COEFFICIENT])),\n # '{:.1f}'.format(np.median(features[i, :,\n # idx_BOOTSTRAP_ENHANCED_TIMING_LAG])),\n # '{:.3f}'.format(mapower_median), u'<<-- 建仓日')\n else:\n ret_massive_fractal_trend[i, 1] = 3\n #print(QA_util_print_timestamp(each_day[i]),\n #polynomial9_sum,\n # '{:.2%}'.format(polynomial9_sum / totals),\n # '{:3d}'.format(polynomial9_dual_sum),\n # '{:.2%}'.format(polynomial9_dual_sum /\n # polynomial9_sum),\n # '{:.3f}'.format(np.median(features[i, :,\n # idx_PREDICT_GROWTH])),\n # '{:.3f}'.format(np.quantile(features[i, :,\n # idx_PREDICT_GROWTH], 0.75)),\n # '{:.3f}'.format(np.median(features[i, :,\n # idx_MAPOWER30])),\n # '{:.3f}'.format(np.median(features[i, :,\n # idx_MAPOWER30_MAJOR])),\n # '{:.3f}'.format(np.median(features[i, :,\n # idx_HMAPOWER120_MAJOR])),\n # '{:.1f}'.format(np.median(features[i, :,\n # idx_MAINFEST_UPRISING_COEFFICIENT])),\n # '{:.1f}'.format(np.median(features[i, :,\n # idx_BOOTSTRAP_ENHANCED_TIMING_LAG])),\n # '{:.3f}'.format(mapower_median), u'<<-- 建仓日')\n else:\n #print(QA_util_print_timestamp(each_day[i]), polynomial9_sum,\n # '{:.2%}'.format(polynomial9_sum / totals),\n # '{:3d}'.format(polynomial9_dual_sum),\n # '{:.2%}'.format(polynomial9_dual_sum /\n # polynomial9_sum),\n # '{:.3f}'.format(np.median(features[i, :,\n # idx_PREDICT_GROWTH])),\n # '{:.3f}'.format(np.quantile(features[i, :,\n # idx_PREDICT_GROWTH], 0.75)),\n # '{:.3f}'.format(np.median(features[i, :,\n # idx_MAPOWER30])),\n # '{:.3f}'.format(np.median(features[i, :,\n # idx_MAPOWER30_MAJOR])),\n # '{:.3f}'.format(np.median(features[i, :,\n # idx_HMAPOWER120_MAJOR])),\n # '{:.1f}'.format(np.median(features[i, :,\n # idx_MAINFEST_UPRISING_COEFFICIENT])),\n # '{:.1f}'.format(np.median(features[i, :,\n # idx_BOOTSTRAP_ENHANCED_TIMING_LAG])),\n # '{:.3f}'.format(mapower_median))\n pass\n ret_massive_fractal_trend[i, 2] = mapower_median\n polynomial9_sum_yesterday = polynomial9_sum / totals\n mainfest_uprising_median_yesterday = mainfest_uprising_median\n bootstrap_enhanced_median_yesterday = bootstrap_enhanced_median\n mapower_median_yesterday = mapower_median\n #print(i, each_day[i], 'Yes!')\n #if (i % 100 == 0):\n # print(i, each_day[i])\n #pass\n #print('sum', np.sum(ret_massive_fractal_trend[:, 1]))\n return ret_massive_fractal_trend", "meta": {"hexsha": "130d1ee3411e9ee04186c111ba35341d663d6b55", "size": 71958, "ext": "py", "lang": "Python", "max_stars_repo_path": "portfolio/utils.py", "max_stars_repo_name": "xixigaga/GolemQ", "max_stars_repo_head_hexsha": "79640eaf34ab61c1591879e58c135ed2bab0c8ed", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "portfolio/utils.py", "max_issues_repo_name": "xixigaga/GolemQ", "max_issues_repo_head_hexsha": "79640eaf34ab61c1591879e58c135ed2bab0c8ed", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "portfolio/utils.py", "max_forks_repo_name": "xixigaga/GolemQ", "max_forks_repo_head_hexsha": "79640eaf34ab61c1591879e58c135ed2bab0c8ed", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 51.1792318634, "max_line_length": 174, "alphanum_fraction": 0.5287667806, "include": true, "reason": "import numpy,import scipy,import numba,from numba", "num_tokens": 17817, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5467381519846138, "lm_q2_score": 0.3557748866829643, "lm_q1q2_score": 0.19451570406757931}} {"text": "# Author: Xavier Paredes-Fortuny (xparedesfortuny@gmail.com)\n# License: MIT, see LICENSE.md\n\nimport numpy as np\nimport time\nimport interpolation_methods as im\nfrom resamp_line import resamp_line\n\n\ndef buffer_present_line(xc, yc, ic, jc, densc, epsc, vxc, vyc,\n divc, tracerc, tc, line_values):\n \"\"\"Keeps track of all the line parameters\"\"\"\n\n line_values.append([xc, yc, ic, jc, densc, epsc,\n vxc, vyc, divc, tracerc, tc])\n return\n\n\ndef buffer_all_lines(all_lines, line_values):\n \"\"\"Keeps track of all the complete lines\"\"\"\n\n all_lines.append(line_values)\n return\n\n\ndef save_all_lines(output_file, all_lines):\n \"\"\"Save all the lines to a file.\n Two lines for each current line:\n 1) length of line\n 2) (xc, yc, ic, jc, densc, epsc, vxc, vyc, divc, tracerc, tc)\n times the length of the line\"\"\"\n\n with open(output_file + '.dat', 'w') as f:\n for line in all_lines:\n line_length = len(line)\n f.write(str(line_length) + '\\n')\n for n in range(line_length):\n for var in line[n]:\n f.write(str(var) + ' ')\n f.write('\\n')\n return\n\n\ndef save_one_file_per_line(output_file, all_lines, gammaad, c, fB0, tr0,\n sf0_array, excluded_lines, input_file):\n \"\"\"Save one file per line. Each column:\n x, y, z, vx, vy, vz, dens, P, B, -div(v)/3, S, tracer\n We can not give the adiabatic losses because they are for the nonthermal\n particles, and from the RHD simulation we do not have this information.\n Therefore we just give -div(v)/3 instead of dE/dt.\n The line surface is given by the flux conservation from the initial\n surface for each line at the injection point (sf0). The surface\n corresponds to that one perpendicular to the line directon.\"\"\"\n\n # Discard the excluded lines from the \"sf0_array\" and add the excluded\n # line surface to the previous line\n #print np.sum(sf0_array[:, 0])\n aux = 1\n while aux == 1:\n aux = 0\n sf0 = sf0_array[:, 0]\n for ll in range(len(sf0)):\n sf0_ind = (sf0_array[ll,1], sf0_array[ll,2])\n if sf0_ind in excluded_lines:\n if ll == 0:\n sf0[1] += sf0[0]\n else:\n sf0[ll-1] += sf0[ll]\n sf0_array = np.delete(sf0_array, ll, 0)\n aux = 1\n break\n\n #print np.sum(sf0_array[:, 0]), len(sf0_array), len(all_lines)\n if len(sf0) != len(all_lines):\n raise RuntimeError('Surface indices do not match with line indices')\n\n # Discard lines with mixing\n aux = 1\n while aux == 1:\n aux = 0\n sf0 = sf0_array[:, 0]\n sf0_ind = sf0_array[:, 1]\n for ll in range(len(sf0)):\n x, y, i, j, dens, eps, vx, vy, div, tracer, time = zip(*all_lines[ll])\n for tr in tracer:\n if tr > tr0:\n aux = 1\n break\n if aux == 1:\n if ll == 0:\n sf0[1] += sf0[0]\n else:\n sf0[ll-1] += sf0[ll]\n sf0_array = np.delete(sf0_array, ll, 0)\n del all_lines[ll]\n break\n #print np.sum(sf0_array[:, 0]), len(sf0_array), len(all_lines)\n #print np.sum(sf0_array[:, 0])/(1e12)**2., len(sf0_array), len(all_lines)\n #print 2010612.22971\n if len(sf0) != len(all_lines):\n raise RuntimeError('Surface indices do not match with line indices')\n\n # Compute secondary variables and create the output files\n for ll, line in enumerate(all_lines):\n #with open('lines/'+output_file + '_' + str(ll+1) + '.dat', 'w') as f:\n with open('lines/lines' + str(ll+1).zfill(3), 'w') as f:\n x, y, i, j, dens, eps, vx, vy, div, tracer, time = zip(*line)\n x = np.array(x)\n y = np.array(y)\n z = np.zeros_like(x) # WARNING: modify if 3D\n dens = np.array(dens)\n eps = np.array(eps)\n vx = np.array(vx)\n vy = np.array(vy)\n vz = np.zeros_like(vx) # WARNING: modify if 3D\n div = np.array(div)\n tracer = np.array(tracer)\n time = np.array(time)\n\n # We will compute secondary variables only for nonzero cells\n nz = np.ones_like(time, dtype=bool)\n for l, t in enumerate(time):\n if l != 0 and t==0:\n nz[l] = 0\n v = np.zeros_like(time)\n v[nz] = np.sqrt(vx[nz]**2.+vy[nz]**2.)\n\n gamma = np.zeros_like(time)\n gamma[nz] = 1./np.sqrt(1.-(v[nz]/c)**2.)\n\n P = np.zeros_like(time)\n P[nz] = (gammaad-1.)*dens[nz]*eps[nz]\n\n h = np.zeros_like(time)\n h[nz] = 1.+eps[nz]/c**2.+P[nz]/dens[nz]/c**2.\n B = np.zeros_like(time)\n #B0 = np.sqrt(fB0*8.*np.pi*(dens[0]*h[0]*c**2.-dens[0]*c**2.-P[0]))\n\n # Energy flux equality\n B0 = np.sqrt(fB0*4.*np.pi*(dens[0]*h[0]*c**2.))\n B[nz] = B0*(dens[nz]*v[0]*gamma[0]/dens[0]/v[nz]/gamma[nz])**0.5\n\n fe = np.zeros_like(time)\n fe[nz] = dens[nz]*gamma[nz]**2.*h[nz]*v[nz]#-dens[nz]*gamma[nz]*v[nz]\n sf = np.zeros_like(time)\n sf[nz] = sf0[ll]*fe[0]/fe[nz] # Energy flux conservation\n# Particle flux conservation\n# sf[nz] = sf0[ll]*(dens[0]*v[0]*gamma[0]/dens[nz]/v[nz]/gamma[nz])\n\n # Save to file\n line_length = len(time)\n for n in range(line_length):\n f.write(str(x[n]) + ' ')\n f.write(str(y[n]) + ' ')\n f.write(str(z[n]) + ' ')\n f.write(str(vx[n]) + ' ')\n f.write(str(vy[n]) + ' ')\n f.write(str(vz[n]) + ' ')\n f.write(str(dens[n]) + ' ')\n f.write(str(P[n]) + ' ')\n f.write(str(B[n]) + ' ')\n f.write(str(-div[n]/3.) + ' ')\n f.write(str(sf[n]) + ' ')\n f.write(str(tracer[n]))\n f.write('\\n')\n return all_lines\n\n\ndef initial_position(xc, yc):\n \"\"\"Returns the initial position at t=0\"\"\"\n\n return xc, yc\n\n\ndef initial_indices(ic, jc):\n \"\"\"Returns the initial indices at t=0\"\"\"\n\n return ic, jc\n\n\ndef initial_variables(densc, epsc, vxc, vyc, divc, tracerc):\n \"\"\"Returns the initial variables at t=0\"\"\"\n\n return densc, epsc, vxc, vyc, divc, tracerc\n\n\ndef update_position(xc, yc, vxc, vyc, tstep):\n \"\"\"Returns the new position after a time step\"\"\"\n\n xc = xc+vxc*tstep\n yc = yc+vyc*tstep\n return xc, yc\n\n\ndef update_indices(xc, yc, xl, yl, xr, yr, ic, jc, vxc, vyc, nx, ny):\n \"\"\"Returns the cell indices for a given coordinates\"\"\"\n\n if vxc > 0:\n iend = nx\n di = 1\n else:\n iend = -1 # xrange function does not include the last element\n di = -1\n for i in xrange(ic, iend, di):\n if (xc >= xl[i]) and (xc < xr[i]):\n ic = i\n break\n\n if vyc > 0:\n jend = ny\n dj = 1\n else:\n jend = -1\n dj = -1\n for j in xrange(jc, jend, dj):\n if (yc >= yl[j]) and (yc < yr[j]):\n jc = j\n break\n return ic, jc\n\n\ndef interpolate(xc, yc, ic, jc, x, y, dens, eps, vx, vy, div, tracer,\n nx, ny, int_method, int_test):\n \"\"\"Interpolate the physical variables at (xc, yc)\"\"\"\n\n dens_test = 0\n if int_test == 1:\n dens_test = dens[ic, jc]\n elif int_test == 2:\n dens_test = im.bilinear(xc, yc, ic, jc, x, y, dens, nx, ny)\n elif int_test == 3:\n dens_test = im.one_dimensional(xc, yc, ic, jc, x, y, dens, nx, ny)\n\n if int_method == 0:\n return dens[ic, jc], eps[ic, jc], vx[ic, jc], vy[ic, jc], div[ic, jc], tracer[ic, jc], dens_test\n elif int_method == 1:\n densi = im.bilinear(xc, yc, ic, jc, x, y, dens, nx, ny)\n epsi = im.bilinear(xc, yc, ic, jc, x, y, eps, nx, ny)\n vxi = im.bilinear(xc, yc, ic, jc, x, y, vx, nx, ny)\n vyi = im.bilinear(xc, yc, ic, jc, x, y, vy, nx, ny)\n divi = im.bilinear_div(xc, yc, ic, jc, x, y, div, nx, ny)\n traceri = im.bilinear(xc, yc, ic, jc, x, y, tracer, nx, ny)\n return densi, epsi, vxi, vyi, divi, traceri, dens_test\n elif int_method == 2:\n densi = im.one_dimensional(xc, yc, ic, jc, x, y, dens, nx, ny)\n epsi = im.one_dimensional(xc, yc, ic, jc, x, y, eps, nx, ny)\n vxi = im.one_dimensional(xc, yc, ic, jc, x, y, vx, nx, ny)\n vyi = im.one_dimensional(xc, yc, ic, jc, x, y, vy, nx, ny)\n divi = div[ic, jc]\n traceri = im.one_dimensional(xc, yc, ic, jc, x, y, tracer, nx, ny)\n return densi, epsi, vxi, vyi, divi, traceri, dens_test\n\n\ndef buffer_diff(densc, densc2, int_diff):\n \"\"\"Keeps the difference between the two interpolation methods\"\"\"\n\n int_diff.append(abs(densc-densc2)/densc*100.)\n return\n\n\ndef tstep_test(ic, jc, ic_aux, jc_aux):\n \"\"\"Checks if the time step is too large\"\"\"\n\n if abs(ic-ic_aux) > 1 or abs(jc-jc_aux) > 1:\n raise RuntimeError('Step larger than 1 cell. '\n 'Reduce the tstep parameter')\n\n\ndef code_units_to_CGS(all_lines, sf0, c, rho0, a):\n \"\"\"Converts from code units to the CGS unit system.\"\"\"\n\n sf0[:, 0] = sf0[:, 0]*a**2.\n all_lines_new = []\n for line in all_lines:\n x, y, i, j, dens, eps, vx, vy, div, tracer, time = zip(*line)\n\n x = np.array(x)*a\n y = np.array(y)*a\n i = np.array(i)\n j = np.array(j)\n dens = np.array(dens)*rho0\n eps = np.array(eps)*c**2.\n vx = np.array(vx)*c\n vy = np.array(vy)*c\n div = np.array(div)*c/a\n tracer = np.array(tracer)\n time = np.array(time)*a/c\n\n line_new = []\n for l in range(len(x)):\n line_new.append([x[l], y[l], i[l], j[l], dens[l],\n eps[l], vx[l], vy[l], div[l], tracer[l],\n time[l]])\n all_lines_new.append(line_new)\n return all_lines_new, sf0\n\n\ndef compute_lines(x, y, xl, yl, xr, yr, vx, vy, dens, eps, tracer,\n injec, sf0, tstep,\n nx, ny, lx, ly, dx, dy, gammaad, div, itemax, resamp,\n int_method, int_test, CGS_units, c, rho0, a, fB0, tr0,\n input_file, output_file):\n \"\"\"Returns the current lines for a given RHD simulation\"\"\"\n\n print '\\nComputing the current lines...'\n\n start_time = time.time()\n all_lines = []\n int_diff = []\n excluded_lines = []\n\n for i0, j0 in injec:\n line_values = []\n tc = 0.\n xc, yc = initial_position(x[i0], y[j0])\n ic, jc = initial_indices(i0, j0)\n densc, epsc, vxc, vyc, divc, tracerc = initial_variables(dens[ic, jc],\n eps[ic, jc], vx[ic, jc],\n vy[ic, jc], div[ic,jc],\n tracer[ic, jc])\n ic_aux, jc_aux = ic, jc\n buffer_present_line(xc, yc, ic, jc, densc, epsc,\n vxc, vyc, divc, tracerc, tc, line_values)\n\n ite = 1\n while True:\n tc += tstep\n xc, yc = update_position(xc, yc, vxc, vyc, tstep)\n\n if (xc > lx) or (xc < 0) or (yc > ly) or (yc < 0):\n break\n\n ic, jc = update_indices(xc, yc, xl, yl, xr, yr, ic, jc,\n vxc, vyc, nx, ny)\n\n tstep_test(ic, jc, ic_aux, jc_aux)\n ic_aux, jc_aux = ic, jc\n\n try:\n (densc, epsc, vxc,\n vyc, divc, tracerc, densc2) = interpolate(xc, yc, ic, jc, x, y,\n dens, eps, vx, vy, div,\n tracer, nx, ny, int_method,\n int_test)\n except Exception:\n print 'WARNING: Interpolation failed for line starting at [{}, {}]'.format(i0,j0)\n\n if int_test != 0:\n buffer_diff(densc, densc2, int_diff)\n\n buffer_present_line(xc, yc, ic, jc, densc, epsc,\n vxc, vyc, divc, tracerc, tc, line_values)\n ite += 1\n if ite == itemax:\n print 'WARNING: Line starting at [{}, {}] did not converged. Increase itemax parameter?'.format(i0,j0)\n excluded_lines += [(i0,j0)]\n break\n\n if ite != itemax:\n buffer_all_lines(all_lines, line_values)\n\n if resamp != 0:\n all_lines = resamp_line(all_lines, resamp, a, CGS_units)\n\n if CGS_units == 1:\n all_lines, sf0 = code_units_to_CGS(all_lines, sf0, c, rho0, a)\n\n save_all_lines(output_file, all_lines)\n\n if CGS_units == 1:\n all_lines = save_one_file_per_line(output_file, all_lines, gammaad, c, fB0,\n tr0, sf0, excluded_lines, input_file)\n else:\n print 'WARNING: current lines not saved. CGS unit conversion is off'\n\n if int_test != 0:\n print \"Density difference between the two interpolation methods: \" \\\n \"{:.2f} %\".format(np.average(np.array(int_diff)))\n print \"Done (elapsed time: {:.0f} seconds) \"\\\n .format(time.time() - start_time)\n return all_lines\n", "meta": {"hexsha": "e1fd84feb6d078f583c4f4ff22d379daced1ce53", "size": 13457, "ext": "py", "lang": "Python", "max_stars_repo_path": "compute_lines.py", "max_stars_repo_name": "xparedesfortuny/pylines", "max_stars_repo_head_hexsha": "f61c1d818480cf1d209bc59f442c0df9081cf435", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2015-12-15T15:29:03.000Z", "max_stars_repo_stars_event_max_datetime": "2015-12-15T15:29:03.000Z", "max_issues_repo_path": "compute_lines.py", "max_issues_repo_name": "xparedesfortuny/pylines", "max_issues_repo_head_hexsha": "f61c1d818480cf1d209bc59f442c0df9081cf435", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "compute_lines.py", "max_forks_repo_name": "xparedesfortuny/pylines", "max_forks_repo_head_hexsha": "f61c1d818480cf1d209bc59f442c0df9081cf435", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.2277486911, "max_line_length": 118, "alphanum_fraction": 0.5116296351, "include": true, "reason": "import numpy", "num_tokens": 3907, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5467381372136563, "lm_q2_score": 0.35577489351363034, "lm_q1q2_score": 0.19451570254702918}} {"text": "#! /usr/bin/env python\n# -*- coding: utf8 -*-\n\n''' \n\nCopyright 2018 University of Liège\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License. \n\ninterpolator.py\nInterface interpolator and communicator.\nAuthors : David THOMAS, Marco Lucio CERQUAGLIA, Romain BOMAN\n\n'''\n\n# ----------------------------------------------------------------------\n# Imports\n# ----------------------------------------------------------------------\n\nimport numpy as np\nimport sys\n\nimport ccupydo\nfrom utilities import *\nfrom interfaceData import FlexInterfaceData\nfrom interfaceData import InterfaceMatrix\nfrom linearSolver import LinearSolver\n\nnp.set_printoptions(threshold=sys.maxsize)\n\n# ----------------------------------------------------------------------\n# Interpolator class\n# ----------------------------------------------------------------------\n\nclass InterfaceInterpolator(ccupydo.CInterpolator):\n \"\"\"\n Interpolator of CUPyDO.\n Perform inteporlation of fluid-structure meshes.\n Inherited public members :\n -matching_fillMatrix()\n -TPS_fillMatrixA()\n -TPS_fillMatrixB()\n -RBF_fillMatrixA()\n -RBF_fillMatrixB()\n -PHI_TPS()\n -PHI_RBF()\n -distance()\n \"\"\"\n\n def __init__(self, Manager, FluidSolver, SolidSolver, mpiComm = None, chtTransferMethod=None, heatTransferCoeff=1.0):\n \"\"\"\n Description.\n \"\"\"\n\n mpiPrint('\\n***************************** Initializing FSI interpolator *****************************', mpiComm)\n\n ccupydo.CInterpolator.__init__(self, Manager)\n\n self.manager = Manager\n self.SolidSolver = SolidSolver\n self.FluidSolver = FluidSolver\n\n self.mappingTimer = Timer()\n\n self.nf = self.manager.getNumberOfFluidInterfaceNodes()\n self.ns = self.manager.getNumberOfSolidInterfaceNodes()\n self.nf_loc = self.manager.getNumberOfLocalFluidInterfaceNodes()\n self.ns_loc = self.manager.getNumberOfLocalSolidInterfaceNodes()\n self.nDim = self.manager.getnDim()\n\n self.d = 0\n\n if self.manager.thermal:\n self.chtTransferMethod = chtTransferMethod\n if self.chtTransferMethod not in ['TFFB','FFTB','hFTB','hFFB']:\n mpiPrint('CHT transfer method not specified or not recognized, using default TFFB',mpiComm)\n self.chtTransferMethod = 'TFFB'\n else:\n self.chtTransferMethod = None\n\n if self.chtTransferMethod in ['hFTB','hFFB']:\n self.heatTransferCoeff = heatTransferCoeff\n else:\n self.heatTransferCoeff = None\n\n self.mpiComm = mpiComm\n\n if self.mpiComm != None:\n self.myid = self.mpiComm.Get_rank()\n self.mpiSize = self.mpiComm.Get_size()\n else:\n self.myid = 0\n self.mpiSize = 1\n\n self.solidInterfaceDisplacement = None\n self.fluidInterfaceDisplacement = None\n self.solidInterfaceLoads = None\n self.fluidInterfaceLoads = None\n\n self.solidInterfaceHeatFlux = None\n self.fluidInterfaceHeatFlux = None\n self.solidInterfaceTemperature = None\n self.fluidInterfaceTemperature = None\n self.fluidInterfaceNormalHeatFlux = None\n self.solidInterfaceNormalHeatFlux = None\n self.fluidInterfaceRobinTemperature = None\n self.solidInterfaceRobinTemperature = None\n\n def checkTotalLoad(self):\n \"\"\"\n Des.\n \"\"\"\n\n FX, FY, FZ = self.solidInterfaceLoads.sum()\n\n FFX, FFY, FFZ = self.fluidInterfaceLoads.sum()\n\n mpiPrint(\"Checking f/s interface total force...\", self.mpiComm)\n mpiPrint('Solid side (Fx, Fy, Fz) = ({}, {}, {})'.format(FX, FY, FZ), self.mpiComm)\n mpiPrint('Fluid side (Fx, Fy, Fz) = ({}, {}, {})'.format(FFX, FFY, FFZ), self.mpiComm)\n\n def getDisplacementFromSolidSolver(self):\n \"\"\"\n Des.\n \"\"\"\n\n if self.myid in self.manager.getSolidInterfaceProcessors():\n localSolidInterfaceDisp_X, localSolidInterfaceDisp_Y, localSolidInterfaceDisp_Z = self.SolidSolver.getNodalDisplacements()\n for iVertex in range(self.ns_loc):\n iGlobalVertex = self.manager.getGlobalIndex('solid', self.myid, iVertex)\n self.solidInterfaceDisplacement[iGlobalVertex] = [localSolidInterfaceDisp_X[iVertex], localSolidInterfaceDisp_Y[iVertex], localSolidInterfaceDisp_Z[iVertex]]\n\n self.solidInterfaceDisplacement.assemble()\n\n def getHeatFluxFromSolidSolver(self):\n \"\"\"\n Des.\n \"\"\"\n\n if self.myid in self.manager.getSolidInterfaceProcessors():\n localSolidInterfaceHeatFlux_X, localSolidInterfaceHeatFlux_Y, localSolidInterfaceHeatFlux_Z = self.SolidSolver.getNodalHeatFluxes()\n for iVertex in range(self.ns_loc):\n iGlobalVertex = self.manager.getGlobalIndex('solid', self.myid, iVertex)\n self.solidInterfaceHeatFlux[iGlobalVertex] = [localSolidInterfaceHeatFlux_X[iVertex], localSolidInterfaceHeatFlux_Y[iVertex], localSolidInterfaceHeatFlux_Z[iVertex]]\n\n self.solidInterfaceHeatFlux.assemble()\n\n def getLoadsFromFluidSolver(self):\n \"\"\"\n Des.\n \"\"\"\n\n if self.myid in self.manager.getFluidInterfaceProcessors():\n localFluidInterfaceLoad_X, localFluidInterfaceLoad_Y, localFluidInterfaceLoad_Z = self.FluidSolver.getNodalLoads()\n for iVertex in range(self.nf_loc):\n iGlobalVertex = self.manager.getGlobalIndex('fluid', self.myid, iVertex)\n self.fluidInterfaceLoads[iGlobalVertex] = [localFluidInterfaceLoad_X[iVertex], localFluidInterfaceLoad_Y[iVertex], localFluidInterfaceLoad_Z[iVertex]]\n\n self.fluidInterfaceLoads.assemble()\n\n def getTemperatureFromFluidSolver(self):\n \"\"\"\n Des.\n \"\"\"\n\n if self.myid in self.manager.getFluidInterfaceProcessors():\n localFluidInterfaceTemperature = self.FluidSolver.getNodalTemperatures()\n for iVertex in range(self.nf_loc):\n iGlobalVertex = self.manager.getGlobalIndex('fluid', self.myid, iVertex)\n self.fluidInterfaceTemperature[iGlobalVertex] = [localFluidInterfaceTemperature[iVertex]]\n\n self.fluidInterfaceTemperature.assemble()\n\n def getRobinTemperatureFromFluidSolver(self):\n \"\"\"\n Des.\n \"\"\"\n\n if self.myid in self.manager.getFluidInterfaceProcessors():\n localFluidInterfaceNormalHeatFlux = self.FluidSolver.getNodalNormalHeatFlux()\n localFluidInterfaceTemperature = self.FluidSolver.getNodalTemperatures()\n localFluidInterfaceRobinTemperature = localFluidInterfaceTemperature - (localFluidInterfaceNormalHeatFlux/self.heatTransferCoeff)\n for iVertex in range(self.nf_loc):\n iGlobalVertex = self.manager.getGlobalIndex('fluid', self.myid, iVertex)\n self.fluidInterfaceRobinTemperature[iGlobalVertex] = [localFluidInterfaceRobinTemperature[iVertex]]\n\n self.fluidInterfaceRobinTemperature.assemble()\n\n def getHeatFluxFromFluidSolver(self):\n \"\"\"\n Des.\n \"\"\"\n\n if self.myid in self.manager.getFluidInterfaceProcessors():\n localFluidInterfaceHeatFlux_X, localFluidInterfaceHeatFlux_Y, localFluidInterfaceHeatFlux_Z = self.FluidSolver.getNodalHeatFluxes()\n localFluidInterfaceNormalHeatFlux = self.FluidSolver.getNodalNormalHeatFlux()\n for iVertex in range(self.nf_loc):\n iGlobalVertex = self.manager.getGlobalIndex('fluid', self.myid, iVertex)\n self.fluidInterfaceHeatFlux[iGlobalVertex] = [localFluidInterfaceHeatFlux_X[iVertex], localFluidInterfaceHeatFlux_Y[iVertex], localFluidInterfaceHeatFlux_Z[iVertex]]\n self.fluidInterfaceNormalHeatFlux[iGlobalVertex] = [localFluidInterfaceNormalHeatFlux[iVertex]]\n\n self.fluidInterfaceHeatFlux.assemble()\n self.fluidInterfaceNormalHeatFlux.assemble()\n\n def redistributeDataToFluidSolver(self, fluidInterfaceData):\n \"\"\"\n Description\n \"\"\"\n\n localFluidInterfaceData_array = None\n haloNodesData = {}\n\n if self.mpiComm != None:\n localSize = fluidInterfaceData.getDataArray(0).shape[0]\n fluidInterfaceData_array_recon = []\n for iDim in range(fluidInterfaceData.nDim):\n array_recon = mpiGatherv(fluidInterfaceData.getDataArray(iDim), localSize, self.nf, self.mpiComm, 0)\n fluidInterfaceData_array_recon.append(array_recon)\n haloNodesData = {}\n haloNodesData_bis = {}\n if self.myid == 0:\n for iProc in self.manager.getFluidInterfaceProcessors():\n fluidPhysicalInterfaceNodesDistribution = self.manager.getFluidPhysicalInterfaceNodesDistribution()\n fluidGlobalIndexRange = self.manager.getFluidGlobalIndexRange()\n sendBuff = []\n for iDim in range(fluidInterfaceData.nDim):\n sendBuff_i = np.zeros(fluidPhysicalInterfaceNodesDistribution[iProc])\n sendBuff.append(sendBuff_i)\n globalIndex = fluidGlobalIndexRange[iProc][0]\n sendBuffHalo = {}\n for iVertex in range(fluidPhysicalInterfaceNodesDistribution[iProc]):\n for iDim in range(fluidInterfaceData.nDim):\n sendBuff[iDim][iVertex] = fluidInterfaceData_array_recon[iDim][globalIndex]\n globalIndex += 1\n fluidHaloNodesList = self.manager.getFluidHaloNodesList()\n fluidIndexing = self.manager.getFluidIndexing()\n for key in fluidHaloNodesList[iProc].keys():\n globalIndex = fluidIndexing[key]\n sendBuffHalo[key] = []\n for iDim in range(fluidInterfaceData.nDim):\n sendBuffHalo[key].append(fluidInterfaceData_array_recon[iDim][globalIndex])\n iTagSend = 1\n if iProc == 0: # In the master node use non-blocking and immediately receive them\n for iDim in range(fluidInterfaceData.nDim):\n self.mpiComm.Isend(sendBuff[iDim], dest=iProc, tag = iTagSend)\n iTagSend += 1\n sendBuffHalo_key = np.array(list(sendBuffHalo.keys()))\n sendBuffHalo_values = np.empty((sendBuffHalo_key.size, 3),dtype=float)\n for ii in range(sendBuffHalo_key.size):\n sendBuffHalo_values[ii] = np.array(sendBuffHalo[sendBuffHalo_key[ii]])\n self.mpiComm.Isend(np.array(sendBuffHalo_key.size), dest=iProc, tag=101)\n self.mpiComm.Isend(sendBuffHalo_key, dest=iProc, tag=102)\n self.mpiComm.Isend(sendBuffHalo_values, dest=iProc, tag=103)\n localFluidInterfaceData_array = []\n iTagRec = 1\n for iDim in range(fluidInterfaceData.nDim):\n local_array = np.zeros(self.nf_loc)\n self.mpiComm.Recv(local_array, source=0, tag=iTagRec)\n localFluidInterfaceData_array.append(local_array)\n iTagRec += 1\n nHaloNodesRcv = np.empty(1, dtype=int)\n req = self.mpiComm.Irecv(nHaloNodesRcv, source=0, tag=101)\n req.Wait()\n rcvBuffHalo_keyBuff = np.empty(nHaloNodesRcv[0], dtype=int)\n req = self.mpiComm.Irecv(rcvBuffHalo_keyBuff, source=0, tag=102)\n req.Wait()\n rcvBuffHalo_values = np.empty((nHaloNodesRcv[0],3), dtype=float)\n req = self.mpiComm.Irecv(rcvBuffHalo_values, source=0, tag=103)\n req.Wait()\n for ii in range(len(rcvBuffHalo_keyBuff)):\n haloNodesData_bis[rcvBuffHalo_keyBuff[ii]] = list(rcvBuffHalo_values[ii])\n haloNodesData = haloNodesData_bis\n else: # In other processors it's ok to send the buffers with blocking comms\n for iDim in range(fluidInterfaceData.nDim):\n self.mpiComm.Send(sendBuff[iDim], dest=iProc, tag = iTagSend)\n iTagSend += 1\n #self.mpiComm.send(sendBuffHalo, dest = iProc, tag=iTagSend)\n sendBuffHalo_key = np.array(list(sendBuffHalo.keys()))\n sendBuffHalo_values = np.empty((sendBuffHalo_key.size, 3),dtype=float)\n for ii in range(sendBuffHalo_key.size):\n sendBuffHalo_values[ii] = np.array(sendBuffHalo[sendBuffHalo_key[ii]])\n self.mpiComm.Send(np.array(sendBuffHalo_key.size), dest=iProc, tag=101)\n self.mpiComm.Send(sendBuffHalo_key, dest=iProc, tag=102)\n self.mpiComm.Send(sendBuffHalo_values, dest=iProc, tag=103)\n elif self.myid in self.manager.getFluidInterfaceProcessors():\n localFluidInterfaceData_array = []\n iTagRec = 1\n for iDim in range(fluidInterfaceData.nDim):\n local_array = np.zeros(self.nf_loc)\n self.mpiComm.Recv(local_array, source=0, tag=iTagRec)\n localFluidInterfaceData_array.append(local_array)\n iTagRec += 1\n #haloNodesData = self.mpiComm.recv(source=0, tag=iTagRec)\n nHaloNodesRcv = np.empty(1, dtype=int)\n req = self.mpiComm.Irecv(nHaloNodesRcv, source=0, tag=101)\n req.Wait()\n rcvBuffHalo_keyBuff = np.empty(nHaloNodesRcv[0], dtype=int)\n self.mpiComm.Recv(rcvBuffHalo_keyBuff, source=0, tag=102)\n rcvBuffHalo_values = np.empty((nHaloNodesRcv[0],3), dtype=float)\n self.mpiComm.Recv(rcvBuffHalo_values, source=0, tag=103)\n for ii in range(len(rcvBuffHalo_keyBuff)):\n haloNodesData_bis[rcvBuffHalo_keyBuff[ii]] = list(rcvBuffHalo_values[ii])\n haloNodesData = haloNodesData_bis\n\n\n return (localFluidInterfaceData_array, haloNodesData)\n\n def redistributeDataToSolidSolver(self, solidInterfaceData):\n \"\"\"\n Des.\n \"\"\"\n\n localSolidInterfaceData_array = None\n haloNodesData = {}\n haloNodesData_bis = {}\n\n if self.mpiComm != None:\n localSize = solidInterfaceData.getDataArray(0).shape[0]\n solidInterfaceData_array_recon = []\n for iDim in range(solidInterfaceData.nDim):\n array_recon = mpiGatherv(solidInterfaceData.getDataArray(iDim), localSize, self.ns+self.d, self.mpiComm, 0)\n solidInterfaceData_array_recon.append(array_recon)\n haloNodesData = {}\n if self.myid == 0:\n for iProc in self.manager.getSolidInterfaceProcessors():\n solidPhysicalInterfaceNodesDistribution = self.manager.getSolidPhysicalInterfaceNodesDistribution()\n solidGlobalIndexRange = self.manager.getSolidGlobalIndexRange()\n sendBuff = []\n for iDim in range(solidInterfaceData.nDim):\n sendBuff_i = np.zeros(solidPhysicalInterfaceNodesDistribution[iProc])\n sendBuff.append(sendBuff_i)\n globalIndex = solidGlobalIndexRange[iProc][0]\n sendBuffHalo = {}\n for iVertex in range(solidPhysicalInterfaceNodesDistribution[iProc]):\n for iDim in range(solidInterfaceData.nDim):\n sendBuff[iDim][iVertex] = solidInterfaceData_array_recon[iDim][globalIndex]\n globalIndex += 1\n solidHaloNodesList = self.manager.getSolidHaloNodesList()\n solidIndexing = self.manager.getSolidIndexing()\n for key in solidHaloNodesList[iProc].keys():\n globalIndex = solidIndexing[key]\n sendBuffHalo[key] = []\n for iDim in range(solidInterfaceData.nDim):\n sendBuffHalo[key].append(solidInterfaceData_array_recon[iDim][globalIndex])\n iTagSend = 1\n for iDim in range(solidInterfaceData.nDim):\n self.mpiComm.Isend(sendBuff[iDim], dest=iProc, tag = iTagSend)\n iTagSend += 1\n #self.mpiComm.send(sendBuffHalo, dest = iProc, tag=iTagSend)\n sendBuffHalo_key = np.array(sendBuffHalo.keys())\n sendBuffHalo_values = np.empty((sendBuffHalo_key.size, 3),dtype=float)\n for ii in range(sendBuffHalo_key.size):\n sendBuffHalo_values[ii] = np.array(sendBuffHalo[sendBuffHalo_key[ii]])\n self.mpiComm.Isend(np.array(sendBuffHalo_key.size), dest=iProc, tag=101)\n self.mpiComm.Isend(sendBuffHalo_key, dest=iProc, tag=102)\n self.mpiComm.Isend(sendBuffHalo_values, dest=iProc, tag=103)\n if self.myid in self.manager.getSolidInterfaceProcessors():\n localSolidInterfaceData_array = []\n iTagRec = 1\n for iDim in range(solidInterfaceData.nDim):\n local_array = np.zeros(self.ns_loc)\n req = self.mpiComm.Irecv(local_array, source=0, tag = iTagRec)\n req.Wait()\n localSolidInterfaceData_array.append(local_array)\n iTagRec += 1\n #haloNodesData = self.mpiComm.recv(source=0, tag=iTagRec)\n nHaloNodesRcv = np.empty(1, dtype=int)\n req = self.mpiComm.Irecv(nHaloNodesRcv, source=0, tag=101)\n req.Wait()\n rcvBuffHalo_keyBuff = np.empty(nHaloNodesRcv[0], dtype=int)\n req = self.mpiComm.Irecv(rcvBuffHalo_keyBuff, source=0, tag=102)\n req.Wait()\n rcvBuffHalo_values = np.empty((nHaloNodesRcv[0],3), dtype=float)\n req = self.mpiComm.Irecv(rcvBuffHalo_values, source=0, tag=103)\n req.Wait()\n for ii in range(len(rcvBuffHalo_keyBuff)):\n haloNodesData_bis[rcvBuffHalo_keyBuff[ii]] = list(rcvBuffHalo_values[ii])\n haloNodesData = haloNodesData_bis\n\n return (localSolidInterfaceData_array, haloNodesData)\n\n def setLoadsToSolidSolver(self, time):\n \"\"\"\n des.\n \"\"\"\n\n FFX, FFY, FFZ = self.fluidInterfaceLoads.sum()\n\n\n FX = 0.\n FY = 0.\n FZ = 0.\n\n FXT = 0.\n FYT = 0.\n FZT = 0.\n\n if self.mpiComm != None:\n (localSolidLoads_array, haloNodesSolidLoads) = self.redistributeDataToSolidSolver(self.solidInterfaceLoads)\n if self.myid in self.manager.getSolidInterfaceProcessors():\n self.SolidSolver.applyNodalLoads(localSolidLoads_array[0], localSolidLoads_array[1], localSolidLoads_array[2], time)\n FX = localSolidLoads_array[0].sum()\n FY = localSolidLoads_array[1].sum()\n FZ = localSolidLoads_array[2].sum()\n FXT = mpiAllReduce(self.mpiComm, FX)\n FYT = mpiAllReduce(self.mpiComm, FY)\n FZT = mpiAllReduce(self.mpiComm, FZ)\n else:\n self.SolidSolver.applyNodalLoads(self.solidInterfaceLoads.getDataArray(0), self.solidInterfaceLoads.getDataArray(1), self.solidInterfaceLoads.getDataArray(2), time)\n FXT, FYT, FZT = self.solidInterfaceLoads.sum()\n\n mpiPrint(\"Checking f/s interface total force...\", self.mpiComm)\n mpiPrint('Solid side (Fx, Fy, Fz) = ({}, {}, {})'.format(FXT, FYT, FZT), self.mpiComm)\n mpiPrint('Fluid side (Fx, Fy, Fz) = ({}, {}, {})'.format(FFX, FFY, FFZ), self.mpiComm)\n\n def setDisplacementToFluidSolver(self, time):\n \"\"\"\n Des.\n \"\"\"\n\n self.checkConservation()\n\n if self.mpiComm != None:\n (localFluidInterfaceDisplacement, haloNodesDisplacements) = self.redistributeDataToFluidSolver(self.fluidInterfaceDisplacement)\n# mpiBarrier(self.mpiComm)\n if self.myid in self.manager.getFluidInterfaceProcessors():\n self.FluidSolver.applyNodalDisplacements(localFluidInterfaceDisplacement[0], localFluidInterfaceDisplacement[1], localFluidInterfaceDisplacement[2], localFluidInterfaceDisplacement[0], localFluidInterfaceDisplacement[1], localFluidInterfaceDisplacement[2], haloNodesDisplacements, time)\n else:\n self.FluidSolver.applyNodalDisplacements(self.fluidInterfaceDisplacement.getDataArray(0), self.fluidInterfaceDisplacement.getDataArray(1), self.fluidInterfaceDisplacement.getDataArray(2), self.fluidInterfaceDisplacement.getDataArray(0), self.fluidInterfaceDisplacement.getDataArray(1), self.fluidInterfaceDisplacement.getDataArray(2), {}, time)\n\n def setHeatFluxToFluidSolver(self, time):\n \"\"\"\n Description.\n \"\"\"\n\n if self.mpiComm != None:\n (localFluidInterfaceHeatFlux, haloNodesHeatFlux) = self.redistributeDataToFluidSolver(self.fluidInterfaceHeatFlux)\n if self.myid in self.manager.getFluidInterfaceProcessors():\n self.FluidSolver.applyNodalHeatFluxes(localFluidInterfaceHeatFlux[0], localFluidInterfaceHeatFlux[1], localFluidInterfaceHeatFlux[2], time)\n else:\n self.FluidSolver.applyNodalHeatFluxes(self.fluidInterfaceHeatFlux.getDataArray(0), self.fluidInterfaceHeatFlux.getDataArray(1), self.fluidInterfaceHeatFlux.getDataArray(2), time)\n\n def setTemperatureToFluidSolver(self, time):\n \"\"\"\n Des.\n \"\"\"\n\n if self.mpiComm != None:\n (localFluidInterfaceTemperature, haloNodesTemperature) = self.redistributeDataToFluidSolver(self.fluidInterfaceTemperature)\n if self.myid in self.manager.getFluidInterfaceProcessors():\n self.FluidSolver.applyNodalTemperatures(localFluidInterfaceTemperature[0], time)\n else:\n self.FluidSolver.applyNodalTemperatures(self.fluidInterfaceTemperature.getDataArray(0), time)\n\n def setTemperatureToSolidSolver(self, time):\n \"\"\"\n Description\n \"\"\"\n\n if self.mpiComm != None:\n (localSolidInterfaceTemperature, haloNodesTemperature) = self.redistributeDataToSolidSolver(self.solidInterfaceTemperature)\n if self.myid in self.manager.getSolidInterfaceProcessors():\n self.SolidSolver.applyNodalTemperatures(localSolidInterfaceTemperature[0], time)\n else:\n self.SolidSolver.applyNodalTemperatures(self.solidInterfaceTemperature.getDataArray(0), time)\n\n def setRobinHeatFluxToSolidSolver(self, time):\n \"\"\"\n Def\n \"\"\"\n\n if self.mpiComm != None:\n (localSolidInterfaceRobinTemperature, haloNodesRobinTemperature) = self.redistributeDataToSolidSolver(self.solidInterfaceRobinTemperature)\n if self.myid in self.manager.getSolidInterfaceProcessors():\n localSolidInterfaceTemperature = self.SolidSolver.getNodalTemperatures()\n localSolidInterfaceRobinHeatFlux = self.heatTransferCoeff*(localSolidInterfaceTemperature-localSolidInterfaceRobinTemperature[0])\n self.SolidSolver.applyNodalNormalHeatFluxes(localSolidInterfaceRobinHeatFlux, time)\n else:\n localSolidInterfaceTemperature = self.SolidSolver.getNodalTemperatures()\n localSolidInterfaceRobinHeatFlux = self.heatTransferCoeff*(localSolidInterfaceTemperature-self.solidInterfaceRobinTemperature.getDataArray(0), time)\n self.SolidSolver.applyNodalNormalHeatFluxes(localSolidInterfaceRobinHeatFlux, time)\n\n def setHeatFluxToSolidSolver(self, time):\n \"\"\"\n Des.\n \"\"\"\n\n if self.mpiComm != None:\n (localSolidInterfaceNormalHeatFlux, haloNodesNormalHeatFlux) = self.redistributeDataToSolidSolver(self.solidInterfaceNormalHeatFlux)\n if self.myid in self.manager.getSolidInterfaceProcessors():\n self.SolidSolver.applyNodalNormalHeatFluxes(localSolidInterfaceNormalHeatFlux[0], time)\n else:\n self.SolidSolver.applyNodalNormalHeatFluxes(self.solidInterfaceNormalHeatFlux.getDataArray(0), time)\n\n def interpolateFluidLoadsOnSolidMesh(self):\n \"\"\"\n Description\n \"\"\"\n\n self.interpolateFluidToSolid(self.fluidInterfaceLoads, self.solidInterfaceLoads)\n\n def interpolateSolidDisplacementOnFluidMesh(self):\n \"\"\"\n Description.\n \"\"\"\n\n self.interpolateSolidToFluid(self.solidInterfaceDisplacement, self.fluidInterfaceDisplacement)\n\n def interpolateSolidHeatFluxOnFluidMesh(self):\n \"\"\"\n Description.\n \"\"\"\n\n self.interpolateSolidToFluid(self.solidInterfaceHeatFlux, self.fluidInterfaceHeatFlux)\n\n\n def interpolateSolidTemperatureOnFluidMesh(self):\n \"\"\"\n Description\n \"\"\"\n\n self.interpolateSolidToFluid(self.solidInterfaceTemperature, self.fluidInterfaceTemperature)\n\n def interpolateFluidHeatFluxOnSolidMesh(self):\n \"\"\"\n Description.\n \"\"\"\n\n self.interpolateFluidToSolid(self.fluidInterfaceHeatFlux, self.solidInterfaceHeatFlux)\n self.interpolateFluidToSolid(self.fluidInterfaceNormalHeatFlux, self.solidInterfaceNormalHeatFlux)\n\n def interpolateFluidTemperatureOnSolidMesh(self):\n \"\"\"\n Description.\n \"\"\"\n\n self.interpolateFluidToSolid(self.fluidInterfaceTemperature, self.solidInterfaceTemperature)\n\n def interpolateFluidRobinTemperatureOnSolidMesh(self):\n \"\"\"\n Des.\n \"\"\"\n\n self.interpolateFluidToSolid(self.fluidInterfaceRobinTemperature, self.solidInterfaceRobinTemperature)\n\n def getNs(self):\n \"\"\"\n Des.\n \"\"\"\n\n return self.ns\n\n def getNf(self):\n \"\"\"\n Des.\n \"\"\"\n\n return self.nf\n\n def getd(self):\n \"\"\"\n Des.\n \"\"\"\n\n return self.d\n\nclass MatchingMeshesInterpolator(InterfaceInterpolator):\n \"\"\"\n Description.\n \"\"\"\n\n def __init__(self, Manager, FluidSolver, SolidSolver, mpiComm = None, chtTransferMethod=None, heatTransferCoeff=1.0):\n \"\"\"\n Description\n \"\"\"\n\n InterfaceInterpolator.__init__(self, Manager, FluidSolver, SolidSolver, mpiComm, chtTransferMethod, heatTransferCoeff)\n\n mpiPrint('\\nSetting matching meshes interpolator...', mpiComm)\n\n if self.nf != self.ns:\n raise Exception(\"Fluid and solid interface must have the same number of nodes for matching meshes ! \")\n ccupydo.CInterpolator.matching_initSearch(self)\n\n self.generateInterfaceData()\n\n self.generateMapping()\n\n def checkConservation(self):\n \"\"\"\n Des.\n \"\"\"\n\n WSX, WSY, WSZ = self.solidInterfaceLoads.dot(self.solidInterfaceDisplacement)\n\n WFX, WFY, WFZ = self.fluidInterfaceLoads.dot(self.fluidInterfaceDisplacement)\n\n mpiPrint(\"Checking f/s interface conservation...\", self.mpiComm)\n mpiPrint('Solid side (Wx, Wy, Wz) = ({}, {}, {})'.format(WSX, WSY, WSZ), self.mpiComm)\n mpiPrint('Fluid side (Wx, Wy, Wz) = ({}, {}, {})'.format(WFX, WFY, WFZ), self.mpiComm)\n\n def generateInterfaceData(self):\n \"\"\"\n Des.\n \"\"\"\n\n if self.manager.mechanical:\n self.solidInterfaceDisplacement = FlexInterfaceData(self.ns, 3, self.mpiComm)\n self.fluidInterfaceDisplacement = FlexInterfaceData(self.nf, 3, self.mpiComm)\n self.solidInterfaceLoads = FlexInterfaceData(self.ns, 3, self.mpiComm)\n self.fluidInterfaceLoads = FlexInterfaceData(self.nf, 3, self.mpiComm)\n\n if self.manager.thermal :\n if self.chtTransferMethod == 'TFFB':\n self.solidInterfaceTemperature = FlexInterfaceData(self.ns, 1, self.mpiComm)\n self.fluidInterfaceTemperature = FlexInterfaceData(self.nf, 1, self.mpiComm)\n self.solidInterfaceHeatFlux = FlexInterfaceData(self.ns, 3, self.mpiComm)\n self.fluidInterfaceHeatFlux = FlexInterfaceData(self.nf, 3, self.mpiComm)\n elif self.chtTransferMethod == 'FFTB':\n self.solidInterfaceTemperature = FlexInterfaceData(self.ns, 1, self.mpiComm)\n self.fluidInterfaceTemperature = FlexInterfaceData(self.nf, 1, self.mpiComm)\n self.solidInterfaceHeatFlux = FlexInterfaceData(self.ns, 3, self.mpiComm)\n self.fluidInterfaceHeatFlux = FlexInterfaceData(self.nf, 3, self.mpiComm)\n self.fluidInterfaceNormalHeatFlux = FlexInterfaceData(self.nf, 1, self.mpiComm)\n self.solidInterfaceNormalHeatFlux = FlexInterfaceData(self.ns, 1, self.mpiComm)\n elif self.chtTransferMethod == 'hFTB':\n self.fluidInterfaceRobinTemperature = FlexInterfaceData(self.nf, 1, self.mpiComm)\n self.solidInterfaceRobinTemperature = FlexInterfaceData(self.ns, 1, self.mpiComm)\n self.solidInterfaceTemperature = FlexInterfaceData(self.ns, 1, self.mpiComm)\n self.fluidInterfaceTemperature = FlexInterfaceData(self.nf, 1, self.mpiComm)\n elif self.chtTransferMethod == 'hFFB':\n self.fluidInterfaceRobinTemperature = FlexInterfaceData(self.nf, 1, self.mpiComm)\n self.solidInterfaceRobinTemperature = FlexInterfaceData(self.ns, 1, self.mpiComm)\n self.solidInterfaceHeatFlux = FlexInterfaceData(self.ns, 3, self.mpiComm)\n self.fluidInterfaceHeatFlux = FlexInterfaceData(self.nf, 3, self.mpiComm)\n\n self.H = InterfaceMatrix((self.nf,self.ns), self.mpiComm)\n self.H_T = InterfaceMatrix((self.ns,self.nf), self.mpiComm)\n self.H.createSparse(1,1)\n self.H_T.createSparse(1,1)\n\n def generateMapping(self):\n \"\"\"\n Des.\n \"\"\"\n\n solidInterfaceProcessors = self.manager.getSolidInterfaceProcessors()\n fluidInterfaceProcessors = self.manager.getFluidInterfaceProcessors()\n solidPhysicalInterfaceNodesDistribution = self.manager.getSolidPhysicalInterfaceNodesDistribution()\n\n mpiPrint('\\nBuilding interpolation matrix...', self.mpiComm)\n mpiPrint('\\nBuilding matrix H of size {} X {}...'.format(self.nf, self.ns), self.mpiComm)\n self.mappingTimer.start()\n\n if self.mpiComm != None:\n for iProc in solidInterfaceProcessors:\n if self.myid == iProc:\n localSolidInterface_array_X, localSolidInterface_array_Y, localSolidInterface_array_Z = self.SolidSolver.getNodalInitialPositions()\n for jProc in fluidInterfaceProcessors:\n self.mpiComm.Isend(localSolidInterface_array_X, dest=jProc, tag=1)\n self.mpiComm.Isend(localSolidInterface_array_Y, dest=jProc, tag=2)\n self.mpiComm.Isend(localSolidInterface_array_Z, dest=jProc, tag=3)\n if self.myid in fluidInterfaceProcessors:\n sizeOfBuff = solidPhysicalInterfaceNodesDistribution[iProc]\n solidInterfaceBuffRcv_X = np.zeros(sizeOfBuff)\n solidInterfaceBuffRcv_Y = np.zeros(sizeOfBuff)\n solidInterfaceBuffRcv_Z = np.zeros(sizeOfBuff)\n req = self.mpiComm.Irecv(solidInterfaceBuffRcv_X, iProc, tag=1)\n req.Wait()\n req = self.mpiComm.Irecv(solidInterfaceBuffRcv_Y, iProc, tag=2)\n req.Wait()\n req = self.mpiComm.Irecv(solidInterfaceBuffRcv_Z, iProc, tag=3)\n req.Wait()\n self.mappingSearch(solidInterfaceBuffRcv_X, solidInterfaceBuffRcv_Y, solidInterfaceBuffRcv_Z, iProc)\n if self.myid in fluidInterfaceProcessors:\n self.fillMatrix()\n else:\n localSolidInterface_array_X, localSolidInterface_array_Y, localSolidInterface_array_Z = self.SolidSolver.getNodalInitialPositions()\n self.mappingSearch(localSolidInterface_array_X, localSolidInterface_array_Y, localSolidInterface_array_Z, 0)\n self.fillMatrix()\n\n mpiBarrier(self.mpiComm)\n mpiPrint(\"\\nAssembling H & H_T...\", self.mpiComm)\n start = tm.time()\n self.H.assemble()\n mpiBarrier(self.mpiComm)\n self.H_T.assemble()\n mpiBarrier(self.mpiComm)\n stop = tm.time()\n mpiPrint('Assembly performed in {} s'.format(stop-start), self.mpiComm)\n mpiPrint('Matrix H is built.', self.mpiComm)\n\n self.mappingTimer.stop()\n self.mappingTimer.cumul()\n\n def mappingSearch(self, solidInterfaceBuffRcv_X, solidInterfaceBuffRcv_Y, solidInterfaceBuffRcv_Z, iProc):\n \"\"\"\n Des.\n \"\"\"\n\n localFluidInterface_array_X_init, localFluidInterface_array_Y_init, localFluidInterface_array_Z_init = self.FluidSolver.getNodalInitialPositions()\n\n print('Matching mapping search on rank {}...'.format(self.myid))\n start = tm.time()\n ccupydo.CInterpolator.matching_search(self, localFluidInterface_array_X_init, localFluidInterface_array_Y_init, localFluidInterface_array_Z_init,\n solidInterfaceBuffRcv_X, solidInterfaceBuffRcv_Y, solidInterfaceBuffRcv_Z, iProc)\n stop = tm.time()\n print('Search on rank {} in {} s'.format(self.myid,stop-start))\n\n def fillMatrix(self):\n \"\"\"\n Des.\n \"\"\"\n\n print('Building H on rank {}...'.format(self.myid))\n start = tm.time()\n ccupydo.CInterpolator.matching_fillMatrix(self, self.H, self.H_T)\n stop = tm.time()\n print('Built H on rank {} in {} s'.format(self.myid,stop-start))\n\n def interpolateFluidToSolid(self, fluidInterfaceData, solidInterfaceData):\n \"\"\"\n des.\n \"\"\"\n\n self.H_T.mult(fluidInterfaceData, solidInterfaceData)\n\n def interpolateSolidToFluid(self, solidInterfaceData, fluidInterfaceData):\n \"\"\"\n Des.\n \"\"\"\n\n self.H.mult(solidInterfaceData, fluidInterfaceData)\n\nclass ConservativeInterpolator(InterfaceInterpolator):\n \"\"\"\n Description.\n \"\"\"\n\n def __init__(self, Manager, FluidSolver, SolidSolver, mpiComm = None, chtTransferMethod=None, heatTransferCoeff=1.0):\n \"\"\"\n Des.\n \"\"\"\n\n InterfaceInterpolator.__init__(self, Manager, FluidSolver, SolidSolver, mpiComm, chtTransferMethod, heatTransferCoeff)\n\n mpiPrint('\\nSetting non-matching conservative interpolator...', mpiComm)\n\n self.d = self.nDim+1\n self.SolverA = None\n self.SolverA_T = None\n\n def getLinearSolvers(self):\n \"\"\"\n Des.\n \"\"\"\n\n return [self.SolverA, self.SolverA_T]\n\n def checkConservation(self):\n \"\"\"\n Des.\n \"\"\"\n\n WSX, WSY, WSZ = self.solidInterfaceLoads.dot(self.solidInterfaceDisplacement)\n\n WFX, WFY, WFZ = self.fluidInterfaceLoads.dot(self.fluidInterfaceDisplacement)\n\n mpiPrint(\"Checking f/s interface conservation...\", self.mpiComm)\n mpiPrint('Solid side (Wx, Wy, Wz) = ({}, {}, {})'.format(WSX, WSY, WSZ), self.mpiComm)\n mpiPrint('Fluid side (Wx, Wy, Wz) = ({}, {}, {})'.format(WFX, WFY, WFZ), self.mpiComm)\n\n def generateInterfaceData(self):\n \"\"\"\n Description.\n \"\"\"\n\n if self.manager.mechanical:\n self.solidInterfaceDisplacement = FlexInterfaceData(self.ns + self.d, 3, self.mpiComm)\n self.fluidInterfaceDisplacement = FlexInterfaceData(self.nf, 3, self.mpiComm)\n self.solidInterfaceLoads = FlexInterfaceData(self.ns + self.d, 3, self.mpiComm)\n self.fluidInterfaceLoads = FlexInterfaceData(self.nf, 3, self.mpiComm)\n\n if self.manager.thermal :\n if self.chtTransferMethod == 'TFFB':\n self.solidInterfaceTemperature = FlexInterfaceData(self.ns + self.d, 1, self.mpiComm)\n self.fluidInterfaceTemperature = FlexInterfaceData(self.nf, 1, self.mpiComm)\n self.solidInterfaceHeatFlux = FlexInterfaceData(self.ns + self.d, 3, self.mpiComm)\n self.fluidInterfaceHeatFlux = FlexInterfaceData(self.nf, 3, self.mpiComm)\n elif self.chtTransferMethod == 'FFTB':\n self.solidInterfaceTemperature = FlexInterfaceData(self.ns + self.d, 1, self.mpiComm)\n self.fluidInterfaceTemperature = FlexInterfaceData(self.nf, 1, self.mpiComm)\n self.solidInterfaceHeatFlux = FlexInterfaceData(self.ns + self.d, 3, self.mpiComm)\n self.fluidInterfaceHeatFlux = FlexInterfaceData(self.nf, 3, self.mpiComm)\n self.fluidInterfaceNormalHeatFlux = FlexInterfaceData(self.nf, 1, self.mpiComm)\n self.solidInterfaceNormalHeatFlux = FlexInterfaceData(self.ns, 1, self.mpiComm)\n elif self.chtTransferMethod == 'hFTB':\n self.fluidInterfaceRobinTemperature = FlexInterfaceData(self.nf, 1, self.mpiComm)\n self.solidInterfaceRobinTemperature = FlexInterfaceData(self.ns, 1, self.mpiComm)\n self.solidInterfaceTemperature = FlexInterfaceData(self.ns + self.d, 1, self.mpiComm)\n self.fluidInterfaceTemperature = FlexInterfaceData(self.nf, 1, self.mpiComm)\n elif self.chtTransferMethod == 'hFFB':\n self.fluidInterfaceRobinTemperature = FlexInterfaceData(self.nf, 1, self.mpiComm)\n self.solidInterfaceRobinTemperature = FlexInterfaceData(self.ns, 1, self.mpiComm)\n self.solidInterfaceHeatFlux = FlexInterfaceData(self.ns + self.d, 3, self.mpiComm)\n self.fluidInterfaceHeatFlux = FlexInterfaceData(self.nf, 3, self.mpiComm)\n\n self.A = InterfaceMatrix((self.ns+self.d,self.ns+self.d), self.mpiComm)\n self.A_T = InterfaceMatrix((self.ns+self.d,self.ns+self.d), self.mpiComm)\n self.B = InterfaceMatrix((self.nf,self.ns+self.d), self.mpiComm)\n self.B_T = InterfaceMatrix((self.ns+self.d,self.nf), self.mpiComm)\n\n def generateMapping(self):\n \"\"\"\n Des.\n \"\"\"\n\n solidInterfaceProcessors = self.manager.getSolidInterfaceProcessors()\n fluidInterfaceProcessors = self.manager.getFluidInterfaceProcessors()\n solidPhysicalInterfaceNodesDistribution = self.manager.getSolidPhysicalInterfaceNodesDistribution()\n\n mpiPrint('\\nBuilding interpolation matrices...', self.mpiComm)\n\n mpiPrint('\\nBuilding matrix A of size {} X {}...'.format(self.ns, self.ns), self.mpiComm)\n # Fill the matrix A\n if self.mpiComm != None:\n for iProc in solidInterfaceProcessors:\n if self.myid == iProc:\n localSolidInterface_array_X, localSolidInterface_array_Y, localSolidInterface_array_Z = self.SolidSolver.getNodalInitialPositions()\n for jProc in solidInterfaceProcessors:\n self.mpiComm.Isend(localSolidInterface_array_X, dest=jProc, tag=1)\n self.mpiComm.Isend(localSolidInterface_array_Y, dest=jProc, tag=2)\n self.mpiComm.Isend(localSolidInterface_array_Z, dest=jProc, tag=3)\n if self.myid in solidInterfaceProcessors:\n sizeOfBuff = solidPhysicalInterfaceNodesDistribution[iProc]\n solidInterfaceBuffRcv_X = np.zeros(sizeOfBuff)\n solidInterfaceBuffRcv_Y = np.zeros(sizeOfBuff)\n solidInterfaceBuffRcv_Z = np.zeros(sizeOfBuff)\n req = self.mpiComm.Irecv(solidInterfaceBuffRcv_X, iProc, tag=1)\n req.Wait()\n req = self.mpiComm.Irecv(solidInterfaceBuffRcv_Y, iProc, tag=2)\n req.Wait()\n req = self.mpiComm.Irecv(solidInterfaceBuffRcv_Z, iProc, tag=3)\n req.Wait()\n self.fillMatrixA(solidInterfaceBuffRcv_X, solidInterfaceBuffRcv_Y, solidInterfaceBuffRcv_Z, iProc)\n else:\n localSolidInterface_array_X, localSolidInterface_array_Y, localSolidInterface_array_Z = self.SolidSolver.getNodalInitialPositions()\n self.fillMatrixA(localSolidInterface_array_X, localSolidInterface_array_Y, localSolidInterface_array_Z, 0)\n\n mpiBarrier(self.mpiComm)\n mpiPrint(\"\\nAssembling A & A_T...\", self.mpiComm)\n start = tm.time()\n self.A.assemble()\n mpiBarrier(self.mpiComm)\n self.A_T.assemble()\n mpiBarrier(self.mpiComm)\n stop = tm.time()\n mpiPrint('Assembly performed in {} s'.format(stop-start), self.mpiComm)\n mpiPrint('Matrix A is built.', self.mpiComm)\n\n mpiPrint('\\nBuilding matrix B of size {} X {}...'.format(self.nf, self.ns), self.mpiComm)\n # Fill the matrix B\n if self.mpiComm != None:\n for iProc in solidInterfaceProcessors:\n if self.myid == iProc:\n for jProc in fluidInterfaceProcessors:\n self.mpiComm.Isend(localSolidInterface_array_X, dest=jProc, tag=1)\n self.mpiComm.Isend(localSolidInterface_array_Y, dest=jProc, tag=2)\n self.mpiComm.Isend(localSolidInterface_array_Z, dest=jProc, tag=3)\n if self.myid in fluidInterfaceProcessors:\n sizeOfBuff = solidPhysicalInterfaceNodesDistribution[iProc]\n solidInterfaceBuffRcv_X = np.zeros(sizeOfBuff)\n solidInterfaceBuffRcv_Y = np.zeros(sizeOfBuff)\n solidInterfaceBuffRcv_Z = np.zeros(sizeOfBuff)\n req = self.mpiComm.Irecv(solidInterfaceBuffRcv_X, iProc, tag=1)\n req.Wait()\n req = self.mpiComm.Irecv(solidInterfaceBuffRcv_Y, iProc, tag=2)\n req.Wait()\n req = self.mpiComm.Irecv(solidInterfaceBuffRcv_Z, iProc, tag=3)\n req.Wait()\n self.fillMatrixB(solidInterfaceBuffRcv_X, solidInterfaceBuffRcv_Y, solidInterfaceBuffRcv_Z, iProc)\n else:\n self.fillMatrixB(localSolidInterface_array_X, localSolidInterface_array_Y, localSolidInterface_array_Z, 0)\n\n mpiBarrier(self.mpiComm)\n mpiPrint(\"\\nAssembling B & B_T...\", self.mpiComm)\n start = tm.time()\n self.B.assemble()\n mpiBarrier(self.mpiComm)\n self.B_T.assemble()\n mpiBarrier(self.mpiComm)\n stop = tm.time()\n mpiPrint('Assembly performed in {} s'.format(stop-start), self.mpiComm)\n mpiPrint('Matrix B is built.', self.mpiComm)\n\n self.SolverA = LinearSolver(self.A, self.mpiComm)\n self.SolverA_T = LinearSolver(self.A_T, self.mpiComm)\n\n def interpolateFluidToSolid(self, fluidInterfaceData, solidInterfaceData):\n \"\"\"\n des.\n \"\"\"\n\n dim = fluidInterfaceData.getDim()\n gamma_array = FlexInterfaceData(self.ns + self.d, dim, self.mpiComm)\n\n self.B_T.mult(fluidInterfaceData, gamma_array)\n self.SolverA_T.solve(gamma_array, solidInterfaceData)\n\n def interpolateSolidToFluid(self, solidInterfaceData, fluidInterfaceData):\n \"\"\"\n Des.\n \"\"\"\n\n dim = solidInterfaceData.getDim()\n gamma_array = FlexInterfaceData(self.ns + self.d, dim, self.mpiComm)\n\n self.SolverA.solve(solidInterfaceData, gamma_array)\n self.B.mult(gamma_array, fluidInterfaceData)\n\n\nclass ConsistentInterpolator(InterfaceInterpolator):\n \"\"\"\n Description.\n \"\"\"\n\n def __init__(self, Manager, FluidSolver, SolidSolver, mpiComm = None, chtTransferMethod=None, heatTransferCoeff=1.0):\n \"\"\"\n Des.\n \"\"\"\n\n InterfaceInterpolator.__init__(self, Manager, FluidSolver, SolidSolver, mpiComm, chtTransferMethod, heatTransferCoeff)\n\n mpiPrint('\\nSetting non-matching consistent interpolator...', mpiComm)\n\n self.d = self.nDim+1\n self.SolverA = None\n self.SolverC = None\n\n def getLinearSolvers(self):\n \"\"\"\n Des.\n \"\"\"\n\n return [self.SolverA, self.SolverC]\n\n def checkConservation(self):\n \"\"\"\n Des.\n \"\"\"\n\n mpiPrint('No conservation check for consistent interpolation.', self.mpiComm)\n\n def generateInterfaceData(self):\n \"\"\"\n Description.\n \"\"\"\n\n if self.manager.mechanical:\n self.solidInterfaceDisplacement = FlexInterfaceData(self.ns + self.d, 3, self.mpiComm)\n self.fluidInterfaceDisplacement = FlexInterfaceData(self.nf, 3, self.mpiComm)\n self.solidInterfaceLoads = FlexInterfaceData(self.ns, 3, self.mpiComm)\n self.fluidInterfaceLoads = FlexInterfaceData(self.nf + self.d, 3, self.mpiComm)\n\n if self.manager.thermal :\n if self.chtTransferMethod == 'TFFB':\n self.solidInterfaceTemperature = FlexInterfaceData(self.ns, 1, self.mpiComm)\n self.fluidInterfaceTemperature = FlexInterfaceData(self.nf + self.d, 1, self.mpiComm)\n self.solidInterfaceHeatFlux = FlexInterfaceData(self.ns + self.d, 3, self.mpiComm)\n self.fluidInterfaceHeatFlux = FlexInterfaceData(self.nf, 3, self.mpiComm)\n elif self.chtTransferMethod == 'FFTB':\n self.solidInterfaceTemperature = FlexInterfaceData(self.ns + self.d, 1, self.mpiComm)\n self.fluidInterfaceTemperature = FlexInterfaceData(self.nf, 1, self.mpiComm)\n self.solidInterfaceHeatFlux = FlexInterfaceData(self.ns, 3, self.mpiComm)\n self.fluidInterfaceHeatFlux = FlexInterfaceData(self.nf + self.d, 3, self.mpiComm)\n self.fluidInterfaceNormalHeatFlux = FlexInterfaceData(self.nf + self.d, 1, self.mpiComm)\n self.solidInterfaceNormalHeatFlux = FlexInterfaceData(self.ns, 1, self.mpiComm)\n elif self.chtTransferMethod == 'hFTB':\n self.fluidInterfaceRobinTemperature = FlexInterfaceData(self.nf + self.d, 1, self.mpiComm)\n self.solidInterfaceRobinTemperature = FlexInterfaceData(self.ns, 1, self.mpiComm)\n self.solidInterfaceTemperature = FlexInterfaceData(self.ns + self.d, 1, self.mpiComm)\n self.fluidInterfaceTemperature = FlexInterfaceData(self.nf, 1, self.mpiComm)\n elif self.chtTransferMethod == 'hFFB':\n self.fluidInterfaceRobinTemperature = FlexInterfaceData(self.nf + self.d, 1, self.mpiComm)\n self.solidInterfaceRobinTemperature = FlexInterfaceData(self.ns, 1, self.mpiComm)\n self.solidInterfaceHeatFlux = FlexInterfaceData(self.ns + self.d, 3, self.mpiComm)\n self.fluidInterfaceHeatFlux = FlexInterfaceData(self.nf, 3, self.mpiComm)\n\n self.A = InterfaceMatrix((self.ns+self.d,self.ns+self.d), self.mpiComm)\n self.B = InterfaceMatrix((self.nf,self.ns+self.d), self.mpiComm)\n self.C = InterfaceMatrix((self.nf+self.d,self.nf+self.d), self.mpiComm)\n self.D = InterfaceMatrix((self.ns,self.nf+self.d), self.mpiComm)\n\n def generateMapping(self):\n \"\"\"\n Des.\n \"\"\"\n\n solidInterfaceProcessors = self.manager.getSolidInterfaceProcessors()\n fluidInterfaceProcessors = self.manager.getFluidInterfaceProcessors()\n solidPhysicalInterfaceNodesDistribution = self.manager.getSolidPhysicalInterfaceNodesDistribution()\n fluidPhysicalInterfaceNodesDistribution = self.manager.getFluidPhysicalInterfaceNodesDistribution()\n\n mpiPrint('\\nBuilding interpolation matrices...', self.mpiComm)\n\n mpiPrint('\\nBuilding matrix A of size {} X {}...'.format(self.ns, self.ns), self.mpiComm)\n # Fill the matrix A\n if self.mpiComm != None:\n for iProc in solidInterfaceProcessors:\n if self.myid == iProc:\n localSolidInterface_array_X, localSolidInterface_array_Y, localSolidInterface_array_Z = self.SolidSolver.getNodalInitialPositions()\n for jProc in solidInterfaceProcessors:\n self.mpiComm.Isend(localSolidInterface_array_X, dest=jProc, tag=1)\n self.mpiComm.Isend(localSolidInterface_array_Y, dest=jProc, tag=2)\n self.mpiComm.Isend(localSolidInterface_array_Z, dest=jProc, tag=3)\n if self.myid in solidInterfaceProcessors:\n sizeOfBuff = solidPhysicalInterfaceNodesDistribution[iProc]\n solidInterfaceBuffRcv_X = np.zeros(sizeOfBuff)\n solidInterfaceBuffRcv_Y = np.zeros(sizeOfBuff)\n solidInterfaceBuffRcv_Z = np.zeros(sizeOfBuff)\n req = self.mpiComm.Irecv(solidInterfaceBuffRcv_X, iProc, tag=1)\n req.Wait()\n req = self.mpiComm.Irecv(solidInterfaceBuffRcv_Y, iProc, tag=2)\n req.Wait()\n req = self.mpiComm.Irecv(solidInterfaceBuffRcv_Z, iProc, tag=3)\n req.Wait()\n self.fillMatrixA(solidInterfaceBuffRcv_X, solidInterfaceBuffRcv_Y, solidInterfaceBuffRcv_Z, iProc)\n else:\n localSolidInterface_array_X, localSolidInterface_array_Y, localSolidInterface_array_Z = self.SolidSolver.getNodalInitialPositions()\n self.fillMatrixA(localSolidInterface_array_X, localSolidInterface_array_Y, localSolidInterface_array_Z, 0)\n\n mpiBarrier(self.mpiComm)\n mpiPrint(\"\\nAssembling A...\", self.mpiComm)\n start = tm.time()\n self.A.assemble()\n mpiBarrier(self.mpiComm)\n stop = tm.time()\n mpiPrint('Assembly performed in {} s'.format(stop-start), self.mpiComm)\n mpiPrint('Matrix A is built.', self.mpiComm)\n\n mpiPrint('\\nBuilding matrix B & D of size {} X {} & {} X {}...'.format(self.nf, self.ns, self.ns, self.nf), self.mpiComm)\n # Fill the matrix B & D\n if self.mpiComm != None:\n for iProc in solidInterfaceProcessors:\n if self.myid == iProc:\n for jProc in fluidInterfaceProcessors:\n self.mpiComm.Isend(localSolidInterface_array_X, dest=jProc, tag=1)\n self.mpiComm.Isend(localSolidInterface_array_Y, dest=jProc, tag=2)\n self.mpiComm.Isend(localSolidInterface_array_Z, dest=jProc, tag=3)\n if self.myid in fluidInterfaceProcessors:\n sizeOfBuff = solidPhysicalInterfaceNodesDistribution[iProc]\n solidInterfaceBuffRcv_X = np.zeros(sizeOfBuff)\n solidInterfaceBuffRcv_Y = np.zeros(sizeOfBuff)\n solidInterfaceBuffRcv_Z = np.zeros(sizeOfBuff)\n req = self.mpiComm.Irecv(solidInterfaceBuffRcv_X, iProc, tag=1)\n req.Wait()\n req = self.mpiComm.Irecv(solidInterfaceBuffRcv_Y, iProc, tag=2)\n req.Wait()\n req = self.mpiComm.Irecv(solidInterfaceBuffRcv_Z, iProc, tag=3)\n req.Wait()\n self.fillMatrixBD(solidInterfaceBuffRcv_X, solidInterfaceBuffRcv_Y, solidInterfaceBuffRcv_Z, iProc)\n else:\n self.fillMatrixBD(localSolidInterface_array_X, localSolidInterface_array_Y, localSolidInterface_array_Z, 0)\n\n mpiBarrier(self.mpiComm)\n mpiPrint(\"\\nAssembling B & D...\", self.mpiComm)\n start = tm.time()\n self.B.assemble()\n mpiBarrier(self.mpiComm)\n self.D.assemble()\n mpiBarrier(self.mpiComm)\n stop = tm.time()\n mpiPrint('Assembly performed in {} s'.format(stop-start), self.mpiComm)\n mpiPrint('Matrix B & D are built.', self.mpiComm)\n\n mpiPrint('\\nBuilding matrix C of size {} X {}...'.format(self.nf, self.nf), self.mpiComm)\n # Fill the matrix C\n if self.mpiComm != None:\n for iProc in fluidInterfaceProcessors:\n if self.myid == iProc:\n localFluidInterface_array_X, localFluidInterface_array_Y, localFluidInterface_array_Z = self.FluidSolver.getNodalInitialPositions()\n for jProc in fluidInterfaceProcessors:\n self.mpiComm.Send(localFluidInterface_array_X, dest=jProc, tag=1)\n self.mpiComm.Send(localFluidInterface_array_Y, dest=jProc, tag=2)\n self.mpiComm.Send(localFluidInterface_array_Z, dest=jProc, tag=3)\n if self.myid in fluidInterfaceProcessors:\n sizeOfBuff = fluidPhysicalInterfaceNodesDistribution[iProc]\n fluidInterfaceBuffRcv_X = np.zeros(sizeOfBuff)\n fluidInterfaceBuffRcv_Y = np.zeros(sizeOfBuff)\n fluidInterfaceBuffRcv_Z = np.zeros(sizeOfBuff)\n self.mpiComm.Recv(fluidInterfaceBuffRcv_X, iProc, tag=1)\n self.mpiComm.Recv(fluidInterfaceBuffRcv_Y, iProc, tag=2)\n self.mpiComm.Recv(fluidInterfaceBuffRcv_Z, iProc, tag=3)\n self.fillMatrixC(fluidInterfaceBuffRcv_X, fluidInterfaceBuffRcv_Y, fluidInterfaceBuffRcv_Z, iProc)\n else:\n localFluidInterface_array_X, localFluidInterface_array_Y, localFluidInterface_array_Z = self.FluidSolver.getNodalInitialPositions()\n self.fillMatrixC(localFluidInterface_array_X, localFluidInterface_array_Y, localFluidInterface_array_Z, 0)\n\n mpiBarrier(self.mpiComm)\n mpiPrint(\"\\nAssembling C...\", self.mpiComm)\n start = tm.time()\n self.C.assemble()\n mpiBarrier(self.mpiComm)\n stop = tm.time()\n mpiPrint('Assembly performed in {} s'.format(stop-start), self.mpiComm)\n mpiPrint('Matrix C is built.', self.mpiComm)\n\n self.SolverA = LinearSolver(self.A, self.mpiComm)\n self.SolverC = LinearSolver(self.C, self.mpiComm)\n\n def interpolateFluidToSolid(self, fluidInterfaceData, solidInterfaceData):\n \"\"\"\n des.\n \"\"\"\n\n dim = fluidInterfaceData.getDim()\n gamma_array = FlexInterfaceData(self.nf + self.d, dim, self.mpiComm)\n\n self.SolverC.solve(fluidInterfaceData, gamma_array)\n self.D.mult(gamma_array, solidInterfaceData)\n\n def interpolateSolidToFluid(self, solidInterfaceData, fluidInterfaceData):\n \"\"\"\n Des.\n \"\"\"\n\n dim = solidInterfaceData.getDim()\n gamma_array = FlexInterfaceData(self.ns + self.d, dim, self.mpiComm)\n\n self.SolverA.solve(solidInterfaceData, gamma_array)\n self.B.mult(gamma_array, fluidInterfaceData)\n\nclass RBFInterpolator(ConservativeInterpolator):\n \"\"\"\n Description.\n \"\"\"\n\n def __init__(self, Manager, FluidSolver, SolidSolver, RBFradius=0.1, mpiComm = None, chtTransferMethod=None, heatTransferCoeff=1.0):\n \"\"\"\"\n Description.\n \"\"\"\n\n ConservativeInterpolator.__init__(self, Manager, FluidSolver, SolidSolver, mpiComm, chtTransferMethod, heatTransferCoeff)\n\n mpiPrint('\\nSetting interpolation with Radial Basis Functions...', mpiComm)\n\n self.radius = RBFradius\n\n self.generateInterfaceData()\n\n self.generateMapping()\n\n\n def generateInterfaceData(self):\n \"\"\"\n Des.\n \"\"\"\n\n ConservativeInterpolator.generateInterfaceData(self)\n\n mpiPrint('Generating interface data for conservative RBF interpolator...', self.mpiComm)\n\n self.A.createSparseFullAlloc()\n self.A_T.createSparseFullAlloc()\n self.B.createSparseFullAlloc()\n self.B_T.createSparseFullAlloc()\n\n def fillMatrixA(self, solidInterfaceBuffRcv_X, solidInterfaceBuffRcv_Y, solidInterfaceBuffRcv_Z, iProc):\n \"\"\"\n Description.\n \"\"\"\n\n localSolidInterface_array_X_init, localSolidInterface_array_Y_init, localSolidInterface_array_Z_init = self.SolidSolver.getNodalInitialPositions()\n start = tm.time()\n ccupydo.CInterpolator.RBF_fillMatrixA(self, localSolidInterface_array_X_init, localSolidInterface_array_Y_init, localSolidInterface_array_Z_init,\n solidInterfaceBuffRcv_X, solidInterfaceBuffRcv_Y, solidInterfaceBuffRcv_Z, self.A, self.A_T, iProc, 1.01*self.radius)\n stop = tm.time()\n print('Built A on rank {} in {} s'.format(self.myid,stop-start))\n\n\n def fillMatrixB(self, solidInterfaceBuffRcv_X, solidInterfaceBuffRcv_Y, solidInterfaceBuffRcv_Z, iProc):\n \"\"\"\n Description.\n \"\"\"\n\n localFluidInterface_array_X_init, localFluidInterface_array_Y_init, localFluidInterface_array_Z_init = self.FluidSolver.getNodalInitialPositions()\n start = tm.time()\n ccupydo.CInterpolator.RBF_fillMatrixB(self, localFluidInterface_array_X_init, localFluidInterface_array_Y_init, localFluidInterface_array_Z_init,\n solidInterfaceBuffRcv_X, solidInterfaceBuffRcv_Y, solidInterfaceBuffRcv_Z, self.B, self.B_T, iProc, 1.01*self.radius)\n stop = tm.time()\n print('Built B on rank {} in {} s'.format(self.myid,stop-start))\n\n\n\nclass ConsistentRBFInterpolator(ConsistentInterpolator):\n \"\"\"\n Description.\n \"\"\"\n\n def __init__(self, Manager, FluidSolver, SolidSolver, RBFradius = 0.1, mpiComm= None, chtTransferMethod=None, heatTransferCoeff=1.0):\n \"\"\"\n Des.\n \"\"\"\n\n ConsistentInterpolator.__init__(self, Manager, FluidSolver, SolidSolver, mpiComm, chtTransferMethod, heatTransferCoeff)\n\n mpiPrint('\\nSetting interpolation with Radial Basis Functions...', mpiComm)\n\n self.radius = RBFradius\n\n self.generateInterfaceData()\n\n self.generateMapping()\n\n def generateInterfaceData(self):\n \"\"\"\n Des.\n \"\"\"\n\n ConsistentInterpolator.generateInterfaceData(self)\n\n mpiPrint('Generating interface data for consistent RBF interpolator...', self.mpiComm)\n\n self.A.createSparseFullAlloc()\n self.B.createSparseFullAlloc()\n self.C.createSparseFullAlloc()\n self.D.createSparseFullAlloc()\n\n\n def fillMatrixA(self, solidInterfaceBuffRcv_X, solidInterfaceBuffRcv_Y, solidInterfaceBuffRcv_Z, iProc):\n \"\"\"\n Description.\n \"\"\"\n\n localSolidInterface_array_X_init, localSolidInterface_array_Y_init, localSolidInterface_array_Z_init = self.SolidSolver.getNodalInitialPositions()\n start = tm.time()\n ccupydo.CInterpolator.consistent_RBF_fillMatrixA(self, localSolidInterface_array_X_init, localSolidInterface_array_Y_init, localSolidInterface_array_Z_init,\n solidInterfaceBuffRcv_X, solidInterfaceBuffRcv_Y, solidInterfaceBuffRcv_Z, self.A, iProc, 1.01*self.radius)\n stop = tm.time()\n print('Built A on rank {} in {} s'.format(self.myid,stop-start))\n\n def fillMatrixBD(self, solidInterfaceBuffRcv_X, solidInterfaceBuffRcv_Y, solidInterfaceBuffRcv_Z, iProc):\n \"\"\"\n Description.\n \"\"\"\n\n localFluidInterface_array_X_init, localFluidInterface_array_Y_init, localFluidInterface_array_Z_init = self.FluidSolver.getNodalInitialPositions()\n start = tm.time()\n ccupydo.CInterpolator.consistent_RBF_fillMatrixBD(self, localFluidInterface_array_X_init, localFluidInterface_array_Y_init, localFluidInterface_array_Z_init,\n solidInterfaceBuffRcv_X, solidInterfaceBuffRcv_Y, solidInterfaceBuffRcv_Z, self.B, self.D, iProc, 1.01*self.radius)\n stop = tm.time()\n print('Built B & D on rank {} in {} s'.format(self.myid,stop-start))\n\n def fillMatrixC(self, fluidInterfaceBuffRcv_X, fluidInterfaceBuffRcv_Y, fluidInterfaceBuffRcv_Z, iProc):\n \"\"\"\n Description.\n \"\"\"\n\n localFluidInterface_array_X_init, localFluidInterface_array_Y_init, localFluidInterface_array_Z_init = self.FluidSolver.getNodalInitialPositions()\n start = tm.time()\n ccupydo.CInterpolator.consistent_RBF_fillMatrixC(self, localFluidInterface_array_X_init, localFluidInterface_array_Y_init, localFluidInterface_array_Z_init,\n fluidInterfaceBuffRcv_X, fluidInterfaceBuffRcv_Y, fluidInterfaceBuffRcv_Z, self.C, iProc, 1.01*self.radius)\n stop = tm.time()\n print('Built C on rank {} in {} s'.format(self.myid,stop-start))\n\nclass TPSInterpolator(ConservativeInterpolator):\n \"\"\"\n Des.\n \"\"\"\n\n def __init__(self, Manager, FluidSolver, SolidSolver, mpiComm=None, chtTransferMethod=None, heatTransferCoeff=1.0):\n \"\"\"\n des.\n \"\"\"\n\n ConservativeInterpolator.__init__(self, Manager, FluidSolver, SolidSolver, mpiComm, chtTransferMethod, heatTransferCoeff)\n\n mpiPrint('\\nSetting interpolation with Thin Plate Spline...', self.mpiComm)\n\n self.generateInterfaceData()\n\n self.generateMapping()\n\n def generateInterfaceData(self):\n \"\"\"\n Des.\n \"\"\"\n\n ConservativeInterpolator.generateInterfaceData(self)\n\n mpiPrint('Generating interface data for TPS interpolator...', self.mpiComm)\n\n self.A.createDense()\n self.A_T.createDense()\n self.B.createDense()\n self.B_T.createDense()\n\n def fillMatrixA(self, solidInterfaceBuffRcv_X, solidInterfaceBuffRcv_Y, solidInterfaceBuffRcv_Z, iProc):\n \"\"\"\n Description.\n \"\"\"\n\n localSolidInterface_array_X_init, localSolidInterface_array_Y_init, localSolidInterface_array_Z_init = self.SolidSolver.getNodalInitialPositions()\n\n start = tm.time()\n ccupydo.CInterpolator.TPS_fillMatrixA(self, localSolidInterface_array_X_init, localSolidInterface_array_Y_init, localSolidInterface_array_Z_init,\n solidInterfaceBuffRcv_X, solidInterfaceBuffRcv_Y, solidInterfaceBuffRcv_Z, self.A, self.A_T, iProc)\n stop = tm.time()\n print('Built A on rank {} in {} s'.format(self.myid,stop-start))\n\n def fillMatrixB(self, solidInterfaceBuffRcv_X, solidInterfaceBuffRcv_Y, solidInterfaceBuffRcv_Z, iProc):\n \"\"\"\n Description.\n \"\"\"\n\n localFluidInterface_array_X_init, localFluidInterface_array_Y_init, localFluidInterface_array_Z_init = self.FluidSolver.getNodalInitialPositions()\n\n start = tm.time()\n ccupydo.CInterpolator.TPS_fillMatrixB(self, localFluidInterface_array_X_init, localFluidInterface_array_Y_init, localFluidInterface_array_Z_init,\n solidInterfaceBuffRcv_X, solidInterfaceBuffRcv_Y, solidInterfaceBuffRcv_Z, self.B, self.B_T, iProc)\n stop = tm.time()\n print('Built B on rank {} in {} s'.format(self.myid,stop-start))\n\nclass ConsistentTPSInterpolator(ConsistentInterpolator):\n \"\"\"\n Description.\n \"\"\"\n\n def __init__(self, Manager, FluidSolver, SolidSolver, mpiComm= None, chtTransferMethod=None, heatTransferCoeff=1.0):\n \"\"\"\n Des.\n \"\"\"\n\n ConsistentInterpolator.__init__(self, Manager, FluidSolver, SolidSolver, mpiComm, chtTransferMethod, heatTransferCoeff)\n\n mpiPrint('\\nSetting consistent interpolation with Thin Plate Spline...', self.mpiComm)\n\n self.generateInterfaceData()\n\n self.generateMapping()\n\n def generateInterfaceData(self):\n \"\"\"\n Des.\n \"\"\"\n\n ConsistentInterpolator.generateInterfaceData(self)\n\n mpiPrint('Generating interface data for consistent TPS interpolator...', self.mpiComm)\n\n self.A.createDense()\n self.B.createDense()\n self.C.createDense()\n self.D.createDense()\n\n def fillMatrixA(self, solidInterfaceBuffRcv_X, solidInterfaceBuffRcv_Y, solidInterfaceBuffRcv_Z, iProc):\n \"\"\"\n Des.\n \"\"\"\n\n localSolidInterface_array_X_init, localSolidInterface_array_Y_init, localSolidInterface_array_Z_init = self.SolidSolver.getNodalInitialPositions()\n start = tm.time()\n ccupydo.CInterpolator.consistent_TPS_fillMatrixA(self, localSolidInterface_array_X_init, localSolidInterface_array_Y_init, localSolidInterface_array_Z_init,\n solidInterfaceBuffRcv_X, solidInterfaceBuffRcv_Y, solidInterfaceBuffRcv_Z, self.A, iProc)\n stop = tm.time()\n print('Built A on rank {} in {} s'.format(self.myid,stop-start))\n\n def fillMatrixBD(self, solidInterfaceBuffRcv_X, solidInterfaceBuffRcv_Y, solidInterfaceBuffRcv_Z, iProc):\n \"\"\"\n des.\n \"\"\"\n\n localFluidInterface_array_X_init, localFluidInterface_array_Y_init, localFluidInterface_array_Z_init = self.FluidSolver.getNodalInitialPositions()\n start = tm.time()\n ccupydo.CInterpolator.consistent_TPS_fillMatrixBD(self, localFluidInterface_array_X_init, localFluidInterface_array_Y_init, localFluidInterface_array_Z_init,\n solidInterfaceBuffRcv_X, solidInterfaceBuffRcv_Y, solidInterfaceBuffRcv_Z, self.B, self.D, iProc)\n stop = tm.time()\n print('Built B & D on rank {} in {} s'.format(self.myid,stop-start))\n\n def fillMatrixC(self, fluidInterfaceBuffRcv_X, fluidInterfaceBuffRcv_Y, fluidInterfaceBuffRcv_Z, iProc):\n \"\"\"\n Des.\n \"\"\"\n\n localFluidInterface_array_X_init, localFluidInterface_array_Y_init, localFluidInterface_array_Z_init = self.FluidSolver.getNodalInitialPositions()\n start = tm.time()\n ccupydo.CInterpolator.consistent_TPS_fillMatrixC(self, localFluidInterface_array_X_init, localFluidInterface_array_Y_init, localFluidInterface_array_Z_init,\n fluidInterfaceBuffRcv_X, fluidInterfaceBuffRcv_Y, fluidInterfaceBuffRcv_Z, self.C, iProc)\n stop = tm.time()\n print('Built C on rank {} in {} s'.format(self.myid,stop-start))\n", "meta": {"hexsha": "e2e927f86630e11630fba2961f7d26653175c737", "size": 66490, "ext": "py", "lang": "Python", "max_stars_repo_path": "cupydo/interpolator.py", "max_stars_repo_name": "AxelDechamps/CUPyDO", "max_stars_repo_head_hexsha": "52b42804516ac95c7969d04ba9471b62c6f7b875", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 16, "max_stars_repo_stars_event_min_datetime": "2018-12-09T09:50:13.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-10T01:06:48.000Z", "max_issues_repo_path": "cupydo/interpolator.py", "max_issues_repo_name": "AxelDechamps/CUPyDO", "max_issues_repo_head_hexsha": "52b42804516ac95c7969d04ba9471b62c6f7b875", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 24, "max_issues_repo_issues_event_min_datetime": "2019-02-07T10:47:06.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-07T22:01:31.000Z", "max_forks_repo_path": "cupydo/interpolator.py", "max_forks_repo_name": "AxelDechamps/CUPyDO", "max_forks_repo_head_hexsha": "52b42804516ac95c7969d04ba9471b62c6f7b875", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2020-02-14T09:23:36.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-10T09:19:32.000Z", "avg_line_length": 47.4589578872, "max_line_length": 356, "alphanum_fraction": 0.6477365017, "include": true, "reason": "import numpy", "num_tokens": 15033, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5813030906443133, "lm_q2_score": 0.334589441253186, "lm_q1q2_score": 0.19449787629743093}} {"text": "#A library of code to examine properties of bulk water and near solutes\n#\n#Should eventually be able to handle local densities and fluctuations,\n#solute-water and water-water energies, 3-body angles, hydrogen bonds,\n#energy densities, and all of this as a function of space. Additionally,\n#should also be able to compute interfaces, such as Willard-Chandler\n#instantaneous interface, or vdW surface, SASA and volume of solute.\n#\n#Will work with pytraj interface for trajectory analysis, since this\n#should later allow easier energy decomposition?\n#If doesn't work out, will go back to sim package with netcdf plugin.\n#\n#Also, should have test script and some test system where know answers\n#\n\nimport sys, os\nimport numpy as np\nimport scipy.optimize as optimize\nfrom scipy.special import sph_harm\nimport waterlib as wl\n\n#Define constants and unit conversions\n\n#conversion for surface tension\nkBJ = 1.38064852*(10**(-23))\ntemp = 300.0\ntomJm2 = kBJ*temp*1000.0*(10**20) #converts kBT/Angstrom^2 to mJ/m^2\n\n#Convert potential energy to kBT\nkBTkcal = 0.0019858775*300.0\n\n#Water density\nwatdens = 0.033456 # molecules or oxygens per Angstrom ^ 3 near 300 K\n\n#Define library of useful functions\n\ndef SASAperAtom(pos, radii, radius=1.4, nPoints = 1000, nExpose = 10):\n \"\"\"Inputs:\n pos - Nx3 array of atomic positions\n radii - N array of atomic radii\n radius - solvent radius to \"roll\" over surface\n nPoints - number points on each sphere\n nExpose - number exposed points on atom (sphere) to be considered on surface\n Outputs:\n SASAper - SASA for each atom\n surfAtoms - array of 1 for solvent exposed, 0 for not on surface\n \"\"\"\n\n points = wl.spherepoints(nPoints)\n SASAper, surfAtoms = wl.spheresurfaceareas(pos, radii+radius, points, nExpose)\n\n return SASAper, surfAtoms\n\n\ndef PepWatHBonds(allPos, pepAccInds, pepDonInds, watInds, distCut = 2.1, angCut = 30.0):\n \"\"\"Currently kind of wack (does acceptor to hydrogen distance). Also, calculating \nH-bonds geometrically seems less useful.\n Inputs:\n allPos - full position array for trajectory frame (all atoms included)\n pepAccInds - global indices of peptide acceptors\n pepDonInds - global indices of peptide donors\n watInds - global indices of water atoms in selected hydration shell(s)\n distCut(=2.1) - distance cutoff for H-bond detection\n angCut(=30.0) - angle cutoff for H-bond detection\n Outputs:\n NBonds - number of detected H-bonds\n bondsPer - number H-bonds for each water molecule with peptide\n donors - indices of donors (H atoms only) as string\n acceptors - indices of acceptors as string\n \"\"\"\n\n #Get H-bond info\n NBonds, watAcc, watDon, pepAcc, pepDon = wl.findhbonds(\n allPos[pepAccInds], allPos[pepDonInds], allPos[watInds], distCut, angCut)\n\n #And sort nicely into just acceptors and donors\n acceptorsList = []\n donorsList = []\n bondsWat = np.zeros(int(len(watInds)/3))\n\n for (j, val) in enumerate(pepAcc):\n acceptorsList = acceptorsList + (val*[pepAccInds[j]])\n\n for (j, val) in enumerate(pepDon):\n donorsList = donorsList + (val*[pepDonInds[j]])\n\n for (j, val) in enumerate(watAcc):\n acceptorsList = acceptorsList + (val*[watInds[j]])\n bondsWat[int(j/3)] = bondsWat[int(j/3)] + val\n\n for (j, val) in enumerate(watDon):\n donorsList = donorsList + (val*[watInds[j]])\n bondsWat[int(j/3)] = bondsWat[int(j/3)] + val\n\n #Above uses properties of python lists to add each index the number of H-bonds it participates in\n\n bondsPer = bondsWat\n \n #For easy file writing, make donors and acceptors into strings of indices\n #Remember that the sim package indexes at zero!\n donors = ''.join(str(e)+\"|\" for e in donorsList)\n acceptors = ''.join(str(e)+\"|\" for e in acceptorsList)\n \n return NBonds, bondsPer, acceptors, donors\n\n\ndef BBHBonds(allPos, pepAccInds, pepDonInds, distCut = 2.1, angCut = 30.0):\n \"\"\"Finds H bonds between two list of acceptors and donors. Intended for just peptide backbone.\n Inputs:\n allPos - full position array for trajectory frame\n pepAccInds - global indics of peptide acceptors\n pepDonInds - global indices of peptide doneors\n distCut(=2.1) - distance cutoff for H-bond detection\n angCut(=30.0) - angle cutoff for H-bond detection\n Outputs:\n NBonds - number of detected H-bonds\n donors - indices of donors as string\n acceptors - indices of acceptors as string\n \"\"\"\n\n #Get H-bonds\n NBonds, pepAcc, pepDon = wl.bbhbonds(allPos[pepAccInds], allPos[pepDonInds], distCut, angCut)\n \n #Sort nicely\n acceptorsList = []\n donorsList = []\n\n for (j, val) in enumerate(pepAcc):\n acceptorsList = acceptorsList + (val*[pepAccInds[j]])\n\n for (j, val) in enumerate(pepDon):\n donorsList = donorsList + (val*[pepDonInds[j]])\n\n #set lists to strings and return\n donors = ''.join(str(e)+\"|\" for e in donorsList)\n acceptors = ''.join(str(e)+\"|\" for e in acceptorsList)\n \n return NBonds, acceptors, donors\n\n\ndef WatHBonds(allPos, watInds, allWatInds, BoxDims, distCut = 2.1, angCut = 30.0):\n \"\"\"Also kind of wack, but keeping since used in peptide-surface pulling analysis.\n For a better, more general algorithm, use HBondsGeneral.\n Inputs:\n allPos - full position array for trajectory frame (all atoms included)\n watInds - global indices of water atoms in selected hydration shell(s)\n allWatInds - global indices of ALL water atoms\n BoxDims - dimensions of box to account for periodic BCs (to turn off, set to zero)\n distCut(=2.1) - distance cutoff for H-bond detection\n angCut(=30.0) - angle cutoff for H-bond detection\n Outputs:\n NBonds - number of detected H-bonds\n bondsPer - number of detected H-bonds for each water molecule in selection\n acceptors - indices of acceptors as string\n donors - indices of donors (H atoms only) as string\n \"\"\"\n\n #Get H-bond info\n NBonds, watAcc, watDon = wl.wathbonds(allPos[watInds], allPos[allWatInds], BoxDims, distCut, angCut)\n\n #And sort nicely into just acceptors and donors\n #Also count number of H-bonds for each water to get estimate of average per water\n acceptorsList = []\n donorsList = []\n bondsWat = np.zeros(int(len(watInds)/3))\n\n for (j, val) in enumerate(watAcc):\n acceptorsList = acceptorsList + (val*[watInds[j]])\n bondsWat[int(j/3)] = bondsWat[int(j/3)] + val\n\n for (j, val) in enumerate(watDon):\n donorsList = donorsList + (val*[watInds[j]])\n bondsWat[int(j/3)] = bondsWat[int(j/3)] + val\n\n #Above uses properties of python lists to add each index the number of H-bonds it participates in\n\n #print bondsWat\n #bondsPer = np.average(bondsWat)\n bondsPer = bondsWat\n \n #For easy file writing, make donors and acceptors into strings of indices\n #Remember that the sim package indexes at zero!\n donors = ''.join(str(e)+\"|\" for e in donorsList)\n acceptors = ''.join(str(e)+\"|\" for e in acceptorsList)\n \n return NBonds, bondsPer, acceptors, donors\n\n\ndef getCosAngs(subPos, Pos, BoxDims, lowCut=0.0, highCut=3.413):\n \"\"\"This is called getCosAngs, but actually just returns the angles themselves (faster to convert\n from cos(theta) to theta in Fortran)\n Inputs:\n subPos - positions of set of atoms to measure tetrahedrality of (may be different, subset, or same as Pos)\n Pos - positions of ALL atoms that can make tetrahedral configurations (needed if subPos not same as Pos)\n BoxDims - current box dimensions to account for periodicity\n lowCut - lower cutoff for nearest-neighbor shell (default 0.0)\n highCut - higher cutoff for nearest-neighbor shell (default 3.413 - see Chaimovich, 2014, but should really\n change to reflect first peak in g(r) for the chosen water model)\n Outputs:\n angVals - all angle values for current configuration of positions supplied\n numAngs - number of angles for each central oxygen atom (i.e. number neighbors factorial)\n This is useful for finding which angles belong to which central oxygens\n This return value was added on 07/09/2017, so any code using this function\n before then will break, unfortunately, but the fix is easy.\n \"\"\"\n\n #Set-up array to hold angle results and stack as go... list increases in size!\n angVals = np.array([])\n numAngs = np.zeros(len(subPos))\n\n #Find nearest neighbors for ALL atoms in subPos\n #But make sure using efficient algorithm...\n #If subPos is same as Pos, use allnearneighbors instead\n if np.array_equal(subPos, Pos):\n nearNeighbs = wl.allnearneighbors(Pos, BoxDims, lowCut, highCut).astype(bool)\n else:\n nearNeighbs = wl.nearneighbors(subPos, Pos, BoxDims, lowCut, highCut).astype(bool)\n\n #Loop over each position in subPos, finding angle made with all neighbor pairs\n for (i, apos) in enumerate(subPos):\n #Make sure have nearest neighbors...\n if len(Pos[nearNeighbs[i]]) > 0:\n #below returns symmetric, square array (zero diagonal)\n tempAng = wl.tetracosang(apos, Pos[nearNeighbs[i]], BoxDims) \n #Only want half of array, flattened\n angVals = np.hstack((angVals, tempAng[np.triu_indices(len(tempAng),k=1)].tolist()))\n numAngs[i] = tempAng.shape[0]\n\n return angVals, numAngs\n \n \ndef tetrahedralMetrics(angVals, nBins=500, binRange=[0.0, 180.0]):\n \"\"\"Inputs:\n angVals - all angle values sampled\n nBins - number histogram bins to use\n binRange - histogram bin range to apply\n Outputs:\n angDist - distribution of angle\n bins - bins used in histogramming\n fracTet - fraction of distribution that is tetrahedral (integrate cosDist from -0.75 to 0.25 - see Chaimovich, 2014)\n avgCos - average Cos(angle) within tetrahedral peak\n stdCos - second moment of Cos(angle) within tetrahedral peak\n \"\"\"\n \n #Histogram the data - note that density set so just returns number of counts, not normalized\n angDist, bins = np.histogram(angVals, bins=nBins, range=binRange, density=False)\n\n #Take index before since want histogram bin containing this value\n startTet = np.argmax(bins>np.arccos(0.25)*180.0/np.pi) - 1\n endTet = np.argmax(bins>np.arccos(-0.75)*180.0/np.pi) - 1 \n\n fracTet = np.sum(angDist[startTet:endTet]) / np.sum(angDist)\n\n #Take average and second moment within peak\n avgCos = 0.0\n stdCos = 0.0\n angCount = 0\n\n for ang in angVals:\n if (ang >= np.arccos(0.25)*180.0/np.pi) and (ang <= np.arccos(-0.75)*180.0/np.pi):\n avgCos = avgCos + np.cos(ang*np.pi/180.0)\n stdCos = stdCos + np.cos(ang*np.pi/180.0)**2\n angCount += 1\n\n avgCos = avgCos / angCount\n stdCos = stdCos / angCount\n\n return angDist, bins, fracTet, avgCos, stdCos\n\n\ndef getOrderParamq(subPos, Pos, BoxDims, lowCut=0.0, highCut=8.0):\n \"\"\"Finds angles for 4 nearest neighbors of each water and returns for all waters the \ntetrahedral order parameter, q, used by Errington and Debenedetti (2001).\n Inputs: \n subPos - positions of set of atoms to measure tetrahedrality of (may be different, subset, or same as Pos)\n Pos - positions of ALL atoms that can make tetrahedral configurations (needed if subPos not same as Pos)\n BoxDims - current box dimensions to account for periodicity\n lowCut - lower cutoff for nearest-neighbor shell (default 0.0)\n highCut - higher cutoff for nearest-neighbor shell used to find 4 nearest neighbors\n Outputs:\n qVals - returns an order parameter value for each water\n distNeighbs - returns distances from central oxygen to 4 nearest neighbors\n \"\"\"\n\n #Set-up array to hold results\n qVals = np.zeros(len(subPos))\n distNeighbs = np.zeros((len(subPos), 4))\n\n #Find nearest neighbors for ALL atoms in subPos\n #But make sure using efficient algorithm...\n #If subPos is same as Pos, use allnearneighbors instead\n if np.array_equal(subPos, Pos):\n nearNeighbs = wl.allnearneighbors(Pos, BoxDims, lowCut, highCut).astype(bool)\n else:\n nearNeighbs = wl.nearneighbors(subPos, Pos, BoxDims, lowCut, highCut).astype(bool)\n\n #Loop over each position in subPos, finding angle made with the closest 4 neighbors, then q\n for (i, apos) in enumerate(subPos):\n #Make sure have nearest neighbors...\n if np.sum(nearNeighbs[i]) > 0:\n thisPos = wl.reimage(Pos[nearNeighbs[i]], apos, BoxDims)\n thisDists = np.linalg.norm(thisPos - apos, axis=1)\n sortInds = np.argsort(thisDists)\n newPos = thisPos[sortInds][:4]\n distNeighbs[i,:] = thisDists[sortInds][:4]\n #below returns symmetric, square array (zero diagonal)\n tempAng = wl.tetracosang(apos, newPos, BoxDims)\n #Only want half of array, flattened\n angVals = tempAng[np.triu_indices(len(tempAng),k=1)]\n #Now compute q for this set of angles\n qVals[i] = 1.0 - (3.0/8.0)*np.sum((np.cos(angVals*np.pi/180.0) + (1.0/3.0))**2)\n\n #Return all of the order parameter values\n return qVals, distNeighbs\n\n\ndef findSineCoeffs(allangs, Norder=180, doNormalize=False):\n \"\"\"Given an array of angles, computes the sine coefficients to the given order.\nNote that to get right coefficients, will need to divide by total number of angles.\nThis is not done by default, assuming that angles provided are for each frame.\n Inputs:\n allangs - array or list of angles\n Norder - (default 180) number of terms in sine series to use (excludes k=0)\n doNormalize - (default False) if true, divides by number of samples to correctly normalize\n Outputs:\n coeffs - Norder x 2 array; 1st column is k, second column is coefficient\n Comes from fact that period is zero to Pi, so only keep sin(k*angle) in series\n \"\"\"\n #Check if angles in radians - if any values are greater than Pi, assume in degrees\n if np.max(allangs) > np.pi:\n allangs = allangs * np.pi / 180.0\n coeffs = np.zeros((Norder,2))\n for k in range(Norder):\n coeffs[k,0] = k+1\n coeffs[k,1] = np.sqrt(2.0/np.pi)*np.sum(np.sin((k+1)*allangs))\n if doNormalize:\n coeffs = coeffs / len(allangs)\n return coeffs\n\n\ndef distFromCoeffs(coeffs, angvals=None, Norder=60):\n \"\"\"Given an array of coefficients for a sine series, compute the distribution.\n Inputs:\n coeffs - coefficients for each term in a sine series\n assuming that for sin(k*angle) form, this array is sorted from small to large k\n angvals - (default 0.0 to 180.0 by 0.01) angle values in degrees at which distribution \n should be evaluated - normalization will be done for PDF along degrees\n Norder - (default 60) number of terms in the series to use (i.e. number of coeffs)\n Outputs:\n adist - returns a normalized distribution\n \"\"\"\n if angvals is None:\n angvals = np.arange(0.0, 180.0, 0.01)\n #Also define in radians\n radvals = angvals * np.pi / 180.0\n adist = np.zeros(len(angvals))\n normfac = 0.0\n for k in range(Norder):\n adist += coeffs[k]*np.sin((k+1)*radvals)\n if (k+1)%2 != 0:\n normfac += coeffs[k]*2.0/(k+1)\n adist = adist / (normfac*(angvals[1]-angvals[0]))\n return adist\n\n\ndef fitDist(refDists, Dist, bruteNs=200):\n \"\"\"Given a set of reference distributions, as a numpy array with each distribution as a row,\nfits the current distribution using a linear combination of the reference distributions.\n Inputs:\n refDists - array with each reference distribution as a row\n Dist - (3-body angle) distribution to fit as linear combination of references with\n the fitting parameters (linear coefficients) summing to one\n bruteNs - number of discrete bins to use along each parameter when searching for brute minimum\n Outputs:\n fitParams - fit parameters resulting from fitting \n resSq - sum of squared residuals for fit\n resSigned - signed residuals at each point of fit\n \"\"\"\n\n #Define tolerance\n tolf = 1.0e-12\n tolx = 1.0e-12 \n\n #Initialize parameters to seek for - start in 4 ways and take minimum of these\n initParams = np.eye(refDists.shape[0])\n initParams = np.vstack((initParams, np.ones(refDists.shape[0]) * (1.0/refDists.shape[0])))\n\n #Define an objective function to be minimized\n def funcMin(vals, *withcon):\n #Give it parameter values, returns squared residuals\n func = np.sum((np.dot(vals, refDists) - Dist)**2)\n if withcon:\n func = func + (np.sum(vals) - 1.0)**2\n return func\n\n def jacFunc(vals):\n #Returns the Jacobian of the function to minimize\n func = np.dot(refDists, 2.0*(np.dot(vals, refDists) - Dist))\n return func\n\n def funcSquares(vals):\n #Gives vector of squared residuals to see where best/worst parts of fit are\n func = (np.dot(vals, refDists) - Dist)**2\n return func\n\n #Define constraints... for now say that all parms must sum to one\n cons = ({'type' : 'eq',\n 'fun' : lambda x: np.sum(x) - 1.0,\n 'jac' : lambda x: np.ones(len(x))})\n\n #And define bounds to keep all params between 0 and 1\n bnds = [(0.0,1.0)]*refDists.shape[0]\n\n #For each set of starting conditions, do minimization, then pick global min\n globMinInfo = None\n\n #And will store squared residuals at found mins as go\n #Checks if one part of curve fits better than another\n resSq = np.zeros((refDists.shape[1], initParams.shape[0]))\n\n for (i, params) in enumerate(initParams):\n\n #If only one distribution given, don't use constraint\n if refDists.shape[0] == 1:\n mininfo = optimize.minimize(funcMin, params, jac=jacFunc, method='SLSQP',\n bounds=bnds, options={'ftol':tolf})\n else:\n mininfo = optimize.minimize(funcMin, params, jac=jacFunc, method='SLSQP',\n constraints=cons, bounds=bnds, options={'ftol':tolf})\n \n #print \"Minimum sum of squares: %e at values \"%mininfo.fun+str(mininfo.x)\n\n if globMinInfo != None:\n if mininfo.fun < globMinInfo.fun:\n globMinInfo = mininfo\n else:\n globMinInfo = mininfo\n\n resSq[:,i] = funcSquares(mininfo.x)\n\n #Compare to global min with brute force\n if refDists.shape[0] == 1:\n (bruteMinInfo) = optimize.brute(funcMin, tuple(bnds), Ns=bruteNs, finish=None, full_output=True, disp=False)\n else:\n (bruteMinInfo) = optimize.brute(funcMin, tuple(bnds), args=(1,), Ns=bruteNs, finish=None, full_output=True, disp=False)\n\n fitParams = bruteMinInfo[0]\n\n #print \"Brute force finds minima at \"+str(fitParams)\n\n #Also compute regular residuals, not squared\n resSigned = np.dot(fitParams, refDists) - Dist\n\n #print \"Best fit found at:\"\n #print [float(q) for q in fitParams]\n #print \"And with parameters summing to %f\" % np.sum(fitParams)\n return fitParams, resSq, resSigned \n\n\ndef waterOrientationBinZ(Opos, Hpos, boxDim, refVec=[0.0, 0.0, 1.0], refBins=None, angBins=None):\n \"\"\"Determines the angle between a reference vector and the dipoles and plane-normal vector\nof all water molecule positions provided.\n Inputs:\n Opos - all water oxygen positions\n Hpos - all water hydrogen positions\n boxDim - box dimensions for imaging\n refVec - the reference vector for water orientation, default\n is the z-direction [1, 0, 0]\n refBins - bins along the direction of refVec that the waters \n should be placed into (default is min and max along refVec)\n angBins - bins for calculated angles, default 500 bins from 0 to 180\n Outputs:\n plane2Dhist - 2D histogram with angle bins varying over rows and \n refVec bins varying over rows (for the water plane vector angles)\n dip2Dhist - 2D histogram as above, but for dipole vector angles\n \"\"\"\n\n #Get positions of oxygen atoms along refVec, then create \n #this array with each entry repeated\n refVec = refVec / np.linalg.norm(refVec)\n zOpos = np.dot(Opos, refVec)\n zOposforH = np.array([[z,z] for z in zOpos]).flatten()\n\n #Compute all of the angles with respect to the reference\n #Note that the dipole vector of each water molecule will be taken as\n #the sum of the OH bond vectors\n angDip, angPlane = wl.watorient(Opos, Hpos, refVec, boxDim)\n\n #Set refBins if not set\n if refBins is None:\n refBins = np.arange(np.min(zOpos), np.max(zOpos), 0.2)\n\n #Same for angBins\n if angBins is None:\n angBins = np.arange(0.0, 180.001, 180.0/500.0)\n\n #And do 2D histogramming\n plane2Dhist, angEdges, refEdges = np.histogram2d(angPlane, zOposforH, bins=[angBins, refBins], normed=False)\n dip2Dhist, angEdges, refEdges = np.histogram2d(angDip, zOpos, bins=[angBins, refBins], normed=False)\n\n return plane2Dhist, dip2Dhist\n\n\ndef waterOrientation(Opos, Hpos, boxDim, refVec=[0.0, 0.0, 1.0]):\n \"\"\"This is a wrapper for the waterlib function watorient.\n Inputs:\n Opos - all water oxygen positions\n Hpos - all water hydrogen positions\n boxDim - box dimensions for imaging\n refVec - the reference vector for water orientation, default\n is the z-direction [1, 0, 0]\n Outputs:\n dipAngs - all angles of dipole vectors with reference vector for all waters\n planeAngs - all angles of plane-normal vector to reference vector for all waters\n \"\"\"\n\n #Call watorient to get all angles\n dipAngs, planeAngs = wl.watorient(Opos, Hpos, refVec, boxDim)\n\n return dipAngs, planeAngs\n\n\ndef binnedVolumePofN(Opos, volBins, numBins, binMask=None):\n \"\"\"Inputs:\n Opos - array of oxygen 3D coordinates\n volBins - volume (x,y,z coordinate) bin edges tiling the space to place waters into\n Form should be tuple of x, y, and z bin edge arrays\n Bins should be uniform (makes no sense to structure analysis this way otherwise)\n numBins - bin edges for histogramming number of waters in each volume of volBins\n binMask - boolean array of same dimension as number of bins in x, y, z\n Use to exclude some bins by changing certain coordinates to False\n Outputs:\n numWatHist - counts for number of waters in sub-volume of size edgeLxedgeLxedgeL\n \"\"\"\n\n #Create mask if necessary\n if binMask is None:\n binMask = np.ones((len(volBins[0])-1, len(volBins[1])-1, len(volBins[2])-1), dtype=bool)\n else:\n if binMask.shape == (len(volBins[0])-1, len(volBins[1])-1, len(volBins[2])-1):\n binMask = binMask\n else:\n print \"Dimensions of mask for spatial bins does not match dimensions of spatial bins. Quitting.\"\n sys.exit(2)\n\n #Want to use sphere rather than cube for statistics\n #So first find which bin each oxygen belongs to, then find distance\n #to center of bin and see if should exclude or not\n #Written in Fortran for speed\n hist = wl.binongrid(Opos, volBins[0], volBins[1], volBins[2])\n\n #Use numpy histogramming to count how many oxygens in each cube volume (doesn't use interior spheres)\n #hist, edges = np.histogramdd(Opos, bins=volBins, normed=False)\n\n #Now histogram number of waters in each subvolume, which will be P(N)\n numWatHist, watedges = np.histogram(hist[binMask].flatten(), bins=numBins, normed=False)\n\n return numWatHist\n\n#Should also define some function \"pointsInVol\" that creates binMask based on given set of points or some geometry that should not be included when finding waters (i.e. like a hard sphere or protein)\n\n\ndef HBondsGeneral(accPos, donPos, donHPos, boxL, accInds, donInds, donHInds, distCut=3.5, angCut=150.0):\n \"\"\"Wraps generalHbonds in the waterlib library to define H-bonds, and also returns their locations.\n Inputs:\n accPos - 3-dimensional vectors of acceptor heavy-atom positions\n donPos - 3D vectors of donor heavy-atom positions (if have multiple hydrogens, must list multiple times)\n donHPos - 3D vector of donor hydrogen positions (should be same length as donPos, which may have duplicates)\n accInds - indices of acceptor atoms\n donInds - indices of donor heavy-atoms\n donHInds - indices of donor hydrogen atoms\n boxL - box dimensions\n distCut - (default 3.5) heavy-atom to heavy-atom distance below which an H-bond may be defined \n angCut - (default 150.0) O-H---O angle cut-off, in degrees, above which an H-bond may be defined\n Outputs:\n NumHB - number of hydrogen bonds for acceptor/donor set provided\n HBlist - NumHB x 2 array with acceptor index in the 1st column and donor index in the 2nd\n HBloc - NumHB x 3 array of h-bond locations, which is halfway between the acceptor and donor H\n \"\"\"\n\n #First get H-bond matrix and locations\n HBboolMat = wl.generalhbonds(accPos, donPos, donHPos, boxL, distCut, angCut)\n HBboolMat = np.array(HBboolMat, dtype=bool)\n\n #Now parse through matrix, counting H-bonds and creating list of index pairs\n NumHB = np.sum(HBboolMat)\n HBlist = (-1)*np.ones((NumHB, 2))\n HBloc = np.zeros((NumHB, 3))\n HBlistCount = 0\n for i, abool in enumerate(HBboolMat):\n theseDonors = donInds[abool]\n if len(theseDonors) > 0:\n theseDonHPos = donHPos[abool]\n #Image donor H location around acceptor\n theseDonHPos = wl.reimage(theseDonHPos, accPos[i], boxL)\n for j, aDon in enumerate(theseDonors):\n HBlist[HBlistCount,:] = [accInds[i], aDon]\n HBloc[HBlistCount] = 0.5*(theseDonHPos[j] + accPos[i])\n HBlistCount += 1\n\n return NumHB, HBlist, HBloc\n\n\ndef computeSphericalFourierCoeffs(subPos, Pos, BoxDims, lowCut=0.0, highCut=3.413, minDegree=0, maxDegree=12):\n \"\"\"Computes the vectors of Fourier coefficients for each degree of a spherical harmonic expansion \n as described by Keys, Iacovella, and Glotzer, 2011. subPos is treated as the central atoms, \n while Pos should include the atoms that may potentially be neighbors.\n Inputs:\n subPos - positions of atoms to treat as the central atoms\n Pos - positions of all other atoms, which will be considered for neighbor-searching; can be same as subPos\n BoxDims - box dimensions so that minimum images may be used\n lowCut - (default 0.0) the lower cutoff for the radial shell\n highCut - (default 3.413) the upper cutoff for the radial shell\n minDegree - (default 0) the minimum spherical harmonic degree (l)\n maxDegree - (default 12) the maximum spherical harmonic degree (l)\n Outputs:\n coeffVecs - a len(subPos) x (1 + maxDegree - minDegree) x (2*maxDegree + 1) matrix\n For each central atom in subPos, a matrix of the complex-valued vectors (as rows)\n is provided. This still allows magnitudes to be easily evaluated, since real and\n imaginary parts of zero will contribute nothing to the magnitude\n numNeighbs - number of neighbors for each water molecule (necessary to compute global order parameters\n or coefficients by multiplying by this and the dividing by the total of the waters\n to \"average\" over)\n \"\"\"\n\n #Set up the output matrix now since know size\n coeffVecs = np.zeros((len(subPos), 1+maxDegree-minDegree, 2*maxDegree+1), dtype=complex)\n \n #And array to return number of neighbors for each water\n numNeighbs = np.zeros(len(subPos), dtype='float16')\n\n #Would be nice to combine neighbor searching with 3-body angle computation or H-bonding code\n #But then harder to efficiently implement different cutoffs...\n #So that might be too ambitious\n #Find neighbors within cutoff for ALL atoms in subPos\n #But make sure using efficient algorithm...\n #If subPos is same as Pos, use allnearneighbors instead\n if np.array_equal(subPos, Pos):\n nearNeighbs = wl.allnearneighbors(Pos, BoxDims, lowCut, highCut).astype(bool)\n else:\n nearNeighbs = wl.nearneighbors(subPos, Pos, BoxDims, lowCut, highCut).astype(bool)\n\n #Loop over each position in subPos and find neighbor positions in spherical coordinates\n for (i, apos) in enumerate(subPos):\n #Make sure have nearest neighbors...\n if len(Pos[nearNeighbs[i]]) > 0:\n tempPos = wl.reimage(Pos[nearNeighbs[i]], apos, BoxDims) - apos\n numNeighbs[i] = len(tempPos)\n #Compute radial distances... unfortunate that have to do this again, but maybe improve later\n rdists = np.linalg.norm(tempPos, axis=1)\n #And get polar and azimuthal angles\n polarang = np.arccos(tempPos[:,2]/rdists)\n azimang = np.arctan2(tempPos[:,1], tempPos[:,0]) #Using special arctan2 function to get quadrant right\n #Now compute Fourier coefficient vectors (i.e. have complex-valued component of coefficient vector\n #associated with each m value, where m = -l, -l+1, ... , l)\n #Loop over the desired number of coefficients to compute\n for l in range(minDegree, maxDegree + 1):\n thisvec = np.zeros(2*l + 1, dtype=complex)\n #Also note that have one vector for each neighbor, so must loop over neighbors\n for j in range(len(tempPos)):\n thisvec += sph_harm(np.arange(-l, l+1), l, azimang[j], polarang[j])\n thisvec /= len(tempPos)\n #And compute the magnitude of this vector of complex numbers\n coeffVecs[i,l-minDegree,:(2*l+1)] = thisvec\n\n return coeffVecs, numNeighbs\n\n\ndef get1BodyDOFs(coordO, coordH1, coordH2):\n \"\"\"Given O, H, and H 3D coordinates, identifies the 6 degrees of freedom for a single water\nNote that this is assuming an inhomogeneous system\nVector returned is oxygen x, y, z, followed by the spherical coordinate angles for the \ndipole vector relative to the oxygen, and the angle of rotation around the dipole vector\nCOORDINATES SHOULD ALREADY BE IMAGED.\n \"\"\"\n dofVec = np.zeros(6)\n dofVec[:3] = coordO[:]\n\n rOD = 0.5*(coordH1 + coordH2) - coordO\n rOD /= np.linalg.norm(rOD) #Could hard-code the rOD length for speed... maybe later\n\n rH1H2 = coordH2 - coordH1\n rH1H2 /= np.linalg.norm(rH1H2) #And could also hard-code this, too...\n\n #rOH1 = coordH1 - coordO\n #rOH1 /= np.linalg.norm(rOH1)\n\n #rOH2 = coordH2 - coordO\n #rOH2 /= np.linalg.norm(rOH2)\n\n unitX = np.array([0.0, 0.0, 1.0]) #Arbitrarily pick x axis to define reference plane for rotation about dipole\n\n #cross1 = np.cross(rOH1, rOH2)\n #cross1 /= np.linalg.norm(cross1)\n\n crossX = np.cross(rOD, unitX)\n crossX /= np.linalg.norm(crossX)\n\n dofVec[3] = np.arctan2(rOD[1], rOD[0]) #Making sure to use arctan2 to cover range [-pi, pi]\n dofVec[4] = np.arccos(rOD[2]) #Taking last element is same as dotting with unit Z vector\n dofVec[5] = np.arccos(np.dot(rH1H2, crossX))\n #dofVec[5] = np.arccos(np.dot(cross1, crossX))\n\n return dofVec\n\n\ndef get2BodyDOFs(coordO1, coordH11, coordH12, coordO2, coordH21, coordH22):\n \"\"\"Given 3D coordinates for all atoms in two water molecules, computes specifically 2-body degrees of freedom\nNote that returns only 6 degrees of freedom, so excludes the DOFs for the first water\nONLY gives those relevant to relative distance and orientation of two waters\nOrder in returned vector is rO1O2, theta1, theta2, phi, chi1, chi2 (see Lazaridis and Karplus for definitions)\nCOORDINATES SHOULD ALREADY BE IMAGED\n \"\"\"\n dofVec = np.zeros(6)\n\n rO1O2 = coordO2 - coordO1\n dofVec[0] = np.linalg.norm(rO1O2)\n rO1O2 /= dofVec[0]\n rO2O1 = -rO1O2\n\n rO1D1 = 0.5*(coordH11 + coordH12) - coordO1\n rO1D1 /= np.linalg.norm(rO1D1) #Could hard-code to speed up... may do later\n\n rO2D2 = 0.5*(coordH21 + coordH22) - coordO2\n rO2D2 /= np.linalg.norm(rO2D2)\n\n #Need to figure out which H is closer to other oxygen to define rH11H12 according to Lazaridis and Karplus, 1996\n if np.linalg.norm(coordH11 - coordO2) <= np.linalg.norm(coordH12 - coordO2):\n rH11H12 = coordH12 - coordH11\n else:\n rH11H12 = coordH11 - coordH12\n rH11H12 /= np.linalg.norm(rH11H12) #Again, could hard code if wanted\n\n if np.linalg.norm(coordH21 - coordO1) <= np.linalg.norm(coordH22 - coordO1):\n rH21H22 = coordH22 - coordH21\n else:\n rH21H22 = coordH21 - coordH22\n rH21H22 /= np.linalg.norm(rH21H22)\n\n cross1 = np.cross(rO1O2, rO1D1)\n cross1 /= np.linalg.norm(cross1)\n\n cross2 = np.cross(rO2D2, rO2O1)\n cross2 /= np.linalg.norm(cross2)\n\n dofVec[1] = np.arccos(np.dot(rO1D1, rO1O2))\n dofVec[2] = np.arccos(np.dot(rO2D2, rO2O1))\n dofVec[3] = np.arccos(np.dot(cross1, cross2))\n dofVec[4] = np.arccos(np.dot(rH11H12, cross1))\n dofVec[5] = np.arccos(np.dot(rH21H22, cross2))\n\n return dofVec\n\n\ndef get3BodyDOFs(coordO1, coordH11, coordH12, coordO2, coordH21, coordH22, coordO3, coordH31, coordH32):\n \"\"\"Like above function, but gives 6 DOFs pertaining to just the 3-body degrees of freedom\nOrder in returned vector is rO1O3 (distance), theta3b (three-body angle),\nomega (rotation of 3rd water around O1-O3 vector), then theta3, phi3, and chi3\n(last three defined as for the second water in the 2-body DOFs, but for just the third water)\nCOORDINATES SHOULD ALREADY BE IMAGED\n \"\"\"\n dofVec = np.zeros(6)\n\n rO1O2 = coordO2 - coordO1\n rO1O2 /= np.linalg.norm(rO1O2)\n rO2O1 = -rO1O2\n\n rO1O3 = coordO3 - coordO1\n dofVec[0] = np.linalg.norm(rO1O3)\n rO1O3 /= dofVec[0]\n rO3O1 = -rO1O3\n\n rO1D1 = 0.5*(coordH11 + coordH12) - coordO1\n rO1D1 /= np.linalg.norm(rO1D1)\n\n rO3D3 = 0.5*(coordH31 + coordH32) - coordO3\n rO3D3 /= np.linalg.norm(rO3D3)\n\n if np.linalg.norm(coordH31 - coordO1) <= np.linalg.norm(coordH32 - coordO1):\n rH31H32 = coordH32 - coordH31\n else:\n rH31H32 = coordH31 - coordH32\n rH31H32 /= np.linalg.norm(rH31H32)\n\n cross12 = np.cross(rO1O2, rO1D1)\n cross12 /= np.linalg.norm(cross12)\n\n cross13 = np.cross(rO1O3, rO1D1)\n cross13 /= np.linalg.norm(cross13)\n\n cross31 = np.cross(rO3D3, rO3O1)\n cross31 /= np.linalg.norm(cross31)\n\n rperp = rO1O3 - np.dot(rO1O2, rO1O3)*rO1O2\n rperp /= np.linalg.norm(rperp)\n\n dofVec[1] = np.arccos(np.dot(rO1O2, rO1O3))\n dofVec[2] = np.arccos(np.dot(rperp, cross12))\n dofVec[3] = np.arccos(np.dot(rO3D3, rO3O1))\n dofVec[4] = np.arccos(np.dot(cross13, cross31))\n dofVec[5] = np.arccos(np.dot(rH31H32, cross31))\n\n return dofVec\n\n\ndef distanceMetric1B(vec1, vec2, Rsq=(0.09572**2), sintw=(np.sin(104.52*np.pi/180.0)**2)):\n \"\"\"Computes distance metric appropriate to 1-body DOFs.\n A direct Euclidean distance is not appropriate since using curvilinear coordinates, \n so this defines a distance utilizing local curvature that is exact for very small\n differences. It comes from Taylor-expanding the formula for Euclidean distance in \n spherical coordinates with respect to both angles to second order.\n \"\"\"\n diffs = (vec2 - vec1)**2\n dist = np.sqrt(diffs[0] + diffs[1] + diffs[2] + Rsq*diffs[3]\n + Rsq*np.sin(vec2[3])*np.sin(vec1[3])*diffs[4]\n + Rsq*sintw*diffs[5])\n return dist\n\n\ndef distanceMetric2B(vec1, vec2, Rsq=(0.09572**2), sintw=(np.sin(104.52*np.pi/180.0)**2)):\n \"\"\"Computes distance metric appropriate to 2-body DOFs.\n A direct Euclidean distance is not appropriate since using curvilinear coordinates, \n so this defines a distance utilizing local curvature that is exact for very small\n differences. It comes from Taylor-expanding the formula for Euclidean distance in \n spherical coordinates with respect to both angles to second order.\n Note that this includes 1-body degrees of freedom, so expects 12-dimensional vectors.\n \"\"\"\n diffs = (vec2 - vec1)**2\n dist = np.sqrt(diffs[0] + diffs[1] + diffs[2] + Rsq*diffs[3]\n + Rsq*np.sin(vec2[3])*np.sin(vec1[3])*diffs[4]\n + Rsq*sintw*diffs[5]\n + diffs[6] + Rsq*diffs[7] + Rsq*diffs[8]\n + Rsq*np.sin(vec2[8])*np.sin(vec1[8])*diffs[9]\n + Rsq*sintw*diffs[10] + Rsq*sintw*diffs[11])\n return dist\n\n\ndef distanceMetric3B(vec1, vec2, Rsq=(0.09572**2), sintw=(np.sin(104.52*np.pi/180.0)**2)):\n \"\"\"Computes distance metric appropriate to 3-body DOFs.\n A direct Euclidean distance is not appropriate since using curvilinear coordinates, \n so this defines a distance utilizing local curvature that is exact for very small\n differences. It comes from Taylor-expanding the formula for Euclidean distance in \n spherical coordinates with respect to both angles to second order.\n Note that this includes 1- and 2-body degrees of freedom, so expects 18-dimensional vectors.\n \"\"\"\n diffs = (vec2 - vec1)**2\n dist = np.sqrt(diffs[0] + diffs[1] + diffs[2] + Rsq*diffs[3]\n + Rsq*np.sin(vec2[3])*np.sin(vec1[3])*diffs[4]\n + Rsq*sintw*diffs[5]\n + diffs[6] + Rsq*diffs[7] + Rsq*diffs[8]\n + Rsq*np.sin(vec2[8])*np.sin(vec1[8])*diffs[9]\n + Rsq*sintw*diffs[10] + Rsq*sintw*diffs[11]\n + diffs[12] + vec2[12]*vec1[12]*diffs[13]\n + vec2[12]*vec1[12]*np.sin(vec2[13])*np.sin(vec1[13])*diffs[14]\n + Rsq*diffs[15]\n + Rsq*np.sin(vec2[15])*np.sin(vec1[15])*diffs[16]\n + Rsq*sintw*diffs[17])\n return dist\n\n", "meta": {"hexsha": "7e0e24717ebd3426596a08735d739279019f3726", "size": 36462, "ext": "py", "lang": "Python", "max_stars_repo_path": "libraries/water_properties.py", "max_stars_repo_name": "JIMonroe/Surface_Affinities_Optimization", "max_stars_repo_head_hexsha": "94853571c690b099362431aac32d26611134a009", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "libraries/water_properties.py", "max_issues_repo_name": "JIMonroe/Surface_Affinities_Optimization", "max_issues_repo_head_hexsha": "94853571c690b099362431aac32d26611134a009", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "libraries/water_properties.py", "max_forks_repo_name": "JIMonroe/Surface_Affinities_Optimization", "max_forks_repo_head_hexsha": "94853571c690b099362431aac32d26611134a009", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-03-07T11:52:27.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-07T11:52:27.000Z", "avg_line_length": 42.3976744186, "max_line_length": 199, "alphanum_fraction": 0.6938730733, "include": true, "reason": "import numpy,import scipy,from scipy", "num_tokens": 10635, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5813030761371503, "lm_q2_score": 0.3345894279828469, "lm_q1q2_score": 0.19449786372939842}} {"text": "import networkx as nx\nfrom networkx.algorithms import isomorphism\nimport math\nimport re\n\nORIG_PPI = [[\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 234) ('type_1' 'type_1') ('type_1' 234) (197 234) (234 197)]\", 844],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 478) ('type_1' 'type_1') ('type_1' 478) (197 234) (197 478) (234 197) (478 197)]\", 73],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 234) ('type_1' 'type_1') ('type_1' 234) (197 234) (234 197) (234 338) (338 234)]\", 53],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 234) ('type_1' 'type_1') ('type_1' 234) (197 234) (234 197) (234 738) (234 800) (738 234) (800 234)]\", 25],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 328) ('type_1' 'type_1') ('type_1' 328) (197 478) (478 197) (478 479) (328 479) (479 328) (479 478)]\", 4],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 314) ('type_1' 'type_1') ('type_1' 314) (114 314) (314 114) (314 331) (314 1120) (294 331) (331 294) (331 314)]\", 11],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 314) ('type_1' 'type_1') ('type_1' 314) (114 314) (314 114) (314 1120)]\", 14],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 275) ('type_1' 'type_1') ('type_1' 275) (275 334) (275 375) (275 589) (275 1069) (334 275) (375 275) (589 275) (1069 275)]\", 21],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 314) ('type_1' 'type_1') ('type_1' 314) (314 1120)]\", 60],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 558) ('type_1' 'type_1') ('type_1' 558) (558 559) (558 571) (558 654) (558 1328) (558 1329) (559 558) (571 558) (654 558) (1328 558) (1329 558)]\", 36],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 239) ('type_1' 'type_1') ('type_1' 239) (239 1056) (239 1107) (239 1331) (1056 239)]\", 12],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 43) ('type_1' 'type_1') ('type_1' 43) (42 43)]\", 7],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 1059) ('type_0' 925) ('type_1' 'type_1') ('type_1' 1059) ('type_1' 925) (925 1185) (1185 925) (1185 1059) (1059 1185)]\", 12],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 1440) ('type_0' 749) ('type_0' 1551) ('type_1' 'type_1') ('type_1' 1440) ('type_1' 749) ('type_1' 1551) (749 750) (750 749) (750 1440) (750 1551) (1440 750) (1551 750)]\", 4],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 1) ('type_0' 5) ('type_1' 'type_1') ('type_1' 1) ('type_1' 5) (1 12) (1 58) (1 188) (12 1) (12 5) (58 1) (58 5) (58 609) (188 1) (188 5) (5 12) (5 58) (5 188) (5 609) (609 5) (609 58)]\", 1]]\n\nCL_PPI = [[\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 215) ('type_1' 'type_1') ('type_1' 215) (215 807)]\", 682],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 215) ('type_1' 'type_1') ('type_1' 215) (215 437) (215 807)]\", 15],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 602) ('type_1' 'type_1') ('type_1' 602) (215 807) (602 215)]\", 13],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 215) ('type_1' 'type_1') ('type_1' 215) (1064 215)]\", 488],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 770) ('type_1' 'type_1') ('type_1' 76) (76 770)]\", 392],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 64) ('type_1' 'type_1') ('type_1' 64) (5 64) (64 5)]\", 56],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 30) ('type_1' 'type_1') ('type_1' 30) (30 503) (503 30) (777 30)]\", 1],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 49) ('type_1' 'type_1') ('type_1' 9) (9 49) (49 9)]\", 12],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 10) ('type_1' 'type_1') ('type_1' 10) ('type_1' 6) (6 10) (10 6)]\", 2],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 9) ('type_0' 10) ('type_1' 'type_1') ('type_1' 9) ('type_1' 10) (9 10)]\", 2],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 10) ('type_0' 50) ('type_1' 'type_1') ('type_1' 50) (10 50) (50 10)]\", 4],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 20) ('type_0' 244) ('type_1' 'type_1') ('type_1' 33) ('type_1' 6) (3 6) (3 8) (3 33) (3 244) (6 8) (6 20) (8 20) (8 33) (8 244) (33 3) (33 6) (33 20) (244 3) (244 8) (244 20) (244 33) (20 8)]\", 1]]\n\nER_PPI = [[\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 1480) ('type_1' 'type_1') ('type_1' 1281) (1281 1480)]\", 1303],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 1643) ('type_1' 'type_1') ('type_1' 1643) (1643 1281)]\", 127],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 1437) ('type_1' 'type_1') ('type_1' 1437) (1004 1437)]\", 155],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 581) ('type_1' 'type_1') ('type_1' 736) (581 736)]\", 102],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 650) ('type_1' 'type_1') ('type_1' 537) (537 650) (650 537)]\", 2],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 650) ('type_1' 'type_1') ('type_1' 650) (537 650) (650 537)]\", 6],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 32) ('type_1' 'type_1') ('type_1' 170) (4 32) (4 252) (170 4) (170 32) (252 4) (252 170)]\", 1],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 17) ('type_0' 74) ('type_1' 'type_1') ('type_1' 8) ('type_1' 13) (1 8) (1 13) (1 17) (3 1) (3 74) (8 3) (8 17) (13 1) (13 3) (17 74) (74 3)]\", 1]]\n\nORIG_BLOGS = [[\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 896) ('type_1' 'type_1') ('type_1' 446) (896 446)]\", 323],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 896) ('type_1' 'type_1') ('type_1' 446) (896 446) (913 446)]\", 6],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 515) ('type_1' 'type_1') ('type_1' 515) (515 446)]\", 127],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 772) ('type_1' 'type_1') ('type_1' 772) (446 772)]\", 226],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 652) ('type_1' 'type_1') ('type_1' 446) (446 652) (652 446)]\", 88],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 1068) ('type_1' 'type_1') ('type_1' 163) (92 163) (1066 163) (1068 163)]\", 3],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 887) ('type_1' 'type_1') ('type_1' 887) (885 887) (887 885)]\", 155],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 987) ('type_1' 'type_1') ('type_1' 871) (871 987)]\", 99],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 193) ('type_0' 265) ('type_1' 'type_1') ('type_1' 265) (193 265) (265 193)]\", 39],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 193) ('type_1' 'type_1') ('type_1' 193) (193 383) (193 679) (193 680)]\", 8],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 209) ('type_1' 'type_1') ('type_1' 209) ('type_1' 210) (209 210)]\", 14],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 4) ('type_0' 293) ('type_1' 'type_1') ('type_1' 4) (293 4)]\", 21],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 4) ('type_1' 'type_1') ('type_1' 4) (405 4) (657 4)]\", 9],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 135) ('type_1' 'type_1') ('type_1' 317) ('type_1' 135) (135 317) (317 135)]\", 13],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 106) ('type_0' 44) ('type_1' 'type_1') ('type_1' 106) ('type_1' 44) (44 106) (106 44)]\", 11],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 107) ('type_0' 44) ('type_1' 'type_1') ('type_1' 107) (107 44)]\", 16],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 512) ('type_1' 'type_1') ('type_1' 512) ('type_1' 511) (511 512)]\", 12],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 426) ('type_0' 427) ('type_1' 'type_1') ('type_1' 426) ('type_1' 427) (426 427)]\", 9],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 64) ('type_0' 42) ('type_0' 4) ('type_1' 'type_1') ('type_1' 64) ('type_1' 2) (2 4) (2 42) (4 42) (4 64) (42 2) (42 4) (42 64) (64 2) (64 4) (64 42)]\", 1],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 47) ('type_0' 7) ('type_1' 'type_1') ('type_1' 3) ('type_1' 47) (1 3) (1 7) (1 47) (3 1) (3 7) (3 47) (7 1) (7 3) (47 7)]\", 1]]\n\n\nCL_BLOGS = [[\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 208) ('type_1' 'type_1') ('type_1' 208) (208 257)]\", 191],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 208) ('type_1' 'type_1') ('type_1' 208) (208 257) (776 208)]\", 7],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 208) ('type_1' 'type_1') ('type_1' 514) (514 208)]\", 237],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 520) ('type_1' 'type_1') ('type_1' 208) (520 208)]\", 321],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 208) ('type_1' 'type_1') ('type_1' 208) (776 208)]\", 345],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 114) ('type_1' 'type_1') ('type_1' 114) ('type_1' 1155) (114 1155)]\", 5],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 128) ('type_1' 'type_1') ('type_1' 70) (70 128) (128 70)]\", 50],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 274) ('type_1' 'type_1') ('type_1' 274) (45 274) (274 45)]\", 26],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 14) ('type_1' 'type_1') ('type_1' 68) ('type_1' 14) (14 68) (68 14)]\", 7],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 29) ('type_0' 14) ('type_1' 'type_1') ('type_1' 14) (14 29) (29 14)]\", 10],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 29) ('type_0' 46) ('type_1' 'type_1') ('type_1' 29) (29 46)]\", 6],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 29) ('type_0' 14) ('type_1' 'type_1') ('type_1' 29) ('type_1' 14) (14 29) (29 14)]\", 4],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 17) ('type_0' 19) ('type_1' 'type_1') ('type_1' 17) ('type_1' 19) (19 17)]\", 4],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 1) ('type_0' 12) ('type_0' 5) ('type_1' 'type_1') ('type_1' 1) ('type_1' 5) (1 12) (1 26) (12 1) (12 5) (12 26) (26 1) (26 12) (5 12)]\", 1]]\n\nER_BLOGS = [[\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 877) ('type_1' 'type_1') ('type_1' 1121) (877 1121)]\", 54],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 1075) ('type_1' 'type_1') ('type_1' 877) (877 1075)]\", 1032],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 1109) ('type_1' 'type_1') ('type_1' 1109) (877 1109)]\", 48],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 1152) ('type_1' 'type_1') ('type_1' 1152) (1152 1117)]\", 18],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 141) ('type_1' 'type_1') ('type_1' 141) (141 1080) (1080 141)]\", 4],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 406) ('type_1' 'type_1') ('type_1' 540) (406 540) (540 406)]\", 57],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_0' 73) ('type_0' 6) ('type_1' 'type_1') ('type_1' 73) (73 6)]\", 5],\\\n [\"[('type_0' 'type_0') ('type_0' 'type_1') ('type_1' 'type_1') (1 7) (1 23) (5 1) (5 7) (7 23) (10 1) (10 8) (23 1) (23 7) (23 8) (23 10) (8 5) (8 10)]\", 1]]\n\ndef graph_from_string(the_string):\n pieces = re.split('\\[\\(| |\\) \\(|\\)\\]', the_string)\n pieces = pieces[1:(len(pieces)-1)]\n nodes = set()\n for piece in pieces:\n nodes.add(piece)\n G = nx.DiGraph()\n for node in nodes:\n G.add_node(node)\n idx = 0\n while idx < len(pieces):\n G.add_edge(pieces[idx], pieces[idx + 1])\n idx += 2\n return G\n\ndef make_graph_list(the_list):\n return [[graph_from_string(x[0]), x[1]] for x in the_list]\n\ndef merge_graph_lists(list_a, list_b, list_c):\n main_list = [[x[0], x[1], 0, 0] for x in list_a]\n for graph_and_count_b in list_b:\n found_match = False\n for i in range(0, len(main_list)):\n gm = isomorphism.DiGraphMatcher(graph_and_count_b[0], main_list[i][0])\n if gm.is_isomorphic():\n main_list[i][2] = graph_and_count_b[1]\n found_match = True\n break\n if not found_match:\n main_list.append([graph_and_count_b[0], 0, graph_and_count_b[1], 0])\n\n for graph_and_count_c in list_c:\n found_match = False\n for main_gc in main_list:\n gm = isomorphism.DiGraphMatcher(graph_and_count_c[0], main_gc[0])\n if gm.is_isomorphic():\n main_gc[3] = graph_and_count_c[1]\n found_match = True\n break\n if not found_match:\n main_list.append([graph_and_count_c[0], 0, 0, graph_and_count_c[1]])\n return main_list\n\ndef merged_probabilities(merged_lists):\n sum_a = 0.0\n sum_b = 0.0\n sum_c = 0.0\n for list_element in merged_lists:\n sum_a += list_element[1] + 1.0\n sum_b += list_element[2] + 1.0\n sum_c += list_element[3] + 1.0\n return [[x[0], (x[1] + 1.0) / sum_a, (x[2] + 1.0) / sum_b, (x[3] + 1.0) / sum_c] for x in merged_lists]\n\ndef ratios(prob_list, idx_1, idx_2):\n ratio_list = [[x[0], x[idx_1] / x[idx_2] if x[idx_1] > x[idx_2] else -1.0 * x[idx_2] / x[idx_1]] for x in prob_list]\n ratio_list.sort(key=(lambda x: -1.0 * abs(x[1])))\n return ratio_list\n\ndef kl_contributions(prob_list, idx_1, idx_2):\n contributions = [[x[0], -1.0 * x[idx_1] * math.log(x[idx_2] / x[idx_1])] for x in prob_list]\n contributions.sort(key=(lambda x: -1.0 * x[1]))\n return contributions\n\ndef KL_divergence(kl_contributions):\n kl = 0.0\n for item in kl_contributions:\n kl += item[1]\n return kl\n\ndef display_kl_contributions(some_kl, title):\n print(title)\n for i in range(0, min(len(some_kl), 3)):\n edges = list(some_kl[i][0].edges())\n edges.sort()\n print(\"%s %s\" % (edges, some_kl[i][1]))\n\norig_ppi_list = make_graph_list(ORIG_PPI)\ncl_ppi_list = make_graph_list(CL_PPI)\ner_ppi_list = make_graph_list(ER_PPI)\nmerged_list = merge_graph_lists(orig_ppi_list, cl_ppi_list, er_ppi_list)\nprobs_list = merged_probabilities(merged_list)\norig_cl_kl_contributions = kl_contributions(probs_list, 1, 2)\norig_er_kl_contributions = kl_contributions(probs_list, 1, 3)\ndisplay_kl_contributions(orig_cl_kl_contributions, \"PPI: Original vs CL\")\ndisplay_kl_contributions(orig_er_kl_contributions, \"PPI: Original vs ER\")\norig_cl_kl = KL_divergence(orig_cl_kl_contributions)\nprint(\"orig_cl_kl: %s\" % orig_cl_kl)\norig_er_kl = KL_divergence(orig_er_kl_contributions)\nprint(\"orig_er_kl: %s\" % orig_er_kl)\n\norig_blogs_list = make_graph_list(ORIG_BLOGS)\ncl_blogs_list = make_graph_list(CL_BLOGS)\ner_blogs_list = make_graph_list(ER_BLOGS)\nmerged_list = merge_graph_lists(orig_blogs_list, cl_blogs_list, er_blogs_list)\nprobs_list = merged_probabilities(merged_list)\norig_cl_kl_contributions = kl_contributions(probs_list, 1, 2)\norig_er_kl_contributions = kl_contributions(probs_list, 1, 3)\ndisplay_kl_contributions(orig_cl_kl_contributions, \"Blogs: Original vs CL\")\ndisplay_kl_contributions(orig_er_kl_contributions, \"Blogs: Original vs ER\")\norig_cl_kl = KL_divergence(orig_cl_kl_contributions)\nprint(\"orig_cl_kl: %s\" % orig_cl_kl)\norig_er_kl = KL_divergence(orig_er_kl_contributions)\nprint(\"orig_er_kl: %s\" % orig_er_kl)\n", "meta": {"hexsha": "7e63f0c03aba591391f3d69672f24b0feb4403e7", "size": 15555, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/bugge/difference_in_extracted_rules.py", "max_stars_repo_name": "Abdumaleek/infinity-mirror", "max_stars_repo_head_hexsha": "b493c5602d9e4bcf374b748e9b80e7c85be54a88", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2020-03-13T02:54:03.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-18T02:33:12.000Z", "max_issues_repo_path": "src/bugge/difference_in_extracted_rules.py", "max_issues_repo_name": "Abdumaleek/infinity-mirror", "max_issues_repo_head_hexsha": "b493c5602d9e4bcf374b748e9b80e7c85be54a88", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-11-10T19:47:00.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-10T01:24:59.000Z", "max_forks_repo_path": "src/bugge/difference_in_extracted_rules.py", "max_forks_repo_name": "Abdumaleek/infinity-mirror", "max_forks_repo_head_hexsha": "b493c5602d9e4bcf374b748e9b80e7c85be54a88", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-05-24T21:54:44.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-24T21:54:44.000Z", "avg_line_length": 80.5958549223, "max_line_length": 262, "alphanum_fraction": 0.5540340726, "include": true, "reason": "import networkx,from networkx", "num_tokens": 7041, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6187804337438501, "lm_q2_score": 0.3140505321516081, "lm_q1q2_score": 0.19432832450225898}} {"text": "from os.path import join, basename\nfrom os import environ\nfrom sys import stderr\n\nimport numpy as np\nfrom SetCoverPy import setcover, mathutils\nfrom matplotlib import pyplot as plt\nimport seaborn as sns\nfrom astropy.io import fits\n\nfrom redmonster.datamgr.io2 import read_ndArch\nfrom _linelist import __linelist__\n\n# Dict of plates and corresponding MJDS\nplates = {8123:56931}\n\n# version of redmonster reductions to use\nrmver = 'v1_1_0'\n\n# chi2 threshold to use in set cover distance matrix\nmindist = 0.48\n\nrmdir = join( environ['REDMONSTER_SPECTRO_REDUX'], environ['RUN2D'],\n '%s' % rmver)\n\n# loop over all plates\nfor plate in plates.keys():\n # list of fibers classified as galaxy with zwarning=0\n fibers = []\n zs = []\n # open redmonster file\n hdu = fits.open( join( rmdir, '%s' % plate, 'redmonster-%s-%s.fits'\n % (plate, plates[plate]) ) )\n # open data file\n idlpath = join( environ['BOSS_SPECTRO_REDUX'], environ['RUN2D'],\n '%s' % plate, 'spPlate-%s-%s.fits' % (plate, plates[plate]) )\n hduidl = fits.open(idlpath)\n\n # create wavelength solution\n wave = 10**(hduidl[0].header['COEFF0'] + hduidl[0].header['COEFF1'] *\n np.arange(hduidl[0].header['NAXIS1']))\n\n # loop over fibers and keep those classed as gal with zwarn=0\n for i,fiber in enumerate(hdu[1].data.FIBERID):\n if fiber != 516:\n if hdu[1].data.ZWARNING[i] == 0:\n if hdu[1].data.CLASS1[i] == 'ssp_galaxy_glob':\n fibers.append(fiber)\n zs.append(hdu[1].data.Z1[i])\n\n # nfibers x nfibers matrix to hold distances\n distmat = np.zeros( (len(fibers), len(fibers)) )\n\n # binary distance matrix\n #binmat = np.zeros( distmat.shape )\n\n\n # calculate distance from each fiber to every other fiber\n for i in range(len(fibers)):\n # set data and such for this fiber\n fiber1 = fibers[i]\n data1 = hduidl[0].data[fiber1]\n sigma1 = hduidl[1].data[fiber1]\n wave1 = wave / (1+zs[i])\n # normalize slow spectrum to mean value between 4500 and 4700 A, and\n # scale errors accordingly\n high1 = np.abs(wave1-4700).argmin()\n low1 = np.abs(wave1-4500).argmin()\n mean1 = np.mean(data1[low1:high1+1])\n data1 /= mean1\n sigma1 *= mean1**2\n # loop over upper half of matrix and fill bottom half with symmetry\n for j in range(i, len(fibers)):\n fiber2 = fibers[j]\n stderr.write(\"\\rTotal: %s i: %s j:%s\" % (len(fibers), (i+1), (j+1)) )\n # convert to rest-frame wavelength\n wave2 = wave / (1+zs[j])\n # crop spectra to only overlapping region\n if wave1[0] < wave2[0]:\n low_bound = np.abs(wave1 - wave2[0]).argmin()\n data1_2 = data1[low_bound:]\n sigma1_2 = sigma1[low_bound:]\n wave1_2 = wave1[low_bound:]\n high_bound = np.abs(wave2 - wave1[-1]).argmin()\n data2 = hduidl[0].data[fiber2][:high_bound+1]\n sigma2 = hduidl[1].data[fiber2][:high_bound+1]\n wave2 = wave2[:high_bound+1]\n elif wave1[0] > wave2[0]:\n low_bound = np.abs(wave2 - wave1[0]).argmin()\n data2 = hduidl[0].data[fiber2][low_bound:]\n sigma2 = hduidl[1].data[fiber2][low_bound:]\n wave2 = wave2[low_bound:]\n high_bound = np.abs(wave1 - wave2[-1]).argmin()\n data1_2 = data1[:high_bound+1]\n sigma1_2 = sigma1[:high_bound+1]\n wave1_2 = wave1[:high_bound+1]\n else: # same redshift (most likely same spectrum)\n data1_2 = data1\n sigma1_2 = sigma1\n data2 = hduidl[0].data[fiber2]\n sigma2 = hduidl[1].data[fiber2]\n # normalize fast spectrum to mean value between 4500 and 4700 A, and\n # scale errors accordingly\n low2 = np.abs(wave2-4500).argmin()\n high2 = np.abs(wave2-4700).argmin()\n mean2 = np.mean(data2[low2:high2+1])\n data2 /= mean2\n sigma2 *= mean2**2\n # convert inverse variance to sigma squared and add in quadrature\n variance = (1/sigma1_2) + (1/sigma2)\n # calculate reduced chi2 as distance\n distmat[i][j] = distmat[j][i] = np.sum( (data1_2 - data2)**2 /\\\n variance ) / data1.shape[0]\n #if distmat[i][j] < mindist:\n #binmat[i][j] = 1\n print \" \"\n binmat = distmat < mindist\n cost = np.ones(binmat.shape[0])\n #cost = 1 / hdu\n\n g = setcover.SetCover(binmat, cost)\n #g.greedy()\n g.SolveSCP()\n\n # Get the archetype indices\n iarchetype = np.nonzero(g.s)[0]\n print \"Number of archetypes: %s\\n\" % iarchetype.shape\n\n # How many are covered by each archetype?\n n_rep = np.sum(binmat[:, iarchetype], axis=0)\n for i,arch in enumerate(iarchetype):\n if n_rep[i] == 1:\n print \"Archetype #%s represents %s spectra.\" % (arch, n_rep[i])\n elif n_rep[i] > 1:\n print \"Archetype #%s represents %i spectra.\" % (arch, n_rep[i])\n\n # Get instances represented by each archetype\n stacks = [] # place to store stacks\n all_counts = []\n restwave = 10**(2.6990 + np.arange(20000) * 0.0001)\n redshifts = []\n fibnums = []\n archfibs = []\n j = -1\n for i in xrange(iarchetype.size):\n if n_rep[i] > 1:\n j += 1\n redshifts.append([])\n fibnums.append([])\n this_stack = np.zeros(20000)\n counts = np.zeros(20000)\n # binary vector of which spectra are represented by this archetype\n itmp = binmat[:, iarchetype[i]]\n # list of fiber numbers represented\n fibrep = np.asarray(fibers)[itmp]\n for fiber in fibrep:\n fiberind = np.where((np.asarray(fibers)-fiber) == 0)[0][0]\n fiberlen = hduidl[0].data[fiber-1].shape[-1]\n this_wave = wave / (1 + zs[fiberind])\n wave0 = np.abs(restwave - this_wave[0]).argmin()\n this_stack[wave0:wave0+fiberlen] += hduidl[0].data[fiber-1]\n counts[wave0:wave0+fiberlen] += 1\n redshifts[j].append(zs[fiberind])\n fibnums[j].append(fiber)\n this_stack /= counts\n stacks.append(this_stack)\n all_counts.append(counts)\n archfibs.append( fibers[iarchetype[i]] )\n\n # Crop stacks to regions with at least XXX% of max counts\n mastercounts = []\n masterstacks = []\n masterwave = []\n for i,counts in enumerate(all_counts):\n w = (counts >= (0.3*np.max(counts)))\n mastercounts.append(counts[w])\n masterstacks.append(stacks[i][w])\n masterwave.append(restwave[w])\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n", "meta": {"hexsha": "64cdc1e1c3da9da19f6a56b11a1b0e838261cb5b", "size": 6936, "ext": "py", "lang": "Python", "max_stars_repo_path": "python/elg_templates/setcoverstacks.py", "max_stars_repo_name": "timahutchinson/elg-templates", "max_stars_repo_head_hexsha": "5cd2ec6e5b6a05ddb4b79cf64a8e4c79d31a0c72", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "python/elg_templates/setcoverstacks.py", "max_issues_repo_name": "timahutchinson/elg-templates", "max_issues_repo_head_hexsha": "5cd2ec6e5b6a05ddb4b79cf64a8e4c79d31a0c72", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "python/elg_templates/setcoverstacks.py", "max_forks_repo_name": "timahutchinson/elg-templates", "max_forks_repo_head_hexsha": "5cd2ec6e5b6a05ddb4b79cf64a8e4c79d31a0c72", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.5692307692, "max_line_length": 81, "alphanum_fraction": 0.5625720877, "include": true, "reason": "import numpy,from astropy", "num_tokens": 1944, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.682573734412324, "lm_q2_score": 0.28457600421652673, "lm_q1q2_score": 0.19424410592221192}} {"text": "# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Wed Aug 21 12:33:36 2019\n\nCombined new simulation using missing data and finite mutation model\n\n@author: marianne aspbury\n\"\"\"\n\nimport msprime\nimport tsinfer\nimport numpy as np\nfrom IPython.display import display\nfrom IPython.display import SVG\n\nimport pickle\nimport random # to pick from list of poss roots of subtree\nfrom IndividualClass import Individual # might say unused, but not true, needed to read pickled file\nfrom truncate_ts_samples import truncate_ts_samples as truncate_ts_samples\n\n### import the trees ###\nfile_loc = 'C:\\\\Users\\\\mazmysta\\OneDrive - Nexus365\\\\BDI_proj\\\\HIV_Transmission_Networks_WillProbert\\\\19-08-08-first_example_network\\\\'\n\nwith open(file_loc + 'pickled_data_all.pickle', 'rb') as f:\n total_tree = pickle.load(f)\n\n#proof it works\nprint('Pickle loaded, 1st root num kids: {}'.format(total_tree['-1_-1'].total_children_num))\n\n# Saving list of people with desired num kids beneath\nsamples_poss = []\ndesired_overall_children = 5 ## Seemingly my max is 30 with 10 samples, 100 pop size and 1000 length genome.\n\nfor key in total_tree:\n if total_tree[key].total_children_num == desired_overall_children:\n samples_poss.append(key)\n\nprint(len(samples_poss))\n# 8 for kids = 100\n\n#pick only one random sample\nrandom.seed(4) # repeatable choice(s) - sequence same\nstart = random.choice(samples_poss)\n#start='58582_0'\nprint(start)\n\nprint(total_tree[start].infected_others)\n\ndef preorder_traversal(u):\n all_nodes = []\n stack = [u]\n while len(stack) > 0:\n v = stack.pop()\n if total_tree[v].direct_children_num > 0: #Returns True if the specified node is not a leaf\n stack.extend(total_tree[v].infected_others)\n all_nodes.append(v)\n return all_nodes\n\nlist_of_root_and_kids = preorder_traversal(start)\n\n#print(preorder_traversal(start), len(preorder_traversal(start)))\n\n#print(list(set(list_of_root_and_kids) - set(start)))\n\n# all info required for mini-transmission chain\n#for item in list_of_root_and_kids:\n# print(item, total_tree[item].infected_others,\n# total_tree[item].time_infected_others,\n# total_tree[item].age_birth,\n# total_tree[item].age_death)\n\n\n### msprime assimilation\n# Find total num of generations (days) to model over\ntimes_loop = []\n\nfor item in list_of_root_and_kids:\n #float to take as number not string, and access list element with [0]\n times_loop.append(float(total_tree[item].time_infected_by[0]))\n\n#since floats, can do maths\ntotal_time = (max(times_loop)-min(times_loop))*365\n\n#Furthest back in time is the smallest date (lowest year), do everything in diffs\ngens_list = []\nfor item in list_of_root_and_kids:\n #float to take as number not string, and access list element with [0]\n diff_calc = 365*(max(times_loop)-float(total_tree[item].time_infected_by[0]))\n gens_list.append(diff_calc + 100) # add 100 so most recent infection is '100 gens (days) in past'\n\n# print(float(total_tree[item].time_infected_by[0]))\n\n# info on dates so far\nfor i in range(len(gens_list)):\n print((list_of_root_and_kids)[i],\n #times_loop[i],\n gens_list[i])\n\n######## msprime variable populations setup #########\n\n## source population\nPopSource = msprime.PopulationConfiguration(initial_size = 1e8, growth_rate = 0)\n\n## number of populations in present time of model, not including source pop...\nfinal_num_pops = len(list_of_root_and_kids)\n\n## sample_sizes for each population and effective pop sizes\nsample_size = 20\ninfection_size = 1\nstable_pop_size = 100\n# ## subpops based on infected people, all subpops that want to exist at end of sim (present time) need stated here\npop_list = [PopSource]\n\n#Setting up the end, so all pops exist and at stable pop size, no death in simulation time\nfor pop in range(final_num_pops):\n# print(pop)\n pop_list.append(\n msprime.PopulationConfiguration(sample_size = sample_size, initial_size = stable_pop_size, growth_rate = 0)\n )\n\n# no migration between sources accross time, only infection events,\n # so migration matrix is zeros\nM = np.zeros((final_num_pops+1,final_num_pops+1))\n\n# Now get transmission events from the data. Use index as population number, but +1 since have fake source pop at index 0.\n#for i in list_of_root_and_kids:\n# print(list_of_root_and_kids.index(i) + 1)\n\n####--- new version with sub-pops ---####\n\n## a simple model where independent sub-pop is infection derived from source pop\n# if infected by true pop, need to state when diverged from past pop if that's the case\n# Oddly source is the destination, i.e. direction of migration is dest -> source if forwards in time view.\n# backwards in time means that destination is destination (but it's where the migration has come from)\n\ntransfers_list = []\nfor entry in range(len(pop_list)):\n# print(entry)\n if entry == 0: # ignore 0 since this is the source pop\n pass\n\n elif entry == 1: # 1 is root so needs own bit\n entry_ID = list_of_root_and_kids[entry-1]\n# print(entry, entry_ID)\n dest_index = 0 #infected from source\n transfer_time = gens_list[entry-1] # time infected still stored.\n# print(transfer_time)\n transfers_list.append(msprime.MassMigration(time = transfer_time, source = entry, dest = dest_index, proportion = 1))\n\n elif entry > 1: # 1 is root so needs own bit\n # get the index of the infected_by population\n # index of current population is its index in pop_list (index in list_of_root... + 1)\n entry_ID = list_of_root_and_kids[entry-1]\n# print(entry, entry_ID)\n dest_ID = total_tree[entry_ID].infected_by[0]\n dest_index = list_of_root_and_kids.index(dest_ID) + 1\n# print(dest_index, dest_ID)\n transfer_time = gens_list[entry-1]\n# print(transfer_time)\n transfers_list.append(msprime.MassMigration(time = transfer_time, source = entry, dest = dest_index, proportion = 1))\n\n#check as expected\nprint(transfers_list)\n\n# compare\n#for i in range(len(gens_list)):\n# print((list_of_root_and_kids)[i],\n# #times_loop[i],\n# gens_list[i])\n\n## now have set of populations, the transfers for pops (infection events)\n # still need the bottlenecks (pop growth & stabilisation)\n # then can order(sort) the complete demography list by time and simulate\n\n## Bottlenecks: add population growth in so infections from source pop are only ~ 1-5 virions, which then balloons to e.g. ~1000\n\n#### Bottleneck list initiation and creation\nPop_bottleneck_ie_growth_list = []\nfor entry in range(len(pop_list)):\n if entry > 0: # ignore 0 since this is the source pop. Only need infection time for this so root doesn't need own case\n\n transfer_time = gens_list[entry-1]\n\n #infection size setting\n pop_entry_bottleneck_start = msprime.PopulationParametersChange(\n time = transfer_time, initial_size=infection_size, growth_rate=0, population = entry) #i.e. for epochs inf-> 100*entry, this is growth rate\n\n #growth after infection setting - trial that 20 gens in future (less time back) gives appropriate growth for these params of pop_size = 100, rate = 0.25\n pop_entry_bottleneck_end = msprime.PopulationParametersChange(\n time = transfer_time-20, growth_rate = 0.23, initial_size=stable_pop_size, population = entry) #i.e. for epochs inf-> 100*entry, this is growth rate\n\n #save to list for manip outside loop\n Pop_bottleneck_ie_growth_list.extend((pop_entry_bottleneck_start, pop_entry_bottleneck_end))\n\n# put all events together then sort them\nevents = Pop_bottleneck_ie_growth_list + transfers_list\nevents_sorted = sorted(events, key=lambda x: x.time, reverse=False)\n\n#check\n#for event in events_sorted:\n# print(event.__dict__) # just for easier digestion of output\n\n\nmy_history = msprime.DemographyDebugger(\n population_configurations=pop_list, migration_matrix = M,\n demographic_events = events_sorted)\n\n#my_history.print_history()\n\n\n\n### plot how pop changes ##\n#\n#time_steps= range(1,int(np.max(gens_list))+100,2)\n## print('pop0:', my_history.population_size_trajectory(time_steps)[:,0])\n## print('pop1:', my_history.population_size_trajectory(time_steps)[:,1])\n## print('time:', np.array(time_steps))\n## plot the populations, matplotlib understands array of y's as multiple y's so don't need to call individually\n#\n#import matplotlib.pyplot as plt\n#plt.figure(1)\n##plt.plot(time_steps, my_history.population_size_trajectory(time_steps)[:,0])\n##plt.plot(time_steps, my_history.population_size_trajectory(time_steps)[:,1])\n##plt.rc('axes', prop_cycle=(cycler(color=['r', 'g', 'b', 'y'])))\n#fig, ax = plt.subplots(figsize=(15, 6), dpi=80)\n#ax.set_prop_cycle(color=[\"green\", \"blue\", \"red\", \"orange\", \"grey\", \"cyan\", \"black\"][1:])\n#plt.plot(time_steps, my_history.population_size_trajectory(time_steps)[:,1:], '--', alpha=0.5) # this will plot each y (pop size var.) separately\n#plt.xlim(np.max(time_steps),0) # switch the order of time so present (0) is RHS and past is LHS (max time step)\n##plt.xlim(np.max(time_steps),1) # switch the order of time so present (0) is RHS and past is LHS (max time step)\n##plt.ylim(np.log(0.5), np.log(150))\n##plt.axvline(x=100, color='k', linestyle='-', alpha=0.5) # add a vertical line for migration step\n##plt.legend(('1','2','3','4','5','6'),loc='best')\n##box = ax.get_position()\n##ax.set_position([box.x0, box.y0, box.width * 0.8, box.height])\n## Put a legend to the right of the current axis\n##plt.yscale(\"log\")\n##plt.xscale(\"log\")\n#ax.legend(('1: ' + list_of_root_and_kids[0],\n# '2: ' + list_of_root_and_kids[1],\n# '3: ' + list_of_root_and_kids[2],\n# '4: ' + list_of_root_and_kids[3],\n# '5: ' + list_of_root_and_kids[4],\n# '6: ' + list_of_root_and_kids[5]),\n# loc='center left', bbox_to_anchor=(1.02, 0.5))\n#plt.show()\n## time = 0 is present, larger time is past\n\n\n\n\n############ Simulation time ############\n\n#file_loc = 'C:\\\\Users\\\\mazmysta\\\\OneDrive - Nexus365\\\\BDI_proj\\\\scripts\\\\PopulationsHIV\\\\'\n#\n##how to save\n#with open(file_loc + 'pickled_pop_list.pickle', 'wb') as f:\n# pickle.dump(pop_list, f)\n#\n#with open(file_loc + 'pickled_events_sorted.pickle', 'wb') as f:\n# pickle.dump(events_sorted, f)\n#\n#with open(file_loc + 'pickled_M.pickle', 'wb') as f:\n# pickle.dump(M, f)\n#\n## loading example\n#with open(file_loc + 'pickled_pop_list.pickle', 'rb') as f:\n# pop_list = pickle.load(f)\n#\n## simulate this extended simple model\nts2 = msprime.simulate(population_configurations=pop_list, migration_matrix = M,\n demographic_events = events_sorted,\n length = 1000,\n random_seed = 17, recombination_rate = 0.7e-4,\n mutation_rate=2e-5, end_time=60000)\n\n\n## simulate this extended simple model\n#ts2 = msprime.simulate(population_configurations=pop_list, migration_matrix = M,\n# demographic_events = events_sorted,\n# length = 1000,\n# random_seed = 17, recombination_rate = 0.7e-4)\n\n# 5 pops\ncolour_map = {0:\"grey\", 1:\"blue\", 2:\"red\", 3:\"orange\", 4:\"green\", 5:\"cyan\", 6:\"black\"}\nnode_colours = {u.id: colour_map[u.population] for u in ts2.nodes()}\n\n\nX = 1\ni = 0\nfor tree in ts2.trees():\n if i < X:\n display(SVG(tree.draw(node_colours = node_colours,\n height=800, width = 1000,\n format='SVG',\n tree_height_scale='log_time')))\n print(\"Tree {} covers [{:.2f}, {:.2f}); TMRCA = {:.4f}\".format(\n tree.index, *tree.interval, tree.time(tree.roots[0])))\n print(tree.branch_length(46))\n else:\n break\n i+=1\n\n#### truncation part\n\n# Having run\n# ReadingTransmissionNetworkCSV_OverallChildrenCalcs_save.py\n# have a ts2 = simulated data\n\n\n# ts2 from subsetting to msprime, length 100, picking just one population below\n# simplification and subsetting\n\n#ts3 = ts.simplify(samples=[3,8,0,4,7,2,6,5,1,9]\n#)\n\ntruncated_ts3 = truncate_ts_samples(ts2, average_span=200, random_seed=123)\n\n#print(truncated_ts3)\n#\n\n#truncated_ts3.tables\n#Out[34]: \n\n#truncated_ts3.tables.nodes\n#Out[35]: \n\n#print(truncated_ts3.tables)\n#prints the tables - long\nX = 10\ni = 0\nfor tree in truncated_ts3.trees():\n if i < X:\n display(SVG(tree.draw(height=800, width = 1000,\n format='SVG',\n tree_height_scale='log_time')))\n print(\"Tree {} covers [{:.2f}, {:.2f}); TMRCA = {:.4f}\".format(\n tree.index, *tree.interval, tree.time(tree.roots[0])))\n print(tree.branch_length(46))\n else:\n break\n i+=1\n\ntruncated_ts3.dump(file_loc + 'truncated_simulation_tree.trees')\n# ts infer\n\nsd = tsinfer.SampleData.from_tree_sequence(truncated_ts3, use_times=False)\n\nts_inferred = tsinfer.infer(sd, simplify=False)\n\nts_inferred = ts_inferred.simplify(filter_sites=False, keep_unary=True)\n\nts_inferred\nts_inferred.dump(file_loc + 'inferred_tree.trees')\n#Out[43]: \n\nX = 10\ni = 0\nfor tree in ts_inferred.trees():\n if i < X:\n display(SVG(tree.draw(height=400, width=600,\n tree_height_scale='rank')))\n print(\"Tree {} covers [{:.2f}, {:.2f}); TMRCA = {:.4f}\".format(\n tree.index, *tree.interval, tree.time(tree.roots[0])))\n# print(tree.branch_length(46))\n else:\n break\n i+=1\n\nprint(ts_inferred.genotype_matrix())\nprint(truncated_ts3.genotype_matrix())\n\nhaps = []\nfor i in ts2.haplotypes():\n haps.append(i)\n\nsequence_IDs = []\nfor i in range(len(haps)):\n sequence_IDs.append(f'sample_{ts2.samples()[i]}_pop_{ts2.node(i).population}')\n\n#fasta printing\n#for i in range(len(haps)):\n# print(f'>{sequence_IDs[i]}\\n{haps[i]}')\n\n## write and save fasta file\nwith open(file_loc + 'test_fasta_file.txt', 'w') as f:\n for i in range(len(haps)):\n f.write(f'>{sequence_IDs[i]}\\n{haps[i]}\\n')\n\n", "meta": {"hexsha": "944640c6cf919e30f2778b3be6d9811f57e90e00", "size": 14155, "ext": "py", "lang": "Python", "max_stars_repo_path": "Older_progress/FullSimFiniteMutMissingData-notyetfinite-fastaoutput.py", "max_stars_repo_name": "marianne-aspbury/HIVsimulation", "max_stars_repo_head_hexsha": "56e110f84474010f1866e299da4c41acd567e0b3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Older_progress/FullSimFiniteMutMissingData-notyetfinite-fastaoutput.py", "max_issues_repo_name": "marianne-aspbury/HIVsimulation", "max_issues_repo_head_hexsha": "56e110f84474010f1866e299da4c41acd567e0b3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Older_progress/FullSimFiniteMutMissingData-notyetfinite-fastaoutput.py", "max_forks_repo_name": "marianne-aspbury/HIVsimulation", "max_forks_repo_head_hexsha": "56e110f84474010f1866e299da4c41acd567e0b3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-12-09T12:15:35.000Z", "max_forks_repo_forks_event_max_datetime": "2019-12-09T12:15:35.000Z", "avg_line_length": 36.3881748072, "max_line_length": 164, "alphanum_fraction": 0.6899328859, "include": true, "reason": "import numpy", "num_tokens": 3735, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.519521321952093, "lm_q2_score": 0.3738758227716966, "lm_q1q2_score": 0.19423646169227826}} {"text": "\"\"\"\ninvariants:\n- distinct prototype prefixes have distinct node in the prefix graph, regardless of wildcard matches\n- if a node has two or more distinct child nodes, all the node's links are tame\n\nimplies that any node with wild links has exactly one child node,\nand all rules descending from node match without wildcards through the child prefix\n\n- any node with two or more distinct child nodes must be tame (no wild links)\n- all descendent rules of a tamed node must have wildcard disabled at that position\n- except for root, wild nodes never have None links, and all links point to same child node\n- any two distinct prototype prefixes must have distinct node paths in the prefix tree\n\nif you're adding a new rule, nobody matched prototype (early tame None leaf)\nif you're disabling a wildcard, someone matched it (wild node with non-None links)\n\nshould never take some wild links and then fail unmatched if a different non-wild link would have matched\nall prototypes should have persistent trails with no wildcard links\nthat way, disabling wildcards for one rule does not break another rule\n\n\"\"\"\nimport numpy as np\n\nclass PrefixTreeNode:\n def __init__(self, bound, value=None, added=0):\n self.bound = bound # maximum number of outgoing links\n self.value = value # value of incoming link\n self.added = added # integer timestamp when node is added\n self.tamed = np.iinfo(int).max # integer timestamp when node is tamed\n self.rule = None # for leaf nodes, the associated rule\n self.links = {} # links[v] = child node for value v\n \n def is_wild(self):\n child_ids = set(map(id, self.links.values()))\n return len(self.links) == self.bound and len(child_ids) == 1\n\n def tame(self, tamed=0):\n self.links = {value:node for value, node in self.links.items() if node.value == value}\n self.tamed = tamed\n\n def __str__(self, prefix=\"\"):\n tamed = \"\" if self.tamed == np.iinfo(int).max else str(self.tamed)\n if self.rule != None: return \"%sr%d [%d~>%s]\\n\" % (prefix, self.rule, self.added, tamed)\n if self.is_wild():\n result = prefix + \"* [%d~>%s]\\n\" % (self.added, tamed)\n result += self.links[0].__str__(prefix+\" \")\n else:\n result = \"\"\n p = \" \" if len(self.links) == 1 else \"|\"\n for v in range(self.bound):\n if v in self.links:\n result += prefix + \"%d [%d~>%s]\\n\" % (v, self.added, tamed)\n result += self.links[v].__str__(prefix+p)\n return result\n\n def rules(self):\n if self.rule != None: return [self.rule]\n if self.is_wild(): return self.links[0].rules()\n result = []\n for v in range(self.bound):\n if v in self.links:\n result += self.links[v].rules()\n return result\n\n def copy(self):\n node = PrefixTreeNode(self.bound, self.value, self.added)\n node.tamed = self.tamed\n node.rule = self.rule\n if self.is_wild():\n child_node = self.links[0].copy()\n node.links = {v: child_node for v in range(self.bound)}\n else:\n node.links = {v: child_node.copy() for v, child_node in self.links.items()}\n return node\n\n def rewind(self, i):\n\n # Rewind current node and links\n self.links = {v: node for v, node in self.links.items() if node.added <= i}\n if self.tamed > i and len(self.links) > 0: # should imply len == 1\n _, node = self.links.popitem()\n for v in range(self.bound): self.links[v] = node\n self.tamed = np.iinfo(int).max\n\n # Recurse on children\n if self.is_wild():\n self.links[0].rewind(i)\n else:\n for child_node in self.links.values(): child_node.rewind(i)\n\nclass MacroDatabase:\n def __init__(self, domain, max_rules):\n\n self.domain = domain\n self.max_rules = max_rules\n self.num_rules = 0\n self.bounds = (7,) * domain.state_size()\n self.root = PrefixTreeNode(self.bounds[0])\n\n self.prototypes = np.empty((max_rules, domain.state_size()), dtype=int)\n self.wildcards = np.empty((max_rules, domain.state_size()), dtype=bool)\n self.costs = np.empty(max_rules, dtype=int)\n self.macros = [None] * max_rules\n self.permutations = np.empty((max_rules, domain.state_size()), dtype=int)\n\n self.added = np.ones(max_rules, dtype=int) * np.iinfo(int).max\n self.tamed = np.ones((max_rules, domain.state_size()), dtype=int) * np.iinfo(int).max\n\n def query(self, state):\n node = self.root\n for k,v in enumerate(state):\n if v not in node.links: return None\n node = node.links[v]\n return node.rule\n\n def tame(self, node, w, tamed=0):\n node.tame(tamed)\n for r in node.rules():\n self.wildcards[r,w] = False\n self.tamed[r,w] = tamed\n\n def add_rule(self, prototype, macro, cost, added=0):\n r = self.num_rules\n self.prototypes[r] = prototype\n self.costs[r] = cost\n self.macros[r] = macro\n self.permutations[r] = self.domain.execute(macro, np.arange(self.domain.state_size()))\n self.added[r] = added\n\n node = self.root\n for k, value in enumerate(prototype):\n child_bound = self.bounds[k+1] if k+1 < len(self.bounds) else 0\n if len(node.links) == 0:\n child_node = PrefixTreeNode(child_bound, value, added)\n node.links = {v: child_node for v in range(node.bound)}\n elif value not in node.links:\n node.links[value] = PrefixTreeNode(child_bound, value, added)\n elif node.links[value].value != value:\n self.tame(node, k, tamed=added)\n node.links[value] = PrefixTreeNode(child_bound, value, added)\n self.wildcards[r,k] = node.is_wild()\n node = node.links[value]\n node.rule = r\n\n self.num_rules += 1\n\n def disable(self, r, w, tamed=0):\n node = self.root\n for k in range(w): node = node.links[self.prototypes[r,k]]\n if node.is_wild(): self.tame(node, w, tamed)\n\n def apply_rule(self, r, state):\n return state[self.permutations[r]].copy()\n\n def copy(self):\n db = MacroDatabase(self.domain, self.max_rules)\n db.num_rules = self.num_rules\n db.root = self.root.copy()\n\n db.prototypes = self.prototypes.copy()\n db.wildcards = self.wildcards.copy()\n db.costs = self.costs.copy()\n db.macros = list(self.macros)\n db.permutations = self.permutations.copy()\n\n db.added = self.added.copy()\n db.tamed = self.tamed.copy()\n \n return db\n\n def rewind(self, i):\n # keep all edits up to and including i\n self.root.rewind(i)\n if (self.added > i).any():\n self.num_rules = np.argmax(self.added > i)\n self.added[self.num_rules:] = np.iinfo(int).max\n self.wildcards = self.tamed > i\n self.tamed[self.wildcards] = np.iinfo(int).max\n return self\n\n def shrink_wrap(self):\n # reduce max_rules to num_rules and shrink arrays in-place for lighter footprint\n self.max_rules = self.num_rules\n\n self.prototypes = self.prototypes[:self.num_rules].copy()\n self.wildcards = self.wildcards[:self.num_rules].copy()\n self.costs = self.costs[:self.num_rules].copy()\n self.macros = tuple(self.macros[:self.num_rules])\n self.permutations = self.permutations[:self.num_rules].copy()\n\n self.added = self.added[:self.num_rules].copy()\n self.tamed = self.tamed[:self.num_rules].copy()\n \n return self\n\nif __name__ == \"__main__\":\n\n from cube import CubeDomain\n domain = CubeDomain(2)\n solved = domain.solved_state()\n\n md = MacroDatabase(domain, max_rules=10)\n \n result = md.query(solved)\n assert result == None\n print(md.root)\n\n md.add_rule(solved, (), 0)\n assert md.query(solved) == 0\n assert (md.wildcards[:md.num_rules] == True).all()\n print(\"-\"*24)\n print(md.root)\n\n # disable all wildcards for solved\n for w in range(len(solved)): md.disable(0, w)\n\n assert md.query(solved) == 0\n assert (md.wildcards[:md.num_rules] == False).all()\n print(\"-\"*24)\n print(md.root)\n\n state = domain.perform((0,1,1), solved)\n md.add_rule(state, ((0,1,3),), 1)\n\n print(\"-\"*24)\n print(md.root)\n assert md.query(solved) == 0\n assert md.query(state) == 1\n assert not (md.wildcards[:md.num_rules] == True).all()\n assert not (md.wildcards[:md.num_rules] == False).all()\n\n state2 = domain.perform((0,1,2), solved)\n md.add_rule(state2, ((0,1,2),), 1)\n print(\"-\"*24)\n print(md.root)\n\n state3 = domain.perform((1,1,1), solved)\n md.add_rule(state3, ((1,1,3),), 1)\n print(\"-\"*24)\n print(md.root)\n \n # simulate adding rules and check queries match after\n md = MacroDatabase(domain, max_rules=10)\n md.add_rule(solved, (), 0)\n for w in range(len(solved)): md.disable(0, w)\n\n rng = np.random.default_rng()\n for r in range(1, 10):\n state = domain.random_state(20, rng)\n md.add_rule(state, (), 0)\n\n for r in range(md.num_rules):\n state = md.prototypes[r]\n result = md.query(state)\n brutes = np.flatnonzero(((md.prototypes == state) | md.wildcards).all(axis=1))\n print(r, result, brutes)\n if result not in brutes:\n print(\"predisable\")\n print(\"-\"*24)\n print(md.root)\n assert result in brutes\n\n for r in range(md.num_rules): \n for w in range(len(state)): \n if rng.uniform() < 0.1:\n md.disable(r, w)\n\n for r in range(md.num_rules):\n state = md.prototypes[r]\n result = md.query(state)\n brutes = np.flatnonzero(((md.prototypes == state) | md.wildcards).all(axis=1))\n print(r, result, brutes)\n if result not in brutes:\n print(\"postdisable\")\n print(\"-\"*24)\n print(md.root)\n assert result in brutes\n\n print(\"-\"*24)\n print(md.root)\n\n # test rewinding\n md = MacroDatabase(domain, max_rules=10)\n md.add_rule(prototype=solved, macro=(), cost=0, added=0)\n for w in range(len(solved)): md.disable(0, w, tamed=0)\n\n rng = np.random.default_rng()\n for r in range(1, 5):\n state = domain.random_state(20, rng)\n md.add_rule(prototype=state, macro=(), cost=0, added=r)\n md.disable(rng.integers(r, endpoint=True), rng.integers(len(state)), tamed=r)\n\n for r in range(md.num_rules):\n state = md.prototypes[r]\n result = md.query(state)\n brutes = np.flatnonzero(((md.prototypes == state) | md.wildcards).all(axis=1))\n if result not in brutes:\n print(\"prerewind\")\n print(\"-\"*24)\n print(md.root)\n assert result in brutes\n\n print(\"prerewind\")\n print(\"-\"*24)\n print(md.root)\n\n md.rewind(3)\n md.rewind(2)\n for r in range(md.num_rules):\n state = md.prototypes[r]\n result = md.query(state)\n brutes = np.flatnonzero(((md.prototypes == state) | md.wildcards).all(axis=1))\n if result not in brutes:\n print(\"postrewind\")\n print(\"-\"*24)\n print(md.root)\n assert result in brutes\n\n print(\"postrewind\")\n print(\"-\"*24)\n print(md.root)\n\n # test copy\n md = MacroDatabase(domain, max_rules=10)\n md.add_rule(prototype=solved, macro=(), cost=0, added=0)\n for w in range(len(solved)): md.disable(0, w, tamed=0)\n\n rng = np.random.default_rng()\n num_rules = 4\n states = []\n for r in range(1, num_rules-1):\n state = domain.random_state(20, rng)\n md.add_rule(prototype=state, macro=(), cost=0, added=r)\n md.disable(rng.integers(r, endpoint=True), rng.integers(len(state)), tamed=r)\n states.append(state)\n\n md2 = md.copy()\n state = domain.random_state(20, rng)\n md2.add_rule(prototype=state, macro=(), cost=0, added=num_rules-1)\n for r in range(md.num_rules):\n for w in range(len(state)):\n md.disable(r, w, tamed=num_rules)\n\n print(\"orig\")\n print(\"-\"*24)\n print(md.root)\n print(\"copy\")\n print(\"-\"*24)\n print(md2.root)\n\n assert md.num_rules + 1 == md2.num_rules\n assert md.wildcards[:md.num_rules].sum() == 0\n assert md2.wildcards[:md.num_rules].sum() > 0\n assert md.query(state) == None\n assert md2.query(state) != None\n for state in states:\n assert md.query(state) != None\n assert md2.query(state) != None\n\n # test macro permutations\n md = MacroDatabase(domain, max_rules=1)\n state = domain.perform((0, 1, 1), solved)\n actions = ((1, 1, 1), (2, 1, 1))\n md.add_rule(prototype=solved, macro=actions, cost=0, added=0)\n for w in range(len(solved)):\n if state[w] == solved[w]: md.disable(0, w, tamed=0)\n\n print(\"one rule perm\")\n print(\"-\"*24)\n print(md.root)\n\n r = md.query(state)\n assert r == 0\n new_state = md.apply_rule(r, state)\n for action in actions: state = domain.perform(action, state)\n assert (state == new_state).all()\n\n # compare timing of prefix and brute queries, and array-based prefix\n rule_count = 5000\n\n md = MacroDatabase(domain, max_rules=rule_count)\n md.add_rule(solved, (), 0)\n for w in range(len(solved)): md.disable(0, w)\n\n rng = np.random.default_rng()\n for r in range(1, rule_count):\n state = domain.random_state(20, rng)\n md.add_rule(state, (), 0)\n\n print(\"counting nodes...\")\n def count_nodes(node):\n if node.is_wild():\n return 1 + count_nodes(node.links[0])\n else:\n count = 0\n for v, child in node.links.items():\n count += count_nodes(child)\n return 1 + count\n print(f\"{count_nodes(md.root)} total nodes\")\n\n # make prefix tree array query\n class ArrayPrefixTree:\n def __init__(self, root):\n self.links = -np.ones((rule_count * (domain.state_size()+1), 7), dtype=int)\n self.rules = -np.ones(rule_count * (domain.state_size()+1), dtype=int)\n self.num_nodes = 0\n self.link(root)\n # very marginal benefit after tuplifying, otherwise marginally worse\n self.links = tuple(tuple(links) for links in self.links)\n self.rules = tuple(self.rules)\n def add(self, node):\n n = self.num_nodes\n if node.rule != None: self.rules[n] = node.rule\n self.num_nodes += 1\n return n\n def link(self, node):\n n = self.add(node)\n if node.is_wild():\n c = self.link(node.links[0])\n self.links[n,:] = c\n else:\n for v, child in node.links.items():\n c = self.link(node.links[v])\n self.links[n,v] = c\n return n\n def query(self, state):\n n = 0\n for k,v in enumerate(state):\n n = self.links[n][v]\n if n == -1: return None\n return self.rules[n]\n\n apt = ArrayPrefixTree(md.root)\n\n from time import perf_counter\n prefix_time = 0\n brute_time = 0\n array_time = 0\n\n for state in md.prototypes:\n\n assert md.query(state) == apt.query(state)\n\n start = perf_counter()\n result = md.query(state)\n prefix_time += perf_counter() - start\n\n start = perf_counter()\n result = np.flatnonzero(((state == md.prototypes) | md.wildcards).all(axis=1))\n brute_time += perf_counter() - start\n\n start = perf_counter()\n result = apt.query(state)\n array_time += perf_counter() - start\n\n print(\"prototype queries:\")\n print(\"prefix time\", prefix_time)\n print(\"brute time\", brute_time)\n print(\"array time\", array_time)\n\n prefix_time = 0\n brute_time = 0\n array_time = 0\n\n for s in range(rule_count):\n state = domain.random_state(20, rng)\n\n assert md.query(state) == apt.query(state)\n\n start = perf_counter()\n result = md.query(state)\n prefix_time += perf_counter() - start\n\n start = perf_counter()\n result = np.flatnonzero(((state == md.prototypes) | md.wildcards).all(axis=1))\n brute_time += perf_counter() - start\n\n start = perf_counter()\n result = apt.query(state)\n array_time += perf_counter() - start\n\n print(\"random state queries:\")\n print(\"prefix time\", prefix_time)\n print(\"brute time\", brute_time)\n print(\"array time\", array_time)\n\n", "meta": {"hexsha": "c221f130bf1ec1eb8f88672f25583c164e6c503d", "size": 16643, "ext": "py", "lang": "Python", "max_stars_repo_path": "macro_database.py", "max_stars_repo_name": "garrettkatz/cubbies", "max_stars_repo_head_hexsha": "81850ffb9f0dcfed75a070f3344d931c6c74d96b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "macro_database.py", "max_issues_repo_name": "garrettkatz/cubbies", "max_issues_repo_head_hexsha": "81850ffb9f0dcfed75a070f3344d931c6c74d96b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "macro_database.py", "max_forks_repo_name": "garrettkatz/cubbies", "max_forks_repo_head_hexsha": "81850ffb9f0dcfed75a070f3344d931c6c74d96b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.1745379877, "max_line_length": 105, "alphanum_fraction": 0.5920206694, "include": true, "reason": "import numpy", "num_tokens": 4237, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.519521321952093, "lm_q2_score": 0.373875808818685, "lm_q1q2_score": 0.19423645444339122}} {"text": "\n#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\n'''\nQSDsan: Quantitative Sustainable Design for sanitation and resource recovery systems\nCopyright (C) 2020, Quantitative Sustainable Design Group\n\nThis module is developed by:\n Lewis Rowles \n \n\nThis module is under the University of Illinois/NCSA Open Source License.\nPlease refer to https://github.com/QSD-Group/QSDsan/blob/master/LICENSE.txt\nfor license details.\n'''\n# %%\n\n\nimport numpy as np\nfrom qsdsan import SanUnit, Construction\nfrom qsdsan.utils.loading import load_data, data_path\nimport os\n__all__ = ('IonExchangeNH3',)\n\n#path to csv with all the inputs\n#data_path = '/Users/lewisrowles/opt/anaconda3/lib/python3.8/site-packages/exposan/biogenic_refinery/_ion_exchange_NH3.csv'\n#data_path = os.path.abspath(os.path.dirname('_ion_exchange_NH3.csv'))\ndata_path += 'sanunit_data/_ion_exchange_NH3.tsv'\n# data_path += 'sanunit_data/_carbonizer_base.csv'\n\n### \nclass IonExchangeNH3(SanUnit):\n '''\n Ion Exchange for N recovery from liquid stream. Concentrated NH3 is recovered.\n\n \n Reference documents\n -------------------\n N/A\n \n Parameters\n ----------\n ins : WasteStream (liquid), FreshResin, H2SO4\n \n outs : WasteStream, SpentResin, ConcentratedNH3\n \n\n \n References\n ----------\n .. Lohman et al., Advancing Sustainable Sanitation and Agriculture \n through Investments in Human-Derived Nutrient Systems. \n Environ. Sci. Technol. 2020, 54, (15), 9217-9227.\n https://dx.doi.org/10.1021/acs.est.0c03764\n \n .. Tarpeh et al., Evaluating ion exchange for nitrogen recovery from \n source-separated urine in Nairobi, Kenya. Development Engineering. 2018, \n 3, 188–195.\n https://doi.org/10.1016/j.deveng.2018.07.002\n \n '''\n \n\n def __init__(self, ID='', ins=None, outs=(), **kwargs):\n \n SanUnit.__init__(self, ID, ins, outs)\n\n# load data from csv each name will be self.name \n data = load_data(path=data_path)\n for para in data.index:\n value = float(data.loc[para]['expected'])\n setattr(self, para, value)\n del data\n \n for attr, value in kwargs.items():\n setattr(self, attr, value)\n\n\n\n\n \n# define the number of influent and effluent streams \n _N_ins = 3\n _N_outs = 3\n\n# in _run: define influent and effluent streams and treatment processes \n def _run(self):\n waste, resin_in, H2SO4 = self.ins\n treated, resin_out, conc_NH3 = self.outs\n treated.copy_like(self.ins[0])\n resin_in.phase = 'l'\n resin_out.phase = 'l'\n conc_NH3.phase = 'l'\n \n \n #!!! During storage most N as urea goes to NH3, should that \n # conversion be added or just use total N here? \n N_recovered = waste.imass['NH3'] * (self.N_rec_2) # kg N / hr\n treated.imass['NH3'] = waste.imass['NH3'] - N_recovered # kg N / hr\n conc_NH3.imass['NH3'] = N_recovered # kg N / hr\n \n # following Terpeh et al. 2018 estimates for regenerating resin\n # assume volume of eluent = volume of urine\n # !!! cost associated with this influent stream neg compared to cost of resin and acid?\n #conc_NH3.F_vol = waste.F_vol\n # 0.1 M H2SO4 (0.65%) used to regenerate resin\n \n # !!! need to add SO4 as a component? \n # conc_NH3.imass['SO4'] = 0.1 * 98 * conc_NH3.F_vol # kg SO4 / hr\n \n # !!! add resin and H2SO4 as influent streams and spent resin as effluent\n resin_demand_influent = (waste.TN / self.resin_lifetime / self.ad_density / 14) # kg resin / m3 treated\n resin_demand_time = resin_demand_influent * waste.F_vol # kg resin / hr\n resin_cost_day = resin_demand_time * 24 * self.cost_resin # $ resin / d\n resin_in.imass['Polystyrene'] = resin_demand_time\n resin_out.imass['Polystyrene'] = resin_demand_time\n\n acid_demand_influent = waste.TN * self.vol_H2SO4 / self.ad_density / 14 # L acid / L treated\n acid_demand_time = acid_demand_influent * waste.F_vol * 1000 * 1.83 # kg acid / hr\n acid_cost_day = acid_demand_time * 24 / 1000 * self.cost_H2SO4 # $ acid / d\n H2SO4.imass['H2SO4'] = acid_demand_time\n\n # set values needed for _design and _cost as attributes\n self.volume_treated = waste.F_vol * 1000 * 24 # L liq / d \n \n\n \n \n #_design will include all the construction or captial impacts \n def _design(self):\n design = self.design_results\n # defining the quantities of materials/items\n # note that these items to be to be in the _impacts_items.xlsx\n \n self.quantity_columns = np.ceil(self.volume_treated / \n self.column_daily_loading_rate) # number of 0.4 m columns\n design['PVC'] = PVC_quant = (self.column_length * self.quantity_columns \n * self.pvc_mass) # kg PVC\n Tubing_quant = (self.tubing_length * self.quantity_columns \n * self.tubing_mass) # kg PE\n Tank_quant = (self.quantity_columns * self.tank_mass / 3) # number of tanks with one tank for three columns\n design['PE'] = PE_quant = Tubing_quant + Tank_quant\n\n \n self.construction = (\n Construction(item='PVC', quantity = PVC_quant, quantity_unit = 'kg'),\n Construction(item='PE', quantity = PE_quant, quantity_unit = 'kg'),\n )\n self.add_construction()\n \n \n #_cost based on amount of steel and stainless plus individual components\n def _cost(self):\n #purchase_costs is used for capital costs\n #can use quantities from above (e.g., self.design_results['StainlessSteel'])\n #can be broken down as specific items within purchase_costs or grouped (e.g., 'Misc. parts')\n self.purchase_costs['PVC'] = (self.cost_PVC_column * self.column_length \n * self.quantity_columns)\n self.purchase_costs['Tubing'] = (self.cost_tubing * self.tubing_length \n * self.quantity_columns)\n self.purchase_costs['Tank'] = (self.quantity_columns * self.tank_cost / 3) # one tank for three columns\n self._BM = dict.fromkeys(self.purchase_costs.keys(), 1)\n \n #certain parts need to be replaced based on an expected lifefime\n #the cost of these parts is considered along with the cost of the labor to replace them\n ix_replacement_parts_annual_cost = 0 # USD/yr only accounts for time running\n \n ix_annual_maintenance = 0 #USD/yr only accounts for time running\n \n self.add_OPEX = (ix_replacement_parts_annual_cost + ix_annual_maintenance) / (365 * 24) # USD/hr (all items are per hour)\n \n # costs associated with full time opperators can be added in the TEA as staff\n \n\n\n\n\n \n", "meta": {"hexsha": "0453ad382d979062b8c8e69eaba0db75446b718a", "size": 6955, "ext": "py", "lang": "Python", "max_stars_repo_path": "qsdsan/sanunits/_ion_exchange_NH3.py", "max_stars_repo_name": "stetsonrowles/QSDsan", "max_stars_repo_head_hexsha": "a74949fcf9e6ff91e9160a75bedaf6fab2191efb", "max_stars_repo_licenses": ["NCSA", "CNRI-Python", "FTL"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "qsdsan/sanunits/_ion_exchange_NH3.py", "max_issues_repo_name": "stetsonrowles/QSDsan", "max_issues_repo_head_hexsha": "a74949fcf9e6ff91e9160a75bedaf6fab2191efb", "max_issues_repo_licenses": ["NCSA", "CNRI-Python", "FTL"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "qsdsan/sanunits/_ion_exchange_NH3.py", "max_forks_repo_name": "stetsonrowles/QSDsan", "max_forks_repo_head_hexsha": "a74949fcf9e6ff91e9160a75bedaf6fab2191efb", "max_forks_repo_licenses": ["NCSA", "CNRI-Python", "FTL"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.6388888889, "max_line_length": 130, "alphanum_fraction": 0.6342199856, "include": true, "reason": "import numpy", "num_tokens": 1752, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.519521321952093, "lm_q2_score": 0.373875808818685, "lm_q1q2_score": 0.19423645444339122}} {"text": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nCloud HR experiments\n\nCreated on Fri Dec 9 11:22:51 2016\n\n@author: maxwell\n\"\"\"\n\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport time\nimport copy\n\n\nimport atmosphere as a\nfrom parm import ChemParm, LWParm, SWParm\nfrom solver import SolverFactory,HR\nfrom misc.humidity import manaberh\nimport misc.solargeometry as solar\n\n\n# %% set up\nst = time.clock()\ntimestr = \"Elapsed Time: {:4f}s\"\n\nplev =np.logspace(-2,np.log10(1013), 601)\nlat = 10\ndecl = 21.11\nrhlabel= ''\nholdrh=True\nrh = np.ones(len(plev))*0.5\nholdtsfc=True\ncpdair=1004.0\n\ntimestep=0.25\nradmodel='fu'\ngridstagger=False\nmaxsteps=300\ntol = .011\n\ncldprofiles=[ None,\n 'atmosphere/profiles/hr/yang/cf_allclouds/annual_mean_20Nto20S_cf.txt',\n 'atmosphere/profiles/hr/yang/cf_withoutcirrus/annual_mean_20Nto20S_cf_withoutcirrus.txt',\n None,\n 'atmosphere/profiles/hr/yang/cf_allclouds/annual_mean_wp_cf.txt',\n 'atmosphere/profiles/hr/yang/cf_withoutcirrus/annual_mean_wp_cf_withoutcirrus.txt'\n ]\no3profiles=['atmosphere/profiles/ozone/yang/annual_ozone_20Nto20S.dat',\n 'atmosphere/profiles/ozone/yang/annual_ozone_20Nto20S.dat',\n 'atmosphere/profiles/ozone/yang/annual_ozone_20Nto20S.dat',\n 'atmosphere/profiles/ozone/yang/annual_ozone_fiji.dat',\n 'atmosphere/profiles/ozone/yang/annual_ozone_fiji.dat',\n 'atmosphere/profiles/ozone/yang/annual_ozone_fiji.dat'\n ]\n\nanames=['Trop', 'Trop CF', 'Trop CF (no Ci)', 'WP', 'WP CF', 'WP CF (no Ci)']\ncldconds = dict(zip(anames, cldprofiles))\no3conds = dict(zip(anames, o3profiles))\nts = 300.0\nnsim = len(anames)\natms=dict.fromkeys(anames)\natms_noco2 = dict.fromkeys(anames)\natms_noo3 = dict.fromkeys(anames)\natms_wvonly = dict.fromkeys(anames)\nhr=dict.fromkeys(anames)\nauxhr=dict.fromkeys(anames)\nhr_noco2=dict.fromkeys(anames)\nhr_noo3 = dict.fromkeys(anames)\nhr_wvonly= dict.fromkeys(anames)\nflx = dict.fromkeys(anames)\nflx_noco2 = dict.fromkeys(anames)\nflx_noo3 = dict.fromkeys(anames)\nflx_wvonly = dict.fromkeys(anames)\n\n\nswparm = dict.fromkeys(anames)\n\n\ncparm = ChemParm()\ncparm_noco2=ChemParm(co2ppmv=1.0e-4)\nlwparm = LWParm()\nslv = SolverFactory.create(kind='rce', timestep=timestep, holdtsfc=holdtsfc,\n radmodel=radmodel,cpdair=cpdair,tol=tol,\n maxsteps=maxsteps)\nradslv = SolverFactory.create(kind='rad',radmodel=radmodel,\n cpdair=cpdair)\n\n\n\nst2 = st\nfor name,cond in cldconds.items():\n print('SOLVING {}'.format(name))\n prof = 'jtrp'\n atms[name] = a.Atmosphere.mcclatchy(prof, p=plev, rhlev=rh, holdrh=holdrh,\n gridstagger=gridstagger,tsfc=ts)\n atms[name].ozone_fromfile(o3conds[name])\n atms_noco2[name] = copy.deepcopy(atms[name])\n atms_noo3[name] = copy.deepcopy(atms[name])\n atms_noo3[name].o3 = np.zeros(len(atms_noo3[name]))\n atms_wvonly[name] = copy.deepcopy(atms[name])\n atms_wvonly[name].o3 = np.zeros(len(atms_wvonly[name]))\n\n mu=solar.mubar(lat,decl)\n fday=solar.fday(lat,decl)\n swparm[name] = SWParm(coszen=mu,fday=fday)\n\n if cond is not None:\n auxhr[name]=HR.fromfile(atms[name], cond)\n else:\n zeros = np.zeros(len(atms[name]))\n auxhr[name]=HR(zeros, zeros)\n slv.auxhr=auxhr[name]\n\n atms[name],flx[name],hr[name] = slv.solve(\n atms[name],cparm,lwparm,swparm[name])\n atms_noco2[name], flx_noco2[name], hr_noco2[name] = radslv.solve(\n atms_noco2[name],cparm_noco2, lwparm,swparm[name])\n atms_noo3[name], flx_noo3[name], hr_noo3[name] = radslv.solve(\n atms_noo3[name],cparm,lwparm,swparm[name])\n atms_wvonly[name], flx_wvonly[name], hr_wvonly[name] = radslv.solve(\n atms_wvonly[name], cparm_noco2, lwparm,swparm[name])\n ed = time.clock()\n print(timestr.format(ed-st2))\n st2 = ed\n\n\nprint('Total time: {}'.format(ed-st))\n\n\n# %% plot temps\n\nplt.figure(1)\nplt.clf()\nyls = (8,1013)\n#ytcks = [10,20,40,60,80,100,200,400,600,800,1000]\nxls = (150,300)\nxtcks = np.linspace(150,300,3)\nplt.suptitle('Temperature (K)')\n\nif(gridstagger):\n fstag='0'\nelse:\n fstag='1'\n\nfor i, name in enumerate(anames):\n ax = plt.subplot(1,nsim,i+1)\n plt.hold('on')\n try:\n plt.semilogy(atms[name].t, atms[name].p)\n plt.plot(atms[name].tconv, atms[name].pconv, 'ks')\n plt.plot(atms[name].tcold, atms[name].pcold, 'ko')\n except ValueError:\n pass\n finally:\n plt.ylim(yls)\n # plt.yticks(ytcks)\n plt.xlim(xls)\n plt.xticks(xtcks)\n plt.xlabel(name.upper())\n ax.invert_yaxis()\n if (i==0):\n plt.ylabel('Pressure (hPa)')\n # ax.yaxis.set_ticklabels(['{:.0f}'.format(tick) for tick in ytcks])\n else:\n ax.yaxis.set_ticklabels([])\nelse:\n plt.show()\n\nfigname = 'img/rce_{}g{}_cld_{}_eq.png'.format(\n radmodel,fstag,rhlabel)\nprint(\"Writing figure: {}\".format(figname))\nplt.savefig(\n bbox_inches='tight', dpi=300, filename=figname)\n\n# %% plot hr (net)\nplt.figure(2)\nplt.clf()\nyls = (10,1013)\nxls = (-3,2)\nxtcks = np.linspace(xls[0],xls[1],2)\n#ytcks = np.linspace(,1000,10)\nplt.suptitle('HR (K/d)')\n\nfor i, name in enumerate(anames):\n ax = plt.subplot(1,nsim,i+1)\n plt.hold('on')\n iconv = atms[name].iconv\n icold = atms[name].icold\n try:\n plt.semilogy(hr[name].hrir, atms[name].p,color='crimson')\n plt.semilogy(hr[name].hrsw, atms[name].p,'mediumblue')\n plt.semilogy(hr[name].hr, atms[name].p,'orange')\n plt.plot(np.zeros(len(atms[name])), atms[name].p, 'k--')\n plt.plot(xtcks, np.ones(len(xtcks))*atms[name].pcold, 'k')\n plt.plot(xtcks, np.ones(len(xtcks))*atms[name].pconv, 'k')\n\n except ValueError:\n pass\n finally:\n plt.ylim(yls)\n # plt.yticks(ytcks)\n plt.xlim(xls)\n plt.xticks(xtcks)\n plt.xlabel(name.upper())\n ax.invert_yaxis()\n\n if (i==0):\n plt.ylabel('Pressure (hPa)')\n # ax.yaxis.set_ticklabels(['{:.0f}'.format(tick) for tick in ytcks])\n else:\n ax.yaxis.set_ticklabels([])\nelse:\n plt.show()\n\nfigname = 'img/rce_{}g{}_cld_{}_hr.png'.format(\n radmodel,fstag,rhlabel)\nprint(\"Writing figure: {}\".format(figname))\nplt.savefig(\n bbox_inches='tight', dpi=300, filename=figname)\n\n# %% co2-only hr\nplt.figure(3)\nplt.clf()\nyls = (10,1013)\nxls = (-3,3)\nxtcks = np.linspace(xls[0],xls[1],3)\n#ytcks = np.linspace(100,1000,10)\nplt.suptitle('CO2 IR HR (K/d)')\n\nfor i, name in enumerate(anames):\n ax = plt.subplot(1,nsim,i+1)\n plt.hold('on')\n iconv = atms[name].iconv\n icold = atms[name].icold\n\n try:\n plt.plot(hr[name].hrir - hr_noco2[name].hrir, atms[name].p)\n plt.plot(np.zeros(len(atms[name])), atms[name].p, 'k--')\n plt.plot(xtcks, np.ones(len(xtcks))*atms[name].pcold, 'k')\n plt.plot(xtcks, np.ones(len(xtcks))*atms[name].pconv, 'k')\n\n except ValueError:\n pass\n finally:\n plt.ylim(yls)\n plt.xlim(xls)\n plt.xticks(xtcks)\n plt.xlabel(name.upper())\n ax.invert_yaxis()\n ax.set_yscale('log')\n # plt.yticks(ytcks)\n\n if (i==0):\n plt.ylabel('Pressure (hPa)')\n # ax.yaxis.set_ticklabels(['{:.0f}'.format(tick) for tick in ytcks])\n else:\n ax.yaxis.set_ticklabels([])\nelse:\n plt.show()\n\nfigname = 'img/rce_{}g{}_cld_{}_hrco2.png'.format(\n radmodel,fstag,rhlabel)\nprint(\"Writing figure: {}\".format(figname))\nplt.savefig(\n bbox_inches='tight', dpi=300, filename=figname)\n\n\n\n\n# %% o3-only hr\nplt.figure(4)\nplt.clf()\nyls = (10,1013)\nxls = (-1,2)\nxtcks = np.linspace(xls[0],xls[1],4)\n#ytcks = np.linspace(100,1000,10)\nplt.suptitle(' O3 HR (K/d)')\n\nfor i, name in enumerate(anames):\n ax = plt.subplot(1,nsim,i+1)\n plt.hold('on')\n iconv = atms[name].iconv\n icold = atms[name].icold\n try:\n# plt.plot(hr[name].hrir - hr_noo3[name].hrir, atms[name].p,color='crimson')\n# plt.plot(hr[name].hrsw - hr_noo3[name].hrsw, atms[name].p,color='mediumblue')\n plt.plot(hr[name].hr - hr_noo3[name].hr, atms[name].p,'orange')\n plt.plot(np.zeros(len(atms[name])), atms[name].p, 'k--')\n plt.plot(xtcks, np.ones(len(xtcks))*atms[name].pcold, 'k')\n plt.plot(xtcks, np.ones(len(xtcks))*atms[name].pconv, 'k')\n except ValueError:\n pass\n finally:\n plt.ylim(yls)\n plt.xlim(xls)\n plt.xticks(xtcks)\n plt.xlabel(name.upper())\n ax.invert_yaxis()\n ax.set_yscale('log')\n # plt.yticks(ytcks)\n\n if (i==0):\n plt.ylabel('Pressure (hPa)')\n # ax.yaxis.set_ticklabels(['{:.0f}'.format(tick) for tick in ytcks])\n else:\n ax.yaxis.set_ticklabels([])\nelse:\n plt.show()\n\nfigname = 'img/rce_{}g{}_cld_{}_hro3.png'.format(\n radmodel,fstag,rhlabel)\nprint(\"Writing figure: {}\".format(figname))\nplt.savefig(\n bbox_inches='tight', dpi=300, filename=figname)\n\n# %% wv-only hr\nplt.figure(5)\nplt.clf()\nyls = (10, 1013)\nxls = (-2, 2)\nxtcks = np.linspace(-2,2,3)\nplt.suptitle('H2O HR')\n\nfor i, name in enumerate(anames):\n ax = plt.subplot(1,nsim,i+1)\n plt.hold('on')\n iconv = atms[name].iconv\n icold = atms[name].icold\n try:\n# plt.plot(hr[name].hrir - hr_noo3[name].hrir, atms[name].p,color='crimson')\n# plt.plot(hr[name].hrsw - hr_noo3[name].hrsw, atms[name].p,color='mediumblue')\n plt.plot(hr_wvonly[name].hr, atms[name].p,'g')\n plt.plot(np.zeros(len(atms[name])), atms[name].p, 'k--')\n plt.plot(xtcks, np.ones(len(xtcks))*atms[name].pcold, 'k')\n plt.plot(xtcks, np.ones(len(xtcks))*atms[name].pconv, 'k')\n except ValueError:\n pass\n finally:\n plt.ylim(yls)\n plt.xlim(xls)\n plt.xticks(xtcks)\n plt.xlabel(name.upper())\n ax.invert_yaxis()\n ax.set_yscale('log')\n # plt.yticks(ytcks)\n\n if (i==0):\n plt.ylabel('Pressure (hPa)')\n # ax.yaxis.set_ticklabels(['{:.0f}'.format(tick) for tick in ytcks])\n else:\n ax.yaxis.set_ticklabels([])\nelse:\n plt.show()\n\nfigname = 'img/rce_{}g{}_cld_{}_hrwv.png'.format(\n radmodel,fstag,rhlabel)\nprint(\"Writing figure: {}\".format(figname))\nplt.savefig(\n bbox_inches='tight', dpi=300, filename=figname)\n\n# %% compare o3 profiles\nplt.figure(6)\nplt.clf()\nxls1 = (0,18)\nxls2 = (-1.6, 0.2)\nyls = (1, 1013)\n\nplt.subplot(1,2,1)\nplt.hold('on')\nplt.plot(atms['Trop'].o3*1e6,atms['Trop'].p, label='All Tropics')\nplt.plot(atms['WP'].o3*1e6, atms['WP'].p, label='WP')\nplt.ylim(yls)\nplt.xlim(xls1)\nax = plt.gca()\nax.set_yscale('log')\nax.invert_yaxis()\nplt.title('O3 Profile')\nplt.ylabel('Pressure (hPa)')\nplt.xlabel('Conc. ($10^{-6}$ g/g)')\nplt.legend(loc='best')\n\nplt.subplot(1,2,2)\nplt.hold('on')\nplt.plot(1e6*(atms['WP'].o3-atms['Trop'].o3), atms['WP'].p)\nplt.plot(np.zeros(len(atms['WP'])), atms['WP'].p, 'k--')\nplt.ylim(yls)\nplt.xlim(xls2)\nax = plt.gca()\nax.set_yscale('log')\nax.invert_yaxis()\nplt.title('$\\Delta$ O3')\nplt.xlabel('Conc. ($10^{-6}$ g/g)')\n\n\n\nfigname = 'img/rce_{}g{}_cld_{}_o3prof.png'.format(\n radmodel,fstag,rhlabel)\nprint(\"Writing figure: {}\".format(figname))\nplt.savefig(\n bbox_inches='tight', dpi=300, filename=figname)\n\n\n\n\n# %% show delta T for clouds\nplt.figure(7)\nplt.clf()\nxls1 = (-10,10)\nxls2 = (-10, 10)\nyls = (40, 400)\n\nplt.subplot(1,2,1)\nplt.hold('on')\nnames = anames[1:3]\nref = anames[0]\nfor name in names:\n plt.plot(atms[name].t-atms[ref].t,atms[name].p,label=name)\n plt.plot(atms[name].tconv-atms[ref].t[atms[name].iconv], atms[name].pconv, 'ks')\n plt.plot(atms[name].tcold-atms[ref].t[atms[name].icold], atms[name].pcold, 'ko')\n plt.plot(np.zeros(len(atms[name])),atms[name].p, 'k--')\nplt.ylim(yls)\nplt.xlim(xls1)\nax = plt.gca()\nax.set_yscale('log')\nax.invert_yaxis()\nplt.title('')\nplt.ylabel('Pressure (hPa)')\nplt.xlabel('Temperature (K)')\nplt.legend(loc='best')\n\nplt.subplot(1,2,2)\nplt.hold('on')\nnames = anames[4:6]\nref = anames[3]\nfor name in names:\n plt.plot(atms[name].t-atms[ref].t,atms[name].p,label=name)\n plt.plot(atms[name].tconv-atms[ref].t[atms[name].iconv], atms[name].pconv, 'ks')\n plt.plot(atms[name].tcold-atms[ref].t[atms[name].icold], atms[name].pcold, 'ko')\n plt.plot(np.zeros(len(atms[name])),atms[name].p, 'k--')\nplt.ylim(yls)\nplt.xlim(xls1)\nax = plt.gca()\nax.set_yscale('log')\nax.invert_yaxis()\nplt.title('')\nplt.ylabel('Pressure (hPa)')\nplt.xlabel('Temperature (K)')\nplt.legend(loc='best')\n\n\n\n\nfigname = 'img/rce_{}g{}_cld_{}_tdiff.png'.format(\n radmodel,fstag,rhlabel)\nprint(\"Writing figure: {}\".format(figname))\nplt.savefig(\n bbox_inches='tight', dpi=300, filename=figname)\n\n\n\n# %% plot of cloud heating rates\nplt.figure(8)\nplt.clf()\nxls = (-0.5,1.5)\nyls = (80, 1000)\n\nplt.subplot(131)\nplt.hold('on')\nnames = anames[1:3]\nfor name in names:\n plt.plot(auxhr[name].hr,atms[name].p,label=name)\n plt.plot(auxhr[name].hr[atms[name].iconv], atms[name].pconv, 'ks')\n plt.plot(auxhr[name].hr[atms[name].icold], atms[name].pcold, 'ko')\n plt.plot(np.zeros(len(atms[name])),atms[name].p, 'k--')\nnames = anames[4:6]\nfor name in names:\n plt.plot(auxhr[name].hr,atms[name].p,'--',label=name)\n plt.plot(auxhr[name].hr[atms[name].iconv], atms[name].pconv, 'ks')\n plt.plot(auxhr[name].hr[atms[name].icold], atms[name].pcold, 'ko')\n plt.plot(np.zeros(len(atms[name])),atms[name].p, 'k--')\nplt.ylim(yls)\nplt.xlim(xls)\nax = plt.gca()\nax.set_yscale('log')\nax.invert_yaxis()\nplt.title('')\nplt.ylabel('Pressure (hPa)')\nplt.xlabel('Cloud HR (K/d)')\n#plt.legend(loc='best')\n\nplt.subplot(132)\nplt.hold('on')\nnames = anames[1:3]\nfor name in names:\n plt.plot(auxhr[name].hrir,atms[name].p,label=name)\n plt.plot(auxhr[name].hrir[atms[name].iconv], atms[name].pconv, 'ks')\n plt.plot(auxhr[name].hrir[atms[name].icold], atms[name].pcold, 'ko')\n plt.plot(np.zeros(len(atms[name])),atms[name].p, 'k--')\nnames = anames[4:6]\nfor name in names:\n plt.plot(auxhr[name].hrir,atms[name].p,'--',label=name)\n plt.plot(auxhr[name].hrir[atms[name].iconv], atms[name].pconv, 'ks')\n plt.plot(auxhr[name].hrir[atms[name].icold], atms[name].pcold, 'ko')\n plt.plot(np.zeros(len(atms[name])),atms[name].p, 'k--')\nplt.ylim(yls)\nplt.xlim(xls)\nax = plt.gca()\nax.set_yscale('log')\nax.invert_yaxis()\nplt.title('')\nplt.ylabel('Pressure (hPa)')\nplt.xlabel('Cloud IR HR (K/d)')\n#plt.legend(loc='best')\n\nplt.subplot(133)\nplt.hold('on')\nnames = anames[1:3]\nfor name in names:\n plt.plot(auxhr[name].hrsw,atms[name].p,label=name)\n plt.plot(auxhr[name].hrsw[atms[name].iconv], atms[name].pconv, 'ks')\n plt.plot(auxhr[name].hrsw[atms[name].icold], atms[name].pcold, 'ko')\n plt.plot(np.zeros(len(atms[name])),atms[name].p, 'k--')\nnames = anames[4:6]\nfor name in names:\n plt.plot(auxhr[name].hrsw,atms[name].p,'--',label=name)\n plt.plot(auxhr[name].hrsw[atms[name].iconv], atms[name].pconv, 'ks')\n plt.plot(auxhr[name].hrsw[atms[name].icold], atms[name].pcold, 'ko')\n plt.plot(np.zeros(len(atms[name])),atms[name].p, 'k--')\nplt.ylim(yls)\nplt.xlim(xls)\nax = plt.gca()\nax.set_yscale('log')\nax.invert_yaxis()\nplt.title('')\nplt.ylabel('Pressure (hPa)')\nplt.xlabel('Cloud SW HR (K/d)')\n#plt.legend(loc='best')\n\n\n\n\n\n\n\n\n\n", "meta": {"hexsha": "1a5f290011d74e4b7a482ed4477db19177b7d656", "size": 15399, "ext": "py", "lang": "Python", "max_stars_repo_path": "experiment_cld.py", "max_stars_repo_name": "msmithsm/rce", "max_stars_repo_head_hexsha": "91e6fd2ee93b64a471aa7e0ca62bb4649c1b3b19", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "experiment_cld.py", "max_issues_repo_name": "msmithsm/rce", "max_issues_repo_head_hexsha": "91e6fd2ee93b64a471aa7e0ca62bb4649c1b3b19", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "experiment_cld.py", "max_forks_repo_name": "msmithsm/rce", "max_forks_repo_head_hexsha": "91e6fd2ee93b64a471aa7e0ca62bb4649c1b3b19", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.9981818182, "max_line_length": 102, "alphanum_fraction": 0.6245210728, "include": true, "reason": "import numpy", "num_tokens": 5053, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5350984286266115, "lm_q2_score": 0.36296921241058616, "lm_q1q2_score": 0.19422425520074343}} {"text": "# required tensoefrlow version: 1.14.0\n# conda install -c anaconda tensorflow-gpu==1.14.0\n\nimport Utils\n# import tensorflow as tf\nimport tensorflow.compat.v1 as tf\ntf.disable_v2_behavior()\nimport CNN_Siamese\nimport ResNet_Siamese\nimport numpy as np\nimport matplotlib.pyplot as plt\n# import cv2\nfrom collections import OrderedDict #--> for not repeating legends in plot\nimport umap\nimport os\nfrom Evaluate_embedding_space import Evaluate_embedding_space\nimport dataset_characteristics\n\n# import warnings\n# warnings.filterwarnings('ignore')\n\ndef main():\n #================================ settings:\n train_the_embedding_space = True\n evaluate_the_embedding_space = False\n assert train_the_embedding_space != evaluate_the_embedding_space\n deep_model = \"ResNet\" #--> \"CNN\", \"ResNet\"\n loss_type = \"triplet\" #--> \"triplet\", \"FDA\", \"contrastive\", \"FDA_contrastive\"\n n_res_blocks = 18 #--> 18, 34, 50, 101, 152\n batch_size = 32\n learning_rate = 1e-5\n margin_in_loss = 0.25\n latent_space_dimension = 100\n feature_space_dimension = 2\n path_save_network_model = \".\\\\network_model\\\\\" + deep_model + \"\\\\\"\n model_dir_ = model_dir(model_name=deep_model, n_res_blocks=n_res_blocks, batch_size=batch_size, learning_rate=learning_rate)\n #================================ \n if train_the_embedding_space:\n train_embedding_space(deep_model, n_res_blocks, batch_size, learning_rate, path_save_network_model, model_dir_, feature_space_dimension, latent_space_dimension, margin_in_loss, loss_type)\n if evaluate_the_embedding_space:\n evaluate_embedding_space(path_save_network_model, model_dir_, deep_model, feature_space_dimension, latent_space_dimension, n_res_blocks, margin_in_loss, loss_type)\n\ndef evaluate_embedding_space(path_save_network_model, model_dir_, deep_model, feature_space_dimension, latent_space_dimension, n_res_blocks, margin_in_loss, loss_type):\n which_epoch_to_load_NN_model = 45\n path_save_embeddings_of_test_data = \".\\\\results\\\\\" + deep_model + \"\\\\embedding_test_set\\\\\"\n image_height = dataset_characteristics.get_image_height()\n image_width = dataset_characteristics.get_image_width()\n image_n_channels = dataset_characteristics.get_image_n_channels()\n # path_save_network_model = \"./network_model/ResNet/\"\n if deep_model == \"CNN\":\n siamese = CNN_Siamese.CNN_Siamese(loss_type=loss_type, feature_space_dimension=feature_space_dimension, margin_in_loss=margin_in_loss)\n elif deep_model == \"ResNet\":\n siamese = ResNet_Siamese.ResNet_Siamese(loss_type=loss_type, feature_space_dimension=feature_space_dimension, latent_space_dimension=latent_space_dimension,\n n_res_blocks=n_res_blocks, margin_in_loss=margin_in_loss, is_train=True)\n evaluate_ = Evaluate_embedding_space(checkpoint_dir=path_save_network_model+str(which_epoch_to_load_NN_model)+\"/\", model_dir_=model_dir_)\n (X_train, y_train), (X_test, y_test) = tf.keras.datasets.mnist.load_data()\n # X_train = X_train[:2000, :, :]\n # X_train = X_train.reshape((X_train.shape[0], image_height, image_width, image_n_channels))\n X_test = X_test.reshape((X_test.shape[0], image_height, image_width, image_n_channels))\n # evaluate_.embed_the_data(X=X_train, labels=y_train, siamese=siamese, path_save_embeddings_of_test_data=path_save_embeddings_of_test_data)\n embedding, labels = evaluate_.embed_the_data(X=X_test, labels=y_test, siamese=siamese, path_save_embeddings_of_test_data=path_save_embeddings_of_test_data)\n evaluate_.classify_with_1NN(embedding, labels, path_to_save=path_save_embeddings_of_test_data + \"KNN/\")\n\n\ndef train_embedding_space(deep_model, n_res_blocks, batch_size, learning_rate, path_save_network_model, model_dir_, feature_space_dimension, latent_space_dimension, margin_in_loss, loss_type):\n #================================ settings:\n save_plot_embedding_space = True\n save_points_in_embedding_space = True\n load_saved_network_model = False\n which_epoch_to_load_NN_model = 0\n num_epoch = 51\n save_network_model_every_how_many_epochs = 2\n save_embedding_every_how_many_epochs = 2\n # STEPS_PER_EPOCH_TRAIN = 704\n # STEPS_PER_EPOCH_TRAIN = 16\n STEPS_PER_EPOCH_TRAIN = 312 #--> 10000/32 (n_samples/batch_size)\n n_samples_plot = None #--> if None, plot all\n image_height = dataset_characteristics.get_image_height()\n image_width = dataset_characteristics.get_image_width()\n image_n_channels = dataset_characteristics.get_image_n_channels()\n # path_tfrecords_train = 'C:\\\\Users\\\\bghojogh\\\\Desktop\\\\My_PhD\\\\PhD_projects\\\\Pathology\\\\dataset\\\\TCGA_triplets\\\\tfrecord\\\\triplets.tfrecords'\n # path_tfrecords_train = 'C:\\\\Users\\\\bghojogh\\\\Desktop\\\\My_PhD\\\\PhD_projects\\\\Fisher_loss\\\\codes\\\\4_make_triplets\\\\2_MNIST\\\\triplets\\\\MNIST_1024_triplets\\\\tfrecord\\\\triplets.tfrecords'\n # path_tfrecords_train = 'C:\\\\Users\\\\bghojogh\\\\Desktop\\\\My_PhD\\\\PhD_projects\\\\Fisher_loss\\\\codes\\\\4_make_triplets\\\\2_MNIST\\\\triplets\\\\MNIST_500_triplets\\\\tfrecord\\\\triplets.tfrecords'\n path_tfrecords_train = '.\\\\triplets.tfrecords'\n path_save_embedding_space = \".\\\\results\\\\\" + deep_model + \"\\\\embedding_train_set\\\\\"\n path_save_loss = \".\\\\loss_saved\\\\\"\n #================================ \n\n train_dataset = tf.data.TFRecordDataset([path_tfrecords_train])\n train_dataset = train_dataset.map(Utils.parse_function)\n train_dataset = train_dataset.map(Utils.normalize_triplets)\n\n num_repeat = None\n train_dataset = train_dataset.repeat(num_repeat)\n train_dataset = train_dataset.shuffle(buffer_size=1024)\n train_dataset = train_dataset.batch(batch_size)\n handle = tf.placeholder(tf.string, shape=[])\n iterator = tf.data.Iterator.from_string_handle(handle, train_dataset.output_types,\n train_dataset.output_shapes)\n\n next_element = iterator.get_next()\n # training_iterator = train_dataset.make_initializable_iterator()\n training_iterator = tf.data.make_initializable_iterator(train_dataset)\n\n # Siamese:\n if deep_model == \"CNN\":\n siamese = CNN_Siamese.CNN_Siamese(loss_type=loss_type, feature_space_dimension=feature_space_dimension, margin_in_loss=margin_in_loss)\n elif deep_model == \"ResNet\":\n siamese = ResNet_Siamese.ResNet_Siamese(loss_type=loss_type, feature_space_dimension=feature_space_dimension, latent_space_dimension=latent_space_dimension,\n n_res_blocks=n_res_blocks, margin_in_loss=margin_in_loss, is_train=True)\n # train_step = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(siamese.loss)\n train_step = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(siamese.loss)\n # tf.initialize_all_variables().run()\n\n saver_ = tf.train.Saver(max_to_keep=None) # https://www.tensorflow.org/api_docs/python/tf/compat/v1/train/Saver\n\n with tf.Session() as sess:\n sess.run(tf.global_variables_initializer())\n sess.run(tf.local_variables_initializer())\n\n training_handle = sess.run(training_iterator.string_handle())\n sess.run(training_iterator.initializer)\n\n if load_saved_network_model:\n succesful_load, latest_epoch = load_network_model(saver_=saver_, session_=sess, checkpoint_dir=path_save_network_model+str(which_epoch_to_load_NN_model)+\"/\",\n model_dir_=model_dir_, model_name=deep_model)\n assert (succesful_load == True)\n loss_average_of_epochs = np.load(path_save_loss + \"loss.npy\")\n loss_average_of_epochs = loss_average_of_epochs[:latest_epoch+1]\n loss_average_of_epochs = list(loss_average_of_epochs)\n else:\n latest_epoch = -1\n loss_average_of_epochs = []\n\n for epoch in range(latest_epoch+1, num_epoch):\n losses_in_epoch = []\n print(\"============= epoch: \" + str(epoch) + \"/\" + str(num_epoch-1))\n embeddings_in_epoch = np.zeros((STEPS_PER_EPOCH_TRAIN * batch_size * 3, feature_space_dimension))\n labels_in_epoch = np.zeros((STEPS_PER_EPOCH_TRAIN * batch_size * 3,))\n latent_space_dimension = 100 #--> see the file ResNet_siamese.py\n embeddings_in_epoch_secondToLast = np.zeros((STEPS_PER_EPOCH_TRAIN * batch_size * 3, latent_space_dimension))\n for i in range(STEPS_PER_EPOCH_TRAIN):\n image_anchor, image_neighbor, image_distant, label_anchor, label_neighbor, label_distant = sess.run(next_element,\n feed_dict={handle: training_handle})\n\n image_anchor = image_anchor.reshape((batch_size, image_height, image_width, image_n_channels))\n image_neighbor = image_neighbor.reshape((batch_size, image_height, image_width, image_n_channels))\n image_distant = image_distant.reshape((batch_size, image_height, image_width, image_n_channels))\n\n _, loss_v, embedding1, embedding2, embedding3, \\\n embedding1_secondToLast, embedding2_secondToLast, embedding3_secondToLast = sess.run([train_step, siamese.loss, siamese.o1, siamese.o2, siamese.o3,\n siamese.o1_secondToLast, siamese.o2_secondToLast, siamese.o3_secondToLast], feed_dict={\n siamese.x1: image_anchor,\n siamese.x2: image_neighbor,\n siamese.x3: image_distant})\n\n embeddings_in_epoch[ ((i*3*batch_size)+(0*batch_size)) : ((i*3*batch_size)+(1*batch_size)), : ] = embedding1\n embeddings_in_epoch[ ((i*3*batch_size)+(1*batch_size)) : ((i*3*batch_size)+(2*batch_size)), : ] = embedding2\n embeddings_in_epoch[ ((i*3*batch_size)+(2*batch_size)) : ((i*3*batch_size)+(3*batch_size)), : ] = embedding3\n\n labels_in_epoch[ ((i*3*batch_size)+(0*batch_size)) : ((i*3*batch_size)+(1*batch_size)) ] = label_anchor\n labels_in_epoch[ ((i*3*batch_size)+(1*batch_size)) : ((i*3*batch_size)+(2*batch_size)) ] = label_neighbor\n labels_in_epoch[ ((i*3*batch_size)+(2*batch_size)) : ((i*3*batch_size)+(3*batch_size)) ] = label_distant\n\n embeddings_in_epoch_secondToLast[ ((i*3*batch_size)+(0*batch_size)) : ((i*3*batch_size)+(1*batch_size)), : ] = embedding1_secondToLast\n embeddings_in_epoch_secondToLast[ ((i*3*batch_size)+(1*batch_size)) : ((i*3*batch_size)+(2*batch_size)), : ] = embedding2_secondToLast\n embeddings_in_epoch_secondToLast[ ((i*3*batch_size)+(2*batch_size)) : ((i*3*batch_size)+(3*batch_size)), : ] = embedding3_secondToLast\n\n losses_in_epoch.extend([loss_v])\n \n # report average loss of epoch:\n loss_average_of_epochs.append(np.average(np.asarray(losses_in_epoch)))\n print(\"Average loss of epoch \" + str(epoch) + \": \" + str(loss_average_of_epochs[-1]))\n if not os.path.exists(path_save_loss):\n os.makedirs(path_save_loss)\n np.save(path_save_loss + \"loss.npy\", np.asarray(loss_average_of_epochs))\n\n # plot the embedding space:\n if (epoch % save_embedding_every_how_many_epochs == 0):\n if save_points_in_embedding_space:\n if not os.path.exists(path_save_embedding_space+\"numpy\\\\\"):\n os.makedirs(path_save_embedding_space+\"numpy\\\\\")\n np.save(path_save_embedding_space+\"numpy\\\\embeddings_in_epoch_\" + str(epoch) + \".npy\", embeddings_in_epoch)\n np.save(path_save_embedding_space+\"numpy\\\\labels_in_epoch_\" + str(epoch) + \".npy\", labels_in_epoch)\n # np.save(path_save_embedding_space+\"numpy\\\\embeddings_in_epoch_secondToLast_\" + str(epoch) + \".npy\", embeddings_in_epoch_secondToLast)\n if save_plot_embedding_space:\n print(\"saving the plot of embedding space....\")\n plt.figure(200)\n # fig.clf()\n _, indices_to_plot = plot_embedding_of_points(embeddings_in_epoch, labels_in_epoch, n_samples_plot)\n if not os.path.exists(path_save_embedding_space+\"plots\\\\\"):\n os.makedirs(path_save_embedding_space+\"plots\\\\\")\n plt.savefig(path_save_embedding_space+\"plots\\\\\" + 'epoch' + str(epoch) + '_step' + str(i) + '.png')\n plt.clf()\n plt.close()\n # if not os.path.exists(path_save_embedding_space+\"plots_secondToLast\\\\\"):\n # os.makedirs(path_save_embedding_space+\"plots_secondToLast\\\\\")\n # plot_embedding_of_points_secondToLast(embeddings_in_epoch_secondToLast, labels_in_epoch, indices_to_plot)\n # plt.savefig(path_save_embedding_space+\"plots_secondToLast\\\\\" + 'epoch' + str(epoch) + '_step' + str(i) + '.png')\n # plt.clf()\n # plt.close()\n\n # save the network model:\n if (epoch % save_network_model_every_how_many_epochs == 0):\n # save_network_model(saver_=saver_, session_=sess, checkpoint_dir=path_save_network_model, step=epoch, model_name=deep_model, model_dir_=model_dir_)\n save_network_model(saver_=saver_, session_=sess, checkpoint_dir=path_save_network_model+str(epoch)+\"/\", step=epoch, model_name=deep_model, model_dir_=model_dir_)\n print(\"Model saved in path: %s\" % path_save_network_model)\n\ndef plot_embedding_of_points(embedding, labels, n_samples_plot=None):\n n_samples = embedding.shape[0]\n if n_samples_plot != None:\n indices_to_plot = np.random.choice(range(n_samples), min(n_samples_plot, n_samples), replace=False)\n else:\n indices_to_plot = np.random.choice(range(n_samples), n_samples, replace=False)\n embedding_sampled = embedding[indices_to_plot, :]\n if embedding.shape[1] == 2:\n pass\n else:\n embedding_sampled = umap.UMAP(n_neighbors=500).fit_transform(embedding_sampled)\n n_points = embedding.shape[0]\n # n_points_sampled = embedding_sampled.shape[0]\n labels_sampled = labels[indices_to_plot]\n _, ax = plt.subplots(1, figsize=(14, 10))\n classes = dataset_characteristics.get_class_names()\n n_classes = len(classes)\n plt.scatter(embedding_sampled[:, 0], embedding_sampled[:, 1], s=10, c=labels_sampled, cmap='Spectral', alpha=1.0)\n # plt.setp(ax, xticks=[], yticks=[])\n cbar = plt.colorbar(boundaries=np.arange(n_classes+1)-0.5)\n cbar.set_ticks(np.arange(n_classes))\n cbar.set_ticklabels(classes)\n return plt, indices_to_plot\n\ndef plot_embedding_of_points_secondToLast(embedding_secondToLast, labels, indices_to_plot):\n embedding_sampled = embedding_secondToLast[indices_to_plot, :]\n if embedding_secondToLast.shape[1] == 2:\n pass\n else:\n embedding_sampled = umap.UMAP(n_neighbors=500).fit_transform(embedding_sampled)\n n_points = embedding_secondToLast.shape[0]\n # n_points_sampled = embedding_sampled.shape[0]\n labels_sampled = labels[indices_to_plot]\n _, ax = plt.subplots(1, figsize=(14, 10))\n classes = dataset_characteristics.get_class_names()\n n_classes = len(classes)\n plt.scatter(embedding_sampled[:, 0], embedding_sampled[:, 1], s=10, c=labels_sampled, cmap='Spectral', alpha=1.0)\n # plt.setp(ax, xticks=[], yticks=[])\n cbar = plt.colorbar(boundaries=np.arange(n_classes+1)-0.5)\n cbar.set_ticks(np.arange(n_classes))\n cbar.set_ticklabels(classes)\n return plt\n\ndef save_network_model(saver_, session_, checkpoint_dir, step, model_name, model_dir_):\n # https://stackoverflow.com/questions/33759623/tensorflow-how-to-save-restore-a-model\n # https://github.com/taki0112/ResNet-Tensorflow/blob/master/ResNet.py\n checkpoint_dir = os.path.join(checkpoint_dir, model_dir_)\n if not os.path.exists(checkpoint_dir):\n os.makedirs(checkpoint_dir)\n saver_.save(session_, os.path.join(checkpoint_dir, model_name+'.model'), global_step=step)\n\ndef load_network_model(saver_, session_, checkpoint_dir, model_dir_, model_name):\n # https://stackoverflow.com/questions/33759623/tensorflow-how-to-save-restore-a-model\n print(\" [*] Reading checkpoints...\")\n checkpoint_dir = os.path.join(checkpoint_dir, model_dir_)\n ckpt = tf.train.get_checkpoint_state(checkpoint_dir)\n if ckpt and ckpt.model_checkpoint_path:\n ckpt_name = os.path.basename(ckpt.model_checkpoint_path)\n saver_.restore(session_, os.path.join(checkpoint_dir, ckpt_name))\n print(\" [*] Success to read {}\".format(ckpt_name))\n latest_epoch = int(ckpt_name.split(\"-\")[-1])\n return True, latest_epoch\n else:\n print(\" [*] Failed to find a checkpoint\")\n return False, 0\n\n\ndef model_dir(model_name, n_res_blocks, batch_size, learning_rate):\n return \"{}_{}_{}_{}\".format(model_name, n_res_blocks, batch_size, learning_rate)\n\n\nif __name__ == \"__main__\":\n main()", "meta": {"hexsha": "90ac58c74c734b3a4760bc4d0cea571e8039a3c1", "size": 17349, "ext": "py", "lang": "Python", "max_stars_repo_path": "2_deep_codes/3_Siamese_triplet/main.py", "max_stars_repo_name": "bghojogh/Quantile-Quantile-Embedding", "max_stars_repo_head_hexsha": "5daff878a838f6dbeb04cc0b15da2ad66ab9796c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-09-19T17:50:50.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-19T17:50:50.000Z", "max_issues_repo_path": "2_deep_codes/3_Siamese_triplet/main.py", "max_issues_repo_name": "bghojogh/Quantile-Quantile-Embedding", "max_issues_repo_head_hexsha": "5daff878a838f6dbeb04cc0b15da2ad66ab9796c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "2_deep_codes/3_Siamese_triplet/main.py", "max_forks_repo_name": "bghojogh/Quantile-Quantile-Embedding", "max_forks_repo_head_hexsha": "5daff878a838f6dbeb04cc0b15da2ad66ab9796c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 61.7402135231, "max_line_length": 195, "alphanum_fraction": 0.6852268142, "include": true, "reason": "import numpy", "num_tokens": 4021, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5350984137988772, "lm_q2_score": 0.3629692055196168, "lm_q1q2_score": 0.19422424613138564}} {"text": "# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Thu Jun 16 13:24:45 2016\n\n@author: Ent00002\n\"\"\"\n\n# delayed runs, comment the 2 lines below when unused\n# import time\n# time.sleep(100)\n\n#%% Import libraries\n\nimport numpy as np\nimport scipy.io as sio\nimport calendar\nimport datetime\nfrom getconstants import getconstants\nfrom timeit import default_timer as timer\nimport os\n\n#%%BEGIN OF INPUT1 (FILL THIS IN)\nyears\t\t= np.arange(1979,2016)\t# Note that this can be forward as tracking was already finished, whereas the masterscript must be in backward order\nyearpart\t= np.arange(0,366)\t# for a full (leap)year fill in np.arange(0,366)\ndaily\t\t= 0\t\t\t# 1 for writing out daily data, 0 for only monthly data\ntimetracking\t= 1\t\t\t# 0 for not tracking time and 1 for tracking time\n\n# Manage the extent of your dataset (FILL THIS IN)\n# Define the latitude and longitude cell numbers to consider and corresponding lakes that should be considered part of the land\nlatnrs = np.arange(7,114)\nlonnrs = np.arange(0,240)\n\n# the lake numbers below belong to the ERA-Interim data on 1.5 degree starting at Northern latitude 79.5 and longitude -180\nlake_mask_1 = np.array([9,9,9,12,12,21,21,22,22,23,24,25,23,23,25,25,53,54,61,23,24,23,24,25,27,22,23,24,25,26,27,28,22,25,26,27,28,23,23,12,18])\nlake_mask_2 = np.array([120+19,120+40,120+41,120+43,120+44,120+61,120+62,120+62,120+63,120+62,120+62,120+62,120+65,120+66,120+65,120+66,142-120,142-120,143-120,152-120,152-120,153-120,153-120,153-120,153-120,154-120,154-120,154-120,154-120,154-120,154-120,154-120,155-120,155-120,155-120,155-120,155-120,159-120,160-120,144-120,120+55])\nlake_mask = np.transpose(np.vstack((lake_mask_1,lake_mask_2))) #recreate the arrays of the matlab model\n\n# obtain the constants\ninvariant_data = '/home/users/lguo/CSSP/WAM2layersPython-master/download_scripts/invariants.nc'\t#invariants\nlatitude,longitude,lsm,g,density_water,timestep,A_gridcell,L_N_gridcell,L_S_gridcell,L_EW_gridcell,gridcell = getconstants(latnrs,lonnrs,lake_mask,invariant_data)\n\ninterdata_folder = r'/home/users/lguo/CSSP/WAM2layersPython-master/interdata'\noutput_folder = r'/home/users/lguo/CSSP/WAM2layersPython-master/output'\nsub_interdata_folder = os.path.join(interdata_folder, 'cn1_backward')\n\n#END OF INPUT\n\n#%% Datapaths (FILL THIS IN)\n\n\ndef data_path(y,a,years,timetracking):\n load_Sa_track = os.path.join(sub_interdata_folder, str(y) + '-' + str(a) + 'Sa_track.mat')\n load_Sa_time = os.path.join(sub_interdata_folder, str(y) + '-' + str(a) + 'Sa_time.mat')\n load_fluxes_and_storages = os.path.join(interdata_folder, str(y) + '-' + str(a) + 'fluxes_storages.mat')\n\n save_path = os.path.join(output_folder, 'E_track_cn1_full' + str(years[0]) + '-' + str(years[-1]) + '-timetracking' + str(timetracking) + '.mat')\n save_path_daily = os.path.join(output_folder, 'E_track_cn1_daily_full' + str(y) + '-timetracking' + str(timetracking) + '.mat')\n\n return load_Sa_track,load_Sa_time,load_fluxes_and_storages,save_path,save_path_daily\n\n\n#%% Runtime & Results\nstart1 = timer()\nstartyear = years[0]\n\nE_per_year_per_month\t\t= np.zeros((len(years),12,len(latitude),len(longitude)))\nE_track_per_year_per_month\t= np.zeros((len(years),12,len(latitude),len(longitude)))\nP_per_year_per_month\t\t= np.zeros((len(years),12,len(latitude),len(longitude)))\nSa_track_down_per_year_per_month= np.zeros((len(years),12,len(latitude),len(longitude)))\nSa_track_top_per_year_per_month = np.zeros((len(years),12,len(latitude),len(longitude)))\nW_down_per_year_per_month\t= np.zeros((len(years),12,len(latitude),len(longitude)))\nW_top_per_year_per_month\t= np.zeros((len(years),12,len(latitude),len(longitude)))\nnorth_loss_per_year_per_month\t= np.zeros((len(years),12,1,len(longitude)))\nsouth_loss_per_year_per_month\t= np.zeros((len(years),12,1,len(longitude)))\ndown_to_top_per_year_per_month\t= np.zeros((len(years),12,len(latitude),len(longitude)))\ntop_to_down_per_year_per_month\t= np.zeros((len(years),12,len(latitude),len(longitude)))\nwater_lost_per_year_per_month\t= np.zeros((len(years),12,len(latitude),len(longitude)))\n\nif timetracking == 1:\n Sa_time_down_per_year_per_month\t= np.zeros((len(years),12,len(latitude),len(longitude)))\n Sa_time_top_per_year_per_month\t= np.zeros((len(years),12,len(latitude),len(longitude)))\n E_time_per_year_per_month\t\t= np.zeros((len(years),12,len(latitude),len(longitude)))\n Sa_dist_down_per_year_per_month\t= np.zeros((len(years),12,len(latitude),len(longitude)))\n Sa_dist_top_per_year_per_month\t= np.zeros((len(years),12,len(latitude),len(longitude)))\n E_dist_per_year_per_month\t\t= np.zeros((len(years),12,len(latitude),len(longitude)))\n\nfor i in range(len(years)):\n y = years[i]\n ly = int(calendar.isleap(y))\n final_time = 364+ly\n \n E_per_day\t\t\t= np.zeros((365+ly,len(latitude),len(longitude)))\n E_track_per_day\t\t= np.zeros((365+ly,len(latitude),len(longitude)))\n P_per_day\t\t\t= np.zeros((365+ly,len(latitude),len(longitude)))\n Sa_track_down_per_day\t= np.zeros((365+ly,len(latitude),len(longitude)))\n Sa_track_top_per_day\t= np.zeros((365+ly,len(latitude),len(longitude)))\n W_down_per_day\t\t= np.zeros((365+ly,len(latitude),len(longitude)))\n W_top_per_day\t\t= np.zeros((365+ly,len(latitude),len(longitude)))\n north_loss_per_day\t\t= np.zeros((365+ly,1,len(longitude)))\n south_loss_per_day\t\t= np.zeros((365+ly,1,len(longitude)))\n down_to_top_per_day\t\t= np.zeros((365+ly,len(latitude),len(longitude)))\n top_to_down_per_day\t\t= np.zeros((365+ly,len(latitude),len(longitude)))\n water_lost_per_day\t\t= np.zeros((365+ly,len(latitude),len(longitude)))\n if timetracking == 1:\n Sa_time_down_per_day\t= np.zeros((365+ly,len(latitude),len(longitude)))\n Sa_time_top_per_day\t= np.zeros((365+ly,len(latitude),len(longitude)))\n E_time_per_day\t\t= np.zeros((365+ly,len(latitude),len(longitude)))\n Sa_dist_down_per_day\t= np.zeros((365+ly,len(latitude),len(longitude)))\n Sa_dist_top_per_day\t= np.zeros((365+ly,len(latitude),len(longitude)))\n E_dist_per_day\t\t= np.zeros((365+ly,len(latitude),len(longitude)))\n \n for j in range(len(yearpart)):\n start = timer()\n a = yearpart[j]\n datapath = data_path(y,a,years,timetracking)\n if a > final_time: # a = 365 (366th index) and not a leapyear\\\n pass\n else:\n # load tracked data [97,107,240]\n loading_ST = sio.loadmat(datapath[0],verify_compressed_data_integrity=False)\n Sa_track_top\t= loading_ST['Sa_track_top']\n Sa_track_down\t= loading_ST['Sa_track_down']\n north_loss\t\t= loading_ST['north_loss']\n south_loss\t\t= loading_ST['south_loss']\n down_to_top\t\t= loading_ST['down_to_top']\n top_to_down\t\t= loading_ST['top_to_down']\n water_lost\t\t= loading_ST['water_lost']\n Sa_track\t\t= Sa_track_top + Sa_track_down\n if timetracking == 1:\n loading_STT = sio.loadmat(datapath[1],verify_compressed_data_integrity=False)\n Sa_time_top\t= loading_STT['Sa_time_top']\n Sa_time_down\t= loading_STT['Sa_time_down']\n Sa_dist_top\t= loading_STT['Sa_dist_top']\n Sa_dist_down\t= loading_STT['Sa_dist_down']\n \n # load the total moisture data [96/97,107,240]\n loading_FS = sio.loadmat(datapath[2],verify_compressed_data_integrity=False)\n Fa_E_top\t= loading_FS['Fa_E_top']\n Fa_N_top\t= loading_FS['Fa_N_top']\n Fa_E_down\t= loading_FS['Fa_E_down']\n Fa_N_down\t= loading_FS['Fa_N_down']\n Fa_Vert\t= loading_FS['Fa_Vert']\n E\t\t= loading_FS['E']\n P\t\t= loading_FS['P']\n W_top\t= loading_FS['W_top']\n W_down\t= loading_FS['W_down']\n W = W_top + W_down\n \n # compute tracked evaporation [96,107,240]\n\t # LG: E_track is calculated via the bottom layer Sa.\n E_track = E[:,:,:] * (Sa_track_down[1:,:,:] / W_down[1:,:,:])\n \n # save per day\n E_per_day[a,:,:]\t\t\t= np.sum(E, axis =0)\n E_track_per_day[a,:,:]\t\t= np.sum(E_track, axis =0)\n P_per_day[a,:,:]\t\t\t= np.sum(P, axis =0)\n Sa_track_down_per_day[a,:,:]\t= np.mean(Sa_track_down[1:,:,:], axis =0)\n Sa_track_top_per_day[a,:,:]\t\t= np.mean(Sa_track_top[1:,:,:], axis =0)\n W_down_per_day[a,:,:]\t\t= np.mean(W_down[1:,:,:], axis =0)\n W_top_per_day[a,:,:]\t\t= np.mean(W_top[1:,:,:], axis =0)\n \n north_loss_per_day[a,:,:]\t\t= np.sum(north_loss, axis =0)\n south_loss_per_day[a,:,:]\t\t= np.sum(south_loss, axis =0)\n down_to_top_per_day[a,:,:]\t\t= np.sum(down_to_top, axis =0)\n top_to_down_per_day[a,:,:]\t\t= np.sum(top_to_down, axis =0)\n water_lost_per_day[a,:,:]\t\t= np.sum(water_lost, axis =0)\n \n if timetracking == 1:\n # compute tracked evaporation time [96,107,240]\n\t\t# LG: E_time is mean of two concecutive timesteps\n E_time = 0.5 * ( Sa_time_down[:-1,:,:] + Sa_time_down[1:,:,:] )\t\t\t\t\t# seconds\n # save per day\n Sa_time_down_per_day[a,:,:]\t= np.mean(Sa_time_down[:-1,:,:], axis=0)\t\t\t# seconds\n Sa_time_top_per_day[a,:,:]\t= np.mean(Sa_time_top[:-1,:,:], axis=0)\t\t\t\t# seconds\n E_time_per_day[a,:,:]\t\t= np.sum((E_time * E_track), axis = 0) / E_track_per_day[a,:,:]\t# seconds\n # remove nans \n where_are_NaNs = np.isnan(E_time_per_day)\n E_time_per_day[where_are_NaNs] = 0\n\n # compute tracked evaporation distance [96,107,240]\n E_dist = 0.5 * ( Sa_dist_down[:-1,:,:] + Sa_dist_down[1:,:,:] )\t\t\t\t\t# m\n # save per day\n Sa_dist_down_per_day[a,:,:]\t= np.mean(Sa_dist_down[:-1,:,:], axis=0)\t\t\t# m\n Sa_dist_top_per_day[a,:,:]\t= np.mean(Sa_dist_top[:-1,:,:], axis=0)\t\t\t\t# m\n E_dist_per_day[a,:,:]\t\t= np.sum((E_dist * E_track), axis = 0) / E_track_per_day[a,:,:]\t# m\n # remove nans \n where_are_NaNs = np.isnan(E_dist_per_day)\n E_dist_per_day[where_are_NaNs] = 0\n \n end = timer()\n print 'Runtime output for day ' + str(a+1) + ' in year ' + str(y) + ' is',(end - start),' seconds.'\n \n if daily == 1:\n if timetracking == 0: # create dummy values\n Sa_time_down_per_day\t= 0\n Sa_time_top_per_day\t\t= 0\n E_time_per_day\t\t= 0\n \n sio.savemat(datapath[4],\n {'E_per_day':E_per_day,'E_track_per_day':E_track_per_day,'P_per_day':P_per_day,\n 'Sa_track_down_per_day':Sa_track_down_per_day,'Sa_track_top_per_day':Sa_track_top_per_day, \n 'Sa_time_down_per_day':Sa_time_down_per_day,'Sa_time_top_per_day':Sa_time_top_per_day, \n 'Sa_dist_down_per_day':Sa_dist_down_per_day,'Sa_dist_top_per_day':Sa_dist_top_per_day, \n 'W_down_per_day':W_down_per_day,'W_top_per_day':W_top_per_day,\n 'E_time_per_day':E_time_per_day,'E_dist_per_day':E_dist_per_day},do_compression=True)\n\n # values per month \n for m in range(12):\n first_day = int(datetime.date(y,m+1,1).strftime(\"%j\"))\n last_day = int(datetime.date(y,m+1,calendar.monthrange(y,m+1)[1]).strftime(\"%j\"))\n days = np.arange(first_day,last_day+1)-1\t\t\t\t\t\t# -1 because Python is zero-based\n \n E_per_year_per_month[y-startyear,m,:,:]\t\t\t= (np.squeeze(np.sum(E_per_day[days,:,:], axis = 0)))\n E_track_per_year_per_month[y-startyear,m,:,:]\t\t= (np.squeeze(np.sum(E_track_per_day[days,:,:], axis = 0)))\n P_per_year_per_month[y-startyear,m,:,:]\t\t\t= (np.squeeze(np.sum(P_per_day[days,:,:], axis = 0)))\n Sa_track_down_per_year_per_month[y-startyear,m,:,:]\t= (np.squeeze(np.mean(Sa_track_down_per_day[days,:,:], axis = 0)))\n Sa_track_top_per_year_per_month[y-startyear,m,:,:]\t= (np.squeeze(np.mean(Sa_track_top_per_day[days,:,:], axis = 0)))\n W_down_per_year_per_month[y-startyear,m,:,:]\t\t= (np.squeeze(np.mean(W_down_per_day[days,:,:], axis = 0)))\n W_top_per_year_per_month[y-startyear,m,:,:]\t\t= (np.squeeze(np.mean(W_top_per_day[days,:,:], axis = 0)))\n north_loss_per_year_per_month[y-startyear,m,:,:]\t= (np.squeeze(np.sum(north_loss_per_day[days,:,:], axis = 0)))\n south_loss_per_year_per_month[y-startyear,m,:,:]\t= (np.squeeze(np.sum(south_loss_per_day[days,:,:], axis = 0)))\n down_to_top_per_year_per_month[y-startyear,m,:,:]\t= (np.squeeze(np.sum(down_to_top_per_day[days,:,:], axis = 0)))\n top_to_down_per_year_per_month[y-startyear,m,:,:]\t= (np.squeeze(np.sum(top_to_down_per_day[days,:,:], axis = 0)))\n water_lost_per_year_per_month[y-startyear,m,:,:]\t= (np.squeeze(np.sum(water_lost_per_day[days,:,:], axis = 0)))\n \n if timetracking == 1:\n # tracked time\n Sa_time_down_per_year_per_month[y-startyear,m,:,:]\t= (np.squeeze(np.mean(Sa_time_down_per_day[days,:,:], axis = 0)))\n Sa_time_top_per_year_per_month[y-startyear,m,:,:]\t= (np.squeeze(np.mean(Sa_time_top_per_day[days,:,:], axis =0)))\n E_time_per_year_per_month[y-startyear,m,:,:]\t= (np.squeeze(np.sum( E_time_per_day[days,:,:] \n * E_track_per_day[days,:,:], axis=0)) / np.squeeze(E_track_per_year_per_month[y-startyear,m,:,:]))\n \n # remove nans \n where_are_NaNs = np.isnan(E_time_per_year_per_month)\n E_time_per_year_per_month[where_are_NaNs] = 0\n\n # tracked distance\n Sa_dist_down_per_year_per_month[y-startyear,m,:,:]\t= (np.squeeze(np.mean(Sa_dist_down_per_day[days,:,:], axis = 0)))\n Sa_dist_top_per_year_per_month[y-startyear,m,:,:]\t= (np.squeeze(np.mean(Sa_dist_top_per_day[days,:,:], axis =0)))\n E_dist_per_year_per_month[y-startyear,m,:,:]\t= (np.squeeze(np.sum( E_dist_per_day[days,:,:] \n * E_track_per_day[days,:,:], axis=0)) / np.squeeze(E_track_per_year_per_month[y-startyear,m,:,:]))\n \n # remove nans \n where_are_NaNs = np.isnan(E_dist_per_year_per_month)\n E_dist_per_year_per_month[where_are_NaNs] = 0\n \n elif timetracking == 0:\n Sa_time_down_per_year_per_month\t= 0\n Sa_time_top_per_year_per_month\t= 0\n E_time_per_year_per_month\t\t= 0\n Sa_dist_down_per_year_per_month\t= 0\n Sa_dist_top_per_year_per_month\t= 0\n E_dist_per_year_per_month\t\t= 0\n\n# save monthly data\nsio.savemat(datapath[3],\n {'E_per_year_per_month':E_per_year_per_month,'E_track_per_year_per_month':E_track_per_year_per_month,'P_per_year_per_month':P_per_year_per_month,\n 'Sa_track_down_per_year_per_month':Sa_track_down_per_year_per_month,'Sa_track_top_per_year_per_month':Sa_track_top_per_year_per_month, \n 'Sa_time_down_per_year_per_month':Sa_time_down_per_year_per_month,'Sa_time_top_per_year_per_month':Sa_time_top_per_year_per_month, \n 'E_time_per_year_per_month':E_time_per_year_per_month, 'Sa_dist_down_per_year_per_month':Sa_dist_down_per_year_per_month,'Sa_dist_top_per_year_per_month':Sa_dist_top_per_year_per_month, 'E_dist_per_year_per_month':E_dist_per_year_per_month, 'W_down_per_year_per_month':W_down_per_year_per_month,'W_top_per_year_per_month':W_top_per_year_per_month,\n 'north_loss_per_year_per_month':north_loss_per_year_per_month,'south_loss_per_year_per_month':south_loss_per_year_per_month,\n 'down_to_top_per_year_per_month':down_to_top_per_year_per_month,'top_to_down_per_year_per_month':top_to_down_per_year_per_month,\n 'water_lost_per_year_per_month':water_lost_per_year_per_month})\n\nend1 = timer()\nprint 'The total runtime of Con_E_Recyc_Output is',(end1-start1),' seconds.'\n", "meta": {"hexsha": "4b69b069f8b5dcf38f4a5aae996f9ce39d92420d", "size": 15955, "ext": "py", "lang": "Python", "max_stars_repo_path": "WAM-2layers/Con_E_Recyc_Output.py", "max_stars_repo_name": "nick-klingaman/dubstep", "max_stars_repo_head_hexsha": "576ac6efa1748933aa37ae28a41e77c8c0dbe2ab", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "WAM-2layers/Con_E_Recyc_Output.py", "max_issues_repo_name": "nick-klingaman/dubstep", "max_issues_repo_head_hexsha": "576ac6efa1748933aa37ae28a41e77c8c0dbe2ab", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "WAM-2layers/Con_E_Recyc_Output.py", "max_forks_repo_name": "nick-klingaman/dubstep", "max_forks_repo_head_hexsha": "576ac6efa1748933aa37ae28a41e77c8c0dbe2ab", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-02-21T06:35:51.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-21T06:35:51.000Z", "avg_line_length": 59.7565543071, "max_line_length": 359, "alphanum_fraction": 0.6612973989, "include": true, "reason": "import numpy,import scipy", "num_tokens": 4544, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.5350984286266115, "lm_q2_score": 0.3629691917376783, "lm_q1q2_score": 0.1942242441387029}} {"text": "#!/usr/bin/env python\n\"\"\"\nProgram for the regression of mlp about paramagnetic FCC Fe\n\"\"\"\n\nimport argparse\nimport copy\n\n# import time\n# import tqdm\nimport random\n\nimport numpy as np\nfrom mlptools.common.fileio import InputParams\nfrom mlptools.common.structure import Structure\nfrom mlptools.mlpgen.model import Terms\nfrom mlptools.mlpgen.myIO import ReadFeatureParams, read_regression_params\nfrom mlptools.mlpgen.regression import PotEstimation\n\n\ndef rearange_L(array, index_array):\n \"\"\"Move designated columns to the head of array.\n\n Args:\n array (ndarray): input array(2D)\n index_array (list): list of index by which columns are designated\n\n Returns:\n ndarray: changed array\n \"\"\"\n rest = np.delete(array, index_array, 1)\n return np.hstack((array[:, index_array], rest))\n\n\nclass VirtualDataInput:\n \"\"\"Generate a virtual DataInput from normal DataInput\"\"\"\n\n def __init__(self, di):\n self.vdi = copy.deepcopy(di)\n self.vdi.n_type = 2\n\n def get_data_input(self):\n \"\"\"Return a newly generated DataInput.\n\n Returns:\n DataInput: virtual DataInput\n \"\"\"\n return self.vdi\n\n\nclass MagneticStructuralFeatures:\n \"\"\"Data structure including magnetic structural features\"\"\"\n\n def __init__(self, tr, spin_array, vdi):\n st_set_all_train = self.get_virtual_structures(tr.train, spin_array)\n n_st_dataset = [len(data.st_set) for data in tr.train]\n term = Terms(st_set_all_train, vdi, n_st_dataset, vdi.train_force)\n self.train_x = np.hstack((tr.train_x, term.get_x()))\n st_set_all_test = self.get_virtual_structures(tr.test, spin_array)\n n_st_dataset = [len(data.st_set) for data in tr.test]\n force_dataset = [vdi.wforce for v in vdi.test_names]\n term = Terms(st_set_all_test, vdi, n_st_dataset, force_dataset)\n self.test_x = np.hstack((tr.test_x, term.get_x()))\n\n def get_x(self):\n \"\"\"Return the X matrices for regression\n\n Returns:\n ndarray: X matrices needed for training and test\n \"\"\"\n return self.train_x, self.test_x\n\n def get_virtual_structures(self, dataset, spin_array):\n \"\"\"Generate virtual structures from dataset based on spin_array and return the\n list of them\n\n Args:\n dataset (dr_array): array of the instances, DataRegression\n spin_array (ndarray): which spin each atom has\n\n Returns:\n list: list of rewrited structures\n \"\"\"\n index_array = np.nonzero(spin_array == 1)[0]\n n_atom_1 = len(index_array)\n n_atom_2 = sum(dataset[0].st_set[0].n_atoms) - len(index_array)\n n_atoms = [n_atom_1, n_atom_2]\n specie1 = [\"A\" for i in range(n_atom_1)]\n specie2 = [\"B\" for i in range(n_atom_2)]\n elements = specie1.extend(specie2)\n type1 = [0 for i in range(n_atom_1)]\n type2 = [1 for i in range(n_atom_2)]\n types = type1.extend(type2)\n st_list = [\n Structure(\n st.axis,\n rearange_L(st.positions, index_array),\n n_atoms,\n elements,\n types=types,\n comment=st.comment,\n )\n for data in dataset\n for st in data.st_set\n ]\n return st_list\n\n\nif __name__ == \"__main__\":\n parser = argparse.ArgumentParser()\n parser.add_argument(\n \"-i\",\n \"--infile\",\n type=str,\n required=True,\n help=\"Input file name. Training is performed from vasprun files.\",\n )\n parser.add_argument(\n \"-p\",\n \"--pot\",\n type=str,\n default=\"mlp.pkl\",\n help=\"Potential file name for mlptools\",\n )\n args = parser.parse_args()\n\n # prepare temporary spin array\n spin_array = np.array(random.choices([-1, 1], k=32))\n\n p = InputParams(args.infile)\n di = ReadFeatureParams(p).get_params()\n vdi = VirtualDataInput(di).get_data_input()\n\n # calculate structural features\n tr = PotEstimation(di=di)\n # calculate magnetic structural features\n tr.train_x, tr.test_x = MagneticStructuralFeatures(tr, spin_array, vdi).get_x()\n tr.set_regression_data()\n\n # start regression\n if args.noreg is False:\n reg_method, alpha_min, alpha_max, n_alpha = read_regression_params(p)\n if reg_method == \"ridge\" or reg_method == \"lasso\":\n pot = tr.regularization_reg(\n method=reg_method,\n alpha_min=alpha_min,\n alpha_max=alpha_max,\n n_alpha=n_alpha,\n svd=args.svd,\n )\n elif reg_method == \"normal\":\n pot = tr.normal_reg()\n\n pot.save_pot(file_name=args.pot)\n pot.save_pot_for_lammps(file_name=args.lammps)\n\n print(\" --- input parameters ----\")\n pot.di.model_e.print()\n print(\" --- best model ----\")\n if reg_method == \"ridge\" or reg_method == \"lasso\":\n print(\" alpha = \", tr.best_alpha)\n\n (\n rmse_train_e,\n rmse_test_e,\n rmse_train_f,\n files_train,\n rmse_test_f,\n rmse_train_s,\n rmse_test_s,\n files_test,\n ) = tr.get_best_rmse()\n\n print(\" -- Prediction Error --\")\n for re, rf, rs, f in zip(rmse_train_e, rmse_train_f, rmse_train_s, files_train):\n print(\" structures :\", f)\n print(\" rmse (energy, train) = \", re * 1000, \" (meV/atom)\")\n if rf is not None:\n print(\" rmse (force, train) = \", rf, \" (eV/ang)\")\n print(\" rmse (stress, train) = \", rs, \" (GPa)\")\n for re, rf, rs, f in zip(rmse_test_e, rmse_test_f, rmse_test_s, files_test):\n print(\" structures :\", f)\n print(\" rmse (energy, test) = \", re * 1000, \" (meV/atom)\")\n if rf is not None:\n print(\" rmse (force, test) = \", rf, \" (eV/ang)\")\n print(\" rmse (stress, test) = \", rs, \" (GPa)\")\n", "meta": {"hexsha": "4056b751c293d98a603ec05dd914fca16e0d04b0", "size": 6010, "ext": "py", "lang": "Python", "max_stars_repo_path": "my_codes/mlpgen/_regression.py", "max_stars_repo_name": "iwamura-lab/my_codes", "max_stars_repo_head_hexsha": "70140fe81b70d7ea4969c442771db40054cc109e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "my_codes/mlpgen/_regression.py", "max_issues_repo_name": "iwamura-lab/my_codes", "max_issues_repo_head_hexsha": "70140fe81b70d7ea4969c442771db40054cc109e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "my_codes/mlpgen/_regression.py", "max_forks_repo_name": "iwamura-lab/my_codes", "max_forks_repo_head_hexsha": "70140fe81b70d7ea4969c442771db40054cc109e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.1390374332, "max_line_length": 88, "alphanum_fraction": 0.5941763727, "include": true, "reason": "import numpy", "num_tokens": 1458, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6113819732941511, "lm_q2_score": 0.31742625267332647, "lm_q1q2_score": 0.19406868873478614}} {"text": "\"\"\"\nCommon solar physics coordinate systems.\n\nThis submodule implements various solar physics coordinate frames for use with\nthe `astropy.coordinates` module.\n\"\"\"\nfrom contextlib import contextmanager\n\nimport numpy as np\n\nimport astropy.units as u\nfrom astropy.coordinates import ConvertError, QuantityAttribute\nfrom astropy.coordinates.baseframe import BaseCoordinateFrame, RepresentationMapping\nfrom astropy.coordinates.representation import (\n CartesianDifferential,\n CartesianRepresentation,\n CylindricalRepresentation,\n SphericalDifferential,\n SphericalRepresentation,\n UnitSphericalRepresentation,\n)\nfrom astropy.time import Time\n\nfrom sunpy import log\nfrom sunpy.sun.constants import radius as _RSUN\nfrom sunpy.time.time import _variables_for_parse_time_docstring\nfrom sunpy.util.decorators import add_common_docstring\nfrom sunpy.util.exceptions import warn_user\nfrom .frameattributes import ObserverCoordinateAttribute, TimeFrameAttributeSunPy\n\n_J2000 = Time('J2000.0', scale='tt')\n\n__all__ = ['SunPyBaseCoordinateFrame', 'BaseHeliographic',\n 'HeliographicStonyhurst', 'HeliographicCarrington',\n 'Heliocentric', 'Helioprojective',\n 'HeliocentricEarthEcliptic', 'GeocentricSolarEcliptic',\n 'HeliocentricInertial', 'GeocentricEarthEquatorial']\n\n\ndef _frame_parameters():\n \"\"\"\n Returns formatting dictionary to use with add_common_docstring to populate frame docstrings\n \"\"\"\n ret = {}\n\n # Each text block is missing the first indent because it already exists in the frame docstring\n ret['data'] = (\"data : `~astropy.coordinates.BaseRepresentation` or ``None``\\n\"\n \" A representation object or ``None`` to have no data\\n\"\n \" (or use the coordinate component arguments, see below).\")\n ret['common'] = (f\"obstime : {_variables_for_parse_time_docstring()['parse_time_types']}\\n\"\n \" The time of the observation. This is used to determine the\\n\"\n \" position of solar-system bodies (e.g., the Sun and the Earth) as\\n\"\n \" needed to define the origin and orientation of the frame.\\n\"\n \" representation_type : `~astropy.coordinates.BaseRepresentation`, str, optional\\n\"\n \" A representation class or string name of a representation class.\\n\"\n \" This may change the valid coordinate component arguments from the\\n\"\n \" defaults (see above). For example, passing\\n\"\n \" ``representation_type='cartesian'`` will make the frame expect\\n\"\n \" Cartesian coordinate component arguments (typically, ``x``, ``y``,\\n\"\n \" and ``z``).\\n\"\n \" copy : bool, optional\\n\"\n \" If `True` (default), make copies of the input coordinate arrays.\")\n ret['lonlat'] = (\"lon : `~astropy.coordinates.Angle` or `~astropy.units.Quantity`, optional\\n\"\n \" The longitude coordinate for this object (``lat`` must also be\\n\"\n \" given and ``data`` must be ``None``).\\n\"\n \" Not needed if ``data`` is given.\\n\"\n \" lat : `~astropy.coordinates.Angle` or `~astropy.units.Quantity`, optional\\n\"\n \" The latitude coordinate for this object (``lon`` must also be\\n\"\n \" given and ``data`` must be ``None``).\\n\"\n \" Not needed if ``data`` is given.\")\n ret['radius'] = (\"radius : `~astropy.units.Quantity`, optional\\n\"\n \" The radial distance coordinate from Sun center for this object.\\n\"\n \" Defaults to the radius of the Sun. Not needed if ``data`` is given.\")\n ret['distance_sun'] = (\"distance : `~astropy.units.Quantity`, optional\\n\"\n \" The distance coordinate from Sun center for this object.\\n\"\n \" Not needed if ``data`` is given.\")\n ret['distance_earth'] = (\"distance : `~astropy.units.Quantity`, optional\\n\"\n \" The distance coordinate from Earth center for this object.\\n\"\n \" Not needed if ``data`` is given.\")\n ret['xyz'] = (\"x : `~astropy.units.Quantity`, optional\\n\"\n \" X-axis coordinate for this object. Not needed if ``data`` is given.\\n\"\n \" y : `~astropy.units.Quantity`, optional\\n\"\n \" Y-axis coordinate for this object. Not needed if ``data`` is given.\\n\"\n \" z : `~astropy.units.Quantity`, optional\\n\"\n \" Z-axis coordinate for this object. Not needed if ``data`` is given.\")\n ret['observer'] = (\"observer : `~sunpy.coordinates.frames.HeliographicStonyhurst`, str\\n\"\n \" The location of the observer. If a string is provided,\\n\"\n \" it must be a solar system body that can be parsed by\\n\"\n \" `~sunpy.coordinates.ephemeris.get_body_heliographic_stonyhurst`\\n\"\n \" at the time ``obstime``. Defaults to Earth center.\")\n ret['rsun'] = (\"rsun : `~astropy.units.Quantity`\\n\"\n \" The radius of the Sun in length units. Used to convert a 2D\\n\"\n \" coordinate (i.e., no ``radius`` component) to a 3D coordinate by\\n\"\n \" assuming that the coordinate is on the surface of the Sun. Defaults\\n\"\n \" to the photospheric radius as defined in `sunpy.sun.constants`.\")\n ret['equinox'] = (f\"equinox : {_variables_for_parse_time_docstring()['parse_time_types']}\\n\"\n \" The date for the mean vernal equinox.\\n\"\n \" Defaults to the J2000.0 equinox.\")\n\n return ret\n\n\nclass SunPyBaseCoordinateFrame(BaseCoordinateFrame):\n \"\"\"\n Base class for sunpy coordinate frames.\n\n This class is not intended to be used directly and has no transformations defined.\n\n * Defines the frame attribute ``obstime`` for observation time.\n * Defines a default wrap angle of 180 degrees for longitude in spherical coordinates,\n which can be overridden via the class variable ``_wrap_angle``.\n * Inject a nice way of representing the object which the coordinate represents.\n \"\"\"\n obstime = TimeFrameAttributeSunPy()\n\n default_representation = SphericalRepresentation\n default_differential = SphericalDifferential\n\n frame_specific_representation_info = {\n SphericalDifferential: [RepresentationMapping('d_lon', 'd_lon', u.arcsec/u.s),\n RepresentationMapping('d_lat', 'd_lat', u.arcsec/u.s),\n RepresentationMapping('d_distance', 'd_distance', u.km/u.s)],\n }\n\n _wrap_angle = 180*u.deg # for longitude in spherical coordinates\n\n def __init__(self, *args, **kwargs):\n self.object_name = None\n\n # If wrap_longitude=False is passed in, do not impose a specific wrap angle for the frame\n if not kwargs.pop('wrap_longitude', True):\n self._wrap_angle = None\n\n super().__init__(*args, **kwargs)\n\n # If obstime is specified, treat the default observer (None) as explicitly set\n if self.obstime is not None and self.is_frame_attr_default('observer'):\n self._attr_names_with_defaults.remove('observer')\n\n return\n\n def represent_as(self, base, s='base', in_frame_units=False):\n data = super().represent_as(base, s, in_frame_units=in_frame_units)\n\n # If a frame wrap angle is set, use that wrap angle for any spherical representations.\n if self._wrap_angle is not None and \\\n isinstance(data, (UnitSphericalRepresentation, SphericalRepresentation)):\n data.lon.wrap_angle = self._wrap_angle\n return data\n\n def __str__(self):\n # We override this here so that when you print a SkyCoord it shows the\n # observer as the string and not the whole massive coordinate.\n if getattr(self, \"object_name\", None):\n return f\"<{self.__class__.__name__} Coordinate for '{self.object_name}'>\"\n else:\n return super().__str__()\n\n @property\n def _is_2d(self):\n return (self._data is not None and self._data.norm().unit is u.one\n and u.allclose(self._data.norm(), 1*u.one))\n\n def __init_subclass__(cls, **kwargs):\n super().__init_subclass__(**kwargs)\n\n # TODO: Remove this after the minimum Astropy dependency includes astropy/astropy#12005\n cls._fix_property_docstrings()\n\n @classmethod\n def _fix_property_docstrings(cls):\n # This class method adds docstrings to properties dynamically created by\n # BaseCoordinateFrame.__init_subclass__(). Accordingly, this method needs to itself be\n # called from SunPyBaseCoordinateFrame.__init_subclass__() to work for our subclasses.\n property_docstrings = {\n 'default_representation': \"Default representation for position data\",\n 'default_differential': \"Default representation for differential data\",\n 'frame_specific_representation_info': \"Mapping for frame-specific component names\",\n }\n for prop, docstring in property_docstrings.items():\n if getattr(cls, prop).__doc__ is None:\n setattr(getattr(cls, prop), '__doc__', docstring)\n\n\n# TODO: Remove this after the minimum Astropy dependency includes astropy/astropy#12005\nSunPyBaseCoordinateFrame._fix_property_docstrings()\n\n\nclass BaseHeliographic(SunPyBaseCoordinateFrame):\n \"\"\"\n Base class for HeliographicCarrington (HGC) and HeliographicStonyhurst (HGS) frames.\n\n This class is not intended to be used directly and has no transformations defined.\n \"\"\"\n frame_specific_representation_info = {\n SphericalRepresentation: [RepresentationMapping('lon', 'lon', u.deg),\n RepresentationMapping('lat', 'lat', u.deg),\n RepresentationMapping('distance', 'radius', None)],\n SphericalDifferential: [RepresentationMapping('d_lon', 'd_lon', u.arcsec/u.s),\n RepresentationMapping('d_lat', 'd_lat', u.arcsec/u.s),\n RepresentationMapping('d_distance', 'd_radius', u.km/u.s)],\n }\n\n rsun = QuantityAttribute(default=_RSUN, unit=u.km)\n\n def make_3d(self):\n \"\"\"\n Returns a fully 3D coordinate based on this coordinate.\n\n If this coordinate is only 2D (i.e., no ``radius`` component) or is a\n unit vector (i.e., the norm of the coordinate is unity), a new\n coordinate is created that corresponds to the surface of the Sun.\n That is, the 3D coordinate will retain the ``lon`` and ``lat``, and\n ``radius`` will be set to the frame's ``rsun`` frame attribute.\n\n If this coordinate is already fully 3D, it is directly returned, even\n if it does not lie on the surface of the Sun.\n\n Returns\n -------\n frame : `~sunpy.coordinates.frames.BaseHeliographic`\n The fully 3D coordinate\n \"\"\"\n if self._is_2d:\n return self.realize_frame(self._data * self.rsun)\n\n # The coordinate is already 3D\n return self\n\n\n@add_common_docstring(**_frame_parameters())\nclass HeliographicStonyhurst(BaseHeliographic):\n \"\"\"\n A coordinate or frame in the Stonyhurst Heliographic (HGS) system.\n\n - The origin is the center of the Sun.\n - The Z-axis (+90 degrees latitude) is aligned with the Sun's north pole.\n - The X-axis (0 degrees longitude and 0 degrees latitude) is aligned with the projection of\n the Sun-Earth line onto the Sun's equatorial plane.\n\n This system is also know as the Heliocentric Earth Equatorial (HEEQ) system when\n represented using Cartesian components.\n\n A new instance can be created using the following signatures\n (note that if supplied, ``obstime`` and ``representation_type`` must be\n keyword arguments)::\n\n HeliographicStonyhurst(lon, lat, obstime=obstime)\n HeliographicStonyhurst(lon, lat, radius, obstime=obstime)\n HeliographicStonyhurst(x, y, z, representation_type='cartesian', obstime=obstime)\n\n Parameters\n ----------\n {data}\n {lonlat}\n {radius}\n {rsun}\n {common}\n\n Examples\n --------\n >>> from astropy.coordinates import SkyCoord\n >>> import sunpy.coordinates\n >>> import astropy.units as u\n >>> sc = SkyCoord(1*u.deg, 1*u.deg, 2*u.km,\n ... frame=\"heliographic_stonyhurst\",\n ... obstime=\"2010/01/01T00:00:45\")\n >>> sc\n \n >>> sc.frame\n \n >>> sc = SkyCoord(HeliographicStonyhurst(-10*u.deg, 2*u.deg))\n >>> sc\n \n >>> sc = SkyCoord(CartesianRepresentation(0*u.km, 45*u.km, 2*u.km),\n ... obstime=\"2011/01/05T00:00:50\",\n ... frame=\"heliographic_stonyhurst\")\n >>> sc\n \n \"\"\"\n name = \"heliographic_stonyhurst\"\n\n def _apply_diffrot(self, duration, rotation_model):\n oldrepr = self.spherical\n\n from sunpy.physics.differential_rotation import diff_rot\n log.debug(f\"Applying {duration} of solar rotation\")\n newlon = oldrepr.lon + diff_rot(duration,\n oldrepr.lat,\n rot_type=rotation_model,\n frame_time='sidereal')\n newrepr = SphericalRepresentation(newlon, oldrepr.lat, oldrepr.distance)\n\n return self.realize_frame(newrepr)\n\n\n@add_common_docstring(**_frame_parameters())\nclass HeliographicCarrington(BaseHeliographic):\n \"\"\"\n A coordinate or frame in the Carrington Heliographic (HGC) system.\n\n - The origin is the center of the Sun.\n - The Z-axis (+90 degrees latitude) is aligned with the Sun's north pole.\n - The X-axis and Y-axis rotate with a period of 25.38 days.\n\n This system differs from Stonyhurst Heliographic (HGS) in its definition of longitude. This\n longitude is an \"apparent\" longitude because it takes into account the time it takes for light\n to travel from the Sun's surface to the observer (see :ref:`sunpy-coordinates-carrington`).\n Thus, the observer needs to be specified to be able to transform to any other coordinate frame.\n\n A new instance can be created using the following signatures\n (note that if supplied, ``obstime`` and ``observer`` must be a keyword argument)::\n\n HeliographicCarrington(lon, lat, obstime=obstime, observer=observer)\n HeliographicCarrington(lon, lat, radius, obstime=obstime, observer=observer)\n\n If you want to define the location in HGC such that the observer for the coordinate frame is\n the same as that location (e.g., the location of an observatory in its corresponding HGC\n frame), use ``observer='self'``::\n\n HeliographicCarrington(lon, lat, radius, obstime=obstime, observer='self')\n\n Parameters\n ----------\n {data}\n {lonlat}\n {radius}\n {observer}\n {rsun}\n {common}\n\n Examples\n --------\n >>> from astropy.coordinates import SkyCoord\n >>> import sunpy.coordinates\n >>> import astropy.units as u\n >>> sc = SkyCoord(1*u.deg, 2*u.deg, 3*u.km,\n ... frame=\"heliographic_carrington\",\n ... observer=\"earth\",\n ... obstime=\"2010/01/01T00:00:30\")\n >>> sc\n ): (lon, lat, radius) in (deg, deg, km)\n (1., 2., 3.)>\n\n >>> sc = SkyCoord([1,2,3]*u.deg, [4,5,6]*u.deg, [5,6,7]*u.km,\n ... obstime=\"2010/01/01T00:00:45\",\n ... observer=\"self\",\n ... frame=\"heliographic_carrington\")\n >>> sc\n \n\n >>> sc = SkyCoord(CartesianRepresentation(0*u.km, 45*u.km, 2*u.km),\n ... obstime=\"2011/01/05T00:00:50\",\n ... frame=\"heliographic_carrington\")\n >>> sc\n \n \"\"\"\n name = \"heliographic_carrington\"\n _wrap_angle = 360*u.deg\n\n observer = ObserverCoordinateAttribute(HeliographicStonyhurst)\n\n def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n if not isinstance(self.observer, BaseCoordinateFrame) and self.observer == 'self' and self._is_2d:\n raise ValueError(\"Full 3D coordinate (including radius) must be specified \"\n \"when observer='self'.\")\n\n\n@add_common_docstring(**_frame_parameters())\nclass Heliocentric(SunPyBaseCoordinateFrame):\n \"\"\"\n A coordinate or frame in the Heliocentric system, which is observer-based.\n\n - The origin is the center of the Sun.\n - The Z-axis is aligned with the Sun-observer line.\n - The Y-axis is aligned with the component of the vector to the Sun's north pole that is\n perpendicular to the Z-axis.\n\n This frame defaults to a Cartesian component representation, which is known as Heliocentric\n Cartesian (HCC). This frame can also be represented using cylindrical components, where\n where ``rho`` is the impact parameter and ``psi`` is the position angle.\n ``psi`` is measured relative to the west limb, rather than solar north, so is shifted\n by 90 degrees compared to the convention of the Heliocentric Radial (HCR) system.\n\n A new instance can be created using the following signatures\n (note that if supplied, ``obstime``, ``observer``, and ``representation_type`` must be\n keyword arguments)::\n\n Heliocentric(x, y, z, obstime=obstime, observer=observer)\n Heliocentric(rho, psi, z, representation_type='cylindrical', obstime=obstime, observer=observer)\n\n Parameters\n ----------\n {data}\n {xyz}\n {observer}\n {common}\n\n Examples\n --------\n\n >>> from astropy.coordinates import SkyCoord, CartesianRepresentation\n >>> import sunpy.coordinates\n >>> import astropy.units as u\n\n >>> sc = SkyCoord(CartesianRepresentation(10*u.km, 1*u.km, 2*u.km),\n ... obstime=\"2011/01/05T00:00:50\", observer=\"earth\", frame=\"heliocentric\")\n >>> sc\n ): (x, y, z) in km\n (10., 1., 2.)>\n\n >>> sc = SkyCoord([1,2]*u.km, [3,4]*u.m, [5,6]*u.cm,\n ... obstime=\"2011/01/01T00:00:54\", observer=\"earth\", frame=\"heliocentric\")\n >>> sc\n ): (x, y, z) in (km, m, cm)\n [(1., 3., 5.), (2., 4., 6.)]>\n\n >>> sc = SkyCoord(CylindricalRepresentation(10*u.km, 60*u.deg, 10*u.km),\n ... obstime=\"2011/01/05T00:00:50\", observer=\"earth\", frame=\"heliocentric\")\n >>> sc\n ): (x, y, z) in km\n (5., 8.66025404, 10.)>\n \"\"\"\n default_representation = CartesianRepresentation\n default_differential = CartesianDifferential\n\n frame_specific_representation_info = {\n CylindricalRepresentation: [RepresentationMapping('phi', 'psi', u.deg)]\n }\n\n observer = ObserverCoordinateAttribute(HeliographicStonyhurst)\n\n def represent_as(self, base, s='base', in_frame_units=False):\n data = super().represent_as(base, s, in_frame_units=in_frame_units)\n\n # For cylindrical representations, wrap the `psi` component (natively `phi`) at 360 deg\n if isinstance(data, CylindricalRepresentation):\n data.phi.wrap_at(360*u.deg, inplace=True)\n return data\n\n\n@add_common_docstring(**_frame_parameters())\nclass Helioprojective(SunPyBaseCoordinateFrame):\n \"\"\"\n A coordinate or frame in the Helioprojective Cartesian (HPC) system, which is observer-based.\n\n - The origin is the location of the observer.\n - ``Tx`` (aka \"theta_x\") is the angle relative to the plane containing the Sun-observer line\n and the Sun's rotation axis, with positive values in the direction of the Sun's west limb.\n - ``Ty`` (aka \"theta_y\") is the angle relative to the Sun's equatorial plane, with positive\n values in the direction of the Sun's north pole.\n - ``distance`` is the Sun-observer distance.\n\n This system is frequently used in a projective form without ``distance`` specified. For\n observations looking very close to the center of the Sun, where the small-angle approximation\n is appropriate, ``Tx`` and ``Ty`` can be approximated as Cartesian components.\n\n A new instance can be created using the following signatures\n (note that if supplied, ``obstime`` and ``observer`` must be keyword arguments)::\n\n Helioprojective(Tx, Ty, obstime=obstime, observer=observer)\n Helioprojective(Tx, Ty, distance, obstime=obstime, observer=observer)\n\n Parameters\n ----------\n {data}\n Tx : `~astropy.coordinates.Angle` or `~astropy.units.Quantity`\n The theta_x coordinate for this object. Not needed if ``data`` is given.\n Ty : `~astropy.coordinates.Angle` or `~astropy.units.Quantity`\n The theta_y coordinate for this object. Not needed if ``data`` is given.\n distance : `~astropy.units.Quantity`\n The distance coordinate from the observer for this object.\n Not needed if ``data`` is given.\n {observer}\n {rsun}\n {common}\n\n Examples\n --------\n >>> from astropy.coordinates import SkyCoord\n >>> import sunpy.coordinates\n >>> import astropy.units as u\n >>> sc = SkyCoord(0*u.deg, 0*u.deg, 5*u.km,\n ... obstime=\"2010/01/01T00:00:00\", observer=\"earth\", frame=\"helioprojective\")\n >>> sc\n ): (Tx, Ty, distance) in (arcsec, arcsec, km)\n (0., 0., 5.)>\n >>> sc = SkyCoord(0*u.deg, 0*u.deg,\n ... obstime=\"2010/01/01T00:00:00\", observer=\"earth\", frame=\"helioprojective\")\n >>> sc\n ): (Tx, Ty) in arcsec\n (0., 0.)>\n >>> sc = SkyCoord(CartesianRepresentation(1*u.AU, 1e5*u.km, -2e5*u.km),\n ... obstime=\"2011/01/05T00:00:50\", observer=\"earth\", frame=\"helioprojective\")\n >>> sc\n ): (Tx, Ty, distance) in (arcsec, arcsec, AU)\n (137.87948623, -275.75878762, 1.00000112)>\n \"\"\"\n frame_specific_representation_info = {\n SphericalRepresentation: [RepresentationMapping('lon', 'Tx', u.arcsec),\n RepresentationMapping('lat', 'Ty', u.arcsec),\n RepresentationMapping('distance', 'distance', None)],\n SphericalDifferential: [RepresentationMapping('d_lon', 'd_Tx', u.arcsec/u.s),\n RepresentationMapping('d_lat', 'd_Ty', u.arcsec/u.s),\n RepresentationMapping('d_distance', 'd_distance', u.km/u.s)],\n UnitSphericalRepresentation: [RepresentationMapping('lon', 'Tx', u.arcsec),\n RepresentationMapping('lat', 'Ty', u.arcsec)],\n }\n\n rsun = QuantityAttribute(default=_RSUN, unit=u.km)\n observer = ObserverCoordinateAttribute(HeliographicStonyhurst)\n\n @property\n def angular_radius(self):\n \"\"\"\n Angular radius of the Sun as seen by the observer.\n\n The ``rsun`` frame attribute is the radius of the Sun in length units.\n The tangent vector from the observer to the edge of the Sun forms a\n right-angle triangle with the radius of the Sun as the far side and the\n Sun-observer distance as the hypotenuse. Thus, the sine of the angular\n radius of the Sun is ratio of these two distances.\n \"\"\"\n from sunpy.coordinates.sun import _angular_radius # avoiding a circular import\n\n if not isinstance(self.observer, HeliographicStonyhurst):\n if self.observer is None:\n raise ValueError(\"The observer must be defined, not `None`.\")\n raise ValueError(\"The observer must be fully defined by specifying `obstime`.\")\n return _angular_radius(self.rsun, self.observer.radius)\n\n def make_3d(self):\n \"\"\"\n This method calculates the third coordinate of the Helioprojective\n frame. It assumes that the coordinate point is on the surface of the Sun.\n\n If a point in the frame is off limb then NaN will be returned.\n\n Returns\n -------\n new_frame : `~sunpy.coordinates.frames.Helioprojective`\n A new frame instance with all the attributes of the original but\n now with a third coordinate.\n \"\"\"\n # Skip if we already are 3D\n if not self._is_2d:\n return self\n\n if not isinstance(self.observer, BaseCoordinateFrame):\n raise ConvertError(\"Cannot calculate distance to the Sun \"\n f\"for observer '{self.observer}' \"\n \"without `obstime` being specified.\")\n\n rep = self.represent_as(UnitSphericalRepresentation)\n lat, lon = rep.lat, rep.lon\n\n # Check for the use of floats with lower precision than the native Python float\n if not set([lon.dtype.type, lat.dtype.type]).issubset([float, np.float64, np.longdouble]):\n warn_user(\"The Helioprojective component values appear to be lower \"\n \"precision than the native Python float: \"\n f\"Tx is {lon.dtype.name}, and Ty is {lat.dtype.name}. \"\n \"To minimize precision loss, you may want to cast the values to \"\n \"`float` or `numpy.float64` via the NumPy method `.astype()`.\")\n\n # Calculate the distance to the surface of the Sun using the law of cosines\n cos_alpha = np.cos(lat) * np.cos(lon)\n c = self.observer.radius**2 - self.rsun**2\n b = -2 * self.observer.radius * cos_alpha\n # Ignore sqrt of NaNs\n with np.errstate(invalid='ignore'):\n d = ((-1*b) - np.sqrt(b**2 - 4*c)) / 2 # use the \"near\" solution\n\n if self._spherical_screen:\n sphere_center = self._spherical_screen['center'].transform_to(self).cartesian\n c = sphere_center.norm()**2 - self._spherical_screen['radius']**2\n b = -2 * sphere_center.dot(rep)\n # Ignore sqrt of NaNs\n with np.errstate(invalid='ignore'):\n dd = ((-1*b) + np.sqrt(b**2 - 4*c)) / 2 # use the \"far\" solution\n\n d = np.fmin(d, dd) if self._spherical_screen['only_off_disk'] else dd\n\n return self.realize_frame(SphericalRepresentation(lon=lon,\n lat=lat,\n distance=d))\n\n _spherical_screen = None\n\n @classmethod\n @contextmanager\n def assume_spherical_screen(cls, center, only_off_disk=False):\n \"\"\"\n Context manager to interpret 2D coordinates as being on the inside of a spherical screen.\n\n The radius of the screen is the distance between the specified ``center`` and Sun center.\n This ``center`` does not have to be the same as the observer location for the coordinate\n frame. If they are the same, then this context manager is equivalent to assuming that the\n helioprojective \"zeta\" component is zero.\n\n This replaces the default assumption where 2D coordinates are mapped onto the surface of the\n Sun.\n\n Parameters\n ----------\n center : `~astropy.coordinates.SkyCoord`\n The center of the spherical screen\n only_off_disk : `bool`, optional\n If `True`, apply this assumption only to off-disk coordinates, with on-disk coordinates\n still mapped onto the surface of the Sun. Defaults to `False`.\n\n Examples\n --------\n .. minigallery:: sunpy.coordinates.Helioprojective.assume_spherical_screen\n\n >>> import astropy.units as u\n >>> from sunpy.coordinates import Helioprojective\n >>> h = Helioprojective(range(7)*u.arcsec*319, [0]*7*u.arcsec,\n ... observer='earth', obstime='2020-04-08')\n >>> print(h.make_3d())\n ): (Tx, Ty, distance) in (arcsec, arcsec, AU)\n [( 0., 0., 0.99660825), ( 319., 0., 0.99687244),\n ( 638., 0., 0.99778472), ( 957., 0., 1.00103285),\n (1276., 0., nan), (1595., 0., nan),\n (1914., 0., nan)]>\n\n >>> with Helioprojective.assume_spherical_screen(h.observer):\n ... print(h.make_3d())\n ): (Tx, Ty, distance) in (arcsec, arcsec, AU)\n [( 0., 0., 1.00125872), ( 319., 0., 1.00125872),\n ( 638., 0., 1.00125872), ( 957., 0., 1.00125872),\n (1276., 0., 1.00125872), (1595., 0., 1.00125872),\n (1914., 0., 1.00125872)]>\n\n >>> with Helioprojective.assume_spherical_screen(h.observer, only_off_disk=True):\n ... print(h.make_3d())\n ): (Tx, Ty, distance) in (arcsec, arcsec, AU)\n [( 0., 0., 0.99660825), ( 319., 0., 0.99687244),\n ( 638., 0., 0.99778472), ( 957., 0., 1.00103285),\n (1276., 0., 1.00125872), (1595., 0., 1.00125872),\n (1914., 0., 1.00125872)]>\n \"\"\"\n try:\n old_spherical_screen = cls._spherical_screen # nominally None\n\n center_hgs = center.transform_to(HeliographicStonyhurst(obstime=center.obstime))\n cls._spherical_screen = {\n 'center': center,\n 'radius': center_hgs.radius,\n 'only_off_disk': only_off_disk\n }\n yield\n finally:\n cls._spherical_screen = old_spherical_screen\n\n\n@add_common_docstring(**_frame_parameters())\nclass HeliocentricEarthEcliptic(SunPyBaseCoordinateFrame):\n \"\"\"\n A coordinate or frame in the Heliocentric Earth Ecliptic (HEE) system.\n\n - The origin is the center of the Sun.\n - The X-axis (0 degrees longitude and 0 degrees latitude) is aligned with the Sun-Earth line.\n - The Z-axis (+90 degrees latitude) is aligned with the component perpendicular to the X-axis\n of the mean ecliptic pole at the observation time.\n\n Parameters\n ----------\n {data}\n {lonlat}\n {distance_sun}\n {common}\n \"\"\"\n\n\n@add_common_docstring(**_frame_parameters())\nclass GeocentricSolarEcliptic(SunPyBaseCoordinateFrame):\n \"\"\"\n A coordinate or frame in the Geocentric Solar Ecliptic (GSE) system.\n\n - The origin is the center of the Earth.\n - The X-axis (0 degrees longitude and 0 degrees latitude) is aligned with the Earth-Sun line.\n - The Z-axis (+90 degrees latitude) is aligned with the component perpendicular to the X-axis\n of the mean ecliptic pole at the observation time.\n\n Parameters\n ----------\n {data}\n {lonlat}\n {distance_earth}\n {common}\n\n Notes\n -----\n Aberration due to Earth motion is not included.\n \"\"\"\n\n\n@add_common_docstring(**_frame_parameters())\nclass HeliocentricInertial(SunPyBaseCoordinateFrame):\n \"\"\"\n A coordinate or frame in the Heliocentric Inertial (HCI) system.\n\n - The origin is the center of the Sun.\n - The Z-axis (+90 degrees latitude) is aligned with the Sun's north pole.\n - The X-axis (0 degrees longitude and 0 degrees latitude) is aligned with the solar ascending\n node on the ecliptic (mean J2000.0).\n\n Parameters\n ----------\n {data}\n {lonlat}\n {distance_sun}\n {common}\n\n Notes\n -----\n The solar ascending node on the ecliptic lies on the intersection of the solar equatorial\n plane with the ecliptic plane, not on the intersection of the celestial equatorial plane with\n the ecliptic plane.\n \"\"\"\n\n\n@add_common_docstring(**_frame_parameters())\nclass GeocentricEarthEquatorial(SunPyBaseCoordinateFrame):\n \"\"\"\n A coordinate or frame in the Geocentric Earth Equatorial (GEI) system.\n\n - The origin is the center of the Earth.\n - The Z-axis (+90 degrees latitude) is aligned with the Earth's north pole.\n - The X-axis (0 degrees longitude and 0 degrees latitude) is aligned with the mean (not true)\n vernal equinox.\n\n Parameters\n ----------\n {data}\n {lonlat}\n {distance_earth}\n {equinox}\n {common}\n\n Notes\n -----\n Aberration due to Earth motion is not included.\n \"\"\"\n equinox = TimeFrameAttributeSunPy(default=_J2000)\n", "meta": {"hexsha": "54da0ae96fcdc260383b8948a94e81d91048ebba", "size": 34323, "ext": "py", "lang": "Python", "max_stars_repo_path": "sunpy/coordinates/frames.py", "max_stars_repo_name": "Octaves0911/sunpy", "max_stars_repo_head_hexsha": "d3dff03fe6cc404e40f22da90200ffbb3d38c1a7", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "sunpy/coordinates/frames.py", "max_issues_repo_name": "Octaves0911/sunpy", "max_issues_repo_head_hexsha": "d3dff03fe6cc404e40f22da90200ffbb3d38c1a7", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "sunpy/coordinates/frames.py", "max_forks_repo_name": "Octaves0911/sunpy", "max_forks_repo_head_hexsha": "d3dff03fe6cc404e40f22da90200ffbb3d38c1a7", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 45.5816733068, "max_line_length": 189, "alphanum_fraction": 0.629694374, "include": true, "reason": "import numpy,import astropy,from astropy", "num_tokens": 8538, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5621765008857981, "lm_q2_score": 0.34510527769342453, "lm_q1q2_score": 0.19401007745091106}} {"text": "\"\"\"Given (x,wave,matrices, slit_profile), extract the flux from each order. For \nreadability, we keep this separate from the simulator.... but the simulator is\nrequired in order to run this.\n\nTo run, create a simulated fits file (e.g. \"test_blue.fits\") using ghost module then:\n\nblue_high = pymfe.Extractor(pymfe.ghost.Arm('blue', 'high'))\n\nflux,var = blue_high.two_d_extract(\"test_blue.fits\")\n\nplt.plot(blue_high.w_map[0,:], flux[0,:,0])\n\n\"\"\"\n\nfrom __future__ import division, print_function\nimport numpy as np\nimport matplotlib.pyplot as plt\ntry: \n import pyfits\nexcept:\n import astropy.io.fits as pyfits\nimport pdb\nfrom astropy.modeling import models, fitting\nimport matplotlib.cm as cm\n\nclass Extractor():\n \"\"\"A class for each arm of the spectrograph. The initialisation function takes a \n single string representing the configuration. For GHOST, it can be \"red\" or \"blue\".\n \n The extraction is defined by 3 key parameters: an \"x_map\", which is equivalent to\n 2dFDR's tramlines and contains a physical x-coordinate for every y (dispersion direction)\n coordinate and order, and a \"w_map\", which is the wavelength corresponding to every y\n (dispersion direction) coordinate and order. \n \n sim must include:\n \n spectral_format_with_matrix()\n make_lenslets(fluxes)\n \n fluxes (nlenslets x nobj) array\n nl (nlenslets)\n szx (size in x [non-dispersion] direction)\n mode (string,for error messages)\n lenslet_width, im_slit_sz, microns_pix (together define the make_lenslets output)\n \"\"\"\n \n def __init__(self,sim,transpose_data=True,badpixmask=[]):\n self.sim = sim\n self.transpose_data=transpose_data\n self.badpixmask = badpixmask\n self.x_map,self.w_map,self.blaze,self.matrices = self.sim.spectral_format_with_matrix()\n #Fill in the slit dimensions in \"simulator pixel\"s. based on if we are in the \n #high or standard resolution mode.\n self.define_profile(sim.fluxes)\n \n #Set some default pixel offsets for each lenslet, as used for a square lenslet profile\n ny = self.x_map.shape[1]\n nm = self.x_map.shape[0]\n pix_offset_ix = np.append(np.append([0],np.arange(1,sim.nl).repeat(2)),sim.nl)\n self.square_offsets = np.empty( (2*sim.nl,nm) )\n # The [0,0] component of \"matrices\" measures the size of a detector pixel in the \n # simulated slit image space. i.e. slitmicrons/detpix.\n for i in range(sim.nl):\n self.square_offsets[:,i] = (pix_offset_ix - sim.nl/2.0) * sim.lenslet_width / self.matrices[i,self.x_map.shape[1]//2,0,0]\n self.sim_offsets = np.empty( (self.sim.im_slit_sz,nm) )\n #Creat an array of slit positions in microns. !!! Add an optional offset to this, i.e. a 1D offset !!!\n im_slit_pix_in_microns = (np.arange(self.sim.im_slit_sz) - self.sim.im_slit_sz/2.0) * self.sim.microns_pix\n for i in range(nm):\n self.sim_offsets[:,i] = im_slit_pix_in_microns / self.matrices[i,self.x_map.shape[1]//2,0,0]\n #To aid in 2D extraction, let's explicitly compute the y offsets corresponding to these x offsets...\n #The \"matrices\" map pixels back to slit co-ordinates. \n self.slit_tilt = np.zeros( (nm,ny) )\n for i in range(nm):\n for j in range(ny):\n invmat = np.linalg.inv( self.matrices[i,j] )\n #What happens to the +x direction?\n x_dir_map = np.dot(invmat,[1,0])\n self.slit_tilt[i,j] = x_dir_map[1]/x_dir_map[0]\n \n def define_profile(self,fluxes):\n \"\"\" Manually define the slit profile as used in lenslet extraction. As this is\n a low-level function, all lenslets must be defined. e.g. by convention, for the\n star lenslets of the high resolution mode, lenslets 0,1 and 21 through 27 would \n be zero. Also \"\"\"\n \n if fluxes.shape[0] != self.sim.nl:\n print(\"Error: {0:s} resolution mode must have {1:d} lenslets\".format(self.sim.mode,self.sim.nl))\n else:\n self.square_profile = np.empty( (fluxes.shape[0]*2, fluxes.shape[1]) )\n self.sim_profile = np.empty( (self.sim.im_slit_sz, fluxes.shape[1]) )\n for i in range(fluxes.shape[1]):\n self.square_profile[:,i] = np.array(fluxes[:,i]).repeat(2)\n im_slit=self.sim.make_lenslets(fluxes=fluxes[:,i])\n self.sim_profile[:,i] = np.sum(im_slit, axis=0)\n \n def one_d_extract(self, data=[], file='', lenslet_profile='sim', rnoise=3.0):\n \"\"\" Extract flux by integrating down columns (the \"y\" direction), using an\n optimal extraction method.\n \n Given that some of this code is in common with two_d_extract, the routines could\n easily be merged... however that would make one_d_extract less readable.\n \n Parameters\n ----------\n data: numpy array (optional) \n Image data, transposed so that dispersion is in the \"y\" direction. Note that\n this is the transpose of a conventional echellogram. Either data or file\n must be given\n \n file: string (optional)\n A fits file with conventional row/column directions containing the data to be\n extracted.\n \n lenslet_profile: 'square' or 'sim'\n Shape of the profile of each fiber as used in the extraction. For a final\n implementation, 'measured' should be a possibility. 'square' assigns each\n pixel uniquely to a single lenslet. For testing only\n \n badpix: (float array, float array)\n Output of e.g. np.where giving the bad pixel coordinates.\n \n rnoise: float\n The assumed readout noise.\n \n WARNING: Binning not implemented yet\"\"\"\n \n if len(data)==0:\n if len(file)==0:\n print(\"ERROR: Must input data or file\")\n else:\n if self.transpose_data:\n #Transpose the data from the start.\n data = pyfits.getdata(file).T\n else:\n data = pyfits.getdata(file)\n \n ny = self.x_map.shape[1]\n nm = self.x_map.shape[0]\n nx = self.sim.szx\n \n #Number of \"objects\"\n no = self.square_profile.shape[1]\n extracted_flux = np.zeros( (nm,ny,no) )\n extracted_var = np.zeros( (nm,ny,no) )\n \n #Assuming that the data are in photo-electrons, construct a simple model for the\n #pixel inverse variance.\n pixel_inv_var = 1.0/(np.maximum(data,0)/self.sim.gain + rnoise**2)\n pixel_inv_var[self.badpixmask]=0.0\n \n #Loop through all orders then through all y pixels.\n for i in range(nm):\n print(\"Extracting order: {0:d}\".format(i))\n #Based on the profile we're using, create the local offsets and profile vectors\n if lenslet_profile == 'square':\n offsets = self.square_offsets[:,i]\n profile = self.square_profile\n elif lenslet_profile == 'sim':\n offsets = self.sim_offsets[:,i]\n profile = self.sim_profile\n nx_cutout = 2*int( (np.max(offsets) - np.min(offsets))/2 ) + 2\n phi = np.empty( (nx_cutout,no) )\n for j in range(ny):\n #Check for NaNs\n if self.x_map[i,j] != self.x_map[i,j]:\n extracted_var[i,j,:] = np.nan\n continue\n #Create our column cutout for the data and the PSF. !!! Is \"round\" correct on the next line??? \n x_ix = int(np.round(self.x_map[i,j])) - nx_cutout//2 + np.arange(nx_cutout,dtype=int) + nx//2\n for k in range(no):\n phi[:,k] = np.interp(x_ix - self.x_map[i,j] - nx//2, offsets, profile[:,k])\n phi[:,k] /= np.sum(phi[:,k])\n #Deal with edge effects...\n ww = np.where( (x_ix >= nx) | (x_ix < 0) )[0]\n x_ix[ww]=0\n phi[ww,:]=0.0\n \n #Stop here. \n# if i==10:\n# pdb.set_trace()\n \n #Cut out our data and inverse variance.\n col_data = data[j,x_ix]\n col_inv_var = pixel_inv_var[j,x_ix]\n #Fill in the \"c\" matrix and \"b\" vector from Sharp and Birchall equation 9\n #Simplify things by writing the sum in the computation of \"b\" as a matrix\n #multiplication. We can do this because we're content to invert the \n #(small) matrix \"c\" here. Equation 17 from Sharp and Birchall \n #doesn't make a lot of sense... so lets just calculate the variance in the\n #simple explicit way.\n col_inv_var_mat = np.reshape(col_inv_var.repeat(no), (nx_cutout,no) )\n b_mat = phi * col_inv_var_mat\n c_mat = np.dot(phi.T,phi*col_inv_var_mat)\n pixel_weights = np.dot(b_mat,np.linalg.inv(c_mat))\n extracted_flux[i,j,:] = np.dot(col_data,pixel_weights)\n extracted_var[i,j,:] = np.dot(1.0/np.maximum(col_inv_var,1e-12),pixel_weights**2)\n #if ((i % 5)==1) & (j==ny//2):\n #if (i%5==1) & (j==ny//2):\n #if (j==ny//2):\n # pdb.set_trace()\n \n return extracted_flux, extracted_var\n \n def two_d_extract(self, file='', data=[], lenslet_profile='sim', rnoise=3.0, deconvolve=True):\n \"\"\" Extract using 2D information. The lenslet model used is a collapsed profile, \n in 1D but where we take into account the slit shear/rotation by interpolating this\n 1D slit profile to the nearest two pixels along each row (y-axis in code).\n \n One key difference to Sharp and Birchall is that c_kj (between equations 8 and 9)\n is the correct normalisation for a (fictitious) 1-pixel wide PSF centered exactly\n on a pixel, but not for a continuum. We normalise correctly for a continuum by\n having one of the \\phi functions being one-pixel wide along the slit, and the \n other being unbounded in the dispersion direction.\n \n Note that the input data has to be the transpose of a conventional echellogram\n \n TODO:\n 1) Neaten the approximate matrix inverse square root\n \n Parameters\n ----------\n data: numpy array (optional) \n Image data, transposed so that dispersion is in the \"y\" direction. Note that\n this is the transpose of a conventional echellogram. Either data or file\n must be given\n \n file: string (optional)\n A fits file with conventional row/column directions containing the data to be\n extracted.\n \n lenslet_profile: 'square' or 'sim'\n Shape of the profile of each fiber as used in the extraction. For a final\n implementation, 'measured' should be a possibility. 'square' assigns each\n pixel uniquely to a single lenslet. For testing only\n \n rnoise: float\n The assumed readout noise.\n \n deconvolve: bool\n Do we deconvolve so that neighboring extracted spectral points \n are statistically independent? This is an approximate deconvolution (a linear \n function of 5 neighboring pixels) so is reasonably robust. \"\"\"\n \n if len(data)==0:\n if len(file)==0:\n print(\"ERROR: Must input data or file\")\n else:\n #Transpose the data from the start.\n data = pyfits.getdata(file).T\n\n ny = self.x_map.shape[1]\n nm = self.x_map.shape[0]\n nx = self.sim.szx\n \n #Number of \"objects\"\n no = self.square_profile.shape[1]\n extracted_flux = np.zeros( (nm,ny,no) )\n extracted_var = np.zeros( (nm,ny,no) )\n extracted_covar = np.zeros( (nm,ny-1,no) )\n \n #Assuming that the data are in photo-electrons, construct a simple model for the\n #pixel inverse variance.\n pixel_inv_var = 1.0/(np.maximum(data,0) + rnoise**2)\n pixel_inv_var[self.badpixmask]=0.0\n \n #Loop through all orders then through all y pixels.\n for i in range(nm):\n print(\"Extracting order index: {0:d}\".format(i))\n #Based on the profile we're using, create the local offsets and profile vectors\n if lenslet_profile == 'sim':\n offsets = self.sim_offsets[:,i]\n profile = self.sim_profile\n else:\n print(\"Only sim lenslet profile available for 2D extraction so far...\")\n raise userwarning\n nx_cutout = 2*int( (np.max(offsets) - np.min(offsets))/2 ) + 2\n ny_cutout = 2*int(nx_cutout * np.nanmax(np.abs(self.slit_tilt)) / 2) + 3\n for j in range(ny):\n phi = np.zeros( (ny_cutout,nx_cutout,no) )\n phi1d = np.zeros( (ny_cutout,nx_cutout,no) )\n #Check for NaNs\n if self.x_map[i,j] != self.x_map[i,j]:\n extracted_var[i,j,:] = np.nan\n continue\n #Create our column cutout for the data and the PSF\n x_ix = int(self.x_map[i,j]) - nx_cutout//2 + np.arange(nx_cutout,dtype=int) + nx//2\n y_ix = j + np.arange(ny_cutout, dtype=int) - ny_cutout//2\n for k in range(no):\n x_prof = np.interp(x_ix - self.x_map[i,j] - nx//2, offsets, profile[:,k])\n y_pix = (x_ix - self.x_map[i,j] - nx//2) * self.slit_tilt[i,j] + ny_cutout//2\n frac_y_pix = y_pix - y_pix.astype(int)\n subx_ix = np.arange(nx_cutout,dtype=int)\n phi[y_pix.astype(int),subx_ix,k] = (1-frac_y_pix)*x_prof\n phi[y_pix.astype(int)+1,subx_ix,k] = frac_y_pix*x_prof\n phi[:,:,k] /= np.sum(phi[:,:,k]) \n x_prof /= np.sum(x_prof) \n phi1d[:,:,k] = np.tile(x_prof,ny_cutout).reshape( (ny_cutout, nx_cutout) )\n #Deal with edge effects...\n ww = np.where( (x_ix >= nx) | (x_ix < 0) )[0]\n x_ix[ww]=0\n phi[:,ww,:]=0.0\n phi1d[:,ww,:]=0.0\n ww = np.where( (y_ix >= ny) | (y_ix < 0) )[0]\n y_ix[ww]=0\n phi[ww,:,:]=0.0\n xy = np.meshgrid(y_ix, x_ix, indexing='ij') \n #Cut out our data and inverse variance.\n col_data = data[xy].flatten()\n col_inv_var = pixel_inv_var[xy].flatten()\n #Fill in the \"c\" matrix and \"b\" vector from Sharp and Birchall equation 9\n #Simplify things by writing the sum in the computation of \"b\" as a matrix\n #multiplication. We can do this because we're content to invert the \n #(small) matrix \"c\" here. Equation 17 from Sharp and Birchall \n #doesn't make a lot of sense... so lets just calculate the variance in the\n #simple explicit way.\n col_inv_var_mat = np.reshape(col_inv_var.repeat(no), (ny_cutout*nx_cutout,no) )\n phi = phi.reshape( (ny_cutout*nx_cutout,no) )\n phi1d = phi1d.reshape( (ny_cutout*nx_cutout,no) )\n b_mat = phi * col_inv_var_mat\n c_mat = np.dot(phi.T,phi1d*col_inv_var_mat)\n pixel_weights = np.dot(b_mat,np.linalg.inv(c_mat))\n# if (j==1000):\n# pdb.set_trace()\n extracted_flux[i,j,:] = np.dot(col_data,pixel_weights)\n extracted_var[i,j,:] = np.dot(1.0/np.maximum(col_inv_var,1e-12),pixel_weights**2)\n if (j > 0):\n extracted_covar[i,j-1,:] = np.dot(1.0/np.maximum(col_inv_var,1e-12),pixel_weights* \\\n np.roll(last_pixel_weights,-nx_cutout, axis=0))\n last_pixel_weights = pixel_weights.copy()\n# if (j > 591):\n# pdb.set_trace()\n if (deconvolve):\n #Create the diagonals of the matrix Q gradually, using the Taylor approximation for\n #the matrix inverse.\n #(Bolton and Schlegel 2009, equation 10)\n #D = diag(C)\n #A = D^{-1/2} (C-D) D^{-1/2}, so C = D^{1/2}(I + A)D^{1/2}\n #Then if Q = (I - 1/2 A + 3/8 A^2) D^{-1/2}\n #... then C^{-1} = QQ, approximately.\n #Note that all of this effort doesn't really seem to achieve much at all in practice...\n #an extremely marginal improvement in resolution... but at least formal pixel-to-pixel\n #data independence is returned.\n extracted_sig = np.sqrt(extracted_var)\n a_diag_p1 = extracted_covar/extracted_sig[:,:-1,:]/extracted_sig[:,1:,:]\n# a_diag_m1 = extracted_covar/extracted_var[:,1:,:]\n Q_diag = np.ones( (nm,ny,no) )\n Q_diag[:,:-1,:] += 3/8.0*a_diag_p1**2\n Q_diag[:,1:,:] += 3/8.0*a_diag_p1**2\n# Q_diag[:,:-1,:] += 3/8.0*a_diag_p1*a_diag_m1\n# Q_diag[:,1:,:] += 3/8.0*a_diag_p1*a_diag_m1\n Q_diag /= extracted_sig\n extracted_sqrtsig = np.sqrt(extracted_sig)\n Q_diag_p2 = 3/8.0*a_diag_p1[:,:-1,:]*a_diag_p1[:,1:,:]/extracted_sqrtsig[:,2:,:]/extracted_sqrtsig[:,:-2,:]\n# Q_diag_m2 = 3/8.0*a_diag_m1[:,:-1,:]*a_diag_m1[:,1:,:]/extracted_sig[:,:-2,:]\n# Q_diag_m1 = -0.5*a_diag_m1/extracted_sig[:,:-1,:]\n Q_diag_p1 = -0.5*a_diag_p1/extracted_sqrtsig[:,1:,:]/extracted_sqrtsig[:,:-1,:]\n #The approximation doesn't seem to be quite right, with the ~3% uncertainty on the diagonal of cinv, when there should\n #only be a ~1% uncertainty (obtained by going to the next term in the Taylor expansion). But pretty close...\n #Q = np.diag(Q_diag[0,:,0]) + np.diag(Q_diag_m1[0,:,0],k=-1) + np.diag(Q_diag_p1[0,:,0],k=+1) + np.diag(Q_diag_p2[0,:,0],k=+2) + np.diag(Q_diag_m2[0,:,0],k=-2)\n #cinv_approx = np.dot(Q,Q)\n #cinv = np.diag(extracted_var[0,:,0]) + np.diag(extracted_covar[0,:,0],k=1) + np.diag(extracted_covar[0,:,0],k=-1)\n #cinv = np.linalg.inv(cinv)\n #Now we have a sparse matrix with 5 terms. We need to sum down the rows, ignoring the \n #edge pixels\n# s_vect = Q_diag[:,2:-2,:] + Q_diag_p1[:,1:-2,:] + Q_diag_m1[:,2:-1,:] + Q_diag_p2[:,:-2,:] + Q_diag_m2[:,2:,:]\n s_vect = Q_diag.copy()\n s_vect[:,:-1,:] += Q_diag_p1\n s_vect[:,:-2,:] += Q_diag_p2\n s_vect[:,1:,:] += Q_diag_p1\n s_vect[:,2:,:] += Q_diag_p2\n new_var = 1.0/s_vect**2\n new_flux = extracted_flux*Q_diag/s_vect\n new_flux[:,:-1,:] += extracted_flux[:,1:,:]*Q_diag_p1/s_vect[:,1:,:]\n new_flux[:,:-2,:] += extracted_flux[:,2:,:]*Q_diag_p2/s_vect[:,2:,:]\n new_flux[:,1:,:] += extracted_flux[:,:-1,:]*Q_diag_p1/s_vect[:,:-1,:]\n new_flux[:,2:,:] += extracted_flux[:,:-2,:]*Q_diag_p2/s_vect[:,:-2,:]\n \n #Fill in the Variance and Flux arrays with NaNs, so that the (not computed) edges \n #are undefined.\n # new_flux = np.empty_like(extracted_flux)\n # new_var = np.empty_like(extracted_var)\n # new_flux[:,:,:]=np.nan\n # new_var[:,:,:]=np.nan\n #Now fill in the arrays.\n # new_var[:,2:-2,:] = 1.0/s_vect**2\n # new_flux[:,2:-2,:] = extracted_flux[:,2:-2,:]*Q_diag[:,2:-2,:]/s_vect \n #\n # new_flux[:,2:-2,:] += extracted_flux[:,1:-3,:]*Q_diag_p1[:,1:-2,:]/s_vect\n # new_flux[:,2:-2,:] += extracted_flux[:,3:-1,:]*Q_diag_p1[:,2:-1,:]/s_vect\n # new_flux[:,2:-2,:] += extracted_flux[:,:-4,:] *Q_diag_p2[:,:-2,:]/s_vect\n # new_flux[:,2:-2,:] += extracted_flux[:,4:,:] *Q_diag_p2[:,2:,:]/s_vect\n \n return new_flux, new_var\n else:\n return extracted_flux, extracted_var\n \n \n def find_lines(self,data,arcfile='lines.txt',outfile='arclines.txt', hw=10,flat_data=[]):\n \"\"\"Find lines near the locations of input arc lines.\n \n Parameters\n ----------\n data: numpy array\n data array\n \n arcfile: string\n file containing lines \"\"\"\n\n #First, extract the data\n flux,var = self.one_d_extract(data=data, rnoise=self.sim.rnoise)\n #Read in the lines\n lines = np.loadtxt(arcfile)\n #Only use the first lenslet.\n flux = flux[:,:,0]\n ny = self.x_map.shape[1]\n nm = self.x_map.shape[0]\n nx = self.sim.szx\n lines_out=[]\n if len(flat_data)>0:\n data_to_show = data - 0.05*flat_data\n else:\n data_to_show = data.copy()\n plt.clf()\n plt.imshow( np.arcsinh( (data_to_show-np.median(data_to_show))/1e2) , interpolation='nearest', aspect='auto', cmap=cm.gray)\n for m_ix in range(nm):\n w_ix = np.interp(lines,self.w_map[m_ix,:],np.arange(ny))\n ww = np.where( (w_ix >= hw) & (w_ix < ny-hw) )[0]\n w_ix = w_ix[ww]\n arclines_to_fit = lines[ww]\n for i,ix in enumerate(w_ix):\n x = np.arange(ix-hw,ix+hw,dtype=np.int)\n y = flux[m_ix,x]\n y -= np.min(y) #Rough...\n if np.max(y)< 25*self.sim.rnoise:\n continue\n g_init = models.Gaussian1D(amplitude=np.max(y), mean=x[np.argmax(y)], stddev=1.5)\n fit_g = fitting.LevMarLSQFitter()\n g = fit_g(g_init, x, y)\n #Wave, ypos, xpos, m, amplitude, fwhm\n xpos = nx//2+np.interp(g.mean.value,np.arange(ny),self.x_map[m_ix])\n ypos = g.mean.value\n plt.plot(xpos,ix,'bx')\n plt.plot(xpos,ypos,'rx') #!!! Maybe around the other way?\n plt.text(xpos+10,ypos,str(arclines_to_fit[i]),color='green',fontsize=10)\n lines_out.append( [arclines_to_fit[i],ypos,xpos,m_ix+self.sim.m_min,g.amplitude.value, g.stddev.value*2.3548] )\n plt.axis([0,nx,ny,0])\n lines_out = np.array(lines_out)\n np.savetxt(outfile,lines_out,fmt='%9.4f %7.2f %7.2f %2d %7.1e %4.1f')\n \n", "meta": {"hexsha": "8a0c2b6728a510bff40cc4bc5eaf968a33cc6975", "size": 22573, "ext": "py", "lang": "Python", "max_stars_repo_path": "pymfe/extract.py", "max_stars_repo_name": "mikeireland/pymfe", "max_stars_repo_head_hexsha": "ce78392215bb40467a0d4efd453c2a6d062c12f5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pymfe/extract.py", "max_issues_repo_name": "mikeireland/pymfe", "max_issues_repo_head_hexsha": "ce78392215bb40467a0d4efd453c2a6d062c12f5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pymfe/extract.py", "max_forks_repo_name": "mikeireland/pymfe", "max_forks_repo_head_hexsha": "ce78392215bb40467a0d4efd453c2a6d062c12f5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 50.1622222222, "max_line_length": 163, "alphanum_fraction": 0.5619988482, "include": true, "reason": "import numpy,import astropy,from astropy", "num_tokens": 5847, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5621765008857981, "lm_q2_score": 0.34510527095787247, "lm_q1q2_score": 0.19401007366434198}} {"text": "#!/usr/bin/env python\n\nimport copy\nfrom importlib import import_module\n\nimport numpy as np\n\nfrom openquake.hazardlib.gsim.base import GMPE\nfrom openquake.hazardlib.imt import PGA, PGV, SA\nfrom openquake.hazardlib import const\n\nfrom shakelib.conversions.imt.newmark_hall_1982 import NewmarkHall1982\nfrom shakelib.conversions.imc.boore_kishida_2017 import BooreKishida2017\nfrom shakelib.sites import Sites\n\n\nclass MultiGMPE(GMPE):\n \"\"\"\n Implements a GMPE that is the combination of multiple GMPEs.\n\n To do\n\n * Allow site to be based on a model that isn't a GMPE (e.g.,\n Borcherdt).\n\n \"\"\"\n\n DEFINED_FOR_TECTONIC_REGION_TYPE = None\n DEFINED_FOR_INTENSITY_MEASURE_TYPES = None\n DEFINED_FOR_INTENSITY_MEASURE_COMPONENT = None\n DEFINED_FOR_STANDARD_DEVIATION_TYPES = None\n REQUIRES_SITES_PARAMETERS = None\n REQUIRES_RUPTURE_PARAMETERS = None\n REQUIRES_DISTANCES = None\n\n def get_mean_and_stddevs(self, sites, rup, dists, imt, stddev_types):\n \"\"\"\n See superclass `method `__.\n \"\"\" # noqa\n\n # Evaluate MultiGMPE:\n lnmu, lnsd = self.__get_mean_and_stddevs(\n sites, rup, dists, imt, stddev_types)\n\n # Check for large-distance cutoff/weights\n if hasattr(self, 'CUTOFF_DISTANCE'):\n lnmu_large, lnsd_large = self.__get_mean_and_stddevs(\n sites, rup, dists, imt, stddev_types, large_dist=True)\n # Stomp on lnmu and lnsd at large distances\n dist_cutoff = self.CUTOFF_DISTANCE\n lnmu[dists.rjb > dist_cutoff] = lnmu_large[dists.rjb > dist_cutoff]\n for i in range(len(lnsd)):\n lnsd[i][dists.rjb > dist_cutoff] = \\\n lnsd_large[i][dists.rjb > dist_cutoff]\n\n return lnmu, lnsd\n\n def __get_mean_and_stddevs(self, sites, rup, dists, imt, stddev_types,\n large_dist=False):\n\n # ---------------------------------------------------------------------\n # Sort out which set of weights to use\n # ---------------------------------------------------------------------\n if large_dist is False:\n wts = self.WEIGHTS\n else:\n wts = self.WEIGHTS_LARGE_DISTANCE\n\n # ---------------------------------------------------------------------\n # Sort out shapes of sites and dists elements\n # ---------------------------------------------------------------------\n\n shapes = []\n for k, v in sites.__dict__.items():\n if (k is not 'lons') and (k is not 'lats'):\n shapes.append(v.shape)\n for k, v in dists.__dict__.items():\n if (k is not 'lons') and (k is not 'lats'):\n shapes.append(v.shape)\n\n shapeset = set(shapes)\n if len(shapeset) != 1:\n raise Exception(\n 'All sites and dists elements must have same shape.')\n else:\n orig_shape = list(shapeset)[0]\n\n # Need to turn all 2D arrays into 1D arrays because of\n # inconsistencies in how arrays are handled in OpenQuake.\n for k, v in dists.__dict__.items():\n if (k is not 'lons') and (k is not 'lats'):\n dists.__dict__[k] = np.reshape(dists.__dict__[k], (-1,))\n for k, v in sites.__dict__.items():\n if (k is not 'lons') and (k is not 'lats'):\n sites.__dict__[k] = np.reshape(sites.__dict__[k], (-1,))\n\n # ---------------------------------------------------------------------\n # These are arrays to hold the weighted combination of the GMPEs\n # ---------------------------------------------------------------------\n lnmu = np.zeros_like(sites.vs30)\n sd_avail = self.DEFINED_FOR_STANDARD_DEVIATION_TYPES\n if not sd_avail.issuperset(set(stddev_types)):\n raise Exception(\"Requested an unavailable stddev_type.\")\n\n lnsd2 = [np.zeros_like(sites.vs30) for a in stddev_types]\n\n for i in range(len(self.GMPES)):\n # -----------------------------------------------------------------\n # Loop over GMPE list\n # -----------------------------------------------------------------\n\n gmpe = self.GMPES[i]\n\n sites = MultiGMPE.set_sites_depth_parameters(sites, gmpe)\n\n # -----------------------------------------------------------------\n # Evaluate GMPEs\n # -----------------------------------------------------------------\n\n gmpe_imts = [imt.__name__ for imt in\n gmpe.DEFINED_FOR_INTENSITY_MEASURE_TYPES]\n if (isinstance(imt, PGV)) and (\"PGV\" not in gmpe_imts):\n # -------------------------------------------------------------\n # If IMT is PGV and PGV is not given by the GMPE, then\n # convert from PSA10.\n # -------------------------------------------------------------\n if self.HAS_SITE[i] is True:\n psa10, psa10sd = gmpe.get_mean_and_stddevs(\n sites, rup, dists, SA(1.0), stddev_types)\n else:\n lamps = self.get_site_factors(\n sites, rup, dists, SA(1.0), default=True)\n psa10, psa10sd = gmpe.get_mean_and_stddevs(\n sites, rup, dists, SA(1.0), stddev_types)\n psa10 = psa10 + lamps\n\n lmean, lsd = NewmarkHall1982.psa102pgv(psa10, psa10sd[0])\n else:\n if self.HAS_SITE[i] is True:\n lmean, lsd = gmpe.get_mean_and_stddevs(\n sites, rup, dists, imt, stddev_types)\n else:\n lamps = self.get_site_factors(\n sites, rup, dists, imt, default=True)\n lmean, lsd = gmpe.get_mean_and_stddevs(\n sites, rup, dists, imt, stddev_types)\n lmean = lmean + lamps\n\n # -----------------------------------------------------------------\n # Convertions due to component definition\n # -----------------------------------------------------------------\n\n imc_in = gmpe.DEFINED_FOR_INTENSITY_MEASURE_COMPONENT\n imc_out = self.DEFINED_FOR_INTENSITY_MEASURE_COMPONENT\n bk17 = BooreKishida2017(imc_in, imc_out)\n lmean = bk17.convertAmps(imt, lmean, dists.rrup, rup.mag)\n #\n # The extra sigma from the component conversion appears to \n # apply to the total sigma, so the question arises as to\n # how to apportion it between the intra- and inter-event\n # sigma. Here we assume it all enters as intra-event sigma.\n # \n for j in range(len(lnsd2)):\n if stddev_types[j] == const.StdDev.INTER_EVENT:\n continue\n lsd[j] = bk17.convertStddevs(imt, lsd[j], dists.rrup, rup.mag)\n\n # -----------------------------------------------------------------\n # Compute weighted mean and sd\n # -----------------------------------------------------------------\n\n lnmu = lnmu + wts[i] * lmean\n\n # Note: the lnsd2 calculation isn't complete until we drop out of\n # this loop and substract lnmu**2\n for j in range(len(lnsd2)):\n lnsd2[j] = lnsd2[j] + wts[i] * (lmean**2 + lsd[j]**2)\n\n for j in range(len(lnsd2)):\n lnsd2[j] = lnsd2[j] - lnmu**2\n\n lnsd = [np.sqrt(a) for a in lnsd2]\n\n # Undo reshapes of inputs\n for k, v in dists.__dict__.items():\n if (k is not 'lons') and (k is not 'lats'):\n dists.__dict__[k] = np.reshape(dists.__dict__[k], orig_shape)\n for k, v in sites.__dict__.items():\n if (k is not 'lons') and (k is not 'lats'):\n sites.__dict__[k] = np.reshape(sites.__dict__[k], orig_shape)\n\n # Reshape output\n lnmu = np.reshape(lnmu, orig_shape)\n for i in range(len(lnsd)):\n lnsd[i] = np.reshape(lnsd[i], orig_shape)\n\n return lnmu, lnsd\n\n @classmethod\n def from_config(cls, conf, filter_imt=None, verbose=False):\n \"\"\"\n Construct a MultiGMPE from a config file.\n\n Args:\n conf (dict): Dictionary of config options.\n filter_imt (IMT): An optional IMT to filter/reweight the GMPE list.\n verbose (bool): Print verbose output for debugging.\n\n Returns:\n MultiGMPE object.\n\n \"\"\"\n IMC = getattr(const.IMC, conf['interp']['component'])\n selected_gmpe = conf['modeling']['gmpe']\n\n if verbose is True:\n print('selected_gmpe: %s' % selected_gmpe)\n print('IMC: %s' % IMC)\n\n # ---------------------------------------------------------------------\n # Allow for selected_gmpe to be found in either conf['gmpe_sets'] or\n # conf['gmpe_modules'], if it is a GMPE set, then all entries must be\n # either a GMPE or a GMPE set (cannot have a GMPE set that is a mix of\n # GMPEs and GMPE sets).\n # ---------------------------------------------------------------------\n\n if selected_gmpe in conf['gmpe_sets'].keys():\n selected_gmpe_sets = conf['gmpe_sets'][selected_gmpe]['gmpes']\n gmpe_set_weights = \\\n [float(w) for w in conf['gmpe_sets'][selected_gmpe]['weights']]\n if verbose is True:\n print('selected_gmpe_sets: %s' % selected_gmpe_sets)\n print('gmpe_set_weights: %s' % gmpe_set_weights)\n\n # -----------------------------------------------------------------\n # If it is a GMPE set, does it contain GMPEs or GMPE sets?\n # -----------------------------------------------------------------\n\n set_of_gmpes = all([s in conf['gmpe_modules'] for s in\n selected_gmpe_sets])\n set_of_sets = all([s in conf['gmpe_sets'] for s in\n selected_gmpe_sets])\n\n if set_of_sets is True:\n mgmpes = []\n for s in selected_gmpe_sets:\n mgmpes.append(cls.__multigmpe_from_gmpe_set(\n conf, s, filter_imt=filter_imt, verbose=verbose))\n out = MultiGMPE.from_list(mgmpes, gmpe_set_weights, imc=IMC)\n elif set_of_gmpes is True:\n out = cls.__multigmpe_from_gmpe_set(\n conf,\n selected_gmpe,\n filter_imt=filter_imt,\n verbose=verbose)\n else:\n raise Exception(\"%s must consist exclusively of keys in \"\n \"conf['gmpe_modules'] or conf['gmpe_sets']\"\n % selected_gmpe)\n elif selected_gmpe in conf['gmpe_modules'].keys():\n modinfo = conf['gmpe_modules'][selected_gmpe]\n mod = import_module(modinfo[1])\n tmpclass = getattr(mod, modinfo[0])\n out = MultiGMPE.from_list([tmpclass()], [1.0], imc=IMC)\n else:\n raise Exception(\"conf['modeling']['gmpe'] must be a key in \"\n \"conf['gmpe_modules'] or conf['gmpe_sets']\")\n\n out.DESCRIPTION = selected_gmpe\n return out\n\n def __multigmpe_from_gmpe_set(conf, set_name, filter_imt=None,\n verbose=False):\n \"\"\"\n Private method for constructing a MultiGMPE from a set_name.\n\n Args:\n conf (ConfigObj): A ShakeMap config object.\n filter_imt (IMT): An optional IMT to filter/reweight the GMPE list.\n set_name (str): Set name; must correspond to a key in\n conf['set_name'].\n\n Returns:\n MultiGMPE.\n\n \"\"\"\n IMC = getattr(const.IMC, conf['interp']['component'])\n\n selected_gmpes = conf['gmpe_sets'][set_name]['gmpes']\n selected_gmpe_weights = \\\n [float(w) for w in conf['gmpe_sets'][set_name]['weights']]\n\n # Check for large distance GMPEs\n if 'weights_large_dist' in conf['gmpe_sets'][set_name].keys():\n if not conf['gmpe_sets'][set_name]['weights_large_dist']:\n selected_weights_large_dist = None\n else:\n selected_weights_large_dist = \\\n [float(w) for w in\n conf['gmpe_sets'][set_name]['weights_large_dist']]\n else:\n selected_weights_large_dist = None\n\n if 'dist_cutoff' in conf['gmpe_sets'][set_name].keys():\n if np.isnan(conf['gmpe_sets'][set_name]['dist_cutoff']):\n selected_dist_cutoff = None\n else:\n selected_dist_cutoff = \\\n float(conf['gmpe_sets'][set_name]['dist_cutoff'])\n else:\n selected_dist_cutoff = None\n\n if 'site_gmpes' in conf['gmpe_sets'][set_name].keys():\n if not conf['gmpe_sets'][set_name]['site_gmpes']:\n selected_site_gmpes = None\n else:\n selected_site_gmpes = \\\n conf['gmpe_sets'][set_name]['site_gmpes']\n else:\n selected_site_gmpes = None\n\n if 'weights_site_gmpes' in conf['gmpe_sets'][set_name].keys():\n if not conf['gmpe_sets'][set_name]['weights_site_gmpes']:\n selected_weights_site_gmpes = None\n else:\n selected_weights_site_gmpes = \\\n conf['gmpe_sets'][set_name]['weights_site_gmpes']\n else:\n selected_weights_site_gmpes = None\n\n # ---------------------------------------------------------------------\n # Import GMPE modules and initialize classes into list\n # ---------------------------------------------------------------------\n gmpes = []\n for g in selected_gmpes:\n mod = import_module(conf['gmpe_modules'][g][1])\n tmpclass = getattr(mod, conf['gmpe_modules'][g][0])\n gmpes.append(tmpclass())\n\n # ---------------------------------------------------------------------\n # Filter out GMPEs not applicable to this period\n # ---------------------------------------------------------------------\n if filter_imt is not None:\n filtered_gmpes, filtered_wts = filter_gmpe_list(\n gmpes, selected_gmpe_weights, filter_imt)\n else:\n filtered_gmpes, filtered_wts = gmpes, selected_gmpe_weights\n\n # ---------------------------------------------------------------------\n # Import site GMPEs\n # ---------------------------------------------------------------------\n if selected_site_gmpes is not None:\n if isinstance(selected_site_gmpes, str):\n selected_site_gmpes = [selected_site_gmpes]\n site_gmpes = []\n for g in selected_site_gmpes:\n mod = import_module(conf['gmpe_modules'][g][1])\n tmpclass = getattr(mod, conf['gmpe_modules'][g][0])\n site_gmpes.append(tmpclass())\n else:\n site_gmpes = None\n\n # ---------------------------------------------------------------------\n # Filter out site GMPEs not applicable to this period\n # ---------------------------------------------------------------------\n if site_gmpes is not None:\n if filter_imt is not None:\n filtered_site_gmpes, filtered_site_wts = filter_gmpe_list(\n site_gmpes, selected_weights_site_gmpes, filter_imt)\n else:\n filtered_site_gmpes = copy.copy(site_gmpes)\n filtered_site_wts = copy.copy(selected_weights_site_gmpes)\n else:\n filtered_site_gmpes = None\n filtered_site_wts = None\n\n # ---------------------------------------------------------------------\n # Construct MultiGMPE\n # ---------------------------------------------------------------------\n if verbose is True:\n print(' filtered_gmpes: %s' % filtered_gmpes)\n print(' filtered_wts: %s' % filtered_wts)\n\n mgmpe = MultiGMPE.from_list(\n filtered_gmpes, filtered_wts,\n default_gmpes_for_site=filtered_site_gmpes,\n default_gmpes_for_site_weights=filtered_site_wts,\n imc=IMC)\n\n # ---------------------------------------------------------------------\n # Append large-distance info if specified\n # ---------------------------------------------------------------------\n if selected_dist_cutoff is not None:\n if filter_imt is not None:\n filtered_gmpes_ld, filtered_wts_ld = filter_gmpe_list(\n gmpes, selected_weights_large_dist, filter_imt)\n else:\n filtered_wts_ld = copy.copy(selected_weights_large_dist)\n\n mgmpe.CUTOFF_DISTANCE = copy.copy(selected_dist_cutoff)\n mgmpe.WEIGHTS_LARGE_DISTANCE = copy.copy(filtered_wts_ld)\n\n return mgmpe\n\n @classmethod\n def from_list(cls, gmpes, weights,\n imc=const.IMC.GREATER_OF_TWO_HORIZONTAL,\n default_gmpes_for_site=None,\n default_gmpes_for_site_weights=None,\n reference_vs30=760):\n \"\"\"\n Construct a MultiGMPE instance from lists of GMPEs and weights.\n\n Args:\n gmpes (list): List of OpenQuake\n `GMPE `__\n instances.\n\n weights (list): List of weights; must sum to 1.0.\n\n imc: Requested intensity measure component. Must be one listed\n `here `__.\n The amplitudes returned by the GMPEs will be converted to this\n IMT. Default is 'GREATER_OF_TWO_HORIZONTAL', which is used by\n ShakeMap. See discussion in\n `this section `__\n of the ShakeMap manual.\n\n default_gmpes_for_site (list):\n Optional list of OpenQuake GMPE instance to use as a site term\n for any of the GMPEs that do not have a site term.\n\n Notes:\n\n * We do not check for consistency in the reference rock\n defintion, so the user nees to be aware of this issue and\n holds responsibiilty for ensuring compatibility.\n * We check whether or not a GMPE has a site term by c\n hecking the REQUIRES_SITES_PARAMETERS slot for vs30.\n\n default_gmpes_for_site_weights: Weights for default_gmpes_for_site.\n Must sum to one and be same length as default_gmpes_for_site.\n If None, then weights are set to be equal.\n\n reference_vs30:\n Reference rock Vs30 in m/s. We do not check that this matches\n the reference rock in the GMPEs so this is the responsibility\n of the user.\n\n \"\"\" # noqa\n\n # ---------------------------------------------------------------------\n # Check that GMPE weights sum to 1.0:\n # ---------------------------------------------------------------------\n\n if np.abs(np.sum(weights) - 1.0) > 1e-7:\n raise Exception('Weights must sum to one.')\n\n # ---------------------------------------------------------------------\n # Check that length of GMPE weights equals length of gmpe list\n # ---------------------------------------------------------------------\n\n if len(weights) != len(gmpes):\n raise Exception(\n 'Length of weights must match length of GMPE list.')\n\n # ---------------------------------------------------------------------\n # Check that gmpes is a list of OQ GMPE instances\n # ---------------------------------------------------------------------\n\n for g in gmpes:\n if not isinstance(g, GMPE):\n raise Exception(\"\\\"%s\\\" is not a GMPE instance.\" % g)\n\n self = cls()\n self.GMPES = gmpes\n self.WEIGHTS = weights\n\n # ---------------------------------------------------------------------\n # Combine the intensity measure types. This is problematic:\n # - Logically, we should only include the intersection of the sets\n # of imts for the different GMPEs.\n # - In practice, this is not feasible because most GMPEs in CEUS and\n # subduction zones do not have PGV.\n # - So instead we will use the union of the imts and then convert\n # to get the missing imts later in get_mean_and_stddevs.\n # ---------------------------------------------------------------------\n\n imts = [g.DEFINED_FOR_INTENSITY_MEASURE_TYPES for g in gmpes]\n self.DEFINED_FOR_INTENSITY_MEASURE_TYPES = set.union(*imts)\n\n # ---------------------------------------------------------------------\n # For VirtualIPE class, we also want to know if ALL of the GMPEs are\n # defined for PGV, in which case we will convert from PGV to MI,\n # otherwise use PGA or Sa.\n # ---------------------------------------------------------------------\n haspgv = [PGV in g.DEFINED_FOR_INTENSITY_MEASURE_TYPES for g in gmpes]\n self.ALL_GMPES_HAVE_PGV = all(haspgv)\n\n # ---------------------------------------------------------------------\n # Store intensity measure types for conversion in get_mean_and_stddevs.\n # ---------------------------------------------------------------------\n self.IMCs = [g.DEFINED_FOR_INTENSITY_MEASURE_COMPONENT for g in gmpes]\n\n # ---------------------------------------------------------------------\n # Store the component\n # ---------------------------------------------------------------------\n self.DEFINED_FOR_INTENSITY_MEASURE_COMPONENT = imc\n\n # ---------------------------------------------------------------------\n # Intersection of GMPE standard deviation types\n # ---------------------------------------------------------------------\n stdlist = [set(g.DEFINED_FOR_STANDARD_DEVIATION_TYPES) for g in gmpes]\n self.DEFINED_FOR_STANDARD_DEVIATION_TYPES = \\\n set.intersection(*stdlist)\n\n # ---------------------------------------------------------------------\n # Need union of site parameters, but it is complicated by the\n # different depth parameter flavors.\n # ---------------------------------------------------------------------\n sitepars = [g.REQUIRES_SITES_PARAMETERS for g in gmpes]\n self.REQUIRES_SITES_PARAMETERS = set.union(*sitepars)\n\n # ---------------------------------------------------------------------\n # Construct a list of whether or not each GMPE has a site term\n # ---------------------------------------------------------------------\n self.HAS_SITE = ['vs30' in g.REQUIRES_SITES_PARAMETERS for g in gmpes]\n\n # ---------------------------------------------------------------------\n # Checks and sort out defaults\n # ---------------------------------------------------------------------\n\n # things to check if default_gmpes_for_site is provided\n if default_gmpes_for_site is not None:\n # check that default_gmpe_for_site are OQ GMPEs or None\n for g in default_gmpes_for_site:\n if not isinstance(g, GMPE):\n raise Exception(\"\\\"%s\\\" is not a GMPE instance.\" % g)\n\n # apply default weights if necessary\n if default_gmpes_for_site_weights is None:\n n = len(default_gmpes_for_site)\n default_gmpes_for_site_weights = [1 / n] * n\n\n # Things to check if one or more GMPE does not have a site term\n if not all(self.HAS_SITE):\n # Raise an exception if no default site is provided\n if default_gmpes_for_site is None:\n raise Exception('Must provide default_gmpes_for_site if one or'\n ' more GMPE does not have site term.')\n\n # If weights are unspecified, use equal weight\n if default_gmpes_for_site_weights is None:\n default_gmpes_for_site_weights = \\\n [1 / len(default_gmpes_for_site)] * \\\n len(default_gmpes_for_site)\n\n # check that length of default_gmpe_for_site matches length of\n # default_gmpe_for_site_weights\n if len(default_gmpes_for_site_weights) != \\\n len(default_gmpes_for_site):\n raise Exception('Length of default_gmpes_for_site_weights '\n 'must match length of default_gmpes_for_site '\n 'list.')\n\n # check weights sum to one if needed\n if not all(self.HAS_SITE):\n if np.sum(default_gmpes_for_site_weights) != 1.0:\n raise Exception('default_gmpes_for_site_weights must sum'\n ' to one.')\n\n # Note: if ALL of the GMPEs do not have a site term (requiring Vs30),\n # then REQUIRES_SITES_PARAMETERS for the MultiGMPE will not\n # include Vs30 even though it will be needed to compute the\n # default site term. So if the site checks have passed to this\n # point, we should add Vs30 to the set of required site pars:\n self.REQUIRES_SITES_PARAMETERS = set.union(\n self.REQUIRES_SITES_PARAMETERS, set(['vs30']))\n\n self.DEFAULT_GMPES_FOR_SITE = default_gmpes_for_site\n self.DEFAULT_GMPES_FOR_SITE_WEIGHTS = default_gmpes_for_site_weights\n self.REFERENCE_VS30 = reference_vs30\n\n # ---------------------------------------------------------------------\n # Union of rupture parameters\n # ---------------------------------------------------------------------\n ruppars = [g.REQUIRES_RUPTURE_PARAMETERS for g in gmpes]\n self.REQUIRES_RUPTURE_PARAMETERS = set.union(*ruppars)\n\n # ---------------------------------------------------------------------\n # Union of distance parameters\n # ---------------------------------------------------------------------\n distpars = [g.REQUIRES_DISTANCES for g in gmpes]\n self.REQUIRES_DISTANCES = set.union(*distpars)\n\n return self\n\n def get_site_factors(self, sites, rup, dists, imt, default=False):\n \"\"\"\n Method for computing site amplification factors from the defalut GMPE\n to be applied to GMPEs which do not have a site term.\n\n **NOTE** Amps are calculated in natural log units and so the ln(amp)\n is returned.\n\n Args:\n sites (SitesContext): Instance of SitesContext.\n rup (RuptureContext): Instance of RuptureContext.\n dists (DistancesContext): Instance of DistancesContext.\n imt: An instance openquake.hazardlib.imt.\n default (bool): Boolean of whether or not to return the\n amplificaiton factors for the gmpes or default_gmpes_for_site.\n This argument is primarily only intended to be used internally\n for when we just need to access the default amplifications to\n apply to those GMPEs that do not have site terms.\n\n Returns:\n Site amplifications in natural log units.\n \"\"\"\n\n # ---------------------------------------------------------------------\n # Make reference sites context\n # ---------------------------------------------------------------------\n\n ref_sites = copy.deepcopy(sites)\n ref_sites.vs30 = np.ones_like(sites.vs30) * self.REFERENCE_VS30\n\n # ---------------------------------------------------------------------\n # If default True, construct new MultiGMPE with default GMPE/weights\n # ---------------------------------------------------------------------\n if default is True:\n tmp = MultiGMPE.from_list(\n self.DEFAULT_GMPES_FOR_SITE,\n self.DEFAULT_GMPES_FOR_SITE_WEIGHTS,\n self.DEFINED_FOR_INTENSITY_MEASURE_COMPONENT)\n\n # ---------------------------------------------------------------------\n # If default False, just use self\n # ---------------------------------------------------------------------\n else:\n tmp = self\n\n lmean, lsd = tmp.get_mean_and_stddevs(\n sites, rup, dists, imt,\n list(tmp.DEFINED_FOR_STANDARD_DEVIATION_TYPES))\n lmean_ref, lsd = tmp.get_mean_and_stddevs(\n ref_sites, rup, dists, imt,\n list(tmp.DEFINED_FOR_STANDARD_DEVIATION_TYPES))\n\n lamps = lmean - lmean_ref\n\n return lamps\n\n @staticmethod\n def set_sites_depth_parameters(sites, gmpe):\n \"\"\"\n Need to select the appropriate z1pt0 value for different GMPEs.\n Note that these are required site parameters, so even though\n OQ has these equations built into the class in most cases.\n I have submitted an issue to OQ requesting subclasses of these\n methods that do not require the depth parameters in the\n SitesContext to make this easier.\n\n Args:\n sites:1 An OQ sites context.\n gmpe: An OQ GMPE instance.\n\n Returns:\n An OQ sites context with the depth parameters set for the\n requested GMPE.\n \"\"\"\n\n sites = Sites._addDepthParameters(sites)\n\n if gmpe == 'AbrahamsonEtAl2014()':\n sites.z1pt0 = sites.z1pt0_ask14_cal\n if gmpe == 'ChiouYoungs2014()':\n # Also BooreEtAl2014() if using subclass with depth parameter\n sites.z1pt0 = sites.z1pt0_cy14_cal\n if gmpe == 'CampbellBozorgnia2014()':\n sites.z2pt5 = sites.z2pt5_cb14_cal\n if gmpe == 'ChiouYoungs2008()':\n sites.z1pt0 = sites.z1pt0_cy08\n if gmpe == 'CampbellBozorgnia2008()':\n sites.z2pt5 = sites.z2pt5_cb07\n\n return sites\n\n\ndef filter_gmpe_list(gmpes, wts, imt):\n \"\"\"\n Method to remove GMPEs from the GMPE list that are not applicable\n to a specific IMT. Rescales the weights to sum to one.\n\n Args:\n gmpes (list): List of GMPE instances.\n wts (list): List of floats indicating the weight of the GMPEs.\n imt (IMT): OQ IMT to filter GMPE list for.\n\n Returns:\n tuple: List of GMPE instances and list of weights.\n\n \"\"\"\n if wts is None:\n n = len(gmpes)\n wts = [1 / n] * n\n\n per_max = [np.max(get_gmpe_sa_periods(g)) for g in gmpes]\n per_min = [np.min(get_gmpe_sa_periods(g)) for g in gmpes]\n if imt == PGA():\n sgmpe = [g for g in gmpes if imt in\n get_gmpe_coef_table(g).non_sa_coeffs]\n swts = [w for g, w in zip(gmpes, wts) if imt in\n get_gmpe_coef_table(g).non_sa_coeffs]\n elif imt == PGV():\n sgmpe = []\n swts = []\n for i in range(len(gmpes)):\n if (imt in get_gmpe_coef_table(gmpes[i]).non_sa_coeffs) or\\\n (per_max[i] >= 1.0 and per_min[i] <= 1.0):\n sgmpe.append(gmpes[i])\n swts.append(wts[i])\n else:\n per = imt.period\n sgmpe = []\n swts = []\n for i in range(len(gmpes)):\n if (per_max[i] >= per and per_min[i] <= per):\n sgmpe.append(gmpes[i])\n swts.append(wts[i])\n\n if len(sgmpe) == 0:\n raise Exception('No applicable GMPEs from GMPE list for %s' % imt)\n\n # Scale weights to sum to one\n swts = np.array(swts)\n swts = swts / np.sum(swts)\n\n return sgmpe, swts\n\n\ndef get_gmpe_sa_periods(gmpe):\n \"\"\"\n Method to extract the SA periods defined by a GMPE.\n\n Args:\n gmpe (GMPE): A GMPE instance.\n\n Retunrs:\n list: List of periods.\n\n \"\"\"\n ctab = get_gmpe_coef_table(gmpe).sa_coeffs\n ilist = list(ctab.keys())\n per = [i.period for i in ilist]\n return per\n\n\ndef get_gmpe_coef_table(gmpe):\n \"\"\"\n Method for finding the (or \"a\") GMPE table.\n\n Notes:\n\n * The reason for the complexity here is that there can be multiple\n coefficient tables, and some of them may not have the sa_coeffs\n attribute, which is the main reason for getting the table.\n * We are also assuming that if there are more than one coefficient\n table, the range of periods will be the same across all of the\n tables.\n\n Args:\n gmpe (GMPE): An OQ GMPE instance.\n\n Returns:\n The associated coefficient table.\n\n \"\"\"\n stuff = gmpe.__dir__()\n coef_list = [s for s in stuff if 'COEFFS' in s]\n for coef_sel in coef_list:\n cobj = getattr(gmpe, coef_sel)\n if \"sa_coeffs\" in cobj.__dir__():\n return cobj\n raise Exception(\"GMPE %s does not contain sa_coeffs attribute.\" % gmpe)\n", "meta": {"hexsha": "0c13d366bf4b27b8fc7cc296dc59444e15a00dbd", "size": 33517, "ext": "py", "lang": "Python", "max_stars_repo_path": "shakelib/multigmpe.py", "max_stars_repo_name": "ynthdhj/shakemap", "max_stars_repo_head_hexsha": "2771b8aee6b22f065cc80632c894a0ba77829619", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "shakelib/multigmpe.py", "max_issues_repo_name": "ynthdhj/shakemap", "max_issues_repo_head_hexsha": "2771b8aee6b22f065cc80632c894a0ba77829619", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "shakelib/multigmpe.py", "max_forks_repo_name": "ynthdhj/shakemap", "max_forks_repo_head_hexsha": "2771b8aee6b22f065cc80632c894a0ba77829619", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.6424936387, "max_line_length": 177, "alphanum_fraction": 0.5030581496, "include": true, "reason": "import numpy", "num_tokens": 7278, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5621765008857981, "lm_q2_score": 0.34510527095787247, "lm_q1q2_score": 0.19401007366434198}} {"text": "#pylint: disable=dangerous-default-value, unused-import\n\"\"\"\n This module contains material models containing thermal, fluid, and\n material properties. These models can be stored to and recalled from\n XML files for archiving.\n\"\"\"\n\nfrom collections import ChainMap\nimport xml.etree.ElementTree as ET\n\nimport numpy as np\nimport scipy.interpolate as inter\n\nfrom neml import parse, models\n\nclass DeformationMaterial:\n \"\"\"\n Incredibly thin wrapper around a NEML XML file\n \"\"\"\n def __init__(self, xmlfile, modelname):\n \"\"\"\n Parameters:\n xmlfile: file location for the input file\n modelname: which model to load\n \"\"\"\n self.xmlfile = xmlfile\n self.modelname = modelname\n\n def get_neml_model(self):\n \"\"\"\n Return the actual model for use in a solve\n \"\"\"\n return parse.parse_xml(self.xmlfile, self.modelname)\n\nclass ThermalMaterial:\n \"\"\"\n Material thermal properties.\n\n This object needs to provide:\n 1) material name\n 2) the conductivity, as a function of temperature and its derivative\n 3) the diffusivity, as a function of temperature and its derivative\n \"\"\"\n def get_dict(self):\n \"\"\"\n Returns the data as a dictionary\n \"\"\"\n raise NotImplementedError()\n\n def get_type(self):\n \"\"\"\n Return the string type for the data\n \"\"\"\n raise NotImplementedError()\n\n @classmethod\n def load(cls, fname, modelname):\n \"\"\"\n Load from a dictionary\n\n Parameters:\n fname filename\n \"\"\"\n tag, typ = find_name(fname, modelname)\n data = load_node(tag)[modelname]\n\n if typ == \"PiecewiseLinearThermalMaterial\":\n return PiecewiseLinearThermalMaterial.load(data)\n elif typ == \"ConstantThermalMaterial\":\n return ConstantThermalMaterial.load(data)\n else:\n raise ValueError(\"Unknown ThermalMaterial type %s\" % typ)\n\n def save(self, fname, modelname):\n \"\"\"\n Save the model to an XML file as modelname\n\n Parameters:\n fname filename to use\n modelname (base tag) to use\n \"\"\"\n root = ET.Element(\"models\")\n\n save_node(modelname, self.get_dict(), root,\n attrib = {\"type\": self.get_type()})\n\n tree = ET.ElementTree(element = root)\n tree.write(fname)\n\nclass PiecewiseLinearThermalMaterial(ThermalMaterial):\n \"\"\"\n Interpolate thermal properties linearly from a table\n \"\"\"\n def __init__(self, name, temps, cond, diff):\n \"\"\"\n Properties:\n name: material name\n temps: list of temperature points\n cond: list of conductivity values\n diff: list of diffusivity values\n \"\"\"\n if len(temps) != len(cond) or len(temps) != len(diff):\n raise ValueError(\"The lists of temperatures, conductivity,\"\n \"and diffusivity values must have equal lengths!\")\n\n self.name = name\n self.temps = np.array(temps)\n self.cond = np.array(cond)\n self.diff = np.array(diff)\n\n self.fcond, self.dfcond = make_piecewise(self.temps, self.cond)\n self.fdiff, self.dfdiff = make_piecewise(self.temps, self.diff)\n\n def conductivity(self, T):\n \"\"\"\n Conductivity as a function of temperature\n\n Parameters:\n T temperature\n \"\"\"\n return self.fcond(T)\n\n def diffusivity(self, T):\n \"\"\"\n Diffusivity as a function of temperature\n\n Parameters:\n T temperature\n \"\"\"\n return self.fdiff(T)\n\n def dconductivity(self, T):\n \"\"\"\n Derivative of conductivity as a function of temperature\n\n Parameters:\n T temperature\n \"\"\"\n return self.dfcond(T)\n\n def ddiffusivity(self, T):\n \"\"\"\n Derivative of diffusivity as a function of temperature\n\n Parameters:\n T temperature\n \"\"\"\n return self.dfdiff(T)\n\n def get_type(self):\n \"\"\"\n String type\n \"\"\"\n return \"PiecewiseLinearThermalMaterial\"\n\n def get_dict(self):\n \"\"\"\n Pickled dictionary\n \"\"\"\n return {\"name\": self.name, \"temps\": string_array(self.temps),\n \"cond\": string_array(self.cond), \"diff\": string_array(self.diff)} \n\n @classmethod\n def load(cls, values):\n \"\"\"\n Load from a dictionary\n\n Parameters:\n values dictionary values\n \"\"\"\n return cls(values[\"name\"], destring_array(values[\"temps\"]), destring_array(values[\"cond\"]),\n destring_array(values[\"diff\"]))\n\nclass ConstantThermalMaterial(ThermalMaterial):\n \"\"\"\n Constant thermal properties\n \"\"\"\n def __init__(self, name, k, alpha):\n \"\"\"\n Properties:\n name: material name\n k: conductivity\n alpha: diffusivity\n \"\"\"\n self.name = name\n self.cond = k\n self.diff = alpha\n\n def conductivity(self, T):\n \"\"\"\n Conductivity as a function of temperature\n\n Parameters:\n T temperature\n \"\"\"\n return T * 0.0 + self.cond\n\n def diffusivity(self, T):\n \"\"\"\n Diffusivity as a function of temperature\n\n Parameters:\n T temperature\n \"\"\"\n return T * 0.0 + self.diff\n\n def dconductivity(self, T):\n \"\"\"\n Derivative of conductivity as a function of temperature\n\n Parameters:\n T temperature\n \"\"\"\n return T * 0.0\n\n def ddiffusivity(self, T):\n \"\"\"\n Derivative of diffusivity as a function of temperature\n\n Parameters:\n T temperature\n \"\"\"\n return T * 0.0\n\n def get_type(self):\n \"\"\"\n String type\n \"\"\"\n return \"ConstantThermalMaterial\"\n\n def get_dict(self):\n \"\"\"\n Pickled dictionary\n \"\"\"\n return {\"name\": self.name, \"k\": str(self.cond),\n \"alpha\": str(self.diff)}\n\n @classmethod\n def load(cls, values):\n \"\"\"\n Load from a dictionary\n\n Parameters:\n values dictionary values\n \"\"\"\n return cls(values[\"name\"], float(values[\"k\"]), float(values[\"alpha\"]))\n\nclass FluidMaterial:\n \"\"\"\n Properties for convective heat transfer.\n\n This object needs to store:\n 1) Fluid name\n 2) A map between a ThermalMaterial name and the corresponding\n temperature-dependent film coefficient and its derivative\n \"\"\"\n def get_dict(self):\n \"\"\"\n Returns the data as a dictionary\n \"\"\"\n raise NotImplementedError()\n\n def get_type(self):\n \"\"\"\n Return the string type for the data\n \"\"\"\n raise NotImplementedError()\n\n @classmethod\n def load(cls, fname, modelname):\n \"\"\"\n Load a FluidMaterial object from a file\n\n Parameters:\n fname file name to load from\n \"\"\"\n tag, typ = find_name(fname, modelname)\n data = load_node(tag)[modelname]\n\n if typ == \"PiecewiseLinearFluidMaterial\":\n return PiecewiseLinearFluidMaterial.load(data)\n elif typ == \"ConstantFluidMaterial\":\n return ConstantFluidMaterial.load(data)\n else:\n raise ValueError(\"Unknown FluidMaterial type %s\" % typ)\n\n def save(self, fname, modelname):\n \"\"\"\n Save the model to an XML file as modelname\n\n Parameters:\n fname filename to use\n modelname (base tag) to use\n \"\"\"\n root = ET.Element(\"models\")\n\n save_node(modelname, self.get_dict(), root,\n attrib = {\"type\": self.get_type()})\n\n tree = ET.ElementTree(element = root)\n tree.write(fname)\n\nclass ConstantFluidMaterial(FluidMaterial):\n \"\"\"\n Supply a mapping between the material type and a constant\n film coefficient\n \"\"\"\n def __init__(self, data):\n \"\"\"\n Dictionary of the form {name: value} mapping\n a material name to the definition of the piecewise linear map\n\n Parameters:\n data: the dictionary\n \"\"\"\n self.data = data\n \n def get_dict(self):\n return {k: str(v) for k, v in self.data.items()} \n\n def get_type(self):\n return \"ConstantFluidMaterial\"\n\n @classmethod\n def load(cls, values):\n \"\"\"\n Load from a dictionary\n\n Parameters:\n values dictionary data\n \"\"\"\n data = {k: float(val) for k, val in values.items()}\n return cls(data)\n\n def coefficient(self, material, T):\n \"\"\"\n Return the film coefficient for the given material and temperature\n\n Parameters:\n material: material name\n T: temperatures\n\n \"\"\"\n if material in self.data:\n return T*0.0 + self.data[material]\n else:\n return T*0.0 + self.data[\"default\"]\n\n # pylint: disable=unused-argument\n def dcoefficient(self, material, T):\n \"\"\"\n Return the derivative of the film coefficient with respect to\n temperature for the give material and temperature.\n\n Parameters:\n material: material name\n T: temperatures\n \"\"\"\n return T * 0.0\n\nclass PiecewiseLinearFluidMaterial(FluidMaterial):\n \"\"\"\n Supply a mapping between the material type and a piecewise linear\n interpolate defining the film coefficient as a function of temperature.\n \"\"\"\n def __init__(self, data):\n \"\"\"\n Dictionary of the form {name: (temperatures, values)} mapping\n a material name to the definition of the piecewise linear map\n\n Parameters:\n data: the dictionary\n \"\"\"\n self.data = data\n\n self.fns = {name: make_piecewise(T, v) for name, (T,v) in data.items()}\n\n def get_dict(self):\n return {k: {'temp': string_array(T),\n 'values': string_array(v)} for k, (T, v) in self.data.items()}\n\n def get_type(self):\n return \"PiecewiseLinearFluidMaterial\"\n\n @classmethod\n def load(cls, values):\n \"\"\"\n Load from a dictionary\n\n Parameters:\n values dictionary data\n \"\"\"\n data = {k: (destring_array(pair['temp']),\n destring_array(pair['values'])) for k, pair in values.items()}\n return cls(data)\n\n def coefficient(self, material, T):\n \"\"\"\n Return the film coefficient for the given material and temperature\n\n Parameters:\n material: material name\n T: temperatures\n\n \"\"\"\n if material in self.fns.keys():\n return self.fns[material][0](T)\n else:\n return self.fns[\"default\"][0](T)\n\n def dcoefficient(self, material, T):\n \"\"\"\n Return the derivative of the film coefficient with respect to\n temperature for the give material and temperature.\n\n Parameters:\n material: material name\n T: temperatures\n \"\"\"\n if material in self.fns.keys():\n return self.fns[material][1](T)\n else:\n return self.fns[\"default\"][1](T)\n\nclass StructuralMaterial:\n \"\"\"\n Properties for structural material\n\n Supply\n 1) cycles to failure as a function of temperature and strain range\n 2) time to rupture as a function of temperaure and stress\n 3) checks creep-fatigue interaction diagram\n \"\"\"\n def __init__(self, data):\n self.data = data\n\n def cycles_to_fail(self, pname, temp, erange):\n \"\"\"\n Returns fatigue cycles to failure at a given temperature and strain range\n\n Parameters:\n pname: property name (\"nominalFatigue\")\n erange: strain range in mm/mm\n temp: temperature in K\n \"\"\"\n pdata = self.data[pname]\n T, a, n, cutoff = [],[],[],[]\n\n for i in pdata:\n T.append(destring_array(pdata[i][\"T\"]))\n a.append(destring_array(pdata[i][\"a\"]))\n n.append(destring_array(pdata[i][\"n\"]))\n cutoff.append(destring_array(pdata[i][\"cutoff\"]))\n\n if np.array(a).shape != np.array(n).shape:\n raise ValueError(\"\\tThe lists of a and n must have equal lengths!\")\n\n inds=np.array(T).argsort(axis=0)\n T = np.array(T)[inds]\n a = np.array(a)[inds]\n n = np.array(n)[inds]\n cutoff = np.array(cutoff)[inds]\n\n if temp > max(T):\n raise ValueError(\"\\ttemperature is out of range for cycle to failure determination\")\n\n for i in range(np.size(T, axis=0)):\n if temp<=T[i]:\n polysum = 0.0\n if erange<=cutoff[i]:\n erange = cutoff[i][0][0]\n for (b,m) in zip(a[i][0],n[i][0]):\n polysum+=b*np.log10(erange)**m\n break\n\n return 10**polysum\n\n def time_to_rupture(self, pname, temp, stress):\n \"\"\"\n Returns time to rupture at a given temperature and stress\n\n Parameters:\n pname: property name (\"averageRupture\" or \"lowerboundRupture\")\n stress: stress in MPa\n temp: temperature in K\n \"\"\"\n pdata = self.data[pname]\n\n a=destring_array(pdata[\"a\"])\n n=destring_array(pdata[\"n\"])\n C=destring_array(pdata[\"C\"])\n\n if a.shape != n.shape:\n raise ValueError(\"The lists of a and n must have equal lengths!\")\n \n if stress.shape != temp.shape:\n raise ValueError(\"Stress and temperature must have the same shape!\")\n \n zeros = stress == 0.0\n not_zeros = np.logical_not(zeros)\n\n res = np.zeros(stress.shape)\n for (b,m) in zip(a,n):\n res[not_zeros] += b*np.log10(stress[not_zeros])**m\n res[not_zeros] = 10.0**(res[not_zeros]/temp[not_zeros]-C)\n res[zeros] = np.inf\n\n return res\n\n def inside_envelope(self, pname, damage_fatigue, damage_creep):\n \"\"\"\n Returns True if the point lies inside the design envelope and False if not\n\n Parameters:\n pname: property name (\"cfinteraction\")\n damage_fatigue: fatigue damage fraction\n creep_fatigue: creep damage fraction\n \"\"\"\n\n if damage_fatigue < 0.0 or damage_creep < 0.0:\n raise ValueError(\"\\tout of range: negative damage fraction\")\n\n pdata = destring_array(self.data[pname])\n\n x_1 = 0.0\n y_1 = 1.0\n x_2 = pdata[0]\n y_2 = pdata[1]\n x_3 = 1.0\n y_3 = 0.0\n\n if damage_fatigue < x_2:\n return damage_creep <= ((y_2 - y_1) / (x_2 - x_1) * (damage_fatigue - x_1) + y_1)\n return damage_creep <= ((y_3 - y_2) / (x_3 - x_2) * (damage_fatigue - x_2) + y_2)\n\n @classmethod\n def load(cls, fname, model):\n \"\"\"\n Load a Structural Material object from a file\n\n Parameters:\n fname: file name to load from\n material: model name\n \"\"\"\n tag = ET.parse(fname).getroot().find(model)\n return cls(load_node(tag)[model])\n\n def save(self, fname, modelname):\n \"\"\"\n Save to a particular file under a particular model name\n \"\"\"\n root = ET.Element('models')\n save_node(modelname, self.data, root)\n tree = ET.ElementTree(element = root)\n tree.write(fname)\n\ndef make_piecewise(x, y):\n \"\"\"\n Make two piecewise interpolation functions: a piecewise linear\n interpolate between x and y and the corresponding derivative.\n \"\"\"\n ydiff = np.zeros(y.shape)\n ydiff[:-1] = np.diff(y) / np.diff(x)\n ydiff[-1] = ydiff[-2]\n\n return inter.interp1d(x, y), inter.interp1d(x, ydiff, kind = \"previous\")\n\ndef find_name(xmlfile, name):\n \"\"\"\n Find the base tag with name in an XML file\n\n Parameters:\n xmlfile: file name\n name: tag to look for\n \"\"\"\n root = ET.parse(xmlfile).getroot()\n tag = root.find(name)\n\n return tag, tag.attrib[\"type\"]\n\ndef save_node(name, entry, node, attrib = {}):\n \"\"\"\n Save a dictionary to a particular node\n\n Parameters:\n name: name of the new node\n entry: entry of interest\n node: ET parent node object\n\n Additional parameters:\n attribs node attributes\n \"\"\"\n nnode = ET.SubElement(node, name, attrib)\n if isinstance(entry, dict):\n for k,v in entry.items():\n save_node(k, v, nnode)\n else:\n nnode.text = entry\n\ndef load_node(node):\n \"\"\"\n The actual function that does the loading by walking the XML file\n\n Parameters:\n node: xml node object from ET\n \"\"\"\n if len(node) > 0:\n return {node.tag: dict(ChainMap(*(load_node(child) for child in node)))}\n else:\n return {node.tag: node.text}\n\ndef string_array(array):\n \"\"\"\n Make a numpy array a space separated string\n \"\"\"\n return \" \".join(map(str, array))\n\ndef destring_array(string):\n \"\"\"\n Make an array from a space separated string\n \"\"\"\n return np.array(list(map(float, string.split(\" \"))))\n", "meta": {"hexsha": "86a46276f058eeb8171a7e3a34c9da0249e6c2f3", "size": 15901, "ext": "py", "lang": "Python", "max_stars_repo_path": "srlife/materials.py", "max_stars_repo_name": "willietheboy/srlife-dev", "max_stars_repo_head_hexsha": "d4c2d28b40d2ee1bf64c7555a913b0a49adffe0f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-10-05T20:36:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-09T00:33:41.000Z", "max_issues_repo_path": "srlife/materials.py", "max_issues_repo_name": "willietheboy/srlife-dev", "max_issues_repo_head_hexsha": "d4c2d28b40d2ee1bf64c7555a913b0a49adffe0f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2020-12-02T16:10:28.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-22T19:45:32.000Z", "max_forks_repo_path": "srlife/materials.py", "max_forks_repo_name": "willietheboy/srlife-dev", "max_forks_repo_head_hexsha": "d4c2d28b40d2ee1bf64c7555a913b0a49adffe0f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2020-09-10T17:46:41.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-08T04:26:39.000Z", "avg_line_length": 25.5232744783, "max_line_length": 95, "alphanum_fraction": 0.6166907742, "include": true, "reason": "import numpy,import scipy", "num_tokens": 3887, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5621765008857981, "lm_q2_score": 0.34510526422232046, "lm_q1q2_score": 0.19401006987777292}} {"text": "from collections import namedtuple\nimport sys\nimport re\nimport warnings\nimport array\n\nimport numpy as np\n\nfrom scipy._lib._util import check_random_state\nfrom scipy.optimize import minimize, differential_evolution, least_squares\nimport scipy.optimize as sciopt\n\nfrom refnx.analysis import Objective, Interval, PDF, is_parameter\nfrom refnx._lib import (\n unique as f_unique,\n MapWrapper,\n possibly_open_file,\n flatten,\n)\nfrom refnx._lib.util import getargspec\nfrom refnx._lib._qmc import LatinHypercube\nfrom refnx._lib import emcee\nfrom refnx._lib.emcee.state import State\nfrom refnx._lib.emcee.pbar import get_progress_bar\n\n\nMCMCResult = namedtuple(\n \"MCMCResult\", [\"name\", \"param\", \"stderr\", \"chain\", \"median\"]\n)\n\n\nclass PTSampler:\n def __init__(self, ntemps, nwalkers, ndim, logl, logp, **kwargs):\n \"\"\"\n Shim class for a ptemcee.PTSampler.\n\n Parameters\n ----------\n ntemps: int, np.array\n Specifies the number of parallel tempering temperatures.\n If an array specifies a ladder of Beta values.\n nwalkers: int\n Number of walkers\n ndim: int\n Dimensionality of the problem space\n logl: callable\n log-likelihood function\n logp: callable\n log-prior function\n kwargs:\n Other keyword arguments supplied to construct the ptemcee.Sampler.\n \"\"\"\n from refnx._lib.ptemcee import Sampler as _PTSampler\n\n self.ntemps = ntemps\n self.nwalkers = nwalkers\n self.ndim = ndim\n self.logl = logl\n self.logp = logp\n self.kwargs = kwargs\n\n sig = {\n \"betas\": ntemps,\n \"nwalkers\": nwalkers,\n \"ndim\": ndim,\n \"logl\": logl,\n \"logp\": logp,\n }\n sig.update(kwargs)\n self.sampler = _PTSampler(**sig)\n\n # chain stepper\n self._ptchain = None\n self._state = None\n\n def sample(\n self,\n initial_state,\n iterations=1,\n thin_by=1,\n progress=False,\n mapper=None,\n **kwds\n ):\n \"\"\"\n Runs the PTSampler for a given number of iterations.\n\n Parameters\n ----------\n initial_state: emcee.state.State\n Holds the coordinates of the initial state\n iterations: int\n Number of steps to save into the chain\n thin_by: int\n The saved steps are separated by this many discarded steps.\n progress: bool\n Display a progress bar.\n mapper: map-like callable\n For parallelisation\n kwds: dict\n Unknown keywords\n\n Yields\n -------\n state: emcee.state.State\n The coordinates of the current state\n \"\"\"\n if isinstance(initial_state, State):\n init_x = initial_state.coords\n rstate0 = initial_state.random_state\n else:\n init_x = initial_state\n rstate0 = np.random.RandomState().get_state()\n\n if self._ptchain is None:\n self._ptchain = self.sampler.chain(init_x)\n else:\n self._ptchain.ensemble.x = init_x\n\n # set random state of stateful chain\n self.random_state = rstate0\n\n self._ptchain.thin_by = thin_by\n\n if mapper is not None:\n self._ptchain.ensemble._mapper = mapper\n\n try:\n with get_progress_bar(progress, iterations * thin_by) as pbar:\n for e in self._ptchain.iterate(iterations):\n self._state = State(e.x, log_prob=e.logl + e.logP)\n yield self._state\n pbar.update(thin_by)\n finally:\n self._ptchain.ensemble._mapper = map\n\n def thermodynamic_integration_log_evidence(self, fburnin=0.1):\n if self._ptchain is not None:\n return self._ptchain.log_evidence_estimate(fburnin)\n return None, None\n\n def reset(self):\n if self._state is not None:\n self._ptchain = self.sampler.chain(self._state.coords)\n\n def get_chain(self):\n if self._ptchain is not None:\n return self._ptchain.x\n return None\n\n @property\n def chain(self):\n if self._ptchain is not None:\n return self._ptchain.x\n return None\n\n def get_log_prob(self):\n if self._ptchain is not None:\n return self._ptchain.logP\n return None\n\n @property\n def random_state(self):\n if self._ptchain is not None:\n self._ptchain.ensemble._random.get_state()\n\n @random_state.setter\n def random_state(self, rstate0):\n if self._ptchain is not None:\n self._ptchain.ensemble._random.set_state(rstate0)\n\n\nclass CurveFitter:\n \"\"\"\n Analyse a curvefitting system (with MCMC sampling)\n\n Parameters\n ----------\n objective : refnx.analysis.Objective\n The :class:`refnx.analysis.Objective` to be analysed.\n nwalkers : int, optional\n How many walkers you would like the sampler to have. Must be an\n even number. The more walkers the better.\n ntemps : int or None, optional\n If `ntemps == -1`, then an :class:`emcee.EnsembleSampler` is used\n during the `sample` method.\n Otherwise, or if `ntemps is None` then parallel tempering is\n used with a :class:`ptemcee.sampler.Sampler` object during the `sample`\n method, with `ntemps` specifing the number of temperatures. Can be\n `None`, in which case the `Tmax` keyword argument sets the maximum\n temperature. Parallel Tempering is useful if you expect your\n posterior distribution to be multi-modal.\n\n mcmc_kws : dict\n Keywords used to create the :class:`emcee.EnsembleSampler` or\n :class:`ptemcee.sampler.Sampler` objects.\n\n Notes\n -----\n See the documentation at http://dan.iel.fm/emcee/current/api/ for\n further details on what keywords are permitted, and for further\n information on Parallel Tempering. The `pool` and `threads` keywords\n are ignored here. Specification of parallel threading is done with the\n `pool` argument in the `sample` method.\n \"\"\"\n\n def __init__(self, objective, nwalkers=200, ntemps=-1, **mcmc_kws):\n \"\"\"\n Parameters\n ----------\n objective : refnx.analysis.Objective\n The :class:`refnx.analysis.Objective` to be analysed.\n nwalkers : int, optional\n How many walkers you would like the sampler to have. Must be an\n even number. The more walkers the better.\n ntemps : int or None, optional\n If `ntemps == -1`, then an :class:`emcee.EnsembleSampler` is used\n during the `sample` method.\n Otherwise, or if `ntemps is None` then parallel tempering is\n used with a :class:`ptemcee.sampler.Sampler` object during the\n `sample` method, with `ntemps` specifing the number of\n temperatures. Can be `None`, in which case the `Tmax` keyword\n argument sets the maximum temperature. Parallel Tempering is\n useful if you expect your posterior distribution to be multi-modal.\n mcmc_kws : dict\n Keywords used to create the :class:`emcee.EnsembleSampler` or\n :class:`ptemcee.sampler.PTSampler` objects.\n\n Notes\n -----\n See the documentation at http://dan.iel.fm/emcee/current/api/ for\n further details on what keywords are permitted. The `pool` and\n keyword is ignored here. Specification of parallel threading is done\n with the `pool` argument in the `sample` method.\n To use parallel tempering you will need to install the\n :package:`ptemcee` package.\n \"\"\"\n self.objective = objective\n self._varying_parameters = []\n self.__var_id = []\n\n self.mcmc_kws = {}\n if mcmc_kws is not None:\n self.mcmc_kws.update(mcmc_kws)\n\n if \"pool\" in self.mcmc_kws:\n self.mcmc_kws.pop(\"pool\")\n if \"threads\" in self.mcmc_kws:\n self.mcmc_kws.pop(\"threads\")\n\n self._nwalkers = nwalkers\n self._ntemps = ntemps\n self.make_sampler()\n self._state = None\n\n def __setstate__(self, state):\n self.__dict__.update(state)\n self.__var_id = [\n id(obj) for obj in self.objective.varying_parameters()\n ]\n\n @property\n def nvary(self):\n return len(self._varying_parameters)\n\n def __repr__(self):\n # attempt to get a minimum repr for a CurveFitter. However,\n # it has so much state when the sampling has been done, that\n # will be ignored.\n d = {\n \"objective\": self.objective,\n \"_nwalkers\": self._nwalkers,\n \"_ntemps\": self._ntemps,\n \"mcmc_kws\": self.mcmc_kws,\n }\n return (\n \"CurveFitter({objective!r},\"\n \" nwalkers={_nwalkers},\"\n \" ntemps={_ntemps},\"\n \" {mcmc_kws!r})\".format(**d)\n )\n\n def make_sampler(self):\n \"\"\"\n Make the samplers for the Objective.\n\n Use this method if the number of varying parameters changes.\n \"\"\"\n self._varying_parameters = self.objective.varying_parameters()\n self.__var_id = [id(obj) for obj in self._varying_parameters]\n\n if not self.nvary:\n raise ValueError(\"No parameters are being fitted\")\n\n if self._ntemps == -1:\n self.sampler = emcee.EnsembleSampler(\n self._nwalkers,\n self.nvary,\n self.objective.logpost,\n **self.mcmc_kws\n )\n # Parallel Tempering was requested.\n else:\n sig = {\n \"ntemps\": self._ntemps,\n \"nwalkers\": self._nwalkers,\n \"ndim\": self.nvary,\n \"logl\": self.objective.logl,\n \"logp\": self.objective.logp,\n }\n sig.update(self.mcmc_kws)\n self.sampler = PTSampler(**sig)\n\n self._state = None\n\n def _check_vars_unchanged(self):\n \"\"\"\n Keep track of whether the varying parameters have changed after\n construction of CurveFitter object.\n\n \"\"\"\n var_ids = [id(obj) for obj in self.objective.varying_parameters()]\n if not (np.array_equal(var_ids, self.__var_id)):\n raise RuntimeError(\n \"The Objective.varying_parameters() have\"\n \" changed since the CurveFitter was created.\"\n \" To keep on using the CurveFitter call\"\n \" the CurveFitter.make_samplers() method.\"\n )\n\n def initialise(self, pos=\"covar\", random_state=None):\n \"\"\"\n Initialise the emcee walkers.\n\n Parameters\n ----------\n pos : str or np.ndarray\n Method for initialising the emcee walkers. One of:\n\n - 'covar', use the estimated covariance of the system.\n - 'jitter', add a small amount of gaussian noise to each parameter\n - 'prior', sample random locations from the prior using Latin\n Hyper Cube.\n - pos, an array that specifies a snapshot of the walkers. Has shape\n `(nwalkers, ndim)`, or `(ntemps, nwalkers, ndim)` if parallel\n tempering is employed. You can also provide a previously\n created chain.\n random_state : {int, `np.random.RandomState`, `np.random.Generator`}\n If `random_state` is not specified the `~np.random.RandomState`\n singleton is used.\n If `random_state` is an int, a new ``RandomState`` instance is\n used, seeded with random_state.\n If `random_state` is already a ``RandomState`` or a ``Generator``\n instance, then that object is used.\n Specify `random_state` for repeatable initialisations.\n \"\"\"\n nwalkers = self._nwalkers\n nvary = self.nvary\n\n # acquire a random number generator\n rng = check_random_state(random_state)\n\n # account for parallel tempering\n _ntemps = self._ntemps\n\n # If you're not doing parallel tempering, temporarily set the number of\n # temperatures to be created to 1, thereby producing initial positions\n # of (1, nwalkers, nvary), this first dimension should be removed at\n # the end of the method\n if self._ntemps == -1:\n _ntemps = 1\n\n # position is specified with array (no parallel tempering)\n if (\n isinstance(pos, np.ndarray)\n and self._ntemps == -1\n and pos.shape == (nwalkers, nvary)\n ):\n init_walkers = np.copy(pos)[np.newaxis]\n\n # position is specified with array (with parallel tempering)\n elif (\n isinstance(pos, np.ndarray)\n and self._ntemps > -1\n and pos.shape == (_ntemps, nwalkers, nvary)\n ):\n init_walkers = np.copy(pos)\n\n # position is specified with existing chain\n elif isinstance(pos, np.ndarray):\n self.initialise_with_chain(pos)\n return\n\n # position is to be created from covariance matrix\n elif pos == \"covar\":\n p0 = np.array(self._varying_parameters)\n cov = self.objective.covar()\n init_walkers = rng.multivariate_normal(\n np.atleast_1d(p0), np.atleast_2d(cov), size=(_ntemps, nwalkers)\n )\n\n # position is specified by jittering the parameters with gaussian noise\n elif pos == \"jitter\":\n var_arr = np.array(self._varying_parameters)\n pos = 1 + rng.standard_normal((_ntemps, nwalkers, nvary)) * 1.0e-4\n pos *= var_arr\n init_walkers = pos\n\n # use the prior to initialise position\n elif pos == \"prior\":\n arr = np.zeros((_ntemps, nwalkers, nvary))\n LHC = LatinHypercube(nvary, seed=random_state)\n samples = LHC.random(n=_ntemps * nwalkers).reshape(\n _ntemps, nwalkers, nvary\n )\n\n for i, param in enumerate(self._varying_parameters):\n # bounds are not a closed interval, just jitter it.\n if (\n isinstance(param.bounds, Interval)\n and not param.bounds._closed_bounds\n ):\n vals = (\n 1 + rng.standard_normal((_ntemps, nwalkers)) * 1.0e-1\n )\n vals *= param.value\n arr[..., i] = vals\n else:\n sample_arr = samples[..., i]\n transformed = param.bounds.invcdf(sample_arr)\n arr[..., i] = transformed\n\n init_walkers = arr\n\n else:\n raise RuntimeError(\n \"Didn't use any known method for \" \"CurveFitter.initialise\"\n )\n\n # if you're not doing parallel tempering then remove the first\n # dimension\n if self._ntemps == -1:\n init_walkers = init_walkers[0]\n\n # now validate initialisation, ensuring all init pos have finite\n # logpost\n for i, param in enumerate(self._varying_parameters):\n init_walkers[..., i] = param.valid(init_walkers[..., i])\n\n rstate0 = None\n if isinstance(rng, np.random.RandomState):\n rstate0 = rng.get_state()\n\n self._state = State(init_walkers, random_state=rstate0)\n\n # finally reset the sampler to reset the chain\n # you have to do this at the end, not at the start because resetting\n # makes self.sampler.chain == None and the PTsampler creation doesn't\n # work\n self.sampler.reset()\n\n def initialise_with_chain(self, chain):\n \"\"\"\n Initialise sampler with a pre-existing chain\n\n Parameters\n ----------\n chain : array\n Array of size `(steps, ntemps, nwalkers, ndim)` or\n `(steps, nwalkers, ndim)`, containing a chain from a previous\n sampling run.\n \"\"\"\n # we should be left with (nwalkers, ndim) or (ntemp, nwalkers, ndim)\n\n if self._ntemps == -1:\n required_shape = (self._nwalkers, self.nvary)\n else:\n required_shape = (self._ntemps, self._nwalkers, self.nvary)\n\n chain_shape = chain.shape[1:]\n\n # if the shapes are the same, then we can initialise\n if required_shape == chain_shape:\n self.initialise(pos=chain[-1])\n else:\n raise ValueError(\n \"You tried to initialise with a chain, but it was\"\n \" the wrong shape\"\n )\n\n @property\n def chain(self):\n \"\"\"\n MCMC chain belonging to CurveFitter.sampler\n\n Returns\n -------\n chain : array\n The MCMC chain with shape `(steps, nwalkers, ndim)` or\n `(steps, ntemps, nwalkers, ndim)`.\n \"\"\"\n return self.sampler.get_chain()\n\n @property\n def logpost(self):\n \"\"\"\n Log-probability for each of the entries in `self.chain`\n \"\"\"\n return self.sampler.get_log_prob()\n\n @property\n def index_max_prob(self):\n \"\"\"\n The index of the highest log-probability for the samples\n \"\"\"\n log_probs = self.sampler.get_log_prob()\n if isinstance(self.sampler, PTSampler):\n log_probs = log_probs[:, 0]\n\n loc = np.argmax(log_probs)\n idx = np.unravel_index(loc, log_probs.shape)\n\n if isinstance(self.sampler, PTSampler):\n idx = list(idx)\n idx.insert(1, 0)\n return tuple(idx)\n\n return idx\n\n def reset(self):\n \"\"\"\n Reset the sampled chain.\n\n Typically used on a sampler after a burn-in period.\n \"\"\"\n self.sampler.reset()\n\n def acf(self, nburn=0, nthin=1):\n \"\"\"\n Calculate the autocorrelation function\n\n Returns\n -------\n acfs : np.ndarray\n The autocorrelation function, acfs.shape=(lags, nvary)\n \"\"\"\n return autocorrelation_chain(self.chain, nburn=nburn, nthin=nthin)\n\n def sample(\n self,\n steps,\n nthin=1,\n random_state=None,\n f=None,\n callback=None,\n verbose=True,\n pool=-1,\n ):\n \"\"\"\n Performs sampling from the objective.\n\n Parameters\n ----------\n steps : int\n Collect `steps` samples into the chain. The sampler will run a\n total of `steps * nthin` moves.\n nthin : int, optional\n Each chain sample is separated by `nthin` iterations.\n random_state : {int, `np.random.RandomState`, `np.random.Generator`}\n If `random_state` is not specified the `~np.random.RandomState`\n singleton is used.\n If `random_state` is an int, a new ``RandomState`` instance is\n used, seeded with random_state.\n If `random_state` is already a ``RandomState`` or a ``Generator``\n instance, then that object is used.\n Specify `random_state` for repeatable minimizations.\n f : file-like or str\n File to incrementally save chain progress to. Each row in the file\n is a flattened array of size `(nwalkers, ndim)` or\n `(ntemps, nwalkers, ndim)`. There are `steps` rows in the\n file.\n callback : callable\n callback function to be called at each iteration step. Has the\n signature `callback(coords, logprob)`.\n verbose : bool, optional\n Gives updates on the sampling progress\n pool : int or map-like object, optional\n If `pool` is an `int` then it specifies the number of threads to\n use for parallelization. If `pool == -1`, then all CPU's are used.\n If pool is a map-like callable that follows the same calling\n sequence as the built-in map function, then this pool is used for\n parallelisation.\n\n Notes\n -----\n Please see :class:`emcee.EnsembleSampler` for its detailed behaviour.\n\n >>> # we'll burn the first 500 steps\n >>> fitter.sample(500)\n >>> # after you've run those, then discard them by resetting the\n >>> # sampler.\n >>> fitter.sampler.reset()\n >>> # Now collect 40 steps, each step separated by 50 sampler\n >>> # generations.\n >>> fitter.sample(40, nthin=50)\n\n One can also burn and thin in `Curvefitter.process_chain`.\n \"\"\"\n self._check_vars_unchanged()\n\n # setup a random number generator\n rng = check_random_state(random_state)\n\n if self._state is None:\n self.initialise(random_state=rng)\n\n # for saving progress to file\n def _callback_wrapper(state, h=None):\n if callback is not None:\n callback(state.coords, state.log_prob)\n\n if h is not None:\n h.write(\" \".join(map(str, state.coords.ravel())))\n h.write(\"\\n\")\n\n # remove chains from each of the parameters because they slow down\n # pickling but only if they are parameter objects.\n flat_params = f_unique(flatten(self.objective.parameters))\n flat_params = [param for param in flat_params if is_parameter(param)]\n # zero out all the old parameter stderrs\n for param in flat_params:\n param.stderr = None\n param.chain = None\n\n # make sure the checkpoint file exists\n if f is not None:\n with possibly_open_file(f, \"w\") as h:\n # write the shape of each step of the chain\n h.write(\"# \")\n shape = self._state.coords.shape\n h.write(\", \".join(map(str, shape)))\n h.write(\"\\n\")\n\n # set the random state of the sampler\n # normally one could give this as an argument to the sample method\n # but PTSampler didn't historically accept that...\n if isinstance(rng, np.random.RandomState):\n rstate0 = rng.get_state()\n self._state.random_state = rstate0\n self.sampler.random_state = rstate0\n\n # using context manager means we kill off zombie pool objects\n # but does mean that the pool has to be specified each time.\n with MapWrapper(pool) as g, possibly_open_file(f, \"a\") as h:\n # these kwargs are provided to the sampler.sample method\n kwargs = {\"iterations\": steps, \"thin\": nthin}\n\n # if you're not creating more than 1 thread, then don't bother with\n # a pool.\n if isinstance(self.sampler, emcee.EnsembleSampler):\n if pool == 1:\n self.sampler.pool = None\n else:\n self.sampler.pool = g\n else:\n kwargs[\"mapper\"] = g\n\n # new emcee arguments\n sampler_args = getargspec(self.sampler.sample).args\n if \"progress\" in sampler_args and verbose:\n kwargs[\"progress\"] = True\n verbose = False\n\n if \"thin_by\" in sampler_args:\n kwargs[\"thin_by\"] = nthin\n kwargs.pop(\"thin\", 0)\n\n # perform the sampling\n for state in self.sampler.sample(self._state, **kwargs):\n self._state = state\n _callback_wrapper(state, h=h)\n\n if isinstance(self.sampler, emcee.EnsembleSampler):\n self.sampler.pool = None\n\n # sets parameter value and stderr\n return process_chain(self.objective, self.chain)\n\n def fit(self, method=\"L-BFGS-B\", target=\"nll\", verbose=True, **kws):\n \"\"\"\n Obtain the maximum log-likelihood, or log-posterior, estimate (mode)\n of the objective. Maximising the log-likelihood is equivalent to\n minimising chi2 in a least squares fit.\n\n Parameters\n ----------\n method : str\n which method to use for the optimisation. One of:\n\n - `'least_squares'`: :func:`scipy.optimize.least_squares`.\n - `'L-BFGS-B'`: L-BFGS-B.\n - `'differential_evolution'`:\n :func:`scipy.optimize.differential_evolution`\n - `'dual_annealing'`:\n :func:`scipy.optimize.dual_annealing` (SciPy >= 1.2.0)\n - `'shgo'`: :func:`scipy.optimize.shgo` (SciPy >= 1.2.0)\n\n You can also choose many of the minimizers from\n :func:`scipy.optimize.minimize`.\n\n target : {'nll', 'nlpost'}, optional\n Minimize the negative log-likelihood (`'nll'`) or the negative\n log-posterior (`'nlpost'`). This is equivalent to maximising the\n likelihood or posterior probabilities respectively.\n Maximising the likelihood is equivalent to minimising chi^2 in a\n least-squares fit.\n This option only applies to the `differential_evolution`, `shgo`,\n `dual_annealing` or `L-BFGS-B` methods.\n These optimisers require lower and upper (box) bounds for each\n parameter. If the `Bounds` on a parameter are not an `Interval`,\n but a `PDF` specifying a statistical distribution, then the lower\n and upper bounds are approximated as\n ``PDF.rv.ppf([0.005, 0.995])``, covering 99 % of the statistical\n distribution.\n verbose : bool, optional\n Gives fitting progress. To see a progress bar tqdm has to be\n installed.\n kws : dict\n Additional arguments are passed to the underlying minimization\n method.\n\n Returns\n -------\n result, covar : :class:`scipy.optimize.OptimizeResult`, np.ndarray\n `result.x` contains the best fit parameters\n `result.covar` is the covariance matrix for the fit.\n `result.stderr` is the uncertainties on each of the fit parameters.\n\n Notes\n -----\n If the `objective` supplies a `residuals` method then `least_squares`\n can be used. Otherwise the `nll` method of the `objective` is\n minimised. Use this method just before a sampling run.\n If `self.objective.parameters` is a `Parameters` instance, then each\n of the varying parameters has its value updated by the fit, and each\n `Parameter` has a `stderr` attribute which represents the uncertainty\n on the fit parameter.\n\n The use of `dual annealing` and `shgo` requires that `scipy >= 1.2.0`\n be installed.\n\n \"\"\"\n _varying_parameters = self.objective.varying_parameters()\n init_pars = np.array(_varying_parameters)\n\n _min_kws = {}\n _min_kws.update(kws)\n _bounds = bounds_list(self.objective.varying_parameters())\n _min_kws[\"bounds\"] = _bounds\n\n # setup callback default\n _min_kws.setdefault(\"callback\", None)\n\n cost = self.objective.nll\n if target == \"nlpost\":\n cost = self.objective.nlpost\n\n # a decorator for the progress bar updater\n def _callback_wrapper(callback_func, pbar):\n def callback(*args, **kwds):\n pbar.update(1)\n if callback_func is None:\n return None\n else:\n return callback_func(*args, **kwds)\n\n return callback\n\n # least_squares Trust Region Reflective by default\n if method == \"least_squares\":\n b = np.array(_bounds)\n _min_kws[\"bounds\"] = (b[..., 0], b[..., 1])\n\n # least_squares doesn't have a callback\n _min_kws.pop(\"callback\", None)\n\n res = least_squares(\n self.objective.residuals, init_pars, **_min_kws\n )\n # differential_evolution, dual_annealing, shgo require lower and upper\n # bounds\n elif method in [\"differential_evolution\", \"dual_annealing\", \"shgo\"]:\n mini = getattr(sciopt, method)\n\n if method == \"shgo\":\n if \"n\" not in _min_kws:\n _min_kws[\"n\"] = 100\n if \"iters\" not in kws:\n _min_kws[\"iters\"] = 5\n\n with get_progress_bar(verbose, None) as pbar:\n _min_kws[\"callback\"] = _callback_wrapper(\n _min_kws[\"callback\"], pbar\n )\n\n res = mini(cost, **_min_kws)\n else:\n # otherwise stick it to minimizer. Default being L-BFGS-B\n _min_kws[\"method\"] = method\n _min_kws[\"bounds\"] = _bounds\n\n with get_progress_bar(verbose, None) as pbar:\n _min_kws[\"callback\"] = _callback_wrapper(\n _min_kws[\"callback\"], pbar\n )\n\n res = minimize(cost, init_pars, **_min_kws)\n\n # OptimizeResult.success may not be present (dual annealing)\n if hasattr(res, \"success\") and res.success:\n self.objective.setp(res.x)\n\n # Covariance matrix estimation\n covar = self.objective.covar()\n errors = np.sqrt(np.diag(covar))\n res[\"covar\"] = covar\n res[\"stderr\"] = errors\n\n # check if the parameters are all Parameter instances.\n flat_params = list(f_unique(flatten(self.objective.parameters)))\n if np.all([is_parameter(param) for param in flat_params]):\n # zero out all the old parameter stderrs\n for param in flat_params:\n param.stderr = None\n param.chain = None\n\n for i, param in enumerate(_varying_parameters):\n param.stderr = errors[i]\n\n # need to touch up the output to check we leave\n # parameters as we found them\n self.objective.setp(res.x)\n\n return res\n\n\ndef load_chain(f):\n \"\"\"\n Loads a chain from disk. Does not change the state of a CurveFitter\n object.\n\n Parameters\n ----------\n f : str or file-like\n File containing the chain.\n\n Returns\n -------\n chain : array\n The loaded chain - `(nsteps, nwalkers, ndim)` or\n `(nsteps, ntemps, nwalkers, ndim)`\n \"\"\"\n with possibly_open_file(f, \"r\") as g:\n # read header\n header = g.readline()\n expr = re.compile(r\"(\\d+)\")\n matches = expr.findall(header)\n if matches:\n if len(matches) == 3:\n ntemps, nwalkers, ndim = map(int, matches)\n elif len(matches) == 2:\n ntemps = None\n nwalkers, ndim = map(int, matches)\n else:\n raise ValueError(\"Couldn't read header line of chain file\")\n\n chain = np.loadtxt(f)\n\n if ntemps is not None:\n chain = np.reshape(chain, (-1, ntemps, nwalkers, ndim))\n else:\n chain = np.reshape(chain, (-1, nwalkers, ndim))\n\n return chain\n\n\ndef process_chain(objective, chain, nburn=0, nthin=1, flatchain=False):\n \"\"\"\n Process the chain produced by a sampler for a given Objective\n\n Parameters\n ----------\n objective : refnx.analysis.Objective\n The Objective function that the Posterior was sampled for\n chain : array\n The MCMC chain\n nburn : int, optional\n discard this many steps from the start of the chain\n nthin : int, optional\n only accept every `nthin` samples from the chain\n flatchain : bool, optional\n collapse the walkers down into a single dimension.\n\n Returns\n -------\n [(param, stderr, chain)] : list\n List of (param, stderr, chain) tuples.\n If `isinstance(objective.parameters, Parameters)` then `param` is a\n `Parameter` instance. `param.value`, `param.stderr` and\n `param.chain` will contain the median, stderr and chain samples,\n respectively. Otherwise `param` will be a float representing the\n median of the chain samples.\n `stderr` is the half width of the [15.87, 84.13] spread (similar to\n standard deviation) and `chain` is an array containing the MCMC\n samples for that parameter.\n\n Notes\n -----\n The chain should have the shape `(iterations, nwalkers, nvary)` or\n `(iterations, ntemps, nwalkers, nvary)` if parallel tempering was\n employed.\n The burned and thinned chain is created via:\n `chain[nburn::nthin]`.\n Note, if parallel tempering is employed, then only the lowest temperature\n of the parallel tempering chain is processed and returned as it\n corresponds to the (lowest energy) target distribution.\n If `flatten is True` then the burned/thinned chain is reshaped and\n `arr.reshape(-1, nvary)` is returned.\n This function has the effect of setting the parameter stderr's.\n \"\"\"\n chain = chain[nburn::nthin]\n shape = chain.shape\n nvary = shape[-1]\n\n # nwalkers = shape[1]\n if len(shape) == 4:\n ntemps = shape[1]\n elif len(shape) == 3:\n ntemps = -1\n\n if ntemps != -1:\n # PTSampler, we require the target distribution in the first row.\n chain = chain[:, 0]\n\n _flatchain = chain.reshape((-1, nvary))\n if flatchain:\n chain = _flatchain\n\n flat_params = list(f_unique(flatten(objective.parameters)))\n varying_parameters = objective.varying_parameters()\n\n # set the stderr of each of the Parameters\n result_list = []\n if np.all([is_parameter(param) for param in flat_params]):\n # zero out all the old parameter stderrs\n for param in flat_params:\n param.stderr = None\n param.chain = None\n\n # do the error calcn for the varying parameters and set the chain\n quantiles = np.percentile(_flatchain, [15.87, 50, 84.13], axis=0)\n for i, param in enumerate(varying_parameters):\n std_l, median, std_u = quantiles[:, i]\n param.value = median\n param.stderr = 0.5 * (std_u - std_l)\n\n # copy in the chain\n param.chain = np.copy(chain[..., i])\n res = MCMCResult(\n name=param.name,\n param=param,\n median=param.value,\n stderr=param.stderr,\n chain=param.chain,\n )\n result_list.append(res)\n\n fitted_values = np.array(varying_parameters)\n\n # give each constrained param a chain (to be reshaped later)\n constrained_params = [\n param for param in flat_params if param.constraint is not None\n ]\n\n for constrain_param in constrained_params:\n constrain_param.chain = np.empty(chain.shape[:-1], float)\n\n # now iterate through the varying parameters, set the values, thereby\n # setting the constraint value\n if len(constrained_params):\n for index in np.ndindex(chain.shape[:-1]):\n # iterate over parameter vectors\n pvals = chain[index]\n objective.setp(pvals)\n\n for constrain_param in constrained_params:\n constrain_param.chain[index] = constrain_param.value\n\n for constrain_param in constrained_params:\n quantiles = np.percentile(\n constrain_param.chain, [15.87, 50, 84.13]\n )\n\n std_l, median, std_u = quantiles\n constrain_param.value = median\n constrain_param.stderr = 0.5 * (std_u - std_l)\n\n # now reset fitted parameter values (they would've been changed by\n # constraints calculations\n objective.setp(fitted_values)\n\n # the parameter set are not Parameter objects, an array was probably\n # being used with BaseObjective.\n else:\n for i in range(nvary):\n c = np.copy(chain[..., i])\n median, stderr = uncertainty_from_chain(c)\n res = MCMCResult(\n name=\"\", param=median, median=median, stderr=stderr, chain=c\n )\n result_list.append(res)\n\n return result_list\n\n\ndef uncertainty_from_chain(chain):\n \"\"\"\n Calculates the median and uncertainty of MC samples.\n\n Parameters\n ----------\n chain : array-like\n\n Returns\n -------\n median, stderr : float, float\n `median` of the chain samples. `stderr` is half the width of the\n [15.87, 84.13] spread.\n \"\"\"\n flatchain = chain.flatten()\n std_l, median, std_u = np.percentile(flatchain, [15.87, 50, 84.13])\n return median, 0.5 * (std_u - std_l)\n\n\ndef autocorrelation_chain(chain, nburn=0, nthin=1):\n \"\"\"\n Calculate the autocorrelation function\n\n Parameters\n ----------\n chain : np.ndarray\n The MCMC chain - `(nsteps, nwalkers, ndim)` or\n `(nsteps, ntemps, nwalkers, ndim)`\n\n Returns\n -------\n acfs : np.ndarray\n The autocorrelation function, acfs.shape=(lags, nvary)\n \"\"\"\n lchain = chain\n # parallel tempered chain\n if len(chain.shape) == 4:\n lchain = lchain[:, 0]\n\n lchain = lchain[nburn::nthin]\n # (iterations, walkers, vary) -> (vary, walkers, iterations)\n lchain = np.swapaxes(lchain, 0, 2)\n shape = lchain.shape[:-1]\n\n acfs = np.zeros_like(lchain)\n\n # iterate over each parameter/walker\n for index in np.ndindex(*shape):\n s = _function_1d(lchain[index])\n acfs[index] = s\n\n # now average over walkers\n acfs = np.mean(acfs, axis=1)\n return np.transpose(acfs)\n\n\ndef bounds_list(parameters):\n \"\"\"\n Approximates interval bounds for a parameter set.\n\n Parameters\n ----------\n parameters : sequence\n A sequence containing individual parameters\n\n Returns\n -------\n bounds: tuple\n ``(min, max)`` pairs that define the finite lower and upper bounds\n every element in ``parameters``.\n\n If the `Bounds` applied by a parameter are a `PDF` instance then the upper\n and lower bound are approximated by ``PDF.rv.ppf([0.005, 0.995])``, which\n covers 99% of the statistical distribution.\n \"\"\"\n bounds = []\n for param in parameters:\n if hasattr(param, \"bounds\") and isinstance(param.bounds, Interval):\n bnd = param.bounds\n bounds.append((bnd.lb, bnd.ub))\n elif (\n hasattr(param, \"bounds\")\n and isinstance(param.bounds, PDF)\n and hasattr(param.bounds.rv, \"ppf\")\n ):\n bounds.append(param.bounds.rv.ppf([0.005, 0.995]))\n else:\n # We can't handle this bound\n bounds.append((-np.inf, np.inf))\n\n return bounds\n\n\n# Following code is for autocorrelation analysis of chains and is taken from\n# emcee.autocorr\ndef _next_pow_two(n):\n \"\"\"Returns the next power of two greater than or equal to `n`\"\"\"\n i = 1\n while i < n:\n i = i << 1\n return i\n\n\ndef _function_1d(x):\n \"\"\"Estimate the normalized autocorrelation function of a 1-D series\n\n Args:\n x: The series as a 1-D numpy array.\n\n Returns:\n array: The autocorrelation function of the time series.\n\n \"\"\"\n x = np.atleast_1d(x)\n if len(x.shape) != 1:\n raise ValueError(\"invalid dimensions for 1D autocorrelation function\")\n n = _next_pow_two(len(x))\n\n # Compute the FFT and then (from that) the auto-correlation function\n f = np.fft.fft(x - np.mean(x), n=2 * n)\n acf = np.fft.ifft(f * np.conjugate(f))[: len(x)].real\n acf /= acf[0]\n return acf\n", "meta": {"hexsha": "e3e65299fd41406d97fa3068a6272543098ca697", "size": 39411, "ext": "py", "lang": "Python", "max_stars_repo_path": "refnx/analysis/curvefitter.py", "max_stars_repo_name": "dcortie/refnx", "max_stars_repo_head_hexsha": "037434fa0a64755f72c540d75063986bd517ab10", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 32, "max_stars_repo_stars_event_min_datetime": "2016-04-18T15:29:59.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-27T08:35:29.000Z", "max_issues_repo_path": "refnx/analysis/curvefitter.py", "max_issues_repo_name": "dcortie/refnx", "max_issues_repo_head_hexsha": "037434fa0a64755f72c540d75063986bd517ab10", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 116, "max_issues_repo_issues_event_min_datetime": "2015-10-27T04:33:09.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-22T02:02:47.000Z", "max_forks_repo_path": "refnx/analysis/curvefitter.py", "max_forks_repo_name": "dcortie/refnx", "max_forks_repo_head_hexsha": "037434fa0a64755f72c540d75063986bd517ab10", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 22, "max_forks_repo_forks_event_min_datetime": "2015-09-29T23:21:15.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-27T18:12:18.000Z", "avg_line_length": 34.3002610966, "max_line_length": 79, "alphanum_fraction": 0.58420238, "include": true, "reason": "import numpy,import scipy,from scipy", "num_tokens": 9098, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5621764862150634, "lm_q2_score": 0.3451052574867685, "lm_q1q2_score": 0.19401006102825624}} {"text": "\"\"\"\nCreated on 01 Apr 2021 21:40:47\n@author: jiahuei\n\"\"\"\nimport logging\nimport numpy as np\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torch import Tensor\nfrom argparse import ArgumentParser, _ArgumentGroup\nfrom typing import Optional, Union, Dict\nfrom copy import deepcopy\nfrom models import register_model\nfrom models.transformer import (\n CachedMultiHeadedAttention, MultiHeadedAttention, PositionwiseFeedForward, PositionalEncoding,\n InputEmbedding as Embeddings, OutputEmbedding as Generator,\n LayerNorm, SublayerConnection,\n Decoder, DecoderLayer, CachedTransformerBase\n)\nfrom data.collate import ObjectRelationCollate\nfrom utils.model_utils import repeat_tensors, pack_wrapper, clones\nfrom utils.misc import str_to_bool\n\nlogger = logging.getLogger(__name__)\n\n\n# noinspection PyAbstractClass\nclass EncoderComputerDecoder(nn.Module):\n \"\"\"\n A standard Encoder-Decoder architecture. Base for this and many\n other models.\n \"\"\"\n\n def __init__(self, encoder, computer, decoder, src_embed, tgt_embed, generator):\n super().__init__()\n self.encoder = encoder\n self.computer = computer\n self.decoder = decoder\n self.src_embed = src_embed\n self.tgt_embed = tgt_embed\n self.generator = generator\n\n def forward(self, src, boxes, tgt, src_mask, tgt_mask):\n \"\"\"Take in and process masked src and target sequences.\"\"\"\n enc_out = self.encode(src, boxes, src_mask)\n assert enc_out.size(0) == src_mask.size(0)\n if logger.isEnabledFor(logging.DEBUG):\n logger.debug(\n f\"{self.__class__.__name__}: \"\n f\"Encoder output shape = `{enc_out.shape}` \"\n f\"Target shape = `{tgt.shape}`\"\n )\n com_out = self.compute(enc_out, src_mask)\n if com_out.size(0) != tgt.size(0):\n assert tgt.size(0) % com_out.size(0) == 0\n seq_per_img = int(tgt.size(0) / com_out.size(0))\n com_out = repeat_tensors(seq_per_img, com_out)\n return self.decode(com_out, None, tgt, tgt_mask), com_out\n\n def encode(self, src, boxes, src_mask):\n return self.encoder(self.src_embed(src), boxes, src_mask)\n\n def compute(self, memory, src_mask):\n return self.computer(memory, src_mask)\n\n def decode(self, memory, src_mask, tgt, tgt_mask):\n return self.decoder(self.tgt_embed(tgt), memory, src_mask, tgt_mask)\n\n\n# noinspection PyAbstractClass\nclass Computer(nn.Module):\n \"\"\"Generic N layer decoder with masking.\"\"\"\n\n def __init__(self, layer, N):\n super().__init__()\n self.inputs = nn.Parameter(torch.Tensor(1, 5, layer.size))\n self.layers = clones(layer, N)\n self.norm = LayerNorm(layer.size)\n\n def forward(self, memory, src_mask):\n x = self.inputs\n x = repeat_tensors(memory.size(0), x)\n for layer in self.layers:\n x = layer(x, memory, src_mask)\n return self.norm(x)\n\n\n# noinspection PyAbstractClass\nclass ComputerLayer(nn.Module):\n \"\"\"Decoder is made of self-attn, src-attn, and feed forward (defined below)\"\"\"\n\n def __init__(self, size, self_attn, src_attn, feed_forward, dropout):\n super().__init__()\n self.size = size\n self.self_attn = self_attn\n self.src_attn = src_attn\n self.feed_forward = feed_forward\n self.sublayer = clones(SublayerConnection(size, dropout), 3)\n\n def forward(self, x, memory, src_mask):\n \"\"\"Follow Figure 1 (right) for connections.\"\"\"\n m = memory\n x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x))\n x = self.sublayer[1](x, lambda x: self.src_attn(x, m, m, src_mask))\n return self.sublayer[2](x, self.feed_forward)\n\n\n# noinspection PyAbstractClass\nclass Encoder(nn.Module):\n \"\"\"Core encoder is a stack of N layers\"\"\"\n\n def __init__(self, layer, N):\n super().__init__()\n self.layers = clones(layer, N)\n self.norm = LayerNorm(layer.size)\n\n def forward(self, x, box, mask):\n \"\"\"Pass the input (and mask) through each layer in turn.\"\"\"\n for layer in self.layers:\n x = layer(x, box, mask)\n return self.norm(x)\n\n\n# noinspection PyAbstractClass\nclass EncoderLayer(nn.Module):\n \"\"\"Encoder is made up of self-attn and feed forward (defined below)\"\"\"\n\n def __init__(self, size, self_attn, feed_forward, dropout):\n super().__init__()\n self.self_attn = self_attn\n self.feed_forward = feed_forward\n self.sublayer = clones(SublayerConnection(size, dropout), 2)\n self.size = size\n\n def forward(self, x, box, mask):\n \"\"\"Follow Figure 1 (left) for connections.\"\"\"\n x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, box, mask))\n return self.sublayer[1](x, self.feed_forward)\n\n\n# noinspection PyAbstractClass\nclass BoxMultiHeadedAttention(nn.Module):\n \"\"\"\n Self-attention layer with relative position weights.\n Following the paper \"Relation Networks for Object Detection\" in https://arxiv.org/pdf/1711.11575.pdf\n \"\"\"\n\n def __init__(self, h, d_model, trigonometric_embedding=True, dropout=0.1):\n \"\"\"Take in model size and number of heads.\"\"\"\n super().__init__()\n\n assert d_model % h == 0\n self.trigonometric_embedding = trigonometric_embedding\n\n # We assume d_v always equals d_k\n self.h = h\n self.d_k = d_model // h\n if self.trigonometric_embedding:\n self.dim_g = 64\n else:\n self.dim_g = 4\n geo_feature_dim = self.dim_g\n\n # matrices W_q, W_k, W_v, and one last projection layer\n self.linears = clones(nn.Linear(d_model, d_model), 4)\n self.WGs = clones(nn.Linear(geo_feature_dim, 1, bias=True), 8)\n\n # self.attn = None\n self.dropout = nn.Dropout(p=dropout)\n\n def forward(self, input_query, input_key, input_value, input_box, mask=None):\n \"\"\"Implements Figure 2 of Relation Network for Object Detection\"\"\"\n if mask is not None:\n # Same mask applied to all h heads.\n mask = mask.unsqueeze(1)\n nbatches = input_query.size(0)\n\n # tensor with entries R_mn given by a hardcoded embedding of the relative position between bbox_m and bbox_n\n relative_geometry_embeddings = self.BoxRelationalEmbedding(\n input_box,\n trigonometric_embedding=self.trigonometric_embedding\n )\n flatten_relative_geometry_embeddings = relative_geometry_embeddings.view(-1, self.dim_g)\n\n # 1) Do all the linear projections in batch from d_model => h x d_k\n query, key, value = [\n l(x).view(nbatches, -1, self.h, self.d_k).transpose(1, 2)\n for l, x in zip(self.linears, (input_query, input_key, input_value))\n ]\n box_size_per_head = list(relative_geometry_embeddings.shape[:3])\n box_size_per_head.insert(1, 1)\n relative_geometry_weights_per_head = [\n ly(flatten_relative_geometry_embeddings).view(box_size_per_head) for ly in self.WGs\n ]\n relative_geometry_weights = torch.cat(relative_geometry_weights_per_head, 1)\n relative_geometry_weights = F.relu(relative_geometry_weights)\n\n # 2) Apply attention on all the projected vectors in batch.\n x, box_attn = self.box_attention(\n query, key, value, relative_geometry_weights, mask=mask, dropout=self.dropout\n )\n\n # 3) \"Concat\" using a view and apply a final linear.\n x = x.transpose(1, 2).contiguous().view(nbatches, -1, self.h * self.d_k)\n\n # # Legacy\n # x = input_value + x\n\n return self.linears[-1](x)\n\n @staticmethod\n def BoxRelationalEmbedding(f_g, dim_g=64, wave_len=1000, trigonometric_embedding=True):\n \"\"\"\n Given a tensor with bbox coordinates for detected objects on each batch image,\n this function computes a matrix for each image\n\n with entry (i,j) given by a vector representation of the\n displacement between the coordinates of bbox_i, and bbox_j\n\n input: np.array of shape=(batch_size, max_nr_bounding_boxes, 4)\n output: np.array of shape=(batch_size, max_nr_bounding_boxes, max_nr_bounding_boxes, 64)\n \"\"\"\n # returns a relational embedding for each pair of bboxes, with dimension = dim_g\n # follow implementation of https://github.com/heefe92/Relation_Networks-pytorch/blob/master/model.py#L1014-L1055\n\n batch_size = f_g.size(0)\n\n x_min, y_min, x_max, y_max = torch.chunk(f_g, 4, dim=-1)\n\n cx = (x_min + x_max) * 0.5\n cy = (y_min + y_max) * 0.5\n w = (x_max - x_min) + 1.\n h = (y_max - y_min) + 1.\n\n # cx.view(1,-1) transposes the vector cx, and so dim(delta_x) = (dim(cx), dim(cx))\n delta_x = cx - cx.view(batch_size, 1, -1)\n delta_x = torch.clamp(torch.abs(delta_x / w), min=1e-3)\n delta_x = torch.log(delta_x)\n\n delta_y = cy - cy.view(batch_size, 1, -1)\n delta_y = torch.clamp(torch.abs(delta_y / h), min=1e-3)\n delta_y = torch.log(delta_y)\n\n delta_w = torch.log(w / w.view(batch_size, 1, -1))\n delta_h = torch.log(h / h.view(batch_size, 1, -1))\n\n matrix_size = delta_h.size()\n delta_x = delta_x.view(batch_size, matrix_size[1], matrix_size[2], 1)\n delta_y = delta_y.view(batch_size, matrix_size[1], matrix_size[2], 1)\n delta_w = delta_w.view(batch_size, matrix_size[1], matrix_size[2], 1)\n delta_h = delta_h.view(batch_size, matrix_size[1], matrix_size[2], 1)\n\n position_mat = torch.cat((delta_x, delta_y, delta_w, delta_h), -1)\n\n if trigonometric_embedding:\n feat_range = torch.arange(dim_g / 8, device=f_g.device)\n dim_mat = feat_range / (dim_g / 8)\n dim_mat = 1. / (torch.pow(wave_len, dim_mat))\n\n dim_mat = dim_mat.view(1, 1, 1, -1)\n position_mat = position_mat.view(batch_size, matrix_size[1], matrix_size[2], 4, -1)\n position_mat = 100. * position_mat\n\n mul_mat = position_mat * dim_mat\n mul_mat = mul_mat.view(batch_size, matrix_size[1], matrix_size[2], -1)\n sin_mat = torch.sin(mul_mat)\n cos_mat = torch.cos(mul_mat)\n embedding = torch.cat((sin_mat, cos_mat), -1)\n else:\n embedding = position_mat\n return embedding\n\n @staticmethod\n def box_attention(query, key, value, box_relation_embds_matrix, mask=None, dropout=None):\n \"\"\"\n Compute 'Scaled Dot Product Attention as in paper Relation Networks for Object Detection'.\n Follow the implementation in\n https://github.com/heefe92/Relation_Networks-pytorch/blob/master/model.py#L1026-L1055\n \"\"\"\n\n N = value.size()[:2]\n dim_k = key.size(-1)\n dim_g = box_relation_embds_matrix.size()[-1]\n\n w_q = query\n w_k = key.transpose(-2, -1)\n w_v = value\n\n # attention weights\n scaled_dot = torch.matmul(w_q, w_k)\n scaled_dot = scaled_dot / np.sqrt(dim_k)\n if mask is not None:\n scaled_dot = scaled_dot.masked_fill(mask == 0, -1e9)\n\n # w_g = box_relation_embds_matrix.view(N,N)\n w_g = box_relation_embds_matrix\n w_a = scaled_dot\n # w_a = scaled_dot.view(N,N)\n\n # multiplying log of geometric weights by feature weights\n w_mn = torch.log(torch.clamp(w_g, min=1e-6)) + w_a\n w_mn = torch.nn.Softmax(dim=-1)(w_mn)\n if dropout is not None:\n w_mn = dropout(w_mn)\n\n output = torch.matmul(w_mn, w_v)\n\n return output, w_mn\n\n\n# noinspection PyAbstractClass,PyAttributeOutsideInit\n@register_model(\"ort_computer\")\nclass ORTComputerModel(CachedTransformerBase):\n COLLATE_FN = ObjectRelationCollate\n\n def __init__(self, config):\n super().__init__(config)\n self.box_trigonometric_embedding = True\n self.make_model()\n\n def make_model(self, h=8, dropout=0.1):\n \"\"\"Helper: Construct a model from hyperparameters.\"\"\"\n bbox_attn = BoxMultiHeadedAttention(h, self.d_model, self.box_trigonometric_embedding)\n attn = CachedMultiHeadedAttention(h, self.d_model)\n self_attn = deepcopy(attn)\n self_attn.self_attention = True\n ff = PositionwiseFeedForward(self.d_model, self.dim_feedforward, dropout)\n position = PositionalEncoding(self.d_model, dropout)\n model = EncoderComputerDecoder(\n Encoder(EncoderLayer(\n self.d_model, deepcopy(bbox_attn), deepcopy(ff), dropout), self.num_layers\n ),\n Computer(ComputerLayer(\n self.d_model, MultiHeadedAttention(h, self.d_model), MultiHeadedAttention(h, self.d_model),\n deepcopy(ff), dropout), self.num_layers\n ),\n Decoder(DecoderLayer(\n self.d_model, self_attn, attn, deepcopy(ff), dropout), self.num_layers\n ),\n lambda x: x, # nn.Sequential(Embeddings(self.d_model, src_vocab), deepcopy(position)),\n nn.Sequential(Embeddings(self.d_model, self.vocab_size), deepcopy(position)),\n Generator(self.d_model, self.vocab_size)\n )\n self.att_embed = nn.Sequential(\n nn.Linear(self.att_feat_size, self.d_model),\n nn.ReLU(),\n nn.Dropout(self.drop_prob_src)\n )\n # This was important from their code.\n # Initialize parameters with Glorot / fan_avg.\n for p in model.parameters():\n if p.dim() > 1:\n nn.init.xavier_uniform_(p)\n self.model = model\n\n def _prepare_feature(\n self,\n att_feats: Tensor,\n att_masks: Optional[Tensor] = None,\n boxes: Optional[Tensor] = None,\n seq: Optional[Tensor] = None\n ):\n\n att_feats, att_masks = self.clip_att(att_feats, att_masks)\n att_feats = pack_wrapper(self.att_embed, att_feats, att_masks)\n\n if att_masks is None:\n att_masks = att_feats.new_ones(att_feats.shape[:2], dtype=torch.long)\n att_masks = att_masks.unsqueeze(-2)\n\n if seq is not None:\n # crop the last one\n seq = seq[:, :-1]\n seq_mask = seq.data.ne(self.pad_idx) # seq_mask: torch.Tensor\n seq_mask = seq_mask.unsqueeze(-2)\n seq_mask = seq_mask & self.subsequent_mask(seq.size(-1)).to(seq_mask)\n else:\n seq_mask = None\n\n return att_feats, boxes, seq, att_masks, seq_mask\n\n # noinspection PyMethodOverriding\n def _forward(self, att_feats, boxes, seqs, att_masks=None, **kwargs):\n att_feats, boxes, seq, att_masks, seq_mask = self._prepare_feature(att_feats, att_masks, boxes, seqs)\n out = self.model(att_feats, boxes, seq, att_masks, seq_mask)\n outputs = self.model.generator(out[0])\n return outputs #, self.model.generator(out[1])\n\n def get_logprobs_state(self, it, memory, mask, state):\n \"\"\"\n state = [ys.unsqueeze(0)]\n \"\"\"\n ys = it.unsqueeze(1)\n if state is None:\n pass\n else:\n # Retrieve reordered cache from state, and update them\n self._update_caches(state[1:])\n out = self.model.decode(\n memory, mask, ys, self.subsequent_mask(ys.size(1)).to(memory.device)\n )\n logprobs = self.model.generator(out[:, -1])\n # Add layer cache into state list, transposed so that beam_step can reorder them\n return logprobs, [ys.unsqueeze(0)] + self._retrieve_caches()\n\n # noinspection PyMethodOverriding\n def _sample(self, att_feats, boxes, att_masks=None, opt=None, **kwargs):\n if opt is None:\n opt = {}\n att_feats, boxes, seq, att_masks, seq_mask = self._prepare_feature(att_feats, att_masks, boxes)\n memory = self.model.encode(att_feats, boxes, att_masks)\n memory = self.model.compute(memory, att_masks)\n state = None\n mask = torch.ones(size=(memory.size(0), 1, memory.size(1)), dtype=memory.dtype, device=memory.device)\n return self._generate_captions(att_feats, mask, memory, state, opt)\n\n @staticmethod\n def clip_att(att_feats, att_masks):\n # Clip the length of att_masks and att_feats to the maximum length\n if att_masks is not None:\n max_len = att_masks.data.long().sum(1).max()\n att_feats = att_feats[:, :max_len].contiguous()\n att_masks = att_masks[:, :max_len].contiguous()\n return att_feats, att_masks\n\n @staticmethod\n def subsequent_mask(size):\n \"\"\"Mask out subsequent positions.\"\"\"\n attn_shape = (1, size, size)\n mask = torch.triu(torch.ones(attn_shape), diagonal=1).eq(0)\n return mask\n\n @staticmethod\n def add_argparse_args(parser: Union[_ArgumentGroup, ArgumentParser]):\n # fmt: off\n ORTComputerModel.COLLATE_FN.add_argparse_args(parser)\n CachedTransformerBase.add_argparse_args(parser)\n # Relation args\n parser.add_argument(\n \"--box_trigonometric_embedding\", type=str_to_bool,\n default=True\n )\n # fmt: on\n # return parser\n", "meta": {"hexsha": "bcb0596931eb4492e1f7fcdcb3dddec8f8c7061d", "size": 17159, "ext": "py", "lang": "Python", "max_stars_repo_path": "caption_vae/models/relation_transformer_computer.py", "max_stars_repo_name": "jiahuei/test-caption-actions", "max_stars_repo_head_hexsha": "cbf68dc29a0fdafe92730bf4881319bcbd41eb7f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-01-24T00:28:40.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-04T12:34:07.000Z", "max_issues_repo_path": "caption_vae/models/relation_transformer_computer.py", "max_issues_repo_name": "jiahuei/test-caption-actions", "max_issues_repo_head_hexsha": "cbf68dc29a0fdafe92730bf4881319bcbd41eb7f", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "caption_vae/models/relation_transformer_computer.py", "max_forks_repo_name": "jiahuei/test-caption-actions", "max_forks_repo_head_hexsha": "cbf68dc29a0fdafe92730bf4881319bcbd41eb7f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.4730941704, "max_line_length": 120, "alphanum_fraction": 0.6374497348, "include": true, "reason": "import numpy", "num_tokens": 4176, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5039061705290806, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.1939596047170351}} {"text": "import sys\nimport os\nimport ctypes\nimport glob\nimport warnings\nimport numpy as np\nfrom math import fsum, sqrt\n\nimport MulensModel\nfrom MulensModel.utils import Utils\ntry:\n import MulensModel.VBBL as mm_vbbl\nexcept Exception:\n _vbbl_wrapped = False\nelse:\n _vbbl_wrapped = True\ntry:\n import MulensModel.AdaptiveContouring as mm_ac\nexcept Exception:\n _adaptive_contouring_wrapped = False\nelse:\n _adaptive_contouring_wrapped = True\n\n\ndef _try_load(path, name):\n \"\"\"\n Try loading compiled C library.\n Input is *str* or *list* of *str*.\n \"\"\"\n if isinstance(path, str):\n path = [path]\n for path_ in path:\n try:\n out = ctypes.cdll.LoadLibrary(path_)\n except OSError:\n print(\"WARNING - File not loaded:\", path_)\n print(\"Everything should work except:\", name)\n pass\n else:\n return out\n return None\n\n\ndef _get_path_2(name_1, name_2):\n \"\"\"convenience function\"\"\"\n module_path = os.path.abspath(__file__)\n for i in range(3):\n module_path = os.path.dirname(module_path)\n return os.path.join(module_path, 'source', name_1, name_2)\n\n\ndef _import_compiled_VBBL():\n \"\"\"try importing manually compiled VBBL package\"\"\"\n vbbl = _try_load(\n _get_path_2('VBBL', \"VBBinaryLensingLibrary_wrapper.so\"), \"VBBL\")\n _vbbl_wrapped = (vbbl is not None)\n if not _vbbl_wrapped:\n return (_vbbl_wrapped, None, None)\n\n vbbl.VBBinaryLensing_BinaryMagDark.argtypes = 7 * [ctypes.c_double]\n vbbl.VBBinaryLensing_BinaryMagDark.restype = ctypes.c_double\n\n vbbl.VBBL_SG12_5.argtypes = 12 * [ctypes.c_double]\n vbbl.VBBL_SG12_5.restype = np.ctypeslib.ndpointer(\n dtype=ctypes.c_double, shape=(10,))\n\n return (_vbbl_wrapped,\n vbbl.VBBinaryLensing_BinaryMagDark, vbbl.VBBL_SG12_5)\n\n\ndef _import_compiled_AdaptiveContouring():\n \"\"\"try importing manually compiled AdaptiveContouring package\"\"\"\n ac = \"AdaptiveContouring\"\n adaptive_contour = _try_load(_get_path_2(ac, ac + \"_wrapper.so\"), ac)\n _adaptive_contouring_wrapped = (adaptive_contour is not None)\n if not _adaptive_contouring_wrapped:\n return (_adaptive_contouring_wrapped, None)\n adaptive_contour.Adaptive_Contouring_Linear.argtypes = (\n 8 * [ctypes.c_double])\n adaptive_contour.Adaptive_Contouring_Linear.restype = ctypes.c_double\n return (_adaptive_contouring_wrapped,\n adaptive_contour.Adaptive_Contouring_Linear)\n\n\n# Check import and try manually compiled versions.\nif _vbbl_wrapped:\n _vbbl_binary_mag_dark = mm_vbbl.VBBinaryLensing_BinaryMagDark\n _vbbl_SG12_5 = mm_vbbl.VBBL_SG12_5\nelse:\n out = _import_compiled_VBBL()\n _vbbl_wrapped = out[0]\n _vbbl_binary_mag_dark = out[1]\n _vbbl_SG12_5 = out[2]\nif not _vbbl_wrapped:\n _solver = 'numpy'\nelse:\n _solver = 'Skowron_and_Gould_12'\nif _adaptive_contouring_wrapped:\n _adaptive_contouring_linear = mm_ac.Adaptive_Contouring_Linear\nelse:\n out = _import_compiled_AdaptiveContouring()\n _adaptive_contouring_wrapped = out[0]\n _adaptive_contouring_linear = out[1]\n\n\nclass BinaryLens(object):\n \"\"\"\n The binary lens equation - its solutions, images, parities,\n magnifications, etc.\n\n The binary lens equation is a 5th order complex polynomial.\n\n Attributes :\n mass_1: *float*\n mass of the primary (left-hand object) as a fraction of\n the total mass.\n\n mass_2: *float*\n mass of the secondary (right-hand object) as a fraction of the\n total mass.\n\n separation: *float*\n separation between the two bodies as a fraction of the Einstein\n ring.\n\n Note: mass_1 and mass_2 may be defined as a fraction of some other\n mass than the total mass. This is possible but not recommended -\n make sure you know what you're doing before you start using this\n possibility.\n\n \"\"\"\n def __init__(self, mass_1=None, mass_2=None, separation=None):\n self.mass_1 = float(mass_1) # This speeds-up code for np.float input.\n self.mass_2 = float(mass_2)\n self.separation = float(separation)\n self._total_mass = None\n self._mass_difference = None\n self._position_z1 = None\n self._position_z2 = None\n self._last_polynomial_input = None\n self._solver = _solver\n self._use_planet_frame = True\n\n def _calculate_variables(self, source_x, source_y):\n \"\"\"calculates values of constants needed for polynomial coefficients\"\"\"\n self._total_mass = 0.5 * (self.mass_1 + self.mass_2)\n # This is total_mass in WM95 paper.\n\n self._mass_difference = 0.5 * (self.mass_2 - self.mass_1)\n self._zeta = source_x + source_y * 1.j\n if self._use_planet_frame:\n self._position_z1 = -self.separation + 0.j\n self._position_z2 = 0. + 0.j\n else:\n self._position_z1 = -0.5 * self.separation + 0.j\n self._position_z2 = 0.5 * self.separation + 0.j\n\n def _get_polynomial(self, source_x, source_y):\n \"\"\"get polynomial coefficients\"\"\"\n if self._use_planet_frame:\n return self._get_polynomial_planet_frame(source_x, source_y)\n else:\n return self._get_polynomial_WM95(source_x, source_y)\n\n def _get_polynomial_WM95(self, source_x, source_y):\n \"\"\"\n calculate coefficients of the polynomial in geometric center frame\n \"\"\"\n # Calculate constants\n self._calculate_variables(source_x=source_x, source_y=source_y)\n total_m = self._total_mass\n total_m_pow2 = total_m * total_m\n\n m_diff = self._mass_difference\n m_diff_pow2 = m_diff * m_diff\n\n pos_z1 = self._position_z1\n\n z1_pow2 = pos_z1 * pos_z1\n z1_pow3 = z1_pow2 * pos_z1\n z1_pow4 = z1_pow2 * z1_pow2\n\n zeta = self._zeta\n zeta_conj = zeta.conjugate()\n zeta_conj_pow2 = zeta_conj * zeta_conj\n\n # Calculate the coefficients of the 5th order complex polynomial\n coeff_5 = Utils.complex_fsum([z1_pow2, -zeta_conj_pow2])\n coeff_4 = Utils.complex_fsum(\n [-2. * total_m * zeta_conj,\n zeta * zeta_conj_pow2, -2. * m_diff * pos_z1,\n -zeta * z1_pow2])\n coeff_3 = Utils.complex_fsum(\n [4. * total_m * zeta * zeta_conj,\n 4. * m_diff * zeta_conj * pos_z1,\n 2. * zeta_conj_pow2 * z1_pow2, -2. * z1_pow4])\n coeff_2 = Utils.complex_fsum(\n [4. * total_m_pow2 * zeta,\n 4. * total_m * m_diff * pos_z1,\n -4. * m_diff * zeta * zeta_conj * pos_z1,\n -2. * zeta * zeta_conj_pow2 * z1_pow2,\n 4. * m_diff * z1_pow3, 2. * zeta * z1_pow4])\n coeff_1 = Utils.complex_fsum(\n [-8. * total_m * m_diff * zeta * pos_z1,\n -4. * m_diff_pow2 * z1_pow2,\n -4. * total_m_pow2 * z1_pow2,\n -4. * total_m * zeta * zeta_conj * z1_pow2,\n -4. * m_diff * zeta_conj * z1_pow3,\n -zeta_conj_pow2 * z1_pow4, z1_pow3 * z1_pow3])\n coeff_0 = Utils.complex_fsum(\n [4. * m_diff_pow2 * zeta,\n 4. * total_m * m_diff * pos_z1,\n 4. * m_diff * zeta * zeta_conj * pos_z1,\n 2. * total_m * zeta_conj * z1_pow2,\n zeta * zeta_conj_pow2 * z1_pow2,\n -2. * m_diff * z1_pow3 - zeta * z1_pow4])\n coeff_0 *= z1_pow2\n\n # Return the coefficients of the polynomial\n coeffs_list = [coeff_0, coeff_1, coeff_2, coeff_3, coeff_4, coeff_5]\n return np.array(coeffs_list).reshape(6)\n\n def _get_polynomial_planet_frame(self, source_x, source_y):\n \"\"\"calculate coefficients of the polynomial in planet frame\"\"\"\n # Calculate constants\n self._calculate_variables(source_x=source_x, source_y=source_y)\n total_m = self._total_mass\n\n m_diff = self._mass_difference\n\n zeta = self._zeta\n zeta_conj = zeta.conjugate()\n\n c_sum = Utils.complex_fsum\n\n z1 = self._position_z1\n\n coeff_5 = c_sum([z1, -zeta_conj]) * zeta_conj\n coeff_4 = c_sum([\n (-m_diff + total_m) * z1,\n -c_sum([2. * total_m, z1 * c_sum([2. * z1, zeta])]) * zeta_conj,\n c_sum([2. * z1 + zeta]) * zeta_conj**2\n ])\n coeff_3 = c_sum([\n z1 * c_sum([m_diff * z1, -total_m * c_sum([z1, 2. * zeta])]),\n zeta_conj * c_sum([\n 2. * m_diff * z1,\n c_sum([2. * total_m, z1**2]) * c_sum([z1, 2. * zeta])\n ]),\n -z1 * c_sum([z1, 2. * zeta]) * zeta_conj**2\n ])\n coeff_2 = c_sum([\n m_diff * z1 * c_sum([2. * total_m, z1 * zeta]),\n total_m * c_sum([\n -2. * total_m * z1, 4. * total_m * zeta, 3. * z1**2 * zeta]),\n -z1 * zeta_conj * c_sum([\n zeta * c_sum([6. * total_m, z1**2]),\n 2. * m_diff * c_sum([z1, zeta])\n ]),\n z1**2 * zeta * zeta_conj**2\n ])\n coeff_1 = -z1 * (m_diff + total_m) * c_sum([\n m_diff * z1, -total_m * z1, 4. * total_m * zeta, z1**2 * zeta,\n -2. * z1 * zeta * zeta_conj\n ])\n coeff_0 = (m_diff + total_m)**2 * z1**2 * zeta\n\n coeffs_list = [coeff_0, coeff_1, coeff_2, coeff_3, coeff_4, coeff_5]\n return np.array(coeffs_list).reshape(6)\n\n def _get_polynomial_roots(self, source_x, source_y):\n \"\"\"roots of the polynomial\"\"\"\n polynomial_input = [self.mass_1, self.mass_2, self.separation,\n source_x, source_y]\n\n if polynomial_input == self._last_polynomial_input:\n return self._polynomial_roots\n\n polynomial = self._get_polynomial(\n source_x=source_x, source_y=source_y)\n\n np_polyroots = np.polynomial.polynomial.polyroots\n if self._solver == 'numpy':\n self._polynomial_roots = np_polyroots(polynomial)\n elif self._solver == 'Skowron_and_Gould_12':\n args = polynomial.real.tolist() + polynomial.imag.tolist()\n try:\n out = _vbbl_SG12_5(*args)\n except ValueError as err:\n err2 = \"\\n\\nSwitching from Skowron & Gould 2012 to numpy\"\n warnings.warn(str(err) + err2, UserWarning)\n self._solver = 'numpy'\n self._polynomial_roots = np_polyroots(polynomial)\n else:\n self._polynomial_roots = np.array([\n out[0]+out[5]*1.j, out[1]+out[6]*1.j, out[2]+out[7]*1.j,\n out[3]+out[8]*1.j, out[4]+out[9]*1.j])\n else:\n raise ValueError('Unknown solver: {:}'.format(self._solver))\n self._last_polynomial_input = polynomial_input\n\n return self._polynomial_roots\n\n def _polynomial_roots_ok(\n self, source_x, source_y, return_distances=False):\n \"\"\"verified roots of polynomial i.e. roots of lens equation\"\"\"\n roots = self._get_polynomial_roots(\n source_x=source_x, source_y=source_y)\n\n # Two lines below are simplified assuming\n # self._position_z1.imag = 0 and same for z2.\n roots_conj = np.conjugate(roots)\n solutions = (self._zeta +\n self.mass_1 / (roots_conj - self._position_z1) +\n self.mass_2 / (roots_conj - self._position_z2))\n # This backs-up the lens equation.\n\n out = []\n distances = []\n for (i, root) in enumerate(roots):\n distances_from_root = abs((solutions-root)**2)\n min_distance_arg = np.argmin(distances_from_root)\n\n if i == min_distance_arg:\n out.append(root)\n distances.append(distances_from_root[min_distance_arg])\n # The values in distances[] are a diagnostic on how good the\n # numerical accuracy is.\n\n # If the lens equation is solved correctly, there should be\n # either 3 or 5 solutions (corresponding to 3 or 5 images)\n if len(out) not in [3, 5]:\n msg = (\"Wrong number of solutions to the lens equation of binary\" +\n \" lens.\\nGot {:} and expected 3 or 5.\\nThe parameters \" +\n \"(m1, m2, s, source_x, source_y, solver) are:\\n\" +\n \"{:} {:} {:} {:} {:} {:}\\n\\n\" +\n \"Consider using 'point_source_point_lens' method for \" +\n \"epochs when the source is very far from the lens. Note \" +\n \"that it's different from 'point_source' method.\")\n txt = msg.format(\n len(out), repr(self.mass_1), repr(self.mass_2),\n repr(self.separation), repr(source_x), repr(source_y),\n self._solver)\n\n if self._solver != \"Skowron_and_Gould_12\":\n txt += (\n \"\\n\\nYou should switch to using Skowron_and_Gould_12\" +\n \" polynomial root solver. It is much more accurate than \" +\n \"numpy.polynomial.polynomial.polyroots(). \" +\n \"Skowron_and_Gould_12 method is selected in automated \" +\n \"way if VBBL is imported properly.\")\n else:\n distance = sqrt(source_x**2 + source_y**2)\n if (self.mass_2 > 1.e-6 * self.mass_1 and\n (distance < 15. or distance < 2. * self.separation)):\n txt += (\"\\n\\nThis is surprising error - please contact \" +\n \"code authors and provide the above error \" +\n \"message.\")\n txt += \"\\nMulensModel version: {:}\".format(MulensModel.__version__)\n\n raise ValueError(txt)\n\n if return_distances:\n return (np.array(out), np.array(distances))\n else:\n return np.array(out)\n\n def _jacobian_determinant_ok(self, source_x, source_y):\n \"\"\"determinants of lens equation Jacobian for verified roots\"\"\"\n roots_ok_bar = np.conjugate(self._polynomial_roots_ok(\n source_x=source_x, source_y=source_y))\n # Variable X_bar is conjugate of variable X.\n add_1 = self.mass_1 / (self._position_z1 - roots_ok_bar)**2\n add_2 = self.mass_2 / (self._position_z2 - roots_ok_bar)**2\n derivative = add_1 + add_2\n\n return 1. - derivative * np.conjugate(derivative)\n\n def _signed_magnification(self, source_x, source_y):\n \"\"\"signed magnification for each image separately\"\"\"\n return 1. / self._jacobian_determinant_ok(\n source_x=source_x, source_y=source_y)\n\n def _point_source(self, source_x, source_y):\n \"\"\"calculate point source magnification\"\"\"\n signed_magnification = self._signed_magnification(\n source_x=source_x, source_y=source_y)\n return fsum(abs(signed_magnification))\n\n def _point_source_Witt_Mao_95(self, source_x, source_y):\n \"\"\"calculate point source magnification\"\"\"\n return self._point_source(source_x=source_x, source_y=source_y)\n\n def point_source_magnification(self, source_x, source_y):\n \"\"\"\n Calculate point source magnification for given position. The\n origin of the coordinate system is at the center of mass and\n both masses are on X axis with higher mass at negative X; this\n means that the higher mass is at (X, Y)=(-s*q/(1+q), 0) and\n the lower mass is at (s/(1+q), 0).\n\n Parameters :\n source_x: *float*\n X-axis coordinate of the source.\n\n source_y: *float*\n Y-axis coordinate of the source.\n\n Returns :\n magnification: *float*\n Point source magnification.\n \"\"\"\n if self._use_planet_frame:\n x_shift = -self.mass_1 / (self.mass_1 + self.mass_2)\n else:\n x_shift = self.mass_2 / (self.mass_1 + self.mass_2) - 0.5\n x_shift *= self.separation\n # We need to add this because in order to shift to correct frame.\n return self._point_source_Witt_Mao_95(\n source_x=float(source_x)+x_shift, source_y=float(source_y))\n # Casting to float speeds-up code for np.float input.\n\n def _get_magnification_w_plus(self, source_x, source_y, radius,\n magnification_center=None):\n \"\"\"Evaluates Gould (2008) eq. 7\"\"\"\n dx = [1., 0., -1., 0.]\n dy = [0., 1., 0., -1.]\n out = []\n for (i, dxval) in enumerate(dx):\n x = source_x + dxval * radius\n y = source_y + dy[i] * radius\n out.append(self.point_source_magnification(\n source_x=x, source_y=y))\n if magnification_center is None:\n magnification_center = self.point_source_magnification(\n source_x=source_x, source_y=source_y)\n return 0.25 * fsum(out) - magnification_center\n\n def _get_magnification_w_times(self, source_x, source_y, radius,\n magnification_center=None):\n \"\"\"Evaluates Gould (2008) eq. 8\"\"\"\n shift = radius / sqrt(2.)\n dx = [1., -1., -1., 1.]\n dy = [1., 1., -1., -1.]\n out = []\n for (i, dxval) in enumerate(dx):\n x = source_x + dxval * shift\n y = source_y + dy[i] * shift\n out.append(self.point_source_magnification(\n source_x=x, source_y=y))\n if magnification_center is None:\n magnification_center = self.point_source_magnification(\n source_x=source_x, source_y=source_y)\n return 0.25 * fsum(out) - magnification_center\n\n def _rho_check(self, rho):\n \"\"\"\n Check if rho is float and positive.\n \"\"\"\n if rho is None:\n raise TypeError(\n 'rho must be positive float, but None was provided')\n if not isinstance(rho, float):\n raise TypeError(\n 'rho must be positive float, but ' + str(rho) +\n str(type(rho)) + ' was provided')\n if rho < 0:\n raise ValueError(\n 'rho must be positive, got: {:}'.format(rho))\n\n def hexadecapole_magnification(self, source_x, source_y, rho, gamma,\n quadrupole=False, all_approximations=False):\n \"\"\"\n Magnification in hexadecapole approximation of the\n binary-lens/finite-source event - based on `Gould 2008 ApJ\n 681, 1593\n `_.\n\n For coordinate system convention see\n :py:func:`point_source_magnification()`\n\n Parameters :\n source_x: *float*\n X-axis coordinate of the source.\n\n source_y: *float*\n Y-axis coordinate of the source.\n\n rho: *float*\n Source size relative to Einstein ring radius.\n\n gamma: *float*\n Linear limb-darkening coefficient in gamma convention.\n\n quadrupole: *boolean*, optional\n Return quadrupole approximation instead of hexadecapole?\n Default is *False*.\n\n all_approximations: *boolean*, optional\n Return hexadecapole, quadrupole, and point source\n approximations? Default is *False*.\n\n Returns :\n magnification: *float* or *sequence* of three *floats*\n Hexadecapole approximation (*float*) by default.\n Quadrupole approximation (*float*) if *quadrupole*\n parameter is *True*. Hexadecapole, quadrupole, and\n point source approximations (*sequence* of three\n *floats*) if *all_approximations* parameter is *True*.\n \"\"\"\n # In this function, variables named a_* depict magnification.\n if quadrupole and all_approximations:\n raise ValueError('Inconsistent parameters of ' +\n 'BinaryLens.hexadecapole_magnification()')\n self._rho_check(rho)\n\n a_center = self.point_source_magnification(\n source_x=source_x, source_y=source_y)\n a_rho_half_plus = self._get_magnification_w_plus(\n source_x=source_x, source_y=source_y, radius=0.5*rho,\n magnification_center=a_center)\n a_rho_plus = self._get_magnification_w_plus(\n source_x=source_x, source_y=source_y, radius=rho,\n magnification_center=a_center)\n\n # This is Gould 2008 eq. 9:\n a_2_rho_square = (16. * a_rho_half_plus - a_rho_plus) / 3.\n\n # Gould 2008 eq. 6 (part 1/2):\n a_quadrupole = a_center + a_2_rho_square * (1. - 0.2 * gamma)\n\n # At this point is quadrupole approximation is finished\n if quadrupole:\n return a_quadrupole\n\n a_rho_times = self._get_magnification_w_times(\n source_x=source_x, source_y=source_y, radius=rho,\n magnification_center=a_center)\n\n # This is Gould (2008) eq. 9:\n a_4_rho_power4 = 0.5 * (a_rho_plus + a_rho_times) - a_2_rho_square\n # This is Gould (2008) eq. 6 (part 2/2):\n a_add = a_4_rho_power4 * (1. - 11. * gamma / 35.)\n a_hexadecapole = a_quadrupole + a_add\n\n if all_approximations:\n return (a_hexadecapole, a_quadrupole, a_center)\n else:\n return a_hexadecapole\n\n def adaptive_contouring_magnification(\n self, source_x, source_y, rho, gamma=None, u_limb_darkening=None,\n accuracy=0.1, ld_accuracy=0.001):\n \"\"\"\n Binary lens finite source magnification calculated using\n Adaptive Contouring method by `Dominik 2007 MNRAS, 377, 1679\n `_\n\n See also\n `AdaptiveContouring website by Martin Dominik\n `_\n\n For coordinate system convention see\n :py:func:`point_source_magnification()`\n\n Parameters :\n source_x: *float*\n X-axis coordinate of the source.\n\n source_y: *float*\n Y-axis coordinate of the source.\n\n rho: *float*\n Source size relative to Einstein ring radius.\n\n gamma: *float*, optional\n Linear limb-darkening coefficient in gamma convention.\n\n u_limb_darkening: *float*\n Linear limb-darkening coefficient in u convention.\n Note that either *gamma* or *u_limb_darkening* can be\n set. If neither of them is provided then limb\n darkening is ignored.\n\n accuracy: *float*, optional\n Requested accuracy of the result defined as the sum of\n the area of the squares that determine the contour\n line and the estimated total enclosed area (see sec. 4\n of the paper). As M. Dominik states: *\"this vastly\n overestimates the fractional error, and a suitable\n value should be chosen by testing how its variation\n affects the final results - I recommend starting at\n acc = 0.1.\"* It significantly affects execution time.\n\n ld_accuracy: *float*, optional\n Requested limb-darkening accuracy. As M. Dominik\n states: *\" Fractional uncertainty for the adaptive\n Simpson integration of the limb-darkening\n profile-related function during application of Green's\n theorem.\"* It does not add execution time so can be\n set to very small value.\n\n Returns :\n magnification: *float*\n Magnification.\n\n\n \"\"\"\n if accuracy <= 0.:\n raise ValueError('adaptive_contouring requires accuracy > 0')\n if ld_accuracy <= 0.:\n raise ValueError('adaptive_contouring requires ld_accuracy > 0')\n # Note that this accuracy is not guaranteed.\n self._rho_check(rho)\n\n if not _adaptive_contouring_wrapped:\n raise ValueError('Adaptive Contouring was not imported properly')\n\n if gamma is not None and u_limb_darkening is not None:\n raise ValueError(\n 'Only one limb darkening parameters can be set' +\n ' in BinaryLens.adaptive_contouring_magnification()')\n elif gamma is not None:\n gamma = float(gamma)\n elif u_limb_darkening is not None:\n gamma = float(Utils.u_to_gamma(u_limb_darkening))\n else:\n gamma = float(0.0)\n\n s = float(self.separation)\n q = float(self.mass_2 / self.mass_1)\n # AdaptiveContouring uses different coordinates conventions,\n # so we have to transform the coordinates below.\n x = float(-source_x)\n y = float(-source_y)\n rho = float(rho)\n accuracy = float(accuracy)\n ld_accuracy = float(ld_accuracy)\n\n magnification = _adaptive_contouring_linear(\n s, q, x, y, rho, gamma, accuracy, ld_accuracy)\n\n return magnification\n\n def vbbl_magnification(self, source_x, source_y, rho,\n gamma=None, u_limb_darkening=None,\n accuracy=0.001):\n \"\"\"\n Binary lens finite source magnification calculated using VBBL\n library that implements advanced contour integration algorithm\n presented by `Bozza 2010 MNRAS, 408, 2188\n `_.\n See also `VBBL website by Valerio Bozza\n `_.\n\n For coordinate system convention see\n :py:func:`point_source_magnification()`\n\n Parameters :\n source_x: *float*\n X-axis coordinate of the source.\n\n source_y: *float*\n Y-axis coordinate of the source.\n\n rho: *float*\n Source size relative to Einstein ring radius.\n\n gamma: *float*, optional\n Linear limb-darkening coefficient in gamma convention.\n\n u_limb_darkening: *float*\n Linear limb-darkening coefficient in u convention.\n Note that either *gamma* or *u_limb_darkening* can be\n set. If neither of them is provided then limb\n darkening is ignored.\n\n accuracy: *float*, optional\n Requested accuracy of the result.\n\n Returns :\n magnification: *float*\n Magnification.\n\n \"\"\"\n self._rho_check(rho)\n if accuracy <= 0.:\n raise ValueError(\n \"VBBL requires accuracy > 0 e.g. 0.01 or 0.001;\" +\n \"\\n{:} was provided\".format(accuracy))\n\n if not _vbbl_wrapped:\n raise ValueError('VBBL was not imported properly')\n\n if gamma is not None and u_limb_darkening is not None:\n raise ValueError('Only one limb darkening parameters can be set' +\n ' in BinaryLens.vbbl_magnification()')\n elif gamma is not None:\n u_limb_darkening = float(Utils.gamma_to_u(gamma))\n elif u_limb_darkening is not None:\n u_limb_darkening = float(u_limb_darkening)\n else:\n u_limb_darkening = float(0.0)\n\n s = float(self.separation)\n q = float(self.mass_2 / self.mass_1)\n x = float(source_x)\n y = float(source_y)\n rho = float(rho)\n accuracy = float(accuracy)\n\n magnification = _vbbl_binary_mag_dark(\n s, q, x, y, rho, u_limb_darkening, accuracy)\n\n return magnification\n", "meta": {"hexsha": "7cd064c1143a74293e69b881dbd8b1405ee70b47", "size": 27863, "ext": "py", "lang": "Python", "max_stars_repo_path": "source/MulensModel/binarylens.py", "max_stars_repo_name": "pmehta08/MulensModel", "max_stars_repo_head_hexsha": "261738c445a8d116d09c90e65f6e847cfc8a7ad8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "source/MulensModel/binarylens.py", "max_issues_repo_name": "pmehta08/MulensModel", "max_issues_repo_head_hexsha": "261738c445a8d116d09c90e65f6e847cfc8a7ad8", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "source/MulensModel/binarylens.py", "max_forks_repo_name": "pmehta08/MulensModel", "max_forks_repo_head_hexsha": "261738c445a8d116d09c90e65f6e847cfc8a7ad8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.9148044693, "max_line_length": 83, "alphanum_fraction": 0.5928650899, "include": true, "reason": "import numpy", "num_tokens": 7045, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5039061705290805, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.19395960471703508}} {"text": "\"\"\"\nGeneral utility functions for the pymodulon package\n\"\"\"\nimport json\nimport logging\nimport re\nfrom itertools import combinations\n\nimport numpy as np\nimport pandas as pd\nfrom scipy import stats\nfrom scipy.special import digamma\nfrom sklearn.neighbors import BallTree, KDTree\n\nfrom pymodulon.enrichment import FDR\n\n\n################\n# Type Aliases #\n################\n\n\ndef _check_table(table, name, index=None, index_col=0):\n # Set as empty dataframe if not input given\n if table is None:\n return pd.DataFrame(index=index)\n\n # Load table if necessary\n elif isinstance(table, str):\n try:\n table = pd.read_json(table)\n except ValueError:\n sep = \"\\t\" if table.endswith(\".tsv\") else \",\"\n table = pd.read_csv(table, index_col=index_col, sep=sep)\n\n # Coerce indices and columns to ints if necessary\n newcols = []\n for col in table.columns:\n try:\n newcols.append(int(col))\n except ValueError:\n newcols.append(col)\n table.columns = newcols\n\n newrows = []\n for row in table.index:\n try:\n newrows.append(int(row))\n except ValueError:\n newrows.append(row)\n table.index = newrows\n\n # Replace empty strings with None\n table = table.replace(\"\", np.nan)\n\n if isinstance(table, pd.DataFrame):\n # dont run _check_table_helper if no index is passed\n return table if index is None else _check_table_helper(table, index, name)\n else:\n raise TypeError(\n \"{}_table must be a pandas DataFrame \"\n \"filename or a valid JSON string\".format(name)\n )\n\n\ndef _check_table_helper(table, index, name):\n if table.shape == (0, 0):\n return pd.DataFrame(index=index)\n\n # Check if all indices are in table\n missing_index = list(set(index) - set(table.index))\n if len(missing_index) > 0:\n logging.warning(\n \"Some {} are missing from the {} table: {}\".format(\n name, name, missing_index\n )\n )\n\n # Remove extra indices from table\n table = table.reindex(index)\n return table\n\n\ndef _check_dict(table, index_col=0):\n try:\n table = json.loads(table.replace(\"'\", '\"'))\n except ValueError:\n sep = \"\\t\" if table.endswith(\".tsv\") else \",\"\n table = pd.read_csv(table, index_col=index_col, header=None, sep=sep)\n table = table.to_dict()[1]\n return table\n\n\ndef compute_threshold(ic, dagostino_cutoff):\n \"\"\"\n Computes D'agostino-test-based threshold for a component of an M matrix\n\n Parameters\n ----------\n ic: ~pandas.Series\n Pandas Series containing an independent component\n dagostino_cutoff: int\n Minimum D'agostino test statistic value to determine threshold\n\n Returns\n -------\n iModulon threshold: list\n List of thresholds for each iModulon\n \"\"\"\n\n i = 0\n\n # Sort genes based on absolute value\n ordered_genes = abs(ic).sort_values()\n\n # Compute k2-statistic\n k_square, p = stats.normaltest(ic)\n\n # Iteratively remove gene w/ largest weight until k2-statistic < cutoff\n while k_square > dagostino_cutoff:\n i -= 1\n k_square, p = stats.normaltest(ic.loc[ordered_genes.index[:i]])\n\n # Select genes in iModulon\n comp_genes = ordered_genes.iloc[i:]\n\n # Slightly modify threshold to improve plotting visibility\n if len(comp_genes) == len(ic.index):\n return max(comp_genes) + 0.05\n else:\n return np.mean([ordered_genes.iloc[i], ordered_genes.iloc[i - 1]])\n\n\ndef dima(ica_data, sample1, sample2, threshold=5, fdr=0.1, alternate_A=None):\n \"\"\"\n Creates DIMA table of differentially expressed iModulons\n\n Parameters\n ----------\n ica_data: ~pymodulon.core.IcaData\n :class:`~pymodulon.core.IcaData` data object\n sample1: str or list\n List of sample IDs or name of \"project:condition\"\n sample2: str or list\n List of sample IDs or name of \"project:condition\"\n threshold: float\n Minimum activity difference to determine DiMAs (default = 5)\n fdr: float\n False Detection Rate (default = .1)\n alternate_A: ~pandas.DataFrame\n Alternate A to use (default = None)\n\n Returns\n -------\n results: DataFrame\n Table of differentially expressed iModulons\n\n \"\"\"\n\n # use the undocumented alternate_A option to allow custom-built DIMCA\n # activity matrix to be used in lieu of standard activty matrix\n if alternate_A is not None:\n A_to_use = alternate_A\n else:\n A_to_use = ica_data.A\n\n _diff = pd.DataFrame()\n\n sample1_list = _parse_sample(ica_data, sample1)\n sample2_list = _parse_sample(ica_data, sample2)\n\n for name, group in ica_data.sample_table.groupby([\"project\", \"condition\"]):\n for i1, i2 in combinations(group.index, 2):\n _diff[\":\".join(name)] = abs(A_to_use[i1] - A_to_use[i2])\n dist = {}\n\n for k in A_to_use.index:\n dist[k] = stats.lognorm(*stats.lognorm.fit(_diff.loc[k].values)).cdf\n\n res = pd.DataFrame(index=A_to_use.index)\n for k in res.index:\n a1 = A_to_use.loc[k, sample1_list].mean()\n a2 = A_to_use.loc[k, sample2_list].mean()\n res.loc[k, \"difference\"] = a2 - a1\n res.loc[k, \"pvalue\"] = 1 - dist[k](abs(a1 - a2))\n result = FDR(res, fdr)\n return result[(abs(result.difference) > threshold)].sort_values(\n \"difference\", ascending=False\n )\n\n\ndef _parse_sample(ica_data, sample):\n \"\"\"\n Parses sample inputs into a list of sample IDs\n\n Parameters\n ----------\n ica_data: ~pymodulon.core.IcaData\n :class:`~pymodulon.core.IcaData` data object\n sample: list\n Sequence of sample IDs or \"project:condition\"\n\n Returns\n -------\n samples: list\n A list of `samples`\n \"\"\"\n\n sample_table = ica_data.sample_table\n if isinstance(sample, str):\n proj, cond = re.search(\"(.*):(.*)\", sample).groups()\n samples = sample_table[\n (sample_table.project == proj) & (sample_table.condition == cond)\n ].index\n if len(samples) == 0:\n raise ValueError(\n f\"No samples exist for project={proj} condition=\" f\"{cond}\"\n )\n else:\n return samples\n else:\n return sample\n\n\ndef explained_variance(\n ica_data, genes=None, samples=None, imodulons=None, reference=None\n):\n \"\"\"\n Computes the fraction of variance explained by iModulons (from 0 to 1)\n\n Parameters\n ----------\n ica_data: ~pymodulon.core.IcaData\n :class:`~pymodulon.core.IcaData` data object\n genes: str or list, optional\n List of genes to use (default: all genes)\n samples: str or list, optional\n List of samples to use (default: all samples)\n imodulons: int or str or list, optional\n List of iModulons to use (default: all iModulons)\n reference: list, optional\n List of samples that represent the reference condition for the\n set. If none are provided, uses the dataset-specific reference\n condition.\n\n Returns\n -------\n float\n Fraction of variance explained by selected iModulons for selected\n genes/samples\n \"\"\"\n\n # Check inputs\n if genes is None:\n genes = ica_data.X.index\n elif isinstance(genes, str):\n genes = [genes]\n\n gene_loci = set(genes) & set(ica_data.X.index)\n gene_names = set(genes) - set(ica_data.X.index)\n name_loci = [ica_data.name2num(gene) for gene in gene_names]\n genes = list(set(gene_loci) | set(name_loci))\n\n if samples is None:\n samples = ica_data.X.columns\n elif isinstance(samples, str):\n samples = [samples]\n\n if imodulons is None:\n imodulons = ica_data.M.columns\n elif isinstance(imodulons, str) or isinstance(imodulons, int):\n imodulons = [imodulons]\n\n if reference is None:\n centered = ica_data.X\n else:\n centered = ica_data.X.subtract(ica_data.X[reference].mean(axis=1), axis=0)\n\n # Account for normalization procedures before ICA (X=SA-x_mean)\n baseline = centered.subtract(centered.mean(axis=0), axis=1)\n baseline = baseline.loc[genes, samples]\n\n # Initialize variables\n base_err = np.linalg.norm(baseline) ** 2\n MA = np.zeros(baseline.shape)\n rec_var = [0]\n ma_arrs = {}\n ma_weights = {}\n\n # Get individual modulon contributions\n for k in imodulons:\n ma_arr = np.dot(\n ica_data.M.loc[genes, k].values.reshape(len(genes), 1),\n ica_data.A.loc[k, samples].values.reshape(1, len(samples)),\n )\n ma_arrs[k] = ma_arr\n ma_weights[k] = np.sum(ma_arr ** 2)\n\n # Sum components in order of most important component first\n sorted_mods = sorted(ma_weights, key=ma_weights.get, reverse=True)\n # Compute reconstructed variance\n for k in sorted_mods:\n MA = MA + ma_arrs[k]\n sa_err = np.linalg.norm(MA - baseline) ** 2\n rec_var.append((1 - sa_err / base_err))\n\n return np.clip(rec_var[-1], 0, 1)\n\n\ndef infer_activities(ica_data, data):\n \"\"\"\n Infer iModulon activities for external data\n\n Parameters\n ----------\n ica_data: ~pymodulon.core.IcaData\n :class:`~pymodulon.core.IcaData` data object\n data: ~pandas.DataFrame\n External expression profiles (must be centered to a reference)\n\n Returns\n -------\n new_activities: ~pandas.DataFrame\n Inferred activities for the expression profiles\n \"\"\"\n\n shared_genes = ica_data.M.index & data.index\n x = data.loc[shared_genes].values\n m = ica_data.M.loc[shared_genes].values\n m_inv = np.linalg.pinv(m)\n a = np.dot(m_inv, x)\n return pd.DataFrame(a, index=ica_data.imodulon_names, columns=data.columns)\n\n\ndef mutual_info_distance(x, y):\n x = np.asarray(x).reshape(x.shape[0], 1)\n y = np.asarray(y).reshape(x.shape[0], 1)\n h = entropy(np.hstack([x, y]))\n if h == 0:\n return 1\n else:\n return 1 - mi(x, y) / h\n\n\n# the following code is taken from the NPEET package; it cannot be installed\n# via pip, so the necessary functions are copied here; the package appears to\n# be un-maintained, so updates are not very likely; this is the GitHub page:\n# https://github.com/gregversteeg/NPEET\n\n\ndef mi(x, y, z=None, k=3, base=2, alpha=0):\n \"\"\"Mutual information of x and y (conditioned on z if z is not None)\n x, y should be a list of vectors, e.g. x = [[1.3], [3.7], [5.1], [2.4]]\n if x is a one-dimensional scalar and we have four samples\n \"\"\"\n assert len(x) == len(y), \"Arrays should have same length\"\n assert k <= len(x) - 1, \"Set k smaller than num. samples - 1\"\n x, y = np.asarray(x), np.asarray(y)\n x, y = x.reshape(x.shape[0], -1), y.reshape(y.shape[0], -1)\n x = add_noise(x)\n y = add_noise(y)\n points = [x, y]\n if z is not None:\n z = np.asarray(z)\n z = z.reshape(z.shape[0], -1)\n points.append(z)\n points = np.hstack(points)\n # Find nearest neighbors in joint space, p=inf means max-norm\n tree = build_tree(points)\n dvec = query_neighbors(tree, points, k)\n if z is None:\n a, b, c, d = (\n avgdigamma(x, dvec),\n avgdigamma(y, dvec),\n digamma(k),\n digamma(len(x)),\n )\n if alpha > 0:\n d += lnc_correction(tree, points, k, alpha)\n else:\n xz = np.c_[x, z]\n yz = np.c_[y, z]\n a, b, c, d = (\n avgdigamma(xz, dvec),\n avgdigamma(yz, dvec),\n avgdigamma(z, dvec),\n digamma(k),\n )\n return max(0, (-a - b + c + d) / np.log(base))\n\n\ndef entropy(x, k=3, base=2):\n \"\"\"The classic K-L k-nearest neighbor continuous entropy estimator\n x should be a list of vectors, e.g. x = [[1.3], [3.7], [5.1], [2.4]]\n if x is a one-dimensional scalar and we have four samples\n \"\"\"\n assert k <= len(x) - 1, \"Set k smaller than num. samples - 1\"\n x = np.asarray(x)\n n_elements, n_features = x.shape\n x = add_noise(x)\n tree = build_tree(x)\n nn = query_neighbors(tree, x, k)\n const = digamma(n_elements) - digamma(k) + n_features * np.log(2)\n return max(0, (const + n_features * np.log(nn).mean()) / np.log(base))\n\n\ndef add_noise(x, intens=1e-10):\n \"\"\"Small noise to break degeneracy, see doc.\"\"\"\n return x + intens * np.random.random_sample(x.shape)\n\n\ndef build_tree(points):\n if points.shape[1] >= 20:\n return BallTree(points, metric=\"chebyshev\")\n return KDTree(points, metric=\"chebyshev\")\n\n\ndef query_neighbors(tree, x, k):\n return tree.query(x, k=k + 1)[0][:, k]\n\n\ndef avgdigamma(points, dvec):\n \"\"\"This part finds number of neighbors in some radius in the marginal space\n returns expectation value of \"\"\"\n tree = build_tree(points)\n dvec = dvec - 1e-15\n num_points = count_neighbors(tree, points, dvec)\n return np.mean(digamma(num_points))\n\n\ndef lnc_correction(tree, points, k, alpha):\n e = 0\n n_sample = points.shape[0]\n for point in points:\n # Find k-nearest neighbors in joint space, p=inf means max norm\n knn = tree.query(point[None, :], k=k + 1, return_distance=False)[0]\n knn_points = points[knn]\n # Substract mean of k-nearest neighbor points\n knn_points = knn_points - knn_points[0]\n # Calculate covariance matrix of k-nearest neighbor points, obtain\n # eigen vectors\n covr = knn_points.T @ knn_points / k\n _, v = np.linalg.eig(covr)\n # Calculate PCA-bounding box using eigen vectors\n V_rect = np.log(np.abs(knn_points @ v).max(axis=0)).sum()\n # Calculate the volume of original box\n log_knn_dist = np.log(np.abs(knn_points).max(axis=0)).sum()\n\n # Perform local non-uniformity checking and update correction term\n if V_rect < log_knn_dist + np.log(alpha):\n e += (log_knn_dist - V_rect) / n_sample\n return e\n\n\ndef count_neighbors(tree, x, r):\n return tree.query_radius(x, r, count_only=True)\n", "meta": {"hexsha": "67ceee2f49a71c60418d405de83c87406ed525f3", "size": 13959, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/pymodulon/util.py", "max_stars_repo_name": "SBRG/pymodulon", "max_stars_repo_head_hexsha": "7de0d3f86203b3eeafbfa95f4184145c6edca03f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-07-06T15:52:03.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-27T09:42:04.000Z", "max_issues_repo_path": "src/pymodulon/util.py", "max_issues_repo_name": "SBRG/pymodulon", "max_issues_repo_head_hexsha": "7de0d3f86203b3eeafbfa95f4184145c6edca03f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 34, "max_issues_repo_issues_event_min_datetime": "2021-03-09T21:42:36.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-09T04:31:53.000Z", "max_forks_repo_path": "src/pymodulon/util.py", "max_forks_repo_name": "SBRG/pymodulon", "max_forks_repo_head_hexsha": "7de0d3f86203b3eeafbfa95f4184145c6edca03f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-06-10T14:50:05.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-14T20:57:35.000Z", "avg_line_length": 30.5448577681, "max_line_length": 82, "alphanum_fraction": 0.623683645, "include": true, "reason": "import numpy,from scipy", "num_tokens": 3674, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5039061705290805, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.19395960471703508}} {"text": "from __future__ import division\nimport torch\n\n# Beam decoding with KL divergence\nimport numpy as np\nfrom scipy.stats import entropy\n\nclass Beam(object):\n \"\"\"\n Class for managing the internals of the beam search process.\n\n Takes care of beams, back pointers, and scores.\n\n Args:\n size (int): beam size\n pad, bos, eos (int): indices of padding, beginning, and ending.\n vocab (vocab): vocab of the target\n syntax_topics_model (Syntax and Topics module): This is an object of the class which will have the topics \n and classes word probabilities\n source (list): list of source indices which will be the source sentence\n targets (list of list): list of taget sentences each of which is a list of indices of the full hypothesis generated till now\n n_best (int): nbest size to use\n cuda (bool): use gpu\n global_scorer (:obj:`GlobalScorer`)\n \"\"\"\n def __init__(self, size, pad, bos, eos,\n vocab, syntax_topics_model,\n source,\n n_best=1, cuda=False,\n global_scorer=None,\n min_length=0):\n\n self.size = size\n self.tt = torch.cuda if cuda else torch\n\n # The score for each translation on the beam.\n self.scores = self.tt.FloatTensor(size).zero_()\n self.all_scores = []\n\n # The backpointers at each time-step.\n self.prev_ks = []\n\n \n\n # The outputs at each time-step.\n self.next_ys = [self.tt.LongTensor(size)\n .fill_(pad)]\n self.next_ys[0][0] = bos\n ##NOTE: speical marker which tells which class is the previous word from\n self.next_ys_topic_prior_sum = [] # Store the sum of the topic prior for the entire hypothesis\n self.next_ys_class_prior_sum = [] # Store the sum of the class prior for the entire hypothesis\n self.TOPIC_FLAG = 0\n self.CLASS_FLAG = 1\n\n\n # Has EOS topped the beam yet.\n self._eos = eos\n self.eos_top = False\n\n # The attentions (matrix) for each time.\n self.attn = []\n\n # Time and k pair for finished.\n self.finished = []\n self.n_best = n_best\n\n # Information for global scoring.\n self.global_scorer = global_scorer\n self.global_state = {}\n\n # Minimum prediction length\n self.min_length = min_length\n\n\n\n ##NOTE: Custom code\n self.vocab = vocab\n self.finished_marker = [-1]*size\n self.syntax_topics_model = syntax_topics_model\n self.source = [self.vocab.itos[word_id] for word_id in source]\n # Compute the topic prior probability for the source sentence\n self.source_topic_prior = np.zeros(self.syntax_topics_model.num_topics+1, dtype=np.float)\n print self.source\n self.src_topic_word_count = 0\n for word in self.source:\n word_topic_prior = self.syntax_topics_model.get_topic_prior_for_word(word)\n if word_topic_prior[self.syntax_topics_model.num_topics] != 1.0:\n print word\n self.src_topic_word_count += 1\n self.source_topic_prior += word_topic_prior\n self.source_class_prior = np.zeros(self.syntax_topics_model.num_classes, dtype=np.float)\n for word in self.source:\n self.source_class_prior += self.syntax_topics_model.get_class_prior_for_word(word)\n \n self.source_topic_prior /= len(self.source)\n self.source_class_prior /= len(self.source)\n self.beta = 0.0 # Additive smoothing\n self.source_topic_prior += self.beta\n self.source_class_prior += self.beta\n print(self.source_topic_prior)\n print(self.source_class_prior)\n self.L = 50 # Number of words to be chosen for the similarity consideration\n # temp = np.zeros_like(self.source_topic_prior) + self.beta\n # least_KL = entropy(self.source_topic_prior, temp)\n self.alpha = 1.5 # Multiplicative factor for topic KL divergence\n self.gamma = 1.5 # Multiplicative factor for class KL divergence\n # self.alpha = 8/least_KL # multiplicative factor for the KL divergence\n # print vocab.itos[0]\n # print vocab.itos[bos]\n # print vocab.itos[self._eos]\n # print vocab.__dict__.keys()\n # print vocab.unk_init\n # print type(vocab)\n self.topic_KL_flag = False\n self.class_KL_flag = True\n\n def print_hyp(self, hyp, class_or_topic = None):\n for i, word_id in enumerate(hyp):\n if class_or_topic:\n print \"{}_{} \".format(self.vocab.itos[word_id], class_or_topic[i]),\n else:\n print \"{} \".format(self.vocab.itos[word_id]),\n\n ##NOTE: Custom function for debugging\n def print_all_words_in_beam(self):\n # Uses the vocab and prints the list of next_ys\n for i in range(self.size):\n timestep = len(self.next_ys)\n # if self.finished_marker[i] != -1:\n # timestep = self.finished_marker[i]\n if timestep > 1:\n hyp, _ = self.get_hyp(timestep, i)\n # print hyp\n # print type(hyp)\n self.print_hyp(hyp)\n print \"$$$\"\n # print \"\"\n\n def print_received_targets(self):\n for i in range(len(self.targets)):\n self.print_hyp(self.targets[i])\n print \"\"\n print \"############### Received Targets ############\"\n\n def print_the_top_choices(self, best_choices):\n w, h = best_choices.size()\n for i in range(w):\n for j in range(h):\n print \"{} \".format(self.vocab.itos[best_choices[i,j]]),\n print \"\"\n\n\n def get_current_state(self):\n \"Get the outputs for the current timestep.\"\n return self.next_ys[-1]\n\n def get_current_origin(self):\n \"Get the backpointers for the current timestep.\"\n return self.prev_ks[-1]\n\n def advance(self, word_probs, attn_out):\n print \"Advancing beam\"\n \"\"\"\n Given prob over words for every last beam `wordLk` and attention\n `attn_out`: Compute and update the beam search.\n\n Parameters:\n\n * `word_probs`- probs of advancing from the last step (K x words)\n * `attn_out`- attention at the last step\n\n Returns: True if beam search is complete.\n \"\"\"\n num_words = word_probs.size(1)\n\n # force the output to be longer than self.min_length\n cur_len = len(self.next_ys)\n if cur_len < self.min_length:\n for k in range(len(word_probs)):\n word_probs[k][self._eos] = -1e20\n\n # Sum the previous scores.\n if len(self.prev_ks) > 0:\n beam_scores = word_probs + \\\n self.scores.unsqueeze(1).expand_as(word_probs)\n\n # Don't let EOS have children.\n for i in range(self.next_ys[-1].size(0)):\n if self.next_ys[-1][i] == self._eos:\n beam_scores[i] = -1e20\n else:\n beam_scores = word_probs[0]\n\n #TODO: 1) find the last word for each beam\n # 2) For each possible hypothesis find the Topic modeling probability\n # 3) Weighted add the syntax and topic scores to beam_scores and just calculate the next_ys and backpointers as normal\n \n if len(self.prev_ks) > 0:\n per_beam_words = self.next_ys[-1]\n if self.topic_KL_flag:\n per_beam_hyp_topic_prior_sum = self.next_ys_topic_prior_sum[-1]\n if self.class_KL_flag:\n per_beam_hyp_class_prior_sum = self.next_ys_class_prior_sum[-1]\n\n if self.topic_KL_flag:\n topic_KL_divergence_scores = self.tt.zeros_like(beam_scores)\n if self.class_KL_flag:\n class_KL_divergence_scores = self.tt.zeros_like(beam_scores)\n for i in range(self.size):\n if self.topic_KL_flag:\n hyp_topic_prior = per_beam_hyp_topic_prior_sum[i]\n if self.class_KL_flag:\n hyp_class_prior = per_beam_hyp_class_prior_sum[i]\n\n len_hyp = len(self.next_ys) # Includes current word because we want to skip the count added by the start word \n for j in range(num_words):\n word = self.vocab.itos[j]\n #KL divergence for Topic Priors\n if self.topic_KL_flag:\n word_topic_prior = self.syntax_topics_model.get_topic_prior_for_word(word)\n hyp_topic_prior_sum = (hyp_topic_prior + word_topic_prior) + self.beta\n # topic_KL_divergence_scores[i][j] = entropy(self.source_topic_prior, hyp_topic_prior_sum)\n topic_KL_divergence_scores[i][j] = self.syntax_topics_model.KL_divergence(self.source_topic_prior, hyp_topic_prior_sum)\n if topic_KL_divergence_scores[i][j] == float('Inf'):\n print word\n print topic_KL_divergence_scores[i][j]\n print self.source_topic_prior\n print hyp_topic_prior_sum\n #KL divergence for Class Priors\n if self.class_KL_flag:\n if \"\" in word:\n class_KL_divergence_scores[i][j] = 1000000.0\n continue\n word_class_prior = self.syntax_topics_model.get_class_prior_for_word(word)\n hyp_class_prior_sum = (hyp_class_prior + word_class_prior) + self.beta\n # class_KL_divergence_scores[i][j] = entropy(self.source_class_prior, hyp_class_prior_sum)\n class_KL_divergence_scores[i][j] = self.syntax_topics_model.KL_divergence(self.source_class_prior, hyp_class_prior_sum)\n if class_KL_divergence_scores[i][j] == float('Inf'):\n print word\n print class_KL_divergence_scores[i][j]\n print self.source_class_prior\n print hyp_class_prior_sum\n\n #TODO: Convert the zeros to max KL divergence\n if self.topic_KL_flag:\n max_topic_KL = topic_KL_divergence_scores.mean()\n for i in range(self.size):\n for j in range(num_words):\n word = self.vocab.itos[j]\n if \"\" in word:\n topic_KL_divergence_scores[i][j] = 1000000.0\n continue\n if topic_KL_divergence_scores[i][j] == 0.0:\n topic_KL_divergence_scores[i][j] = max_topic_KL\n print \"########\\n\", max_topic_KL, \"\\n#########\"\n # Manually discourage unk by setting large negative syntax_topic_probability\n # if \"\" in word:\n # syntax_topic_score, best_class_or_topic, class_or_topic = -1000000.0, -1, \"C\"\n # else:\n # syntax_topic_score, best_class_or_topic, class_or_topic = self.syntax_topics_model.get_log_prob(word, 0 if per_beam_words_class_or_topic[i] == self.TOPIC_FLAG else per_beam_words_class_or_topic_number[i])\n overall_scores = beam_scores - ((self.alpha * topic_KL_divergence_scores) if self.topic_KL_flag else 0.0) - ((self.gamma * class_KL_divergence_scores) if self.class_KL_flag else 0.0)\n # print \"Overall Score\"\n # print overall_scores\n # print overall_scores.size()\n \n\n size = int(overall_scores.size(1))\n # print \"Size of the overall_scores = \", size\n flat_beam_scores = overall_scores.view(-1)\n best_scores, best_scores_id = flat_beam_scores.topk(self.size, 0,\n True, True)\n\n # We will debug the individual scores of the best candidates\n word_prob_best_scores = self.tt.zeros_like(best_scores)\n for i in range(self.size):\n word_prob_best_scores[i] = beam_scores[int(best_scores_id[i] / size)][best_scores_id[i] - int(best_scores_id[i] / size) * size]\n if self.topic_KL_flag:\n topic_KL_divergence_best_scores = self.tt.zeros_like(best_scores)\n for i in range(self.size):\n topic_KL_divergence_best_scores[i] = topic_KL_divergence_scores[int(best_scores_id[i] / size)][best_scores_id[i] - int(best_scores_id[i] / size) * size]\n if self.class_KL_flag:\n class_KL_divergence_best_scores = self.tt.zeros_like(best_scores)\n for i in range(self.size):\n class_KL_divergence_best_scores[i] = class_KL_divergence_scores[int(best_scores_id[i] / size)][best_scores_id[i] - int(best_scores_id[i] / size) * size]\n print best_scores\n print word_prob_best_scores\n # print topic_KL_divergence_best_scores\n # print class_KL_divergence_best_scores\n if self.topic_KL_flag:\n print self.alpha\n print self.alpha * topic_KL_divergence_best_scores\n if self.class_KL_flag:\n print self.gamma\n print self.gamma * class_KL_divergence_best_scores\n\n if self.topic_KL_flag:\n KL_size = int(topic_KL_divergence_scores.size(1))\n # print \"Size of the overall_scores = \", size\n flat_beam_scores = topic_KL_divergence_scores.view(-1)\n debug_size = 25\n best_topic_KL_scores, best_topic_KL_scores_id = flat_beam_scores.topk(debug_size, 0,\n False, True)\n print \"Best words from topic KL\"\n for i in range(debug_size):\n # print best_topic_KL_scores_id[i], best_topic_KL_scores_id[i] - int(best_topic_KL_scores_id[i] / KL_size) * KL_size\n word = self.vocab.itos[best_topic_KL_scores_id[i] - int(best_topic_KL_scores_id[i] / KL_size) * KL_size]\n word_topic_prior = self.syntax_topics_model.get_topic_prior_for_word(word)\n # print word, word_topic_prior, entropy(self.source_topic_prior, word_topic_prior + self.beta), \\\n print word, \\\n overall_scores[int(best_topic_KL_scores_id[i] / KL_size)][best_topic_KL_scores_id[i] - int(best_topic_KL_scores_id[i] / KL_size) * KL_size], \\\n best_topic_KL_scores[i], \\\n topic_KL_divergence_scores[int(best_topic_KL_scores_id[i] / KL_size)][best_topic_KL_scores_id[i] - int(best_topic_KL_scores_id[i] / KL_size) * KL_size]\n # class_KL_divergence_scores[int(best_topic_KL_scores_id[i] / KL_size)][best_topic_KL_scores_id[i] - int(best_topic_KL_scores_id[i] / KL_size) * KL_size], \\\n # print word_prob_best_scores + self.alpha * syntax_topic_best_scores\n\n prev_k = best_scores_id / num_words\n # Update next_ys_topic_prior_sum for all beams\n if self.topic_KL_flag:\n best_hyp_topic_prior_sum = list()\n for i in range(self.size):\n word = self.vocab.itos[best_scores_id[i] - int(best_scores_id[i] / size) * size]\n word_topic_prior = self.syntax_topics_model.get_topic_prior_for_word(word)\n if word_topic_prior[self.syntax_topics_model.num_topics] != 1.0:\n best_hyp_topic_prior_sum.append(self.next_ys_topic_prior_sum[-1][int(best_scores_id[i] / size)] + word_topic_prior)\n else:\n # Add the word_topic_prior only if its a topic word\n best_hyp_topic_prior_sum.append(self.next_ys_topic_prior_sum[-1][int(best_scores_id[i] / size)])\n self.next_ys_topic_prior_sum.append(best_hyp_topic_prior_sum)\n # Update next_ys_class_prior_sum for all beams\n if self.class_KL_flag:\n best_hyp_class_prior_sum = list()\n for i in range(self.size):\n word = self.vocab.itos[best_scores_id[i] - int(best_scores_id[i] / size) * size]\n word_class_prior = self.syntax_topics_model.get_class_prior_for_word(word)\n best_hyp_class_prior_sum.append(self.next_ys_class_prior_sum[-1][int(best_scores_id[i] / size)] + word_class_prior)\n self.next_ys_class_prior_sum.append(best_hyp_class_prior_sum)\n self.prev_ks.append(prev_k)\n self.next_ys.append((best_scores_id - prev_k * num_words))\n self.attn.append(attn_out.index_select(0, prev_k))\n # exit()\n\n self.print_all_words_in_beam()\n print \"############## After new words chosen ###########\"\n else:\n # beam_scores is only V dimensional vector\n # Thus for every word add the KL divergence score to the beam score\n if self.topic_KL_flag:\n topic_KL_divergence_scores = self.tt.zeros_like(beam_scores)\n if self.class_KL_flag:\n class_KL_divergence_scores = self.tt.zeros_like(beam_scores)\n for i in range(num_words):\n word = self.vocab.itos[i]\n if \"\" in word:\n if self.topic_KL_flag:\n topic_KL_divergence_scores[i] = 1000000.0\n if self.class_KL_flag:\n class_KL_divergence_scores[i] = 1000000.0\n beam_scores[i] = -1000000.0\n continue\n # KL for Topic priors of the first word\n if self.topic_KL_flag:\n word_topic_prior = self.syntax_topics_model.get_topic_prior_for_word(word)\n word_topic_prior += self.beta\n # topic_KL_divergence_scores[i] = entropy(self.source_topic_prior, word_topic_prior)\n topic_KL_divergence_scores[i] = self.syntax_topics_model.KL_divergence(self.source_topic_prior, word_topic_prior)\n # KL for Class priors of the first word\n if self.class_KL_flag:\n word_class_prior = self.syntax_topics_model.get_class_prior_for_word(word)\n word_class_prior += self.beta\n # class_KL_divergence_scores[i] = entropy(self.source_class_prior, word_class_prior)\n class_KL_divergence_scores[i] = self.syntax_topics_model.KL_divergence(self.source_class_prior, word_class_prior)\n \n overall_scores = beam_scores - ((self.alpha * topic_KL_divergence_scores) if self.topic_KL_flag else 0.0) - ((self.gamma * class_KL_divergence_scores) if self.class_KL_flag else 0.0)\n # flat_beam_scores = overall_scores.view(-1)\n flat_beam_scores = beam_scores.view(-1) # For the first iteration use only the word probabilities\n best_scores, best_scores_id = flat_beam_scores.topk(self.size, 0,\n True, True)\n\n self.all_scores.append(self.scores)\n # self.scores = best_scores # will store the word_prob + the KL divergence for hypothesis\n self.scores = best_scores # will store the word_prob log prob for hypothesis\n\n # best_scores_id is flattened, beam * word array, so calculate which\n # word and beam each score came from\n size = int(overall_scores.size(0))\n prev_k = best_scores_id / num_words\n # Update next_ys_topic_prior_sum for all beams\n if self.topic_KL_flag:\n best_hyp_topic_prior_sum = list()\n for i in range(self.size):\n word = self.vocab.itos[best_scores_id[i]]\n word_topic_prior = self.syntax_topics_model.get_topic_prior_for_word(word)\n if word_topic_prior[self.syntax_topics_model.num_topics] != 1.0:\n best_hyp_topic_prior_sum.append(word_topic_prior)\n else:\n # starting word is a syntax word. Therefore we will set the prior to zeros\n best_hyp_topic_prior_sum.append(np.zeros((self.syntax_topics_model.num_topics+1), dtype=np.float))\n self.next_ys_topic_prior_sum.append(best_hyp_topic_prior_sum)\n\n # Update next_ys_class_prior_sum for all beams\n if self.class_KL_flag:\n best_hyp_class_prior_sum = list()\n for i in range(self.size):\n word = self.vocab.itos[best_scores_id[i]]\n word_class_prior = self.syntax_topics_model.get_class_prior_for_word(word)\n best_hyp_class_prior_sum.append(word_class_prior)\n self.next_ys_class_prior_sum.append(best_hyp_class_prior_sum)\n\n self.prev_ks.append(prev_k)\n self.next_ys.append((best_scores_id - prev_k * num_words))\n self.attn.append(attn_out.index_select(0, prev_k))\n\n if self.global_scorer is not None:\n self.global_scorer.update_global_state(self)\n\n for i in range(self.next_ys[-1].size(0)):\n if self.next_ys[-1][i] == self._eos:\n s = self.scores[i]\n timestep = len(self.next_ys)\n if self.global_scorer is not None:\n global_scores = self.global_scorer.score(self, self.scores)\n s = global_scores[i]\n self.finished.append((s, len(self.next_ys) - 1, i))\n # TODO: Experimental!! Dividing the finished scores by their lenghts to be fair\n # self.finished.append((s/float(len(self.next_ys) - 1), len(self.next_ys) - 1, i))\n\n\n ##NOTE: Custom code\n if self.finished_marker[i] == -1:\n # print \"SET AND FORGET FOR \", i, \"#$#$#$#$##$\"\n self.finished_marker[i] = len(self.next_ys) - 1\n\n\n\n # End condition is when top-of-beam is EOS and no global score.\n if self.next_ys[-1][0] == self._eos:\n # self.all_scores.append(self.scores)\n self.eos_top = True\n\n\n\n ##NOTE: Debugging\n # print word_probs, \"$$\"\n # print self.get_current_state(), \"$$\" \n # self.print_all_words_in_beam()\n # print \"############## Beam Advance ###########\"\n\n def done(self):\n return self.eos_top and len(self.finished) >= self.n_best\n\n def sort_finished(self, minimum=None):\n if minimum is not None:\n i = 0\n # Add from beam until we have minimum outputs.\n while len(self.finished) < minimum:\n s = self.scores[i]\n if self.global_scorer is not None:\n global_scores = self.global_scorer.score(self, self.scores)\n s = global_scores[i]\n self.finished.append((s, len(self.next_ys) - 1, i))\n\n # print self.finished\n # exit()\n\n self.finished.sort(key=lambda a: -a[0])\n scores = [sc for sc, _, _ in self.finished]\n ks = [(t, k) for _, t, k in self.finished]\n return scores, ks\n\n def get_hyp_with_class(self, timestep, k):\n \"\"\"\n Walk back to construct the full hypothesis while also storing the class/topic number\n \"\"\"\n hyp, class_or_topic = [], []\n # print len(self.next_ys), len(self.next_class_or_topics), len(self.next_class_or_topic_numbers)\n for j in range(len(self.prev_ks[:timestep]) - 1, -1, -1):\n hyp.append(self.next_ys[j+1][k])\n class_or_topic.append(\"{}{}\".format(\"C\" if self.next_class_or_topics[j][k] == 1 else \"T\", self.next_class_or_topic_numbers[j][k]))\n k = self.prev_ks[j][k]\n class_or_topic.reverse()\n return hyp[::-1], class_or_topic\n\n def get_hyp(self, timestep, k):\n \"\"\"\n Walk back to construct the full hypothesis.\n \"\"\"\n hyp, attn = [], []\n for j in range(len(self.prev_ks[:timestep]) - 1, -1, -1):\n hyp.append(self.next_ys[j+1][k])\n attn.append(self.attn[j][k])\n k = self.prev_ks[j][k]\n return hyp[::-1], torch.stack(attn[::-1])\n\n\nclass GNMTGlobalScorer(object):\n \"\"\"\n NMT re-ranking score from\n \"Google's Neural Machine Translation System\" :cite:`wu2016google`\n\n Args:\n alpha (float): length parameter\n beta (float): coverage parameter\n \"\"\"\n def __init__(self, alpha, beta):\n self.alpha = alpha\n self.beta = beta\n\n def score(self, beam, logprobs):\n \"Additional term add to log probability\"\n cov = beam.global_state[\"coverage\"]\n pen = self.beta * torch.min(cov, cov.clone().fill_(1.0)).log().sum(1)\n l_term = (((5 + len(beam.next_ys)) ** self.alpha) /\n ((5 + 1) ** self.alpha))\n return (logprobs / l_term) + pen\n\n def update_global_state(self, beam):\n \"Keeps the coverage vector as sum of attens\"\n if len(beam.prev_ks) == 1:\n beam.global_state[\"coverage\"] = beam.attn[-1]\n else:\n beam.global_state[\"coverage\"] = beam.global_state[\"coverage\"] \\\n .index_select(0, beam.prev_ks[-1]).add(beam.attn[-1])\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n", "meta": {"hexsha": "6b70cdd932e52e1e4edc4d014918e06322f43a09", "size": 25717, "ext": "py", "lang": "Python", "max_stars_repo_path": "onmt/translate/Beam_KL_divergence.py", "max_stars_repo_name": "abaheti95/DC-NeuralConversation", "max_stars_repo_head_hexsha": "14f3c03adfb7379b48a325c0b3416eee39af7fdb", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 29, "max_stars_repo_stars_event_min_datetime": "2018-09-06T07:38:02.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T06:55:42.000Z", "max_issues_repo_path": "onmt/translate/Beam_KL_divergence.py", "max_issues_repo_name": "abaheti95/DC-NeuralConversation", "max_issues_repo_head_hexsha": "14f3c03adfb7379b48a325c0b3416eee39af7fdb", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2018-10-12T13:33:16.000Z", "max_issues_repo_issues_event_max_datetime": "2019-04-07T14:25:48.000Z", "max_forks_repo_path": "onmt/translate/Beam_KL_divergence.py", "max_forks_repo_name": "abaheti95/DC-NeuralConversation", "max_forks_repo_head_hexsha": "14f3c03adfb7379b48a325c0b3416eee39af7fdb", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2018-09-24T19:56:55.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-16T06:10:38.000Z", "avg_line_length": 46.0053667263, "max_line_length": 230, "alphanum_fraction": 0.5871602442, "include": true, "reason": "import numpy,from scipy", "num_tokens": 5645, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5039061705290805, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.19395960471703508}} {"text": "\"\"\"\nJoseph Cook, Aarhus University, Jan 2022\n\nThis script contains functions that a) generate \nSNICAR-predicted spectral albedo that approximate\nfield-measured spectra for a variety of weathering \ncrust configurations; b) quantify the albedo change\nresulting from a range of WC development scenarios \n\n\nincludes:\n\nfind_best_params()\n the forward modelling script that retrieves the snicar params that generate the\n best-matching curve to a given field spectrum\n\ncall_snicar()\n the function used to do multiple snicar runs with params provided as a named tuple\n\nmatch_field_spectra()\n the function for plotting simulated and measured field spectra in a multipanel fig\n\nisolate_biological_effect()\n the function for calculating the albedo reduction due to bio vs phys processes by spectral differencing\n\nbuild_LUT()\n function for constructing lookup table to be used in the inverse model\n\ninverse_model()\n function finds the best matching entry in the LUTs for each field spectrum and returns the params\n used to generate it\n\n\n\"\"\"\nimport collections as c\nimport sys\n\nsys.path.append(\"./src\")\nimport dask\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\nimport statsmodels.api as sm\nimport xarray as xr\nfrom call_snicar import call_snicar\n\n\ndef match_field_spectra(\n FIELD_DATA_FNAME,\n fnames,\n rho,\n rds,\n dz,\n alg,\n measured_cells,\n CIsites,\n LAsites,\n HAsites,\n APPLY_ARF,\n PLOT_ARF,\n ARF_CI,\n ARF_HA,\n SAVEPATH,\n):\n\n \"\"\"\n plot field against SNICAR spectra\n requires parameters to be known in advance and hard coded inside this function\n the relevant params can be generated using the find_best_params() func\n\n params:\n FIELD_DATA_FNAME = filename for spectral database\n\n The following params are parallel arrays - the order matters and\n must match the filenames! Pairs of values represent values for\n upper and lower layers in model. These are the values used to\n generate snicar spectrum to match field spectrum with name = fname[i]\n\n fnames = sample IDs for spectra to match model runs\n rho = pairs of density values [upper, lower]\n rds = pairs of r_eff values [upper, lower]\n dz = layer thickness [upper, lower] NB. upper is always 0.001\n alg = mass concentration of algae [upper, lower] NB. lower is always 0\n measured_cells = array of the actual measured cell concentration for each spectrum\n\n e.g.\n fnames= ['2016_WI_8','14_7_SB6','14_7_SB9','14_7_SB1','21_7_SB2','14_7_SB2', '22_7_SB3', 'RAIN']\n rho = [[550,550],[650,650],[800,800],[850,850],[750,750],[800,800],[800,800],[900,900]]\n rds = [[550,550],[650,650],[850,850],[850,850],[800,800],[800,800],[750,750],[900,900]]\n dz = [[0.001,0.3],[0.001,0.09],[0.001,0.03],[0.001,0.03],[0.001,0.02],[0.001,0.06],[0.001,0.05],[0.001,0.03]]\n alg = [[0,0],[0,0],[20000,0],[30000,0],[45000,0],[3000,0],[8000,0],[0,0]]\n\n returns:\n None, but saves figure to SAVEPATH\n\n \"\"\"\n\n spectra = pd.read_csv(FIELD_DATA_FNAME)\n\n # reformat feld spectra to match snicar resolution\n spectra = spectra[::10]\n\n # gather spectra for each surface type\n CIspec = spectra[spectra.columns.intersection(CIsites)]\n HAspec = spectra[spectra.columns.intersection(HAsites)]\n LAspec = spectra[spectra.columns.intersection(LAsites)]\n RAINspec = spectra[\"RAIN2\"]\n\n if PLOT_ARF:\n plt.plot(\n spectra.Wavelength[0:100], ARF_CI[0:100], marker=\"x\", label=\"clean ice ARF\"\n ),\n plt.plot(\n spectra.Wavelength[0:100],\n ARF_HA[0:100],\n marker=\"o\",\n linestyle=\"dashed\",\n label=\"algal ice ARF\",\n )\n plt.ylabel(\"Anitostropic Reflectance Factor\"), plt.xlabel(\"Wavelength (nm)\")\n plt.legend(loc=\"best\")\n plt.savefig(str(SAVEPATH + \"ARF.jpg\"), dpi=300)\n\n # define local function for calling snicar\n def simulate_albedo(rds, rho, dz, alg):\n\n params = c.namedtuple(\n \"params\",\n \"rho_layers, grain_rds, layer_type, dz,\\\n mss_cnc_glacier_algae, c_factor_GA, solzen\",\n )\n params.grain_rds = rds\n params.rho_layers = rho\n params.layer_type = [1, 1]\n params.dz = dz\n params.mss_cnc_glacier_algae = alg\n params.c_factor_GA = 20\n params.solzen = 40\n albedo, BBA = call_snicar(params)\n\n return albedo, BBA\n\n # set up output array\n # and call snicar with each set of params\n OutArray = np.zeros(shape=(len(fnames), 480))\n\n for i in np.arange(0, len(fnames), 1):\n\n albedo, BBA = simulate_albedo(rds[i], rho[i], dz[i], alg[i])\n if APPLY_ARF:\n if alg[i][0] > 5000:\n albedo[15:230] = albedo[15:230] * ARF_HA\n else:\n albedo[15:230] = albedo[15:230] * ARF_CI\n\n OutArray[i, :] = albedo\n\n # calculate mean absolute error for model vs measured spectrum\n error = []\n for i in np.arange(0, len(fnames), 1):\n error.append(\n abs(np.mean(spectra[fnames[i]].iloc[0:130] - (OutArray[i, 15:145])))\n )\n\n # plot figure\n fig, axes = plt.subplots(4, 2, figsize=(10, 10))\n\n if APPLY_ARF:\n ylabel = \"Reflectance\"\n PlotName = \"FieldvsMeasuredReflectance.jpg\"\n else:\n ylabel = \"Albedo\"\n PlotName = \"FieldvsMeasuredAlbedo.jpg\"\n\n axes[0, 0].plot(spectra.Wavelength, spectra[\"23_7_SB1\"], label=\"field\")\n axes[0, 0].plot(\n spectra.Wavelength, OutArray[0, 15:230], label=\"model\", linestyle=\"--\"\n )\n axes[0, 0].set_ylim(0, 1), axes[0, 0].set_xlim(350, 1800)\n axes[0, 0].text(\n 1400,\n 0.2,\n \"r_eff: {}\\nrho: {}\\ndz: {}\\nC-factor: 30\\nerror: {:.3f}\".format(\n rds[0][0], rho[0][0], dz[0][1], error[0]\n ),\n )\n axes[0, 0].text(400, 0.1, \"{} \\n{} cells/mL \".format(fnames[0], measured_cells[0]))\n axes[0, 0].set_ylabel(ylabel), axes[0, 0].set_xlabel(\"Wavelength (nm)\")\n axes[0, 0].legend(loc=\"best\")\n\n axes[0, 1].plot(spectra.Wavelength, spectra[\"14_7_SB6\"])\n axes[0, 1].plot(spectra.Wavelength, OutArray[1, 15:230], linestyle=\"--\")\n axes[0, 1].set_ylim(0, 1), axes[0, 1].set_xlim(350, 1800)\n axes[0, 1].text(\n 1450,\n 0.3,\n \"r_eff: {}\\nrho: {}\\ndz: {}\\nC-factor: 30\\nerror: {:.3f}\".format(\n rds[1][0], rho[1][0], dz[1][1], error[1]\n ),\n )\n axes[0, 1].text(400, 0.8, \"{}: \\n{} cells/mL\".format(fnames[1], measured_cells[1]))\n axes[0, 1].set_ylabel(ylabel), axes[0, 1].set_xlabel(\"Wavelength (nm)\")\n\n axes[1, 0].plot(spectra.Wavelength, spectra[\"14_7_SB9\"])\n axes[1, 0].plot(spectra.Wavelength, OutArray[2, 15:230], linestyle=\"--\")\n axes[1, 0].set_ylim(0, 1), axes[1, 0].set_xlim(350, 1800)\n axes[1, 0].text(\n 1400,\n 0.3,\n \"r_eff: {}\\nrho: {}\\ndz: {}\\nC-factor: 30\\nerror: {:.3f}\".format(\n rds[2][0], rho[2][0], dz[2][1], error[2]\n ),\n )\n axes[1, 0].text(400, 0.8, \"{}: \\n{} cells/mL\".format(fnames[2], measured_cells[2]))\n axes[1, 0].set_ylabel(ylabel), axes[1, 0].set_xlabel(\"Wavelength (nm)\")\n\n axes[1, 1].plot(spectra.Wavelength, spectra[\"14_7_SB1\"])\n axes[1, 1].plot(spectra.Wavelength, OutArray[3, 15:230], linestyle=\"--\")\n axes[1, 1].set_ylim(0, 1), axes[1, 1].set_xlim(350, 1800)\n axes[1, 1].text(\n 1400,\n 0.3,\n \"r_eff: {}\\nrho: {}\\ndz: {}\\nC-factor: 30\\nerror: {:.3f}\".format(\n rds[3][0], rho[3][0], dz[3][1], error[3]\n ),\n )\n axes[1, 1].text(400, 0.8, \"{}: \\n{} cells/mL\".format(fnames[3], measured_cells[3]))\n axes[1, 1].set_ylabel(ylabel), axes[1, 1].set_xlabel(\"Wavelength (nm)\")\n\n axes[2, 0].plot(spectra.Wavelength, spectra[\"22_7_SB5\"])\n axes[2, 0].plot(spectra.Wavelength, OutArray[4, 15:230], linestyle=\"--\")\n axes[2, 0].set_ylim(0, 1), axes[2, 0].set_xlim(350, 1800)\n axes[2, 0].text(\n 1400,\n 0.3,\n \"r_eff: {}\\nrho: {}\\ndz: {}\\nC-factor: 30\\nerror: {:.3f}\".format(\n rds[4][0], rho[4][0], dz[4][1], error[4]\n ),\n )\n axes[2, 0].text(400, 0.8, \"{}: \\n{} cells/mL\".format(fnames[4], measured_cells[4]))\n axes[2, 0].set_ylabel(ylabel), axes[2, 0].set_xlabel(\"Wavelength (nm)\")\n\n axes[2, 1].plot(spectra.Wavelength, spectra[\"14_7_SB2\"])\n axes[2, 1].plot(spectra.Wavelength, OutArray[5, 15:230], linestyle=\"--\")\n axes[2, 1].set_ylim(0, 1), axes[2, 1].set_xlim(350, 1800)\n axes[2, 1].text(\n 1400,\n 0.3,\n \"r_eff: {}\\nrho: {}\\ndz: {}\\nC-factor: 30\\nerror: {:.3f}\".format(\n rds[5][0], rho[5][0], dz[5][1], error[5]\n ),\n )\n axes[2, 1].text(400, 0.8, \"{}: \\n{} cells/mL\".format(fnames[5], measured_cells[5]))\n axes[2, 1].set_ylabel(ylabel), axes[2, 1].set_xlabel(\"Wavelength (nm)\")\n\n axes[3, 0].plot(spectra.Wavelength, spectra[\"22_7_SB3\"])\n axes[3, 0].plot(spectra.Wavelength, OutArray[6, 15:230], linestyle=\"--\")\n axes[3, 0].set_ylim(0, 1), axes[3, 0].set_xlim(350, 1800)\n axes[3, 0].text(\n 1400,\n 0.3,\n \"r_eff: {}\\nrho: {}\\ndz: {}\\nC-factor: 30\\nerror: {:.3f}\".format(\n rds[6][0], rho[6][0], dz[6][1], error[6]\n ),\n )\n axes[3, 0].text(400, 0.8, \"{}: \\n{} cells/mL\".format(fnames[6], measured_cells[6]))\n axes[3, 0].set_ylabel(ylabel), axes[3, 0].set_xlabel(\"Wavelength (nm)\")\n\n axes[3, 1].plot(spectra.Wavelength, RAINspec)\n axes[3, 1].plot(spectra.Wavelength, OutArray[7, 15:230], linestyle=\"--\")\n axes[3, 1].set_ylim(0, 1), axes[3, 1].set_xlim(350, 1800)\n axes[3, 1].text(\n 1400,\n 0.3,\n \"r_eff: {}\\nrho: {}\\ndz: {}\\nC-factor: 30\\nerror: {:.3f}\".format(\n rds[7][0], rho[7][0], dz[7][1], error[7]\n ),\n )\n axes[3, 1].text(400, 0.8, \"{}: \\n{} cells/mL\".format(fnames[1], measured_cells[1]))\n axes[3, 1].set_ylabel(ylabel), axes[3, 1].set_xlabel(\"Wavelength (nm)\")\n\n fig.tight_layout()\n plt.savefig(str(SAVEPATH + PlotName), dpi=300)\n\n return True\n\n\ndef build_LUT(\n cfactor,\n solzen,\n dz,\n densities,\n radii,\n algae,\n wavelengths,\n save_LUT,\n APPLY_ARF,\n ARF_CI,\n ARF_HA,\n LUT_PATH,\n):\n\n \"\"\"\n generates LUTs used to invert BioSNICAR in RISA project\n\n params:\n ice_rds: fixed effective bubble radius for solid ice layers (default = 525)\n ice dens: fixed density for solid ice layers (default = 894)\n zeniths: range of solar zenith angles to loop over\n dz: thickness of each vertical layer\n densities: densities for top layer. Lower layers predicted by exponential model\n algae: mass mixing ratio of algae in top layer\n wavelengths: wavelength range, default is np.arange(0.2, 5, 0.01)\n save_LUT: Boolean to toggle saving to npy file\n SAVEPATH: directory to save LUT\n\n returns:\n WCthickLUT: for each index position in the spectraLUT, this holds the WC\n thickness in the corresponding index position\n SpectraLUT: ND array containing 480element spectrum for each\n dens/alg/zen combination\n\n return spectraLUT\n\n\n \"\"\"\n LUT = []\n\n @dask.delayed\n def run_sims(cfactor, dens, rad, dz, alg, zen):\n\n params = c.namedtuple(\n \"params\",\n \"rho_layers, grain_rds, layer_type, c_factor_GA, dz, mss_cnc_glacier_algae, solzen\",\n )\n params.rho_layers = [916, dens]\n params.grain_rds = [rad, rad] # set equal to density\n params.layer_type = [1, 1]\n params.dz = [0.001, dz]\n params.mss_cnc_glacier_algae = [alg, 0]\n params.solzen = zen\n params.c_factor_GA = cfactor\n\n albedo, BBA = call_snicar(params)\n\n return albedo\n\n for x in np.arange(0, len(cfactor), 1):\n for z in np.arange(0, len(solzen), 1):\n for i in np.arange(0, len(densities), 1):\n for j in np.arange(0, len(radii), 1):\n for p in np.arange(0, len(dz), 1):\n for q in np.arange(0, len(algae), 1):\n\n albedo = run_sims(\n cfactor[x],\n densities[i],\n radii[j],\n dz[p],\n algae[q],\n solzen[z],\n )\n\n LUT.append(albedo)\n\n LUT = dask.compute(*LUT, num_workers=12)\n LUT = np.array(LUT).reshape(\n len(cfactor),\n len(solzen),\n len(densities),\n len(radii),\n len(dz),\n len(algae),\n len(wavelengths),\n )\n\n # move the ARF application to new loop because dask compute objets are immutable\n # i.e. modifications to albedo must be done post-compute\n if APPLY_ARF:\n for x in np.arange(0, len(cfactor), 1):\n for z in np.arange(0, len(solzen), 1):\n for i in np.arange(0, len(densities), 1):\n for j in np.arange(0, len(radii), 1):\n for p in np.arange(0, len(dz), 1):\n for q in np.arange(0, len(algae), 1):\n\n if algae[q] > 5000:\n\n LUT[x, z, i, j, p, q, 15:230] = (\n LUT[x, z, i, j, p, q, 15:230] * ARF_HA\n )\n\n else:\n LUT[x, z, i, j, p, q, 15:230] = (\n LUT[x, z, i, j, p, q, 15:230] * ARF_CI\n )\n\n if save_LUT:\n np.save(str(LUT_PATH + \"LUT.npy\"), LUT)\n\n return LUT\n\n\ndef inverse_model(\n FIELD_DATA_FNAME, LUT_PATH, SITES, DZ, DENSITIES, RADII, ZENS, ALGAE, SAVEPATH\n):\n \"\"\"\n function takes arrays of vals used to build LUT and runs a 2 step inversion.\n First, each spectrum in the LUT is compared to each field spectrum\n The parameters giving the smallest mean error are selected\n Then those parameters are fixed and the process repeats, only varying algal concentration\n This gives the parameter set that best simulates each field measurement\n\n \"\"\"\n # read in and reshape luts and field spectra\n field_data = pd.read_csv(FIELD_DATA_FNAME, index_col=None)\n field_spectra = field_data[::10]\n lut = np.load(str(LUT_PATH + \"LUT.npy\"))\n vis_start_idx = 15\n vis_end_idx = 55\n nir_start_idx = 55\n nir_end_idx = 230\n lut_nir = lut[:, :, :, :, :, nir_start_idx:nir_end_idx]\n lut_vis = lut[:, :, :, :, :, vis_start_idx:vis_end_idx]\n flat_nir_lut = lut_nir.reshape(\n len(ZENS) * len(DENSITIES) * len(RADII) * len(DZ) * len(ALGAE), 175\n )\n\n output = pd.DataFrame()\n retrieved_zen = []\n retrieved_density = []\n retrieved_radii = []\n retrieved_dz = []\n retrieved_algae = []\n names = []\n nir_errors = []\n vis_errors = []\n total_errors = []\n\n for (name, data) in field_spectra.iteritems():\n # filter to sites defined in config\n if name in SITES:\n names.append(name)\n\n # step 1: find params that match best in NIR\n error_array = np.sqrt(abs(flat_nir_lut**2 - np.array(data[40:]) ** 2))\n error_array = np.nan_to_num(\n error_array, nan=9999\n ) # protect agaiunst nans being interpreted as low error\n error_list = np.sum(error_array, axis=1)\n index = np.argmin(error_list)\n nir_errors.append(error_list[index])\n param_idx_phys = np.unravel_index(\n index, (len(ZENS), len(DENSITIES), len(RADII), len(DZ), len(ALGAE), 1)\n )\n\n # step 2: fix physical params and minimise error\n # in vis by varying algae only\n lut2 = lut_vis[\n param_idx_phys[0],\n param_idx_phys[1],\n param_idx_phys[2],\n param_idx_phys[3],\n :,\n :,\n ]\n\n np.sqrt(abs(flat_nir_lut**2 - np.array(data[40:]) ** 2))\n error_array = np.sqrt(\n abs(lut2**2 - np.array(data[vis_start_idx:vis_end_idx]) ** 2)\n )\n error_list = np.sum(error_array, axis=1)\n index = np.argmin(error_list)\n vis_errors.append(error_list[index])\n param_idx_alg = np.unravel_index(index, [1, 1, 1, 1, len(ALGAE), 1])\n\n # step 3: organize out data\n retrieved_zen.append(ZENS[param_idx_phys[0]])\n retrieved_density.append(DENSITIES[param_idx_phys[1]])\n retrieved_radii.append(RADII[param_idx_phys[2]])\n retrieved_dz.append(DZ[param_idx_phys[3]])\n retrieved_algae.append(ALGAE[param_idx_alg[4]])\n\n total_error = abs(\n lut[\n param_idx_phys[0],\n param_idx_phys[1],\n param_idx_phys[2],\n param_idx_phys[3],\n param_idx_alg[4],\n vis_start_idx:nir_end_idx,\n ]\n - data\n )\n total_errors.append(np.mean(total_error))\n\n output[\"fname\"] = names\n output[\"solzen\"] = retrieved_zen\n output[\"density\"] = retrieved_density\n output[\"radii\"] = retrieved_radii\n output[\"dz\"] = retrieved_dz\n output[\"algae\"] = retrieved_algae\n output[\"nir_error\"] = nir_errors\n output[\"vis_error\"] = vis_errors\n output[\"total_error\"] = total_errors\n\n output.to_csv(str(SAVEPATH + \"inverse_model_output.csv\"))\n\n return output\n\n\ndef isolate_biological_effect(FIELD_DATA_FNAME, CIsites, LAsites, HAsites, SAVEPATH):\n\n \"\"\"\n This function estimates the albedo reduction resulting from the ice physical changes\n versus the biological growth.\n\n Some nuance to the interpretation because the ce surface likely would not\n degrade to the same extent without the algal bloom.\n\n \"\"\"\n\n # read in spectral database\n spectra = pd.read_csv(FIELD_DATA_FNAME)\n\n # reformat feld spectra to match snicar resolution\n spectra = spectra[::10]\n CIspec = spectra[spectra.columns.intersection(CIsites)]\n HAspec = spectra[spectra.columns.intersection(HAsites)]\n LAspec = spectra[spectra.columns.intersection(LAsites)]\n meanCI = CIspec.mean(axis=1)\n meanHA = HAspec.mean(axis=1)\n meanLA = LAspec.mean(axis=1)\n\n # define local function for calling snicar\n def simulate_albedo(rds, rho, dz, alg):\n params = c.namedtuple(\n \"params\",\n \"rho_layers, grain_rds, layer_type, dz, mss_cnc_glacier_algae, solzen\",\n )\n params.grain_rds = rds\n params.rho_layers = rho\n params.layer_type = [1, 1]\n params.dz = dz\n params.mss_cnc_glacier_algae = alg\n params.solzen = 53\n albedo, BBA = call_snicar(params)\n return albedo, BBA\n\n # call snicar to generat esimulated spectrum for LA and HA using predetermined params\n\n SNICARalbedoLA, BBA = simulate_albedo([800, 800], [800, 800], [0.001, 0.1], [0, 0])\n SNICARalbedoHA, BBA = simulate_albedo([900, 900], [800, 800], [0.001, 0.08], [0, 0])\n SNICARalbedoLA = SNICARalbedoLA[15:230]\n SNICARalbedoHA = SNICARalbedoHA[15:230]\n\n # plot figure\n x = np.arange(350, 2500, 10)\n fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 5))\n ax1.plot(x, meanCI, linestyle=\"--\", alpha=0.4, label=\"Clean ice (mean)\")\n ax1.plot(x, meanLA, linestyle=\"-.\", alpha=0.4, label=\"Algal ice (mean)\")\n ax1.plot(\n x, SNICARalbedoLA, linestyle=\"dotted\", alpha=0.4, label=\"Clean ice (model)\"\n )\n ax1.fill_between(x, meanCI, SNICARalbedoLA, alpha=0.2)\n ax1.fill_between(x, SNICARalbedoLA, meanLA, color=\"k\", alpha=0.2)\n ax1.set_xlim(350, 1500), ax1.legend(loc=\"best\")\n ax1.set_ylabel(\"Albedo\"), ax1.set_xlabel(\"Wavelength (nm)\")\n\n ax2.plot(x, meanCI, linestyle=\"--\", alpha=0.4, label=\"Clean ice (mean)\")\n ax2.plot(x, meanHA, linestyle=\"-.\", alpha=0.4, label=\"Algal ice (mean)\")\n ax2.plot(\n x, SNICARalbedoHA, linestyle=\"dotted\", alpha=0.4, label=\"Clean ice (model)\"\n )\n ax2.fill_between(x, meanCI, SNICARalbedoHA, alpha=0.2)\n ax2.fill_between(x, SNICARalbedoHA, meanHA, color=\"k\", alpha=0.2)\n ax2.set_xlim(350, 1500), ax2.legend(loc=\"best\")\n ax2.set_ylabel(\"Albedo\"), ax2.set_xlabel(\"Wavelength (nm)\")\n fig.tight_layout()\n plt.savefig(str(SAVEPATH + \"/BiovsPhysEffect.jpg\"), dpi=300)\n\n # define incoming to calculate broadband albedo\n incoming = xr.open_dataset(\n \"/home/joe/Code/BioSNICAR_GO_PY/Data/Mie_files/480band/fsds/swnb_480bnd_sas_clr_SZA60.nc\"\n )\n incoming = incoming[\"flx_frc_sfc\"].values\n incoming = incoming[15:230]\n\n # calculate broadband albedo of each case\n LA_BBA = np.sum(meanLA * incoming) / np.sum(incoming)\n HA_BBA = np.sum(meanHA * incoming) / np.sum(incoming)\n CI_BBA = np.sum(meanCI * incoming) / np.sum(incoming)\n CI2_BBA_LA = np.sum(SNICARalbedoLA * incoming) / np.sum(incoming)\n CI2_BBA_HA = np.sum(SNICARalbedoHA * incoming) / np.sum(incoming)\n\n # calculate change due to bio/phys as BBA difference\n delAbioLA = CI2_BBA_LA - LA_BBA\n delAphysLA = CI_BBA - CI2_BBA_LA\n delAbioHA = CI2_BBA_HA - HA_BBA\n delAphysHA = CI_BBA - CI2_BBA_HA\n\n return delAbioLA, delAphysLA, delAbioHA, delAphysHA\n\n\ndef run_best_params(\n SAVEPATH,\n ALL_FIELD_SAMPLES,\n FIELD_DATA_FNAME,\n CI_SITES,\n LA_SITES,\n HA_SITES,\n WEIGHT,\n CLEAN,\n):\n \"\"\"\n function calls out to find_best_params\n \"\"\"\n ResultArray = np.zeros(shape=(len(ALL_FIELD_SAMPLES), 6))\n\n for i in np.arange(0, len(ALL_FIELD_SAMPLES), 1):\n\n fn = ALL_FIELD_SAMPLES[i]\n Results = find_best_params(\n FIELD_DATA_FNAME, fn, CI_SITES, LA_SITES, HA_SITES, WEIGHT, CLEAN\n )\n Results = np.array(Results)\n best_idx = Results[:, 1].argmin()\n best_params = Results[best_idx, 0]\n best_error = Results[best_idx, 1]\n best_dens, best_rds, best_dz, best_alg, best_zen = zip(best_params)\n ResultArray[i, :] = (\n np.array(best_dens),\n np.array(best_rds),\n np.array(best_dz),\n np.array(best_alg),\n np.array(best_zen),\n np.array(best_error),\n )\n\n Out = pd.DataFrame(\n data=ResultArray, columns=[\"dens\", \"rds\", \"dz\", \"alg\", \"zen\", \"spec_err\"]\n )\n Out.index = ALL_FIELD_SAMPLES\n Out.to_csv(str(SAVEPATH + \"retrieved_params.csv\"))\n\n return True\n\n\ndef find_best_params(\n FIELD_DATA_FNAME, sampleID, CIsites, LAsites, HAsites, weight, clean=True\n):\n\n \"\"\"\n This function will return the SNICAR parameter set that provides the\n best approximation to a given field spectrum.\n\n \"\"\"\n\n spectra = pd.read_csv(FIELD_DATA_FNAME)\n spectra = spectra[::10]\n\n CIspec = spectra[spectra.columns.intersection(CIsites)]\n HAspec = spectra[spectra.columns.intersection(HAsites)]\n LAspec = spectra[spectra.columns.intersection(LAsites)]\n\n if sampleID == \"CImean\":\n field_spectrum = CIspec.mean(axis=1)\n elif sampleID == \"HAmean\":\n field_spectrum = HAspec.mean(axis=1)\n elif sampleID == \"LAmean\":\n field_spectrum = LAspec.mean(axis=1)\n elif sampleID == \"RAIN\":\n field_spectrum = spectra[\"RAIN2\"]\n else:\n field_spectrum = spectra[sampleID]\n\n # calculate 2BDA index of field spectrum\n BDA2idx = np.array(field_spectrum)[36] / np.array(field_spectrum)[31]\n\n dens = [550, 600, 650, 700, 750, 800, 850]\n dz = [0.02, 0.03, 0.04, 0.05, 0.06, 0.08, 0.1, 0.2]\n rds = [600, 700, 800, 900, 1000]\n alg = [0, 2500, 5000, 7500, 10000, 15000, 20000, 25000, 30000, 35000, 40000, 45000]\n c_factors = [10, 20, 30]\n solzen = [40, 45, 50]\n\n @dask.delayed\n def run_sims(i, j, k, p, q, z):\n\n params = c.namedtuple(\n \"params\",\n \"rho_layers, grain_rds, layer_type, dz, mss_cnc_glacier_algae, c_factor_GA, solzen\",\n )\n params.rho_layers = [i, i]\n params.grain_rds = [j, j]\n params.layer_type = [1, 1]\n params.dz = [0.001, k]\n params.mss_cnc_glacier_algae = [p, 0]\n params.c_factor_GA = c_factors[q]\n params.solzen = z\n\n albedo, BBA = call_snicar(params)\n\n error_vis = np.mean(abs(albedo[15:55] - field_spectrum[0:40]))\n error_nir = np.mean(abs(albedo[55:100] - field_spectrum[40:85]))\n error = ((error_vis * weight) + error_nir) / (1 + weight)\n\n params = (i, j, k, p, z)\n out = (params, error)\n\n return out\n\n Out = []\n # now use the reduced LUT to call snicar and obtain best matching spectrum\n for i in dens:\n for j in rds:\n for k in dz:\n for p in alg:\n for z in solzen:\n out = run_sims(i, j, k, p, z)\n Out.append(out)\n\n Result = dask.compute(*Out, num_workers=12)\n\n return Result\n\n\ndef BDA2_of_field_samples():\n\n \"\"\"\n 2DBA index calculated from field samples after field spectra are averaged over S2 band 4 and 5 wavelengths\n weighted by the sensor spectral response function for each band. The index is then calculated as B5/B4\n and the cell concentration predicted using Wang et al's (2018) conversion equation.\n\n \"\"\"\n\n spectra = pd.read_csv(\n \"/home/joe/Code/Remote_Ice_Surface_Analyser/Training_Data/HCRF_master_16171819.csv\"\n )\n\n # reformat LUT: flatten LUT from 3D to 2D array with one column per combination\n # of RT params, one row per wavelength\n\n responsefunc = pd.read_csv(\n \"/home/joe/Code/Remote_Ice_Surface_Analyser/S2SpectralResponse.csv\"\n )\n func04 = responsefunc[\"B4\"].loc[\n (responsefunc[\"SR_WL\"] > 650) & (responsefunc[\"SR_WL\"] <= 680)\n ]\n func05 = responsefunc[\"B5\"].loc[\n (responsefunc[\"SR_WL\"] > 698) & (responsefunc[\"SR_WL\"] <= 713)\n ]\n\n filenames = []\n Idx2DBAList = []\n prd2DBAList = []\n Idx2DBA_S2List = []\n prd2DBA_S2List = []\n Idx2DBA_Ideal_List = []\n prd2DBA_Ideal_List = []\n\n for i in np.arange(0, len(spectra.columns), 1):\n\n if i != \"Wavelength\":\n\n colname = spectra.columns[i]\n spectrum = np.array(spectra[colname])\n\n B04 = np.mean(spectrum[300:330] * func04)\n B05 = np.mean(spectrum[348:363] * func05)\n Idx2DBA = spectrum[355] / spectrum[315]\n prd2DBA = 10e-35 * Idx2DBA * np.exp(87.015 * Idx2DBA)\n Idx2DBA_S2 = B05 / B04\n prd2DBA_S2 = 10e-35 * Idx2DBA_S2 * np.exp(87.015 * Idx2DBA_S2)\n Idx2DBA_Ideal = spectrum[360] / spectrum[330]\n prd2DBA_Ideal = 10e-35 * Idx2DBA_Ideal * np.exp(87.015 * Idx2DBA_Ideal)\n\n filenames.append(colname)\n Idx2DBAList.append(Idx2DBA)\n prd2DBAList.append(prd2DBA)\n Idx2DBA_S2List.append(Idx2DBA_S2)\n prd2DBA_S2List.append(prd2DBA_S2)\n Idx2DBA_Ideal_List.append(Idx2DBA_Ideal)\n prd2DBA_Ideal_List.append(prd2DBA_Ideal)\n\n Out = pd.DataFrame()\n Out[\"filename\"] = filenames\n Out[\"2DBAIdx\"] = Idx2DBAList\n Out[\"2DBAPrediction\"] = prd2DBAList\n Out[\"2DBA_S2Idx\"] = Idx2DBA_S2List\n Out[\"2DBA_S2Prediction\"] = prd2DBA_S2List\n Out[\"2DBAIdx_Ideal\"] = Idx2DBA_Ideal_List\n Out[\"2DBAPrediction_Ideal\"] = prd2DBA_Ideal_List\n\n return Out\n\n\ndef compare_predicted_and_measured(SAVEPATH, path_to_metadata):\n\n ## imports and data organisation\n import numpy as np\n import pandas as pd\n import statsmodels.api as sm\n\n DF = pd.read_csv(path_to_metadata)\n\n measured_cells = DF[\"measured_cells\"]\n modelled_cells = DF[\"algae_cells_inv_model_S2\"]\n BDA2_cells = DF[\"cells_BDA2_centre_wang\"]\n BDA2_idx = DF[\"BDA2_centre\"]\n\n ## regression models\n\n # Ordinary least squares regression\n model1 = sm.OLS(modelled_cells, measured_cells).fit()\n summary1 = model1.summary()\n test_x = [\n 0,\n 1000,\n 5000,\n 7500,\n 10000,\n 12500,\n 15000,\n 17500,\n 20000,\n 25000,\n 30000,\n 35000,\n 40000,\n 50000,\n ]\n ypred1 = model1.predict(test_x)\n\n # regress measured cells against band index\n # use this to give predictive linear model\n\n BDA2_PredModel = sm.OLS(measured_cells, sm.add_constant(BDA2_idx)).fit()\n BDA2_PredModel_r2 = np.round(BDA2_PredModel.rsquared, 3)\n BDA2_PredModel_y = BDA2_PredModel.predict(sm.add_constant(BDA2_idx))\n\n # regress BDA2 predicted cells against measured cells\n model2 = sm.OLS(BDA2_PredModel_y, measured_cells).fit()\n summary2 = model2.summary()\n test_x = [\n 0,\n 1000,\n 5000,\n 7500,\n 10000,\n 12500,\n 15000,\n 17500,\n 20000,\n 25000,\n 30000,\n 35000,\n 40000,\n 50000,\n ]\n ypred2 = model2.predict(test_x)\n\n # multipanel figure\n fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(8, 8))\n\n ax1.plot(\n measured_cells, color=\"k\", marker=\"x\", linestyle=\"None\", label=\"field-measured\"\n )\n ax1.plot(\n modelled_cells,\n color=\"b\",\n marker=\"o\",\n markerfacecolor=\"None\",\n alpha=0.6,\n linestyle=\"None\",\n label=\"RTM model prediction\",\n )\n ax1.plot(\n BDA2_PredModel_y,\n color=\"r\",\n marker=\"^\",\n markerfacecolor=\"r\",\n alpha=0.3,\n linestyle=\"None\",\n label=\"new 2BDA model prediction\",\n )\n ax1.set_ylabel(\"Algal concentration (cells/mL)\")\n ax1.set_xticks(range(len(measured_cells)))\n ax1.set_xticklabels([])\n ax1.legend(loc=\"upper left\")\n ax1.set_xlabel(\"Individual samples\")\n ax1.set_ylim(0, 65000)\n\n ax2.scatter(\n measured_cells,\n modelled_cells,\n marker=\"o\",\n facecolor=\"None\",\n color=\"b\",\n alpha=0.6,\n label=\"RTM\\nr$^2$ = {}\\np = {}\".format(\n np.round(model1.rsquared, 3), np.round(model1.pvalues[0], 8)\n ),\n )\n ax2.plot(test_x, ypred1, linestyle=\"dotted\", color=\"b\", alpha=0.6)\n ax2.scatter(\n measured_cells,\n BDA2_PredModel_y,\n marker=\"^\",\n facecolor=\"r\",\n color=\"r\",\n alpha=0.3,\n label=\"2BDA\\nr$^2$ = {}\\np = {}\".format(\n np.round(model2.rsquared, 3), np.round(model2.pvalues[0], 10)\n ),\n )\n ax2.plot(test_x, ypred2, linestyle=\"dashed\", color=\"r\", alpha=0.3)\n ax2.set_ylabel(\"Algal concentration,\\n cells/mL (field)\")\n ax2.set_xlabel(\"Algal concentration,\\n clls/mL (predicted by model)\")\n ax2.set_xlim(0, 50000), ax2.set_ylim(0, 60000)\n\n ax2.legend(loc=\"upper left\")\n\n fig.tight_layout()\n\n SAVEPATH = \"/home/joe/Code/Remote_Ice_Surface_Analyser/Manuscript/Figures\"\n fig.savefig(str(SAVEPATH + \"/measured_modelled_algae.png\"), dpi=300)\n\n return\n", "meta": {"hexsha": "69bb6a469de95c5ac5542ff6e6d2c1ef7c8dbdd8", "size": 30835, "ext": "py", "lang": "Python", "max_stars_repo_path": "experiments/utils.py", "max_stars_repo_name": "jmcook1186/biosnicar-py", "max_stars_repo_head_hexsha": "7a2e224f7a30c746291c718fcddb908575f0f3c1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "experiments/utils.py", "max_issues_repo_name": "jmcook1186/biosnicar-py", "max_issues_repo_head_hexsha": "7a2e224f7a30c746291c718fcddb908575f0f3c1", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2022-03-28T14:31:07.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-28T14:31:51.000Z", "max_forks_repo_path": "experiments/utils.py", "max_forks_repo_name": "jmcook1186/biosnicar-py", "max_forks_repo_head_hexsha": "7a2e224f7a30c746291c718fcddb908575f0f3c1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.1559139785, "max_line_length": 113, "alphanum_fraction": 0.595654289, "include": true, "reason": "import numpy,import statsmodels", "num_tokens": 9333, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5039061705290805, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.19395960471703508}} {"text": "# -*- coding: utf-8 -*-\n\"\"\"\n============================================================================\nGenerating simple pulses and pulse trains\n============================================================================\nThis example shows how to build and visualize basic types of stimuli such as\n:py:class:`~pulse2percept.stimuli.MonophasicPulse`,\n:py:class:`~pulse2percept.stimuli.BiphasicPulse` or a\n:py:class:`~pulse2percept.stimuli.PulseTrain` for a given implant.\n\nA monophasic pulse has a single phase and can be either anodic (by definition:\nhas a positive current amplitude) or cathodic (negative current amplitude).\n\nA biphasic pulse is generally charge-balanced for safety reasons (i.e., the\nnet current must sum to zero over time) and defined as either anodic-first\nor cathodic-first.\n\nMultiple pulses can form a pulse train.\n\n\n\"\"\"\n# sphinx_gallery_thumbnail_number = 7\n\n##############################################################################\n# Simplest stimulus\n# ---------------------\n# :py:class:`~pulse2percept.stimuli.Stimulus` is the base class to generate\n# different types of stimuli. The simplest way to instantiate a Stimulus is\n# to pass a scalar value which is interpreted as the current amplitude\n# for a single electrode.\n\n# Let's start by importing necessary modules\nfrom pulse2percept.stimuli import (MonophasicPulse, BiphasicPulse,\n Stimulus, PulseTrain)\n\nimport numpy as np\n\nstim = Stimulus(10)\n\n##############################################################################\n# Parameters we don't specify will take on default values. We can inspect\n# all current model parameters as follows:\n\nprint(stim)\n\n##############################################################################\n# This command also reveals a number of other parameters to set, such as:\n#\n# * ``electrodes``: We can either specify the electrodes in the source\n# or within the stimulus. If none are specified it looks up the source\n# electrode.\n#\n# * ``metadata``: Optionally we can include metadata to the stimulus we\n# generate as a dictionary.\n#\n# To change parameter values, either pass them directly to the constructor\n# above or set them by hand, like this:\n\nstim.metadata = {'name': 'A simple stimulus', 'date': '2020-01-01'}\nstim\n\n##############################################################################\n# A monophasic pulse\n# --------------------\n# We can specify the arguments of the monophasic pulse as follows:\n\npulse_type = 'anodic' # anodic: positive amplitude, cathodic: negative\npulse_dur = 4.6 / 1000 # pulse duration in seconds\ndelay_dur = 10.0 / 1000 # pulse delivered after delay in seconds\nstim_dur = 0.5 # stimulus duration in seconds (pulse padded with zeros)\ntime_step = 0.1 / 1000 # temporal sampling step in seconds\n\n##############################################################################\n# The sampling step ``time_step`` defines at which temporal resolution the\n# stimulus is resolved. In the above example, the time step is 0.1 ms.\n#\n# By calling Stimulus with a ``MonophasicPulse`` source, we can generate a\n# single pulse:\nmonophasic_stim = Stimulus(MonophasicPulse(ptype=pulse_type, pdur=pulse_dur,\n delay_dur=delay_dur,\n stim_dur=stim_dur,\n tsample=time_step))\nprint(monophasic_stim)\n\n##############################################################################\n# Here, ``data`` is a 2D NumPy array where rows are electrodes and columns are\n# the points in time. Since we did not specify any electrode names in\n# ``MonophasicPulse``, the number of electrodes is inferred from the input\n# source type. There is only one row in the above example, denoting a single\n# electrode.\n#\n# By default, the :py:class:`~pulse2percept.stimuli.MonophasicPulse` object\n# automatically assumes a current amplitude of 1 uA.\n\n##############################################################################\n# We can visualize the generated pulse using Matplotlib:\n\nimport matplotlib.pyplot as plt\nfig, ax = plt.subplots(figsize=(8, 5))\nax.plot(monophasic_stim.time, monophasic_stim.data[0, :])\nax.set_xlabel('Time (s)')\nax.set_ylabel('Amplitude ($\\mu$A)')\n\n###############################################################################\n# A biphasic pulse\n# ------------------\n# Similarly, we can generate a biphasic pulse by changing the source of the\n# stimulus to :py:class:`~pulse2percept.stimuli.BiphasicPulse`. This time\n# parameter ``ptype`` can either be 'anodicfirst' or 'cathodicfirst'.\n\n# set relevant parameters\npulse_type = 'cathodicfirst'\nbiphasic_stim = Stimulus(BiphasicPulse(ptype=pulse_type, pdur=pulse_dur,\n tsample=time_step))\n\n###############################################################################\n# If we visualize this stimulus, we can see the difference between a monophasic\n# and biphasic pulse:\n\n# Create a figure with two subplots\nfig, axes = plt.subplots(1, 2, figsize=(8, 5))\n\n# First, plot monophasic pulse\naxes[0].plot(monophasic_stim.time, monophasic_stim.data[0])\nax.set_xlabel('Time (s)')\nax.set_ylabel('Amplitude ($\\mu$A)')\n\n# Second, plot biphasic pulse\naxes[1].plot(biphasic_stim.time, biphasic_stim.data[0])\nax.set_xlabel('Time (s)')\nax.set_ylabel('Amplitude ($\\mu$A)')\n\n###############################################################################\n# Changing pulse amplitude\n# ----------------------------------\n# For any given pulse, we can modify the amplitude by indexing into the ``data``\n# row that corresponds to the desired electrode. In the above example, we only\n# have one electrode (index 0).\n# Let's say we want the amplitude of the monophasic pulse to be 10 micro amps.\n# We have two options: either change the values of the ``data`` array directly:\n\n# get the data structure by indexing the electrode at 0\nmonophasic_stim.data[0] = 10 * monophasic_stim.data[0]\nprint(monophasic_stim)\n\n###############################################################################\n# Or we can create a NumPy array and assign that to the data structure of the\n# stimulus:\n\n# recreate the same stimulus with an amplitude 1 microAmps.\nmonophasic_stim = Stimulus(MonophasicPulse(ptype='anodic', pdur=pulse_dur,\n delay_dur=delay_dur,\n stim_dur=stim_dur,\n tsample=time_step))\nmonophasic_stim.data[0] = 10 * np.ones_like(monophasic_stim.data[0])\nprint(monophasic_stim)\n\n###############################################################################\n# Similarly, let's say we want the cathodic part of the biphasic pulse to be -5\n# micro amps, and the anodic part to be +20 micro amps (note that this stimulus\n# wouldn't be charge-balanced).\n#\n# We first need to find the halfway point where the current switches from\n# cathodic to anodic. To do that we first get the length of the pulse by\n# indexing the single electrode at 0\nlength = len(biphasic_stim.data[0])\nprint(length)\n\n# Find the halfway where cathodic turns into anodic pulse\nhalf = int(len(biphasic_stim.data[0]) / 2)\nprint(\"Halfway index is\", half)\n\n# change the first half of the pulse to be 5 times larger\nbiphasic_stim.data[0][0:half] = 5 * biphasic_stim.data[0][0:half]\n\n# change the second half to be 20 times larger\nbiphasic_stim.data[0][half:length] = 20 * biphasic_stim.data[0][half:length]\n\n###############################################################################\n# Let's plot the monophasic and biphasic pulses again:\n\n# Create a figure with two subplots\nfig, axes = plt.subplots(ncols=2, figsize=(8, 5))\n\n# First, plot monophasic pulse\naxes[0].plot(monophasic_stim.time, monophasic_stim.data[0])\naxes[0].set_xlabel('Time (s)')\naxes[0].set_ylabel('Amplitude ($\\mu$A)')\n# Second, plot biphasic pulse\naxes[1].plot(biphasic_stim.time, biphasic_stim.data[0])\naxes[1].set_xlabel('Time (s)')\naxes[1].set_ylabel('Amplitude ($\\mu$A)')\nfig.tight_layout()\n\n\n###############################################################################\n# Generating standard pulse trains\n# ----------------------------------\n# The easiest way to generate a pulse train is to use the\n# :py:class:`~pulse2percept.stimuli.PulseTrain` object, which allows for\n# various stimulus attributes to be specified:\n\ntime_step = 0.1 / 1000 # temporal sampling in seconds\nfreq = 20 # frequency in Hz\namp = 100 # maximum amplitude of the pulse train in microAmps\ndur = 0.2 # total duration of the pulse train in seconds\npulse_type = 'cathodicfirst' # whether the first phase is positive or negative\npulse_order = 'gapfirst' # whether the train starts with gap or a pulse.\n\n# Define the pulse train with given parameters\nptrain = PulseTrain(tsample=time_step,\n freq=freq,\n dur=dur,\n amp=amp,\n pulsetype=pulse_type,\n pulseorder=pulse_order)\n\n# Create a new stimulus where the pulse train is the source\nptrain_stim = Stimulus(ptrain)\n\n# Visualize:\nfig, ax = plt.subplots(figsize=(8, 5))\nax.plot(ptrain_stim.time, ptrain_stim.data[0, :])\nax.set_xlabel('Time (s)')\nax.set_ylabel('Amplitude ($\\mu$A)')\n\n###############################################################################\n# Alternatively, we are free to specify a discrete set of points in time and\n# the current amplitude we would like to apply at those times.\n#\n# It is important to note that the :py:class:`~pulse2percept.stimuli.Stimulus`\n# object will linearly interpolate between specified time points.\n# For example, the following generates a simple sawtooth stimulus:\n\nstim = Stimulus([[0, -10, 10, -10, 10, -10, 0]],\n time=[0, 0.1, 0.3, 0.5, 0.7, 0.9, 1.0])\nfig, ax = plt.subplots(figsize=(8, 5))\nax.plot(stim.time, stim.data[0, :])\nax.set_xlabel('Time (s)')\nax.set_ylabel('Amplitude ($\\mu$A)')\n\n##############################################################################\n# For a biphasic pulse, we need to specify both the rising edge (low-to-high\n# transition) and falling edge (high-to-low transition) of the signal:\n\nstim = Stimulus([[0, 0, 10, 10, 0, 0]],\n time=[0, 0.1, 0.1, 0.2, 0.2, 1.0])\nfig, ax = plt.subplots(figsize=(8, 5))\nax.plot(stim.time, stim.data[0, :])\nax.set_xlabel('Time (s)')\nax.set_ylabel('Amplitude ($\\mu$A)')\n\n##############################################################################\n# We can thus generate arbitrarily complex stimuli:\n\nstim = Stimulus([[0, 0, 20, 20, -5, -5, 0, 0, 0, 20, 20, -5, -5, 0, 0]],\n time=[0, 0.1, 0.1, 0.2, 0.2, 0.6, 0.6, 1.0, 1.1, 1.1, 1.2, 1.2, 1.6, 1.6, 2.0])\nfig, ax = plt.subplots(figsize=(8, 5))\nax.plot(stim.time, stim.data[0, :])\nax.set_xlabel('Time (s)')\nax.set_ylabel('Amplitude ($\\mu$A)')\n", "meta": {"hexsha": "e889bcfb0a81156b932dca193f562661d5f59897", "size": 10828, "ext": "py", "lang": "Python", "max_stars_repo_path": "examples/stimuli/plot_pulses.py", "max_stars_repo_name": "garethgeorge/pulse2percept", "max_stars_repo_head_hexsha": "14b85a7b7acfd740e8a2ac4a471aa8149a5152c5", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-09-02T00:13:11.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-07T07:34:21.000Z", "max_issues_repo_path": "examples/stimuli/plot_pulses.py", "max_issues_repo_name": "NathanWoo/pulse2percept", "max_issues_repo_head_hexsha": "2a1e15159af234fb247092b88a465b7bdffd21db", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "examples/stimuli/plot_pulses.py", "max_forks_repo_name": "NathanWoo/pulse2percept", "max_forks_repo_head_hexsha": "2a1e15159af234fb247092b88a465b7bdffd21db", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.3282442748, "max_line_length": 95, "alphanum_fraction": 0.5966014038, "include": true, "reason": "import numpy", "num_tokens": 2643, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5039061705290805, "lm_q2_score": 0.38491214448393346, "lm_q1q2_score": 0.19395960471703505}} {"text": "from __future__ import (absolute_import, division, print_function, unicode_literals)\nimport numpy as np\nimport multiprocessing\nfrom functools import partial\n\nfrom ..pair_counters.npairs_xy_z import _npairs_xy_z_process_args\nfrom ..pair_counters.mesh_helpers import _set_approximate_cell_sizes, _cell1_parallelization_indices\nfrom ..pair_counters.rectangular_mesh import RectangularDoubleMesh\nfrom .velocity_marked_npairs_3d import _velocity_marked_npairs_3d_process_weights\nfrom .engines import velocity_marked_npairs_xy_z_engine\n\n__author__ = ('Duncan Campbell', 'Andrew Hearin')\n\n\n__all__ = ('velocity_marked_npairs_xy_z', )\n\n\ndef velocity_marked_npairs_xy_z(sample1, sample2, rp_bins, pi_bins, period=None,\n weights1=None, weights2=None, weight_func_id=1, num_threads=1,\n approx_cell1_size=None, approx_cell2_size=None):\n r\"\"\"\n Calculate the number of velocity weighted pairs\n with separations greater than or equal to\n :math:`r_{\\perp}` and :math:`r_{\\parallel}`, :math:`W(>r_{\\perp},>r_{\\parallel})`.\n\n :math:`r_{\\perp}` and :math:`r_{\\parallel}` are defined wrt the z-direction.\n\n The weight given to each pair is determined by the weights for a pair,\n :math:`w_1`, :math:`w_2`, and a user-specified \"velocity weighting function\", indicated\n by the ``weight_func_id`` parameter, :math:`f(w_1,w_2)`.\n\n Parameters\n ----------\n sample1 : array_like\n Npts1 x 3 numpy array containing 3-D positions of points.\n See the :ref:`mock_obs_pos_formatting` documentation page, or the\n Examples section below, for instructions on how to transform\n your coordinate position arrays into the\n format accepted by the ``sample1`` and ``sample2`` arguments.\n Length units are comoving and assumed to be in Mpc/h, here and throughout Halotools.\n\n sample2 : array_like\n Npts2 x 3 array containing 3-D positions of points.\n\n rp_bins : array_like\n array of boundaries defining the radial bins perpendicular to the LOS in which\n pairs are counted.\n Length units are comoving and assumed to be in Mpc/h, here and throughout Halotools.\n\n pi_bins : array_like\n array of boundaries defining the bins parallel to the LOS in which\n pairs are counted.\n Length units are comoving and assumed to be in Mpc/h, here and throughout Halotools.\n\n period : array_like, optional\n Length-3 sequence defining the periodic boundary conditions\n in each dimension. If you instead provide a single scalar, Lbox,\n period is assumed to be the same in all Cartesian directions.\n If set to None (the default option), PBCs are set to infinity.\n Length units are comoving and assumed to be in Mpc/h, here and throughout Halotools.\n\n weights1 : array_like, optional\n Either a 1-D array of length *Npts1*, or a 2-D array of length *Npts1* x *N_weights*,\n containing the weights used for the weighted pair counts. If this parameter is\n None, the weights are set to np.ones(*(Npts1,N_weights)*).\n\n weights2 : array_like, optional\n Either a 1-D array of length *Npts2*, or a 2-D array of length *Npts2* x *N_weights*,\n containing the weights used for the weighted pair counts. If this parameter is\n None, the weights are set to np.ones(*(Npts2,N_weights)*).\n\n weight_func_id : int, optional\n velocity weighting function integer ID. Each weighting function requires a specific\n number of weights per point, *N_weights*. See the Notes for a description of\n available weighting functions.\n\n num_threads : int, optional\n Number of threads to use in calculation, where parallelization is performed\n using the python ``multiprocessing`` module. Default is 1 for a purely serial\n calculation, in which case a multiprocessing Pool object will\n never be instantiated. A string 'max' may be used to indicate that\n the pair counters should use all available cores on the machine.\n\n approx_cell1_size : array_like, optional\n Length-3 array serving as a guess for the optimal manner by how points\n will be apportioned into subvolumes of the simulation box.\n The optimum choice unavoidably depends on the specs of your machine.\n Default choice is to use Lbox/10 in each dimension,\n which will return reasonable result performance for most use-cases.\n Performance can vary sensitively with this parameter, so it is highly\n recommended that you experiment with this parameter when carrying out\n performance-critical calculations.\n\n approx_cell2_size : array_like, optional\n Analogous to ``approx_cell1_size``, but for sample2. See comments for\n ``approx_cell1_size`` for details.\n\n Returns\n -------\n w1N_pairs : numpy.array\n 2-D array of shape *(Nrp_bins,Npi_bins)* containing the weighted number counts\n of pairs. The exact values depend on ``weight_func_id``\n (which weighting function was chosen).\n\n w2N_pairs : numpy.array\n 2-D array of shape *(Nrp_bins,Npi_bins)* containing the weighted number counts\n of pairs. The exact values depend on ``weight_func_id``\n (which weighting function was chosen).\n\n w3N_pairs : numpy.array\n 2-D array of shape *(Nrp_bins,Npi_bins)* containing the weighted number counts\n of pairs. The exact values depend on ``weight_func_id``\n (which weighting function was chosen).\n\n Examples\n --------\n For demonstration purposes we will work with\n halos in the `~halotools.sim_manager.FakeSim`.\n\n >>> from halotools.sim_manager import FakeSim\n >>> halocat = FakeSim()\n\n >>> x = halocat.halo_table['halo_x']\n >>> y = halocat.halo_table['halo_y']\n >>> z = halocat.halo_table['halo_z']\n\n We transform our *x, y, z* points into the array shape used by the pair-counter by\n taking the transpose of the result of `numpy.vstack`. This boilerplate transformation\n is used throughout the `~halotools.mock_observables` sub-package:\n\n >>> sample1 = np.vstack((x,y,z)).T\n\n We will do the same to get a random set of velocities.\n\n >>> vx = halocat.halo_table['halo_vx']\n >>> vy = halocat.halo_table['halo_vy']\n >>> vz = halocat.halo_table['halo_vz']\n >>> velocities = np.vstack((x,y,z,vx,vy,vz)).T\n\n >>> rp_bins = np.logspace(-2,-1,10)\n >>> pi_bins = np.linspace(0, 10, 5)\n >>> result = velocity_marked_npairs_xy_z(sample1, sample1, rp_bins, pi_bins, period=halocat.Lbox, weights1=velocities, weights2=velocities,)\n\n \"\"\"\n result = _npairs_xy_z_process_args(sample1, sample2, rp_bins, pi_bins, period,\n num_threads, approx_cell1_size, approx_cell2_size)\n x1in, y1in, z1in, x2in, y2in, z2in = result[0:6]\n rp_bins, pi_bins, period, num_threads, PBCs, approx_cell1_size, approx_cell2_size = result[6:]\n xperiod, yperiod, zperiod = period\n\n rp_max = np.max(rp_bins)\n pi_max = np.max(pi_bins)\n search_xlength, search_ylength, search_zlength = rp_max, rp_max, pi_max\n\n # Process the input weights and with the helper function\n weights1, weights2 = (\n _velocity_marked_npairs_3d_process_weights(sample1, sample2,\n weights1, weights2, weight_func_id))\n\n # Compute the estimates for the cell sizes\n approx_cell1_size, approx_cell2_size = (\n _set_approximate_cell_sizes(approx_cell1_size, approx_cell2_size, period)\n )\n approx_x1cell_size, approx_y1cell_size, approx_z1cell_size = approx_cell1_size\n approx_x2cell_size, approx_y2cell_size, approx_z2cell_size = approx_cell2_size\n\n # Build the rectangular mesh\n double_mesh = RectangularDoubleMesh(x1in, y1in, z1in, x2in, y2in, z2in,\n approx_x1cell_size, approx_y1cell_size, approx_z1cell_size,\n approx_x2cell_size, approx_y2cell_size, approx_z2cell_size,\n search_xlength, search_ylength, search_zlength, xperiod, yperiod, zperiod, PBCs)\n\n # Create a function object that has a single argument, for parallelization purposes\n engine = partial(velocity_marked_npairs_xy_z_engine, double_mesh,\n x1in, y1in, z1in, x2in, y2in, z2in,\n weights1, weights2, weight_func_id, rp_bins, pi_bins)\n\n # Calculate the cell1 indices that will be looped over by the engine\n num_threads, cell1_tuples = _cell1_parallelization_indices(\n double_mesh.mesh1.ncells, num_threads)\n\n if num_threads > 1:\n pool = multiprocessing.Pool(num_threads)\n result = np.array(pool.map(engine, cell1_tuples))\n counts1, counts2, counts3 = result[:, 0], result[:, 1], result[:, 2]\n counts1 = np.sum(counts1, axis=0)\n counts2 = np.sum(counts2, axis=0)\n counts3 = np.sum(counts3, axis=0)\n pool.close()\n else:\n counts1, counts2, counts3 = np.array(engine(cell1_tuples[0]))\n\n return counts1, counts2, counts3\n", "meta": {"hexsha": "d4abc03757260dd30d75b0f90f15a89c9eca5966", "size": 8874, "ext": "py", "lang": "Python", "max_stars_repo_path": "halotools/mock_observables/pairwise_velocities/velocity_marked_npairs_xy_z.py", "max_stars_repo_name": "pllim/halotools", "max_stars_repo_head_hexsha": "6499cff09e7e0f169e4f425ee265403f6be816e8", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 83, "max_stars_repo_stars_event_min_datetime": "2015-01-15T14:54:16.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-09T11:28:02.000Z", "max_issues_repo_path": "halotools/mock_observables/pairwise_velocities/velocity_marked_npairs_xy_z.py", "max_issues_repo_name": "pllim/halotools", "max_issues_repo_head_hexsha": "6499cff09e7e0f169e4f425ee265403f6be816e8", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 579, "max_issues_repo_issues_event_min_datetime": "2015-01-14T15:57:37.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-13T18:58:44.000Z", "max_forks_repo_path": "halotools/mock_observables/pairwise_velocities/velocity_marked_npairs_xy_z.py", "max_forks_repo_name": "pllim/halotools", "max_forks_repo_head_hexsha": "6499cff09e7e0f169e4f425ee265403f6be816e8", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 70, "max_forks_repo_forks_event_min_datetime": "2015-01-14T15:15:58.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-22T18:18:31.000Z", "avg_line_length": 45.7422680412, "max_line_length": 144, "alphanum_fraction": 0.7110660356, "include": true, "reason": "import numpy", "num_tokens": 2245, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.5736784074525096, "lm_q2_score": 0.3380771374883919, "lm_q1q2_score": 0.19394755383044382}} {"text": "from dataclasses import dataclass\nfrom typing import Any, Dict, List, Optional, Tuple, Union, cast\n\nimport numpy as np\nimport tensorflow as tf\nfrom srl.base.rl.algorithms.continuous_action import ContinuousActionConfig, ContinuousActionWorker\nimport tensorflow.keras as keras\nimport tensorflow.keras.layers as kl\nfrom srl.base.define import RLObservationType\nfrom srl.base.env.base import EnvRun\nfrom srl.base.rl.algorithms.continuous_action import ContinuousActionConfig, ContinuousActionWorker\nfrom srl.base.rl.base import RLParameter, RLTrainer\nfrom srl.base.rl.registration import register\nfrom srl.base.rl.remote_memory import ExperienceReplayBuffer\nfrom srl.rl.functions.common_tf import compute_logprob_sgp\nfrom srl.rl.functions.model import ImageLayerType, create_input_layers_one_sequence\n\n\"\"\"\nDDPG\n Replay buffer : o\n Target Network(soft): o\n Target Network(hard): o\n Add action noise : x\nTD3\n Clipped Double Q learning : o\n Target Policy Smoothing : x\n Delayed Policy Update : x\nSAC\n Squashed Gaussian Policy: o\n\"\"\"\n\n\n# ------------------------------------------------------\n# config\n# ------------------------------------------------------\n@dataclass\nclass Config(ContinuousActionConfig):\n\n # model\n policy_hidden_layer_sizes: Tuple[int, ...] = (64, 64, 64)\n q_hidden_layer_sizes: Tuple[int, ...] = (64, 64, 64)\n activation: str = \"relu\"\n image_layer_type: ImageLayerType = ImageLayerType.DQN\n\n gamma: float = 0.9 # 割引率\n lr: float = 0.005 # 学習率\n soft_target_update_tau: float = 0.02\n hard_target_update_interval: int = 100\n\n batch_size: int = 32\n capacity: int = 10_000\n memory_warmup_size: int = 500\n\n def __post_init__(self):\n super().__init__()\n\n @property\n def observation_type(self) -> RLObservationType:\n return RLObservationType.CONTINUOUS\n\n @staticmethod\n def getName() -> str:\n return \"SAC\"\n\n def assert_params(self) -> None:\n super().assert_params()\n assert self.memory_warmup_size < self.capacity\n assert self.batch_size < self.memory_warmup_size\n\n\nregister(\n Config,\n __name__ + \":RemoteMemory\",\n __name__ + \":Parameter\",\n __name__ + \":Trainer\",\n __name__ + \":Worker\",\n)\n\n\n# ------------------------------------------------------\n# RemoteMemory\n# ------------------------------------------------------\nclass RemoteMemory(ExperienceReplayBuffer):\n def __init__(self, *args):\n super().__init__(*args)\n self.config = cast(Config, self.config)\n\n self.init(self.config.capacity)\n\n\n# ------------------------------------------------------\n# network\n# ------------------------------------------------------\nclass _PolicyModel(keras.Model):\n def __init__(self, config: Config):\n super().__init__()\n\n in_state, c = create_input_layers_one_sequence(\n config.observation_shape,\n config.env_observation_type,\n config.image_layer_type,\n )\n\n # --- hidden layer\n for h in config.policy_hidden_layer_sizes:\n c = kl.Dense(h, activation=config.activation, kernel_initializer=\"he_normal\")(c)\n c = kl.LayerNormalization()(c) # 勾配爆発抑制用?\n\n # --- out layer\n pi_mean = kl.Dense(\n config.action_num,\n activation=\"linear\",\n kernel_initializer=\"truncated_normal\",\n bias_initializer=\"truncated_normal\",\n )(c)\n pi_stddev = kl.Dense(\n config.action_num,\n activation=\"linear\",\n kernel_initializer=\"truncated_normal\",\n bias_initializer=\"truncated_normal\",\n )(c)\n self.model = keras.Model(in_state, [pi_mean, pi_stddev])\n\n # 重みを初期化\n dummy_state = np.zeros(shape=(1,) + config.observation_shape, dtype=np.float32)\n action, mean, stddev, action_org = self(dummy_state)\n assert mean.shape == (1, config.action_num)\n assert stddev.shape == (1, config.action_num)\n\n @tf.function\n def call(self, state):\n mean, stddev = self.model(state)\n\n # σ > 0\n stddev = tf.exp(stddev)\n\n # Reparameterization trick\n normal_random = tf.random.normal(mean.shape, mean=0.0, stddev=1.0)\n action_org = mean + stddev * normal_random\n\n # Squashed Gaussian Policy\n action = tf.tanh(action_org)\n\n return action, mean, stddev, action_org\n\n\nclass _DualQNetwork(keras.Model):\n def __init__(self, config: Config):\n super().__init__()\n\n in_state, c = create_input_layers_one_sequence(\n config.observation_shape,\n config.env_observation_type,\n config.image_layer_type,\n )\n in_action = kl.Input(shape=(config.action_num,))\n c = kl.Concatenate()([c, in_action])\n\n for h in config.q_hidden_layer_sizes:\n c = kl.Dense(h, activation=config.activation, kernel_initializer=\"he_normal\")(c)\n c = kl.LayerNormalization()(c) # 勾配爆発抑制用?\n\n # q1\n q1 = kl.Dense(\n 1, activation=\"linear\", kernel_initializer=\"truncated_normal\", bias_initializer=\"truncated_normal\"\n )(c)\n\n # q2\n q2 = kl.Dense(\n 1, activation=\"linear\", kernel_initializer=\"truncated_normal\", bias_initializer=\"truncated_normal\"\n )(c)\n\n # out layer\n self.model = keras.Model([in_state, in_action], [q1, q2])\n\n # 重みを初期化\n dummy_state = np.zeros(shape=(1,) + config.observation_shape, dtype=np.float32)\n dummy_action = np.zeros(shape=(1, config.action_num), dtype=np.float32)\n _q1, _q2 = self(dummy_state, dummy_action)\n assert _q1.shape == (1, 1)\n assert _q2.shape == (1, 1)\n\n def call(self, state, action):\n return self.model([state, action])\n\n\n# ------------------------------------------------------\n# Parameter\n# ------------------------------------------------------\nclass Parameter(RLParameter):\n def __init__(self, *args):\n super().__init__(*args)\n self.config = cast(Config, self.config)\n\n self.policy = _PolicyModel(self.config)\n self.q_online = _DualQNetwork(self.config)\n self.q_target = _DualQNetwork(self.config)\n\n def restore(self, data: Any) -> None:\n self.policy.set_weights(data[0])\n self.q_online.set_weights(data[1])\n self.q_target.set_weights(data[1])\n\n def backup(self) -> Any:\n return [\n self.policy.get_weights(),\n self.q_online.get_weights(),\n ]\n\n def summary(self):\n self.policy.model.summary()\n self.q_online.model.summary()\n\n\n# ------------------------------------------------------\n# Trainer\n# ------------------------------------------------------\nclass Trainer(RLTrainer):\n def __init__(self, *args):\n super().__init__(*args)\n self.config = cast(Config, self.config)\n self.parameter = cast(Parameter, self.parameter)\n self.remote_memory = cast(RemoteMemory, self.remote_memory)\n\n self.train_count = 0\n\n self.q_optimizer = keras.optimizers.Adam(learning_rate=self.config.lr)\n self.policy_optimizer = keras.optimizers.Adam(learning_rate=self.config.lr)\n self.alpha_optimizer = keras.optimizers.Adam(learning_rate=self.config.lr)\n\n # エントロピーαの目標値、-1×アクション数が良いらしい\n self.target_entropy = -1 * self.config.action_num\n\n # エントロピーα自動調整用\n self.log_alpha = tf.Variable(0.5, dtype=tf.float32)\n\n def get_train_count(self):\n return self.train_count\n\n def train(self):\n if self.remote_memory.length() < self.config.memory_warmup_size:\n return {}\n batchs = self.remote_memory.sample(self.config.batch_size)\n\n states = []\n actions = []\n n_states = []\n rewards = []\n dones = []\n for b in batchs:\n states.append(b[\"state\"])\n actions.append(b[\"action\"])\n n_states.append(b[\"next_state\"])\n rewards.append(b[\"reward\"])\n dones.append(b[\"done\"])\n states = np.asarray(states)\n n_states = np.asarray(n_states)\n actions = np.asarray(actions)\n dones = np.asarray(dones).reshape((-1, 1))\n rewards = np.asarray(rewards).reshape((-1, 1))\n\n # 方策エントロピーの反映率αを計算\n alpha = tf.math.exp(self.log_alpha)\n\n # ポリシーより次の状態のアクションを取得\n n_actions, n_means, n_stddevs, n_action_orgs = self.parameter.policy(n_states)\n # 次の状態のアクションのlogpiを取得(Squashed Gaussian Policy時)\n n_logpi = compute_logprob_sgp(n_means, n_stddevs, n_action_orgs)\n\n # 2つのQ値から小さいほうを採用(Clipped Double Q learning)して、\n # Q値を計算 : reward if done else (reward + gamma * n_qval) - (alpha * H)\n n_q1, n_q2 = self.parameter.q_target(n_states, n_actions)\n q_vals = rewards + (1 - dones) * self.config.gamma * tf.minimum(n_q1, n_q2) - (alpha * n_logpi)\n\n # --- Qモデルの学習\n with tf.GradientTape() as tape:\n q1, q2 = self.parameter.q_online(states, actions)\n loss1 = tf.reduce_mean(tf.square(q_vals - q1))\n loss2 = tf.reduce_mean(tf.square(q_vals - q2))\n q_loss = (loss1 + loss2) / 2\n\n grads = tape.gradient(q_loss, self.parameter.q_online.trainable_variables)\n self.q_optimizer.apply_gradients(zip(grads, self.parameter.q_online.trainable_variables))\n\n # --- ポリシーの学習\n with tf.GradientTape() as tape:\n # アクションを出力\n selected_actions, means, stddevs, action_orgs = self.parameter.policy(states)\n\n # logπ(a|s) (Squashed Gaussian Policy)\n logpi = compute_logprob_sgp(means, stddevs, action_orgs)\n\n # Q値を出力、小さいほうを使う\n q1, q2 = self.parameter.q_online(states, selected_actions)\n q_min = tf.minimum(q1, q2)\n\n # alphaは定数扱いなので勾配が流れないようにする\n policy_loss = q_min - (tf.stop_gradient(alpha) * logpi)\n\n policy_loss = -tf.reduce_mean(policy_loss) # 最大化\n\n grads = tape.gradient(policy_loss, self.parameter.policy.trainable_variables)\n self.policy_optimizer.apply_gradients(zip(grads, self.parameter.policy.trainable_variables))\n\n # --- 方策エントロピーαの自動調整\n _, means, stddevs, action_orgs = self.parameter.policy(states)\n logpi = compute_logprob_sgp(means, stddevs, action_orgs)\n\n with tf.GradientTape() as tape:\n entropy_diff = -logpi - self.target_entropy\n log_alpha_loss = tf.reduce_mean(tf.exp(self.log_alpha) * entropy_diff)\n\n grad = tape.gradient(log_alpha_loss, self.log_alpha)\n self.alpha_optimizer.apply_gradients([(grad, self.log_alpha)])\n\n # --- soft target update\n self.parameter.q_target.set_weights(\n (1 - self.config.soft_target_update_tau) * np.array(self.parameter.q_target.get_weights(), dtype=object)\n + (self.config.soft_target_update_tau) * np.array(self.parameter.q_online.get_weights(), dtype=object)\n )\n\n # --- hard target sync\n if self.train_count % self.config.hard_target_update_interval == 0:\n self.parameter.q_target.set_weights(self.parameter.q_online.get_weights())\n\n self.train_count += 1\n return {\n \"q_loss\": q_loss.numpy(),\n \"policy_loss\": policy_loss.numpy(),\n \"alpha_loss\": log_alpha_loss.numpy(),\n }\n\n\n# ------------------------------------------------------\n# Worker\n# ------------------------------------------------------\nclass Worker(ContinuousActionWorker):\n def __init__(self, *args):\n super().__init__(*args)\n self.config = cast(Config, self.config)\n self.parameter = cast(Parameter, self.parameter)\n self.remote_memory = cast(RemoteMemory, self.remote_memory)\n\n def call_on_reset(self, state: np.ndarray) -> None:\n self.state = state\n\n def call_policy(self, state: np.ndarray) -> List[float]:\n self.state = state\n action, mean, _, _ = self.parameter.policy(state.reshape(1, -1))\n\n if self.training:\n action = action.numpy()[0]\n else:\n # テスト時は平均を使う\n action = mean.numpy()[0]\n\n # Squashed Gaussian Policy (-1, 1) -> (action range)\n action = (action + 1) / 2\n action = self.config.action_low + action * (self.config.action_high - self.config.action_low)\n\n self.action = action\n return self.action\n\n def call_on_step(\n self,\n next_state: np.ndarray,\n reward: float,\n done: bool,\n ) -> Dict[str, Union[float, int]]:\n if not self.training:\n return {}\n\n batch = {\n \"state\": self.state,\n \"action\": self.action,\n \"next_state\": next_state,\n \"reward\": reward,\n \"done\": done,\n }\n self.remote_memory.add(batch)\n\n return {}\n\n def call_render(self, env: EnvRun) -> None:\n state = self.state.reshape(1, -1)\n action = np.asarray([self.action])\n _, mean, stddev, _ = self.parameter.policy(state)\n mean = mean.numpy()[0][0]\n stddev = stddev.numpy()[0][0]\n q1, q2 = self.parameter.q_online(state, action)\n q1 = q1.numpy()[0][0]\n q2 = q2.numpy()[0][0]\n\n print(f\"mean {mean:.5f}, stddev {stddev:.5f}\")\n print(f\"q1 {q1:.5f}, q2 {q2:.5f}\")\n", "meta": {"hexsha": "f3b5873d33467a61371014286d1d2a7053d01514", "size": 13295, "ext": "py", "lang": "Python", "max_stars_repo_path": "srl/rl/sac.py", "max_stars_repo_name": "pocokhc/simple_rl", "max_stars_repo_head_hexsha": "765f12f392f87e6897027905d74f1bced6a2b7bf", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-03-01T09:16:57.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-01T09:16:57.000Z", "max_issues_repo_path": "srl/rl/sac.py", "max_issues_repo_name": "pocokhc/simple_rl", "max_issues_repo_head_hexsha": "765f12f392f87e6897027905d74f1bced6a2b7bf", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "srl/rl/sac.py", "max_forks_repo_name": "pocokhc/simple_rl", "max_forks_repo_head_hexsha": "765f12f392f87e6897027905d74f1bced6a2b7bf", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.5732323232, "max_line_length": 116, "alphanum_fraction": 0.5957878902, "include": true, "reason": "import numpy", "num_tokens": 3222, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5736784220301065, "lm_q2_score": 0.3380771174808128, "lm_q1q2_score": 0.19394754728087965}} {"text": "import sys, re, glob\nimport numpy as np\n\nfrom cctk import GaussianFile, Molecule\nfrom cctk import parse_gaussian as parse\n\nfilenames = sys.argv[1]\ninfo = []\n\nfor filename in sorted(glob.glob(filenames, recursive=True)):\n try:\n output_file, lines = GaussianFile.read_file(filename, return_lines=True)\n except:\n continue\n\n success = \"NO\"\n if output_file.success:\n success = output_file.success\n else:\n continue\n\n energy = output_file.energies[-1]\n iters = len(output_file.energies)\n mol = output_file.get_molecule()\n\n cation_anion_dist = 0\n mul_q = 0\n hir_q = 0\n if 29 in mol.atomic_numbers:\n mul_q = float(parse.find_parameter(lines, \" 52 Cu\", 4, 2)[-1])\n hir_q = float(parse.find_parameter(lines, \" 52 Cu\", 8, 2)[-1])\n\n if 16 in mol.atomic_numbers:\n cation_anion_dist = mol.get_distance(52, 54)\n elif 51 in mol.atomic_numbers:\n cation_anion_dist = mol.get_distance(52, 53)\n\n imaginaries = \"--\"\n try:\n if output_file.num_imaginaries() > 0:\n if output_file.num_imaginaries() > 1:\n imaginaries = \", \".join(output_file.imaginaries())\n else:\n imaginaries = output_file.imaginaries()[0]\n except:\n #### Will raise ValueError if job is not of type \"FREQ\"\n pass\n\n info.append([filename, energy, energy * 627.509, iters, mul_q, hir_q, success, imaginaries, cation_anion_dist])\n\n\nif len(info) > 0:\n min_energy = np.min([x[2] for x in info])\n def adjust_energy(row):\n if row[2] < 0:\n row[2] = row[2] - min_energy\n return row\n\n info = list(map(adjust_energy, info))\n\n print(\"{0},{1},{2},{3},{4},{5},{6},{7},{8}\".format(\n \"File\", \"Energy (Hartree)\", \"Rel Energy (kcal)\", \"Iterations\", \"Mulliken Q\", \"Hirshfeld Q\", \"Success?\", \"Imaginaries?\",\"X-Cu Distance\"\n ))\n\n for row in info:\n print(\"{0},{1:.4f},{2:.2f},{3},{4:.4f},{5:.4f},{6},{7:},{8:.2f}\".format(*row))\n\n", "meta": {"hexsha": "c8fc4913a180822d93c04f85fb98514c8e5b3a25", "size": 2011, "ext": "py", "lang": "Python", "max_stars_repo_path": "tutorial/tutorial_07/analyze.py", "max_stars_repo_name": "ekwan/cctk", "max_stars_repo_head_hexsha": "85cb8d0b714a80e8e353987dc24006695f1d0532", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 10, "max_stars_repo_stars_event_min_datetime": "2020-01-16T15:26:57.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-15T23:12:00.000Z", "max_issues_repo_path": "tutorial/tutorial_07/analyze.py", "max_issues_repo_name": "ekwan/cctk", "max_issues_repo_head_hexsha": "85cb8d0b714a80e8e353987dc24006695f1d0532", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2020-05-27T21:04:36.000Z", "max_issues_repo_issues_event_max_datetime": "2020-09-26T20:49:53.000Z", "max_forks_repo_path": "tutorial/tutorial_07/analyze.py", "max_forks_repo_name": "ekwan/cctk", "max_forks_repo_head_hexsha": "85cb8d0b714a80e8e353987dc24006695f1d0532", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-09-24T18:44:18.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-05T20:35:51.000Z", "avg_line_length": 29.5735294118, "max_line_length": 142, "alphanum_fraction": 0.5967180507, "include": true, "reason": "import numpy", "num_tokens": 584, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5736784074525096, "lm_q2_score": 0.3380771241500058, "lm_q1q2_score": 0.1939475461784997}} {"text": "__doc__ = \"\"\"Symplectic time steppers and concepts for integrating the kinematic and dynamic equations of rod-like objects. \"\"\"\nimport numpy as np\n\nfrom elastica.timestepper._stepper_interface import (\n _TimeStepper,\n _LinearExponentialIntegratorMixin,\n)\n\n\"\"\"\nDeveloper Note\n--------------\n\nFor the reasons why we define Mixin classes here, the developer\nis referred to the same section on `explicit_steppers.py`.\n\"\"\"\n\n\nclass _SystemInstanceStepperMixin:\n def do_step(self, System, time: np.float64, dt: np.float64):\n for (\n kin_prefactor,\n kin_step,\n dyn_prefactor,\n dyn_step,\n ) in self._steps_and_prefactors[:-1]:\n prefac = kin_prefactor(self, dt)\n time = kin_step(self, System, time, prefac)\n prefac = dyn_prefactor(self, dt)\n time = dyn_step(self, System, time, prefac)\n\n # Peel the last kinematic step and prefactor alone\n last_kin_prefactor = self._steps_and_prefactors[-1][0]\n last_kin_step = self._steps_and_prefactors[-1][1]\n\n prefac = last_kin_prefactor(self, dt)\n time = last_kin_step(self, System, time, prefac)\n return time\n\n\nclass _SystemCollectionStepperMixin:\n \"\"\"\n Symplectic stepper mixin collection class\n \"\"\"\n\n def do_step(self, SystemCollection, time: np.float64, dt: np.float64):\n \"\"\"\n Function for doing symplectic stepper over the user defined rods (system).\n\n Parameters\n ----------\n SystemCollection: rod object\n time: float\n dt: float\n\n Returns\n -------\n\n \"\"\"\n for (\n kin_prefactor,\n kin_step,\n dyn_prefactor,\n dyn_step,\n ) in self._steps_and_prefactors[:-1]:\n prefac = kin_prefactor(self, dt)\n for system in SystemCollection[:-1]:\n _ = kin_step(self, system, time, prefac)\n time = kin_step(self, SystemCollection[-1], time, prefac)\n\n # TODO: remove below lines and try to find a better call option to compute internal forces and torques\n # We need internal forces and torques because they are used by interaction module.\n update_internal_forces_torques = self._update_internal_forces_torques[\n 0\n ] # here 0 because you have one item in list\n for system in SystemCollection[:-1]:\n _ = update_internal_forces_torques(self, system, time)\n time = update_internal_forces_torques(self, SystemCollection[-1], time)\n\n # BoCos, External forces, controls etc.\n SystemCollection.synchronize(time)\n # TODO: remove below line, it should be some other function synchronizeBC\n SystemCollection.synchronizeBC(time)\n prefac = dyn_prefactor(self, dt)\n for system in SystemCollection[:-1]:\n _ = dyn_step(self, system, time, prefac)\n time = dyn_step(self, SystemCollection[-1], time, prefac)\n\n # TODO: remove below line, it should be some other function synchronizeBC\n SystemCollection.synchronizeBC(time)\n\n # Peel the last kinematic step and prefactor alone\n last_kin_prefactor = self._steps_and_prefactors[-1][0]\n last_kin_step = self._steps_and_prefactors[-1][1]\n\n prefac = last_kin_prefactor(self, dt)\n for system in SystemCollection[:-1]:\n _ = last_kin_step(self, system, time, prefac)\n time = last_kin_step(self, SystemCollection[-1], time, prefac)\n\n # Call back function, will call the user defined call back functions and store data\n SystemCollection.callBack(time, int(time / dt))\n\n return time\n\n\nclass SymplecticStepper(_TimeStepper):\n \"\"\"\n Symplectic stepper constructor.\n\n Attributes\n ----------\n _steps: list\n List containing methods of symplectic time stepper.\n _prefactors: list\n List containing prefactors of symplectic time stepper.\n _update_internal_forces_torques: list\n List containing methods for computing internal forces and torques.\n \"\"\"\n\n def __init__(self, cls=None):\n super(SymplecticStepper, self).__init__()\n take_methods_from = self if cls is None else cls()\n # Let the total number of steps for the Symplectic method\n # be (2*n + 1) (for time-symmetry). What we do is collect\n # the first n + 1 entries down in _steps and _prefac below, and then\n # reverse and append it to itself.\n self._steps = [\n v\n for (k, v) in take_methods_from.__class__.__dict__.items()\n if k.endswith(\"step\")\n ]\n # Prefac here is necessary because the linear-exponential integrator\n # needs only the prefactor and not the dt.\n self._prefactors = [\n v\n for (k, v) in take_methods_from.__class__.__dict__.items()\n if k.endswith(\"prefactor\")\n ]\n\n # We are getting function named as _update_internal_forces_torques from dictionary,\n # it turns a list.\n self._update_internal_forces_torques = [\n v\n for (k, v) in take_methods_from.__class__.__dict__.items()\n if k.endswith(\"forces_torques\")\n ]\n\n def mirror(in_list):\n \"\"\" Mirrors an input list ignoring the last element\n If steps = [A, B, C]\n then this call makes it [A, B, C, B, A]\n\n Parameters\n ----------\n in_list : input list to be mirrored, modified in-place\n\n Returns\n -------\n\n \"\"\"\n # syntax is very ugly\n in_list.extend(in_list[-2::-1])\n\n mirror(self._steps)\n mirror(self._prefactors)\n\n assert len(self._steps) == len(\n self._prefactors\n ), \"Size mismatch in the number of steps and prefactors provided for a Symplectic Stepper!\"\n\n self._kinematic_steps = self._steps[::2]\n self._dynamic_steps = self._steps[1::2]\n self._kinematic_prefactors = self._prefactors[::2]\n self._dynamic_prefactors = self._prefactors[1::2]\n\n # Avoid this check for MockClasses\n if len(self._kinematic_steps) > 0:\n assert (\n len(self._kinematic_steps) == len(self._dynamic_steps) + 1\n ), \"Size mismatch in the number of kinematic and dynamic steps provided for a Symplectic Stepper!\"\n assert (\n len(self._kinematic_prefactors) == len(self._dynamic_prefactors) + 1\n ), \"Size mismatch in the number of kinematic and dynamic prefactors provided for a Symplectic Stepper!\"\n\n from itertools import zip_longest\n\n self._steps_and_prefactors = tuple(\n zip_longest(\n self._kinematic_prefactors,\n self._kinematic_steps,\n self._dynamic_prefactors,\n self._dynamic_steps,\n )\n )\n\n @property\n def n_stages(self):\n return len(self._steps_and_prefactors)\n\n\nclass PositionVerlet(SymplecticStepper):\n \"\"\"\n Position Verlet symplectic time stepper class, which\n includes methods for second-order position Verlet.\n \"\"\"\n\n def __init__(self):\n super(PositionVerlet, self).__init__()\n\n def _first_kinematic_prefactor(self, dt):\n return 0.5 * dt\n\n def _first_kinematic_step(self, System, time: np.float64, prefac: np.float64):\n System.kinematic_states += prefac * System.kinematic_rates(time, prefac)\n return time + prefac\n\n def _first_dynamic_prefactor(self, dt):\n return dt\n\n def _first_dynamic_step(self, System, time: np.float64, prefac: np.float64):\n System.dynamic_states += prefac * System.dynamic_rates(\n time, prefac\n ) # TODO : Why should we pass dt into System again?\n return time\n\n # TODO: find a better place for this or a better call option. We need to compute internal forces and torques before external because interaction uses it!\n def _update_internal_forces_torques(self, System, time: np.float64):\n System.update_internal_forces_and_torques(time)\n return time\n\n # Note : we don't need the second half of the calls as it simply forwards\n # to its equivalent first half. This is taken care in the base class\n\n # def _second_kinematic_step(self, System, time: np.float64, dt: np.float64):\n # return self._first_kinematic_step(System, time, dt)\n\n\nclass PEFRL(SymplecticStepper):\n \"\"\"\n Position Extended Forest-Ruth Like Algorithm of\n I.M. Omelyan, I.M. Mryglod, and R. Folk, Computer Physics Communications 146, 188 (2002),\n http://arxiv.org/abs/cond-mat/0110585\n \"\"\"\n\n # xi and chi are confusing, but be careful!\n ξ = np.float64(0.1786178958448091e0) # ξ\n λ = -np.float64(0.2123418310626054e0) # λ\n χ = -np.float64(0.6626458266981849e-1) # χ\n\n # Pre-calculate other coefficients\n lambda_dash_coeff = 0.5 * (1.0 - 2.0 * λ)\n xi_chi_dash_coeff = 1.0 - 2.0 * (ξ + χ)\n\n def __init__(self):\n super(PEFRL, self).__init__()\n\n def _first_kinematic_prefactor(self, dt):\n return self.ξ * dt\n\n def _first_kinematic_step(self, System, time: np.float64, prefac: np.float64):\n System.kinematic_states += prefac * System.kinematic_rates(time, prefac)\n return time + prefac\n\n def _first_dynamic_prefactor(self, dt):\n return self.lambda_dash_coeff * dt\n\n def _first_dynamic_step(self, System, time: np.float64, prefac: np.float64):\n System.dynamic_states += prefac * System.dynamic_rates(time, prefac)\n return time\n\n def _second_kinematic_prefactor(self, dt):\n return self.χ * dt\n\n def _second_kinematic_step(self, System, time: np.float64, prefac: np.float64):\n System.kinematic_states += prefac * System.kinematic_rates(time, prefac)\n return time + prefac\n\n def _second_dynamic_prefactor(self, dt):\n return self.λ * dt\n\n def _second_dynamic_step(self, System, time: np.float64, prefac: np.float64):\n System.dynamic_states += prefac * System.dynamic_rates(time, prefac)\n return time\n\n def _third_kinematic_prefactor(self, dt):\n return self.xi_chi_dash_coeff * dt\n\n def _third_kinematic_step(self, System, time: np.float64, prefac: np.float64):\n # Need to fill in\n System.kinematic_states += prefac * System.kinematic_rates(time, prefac)\n return time + prefac\n\n # TODO: find a better place for this or a better call option. We need to compute internal forces and torques before external because interaction uses it!\n def _update_internal_forces_torques(self, System, time: np.float64):\n System.update_internal_forces_and_torques(time)\n return time\n\n # Note : we don't need the second half of the calls as it simply forwards\n # to its equivalent first half. This is taken care in the base class\n\n # def _third_dynamic_step(self, System, time: np.float64, dt: np.float64):\n # return self._second_dynamic_step(System, time, dt)\n #\n # def _fourth_kinematic_step(self, System, time: np.float64, dt: np.float64):\n # return self._second_kinematic_step(System, time, dt)\n #\n # def _fourth_dynamic_step(self, System, time: np.float64, dt: np.float64):\n # return self._first_dynamic_step(System, time, dt)\n #\n # def _fifth_kinematic_step(self, System, time: np.float64, dt: np.float64):\n # return self._first_kinematic_step(System, time, dt)\n # # return time + dt # To avoid numerical precision errors\n\n\nclass SymplecticLinearExponentialIntegrator(\n _LinearExponentialIntegratorMixin, SymplecticStepper\n):\n def __init__(self):\n _LinearExponentialIntegratorMixin.__init__(self)\n SymplecticStepper.__init__(self, _LinearExponentialIntegratorMixin)\n", "meta": {"hexsha": "af9ecce9bbe8a515b479155aece68e1fba9ba34b", "size": 11865, "ext": "py", "lang": "Python", "max_stars_repo_path": "elastica/timestepper/symplectic_steppers.py", "max_stars_repo_name": "merozlab/PyElastica", "max_stars_repo_head_hexsha": "1d8c354a25846f63073809e3a809f27a150c3b9c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "elastica/timestepper/symplectic_steppers.py", "max_issues_repo_name": "merozlab/PyElastica", "max_issues_repo_head_hexsha": "1d8c354a25846f63073809e3a809f27a150c3b9c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "elastica/timestepper/symplectic_steppers.py", "max_forks_repo_name": "merozlab/PyElastica", "max_forks_repo_head_hexsha": "1d8c354a25846f63073809e3a809f27a150c3b9c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-01-21T15:42:58.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-21T15:42:58.000Z", "avg_line_length": 36.9626168224, "max_line_length": 157, "alphanum_fraction": 0.6475347661, "include": true, "reason": "import numpy", "num_tokens": 2889, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5736784074525096, "lm_q2_score": 0.3380771241500058, "lm_q1q2_score": 0.1939475461784997}} {"text": "\"\"\" @package forcebalance.lipid Matching of lipid bulk properties. Under development.\n\nauthor Lee-Ping Wang\n@date 04/2012\n\"\"\"\nfrom __future__ import division\nfrom __future__ import print_function\n\nfrom builtins import str\nfrom builtins import zip\nfrom builtins import map\nfrom builtins import range\nimport abc\nimport os\nimport shutil\nfrom forcebalance.finite_difference import *\nfrom forcebalance.nifty import *\nfrom forcebalance.nifty import _exec\nfrom forcebalance.target import Target\nimport numpy as np\nfrom forcebalance.molecule import Molecule\nfrom re import match, sub\nimport subprocess\nfrom subprocess import PIPE\ntry:\n from lxml import etree\nexcept: pass\nfrom pymbar import pymbar\nimport itertools\nfrom collections import defaultdict, namedtuple, OrderedDict\nimport csv\nimport copy\n\nfrom forcebalance.output import getLogger\nlogger = getLogger(__name__)\n\ndef weight_info(W, PT, N_k, verbose=True):\n C = []\n N = 0\n W += 1.0e-300\n I = np.exp(-1*np.sum((W*np.log(W))))\n for ns in N_k:\n C.append(sum(W[N:N+ns]))\n N += ns\n C = np.array(C)\n if verbose:\n logger.info(\"MBAR Results for Phase Point %s, Box, Contributions:\\n\" % str(PT))\n logger.info(str(C) + '\\n')\n logger.info(\"InfoContent: % .2f snapshots (%.2f %%)\\n\" % (I, 100*I/len(W)))\n return C\n\n# NPT_Trajectory = namedtuple('NPT_Trajectory', ['fnm', 'Rhos', 'pVs', 'Energies', 'Grads', 'mEnergies', 'mGrads', 'Rho_errs', 'Hvap_errs'])\n\nclass Lipid(Target):\n \n \"\"\" Subclass of Target for lipid property matching.\"\"\"\n\n def __init__(self,options,tgt_opts,forcefield):\n # Initialize base class\n super(Lipid,self).__init__(options,tgt_opts,forcefield)\n # Weight of the density\n self.set_option(tgt_opts,'w_rho',forceprint=True)\n # Weight of the thermal expansion coefficient\n self.set_option(tgt_opts,'w_alpha',forceprint=True)\n # Weight of the isothermal compressibility\n self.set_option(tgt_opts,'w_kappa',forceprint=True)\n # Weight of the isobaric heat capacity\n self.set_option(tgt_opts,'w_cp',forceprint=True)\n # Weight of the dielectric constant\n self.set_option(tgt_opts,'w_eps0',forceprint=True)\n # Weight of the area per lipid\n self.set_option(tgt_opts,'w_al',forceprint=True)\n # Weight of the bilayer isothermal compressibility\n self.set_option(tgt_opts,'w_lkappa',forceprint=True)\n # Weight of the deuterium order parameter\n self.set_option(tgt_opts,'w_scd',forceprint=True)\n # Normalize the property contributions to the objective function\n self.set_option(tgt_opts,'w_normalize',forceprint=True)\n # Optionally pause on the zeroth step\n self.set_option(tgt_opts,'manual')\n # Number of time steps in the lipid \"equilibration\" run\n self.set_option(tgt_opts,'lipid_eq_steps',forceprint=True)\n # Number of time steps in the lipid \"production\" run\n self.set_option(tgt_opts,'lipid_md_steps',forceprint=True)\n # Number of time steps in the gas \"equilibration\" run\n self.set_option(tgt_opts,'gas_eq_steps',forceprint=False)\n # Number of time steps in the gas \"production\" run\n self.set_option(tgt_opts,'gas_md_steps',forceprint=False)\n # Cutoff for nonbonded interactions in the liquid\n if tgt_opts['nonbonded_cutoff'] is not None:\n self.set_option(tgt_opts,'nonbonded_cutoff')\n # Cutoff for vdW interactions if different from other nonbonded interactions\n if tgt_opts['vdw_cutoff'] is not None:\n self.set_option(tgt_opts,'vdw_cutoff')\n # Time step length (in fs) for the lipid production run\n self.set_option(tgt_opts,'lipid_timestep',forceprint=True)\n # Time interval (in ps) for writing coordinates\n self.set_option(tgt_opts,'lipid_interval',forceprint=True)\n # Time step length (in fs) for the gas production run\n self.set_option(tgt_opts,'gas_timestep',forceprint=True)\n # Time interval (in ps) for writing coordinates\n self.set_option(tgt_opts,'gas_interval',forceprint=True)\n # Minimize the energy prior to running any dynamics\n self.set_option(tgt_opts,'minimize_energy',forceprint=True)\n # Isolated dipole (debye) for analytic self-polarization correction.\n self.set_option(tgt_opts,'self_pol_mu0',forceprint=True)\n # Molecular polarizability (ang**3) for analytic self-polarization correction.\n self.set_option(tgt_opts,'self_pol_alpha',forceprint=True)\n # Set up the simulation object for self-polarization correction.\n self.do_self_pol = (self.self_pol_mu0 > 0.0 and self.self_pol_alpha > 0.0)\n # Enable anisotropic periodic box\n self.set_option(tgt_opts,'anisotropic_box',forceprint=True)\n # Whether to save trajectories (0 = never, 1 = delete after good step, 2 = keep all)\n self.set_option(tgt_opts,'save_traj')\n\n #======================================#\n # Variables which are set here #\n #======================================#\n ## LPW 2018-02-11: This is set to True if the target calculates\n ## a single-point property over several existing snapshots.\n self.loop_over_snapshots = False\n # List of trajectory files that may be deleted if self.save_traj == 1.\n self.last_traj = []\n # Extra files to be copied back at the end of a run.\n self.extra_output = []\n # Read the reference data\n self.read_data()\n # Read in lipid starting coordinates.\n if 'n_ic' in self.RefData:\n # Linked IC folder into the temp-directory.\n self.nptfiles += [\"IC\"]\n # Store IC frames in a dictionary.\n self.lipid_mols = OrderedDict()\n self.lipid_mols_new = OrderedDict()\n for pt in self.PhasePoints:\n pt_label = \"IC/%sK-%s%s\" % (pt[0], pt[1], pt[2])\n if not os.path.exists(os.path.join(self.root, self.tgtdir, pt_label, self.lipid_coords)):\n raise RuntimeError(\"Initial condition files don't exist; please provide IC directory\")\n # Create molecule object for each IC.\n all_ic = Molecule(os.path.join(self.root, self.tgtdir, pt_label, self.lipid_coords))\n self.lipid_mols[pt] = []\n n_uniq_ic = int(self.RefData['n_ic'][pt])\n if n_uniq_ic > len(all_ic):\n raise RuntimeError(\"Number of frames in initial conditions .gro file is less than the number of parallel simulations requested in data.csv\")\n # Index ICs by pressure and temperature in a dictionary.\n for ic in range(n_uniq_ic):\n self.lipid_mols[pt].append(all_ic[ic])\n else:\n # Read in lipid starting coordinates.\n if not os.path.exists(os.path.join(self.root, self.tgtdir, self.lipid_coords)): \n logger.error(\"%s doesn't exist; please provide lipid_coords option\\n\" % self.lipid_coords)\n raise RuntimeError\n self.lipid_mol = Molecule(os.path.join(self.root, self.tgtdir, self.lipid_coords), toppbc=True)\n # Extra files to be linked into the temp-directory.\n self.nptfiles += [self.lipid_coords]\n # Scripts to be copied from the ForceBalance installation directory.\n self.scripts += ['npt_lipid.py']\n # Prepare the temporary directory.\n self.prepare_temp_directory()\n # Build keyword dictionary to pass to engine.\n if self.do_self_pol:\n self.gas_engine_args.update(self.OptionDict)\n self.gas_engine_args.update(options)\n del self.gas_engine_args['name']\n # Create engine object for gas molecule to do the polarization correction.\n self.gas_engine = self.engine_(target=self, mol=self.gas_mol, name=\"selfpol\", **self.gas_engine_args)\n # Don't read indicate.log when calling meta_indicate()\n self.read_indicate = False\n self.write_indicate = False\n # Don't read objective.p when calling meta_get()\n self.read_objective = False\n #======================================#\n # UNDER DEVELOPMENT #\n #======================================#\n # Put stuff here that I'm not sure about. :)\n np.set_printoptions(precision=4, linewidth=100)\n np.seterr(under='ignore')\n ## Saved force field mvals for all iterations\n self.SavedMVal = {}\n ## Saved trajectories for all iterations and all temperatures\n self.SavedTraj = defaultdict(dict)\n ## Evaluated energies for all trajectories (i.e. all iterations and all temperatures), using all mvals\n self.MBarEnergy = defaultdict(lambda:defaultdict(dict))\n\n def prepare_temp_directory(self):\n \"\"\" Prepare the temporary directory by copying in important files. \"\"\"\n abstempdir = os.path.join(self.root,self.tempdir)\n for f in self.nptfiles:\n LinkFile(os.path.join(self.root, self.tgtdir, f), os.path.join(abstempdir, f))\n for f in self.scripts:\n LinkFile(os.path.join(os.path.split(__file__)[0],\"data\",f),os.path.join(abstempdir,f))\n\n def read_data(self):\n # Read the 'data.csv' file. The file should contain guidelines.\n with open(os.path.join(self.tgtdir,'data.csv'),'r') as f: R0 = list(csv.reader(f))\n # All comments are erased.\n R1 = [[sub('#.*$','',word) for word in line] for line in R0 if len(line[0]) > 0 and line[0][0] != \"#\"]\n # All empty lines are deleted and words are converted to lowercase.\n R = [[wrd.lower() for wrd in line] for line in R1 if any([len(wrd) for wrd in line]) > 0]\n global_opts = OrderedDict()\n found_headings = False\n known_vars = ['mbar','rho','hvap','alpha','kappa','cp','eps0','cvib_intra',\n 'cvib_inter','cni','devib_intra','devib_inter', 'al', 'scd', 'n_ic', 'lkappa']\n self.RefData = OrderedDict()\n for line in R:\n if line[0] == \"global\":\n # Global options are mainly denominators for the different observables.\n if isfloat(line[2]):\n global_opts[line[1]] = float(line[2])\n elif line[2].lower() == 'false':\n global_opts[line[1]] = False\n elif line[2].lower() == 'true':\n global_opts[line[1]] = True\n elif not found_headings:\n found_headings = True\n headings = line\n if len(set(headings)) != len(headings):\n logger.error('Column headings in data.csv must be unique\\n')\n raise RuntimeError\n if 'p' not in headings:\n logger.error('There must be a pressure column heading labeled by \"p\" in data.csv\\n')\n raise RuntimeError\n if 't' not in headings:\n logger.error('There must be a temperature column heading labeled by \"t\" in data.csv\\n')\n raise RuntimeError\n elif found_headings:\n try:\n # Temperatures are in kelvin.\n t = [float(val) for head, val in zip(headings,line) if head == 't'][0]\n # For convenience, users may input the pressure in atmosphere or bar.\n pval = [float(val.split()[0]) for head, val in zip(headings,line) if head == 'p'][0]\n punit = [val.split()[1] if len(val.split()) >= 1 else \"atm\" for head, val in zip(headings,line) if head == 'p'][0]\n unrec = set([punit]).difference(['atm','bar']) \n if len(unrec) > 0:\n logger.error('The pressure unit %s is not recognized, please use bar or atm\\n' % unrec[0])\n raise RuntimeError\n # This line actually reads the reference data and inserts it into the RefData dictionary of dictionaries.\n for head, val in zip(headings,line):\n if head == 't' or head == 'p' : continue\n if isfloat(val):\n self.RefData.setdefault(head,OrderedDict([]))[(t,pval,punit)] = float(val.strip())\n elif val.lower() == 'true':\n self.RefData.setdefault(head,OrderedDict([]))[(t,pval,punit)] = True\n elif val.lower() == 'false':\n self.RefData.setdefault(head,OrderedDict([]))[(t,pval,punit)] = False\n elif head == 'scd':\n self.RefData.setdefault(head,OrderedDict([]))[(t,pval,punit)] = np.array(list(map(float, val.split())))\n except:\n logger.error(line + '\\n')\n logger.error('Encountered an error reading this line!\\n')\n raise RuntimeError\n else:\n logger.error(line + '\\n')\n logger.error('I did not recognize this line!\\n')\n raise RuntimeError\n # Check the reference data table for validity.\n default_denoms = defaultdict(int)\n PhasePoints = None\n RefData_copy = copy.deepcopy(self.RefData)\n for head in self.RefData:\n if head == 'n_ic':\n continue\n if head not in known_vars+[i+\"_wt\" for i in known_vars]:\n # Only hard-coded properties may be recognized.\n logger.error(\"The column heading %s is not recognized in data.csv\\n\" % head)\n raise RuntimeError\n if head in known_vars:\n if head+\"_wt\" not in self.RefData:\n # If the phase-point weights are not specified in the reference data file, initialize them all to one.\n RefData_copy[head+\"_wt\"] = OrderedDict([(key, 1.0) for key in self.RefData[head]])\n wts = np.array(list(RefData_copy[head+\"_wt\"].values()))\n dat = np.array(list(self.RefData[head].values()))\n # S_cd specifies an array of averages (one for each tail node). Find avg over axis 0.\n avg = np.average(dat, weights=wts, axis=0)\n if len(wts) > 1:\n # If there is more than one data point, then the default denominator is the\n # standard deviation of the experimental values.\n if head == 'scd':\n default_denoms[head+\"_denom\"] = np.average(np.sqrt(np.dot(wts, (dat-avg)**2)/wts.sum()))\n else:\n default_denoms[head+\"_denom\"] = np.sqrt(np.dot(wts, (dat-avg)**2)/wts.sum())\n else:\n # If there is only one data point, then the denominator is just the single\n # data point itself.\n if head == 'scd':\n default_denoms[head+\"_denom\"] = np.average(np.sqrt(np.abs(dat[0])))\n else:\n default_denoms[head+\"_denom\"] = np.sqrt(np.abs(dat[0]))\n self.PhasePoints = list(self.RefData[head].keys())\n # This prints out all of the reference data.\n # printcool_dictionary(self.RefData[head],head)\n self.RefData = RefData_copy\n # Create labels for the directories.\n self.Labels = [\"%.2fK-%.1f%s\" % i for i in self.PhasePoints]\n logger.debug(\"global_opts:\\n%s\\n\" % str(global_opts))\n logger.debug(\"default_denoms:\\n%s\\n\" % str(default_denoms))\n for opt in global_opts:\n if \"_denom\" in opt:\n # Record entries from the global_opts dictionary so they can be retrieved from other methods.\n self.set_option(global_opts,opt,default=default_denoms[opt])\n else:\n self.set_option(global_opts,opt)\n\n def check_files(self, there):\n there = os.path.abspath(there)\n havepts = 0\n if all([i in os.listdir(there) for i in self.Labels]):\n for d in os.listdir(there):\n if d in self.Labels:\n if os.path.exists(os.path.join(there, d, 'npt_result.p')):\n havepts += 1\n if (float(havepts)/len(self.Labels)) > 0.75:\n return 1\n else:\n return 0\n def npt_simulation(self, temperature, pressure, simnum):\n \"\"\" Submit a NPT simulation to the Work Queue. \"\"\"\n wq = getWorkQueue()\n if not os.path.exists('npt_result.p'):\n link_dir_contents(os.path.join(self.root,self.rundir),os.getcwd())\n self.last_traj += [os.path.join(os.getcwd(), i) for i in self.extra_output]\n self.lipid_mol[simnum%len(self.lipid_mol)].write(self.lipid_coords, ftype='tinker' if self.engname == 'tinker' else None)\n cmdstr = '%s python npt_lipid.py %s %.3f %.3f' % (self.nptpfx, self.engname, temperature, pressure)\n if wq is None:\n logger.info(\"Running condensed phase simulation locally.\\n\")\n logger.info(\"You may tail -f %s/npt.out in another terminal window\\n\" % os.getcwd())\n _exec(cmdstr, copy_stderr=True, outfnm='npt.out')\n else:\n queue_up(wq, command = cmdstr+' &> npt.out',\n input_files = self.nptfiles + self.scripts + ['forcebalance.p'],\n output_files = ['npt_result.p', 'npt.out'] + self.extra_output, tgt=self)\n\n def polarization_correction(self,mvals):\n d = self.gas_engine.get_multipole_moments(optimize=True)['dipole']\n if not in_fd():\n logger.info(\"The molecular dipole moment is % .3f debye\\n\" % np.linalg.norm(d))\n # Taken from the original OpenMM interface code, this is how we calculate the conversion factor.\n # dd2 = ((np.linalg.norm(d)-self.self_pol_mu0)*debye)**2\n # eps0 = 8.854187817620e-12 * coulomb**2 / newton / meter**2\n # epol = 0.5*dd2/(self.self_pol_alpha*angstrom**3*4*np.pi*eps0)/(kilojoule_per_mole/AVOGADRO_CONSTANT_NA)\n # In [2]: eps0 = 8.854187817620e-12 * coulomb**2 / newton / meter**2\n # In [7]: 1.0 * debye ** 2 / (1.0 * angstrom**3*4*np.pi*eps0) / (kilojoule_per_mole/AVOGADRO_CONSTANT_NA)\n # Out[7]: 60.240179789402056\n convert = 60.240179789402056\n dd2 = (np.linalg.norm(d)-self.self_pol_mu0)**2\n epol = 0.5*convert*dd2/self.self_pol_alpha\n return epol\n\n def indicate(self): \n AGrad = hasattr(self, 'Gp')\n PrintDict = OrderedDict()\n def print_item(key, heading, physunit):\n if self.Xp[key] > 0:\n printcool_dictionary(self.Pp[key], title='%s %s%s\\nTemperature Pressure Reference Calculated +- Stdev Delta Weight Term ' % \n (self.name, heading, \" (%s) \" % physunit if physunit else \"\"), bold=True, color=4, keywidth=15)\n bar = printcool(\"%s objective function: % .3f%s\" % (heading, self.Xp[key], \", Derivative:\" if AGrad else \"\"))\n if AGrad:\n self.FF.print_map(vals=self.Gp[key])\n logger.info(bar)\n PrintDict[heading] = \"% 10.5f % 8.3f % 14.5e\" % (self.Xp[key], self.Wp[key], self.Xp[key]*self.Wp[key])\n\n print_item(\"Rho\", \"Density\", \"kg m^-3\")\n print_item(\"Alpha\", \"Thermal Expansion Coefficient\", \"10^-4 K^-1\")\n print_item(\"Kappa\", \"Isothermal Compressibility\", \"10^-6 bar^-1\")\n print_item(\"Cp\", \"Isobaric Heat Capacity\", \"cal mol^-1 K^-1\")\n print_item(\"Eps0\", \"Dielectric Constant\", None)\n print_item(\"Al\", \"Average Area per Lipid\", \"nm^2\")\n print_item(\"Scd\", \"Deuterium Order Parameter\", None)\n print_item(\"LKappa\", \"Bilayer Isothermal Compressibility\", \"mN/m\")\n\n PrintDict['Total'] = \"% 10s % 8s % 14.5e\" % (\"\",\"\",self.Objective)\n\n Title = \"%s Condensed Phase Properties:\\n %-20s %40s\" % (self.name, \"Property Name\", \"Residual x Weight = Contribution\")\n printcool_dictionary(PrintDict,color=4,title=Title,keywidth=31)\n return\n\n def objective_term(self, points, expname, calc, err, grad, name=\"Quantity\", SubAverage=False):\n if expname in self.RefData:\n exp = self.RefData[expname]\n Weights = self.RefData[expname+\"_wt\"]\n Denom = getattr(self,expname+\"_denom\")\n else:\n # If the reference data doesn't exist then return nothing.\n return 0.0, np.zeros(self.FF.np), np.zeros((self.FF.np,self.FF.np)), None\n \n Sum = sum(Weights.values())\n for i in Weights:\n Weights[i] /= Sum\n logger.info(\"Weights have been renormalized to \" + str(sum(Weights.values())) + \"\\n\")\n # Use least-squares or hyperbolic (experimental) objective.\n LeastSquares = True\n\n logger.info(\"Physical quantity %s uses denominator = % .4f\\n\" % (name, Denom))\n if not LeastSquares:\n # If using a hyperbolic functional form\n # we still want the contribution to the \n # objective function to be the same when\n # Delta = Denom.\n Denom /= 3 ** 0.5\n \n Objective = 0.0\n Gradient = np.zeros(self.FF.np)\n Hessian = np.zeros((self.FF.np,self.FF.np))\n Objs = {}\n GradMap = []\n avgCalc = 0.0\n avgExp = 0.0\n avgGrad = np.zeros(self.FF.np)\n for i, PT in enumerate(points):\n avgCalc += Weights[PT]*calc[PT]\n avgExp += Weights[PT]*exp[PT]\n avgGrad += Weights[PT]*grad[PT]\n for i, PT in enumerate(points):\n if SubAverage:\n G = grad[PT]-avgGrad\n Delta = calc[PT] - exp[PT] - avgCalc + avgExp\n else:\n G = grad[PT]\n Delta = calc[PT] - exp[PT]\n if hasattr(Delta, \"__len__\"):\n Delta = np.average(Delta)\n if LeastSquares:\n # Least-squares objective function.\n ThisObj = Weights[PT] * Delta ** 2 / Denom**2\n Objs[PT] = ThisObj\n ThisGrad = 2.0 * Weights[PT] * Delta * G / Denom**2\n GradMap.append(G)\n Objective += ThisObj\n Gradient += ThisGrad\n # Gauss-Newton approximation to the Hessian.\n Hessian += 2.0 * Weights[PT] * (np.outer(G, G)) / Denom**2\n else:\n # L1-like objective function.\n D = Denom\n S = Delta**2 + D**2\n ThisObj = Weights[PT] * (S**0.5-D) / Denom\n ThisGrad = Weights[PT] * (Delta/S**0.5) * G / Denom\n ThisHess = Weights[PT] * (1/S**0.5-Delta**2/S**1.5) * np.outer(G,G) / Denom\n Objs[PT] = ThisObj\n GradMap.append(G)\n Objective += ThisObj\n Gradient += ThisGrad\n Hessian += ThisHess\n GradMapPrint = [[\"#PhasePoint\"] + self.FF.plist]\n for PT, g in zip(points,GradMap):\n GradMapPrint.append([' %8.2f %8.1f %3s' % PT] + [\"% 9.3e\" % i for i in g])\n o = wopen('gradient_%s.dat' % name)\n for line in GradMapPrint:\n print(' '.join(line), file=o)\n o.close()\n \n Delta = np.array([calc[PT] - exp[PT] for PT in points])\n delt = {PT : r for PT, r in zip(points,Delta)}\n if expname == 'scd': \n print_out = OrderedDict([(' %8.2f %8.1f %3s' % PT, '\\n %s' % (' '.join('\\t \\t \\t %9.6f %9.6f +- %-7.6f % 7.6f \\n' % F for F in zip(exp[PT], calc[PT], flat(err[PT]), delt[PT])))) for PT in calc])\n else:\n print_out = OrderedDict([(' %8.2f %8.1f %3s' % PT, \"%9.3f %9.3f +- %-7.3f % 7.3f % 9.5f % 9.5f\" % (exp[PT],calc[PT],err[PT],delt[PT],Weights[PT],Objs[PT])) for PT in calc])\n\n return Objective, Gradient, Hessian, print_out\n\n def submit_jobs(self, mvals, AGrad=True, AHess=True):\n # This routine is called by Objective.stage() will run before \"get\".\n # It submits the jobs to the Work Queue and the stage() function will wait for jobs to complete.\n #\n # First dump the force field to a pickle file\n lp_dump((self.FF,mvals,self.OptionDict,AGrad),'forcebalance.p')\n\n # Give the user an opportunity to copy over data from a previous (perhaps failed) run.\n if (not self.evaluated) and self.manual:\n warn_press_key(\"Now's our chance to fill the temp directory up with data!\\n(Considering using 'read' or 'continue' for better checkpointing)\", timeout=7200)\n\n # If self.save_traj == 1, delete the trajectory files from a previous good optimization step.\n if self.evaluated and self.goodstep and self.save_traj < 2:\n for fn in self.last_traj:\n if os.path.exists(fn):\n os.remove(fn)\n self.last_traj = []\n\n # Set up and run the NPT simulations.\n snum = 0\n for label, pt in zip(self.Labels, self.PhasePoints):\n T = pt[0]\n P = pt[1]\n Punit = pt[2]\n if Punit == 'bar':\n P *= 1.0 / 1.01325\n if not os.path.exists(label):\n os.makedirs(label)\n os.chdir(label)\n if 'n_ic' in self.RefData:\n n_uniq_ic = int(self.RefData['n_ic'][pt])\n # Loop over parallel trajectories.\n for trj in range(n_uniq_ic):\n rel_trj = \"trj_%i\" % trj\n # Create directories for each parallel simulation.\n if not os.path.exists(rel_trj):\n os.makedirs(rel_trj)\n os.chdir(rel_trj)\n # Pull each simulation molecule from the lipid_mols dictionary.\n # lipid_mols is a dictionary of paths to either the initial \n # geometry files, or the geometries from the final frame of the \n # previous iteration.\n self.lipid_mol = self.lipid_mols[pt][trj]\n self.lipid_mol.write(self.lipid_coords)\n if not self.lipid_coords in self.nptfiles:\n self.nptfiles += [self.lipid_coords]\n self.npt_simulation(T,P,snum)\n os.chdir('..')\n else:\n self.npt_simulation(T,P,snum)\n os.chdir('..')\n snum += 1\n\n def get(self, mvals, AGrad=True, AHess=True):\n \n \"\"\"\n Fitting of lipid bulk properties. This is the current major\n direction of development for ForceBalance. Basically, fitting\n the QM energies / forces alone does not always give us the\n best simulation behavior. In many cases it makes more sense\n to try and reproduce some experimentally known data as well.\n\n In order to reproduce experimentally known data, we need to\n run a simulation and compare the simulation result to\n experiment. The main challenge here is that the simulations\n are computationally intensive (i.e. they require energy and\n force evaluations), and furthermore the results are noisy. We\n need to run the simulations automatically and remotely\n (i.e. on clusters) and a good way to calculate the derivatives\n of the simulation results with respect to the parameter values.\n\n This function contains some experimentally known values of the\n density and enthalpy of vaporization (Hvap) of lipid water.\n It launches the density and Hvap calculations on the cluster,\n and gathers the results / derivatives. The actual calculation\n of results / derivatives is done in a separate file.\n\n After the results come back, they are gathered together to form\n an objective function.\n\n @param[in] mvals Mathematical parameter values\n @param[in] AGrad Switch to turn on analytic gradient\n @param[in] AHess Switch to turn on analytic Hessian\n @return Answer Contribution to the objective function\n \n \"\"\"\n\n mbar_verbose = False\n\n Answer = {}\n\n Results = {}\n Points = [] # These are the phase points for which data exists.\n BPoints = [] # These are the phase points for which we are doing MBAR for the condensed phase.\n tt = 0\n for label, PT in zip(self.Labels, self.PhasePoints):\n if 'n_ic' in self.RefData:\n self.lipid_mols[PT] = [Molecule(last_frame) for last_frame in self.lipid_mols[PT]]\n n_uniq_ic = int(self.RefData['n_ic'][PT])\n for ic in range(n_uniq_ic):\n if os.path.exists('./%s/trj_%s/npt_result.p' % (label, ic)):\n # Read in each each parallel simulation's data, and concatenate each property time series.\n ts = lp_load('./%s/trj_%s/npt_result.p' % (label, ic))\n if ic == 0:\n ts_concat = list(ts)\n else:\n for d_arr in range(len(ts)):\n if isinstance(ts[d_arr], np.ndarray):\n # Gradients need a unique append format.\n if d_arr == 5:\n ts_concat[d_arr] = np.append(ts_concat[d_arr], ts[d_arr], axis = 1)\n else:\n ts_concat[d_arr] = np.append(ts_concat[d_arr], ts[d_arr], axis = 0)\n if isinstance(ts_concat[d_arr], list):\n ts_concat[d_arr] = [np.append(ts_concat[d_arr][i], ts[d_arr][i], axis = 1) for i in range(len(ts_concat[d_arr]))]\n # Write concatenated time series to a pickle file.\n if ic == (int(n_uniq_ic) - 1):\n lp_dump((ts_concat), './%s/npt_result.p' % label)\n if os.path.exists('./%s/npt_result.p' % label):\n logger.info('Reading information from ./%s/npt_result.p\\n' % label)\n Points.append(PT)\n Results[tt] = lp_load('./%s/npt_result.p' % label)\n tt += 1\n else:\n logger.warning('The file ./%s/npt_result.p does not exist so we cannot read it\\n' % label)\n pass\n # for obs in self.RefData:\n # del self.RefData[obs][PT]\n if len(Points) == 0:\n logger.error('The lipid simulations have terminated with \\x1b[1;91mno readable data\\x1b[0m - this is a problem!\\n')\n raise RuntimeError\n\n # Assign variable names to all the stuff in npt_result.p\n Rhos, Vols, Potentials, Energies, Dips, Grads, GDips, \\\n Rho_errs, Alpha_errs, Kappa_errs, Cp_errs, Eps0_errs, NMols, Als, Al_errs, Scds, Scd_errs, LKappa_errs = ([Results[t][i] for t in range(len(Points))] for i in range(18))\n # Determine the number of molecules\n if len(set(NMols)) != 1:\n logger.error(str(NMols))\n logger.error('The above list should only contain one number - the number of molecules\\n')\n raise RuntimeError\n else:\n NMol = list(set(NMols))[0]\n \n R = np.array(list(itertools.chain(*list(Rhos))))\n V = np.array(list(itertools.chain(*list(Vols))))\n E = np.array(list(itertools.chain(*list(Energies))))\n Dx = np.array(list(itertools.chain(*list(d[:,0] for d in Dips))))\n Dy = np.array(list(itertools.chain(*list(d[:,1] for d in Dips))))\n Dz = np.array(list(itertools.chain(*list(d[:,2] for d in Dips))))\n G = np.hstack(tuple(Grads))\n GDx = np.hstack(tuple(gd[0] for gd in GDips))\n GDy = np.hstack(tuple(gd[1] for gd in GDips))\n GDz = np.hstack(tuple(gd[2] for gd in GDips))\n A = np.array(list(itertools.chain(*list(Als))))\n S = np.array(list(itertools.chain(*list(Scds))))\n\n Rho_calc = OrderedDict([])\n Rho_grad = OrderedDict([])\n Rho_std = OrderedDict([])\n Alpha_calc = OrderedDict([])\n Alpha_grad = OrderedDict([])\n Alpha_std = OrderedDict([])\n Kappa_calc = OrderedDict([])\n Kappa_grad = OrderedDict([])\n Kappa_std = OrderedDict([])\n Cp_calc = OrderedDict([])\n Cp_grad = OrderedDict([])\n Cp_std = OrderedDict([])\n Eps0_calc = OrderedDict([])\n Eps0_grad = OrderedDict([])\n Eps0_std = OrderedDict([])\n Al_calc = OrderedDict([])\n Al_grad = OrderedDict([])\n Al_std = OrderedDict([])\n LKappa_calc = OrderedDict([])\n LKappa_grad = OrderedDict([])\n LKappa_std = OrderedDict([])\n Scd_calc = OrderedDict([])\n Scd_grad = OrderedDict([])\n Scd_std = OrderedDict([])\n\n # The unit that converts atmospheres * nm**3 into kj/mol :)\n pvkj=0.061019351687175\n \n # Run MBAR using the total energies. Required for estimates that use the kinetic energy.\n BSims = len(BPoints)\n Shots = len(Energies[0])\n Shots_m = [len(i) for i in Energies]\n N_k = np.ones(BSims)*Shots\n # Use the value of the energy for snapshot t from simulation k at potential m\n U_kln = np.zeros([BSims,BSims,Shots])\n for m, PT in enumerate(BPoints):\n T = PT[0]\n P = PT[1] / 1.01325 if PT[2] == 'bar' else PT[1]\n beta = 1. / (kb * T)\n for k in range(BSims):\n # The correct Boltzmann factors include PV.\n # Note that because the Boltzmann factors are computed from the conditions at simulation \"m\",\n # the pV terms must be rescaled to the pressure at simulation \"m\".\n kk = Points.index(BPoints[k])\n U_kln[k, m, :] = Energies[kk] + P*Vols[kk]*pvkj\n U_kln[k, m, :] *= beta\n W1 = None\n if len(BPoints) > 1:\n logger.info(\"Running MBAR analysis on %i states...\\n\" % len(BPoints))\n mbar = pymbar.MBAR(U_kln, N_k, verbose=mbar_verbose, relative_tolerance=5.0e-8)\n W1 = mbar.getWeights()\n logger.info(\"Done\\n\")\n elif len(BPoints) == 1:\n W1 = np.ones((BPoints*Shots,BPoints))\n W1 /= BPoints*Shots\n \n def fill_weights(weights, phase_points, mbar_points, snapshots):\n \"\"\" Fill in the weight matrix with MBAR weights where MBAR was run, \n and equal weights otherwise. \"\"\"\n new_weights = np.zeros([len(phase_points)*snapshots,len(phase_points)])\n for m, PT in enumerate(phase_points):\n if PT in mbar_points:\n mm = mbar_points.index(PT)\n for kk, PT1 in enumerate(mbar_points):\n k = phase_points.index(PT1)\n logger.debug(\"Will fill W2[%i:%i,%i] with W1[%i:%i,%i]\\n\" % (k*snapshots,k*snapshots+snapshots,m,kk*snapshots,kk*snapshots+snapshots,mm))\n new_weights[k*snapshots:(k+1)*snapshots,m] = weights[kk*snapshots:(kk+1)*snapshots,mm]\n else:\n logger.debug(\"Will fill W2[%i:%i,%i] with equal weights\\n\" % (m*snapshots,(m+1)*snapshots,m))\n new_weights[m*snapshots:(m+1)*snapshots,m] = 1.0/snapshots\n return new_weights\n \n W2 = fill_weights(W1, Points, BPoints, Shots)\n\n if self.do_self_pol:\n EPol = self.polarization_correction(mvals)\n GEPol = np.array([(f12d3p(fdwrap(self.polarization_correction, mvals, p), h = self.h, f0 = EPol)[0] if p in self.pgrad else 0.0) for p in range(self.FF.np)])\n bar = printcool(\"Self-polarization correction to \\nenthalpy of vaporization is % .3f kJ/mol%s\" % (EPol, \", Derivative:\" if AGrad else \"\"))\n if AGrad:\n self.FF.print_map(vals=GEPol)\n logger.info(bar)\n \n for i, PT in enumerate(Points):\n T = PT[0]\n P = PT[1] / 1.01325 if PT[2] == 'bar' else PT[1]\n PV = P*V*pvkj\n H = E + PV\n # The weights that we want are the last ones.\n W = flat(W2[:,i])\n C = weight_info(W, PT, np.ones(len(Points), dtype=int)*Shots, verbose=mbar_verbose)\n Gbar = flat(np.dot(G,col(W)))\n mBeta = -1/kb/T\n Beta = 1/kb/T\n kT = kb*T\n # Define some things to make the analytic derivatives easier.\n def avg(vec):\n return np.dot(W,vec)\n def covde(vec):\n return flat(np.dot(G,col(W*vec))) - avg(vec)*Gbar\n def deprod(vec):\n return flat(np.dot(G,col(W*vec)))\n ## Density.\n Rho_calc[PT] = np.dot(W,R)\n Rho_grad[PT] = mBeta*(flat(np.dot(G,col(W*R))) - np.dot(W,R)*Gbar)\n ## Ignore enthalpy.\n ## Thermal expansion coefficient.\n Alpha_calc[PT] = 1e4 * (avg(H*V)-avg(H)*avg(V))/avg(V)/(kT*T)\n GAlpha1 = -1 * Beta * deprod(H*V) * avg(V) / avg(V)**2\n GAlpha2 = +1 * Beta * avg(H*V) * deprod(V) / avg(V)**2\n GAlpha3 = deprod(V)/avg(V) - Gbar\n GAlpha4 = Beta * covde(H)\n Alpha_grad[PT] = 1e4 * (GAlpha1 + GAlpha2 + GAlpha3 + GAlpha4)/(kT*T)\n ## Isothermal compressibility.\n bar_unit = 0.06022141793 * 1e6\n Kappa_calc[PT] = bar_unit / kT * (avg(V**2)-avg(V)**2)/avg(V)\n GKappa1 = +1 * Beta**2 * avg(V**2) * deprod(V) / avg(V)**2\n GKappa2 = -1 * Beta**2 * avg(V) * deprod(V**2) / avg(V)**2\n GKappa3 = +1 * Beta**2 * covde(V)\n Kappa_grad[PT] = bar_unit*(GKappa1 + GKappa2 + GKappa3)\n ## Isobaric heat capacity.\n Cp_calc[PT] = 1000/(4.184*NMol*kT*T) * (avg(H**2) - avg(H)**2)\n if hasattr(self,'use_cvib_intra') and self.use_cvib_intra:\n logger.debug(\"Adding \" + str(self.RefData['devib_intra'][PT]) + \" to the heat capacity\\n\")\n Cp_calc[PT] += self.RefData['devib_intra'][PT]\n if hasattr(self,'use_cvib_inter') and self.use_cvib_inter:\n logger.debug(\"Adding \" + str(self.RefData['devib_inter'][PT]) + \" to the heat capacity\\n\")\n Cp_calc[PT] += self.RefData['devib_inter'][PT]\n GCp1 = 2*covde(H) * 1000 / 4.184 / (NMol*kT*T)\n GCp2 = mBeta*covde(H**2) * 1000 / 4.184 / (NMol*kT*T)\n GCp3 = 2*Beta*avg(H)*covde(H) * 1000 / 4.184 / (NMol*kT*T)\n Cp_grad[PT] = GCp1 + GCp2 + GCp3\n ## Static dielectric constant.\n prefactor = 30.348705333964077\n D2 = avg(Dx**2)+avg(Dy**2)+avg(Dz**2)-avg(Dx)**2-avg(Dy)**2-avg(Dz)**2\n Eps0_calc[PT] = 1.0 + prefactor*(D2/avg(V))/T\n GD2 = 2*(flat(np.dot(GDx,col(W*Dx))) - avg(Dx)*flat(np.dot(GDx,col(W)))) - Beta*(covde(Dx**2) - 2*avg(Dx)*covde(Dx))\n GD2 += 2*(flat(np.dot(GDy,col(W*Dy))) - avg(Dy)*flat(np.dot(GDy,col(W)))) - Beta*(covde(Dy**2) - 2*avg(Dy)*covde(Dy))\n GD2 += 2*(flat(np.dot(GDz,col(W*Dz))) - avg(Dz)*flat(np.dot(GDz,col(W)))) - Beta*(covde(Dz**2) - 2*avg(Dz)*covde(Dz))\n Eps0_grad[PT] = prefactor*(GD2/avg(V) - mBeta*covde(V)*D2/avg(V)**2)/T\n ## Average area per lipid\n Al_calc[PT] = np.dot(W,A)\n Al_grad[PT] = mBeta*(flat(np.dot(G,col(W*A))) - np.dot(W,A)*Gbar)\n ## Bilayer Isothermal compressibility.\n A_m2 = A * 1e-18\n kbT = 1.3806488e-23 * T\n LKappa_calc[PT] = (1e3 * 2 * kbT / 128) * (avg(A_m2) / (avg(A_m2**2)-avg(A_m2)**2))\n al_avg = avg(A_m2)\n al_sq_avg = avg(A_m2**2)\n al_avg_sq = al_avg**2\n al_var = al_sq_avg - al_avg_sq\n GLKappa1 = covde(A_m2) / al_var\n GLKappa2 = (al_avg / al_var**2) * (covde(A_m2**2) - (2 * al_avg * covde(A)))\n LKappa_grad[PT] = (1e3 * 2 * kbT / 128) * (GLKappa1 - GLKappa2)\n ## Deuterium order parameter\n Scd_calc[PT] = np.dot(W,S)\n # LPW: In case I did not do the conversion correctly, the line of code previously here was:\n # Scd_grad[PT] = mBeta * (flat(np.average(np.mat(G) * (S * W[:, np.newaxis]), axis = 1)) - np.average(np.average(S * W[:, np.newaxis], axis = 0), axis = 0) * Gbar) \n Scd_grad[PT] = mBeta * (flat(np.average(np.dot(G, (S * W[:, np.newaxis])), axis = 1)) - np.average(np.average(S * W[:, np.newaxis], axis = 0), axis = 0) * Gbar) \n ## Estimation of errors.\n Rho_std[PT] = np.sqrt(sum(C**2 * np.array(Rho_errs)**2))\n Alpha_std[PT] = np.sqrt(sum(C**2 * np.array(Alpha_errs)**2)) * 1e4\n Kappa_std[PT] = np.sqrt(sum(C**2 * np.array(Kappa_errs)**2)) * 1e6\n Cp_std[PT] = np.sqrt(sum(C**2 * np.array(Cp_errs)**2))\n Eps0_std[PT] = np.sqrt(sum(C**2 * np.array(Eps0_errs)**2))\n Al_std[PT] = np.sqrt(sum(C**2 * np.array(Al_errs)**2))\n # LPW: In case I did not do the conversion correctly, the line of code previously here was:\n # Scd_std[PT] = np.sqrt(sum(np.mat(C**2) * np.array(Scd_errs)**2))\n Scd_std[PT] = np.sqrt(sum(np.dot(row(C**2), np.array(Scd_errs)**2)))\n LKappa_std[PT] = np.sqrt(sum(C**2 * np.array(LKappa_errs)**2)) * 1e6\n\n # Get contributions to the objective function\n X_Rho, G_Rho, H_Rho, RhoPrint = self.objective_term(Points, 'rho', Rho_calc, Rho_std, Rho_grad, name=\"Density\")\n X_Alpha, G_Alpha, H_Alpha, AlphaPrint = self.objective_term(Points, 'alpha', Alpha_calc, Alpha_std, Alpha_grad, name=\"Thermal Expansion\")\n X_Kappa, G_Kappa, H_Kappa, KappaPrint = self.objective_term(Points, 'kappa', Kappa_calc, Kappa_std, Kappa_grad, name=\"Compressibility\")\n X_Cp, G_Cp, H_Cp, CpPrint = self.objective_term(Points, 'cp', Cp_calc, Cp_std, Cp_grad, name=\"Heat Capacity\")\n X_Eps0, G_Eps0, H_Eps0, Eps0Print = self.objective_term(Points, 'eps0', Eps0_calc, Eps0_std, Eps0_grad, name=\"Dielectric Constant\")\n X_Al, G_Al, H_Al, AlPrint = self.objective_term(Points, 'al', Al_calc, Al_std, Al_grad, name=\"Avg Area per Lipid\")\n X_Scd, G_Scd, H_Scd, ScdPrint = self.objective_term(Points, 'scd', Scd_calc, Scd_std, Scd_grad, name=\"Deuterium Order Parameter\")\n X_LKappa, G_LKappa, H_LKappa, LKappaPrint = self.objective_term(Points, 'lkappa', LKappa_calc, LKappa_std, LKappa_grad, name=\"Bilayer Compressibility\")\n\n Gradient = np.zeros(self.FF.np)\n Hessian = np.zeros((self.FF.np,self.FF.np))\n\n if X_Rho == 0: self.w_rho = 0.0\n if X_Alpha == 0: self.w_alpha = 0.0\n if X_Kappa == 0: self.w_kappa = 0.0\n if X_Cp == 0: self.w_cp = 0.0\n if X_Eps0 == 0: self.w_eps0 = 0.0\n if X_Al == 0: self.w_al = 0.0\n if X_Scd == 0: self.w_scd = 0.0\n if X_LKappa == 0: self.w_lkappa = 0.0\n\n if self.w_normalize:\n w_tot = self.w_rho + self.w_alpha + self.w_kappa + self.w_cp + self.w_eps0 + self.w_al + self.w_scd + self.w_lkappa\n else:\n w_tot = 1.0\n w_1 = self.w_rho / w_tot\n w_3 = self.w_alpha / w_tot\n w_4 = self.w_kappa / w_tot\n w_5 = self.w_cp / w_tot\n w_6 = self.w_eps0 / w_tot\n w_7 = self.w_al / w_tot\n w_8 = self.w_scd / w_tot\n w_9 = self.w_lkappa / w_tot\n\n Objective = w_1 * X_Rho + w_3 * X_Alpha + w_4 * X_Kappa + w_5 * X_Cp + w_6 * X_Eps0 + w_7 * X_Al + w_8 * X_Scd + w_9 * X_LKappa\n if AGrad:\n Gradient = w_1 * G_Rho + w_3 * G_Alpha + w_4 * G_Kappa + w_5 * G_Cp + w_6 * G_Eps0 + w_7 * G_Al + w_8 * G_Scd + w_9 * G_LKappa\n if AHess:\n Hessian = w_1 * H_Rho + w_3 * H_Alpha + w_4 * H_Kappa + w_5 * H_Cp + w_6 * H_Eps0 + w_7 * H_Al + w_8 * H_Scd + w_9 * H_LKappa\n\n if not in_fd():\n self.Xp = {\"Rho\" : X_Rho, \"Alpha\" : X_Alpha, \n \"Kappa\" : X_Kappa, \"Cp\" : X_Cp, \"Eps0\" : X_Eps0, \"Al\" : X_Al, \"Scd\" : X_Scd, \"LKappa\" : X_LKappa}\n self.Wp = {\"Rho\" : w_1, \"Alpha\" : w_3, \n \"Kappa\" : w_4, \"Cp\" : w_5, \"Eps0\" : w_6, \"Al\" : w_7, \"Scd\" : w_8, \"LKappa\" : w_9}\n self.Pp = {\"Rho\" : RhoPrint, \"Alpha\" : AlphaPrint, \n \"Kappa\" : KappaPrint, \"Cp\" : CpPrint, \"Eps0\" : Eps0Print, \"Al\" : AlPrint, \"Scd\" : ScdPrint, \"LKappa\": LKappaPrint}\n if AGrad:\n self.Gp = {\"Rho\" : G_Rho, \"Alpha\" : G_Alpha, \n \"Kappa\" : G_Kappa, \"Cp\" : G_Cp, \"Eps0\" : G_Eps0, \"Al\" : G_Al, \"Scd\" : G_Scd, \"LKappa\" : G_LKappa}\n self.Objective = Objective\n\n Answer = {'X':Objective, 'G':Gradient, 'H':Hessian}\n return Answer\n", "meta": {"hexsha": "1cf809b629306e177d82d1e4434ff7f82730f6ef", "size": 45099, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/lipid.py", "max_stars_repo_name": "cresset-group/forcebalance", "max_stars_repo_head_hexsha": "78a48d0e9ee9b5a8f3295cee8a811ad4cfcd2aa6", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 98, "max_stars_repo_stars_event_min_datetime": "2015-03-31T06:42:14.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-13T12:07:37.000Z", "max_issues_repo_path": "src/lipid.py", "max_issues_repo_name": "cresset-group/forcebalance", "max_issues_repo_head_hexsha": "78a48d0e9ee9b5a8f3295cee8a811ad4cfcd2aa6", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 121, "max_issues_repo_issues_event_min_datetime": "2015-07-13T15:57:02.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-24T20:07:10.000Z", "max_forks_repo_path": "src/lipid.py", "max_forks_repo_name": "cresset-group/forcebalance", "max_forks_repo_head_hexsha": "78a48d0e9ee9b5a8f3295cee8a811ad4cfcd2aa6", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 66, "max_forks_repo_forks_event_min_datetime": "2015-04-06T03:05:04.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-26T05:11:59.000Z", "avg_line_length": 53.5617577197, "max_line_length": 212, "alphanum_fraction": 0.564181024, "include": true, "reason": "import numpy", "num_tokens": 11916, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073802837478, "lm_q2_score": 0.35220178204788966, "lm_q1q2_score": 0.19392490054465603}} {"text": "# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\"\"\"\nQuantum chemistry module\n\"\"\"\n\nimport os\nimport re\nimport numpy as np\nimport psi4\nimport openfermion\nfrom openfermion import MolecularData, transforms\nfrom openfermion.ops import general_basis_change\nfrom paddle_quantum.utils import Hamiltonian\n\n__all__ = [\n \"geometry\",\n \"get_molecular_data\",\n \"active_space\",\n \"fermionic_hamiltonian\",\n \"spin_hamiltonian\"\n]\n\n\ndef _hamiltonian_transformation(spin_h, tol=1e-8):\n r\"\"\"将哈密顿量从 openfermion 格式转换成 Paddle Quantum 格式。\n\n Warning:\n 输入的哈密顿量必须为埃尔米特的，输入的哈密顿中虚数的系数会和实数一起转换成他们的范数 (norm)。\n\n Args:\n spin_h (openfermion.ops.operators.qubit_operator.QubitOperator): openfermion 格式的哈密顿量\n tol (float, optional): 系数小于 tol 的值将被忽略掉，默认为 1e-8\n\n Returns:\n paddle_quantum.Hamiltonian object: Paddle Quantum 格式的哈密顿量\n \"\"\"\n terms = spin_h.__str__().split('+\\n')\n spin_h.compress(abs_tol=tol)\n pauli_str = []\n for term in terms:\n decomposed_term = re.match(r\"(.*) \\[(.*)\\].*\", term).groups()\n if decomposed_term[1] == '':\n try:\n pauli_str.append([float(decomposed_term[0]), 'I'])\n except ValueError:\n if complex(decomposed_term[0]).real > 0:\n pauli_str.append([abs(complex(decomposed_term[0])), 'I'])\n else:\n pauli_str.append([-abs(complex(decomposed_term[0])), 'I'])\n else:\n term_str = ', '.join(re.split(r' ', decomposed_term[1]))\n try:\n pauli_str.append([float(decomposed_term[0]), term_str])\n except ValueError:\n if complex(decomposed_term[0]).real > 0:\n pauli_str.append([abs(complex(decomposed_term[0])), term_str])\n else:\n pauli_str.append([-abs(complex(decomposed_term[0])), term_str])\n return Hamiltonian(pauli_str)\n\n\ndef _geo_str(geometry):\n r\"\"\"创建分子几何信息的字符串。\n\n Args:\n geometry (list): 包含了分子的几何信息，以 H2 分子为例\n [['H', [-1.68666, 1.79811, 0.0]], ['H', [-1.12017, 1.37343, 0.0]]]。\n\n Returns:\n str: 分子几何信息的字符串。\n \"\"\"\n geo_str = ''\n for item in geometry:\n atom_symbol = item[0]\n position = item[1]\n line = '{} {} {} {}'.format(atom_symbol,\n position[0],\n position[1],\n position[2])\n if len(geo_str) > 0:\n geo_str += '\\n'\n geo_str += line\n geo_str += '\\nsymmetry c1'\n return geo_str\n\n\ndef _run_psi4(\n molecule,\n charge,\n multiplicity,\n method,\n basis,\n if_print,\n if_save\n):\n r\"\"\"计算分子的必要信息，包括单体积分 (one-body integrations) 和双体积分 (two-body integrations)，\n 以及用 scf 和 fci 的方法计算基态的能量。\n\n Args:\n molecule (MolecularData object): 包含分子所有信息的类 (class)。\n charge (int): 分子的电荷。\n multiplicity (int): 分子的多重度。\n method (str): 用于计算基态能量的方法，包括 'scf'和 'fci'。\n basis (str): 常用的基组是 'sto-3g', '6-31g'等。更多的基组选择可以参考网站。\n https://psicode.org/psi4manual/master/basissets_byelement.html#apdx-basiselement。\n if_print (Boolean): 是否需要打印出选定方法 (method) 计算出的分子基态能量。\n if_save (Boolean): 是否需要将分子信息存储成 .hdf5 文件。\n \"\"\"\n psi4.set_memory('500 MB')\n psi4.set_options({'soscf': 'false',\n 'scf_type': 'pk'})\n geo = molecule.geometry\n mol = psi4.geometry(_geo_str(geo))\n mol.set_multiplicity(multiplicity)\n mol.set_molecular_charge(charge)\n\n if molecule.multiplicity == 1:\n psi4.set_options({'reference': 'rhf',\n 'guess': 'sad'})\n else:\n psi4.set_options({'reference': 'rohf',\n 'guess': 'gwh'})\n\n # HF calculation\n hf_energy, hf_wfn = psi4.energy('scf/' + basis, molecule=mol, return_wfn='on')\n # Get orbitals and Fock matrix.\n molecule.hf_energy = hf_energy\n molecule.nuclear_repulsion = mol.nuclear_repulsion_energy()\n molecule.canonical_orbitals = np.asarray(hf_wfn.Ca())\n molecule.overlap_integrals = np.asarray(hf_wfn.S())\n molecule.n_orbitals = molecule.canonical_orbitals.shape[0]\n molecule.n_qubits = 2 * molecule.n_orbitals\n molecule.orbital_energies = np.asarray(hf_wfn.epsilon_a())\n molecule.fock_matrix = np.asarray(hf_wfn.Fa())\n\n # Get integrals using MintsHelper.\n mints = psi4.core.MintsHelper(hf_wfn.basisset())\n\n molecule.one_body_integrals = general_basis_change(\n np.asarray(mints.ao_kinetic()), molecule.canonical_orbitals, (1, 0))\n molecule.one_body_integrals += general_basis_change(\n np.asarray(mints.ao_potential()), molecule.canonical_orbitals, (1, 0))\n two_body_integrals = np.asarray(mints.ao_eri())\n two_body_integrals.reshape((molecule.n_orbitals, molecule.n_orbitals,\n molecule.n_orbitals, molecule.n_orbitals))\n two_body_integrals = np.einsum('psqr', two_body_integrals)\n two_body_integrals = general_basis_change(\n two_body_integrals, molecule.canonical_orbitals, (1, 1, 0, 0))\n molecule.two_body_integrals = two_body_integrals\n\n # FCI calculation\n psi4.set_options({'qc_module': 'detci'})\n fci_energy, fci_wfn = psi4.energy('fci/' + basis, molecule=mol, return_wfn='on')\n molecule.fci_energy = fci_energy\n\n if if_save is True:\n molecule.save()\n\n if if_print is True:\n if method == 'scf':\n print('Hartree-Fock energy for {} ({} electrons) is {}.'.format(\n molecule.name, molecule.n_electrons, hf_energy))\n\n elif method == 'fci':\n print('FCI energy for {} ({} electrons) is {}.'.format(\n molecule.name, molecule.n_electrons, fci_energy))\n elif method == '':\n print('Calculation is done')\n\n\ndef geometry(structure=None, file=None):\n r\"\"\"读取分子的几何信息。\n\n Args:\n structure (string, optional): 分子几何信息的字符串形式，以 H2 分子为例\n ``[['H', [-1.68666, 1.79811, 0.0]], ['H', [-1.12017, 1.37343, 0.0]]]``\n file (string, optional): .xyz 文件的路径\n\n Returns:\n str: 分子的几何信息\n\n Raises:\n AssertionError: 两个输入参数不可以同时为 ``None`` 。\n \"\"\"\n if ((structure is None) and (file is None)):\n raise AssertionError('Input must be structure or .xyz file')\n elif file is None:\n shape = np.array(structure).shape\n assert shape[1] == 2, 'The shape of structure must be (n, 2)'\n for i in range(shape[0]):\n assert type(np.array(structure)[:, 0][i]) == str, 'The first position must be element symbol'\n assert len(np.array(structure)[:, 1][i]) == 3, 'The second position represents coordinate ' \\\n 'of particle: x, y, z'\n geo = structure\n elif structure is None:\n assert file[-4:] == '.xyz', 'The file is supposed to be .xyz'\n geo = []\n with open(file) as f:\n for line in f.readlines()[2:]:\n one_geo = []\n\n symbol, x, y, z = line.split()\n one_geo.append(symbol)\n one_geo.append([float(x), float(y), float(z)])\n geo.append(one_geo)\n\n return geo\n\n\ndef get_molecular_data(\n geometry,\n charge=0,\n multiplicity=1,\n basis='sto-3g',\n method='scf',\n if_save=True,\n if_print=True,\n name=\"\",\n file_path=\".\"\n):\n r\"\"\"计算分子的必要信息，包括单体积分（one-body integrations）和双体积分（two-body integrations），\n 以及用选定的方法计算基态的能量。\n\n Args:\n geometry (str): 分子的几何信息\n charge (int, optional): 分子的电荷，默认值为 0\n multiplicity (int, optional): 分子的多重度，默认值为 1\n basis (str, optional): 常用的基组是 ``'sto-3g'`` 、 ``'6-31g'`` 等，默认的基组是 ``'sto-3g'``，更多的基组选择可以参考网站\n https://psicode.org/psi4manual/master/basissets_byelement.html#apdx-basiselement\n method (str, optional): 用于计算基态能量的方法，包括 ``'scf'`` 和 ``'fci'`` ，默认方法为 ``'scf'``\n if_save (bool, optional): 是否需要将分子信息存储成 .hdf5 文件，默认为 ``True``\n if_print (bool, optional): 是否需要打印出选定方法 (method) 计算出的分子基态能量，默认为 ``True``\n name (str, optional): 命名储存的文件，默认为 ``\"\"``\n file_path (str, optional): 文件的储存路径，默认为 ``\".\"``\n\n Returns:\n MolecularData: 包含分子所有信息的类\n \"\"\"\n methods = ['scf', 'fci']\n assert method in methods, 'We provide 2 methods: scf and fci'\n\n if if_save is True:\n path = file_path + '/qchem_data/'\n folder = os.path.exists(path)\n if not folder:\n os.makedirs(path)\n if name == \"\":\n elements = np.array(geometry)[:, 0]\n symbol, counts = np.unique(elements, return_counts=True)\n filename = path\n for i in range(len(symbol)):\n filename += symbol[i]+str(counts[i])+'_'\n filename += basis + '_' + method + '.hdf5'\n else:\n if name[-5:] == '.hdf5':\n filename = name\n else:\n filename = name + '.hdf5'\n\n molecule = MolecularData(geometry,\n basis=basis,\n multiplicity=multiplicity,\n charge=charge,\n filename=filename)\n\n _run_psi4(molecule,\n charge,\n multiplicity,\n method,\n basis,\n if_print,\n if_save)\n\n return molecule\n\n\ndef active_space(electrons,\n orbitals,\n multiplicity=1,\n active_electrons=None,\n active_orbitals=None):\n r\"\"\"对于给定的活跃电子和活跃轨道计算相应的活跃空间（active space）。\n\n Args:\n electrons (int): 电子数\n orbitals (int): 轨道数\n multiplicity (int, optional): 自旋多重度\n active_electrons (int, optional): 活跃 (active) 电子数，默认情况为所有电子均为活跃电子\n active_orbitals (int, optional): 活跃 (active) 轨道数，默认情况为所有轨道均为活跃轨道\n\n Returns:\n tuple: 核心轨道和活跃轨道的索引\n \"\"\"\n assert type(electrons) == int and electrons > 0, 'Number of electrons must be positive integer.'\n assert type(orbitals) == int and orbitals > 0, 'Number of orbitals must be positive integer.'\n assert type(multiplicity) == int and multiplicity >= 0, 'The multiplicity must be non-negative integer.'\n\n if active_electrons is None:\n no_core_orbitals = 0\n core_orbitals = []\n else:\n assert type(active_electrons) == int, 'The number of active electrons must be integer.'\n assert active_electrons > 0, 'The number of active electrons must be greater than 0.'\n assert electrons >= active_electrons, 'The number of electrons should more than or equal ' \\\n 'to the number of active electrons.'\n assert active_electrons >= multiplicity - 1, 'The number of active electrons should greater than ' \\\n 'or equal to multiplicity - 1.'\n assert multiplicity % 2 != active_electrons % 2, 'Mulitiplicity and active electrons should be one odd ' \\\n 'and the other one even.'\n\n no_core_orbitals = (electrons - active_electrons) // 2\n core_orbitals = list(np.arange(0, no_core_orbitals))\n\n if active_orbitals is None:\n active_orbitals = list(np.arange(no_core_orbitals, orbitals))\n else:\n assert type(active_orbitals) == int, 'The number of active orbitals must be integer.'\n assert active_orbitals > 0, 'The number of active orbitals must be greater than 0.'\n assert no_core_orbitals + active_orbitals <= orbitals, 'The summation of core orbitals and active ' \\\n 'orbitals should be smaller than orbitals.'\n assert no_core_orbitals + active_orbitals > (electrons + multiplicity - 1) / 2, \\\n 'The summation of core orbitals and active orbitals should be greater than ' \\\n '(electrons + multiplicity - 1)/2.'\n\n active_orbitals = list(np.arange(no_core_orbitals, no_core_orbitals + active_orbitals))\n\n return core_orbitals, active_orbitals\n\n\ndef fermionic_hamiltonian(molecule,\n filename=None,\n multiplicity=1,\n active_electrons=None,\n active_orbitals=None):\n r\"\"\"计算给定分子的费米哈密顿量。\n\n Args:\n molecule (MolecularData): 包含分子所有信息的类\n filename (str, optional): 分子的 .hdf5 文件的路径\n multiplicity (int, optional): 自旋多重度\n active_electrons (int, optional): 活跃 (active) 电子数，默认情况为所有电子均为活跃电子\n active_orbitals (int, optional): 活跃 (active) 轨道数，默认情况为所有轨道均为活跃轨道\n\n Returns:\n openfermion.ops.operators.qubit_operator.QubitOperator: openfermion 格式的哈密顿量\n \"\"\"\n if molecule is None:\n assert type(filename) == str, 'Please provide the path of .hdf5 file.'\n assert filename[-5:] == '.hdf5', 'The filename is supposed to be .hdf5 file'\n molecule = MolecularData(filename=filename)\n core_orbitals, active_orbitals = active_space(\n molecule.n_electrons,\n molecule.n_orbitals,\n multiplicity,\n active_electrons,\n active_orbitals)\n terms_molecular_hamiltonian = molecule.get_molecular_hamiltonian(\n occupied_indices=core_orbitals, active_indices=active_orbitals\n )\n fermionic_hamiltonian = openfermion.transforms.get_fermion_operator(terms_molecular_hamiltonian)\n\n return fermionic_hamiltonian\n\n\ndef spin_hamiltonian(molecule,\n filename=None,\n multiplicity=1,\n mapping_method='jordan_wigner',\n active_electrons=None,\n active_orbitals=None):\n r\"\"\"生成 Paddle Quantum 格式的哈密顿量\n\n Args:\n molecule (openfermion.ops.operators.qubit_operator.QubitOperator): openfermion 格式的哈密顿量\n filename (str, optional): 分子的 .hdf5 文件的路径\n multiplicity (int, optional): 自旋多重度\n mapping_method (str, optional): 映射方法，这里默认为 ``'jordan_wigner'`` ，此外还提供 ``'bravyi_kitaev'``\n active_electrons (int, optional): 活跃 (active) 电子数，默认情况为所有电子均为活跃电子\n active_orbitals (int, optional): 活跃 (active) 轨道数默认情况为所有轨道均为活跃轨道\n\n Returns:\n paddle_quantum.utils.Hamiltonian: Paddle Quantum 格式的哈密顿量\n \"\"\"\n assert mapping_method in ['jordan_wigner', 'bravyi_kitaev'], \"Please choose the mapping \" \\\n \"in ['jordan_wigner', 'bravyi_kitaev'].\"\n fermionic_h = fermionic_hamiltonian(molecule,\n filename,\n multiplicity,\n active_electrons,\n active_orbitals)\n\n if mapping_method == 'jordan_wigner':\n spin_h = transforms.jordan_wigner(fermionic_h)\n elif mapping_method == 'bravyi_kitaev':\n spin_h = transforms.bravyi_kitaev(fermionic_h)\n return _hamiltonian_transformation(spin_h, tol=1e-8)\n", "meta": {"hexsha": "2e5a54fa29ac97b0008e8b4b65a9843d6feef787", "size": 15486, "ext": "py", "lang": "Python", "max_stars_repo_path": "paddle_quantum/qchem.py", "max_stars_repo_name": "gsq7474741/Quantum", "max_stars_repo_head_hexsha": "16e7d3bf2dba7e94e6faf5c853faf0e913e1f268", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-07-14T14:10:23.000Z", "max_stars_repo_stars_event_max_datetime": "2020-07-14T14:10:23.000Z", "max_issues_repo_path": "paddle_quantum/qchem.py", "max_issues_repo_name": "gsq7474741/Quantum", "max_issues_repo_head_hexsha": "16e7d3bf2dba7e94e6faf5c853faf0e913e1f268", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "paddle_quantum/qchem.py", "max_forks_repo_name": "gsq7474741/Quantum", "max_forks_repo_head_hexsha": "16e7d3bf2dba7e94e6faf5c853faf0e913e1f268", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.7707317073, "max_line_length": 114, "alphanum_fraction": 0.6007361488, "include": true, "reason": "import numpy", "num_tokens": 4421, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073802837477, "lm_q2_score": 0.35220178204788966, "lm_q1q2_score": 0.193924900544656}} {"text": "from warnings import warn\nfrom pathlib import Path\n\nimport numpy as np\nimport pandas as pd\n\nfrom astropy.nddata import CCDData, StdDevUncertainty\nfrom astropy.table import Table\nfrom astropy.io import fits\nimport ccdproc\nfrom ccdproc import combine, trim_image\n\nfrom .filemgmt import load_if_exists, make_summary\nfrom .ccdutil import CCDData_astype, load_ccd\nfrom .misc import chk_keyval\n\n__all__ = [\"sstd\", \"weighted_mean\", \"stack_FITS\", \"combine_ccd\"]\n\n\ndef sstd(a, **kwargs):\n ''' Sample standard deviation function\n '''\n return np.std(a, ddof=1, **kwargs)\n\n\n# FIXME: Add this to Ccdproc esp. for mem_limit\ndef weighted_mean(ccds, unit='adu'):\n datas = []\n ws = [] # weights = 1 / sigma**2\n for ccd in ccds:\n datas.append(ccd.data)\n ws.append(1 / ccd.uncertainty.array**2)\n wmean = np.average(np.array(datas), axis=0, weights=ws)\n wuncert = np.sqrt(1 / np.sum(np.array(ws), axis=0))\n nccd = CCDData(data=wmean, header=ccds[0].header, unit=unit)\n nccd.uncertainty = StdDevUncertainty(wuncert)\n return nccd\n\n\ndef group_FITS(summary_table, type_key=None, type_val=None, group_key=None):\n ''' Organize the group_by and type_key for stack_FITS\n Parameters\n ----------\n summary_table: pandas.DataFrame or astropy.table.Table\n The table which contains the metadata (header) of files. If it\n is in the astropy table format, it will be converted to\n `~pandas.DataFrame` object.\n\n type_key, type_val: None, str, list of str, optional\n The header keyword for the ccd type, and the value you want to\n match.\n\n group_key : None, str, list of str, optional\n The header keyword which will be used to make groups for the\n CCDs that have selected from ``type_key`` and ``type_val``. If\n ``None`` (default), no grouping will occur, but it will return\n the `~pandas.DataFrameGroupBy` object will be returned for the\n sake of consistency.\n\n Return\n ------\n grouped : ~pandas.DataFrameGroupBy\n The table after the grouping process.\n\n group_type_key : list of str\n The ``type_key`` that can directly be used for ``stack_FITS``\n for each element of ``grouped.groups``.\n Basically this is ``type_key + group_key``.\n\n Example\n -------\n >>> allfits = list(Path('.').glob(\"*.fits\"))\n >>> summary_table = make_summary(allfits)\n >>> type_key = [\"OBJECT\"]\n >>> type_val = [\"dark\"]\n >>> group_key = [\"EXPTIME\"]\n >>> gs, g_key = group_FITS(summary_table,\n ... type_key,\n ... type_val,\n ... group_key)\n >>> for g_val, group in gs:\n >>> _ = combine_ccd(group[\"file\"],\n ... type_key=g_key,\n ... type_val=g_val)\n '''\n if ((not isinstance(summary_table, Table))\n and (not isinstance(summary_table, pd.DataFrame))):\n raise TypeError(\"summary_table must be an astropy Table or Pandas \"\n + f\"DataFrame. It's now {type(summary_table)}.\")\n elif isinstance(summary_table, Table):\n st = summary_table.to_pandas()\n else:\n st = summary_table.copy()\n\n type_key, type_val, group_key = chk_keyval(type_key=type_key,\n type_val=type_val,\n group_key=group_key)\n\n if len(group_key + type_key) == 0:\n raise ValueError(\"At least one of type_key and group_key should not \"\n + \"be empty!\")\n\n # For simplicity, crop the original data by type_key and type_val first.\n for k, v in zip(type_key, type_val):\n st = st[st[k] == v]\n\n group_type_key = type_key + group_key\n grouped = st.groupby(group_key)\n\n return grouped, group_type_key\n\n\ndef stack_FITS(fitslist=None, summary_table=None, extension=0,\n unit='adu', table_filecol=\"file\", trim_fits_section=None,\n loadccd=True, type_key=None, type_val=None):\n ''' Stacks the FITS files specified in fitslist\n Parameters\n ----------\n fitslist: None, list of path-like, or list of CCDData\n The list of path to FITS files or the list of CCDData to be\n stacked. It is useful to give list of CCDData if you have\n already stacked/loaded FITS file into a list by your own\n criteria. If ``None`` (default), you must give ``fitslist`` or\n ``summary_table``. If it is not ``None``, this function will do\n very similar job to that of ``ccdproc.combine``. Although it is\n not a good idea, a mixed list of CCDData and paths to the files\n is also acceptable.\n\n summary_table: None, pandas.DataFrame or astropy.table.Table\n The table which contains the metadata of files. If there are\n many FITS files and you want to use stacking many times, it is\n better to make a summary table by ``filemgmt.make_summary`` and\n use that instead of opening FITS files' headers every time you\n call this function. If you want to use ``summary_table`` instead\n of ``fitslist`` and have set ``loadccd=True``, you must not have\n ``None`` or ``NaN`` value in the\n ``summary_table[table_filecol]``.\n\n extension: int or str\n The extension of FITS to be stacked. For single extension, set\n it as 0.\n\n unit: Unit or str, optional\n The unit of the CCDs to be loaded.\n Used only when ``fitslist`` is not a list of ``CCDData`` and\n ``loadccd`` is ``True``.\n\n table_filecol: str\n The column name of the ``summary_table`` which contains the path\n to the FITS files.\n\n trim_fits_section : str or None, optional\n The ``fits_section`` of ``ccdproc.trim_image``. Region of\n ``ccd`` from which the overscan is extracted; see\n `~ccdproc.subtract_overscan` for details.\n Default is ``None``.\n\n loadccd: bool, optional\n Whether to return file paths or loaded CCDData. If ``False``, it\n is a function to select FITS files using ``type_key`` and\n ``type_val`` without using much memory.\n This is ignored if ``fitslist`` is given and composed of\n ``CCDData`` objects.\n\n type_key, type_val: str, list of str\n The header keyword for the ccd type, and the value you want to\n match.\n\n Return\n ------\n matched: list of Path or list of CCDData\n list containing Path to files if ``loadccd`` is ``False``.\n Otherwise it is a list containing loaded CCDData after loading\n the files. If ``ccdlist`` is given a priori, list of CCDData\n will be returned regardless of ``loadccd``.\n '''\n def _parse_val(value):\n val = str(value)\n if val.lstrip('+-').isdigit(): # if int\n result = int(val)\n else:\n try:\n result = float(val)\n except ValueError:\n result = str(val)\n return result\n\n def _check_mismatch(row):\n mismatch = False\n for k, v in zip(type_key, type_val):\n hdr_val = _parse_val(row[k])\n parse_v = _parse_val(v)\n if (hdr_val != parse_v):\n mismatch = True\n break\n return mismatch\n\n if ((fitslist is not None) + (summary_table is not None) != 1):\n raise ValueError(\"One and only one of fitslist or summary_table must \"\n + \"be not None.\")\n\n # If fitslist\n if fitslist is not None:\n table_mode = False\n try:\n fitslist = list(fitslist)\n except TypeError:\n raise TypeError(\"fitslist must be convertable to list. \"\n + f\"It's now {type(fitslist)}.\")\n\n # If summary_table\n if summary_table is not None:\n table_mode = True\n if ((not isinstance(summary_table, Table))\n and (not isinstance(summary_table, pd.DataFrame))):\n raise TypeError(\"summary_table must be an astropy Table or Pandas \"\n + f\"DataFrame. It's now {type(summary_table)}.\")\n\n # Check for type_key and type_val\n type_key, type_val, _ = chk_keyval(type_key=type_key,\n type_val=type_val,\n group_key=None)\n\n # Setting whether to group\n grouping = False\n if len(type_key) > 0:\n grouping = True\n\n print(\"Analyzing FITS... \", end='')\n # Set fitslist and summary_table based on the given input and grouping.\n if table_mode:\n if isinstance(summary_table, Table):\n summary_table = summary_table.to_pandas()\n fitslist = summary_table[table_filecol].tolist()\n else:\n if grouping:\n summary_table = make_summary(fitslist,\n extension=extension,\n verbose=True,\n fname_option='relative',\n keywords=type_key,\n sort_by=None,\n pandas=True)\n # else: no need to make summary_table.\n\n print(\"Done\", end='')\n\n if loadccd:\n print(\" and loading FITS... \")\n else:\n print(\".\")\n\n matched = []\n\n # Append appropriate CCDs or filepaths to matched\n if grouping: # summary_table is used.\n for i, row in summary_table.iterrows():\n mismatch = _check_mismatch(row)\n if mismatch: # skip this row (file)\n continue\n\n # if not skipped:\n # TODO: Is it better to remove Path here?\n if isinstance(fitslist[i], CCDData):\n matched.append(fitslist[i])\n else: # it must be a path to the file\n fpath = Path(fitslist[i])\n if loadccd:\n ccd_i = load_ccd(fpath, extension=extension, unit=unit)\n if trim_fits_section is not None:\n ccd_i = trim_image(ccd_i,\n fits_section=trim_fits_section)\n matched.append(ccd_i)\n else:\n matched.append(fpath)\n else: # summary_table is not used.\n for item in fitslist:\n if isinstance(item, CCDData):\n matched.append(item)\n else:\n if loadccd:\n ccd_i = load_ccd(item, extension=extension, unit=unit)\n if trim_fits_section is not None:\n ccd_i = trim_image(\n ccd_i, fits_section=trim_fits_section)\n matched.append(ccd_i)\n else: # TODO: Is is better to remove Path here?\n matched.append(Path(item))\n\n # Generate warning OR information messages\n if len(matched) == 0:\n if grouping:\n warn('No FITS file had \"{:s} = {:s}\"'.format(str(type_key),\n str(type_val))\n + \"Maybe int/float/str confusing?\")\n else:\n warn('No FITS file found')\n else:\n if grouping:\n N = len(matched)\n ks = str(type_key)\n vs = str(type_val)\n if loadccd:\n print(f'{N} FITS files with \"{ks} = {vs}\" are loaded.')\n else:\n print(f'{N} FITS files with \"{ks} = {vs}\" are selected.')\n else:\n if loadccd:\n print('{:d} FITS files are loaded.'.format(len(matched)))\n\n return matched\n\n\ndef combine_ccd(fitslist=None, summary_table=None, table_filecol=\"file\",\n trim_fits_section=None, output=None, unit='adu',\n subtract_frame=None, combine_method='median',\n reject_method=None, normalize_exposure=False,\n normalize_average=False,\n exposure_key='EXPTIME', mem_limit=2e9,\n combine_uncertainty_function=None,\n extension=0, type_key=None, type_val=None,\n dtype=\"float32\", uncertainty_dtype=\"float32\",\n output_verify='fix', overwrite=False,\n verbose=True, **kwargs):\n ''' Combining images\n Slight variant from ccdproc.\n # TODO: accept the input like ``sigma_clip_func='median'``, etc.\n Parameters\n ----------\n fitslist: path-like, list of path-like, or list of CCDData\n The list of path to FITS files or the list of CCDData to be\n stacked. It is useful to give list of CCDData if you have\n already stacked/loaded FITS file into a list by your own\n criteria. If ``None`` (default), you must give ``fitslist`` or\n ``summary_table``. If it is not ``None``, this function will do\n very similar job to that of ``ccdproc.combine``. Although it is\n not a good idea, a mixed list of CCDData and paths to the files\n is also acceptable.\n\n summary_table: pandas.DataFrame or astropy.table.Table\n The table which contains the metadata of files. If there are\n many FITS files and you want to use stacking many times, it is\n better to make a summary table by ``filemgmt.make_summary`` and\n use that instead of opening FITS files' headers every time you\n call this function. If you want to use ``summary_table`` instead\n of ``fitslist`` and have set ``loadccd=True``, you must not have\n ``None`` or ``NaN`` value in the\n ``summary_table[table_filecol]``.\n\n table_filecol: str\n The column name of the ``summary_table`` which contains the path\n to the FITS files.\n\n trim_fits_section : str or None, optional\n The ``fits_section`` of ``ccdproc.trim_image``. Region of\n ``ccd`` from which the overscan is extracted; see\n `~ccdproc.subtract_overscan` for details.\n Default is ``None``.\n\n output : path-like or None, optional.\n The path if you want to save the resulting ``ccd`` object.\n Default is ``None``.\n\n unit : `~astropy.units.Unit` or str, optional.\n The units of the data.\n Default is ``'adu'``.\n\n subtract_frame : array-like, optional.\n The frame you want to subtract from the image after the\n combination. It can be, e.g., dark frame, because it is easier\n to calculate Poisson error before the dark subtraction and\n subtract the dark later.\n TODO: This maybe unnecessary.\n Default is ``None``.\n\n combine_method : str or None, optinal.\n The ``method`` for ``ccdproc.combine``, i.e., {'average',\n 'median', 'sum'}\n Default is ``None``.\n\n reject_method : str\n Made for simple use of ``ccdproc.combine``, [None, 'minmax',\n 'sigclip' == 'sigma_clip', 'extrema' == 'ext']. Automatically\n turns on the option, e.g., ``clip_extrema = True`` or\n ``sigma_clip = True``. Leave it blank for no rejection.\n Default is ``None``.\n\n normalize_exposure : bool, optional.\n Whether to normalize the values by the exposure time of each\n frame before combining.\n Default is ``False``.\n\n normalize_average : bool, optional.\n Whether to normalize the values by the average value of each\n frame before combining.\n Default is ``False``.\n\n exposure_key : str, optional\n The header keyword for the exposure time.\n Default is ``\"EXPTIME\"``.\n\n combine_uncertainty_function : callable, None, optional\n The uncertainty calculation function of ``ccdproc.combine``. If\n ``None`` use the default uncertainty func when using average,\n median or sum combine, otherwise use the function provided.\n Default is ``None``.\n\n extension: int or str, optional\n The extension to be used.\n Default is ``0``.\n\n dtype : str or `numpy.dtype` or None, optional\n Allows user to set dtype. See `numpy.array` ``dtype`` parameter\n description. If ``None`` it uses ``np.float64``.\n Default is ``None``.\n\n type_key, type_val: str, list of str\n The header keyword for the ccd type, and the value you want to\n match. For an open HDU named ``hdu``, e.g., only the files which\n satisfies ``hdu[extension].header[type_key] == type_val`` among\n all the ``fitslist`` will be used.\n\n output_verify : str\n Output verification option. Must be one of ``\"fix\"``,\n ``\"silentfix\"``, ``\"ignore\"``, ``\"warn\"``, or ``\"exception\"``.\n May also be any combination of ``\"fix\"`` or ``\"silentfix\"`` with\n ``\"+ignore\"``, ``+warn``, or ``+exception\" (e.g.\n ``\"fix+warn\"``). See the astropy documentation below:\n http://docs.astropy.org/en/stable/io/fits/api/verification.html#verify\n\n mem_limit : float, optional\n Maximum memory which should be used while combining (in bytes).\n Default is ``2.e9``.\n\n **kwarg:\n kwargs for the ``ccdproc.combine``. See its documentation. This\n includes (RHS are the default values)\n ```\n weights=None,\n scale=None,\n mem_limit=16000000000.0,\n clip_extrema=False,\n nlow=1,\n nhigh=1,\n minmax_clip=False,\n minmax_clip_min=None,\n minmax_clip_max=None,\n sigma_clip=False,\n sigma_clip_low_thresh=3,\n sigma_clip_high_thresh=3,\n sigma_clip_func=,\n sigma_clip_dev_func=,\n combine_uncertainty_function=None, **ccdkwargs\n ```\n\n Returns\n -------\n master: astropy.nddata.CCDData\n Resulting combined ccd.\n '''\n def _set_reject_method(reject_method):\n ''' Convenience function for ccdproc.combine reject switches\n '''\n clip_extrema, minmax_clip, sigma_clip = False, False, False\n\n if reject_method in ['extrema', 'ext']:\n clip_extrema = True\n elif reject_method in ['minmax']:\n minmax_clip = True\n elif reject_method in ['sigma_clip', 'sigclip']:\n sigma_clip = True\n else:\n if reject_method not in [None, 'no']:\n raise KeyError(\"reject must be one in [None, 'minmax', \"\n + \"'sigclip'=='sigma_clip', 'extrema'=='ext']\")\n\n return clip_extrema, minmax_clip, sigma_clip\n\n def _print_info(combine_method, Nccd, reject_method, **kwargs):\n if reject_method is None:\n reject_method = 'no'\n\n info_str = ('\"{:s}\" combine {:d} images by \"{:s}\" rejection')\n\n print(info_str.format(combine_method, Nccd, reject_method))\n print(dict(**kwargs))\n return\n\n # def _normalize_exptime(ccdlist, exposure_key):\n # _ccdlist = ccdlist.copy()\n # exptimes = []\n\n # for i in range(len(_ccdlist)):\n # exptime = _ccdlist[i].header[exposure_key]\n # exptimes.append(exptime)\n # _ccdlist[i] = _ccdlist[i].divide(exptime)\n\n # if verbose:\n # if len(np.unique(exptimes)) != 1:\n # print('There are more than one exposure times:\\n\\t', end=' ')\n # print(np.unique(exptimes), end=' ')\n # print('seconds')\n # print(f'Normalized images by exposure time (\"{exposure_key}\").')\n\n # return _ccdlist\n\n def _add_and_print(s, header, verbose):\n header.add_history(s)\n if verbose:\n print(s)\n # Give only one\n if ((fitslist is not None) + (summary_table is not None) != 1):\n raise ValueError(\n \"One and only one of [fitslist, summary_table] must be given.\")\n\n # If fitslist\n if fitslist is not None:\n try:\n fitslist = list(fitslist)\n except TypeError:\n raise TypeError(\"fitslist must be convertable to list. \"\n + f\"It's now {type(fitslist)}.\")\n\n # If summary_table\n if summary_table is not None:\n if ((not isinstance(summary_table, Table))\n and (not isinstance(summary_table, pd.DataFrame))):\n raise TypeError(\"summary_table must be an astropy Table or Pandas \"\n + f\"DataFrame. It's now {type(summary_table)}.\")\n\n # Check for type_key and type_val\n if ((type_key is None) ^ (type_val is None)):\n raise ValueError(\n \"type_key and type_val must be both specified or both None.\")\n\n if (output is not None) and (Path(output).exists()):\n if overwrite:\n print(f\"{output} already exists:\\n\\tBut will be overridden.\")\n else:\n print(f\"{output} already exists:\")\n return load_if_exists(output, loader=CCDData.read, if_not=None)\n\n # Do we really need to accept all three of normalize & scale?\n # if scale is None:\n # scale = np.ones(len(ccdlist))\n if (((normalize_average) + (normalize_exposure)) > 1):\n raise ValueError(\"Only up to one of [normalize_average, \"\n + \"normalize_exposure] must be not None.\")\n\n # Set history messages\n str_history = ('{:d} images with {:s} = {:s} are \"{:s}\" combined '\n + 'using \"{:s}\" rejection (additional kwargs: {})')\n str_nexp = \"Each frame normalized by exposure time before combination.\"\n str_navg = \"Each frame normalized by average value before combination.\"\n str_subt = \"Subtracted a user-provided frame\"\n str_trim = \"Trim by FITS section {}\"\n\n if reject_method is None:\n reject_method = 'no'\n\n # Select CCDs by\n ccdlist = stack_FITS(fitslist=fitslist,\n summary_table=summary_table,\n table_filecol=table_filecol,\n extension=extension,\n unit=unit,\n type_key=type_key,\n type_val=type_val,\n loadccd=False)\n # trim_fits_section=trim_fits_section,\n # loadccd=False: Loading CCD here may cause memory blast...\n\n try:\n header = ccdlist[0].header\n except AttributeError:\n header = fits.getheader(ccdlist[0])\n\n if verbose:\n _print_info(combine_method=combine_method,\n Nccd=len(ccdlist),\n reject_method=reject_method,\n dtype=dtype,\n **kwargs)\n\n scale = None\n # Normalize by exposure\n if normalize_exposure:\n tmp = make_summary(fitslist=fitslist,\n keywords=[exposure_key],\n verbose=False,\n sort_by=None)\n exptimes = tmp[exposure_key].tolist()\n scale = 1 / np.array(exptimes)\n _add_and_print(str_nexp, header, verbose)\n\n # Normalize by pixel average\n if normalize_average:\n def invavg(a):\n return 1 / np.mean(a)\n scale = invavg\n _add_and_print(str_navg, header, verbose)\n\n # Set rejection switches\n clip_extrema, minmax_clip, sigma_clip = _set_reject_method(reject_method)\n\n if len(ccdlist) == 1:\n if isinstance(ccdlist[0], CCDData):\n master = ccdlist[0]\n else:\n master = load_ccd(ccdlist[0], extension=extension, unit=unit)\n else:\n master = combine(img_list=ccdlist,\n method=combine_method,\n clip_extrema=clip_extrema,\n minmax_clip=minmax_clip,\n sigma_clip=sigma_clip,\n mem_limit=mem_limit,\n combine_uncertainty_function=combine_uncertainty_function,\n unit=unit,\n hdu=extension,\n scale=scale,\n dtype=dtype,\n **kwargs)\n\n ncombine = len(ccdlist)\n header[\"COMBVER\"] = (ccdproc.__version__,\n \"ccdproc version used for combine.\")\n header[\"NCOMBINE\"] = (ncombine, \"Number of combined images\")\n header[\"COMBMETH\"] = (combine_method, \"Combining method\")\n\n header.add_history(str_history.format(ncombine,\n str(type_key),\n str(type_val),\n str(combine_method),\n str(reject_method),\n kwargs))\n\n if subtract_frame is not None:\n subtract = CCDData(subtract_frame.copy())\n master.data = master.subtract(subtract).data\n _add_and_print(str_subt, header, verbose)\n\n if trim_fits_section is not None:\n master = trim_image(master, fits_section=trim_fits_section)\n _add_and_print(str_trim.format(trim_fits_section), header, verbose)\n\n master.header = header\n master = CCDData_astype(master, dtype=dtype,\n uncertainty_dtype=uncertainty_dtype)\n\n if output is not None:\n if verbose:\n print(f\"Writing FITS to {output}... \", end='')\n master.write(output, output_verify=output_verify, overwrite=overwrite)\n if verbose:\n print(\"Saved.\")\n\n return master\n", "meta": {"hexsha": "5a1c277e0c5950becd15cc7b674a19e8509983f3", "size": 25201, "ext": "py", "lang": "Python", "max_stars_repo_path": "photometry/ysfitsutilpy/ysfitsutilpy/combutil.py", "max_stars_repo_name": "ysBach/IshiguroM_etal_155140_2005UD", "max_stars_repo_head_hexsha": "37e0768f2a9dd59b3d4041c37c104d2d57e037ab", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-12-31T19:39:40.000Z", "max_stars_repo_stars_event_max_datetime": "2019-12-31T19:39:40.000Z", "max_issues_repo_path": "photometry/ysfitsutilpy/ysfitsutilpy/combutil.py", "max_issues_repo_name": "ysBach/IshiguroM_etal_155140_2005UD", "max_issues_repo_head_hexsha": "37e0768f2a9dd59b3d4041c37c104d2d57e037ab", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "photometry/ysfitsutilpy/ysfitsutilpy/combutil.py", "max_forks_repo_name": "ysBach/IshiguroM_etal_155140_2005UD", "max_forks_repo_head_hexsha": "37e0768f2a9dd59b3d4041c37c104d2d57e037ab", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-09-26T08:19:49.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-26T08:19:49.000Z", "avg_line_length": 38.2412746586, "max_line_length": 83, "alphanum_fraction": 0.5793420896, "include": true, "reason": "import numpy,from astropy", "num_tokens": 5714, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073655352404, "lm_q2_score": 0.35220177524832036, "lm_q1q2_score": 0.1939248916063125}} {"text": "import os\nimport warnings\nimport pdb\nimport sys\nimport shutil\nimport pandas as pd\nimport numpy as np\nimport time\nimport multiprocessing as mp\nimport astropy.coordinates as astroCoords\nimport astropy.units as u\nfrom kbmodpy import kbmod as kb\nfrom astropy.io import fits\nfrom astropy.wcs import WCS\nfrom sklearn.cluster import DBSCAN\nfrom skimage import measure\nfrom analysis_utils import Interface, PostProcess\n\nclass region_search:\n \"\"\"\n CLASS CURRENTLY DOES NOT WORK\n \"\"\"\n def __init__(self,v_guess,radius,num_obs):\n \"\"\"\n INPUT-\n v_guess : float array\n Initial object velocity guess. Given as an array or tuple.\n Algorithm will search velocities within 'radius' of 'v_guess'\n radius : float\n radius in velocity space to search, centered around 'v_guess'\n num_obs : int\n The minimum number of observations required to keep the object\n \"\"\"\n self.v_guess = v_guess\n self.radius = radius\n self.num_obs = num_obs\n return\n\n def run_search(self, im_filepath, res_filepath, out_suffix, time_file,\n likelihood_level=10., mjd_lims=None):\n # Initialize some values\n start = time.time()\n\n memory_error = False\n # Load images to search\n search,image_params = self.load_images(\n im_filepath, time_file, mjd_lims=mjd_lims)\n\n # Run the region search\n # Save values in image_params for use in filter_results\n\n print(\"Starting Search\")\n print('---------------------------------------')\n param_headers = (\"X Velocity Guess\",\"Y Velocity Guess\",\n \"Radius in velocity space\")\n param_values = (*self.v_guess,self.radius)\n for header, val in zip(param_headers, param_values):\n print('%s = %.4f' % (header, val))\n results = search.region_search(\n *self.v_guess, self.radius, likelihood_level, int(self.num_obs))\n duration = image_params['times'][-1]-image_params['times'][0]\n # Convert the results to the grid formatting\n grid_results = kb.region_to_grid(results,duration)\n # Process the search results\n keep = self.process_region_results(\n search, image_params, res_filepath, likelihood_level, grid_results)\n del(search)\n\n # Cluster the results\n #keep = self.filter_results(keep,image_params)\n\n # Save the results\n self.save_results(res_filepath, out_suffix, keep)\n\n end = time.time()\n\n del(keep)\n return\n\n def process_region_results(\n self,search,image_params,res_filepath,likelihood_level,results):\n \"\"\"\n Processes results that are output by the gpu search.\n \"\"\"\n\n keep = {'stamps': [], 'new_lh': [], 'results': [], 'times': [],\n 'lc': [], 'final_results': []}\n\n print('---------------------------------------')\n print(\"Processing Results\")\n print('---------------------------------------')\n print('Starting pooling...')\n pool = mp.Pool(processes=16)\n print('Getting results...')\n\n psi_curves = []\n phi_curves = []\n # print(results)\n for line in results:\n psi_curve, phi_curve = search.lightcurve(line)\n psi_curves.append(np.array(psi_curve).flatten())\n phi_curve = np.array(phi_curve).flatten()\n phi_curve[phi_curve == 0.] = 99999999.\n phi_curves.append(phi_curve)\n\n keep_idx_results = pool.starmap_async(\n return_indices,\n zip(psi_curves, phi_curves, [j for j in range(len(psi_curves))]))\n pool.close()\n pool.join()\n keep_idx_results = keep_idx_results.get()\n if (len(keep_idx_results) < 1):\n keep_idx_results = [(0,[-1],0.)]\n\n if (len(keep_idx_results[0]) < 3):\n keep_idx_results = [(0, [-1], 0.)]\n\n for result_on in range(len(psi_curves)):\n\n if keep_idx_results[result_on][1][0] == -1:\n continue\n elif len(keep_idx_results[result_on][1]) < 3:\n continue\n elif keep_idx_results[result_on][2] < likelihood_level:\n continue\n else:\n keep_idx = keep_idx_results[result_on][1]\n new_likelihood = keep_idx_results[result_on][2]\n keep['results'].append(results[result_on])\n keep['new_lh'].append(new_likelihood)\n stamps = search.sci_stamps(results[result_on], 10)\n stamp_arr = np.array(\n [np.array(stamps[s_idx]) for s_idx in keep_idx])\n keep['stamps'].append(np.sum(stamp_arr, axis=0))\n keep['lc'].append(\n (psi_curves[result_on]/phi_curves[result_on])[keep_idx])\n keep['times'].append(image_params['mjd'][keep_idx])\n print(len(keep['results']))\n # Needed for compatibility with grid_search save functions\n keep['final_results'] = range(len(keep['results']))\n\n return(keep)\n\nclass run_search:\n \"\"\"\n This class runs the grid search for kbmod.\n \"\"\"\n def __init__(self, input_parameters):\n\n \"\"\"\n INPUT-\n input_parameters : dictionary\n Dictionary containing input parameters. Merged with the\n defaults dictionary. MUST include 'im_filepath',\n 'res_filepath', and 'time_file'. These are the filepaths to the\n image directory, results directory, and time file,\n respectively. Should contain 'v_arr', and 'ang_arr', which are\n lists containing the lower and upper velocity and angle limits.\n \"\"\"\n\n defaults = { # Mandatory values\n 'im_filepath':None, 'res_filepath':None, 'time_file':None,\n # Suggested values\n 'v_arr':[92.,526.,256], 'ang_arr':[np.pi/15,np.pi/15,128], \n # Optional values\n 'output_suffix':'search', 'mjd_lims':None, 'average_angle':None,\n 'do_mask':True, 'mask_num_images':2, 'mask_threshold':120.,\n 'lh_level':10., 'psf_val':1.4, 'num_obs':10, 'num_cores':30,\n 'visit_in_filename':[0,6], 'file_format':'{0:06d}.fits',\n 'sigmaG_lims':[25,75], 'chunk_size':500000, 'max_lh':1000.,\n 'filter_type':'clipped_sigmaG', 'center_thresh':0.00,\n 'peak_offset':[2.,2.], 'mom_lims':[35.5,35.5,2.0,0.3,0.3],\n 'stamp_type':'sum', 'eps':0.03, 'gpu_filter':False,\n 'do_clustering':True, 'do_stamp_filter':True,\n 'clip_negative':False, 'sigmaG_filter_type':'lh'\n }\n # Make sure input_parameters contains valid input options\n for key, val in input_parameters.items():\n if key in defaults:\n defaults[key] = val\n else:\n warnings.warn('Key \"{}\" is not a valid option. It is being ignored.'.format(key))\n self.config = defaults\n #self.config = {**defaults, **input_parameters}\n if (self.config['im_filepath'] is None):\n raise ValueError('Image filepath not set')\n if (self.config['res_filepath'] is None):\n raise ValueError('Results filepath not set')\n if (self.config['time_file'] is None):\n raise ValueError('Time filepath not set')\n return\n\n def do_gpu_search(self, search, image_params, post_process):\n\n # Run the grid search\n # Set min and max values for angle and velocity\n if self.config['average_angle'] == None:\n average_angle = image_params['ec_angle']\n else:\n average_angle = self.config['average_angle']\n ang_min = average_angle - self.config['ang_arr'][0]\n ang_max = average_angle + self.config['ang_arr'][1]\n vel_min = self.config['v_arr'][0]\n vel_max = self.config['v_arr'][1]\n image_params['ang_lims'] = [ang_min, ang_max]\n image_params['vel_lims'] = [vel_min, vel_max]\n\n search_start = time.time()\n print(\"Starting Search\")\n print('---------------------------------------')\n param_headers = (\"Ecliptic Angle\", \"Min. Search Angle\",\n \"Max Search Angle\", \"Min Velocity\", \"Max Velocity\")\n param_values = (image_params['ec_angle'], *image_params['ang_lims'],\n *image_params['vel_lims'])\n for header, val in zip(param_headers, param_values):\n print('%s = %.4f' % (header, val))\n if self.config['gpu_filter']:\n print('Using in-line GPU filtering methods', flush=True)\n self.config['sigmaG_coeff'] = post_process._find_sigmaG_coeff(\n self.config['sigmaG_lims'])\n search.gpuFilter(\n int(self.config['ang_arr'][2]), int(self.config['v_arr'][2]),\n *image_params['ang_lims'], *image_params['vel_lims'],\n int(self.config['num_obs']),\n np.array(self.config['sigmaG_lims'])/100.0,\n self.config['sigmaG_coeff'], self.config['mom_lims'],\n self.config['lh_level'])\n else:\n search.gpu(\n int(self.config['ang_arr'][2]), int(self.config['v_arr'][2]),\n *image_params['ang_lims'], *image_params['vel_lims'],\n int(self.config['num_obs']))\n print(\n 'Search finished in {0:.3f}s'.format(time.time()-search_start),\n flush=True)\n return(search, image_params)\n\n def run_search(self):\n \"\"\"\n This function serves as the highest-level python interface for starting\n a KBMOD search.\n INPUT-\n im_filepath : string\n Path to the folder containing the images to be ingested into\n KBMOD and searched over.\n res_filepath : string\n Path to the folder that will contain the results from the\n search.\n out_suffix : string\n Suffix to append to the output files. Used to differentiate\n between different searches over the same stack of images.\n time_file : string\n Path to the file containing the image times.\n lh_level : float\n Minimum acceptable likelihood level for a trajectory.\n Trajectories with likelihoods below this value will be\n discarded.\n psf_val : float\n Determines the size of the psf generated by the kbmod stack.\n mjd_lims : numpy array\n Limits the search to images taken within the limits input by\n mjd_lims.\n average_angle : float\n Overrides the ecliptic angle calculation and instead centers\n the average search around average_angle.\n \"\"\"\n\n start = time.time()\n kb_interface = Interface()\n kb_post_process = PostProcess(self.config)\n\n # Load images to search\n stack,image_params = kb_interface.load_images(\n self.config['im_filepath'], self.config['time_file'],\n self.config['mjd_lims'], self.config['visit_in_filename'],\n self.config['file_format'])\n # Save values in image_params for later use\n if self.config['do_mask']:\n stack = kb_post_process.apply_mask(\n stack, mask_num_images=self.config['mask_num_images'],\n mask_threshold=self.config['mask_threshold'])\n psf = kb.psf(self.config['psf_val'])\n search = kb.stack_search(stack, psf)\n\n search, image_params = self.do_gpu_search(\n search, image_params, kb_post_process)\n # Load the KBMOD results into Python and apply a filter based on\n # 'filter_type'\n image_params['sigmaG_filter_type'] = self.config['sigmaG_filter_type']\n keep = kb_post_process.load_results(\n search, image_params, self.config['lh_level'],\n chunk_size=self.config['chunk_size'], \n filter_type=self.config['filter_type'],\n max_lh=self.config['max_lh'])\n if self.config['do_stamp_filter']:\n keep = kb_post_process.apply_stamp_filter(\n keep, search, center_thresh=self.config['center_thresh'],\n peak_offset=self.config['peak_offset'], \n mom_lims=self.config['mom_lims'],\n stamp_type=self.config['stamp_type'])\n if self.config['do_clustering']:\n keep = kb_post_process.apply_clustering(keep, image_params)\n keep = kb_post_process.get_all_stamps(keep, search)\n del(search)\n # Save the results\n kb_interface.save_results(\n self.config['res_filepath'], self.config['output_suffix'], keep)\n end = time.time()\n del(keep)\n print(\"Time taken for patch: \", end-start)\n", "meta": {"hexsha": "60d38010a6c03782a9d9dd3280cd8cd90abe39a1", "size": 12937, "ext": "py", "lang": "Python", "max_stars_repo_path": "analysis/run_search.py", "max_stars_repo_name": "fraserw/kbmod", "max_stars_repo_head_hexsha": "65d69746d1dd8de867f8da147d73c09439d28b41", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 16, "max_stars_repo_stars_event_min_datetime": "2018-07-23T11:39:05.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-27T17:15:42.000Z", "max_issues_repo_path": "analysis/run_search.py", "max_issues_repo_name": "fraserw/kbmod", "max_issues_repo_head_hexsha": "65d69746d1dd8de867f8da147d73c09439d28b41", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 42, "max_issues_repo_issues_event_min_datetime": "2017-06-19T22:55:41.000Z", "max_issues_repo_issues_event_max_datetime": "2018-03-15T02:49:39.000Z", "max_forks_repo_path": "analysis/run_search.py", "max_forks_repo_name": "fraserw/kbmod", "max_forks_repo_head_hexsha": "65d69746d1dd8de867f8da147d73c09439d28b41", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2018-07-23T11:39:04.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-27T18:43:02.000Z", "avg_line_length": 41.5980707395, "max_line_length": 97, "alphanum_fraction": 0.5827471593, "include": true, "reason": "import numpy,import astropy,from astropy", "num_tokens": 2779, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073655352403, "lm_q2_score": 0.3522017684487511, "lm_q1q2_score": 0.19392488786241954}} {"text": "import numpy as np\r\nimport tensorflow as tf\r\nfrom keras import backend as K\r\nfrom keras.backend import epsilon,clip,mean\r\nfrom nets.ious import box_ciou\r\n\r\n\r\n\r\nimport numpy as np\r\nfrom keras.backend import exp\r\nfrom keras.layers import Softmax\r\n\r\nimport math\r\n\r\n\r\ndef DRloss(targets, logits):\r\n pos_lambda = 1\r\n margin = 0.5\r\n neg_lambda = 0.1 / math.log(3.5)\r\n L = 6.\r\n tau = 4.\r\n # 标注相关信息\r\n num_classes = logits.shape[1]\r\n dtype = targets.dtype\r\n device = targets.device\r\n class_range = np.arange(1, num_classes + 1, dtype=dtype, device=device).unsqueeze(0)\r\n t = targets.unsqueeze(1)\r\n # 获得正负样本id\r\n pos_ind = (t == class_range)\r\n neg_ind = (t != class_range) * (t >= 0)\r\n # 概率p使用sigmoid求得\r\n pos_prob = logits[pos_ind].sigmoid()\r\n neg_prob = logits[neg_ind].sigmoid()\r\n # 对应于式(3.9)\r\n neg_q = Softmax(neg_prob/neg_lambda, dim=0)\r\n neg_dist = np.sum(neg_q * neg_prob)\r\n # 论文中提到，如果图像中没有正样本，则正样本的P使用1代替\r\n if pos_prob.numel() > 0:\r\n # 对应于式(3.9)\r\n pos_q = Softmax(-pos_prob/pos_lambda, dim=0)\r\n pos_dist = np.sum(pos_q * pos_prob)\r\n # 对应于式(3.12)\r\n loss = tau*np.log(1.+exp(L*(neg_dist - pos_dist+margin)))/L\r\n else:\r\n # 对应于式(3.12)\r\n loss = tau*np.log(1.+exp(L*(neg_dist - 1. + margin)))/L\r\n return loss\r\n\r\n\r\n#---------------------------------------------------#\r\n# 平滑标签\r\n#---------------------------------------------------#\r\ndef _smooth_labels(y_true, label_smoothing):\r\n num_classes = tf.cast(K.shape(y_true)[-1], dtype=K.floatx())\r\n\r\n label_smoothing = K.constant(label_smoothing, dtype=K.floatx())\r\n\r\n return y_true * (1.0 - label_smoothing) + label_smoothing / num_classes\r\n\r\n\r\ndef focal(alpha=0.25, gamma=2.0):\r\n def _focal(y_true, y_pred):\r\n # y_true [batch_size, num_anchor, num_classes+1]\r\n # y_pred [batch_size, num_anchor, num_classes]\r\n labels = y_true[:, :, :-1]\r\n anchor_state = y_true[:, :, -1] # -1 是需要忽略的, 0 是背景, 1 是存在目标\r\n classification = y_pred\r\n\r\n # 找出存在目标的先验框\r\n indices_for_object = K.where(K.equal(anchor_state, 1))\r\n labels_for_object = K.gather_nd(labels, indices_for_object)\r\n classification_for_object = K.gather_nd(classification, indices_for_object)\r\n\r\n # 计算每一个先验框应该有的权重\r\n alpha_factor_for_object = K.ones_like(labels_for_object) * alpha\r\n alpha_factor_for_object = K.where(K.equal(labels_for_object, 1), alpha_factor_for_object, 1 - alpha_factor_for_object)\r\n focal_weight_for_object = K.where(K.equal(labels_for_object, 1), 1 - classification_for_object, classification_for_object)\r\n focal_weight_for_object = alpha_factor_for_object * focal_weight_for_object ** gamma\r\n\r\n # 将权重乘上所求得的交叉熵\r\n cls_loss_for_object = focal_weight_for_object * K.binary_crossentropy(labels_for_object, classification_for_object)\r\n\r\n # 找出实际上为背景的先验框\r\n indices_for_back = K.where(K.equal(anchor_state, 0))\r\n labels_for_back = K.gather_nd(labels, indices_for_back)\r\n classification_for_back = K.gather_nd(classification, indices_for_back)\r\n\r\n # 计算每一个先验框应该有的权重\r\n alpha_factor_for_back = K.ones_like(labels_for_back) * (1 - alpha)\r\n focal_weight_for_back = classification_for_back\r\n focal_weight_for_back = alpha_factor_for_back * focal_weight_for_back ** gamma\r\n\r\n # 将权重乘上所求得的交叉熵\r\n cls_loss_for_back = focal_weight_for_back * K.binary_crossentropy(labels_for_back, classification_for_back)\r\n\r\n # 标准化，实际上是正样本的数量\r\n normalizer = tf.where(K.equal(anchor_state, 1))\r\n normalizer = K.cast(K.shape(normalizer)[0], K.floatx())\r\n normalizer = K.maximum(K.cast_to_floatx(1.0), normalizer)\r\n\r\n # 将所获得的loss除上正样本的数量\r\n cls_loss_for_object = K.sum(cls_loss_for_object)\r\n cls_loss_for_back = K.sum(cls_loss_for_back)\r\n\r\n # 总的loss\r\n loss = (cls_loss_for_object + cls_loss_for_back)/normalizer\r\n\r\n return loss\r\n return _focal\r\n\r\n\r\n\r\n\r\ndef binary_focal_loss(true_label,probs ):\r\n gamma = 2\r\n alpha = 0.25\r\n alpha = tf.constant(alpha, dtype=tf.float32)\r\n gamma = tf.constant(gamma, dtype=tf.float32)\r\n\r\n epsilon = 1.e-8\r\n # 得到y_true和y_pred\r\n y_true = tf.one_hot(true_label, 2)\r\n # probs = tf.nn.sigmoid(logits)\r\n y_pred = tf.clip_by_value(probs, epsilon, 1. - epsilon)\r\n # 得到调节因子weight和alpha\r\n ## 先得到y_true和1-y_true的概率【这里是正负样本的概率都要计算哦！】\r\n p_t = y_true * y_pred \\\r\n + (tf.ones_like(y_true) - y_true) * (tf.ones_like(y_true) - y_pred)\r\n ## 然后通过p_t和gamma得到weight\r\n weight = tf.pow((tf.ones_like(y_true) - p_t), gamma)\r\n ## 再得到alpha，y_true的是alpha，那么1-y_true的是1-alpha\r\n alpha_t = y_true * alpha + (tf.ones_like(y_true) - y_true) * (1 - alpha)\r\n # 最后就是论文中的公式，相当于：- alpha * (1-p_t)^gamma * log(p_t)\r\n focal_loss = - alpha_t * weight * tf.log(p_t)\r\n return tf.reduce_mean(focal_loss)\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n#---------------------------------------------------#\r\n# 将预测值的每个特征层调成真实值\r\n#---------------------------------------------------#\r\ndef yolo_head(feats, anchors, num_classes, input_shape, calc_loss=False):\r\n num_anchors = len(anchors)\r\n #---------------------------------------------------#\r\n # [1, 1, 1, num_anchors, 2]\r\n #---------------------------------------------------#\r\n anchors_tensor = K.reshape(K.constant(anchors), [1, 1, 1, num_anchors, 2])\r\n\r\n #---------------------------------------------------#\r\n # 获得x，y的网格\r\n # (13, 13, 1, 2)\r\n #---------------------------------------------------#\r\n grid_shape = K.shape(feats)[1:3]\r\n grid_y = K.tile(K.reshape(K.arange(0, stop=grid_shape[0]), [-1, 1, 1, 1]),\r\n [1, grid_shape[1], 1, 1])\r\n grid_x = K.tile(K.reshape(K.arange(0, stop=grid_shape[1]), [1, -1, 1, 1]),\r\n [grid_shape[0], 1, 1, 1])\r\n grid = K.concatenate([grid_x, grid_y])\r\n grid = K.cast(grid, K.dtype(feats))\r\n\r\n #---------------------------------------------------#\r\n # 将预测结果调整成(batch_size,13,13,3,85)\r\n # 85可拆分成4 + 1 + 80\r\n # 4代表的是中心宽高的调整参数\r\n # 1代表的是框的置信度\r\n # 80代表的是种类的置信度\r\n #---------------------------------------------------#\r\n feats = K.reshape(feats, [-1, grid_shape[0], grid_shape[1], num_anchors, num_classes + 5])\r\n\r\n #---------------------------------------------------#\r\n # 将预测值调成真实值\r\n # box_xy对应框的中心点\r\n # box_wh对应框的宽和高\r\n #---------------------------------------------------#\r\n box_xy = (K.sigmoid(feats[..., :2]) + grid) / K.cast(grid_shape[::-1], K.dtype(feats))\r\n box_wh = K.exp(feats[..., 2:4]) * anchors_tensor / K.cast(input_shape[::-1], K.dtype(feats))\r\n box_confidence = K.sigmoid(feats[..., 4:5])\r\n box_class_probs = K.sigmoid(feats[..., 5:])\r\n\r\n #---------------------------------------------------------------------#\r\n # 在计算loss的时候返回grid, feats, box_xy, box_wh\r\n # 在预测的时候返回box_xy, box_wh, box_confidence, box_class_probs\r\n #---------------------------------------------------------------------#\r\n if calc_loss == True:\r\n return grid, feats, box_xy, box_wh\r\n return box_xy, box_wh, box_confidence, box_class_probs\r\n\r\n\r\n#---------------------------------------------------#\r\n# 用于计算每个预测框与真实框的iou\r\n#---------------------------------------------------#\r\ndef box_iou(b1, b2):\r\n # 13,13,3,1,4\r\n # 计算左上角的坐标和右下角的坐标\r\n b1 = K.expand_dims(b1, -2)\r\n b1_xy = b1[..., :2]\r\n b1_wh = b1[..., 2:4]\r\n b1_wh_half = b1_wh/2.\r\n b1_mins = b1_xy - b1_wh_half\r\n b1_maxes = b1_xy + b1_wh_half\r\n\r\n # 1,n,4\r\n # 计算左上角和右下角的坐标\r\n b2 = K.expand_dims(b2, 0)\r\n b2_xy = b2[..., :2]\r\n b2_wh = b2[..., 2:4]\r\n b2_wh_half = b2_wh/2.\r\n b2_mins = b2_xy - b2_wh_half\r\n b2_maxes = b2_xy + b2_wh_half\r\n\r\n # 计算重合面积\r\n intersect_mins = K.maximum(b1_mins, b2_mins)\r\n intersect_maxes = K.minimum(b1_maxes, b2_maxes)\r\n intersect_wh = K.maximum(intersect_maxes - intersect_mins, 0.)\r\n intersect_area = intersect_wh[..., 0] * intersect_wh[..., 1]\r\n b1_area = b1_wh[..., 0] * b1_wh[..., 1]\r\n b2_area = b2_wh[..., 0] * b2_wh[..., 1]\r\n iou = intersect_area / (b1_area + b2_area - intersect_area)\r\n\r\n return iou\r\n\r\n#---------------------------------------------------#\r\n# loss值计算\r\n#---------------------------------------------------#\r\ndef yolo_loss(args, anchors, num_classes, ignore_thresh=.5, label_smoothing=0.1, print_loss=False, normalize=True):\r\n # 一共有两层\r\n num_layers = len(anchors)//3 \r\n\r\n #---------------------------------------------------------------------------------------------------#\r\n # 将预测结果和实际ground truth分开，args是[*model_body.output, *y_true]\r\n # y_true是一个列表，包含两个特征层，shape分别为(m,13,13,3,85),(m,26,26,3,85)\r\n # yolo_outputs是一个列表，包含两个特征层，shape分别为(m,13,13,3,85),(m,26,26,3,85)\r\n #---------------------------------------------------------------------------------------------------#\r\n y_true = args[num_layers:]\r\n yolo_outputs = args[:num_layers]\r\n\r\n #-----------------------------------------------------------#\r\n # 13x13的特征层对应的anchor是[81,82], [135,169], [344,319]\r\n # 26x26的特征层对应的anchor是[23,27], [37,58], [81,82]\r\n #-----------------------------------------------------------#\r\n anchor_mask = [[6,7,8], [3,4,5], [0,1,2]] if num_layers==3 else [[3,4,5], [1,2,3]]\r\n\r\n # 得到input_shpae为416,416 \r\n input_shape = K.cast(K.shape(yolo_outputs[0])[1:3] * 32, K.dtype(y_true[0]))\r\n\r\n loss = 0\r\n num_pos = 0\r\n #-----------------------------------------------------------#\r\n # 取出每一张图片\r\n # m的值就是batch_size\r\n #-----------------------------------------------------------#\r\n m = K.shape(yolo_outputs[0])[0]\r\n mf = K.cast(m, K.dtype(yolo_outputs[0]))\r\n\r\n #---------------------------------------------------------------------------------------------------#\r\n # y_true是一个列表，包含两个特征层，shape分别为(m,13,13,3,85),(m,26,26,3,85)\r\n # yolo_outputs是一个列表，包含两个特征层，shape分别为(m,13,13,3,85),(m,26,26,3,85)\r\n #---------------------------------------------------------------------------------------------------#\r\n for l in range(num_layers):\r\n #-----------------------------------------------------------#\r\n # 以第一个特征层(m,13,13,3,85)为例子\r\n # 取出该特征层中存在目标的点的位置。(m,13,13,3,1)\r\n #-----------------------------------------------------------#\r\n object_mask = y_true[l][..., 4:5]#[…, 4: 5]指的是该框的置信度,用1或0表示https://www.cnblogs.com/learningcaiji/p/14077315.html\r\n\r\n #-----------------------------------------------------------#\r\n # 取出其对应的种类(m,13,13,3,80)\r\n #-----------------------------------------------------------#\r\n true_class_probs = y_true[l][..., 5:]\r\n if label_smoothing:\r\n true_class_probs = _smooth_labels(true_class_probs, label_smoothing)\r\n\r\n #-----------------------------------------------------------#\r\n # 将yolo_outputs的特征层输出进行处理、获得四个返回值\r\n # 其中：\r\n # grid (13,13,1,2) 网格坐标\r\n # raw_pred (m,13,13,3,85) 尚未处理的预测结果\r\n # pred_xy (m,13,13,3,2) 解码后的中心坐标\r\n # pred_wh (m,13,13,3,2) 解码后的宽高坐标\r\n #-----------------------------------------------------------#\r\n grid, raw_pred, pred_xy, pred_wh = yolo_head(yolo_outputs[l],\r\n anchors[anchor_mask[l]], num_classes, input_shape, calc_loss=True)\r\n \r\n #-----------------------------------------------------------#\r\n # pred_box是解码后的预测的box的位置\r\n # (m,13,13,3,4)\r\n #-----------------------------------------------------------#\r\n pred_box = K.concatenate([pred_xy, pred_wh])\r\n\r\n #-----------------------------------------------------------#\r\n # 找到负样本群组，第一步是创建一个数组，[]\r\n #-----------------------------------------------------------#\r\n ignore_mask = tf.TensorArray(K.dtype(y_true[0]), size=1, dynamic_size=True)\r\n object_mask_bool = K.cast(object_mask, 'bool')\r\n \r\n #-----------------------------------------------------------#\r\n # 对每一张图片计算ignore_mask\r\n #-----------------------------------------------------------#\r\n def loop_body(b, ignore_mask):\r\n #-----------------------------------------------------------#\r\n # 取出n个真实框：n,4\r\n #-----------------------------------------------------------#\r\n true_box = tf.boolean_mask(y_true[l][b,...,0:4], object_mask_bool[b,...,0])\r\n #-----------------------------------------------------------#\r\n # 计算预测框与真实框的iou\r\n # pred_box 13,13,3,4 预测框的坐标\r\n # true_box n,4 真实框的坐标\r\n # iou 13,13,3,n 预测框和真实框的iou\r\n #-----------------------------------------------------------#\r\n iou = box_iou(pred_box[b], true_box)\r\n\r\n #-----------------------------------------------------------#\r\n # best_iou 13,13,3 每个特征点与真实框的最大重合程度\r\n #-----------------------------------------------------------#\r\n best_iou = K.max(iou, axis=-1)\r\n\r\n #-----------------------------------------------------------#\r\n # 判断预测框和真实框的最大iou小于ignore_thresh\r\n # 则认为该预测框没有与之对应的真实框\r\n # 该操作的目的是：\r\n # 忽略预测结果与真实框非常对应特征点，因为这些框已经比较准了\r\n # 不适合当作负样本，所以忽略掉。\r\n #-----------------------------------------------------------#\r\n ignore_mask = ignore_mask.write(b, K.cast(best_iou Dict[int, str]:\n iupacs = {}\n with open(iupac_name_file) as file_in:\n csv_reader = csv.reader(file_in)\n for idx,row in enumerate(csv_reader):\n if idx == 0:\n continue\n id = int(row[0])\n # remove right most part'(a1-sp14'\n iupac = re.split(r\"\\([^\\)]*$\", row[1], 1)[0]\n iupacs[id] = iupac\n return iupacs\n\n# method to get a dict of glycans form input iupac snfg\ndef get_glycans(iupacs:Dict[int, str], start = None, end = None) -> Tuple[Dict[int, Glycan], List[str], List[str]]:\n gylcans_dict = {}\n monos = []\n links = []\n \n for id in iupacs:\n if start is not None and id < start:\n continue\n if end is not None and id > end:\n continue \n inpuac_text = iupacs[id]\n gylcan = Glycan(inpuac_text)\n \n #if gylcan.get_num_nosaccharides() > 2:\n gylcans_dict[id] = gylcan\n monos += gylcan.get_filtered_monosaccharide_emssions()\n links += gylcan.get_filtered_linkage_emssions()\n \n mono_emissions = list(set(monos))\n link_emissions = list(set(links))\n\n return gylcans_dict, mono_emissions, link_emissions\n\n# Method create foreset iputs from a dict collection of glycans\n# Input:\n# glycans_dict: dict of glycans\n# Return:\n# joint_adj_matrix - joint adjcent matrix \n# joint_monosaccharide_emission_observations - joint emissions for monosaccharides types\n# joint_linkage_emission_observations - joint emissions for linkage types\ndef create_forest_inputs(glycans_dict:Dict[int, Glycan]) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:\n adj_matrices = []\n joint_monosaccharide_emission_observations = []\n joint_linkage_emission_observations = []\n\n for id in glycans_dict:\n glyan = glycans_dict[id]\n # update list of adj_matrices we are going to join along the diagonal\n adj_matrices.append(glyan.get_adj_matrix())\n # update joint_monosaccharide_emission_observations and joint_linkage_emission_observations\n joint_monosaccharide_emission_observations = joint_monosaccharide_emission_observations + glyan.get_filtered_monosaccharide_emssions()\n joint_linkage_emission_observations = joint_linkage_emission_observations + glyan.get_filtered_linkage_emssions()\n\n # join adj_martrix along diagonal\n joint_adj_matrix = block_diag(*adj_matrices)\n return joint_adj_matrix, joint_monosaccharide_emission_observations, joint_linkage_emission_observations\n\n# Method learn a treehmm from a forset\n# Input:\n# joint_adj_matrix - joint adjcent matrix \n# joint_emissions_observations - emissions observations for this foreset N * M, N is the number of emissions group eg,monosaccharide, linkage,\n# M is number of emssions groups eg. monosaccharide_emissions for group 1 and linkage_emissions for group 2\n# number_state - number of states\n# possible_emissions - possible_ emissions for this foreset N * M, N is the number of emissions group eg,monosaccharide, linkage, \n# M is number of emssions groups eg. monosaccharide_emissions for group 1 and linkage_emissions for group 2\ndef create_and_train_treehmm(number_state:int, iupacs, include_linkage = False, max_iterations=50, delta=1e-5):\n\n gylcans, possible_monosaccharide_emissions, possible_linkage_emissions = get_glycans(iupacs, 50, 75)\n \n joint_adj_matrix, joint_monosaccharide_emission_observations, joint_linkage_emission_observations = create_forest_inputs(gylcans)\n\n #print(possible_monosaccharide_emissions)\n # monosaccharide_emission_observations_counts = {}\n # for item in possible_monosaccharide_emissions:\n # monosaccharide_emission_observations_counts[item] = 0\n # for item in joint_monosaccharide_emission_observations:\n # monosaccharide_emission_observations_counts[item] += 1\n # print(monosaccharide_emission_observations_counts)\n\n # possible_linkage_emissions_counts = {}\n # for item in possible_linkage_emissions:\n # possible_linkage_emissions_counts[item] = 0\n # for item in joint_linkage_emission_observations:\n # possible_linkage_emissions_counts[item] += 1\n # print(possible_linkage_emissions_counts)\n\n # we only use monosaccharide\n if not include_linkage:\n joint_emissions_observations = [joint_monosaccharide_emission_observations]\n possible_emissions = [possible_monosaccharide_emissions]\n else:\n # if we want to use both of them\n joint_emissions_observations = [joint_monosaccharide_emission_observations, joint_linkage_emission_observations]\n possible_emissions = [possible_monosaccharide_emissions, possible_linkage_emissions]\n \n forest = csr_matrix(joint_adj_matrix)\n # create states\n states = [ str(i) for i in range(number_state)]\n \n #state_transition_probabilities = np.array([0.1,0.9,0.1,0.9]).reshape(2,2)\n hmm = initHMM.initHMM(states, possible_emissions)\n newparam = None\n for i in range(5):\n # The baumWelch part: To find the new parameters and result statistics\n newparam = baumWelch.hmm_train_and_test(hmm, forest, joint_emissions_observations, maxIterations = max_iterations, delta = delta)\n #newparam = baumWelch.baumWelchRecursion(hmm, emission_observation)\n\n\n hmm = initHMM.initHMM(states, possible_emissions, state_transition_probabilities=newparam['hmm']['state_transition_probabilities'],\n emission_probabilities=newparam['hmm']['emission_probabilities'])\n \n #print(newparam['hmm']['state_transition_probabilities'])\n #print(newparam['hmm']['emission_probabilities'])\n #fwd_tree_sequence = fwd_seq_gen.forward_sequence_generator(forest)\n #bind_fwd_probs = forward.forward(hmm_trained, forest, joint_emissions_observations, fwd_tree_sequence)\n #print(joint_emissions_observations)\n \n ll = 0\n for glycan_idx in gylcans:\n glycan = gylcans[glycan_idx]\n #print(glycan.get_filtered_monosaccharide_emssions())\n glycan_tree = csr_matrix(glycan.get_adj_matrix())\n fwd_tree_sequence = fwd_seq_gen.forward_sequence_generator(glycan_tree)\n emssions = glycan.get_filtered_monosaccharide_emssions()\n if include_linkage:\n emssions += glycan.get_filtered_linkage_emssions()\n if fwd_tree_sequence[-1] != glycan.get_num_nosaccharides() - 1:\n print('oops')\n bind_fwd_probs = forward.forward(hmm, glycan_tree, [emssions], fwd_tree_sequence)\n case_ll = logsumexp(bind_fwd_probs.iloc[:, -1])\n ll += case_ll\n \n print(max_iterations * (i + 1), ll)\n return newparam\n\nif __name__ == \"__main__\":\n\n #log_format = '%(asctime)s %(message)s'\n #$logging.basicConfig(stream=sys.stdout, level=logging.INFO,\n # format=log_format, datefmt='%m/%d %I:%M:%S %p')\n \n # get arguments\n parser = argparse.ArgumentParser()\n parser.add_argument('--num_states', help='num of hidden states', type = int, default = 2)\n parser.add_argument('--include_linkage', help='0 for no, 1 for yes', type = int, default = 0)\n args = parser.parse_args()\n\n num_states = args.num_states\n include_linkage = True if args.include_linkage > 0 else False\n\n # read iupac and get gylcans\n iupac_name_file = './Data/IUPAC.csv'\n iupacs = get_iupcas(iupac_name_file)\n #create_and_train_treehmm(num_states, iupacs, max_iterations = 5)\n #create_and_train_treehmm(num_states, iupacs, max_iterations = 10)\n #create_and_train_treehmm(num_states, iupacs, max_iterations = 20)\n #create_and_train_treehmm(num_states, iupacs, max_iterations = 30)\n #create_and_train_treehmm(num_states, iupacs, max_iterations = 40)\n \n gylcans, possible_monosaccharide_emissions, possible_linkage_emissions = get_glycans(iupacs)\n joint_adj_matrix, joint_monosaccharide_emission_observations, joint_linkage_emission_observations = create_forest_inputs(gylcans)\n\n #print(possible_monosaccharide_emissions)\n monosaccharide_emission_observations_counts = {}\n for item in possible_monosaccharide_emissions:\n monosaccharide_emission_observations_counts[item] = 0\n for item in joint_monosaccharide_emission_observations:\n monosaccharide_emission_observations_counts[item] += 1\n print(monosaccharide_emission_observations_counts)\n\n possible_linkage_emissions_counts = {}\n for item in possible_linkage_emissions:\n possible_linkage_emissions_counts[item] = 0\n for item in joint_linkage_emission_observations:\n possible_linkage_emissions_counts[item] += 1\n print(possible_linkage_emissions_counts)\n", "meta": {"hexsha": "5a3216a89938691c5c42d85a6949e980a771532a", "size": 9202, "ext": "py", "lang": "Python", "max_stars_repo_path": "treehmm4glycan.py", "max_stars_repo_name": "TreeHMM4Glycan/TreeHMM4Glycan", "max_stars_repo_head_hexsha": "3fe654307a0d6b0b2a5d727ef0e3b1e40c965e67", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "treehmm4glycan.py", "max_issues_repo_name": "TreeHMM4Glycan/TreeHMM4Glycan", "max_issues_repo_head_hexsha": "3fe654307a0d6b0b2a5d727ef0e3b1e40c965e67", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "treehmm4glycan.py", "max_forks_repo_name": "TreeHMM4Glycan/TreeHMM4Glycan", "max_forks_repo_head_hexsha": "3fe654307a0d6b0b2a5d727ef0e3b1e40c965e67", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 46.2412060302, "max_line_length": 144, "alphanum_fraction": 0.7276678983, "include": true, "reason": "import numpy,from scipy", "num_tokens": 2392, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.523420348936324, "lm_q2_score": 0.3702253925955867, "lm_q1q2_score": 0.19378350417746953}} {"text": "#!/usr/bin/env python2\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Thu May 25 10:10:28 2017\n\n@author: Katherine\n\"\"\"\n\n#!/usr/bin/env python2\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Tue May 23 16:04:21 2017\n\n@author: Katherine\n\"\"\"\n\n# -*- coding: utf-8 -*-\n\"\"\"\nPhotosynthesis and Stomatal Conductance Model \nCreated 9/27/2016\nKatherine Wentz\n\nThis is a program that runs photosynthesis and\nstomatal conductance models given changes in leaf-\nlevel traits. \n\nThe end product is graphs of NUE vs. WUE.\n\n\nUpdate: I am going to run the model for plants with \ntraits that are distinctive of the meadow moisture \ngradient in the alpine tundra.\n\nFix: correct for atmospheric pressure differences in co2, o2, and vapor pressure\n\nFix: vcmax temp dependence (pg 63 in plant physiological ecology book)\n\nFix: NEW VARIBALE TRAIT-->make the fraction of leaf N in rubisco go down with increasing SLA,\nchlorophyll content, and decreasing light (wet meadow)--more N is allocated\nto thylakoids. The only way for chl/m2 to increase even when g N/m2 goes down\nor is constant is for the leaf to allocate more of leaf N to chl...also, note\nthat there is more organic N designated to photo in leaf when SLA goes up\nbecause less N is used in structure. see \"Photosynthesis or persistence: N allocation\nin leaves of evergreen and deciduous... by Takashima et al. 2004. Also see Photosynthetic\nnitrogen-use efficiency of species...by Poorter and Evans 1998\n\nNote to self: NUE and WUE relationship flipflops with change in air temperature;\nNUE makes sense because C:N decreases from dry to wet meadows; WUE increasing\nin snowbed does not necessarilly make sense--look in the literature for this\n\nherbs have a higher NUE\n\n\"\"\"\n\n#---------------Import Modules---------------#\n\nimport itertools as it\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\n#Import combinations of variable parameters \nfrom uncertain_params import monte_carlo\n\n#Import photosynthesis model\nfrom Photosynthesis_Model import photo_bound_meso_eqstom as photo\n\n#Import functions to switch between Pa and umol/mol at sea level\nfrom photo_functions import pa_con_atmfrac\n\n\n#import timeseries of vwc and temp\nfrom time_dep_params import surtemp_dm, surtemp_wm, vwc_dm, vwc_wm, na_dm_min_inter,na_wm_min_inter,na_dm_max_inter,na_wm_max_inter\n\n\n#---------------Determine if I Want to Keep Any of the Variable Parameters Constant---------------#\n\nconst_params=[]\nfor xxx in it.combinations(['ht'],0): #keep ht and t constant for constant vpd\n const_params+=[xxx]\n\n#do this when I do not put any of the variable parameters as constant. instead I \n#vary each parameter one at a time while keeping the other parameters constant.\nif const_params==[()]:\n const_params=[[-999999]] \n\n#---------------Begin Looping Through Photosynthesis Model---------------#\n\n#each loop is for a constant value, or combinatin of constant values, of variable parameter as determined above\nfor ii in range(len(const_params)):\n\n\n\n\n #---------------Run through time series---------------#\n \n days=np.linspace(1,365,365)\n \n #dry meadow\n tot_nue_dm_avg=[]\n tot_wue_dm_avg=[]\n tot_nue_dm_min=[]\n tot_wue_dm_min=[]\n tot_nue_dm_max=[]\n tot_wue_dm_max=[]\n tot_A_dm_avg=[]\n tot_gs_dm_avg=[]\n \n #moist meadow\n tot_nue_mm_avg=[]\n tot_wue_mm_avg=[]\n tot_nue_mm_min=[]\n tot_wue_mm_min=[]\n tot_nue_mm_max=[]\n tot_wue_mm_max=[] \n tot_A_mm_avg=[]\n tot_gs_mm_avg=[]\n\n #wet meadow\n tot_nue_wm_avg=[]\n tot_wue_wm_avg=[]\n tot_nue_wm_min=[]\n tot_wue_wm_min=[]\n tot_nue_wm_max=[]\n tot_wue_wm_max=[]\n tot_A_wm_avg=[]\n tot_gs_wm_avg=[]\n\n\n \n\n \n \n\n\n\n #---------------Photosynthesis + Stomatal Conductance Model---------------#\n\n \n ##---Constant Parameter Arrays for Model---##\n\n #----Params Used in Model Currently----#\n \n tk_25=298.16; #absolute temperature at 25 C\n ekc=80500.0 #Activation energy for K of CO2 (J mol-1)\n eko=14500.0 #Activation energy for K of O2 (J mol-1)\n etau=-29000.0 #Activation energy for tau (???) (J mol-1)\n ev=55000.0 #Activation energy for carboxylation (J mol-1)\n ej=55000.0 #Activation energy for electron transport (J mol-1)\n toptv=303.0 #Optimum temperature for maximum carboxylation (K)\n toptj=303.0 #Optimum temperature for maximum electron transport (K)\n ra=np.zeros(shape=1)+20.7 #specific rubisco activity (umol CO2/g Rub s)\n flnr=np.zeros(shape=1)+0.1 #fraction of leaf nitrogen in rubisco (g N Rub/g N leaf)\n frnr=np.zeros(shape=1)+6.25 #weight fraction of nitrogen in rubisco molecule (g Rub/g N Rub) \n rh=np.zeros(shape=1)+0.5 #relative humidity (kPa/kPa)\n ca=np.zeros(shape=1)+405 #ambient carbon dioxide (umol CO2/mol air)\n ko25=np.zeros(shape=1)+30000 #Michaelis-Menten kinetic coefficient for oxygen at 25 C(Pa) \n kc25=np.zeros(shape=1)+30 #Michaelis-Menten kinetic coefficient for carbon dioxide at 25 C (Pa)\n o=np.zeros(shape=1)+210000 #concentration of ambient oxygen (umol/mol)\n g0=np.zeros(shape=1)+0.002 #Ball-Berry stomatal conductance intercept parameter (mol H2O/m2s)\n a=np.zeros(shape=1)+1.6 #Conversion Coefficient between stomatal conductance to water and carbon dioxide (unitless)\n ij=np.zeros(shape=1)+1.0 #leaf angle index--downregulates jmax\n m=np.zeros(shape=1)+9.0 #ball-berry parameter (unitless)\n b=1.37 #Conversion Coefficient between boundary layer conductance to water and carbon dioxide \n u=5.0 #windspeed (m/s)\n qeff=0.32 #leaf quantum yield, electrons\n PAR=2000 #photosynthetic active radiation (umol/m2s)\n jm=2.68 #slope coefficient \n vwc_min=0.08 #minimum soil water content for photosynthesis to occur (permanent wilting point) (cm3/cm3) \n vwc_max=0.68 #maximum soil water content where increases in soil water do not affect photosynthesis (field capacity?) (cm3/cm3)\n q=0.2 #parameter for soil water affect on photosynthesis (unitless)\n \n \n #------constant variable params for sensitivty analysis-----#\n \n chl_c=np.zeros(shape=1)+(np.mean([396,465,476])) #Chlorophyll Content of the Leaf (umol chl/m2)\n ht_c=np.zeros(shape=1)+(np.mean([9.2,19.5,20.0])) #Temperature of the Leaf (K)\n dia_c=np.zeros(shape=1)+(np.mean([1.4,2.3,2.6])/100.) #Mean diameter or size of leaf (m)\n na_c=np.zeros(shape=1)+(np.mean([2.5,5.6,6.3])) #leaf nitrogen (g N/ m2)\n t_c=np.zeros(shape=1)+15.0 #temp (C)\n\n\n #-----which timeseries should I use--based on factorial meadow type---#\n \n na_min=[na_dm_min_inter, na_dm_min_inter, na_wm_min_inter, na_wm_min_inter]\n na_max=[na_dm_max_inter, na_dm_max_inter, na_wm_max_inter, na_wm_max_inter]\n\n vwc_type=[vwc_dm,vwc_dm,vwc_wm,vwc_wm]\n temp_type=[surtemp_dm,surtemp_dm,surtemp_wm,surtemp_wm]\n\n \n A_tot_all=[]\n \n chl_mean=[[395.7132],[475.8913],[395.7132],[475.8913]]\n chl_sd=[[24.410199999999975],[29.185099999999977],[24.410199999999975],[29.185099999999977]]\n dia_mean=[[1.6/100.],[3.0/100.],[1.6/100.],[3.0/100.]]\n dia_sd=[[0.9/100.0],[1.2/100.0],[0.9/100.0],[1.2/100.0]]\n ht_mean=[[9.183549],[19.98519],[9.183549],[19.98519]]\n ht_sd=[[1.5],[3.1],[1.5],[3.1]]\n \n depth=[0.2,0.2,0.2,0.4,0.4,0.4]\n \n\n#---------------Import Variable Parameter Arrays from Leaf Parameter File---------------#\n for iii in range(len(chl_mean)):\n A_tot=0\n for time in range(129):\n params=monte_carlo(chl_mean[iii], chl_sd[iii], dia_mean[iii], dia_sd[iii], [na_min[iii][time]], [na_max[iii][time]], ht_mean[iii], ht_sd[iii]) \n A_day=[]\n for xx in range(len(params)):\n for yy in range(len(params[xx])):\n for key,val in params[xx][yy].items():\n exec(key + '=val')\n \n #set variable parameters constant if I specify this above\n if 'na' in const_params[ii]:\n na=na_c\n if 'dia' in const_params[ii]:\n dia=dia_c\n if 'chl' in const_params[ii]:\n chl=chl_c\n if 'ht' in const_params[ii]:\n ht=ht_c\n \n \n #------calculate vapor pressure-----#\n pa_v=611*np.exp((17.27*temp_type[iii][time])/(temp_type[iii][time]+237.3)) #saturation vapor pressure of air (Pa)\n ea_str=pa_con_atmfrac(pa_v,3528) #saturation vapor pressure of air (Pa-->umol h20/mol air)\n ea=rh*ea_str #vapor pressure (umol h2O/mol air) \n \n \n #correct for leaf temperatures using leaf height\n \n t_diff=18-0.4*ht\n \n tl=temp_type[iii][time]+t_diff \n \n z=depth[iii]\n \n #---------------Photosynthesis Function---------------#\n \n #alter this line of code for when implementing different photosynthesis functions\n wue, nue, A, E, cs, ci, gsw, gs, gbw, gb, gm, cc,dd =photo(tk_25,ekc,eko,etau,ev,ej,toptv,toptj,na, qeff, PAR,tl,ea,chl,ij,kc25,ko25,o,ca,rh,m,a,frnr,flnr,ra,jm,g0,b,dia,u,q,vwc_min,vwc_max,vwc_type[iii][time],z)\n \n \n #test to make sure wue and nue are positive at not 'nan'\n if wue[0]==-999 and nue[0]==-999:\n \n continue \n \n if np.isnan(A[0]):\n A[0]=0.0\n \n A_day+=[(A[0]*3600*6)/1000000.*44.]\n \n\n A_tot+=np.mean(A_day)\n\n \n \n A_tot_all+=[A_tot]\n print A_tot_all\n\n \n \nprint A_tot_all \n \n\n", "meta": {"hexsha": "25ec21860a4a7eb90ce6aa2fe9f2d92be59b0512", "size": 9910, "ext": "py", "lang": "Python", "max_stars_repo_path": "Traits_Physical_Factorial_CummulativeGS.py", "max_stars_repo_name": "kwentz10/Photosynthesis_Optimization_Modeling", "max_stars_repo_head_hexsha": "864c174ae4298bfdabee36fd0305c6a3649c38bd", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Traits_Physical_Factorial_CummulativeGS.py", "max_issues_repo_name": "kwentz10/Photosynthesis_Optimization_Modeling", "max_issues_repo_head_hexsha": "864c174ae4298bfdabee36fd0305c6a3649c38bd", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Traits_Physical_Factorial_CummulativeGS.py", "max_forks_repo_name": "kwentz10/Photosynthesis_Optimization_Modeling", "max_forks_repo_head_hexsha": "864c174ae4298bfdabee36fd0305c6a3649c38bd", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.9776119403, "max_line_length": 232, "alphanum_fraction": 0.6206861756, "include": true, "reason": "import numpy", "num_tokens": 2710, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.523420348936324, "lm_q2_score": 0.3702253925955866, "lm_q1q2_score": 0.1937835041774695}} {"text": "#Script to generate DSWE Version 2 Prototype 1 (V2_P1) Open Source Distribution Version 2 (distro_v3)\n#\n#\n#\n# *****************DEPENDENCIES*******************************************\n# Python 2.7 64 bit, will not run on 32 bit Python\n# GDAL 2.1+\n# numpy 1.12\n# lxml 3.7+\n#\n# *****************REVISION HISTORY*************************************** \n# Initiated on 08/13/16 by John W. Jones.\n# Modified on 8/15/16 by Jacob Shermeyer to improve efficiency and activate\n# recoding scheme to produce the interpreted layer.\n# Modified on 11/08/16 by John W. Jones to improve documentation as well as\n# revise the recode scheme to produce revised interpreted layer.\n# Modified on 11/14/2016 to add slope masking.\n# Modified on 1/18/2017 to enhance processing speed and remove a few unnecessary items\n# Modified on 2/22/2017 to change to open source implementation (GDAL and numpy)\n# Modified through March and April 2017 to add hillshade, modify slope masking, and update to the \n# new SR naming convention\n# Modified April 27-28 2017 to remove NLCD masking, remove redundant opening and closing of files,\n# generally improve performance, and change output bands to only those that will be distributed.\n# Note also, that the calculation of percent slope and hillshade layers are assumed to occur\n# outside of this code (in a pre-processing program).\n#\n# *****************INPUT FILE STRUCTURE***********************************\n# Required inputs for DSWE are LSRP data, the CFMask file generated by EROS, percent slope and hillshade\n# The input file directory should contain subdirectories in which all the geotiff formatted bands of a single\n# input scene have been extracted from their zip files and are stored in seperate folders.\n# Naming conventions of these files must not be edited in ANY way! Use the default filenames as they were distributed by EROS.\n# 04/28/2017\n# With this version, a percent slope file for the US is stored at the top level of the input directory. And hillshade data\n# calculated using the scene-specific solar geometry included in the mtl or xml file is included in\n# the same folder as each set of unzipped LSRP file associated with each scene. \n# This data derived from the DEM should be at 30m spatial resolution, snapped to your Landsat image and MUST be projected to match\n# the Landsat UTM zone. It should be slighlty larger than your path/row.\n# \n#\n# *****************VARIABLE DECLARATIONS***********************************\n#\n# Input (data) variables\n# BLUE = Landsat TM/ETM Band 1 or OLI Band 2\n# GREEN = Landsat TM/ETM Band 2 or OLI Band 3 \n# NIR = Landsat TM/ETM Band 4 or OLI Band 5\n# SWIR1 = Landsat TM/ETM Band 5 or OLI Band 6 \n# SWIR2 = Landsat TM/ETM Band 7 or OLI Band 7\n# CF= Landsat Cfmask- Cloud, Cloud Shadow, and Snow Mask distributed with LSRP data\n#\n# *****************CALCULATED VARIABLES ON WHICH DECISIONS ARE MADE*********\n#\n# NDVI = Normalized Difference Vegetation Index\n# MNDWI = Modified Normalized Difference Wetness Index\n# MBSRV = Multiband Spectral Relationship Visible\n# MBSRN = Multiband Spectral Relationship Near-infrared\n# AWEsh = Automated raster Extent Shadow\n# PSW1 = Partial Surface Water 1\n# PSW2 = Partial Surface Water 2\n#\n# *****************OUTPUT INFORMATION*****************************\n# Diagnostic layer- Layer indicating the combination of outcomes of the 5 water tests\n# Interpreted layer- Interpretation of the diagnostic layer:\n# 0= Non-Water, 1= High Confidence water, 2= Medium Confidence Water, 3= Potential Wetland, 4= Low Confidence Water or Wetland\n# Masked Interpreted layer- Cloud, Snow, Slope, and Hillshade\n# Mask Layer- A combination of all masks, combinations of these values indicate a pixel was masked multiple times:\n# 0- No masks applied\n# 2- CFMask Cloud Shadow Mask\n# 3- CFMask Snow Mask\n# 4- CFMask Cloud Mask\n# 10- Slope Mask\n# 20- Hillshade Mask\n# 30- Slope and Hillshade Combination Mask\n\n\n\n#Imports\nimport numpy as np\nimport gdal\nimport os\nimport datetime\nimport glob\nimport sys\nfrom lxml import etree\n\n\n# ******************REQUIRED INPUT PARAMETERS******************************** \nWIGT = 0.124\nAWGT = 0\nAWE_param1 = 2.5\nAWE_param2 = -1.5\nAWE_param3 = -0.25\nPSW1_MNDWI = -0.44\nPSW1_NIR = 1500\nPSW1_SWIR1 = 900\nPSW1_NDVI = 0.7\nPSW2_MNDWI = -0.5\nPSW2_BLUE = 1000\nPSW2_NIR = 2500\nPSW2_SWIR1 = 3000\nPSW2_SWIR2 = 1000\n# Cutoff value for hillshade, values for hillshade range from 1-255, the lower the more shaded.\nHS=110\n\n\n\n# ***************************REQUIRED PATH INFORMATION**************************\n# Specify the path for input and output data, remember to use / insted of \\ if there are any numbers in the path\ninput_dir = \"H:\\DSWE\\DSWE_V2\\Cal_Val_Inputs_subset\"\noutput_dir = \"H:\\DSWE\\DSWE_V2\\Cal_Val_Outputs_subset\"\n\n\n\n# ***************************REQUIRED SLOPE INFORMATION**************************\n# Slope file you have created must be stored in the input_dir along with the LSRP data\n# The file must have the word \"perslp\" anywhere in the filename and be a .tif image.\n\n\n#Set the overwrite & output environment\ndriver = gdal.GetDriverByName(\"GTiff\")\nos.chdir(input_dir)\npaths = glob.glob('*/')\nprint paths\nfor folder in paths:\n output_dir2=output_dir + \"/\" + folder\n if not os.path.exists(output_dir2):\n os.makedirs(output_dir2) \n folder=os.path.join(input_dir,folder)\n os.chdir(folder)\n # Identify our percent slope file\n PerSlpL=[]\n PerSlpL=glob.glob('*perslp*.tif')\n if len(PerSlpL) > 1 or len(PerSlpL) < 1:\n print \"multiple or no PerSlpL files, please place only one PerSlpL file in the LSRP input_dir\"\n exit()\n else:\n print \"Using PerSlpL file:\"\n print PerSlpL[0]\n Perslp= os.path.abspath(PerSlpL[0])\n print Perslp\n count = 1\n #Loop through the input directory and identitify our LSRP scenes and save them to the list\n print datetime.datetime.now()\n subdirs= glob.glob('*/')\n print('Found directories: %s' % subdirs)\n subdirnumber=0\n subdirnumber+= len(subdirs)\n print subdirnumber\n cwd = os.getcwd()\n print cwd\n if count <= subdirnumber:\n T1=datetime.datetime.now()\n for directory in subdirs:\n print \"\"\n print \"\"\n print \"\"\n working_dir=folder + \"//\" + directory\n print working_dir\n os.chdir(working_dir)\n inputRaster = []\n inputRaster= glob.glob('L*')\n print inputRaster\n \n #Identify bands based upon satellite\n for raster in inputRaster:\n filetrim=raster[:5]\n numtrim=filetrim[4:]\n if numtrim == \"_\":\n filetrim=raster[:4]\n numtrim=filetrim[3:]\n LSnum=int(numtrim)\n length=40\n length2=21\n else:\n filetrim=raster[:3]\n numtrim=filetrim[2:]\n LSnum=int(numtrim)\n length=21\n length2=13\n \n #Landsat 4,5, and 7\n if LSnum<=7 :\n Blue= working_dir + '\\%s_sr_band1.tif'%(raster)[0:length]\n Green= working_dir + '\\%s_sr_band2.tif'%(raster)[0:length]\n Red= working_dir + '\\%s_sr_band3.tif'%(raster)[0:length]\n NIR= working_dir + '\\%s_sr_band4.tif'%(raster)[0:length]\n SWIR1= working_dir + '\\%s_sr_band5.tif'%(raster)[0:length]\n SWIR2= working_dir + '\\%s_sr_band7.tif'%(raster)[0:length]\n CF = working_dir + '\\%s_cfmask.tif'%(raster)[0:length]\n Hillshade= working_dir + '\\%s_hillshade.tif'%(raster)[0:length]\n Metadata = working_dir + '\\%s.xml'%(raster)[0:length]\n yeartrim=raster[:length2]\n year=yeartrim[-4:]\n year=int(year)\n #Landsat 8\n elif LSnum==8:\n Blue= working_dir + '\\%s_sr_band2.tif'%(raster)[0:length]\n Green= working_dir + '\\%s_sr_band3.tif'%(raster)[0:length] \n Red= working_dir + '\\%s_sr_band4.tif'%(raster)[0:length]\n NIR= working_dir + '\\%s_sr_band5.tif'%(raster)[0:length]\n SWIR1= working_dir + '\\%s_sr_band6.tif'%(raster)[0:length]\n SWIR2= working_dir + '\\%s_sr_band7.tif'%(raster)[0:length]\n CF = working_dir + '\\%s_cfmask.tif'%(raster)[0:length]\n Hillshade= working_dir + '\\%s_hillshade.tif'%(raster)[0:length]\n Metadata = working_dir + '\\%s.xml'%(raster)[0:length]\n yeartrim=raster[:length2]\n year=yeartrim[-4:]\n year=int(year)\n else:\n print \"Wrong satellite or wonky input, check data.\"\n quit()\n out_name = 'DSWE_V2_P1'\n\n # Perform Water Index (MNDWI only based) Test- Working\n GreenB= gdal.Open(Green)\n SWIR1B= gdal.Open(SWIR1)\n geo = GreenB.GetGeoTransform() \n proj = GreenB.GetProjection()\n GreenB= GreenB.GetRasterBand(1).ReadAsArray()\n SWIR1B= SWIR1B.GetRasterBand(1).ReadAsArray()\n shape = GreenB.shape\n MNDWI = ((GreenB - SWIR1B) /np.float32(GreenB + SWIR1B))\n con_MNDWI=MNDWI.copy()\n con_MNDWI[con_MNDWI <= WIGT] = 0\n con_MNDWI[con_MNDWI > WIGT] = 1\n con_MNDWI=np.int8(con_MNDWI)\n #Optional to output MNDWI test\n #con_MNDWI1_out = driver.Create( \"con_MNDWI1.tif\", shape[1], shape[0], 1, gdal.GDT_UInt16)\n #con_MNDWI1_out.SetGeoTransform( geo )\n #con_MNDWI1_out.SetProjection( proj ) \n #con_MNDWI1_out.GetRasterBand(1).WriteArray(con_MNDWI)\n #con_MNDWI1_out=None \n\n # Perform MBSR Test- Working\n RedB= gdal.Open(Red)\n RedB= RedB.GetRasterBand(1).ReadAsArray()\n MBSV = (GreenB + RedB)\n NIRB= gdal.Open(NIR)\n NIRB= NIRB.GetRasterBand(1).ReadAsArray()\n MBSRN = (NIRB + SWIR1B)\n con_MBSR=np.zeros(shape)\n con_MBSR[MBSV > MBSRN] = 10\n con_MBSR=np.int8(con_MBSR)\n del MBSV\n #Optional to output MBSR test\n #con_MBSR_out = driver.Create( \"con_MBSR.tif\", shape[1], shape[0], 1, gdal.GDT_UInt16)\n #con_MBSR_out.SetGeoTransform( geo )\n #con_MBSR_out.SetProjection( proj ) \n #con_MBSR_out.GetRasterBand(1).WriteArray(con_MBSR)\n #con_MBSR_out=None\n\n #Calculate AWEsh values- working\n con_AWEsh = (np.float32(GreenB) * AWE_param1)\n con_AWEsh += (np.float32(MBSRN) * AWE_param2)\n MBSRN_out = driver.Create( \"MBSRN.tif\", shape[1], shape[0], 1, gdal.GDT_UInt32)\n MBSRN_out.SetGeoTransform( geo )\n MBSRN_out.SetProjection( proj ) \n MBSRN_out.GetRasterBand(1).WriteArray(MBSRN)\n MBSRN_out=None\n SWIR2B= gdal.Open(SWIR2)\n SWIR2B= SWIR2B.GetRasterBand(1).ReadAsArray()\n con_AWEsh += (np.float32(SWIR2B) * AWE_param3)\n BlueB= gdal.Open(Blue)\n BlueB= BlueB.GetRasterBand(1).ReadAsArray()\n con_AWEsh += np.float32(BlueB)\n con_AWEsh[con_AWEsh > 0] = 100\n con_AWEsh[con_AWEsh <= 0] = 0\n con_AWEsh=np.int8(con_AWEsh)\n #Optional to output AWEsh test\n #con_AWEsh_out = driver.Create( \"con_AWEsh.tif\", shape[1], shape[0], 1, gdal.GDT_UInt16)\n #con_AWEsh_out.SetGeoTransform( geo )\n #con_AWEsh_out.SetProjection( proj ) \n #con_AWEsh_out.GetRasterBand(1).WriteArray(con_AWEsh)\n #con_AWEsh_out=None\n\n\n # Perform Partial Surface Water test 1 (PSW1)-working\n con_PSW1_MNDWI=((GreenB - SWIR1B) /np.float32(GreenB + SWIR1B))\n\n con_PSW1_MNDWI[con_PSW1_MNDWI > PSW1_MNDWI] = 1\n con_PSW1_MNDWI[con_PSW1_MNDWI <= PSW1_MNDWI] = 0\n con_PSW1_MNDWI=np.int8(con_PSW1_MNDWI)\n NIRB[NIRB < PSW1_NIR] = 1\n NIRB[NIRB >= PSW1_NIR] = 0\n PSW1= np.int8(con_PSW1_MNDWI) * np.int8(NIRB)\n PSW1_SWIR1B=SWIR1B.copy()\n PSW1_SWIR1B[PSW1_SWIR1B < PSW1_SWIR1] = 1\n PSW1_SWIR1B[PSW1_SWIR1B >= PSW1_SWIR1] = 0\n PSW1= np.int8(PSW1) * np.int8(PSW1_SWIR1B)\n del PSW1_SWIR1B\n \n # Calculate NDVI\n NIRB= gdal.Open(NIR)\n NIRB= NIRB.GetRasterBand(1).ReadAsArray() \n NDVI = ((NIRB - RedB) /np.float32(NIRB + RedB))\n con_NDVI=np.zeros(shape)\n con_NDVI[NDVI < PSW1_NDVI] = 1\n PSW1= np.int16(PSW1) * np.int16(con_NDVI) * 1000\n #Optional to output PSW1 test\n #PSW1_out = driver.Create( \"PSW1.tif\", shape[1], shape[0], 1, gdal.GDT_UInt16)\n #PSW1_out.SetGeoTransform( geo )\n #PSW1_out.SetProjection( proj ) \n #PSW1_out.GetRasterBand(1).WriteArray(PSW1)\n #PSW1_out=None\n \n #Perform PSW2 test- working\n con_PSW2_MNDWI=((GreenB - SWIR1B) /np.float32(GreenB + SWIR1B))\n con_PSW2_MNDWI[con_PSW2_MNDWI > PSW2_MNDWI] = 1\n con_PSW2_MNDWI[con_PSW2_MNDWI <= PSW2_MNDWI] = 0\n con_PSW2_MNDWI=np.int8(con_PSW2_MNDWI)\n BlueB[BlueB < PSW2_BLUE] = 1\n BlueB[BlueB >= PSW2_BLUE] = 0\n BlueB=np.int8(BlueB) \n NIRB[NIRB < PSW2_NIR] = 1\n NIRB[NIRB >= PSW2_NIR] = 0\n NIRB=np.int8(NIRB)\n SWIR1B[SWIR1B < PSW2_SWIR1] = 1\n SWIR1B[SWIR1B >= PSW2_SWIR1] = 0\n SWIR1B=np.int8(SWIR1B) \n SWIR2B[SWIR2B < PSW2_SWIR2] = 1\n SWIR2B[SWIR2B >= PSW2_SWIR2] = 0\n SWIR2B=np.int8(SWIR2B)\n PSW2= con_PSW2_MNDWI * BlueB * NIRB * SWIR1B * SWIR2B * 10000\n #Optional to output PSW2 test\n #PSW2_out = driver.Create( \"PSW2.tif\", shape[1], shape[0], 1, gdal.GDT_UInt16)\n #PSW2_out.SetGeoTransform( geo )\n #PSW2_out.SetProjection( proj ) \n #PSW2_out.GetRasterBand(1).WriteArray(PSW2)\n #PSW2_out=None\n del GreenB, SWIR1B, MNDWI, RedB, NIRB, MBSRN, SWIR2B, BlueB, con_PSW1_MNDWI, con_NDVI, con_PSW2_MNDWI\n diagmap= con_MNDWI + con_MBSR + con_AWEsh + PSW1 + PSW2\n del con_MNDWI, con_MBSR, con_AWEsh, PSW1, PSW2\n \n os.chdir(input_dir)\n\n \n # Terrain Correction, here we are simply recoding slopes >=x degrees to PS (specified above), which will be reclassified as non-water.\n\n perslp = gdal.Open(Perslp)\n #Get extent and projection\n perslpgeo = perslp.GetGeoTransform()\n perslpproj = perslp.GetProjection()\n # Calculate percent slope\n #perslp= perslp.GetRasterBand(1).ReadAsArray()\n os.chdir(working_dir)\n CF = gdal.Open(CF)\n #Get extent of CF mask (and our LS image by proxy)\n geoTransform = CF.GetGeoTransform()\n minx = geoTransform[0]\n maxy = geoTransform[3]\n maxx = minx + geoTransform[1] * CF.RasterXSize\n miny = maxy + geoTransform[5] * CF.RasterYSize\n #Clip our slope and hillshade mask to the image (have to do this for each image due to the variable extents of each image)\n GeoClip= [minx, maxy, maxx, miny]\n print GeoClip\n hillshade= gdal.Open(Hillshade)\n perslp_clip=gdal.Translate('perslp_clip.tif', perslp, projWin = GeoClip)\n hillshade_clip=gdal.Translate('hillshade_clip.tif', hillshade, projWin = GeoClip)\n hillshade= hillshade_clip.GetRasterBand(1).ReadAsArray()\n hillshade[hillshade <= HS] = 0\n hillshade[hillshade > HS] = 1\n \n #Read in the slope and hillshade masks and convert to an array\n workingoutput_dir=output_dir2 + \"\\\\\" + directory\n if not os.path.exists(workingoutput_dir):\n os.makedirs(workingoutput_dir)\n \n #calculate our unmasked diagnostic map\n CF= CF.GetRasterBand(1).ReadAsArray()\n diagoutput=output_dir2 + \"\\\\\" + directory + \"\\\\\" + out_name + \"_diag\" + \"_%s.tif\"%\"_\".join(raster.split('_'))[0:length]\n diagmap[np.where((CF == 255))] = -9999\n diagmap_out = driver.Create( diagoutput, shape[1], shape[0], 1, gdal.GDT_Int16)\n diagmap_out.SetGeoTransform( geo )\n diagmap_out.SetProjection( proj )\n diagmap_out.GetRasterBand(1).WriteArray(diagmap)\n diagmap_out.GetRasterBand(1).SetNoDataValue(-9999)\n \n \n # Output unmasked interpreted map\n interpoutput=output_dir2 + \"\\\\\" + directory + \"\\\\\" + out_name + \"_interp\" + \"_%s.tif\"%\"_\".join(raster.split('_'))[0:length]\n interpmap=diagmap.copy()\n interpmap[np.where((diagmap == 0) | (diagmap == 1) | (diagmap == 10) | (diagmap == 100) | (diagmap == 1000))] = 0\n interpmap[np.where((diagmap == 1111) | (diagmap == 10111) | (diagmap == 11011) | (diagmap == 11101) | (diagmap == 11110) | (diagmap == 11111)) ] = 1\n interpmap[np.where((diagmap == 111) | (diagmap == 1011) | (diagmap == 1101) | (diagmap == 1110) | (diagmap == 10011) | (diagmap == 10101) | (diagmap == 10110) | (diagmap == 11001) | (diagmap == 11010) | (diagmap == 11100)) ] = 2\n interpmap[np.where((diagmap == 11000)) ] = 3\n interpmap[np.where((diagmap == 11) | (diagmap == 101) | (diagmap == 110) | (diagmap == 1001) | (diagmap == 1010) | (diagmap == 1100) | (diagmap == 10000) | (diagmap == 10001) | (diagmap == 10010) | (diagmap == 10100)) ] = 4\n interpmap[np.where((diagmap == -9999)) ] = 255\n interpmap_out = driver.Create( interpoutput, shape[1], shape[0], 1, gdal.GDT_Byte)\n interpmap_out.SetGeoTransform( geo )\n interpmap_out.SetProjection( proj )\n interpmap_out.GetRasterBand(1).WriteArray(interpmap)\n interpmap_out.GetRasterBand(1).SetNoDataValue(255)\n\n\n # Mask interpreted map using the slope file\n perslp= perslp_clip.GetRasterBand(1).ReadAsArray()\n interpmap_copy=interpmap.copy()\n interpmap[np.where((perslp >= 30) & (interpmap == 2))] = 0\n interpmap[np.where((perslp >= 20) & (interpmap == 3))] = 0\n interpmap[np.where((perslp >= 10) & (interpmap == 4))] = 0\n interpmap[np.where((perslp >= 30) & (interpmap == 1))] = 0\n interpmap_masked= interpmap * hillshade \n\n \n \n #Cloud and snow masking and outputing masked interpreted layer\n interpmaskoutput=output_dir2 + \"\\\\\" + directory + \"\\\\\" + out_name + \"_interp_masked\" + \"_%s.tif\"%\"_\".join(raster.split('_'))[0:length]\n interpmap_masked=interpmap_masked.copy()\n interpmap_masked[np.where((CF == 255))] = 255\n interpmap_masked[np.where((CF >= 2) & (CF < 255))] = 9\n interpmap_masked_out = driver.Create( interpmaskoutput, shape[1], shape[0], 1, gdal.GDT_Byte)\n interpmap_masked_out.SetGeoTransform( geo )\n interpmap_masked_out.SetProjection( proj )\n interpmap_masked_out.GetRasterBand(1).WriteArray(interpmap_masked)\n interpmap_masked_out.GetRasterBand(1).SetNoDataValue(255)\n del interpmap_masked_out\n del diagmap\n del interpmap\n\n\n\n #Create a full mask layer\n CF[np.where((CF == 1)) ] = 0\n perslp[np.where((perslp < 10) & (interpmap_copy == 4)) ] = 0\n perslp[np.where((perslp < 20) & (interpmap_copy == 3)) ] = 0\n perslp[np.where((perslp < 30) & (interpmap_copy == 2)) ] = 0\n perslp[np.where((perslp < 30) & (interpmap_copy == 1)) ] = 0\n perslp[np.where((perslp >= 10) & (interpmap_copy == 4)) ] = 10\n perslp[np.where((perslp >= 20) & (interpmap_copy == 3)) ] = 10\n perslp[np.where((perslp >= 30) & (interpmap_copy == 2)) ] = 10\n perslp[np.where((perslp >= 30) & (interpmap_copy == 1)) ] = 10\n perslp[np.where((interpmap_copy == 0)) ] = 0 \n hillshade[np.where((hillshade == 0)) ] = 20\n hillshade[np.where((hillshade == 1)) ] = 0\n MaskLayer=CF + perslp + hillshade\n MaskLayerOut=output_dir2 + \"\\\\\" + directory + \"\\\\\" + out_name + \"_MaskLayer\" + \"_%s.tif\"%\"_\".join(raster.split('_'))[0:length]\n MaskLayer[np.where((CF == 255))] = 255\n MaskLayer_Output = driver.Create(MaskLayerOut, shape[1], shape[0], 1, gdal.GDT_Byte)\n MaskLayer_Output.SetGeoTransform( geo )\n MaskLayer_Output.SetProjection( proj )\n MaskLayer_Output.GetRasterBand(1).WriteArray(MaskLayer)\n MaskLayer_Output.GetRasterBand(1).SetNoDataValue(255)\n del hillshade_clip, hillshade, MaskLayer, CF, MaskLayerOut, MaskLayer_Output, diagoutput\n del Metadata, diagmap_out, interpmap_masked, interpmap_out, interpmaskoutput, interpoutput, perslp, perslp_clip \n \n itemlist=[\"hillshade*.tif\", \"perslp*.tif\"]\n for item in itemlist:\n i=glob.glob(item)\n for r in i:\n os.remove(r)\n\n #Timer\n print datetime.datetime.now()\n T2=datetime.datetime.now()\n T3=T2-T1\n print T3\n \n if count == subdirnumber:\n break \n else:\n count=count+1\n print count\n\n \n \n\n \n\n \n\n\n", "meta": {"hexsha": "47546ad5336c58f2a0f80fbe7827137a506a9432", "size": 22019, "ext": "py", "lang": "Python", "max_stars_repo_path": "dswe/prototype_implementation/DSWE_P1_V2_ESPA_06_05_2017.py", "max_stars_repo_name": "jakebrinkmann/lagoon-water-dragon", "max_stars_repo_head_hexsha": "351db2afc99859e1c87398fdbdcb270a3a16cb83", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "dswe/prototype_implementation/DSWE_P1_V2_ESPA_06_05_2017.py", "max_issues_repo_name": "jakebrinkmann/lagoon-water-dragon", "max_issues_repo_head_hexsha": "351db2afc99859e1c87398fdbdcb270a3a16cb83", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "dswe/prototype_implementation/DSWE_P1_V2_ESPA_06_05_2017.py", "max_forks_repo_name": "jakebrinkmann/lagoon-water-dragon", "max_forks_repo_head_hexsha": "351db2afc99859e1c87398fdbdcb270a3a16cb83", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 46.7494692144, "max_line_length": 240, "alphanum_fraction": 0.5835869022, "include": true, "reason": "import numpy", "num_tokens": 6258, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5234203489363239, "lm_q2_score": 0.3702253925955866, "lm_q1q2_score": 0.19378350417746948}} {"text": "\"\"\"Tensorflow implementation of adversarial autoencoders.\n\nOriginally based on [1] with significant changers.\n\n\n\nDemo (command line)\n===================\n\nconda activate tf114\npython -m dltb.thirdparty.tensorflow.aae\n\n\n\nDemo (interactive)\n==================\n\n# import tensorflow as tf\nimport tensorflow.compat.v1 as tf\nfrom ulf import SupervisedAdversarialAutoencoder\naae = SupervisedAdversarialAutoencoder(code_dim=2)\naae.prepare()\n\nsaver = tf.train.Saver(name='aae', filename=\"my_test_model\")\nsess = tf.InteractiveSession()\naae.set_tensorflow_session(sess)\nstart_epoch = aae._tf_initialize_variables(sess, saver)\n\naae.plot_data_codes_2d(test_xs, labels=test_ys)\n\naae.plot_recoded_images(test_xs[:100], labels=test_ys[:100])\n\naae.plot_decoded_codespace_2d(labels=3)\n\naae.plot_analogical_decoding()\n\nsess.close()\n\n\nData\n====\n# data are numpy.ndarray.\n# xs: image pixel data\n# dtype=float64, min/max=0.0/1.0,\n# shape=(batch, height, width, channels)\n# ys: one-hot encoded class labels\n# dtype=float64, min/max=0.0/1.0\n# shape=(batch, classes)\n\n sellf._data_semi_pipeline = data_pipeline(self._conf.data)\n self._valid_xs = self._valid_xs[:self._conf.num_samples]\n self._valid_ys = self._valid_ys[:self._conf.num_samples]\n\n\nReferences\n==========\n[1] https://github.com/MINGUKKANG/Adversarial-AutoEncoder.git\n\"\"\"\n\n# pylint: disable=too-many-lines\n# pylint: disable=fixme\n# pylint: disable=unexpected-keyword-arg,no-value-for-parameter\n\n\n# standard imports\nfrom typing import Tuple, Optional, Sized, Union\nimport time\nimport datetime\n\n# third-party imports\nimport numpy as np\nfrom tqdm import tqdm\n\n# toolbox imports\nfrom dltb.datasource import Datasource\nfrom dltb.base.data import add_noise\nfrom dltb.util.plot import TilingPlotter\nfrom dltb.util.distributions import gaussian, gaussian_mixture, swiss_roll\nfrom . import v1 as tf\nfrom .v1 import Utils as tf_helper\nfrom .ae import Autoencoder\n\n\nclass AdversarialAutoencoder(Autoencoder):\n \"\"\"Base class for the TensorFlow Adversarial Autoencoder (AAE)\n implementation. The AAE extends the basic Autoencoder (AE) by\n introducing an additional training objective to force the encoder\n to produces code that is distributed according to a given target\n distribution (\"prior\").\n\n The method :py:class:`_sample_prior` allows to samples codes\n from the target distribution. There are three different target\n distributions implemented by this class: `'gaussian'`,\n `'gaussian_mixture'`, and `'swiss_roll'`.\n\n Training\n --------\n Training the AAE consists of two parts: on the one hand, the full\n autoencoder stack (encoder + decoder) is trained to minimize the\n reconstruction error. On the other hand, the encoder part is\n trained to fit the code distribution to a given target distribution\n (\"prior\"). This training employs an adversarial training procedure\n in which the encoder acts as generator that tries to mimic the\n target distribution.\n\n The autoencoder training aims to minimize the reconstruction loss,\n which is accessible via the property `_tf_loss_reconstruction`. It is\n interpreted as the \"negative log likelihood\". Computing this loss\n only requires the input data values.\n\n The adversarial training process consist of two parts: on the one\n hand it aims to improve the discriminator in its ability to\n discriminate codes output by the encode from codes sampled from\n the target distribution. On the other hand it wants the encoder to\n improve to create codes that follow the target distribution.\n\n Arguments\n ---------\n data:\n The dataset to use (either 'MNIST' or '')\n\n \"\"\"\n\n def __init__(self, data: str = 'MNIST',\n prior: str = 'gaussian', **kwargs) -> None:\n super().__init__(**kwargs)\n self._conf.data = data\n self._conf.prior = prior\n\n # tensorflow placeholders\n self._tf_prior = None\n\n # The model\n self._tf_loss_discriminator = None\n self._tf_loss_generator = None\n\n # Optimizers\n self._tf_optimize_discriminator = None\n self._tf_optimize_generator = None\n\n # loss values (per batch)\n self._loss_discriminator_value = None\n self._loss_generator_value = None\n\n def _prepare_tensors(self) -> None:\n \"\"\"\n \"\"\"\n if self._tf_prior is None:\n self._tf_prior = \\\n tf.placeholder(tf.float32, shape=[None, self.code_dim],\n name=\"z_prior\")\n\n super()._prepare_tensors()\n\n @staticmethod\n def _sample_prior(prior: str, zdim: int, nclasses: int, batch_size: int,\n use_label_info: bool) -> Tuple[np.ndarray, np.ndarray]:\n \"\"\"\n Results\n -------\n prior_style:\n prior_label_onehot:\n A 2-dimensional numpy.ndarray of type float holding `prior_label`\n in one-hot-encoding. The shape is (batch_size, nclasses).\n \"\"\"\n if prior == 'gaussian':\n prior_style, prior_label = \\\n gaussian(batch_size, labels=nclasses)\n\n elif prior == 'gaussian_mixture':\n prior_style, prior_label = \\\n gaussian_mixture(batch_size, components=nclasses, labels=True)\n\n elif prior == 'swiss_roll':\n prior_style, prior_label = \\\n swiss_roll(batch_size, labels=nclasses)\n\n else:\n raise ValueError(f\"Unknow prior: '{prior}'. Known values are: \"\n \"gaussian, gaussian_mixture, swiss_roll\")\n\n prior_label_onehot = np.eye(nclasses, dtype=np.float32)[prior_label]\n return prior_style, prior_label_onehot\n\n def _tf_define_optimizers(self, variables) -> None:\n \"\"\"Prepare the training process. Define optimizers.\n \"\"\"\n super()._tf_define_optimizers(variables)\n\n var_generator = [var for var in variables\n if \"encoder\" in var.name]\n var_discriminator = [var for var in variables\n if \"discriminator\" in var.name]\n\n self._tf_optimize_discriminator = \\\n tf.train.AdamOptimizer(learning_rate=self._tf_learning_rate/5).\\\n minimize(self._tf_loss_discriminator,\n global_step=self._tf_global_step,\n var_list=var_discriminator)\n self._tf_optimize_generator = \\\n tf.train.AdamOptimizer(learning_rate=self._tf_learning_rate).\\\n minimize(self._tf_loss_generator,\n global_step=self._tf_global_step,\n var_list=var_generator)\n\n def _tf_train_step(self, sess, feed_dict) -> None:\n \"\"\"Perform one training step.\n \"\"\"\n super()._tf_train_step(sess, feed_dict)\n # Optmize the reconstruction loss. This requires\n # 'inputs' and 'outputs' to be given in the 'feed_dict'\n # _negative_log_likelihood_value, _, _g = \\\n self._loss_reconstruction_value, _, _g = \\\n sess.run([self._tf_loss_reconstruction,\n self._tf_optimize_reconstruction,\n self._tf_global_step],\n feed_dict=feed_dict)\n\n # Discriminator phase\n self._loss_discriminator_value, _ = \\\n sess.run([self._tf_loss_discriminator,\n self._tf_optimize_discriminator],\n feed_dict=feed_dict)\n\n # Generator phase\n self._loss_generator_value, _ = \\\n sess.run([self._tf_loss_generator,\n self._tf_optimize_generator],\n feed_dict=feed_dict)\n\n\nclass LabeledAutoencoder(Autoencoder):\n \"\"\"A labeled autoencoder splits the code interpretation into two\n parts: one part representing the class label (as one-hot encoded\n vector) while the other part should hold other information\n (sometimes referred to as \"style\").\n\n A labeled autoencoder provides methods to compute and access the\n two code parts (style and label) independently.\n\n In a `LabeledAutoencoder`, the property :py:prop:`code_dim` refers\n to the dimensionality of the style part of the code, while the\n property :py:prop:`nclasses` contains the number of classes.\n That is, the combined code vector (style + label) has dimensionality\n `code_dim + nclasses`.\n \"\"\"\n\n def __init__(self, nclasses: Optional[int] = None, **kwargs) -> None:\n super().__init__(**kwargs)\n\n # properties\n self._nclasses = nclasses\n\n # tensorflow placeholders\n self._tf_labels = None\n\n @property\n def nclasses(self) -> int:\n \"\"\"The number of classes, that is the number of different labels,\n in this :py:class:`LabeledAutoencoder`.\n \"\"\"\n return self._nclasses\n\n def _prepare_tensors(self) -> None:\n \"\"\"\n \"\"\"\n self._tf_labels = \\\n tf.placeholder(dtype=tf.float32, shape=[None, self.nclasses],\n name=\"Input_labels\")\n\n super()._prepare_tensors()\n\n def one_hot(self, labels: np.ndarray,\n length: Optional[int] = None) -> np.ndarray:\n \"\"\"Get the given labels in one-hot encoding.\n \"\"\"\n if isinstance(labels, Sized):\n if length is not None and len(labels) != length:\n raise ValueError(f\"Labels have length {len(labels)} but \"\n f\"should have lenght {length}.\")\n if isinstance(labels, np.ndarray):\n if labels.ndim == 2:\n return labels\n if labels.ndim == 1:\n return np.eye(self.nclasses, dtype=np.float32)[labels]\n elif isinstance(labels, list):\n return np.eye(self.nclasses, dtype=np.float32)[labels]\n elif isinstance(labels, int):\n if length is None:\n raise ValueError(\"You need to specify a length for \"\n \"the one-hot vector\")\n return np.eye(self.nclasses, dtype=np.float32)[[labels] * length]\n raise TypeError(\"Unexpected type {type(labels)} for labels.\")\n\n\nclass LabeledAdversarialAutoencoder(LabeledAutoencoder,\n AdversarialAutoencoder):\n \"\"\"A labeled adversarial autoencoder combines the ideas of the labeled\n autoencoder and the adversarial autoencoder. It aims at forcing\n both, the distribution of the style part of code and the\n distribution of the label part of the code towards two given\n priors using adversarial training techniques.\n \"\"\"\n\n def __init__(self, **kwargs) -> None:\n super().__init__(**kwargs)\n\n # tensorflow placeholders\n self._tf_prior_style = None\n self._tf_prior_label = None\n\n def _prepare_tensors(self) -> None:\n \"\"\"\n \"\"\"\n self._tf_prior_style = \\\n tf.placeholder(tf.float32, shape=[None, self.code_dim],\n name=\"z_prior\")\n self._tf_prior_label = \\\n tf.placeholder(tf.float32, shape=[None, self.nclasses],\n name=\"prior_labels\")\n\n self._tf_prior = \\\n tf.concat([self._tf_prior_style, self._tf_prior_label], axis=1)\n\n super()._prepare_tensors()\n\n def plot_analogical_decoding(self, style: Union[np.ndarray, int] = 10,\n plotter: Optional[TilingPlotter] = None,\n **kwargs) -> None:\n \"\"\"Plot the analogical reasoning results. For a given style,\n generate analogical exemplas for each of the classes.\n\n Arguments\n ---------\n style:\n The styles to be used for generation. If an `int`\n this will specify the number of random styles to\n to be choosen.\n \"\"\"\n # generate random code style samples (styles)\n if isinstance(style, int): # number of examples\n style = np.random.rand(style, self.code_dim)\n examples = len(style)\n style = np.repeat(style, self.nclasses, axis=0)\n\n labels = np.arange(self.nclasses)\n labels = np.tile(labels, examples)\n one_hot = self.one_hot(labels)\n\n codes = np.concatenate((style, one_hot), axis=1)\n\n # use decoder to generate output data from the combined code.\n data = self.decode(codes)\n\n # plot the results\n if plotter is None:\n plotter = TilingPlotter()\n plotter.plot_tiling(data, rows=examples, columns=self.nclasses,\n **kwargs)\n\n\nclass SupervisedAdversarialAutoencoder(LabeledAdversarialAutoencoder):\n \"\"\"Specialized sublasse for a supervised Adversarial Autoencoder (AAE)\n implementation.\n\n Notice that the :py:class:`SupervisedAdversarialAutoencoder` is\n not really an autoencoder, as the code does not contain sufficient\n information to reconstruct the input. Instead the decoder needs\n additional label information.\n\n The encoder encodes a given input just in the \"style\" part. This\n style code has to be combined with the label information to obtain\n the full code.\n\n The encoder uses `tf_inputs` to compute the style code which is\n provided in `tf_encoded_style`. This can be combined with\n information from `tf_labels` to obtain the full code vector in\n `tf_encoded`. The decoder uses `tf_encoded` to reconstruct the\n data and provides it in `tf_decoded`.\n\n This specific behavior results in a slight redesign of the\n autoencoder interface: the methods :py:meth:`encode`,\n :py:meth:`decode`, and :py:meth:`recode` accept an additional\n argument `labels` that allows to provide the required class\n labels.\n\n \"\"\"\n\n def __init__(self, **kwargs) -> None:\n super().__init__(**kwargs)\n self._conf.model = 'supervised'\n\n self._tf_encoded_style = None\n\n def encode(self, data: np.ndarray, batch_size: int = 128,\n labels: Optional[np.ndarray] = None) -> np.ndarray:\n \"\"\"Encode data using the encoder part of the autoencoder.\n\n Arguments\n ---------\n data:\n The data to be encoded.\n\n Result\n ------\n code:\n The codes obtained from the data. If no label information\n is available, this will only be the style part of the code.\n \"\"\"\n length = len(data)\n code = np.ndarray((length, self.code_dim))\n\n offset = 0\n batches = self._np_batcher(data, batch_size=batch_size)\n code_batches = \\\n self._tf_encode_batches(batches, tf_encoded=self._tf_encoded_style)\n for batch in code_batches:\n end = offset + len(batch)\n code[offset: end] = batch\n offset = end\n\n if labels is None:\n return code\n\n labels_one_hot = self.one_hot(labels, length=length)\n return np.concatenate((code, labels_one_hot), axis=1)\n\n def decode(self, code: np.ndarray, batch_size: int = 128,\n labels: Optional[np.ndarray] = None) -> np.ndarray:\n \"\"\"Decode given code values into the data space using the decoder\n part of the autoencoder.\n\n Arguments\n ---------\n code:\n The codes to be decoded.\n\n Result\n ------\n data:\n The reconstructed data.\n \"\"\"\n if code.shape[1] == self.code_dim:\n if labels is None:\n raise ValueError(\"The supervised autoencoder needs explicit \"\n \"label information for decoding.\")\n labels_one_hot = self.one_hot(labels, length=len(code))\n code = np.concatenate((code, labels_one_hot), axis=1)\n return super().decode(code, batch_size=batch_size)\n\n def recode(self, data: np.ndarray, batch_size: int = 128,\n labels: Optional[np.ndarray] = None) -> np.ndarray:\n \"\"\"Reconstruct data values using the autoencoder, that is first\n encode the data and the decode it back into the data space.\n\n Arguments\n ---------\n data:\n The data to be recoded.\n\n Result\n ------\n recoded:\n The reconstructed data.\n \"\"\"\n # FIXME[hack]: just encode + decode. A full tensorflow\n # recoding would probably be more efficient\n code = self.encode(data, batch_size=batch_size, labels=labels)\n return self.decode(code, batch_size=batch_size)\n\n def _prepare_tensors(self) -> None:\n \"\"\"Setup TensorFlow properties for the supervised adversarial\n autoencoder.\n\n Prepare the tensorflow network (computational graph) realizing\n the supervised adversarial autoencoder.\n\n The constructed graph looks as follows:\n\n [inputs] [labels]\n | |\n inputs_flat |\n | |\n (encoder) | |\n V |\n *encoded_style* | [prior_style] [prior_label]\n | | | |\n +------------------+ +------+-----+\n | |\n V V\n *encoded* prior\n | |\n +----------------+ |\n (decoder) | | |\n | V V\n V D_fake_logits D_real_logits\n *decoded* | | |\n | V V V\n +-----+ G_loss D_loss_fake D_loss_true\n | | | |\n [outputs] | V +-------+------+\n | | *loss_generator* V\n outputs_flat | *loss_discriminator*\n V V\n *loss_reconstruction*\n\n [...]: input values (tf.placeholder)\n inputs\n outputs\n code\n prior_style\n prior_label\n *...*: output values (tf.tensor)\n encoded: encoder output (just style, no label)\n decoded: decoder output (flat data)\n\n Tensorflow properties are prefixed with '_tf_'.\n \"\"\"\n # Super class sets up a standard autoencoder from placeholders\n # 'inputs', 'outputs', providing 'encoded', 'decoded' and\n # 'loss_reconstruction'.\n super()._prepare_tensors()\n\n #\n # The discriminators\n #\n prior = \\\n tf.concat([self._tf_prior_style, self._tf_prior_label], axis=1)\n discriminator_real_logits = \\\n self._tf_discriminator(prior, self._tf_keep_prob)\n discriminator_fake_logits = \\\n self._tf_discriminator(self._tf_encoded, self._tf_keep_prob)\n\n discriminator_fake_labels = tf.zeros_like(discriminator_fake_logits)\n discriminator_loss_fake = tf.nn.\\\n sigmoid_cross_entropy_with_logits(logits=discriminator_fake_logits,\n labels=discriminator_fake_labels)\n discriminator_real_labels = tf.ones_like(discriminator_real_logits)\n discriminator_loss_true = tf.nn.\\\n sigmoid_cross_entropy_with_logits(logits=discriminator_real_logits,\n labels=discriminator_real_labels)\n\n generator_fake_labels = tf.ones_like(discriminator_fake_logits)\n generator_loss = tf.nn.\\\n sigmoid_cross_entropy_with_logits(logits=discriminator_fake_logits,\n labels=generator_fake_labels)\n\n self._tf_loss_discriminator = \\\n tf.reduce_mean(discriminator_loss_fake) + \\\n tf.reduce_mean(discriminator_loss_true)\n self._tf_loss_generator = tf.reduce_mean(generator_loss)\n\n def _tf_encoder(self, data, keep_prob):\n \"\"\"Encoder for an autoencoder.\n \"\"\"\n self._tf_encoded_style = super()._tf_encoder(data, keep_prob)\n return tf.concat([self._tf_encoded_style, self._tf_labels], axis=1)\n\n def train(self,\n labeled_train_data: Datasource,\n labeled_display_data: Datasource,\n sess: tf.Session, saver) -> None:\n \"\"\"Train the network.\n \"\"\"\n # display_data: (images, images_noised, labels)\n # A batch of data used for plotting intermediate results\n # during training (taken from the validation dataset)\n # Each is a numpy array of length 100 and appropriate shape.\n display_data = labeled_display_data[:100, ('array', 'array', 'label')]\n\n #\n # prepare the optimizers\n #\n\n # obtain the variables used in the model\n total_vars = tf.trainable_variables()\n # var_ae = [var for var in total_vars\n # if \"encoder\" in var.name or \"decoder\" in var.name]\n\n # Optimizers\n self._tf_define_optimizers(total_vars)\n\n #\n # Start the training\n #\n start_epoch = self._tf_initialize_variables(sess, saver)\n start_time = time.time()\n\n total_batch = len(labeled_train_data) // self._conf.batch_size\n labeled_batch_iterator = \\\n labeled_train_data(batch_size=self._conf.batch_size, loop=True,\n attributes=('array', 'noisy', 'label'))\n\n for epoch in tqdm(range(start_epoch, self._conf.n_epoch),\n initial=start_epoch, total=self._conf.n_epoch):\n likelihood = 0\n discriminator_value = 0\n generator_value = 0\n\n # Adapt the learning rate depending on the epoch\n lr_value = self._learning_rate_schedule(epoch)\n\n for _batch_idx in tqdm(range(total_batch)):\n batch_xs, batch_noised_xs, batch_ys = \\\n next(labeled_batch_iterator)\n\n # Sample from the prior distribution\n prior_style, prior_label_onehot = \\\n self._sample_prior(self._conf.prior, zdim=self.code_dim,\n nclasses=self.nclasses,\n batch_size=self._conf.batch_size,\n use_label_info=True)\n\n feed_dict = {\n self._tf_inputs: batch_noised_xs,\n self._tf_outputs: batch_xs,\n self._tf_labels: batch_ys,\n self._tf_prior_style: prior_style,\n self._tf_prior_label: prior_label_onehot,\n self._tf_learning_rate: lr_value,\n self._tf_keep_prob: self._conf.keep_prob\n }\n\n # AutoEncoder phase\n self._tf_train_step(sess, feed_dict)\n\n # Summary\n likelihood += \\\n self._loss_reconstruction_value/total_batch\n discriminator_value += \\\n self._loss_discriminator_value/total_batch\n generator_value += \\\n self._loss_generator_value/total_batch\n\n # every 5th epoch (except the last) plot the manifold canvas\n if epoch % 5 == 0 or epoch == (self._conf.n_epoch - 1):\n name = f\"Manifold_canvas_{epoch}\"\n self.plot_recoded_images(display_data[1],\n targets=display_data[0],\n labels=display_data[2],\n filename=name)\n\n # output end of epoch information\n runtime = time.time() - start_time\n print(f\"Epoch: {epoch:3d}, \"\n f\"global step: {sess.run(self._tf_global_step)}, \"\n f\"Time: {datetime.timedelta(seconds=runtime)}\")\n print(f\" lr_AE: {lr_value:.5f}\"\n f\" loss_AE: {likelihood:.4f} \")\n print(f\" lr_D: {lr_value/5:.5f}\"\n f\" loss_D: {discriminator_value:.4f}\")\n print(f\" lr_G: {lr_value:.5f}\"\n f\" loss_G: {generator_value:.4f}\\n\")\n\n if saver is not None:\n saver.save(sess, 'checkpoints/my_test_model',\n global_step=self._tf_global_step,\n write_meta_graph=False)\n print(f\"Saver: {saver.last_checkpoints}\")\n\n\nclass SemisupervisedAdversarialAutoencoder(LabeledAdversarialAutoencoder):\n \"\"\"Specialized sublasse for a semi-supervised\n Adversarial Autoencoder (AAE) implementation.\n\n The main differences to the fully supervised AAE are\n the following:\n * the encoder (generator) also outputs class labels. That is the latent\n representation is split into two parts: the continuous z and the one-hot\n encoded label information y.\n * there now are two discriminators, one for each part of the latent\n representation, and two loss functions training them:\n `_loss_discriminator_style` and `_loss_discriminator_label`.\n Training the z part requires z value output from the encoder/generator\n ()\n as well as real z values sampled from the target distribution.\n Training the y part requires the label output from the encoder/generator\n\n * the produced class labels can be used as additional training objective\n to train the encoder (generator) to minimize crossentropy loss, if\n ground truth label are available (supervised case). This loss function\n is stored under the name `_crossentropy_labels`. The training process\n requires input data with real class labels.\n \"\"\"\n\n def __init__(self, **kwargs) -> None:\n super().__init__(**kwargs)\n self._conf.model = 'semi_supervised'\n\n #\n # data related properties\n #\n\n # model related properties\n self._style = None\n self._crossentropy_labels = None\n\n # loss functions\n self._tf_loss_discriminator_label = None\n self._tf_loss_discriminator_style = None\n\n # optimizers\n self._op_z_discriminator = None\n self._op_y_discriminator = None\n self._op_generator = None\n self._op_crossentropy_labels = None\n\n self._l_z_discriminator = None\n self._l_y_discriminator = None\n self._l_generator = None\n self._crossentropy = None\n\n def _prepare_tensors(self) -> None:\n \"\"\"Setup TensorFlow properties for the supervised adversarial\n autoencoder.\n\n \"\"\"\n super()._prepare_tensors()\n\n # placeholders\n # FIXME[semi]: self._z_cat\n # Y_cat = tf.placeholder(dtype=tf.float32,\n # shape=[None, n_cls], name=\"labels_cat\")\n # labels_cat = self._tf_prior_label\n\n # FIXME[coding]: code duplication\n flat_data_length = \\\n self._data_shape[0] * self._data_shape[1] * self._data_shape[2]\n inputs_flat = tf.reshape(self._tf_inputs, [-1, flat_data_length])\n outputs_flat = tf.reshape(self._tf_outputs, [-1, flat_data_length])\n\n # the encoder\n self._style, labels_softmax = \\\n self._tf_semi_encoder(inputs_flat, self._tf_keep_prob,\n semi_supervised=False)\n _, labels_generated = \\\n self._tf_semi_encoder(inputs_flat, self._tf_keep_prob,\n semi_supervised=True)\n latent_inputs = tf.concat([self._style, labels_softmax], axis=1)\n\n # the decoder\n self._tf_decoded = \\\n self._tf_semi_decoder(latent_inputs, self._tf_keep_prob)\n\n #\n # the discriminators\n #\n\n discriminator_label_fake = \\\n self._tf_semi_y_discriminator(labels_softmax,\n self._tf_keep_prob)\n discriminator_label_real = \\\n self._tf_semi_y_discriminator(self._tf_prior_label,\n self._tf_keep_prob)\n\n discriminator_style_fake = \\\n self._tf_semi_z_discriminator(self._style,\n self._tf_keep_prob)\n discriminator_style_real = \\\n self._tf_semi_z_discriminator(self._tf_prior_style,\n self._tf_keep_prob)\n\n #\n # loss functions\n #\n self._tf_loss_reconstruction = \\\n tf.reduce_mean(tf.squared_difference(self._tf_decoded,\n outputs_flat))\n\n discriminator_label_zeros = tf.zeros_like(discriminator_label_fake)\n discriminator_label_ones = tf.ones_like(discriminator_label_real)\n discriminator_loss_label_real = tf.nn.\\\n sigmoid_cross_entropy_with_logits(logits=discriminator_label_real,\n labels=discriminator_label_ones)\n discriminator_loss_label_fake = tf.nn.\\\n sigmoid_cross_entropy_with_logits(logits=discriminator_label_fake,\n labels=discriminator_label_zeros)\n self._tf_loss_discriminator_label = \\\n tf.reduce_mean(discriminator_loss_label_real) + \\\n tf.reduce_mean(discriminator_loss_label_fake)\n\n discriminator_style_zeros = tf.zeros_like(discriminator_style_fake)\n discriminator_style_ones = tf.ones_like(discriminator_style_real)\n discriminator_loss_style_real = tf.nn.\\\n sigmoid_cross_entropy_with_logits(logits=discriminator_style_real,\n labels=discriminator_style_ones)\n discriminator_loss_style_fake = tf.nn.\\\n sigmoid_cross_entropy_with_logits(logits=discriminator_style_fake,\n labels=discriminator_style_zeros)\n self._tf_loss_discriminator_style = \\\n tf.reduce_mean(discriminator_loss_style_real) + \\\n tf.reduce_mean(discriminator_loss_style_fake)\n\n loss_generator_label = tf.nn.\\\n sigmoid_cross_entropy_with_logits(logits=discriminator_label_fake,\n labels=discriminator_label_ones)\n loss_generator_style = tf.nn.\\\n sigmoid_cross_entropy_with_logits(logits=discriminator_style_fake,\n labels=discriminator_style_ones)\n self._tf_loss_generator = \\\n tf.reduce_mean(loss_generator_style) + \\\n tf.reduce_mean(loss_generator_label)\n\n crossentropy_labels = tf.nn.\\\n softmax_cross_entropy_with_logits(logits=labels_generated,\n labels=self._tf_labels)\n self._crossentropy_labels = tf.reduce_mean(crossentropy_labels)\n\n def _tf_semi_encoder(self, data, keep_prob, semi_supervised=False):\n \"\"\"Encoder for semi-supervised AAE.\n\n Arguments\n ---------\n \"\"\"\n with tf.variable_scope(\"semi_encoder\", reuse=tf.AUTO_REUSE):\n net = tf_helper.dense_layer(data, self._conf.semi_n_hidden,\n name=\"dense_1\", keep_prob=keep_prob)\n net = tf_helper.dense_layer(net, self._conf.semi_n_hidden,\n name=\"dense_2\", keep_prob=keep_prob)\n style = tf_helper.dense(net, self.code_dim, name=\"style\")\n\n if semi_supervised is False:\n labels_generated = \\\n tf.nn.softmax(tf_helper.dense(net, self.nclasses,\n name=\"labels\"))\n else:\n labels_generated = \\\n tf_helper.dense(net, self.nclasses,\n name=\"label_logits\")\n\n return style, labels_generated\n\n def _tf_semi_decoder(self, code, keep_prob):\n \"\"\"Decoder for semi-supervised AAE.\n\n Result\n ------\n decoder:\n A flat tensor holding the decoded data.\n \"\"\"\n flat_data_length = \\\n self._data_shape[0] * self._data_shape[1] * self._data_shape[2]\n with tf.variable_scope(\"semi_decoder\", reuse=tf.AUTO_REUSE):\n net = tf_helper.dense_layer(code, self._conf.semi_n_hidden,\n name=\"dense_1\", keep_prob=keep_prob)\n net = tf_helper.dense_layer(net, self._conf.semi_n_hidden,\n name=\"dense_2\", keep_prob=keep_prob)\n net = tf.nn.sigmoid(tf_helper.dense(net, flat_data_length,\n name=\"dense_3\"))\n return net\n\n def _tf_semi_z_discriminator(self, style, keep_prob):\n \"\"\"Discriminator for style codes.\n \"\"\"\n with tf.variable_scope(\"semi_z_discriminator\", reuse=tf.AUTO_REUSE):\n net = tf_helper.dense_layer(style, self._conf.semi_n_hidden,\n name=\"dense_1\", keep_prob=keep_prob)\n net = tf_helper.dense_layer(net, self._conf.semi_n_hidden,\n name=\"dense_2\", keep_prob=keep_prob)\n logits = tf_helper.dense(net, 1, name=\"dense_3\")\n return logits\n\n def _tf_semi_y_discriminator(self, label, keep_prob):\n \"\"\"Discriminator for class labels.\n \"\"\"\n with tf.variable_scope(\"semi_y_discriminator\", reuse=tf.AUTO_REUSE):\n net = tf_helper.dense_layer(label, self._conf.semi_n_hidden,\n name=\"dense_1\", keep_prob=keep_prob)\n net = tf_helper.dense_layer(net, self._conf.semi_n_hidden,\n name=\"dense_2\", keep_prob=keep_prob)\n logits = tf_helper.dense(net, 1, name=\"dense_3\")\n return logits\n\n def _tf_define_optimizers(self, variables) -> None:\n \"\"\"Prepare the training process. Define optimizers.\n \"\"\"\n super()._tf_define_optimizers(variables)\n\n # FIXME[semi]: z and y discriminator\n var_z_discriminator = [var for var in variables\n if \"z_discriminator\" in var.name]\n var_y_discriminator = [var for var in variables\n if \"y_discriminator\" in var.name]\n var_generator = [var for var in variables\n if \"encoder\" in var.name]\n\n self._op_z_discriminator = \\\n tf.train.AdamOptimizer(learning_rate=self._tf_learning_rate/5).\\\n minimize(self._tf_loss_discriminator,\n global_step=self._tf_global_step,\n var_list=var_z_discriminator)\n self._op_y_discriminator = \\\n tf.train.AdamOptimizer(learning_rate=self._tf_learning_rate/5).\\\n minimize(self._tf_loss_discriminator,\n global_step=self._tf_global_step,\n var_list=var_y_discriminator)\n self._op_generator = \\\n tf.train.AdamOptimizer(learning_rate=self._tf_learning_rate).\\\n minimize(self._tf_loss_generator,\n global_step=self._tf_global_step,\n var_list=var_generator)\n\n # optimizer for supervised data: minimize cross-entropy between\n # real and fake labels.\n self._op_crossentropy_labels = \\\n tf.train.AdamOptimizer(learning_rate=self._tf_learning_rate).\\\n minimize(self._crossentropy_labels,\n global_step=self._tf_global_step,\n var_list=var_generator)\n\n def _tf_train_step(self, sess, feed_dict) -> None:\n \"\"\"Perform one training step.\n \"\"\"\n # AutoEncoder phase\n super()._tf_train_step(sess, feed_dict)\n\n # Discriminator phase\n # FIXME[semi]: optimize both discriminators\n self._l_z_discriminator, _ = \\\n sess.run([self._tf_loss_discriminator_style,\n self._op_z_discriminator],\n feed_dict=feed_dict)\n self._l_y_discriminator, _ = \\\n sess.run([self._tf_loss_discriminator_label,\n self._op_y_discriminator],\n feed_dict=feed_dict)\n\n # Generator phase\n self._l_generator, _ = \\\n sess.run([self._tf_loss_generator, self._op_generator],\n feed_dict=feed_dict)\n\n def _tf_train_supervised_step(self, sess, feed_dict) -> None:\n # Cross_Entropy phase\n self._crossentropy, _ = \\\n sess.run([self._crossentropy_labels,\n self._op_crossentropy_labels],\n feed_dict=feed_dict)\n\n def train(self,\n unlabeled_train_data: Datasource,\n labeled_train_data: Datasource,\n labeled_display_data: Datasource,\n sess: tf.Session, saver) -> None:\n \"\"\"Train the network.\n \"\"\"\n # display_data: (images, images_noised, labels)\n # A batch of data used for plotting intermediate results\n # during training (taken from the validation dataset)\n # Each is a numpy array of length 100 and appropriate shape.\n display_data = labeled_display_data[:100, ('array', 'array', 'label')]\n\n # obtain the variables used in the model\n total_vars = tf.trainable_variables()\n\n # Optimizers\n self._tf_define_optimizers(total_vars)\n\n #\n # Start the training\n #\n start_epoch = self._tf_initialize_variables(sess, saver)\n start_time = time.time()\n\n total_batch = len(labeled_train_data) // self._conf.batch_size\n labeled_batch_iterator = \\\n labeled_train_data(batch_size=self._conf.batch_size,\n attributes=('array', 'array', 'label'))\n unlabeled_batch_iterator = \\\n unlabeled_train_data(batch_size=self._conf.batch_size,\n attributes=('array', 'noisy'))\n\n for epoch in tqdm(range(start_epoch, self._conf.n_epoch),\n initial=start_epoch, total=self._conf.n_epoch):\n likelihood = 0\n discriminator_z_value = 0\n discriminator_y_value = 0\n generator_value = 0\n crossentropy_value = 0\n\n # Adapt the learning rate depending on the epoch\n lr_value = self._learning_rate_schedule(epoch)\n\n for _batch_idx in tqdm(range(total_batch)):\n\n #\n # Part 1: unsupervised learning\n #\n batch_xs, batch_noised_xs = next(unlabeled_batch_iterator)\n\n # FIXME[semi]:\n real_cat_labels = \\\n np.random.randint(low=0, high=self.nclasses,\n size=self._conf.batch_size)\n real_cat_labels = np.eye(self.nclasses)[real_cat_labels]\n\n # Sample from the prior distribution\n prior_style, _tf_prior_label_onehot = \\\n self._sample_prior(self._conf.prior, zdim=self.code_dim,\n nclasses=self.nclasses,\n batch_size=self._conf.batch_size,\n use_label_info=False)\n\n feed_dict = {\n self._tf_inputs: batch_noised_xs,\n self._tf_outputs: batch_xs,\n # self._tf_labels: batch_ys,\n self._tf_prior_style: prior_style,\n # FIXME[semi]: real_cat_labels instead of\n # prior_label_onehot\n self._tf_prior_label: real_cat_labels,\n self._tf_learning_rate: lr_value,\n self._tf_keep_prob: self._conf.keep_prob\n }\n\n # perform the actual training\n self._tf_train_step(sess, feed_dict)\n\n #\n # Part 2: supervised training with labels\n #\n\n # Obtain a batch of labeled validation data to train\n # the encoder to predict correct class labels\n # (minimizing crossentropy)\n batch_semi_xs, batch_noised_semi_xs, batch_semi_ys = \\\n next(labeled_batch_iterator)\n\n feed_dict_semi = {\n self._tf_inputs: batch_noised_semi_xs,\n self._tf_outputs: batch_semi_xs,\n self._tf_labels: batch_semi_ys,\n # FIXME[semi]: _tf_prior_label was Y_cat\n self._tf_prior_label: real_cat_labels,\n self._tf_learning_rate: lr_value,\n self._tf_keep_prob: self._conf.keep_prob\n }\n\n self._tf_train_supervised_step(self, sess, feed_dict_semi)\n\n # Summary\n likelihood += \\\n self._loss_reconstruction_value/total_batch\n discriminator_z_value += self._l_z_discriminator/total_batch\n discriminator_y_value += self._l_y_discriminator/total_batch\n generator_value += self._l_generator/total_batch\n crossentropy_value += self._crossentropy/total_batch\n\n # every 5th epoch (except the last) plot the manifold canvas\n if epoch % 5 == 0 or epoch == (self._conf.n_epoch - 1):\n name = f\"Manifold_semi_canvas_{epoch}\"\n self.plot_recoded_images(display_data[1],\n targets=display_data[0],\n filename=name)\n\n # output end of epoch information\n runtime = time.time() - start_time\n print(f\"Epoch: {epoch:3d}, \"\n f\"global step: {sess.run(self._tf_global_step)}, \"\n f\"Time: {datetime.timedelta(seconds=runtime)}\")\n print(f\" lr_AE: {lr_value:.5f}\"\n f\" loss_AE: {likelihood:.4f}\")\n print(f\" lr_D: {lr_value/5:.5f}\"\n f\" loss_z_D: {discriminator_z_value:.4f},\"\n f\" loss_y_D: {discriminator_y_value:.4f}\")\n print(f\" lr_G: {lr_value:.5f}\"\n f\" loss_G: {generator_value:.4f},\"\n f\" loss_CE: {crossentropy_value:.4f}\\n\")\n\n\ndef main() -> None:\n \"\"\"The main program.\n \"\"\"\n ModelClass = SupervisedAdversarialAutoencoder\n # ModelClass = SemiSupervisedAdversarialAutoencoder\n\n datasource_train = Datasource(module='mnist', one_hot=True)\n datasource_train.add_postprocessor(add_noise)\n datasource_test = Datasource(module='mnist', section='test', one_hot=True)\n\n aae = ModelClass(shape=datasource_train.shape, code_dim=2,\n nclasses=len(datasource_train.label_scheme))\n aae.prepare()\n\n saver = tf.train.Saver(name='aae', filename=\"my_test_model\")\n # print(f\"\\n\\n##### Saver: {saver.last_checkpoints}\\n\\n\")\n # print(\"tf.train.latest_checkpoint(): \"\n # f\"{tf.train.latest_checkpoint('checkpoints')}\")\n # print(f\"\\n\\n##### Saver: {saver.last_checkpoints}\\n\\n\")\n\n with tf.Session() as sess:\n aae.set_tensorflow_session(sess)\n aae.train(datasource_train, datasource_test, sess, saver)\n\n if aae.code_dim == 2:\n print(\"-\" * 80)\n print(\"plot 2D Scatter Result\")\n aae.plot_data_codes_2d(datasource_test._array,\n labels=datasource_test._labels,\n filename='2D_latent_space.png')\n\n if aae.code_dim and aae.conf.flag_plot_mlr:\n print(\"-\" * 80)\n print(\"plot Manifold Learning Result\")\n # filename = \"PMLR/PMLR\"\n aae.plot_decoded_codespace_2d(labels=5)\n\n if aae.conf.flag_plot_arr:\n print(\"-\"*80)\n print(\"plot analogical reasoning result\")\n aae.plot_analogical_decoding()\n\n\nif __name__ == '__main__':\n main()\n", "meta": {"hexsha": "ddf19e93e72820d0cf65e8b012ae143cd8e9a2f7", "size": 44319, "ext": "py", "lang": "Python", "max_stars_repo_path": "dltb/thirdparty/tensorflow/aae.py", "max_stars_repo_name": "Petr-By/qtpyvis", "max_stars_repo_head_hexsha": "0b9a151ee6b9a56b486c2bece9c1f03414629efc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2017-10-04T14:51:26.000Z", "max_stars_repo_stars_event_max_datetime": "2017-10-22T09:35:50.000Z", "max_issues_repo_path": "dltb/thirdparty/tensorflow/aae.py", "max_issues_repo_name": "Petr-By/qtpyvis", "max_issues_repo_head_hexsha": "0b9a151ee6b9a56b486c2bece9c1f03414629efc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 13, "max_issues_repo_issues_event_min_datetime": "2017-09-05T12:56:11.000Z", "max_issues_repo_issues_event_max_datetime": "2017-11-22T10:38:27.000Z", "max_forks_repo_path": "dltb/thirdparty/tensorflow/aae.py", "max_forks_repo_name": "krumnack/qtpyvis", "max_forks_repo_head_hexsha": "0b9a151ee6b9a56b486c2bece9c1f03414629efc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2017-09-24T21:39:42.000Z", "max_forks_repo_forks_event_max_datetime": "2017-10-04T15:29:54.000Z", "avg_line_length": 39.7123655914, "max_line_length": 79, "alphanum_fraction": 0.5832261558, "include": true, "reason": "import numpy", "num_tokens": 9096, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5234203489363239, "lm_q2_score": 0.37022539259558657, "lm_q1q2_score": 0.19378350417746945}} {"text": "\"\"\"\n针对brats数据集\n做包含预处理的数据管道(Python生成器)\n\n每次优先读取npy 不存在则读取nii 同时保存npy\n\n读取240*240 指定155中部切片\n或者读取240*240*155 3D\n\n以2D为例，进行中心附近剪裁，单个240*240切片 中心有效区域为196*144\n在这个区域内选取若然随机的128*128切片 进行训练 确保训练的数据是有监督的 对其的\n切片范围为中心的196-128 和144-128 即 68*16范围内去随机值\n\n\"\"\"\n\nimport os \nimport sys\nfrom PIL import Image\nimport numpy as np \nimport nibabel as nib\nfrom scipy import ndimage\nimport random\nbase = os.path.dirname(os.path.abspath(__file__))\nsys.path.append(os.path.join(base, '../'))\nfrom utils import CutPadding\nimport random\nclass UnpairedError(Exception):\n def __init__(self,path):\n self.err_msg = \"There are not exixting paired samples! We can only find:\"\n self.filename = path\nclass DataPipeLine():\n def __init__(self,path,target_size,patch_size,remake_flag=False,random_flag=False,crop=\"crop_random\"):\n self.path = path\n self.datalist = self.__readDirFile(self.path,random_flag)\n self.target_size = target_size\n self.patch_size = patch_size\n self.dims = len(target_size)\n self.remake_flag = remake_flag\n self.random_flag = random_flag\n self.crop = crop.lower()\n def __readDirFile(self,path,random_flag=False):\n buf_A = []\n buf_B = []\n buf_A_mask_v0 = []\n buf_B_mask_v0 = []\n for (dirName, subdirList, fileList) in os.walk(path):\n try:\n for filename in fileList:\n if \"t1.nii\" in filename.lower(): \n buf_A.append(os.path.join(dirName,filename))\n if \"t2.nii\" in filename.lower(): \n buf_B.append(os.path.join(dirName,filename))\n if \"mask_t1_v0.nii\" in filename.lower(): \n buf_A_mask_v0.append(os.path.join(dirName,filename))\n if \"mask_t2_v0.nii\" in filename.lower(): \n buf_B_mask_v0.append(os.path.join(dirName,filename))\n if len(buf_A) > len(buf_B):\n raise UnpairedError(buf_A.pop(-1))\n elif len(buf_A) < len(buf_B):\n raise UnpairedError(buf_B.pop(-1))\n else:\n pass\n except UnpairedError as error:\n print(error.err_msg)\n print(error.filename)\n else:# normal condition\n pass\n finally:# any way\n pass\n if random_flag:\n \"\"\"\n 打乱A B之间的对应关系\n \"\"\"\n random_num1 = random.randint(0,200)\n random_num2 = random.randint(0,200)\n random.seed(random_num1)\n random.shuffle(buf_A)\n random.seed(random_num1)\n random.shuffle(buf_A_mask_v0)\n random.seed(random_num2)\n random.shuffle(buf_B)\n random.seed(random_num2)\n random.shuffle(buf_B_mask_v0)\n return list(zip(buf_A,buf_B,buf_A_mask_v0,buf_B_mask_v0))\n else:\n return list(zip(buf_A,buf_B,buf_A_mask_v0,buf_B_mask_v0))\n def re_rand(self):\n self.datalist = self.__readDirFile(self.path,random_flag=True)\n def read_file(self,path):\n if self.dims == 3:\n temp_path = path[:-3]+\"npy\"\n if (os.path.exists(temp_path)==True)and(self.remake_flag==False):\n return np.load(temp_path)\n else:\n return self.load_nii_file(path)\n elif self.dims == 2:\n temp_path = path[:-3]+\"2D.npy\"\n if (os.path.exists(temp_path)==True)and(self.remake_flag==False):\n return np.load(temp_path)\n else:\n return self.load_nii_file(path)\n else:\n raise ValueError\n def __read_nii_file(self,path):\n img = nib.load(path)\n img = np.array(img.dataobj[:,:,:])\n return img\n def __cut_nii_file(self,img):\n return CutPadding.cut_img_3D(img)\n def __save_nii2npy(self,img,path):\n if self.dims == 3:\n temp_path = path[:-3]+\"npy\"\n elif self.dims ==2:\n temp_path = path[:-3]+\"2D.npy\"\n else:\n raise ValueError\n np.save(temp_path,img)\n return img\n def __cut_np_array(self,array,target_shape=[128,128,128]):\n old_shape = array.shape\n buf = [0,0,0]\n for i in range(3):\n buf[i]=old_shape[i]//2-target_shape[i]//2\n #左半部右下标+1 减去目标点数的一半 获得新的起始点 10//2 -6//2 = 2 从下标2开始然后到下标2+6-1结束\n return array[buf[0]:buf[0]+target_shape[0],buf[1]:buf[1]+target_shape[1],buf[2]:buf[2]+target_shape[2]] \n def __normalize(self,slice,dtype=np.float32):\n tmp = slice/slice.max()\n return tmp.astype(dtype)\n def get_centro_ranges(self,target_size,patch_size):\n ranges_buf = []\n shape = target_size\n for i in range(len(patch_size)):\n if shape[i] Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray,\n numpy.ndarray]:\n \"\"\"\n Given a frame1 and global transformations transformation1 and transformation2, warps frame1 to next view using\n bilinear splatting.\n :param frame1: (h, w, 3) uint8 numpy array\n :param mask1: (h, w) bool numpy array. Wherever mask1 is False, those pixels are ignored while warping. Optional\n :param depth1: (h, w) float numpy array.\n :param transformation1: (4, 4) extrinsic transformation matrix of first view: [R, t; 0, 1]\n :param transformation2: (4, 4) extrinsic transformation matrix of second view: [R, t; 0, 1]\n :param intrinsic1: (3, 3) camera intrinsic matrix\n :param intrinsic2: (3, 3) camera intrinsic matrix. Optional\n \"\"\"\n if self.resolution is not None:\n assert frame1.shape[:2] == self.resolution\n h, w = frame1.shape[:2]\n if mask1 is None:\n mask1 = numpy.ones(shape=(h, w), dtype=bool)\n if intrinsic2 is None:\n intrinsic2 = numpy.copy(intrinsic1)\n assert frame1.shape == (h, w, 3)\n assert mask1.shape == (h, w)\n assert depth1.shape == (h, w)\n assert transformation1.shape == (4, 4)\n assert transformation2.shape == (4, 4)\n assert intrinsic1.shape == (3, 3)\n assert intrinsic2.shape == (3, 3)\n\n trans_points1 = self.compute_transformed_points(depth1, transformation1, transformation2, intrinsic1,\n intrinsic2)\n trans_coordinates = trans_points1[:, :, :2, 0] / trans_points1[:, :, 2:3, 0]\n trans_depth1 = trans_points1[:, :, 2, 0]\n\n grid = self.create_grid(h, w)\n flow12 = trans_coordinates - grid\n\n warped_frame2, mask2 = self.bilinear_splatting(frame1, mask1, trans_depth1, flow12, None, is_image=True)\n warped_depth2 = self.bilinear_splatting(trans_depth1[:, :, None], mask1, trans_depth1, flow12, None,\n is_image=False)[0][:, :, 0]\n return warped_frame2, mask2, warped_depth2, flow12\n\n def compute_transformed_points(self, depth1: numpy.ndarray, transformation1: numpy.ndarray,\n transformation2: numpy.ndarray, intrinsic1: numpy.ndarray,\n intrinsic2: Optional[numpy.ndarray]):\n \"\"\"\n Computes transformed position for each pixel location\n \"\"\"\n if self.resolution is not None:\n assert depth1.shape == self.resolution\n h, w = depth1.shape\n if intrinsic2 is None:\n intrinsic2 = numpy.copy(intrinsic1)\n transformation = numpy.matmul(transformation2, numpy.linalg.inv(transformation1))\n\n y1d = numpy.array(range(h))\n x1d = numpy.array(range(w))\n x2d, y2d = numpy.meshgrid(x1d, y1d)\n ones_2d = numpy.ones(shape=(h, w))\n ones_4d = ones_2d[:, :, None, None]\n pos_vectors_homo = numpy.stack([x2d, y2d, ones_2d], axis=2)[:, :, :, None]\n\n intrinsic1_inv = numpy.linalg.inv(intrinsic1)\n intrinsic1_inv_4d = intrinsic1_inv[None, None]\n intrinsic2_4d = intrinsic2[None, None]\n depth_4d = depth1[:, :, None, None]\n trans_4d = transformation[None, None]\n\n unnormalized_pos = numpy.matmul(intrinsic1_inv_4d, pos_vectors_homo)\n world_points = depth_4d * unnormalized_pos\n world_points_homo = numpy.concatenate([world_points, ones_4d], axis=2)\n trans_world_homo = numpy.matmul(trans_4d, world_points_homo)\n trans_world = trans_world_homo[:, :, :3]\n trans_norm_points = numpy.matmul(intrinsic2_4d, trans_world)\n return trans_norm_points\n\n def bilinear_splatting(self, frame1: numpy.ndarray, mask1: Optional[numpy.ndarray], depth1: numpy.ndarray,\n flow12: numpy.ndarray, flow12_mask: Optional[numpy.ndarray], is_image: bool = False) -> \\\n Tuple[numpy.ndarray, numpy.ndarray]:\n \"\"\"\n Using inverse bilinear interpolation based splatting\n :param frame1: (h, w, c)\n :param mask1: (h, w): True if known and False if unknown. Optional\n :param depth1: (h, w)\n :param flow12: (h, w, 2)\n :param flow12_mask: (h, w): True if valid and False if invalid. Optional\n :param is_image: If true, the return array will be clipped to be in the range [0, 255] and type-casted to uint8\n :return: warped_frame2: (h, w, c)\n mask2: (h, w): True if known and False if unknown\n \"\"\"\n if self.resolution is not None:\n assert frame1.shape[:2] == self.resolution\n h, w, c = frame1.shape\n if mask1 is None:\n mask1 = numpy.ones(shape=(h, w), dtype=bool)\n if flow12_mask is None:\n flow12_mask = numpy.ones(shape=(h, w), dtype=bool)\n grid = self.create_grid(h, w)\n trans_pos = flow12 + grid\n\n trans_pos_offset = trans_pos + 1\n trans_pos_floor = numpy.floor(trans_pos_offset).astype('int')\n trans_pos_ceil = numpy.ceil(trans_pos_offset).astype('int')\n trans_pos_offset[:, :, 0] = numpy.clip(trans_pos_offset[:, :, 0], a_min=0, a_max=w + 1)\n trans_pos_offset[:, :, 1] = numpy.clip(trans_pos_offset[:, :, 1], a_min=0, a_max=h + 1)\n trans_pos_floor[:, :, 0] = numpy.clip(trans_pos_floor[:, :, 0], a_min=0, a_max=w + 1)\n trans_pos_floor[:, :, 1] = numpy.clip(trans_pos_floor[:, :, 1], a_min=0, a_max=h + 1)\n trans_pos_ceil[:, :, 0] = numpy.clip(trans_pos_ceil[:, :, 0], a_min=0, a_max=w + 1)\n trans_pos_ceil[:, :, 1] = numpy.clip(trans_pos_ceil[:, :, 1], a_min=0, a_max=h + 1)\n\n prox_weight_nw = (1 - (trans_pos_offset[:, :, 1] - trans_pos_floor[:, :, 1])) * \\\n (1 - (trans_pos_offset[:, :, 0] - trans_pos_floor[:, :, 0]))\n prox_weight_sw = (1 - (trans_pos_ceil[:, :, 1] - trans_pos_offset[:, :, 1])) * \\\n (1 - (trans_pos_offset[:, :, 0] - trans_pos_floor[:, :, 0]))\n prox_weight_ne = (1 - (trans_pos_offset[:, :, 1] - trans_pos_floor[:, :, 1])) * \\\n (1 - (trans_pos_ceil[:, :, 0] - trans_pos_offset[:, :, 0]))\n prox_weight_se = (1 - (trans_pos_ceil[:, :, 1] - trans_pos_offset[:, :, 1])) * \\\n (1 - (trans_pos_ceil[:, :, 0] - trans_pos_offset[:, :, 0]))\n\n sat_depth1 = numpy.clip(depth1, a_min=0, a_max=1000)\n log_depth1 = numpy.log(1 + sat_depth1)\n depth_weights = numpy.exp(log_depth1 / log_depth1.max() * 50)\n\n weight_nw = prox_weight_nw * mask1 * flow12_mask / depth_weights\n weight_sw = prox_weight_sw * mask1 * flow12_mask / depth_weights\n weight_ne = prox_weight_ne * mask1 * flow12_mask / depth_weights\n weight_se = prox_weight_se * mask1 * flow12_mask / depth_weights\n\n weight_nw_3d = weight_nw[:, :, None]\n weight_sw_3d = weight_sw[:, :, None]\n weight_ne_3d = weight_ne[:, :, None]\n weight_se_3d = weight_se[:, :, None]\n\n warped_image = numpy.zeros(shape=(h + 2, w + 2, c), dtype=numpy.float64)\n warped_weights = numpy.zeros(shape=(h + 2, w + 2), dtype=numpy.float64)\n\n numpy.add.at(warped_image, (trans_pos_floor[:, :, 1], trans_pos_floor[:, :, 0]), frame1 * weight_nw_3d)\n numpy.add.at(warped_image, (trans_pos_ceil[:, :, 1], trans_pos_floor[:, :, 0]), frame1 * weight_sw_3d)\n numpy.add.at(warped_image, (trans_pos_floor[:, :, 1], trans_pos_ceil[:, :, 0]), frame1 * weight_ne_3d)\n numpy.add.at(warped_image, (trans_pos_ceil[:, :, 1], trans_pos_ceil[:, :, 0]), frame1 * weight_se_3d)\n\n numpy.add.at(warped_weights, (trans_pos_floor[:, :, 1], trans_pos_floor[:, :, 0]), weight_nw)\n numpy.add.at(warped_weights, (trans_pos_ceil[:, :, 1], trans_pos_floor[:, :, 0]), weight_sw)\n numpy.add.at(warped_weights, (trans_pos_floor[:, :, 1], trans_pos_ceil[:, :, 0]), weight_ne)\n numpy.add.at(warped_weights, (trans_pos_ceil[:, :, 1], trans_pos_ceil[:, :, 0]), weight_se)\n\n cropped_warped_image = warped_image[1:-1, 1:-1]\n cropped_weights = warped_weights[1:-1, 1:-1]\n\n mask = cropped_weights > 0\n with numpy.errstate(invalid='ignore'):\n warped_frame2 = numpy.where(mask[:, :, None], cropped_warped_image / cropped_weights[:, :, None], 0)\n\n if is_image:\n assert numpy.min(warped_frame2) >= 0\n assert numpy.max(warped_frame2) <= 256\n clipped_image = numpy.clip(warped_frame2, a_min=0, a_max=255)\n warped_frame2 = numpy.round(clipped_image).astype('uint8')\n return warped_frame2, mask\n\n def bilinear_interpolation(self, frame2: numpy.ndarray, mask2: Optional[numpy.ndarray], flow12: numpy.ndarray,\n flow12_mask: Optional[numpy.ndarray], is_image: bool = False) -> \\\n Tuple[numpy.ndarray, numpy.ndarray]:\n \"\"\"\n Using bilinear interpolation\n :param frame2: (h, w, c)\n :param mask2: (h, w): True if known and False if unknown. Optional\n :param flow12: (h, w, 2)\n :param flow12_mask: (h, w): True if valid and False if invalid. Optional\n :param is_image: If true, the return array will be clipped to be in the range [0, 255] and type-casted to uint8\n :return: warped_frame1: (h, w, c)\n mask1: (h, w): True if known and False if unknown\n \"\"\"\n if self.resolution is not None:\n assert frame2.shape[:2] == self.resolution\n h, w, c = frame2.shape\n if mask2 is None:\n mask2 = numpy.ones(shape=(h, w), dtype=bool)\n if flow12_mask is None:\n flow12_mask = numpy.ones(shape=(h, w), dtype=bool)\n grid = self.create_grid(h, w)\n trans_pos = flow12 + grid\n\n trans_pos_offset = trans_pos + 1\n trans_pos_floor = numpy.floor(trans_pos_offset).astype('int')\n trans_pos_ceil = numpy.ceil(trans_pos_offset).astype('int')\n trans_pos_offset[:, :, 0] = numpy.clip(trans_pos_offset[:, :, 0], a_min=0, a_max=w + 1)\n trans_pos_offset[:, :, 1] = numpy.clip(trans_pos_offset[:, :, 1], a_min=0, a_max=h + 1)\n trans_pos_floor[:, :, 0] = numpy.clip(trans_pos_floor[:, :, 0], a_min=0, a_max=w + 1)\n trans_pos_floor[:, :, 1] = numpy.clip(trans_pos_floor[:, :, 1], a_min=0, a_max=h + 1)\n trans_pos_ceil[:, :, 0] = numpy.clip(trans_pos_ceil[:, :, 0], a_min=0, a_max=w + 1)\n trans_pos_ceil[:, :, 1] = numpy.clip(trans_pos_ceil[:, :, 1], a_min=0, a_max=h + 1)\n\n prox_weight_nw = (1 - (trans_pos_offset[:, :, 1] - trans_pos_floor[:, :, 1])) * \\\n (1 - (trans_pos_offset[:, :, 0] - trans_pos_floor[:, :, 0]))\n prox_weight_sw = (1 - (trans_pos_ceil[:, :, 1] - trans_pos_offset[:, :, 1])) * \\\n (1 - (trans_pos_offset[:, :, 0] - trans_pos_floor[:, :, 0]))\n prox_weight_ne = (1 - (trans_pos_offset[:, :, 1] - trans_pos_floor[:, :, 1])) * \\\n (1 - (trans_pos_ceil[:, :, 0] - trans_pos_offset[:, :, 0]))\n prox_weight_se = (1 - (trans_pos_ceil[:, :, 1] - trans_pos_offset[:, :, 1])) * \\\n (1 - (trans_pos_ceil[:, :, 0] - trans_pos_offset[:, :, 0]))\n\n weight_nw = prox_weight_nw * flow12_mask\n weight_sw = prox_weight_sw * flow12_mask\n weight_ne = prox_weight_ne * flow12_mask\n weight_se = prox_weight_se * flow12_mask\n\n weight_nw_3d = weight_nw[:, :, None]\n weight_sw_3d = weight_sw[:, :, None]\n weight_ne_3d = weight_ne[:, :, None]\n weight_se_3d = weight_se[:, :, None]\n\n frame2_offset = numpy.pad(frame2, pad_width=((1, 1), (1, 1), (0, 0)), mode='constant', constant_values=0)\n mask2_offset = numpy.pad(mask2, pad_width=((1, 1), (1, 1)), mode='constant', constant_values=0)\n\n f2_nw = frame2_offset[trans_pos_floor[:, :, 1], trans_pos_floor[:, :, 0]]\n f2_sw = frame2_offset[trans_pos_ceil[:, :, 1], trans_pos_floor[:, :, 0]]\n f2_ne = frame2_offset[trans_pos_floor[:, :, 1], trans_pos_ceil[:, :, 0]]\n f2_se = frame2_offset[trans_pos_ceil[:, :, 1], trans_pos_ceil[:, :, 0]]\n\n m2_nw = mask2_offset[trans_pos_floor[:, :, 1], trans_pos_floor[:, :, 0]]\n m2_sw = mask2_offset[trans_pos_ceil[:, :, 1], trans_pos_floor[:, :, 0]]\n m2_ne = mask2_offset[trans_pos_floor[:, :, 1], trans_pos_ceil[:, :, 0]]\n m2_se = mask2_offset[trans_pos_ceil[:, :, 1], trans_pos_ceil[:, :, 0]]\n\n m2_nw_3d = m2_nw[:, :, None]\n m2_sw_3d = m2_sw[:, :, None]\n m2_ne_3d = m2_ne[:, :, None]\n m2_se_3d = m2_se[:, :, None]\n\n nr = weight_nw_3d * f2_nw * m2_nw_3d + weight_sw_3d * f2_sw * m2_sw_3d + \\\n weight_ne_3d * f2_ne * m2_ne_3d + weight_se_3d * f2_se * m2_se_3d\n dr = weight_nw_3d * m2_nw_3d + weight_sw_3d * m2_sw_3d + weight_ne_3d * m2_ne_3d + weight_se_3d * m2_se_3d\n warped_frame1 = numpy.where(dr > 0, nr / dr, 0)\n mask1 = dr[:, :, 0] > 0\n\n if is_image:\n assert numpy.min(warped_frame1) >= 0\n assert numpy.max(warped_frame1) <= 256\n clipped_image = numpy.clip(warped_frame1, a_min=0, a_max=255)\n warped_frame1 = numpy.round(clipped_image).astype('uint8')\n return warped_frame1, mask1\n\n @staticmethod\n def create_grid(h, w):\n x_1d = numpy.arange(0, w)[None]\n y_1d = numpy.arange(0, h)[:, None]\n x_2d = numpy.repeat(x_1d, repeats=h, axis=0)\n y_2d = numpy.repeat(y_1d, repeats=w, axis=1)\n grid = numpy.stack([x_2d, y_2d], axis=2)\n return grid\n\n @staticmethod\n def read_image(path: Path) -> numpy.ndarray:\n if path.suffix in ['.jpg', '.png', '.bmp']:\n image = skimage.io.imread(path.as_posix())\n elif path.suffix == '.npy':\n image = numpy.load(path.as_posix())\n else:\n raise RuntimeError(f'Unknown image format: {path.as_posix()}')\n return image\n\n @staticmethod\n def read_depth(path: Path) -> numpy.ndarray:\n if path.suffix == '.png':\n depth = skimage.io.imread(path.as_posix())\n elif path.suffix == '.npy':\n depth = numpy.load(path.as_posix())\n elif path.suffix == '.npz':\n with numpy.load(path.as_posix()) as depth_data:\n depth = depth_data['depth']\n elif path.suffix == '.exr':\n import Imath\n import OpenEXR\n\n exr_file = OpenEXR.InputFile(path.as_posix())\n raw_bytes = exr_file.channel('B', Imath.PixelType(Imath.PixelType.FLOAT))\n depth_vector = numpy.frombuffer(raw_bytes, dtype=numpy.float32)\n height = exr_file.header()['displayWindow'].max.y + 1 - exr_file.header()['displayWindow'].min.y\n width = exr_file.header()['displayWindow'].max.x + 1 - exr_file.header()['displayWindow'].min.x\n depth = numpy.reshape(depth_vector, (height, width))\n else:\n raise RuntimeError(f'Unknown depth format: {path.as_posix()}')\n return depth\n\n @staticmethod\n def camera_intrinsic_transform(capture_width=1920, capture_height=1080, patch_start_point: tuple = (0, 0)):\n start_y, start_x = patch_start_point\n camera_intrinsics = numpy.eye(3)\n camera_intrinsics[0, 0] = 2100\n camera_intrinsics[0, 2] = capture_width / 2.0 - start_x\n camera_intrinsics[1, 1] = 2100\n camera_intrinsics[1, 2] = capture_height / 2.0 - start_y\n return camera_intrinsics\n\n\ndef demo1():\n frame1_path = Path('../Data/frame1.png')\n frame2_path = Path('../Data/frame2.png')\n depth1_path = Path('../Data/depth1.npy')\n transformation1 = numpy.array([\n 4.067366123199462891e-01, 9.135454893112182617e-01, 2.251522164442576468e-05, -1.571802258491516113e+00,\n -7.961163669824600220e-02, 3.546993434429168701e-02, -9.961947202682495117e-01, 1.842712044715881348e+00,\n -9.100699424743652344e-01, 4.051870703697204590e-01, 8.715576678514480591e-02, -2.255212306976318359e+00,\n 0.000000000000000000e+00, 0.000000000000000000e+00, 0.000000000000000000e+00, 1.000000000000000000e+00\n ]).reshape(4, 4)\n transformation2 = numpy.array([\n 4.067366123199462891e-01, 9.135454893112182617e-01, 2.251522164442576468e-05, -1.616834521293640137e+00,\n -7.961163669824600220e-02, 3.546993434429168701e-02, -9.961947202682495117e-01, 1.848096847534179688e+00,\n -9.100699424743652344e-01, 4.051870703697204590e-01, 8.715576678514480591e-02, -2.275809526443481445e+00,\n 0.000000000000000000e+00, 0.000000000000000000e+00, 0.000000000000000000e+00, 1.000000000000000000e+00\n ]).reshape(4, 4)\n\n warper = Warper()\n frame1 = warper.read_image(frame1_path)\n frame2 = warper.read_image(frame2_path)\n depth1 = warper.read_depth(depth1_path)\n intrinsic = warper.camera_intrinsic_transform()\n\n warped_frame2 = warper.forward_warp(frame1, None, depth1, transformation1, transformation2, intrinsic, None)[0]\n skimage.io.imsave('frame1.png', frame1)\n skimage.io.imsave('frame2.png', frame2)\n skimage.io.imsave('frame2_warped.png', warped_frame2)\n return\n\n\ndef main():\n demo1()\n return\n\n\nif __name__ == '__main__':\n print('Program started at ' + datetime.datetime.now().strftime('%d/%m/%Y %I:%M:%S %p'))\n start_time = time.time()\n try:\n main()\n except Exception as e:\n print(e)\n traceback.print_exc()\n end_time = time.time()\n print('Program ended at ' + datetime.datetime.now().strftime('%d/%m/%Y %I:%M:%S %p'))\n print('Execution time: ' + str(datetime.timedelta(seconds=end_time - start_time)))\n", "meta": {"hexsha": "55da69fb80ebcabf1e2f99bf5b4e90db84bc068b", "size": 18375, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/Warper.py", "max_stars_repo_name": "NagabhushanSN95/Pose-Warping", "max_stars_repo_head_hexsha": "9d5400b6a0fe299ece3481c29b0f8fe9ba7bee4e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7, "max_stars_repo_stars_event_min_datetime": "2021-07-13T07:29:23.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-23T08:53:42.000Z", "max_issues_repo_path": "src/Warper.py", "max_issues_repo_name": "NagabhushanSN95/Pose-Warping", "max_issues_repo_head_hexsha": "9d5400b6a0fe299ece3481c29b0f8fe9ba7bee4e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-09-14T14:55:29.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-05T16:32:50.000Z", "max_forks_repo_path": "src/Warper.py", "max_forks_repo_name": "NagabhushanSN95/Pose-Warping", "max_forks_repo_head_hexsha": "9d5400b6a0fe299ece3481c29b0f8fe9ba7bee4e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-11-05T03:04:18.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-05T03:04:18.000Z", "avg_line_length": 50.4807692308, "max_line_length": 120, "alphanum_fraction": 0.6099047619, "include": true, "reason": "import numpy", "num_tokens": 5278, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5234203489363242, "lm_q2_score": 0.3702253856469203, "lm_q1q2_score": 0.1937835005403962}} {"text": "#!/usr/bin/env python\n\nimport sys\nimport loco\nimport tinymath as tm\nimport numpy as np\n\nPHYSICS_BACKEND = loco.sim.PHYSICS_NONE\nRENDERING_BACKEND = loco.sim.RENDERING_GLVIZ_GLFW\n\nclass DoublePendulum(object):\n\n def __init__(self, name='double_pendulum', pos=[0.0, 0.0, 2.0], l1=0.5, l2=0.5):\n super(DoublePendulum, self).__init__()\n\n self.kintree = loco.sim.kintree.KinematicTree(name, pos, tm.Matrix3f())\n self.base = loco.sim.kintree.Box(name + '_base', [0.1, 0.1, 0.1])\n self.link_1 = loco.sim.kintree.Capsule(name + '_link_1', 0.05, l1)\n self.link_2 = loco.sim.kintree.Capsule(name + '_link_2', 0.04, l2)\n\n jnt_1_axis = [1.0, 0.0, 0.0]\n jnt_2_axis = [1.0, 0.0, 0.0]\n self.jnt_base = loco.sim.kintree.FixedJoint(name + '_jnt_fixed')\n self.jnt_1 = loco.sim.kintree.RevoluteJoint(name + '_jnt_rev_1', jnt_1_axis, [1.0, -1.0])\n self.jnt_2 = loco.sim.kintree.RevoluteJoint(name + '_jnt_rev_2', jnt_2_axis, [1.0, -1.0])\n\n tf_link_1_to_base = tm.Matrix4f(np.identity(3), [0.0, 0.0, -0.5 * l1])\n tf_link_2_to_link_1 = tm.Matrix4f(np.identity(3), [0.0, 0.0, -0.5 * l1 - 0.5 * l2] )\n tf_jnt_1_to_link_1 = tm.Matrix4f(np.identity(3), [0.0, 0.0, 0.5 * l1])\n tf_jnt_2_to_link_2 = tm.Matrix4f(np.identity(3), [0.0, 0.0, 0.5 * l2])\n\n self.kintree.SetRoot(self.base)\n self.base.AddJoint(self.jnt_base, np.identity(4))\n self.base.AddChild(self.link_1, tf_link_1_to_base)\n self.link_1.AddJoint(self.jnt_1, tf_jnt_1_to_link_1)\n self.link_1.AddChild(self.link_2, tf_link_2_to_link_1)\n self.link_2.AddJoint(self.jnt_2, tf_jnt_2_to_link_2)\n\nif __name__ == '__main__' :\n\n if len( sys.argv ) > 1 :\n choice_backend = sys.argv[1]\n if choice_backend == 'mujoco' :\n PHYSICS_BACKEND = loco.sim.PHYSICS_MUJOCO\n elif choice_backend == 'bullet' :\n PHYSICS_BACKEND = loco.sim.PHYSICS_BULLET\n elif choice_backend == 'dart' :\n PHYSICS_BACKEND = loco.sim.PHYSICS_DART\n elif choice_backend == 'raisim' :\n PHYSICS_BACKEND = loco.sim.PHYSICS_RAISIM\n print( 'Physics backend: {}'.format( PHYSICS_BACKEND ) )\n print( 'Rendering backend: {}'.format( RENDERING_BACKEND ) )\n\n scenario = loco.sim.Scenario()\n floor = scenario.AddSingleBody( loco.sim.primitives.Plane( \"floor\", 10.0, 10.0, tm.Vector3f(), tm.Matrix3f() ) )\n double_pendulum = DoublePendulum()\n scenario.AddKinematicTree( double_pendulum.kintree )\n\n runtime = loco.sim.Runtime( PHYSICS_BACKEND, RENDERING_BACKEND )\n simulation = runtime.CreateSimulation( scenario )\n visualizer = runtime.CreateVisualizer( scenario )\n\n floor.drawable.texture = 'built_in_chessboard'\n floor.drawable.ambient = [ 0.3, 0.5, 0.7 ]\n floor.drawable.diffuse = [ 0.3, 0.5, 0.7 ]\n floor.drawable.specular = [ 0.3, 0.5, 0.7 ]\n\n while visualizer.IsActive() :\n if visualizer.CheckSingleKeyPress( loco.sim.Keys.KEY_ESCAPE ) :\n break\n elif visualizer.CheckSingleKeyPress( loco.sim.Keys.KEY_R ) :\n simulation.Reset()\n elif visualizer.CheckSingleKeyPress( loco.sim.Keys.KEY_P ) :\n simulation.Pause() if simulation.running else simulation.Resume()\n\n double_pendulum.jnt_1.angle = double_pendulum.jnt_1.angle + 0.01\n double_pendulum.jnt_2.angle = double_pendulum.jnt_2.angle + 0.005\n\n simulation.Step( 1. / 60. )\n visualizer.Render()\n\n runtime.DestroySimulation()\n runtime.DestroyVisualizer()", "meta": {"hexsha": "68c31879fdd5b978673d910f0e3634760f92c232", "size": 3535, "ext": "py", "lang": "Python", "max_stars_repo_path": "examples/python/kinematic_trees/example_programmatical.py", "max_stars_repo_name": "wpumacay/tysocTerrain", "max_stars_repo_head_hexsha": "78b6d9804ade89a483fb60952ed6e1bf50fbf3da", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-06-17T00:57:11.000Z", "max_stars_repo_stars_event_max_datetime": "2020-06-17T00:57:11.000Z", "max_issues_repo_path": "examples/python/kinematic_trees/example_programmatical.py", "max_issues_repo_name": "wpumacay/tysocCore", "max_issues_repo_head_hexsha": "78b6d9804ade89a483fb60952ed6e1bf50fbf3da", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2019-05-30T03:41:42.000Z", "max_issues_repo_issues_event_max_datetime": "2020-08-21T06:29:52.000Z", "max_forks_repo_path": "examples/python/kinematic_trees/example_programmatical.py", "max_forks_repo_name": "wpumacay/tysoc", "max_forks_repo_head_hexsha": "78b6d9804ade89a483fb60952ed6e1bf50fbf3da", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.5903614458, "max_line_length": 116, "alphanum_fraction": 0.6574257426, "include": true, "reason": "import numpy", "num_tokens": 1146, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.523420348936324, "lm_q2_score": 0.3702253786982541, "lm_q1q2_score": 0.1937834969033229}} {"text": "\"\"\"\nゲルフォントの定数\n\"\"\"\n\ndef gelfonds_constant(digit: int) -> str:\n\tfrom sympy import N, I\n\treturn str(N(\"(-1) ** -I\", digit))\n\nif __name__ == \"__main__\":\n\tdigit = 10000\n\tprint(gelfonds_constant(digit))\n", "meta": {"hexsha": "695ad4044fb90f7edf4bff6881b4f776d68a5d4f", "size": 197, "ext": "py", "lang": "Python", "max_stars_repo_path": "extra/gelfonds_constant.py", "max_stars_repo_name": "Fairy-Phy/Relium", "max_stars_repo_head_hexsha": "70ea037cea176f02e4768bde44dd5ee23af699b3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "extra/gelfonds_constant.py", "max_issues_repo_name": "Fairy-Phy/Relium", "max_issues_repo_head_hexsha": "70ea037cea176f02e4768bde44dd5ee23af699b3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "extra/gelfonds_constant.py", "max_forks_repo_name": "Fairy-Phy/Relium", "max_forks_repo_head_hexsha": "70ea037cea176f02e4768bde44dd5ee23af699b3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 16.4166666667, "max_line_length": 41, "alphanum_fraction": 0.654822335, "include": true, "reason": "from sympy", "num_tokens": 69, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.523420348936324, "lm_q2_score": 0.3702253786982541, "lm_q1q2_score": 0.1937834969033229}} {"text": "\"\"\"Plot figure 6: attack rates vs R0.\"\"\"\nimport numpy as np\nimport pandas as pd\nfrom scipy.stats import linregress\n\nimport matplotlib as mplt\nimport matplotlib.pyplot as plt\nimport matplotlib.colors as colors\nimport matplotlib.cm as cm\nimport matplotlib.font_manager as font_manager\n\nimport cmocean\nimport cmasher\nimport seaborn\nimport copy\nimport os\n\n\n# set the font family style\nmplt.rcParams['font.family'] = 'Myriad Pro' # change to a font you have installed on your computer - checkout Google Fonts for free fonts available for download\n\n# set some initial paths\n\n# path to the directory where this script lives\nthisdir = os.path.abspath('')\n\n# path to the main directory of the repository\nmaindir = os.path.split(os.path.split(thisdir)[0])[0]\n\n# path to the analysis_results subdirectory\nanalysisdir = os.path.split(thisdir)[0]\n\n# path to the data subdirectory\ndatadir = os.path.join(os.path.split(os.path.split(thisdir)[0])[0], 'data')\n\n# path to the figures subdirectory within analysis_results\nfigdir = os.path.join(analysisdir, 'figures')\n\nlocation_file = os.path.join(analysisdir, 'location_country_names.csv')\nlocations_df = pd.read_csv(location_file, delimiter = ',')\n\nsetting_fractions_file = os.path.join(analysisdir, 'summary_fractions_by_location.csv')\nsetting_fractions_df = pd.read_csv(setting_fractions_file)\nsetting_codes = ['H','S','W','R']\n\n\ndef get_country_name(df,location):\n \"\"\"\n Return country name of the location\n\n Args:\n df (pandas Dataframe) : dataframe containing locations and corresponding countries\n location (str) : name of the location\n\n Returns:\n str: Name of the country the location is in.\n \"\"\"\n d = df[df.location == location]\n return d.country.values[0]\n\n\ndef get_locations_by_country(df,country):\n \"\"\"\n Return locations in the country\n\n Args:\n df (pandas Dataframe) : dataframe containing locations and corresponding countries\n country (str) : name of the country\n\n Returns:\n str: Name of the country the location is in.\n \"\"\"\n locations = list(df[df.country == country].location.values)\n return locations\n\n\ndef get_fractions(setting_fractions_df, location):\n \"\"\"\n Get the fraction of people with contacts in each setting of household (H), school (S), or work (W).\n\n Args:\n setting_fractions_df (pandas DataFrame) : a dataframe\n location (str) : name of the location\n\n Returns:\n dict: A dictionary of fractions of people with contacts in each setting for the location.\n \"\"\"\n fractions = dict.fromkeys(['H','S','W','R'],1.)\n d = setting_fractions_df[setting_fractions_df.location == location]\n fractions['H'] = d.NhN.values[0]\n fractions['S'] = d.NsN.values[0]\n fractions['W'] = d.NwN.values[0]\n return fractions\n\n\ndef read_contact_matrix(location, country, level, setting, num_agebrackets=85):\n \"\"\"\n Read in the contact for each setting.\n\n Args:\n location (str) : name of the location\n country (str) : name of the country\n level (str) : name of level (country or subnational)\n setting (str) : name of the contact setting\n num_agebrackets (int) : the number of age brackets for the matrix\n\n Returns:\n A numpy matrix of contact.\n \"\"\"\n setting_type, setting_suffix = 'F', 'setting'\n if setting == 'overall':\n setting_type, setting_suffix = 'M', 'contact_matrix'\n\n if country == 'Europe':\n country = location\n level = 'country'\n\n if level == 'country':\n file_name = country + '_' + level + '_level_' + setting_type + '_' + setting + '_' + setting_suffix + '_' + '%i' % num_agebrackets + '.csv'\n else:\n file_name = country + '_' + level + '_' + location + '_' + setting_type + '_' + setting + '_' + setting_suffix + '_' + '%i' % num_agebrackets + '.csv'\n file_path = os.path.join(datadir, 'contact_matrices', file_name)\n M = np.loadtxt(file_path, delimiter=',')\n return M\n\n\ndef get_ages(location, country, level, num_agebrackets=85):\n \"\"\"\n Get the age count for the synthetic population of the location.\n\n Args:\n location (str) : name of the location\n country (str) : name of the country\n level (str) : name of level (country or subnational)\n num_agebrackets (int) : the number of age brackets\n\n Returns:\n dict: A dictionary of the age count.\n \"\"\"\n\n if country == 'Europe':\n country = location\n level = 'country'\n\n if level == 'country':\n file_name = country + '_' + level + '_level_age_distribution_' + '%i' % num_agebrackets + '.csv'\n else:\n file_name = country + '_' + level + '_' + location + '_age_distribution_' + '%i' % num_agebrackets + '.csv'\n file_path = os.path.join(datadir, 'age_distributions', file_name)\n df = pd.read_csv(file_path, delimiter=',', header=None)\n df.columns = ['age', 'age_count']\n ages = dict(zip(df.age.values.astype(int), df.age_count.values))\n return ages \n\n\ndef get_average_age(ages):\n \"\"\"\n Get the average age from a dictionary of age counts.\n\n Args:\n ages (dict): dictionary of age counts\n\n Return:\n float: The average age given the age count.\n \"\"\"\n average_age = 0\n total_population = sum(ages.values())\n for a in ages:\n average_age += ages[a] * a\n average_age = average_age/total_population\n return average_age\n\n\ndef get_school_age_distribution(location):\n \"\"\"\n Get the age count of people active in the school setting.\n\n Args:\n location (str): name of the location\n\n Returns:\n dict: Age count of people active in the school setting.\n \"\"\"\n ages = {}\n file_path = os.path.join(analysisdir, 'schools_age_distributions',\n 'schools_age_distributions_' + location + '.dat')\n df = pd.read_csv(file_path, delimiter = ',')\n ages = dict(zip(df.age.values, df.setting_count.values))\n return ages\n\n\ndef get_percent_in_school(ages, school_ages):\n \"\"\"\n Get the percent of people in school.\n\n Args: \n ages (dict) : age count\n school_ages (dict) : school age count\n\n Returns:\n float: The percent of people in the school setting.\n \"\"\"\n total_in_school = np.sum([v for v in school_ages.values()], dtype = float)\n total_population = np.sum([v for v in ages.values()], dtype = float)\n return total_in_school/total_population * 100\n\n\ndef get_attack_rates_df(reference_location, reference_scenario, beta, susceptibility_drop_factor, gamma_inverse, num_agebrackets):\n \"\"\"\n Get attack rates dataframe for an SIR compartmental model with age specific contact patterns.\n\n Args:\n reference_location (str) : name of reference location or locations\n reference_scenario (str) : specific reference scenario\n beta (float) : the transmissibilty\n susceptibility_drop_factor (float) : susceptibility of adults to those under 18\n gamma_inverse (float) : the mean recovery period\n num_agebrackets (int) : the number of age brackets for the matrix\n \n Returns:\n Pandas dataframe of attack rates by location\n \"\"\"\n\n file_path = os.path.join(analysisdir, 'reference_location_' + reference_location, 'mcmc_beta_and_dropfactor_scenario_' + reference_scenario,\n 'all_locations_attack_rates_by_age_reference_scenario_' + reference_scenario + '_beta_' + '%.2f' % beta + '_susceptibility_' + '%.2f' % susceptibility + '_gamma_inverse_' + '%.1f' % gamma_inverse + '_' + str(num_agebrackets) + '.csv')\n return pd.read_csv(file_path)\n\n\ndef get_attack_rate(df, location):\n \"\"\"\n Get the total attack rate for the location from the dataframe for an SIR compartmental model with age specific contact patterns.\n\n Args:\n df (pd.DataFrame) : a dataframe of attack rates by location\n location (str) : name of the location\n\n Returns:\n float: The total attack rate for the location as a fraction from an SIR compartmental model with age specific contact patterns. Values between 0 and 1.\n \"\"\"\n return df.loc[df['location'] == location]['artotal'].values[0]\n\n\ndef get_homogeneous_attack_rate_df(gamma_inverse, num_agebrackets):\n \"\"\"\n Get a dataframe with the attack rate for an SIR model with the homogeneous mixing assumption for different basic reproduction, R0, values with a given average recovery period.\n\n Args:\n gamma_inverse (float): the mean recovery period\n num_agebrackets (int): the number of age brackets for the matrix\n\n Returns:\n Pandas dataframe of attack rates by R0 value\n \"\"\"\n file_path = os.path.join(analysisdir, 'homogeneous_sir_attack_rates', 'attack_rates_SIR_homogeneous_mixing.csv')\n df = pd.read_csv(file_path)\n return df\n\n\ndef get_homogeneous_attack_rate(df, R0_star):\n \"\"\"\n Get the attack rate for an SIR model with the homogeneous mixing assumption for a given basic reproduction, R0_star, value.\n\n Args:\n df (pd.DataFrame) : a dataframe of attack rates by the basic reproduction number\n R0_star (float) : the basic reproduction number\n\n Returns:\n float: The total attack rate as a fraction from an SIR model with homogeneous mixing assumptions and specified basic reproduction number R0_star. Values between 0 and 1.\n \"\"\"\n return df.loc[df['R0'] == R0_star]['attack_rate'].values[0]\n\n\ndef get_eigenvalue(matrix):\n \"\"\"\n Get the real component of the leading eigenvalue of a square matrix.\n\n Args:\n matrix (np.ndarray): square matrix\n\n Returns:\n float: Real component of the leading eigenvalue of the matrix.\n \"\"\"\n eigenvalue = max(np.linalg.eigvals(matrix)).real\n return eigenvalue\n\n\ndef get_R0(beta, gamma_inverse, matrix):\n \"\"\"\n Get the basic reproduction number, R0, for an SIR compartmental model given the basic reproduction number, the mean recovery period, and the contact matrix.\n \n Args:\n beta (float) : the transmissibility beta\n gamma_inverse (float) : the mean recovery period\n matrix (np.ndarray) : the contact matrix\n\n Returns:\n float: The basic reproduction number R0 for an SIR compartmental model.\n \"\"\"\n\n gamma = 1./gamma_inverse\n eigenvalue = get_eigenvalue(matrix)\n return beta * eigenvalue / gamma\n\n\ndef get_beta(R0, gamma_inverse, matrix):\n \"\"\"\n Get the transmissibility from an SIR model with age specific contact patterns and basic reproduction number.\n\n Args:\n R0_star (float) : the basic reproduction number\n gamma_inverse (float) : the mean recovery period\n matrix (np.ndarray) : the age specific contact matrix\n\n Returns:\n float: The transmissibility from an SIR model with age specific contact patterns.\n \"\"\"\n gamma = float(1)/gamma_inverse\n eigenvalue = get_eigenvalue(matrix)\n return R0 * gamma / eigenvalue\n\n\ndef linear_function(x,m,b):\n \"\"\"\n Get the y value of a linear function given the x value.\n\n Args:\n m (float): the slope\n b (float): the intercept\n\n Returns:\n The expected y value from a linear function at some specified x value.\n \"\"\"\n return m*x + b\n\n\ndef plot_fig(countries, reference_location, reference_scenario, beta, susceptibility_drop_factor, gamma_inverse, num_agebrackets):\n \"\"\"\n Plot the attack rates from an SIR model with age specific contact patterns vs the basic reproduction, the average age, \n and the percent of the population with contacts in the school layer for subnational locations.\n\n Args:\n countries (list) : list of countries\n reference_location (str) : the reference location (or set of locations) the transmissibilty is calibrated to\n reference_scenario (str) : label of the reference scenario\n beta (float) : the transmissibility\n susceptibility_drop_factor (float) : susceptibility of adults to those under 18\n gamma_inverse (float) : the mean recovery period\n num_agebrackets (int) : the number of age brackets\n\n Returns:\n Matplotlib figure.\n \"\"\"\n countries = ['Australia', 'Canada', 'China', 'Europe', 'India', 'Israel', 'Japan', 'Russia', 'South_Africa', 'United_States']\n locations = []\n\n for country in countries:\n locations += get_locations_by_country(locations_df, country)\n if country in locations and country != 'Israel':\n locations.remove(country)\n\n if country == 'India':\n locations.remove('Dadra_and_Nagar_Haveli')\n locations.remove('Chandigarh')\n locations.remove('Lakshadweep')\n\n if 'Russian_Federation' in locations:\n locations.remove('Russian_Federation')\n\n country_colour_dic = {}\n country_colour_dic['Australia'] = '#0000ff'\n country_colour_dic['Canada'] = '#2ab207'\n country_colour_dic['China'] = '#fcc200'\n country_colour_dic['Europe'] = '#941cca'\n country_colour_dic['India'] = 'darkorange'\n country_colour_dic['Israel'] = '#9b9b9b'\n country_colour_dic['Japan'] = '#000098'\n country_colour_dic['Russia'] = '#dc142b'\n country_colour_dic['South_Africa'] = '#b5d93c'\n country_colour_dic['United_States'] = '#00ace7'\n\n hdf = get_homogeneous_attack_rate_df(gamma_inverse, num_agebrackets)\n df = get_attack_rates_df(reference_location, reference_scenario, beta, susceptibility_drop_factor, gamma_inverse, num_agebrackets)\n\n width = 16\n height = 5\n left = 0.06\n right = 0.865\n bottom = 0.16\n top = 0.88\n wspace = 0.32\n\n fig, ax = plt.subplots(1, 3, figsize=(width, height))\n fig.subplots_adjust(left = left, right = right, top = top, bottom = bottom, wspace = wspace)\n\n\n leg_left = right + 0.01\n leg_right = 0.985\n leg_bottom = bottom\n leg_top = top\n leg_width = leg_right - leg_left\n leg_height = leg_top - leg_bottom\n\n fontsize = 20\n\n axleg = fig.add_axes([leg_left, leg_bottom, leg_width, leg_height])\n axleg.axis('off')\n\n attack_rates_list = []\n R0_list = []\n average_age_list = []\n percent_in_school_list = []\n color_list = []\n\n beta_drop_age = 18\n\n for n, location in enumerate(locations):\n country = get_country_name(locations_df, location)\n if location == 'Israel':\n matrix = read_contact_matrix(location, country, 'country', 'overall')\n ages = get_ages(location, country, 'country')\n else:\n matrix = read_contact_matrix(location, country, 'subnational', 'overall')\n ages = get_ages(location, country, 'subnational')\n\n R0 = get_R0(beta, gamma_inverse, matrix)\n R0_list.append(R0)\n\n average_age = get_average_age(ages)\n average_age_list.append(average_age)\n\n if country != 'Europe':\n school_ages = get_school_age_distribution(location)\n percent_in_school = get_percent_in_school(ages, school_ages)\n\n else:\n fractions = get_fractions(setting_fractions_df, location)\n percent_in_school = fractions['S'] * 100\n\n percent_in_school_list.append(percent_in_school)\n\n ar = get_attack_rate(df, location) * 100\n attack_rates_list.append(ar)\n color = country_colour_dic[country]\n color_list.append(color)\n\n homogeneous_attack_rates_list = hdf.attack_rate.values * 100\n homogeneous_R0_list = hdf.R0.values\n\n size = 12\n\n leg = []\n\n ax[0].scatter(R0_list, attack_rates_list, marker='o', color=color_list, s=size)\n ax[0].plot(homogeneous_R0_list, homogeneous_attack_rates_list, color='k', lw=1.5, label='Homogenous \\nmixing model')\n leg.append(ax[0].legend(loc=2, fontsize=17))\n ax[0].set_xlim(1.5, 2.0)\n ax[0].set_xticks(np.arange(1.5, 2.01, 0.1))\n ax[0].set_xlabel(r'$R_0$', fontsize = fontsize)\n ax[0].text(1.39, 50, 'a', fontsize=fontsize+24, fontstyle='oblique')\n\n\n m,b,r,p,std_err = linregress(average_age_list,attack_rates_list)\n y_theory = np.array([linear_function(a,m,b) for a in average_age_list])\n ax[1].plot(average_age_list, y_theory, color = 'k', lw = 1.5)\n ax[1].scatter(average_age_list, attack_rates_list, marker='o', color=color_list, s=size)\n ax[1].text(45,73, r'$\\rho$ = ' + '%.2f' % r , fontsize = 18, verticalalignment = 'center', horizontalalignment = 'center', color = 'k')\n ax[1].set_xlim(20, 55)\n ax[1].set_xticks(np.arange(20, 51, 10))\n leg.append(ax[1].legend(loc = 7, fontsize = 16, ncol = 1))\n ax[1].set_xlabel('Average Age', fontsize = fontsize)\n ax[1].text(13.5, 50, 'b', fontsize=fontsize+24, fontstyle='oblique')\n\n\n m,b,r,p,std_err = linregress(percent_in_school_list,attack_rates_list)\n y_theory = np.array([linear_function(a,m,b) for a in percent_in_school_list])\n ax[2].plot(percent_in_school_list, y_theory, color = 'k', lw = 1.5)\n ax[2].scatter(percent_in_school_list, attack_rates_list, marker='o', color=color_list, s=size)\n ax[2].text(20,73, r'$\\rho$ = ' + '%.2f' % r , fontsize = 18, verticalalignment = 'center', horizontalalignment = 'center', color = 'k')\n ax[2].set_xlim(10, 45)\n ax[2].set_xticks(np.arange(10, 50, 10))\n ax[2].set_xlabel('% In Educational Institutions', fontsize = fontsize)\n ax[2].text(3.5, 50, 'c', fontsize=fontsize+24, fontstyle='oblique')\n\n\n for country in ['Australia','Canada','China','Europe','India','Israel','Japan','Russia','South_Africa','United_States']:\n ax[2].scatter(0,0, color = country_colour_dic[country], s = size * 2, label = country.replace('-',' ').replace('_',' '))\n leg.append(ax[2].legend(loc = 7, fontsize = 17, ncol = 1, bbox_to_anchor = (0.6,0.4,1,0.2)))\n\n for i in range(len(ax)):\n ax[i].set_ylabel('Attack Rate (%)', fontsize = fontsize)\n ax[i].set_yticks(np.arange(55, 81, 5))\n ax[i].set_ylim(54, 80)\n ax[i].tick_params(labelsize=fontsize-2)\n ax[i].tick_params(axis='x', which='minor', bottom=False)\n ax[i].tick_params(axis='y', which='minor', left=False)\n leg[i].draw_frame(False)\n\n plt.minorticks_off()\n\n fig_path = os.path.join(figdir, 'fig_6.pdf')\n fig.savefig(fig_path, format='pdf')\n\n\n\nif __name__ == '__main__':\n \n reference_location = 'polymod_and_tomsk'\n reference_scenario = 'all_locations'\n\n beta = 0.04752\n susceptibility = 1.0\n gamma_inverse = 2.6\n num_agebrackets = 85\n\n countries = ['Australia', 'Canada', 'China', 'Europe', 'India', 'Israel', 'Japan', 'Russia', 'South_Africa', 'United_States']\n\n plot_fig(countries, reference_location, reference_scenario, beta, susceptibility, gamma_inverse, num_agebrackets)\n\n\n\n\n\n\n\n\n\n", "meta": {"hexsha": "ffc6b88d977bbccfc1e9301514b3a2d799bc9548", "size": 18802, "ext": "py", "lang": "Python", "max_stars_repo_path": "analysis_results/scripts/fig_6.py", "max_stars_repo_name": "DongxiaW/mixing-patterns", "max_stars_repo_head_hexsha": "e841a934b826ecc98bf443026c32e7c6b7aa75bc", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 30, "max_stars_repo_stars_event_min_datetime": "2020-03-03T07:05:19.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T22:40:49.000Z", "max_issues_repo_path": "analysis_results/scripts/fig_6.py", "max_issues_repo_name": "DongxiaW/mixing-patterns", "max_issues_repo_head_hexsha": "e841a934b826ecc98bf443026c32e7c6b7aa75bc", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 11, "max_issues_repo_issues_event_min_datetime": "2020-03-03T07:22:57.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-12T00:51:47.000Z", "max_forks_repo_path": "analysis_results/scripts/fig_6.py", "max_forks_repo_name": "DongxiaW/mixing-patterns", "max_forks_repo_head_hexsha": "e841a934b826ecc98bf443026c32e7c6b7aa75bc", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 13, "max_forks_repo_forks_event_min_datetime": "2020-12-10T08:39:15.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-16T00:12:54.000Z", "avg_line_length": 35.6774193548, "max_line_length": 263, "alphanum_fraction": 0.6642910329, "include": true, "reason": "import numpy,from scipy", "num_tokens": 4635, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5234203340678568, "lm_q2_score": 0.3702253786982541, "lm_q1q2_score": 0.19378349139863896}} {"text": "from __future__ import annotations\n\n\nfrom collections import Counter\nimport datetime as dt\nimport json\nimport math\nfrom queue import PriorityQueue\nfrom typing import Union, Optional, Tuple, cast, TYPE_CHECKING, Dict\n\nimport numpy as np\n\nfrom slim import logger, LoggableMixin\nfrom slim.simulation.config import Config\nfrom slim.types.TreatmentTypes import GeneticMechanism, Money, ChemicalTreatment, \\\n ThermalTreatment\nfrom slim.simulation.lice_population import (GenoDistrib, GrossLiceDistrib,\n LicePopulation, GenoTreatmentDistrib, GenoTreatmentValue,\n GenoLifeStageDistrib, largest_remainder, LifeStage, GenoDistribDict)\nfrom slim.types.QueueTypes import (DamAvailabilityBatch, EggBatch, TravellingEggBatch, TreatmentEvent,\n pop_from_queue)\nfrom slim.JSONEncoders import CustomFarmEncoder\n\nif TYPE_CHECKING: # pragma: no cover\n from slim.simulation.farm import Farm, GenoDistribByHatchDate\n\nOptionalDamBatch = Optional[DamAvailabilityBatch]\nOptionalEggBatch = Optional[EggBatch]\n\nclass Cage(LoggableMixin):\n \"\"\"\n Fish cages contain the fish.\n \"\"\"\n\n def __init__(self, cage_id: int, cfg: Config, farm: Farm,\n initial_lice_pop: Optional[GrossLiceDistrib] = None):\n \"\"\"\n Create a cage on a farm.\n\n :param cage_id: the label (id) of the cage within the farm\n :param cfg: the farm configuration\n :param farm: a Farm object\n :param initial_lice_pop: if provided, overrides default generated lice population\n \"\"\"\n super().__init__()\n\n self.cfg = cfg\n self.id = cage_id\n\n self.farm_id = farm.name\n self.start_date = cfg.farms[self.farm_id].cages_start[cage_id]\n self.date = cfg.start_date\n\n # TODO: update with calculations\n if initial_lice_pop is None:\n lice_population = {\"L1\": cfg.min_ext_pressure, \"L2\": 0, \"L3\": 0, \"L4\": 0, \"L5f\": 0,\n \"L5m\": 0}\n else:\n lice_population = initial_lice_pop\n\n self.farm = farm\n\n self.egg_genotypes = GenoDistrib()\n # TODO/Question: what's the best way to deal with having multiple possible genetic schemes?\n # TODO/Question: I suppose some of this initial genotype information ought to come from the config file\n # TODO/Question: the genetic mechanism will be the same for all lice in a simulation, so should it live in the driver?\n self.genetic_mechanism = self.cfg.genetic_mechanism\n\n geno_by_lifestage = {stage: GenoDistrib(self.cfg.initial_genetic_ratios).normalise_to(lice_population[stage])\n for stage in lice_population}\n\n self.lice_population = LicePopulation(geno_by_lifestage, self.cfg.initial_genetic_ratios)\n\n self.num_fish = cfg.farms[self.farm_id].num_fish\n self.num_infected_fish = self.get_mean_infected_fish()\n\n self.hatching_events: PriorityQueue[EggBatch] = PriorityQueue()\n self.arrival_events: PriorityQueue[TravellingEggBatch] = PriorityQueue()\n self.treatment_events: PriorityQueue[TreatmentEvent] = PriorityQueue()\n\n self.last_effective_treatment: Optional[TreatmentEvent] = None\n\n def to_json_dict(self):\n \"\"\"\n Create a JSON-serialisable dictionary version of a cage.\n \"\"\"\n filtered_vars = vars(self).copy()\n\n del filtered_vars[\"farm\"]\n del filtered_vars[\"cfg\"]\n del filtered_vars[\"logged_data\"]\n\n # May want to improve these or change them if we change the representation for genotype distribs\n # Note: JSON encoders do not allow a default() being run on the _keys_ of dictionaries\n # and GenotypePopulation is a dict subclass. The simplest option here is to trivially force to_json_dict()\n # whenever possible,\n filtered_vars[\"egg_genotypes\"] = self.egg_genotypes.to_json_dict()\n filtered_vars[\"lice_population\"] = self.lice_population.to_json_dict()\n filtered_vars[\"geno_by_lifestage\"] = self.lice_population.geno_by_lifestage.to_json_dict()\n filtered_vars[\"genetic_mechanism\"] = str(filtered_vars[\"genetic_mechanism\"])[len(\"GeneticMechanism.\"):]\n\n return filtered_vars\n\n def __str__(self):\n \"\"\"\n Get a human readable string representation of the cage in json form.\n :return: a description of the cage\n \"\"\"\n\n return json.dumps(self.to_json_dict(), cls=CustomFarmEncoder, indent=4)\n\n def update(\n self,\n cur_date: dt.datetime,\n pressure: int,\n ext_pressure_ratio: GenoDistribDict\n ) -> Tuple[GenoDistrib, Optional[dt.datetime], Money]:\n \"\"\"Update the cage at the current time step.\n\n :param cur_date: Current date of simulation\n :param pressure: External pressure, planctonic lice coming from the reservoir\n :param ext_pressure_ratio: The genotype ratio to use for the external pressure\n :return: Tuple (egg genotype distribution, hatching date, cost)\n \"\"\"\n\n self.clear_log()\n\n if cur_date >= self.start_date:\n logger.debug(\"\\tUpdating farm {} / cage {}\".format(self.farm_id, self.id))\n logger.debug(\"\\t\\tinitial fish population = {}\".format(self.num_fish))\n else:\n logger.debug(\"\\tUpdating farm {} / cage {} (non-operational)\".format(self.farm_id, self.id))\n\n logger.debug(\"\\t\\tinitial lice population = {}\".format(self.lice_population))\n\n logger.debug(f\"\\t\\tAdding {pressure} lice from external pressure\")\n\n # Background lice mortality events\n dead_lice_dist = self.get_background_lice_mortality()\n\n # Development events\n new_L2, new_L4, new_females, new_males = self.get_lice_lifestage(cur_date)\n\n # Lice coming from other cages and farms\n # NOTE: arrivals first then hatching\n hatched_arrivals_dist = self.get_arrivals(cur_date)\n\n # Egg hatching\n new_offspring_distrib = self.create_offspring(cur_date)\n\n # Lice coming from reservoir\n lice_from_reservoir = self.get_reservoir_lice(pressure, ext_pressure_ratio)\n logger.debug(f\"\\t\\tExternal pressure lice distribution = {lice_from_reservoir}\")\n\n if cur_date < self.start_date or self.is_fallowing:\n # Values that are not used before the start date\n treatment_mortality = self.lice_population.get_empty_geno_distrib()\n fish_deaths_natural, fish_deaths_from_lice = 0, 0\n num_infection_events = 0\n avail_dams_batch: OptionalDamBatch = None\n new_egg_batch: OptionalEggBatch = None\n cost = self.cfg.monthly_cost / 28\n\n else:\n # Events that happen when cage is populated with fish\n # (after start date)\n days_since_start = (cur_date - self.date).days\n\n # Treatment mortality events\n treatment_mortality, cost = self.get_lice_treatment_mortality(cur_date)\n\n # Fish growth and death\n fish_deaths_natural, fish_deaths_from_lice = self.get_fish_growth(days_since_start)\n\n # Infection events\n num_infection_events = self.do_infection_events(days_since_start)\n\n # Mating events that create eggs\n self.lice_population.free_dams(cur_date)\n delta_avail_dams, delta_eggs = self.do_mating_events(cur_date)\n avail_dams_batch = DamAvailabilityBatch(cur_date + dt.timedelta(days=self.cfg.dam_unavailability),\n delta_avail_dams)\n\n new_egg_batch = self.get_egg_batch(cur_date, delta_eggs)\n\n fish_deaths_from_treatment = self.get_fish_treatment_mortality(\n (cur_date - self.start_date).days,\n fish_deaths_from_lice,\n fish_deaths_natural\n )\n\n self.update_deltas(\n dead_lice_dist,\n treatment_mortality,\n fish_deaths_natural,\n fish_deaths_from_lice,\n fish_deaths_from_treatment,\n new_L2,\n new_L4,\n new_females,\n new_males,\n num_infection_events,\n lice_from_reservoir,\n avail_dams_batch,\n new_offspring_distrib,\n hatched_arrivals_dist,\n )\n\n logger.debug(\"\\t\\tfinal lice population= {}\".format(self.lice_population))\n\n egg_distrib = GenoDistrib()\n hatch_date: Optional[dt.datetime] = None\n if cur_date >= self.start_date and new_egg_batch:\n logger.debug(\"\\t\\tfinal fish population = {}\".format(self.num_fish))\n egg_distrib = new_egg_batch.geno_distrib\n hatch_date = new_egg_batch.hatch_date\n logger.debug(\"\\t\\tlice offspring = {}\".format(sum(egg_distrib.values())))\n\n assert egg_distrib.is_positive()\n return egg_distrib, hatch_date, cost\n\n def get_temperature(self, cur_date: dt.datetime) -> float:\n cur_month = cur_date.month\n return self.farm.year_temperatures[cur_month - 1]\n\n def get_lice_treatment_mortality_rate(self, cur_date: dt.datetime) -> GenoTreatmentDistrib:\n \"\"\"Check if the cage is currently being treated. If yes, calculate the treatment rates.\n Note: this method consumes the internal treatment event queue.\n\n :param cur_date: the current date\n :returns: the mortality rates broken down by geno data.\n \"\"\"\n susceptible_populations = [self.lice_population.geno_by_lifestage[stage] for stage in LicePopulation.susceptible_stages]\n num_susc_per_geno = cast(GenoDistrib, GenoDistrib.batch_sum(susceptible_populations))\n\n geno_treatment_distrib = {geno: GenoTreatmentValue(0.0, 0) for geno in num_susc_per_geno}\n\n def cts(event):\n nonlocal self\n self.last_effective_treatment = event\n\n pop_from_queue(self.treatment_events, cur_date, cts)\n\n # if no treatment has been applied check if the previous treatment is still effective\n if self.last_effective_treatment is None or \\\n self.last_effective_treatment.affecting_date > cur_date or \\\n cur_date > self.last_effective_treatment.treatment_window:\n return geno_treatment_distrib\n\n treatment_type = self.last_effective_treatment.treatment_type\n ave_temp = self.get_temperature(cur_date)\n\n logger.debug(\"\\t\\ttreating farm {}/cage {} on date {}\".format(self.farm_id,\n self.id, cur_date))\n\n geno_treatment_distrib = self.cfg.get_treatment(treatment_type).get_lice_treatment_mortality_rate(self.lice_population, ave_temp)\n\n return geno_treatment_distrib\n\n def get_lice_treatment_mortality(self, cur_date) -> Tuple[GenoLifeStageDistrib, Money]:\n \"\"\"\n Calculate the number of lice in each stage killed by treatment.\n\n Note: this method consumes the internal event queue\n\n :param cur_date: the current date\n \"\"\"\n\n dead_lice_dist = self.lice_population.get_empty_geno_distrib()\n\n dead_mortality_distrib = self.get_lice_treatment_mortality_rate(cur_date)\n\n cost = Money(\"0.00\")\n\n for geno, (mortality_rate, num_susc) in dead_mortality_distrib.items():\n if mortality_rate > 0:\n num_dead_lice = self.cfg.rng.poisson(mortality_rate * num_susc)\n num_dead_lice = min(num_dead_lice, num_susc)\n\n # We emulate the top algorithm with a multivariate hypergeom distrib\n population_by_stages = np.array([self.lice_population.geno_by_lifestage[stage][geno]\n for stage in LicePopulation.susceptible_stages])\n\n # TODO: why is num_dead_lice not clamped?\n num_dead_lice = min(population_by_stages.sum(), num_dead_lice)\n dead_lice_nums = self.cfg.rng.multivariate_hypergeometric(\n population_by_stages, num_dead_lice).tolist()\n for stage, dead_lice_num in zip(LicePopulation.susceptible_stages, dead_lice_nums):\n dead_lice_dist[stage][geno] = dead_lice_num\n\n logger.debug(\"\\t\\tdistribution of dead lice on farm {}/cage {} = {}\"\n .format(self.farm_id, self.id, dead_lice_dist))\n\n # Compute cost\n if self.last_effective_treatment is not None and self.last_effective_treatment.end_application_date > cur_date:\n treatment_type = self.last_effective_treatment.treatment_type\n treatment_cfg = self.cfg.get_treatment(treatment_type)\n cage_days = (cur_date - self.start_date).days\n if isinstance(treatment_cfg, ChemicalTreatment):\n cost = treatment_cfg.price_per_kg * int(self.average_fish_mass(cage_days) / 1e3)\n elif isinstance(treatment_cfg, ThermalTreatment):\n cost = treatment_cfg.price_per_application\n\n return dead_lice_dist, cost\n\n def get_stage_ages_distrib(self, stage: str, temp_c: float = 10.0):\n \"\"\"\n Create an age distribution (in days) for the sea lice within a lifecycle stage.\n\n This distribution is computed by using a simplified version of formulae (4), (6), (8)\n in Aldrin et al.: we assume that all lice of a stage m-1 that evolve at stage m\n will be put at a stage-age of 0, and that this is going to be a constant/stable\n amount.\n \"\"\"\n\n stage_age_max_days = int(self.cfg.stage_age_evolutions[stage])\n\n if stage in (\"L2\", \"L5f\"):\n # Bogus uniform distribution L5m/L5f follow different schemes.\n # More realistically, this is an exponential/poisson distribution\n return np.full(stage_age_max_days, 1/stage_age_max_days)\n\n delta_p = self.cfg.delta_p[stage]\n delta_m10 = self.cfg.delta_m10[stage]\n delta_s = self.cfg.delta_s[stage]\n\n ages = np.arange(stage_age_max_days)\n\n weibull_median_rates = self._dev_rates(delta_p, delta_m10, delta_s, temp_c, ages)\n\n probas = np.empty_like(ages, dtype=np.float64)\n probas[0] = 1.0\n for i in range(1, stage_age_max_days):\n probas[i] = probas[i-1] * (1.0 - weibull_median_rates[i-1])\n\n return probas / np.sum(probas)\n\n @staticmethod\n def _dev_rates(del_p: float, del_m10: float, del_s: float, temp_c: float, ages: np.ndarray):\n \"\"\"\n Probability of developing after n_days days in a stage as given by Aldrin et al 2017\n See section 2.2.4 of Aldrin et al. (2017)\n :param del_p: power transformation constant on temp_c\n :param del_m10: 10 °C median reference value\n :param del_s: fitted Weibull shape parameter\n :param temp_c: average temperature in °C\n :param ages: stage-age\n :return: expected development rate\n \"\"\"\n epsilon = np.float64(1e-30)\n del_m = del_m10 * (10 / temp_c) ** del_p\n\n unbounded = np.clip(np.log(2) * del_s * ages ** (del_s - 1) * del_m ** (-del_s), epsilon, np.float64(1.0))\n return unbounded\n\n def get_lice_lifestage(self, cur_date: dt.datetime) -> Tuple[int, int, int, int]:\n \"\"\"\n Move lice between lifecycle stages.\n See Section 2.1 of Aldrin et al. (2017)\n\n :param cur_date: the current date\n :returns: a tuple (new_l2, new_l4, new_l5f, new_l5m)\n \"\"\"\n logger.debug(\"\\t\\tupdating lice lifecycle stages\")\n\n def evolve_next_stage(stage: LifeStage, temp_c: float) -> int:\n # weibull params\n del_p = self.cfg.delta_p[stage]\n del_m10 = self.cfg.delta_m10[stage]\n del_s = self.cfg.delta_s[stage]\n num_lice = self.lice_population[stage]\n if num_lice == 0:\n return 0\n max_dev_time = self.cfg.stage_age_evolutions[stage]\n ages_distrib = self.get_stage_ages_distrib(stage, temp_c)\n # let us sample from 1000 lice\n ages = self.cfg.rng.choice(np.arange(max_dev_time), 1000, p=ages_distrib)\n\n evolution_rates = self._dev_rates(del_p, del_m10, del_s, temp_c, ages)\n average_rates = np.mean(evolution_rates)\n\n # print(f\"Stage {stage} -> {average_rates}\")\n\n return round(num_lice * average_rates) #int(min(self.cfg.rng.poisson(num_lice * average_rates), num_lice))\n\n lice_dist = {}\n ave_temp = self.get_temperature(cur_date)\n\n # L4 -> L5\n l4_to_l5 = evolve_next_stage(\"L4\", ave_temp)\n new_females = int(self.cfg.rng.choice([math.floor(l4_to_l5 / 2.0), math.ceil(l4_to_l5 / 2.0)]))\n new_males = (l4_to_l5 - new_females)\n\n lice_dist[\"L5f\"] = new_females\n lice_dist[\"L5m\"] = new_males\n\n # L3 -> L4\n new_L4 = lice_dist[\"L4\"] = evolve_next_stage(\"L3\", ave_temp)\n\n # L2 -> L3 is done in do_infection_events(). Indeed, evolution from L2 to L3 is (virtually) age-independent\n\n # L1 -> L2\n new_L2 = lice_dist[\"L2\"] = evolve_next_stage(\"L1\", ave_temp)\n\n logger.debug(\"\\t\\t\\tdistribution of new lice lifecycle stages on farm {}/cage {} = {}\"\n .format(self.farm_id, self.id, lice_dist))\n\n return new_L2, new_L4, new_females, new_males\n\n def get_fish_treatment_mortality(\n self,\n days_since_start: int,\n fish_lice_deaths: int,\n fish_backgroud_deaths: int) -> int:\n \"\"\"\n Get fish mortality due to treatment. Mortality due to treatment is defined in terms of\n point percentage increases, thus we can only account for \"excess deaths\".\n If treatment is not being applied the overall\n\n :param days_since_start: the number of days since the beginning of the simulation\n :param fish_lice_deaths: the number of fish dead by lice\n :param fish_background_deaths: the number of fish dead by natural reasons\n\n :returns: number of fish death events\n \"\"\"\n # See surveys/overton_treatment_mortalities.py for an explanation on what is going on\n mortality_events = fish_lice_deaths + fish_backgroud_deaths\n\n if mortality_events == 0 or self.num_fish == 0:\n return 0\n\n cur_date = self.start_date + dt.timedelta(days=days_since_start)\n if not self.is_treated(cur_date):\n return 0\n\n efficacy_window = self.last_effective_treatment.effectiveness_duration_days\n\n temperature = self.get_temperature(cur_date)\n fish_mass = self.average_fish_mass(days_since_start)\n\n last_treatment_params = self.cfg.get_treatment(self.last_effective_treatment.treatment_type)\n predicted_deaths = last_treatment_params.get_fish_mortality_occurrences(\n temperature, fish_mass, self.num_fish, efficacy_window, mortality_events)\n\n treatment_mortality_occurrences = round(predicted_deaths)\n\n return treatment_mortality_occurrences\n\n def get_fish_growth(self, days_since_start) -> Tuple[int, int]:\n \"\"\"\n Get the number of fish that get killed either naturally or by lice.\n\n :param: days_since_start: the number of days since the beginning.\n :returns: a tuple (natural_deaths, lice_induced_deaths, lice_deaths)\n \"\"\"\n\n logger.debug(\"\\t\\tupdating fish population\")\n\n def fb_mort(days):\n \"\"\"\n Fish background mortality rate, decreasing as in Soares et al 2011\n\n Fish death rate: constant background daily rate 0.00057 originally based on\n www.gov.scot/Resource/0052/00524803.pdf\n\n According to Volsett it should be higher (around 0.005) , but that's unlikely.\n However the authors used a trick: assuming that a mortality event takes 5 days one can\n divide the actual mortality rate by 5.\n Thus, 0.005 / 5 ~~ 0.0009-0.001 . It is still quite higher than expected.\n\n Therefore, we'll stick to this constant.\n TODO: what should we do with the formulae?\n\n :param days: number of days elapsed\n :return: fish background mortality rate\n \"\"\"\n return 0.000057 # (1000 + (days - 700)**2)/490000000\n\n # Apply a sigmoid based on the number of lice per fish\n pathogenic_lice = sum([self.lice_population[stage] for stage in LicePopulation.pathogenic_stages])\n if self.num_infected_fish > 0:\n lice_per_host_mass = pathogenic_lice / (self.num_infected_fish *\n (self.average_fish_mass(days_since_start) / 1e3))\n else:\n lice_per_host_mass = 0.0\n\n # The daily mortality rate also takes into account a mortality event takes days (in this case, 5).\n prob_lice_death = 0.2 / (1 + math.exp(-self.cfg.fish_mortality_k *\n (lice_per_host_mass - self.cfg.fish_mortality_center)))\n\n ebf_death = fb_mort(days_since_start) * self.num_fish\n elf_death = self.num_infected_fish * prob_lice_death\n fish_deaths_natural = round(ebf_death) # self.cfg.rng.poisson(ebf_death)\n fish_deaths_from_lice = round(elf_death) # self.cfg.rng.poisson(elf_death)\n\n logger.debug(\"\\t\\t\\tnumber of background fish death {}, from lice {}\"\n .format(fish_deaths_natural, fish_deaths_from_lice))\n\n return fish_deaths_natural, fish_deaths_from_lice\n\n def compute_eta_aldrin(self, num_fish_in_farm, days):\n return self.cfg.infection_main_delta + math.log(num_fish_in_farm/1e5) + self.cfg.infection_weight_delta * \\\n (math.log(self.average_fish_mass(days)/1e3) - self.cfg.delta_expectation_weight_log)\n\n def get_infection_rates(self, days_since_start) -> Tuple[float, int]:\n \"\"\"\n Compute the number of lice that can infect and what their infection rate (number per fish) is\n\n :param days_since_start: days since the cage has opened\n\n :returns: a pair (Einf, num_avail_lice)\n \"\"\"\n\n # Based on Aldrin et al.\n # Perhaps we can have a distribution which can change per day (the mean/median increaseѕ?\n # but at what point does the distribution mean decrease)./\n age_distrib = self.get_stage_ages_distrib(\"L2\")\n num_avail_lice = round(self.lice_population[\"L2\"] * np.sum(age_distrib[1:]))\n if num_avail_lice > 0:\n num_fish_in_farm = self.farm.num_fish\n\n # TODO: this has O(c^2) complexity\n etas = np.array([c.compute_eta_aldrin(num_fish_in_farm, days_since_start) for c in self.farm.cages])\n Einf = math.exp(etas[self.id]) / (1 + np.sum(np.exp(etas)))\n\n return Einf, num_avail_lice\n\n return 0.0, num_avail_lice\n\n def do_infection_events(self, days: int) -> int:\n \"\"\"Infect fish in this cage if the sea lice are in stage L2 and at least 1 day old\n\n :param cur_date: current date of simulation\n :param days: days the number of days elapsed\n\n :return: number of evolving lice, or equivalently the new number of infections\n \"\"\"\n Einf, num_avail_lice = self.get_infection_rates(days)\n\n if Einf == 0:\n return 0\n\n expected_events = Einf * num_avail_lice\n\n inf_events = self.cfg.rng.poisson(expected_events)\n\n return min(inf_events, num_avail_lice)\n\n def get_infecting_population(self, *args) -> int:\n if args is None or len(args) == 0:\n infective_stages = [\"L3\", \"L4\", \"L5m\", \"L5f\"]\n else:\n infective_stages = list(args)\n return sum(self.lice_population[stage] for stage in infective_stages)\n\n def get_mean_infected_fish(self, *args) -> int:\n \"\"\"\n Get the average number of infected fish.\n\n :param \\*args: the stages to consider (optional, by default all stages from the third onward are taken into account)\n\n :returns: the number of infected fish\n \"\"\"\n if self.num_fish == 0:\n return 0\n\n attached_lice = self.get_infecting_population(*args)\n\n # see: https://stats.stackexchange.com/a/296053\n num_infected_fish = int(self.num_fish * (1 - ((self.num_fish - 1) / self.num_fish) ** attached_lice))\n return num_infected_fish\n\n def get_variance_infected_fish(self, n: int, k: int) -> float:\n # Rationale: assuming that we generate N bins that sum to K, we can model this as a multinomial distribution\n # where all p_i are the same. Therefore, the variance of each bin is k*(n-1)/(n**2)\n # Because we are considering the total variance of k events at the same time we need to multiply by k,\n # thus yielding k**2*(n-1)/(n**2).\n\n if n == 0:\n return 0.0\n return k**2 * (n - 1) / (n ** 2)\n\n def get_num_matings(self) -> int:\n \"\"\"\n Get the number of matings. Implement Cox's approach assuming an unbiased sex distribution\n \"\"\"\n\n # Background: AF and AM are randomly assigned to fish according to a negative multinomial distribution.\n # What we want is determining what is the expected likelihood there is _at least_ one AF and _at\n # least_ one AM on the same fish.\n\n males = self.lice_population[\"L5m\"]\n females = self.lice_population.available_dams.gross\n\n if males == 0 or females == 0:\n return 0\n\n # VMR: variance-mean ratio; VMR = m/k + 1 -> k = m / (VMR - 1) with k being an \"aggregation factor\"\n mean = (males + females) / self.get_mean_infected_fish(\"L5m\", \"L5f\")\n\n n = self.num_fish\n k = self.get_infecting_population(\"L5m\", \"L5f\")\n variance = self.get_variance_infected_fish(n, k)\n vmr = variance / mean\n if vmr <= 1.0:\n return 0\n aggregation_factor = mean / (vmr - 1)\n\n prob_matching = 1 - (1 + males / ((males + females) * aggregation_factor)) ** (-1 - aggregation_factor)\n # TODO: using a poisson distribution can lead to a high std for high prob*females\n return int(np.clip(self.cfg.rng.poisson(prob_matching * females), np.int32(0), np.int32(min(males, females))))\n\n def do_mating_events(self, cur_date) -> Tuple[GenoDistrib, GenoDistrib]:\n \"\"\"\n Will generate two deltas: one to add to unavailable dams and subtract from available dams, one to add to eggs\n Assume males don't become unavailable? in this case we don't need a delta for sires\n\n :param cur_date: the current date\n\n :returns: a pair (mating_dams, new_eggs)\n \"\"\"\n\n delta_eggs = GenoDistrib()\n num_matings = self.get_num_matings()\n\n distrib_sire_available = self.lice_population.geno_by_lifestage[\"L5m\"]\n distrib_dam_available = self.lice_population.available_dams\n\n mating_dams = self.select_lice(distrib_dam_available, num_matings)\n mating_sires = self.select_lice(distrib_sire_available, num_matings)\n\n if distrib_sire_available.gross == 0 or distrib_dam_available.gross == 0:\n return GenoDistrib(), GenoDistrib()\n\n num_eggs = self.get_num_eggs(num_matings)\n if self.genetic_mechanism == GeneticMechanism.DISCRETE:\n delta_eggs = self.generate_eggs_discrete_batch(mating_sires, mating_dams, num_eggs)\n elif self.genetic_mechanism == GeneticMechanism.MATERNAL:\n delta_eggs = self.generate_eggs_maternal_batch(distrib_dam_available, num_eggs)\n\n delta_eggs = self.mutate(delta_eggs, mutation_rate=self.cfg.geno_mutation_rate)\n\n return mating_dams, delta_eggs\n\n def generate_eggs_discrete_batch(self, sire_distrib: GenoDistrib, dam_distrib: GenoDistrib,\n number_eggs: int) -> GenoDistrib:\n \"\"\"\n Get number of eggs based on discrete genetic mechanism.\n\n The algorithm emulates the following scenario: each sire s_i is sampled from sire_distrib\n and will have a given genomic :math:`g_{s_i}` and similarly a dam :math:`d_i` will have a genotype :math:`g_{d_i}`.\n Because the genomic of a lice can only be dominant, recessive or partial dominant then\n the mating will result in one of these happening depending on the usual Mendelevian\n mechanism.\n The algorithm terminates when all sires and dams have been mated.\n Here we emulate such sampling strategy via a O(1) algorithm as follows: we compute\n the probabilities of each combination arising and adopt a multinomial distribution\n in order to achieve a given number of eggs.\n The rationale for the formulae used here is the following:\n\n - to get an A (dominant) one needs a combination of dominant and dominant allele, or dominant and the right half of partially dominant genes;\n\n - to get an a (recessive) one does the same as above, but with fully recessive alleles instead;\n\n - to get a partially dominant one, we use the inclusion-exclusion principle and subtract the cases above from all the possible pairings.\n\n Together with being fast, this approach naturally models statistical uncertainty compared\n to a perfect Mendelevian split. Unfortunately it does not naturally include mutation\n to non-existent strains (e.g. a mating between pure dominant lice distributions can never\n yield partial dominance or recessive genomics in the offspring).\n\n :param sire_distrib: the genotype distribution of the sires\n :param dam_distrib: the genotype distribution of the eggs\n :param number_eggs: the total number of eggs\n\n :returns: the newly sampled eggs as a :class:`GenoDistrib`.\n \"\"\"\n\n assert sire_distrib.gross == dam_distrib.gross\n\n keys = [('A',), ('a',), ('A', 'a')]\n x1, y1, z1 = tuple(sire_distrib[k] for k in keys)\n x2, y2, z2 = tuple(dam_distrib[k] for k in keys)\n\n N_A = (x1 + 1/2*z1)*(x2+1/2*z2)\n N_a = (y1 + 1/2*z1)*(y2+1/2*z2)\n denom = sire_distrib.gross * dam_distrib.gross\n N_Aa = denom - N_A - N_a\n\n if denom == 0:\n return GenoDistrib()\n\n # We need to follow GenoDistrib's ordering now\n p = np.array([N_a, N_Aa, N_A]) / denom\n\n return GenoDistrib.from_ratios(number_eggs, p, self.cfg.rng)\n\n @staticmethod\n def generate_eggs_maternal_batch(dams: GenoDistrib, number_eggs: int) -> GenoDistrib:\n \"\"\"Get number of eggs based on maternal genetic mechanism.\n\n Maternal-only inheritance - all eggs have mother's genotype.\n\n :param dam: the genomics of the dams\n :param number_eggs: the number of eggs produced\n :return: genomics distribution of eggs produced\n \"\"\"\n return dams.normalise_to(number_eggs)\n\n def mutate(self, eggs: GenoDistrib, mutation_rate: float) -> GenoDistrib:\n \"\"\"\n Mutate the genotype distribution\n\n :param eggs: the genotype distribution of the newly produced eggs\n :param mutation_rate: the rate of mutation with respect to the number of eggs.\n \"\"\"\n if mutation_rate == 0:\n return eggs\n\n mutations = self.cfg.rng.poisson(mutation_rate * sum(eggs.values()))\n\n # generate a \"swap\" matrix\n # rationale: since ('a',) actually represents a pair of genes ('a', 'a')\n # there are only three directions: R->ID, ID->D, ID->R, D->ID. Note that\n # R->D or D->R are impossible via a single mutation.\n # Self-mutations are ignored.\n # To model this, we create a \"masking\" swapping matrix and force to 0 masked entries\n # and make sure they cannot be selected.\n\n alleles = [('a',), ('A',), ('A', 'a')]\n n = len(alleles)\n mask_matrix = np.array([[0, 0, 1],\n [0, 0, 1],\n [1, 1, 0]])\n\n p = mask_matrix.flatten() / np.sum(mask_matrix)\n\n # since I can't really be bothered to avoid negative mutations, we simply roll the dice every time until we get\n # a favourable outcome. Not ideal, but it works...\n\n while True:\n swap_matrix = self.cfg.rng.multinomial(mutations, p).reshape(n, n)\n result = eggs.copy()\n for idx, allele in enumerate(alleles):\n to_add = np.sum(swap_matrix[idx, :]) - np.sum(swap_matrix[:, idx])\n result[allele] += to_add\n if result[allele] == 0:\n del result[allele]\n if result.is_positive():\n break\n\n return result\n\n def select_lice(self, distrib_lice_available: GenoDistrib, num_lice: int) -> GenoDistrib:\n \"\"\"\n From a geno distribution of eligible lice sample a given Genotype distribution\n\n Note: this is very similar to GenoDistrib.normalise_to() but performs an explicit\n sampling.\n\n TODO: should we integrate this into GenoDistrib class\n\n :param distrib_lice_available: the starting dam genomic distribution\n :param num_lice: the wished number of dams to sample\n \"\"\"\n # TODO: this function is flexible enough to be renamed and used elsewhere\n if sum(distrib_lice_available.values()) <= num_lice:\n return distrib_lice_available.copy()\n\n # \"we need to select k lice from the given population broken down into different allele\n # bins and subtract\" -> \"select :math:`n` balls from the following :math`N_1, ..., N_k` bins without\n # replacement -> use a multivariate hypergeometric distribution\n lice_as_list = self.cfg.rng.multivariate_hypergeometric(\n list(distrib_lice_available.values()), num_lice)\n selected_lice = GenoDistrib(dict(zip(distrib_lice_available.keys(),\n lice_as_list)))\n\n return selected_lice\n\n def get_num_eggs(self, mated_females) -> int:\n \"\"\"\n Get the number of new eggs\n\n :param mated_females: the number of mated females that reproduce\n\n :returns: the number of eggs produced\n \"\"\"\n\n # See Aldrin et al. 2017, §2.2.6\n age_distrib = self.get_stage_ages_distrib(\"L5f\")\n age_range = np.arange(1, len(age_distrib) + 1)\n\n mated_females_distrib = mated_females * age_distrib\n\n # Hatching time is already covered in get_egg_batch\n eggs = self.cfg.reproduction_eggs_first_extruded * \\\n (age_range ** self.cfg.reproduction_age_dependence) * mated_females_distrib\n\n return int(np.round(np.sum(eggs)))\n\n def get_egg_batch(self, cur_date: dt.datetime, egg_distrib: GenoDistrib) -> EggBatch:\n \"\"\"\n Get the expected arrival date of an egg batch\n\n :param cur_date: the current time\n :param egg_distrib: the egg distribution\n\n :returns: EggBatch representing egg distribution and expected hatching date\n \"\"\"\n\n # We use Stien et al (2005)'s regressed formula\n # τE= [β1/(T – 10 + β1β2)]**2 (see equation 8)\n # where β2**(-2) is the average temperature centered at around 10 degrees\n # and β1 is a shaping factor. This function is formally known as Belehrádek’s function\n cur_month = cur_date.month\n ave_temp = self.get_temperature(cur_date)\n\n beta_1 = self.cfg.delta_m10[\"L0_stien\"]\n beta_2 = self.cfg.delta_p[\"L0\"]\n expected_time = (beta_1 / (ave_temp - 10 + beta_1 * beta_2)) ** 2\n expected_hatching_date = cur_date + dt.timedelta(self.cfg.rng.poisson(expected_time))\n return EggBatch(expected_hatching_date, egg_distrib)\n\n def create_offspring(self, cur_time: dt.datetime) -> GenoDistrib:\n \"\"\"\n Hatch the eggs from the event queue\n\n :param cur_time: the current time\n\n :returns: a delta egg genomics\n \"\"\"\n\n delta_egg_offspring = GenoDistrib({geno: 0 for geno in self.cfg.initial_genetic_ratios})\n\n def cts(hatching_event: EggBatch):\n nonlocal delta_egg_offspring\n delta_egg_offspring += hatching_event.geno_distrib\n\n pop_from_queue(self.hatching_events, cur_time, cts)\n return delta_egg_offspring\n\n def get_arrivals(self, cur_date: dt.datetime) -> GenoDistrib:\n \"\"\"Process the arrivals queue.\n\n :param cur_date: Current date of simulation\n\n :returns: Genotype distribution of eggs hatched in travel\n \"\"\"\n\n hatched_dist = GenoDistrib()\n\n # check queue for arrivals at current date\n def cts(batch: TravellingEggBatch):\n nonlocal self\n nonlocal hatched_dist\n\n # if the hatch date is after current date, add to stationary egg queue\n if batch.hatch_date >= cur_date:\n stationary_batch = EggBatch(batch.hatch_date, batch.geno_distrib)\n self.hatching_events.put(stationary_batch)\n\n # otherwise the egg has hatched during travel, so determine the life stage\n # and add to population\n else:\n # TODO: determine life stage it arrives at; assumes all are L1 for now\n hatched_dist = batch.geno_distrib\n\n pop_from_queue(self.arrival_events, cur_date, cts)\n\n return hatched_dist\n\n def get_dying_lice_from_dead_fish(self, num_dead_fish: int) -> GrossLiceDistrib:\n \"\"\"\n Get the number of lice that die when fish die.\n\n :param num_dead_fish: the number of dead fish\n :returns: a gross distribution\n \"\"\"\n\n # Note: no paper actually provides a clear guidance on this.\n # This is mere speculation.\n # Basically, only consider PA and A males (for L4m = 0.5*L4)\n # as potentially able to survive and find a new host.\n # Only a fixed proportion can survive.\n\n if self.get_infecting_population() == 0 or self.num_infected_fish == 0:\n return {}\n\n affected_lice_gross = round(self.get_infecting_population() *\n num_dead_fish / self.num_infected_fish)\n infecting_lice = self.get_infecting_population()\n\n affected_lice_quotas = np.array([self.lice_population[stage] / infecting_lice * affected_lice_gross\n for stage in LicePopulation.susceptible_stages])\n affected_lice_np = largest_remainder(affected_lice_quotas)\n\n affected_lice = Counter(dict(zip(LicePopulation.susceptible_stages, affected_lice_np.tolist())))\n\n surviving_lice_quotas = np.rint(np.trunc([\n self.lice_population['L4'] / (2 * infecting_lice) *\n affected_lice_gross * self.cfg.male_detachment_rate,\n self.lice_population['L5m'] / infecting_lice *\n affected_lice_gross * self.cfg.male_detachment_rate,\n ]))\n surviving_lice = Counter(dict(zip(['L4', 'L5m'], surviving_lice_quotas.tolist())))\n\n dying_lice = affected_lice - surviving_lice\n\n dying_lice_distrib = {k: int(v) for k, v in dying_lice.items() if v > 0}\n logger.debug(f\"\\t\\tLice mortality due to fish mortality: {dying_lice_distrib}\")\n return dying_lice_distrib\n\n def promote_population(\n self,\n prev_stage: Union[str, GenoDistrib],\n cur_stage: str,\n leaving_lice: int,\n entering_lice: Optional[int] = None\n ):\n \"\"\"\n Promote the population by stage and respect the genotypes\n\n :param prev_stage: the lice stage from which cur_stage evolves\n :param cur_stage: the lice stage that is about to evolve\n :param leaving_lice: the number of lice in the _cur_stage=>next_stage_ progression\n :param entering_lice: the number of lice in the _prev_stage=>cur_stage_ progression. If _prev_stage_ is a a string, _entering_lice_ must be an _int_\n \"\"\"\n if isinstance(prev_stage, str):\n if entering_lice is not None:\n prev_stage_geno = self.lice_population.geno_by_lifestage[prev_stage]\n entering_geno_distrib = prev_stage_geno.normalise_to(entering_lice)\n else:\n raise ValueError(\"entering_lice must be an int when prev_stage is a str\")\n else:\n entering_geno_distrib = prev_stage\n cur_stage_geno = self.lice_population.geno_by_lifestage[cur_stage]\n\n leaving_geno_distrib = cur_stage_geno.normalise_to(leaving_lice)\n cur_stage_geno = cur_stage_geno + entering_geno_distrib - leaving_geno_distrib\n\n # update gross population. This is a bit hairy but I cannot think of anything simpler.\n self.lice_population.geno_by_lifestage[cur_stage] = cur_stage_geno\n\n def update_deltas(\n self,\n dead_lice_dist: GrossLiceDistrib,\n treatment_mortality: GenoLifeStageDistrib,\n fish_deaths_natural: int,\n fish_deaths_from_lice: int,\n fish_deaths_from_treatment: int,\n new_L2: int,\n new_L4: int,\n new_females: int,\n new_males: int,\n new_infections: int,\n lice_from_reservoir: Dict[LifeStage, GenoDistrib],\n delta_dams_batch: OptionalDamBatch,\n new_offspring_distrib: GenoDistrib,\n hatched_arrivals_dist: GenoDistrib,\n ):\n \"\"\"Update the number of fish and the lice in each life stage\n\n :param dead_lice_dist: the number of dead lice due to background death (as a distribution)\n :param treatment_mortality: the distribution of genotypes being affected by treatment\n :param fish_deaths_natural: the number of natural fish death events\n :param fish_deaths_from_lice: the number of lice-induced fish death events\n :param fish_deaths_from_treatment: the number of treatment-induced fish death events\n :param new_L2: number of new L2 fish\n :param new_L4: number of new L4 fish\n :param new_females: number of new adult females\n :param new_males: number of new adult males\n :param new_infections: the number of new infections (i.e. progressions from L2 to L3)\n :param lice_from_reservoir: the number of lice taken from the reservoir\n :param delta_dams_batch: the genotypes of now-unavailable females in batch events\n :param new_offspring_distrib: the new offspring obtained from hatching and migrations\n :param hatched_arrivals_dist: new offspring obtained from arrivals\n \"\"\"\n\n # Update dead_lice_dist to include fish-caused death as well\n dead_lice_by_fish_death = self.get_dying_lice_from_dead_fish(\n min(fish_deaths_natural + fish_deaths_from_lice, self.num_infected_fish))\n for affected_stage, reduction in dead_lice_by_fish_death.items():\n dead_lice_dist[affected_stage] += reduction\n\n for stage in self.lice_population:\n # update background mortality\n bg_delta = self.lice_population[stage] - dead_lice_dist[stage]\n self.lice_population[stage] = max(0, bg_delta)\n\n # update population due to treatment\n # TODO: __isub__ here is broken\n self.lice_population.geno_by_lifestage[stage] = self.lice_population.geno_by_lifestage[stage] - \\\n treatment_mortality[stage]\n\n self.lice_population.remove_negatives()\n\n self.promote_population(\"L4\", \"L5m\", 0, new_males)\n self.promote_population(\"L4\", \"L5f\", 0, new_females)\n self.promote_population(\"L3\", \"L4\", new_males + new_females, new_L4)\n self.promote_population(\"L2\", \"L3\", new_L4, new_infections)\n self.promote_population(\"L1\", \"L2\", new_infections, new_L2)\n\n self.promote_population(new_offspring_distrib, \"L1\", new_L2, None)\n self.promote_population(hatched_arrivals_dist, \"L1\", 0, None)\n\n self.lice_population.remove_negatives()\n\n # in absence of wildlife genotype, simply upgrade accordingly\n self.lice_population.geno_by_lifestage[\"L2\"] += lice_from_reservoir[\"L2\"]\n self.lice_population.geno_by_lifestage[\"L1\"] += lice_from_reservoir[\"L1\"]\n\n if delta_dams_batch:\n self.lice_population.add_busy_dams_batch(delta_dams_batch)\n\n self.num_fish -= (fish_deaths_natural + fish_deaths_from_lice + fish_deaths_from_treatment)\n if self.num_fish < 0:\n self.num_fish = 0\n\n # treatment may kill some lice attached to the fish, thus update at the very end\n self.num_infected_fish = self.get_mean_infected_fish()\n\n # TODO: update arrivals dict type\n def update_arrivals(self, arrivals_dict: GenoDistribByHatchDate, arrival_date: dt.datetime):\n \"\"\"Update the arrivals queue\n\n :param arrivals_dict: List of dictionaries of genotype distributions based on hatch date\n :param arrival_date: Arrival date at this cage\n \"\"\"\n\n for hatch_date in arrivals_dict:\n\n # skip if there are no eggs in the dictionary\n if sum(arrivals_dict[hatch_date].values()) == 0:\n continue\n\n # create new travelling batch and update the queue\n batch = TravellingEggBatch(arrival_date, hatch_date, arrivals_dict[hatch_date])\n self.arrival_events.put(batch)\n\n def get_background_lice_mortality(self) -> GrossLiceDistrib:\n \"\"\"\n Background death in a stage (remove entry) -> rate = number of\n individuals in stage*stage rate (nauplii 0.17/d, copepods 0.22/d,\n pre-adult female 0.05, pre-adult male ... Stien et al 2005)\n\n :returns: the current background mortality. The return value is genotype-agnostic\n\n \"\"\"\n # TODO: this is dumb\n lice_mortality_rates = self.cfg.background_lice_mortality_rates\n lice_population = self.lice_population\n\n dead_lice_dist = {}\n for stage in lice_population:\n mortality_rate = lice_population[stage] * lice_mortality_rates[stage] # some exp / different mortalities - but this gets quickly unwieldly\n mortality: int = round(mortality_rate)#min(self.cfg.rng.poisson(mortality_rate), lice_population[stage])\n dead_lice_dist[stage] = mortality\n\n logger.debug(\"\\t\\tbackground mortality distribution of dead lice = {}\".format(dead_lice_dist))\n return dead_lice_dist\n\n\n def average_fish_mass(self, days):\n \"\"\"\n Average fish mass.\n\n :params days: number of elapsed days\n :returns: the average fish mass (in grams).\n \"\"\"\n smolt_params = self.cfg.smolt_mass_params\n return smolt_params.max_mass / (1 + math.exp(smolt_params.skewness * (days - smolt_params.x_shift)))\n\n def get_reservoir_lice(self, pressure: int, external_pressure_ratios: GenoDistribDict) -> Dict[LifeStage, GenoDistrib]:\n \"\"\"Get distribution of lice coming from the reservoir\n\n :param pressure: External pressure\n :param external_pressure_ratios: the external pressure ratios to sample from\n\n :return: Distribution of lice in L1 and L2\n \"\"\"\n\n if pressure == 0:\n return {\"L1\": GenoDistrib(), \"L2\": GenoDistrib()}\n\n new_L1_gross = self.cfg.rng.integers(low=0, high=pressure, size=1)[0]\n new_L2_gross = pressure - new_L1_gross\n\n keys = list(external_pressure_ratios.keys())\n probas = list(external_pressure_ratios.values())\n new_L1 = GenoDistrib.from_ratios(new_L1_gross, probas, self.cfg.rng)\n new_L2 = GenoDistrib.from_ratios(new_L2_gross, probas, self.cfg.rng)\n #new_L1 = GenoDistrib(dict(zip(keys, self.cfg.rng.multinomial(new_L1_gross, probas).tolist())))\n #new_L2 = GenoDistrib(dict(zip(keys, self.cfg.rng.multinomial(new_L2_gross, probas).tolist())))\n\n new_lice_dist = {\"L1\": new_L1, \"L2\": new_L2}\n logger.debug(\"\\t\\tdistribution of new lice from reservoir = {}\".format(new_lice_dist))\n return new_lice_dist\n\n def fallow(self):\n \"\"\"Put the cage in a fallowing state.\n\n Implications:\n\n 1. All the fish would be removed.\n 2. L3/L4/L5 would therefore disappear as they are attached to fish.\n 3. Dam waiting and treatment queues will be flushed.\n \"\"\"\n\n for stage in LicePopulation.pathogenic_stages:\n self.lice_population[stage] = 0\n\n self.num_infected_fish = self.num_fish = 0\n self.treatment_events = PriorityQueue()\n\n @property\n def is_fallowing(self):\n return self.num_fish == 0\n\n def is_treated(self, cur_date):\n if self.last_effective_treatment is not None:\n treatment = self.last_effective_treatment\n if cur_date <= treatment.treatment_window:\n return True\n\n return False\n\n @property\n def aggregation_rate(self):\n \"\"\"The aggregation rate is the number of lice over the total number of fish.\n Elsewhere it is referred to as infection rate, but here \"infection rate\" only refers to host fish.\n\n :returns: the aggregation rate\"\"\"\n return self.lice_population[\"L5f\"] / self.num_fish if self.num_fish > 0 else 0.0\n", "meta": {"hexsha": "9bed84648a7f91a9e44bb5ca286f28f8ad118f00", "size": 49060, "ext": "py", "lang": "Python", "max_stars_repo_path": "slim/simulation/cage.py", "max_stars_repo_name": "magicicada/slim", "max_stars_repo_head_hexsha": "e6e966dfa88145f0f571e9479ea22ed7ce61fd57", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-10-06T20:09:53.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-05T11:40:57.000Z", "max_issues_repo_path": "slim/simulation/cage.py", "max_issues_repo_name": "resistance-modelling/slim", "max_issues_repo_head_hexsha": "ce05d40f56f5263cb039973af3e187cffc1d00b4", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 143, "max_issues_repo_issues_event_min_datetime": "2021-07-16T09:44:23.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-29T16:27:40.000Z", "max_forks_repo_path": "slim/simulation/cage.py", "max_forks_repo_name": "resistance-modelling/slim", "max_forks_repo_head_hexsha": "ce05d40f56f5263cb039973af3e187cffc1d00b4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.2627865961, "max_line_length": 156, "alphanum_fraction": 0.6560538117, "include": true, "reason": "import numpy", "num_tokens": 11831, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6513548782017745, "lm_q2_score": 0.2974699363766585, "lm_q1q2_score": 0.193758494177308}} {"text": "from __future__ import print_function, division\nfrom clock_tree import ClockTree\nimport utils as ttutils\nimport config as ttconf\nimport numpy as np\nfrom scipy import optimize as sciopt\nfrom Bio import Phylo\nfrom version import tt_version as __version__\n\n\nclass TreeTime(ClockTree):\n \"\"\"\n TreeTime is a wrapper class to ClockTree that adds additional functionality\n such as reroot, detection and exclusion of outliers, resolution of polytomies\n using temporal information, and relaxed molecular clock models\n \"\"\"\n\n def __init__(self, *args,**kwargs):\n \"\"\"\n TreeTime constructor\n\n Parameters\n -----------\n Arguments to construct ClockTree\n\n Keyword Args\n ------------\n Kwargs to construct ClockTree\n\n \"\"\"\n super(TreeTime, self).__init__(*args, **kwargs)\n self.n_iqd = ttconf.NIQD\n\n def run(self, root=None, infer_gtr=True, relaxed_clock=None, n_iqd = None,\n resolve_polytomies=True, max_iter=0, Tc=None, fixed_clock_rate=None,\n time_marginal=False, use_input_branch_length = False, **kwargs):\n\n \"\"\"\n Run TreeTime reconstruction. Based on the input parameters, it divides\n the analysis into semi-independent jobs and conquers them one-by one\n gradually optimizing the tree given the temporal constarints and leaf\n nodes sequences.\n\n Parameters\n ----------\n\n root : str, None\n Try to find better root position on a given tree. If string is passed,\n the root will be searched according to the specified method. Available\n reroot methods are: 'best', 'oldest', ''\n\n If None, use tree as-is.\n\n infer_gtr : bool default True\n Should infer GTR model?\n\n relaxed_clock : dic, None\n If not None, use autocorrelated molecular clock model. Specify the\n clock parameters as {slack:, coupling:} dictionary.\n\n n_iqd : int, None\n If not None, filter tree nodes, which do not obey molecular clock\n for the particular tree. The nodes, which deviate more than\n :code:`n_iqd` interquantile intervals from the molecular clock\n regression will be marked as 'BAD' and not account in the TreeTime\n analysis\n\n resolve_polytomies : bool\n Should attempt to resolve multiple mergers?\n\n max_iter : int\n Maximum number of iterations to optimize the tree\n\n Tc : float, str, None\n If not None, use coalescent model to correct the branch lengths by\n introducing merger costs.\n\n If Tc is float, it is interpreted as the coalescence time scale\n\n If Tc is str, it should be one of (:code:`opt`, :code:`skyline`)\n\n fixed_clock_rate : float, None\n If None, infer clock rate from the molecular clock\n\n If float, use this rate\n\n time_marginal : bool default False\n Should perform marginal reconstruction of the node's positions?\n\n use_input_branch_length : bool\n If True, rely on the branch lengths in the imput tree and skip directly\n to the maximum-likelihood ancestral sequence reconstruction.\n Otherwise, perform preliminary sequence reconstruction using parsimony\n algorithm and do branch length optimization\n\n Keyword Args\n ------------\n\n Additional arguments needed by the dowstream funcitons\n\n\n \"\"\"\n # determine how to reconstruct and sample sequences\n seq_kwargs = {\"marginal\":False, \"sample_from_profile\":\"root\"}\n if \"fixed_pi\" in kwargs:\n seq_kwargs[\"fixed_pi\"] = kwargs[\"fixed_pi\"]\n if \"do_marginal\" in kwargs:\n time_marginal=kwargs[\"do_marginal\"]\n\n # initially, infer ancestral sequences and infer gtr model if desired\n if use_input_branch_length:\n self.infer_ancestral_sequences(infer_gtr=infer_gtr, **seq_kwargs)\n self.prune_short_branches()\n else:\n self.optimize_sequences_and_branch_length(infer_gtr=infer_gtr,\n max_iter=2, prune_short=True, **seq_kwargs)\n avg_root_to_tip = np.mean([x.dist2root for x in self.tree.get_terminals()])\n\n # optionally reroot the tree either by oldest, best regression or with a specific leaf\n if n_iqd or root=='clock_filter':\n if \"plot_rtt\" in kwargs and kwargs[\"plot_rtt\"]:\n plot_rtt=True\n else:\n plot_rtt=False\n self.clock_filter(reroot='best' if root=='clock_filter' else root,\n n_iqd=n_iqd, plot=plot_rtt)\n elif root is not None:\n self.reroot(root=root)\n\n if use_input_branch_length:\n self.infer_ancestral_sequences(**seq_kwargs)\n else:\n self.optimize_sequences_and_branch_length(max_iter=2,**seq_kwargs)\n\n # infer time tree and optionally resolve polytomies\n self.logger(\"###TreeTime.run: INITIAL ROUND\",0)\n self.make_time_tree(clock_rate=fixed_clock_rate, time_marginal=False, **kwargs)\n\n self.LH = [[self.tree.sequence_marginal_LH if seq_kwargs['marginal'] else self.tree.sequence_joint_LH,\n self.tree.positional_joint_LH, 0.0]]\n\n # iteratively reconstruct ancestral sequences and re-infer\n # time tree to ensure convergence.\n niter = 0\n while niter < max_iter:\n\n self.logger(\"###TreeTime.run: ITERATION %d out of %d iterations\"%(niter+1,max_iter),0)\n # add coalescent prior\n if Tc and (Tc is not None):\n from merger_models import Coalescent\n self.logger('TreeTime.run: adding coalescent prior with Tc='+str(Tc),1)\n self.merger_model = Coalescent(self.tree, Tc=avg_root_to_tip,\n date2dist=self.date2dist, logger=self.logger)\n\n if Tc=='skyline' and niter==max_iter-1: # restrict skyline model optimization to last iteration\n self.merger_model.optimize_skyline(**kwargs)\n self.logger(\"optimized a skyline \", 2)\n else:\n if Tc in ['opt', 'skyline']:\n self.merger_model.optimize_Tc()\n self.logger(\"optimized Tc to %f\"%self.merger_model.Tc.y[0], 2)\n else:\n try:\n self.merger_model.set_Tc(Tc)\n except:\n self.logger(\"setting of coalescent time scale failed\", 1, warn=True)\n\n self.merger_model.attach_to_tree()\n\n # estimate a relaxed molecular clock\n if relaxed_clock:\n self.relaxed_clock(**relaxed_clock)\n\n n_resolved=0\n if resolve_polytomies:\n # if polytomies are found, rerun the entire procedure\n n_resolved = self.resolve_polytomies()\n if n_resolved:\n self.prepare_tree()\n # when using the input branch length, only infer ancestral sequences\n if use_input_branch_length:\n self.infer_ancestral_sequences(**seq_kwargs)\n else: # otherwise reoptimize branch length while preserving branches without mutations\n self.optimize_sequences_and_branch_length(prune_short=False,\n max_iter=0, **seq_kwargs)\n\n self.make_time_tree(clock_rate=fixed_clock_rate, time_marginal=False, **kwargs)\n ndiff = self.infer_ancestral_sequences('ml',**seq_kwargs)\n else:\n ndiff = self.infer_ancestral_sequences('ml',**seq_kwargs)\n self.make_time_tree(clock_rate=fixed_clock_rate, time_marginal=False, **kwargs)\n elif (Tc and (Tc is not None)) or relaxed_clock: # need new timetree first\n self.make_time_tree(clock_rate=fixed_clock_rate, time_marginal=False, **kwargs)\n ndiff = self.infer_ancestral_sequences('ml',**seq_kwargs)\n else: # no refinements, just iterate\n ndiff = self.infer_ancestral_sequences('ml',**seq_kwargs)\n self.make_time_tree(clock_rate=fixed_clock_rate, time_marginal=False, **kwargs)\n\n self.tree.coalescent_joint_LH = self.merger_model.total_LH() if Tc else 0.0\n\n self.LH.append([self.tree.sequence_marginal_LH if seq_kwargs['marginal'] else self.tree.sequence_joint_LH,\n self.tree.positional_joint_LH, self.tree.coalescent_joint_LH])\n niter+=1\n\n if ndiff==0 & n_resolved==0:\n self.logger(\"###TreeTime.run: CONVERGED\",0)\n break\n\n # if marginal reconstruction requested, make one more round with marginal=True\n # this will set marginal_pos_LH, which to be used as error bar estimations\n if time_marginal:\n self.logger(\"###TreeTime.run: FINAL ROUND - confidence estimation via marginal reconstruction\", 0)\n self.make_time_tree(clock_rate=fixed_clock_rate, time_marginal=time_marginal, **kwargs)\n\n\n\n\n def clock_filter(self, reroot='best', n_iqd=None, plot=False):\n '''\n Labels outlier branches that don't seem to follow a molecular clock\n and excludes them from subsequent the molecular clock estimate and\n the timetree propagation\n\n Parameters\n ----------\n reroot : str, None\n Method to find the best root in the tree.\n\n n_iqd : int, None\n Number of iqd intervals. The outlier nodes are those which do not fall\n into :math:`IQD\\cdot n_iqd` interval (:math:`IQD` is the interval between\n 75 and 25 percentiles)\n\n if None, the default (3) assumed\n\n plot : bool\n Should plot the reults?\n\n '''\n if n_iqd is None:\n n_iqd = self.n_iqd\n\n terminals = self.tree.get_terminals()\n if reroot:\n self.reroot(root=reroot)\n icpt, clock_rate = self.tree.root._alpha, self.tree.root._beta\n else:\n tmp_date2dist = ttutils.DateConversion.from_tree(self.tree)\n icpt, clock_rate = tmp_date2dist.intercept, tmp_date2dist.clock_rate\n\n res = {}\n for node in terminals:\n if hasattr(node, 'numdate_given') and (node.numdate_given is not None):\n res[node] = node.dist2root - clock_rate*np.mean(node.numdate_given) - icpt\n residuals = np.array(res.values())\n iqd = np.percentile(residuals,75) - np.percentile(residuals,25)\n for node,r in res.iteritems():\n if abs(r)>n_iqd*iqd and node.up.up is not None:\n self.logger('TreeTime.ClockFilter: marking %s as outlier, residual %f interquartile distances'%(node.name,r/iqd), 3)\n node.bad_branch=True\n else:\n node.bad_branch=False\n\n if plot:\n self.plot_root_to_tip()\n\n # redo root estimation after outlier removal\n if reroot:\n self.reroot(root=reroot)\n\n\n def plot_root_to_tip(self, add_internal=False, label=True, ax=None, **kwargs):\n \"\"\"\n Plot root-to-tip regression\n\n Parameters\n ----------\n\n add_internal : bool\n Should plot internal node positoins?\n\n label : bool\n Should label the plots?\n\n ax: matplotlib axes, None\n If not None, use the provided matplotlib axes to plot the results\n\n Keyword Args\n ------------\n Additional arguments for matplotlib.pyplot.scatter function\n\n \"\"\"\n import matplotlib.pyplot as plt\n tips = self.tree.get_terminals()\n internal = self.tree.get_nonterminals()\n if ax is None:\n plt.figure()\n ax=plt.subplot(111)\n dates = np.array([np.mean(n.numdate_given) for n in tips if n.numdate_given is not None])\n dist = np.array([n.dist2root for n in tips if n.numdate_given is not None])\n ind = np.array([n.bad_branch for n in tips if n.numdate_given is not None])\n # plot tips\n ax.scatter(dates[ind], dist[ind] , c='r', label=\"bad tips\" if label else \"\" , **kwargs)\n ax.scatter(dates[~ind], dist[~ind], c='g', label=\"good tips\" if label else \"\", **kwargs)\n if add_internal and hasattr(self.tree.root, \"numdate\"):\n dates = np.array([n.numdate for n in internal])\n dist = np.array([n.dist2root for n in internal])\n ind = np.array([n.bad_branch for n in internal])\n # plot internal\n ax.scatter(dates[~ind], dist[~ind], c='b', marker='<', label=\"internal\" if label else \"\", **kwargs)\n\n if label:\n ax.legend(loc=2)\n ax.set_ylabel('root-to-tip distance')\n ax.set_xlabel('date')\n ax.ticklabel_format(useOffset=False)\n plt.tight_layout()\n\n\n def reroot(self,root='best'):\n \"\"\"\n Find best root and re-root the tree to the new root\n\n Parameters\n ----------\n\n root : str\n Which method should be used to find the best root. Available methods are:\n\n :code:`best` - maximize root-to-tip regression coefficient\n\n :code:`oldest` - choose the oldest node\n\n :code:`` - reroot to the node with name :code:``\n\n :code:`[, , ...]` - reroot to the MRCA of these nodes\n \"\"\"\n self.logger(\"TreeTime.reroot: with method or node: %s\"%root,1)\n for n in self.tree.find_clades():\n n.branch_length=n.mutation_length\n from Bio import Phylo\n if isinstance(root,Phylo.BaseTree.Clade):\n new_root = root\n elif isinstance(root, list):\n new_root = self.tree.common_ancestor(*root)\n elif root in self._leaves_lookup:\n new_root = self._leaves_lookup[root]\n elif root=='oldest':\n new_root = sorted([n for n in self.tree.get_terminals()\n if n.numdate_given is not None],\n key=lambda x:np.mean(x.numdate_given))[0]\n elif root=='best':\n new_root = self.reroot_to_best_root(criterium='residual')\n elif root=='rsq':\n new_root = self.reroot_to_best_root(criterium='rsq')\n elif root=='residual':\n new_root = self.reroot_to_best_root(criterium='residual')\n elif root=='min_dev':\n new_root = self.reroot_to_best_root(criterium='min_dev')\n else:\n self.logger('TreeTime.reroot -- WARNING: unsupported rooting mechanisms or root not found',2,warn=True)\n return\n\n self.logger(\"TreeTime.reroot: Tree is being re-rooted to node \"\n +('new_node' if new_root.name is None else new_root.name), 2)\n if isinstance(root, list):\n #this forces a bifurcating root, as we want. Branch lengths will be reoptimized anyway.\n #(Without outgroup_branch_length, gives a trifurcating root, but this will mean\n #mutations may have to occur multiple times.)\n self.tree.root_with_outgroup(new_root, outgroup_branch_length=new_root.branch_length/2)\n else:\n self.tree.root_with_outgroup(new_root)\n # new nodes are produced when rooting with a terminal node, copy this clock info\n\n if new_root.is_terminal():\n if hasattr(new_root, \"_alpha\"):\n self.tree.root._alpha = new_root._alpha\n if hasattr(new_root, \"_beta\"):\n self.tree.root._beta = new_root._beta\n if hasattr(new_root, \"_R2\"):\n self.tree.root._R2 = new_root._R2\n if hasattr(new_root, \"_residual\"):\n self.tree.root._residual = new_root._residual\n\n self.tree.root.branch_length = self.one_mutation\n for n in self.tree.find_clades():\n n.mutation_length=n.branch_length\n self.tree.root.numdate_given = None\n # set root.gamma bc root doesn't have a branch_length_interpolator but gamma is needed\n if not hasattr(self.tree.root, 'gamma'):\n self.tree.root.gamma = 1.0\n self.prepare_tree()\n\n\n def resolve_polytomies(self, merge_compressed=False, rerun=True):\n \"\"\"\n Resolve the polytomies on the tree.\n The function scans the tree, resolves polytomies in case there are any,\n and re-optimizes the tree with new topology. Note that polytomies are only\n resolved if that would result in higher likelihood. Sometimes, stretching\n two or more branches that carry several mutations are less costly than\n an additional branch with zero mutations (long branches are not stiff,\n short branches are.)\n\n Parameters\n ----------\n merge_compressed : bool\n Whether to keep compressed branches as polytomies or\n return a strictly binary tree.\n\n \"\"\"\n self.logger(\"TreeTime.resolve_polytomies: resolving multiple mergers...\",1)\n\n poly_found=0\n for n in self.tree.find_clades():\n if len(n.clades) > 2:\n prior_n_clades = len(n.clades)\n self._poly(n, merge_compressed)\n poly_found+=prior_n_clades - len(n.clades)\n\n obsolete_nodes = [n for n in self.tree.find_clades() if len(n.clades)==1 and n.up is not None]\n for node in obsolete_nodes:\n self.logger('TreeTime.resolve_polytomies: remove obsolete node '+node.name,4)\n if node.up is not None:\n self.tree.collapse(node)\n\n if poly_found:\n self.logger('TreeTime.resolve_polytomies: introduces %d new nodes'%poly_found,3)\n else:\n self.logger('TreeTime.resolve_polytomies: No more polytomies to resolve',3)\n return poly_found\n\n\n def _poly(self, clade, merge_compressed, verbose=1):\n\n \"\"\"\n Function to resolve polytomies for a given parent node. If the\n number of the direct decendants is less than three (not a polytomy), does\n nothing. Otherwise, for each pair of nodes, assess the possible LH increase\n which could be gained by merging the two nodes. The increase in the LH is\n basically the tradeoff between the gain of the LH due to the changing the\n branch lenghts towards the optimal values and the decrease due to the\n introduction of the new branch with zero optimal length.\n \"\"\"\n\n from branch_len_interpolator import BranchLenInterpolator\n from Bio import Phylo\n\n zero_branch_slope = self.gtr.mu*self.seq_len\n\n def _c_gain(t, n1, n2, parent):\n \"\"\"\n cost gain if nodes n1, n2 are joined and their parent is placed at time t\n cost gain = (LH loss now) - (LH loss when placed at time t)\n \"\"\"\n cg2 = n2.branch_length_interpolator(parent.time_before_present - n2.time_before_present) - n2.branch_length_interpolator(t - n2.time_before_present)\n cg1 = n1.branch_length_interpolator(parent.time_before_present - n1.time_before_present) - n1.branch_length_interpolator(t - n1.time_before_present)\n cg_new = - zero_branch_slope * (parent.time_before_present - t) # loss in LH due to the new branch\n return -(cg2+cg1+cg_new)\n\n def cost_gain(n1, n2, parent):\n \"\"\"\n cost gained if the two nodes would have been connected.\n \"\"\"\n try:\n cg = sciopt.minimize_scalar(_c_gain,\n bounds=[max(n1.time_before_present,n2.time_before_present), parent.time_before_present],\n method='Bounded',args=(n1,n2, parent))\n return cg['x'], - cg['fun']\n except:\n self.logger(\"TreeTime._poly.cost_gain: optimization of gain failed\", 3, warn=True)\n return parent.time_before_present, 0.0\n\n\n def merge_nodes(source_arr, isall=False):\n mergers = np.array([[cost_gain(n1,n2, clade) if i1 1 + int(isall):\n # max possible gains of the cost when connecting the nodes:\n # this is only a rough approximation because it assumes the new node positions\n # to be optimal\n new_positions = mergers[:,:,0]\n cost_gains = mergers[:,:,1]\n # set zero to large negative value and find optimal pair\n np.fill_diagonal(cost_gains, -1e11)\n idxs = np.unravel_index(cost_gains.argmax(),cost_gains.shape)\n if (idxs[0] == idxs[1]) or cost_gains.max()<0:\n self.logger(\"TreeTime._poly.merge_nodes: node is not fully resolved \"+clade.name,4)\n return LH\n\n n1, n2 = source_arr[idxs[0]], source_arr[idxs[1]]\n LH += cost_gains[idxs]\n\n new_node = Phylo.BaseTree.Clade()\n\n # fix positions and branch lengths\n new_node.time_before_present = new_positions[idxs]\n new_node.branch_length = clade.time_before_present - new_node.time_before_present\n new_node.clades = [n1,n2]\n n1.branch_length = new_node.time_before_present - n1.time_before_present\n n2.branch_length = new_node.time_before_present - n2.time_before_present\n\n # set parameters for the new node\n new_node.up = clade\n n1.up = new_node\n n2.up = new_node\n new_node.cseq = clade.cseq\n self._store_compressed_sequence_to_node(new_node)\n\n new_node.mutations = []\n new_node.mutation_length = 0.0\n new_node.branch_length_interpolator = BranchLenInterpolator(new_node, self.gtr, one_mutation=self.one_mutation)\n clade.clades.remove(n1)\n clade.clades.remove(n2)\n clade.clades.append(new_node)\n self.logger('TreeTime._poly.merge_nodes: creating new node as child of '+clade.name,3)\n self.logger(\"TreeTime._poly.merge_nodes: Delta-LH = \" + str(cost_gains[idxs].round(3)), 3)\n\n # and modify source_arr array for the next loop\n if len(source_arr)>2: # if more than 3 nodes in polytomy, replace row/column\n for ii in np.sort(idxs)[::-1]:\n tmp_ind = np.arange(mergers.shape[0])!=ii\n mergers = mergers[tmp_ind].swapaxes(0,1)\n mergers = mergers[tmp_ind].swapaxes(0,1)\n\n source_arr.remove(n1)\n source_arr.remove(n2)\n new_gains = np.array([[cost_gain(n1,new_node, clade) for n1 in source_arr]])\n mergers = np.vstack((mergers, new_gains)).swapaxes(0,1)\n\n source_arr.append(new_node)\n new_gains = np.array([[cost_gain(n1,new_node, clade) for n1 in source_arr]])\n mergers = np.vstack((mergers, new_gains)).swapaxes(0,1)\n else: # otherwise just recalculate matrix\n source_arr.remove(n1)\n source_arr.remove(n2)\n source_arr.append(new_node)\n mergers = np.array([[cost_gain(n1,n2, clade) for n1 in source_arr]\n for n2 in source_arr])\n\n return LH\n\n stretched = [c for c in clade.clades if c.mutation_length < c.clock_length]\n compressed = [c for c in clade.clades if c not in stretched]\n\n if len(stretched)==1 and merge_compressed==False:\n return 0.0\n\n LH = merge_nodes(stretched, isall=len(stretched)==len(clade.clades))\n if merge_compressed and len(compressed)>1:\n LH += merge_nodes(compressed, isall=len(compressed)==len(clade.clades))\n\n return LH\n\n\n def print_lh(self, joint=True):\n \"\"\"\n Print the total likelihood of the tree given the constrained leaves\n\n Parameters\n ----------\n\n joint : bool\n Whether joint or marginal LH should be printed\n\n \"\"\"\n try:\n u_lh = self.tree.unconstrained_sequence_LH\n if joint:\n s_lh = self.tree.sequence_joint_LH\n t_lh = self.tree.positional_joint_LH\n c_lh = self.tree.coalescent_joint_LH\n else:\n s_lh = self.tree.sequence_marginal_LH\n t_lh = self.tree.positional_marginal_LH\n c_ls = 0\n\n print (\"### Tree Log-Likelihood ###\\n\"\n \" Sequence log-LH without constraints: \\t%1.3f\\n\"\n \" Sequence log-LH with constraints: \\t%1.3f\\n\"\n \" TreeTime sequence log-LH: \\t%1.3f\\n\"\n \" Coalescent log-LH: \\t%1.3f\\n\"\n \"#########################\"%(u_lh, s_lh,t_lh, c_lh))\n except:\n print(\"ERROR. Did you run the corresponding inference (joint/marginal)?\")\n\n\n def relaxed_clock(self, slack=None, coupling=None, **kwargs):\n \"\"\"\n Allow the mutation rate to vary on the tree (relaxed molecular clock).\n Changes of the mutation rates from one branch to another are penalized.\n In addition, deviation of the mutation rate from the mean rate are\n penalized.\n\n Parameters\n ----------\n slack : float\n Maximum change in substitution rate between parent and child nodes\n\n coupling : float\n Maximum difference in substitution rates in sibling nodes\n\n \"\"\"\n if slack is None: slack=ttconf.MU_ALPHA\n if coupling is None: coupling=ttconf.MU_BETA\n self.logger(\"TreeTime.relaxed_clock: slack=%f, coupling=%f\"%(slack, coupling),2)\n\n c=1.0/self.one_mutation\n for node in self.tree.find_clades(order='postorder'):\n opt_len = node.mutation_length\n\n # opt_len \\approx 1.0*len(node.mutations)/node.profile.shape[0] but calculated via gtr model\n # contact term: stiffness*(g*bl - bl_opt)^2 + slack(g-1)^2 =\n # (slack+bl^2) g^2 - 2 (bl*bl_opt+1) g + C= k2 g^2 + k1 g + C\n node._k2 = slack + c*node.branch_length**2/(opt_len+self.one_mutation)\n node._k1 = -2*(c*node.branch_length*opt_len/(opt_len+self.one_mutation) + slack)\n # coupling term: \\sum_c coupling*(g-g_c)^2 + Cost_c(g_c|g)\n # given g, g_c needs to be optimal-> 2*coupling*(g-g_c) = 2*child.k2 g_c + child.k1\n # hence g_c = (coupling*g - 0.5*child.k1)/(coupling+child.k2)\n # substituting yields\n for child in node.clades:\n denom = coupling+child._k2\n node._k2 += coupling*(1.0-coupling/denom)**2 + child._k2*coupling**2/denom**2\n node._k1 += (coupling*(1.0-coupling/denom)*child._k1/denom \\\n - coupling*child._k1*child._k2/denom**2 \\\n + coupling*child._k1/denom)\n\n for node in self.tree.find_clades(order='preorder'):\n if node.up is None:\n node.gamma =- 0.5*node._k1/node._k2\n else:\n if node.up.up is None:\n g_up = node.up.gamma\n else:\n g_up = node.up.branch_length_interpolator.gamma\n node.branch_length_interpolator.gamma = (coupling*g_up - 0.5*node._k1)/(coupling+node._k2)\n\n###############################################################################\n### rerooting\n###############################################################################\n def find_best_root_and_regression(self, criterium='rsq'):\n \"\"\"\n Find the best root for the tree in linear time, given the timestamps of\n the leaves. The branch lengths should be optimized prior to the run;\n the terminal nodes should have the timestamps assigned as numdate_given\n attribute.\n \"\"\"\n sum_ti = np.sum([np.mean(node.numdate_given)*node.count for node in self.tree.get_terminals() if (not node.bad_branch)])\n sum_ti2 = np.sum([np.mean(node.numdate_given)**2*node.count for node in self.tree.get_terminals() if (not node.bad_branch)])\n N = 1.0*np.sum([node.count for node in self.tree.get_terminals() if not node.bad_branch])\n tip_count = 1.0*np.sum([1.0 for node in self.tree.get_terminals() if not node.bad_branch])\n if tip_count<2:\n self.logger(\"****ERROR: TreeTime.find_best_root_and_regression: need at least two dates to reroot!\", 0, warn=True)\n self.logger(\"****ERROR: only %d tips have valid dates!\"%N, 0, warn=True)\n return selt.tree.root, np.nan, np.nan\n\n Ninv = 1.0/N\n time_variance = (N*sum_ti2 - sum_ti**2)*Ninv**2\n\n # fill regression terms for one of the two subtrees\n for node in self.tree.find_clades(order='postorder'): # children first, msg to parents\n if node.is_terminal(): # inititalize the leaves\n # will not rely on the standard func - count terminals directly\n node._st_n_leaves = 0 if node.bad_branch else node.count\n node._st_di = 0.0\n node._st_diti = 0.0\n node._st_di2 = 0.0\n\n if node.bad_branch:\n node._st_ti = 0\n else:\n node._st_ti = np.mean(node.numdate_given)*node.count\n\n node._ti = sum_ti\n else:\n # for non-terminal nodes,\n node._st_ti = np.sum([k._st_ti for k in node.clades])\n node._st_n_leaves = np.sum([k._st_n_leaves for k in node.clades])\n node._st_di = np.sum([k._st_di + k._st_n_leaves*k.branch_length for k in node.clades])\n node._st_diti = np.sum([k._st_diti + k.branch_length*k._st_ti for k in node.clades])\n node._st_di2 = np.sum([k._st_di2 + 2*k._st_di*k.branch_length + k._st_n_leaves*k.branch_length**2\n for k in node.clades])\n node._ti = sum_ti\n node.bad_branch = np.all([x.bad_branch for x in node])\n\n best_root = self.tree.root\n best_root_any = self.tree.root\n for node in self.tree.find_clades(order='preorder'): # root first\n\n if node.up is None:\n # assign the values for the root node\n node._di = node._st_di\n node._diti = node._st_diti\n node._di2 = node._st_di2\n\n dist_variance = (N*node._di2 - node._di**2)*(Ninv**2)\n disttime_cov = (N*node._diti - sum_ti*node._di)*(Ninv**2)\n time_variance = time_variance\n\n node._beta = disttime_cov/time_variance\n node._alpha = (node._di - node._beta*sum_ti)/N\n node._residual = (node._di2 - 2*node._beta*node._diti - 2*node._alpha*node._di\n + node._beta**2*sum_ti2 + 2*node._alpha*node._beta*sum_ti + node._alpha**2*N)\n\n node._R2 = disttime_cov**2/(time_variance*dist_variance)\n node._R2_delta_x = 0.0 # there is no branch to move the root\n elif node.bad_branch:\n node._beta = np.nan\n node._alpha = np.nan\n node._R2 = 0.0\n node._R2_delta_x = 0.0\n node._residual = np.inf\n\n elif criterium=='rsq': # calculate the r^2 of the root to tip regression and pick the best intermediate position on the branch\n # NOTE order of these computation matters\n n_up = N - node._st_n_leaves\n n_down = node._st_n_leaves\n L = node.branch_length\n node._di = node.up._di + (n_up-n_down)*L\n node._di2 = (node.up._di2 + 2*L*node.up._di\n - 4*(L*(node._st_di + n_down*L))\n + N*L**2)\n node._diti = node.up._diti + L*(sum_ti - 2*node._st_ti)\n\n\n ## Express Node's sum_Di as the function of parent's sum_Di\n # and **displacement from parent's node x** :\n # sum_Di = A1 + A2 * x\n A1 = node.up._di\n A2 = n_up - n_down\n\n ## Express Node's sum_Di**2 as the function of parent's params\n # and **displacement from parent's node x** :\n # sum_Di2 = B1 + B2 * x + B3 * x**2\n B1 = node.up._di2\n B2 = 2 * (node.up._di - 2 * node._st_di - 2 * L * n_down )\n B3 = N\n\n ## Express Node's sum_DiTi as the function of parent's params\n # and **displacement from parent's node x** :\n # sum_DiTi = C1 + C2 * x\n C1 = node.up._diti\n C2 = sum_ti - 2 * node._st_ti\n\n ## Substituting Ai, Bi, Ci to the expression for R2, and\n ## making all the algebra, we get the R2 as the function of the\n ## displacement from the parent's node x:\n # R2(x) = CONST * (alpha * x**2 + beta * x+ gamma) / (mu * x**2 + nu * x + delta)\n # Expressions for alpha, beta, etc through Ai, Bi, Ci:\n alpha = (N * C2 - sum_ti * A2)**2\n beta = 2 * (N*C2 - sum_ti*A2) * (N*C1 - sum_ti*A1)\n gamma = (N*C1 - sum_ti*A1)**2\n mu = N * B3 - A2**2\n nu = N * B2 - 2 * A1 * A2\n delta = N * B1 - A1**2\n\n # Search for the maximum of R2 in the middle of the branch.\n # Eq: dR2/dx = 0 -> square equation:\n # x**2*(alpha*nu - beta * mu) + 2x*(alpha*delta-mu*gamma) + (beta*delta - nu*gamma) = 0\n # look for the root(s):\n # Determinant is\n D2 = (alpha * delta - mu * gamma) ** 2 - (alpha * nu - beta * mu) * (beta * delta - nu * gamma)\n\n if D2 < 0:\n # somehow there is no extremum for the R2(x) function\n x1 = -1.0 # any arbitrary value out of range [0, L], see below\n x2 = -1.0\n else:\n # actual roots - the extrema for the R2(x) function\n if np.abs(alpha * nu - beta * mu)>0:\n x1 = (-1 * (alpha * delta - mu * gamma) + D2**0.5) / (alpha * nu - beta * mu)\n x2 = (-1 * (alpha * delta - mu * gamma) - D2**0.5) / (alpha * nu - beta * mu)\n else:\n x1 = -(beta*delta - nu*gamma)/(alpha * delta - mu * gamma)\n x2 = x1\n\n # possible positions, where the new root can possibly be located\n # (restrict to the branch length)\n max_points = [k for k in (x1,x2,L) if k >= 0 and k <= L]\n # values of the R2 at these positions\n R2s = [(alpha * x**2 + beta * x + gamma) / (mu * x**2 + nu * x + delta) / time_variance / N**2 for x in max_points]\n # choose the best R2\n node._R2 = np.max(R2s)\n # and set the position for the best R2 value\n node._R2_delta_x = L - max_points[np.argmax(R2s)]\n\n # for this position, define the clock_rate and intercept:\n node._beta = ((L - node._R2_delta_x) * (N * C2 - sum_ti * A2) + (N*C1-sum_ti*A1)) / time_variance / N**2\n node._alpha = (L - node._R2_delta_x) * A2 / N + (A1 - node._beta * sum_ti) / N\n elif criterium in ['residual', 'min_dev']: # calculate the squared residuals and minimize as rooting criterium\n L = node.branch_length\n # number of nodes descendent and outgrouping this node\n n_up = N - node._st_n_leaves\n n_down = node._st_n_leaves\n # sum of branch length of the descendent tree and the outgrouping one\n node._di = node.up._di + (n_up-n_down)*L\n nd_down = node._st_di\n nd_up = node._di - node._st_di\n # sum of times of descendent tips and outgrouping ones\n nt_down = node._st_ti\n nt_up = sum_ti - node._st_ti\n\n # sum of squared branch length of the descendent tree and the outgrouping one\n node._di2 = (node.up._di2 + 2*L*node.up._di\n - 4*(L*(node._st_di + n_down*L))\n + N*L**2)\n nd2_down = node._st_di2\n nd2_up = node._di2 - node._st_di2\n\n # sum of timexbranch length of the descendent tree and the outgrouping one\n node._diti = node.up._diti + L*(sum_ti - 2*node._st_ti)\n ndt_down = node._st_diti\n ndt_up = node._diti - node._st_diti\n\n disttime_cov = (N*node._diti - sum_ti*node._di)*(Ninv**2)\n\n # decompose expression for alpha and beta into parts independent and linear in epsilon\n # where epsilon is the shift in root position along the branch\n beta_0 = disttime_cov/time_variance\n b = L*(nt_down - nt_up - (n_down-n_up)*sum_ti*Ninv)*Ninv/time_variance\n alpha_0 = (node._di - beta_0*sum_ti)*Ninv\n a = (-b*sum_ti + L*(n_down-n_up))*Ninv\n eps = -(((nd_down - beta_0*nt_down - n_down*alpha_0) - (nd_up - beta_0*nt_up - n_up*alpha_0))/\n ((n_down*L - b*nt_down - a*n_down) - (-n_up*L - b*nt_up - a*n_up)))\n\n # only shifts between 0 and 1 are admissible (where 0 is the node itself and 1 is the parent)\n eps = min(1,max(0,eps))\n beta = beta_0 + eps*b\n alpha = alpha_0 + eps*a\n\n # calculate the residual and assign the regression coefficients\n node._residual = (node._di2 - 2*beta*node._diti - 2*alpha*node._di\n + beta**2*sum_ti2 + 2*alpha*beta*sum_ti + alpha**2*N)\n node._residual += N*(L*eps)**2\n node._residual += 2*eps*L*(nd_down - beta*nt_down - n_down*alpha) - 2*eps*L*(nd_up - beta*nt_up - n_up*alpha)\n node._alpha = alpha\n node._beta = beta\n node._R2_delta_x = eps*L\n else:\n self.logger(\"TreeTime.find_best_root_and_regression: unknown criterium\",0)\n\n if criterium=='rsq':\n if node.up is None:\n self.logger(\"TreeTime.find_best_root_and_regression: Initial root: R2:%f\\tclock_rate:%.3e\"%(best_root._R2, best_root._beta),3)\n if node._R2 > best_root_any._R2:\n best_root_any = node\n if (node._R2 > best_root._R2 and node._beta>0) or best_root._beta<0:\n best_root = node\n self.logger(\"TreeTime.find_best_root_and_regression: Better root found: R2:%f\\tclock_rate:%.3e\\tbranch_displacement:%f\"\n %(best_root._R2, best_root._beta, (best_root._R2_delta_x) / ( best_root.branch_length + self.one_mutation)),4)\n elif criterium in ['residual', 'min_dev']:\n if node.up is None:\n self.logger(\"TreeTime.find_best_root_and_regression: Initial root: residual:%.3e\\tclock_rate:%.3e\"%(best_root._residual, best_root._beta),3)\n if node._residual < best_root_any._residual:\n best_root_any = node\n if (node._residual < best_root._residual and node._beta>0) or best_root._beta<0:\n best_root = node\n self.logger(\"TreeTime.find_best_root_and_regression: Better root found: residual:%.3e\\tclock_rate:%.3e\\tbranch_displacement:%f\"\n %(best_root._residual, best_root._beta, (best_root._R2_delta_x) / ( best_root.branch_length + self.one_mutation)),4)\n\n\n if criterium=='rsq':\n if (best_root_any._R2 > best_root._R2):\n self.logger(\"WARNING: TreeTime.find_best_root_and_regression: optimal regression has negative rate: R2:%f\\tclock_rate:%.3e\"\n %(best_root_any._R2, best_root_any._beta), 1)\n self.logger(\"TreeTime.find_best_root_and_regression: Best root: R2:%f\\tclock_rate:%.3e\\tbranch_displacement:%f\"\n %(best_root._R2, best_root._beta, (best_root._R2_delta_x) / ( best_root.branch_length + 0.001*self.one_mutation)),3)\n elif criterium=='residual':\n if (best_root_any._residual < best_root._residual):\n self.logger(\"WARNING: TreeTime.find_best_root_and_regression: optimal regression has negative rate: residual:%.3e\\tclock_rate:%.3e\"\n %(best_root_any._residual, best_root_any._beta), 1)\n self.logger(\"TreeTime.find_best_root_an_R2_delta_xd_regression: Best root: residual:%.3e\\tclock_rate:%.3e\\tbranch_displacement:%f\"\n %(best_root._residual, best_root._beta, (best_root._R2_delta_x) / ( best_root.branch_length + 0.001*self.one_mutation)),3)\n elif criterium=='min_dev':\n if (best_root_any._residual < best_root._residual):\n self.logger(\"WARNING: TreeTime.find_best_root_and_regression: optimal regression has negative rate\",1)\n best_root = best_root_any\n self.logger(\"TreeTime.find_best_root_an_R2_delta_xd_regression: Best root: residual:%.3e\\tclock_rate:%.3e\\tbranch_displacement:%f\"\n %(best_root._residual, best_root._beta, (best_root._R2_delta_x) / ( best_root.branch_length + 0.001*self.one_mutation)),3)\n\n return best_root, best_root._alpha, best_root._beta\n\n\n def reroot_to_best_root(self,infer_gtr = False, criterium='rsq', **kwarks):\n '''\n determine the node that, when the tree is rooted on this node, results\n in the best regression of temporal constraints and root to tip distances\n\n Parameters\n ----------\n\n infer_gtr : bool\n Should infer new GTR model after re-root?\n\n '''\n from Bio import Phylo\n self.logger(\"TreeTime.reroot_to_best_root: searching for the best root position...\",2)\n best_root, a, b = self.find_best_root_and_regression(criterium=criterium)\n # first, re-root the tree\n\n if hasattr(best_root, \"_R2_delta_x\") and best_root._R2_delta_x > 0 and best_root.up is not None:\n\n # create new node in the branch and root the tree to it\n new_node = Phylo.BaseTree.Clade()\n\n # insert the new node in the middle of the branch\n # by simple re-wiring the links on the both sides of the branch\n # and fix the branch lengths\n new_node.branch_length = best_root.branch_length - best_root._R2_delta_x\n new_node.up = best_root.up\n new_node._alpha = a\n new_node._beta = b\n new_node.clades = [best_root]\n if hasattr(best_root, \"_R2\"):\n new_node._R2 = best_root._R2\n if hasattr(best_root, \"_residual\"):\n new_node._residual = best_root._residual\n new_node.up.clades = [k if k != best_root else new_node\n for k in best_root.up.clades]\n\n best_root.branch_length = best_root._R2_delta_x\n best_root.up = new_node\n self.logger(\"TreeTime.reroot_to_best_root:\"\n \" branch length of children of new root:\"\n \" %.3e, %.3e\"%(best_root.branch_length,\n new_node.branch_length),2)\n return new_node\n else:\n # simply use the existing node as the new root\n return best_root\n\n\ndef plot_vs_years(tt, years = 1, ax=None, confidence=None, ticks=True, **kwargs):\n '''\n converts branch length to years and plots the time tree on a time axis.\n Args:\n tt: treetime object after a time tree is inferred\n years: width of shaded boxes indicating blocks of years, default 1\n ax: axis object. will create new axis of none specified\n confidence: draw confidence intervals. This assumes that marginal\n time tree inference was run\n **kwargs: arbitrary kew word arguments that are passed down to Phylo.draw\n '''\n import matplotlib.pyplot as plt\n tt.branch_length_to_years()\n if ax is None:\n fig = plt.figure()\n ax = plt.subplot(111)\n # draw tree\n if \"label_func\" not in kwargs:\n nleafs = tt.tree.count_terminals()\n kwargs[\"label_func\"] = lambda x:x.name if (x.is_terminal() and nleafs<30) else \"\"\n Phylo.draw(tt.tree, axes=ax, **kwargs)\n\n # set axis labels\n offset = tt.tree.root.numdate - tt.tree.root.branch_length\n xticks = ax.get_xticks()\n dtick = xticks[1]-xticks[0]\n shift = offset - dtick*(offset//dtick)\n tick_vals = [x+offset-shift for x in xticks]\n ax.set_xticks(xticks - shift)\n ax.set_xticklabels(map(str, tick_vals))\n ax.set_xlabel('year')\n ax.set_ylabel('')\n ax.set_xlim((0,np.max([n.numdate for n in tt.tree.get_terminals()])+2-offset))\n\n # put shaded boxes to delineate years\n if years:\n ylim = ax.get_ylim()\n xlim = ax.get_xlim()\n if type(years) in [int, float]:\n dyear=years\n from matplotlib.patches import Rectangle\n for yi,year in enumerate(np.arange(tick_vals[0], tick_vals[-1],dyear)):\n pos = year - offset\n r = Rectangle((pos, ylim[1]-5),\n dyear, ylim[0]-ylim[1]+10,\n facecolor=[0.7+0.1*(1+yi%2)] * 3,\n edgecolor=[1,1,1])\n ax.add_patch(r)\n if year in tick_vals and pos>xlim[0] and pos> 20) & 0xf\n\n\n# Frame header\n@njit\ndef is_frame_header(word): # Check if frame header high word (frame start flag is set by R/0)\n return (0x00010000 & word) == 0x00010000\n\n\n@njit\ndef is_data_loss(word): # Indicates data loss\n return (0x00020000 & word) == 0x00020000\n\n\n@njit\ndef get_m26_timestamp_low(word): # Timestamp of Mimosa26 data from frame header low (generated by R/0)\n return 0x0000ffff & word\n\n\n@njit\ndef get_m26_timestamp_high(word): # Timestamp of Mimosa26 data from frame header high (generated by R/0)\n return (0x0000ffff & word) << 16\n\n\n@njit\ndef is_frame_header0(word): # Check if frame header0 word\n return (0x0000ffff & word) == 0x00005555\n\n\n@njit\ndef is_frame_header1(word, plane): # Check if frame header1 word for the actual plane\n return (0x0000ffff & word) == (0x00005550 | plane)\n\n\n# Frame counter\n@njit\ndef get_frame_id_low(word): # Get the frame id from the frame id low word\n return 0x0000ffff & word\n\n\n@njit\ndef get_frame_id_high(word): # Get the frame id from the frame id high word\n return (0x0000ffff & word) << 16\n\n\n# Data length\n@njit\ndef get_frame_length(word): # Get length of Mimosa26 frame\n return (0x0000ffff & word)\n\n\n# Status / line word\n@njit\ndef get_n_words(word): # Return the number of data words for the actual row\n return 0x0000000f & word\n\n\n@njit\ndef get_row(word): # Extract row from Mimosa26 hit word\n return (0x00007ff0 & word) >> 4\n\n\n@njit\ndef has_overflow(word):\n return (0x00008000 & word) != 0\n\n\n# State word\n@njit\ndef get_n_hits(word): # Returns the number of hits given by actual column word\n return 0x00000003 & word\n\n\n@njit\ndef get_column(word): # Extract column from Mimosa26 hit word\n return (0x00001ffc & word) >> 2\n\n\n# Frame trailer\n@njit\ndef is_frame_trailer0(word): # Check if frame trailer0 word\n return (0x0000ffff & word) == 0xaa50\n\n\n@njit\ndef is_frame_trailer1(word, plane): # Check if frame trailer1 word for the actual plane\n return (0x0000ffff & word) == (0xaa50 | plane)\n\n\n# Trigger words\n@njit\ndef is_trigger_word(word): # Check if TLU word (trigger)\n return (0x80000000 & word) == 0x80000000\n\n\n@njit\ndef get_trigger_timestamp(word): # Get timestamp of TLU word\n return (word & 0x7fff0000) >> 16\n\n\n@njit\ndef get_trigger_number(word, trigger_data_format): # Get trigger number of TLU word\n if trigger_data_format == 2:\n return word & 0x0000ffff\n else:\n return word & 0x7fffffff\n\n\nclass RawDataInterpreter(object):\n ''' Class to convert the raw data chunks to hits'''\n\n def __init__(self, analyze_m26_header_ids=None):\n '''\n Parameters:\n -----------\n analyze_m26_header_ids : list\n List of Mimosa26 header IDs that will be interpreted.\n If None, the value defaults to the global value raw_data_interpreter.DEFAULT_PYMOSA_M26_HEADER_IDS.\n '''\n if analyze_m26_header_ids is None:\n self.analyze_m26_header_ids = DEFAULT_PYMOSA_M26_HEADER_IDS\n else:\n self.analyze_m26_header_ids = analyze_m26_header_ids\n for analyze_m26_header_id in self.analyze_m26_header_ids:\n if analyze_m26_header_id < 0 or analyze_m26_header_id >= 2**16:\n raise ValueError('Invalid header ID.')\n self.analyze_m26_header_ids = np.asarray(self.analyze_m26_header_ids, dtype=np.uint16)\n self.plane_id_to_index = -1 * np.ones(shape=max(self.analyze_m26_header_ids) + 1, dtype=np.int32)\n for plane_index, plane_id in enumerate(self.analyze_m26_header_ids):\n self.plane_id_to_index[plane_id] = plane_index\n self.reset()\n\n def reset(self): # Reset variables\n # Temporary arrays\n self.trigger_data = np.zeros(shape=0, dtype=trigger_data_dtype)\n self.trigger_data_index = np.int64(-1)\n self.telescope_data = np.zeros(shape=0, dtype=telescope_data_dtype)\n self.telescope_data_index = np.int64(-1)\n\n # Raw data interpreter\n # Per frame variables\n self.m26_frame_ids = np.zeros(shape=len(self.analyze_m26_header_ids), dtype=np.int64) # The Mimosa26 frame ID of the actual frame\n self.m26_frame_length = np.zeros(shape=len(self.analyze_m26_header_ids), dtype=np.uint32) # The number of \"useful\" data words for the actual frame\n self.m26_data_loss = np.ones(len(self.analyze_m26_header_ids), dtype=np.bool_) # The data loss status for the actual frame\n self.m26_word_index = np.zeros(shape=len(self.analyze_m26_header_ids), dtype=np.uint32) # The word index per device of the actual frame\n self.m26_timestamps = np.zeros(shape=len(self.analyze_m26_header_ids), dtype=np.int64) # The timestamp for each plane (in units of 40 MHz)\n self.last_m26_timestamps = np.zeros(shape=len(self.analyze_m26_header_ids), dtype=np.int64)\n self.m26_n_words = np.zeros(shape=len(self.analyze_m26_header_ids), dtype=np.uint32) # The number of words containing column / row info\n self.m26_rows = np.zeros(shape=len(self.analyze_m26_header_ids), dtype=np.uint32) # The actual readout row (rolling shutter)\n self.m26_frame_status = np.zeros(shape=len(self.analyze_m26_header_ids), dtype=np.uint32) # The status flags for the actual frames\n self.last_completed_m26_frame_ids = -1 * np.ones(shape=len(self.analyze_m26_header_ids), dtype=np.int64) # The status if the frame is complete for the actual frame\n # Per event variables\n self.event_number = np.int64(-1) # The event number of the actual trigger, event number starts at 0\n self.trigger_number = np.int64(-1) # The trigger number of the actual trigger\n self.trigger_timestamp = np.int64(0) # The trigger timestamp of the actual trigger\n\n # Event builder\n self.hits = np.zeros(shape=0, dtype=hits_dtype)\n self.hits_index = np.int64(-1)\n\n # Properties\n self._add_missing_events = False\n self._timing_offset = TIMING_OFFSET\n\n @property\n def add_missing_events(self):\n return self._add_missing_events\n\n @add_missing_events.setter\n def add_missing_events(self, value):\n self._add_missing_events = bool(value)\n\n @property\n def timing_offset(self):\n return self._timing_offset\n\n @timing_offset.setter\n def timing_offset(self, value):\n self._timing_offset = int(value)\n\n def interpret_raw_data(self, raw_data=None, build_all_events=False):\n ''' Converting the raw data array to a hit array.\n The is the only function that needs to be called to convert the raw data.\n\n Parameters:\n -----------\n raw_data : np.array\n The array with the raw data words.\n build_all_events : bool\n If True, build all events from the remaining trigger_data and telescope_data_array.\n Use this only after the last raw data chunk to receive the the remaining events in the buffers.\n '''\n if raw_data is None:\n raw_data = np.zeros(shape=0, dtype=np.uint32)\n if self.telescope_data_index != -1:\n telescope_data_index_start = self.telescope_data_index + 1\n else:\n telescope_data_index_start = 0\n # Analyze raw data\n self.trigger_data, self.trigger_data_index, self.telescope_data, self.telescope_data_index, self.m26_frame_ids, self.m26_frame_length, self.m26_data_loss, self.m26_word_index, self.m26_timestamps, self.last_m26_timestamps, self.m26_n_words, self.m26_rows, self.m26_frame_status, self.last_completed_m26_frame_ids, self.event_number, self.trigger_number, self.trigger_timestamp = _interpret_raw_data(\n raw_data=raw_data,\n trigger_data=self.trigger_data,\n trigger_data_index=self.trigger_data_index,\n telescope_data=self.telescope_data,\n telescope_data_index=self.telescope_data_index,\n m26_frame_ids=self.m26_frame_ids,\n m26_frame_length=self.m26_frame_length,\n m26_data_loss=self.m26_data_loss,\n m26_word_index=self.m26_word_index,\n m26_timestamps=self.m26_timestamps,\n last_m26_timestamps=self.last_m26_timestamps,\n m26_n_words=self.m26_n_words,\n m26_rows=self.m26_rows,\n m26_frame_status=self.m26_frame_status,\n last_completed_m26_frame_ids=self.last_completed_m26_frame_ids,\n event_number=self.event_number,\n trigger_number=self.trigger_number,\n trigger_timestamp=self.trigger_timestamp,\n add_missing_events=self.add_missing_events,\n build_all_events=build_all_events,\n analyze_m26_header_ids=self.analyze_m26_header_ids,\n plane_id_to_index=self.plane_id_to_index)\n\n # Get data from telescope (just hit data, no assignment to events or data multiplication)\n telescope_data = self.telescope_data[telescope_data_index_start:self.telescope_data_index + 1].copy()\n\n # Build events\n self.trigger_data, self.trigger_data_index, self.telescope_data, self.telescope_data_index, self.hits, self.hits_index = _build_events(\n trigger_data=self.trigger_data,\n trigger_data_index=self.trigger_data_index,\n telescope_data=self.telescope_data,\n telescope_data_index=self.telescope_data_index,\n hits=self.hits,\n hits_index=self.hits_index,\n last_completed_m26_frame_ids=self.last_completed_m26_frame_ids,\n timing_offset=self.timing_offset,\n build_all_events=build_all_events,\n analyze_m26_header_ids=self.analyze_m26_header_ids,\n plane_id_to_index=self.plane_id_to_index)\n # Create a copy of the hits array that is returned\n hits = self.hits[:self.hits_index + 1].copy()\n self.hits_index -= (self.hits_index + 1)\n\n return hits, telescope_data\n\n\n@njit(locals={'trigger_data_index': numba.int64, 'telescope_data_index': numba.int64, 'trigger_status': numba.uint32, 'last_trigger_number': numba.int64, 'last_trigger_timestamp': numba.int64, 'n_missing_events': numba.uint32})\ndef _interpret_raw_data(raw_data, trigger_data, trigger_data_index, telescope_data, telescope_data_index, m26_frame_ids, m26_frame_length, m26_data_loss, m26_word_index, m26_timestamps, last_m26_timestamps, m26_n_words, m26_rows, m26_frame_status, last_completed_m26_frame_ids, event_number, trigger_number, trigger_timestamp, add_missing_events, build_all_events, analyze_m26_header_ids, plane_id_to_index):\n ''' This function is interpreting the Mimosa26 telescope raw data and creates temporary trigger and telescope data arrays.\n The interpreter checks for trigger and Mimosa26 data errors.\n\n Parameters:\n -----------\n raw_data : np.array\n The array with the raw data words.\n TBD\n '''\n # Loop over the raw data words\n for raw_data_word in raw_data:\n if is_mimosa_data(raw_data_word): # Check if word is from Mimosa26.\n # Check to which plane the data belongs\n plane_id = get_plane_number(raw_data_word) # The actual_plane if the actual word belongs to (0 to 5)\n for analyze_m26_header_id in analyze_m26_header_ids:\n if plane_id == analyze_m26_header_id:\n break\n else:\n continue # Do not interpret data of planes which should be skipped\n plane_index = plane_id_to_index[plane_id]\n # In the following, interpretation of the raw data words of the actual plane\n # Check for data loss bit set by the M26 RX FSM\n if is_data_loss(raw_data_word):\n # Setting the data loss flag to true.\n # The data loss bit is set by the M26 RX FSM.\n # The bit is set only once after each data loss, i.e.,\n # the first data word after the lost data words.\n m26_data_loss[plane_index] = True\n if is_frame_header(raw_data_word): # New frame for actual plane, M26 timestamp (LSB), frame header0\n # Get Mimosa26 timestamp from raw data word (LSB)\n last_m26_timestamps[plane_index] = m26_timestamps[plane_index]\n m26_timestamps[plane_index] = (m26_timestamps[plane_index] & 0x7fffffffffff0000) | get_m26_timestamp_low(raw_data_word)\n m26_word_index[plane_index] = 0\n # Reset parameters after header\n m26_frame_length[plane_index] = 0\n m26_n_words[plane_index] = 0\n # Set the status bits for priviously incomplete frames\n index = telescope_data_index\n while index >= 0:\n if telescope_data[index]['plane'] == plane_id:\n if telescope_data[index]['frame_id'] > last_completed_m26_frame_ids[plane_index]:\n telescope_data[index]['frame_status'] |= DATA_ERROR\n else:\n break\n index -= 1\n m26_data_loss[plane_index] = False\n m26_frame_status[plane_index] = 0\n elif m26_data_loss[plane_index] is True: # Trash data\n # Nothing to do, do not trust data\n continue\n else: # Interpreting M26 raw data\n m26_word_index[plane_index] += 1\n if m26_word_index[plane_index] == 1: # Mimosa26 timestamp, M26 timestamp (MSB), frame header1\n # Check for 32bit timestamp overflow\n if m26_timestamps[plane_index] >= 0 and get_m26_timestamp_high(raw_data_word) < (m26_timestamps[plane_index] & 0x00000000ffff0000):\n m26_frame_status[plane_index] |= TIMESTAMP_OVERFLOW\n m26_timestamps[plane_index] = np.int64(2**32) + m26_timestamps[plane_index]\n # Get Mimosa26 timestamp from raw data word (MSB)\n m26_timestamps[plane_index] = get_m26_timestamp_high(raw_data_word) | (m26_timestamps[plane_index] & 0x7fffffff0000ffff)\n elif m26_word_index[plane_index] == 2: # Mimosa26 frame ID\n # Get Mimosa26 frame ID from raw data word (LSB)\n m26_frame_ids[plane_index] = (m26_frame_ids[plane_index] & 0x7fffffffffff0000) | get_frame_id_low(raw_data_word)\n elif m26_word_index[plane_index] == 3: # Mimosa26 frame ID\n # Check for 32bit frame ID overflow\n if m26_frame_ids[plane_index] >= 0 and get_frame_id_high(raw_data_word) < (m26_frame_ids[plane_index] & 0x00000000ffff0000):\n m26_frame_status[plane_index] |= FRAME_ID_OVERFLOW\n m26_frame_ids[plane_index] = np.int64(2**32) + m26_frame_ids[plane_index]\n # Get Mimosa26 frame ID from raw data word (MSB)\n m26_frame_ids[plane_index] = get_frame_id_high(raw_data_word) | (m26_frame_ids[plane_index] & 0x7fffffff0000ffff)\n elif m26_word_index[plane_index] == 4: # Mimosa26 frame length\n m26_frame_length[plane_index] = get_frame_length(raw_data_word)\n if m26_frame_length[plane_index] > 570: # Defined in the Mimosa26 protocol, no more than 570 \"useful\" data words\n m26_data_loss[plane_index] = True\n continue\n elif m26_word_index[plane_index] == 5: # Mimosa26 frame length, a second time\n if m26_frame_length[plane_index] != get_frame_length(raw_data_word): # DO0 & DO1 should always have the same data length\n m26_data_loss[plane_index] = True\n continue\n else:\n m26_frame_length[plane_index] += get_frame_length(raw_data_word)\n elif m26_word_index[plane_index] == 5 + m26_frame_length[plane_index] + 1: # Frame trailer0\n if not is_frame_trailer0(raw_data_word):\n m26_data_loss[plane_index] = True\n continue\n elif m26_word_index[plane_index] == 5 + m26_frame_length[plane_index] + 2: # Frame trailer1\n if not is_frame_trailer1(raw_data_word, plane=plane_id):\n m26_data_loss[plane_index] = True\n continue\n else:\n last_completed_m26_frame_ids[plane_index] = m26_frame_ids[plane_index]\n elif m26_word_index[plane_index] > 5 + m26_frame_length[plane_index] + 2: # Ignore any occurrence of additional raw data words\n m26_data_loss[plane_index] = True\n continue\n else: # Column / Row words (actual data word with hits)\n if m26_n_words[plane_index] == 0: # First word contains the row info and the number of data words for this row\n if m26_word_index[plane_index] == 5 + m26_frame_length[plane_index]: # Always even amount of words or this fill word is used\n # Ignore this fill word\n continue\n else:\n m26_n_words[plane_index] = get_n_words(raw_data_word)\n m26_rows[plane_index] = get_row(raw_data_word) # Get row from data word\n if m26_rows[plane_index] >= 576: # Row overflow\n m26_data_loss[plane_index] = True\n continue\n if has_overflow(raw_data_word):\n m26_frame_status[plane_index] |= OVERFLOW_FLAG # set overflow bit\n else:\n m26_frame_status[plane_index] & ~OVERFLOW_FLAG # unset overflow bit\n else:\n m26_n_words[plane_index] = m26_n_words[plane_index] - 1 # Count down the words\n n_hits = get_n_hits(raw_data_word)\n column = get_column(raw_data_word) # Get column from data word\n if column >= 1152: # Column overflow\n m26_data_loss[plane_index] = True\n continue\n for k in range(n_hits + 1):\n if column + k >= 1152:\n m26_data_loss[plane_index] = True\n break\n # Increase index\n telescope_data_index += 1\n # extend telescope data array if neccessary\n if telescope_data_index >= telescope_data.shape[0]:\n # remove old hit data from array for each plane individually. Prevents the case that telescope data array gets too big in case\n # time until next trigger is very large, since telescope data has to be buffered until next trigger.\n select = (telescope_data['plane'] == plane_id)\n select &= (telescope_data['time_stamp'] < (m26_timestamps[plane_index] - MAX_BUFFER_TIME_SLIP * MIMOSA_FREQ * 10**6))\n count_outdated = np.sum(select)\n if count_outdated:\n telescope_data = telescope_data[~select]\n telescope_data_index = telescope_data_index - count_outdated\n # extend telescope data array if neccessary\n telescope_data_tmp = np.zeros(shape=max(1, int(raw_data.shape[0] / 2)), dtype=telescope_data_dtype)\n telescope_data = np.concatenate((telescope_data, telescope_data_tmp))\n\n # Store hits\n telescope_data[telescope_data_index]['plane'] = plane_id\n telescope_data[telescope_data_index]['time_stamp'] = m26_timestamps[plane_index]\n telescope_data[telescope_data_index]['frame_id'] = m26_frame_ids[plane_index]\n telescope_data[telescope_data_index]['column'] = column + k\n telescope_data[telescope_data_index]['row'] = m26_rows[plane_index]\n telescope_data[telescope_data_index]['frame_status'] = m26_frame_status[plane_index]\n elif is_trigger_word(raw_data_word): # Raw data word is TLU/trigger word\n # Reset trigger status\n trigger_status = 0\n # Get latest telescope timestamp and set trigger timestamp\n last_trigger_timestamp = trigger_timestamp\n # Get largest M26 timestamp\n for tmp_plane_index, _ in enumerate(analyze_m26_header_ids):\n if last_m26_timestamps[tmp_plane_index] > trigger_timestamp:\n trigger_timestamp = last_m26_timestamps[tmp_plane_index]\n # Calculating 63bit timestamp from 15bit trigger timestamp\n # and last telescope timestamp (frame header timestamp).\n # Assumption: the telescope timestamp is updated more frequent than\n # the 15bit trigger timestamp can overflow. The frame is occurring\n # every 4608 clock cycles (115.2 us).\n # Get trigger timestamp from raw data word\n trigger_timestamp = (0x7fffffffffff8000 & trigger_timestamp) | get_trigger_timestamp(raw_data_word)\n # Check for 15bit trigger timestamp overflow\n if last_trigger_timestamp >= 0 and trigger_timestamp <= last_trigger_timestamp:\n trigger_status |= TRIGGER_TIMESTAMP_OVERFLOW\n trigger_timestamp = np.int64(2**15) + trigger_timestamp\n # Copy of trigger number\n last_trigger_number = trigger_number\n # Check for 16bit trigger number overflow\n if trigger_number >= 0 and get_trigger_number(raw_data_word, trigger_data_format=2) <= (trigger_number & 0x000000000000ffff):\n trigger_status |= TRIGGER_NUMBER_OVERFLOW\n trigger_number = np.int64(2**16) + trigger_number\n # Get trigger number from raw data word\n if trigger_number < 0:\n trigger_number = get_trigger_number(raw_data_word, trigger_data_format=2)\n else:\n trigger_number = (0x7fffffffffff0000 & trigger_number) | get_trigger_number(raw_data_word, trigger_data_format=2)\n # Check validity of trigger number\n # Trigger number has to increase by 1\n if trigger_data_index >= 0:\n # Check if trigger number has increased by 1\n if last_trigger_number < 0:\n n_missing_events = 0\n else:\n n_missing_events = trigger_number - (last_trigger_number + 1)\n if n_missing_events != 0:\n if n_missing_events > 0 and add_missing_events:\n for i in range(n_missing_events):\n # Increase index\n trigger_data_index += 1\n # extend trigger data array if neccessary\n if trigger_data_index >= trigger_data.shape[0]:\n trigger_data_tmp = np.zeros(shape=max(1, int(raw_data.shape[0] / 6)), dtype=trigger_data_dtype)\n trigger_data = np.concatenate((trigger_data, trigger_data_tmp))\n # Increase event number\n event_number += 1\n # Store trigger data\n trigger_data[trigger_data_index]['event_number'] = event_number # Timestamp of TLU word\n trigger_data[trigger_data_index]['trigger_time_stamp'] = -1 # Timestamp of TLU word\n trigger_data[trigger_data_index]['trigger_number'] = trigger_data[trigger_data_index - 1]['trigger_number'] + 1 + i\n trigger_data[trigger_data_index]['trigger_status'] = NO_TRIGGER_WORD_ERROR # Trigger status\n else:\n trigger_status |= TRIGGER_NUMBER_ERROR\n # Increase index\n trigger_data_index += 1\n # extend trigger data array if neccessary\n if trigger_data_index >= trigger_data.shape[0]:\n trigger_data_tmp = np.zeros(shape=max(1, int(raw_data.shape[0] / 6)), dtype=trigger_data_dtype)\n trigger_data = np.concatenate((trigger_data, trigger_data_tmp))\n # Increase event number\n event_number += 1\n # Store trigger data\n trigger_data[trigger_data_index]['event_number'] = event_number # Timestamp of TLU word\n trigger_data[trigger_data_index]['trigger_number'] = trigger_number\n trigger_data[trigger_data_index]['trigger_time_stamp'] = trigger_timestamp # Timestamp of TLU word\n trigger_data[trigger_data_index]['trigger_status'] = trigger_status # Trigger status\n else: # Raw data contains unknown word, neither M26 nor TLU word\n for tmp_plane_index, _ in enumerate(analyze_m26_header_ids):\n m26_data_loss[tmp_plane_index] = True\n\n # Set the status bits for priviously incomplete frames\n if build_all_events:\n for tmp_plane_index, tmp_plane_id in enumerate(analyze_m26_header_ids):\n index = telescope_data_index\n while index >= 0:\n if telescope_data[index]['plane'] == tmp_plane_id:\n if telescope_data[index]['frame_id'] > last_completed_m26_frame_ids[tmp_plane_index]:\n telescope_data[index]['frame_status'] |= DATA_ERROR\n else:\n break\n index -= 1\n\n return trigger_data, trigger_data_index, telescope_data, telescope_data_index, m26_frame_ids, m26_frame_length, m26_data_loss, m26_word_index, m26_timestamps, last_m26_timestamps, m26_n_words, m26_rows, m26_frame_status, last_completed_m26_frame_ids, event_number, trigger_number, trigger_timestamp\n\n\n@njit(locals={'hits_index': numba.int64, 'curr_trigger_data_index': numba.int64, 'curr_telescope_data_index': numba.int64})\ndef _build_events(trigger_data, trigger_data_index, telescope_data, telescope_data_index, hits, hits_index, last_completed_m26_frame_ids, timing_offset, build_all_events, analyze_m26_header_ids, plane_id_to_index):\n ''' This function is builds events from the temporary trigger and telescope data arrays.\n\n Parameters:\n -----------\n TBD\n '''\n latest_trigger_data_index = -1\n finished_telescope_data_indices = -1 * np.ones(shape=len(analyze_m26_header_ids), dtype=np.int64)\n last_event_trigger_data_indices = -1 * np.ones(shape=len(analyze_m26_header_ids), dtype=np.int64)\n finished_event = np.ones(shape=len(analyze_m26_header_ids), dtype=np.bool_)\n curr_event_status = np.zeros(shape=len(analyze_m26_header_ids), dtype=np.uint32)\n\n curr_trigger_data_index = 0\n curr_hits_index = hits_index\n # adding hits\n while curr_trigger_data_index <= trigger_data_index and np.all(finished_event):\n trigger_event_number = trigger_data[curr_trigger_data_index]['event_number']\n trigger_number = trigger_data[curr_trigger_data_index]['trigger_number']\n trigger_timestamp = trigger_data[curr_trigger_data_index]['trigger_time_stamp']\n trigger_status = trigger_data[curr_trigger_data_index]['trigger_status']\n curr_telescope_data_index = np.min(finished_telescope_data_indices) + 1\n # Reset status\n for tmp_plane_index, _ in enumerate(analyze_m26_header_ids):\n finished_event[tmp_plane_index] = False\n curr_event_status[tmp_plane_index] = 0\n while curr_telescope_data_index <= telescope_data_index:\n curr_plane_id = telescope_data[curr_telescope_data_index]['plane']\n curr_plane_index = plane_id_to_index[curr_plane_id]\n curr_frame_id = telescope_data[curr_telescope_data_index]['frame_id']\n if not finished_event[curr_plane_index] and (build_all_events or curr_frame_id <= last_completed_m26_frame_ids[curr_plane_index]):\n hit_timestamp_start = telescope_data[curr_telescope_data_index]['time_stamp'] + telescope_data[curr_telescope_data_index]['row'] * ROW_UNIT_CYCLE - 2 * FRAME_UNIT_CYCLE - timing_offset\n hit_timestamp_stop = hit_timestamp_start + FRAME_UNIT_CYCLE + ROW_UNIT_CYCLE\n if hit_timestamp_start <= trigger_timestamp and trigger_timestamp < hit_timestamp_stop:\n curr_hits_index += 1\n # extend hits array if neccessary\n if curr_hits_index >= hits.shape[0]:\n hits_tmp = np.zeros(shape=telescope_data.shape[0], dtype=hits_dtype)\n hits = np.concatenate((hits, hits_tmp))\n # Adding hits to event\n hits[curr_hits_index]['plane'] = curr_plane_id\n hits[curr_hits_index]['event_number'] = trigger_event_number\n hits[curr_hits_index]['trigger_number'] = trigger_number\n hits[curr_hits_index]['trigger_time_stamp'] = trigger_timestamp\n hits[curr_hits_index]['row_time_stamp'] = hit_timestamp_start\n hits[curr_hits_index]['frame_id'] = curr_frame_id\n hits[curr_hits_index]['column'] = telescope_data[curr_telescope_data_index]['column']\n hits[curr_hits_index]['row'] = telescope_data[curr_telescope_data_index]['row']\n hits[curr_hits_index]['event_status'] = 0\n curr_event_status[curr_plane_index] |= telescope_data[curr_telescope_data_index]['frame_status'] | trigger_status\n elif hit_timestamp_start > trigger_timestamp:\n # latest_trigger_data_indices[plane_id_to_index[telescope_data[curr_telescope_data_index]['plane']]] = curr_trigger_data_index\n finished_event[plane_id_to_index[telescope_data[curr_telescope_data_index]['plane']]] = True\n if np.all(finished_event):\n latest_trigger_data_index = curr_trigger_data_index\n for tmp_plane_index, _ in enumerate(analyze_m26_header_ids):\n last_event_trigger_data_indices[tmp_plane_index] = finished_telescope_data_indices[tmp_plane_index]\n hits_index = curr_hits_index\n # Set event status for complete event\n index = curr_hits_index\n while trigger_event_number == hits[index]['event_number'] and index >= 0:\n hits[index]['event_status'] = curr_event_status[plane_id_to_index[hits[index]['plane']]]\n index -= 1\n break\n else: # trigger_timestamp >= hit_timestamp_stop\n finished_telescope_data_indices[plane_id_to_index[telescope_data[curr_telescope_data_index]['plane']]] = curr_telescope_data_index\n curr_telescope_data_index += 1\n # special case\n if build_all_events:\n hits_index = curr_hits_index\n # Set event status for complete event\n index = curr_hits_index\n while index >= 0:\n if hits[index]['event_number'] == trigger_event_number:\n hits[index]['event_status'] = curr_event_status[plane_id_to_index[hits[index]['plane']]]\n elif hits[index]['event_number'] < trigger_event_number:\n break\n index -= 1\n for tmp_plane_index, _ in enumerate(analyze_m26_header_ids):\n finished_event[tmp_plane_index] = True\n curr_trigger_data_index += 1\n\n if build_all_events:\n telescope_data_start_index = telescope_data_index + 1\n else:\n telescope_data_start_index = np.min(last_event_trigger_data_indices) + 1\n telescope_data = telescope_data[telescope_data_start_index:]\n telescope_data_index -= telescope_data_start_index\n if build_all_events:\n trigger_data_start_index = trigger_data_index + 1\n else:\n trigger_data_start_index = latest_trigger_data_index + 1\n trigger_data = trigger_data[trigger_data_start_index:]\n trigger_data_index -= trigger_data_start_index\n\n return trigger_data, trigger_data_index, telescope_data, telescope_data_index, hits, hits_index\n", "meta": {"hexsha": "55d503c8ce5cce93da23902fa44854d5aff7a512", "size": 35958, "ext": "py", "lang": "Python", "max_stars_repo_path": "pymosa_mimosa26_interpreter/raw_data_interpreter.py", "max_stars_repo_name": "SiLab-Bonn/pymosa_mimosa26_interpreter", "max_stars_repo_head_hexsha": "ef43b72dfed65b072703627a18d6e47a8a344165", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pymosa_mimosa26_interpreter/raw_data_interpreter.py", "max_issues_repo_name": "SiLab-Bonn/pymosa_mimosa26_interpreter", "max_issues_repo_head_hexsha": "ef43b72dfed65b072703627a18d6e47a8a344165", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 6, "max_issues_repo_issues_event_min_datetime": "2016-03-07T12:05:54.000Z", "max_issues_repo_issues_event_max_datetime": "2020-01-08T09:11:37.000Z", "max_forks_repo_path": "pymosa_mimosa26_interpreter/raw_data_interpreter.py", "max_forks_repo_name": "SiLab-Bonn/pyBAR_mimosa26_interpreter", "max_forks_repo_head_hexsha": "ef43b72dfed65b072703627a18d6e47a8a344165", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2016-03-04T20:22:38.000Z", "max_forks_repo_forks_event_max_datetime": "2017-08-25T07:44:12.000Z", "avg_line_length": 54.9816513761, "max_line_length": 408, "alphanum_fraction": 0.6500917737, "include": true, "reason": "import numpy,import numba,from numba", "num_tokens": 8117, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6039318337259584, "lm_q2_score": 0.320821300824607, "lm_q1q2_score": 0.19375419650535225}} {"text": "\"\"\"Calculate collision matrix of direct solution of LBTE.\"\"\"\n# Copyright (C) 2020 Atsushi Togo\n# All rights reserved.\n#\n# This file is part of phono3py.\n#\n# Redistribution and use in source and binary forms, with or without\n# modification, are permitted provided that the following conditions\n# are met:\n#\n# * Redistributions of source code must retain the above copyright\n# notice, this list of conditions and the following disclaimer.\n#\n# * Redistributions in binary form must reproduce the above copyright\n# notice, this list of conditions and the following disclaimer in\n# the documentation and/or other materials provided with the\n# distribution.\n#\n# * Neither the name of the phonopy project nor the names of its\n# contributors may be used to endorse or promote products derived\n# from this software without specific prior written permission.\n#\n# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n# \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS\n# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE\n# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,\n# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,\n# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\n# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN\n# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n# POSSIBILITY OF SUCH DAMAGE.\n\nimport numpy as np\nfrom phonopy.units import Kb, THzToEv\n\nfrom phono3py.phonon3.imag_self_energy import ImagSelfEnergy\nfrom phono3py.phonon3.interaction import Interaction\n\n\nclass CollisionMatrix(ImagSelfEnergy):\n \"\"\"Collision matrix of direct solution of LBTE for one grid point.\n\n Main diagonal part (imag-self-energy) and\n the other part are separately stored.\n\n \"\"\"\n\n def __init__(\n self,\n interaction: Interaction,\n rotations_cartesian=None,\n num_ir_grid_points=None,\n rot_grid_points=None,\n is_reducible_collision_matrix=False,\n log_level=0,\n lang=\"C\",\n ):\n \"\"\"Init method.\"\"\"\n self._pp: Interaction\n self._is_collision_matrix: bool\n self._sigma = None\n self._frequency_points = None\n self._temperature = None\n self._grid_point = None\n self._lang = None\n self._imag_self_energy = None\n self._collision_matrix = None\n self._pp_strength = None\n self._frequencies = None\n self._triplets_at_q = None\n self._triplets_map_at_q = None\n self._weights_at_q = None\n self._band_indices = None\n self._unit_conversion = None\n self._cutoff_frequency = None\n self._g = None\n self._unit_conversion = None\n self._log_level = log_level\n\n super().__init__(interaction, lang=lang)\n\n self._is_reducible_collision_matrix = is_reducible_collision_matrix\n self._is_collision_matrix = True\n\n if not self._is_reducible_collision_matrix:\n self._num_ir_grid_points = num_ir_grid_points\n self._rot_grid_points = np.array(\n self._pp.bz_grid.bzg2grg[rot_grid_points], dtype=\"int_\", order=\"C\"\n )\n self._rotations_cartesian = rotations_cartesian\n\n def run(self):\n \"\"\"Calculate collision matrix at a grid point.\"\"\"\n if self._pp_strength is None:\n self.run_interaction()\n\n num_band0 = self._pp_strength.shape[1]\n num_band = self._pp_strength.shape[2]\n self._imag_self_energy = np.zeros(num_band0, dtype=\"double\")\n\n if self._is_reducible_collision_matrix:\n num_mesh_points = np.prod(self._pp.mesh_numbers)\n self._collision_matrix = np.zeros(\n (num_band0, num_mesh_points, num_band), dtype=\"double\"\n )\n else:\n self._collision_matrix = np.zeros(\n (num_band0, 3, self._num_ir_grid_points, num_band, 3), dtype=\"double\"\n )\n self._run_with_band_indices()\n self._run_collision_matrix()\n\n def get_collision_matrix(self):\n \"\"\"Return collision matrix at a grid point.\"\"\"\n return self._collision_matrix\n\n def set_grid_point(self, grid_point=None):\n \"\"\"Set a grid point and prepare for collision matrix calculation.\"\"\"\n if grid_point is None:\n self._grid_point = None\n else:\n self._pp.set_grid_point(grid_point, store_triplets_map=True)\n self._pp_strength = None\n (\n self._triplets_at_q,\n self._weights_at_q,\n self._triplets_map_at_q,\n self._ir_map_at_q,\n ) = self._pp.get_triplets_at_q()\n self._grid_point = grid_point\n self._frequencies, self._eigenvectors, _ = self._pp.get_phonons()\n\n def _run_collision_matrix(self):\n if self._temperature > 0:\n if self._lang == \"C\":\n if self._is_reducible_collision_matrix:\n self._run_c_reducible_collision_matrix()\n else:\n self._run_c_collision_matrix()\n else:\n if self._is_reducible_collision_matrix:\n self._run_py_reducible_collision_matrix()\n else:\n self._run_py_collision_matrix()\n\n def _run_c_collision_matrix(self):\n import phono3py._phono3py as phono3c\n\n phono3c.collision_matrix(\n self._collision_matrix,\n self._pp_strength,\n self._frequencies,\n self._g,\n self._triplets_at_q,\n self._triplets_map_at_q,\n self._ir_map_at_q,\n self._rot_grid_points, # in GRGrid\n self._rotations_cartesian,\n self._temperature,\n self._unit_conversion,\n self._cutoff_frequency,\n )\n\n def _run_c_reducible_collision_matrix(self):\n import phono3py._phono3py as phono3c\n\n phono3c.reducible_collision_matrix(\n self._collision_matrix,\n self._pp_strength,\n self._frequencies,\n self._g,\n self._triplets_at_q,\n self._triplets_map_at_q,\n self._ir_map_at_q,\n self._temperature,\n self._unit_conversion,\n self._cutoff_frequency,\n )\n\n def _run_py_collision_matrix(self):\n r\"\"\"Sum over rotations, and q-points and bands for third phonons.\n\n \\Omega' = \\sum_R' R' \\Omega_{kp,R'k'p'}\n\n pp_strength.shape = (num_triplets, num_band0, num_band, num_band)\n\n \"\"\"\n num_band0 = self._pp_strength.shape[1]\n num_band = self._pp_strength.shape[2]\n gp2tp, tp2s, swapped = self._get_gp2tp_map()\n for i in range(self._num_ir_grid_points):\n r_gps = self._rot_grid_points[i]\n for r, r_gp in zip(self._rotations_cartesian, r_gps):\n inv_sinh = self._get_inv_sinh(tp2s[r_gp])\n ti = gp2tp[r_gp]\n for j, k in np.ndindex((num_band0, num_band)):\n if swapped[r_gp]:\n collision = (\n self._pp_strength[ti, j, :, k]\n * inv_sinh\n * self._g[2, ti, j, :, k]\n ).sum()\n else:\n collision = (\n self._pp_strength[ti, j, k]\n * inv_sinh\n * self._g[2, ti, j, k]\n ).sum()\n collision *= self._unit_conversion\n self._collision_matrix[j, :, i, k, :] += collision * r\n\n def _run_py_reducible_collision_matrix(self):\n r\"\"\"Sum over q-points and bands of third phonons.\n\n This corresponds to the second term of right hand side of\n \\Omega_{q0p0, q1p1} in Chaput's paper.\n\n pp_strength.shape = (num_triplets, num_band0, num_band, num_band)\n\n \"\"\"\n num_mesh_points = np.prod(self._pp.mesh_numbers)\n num_band0 = self._pp_strength.shape[1]\n num_band = self._pp_strength.shape[2]\n gp2tp, tp2s, swapped = self._get_gp2tp_map()\n for gp1 in range(num_mesh_points):\n inv_sinh = self._get_inv_sinh(tp2s[gp1])\n ti = gp2tp[gp1]\n for j, k in np.ndindex((num_band0, num_band)):\n if swapped[gp1]:\n collision = (\n self._pp_strength[ti, j, :, k]\n * inv_sinh\n * self._g[2, ti, j, :, k]\n ).sum()\n else:\n collision = (\n self._pp_strength[ti, j, k] * inv_sinh * self._g[2, ti, j, k]\n ).sum()\n collision *= self._unit_conversion\n self._collision_matrix[j, gp1, k] += collision\n\n def _get_gp2tp_map(self):\n \"\"\"Return mapping table from grid point index to triplet index.\n\n triplets_map_at_q contains index mapping of q1 in (q0, q1, q2) to\n independet q1 under q0+q1+q2=G with a fixed q0.\n\n Note\n ----\n map_q[gp1] <= gp1.:\n Symmetry relation of grid poi nts with a stabilizer q0.\n map_triplets[gp1] <= gp1 :\n map_q[gp1] == gp1 : map_q[gp2] if map_q[gp2] < gp1 otherwise gp1.\n map_q[gp1] != gp1 : map_triplets[map_q[gp1]]\n\n\n\n As a rule\n 1. map_triplets[gp1] == gp1 : [gp0, gp1, gp2]\n 2. map_triplets[gp1] != gp1 : [gp0, map_q[gp2], gp1'],\n map_triplets[gp1] == map_q[gp2]\n\n \"\"\"\n map_triplets = self._triplets_map_at_q\n map_q = self._ir_map_at_q\n gp2tp = -np.ones(len(map_triplets), dtype=\"int_\")\n tp2s = -np.ones(len(map_triplets), dtype=\"int_\")\n swapped = np.zeros(len(map_triplets), dtype=\"bytes\")\n num_tps = 0\n\n bzg2grg = self._pp.bz_grid.bzg2grg\n\n for gp1, tp_gp1 in enumerate(map_triplets):\n if map_q[gp1] == gp1:\n if gp1 == tp_gp1:\n gp2tp[gp1] = num_tps\n tp2s[gp1] = self._triplets_at_q[num_tps][2]\n assert bzg2grg[self._triplets_at_q[num_tps][1]] == gp1\n num_tps += 1\n else: # q1 <--> q2 swap if swappable.\n gp2tp[gp1] = gp2tp[tp_gp1]\n tp2s[gp1] = self._triplets_at_q[gp2tp[gp1]][1]\n swapped[gp1] = 1\n assert map_q[bzg2grg[self._triplets_at_q[gp2tp[gp1]][2]]] == gp1\n else: # q1 is not in ir-q1s.\n gp2tp[gp1] = gp2tp[map_q[gp1]]\n tp2s[gp1] = tp2s[map_q[gp1]]\n swapped[gp1] = swapped[map_q[gp1]]\n\n # Alternative implementation of tp2s\n # grg2bzg = self._pp.bz_grid.grg2bzg\n # addresses = self._pp.bz_grid.addresses\n # q0 = addresses[self._triplets_at_q[0][0]]\n # q1 = addresses[grg2bzg[gp1]]\n # q2 = -q0 - q1\n # gp2 = get_grid_point_from_address(q2, self._pp.bz_grid.D_diag)\n # tp2s[gp1] = self._pp.bz_grid.grg2bzg[gp2]\n\n return gp2tp, tp2s, swapped\n\n def _get_inv_sinh(self, gp):\n \"\"\"Return sinh term for bands at a q-point.\"\"\"\n freqs = self._frequencies[gp]\n sinh = np.where(\n freqs > self._cutoff_frequency,\n np.sinh(freqs * THzToEv / (2 * Kb * self._temperature)),\n -1.0,\n )\n inv_sinh = np.where(sinh > 0, 1.0 / sinh, 0)\n\n return inv_sinh\n", "meta": {"hexsha": "86e82557dac1386d92b68148fcf81c31069b90a5", "size": 11814, "ext": "py", "lang": "Python", "max_stars_repo_path": "phono3py/phonon3/collision_matrix.py", "max_stars_repo_name": "sjli47/phono3py-sjl", "max_stars_repo_head_hexsha": "22740415512d2f9bd00cbf2dc43594de003a37df", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "phono3py/phonon3/collision_matrix.py", "max_issues_repo_name": "sjli47/phono3py-sjl", "max_issues_repo_head_hexsha": "22740415512d2f9bd00cbf2dc43594de003a37df", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "phono3py/phonon3/collision_matrix.py", "max_forks_repo_name": "sjli47/phono3py-sjl", "max_forks_repo_head_hexsha": "22740415512d2f9bd00cbf2dc43594de003a37df", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.5047619048, "max_line_length": 85, "alphanum_fraction": 0.5879465041, "include": true, "reason": "import numpy", "num_tokens": 2912, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.603931819468636, "lm_q2_score": 0.3208212943308302, "lm_q1q2_score": 0.1937541880095011}} {"text": "#! /usr/bin/env python\n#S.rodney\n# 2011.05.04\n\"\"\"\nExtrapolate the Hsiao SED and the non1a SEDs \ndown to 300 angstroms to allow the W filter to \nreach out to z=2.5 smoothly in the k-correction \ntables and model light curves.\n\"\"\"\n\nimport os\nfrom numpy import *\nfrom pylab import * \n\ntry : sndataroot = os.environ['SNDATA_ROOT']\nexcept KeyError: \n sndataroot = os.path.abspath( '.' )\n\nMINWAVE = 300 # min wavelength for extrapolation (Angstroms)\nMAXWAVE = 20000 # max wavelength for extrapolation (Angstroms)\n\ndef extendEverything( salt2dir = 'models/SALT2/SALT2.Guy10_UV2IR', \n doCC=True, doIa=True ) :\n \"\"\" Run all the extrapolation functions, for both the SALT2 model \n components and all the non1a SEDs \"\"\"\n\n if doCC : \n extendNon1a()\n\n if doIa : \n salt2dir = os.path.join( sndataroot, salt2dir ) \n if not os.path.isdir( salt2dir ) : \n os.makedirs( salt2dir )\n\n # make the Hsiao07.extrap.dat template SED\n hsiao07 = os.path.join( sndataroot, 'snsed/Hsiao07.dat')\n hsiao07ext = os.path.join( sndataroot, 'snsed/Hsiao07.extrap.dat')\n extrapolatesed_linfit( hsiao07, hsiao07ext, Npt=10, Nsmooth=0, forceslope=True )\n\n extendSALT2_temp0()\n extendSALT2_temp1()\n extendSALT2_flatline() \n\n\ndef getsed( sedfile = os.path.join( sndataroot, 'snsed/Hsiao07.dat'), day='all' ) : \n d,w,f = loadtxt( sedfile, unpack=True ) \n\n #d = d.astype(int)\n days = unique( d ) \n\n if day == 'all' : \n dlist = [ d[ where( d == day ) ] for day in days ]\n wlist = [ w[ where( d == day ) ] for day in days ]\n flist = [ f[ where( d == day ) ] for day in days ]\n return( dlist, wlist, flist )\n else : \n return( w[ where( d == day ) ], f[ where( d == day ) ] )\n\n\ndef plotsed( sedfile= os.path.join( sndataroot, 'snsed/Hsiao07.dat'), \n day='all', normalize=False, **kwarg): \n dlist,wlist,flist = getsed( sedfile ) \n #days = unique( dlist ) \n for i in range( len(wlist) ) : \n thisday = dlist[i][0]\n \n #defaults = { 'label':str(thisday) } \n #plotarg = dict( kwarg.items() + defaults.items() )\n if day!='all' : \n if abs(thisday-day)>0.6 : continue\n offset, normfactor = 0, 1\n if normalize : \n if normalize > 1 : \n normfactor = (flist[i][:-1] * (wlist[i][1:]-wlist[i][:-1])).sum()\n else : \n normfactor = flist[i].max()\n offset = thisday\n plot( wlist[i], flist[i]/normfactor + offset, **kwarg )\n # user_in=raw_input('%i : return to continue'%i)\n\n\ndef extrapolatesed( sedfile, newsedfile, minwave=MINWAVE, maxwave=MAXWAVE, \n Bzptwave=900, Bextwave=2000, Bfrac=0.2, Brefwave=2800, \n Nred = 10, Nsmooth=0, verbose=False ):\n \"\"\"\n Set bluewave and bluefrac to define an extrapolation point\n blueward of the low-wavelength edge of the SED: \n Bextwave = wavelength of the extrapolation point\n Brefwave = reference wavelength for setting extrapolated flux \n Bfrac = fraction of the flux at Brefwave to set as the \n flux value at Bextwave\n The linear extrapolation uses only this fixed point and\n the input SED point at Brefwave. \n\n On the red side (where the SED tail is more well behaved)\n we perform a linear fit to the last Nred points to define \n the extrapolation. Set Nsmooth to a positive integer to set \n the window size for median smoothing of the input spectrum \n before the linear fitting. \n\n e.g. Bzptwave, Bextwave, Bfrac, Brefwave = 900, 2000, 0.2, 2800 \n fix the flux at 900 angstroms to be 0. \n fix the flux at 2000 angstroms to be 20% of the input SED's\n flux at 2800 angstrom, then define a piecewise linear extrapolation\n connecting the three anchor points at 900, 2000, and the minimum \n wavelength of the input SED.\n\n Note: For CCSN SEDs, we use \n Bzptwave=900, Bextwave=2000, Bfrac=0.2, Brefwave=2800, \n \n and for a SNIa SED, we might use \n Bzptwave=600, Bextwave=800, Bfrac=0.1, Brefwave=1000\n \n \"\"\"\n from scipy import interpolate as scint\n from scipy import stats\n import shutil\n\n medsmooth = lambda f,N : array( [ median( f[max(0,i-N):min(len(f),max(0,i-N)+2*N)]) for i in range(len(f)) ] )\n\n dlist,wlist,flist = getsed( sedfile ) # these are 2-D lists of SEDs at different phases\n dlistnew, wlistnew, flistnew = [],[],[]\n\n fout = open( newsedfile, 'w' )\n for i in range( len(dlist) ) : \n d,w,f = dlist[i],wlist[i],flist[i]\n\n if minwave < w[0] : \n wavestep = w[1] - w[0]\n irefpt = abs( w - Brefwave ).argmin()\n wrefpt = w[irefpt]\n frefpt = f[irefpt]\n wextpt = Bextwave\n fextpt = Bfrac * frefpt\n\n if wextpt < w[0] : \n # Blueward extrapolation from the minimum wavelength of the input \n # SED down to the first extrapolation point\n a = (f[0]-fextpt)/(w[0]-wextpt) # slope of extrapolation line\n b = f[0] - a*w[0] # intercept\n wextBlue = arange( wextpt, w[0], wavestep )\n fextBlue = array( [ max( 0, a * wave + b ) for wave in wextBlue ] ) \n w = append( wextBlue, w )\n f = append( fextBlue, f )\n if minwave < w[0] : \n # Blueward extrapolation to the min wavelength (fixed to zero flux at Bzptwave)\n wextpt = Bzptwave\n fextpt = 0\n a = (f[0]-fextpt)/(w[0]-wextpt) # slope of extrapolation line\n b = f[0] - a*w[0] # intercept\n wextBlue = arange( minwave, w[0], wavestep )\n fextBlue = array( [ max( 0, a * wave + b ) for wave in wextBlue ] ) \n w = append( wextBlue, w )\n f = append( fextBlue, f )\n \n if maxwave > w[-1] : \n # Redward linear extrapolation from last Nred points\n wavestep = w[-1] - w[-2]\n wN = w[-Nred:]\n\n if Nsmooth : fN = medsmooth( f, Nsmooth )[-Nred:]\n else : fN = f[-Nred:]\n (a,b,rval,pval,stderr)=stats.linregress(wN,fN)\n\n if a > 0 : \n # re-do redward linear extrapolation using the peak\n # in order to guarantee a downward slope\n if verbose : print( \" re-fitting %s day %i to ensure downward slope to the red\"%(sedfile, d[0]) )\n wN = [ w[ f.argmax() ], w[-1] ]\n fN = [ f.max(), f[-1], ]\n (a,b,rval,pval,stderr)=stats.linregress(wN,fN)\n\n wextRed = arange( w[-1]+wavestep, maxwave, wavestep )\n fextRed = array( [ max( 0, a * wave + b ) for wave in wextRed ] )\n\n w = append( w, wextRed )\n f = append( f, fextRed )\n \n for i in range( len( w ) ) :\n print >> fout, \"%7.2f %10.2f %12.7e\"%( d[0], w[i], f[i] )\n fout.close() \n\n return( newsedfile )\n\n\n\ndef extrapolatesed_linfit(sedfile, newsedfile, minwave=MINWAVE, maxwave=MAXWAVE, \n Npt=2, Nsmooth=0, forceslope=True, verbose=False ):\n \"\"\" use a linear fit of the first/last Npt points on the SED\n to extrapolate to the blue and red. \n\n Set Nsmooth to a positive integer to set the window size for median \n smoothing of the input spectrum before the linear fitting. \n \n With forceslope=True, check if the linear fit returns a slope that would \n send the tail upward (i.e. a positive derivative on the red side, negative \n on the blue side). If so, then re-do the fit using just the first/last \n point and the peak flux point, in order to guarantee a downward sloping tail.\n \"\"\"\n\n from scipy import interpolate as scint\n from scipy import stats\n import shutil\n\n medsmooth = lambda f,N : array( [ median( f[max(0,i-N):min(len(f),max(0,i-N)+2*N)]) for i in range(len(f)) ] )\n \n dlist,wlist,flist = getsed( sedfile ) \n dlistnew, wlistnew, flistnew = [],[],[]\n\n fout = open( newsedfile, 'w' )\n for i in range( len(dlist) ) : \n d,w,f = dlist[i],wlist[i],flist[i]\n\n if Nsmooth : ffit = medsmooth( f, Nsmooth )\n else : ffit = f\n wavestep = w[1] - w[0]\n\n # blueward linear extrapolation from first N points\n wN = w[:Npt]\n fN = ffit[:Npt]\n (a,b,rval,pval,stderr)=stats.linregress(wN,fN)\n if forceslope and a < 0 : \n # re-do blueward linear extrapolation using the peak\n # in order to guarantee a downward slope\n print( \" re-fitting %s day %i to ensure downward slope to the blue\"%(sedfile,d[0]))\n wN = [ w[0], w[ ffit.argmax() ] ]\n fN = [ f[0], ffit.max() ]\n (a,b,rval,pval,stderr)=stats.linregress(wN,fN)\n Nbluestep = len( arange( minwave, w[0], wavestep ) )\n wextBlue = sorted( [ w[0] -(i+1)*wavestep for i in range(Nbluestep) ] )\n fextBlue = array( [ max( 0, a * wave + b ) for wave in wextBlue ] )\n\n # redward linear extrapolation from last N points\n wN = w[-Npt:]\n fN = ffit[-Npt:]\n (a,b,rval,pval,stderr)=stats.linregress(wN,fN)\n if forceslope and a > 0 : \n # re-do redward linear extrapolation using the peak\n # in order to guarantee a downward slope\n if verbose : print( \" re-fitting %s day %i to ensure downward slope to the red\"%(sedfile, d[0]) )\n wN = [ w[ ffit.argmax() ], w[-1] ]\n fN = [ ffit.max(), ffit[-1], ]\n (a,b,rval,pval,stderr)=stats.linregress(wN,fN)\n Nredstep = len( arange( w[-1], maxwave, wavestep ) )\n wextRed = sorted( [ w[-1] + (i+1)*wavestep for i in range(Nredstep) ] )\n fextRed = array( [ max( 0, a * wave + b ) for wave in wextRed ] )\n\n wnew = append( append( wextBlue, w ), wextRed )\n fnew = append( append( fextBlue, f ), fextRed )\n # dnew = zeros( len(wnew) ) + d[0]\n \n for i in range( len( wnew ) ) :\n print >> fout, \"%7.2f %10.2f %12.7e\"%( d[0], wnew[i], fnew[i] )\n fout.close() \n\n return( newsedfile )\n\n\ndef extrapolatesed_flatline(sedfile, newsedfile, minwave=MINWAVE, maxwave=MAXWAVE ):\n \"\"\" extrapolate to the red and the blue using a flatline. i.e. the \n extrapolated flux is fixed to the endpoint values\n \"\"\"\n from scipy import interpolate as scint\n from scipy import stats\n import shutil\n \n dlist,wlist,flist = getsed( sedfile ) \n dlistnew, wlistnew, flistnew = [],[],[]\n\n fout = open( newsedfile, 'w' )\n for i in range( len(dlist) ) : \n d,w,f = dlist[i],wlist[i],flist[i]\n\n wavestep = w[1] - w[0]\n # blueward flatline extrapolation from first point\n Nbluestep = len( arange( minwave, w[0], wavestep ) )\n wextBlue = sorted( [ w[0] -(i+1)*wavestep for i in range(Nbluestep) ] )\n fextBlue = array( [ f[0] for wave in wextBlue ] )\n\n # redward flatline extrapolation from last point\n Nredstep = len( arange( w[-1], maxwave, wavestep ) )\n wextRed = sorted( [ w[-1] + (i+1)*wavestep for i in range(Nredstep) ] )\n fextRed = array( [ f[-1] for wave in wextRed ] )\n\n wnew = append( append( wextBlue, w ), wextRed )\n fnew = append( append( fextBlue, f ), fextRed )\n # dnew = zeros( len(wnew) ) + d[0]\n \n for i in range( len( wnew ) ) :\n print >> fout, \"%5.1f %10i %12.7e\"%( d[0], wnew[i], fnew[i] )\n fout.close() \n\n return( newsedfile )\n\n\ndef extendNon1a(origdir = \"snsed/non1a.ORIG\", verbose=True ):\n \"\"\" Extrapolate each of the Non-Ia template sed files,\n preserving a pristine copy in $SNDATA_ROOT/snsed/non1a.ORIG\n \"\"\"\n import glob\n import shutil\n\n origdir = os.path.join(sndataroot, origdir)\n non1adir = os.path.join(sndataroot, \"snsed/non1a\")\n if not os.path.isdir( origdir ) :\n os.rename( non1adir, origdir ) \n if not os.path.isdir( non1adir ) :\n os.mkdir( non1adir )\n\n otherstufflist = glob.glob(\"%s/*.DAT\"%(origdir)) + glob.glob(\"%s/*.LIST\"%(origdir)) + glob.glob(\"%s/*.INPUT\"%(origdir))\n for otherfile in otherstufflist : \n newfile = os.path.join( non1adir, os.path.basename( otherfile ) )\n shutil.copy( otherfile, newfile )\n \n sedlist = glob.glob(\"%s/*.SED\"%origdir)\n for sedfile in sedlist : \n newsedfile = os.path.join( non1adir, os.path.basename( sedfile ) )\n\n if 'SDSS-012842' in sedfile or 'SDSS-013449' in sedfile : \n # These are already super-smooth blackbodies for the IIn templates\n # 2-pt linear extrapolation is best.\n Npt = 2\n Nsmooth=0\n print(\"EXTRAPOLATING %s\\n ==> %s\"%(sedfile, newsedfile) )\n extrapolatesed_linfit(sedfile, newsedfile, minwave=MINWAVE, maxwave=MAXWAVE, \n Npt=Npt, Nsmooth=Nsmooth, forceslope=True )\n print(\" Done with %s.\\a\\a\\a\"%newsedfile)\n\n\n else : \n # for all other templates, we use a fixed blue anchor point \n # and on the red side we fit a lot of points so we don't \n # get thrown around by sharp spectral features\n Nred = 100\n Nsmooth = 20\n\n print(\"EXTRAPOLATING %s\\n ==> %s\"%(sedfile, newsedfile) )\n extrapolatesed( sedfile, newsedfile, minwave=MINWAVE, maxwave=MAXWAVE, \n Bextwave=2000, Bfrac=0.2, Brefwave=2800, \n Nred = 100, Nsmooth=20, verbose=verbose )\n print(\" Done with %s.\\a\\a\\a\"%newsedfile)\n\n\n\ndef extendSALT2_temp0( salt2dir = 'models/SALT2/SALT2.Guy10_UV2IR', \n salt2srcdir = 'models/SALT2/SALT2.Guy10_LAMOPEN', \n tailsedfile = 'snsed/Hsiao07.extrap.dat',\n wjoinblue = 2800, wjoinred = 8500 ,\n wmin = MINWAVE, wmax = MAXWAVE ):\n \"\"\" extend the salt2 Template_0 model component \n by adopting the UV and IR tails from another SED model. \n The default is to use SR's extrapolated modification \n of the Hsiao 2007 sed model, scaled and joined at the \n wjoin wavelengths, and extrapolated out to wmin and wmax. \n \"\"\"\n import shutil\n sndataroot = os.environ['SNDATA_ROOT']\n \n salt2dir = os.path.join( sndataroot, salt2dir ) \n salt2srcdir = os.path.join( sndataroot, salt2srcdir ) \n \n temp0fileIN = os.path.join( salt2srcdir, 'salt2_template_0.dat' ) \n temp0fileOUT = os.path.join( salt2dir, 'salt2_template_0.dat' ) \n temp0dat = getsed( sedfile=temp0fileIN ) \n\n tailsedfile = os.path.join( sndataroot, tailsedfile ) \n\n taildat = getsed( sedfile=tailsedfile ) \n \n dt,wt,ft = loadtxt( tailsedfile, unpack=True ) \n taildays = unique( dt ) \n\n # build up modified template from day -20 to +50\n outlines = []\n for i in range( 71 ) : \n thisday = i - 20\n\n # get the tail SED for this day\n it = where( taildays == thisday )[0]\n dt = taildat[0][it]\n wt = taildat[1][it]\n ft = taildat[2][it]\n\n #if thisday > 50 : \n # d0new = dt\n # w0new = wt\n # f0new = ft * (bluescale+redscale)/2.\n #else : \n\n # get the SALT2 template SED for this day\n d0 = temp0dat[0][i]\n w0 = temp0dat[1][i]\n f0 = temp0dat[2][i]\n print( 'splicing tail onto template for day : %i'%thisday )\n\n i0blue = argmin( abs(w0-wjoinblue) )\n itblue = argmin( abs( wt-wjoinblue))\n\n i0red = argmin( abs(w0-wjoinred) )\n itred = argmin( abs( wt-wjoinred))\n\n itmin = argmin( abs( wt-wmin))\n itmax = argmin( abs( wt-wmax))\n\n bluescale = f0[i0blue]/ft[itblue] \n redscale = f0[i0red]/ft[itred] \n\n d0new = dt.tolist()[itmin:itblue] + d0.tolist()[i0blue:i0red-1] + dt.tolist()[itred:itmax+1]\n w0new = wt.tolist()[itmin:itblue] + w0.tolist()[i0blue:i0red-1] + wt.tolist()[itred:itmax+1]\n f0new = (bluescale*ft).tolist()[itmin:itblue] + f0.tolist()[i0blue:i0red-1] + (redscale*ft).tolist()[itred:itmax+1]\n\n # plot it\n clf()\n plot( w0, f0, ls='-',color='b', lw=1, label='Input SALT2 Model')\n plot( wt, (bluescale+redscale)/2. * ft, ls=':',color='r', lw=1, label='SED model')\n plot( w0new, f0new, ls='--',color='k', lw=2, label='Extrapolated SALT2 model')\n legend()\n draw()\n #raw_input('return to continue')\n\n # append to the list of output data lines\n for j in range( len( d0new ) ) :\n outlines.append( \"%6.2f %12i %12.7e\\n\"%(\n d0new[j], w0new[j], f0new[j] ) )\n\n # write it out to the new template sed .dat file\n fout = open( temp0fileOUT, 'w' ) \n fout.writelines( outlines ) \n fout.close() \n \n\n\ndef extendSALT2_temp1( salt2dir = 'models/SALT2/SALT2.Guy10_UV2IR', \n salt2srcdir = 'models/SALT2/SALT2.Guy10_LAMOPEN', \n # wjoinblue = 2000, wjoinred = 8500 ,\n wjoinblue = None, wjoinred = None,\n wmin = MINWAVE, wmax = MAXWAVE,\n wstep = 10 ):\n \"\"\" extend the salt2 Template_1 model component \n with a flat line at 0 to the blue and to the red.\n If join wavelengths are not provided, uses the \n end points of the input spectrum\n \"\"\"\n import shutil\n sndataroot = os.environ['SNDATA_ROOT']\n \n salt2dir = os.path.join( sndataroot, salt2dir ) \n salt2srcdir = os.path.join( sndataroot, salt2srcdir ) \n \n temp1fileIN = os.path.join( salt2srcdir, 'salt2_template_1.dat' ) \n temp1fileOUT = os.path.join( salt2dir, 'salt2_template_1.dat' ) \n temp1dat = getsed( sedfile=temp1fileIN ) \n\n # build up modified template from day -20 to +50\n outlines = []\n for i in range( 71 ) : \n thisday = i - 20\n\n # get the SALT2 template SED for this day\n d1 = temp1dat[0][i]\n w1 = temp1dat[1][i]\n f1 = temp1dat[2][i]\n print( 'extrapolating with flatline onto template for day : %i'%thisday )\n \n if wjoinblue==None : wjoinblue=w1[0]\n if wjoinred==None : wjoinred=w1[-1]\n\n i1blue = argmin( abs(w1-wjoinblue) )\n i1red = argmin( abs(w1-wjoinred) )\n \n Nblue = int((wjoinblue-wmin )/wstep + 1)\n Nred = int((wmax -wjoinred )/wstep + 1)\n\n d1new = (ones(Nblue)*thisday).tolist() + d1.tolist()[i1blue+1:i1red-1] + (ones(Nred)*thisday).tolist()\n w1new = arange(wmin,wmin+Nblue*wstep,wstep).tolist() + w1.tolist()[i1blue+1:i1red-1] + arange(wjoinred,wjoinred+Nred*wstep,wstep).tolist()\n f1new = zeros(Nblue).tolist() + f1.tolist()[i1blue+1:i1red-1] + zeros(Nred).tolist()\n\n # plot it\n clf()\n plot( w1, f1, ls='-',color='r', lw=1)\n plot( w1new, f1new, ls='--',color='k', lw=2)\n draw()\n #raw_input('return to continue')\n\n # append to the list of output data lines\n for j in range( len( d1new ) ) :\n outlines.append( \"%6.2f %12i %12.7e\\n\"%(\n d1new[j], w1new[j], f1new[j] ) )\n\n # write it out to the new template sed .dat file\n fout = open( temp1fileOUT, 'w' ) \n fout.writelines( outlines ) \n fout.close() \n \n\n\ndef extendSALT2_flatline( salt2dir = 'models/SALT2/SALT2.Guy10_UV2IR', \n salt2srcdir = 'models/SALT2/SALT2.Guy10_LAMOPEN', \n wjoinblue = 2000, wjoinred = 8500 ,\n wmin = MINWAVE, wmax = MAXWAVE,\n wstep = 10, showplots=False ):\n \"\"\" extrapolate the *lc* and *spec* .dat files for SALT2\n using a flatline to the blue and red \"\"\"\n\n sndataroot = os.environ['SNDATA_ROOT']\n salt2dir = os.path.join( sndataroot, salt2dir ) \n salt2srcdir = os.path.join( sndataroot, salt2srcdir ) \n \n filelist = ['salt2_lc_dispersion_scaling.dat',\n 'salt2_lc_relative_covariance_01.dat',\n 'salt2_lc_relative_variance_0.dat',\n 'salt2_lc_relative_variance_1.dat',\n 'salt2_spec_covariance_01.dat',\n 'salt2_spec_variance_0.dat',\n 'salt2_spec_variance_1.dat']\n \n #for filename in ['salt2_lc_dispersion_scaling.dat']: \n #for filename in ['salt2_lc_relative_covariance_01.dat']:\n for filename in filelist : \n infile = os.path.join( salt2srcdir, filename )\n outfile = os.path.join( salt2dir, filename )\n\n newsedfile = extrapolatesed_flatline( infile, outfile, minwave=wmin, maxwave=wmax,\n wjoinblue=wjoinblue, wjoinred=wjoinred )\n \n # plot it\n if showplots: \n #for d in range(-20,50) : \n for d in [-10,-5,0,5,10,15,20,25,30,35,40,45,50] : \n clf()\n plotsed( infile, day=d, ls='-',color='r', lw=1) \n plotsed( outfile,day=d, ls='--',color='k', lw=2)\n print( '%s : day %i'%(filename,d) )\n draw()\n # raw_input('%s : day %i. return to continue'%(filename,d)) \n\n \n\ndef plotAll(): \n \"\"\" \n read in and plot all the non1a template SEDs at peak, \n in three panels, with the Ia template for comparison,\n \"\"\"\n ioff()\n ax1 = subplot( 131 )\n # plot the type II-L in purple\n plotsed( os.path.join(sndataroot,'snsed/non1a/Nugent+Scolnic_IIL.SED'), day=0, normalize=2, color='b', lw=0.5, label='II-L' )\n # plot the type IIn's in orange \n for sed in ['SDSS-012842','SDSS-013449'] : \n plotsed( os.path.join(sndataroot,'snsed/non1a/%s.SED'%sed), day=0.5, normalize=2, color='b', lw=0.5, label=sed )\n # Ia in red\n plotsed( os.path.join(sndataroot,'snsed/Hsiao07.extrap.dat'), day=0, normalize=2, color='r', label='Ia (Hsiao)', lw=2 )\n plotsed( os.path.join(sndataroot,'snsed/Hsiao07.dat'), day=0, normalize=2, color='k', label='Ia (Hsiao)', lw=1, ls=':' )\n title('Type II-L and IIn Templates')\n #legend()\n draw()\n\n subplot( 132, sharex=ax1, sharey=ax1 )\n # plot the type IIP's in blue \n IIpsedlist = [ 'SDSS-000018','SDSS-003818','SDSS-013376','SDSS-014450','SDSS-014599','SDSS-015031','SDSS-015320',\n 'SDSS-015339','SDSS-017564','SDSS-017862','SDSS-018109','SDSS-018297','SDSS-018408','SDSS-018441',\n 'SDSS-018457','SDSS-018590','SDSS-018596','SDSS-018700','SDSS-018713','SDSS-018734','SDSS-018793',\n 'SDSS-018834','SDSS-018892','SDSS-020038' ]\n for sed in IIpsedlist :\n plotsed( os.path.join(sndataroot,'snsed/non1a/%s.SED'%sed), day=0.5, normalize=2, color='b', lw=0.5, label=sed )\n # Ia in red\n plotsed( os.path.join(sndataroot,'snsed/Hsiao07.extrap.dat'), day=0, normalize=2, color='r', label='Ia (Hsiao)', lw=2 )\n plotsed( os.path.join(sndataroot,'snsed/Hsiao07.dat'), day=0, normalize=2, color='k', label='Ia (Hsiao)', lw=1, ls=':' )\n #legend()\n title('Type II-P Templates')\n draw()\n\n subplot( 133, sharex=ax1, sharey=ax1 )\n Ibclist = [ 'CSP-2004gv','CSP-2006ep','CSP-2007Y','SDSS-000020','SDSS-002744','SDSS-014492',\n 'SDSS-019323','SNLS-04D1la','SNLS-04D4jv','CSP-2004fe','CSP-2004gq','SDSS-004012',\n 'SDSS-013195','SDSS-014475','SDSS-015475','SDSS-017548' ]\n for sed in Ibclist :\n plotsed( os.path.join(sndataroot,'snsed/non1a/%s.SED'%sed), day=0.5, normalize=2, color='g', lw=0.5, label=sed )\n # Ia in red\n plotsed( os.path.join(sndataroot,'snsed/Hsiao07.extrap.dat'), day=0, normalize=2, color='r', label='Ia (Hsiao)', lw=2 )\n plotsed( os.path.join(sndataroot,'snsed/Hsiao07.dat'), day=0, normalize=2, color='k', label='Ia (Hsiao)', lw=1, ls=':' )\n title('Type Ib and Ic Templates', color='g')\n #legend()\n ion()\n\n suptitle( 'Comparing SNANA CC and Ia templates at peak' )\n draw()\n\n\n\n\ndef extratest( sed, **kwarg ) :\n sedorig = '/usr/local/SNDATA_ROOT/snsed/non1a.ORIG/'+sed+'.SED'\n sednew = '/usr/local/SNDATA_ROOT/snsed/non1a/'+sed+'test.SED'\n extrapolatesed_linfit( sedorig, sednew, **kwarg )\n clf()\n plotsed( sednew, day=0.5, color='g', ls='-', lw=1, normalize=2, label='new' )\n plotsed( sedorig, day=0.5, color='b', ls='-', lw=3, normalize=2, label='orig' )\n\n plotsed( '/usr/local/SNDATA_ROOT/snsed/Hsiao07.extrap.dat', day=0, normalize=2, color='r', label='Ia (Hsiao)', lw=2 )\n\n ax = gca()\n text( 0.1,0.95, sed, ha='left',va='top', transform=ax.transAxes )\n legend( )\n\n \n", "meta": {"hexsha": "9c4282e92d97e145ab0d79043dec027af4c7d07e", "size": 24581, "ext": "py", "lang": "Python", "max_stars_repo_path": "snsed.py", "max_stars_repo_name": "srodney/stardust", "max_stars_repo_head_hexsha": "27742c17cfc17df2f6d016b33ecb32f9b0f9950d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "snsed.py", "max_issues_repo_name": "srodney/stardust", "max_issues_repo_head_hexsha": "27742c17cfc17df2f6d016b33ecb32f9b0f9950d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "snsed.py", "max_forks_repo_name": "srodney/stardust", "max_forks_repo_head_hexsha": "27742c17cfc17df2f6d016b33ecb32f9b0f9950d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2017-10-06T17:32:08.000Z", "max_forks_repo_forks_event_max_datetime": "2019-06-04T17:49:06.000Z", "avg_line_length": 40.4958813839, "max_line_length": 146, "alphanum_fraction": 0.5762174037, "include": true, "reason": "from numpy,from scipy", "num_tokens": 7765, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6442251064863697, "lm_q2_score": 0.3007455789412415, "lm_q1q2_score": 0.19374785261872618}} {"text": "import os\nimport numpy as np\nfrom .decoder import AmbiDecoder\nfrom .hrir import CIPIC_HRIR\nfrom .position import Position, PositionalSource, MovingSource\nfrom scipy.ndimage.interpolation import shift\n#from tdesigns import get_tDesign\n\nC = 343. # Speed of sound [m/s]\n\n\nclass VirtualStereoMic(object):\n def __init__(self, radius=0.1):\n self.radius = radius\n self.lmic_pos = Position(0, radius, 0, 'cartesian')\n self.rmic_pos = Position(0, -radius, 0, 'cartesian')\n\n def binauralize(self, sources):\n if isinstance(sources, PositionalSource):\n sources = [sources]\n\n l_signal, r_signal = 0, 0.\n for src in sources:\n l_dist = np.sqrt(((src.position.coords('cartesian') - self.lmic_pos.coords('cartesian'))**2).sum())\n r_dist = np.sqrt(((src.position.coords('cartesian') - self.rmic_pos.coords('cartesian'))**2).sum())\n\n # Time delay\n l_delay, r_delay = int(l_dist / C * src.sample_rate), int(r_dist / C * src.sample_rate)\n\n # Attenuation is frequency dependent, but lets simplify.\n l_attn, r_attn = 1 / (1. + l_dist), 1 / (1. + r_dist)\n\n l_signal += l_attn * shift(src.signal, l_delay, cval=0.) / len(sources)\n r_signal += r_attn * shift(src.signal, r_delay, cval=0.) / len(sources)\n\n return np.stack((l_signal, r_signal), axis=1)\n\n def binauralize_frame(self, sources, output, frame_no):\n if isinstance(sources, PositionalSource):\n sources = [sources]\n\n for src in sources:\n l_dist = np.sqrt(((src.position.coords('cartesian') - self.lmic_pos.coords('cartesian'))**2).sum())\n r_dist = np.sqrt(((src.position.coords('cartesian') - self.rmic_pos.coords('cartesian'))**2).sum())\n\n # Time delay\n l_delay, r_delay = int(l_dist / C * src.sample_rate), int(r_dist / C * src.sample_rate)\n\n # Attenuation is frequency dependent, but lets simplify.\n l_attn, r_attn = 1 / (1. + l_dist), 1 / (1. + r_dist)\n\n if frame_no-l_delay >= 0:\n output[frame_no, 0] += l_attn * src.signal[frame_no-l_delay] / len(sources)\n if frame_no-r_delay >= 0:\n output[frame_no, 1] += r_attn * src.signal[frame_no-r_delay] / len(sources)\n\n\nclass Convolvotron(object):\n def __init__(self, cipic_dir):\n assert os.path.exists(cipic_dir)\n self.hrir_db = CIPIC_HRIR(cipic_dir)\n\n def binauralize(self, sources):\n if isinstance(sources, PositionalSource):\n sources = [sources]\n num_frames = max([src.signal.shape[0] for src in sources])\n stereo = np.zeros((num_frames, 2))\n for src in sources:\n left_hrir, right_hrir = self.hrir_db.get_closest(src.position)[1:]\n left_signal = np.convolve(src.signal, np.flip(left_hrir, axis=0), 'valid')\n right_signal = np.convolve(src.signal, np.flip(right_hrir, axis=0), 'valid')\n\n n_valid, i_start = left_signal.shape[0], left_hrir.shape[0] - 1\n stereo[i_start:(i_start + n_valid), 0] += left_signal\n stereo[i_start:(i_start + n_valid), 1] += right_signal\n\n return stereo\n\n def binauralize_frame(self, sources, output, frame_no):\n if isinstance(sources, PositionalSource):\n sources = [sources]\n\n for src in sources:\n left_hrir, right_hrir = self.hrir_db.get_closest(src.position)[1:]\n\n i_start = frame_no - left_hrir.size + 1 if frame_no >= left_hrir.size else 0\n i_end = frame_no + 1\n i_range = i_end - i_start\n\n output[frame_no, 0] = (src.signal[i_start:i_end] * left_hrir[-i_range:]).sum()\n output[frame_no, 1] = (src.signal[i_start:i_end] * right_hrir[-i_range:]).sum()\n\n\nclass SourceBinauralizer(object):\n def __init__(self, use_hrtfs=True, cipic_dir=None):\n self.use_hrts = use_hrtfs\n if use_hrtfs:\n self.convolvotron = Convolvotron(cipic_dir)\n else:\n self.stereo_mic = VirtualStereoMic()\n\n def binauralize(self, sources):\n if isinstance(sources, PositionalSource):\n sources = [sources]\n assert isinstance(sources, list) and all([isinstance(src, PositionalSource) for src in sources])\n assert all([src.sample_rate == sources[0].sample_rate for src in sources])\n\n if self.use_hrts:\n return self.convolvotron.binauralize(sources)\n else:\n return self.stereo_mic.binauralize(sources)\n\n def binauralize_frame(self, sources, output, frame_no):\n if isinstance(sources, PositionalSource):\n sources = [sources]\n assert isinstance(sources, list) and all([isinstance(src, PositionalSource) for src in sources])\n assert all([src.sample_rate == sources[0].sample_rate for src in sources])\n\n if self.use_hrts:\n return self.convolvotron.binauralize_frame(sources, output, frame_no)\n else:\n return self.stereo_mic.binauralize_frame(sources, output, frame_no)\n\n\nclass AmbisonicBinauralizer(object):\n def __init__(self, ambi_format, method='projection', use_hrtfs=False, cipic_dir=None):\n self.source_bin = SourceBinauralizer(cipic_dir=cipic_dir, use_hrtfs=use_hrtfs)\n self.fmt = ambi_format\n self.method = method\n\n # Initialize speakers\n if self.method == 'pseudoinv':\n self.speaker_pos = map(lambda x: Position(x[0], x[1], x[2], 'cartesian'), get_tDesign(self.fmt.order))\n map(lambda p: p.set_radius(self.fmt.radius), self.speaker_pos)\n # speakers_phi = (2. * np.arange(2*self.fmt.num_channels) / float(2*self.fmt.num_channels) - 1.) * np.pi\n # self.speaker_pos = map(lambda x: Position(x, 0, self.fmt.radius, 'polar'), speakers_phi)\n elif self.method == 'projection':\n speakers_phi = (2. * np.arange(2*self.fmt.num_channels) / float(2*self.fmt.num_channels) - 1.) * np.pi\n # self.speaker_pos = map(lambda x: Position(x, 0, self.fmt.radius, 'polar'), speakers_phi)\n self.speaker_pos = [Position(x, 0, self.fmt.radius, 'polar') for x in speakers_phi]\n else:\n raise ValueError('Unknown decoding method. Options: projection and pseudoinv')\n self.n_speakers = len(self.speaker_pos)\n self.ambi_decoder = AmbiDecoder(self.speaker_pos, self.fmt, method=self.method)\n\n def binauralize(self, ambi):\n # Decode ambisonics into speakers\n speakers = self.ambi_decoder.decode(ambi)\n\n # Binauralize speaker as if they were point sources\n sources = [PositionalSource(speakers[:, i], self.speaker_pos[i], self.fmt.sample_rate) for i in range(self.n_speakers)]\n stereo = self.source_bin.binauralize(sources)\n\n return stereo\n\n\nclass DirectAmbisonicBinauralizer(object):\n def __init__(self, ambi_format, method='projection'):\n self.fmt = ambi_format\n self.method = method\n\n # Initialize ear position\n self.ear_pos = [Position(0, 0.1, 0, 'cartesian'), Position(0, -0.1, 0, 'cartesian')]\n self.ambi_decoder = AmbiDecoder(self.ear_pos, self.fmt, method=self.method)\n\n def binauralize(self, ambi):\n return self.ambi_decoder.decode(ambi)\n\n\ndef test_convolvotron():\n from pyutils.iolib.audio import load_wav, save_wav\n convolvotron = Convolvotron('hrtfs/cipic_subj3')\n mono, rate = load_wav('wav_test/piano.wav')\n mono = mono[:, 0]\n\n positions = [[float(num) for num in l.strip().split()] for l in open('wav_test/piano_stat_position.txt', 'r')]\n positions = [Position(p[0], p[1], p[2], 'polar') for p in positions]\n source = PositionalSource(mono, positions[0], rate)\n\n stereo = convolvotron.binauralize([source])\n save_wav('/tmp/output.wav', stereo, rate)\n os.system('play /tmp/output.wav')\n os.remove('/tmp/output.wav')\n\n positions = [[float(num) for num in l.strip().split()] for l in open('wav_test/piano_mov_position.txt', 'r')]\n positions = [Position(p[0], p[1], p[2], 'polar') for p in positions]\n source = MovingSource(mono, positions, rate)\n\n stereo = np.zeros((mono.shape[0], 2))\n while source.tic():\n convolvotron.binauralize_frame([source], stereo, source.cur_idx)\n save_wav('/tmp/output.wav', stereo, rate)\n os.system('play /tmp/output.wav')\n os.remove('/tmp/output.wav')\n\n\ndef test_virtual_mic():\n from pyutils.iolib.audio import load_wav, save_wav\n mic = VirtualStereoMic()\n mono, rate = load_wav('wav_test/piano.wav')\n mono = mono[:, 0]\n\n positions = [[float(num) for num in l.strip().split()] for l in open('wav_test/piano_stat_position.txt', 'r')]\n positions = [Position(p[0], p[1], p[2], 'polar') for p in positions]\n source = PositionalSource(mono, positions[0], rate)\n\n stereo = mic.binauralize([source])\n save_wav('/tmp/output.wav', stereo, rate)\n os.system('play /tmp/output.wav')\n os.remove('/tmp/output.wav')\n\n positions = [[float(num) for num in l.strip().split()] for l in open('wav_test/piano_mov_position.txt', 'r')]\n positions = [Position(p[0], p[1], p[2], 'polar') for p in positions]\n source = MovingSource(mono, positions, rate)\n\n stereo = np.zeros((mono.shape[0], 2))\n while source.tic():\n mic.binauralize_frame([source], stereo, source.cur_idx)\n save_wav('/tmp/output.wav', stereo, rate)\n os.system('play /tmp/output.wav')\n os.remove('/tmp/output.wav')\n\n\ndef test_source_binauralizer():\n from pyutils.iolib.audio import load_wav, save_wav\n from pyutils.iolib.position import read_position_file\n\n # binauralizer = SourceBinauralizer(use_hrtfs=True, cipic_dir='hrtfs/cipic_subj3')\n binauralizer = SourceBinauralizer(use_hrtfs=False)\n\n # Static source\n sample = 'wav_test/gen_synthetic-S1'\n positions, wav_fns, _, sample_ids = read_position_file(sample+'-position.txt')\n mono, rate = load_wav(wav_fns[sample_ids[0]])\n source = PositionalSource(mono[:, 0], positions[sample_ids[0]][0], rate)\n stereo = binauralizer.binauralize([source])\n\n save_wav('/tmp/output.wav', stereo / np.abs(stereo).max(), rate)\n os.system('play /tmp/output.wav')\n os.remove('/tmp/output.wav')\n\n # Moving source\n sample = 'wav_test/gen_synthetic-M1'\n positions, wav_fns, _, sample_ids = read_position_file(sample+'-position.txt')\n mono, rate = load_wav(wav_fns[sample_ids[0]])\n source = MovingSource(mono[:, 0], positions[sample_ids[0]], rate)\n stereo = np.zeros((mono.shape[0], 2))\n while source.tic():\n binauralizer.binauralize_frame([source], stereo, source.cur_idx)\n\n save_wav('/tmp/output.wav', stereo / np.abs(stereo).max(), rate)\n os.system('play /tmp/output.wav')\n os.remove('/tmp/output.wav')\n\n\ndef test_ambisonics_binauralizer():\n from pyutils.iolib.audio import load_wav, save_wav\n from pyutils.ambisonics.common import AmbiFormat\n\n sample = 'wav_test/gen_synthetic-S1'\n ambi, rate = load_wav(sample+'-ambix.wav')\n\n fmt = AmbiFormat(1, rate)\n binauralizer = DirectAmbisonicBinauralizer(fmt, method='pseudoinv')\n # binauralizer = AmbisonicBinauralizer(fmt, method='projection', use_hrtfs=True, cipic_dir='hrtfs/cipic_subj3')\n\n stereo = binauralizer.binauralize(ambi)\n\n save_wav('/tmp/output.wav', stereo / np.abs(stereo).max(), rate)\n os.system('play /tmp/output.wav')\n os.remove('/tmp/output.wav')\n\n sample = 'wav_test/gen_synthetic-M1'\n ambi, rate = load_wav(sample+'-ambix.wav')\n stereo = binauralizer.binauralize(ambi)\n\n save_wav('/tmp/output.wav', stereo / np.abs(stereo).max(), rate)\n os.system('play /tmp/output.wav')\n os.remove('/tmp/output.wav')\n\n\nif __name__ == '__main__':\n # test_ambisonics_binauralizer()\n test_source_binauralizer()\n # test_convolvotron()\n # test_virtual_mic()\n", "meta": {"hexsha": "53a2c02906291c1dd7707a16839be893e7dc6a3f", "size": 11794, "ext": "py", "lang": "Python", "max_stars_repo_path": "ambisonics/binauralizer.py", "max_stars_repo_name": "realningzheng/BinauralAudioTools", "max_stars_repo_head_hexsha": "f7ad77d6dfc92068a29a01ab99ceb21497583475", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-11-04T14:11:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-04T14:11:14.000Z", "max_issues_repo_path": "ambisonics/binauralizer.py", "max_issues_repo_name": "realningzheng/BinauralAudioTools", "max_issues_repo_head_hexsha": "f7ad77d6dfc92068a29a01ab99ceb21497583475", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ambisonics/binauralizer.py", "max_forks_repo_name": "realningzheng/BinauralAudioTools", "max_forks_repo_head_hexsha": "f7ad77d6dfc92068a29a01ab99ceb21497583475", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-11-27T03:35:46.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-05T06:06:11.000Z", "avg_line_length": 41.0940766551, "max_line_length": 127, "alphanum_fraction": 0.6543157538, "include": true, "reason": "import numpy,from scipy", "num_tokens": 3234, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5851011542032312, "lm_q2_score": 0.33111974622959367, "lm_q1q2_score": 0.19373854569841625}} {"text": "#!/usr/bin/env python\n## top-level script for generating probability distributions for component scores as part of CMS 2.0. \n## last updated: 06.24.2017 \tvitti@broadinstitute.org\n\nimport matplotlib as mp \nmp.use('agg') \nfrom dists.freqbins_func import run_traj, get_bin_strings, get_bins, check_create_dir, check_create_file, write_bin_paramfile, execute, get_concat_files, get_info_from_tped_name\nfrom dists.scores_func import calc_ihs, calc_delihh, calc_xpehh, calc_fst_deldaf, read_neut_normfile, norm_neut_ihs, norm_sel_ihs, norm_neut_xpehh, norm_sel_xpehh, get_sim_compscore_files, get_scores_from_files, get_compscores_from_files_flatten\nfrom dists.likes_func import plot_pdf_comparison_from_scores, get_plot_pdf_params, quick_load_likes, quick_cl_from_likes, quick_clr_from_likes, get_likes_filenames, write_master_likesfile, get_master_likefiles, get_likes_savestrings\nimport numpy as np\nimport argparse\nimport sys, os, subprocess\nimport matplotlib.pyplot as plt\n\n#############################\n## DEFINE ARGUMENT PARSER ###\n#############################\ndef full_parser_likes_from_model():\n\tparser=argparse.ArgumentParser(description=\"This script contains command-line utilities for generating probability distributions for component scores from pre-specified demographic model(s).\")\n\tsubparsers = parser.add_subparsers(help=\"sub-commands\")\n\tgenerate_sel_bins_parser = subparsers.add_parser('generate_sel_bins', help=\"Pre-processing step: generate directories with parameter files divided by selDAF, according to specified bins\") #nix or clean\n\tgenerate_sel_bins_parser.add_argument('outputDir', type=str, action='store', help='location to write cosi output')\n\t\n\t#####################################\n\t## SIMULATE SELECTION TRAJECTORIES ##\n\t#####################################\n\tget_sel_traj_parser = subparsers.add_parser('get_sel_traj', help='Run forward simulations of selection trajectories to populate selscenarios by final allele frequency before running coalescent simulations for entire sample.')\n\tget_sel_traj_parser.add_argument('traj_outputname', type=str, action='store', help=\"write to file\")\t\n\tget_sel_traj_parser.add_argument('--maxAttempts', type=int, action='store', help='maximum number of attempts to generate a trajectory before re-sampling selection coefficient / start time', default=100)\n\t\n\t##########################\n\t## RUN FULL SIMULATIONS ##\n\t##########################\n\trun_neut_sim_parser = subparsers.add_parser('run_neut_sim', help='run neutral simulations')\n\trun_sel_sim_parser = subparsers.add_parser('run_sel_sim', help='run sims with selection')\n\trun_sel_sim_parser.add_argument('traj_infilename', type=str, action='store', help=\"selection trajectory\")\n\n\t####################################\n\t## GENERATE SCORES FROM SIMULATES ##\n\t####################################\n\trun_repscores_parser = subparsers.add_parser('run_repscores', help=\"run composite score calculations for simulated tped\")\n\trun_repscores_parser.add_argument('score_basedir', type=str, action='store', help=\"parent directory in which to generate/populate folders for each composite score\")\n\trun_repscores_parser.add_argument('inputTpedFile', type=str, action='store', help=\"TPED file with simulate data for putative selected population\") \n\trun_repscores_parser.add_argument('--simRecomFile', type=str, action=\"store\", help=\"location of input recom file\", default=\"/n/home08/jvitti/params/test_recom.recom\")\n\tget_neut_norm_params_parser = subparsers.add_parser('get_neut_norm_params', help=\"jointly normalize scores from neutral replicates to get parameters with which to normalize all replicates\")\t\n\tnorm_from_neut_params_parser = subparsers.add_parser('norm_from_neut_params', help=\"normalize component scores according to neutral distribution\")\n\tnorm_from_neut_params_parser.add_argument('--selbin', action='store', help=\"e.g. 0.10 -- if excluded, normalize neutral simulates\")\n\tnorm_from_neut_params_parser.add_argument('--scenario_dir', action='store', help=\"neut/selsim dir\", default=\"neut\")\n\n\t##################################################\n\t## GATHER SCORES AND CALCULATE LIKELIHOOD TABLE ##\n\t##################################################\n\tlikes_from_scores_parser = subparsers.add_parser('likes_from_scores', help='Collate scores from simulated data in order to generate component test probability distributions.')\n\tlikes_from_scores_parser.add_argument('--nrep_neut', type=int, action=\"store\", help=\"number of neutral replicates\", default=1000)\n\tlikes_from_scores_parser.add_argument('--nrep_sel', type=int, action=\"store\", help=\"number of replicates per selection scenario bin\", default=500)\n\tlikes_from_scores_parser.add_argument('--binMerge', action=\"store_true\", help=\"if included, generate higher-order groupings of selscenario frequency bins\")\n\tlikes_from_scores_parser.add_argument('--foldDist', action=\"store_true\", help=\"if included, take absolute value of score values (fold distribution over y-axis)\", default=False)\n\tlikes_from_scores_parser.add_argument('--save_suffix', type=str, action=\"store\", help=\"optional string to add to filenames (e.g. to avoid overwrite)\", default=None)\n\tlikes_from_scores_parser.add_argument('--save_dir', type=str, action=\"store\", help=\"if included, specify alternate outpot location\", default=None)\n\tlikes_from_scores_parser.add_argument('--save_likelihoods', action=\"store_true\", help=\"in addition to plotting, save data\", default=False)\n\tif True:\n\t\tlikes_from_scores_parser.add_argument('--ihs', action=\"store_true\", help=\"visualize likelihoods for iHS\", default=False)\n\t\tlikes_from_scores_parser.add_argument('--delihh', action=\"store_true\", help=\"visualize likelihoods for delIHH\", default=False)\n\t\tlikes_from_scores_parser.add_argument('--nsl', action=\"store_true\", help=\"visualize likelihoods for nSL\", default=False)\n\t\tlikes_from_scores_parser.add_argument('--xpehh', action=\"store_true\", help=\"visualize likelihoods for XP-EHH\", default=False)\n\t\tlikes_from_scores_parser.add_argument('--deldaf', action=\"store_true\", help=\"visualize likelihoods for delDAF\", default=False)\n\t\tlikes_from_scores_parser.add_argument('--fst', action=\"store_true\", help=\"visualize likelihoods for Fst\", default=False)\n\n\t########################################################\n\t## ANALYZE AND BUNDLE SCORE PROBABILITY DISTRIBUTIONS ##\n\t########################################################\n\tplot_likes_vs_scores_parser = subparsers.add_parser('plot_likes_vs_scores', help='useful QC step; visualize the function that converts score values into likelihood contributions towards composite scores')\n\tplot_likes_vs_scores_parser.add_argument('inputLikesPrefix', action=\"store\", help=\"filename minus causal/linked/neutral.txt\")\n\tplot_likes_vs_scores_parser.add_argument('--default_nregion_snps', type=int, action=\"store\", help=\"presumptive number of SNPs in region (determines prior distributions for within-region CMS calculations)\", default=5000)\n\twrite_master_likes_parser = subparsers.add_parser('write_master_likes', help='specify and bundle together input distributions to pass to CMS. This allows the user to specify models, frequency of SNPs used to generated p(score|sel), etc.')\n\twrite_master_likes_parser.add_argument('--likes_masterDir', type=str, default=\"/n/regal/sabeti_lab/jvitti/\", help=\"location of likelihood tables, defined\")\n\t#write_master_likes_parser.add_argument('--likes_nonSel', type=str, default=\"vsNeut\", help='do we use completely neutral, or linked neutral SNPs for our non-causal distributions? by default, uses strict neutral (CMSgw)')\n\t#write_master_likes_parser.add_argument('--likes_freqSuffix', type=str, default=\"allFreqs\", help='for causal SNPs, include suffix to specify which selbins to include')\n\t#write_master_likes_parser.add_argument('--likes_savestring', type=str, default=\"allFreqs\", help='default savestring for individual likes files to cull')\n\twrite_master_likes_parser.add_argument('--model', type=str, default=\"nulldefault\", help='...')\n\twrite_master_likes_parser.add_argument('--likes_inDir', type=str, default=\"/n/regal/sabeti_lab/jvitti/\", help='...')\n\n\n\t#################\n\t## SHARED ARGS ## \n\t################# \n\tfor common_parser in [run_neut_sim_parser, run_sel_sim_parser, run_repscores_parser, get_neut_norm_params_parser, norm_from_neut_params_parser]:\n\t\tcommon_parser.add_argument('--checkOverwrite', action=\"store_true\", default=True)\n\tfor run_sim_parser in [run_neut_sim_parser, run_sel_sim_parser]:\n\t\trun_sim_parser.add_argument('writeBase', type=str, action='store', help=\"write prefix\")\n\t\trun_sim_parser.add_argument('--dropSings', type=float, action='store', help='randomly thin global singletons from output dataset to model ascertainment bias', default=.25)\t\n\tfor cosi_parser in [get_sel_traj_parser, run_neut_sim_parser, run_sel_sim_parser]:\n\t\tcosi_parser.add_argument('--cosiBuild', type=str, action='store', help='which version of cosi to run', default=\"coalescent\")\n\t\tcosi_parser.add_argument('inputParamFile', type=str, action='store', help='file with model specifications for input')\n\t\t#cosi_parser.add_argument('--genmapRandomRegions', action='store_true', help='cosi option to sub-sample genetic map randomly from input')\t\n\tfor cms_preconda_parser in [run_repscores_parser, get_neut_norm_params_parser, norm_from_neut_params_parser]: #TEMPORARY; conda will obviate\n\t\tcms_preconda_parser.add_argument('--cmsdir', type=str, action='store', help=\"location of CMS scripts (TEMPORARY; conda will obviate)\", default=\"/n/home08/jvitti/cms/cms/\") \n\tfor interior_score_parser in [get_neut_norm_params_parser, likes_from_scores_parser]:\n\t\tinterior_score_parser.add_argument('--edge', type=int, action=\"store\", help=\"use interior of replicates; define per-end bp. (e.g. 1.5Mb -> 1Mb: 250000)\", default=250000)\n\t\tinterior_score_parser.add_argument('--chromlen', type=int, action=\"store\", help=\"per bp (1.5mb = 1500000)\", default=1500000)\n\tfor norm_parser in [get_neut_norm_params_parser, norm_from_neut_params_parser, write_master_likes_parser]:\n\t\tnorm_parser.add_argument('--score', type=str, action='store', default='ihs')\n\t\tnorm_parser.add_argument('--simpop', type=int, action='store', default=1)\n\t\tnorm_parser.add_argument('--altpop', type=int, action='store', default=2)\n\t\tnorm_parser.add_argument('--nrep', type=int, action='store', default=100)\n\tfor norm_sims_parser in [get_neut_norm_params_parser, norm_from_neut_params_parser, likes_from_scores_parser]:\n\t\tnorm_sims_parser.add_argument('modeldir', type=str, action=\"store\", help=\"location of component score folders for demographic scenario\")\n\tfor selbin_parser in [generate_sel_bins_parser, get_sel_traj_parser, likes_from_scores_parser]:\n\t\tselbin_parser.add_argument('--freqRange', type=str, help=\"range of final selected allele frequencies to simulate, e.g. .05-.95\", default='.05-.95')\n\t\tselbin_parser.add_argument('--nBins', type=int, help=\"number of frequency bins\", default=9)\t\t\n\treturn parser\n\n############################\n## DEFINE EXEC FUNCTIONS ###\n############################\n### Run simuates from specified demographic\n### model under various scenarios\ndef execute_generate_sel_bins(args):\n\t''' pre-processing step for sel_trajs(->sel_sim) ''' #hmmm nix this? or else, fix write_bin_paramfile: merge with quick_write_inclusive_sweep_paramfiles.py\n\tfreqRange = args.freqRange\n\tnBins = args.nBins\n\trunDir = args.outputDir\n\tneutParamfile = args.inputParamFile\n\tfullrange, bin_starts, bin_ends, bin_medians, bin_medians_str = get_bins(freqRange, nBins)\n\tfor ibin in range(nBins):\n\t\tpopulateDir = runDir + \"sel_\" + bin_medians_str[ibin]\n\t\tbinDir = check_create_dir(populateDir)\n\t\tbounds = bin_starts[ibin], bin_ends[ibin]\n\t\tparamfilename = populateDir + \"/params\"\n\t\twrite_bin_paramfile(neutParamfile, paramfilename, bounds)\n\t\tprint('wrote to: ' + paramfilename)\t\n\treturn\ndef execute_get_sel_traj(args):\n\t'''generate forward trajectories of simulated allele frequencies for demographic scenarios with selection'''\n\ttraj_outputname = args.traj_outputname\n\tcosibuild = args.cosiBuild\n\tparamfilename = args.inputParamFile\n\tmaxattempts = args.maxAttempts\n\trun_traj(traj_outputname, cosibuild, paramfilename, maxattempts)\n\treturn\ndef execute_run_neut_sim(args):\n\t''' generates tped data for one neutral replicate from a demographic model parameter file using coalescent simulator cosi '''\n\tcosibuild = args.cosiBuild\n\toutbase = args.writeBase\n\tparamfilename = args.inputParamFile\n\tdropSing = args.dropSings\n\tcmd = cosibuild\n\targstring = \"-p \" + paramfilename + \" --genmapRandomRegions --drop-singletons \" + str(dropSing) + \" --tped \" + outbase + \" --output-gen-map\"\n\t#print(cmd + \" \" + argstring)\t\n\tcosicreatefilename = outbase + \"_0_1.tped\"\n\tcosi_movedfilename = outbase + \"_1.tped\"\t\n\tproceed = check_create_file(cosicreatefilename, args.checkOverwrite)\n\tif proceed:\n\t#if not os.path.isfile(cosicreatefilename):\n\t\tfullCmd = cmd + \" \" + argstring\n\t\tprint(fullCmd)\n\t\texecute(fullCmd)\n\t\tfor ipop in [1, 2, 3, 4]:\n\t\t\ttorenamefile = outbase + \"_0_\" + str(ipop) + \".tped\"\n\t\t\t#print(torenamefile)\n\t\t\tassert os.path.isfile(torenamefile)\n\t\t\trenamed = outbase +\"_\" + str(ipop) + \".tped\"\n\t\t\trenamecmd = \"mv \" + torenamefile + \" \" + renamed\n\t\t\texecute(renamecmd)\n\tprint(\"wrote simulates to e.g. \" + renamed)\n\treturn\ndef execute_run_sel_sim(args):\n\t''' generates tped data for one replicate from a demographic model parameter file and selection trajectory file using coalescent simulator cosi '''\n\ttrajectory = args.traj_infilename\n\tcosibuild = args.cosiBuild\n\toutbase = args.writeBase\n\tparamfilename = args.inputParamFile\n\tdropSing = args.dropSings\t\n\tcmd = \"env COSI_NEWSIM=1 env COSI_LOAD_TRAJ=\" + trajectory + \" \" + cosibuild \n\targstring = \"-p \" + paramfilename + \" --genmapRandomRegions --drop-singletons \" + str(dropSing) + \" --tped \" + outbase + \" --output-gen-map\"\n\t#print(cmd + \" \" + argstring)\n\tcosicreatefilename = outbase + \"_0_1.tped\"\n\tcosi_movedfilename = outbase + \"_1.tped\"\n\tproceed = check_create_file(cosi_movedfilename, args.checkOverwrite)\n\tif proceed:\n\t\tfullCmd = cmd + \" \" + argstring\n\t\tprint(fullCmd)\n\t\texecute(fullCmd)\n\t\tfor ipop in [1, 2, 3, 4]:\n\t\t\ttorenamefile = outbase + \"_0_\" + str(ipop) + \".tped\"\n\t\t\t#print(torenamefile)\n\t\t\tassert os.path.isfile(torenamefile)\n\t\t\trenamed = outbase +\"_\" + str(ipop) + \".tped\"\n\t\t\trenamecmd = \"mv \" + torenamefile + \" \" + renamed\n\t\t\texecute(renamecmd)\n\tprint(\"wrote simulates to e.g. \" + renamed)\n\treturn\n\n### Calculate component scores from \n### simulated data\ndef execute_run_repscores(args):\n\t''' for one simulated replicate (agnostic wrt neut/sel), generate all component scores '''\n\tbasedir = args.score_basedir\n\tcmsdir = args.cmsdir \n\ttped = args.inputTpedFile\n\trepNum, pop, tpeddir = get_info_from_tped_name(tped)\n\tcheckOverwrite = args.checkOverwrite \n\tsimRecomFile = args.simRecomFile\n\tassert os.path.isfile(tped)\n\tfor scorefiledir in ['ihs', 'delihh', 'nsl', 'xpehh', 'freqs']:\n\t\tcheck_create_dir(basedir + scorefiledir)\n\n\t####### Calculate per-population\n\t####### scores: iHS, delIHH, nSL\n\tihs_commandstring = \"python \" + cmsdir + \"scans.py selscan_ihs\"\n\tihs_outfileprefix = basedir + \"ihs/rep\" + str(repNum) + \"_\" + str(pop) \n\tihs_unnormedfile = ihs_outfileprefix + \".ihs.out\"\n\tihs_argstring = tped + \" \" + ihs_outfileprefix + \" --threads 7 \"\n\tihs_fullcmd = ihs_commandstring + \" \" + ihs_argstring\n\tihs_normedfile = ihs_unnormedfile + \".norm\"\n\tproceed = check_create_file(ihs_unnormedfile, args.checkOverwrite)\n\tif proceed:\n\t\tprint(ihs_fullcmd)\n\t\texecute(ihs_fullcmd)\n\tdelihh_commandstring = \"python \" + cmsdir + \"composite.py delihh_from_ihs\"\n\tdelihh_unnormedfile = basedir + \"delihh/rep\" + str(repNum) + \"_\" + str(pop) + \".txt\"\n\tdelihh_argstring = ihs_unnormedfile + \" \"+ delihh_unnormedfile\n\tdelihh_fullcmd = delihh_commandstring + \" \" + delihh_argstring \n\tdelihh_normedfile = delihh_unnormedfile + \".norm\"\n\tproceed = check_create_file(delihh_unnormedfile, args.checkOverwrite)\n\tif proceed:\n\t\tprint(delihh_fullcmd)\n\t\texecute(delihh_fullcmd)\t\t\n\tnsl_commandstring = \"python \" + cmsdir + \"scans.py selscan_nsl\" \n\tnsl_unnormedfileprefix = basedir + \"nsl/rep\" + str(repNum) + \"_\" + str(pop)\n\tnsl_argstring = tped + \" \" + nsl_unnormedfileprefix\n\tnsl_fullcmd = nsl_commandstring + \" \" + nsl_argstring\n\tnsl_unnormedfilename = nsl_unnormedfileprefix + \".nsl.out\"\n\tproceed = check_create_file(nsl_unnormedfilename, args.checkOverwrite)\n\tif proceed:\n\t\tprint(nsl_fullcmd)\n\t\texecute(nsl_fullcmd)\t\n\n\t####### Calculate per-population-pair\n\t####### scores: XP-EHH, Fst, delDAF\n\tpops = [1, 2, 3, 4]\n\taltpops = pops[:]\n\taltpops.remove(int(pop))\n\tfor altpop in altpops:\n\t\txpehh_commandstring = \"python \" + cmsdir + \"scans.py selscan_xpehh --threads 7\"\n\t\ttped2 = tpeddir + \"rep\" + str(repNum) + \"_\" + str(altpop) + \".tped\"\n\t\txpehh_outfileprefix = basedir + \"xpehh/rep\" + str(repNum) + \"_\" + str(pop) + \"_\" + str(altpop)\n\t\txpehh_unnormedfile = basedir + \"xpehh/rep\" + str(repNum) + \"_\" + str(pop) + \"_\" + str(altpop) + \".xpehh.out\"\n\t\txpehh_argumentstring = tped + \" \" + xpehh_outfileprefix + \" \" + tped2\n\t\txpehh_fullcmd = xpehh_commandstring + \" \" + xpehh_argumentstring\n\t\tproceed = check_create_file(xpehh_unnormedfile, args.checkOverwrite)\n\t\tif proceed:\n\t\t\tprint(xpehh_fullcmd)\n\t\t\texecute(xpehh_fullcmd)\n\n\t\tfstdeldaf_commandstring = \"python \" + cmsdir + \"composite.py freqscores\"\n\t\tfstdeldaf_outfilename = basedir + \"freqs/rep\" + str(repNum) + \"_\" + str(pop) + \"_\" + str(altpop)\n\t\tfstdeldaf_argumentstring = tped + \" \" + tped2 + \" \" + simRecomFile + \" \" + fstdeldaf_outfilename \n\t\tfstdeldaf_fullcmd = fstdeldaf_commandstring + \" \" + fstdeldaf_argumentstring \n\t\tproceed = check_create_file(fstdeldaf_outfilename, args.checkOverwrite)\n\t\tif proceed:\n\t\t\tprint(fstdeldaf_fullcmd)\n\t\t\texecute(fstdeldaf_fullcmd)\n\treturn\ndef execute_get_neut_norm_params(args):\n\t''' creates a concatenated file and saves bin output if run for the first time'''\n\tpop = args.simpop\n\tnumReps = args.nrep\n\tbasedir = args.modeldir \n\tif basedir[-1] != \"/\":\n\t\tbasedir += \"/\"\n\tcmsdir = args.cmsdir\n\tscore = args.score\n\taltpop = args.altpop\n\tchrlen, edge = args.chromlen, args.edge\n\tstartbound, endbound = int(edge), chrlen - int(edge) #define replicate interior (conservative strategy to avoid edge effects)\n\n\tif score in ['ihs', 'delihh', 'nsl']:\n\t\tconcatfilebase = basedir + \"neut/concat_\" + str(pop) + \"_\"\n\telif score in ['xpehh', 'fst']:\n\t\taltpop = args.altpop\n\t\tconcatfilebase = basedir + \"neut/concat_\" + str(pop) + \"_\" + str(altpop) + \"_\"\n\telse:\n\t\tprint('must call per composite score')\n\t\tsys.exit(0)\n\n\tconcatfilename = concatfilebase + score + \".txt\"\n\tbinfilename = concatfilebase + score + \".bins\"\n\n\tif not os.path.isfile(binfilename):\n\t\tif not os.path.isfile(concatfilename):\n\t\t\trepfiles = []\n\t\t\tfor irep in range(1, numReps+1):\n\t\t\t\tif score == 'ihs':\n\t\t\t\t\tunnormedfile = basedir + \"neut/ihs/rep\" + str(irep) + \"_\" + str(pop) + \".ihs.out\"\n\t\t\t\t\tphyspos_ind = 1\n\t\t\t\telif score == \"delihh\":\n\t\t\t\t\tunnormedfile = basedir + \"neut/delihh/rep\" + str(irep) + \"_\" + str(pop) + \".txt\"\n\t\t\t\t\tphyspos_ind = 1\n\t\t\t\telif score == \"nsl\":\n\t\t\t\t\tunnormedfile = basedir + \"neut/nsl/rep\" + str(irep) + \"_\" + str(pop) + \".nsl.out\"\n\t\t\t\t\tphyspos_ind = 1\n\t\t\t\telif score == \"xpehh\":\n\t\t\t\t\tunnormedfile = basedir + \"neut/xpehh/rep\" + str(irep) + \"_\" + str(pop) + \"_\" + str(altpop) + \".xpehh.out\"\n\t\t\t\t\tphyspos_ind = 1\n\t\t\t\telif score == \"fst\":\n\t\t\t\t\tunnormedfile = basedir + \"neut/freqs/rep\" + str(irep) + \"_\" + str(pop) + \"_\" + str(altpop)\n\t\t\t\t\tphyspos_ind = 0\n\t\t\t\tif os.path.isfile(unnormedfile):\n\t\t\t\t\trepfiles.append(unnormedfile)\n\t\t\t\telse:\n\t\t\t\t\tprint('missing: ' + unnormedfile)\n\t\t\tconcatfile = open(concatfilename, 'w')\n\t\t\tfor irepfile in range(len(repfiles)):\n\t\t\t\trepfile = repfiles[irepfile]\n\t\t\t\treadfile = open(repfile, 'r')\n\t\t\t\tfirstline = readfile.readline()\n\t\t\t\tif score in ['xpehh', 'fst']: #header\n\t\t\t\t\tif irepfile == 0:\n\t\t\t\t\t\tconcatfile.write(firstline)\n\t\t\t\t\telse:\n\t\t\t\t\t\tpass\n\t\t\t\tfor line in readfile:\n\t\t\t\t\tentries = line.split()\n\t\t\t\t\tphyspos = int(entries[physpos_ind])\n\t\t\t\t\tif physpos >= startbound and physpos <= endbound:\n\t\t\t\t\t\tconcatfile.write(line)\n\t\t\t\treadfile.close()\n\t\t\tconcatfile.close()\n\t\t\tprint('wrote to: ' + concatfilename)\n\n\t\t#already have concatfile\n\t\tinfilename = concatfilename\n\t\toutfilename = concatfilename + \".norm\" #or just write to /tmp ?\n\t\targstring = infilename #+ \" \" + outfilename\n\t\tif score in ['ihs', 'delihh']:\n\t\t\tcmd = \"python \" + cmsdir + \"scans.py selscan_norm_ihs\"\n\t\telif score in ['nsl']:\n\t\t\tcmd = \"python \" + cmsdir + \"scans.py selscan_norm_nsl\"\n\t\telif score in ['xpehh']:\n\t\t\tcmd = \"python \" + cmsdir + \"scans.py selscan_norm_xpehh\"\n\t\telse:\n\t\t\tcmd = \"\"\n\t\tfullcmd = cmd + \" \" + argstring\n\t\n\t\talreadyExists = False\n\t\tif args.checkOverwrite:\n\t\t\tif not os.path.isfile(binfilename): #check for overwrite\n\t\t\t\talreadyExists = False\n\t\t\telse:\n\t\t\t\talreadyExists = True\t\t\t\t\n\t\tif alreadyExists == False:\n\t\t\tprint(fullcmd)\n\t\t\t#execute(fullcmd)\n\t\t\twith open(binfilename, 'w') as outfile:\n\t\t\t\tsubprocess.check_output( fullcmd.split(), stderr=outfile)\n\t\t\toutfile.close()\n\t\t\tprint('wrote to: ' + binfilename)\n\treturn\ndef execute_norm_from_neut_params(args): \n\t''' using parameters from neutral simulates, normalizes component scores '''\n\tpop = args.simpop\n\tnumReps = args.nrep\n\tbasedir = args.modeldir\n\tif basedir[-1] != \"/\":\n\t\tbasedir += \"/\"\n\tcmsdir = args.cmsdir\n\tscore = args.score\n\taltpop = args.altpop\n\tscenario_dir = args.scenario_dir\n\t#if args.selbin is None:\n\t#\tscenario_dir = \"neut/\"\n\t#else:\n\t#\tscenario_dir = \"sel\" + str(pop) + \"/sel_\" + str(args.selbin) + \"/\"\n\tconcatfilename, binfilename = get_concat_files(pop, score, altpop, basedir=basedir) #I NEED TO MAKE THIS HANDLE SEL SITUATION\n\tprint('loading normalization parameters from ' + binfilename + \"...\")\n\t###############\n\t## NORMALIZE ##\n\t###############\n\tfor irep in range(1, numReps+1):\n\t\tif score in ['ihs']:\n\t\t\tunnormedfile = basedir + scenario_dir + \"ihs/rep\" + str(irep) + \"_\" + str(pop) + \".ihs.out\"\n\t\t\tnorm_sel_ihs(unnormedfile, binfilename)\n\t\telif score in ['delihh']:\n\t\t\tunnormedfile = basedir + scenario_dir + \"delihh/rep\" + str(irep) + \"_\" + str(pop) + \".txt\"\n\t\t\tnorm_sel_ihs(unnormedfile, binfilename)\n\t\telif score in ['nsl']:\n\t\t\tunnormedfile = basedir + scenario_dir + \"nsl/rep\" + str(irep) + \"_\" + str(pop)+ \".nsl.out\"\n\t\t\tnorm_sel_ihs(unnormedfile, binfilename)\n\t\telif score in ['xpehh']:\n\t\t\tunnormedfile = basedir + scenario_dir + \"xpehh/rep\" + str(irep) + \"_\" + str(pop) + \"_\" + str(altpop) + \".xpehh.out\"\n\t\t\tnorm_sel_xpehh(unnormedfile, binfilename)\n\t\telse: #if score in ['fst']:\n\t\t\tprint('currently handling this manually: rewrite_fst_bins.py')\n\t\t\tpass\n\t\tif irep%100 == 0:\n\t\t\tprint(\"currently rep: \" + str(irep))\n\treturn\t\n\n### Define component score likelihood \n### functions as histograms of simulated scores\ndef execute_likes_from_scores(args): \n\t''' define likelihood function for component score based on histograms of score values from simulated data.\n\teach run is per-score, per-scenario. does all pops / poppairs '''\n\tmodeldir, pops = args.modeldir, [1, 2, 3, 4]\n\tif modeldir[-1] != \"/\":\n\t\tmodeldir += \"/\"\n\tmodeldir_entries = modeldir.split('/')\n\tmodel = modeldir_entries[-2]\n\tnPerBin_Neut, nPerBin_Sel = args.nrep_neut, args.nrep_sel\n\tfreqRange, nBins = args.freqRange, args.nBins #define selscenario bins\n\tfullrange, bin_starts, bin_ends, bin_medians, bin_medians_str = get_bins(freqRange, nBins)\n\tchrlen, edge = args.chromlen, args.edge #define replicate interior (conservative strategy to avoid edge effects)\n\tstartbound, endbound = int(edge), chrlen - int(edge) \n\t#print(str([args.ihs, args.delihh, args.nsl, args.xpehh, args.deldaf, args.fst]))\n\tif [args.ihs, args.delihh, args.nsl, args.xpehh, args.deldaf, args.fst].count(True) != 1:\n\t\tprint('must call one score at a time')\n\t\tsys.exit(0)\n\t#####################\n\t## LOAD NEUT FILES ##\n\t#####################\n\tneutdir = modeldir + \"neut/\"\n\tall_completed_neut = []\n\tfor pop in pops:\n\t\tcompleted_neut = []\n\t\tfor irep in range(1, nPerBin_Neut+1):\n\t\t\tloaded_neut_files = get_sim_compscore_files(pop, irep, neutdir) \n\t\t\tall_present = [os.path.isfile(item) for item in loaded_neut_files]\n\t\t\tif (all_present.count(True)) == 9: #replicate done\n\t\t\t\tcompleted_neut.append(loaded_neut_files)\n\t\tall_completed_neut.append(completed_neut)\n\tprint(\"loaded \" + str(sum([len(item) for item in all_completed_neut])) + \" neutral replicates with complete component scores from \" + neutdir)\n\t####################\n\t## LOAD SEL FILES ## \n\t####################\n\tbinlabels = bin_medians_str \n\tall_completed_sel, selcounter = [], 0\n\tfor pop in pops:\n\t\tseldir = modeldir + \"sel\" + str(pop) + \"/\"\n\t\tcompleted_sel = []\n\t\t## generate likelihood distributions for selection simulates \n\t\t## from multiple frequency bins\n\t\tif args.binMerge: \n\t\t\t#need: input bins and name of cluster\n\t\t\tselbin_clusters = [[\"0.10\", \"0.20\", \"0.30\", \"0.40\", \"0.50\", \"0.60\", \"0.70\", \"0.80\", \"0.90\"],[\"0.70\", \"0.80\", \"0.90\",], [\"0.40\", \"0.50\", \"0.60\",], [\"0.10\", \"0.20\", \"0.30\"],] \n\t\t\tcluster_names = [\"allfreq\", \"hi\", \"mid\", \"low\"] \n\t\t\tfor icluster in range(len(selbin_clusters)):\n\t\t\t\tcluster, clustername = selbin_clusters[icluster], cluster_names[icluster]\n\t\t\t\tcompleted_cluster = []\n\t\t\t\tfor selbin in cluster:\n\t\t\t\t\tbindir = seldir + \"sel_\" + str(selbin) + \"/\"\t\t\t\t\n\t\t\t\t\tfor irep in range(1, nPerBin_Sel+1):\n\t\t\t\t\t\tloaded_sel_files = get_sim_compscore_files(pop, irep, bindir)\n\t\t\t\t\t\tall_present = [os.path.isfile(item) for item in loaded_sel_files]\n\t\t\t\t\t\tif (all_present.count(True)) == 9: #replicate done\n\t\t\t\t\t\t\tcompleted_cluster.append(loaded_sel_files)\n\t\t\t\t\t\t\tselcounter +=1\n\t\t\t\tcompleted_sel.append(completed_cluster)\n\t\t\tall_completed_sel.append(completed_sel) #[ipop][iCLUSTER][irep][iscore]\n\t\t\tnChunks, chunk_labels = len(cluster_names), cluster_names\n\t\t\n\t\t## fine-grained (ie per-sel-bin) generation of \n\t\t## score probability density functions\n\t\telse:\n\t\t\tfor selbin in binlabels:\n\t\t\t\tbindir = seldir + \"sel_\" + str(selbin) + \"/\"\n\t\t\t\tcompleted_bin = []\n\t\t\t\tfor irep in range(1, nPerBin_Sel+1):\n\t\t\t\t\tloaded_sel_files = get_sim_compscore_files(pop, irep, bindir)\n\t\t\t\t\tall_present = [os.path.isfile(item) for item in loaded_sel_files]\n\t\t\t\t\tif (all_present.count(True)) == 9: #replicate done\n\t\t\t\t\t\tcompleted_bin.append(loaded_sel_files)\n\t\t\t\t\t\tselcounter +=1\n\t\t\t\tcompleted_sel.append(completed_bin)\n\t\t\tall_completed_sel.append(completed_sel) #[ipop][ibin][irep][iscore]\n\t\t\tnChunks, chunk_labels = len(binlabels), bin_medians_str\n\tprint(\"loaded \" + str(selcounter) + \" selection replicates with complete component scores\")\n\t#################################\n\t## SORT SCORES INTO HISTOGRAMS ## \n\t################################# \n\tfor ichunk in range(nChunks): #iterate over selfreqs\n\t\tchunkstring = chunk_labels[ichunk]\n\t\t####################\n\t\t## PER POP SCORES ##\n\t\t####################\n\t\tif (args.ihs or args.delihh or args.nsl): #per pop\n\t\t\t###########\n\t\t\t### SORT ## \n\t\t\t###########\n\t\t\tif args.ihs:\n\t\t\t\tscore = \"ihs\"\n\t\t\t\tprint('binning iHS scores...')\n\t\t\t\tvalues = get_scores_from_files(all_completed_neut, all_completed_sel, 0, ichunk, startbound, endbound, foldDists = args.foldDist)\n\t\t\tif args.delihh:\n\t\t\t\tscore = \"delihh\"\n\t\t\t\tprint('binning delIHH scores...')\n\t\t\t\tvalues = get_scores_from_files(all_completed_neut, all_completed_sel, 1, ichunk, startbound, endbound, foldDists = args.foldDist)\t\n\t\t\tif args.nsl:\n\t\t\t\tscore = \"nsl\"\n\t\t\t\tprint('binning nSL scores...')\n\t\t\t\tvalues = get_scores_from_files(all_completed_neut, all_completed_sel, 2, ichunk, startbound, endbound, foldDists = args.foldDist)\n\t\t\tif True:\n\t\t\t\tpop1vals, pop2vals, pop3vals, pop4vals = values\n\t\t\t\tneut_1, causal_1, linked_1 = pop1vals\n\t\t\t\tneut_2, causal_2, linked_2 = pop2vals\n\t\t\t\tneut_3, causal_3, linked_3 = pop3vals\n\t\t\t\tneut_4, causal_4, linked_4 = pop4vals\n\t\t\t##########\n\t\t\t## PLOT ##\n\t\t\t##########\n\t\t\tminVal, maxVal, nProbBins, annotate = get_plot_pdf_params(score, args.foldDist)\n\t\t\tplot_title = \"PDF for \" + score + \", sel_\" + str(chunkstring)\n\t\t\toutput_dir = \"\"\n\t\t\tif args.save_dir is not None:\n\t\t\t\toutput_dir = args.save_dir + model + \"_\"\n\t\t\telse:\n\t\t\t\toutput_dir = modeldir + \"likes/\"\n\n\t\t\tsavefilebase = output_dir + score + \"_sel_\" + chunkstring \n\t\t\tif args.save_suffix is not None:\n\t\t\t\tsavefilebase += \"_\" + args.save_suffix\n\n\t\t\tsavefilename = savefilebase + \".png\"\n\t\t\t#savefilebase = modeldir + \"likes/\" + score + \"_sel_\" + chunkstring #ensure consistency with get_likes_filenames\n\t\t\tlikes_savebase_1 = output_dir + score + \"_sel1_\" + chunkstring + \"_\" \n\t\t\tlikes_savebase_2 = output_dir + score + \"_sel2_\" + chunkstring + \"_\" #+ args.save_suffix + \"_\"\n\t\t\tlikes_savebase_3 = output_dir + score + \"_sel3_\" + chunkstring + \"_\" #+ args.save_suffix + \"_\"\n\t\t\tlikes_savebase_4 = output_dir + score + \"_sel4_\" + chunkstring + \"_\" #+ args.save_suffix + \"_\"\n\t\t\tif args.save_suffix is not None:\n\t\t\t\tlikes_savebase_1 += args.save_suffix + \"_\"\n\t\t\t\tlikes_savebase_2 += args.save_suffix + \"_\"\n\t\t\t\tlikes_savebase_3 += args.save_suffix + \"_\"\n\t\t\t\tlikes_savebase_4 += args.save_suffix + \"_\"\n\n\t\t\tf1, (ax1, ax2, ax3, ax4) = plt.subplots(4, sharex=True, sharey=True)\n\t\t\tplt.suptitle(plot_title)\n\t\t\tplot_pdf_comparison_from_scores(ax1, neut_1, causal_1, linked_1, minVal, maxVal, nProbBins, \"1 (AFR)\", likes_savebase_1, saveFiles = args.save_likelihoods, annotate = annotate)\n\t\t\tplot_pdf_comparison_from_scores(ax2, neut_2, causal_2, linked_2, minVal, maxVal, nProbBins, \"2 (EUR)\", likes_savebase_2, saveFiles = args.save_likelihoods, annotate = annotate)\n\t\t\tplot_pdf_comparison_from_scores(ax3, neut_3, causal_3, linked_3, minVal, maxVal, nProbBins, \"3 (EAS)\", likes_savebase_3, annotate = annotate, saveFiles = args.save_likelihoods)\n\t\t\tplot_pdf_comparison_from_scores(ax4, neut_4, causal_4, linked_4, minVal, maxVal, nProbBins, \"4 (SAS)\", likes_savebase_4, annotate = annotate, saveFiles = args.save_likelihoods)\n\t\t\tax4.set_xlabel('score value')\n\t\t\t#f1.subplots_adjust(hspace=0)\n\t\t\t#f1.ylabel(\"p(score)\")\n\t\t\tplt.savefig(savefilename)\n\t\t\tplt.close()\n\t\t\tprint('saved to ' + savefilename)\n\n\t\t##################\n\t\t## PER POP COMP ##\n\t\t##################\n\t\tif (args.xpehh or args.deldaf or args.fst): #per pop-comp\n\t\t\t###########\n\t\t\t### SORT ##\n\t\t\t###########\n\t\t\tif args.xpehh:\n\t\t\t\tscore = \"xpehh\"\n\t\t\t\tprint('binning XP-EHH scores...')\n\t\t\t\tvalues = get_compscores_from_files_flatten(all_completed_neut, all_completed_sel, \"xpehh\", ichunk, startbound, endbound, foldDists = args.foldDist)\n\t\t\tif args.deldaf:\n\t\t\t\tscore = \"deldaf\"\n\t\t\t\tprint('binning delDAF scores...')\n\t\t\t\tvalues = get_compscores_from_files_flatten(all_completed_neut, all_completed_sel, \"deldaf\", ichunk, startbound, endbound, foldDists = args.foldDist)\t\n\t\t\tif args.fst:\n\t\t\t\tscore = \"fst\"\n\t\t\t\tprint('binning Fst scores...')\n\t\t\t\tvalues = get_compscores_from_files_flatten(all_completed_neut, all_completed_sel, \"fst\", ichunk, startbound, endbound, foldDists = args.foldDist)\n\t\t\tif True:\n\t\t\t\tpop1vals, pop2vals, pop3vals, pop4vals = values\n\t\t\t\tneutvals1, causalvals1, linkedvals1 = pop1vals\n\t\t\t\tneutvals2, causalvals2, linkedvals2 = pop2vals\n\t\t\t\tneutvals3, causalvals3, linkedvals3 = pop3vals\n\t\t\t\tneutvals4, causalvals4, linkedvals4 = pop4vals\n\n\t\t\t##########\n\t\t\t## PLOT ##\n\t\t\t##########\n\t\t\tminVal, maxVal, nProbBins, annotate = get_plot_pdf_params(score, args.foldDist)\n\t\t\toutput_dir = \"\"\n\t\t\tif args.save_dir is not None:\n\t\t\t\toutput_dir = args.save_dir + model + \"_\"\n\t\t\telse:\n\t\t\t\toutput_dir = modeldir + \"likes/\"\n\n\t\t\tsavefilebase = output_dir + score + \"_sel_\" + str(chunkstring)\n\t\t\tif args.save_suffix is not None:\n\t\t\t\tsavefilebase += \"_\" + args.save_suffix\n\t\t\tsavefilename = savefilebase + \".png\"\n\t\n\t\t\tplot_title = \"PDF for \" + score + \", \" + str(chunkstring)\n\n\t\t\tlikes_savebase_1 = output_dir + score + \"_sel1_\" + chunkstring + \"_\" \n\t\t\tlikes_savebase_2 = output_dir + score + \"_sel2_\" + chunkstring + \"_\" #+ args.save_suffix + \"_\"\n\t\t\tlikes_savebase_3 = output_dir + score + \"_sel3_\" + chunkstring + \"_\" #+ args.save_suffix + \"_\"\n\t\t\tlikes_savebase_4 = output_dir + score + \"_sel4_\" + chunkstring + \"_\" #+ args.save_suffix + \"_\"\n\t\t\tif args.save_suffix is not None:\n\t\t\t\tlikes_savebase_1 += args.save_suffix + \"_\"\n\t\t\t\tlikes_savebase_2 += args.save_suffix + \"_\"\n\t\t\t\tlikes_savebase_3 += args.save_suffix + \"_\"\n\t\t\t\tlikes_savebase_4 += args.save_suffix + \"_\"\n\t\t\tf1, (ax1, ax2, ax3, ax4) = plt.subplots(4, sharex=True, sharey=True)\n\t\t\tplt.suptitle(plot_title)\n\t\t\tplot_pdf_comparison_from_scores(ax1, neutvals1, causalvals1, linkedvals1, minVal, maxVal, nProbBins, \"1 (AFR)\", likes_savebase_1, saveFiles = args.save_likelihoods, annotate = annotate)\n\t\t\tplot_pdf_comparison_from_scores(ax2, neutvals2, causalvals2, linkedvals2, minVal, maxVal, nProbBins, \"2 (EUR)\", likes_savebase_2, saveFiles = args.save_likelihoods, annotate = annotate)\n\t\t\tplot_pdf_comparison_from_scores(ax3, neutvals3, causalvals3, linkedvals3, minVal, maxVal, nProbBins, \"3 (EAS)\", likes_savebase_3, annotate = annotate, saveFiles = args.save_likelihoods)\n\t\t\tplot_pdf_comparison_from_scores(ax4, neutvals4, causalvals4, linkedvals4, minVal, maxVal, nProbBins, \"4 (SAS)\", likes_savebase_4, annotate = annotate, saveFiles = args.save_likelihoods)\n\t\t\tax4.set_xlabel('score value')\n\t\t\t#plot_pdf_comparison_from_scores(ax1, neuta, causala, linkeda, minVal, maxVal, nProbBins, ax_ylabela, savefilename_a, annotate = annotate, saveFiles = args.save_likelihoods)\n\t\t\t#ax3.set_xlabel('score value')\n\t\t\t#f1.subplots_adjust(hspace=0)\n\t\t\tplt.savefig(savefilename)\n\t\t\tplt.close()\n\t\t\tprint('saved to ' + savefilename)\n\treturn\ndef execute_plot_likes_vs_scores(args): ##REVISIT\n\t''' useful QC step; visualize the function that converts score values into likelihood contributions towards composite scores '''\n\tprint(\"Does this still apply with the combine_amend?\") \n\tinputprefix = args.inputLikesPrefix\n\tnregionsnps = args.default_nregion_snps\n\tcausal_likes_filename, linked_likes_filename, neut_likes_filename = inputprefix + \"_causal.txt\", inputprefix + \"_linked.txt\", inputprefix + \"_neut.txt\"\n\n\tcausal_likes = quick_load_likes(causal_likes_filename)\n\tlinked_likes = quick_load_likes(linked_likes_filename)\n\tneut_likes = quick_load_likes(neut_likes_filename)\n\n\tcomp_likes = quick_cl_from_likes(causal_likes, linked_likes, nSnp = nregionsnps, takeLn = True)\n\tcomp_like_ratios = quick_clr_from_likes(causal_likes, neut_likes, takeLn = True)\n\n\tsavefilename = inputprefix + \"_clr_likes_vs_likesscores.png\"\n\tfig, ax = plt.subplots()\n\tax.scatter(np.arange(len(comp_like_ratios)), comp_like_ratios) #I want to make this use the actual score ranges.\n\tplt.savefig(savefilename)\n\tprint('saved to: ' + savefilename)\n\tplt.close()\n\n\tsavefilename = inputprefix + \"_cl_likes_vs_likesscores.png\"\n\tfig, ax = plt.subplots()\n\tax.scatter(np.arange(len(comp_likes)), comp_likes)\n\tplt.savefig(savefilename)\n\tprint('saved to: ' + savefilename)\n\tplt.close()\n\treturn\ndef execute_write_master_likes(args):\n\t\"\"\" given granular output from likes_from_scores, bundle together into groups of distributions with which to composite \"\"\" \n\tscore = args.score\n\twriteloc = args.likes_masterDir\n\tbasedir = args.likes_inDir \n\tif basedir[-1] != \"/\":\n\t\tbasedir += \"/\"\n\tif writeloc[-1] != \"/\":\n\t\twriteloc += \"/\"\n\tpop = args.simpop\n\tmodel = args.model\n\t#like_savestring = args.likes_savestring\n\tscore_gw_like_savestring, score_local_like_savestring = get_likes_savestrings(score, basedir) #includes _folded\n\n\t###############################\n\t## CMS_GW : FOLDED, VS. NEUT ##\n\t################## #############\n\t\n\tneut_filename, linked_filename, hit_hi_filename, hit_mid_filename, hit_low_filename, hit_allfreqs_filename = get_likes_filenames(basedir, model, score, pop, like_savestring = score_gw_like_savestring)\n\tlikesFreqs_master_writefilename_global = writeloc + model + \"_\" + score + \"_sel\" + str(pop) + \"_vsNeut_likesFreqs.master.txt\"\n\tallFreqs_master_writefilename_global = writeloc + model + \"_\" + score + \"_sel\" + str(pop) + \"_vsNeut_allFreqs.master.txt\"\n\twrite_master_likesfile(likesFreqs_master_writefilename_global, neut_filename, hit_hi_filename, hit_mid_filename, hit_low_filename)\n\twrite_master_likesfile(allFreqs_master_writefilename_global, neut_filename, hit_allfreqs_filename, hit_allfreqs_filename, hit_allfreqs_filename)\n\t\n\t######################################\n\t## CMS_LOCAL : UNFOLDED, VS. LINKED ##\n\t######################################\n\tneut_filename, linked_filename, hit_hi_filename, hit_mid_filename, hit_low_filename, hit_allfreqs_filename = get_likes_filenames(basedir, model, score, pop, like_savestring = score_local_like_savestring)\n\tlikesFreqs_master_writefilename_local = writeloc + model + \"_\" + score + \"_sel\" + str(pop) + \"_vsLinked_likesFreqs.master.txt\"\n\tallFreqs_master_writefilename_local = writeloc + model + \"_\" + score + \"_sel\" + str(pop) + \"_vsLinked_allFreqs.master.txt\"\n\twrite_master_likesfile(likesFreqs_master_writefilename_local, linked_filename, hit_hi_filename, hit_mid_filename, hit_low_filename)\n\twrite_master_likesfile(allFreqs_master_writefilename_local, linked_filename, hit_allfreqs_filename, hit_allfreqs_filename, hit_allfreqs_filename)\n\treturn \n\n##########\n## MAIN ##\n##########\nif __name__ == '__main__':\n\trunparser = full_parser_likes_from_model()\n\targs = runparser.parse_args()\n\n\t# if called with no arguments, print help\n\tif len(sys.argv)==1:\n\t\trunparser.parse_args(['--help'])\n\n\tsubcommand = sys.argv[1]\n\tfunction_name = 'execute_' + subcommand + \"(args)\"\n\teval(function_name) #points to functions defined above, which wrap other programs in the pipeline\n", "meta": {"hexsha": "5c9f12d70489ca166f5b9d018e380bdd0194beab", "size": 37167, "ext": "py", "lang": "Python", "max_stars_repo_path": "cms/likes_from_model.py", "max_stars_repo_name": "broadinstitute/cms", "max_stars_repo_head_hexsha": "4743ffd3feac08f02be7719c82b3371cb94a4d6b", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 13, "max_stars_repo_stars_event_min_datetime": "2015-05-18T14:39:00.000Z", "max_stars_repo_stars_event_max_datetime": "2020-07-22T12:57:07.000Z", "max_issues_repo_path": "cms/likes_from_model.py", "max_issues_repo_name": "broadinstitute/cms", "max_issues_repo_head_hexsha": "4743ffd3feac08f02be7719c82b3371cb94a4d6b", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 33, "max_issues_repo_issues_event_min_datetime": "2015-04-13T20:48:02.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-19T07:27:30.000Z", "max_forks_repo_path": "cms/likes_from_model.py", "max_forks_repo_name": "broadinstitute/cms", "max_forks_repo_head_hexsha": "4743ffd3feac08f02be7719c82b3371cb94a4d6b", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 9, "max_forks_repo_forks_event_min_datetime": "2016-03-31T06:56:01.000Z", "max_forks_repo_forks_event_max_datetime": "2020-01-30T16:35:45.000Z", "avg_line_length": 53.8652173913, "max_line_length": 245, "alphanum_fraction": 0.7179756235, "include": true, "reason": "import numpy", "num_tokens": 10269, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.5851011397337391, "lm_q2_score": 0.33111975283019596, "lm_q1q2_score": 0.19373854476930163}} {"text": "# -*- coding: utf-8 -*-\n# vim: tabstop=4 shiftwidth=4 softtabstop=4\n#\n# Copyright (C) 2013-2018 GEM Foundation\n#\n# OpenQuake is free software: you can redistribute it and/or modify it\n# under the terms of the GNU Affero General Public License as published\n# by the Free Software Foundation, either version 3 of the License, or\n# (at your option) any later version.\n#\n# OpenQuake is distributed in the hope that it will be useful,\n# but WITHOUT ANY WARRANTY; without even the implied warranty of\n# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n# GNU Affero General Public License for more details.\n#\n# You should have received a copy of the GNU Affero General Public License\n# along with OpenQuake. If not, see .\n\n\"\"\"\nModule exports :class:`CampbellBozorgnia2008`, and\n:class:'CampbellBozorgnia2008Arbitrary'\n\"\"\"\nimport numpy as np\nfrom math import log, exp\nfrom openquake.hazardlib.gsim.base import GMPE, CoeffsTable\nfrom openquake.hazardlib import const\nfrom openquake.hazardlib.imt import PGA, PGV, PGD, CAV, SA\n\n\nclass CampbellBozorgnia2008(GMPE):\n \"\"\"\n Implements GMPE developed by Kenneth W. Campbell and Yousef Bozorgnia,\n published as \"NGA Ground Motion Model for the Geometric Mean Horizontal\n Component of PGA, PGV, PGD and 5 % Damped Linear Elastic Response Spectra\n for Periods Ranging from 0.01 to 10s\" (2008, Earthquake Spectra,\n Volume 24, Number 1, pages 139 - 171).\n This class implements the model for the Geometric Mean of the elastic\n spectra.\n Included in the coefficient set are the coefficients for the\n Campbell & Bozorgnia (2010) GMPE for predicting Cumulative Absolute\n Velocity (CAV), published as \"A Ground Motion Prediction Equation for\n the Horizontal Component of Cumulative Absolute Velocity (CSV) Based on\n the PEER-NGA Strong Motion Database\" (2010, Earthquake Spectra, Volume 26,\n Number 3, 635 - 650).\n \"\"\"\n #: Supported tectonic region type is active shallow crust\n DEFINED_FOR_TECTONIC_REGION_TYPE = const.TRT.ACTIVE_SHALLOW_CRUST\n\n #: Supported intensity measure types are spectral acceleration, peak\n #: ground velocity, peak ground displacement and peak ground acceleration\n #: Additional model for cumulative absolute velocity defined in\n #: Campbell & Bozorgnia (2010)\n DEFINED_FOR_INTENSITY_MEASURE_TYPES = set([\n PGA,\n PGV,\n PGD,\n CAV,\n SA\n ])\n\n #: Supported intensity measure component is orientation-independent\n #: average horizontal :attr:`~openquake.hazardlib.const.IMC.GMRotI50`\n DEFINED_FOR_INTENSITY_MEASURE_COMPONENT = const.IMC.GMRotI50\n\n #: Supported standard deviation types are inter-event, intra-event\n #: and total, see section \"Aleatory Uncertainty Model\", page 147.\n DEFINED_FOR_STANDARD_DEVIATION_TYPES = set([\n const.StdDev.TOTAL,\n const.StdDev.INTER_EVENT,\n const.StdDev.INTRA_EVENT\n ])\n\n #: Required site parameters are Vs30, Vs30 type (measured or inferred),\n #: and depth (km) to the 2.5 km/s shear wave velocity layer (z2pt5)\n REQUIRES_SITES_PARAMETERS = set(('vs30', 'z2pt5'))\n\n #: Required rupture parameters are magnitude, rake, dip, ztor\n REQUIRES_RUPTURE_PARAMETERS = set(('mag', 'rake', 'dip', 'ztor'))\n\n #: Required distance measures are Rrup and Rjb.\n REQUIRES_DISTANCES = set(('rrup', 'rjb'))\n\n def get_mean_and_stddevs(self, sites, rup, dists, imt, stddev_types):\n \"\"\"\n See :meth:`superclass method\n <.base.GroundShakingIntensityModel.get_mean_and_stddevs>`\n for spec of input and result values.\n \"\"\"\n # extract dictionaries of coefficients specific to required\n # intensity measure type and for PGA\n C = self.COEFFS[imt]\n C_PGA = self.COEFFS[PGA()]\n\n # compute median pga on rock (vs30=1100), needed for site response\n # term calculation\n # For spectral accelerations at periods between 0.0 and 0.25 s, Sa (T)\n # cannot be less than PGA on soil, therefore if the IMT is in this\n # period range it is necessary to calculate PGA on soil\n if isinstance(imt, SA) and (imt.period > 0.0) and (imt.period < 0.25):\n get_pga_site = True\n else:\n get_pga_site = False\n pga1100, pga_site = self._compute_imt1100(C_PGA,\n sites,\n rup,\n dists,\n get_pga_site)\n\n # Get the median ground motion\n mean = (self._compute_magnitude_term(C, rup.mag) +\n self._compute_distance_term(C, rup, dists) +\n self._compute_style_of_faulting_term(C, rup) +\n self._compute_hanging_wall_term(C, rup, dists) +\n self._compute_shallow_site_response(C, sites, pga1100) +\n self._compute_basin_response_term(C, sites.z2pt5))\n\n # If it is necessary to ensure that Sa(T) >= PGA (see previous comment)\n if get_pga_site:\n idx = mean < np.log(pga_site)\n mean[idx] = np.log(pga_site[idx])\n\n stddevs = self._get_stddevs(C,\n sites,\n pga1100,\n C_PGA['s_lny'],\n stddev_types)\n return mean, stddevs\n\n def _compute_imt1100(self, C, sites, rup, dists, get_pga_site=False):\n \"\"\"\n Computes the PGA on reference (Vs30 = 1100 m/s) rock.\n \"\"\"\n # Calculates simple site response term assuming all sites 1100 m/s\n fsite = (C['c10'] + (C['k2'] * C['n'])) * log(1100. / C['k1'])\n # Calculates the PGA on rock\n pga1100 = np.exp(self._compute_magnitude_term(C, rup.mag) +\n self._compute_distance_term(C, rup, dists) +\n self._compute_style_of_faulting_term(C, rup) +\n self._compute_hanging_wall_term(C, rup, dists) +\n self._compute_basin_response_term(C, sites.z2pt5) +\n fsite)\n # If PGA at the site is needed then remove factor for rock and\n # re-calculate on correct site condition\n if get_pga_site:\n pga_site = np.exp(np.log(pga1100) - fsite)\n fsite = self._compute_shallow_site_response(C, sites, pga1100)\n pga_site = np.exp(np.log(pga_site) + fsite)\n else:\n pga_site = None\n return pga1100, pga_site\n\n def _compute_magnitude_term(self, C, mag):\n \"\"\"\n Returns the magnitude scaling factor (equation (2), page 144)\n \"\"\"\n fmag = C['c0'] + C['c1'] * mag\n if mag <= 5.5:\n return fmag\n elif mag > 6.5:\n return fmag + (C['c2'] * (mag - 5.5)) + (C['c3'] * (mag - 6.5))\n else:\n return fmag + (C['c2'] * (mag - 5.5))\n\n def _compute_distance_term(self, C, rup, dists):\n \"\"\"\n Returns the distance scaling factor (equation (3), page 145)\n \"\"\"\n return (C['c4'] + C['c5'] * rup.mag) * \\\n np.log(np.sqrt(dists.rrup ** 2. + C['c6'] ** 2.))\n\n def _compute_style_of_faulting_term(self, C, rup):\n \"\"\"\n Returns the style of faulting factor, depending on the mechanism (rake)\n and top of rupture depth (equations (4) and (5), pages 145 - 146)\n \"\"\"\n frv, fnm = self._get_fault_type_dummy_variables(rup.rake)\n\n if frv > 0.:\n # Top of rupture depth term only applies to reverse faults\n if rup.ztor < 1.:\n ffltz = rup.ztor\n else:\n ffltz = 1.\n else:\n ffltz = 0.\n return (C['c7'] * frv * ffltz) + (C['c8'] * fnm)\n\n def _get_fault_type_dummy_variables(self, rake):\n \"\"\"\n Returns the coefficients FRV and FNM, describing if the rupture is\n reverse (FRV = 1.0, FNM = 0.0), normal (FRV = 0.0, FNM = 1.0) or\n strike-slip/oblique-slip (FRV = 0.0, FNM = 0.0). Reverse faults are\n classified as those with a rake in the range 30 to 150 degrees. Normal\n faults are classified as having a rake in the range -150 to -30 degrees\n :returns:\n FRV, FNM\n \"\"\"\n if (rake > 30.0) and (rake < 150.):\n return 1., 0.\n elif (rake > -150.0) and (rake < -30.0):\n return 0., 1.\n else:\n return 0., 0.\n\n def _compute_hanging_wall_term(self, C, rup, dists):\n \"\"\"\n Returns the hanging wall scaling term, the product of the scaling\n coefficient and four separate scaling terms for distance, magnitude,\n rupture depth and dip (equations 6 - 10, page 146). Individual\n scaling terms defined in separate functions\n \"\"\"\n return (C['c9'] *\n self._get_hanging_wall_distance_term(dists, rup.ztor) *\n self._get_hanging_wall_magnitude_term(rup.mag) *\n self._get_hanging_wall_depth_term(rup.ztor) *\n self._get_hanging_wall_dip_term(rup.dip))\n\n def _get_hanging_wall_distance_term(self, dists, ztor):\n \"\"\"\n Returns the hanging wall distance scaling term (equation 7, page 146)\n \"\"\"\n fhngr = np.ones_like(dists.rjb, dtype=float)\n idx = dists.rjb > 0.\n if ztor < 1.:\n temp_rjb = np.sqrt(dists.rjb[idx] ** 2. + 1.)\n r_max = np.max(np.column_stack([dists.rrup[idx], temp_rjb]),\n axis=1)\n fhngr[idx] = (r_max - dists.rjb[idx]) / r_max\n else:\n fhngr[idx] = (dists.rrup[idx] - dists.rjb[idx]) / dists.rrup[idx]\n return fhngr\n\n def _get_hanging_wall_magnitude_term(self, mag):\n \"\"\"\n Returns the hanging wall magnitude scaling term (equation 8, page 146)\n \"\"\"\n if mag <= 6.0:\n return 0.\n elif mag >= 6.5:\n return 1.\n else:\n return 2. * (mag - 6.0)\n\n def _get_hanging_wall_depth_term(self, ztor):\n \"\"\"\n Returns the hanging wall depth scaling term (equation 9, page 146)\n \"\"\"\n if ztor >= 20.0:\n return 0.\n else:\n return (20. - ztor) / 20.0\n\n def _get_hanging_wall_dip_term(self, dip):\n \"\"\"\n Returns the hanging wall dip scaling term (equation 10, page 146)\n \"\"\"\n if dip > 70.0:\n return (90.0 - dip) / 20.0\n else:\n return 1.0\n\n def _compute_shallow_site_response(self, C, sites, pga1100):\n \"\"\"\n Returns the shallow site response term (equation 11, page 146)\n \"\"\"\n stiff_factor = C['c10'] + (C['k2'] * C['n'])\n # Initially default all sites to intermediate rock value\n fsite = stiff_factor * np.log(sites.vs30 / C['k1'])\n # Check for soft soil sites\n idx = sites.vs30 < C['k1']\n if np.any(idx):\n pga_scale = np.log(pga1100[idx] +\n (C['c'] * ((sites.vs30[idx] / C['k1']) **\n C['n']))) - np.log(pga1100[idx] + C['c'])\n fsite[idx] = C['c10'] * np.log(sites.vs30[idx] / C['k1']) + \\\n (C['k2'] * pga_scale)\n # Any very hard rock sites are rendered to the constant amplification\n # factor\n idx = sites.vs30 >= 1100.\n if np.any(idx):\n fsite[idx] = stiff_factor * log(1100. / C['k1'])\n\n return fsite\n\n def _compute_basin_response_term(self, C, z2pt5):\n \"\"\"\n Returns the basin response term (equation 12, page 146)\n \"\"\"\n fsed = np.zeros_like(z2pt5, dtype=float)\n idx = z2pt5 < 1.0\n if np.any(idx):\n fsed[idx] = C['c11'] * (z2pt5[idx] - 1.0)\n\n idx = z2pt5 > 3.0\n if np.any(idx):\n fsed[idx] = (C['c12'] * C['k3'] * exp(-0.75)) *\\\n (1.0 - np.exp(-0.25 * (z2pt5[idx] - 3.0)))\n return fsed\n\n def _get_stddevs(self, C, sites, pga1100, sigma_pga, stddev_types):\n \"\"\"\n Returns the standard deviations as described in the \"ALEATORY\n UNCERTAINTY MODEL\" section of the paper. Equations 13 to 19, pages 147\n to 151\n \"\"\"\n std_intra = self._compute_intra_event_std(C,\n sites.vs30,\n pga1100,\n sigma_pga)\n\n std_inter = C['t_lny'] * np.ones_like(sites.vs30)\n stddevs = []\n for stddev_type in stddev_types:\n assert stddev_type in self.DEFINED_FOR_STANDARD_DEVIATION_TYPES\n if stddev_type == const.StdDev.TOTAL:\n stddevs.append(self._get_total_sigma(C, std_intra, std_inter))\n elif stddev_type == const.StdDev.INTRA_EVENT:\n stddevs.append(std_intra)\n elif stddev_type == const.StdDev.INTER_EVENT:\n stddevs.append(std_inter)\n return stddevs\n\n def _compute_intra_event_std(self, C, vs30, pga1100, sigma_pga):\n \"\"\"\n Returns the intra-event standard deviation at the site, as defined in\n equation 15, page 147\n \"\"\"\n # Get intra-event standard deviation at the base of the site profile\n sig_lnyb = np.sqrt(C['s_lny'] ** 2. - C['s_lnAF'] ** 2.)\n sig_lnab = np.sqrt(sigma_pga ** 2. - C['s_lnAF'] ** 2.)\n # Get linearised relationship between f_site and ln PGA\n alpha = self._compute_intra_event_alpha(C, vs30, pga1100)\n\n return np.sqrt(\n (sig_lnyb ** 2.) +\n (C['s_lnAF'] ** 2.) +\n ((alpha ** 2.) * (sig_lnab ** 2.)) +\n (2.0 * alpha * C['rho'] * sig_lnyb * sig_lnab))\n\n def _compute_intra_event_alpha(self, C, vs30, pga1100):\n \"\"\"\n Returns the linearised functional relationship between fsite and\n pga1100, determined from the partial derivative defined on equation 17\n on page 148\n \"\"\"\n alpha = np.zeros_like(vs30, dtype=float)\n idx = vs30 < C['k1']\n if np.any(idx):\n temp1 = (pga1100[idx] +\n C['c'] * (vs30[idx] / C['k1']) ** C['n']) ** -1.\n temp1 = temp1 - ((pga1100[idx] + C['c']) ** -1.)\n alpha[idx] = C['k2'] * pga1100[idx] * temp1\n\n return alpha\n\n def _get_total_sigma(self, C, std_intra, std_inter):\n \"\"\"\n Returns the total sigma term as defined by equation 16, page 147\n This method is defined here as the Campbell & Bozorgnia (2008) model\n can also be applied to the \"arbitrary\" horizontal component\n definition, in which case the total sigma is modified.\n \"\"\"\n return np.sqrt(std_intra ** 2. + std_inter ** 2.)\n\n COEFFS = CoeffsTable(sa_damping=5, table=\"\"\"\\\n imt c0 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 k1 k2 k3 c n s_lny t_lny s_lnAF c_lny rho\n cav -4.354 0.942 -0.178 -0.346 -1.309 0.087 7.24 0.111 -0.108 0.362 2.549 0.090 1.277 400 -2.690 1.000 1.88 1.18 0.371 0.196 0.300 0.089 0.735\n pgd -5.270 1.600 -0.070 0.000 -2.000 0.17 4.00 0.000 0.000 0.000 -0.820 0.300 1.000 400 0.000 2.744 1.88 1.18 0.667 0.485 0.300 0.290 0.174\n pgv 0.954 0.696 -0.309 -0.019 -2.016 0.17 4.00 0.245 0.000 0.358 1.694 0.092 1.000 400 -1.955 1.929 1.88 1.18 0.484 0.203 0.300 0.190 0.691\n pga -1.715 0.500 -0.530 -0.262 -2.118 0.17 5.60 0.280 -0.120 0.490 1.058 0.040 0.610 865 -1.186 1.839 1.88 1.18 0.478 0.219 0.300 0.166 1.000\n 0.010 -1.715 0.500 -0.530 -0.262 -2.118 0.17 5.60 0.280 -0.120 0.490 1.058 0.040 0.610 865 -1.186 1.839 1.88 1.18 0.478 0.219 0.300 0.166 1.000\n 0.020 -1.680 0.500 -0.530 -0.262 -2.123 0.17 5.60 0.280 -0.120 0.490 1.102 0.040 0.610 865 -1.219 1.840 1.88 1.18 0.480 0.219 0.300 0.166 0.999\n 0.030 -1.552 0.500 -0.530 -0.262 -2.145 0.17 5.60 0.280 -0.120 0.490 1.174 0.040 0.610 908 -1.273 1.841 1.88 1.18 0.489 0.235 0.300 0.165 0.989\n 0.050 -1.209 0.500 -0.530 -0.267 -2.199 0.17 5.74 0.280 -0.120 0.490 1.272 0.040 0.610 1054 -1.346 1.843 1.88 1.18 0.510 0.258 0.300 0.162 0.963\n 0.075 -0.657 0.500 -0.530 -0.302 -2.277 0.17 7.09 0.280 -0.120 0.490 1.438 0.040 0.610 1086 -1.471 1.845 1.88 1.18 0.520 0.292 0.300 0.158 0.922\n 0.100 -0.314 0.500 -0.530 -0.324 -2.318 0.17 8.05 0.280 -0.099 0.490 1.604 0.040 0.610 1032 -1.624 1.847 1.88 1.18 0.531 0.286 0.300 0.170 0.898\n 0.150 -0.133 0.500 -0.530 -0.339 -2.309 0.17 8.79 0.280 -0.048 0.490 1.928 0.040 0.610 878 -1.931 1.852 1.88 1.18 0.532 0.280 0.300 0.180 0.890\n 0.200 -0.486 0.500 -0.446 -0.398 -2.220 0.17 7.60 0.280 -0.012 0.490 2.194 0.040 0.610 748 -2.188 1.856 1.88 1.18 0.534 0.249 0.300 0.186 0.871\n 0.250 -0.890 0.500 -0.362 -0.458 -2.146 0.17 6.58 0.280 0.000 0.490 2.351 0.040 0.700 654 -2.381 1.861 1.88 1.18 0.534 0.240 0.300 0.191 0.852\n 0.300 -1.171 0.500 -0.294 -0.511 -2.095 0.17 6.04 0.280 0.000 0.490 2.460 0.040 0.750 587 -2.518 1.865 1.88 1.18 0.544 0.215 0.300 0.198 0.831\n 0.400 -1.466 0.500 -0.186 -0.592 -2.066 0.17 5.30 0.280 0.000 0.490 2.587 0.040 0.850 503 -2.657 1.874 1.88 1.18 0.541 0.217 0.300 0.206 0.785\n 0.500 -2.569 0.656 -0.304 -0.536 -2.041 0.17 4.73 0.280 0.000 0.490 2.544 0.040 0.883 457 -2.669 1.883 1.88 1.18 0.550 0.214 0.300 0.208 0.735\n 0.750 -4.844 0.972 -0.578 -0.406 -2.000 0.17 4.00 0.280 0.000 0.490 2.133 0.077 1.000 410 -2.401 1.906 1.88 1.18 0.568 0.227 0.300 0.221 0.628\n 1.000 -6.406 1.196 -0.772 -0.314 -2.000 0.17 4.00 0.255 0.000 0.490 1.571 0.150 1.000 400 -1.955 1.929 1.88 1.18 0.568 0.255 0.300 0.225 0.534\n 1.500 -8.692 1.513 -1.046 -0.185 -2.000 0.17 4.00 0.161 0.000 0.490 0.406 0.253 1.000 400 -1.025 1.974 1.88 1.18 0.564 0.296 0.300 0.222 0.411\n 2.000 -9.701 1.600 -0.978 -0.236 -2.000 0.17 4.00 0.094 0.000 0.371 -0.456 0.300 1.000 400 -0.299 2.019 1.88 1.18 0.571 0.296 0.300 0.226 0.331\n 3.000 -10.556 1.600 -0.638 -0.491 -2.000 0.17 4.00 0.000 0.000 0.154 -0.820 0.300 1.000 400 0.000 2.110 1.88 1.18 0.558 0.326 0.300 0.229 0.289\n 4.000 -11.212 1.600 -0.316 -0.770 -2.000 0.17 4.00 0.000 0.000 0.000 -0.820 0.300 1.000 400 0.000 2.200 1.88 1.18 0.576 0.297 0.300 0.237 0.261\n 5.000 -11.684 1.600 -0.070 -0.986 -2.000 0.17 4.00 0.000 0.000 0.000 -0.820 0.300 1.000 400 0.000 2.291 1.88 1.18 0.601 0.359 0.300 0.237 0.200\n 7.500 -12.505 1.600 -0.070 -0.656 -2.000 0.17 4.00 0.000 0.000 0.000 -0.820 0.300 1.000 400 0.000 2.517 1.88 1.18 0.628 0.428 0.300 0.271 0.174\n 10.00 -13.087 1.600 -0.070 -0.422 -2.000 0.17 4.00 0.000 0.000 0.000 -0.820 0.300 1.000 400 0.000 2.744 1.88 1.18 0.667 0.485 0.300 0.290 0.174\n \"\"\")\n\n\nclass CampbellBozorgnia2008Arbitrary(CampbellBozorgnia2008):\n \"\"\"\n Implements the Campbell & Bozorgnia (2008) GMPE as modified to represent\n the arbitrary horizontal component of ground motion, instead of the\n Rotationally Independent Geometric Mean (GMRotI) originally defined in\n the paper.\n \"\"\"\n\n #: Supported intensity measure component is arbitrary horizontal\n #: :attr:`~openquake.hazardlib.const.IMC.HORIZONTAL`,\n DEFINED_FOR_INTENSITY_MEASURE_COMPONENT = const.IMC.HORIZONTAL\n\n def _get_total_sigma(self, C, std_intra, std_inter):\n \"\"\"\n Returns the total sigma term for the arbitrary horizontal component of\n ground motion defined by equation 18, page 150\n \"\"\"\n return np.sqrt(std_intra ** 2. + std_inter ** 2. + C['c_lny'] ** 2.)\n", "meta": {"hexsha": "8f45b6206bbe8aef19f6f4054b1027f530ae20d3", "size": 20174, "ext": "py", "lang": "Python", "max_stars_repo_path": "openquake/hazardlib/gsim/campbell_bozorgnia_2008.py", "max_stars_repo_name": "gfzriesgos/shakyground-lfs", "max_stars_repo_head_hexsha": "2caf67cc32e6800286eded2df1efb05973ccf41b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-08-01T00:28:24.000Z", "max_stars_repo_stars_event_max_datetime": "2019-08-01T00:28:24.000Z", "max_issues_repo_path": "openquake/hazardlib/gsim/campbell_bozorgnia_2008.py", "max_issues_repo_name": "gfzriesgos/shakyground-lfs", "max_issues_repo_head_hexsha": "2caf67cc32e6800286eded2df1efb05973ccf41b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2018-08-31T14:14:35.000Z", "max_issues_repo_issues_event_max_datetime": "2021-10-11T12:53:13.000Z", "max_forks_repo_path": "openquake/hazardlib/gsim/campbell_bozorgnia_2008.py", "max_forks_repo_name": "gfzriesgos/shakyground-lfs", "max_forks_repo_head_hexsha": "2caf67cc32e6800286eded2df1efb05973ccf41b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2018-08-31T14:11:00.000Z", "max_forks_repo_forks_event_max_datetime": "2019-07-17T10:06:02.000Z", "avg_line_length": 48.8474576271, "max_line_length": 171, "alphanum_fraction": 0.5711807277, "include": true, "reason": "import numpy", "num_tokens": 7207, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.5851011542032312, "lm_q2_score": 0.3311197264277872, "lm_q1q2_score": 0.19373853411235645}} {"text": "# -*- coding: utf-8 -*-\n#!/usr/bin/env python\n\n__author__ = \"Luocheng Huang\"\n__copyright__ = \"Copyright 2018\"\n__credits__ = [\"Luocheng Huang\"]\n__license__ = \"GPL\"\n__version__ = \"2.0.2\"\n__maintainer__ = \"Luocheng Huang\"\n__email__ = \"luocheng@uw.edu\"\n__status__ = \"Production\"\n\nimport pandas as pd\nimport os\nimport numpy as np\nimport math\nimport time as time\nfrom multiprocessing import Pool\nimport matplotlib.pyplot as plt\nimport S4\n\n\n\n#CWD = os.getcwd()+'/'\n\n\n \ndef simulate_one(config, field=1):\n \"\"\"a wrapper for pickling\n simulates one instance\n \"\"\"\n global FIELD\n FIELD = field\n new = RCWA.Simulation()\n new.load_input(config)\n return new.run()\n\n\nclass RCWA:\n \"\"\"\n An rcwa simulation ojbect\n \"\"\"\n \n \n def __init__(self, input_list=None, cores=10, field = None):\n self.input = input_list\n self.cores = cores\n self.field = field\n global FIELD\n \"\"\"field is the amount of field in the center measured. 1 is 100% .5 is 25%\n returns the mean value if field==None\n else returns the center field.\"\"\"\n FIELD = field\n pass\n \n \n def timeit(method):\n \"\"\"a decor for timing methods, should be used as a decorator\n \"\"\"\n def timed(*args, **kw):\n ts = time.time()\n result = method(*args, **kw)\n te = time.time()\n if 'log_time' in kw:\n name = kw.get('log_name', method.__name__.upper())\n kw['log_time'][name] = int((te - ts) * 1000)\n else:\n print '%r %2.2f s' % \\\n (method.__name__, (te - ts) )\n return result\n return timed\n\n\n @timeit\n def simulate_and_graph(self):\n \"\"\"\n inputs the attribute list, \n :return: simulate results\n \"\"\"\n\n p = Pool(self.cores)\n df = pd.DataFrame()\n FIELD = self.field\n solution = p.map(simulate_one, self.input) # create a pool of workers and map it onto different cores\n p.close() # prevent memory leakage \n p.join() # synchronization point\n\n t_list = []\n p_list = []\n for s in solution:\n t_list.append(s[0])\n p_list.append(s[1])\n # make phase continuous\n # new_p = unwrap(p_list)\n new_p = [x[0] / (2*math.pi) for x in p_list]\n\n config = self.input[0]\n\n # plot data\n plt.figure(0)\n plt.figure(figsize=(10, 5), dpi=200)\n label1 = 'phase'\n label2 = 'amplitude'\n plt.plot(new_p, label=label1)\n plt.plot(t_list, label=label2)\n plt.xlabel('Grating post width')\n plt.ylabel('amp & phase')\n plt.title('Wavelength = {} nm'.format('unknown'))\n plt.legend()\n\n\n plt.savefig(\"{}.png\".format(('unknown')))\n plt.show();\n plt.clf();\n\n # save to csv\n a = (new_p, t_list)\n\n np.savetxt(\"data_{}.csv\".format(('unknown')), a, delimiter=\",\")\n\n\n pass\n\n \n @timeit\n def simulate(self):\n \"\"\"\n inputs the attribute list, \n :return: simulate results\n \"\"\"\n\n p = Pool(self.cores)\n df = pd.DataFrame(self.input)\n solution = p.map(simulate_one, self.input) # create a pool of workers and map it onto different cores\n solutions = pd.DataFrame(solution)\n p.close() # prevent memory leakage \n p.join() # synchronization point\n\n result = pd.concat([df, solutions], axis=1)\n result.columns = ['CSCS', 'e_field']\n\n # make phase continuous\n # new_p = unwrap(p_list)\n\n return result\n \n\n \n \n\n class Simulation:\n \"\"\"A simulation object\"\"\"\n \n def __init__(self):\n self.layers = []\n self.basis = ((1,0),(0,1))\n self.NumBasis=150\n self.layers = None\n self.layer_material = None\n self.layer_thickness = None\n self.layer_pattern = None\n self.transmission = None\n self.wavelength = None\n self.buffer = 0.1\n self.Nxy = 52\n \n \n def load_input(self,input_instance):\n \"\"\"loades the canonical id into local variables\"\"\"\n \n \n # the first step is to assign values to the variables from the input_instance\n parts = input_instance.split('/')\n first_arg = parts[0].split('-')\n if first_arg[0] == 't':\n self.transmission = True\n elif first_arg[0] == 'r':\n self.transmission = False\n \n self.wavelength = float(first_arg[1])\n self.basis = eval(first_arg[2])\n \n self.layers = parts[1:]\n layers_split = [layer.split('=') for layer in self.layers]\n self.layer_material = [layer_split[0] for layer_split in layers_split]\n split_2 = [layer_split[1] for layer_split in layers_split]\n self.layer_thickness = []\n self.layer_pattern = []\n for x in split_2:\n x_split = x.split(':')\n if len(x_split) == 1:\n self.layer_thickness.append(float(x_split[0]))\n self.layer_pattern.append(None)\n else:\n self.layer_thickness.append(float(x_split[0]))\n self.layer_pattern.append(x_split[1].split('-'))\n \n \n\n \n def run(self):\n \"\"\"create layers and return a S4 object\n :type attr: dict\n return S\n \"\"\"\n def querry_n(material, wavelength):\n \"\"\"\n given the material in string, wavelength in µm\n output (n,k)\n \"\"\"\n mat = pd.read_csv('../rcwa/n_data/{}_n.csv'.format(material))\n\n w = mat['Wavelength, µm']\n n_list = mat['n']\n k_list = mat['k']\n\n n = np.interp(wavelength, w, n_list) # interpolate the refractive index value\n k = np.interp(wavelength, w, k_list) # interpolate the k value\n\n return n + k*1j \n\n # define the S object\n S = S4.New(Lattice=self.basis,\n NumBasis=self.NumBasis) # orthogonal basis, numbasis scales with memory O(N^2)\n\n # define materials\n for material in set(self.layer_material):\n n = querry_n(material,self.wavelength)\n # defines permittivity in terms of refractive index\n eps = n**2\n S.SetMaterial(Name=material, Epsilon=eps)\n S.SetMaterial(Name='Vacuum', Epsilon=1.0)\n\n # define layers\n S.AddLayer(Name='air_above', Thickness=self.buffer, Material='Vacuum')\n index = 0\n for layer in zip(self.layer_material, self.layer_thickness, self.layer_pattern):\n index += 1\n if layer[2] == None:\n S.AddLayer(Name=str(index), Thickness=layer[1], Material=layer[0])\n else:\n S.AddLayer(Name=str(index), Thickness=layer[1], Material='Vacuum')\n if '+' in layer[2]:\n patterns = layer[2].split('+')\n else:\n patterns = layer[2]\n for pattern in patterns:\n shape = pattern[0]\n coor = eval(pattern[1:])\n if shape == 'C':\n # create circle features\n if coor[2] != 0:\n S.SetRegionCircle(\n Layer = str(index),\n Material = layer[0],\n Center = (coor[0],coor[1]),\n Radius = coor[2]\n )\n elif shape == 'S':\n # create circle features\n if coor[2] != 0:\n S.SetRegionSquare(\n Layer = str(index),\n Material = layer[0],\n Center = (coor[0],coor[1]),\n Angle = 0,\n Halfwidths = (coor[2], coor[2])\n \n )\n \n S.AddLayer(Name='below', Thickness=self.buffer, Material='Vacuum')\n\n\n # simulation settings\n S.SetExcitationPlanewave(IncidenceAngles=(0.0, 0.0), sAmplitude=0.0,\n pAmplitude=1.0, Order=0)\n\n S.SetFrequency(1/self.wavelength)\n\n # For higher accuracy\n S.SetOptions(SubpixelSmoothing=True)\n \n # e is array of dimension Nx by Ny, each element is a tuple of length 3\n \n if not self.transmission:\n z_pos = self.buffer/(2.0)\n else:\n z_pos = self.buffer*1.5+sum(self.layer_thickness)\n \n e, h = S.GetFieldsOnGrid(z=z_pos, NumSamples=(self.Nxy, self.Nxy),\n Format='Array') \n e = np.array(e)\n if not self.transmission:\n e = e - np.exp(1j*2*np.pi/self.wavelength*self.buffer/2)\n \n if FIELD==None:\n e_field = np.mean(e[:,:,0]) # adding 1 removes incident wave \n else: \n (a,b,_) = np.shape(e)\n edge = (1-FIELD)/2.0\n e_field = e[int(a*edge):int(a*(1-edge)),int(b*edge):int(b*(1-edge)),0]\n \n e_field = np.round(e_field, 3)\n \n return pd.Series(str(e_field.tolist()))\n", "meta": {"hexsha": "0296e0b41c6d377cfb7f18ec7aa337fa255b82fe", "size": 9957, "ext": "py", "lang": "Python", "max_stars_repo_path": "rcwa/RCWA.py", "max_stars_repo_name": "Luochenghuang/shared_lib", "max_stars_repo_head_hexsha": "47197a271dd87fb3b6776a8996dc92019d6f439a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "rcwa/RCWA.py", "max_issues_repo_name": "Luochenghuang/shared_lib", "max_issues_repo_head_hexsha": "47197a271dd87fb3b6776a8996dc92019d6f439a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2018-11-10T23:32:31.000Z", "max_issues_repo_issues_event_max_datetime": "2018-11-10T23:32:31.000Z", "max_forks_repo_path": "rcwa/RCWA.py", "max_forks_repo_name": "Luochenghuang/shared_lib", "max_forks_repo_head_hexsha": "47197a271dd87fb3b6776a8996dc92019d6f439a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2018-11-07T21:41:07.000Z", "max_forks_repo_forks_event_max_datetime": "2018-11-07T21:41:07.000Z", "avg_line_length": 32.5392156863, "max_line_length": 110, "alphanum_fraction": 0.4794616852, "include": true, "reason": "import numpy", "num_tokens": 2166, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5389832206876841, "lm_q2_score": 0.3593641588823761, "lm_q1q2_score": 0.1936912517541437}} {"text": "\"\"\"Model of somatostatin brain extracellular release, diffusion, and loss.\r\n\"\"\"\r\n\r\nfrom neuron import h, rxd\r\nfrom neuron.units import nM, uM, cm, s, M, nm, um\r\nimport numpy as np\r\n\r\n# Avogadro's Number from scipy\r\nfrom scipy.constants import N_A\r\nfrom .basemodel import ModelBase\r\n\r\n\r\nclass Model(ModelBase):\r\n \"\"\"A model of somatostatin release, diffusion, and loss in the brain extracellular space.\r\n\r\n This model simulates the photorelease of the neuropeptide somatostatin from\r\n gold coated nanovesicles and its subsequent diffusion in the brain\r\n extracellular space. An initial cylindrical bolus of somatostatin is placed in\r\n the center of the extracellular domain to approximate the condition after\r\n photorelease from gold coated nanovesicles with release stimulated by a\r\n tornado scan of radius 30 micron with a multi-photon microscope. Somatostatin\r\n can then diffuse away from the release site and can be lost from the\r\n extracellular space through a first order decay reaction.\r\n\r\n Model components (accessible as model attributes):\r\n\r\n Compartments:\r\n ecs -> rxd.Extracellular: The extracellular space domain and its\r\n parameters like volume fraction and tortuosity.\r\n Species:\r\n sst -> rxd.Species: Neuropeptide somatostatin (sst) that is\r\n photoreleased in the brain extracellular space.\r\n Parameters:\r\n loss_rate -> rxd.Parameter: Defines the kinetic rate for first order\r\n loss of sst from the extracellular space.\r\n Reactions:\r\n sst_loss -> rxd.Rate: The reaction corresponding to first order loss\r\n of sst from the extracellular space.\r\n Forward reaction: sst --loss_rate--> None\r\n\r\n \"\"\"\r\n\r\n def __init__(\r\n self,\r\n volume_fraction: float = 0.2,\r\n tortuosity: float = 1.0,\r\n dx: float = 5,\r\n xlo: float = -200.0,\r\n xhi: float = 200.0,\r\n ylo: float = -200.0,\r\n yhi: float = 200.0,\r\n zlo: float = -200.0,\r\n zhi: float = 200.0,\r\n ):\r\n \"\"\"Defines and constructs all the model components.\r\n\r\n Args:\r\n volume_fraction: The volume fraction of extracellular space\r\n (unitless). DEFAULT: 0.2\r\n tortuosity: The tortuosity for diffusion in the extracellular space\r\n (unitless). DEFAULT: 1.\r\n dx: The discrettization size for volume voxels in the extracellular\r\n space in microns. DEFAUT: 5\r\n xlo: The position of the lower edge of the extracellular simulation\r\n domain along the x-direction in microns. DEFAULT: -200.\r\n xhi: The position of the upper edge of the extracellular simulation\r\n domain along the x-direction in microns. DEFAULT: 200.\r\n ylo: The position of the lower edge of the extracellular simulation\r\n domain along the y-direction in microns. DEFAULT: -200.\r\n yhi: The position of the upper edge of the extracellular simulation\r\n domain along the y-direction in microns. DEFAULT: 200.\r\n zlo: The position of the lower edge of the extracellular simulation\r\n domain along the z-direction in microns. DEFAULT: -200.\r\n zhi: The position of the upper edge of the extracellular simulation\r\n domain along the z-direction in microns. DEFAULT: 200.\r\n \"\"\"\r\n # Where? -- specify the regions\r\n # For extracellular reaction-diffusion we just have one\r\n # Extracellular region.\r\n self.ecs = rxd.Extracellular(\r\n xlo=xlo,\r\n ylo=ylo,\r\n zlo=zlo,\r\n xhi=xhi,\r\n yhi=yhi,\r\n zhi=zhi,\r\n dx=dx,\r\n volume_fraction=volume_fraction,\r\n tortuosity=tortuosity,\r\n )\r\n # Who? -- define all the species\r\n # Calcein\r\n # The effective diffusion coefficient for fluorescently labelled SST\r\n # in acute brain slices from integrative optical imaging (IOI) is\r\n # 8.9+-1.3 x10^-7 cm^2/s. Xiong et al. 2021 bioRxiv https://doi.org/10.1101/2021.09.10.459853\r\n d_sst = (\r\n 8.9e-7 * cm ** 2 / s\r\n ) # effective diffusion coefficient (factoring in tortuosity)\r\n # Approximate SST photorelease from gold coated nanovesicles as in\r\n # Xiong et al. 2021 bioRxiv https://doi.org/10.1101/2021.09.10.459853\r\n # Use an initial bolus of SST with a uniform concentration corresponding\r\n # to the estimated 1.2x10^8 released molecs inside a disc that\r\n # approximates the two-photon tornado scan area used for nanovesicle\r\n # release.\r\n r_stim = 30 * um # radius of the tornado scan area\r\n Qsst = 1.2e8 # Number of SST molecules released during photostimulation\r\n focal_disc_z = 12 # z-height of the 2-photon focal plane\r\n disc_vol = (\r\n np.pi * r_stim ** 2 * focal_disc_z\r\n ) # volume of the tornado scan area.\r\n # SST concentration accounting for the disc volume and volume faction.\r\n sst_0 = ((Qsst / N_A) / disc_vol) / volume_fraction * 1e15 * M\r\n self.sst = rxd.Species(\r\n self.ecs,\r\n name=\"somatostatin\",\r\n d=d_sst,\r\n charge=0,\r\n initial=lambda nd: sst_0\r\n if (nd.x3d ** 2 + nd.y3d ** 2 < r_stim ** 2)\r\n and (np.abs(nd.z3d) < focal_disc_z / 2)\r\n else 0,\r\n ecs_boundary_conditions=0.0,\r\n )\r\n # What? -- specify all the reactions\r\n # 1st-order loss of SST\r\n # Loss rate of SST estimated in range 0.023-0.048 per second.\r\n # Xiong et al. 2021 bioRxiv https://doi.org/10.1101/2021.09.10.459853\r\n kf = 3.6e-2 / s # the reaction rate\r\n self.loss_rate = rxd.Parameter(self.ecs, value=kf)\r\n self.sst_loss = rxd.Rate(self.sst, -self.loss_rate * self.sst)\r\n\r\n # Initialize private variables -- required for all models\r\n self._times = None # We'll store the time points in our simulation trajectory.\r\n self._observables = None # We'll assign our observables to this variable.\r\n\r\n def simulate(self, time_step: float, n_steps: int, output_frequency: int = 1):\r\n \"\"\"Run the simulation and set the desired trajectory ouptuts.\r\n\r\n Args:\r\n time_step: The time interval between each step of the simulation\r\n trajectory in milliseconds. Times not in milliseconds can\r\n be converted using unit conversions from the neuron.units\r\n module.\r\n n_steps: The total number of simulation steps to run.\r\n output_frequency: Set the frequency for computing and storing\r\n any observables during the simulation. DEFAULT: 1\r\n\r\n \"\"\"\r\n # Set the time step and initialize the simulator.\r\n h.dt = time_step\r\n h.finitialize()\r\n # define any observables that you want to store\r\n times = list()\r\n sst_zproject_mean = list()\r\n # Run each step.\r\n for f in range(n_steps + 1):\r\n if (f == 0) or ((f % output_frequency) == 0):\r\n # simulation time\r\n times.append(f * time_step)\r\n # Get the mean value z-projection of the Calcein concentration.\r\n sst_zproject_mean.append(self.sst[self.ecs].states3d.mean(2))\r\n h.fadvance()\r\n self._times = np.array(times)\r\n self._observables = {\"zproject_mean_sst\": sst_zproject_mean}\r\n return\r\n\r\n\r\nmodel = Model()\r\n", "meta": {"hexsha": "9ba22e365628186e39b3b3fabdaefaecd9460490", "size": 7655, "ext": "py", "lang": "Python", "max_stars_repo_path": "extmodels/somatostatin.py", "max_stars_repo_name": "NTBEL/extracellular-models", "max_stars_repo_head_hexsha": "b69493a331aca735f419440f21809807075f596a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "extmodels/somatostatin.py", "max_issues_repo_name": "NTBEL/extracellular-models", "max_issues_repo_head_hexsha": "b69493a331aca735f419440f21809807075f596a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "extmodels/somatostatin.py", "max_forks_repo_name": "NTBEL/extracellular-models", "max_forks_repo_head_hexsha": "b69493a331aca735f419440f21809807075f596a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 45.2958579882, "max_line_length": 102, "alphanum_fraction": 0.6094056172, "include": true, "reason": "import numpy,from scipy", "num_tokens": 1823, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5389832206876841, "lm_q2_score": 0.359364131437828, "lm_q1q2_score": 0.19369123696199278}} {"text": "import os\nimport sys\nfrom functools import lru_cache, wraps\n\nimport astropy.units as astropy_units\nimport numpy as np\nimport six\nfrom astropy.io import fits\n\nfrom astromodels.functions.function import Function1D, FunctionMeta\nfrom astromodels.utils import configuration\nfrom astromodels.utils import _get_data_file_path\nimport gc\n\ntry:\n\n import pyatomdb\n\n has_atomdb = True\n\nexcept:\n\n has_atomdb = False\n\nif has_atomdb:\n # APEC class\n \n class APEC(Function1D, metaclass=FunctionMeta):\n r\"\"\"\n description :\n The Astrophysical Plasma Emission Code (APEC, Smith et al. 2001)\n contributed by Dominique Eckert\n parameters :\n K :\n desc : Normalization in units of 1e-14/(4*pi*(1+z)^2*dA*2)*EM\n initial value : 1.0\n is_normalization : True\n transformation : log10\n min : 1e-30\n max : 1e3\n delta : 0.1\n kT :\n desc : Plasma temperature\n initial value : 1.0\n min : 0.08\n max : 64\n delta : 0.1\n abund :\n desc : Metal abundance\n initial value : 1\n min : 0.0\n max : 5.0\n delta : 0.01\n fix : yes\n redshift :\n desc : Source redshift\n initial value : 0.1\n min : 0.0\n max : 10.0\n delta : 1e-3\n fix : yes\n\n \"\"\"\n\n def _set_units(self, x_unit, y_unit):\n self.kT.unit = astropy_units.keV\n\n self.abund.unit = astropy_units.dimensionless_unscaled\n\n self.redshift.unit = astropy_units.dimensionless_unscaled\n\n self.K.unit = y_unit\n\n def init_session(self, abund_table=\"AG89\"):\n # initialize PyAtomDB session\n self.session = pyatomdb.spectrum.CIESession(abundset=abund_table)\n\n def clean(self):\n \"\"\"\n Clean the current APEC session to avoid having too many open files\n :returns: \n \"\"\"\n \n self.session = None\n del self.session\n gc.collect()\n\n def evaluate(self, x, K, kT, abund, redshift):\n assert self.session is not None, \"please run init_session(abund)\"\n\n sess = self.session\n\n nval = len(x)\n\n xz = x * (1.0 + redshift)\n\n ebplus = (np.roll(xz, -1) + xz)[: nval - 1] / 2.0\n\n ebounds = np.empty(nval + 1)\n\n ebounds[1:nval] = ebplus\n\n ebounds[0] = xz[0] - (ebplus[0] - xz[0])\n\n ebounds[nval] = xz[nval - 1] + (xz[nval - 1] - ebplus[nval - 2])\n\n binsize = (np.roll(ebounds, -1) - ebounds)[:nval]\n\n sess.set_response(ebounds, raw=True)\n\n sess.set_abund(\n [\n 6,\n 7,\n 8,\n 9,\n 10,\n 11,\n 12,\n 13,\n 14,\n 16,\n 17,\n 18,\n 19,\n 20,\n 21,\n 22,\n 23,\n 24,\n 25,\n 26,\n 27,\n 28,\n 29,\n 30,\n ],\n abund,\n )\n\n spec = sess.return_spectrum(kT) / binsize / 1e-14\n\n return K * spec\n\n # VAPEC class\n \n class VAPEC(Function1D, metaclass=FunctionMeta):\n r\"\"\"\n description :\n The Astrophysical Plasma Emission Code (APEC, Smith et al. 2001), variable abundances for individual elements\n contributed by Dominique Eckert\n parameters :\n K :\n desc : Normalization in units of 1e-14/(4*pi*(1+z)^2*dA*2)*EM\n initial value : 1.0\n is_normalization : True\n transformation : log10\n min : 1e-30\n max : 1e3\n delta : 0.1\n kT :\n desc : Plasma temperature\n initial value : 1.0\n min : 0.08\n max : 64\n delta : 0.1\n Fe :\n desc : Fe abundance\n initial value : 1\n min : 0.0\n max : 5.0\n delta : 0.01\n fix : yes\n C :\n desc : C abundance\n initial value : 1\n min : 0.0\n max : 5.0\n delta : 0.01\n fix : yes\n N :\n desc : N abundance\n initial value : 1\n min : 0.0\n max : 5.0\n delta : 0.01\n fix : yes\n O :\n desc : O abundance\n initial value : 1\n min : 0.0\n max : 5.0\n delta : 0.01\n fix : yes\n Ne :\n desc : Ne abundance\n initial value : 1\n min : 0.0\n max : 5.0\n delta : 0.01\n fix : yes\n Mg :\n desc : Mg abundance\n initial value : 1\n min : 0.0\n max : 5.0\n delta : 0.01\n fix : yes\n Al :\n desc : Al abundance\n initial value : 1\n min : 0.0\n max : 5.0\n delta : 0.01\n fix : yes\n Si :\n desc : Si abundance\n initial value : 1\n min : 0.0\n max : 5.0\n delta : 0.01\n fix : yes\n S :\n desc : S abundance\n initial value : 1\n min : 0.0\n max : 5.0\n delta : 0.01\n fix : yes\n Ar :\n desc : Ar abundance\n initial value : 1\n min : 0.0\n max : 5.0\n delta : 0.01\n fix : yes\n Ca :\n desc : Ca abundance\n initial value : 1\n min : 0.0\n max : 5.0\n delta : 0.01\n fix : yes\n Ni :\n desc : Ni abundance\n initial value : 1\n min : 0.0\n max : 5.0\n delta : 0.01\n fix : yes\n redshift :\n desc : Source redshift\n initial value : 0.1\n min : 0.0\n max : 10.0\n delta : 1e-3\n fix : yes\n\n \"\"\"\n\n def _set_units(self, x_unit, y_unit):\n self.kT.unit = astropy_units.keV\n\n self.Fe.unit = astropy_units.dimensionless_unscaled\n\n self.C.unit = astropy_units.dimensionless_unscaled\n\n self.N.unit = astropy_units.dimensionless_unscaled\n\n self.O.unit = astropy_units.dimensionless_unscaled\n\n self.Ne.unit = astropy_units.dimensionless_unscaled\n\n self.Mg.unit = astropy_units.dimensionless_unscaled\n\n self.Al.unit = astropy_units.dimensionless_unscaled\n\n self.Si.unit = astropy_units.dimensionless_unscaled\n\n self.Ar.unit = astropy_units.dimensionless_unscaled\n\n self.Ca.unit = astropy_units.dimensionless_unscaled\n\n self.Ni.unit = astropy_units.dimensionless_unscaled\n\n self.redshift.unit = astropy_units.dimensionless_unscaled\n\n self.K.unit = y_unit\n\n def init_session(self, abund_table=\"AG89\"):\n # initialize PyAtomDB session\n self.session = pyatomdb.spectrum.CIESession(abundset=abund_table)\n\n def clean(self):\n \"\"\"\n Clean the current APEC session to avoid having too many open files\n :returns: \n \"\"\"\n \n self.session = None\n del self.session\n gc.collect()\n\n def evaluate(\n self, x, K, kT, Fe, C, N, O, Ne, Mg, Al, Si, S, Ar, Ca, Ni, redshift\n ):\n assert self.session is not None, \"please run init_session(abund)\"\n\n sess = self.session\n\n nval = len(x)\n\n xz = x * (1.0 + redshift)\n\n ebplus = (np.roll(xz, -1) + xz)[: nval - 1] / 2.0\n\n ebounds = np.empty(nval + 1)\n\n ebounds[1:nval] = ebplus\n\n ebounds[0] = xz[0] - (ebplus[0] - xz[0])\n\n ebounds[nval] = xz[nval - 1] + (xz[nval - 1] - ebplus[nval - 2])\n\n binsize = (np.roll(ebounds, -1) - ebounds)[:nval]\n\n sess.set_response(ebounds, raw=True)\n\n sess.set_abund(\n [6, ], C,\n )\n\n sess.set_abund(\n [7, ], N,\n )\n\n sess.set_abund(\n [8, ], O,\n )\n\n sess.set_abund(\n [10, ], Ne,\n )\n\n sess.set_abund(\n [12, ], Mg,\n )\n\n sess.set_abund(\n [13, ], Al,\n )\n\n sess.set_abund(\n [14, ], Si,\n )\n\n sess.set_abund(\n [16, ], S,\n )\n\n sess.set_abund(\n [18, ], Ar,\n )\n\n sess.set_abund(\n [20, ], Ca,\n )\n\n sess.set_abund(\n [26, ], Fe,\n )\n\n sess.set_abund(\n [28, ], Ni,\n )\n\n sess.set_abund(\n [9, 11, 15, 17, 19, 21, 22, 23, 24, 25, 27, 29, 30], Fe\n ) # Remaining elements are set to Fe\n\n spec = sess.return_spectrum(kT) / binsize / 1e-14\n\n return K * spec\n\n\n", "meta": {"hexsha": "467579f35767c68cc6733a68b57904b3495b49e8", "size": 10065, "ext": "py", "lang": "Python", "max_stars_repo_path": "astromodels/functions/functions_1D/apec.py", "max_stars_repo_name": "rwiller/astromodels", "max_stars_repo_head_hexsha": "0d222fe88f2b72fbc23675ee5309dde649d1b4b9", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 12, "max_stars_repo_stars_event_min_datetime": "2019-03-07T09:45:35.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-13T14:05:07.000Z", "max_issues_repo_path": "astromodels/functions/functions_1D/apec.py", "max_issues_repo_name": "rwiller/astromodels", "max_issues_repo_head_hexsha": "0d222fe88f2b72fbc23675ee5309dde649d1b4b9", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 83, "max_issues_repo_issues_event_min_datetime": "2019-01-27T18:57:51.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-28T12:57:26.000Z", "max_forks_repo_path": "astromodels/functions/functions_1D/apec.py", "max_forks_repo_name": "rwiller/astromodels", "max_forks_repo_head_hexsha": "0d222fe88f2b72fbc23675ee5309dde649d1b4b9", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 25, "max_forks_repo_forks_event_min_datetime": "2019-01-10T09:02:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-23T03:52:36.000Z", "avg_line_length": 26.0751295337, "max_line_length": 121, "alphanum_fraction": 0.4101341282, "include": true, "reason": "import numpy,import astropy,from astropy", "num_tokens": 2411, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6370308082623217, "lm_q2_score": 0.30404168757891037, "lm_q1q2_score": 0.19368392198383358}} {"text": "# -*- coding: utf8 -*-\nimport numpy as np\nimport pickle\nimport Tree\n\n\nclass RAE(object):\n \"\"\"Class to use Recursive Neural Network on Tree\n\n Usage\n -----\n\n\n Methods\n -------\n\n \"\"\"\n def __init__(self, vocab={}, dim=30, r=0.0001, reg=1):\n self.dim = dim\n\n #Initiate V, the tensor operator\n self.V = np.random.uniform(-r, r, size=(dim+1, 2*dim+2, 2*dim+2))\n self.V = (self.V+np.transpose(self.V, axes=[0, 2, 1]))/2\n\n #Initiate W, the linear operator\n self.W = np.random.uniform(-r, r, size=(dim+1, 2*dim+2))\n\n #Initiate Ws, the linear operator\n self.Ws = np.random.uniform(-r, r, size=(2, dim+1))\n\n #Initiate VE, the encoder tensor\n self.Ve = np.random.uniform(-r, r, size=(2*dim+2, dim+1, dim+1))\n self.Ve = (self.Ve+np.transpose(self.Ve, axes=[0, 2, 1]))/2\n\n #Initiate VE, the encoder tensor\n self.We = np.random.uniform(-r, r, size=(2*dim+2, dim+1))\n\n #Initiate L, the Lexicon representation\n self.L = np.random.uniform(-r, r, size=(len(vocab), dim))\n\n #Parameter holder\n self.params = {}\n self.params['V'] = self.V\n self.params['W'] = self.W\n self.params['Ws'] = self.Ws\n self.params['L'] = self.L\n self.params['Ve'] = self.Ve\n self.params['We'] = self.We\n\n #Regularisation\n self.reg = {'V': 0.001*reg, 'W': 0.001*reg, 'Ws': 0.0001*reg, 'L': 0.0001*reg,\n 'We': reg*0.0001, 'Ve': reg*0.0001}\n\n self.vocab = {}\n self.index = {}\n for i, w in enumerate(vocab):\n self.vocab[w] = i\n self.index[i] = w\n\n self.f = lambda X: np.tanh(X.T.dot(self.V).dot(X) + self.W.dot(X))\n self.grad = lambda f: 1-f**2\n self.dec = lambda X: np.tanh(X.T.dot(self.Ve).dot(X) + self.We.dot(X))\n\n self.y = lambda X: np.exp(self.Ws.dot(X).clip(-500, 700)) \\\n / sum(np.exp(self.Ws.dot(X).clip(-500, 700)))\n\n self.norm = lambda X: np.sum(X*X)\n\n def save(self, saveFile):\n with open(saveFile, 'wb') as output:\n pickle.dump(self.dim, output, -1)\n pickle.dump(self.vocab, output, -1)\n for k in self.params.keys():\n pickle.dump(self.params[k], output, -1)\n for k in self.params.keys():\n pickle.dump(self.reg[k], output, -1)\n\n def load(self, loadFile):\n with open(loadFile, 'rb') as input:\n self.dim = pickle.load(input)\n self.vocab = pickle.load(input)\n for k in self.params.keys():\n self.params[k] = pickle.load(input)\n for k in self.params.keys():\n self.reg[k] = pickle.load(input)\n\n def error(self, val_set):\n '''\n Calcule l'erreur moyenne sur le set val_set avec les parametres actuel\n '''\n errorVal = 0.0\n for X_tree in val_set:\n errorVal += self.forward_pass(X_tree)\n return errorVal/len(val_set)\n\n def forward_pass(self, X_tree):\n '''\n Effectue la passe forward et calcule l'erreur actuelle pour l'arbre X_tree\n '''\n errorVal = 0.0\n for n in X_tree.leaf:\n # Met a jour le mot avec le Lexicon courant\n n.X = np.append(self.L[self.vocab[n.word]], 0)\n n.ypred = self.y(n.X) # Mise a jour du label predit\n n.ypred += 1e-300*(n.ypred == 0)\n assert (n.ypred != 0).all()\n errorVal += -np.sum(n.y*np.log(n.ypred))\n\n for p, [a, b] in X_tree.parcours:\n aT = X_tree.nodes[a] #\n bT = X_tree.nodes[b] # Recupere pour chaque triplet parent,enfant1/2 les noeuds\n pT = X_tree.nodes[p]\n if aT.order < bT.order:\n X = np.append(aT.X, bT.X)\n else:\n X = np.append(bT.X, aT.X)\n pT.X = self.f(X) # Mise a jour du decripteur du parent\n pT.X[-1] = 1\n\n pT.ypred = self.y(pT.X) # Mise a jour du label predit\n pT.ypred += 1e-300*(pT.ypred == 0)\n errorVal += -np.sum(pT.y*np.log(pT.ypred))\n pT.c = pT.X\n for p, [a, b] in X_tree.parcours[::-1]:\n aT = X_tree.nodes[a] #\n bT = X_tree.nodes[b] # Recupere pour chaque triplet parent,enfant1/2 les noeuds\n pT = X_tree.nodes[p]\n C = self.dec(pT.c)\n #Propagation des erreurs vers le bas\n if aT.order < bT.order: # Si aT est le noeud de gauche\n aT.c = C[:self.dim+1]\n bT.c = C[self.dim+1:]\n else: # aT est a droite\n bT.c = C[:self.dim+1]\n aT.c = C[self.dim+1:]\n\n nn = len(X_tree.nodes)\n for n in X_tree.nodes:\n errorVal += np.sum((n.c-n.X)**2) / nn\n #E = sum([(self.y(n.X) - n.y) for n in X_tree.nodes])\n #print E\n #return self.Ws.dot(pT.X) -> Pas besoin de retourner le lbel, il faut le maj aussi?\n return errorVal\n\n def backward_pass(self, X_tree, w_root=1):\n '''\n Retourne le gradient du a l'erreur commise sur l'arbre X_tree\n Attention: suppose la forward_pass faite\n '''\n #Initialise les gradients\n grad = {}\n for k in self.params.keys():\n grad[k] = np.zeros(self.params[k].shape)\n\n #Initialise les deltas\n for n in X_tree.nodes:\n gX = self.grad(n.X)\n gC = self.grad(n.c)\n n.d = self.Ws.T.dot(n.ypred-n.y)*gX*w_root - 2*(n.c-n.X)*gX\n n.dr = 2*(n.c-n.X)*gC\n\n n.d += self.Ws.T.dot(n.ypred-n.y)*gX*(1-w_root)\n\n err_rec = 0\n\n for p, [a, b] in X_tree.parcours:\n aT = X_tree.nodes[a] #\n bT = X_tree.nodes[b] # Recupere pour chaque triplet parent,enfant1/2 les noeuds\n pT = X_tree.nodes[p]\n if aT.order < bT.order:\n dR = np.append(aT.dr, bT.dr)\n else:\n dR = np.append(bT.dr, aT.dr)\n pT.dr += dR.dot(self.We) + 2*dR.dot(self.Ve.dot(pT.X))\n grad['We'] += np.outer(dR, pT.X)\n grad['Ve'] += np.tensordot(dR, np.outer(pT.X, pT.X), axes=0)\n\n #Descend dans l arbre\n for p, [a, b] in X_tree.parcours[::-1]:\n aT = X_tree.nodes[a] #\n bT = X_tree.nodes[b] # Recupere pour chaque triplet parent,enfant1/2 les noeuds\n pT = X_tree.nodes[p]\n #Propagation des erreurs vers le bas\n if aT.order < bT.order: # Si aT est le noeud de gauche\n X = np.append(aT.X, bT.X)\n ddown = (self.W.T.dot(pT.d+pT.dr)+2*(pT.d+pT.dr).dot(self.V.dot(X)))\n aT.d += ddown[:self.dim+1]\n bT.d += ddown[self.dim+1:]\n else: # aT est a droite\n X = np.append(bT.X, aT.X)\n ddown = (self.W.T.dot(pT.d+pT.dr)+2*(pT.d+pT.dr).dot(self.V.dot(X)))\n aT.d += ddown[self.dim+1:]\n bT.d += ddown[:self.dim+1]\n err_rec += np.sum((aT.c-aT.X)**2)\n err_rec += np.sum((bT.c-bT.X)**2)\n #Contribution aux gradients du pT\n grad['Ws'] += np.outer(pT.ypred-pT.y, pT.X)\n grad['V'] += np.tensordot(pT.d + pT.dr, np.outer(X, X), axes=0)\n grad['W'] += np.outer(pT.d + pT.dr, X)\n\n #Contribution des feuilles\n for n in X_tree.leaf:\n grad['L'][self.vocab[n.word]] += n.d[:-1] + n.dr[:-1]\n grad['Ws'] += np.outer(n.ypred-n.y, n.X)\n\n return grad\n\n def train(self, X_trees, learning_rate=0.01, mini_batch_size=27,\n warm_start=True, r=0.0001, max_iter=1000, val_set=[],\n n_check=100, strat='AdaGrad', w_root=1,\n bin=False, reset_freq=-1, save_tmp='tmp.pkl', n_stop=4):\n '''\n Training avec AdaGrad (Dutchi et al.), prends en entrée une liste d'arbres X_trees\n '''\n #Remise à zero du modele\n if not warm_start:\n dim = self.dim\n #Initiate V, the tensor operator\n self.params['V'] = np.random.uniform(-r, r, size=(dim+1, 2*dim+2, 2*dim+2))\n self.params['V'] = (self.V+np.transpose(self.V, axes=[0, 2, 1]))/2\n\n #Initiate W, the linear operator\n self.params['W'] = np.random.uniform(-r, r, size=(dim+1, 2*dim+2))\n\n #Initiate Ws, the linear operator\n self.params['Ws'] = np.random.uniform(-r, r, size=(2, dim+1))\n\n #Initiate VE, the encoder tensor\n self.Ve = np.random.uniform(-r, r, size=(2*dim+2, dim+1, dim+1))\n self.Ve = (self.Ve+np.transpose(self.Ve, axes=[0, 2, 1]))/2\n\n #Initiate VE, the encoder tensor\n self.We = np.random.uniform(-r, r, size=(2*dim+2, dim+1))\n\n #Initiate L, the Lexicon representation\n self.params['L'] = np.random.uniform(-r, r, size=(len(self.vocab), dim))\n\n #Liste pour erreurs\n self.errMB = []\n self.errVal = []\n errMB = self.errMB\n errVal = self.errVal\n\n #Condition d'arret\n n_iter = 1\n gradNorm = 1.0\n if val_set != []:\n prevError = self.error(val_set) / len(val_set)\n for k in self.params.keys():\n prevError += self.reg[k]*self.norm(self.params[k])/2.0\n iniError = prevError\n minError = prevError # optimal error so far\n glError = 0\n upStop = 0\n errVal.append(prevError)\n\n # Normalisation pour AdaGrad/Rms-prop\n eta = learning_rate\n dHist = {}\n dMask = {}\n dPrev = {}\n for k in self.params.keys():\n sh = self.params[k].shape\n dHist[k] = np.zeros(sh)\n dMask[k] = np.ones(sh)\n dPrev[k] = np.zeros(sh)\n\n early_stop = False\n while (not early_stop) and n_iter < max_iter: # Critere moins random\n if n_iter % reset_freq == 0 and reset_freq > 0: # Remise a zero des rates cf Socher\n for k in self.params.keys():\n dHist[k] = np.zeros(self.params[k].shape)\n\n #Choose mini batch randomly\n mini_batch_samples = np.random.choice(X_trees, size=mini_batch_size)\n\n #Initialize gradients to 0\n dCurrent = {}\n for k in self.params.keys():\n dCurrent[k] = np.zeros(self.params[k].shape)\n\n #Mini batch pour gradient\n currentMbe = 0.0\n for X_tree in mini_batch_samples:\n currentMbe += self.forward_pass(X_tree)\n grad = self.backward_pass(X_tree, w_root=w_root)\n for k in self.params.keys():\n dCurrent[k] += grad[k]\n\n currentMbe /= mini_batch_size\n for k in self.params.keys():\n currentMbe += self.reg[k]*self.norm(self.params[k])/2.0\n\n #Division par le nombre de sample + regularisation\n for k in self.params.keys():\n dCurrent[k] = dCurrent[k]/mini_batch_size + self.reg[k]*self.params[k]\n\n #Mise a jour des poids et calcul des pas\n if strat == 'AdaGrad':\n eps = 0.001 # Adagrad >0 ? cf Socher\n for k in self.params.keys():\n dHist[k] += dCurrent[k]*dCurrent[k]\n dCurrent[k] = eta*dCurrent[k]/np.sqrt(dHist[k]+eps)\n else:\n eps = 0.001\n for k in self.params.keys():\n dHist[k] = 0.9*dHist[k] + 0.1*dCurrent[k]*dCurrent[k]\n dMask[k] *= .7*(dPrev[k]*dCurrent[k] >= 0) + .5\n dCurrent[k] = eta*dMask[k].clip(1e-6, 50, out=dMask[k]) *\\\n dCurrent[k]/np.sqrt(dHist[k]+eps)\n\n #Calcul de la norme du gradient (critere d'arret)\n gradNorm = 0\n for k in self.params.keys():\n gradNorm += np.sum(np.abs(dCurrent[k]))\n\n #Keep previous gradient\n for k in self.params.keys():\n dPrev[k] = dCurrent[k]\n\n #Descente\n for k in self.params.keys():\n self.params[k] -= dCurrent[k]\n\n #Maj de la condition d'arret\n if val_set != [] and (n_iter % n_check) == 0:\n currentError = self.error(val_set)\n for k in self.params.keys():\n currentError += self.reg[k]*self.norm(self.params[k])/2.0\n\n errVal.append(currentError)\n errMB.append(currentMbe)\n print('Error on validation set at iter {0} : {1} '\n '(previous : {2})'.format(n_iter, currentError, prevError))\n print('Error on mini batch at iter {0} : {1} '\n '(Gradient norm : {2})'.format(n_iter, currentMbe, gradNorm))\n\n with open(save_tmp, 'wb') as output:\n pickle.dump(errVal, output, -1)\n pickle.dump(errMB, output, -1)\n\n #Early stopping\n minError = min(minError, currentError)\n glError = 100*((currentError/minError)-1.0)\n if currentError > prevError:\n upStop += 1\n else:\n upStop = 0\n early_stop = (upStop >= n_stop) and (n_stop > 0) # UP criterion\n prevError = currentError\n else:\n print('Error on mini batch at iter {0} : {1} '\n '(Gradient norm : {2})'.format(n_iter, currentMbe, gradNorm))\n errMB.append(currentMbe)\n\n #Maj iter\n n_iter += 1\n\n if val_set != []:\n print('Error on training set before and after training'\n '({2} iter) : {0}->{1}\\n'.format(iniError, currentError, n_iter))\n print('Generalization error : {0}'.format(glError))\n return errMB, errVal\n\n def score_fine(self, X_trees):\n '''\n Score sur les predictions MAP avec 5 label\n '''\n countAll = 0\n countRoot = 0\n scAll = 0.0\n scRoot = 0.0\n for X_tree in X_trees:\n self.forward_pass(X_tree)\n for n in X_tree.nodes:\n countAll += 1\n scAll += (Tree.Tree.getSoftLabel(n.ypred[1]) == Tree.Tree.getSoftLabel(n.y[1]))\n countRoot += 1\n n = X_tree.nodes[-1]\n scRoot += (Tree.Tree.getSoftLabel(n.ypred[1]) == Tree.Tree.getSoftLabel(n.y[1]))\n return scAll/countAll, scRoot/countRoot\n\n def score_eps(self, X_trees, eps):\n '''\n Score sur les predictions MAP avec 5 label\n '''\n countAll = 0\n countRoot = 0\n scAll = 0.0\n scRoot = 0.0\n for X_tree in X_trees:\n self.forward_pass(X_tree)\n for n in X_tree.nodes:\n countAll += 1\n scAll += (abs(n.ypred[1] - n.y[1]) <= eps)\n countRoot += 1\n n = X_tree.nodes[-1]\n scRoot += (abs(n.ypred[1] - n.y[1]) <= eps)\n return scAll/countAll, scRoot/countRoot\n\n def score_binary(self, X_trees, inc_neut=False):\n '''\n Score sur les prediction MAP pos/neg\n '''\n countAll = 0\n countRoot = 0\n scAll = 0.0\n scRoot = 0.0\n for X_tree in X_trees:\n self.forward_pass(X_tree)\n for n in X_tree.nodes:\n countAll += 1 * (inc_neut or not (0.4 < n.y[1] <= 0.6))\n scAll += ((n.ypred[1] <= 0.5 and n.y[1] <= 0.5) or\n (n.ypred[1] > 0.5 and n.y[1] > 0.5)) *\\\n (inc_neut or not (0.4 < n.y[1] <= 0.6))\n n = X_tree.nodes[-1]\n countRoot += 1 * (inc_neut or not (0.4 < n.y[1] <= 0.6))\n scRoot += ((n.ypred[1] <= 0.5 and n.y[1] <= 0.5) or\n (n.ypred[1] > 0.5 and n.y[1] > 0.5)) *\\\n (inc_neut or not (0.4 < n.y[1] <= 0.6))\n return scAll/countAll, scRoot/countRoot\n\n def check_derivative(self, X_tree, eps=1e-6):\n '''\n Fait une compaaison dérivee / differences finies\n '''\n error1 = self.forward_pass(X_tree)\n dWs, dV, dW, dL = self.backward_pass(X_tree)\n dirW = np.random.uniform(size=self.W.shape)\n dirWs = np.random.uniform(size=self.Ws.shape)\n dirL = np.random.uniform(size=self.L.shape)\n dirV = np.random.uniform(size=self.V.shape)\n\n self.Ws += eps*dirWs\n self.W += eps*dirW\n self.L += eps*dirL\n self.V += eps*dirV\n\n error2 = self.forward_pass(X_tree)\n diff = (error2-error1)/eps\n diff2 = np.sum(dW*dirW)+np.sum(dWs*dirWs)+np.sum(dL*dirL)+np.sum(dV*dirV)\n\n return np.abs(diff-diff2)\n\n def confusion_matrix(self, X_trees):\n confAll = np.zeros((5, 5))\n confRoot = np.zeros((5, 5))\n for tree in X_trees:\n for n in tree.nodes:\n lp = Tree.Tree.getSoftLabel(n.ypred[1])\n l = Tree.Tree.getSoftLabel(n.y[1])\n confAll[l, lp] += 1\n lp = Tree.Tree.getSoftLabel(tree.nodes[-1].ypred[1])\n l = Tree.Tree.getSoftLabel(tree.nodes[-1].y[1])\n confRoot[l, lp] += 1\n for lp in range(5):\n confAll[lp, :] /= np.sum(confAll[lp, :])\n confRoot[lp, :] /= np.sum(confRoot[lp, :])\n return confAll, confRoot\n\n def plot_words_2D(self, labels, N=-1):\n from sklearn.decomposition import PCA\n import matplotlib.pyplot as plt\n import matplotlib.cm as cm\n\n if N == -1:\n N = self.L.shape[0]\n\n pca = PCA(n_components=2)\n X = pca.fit_transform(self.L[:N])\n revert_vocab = {i: (w, labels[w]) for (w, i) in self.vocab.iteritems()}\n y = np.zeros(N)\n for i in range(N):\n _, y[i] = revert_vocab[i]\n plt.scatter(X[:, 0], X[:, 1], c=y, cmap=cm.jet)\n\n def sample_w(self, p):\n dist = ((self.L-p)**2).sum(axis=1)\n i0 = dist.argmin()\n return self.index[i0]\n\n def sample(self, p):\n queue = [p]\n while len(queue) != 0:\n curr = queue.pop()\n self.dec(curr)\n C = self.dec(curr)\n ac = C[:self.dim+1:]\n bc = C[self.dim+1:]\n if ac[-1] > 0.:\n queue.append(ac)\n else:\n print(self.sample_w(ac[:-1]))\n if bc[-1] > 0.:\n queue.append(bc)\n else:\n print(self.sample_w(bc[:-1]))\n\n def plot_eps_curve(self, X, n_pts):\n import matplotlib.pyplot as plt\n\n eps = np.logspace(-3, 0, n_pts)\n curve_r = []\n curve_a = []\n for e in eps:\n a, r = self.score_eps(X, e)\n curve_r.append(r)\n curve_a.append(a)\n\n plt.semilogx(eps, curve_a)\n plt.semilogx(eps, curve_r)\n plt.show()\n\n return curve_a, curve_r\n", "meta": {"hexsha": "7a9bfd360c67df12a9786cdc166f952fd7ae75b6", "size": 18919, "ext": "py", "lang": "Python", "max_stars_repo_path": "code/code/RAE.py", "max_stars_repo_name": "jalayrupera/Sentiment-analysis-on-amazon-product", "max_stars_repo_head_hexsha": "f04d77769f9c9b533d530ce5b217d741c09c93ee", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "code/code/RAE.py", "max_issues_repo_name": "jalayrupera/Sentiment-analysis-on-amazon-product", "max_issues_repo_head_hexsha": "f04d77769f9c9b533d530ce5b217d741c09c93ee", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "code/code/RAE.py", "max_forks_repo_name": "jalayrupera/Sentiment-analysis-on-amazon-product", "max_forks_repo_head_hexsha": "f04d77769f9c9b533d530ce5b217d741c09c93ee", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.7359223301, "max_line_length": 96, "alphanum_fraction": 0.5020878482, "include": true, "reason": "import numpy", "num_tokens": 5338, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6370307944803831, "lm_q2_score": 0.30404168757891037, "lm_q1q2_score": 0.1936839177935497}} {"text": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\nimport numpy as np\n\nfrom . import preliminary_computations as precomp\nfrom .local_conditions import sky_countrate\nfrom . import optics as opt\nfrom . import photometry as phot\nfrom . import utils\n\n\ndef etc_computation(info_dict):\n \"\"\"\n Compute either the SNR, the total exposure time or\n the magnitude in function of the 2 others\n\n Parameters\n ----------\n info_dict: dictionary\n contains all relevant information\n\n wavelength : array\n wavelengths in angstrom\n\n Returns\n ---------\n SNR: float\n Signal to noise ratio\n\n mag: float\n magnitude reached\n\n tot_exp_time: float\n total exposure time in seconds\n\n \"\"\"\n # display result\n verbose = info_dict[\"verbose\"]\n\n etc_type = info_dict[\"etc_type\"]\n SNR = info_dict[\"SNR\"]\n tot_exp_time = info_dict[\"Nexp\"] * info_dict[\"exptime\"]\n info_dict[\"total_exposure_time\"] = tot_exp_time\n Nexp = info_dict[\"Nexp\"]\n # Detector Integration Time in seconds\n if etc_type == \"snr\" or etc_type == \"mag\":\n DIT = info_dict[\"exptime\"] - info_dict[\"T_dithering\"]\n\n # Display\n if verbose:\n print(\"\\nInformation about Passband:\")\n print(\"----------------------------\")\n print(\"Cut_on: %.f angstroms\" % info_dict[\"Passband_cuton\"])\n print(\"Effective wavelength: %.f angstroms\" %\n info_dict[\"effWavelength\"])\n print(\"Cut_off: %.f angstroms\" % info_dict[\"Passband_cutoff\"])\n\n print(\"\\nAirmass: %.2f\" % info_dict[\"airmass\"])\n print(\"\\nSeeing: %.2f\" % info_dict[\"seeing_los_arcsec\"])\n\n if info_dict[\"detailed_trans\"] == 1:\n # Computes mean transmission of each components for the given passband\n mean_trans_tel = utils.mean_efficiency_passband(\n info_dict, opt.telescope_efficiency(info_dict)\n )\n mean_trans_inst = utils.mean_efficiency_passband(\n info_dict,\n opt.instrument_channel_efficiency(info_dict)\n * info_dict[\"Trans_filter\"]\n * info_dict[\"camera_efficiency\"],\n )\n mean_trans_filter = utils.mean_efficiency_passband(\n info_dict, info_dict[\"Trans_filter\"]\n )\n mean_eta_cam = utils.mean_efficiency_passband(\n info_dict, info_dict[\"camera_efficiency\"]\n )\n mean_trans_optics = mean_trans_tel * mean_trans_inst\n mean_trans_atm = utils.mean_efficiency_passband(\n info_dict, info_dict[\"Trans_atmosphere\"]\n )\n mean_trans_system = mean_trans_optics\n info_dict[\"trans_mean_tel\"] = mean_trans_tel\n info_dict[\"trans_mean_inst\"] = mean_trans_inst\n info_dict[\"trans_mean_optics\"] = mean_trans_optics\n info_dict[\"trans_mean_filter\"] = mean_trans_filter\n info_dict[\"trans_mean_atm\"] = mean_trans_atm\n info_dict[\"trans_mean_cam\"] = mean_eta_cam\n info_dict[\"trans_mean_system\"] = mean_trans_system\n\n if verbose:\n print(\"\\nMEAN EFFICENCIES:\")\n print(\"------------------\")\n print(\"Obscuration: %.3f\" % (1.0 - info_dict[\"obstruction\"]))\n print(\n \"Telescope: %.3f (+obs: %.3f)\"\n % (mean_trans_tel,\n mean_trans_tel * (1.0 - info_dict[\"obstruction\"]))\n )\n print(\"Instrument: %.3f\" % mean_trans_inst)\n print(\n \"Optics (tel+inst): %.3f (+obs: %.3f)\"\n % (\n mean_trans_optics,\n mean_trans_optics * (1.0 - info_dict[\"obstruction\"]),\n )\n )\n print(\"Filter: %.3f\" % mean_trans_filter)\n print(\"Atmosphere: %.3f\" % mean_trans_atm)\n print(\"Camera: %.3f\" % mean_eta_cam)\n print(\n \"System: %.3f (+obs: %.3f)\\n\"\n % (\n mean_trans_system,\n mean_trans_system * (1 - info_dict[\"obstruction\"]),\n )\n )\n\n elif info_dict[\"detailed_trans\"] == 0:\n mean_eta_cam = utils.mean_efficiency_passband(\n info_dict, info_dict[\"camera_efficiency\"]\n )\n mean_eta_optics = utils.mean_efficiency_passband(\n info_dict, phot.set_filter(info_dict)\n )\n mean_trans_system = mean_eta_cam * mean_eta_optics\n info_dict[\"trans_mean_system\"] = mean_trans_system\n if verbose:\n print(\"\\nMEAN EFFICENCIES:\")\n print(\"------------------\")\n print(\"Obscuration: %.3f\" % (1.0 - info_dict[\"obstruction\"]))\n print(\n \"System: %.2f (+obs: %.3f)\\n\"\n % (\n mean_trans_system,\n mean_trans_system * (1 - info_dict[\"obstruction\"]),\n )\n )\n\n # Number of pixels covering 1.35*FWHM of the PSF\n npix = info_dict[\"npix\"]\n # Factor when estimating the Noise from other images\n factor_ima = precomp.factor_images_averaged(info_dict)\n # Fraction of light in the brightest pixel\n f_pix = precomp.Normalisation_factor(info_dict, True)\n # Fraction of light in the PSF\n f_PSF = precomp.Normalisation_factor(info_dict, False)\n\n info_dict[\"factor_ima\"] = factor_ima\n info_dict[\"f_pix\"] = f_pix\n info_dict[\"f_PSF\"] = f_PSF\n\n # Background Noise countrate in e-/s/px\n # ---------------------------------------\n info_dict = sky_countrate(info_dict) # e-/s/px\n BN = info_dict[\"Sky_CountRate\"]\n # print ('Sky countrate: %.2f (e-/px/s)' % BN)\n # Thermic signal (electrons/s/pixel) <--> Dark current\n # ------------------------------------------------------\n DC = info_dict[\"cameras\"][info_dict[\"channel\"]][\"DC\"]\n # Digitization noise (e-/pixel)\n # ----------------------------------\n # Converter analog to digital noise of 1/2 ADU (electrons/pixel)\n DigN = info_dict[\"dig_noise\"]\n\n # Readout noise (e-/pixel)\n # --------------------------\n RN = info_dict[\"cameras\"][info_dict[\"channel\"]][\"RN\"]\n\n # Instrument background (e-/s/pix)\n inst_bg = info_dict[\"Instrument_bg\"]\n\n # Object\n # ---------\n # Count rate of the object in e-/s\n if etc_type == \"snr\" or etc_type == \"time\":\n CR, fph = info_dict[\"Object_fes\"], info_dict[\"Object_fph\"] # e-/s\n\n # Zeropoint\n # -----------\n ZP = info_dict[\"zeropoint\"]\n\n # Add some info in info_cit\n if verbose:\n print(\"Zeropoint: %.2f (%s mag)\" % (ZP,\n info_dict[\"photometry_system\"]))\n\n # Compute the SNR\n # ------------------\n if etc_type == \"snr\":\n # In the case of a given magnitude to reach, the fraction of flux\n # we kept should be included so that the given mag corresponds to the\n # measured count rate.\n if info_dict[\"object_type\"] == \"magnitude\":\n CR = CR # / f_PSF\n CR_pix = CR # / f_pix\n else:\n CR_pix = CR\n\n # Peak SNR (Object signal/noise at the brightest pixel)\n SNR_pix = (\n np.sqrt(Nexp)\n * CR_pix\n * f_pix\n * DIT\n / np.sqrt(\n CR_pix * f_pix * DIT\n + factor_ima * ((RN ** 2.0 + DigN ** 2.0)\n + DIT * (DC + BN + inst_bg))\n )\n )\n\n # Total integrated noise over npix (electrons/area)\n SNR = (\n np.sqrt(Nexp)\n * CR\n * f_PSF\n * DIT\n / np.sqrt(\n CR * f_PSF * DIT\n + factor_ima\n * npix\n * ((RN ** 2.0 + DigN ** 2.0) + DIT * (DC + BN + inst_bg))\n )\n )\n\n if info_dict[\"object_type\"] == \"magnitude\":\n # mag = ZP - 2.5*np.log10(CR*f_PSF)\n mag = info_dict[\"object_magnitude\"]\n mag_pix = ZP - 2.5 * np.log10(CR_pix * f_pix)\n mag_pix = info_dict[\"object_magnitude\"]\n else:\n mag = ZP - 2.5 * np.log10(CR)\n mag_pix = ZP - 2.5 * np.log10(CR_pix)\n\n Ftot_el = CR * f_PSF * DIT # *np.sqrt(Nexp)\n Ftot_el_pix = CR_pix * f_pix * DIT # *np.sqrt(Nexp)\n DIT_pix = DIT\n\n info_dict[\"SNR\"] = SNR\n info_dict[\"SNR_pix\"] = SNR_pix\n info_dict[\"mag_pix\"] = mag_pix\n info_dict[\"Ftot_el_pix\"] = Ftot_el_pix\n info_dict[\"Ftot_el\"] = Ftot_el\n info_dict[\"DIT_pix\"] = DIT_pix\n\n if verbose:\n print(\n \"\\n\\nA magnitude (%s system) of %.2f in %s band within a total exposure time of %.2f seconds splited in %d exposure(s), implies a total SNR of :\\n\"\n % (\n info_dict[\"photometry_system\"],\n mag,\n info_dict[\"filter_band\"],\n DIT * Nexp,\n Nexp,\n )\n )\n # print ('\\t - Peak SNR at the brightest pixel: %.2f \\n' % SNR_pix)\n print(\"\\t - Integrated SNR over %d pixels: %.2f\" % (npix, SNR))\n print(\n \"\\n\\nA magnitude (%s system) of %.2f in %s band within a total exposure time of %.2f seconds splited in %d exposure(s), implies a SNR for the central pixel of of :\\n\\n\"\n % (\n info_dict[\"photometry_system\"],\n mag_pix,\n info_dict[\"filter_band\"],\n DIT_pix * Nexp,\n Nexp,\n )\n )\n print(\"\\t - SNR of the central pixel: %.2f \\n\\n\" % SNR_pix)\n\n # Compute the total exposure time\n # --------------------------------\n elif etc_type == \"time\":\n\n # In the case of a given magnitude to reach, the fraction of flux\n # we kept should be included so that the given mag corresponds to the\n # measured count rate.\n if info_dict[\"object_type\"] == \"magnitude\":\n CR = CR # / f_PSF\n\n # Integrated over Npixels (solve 2nd degree equation)\n if Nexp > 1:\n SNR_1 = SNR / np.sqrt(Nexp)\n else:\n SNR_1 = SNR\n A_sys = -((CR * f_PSF) ** 2.0)\n B_sys = SNR_1 ** 2.0 * (CR * f_PSF + factor_ima * npix\n * (DC + BN + inst_bg))\n C_sys = SNR_1 ** 2.0 * factor_ima * npix * (RN ** 2.0 + DigN ** 2.0)\n\n delta = B_sys * B_sys - 4.0 * A_sys * C_sys\n\n DIT = (-B_sys - np.sqrt(delta)) / (2.0 * A_sys)\n # mag = -2.5*np.log10(obj_janskys/3631)\n\n if info_dict[\"object_type\"] == \"magnitude\":\n mag = ZP - 2.5 * np.log10(CR) # *f_PSF)\n else:\n mag = ZP - 2.5 * np.log10(CR)\n\n Ftot_el = CR * f_PSF * DIT # *np.sqrt(Nexp)\n\n # Brightest pixel\n if info_dict[\"object_type\"] == \"magnitude\":\n CR_pix = CR # / f_pix\n else:\n CR_pix = CR\n\n A_sys = -((CR_pix * f_pix) ** 2.0)\n B_sys = SNR_1 ** 2.0 * (CR_pix * f_pix + factor_ima\n * (DC + BN + inst_bg))\n C_sys = SNR_1 ** 2.0 * factor_ima * (RN ** 2.0 + DigN ** 2.0)\n\n delta = B_sys * B_sys - 4.0 * A_sys * C_sys\n\n DIT_pix = (-B_sys - np.sqrt(delta)) / (2.0 * A_sys)\n\n if info_dict[\"object_type\"] == \"magnitude\":\n mag_pix = ZP - 2.5 * np.log10(CR_pix) # *f_pix)\n else:\n mag_pix = ZP - 2.5 * np.log10(CR)\n\n Ftot_el_pix = CR_pix * f_pix * DIT_pix # *np.sqrt(Nexp)\n\n info_dict[\"DIT\"] = DIT\n info_dict[\"DIT_pix\"] = DIT_pix\n info_dict[\"Ftot_el_pix\"] = Ftot_el_pix\n info_dict[\"Ftot_el\"] = Ftot_el\n info_dict[\"mag_pix\"] = mag_pix\n\n if verbose:\n print(\n \"\\n\\nReaching a magnitude (%s system) of %.2f in %s band with a SNR of %.2f requires:\\n\"\n % (info_dict[\"photometry_system\"], mag, info_dict[\"filter_band\"], SNR)\n )\n print(\"\\t - a Total exposure time of: %.2f s\\n\" % (DIT * Nexp))\n print(\n \"\\n\\nReaching a magnitude (%s system) of %.2f in %s band with a SNR of %.2f for the central pixel requires:\\n\\n\"\n % (\n info_dict[\"photometry_system\"],\n mag_pix,\n info_dict[\"filter_band\"],\n SNR,\n )\n )\n print(\"\\t - a Total exposure time of: %.2f s\\n\\n\" % (DIT_pix * Nexp))\n\n # Compute the magnitude\n # ------------------------\n elif etc_type == \"mag\":\n # f_PSF=1\n # f_pix=1\n # Integrated over Npixels (solve 2nd degree equation)\n A_sys = -((f_PSF * DIT * np.sqrt(Nexp)) ** 2.0)\n B_sys = SNR ** 2.0 * f_PSF * DIT\n C_sys = SNR ** 2.0 * (\n factor_ima * npix * (RN ** 2.0 + DigN ** 2.0 + DIT\n * (DC + BN + inst_bg))\n )\n\n delta = B_sys * B_sys - 4.0 * A_sys * C_sys\n\n CR = (-B_sys - np.sqrt(delta)) / (2.0 * A_sys)\n Ftot_el = CR * f_PSF * DIT # *np.sqrt(Nexp)\n\n mag = ZP - 2.5 * np.log10(CR)\n\n # Central pixel\n A_sys = -((f_pix * DIT * np.sqrt(Nexp)) ** 2.0)\n B_sys = SNR ** 2.0 * f_pix * DIT\n C_sys = SNR ** 2.0 * (\n factor_ima * (RN ** 2.0 + DigN ** 2.0 + DIT * (DC + BN + inst_bg))\n )\n\n delta = B_sys * B_sys - 4.0 * A_sys * C_sys\n\n CR_pix = (-B_sys - np.sqrt(delta)) / (2.0 * A_sys)\n Ftot_el_pix = CR_pix * f_pix * DIT # *np.sqrt(Nexp)\n mag_pix = ZP - 2.5 * np.log10(CR_pix)\n DIT_pix = DIT\n\n object_mag = mag * np.ones(len(info_dict[\"wavelength_ang\"]))\n fJy = phot.mag2Jy(info_dict, object_mag) # Jy\n # erg/s/cm2/A\n flam = utils.fJy_to_flambda(info_dict[\"wavelength_ang\"], fJy)\n # ph/s/cm2/A\n fph = utils.flambda_to_fph(info_dict[\"wavelength_ang\"], flam)\n\n info_dict[\"Object_mag\"] = object_mag\n info_dict[\"object_magnitude\"] = mag\n info_dict[\"mag_pix\"] = mag_pix\n info_dict[\"DIT_pix\"] = DIT\n info_dict[\"Ftot_el_pix\"] = Ftot_el_pix\n info_dict[\"Ftot_el\"] = Ftot_el\n\n if verbose:\n print(\n \"\\n\\nFor a total SNR=%.2f in a total exposure time of %.2f (sec) in %d exposure(s) we reach:\\n\"\n % (SNR, DIT * Nexp, Nexp)\n )\n print(\n \"\\t - a magnitude (%s system) of: %.2f in %s band\\n\"\n % (info_dict[\"photometry_system\"],\n mag,\n info_dict[\"filter_band\"])\n )\n print(\n \"\\n\\nFor the central pixel a SNR=%.2f in a total exposure time of %.2f (sec) in %d exposure(s) we reach:\\n\\n\"\n % (SNR, DIT_pix * Nexp, Nexp)\n )\n print(\n \"\\t - a magnitude (%s system) of: %.2f in %s band\\n\\n\"\n % (info_dict[\"photometry_system\"], mag_pix, info_dict[\"filter_band\"])\n )\n\n info_dict[\"DIT\"] = DIT\n\n # sigma_shot_noise = np.sqrt(Ftot_el * DIT)\n # sigma_dark_current = np.sqrt(DC * npix * DIT)\n # sigma_sky = np.sqrt(BN * npix * DIT)\n # sigma_digitization = np.sqrt(npix * DigN ** 2.0)\n # sigma_readout_noise = np.sqrt(npix * RN ** 2.0)\n\n # Total number of electrons in the brightest pixel for 1 exposure\n N_el_tot_pix1 = Ftot_el_pix + (BN + DC + inst_bg) * DIT_pix + RN + DigN\n N_el_tot_pix2 = (Ftot_el * f_pix / f_PSF\n + (BN + DC + inst_bg) * DIT + RN + DigN)\n\n info_dict[\"N_el_tot_pix1\"] = N_el_tot_pix1\n info_dict[\"N_el_tot_pix2\"] = N_el_tot_pix2\n\n if N_el_tot_pix1 > info_dict[\"cameras\"][info_dict[\"channel\"]][\"FWC\"]:\n info_dict[\"saturation\"] = \"Yes\"\n else:\n info_dict[\"saturation\"] = \"No\"\n\n if verbose:\n\n print(\n \"\\nFull well capacity of 1 pixel: %.2f (electrons)\"\n % (info_dict[\"cameras\"][info_dict[\"channel\"]][\"FWC\"])\n )\n print(\"\\n\\n--------- One pixel only------------------\")\n print(\n \"\\nPhoto-electrons created: central pix for %d exposure(s) of %.2f sec \"\n % (Nexp, DIT_pix)\n )\n print(\"\\tby:\")\n print(\"\\t- Object: %10.2f (electrons)\" % Ftot_el_pix)\n print(\"\\t- Sky: %10.2f (electrons)\" % (BN * DIT_pix))\n print(\"\\t- Readout: %10.2f (electrons)\" % RN)\n print(\"\\t- Dark current: %10.2f (electrons)\" % (DC * DIT_pix))\n print(\"\\t- Digitization: %10.2f (electrons)\" % DigN)\n print(\"\\t- Instrument bg: %10.2f (electrons)\" % (inst_bg * DIT_pix))\n\n print(\n \"\\nSNR: -central pixel: %.2f\"\n % (\n np.sqrt(Nexp)\n * Ftot_el_pix\n / np.sqrt(\n Ftot_el_pix\n + factor_ima\n * ((RN ** 2.0 + DigN ** 2.0) + DIT_pix\n * (DC + BN + inst_bg))\n )\n )\n )\n\n print(\n \"\\nTotal of electrons collected in the central pixel during an exposure time of %d seconds: %.2f \"\n % (DIT_pix, N_el_tot_pix1)\n )\n if N_el_tot_pix1 > info_dict[\"cameras\"][info_dict[\"channel\"]][\"FWC\"]:\n print(\n \"--> Central pixel saturated: number of electrons > Full well Capacity\"\n )\n elif N_el_tot_pix1 > info_dict[\"cameras\"][info_dict[\"channel\"]][\"gain\"] * (\n 2.0 ** (info_dict[\"cameras\"][info_dict[\"channel\"]][\"bits\"]) - 1\n ):\n print(\n \"--> Central pixel saturated: number of electrons > number of digitizations\"\n )\n elif (\n N_el_tot_pix1 > 1.0 / 2 * info_dict[\"cameras\"][info_dict[\"channel\"]][\"FWC\"]\n ):\n print(\n \"--> Number of electrons in central pixel > 1/2 of Full well Capacity. Risk of non-linear response.\"\n )\n\n else:\n print(\"--> No saturation\")\n\n print(\"\\n\\n\\n--------- Integrated over %d pixels------------------\" % npix)\n print(\n \"\\nPhoto-electrons created: brightest pix | total of %d pixels, %d exposure(s) of %.2f sec \"\n % (npix, Nexp, DIT)\n )\n print(\"\\tby:\")\n print(\n \"\\t- Object: %10.2f | %10.2f (electrons)\"\n % (Ftot_el * f_pix / f_PSF, Ftot_el)\n )\n print(\n \"\\t- Sky: %10.2f | %10.2f (electrons)\"\n % (BN * DIT, (BN * npix * DIT * Nexp))\n )\n print(\n \"\\t- Readout: %10.2f | %10.2f (electrons)\"\n % (RN, (RN * npix * Nexp))\n )\n print(\n \"\\t- Dark current: %10.2f | %10.2f (electrons)\"\n % (DC * DIT, (DC * DIT * npix * Nexp))\n )\n print(\n \"\\t- Digitization: %10.2f | %10.2f (electrons)\"\n % (DigN, (DigN * npix * Nexp))\n )\n print(\n \"\\t- Instrument bg: %10.2f | %10.2f (electrons)\"\n % (inst_bg * DIT, (inst_bg * DIT * npix * Nexp))\n )\n\n print(\n \"\\nSNR: -Brightest pixel: %.2f\"\n % (\n np.sqrt(Nexp)\n * Ftot_el\n * f_pix\n / f_PSF\n / np.sqrt(\n Ftot_el * f_pix / f_PSF\n + factor_ima\n * ((RN ** 2.0 + DigN ** 2.0) + DIT * (DC + BN + inst_bg))\n )\n )\n )\n print(\n \" -integrated over %d pixels: %.2f\"\n % (\n npix,\n np.sqrt(Nexp)\n * Ftot_el\n / np.sqrt(\n Ftot_el\n + factor_ima\n * npix\n * ((RN ** 2.0 + DigN ** 2.0) + DIT * (DC + BN + inst_bg))\n ),\n )\n )\n print(\n \"\\nTotal of electrons collected in the brightest pixel during an exposure time of %d seconds: %.2f \"\n % (DIT_pix, N_el_tot_pix2)\n )\n if N_el_tot_pix2 > info_dict[\"cameras\"][info_dict[\"channel\"]][\"FWC\"]:\n print(\n \"--> Brightest pixel saturated: number of electrons > Full well Capacity\"\n )\n elif N_el_tot_pix2 > info_dict[\"cameras\"][info_dict[\"channel\"]][\"gain\"] * (\n 2.0 ** (info_dict[\"cameras\"][info_dict[\"channel\"]][\"bits\"]) - 1\n ):\n print(\n \"--> Brightest pixel saturated: number of electrons > number of digitizations\"\n )\n elif (\n N_el_tot_pix2 > 1.0 / 2 * info_dict[\"cameras\"][info_dict[\"channel\"]][\"FWC\"]\n ):\n print(\n \"--> Number of electrons in brightest pixel > 1/2 of Full well Capacity. Risk of non-linear response.\"\n )\n\n else:\n print(\"--> No saturation\")\n\n print(\n \"\\nDead time: %.2f sec \\n(%.2f sec for dithering, the %.2f sec for the readout are not taken into account)\"\n % (\n info_dict[\"deadtime_tot\"],\n info_dict[\"T_dithering\"],\n info_dict[\"cameras\"][info_dict[\"channel\"]][\"ReadoutTime\"],\n )\n )\n info_dict[\"SNR\"] = SNR\n info_dict[\"mag\"] = mag\n info_dict[\"total_exposure_time\"] = DIT * Nexp\n info_dict[\"fph\"] = fph\n\n return info_dict\n", "meta": {"hexsha": "606b64e5ca835e93c59e643bbde3605c66b1111b", "size": 21276, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyETC/solver.py", "max_stars_repo_name": "dcorre/pyETC", "max_stars_repo_head_hexsha": "88d4eb78a6a638b28d05c6798c32952956f956b4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-05-21T14:53:54.000Z", "max_stars_repo_stars_event_max_datetime": "2020-08-04T21:48:03.000Z", "max_issues_repo_path": "pyETC/solver.py", "max_issues_repo_name": "dcorre/pyETC", "max_issues_repo_head_hexsha": "88d4eb78a6a638b28d05c6798c32952956f956b4", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 11, "max_issues_repo_issues_event_min_datetime": "2020-08-02T06:54:46.000Z", "max_issues_repo_issues_event_max_datetime": "2020-08-05T10:44:22.000Z", "max_forks_repo_path": "pyETC/solver.py", "max_forks_repo_name": "dcorre/pyETC", "max_forks_repo_head_hexsha": "88d4eb78a6a638b28d05c6798c32952956f956b4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-05-24T21:37:11.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-24T21:37:11.000Z", "avg_line_length": 35.8785834739, "max_line_length": 184, "alphanum_fraction": 0.495534875, "include": true, "reason": "import numpy", "num_tokens": 5780, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6370307944803831, "lm_q2_score": 0.30404168127272885, "lm_q1q2_score": 0.19368391377631788}} {"text": "# This file is part of sequencing.\n#\n# Copyright (c) 2021, The Sequencing Authors.\n# All rights reserved.\n#\n# This source code is licensed under the BSD-style license found in the\n# LICENSE file in the root directory of this source tree.\n\nimport re\nimport json\nfrom collections import defaultdict\nfrom contextlib import contextmanager\n\nimport numpy as np\nimport qutip\nimport attr\n\nfrom .parameters import Parameterized, ListParameter, DictParameter\nfrom .modes import Mode, sort_modes\n\n\nclass CouplingTerm(object):\n \"\"\"An object representing a coupling between two ``Modes``,\n given by a Hamiltonian term of the form ``strength * op1 * op2``.\n If the keyword argument ``add_hc`` is provided and is True,\n then the Hamiltonian term takes the form\n ``strength * ((op1 * op2) + (op1 * op2).dag())``.\n\n Args:\n mode1 (Mode): First mode to be coupled.\n op1_expr (str): String representation of mode1's operator in the coupling term.\n mode2 (Mode): Second mode to tbe coupled (can the same object as mode1).\n op2_expr (str): String representation of mode2's operator in the coupling term.\n strength (optional, float): Coefficient parameterizing the\n strength of the coupling. Strength should be given in\n units of 2 * pi * GHz. Default: 1.\n add_hc (optional, bool): Whether to add the Hermitian conjugate\n of the product of op1 and op2. Default: False.\n \"\"\"\n\n def __init__(self, mode1, op1_expr, mode2, op2_expr, strength=1, add_hc=False):\n for mode in [mode1, mode2]:\n if not isinstance(mode, Mode):\n raise TypeError(f\"Expected instance of Mode, but got {type(mode)}.\")\n for expr in [op1_expr, op2_expr]:\n if not isinstance(expr, str):\n raise TypeError(f\"Expected instance of str, but got {type(expr)}.\")\n self.mode1 = mode1\n self.mode2 = mode2\n self.op1_expr = op1_expr\n self.op2_expr = op2_expr\n self.strength = float(strength)\n self.add_hc = bool(add_hc)\n\n @property\n def op1(self):\n \"\"\"Operator for ``mode1``.\"\"\"\n op = self.mode1.operator_expr(self.op1_expr)\n if not isinstance(op, qutip.Qobj):\n raise TypeError(f\"Expected op1 to be a qutip.Qobj, not {type(op)}\")\n if not self.add_hc and not op.isherm:\n raise ValueError(\"Expected op1 to be Hermitian since add_hc is False.\")\n return op\n\n @property\n def op2(self):\n \"\"\"Operator for ``mode2``.\"\"\"\n op = self.mode2.operator_expr(self.op2_expr)\n if not isinstance(op, qutip.Qobj):\n raise TypeError(f\"Expected op2 to be a qutip.Qobj, not {type(op)}\")\n if not self.add_hc and not op.isherm:\n raise ValueError(\"Expected op2 to be Hermitian since add_hc is False.\")\n return op\n\n def H(self, strength=None, add_hc=None):\n \"\"\"Returns the operator representing the coupling term.\n\n Args:\n strength (optional, float): Coefficient parameterizing the\n strength of the coupling. Strength should be given in units\n of 2 * pi * GHz. Defaults to self.strength.\n add_hc (optional, bool): Whether to add the Hermitian conjugate\n of product of op1 and op2. Defaults to self.add_hc.\n\n Returns:\n ``qutip.Qobj``: Operator representing the coupling term.\n \"\"\"\n if strength is None:\n strength = self.strength\n if add_hc is None:\n add_hc = self.add_hc\n op = self.op1 * self.op2\n if add_hc:\n op = op + op.dag()\n return strength * op\n\n def __repr__(self):\n return (\n f\"{type(self).__name__}(\"\n f\"{self.mode1.name}.{self.op1_expr}, \"\n f\"{self.mode2.name}.{self.op2_expr}, \"\n f\"strength={self.strength:.3e}, \"\n f\"add_hc={self.add_hc}\"\n \")\"\n )\n\n\n@attr.s\nclass System(Parameterized):\n \"\"\"A collection of ``Modes`` that can be coupled together.\n\n Attributes:\n modes (list[Mode]): List of all Modes in the system.\n coupling_terms (dict[frozenset[str], list[CouplingTerm]]):\n A dictionary of CouplingTerm objects specifying all\n interactions in the system.\n cross_kerrs (dict[frozenset[str], float]): A dictionary\n of cross-Kerr values in units of GHz.\n \"\"\"\n\n modes = ListParameter()\n cross_kerrs = DictParameter()\n\n order_modes = True\n\n def initialize(self):\n super().initialize()\n if self.order_modes:\n self.modes = sort_modes(self.modes)\n self.active_modes = self.modes\n self.coupling_terms = defaultdict(list)\n\n def __getattribute__(self, name):\n # Access modes like system.qubit.\n # System.modes can be changed at any time, so we cannot\n # just setattr(self, name, mode) in initialize().\n try:\n for mode in object.__getattribute__(self, \"modes\"):\n if mode.name == name:\n return mode\n except AttributeError:\n pass\n return object.__getattribute__(self, name)\n\n def get_mode(self, mode):\n \"\"\"Fetch a mode by name.\n\n Args:\n mode (str or Mode): Name of Mode to fetch, or the Mode itself.\n\n Returns:\n Mode: The requested ``Mode``.\n \"\"\"\n if isinstance(mode, Mode):\n mode = mode.name\n if mode not in [m.name for m in self.modes]:\n raise ValueError(f\"{mode} is not a mode of {self.name}.\")\n return getattr(self, mode)\n\n @property\n def levels(self):\n \"\"\"Dictionary of (mode_name, number_of_levels)\"\"\"\n return {mode.name: mode.levels for mode in self.modes}\n\n @property\n def active_modes(self):\n \"\"\"List of the modes currently being used.\"\"\"\n for mode in self._active_modes:\n if mode not in self.modes:\n raise ValueError(\n f\"{mode.name} is not in {self.name}.modes. \"\n f\"This likely happened because {self.name}.modes \"\n f\"was changed after {self.name} was created.\"\n f\"Please set {self.name}.active_modes to be \"\n f\"a subset of {self.name}.modes.\"\n )\n return self._active_modes\n\n @active_modes.setter\n def active_modes(self, modes):\n if isinstance(modes[0], str):\n modes = [getattr(self, m) for m in modes]\n if self.order_modes:\n modes = sort_modes(modes)\n if not all(mode in self.modes for mode in modes):\n raise ValueError(\"active_modes must be a subset of the system's modes.\")\n self._active_modes = modes\n for mode in self._active_modes:\n mode.space = self._active_modes\n\n @contextmanager\n def use_modes(self, modes):\n \"\"\"A context manager that temporarily sets ``self.active_modes``\n to ``modes``, then reverts ``self.active_modes``\n to its previous value.\n\n Args:\n modes (list[Mode]): List of ``Modes`` to temporarily\n assign to ``self.active_modes``.\n \"\"\"\n if isinstance(modes, (str, Mode)):\n modes = [modes]\n old_modes = self.active_modes\n try:\n self.active_modes = modes\n yield\n finally:\n self.active_modes = old_modes\n\n @staticmethod\n def tensor(*args):\n \"\"\"Calculates the tensor product of input operators.\"\"\"\n return qutip.tensor(*args)\n\n def I(self, modes=None): # noqa: E741, E743\n \"\"\"Identity operator.\n\n Args:\n modes (optional, list[Mode]): List of Modes to use in\n constructing H0. If None, will use self.active_modes.\n Default: None.\n\n Returns:\n ``qutip.Qobj``: Identity operator on the Hilbert space\n defined by ``modes``.\n \"\"\"\n if modes is None:\n modes = self.active_modes\n elif not all(mode in self.modes for mode in modes):\n raise ValueError(\"modes must be a subset of the system's modes.\")\n return self.tensor(*[qutip.qeye(mode.levels) for mode in modes])\n\n eye = I\n\n def fock(self, *args, **kwargs):\n \"\"\"Returns a product state in the Fock basis. States can be\n specified either positionally or as keyword arguments.\n\n Args:\n *args (tuple): Fock states of Modes in the order of self.modes.\n **kwargs (dict): Fock states of Modes specified as keyword\n arguments, mode_name=n.\n\n Returns:\n ``qutip.Qobj``: The requested product state.\n \"\"\"\n if args:\n if kwargs:\n raise ValueError(\n \"If positional arguments are provided, \"\n \"no keyword arguments are allowed.\"\n )\n if len(args) != len(self.active_modes):\n raise ValueError(\n \"The number of positional argument must match \"\n \"the number of active modes.\"\n )\n states = [\n qutip.fock(mode.levels, val)\n for mode, val in zip(self.active_modes, args)\n ]\n else:\n states = [\n qutip.fock(mode.levels, kwargs.get(mode.name, 0))\n for mode in self.active_modes\n ]\n return self.tensor(*states)\n\n def fock_dm(self, *args, **kwargs):\n \"\"\"Returns a product state in the Fock basis, as a density matrix.\n\n States can be specified either positionally or as keyword arguments.\n\n Args:\n *args (tuple): Fock states of Modes in the order of self.modes.\n **kwargs (dict): Fock states of Modes specified as keyword\n arguments, mode_name=n.\n\n Returns:\n ``qutip.Qobj``: The requested product state, as a density matrix.\n \"\"\"\n ket = self.fock(*args, **kwargs)\n return qutip.ket2dm(ket)\n\n basis = fock\n\n def ground_state(self):\n \"\"\"Returns the ground state of the system.\n\n Returns:\n ``qutip.Qobj``: The system's ground state.\n \"\"\"\n return self.fock()\n\n def logical_basis(self, *args, **kwargs):\n \"\"\"Returns a product state in the basis spanned by the logical states\n of all modes. Logical states can be specified either positionally\n or as keyword arguments.\n\n Args:\n *args (tuple): Logical states of Modes in the order of self.modes.\n **kwargs (dict): Logical states of Modes specified as keyword\n arguments, mode_name=n.\n\n Returns:\n ``qutip.Qobj``: The requested product state.\n \"\"\"\n if args:\n if kwargs:\n raise ValueError(\n \"If positional arguments are provided, \"\n \"no keyword arguments are allowed.\"\n )\n if len(args) != len(self.active_modes):\n raise ValueError(\n \"The number of positional argument must match \"\n \"the number of active modes.\"\n )\n states = [\n mode.logical_states(full_space=False)[val]\n for mode, val in zip(self.active_modes, args)\n ]\n else:\n states = [\n mode.logical_states(full_space=False)[kwargs.get(mode.name, 0)]\n for mode in self.active_modes\n ]\n return self.tensor(*states)\n\n def set_cross_kerr(self, mode1, mode2, chi=0):\n \"\"\"Set the cross-Kerr (in GHz) between two modes. Note that the order\n of mode1 and mode2 doesn't matter.\n\n Args:\n mode1 (Mode or str): Instance of Mode or\n the name of a member of ``self.modes``.\n mode2 (Mode or str): Instance of Mode or\n the name of a member of ``self.modes``.\n chi (optional, float): Cross-Kerr between mode0 and mode1 in GHz.\n Default: 0.\n \"\"\"\n if isinstance(mode1, str):\n mode1 = self.get_mode(mode1)\n if isinstance(mode2, str):\n mode2 = self.get_mode(mode2)\n if mode1 is mode2:\n raise ValueError(\"If mode1 is mode2, then it's not a cross-Kerr.\")\n key = frozenset([mode1.name, mode2.name])\n # Replace this cross-Kerr if it already exists\n if key in self.coupling_terms:\n for i, term in enumerate(self.coupling_terms[key][:]):\n if (\n term.mode1 is mode1\n and term.op1_expr == \"n\"\n and term.mode2 is mode2\n and term.op2_expr == \"n\"\n ) or (\n term.mode1 is mode2\n and term.op1_expr == \"n\"\n and term.mode2 is mode1\n and term.op2_expr == \"n\"\n ):\n _ = self.coupling_terms[key].pop(i)\n self.coupling_terms[key].append(\n CouplingTerm(mode1, \"n\", mode2, \"n\", strength=2 * np.pi * chi)\n )\n self.cross_kerrs[key] = chi\n\n def couplings(self, modes=None, clean=True):\n \"\"\"Returns all of the static coupling terms in the Hamiltonian.\n\n Args:\n modes (optional, list[Mode]): List of Modes to use in\n constructing H0. If None, will use self.active_modes.\n Default: None.\n clean (optional, bool): Only keep operators with nonzero elements.\n Default: True.\n\n Returns:\n list[qutip.Qobj]: List of static coupling terms.\n \"\"\"\n if modes is None:\n modes = self.active_modes\n mode_names = [mode.name for mode in modes]\n coupling_terms = []\n with self.use_modes(modes):\n for (mode0, mode1), terms in self.coupling_terms.items():\n if mode0 in mode_names and mode1 in mode_names:\n coupling_terms.extend([term.H() for term in terms])\n if clean:\n return [term for term in coupling_terms if term.data.nnz]\n return coupling_terms\n\n def H0(self, modes=None, clean=True):\n \"\"\"Returns the static Hamiltonian consisting of all\n self-Kerrs and cross-Kerrs.\n\n Args:\n modes (optional, list[Mode]): List of Modes to use in\n constructing H0. If None, will use self.active_modes.\n Default: None.\n clean (optional, bool): Only keep operators with nonzero elements.\n Default: True.\n\n Returns:\n list[qutip.Qobj]: Static Hamiltonian in list form.\n \"\"\"\n if modes is None:\n modes = self.active_modes\n detunings = [mode.detuning for mode in modes]\n self_kerrs = [mode.self_kerr for mode in modes]\n couplings = self.couplings(modes=modes, clean=clean)\n H0 = detunings + self_kerrs + couplings\n if clean:\n return [H for H in H0 if H.data.nnz]\n return H0\n\n def c_ops(self, modes=None, clean=True):\n \"\"\"Returns a list of collapse operators corresponding to\n loss (decay/excitation) and dephasing of all modes.\n\n Args:\n modes (optional, list[Mode]): List of Modes to use in\n constructing H0. If None, will use self.active_modes.\n Default: None.\n clean (optional, bool): Only keep operators with nonzero elements.\n Default: True.\n\n Returns:\n list[qutip.Qobj]: List of all collapse operators.\n \"\"\"\n if modes is None:\n modes = self.active_modes\n decay = [mode.decay for mode in modes]\n excitation = [mode.excitation for mode in modes]\n dephasing = [mode.dephasing for mode in modes]\n c_ops = decay + excitation + dephasing\n if clean:\n return [c for c in c_ops if c.data.nnz]\n return c_ops\n\n def as_dict(self, json_friendly=False):\n \"\"\"Overrides Parameterized.as_dict() in order to deal with cross_kerrs.\n\n Args:\n json_friendly (optional, bool): Whether to return\n a JSON-friendly dictionary. Default:True.\n\n Returns:\n dict: Dictionary representation of the System object.\n \"\"\"\n d = super().as_dict(json_friendly=json_friendly)\n cross_kerrs = d.pop(\"cross_kerrs\")\n d[\"cross_kerrs\"] = {}\n if json_friendly:\n # turn frozenset({mode0, mode1}) into '{mode0, mode1}' for json\n for key, val in cross_kerrs.items():\n new_key = \"{\" + \", \".join(key) + \"}\"\n d[\"cross_kerrs\"][new_key] = val\n else:\n for key, val in cross_kerrs.items():\n d[\"cross_kerrs\"][key] = val\n return d\n\n @classmethod\n def from_json(cls, json_path=None, json_str=None):\n \"\"\"Overrides Parameterized.from_json()\n in order to deal with cross_kerrs.\n\n Args:\n json_path (optional, str): Path to JSON file from which\n to load parameters. Required if ``json_str`` is ``None``.\n Default: None.\n json_str (optional, str): JSON string like that returned by\n ``self.to_json(dumps=True)``. Required if ``json_path``\n is ``None`` Default: None.\n\n Returns:\n System: Instance of ``System``\n whose parameters have been populated from the JSON data.\n \"\"\"\n\n def json_decode(obj):\n # decode CrossKerr\n for key in list(obj):\n if re.match(r\"\\{(.*?)\\}\", key):\n # turn '{mode0, mode1}' into frozenset({mode0, mode1})\n k = key.replace(\"{\", \"\").replace(\"}\", \"\").split(\", \")\n new_key = frozenset(k)\n obj[new_key] = obj[key]\n del obj[key]\n return obj\n\n if json_str is not None:\n if json_path is not None:\n raise ValueError(\n \"You must provide either json_path \" \"or json_str, not both.\"\n )\n d = json.loads(json_str, object_hook=json_decode)\n else:\n if json_path is None:\n raise ValueError(\"You must provide either json_path \" \"or json_str.\")\n if not json_path.endswith(\".json\"):\n json_path = json_path + \".json\"\n with open(json_path, \"r\") as f:\n d = json.load(f, object_hook=json_decode)\n\n return cls.from_dict(d)\n", "meta": {"hexsha": "e4c00db13b875aadb2706bb663b5badbfc20dd3b", "size": 18679, "ext": "py", "lang": "Python", "max_stars_repo_path": "sequencing/system.py", "max_stars_repo_name": "ypeels/sequencing", "max_stars_repo_head_hexsha": "3d00a60ae94164422bb891dac35d686dbc3a1210", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "sequencing/system.py", "max_issues_repo_name": "ypeels/sequencing", "max_issues_repo_head_hexsha": "3d00a60ae94164422bb891dac35d686dbc3a1210", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "sequencing/system.py", "max_forks_repo_name": "ypeels/sequencing", "max_forks_repo_head_hexsha": "3d00a60ae94164422bb891dac35d686dbc3a1210", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.6974459725, "max_line_length": 87, "alphanum_fraction": 0.5635205311, "include": true, "reason": "import numpy", "num_tokens": 4166, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792046, "lm_q2_score": 0.38121956625614994, "lm_q1q2_score": 0.19358781864024524}} {"text": "\"\"\"\nCopyright 2020 The OneFlow Authors. All rights reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n\"\"\"\nimport math\n\nimport oneflow as flow\nfrom oneflow.nn import init\nfrom oneflow.nn.common_types import _size_2_t\nfrom oneflow.nn.module import Module\nfrom oneflow.nn.modules.utils import _pair\n\n\ndef slice(x, begin, size):\n ndim = len(x.shape)\n if not isinstance(begin, (list, tuple)) or len(begin) != ndim:\n raise ValueError(\n \"begin must be a list/tuple with the same length as input tensor's number of dimensions\"\n )\n if not all((isinstance(b, int) or b is None for b in begin)):\n raise ValueError(\"element of begin must be a int or None\")\n if not isinstance(size, (list, tuple)) or len(size) != ndim:\n raise ValueError(\n \"size must be a list/tuple with the same length as input tensor's number of dimensions.\"\n )\n if not all((isinstance(s, int) or s is None for s in size)):\n raise ValueError(\"element of size must be a int or None\")\n slice_tup_list = []\n for (b, s, dim_size) in zip(begin, size, x.shape):\n (start, stop, step) = (None, None, 1)\n if b is not None:\n if b < -dim_size or b >= dim_size:\n raise ValueError(\"element of begin is out of range\")\n start = b\n if s is not None:\n if s == -1:\n stop = dim_size\n else:\n if s <= 0 or s > dim_size:\n raise ValueError(\"element of size is invalid\")\n if b + s < dim_size:\n stop = b + s\n slice_tup_list.append((start, stop, step))\n return flow.slice(x, slice_tup_list)\n\n\nclass ConvUtil(object):\n @classmethod\n def split(cls, x, axis, split_num):\n split_len = x.shape[axis] // split_num\n result_list = []\n slice_begin = [0] * len(x.shape)\n slice_size = [-1] * len(x.shape)\n slice_size[axis] = split_len\n for i in range(split_num):\n slice_begin[axis] = i * split_len\n result = slice(x, slice_begin, slice_size)\n result_list.append(result)\n return result_list\n\n\nclass ConvTranspose2d(Module):\n \"\"\"\n \n Applies a 2D transposed convolution operator over an input image composed of several input planes.\n\n This module can be seen as the gradient of Conv2d with respect to its input.\n It is also known as a fractionally-strided convolution or\n a deconvolution (although it is not an actual deconvolution operation).\n\n Args:\n in_channels (int): Number of channels in the input image\n out_channels (int): Number of channels produced by the convolution\n kernel_size (int or tuple): Size of the convolving kernel\n stride (int or tuple, optional): Stride of the convolution. Default: 1\n padding (int or tuple, optional): ``dilation * (kernel_size - 1) - padding`` zero-padding\n will be added to both sides of each dimension in the input. Default: 0\n output_padding (int or tuple, optional): Additional size added to one side\n of each dimension in the output shape. Default: 0\n groups (int, optional): Number of blocked connections from input channels to output channels. Default: 1\n bias (bool, optional): If ``True``, adds a learnable bias to the output. Default: ``True``\n dilation (int or tuple, optional): Spacing between kernel elements. Default: 1\n\n Shape:\n - Input: :math:`(N, C_{in}, H_{in}, W_{in})`\n - Output: :math:`(N, C_{out}, H_{out}, W_{out})` where\n\n .. math::\n H_{out} = (H_{in} - 1) \\\\times \\\\text{stride}[0] - 2 \\\\times \\\\text{padding}[0] + \\\\text{dilation}[0] \n\n \\\\times (\\\\text{kernel_size}[0] - 1) + \\\\text{output_padding}[0] + 1\n .. math::\n W_{out} = (W_{in} - 1) \\\\times \\\\text{stride}[1] - 2 \\\\times \\\\text{padding}[1] + \\\\text{dilation}[1]\n \n \\\\times (\\\\text{kernel_size}[1] - 1) + \\\\text{output_padding}[1] + 1\n\n Attributes:\n ConvTranspose2d.weight (Tensor): the learnable weights of the module of shape\n :math:`(\\\\text{in_channels}, \\\\frac{\\\\text{out_channels}}{\\\\text{groups}},`\n :math:`\\\\text{kernel_size[0]}, \\\\text{kernel_size[1]})`.\n The values of these weights are sampled from\n :math:`\\\\mathcal{U}(-\\\\sqrt{k}, \\\\sqrt{k})` where\n :math:`k = \\\\frac{groups}{C_\\\\text{out} * \\\\prod_{i=0}^{1}\\\\text{kernel_size}[i]}`\n ConvTranspose2d.bias (Tensor): the learnable bias of the module of shape (out_channels)\n If :attr:`bias` is ``True``, then the values of these weights are\n sampled from :math:`\\\\mathcal{U}(-\\\\sqrt{k}, \\\\sqrt{k})` where\n :math:`k = \\\\frac{groups}{C_\\\\text{out} * \\\\prod_{i=0}^{1}\\\\text{kernel_size}[i]}`\n\n Examples::\n\n >>> import numpy as np\n >>> import oneflow as flow\n >>> import oneflow.nn as nn\n \n >>> m = nn.ConvTranspose2d(16, 33, 3, stride=2)\n >>> # non-square kernels and unequal stride and with padding\n >>> m = nn.ConvTranspose2d(16, 33, (3, 5), stride=(2, 1), padding=(4, 2))\n >>> m = m.to(\"cuda\")\n >>> input = flow.Tensor(np.random.randn(20, 16, 50, 100), device=flow.device(\"cuda\"))\n >>> output = m(input)\n >>> output.size()\n flow.Size([20, 33, 93, 100])\n\n .. _cross-correlation:\n https://en.wikipedia.org/wiki/Cross-correlation\n\n .. _link:\n https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md\n \"\"\"\n\n def __init__(\n self,\n in_channels: int,\n out_channels: int,\n kernel_size: _size_2_t,\n stride: _size_2_t = 1,\n padding: _size_2_t = 0,\n output_padding: _size_2_t = 0,\n groups: int = 1,\n bias: bool = True,\n dilation: int = 1,\n padding_mode: str = \"zeros\",\n ) -> None:\n super().__init__()\n assert padding_mode == \"zeros\"\n kernel_size = _pair(kernel_size)\n stride = _pair(stride)\n padding = _pair(padding)\n output_padding = _pair(output_padding)\n dilation = _pair(dilation)\n self.groups = groups\n assert in_channels % groups == 0\n assert out_channels % groups == 0\n self.weight = flow.nn.Parameter(\n flow.Tensor(in_channels, out_channels // groups, *kernel_size)\n )\n self.in_channel_groups = in_channels // groups\n self.bias = None\n self._bias_add_op = None\n if bias:\n self.bias = flow.nn.Parameter(flow.Tensor(out_channels))\n self._bias_add_op = (\n flow.builtin_op(\"bias_add\")\n .Input(\"a\")\n .Input(\"b\")\n .Output(\"out\")\n .Attr(\"axis\", 1)\n .Build()\n )\n self._op = (\n flow.builtin_op(\"deconv2d\")\n .Input(\"in\")\n .Input(\"weight\")\n .Attr(\"filters\", out_channels // groups)\n .Attr(\"padding_before\", padding)\n .Attr(\"data_format\", \"channels_first\")\n .Attr(\"kernel_size\", kernel_size)\n .Attr(\"strides\", stride)\n .Attr(\"dilation_rate\", dilation)\n .Attr(\"output_padding\", output_padding)\n .Attr(\"groups\", 1)\n .Output(\"out\")\n .Build()\n )\n self.reset_parameters()\n\n def reset_parameters(self) -> None:\n init.kaiming_uniform_(self.weight, a=math.sqrt(5))\n if self.bias is not None:\n (fan_in, _) = init._calculate_fan_in_and_fan_out(self.weight)\n bound = 1 / math.sqrt(fan_in)\n init.uniform_(self.bias, -bound, bound)\n\n def forward(self, x):\n if self.groups > 1:\n in_channel_axis = 1\n in_split_list = ConvUtil.split(\n x, axis=in_channel_axis, split_num=self.groups\n )\n out_list = []\n for i in range(len(in_split_list)):\n out_list.append(\n self._op(\n in_split_list[i],\n self.weight[\n i\n * self.in_channel_groups : (i + 1)\n * self.in_channel_groups,\n :,\n :,\n :,\n ],\n )[0]\n )\n res = flow.cat(out_list, dim=in_channel_axis)\n else:\n res = self._op(x, self.weight)[0]\n if self._bias_add_op is not None:\n res = self._bias_add_op(res, self.bias)[0]\n return res\n\n\nif __name__ == \"__main__\":\n import doctest\n\n doctest.testmod(raise_on_error=True)\n", "meta": {"hexsha": "e69794aea2a37bbb86fa10e7c0e7d7b120f9e09e", "size": 9388, "ext": "py", "lang": "Python", "max_stars_repo_path": "python/oneflow/nn/modules/deconv.py", "max_stars_repo_name": "wangyuyue/oneflow", "max_stars_repo_head_hexsha": "0a71c22fe8355392acc8dc0e301589faee4c4832", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-13T02:34:53.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-13T02:34:53.000Z", "max_issues_repo_path": "python/oneflow/nn/modules/deconv.py", "max_issues_repo_name": "wangyuyue/oneflow", "max_issues_repo_head_hexsha": "0a71c22fe8355392acc8dc0e301589faee4c4832", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "python/oneflow/nn/modules/deconv.py", "max_forks_repo_name": "wangyuyue/oneflow", "max_forks_repo_head_hexsha": "0a71c22fe8355392acc8dc0e301589faee4c4832", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-01-17T03:34:39.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-17T03:34:39.000Z", "avg_line_length": 39.4453781513, "max_line_length": 116, "alphanum_fraction": 0.5609288453, "include": true, "reason": "import numpy", "num_tokens": 2289, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792044, "lm_q2_score": 0.38121956625614994, "lm_q1q2_score": 0.1935878186402452}} {"text": "#!/usr/bin/env python3\n\"\"\"Compute a background mask for X-ray microscopy data.\n\nFunctions\n---------\nparse_args\n Parse command line arguments.\ninitialize_cloudvolume\n Create a new CloudVolume archive.\nload_image\n Load an image from CloudVolume.\ncreate_bg_mask\n Create a mask of background regions in x-ray microscopy.\nwrite_image\n Write an image to CloudVolume.\n\nDependencies\n------------\ncloud-volume\nmpi4py\nnumpy\nscipy\nscikit-image\n\"\"\"\n\nimport argparse\nimport logging\nimport os\nimport re\n\nfrom cloudvolume import CloudVolume\nfrom mpi4py import MPI\nimport numpy as np\nfrom scipy.signal import find_peaks, peak_prominences, peak_widths\nfrom skimage.exposure import histogram\nfrom skimage.filters import gaussian\nfrom skimage.measure import label, regionprops\nfrom skimage.morphology import remove_small_holes\n\n\nCOMM = MPI.COMM_WORLD\nRANK = COMM.Get_rank()\nSIZE = COMM.Get_size()\n\nLOGGER = logging.getLogger('create_background_mask.py')\nsyslog = logging.StreamHandler()\nformatter = logging.Formatter('%(asctime)s %(name)s Rank %(rank)s : %(message)s')\nsyslog.setFormatter(formatter)\nLOGGER.setLevel(logging.INFO)\nLOGGER.addHandler(syslog)\nLOGGER = logging.LoggerAdapter(LOGGER, {'rank': str(RANK)})\n\n\ndef parse_args():\n \"\"\"Parse command line arguments.\"\"\"\n p = argparse.ArgumentParser()\n\n p.add_argument('--input', type=str,\n help='path to the CloudVolume archive')\n p.add_argument('--output', type=str,\n help='path to the bg mask CloudVolume archive')\n p.add_argument('--resolution', type=int, nargs='*', default=[10, 10, 10],\n help='resolution of the dataset')\n p.add_argument('--mip', type=int, default=0,\n help='number of mip levels to create')\n p.add_argument('--chunk-size', type=int, nargs='*', default=[64, 64, 64],\n help='size of each CloudVolume block file')\n p.add_argument('--z-step', type=int, default=None)\n p.add_argument('--factor', type=int, nargs='*', default=[2, 2, 2],\n help='factor to scale between mip levels')\n p.add_argument('--flip-xy', action='store_true',\n help='pass to transplose the X and Y axes')\n p.add_argument('--memory-limit', type=float, default=10000,\n help='max memory available to CloudVolume')\n p.add_argument('--offset', type=int, nargs='*', default=[0, 0, 0],\n help='offset into the volume from the upper-left corner')\n p.add_argument('--quiet', action='store_true',\n help='pass to deactivate logging')\n\n return p.parse_args()\n\n\ndef initialize_cloudvolume(path, resolution, offset, volume_size, chunk_size,\n mip, factor):\n \"\"\"Create a new CloudVolume archive.\n\n Parameters\n ----------\n path : str\n Filepath to the location to write the archive.\n resolution : tuple of int\n Imaging resolution of the images in each dimension.\n offset : tuple of int\n Offset within the volume to the start of the archive.\n volume_size : tuple of int\n The dimensions of the volume in pixels.\n chunk_size : tuple of int\n The size of each CloudVolume block in pixels.\n mip : int\n The number of mip levels to include.\n factor : tuple of int\n The factor of change in each dimension across mip levels.\n\n Returns\n -------\n cv_args : dict\n The parameters needed to re-access the CloudVolume archive.\n \"\"\"\n # Set the parameters of the info file.\n info = CloudVolume.create_new_info(\n num_channels=1,\n layer_type='segmentation',\n data_type='uint32',\n encoding='compressed_segmentation',\n resolution=resolution,\n voxel_offset=offset,\n volume_size=volume_size[:-1],\n chunk_size=chunk_size,\n max_mip=0,\n factor=factor\n )\n\n # Set up and initialize the CloudVolume object\n cv_args = dict(\n bounded=True, fill_missing=True, autocrop=False,\n cache=False, compress_cache=None, cdn_cache=False,\n progress=False, info=info, provenance=None, compress=True,\n non_aligned_writes=True, parallel=1)\n\n # for i in range(1, mip + 1):\n # info['scales'][i]['compressed_segmentation_block_size'] = \\\n # info['scales'][0]['compressed_segmentation_block_size']\n\n cv = CloudVolume(path, mip=0, **cv_args)\n\n # Create the info file.\n LOGGER.info('Initializing image layer with config {}'.format(cv_args))\n cv.commit_info()\n return cv_args\n\n\ndef load_subvolume(cv, z_start, z_end, flip_xy=False):\n \"\"\"Load an image from CloudVolume.\n\n Parameters\n ----------\n cv : cloudvolume.CloudVolume\n CloudVolume image layer to mask.\n z_start : int\n The index of the first image in the layer.\n z_end : int\n The index of the last image in the layer.\n flip_xy : bool\n CloudVolume reorders the dimension of image volumes, and the order of\n the x and y dimensions can vary. If True, indicates that the CloudVolume\n layer is saved in (Y, X, Z) order; otherwise it is saved as (X, Y, Z).\n\n Returns\n -------\n subvol : numpy.ndarray\n The subvolume with the dimensions reordered as (Z, Y, X).\n \"\"\"\n # Each entry in the z dimension represents one image. Extract an image.\n subvol = cv[:, :, z_start:z_end, :]\n subvol = np.squeeze(subvol)\n\n # Transpose the dimensions back to\n if not flip_xy:\n subvol = np.transpose(subvol, axes=[2, 1, 0])\n\n LOGGER.info('Loaded subvolume with shape {}.'.format(subvol.shape))\n return subvol\n\n\ndef find_bg_mask(img):\n \"\"\"Create a mask of background regions in x-ray microscopy.\n\n Parameters\n ----------\n img : numpy.ndarray\n X-ray microscopy image.\n\n Returns\n -------\n bgmask : numpy.ndarray\n Binary mask of the background of ``img``.\n \"\"\"\n if img.ndim == 2:\n img = np.expand_dims(img, axis=0)\n\n bgmask = np.zeros((3,) +img.shape, dtype=np.uint8)\n\n for d in range(img.ndim):\n for i in range(img.shape[d]):\n if d == 0:\n subimg = img[i, :, :]\n elif d == 1:\n subimg = img[:, i, :]\n elif d == 2:\n subimg = img[:, :, i]\n\n # Blur the image to smooth any background artifacts.\n LOGGER.info('Blurring image.')\n blur = gaussian(subimg, sigma=5, preserve_range=True)\n\n # Compute the image histogram and find the peaks.\n LOGGER.info('Finding histogram peaks.')\n hist, bins = histogram(blur)\n peaks, properties = find_peaks(hist) # , height=(0.3 * img.size))\n prominences = peak_prominences(hist, peaks)\n widths = peak_widths(hist, peaks, rel_height=0.333,\n prominence_data=prominences)\n\n # Select the left-most peak (backgrounds are usually dark) and use the\n # width of the peak to select a threshold value. Create a mask of all\n # pixels less than or equal to the threshold.\n ordered = np.argsort(peaks)\n threshold = peaks[ordered[0]] + (widths[0][ordered[0]] / 2.0)\n # threshold = peaks[0] + (widths[0][0] / 2.0)\n LOGGER.info('Setting hard threshold {} for image.'.format(threshold))\n mask = np.zeros(subimg.shape, dtype=np.uint8)\n mask[np.where(subimg <= threshold)] = 1\n # Perform some clean up and find the largest connected component.\n LOGGER.info('Cleaning mask of image.')\n # remove_small_holes(mask, area_threshold=30, connectivity=2,\n # in_place=True)\n labels = label(mask)\n objs = regionprops(labels)\n # bg = None\n # for obj in objs:\n # if obj.bbox_area >= 0.85 * img.size:\n # coords = obj.coords\n # break\n\n # Select the connected component with the largest bounding box as the\n # background mask.\n objs.sort(key=lambda x: x.bbox_area, reverse=True)\n # objs = [o for o in objs\n # if np.any(np.asarray(o.bbox[:mask.ndim]) == np.asarray(mask.shape))\n # or np.any(np.asarray(o.bbox[mask.ndim:]) == 0)]\n print(len(objs))\n if len(objs) > 0:\n coords = tuple([objs[0].coords[:, j] for j in range(subimg.ndim)])\n LOGGER.info('Setting background mask of image.')\n\n if d == 0:\n bgmask[d, i, coords[0], coords[1]] = 1\n elif d == 1:\n bgmask[d, coords[0], i, coords[1]] = 1\n elif d == 2:\n bgmask[d, coords[0], coords[1], i] = 1\n LOGGER.info('Full background mask covers {} voxels.'.format(np.sum(bgmask)))\n\n consensus = bgmask[0] + bgmask[1] + bgmask[2]\n consensus[np.where(consensus == 1)] = 0\n consensus[consensus.nonzero()] = 1\n objs = sorted(regionprops(label(consensus)), key=lambda x: x.bbox_area, reverse=True)\n for obj in objs[1:]:\n coords = tuple([obj.coords[:, j] for j in range(img.ndim)])\n consensus[coords] = 0\n\n LOGGER.info('Full background mask covers {} voxels.'.format(np.sum(consensus)))\n return consensus.astype(np.uint32)\n\n\ndef write_subvolume(path, subvolume, flip_xy, z_start, mip, factor):\n \"\"\"Write an image to CloudVolume.\n\n Parameter\n ---------\n path : str\n Filepath to the location to write the archive.\n subvolume : numpy.ndarray\n Image data to write to the archive.\n flip_xy : bool\n If True, order ``layer`` as [Y, X, Z]. Otherwise, order ``layer`` as\n [X, Y, Z].\n z_start\n The starting index of ``layer`` within the archive.\n mip\n The number of mip levels to compute.\n factor\n The factor by which to reduce each mip level along each dimension.\n \"\"\"\n # Transpose the axes to match the CloudVolume order\n if subvolume.ndim == 2:\n subvolume = np.expand_dims(subvolume, 0)\n\n if flip_xy:\n subvolume = np.transpose(subvolume, axes=[1, 2, 0])\n else:\n subvolume = np.transpose(subvolume, axes=[2, 1, 0])\n\n if subvolume.ndim == 3:\n subvolume = np.expand_dims(subvolume, -1)\n\n cv_args = dict(\n bounded=True, fill_missing=True, autocrop=False,\n cache=False, compress_cache=None, cdn_cache=False,\n progress=False, info=None, provenance=None, compress=True,\n non_aligned_writes=True, parallel=1)\n\n # Set the volume for each mip level\n for m in range(1):\n # Access the CloudVolume\n LOGGER.info('Writing MIP level {}.'.format(mip))\n cv = CloudVolume(path, mip=m, **cv_args)\n\n # Compute the index of this layer in the CloudVolume archive\n offset = cv.mip_voxel_offset(m)\n step = np.power(np.array(factor), m)\n cv_z_start = int(z_start // step[2] + offset[2])\n cv_z_end = int(min(cv_z_start + subvolume.shape[-2], cv.shape[-2]))\n\n # Set the layer\n cv[:, :, cv_z_start:cv_z_end] = subvolume\n\n # Reduce the size of the layer to match the next mip level\n subvolume = subvolume[::factor[0], ::factor[1], ::factor[2]]\n\n\ndef create_background_mask(input, output, resolution=(10, 10, 10), mip=0,\n chunk_size=(64, 64, 64), z_step=None,\n factor=(2, 2, 2), flip_xy=False, memory_limit=10000,\n offset=(0, 0, 0), quiet=False):\n \"\"\"Create and write data to a new CloudVolume archive.\"\"\"\n if quiet:\n LOGGER.logger.removeHandler(syslog)\n noop = logging.NullHandler()\n LOGGER.logger.addHandler(noop)\n\n if 'image' not in os.path.basename(input):\n inpath = input + '/image'\n else:\n inpath = input\n\n if os.path.isdir(inpath) and not re.search(r'^file://', inpath):\n inpath = 'file://' + os.path.abspath(inpath)\n\n if RANK == 0:\n LOGGER.info('Loading CloudVolume image layer {}.'.format(inpath))\n\n img_cv = CloudVolume(inpath)\n volume_shape = img_cv.shape\n\n outpath = os.path.abspath(output)\n\n if os.path.dirname(inpath) == outpath:\n outpath = outpath + 'background'\n\n if not re.search(r'^[\\w]+://.+$', outpath):\n outpath = 'file://' + os.path.abspath(output)\n\n # On rank 0, initialize the CloudVolume info file, and load in the list of\n # images to insert into the archive.\n if RANK == 0:\n LOGGER.info('Initialized CloudVolume image layer at {}'.format(outpath))\n cv_args = initialize_cloudvolume(\n outpath,\n resolution,\n offset,\n volume_shape,\n chunk_size,\n mip,\n factor)\n\n # Block until the background CloudVolume layer is initialized.\n GOGOGO = COMM.bcast(1, root=0)\n\n # Iterate over layers of the volume. Each rank will load and write one\n # layer at a time. If there are fewer ranks than layers, increment to\n # n_ranks + rank and load the layer at that index.\n # offset from the volume origin.\n layer_idx = RANK * chunk_size[-1]\n while layer_idx < volume_shape[-2]:\n # Compute the index of the first image in this layer, including any\n layer_shape = int(min(layer_idx + chunk_size[-1],\n img_cv.shape[-2]))\n LOGGER.info('Loading images {}-{}.'.format(layer_idx, layer_shape))\n image = load_subvolume(img_cv, layer_idx, layer_shape,\n flip_xy=flip_xy)\n\n LOGGER.info('Creating background mask.')\n mask = find_bg_mask(image)\n\n # Write the layer to the archive.\n LOGGER.info('Writing mask of images {}-{}'.format(layer_idx, layer_shape))\n write_subvolume(\n outpath,\n mask,\n flip_xy,\n layer_idx,\n mip,\n factor)\n\n # Increment to the next known layer that does not overlap with any\n # other rank.\n layer_idx += SIZE * chunk_size[-1]\n\n LOGGER.info('Done.')\n\n\ndef main():\n args = parse_args()\n create_background_mask(\n args.input,\n args.output,\n resolution=args.resolution,\n mip=args.mip,\n chunk_size=args.chunk_size,\n z_step=args.z_step,\n factor=args.factor,\n flip_xy=args.flip_xy,\n memory_limit=args.memory_limit,\n offset=args.offset,\n quiet=args.quiet)\n\n\nif __name__ == '__main__':\n main()\n", "meta": {"hexsha": "0d043a43e7db9289c34e26d5014e85241aadfddf", "size": 14526, "ext": "py", "lang": "Python", "max_stars_repo_path": "happyneuron/background/create_background_mask.py", "max_stars_repo_name": "jeffkinnison/HappyNeuron", "max_stars_repo_head_hexsha": "66ad1c3dc8fc89b518fe74e8318c5ba6d79b8f0a", "max_stars_repo_licenses": ["BSD-Source-Code"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-01-31T12:21:57.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-16T09:20:10.000Z", "max_issues_repo_path": "happyneuron/background/create_background_mask.py", "max_issues_repo_name": "jeffkinnison/HappyNeuron", "max_issues_repo_head_hexsha": "66ad1c3dc8fc89b518fe74e8318c5ba6d79b8f0a", "max_issues_repo_licenses": ["BSD-Source-Code"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "happyneuron/background/create_background_mask.py", "max_forks_repo_name": "jeffkinnison/HappyNeuron", "max_forks_repo_head_hexsha": "66ad1c3dc8fc89b518fe74e8318c5ba6d79b8f0a", "max_forks_repo_licenses": ["BSD-Source-Code"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-09-16T09:33:12.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-16T09:33:12.000Z", "avg_line_length": 34.5035629454, "max_line_length": 89, "alphanum_fraction": 0.6043645876, "include": true, "reason": "import numpy,from scipy", "num_tokens": 3414, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792044, "lm_q2_score": 0.38121956625614994, "lm_q1q2_score": 0.1935878186402452}} {"text": "# Copyright 2018-2021 Xanadu Quantum Technologies Inc.\r\n\r\n# Licensed under the Apache License, Version 2.0 (the \"License\");\r\n# you may not use this file except in compliance with the License.\r\n# You may obtain a copy of the License at\r\n\r\n# http://www.apache.org/licenses/LICENSE-2.0\r\n\r\n# Unless required by applicable law or agreed to in writing, software\r\n# distributed under the License is distributed on an \"AS IS\" BASIS,\r\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n# See the License for the specific language governing permissions and\r\n# limitations under the License.\r\n\"\"\"Function wrappers for the TensorBox API\"\"\"\r\n# pylint:disable=abstract-class-instantiated,unexpected-keyword-arg\r\nfrom collections.abc import Sequence\r\nimport itertools\r\nimport warnings\r\n\r\nimport numpy as np\r\n\r\nfrom .tensorbox import TensorBox\r\n\r\n\r\ndef _get_multi_tensorbox(values):\r\n \"\"\"Determines the correct framework to dispatch to given a\r\n sequence of tensor-like objects.\r\n\r\n Args:\r\n values (Sequence[tensor_like]): a sequence of tensor like objects\r\n\r\n Returns:\r\n .TensorBox: A TensorBox that will dispatch to the correct framework\r\n given the rules of precedence. This TensorBox will contain the *first*\r\n tensor-like object in ``values`` that corresponds to the highest-priority\r\n framework.\r\n\r\n To determine the framework to dispatch to, the following rules\r\n are applied:\r\n\r\n * Tensors that are incompatible (such as Torch and TensorFlow tensors)\r\n cannot both be present.\r\n\r\n * Autograd tensors *may* be present alongside Torch and TensorFlow tensors,\r\n but Torch and TensorFlow take precendence; the autograd arrays will\r\n be treated as non-differentiable NumPy arrays. A warning will be raised\r\n suggesting that vanilla NumPy be used instead.\r\n\r\n * Vanilla NumPy arrays can be used alongside other tensor objects; they will\r\n always be treated as non-differentiable constants.\r\n \"\"\"\r\n interfaces = [get_interface(v) for v in values]\r\n\r\n if len(set(interfaces) - {\"numpy\", \"autograd\"}) > 1:\r\n # contains multiple non-autograd interfaces\r\n raise ValueError(\"Tensors contain mixed types; cannot determine dispatch library\")\r\n\r\n non_numpy_interfaces = set(interfaces) - {\"numpy\"}\r\n\r\n if len(non_numpy_interfaces) > 1:\r\n # contains autograd and another interface\r\n warnings.warn(\r\n f\"Contains tensors of types {non_numpy_interfaces}; dispatch will prioritize \"\r\n \"TensorFlow and PyTorch over autograd. Consider replacing Autograd with vanilla NumPy.\",\r\n UserWarning,\r\n )\r\n\r\n if \"tf\" in interfaces:\r\n return TensorBox(values[interfaces.index(\"tf\")])\r\n\r\n if \"torch\" in interfaces:\r\n return TensorBox(values[interfaces.index(\"torch\")])\r\n\r\n if \"autograd\" in interfaces:\r\n return TensorBox(values[interfaces.index(\"autograd\")])\r\n\r\n if \"jax\" in interfaces:\r\n return TensorBox(values[interfaces.index(\"jax\")])\r\n\r\n return TensorBox(values[interfaces.index(\"numpy\")])\r\n\r\n\r\ndef abs_(tensor):\r\n \"\"\"Returns the element-wise absolute value.\r\n\r\n Args:\r\n tensor (tensor_like): input tensor\r\n\r\n Returns:\r\n tensor_like:\r\n\r\n **Example**\r\n\r\n >>> a = torch.tensor([1., -2.], requires_grad=True)\r\n >>> abs(a)\r\n tensor([1., 2.], grad_fn=)\r\n \"\"\"\r\n return TensorBox(tensor).abs(wrap_output=False)\r\n\r\n\r\ndef allequal(tensor1, tensor2, **kwargs):\r\n \"\"\"Returns True if two tensors are element-wise equal along a given axis.\r\n\r\n This function is equivalent to calling ``np.all(tensor1 == tensor2, **kwargs)``,\r\n but allows for ``tensor1`` and ``tensor2`` to differ in type.\r\n\r\n Args:\r\n tensor1 (tensor_like): tensor to compare\r\n tensor2 (tensor_like): tensor to compare\r\n **kwargs: Accepts any keyword argument that is accepted by ``np.all``,\r\n such as ``axis``, ``out``, and ``keepdims``. See the `NumPy documentation\r\n `__ for\r\n more details.\r\n\r\n Returns:\r\n ndarray, bool: If ``axis=None``, a logical AND reduction is applied to all elements\r\n and a boolean will be returned, indicating if all elements evaluate to True. Otherwise,\r\n a boolean NumPy array will be returned.\r\n\r\n **Example**\r\n\r\n >>> a = torch.tensor([1, 2])\r\n >>> b = np.array([1, 2])\r\n >>> allequal(a, b)\r\n True\r\n \"\"\"\r\n t1 = toarray(tensor1)\r\n t2 = toarray(tensor2)\r\n return np.all(t1 == t2, **kwargs)\r\n\r\n\r\ndef allclose(a, b, rtol=1e-05, atol=1e-08, **kwargs):\r\n \"\"\"Wrapper around np.allclose, allowing tensors ``a`` and ``b``\r\n to differ in type\"\"\"\r\n t1 = toarray(a)\r\n t2 = toarray(b)\r\n return np.allclose(t1, t2, rtol=rtol, atol=atol, **kwargs)\r\n\r\n\r\nallclose.__doc__ = np.allclose.__doc__\r\n\r\n\r\ndef angle(tensor):\r\n \"\"\"Returns the element-wise angle of a complex tensor.\r\n\r\n Args:\r\n tensor (tensor_like): input tensor\r\n\r\n Returns:\r\n tensor_like:\r\n\r\n **Example**\r\n\r\n >>> a = torch.tensor([1.0, 1.0j, 1+1j], requires_grad=True)\r\n >>> angle(a)\r\n tensor([0.0000, 1.5708, 0.7854], grad_fn=)\r\n \"\"\"\r\n return TensorBox(tensor).angle(wrap_output=False)\r\n\r\n\r\ndef arcsin(tensor):\r\n \"\"\"Returns the element-wise inverse sine of the tensor\"\"\"\r\n return TensorBox(tensor).arcsin(wrap_output=False)\r\n\r\n\r\ndef block_diag(values):\r\n \"\"\"Combine a sequence of 2D tensors to form a block diagonal tensor.\r\n\r\n Args:\r\n values (Sequence[tensor_like]): Sequence of 2D arrays/tensors to form\r\n the block diagonal tensor.\r\n\r\n Returns:\r\n tensor_like: the block diagonal tensor\r\n\r\n **Example**\r\n\r\n >>> t = [\r\n ... np.array([[1, 2], [3, 4]]),\r\n ... torch.tensor([[1, 2, 3], [-1, -6, -3]]),\r\n ... torch.tensor(5)\r\n ... ]\r\n >>> qml.math.block_diag(t)\r\n tensor([[ 1, 2, 0, 0, 0, 0],\r\n [ 3, 4, 0, 0, 0, 0],\r\n [ 0, 0, 1, 2, 3, 0],\r\n [ 0, 0, -1, -6, -3, 0],\r\n [ 0, 0, 0, 0, 0, 5]])\r\n \"\"\"\r\n return _get_multi_tensorbox(values).block_diag(values, wrap_output=False)\r\n\r\n\r\ndef cast(tensor, dtype):\r\n \"\"\"Casts the given tensor to a new type.\r\n\r\n Args:\r\n tensor (tensor_like): tensor to cast\r\n dtype (str, np.dtype): Any supported NumPy dtype representation; this can be\r\n a string (``\"float64\"``), a ``np.dtype`` object (``np.dtype(\"float64\")``), or\r\n a dtype class (``np.float64``). If ``tensor`` is not a NumPy array, the\r\n **equivalent** dtype in the dispatched framework is used.\r\n\r\n Returns:\r\n tensor_like: a tensor with the same shape and values as ``tensor`` and the\r\n same dtype as ``dtype``\r\n\r\n **Example**\r\n\r\n We can use NumPy dtype specifiers:\r\n\r\n >>> x = torch.tensor([1, 2])\r\n >>> cast(x, np.float64)\r\n tensor([1., 2.], dtype=torch.float64)\r\n\r\n We can also use strings:\r\n\r\n >>> x = tf.Variable([1, 2])\r\n >>> cast(x, \"complex128\")\r\n \r\n \"\"\"\r\n return TensorBox(tensor).cast(dtype, wrap_output=False)\r\n\r\n\r\ndef cast_like(tensor1, tensor2):\r\n \"\"\"Casts a tensor to the same dtype as another.\r\n\r\n Args:\r\n tensor1 (tensor_like): tensor to cast\r\n tensor2 (tensor_like): tensor with corresponding dtype to cast to\r\n\r\n Returns:\r\n tensor_like: a tensor with the same shape and values as ``tensor1`` and the\r\n same dtype as ``tensor2``\r\n\r\n **Example**\r\n\r\n >>> x = torch.tensor([1, 2])\r\n >>> y = torch.tensor([3., 4.])\r\n >>> cast(x, y)\r\n tensor([1., 2.])\r\n \"\"\"\r\n dtype = toarray(tensor2).dtype.type\r\n return cast(tensor1, dtype)\r\n\r\n\r\ndef concatenate(values, axis=0):\r\n \"\"\"Concatenate a sequence of tensors along the specified axis.\r\n\r\n .. warning::\r\n\r\n Tensors that are incompatible (such as Torch and TensorFlow tensors)\r\n cannot both be present.\r\n\r\n Args:\r\n values (Sequence[tensor_like]): Sequence of tensor-like objects to\r\n concatenate. The objects must have the same shape, except in the dimension corresponding\r\n to axis (the first, by default).\r\n axis (int): The axis along which the input tensors are concatenated. If axis is None,\r\n tensors are flattened before use. Default is 0.\r\n\r\n Returns:\r\n tensor_like: The concatenated tensor.\r\n\r\n **Example**\r\n\r\n >>> x = tf.constant([0.6, 0.1, 0.6])\r\n >>> y = tf.Variable([0.1, 0.2, 0.3])\r\n >>> z = np.array([5., 8., 101.])\r\n >>> concatenate([x, y, z])\r\n TensorBox: \r\n \"\"\"\r\n return _get_multi_tensorbox(values).concatenate(values, axis=axis, wrap_output=False)\r\n\r\n\r\ndef conj(tensor):\r\n \"\"\"Conjugate a tensor. Negate the imaginary part of a complex value.\r\n\r\n Args:\r\n tensor (tensor_like): A tensor-like object to conjugate.\r\n\r\n Returns:\r\n tensor_like: The conjugated tensor.\r\n\r\n **Example**\r\n\r\n >>> x = tf.constant([0.6 + 0.1j, 0.1 - 0.3j, 0.6])\r\n >>> conj(x)\r\n \r\n \"\"\"\r\n return TensorBox(tensor).conj(wrap_output=False)\r\n\r\n\r\ndef cov_matrix(prob, obs, wires=None, diag_approx=False):\r\n \"\"\"Calculate the covariance matrix of a list of commuting observables, given\r\n the joint probability distribution of the system in the shared eigenbasis.\r\n\r\n .. note::\r\n This method only works for **commuting observables.**\r\n If the probability distribution is the result of a quantum circuit,\r\n the quantum state must be rotated into the shared\r\n eigenbasis of the list of observables before measurement.\r\n\r\n Args:\r\n prob (tensor_like): probability distribution\r\n obs (list[.Observable]): a list of observables for which\r\n to compute the covariance matrix for\r\n diag_approx (bool): if True, return the diagonal approximation\r\n wires (.Wires): The wire register of the system. If not provided,\r\n it is assumed that the wires are labelled with consecutive integers.\r\n\r\n Returns:\r\n tensor_like: the covariance matrix of size ``(len(obs), len(obs))``\r\n\r\n **Example**\r\n\r\n Consider the following ansatz and observable list:\r\n\r\n >>> obs_list = [qml.PauliX(0) @ qml.PauliZ(1), qml.PauliY(2)]\r\n >>> ansatz = qml.templates.StronglyEntanglingLayers\r\n\r\n We can construct a QNode to output the probability distribution in the shared eigenbasis of the\r\n observables:\r\n\r\n .. code-block:: python\r\n\r\n dev = qml.device(\"default.qubit\", wires=3)\r\n\r\n @qml.qnode(dev, interface=\"autograd\")\r\n def circuit(weights):\r\n ansatz(weights, wires=[0, 1, 2])\r\n # rotate into the basis of the observables\r\n for o in obs_list:\r\n o.diagonalizing_gates()\r\n return qml.probs(wires=[0, 1, 2])\r\n\r\n We can now compute the covariance matrix:\r\n\r\n >>> weights = qml.init.strong_ent_layers_normal(n_layers=2, n_wires=3)\r\n >>> cov = qml.math.cov_matrix(circuit(weights), obs_list)\r\n >>> cov\r\n array([[0.98707611, 0.03665537],\r\n [0.03665537, 0.99998377]])\r\n\r\n Autodifferentiation is fully supported using all interfaces.\r\n Here we use autograd:\r\n\r\n >>> cost_fn = lambda weights: qml.math.cov_matrix(circuit(weights), obs_list)[0, 1]\r\n >>> qml.grad(cost_fn)(weights)[0]\r\n array([[[ 4.94240914e-17, -2.33786398e-01, -1.54193959e-01],\r\n [-3.05414996e-17, 8.40072236e-04, 5.57884080e-04],\r\n [ 3.01859411e-17, 8.60411436e-03, 6.15745204e-04]],\r\n [[ 6.80309533e-04, -1.23162742e-03, 1.08729813e-03],\r\n [-1.53863193e-01, -1.38700657e-02, -1.36243323e-01],\r\n [-1.54665054e-01, -1.89018172e-02, -1.56415558e-01]]])\r\n \"\"\"\r\n variances = []\r\n\r\n # diagonal variances\r\n for i, o in enumerate(obs):\r\n l = cast(o.eigvals, dtype=np.float64)\r\n w = o.wires.labels if wires is None else wires.indices(o.wires)\r\n p = marginal_prob(prob, w)\r\n\r\n res = dot(l ** 2, p) - (dot(l, p)) ** 2\r\n variances.append(res)\r\n\r\n cov = diag(variances)\r\n\r\n if diag_approx:\r\n return cov\r\n\r\n for i, j in itertools.combinations(range(len(obs)), r=2):\r\n o1 = obs[i]\r\n o2 = obs[j]\r\n\r\n o1wires = o1.wires.labels if wires is None else wires.indices(o1.wires)\r\n o2wires = o2.wires.labels if wires is None else wires.indices(o2.wires)\r\n shared_wires = set(o1wires + o2wires)\r\n\r\n l1 = cast(o1.eigvals, dtype=np.float64)\r\n l2 = cast(o2.eigvals, dtype=np.float64)\r\n l12 = cast(np.kron(l1, l2), dtype=np.float64)\r\n\r\n p1 = marginal_prob(prob, o1wires)\r\n p2 = marginal_prob(prob, o2wires)\r\n p12 = marginal_prob(prob, shared_wires)\r\n\r\n res = dot(l12, p12) - dot(l1, p1) * dot(l2, p2)\r\n\r\n cov = scatter_element_add(cov, [i, j], res)\r\n cov = scatter_element_add(cov, [j, i], res)\r\n\r\n return cov\r\n\r\n\r\ndef convert_like(tensor1, tensor2):\r\n \"\"\"Convert a tensor to the same type as another.\r\n\r\n Args:\r\n tensor1 (tensor_like): tensor to convert\r\n tensor2 (tensor_like): tensor with corresponding type to convert to\r\n\r\n Returns:\r\n tensor_like: a tensor with the same shape, values, and dtype as ``tensor1`` and the\r\n same type as ``tensor2``.\r\n\r\n **Example**\r\n\r\n >>> x = np.array([1, 2])\r\n >>> y = tf.Variable([3, 4])\r\n >>> cast(x, y)\r\n \r\n \"\"\"\r\n return TensorBox(tensor2).astensor(tensor1)\r\n\r\n\r\ndef diag(values, k=0):\r\n \"\"\"Construct a diagonal tensor from a list of scalars.\r\n\r\n Args:\r\n values (tensor_like or Sequence[scalar]): sequence of numeric values that\r\n make up the diagonal\r\n k (int): The diagonal in question. ``k=0`` corresponds to the main diagonal.\r\n Use ``k>0`` for diagonals above the main diagonal, and ``k<0`` for\r\n diagonals below the main diagonal.\r\n\r\n Returns:\r\n tensor_like: the 2D diagonal tensor\r\n\r\n **Example**\r\n\r\n >>> x = [1., 2., tf.Variable(3.)]\r\n >>> diag(x)\r\n \r\n >>> y = tf.Variable([0.65, 0.2, 0.1])\r\n >>> diag(y, k=-1)\r\n \r\n >>> z = torch.tensor([0.1, 0.2])\r\n >>> qml.diag(z, k=1)\r\n >>> qml.math.diag(z, k=1)\r\n tensor([[0.0000, 0.1000, 0.0000],\r\n [0.0000, 0.0000, 0.2000],\r\n [0.0000, 0.0000, 0.0000]])\r\n \"\"\"\r\n if isinstance(values, Sequence):\r\n return _get_multi_tensorbox(values).diag(values, k=k, wrap_output=False)\r\n\r\n return TensorBox(values).diag(values, k=k, wrap_output=False)\r\n\r\n\r\ndef dot(tensor1, tensor2):\r\n \"\"\"Returns the matrix or dot product of two tensors.\r\n\r\n * If both tensors are 0-dimensional, elementwise multiplication\r\n is performed and a 0-dimensional scalar returned.\r\n\r\n * If both tensors are 1-dimensional, the dot product is returned.\r\n\r\n * If the first array is 2-dimensional and the second array 1-dimensional,\r\n the matrix-vector product is returned.\r\n\r\n * If both tensors are 2-dimensional, the matrix product is returned.\r\n\r\n * Finally, if the the first array is N-dimensional and the second array\r\n M-dimensional, a sum product over the last dimension of the first array,\r\n and the second-to-last dimension of the second array is returned.\r\n\r\n Args:\r\n tensor1 (tensor_like): input tensor\r\n tensor2 (tensor_like): input tensor\r\n \"\"\"\r\n return _get_multi_tensorbox([tensor1, tensor2]).dot(tensor1, tensor2, wrap_output=False)\r\n\r\n\r\ndef expand_dims(tensor, axis):\r\n \"\"\"Expand the shape of an array by adding a new dimension of size 1\r\n at the specified axis location.\r\n\r\n .. warning::\r\n\r\n This function differs from ``np.expand_dims``.\r\n\r\n Args:\r\n tensor (tensor_like): tensor to expand\r\n axis (int): location in the axes to place the new dimension\r\n\r\n Returns:\r\n tensor_like: a tensor with the expanded shape\r\n\r\n **Example**\r\n\r\n >>> x = tf.Variable([3, 4])\r\n >>> expand_dims(x, axis=1)\r\n \r\n \"\"\"\r\n return TensorBox(tensor).expand_dims(axis, wrap_output=False)\r\n\r\n\r\ndef flatten(tensor):\r\n \"\"\"Flattens an N-dimensional tensor to a 1-dimensional tensor.\r\n\r\n Args:\r\n tensor (tensor_like): tensor to flatten\r\n\r\n Returns:\r\n tensor_like: the flattened tensor\r\n\r\n **Example**\r\n\r\n >>> x = tf.Variable([[1, 3], [2, 4]])\r\n >>> flatten(x)\r\n \r\n \"\"\"\r\n return reshape(tensor, (-1,))\r\n\r\n\r\ndef gather(tensor, indices):\r\n \"\"\"Gather tensor values given a tuple of indices.\r\n\r\n This is equivalent to the following NumPy fancy indexing:\r\n\r\n ..code-block:: python\r\n\r\n tensor[array(indices)]\r\n\r\n Args:\r\n tensor (tensor_like): tensor to gather from\r\n indices (Sequence[int]): the indices of the values to extract\r\n\r\n Returns:\r\n\r\n tensor_like: the gathered tensor values\r\n\r\n .. seealso::\r\n\r\n :func:`~.take`\r\n \"\"\"\r\n return TensorBox(tensor).gather(np.array(indices), wrap_output=False)\r\n\r\n\r\ndef get_interface(tensor):\r\n \"\"\"Returns the name of the package that any array/tensor manipulations\r\n will dispatch to. The returned strings correspond to those used for PennyLane\r\n :doc:`interfaces `.\r\n\r\n Args:\r\n tensor (tensor_like): tensor input\r\n\r\n Returns:\r\n str: name of the interface\r\n\r\n **Example**\r\n\r\n >>> x = torch.tensor([1., 2.])\r\n >>> get_interface(x)\r\n 'torch'\r\n >>> from pennylane import numpy as np\r\n >>> x = np.array([4, 5], requires_grad=True)\r\n >>> get_interface(x)\r\n 'autograd'\r\n \"\"\"\r\n return TensorBox(tensor).interface\r\n\r\n\r\ndef marginal_prob(prob, axis):\r\n \"\"\"Compute the marginal probability given a joint probability distribution expressed as a tensor.\r\n Each random variable corresponds to a dimension.\r\n\r\n If the distribution arises from a quantum circuit measured in computational basis, each dimension\r\n corresponds to a wire. For example, for a 2-qubit quantum circuit `prob[0, 1]` is the probability of measuring the\r\n first qubit in state 0 and the second in state 1.\r\n\r\n Args:\r\n prob (tensor_like): 1D tensor of probabilities. This tensor should of size\r\n ``(2**N,)`` for some integer value ``N``.\r\n axis (list[int]): the axis for which to calculate the marginal\r\n probability distribution\r\n\r\n Returns:\r\n tensor_like: the marginal probabilities, of\r\n size ``(2**len(axis),)``\r\n\r\n **Example**\r\n\r\n >>> x = tf.Variable([1, 0, 0, 1.], dtype=tf.float64) / np.sqrt(2)\r\n >>> marginal_prob(x, axis=[0, 1])\r\n \r\n >>> marginal_prob(x, axis=[0])\r\n \r\n \"\"\"\r\n prob = flatten(prob)\r\n num_wires = int(np.log2(len(prob)))\r\n\r\n if num_wires == len(axis):\r\n return prob\r\n\r\n inactive_wires = tuple(set(range(num_wires)) - set(axis))\r\n prob = reshape(prob, [2] * num_wires)\r\n prob = sum_(prob, axis=inactive_wires)\r\n return flatten(prob)\r\n\r\n\r\ndef toarray(tensor):\r\n \"\"\"Returns the tensor as a NumPy ``ndarray``. No copying\r\n is performed; the tensor and the returned array share the\r\n same storage.\r\n\r\n Args:\r\n tensor (tensor_like): input tensor\r\n\r\n Returns:\r\n array: a ``ndarray`` view into the same data\r\n\r\n **Example**\r\n\r\n >>> x = torch.tensor([1., 2.])\r\n >>> toarray(x)\r\n array([1, 2])\r\n \"\"\"\r\n return TensorBox(tensor).numpy()\r\n\r\n\r\ndef ones_like(tensor, dtype=None):\r\n \"\"\"Returns a tensor of all ones with the same shape and dtype\r\n as the input tensor.\r\n\r\n Args:\r\n tensor (tensor_like): input tensor\r\n dtype (str, np.dtype): The desired output datatype of the array. If not provided, the dtype of\r\n\r\n ``tensor`` is used. This argument can be any supported NumPy dtype representation, including\r\n a string (``\"float64\"``), a ``np.dtype`` object (``np.dtype(\"float64\")``), or\r\n a dtype class (``np.float64``). If ``tensor`` is not a NumPy array, the\r\n **equivalent** dtype in the dispatched framework is used.\r\n\r\n Returns:\r\n tensor_like: an all-ones tensor with the same shape and\r\n size as ``tensor``\r\n\r\n **Example**\r\n\r\n >>> x = torch.tensor([1., 2.])\r\n >>> ones_like(x)\r\n tensor([1, 1])\r\n >>> y = tf.Variable([[0], [5]])\r\n >>> ones_like(y, dtype=np.complex128)\r\n \r\n \"\"\"\r\n if dtype is not None:\r\n return TensorBox(tensor).ones_like().cast(dtype, wrap_output=False)\r\n\r\n return TensorBox(tensor).ones_like(wrap_output=False)\r\n\r\n\r\ndef reshape(tensor, shape): # pylint: disable=redefined-outer-name\r\n \"\"\"Gives a new shape to a tensor without changing its data.\r\n\r\n Args:\r\n tensor (tensor_like): input tensor\r\n shape (tuple[int]): The new shape. The special value of -1 indicates\r\n that the size of that dimension is computed so that the total size\r\n remains constant. A dimension of -1 can only be specified once.\r\n\r\n Returns:\r\n tensor_like: a new view into the input tensor with\r\n shape ``shape``\r\n\r\n **Example**\r\n\r\n >>> a = tf.range(4.)\r\n >>> reshape(a, (2, 2))\r\n \r\n >>> b = torch.tensor([[0, 1], [2, 3]])\r\n >>> torch.reshape(b, (-1,))\r\n tensor([0, 1, 2, 3])\r\n \"\"\"\r\n return TensorBox(tensor).reshape(shape, wrap_output=False)\r\n\r\n\r\ndef requires_grad(tensor):\r\n \"\"\"Returns True if the tensor is considered trainable.\r\n\r\n .. warning::\r\n\r\n The implemetation depends on the contained tensor type, and\r\n may be context dependent.\r\n\r\n For example, Torch tensors and PennyLane tensors track trainability\r\n as a property of the tensor itself. TensorFlow, on the other hand,\r\n\r\n only tracks trainability if being watched by a gradient tape.\r\n\r\n Args:\r\n tensor (tensor_like): input tensor\r\n\r\n **Example**\r\n\r\n Calling this function on a PennyLane NumPy array:\r\n\r\n >>> x = np.array([1., 5.], requires_grad=True)\r\n >>> requires_grad(x)\r\n True\r\n >>> x.requires_grad = False\r\n >>> requires_grad(x)\r\n False\r\n\r\n PyTorch has similar behaviour.\r\n\r\n With TensorFlow, the output is dependent on whether the tensor\r\n is currently being watched by a gradient tape:\r\n\r\n >>> x = tf.Variable([0.6, 0.1])\r\n >>> requires_grad(x)\r\n False\r\n >>> with tf.GradientTape() as tape:\r\n ... print(requires_grad(x))\r\n True\r\n\r\n While TensorFlow constants are by default not trainable, they can be\r\n manually watched by the gradient tape:\r\n\r\n >>> x = tf.constant([0.6, 0.1])\r\n >>> with tf.GradientTape() as tape:\r\n ... print(requires_grad(x))\r\n False\r\n >>> with tf.GradientTape() as tape:\r\n ... tape.watch([x])\r\n ... print(requires_grad(x))\r\n True\r\n \"\"\"\r\n return TensorBox(tensor).requires_grad\r\n\r\n\r\ndef scatter_element_add(tensor, index, value):\r\n \"\"\"Adds a scalar value to a specific index of a tensor.\r\n\r\n This is a pure equivalent of ``tensor[index] += value``.\r\n\r\n Args:\r\n tensor (tensor_like): the input tensor to be updated\r\n index (tuple[int]): the index of the input tensor to update\r\n value (scalar): the scalar value to add to the tensor element\r\n\r\n Returns:\r\n tensor_like: the output tensor\r\n\r\n **Example**\r\n\r\n >>> x = torch.ones((2, 3))\r\n >>> qml.math.scatter_element_add(x, [1, 2], 3)\r\n tensor([[1., 1., 1.],\r\n [1., 1., 4.]])\r\n \"\"\"\r\n value = convert_like(value, tensor)\r\n return TensorBox(tensor).scatter_element_add(index, value, wrap_output=False)\r\n\r\n\r\ndef shape(tensor):\r\n \"\"\"Returns the shape of the tensor.\r\n\r\n Args:\r\n tensor (tensor_like): input tensor\r\n\r\n Returns:\r\n tuple[int]: shape of the tensor\r\n\r\n **Example**\r\n\r\n >>> x = tf.constant([[0.6, 0.1, 0.6], [1., 2., 3.]])\r\n >>> shape(x)\r\n (2, 3)\r\n \"\"\"\r\n return TensorBox(tensor).shape\r\n\r\n\r\ndef sqrt(tensor):\r\n \"\"\"Returns the element-wise square root.\r\n\r\n Args:\r\n tensor (tensor_like): input tensor\r\n\r\n Returns:\r\n tensor_like:\r\n\r\n **Example**\r\n\r\n >>> a = torch.tensor([4., 9.], requires_grad=True)\r\n >>> sqrt(a)\r\n tensor([2., 3.], grad_fn=)\r\n \"\"\"\r\n return TensorBox(tensor).sqrt(wrap_output=False)\r\n\r\n\r\ndef stack(values, axis=0):\r\n \"\"\"Stack a sequence of tensors along the specified axis.\r\n\r\n .. warning::\r\n\r\n Tensors that are incompatible (such as Torch and TensorFlow tensors)\r\n cannot both be present.\r\n\r\n Args:\r\n values (Sequence[tensor_like]): Sequence of tensor-like objects to\r\n stack. Each object in the sequence must have the same size in the given axis.\r\n axis (int): The axis along which the input tensors are stacked. ``axis=0`` corresponds\r\n to vertical stacking.\r\n\r\n Returns:\r\n tensor_like: The stacked array. The stacked array will have one additional dimension\r\n compared to the unstacked tensors.\r\n\r\n **Example**\r\n\r\n >>> x = tf.constant([0.6, 0.1, 0.6])\r\n >>> y = tf.Variable([0.1, 0.2, 0.3])\r\n >>> z = np.array([5., 8., 101.])\r\n >>> stack([x, y, z])\r\n \r\n \"\"\"\r\n return _get_multi_tensorbox(values).stack(values, axis=axis, wrap_output=False)\r\n\r\n\r\ndef squeeze(tensor):\r\n \"\"\"Remove single-dimensional entries from the shape of an array.\r\n\r\n Args:\r\n tensor (tensor_like): A tensor-like object.\r\n\r\n Returns:\r\n The input array, but with all or a subset of the dimensions of length 1 removed.\r\n This is always a itself or a view into a. Note that if all axes are squeezed,\r\n the result is a 0d array and not a scalar.\r\n\r\n **Example**\r\n\r\n >>> x = torch.ones((2, 1, 3, 4, 1))\r\n >>> y = squeeze(x)\r\n >>> y.shape\r\n (2, 3, 4)\r\n \"\"\"\r\n return TensorBox(tensor).squeeze(wrap_output=False)\r\n\r\n\r\ndef sum_(tensor, axis=None, keepdims=False):\r\n \"\"\"TensorBox: Returns the sum of the tensor elements across the specified dimensions.\r\n\r\n Args:\r\n tensor (tensor_like): input tensor\r\n axis (int or tuple[int]): The axis or axes along which to perform the sum.\r\n If not specified, all elements of the tensor across all dimensions\r\n will be summed, returning a tensor.\r\n keepdims (bool): If True, retains all summed dimensions.\r\n\r\n Returns:\r\n tensor_like: The tensor with specified dimensions summed over. Note that\r\n if all elements are summed, then a 0-dimensional tensor is returned, rather\r\n than a Python scalar.\r\n\r\n **Example**\r\n\r\n Summing over all dimensions:\r\n\r\n >>> x = tf.Variable([[1., 2.], [3., 4.]])\r\n >>> sum(x)\r\n \r\n\r\n Summing over specified dimensions:\r\n\r\n >>> x = np.array([[[1, 1], [5, 3]], [[1, 4], [-6, -1]]])\r\n >>> x.shape\r\n (2, 2, 2)\r\n >>> sum(x, axis=(0, 2))\r\n tensor([7, 1], requires_grad=True)\r\n >>> sum(x, axis=(0, 2), keepdims=True)\r\n tensor([[[7],\r\n [1]]], requires_grad=True)\r\n \"\"\"\r\n return TensorBox(tensor).sum(axis=axis, keepdims=keepdims, wrap_output=False)\r\n\r\n\r\ndef T(tensor):\r\n \"\"\"Returns the transpose of the tensor by reversing the order\r\n of the axes. For a 2D tensor, this corresponds to the matrix transpose.\r\n\r\n Args:\r\n tensor (tensor_like): input tensor\r\n\r\n Returns:\r\n tensor_like: input tensor with axes reversed\r\n\r\n **Example**\r\n\r\n >>> x = tf.Variable([[1, 2], [3, 4]])\r\n >>> T(x)\r\n \r\n \"\"\"\r\n return TensorBox(tensor).T(wrap_output=False)\r\n\r\n\r\ndef take(tensor, indices, axis=None):\r\n \"\"\"Gather elements from a tensor.\r\n\r\n Note that ``take(indices, axis=3)`` is equivalent\r\n to ``tensor[:, :, :, indices, ...]`` for frameworks that support\r\n NumPy-like fancy indexing.\r\n\r\n This function is roughly equivalent to ``np.take`` and ``tf.gather``.\r\n In the case of a 1-dimensional set of indices, it is roughly equivalent\r\n to ``torch.index_select``, but deviates for multi-dimensional indices.\r\n\r\n Args:\r\n tensor (tensor_like): input tensor\r\n indices (Sequence[int]): the indices of the values to extract\r\n axis: The axis over which to select the values. If not provided,\r\n the tensor is flattened before value extraction.\r\n\r\n **Example**\r\n\r\n >>> x = torch.tensor([[1, 2], [3, 4]])\r\n >>> take(y, indices=[[0, 0], [1, 0]], axis=1)\r\n tensor([[[1, 1],\r\n [2, 1]],\r\n\r\n [[3, 3],\r\n [4, 3]]])\r\n \"\"\"\r\n return TensorBox(tensor).take(indices, axis=axis, wrap_output=False)\r\n\r\n\r\ndef where(condition, x, y):\r\n \"\"\"Returns elements chosen from x or y depending on a boolean tensor condition.\r\n\r\n The input tensors ``condition``, ``x``, and ``y`` must all be broadcastable to the same shape.\r\n\r\n Args:\r\n condition (tensor_like[bool]): A boolean tensor. Where True, elements from\r\n ``x`` will be chosen, otherwise ``y``.\r\n x (tensor_like): values from which to choose if the condition evaluates to True\r\n y (tensor_like): values from which to choose if the condition evaluates to False\r\n\r\n Returns:\r\n tensor_like: A tensor with elements from ``x`` where the condition is True, and\r\n ``y`` otherwise. The output tensor has the same shape as the input tensors.\r\n\r\n **Example**\r\n\r\n >>> a = torch.tensor([0.6, 0.23, 0.7, 1.5, 1.7], requires_grad=True)\r\n >>> b = torch.tensor([-1., -2., -3., -4., -5.], requires_grad=True)\r\n >>> math.where(a < 1, a, b)\r\n tensor([ 0.6000, 0.2300, 0.7000, -4.0000, -5.0000], grad_fn=)\r\n \"\"\"\r\n return _get_multi_tensorbox([x, y]).where(condition, x, y, wrap_output=False)\r\n", "meta": {"hexsha": "c7b18fc736eb01bad5de85df2d3eb8e6dd0a57a2", "size": 31273, "ext": "py", "lang": "Python", "max_stars_repo_path": "pennylane/math/fn.py", "max_stars_repo_name": "nahumsa/pennylane", "max_stars_repo_head_hexsha": "f92c36ea632f450908de915fb01ebb314a68e3fa", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pennylane/math/fn.py", "max_issues_repo_name": "nahumsa/pennylane", "max_issues_repo_head_hexsha": "f92c36ea632f450908de915fb01ebb314a68e3fa", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-05-27T05:36:41.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-27T05:36:41.000Z", "max_forks_repo_path": "pennylane/math/fn.py", "max_forks_repo_name": "nahumsa/pennylane", "max_forks_repo_head_hexsha": "f92c36ea632f450908de915fb01ebb314a68e3fa", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-07-11T11:45:14.000Z", "max_forks_repo_forks_event_max_datetime": "2021-07-11T11:45:14.000Z", "avg_line_length": 32.1738683128, "max_line_length": 137, "alphanum_fraction": 0.6018930067, "include": true, "reason": "import numpy", "num_tokens": 8187, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792044, "lm_q2_score": 0.38121956625614994, "lm_q1q2_score": 0.1935878186402452}} {"text": "# -*- coding: utf-8 -*-\n# vim: tabstop=4 shiftwidth=4 softtabstop=4\n\n#\n# LICENSE\n#\n# Copyright (C) 2010-2018 GEM Foundation, G. Weatherill, M. Pagani,\n# D. Monelli.\n#\n# The Hazard Modeller's Toolkit is free software: you can redistribute\n# it and/or modify it under the terms of the GNU Affero General Public\n# License as published by the Free Software Foundation, either version\n# 3 of the License, or (at your option) any later version.\n#\n# You should have received a copy of the GNU Affero General Public License\n# along with OpenQuake. If not, see \n#\n# DISCLAIMER\n#\n# The software Hazard Modeller's Toolkit (openquake.hmtk) provided herein\n# is released as a prototype implementation on behalf of\n# scientists and engineers working within the GEM Foundation (Global\n# Earthquake Model).\n#\n# It is distributed for the purpose of open collaboration and in the\n# hope that it will be useful to the scientific, engineering, disaster\n# risk and software design communities.\n#\n# The software is NOT distributed as part of GEM's OpenQuake suite\n# (https://www.globalquakemodel.org/tools-products) and must be considered as a\n# separate entity. The software provided herein is designed and implemented\n# by scientific staff. It is not developed to the design standards, nor\n# subject to same level of critical review by professional software\n# developers, as GEM's OpenQuake software suite.\n#\n# Feedback and contribution to the software is welcome, and can be\n# directed to the hazard scientific staff of the GEM Model Facility\n# (hazard@globalquakemodel.org).\n#\n# The Hazard Modeller's Toolkit (openquake.hmtk) is therefore distributed\n# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\n# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License\n# for more details.\n#\n# The GEM Foundation, and the authors of the software, assume no\n# liability for use of the software.\n\n#!/usr/bin/env python\n\n'''\nModule openquake.hmtk.plotting.seismicity.completeness.simple_completeness is a graphical\nfunction for estimating the completeness period of magnitude intervals\nby plotting the cumulative rate of events with time in each interval\n'''\n\nimport numpy as np\nimport pylab\nimport matplotlib.pyplot as plt\nfrom openquake.hmtk.seismicity.completeness.base import (\n BaseCatalogueCompleteness)\n\n\nclass SimpleCumulativeRate(BaseCatalogueCompleteness):\n '''\n Class to define the temporal variation in completess using simple\n changes in cumulative rates in individual completeness bins\n '''\n\n def completeness(self, catalogue, config, saveplot=False, filetype='png',\n timeout=120):\n '''\n :param catalogue:\n Earthquake catalogue as instance of\n :class:`openquake.hmtk.seismicity.catalogue.Catalogue`\n :param dict config:\n Configuration parameters of the algorithm, containing the\n following information:\n 'magnitude_bin' Size of magnitude bin (non-negative float)\n 'time_bin' Size (in dec. years) of the time window (non-negative\n float)\n 'increment_lock' Boolean to indicate whether to ensure\n completeness magnitudes always decrease with more\n recent bins\n :returns:\n 2-column table indicating year of completeness and corresponding\n magnitude numpy.ndarray\n '''\n if saveplot and not isinstance(saveplot, str):\n raise ValueError('To save the figures enter a filename: ')\n\n # Get magntitude bins\n magnitude_bins = self._get_magnitudes_from_spacing(\n catalogue.data['magnitude'],\n config['magnitude_bin'])\n dec_time = catalogue.get_decimal_time()\n completeness_table = np.zeros([len(magnitude_bins) - 1, 2],\n dtype=float)\n min_year = float(np.min(catalogue.data['year']))\n max_year = float(np.max(catalogue.data['year'])) + 1.0\n has_completeness = np.zeros(len(magnitude_bins) - 1, dtype=bool)\n for iloc in range(0, len(magnitude_bins) - 1):\n lower_mag = magnitude_bins[iloc]\n upper_mag = magnitude_bins[iloc + 1]\n idx = np.logical_and(catalogue.data['magnitude'] >= lower_mag,\n catalogue.data['magnitude'] < upper_mag)\n cumvals = np.cumsum(np.ones(np.sum(idx)))\n plt.plot(dec_time[idx], cumvals, '.')\n plt.xlim(min_year, max_year + 5)\n title_string = 'Magnitude %5.2f to %5.2f' % (lower_mag, upper_mag)\n plt.title(title_string)\n pts = pylab.ginput(1, timeout=timeout)[0]\n if pts[0] <= max_year:\n # Magnitude bin has no completeness!\n has_completeness[iloc] = True\n completeness_table[iloc, 0] = np.floor(pts[0])\n completeness_table[iloc, 1] = magnitude_bins[iloc]\n print(completeness_table[iloc, :], has_completeness[iloc])\n if config['increment_lock'] and (iloc > 0) and \\\n (completeness_table[iloc, 0] > completeness_table[iloc - 1, 0]):\n completeness_table[iloc, 0] = \\\n completeness_table[iloc - 1, 0]\n # Add marker line to indicate completeness point\n marker_line = np.array([\n [0., completeness_table[iloc, 0]],\n [cumvals[-1], completeness_table[iloc, 0]]])\n plt.plot(marker_line[:, 0], marker_line[:, 1], 'r-')\n if saveplot:\n filename = saveplot + '_' + ('%5.2f' % lower_mag) + (\n '%5.2f' % upper_mag) + '.' + filetype\n plt.savefig(filename, format=filetype)\n plt.close()\n return completeness_table[has_completeness, :]\n\n def _get_magnitudes_from_spacing(self, magnitudes, delta_m):\n '''If a single magnitude spacing is input then create the bins\n\n :param numpy.ndarray magnitudes:\n Vector of earthquake magnitudes\n\n :param float delta_m:\n Magnitude bin width\n\n :returns: Vector of magnitude bin edges (numpy.ndarray)\n '''\n min_mag = np.min(magnitudes)\n max_mag = np.max(magnitudes)\n if (max_mag - min_mag) < delta_m:\n raise ValueError('Bin width greater than magnitude range!')\n mag_bins = np.arange(np.floor(min_mag), np.ceil(max_mag), delta_m)\n # Check to see if there are magnitudes in lower and upper bins\n is_mag = np.logical_and(mag_bins - max_mag < delta_m,\n min_mag - mag_bins < delta_m)\n mag_bins = mag_bins[is_mag]\n return mag_bins\n", "meta": {"hexsha": "7891d5b7e3762547f9dcb68676c2302e7a63be58", "size": 6712, "ext": "py", "lang": "Python", "max_stars_repo_path": "openquake/hmtk/plotting/seismicity/completeness/cumulative_rate_analysis.py", "max_stars_repo_name": "gfzriesgos/shakyground-lfs", "max_stars_repo_head_hexsha": "2caf67cc32e6800286eded2df1efb05973ccf41b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-08-01T00:28:24.000Z", "max_stars_repo_stars_event_max_datetime": "2019-08-01T00:28:24.000Z", "max_issues_repo_path": "openquake/hmtk/plotting/seismicity/completeness/cumulative_rate_analysis.py", "max_issues_repo_name": "gfzriesgos/shakyground-lfs", "max_issues_repo_head_hexsha": "2caf67cc32e6800286eded2df1efb05973ccf41b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2018-08-31T14:14:35.000Z", "max_issues_repo_issues_event_max_datetime": "2021-10-11T12:53:13.000Z", "max_forks_repo_path": "openquake/hmtk/plotting/seismicity/completeness/cumulative_rate_analysis.py", "max_forks_repo_name": "gfzriesgos/shakyground-lfs", "max_forks_repo_head_hexsha": "2caf67cc32e6800286eded2df1efb05973ccf41b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2018-08-31T14:11:00.000Z", "max_forks_repo_forks_event_max_datetime": "2019-07-17T10:06:02.000Z", "avg_line_length": 43.3032258065, "max_line_length": 89, "alphanum_fraction": 0.6561382598, "include": true, "reason": "import numpy", "num_tokens": 1504, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792044, "lm_q2_score": 0.38121956625614994, "lm_q1q2_score": 0.1935878186402452}} {"text": "\"\"\"The WaveBlocks Project\n\nThis file contains the basic interface for general wavepackets.\n\n@author: R. Bourquin\n@copyright: Copyright (C) 2011 R. Bourquin\n@license: Modified BSD License\n\"\"\"\n\nfrom numpy import vstack, vsplit, cumsum, zeros, complexfloating\n\n\nclass Wavepacket:\n r\"\"\"\n This class is primarily an abstract interface to wavepackets in general.\n But it implemets some methods for both the homogeneous and inhomogeneous Hagedorn\n wavepackets.\n \"\"\"\n\n def __init__(self, parameters):\n r\"\"\"\n Initialize the ``Wavepacket`` object that represents :math:`|\\Psi\\rangle`.\n\n :raise NotImplementedError: Abstract interface.\n \"\"\"\n raise NotImplementedError(\"'Wavepacket' is an abstract interface.\")\n\n\n def __str__(self):\n r\"\"\"\n :return: A string describing the wavepacket.\n :raise NotImplementedError: Abstract interface.\n \"\"\"\n raise NotImplementedError(\"'Wavepacket' is an abstract interface.\")\n\n\n def _resize_coefficient_vector(self, component):\n r\"\"\"\n Adapt the coefficient vector for a given component to a new size.\n \"\"\"\n oldsize = self.coefficients[component].shape[0]\n newsize = self.basis_size[component]\n\n if oldsize == newsize:\n return\n elif oldsize < newsize:\n # Append some zeros\n z = zeros((newsize - oldsize, 1), dtype=complexfloating)\n self.coefficients[component] = vstack([self.coefficients[component], z])\n elif oldsize > newsize:\n # Cut off the last part\n self.coefficients[component] = self.coefficients[component][0:newsize]\n\n\n def clone(self):\n raise NotImplementedError(\"'Wavepacket' is an abstract interface.\")\n\n\n def gen_id(self):\n r\"\"\"\n Generate an (unique) ID per wavepacket instance.\n \"\"\"\n #TODO: Better id generating function!\n self._id = id(self)\n\n\n def get_id(self):\n r\"\"\"\n Return the packet ID of this wavepacket instance. The ID may be used for storing packets in associative lists.\n \"\"\"\n if not hasattr(self, \"_id\"):\n self.gen_id()\n\n return self._id\n\n\n def set_id(self, anid):\n r\"\"\"\n Manually set an ID for the current wavepacket instance.\n \"\"\"\n assert(type(anid) is int)\n self._id = anid\n\n\n def get_number_components(self):\n r\"\"\"\n :return: The number :math:`N` of components the wavepacket :math:`\\Psi` has.\n \"\"\"\n return self.number_components\n\n\n def get_basis_size(self, component=None):\n r\"\"\"\n :return: The size of the basis, i.e. the number :math:`K` of :math:`{\\phi_k}_{k=1}^K`.\n \"\"\"\n if component is not None:\n return self.basis_size[component]\n else:\n return tuple(self.basis_size)\n\n\n def set_basis_size(self, basis_size, component=None):\n r\"\"\"\n Set the size of the basis of a given component or all components.\n\n :param basis_size: An single positive integer or a list of :math:`N` positive integers.\n :param component: The component for which we want to set the basis size.\n Default is ``None`` which means 'all'.\n \"\"\"\n if component is not None:\n # Check for valid input basis size\n if not component in range(self.number_components):\n raise ValueError(\"Invalid component index \" + str(component))\n\n if basis_size < 2:\n raise ValueError(\"Basis size has to be a positive integer >=2.\")\n\n # Set the new basis size for the given component\n self.basis_size[component] = basis_size\n # And adapt the coefficient vectors\n self._resize_coefficient_vector(component)\n\n else:\n # Check for valid input basis size\n if any([bs < 2 for bs in basis_size]):\n raise ValueError(\"Basis size has to be a positive integer >=2.\")\n\n if not len(basis_size) == self.number_components:\n raise ValueError(\"Number of value(s) for basis size(s) does not match.\")\n\n # Set the new basis size for all components\n self.basis_size = [ bs for bs in basis_size ]\n # And adapt the coefficient vectors\n for index in xrange(self.number_components):\n self._resize_coefficient_vector(index)\n\n\n def set_coefficients(self, values, component=None):\n r\"\"\"\n Update the coefficients :math:`c` of :math:`\\Psi`.\n\n :param values: The new values of the coefficients :math:`c^i` of :math:`\\Phi_i`.\n :param component: The index :math:`i` of the component we want to update with new coefficients.\n :raise ValueError: For invalid indices :math:`i`.\n\n .. note:: This function can either set new coefficients for a single component :math:`\\Phi_i`\n only if the ``component`` attribute is set or for all components simultaneously if\n ``values`` is a list of arrays.\n \"\"\"\n if component is None:\n for index, value in enumerate(values):\n if index > self.number_components-1:\n raise ValueError(\"There is no component with index \"+str(index)+\".\")\n\n self.coefficients[index] = value.copy().reshape((self.basis_size[index],1))\n else:\n if component > self.number_components-1:\n raise ValueError(\"There is no component with index \"+str(component)+\".\")\n\n self.coefficients[component] = values.copy().reshape((self.basis_size[component],1))\n\n\n def set_coefficient(self, component, index, value):\n r\"\"\"\n Set a single coefficient :math:`c^i_k` of the specified component :math:`\\Phi_i` of :math:`|\\Psi\\rangle`.\n\n :param component: The index :math:`i` of the component :math:`\\Phi_i` we want to update.\n :param index: The index :math:`k` of the coefficient :math:`c^i_k` we want to update.\n :param value: The new value of the coefficient :math:`c^i_k`.\n :raise ValueError: For invalid indices :math:`i` or :math:`k`.\n \"\"\"\n if component > self.number_components-1:\n raise ValueError(\"There is no component with index \"+str(component)+\".\")\n if index > self.basis_size[component]-1:\n raise ValueError(\"There is no basis function with index \"+str(index)+\".\")\n\n self.coefficients[component][index] = value\n\n\n def get_coefficients(self, component=None):\n r\"\"\"\n Returns the coefficients :math:`c^i` for some components :math:`\\Phi_i` of :math:`|\\Psi\\rangle`.\n\n :param component: The index :math:`i` of the coefficients :math:`c^i` we want to get.\n :return: The coefficients :math:`c^i` either for all components :math:`\\Phi_i`\n or for a specified one.\n \"\"\"\n if component is None:\n return [ item.copy() for item in self.coefficients ]\n else:\n return self.coefficients[component].copy()\n\n\n def get_coefficient_vector(self):\n r\"\"\"\n :return: The coefficients :math:`c^i` of all components :math:`\\Phi_i` as a single long column vector.\n \"\"\"\n return vstack(self.coefficients)\n\n\n def set_coefficient_vector(self, vector):\n r\"\"\"\n Set the coefficients for all components :math:`\\Phi_i` simultaneously.\n\n :param vector: The coefficients of all components as a single long column vector.\n\n .. note:: This function does *NOT* copy the input data! This is for efficiency as this\n routine is used in the innermost loops.\n \"\"\"\n # Compute the partition of the block-vector from the basis sizes\n partition = cumsum(self.basis_size)[:-1]\n\n # Split the block-vector with the given partition and assign\n self.coefficients = vsplit(vector, partition)\n\n\n def get_parameters(self, component=None, aslist=False):\n r\"\"\"\n Get the Hagedorn parameters :math:`{\\Pi}` of the wavepacket :math:`\\Psi`.\n\n :raise NotImplementedError: Abstract interface.\n \"\"\"\n raise NotImplementedError(\"'Wavepacket' is an abstract interface.\")\n\n\n def set_parameters(self, parameters, component=None):\n r\"\"\"\n Set the Hagedorn parameters :math:`{\\Pi}` of the wavepacket :math:`\\Psi`.\n\n :raise NotImplementedError: Abstract interface.\n \"\"\"\n raise NotImplementedError(\"'Wavepacket' is an abstract interface.\")\n\n\n def evaluate_basis_at(self, nodes, component, prefactor=False):\n r\"\"\"\n Evaluate the basis functions :math:`\\phi_k` recursively at the given nodes :math:`\\gamma`.\n\n :raise NotImplementedError: Abstract interface.\n \"\"\"\n raise NotImplementedError(\"'Wavepacket' is an abstract interface.\")\n\n\n def evaluate_at(self, nodes, component=None, prefactor=False):\n r\"\"\"\n Evaluete the wavepacket :math:`\\Psi` at the given nodes :math:`\\gamma`.\n\n :raise NotImplementedError: Abstract interface.\n \"\"\"\n raise NotImplementedError(\"'Wavepacket' is an abstract interface.\")\n\n\n def get_norm(self, component=None, summed=False):\n r\"\"\"\n Calculate the :math:`L^2` norm of the wavepacket :math:`|\\Psi\\rangle`.\n\n :raise NotImplementedError: Abstract interface.\n \"\"\"\n raise NotImplementedError(\"'Wavepacket' is an abstract interface.\")\n\n\n def potential_energy(self, potential, summed=False):\n r\"\"\"\n Calculate the potential energy :math:`\\langle\\Psi|V|\\Psi\\rangle ` of the wavepacket componentwise.\n\n :raise NotImplementedError: Abstract interface.\n \"\"\"\n raise NotImplementedError(\"'Wavepacket' is an abstract interface.\")\n\n\n def kinetic_energy(self, summed=False):\n r\"\"\"\n Calculate the kinetic energy :math:`\\langle\\Psi|T|\\Psi\\rangle ` of the wavepacket componentwise.\n\n :raise NotImplementedError: Abstract interface.\n \"\"\"\n raise NotImplementedError(\"'Wavepacket' is an abstract interface.\")\n\n\n def project_to_canonical(self, potential):\n r\"\"\"\n Project the wavepacket to the canonical basis.\n\n :raise NotImplementedError: Abstract interface.\n \"\"\"\n raise NotImplementedError(\"'Wavepacket' is an abstract interface.\")\n\n\n def project_to_eigen(self, potential):\n r\"\"\"\n Project the wavepacket to the eigenbasis of a given potential :math:`V`.\n\n :raise NotImplementedError: Abstract interface.\n \"\"\"\n raise NotImplementedError(\"'Wavepacket' is an abstract interface.\")\n\n\n def to_fourier_space(self, assign=True):\n r\"\"\"\n Transform the wavepacket to Fourier space.\n\n :raise NotImplementedError: Abstract interface.\n \"\"\"\n raise NotImplementedError(\"'Wavepacket' is an abstract interface.\")\n\n\n def to_real_space(self, assign=True):\n r\"\"\"\n Transform the wavepacket to real space.\n\n :raise NotImplementedError: Abstract interface.\n \"\"\"\n raise NotImplementedError(\"'Wavepacket' is an abstract interface.\")\n", "meta": {"hexsha": "e5b61123fc5aed424d3ecf4c3be65ca3f7e0ec7f", "size": 11151, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/WaveBlocks/Wavepacket.py", "max_stars_repo_name": "WaveBlocks/WaveBlocks", "max_stars_repo_head_hexsha": "2af3730dcf27e54006ec602e696b4d4df25459d8", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/WaveBlocks/Wavepacket.py", "max_issues_repo_name": "WaveBlocks/WaveBlocks", "max_issues_repo_head_hexsha": "2af3730dcf27e54006ec602e696b4d4df25459d8", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/WaveBlocks/Wavepacket.py", "max_forks_repo_name": "WaveBlocks/WaveBlocks", "max_forks_repo_head_hexsha": "2af3730dcf27e54006ec602e696b4d4df25459d8", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.5127388535, "max_line_length": 118, "alphanum_fraction": 0.6275670343, "include": true, "reason": "from numpy", "num_tokens": 2357, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792044, "lm_q2_score": 0.3812195662561499, "lm_q1q2_score": 0.19358781864024519}} {"text": "\"\"\"\nEverything to store electromagnetic material properties for the solver.\n\"\"\"\n# Copyright 2018-2021 The emsig community.\n#\n# This file is part of emg3d.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\"); you may not\n# use this file except in compliance with the License. You may obtain a copy\n# of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\n# License for the specific language governing permissions and limitations under\n# the License.\n\nfrom copy import deepcopy\n\nimport numpy as np\nfrom scipy.constants import epsilon_0\n\nfrom emg3d import maps, meshes, utils\n\n__all__ = ['Model', 'VolumeModel', 'expand_grid_model']\n\n\n# MODEL\n@utils._known_class\nclass Model:\n r\"\"\"A model containing the electromagnetic properties of the Earth.\n\n A model provides the required model parameters to the solver. The x-, y-,\n and z-directed electrical properties are by default resistivities. However,\n they can be defined as resistivities, :math:`\\rho\\ (\\Omega\\,\\mathrm{m})`,\n or conductivities, :math:`\\sigma\\ (\\mathrm{S/m})`, either on a linear or on\n a logarithmic scale (log or ln), by choosing the appropriate ``mapping``.\n Relative magnetic permeability :math:`\\mu_\\mathrm{r}` is by default set to\n one and electric permittivity :math:`\\varepsilon_\\mathrm{r}` is by default\n set to zero, but they can also be provided (isotropically). Keep in mind\n that the multigrid method as implemented in emg3d works for the diffusive\n approximation. When the displacement part in Maxwell's equations becomes\n too dominant it will start to fail (high frequencies or very high electric\n permittivity).\n\n\n Parameters\n ----------\n grid : TensorMesh\n The grid; a :class:`emg3d.meshes.TensorMesh` instance.\n\n property_{x;y;z} : {None, array_like}, default: 1 (x), None (y, z)\n Electrical material property in x-, y-, and z-directions. The\n properties are stored as Fortran-ordered arrays with the shape given by\n ``grid.shape``. The provided value must be broadcastable to that shape.\n\n By default, property refers to electrical resistivity. However, this\n can be changed with an appropriate ``mapping`` (the internals of\n emg3d work, irrelevant of the map, with electrical conductivities).\n\n The properties have to be of finite value, bigger than zero (on linear\n scale). The four supported anisotropy cases are:\n\n - ``x;y=None;z=None``: isotropic (``y=z=x``);\n - ``x;y=None;z``: vertical transverse isotropy VTI (``y=x``);\n - ``x;y;z=None``: horizontal transverse isotropy HTI (``z=x``);\n - ``x;y;z``: triaxial anisotropy.\n\n If a property is not initiated it cannot be set later on (e.g., if a\n VTI model is created, it is not possible to set ``property_y`` later\n on, instead, a new model has to be initiated).\n\n mu_r, epsilon_r : {None, array_like}, default: None\n Relative magnetic permeability (-) and relative electric permittivity\n (-), respectively, both isotropic. The properties are stored as\n Fortran-ordered arrays with the shape given by ``grid.shape``. The\n provided value must be broadcastable to that shape.\n\n The properties have to be of finite value, bigger than zero.\n\n The relative magnetic permeability is assumed to be 1 if not provided.\n\n The relative electric permittivity is assumed to be 0 if not provided,\n which ignores the displacement part completely (diffusive\n approximation)\n\n mapping : str, default: 'Resistivity'\n Defines what type the electrical input ``property_{x;y;z}``-values\n correspond to. The implemented types are:\n\n - ``'Resistivity'``; ρ (Ω m);\n - ``'Conductivity'``; σ (S/m);\n - ``'LgResistivity'``; log_10(ρ);\n - ``'LgConductivity'``; log_10(σ);\n - ``'LnResistivity'``; log_e(ρ);\n - ``'LnConductivity'``; log_e(σ).\n\n \"\"\"\n\n def __init__(self, grid, property_x=1., property_y=None, property_z=None,\n mu_r=None, epsilon_r=None, mapping='Resistivity'):\n \"\"\"Initiate a new model.\"\"\"\n\n # Store grid.\n self.grid = grid\n\n # Alias shape_cells and n_cells to shape and size.\n self.shape = self.grid.shape_cells\n self.size = self.grid.n_cells\n\n # Get and store map.\n self.map = getattr(maps, 'Map'+mapping)()\n\n # Initiate and store all parameters.\n self._property_x = self._init_parameter(property_x, 'property_x')\n self._property_y = self._init_parameter(property_y, 'property_y')\n self._property_z = self._init_parameter(property_z, 'property_z')\n self._mu_r = self._init_parameter(mu_r, 'mu_r',)\n self._epsilon_r = self._init_parameter(epsilon_r, 'epsilon_r')\n self._properties = ['property_x', 'property_y', 'property_z',\n 'mu_r', 'epsilon_r']\n\n # Store case.\n if self._property_y is None and self._property_z is None:\n self.case = 'isotropic'\n elif self._property_z is None:\n self.case = 'HTI'\n elif self._property_y is None:\n self.case = 'VTI'\n else:\n self.case = 'triaxial'\n\n def __repr__(self):\n \"\"\"Simple representation.\"\"\"\n return (f\"{self.__class__.__name__}: {self.map.description}; \"\n f\"{self.case}{'' if self.mu_r is None else '; mu_r'}\"\n f\"{'' if self.epsilon_r is None else '; epsilon_r'}\"\n f\"; {self.shape[0]} x {self.shape[1]} x {self.shape[2]} \"\n f\"({self.size:,})\")\n\n def __add__(self, model):\n \"\"\"Add two models.\"\"\"\n\n # Ensure model is a Model instance.\n if model.__class__.__name__ != 'Model':\n return NotImplemented\n\n # Check input.\n self._operator_test(model)\n\n # Apply operator.\n kwargs = self._apply_operator(model, np.add)\n\n # Return new Model instance.\n return Model(grid=self.grid, mapping=self.map.name, **kwargs)\n\n def __sub__(self, model):\n \"\"\"Subtract two models.\"\"\"\n\n # Ensure model is a Model instance.\n if model.__class__.__name__ != 'Model':\n return NotImplemented\n\n # Check input.\n self._operator_test(model)\n\n # Apply operator.\n kwargs = self._apply_operator(model, np.subtract)\n\n # Return new Model instance.\n return Model(grid=self.grid, mapping=self.map.name, **kwargs)\n\n def __eq__(self, model):\n \"\"\"Compare two models.\"\"\"\n\n # Check if model is a Model instance.\n equal = model.__class__.__name__ == 'Model'\n\n # Check input.\n if equal:\n try:\n self._operator_test(model)\n except ValueError:\n equal = False\n\n # Compare values if not None.\n if equal:\n for prop in self._properties:\n val = getattr(self, prop)\n if val is not None:\n equal *= np.allclose(val, getattr(model, prop))\n\n return bool(equal)\n\n def copy(self):\n \"\"\"Return a copy of the Model.\"\"\"\n return self.from_dict(self.to_dict(True))\n\n def to_dict(self, copy=False):\n \"\"\"Store the necessary information in a dict for serialization.\n\n Parameters\n ----------\n copy : bool, default: False\n If True, returns a deep copy of the dict.\n\n\n Returns\n -------\n out : dict\n Dictionary containing all information to re-create the Model.\n\n \"\"\"\n out = {\n '__class__': self.__class__.__name__, # v ensure emg3d-TensorMesh\n 'grid': meshes.TensorMesh(self.grid.h, self.grid.origin).to_dict(),\n **{prop: getattr(self, prop) for prop in self._properties},\n 'mapping': self.map.name,\n }\n if copy:\n return deepcopy(out)\n else:\n return out\n\n @classmethod\n def from_dict(cls, inp):\n \"\"\"Convert dictionary into :class:`emg3d.models.Model` instance.\n\n Parameters\n ----------\n inp : dict\n Dictionary as obtained from :func:`emg3d.models.Model.to_dict`. The\n dictionary needs the keys ``property_x``, ``property_y``,\n ``property_z``, ``mu_r``, ``epsilon_r``, ``grid``, and ``mapping``;\n ``grid`` itself is also a dict which needs the keys ``hx``, ``hy``,\n ``hz``, and ``origin``.\n\n Returns\n -------\n model : Model\n A :class:`emg3d.models.Model` instance.\n\n \"\"\"\n inp = {k: v for k, v in inp.items() if k != '__class__'}\n MeshClass = getattr(meshes, inp['grid']['__class__'])\n return cls(grid=MeshClass.from_dict(inp.pop('grid')), **inp)\n\n # ELECTRICAL PROPERTIES\n @property\n def property_x(self):\n r\"\"\"Electrical property in x-direction.\"\"\"\n return self._property_x\n\n @property_x.setter\n def property_x(self, property_x):\n r\"\"\"Update electrical property in x-direction.\"\"\"\n self._check_positive_finite(property_x, 'property_x')\n self._property_x[:] = np.asfortranarray(property_x, dtype=np.float64)\n\n @property\n def property_y(self):\n r\"\"\"Electrical property in y-direction.\"\"\"\n return self._property_y\n\n @property_y.setter\n def property_y(self, property_y):\n r\"\"\"Update electrical property in y-direction.\"\"\"\n self._check_positive_finite(property_y, 'property_y')\n self._property_y[:] = np.asfortranarray(property_y, dtype=np.float64)\n\n @property\n def property_z(self):\n r\"\"\"Electrical property in z-direction.\"\"\"\n return self._property_z\n\n @property_z.setter\n def property_z(self, property_z):\n r\"\"\"Update electrical property in z-direction.\"\"\"\n self._check_positive_finite(property_z, 'property_z')\n self._property_z[:] = np.asfortranarray(property_z, dtype=np.float64)\n\n @property\n def mu_r(self):\n r\"\"\"Relative magnetic permeability.\"\"\"\n return self._mu_r\n\n @mu_r.setter\n def mu_r(self, mu_r):\n r\"\"\"Update relative magnetic permeability.\"\"\"\n self._check_positive_finite(mu_r, 'mu_r')\n self._mu_r[:] = np.asfortranarray(mu_r, dtype=np.float64)\n\n @property\n def epsilon_r(self):\n r\"\"\"Relative electric permittivity.\"\"\"\n return self._epsilon_r\n\n @epsilon_r.setter\n def epsilon_r(self, epsilon_r):\n r\"\"\"Update relative electric permittivity.\"\"\"\n self._check_positive_finite(epsilon_r, 'epsilon_r')\n self._epsilon_r[:] = np.asfortranarray(epsilon_r, dtype=np.float64)\n\n # INTERPOLATION\n def interpolate_to_grid(self, grid, **interpolate_opts):\n \"\"\"Interpolate the model to a new grid.\n\n If the provided grid is identical to the grid of the model, it returns\n the actual model (not a copy).\n\n\n Parameters\n ----------\n grid : TensorMesh\n Grid of the new model; a :class:`emg3d.meshes.TensorMesh` instance.\n\n interpolate_opts : dict\n Passed through to :func:`emg3d.maps.interpolate`. Defaults are\n ``method='volume'``, ``log=True``, and ``extrapolate=True``.\n\n\n Returns\n -------\n obj : Model\n A new :class:`emg3d.models.Model` instance on ``grid``.\n\n \"\"\"\n # If grids are identical, return model.\n if grid == self.grid:\n return self\n\n # Get solver options, set to defaults if not provided.\n g2g_inp = {\n 'method': 'volume',\n 'extrapolate': True,\n 'log': not self.map.name.startswith('L'),\n **({} if interpolate_opts is None else interpolate_opts),\n 'grid': self.grid,\n 'xi': grid,\n }\n\n # Interpolate property_{x;y;z}; mu_r; and epsilon_r; add to dict.\n model_inp = {}\n for prop in self._properties:\n var = getattr(self, prop)\n if var is None:\n model_inp[prop] = None\n else:\n model_inp[prop] = maps.interpolate(values=var, **g2g_inp)\n\n # Assemble new model.\n return Model(grid, mapping=self.map.name, **model_inp)\n\n # INTERNAL UTILITIES\n def _init_parameter(self, values, name):\n \"\"\"Initiate parameter by casting and broadcasting.\"\"\"\n\n # If None, exit.\n if values is None:\n return None\n\n # Cast it to an array of floats, in Fortran order.\n values = np.asfortranarray(values, dtype=np.float64)\n\n # If 1D array of self.size, reshape it.\n if values.size == self.size:\n values = values.reshape(self.shape, order='F')\n\n # If not of shape self.shape, broadcast it.\n elif values.shape != self.shape:\n values = np.ones(self.shape, order='F')*values\n\n # Check >0 and finite.\n self._check_positive_finite(values, name)\n\n return values\n\n def _check_positive_finite(self, values, name):\n \"\"\"Check parameter values are positive (on linear scale) and finite.\"\"\"\n\n # If it is None, it cannot be set.\n if hasattr(self, '_'+name) and getattr(self, '_'+name) is None:\n raise ValueError(\n f\"Model was initiated without `{name}`; cannot set values.\"\n )\n\n # Get mapped values; checks are carried out on conductivities.\n if 'property_' in name:\n mapped = self.map.backward(np.asarray(values))\n else:\n mapped = values\n\n # Check they are positive.\n if not np.all(np.real(mapped) > 0.0):\n raise ValueError(f\"`{name}` must be all bigger than zero.\")\n\n # Check |val| < inf.\n if not np.all(np.isfinite(mapped)):\n raise ValueError(f\"`{name}` must be all finite.\")\n\n def _operator_test(self, model):\n \"\"\"Check if ``self`` and ``model`` are consistent for operations.\"\"\"\n\n # Ensure the two instances have the same grid.\n if self.grid != model.grid:\n raise ValueError(\"Models have different grids.\")\n\n # Ensure the two instances have the same case.\n if self.case != model.case:\n raise ValueError(\"Models have different anisotropy.\")\n\n # Ensure both or none has mu_r:\n if (self.mu_r is None) != (model.mu_r is None):\n raise ValueError(\"One model has mu_r, the other not.\")\n\n # Ensure both or none has epsilon_r:\n if (self.epsilon_r is None) != (model.epsilon_r is None):\n raise ValueError(\"One model has epsilon_r, the other not.\")\n\n # Ensure the two instances have the same mapping:\n if self.map.name != model.map.name:\n raise ValueError(\"Models have different mappings.\")\n\n def _apply_operator(self, model, operator):\n \"\"\"Apply the provided operator to self and model.\"\"\"\n\n # Apply operator to property_{x;y;z}; mu_r; and epsilon_r; add to dict.\n kwargs = {}\n for prop in self._properties:\n val = getattr(self, prop)\n if val is None:\n kwargs[prop] = None\n else:\n kwargs[prop] = operator(val, getattr(model, prop))\n\n return kwargs\n\n\nclass VolumeModel:\n r\"\"\"Return simplified model with volume-averaged eta_{x;y;z}; zeta.\n\n Takes a model and a source field and returns the volume-averaged eta and\n zeta values. This is used internally by the solver.\n\n .. math::\n\n \\eta_{\\{x,y,z\\}} = -V\\mathrm{i}\\omega\\mu_0\n \\left(\\sigma_{\\{x,y,z\\}} + \\mathrm{i}\\omega\\varepsilon\\right)\n\n .. math::\n\n \\zeta = V\\mu_\\mathrm{r}^{-1}\n\n\n Parameters\n ----------\n model : Model\n Model to transform to volume-averaged values.\n\n sfield : Field\n A VolumeModel is frequency-dependent. The frequency-information is taken\n from the provided source field.\n\n \"\"\"\n\n def __init__(self, model, sfield):\n \"\"\"Initiate a new model with volume-averaged properties.\"\"\"\n\n # Store case and minimal TensorMesh.\n self.case = model.case\n self.grid = meshes.BaseMesh(model.grid.h, model.grid.origin)\n\n # Get volume for volume-averaged values.\n vol = self.grid.cell_volumes.reshape(model.shape, order='F')\n\n # Compute and store eta.\n for name in model._properties[:3]:\n\n prop = getattr(model, name)\n\n if prop is None:\n eta = None\n\n else:\n # Get conductivities.\n cond = model.map.backward(prop)\n\n # Diffusive approximation.\n if model.epsilon_r is None:\n eta = -sfield.smu0*vol*cond\n\n # Complete version.\n else:\n eta = -sfield.smu0*vol*(\n cond + sfield.sval*epsilon_0*model.epsilon_r)\n\n setattr(self, '_eta_' + name[-1], eta)\n\n # Compute and store zeta.\n zeta = vol\n if model.mu_r is not None:\n zeta /= model.mu_r\n self._zeta = zeta\n\n @property\n def eta_x(self):\n r\"\"\"Volume-averaged eta in x-direction.\"\"\"\n return self._eta_x\n\n @property\n def eta_y(self):\n r\"\"\"Volume-averaged eta in y-direction.\"\"\"\n if self.case in ['HTI', 'triaxial']:\n return self._eta_y\n else:\n return self._eta_x\n\n @property\n def eta_z(self):\n r\"\"\"Volume-averaged eta in z-direction.\"\"\"\n if self.case in ['VTI', 'triaxial']:\n return self._eta_z\n else:\n return self._eta_x\n\n @property\n def zeta(self):\n r\"\"\"Volume-averaged, isotropic zeta.\"\"\"\n return self._zeta\n\n\ndef expand_grid_model(model, expand, interface):\n \"\"\"Expand model and grid according to provided parameters.\n\n Expand the grid and corresponding model in positive z-direction from the\n edge of the grid to the interface with property ``expand[0]``, and a 100 m\n thick layer above the interface with property ``expand[1]``.\n\n The provided properties are taken as isotropic (as is the case in water and\n air); ``mu_r`` and ``epsilon_r`` are expanded with ones, if necessary.\n\n The ``interface`` is usually the sea-surface, and ``expand`` is therefore\n ``[property_sea, property_air]``.\n\n Parameters\n ----------\n model : Model\n The model; a :class:`emg3d.models.Model` instance.\n\n expand : list\n The two properties below and above the interface:\n ``[below_interface, above_interface]``.\n\n interface : float\n Interface between the two properties in ``expand``.\n\n\n Returns\n -------\n exp_grid : TensorMesh\n Expanded grid; a :class:`emg3d.meshes.TensorMesh` instance.\n\n exp_model : Model\n The expanded model; a :class:`emg3d.models.Model` instance.\n\n \"\"\"\n grid = model.grid\n\n def extend_property(prop, add_values, nadd):\n \"\"\"Expand property `model.prop`, IF it is not None.\"\"\"\n\n if getattr(model, prop) is None:\n prop_ext = None\n\n else:\n prop_ext = np.zeros((grid.shape_cells[0], grid.shape_cells[1],\n grid.shape_cells[2]+nadd))\n prop_ext[:, :, :-nadd] = getattr(model, prop)\n if nadd == 2:\n prop_ext[:, :, -2] = add_values[0]\n prop_ext[:, :, -1] = add_values[1]\n\n return prop_ext\n\n # Initiate.\n nzadd = 0\n hz_ext = grid.h[2]\n\n # Fill-up property_below.\n if grid.nodes_z[-1] < interface-0.05: # At least 5 cm.\n hz_ext = np.r_[hz_ext, interface-grid.nodes_z[-1]]\n nzadd += 1\n\n # Add 100 m of property_above.\n if grid.nodes_z[-1] <= interface+0.001: # +1mm\n hz_ext = np.r_[hz_ext, 100]\n nzadd += 1\n\n if nzadd > 0:\n # Extend properties.\n property_x = extend_property('property_x', expand, nzadd)\n property_y = extend_property('property_y', expand, nzadd)\n property_z = extend_property('property_z', expand, nzadd)\n mu_r = extend_property('mu_r', [1, 1], nzadd)\n epsilon_r = extend_property('epsilon_r', [1, 1], nzadd)\n\n # Create extended grid and model.\n grid = meshes.TensorMesh(\n [grid.h[0], grid.h[1], hz_ext], origin=grid.origin)\n model = Model(grid, property_x, property_y, property_z, mu_r,\n epsilon_r, mapping=model.map.name)\n\n return model\n", "meta": {"hexsha": "9762380fe3c5f2c525b9d4ee371d5e2b066cee0a", "size": 20703, "ext": "py", "lang": "Python", "max_stars_repo_path": "emg3d/models.py", "max_stars_repo_name": "emsig/emg3d", "max_stars_repo_head_hexsha": "5c1e132e0b0a49185b2ca3df2c4b45b7a4914fab", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 14, "max_stars_repo_stars_event_min_datetime": "2020-12-16T08:14:30.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-03T01:05:57.000Z", "max_issues_repo_path": "emg3d/models.py", "max_issues_repo_name": "victortocantins/emg3d", "max_issues_repo_head_hexsha": "e3aba4274424ae61094234946425240883aa2b91", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 92, "max_issues_repo_issues_event_min_datetime": "2020-12-10T09:31:55.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-30T17:44:33.000Z", "max_forks_repo_path": "emg3d/models.py", "max_forks_repo_name": "victortocantins/emg3d", "max_forks_repo_head_hexsha": "e3aba4274424ae61094234946425240883aa2b91", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-07-16T13:52:24.000Z", "max_forks_repo_forks_event_max_datetime": "2021-07-19T00:54:15.000Z", "avg_line_length": 33.6087662338, "max_line_length": 79, "alphanum_fraction": 0.6006858909, "include": true, "reason": "import numpy,from scipy", "num_tokens": 4872, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118493816806, "lm_q2_score": 0.38121956625614994, "lm_q1q2_score": 0.1935878129610176}} {"text": "\"\"\"\nModule of various types of time_evolution\n\"\"\"\n\nfrom copy import deepcopy\nfrom numba import float64, int64, jit, void\nfrom numpy import arange, array, cos, cross, pi, sin, sqrt, zeros\nfrom scipy.linalg import norm\n\n\nclass Integrator:\n \"\"\"\n Class used to assign integrator type.\n\n Attributes\n ----------\n dt : float\n Timestep.\n\n kB : float\n Boltzmann constant.\n\n magnetized : bool\n Magnetized simulation flag.\n\n species_num : numpy.ndarray\n Number of particles of each species.\n\n species_plasma_frequencies : numpy.ndarray\n Plasma frequency of each species.\n\n box_lengths : numpy.ndarray\n Length of each box side.\n\n pbox_lengths : numpy.ndarray\n Initial particle box sides' lengths.\n\n verbose : bool\n Verbose output flag.\n\n type : str\n Integrator type.\n\n \"\"\"\n\n dt: float = None\n kB: float = None\n\n # attributes\n type: str = None\n supported_integrators = {}\n equilibration_type: str = \"verlet\"\n magnetization_type: str = \"magnetic_verlet\"\n production_type: str = \"verlet\"\n\n species_num = None\n species_plasma_frequencies = None\n\n # Thermostat attributes\n thermalization: bool = True\n thermostat_type: str = \"berendsen\"\n thermalization_rate: float = 2.0\n thermalization_timestep: int = 0\n berendsen_tau: float = None\n thermostat_temperatures = None\n thermostat_temperatures_eV = None\n\n # Magnetic attributes\n magnetized: bool = False\n magnetic_field_uvector = None\n magnetic_field = None\n omega_c = None\n species_cyclotron_frequencies = None\n ccodt = None\n cdt = None\n ssodt = None\n sdt = None\n v_B = None\n v_F = None\n\n # Langevin attributes\n c1 = None\n c2 = None\n sigma = None\n box_lengths = None\n pbox_lengths = None\n\n boundary_conditions = None\n\n supported_boundary_conditions = {}\n\n verbose: bool = False\n\n # def __repr__(self):\n # sortedDict = dict(sorted(self.__dict__.items(), key=lambda x: x[0].lower()))\n # disp = 'Integrator( \\n'\n # for key, value in sortedDict.items():\n # disp += \"\\t{} : {}\\n\".format(key, value)\n # disp += ')'\n # return disp\n\n def __copy__(self):\n \"\"\"Make a shallow copy of the object using copy by creating a new instance of the object and copying its __dict__.\"\"\"\n # Create a new object\n _copy = type(self)()\n # copy the dictionary\n _copy.from_dict(input_dict=self.__dict__)\n return _copy\n\n def __deepcopy__(self, memodict={}):\n \"\"\"Make a deepcopy of the object.\n\n Parameters\n ----------\n memodict: dict\n Dictionary of id's to copies\n\n Returns\n -------\n _copy: :class:`sarkas.time_evolution.integrators.Integrator`\n A new Integrator class.\n \"\"\"\n id_self = id(self) # memorization avoids unnecessary recursion\n _copy = memodict.get(id_self)\n if _copy is None:\n _copy = type(self)()\n # Make a deepcopy of the mutable arrays using numpy copy function\n for k, v in self.__dict__.items():\n if k != \"thread_ls\":\n _copy.__dict__[k] = deepcopy(v, memodict)\n\n return _copy\n\n def from_dict(self, input_dict: dict):\n \"\"\"\n Update attributes from input dictionary.\n\n Parameters\n ----------\n input_dict: dict\n Dictionary to be copied.\n\n \"\"\"\n self.__dict__.update(input_dict)\n\n def copy_params(self, params):\n \"\"\"\n Copy necessary parameters.\n\n Parameters\n ----------\n params: :class:`sarkas.core.Parameters`\n Simulation's parameters.\n\n \"\"\"\n self.box_lengths = params.box_lengths\n self.pbox_lengths = params.pbox_lengths\n self.dimensions = params.dimensions\n self.kB = params.kB\n self.eV2K = params.eV2K\n self.total_num_ptcls = params.total_num_ptcls\n self.species_num = params.species_num.copy()\n self.species_plasma_frequencies = params.species_plasma_frequencies.copy()\n self.species_masses = params.species_masses.copy()\n self.species_temperatures = params.species_temperatures.copy()\n self.verbose = params.verbose\n # Enforce consistency\n if not self.boundary_conditions:\n self.boundary_conditions = params.boundary_conditions.lower()\n\n # Check whether you input temperatures in eV or K\n if self.thermalization and self.thermostat_temperatures:\n self.thermostat_temperatures_eV = self.thermostat_temperatures.copy() / self.eV2K\n elif self.thermalization and self.thermostat_temperatures_eV:\n self.thermostat_temperatures = self.thermostat_temperatures_eV.copy() * self.eV2K\n elif self.thermalization and not self.thermostat_temperatures:\n self.thermostate_temperatures = params.species_temperatures.copy()\n self.thermostate_temperatures_eV = params.species_temperatures_eV.copy()\n\n # Backwards compatibility\n if hasattr(self, \"equilibration_steps\"):\n params.equilibration_steps = self.equilibration_steps\n\n if hasattr(self, \"magnetization_steps\"):\n params.equilibration_steps = self.magnetization_steps\n\n if hasattr(self, \"production_steps\"):\n params.production_steps = self.production_steps\n\n if hasattr(self, \"eq_dump_step\"):\n params.eq_dump_step = self.eq_dump_step\n\n if hasattr(self, \"mag_dump_step\"):\n params.mag_dump_step = self.mag_dump_step\n\n if hasattr(self, \"eq_dump_step\"):\n params.prod_dump_step = self.prod_dump_step\n\n if not self.boundary_conditions:\n self.boundary_conditions = params.boundary_conditions\n\n if not hasattr(params, \"boundary_conditions\"):\n params.boundary_conditions = self.boundary_conditions\n\n if params.magnetized:\n self.magnetized = True\n self.magnetic_field = params.magnetic_field.copy()\n self.species_cyclotron_frequencies = params.species_cyclotron_frequencies.copy()\n\n def setup(self, params, potential):\n \"\"\"\n Assign attributes from simulation's parameters and classes.\n\n Parameters\n ----------\n params : :class:`sarkas.core.Parameters`\n Parameters class.\n\n potential : :class:`sarkas.potentials.core.Potential`\n Potential class.\n\n \"\"\"\n if self.dt is None:\n raise ValueError(\"integrator.dt is None. Please define Integrator.dt\")\n\n self.copy_params(params)\n\n if self.magnetized:\n self.magnetic_setup()\n\n if self.type:\n self.type = self.type.lower()\n self.equilibration_type = self.type\n self.production_type = self.type\n\n self.boundary_condition_setup()\n\n if self.thermalization:\n self.thermostat_setup()\n\n self.pot_acc_setup(potential)\n\n def pot_acc_setup(self, potential):\n \"\"\"\n Link the :meth:`.update_accelerations` method depending on the potential algorithm.\n\n Parameters\n ----------\n potential : :class:`sarkas.potentials.core.Potential`\n Potential class.\n\n \"\"\"\n\n self.potential_type = potential.type\n if potential.method != \"fmm\":\n if potential.pppm_on:\n self.update_accelerations = potential.update_pppm\n else:\n if potential.linked_list_on:\n self.update_accelerations = potential.update_linked_list\n else:\n self.update_accelerations = potential.update_brute\n else:\n self.update_accelerations = (\n potential.update_fmm_coulomb if potential.type == \"coulomb\" else potential.update_fmm_yukawa\n )\n\n def boundary_condition_setup(self):\n\n self.supported_boundary_conditions = {\n \"periodic\": self.periodic_bc,\n \"absorbing\": self.absorbing_bc,\n \"reflective\": self.reflecting_bc,\n \"open\": self.open_bc,\n }\n msg = (\n f\"Unsupported boundary conditions. \"\n f\"Choose one of the supported boundary conditions\\n{self.supported_boundary_conditions.keys()}\",\n )\n # Assign integrator.enforce_bc to the correct method\n self.enforce_bc = self.supported_boundary_conditions.get(self.boundary_conditions, ValueError(msg))\n\n def thermostat_setup(self):\n \"\"\"\n Assign attributes from simulation's parameters.\n\n Raises\n ------\n ValueError\n If a thermostat different than Berendsen is chosen.\n\n \"\"\"\n\n self.thermostat_type = self.thermostat_type.lower()\n\n if self.thermostat_type != \"berendsen\":\n raise ValueError(\"Only Berendsen thermostat is supported.\")\n\n if self.berendsen_tau:\n self.thermalization_rate = 1.0 / self.berendsen_tau\n else:\n self.berendsen_tau = 1.0 / self.thermalization_rate\n\n def type_setup(self, int_type):\n \"\"\"\n\n Parameters\n ----------\n int_type: str\n Integrator type to use.\n\n Raises\n ------\n : ValueError\n If `int_type` is not a supported integrator.\n\n \"\"\"\n\n # if int_type not in self.supported_integrators:\n # raise ValueError(\n # \"Integrator not supported. \" \"Please choose one of the supported integrators \\n\",\n # self.supported_integrators,\n # )\n\n # Assign integrator.update to the correct method\n\n if int_type == \"langevin\":\n\n self.sigma = sqrt(2.0 * self.langevin_gamma * self.kB * self.species_temperatures / self.species_masses)\n self.c1 = 1.0 - 0.5 * self.langevin_gamma * self.dt\n self.c2 = 1.0 / (1.0 + 0.5 * self.langevin_gamma * self.dt)\n\n elif int_type == \"magnetic_verlet\":\n\n # Calculate functions for magnetic integrator\n # This could be used when the generalization to Forest-Ruth and MacLachlan algorithms will be implemented\n # In a magnetic Velocity-Verlet the coefficient is 1/2, see eq.~(78) in :cite:`Chin2008`\n self.magnetic_helpers(0.5)\n\n if self.magnetic_field_uvector @ array([0.0, 0.0, 1.0]) == 1.0: # dot product\n int_type = \"magnetic_verlet_zdir\"\n\n elif int_type == \"magnetic_pos_verlet\":\n # Calculate functions for magnetic integrator\n # This could be used when the generalization to Forest-Ruth and MacLachlan algorithms will be implemented\n # In a magnetic Velocity-Verlet the coefficient is 1/2, see eq.~(78) in :cite:`Chin2008`\n self.magnetic_helpers(1.0)\n\n if self.magnetic_field_uvector @ array([0.0, 0.0, 1.0]) == 1.0: # dot product\n int_type = \"magnetic_pos_verlet_zdir\"\n\n elif int_type == \"magnetic_boris\":\n\n # In a leapfrog-type algorithm the coefficient is different for the acceleration and magnetic rotation\n # see eq.~(79) in :cite:`Chin2008`\n self.magnetic_helpers(1.0)\n\n if self.magnetic_field_uvector @ array([0.0, 0.0, 1.0]) == 1.0: # dot product\n int_type = \"magnetic_boris_zdir\"\n\n elif int_type == \"cyclotronic\":\n # Calculate functions for magnetic integrator\n # This could be used when the generalization to Forest-Ruth and MacLachlan algorithms will be implemented\n # In a magnetic Velocity-Verlet the coefficient is 1/2, see eq.~(78) in :cite:`Chin2008`\n self.magnetic_helpers(0.5)\n\n if self.magnetic_field_uvector @ array([0.0, 0.0, 1.0]) == 1.0: # dot product\n int_type = \"cyclotronic_zdir\"\n\n self.supported_integrators = {\n \"verlet\": self.verlet,\n \"langevin\": self.langevin,\n \"magnetic_verlet\": self.magnetic_verlet,\n \"magnetic_verlet_zdir\": self.magnetic_verlet_zdir,\n \"magnetic_pos_verlet\": self.magnetic_pos_verlet,\n \"magnetic_pos_verlet_zdir\": self.magnetic_pos_verlet_zdir,\n \"magnetic_boris\": self.magnetic_boris,\n \"magnetic_boris_zdir\": self.magnetic_boris_zdir,\n \"cyclotronic\": self.cyclotronic,\n \"cyclotronic_zdir\": self.cyclotronic_zdir,\n }\n\n msg = f\"Integrator not supported. Please choose one of the supported integrators \\n{self.supported_integrators.keys()}\"\n\n return self.supported_integrators.get(int_type, ValueError(msg))\n\n def magnetic_setup(self):\n # Create the unit vector of the magnetic field\n self.magnetic_field_uvector = self.magnetic_field / norm(self.magnetic_field)\n self.omega_c = zeros((self.total_num_ptcls, 3))\n\n sp_start = 0\n sp_end = 0\n for ic, sp_np in enumerate(self.species_num):\n sp_end += sp_np\n self.omega_c[sp_start:sp_end, :] = self.species_cyclotron_frequencies[ic]\n sp_start += sp_np\n\n # array to temporary store velocities\n # Luciano: I have the vague doubt that allocating memory for these arrays is faster than calculating them\n # each time step\n self.v_B = zeros((self.total_num_ptcls, 3))\n self.v_F = zeros((self.total_num_ptcls, 3))\n\n def langevin(self, ptcls):\n \"\"\"\n Update particles class using the velocity verlet algorithm and Langevin damping.\n\n Parameters\n ----------\n ptcls: :class:`sarkas.particles.Particles`\n Particles data.\n\n\n \"\"\"\n\n beta = ptcls.gaussian(0.0, 1.0, (self.total_num_ptcls, self.dimensions))\n sp_start = 0 # start index for species loop\n sp_end = 0\n for ic, num in enumerate(self.species_num):\n sp_end += num\n ptcls.pos[sp_start:sp_end, : self.dimensions] += (\n self.c1 * self.dt * ptcls.vel[sp_start:sp_end, : self.dimensions]\n + 0.5 * self.dt**2 * ptcls.acc[sp_start:sp_end, : self.dimensions]\n + 0.5 * self.sigma[ic] * self.dt**1.5 * beta\n )\n sp_start += num\n\n # Enforce boundary condition\n self.enforce_bc(ptcls)\n\n acc_old = ptcls.acc.copy()\n self.update_accelerations(ptcls)\n\n sp_start = 0\n sp_end = 0\n for ic, num in enumerate(self.species_num):\n sp_end += num\n\n ptcls.vel[sp_start:sp_end, : self.dimensions] = (\n self.c1 * self.c2 * ptcls.vel[sp_start:sp_end, : self.dimensions]\n + 0.5\n * self.c2\n * self.dt\n * (ptcls.acc[sp_start:sp_end, : self.dimensions] + acc_old[sp_start:sp_end, : self.dimensions])\n + self.c2 * self.sigma[ic] * sqrt(self.dt) * beta\n )\n sp_start += num\n\n def verlet(self, ptcls):\n \"\"\"\n Update particles' class based on velocity verlet algorithm.\n More information can be found here: https://en.wikipedia.org/wiki/Verlet_integration\n or on the Sarkas website.\n\n Parameters\n ----------\n ptcls: :class:`sarkas.particles.Particles`\n Particles data.\n\n \"\"\"\n # First half step velocity update\n ptcls.vel += 0.5 * ptcls.acc * self.dt\n # Full step position update\n ptcls.pos += ptcls.vel * self.dt\n # Enforce boundary condition\n self.enforce_bc(ptcls)\n # Compute total potential energy and acceleration for second half step velocity update\n self.update_accelerations(ptcls)\n # Second half step velocity update\n ptcls.vel += 0.5 * ptcls.acc * self.dt\n\n def magnetic_helpers(self, coefficient):\n \"\"\"Calculate the trigonometric functions of the magnetic integrators.\n\n Parameters\n ----------\n coefficient: float\n Timestep coefficient.\n\n Notes\n -----\n This is useful for the Leapfrog magnetic algorithm and future Forest-Ruth and MacLachlan algorithms.\n\n \"\"\"\n theta = self.omega_c * self.dt * coefficient\n self.sdt = sin(theta)\n self.cdt = cos(theta)\n self.ccodt = 1.0 - self.cdt\n self.ssodt = 1.0 - self.sdt / theta\n\n def magnetic_verlet_zdir(self, ptcls):\n \"\"\"\n Update particles' class based on velocity verlet method in the case of a\n constant magnetic field along the :math:`z` axis. For more info see eq. (78) of Ref. :cite:`Chin2008`\n\n Parameters\n ----------\n ptcls: :class:`sarkas.particles.Particles`\n Particles data.\n\n Returns\n -------\n potential_energy : float\n Total potential energy.\n\n Notes\n -----\n This integrator is faster than `magnetic_verlet` but valid only for a magnetic field in the :math:`z`-direction.\n This is the preferred choice in this case.\n \"\"\"\n\n # First half step of velocity update\n # # Magnetic rotation x - velocity\n # (B x v)_x = -v_y, (B x B x v)_x = -v_x\n self.v_B[:, 0] = ptcls.vel[:, 1] * self.sdt[:, 0] + ptcls.vel[:, 0] * self.cdt[:, 0]\n # Magnetic rotation y - velocity\n # (B x v)_y = v_x, (B x B x v)_y = -v_y\n self.v_B[:, 1] = -ptcls.vel[:, 0] * self.sdt[:, 0] + ptcls.vel[:, 1] * self.cdt[:, 1]\n\n # Magnetic + Const force field x - velocity\n # (B x a)_x = -a_y, (B x B x a)_x = -a_x\n self.v_F[:, 0] = (\n self.ccodt[:, 1] / self.omega_c[:, 1] * ptcls.acc[:, 1]\n + self.sdt[:, 0] / self.omega_c[:, 0] * ptcls.acc[:, 0]\n )\n # Magnetic + Const force field y - velocity\n # (B x a)_y = a_x, (B x B x a)_y = -a_y\n self.v_F[:, 1] = (\n -self.ccodt[:, 0] / self.omega_c[:, 0] * ptcls.acc[:, 0]\n + self.sdt[:, 1] / self.omega_c[:, 1] * ptcls.acc[:, 1]\n )\n\n ptcls.vel[:, 0] = self.v_B[:, 0] + self.v_F[:, 0]\n ptcls.vel[:, 1] = self.v_B[:, 1] + self.v_F[:, 1]\n ptcls.vel[:, 2] += 0.5 * self.dt * ptcls.acc[:, 2]\n\n # Position update\n ptcls.pos += ptcls.vel * self.dt\n\n # Enforce boundary condition\n self.enforce_bc(ptcls)\n\n # Compute total potential energy and acceleration for second half step velocity update\n potential_energy = self.update_accelerations(ptcls)\n\n # # Magnetic rotation x - velocity\n # (B x v)_x = -v_y, (B x B x v)_x = -v_x\n self.v_B[:, 0] = ptcls.vel[:, 1] * self.sdt[:, 0] + ptcls.vel[:, 0] * self.cdt[:, 0]\n # Magnetic rotation y - velocity\n # (B x v)_y = v_x, (B x B x v)_y = -v_y\n self.v_B[:, 1] = -ptcls.vel[:, 0] * self.sdt[:, 0] + ptcls.vel[:, 1] * self.cdt[:, 1]\n\n # Magnetic + Const force field x - velocity\n # (B x a)_x = -a_y, (B x B x a)_x = -a_x\n self.v_F[:, 0] = (\n self.ccodt[:, 1] / self.omega_c[:, 1] * ptcls.acc[:, 1]\n + self.sdt[:, 0] / self.omega_c[:, 0] * ptcls.acc[:, 0]\n )\n # Magnetic + Const force field y - velocity\n # (B x a)_y = a_x, (B x B x a)_y = -a_y\n self.v_F[:, 1] = (\n -self.ccodt[:, 0] / self.omega_c[:, 0] * ptcls.acc[:, 0]\n + self.sdt[:, 1] / self.omega_c[:, 1] * ptcls.acc[:, 1]\n )\n\n ptcls.vel[:, 0] = self.v_B[:, 0] + self.v_F[:, 0]\n ptcls.vel[:, 1] = self.v_B[:, 1] + self.v_F[:, 1]\n ptcls.vel[:, 2] += 0.5 * self.dt * ptcls.acc[:, 2]\n\n return potential_energy\n\n def magnetic_verlet(self, ptcls):\n \"\"\"\n Update particles' class based on velocity verlet method in the case of an arbitrary direction of the\n constant magnetic field. For more info see eq. (78) of Ref. :cite:`Chin2008`\n\n Parameters\n ----------\n ptcls: :class:`sarkas.particles.Particles`\n Particles data.\n\n Returns\n -------\n potential_energy : float\n Total potential energy.\n\n Notes\n -----\n :cite:`Chin2008` equations are written for a negative charge. This allows him to write\n :math:`\\\\dot{\\\\mathbf v} = \\\\omega_c \\\\hat{B} \\\\times \\\\mathbf v`. In the case of positive charges we will have\n :math:`\\\\dot{\\\\mathbf v} = - \\\\omega_c \\\\hat{B} \\\\times \\\\mathbf v`.\n Hence the reason of the different signs in the formulas below compared to Chin's.\n\n Warnings\n --------\n This integrator is valid for a magnetic field in an arbitrary direction. However, while the integrator works for\n an arbitrary direction, methods in :mod:`sarkas.tools.observables` work only for a magnetic field in the\n :math:`z` - direction. Hence, if you choose to use this integrator remember to change your physical observables.\n\n \"\"\"\n # Calculate the cross products\n b_cross_v = cross(self.magnetic_field_uvector, ptcls.vel)\n b_cross_b_cross_v = cross(self.magnetic_field_uvector, b_cross_v)\n b_cross_a = cross(self.magnetic_field_uvector, ptcls.acc)\n b_cross_b_cross_a = cross(self.magnetic_field_uvector, b_cross_a)\n\n # First half step of velocity update\n ptcls.vel += -self.sdt * b_cross_v + self.ccodt * b_cross_b_cross_v\n\n ptcls.vel += (\n 0.5 * ptcls.acc * self.dt\n - self.ccodt / self.omega_c * b_cross_a\n + 0.5 * self.dt * self.ssodt * b_cross_b_cross_a\n )\n\n # Position update\n ptcls.pos += ptcls.vel * self.dt\n\n # Enforce boundary condition\n self.enforce_bc(ptcls)\n\n # Compute total potential energy and acceleration for second half step velocity update\n potential_energy = self.update_accelerations(ptcls)\n\n # Re-calculate the cross products\n b_cross_v = cross(self.magnetic_field_uvector, ptcls.vel)\n b_cross_b_cross_v = cross(self.magnetic_field_uvector, b_cross_v)\n b_cross_a = cross(self.magnetic_field_uvector, ptcls.acc)\n b_cross_b_cross_a = cross(self.magnetic_field_uvector, b_cross_a)\n\n # Second half step velocity update\n ptcls.vel += -self.sdt * b_cross_v + self.ccodt * b_cross_b_cross_v\n\n ptcls.vel += (\n 0.5 * ptcls.acc * self.dt\n - self.ccodt / self.omega_c * b_cross_a\n + 0.5 * self.dt * self.ssodt * b_cross_b_cross_a\n )\n\n return potential_energy\n\n def magnetic_boris_zdir(self, ptcls):\n \"\"\"\n Update particles' class using the Boris algorithm in the case of a\n constant magnetic field along the :math:`z` axis. For more info see eqs. (80) - (81) of Ref. :cite:`Chin2008`\n\n Parameters\n ----------\n ptcls: :class:`sarkas.particles.Particles`\n Particles data.\n\n Returns\n -------\n potential_energy : float\n Total potential energy.\n\n \"\"\"\n # First half step of velocity update: Apply exp(dt * V_F / 2)\n ptcls.vel += 0.5 * ptcls.acc * self.dt\n\n # Rotate: Apply exp( dt * V)\n # B cross v\n self.v_B[:, 0] = -self.sdt[:, 1] * ptcls.vel[:, 1]\n self.v_B[:, 1] = self.sdt[:, 0] * ptcls.vel[:, 0]\n\n # B cross B cross v\n self.v_B[:, 0] -= self.ccodt[:, 0] * ptcls.vel[:, 0]\n self.v_B[:, 1] -= self.ccodt[:, 1] * ptcls.vel[:, 1]\n # Update velocities\n ptcls.vel[:, :2] += self.v_B[:, :2]\n\n # Second Acceleration half step: Apply exp(dt * V_F / 2)\n ptcls.vel += 0.5 * ptcls.acc * self.dt\n\n # Full step position update\n ptcls.pos += ptcls.vel * self.dt\n\n # Enforce boundary condition\n self.enforce_bc(ptcls)\n\n # Compute total potential energy and acceleration for second half step velocity update\n potential_energy = self.update_accelerations(ptcls)\n\n return potential_energy\n\n def magnetic_boris(self, ptcls):\n \"\"\"\n Update particles' class using the Boris algorithm in the case of a\n constant magnetic field along the :math:`z` axis. For more info see eqs. (80) - (81) of Ref. :cite:`Chin2008`\n\n Parameters\n ----------\n ptcls: :class:`sarkas.particles.Particles`\n Particles data.\n\n Returns\n -------\n potential_energy : float\n Total potential energy.\n\n \"\"\"\n\n # First half step of velocity update: Apply exp(eV_F/2)\n ptcls.vel += 0.5 * ptcls.acc * self.dt\n\n # Rotate: Apply exp( dt * V)\n # B cross v\n b_cross_v = cross(self.magnetic_field_uvector, ptcls.vel)\n # B cross B cross v\n b_cross_b_cross_v = cross(self.magnetic_field_uvector, b_cross_v)\n ptcls.vel += self.sdt * b_cross_v + self.ccodt * b_cross_b_cross_v\n\n # Second Acceleration half step: Apply exp(dt * V_F / 2)\n ptcls.vel += 0.5 * ptcls.acc * self.dt\n\n # Full step position update\n ptcls.pos += ptcls.vel * self.dt\n\n # Periodic boundary condition\n enforce_pbc(ptcls.pos, ptcls.pbc_cntr, self.box_lengths)\n\n # Compute total potential energy and acceleration for second half step velocity update\n potential_energy = self.update_accelerations(ptcls)\n\n return potential_energy\n\n def magnetic_pos_verlet_zdir(self, ptcls):\n \"\"\"\n Update particles' class based on position verlet method in the case of a\n constant magnetic field along the :math:`z` axis. For more info see eq. (79) of Ref. :cite:`Chin2008`\n\n Parameters\n ----------\n ptcls: :class:`sarkas.particles.Particles`\n Particles data.\n\n Returns\n -------\n potential_energy : float\n Total potential energy.\n\n Notes\n -----\n This integrator is faster than `magnetic_verlet` but valid only for a magnetic field in the :math:`z`-direction.\n This is the preferred choice in this case.\n \"\"\"\n\n # Position update\n ptcls.pos += 0.5 * ptcls.vel * self.dt\n\n # Enforce boundary condition\n self.enforce_bc(ptcls)\n\n # Compute total potential energy and acceleration for second half step velocity update\n potential_energy = self.update_accelerations(ptcls)\n\n # First half step of velocity update\n # # Magnetic rotation x - velocity\n # (B x v)_x = -v_y, (B x B x v)_x = -v_x\n self.v_B[:, 0] = ptcls.vel[:, 1] * self.sdt[:, 0] + ptcls.vel[:, 0] * self.cdt[:, 0]\n # Magnetic rotation y - velocity\n # (B x v)_y = v_x, (B x B x v)_y = -v_y\n self.v_B[:, 1] = -ptcls.vel[:, 0] * self.sdt[:, 0] + ptcls.vel[:, 1] * self.cdt[:, 1]\n\n # Magnetic + Const force field x - velocity\n # (B x a)_x = -a_y, (B x B x a)_x = -a_x\n self.v_F[:, 0] = (\n self.ccodt[:, 1] / self.omega_c[:, 1] * ptcls.acc[:, 1]\n + self.sdt[:, 0] / self.omega_c[:, 0] * ptcls.acc[:, 0]\n )\n # Magnetic + Const force field y - velocity\n # (B x a)_y = a_x, (B x B x a)_y = -a_y\n self.v_F[:, 1] = (\n -self.ccodt[:, 0] / self.omega_c[:, 0] * ptcls.acc[:, 0]\n + self.sdt[:, 1] / self.omega_c[:, 1] * ptcls.acc[:, 1]\n )\n\n ptcls.vel[:, 0] = self.v_B[:, 0] + self.v_F[:, 0]\n ptcls.vel[:, 1] = self.v_B[:, 1] + self.v_F[:, 1]\n ptcls.vel[:, 2] += self.dt * ptcls.acc[:, 2]\n\n # Position update\n ptcls.pos += 0.5 * ptcls.vel * self.dt\n\n # Enforce boundary condition\n self.enforce_bc(ptcls)\n\n return potential_energy\n\n def magnetic_pos_verlet(self, ptcls):\n \"\"\"\n Update particles' class based on position verlet method in the case of an arbitrary direction of the\n constant magnetic field. For more info see eq. (79) of Ref. :cite:`Chin2008`\n\n Parameters\n ----------\n ptcls: :class:`sarkas.particles.Particles`\n Particles data.\n\n Returns\n -------\n potential_energy : float\n Total potential energy.\n\n Notes\n -----\n :cite:`Chin2008` equations are written for a negative charge. This allows him to write\n :math:`\\\\dot{\\\\mathbf v} = \\\\omega_c \\\\hat{B} \\\\times \\\\mathbf v`. In the case of positive charges we will have\n :math:`\\\\dot{\\\\mathbf v} = - \\\\omega_c \\\\hat{B} \\\\times \\\\mathbf v`.\n Hence the reason of the different signs in the formulas below compared to Chin's.\n\n Warnings\n --------\n This integrator is valid for a magnetic field in an arbitrary direction. However, while the integrator works for\n an arbitrary direction, methods in :mod:`sarkas.tools.observables` work only for a magnetic field in the\n :math:`z` - direction. Hence, if you choose to use this integrator remember to change your physical observables.\n\n \"\"\"\n # Half position update\n ptcls.pos += ptcls.vel * self.dt\n\n # Enforce boundary condition\n self.enforce_bc(ptcls)\n\n # Compute total potential energy and acceleration for second half step velocity update\n potential_energy = self.update_accelerations(ptcls)\n\n # Calculate the cross products\n b_cross_v = cross(self.magnetic_field_uvector, ptcls.vel)\n b_cross_b_cross_v = cross(self.magnetic_field_uvector, b_cross_v)\n b_cross_a = cross(self.magnetic_field_uvector, ptcls.acc)\n b_cross_b_cross_a = cross(self.magnetic_field_uvector, b_cross_a)\n\n # First half step of velocity update\n ptcls.vel += -self.sdt * b_cross_v + self.ccodt * b_cross_b_cross_v\n\n ptcls.vel += (\n ptcls.acc * self.dt - self.ccodt / self.omega_c * b_cross_a + self.dt * self.ssodt * b_cross_b_cross_a\n )\n\n # Second half position update\n ptcls.pos += ptcls.vel * self.dt\n\n # Enforce boundary condition\n self.enforce_bc(ptcls)\n\n return potential_energy\n\n def cyclotronic_zdir(self, ptcls):\n \"\"\"\n Update particles' class using the cyclotronic algorithm in the case of a\n constant magnetic field along the :math:`z` axis.\n For more info see eqs. (16) - (17) of Ref. :cite:`Patacchini2009`\n\n Parameters\n ----------\n ptcls: :class:`sarkas.particles.Particles`\n Particles data.\n\n Returns\n -------\n potential_energy : float\n Total potential energy.\n\n \"\"\"\n # Drift half step\n # Rotate Positions\n ptcls.pos[:, 0] += (\n ptcls.vel[:, 0] * self.sdt[:, 0] / self.omega_c[:, 0]\n + ptcls.vel[:, 1] * self.ccodt[:, 1] / self.omega_c[:, 1]\n )\n ptcls.pos[:, 1] += (\n ptcls.vel[:, 1] * self.sdt[:, 1] / self.omega_c[:, 1]\n - ptcls.vel[:, 0] * self.ccodt[:, 0] / self.omega_c[:, 0]\n )\n ptcls.pos[:, 2] += 0.5 * ptcls.vel[:, 2] * self.dt\n # Enforce boundary condition\n self.enforce_bc(ptcls)\n # Create rotated velocities\n self.v_B[:, 0] = self.cdt[:, 0] * ptcls.vel[:, 0] + self.sdt[:, 1] * ptcls.vel[:, 1]\n self.v_B[:, 1] = self.cdt[:, 1] * ptcls.vel[:, 1] - self.sdt[:, 0] * ptcls.vel[:, 0]\n ptcls.vel[:, :2] = self.v_B[:, :2].copy()\n # Compute total potential energy and accelerations\n potential_energy = self.update_accelerations(ptcls)\n\n # Kick full step\n ptcls.vel += ptcls.acc * self.dt\n\n # Drift half step\n # Rotate Positions\n ptcls.pos[:, 0] += (\n ptcls.vel[:, 0] * self.sdt[:, 0] / self.omega_c[:, 0]\n + ptcls.vel[:, 1] * self.ccodt[:, 1] / self.omega_c[:, 1]\n )\n ptcls.pos[:, 1] += (\n ptcls.vel[:, 1] * self.sdt[:, 1] / self.omega_c[:, 1]\n - ptcls.vel[:, 0] * self.ccodt[:, 0] / self.omega_c[:, 0]\n )\n ptcls.pos[:, 2] += 0.5 * ptcls.vel[:, 2] * self.dt\n # Enforce boundary condition\n self.enforce_bc(ptcls)\n # Create rotated velocities\n self.v_B[:, 0] = self.cdt[:, 0] * ptcls.vel[:, 0] + self.sdt[:, 1] * ptcls.vel[:, 1]\n self.v_B[:, 1] = self.cdt[:, 1] * ptcls.vel[:, 1] - self.sdt[:, 0] * ptcls.vel[:, 0]\n # Update final velocities\n ptcls.vel[:, :2] = self.v_B[:, :2].copy()\n\n return potential_energy\n\n def cyclotronic(self, ptcls):\n \"\"\"\n Update particles' class using the cyclotronic algorithm in the case of a\n constant magnetic field along the :math:`z` axis.\n For more info see eqs. (16) - (17) of Ref. :cite:`Patacchini2009`\n\n Parameters\n ----------\n ptcls: :class:`sarkas.particles.Particles`\n Particles data.\n\n Returns\n -------\n potential_energy : float\n Total potential energy.\n\n \"\"\"\n # Drift half step\n\n # Calculate the cross products\n b_cross_v = cross(self.magnetic_field_uvector, ptcls.vel)\n b_cross_b_cross_v = cross(self.magnetic_field_uvector, b_cross_v)\n # Rotate Positions\n ptcls.pos += (\n 0.5 * ptcls.vel * self.dt\n - self.ccodt * b_cross_v / self.omega_c\n + 0.5 * self.dt * self.ssodt * b_cross_b_cross_v\n )\n # Enforce boundary condition\n self.enforce_bc(ptcls)\n # First half step of velocity update\n ptcls.vel += -self.sdt * b_cross_v + self.ccodt * b_cross_b_cross_v\n # Compute total potential energy and accelerations\n potential_energy = self.update_accelerations(ptcls)\n\n # Kick full step\n ptcls.vel += ptcls.acc * self.dt\n\n # Drift half step\n # Calculate the cross products\n b_cross_v = cross(self.magnetic_field_uvector, ptcls.vel)\n b_cross_b_cross_v = cross(self.magnetic_field_uvector, b_cross_v)\n # Rotate Positions\n ptcls.pos += (\n 0.5 * ptcls.vel * self.dt\n - self.ccodt * b_cross_v / self.omega_c\n + 0.5 * self.dt * self.ssodt * b_cross_b_cross_v\n )\n # Enforce boundary condition\n self.enforce_bc(ptcls)\n # Second half step of velocity update\n ptcls.vel += -self.sdt * b_cross_v + self.ccodt * b_cross_b_cross_v\n\n return potential_energy\n\n def thermostate(self, ptcls):\n \"\"\"\n Update particles' velocities according to the chosen thermostat\n\n Parameters\n ----------\n ptcls : :class:`sarkas.particles.Particles`\n Particles' data.\n\n \"\"\"\n _, T = ptcls.kinetic_temperature()\n berendsen(ptcls.vel, self.species_temperatures, T, self.species_num, self.thermalization_rate)\n\n def periodic_bc(self, ptcls):\n \"\"\"\n Applies periodic boundary conditions by calling enforce_pbc\n\n Parameters\n ----------\n ptcls: :class:`sarkas.particles.Particles`\n Particles data.\n\n \"\"\"\n\n enforce_pbc(ptcls.pos, ptcls.pbc_cntr, self.box_lengths)\n\n def absorbing_bc(self, ptcls):\n \"\"\"\n Applies absorbing boundary conditions by calling enforce_abc\n\n Parameters\n ----------\n ptcls: :class:`sarkas.particles.Particles`\n Particles data.\n\n \"\"\"\n\n enforce_abc(ptcls.pos, ptcls.vel, ptcls.acc, ptcls.charges, self.box_lengths)\n\n def open_bc(self, ptcls):\n \"\"\"\n Applies open boundary conditions. Basically it does nothing. pass\n\n Parameters\n ----------\n ptcls: :class:`sarkas.particles.Particles`\n Particles data.\n\n \"\"\"\n\n pass\n\n def reflecting_bc(self, ptcls):\n \"\"\"\n Applies reflective boundary conditions by calling enforce_rbc\n\n Parameters\n ----------\n ptcls: :class:`sarkas.particles.Particles`\n Particles data.\n\n \"\"\"\n\n enforce_rbc(ptcls.pos, ptcls.vel, self.box_lengths, self.dt)\n\n def pretty_print(self):\n \"\"\"Print integrator and thermostat information in a user-friendly way.\"\"\"\n\n if self.thermalization:\n print(\"\\nTHERMOSTAT: \")\n print(f\"Type: {self.thermostat_type}\")\n print(f\"First thermostating timestep, i.e. thermalization_timestep = {self.thermalization_timestep}\")\n print(f\"Berendsen parameter tau: {self.berendsen_tau:.3f} [timesteps]\")\n print(f\"Berendsen relaxation rate: {self.thermalization_rate:.3f} [1/timesteps] \")\n print(\"Thermostating temperatures: \")\n for i, (t, t_ev) in enumerate(zip(self.thermostate_temperatures, self.thermostate_temperatures_eV)):\n print(f\"Species ID {i}: T_eq = {t:.6e} [K] = {t_ev:.6e} [eV]\")\n\n print(\"\\nINTEGRATOR: \")\n print(f\"Equilibration Integrator Type: {self.equilibration_type}\")\n if self.magnetized:\n print(f\"Magnetization Integrator Type: {self.magnetization_type}\")\n print(f\"Production Integrator Type: {self.production_type}\")\n\n wp_tot = norm(self.species_plasma_frequencies)\n wp_dt = wp_tot * self.dt\n\n print(f\"Time step = {self.dt:.6e} [s]\")\n print(f\"Total plasma frequency = {wp_tot:.6e} [rad/s]\")\n print(f\"w_p dt = {wp_dt:.4f} ~ 1/{int(1.0 / wp_dt)}\")\n\n if self.potential_type == \"qsp\":\n wp_e = self.species_plasma_frequencies[0]\n wp_ions = norm(self.species_plasma_frequencies[1:])\n print(f\"e plasma frequency = {wp_e:.6e} [rad/s]\")\n print(f\"total ion plasma frequency = {wp_ions:.6e} [rad/s]\")\n print(f\"w_pe dt = {self.dt * wp_e:.4f} ~ 1/{int(1.0 / (self.dt * wp_e))}\")\n print(f\"w_pi dt = {self.dt * wp_ions:.4f} ~ 1/{int(1.0 / (self.dt * wp_ions))}\")\n\n elif self.potential_type == \"lj\":\n print(f\"The plasma frequency is defined as w_p = sqrt( epsilon / (sigma^2 * mass) )\")\n\n if self.magnetized:\n high_wc_dt = abs(self.species_cyclotron_frequencies).max() * self.dt\n low_wc_dt = abs(self.species_cyclotron_frequencies).min() * self.dt\n\n if high_wc_dt > low_wc_dt:\n print(f\"Highest w_c dt = {high_wc_dt:2.4f} = {high_wc_dt / pi:.4f} pi\")\n print(f\"Smallest w_c dt = {low_wc_dt:2.4f} = {low_wc_dt / pi:.4f} pi\")\n else:\n print(f\"w_c dt = {high_wc_dt:2.4f} = {high_wc_dt / pi:.4f} pi\")\n\n if self.equilibration_type == \"langevin\" or self.production_type == \"langevin\":\n print(f\"langevin_gamma * dt = {self.langevin_gamma * self.dt:.4e}\")\n print(f\"langevin_gamma / wp = {self.langevin_gamma / wp_tot:.4e}\")\n\n\n@jit(void(float64[:, :], float64[:], float64[:], int64[:], float64), nopython=True)\ndef berendsen(vel, T_desired, T, species_np, tau):\n \"\"\"\n Numba'd function to update particle velocity based on Berendsen thermostat :cite:`Berendsen1984`.\n\n Parameters\n ----------\n vel : numpy.ndarray\n Particles' velocities to rescale.\n\n T_desired : numpy.ndarray\n Target temperature of each species.\n\n T : numpy.ndarray\n Instantaneous temperature of each species.\n\n species_np : numpy.ndarray\n Number of each species.\n\n tau : float\n Scale factor.\n\n \"\"\"\n\n # if it < therm_timestep:\n # fact = sqrt(T_desired / T)\n # else:\n # fact = sqrt(1.0 + (T_desired / T - 1.0) * tau) # eq.(11)\n\n # branchless programming\n fact = sqrt(1.0 + (T_desired / T - 1.0) * tau)\n species_start = 0\n species_end = 0\n\n for i, num in enumerate(species_np):\n species_end += num\n vel[species_start:species_end, :] *= fact[i]\n species_start += num\n\n\n@jit(void(float64[:, :], float64[:, :], float64[:]), nopython=True)\ndef enforce_pbc(pos, cntr, box_vector) -> None:\n \"\"\"\n Numba'd function to enforce periodic boundary conditions.\n\n Parameters\n ----------\n pos : numpy.ndarray\n Particles' positions.\n\n cntr : numpy.ndarray\n Counter for the number of times each particle get folded back into the main simulation box\n\n box_vector : numpy.ndarray\n Box Dimensions.\n\n \"\"\"\n\n # Loop over all particles\n for p in arange(pos.shape[0]):\n for d in arange(pos.shape[1]):\n\n # If particle is outside of box in positive direction, wrap to negative side\n if pos[p, d] > box_vector[d]:\n pos[p, d] -= box_vector[d]\n cntr[p, d] += 1\n # If particle is outside of box in negative direction, wrap to positive side\n if pos[p, d] < 0.0:\n pos[p, d] += box_vector[d]\n cntr[p, d] -= 1\n\n\n@jit(void(float64[:, :], float64[:, :], float64[:, :], float64[:], float64[:]), nopython=True)\ndef enforce_abc(pos, vel, acc, charges, box_vector) -> None:\n \"\"\"\n Numba'd function to enforce absorbing boundary conditions.\n\n Parameters\n ----------\n pos: numpy.ndarray\n Particles' positions.\n\n vel : numpy.ndarray\n Particles' velocities.\n\n acc : numpy.ndarray\n Particles' accelerations.\n\n charges : numpy.ndarray\n Charge of each particle. Shape = (``total_num_ptcls``).\n\n box_vector: numpy.ndarray\n Box Dimensions.\n\n \"\"\"\n\n # Loop over all particles\n for p in arange(pos.shape[0]):\n for d in arange(pos.shape[1]):\n\n # If particle is outside of box in positive direction, remove charge, velocity and acceleration\n if pos[p, d] >= box_vector[d]:\n pos[p, d] = box_vector[d]\n vel[p, :] = zeros(3)\n acc[p, :] = zeros(3)\n charges[p] = 0.0\n # If particle is outside of box in negative direction, remove charge, velocity and acceleration\n if pos[p, d] <= 0.0:\n pos[p, d] = 0.0\n vel[p, :] = zeros(3)\n acc[p, :] = zeros(3)\n charges[p] = 0.0\n\n\n@jit(void(float64[:, :], float64[:, :], float64[:], float64), nopython=True)\ndef enforce_rbc(pos, vel, box_vector, dt) -> None:\n \"\"\"\n Numba'd function to enforce reflecting boundary conditions.\n\n Parameters\n ----------\n pos: numpy.ndarray\n Particles' positions.\n\n vel : numpy.ndarray\n Particles' velocities.\n\n box_vector: numpy.ndarray\n Box Dimensions.\n\n dt : float\n Timestep.\n\n \"\"\"\n\n # Loop over all particles\n for p in arange(pos.shape[0]):\n for d in arange(pos.shape[1]):\n\n # If particle is outside of box in positive direction, wrap to negative side\n if pos[p, d] > box_vector[d] or pos[p, d] < 0.0:\n # Revert velocity\n vel[p, d] *= -1.0\n # Restore previous position assuming verlet algorithm\n pos[p, d] += vel[p, d] * dt\n\n\n# @jit(void(float64[:, :], int64[:], float64[:]), nopython=True)\n# def remove_drift(vel, nums, masses) -> None:\n# \"\"\"\n# Numba'd function to enforce conservation of total linear momentum.\n# It updates :attr:`sarkas.particles.Particles.vel`.\n#\n# Parameters\n# ----------\n# vel: numpy.ndarray\n# Particles' velocities.\n#\n# nums: numpy.ndarray\n# Number of particles of each species.\n#\n# masses: numpy.ndarray\n# Mass of each species.\n#\n# \"\"\"\n#\n# P = zeros((len(nums), vel.shape[1]))\n# species_start = 0\n# for ic in range(len(nums)):\n# species_end = species_start + nums[ic]\n# P[ic, :] = vel[species_start:species_end, :].sum(axis=0) * masses[ic]\n# species_start = species_end\n#\n# if P.sum(axis=0).any() > 1e-40:\n# # Remove tot momentum\n# species_start = 0\n# for ic in range(len(nums)):\n# species_end = species_start + nums[ic]\n# vel[species_start:species_end, :] -= P[ic, :] / (float(nums[ic]) * masses[ic])\n# species_start = species_end\n", "meta": {"hexsha": "d687c1e22c9d4b82ddef4f7fd203b345c215fb67", "size": 43796, "ext": "py", "lang": "Python", "max_stars_repo_path": "sarkas/time_evolution/integrators.py", "max_stars_repo_name": "lucianogsilvestri/sarkas", "max_stars_repo_head_hexsha": "f4ab00014d09976561fbd4349b9d0610e47a61e1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "sarkas/time_evolution/integrators.py", "max_issues_repo_name": "lucianogsilvestri/sarkas", "max_issues_repo_head_hexsha": "f4ab00014d09976561fbd4349b9d0610e47a61e1", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "sarkas/time_evolution/integrators.py", "max_forks_repo_name": "lucianogsilvestri/sarkas", "max_forks_repo_head_hexsha": "f4ab00014d09976561fbd4349b9d0610e47a61e1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.6761678543, "max_line_length": 127, "alphanum_fraction": 0.585304594, "include": true, "reason": "from numpy,from scipy,from numba", "num_tokens": 11274, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6297745935070806, "lm_q2_score": 0.3073580295544412, "lm_q1q2_score": 0.1935662781237855}} {"text": "import numpy as np\nimport random\nfrom sub_func.get_iou import iou\n\n\n__all__ = ['calc_rpn']\n\n\ndef calc_rpn(config, img_data, width, height, resized_width, resized_height, resize_func):\n \"\"\"(Important part!) Calculate the rpn for all anchors\n If feature map has shape 38x50=1900, there are 1900x(3 x 3)=17100 potential anchors\n\n Args:\n config: Config instance\n img_data: augmented image data\n width: original image width (e.g. 600)\n height: original image height (e.g. 800)\n resized_width: resized image width according to config.im_size (e.g. 300)\n resized_height: resized image height according to config.im_size (e.g. 400)\n resize_func: function to calculate final layer's feature map (of base model) size according to input image size\n\n Returns:\n y_rpn_cls: list(num_bboxes, y_is_box_valid + y_rpn_overlap)\n y_is_box_valid: 0 or 1 (0 means the box is invalid, 1 means the box is valid)\n y_rpn_overlap: 0 or 1 (0 means the box is not an object, 1 means the box is an object)\n y_rpn_regr: list(num_bboxes, 4*y_rpn_overlap + y_rpn_regr)\n y_rpn_regr: x1,y1,x2,y2 bunding boxes coordinates\n \"\"\"\n downscale = float(config.rpn_stride)\n anchor_sizes = config.anchor_box_scales # 128, 256, 512\n anchor_ratios = config.anchor_box_ratios # 1:1, 1:2*sqrt(2), 2*sqrt(2):1\n num_anchors = len(anchor_sizes) * len(anchor_ratios) # 3x3=9\n\n # calculate the output map size based on the network architecture\n (output_width, output_height) = resize_func(resized_width, resized_height)\n\n n_anchratios = len(anchor_ratios) # 3\n\n # initialise empty output objectives\n y_rpn_overlap = np.zeros((output_height, output_width, num_anchors)) # box is object?\n y_is_box_valid = np.zeros((output_height, output_width, num_anchors)) # box is valid?\n y_rpn_regr = np.zeros((output_height, output_width, num_anchors * 4)) # bbox coordinates\n\n num_bboxes = len(img_data['bboxes'])\n\n num_anchors_for_bbox = np.zeros(num_bboxes).astype(int) # 각 bbox 마다 anchor 갯수\n best_anchor_for_bbox = -1 * np.ones((num_bboxes, 4)).astype(int) # 각 bbox 마다 best anchor (x, y, w, h)\n best_iou_for_bbox = np.zeros(num_bboxes).astype(np.float32) # 각 bbox 마다 best IOU\n best_x_for_bbox = np.zeros((num_bboxes, 4)).astype(int) # 각 bbox 마다 (x1, x2, y1, y2)\n best_dx_for_bbox = np.zeros((num_bboxes, 4)).astype(np.float32) # 각 bbox 마다 (tx, ty, tw, th)\n\n # get the GT box coordinates, and resize to account for image resizing\n gta = np.zeros((num_bboxes, 4))\n for bbox_num, bbox in enumerate(img_data['bboxes']):\n # get the GT box coordinates, and resize to account for image resizing\n gta[bbox_num, 0] = bbox['x1'] * (resized_width / float(width))\n gta[bbox_num, 1] = bbox['x2'] * (resized_width / float(width))\n gta[bbox_num, 2] = bbox['y1'] * (resized_height / float(height))\n gta[bbox_num, 3] = bbox['y2'] * (resized_height / float(height))\n\n # rpn ground truth\n\n for anchor_size_idx in range(len(anchor_sizes)):\n for anchor_ratio_idx in range(n_anchratios):\n anchor_x = anchor_sizes[anchor_size_idx] * anchor_ratios[anchor_ratio_idx][0]\n anchor_y = anchor_sizes[anchor_size_idx] * anchor_ratios[anchor_ratio_idx][1]\n # anchor_x, anchor_y : anchor size 에 가로 세율 비율 곱한 값\n\n for ix in range(output_width):\n # x-coordinates of the current anchor box\n x1_anc = downscale * (ix + 0.5) - anchor_x / 2\n x2_anc = downscale * (ix + 0.5) + anchor_x / 2\n\n # ignore boxes that go across image boundaries\n if x1_anc < 0 or x2_anc > resized_width:\n continue\n\n for jy in range(output_height):\n # y-coordinates of the current anchor box\n y1_anc = downscale * (jy + 0.5) - anchor_y / 2\n y2_anc = downscale * (jy + 0.5) + anchor_y / 2\n\n # ignore boxes that go across image boundaries\n if y1_anc < 0 or y2_anc > resized_height:\n continue\n\n # bbox_type indicates whether an anchor should be a target\n # Initialize with 'negative'\n bbox_type = 'neg'\n\n # this is the best IOU for the (x,y) coord and the current anchor\n # note that this is different from the best IOU for a GT bbox\n best_iou_for_loc = 0.0\n\n for bbox_num in range(num_bboxes):\n\n # get IOU of the current GT box and the current anchor box\n gt_coord = [\n gta[bbox_num, 0],\n gta[bbox_num, 2],\n gta[bbox_num, 1],\n gta[bbox_num, 3],\n ]\n anc_coord = [x1_anc, y1_anc, x2_anc, y2_anc]\n curr_iou = iou(gt_coord, anc_coord)\n # calculate the regression targets if they will be needed\n if curr_iou > best_iou_for_bbox[bbox_num] or curr_iou > config.rpn_max_overlap:\n # cx, cy : gt 의 중점좌표\n cx = (gta[bbox_num, 0] + gta[bbox_num, 1]) / 2.0\n cy = (gta[bbox_num, 2] + gta[bbox_num, 3]) / 2.0\n # 현재 anchor 의 좌표\n cxa = (x1_anc + x2_anc) / 2.0\n cya = (y1_anc + y2_anc) / 2.0\n\n # x,y are the center point of ground-truth bbox\n # xa,ya are the center point of anchor bbox (xa=downscale * (ix + 0.5); ya=downscale * (iy+0.5))\n # w,h are the width and height of ground-truth bbox\n # wa,ha are the width and height of anchor bboxe\n # tx = (x - xa) / wa\n # ty = (y - ya) / ha\n # tw = log(w / wa)\n # th = log(h / ha)\n wa = x2_anc - x1_anc\n ha = y2_anc - y1_anc\n\n tx = (cx - cxa) / wa\n ty = (cy - cya) / ha\n tw = np.log((gta[bbox_num, 1] - gta[bbox_num, 0]) / wa)\n th = np.log((gta[bbox_num, 3] - gta[bbox_num, 2]) / ha)\n\n if img_data['bboxes'][bbox_num]['class'] != 'bg':\n # all GT boxes should be mapped to an anchor box, so we keep track of which anchor box was best\n if curr_iou > best_iou_for_bbox[bbox_num]:\n best_anchor_for_bbox[bbox_num] = [jy, ix, anchor_ratio_idx, anchor_size_idx]\n best_iou_for_bbox[bbox_num] = curr_iou\n best_x_for_bbox[bbox_num,:] = [x1_anc, x2_anc, y1_anc, y2_anc]\n best_dx_for_bbox[bbox_num,:] = [tx, ty, tw, th]\n\n # we set the anchor to positive if the IOU is >0.7 (it does not matter if there was another better box, it just indicates overlap)\n if curr_iou > config.rpn_max_overlap:\n bbox_type = 'pos'\n num_anchors_for_bbox[bbox_num] += 1\n # we update the regression layer target if this IOU is the best for the current (x,y) and anchor position\n if curr_iou > best_iou_for_loc:\n best_iou_for_loc = curr_iou\n best_regr = (tx, ty, tw, th)\n\n # if the IOU is >0.3 and <0.7, it is ambiguous and no included in the objective\n if config.rpn_min_overlap < curr_iou < config.rpn_max_overlap:\n # gray zone between neg and pos\n if bbox_type != 'pos':\n bbox_type = 'neutral'\n\n # turn on or off outputs depending on IOUs\n if bbox_type == 'neg':\n y_is_box_valid[jy, ix, anchor_ratio_idx + n_anchratios * anchor_size_idx] = 1\n y_rpn_overlap[jy, ix, anchor_ratio_idx + n_anchratios * anchor_size_idx] = 0\n elif bbox_type == 'neutral':\n y_is_box_valid[jy, ix, anchor_ratio_idx + n_anchratios * anchor_size_idx] = 0\n y_rpn_overlap[jy, ix, anchor_ratio_idx + n_anchratios * anchor_size_idx] = 0\n elif bbox_type == 'pos':\n y_is_box_valid[jy, ix, anchor_ratio_idx + n_anchratios * anchor_size_idx] = 1\n y_rpn_overlap[jy, ix, anchor_ratio_idx + n_anchratios * anchor_size_idx] = 1\n start = 4 * (anchor_ratio_idx + n_anchratios * anchor_size_idx)\n y_rpn_regr[jy, ix, start:start+4] = best_regr\n\n # we ensure that every bbox has at least one positive RPN region\n for idx in range(num_anchors_for_bbox.shape[0]):\n if num_anchors_for_bbox[idx] == 0:\n # no box with an IOU greater than zero ...\n if best_anchor_for_bbox[idx, 0] == -1:\n continue\n y_is_box_valid[\n best_anchor_for_bbox[idx, 0], best_anchor_for_bbox[idx, 1], best_anchor_for_bbox[idx, 2] + n_anchratios *\n best_anchor_for_bbox[idx, 3]] = 1\n y_rpn_overlap[\n best_anchor_for_bbox[idx, 0], best_anchor_for_bbox[idx, 1], best_anchor_for_bbox[idx, 2] + n_anchratios *\n best_anchor_for_bbox[idx, 3]] = 1\n start = 4 * (best_anchor_for_bbox[idx,2] + n_anchratios * best_anchor_for_bbox[idx, 3])\n y_rpn_regr[\n best_anchor_for_bbox[idx, 0], best_anchor_for_bbox[idx, 1], start:start+4] = best_dx_for_bbox[idx, :]\n\n y_rpn_overlap = np.transpose(y_rpn_overlap, (2, 0, 1))\n y_rpn_overlap = np.expand_dims(y_rpn_overlap, axis=0)\n # y_rpn_overlap: (1, num_anchors, output_height, output_width)\n\n y_is_box_valid = np.transpose(y_is_box_valid, (2, 0, 1))\n y_is_box_valid = np.expand_dims(y_is_box_valid, axis=0)\n # y_is_box_valid: (1, num_anchors, output_height, output_width)\n\n y_rpn_regr = np.transpose(y_rpn_regr, (2, 0, 1))\n y_rpn_regr = np.expand_dims(y_rpn_regr, axis=0)\n # y_rpn_regr: (1, num_anchros * 4, output_height, output_width)\n\n pos_locs = np.where(np.logical_and(y_rpn_overlap[0, :, :, :] == 1, y_is_box_valid[0, :, :, :] == 1))\n neg_locs = np.where(np.logical_and(y_rpn_overlap[0, :, :, :] == 0, y_is_box_valid[0, :, :, :] == 1))\n\n num_pos = len(pos_locs[0])\n\n # one issue is that the RPN has many more negative than positive regions,\n # so we turn off some of the negative regions.\n # We also limit it to 256 regions.\n num_regions = 256\n\n if len(pos_locs[0]) > num_regions / 2:\n val_locs = random.sample(\n range(len(pos_locs[0])),\n len(pos_locs[0])-num_regions/2,\n )\n y_is_box_valid[0, pos_locs[0][val_locs], pos_locs[1][val_locs], pos_locs[2][val_locs]] = 0\n num_pos = num_regions / 2\n\n if len(neg_locs[0]) + num_pos > num_regions:\n val_locs = random.sample(\n range(len(neg_locs[0])),\n len(neg_locs[0])-num_pos,\n )\n y_is_box_valid[0, neg_locs[0][val_locs], neg_locs[1][val_locs], neg_locs[2][val_locs]] = 0\n\n y_rpn_cls = np.concatenate([y_is_box_valid, y_rpn_overlap], axis=1)\n y_rpn_regr = np.concatenate([np.repeat(y_rpn_overlap, 4, axis=1), y_rpn_regr], axis=1)\n return np.copy(y_rpn_cls), np.copy(y_rpn_regr), num_pos\n", "meta": {"hexsha": "7774193797f729dc25377cbd2486b99763ab075a", "size": 11889, "ext": "py", "lang": "Python", "max_stars_repo_path": "train/sub_func/calc_rpn.py", "max_stars_repo_name": "DevBruce/Mask_R-CNN_For_Open_Images_2019", "max_stars_repo_head_hexsha": "00574b20eaf6d228d79fba1575c74f080a4cbf44", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "train/sub_func/calc_rpn.py", "max_issues_repo_name": "DevBruce/Mask_R-CNN_For_Open_Images_2019", "max_issues_repo_head_hexsha": "00574b20eaf6d228d79fba1575c74f080a4cbf44", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-01-28T22:16:56.000Z", "max_issues_repo_issues_event_max_datetime": "2020-01-28T22:16:56.000Z", "max_forks_repo_path": "train/sub_func/calc_rpn.py", "max_forks_repo_name": "DevBruce/Mask_R-CNN_For_Open_Images_2019", "max_forks_repo_head_hexsha": "00574b20eaf6d228d79fba1575c74f080a4cbf44", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 53.3139013453, "max_line_length": 158, "alphanum_fraction": 0.5635461351, "include": true, "reason": "import numpy", "num_tokens": 3190, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6297745935070806, "lm_q2_score": 0.3073580295544412, "lm_q1q2_score": 0.1935662781237855}} {"text": "\"\"\"\n15N–1HN DQ/ZQ CPMG\n==================\n\nAnalyzes 15N and 1H chemical exchange by applying CPMG pulses on 15N and 1H\nsimultaneously. The spin system is maintained as DQ or ZQ during Trelax, and\nis calculated using the (15n)×(15n), two-spin matrix, where n is the number\nof states::\n\n { Ix(a), Iy(a), Iz(a), Sx(a), IxSx(a), IySx(a), IzSx(a),\n Sy(a), IxSy(a), IySy(a), IzSy(a), Sz(a), IxSz(a), IySz(a), IzSz(a),\n Ix(b), Iy(b), Iz(b), Sx(b), IxSx(b), IySx(b), IzSx(b),\n Sy(b), IxSy(b), IySy(b), IzSy(b), Sz(b), IxSz(b), IySz(b), IzSz(b), ... }\n\nThe phase cycle of CPMG pulses is chosen based on νCPMG as described in the\nreference, which is a mixture of constant-phase and XY-family phase cycles.\n\nReferences\n----------\n\nOrekhov, Korzhnev and Kay. J Am Chem Soc (2004) 126:1886-1891\n\n\nNote\n----\n\nA sample configuration file for this module is available using the command::\n\n $ chemex config cpmg_hn_dq_zq\n\n\"\"\"\nimport functools as ft\n\nimport numpy as np\n\nimport chemex.experiments.helper as ceh\nimport chemex.helper as ch\nimport chemex.nmr.liouvillian as cnl\n\n\n_SCHEMA = {\n \"type\": \"object\",\n \"properties\": {\n \"experiment\": {\n \"type\": \"object\",\n \"properties\": {\n \"time_t2\": {\"type\": \"number\"},\n \"carrier_h\": {\"type\": \"number\"},\n \"carrier_n\": {\"type\": \"number\"},\n \"pw90_h\": {\"type\": \"number\"},\n \"pw90_n\": {\"type\": \"number\"},\n \"dq_flg\": {\"type\": \"boolean\"},\n \"observed_state\": {\n \"type\": \"string\",\n \"pattern\": \"[a-z]\",\n \"default\": \"a\",\n },\n },\n \"required\": [\n \"time_t2\",\n \"carrier_h\",\n \"carrier_n\",\n \"pw90_h\",\n \"pw90_n\",\n \"dq_flg\",\n ],\n }\n },\n}\n\n\ndef read(config):\n ch.validate(config, _SCHEMA)\n config[\"basis\"] = cnl.Basis(type=\"ixyzsxyz\", spin_system=\"nh\")\n config[\"fit\"] = _fit_this()\n return ceh.load_experiment(config=config, pulse_seq_cls=PulseSeq)\n\n\ndef _fit_this():\n return {\n \"rates\": [\"r2mq_is_{observed_state}\", \"mu_is_{observed_state}\"],\n \"model_free\": [\"tauc_{observed_state}\", \"s2_{observed_state}\"],\n }\n\n\nclass PulseSeq:\n def __init__(self, config, propagator):\n self.prop = propagator\n settings = config[\"experiment\"]\n self.time_t2 = settings[\"time_t2\"]\n self.prop.carrier_i = settings[\"carrier_n\"]\n self.prop.carrier_s = settings[\"carrier_h\"]\n self.pw90_i = settings[\"pw90_n\"]\n self.pw90_s = settings[\"pw90_h\"]\n self.prop.b1_i = 1 / (4.0 * self.pw90_i)\n self.prop.b1_s = 1 / (4.0 * self.pw90_s)\n self.dq_flg = settings[\"dq_flg\"]\n self.prop.detection = self._get_detection(settings[\"observed_state\"])\n\n @ft.lru_cache(maxsize=10000)\n def calculate(self, ncycs, params_local):\n self.prop.update(params_local)\n\n # Calculation of the propagators corresponding to all the delays\n tau_cps = self._get_tau_cps(ncycs)\n tau_cp_list = list(tau_cps.values())\n delays = dict(zip(tau_cp_list, self.prop.delays(tau_cp_list)))\n d_cp = {ncyc: delays[delay] for ncyc, delay in tau_cps.items()}\n\n # Calculation of the propagators corresponding to all the pulses\n p9024090_1 = self.prop.p9024090_is_1[[0, 1], [0, 1]]\n p9024090_2 = self.prop.p9024090_is_2[[0, 1], [0, 1]]\n\n # Getting the starting magnetization\n start = self.prop.get_start_magnetization([\"2ixsx\"])\n\n # Calculating the cpmg trains\n intst = {0: self.prop.detect(start)}\n for ncyc in set(ncycs) - {0}:\n phases1, phases2 = self._get_phases(ncyc)\n echo1 = d_cp[ncyc] @ p9024090_1 @ d_cp[ncyc]\n echo2 = d_cp[ncyc] @ p9024090_2 @ d_cp[ncyc]\n cpmg1 = ft.reduce(np.matmul, echo1[phases1])\n cpmg2 = ft.reduce(np.matmul, echo2[phases2])\n intst[ncyc] = self.prop.detect(0.5 * (cpmg1 + cpmg2) @ start)\n return np.array([intst[ncyc] for ncyc in ncycs])\n\n @ft.lru_cache()\n def _get_tau_cps(self, ncycs):\n ncycs_ = np.asarray(ncycs)\n ncycs_ = ncycs_[ncycs_ > 0]\n return dict(\n zip(ncycs_, self.time_t2 / (4.0 * ncycs_) - 7.0 / 3.0 * self.pw90_i)\n )\n\n @ft.lru_cache()\n def _get_phases(self, ncyc):\n nu_cpmg = self.ncycs_to_nu_cpmgs(ncyc)\n if nu_cpmg < 51.0:\n cp_phases1 = [0, 1, 0, 1]\n cp_phases2 = [1, 0, 1, 0]\n elif nu_cpmg < 255.0:\n cp_phases1 = [0]\n cp_phases2 = [1]\n else:\n cp_phases1 = [0, 1, 0, 1, 1, 0, 1, 0]\n cp_phases2 = [1, 0, 1, 0, 0, 1, 0, 1]\n phases1 = np.take(cp_phases1, np.flip(np.arange(2 * ncyc)), mode=\"wrap\")\n phases2 = np.take(cp_phases2, np.flip(np.arange(2 * ncyc)), mode=\"wrap\")\n return phases1, phases2\n\n def _get_detection(self, state):\n if self.dq_flg:\n return f\"[2ixsx_{state}] - [2iysy_{state}]\"\n return f\"[2ixsx_{state}] + [2iysy_{state}]\"\n\n def ncycs_to_nu_cpmgs(self, ncycs):\n ncycs_ = np.asarray(ncycs)\n ncycs_ = ncycs_[ncycs_ > 0]\n return ncycs_ / self.time_t2\n", "meta": {"hexsha": "b2f92b5d97ffe2c3cc452ac45e2b80acf08a9e82", "size": 5337, "ext": "py", "lang": "Python", "max_stars_repo_path": "chemex/experiments/cpmg_hn_dq_zq.py", "max_stars_repo_name": "gbouvignies/ChemEx", "max_stars_repo_head_hexsha": "b1748f1bdc623a1d078de47dffe8cae2515d3411", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 10, "max_stars_repo_stars_event_min_datetime": "2018-09-20T00:33:59.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-08T10:21:27.000Z", "max_issues_repo_path": "chemex/experiments/cpmg_hn_dq_zq.py", "max_issues_repo_name": "gbouvignies/ChemEx", "max_issues_repo_head_hexsha": "b1748f1bdc623a1d078de47dffe8cae2515d3411", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 28, "max_issues_repo_issues_event_min_datetime": "2018-09-17T12:01:58.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-23T13:40:48.000Z", "max_forks_repo_path": "chemex/experiments/cpmg_hn_dq_zq.py", "max_forks_repo_name": "gbouvignies/ChemEx", "max_forks_repo_head_hexsha": "b1748f1bdc623a1d078de47dffe8cae2515d3411", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2018-09-17T13:50:13.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-23T07:39:10.000Z", "avg_line_length": 33.149068323, "max_line_length": 80, "alphanum_fraction": 0.5617388046, "include": true, "reason": "import numpy", "num_tokens": 1666, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5964331462646254, "lm_q2_score": 0.32423539898095244, "lm_q1q2_score": 0.19338473914457557}} {"text": "# -*- coding: utf-8 -*-\n'''This module provides a user-friendly pythonic wrapper for the low-level C interface functions.'''\n\nfrom __future__ import division, print_function, absolute_import, unicode_literals\n\nimport datetime as dt\nimport calendar\nimport warnings\n\nimport numpy as np\n\nfrom aacgm2._aacgmv2 import A2G, TRACE, BADIDEA, ALLOWTRACE, GEOCENTRIC, setDateTime, aacgmConvert\nfrom aacgm2 import IGRF_12_COEFFS\n\naacgmConvert_vectorized = np.vectorize(aacgmConvert)\n\n\ndef convert(lat, lon, alt, date=None, a2g=False, trace=False, allowtrace=False, badidea=False, geocentric=False):\n '''Converts to/from geomagnetic coordinates.\n\n This is a user-friendly pythonic wrapper for the low-level C interface\n functions available in :mod:`aacgm2._aacgmv2`.\n\n Parameters\n ==========\n lat,lon,alt : array_like\n Input latitude(s), longitude(s) and altitude(s). They must be\n `broadcastable to the same shape `_.\n date : :class:`datetime.date`/:class:`datetime.datetime`, optional\n The date/time to use for the magnetic field model, default ``None`` (uses\n current time). Must be between 1900 and 2020.\n a2g : bool, optional\n Convert from AACGM-v2 to geographic coordinates, default ``False``\n (converts geographic to AACGM-v2).\n trace : bool, optional\n Use field-line tracing, default ``False`` (uses coefficients). Tracing\n is more precise and needed at altitudes > 2000 km, but significantly\n slower.\n allowtrace : bool, optional\n Automatically use field-line tracing above 2000 km, default ``False``\n (raises an exception for these altitudes unless ``trace=True`` or\n ``badidea=True``).\n badidea : bool, optional\n Allow use of coefficients above 2000 km (bad idea!)\n geocentric : bool, optional\n Assume inputs are geocentric with Earth radius 6371.2 km.\n\n Returns\n =======\n\n lat_out : ``numpy.ndarray``\n Converted latitude\n lon_out : ``numpy.ndarray``\n Converted longitude\n alt_out : ``numpy.ndarray``\n Converted altitude\n\n Raises\n ======\n\n ValueError\n if max(alt) > 2000 and neither of `trace`, `allowtrace`, or `badidea` is ``True``\n ValueError\n if latitude is outside the range -90 to +90 degrees\n RuntimeError\n if there was a problem in the C extension\n\n Notes\n =====\n\n This function exclusively relies on the `AACGM-v2 C library\n `_. Specifically,\n it calls the functions :func:`_aacgmv2.setDateTime` and\n :func:`_aacgmv2.aacgmConvert`, which are simple interfaces to the\n C library functions :func:`AACGM_v2_SetDateTime` and\n :func:`AACGM_v2_Convert`. Details of the techniques used to derive the\n AACGM-v2 coefficients are described by Shepherd, 2014 [1]_.\n\n .. [1] Shepherd, S. G. (2014), Altitude-adjusted corrected geomagnetic\n coordinates: Definition and functional approximations,\n J. Geophys. Res. Space Physics, 119, 7501--7521,\n doi:`10.1002/2014JA020264 `_.\n\n '''\n\n # check values\n if np.min(alt) < 0:\n warnings.warn('Coordinate transformations are not intended for altitudes < 0 km', UserWarning)\n\n if np.max(alt) > 2000 and not (trace or allowtrace or badidea):\n raise ValueError('Coefficients are not valid for altitudes above 2000 km. You must either use field-line '\n 'tracing (trace=True or allowtrace=True) or indicate you know this is a bad idea '\n '(badidea=True)')\n\n # check if latitudes are > 90.1 (to allow some room for rounding errors, which will be clipped)\n if np.max(np.abs(lat)) > 90.1:\n raise ValueError('Latitude must be in the range -90 to +90 degrees')\n np.clip(lat, -90, 90)\n\n # constrain longitudes between -180 and 180\n lon = ((np.asarray(lon) + 180) % 360) - 180\n\n # set to current date if none is given\n if date is None:\n date = dt.datetime.now()\n\n # add time info if only date is given\n if isinstance(date, dt.date):\n date = dt.datetime.combine(date, dt.time(0))\n\n # set current date and time\n setDateTime(date.year, date.month, date.day, date.hour, date.minute, date.second)\n\n # make flag\n flag = A2G*a2g + TRACE*trace + ALLOWTRACE*allowtrace + BADIDEA*badidea + GEOCENTRIC*geocentric\n\n # convert\n lat_out, lon_out, alt_out = aacgmConvert_vectorized(lat, lon, alt, flag)\n\n return lat_out, lon_out, alt_out\n\n\ndef convert_mlt(arr, datetime, m2a=False):\n '''Converts between magnetic local time (MLT) and AACGM-v2 longitude.\n\n .. note:: This function is not related to the AACGM-v2 C library, but is provided as\n a convenience in the hopes that it might be useful for some purposes.\n\n Parameters\n ==========\n arr : array_like or float\n Magnetic longitudes or MLTs to convert.\n datetime : :class:`datetime.datetime`\n Date and time for MLT conversion in Universal Time (UT).\n m2a : bool\n Convert MLT to AACGM-v2 longitude (default is ``False``, which implies\n conversion from AACGM-v2 longitude to MLT).\n\n Returns\n =======\n out : numpy.ndarray\n Converted coordinates/MLT\n\n Notes\n =====\n\n The MLT conversion is not part of the AACGM-v2 C library and is instead based\n on Laundal et al., 2016 [1]_. A brief summary of the method is provided below.\n\n MLT is defined as\n\n MLT = (magnetic longitude - magnetic noon meridian longitude) / 15 + 12\n\n where the magnetic noon meridian longitude is the centered dipole longitude\n of the subsolar point.\n\n There are two important reasons for using centered dipole instead of AACGM for\n this calculation. One reason is that the AACGM longitude of the subsolar point\n is often undefined (being at low latitudes). More importantly, if the subsolar\n point close to ground was used, the MLT at polar latitudes would be affected\n by non-dipole features at low latitudes, such as the South Atlantic Anomaly.\n This is not desirable; since the Sun-Earth interaction takes place at polar\n field lines, it is these field lines the MLT should describe.\n\n In calculating the centered dipole longitude of the subsolar point, we use\n the first three IGRF Gauss coefficients, using linear interpolation between\n the model updates every five years.\n\n Both input and output MLON are taken modulo 360 to ensure they are between\n 0 and 360 degrees. Similarly, input/output MLT are taken modulo 24.\n For implementation of the subsolar point calculation, see :func:`subsol`.\n\n .. [1] Laundal, K. M. and A. D. Richmond (2016), Magnetic Coordinate Systems,\n Space Sci. Rev., doi:`10.1007/s11214-016-0275-y `_.\n\n '''\n d2r = np.pi/180\n\n # find subsolar point\n yr = datetime.year\n doy = datetime.timetuple().tm_yday\n ssm = datetime.hour*3600 + datetime.minute*60 + datetime.second\n subsol_lon, subsol_lat = subsol(yr, doy, ssm)\n\n # unit vector pointing at subsolar point:\n s = np.array([np.cos(subsol_lat * d2r) * np.cos(subsol_lon * d2r),\n np.cos(subsol_lat * d2r) * np.sin(subsol_lon * d2r),\n np.sin(subsol_lat * d2r)])\n\n # convert subsolar coordinates to centered dipole coordinates\n z = igrf_dipole_axis(datetime) # Cartesian axis pointing at Northern dipole pole\n y = np.cross(np.array([0, 0, 1]), z)\n y = y/np.linalg.norm(y)\n x = np.cross(y, z)\n R = np.vstack((x, y, z))\n s_cd = R.dot(s)\n\n # centered dipole longitude of subsolar point:\n mlon_subsol = np.arctan2(s_cd[1], s_cd[0])/d2r\n\n # convert the input array\n if m2a: # MLT to AACGM\n mlt = np.asarray(arr) % 24\n mlon = (15*(mlt - 12) + mlon_subsol) % 360\n return mlon\n else: # AACGM to MLT\n mlon = np.asarray(arr) % 360\n mlt = ((mlon - mlon_subsol)/15 + 12) % 24\n return mlt\n\n\ndef subsol(year, doy, ut):\n '''Finds subsolar geocentric longitude and latitude.\n\n Helper function for :func:`convert_mlt`.\n\n Parameters\n ==========\n year : int [1601, 2100]\n Calendar year\n doy : int [1, 365/366]\n Day of year\n ut : float\n Seconds since midnight on the specified day\n\n Returns\n =======\n sbsllon : float\n Subsolar longitude for the given date/time\n sbsllat : float\n Subsolar latitude for the given date/time\n\n Notes\n =====\n\n Based on formulas in Astronomical Almanac for the year 1996, p. C24.\n (U.S. Government Printing Office, 1994). Usable for years 1601-2100,\n inclusive. According to the Almanac, results are good to at least 0.01\n degree latitude and 0.025 degrees longitude between years 1950 and 2050.\n Accuracy for other years has not been tested. Every day is assumed to have\n exactly 86400 seconds; thus leap seconds that sometimes occur on December\n 31 are ignored (their effect is below the accuracy threshold of the\n algorithm).\n\n After Fortran code by A. D. Richmond, NCAR. Translated from IDL\n by K. Laundal.\n\n '''\n\n from numpy import sin, cos, pi, arctan2, arcsin\n\n yr = year - 2000\n\n if year >= 2101:\n print('subsol.py: subsol invalid after 2100. Input year is:', year)\n\n nleap = np.floor((year-1601)/4)\n nleap = nleap - 99\n if year <= 1900:\n if year <= 1600:\n print('subsol.py: subsol invalid before 1601. Input year is:', year)\n ncent = np.floor((year-1601)/100)\n ncent = 3 - ncent\n nleap = nleap + ncent\n\n l0 = -79.549 + (-0.238699*(yr-4*nleap) + 3.08514e-2*nleap)\n\n g0 = -2.472 + (-0.2558905*(yr-4*nleap) - 3.79617e-2*nleap)\n\n # Days (including fraction) since 12 UT on January 1 of IYR:\n df = (ut/86400 - 1.5) + doy\n\n # Addition to Mean longitude of Sun since January 1 of IYR:\n lf = 0.9856474*df\n\n # Addition to Mean anomaly since January 1 of IYR:\n gf = 0.9856003*df\n\n # Mean longitude of Sun:\n l = l0 + lf\n\n # Mean anomaly:\n g = g0 + gf\n grad = g*pi/180\n\n # Ecliptic longitude:\n lmbda = l + 1.915*sin(grad) + 0.020*sin(2*grad)\n lmrad = lmbda*pi/180\n sinlm = sin(lmrad)\n\n # Days (including fraction) since 12 UT on January 1 of 2000:\n n = df + 365*yr + nleap\n\n # Obliquity of ecliptic:\n epsilon = 23.439 - 4e-7*n\n epsrad = epsilon*pi/180\n\n # Right ascension:\n alpha = arctan2(cos(epsrad)*sinlm, cos(lmrad)) * 180/pi\n\n # Declination:\n delta = arcsin(sin(epsrad)*sinlm) * 180/pi\n\n # Subsolar latitude:\n sbsllat = delta\n\n # Equation of time (degrees):\n etdeg = l - alpha\n nrot = round(etdeg/360)\n etdeg = etdeg - 360*nrot\n\n # Apparent time (degrees):\n aptime = ut/240 + etdeg # Earth rotates one degree every 240 s.\n\n # Subsolar longitude:\n sbsllon = 180 - aptime\n nrot = round(sbsllon/360)\n sbsllon = sbsllon - 360*nrot\n\n return sbsllon, sbsllat\n\n\ndef gc2gd_lat(gc_lat):\n '''Convert geocentric latitude to geodetic latitude using WGS84.\n\n Parameters\n ==========\n gc_lat : array_like or float\n Geocentric latitude\n\n Returns\n =======\n gd_lat : same as input\n Geodetic latitude\n\n '''\n WGS84_e2 = 0.006694379990141317\n return np.rad2deg(-np.arctan(np.tan(np.deg2rad(gc_lat))/(WGS84_e2 - 1)))\n\n\ndef igrf_dipole_axis(date):\n '''Get Cartesian unit vector pointing at dipole pole in the north, according to IGRF\n\n Parameters\n ==========\n date : :class:`datetime.datetime`\n Date and time\n\n Returns\n =======\n m: numpy.ndarray\n Cartesian 3 element vector pointing at dipole pole in the north (geocentric coords)\n\n Notes\n =====\n IGRF coefficients are read from the igrf12coeffs.txt file. It should also work after IGRF updates.\n The dipole coefficients are interpolated to the date, or extrapolated if date > latest IGRF model\n '''\n\n # get time in years, as float:\n year = date.year\n doy = date.timetuple().tm_yday\n year = year + doy/(365 + calendar.isleap(year))\n\n # read the IGRF coefficients\n with open(IGRF_12_COEFFS, 'r') as f:\n lines = f.readlines()\n\n years = lines[3].split()[3:][:-1]\n years = np.array(years, dtype=float) # time array\n\n g10 = lines[4].split()[3:]\n g11 = lines[5].split()[3:]\n h11 = lines[6].split()[3:]\n\n # secular variation coefficients (for extrapolation)\n g10sv = np.float32(g10[-1])\n g11sv = np.float32(g11[-1])\n h11sv = np.float32(h11[-1])\n\n # model coefficients:\n g10 = np.array(g10[:-1], dtype=float)\n g11 = np.array(g11[:-1], dtype=float)\n h11 = np.array(h11[:-1], dtype=float)\n\n # get the gauss coefficient at given time:\n if year <= years[-1]: # regular interpolation\n g10 = np.interp(year, years, g10)\n g11 = np.interp(year, years, g11)\n h11 = np.interp(year, years, h11)\n else: # extrapolation\n dt = year - years[-1]\n g10 = g10[-1] + g10sv * dt\n g11 = g11[-1] + g11sv * dt\n h11 = h11[-1] + h11sv * dt\n\n # calculate pole position\n B0 = np.sqrt(g10**2 + g11**2 + h11**2)\n\n return -np.array([g11, h11, g10])/B0\n", "meta": {"hexsha": "b48e4131babf756886763f066ea677048e7ccb3d", "size": 13272, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/aacgm2/wrapper.py", "max_stars_repo_name": "st-bender/aacgmv2", "max_stars_repo_head_hexsha": "edbdb362be04443e0faff083e8bf5bd63a044b65", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/aacgm2/wrapper.py", "max_issues_repo_name": "st-bender/aacgmv2", "max_issues_repo_head_hexsha": "edbdb362be04443e0faff083e8bf5bd63a044b65", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2018-05-26T17:42:27.000Z", "max_issues_repo_issues_event_max_datetime": "2018-05-26T17:42:27.000Z", "max_forks_repo_path": "src/aacgm2/wrapper.py", "max_forks_repo_name": "st-bender/aacgmv2", "max_forks_repo_head_hexsha": "edbdb362be04443e0faff083e8bf5bd63a044b65", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2018-05-26T17:34:42.000Z", "max_forks_repo_forks_event_max_datetime": "2018-05-26T17:34:42.000Z", "avg_line_length": 33.0972568579, "max_line_length": 114, "alphanum_fraction": 0.650994575, "include": true, "reason": "import numpy,from numpy", "num_tokens": 3803, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5660185498374789, "lm_q2_score": 0.34158250614097546, "lm_q1q2_score": 0.19334203477576667}} {"text": "\"\"\"\n Copyright (c) 2019 Intel Corporation\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\"\"\"\n\nimport numpy as np\nfrom scipy.optimize import linear_sum_assignment\n\n\nclass Detection:\n \"\"\"Class that stores detected object\"\"\"\n\n def __init__(self, obj_id, roi, conf, waiting=0, duration=1):\n \"\"\"Constructor\"\"\"\n\n self.id = obj_id\n self.roi = roi\n self.conf = conf\n self.waiting = waiting\n self.duration = duration\n\n @property\n def roi(self):\n \"\"\"Returns ROI of detected object\"\"\"\n\n return self._roi\n\n @roi.setter\n def roi(self, roi):\n \"\"\"Sets ROI of detected object\"\"\"\n\n self._roi = np.copy(roi.reshape(1, -1))\n\n\nclass Tracker: # pylint: disable=too-few-public-methods\n \"\"\"Class that carries out tracking of persons using Hungarian algorithm\"\"\"\n\n def __init__(self, detector, score_threshold, iou_threshold, smooth_weight=0.5, max_waiting=5):\n \"\"\"Constructor\"\"\"\n\n self._detector = detector\n self._score_threshold = score_threshold\n self._iou_threshold = iou_threshold\n self._smooth_weight = smooth_weight\n self._max_waiting = max_waiting\n\n self._last_detections = []\n self._cur_req_id, self._next_req_id = 0, 1\n self._last_id = 0\n\n @staticmethod\n def _matrix_iou(set_a, set_b):\n \"\"\"Computes IoU metric for the two sets of vectors\"\"\"\n\n intersect_ymin = np.maximum(set_a[:, 0].reshape([-1, 1]), set_b[:, 0].reshape([1, -1]))\n intersect_xmin = np.maximum(set_a[:, 1].reshape([-1, 1]), set_b[:, 1].reshape([1, -1]))\n intersect_ymax = np.minimum(set_a[:, 2].reshape([-1, 1]), set_b[:, 2].reshape([1, -1]))\n intersect_xmax = np.minimum(set_a[:, 3].reshape([-1, 1]), set_b[:, 3].reshape([1, -1]))\n\n intersect_heights = np.maximum(0.0, intersect_ymax - intersect_ymin)\n intersect_widths = np.maximum(0.0, intersect_xmax - intersect_xmin)\n intersect_areas = intersect_heights * intersect_widths\n\n areas_set_a = ((set_a[:, 2] - set_a[:, 0]) * (set_a[:, 3] - set_a[:, 1])).reshape([-1, 1])\n areas_set_b = ((set_b[:, 2] - set_b[:, 0]) * (set_b[:, 3] - set_b[:, 1])).reshape([1, -1])\n\n union_areas = areas_set_a + areas_set_b - intersect_areas\n\n return intersect_areas / union_areas\n\n @staticmethod\n def filter_rois(new_rois, score_threshold):\n \"\"\"Filters input ROIs by valid height/width and score threshold values\"\"\"\n\n heights = new_rois[:, 2] - new_rois[:, 0]\n widths = new_rois[:, 3] - new_rois[:, 1]\n valid_sizes_mask = np.logical_and(heights > 0.0, widths > 0.0)\n valid_conf_mask = new_rois[:, 4] > score_threshold\n\n valid_roi_ids = np.where(np.logical_and(valid_sizes_mask, valid_conf_mask))[0]\n filtered_rois = new_rois[valid_roi_ids, :4]\n filtered_conf = new_rois[valid_roi_ids, 4]\n\n return filtered_rois, filtered_conf\n\n def _track(self, last_detections, new_rois):\n \"\"\"Updates current tracks according new observations\"\"\"\n\n filtered_rois, filtered_conf = self.filter_rois(new_rois, self._score_threshold)\n\n if filtered_rois.shape[0] == 0:\n out_detections = []\n for det in last_detections:\n det.waiting = 1\n det.duration = 0\n out_detections.append(det)\n\n return out_detections\n\n if last_detections is None or len(last_detections) == 0:\n out_detections = []\n for roi, conf in zip(filtered_rois, filtered_conf):\n out_detections.append(Detection(self._last_id, roi.reshape(1, -1), conf))\n self._last_id += 1\n\n return out_detections\n\n last_rois = np.concatenate([det.roi for det in last_detections], axis=0)\n affinity_matrix = self._matrix_iou(last_rois, filtered_rois)\n cost_matrix = 1.0 - affinity_matrix\n\n row_ind, col_ind = linear_sum_assignment(cost_matrix)\n affinity_values = 1.0 - cost_matrix[row_ind, col_ind]\n\n valid_matches = affinity_values > self._iou_threshold\n row_ind = row_ind[valid_matches]\n col_ind = col_ind[valid_matches]\n\n out_detections = []\n for src_id, trg_id in zip(row_ind, col_ind):\n det = last_detections[src_id]\n det.waiting = 0\n det.duration += 1\n new_roi = filtered_rois[trg_id]\n det.roi = self._smooth_roi(det.roi, new_roi.reshape(1, -1), self._smooth_weight)\n det.conf = filtered_conf[trg_id]\n out_detections.append(det)\n\n unmatched_src_ind = set(range(len(last_detections))) - set(row_ind.tolist())\n for src_id in unmatched_src_ind:\n det = last_detections[src_id]\n det.waiting += 1\n det.duration = 0\n if det.waiting < self._max_waiting:\n out_detections.append(det)\n\n unmatched_trg_ind = set(range(len(filtered_rois))) - set(col_ind.tolist())\n for trg_id in unmatched_trg_ind:\n new_roi = filtered_rois[trg_id]\n new_roi_conf = filtered_conf[trg_id]\n out_detections.append(Detection(self._last_id, new_roi.reshape(1, -1), new_roi_conf))\n self._last_id += 1\n\n return out_detections\n\n @staticmethod\n def _smooth_roi(prev_roi, new_roi, weight):\n \"\"\"Smooths tracking ROI\"\"\"\n\n if prev_roi is None:\n return new_roi\n\n return weight * prev_roi + (1.0 - weight) * new_roi\n\n @staticmethod\n def _clip_roi(roi, frame_size):\n \"\"\"Clips ROI limits according frame sizes\"\"\"\n\n frame_height, frame_width = frame_size\n\n old_roi = roi.reshape(-1)\n new_roi = [np.maximum(0, int(old_roi[0])),\n np.maximum(0, int(old_roi[1])),\n np.minimum(frame_width, int(old_roi[2])),\n np.minimum(frame_height, int(old_roi[3]))]\n\n return np.array(new_roi)\n\n def _get_last_detections(self, frame_size, max_num_detections, labels_map):\n \"\"\"Returns active detections\"\"\"\n\n if self._last_detections is None or len(self._last_detections) == 0:\n return [], {}\n\n out_detections = []\n for det in self._last_detections:\n if det.waiting > 0 or det.duration <= 1:\n continue\n\n clipped_roi = self._clip_roi(det.roi, frame_size)\n out_det = Detection(det.id, clipped_roi, det.conf, det.waiting, det.duration)\n out_detections.append(out_det)\n\n if len(out_detections) > max_num_detections:\n out_detections.sort(key=lambda x: x.conf, reverse=True)\n out_detections = out_detections[:max_num_detections]\n\n matched_det_ids = {det.id for det in out_detections} & labels_map.keys()\n unused_det_ids = sorted(set(range(max_num_detections)) - matched_det_ids)\n\n out_labels_map = {}\n for det in out_detections:\n if det.id in matched_det_ids:\n out_labels_map[det.id] = labels_map[det.id]\n else:\n new_local_det_id = unused_det_ids[0]\n unused_det_ids = unused_det_ids[1:]\n\n out_labels_map[det.id] = new_local_det_id\n det.id = new_local_det_id\n\n return out_detections, labels_map\n\n def add_frame(self, frame, max_num_detections, labels_map):\n \"\"\"Adds new detections and returns active tracks\"\"\"\n\n self._detector.async_infer(frame, self._next_req_id)\n new_rois = self._detector.wait_request(self._cur_req_id)\n self._cur_req_id, self._next_req_id = self._next_req_id, self._cur_req_id\n\n if new_rois is not None:\n self._last_detections = self._track(self._last_detections, new_rois)\n\n frame_size = frame.shape[:2]\n out_detections, out_labels_map = self._get_last_detections(\n frame_size, max_num_detections, labels_map)\n\n return out_detections, out_labels_map\n", "meta": {"hexsha": "4893e9e2c0fab212d1cff20d292cecc14ada716b", "size": 8443, "ext": "py", "lang": "Python", "max_stars_repo_path": "gesture_recognition_demo/tracker.py", "max_stars_repo_name": "JHP4911/Gesture-Triggered-Alarm-on-Pi-or-Jetson-Nano", "max_stars_repo_head_hexsha": "1e9416c2baeaf40dfc87b2f0263076f7ca79183d", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 2201, "max_stars_repo_stars_event_min_datetime": "2018-10-15T14:37:19.000Z", "max_stars_repo_stars_event_max_datetime": "2020-07-16T02:05:51.000Z", "max_issues_repo_path": "gesture_recognition_demo/tracker.py", "max_issues_repo_name": "JHP4911/Gesture-Triggered-Alarm-on-Pi-or-Jetson-Nano", "max_issues_repo_head_hexsha": "1e9416c2baeaf40dfc87b2f0263076f7ca79183d", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": 966, "max_issues_repo_issues_event_min_datetime": "2020-07-16T08:13:00.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T18:09:18.000Z", "max_forks_repo_path": "gesture_recognition_demo/tracker.py", "max_forks_repo_name": "JHP4911/Gesture-Triggered-Alarm-on-Pi-or-Jetson-Nano", "max_forks_repo_head_hexsha": "1e9416c2baeaf40dfc87b2f0263076f7ca79183d", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 808, "max_forks_repo_forks_event_min_datetime": "2018-10-16T14:03:49.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-15T11:41:45.000Z", "avg_line_length": 36.7086956522, "max_line_length": 99, "alphanum_fraction": 0.635200758, "include": true, "reason": "import numpy,from scipy", "num_tokens": 2060, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5660185351961015, "lm_q2_score": 0.34158251284363395, "lm_q1q2_score": 0.1933420335683572}} {"text": "import numpy as np\nimport numpy.linalg as la\nimport scipy.sparse as SP\nimport scipy\nfrom scipy.sparse import linalg as SPla\n\ndef spdot(a, b, array_out=True):\n \"\"\"\n Matrix multiplication function to deal with sparse and dense objects\n\n Parameters\n ----------\n\n a : array\n first multiplication factor. Can either be sparse or dense.\n b : array\n second multiplication factor. Can either be sparse or dense.\n array_out : boolean\n If True (default) the output object is always a np.array\n\n Returns\n -------\n\n ab : array\n product of a times b. Sparse if a and b are sparse. Dense otherwise.\n \"\"\"\n if type(a).__name__ == 'ndarray' and type(b).__name__ == 'ndarray':\n ab = np.dot(a, b)\n elif type(a).__name__ == 'csr_matrix' or type(b).__name__ == 'csr_matrix' \\\n or type(a).__name__ == 'csc_matrix' or type(b).__name__ == 'csc_matrix':\n ab = a * b\n if array_out:\n if type(ab).__name__ == 'csc_matrix' or type(ab).__name__ == 'csr_matrix':\n ab = ab.toarray()\n else:\n raise Exception, \"Invalid format for 'spdot' argument: %s and %s\" % (\n type(a).__name__, type(b).__name__)\n return ab\n\n\ndef spmultiply(a, b, array_out=True):\n \"\"\"\n Element-wise multiplication function to deal with sparse and dense\n objects. Both objects must be of the same type.\n\n Parameters\n ----------\n\n a : array\n first multiplication factor. Can either be sparse or dense.\n b : array\n second multiplication factor. Can either be sparse or dense.\n integer.\n array_out : boolean\n If True (default) the output object is always a np.array\n\n Returns\n -------\n\n ab : array\n elementwise multiplied object. Sparse if a is sparse. Dense otherwise.\n \"\"\"\n if type(a).__name__ == 'ndarray' and type(b).__name__ == 'ndarray':\n ab = a * b\n elif (type(a).__name__ == 'csr_matrix' or type(a).__name__ == 'csc_matrix') \\\n and (type(b).__name__ == 'csr_matrix' or type(b).__name__ == 'csc_matrix'):\n ab = a.multiply(b)\n if array_out:\n if type(ab).__name__ == 'csc_matrix' or type(ab).__name__ == 'csr_matrix':\n ab = ab.toarray()\n else:\n raise Exception, \"Invalid format for 'spmultiply' argument: %s and %s\" % (\n type(a).__name__, type(b).__name__)\n return ab\n\n\ndef sphstack(a, b, array_out=False):\n \"\"\"\n Horizontal stacking of vectors (or matrices) to deal with sparse and dense objects\n\n Parameters\n ----------\n\n a : array or sparse matrix\n First object.\n b : array or sparse matrix\n Object to be stacked next to a\n array_out : boolean\n If True the output object is a np.array; if False (default)\n the output object is an np.array if both inputs are\n arrays or CSR matrix if at least one input is a CSR matrix\n\n Returns\n -------\n\n ab : array or sparse matrix\n Horizontally stacked objects\n \"\"\"\n if type(a).__name__ == 'ndarray' and type(b).__name__ == 'ndarray':\n ab = np.hstack((a, b))\n elif type(a).__name__ == 'csr_matrix' or type(b).__name__ == 'csr_matrix':\n ab = SP.hstack((a, b), format='csr')\n if array_out:\n if type(ab).__name__ == 'csr_matrix':\n ab = ab.toarray()\n else:\n raise Exception, \"Invalid format for 'sphstack' argument: %s and %s\" % (\n type(a).__name__, type(b).__name__)\n return ab\n\n\ndef spbroadcast(a, b, array_out=False):\n \"\"\"\n Element-wise multiplication of a matrix and vector to deal with sparse \n and dense objects\n\n Parameters\n ----------\n\n a : array or sparse matrix\n Object with one or more columns.\n b : array\n Object with only one column\n array_out : boolean\n If True the output object is a np.array; if False (default)\n the output object is an np.array if both inputs are\n arrays or CSR matrix if at least one input is a CSR matrix\n\n Returns\n -------\n\n ab : array or sparse matrix\n Element-wise multiplication of a and b\n \"\"\"\n if type(a).__name__ == 'ndarray' and type(b).__name__ == 'ndarray':\n ab = a * b\n elif type(a).__name__ == 'csr_matrix':\n b_mod = SP.lil_matrix((b.shape[0], b.shape[0]))\n b_mod.setdiag(b)\n ab = (a.T * b_mod).T\n if array_out:\n if type(ab).__name__ == 'csr_matrix':\n ab = ab.toarray()\n else:\n raise Exception, \"Invalid format for 'spbroadcast' argument: %s and %s\" % (\n type(a).__name__, type(b).__name__)\n return ab\n\n\ndef spmin(a):\n \"\"\"\n Minimum value in a matrix or vector to deal with sparse and dense objects\n\n Parameters\n ----------\n\n a : array or sparse matrix\n Object with one or more columns.\n\n Returns\n -------\n\n min a : int or float\n minimum value in a\n \"\"\"\n return a.min()\n\ndef spmax(a):\n \"\"\"\n Maximum value in a matrix or vector to deal with sparse and dense objects\n\n Parameters\n ----------\n\n a : array or sparse matrix\n Object with one or more columns.\n\n Returns\n -------\n\n max a : int or float\n maximum value in a\n \"\"\"\n return a.max()\n\ndef splogdet(a):\n \"\"\"\n Compute the log determinant of a large matrix. \n\n Parameters\n ----------\n\n a : array or sparse matrix\n Object with one or more columns\n\n Returns\n -------\n\n log determinant of a : int or float\n logged determinant of a\n \"\"\"\n if SP.issparse(a):\n LU = SPla.splu(a)\n det = np.sum(np.log(np.abs(LU.U.diagonal())))\n else:\n sgn, ldet = la.slogdet(a)\n det = sgn * ldet\n return det\n\ndef spfill_diagonal(a, val):\n \"\"\"\n Fill the diagonal of a sparse or dense matrix\n\n Parameters\n ----------\n\n a : array or sparse matrix\n Object with one or more columns\n val : int or float\n value with which to fill the diagonal of a\n\n Returns\n -------\n\n a with val on each element of the diagonal\n \"\"\"\n if SP.issparse(a):\n a.setdiag(val)\n else:\n np.fill_diagonal(a, val)\n return a\n\ndef spinv(a):\n \"\"\"\n Compute the inverse of a sparse or dense matrix\n\n Parameters\n ----------\n\n a : array or sparse matrix\n Object with one or more columns\n \n Returns\n -------\n\n ai, the inverse of a\n \"\"\"\n if SP.issparse(a):\n ai = SPla.inv(a)\n else:\n ai = la.inv(a)\n return ai\n\ndef spisfinite(a):\n \"\"\"\n Determine whether an array has nan or inf values\n\n Parameters\n ----------\n a : array or sparse matrix\n Object with one or more columns\n\n Returns\n -------\n bool denoting whether or not the array contains any NaN or inf\n \"\"\"\n return np.isfinite(a.sum())\n\ndef _test():\n import doctest\n doctest.testmod()\n\nif __name__ == '__main__':\n _test()\n\n", "meta": {"hexsha": "0fde0e9d5c27b6a5a2c52cbf8ea15430c54fa14f", "size": 7410, "ext": "py", "lang": "Python", "max_stars_repo_path": "pysal/spreg/sputils.py", "max_stars_repo_name": "cubensys/pysal", "max_stars_repo_head_hexsha": "8d50990f6e6603ba79ae1a887a20a1e3a0734e51", "max_stars_repo_licenses": ["MIT", "BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pysal/spreg/sputils.py", "max_issues_repo_name": "cubensys/pysal", "max_issues_repo_head_hexsha": "8d50990f6e6603ba79ae1a887a20a1e3a0734e51", "max_issues_repo_licenses": ["MIT", "BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pysal/spreg/sputils.py", "max_forks_repo_name": "cubensys/pysal", "max_forks_repo_head_hexsha": "8d50990f6e6603ba79ae1a887a20a1e3a0734e51", "max_forks_repo_licenses": ["MIT", "BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-07-19T01:46:17.000Z", "max_forks_repo_forks_event_max_datetime": "2021-07-19T01:46:17.000Z", "avg_line_length": 26.847826087, "max_line_length": 87, "alphanum_fraction": 0.5457489879, "include": true, "reason": "import numpy,import scipy,from scipy", "num_tokens": 1759, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5660185351961016, "lm_q2_score": 0.341582499438317, "lm_q1q2_score": 0.19334202598069936}} {"text": "import sys\nimport os\nimport os.path\nimport copy\nimport collections\nimport ast\n\n\n\nimport numpy\nimport numpy as np\nimport pandas as pd\n\nfrom limatix.lm_units import parseunits,multiplyunits,printunits\n\nfrom matplotlib import pyplot as pl\n#import pyximport\n#pyximport.install()\nfrom . import convolution\nfrom .convolution import impulse_response,convolution_evaluation\n\n\n#\n#\n# Inputs:\n# Welder model: Vector A of complex amplitude\n# Vector alpha of complex exponents\n# time delay (syn_time_delay)\n# initial_displacement (should be -rho*c_A) because motion positive toward vibrometer\n# Welder model predicts response to an impulse force away from the vibrometer\n# with amplitude 1 N*s\n\n# Also need a model for the pneumatic cylinder behaviour\n# That provides the restoring force\n# and the long-time behavior where the 1 N-s impulse\n# accelerate the entire welder. \n\n\n#\n#\n# Welder & Specimen model\n# Represent as impulse response, possibly followed by continued ringing\n# of one or more decaying sinusoids (i.e. exp(-alpha*t)\n\n\nclass dummy(object):\n pass\n\npkgpath = sys.modules[dummy.__module__].__file__\npkgdir=os.path.split(pkgpath)[0]\n\n# All welder responses now loaded from welder_modeling_out.py\nwelder_model_output_dir = pkgdir\n\n# Welder model provides globals welder_tip_tip_resp, welder_tip_elec_resp, welder_elec_tip_resp,\n# and welder_elec_elec_resp\nexec(open(os.path.join(welder_model_output_dir,\"welder_modeling_out.py\")).read(),globals())\n\n\n## Temporarily zero out welder_tip_tip_resp for convergence testing\n#welder_tip_tip_resp.h[:]=0.0\n#welder_tip_tip_resp.h[:10]=-1e-28\n#welder_tip_tip_resp.h[1]=-1e-28\n#welder_tip_tip_resp.A[:]=0.0\n\ndefault_welder_spring_constant=5000 # N/m -- bounciness of seals in welder pneumatic cylinder\ndefault_R_contact=25.4e-3 # Hertzian contact parameter: 1 inch radius \ndefault_welder_elec_freq=19890.0 # Frequency, Hz\ndefault_dt=1e-6 # Time step, seconds\n\ndefault_gpu_precision=\"single\" # gpu_precision must be \"single\" or \"double\"\n\ncontact_F_nominal = 100.0 # N -- nominal contact force used to decide to neglect imaginary parts order of magnitude smaller\nG_nominal = contact_F_nominal**(1.0/3.0)\n\n\n#specimen_model_output_dir = '.'\n#specimen_model_fname = \"specimen_modeling_out.py\"\n#specimen_model_fname = \"cantilever_modeling_out.py\"\n#specimen_model_fname = \"cantilever_modeling_out_moredamping.py\"\n#specimen_model_fname = \"cantilever_modeling_out_2019_10_01.py\"\n#specimen_model_fname = \"cantilever_modeling_out_2019-11-09-finerseg.py.xz\"\n\n## response of specimen, evaluated at welder contact point\n#specimen_dataframe = pd.read_csv(specimen_model_fname)\n#specimen_resp =\n\n#specimen_model_fpath=os.path.join(specimen_model_output_dir,specimen_model_fname)\n\n\ndef select_gpu_device(priority_list_str):\n \"\"\"Based on a priority list string of the form:\n [\n ('NVIDIA CUDA','Quadro GP100'), \n ('Intel(R) OpenCL HD Graphics','Intel(R) Gen9 HD Graphics NEO'), \n ('Portable Computing Language','pthread-AMD EPYC 7351P 16-Core Processor')\n ]\n select the first of these devices found and return (context,device,queue).\n If priority_list_str==\"\" then None will be returned. \n Otherwise a ValueError or other error will be raised if the \n string is not parseable or if the device is not found. \n \n Each entry in the list is (Platform Name, Device Name)\n The available platforms and devices can be found by looking\n at the output of the \"clinfo\" command. \n \"\"\"\n \n if priority_list_str != \"\":\n import pyopencl as cl\n gpu_device_priority_list = ast.literal_eval(priority_list_str)\n platforms=cl.get_platforms()\n platforms_byname = { platform.name: platform for platform in platforms }\n\n device = None\n \n for (gpu_platform_name,gpu_device_name) in gpu_device_priority_list:\n \n if gpu_platform_name in platforms_byname:\n platform = platforms_byname[gpu_platform_name]\n\n devices=platform.get_devices()\n devices_byname = { device.name: device for device in devices }\n\n if gpu_device_name in devices_byname:\n device=devices_byname[gpu_device_name]\n break\n pass\n pass\n \n if device is None:\n raise ValueError(\"No OpenCL devices found matching any entry in priority list %s. Use clinfo command to find platform name and device name. Priority list must be entered using list notation: \\\"[ ('platform1_name','device1_name'), ('platform2_name','device2_name') ]\\\"\")\n context = cl.Context(devices=[device])\n queue = cl.CommandQueue(context)\n gpu_context_device_queue = (context,device,queue)\n pass\n else:\n gpu_context_device_queue=None\n pass\n return gpu_context_device_queue\n\ndef load_specimen_model(specimen_model_filepath):\n import pandas as pd\n specimen_dataframe = pd.read_csv(specimen_model_filepath,index_col=\"Time(s)\")\n \n #dt=specimen_dataframe[\"Time(s)\"][1]-specimen_dataframe[\"Time(s)\"][0]\n dt=specimen_dataframe.index[1]-specimen_dataframe.index[0]\n\n assert(specimen_dataframe.index[0]==0.0)\n \n specimen_dict=collections.OrderedDict() \n specimen_units_dict=collections.OrderedDict() \n for column in specimen_dataframe.columns:\n if column==\"Time(s)\":\n continue\n unitstartidx = column.find(\"(\")\n if unitstartidx < 0: \n raise ValueError(\"Dynamic model column name \\\"%s\\\" does not include units\" % (column))\n fieldname=column[:unitstartidx]\n fieldunits_with_close_paren=column[(unitstartidx+1):].strip()\n if not fieldunits_with_close_paren.endswith(\")\"):\n raise ValueError(\"Dynamic model column \\\"%s\\\" units do not end with close parentheses\" % (column))\n fieldunits = fieldunits_with_close_paren[:-1]\n \n \n specimen_dict[fieldname]=convolution.impulse_response(\n h=np.array(specimen_dataframe[column]),\n dt=dt,\n t0=0.0,\n A=np.array((0,),dtype='d'),\n D=0.0,\n alpha=np.array((1.0,),dtype='d'))\n \n \n specimen_units_dict[fieldname]=fieldunits\n pass\n\n return (specimen_dict,specimen_units_dict) # keys are \"specimen_resp\", etc.; values are impulse_response instances\n\n\ndef contact_model(specimen_dict,\n specimen_units_dict,\n t0_t1, # Excitation start time (seconds)\n t2_t3, # Excitation end time (seconds)\n t4, # Time to calculate out to (seconds)\n mass_of_welder_and_slider, # mass, kg\n pneumatic_force, # Force, N\n welder_elec_ampl, # Amplitude (au...? should be volts)\n specimen_E, specimen_nu, # Specimen elastic params\n welder_spring_constant=default_welder_spring_constant, # N/m -- bounciness of seals in welder pneumatic cylinder\n R_contact=default_R_contact, # Hertzian contact parameter: 1 inch radius \n welder_elec_freq=default_welder_elec_freq, # Frequency, Hz\n dt=default_dt, # Time step, seconds\n gpu_context_device_queue=None, \n gpu_precision=default_gpu_precision):\n\n # specimen_model defines specimen_resp, specimen_mobility, specimen_laser,\n # specimen_crackcenternormalstrain, and specimen_crackcentershearstrain\n \n ## temporarily hardwire gpu_precision to double\n #gpu_precision=\"double\"\n #gpu_context_device_queue=None # Temporarily disable GPU\n\n #s(pecimen_dict,specimen_units_dict)=load_specimen_model(specimen_model_fpath)\n\n # IDEA: Add small uniform real part to specimen_resp in frequency domain\n # To keep the phase away from the edge.... FAILED\n\n # IDEA: Add damping to Hertzian contact spring\n\n # Resample specimen data to desired dt value\n for key in specimen_dict:\n \n specimen_dict[key].resample(dt)\n pass\n \n specimen_resp=specimen_dict[\"specimen_resp\"]\n del specimen_dict[\"specimen_resp\"] # Remove specimen_resp from specimen_dict so convolutions with entries in specimen_dict will not be redundant\n if \"specimen_mobility\" in specimen_dict:\n del specimen_dict[\"specimen_mobility\"] # Don't care about predicting specimen contact velocity\n pass \n \n ## Temporarily zero out specimen_resp\n #specimen_resp.h[:]=0.0\n\n assert(welder_elec_tip_resp.h[0]==0.0) # response of tip to electrical excitation MUST be delayed\n assert(welder_elec_elec_resp.h[0]==0.0) # electrical response to electrical excitation MUST be delayed\n assert(welder_tip_elec_resp.h[0]==0.0) # electrical response to tip impulse MUST be delayed\n \n \n welder_tip_tip_resp_local=copy.deepcopy(welder_tip_tip_resp)\n welder_tip_elec_resp_local=copy.deepcopy(welder_tip_elec_resp)\n welder_elec_tip_resp_local=copy.deepcopy(welder_elec_tip_resp)\n welder_elec_elec_resp_local=copy.deepcopy(welder_elec_elec_resp)\n \n # resample all responses to desired timestep\n welder_tip_tip_resp_local.resample(dt)\n welder_tip_elec_resp_local.resample(dt)\n welder_tip_elec_resp_local.h[0]=0.0 # resampling can mess this up\n welder_elec_tip_resp_local.resample(dt)\n welder_elec_tip_resp_local.h[0]=0.0 # resampling can mess tihs up\n welder_elec_elec_resp_local.resample(dt)\n welder_elec_elec_resp_local.h[0]=0.0 # resampling can mess this up\n \n\n # welder_tip_tip_resp_local.h[0] is negative... specimen_resp.h[0] is positive,\n # (criteria for solving for contact force, below)\n assert(welder_tip_tip_resp_local.h[1] < 0.0)\n #assert(specimen_resp.h[0] > 0.0)\n \n\n # Connect specimen and welder models at contact\n # * Sum of forces at contact = 0 (contact massless)\n # * No overlap between specimen and welder.\n \n # z positive towards specimen\n welder_tip_z = 0\n specimen_z = 0\n \n #max_t = 0.1\n #max_t = 0.3\n #max_t=0.2\n trange = np.arange(t4/dt)*dt\n \n #mass_of_welder_and_slider=2.0 # mass, kg !!!*** Need to properly measure\n #pneumatic_force = 300 # Force, N ***!!! Not necessarily representative\n # NOTE: If welder_spring_constant is nonzero, the pneumatic force ( in\n # equilbrium) be split between contact load and spring!!!\n \n\n # NOTE: with welder_overall_dashpot = 0\n # get resonance (~170Hz as of this writing), which\n # matches (1/(2pi))*sqrt(k/m) for\n # m = mass_of_welder_and_slider = 2 and\n # k = 1.0/(np.sum(specimen_resp.eval(np.arange(trange.shape[0])).real)*dt) = 2.5e6 N/m\n # represents the effective DC stiffness of the specimen\n # (we should consider the welder and contact stiffnesses as well probably,\n # but they are much stiffer!) \n # For critically damped, set damping ratio = c/(2sqrt(m*k)) = 1\n # so c = 2*sqrt(m*k) = 4472 for critically damped.\n # Probably want significantly underdamped, so set c=400 N/(m/s)\n welder_overall_dashpot = 1000 # dashpot coefficient simulating absorption of pneumatic cylinder\n \n # ... at welder 50% amplitude setting , expect open circuit velocity of roughly 80 um p-p at 20 kHz. this corresponds to a welder_elec_ampl of ~1.8e7 (UNITS?)\n #welder_elec_ampl= 1.8e7*1.0\n \n #... double it!\n #welder_elec_ampl= 1.8e7*5.0\n \n #welder_elec_freq=19890.0\n \n # Plot welder open-circuit behavior with:\n #\n #welder_elec_input = welder_elec_ampl*np.cos(2*np.pi*welder_elec_freq*trange)\n #welder_elec_tip_conv = convolution_evaluation.blank_from_imp_resp(welder_elec_tip_resp)\n #welder_tip_z = np.zeros(trange.shape,dtype='d')\n #for tcnt in range(trange.shape[0]):\n # welder_tip_z[tcnt]=welder_elec_tip_conv.step(welder_elec_input[tcnt])\n # pass\n #pl.plot(trange,welder_tip_z)\n \n \n # NOTE: This spring represents the limited contact zone,\n # and helps to prevent system resonances involving\n # high Q, high-mobility resonances like the 20 kHz welder motion\n #kspring = 120e9*(np.pi*12e-3**2/4.0)/(1e-3)*.1 # *100) # contact stiffness, N/m\n # NOTE: kspring replaced by Hertzian contact model\n # Hertzian contact parameters\n #R_contact=25.4e-3 # 1 inch radius\n # Welder material (Ti)\n nu1=.342\n E1=113.8e9\n \n ## Al\n #nu2=.33\n #E2=68.9e9\n \n\n Estar = 1.0/( (1.0-nu1**2.0)/E1 + (1.0-specimen_nu**2.0)/specimen_E)\n\n\n # This spring represents the bounciness of the seals in the pneumatic cylinder... based on 20 ms resonant period, and assuming 2kg mass,\n # f=sqrt(k/m) = 1/.02\n # f*sqrt(m) = sqrt(k)\n # k = f^2*m = (1/.02)^2 * 2.0 = 5000 N/m \n # ... if you set this to 0, then you get instead pure\n # pneumatic cylinder behavior\n #welder_spring_constant = 5000\n \n\n welder_overall_velocity=0.0 # positive towards specimen\n #welder_overall_pos=-.5e-3 # half-mm distance initially # positive towards specimen\n #welder_overall_pos=0e-3 # no distance initially # positive towards specimen\n \n # This code is for starting from equilibrium displacement\n # Next line is correct for pneumatic cylinder but no spring\n #welder_overall_pos = convolution_evaluation.quiescent_value(pneumatic_force,specimen_resp.A,specimen_resp.alpha,specimen_resp.dt,specimen_resp.h).real - convolution_evaluation.quiescent_value(pneumatic_force,welder_tip_tip_resp_local.A,welder_tip_tip_resp_local.alpha,welder_tip_tip_resp_local.dt,welder_tip_tip_resp_local.h).real\n\n # overall_pos = specimen_quiescent_coeff*(pneumatic-welder_spring_constant*overall_pos) - welder_quiescent_coeff*(pneumatic-welder_spring_constant*overall_pos)\n # overall_pos = specimen_quiescent_coeff*pneumatic-specimen_quescent_coeff * welder_spring_constant*overall_pos - welder_quiescent_coeff*pneumatic + welder_quiescent_coeff*welder_spring_constant*overall_pos\n # overall_pos*(1.0 + specimen_quiescent_coeff*welder_spring_constant - welder_quiescent_coeff*welder_spring_constant) = (specimen_quiescent_coeff - welder_quiescent_coeff)*pneumatic\n # overall_pos = (specimen_quiescent_coeff - welder_quiescent_coeff)*pneumatic/(1.0 + specimen_quiescent_coeff*welder_spring_constant - welder_quiescent_coeff*welder_spring_constant)\n\n # Hertzian equilibrium displacement:\n # Displacement = (9/(16Estar^2R))^(1/3) * contact_F^(2/3)\n initial_contact_displacement = (9.0/(16.0*R_contact*Estar**2.0))**(1.0/3.0) * pneumatic_force**(2.0/3.0)\n \n\n welder_overall_pos = (convolution_evaluation.quiescent_value(1.0,specimen_resp.A,specimen_resp.alpha,specimen_resp.dt,specimen_resp.h).real - convolution_evaluation.quiescent_value(1.0,welder_tip_tip_resp_local.A,welder_tip_tip_resp_local.alpha,welder_tip_tip_resp_local.dt,welder_tip_tip_resp_local.h).real)*pneumatic_force/(1.0 + convolution_evaluation.quiescent_value(1.0,specimen_resp.A,specimen_resp.alpha,specimen_resp.dt,specimen_resp.h).real*welder_spring_constant - convolution_evaluation.quiescent_value(1.0,welder_tip_tip_resp_local.A,welder_tip_tip_resp_local.alpha,welder_tip_tip_resp_local.dt,welder_tip_tip_resp_local.h).real*welder_spring_constant) + initial_contact_displacement\n\n\n \n\n\n # Define convolutions of the various responses\n # This is for zero initial displacement\n #specimen_conv = convolution_evaluation.blank_from_imp_resp(specimen_resp)\n # This is for equilbrium initial displacement\n\n specimen_conv = convolution_evaluation.quiescent_from_imp_resp(specimen_resp,pneumatic_force-welder_overall_pos*welder_spring_constant,gpu_context_device_queue=gpu_context_device_queue,gpu_precision=gpu_precision)\n\n\n # specimen_dict_conv gets convolution evaluations setup just like\n # specimen_conv for all the other characteristics of interest\n # (laser point velocity, crack normal stress, etc.)\n specimen_dict_conv=collections.OrderedDict()\n specimen_dict_history=collections.OrderedDict()\n for specimen_motion_name in specimen_dict:\n original_unit_str = specimen_units_dict[specimen_motion_name]\n original_units = parseunits(original_unit_str)\n \n # Convolving with force as a function multiplies by Newton seconds\n convolve_units = parseunits(\"N*s\")\n convolution_units = multiplyunits(original_units,convolve_units)\n\n specimen_motion_characteristic=\"%s(%s)\" % (specimen_motion_name,printunits(convolution_units))\n \n specimen_dict_conv[specimen_motion_characteristic] = convolution_evaluation.quiescent_from_imp_resp(specimen_dict[specimen_motion_name],pneumatic_force-welder_overall_pos*welder_spring_constant,gpu_context_device_queue=gpu_context_device_queue,gpu_precision=gpu_precision)\n\n specimen_dict_history[specimen_motion_characteristic]=np.zeros(trange.shape[0],dtype='d')\n\n \n pass\n \n \n\n assert(dt==specimen_resp.dt)\n \n \n # This is for zero initial displacement\n #welder_tip_tip_conv = convolution_evaluation.blank_from_imp_resp(welder_tip_tip_resp_local)\n # This is for equilbrium initial displacement\n welder_tip_tip_conv = convolution_evaluation.quiescent_from_imp_resp(welder_tip_tip_resp_local,pneumatic_force)\n assert(dt==welder_tip_tip_resp_local.dt)\n\n\n welder_tip_elec_conv = convolution_evaluation.blank_from_imp_resp(welder_tip_elec_resp_local)\n assert(dt==welder_tip_elec_resp_local.dt)\n \n welder_elec_tip_conv = convolution_evaluation.blank_from_imp_resp(welder_elec_tip_resp_local)\n assert(dt==welder_elec_tip_resp_local.dt)\n assert(welder_elec_tip_resp_local.h[0]==0.0) # response of tip to electrical excitation MUST be delayed\n \n welder_elec_elec_conv = convolution_evaluation.blank_from_imp_resp(welder_elec_elec_resp_local)\n assert(dt==welder_elec_elec_resp_local.dt)\n assert(welder_elec_elec_resp_local.h[0]==0.0) # electrical response to electrical excitation MUST be delayed\n \n\n\n specimen_z_history=np.zeros(trange.shape[0],dtype='d')\n welder_tip_z_history=np.zeros(trange.shape[0],dtype='d')\n contact_F_history=np.zeros(trange.shape[0],dtype='d')\n welder_overall_velocity_history=np.zeros(trange.shape[0],dtype='d')\n\n welder_tip_z=welder_tip_tip_conv.evaluate() + welder_elec_tip_conv.evaluate() + welder_overall_pos\n\n specimen_z=specimen_conv.evaluate()\n \n \n last_overlap = welder_tip_z - specimen_z\n\n for tcnt in range(trange.shape[0]):\n if tcnt % 10000 == 0:\n print(\"tcnt=%d/%d\" % (tcnt,trange.shape[0]))\n\n # memory leak debugging\n #import tracemalloc\n #snapshot=tracemalloc.take_snapshot()\n #top_stats=snapshot.statistics('lineno')\n #print(\"Top 25:\")\n #print(\"\\n\".join([str(stat) for stat in top_stats[:25]]))\n #print(\" \")\n pass\n \n\n\n #if tcnt==42890:\n # raise ValueError(\"Debug!\")\n \n #if tcnt==3953: \n # import pdb\n # pdb.set_trace()\n # pass\n\n specimen_z=specimen_conv.step_without_instantaneous()\n \n welder_overall_pos += welder_overall_velocity*dt\n welder_tip_z=welder_tip_tip_conv.step_without_instantaneous() + welder_elec_tip_conv.step_without_instantaneous() + welder_overall_pos\n \n \n \n welder_elec_resp_voltage = welder_tip_elec_conv.step_without_instantaneous() + welder_elec_elec_conv.step_without_instantaneous()\n \n # Determine electrical control input\n \n # Welder elec input --- Could include welder controller behavior here (based on welder_elec_resp_voltage and its history)\n \n if trange[tcnt] >= t0_t1 and trange[tcnt] <= t2_t3:\n welder_elec_input = welder_elec_ampl*np.cos(2*np.pi*welder_elec_freq*(trange[tcnt]-t0_t1))\n pass\n else:\n welder_elec_input = 0.0\n pass\n\n # Determine contact force from overlap\n \n # evaluate overlap\n overlap = welder_tip_z - specimen_z # overlap represents amount of overalp between welder and specimen if no force is applied in this step\n\n\n if overlap > 0:\n # Conditions\n # Define Fwelder positive compression into welder\n # Define Fspecimen positive compression into specimen\n # Fwelder = Fspecimen\n # zshift_welder = instantaneous_welder_displacement*Fwelder*dt # instantaneous_welder_displacement from welder model corresponds to displacement resulting from a 1 N*s impulse. Therefore it can be interpreted as have units of meters/(N*s) It is negative because the positive contact_F pulse pushes the welder away from the vibrometer\n # zshift_specimen = specimen_response[0]*Fspecimen*dt # Due to 1 N*s impulse... Should be positive\n # Add in contact springiness in series with\n # surface springiness:\n # zspring=contact_F/kspring\n # zshift_welder - zshift_specimen - zspring = -overlap (known)\n \n # Solve this sytem....\n # let contact_F = Fwelder = Fspecimen = Fspring\n # instantaneous_welder_displacement*contact_F*dt - specimen_response[0]*contact_F*dt - contact_F/kspring = -overlap\n # F = -overlap/(dt*(instantaneous_welder_displacement-specimen_resp[0]) - (1/kspring))\n \n # New Hertzian contact model\n # instantaneous_welder_displacement*contact_F*dt - specimen_response[0]*contact_F*dt - (9/(16Estar^2R))^(1/3) * contact_F^(2/3) = -nocontactforce_overlap\n \n # This is a cubic equation for contact_F\n # for a*F - b*F^(2/3) + c = 0\n # G = F^(1/3)\n # a*G^3 - b*G^2 + c = 0\n G = np.roots([np.real(welder_tip_tip_resp_local.h[0]*dt-specimen_resp.h[0]*dt),-(9.0/(16.0*R_contact*Estar**2.0))**(1.0/3.0),0.0,overlap])\n use_G = G[(G.real > 0) & (abs(G.imag) <= G_nominal*1e-8)].real\n if use_G.shape[0] != 1:\n raise ValueError(\"Bad Hertzian contact solution: %s\" % (str(G)))\n \n contact_F=use_G[0]**3.0\n \n\n # Old simple spring contact model here:\n #contact_F = -overlap/(dt*(np.real(welder_tip_tip_resp_local.h[0]-specimen_resp.h[0])) - 1.0/kspring) # welder_tip_tip_resp_local.h[0] is negative... specimen_resp.h[0] is positive, overlap is positive, so contact_F is positive for compressive force between\n # Welder and specimen\n # Accumulate immediate response to this force\n pass\n else:\n contact_F=0.0\n pass\n \n contact_F_history[tcnt]=contact_F\n \n \n # Need to convolve force history\n # displacement = integral( F(t-tau) * response(tau)) dtau\n # store force history Fhist(t)\n # At a particular time t, \n # displacement = integral( F(t-tau) * response(tau)) dtau where tau >= 0\n \n #welder_tip_z = welder_tip_z + contact_F*welder_tip_tip_resp_local.h[0]*dt\n #specimen_z = specimen_z + contact_F*specimen_resp.h[0]*dt\n \n # Positive (compressive) contact_F gives positive instantaneous\n # contribution... specimen_z moves in +z direction (away from welder)\n specimen_z += specimen_conv.step_instantaneous_contribution(contact_F)\n\n for specimen_motion_characteristic in specimen_dict_conv:\n specimen_dict_history[specimen_motion_characteristic][tcnt] = specimen_dict_conv[specimen_motion_characteristic].step(contact_F)\n pass\n \n \n # Positive (compressive) contact_F gives negative instantaneous\n # contribution... welder tip moves in -z direction (away from specimen)\n # Also need to apply contribution of welder electric input (but\n # the instantaneous effect of this is zero\n welder_tip_z += welder_tip_tip_conv.step_instantaneous_contribution(contact_F) + welder_elec_tip_conv.step_instantaneous_contribution(welder_elec_input)\n \n # Apply the contribution to the electric response...\n # instantaneous effect is zero. \n welder_elec_resp_voltage = welder_tip_elec_conv.step_instantaneous_contribution(contact_F) + welder_elec_elec_conv.step_instantaneous_contribution(welder_elec_input)\n assert(welder_elec_resp_voltage==0.0) # These should not have instantaneous responses!\n \n \n # Should verify that overlap has been reduced to approximately 0\n new_overlap = welder_tip_z - specimen_z\n #assert(new_overlap < 1e-12) (new overlap is no longer small now that we have added contact stiffness) \n \n specimen_z_history[tcnt]=specimen_z\n welder_tip_z_history[tcnt]=welder_tip_z\n \n # determine change in welder_overall_velocity\n # ***!!!! Should this have a lag ?\n # F = ma -> a = F/m\n # v = vprior + a*dt\n # v = vprior + (F/m)*dt\n # Where F = pneumatic_force - contact_F - welder_overall_dashpot*welder_overall_velocity\n welder_spring_force = -welder_tip_z*welder_spring_constant + pneumatic_force # use \"pneumatic_force\" parameter as spring preload\n welder_overall_velocity += ((welder_spring_force-contact_F - welder_overall_dashpot*welder_overall_velocity)/mass_of_welder_and_slider) * dt\n assert(np.imag(welder_overall_velocity)==0.0)\n \n welder_overall_velocity_history[tcnt]=welder_overall_velocity\n \n #if tcnt >= 80890 and contact_F > 0:\n #raise ValueError(\"Debug!\")\n # break\n last_overlap = new_overlap\n pass\n # !!! Need conservation of energy constraint !!!***\n # Would it help to make contact more compliant (don't require\n # exactly zero overlap)? \n \n \n motiontable = pd.DataFrame(index=pd.Float64Index(data=np.arange(trange.shape[0],dtype='d')*dt,dtype='d',name=\"Time(s)\"))\n \n motiontable.insert(len(motiontable.columns),\"specimen_z_history(m)\",specimen_z_history)\n motiontable.insert(len(motiontable.columns),\"welder_tip_z_history(m)\",welder_tip_z_history)\n motiontable.insert(len(motiontable.columns),\"contact_F_history(N)\",contact_F_history)\n motiontable.insert(len(motiontable.columns),\"welder_overall_velocity_history(m/s)\",welder_overall_velocity_history)\n\n motiontable.insert(len(motiontable.columns),\"welder_tip_tip_resp(m/(N*s))\",welder_tip_tip_resp_local.eval(np.arange(trange.shape[0])).real)\n motiontable.insert(len(motiontable.columns),\"specimen_resp(m/(N*s))\",specimen_resp.eval(np.arange(trange.shape[0])).real)\n \n for specimen_motion_characteristic in specimen_dict_history:\n motiontable.insert(len(motiontable.columns),specimen_motion_characteristic,specimen_dict_history[specimen_motion_characteristic])\n pass\n \n return motiontable\n\ndef write_motiontable(motiontable,output_filename):\n if output_filename.endswith(\".bz2\"):\n motiontable.to_csv(output_filename,compression='bz2')\n pass\n else:\n motiontable.to_csv(output_filename)\n pass\n\n pass\n\n\n\ndef plot_contact(motiontable,exc_t0):\n\n trange = np.array(motiontable.index) # [\"Time(s)\"]\n dt=trange[1]-trange[0]\n\n difft = (trange[:-1]+trange[1:])/2.0\n\n max_t_plot = np.max(trange)\n \n # round length up to next power-of-two size \n # so we don't get bogged down if trange.shape[0] is prime\n fft_len = 1 << int(np.ceil(np.log(trange.shape[0])/np.log(2)))\n \n frange = np.arange(fft_len,dtype='d')/(fft_len*dt)\n frange[fft_len//2:] -= 1.0/dt\n frange[fft_len//2]=np.nan\n\n welder_tip_z_history = motiontable[\"welder_tip_z_history(m)\"]\n specimen_z_history = motiontable[\"specimen_z_history(m)\"]\n contact_F_history = motiontable[\"contact_F_history(N)\"]\n specimen_laser_vel_history = motiontable[\"specimen_laser(m/s)\"]\n \n impresp_plot=pl.figure()\n pl.clf()\n pl.title(\"Welder and specimen impulse response\")\n pl.plot(trange*1e6,\n motiontable[\"welder_tip_tip_resp(m/(N*s))\"],'-',\n trange*1e6,\n motiontable[\"specimen_resp(m/(N*s))\"],'--') \n pl.xlabel('time (us)')\n pl.legend(('Welder','Specimen'))\n pl.grid()\n \n velspec_plot=pl.figure()\n pl.clf()\n pl.title(\"Welder and specimen velocity spectrum\")\n pl.plot(frange/1e3,\n np.abs(np.fft.fft(motiontable[\"welder_tip_tip_resp(m/(N*s))\"],n=fft_len)*dt*(2.0*np.pi*np.abs(frange))),'-',\n frange/1e3,\n np.abs(np.fft.fft(motiontable[\"specimen_resp(m/(N*s))\"],n=fft_len)*dt*(2.0*np.pi*np.abs(frange))),'--')\n pl.xlabel('Frequency (kHz)')\n pl.ylabel('Velocity spectrum (m/s/Hz)')\n pl.legend(('Welder','Specimen'))\n pl.axis((0,250,0,.012))\n pl.grid()\n \n phasespec_plot = pl.figure()\n # NOTE: Because welder velocity is negated\n # relative to force direction, we undo that by negating before\n # evaluating the angle, so it is clear whether the phase is in the\n # required (-pi/2,pi/2) range\n pl.clf()\n pl.title(\"Welder and specimen velocity phase spectrum\")\n pl.plot(frange/1e3,\n np.angle(-np.fft.fft(motiontable[\"welder_tip_tip_resp(m/(N*s))\"],n=fft_len)*dt*((0+1j)*2.0*np.pi*np.abs(frange))),'-',\n frange/1e3,\n np.angle(np.fft.fft(motiontable[\"specimen_resp(m/(N*s))\"],n=fft_len)*dt*((0+1j)*2.0*np.pi*np.abs(frange))),'--')\n pl.xlabel('Frequency (kHz)')\n pl.ylabel('Phase angle (rad)')\n pl.legend(('Welder','Specimen'))\n pl.axis((0,250,-np.pi,np.pi))\n pl.grid()\n \n \n disp_plot = pl.figure()\n pl.clf()\n pl.plot(trange*1e3,specimen_z_history*1e6,'-',\n trange*1.e3,welder_tip_z_history*1e6,'-')\n pl.axis((0,max_t_plot*1.e3,min(np.min(specimen_z_history*1e6),np.min(welder_tip_z_history*1e6)),max(np.max(specimen_z_history*1e6),np.max(welder_tip_z_history*1e6))))\n pl.xlabel('Time (ms)')\n pl.ylabel('Displacement (um)')\n pl.title('Specimen and welder displacement')\n pl.legend(('Specimen','Welder'))\n pl.grid()\n \n\n \n dispzoom_plot = pl.figure()\n pl.clf()\n fig5_tstart = exc_t0 - 0.1e-3 #5e-3\n fig5_tend = exc_t0 + 0.9e-3 # 6e-3\n pl.plot(trange*1e3,specimen_z_history*1e6,'-',\n trange*1.e3,welder_tip_z_history*1e6,'-')\n pl.axis((fig5_tstart*1e3,fig5_tend*1e3,min(np.min(specimen_z_history[(trange >= fig5_tstart) & (trange <= fig5_tend)]*1e6),np.min(welder_tip_z_history[(trange >= fig5_tstart) & (trange <= fig5_tend)]*1e6)),max(np.max(specimen_z_history[(trange >= fig5_tstart) & (trange <= fig5_tend)]*1e6),np.max(welder_tip_z_history[(trange >= fig5_tstart) & (trange <= fig5_tend)]*1e6))))\n pl.xlabel('Time (ms)')\n pl.ylabel('Displacement (um)')\n pl.title('Specimen and welder displacement')\n pl.legend(('Specimen','Welder'))\n pl.grid()\n\n \n contactforce_plot = pl.figure()\n pl.clf()\n # Impulse between .28*.33\n Impulse=contact_F_history[(trange >.28e-3) & (trange < .33e-3)].sum()*dt\n pl.plot(trange*1e3,contact_F_history)\n pl.axis((0,max_t_plot*1.e3,0,20000))\n pl.xlabel('Time (ms)')\n pl.ylabel('Force (N)')\n pl.title('Contact force (time domain')\n pl.grid()\n \n \n #pl.figure(5)\n #pl.clf()\n #pl.plot(trange,welder_overall_velocity_history)\n \n contactspectrum_plot = pl.figure()\n pl.clf()\n # Impulse between .28*.33\n pl.plot(frange/1e3,np.abs(np.fft.fft(contact_F_history,n=fft_len)*dt))\n #pl.axis((0,max_t_plot*1.e3,0,20000))\n pl.xlabel('Frequency (kHz)')\n pl.ylabel('Force spectrum (N/Hz)')\n pl.title('Contact force (frequency domain')\n pl.grid()\n \n \n overlap_plot = pl.figure()\n pl.clf()\n pl.plot(trange*1.e3,(welder_tip_z_history-specimen_z_history)*1e6,'-')\n #pl.axis((0,55,-1000,500))\n pl.xlabel('Time (ms)')\n pl.ylabel('Displacement (um)')\n pl.title('Welder/specimen overlap')\n #pl.axis((0,1,-3,1))\n pl.grid()\n \n #pl.figure(7)\n #pl.clf()\n #difft = (trange[:-1]+trange[1:])/2.0\n #pl.plot(difft*1.e3,np.diff(welder_tip_z_history-specimen_z_history)/dt,'-')\n #pl.xlabel('Time (ms)')\n #pl.ylabel('Velocity (m/s)')\n #pl.grid()\n \n contactvel_plot = pl.figure()\n pl.clf()\n pl.plot(difft*1.e3,np.diff(specimen_z_history)/dt,'-')\n #pl.axis((0,55,-1000,500))\n pl.xlabel('Time (ms)')\n pl.ylabel('Velocity (m/s)')\n pl.title('Specimen contact surface velocity (synthetic vibrometer)')\n #pl.axis((0,1,-3,1))\n pl.grid()\n \n contactvelspec_plot = pl.figure()\n pl.clf()\n pl.plot(frange/1.e3,np.abs(np.fft.fft(specimen_z_history,n=fft_len)*dt*(2.0*np.pi*frange)),'-')\n #pl.axis((0,55,-1000,500))\n pl.xlabel('Frequency (kHz)')\n pl.ylabel('Velocity spectrum (m/s)/Hz')\n pl.title('Specimen contact velocity spectrum (synthetic vibrometer)')\n #pl.axis((0,1,-3,1))\n pl.grid()\n \n\n\n laservel_plot = pl.figure()\n pl.clf()\n pl.plot(trange*1e3,specimen_laser_vel_history,'-')\n pl.xlabel('Time (ms)')\n pl.ylabel('Velocity (m/s)')\n pl.title('Laser spot surface velocity (synthetic vibrometer)')\n #pl.axis((0,1,-3,1))\n pl.grid()\n \n laservelspec_plot = pl.figure()\n pl.clf()\n pl.plot(frange/1.e3,np.abs(np.fft.fft(specimen_laser_vel_history,n=fft_len)*dt),'-')\n #pl.axis((0,55,-1000,500))\n pl.xlabel('Frequency (kHz)')\n pl.ylabel('Velocity spectrum (m/s)/Hz')\n pl.title('Laser spot surface velocity spectrum (synthetic vibrometer)')\n #pl.axis((0,1,-3,1))\n pl.grid()\n \n\n\n\n plotdict = {\n \"impulse_response\": impresp_plot,\n \"velocity_spectrum\": velspec_plot,\n \"phase_spectrum\": phasespec_plot,\n \"displacement\": disp_plot,\n \"displacement_zoom\": dispzoom_plot,\n \"contact_force\": contactforce_plot,\n \"contact_spectrum\": contactspectrum_plot,\n \"overlap\": overlap_plot,\n \"contact_velocity\": contactvel_plot,\n \"contact_velocity_spectrum\": contactvelspec_plot,\n \"laser_velocity\": laservel_plot,\n \"laser_velocity_spectrum\": laservelspec_plot,\n }\n return plotdict\n", "meta": {"hexsha": "4710d9ba881e6dd7c0937b628bdff0ca612a473f", "size": 34086, "ext": "py", "lang": "Python", "max_stars_repo_path": "VibroSim_WelderModel/contact_model.py", "max_stars_repo_name": "VibroSim/VibroSim_WelderModel", "max_stars_repo_head_hexsha": "54acab2dc4c7ec8c0fb58f64333eba99b94064aa", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "VibroSim_WelderModel/contact_model.py", "max_issues_repo_name": "VibroSim/VibroSim_WelderModel", "max_issues_repo_head_hexsha": "54acab2dc4c7ec8c0fb58f64333eba99b94064aa", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "VibroSim_WelderModel/contact_model.py", "max_forks_repo_name": "VibroSim/VibroSim_WelderModel", "max_forks_repo_head_hexsha": "54acab2dc4c7ec8c0fb58f64333eba99b94064aa", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.8216080402, "max_line_length": 699, "alphanum_fraction": 0.6892565863, "include": true, "reason": "import numpy", "num_tokens": 8925, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5660185351961015, "lm_q2_score": 0.341582499438317, "lm_q1q2_score": 0.19334202598069933}} {"text": "import abc\nfrom typing import Callable, Optional, Tuple, TypeVar\n\nimport equinox as eqx\nimport jax\nimport jax.numpy as jnp\n\nfrom ..custom_types import Bool, DenseInfo, PyTree, PyTreeDef, Scalar\nfrom ..heuristics import is_sde\nfrom ..local_interpolation import AbstractLocalInterpolation\nfrom ..nonlinear_solver import AbstractNonlinearSolver, NewtonNonlinearSolver\nfrom ..solution import RESULTS\nfrom ..term import AbstractTerm\n\n\n_SolverState = TypeVar(\"SolverState\", bound=Optional[PyTree])\n\n\ndef vector_tree_dot(a, b):\n return jax.tree_map(lambda bi: jnp.tensordot(a, bi, axes=1), b)\n\n\nclass _MetaAbstractSolver(type(eqx.Module)):\n def __instancecheck__(cls, obj):\n if super(_MetaAbstractSolver, AbstractWrappedSolver).__instancecheck__(obj):\n obj = obj.solver\n return super().__instancecheck__(obj)\n\n\nclass AbstractSolver(eqx.Module, metaclass=_MetaAbstractSolver):\n \"\"\"Abstract base class for all differential equation solvers.\"\"\"\n\n @property\n @abc.abstractmethod\n def term_structure(self) -> PyTreeDef:\n \"\"\"What PyTree structure `terms` should have when used with this solver.\"\"\"\n\n # On the type: frequently just Type[AbstractLocalInterpolation]\n @property\n @abc.abstractmethod\n def interpolation_cls(self) -> Callable[..., AbstractLocalInterpolation]:\n \"\"\"How to interpolate the solution in between steps.\"\"\"\n\n def order(self, terms: PyTree[AbstractTerm]) -> Optional[int]:\n \"\"\"Order of the solver for solving ODEs.\"\"\"\n return None\n\n def strong_order(self, terms: PyTree[AbstractTerm]) -> Optional[Scalar]:\n \"\"\"Strong order of the solver for solving SDEs.\"\"\"\n return None\n\n def error_order(self, terms: PyTree[AbstractTerm]) -> Optional[Scalar]:\n \"\"\"Order of the error estimate used for adaptive stepping.\n\n The default (slightly heuristic) implementation is as follows.\n\n The error estimate is assumed to come from the difference of two methods. If\n these two methods have orders `p` and `q` then the local order of the error\n estimate is `min(p, q) + 1` for an ODE and `min(p, q) + 0.5` for an SDE.\n\n - In the SDE case then we assume `p == q == solver.strong_order()`.\n - In the ODE case then we assume `p == q + 1 == solver.order()`.\n - We assume that non-SDE/ODE cases do not arise.\n\n This is imperfect as these assumptions may not be true. In addition in the SDE\n case, then solvers will sometimes exhibit higher orders of convergence for\n specific noise types (see issue #47).\n \"\"\"\n if is_sde(terms):\n order = self.strong_order(terms)\n if order is not None:\n order = order + 0.5\n return order\n else:\n return self.order(terms)\n\n def init(\n self,\n terms: PyTree[AbstractTerm],\n t0: Scalar,\n t1: Scalar,\n y0: PyTree,\n args: PyTree,\n ) -> _SolverState:\n \"\"\"Initialises any hidden state for the solver.\n\n **Arguments** as [`diffrax.diffeqsolve`][].\n\n **Returns:**\n\n The initial solver state, which should be used the first time `step` is called.\n \"\"\"\n return None\n\n @abc.abstractmethod\n def step(\n self,\n terms: PyTree[AbstractTerm],\n t0: Scalar,\n t1: Scalar,\n y0: PyTree,\n args: PyTree,\n solver_state: _SolverState,\n made_jump: Bool,\n ) -> Tuple[PyTree, Optional[PyTree], DenseInfo, _SolverState, RESULTS]:\n \"\"\"Make a single step of the solver.\n\n Each step is made over the specified interval $[t_0, t_1]$.\n\n **Arguments:**\n\n - `terms`: The PyTree of terms representing the vector fields and controls.\n - `t0`: The start of the interval that the step is made over.\n - `t1`: The end of the interval that the step is made over.\n - `y0`: The current value of the solution at `t0`.\n - `args`: Any extra arguments passed to the vector field.\n - `solver_state`: Any evolving state for the solver itself, at `t0`.\n - `made_jump`: Whether there was a discontinuity in the vector field at `t0`.\n Some solvers (notably FSAL Runge--Kutta solvers) usually assume that there\n are no jumps and for efficiency re-use information between steps; this\n indicates that a jump has just occurred and this assumption is not true.\n\n **Returns:**\n\n A tuple of several objects:\n\n - The value of the solution at `t1`.\n - A local error estimate made during the step. (Used by adaptive step size\n controllers to change the step size.) May be `None` if no estimate was\n made.\n - Some dictionary of information that is passed to the solver's interpolation\n routine to calculate dense output. (Used with `SaveAt(ts=...)` or\n `SaveAt(dense=...)`.)\n - The value of the solver state at `t1`.\n - An integer (corresponding to `diffrax.RESULTS`) indicating whether the step\n happened successfully, or if (unusually) it failed for some reason.\n \"\"\"\n\n def func_for_init(\n self, terms: PyTree[AbstractTerm], t0: Scalar, y0: PyTree, args: PyTree\n ) -> PyTree:\n \"\"\"Provides vector field evaluations to select the initial step size.\n\n This is used to make a point evaluation. This is unlike\n [`diffrax.AbstractSolver.step`][], which operates over an interval.\n\n In general differential equation solvers are interval-based. There is precisely\n one place where point evaluations are needed: selecting the initial step size\n automatically in an ODE solve. And that is what this function is for.\n\n **Arguments:** As [`diffrax.diffeqsolve`][]\n\n **Returns:**\n\n The evaluation of the vector field at `t0`.\n \"\"\"\n\n raise ValueError(\n \"An initial step size cannot be selected automatically. The most common \"\n \"scenario for this error to occur is when trying to use adaptive step \"\n \"size solvers with SDEs. Please specify an initial `dt0` instead.\"\n )\n\n\nclass AbstractImplicitSolver(AbstractSolver):\n nonlinear_solver: AbstractNonlinearSolver = NewtonNonlinearSolver()\n\n\nclass AbstractItoSolver(AbstractSolver):\n pass\n\n\nclass AbstractStratonovichSolver(AbstractSolver):\n pass\n\n\nclass AbstractAdaptiveSolver(AbstractSolver):\n pass\n\n\nclass AbstractAdaptiveSDESolver(AbstractAdaptiveSolver):\n pass\n\n\nclass AbstractWrappedSolver(AbstractSolver):\n solver: AbstractSolver\n\n\nclass HalfSolver(AbstractWrappedSolver, AbstractAdaptiveSDESolver):\n \"\"\"Wraps another solver, trading cost in order to provide error estimates. (These\n error estimates mean that the solver can be used with an adaptive step size\n controller, like [`diffrax.PIDController`][].)\n\n For every step of the wrapped solver, it does this by also making two half-steps,\n and comparing the results. (Hence the name \"HalfSolver\".)\n\n As such each step costs 3 times the computational cost of the wrapped solver.\n\n !!! tip\n\n Many solvers already provided error estimates, making `HalfSolver` primarily\n useful when using a solver that doesn't provide error estimates -- e.g.\n [`diffrax.Euler`][] -- in particular this is common when solving SDEs.\n \"\"\"\n\n @property\n def term_structure(self):\n return self.solver.term_structure\n\n @property\n def interpolation_cls(self):\n return self.solver.interpolation_cls\n\n def order(self, terms: PyTree[AbstractTerm]) -> Optional[int]:\n return self.solver.order(terms)\n\n def strong_order(self, terms: PyTree[AbstractTerm]) -> Optional[Scalar]:\n return self.solver.strong_order(terms)\n\n def error_order(self, terms: PyTree[AbstractTerm]) -> Optional[Scalar]:\n if is_sde(terms):\n order = self.strong_order(terms)\n if order is not None:\n order = order + 0.5\n else:\n order = self.order(terms)\n if order is not None:\n order = order + 1\n return order\n\n def init(\n self,\n terms: PyTree[AbstractTerm],\n t0: Scalar,\n t1: Scalar,\n y0: PyTree,\n args: PyTree,\n ):\n return self.solver.init(terms, t0, t1, y0, args)\n\n def step(\n self,\n terms: PyTree[AbstractTerm],\n t0: Scalar,\n t1: Scalar,\n y0: PyTree,\n args: PyTree,\n solver_state: _SolverState,\n made_jump: Bool,\n ) -> Tuple[PyTree, Optional[PyTree], DenseInfo, _SolverState, RESULTS]:\n\n original_solver_state = solver_state\n thalf = t0 + 0.5 * (t1 - t0)\n\n yhalf, _, _, solver_state, result1 = self.solver.step(\n terms, t0, thalf, y0, args, solver_state, made_jump\n )\n y1, _, _, solver_state, result2 = self.solver.step(\n terms, thalf, t1, yhalf, args, solver_state, made_jump=False\n )\n\n # TODO: use dense_info from the pair of half-steps instead\n y1_alt, _, dense_info, _, result3 = self.solver.step(\n terms, t0, t1, y0, args, original_solver_state, made_jump\n )\n\n y_error = jnp.abs(y1 - y1_alt)\n result = jnp.maximum(result1, jnp.maximum(result2, result3))\n\n return y1, y_error, dense_info, solver_state, result\n\n def func_for_init(\n self, terms: PyTree[AbstractTerm], t0: Scalar, y0: PyTree, args: PyTree\n ):\n return self.solver.func_for_init(terms, t0, y0, args)\n\n\nHalfSolver.__init__.__doc__ = \"\"\"**Arguments:**\n\n- `solver`: The solver to wrap.\n\"\"\"\n", "meta": {"hexsha": "8073c600b8bc4ad686babb67130ef316ce95aea7", "size": 9661, "ext": "py", "lang": "Python", "max_stars_repo_path": "diffrax/solver/base.py", "max_stars_repo_name": "FedericoV/diffrax", "max_stars_repo_head_hexsha": "98b010242394491fea832e77dc94f456b48495fa", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "diffrax/solver/base.py", "max_issues_repo_name": "FedericoV/diffrax", "max_issues_repo_head_hexsha": "98b010242394491fea832e77dc94f456b48495fa", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "diffrax/solver/base.py", "max_forks_repo_name": "FedericoV/diffrax", "max_forks_repo_head_hexsha": "98b010242394491fea832e77dc94f456b48495fa", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.2588652482, "max_line_length": 87, "alphanum_fraction": 0.6484835938, "include": true, "reason": "import jax", "num_tokens": 2302, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5660185205547239, "lm_q2_score": 0.3415824860330003, "lm_q1q2_score": 0.19334201339180346}} {"text": "\"\"\"Calculates the Frechet Inception Distance (FID) to evalulate GANs\n\nThe FID metric calculates the distance between two distributions of images.\nTypically, we have summary statistics (mean & covariance matrix) of one\nof these distributions, while the 2nd distribution is given by a GAN.\n\nWhen run as a stand-alone program, it compares the distribution of\nimages that are stored as PNG/JPEG at a specified location with a\ndistribution given by summary statistics (in pickle format).\n\nThe FID is calculated by assuming that X_1 and X_2 are the activations of\nthe pool_3 layer of the inception net for generated samples and real world\nsamples respectively.\n\nSee --help to see further details.\n\nCode apapted from https://github.com/bioinf-jku/TTUR to use PyTorch instead\nof Tensorflow\n\nCopyright 2018 Institute of Bioinformatics, JKU Linz\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n\"\"\"\n\nimport numpy as np\nimport torch\nfrom scipy import linalg\nfrom torch.nn.functional import adaptive_avg_pool2d\n\nfrom models.inception import InceptionV3\n\n\nclass FIDScoreCumulative:\n def __init__(self, dims=2048, device='cpu'):\n \"\"\"Init FIDScore\n\n Params:\n -- dims : Dimensionality of features returned by Inception\n -- device : Device to run calculations\n \"\"\"\n self.dims = dims\n self.device = device\n\n block_idx = InceptionV3.BLOCK_INDEX_BY_DIM[self.dims]\n self.model = InceptionV3([block_idx]).to(self.device)\n self.model.eval()\n\n self.sessions = {}\n\n class Session:\n def __init__(self, data_len, dims):\n self.data_len = data_len\n self.dims = dims\n self.reset_activations()\n\n def reset_activations(self):\n self.pred_arr = np.empty((self.data_len, self.dims))\n self.start_idx = 0\n\n def add_activation(self, pred):\n self.pred_arr[self.start_idx:self.start_idx + pred.shape[0]] = pred\n self.start_idx = self.start_idx + pred.shape[0]\n\n def add_session(self, id, data_len):\n self.sessions[id] = self.Session(data_len, self.dims)\n\n def remove_session(self, id):\n del self.sessions[id]\n\n def reset_activations(self, id):\n self.sessions[id].reset_activations()\n\n def add_activation(self, id, batch, inf_model=None):\n \"\"\"Calculates the activations of the pool_3 layer for all images.\n\n Params:\n -- dataloader : Dataloader containing images or inputs to inf_model\n -- inf_model : Model in which to input the dataset. Use dataset directly\n if inf_model is None.\n\n Returns:\n -- A numpy array of dimension (num images, dims) that contains the\n activations of the given tensor when feeding inception with the\n query tensor.\n \"\"\"\n\n batch = batch.to(self.device)\n pred = self.calculate_activation(batch, inf_model)\n self.sessions[id].add_activation(pred)\n\n def calculate_activation(self, batch, inf_model=None):\n # Use output of inf_model instead of batch if an inf_model is given.\n with torch.no_grad():\n if inf_model is not None:\n batch = inf_model(batch)\n pred = self.model(batch)[0]\n\n # If model output is not scalar, apply global spatial average pooling.\n # This happens if you choose a dimensionality not equal 2048.\n if pred.size(2) != 1 or pred.size(3) != 1:\n pred = adaptive_avg_pool2d(pred, output_size=(1, 1))\n\n pred = pred.squeeze(3).squeeze(2).cpu().numpy()\n\n return pred\n\n def calculate_activation_statistics(self, id):\n \"\"\"Calculation of the statistics used by the FID.\n Params:\n -- dataloader : Dataloader containing images or inputs to inf_model\n -- inf_model : Model in which to input the dataset. Use dataset directly\n if inf_model is None.\n\n Returns:\n -- mu : The mean over samples of the activations of the pool_3 layer of\n the inception model.\n -- sigma : The covariance matrix of the activations of the pool_3 layer of\n the inception model.\n \"\"\"\n mu = np.mean(self.sessions[id].pred_arr, axis=0)\n sigma = np.cov(self.sessions[id].pred_arr, rowvar=False)\n return mu, sigma\n\n def calculate_frechet_distance(self, mu1, sigma1, mu2, sigma2, eps=1e-6):\n \"\"\"Numpy implementation of the Frechet Distance.\n The Frechet distance between two multivariate Gaussians X_1 ~ N(mu_1, C_1)\n and X_2 ~ N(mu_2, C_2) is\n d^2 = ||mu_1 - mu_2||^2 + Tr(C_1 + C_2 - 2*sqrt(C_1*C_2)).\n\n Stable version by Dougal J. Sutherland.\n\n Params:\n -- mu1 : Numpy array containing the activations of a layer of the\n inception net (like returned by the function 'get_predictions')\n for generated samples.\n -- mu2 : The sample mean over activations, precalculated on an\n representative data set.\n -- sigma1: The covariance matrix over activations for generated samples.\n -- sigma2: The covariance matrix over activations, precalculated on an\n representative data set.\n\n Returns:\n -- : The Frechet Distance.\n \"\"\"\n\n mu1 = np.atleast_1d(mu1)\n mu2 = np.atleast_1d(mu2)\n\n sigma1 = np.atleast_2d(sigma1)\n sigma2 = np.atleast_2d(sigma2)\n\n assert mu1.shape == mu2.shape, \\\n 'Training and test mean vectors have different lengths'\n assert sigma1.shape == sigma2.shape, \\\n 'Training and test covariances have different dimensions'\n\n diff = mu1 - mu2\n\n # Product might be almost singular\n covmean, _ = linalg.sqrtm(sigma1.dot(sigma2), disp=False)\n if not np.isfinite(covmean).all():\n msg = ('fid calculation produces singular product; '\n 'adding %s to diagonal of cov estimates') % eps\n print(msg)\n offset = np.eye(sigma1.shape[0]) * eps\n covmean = linalg.sqrtm((sigma1 + offset).dot(sigma2 + offset))\n\n # Numerical error might give slight imaginary component\n if np.iscomplexobj(covmean):\n if not np.allclose(np.diagonal(covmean).imag, 0, atol=1e-3):\n m = np.max(np.abs(covmean.imag))\n raise ValueError('Imaginary component {}'.format(m))\n covmean = covmean.real\n\n tr_covmean = np.trace(covmean)\n\n return (diff.dot(diff) + np.trace(sigma1) +\n np.trace(sigma2) - 2 * tr_covmean)\n\n\n", "meta": {"hexsha": "6d007afaacab801ae5a21415ce6fcb3dc7257f90", "size": 7123, "ext": "py", "lang": "Python", "max_stars_repo_path": "utils/metrics/fid_score_cumulative.py", "max_stars_repo_name": "johnpeterflynn/surface-texture-inpainting-net", "max_stars_repo_head_hexsha": "b2de05eaa47c9bcca53b9aee12b6012ac2c05156", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "utils/metrics/fid_score_cumulative.py", "max_issues_repo_name": "johnpeterflynn/surface-texture-inpainting-net", "max_issues_repo_head_hexsha": "b2de05eaa47c9bcca53b9aee12b6012ac2c05156", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "utils/metrics/fid_score_cumulative.py", "max_forks_repo_name": "johnpeterflynn/surface-texture-inpainting-net", "max_forks_repo_head_hexsha": "b2de05eaa47c9bcca53b9aee12b6012ac2c05156", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.2931937173, "max_line_length": 82, "alphanum_fraction": 0.644812579, "include": true, "reason": "import numpy,from scipy", "num_tokens": 1633, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5544704649604273, "lm_q2_score": 0.34864514886966624, "lm_q1q2_score": 0.19331343779996124}} {"text": "# -.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.\n#\n# File Name : to_tardis_mapper.py\n#\n# Purpose : Generate Tardis input from generic explosion models\n#\n# Creation Date : 29-02-2016\n#\n# Last Modified : Fri 04 Mar 2016 15:23:22 CET\n#\n# Created By : unoebauer\n#\n# _._._._._._._._._._._._._._._._._._._._._.\n\"\"\"A simple tool to map the output of SN explosion calculations or any ejecta\nmodel into Tardis, using its capability to work with specific density and\nabundance files.\n\"\"\"\nimport numpy as np\nimport logging\nimport astropy.units as units\nfrom pyne import nucname, material\n\nlogger = logging.getLogger(__name__)\n\ntry:\n material.Material().decay\nexcept AttributeError:\n logger.critical(\"PyNe module outdated: version >= 0.5 is required\")\n raise ImportError(\"No recent PyNe module found\")\n\n# maximum atomic number\nzmax = 30\n\n\nclass original_model(object):\n \"\"\"Simple model interface. It and its derived classes should provide a\n common interface for all possible explosion model formats.\n\n This class only requires a minimal set of information, from which all the\n remaining quantities are constructed (under the assumption of homologous\n expansion). For each radial shell, the inner and the outer shell radius\n have to be provided, in addition with the shell density, the mass fractions\n of all stable elements and of all radioactive elements. The final\n information to be passed is the time since explosion.\n\n Velocity and shell masses are generated from these input data, by assuming\n perfect homologous expansion, (i.e. $u = r/t$) and spherical symmetry.\n\n Notes\n -----\n\n The to_tardis_mapper tool expects that stable_abundances + radio_abundance\n = 1. In other words, the radioactive isotopes should not be contained in\n the mass fractions stores in stable_abundances.\n\n Parameters\n ----------\n \"\"\"\n def __init__(self):\n\n self._ro = None\n self._ri = None\n self._t = None\n self._rho = None\n\n self._nzones = None\n self._vo = None\n self._vi = None\n self._dm = None\n self._mr = None\n\n self._stable_abundances = None\n self._radio_abundances = None\n\n def _reset_cached_variables(self):\n \"\"\"Resets the cached derived quantities. This routine should be called\n every time one of the principle inputs (such as density) is reset.\n \"\"\"\n\n self._nzones = None\n self._vo = None\n self._vi = None\n self._dm = None\n self._mr = None\n\n @property\n def ro(self):\n \"\"\"outer shell edge for each radial cell\"\"\"\n if self._ro is None:\n raise ValueError(\n \"You have to read-in or assign the outer cell radii first\")\n return self._ro\n\n @ro.setter\n def ro(self, val):\n try:\n val.to(\"cm\")\n except (AttributeError, units.UnitConversionError):\n raise ValueError(\n \"ro must be a valid length astropy.units.Quantity\")\n self._ro = val\n self._reset_cached_variables()\n\n @property\n def ri(self):\n \"\"\"inner shell edge for each radial cell\"\"\"\n if self._ri is None:\n raise ValueError(\n \"You have to read-in or assign the inner cell radii first\")\n return self._ri\n\n @ri.setter\n def ri(self, val):\n try:\n val.to(\"cm\")\n except (AttributeError, units.UnitConversionError):\n raise ValueError(\n \"ri must be a valid length astropy.units.Quantity\")\n self._ri = val\n self._reset_cached_variables()\n\n @property\n def rho(self):\n \"\"\"cell density\"\"\"\n if self._rho is None:\n raise ValueError(\n \"You have to read-in or assign the cell density first\")\n return self._rho\n\n @rho.setter\n def rho(self, val):\n try:\n val.to(\"g/cm^3\")\n except (AttributeError, units.UnitConversionError):\n raise ValueError(\n \"rho must be a valid mass density astropy.units.Quantity\")\n self._rho = val\n self._reset_cached_variables()\n\n @property\n def t(self):\n \"\"\"time since explosion\"\"\"\n if self._t is None:\n raise ValueError(\n \"You have to read-in or assign the time since explosion first\")\n return self._t\n\n @t.setter\n def t(self, val):\n try:\n val.to(\"s\")\n except (AttributeError, units.UnitConversionError):\n raise ValueError(\n \"t must be a valid time astropy.units.Quantity\")\n self._t = val\n self._reset_cached_variables()\n\n @property\n def nzones(self):\n \"\"\"number of shells in the model\"\"\"\n if self._nzones is None:\n self._nzones = len(self.ro)\n\n return self._nzones\n\n @property\n def vo(self):\n \"\"\"fluid velocity at outer cell edge\"\"\"\n if self._vo is None:\n self._vo = self.ro / self.t\n return self._vo\n\n @property\n def vi(self):\n \"\"\"fluid velocity at inner cell edge\"\"\"\n if self._vi is None:\n self._vi = self.ri / self.t\n return self._vi\n\n @property\n def dm(self):\n \"\"\"mass contained within a cell\"\"\"\n if self._dm is None:\n self._dm = 4. * np.pi / 3. * (self.ro**3 - self.ri**3) * self.rho\n return self._dm\n\n @property\n def mr(self):\n \"\"\"mass enclosed by shells outer radius\"\"\"\n if self._mr is None:\n _mr = np.zeros(self.nzones) * self.dm.unit\n _mr[0] = self.dm[0]\n for i in xrange(1, self.nzones):\n _mr[i] = _mr[i-1] + self.dm[i]\n self._mr = _mr\n return self._mr\n\n @property\n def stable_abundances(self):\n \"\"\"a dictionary holding the mass fractions of all stable elements up to\n Z = zmax. The proton number serves as dictionary key\n \"\"\"\n if self._stable_abundances is None:\n tmp = {}\n\n for i in xrange(zmax):\n z = i+1\n tmp[z] = np.zeros(self.nzones)\n self._stable_abundances = tmp\n\n return self._stable_abundances\n\n @property\n def radio_abundances(self):\n \"\"\"a dictionary holding the mass fractions of all radioactive isotopes\n at time = t. Strings such as 'Ni56', i.e. containing the Element symbol\n and the mass number, serve as dictionary keys\n \"\"\"\n if self._radio_abundances is None:\n self._radio_abundances = {}\n return self._radio_abundances\n\n @property\n def complete(self):\n \"\"\"A simple flag determining whether all quantities necessary for the\n mapping process have been set/read-in\"\"\"\n\n _complete = False\n try:\n self.t\n self.rho\n self.ro\n self.ri\n _complete = True\n except ValueError:\n pass\n\n try:\n X = np.array(\n [self.stable_abundances[z] for z in xrange(1, zmax+1)])\n _complete = _complete * (X > 0).any()\n except ValueError:\n _complete = False\n\n return _complete\n\n def read_density(self, fname):\n \"\"\"A prototype for reading the radius and density information from\n file\"\"\"\n\n pass\n\n def read_abundances(self, fname):\n \"\"\"A prototype for reading the stable and radioactive elemental\n abundances from file\"\"\"\n\n pass\n\n\nclass w7_model(original_model):\n \"\"\"A simple interface class for the W7 model.\n\n Notes\n -----\n The original W7 model has been presented by [1]_. This reader is designed\n particular version calculated by [2]_.\n\n References\n ----------\n\n .. [1] Nomoto et al. \"Accreting white dwarf models of Type I supernovae.\n III - Carbon deflagration supernovae\" ApJ, 1984, 286, 644-658\n .. [2] Iwamoto et al. \"Nucleosynthesis in Chandrasekhar Mass Models for\n Type IA Supernovae and Constraints on Progenitor Systems and\n Burning-Front Propagation\" ApJS, 1999, 125, 439-462\n \"\"\"\n def __init__(self):\n super(w7_model, self).__init__()\n\n def read_density(self, fname):\n \"\"\"Read the radius and density of the W7 model from file.\n\n Parameters\n ----------\n fname : str\n Name of the hydrodynamics file of the W7 model\n \"\"\"\n\n f = open(fname, \"r\")\n\n # read header\n buffer = f.readline().rsplit()\n self.t = float(buffer[2]) * units.s\n buffer = f.readline()\n\n # read main data block\n data = np.loadtxt(f)\n f.close()\n\n self.ro = data[:, 2] * units.cm\n self.ri = np.insert(self.ro, 0, 0 * units.cm)[:-1]\n self.rho = data[:, 3] * units.g / units.cm**3\n\n def read_abundances(self, fname):\n \"\"\"Read elemental abundances of the W7 model from file.\n\n Parameters\n ----------\n fname : str\n Name of the nucleosynthesis file of the W7 model\n \"\"\"\n\n f = open(fname, \"r\")\n data = np.loadtxt(f, skiprows=1)\n f.close()\n\n # the file contains abundances for elements from Z=1 to Z=32 (Ge).\n for i in xrange(np.max([zmax, 32])):\n self.stable_abundances[i+1] = data[:, i]\n\n # the last three columns contain the mass fractions of the radioactive\n # isotopes nickel-56, cobalt-56, nickel-57\n self.radio_abundances[\"ni56\"] = data[:, 32]\n self.radio_abundances[\"co56\"] = data[:, 33]\n self.radio_abundances[\"ni57\"] = data[:, 34]\n\n\nclass to_tardis_mapper(object):\n \"\"\"A simple mapper object, transforming explosion models, stored in the\n original_model interface classes, into Tardis specific structure input\n files\n\n Parameters\n ----------\n orig_model : original_model or derived classes\n interface object holding the essential data of the original explosion\n model\n \"\"\"\n def __init__(self, orig_model):\n\n if not orig_model.complete:\n logger.critical(\"Not all necessary information have been\"\n \" set/read-in in the original model\")\n raise ValueError(\"Check original_model for completeness\")\n self.orig = orig_model\n\n def remap(self, v, t, decay=True, write_density=True,\n density_fname=\"tardis_densities.dat\", write_abundances=True,\n abundance_fname=\"tardis_abundances.dat\", be_fix=True, be_to_z=6):\n \"\"\"Perform the remapping of the original model onto a specified Tardis\n velocity grid. A homologous expansion from the time of the model to the\n time since explosion used in the Tardis calculation is automatically\n performed. Optionally, the decay of the radioactive isotopes can also\n be performed. The remapped model can then be written to Tardis files.\n\n Notes\n -----\n When supplying specific structure files to Tardis, it expects to find\n also the density and composition of the photosphere. Thus, if the\n ejecta above the photosphere is supposed to be described by 20 shells,\n the data files have to contain 21 rows. The specific density and\n composition of the photosphere is not important since this information\n is not used within Tardis - the photospheric velocity (i.e. the\n velocity of the first row) is used!\n\n Parameters\n ----------\n v : array-like astropy.units.Quantity\n Tardis velocity grid, interpreted as the velocity at the outer\n shell edges. Mind the photospheric shell!\n t : scalar astropy.units.Quantity\n start time (time since explosion) of the Tardis calculation\n decay : bool\n perform decay of the radioactive isotopes (default True)\n write_density : bool\n write remapped density to a Tardis specific structure file (default\n True)\n density_fname : str\n name of the Tardis specific structure file (default\n 'tardis_densities.dat')\n write_abundances : bool\n write remapped abundances to a Tardis specific abundance file\n (default True)\n abundance_fname : str\n name of the Tardis specific structure file (default\n 'tardis_abundances.dat')\n be_fix : bool\n perform the Beryllium fix (see #438), i.e. set Be to zero and add\n its abundance to a different element (default True)\n be_to_z : int\n proton number of the destination element for the Be fix (default 6,\n i.e. carbon)\n \"\"\"\n\n self._remap_density(v, t)\n self._remap_abundances()\n\n if decay:\n self._decay_abundances()\n else:\n self._copy_radio_abundances()\n if be_fix:\n self._be_fix(to_z=be_to_z)\n if write_density:\n self._write_tardis_density_file(fname=density_fname)\n if write_abundances:\n self._write_tardis_abundance_file(fname=abundance_fname)\n\n def _remap_density(self, v, t):\n \"\"\"Remap density of the original_model onto the provided velocity\n grid and perform a homologous expansion of the density until the\n defined start time of Tardis\n\n Notes\n -----\n\n For the remapping, we interpolate mr in the v**3 space (corresponds to\n volume space).\n\n Parameters\n ----------\n v : array-like astropy.units.Quantity\n Tardis velocity grid, interpreted as the velocity at the outer\n shell edges. Mind the photospheric shell!\n t : scalar astropy.units.Quantity\n start time (time since explosion) of the Tardis calculation\n \"\"\"\n\n self.t = t\n self.N_interp = len(v) - 1\n self.v_interp_r = v[1:].to(\"cm/s\")\n self.v_interp_l = v[:-1].to(\"cm/s\")\n\n V_interp = 4. / 3. * np.pi * ((self.v_interp_r * t).to(\"cm\")**3 -\n (self.v_interp_l * t).to(\"cm\")**3)\n\n vrorig = self.orig.vo.to(\"cm/s\")\n mrorig = self.orig.mr.to(\"solMass\")\n\n mr_interp = np.interp(\n np.insert(self.v_interp_r, 0, self.v_interp_l[0])**3,\n np.append(0 * vrorig.unit, vrorig)**3,\n np.append(0 * mrorig.unit, mrorig)) * mrorig.unit\n\n self.dm_interp = (mr_interp[1:] - mr_interp[:-1])\n self.rho_interp = (self.dm_interp / V_interp).to(\"g/cm^3\")\n\n def _remap_abundances(self):\n \"\"\"Remap abundances for the original model onto the grid defined in\n _remap_density. This routine has be called after _remap_density is\n performed.\n\n Notes\n -----\n Must be called after _remap_density.\n\n Raises\n ------\n AttributeError if called before _remap_density\n \"\"\"\n try:\n self.v_interp_l\n self.v_interp_r\n except AttributeError:\n logger.critical(\"Density must be remapped before abundances are\"\n \" addressed\")\n raise AttributeError(\"no v_interp_r; call _remap_density first\")\n\n self.abundances_interp = {}\n self.radio_abundances_interp = {}\n\n def remap_species(Xorig):\n \"\"\"helper routine to remap one specific elemental species onto the\n new velocity grid\n\n Parameters\n ----------\n Xorig : numpy.ndarray\n original mass fraction of the original model\n\n Returns\n -------\n X_interp : numpy.ndarray\n remapped mass fractions, corresponding to the Tardis model\n \"\"\"\n\n vrorig = self.orig.vo.to(\"cm/s\")\n Xrorig = np.zeros(len(Xorig)) * self.orig.dm.unit\n\n Xrorig[0] = self.orig.dm[0] * Xorig[0]\n for i in xrange(1, self.orig.nzones):\n Xrorig[i] += Xrorig[i-1] + self.orig.dm[i] * Xorig[i]\n\n X_interp = np.interp(\n np.insert(self.v_interp_r, 0, self.v_interp_l[0])**3,\n np.append(0 * vrorig.unit, vrorig)**3,\n np.append(0 * Xrorig.unit, Xrorig)) * Xrorig.unit\n\n X_interp = X_interp[1:] - X_interp[:-1]\n\n return (X_interp / self.dm_interp).to(\"\").value\n\n # remap stable elements\n for z in xrange(1, zmax+1):\n\n Xorig = self.orig.stable_abundances[z]\n X_interp = remap_species(Xorig)\n\n self.abundances_interp[z] = X_interp\n\n # remap radioactive isotopes\n for ident in self.orig.radio_abundances.keys():\n\n Xorig = self.orig.radio_abundances[ident]\n\n X_interp = remap_species(Xorig)\n\n self.radio_abundances_interp[ident] = X_interp\n\n def _copy_radio_abundances(self):\n \"\"\"Copies the radioactive isotopes onto the corresponding stable\n elements. This routine is intended for uses of the mapper during which\n the decay is neglected\n\n Notes\n -----\n Must be called after _remap_abundances.\n\n Raises\n ------\n AttributeError if called before _remap_abundances\n \"\"\"\n try:\n self.radio_abundances_interp\n except AttributeError:\n logger.critical(\"Abundances must be remapped before radioactive:\"\n \" isotopes are copied onto the stable elements\")\n raise AttributeError(\"no radio_abundances_interp; call\"\n \" _remap_abundances first\")\n\n for ident in self.radio_abundances_interp.keys():\n elemid = nucname.id(ident)\n z = nucname.znum(elemid)\n self.abundances_interp[z] = \\\n self.abundances_interp[z] + self.radio_abundances_interp[ident]\n\n def _decay_abundances(self):\n \"\"\"Determines the decay of all radioactive isotopes. Afterwards their\n mass fractions are added to the stable elements.\n\n Notes\n -----\n Must be called after _remap_abundances.\n\n Raises\n ------\n AttributeError if called before _remap_abundances\n \"\"\"\n try:\n self.radio_abundances_interp\n except AttributeError:\n logger.critical(\"Abundances must be remapped before decay is\"\n \" handled\")\n raise AttributeError(\"no radio_abundances_interp; call \"\n \"_remap_abundances first\")\n\n for i in xrange(self.N_interp):\n comp = {}\n mass = 0\n for ident in self.radio_abundances_interp.keys():\n Xi = self.radio_abundances_interp[ident][i]\n mass += Xi\n comp[nucname.id(ident)] = Xi\n inp = material.Material(comp, mass=mass)\n res = inp.decay(\n (self.t - self.orig.t).to(\"s\").value).mult_by_mass()\n\n for item in res.items():\n z = nucname.znum(item[0])\n self.abundances_interp[z][i] = \\\n self.abundances_interp[z][i] + item[1]\n\n def _be_fix(self, to_z=6):\n \"\"\"Set Beryllium abundance to zero and add its mass fraction to another\n (specified) element. This is done to avoid issue #438.\n\n Notes\n -----\n Must be called after _remap_abundances.\n\n Parameters\n ---------\n to_z : int\n proton number of the destination element for the Be fix (default 6,\n i.e. carbon)\n\n Raises\n ------\n AttributeError if called before _remap_abundances\n \"\"\"\n try:\n self.abundances_interp\n except AttributeError:\n logger.critical(\"Abundances must be remapped before the Be fix can\"\n \" be applied\")\n raise AttributeError(\"no abundances_interp; call\"\n \" _remap_abundances first\")\n\n logger.info(\"Total relative Be mass in model: {:e}\\n\".format(\n (self.abundances_interp[4] * self.dm_interp).sum() /\n self.dm_interp.sum()))\n\n self.abundances_interp[to_z] = (\n self.abundances_interp[to_z] + self.abundances_interp[4])\n self.abundances_interp[4] = np.zeros(self.N_interp)\n\n def _write_tardis_abundance_file(self, fname=\"tardis_abundances.dat\"):\n \"\"\"Write specific density file for Tardis\n\n Parameters\n ----------\n fname : str\n name of the Tardis specific structure file (default\n 'tardis_abundances.dat')\n \"\"\"\n f = open(fname, \"w\")\n f.write(\"# index Z=1 - Z={:d}\\n\".format(zmax))\n X = np.zeros((zmax+1, self.N_interp+1))\n\n X[0, :] = np.arange(self.N_interp+1)\n X[1:, 1:] = np.array(\n [self.abundances_interp[z] for z in xrange(1, zmax+1)])\n X[1:, 0] = X[1:, 1]\n\n np.savetxt(f, X.T, fmt=[\"% 4d\"] + [\"%.7e\" for i in xrange(1, zmax+1)])\n f.close()\n\n def _write_tardis_density_file(self, fname=\"tardis_densities.dat\"):\n \"\"\"Write specific abundance file for Tardis\n\n Parameters\n ----------\n fname : str\n name of the Tardis specific structure file (default\n 'tardis_densities.dat')\n \"\"\"\n f = open(fname, \"w\")\n\n f.write(\"{:f} {:s}\\n\".format(self.t.to(\"day\").value, \"day\"))\n f.write(\"# index velocity (km/s) density (g/cm^3)\\n\")\n X = np.array([np.arange(self.N_interp+1),\n np.insert(self.v_interp_r.to(\"km/s\"), 0,\n self.v_interp_l.to(\"km/s\")[0]).value,\n np.insert(self.rho_interp.to(\"g/cm^3\"), 0,\n self.rho_interp.to(\"g/cm^3\")[0]).value]).T\n np.savetxt(f, X, fmt=[\"% 4d\", \"% 9.3f\", \"%.7e\"])\n\n f.close()\n", "meta": {"hexsha": "c8ca58111e1d4ce6862cccfc62784c39238dd897", "size": 21822, "ext": "py", "lang": "Python", "max_stars_repo_path": "to_tardis_mapper.py", "max_stars_repo_name": "jamesgillanders/tardisanalysis", "max_stars_repo_head_hexsha": "b5c27784d3d1db224c629a9d8418a0d126d2f1c8", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2015-08-25T15:00:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-24T16:53:30.000Z", "max_issues_repo_path": "to_tardis_mapper.py", "max_issues_repo_name": "jamesgillanders/tardisanalysis", "max_issues_repo_head_hexsha": "b5c27784d3d1db224c629a9d8418a0d126d2f1c8", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 26, "max_issues_repo_issues_event_min_datetime": "2015-08-25T10:32:48.000Z", "max_issues_repo_issues_event_max_datetime": "2021-04-26T10:59:11.000Z", "max_forks_repo_path": "to_tardis_mapper.py", "max_forks_repo_name": "jamesgillanders/tardisanalysis", "max_forks_repo_head_hexsha": "b5c27784d3d1db224c629a9d8418a0d126d2f1c8", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 15, "max_forks_repo_forks_event_min_datetime": "2015-08-25T10:19:54.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-22T12:10:42.000Z", "avg_line_length": 33.1138088012, "max_line_length": 79, "alphanum_fraction": 0.5831271194, "include": true, "reason": "import numpy,import astropy", "num_tokens": 5122, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5544704796847396, "lm_q2_score": 0.3486451353339458, "lm_q1q2_score": 0.1933134354283639}} {"text": "\"\"\"\nComputes the Heat of Formation at 0 K for a given species\n\"\"\"\n\nimport os\nimport csv\nimport numpy as np\nfrom qcelemental import constants as qcc\nimport autoparse.pattern as app\nimport autoparse.find as apf\nimport automol.inchi\nimport automol.graph\nfrom . import util\n\n# Conversion factors\nKJ2KCAL = qcc.conversion_factor('kJ/mol', 'kcal/mol')\nEH2KCAL = qcc.conversion_factor('hartree', 'kcal/mol')\n\n# Path the database files (stored in the thermo src directory)\nSRC_PATH = os.path.dirname(os.path.realpath(__file__))\n\n\ndef get_hform_298k_thermp(output_string):\n \"\"\"\n Obtains deltaHf from thermp output\n \"\"\"\n\n # Line pattern containing the DeltaHf value at 298 K\n dhf298_pattern = ('h298 final' +\n app.one_or_more(app.SPACE) +\n app.capturing(app.FLOAT))\n dhf298 = float(apf.last_capture(dhf298_pattern, output_string))\n\n return dhf298\n\n\ndef calc_hform_0k(hzero_mol, hzero_basis, basis, coeff, ref_set):\n \"\"\" calculates the heat-of-formation at 0 K\n \"\"\"\n\n # Calculate the heat of formation\n dhzero = hzero_mol * EH2KCAL\n for i, spc in enumerate(basis):\n h_basis = get_ref_h(spc, ref_set, 0)\n if h_basis is None:\n h_basis = 0.0\n dhzero += coeff[i] * h_basis * KJ2KCAL\n dhzero -= coeff[i] * hzero_basis[i] * EH2KCAL\n\n return dhzero\n\n\ndef get_ref_h(species, ref, temp):\n \"\"\" gets a reference value\n \"\"\"\n\n # Set path and name to thermo database file\n thermodb_name = 'thermodb_{}K.csv'.format(str(int(temp)))\n thermodb_file = os.path.join(SRC_PATH, thermodb_name)\n\n # Find the energy value for the given species and enery type\n h_species = None\n with open(thermodb_file, 'r') as db_file:\n reader = csv.DictReader(db_file)\n for row in reader:\n if row['inchi'] == species:\n val = row[ref]\n if val == '':\n val = None\n h_species = float(val)\n\n return h_species\n\n\ndef select_basis(atom_dct, att=0):\n \"\"\"\n Given a list of atoms, generates a list of molecules\n that is best suited to serve as a basis for those atoms\n\n :param atomlist: list of atoms\n :type atomlist: list\n :param att: ???\n :type att: ???\n\n OUPUT:\n basis - recommended basis as a list of stoichiometries\n \"\"\"\n\n # Determine number of basis species required\n nbasis = len(atom_dct)\n\n # Get a list of all the atom types in the molecule\n atoms = list(atom_dct.keys())\n\n # Create list of inchi keys corresponding to basis species\n basis = []\n # H2\n basis.append('InChI=1S/H2/h1H')\n # NH3\n if 'N' in atoms:\n basis.append('InChI=1S/H3N/h1H3')\n # CH4\n if 'C' in atoms:\n basis.append('InChI=1S/CH4/h1H4')\n # H2O\n if 'O' in atoms:\n basis.append('InChI=1S/H2O/h1H2')\n # SO2\n if 'S' in atoms:\n basis.append('InChI=1S/O2S/c1-3-2')\n if not 'O' in atoms:\n basis.append('InChI=1S/H2O/h1H2')\n\n return basis\n\n\ndef get_reduced_basis(basis_ich, species_formula):\n \"\"\"\n Form a matrix for a given basis and atomlist\n INPUT:\n input_basis - ich strings for set of reference molecules\n atomlist - list of atoms (all atoms that appear\n in basis should be in atomlist)\n OUTPUT:\n mat - matrix (length of basis by length of atomlist)\n (square if done right)\n \"\"\"\n\n # Get the basis formulae list\n basis_formulae = [util.inchi_formula(spc) for spc in basis_ich]\n\n reduced_basis = []\n for i, basis_formula in enumerate(basis_formulae):\n basis_atom_dict = util.get_atom_counts_dict(basis_formula)\n flag = True\n for key, _ in basis_atom_dict.items():\n if key not in species_formula:\n flag = False\n\n if flag:\n reduced_basis.append(basis_ich[i])\n\n return reduced_basis\n\n\ndef calc_coefficients(basis, mol_atom_dict):\n \"\"\"\n Form a matrix for a given basis and atomlist\n INPUT:\n basis - basis of molecules\n atomlist - list of atoms (all atoms that appear\n in basis should be in atomlist)\n OUTPUT:\n mat - matrix (length of basis by length of atomlist)\n (square if done right)\n \"\"\"\n\n \n # Initialize an natoms x natoms matrix\n nbasis = len(basis)\n basis_mat = np.zeros((nbasis, nbasis))\n\n # Get the basis formulae list\n basis_formulae = [util.inchi_formula(spc) for spc in basis]\n #basis_atom_dict = [automol.geom.formula(automol.inchi.geom(spc) for spc in basis]\n for spc in basis_formulae:\n basis_atom_dict = util.get_atom_counts_dict(spc)\n for atom in basis_atom_dict:\n if not atom in mol_atom_dict:\n mol_atom_dict[atom] = 0\n # Set the elements of the matrix\n for i, spc in enumerate(basis_formulae):\n basis_atom_dict = util.get_atom_counts_dict(spc)\n basis_vals = []\n for key in mol_atom_dict.keys():\n if key in basis_atom_dict:\n basis_vals.append(basis_atom_dict[key])\n else:\n basis_vals.append(0)\n basis_mat[i] = basis_vals\n\n # Transpose\n basis_mat = basis_mat.T\n\n # Form stoich vector\n stoich_vec = np.zeros(len(mol_atom_dict))\n for i, key in enumerate(mol_atom_dict.keys()):\n stoich_vec[i] = mol_atom_dict[key]\n\n # Solve C = M^-1 S\n basis_mat = np.linalg.inv(basis_mat)\n coeff = np.dot(basis_mat, stoich_vec)\n\n return coeff\n\n\ndef stoich(ich):\n \"\"\"\n Finds the stoichiometry of a molecule\n INPUT:\n ich -- STR inchii\n OUTPUT:\n stoich -- dictionary with key = STR atomsymbol,\n val = INT number of atomsymbol in molecule\n \"\"\"\n\n stoich = {'H': 0}\n gra = automol.inchi.graph(ich)\n atms = automol.graph.atoms(gra)\n for atm in atms:\n stoich['H'] += atms[atm][1]\n if atms[atm][0] in stoich:\n stoich[atms[atm][0]] += 1\n else:\n stoich[atms[atm][0]] = 1\n return stoich\n\n\ndef cbhzed(ich):\n \"\"\"\n Fragments molecule so that each heavy-atom is a seperate fragment\n INPUT:\n ich -- STR inchii name for molecule\n OUTPUT\n frags -- DIC dictionary with keys as STR inchii name for fragments\n and value as INT their coefficient\n \"\"\"\n\n # Graphical info about molecule\n gra = automol.inchi.graph(ich)\n rad_atms = list(automol.graph.sing_res_dom_radical_atom_keys(gra))\n atm_vals = automol.graph.atom_element_valences(gra)\n atms = automol.graph.atoms(gra)\n\n # Determine CBHzed fragments\n frags = {}\n for atm in atm_vals:\n if atm in rad_atms:\n atm_vals[atm] -= 1\n atm_dic = {0: (atms[atm][0], int(atm_vals[atm]), None)}\n gra = (atm_dic, {})\n frag = automol.graph.inchi(gra)\n _add2dic(frags, frag)\n\n return _balance_frags(ich, frags)\n\n\ndef cbhone(ich):\n \"\"\"\n Fragments molecule in a way that conserves each heavy-atom/heavy-atom bond\n INPUT:\n ich -- STR inchii name for molecule\n OUTPUT\n frags -- DIC dictionary with keys as STR inchii name for fragments\n and value as INT their coefficient\n \"\"\"\n\n # Graphical info about molecule\n gra = automol.inchi.graph(ich)\n atms = automol.graph.atoms(gra)\n bnd_ords = automol.graph.one_resonance_dominant_bond_orders(gra)\n rad_atms = list(automol.graph.sing_res_dom_radical_atom_keys(gra))\n atm_vals = automol.graph.atom_element_valences(gra)\n adj_atms = automol.graph.atom_neighbor_keys(gra)\n\n # Determine CBHone fragments\n frags = {}\n for atm in atm_vals:\n for adj in list(adj_atms[atm]):\n if atm > adj:\n vali = atm_vals[atm]\n valj = atm_vals[adj]\n if atm in rad_atms:\n vali -= 1\n if adj in rad_atms:\n valj -= 1\n key = frozenset({atm, adj})\n bnd_ord = list(bnd_ords[key])[0]\n vali -= bnd_ord\n valj -= bnd_ord\n atm_dic = {0: (atms[atm][0], int(vali), None),\n 1: (atms[adj][0], int(valj), None)}\n bnd_dic = {frozenset({0, 1}): (1, None)}\n gra = (atm_dic, bnd_dic)\n frag = automol.graph.inchi(gra)\n _add2dic(frags, frag)\n frags = {k: v for k, v in frags.items() if v}\n\n # Balance\n balance_ = _balance(ich, frags)\n balance_ = {k: v for k, v in balance_.items() if v}\n\n if balance_:\n newfrags = {}\n zedfrags = cbhzed(ich)\n new = {}\n for frag in frags:\n newfrags[frag] = frags[frag]\n new = cbhzed(frag)\n for n in new:\n _add2dic(newfrags, n, - new[n] * frags[frag])\n if not frags:\n frags = cbhzed(ich)\n for frag in zedfrags:\n if frag in newfrags:\n _add2dic(newfrags, frag, zedfrags[frag])\n frags = newfrags\n frags = {k: v for k, v in frags.items() if v}\n balance_ = _balance(ich, frags)\n balance_ = {k: v for k, v in balance_.items() if v}\n\n if balance_:\n frags = _balance_frags(ich, frags)\n\n return frags\n\n\ndef cbhtwo(ich):\n \"\"\"\n Fragments molecule for each heavy-atom to stay bonded to its adjacent atoms\n INPUT:\n ich -- STR inchii name for molecule\n OUTPUT\n frags -- DIC dictionary with keys as STR inchii name for fragments and\n value as INT their coefficient\n \"\"\"\n\n # Graphical info about molecule\n gra = automol.inchi.graph(ich)\n atms = automol.graph.atoms(gra)\n bnd_ords = automol.graph.one_resonance_dominant_bond_orders(gra)\n rad_atms = list(automol.graph.sing_res_dom_radical_atom_keys(gra))\n atm_vals = automol.graph.atom_element_valences(gra)\n adj_atms = automol.graph.atom_neighbor_keys(gra)\n\n # Determine CBHtwo fragments\n frags = {}\n for atm in atms:\n vali = atm_vals[atm]\n if atm in rad_atms:\n vali -= 1\n # First loop over all atoms of this frag to get saturation of atomi\n for adj in list(adj_atms[atm]):\n key = frozenset({atm, adj})\n bnd_ord = list(bnd_ords[key])[0]\n vali -= bnd_ord\n atm_dic = {0: (atms[atm][0], int(vali), None)}\n bnd_dic = {}\n # Then start adding bonds to the bnddic and atomdic\n j = 0\n for adj in list(adj_atms[atm]):\n j += 1\n valj = atm_vals[adj]\n if adj in rad_atms:\n valj -= 1\n key = frozenset({atm, adj})\n bnd_ord = list(bnd_ords[key])[0]\n valj -= bnd_ord\n atm_dic[j] = (atms[adj][0], int(valj), None)\n bnd_dic[frozenset({0, j})] = (1, None)\n gra = (atm_dic, bnd_dic)\n frag = automol.graph.inchi(gra)\n _add2dic(frags, frag)\n\n frags = {k: v for k, v in frags.items() if v}\n\n # Balance\n balance_ = _balance(ich, frags)\n balance_ = {k: v for k, v in balance_.items() if v}\n if balance_:\n newfrags = {}\n onefrags = cbhone(ich)\n new = {}\n for frag in frags:\n newfrags[frag] = frags[frag]\n new = cbhone(frag)\n for n in new:\n _add2dic(newfrags, n, - new[n] * frags[frag])\n if not frags:\n frags = cbhone(ich)\n for frag in onefrags:\n if frag in newfrags:\n _add2dic(newfrags, frag, onefrags[frag])\n frags = newfrags\n frags = {k: v for k, v in frags.items() if v}\n\n balance_ = _balance(ich, frags)\n balance_ = {k: v for k, v in balance_.items() if v}\n if balance_:\n newfrags = {}\n zedfrags = cbhzed(ich)\n new = {}\n for frag in frags:\n newfrags[frag] = frags[frag]\n new = cbhzed(frag)\n for n in new:\n _add2dic(newfrags, n, - new[n] * frags[frag])\n if not frags:\n frags = cbhzed(ich)\n for frag in zedfrags:\n if frag in newfrags:\n _add2dic(newfrags, frag, zedfrags[frag])\n frags = newfrags\n frags = {k: v for k, v in frags.items() if v}\n\n balance_ = _balance(ich, frags)\n balance_ = {k: v for k, v in balance_.items() if v}\n if balance_:\n frags = _balance_frags(ich, frags)\n\n return frags\n\n\ndef get_basis(ich):\n formula = util.inchi_formula(ich)\n atm_dict = util.get_atom_counts_dict(formula)\n return select_basis(atm_dict)\n\n\ndef get_cbhzed(ich):\n return list(cbhzed(ich).keys())\n\n\ndef get_cbhone(ich):\n return list(cbhone(ich).keys())\n\n\ndef get_cbhtwo(ich):\n return list(cbhtwo(ich).keys())\n\n\ndef _add2dic(dic, key, val=1):\n if key in dic:\n dic[key] += val\n else:\n dic[key] = val\n\n\ndef _lhs_rhs(frags):\n rhs = {}\n lhs = {}\n for frag in frags:\n if frags[frag] > 0:\n rhs[frag] = frags[frag]\n elif frags[frag] < 0:\n lhs[frag] = - frags[frag]\n return lhs, rhs\n\n\ndef _print_lhs_rhs(ich, frags):\n lhs, rhs = _lhs_rhs(frags)\n lhsprint = automol.inchi.smiles(ich)\n rhsprint = ''\n for frag in rhs:\n if rhsprint:\n rhsprint += ' + {:.1f} {} '.format(\n rhs[frag], automol.inchi.smiles(frag))\n else:\n rhsprint = ' {:.1f} {} '.format(\n rhs[frag], automol.inchi.smiles(frag))\n for frag in lhs:\n lhsprint += ' + {:.1f} {} '.format(\n lhs[frag], automol.inchi.smiles(frag))\n return '{} --> {}'.format(lhsprint, rhsprint)\n\n\ndef _balance(ich, frags):\n stoichs = {}\n for frag in frags:\n _stoich = stoich(frag)\n for atm in _stoich:\n if atm in stoichs:\n stoichs[atm] += _stoich[atm] * frags[frag]\n else:\n stoichs[atm] = _stoich[atm] * frags[frag]\n balance_ = {}\n _stoich = stoich(ich)\n for atom in _stoich:\n if atom in stoichs:\n balance_[atom] = _stoich[atom] - stoichs[atom]\n else:\n balance_[atom] = _stoich[atom]\n balance_ = {x: y for x, y in balance_.items() if y != 0}\n return balance_\n\n\ndef _balance_frags(ich, frags):\n balance_ = _balance(ich, frags)\n methane = automol.smiles.inchi('C')\n water = automol.smiles.inchi('O')\n ammonm = automol.smiles.inchi('N')\n hydrgn = automol.smiles.inchi('[H][H]')\n if 'C' in balance_:\n _add2dic(frags, methane, balance_['C'])\n if 'N' in balance_:\n _add2dic(frags, ammonm, balance_['N'])\n if 'O' in balance_:\n _add2dic(frags, water, balance_['O'])\n balance_ = _balance(ich, frags)\n if 'H' in balance_:\n _add2dic(frags, hydrgn, balance_['H']/2)\n return frags\n", "meta": {"hexsha": "43cb70baef2fb008df7ee8cc6fe0a701fd6c997e", "size": 14797, "ext": "py", "lang": "Python", "max_stars_repo_path": "thermo/heatform.py", "max_stars_repo_name": "mobergd/interfaces", "max_stars_repo_head_hexsha": "82705d2173b9d213684da80913ec0593d30cdbe1", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "thermo/heatform.py", "max_issues_repo_name": "mobergd/interfaces", "max_issues_repo_head_hexsha": "82705d2173b9d213684da80913ec0593d30cdbe1", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "thermo/heatform.py", "max_forks_repo_name": "mobergd/interfaces", "max_forks_repo_head_hexsha": "82705d2173b9d213684da80913ec0593d30cdbe1", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.4174950298, "max_line_length": 86, "alphanum_fraction": 0.5817395418, "include": true, "reason": "import numpy", "num_tokens": 4162, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5544704649604273, "lm_q2_score": 0.34864513533394575, "lm_q1q2_score": 0.193313430294804}} {"text": "## Observation correction model\n\nimport numpy as np\n\nimport astropy.time\nimport astropy.coordinates\nimport astropy.units as u\nimport astropy.units.imperial\nimport astropy.units.cds\n\nimport bossdata\nimport specsim\n\nimport tpcorr.pointing\nimport tpcorr.guider\nimport tpcorr.acceptance_model\n\nclass Observation(object):\n def __init__(self, plate, mjd, guide_wlen=5400 * u.Angstrom, offset_wlen=4000 * u.Angstrom,\n std_wlen=5400 * u.Angstrom, wlen_grid_steps=15, steps_per_exposure=5,\n pressure0=None, temperature0=None):\n print 'Calculating corrections for {} observed on MJD {}'.format(plate, mjd)\n\n self.plate = plate\n self.mjd = mjd\n self.guide_wlen = guide_wlen\n self.std_wlen = std_wlen\n self.offset_wlen = offset_wlen\n self.steps_per_exposure = steps_per_exposure\n self.wlen_grid_steps = wlen_grid_steps\n \n self.finder = bossdata.path.Finder()\n self.mirror = bossdata.remote.Manager()\n\n # Get the list of exposures used in this observation's coadd from a spec lite file.\n spec_name = self.finder.get_spec_path(plate, mjd, fiber=1, lite=True)\n self.spec_file = bossdata.spec.SpecFile(self.mirror.get(spec_name))\n\n # Read the first b1 raw science exposure to find this plate's plug map.\n raw = self.spec_file.get_raw_image(0, 'blue', finder=self.finder, mirror=self.mirror)\n plug_map = raw.read_plug_map()\n\n # Look up the plate design pointing from the raw header and convert to\n # an index A,B,C,... -> 0,1,2,...\n pointing_label = raw.header['POINTING'].strip()\n pointing_index = ord(pointing_label) - ord('A')\n \n # Initialize a pointing object for this plate's sky location.\n ra_center = float(plug_map['raCen']) * u.deg\n self.ra_center = ra_center\n dec_center = float(plug_map['decCen']) * u.deg\n print 'Plate center is RA={:.3f}, DEC={:.3f} for {}-{}'.format(ra_center, dec_center, plate, pointing_label)\n self.pointing = tpcorr.pointing.Pointing(ra_center, dec_center)\n \n # Find the nominal observing temperature and time that this plate's holes are drilled for.\n self.design_temp = float(plug_map['temp'])*u.deg_C\n self.design_pressure = None # Calculate based on elevation and temperature\n self.design_ha = float(plug_map['ha'].split()[pointing_index]) * u.deg\n midnight = astropy.time.Time(mjd, format='mjd', scale='tai', location=self.pointing.where)\n design_time = specsim.transform.adjust_time_to_hour_angle(midnight, ra_center, self.design_ha, max_iterations=100)\n self.design_tai = design_time.mjd * 86400.\n print 'Holes drilled for T={:.1f} and HA={:.1f} (TAI={:.1f})'.format(self.design_temp, self.design_ha, self.design_tai)\n \n # design_time.mjd\n # when = astropy.time.Time(tai/86400., format='mjd', scale='tai', location=self.where)\n self.design_alt = self.pointing.plate_center.transform_to(astropy.coordinates.AltAz(\n obstime=design_time, location=self.pointing.where)).alt.to(u.deg)\n\n # Find this plate's guide stars.\n plugging = plug_map['PLUGMAPOBJ']\n guide_fibers = plugging['holeType'] == 'GUIDE'\n\n guide_ra, guide_dec = plugging['ra'][guide_fibers], plugging['dec'][guide_fibers]\n self.guide_targets = astropy.coordinates.ICRS(guide_ra * u.deg, guide_dec * u.deg)\n \n # Calculate the nominal guide fiber positions.\n self.guide_x0, self.guide_y0, _, _ = self.pointing.transform(\n self.guide_targets, self.design_tai, guide_wlen, self.design_temp, self.design_pressure)\n \n # Find this plate's offset fibers. We have to use spAll for this since the plug map does\n # not record the design wavelengths.\n self.plugmap = self.get_plugmap_from_spframes()\n\n offset_fibers_mask = self.plugmap['LAMBDA_EFF'] == offset_wlen.to(u.Angstrom).value\n offset_fibers = self.plugmap[offset_fibers_mask]\n\n offset_xfocal = offset_fibers['XFOCAL'] * u.mm\n offset_yfocal = offset_fibers['YFOCAL'] * u.mm\n self.fiber_ids = offset_fibers['FIBERID']\n self.offset_targets = astropy.coordinates.ICRS(ra=offset_fibers['RA'] * u.deg, dec=offset_fibers['DEC'] * u.deg)\n self.num_offset_targets = np.count_nonzero(self.offset_targets)\n print 'Plate has {:d} guide fibers and {:d} offset targets.'.format(len(self.guide_targets), self.num_offset_targets)\n\n if self.num_offset_targets > 0:\n # Calculate the nominal science fiber positions. These will not match XFOCAL, YFOCAL\n # exactly since we do not exactly replicate the IDL transforms, but they should be\n # close (within ~0.2 arcsec) and we only use offsets calculated consistently with\n # transform() in the following.\n self.offset_x0, self.offset_y0, offset_alt, offset_az = self.pointing.transform(\n self.offset_targets, self.design_tai, offset_wlen, self.design_temp, self.design_pressure)\n \n # Calculate where the offset target fibers would have been positioned if they were\n # designed for the same wavelength as the standard stars.\n self.offset_x0_std, self.offset_y0_std, _, _ = self.pointing.transform(\n self.offset_targets, self.design_tai, std_wlen, self.design_temp, self.design_pressure)\n \n # Initialize the wavelength grid to use for calculating corrections.\n self.wlen_grid = np.linspace(3500., 10500., wlen_grid_steps)[:, np.newaxis] * u.Angstrom\n \n # Initialize guided target centroid list\n self.guided_centroids = []\n\n # Initialize exposure meta data lists\n self.seeing = np.empty((self.spec_file.num_exposures)) * u.arcsec\n self.ha = np.empty((self.spec_file.num_exposures)) * u.degree\n self.pressure = np.empty((self.spec_file.num_exposures)) * u.kPa\n self.temperature = np.empty((self.spec_file.num_exposures)) * u.deg_C\n self.tai_beg = np.empty((self.spec_file.num_exposures)) # seconds\n self.tai_end = np.empty((self.spec_file.num_exposures)) # seconds\n self.alt = np.empty((self.spec_file.num_exposures)) * u.degree\n\n self.init_exposure_meta(pressure=pressure0, temperature=temperature0)\n\n\n def init_exposure_meta(self, seeing=None, pressure=None, temperature=None):\n # Precompute the conversion from inches of Hg to kPa.\n pconv = (1 * u.cds.mmHg * u.imperial.inch / u.mm).to(u.kPa).value\n\n # Loop over exposures\n for exp_index in range(self.spec_file.num_exposures):\n\n # Open the b1 frame for this exposure, to access its metadata.\n b1_frame_name = self.finder.get_plate_path(\n self.plate, self.spec_file.get_exposure_name(exp_index, 'blue', 'spFrame'))\n b1_frame = bossdata.plate.FrameFile(self.mirror.get(b1_frame_name))\n exp_id = b1_frame.exposure_id\n\n # Lookup this exposure's observing time, seeing, and temperature.\n self.tai_beg[exp_index] = b1_frame.header['TAI-BEG']\n self.tai_end[exp_index] = b1_frame.header['TAI-END']\n tai_mid = 0.5 * (self.tai_beg[exp_index] + self.tai_end[exp_index])\n \n # Convert tai to hour angle\n self.ha[exp_index] = tpcorr.pointing.normalize_angle(\n self.pointing.hour_angle(tai_mid).to(u.deg).value)*u.deg\n \n if seeing is not None:\n self.seeing[exp_index] = seeing\n else:\n if b1_frame.header['SEEING50'] == 0:\n self.seeing[exp_index] = 1.49 * u.arcsec\n print 'Warning: SEEING50=0. Using nominal value: ', self.seeing[exp_index]\n else:\n self.seeing[exp_index] = b1_frame.header['SEEING50'] * u.arcsec\n\n if temperature is not None:\n self.temperature[exp_index] = temperature\n else:\n try:\n self.temperature[exp_index] = b1_frame.header['AIRTEMP'] * u.deg_C\n except ValueError, e:\n self.temperature[exp_index] = 5 * u.deg_C\n print 'Warning: AIRTEMP not available in exp header. Using nominal value: ', self.temperature[exp_index]\n\n if pressure is not None:\n self.pressure[exp_index] = pressure\n else:\n try:\n self.pressure[exp_index] = b1_frame.header['PRESSURE'] * pconv * u.kPa\n except ValueError, e:\n self.pressure[exp_index] = 71.890 * u.kPa\n print 'Warning: PRESSURE not available in exp header. Using nominal value: ', self.pressure[exp_index]\n\n obstime = astropy.time.Time(tai_mid/86400., format='mjd', scale='tai', location=self.pointing.where)\n self.alt[exp_index] = self.pointing.plate_center.transform_to(astropy.coordinates.AltAz(\n obstime=obstime, location=self.pointing.where)).alt.to(u.deg)\n\n print 'Exp[{:02d}] #{:08d} seeing {:.3f}, T={:+5.1f}, P={:.1f}, TAI {:.1f} ({:+7.3f} days, HA {:+.1f})'.format(\n exp_index, exp_id, self.seeing[exp_index], self.temperature[exp_index], self.pressure[exp_index], \n tai_mid, (tai_mid - self.design_tai)/86400., self.ha[exp_index])\n\n def get_plugmap_from_spframes(self):\n # Read frame files for both spectrographs\n frames = []\n for fiber in (1,501):\n spec_name = self.finder.get_spec_path(self.plate, self.mjd, fiber=fiber, lite=True)\n spec_file = bossdata.spec.SpecFile(self.mirror.get(spec_name))\n frame_name = self.finder.get_plate_path(self.plate, spec_file.get_exposure_name(0, 'blue', 'spFrame'))\n frames.append(bossdata.plate.FrameFile(self.mirror.get(frame_name)))\n # Stack frame plugmaps\n return astropy.table.vstack([frame.plug_map for frame in frames])\n\n def get_exp_centroids(self, exp_index, guide_plot_name=None):\n # Create time steps covering this exposure.\n tai_steps = np.linspace(self.tai_beg[exp_index], self.tai_end[exp_index], self.steps_per_exposure)\n\n # Calculate the actual guide target positions on the focal plane without any guiding.\n guide_x, guide_y, _, _ = self.pointing.transform(\n self.guide_targets[:, np.newaxis], tai_steps, self.guide_wlen, self.temperature[exp_index], self.pressure[exp_index])\n \n # Solve for the optimal guider corrections.\n guider = tpcorr.guider.Guider(self.guide_x0, self.guide_y0, guide_x, guide_y)\n if guide_plot_name:\n guider.plot(tai_steps, field_radius=340 * u.mm, zoom=5000., \n fiber_radius=0.1 * u.arcsec * self.pointing.platescale, save=guide_plot_name)\n\n # Calculate the offset target paths on the focal plane without any guiding, for the actual observing conditions.\n offset_x, offset_y, _, _ = self.pointing.transform(\n self.offset_targets[:, np.newaxis, np.newaxis], tai_steps, self.wlen_grid, self.temperature[exp_index], self.pressure[exp_index])\n \n # Apply guiding corrections to estimate the actual offset target paths during the exposure.\n return guider.correct(offset_x, offset_y)\n\n def get_mean_exp_centroids(self, extrap_wlen=False):\n # Create time steps covering this exposure.\n midnight = astropy.time.Time(self.mjd, format='mjd', scale='tai', location=self.pointing.where)\n ha = np.mean(self.ha)\n time = specsim.transform.adjust_time_to_hour_angle(midnight, self.ra_center, ha, max_iterations=100)\n tai = time.mjd * 86400.\n\n temperature = np.mean(self.temperature)\n pressure = np.mean(self.pressure)\n\n print 'Mean Exposure: seeing {:.3f}, T={:+5.1f}, P={:.1f}, TAI {:.1f} ({:+7.3f} days, HA {:+.1f})'.format(\n np.mean(self.seeing), temperature, pressure, tai, (tai - self.design_tai)/86400., ha)\n\n # Calculate the actual guide target positions on the focal plane without any guiding.\n guide_x, guide_y, _, _ = self.pointing.transform(\n self.guide_targets[:, np.newaxis], tai, self.guide_wlen, self.design_temp, self.design_pressure)\n\n # Solve for the optimal guider corrections.\n guider = tpcorr.guider.Guider(self.guide_x0, self.guide_y0, guide_x, guide_y)\n\n # Calculate the offset target paths on the focal plane without any guiding, for the actual observing conditions.\n offset_x, offset_y, _, _ = self.pointing.transform(\n self.offset_targets[:, np.newaxis, np.newaxis], tai, self.wlen_grid, self.design_temp, self.design_pressure, extrap_wlen=extrap_wlen)\n\n return guider.correct(offset_x, offset_y)\n\n def get_mean_correction(self, extrap_wlen=False):\n\n corrections = np.empty((self.num_offset_targets, self.wlen_grid_steps, 1))\n\n # Estimate the actual offset target paths during the exposure\n # (offset_x0, offset_y0), (offset_x0_std, offset_y0_std), (guided_x, guided_y) = self.get_mean_exp_centroids()\n guided_x, guided_y = self.get_mean_exp_centroids(extrap_wlen=extrap_wlen)\n\n # Calculate centroid offsets for each offset target, relative to its nominal fiber center.\n offset = np.sqrt(\n (guided_x - self.offset_x0[:, np.newaxis, np.newaxis])**2 +\n (guided_y - self.offset_y0[:, np.newaxis, np.newaxis])**2)\n\n # Calculate centroid offsets for each offset target, relative to where its fiber center would\n # be if it were designed for the same wavelength as the standard stars.\n offset_std = np.sqrt(\n (guided_x - self.offset_x0_std[:, np.newaxis, np.newaxis])**2 +\n (guided_y - self.offset_y0_std[:, np.newaxis, np.newaxis])**2)\n\n seeing = np.mean(self.seeing)\n\n max_offset = 1.1/2.0*max(np.max((offset / self.pointing.platescale).to(u.arcsec)).value,\n np.max((offset_std / self.pointing.platescale).to(u.arcsec)).value)\n\n acceptance_model = tpcorr.acceptance_model.AcceptanceModel(seeing, max_offset=max_offset)\n\n # Calculate the acceptance fractions for both sets of centroid offsets.\n acceptance = acceptance_model((offset / self.pointing.platescale).to(u.arcsec))\n acceptance_std = acceptance_model((offset_std / self.pointing.platescale).to(u.arcsec))\n \n # Calculate the acceptance fraction ratios, tabulated for each offset target, wavelength and time.\n # The ratio calculated this way gives the correction of eqn (13).\n corrections = acceptance_std / acceptance\n\n mean_correction = np.mean(corrections, axis=-1)\n\n return mean_correction, guided_x, guided_y\n\n def get_corrections(self, seeing_wlen=5400.*u.Angstrom):\n\n # Precompute wlen ratio for wavelength dependent seeing adjustment\n wlen_ratio = (self.wlen_grid / seeing_wlen).si\n\n # Initialize acceptance ratio grid\n corrections = np.empty(\n (self.spec_file.num_exposures, self.num_offset_targets, self.wlen_grid_steps, self.steps_per_exposure),\n dtype=float)\n\n guided_centroids = []\n\n # Loop over exposures\n for exp_index in range(self.spec_file.num_exposures):\n\n # Estimate the actual offset target paths during the exposure\n guided_x, guided_y = self.get_exp_centroids(exp_index)\n guided_centroids.append((guided_x, guided_y))\n\n # Calculate centroid offsets for each offset target, relative to its nominal fiber center.\n offset = np.sqrt(\n (guided_x - self.offset_x0[:, np.newaxis, np.newaxis])**2 +\n (guided_y - self.offset_y0[:, np.newaxis, np.newaxis])**2)\n \n # Calculate centroid offsets for each offset target, relative to where its fiber center would\n # be if it were designed for the same wavelength as the standard stars.\n offset_std = np.sqrt(\n (guided_x - self.offset_x0_std[:, np.newaxis, np.newaxis])**2 +\n (guided_y - self.offset_y0_std[:, np.newaxis, np.newaxis])**2)\n\n seeing = self.seeing[exp_index]\n # psf = sdss_25m.get_atmospheric_psf(seeing_wlen, seeing, gauss=False)\n # acceptance_model = sdss_25m.calculate_fiber_acceptance(psf)\n\n seeing_wlen_adjusted = seeing*wlen_ratio**(-0.2)\n # acceptance_model_grid = map(tpcorr.acceptance_model.AcceptanceModel, seeing_wlen_adjusted)\n max_offset = 1.1/2.0*max(np.max((offset / self.pointing.platescale).to(u.arcsec)).value,\n np.max((offset_std / self.pointing.platescale).to(u.arcsec)).value)\n\n for wlen_index in range(self.wlen_grid_steps):\n # Build acceptance model for this wavelength\n acceptance_model = tpcorr.acceptance_model.AcceptanceModel(seeing_wlen_adjusted[wlen_index], max_offset=max_offset)\n\n # Calculate the acceptance fractions for both sets of centroid offsets.\n acceptance = acceptance_model((offset[:,wlen_index,:] / self.pointing.platescale).to(u.arcsec))\n acceptance_std = acceptance_model((offset_std[:,wlen_index,:] / self.pointing.platescale).to(u.arcsec))\n \n # Calculate the acceptance fraction ratios, tabulated for each offset target, wavelength and time.\n # The ratio calculated this way gives the correction of eqn (13).\n corrections[exp_index,:,wlen_index,:] = acceptance_std / acceptance\n\n # Average the correction over each exposure time slice.\n avg_corrections = np.mean(np.mean(corrections, axis=-1), axis=0)\n\n return corrections, avg_corrections, guided_centroids\n\nif __name__ == '__main__':\n pass\n", "meta": {"hexsha": "0163bffced5d8b9e70953d2dd27940a45e13b7f8", "size": 17935, "ext": "py", "lang": "Python", "max_stars_repo_path": "tpcorr/observation.py", "max_stars_repo_name": "dmargala/tpcorr", "max_stars_repo_head_hexsha": "64544a4ca51f622e5847407d191fc9a52e0e7e5c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "tpcorr/observation.py", "max_issues_repo_name": "dmargala/tpcorr", "max_issues_repo_head_hexsha": "64544a4ca51f622e5847407d191fc9a52e0e7e5c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "tpcorr/observation.py", "max_forks_repo_name": "dmargala/tpcorr", "max_forks_repo_head_hexsha": "64544a4ca51f622e5847407d191fc9a52e0e7e5c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 53.3779761905, "max_line_length": 145, "alphanum_fraction": 0.6594368553, "include": true, "reason": "import numpy,import astropy", "num_tokens": 4287, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5544704649604273, "lm_q2_score": 0.34864513533394575, "lm_q1q2_score": 0.193313430294804}} {"text": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Sat Feb 2 16:06:09 2019\n\n@author:\nMaximilian N. Günther\nMIT Kavli Institute for Astrophysics and Space Research, \nMassachusetts Institute of Technology,\n77 Massachusetts Avenue,\nCambridge, MA 02109, \nUSA\nEmail: maxgue@mit.edu\nWeb: www.mnguenther.com\n\"\"\"\n\nfrom __future__ import print_function, division, absolute_import\n\n#::: plotting settings\nimport seaborn as sns\nsns.set(context='paper', style='ticks', palette='deep', font='sans-serif', font_scale=1.5, color_codes=True)\nsns.set_style({\"xtick.direction\": \"in\",\"ytick.direction\": \"in\"})\nsns.set_context(rc={'lines.markeredgewidth': 1})\n\n#::: modules\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom matplotlib import gridspec\nfrom matplotlib.patches import Circle\nimport matplotlib.ticker as plticker\nfrom matplotlib.collections import LineCollection\nfrom matplotlib.colors import LinearSegmentedColormap\nimport random\nimport warnings\ntry:\n import rebound\n from rebound.particle import Particle\nexcept:\n warnings.warn('Module \"rebound\" could not be imported. Orbital plots are not available.')\nfrom itertools import cycle\n\n#::: allesfitter codes\nfrom allesfitter import config\nfrom allesfitter.exoworlds_rdx.lightcurves.index_transits import get_first_epoch\nfrom allesfitter.exoworlds_rdx.lightcurves.lightcurve_tools import calc_phase\n\n\n\n\ndef OrbitPlot(sim, figsize=None, lim=None, limz=None, Narc=100, xlabel='x', ylabel='y', zlabel='z', color=False, periastron=False, trails=True, show_orbit=True, lw=1., glow=False, slices=False, plotparticles=[], primary=None, fancy=False, ax=None):\n \"\"\"\n Convenience function for plotting instantaneous orbits.\n\n Parameters\n ----------\n slices : bool, optional\n Plot all three slices if set to True. Default is False and plots orbits only in the xy plane.\n figsize : tuple of float, optional\n Tuple defining the figure size (default: (5,5))\n lim : float, optional \n Limit for axes (default: None = automatically determined)\n limz : float, optional \n Limit for z axis, only used if slices=True (default: None = automatically determined)\n unitlabel : str, optional \n String describing the units, shown on axis labels (default: None)\n color : bool, str or list, optional \n By default plots in black. If set to True, plots using REBOUND color cycle. If a string or list of strings, e.g. ['red', 'cyan'], will cycle between passed colors.\n periastron : bool, optional \n Draw a marker at periastron (default: False)\n trails : bool, optional \n Draw trails instead of solid lines (default: False)\n show_orbit : bool, optional\n Draw orbit trails/lines (default: True)\n lw : float, optional \n Linewidth (default: 1.)\n glow : bool (default: False)\n Make lines glow\n fancy : bool (default: False)\n Changes various settings to create a fancy looking plot\n plotparticles : list, optional\n List of particles to plot. Can be a list of any valid keys for accessing sim.particles, i.e., integer indices or hashes (default: plot all particles)\n primary : rebound.Particle, optional\n Pimrary to use for the osculating orbit (default: Jacobi center of mass)\n\n Returns\n -------\n fig\n A matplotlib figure\n\n Examples\n --------\n The following example illustrates a typical use case.\n\n >>> sim = rebound.Simulation()\n >>> sim.add(m=1)\n >>> sim.add(a=1)\n >>> fig = rebound.OrbitPlot(sim)\n >>> fig.savefig(\"image.png\") # save figure to file\n >>> fig.show() # show figure on screen\n\n \"\"\"\n if slices:\n if figsize is None:\n figsize = (8,8)\n if ax is None:\n fig, ax = plt.subplots(2, 2, figsize=figsize)\n gs = gridspec.GridSpec(2, 2, width_ratios=[3., 2.], height_ratios=[2.,3.],wspace=0., hspace=0.) \n OrbitPlotOneSlice(sim, plt.subplot(gs[2]), lim=lim, Narc=Narc, color=color, periastron=periastron, trails=trails, show_orbit=show_orbit, lw=lw, axes=\"xy\",fancy=fancy, plotparticles=plotparticles, primary=primary, glow=glow)\n OrbitPlotOneSlice(sim, plt.subplot(gs[3]), lim=lim, limz=limz, Narc=Narc, color=color, periastron=periastron, trails=trails, show_orbit=show_orbit, lw=lw,fancy=fancy, axes=\"zy\", plotparticles=plotparticles, primary=primary, glow=glow)\n OrbitPlotOneSlice(sim, plt.subplot(gs[0]), lim=lim, limz=limz, Narc=Narc, color=color, periastron=periastron, trails=trails, show_orbit=show_orbit, lw=lw,fancy=fancy, axes=\"xz\", plotparticles=plotparticles, primary=primary, glow=glow)\n plt.subplot(gs[2]).set_xlabel(xlabel)\n plt.subplot(gs[2]).set_ylabel(ylabel)\n \n plt.setp(plt.subplot(gs[0]).get_xticklabels(), visible=False)\n plt.subplot(gs[0]).set_ylabel(zlabel)\n \n plt.subplot(gs[3]).set_xlabel(zlabel)\n plt.setp(plt.subplot(gs[3]).get_yticklabels(), visible=False)\n else:\n if figsize is None:\n figsize = (5,5)\n if ax is None:\n fig, ax = plt.subplots(1, 1, figsize=figsize)\n ax.set_xlabel(xlabel)\n ax.set_ylabel(ylabel)\n OrbitPlotOneSlice(sim, ax, lim=lim, Narc=Narc, color=color, periastron=periastron, trails=trails, show_orbit=show_orbit, lw=lw,fancy=fancy, plotparticles=plotparticles, primary=primary, glow=glow)\n return plt.gcf(), ax\n\n\n\n\ndef get_color(color):\n \"\"\"\n Takes a string for a color name defined in matplotlib and returns of a 3-tuple of RGB values.\n Will simply return passed value if it's a tuple of length three.\n\n Parameters\n ----------\n color : str\n Name of matplotlib color to calculate RGB values for.\n \"\"\"\n\n if isinstance(color, tuple) and len(color) == 3: # already a tuple of RGB values\n return color\n\n hexcolor = sns.colors.xkcd_rgb[color]\n\n hexcolor = hexcolor.lstrip('#')\n lv = len(hexcolor)\n return tuple(int(hexcolor[i:i + lv // 3], 16)/255. for i in range(0, lv, lv // 3)) # tuple of rgb values\n\n\n\n\ndef fading_line(x, y, color='black', alpha_initial=1., alpha_final=0., glow=False, **kwargs):\n \"\"\"\n Returns a matplotlib LineCollection connecting the points in the x and y lists, with a single color and alpha varying from alpha_initial to alpha_final along the line.\n Can pass any kwargs you can pass to LineCollection, like linewidgth.\n\n Parameters\n ----------\n x : list or array of floats for the positions on the (plot's) x axis\n y : list or array of floats for the positions on the (plot's) y axis\n color : matplotlib color for the line. Can also pass a 3-tuple of RGB values (default: 'black')\n alpha_initial: Limiting value of alpha to use at the beginning of the arrays.\n alpha_final: Limiting value of alpha to use at the end of the arrays.\n \"\"\"\n if glow:\n glow = False\n kwargs[\"lw\"] = 1\n fl1 = fading_line(x, y, color, alpha_initial, alpha_final, glow=False, **kwargs)\n kwargs[\"lw\"] = 2\n alpha_initial *= 0.5\n alpha_final *= 0.5\n fl2 = fading_line(x, y, color, alpha_initial, alpha_final, glow=False, **kwargs)\n kwargs[\"lw\"] = 6\n alpha_initial *= 0.5\n alpha_final *= 0.5\n fl3 = fading_line(x, y, color, alpha_initial, alpha_final, glow=False, **kwargs)\n return [fl3,fl2,fl1]\n\n color = get_color(color)\n cdict = {'red': ((0.,color[0],color[0]),(1.,color[0],color[0])),\n 'green': ((0.,color[1],color[1]),(1.,color[1],color[1])),\n 'blue': ((0.,color[2],color[2]),(1.,color[2],color[2])),\n 'alpha': ((0.,alpha_initial, alpha_initial), (1., alpha_final, alpha_final))}\n \n Npts = len(x)\n if len(y) != Npts:\n raise AttributeError(\"x and y must have same dimension.\")\n \n segments = np.zeros((Npts-1,2,2))\n segments[0][0] = [x[0], y[0]]\n for i in range(1,Npts-1):\n pt = [x[i], y[i]]\n segments[i-1][1] = pt\n segments[i][0] = pt \n segments[-1][1] = [x[-1], y[-1]]\n\n individual_cm = LinearSegmentedColormap('indv1', cdict)\n lc = LineCollection(segments, cmap=individual_cm, **kwargs)\n lc.set_array(np.linspace(0.,1.,len(segments)))\n return lc\n\n\n\n\ndef OrbitPlotOneSlice(sim, ax, lim=None, limz=None, Narc=100, color=False, periastron=False, trails=False, show_orbit=True, lw=1., axes=\"xy\", plotparticles=[], primary=None, glow=False, fancy=False):\n p_orb_pairs = []\n if not plotparticles:\n plotparticles = range(1, sim.N_real)\n for i in plotparticles:\n p = sim.particles[i]\n p_orb_pairs.append((p, p.calculate_orbit(primary=primary)))\n\n if lim is None:\n lim = 0.\n for p, o in p_orb_pairs: \n if o.a>0.:\n r = (1.+o.e)*o.a\n else:\n r = o.d\n if r>lim:\n lim = r\n lim *= 1.15\n if limz is None:\n z = [p.z for p,o in p_orb_pairs]\n limz = 2.0*max(z)\n if limz > lim:\n limz = lim\n if limz <= 0.:\n limz = lim\n\n if axes[0]==\"z\":\n ax.set_xlim([-limz,limz])\n else:\n ax.set_xlim([-lim,lim])\n if axes[1]==\"z\":\n ax.set_ylim([-limz,limz])\n else:\n ax.set_ylim([-lim,lim])\n \n if fancy:\n ax.set_facecolor((0.,0.,0.))\n for pos in ['top', 'bottom', 'right', 'left']:\n ax.spines[pos].set_edgecolor((0.3,0.3,0.3))\n\n if color is not False:\n if isinstance(color, list):\n colors = []\n for c in color:\n colors.append(get_color(c))\n elif isinstance(color, str):\n colors = [get_color(color)]\n elif color == True:\n colors = [(1.,0.,0.),(0.,0.75,0.75),(0.75,0.,0.75),(0.75, 0.75, 0,),(0., 0., 0.),(0., 0., 1.),(0., 0.5, 0.)]\n else:\n if fancy:\n colors = [(181./206.,66./206.,191./206.)]\n glow = True\n else:\n colors = [\"black\"]\n coloriterator = cycle(colors)\n\n# coords = {'x':0, 'y':1, 'z':2}\n# axis0 = coords[axes[0]]\n# axis1 = coords[axes[1]]\n \n prim = sim.particles[0] if primary is None else primary \n if fancy:\n sun = (256./256.,256./256.,190./256.)\n opa = 0.020\n size = 6000.\n for i in range(256):\n ax.scatter(getattr(prim,axes[0]),getattr(prim,axes[1]), alpha=opa, s=size*lw, facecolor=sun, edgecolor=None, zorder=3)\n size *= 0.95\n \n starcolor = (1.,1.,1.)\n mi, ma = ax.get_xlim()\n prestate = random.getstate()\n random.seed(1) #always same stars\n x, y = [], []\n #small stars\n for i in range(64):\n x.append(random.uniform(mi,ma))\n y.append(random.uniform(mi,ma))\n ax.scatter(x,y, alpha=0.05, s=8*lw, facecolor=starcolor, edgecolor=None, zorder=3)\n ax.scatter(x,y, alpha=0.1, s=4*lw, facecolor=starcolor, edgecolor=None, zorder=3)\n ax.scatter(x,y, alpha=0.2, s=0.5*lw, facecolor=starcolor, edgecolor=None, zorder=3)\n #medium stars\n x, y = [], []\n for i in range(16):\n x.append(random.uniform(mi,ma))\n y.append(random.uniform(mi,ma))\n ax.scatter(x,y, alpha=0.1, s=15*lw, facecolor=starcolor, edgecolor=None, zorder=3)\n ax.scatter(x,y, alpha=0.1, s=5*lw, facecolor=starcolor, edgecolor=None, zorder=3)\n ax.scatter(x,y, alpha=0.5, s=2*lw, facecolor=starcolor, edgecolor=None, zorder=3)\n random.setstate(prestate)\n\n else:\n ax.scatter(getattr(prim,axes[0]),getattr(prim,axes[1]), marker=\"*\", s=35*lw, facecolor=\"black\", edgecolor=None, zorder=3)\n \n proj = {}\n for p, o in p_orb_pairs:\n colori = next(coloriterator)\n \n prim = p.jacobi_com if primary is None else primary \n if fancy:\n ax.scatter(getattr(p,axes[0]), getattr(p,axes[1]), s=25*lw, facecolor=colors, edgecolor=None, zorder=3)\n else:\n pass\n #::: !!!\n #::: !!!\n #::: plot the planet symbols\n #::: !!!\n #::: !!!\n# ax.scatter(getattr(p,axes[0]), getattr(p,axes[1]), s=p.r*lw, facecolor=colori, edgecolor=None, zorder=3)\n\n \n if show_orbit is True:\n alpha_final = 0. if trails is True else 1. # fade to 0 with trails\n\n hyperbolic = o.a < 0. # Boolean for whether orbit is hyperbolic\n if hyperbolic is False:\n pts = np.array(p.sample_orbit(Npts=Narc+1, primary=prim))\n proj['x'],proj['y'],proj['z'] = [pts[:,i] for i in range(3)]\n lc = fading_line(proj[axes[0]], proj[axes[1]], colori, alpha_final=alpha_final, lw=lw, glow=glow)\n if type(lc) is list:\n for l in lc:\n ax.add_collection(l)\n else:\n ax.add_collection(lc)\n\n else:\n pts = np.array(p.sample_orbit(Npts=Narc+1, primary=prim, useTrueAnomaly=False))\n # true anomaly stays close to limiting value and switches quickly at pericenter for hyperbolic orbit, so use mean anomaly\n proj['x'],proj['y'],proj['z'] = [pts[:,i] for i in range(3)]\n lc = fading_line(proj[axes[0]], proj[axes[1]], colori, alpha_final=alpha_final, lw=lw, glow=glow)\n if type(lc) is list:\n for l in lc:\n ax.add_collection(l)\n else:\n ax.add_collection(lc)\n \n alpha = 0.2 if trails is True else 1.\n pts = np.array(p.sample_orbit(Npts=Narc+1, primary=prim, trailing=False, useTrueAnomaly=False))\n proj['x'],proj['y'],proj['z'] = [pts[:,i] for i in range(3)]\n lc = fading_line(proj[axes[0]], proj[axes[1]], colori, alpha_initial=alpha, alpha_final=alpha, lw=lw, glow=glow)\n if type(lc) is list:\n for l in lc:\n ax.add_collection(l)\n else:\n ax.add_collection(lc)\n\n if periastron:\n newp = Particle(a=o.a, f=0., inc=o.inc, omega=o.omega, Omega=o.Omega, e=o.e, m=p.m, primary=prim, simulation=sim)\n ax.plot([getattr(prim,axes[0]), getattr(newp,axes[0])], [getattr(prim,axes[1]), getattr(newp,axes[1])], linestyle=\"dotted\", c=colori, zorder=1, lw=lw)\n ax.scatter([getattr(newp,axes[0])],[getattr(newp,axes[1])], marker=\"o\", s=5.*lw, facecolor=\"none\", edgecolor=colori, zorder=1)\n\n\n\n\ndef plot_top_down_view(params_median, params_star, a=None, timestep=None, scaling=5., colors=sns.color_palette('deep'), linewidth=2, plot_arrow=False, ax=None):\n \n sim = rebound.Simulation()\n sim.add(m=1)\n \n for i, companion in enumerate(config.BASEMENT.settings['companions_all']):\n if (i==0) and (timestep is None): \n timestep = params_median[companion+'_epoch'] #calculate it for the timestep where the first companion is in transit\n first_epoch = get_first_epoch(timestep, params_median[companion+'_epoch'], params_median[companion+'_period'])\n phase = calc_phase(timestep, params_median[companion+'_period'], first_epoch)\n ecc = params_median[companion+'_f_s']**2 + params_median[companion+'_f_c']**2\n w = np.arccos( params_median[companion+'_f_c'] / np.sqrt(ecc) ) #in rad\n inc = params_median[companion+'_incl']/180.*np.pi\n if a is None:\n a1 = params_star['R_star'] / params_median[companion+'_radius_1'] #in Rsun \n a1 *= 0.004650467260962157 #in AU\n else:\n a1 = a[i]\n# print(a, inc, ecc, w, phase*2*np.pi)\n if ecc>0:\n sim.add(a=a1, inc=inc-np.pi/2., e=ecc, omega=w, f=phase*2*np.pi)\n else:\n sim.add(a=a1, inc=inc--np.pi/2., f=phase*2*np.pi)\n# print(len(sim.particles))\n \n# print('Epoch, Period and mean anomaly, b:', sim.particles[0].M )\n# print('Mean anomaly, c:', sim.particles[0].M )\n# print('Mean anomaly, c:', sim.particles[0].M )\n# err\n \n fig, ax = OrbitPlot(sim, xlabel='AU', ylabel='AU', color=colors, lw=linewidth, ax=ax) #color=[sns.color_palette('deep')[i] for i in [0,1,3]],\n \n for i, companion in enumerate(config.BASEMENT.settings['companions_all']):\n \n R_companion = params_star['R_star'] * params_median[companion+'_rr'] # in Rsun\n R_companion *= 0.004650467260962157 #in AU\n R_companion *= scaling\n \n \n x = sim.particles.get(i+1).x\n y = sim.particles.get(i+1).y\n p = Circle((x,y), R_companion, color=colors[i])\n ax.add_artist(p)\n \n if plot_arrow:\n x0, x1 = ax.get_xlim()\n plt.arrow( 0.1*x1, 0, 0.7*x1, 0, color='silver', zorder=1 ) \n \n plt.axis('equal')\n# ax.set(xlim=[-0.12,0.12], ylim=[-0.12,0.12])\n# loc = plticker.MultipleLocator(base=0.05) # this locator puts ticks at regular intervals\n# ax.xaxis.set_major_locator(loc)\n# ax.yaxis.set_major_locator(loc)\n\n return fig, ax\n\n\n", "meta": {"hexsha": "9da667dc0833ef79438c28f29e38de6828226382", "size": 17196, "ext": "py", "lang": "Python", "max_stars_repo_path": "allesfitter/plot_top_down_view.py", "max_stars_repo_name": "pierfra-ro/allesfitter", "max_stars_repo_head_hexsha": "a6a885aaeb3253fec0d924ef3b45e8b7c473b181", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "allesfitter/plot_top_down_view.py", "max_issues_repo_name": "pierfra-ro/allesfitter", "max_issues_repo_head_hexsha": "a6a885aaeb3253fec0d924ef3b45e8b7c473b181", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "allesfitter/plot_top_down_view.py", "max_forks_repo_name": "pierfra-ro/allesfitter", "max_forks_repo_head_hexsha": "a6a885aaeb3253fec0d924ef3b45e8b7c473b181", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.9428571429, "max_line_length": 248, "alphanum_fraction": 0.5982786695, "include": true, "reason": "import numpy", "num_tokens": 4789, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5273165233795671, "lm_q2_score": 0.36658974324230986, "lm_q1q2_score": 0.193308828913143}} {"text": "#!/usr/bin/env python\n# -*- coding: utf8 -*-\n\"\"\"\n SAMI XJoin\n\n This script simply joins the four existing extensions inside a FITS file\n created during observations with SAMI (SAM Imager). During the reduce,\n it also fits a 2nd degree polynomium to the OVERSCAN region that is\n subtracted from the corresponding image.\n\n The user also may want to add flags in order to reduce the images\n according to the following options (in order):\n\n - BIAS subtraction;\n - DARK subtraction;\n - Remove hot pixels and cosmic rays;\n - Remove overglow using a long exposure DARK image;\n - Divide by the FLAT;\n - Divide by the exposure time;\n\n The documentation for each reduce is shown in the corresponding function.\n\n Todo\n ----\n - Use multithread or multiprocessing to run this script faster.\n - Use astropy.ccdproc to reduce the data.\n\n Bruno Quint (bquint at ctio.noao.edu)\n May 2016\n\n Thanks to Andrei Tokovinin and Claudia M. de Oliveira for the ideas that\n were implemented here.\n\"\"\"\n\nimport numpy as _np\n\nfrom ccdproc import cosmicray_lacosmic as _cosmicray_lacosmic\nfrom scipy import stats\n\nfrom astropy import wcs\nfrom astropy.coordinates import SkyCoord\nfrom astropy import units as u\n\nfrom soar_simager.io import pyfits as _pyfits\nfrom soar_simager.io.logging import get_logger\nfrom soar_simager.tools import slices\n\nlogger = get_logger(__name__)\n\n\n# Piece of code from cosmics.py\n# We define the laplacian kernel to be used\n_laplkernel = _np.array([[0.0, -1.0, 0.0], [-1.0, 4.0, -1.0], [0.0, -1.0, 0.0]])\n\n# Other kernels :\n_growkernel = _np.ones((3, 3))\n\n# dilation structure for some morphological operations\n_dilstruct = _np.ones((5, 5))\n_dilstruct[0, 0] = 0\n_dilstruct[0, 4] = 0\n_dilstruct[4, 0] = 0\n_dilstruct[4, 4] = 0\n\n\nclass Reducer:\n \"\"\"\n This class holds all the methods used to join the extensions within a\n FITS file obtained with SAMI.\n\n Parameters\n ----------\n zero_file : str\n The filename of the master zero that will be used in subtraction.\n\n clean : bool\n Clean bad collumns by taking the _median value of the pixels around\n them.\n\n cosmic_rays : bool\n Clean cosmic rays using LACosmic package. See noted bellow for\n reference.\n\n dark_file : str\n Master Dark's filename to be used for dark subtraction.\n\n debug : bool\n Turn on debug mode with lots of printing.\n\n flat_file : str\n Master Flat filename to be used for normalization.\n\n glow_file : str\n Master file that contains the lateral glowings sometimes present in\n SAMI's data.\n\n time : bool\n Divide each pixel's values by the exposure time and update header.\n\n verbose : bool\n Turn on verbose mode (not so talktive as debug mode).\n\n Attributes\n ----------\n gain : list\n A list containing the gain that converts ADU values to eletrons for \n each simager amplifier.\n \n read_noise : list\n A list containing the read noise on each simager amplifier.\n\n See also\n --------\n LACosmic - http://www.astro.yale.edu/dokkum/lacosmic/\n \"\"\"\n\n gain = [2.6, 2.6, 2.6, 2.6]\n read_noise = [10., 10., 10., 10.]\n\n def __init__(self, clean=False, cosmic_rays=False, dark_file=None,\n debug=False, flat_file=None, glow_file=None, merge=False,\n overscan=False, norm_flat=False, time=False, verbose=False,\n zero_file=None):\n\n logger.setLevel(\"ERROR\")\n\n if verbose:\n logger.setLevel(\"INFO\")\n\n if debug:\n logger.setLevel(\"DEBUG\")\n\n self.clean = clean\n self.cosmic_rays = cosmic_rays\n self.dark_file = dark_file\n self.flat_file = flat_file\n self.glow_file = glow_file\n self._merge = merge\n self.norm_flat = norm_flat\n self.overscan = overscan\n self.time = time\n self.zero_file = zero_file\n\n return\n\n def reduce(self, hdu_list, prefix=\"\"):\n\n # If the number of extensions is just 1, then the file is already\n # processed.\n if len(hdu_list) == 1:\n return hdu_list, ''\n\n # Merge file\n data, header, prefix = self.merge(hdu_list)\n\n # Correct ZERO\n data, header, prefix = self.correct_zero(\n data, header, prefix, self.zero_file\n )\n\n # Correct DARK\n data, header, prefix = self.correct_dark(\n data, header, prefix, self.dark_file\n )\n\n # Remove cosmic rays and hot pixels\n data, header, prefix = self.remove_cosmic_rays(\n data, header, prefix, self.cosmic_rays\n )\n\n # Remove lateral glows\n data, header, prefix = self.correct_lateral_glow(\n data, header, prefix, self.glow_file\n )\n\n # Correct FLAT\n data, header, prefix = self.correct_flat(\n data, header, prefix, self.flat_file\n )\n\n # Normalize by the EXPOSURE TIME\n data, header, prefix = self.divide_by_exposuretime(\n data, header, prefix, self.time\n )\n\n # Clean known bad columns and lines\n data, header, prefix = self.clean_hot_columns_and_lines(\n data, header, prefix, self.clean\n )\n\n # Add WCS\n data, header = self.create_wcs(\n data, header\n )\n\n return data, header, prefix\n\n @staticmethod\n def create_wcs(data, header):\n \"\"\"\n Creates a first guess of the WCS using the telescope coordinates, the\n CCDSUM (binning), position angle and plate scale.\n\n Parameters\n ----------\n data : numpy.ndarray\n 2D array with the data.\n\n header : astropy.io.fits.Header\n Primary Header to be updated.\n\n Returns\n -------\n header : astropy.io.fits.Header\n Primary Header with updated WCS information.\n \"\"\"\n h = header\n\n if 'EQUINOX' not in h:\n h['EQUINOX'] = 2000.\n\n if 'EPOCH' not in h:\n h['EPOCH'] = 2000.\n\n if h['PIXSCAL1'] != h['PIXSCAL2']:\n logger.warning('Pixel scales for X and Y do not mach.')\n\n if h['OBSTYPE'] != 'OBJECT':\n return data, header\n\n binning = _np.array([int(b) for b in h['CCDSUM'].split(' ')])\n plate_scale = h['PIXSCAL1'] * u.arcsec\n p = plate_scale.to('degree').value\n w = wcs.WCS(naxis=2)\n\n try:\n coordinates = SkyCoord(ra=h['RA'], dec=h['DEC'],\n unit=(u.hourangle, u.deg))\n\n except ValueError:\n\n logger.error(\n '\"RA\" and \"DEC\" missing. Using \"TELRA\" and \"TELDEC\" instead.')\n\n coordinates = SkyCoord(ra=h['TELRA'], dec=h['TELDEC'],\n unit=(u.hourangle, u.deg))\n\n ra = coordinates.ra.to('degree').value\n dec = coordinates.dec.to('degree').value\n\n w.wcs.crpix = [data.shape[1] / 2, data.shape[0] / 2]\n w.wcs.cdelt = p * binning\n w.wcs.crval = [ra, dec]\n w.wcs.ctype = [\"RA---TAN\", \"DEC--TAN\"]\n\n wcs_header = w.to_header()\n\n theta = _np.deg2rad(h['DECPANGL'])\n wcs_header['cd1_1'] = p * binning[0] * _np.cos(theta)\n wcs_header['cd2_2'] = p * binning[0] * _np.cos(theta)\n wcs_header['cd1_2'] = p * binning[0] * _np.sin(theta)\n wcs_header['cd2_1'] = - p * binning[0] * _np.sin(theta)\n\n for key in wcs_header.keys():\n header[key] = wcs_header[key]\n\n return data, header\n\n @staticmethod\n def check_header(hdu_list, prefix):\n\n for i in range(5):\n\n h = hdu_list[i].header\n\n try:\n h['RADESYSa'] = h['RADECSYS']\n del h['RADECSYS']\n except KeyError:\n pass\n\n if 'EQUINOX' in h and 'unavail' in h['EQUINOX']:\n h['EQUINOX'] = 2000.\n\n if 'EPOCH' not in h:\n h['EPOCH'] = 2000.\n\n return hdu_list, prefix\n\n @staticmethod\n def clean_column(_data, x0, y0, yf, n=5):\n \"\"\"\n Substitutes a single column by the _median of the neighbours columns.\n\n Args:\n\n _data (numpy.ndarray) : A 2D numpy array that contains the data.\n\n x0 (int) : X position of the pixel to be cleaned.\n\n y0 (int) : Start position of the column.\n\n yf (int) : Final position of the column.\n\n n (int, optional) : Number of neighbour columns (Default=5).\n\n Returns:\n\n _data (numpy.ndarray) : Processed 2D numpy array.\n\n See also:\n\n Reducer.clean_columns\n Reducer.clean_line\n Reducer.clean_lines\n \"\"\"\n\n if not isinstance(_data, _np.ndarray):\n raise (TypeError, 'Please, use a np.array as input')\n\n if _data.ndim is not 2:\n raise (TypeError, 'Data contains %d dimensions while it was '\n 'expected 2 dimensions.')\n\n t1 = _data[y0:yf, x0 - n:x0]\n t2 = _data[y0:yf, x0 + 1:x0 + n]\n t = _np.hstack((t1, t2))\n _data[y0:yf, x0] = _np.median(t, axis=1)\n\n return _data\n\n def clean_columns(self, data, header):\n \"\"\"\n Clean the known bad columns that exists in most of SAMI's, SOI's or\n SIFS's data. This method is meant to be overwritten via inheritance.\n\n Args:\n\n data (numpy.ndarray) : A 2D numpy array that contains the data.\n\n header (astropy.io.fits.Header) : A header that will be updated.\n\n See also:\n\n Reducer.clean_column\n Reducer.clean_line\n Reducer.clean_lines\n \"\"\"\n return data, header\n\n @staticmethod\n def clean_line(_data, x0, xf, y, n=5):\n \"\"\"\n Substitutes a single column by the _median of the neighbours columns.\n\n Args:\n\n _data (numpy.ndarray) : A 2D numpy array that contains the data.\n\n x0 (int) : Start position of the line.\n\n xf (int) : Final position of the line.\n\n y (int) : Y position of the pixel to be cleaned.\n\n n (int) : Number of neighbour columns. (Default=5)\n\n See also:\n\n Reducer.clean_column\n Reducer.clean_columns\n Reducer.clean_lines\n \"\"\"\n if not isinstance(_data, _np.ndarray):\n raise (TypeError, 'Please, use a np.array as input')\n\n if _data.ndim is not 2:\n raise (TypeError, 'Data contains %d dimensions while it was '\n 'expected 2 dimensions.')\n\n t1 = _data[y - n:y, x0:xf]\n t2 = _data[y + 1:y + n, x0:xf]\n t = _np.vstack((t1, t2))\n _data[y, x0:xf] = _np.median(t, axis=0)\n\n return _data\n\n def clean_lines(self, data, header):\n \"\"\"\n Clean the known bad lines that exists in most of SAMI's, SOI's or\n SIFS's data. This method is meant to be overwritten via inheritance.\n\n Args:\n\n data (numpy.ndarray) : A 2D numpy array that contains the data.\n\n header (astropy.io.fits.Header) : A header that will be updated.\n\n See also:\n\n Reducer.clean_column\n Reducer.clean_line\n Reducer.clean_lines\n \"\"\"\n return data, header\n\n def clean_hot_columns_and_lines(self, data, header, prefix, clean):\n \"\"\"\n Clean known hot columns and lines from SAMI's images.\n\n Args:\n\n data (numpy.ndarray) : A 2D numpy array that contains the data.\n\n header (astropy.io.fits.Header) : A header that will be updated.\n\n prefix (str) : File prefix that is added after each reduce.\n\n clean (bool) : Should I perform the clean?\n\n See also:\n\n Reducer.clean_column\n Reducer.clean_columns\n Reducer.clean_line\n Reducer.clean_lines\n \"\"\"\n if clean is True:\n\n data = self.clean_columns(data, header)\n data = self.clean_lines(data, header)\n header.add_history('Cleaned bad columns and lines.')\n prefix = 'c' + prefix\n\n return data, header, prefix\n\n @staticmethod\n def correct_dark(data, header, prefix, dark_file=None):\n \"\"\"\n Subtract the dark file from data and add HISTORY to header.\n\n Args:\n\n data (numpy.ndarray) : A 2D numpy array that contains the data.\n\n header (astropy.io.fits.Header) : A header that will be updated.\n\n prefix : str\n File prefix that is added after each reduce.\n\n dark_file: str | None\n Master Dark filename. If None is given, nothing is done.\n \"\"\"\n\n if not isinstance(prefix, str):\n raise (TypeError, 'Expected string but found %s instead.' %\n prefix.__class__)\n\n if dark_file is not None:\n\n dark = _pyfits.open(dark_file)[0]\n dark.data = dark.data / float(dark.header['EXPTIME'])\n\n data = data - dark.data * header['EXPTIME']\n header['DARKFILE'] = dark_file\n prefix = 'd' + prefix\n\n return data, header, prefix\n\n @staticmethod\n def correct_flat(data, header, prefix, flat_file):\n \"\"\"\n Divide the image by the master flat file and add HISTORY to header.\n\n Args:\n\n data (numpy.ndarray) : A 2D numpy array that contains the data.\n\n header (astropy.io.fits.Header) : A header that will be updated.\n\n prefix (str) : File prefix that is added after each reduce.\n\n flat_file (str or None) : Master flat filename. If None is given,\n nothing is done.\n \"\"\"\n if not isinstance(prefix, str):\n raise (TypeError, 'Expected string but found %s instead.' %\n prefix.__class__)\n\n if flat_file is not None:\n flat = _pyfits.open(flat_file)[0]\n\n data /= flat.data\n header['FLATFILE'] = flat_file\n prefix = 'f' + prefix\n\n return data, header, prefix\n\n def correct_lateral_glow(self, data, header, prefix, glow_file):\n \"\"\"\n Remove lateral glows by scaling the glows in the `glow_file` based\n on `data` and subtracting it.\n\n Args:\n\n data (numpy.ndarray) : A 2D numpy array that contains the data.\n\n header (astropy.io.fits.Header) : A header that will be updated.\n\n prefix : str\n Filename prefix to flag images that were clean.\n\n glow_file : str\n Path to a long dark file that contains the lateral glow.\n \"\"\"\n\n if glow_file is not None:\n\n # Create four different regions.\n regions = [\n [_np.median(data[539:589, 6:56]), # Top Left\n _np.median(data[539:589, 975:1019])], # Top Right\n [_np.median(data[449:506, 6:56]), # Bottom Left\n _np.median(data[449:506, 975:1019])] # Bottom Right\n ]\n\n min_std_region = _np.argmin(regions) % 2\n\n # The upper reg has background lower or equal to the lower reg\n midpt1 = regions[0][min_std_region]\n midpt2 = regions[1][min_std_region]\n diff = midpt2 - midpt1\n\n dark = _pyfits.getdata(glow_file)\n dark = self.clean_columns(dark)\n dark = self.clean_lines(dark)\n\n dark_regions = [\n [_np.median(dark[539:589, 6:56]), # Top Left\n _np.median(dark[539:589, 975:1019])], # Top Right\n [_np.median(dark[449:506, 6:56]), # Bottom Left\n _np.median(dark[449:506, 975:1019])] # Bottom Right\n ]\n\n dark_midpt1 = dark_regions[0][min_std_region]\n dark_midpt2 = dark_regions[1][min_std_region]\n\n dark_diff = dark_midpt2 - dark_midpt1\n dark -= dark_midpt1\n\n k = diff / dark_diff\n temp_dark = dark * k\n data -= midpt1\n data -= temp_dark\n\n header.add_history('Lateral glow removed using %s file' % glow_file)\n prefix = 'g' + prefix\n\n return data, header, prefix\n\n @staticmethod\n def correct_zero(data, header, prefix, zero_file):\n \"\"\"\n Subtract zero from data.\n\n Args:\n\n data (numpy.ndarray) : A 2D numpy array that contains the data.\n\n header (astropy.io.fits.Header) : A header that will be updated.\n\n prefix (str) : File prefix that is added after each reduce.\n\n zero_file (str | None) : Master Bias filename. If None is given,\n nothing is done.\n\n \"\"\"\n from os.path import abspath\n\n if zero_file is not None:\n\n zero = _pyfits.open(abspath(zero_file))[0]\n data = data - zero.data\n header['BIASFILE'] = zero_file\n prefix = 'z' + prefix\n\n return data, header, prefix\n\n @staticmethod\n def divide_by_exposuretime(data, header, prefix, time):\n \"\"\"\n Divide the image by the exposure time and add HISTORY to header.\n\n Args:\n\n data (numpy.ndarray) : A 2D numpy array that contains the data.\n\n header (astropy.io.fits.Header) : A header that will be updated.\n\n prefix : str\n File prefix that is added after each reduce.\n\n time: bool\n Divide image by exposure time?\n \"\"\"\n if time is True:\n\n h = header\n\n try:\n\n h['UNITS'] = 'adu / s'\n t = float(h['EXPTIME'])\n d = data / t\n\n header = h\n data = d\n\n except AttributeError:\n header = h\n\n except KeyError:\n pass\n\n prefix = 't' + prefix\n\n return data, header, prefix\n\n def get_header(self, hdu_source):\n \"\"\"\n Return the header of the primary HDU extension of a FITS file.\n\n Args:\n\n hdu_source (str or astropy.io.fits.HDUList) : HDUList or name of the\n file which contains a HDUList.\n \"\"\"\n from os.path import exists\n\n if isinstance(hdu_source, str):\n\n if not exists(hdu_source):\n raise (IOError, '%s file not found.' % hdu_source)\n\n hdu_source = _pyfits.open(hdu_source)\n\n h0 = hdu_source[0].header\n h1 = hdu_source[1].header\n\n h0.append('UNITS')\n h0.set('UNITS', value='ADU', comment='Pixel intensity units.')\n\n # Save the CCD binning in the main header\n h0['CCDSUM'] = h1['CCDSUM']\n h0['DETSEC'] = h1['DETSEC']\n\n # Save the area that corresponds to each amplifier\n bin_size = _np.array(h0['CCDSUM'].split(' '), dtype=int)\n\n dx, dy = slices.iraf2python(h0['DETSEC'])\n dx, dy = dx // bin_size[0], dy // bin_size[1]\n\n h0['AMP_SEC1'] = slices.python2iraf(\n dx[0], dx[1], dy[0], dy[1])\n\n h0['AMP_SEC2'] = slices.python2iraf(\n dx[0] + dx[1], dx[1] + dx[1], dy[0], dy[1])\n\n h0['AMP_SEC3'] = slices.python2iraf(\n dx[0], dx[1], dy[0] + dy[1], dy[1] + dy[1])\n\n h0['AMP_SEC4'] = slices.python2iraf(\n dx[0] + dx[1], dx[1] + dx[1], dy[0] + dy[1], dy[1] + dy[1])\n\n return h0\n\n def get_prefix(self):\n \"\"\"\n Return a prefix to be added to the file deppending on the data\n reduction steps.\n\n Returns\n -------\n prefix : (str)\n The prefix that can be used.\n m = merged amplifiers.\n z = zero subtracted.\n f = flat corrected.\n \"\"\"\n\n prefix = 'm_'\n\n if self.zero_file:\n prefix = 'z' + prefix\n\n if self.dark_file:\n prefix = 'd' + prefix\n\n if self.flat_file:\n prefix = 'f' + prefix\n\n return prefix\n\n def merge(self, hdul):\n \"\"\"\n Open a FITS image and try to join its extensions in a single array.\n\n Args:\n\n hdul (astropy.io.fits.HDUList) : an HDUList that contains one\n PrimaryHDU and four ImageHDU\n\n \"\"\"\n w, h = slices.iraf2python(hdul[1].header['DETSIZE'])\n\n if len(hdul) is 1:\n logger.warning('%s file contains a single extension. ' % hdul +\n 'Not doing anything')\n return hdul[0].data\n\n # Correct for binning\n bin_size = _np.array(hdul[1].header['CCDSUM'].split(' '),\n dtype=int)\n bw, bh = w[1] // bin_size[0], h[1] // bin_size[1]\n\n # Create empty full frame\n new_data = _np.empty((bh, bw), dtype=float)\n\n # Process each extension\n for i in range(1, 5):\n tx, ty = slices.iraf2python(hdul[i].header['TRIMSEC'])\n bx, by = slices.iraf2python(hdul[i].header['BIASSEC'])\n\n data = hdul[i].data\n trim = data[ty[0]:ty[1], tx[0]:tx[1]]\n bias = data[by[0]:by[1], bx[0]:bx[1]]\n\n # Collapse the bias columns to a single column.\n bias = _np.median(bias, axis=1)\n\n # Fit and remove OVERSCAN\n x = _np.arange(bias.size) + 1\n bias_fit_pars = _np.polyfit(x, bias, 2) # Last par = inf\n bias_fit = _np.polyval(bias_fit_pars, x)\n bias_fit = bias_fit.reshape((bias_fit.size, 1))\n bias_fit = _np.repeat(bias_fit, trim.shape[1], axis=1)\n\n trim = trim - bias_fit\n dx, dy = slices.iraf2python(hdul[i].header['DETSEC'])\n dx, dy = dx // bin_size[0], dy // bin_size[1]\n new_data[dy[0]:dy[1], dx[0]:dx[1]] = trim\n\n header = self.get_header(hdul)\n\n return new_data, header, \"m_\"\n\n @staticmethod\n def remove_cosmic_rays(data, header, prefix, cosmic_rays):\n \"\"\"\n Use LACosmic to remove cosmic rays.\n\n Args:\n\n data (numpy.ndarray) : A 2D numpy array that contains the data.\n\n header (astropy.io.fits.Header) : A header that will be updated.\n\n prefix : str\n Filename prefix to flag images that were clean.\n\n cosmic_rays : bool\n Flag to indicate if cosmic rays removal should be performed.\n \"\"\"\n if cosmic_rays:\n\n d = data\n d, _ = _cosmicray_lacosmic(\n d, gain=2.6, readnoise=10.0, sigclip=2.5, sigfrac=0.3,\n objlim=5.0)\n d /= 2.6\n\n h = header\n h.add_history(\n 'Cosmic rays and hot pixels removed using LACosmic')\n\n data = d\n header = h\n\n return data, header, prefix\n\n @staticmethod\n def remove_wcs(header):\n\n return header\n\n\nclass SamiReducer(Reducer):\n\n gain = [2.1, 2.0537, 2.1, 2.0823]\n read_noise = [10., 10., 10., 10.]\n \n def reduce(self, hdu_list, prefix=\"\"):\n\n # If the number of extensions is just 1, then the file is already\n # processed.\n if len(hdu_list) == 1:\n return hdu_list, ''\n\n # Merge file\n data, header, prefix = self.merge(hdu_list)\n\n # Removing bad column and line\n data, header, prefix = self.remove_central_bad_columns(\n data, header, prefix,\n )\n\n # Correct ZERO\n data, header, prefix = self.correct_zero(\n data, header, prefix, self.zero_file\n )\n\n # Correct DARK\n data, header, prefix = self.correct_dark(\n data, header, prefix, self.dark_file\n )\n\n # Remove cosmic rays and hot pixels\n data, header, prefix = self.remove_cosmic_rays(\n data, header, prefix, self.cosmic_rays\n )\n\n # Remove lateral glows\n data, header, prefix = self.correct_lateral_glow(\n data, header, prefix, self.glow_file\n )\n\n # Correct FLAT\n data, header, prefix = self.correct_flat(\n data, header, prefix, self.flat_file\n )\n\n # Normalize by the EXPOSURE TIME\n data, header, prefix = self.divide_by_exposuretime(\n data, header, prefix, self.time\n )\n\n # Clean known bad columns and lines\n data, header, prefix = self.clean_hot_columns_and_lines(\n data, header, prefix, self.clean\n )\n\n # Add WCS\n data, header = self.create_wcs(\n data, header\n )\n\n return data, header, prefix\n\n def clean_columns(self, data, header):\n \"\"\"\n Clean the known bad columns that exists in most of SAMI's, SOI's or\n SIFS's data. This method is meant to be overwritten via inheritance.\n\n Args:\n\n data (numpy.ndarray) : A 2D numpy array that contains the data.\n\n header (astropy.io.fits.Header) : A header that will be updated.\n\n See also:\n\n Reducer.clean_column\n Reducer.clean_line\n Reducer.clean_lines\n \"\"\"\n binning = header['CCDSUM'].split(' ')[0]\n binning = int(binning.strip())\n\n if binning == 4:\n bad_columns = [\n [167, 0, 513],\n [213, 513, 1023],\n [304, 0, 513],\n [309, 1, 512],\n [386, 0, 513],\n [476, 0, 513],\n [602, 0, 513],\n [671, 0, 513],\n [673, 475, 513],\n [678, 0, 513],\n [741, 0, 513],\n [810, 0, 513],\n [919, 0, 513],\n [212, 513, 1023],\n [680, 513, 1023],\n [725, 513, 1023],\n [848, 513, 1023],\n [948, 0, 512],\n [949, 0, 512]\n ]\n else:\n []\n\n for column in bad_columns:\n x0 = column[0]\n y0 = column[1]\n yf = column[2]\n data = self.clean_column(data, x0, y0, yf)\n\n return data\n\n def clean_lines(self, data, header):\n \"\"\"\n Clean the known bad lines that exists in most of SAMI's, SOI's or\n SIFS's data. This method is meant to be overwritten via inheritance.\n\n Args:\n\n data (numpy.ndarray) : A 2D numpy array that contains the data.\n\n header (astropy.io.fits.Header) : A header that will be updated.\n\n See also:\n\n Reducer.clean_column\n Reducer.clean_line\n Reducer.clean_lines\n \"\"\"\n binning = header['CCDSUM'].split(' ')[0]\n binning = int(binning.strip())\n\n if binning == 4:\n bad_lines = [\n [166, 206, 282],\n [212, 258, 689],\n [214, 239, 688],\n [304, 345, 291],\n [386, 422, 454],\n [398, 422, 38],\n [477, 516, 490],\n [387, 429, 455],\n [574, 603, 494],\n [574, 603, 493],\n [640, 672, 388],\n [604, 671, 388],\n [698, 746, 198],\n [706, 634, 634],\n [772, 812, 354],\n [900, 938, 426],\n [904, 920, 396]\n ]\n\n else:\n bad_lines = []\n\n for line in bad_lines:\n x0 = line[0]\n xf = line[1]\n y = line[2]\n data = self.clean_line(data, x0, xf, y)\n\n return data\n\n @staticmethod\n def remove_central_bad_columns(data, header, prefix):\n \"\"\"\n Remove central bad columns at the interface of the four extensions.\n\n Parameter\n ---------\n data : numpy.ndarray\n 2D Array containing the data.\n \"\"\"\n n_rows, n_columns = data.shape\n\n # Copy the central bad columns to a temp array\n temp_column = data[:, n_columns // 2 - 1:n_columns // 2 + 1]\n\n # Shift the whole image by two columns\n data[:, n_columns // 2 - 1:-2] = data[:, n_columns // 2 + 1:]\n\n # Copy the bad array in the end (right) of the image).\n data[:, -2:] = temp_column\n\n return data, header, prefix\n\n\nclass SifsReducer(SamiReducer):\n pass\n\n\nclass SoiReducer(Reducer):\n \"\"\"\n SoiReducer\n\n This class holds all the methods used to join the extensions within a\n FITS file obtained with SOI.\n\n Parameters\n ----------\n zero_file : str\n The filename of the master zero that will be used in subtraction.\n\n clean : bool\n Clean bad collumns by taking the _median value of the pixels around\n them.\n\n cosmic_rays : bool\n Clean cosmic rays using LACosmic package. See noted bellow for\n reference.\n\n dark_file : str\n Master Dark's filename to be used for dark subtraction.\n\n debug : bool\n Turn on debug mode with lots of printing.\n\n flat_file : str\n Master Flat filename to be used for normalization.\n\n glow_file : str\n Master file that contains the lateral glowings sometimes present in\n SAMI's data.\n\n time : bool\n Divide each pixel's values by the exposure time and update header.\n\n verbose : bool\n Turn on verbose mode (not so talktive as debug mode).\n\n See also\n --------\n LACosmic - http://www.astro.yale.edu/dokkum/lacosmic/\n \"\"\"\n\n @staticmethod\n def add_gap(data, header, interpolation_factor=10):\n \"\"\"\n SOI has two detectors which are separated by 7.8 arcsec (or 102\n unbinned pixels). This method reads an merged array and adds the gap\n based on the detector's binning.\n\n Parameters\n ----------\n data : numpy.ndarray\n 2D array with the data merged.\n\n header : astropy.io.fits.Header\n a header that contains the binning information on the 'CCDSUM'\n key.\n \"\"\"\n if header['OBSTYPE'] == 'OBJECT':\n\n binning = header['CCDSUM']\n binning = int(binning.split()[0])\n\n gap_size = 7.8 # arcseconds\n pixel_scale = 0.0767 # arcsecond / pixel\n gap_pixel = int(round(gap_size / pixel_scale / binning, 0))\n\n nrow, ncol = data.shape\n\n data = _np.append(data, _np.zeros((nrow, gap_pixel)), axis=1)\n data[:, ncol // 2 + gap_pixel:] = data[:, ncol // 2:- gap_pixel]\n data[:, ncol // 2:ncol // 2 + gap_pixel] = 0\n\n return data, header\n\n def clean_columns(self, _data, _header):\n \"\"\"\n Clean the known bad columns that exists in most of SAMI's data.\n\n Parameters\n ----------\n _data : numpy.ndarray\n A 2D numpy array that contains the data.\n\n _header : astropy.io.fits.Header\n a header that contains the binning information on the 'CCDSUM'\n key.\n\n See also\n --------\n SoiMerger.clean_column\n SoiMerger.clean_line\n SoiMerger.clean_lines\n \"\"\"\n if not isinstance(_data, _np.ndarray):\n raise (TypeError, 'Please, use a np.array as input')\n if _data.ndim is not 2:\n raise (TypeError, 'Data contains %d dimensions while it was '\n 'expected 2 dimensions.')\n\n b = int(_header['CCDSUM'].strip().split(' ')[0])\n\n if b == 1:\n bad_columns = []\n elif b == 2:\n bad_columns = [\n [855, 0, 2047],\n ]\n elif b == 4:\n bad_columns = [\n [427, 0, 1023]\n ]\n else:\n logger.warning(\n 'Skipping clean_columns for binning {} x {}'.format(b, b))\n bad_columns = []\n\n for column in bad_columns:\n x0 = column[0]\n y0 = column[1]\n yf = column[2]\n _data = self.clean_column(_data, x0, y0, yf)\n\n return _data\n\n def clean_lines(self, hdu_list):\n \"\"\"\n Clean the known bad lines that exists in most of SAMI's, SOI's or\n SIFS's data. This method is meant to be overwritten via inheritance.\n\n Args:\n\n hdu_list (astropy.io.fits.HDUList)\n\n See also:\n\n Reducer.clean_column\n Reducer.clean_line\n Reducer.clean_lines\n \"\"\"\n if not isinstance(hdu_list, _pyfits.HDUList):\n raise TypeError('Please, use a HDUList as input')\n\n if len(hdu_list) != 5:\n raise ValueError(\n \"HDUList is expected to have 1 + 4 elements. Found {}\".format(\n len(hdu_list)))\n\n for i in range(1, len(hdu_list)):\n\n _data = hdu_list[i].data\n _hdr = hdu_list[i].header\n\n bad_lines = [\n # [166, 206, 282],\n # [212, 258, 689],\n # [214, 239, 688],\n # [304, 345, 291],\n # [386, 422, 454],\n # [398, 422, 38],\n # [477, 516, 490],\n # [387, 429, 455],\n # [574, 603, 494],\n # [574, 603, 493],\n # [640, 672, 388],\n # [604, 671, 388],\n # [698, 746, 198],\n # [706, 634, 634],\n # [772, 812, 354],\n # [900, 938, 426],\n # [904, 920, 396]\n ]\n\n for line in bad_lines:\n x0 = line[0]\n xf = line[1]\n y = line[2]\n _data = self.clean_line(_data, x0, xf, y)\n\n hdu_list[i].data = _data\n\n return hdu_list\n\n\ndef _normalize_data(data):\n \"\"\"\n This method is intended to normalize flat data before it is applied to the\n images that are being reduced. A total of 1000 random points are used to\n estimate the _median level that will be used for normalization.\n\n Args:\n\n data (numpy.ndarray) : Data that will be normalized\n\n Returns:\n norm_data (numpy.ndarray) : Normalized data.\n \"\"\"\n sample = _np.random.randint(0, high=data.size - 1, size=1000)\n mode = stats.mode(data.ravel()[sample])[0]\n\n return data / mode\n", "meta": {"hexsha": "f789661476f6d1271cee57789463a040f2c9b594", "size": 34399, "ext": "py", "lang": "Python", "max_stars_repo_path": "soar_simager/data_reduction/reduce.py", "max_stars_repo_name": "soar-telescope/sami", "max_stars_repo_head_hexsha": "8a9e2b28e3e7d753d05220abd0bac6912fa36ad1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-04-09T21:57:27.000Z", "max_stars_repo_stars_event_max_datetime": "2020-04-09T21:57:27.000Z", "max_issues_repo_path": "soar_simager/data_reduction/reduce.py", "max_issues_repo_name": "soar-telescope/sami", "max_issues_repo_head_hexsha": "8a9e2b28e3e7d753d05220abd0bac6912fa36ad1", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2018-06-21T22:19:41.000Z", "max_issues_repo_issues_event_max_datetime": "2019-03-22T20:35:55.000Z", "max_forks_repo_path": "soar_simager/data_reduction/reduce.py", "max_forks_repo_name": "soar-telescope/sami", "max_forks_repo_head_hexsha": "8a9e2b28e3e7d753d05220abd0bac6912fa36ad1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.7857740586, "max_line_length": 80, "alphanum_fraction": 0.5343469287, "include": true, "reason": "import numpy,from scipy,from astropy", "num_tokens": 8515, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5273165233795671, "lm_q2_score": 0.3665897432423098, "lm_q1q2_score": 0.19330882891314297}} {"text": "# SVMs for Food Experiment Data\nimport matplotlib \nimport numpy as np\nimport matplotlib.pyplot as pp\nimport optparse\nimport unittest\nimport random\nimport itertools\nfrom sklearn import decomposition\nfrom sklearn import svm\nfrom sklearn.neighbors import KNeighborsClassifier\nfrom sklearn.model_selection import StratifiedKFold\nfrom sklearn.model_selection import cross_val_score\nfrom sklearn.model_selection import LeaveOneOut\nfrom sklearn.model_selection import KFold\nfrom sklearn.metrics import classification_report\nfrom sklearn.metrics import confusion_matrix\nfrom scipy.interpolate import InterpolatedUnivariateSpline\nfrom scipy.ndimage.filters import gaussian_filter1d\nimport sys\nimport lib_get_subset as lib_get_subset\nimport matplotlib.pyplot as plt\n\n\nTRIAL_ORDER = [[1, 4, 6, 2, 3, 7, 0, 5, 8],\n [0, 3, 6, 2, 5, 7, 1, 4, 8],\n [2, 3, 7, 1, 4, 6, 0, 5, 8],\n [2, 4, 6, 0, 5, 8, 1, 3, 7],\n [0, 5, 6, 1, 4, 7, 2, 3, 8],\n [1, 3, 8, 0, 4, 6, 2, 5, 7],\n [0, 4, 7, 1, 3, 8, 2, 5, 6],\n [2, 3, 8, 0, 4, 6, 1, 5, 7],\n [0, 3, 8, 2, 4, 6, 1, 5, 7],\n [1, 3, 6, 0, 5, 7, 2, 4, 8],\n [0, 5, 7, 1, 3, 8, 2, 4, 6],\n [1, 3, 8, 0, 4, 7, 2, 5, 6],\n [1, 5, 6, 0, 4, 7, 2, 3, 8],\n [1, 5, 8, 2, 4, 6, 0, 3, 7],\n [1, 5, 8, 2, 4, 6, 0, 3, 7],\n [1, 4, 6, 2, 5, 7, 0, 3, 8],\n [0, 4, 6, 2, 5, 8, 1, 3, 7],\n [2, 4, 7, 0, 5, 6, 1, 3, 8],\n [1, 5, 7, 0, 3, 6, 2, 4, 8],\n [2, 5, 7, 0, 4, 8, 1, 3, 6],\n [2, 5, 7, 1, 4, 6, 0, 3, 8],\n [0, 5, 7, 2, 3, 6, 1, 4, 8],\n [2, 4, 8, 0, 5, 6, 1, 3, 7],\n [2, 5, 7, 0, 4, 8, 1, 3, 6],\n [1, 3, 7, 2, 5, 8, 0, 4, 6],\n [2, 3, 8, 1, 5, 7, 0, 4, 6],\n [2, 3, 7, 0, 5, 8, 1, 4, 6],\n [1, 4, 7, 0, 5, 6, 2, 3, 8],\n [2, 5, 8, 1, 3, 6, 0, 4, 7],\n [1, 4, 8, 0, 5, 7, 2, 3, 6]]\n\nNUM_TRIAL_SETS = len(TRIAL_ORDER)\n\n\n\ndef get_most_overlapping(x_full, data_dict, num_pairs):\n\n matching_criteria = []\n\n for trial_set in range(len(TRIAL_ORDER)):\n optim_set = data_dict['trial_set_' + str(trial_set + 1) + '_X']\n print(\"trial set 1 shape\", optim_set.shape)\n\n for block in [0, 1, 2]:\n present_set = optim_set[block, :]\n for other_trial_set in range(len(TRIAL_ORDER)):\n if other_trial_set != trial_set:\n for CW_block in [6, 7, 8]:\n check_set = data_dict['trial_set_' + str(other_trial_set + 1) + '_X'][CW_block, :]\n #print(present_set)\n #print(check_set)\n matching_criteria.append([trial_set, block, other_trial_set, CW_block, np.sum(np.square(present_set - check_set))])\n\n #break\n\n\n #break\n\n matching_criteria = np.array(matching_criteria)\n\n matching_criteria = matching_criteria[matching_criteria[:,4].argsort()]\n #matching_criteria = np.flipud(matching_criteria)\n\n #for criteria in matching_criteria:\n # print(criteria)\n\n\n\n #matching_criteria = matching_criteria[0:num_pairs, :]\n\n #here make sure there arne't any duplicates in the list\n reduced_matching_criteria = []\n iterator = 0\n while len(reduced_matching_criteria) < num_pairs:\n next_criteria = matching_criteria[iterator, :]\n should_append = True\n print(next_criteria)\n for item in reduced_matching_criteria:\n if item[0] == next_criteria[0] and item[1] == next_criteria[1]:\n should_append = False\n if item[2] == next_criteria[2] and item[3] == next_criteria[3]:\n should_append = False\n if should_append == True:\n reduced_matching_criteria.append(next_criteria)\n iterator += 1\n\n matching_criteria = np.array(reduced_matching_criteria).astype(int)\n\n\n\n\n\n print(matching_criteria.astype(int))\n\n X_data = []\n y_data = []\n #Use matching criteria indexing to create data subsets that we can use for LOOCV\n for ct in range(num_pairs):\n trial_set = int(matching_criteria[ct, 0])\n block = int(matching_criteria[ct, 1])\n X_data.append(data_dict['trial_set_' + str(trial_set + 1) + '_X'][block, :])\n y_data.append(0)\n for ct in range(num_pairs):\n trial_set = int(matching_criteria[ct, 2])\n block = int(matching_criteria[ct, 3])\n X_data.append(data_dict['trial_set_' + str(trial_set + 1) + '_X'][block, :])\n y_data.append(1)\n X_data = np.array(X_data)\n y_data = np.array(y_data)\n\n # print(len(skf))\n # for train_index, test_index in skf:\n\n\n\n\n\n cm_total = np.zeros((2,2))\n\n #loo = LeaveOneOut(num_pairs)\n #for train_index, test_index in loo:\n\n for i in range(1000):\n kfold = KFold(n_splits=3, shuffle = True)\n kfold.get_n_splits(np.arange(num_pairs))\n for train_index, test_index in kfold.split(np.arange(num_pairs)):\n print(\"TRAIN:\", train_index, \"TEST:\", test_index)\n train_index_second = list(np.array(train_index) + num_pairs)\n train_index = np.array(list(train_index) + train_index_second)\n test_index_second = list(np.array(test_index) + num_pairs)\n test_index = np.array(list(test_index) + test_index_second)\n print(\"TRAIN:\", train_index, \"TEST:\", test_index)\n\n print(np.shape(X_data))\n\n X_train, X_test = X_data[train_index], X_data[test_index]\n print(np.shape(X_train))\n\n y_train, y_test = y_data[train_index], y_data[test_index]\n # print(X_test)\n # print(y_test)\n\n svc = svm.SVC(kernel='linear')\n # svc = svm.SVC(kernel='rbf')\n # svc = svm.SVC(kernel='poly', degree=3)\n clf = svc.fit(X_train, y_train)\n preds = svc.predict(X_test)\n\n print(y_test, preds)\n\n cm = confusion_matrix(y_test, preds, labels=[0, 1])\n\n scores = clf.score(X_test, y_test)\n\n #print(test_index, y_test, np.array(preds))\n cm_total += cm\n print(cm)\n print(cm_total)\n print(cm_total / 1000)\n\n '''\n ax=[]\n fig = plt.figure()\n print(np.shape(X_data))\n for trial_set in range(num_pairs):\n ax.append(trial_set)\n print(\"trial set num: \", trial_set)\n\n ax[-1] = fig.add_subplot(4, 5, trial_set+1)\n\n\n ax[-1].plot(np.arange(1000)/200., X_data[trial_set+num_pairs, :], 'r-', linewidth=0.5)\n ax[-1].plot(np.arange(1000)/200., X_data[trial_set, :], 'b-', linewidth=0.5)\n\n ax[-1].set_ylim(26.0, 30.0)\n ax[-1].set_xlim(0, 5)\n ax[-1].grid()\n\n plt.tight_layout()\n fig = plt.gcf()\n plt.show()\n '''\n\n\n\ndef get_meanstd_overlapping2(data_dict):\n\n\n print(\"GOT TO OVERLAPPING2\")\n\n X_data_all_M = []\n y_data_all_M = []\n X_data_all_CW = []\n y_data_all_CW = []\n X_data_all_W = []\n y_data_all_W = []\n\n for trial_set in range(len(TRIAL_ORDER)):\n optim_set = data_dict['trial_set_' + str(trial_set + 1) + '_X']\n print(\"trial set 1 shape\", optim_set.shape)\n\n for block in [0, 1, 2]:\n X_data_all_M.append(optim_set[block, :])\n y_data_all_M.append(0)\n\n for block in [3, 4, 5]:\n X_data_all_W.append(optim_set[block, :])\n y_data_all_W.append(1)\n\n\n for block in [6, 7, 8]:\n X_data_all_CW.append(optim_set[block, :])\n y_data_all_CW.append(1)\n\n\n\n\n X_data_all_M = np.array(X_data_all_M)\n X_data_all_CW = np.array(X_data_all_CW)\n X_data_all_W = np.array(X_data_all_W)\n print(X_data_all_M.shape)\n X_data_all_M_mean = np.mean(X_data_all_M, axis = 0)\n X_data_all_M_std = np.std(X_data_all_M, axis = 0)\n X_data_all_CW_mean = np.mean(X_data_all_CW, axis = 0)\n X_data_all_CW_std = np.std(X_data_all_CW, axis = 0)\n X_data_all_W_mean = np.mean(X_data_all_W, axis = 0)\n X_data_all_W_std = np.std(X_data_all_W, axis = 0)\n #print(X_data_all_M_mean.shape)\n #print(X_data_all_M_mean)\n #print(X_data_all_M_std)\n\n #print(X_data_all_M_mean - X_data_all_M_std)\n\n\n X_upper_bound = np.amin([X_data_all_CW_mean + X_data_all_CW_std, X_data_all_M_mean + X_data_all_M_std], axis = 0)\n X_lower_bound = np.amax([X_data_all_CW_mean - X_data_all_CW_std, X_data_all_M_mean - X_data_all_M_std], axis = 0)\n #print(\"BLAH\")\n #print(X_upper_bound)\n #print(X_lower_bound)\n #print(\"BLAH2\")\n\n\n fig, ax = plt.subplots()\n\n #ax.plot(np.arange(0, 1000)/200., X_data_all_M_mean[0:1000], color = '#d95f02', label=\"mean M, active\")\n #ax.plot(np.arange(0, 1000)/200., X_data_all_CW_mean[0:1000], '--', color = '#1b9e77', label=\"mean CW, active\")\n #ax.plot(np.arange(0, 1000)/200., X_data_all_W_mean[0:1000], '-.', color = '#7570b3', label=\"mean W, active\")\n #ax.fill_between(np.arange(0, 1000)/200.,\n # X_data_all_M_mean[0:1000] - X_data_all_M_std[0:1000],\n # X_data_all_M_mean[0:1000] + X_data_all_M_std[0:1000], facecolor='#d95f02', alpha = 0.3)\n #ax.fill_between(np.arange(0, 1000)/200.,\n # X_data_all_CW_mean[0:1000] - X_data_all_CW_std[0:1000],\n # X_data_all_CW_mean[0:1000] + X_data_all_CW_std[0:1000], facecolor='#1b9e77', alpha = 0.3)\n #ax.fill_between(np.arange(0, 1000)/200.,\n # X_data_all_W_mean[0:1000] - X_data_all_W_std[0:1000],\n # X_data_all_W_mean[0:1000] + X_data_all_W_std[0:1000], facecolor='#7570b3', alpha = 0.3)\n #ax.plot(np.arange(0, 1000)/200., X_lower_bound, 'c-')\n #ax.plot(np.arange(0, 1000)/200., X_upper_bound, 'c-')\n\n ax.plot(np.arange(0, 1000)/200., X_data_all_M_mean[1000:2000], color = '#d95f02', label=\"mean M, passive\")\n ax.plot(np.arange(0, 1000)/200., X_data_all_CW_mean[1000:2000], '--', color = '#1b9e77', label=\"mean CW, passive\")\n ax.plot(np.arange(0, 1000)/200., X_data_all_W_mean[1000:2000], '-.', color = '#7570b3', label=\"mean W, passive\")\n\n ax.fill_between(np.arange(0, 1000)/200.,\n X_data_all_M_mean[1000:2000] - X_data_all_M_std[1000:2000],\n X_data_all_M_mean[1000:2000] + X_data_all_M_std[1000:2000], facecolor='#d95f02', alpha = 0.3)\n ax.fill_between(np.arange(0, 1000)/200.,\n X_data_all_CW_mean[1000:2000] - X_data_all_CW_std[1000:2000],\n X_data_all_CW_mean[1000:2000] + X_data_all_CW_std[1000:2000], facecolor='#1b9e77', alpha = 0.3)\n ax.fill_between(np.arange(0, 1000)/200.,\n X_data_all_W_mean[1000:2000] - X_data_all_W_std[1000:2000],\n X_data_all_W_mean[1000:2000] + X_data_all_W_std[1000:2000], facecolor='#7570b3', alpha = 0.3)\n #ax.plot(np.arange(0, 1000)/200., X_lower_bound, 'c-')\n #ax.plot(np.arange(0, 1000)/200., X_upper_bound, 'c-')\n\n\n\n ax.legend(loc=3, fontsize=10)\n ax.set_title(\"Mean Temperature and \\n Standard Deviation Bounds\", fontsize=16)\n ax.set_xlabel(\"Time Elapsed (seconds)\", fontsize=14)\n ax.set_ylabel(\"Temperature, Celsius\", fontsize=14)\n plt.tight_layout()\n fig = plt.gcf()\n plt.show()\n\n\n X_data_all_M = list(X_data_all_M)\n X_data_all_CW = list(X_data_all_CW)\n\n X_data = []\n y_data = []\n\n #ax.plot(np.arange(0, 1000) / 200., X_data_all_mean + X_data_all_std, 'k-', label=\"mean\")\n for ct in range(len(X_data_all_M)):\n\n if np.min(X_upper_bound - X_data_all_M[ct]) > 0 and\\\n np.min(X_data_all_M[ct] - X_lower_bound) > 0:\n #ax.plot(np.arange(0, 1000) / 200., X_data_all[ct], 'r-', linewidth = 0.5)\n X_data.append(X_data_all_M[ct])\n y_data.append(y_data_all_M[ct])\n\n for ct in range(len(X_data_all_CW)):\n\n if np.min(X_upper_bound - X_data_all_CW[ct]) > 0 and\\\n np.min(X_data_all_CW[ct] - X_lower_bound) > 0:\n #ax.plot(np.arange(0, 1000) / 200., X_data_all[ct], 'r-', linewidth = 0.5)\n X_data.append(X_data_all_CW[ct])\n y_data.append(y_data_all_CW[ct])\n\n print(np.shape(X_data))\n print(np.shape(y_data))\n print(np.sum(y_data))\n\n #ax.legend()\n #plt.tight_layout()\n #fig = plt.gcf()\n #plt.show()\n\n X_data = np.array(X_data)\n y_data = np.array(y_data)\n\n from time import sleep\n sleep(4)\n\n cm_total = np.zeros((2,2))\n\n for i in range(1000):\n\n skf = StratifiedKFold(y_data, n_folds=3, shuffle=True)\n for train_index, test_index in skf:\n print(\"TRAIN:\", train_index, \"TEST:\", test_index)\n\n print(np.shape(X_data))\n\n X_train = X_data[train_index]\n X_test = X_data[test_index]\n print(np.shape(X_train))\n\n y_train, y_test = y_data[train_index], y_data[test_index]\n # print(X_test)\n # print(y_test)\n\n svc = svm.SVC(kernel='linear')\n # svc = svm.SVC(kernel='rbf')\n # svc = svm.SVC(kernel='poly', degree=3)\n clf = svc.fit(X_train, y_train)\n preds = svc.predict(X_test)\n\n print(y_test, preds)\n\n cm = confusion_matrix(y_test, preds, labels=[0, 1])\n\n scores = clf.score(X_test, y_test)\n\n #print(test_index, y_test, np.array(preds))\n cm_total += cm\n print(cm)\n print(cm_total)\n print(cm_total/1000)\n\n '''\n ax=[]\n fig = plt.figure()\n print(np.shape(X_data))\n for trial_set in range(num_pairs):\n ax.append(trial_set)\n print(\"trial set num: \", trial_set)\n\n ax[-1] = fig.add_subplot(4, 5, trial_set+1)\n\n\n ax[-1].plot(np.arange(1000)/200., X_data[trial_set+num_pairs, :], 'r-', linewidth=0.5)\n ax[-1].plot(np.arange(1000)/200., X_data[trial_set, :], 'b-', linewidth=0.5)\n\n ax[-1].set_ylim(26.0, 30.0)\n ax[-1].set_xlim(0, 5)\n ax[-1].grid()\n\n plt.tight_layout()\n fig = plt.gcf()\n plt.show()\n '''\ndef get_meanstd_overlapping(x_full, data_dict):\n\n X_data_all = []\n y_data_all = []\n\n for trial_set in range(len(TRIAL_ORDER)):\n optim_set = data_dict['trial_set_' + str(trial_set + 1) + '_X']\n print(\"trial set 1 shape\", optim_set.shape)\n\n for block in [0, 1, 2, 6, 7, 8]:\n X_data_all.append(optim_set[block, :])\n if block in [0, 1, 2]:\n y_data_all.append(0)\n else:\n y_data_all.append(1)\n\n X_data_all = np.array(X_data_all)\n print(X_data_all.shape)\n X_data_all_mean = np.mean(X_data_all, axis = 0)\n X_data_all_std = np.std(X_data_all, axis = 0)\n print(X_data_all_mean.shape)\n print(X_data_all_mean)\n print(X_data_all_std)\n\n print(X_data_all_mean - X_data_all_std)\n\n fig, ax = plt.subplots()\n\n ax.plot(np.arange(0, 1000)/200., X_data_all_mean, 'k-', label=\"mean\")\n ax.fill_between(np.arange(0, 1000)/200.,\n X_data_all_mean - X_data_all_std,\n X_data_all_mean + X_data_all_std)\n ax.legend()\n plt.tight_layout()\n fig = plt.gcf()\n plt.show()\n\n X_data_all = list(X_data_all)\n\n X_data = []\n y_data = []\n\n ax.plot(np.arange(0, 1000) / 200., X_data_all_mean + X_data_all_std, 'k-', label=\"mean\")\n for ct in range(len(X_data_all)):\n\n print(ct, np.shape(X_data_all_mean + X_data_all_std - X_data_all[ct]),\n np.min(X_data_all_mean + X_data_all_std - X_data_all[ct]),\n np.min(X_data_all[ct] + X_data_all_std - X_data_all_mean))\n\n if np.min(X_data_all_mean + X_data_all_std - X_data_all[ct]) > 0 and\\\n np.min(X_data_all[ct] - X_data_all_mean + X_data_all_std) > 0:\n #ax.plot(np.arange(0, 1000) / 200., X_data_all[ct], 'r-', linewidth = 0.5)\n X_data.append(X_data_all[ct])\n y_data.append(y_data_all[ct])\n\n print(np.shape(X_data))\n print(np.shape(y_data))\n print(np.sum(y_data))\n\n #ax.legend()\n #plt.tight_layout()\n #fig = plt.gcf()\n #plt.show()\n\n X_data = np.array(X_data)\n y_data = np.array(y_data)\n\n\n\n cm_total = np.zeros((2,2))\n\n for i in range(1000):\n\n skf = StratifiedKFold(y_data, n_folds=3, shuffle=True)\n for train_index, test_index in skf:\n print(\"TRAIN:\", train_index, \"TEST:\", test_index)\n\n print(np.shape(X_data))\n\n X_train = X_data[train_index]\n X_test = X_data[test_index]\n print(np.shape(X_train))\n\n y_train, y_test = y_data[train_index], y_data[test_index]\n # print(X_test)\n # print(y_test)\n\n svc = svm.SVC(kernel='linear')\n # svc = svm.SVC(kernel='rbf')\n # svc = svm.SVC(kernel='poly', degree=3)\n clf = svc.fit(X_train, y_train)\n preds = svc.predict(X_test)\n\n print(y_test, preds)\n\n cm = confusion_matrix(y_test, preds, labels=[0, 1])\n\n scores = clf.score(X_test, y_test)\n\n #print(test_index, y_test, np.array(preds))\n cm_total += cm\n print(cm)\n print(cm_total)\n print(cm_total/1000)\n\n '''\n ax=[]\n fig = plt.figure()\n print(np.shape(X_data))\n for trial_set in range(num_pairs):\n ax.append(trial_set)\n print(\"trial set num: \", trial_set)\n\n ax[-1] = fig.add_subplot(4, 5, trial_set+1)\n\n\n ax[-1].plot(np.arange(1000)/200., X_data[trial_set+num_pairs, :], 'r-', linewidth=0.5)\n ax[-1].plot(np.arange(1000)/200., X_data[trial_set, :], 'b-', linewidth=0.5)\n\n ax[-1].set_ylim(26.0, 30.0)\n ax[-1].set_xlim(0, 5)\n ax[-1].grid()\n\n plt.tight_layout()\n fig = plt.gcf()\n plt.show()\n '''\n\n\ndef get_overlapping_reference(x_full, data_dict, num_referenced):\n\n matching_criteria = []\n\n #get set of all possible pairs of RMSE scores\n for trial_set in range(len(TRIAL_ORDER)):\n optim_set = data_dict['trial_set_' + str(trial_set + 1) + '_X']\n print(\"trial set 1 shape\", optim_set.shape)\n for block in [0, 1, 2]:\n present_set = optim_set[block, :]\n for other_trial_set in range(len(TRIAL_ORDER)):\n if other_trial_set != trial_set:\n for CW_block in [6, 7, 8]:\n check_set = data_dict['trial_set_' + str(other_trial_set + 1) + '_X'][CW_block, :]\n #print(present_set)\n #print(check_set)\n matching_criteria.append([trial_set, block, other_trial_set, CW_block, np.sum(np.square(present_set - check_set))])\n\n\n\n matching_criteria = np.array(matching_criteria)\n matching_criteria = matching_criteria[matching_criteria[:,4].argsort()]\n #matching_criteria = np.flipud(matching_criteria)\n\n\n referenced_pair = matching_criteria[0, :]\n print(referenced_pair)\n\n\n #get set of nearest metals to the metal\n matching_M_criteria = []\n M_trial_set = int(referenced_pair[0])\n M_block = int(referenced_pair[1])\n present_set = data_dict['trial_set_' + str(M_trial_set + 1) + '_X'][M_block, :]\n for other_trial_set in range(len(TRIAL_ORDER)):\n for other_block in [0, 1, 2]:\n if other_trial_set == M_trial_set and other_block == M_block: pass\n else:\n check_set = data_dict['trial_set_' + str(other_trial_set + 1) + '_X'][other_block, :]\n matching_M_criteria.append([other_trial_set, other_block, np.sum(np.square(present_set - check_set))])\n matching_M_criteria = np.array(matching_M_criteria)\n matching_M_criteria = matching_M_criteria[matching_M_criteria[:,2].argsort()]\n\n print(matching_M_criteria[0:num_referenced-1, :])\n\n\n #get set of nearest cold woods to the cold wood\n matching_CW_criteria = []\n CW_trial_set = int(referenced_pair[2])\n CW_block = int(referenced_pair[3])\n present_set = data_dict['trial_set_' + str(CW_trial_set + 1) + '_X'][CW_block, :]\n for other_trial_set in range(len(TRIAL_ORDER)):\n for other_block in [6, 7, 8]:\n if other_trial_set == CW_trial_set and other_block == CW_block: pass\n else:\n check_set = data_dict['trial_set_' + str(other_trial_set + 1) + '_X'][other_block, :]\n matching_CW_criteria.append([other_trial_set, other_block, np.sum(np.square(present_set - check_set))])\n matching_CW_criteria = np.array(matching_CW_criteria)\n matching_CW_criteria = matching_CW_criteria[matching_CW_criteria[:,2].argsort()]\n\n print(matching_CW_criteria[0:num_referenced-1, :])\n\n\n\n\n print(matching_criteria.astype(int))\n\n\n #Use matching criteria indexing to create data subsets that we can use for LOOCV\n X_data = []\n y_data = []\n trial_set = int(referenced_pair[0])\n block = int(referenced_pair[1])\n X_data.append(data_dict['trial_set_' + str(trial_set + 1) + '_X'][block, :])\n y_data.append(0)\n for ct in range(num_referenced-1):\n trial_set = int(matching_M_criteria[ct, 0])\n block = int(matching_M_criteria[ct, 1])\n X_data.append(data_dict['trial_set_' + str(trial_set + 1) + '_X'][block, :])\n y_data.append(0)\n\n\n trial_set = int(referenced_pair[2])\n block = int(referenced_pair[3])\n X_data.append(data_dict['trial_set_' + str(trial_set + 1) + '_X'][block, :])\n y_data.append(1)\n for ct in range(num_referenced-1):\n trial_set = int(matching_CW_criteria[ct, 0])\n block = int(matching_CW_criteria[ct, 1])\n X_data.append(data_dict['trial_set_' + str(trial_set + 1) + '_X'][block, :])\n y_data.append(1)\n\n X_data = np.array(X_data)\n y_data = np.array(y_data)\n\n print(y_data)\n\n # print(len(skf)\n # for train_index, test_index in skf:\n\n\n cm_total = np.zeros((2,2))\n\n #loo = LeaveOneOut(num_pairs)\n #for train_index, test_index in loo:\n\n\n for i in range(1000):\n\n skf = StratifiedKFold(y_data, n_folds=3, shuffle=True)\n for train_index, test_index in skf:\n print(\"TRAIN:\", train_index, \"TEST:\", test_index)\n\n print(np.shape(X_data))\n\n X_train, X_test = X_data[train_index], X_data[test_index]\n print(np.shape(X_train))\n\n y_train, y_test = y_data[train_index], y_data[test_index]\n # print(X_test)\n # print(y_test)\n\n svc = svm.SVC(kernel='linear')\n # svc = svm.SVC(kernel='rbf')\n # svc = svm.SVC(kernel='poly', degree=3)\n clf = svc.fit(X_train, y_train)\n preds = svc.predict(X_test)\n\n print(y_test, preds)\n\n cm = confusion_matrix(y_test, preds, labels=[0, 1])\n\n scores = clf.score(X_test, y_test)\n\n #print(test_index, y_test, np.array(preds))\n cm_total += cm\n print(cm)\n print(cm_total)\n print(cm_total/1000)\n #[[6.234 3.766]\n # [3.221 6.779]]\n\n\n\n '''\n ax=[]\n fig = plt.figure()\n print(np.shape(X_data))\n for trial_set in range(num_pairs):\n ax.append(trial_set)\n print(\"trial set num: \", trial_set)\n\n ax[-1] = fig.add_subplot(4, 5, trial_set+1)\n\n\n ax[-1].plot(np.arange(1000)/200., X_data[trial_set+num_pairs, :], 'r-', linewidth=0.5)\n ax[-1].plot(np.arange(1000)/200., X_data[trial_set, :], 'b-', linewidth=0.5)\n\n ax[-1].set_ylim(26.0, 30.0)\n ax[-1].set_xlim(0, 5)\n ax[-1].grid()\n\n plt.tight_layout()\n fig = plt.gcf()\n plt.show()\n '''", "meta": {"hexsha": "e85a52506cfa37f37762356fe91944432938664d", "size": 23496, "ext": "py", "lang": "Python", "max_stars_repo_path": "robot_study/lib_overlapping.py", "max_stars_repo_name": "Healthcare-Robotics/thermal-ambiguity-ToH", "max_stars_repo_head_hexsha": "70dbe35c6096b3793ed0565656d6ff2a30fdcf5a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "robot_study/lib_overlapping.py", "max_issues_repo_name": "Healthcare-Robotics/thermal-ambiguity-ToH", "max_issues_repo_head_hexsha": "70dbe35c6096b3793ed0565656d6ff2a30fdcf5a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "robot_study/lib_overlapping.py", "max_forks_repo_name": "Healthcare-Robotics/thermal-ambiguity-ToH", "max_forks_repo_head_hexsha": "70dbe35c6096b3793ed0565656d6ff2a30fdcf5a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.517831669, "max_line_length": 139, "alphanum_fraction": 0.5896748383, "include": true, "reason": "import numpy,from scipy", "num_tokens": 7024, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5273165233795671, "lm_q2_score": 0.3665897363221599, "lm_q1q2_score": 0.1933088252640336}} {"text": "#!/urs/bin/env python\n# -*- coding: utf-8 -*-\n\"\"\"/stations.py\nAuthor: Hunter Mellema\nSummary: Defines measuring stations for simulation for CR3BP navigation simulations\nProject: Advanced State Estimation Final Project\nAuthor: Hunter Mellema\nDate: April 2020\n\"\"\"\n# === Begin Imports ===\n# third party\nimport numpy as np\nfrom numpy.linalg import norm\n\n# local imports\nfrom .constants import (\n THETA_0,\n R_E,\n W_E_ND,\n R_E_ND,\n EARTH_ANG_VEL_ND,\n NON_DIM_DIST_TO_DIM,\n MU_EARTH_MOON,\n E_M_OFFSET_ANGLE, \n OMEGA_CR3BP, \n CR3BP_ANG_VEL\n)\nfrom .measurements import R3Msr, Range\n\n# std library\nimport json\n\n# === End Imports ===\n\n# Measurement Generation Functions\nclass CR3BPEarthStn(object):\n \"\"\" Represents a ground station at some point on the earth's surface that is taking measurements\n of a spacecraft.\n Args:\n stn_id (str, int): a unique string or integer id for the given station\n longitude (float): longitude of the station position in degrees\n latitude (float): latitude of the station in degrees\n el_mask (float): elevation below which the station will not take measurements (in degrees)\n covariance (np.ndarray): covariance for measurements take by this station. Will be added to\n every measurement taken by this station\n\n \"\"\"\n\n def __init__(\n self,\n stn_name,\n stn_id,\n pos_ecef_nd,\n el_mask,\n cov,\n msrs,\n mu,\n lat=None,\n longitude=None,\n el=None,\n ):\n self.stn_name = stn_name\n self.stn_id = stn_id\n self.pos = pos_ecef_nd\n self.el_mask = el_mask\n self.cov = cov\n self.allowed_msrs = msrs\n self.lat = lat\n self.long = longitude\n self.el = el\n self.mu = mu\n\n @classmethod\n def from_db_object(cls, station_data):\n \"\"\" Constructs a stn from a row in the database\n \n Args: \n station_data (dict): dicitonary representing a row in the stations table\n\n Return: \n cls\n\n \"\"\"\n pos_nd = lat_long_to_ecef(\n station_data[\"latitude_deg\"],\n station_data[\"longitude_deg\"],\n station_data[\"elevation_km\"],\n ) * (1 / NON_DIM_DIST_TO_DIM)\n\n return cls(\n station_data[\"stn_name\"],\n station_data[\"stn_id\"],\n pos_nd,\n station_data[\"elevation_mask_deg\"],\n json.loads(station_data[\"covariance\"]),\n json.loads(station_data[\"measurement_types\"]),\n station_data[\"mu\"],\n station_data[\"latitude_deg\"],\n station_data[\"longitude_deg\"],\n station_data[\"elevation_km\"],\n )\n\n def __repr__(self):\n string = \"\"\"\n ==================================================\n ++++++++++++++++++++++++++++++++++++++++++++++++++\n STN: {} | STN ID: {}\n ++++++++++++++++++++++++++++++++++++++++++++++++++\n Position: \n {} (Nondimensional CR3BP)\n Location (lat, long, el): \n {} deg N, {} deg E, {} Km,\n Elevation Mask: {} deg\n Measurement Covariance: {}\n ==================================================\n \"\"\".format(\n self.stn_name,\n self.stn_id,\n self.pos,\n self.lat,\n self.long,\n self.el,\n self.el_mask,\n self.cov,\n )\n\n return string\n\n def gen_msr(self, sc_state, time, msr_type=\"R3Msr\"):\n \"\"\"Generates a measurement if the spacecraft is visible\n\n Args:\n sc_state (np.ndarray): spacecraft state vector, pos, vel must be first 6 terms\n time (float): time since reference epoch\n msr_type (str): name of measurement to use (default = R3 (range and range rate))\n\n Returns:\n tuple(bool, float, np.ndarray)\n\n \"\"\"\n valid, el, stn_state = self._check_elevation(sc_state, time)\n if valid:\n return globals()[msr_type].from_stn(\n time, sc_state, stn_state, self.stn_id, self.cov\n )\n else:\n return None\n\n def _check_elevation(self, sc_state, time):\n \"\"\"Checks to see if the spacecraft is visible\n\n Args:\n sc_state (np.ndarray): spacecraft state vector, pos, vel must be first 6 terms\n time (float): time since reference epoch\n\n Returns:\n tuple(bool, float, np.ndarray)\n\n \"\"\"\n stn_state_ns = self.state(time, include_shift=False)\n stn_state_shift = stn_state_ns + np.array([self.mu, 0.0, 0.0, 0.0, 0.0, 0.0])\n line_o_sight = sc_state[0:3] - stn_state_shift[0:3]\n num = np.dot(stn_state_ns[0:3], line_o_sight)\n denom = np.linalg.norm(stn_state_ns[0:3]) * np.linalg.norm(line_o_sight)\n zenel = np.arccos(num / denom)\n el = np.pi / 2 - zenel\n\n if el > np.deg2rad(self.el_mask):\n flag = True\n else:\n flag = False\n\n return (flag, el, stn_state_shift)\n\n def state(self, time_nd, include_shift=True):\n \"\"\"Finds the station state in ECI at a given nondimensional CR3BP time\n\n Args:\n time_nd (float): non-dimensional CR3BP time past reference epoch\n\n Returns:\n np.ndarray([1x6])\n\n \"\"\"\n rot_mat_ecef_eci = ecef_to_eci_nd(time_nd)\n rot_mat_eci_cr3bp = eci_to_cr3bp(time_nd)\n pos_eci = rot_mat_ecef_eci @ self.pos\n pos_cr3bp = rot_mat_eci_cr3bp @ pos_eci\n \n if include_shift:\n pos_cr3bp = pos_cr3bp + np.array([self.mu, 0.0, 0.0])\n\n vel_ecef = np.cross(EARTH_ANG_VEL_ND.T, self.pos.T).T\n vel_eci = rot_mat_ecef_eci @ vel_ecef\n vel_cr3bp_no_cr3bp_and_vel = rot_mat_eci_cr3bp @ vel_eci\n coriolis = np.cross(CR3BP_ANG_VEL.T, pos_cr3bp.T).T\n vel_cr3bp = vel_cr3bp_no_cr3bp_and_vel + coriolis\n\n state = np.concatenate((pos_cr3bp.T[0], vel_cr3bp.T[0]))\n\n return state\n\n\ndef lat_long_to_ecef(latitude, longitude, elevation):\n \"\"\"Converts from latituted-longitude to cartesian position in ECEF\n Note: Assumes location is on the surface of the earth and uses a spherical\n earth model\n\n Args:\n latitude (float): latitude to convert (in degrees)\n longitude (float): longitude to convert (in degrees)\n elevation (float): elevation above spherical model (in km)\n\n Returns:\n np.ndarray([3x3])\n\n \"\"\"\n phi = np.deg2rad(latitude)\n lam = np.deg2rad(longitude)\n\n pos_ecef = (R_E + elevation) * np.array(\n [[np.cos(phi) * np.cos(lam)], [np.cos(phi) * np.sin(lam)], [np.sin(phi)]]\n )\n\n return pos_ecef\n\n\ndef ecef_to_eci_nd(time_nd, theta_0=THETA_0):\n \"\"\"Calculates rotation matrix to ECI at a given time\n Args:\n time_nd (float): nondimensional time since reference epoch\n theta_0 (float): initial rotation of the earth at the reference epoch\n [default=filtering.THETA_0]\n Returns:\n np.ndarray([3x3])\n \"\"\"\n alpha = theta_0 + time_nd * W_E_ND\n rot_mat = np.array(\n [\n [np.cos(alpha), -np.sin(alpha), 0],\n [np.sin(alpha), np.cos(alpha), 0],\n [0, 0, 1],\n ]\n )\n\n return rot_mat\n\n\ndef eci_to_cr3bp(time_nd):\n \"\"\"Calculates rotation matrix from ECI to CR3BP at a given nondimensional time\n\n Args:\n time_nd (float): nondimensional time since reference epoch\n\n Returns:\n np.ndarray([3x3])\n\n \"\"\"\n axis_north_pole = np.array([\n np.sin(-E_M_OFFSET_ANGLE) * np.cos(time_nd * OMEGA_CR3BP), \n np.sin(-E_M_OFFSET_ANGLE) * np.sin(time_nd * OMEGA_CR3BP), \n np.cos(-E_M_OFFSET_ANGLE)\n ])\n z_axis = np.array([0.0, 0.0, 0.1])\n rot = rotate_plane(z_axis, axis_north_pole)\n\n return rot\n\n\ndef unitcross(a, b): \n c = np.cross(a, b)\n return c / norm(c)\n\ndef costheta(a, b): \n return np.dot(a, b) / (norm(a) * norm(b))\n\ndef rotate_plane(M, N): \n (x, y, z) = unitcross(M, N)\n c = costheta(M, N)\n s = np.sqrt(1-c*c)\n C = 1-c\n rmat = np.array(\n [\n [ x * x * C + c, x * y * C - z * s, x * z * C + y * s],\n [ y * x * C + z * s, y * y * C + c, y * z * C - x * s],\n [ z * x * C - y * s, z * y * C + x * s, z * z * C + c]\n ]\n )\n\n return rmat", "meta": {"hexsha": "82e2871d52273b0825919c79d36677422e7324fd", "size": 8365, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/simulation/stations.py", "max_stars_repo_name": "mellemahp/cr3bp_nav", "max_stars_repo_head_hexsha": "9321cfbcc57b20171777897951822edd9d543bd0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/simulation/stations.py", "max_issues_repo_name": "mellemahp/cr3bp_nav", "max_issues_repo_head_hexsha": "9321cfbcc57b20171777897951822edd9d543bd0", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/simulation/stations.py", "max_forks_repo_name": "mellemahp/cr3bp_nav", "max_forks_repo_head_hexsha": "9321cfbcc57b20171777897951822edd9d543bd0", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.8448275862, "max_line_length": 100, "alphanum_fraction": 0.5655708308, "include": true, "reason": "import numpy,from numpy", "num_tokens": 2202, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5273165233795671, "lm_q2_score": 0.36658972248186006, "lm_q1q2_score": 0.19330881796581478}} {"text": "#!/usr/bin/env python\r\n# -*- coding: utf-8 -*-\r\n\r\n\r\n\r\n################################################## ##############################\r\n######################### List of implemented limits #########################\r\n######################### ######################### #############################\r\n\r\n### Define a class to store all the relevant data about the external limits \r\n### as well as the way of recasting them to the fermion portal case. Then loads all the implemented exeternal limits\r\n\r\n\r\n### L. Darme, S. Ellis, T. You, 29/12/2019\r\n\r\n\r\n\r\n\r\n############################ Messy library import part #########################\r\nimport numpy as np\r\n\r\n# Importing the other sub-Modules\r\n\r\nimport UsefulFunctions as uf\r\nimport Production as br\r\nimport Detection as de\r\n\r\nverbose=True\r\n\r\n\r\nclass Limit:\r\n \"\"\"\r\n Contain the informations to recast a given experimental limit\r\n \r\n exp: The experiment associated to the limit\r\n \r\n channel: The type of limit (e.g MissingE, Decay ...)\r\n \r\n descr: Any relevant additional details on the limit \r\n \r\n ref: The Inspire reference for the limit\r\n \r\n mx_ini: The range of Mx value on which the limit is relevant (by convention \r\n this is typically the mass of the lower state X1 in case there is\r\n two dark sector states, such as for decay limits)\r\n \r\n lim_ini: The actual limit (typically from a dark photon model)\r\n \r\n lim_inilist: Dictionnary with the initial limits stored in (mx, lim) list for different operator in case they exist ( \"V\" and \"AV\")\r\n \"\"\"\r\n\r\n def __init__(self, name, exp, channel, Delini,interptype=\"log\"):\r\n self.exp = exp\r\n self.channel = channel\r\n self.delini = Delini\r\n self.descr = \"No description for this limit\"\r\n self.ref = \"No reference for this limit\"\r\n self.combthr=1.1 # Standard value used when relevant to combine the upper and lower limit \r\n try: \r\n self.name = name\r\n self.mx_ini, self.lim_ini = uf.LoadData('LimData/'+name+'.dat',interptype) \r\n# if verbose: print(\"Loading: \", self.name,self.lim_ini ) \r\n except: \r\n self.name = \"NotDefined\"\r\n self.mx_ini = np.logspace(-3., 1., 30.)\r\n self.lim_ini = np.zeros(np.shape(self.mx_ini )) \r\n\r\n try: \r\n self.model = model\r\n except: \r\n self.model = \"No model for this limit\"\r\n \r\n self.lim_inifull = {\"V\":(self.mx_ini,self.lim_ini),\"AV\":(self.mx_ini,self.lim_ini)}\r\n \r\n def UpdateLimIni(self,mx,lim,optype=\"V\"): \r\n# print(optype,(mx,lim)) \r\n self.lim_inifull.update({optype:(mx,lim)})\r\n if optype==\"V\":\r\n self.lim_ini = lim\r\n self.mx_ini = mx\r\n \r\n \r\n def recast(self,delrec, geff, optype,useHeavyMeson=False):\r\n # we define the recast based on the expected signal\r\n \r\n if self.channel == \"decay\":\r\n if self.model == \"EFT\": # For naive NoE based limits\r\n xi,EffLimtmp = de.GetNaiveDecayLimits( delrec, self.exp ,10,geff,optype)\r\n xi,EffLim,EffLim_low = de.RecastDecayLimit(xi, EffLimtmp, delrec,delrec,self.exp,geff,optype)\r\n xi_full, Lim_full=uf.CombineUpDown(xi,EffLim_low,EffLim,self.combthr) \r\n else: # Standard recasting case\r\n xi_full, Lim_full=de.FastDecayLimit(self.exp,self.mx_ini, self.lim_ini , self.delini, delrec, geff, optype,self.combthr,useHeavyMeson)\r\n elif self.channel == \"heavymesondecay\": \r\n if self.model == \"EFT\":\r\n xi,EffLimtmp = de.GetNaiveDecayLimits( delrec, self.exp ,10,geff,optype,True)\r\n xi_heavy,EffLim_heavy,EffLim_heavy_low = de.RecastDecayLimit(xi,EffLimtmp , delrec,delrec,self.exp,geff,optype,True)\r\n xi_full, Lim_full=uf.CombineUpDown(xi_heavy,EffLim_heavy_low,EffLim_heavy,self.combthr)\r\n else:\r\n xi_full, Lim_full=de.FastDecayLimit(self.exp,self.mx_ini, self.lim_ini , self.delini, delrec, geff, optype,self.combthr,useHeavyMeson)\r\n elif self.channel==\"scattering\":\r\n xi_full, Lim_full=de.FastScatLimit(self.exp,self.mx_ini, self.lim_ini , self.delini,delrec, geff, optype)\r\n elif self.channel==\"monogam\":\r\n xi_full, Lim_full=de.FastMonoPhoton(self.exp,self.mx_ini, self.lim_ini , self.delini,delrec, geff, optype)\r\n elif self.channel==\"invisibledecayBmtoKm\":\r\n if self.exp == \"babar\":\r\n xi_full, Lim_full= de.FastInvMesDecay(\"babar_BmtoKmnunu\",delrec, geff, optype)\r\n elif self.exp == \"belle2\":\r\n xi_full, Lim_full= de.FastInvMesDecay(\"belle2_BmtoKmnunu\",delrec, geff, optype)\r\n elif self.channel==\"invisibledecayBmtoPim\":\r\n xi_full, Lim_full= de.FastInvMesDecay(\"babar_BmtoPimnunu\",delrec, geff, optype)\r\n elif self.channel == \"invisibledecayB0toPi0\":\r\n xi_full, Lim_full= de.FastInvMesDecay(\"belle_B0toPi0nunu\",delrec, geff, optype)\r\n elif self.channel == \"invisibledecayB0toK0\":\r\n xi_full, Lim_full= de.FastInvMesDecay(\"belle_B0toK0nunu\",delrec, geff, optype)\r\n elif self.channel==\"monojet_down\":\r\n xi_full, Lim_full = de.FastMonoJet(self.exp,self.mx_ini, self.lim_ini , self.delini,delrec, geff, optype)\r\n elif self.channel==\"monojet_up\":\r\n xi_full, Lim_full = de.FastMonoJet(self.exp,self.mx_ini, self.lim_ini , self.delini,delrec, geff, optype)\r\n elif self.channel == \"invisibledecayKL0toPi0\":\r\n if self.exp == \"e391a\":\r\n xi_full, Lim_full= de.FastInvMesDecay(\"e391a_KL0toPi0nunu\",delrec, geff, optype)\r\n if self.exp == \"na62\":\r\n xi_full, Lim_full= de.FastInvMesDecay(\"na62_KL0toPi0nunu\",delrec, geff, optype)\r\n elif self.channel == \"invisibledecayPi0\":\r\n xi_full, Lim_full= de.FastInvMesDecay(\"na62_pi0toinvisible\",delrec, geff, optype)\r\n elif self.channel == \"invisibledecayJPsi\":\r\n xi_full, Lim_full= de.FastInvMesDecay(\"bes_JPsitoinvisible\",delrec, geff, optype)\r\n elif self.channel == \"invisibledecayUpsilon\":\r\n xi_full, Lim_full= de.FastInvMesDecay(\"babar_Upsilontoinvisible\",delrec, geff, optype) \r\n elif self.channel == \"invisibledecayKptoPip\":\r\n if self.exp == \"na62\":\r\n xi_full, Lim_full= de.FastInvMesDecay(\"na62_KptoPipa\",delrec, geff, optype) \r\n elif self.exp == \"e949\":\r\n xi_full, Lim_full= de.FastInvMesDecay(\"e949_KptoPipa\",delrec, geff, optype) \r\n elif self.channel == \"cosmicrays\":\r\n xi_full, Lim_low_full, Lim_high_full = de.FastCRLimit(\"t2k\", delrec, geff,optype)\r\n xi_full, Lim_full = uf.CombineUpDown(xi_full, Lim_low_full, Lim_high_full)\r\n elif self.channel == \"low_cooling\": \r\n xi_full, Lim_full= de.FastSN1987Limit(self.lim_inifull ,delrec, geff, optype,False)\r\n elif self.channel == \"high_cooling\": \r\n xi_full, Lim_full= de.FastSN1987Limit( self.lim_inifull ,delrec, geff, optype,True)\r\n else:\r\n print(\"Channel selected: \", self.channel, \" is not currently implemented. Possible choices: \\n\",\r\n \"'decay' : faser, mathusla, ship, charm, seaquest, seaquest_Phase2, lsnd \\n\",\r\n \"heavymesondecay : ship\"\r\n \"'scattering' : nova, miniboone, sbnd \\n\",\r\n \"'missingE' : babar, belleII, atlas, lep \\n\",\r\n \"'cosmicrays' : t2k (decay from cosmic ray showers into t2k), \",\r\n \"cooling : for sn1987_low (pessimistic limit from SN1987 cooling), sn1987_high (optimistic limit from SN1987 cooling) \",\r\n \"Invisible light meson decays: na62 (pi0decay and invisibledecayKptoPip) e949 (pi0decay and invisibledecayKptoPip), e391a (invisibledecayKL0toPi0)\",\r\n \"Invisible heavy meson decay: belle (invisibledecayB0toPi0 ,invisibledecayB0toK0) and belleII (invisibledecayBmtoKm)\")\r\n xi_full= np.logspace(-3., 1., 30.);\r\n Lim_full =np.zeros(np.shape(xi_full)) \r\n return xi_full,Lim_full \r\n\r\nAllLimits={} # Dictionnary for all the limits\r\n \r\ndef UpdateLimitList(limit,name=\"noname\"):\r\n \r\n if name==\"noname\":\r\n name=limit.exp+ \"_\"+limit.channel # We fill up the name automatically if not given\r\n\r\n if name in AllLimits: # Making a new limits if one already existing for the same \r\n# print(\"Test:\", name, AllLimits)\r\n i = 1\r\n name_new=name+\"_\"+str(i)\r\n while (name_new in AllLimits):\r\n i += 1\r\n name_new=name+\"_\"+str(i)\r\n name=name_new\r\n AllLimits.update({name:limit})\r\n\r\n\r\n## This function runs over a list of experiments and search channels,\r\n## compute the recasted bound, print it to file and return everything in a dictionnary with a list of label\r\n## Note that it can also just read an external file and use it directly as the limit\r\n\r\ndef GetLimits(LimList,Del,geff,optype=\"V\",PrintToFile = False, ReadFromFile=False, filename=''):\r\n \r\n Res = {}\r\n LabelLimit = []\r\n\r\n # Making sure the input for the effective couplings is okay\r\n if type(geff) is dict:\r\n ge=geff\r\n else:\r\n if np.ndim(geff[0]) >0:\r\n geffdiag=(geff[0][0][0],geff[1][0][0],geff[2][0][0]) \r\n gMesDecay=(geff[1][2][1],geff[1][2][1],geff[1][2][0],geff[1][2][0],geff[1][1][0],geff[1][1][0]) # gd32, gd32,gd31,gd31,gd21,gd21\r\n else:\r\n geffdiag= geff\r\n gMesDecay=(0,0,0,0,0,0)\r\n ge={\"gu11\":geffdiag[0],\"gd11\":geffdiag[1],\"gl11\":geffdiag[2],\"gl22\":geffdiag[2] \\\r\n ,\"gd32\":gMesDecay[0],\"gd31\":gMesDecay[2],\"gd21\":gMesDecay[4]}#We make the couping a dictionnary to have more freedom\r\n\r\n resultsDict = {} #e.g. {\"exp1_channel1\":(mxlist, limlist), \"exp2_channel2\":{mxlist, limlist}, ... }\r\n expchannelList = [] #e.g. [\"exp1_channel1\", \"exp2_channel2\", etc.]\r\n\r\n for expchannel in LimList: \r\n if not expchannel in AllLimits:\r\n print( \"Selected limit \" + expchannel +\" not available, choose from: \", AllLimits.keys())\r\n# raise Exception()\r\n else:\r\n if ReadFromFile: \r\n if filename == '': \r\n filestr = 'Output/Lim_'+expchannel+\".dat\"\r\n else:\r\n filestr = filename\r\n filedat = np.loadtxt(filestr)\r\n Mx, LamLim = np.transpose(filedat)\r\n else: \r\n #print(exp, channel)\r\n \r\n Mx, LamLim = AllLimits[expchannel].recast(Del,ge,optype)\r\n \r\n \r\n expchannelList.append(expchannel)\r\n resultsDict[expchannel] = (Mx,LamLim)\r\n \r\n if PrintToFile:\r\n if filename == '':\r\n filestr = 'Output/Lim_'+expchannel+\".dat\"\r\n else: \r\n filestr = filename\r\n np.savetxt(filestr, np.transpose(resultsDict[expchannel]))\r\n\r\n return resultsDict, expchannelList \r\n \r\n\r\n\r\n################################################## #########################\r\n######################### #########################\r\n######################### Loading external limits #########################\r\n######################### #########################\r\n######################### ######################### #########################\r\n\r\ngeffem={\"gu11\":2/3.,\"gd11\":-1/3.,\"gl11\":-1.}\r\n\r\nprint(\"Loading limits:\")\r\n\r\n######################### Scattering #########################\r\nif verbose: print(\"Scattering ...\")\r\n\r\nminiboone_scattering=Limit(\"miniboone_1807.06137\",\"miniboone\",\"scattering\",0.)\r\nminiboone_scattering.descr=\"\"\"\r\nLimits from MiniBooNE collaboration for light dark matter scattering, produced at the beam dump. \r\n\r\nExtracted from Figure 24.a, the data is given as epsilon^2, for alpha_D = 0.5, \r\nwe rescale it by 5 ^1/4. since the scattering limit scale as eps^4 alpha_D\r\n\"\"\"\r\nminiboone_scattering.ref=\"inspirehep.net/record/1682906\"\r\nminiboone_scattering.UpdateLimIni(miniboone_scattering.mx_ini,np.sqrt(miniboone_scattering.lim_ini)*np.power(5,1/4.) )\r\nUpdateLimitList(miniboone_scattering)\r\n\r\n############\r\n\r\nsbnd_scattering=Limit(\"sbnd_1609.01770\",\"sbnd\",\"scattering\",0.)\r\nsbnd_scattering.descr=\"\"\"\r\nProjective Limits from SBND collaboration for light dark matter scattering\r\nproduced by 1609.01770, for 2. * 10^20 PoT, based on 10 events reach\r\n\r\nExtracted from Figure 9.b, the data is given as epsilon^2, for alpha_D = 0.5\r\n\"\"\"\r\nsbnd_scattering.ref=\"inspirehep.net/record/1485563\"\r\nsbnd_scattering.UpdateLimIni(sbnd_scattering.mx_ini,np.sqrt(sbnd_scattering.lim_ini)*np.power(5,1/4.) )\r\nUpdateLimitList(sbnd_scattering)\r\n\r\n############\r\n\r\nship_scattering=Limit(\"ship_1609.01770\",\"ship\",\"scattering\",0.)\r\nship_scattering.descr=\"\"\"\r\nProjective limits from SHIP collaboration for light dark matter scattering,\r\nproduced by 1609.01770, for 2. * 10^20 PoT, based on 10 events reach\r\n\r\nExtracted from Figure 24.a, the data is given as epsilon^2, for alpha_D = 0.5\r\n\"\"\"\r\nship_scattering.ref=\"inspirehep.net/record/1485563\"\r\nship_scattering.UpdateLimIni(ship_scattering.mx_ini,np.sqrt(ship_scattering.lim_ini)*np.power(5,1/4.) )\r\nUpdateLimitList(ship_scattering)\r\n\r\n\r\n############\r\n\r\nnova_scattering=Limit(\"nova_1807.06501\",\"nova\",\"scattering\",0.)\r\nnova_scattering.descr=\"\"\"\r\nLimit produced by 1807.06501 based on NOvA collaboration neutrino-electron scattering \r\nin 1710.03428, recasted for light dark matter scattering for 2.97 * 10^20 PoT.\r\nThis is not a projection, limit for 58 events, although the authors of 1807.06501 merely\r\ncall for a full analysis by the collaboration\r\n\r\nExtracted from Figure 2, with alpha_D = 0.05, the data is given as y = eps^2 * alpha_D *(mx/ mv)^4= 0.00062 eps^2\r\n\"\"\"\r\nnova_scattering.ref=\"inspirehep.net/record/1682772\"\r\n# print(\"nova\",nova_scattering.mx_ini,nova_scattering.lim_ini)\r\nnova_scattering.UpdateLimIni(nova_scattering.mx_ini,np.sqrt(nova_scattering.lim_ini)/np.sqrt(0.00062)/np.power(2,1/4.) )\r\nUpdateLimitList(nova_scattering)\r\n# print(\"nova2\",nova_scattering.mx_ini,nova_scattering.lim_ini)\r\n\r\n######################### Long-lived particles #########################\r\nif verbose: print(\"Long-lived dark sector ...\")\r\n\r\n############ Based on: Kling, 2018 MATHUSLA\r\n\r\nmathusla_decay=Limit(\"mathusla_1810.01879\",\"mathusla\",\"decay\",0.1)\r\nmathusla_decay.descr=\"\"\"\r\nProjective limits for MATHUSLA from 1810.01879, with 3 ab-1 of luminosity from HL-LHC\r\n\r\nEnergy cut > 0.6 GeV\r\n\"\"\"\r\nmathusla_decay.ref=\"inspirehep.net/record/1696950\"\r\nmathusla_decay.combthr=1.2\r\nUpdateLimitList(mathusla_decay)\r\n\r\n############ Based on: Kling, 2018 FASER\r\n\r\nfaser_decay=Limit(\"faser_1810.01879\",\"faser\",\"decay\",0.1)\r\nfaser_decay.descr=\"\"\"\r\nProjective limits for FASER from 1810.01879, with 3 ab-1 of luminosity from HL-LHC\r\n\r\nEnergy cut > 100 GeV\r\n\"\"\"\r\nfaser_decay.ref=\"inspirehep.net/record/1696950\"\r\nfaser_decay.combthr=1.1\r\nUpdateLimitList(faser_decay)\r\n\r\n\r\n############ Based on: 2018 SeaQuest phase 1 and 2\r\n\r\nseaquest_phase2_decay=Limit(\"seaquest_phase2_1804.00661\",\"seaquest_phase2\",\"decay\",0.1)\r\nseaquest_phase2_decay.descr=\"\"\"\r\nProjective limits 1804.00661 Figure 12, 10 events limits with 5m−6m fiducial decay region Phase 2 with 10^20 PoT\r\n\r\n\"\"\"\r\nseaquest_phase2_decay.ref=\"inspirehep.net/record/1665691\"\r\nUpdateLimitList(seaquest_phase2_decay)\r\n\r\n\r\nseaquest_phase1_decay=Limit(\"\",\"seaquest_phase1\",\"decay\",0.1)\r\nseaquest_phase1_decay.descr=\"\"\"\r\nProjective limit, 1804.00661, rescaled from Figure 12 given the reduced number of PoT: 1.44×10^18 PoT \r\n, 10 events limits with 5m−6m fiducial decay regions \r\n\"\"\"\r\nseaquest_phase1_decay.ref=\"inspirehep.net/record/1665691\"\r\nseaquest_phase1_decay.UpdateLimIni(seaquest_phase1_decay.mx_ini,np.sqrt(seaquest_phase1_decay.lim_ini)/np.power(0.014,1/4.))\r\nUpdateLimitList(seaquest_phase1_decay)\r\n\r\n############ Based on: Izaguiire, 2017 LSND (on-shell pi0 only?)\r\n\r\nlsnd_decay_2=Limit(\"lsnd_1703.06881\",\"lsnd\",\"decay\",0.1)\r\nlsnd_decay_2.descr=\"\"\"\r\nLimits for LSND collaboration, based on original neutrino scattering search from hep-ex/0104049, \r\nrecasted for iDM in 1703.06881 Fig 6, with splitting 10%\r\n\"\"\"\r\nlsnd_decay_2.ref=\"inspirehep.net/record/1682906\"\r\nUpdateLimitList(lsnd_decay_2,\"lsnd_decay_2\")\r\n\r\n\r\n############ LSND ---- based Darme 2018\r\n \r\nlsnd_decay=Limit(\"lsnd_1807.10314\",\"lsnd\",\"decay\",0.15)\r\nlsnd_decay.descr=\"\"\"\r\nLimits for LSND collaboration, based on original neutrino scattering search from hep-ex/0104049, \r\nrecasted for iDM in 1807.10314 Fig5a, with splitting 15%\r\n\"\"\"\r\nlsnd_decay.ref=\"inspirehep.net/record/1684267\"\r\nUpdateLimitList(lsnd_decay)\r\n\r\n############ CHARM ---- based Tsai 2019\r\n \r\ncharm_decay=Limit(\"charm_1908.07525\",\"charm\",\"decay\",0.1)\r\ncharm_decay.descr=\"\"\"\r\nLimits for CHARM collaboration, based on original neutrino scattering search from Phys.Lett. 128B (1983) 361,\r\n recasted for iDM in 1908.07525 Fig1.c\r\n\r\nEcut > 3 GeV\r\n\"\"\"\r\ncharm_decay.ref=\"inspirehep.net/record/1682906\"\r\nUpdateLimitList(charm_decay)\r\n\r\n############ SHIP decay prediction\r\n \r\nship_decay=Limit(\"\",\"ship\",\"decay\",0.1)\r\nship_decay.descr=\"\"\"\r\nNaive limit prediction for SHIP, based on the routine for production and decay implemented in this code.\r\nDoes not include the experimental efficiency. The output is the 10 events line.\r\n\"\"\"\r\nship_decay.ref=\"\"\r\nship_decay.model=\"EFT\"\r\nUpdateLimitList(ship_decay)\r\n\r\nship_heavymesondecay=Limit(\"\",\"ship\",\"heavymesondecay\",0.1)\r\nship_heavymesondecay.descr=\"\"\"\r\nNaive limit prediction for SHIP, based on the routine for production and decay implemented in this code.\r\nDoes not include the experimental efficiency. The output is the 10 events line.\r\nProduction is generated by heavy meson decay\r\n\"\"\"\r\nship_heavymesondecay.ref=\"\"\r\nship_heavymesondecay.model=\"EFT\" # The generated limits are already in the EFT\r\nUpdateLimitList(ship_heavymesondecay)\r\n\r\n######################### Missing energy searches #########################\r\nif verbose: print(\"Mono-X searches ...\")\r\n\r\n############ BaBAr # Based on Essig 2013\r\n\r\nbabar_monogam=Limit(\"babar_1309.5084\",\"babar\",\"monogam\",0.0)\r\nbabar_monogam.descr=\"\"\"\r\nLimits for BaBar collaboration, based on the recasting from 1309.5084 of the upsilon decay \r\nmono-photon search from 0808.0017.\r\n\r\nNotice that the absence of \"bump\" in the reconstructed dark sector invariant mass distribution\r\nsignificantly weakens the reach. Better control of the background could lead to improvement\r\n\"\"\"\r\nbabar_monogam.ref=\"inspirehep.net/record/1254859,inspirehep.net/record/792059\"\r\nUpdateLimitList(babar_monogam)\r\n\r\n############ Belle II # Based on Essig 2013\r\n\r\nbelle2_monogam=Limit(\"belle2_1309.5084\",\"belle2\",\"monogam\",0.0)\r\nbelle2_monogam.descr=\"\"\"\r\nLimits for Belle II collaboration, based on the proejction from 1309.5084\r\n\r\nNotice that the absence of \"bump\" in the reconstructed dark sector invariant mass distribution\r\nsignificantly weakens the reach. Better control of the background could lead to improvement\r\n\"\"\"\r\nbelle2_monogam.ref=\"inspirehep.net/record/1254859\"\r\nUpdateLimitList(belle2_monogam)\r\n\r\n\r\n######################### MonoJet searches at ATLAS 35.9 fb-1 #########################\r\ndata = np.loadtxt('Data/LimData/atlas_1711.03301.dat')\r\nxi_ATLAS = np.abs(data[:,0])\r\nLim_ATLAS_Down = data[:,1]\r\nLim_ATLAS_Up= data[:,2]\r\n\r\natlas_monoXlow=Limit(\"\",\"atlas\",\"monojet_down\",0.0)\r\natlas_monoXlow.descr=\"\"\"\r\nLimits for ATLAS collaboration, 1711.03301 based on the upper recasted limit from 1807.03817 \r\nand our own recast.\r\n\"\"\"\r\natlas_monoXlow.ref=\"inspirehep.net/record/1635274\"\r\natlas_monoXlow.UpdateLimIni(xi_ATLAS,Lim_ATLAS_Down)\r\nUpdateLimitList(atlas_monoXlow)\r\n\r\n\r\natlas_monoXhigh=Limit(\"\",\"atlas\",\"monojet_up\",0.0)\r\natlas_monoXhigh.descr=\"\"\"\r\nLimits for ATLAS collaboration, 1711.03301 based on the upper recasted limit from 1807.03817 \r\nand our own recast.\r\n\"\"\"\r\natlas_monoXhigh.ref=\"inspirehep.net/record/1635274\"\r\natlas_monoXhigh.UpdateLimIni(xi_ATLAS,Lim_ATLAS_Up)\r\nUpdateLimitList(atlas_monoXhigh)\r\n\r\n\r\n######################### MonoPhoton searches at DELPHI from 1103.0240 #########################\r\n\r\nxi_LimLEP_V,LimLEP_V = uf.LoadData('LimData/lep_1103.0240_V.dat',\"lin\")\r\nxi_LimLEP_AV,LimLEP_AV = uf.LoadData('LimData/lep_1103.0240_AV.dat',\"lin\")\r\n\r\nlep_monoX=Limit(\"lep_1103.0240\",\"lep\",\"monogam\",0.0)\r\nlep_monoX.descr=\"\"\"\r\nLimits for LEP collaboration, based on the recasting from 1103.0240 for the upper limit. \r\nThe lower limit is given by the breakdown of the EFT at the LEP CoM energy.\r\n\"\"\"\r\nlep_monoX.ref=\"inspirehep.net/record/890992\"\r\nlep_monoX.UpdateLimIni(xi_LimLEP_V,LimLEP_V)\r\nlep_monoX.UpdateLimIni(xi_LimLEP_AV,LimLEP_AV,\"AV\")\r\nUpdateLimitList(lep_monoX)\r\n\r\n######################### SN1987 cooling rate constraints #####\r\nif verbose: print(\"SN1987 cooling ...\")\r\n\r\nsn1987low_cooling=Limit(\"sn1987low\",\"sn1987\",\"low_cooling\",0.0,\"lin\")\r\nsn1987low_cooling.descr=\"\"\"\r\nLower limit from SN1987 cooling constraints, recasted from ***\r\n\"\"\"\r\nsn1987low_cooling.ref=\"inspirehep.net/record/1682906\"\r\nnewmx=np.power(10.,sn1987low_cooling.mx_ini/1.)\r\nnewlim=np.power(10.,sn1987low_cooling.lim_ini/1.)\r\nsn1987low_cooling.UpdateLimIni(newmx,newlim,\"V\")\r\nsn1987low_cooling.UpdateLimIni(newmx,newlim,\"AV\")\r\nUpdateLimitList(sn1987low_cooling)\r\n# print(sn1987low_cooling.mx_ini,sn1987low_cooling.lim_ini)\r\n\r\n\r\nsn1987high_cooling=Limit(\"sn1987high\",\"sn1987\",\"high_cooling\",0.0,\"lin\")\r\nsn1987high_cooling.descr=\"\"\"\r\nUpper limit from SN1987 cooling constraints, recasted from ***\r\n\r\nIn the case of AV coupling, we use instead the lower limit on the pi0->invisible BR\r\nderived in *** from sn1987 cooling\r\n\"\"\"\r\nsn1987high_cooling.ref=\"inspirehep.net/record/1682906\"\r\nxi_LimSN_AV_up,LamlimSN_AV_up= uf.LoadData('LimData/sn1987_pi0decay.dat',\"log\")\r\nsn1987high_cooling.UpdateLimIni(np.power(10.,sn1987high_cooling.mx_ini/1.),np.power(10.,sn1987high_cooling.lim_ini/1.))\r\nsn1987high_cooling.UpdateLimIni(xi_LimSN_AV_up,LamlimSN_AV_up,\"AV\")\r\nUpdateLimitList(sn1987high_cooling)\r\n\r\n# print(sn1987high_cooling.mx_ini,sn1987high_cooling.lim_ini)\r\n\r\n######################### Invisible decay of pi0 #################\r\n\r\nif verbose: print(\"Invisible meson decay ...\")\r\n\r\nna62_invisibledecayPi0=Limit(\"na62_talkKaon2019\",\"na62\",\"invisibledecayPi0\",0.0)\r\nna62_invisibledecayPi0.descr=\"\"\"\r\nLimits for invisible decay branching ratio of pi0 meson as constrained by the NA62 collaboration\r\n\r\nCurrently value only from https://indico.cern.ch/event/769729/sessions/318725/ Ruggiero's talk\r\nBR < 4.4 10^-9 at 90% CL\r\n\"\"\"\r\nna62_invisibledecayPi0.ref=\"indico.cern.ch/event/769729/contributions/3510938/attachments/1905346/3146619/kaon2019_ruggiero_final.pdf\"\r\nUpdateLimitList(na62_invisibledecayPi0)\r\n\r\n######################### Invisible decay of heavy mesons #################\r\nif verbose: print(\"Invisible heavy meson decay ...\")\r\n\r\nbabar_invisibledecayBmtoKm=Limit(\"babar_invisibledecayBmtoKm\",\"babar\",\"invisibledecayBmtoKm\",0.0)\r\nbelle2_invisibledecayBmtoKm=Limit(\"belle2_invisibledecayBmtoKm\",\"belle2\",\"invisibledecayBmtoKm\",0.0)\r\nbelle_invisibledecayB0toPi0=Limit(\"belle_invisibledecayB0toPi0\",\"belle\",\"invisibledecayB0toPi0\",0.0)\r\nbelle_invisibledecayB0toK0=Limit(\"belle_invisibledecayB0toK0\",\"belle\",\"invisibledecayB0toK0\",0.0)\r\nbabar_invisibledecayBmtoPim=Limit(\"babar_invisibledecayBmtoPim\",\"babar\",\"invisibledecayBmtoPim\",0.0)\r\ne391a_invisibledecayKL0toPi0=Limit(\"e391a_invisibledecayKL0toPi0\",\"e391a\",\"invisibledecayKL0toPi0\",0.0)\r\nna62_invisibledecayKL0toPi0=Limit(\"na62_invisibledecayKL0toPi0\",\"na62\",\"invisibledecayKL0toPi0\",0.0)\r\ne949_invisibledecayKptoPip=Limit(\"e949_invisibledecayKptoPip\",\"e949\",\"invisibledecayKptoPip\",0.0)\r\nna62_invisibledecayKptoPip=Limit(\"na62_invisibledecayKptoPip\",\"na62\",\"invisibledecayKptoPip\",0.0)\r\n\r\n\r\nbes_invisibledecayJPsi=Limit(\"bes_invisibledecayJPsi\",\"bes\",\"invisibledecayJPsi\",0.0)\r\nbes_invisibledecayJPsi.descr=\"Limit BR JPSi-> inv < 7.2 * 10^-4 from BES collaboration 0710.0039\"\r\n\r\nbabar_invisibledecayUpsilon=Limit(\"babar_invisibledecayUpsilon\",\"babar\",\"invisibledecayUpsilon\",0.0)\r\nbabar_invisibledecayUpsilon.descr=\"Limit BR Upsilon-> inv < 3.0 * 10^-4 from BABAR collaboration 0908.2840\"\r\n\r\n\r\nUpdateLimitList(babar_invisibledecayBmtoKm);UpdateLimitList(belle2_invisibledecayBmtoKm);UpdateLimitList(belle_invisibledecayB0toPi0);\r\nUpdateLimitList(belle_invisibledecayB0toK0);UpdateLimitList(babar_invisibledecayBmtoPim);\r\nUpdateLimitList(e391a_invisibledecayKL0toPi0);UpdateLimitList(na62_invisibledecayKL0toPi0);\r\nUpdateLimitList(e949_invisibledecayKptoPip);UpdateLimitList(na62_invisibledecayKptoPip)\r\nUpdateLimitList(bes_invisibledecayJPsi);UpdateLimitList(babar_invisibledecayUpsilon)\r\n\r\n\r\n\r\n######################### CR limits at T2K ################# Currently not used\r\n# if verbose: print(\"Decay from CR production limits ...\")\r\n# \r\n# t2k_cosmicrays=Limit(\"t2k_cosmicrays\",\"t2k\",\"cosmicrays\",0.0)\r\n# t2k_cosmicrays.descr=\"\"\"\r\n# Projections from T2K limits based on cosmic ray production of dark sector states\r\n# limits for 500 number of signal events per year, neutrino background for superK is ~150\r\n# \r\n# \"\"\"\r\n# UpdateLimitList(t2k_cosmicrays)\r\n\r\n", "meta": {"hexsha": "10afc91154443609bb743af325d484164c1dafad", "size": 25197, "ext": "py", "lang": "Python", "max_stars_repo_path": "LimitsList.py", "max_stars_repo_name": "Luc-Darme/DarkEFT", "max_stars_repo_head_hexsha": "f4be14742ced9a1447dbcab40a6c7b18e61cb001", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "LimitsList.py", "max_issues_repo_name": "Luc-Darme/DarkEFT", "max_issues_repo_head_hexsha": "f4be14742ced9a1447dbcab40a6c7b18e61cb001", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "LimitsList.py", "max_forks_repo_name": "Luc-Darme/DarkEFT", "max_forks_repo_head_hexsha": "f4be14742ced9a1447dbcab40a6c7b18e61cb001", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-01-09T06:43:46.000Z", "max_forks_repo_forks_event_max_datetime": "2020-01-09T06:43:46.000Z", "avg_line_length": 45.3183453237, "max_line_length": 162, "alphanum_fraction": 0.6680160337, "include": true, "reason": "import numpy", "num_tokens": 7205, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5774953797290153, "lm_q2_score": 0.334589441253186, "lm_q1q2_score": 0.19322385642982773}} {"text": "import numpy as np\nfrom astropy.cosmology import FlatwCDM\nfrom astropy.cosmology import w0waCDM\nfrom astropy.cosmology import FlatLambdaCDM\nfrom astropy.cosmology import LambdaCDM\nimport matplotlib.pyplot as plt\nfrom astropy import cosmology as cosmo\nimport wmom as wmom\nimport matplotlib\nimport linef\nimport matplotlib\nimport plotsetup\nfrom matplotlib import gridspec\nimport matplotlib.ticker as ticker\nplotsetup.halfpaperfig()\n\ngs1 = gridspec.GridSpec(1,4)\ngs1.update(bottom=0.6, top=0.95, hspace=0.0)\nax1= plt.subplot(gs1[0])\nax2= plt.subplot(gs1[1])\nax3= plt.subplot(gs1[2]) \nax4= plt.subplot(gs1[3])\n\ngs1 = gridspec.GridSpec(1,4)\ngs1.update(bottom=0.34, top=0.57, hspace=0.0)\nax5= plt.subplot(gs1[0])\nax6= plt.subplot(gs1[1])\nax7= plt.subplot(gs1[2])\nax8= plt.subplot(gs1[3])\n\ngs1 = gridspec.GridSpec(1,4)\ngs1.update(bottom=0.1, top=0.31, hspace=0.0)\nax9= plt.subplot(gs1[0])\nax10= plt.subplot(gs1[1])\nax11= plt.subplot(gs1[2])\nax12= plt.subplot(gs1[3])\n\n#ax13= plt.subplot(gs1[1,0])\n#ax14= plt.subplot(gs1[1,1])\n#ax15= plt.subplot(gs1[1,2])\n#ax16= plt.subplot(gs1[1,3])\n\nax=[ax1,ax2,ax3,ax4,ax5,ax6,ax7,ax8,ax9,ax10,ax11,ax12]\nran=[0.04,0.04,0.04,0.04,0.02,0.02,0.02,0.02,0.02,0.02,0.02,0.02]\nheadn=linef.linef('../DATA/SALT2mu_SNLS+SDSS+LOWZ+PS1_Scolnic2+HST/DS17/SALT2mu_FITOPT'+str('000')+'_MUOPT'+str('000')+'.M0DIF','VARN')\nz1,mures, murese = np.loadtxt('../DATA/SALT2mu_SNLS+SDSS+LOWZ+PS1_Scolnic2+HST/DS17/SALT2mu_FITOPT'+str('000')+'_MUOPT'+str('000')+'.M0DIF', usecols=(4,5,6), unpack=True, dtype='string', skiprows=headn+1)\nz1 = z1.astype(float)\nmures1 = mures.astype(float)\nmurese1 = murese.astype(float)\n\n\n#FITOPT: color #GLOBAL GROUP 1\n#FITOPT: massstep #GLOBAL GROUP 1\n#FITOPT: massevol #GLOBAL GROUP 1\n#FITOPT: colorevol #GLOBAL GROUP 1\n\n\n#p1=plt.errorbar(z1, mures, yerr=murese, fmt='ko', ecolor='black', color='black',label='D15 Data')\n#xp=[0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3]\n#yp=[0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3]\n#syslabel=['SALT2 Cal','Beta Evol.','Intr Scat.','Selection',\n# 'MW Ext.','Mass Split','Mass Evol.','Pec. Vel.',\n# 'HST Cal', 'SDSS g','PS1 r','SNLS i','Supercal', 'SDSS r','PS1 i','SNLS z']\n#r'$\\beta$'+' Evol. & '\n#$\\gamma$'+' Evol. & '\n#$m_{\\rm step}$'+'Shift\n\nsyslabel=['SALT2 Cal',r'$\\mathbf{\\beta}$'+' Evol. ','Intr Scat.','Selection',\n 'MW Ext.',r'$\\mathbf{ m_{\\rm step}}$'+' Shift',r'$\\mathbf{\\gamma}$'+' Evol. ','Pec. Vel.',\n 'HST Cal', 'Supercal','PS1 r','SNLS i'];#,'Supercal', 'SDSS r','PS1 i','SNLS z']\n\n#sysnum1=['001','012','000','000','011','000','000','013','012','015','037','046','084','016','038','047']\n#sysnum2=['000','000','001','002','000','006','011','000','000','000','000','000','000','000','000','000']\n#weights=[1,1,0.5,1,\n# 1,1,1,1,\n# 1,.5,.3,.5,.5,.5,.5,.5]\nsysnum1=['001','012','000','000','011','000','000','013','012','084','037','046']\nsysnum2=['000','000','001','002','000','006','011','000','000','000','000','000']\nweights=[1,0.5,0.5,1,\n 1,1,1,1,\n 1,.5,.3,.5]\n\n#sysnum=[1,84,85,86,\n# 11,83,13,11,\n# 28,15,37,50,29,16,38,51]\n#sysnum=[1,11,12,86,83,84,85,15,28,37,51]\n#syslabel=['SALT2 Cal','MW Ext','HST Cal','Int. Scat','Mass Split','Mass Evol','Color Evol','SDSS g','CSP B','PS1 r', 'SNLS z']\nprint len(sysnum1)\n#stop\nfor x in range(0,len(sysnum1)):\n z2,mures2, murese2 = np.loadtxt('../DATA/SALT2mu_SNLS+SDSS+LOWZ+PS1_Scolnic2+HST/DS17/SALT2mu_FITOPT'+str(sysnum1[x])+'_MUOPT'+str(sysnum2[x])+'.M0DIF', usecols=(4,5,6), unpack=True, dtype='string', skiprows=headn+1)\n z2 = z2.astype(float)\n mures2 = mures2.astype(float)\n murese2 = murese2.astype(float)\n\n ax[x].errorbar(z1, (mures1-mures2)*weights[x], yerr=murese2*0, fmt='go', ecolor='g', alpha=.95)\n ax[x].set_ylim(-ran[x]*.99,ran[x]*.99)\n ax[x].set_xlim(0.005,1.7)\n ax[x].set_xscale('log')\n line, = ax[x].plot(np.arange(0,2,.1), np.arange(0,2,.1)*0.0, lw=2)\n if (x<8): ax[x].text(.01,-.88*ran[x], syslabel[x],fontdict={'fontsize':10}, color='black')\n if (x>7): ax[x].text(.01,-.88*ran[x], syslabel[x],fontdict={'fontsize':10}, color='black')\n \n ax[x].set_xticks([0.01,0.1,1.0])\n if (x<4): ax[x].yaxis.set_major_locator(ticker.MultipleLocator(0.02))\n if (x>3): ax[x].yaxis.set_major_locator(ticker.MultipleLocator(0.01))\n if (x>7): ax[x].yaxis.set_major_locator(ticker.MultipleLocator(0.01))\n \n if ((x!=0)&(x!=4)&(x!=8)&(x!=12)):\n ax[x].set_yticklabels(['','','','','','',''])\n if (x<9):\n ax[x].set_xticklabels(['','','','',''])\n if (x>7):\n ax[x].set_xlabel('z',labelpad=-1)\n ax[x].set_xticklabels([' 0.01','0.1','1.0 ',''])\n #ax[x].set_xticklabels(['0.0','','0.5','','1.0'])\n #if ((x==8)|(x==12)):\n # ax[x].set_yticklabels(['','-0.01','0.0','0.01',''])\n ax[x].tick_params('both', length=2, width=2, which='major')\n ax[x].tick_params('both', length=0, width=2, which='minor')\n \n#plt.text(.2,-.13,r'$Omega_M=0.30,\\Omega_{\\Lambda}=.70,w=-1.0$',fontdict={'fontsize':20}, color='black')\n#plt.text(.2,.1,r'$\\Omega_M=0.25,\\Omega_{\\Lambda}=.75,w=-1.0$',fontdict={'fontsize':20}, color='orange')\n#plt.text(.2,.13,r'$\\Omega_M=0.30,\\Omega_{\\Lambda}=.70,w=-1.1$',fontdict={'fontsize':20}, color='red')\n#plt.text(.2,.16,r'$\\Omega_M=0.30,\\Omega_{\\Lambda}=.70,w=-1.0, w_a=-0.1$',fontdict={'fontsize':20}, color='blue')\n\n#ax[1,0].text(-0.3,0.05, 'd(m-M) [Mag]',fontdict={'fontsize':18}, color='black',rotation=90)\n\nax[4].set_ylabel(r'$\\Delta \\mu_{\\rm Sys} - \\Delta \\mu_{\\rm Baseline} $'+' [mag]',labelpad=-1)\n\n#plt.ylabel('d(m-M) [Mag]', size=24)\n\nplt.show()\nplt.savefig('sysgrid.png')\n#line, = plt.plot(range(1,150)/100.0,5.0*np.log(c1/c2), lw=2,color='red')\n#plt.show()\n#plt.savefig('wdemo1.png')\n", "meta": {"hexsha": "e5ff9b5fdbe50a9d8bcd15f7985c01cc90d02760", "size": 5807, "ext": "py", "lang": "Python", "max_stars_repo_path": "SCRIPTS/sysgrid.py", "max_stars_repo_name": "LBJ-Wade/Pantheon", "max_stars_repo_head_hexsha": "7eb29dc87ba223b4ec8457cd3cccba1216c36fb7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 22, "max_stars_repo_stars_event_min_datetime": "2018-06-08T01:38:53.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-23T14:44:46.000Z", "max_issues_repo_path": "SCRIPTS/sysgrid.py", "max_issues_repo_name": "LBJ-Wade/Pantheon", "max_issues_repo_head_hexsha": "7eb29dc87ba223b4ec8457cd3cccba1216c36fb7", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 6, "max_issues_repo_issues_event_min_datetime": "2018-03-31T08:26:16.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-25T11:08:13.000Z", "max_forks_repo_path": "SCRIPTS/sysgrid.py", "max_forks_repo_name": "LBJ-Wade/Pantheon", "max_forks_repo_head_hexsha": "7eb29dc87ba223b4ec8457cd3cccba1216c36fb7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 15, "max_forks_repo_forks_event_min_datetime": "2018-04-09T12:40:09.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-21T15:51:13.000Z", "avg_line_length": 42.0797101449, "max_line_length": 220, "alphanum_fraction": 0.6063371793, "include": true, "reason": "import numpy,from astropy", "num_tokens": 2293, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5774953797290153, "lm_q2_score": 0.33458942798284697, "lm_q1q2_score": 0.19322384876626825}} {"text": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\nr\"\"\"Provide the wrench limits constraint.\n\nThis provides bounds/limits on the wrenches:\n\n.. math:: F_{lb} \\leq F \\leq F_{ub}\n\nwhere :math:`(F_{lb}, F_{ub})` are the lower and upper bound on the wrenches, and\n:math:`F` is the wrench vector being optimized.\n\nThis formulation can be rewritten as the inequality constraint math:`lb \\leq x \\leq ub` in QP, with\n:math:`lb = F_{lb}`, :math:`ub = F_{ub}`, and :math:`x = F`. This can also be rewritten as :math:`Gx \\leq h`,\nwith :math:`G = [-I, I]^\\top` and :math:`h = [-F_{lb}^\\top, F_{ub}^\\top]^\\top` where :math:`I` is the square\nidentity matrix.\n\nThe implementation of this class is inspired by [1] (which is licensed under the LGPLv2).\n\nReferences:\n - [1] \"OpenSoT: A whole-body control library for the compliant humanoid robot COMAN\", Rocchi et al., 2015\n\"\"\"\n\nimport numpy as np\n\nfrom pyrobolearn.priorities.constraints.constraint import BoundConstraint, ForceConstraint\n\n\n__author__ = \"Brian Delhaisse\"\n__copyright__ = \"Copyright 2019, PyRoboLearn\"\n__credits__ = [\"Enrico Mingo Hoffman (C++)\", \"Brian Delhaisse (Python + doc)\"]\n__license__ = \"GNU GPLv3\"\n__version__ = \"1.0.0\"\n__maintainer__ = \"Brian Delhaisse\"\n__email__ = \"briandelhaisse@gmail.com\"\n__status__ = \"Development\"\n\n\nclass WrenchLimitsConstraint(BoundConstraint, ForceConstraint):\n r\"\"\"Wrench Limits constraint.\n\n This provides bounds/limits on the wrenches:\n\n .. math:: F_{lb} \\leq F \\leq F_{ub}\n\n where :math:`(F_{lb}, F_{ub})` are the lower and upper bound on the wrenches, and\n :math:`F` is the wrench vector being optimized.\n\n This formulation can be rewritten as the inequality constraint math:`lb \\leq x \\leq ub` in QP, with\n :math:`lb = F_{lb}`, :math:`ub = F_{ub}`, and :math:`x = F`. This can also be rewritten as :math:`Gx \\leq h`,\n with :math:`G = [-I, I]^\\top` and :math:`h = [-F_{lb}^\\top, F_{ub}^\\top]^\\top` where :math:`I` is the square\n identity matrix.\n\n The implementation of this class is inspired by [1] (which is licensed under the LGPLv2).\n\n References:\n - [1] \"OpenSoT: A whole-body control library for the compliant humanoid robot COMAN\", Rocchi et al., 2015\n \"\"\"\n\n def __init__(self, model, bounds):\n r\"\"\"\n Initialize the constraint.\n\n Args:\n model (ModelInterface): model interface.\n bounds (tuple[2 * np.array[float[M]]], np.array[float[M]]): wrench limits, where `M` is 3 (vector of\n forces) or 6 (vector of forces and torques). If tuple, it is the lower and upper bounds on the wrenches.\n If np.array, then the lower and upper bound will be set to (-bounds, bounds).\n \"\"\"\n super(WrenchLimitsConstraint, self).__init__(model)\n\n # set variables\n self.bounds = bounds\n\n # first update\n self.update()\n\n ##############\n # Properties #\n ##############\n\n @property\n def bounds(self):\n \"\"\"Get the wrench bounds.\"\"\"\n return self._bounds\n\n @bounds.setter\n def bounds(self, bounds):\n \"\"\"Set the wrench bounds.\"\"\"\n if bounds is not None:\n if isinstance(bounds, tuple):\n if len(bounds) != 2:\n raise ValueError(\"Expecting the bounds to be a tuple of length 2, but got a length of \"\n \"{}\".format(len(bounds)))\n for i, bound in enumerate(bounds):\n if isinstance(bound, (int, float)):\n bound = np.ones(3) * bound\n bounds[i] = bound\n elif isinstance(bound, np.ndarray) and len(bound) != 3:\n raise ValueError(\"Expecting the given bound to be of length 3, but instead got a length of \"\n \"{}\".format(len(bound)))\n else:\n raise TypeError(\"Expecting the given bound to be a np.array, but got instead: \"\n \"{}\".format(type(bound)))\n elif isinstance(bounds, np.ndarray):\n bounds = bounds.reshape(-1)\n if len(bounds) == 3:\n bounds = (-bounds, bounds)\n elif len(bounds) == 6:\n bounds = (bounds[:3], bounds[3:])\n elif len(bounds) == 12:\n bounds = (bounds[:6], bounds[6:])\n else:\n raise ValueError(\"Expecting the given bounds to be of length 3 or 6 but got instead a length of: \"\n \"{}\".format(len(bounds)))\n elif isinstance(bounds, (int, float)):\n bounds = (-np.ones(3) * bounds, np.ones(3) * bounds)\n else:\n raise TypeError(\"Expecting the given bounds to be a tuple of np.array, a np.array, or None, but \"\n \"instead got: {}\".format(type(bounds)))\n self._bounds = bounds\n\n ###########\n # Methods #\n ###########\n\n def _update(self):\n \"\"\"Update the lower and upper bounds.\"\"\"\n self._b_lower_bound, self._b_upper_bound = self._bounds\n", "meta": {"hexsha": "92851818caac92f75c2e4611543c8dabf9286879", "size": 5139, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyrobolearn/priorities/constraints/force/wrench_limits.py", "max_stars_repo_name": "Pandinosaurus/pyrobolearn", "max_stars_repo_head_hexsha": "9cd7c060723fda7d2779fa255ac998c2c82b8436", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-01-21T21:08:30.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T16:45:49.000Z", "max_issues_repo_path": "pyrobolearn/priorities/constraints/force/wrench_limits.py", "max_issues_repo_name": "Pandinosaurus/pyrobolearn", "max_issues_repo_head_hexsha": "9cd7c060723fda7d2779fa255ac998c2c82b8436", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pyrobolearn/priorities/constraints/force/wrench_limits.py", "max_forks_repo_name": "Pandinosaurus/pyrobolearn", "max_forks_repo_head_hexsha": "9cd7c060723fda7d2779fa255ac998c2c82b8436", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-09-29T21:25:39.000Z", "max_forks_repo_forks_event_max_datetime": "2020-09-29T21:25:39.000Z", "avg_line_length": 39.8372093023, "max_line_length": 118, "alphanum_fraction": 0.5726795096, "include": true, "reason": "import numpy", "num_tokens": 1267, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.37754068280545827, "lm_q1q2_score": 0.19319383634290138}} {"text": "__docformat__='reStructuredText'\n__author__ = 'Anand Patil, anand.prabhakar.patil@gmail.com'\n__all__ = ['extend_children', 'extend_parents', 'ParentDict', 'Stochastic', 'Deterministic', 'Potential']\n\n\nfrom copy import copy\nfrom numpy import array, ndarray, reshape, Inf, asarray, dot, sum, float, isnan, size, NaN, asanyarray\nimport numpy as np\nfrom Node import Node, ZeroProbability, Variable, PotentialBase, StochasticBase, DeterministicBase\nimport Container\nfrom Container import DictContainer, ContainerBase, file_items, ArrayContainer\nimport sys\nimport pdb\n\nd_neg_inf = float(-1.7976931348623157e+308)\n\n# from PyrexLazyFunction import LazyFunction\nfrom LazyFunction import LazyFunction, Counter\n\ndef extend_children(children):\n \"\"\"\n extend_children(children)\n\n Returns a set containing\n nearest conditionally stochastic (Stochastic, not Deterministic) descendants.\n \"\"\"\n new_children = copy(children)\n need_recursion = False\n dtrm_children = set()\n\n for child in children:\n if isinstance(child,Deterministic):\n new_children |= child.children\n dtrm_children.add(child)\n need_recursion = True\n\n new_children -= dtrm_children\n\n if need_recursion:\n new_children = extend_children(new_children)\n\n return new_children\n\ndef extend_parents(parents):\n \"\"\"\n extend_parents(parents)\n\n Returns a set containing\n nearest conditionally stochastic (Stochastic, not Deterministic) ancestors.\n \"\"\"\n new_parents = set()\n\n for parent in parents:\n\n new_parents.add(parent)\n\n if isinstance(parent, DeterministicBase):\n new_parents.remove(parent)\n new_parents |= parent.extended_parents\n\n elif isinstance(parent, ContainerBase):\n for contained_parent in parent.stochastics:\n new_parents.add(contained_parent)\n for contained_parent in parent.deterministics:\n new_parents |= contained_parent.extended_parents\n\n\n return new_parents\n\n\nclass ParentDict(DictContainer):\n \"\"\"\n A special subclass of DictContainer which makes it safe to change\n varibales' parents. When __setitem__ is called, a ParentDict instance\n removes its owner from the old parent's children set (if appropriate)\n and adds its owner to the new parent's children set. It then asks\n its owner to generate a new LazyFunction instance using its new\n parents.\n\n Also manages the extended_parents attribute of owner.\n\n NB: StepMethod and Model are expecting variables'\n children to be static. If you want to change indedependence structure\n over the course of an MCMC loop, please do so with indicator variables.\n\n :SeeAlso: DictContainer\n \"\"\"\n def __init__(self, regular_dict, owner):\n DictContainer.__init__(self, dict(regular_dict))\n self.owner = owner\n self.owner.extended_parents = extend_parents(self.variables)\n if isinstance(self.owner, StochasticBase) or isinstance(self.owner, PotentialBase):\n self.has_logp = True\n else:\n self.has_logp = False\n\n def detach_parents(self):\n for parent in self.itervalues():\n if isinstance(parent, Variable):\n parent.children.discard(self.owner)\n elif isinstance(parent, ContainerBase):\n for variable in parent.variables:\n variable.chidren.discard(self.owner)\n\n if self.has_logp:\n self.detach_extended_parents()\n\n\n def detach_extended_parents(self):\n for e_parent in self.owner.extended_parents:\n if isinstance(e_parent, StochasticBase):\n e_parent.extended_children.discard(self.owner)\n\n\n def attach_parents(self):\n for parent in self.itervalues():\n if isinstance(parent, Variable):\n parent.children.add(self.owner)\n elif isinstance(parent, ContainerBase):\n for variable in parent.variables:\n variable.children.add(self.owner)\n\n if self.has_logp:\n self.attach_extended_parents()\n\n def attach_extended_parents(self):\n for e_parent in self.owner.extended_parents:\n if isinstance(e_parent, StochasticBase):\n e_parent.extended_children.add(self.owner)\n\n\n def __setitem__(self, key, new_parent):\n old_parent = self[key]\n\n # Possibly remove owner from old parent's children set.\n if isinstance(old_parent, Variable) or isinstance(old_parent, ContainerBase):\n\n # Tell all extended parents to forget about owner\n if self.has_logp:\n self.detach_extended_parents()\n\n self.val_keys.remove(key)\n self.nonval_keys.append(key)\n\n if isinstance(old_parent, Variable):\n # See if owner only claims the old parent via this key.\n if sum([parent is old_parent for parent in self.itervalues()]) == 1:\n old_parent.children.remove(self.owner)\n\n\n if isinstance(old_parent, ContainerBase):\n for variable in old_parent.variables:\n if sum([parent is variable for parent in self.itervalues()]) == 1:\n variable.children.remove(self.owner)\n\n\n\n # If the new parent is a variable, add owner to its children set.\n if isinstance(new_parent, Variable) or isinstance(new_parent, ContainerBase):\n\n self.val_keys.append(key)\n self.nonval_keys.remove(key)\n\n if isinstance(new_parent, Variable):\n new_parent.children.add(self.owner)\n\n elif isinstance(new_parent, ContainerBase):\n for variable in new_parent.variables:\n new_parent.children.add(self.owner)\n\n # Totally recompute extended parents\n self.owner.extended_parents = extend_parents(self.variables)\n if self.has_logp:\n self.attach_extended_parents()\n\n dict.__setitem__(self, key, new_parent)\n\n file_items(self, self)\n\n # Tell my owner it needs a new lazy function.\n self.owner.gen_lazy_function()\n\nclass Potential(PotentialBase):\n \"\"\"\n Not a variable; just an arbitrary log-probability term to multiply into the\n joint distribution. Useful for expressing models that aren't directed, such as\n Markov random fields.\n\n Decorator instantiation:\n\n @potential(trace = True)\n def A(x = B, y = C):\n return -.5 * (x-y)**2 / 3.\n\n Direct instantiation:\n\n :Parameters:\n\n -logp: function\n The function that computes the potential's value from the values\n of its parents.\n\n -doc: string\n The docstring for this potential.\n\n -name: string\n The name of this potential.\n\n -parents: dictionary\n A dictionary containing the parents of this potential.\n\n -cache_depth (optional): integer\n An integer indicating how many of this potential's value computations\n should be 'memoized'.\n\n - plot (optional) : boolean\n A flag indicating whether this variable is to be plotted.\n\n - verbose (optional) : integer\n Level of output verbosity: 0=none, 1=low, 2=medium, 3=high\n\n\n Externally-accessible attribute:\n\n -logp: float\n Returns the potential's log-probability given its parents' values. Skips\n computation if possible.\n\n No methods.\n\n :SeeAlso: Stochastic, Node, LazyFunction, stoch, dtrm, data, Model, Container\n \"\"\"\n def __init__(self, logp, doc, name, parents, cache_depth=2, plot=None, verbose=None):\n\n self.ParentDict = ParentDict\n\n # This function gets used to evaluate self's value.\n self._logp_fun = logp\n\n self.errmsg = \"Potential %s forbids its parents' current values\"%name\n\n Node.__init__( self,\n doc=doc,\n name=name,\n parents=parents,\n cache_depth = cache_depth,\n verbose=verbose)\n\n self._plot = plot\n\n # self._logp.force_compute()\n\n # Check initial value\n if not isinstance(self.logp, float):\n raise ValueError, \"Potential \" + self.__name__ + \"'s initial log-probability is %s, should be a float.\" %self.logp.__repr__()\n\n def gen_lazy_function(self):\n\n self._logp = LazyFunction(fun = self._logp_fun,\n arguments = self.parents,\n ultimate_args = self.extended_parents,\n cache_depth = self._cache_depth)\n self._logp.force_compute()\n\n def get_logp(self):\n if self.verbose > 1:\n print '\\t' + self.__name__ + ': log-probability accessed.'\n logp = self._logp.get()\n if self.verbose > 1:\n print '\\t' + self.__name__ + ': Returning log-probability ', logp\n\n try:\n logp = float(logp)\n except:\n raise TypeError, self.__name__ + ': computed log-probability ' + str(logp) + ' cannot be cast to float'\n\n if logp != logp:\n raise ValueError, self.__name__ + ': computed log-probability is NaN'\n\n # Check if the value is smaller than a double precision infinity:\n if logp <= d_neg_inf:\n if self.verbose > 0:\n raise ZeroProbability, self.errmsg + \": %s\" %self._parents.value\n else:\n raise ZeroProbability, self.errmsg\n\n return logp\n\n def set_logp(self,value):\n raise AttributeError, 'Potential '+self.__name__+'\\'s log-probability cannot be set.'\n\n logp = property(fget = get_logp, fset=set_logp, doc=\"Self's log-probability value conditional on parents.\")\n\n\nclass Deterministic(DeterministicBase):\n \"\"\"\n A variable whose value is determined by the values of its parents.\n\n Decorator instantiation:\n\n @dtrm(trace=True)\n def A(x = B, y = C):\n return sqrt(x ** 2 + y ** 2)\n\n :Parameters:\n eval : function\n The function that computes the variable's value from the values\n of its parents.\n doc : string\n The docstring for this variable.\n name: string\n The name of this variable.\n parents: dictionary\n A dictionary containing the parents of this variable.\n trace (optional): boolean\n A boolean indicating whether this variable's value\n should be traced (in MCMC).\n cache_depth (optional): integer\n An integer indicating how many of this variable's\n value computations should be 'memoized'.\n plot (optional) : boolean\n A flag indicating whether this variable is to be plotted.\n verbose (optional) : integer\n Level of output verbosity: 0=none, 1=low, 2=medium, 3=high\n\n :Attributes:\n value : any object\n Returns the variable's value given its parents' values. Skips\n computation if possible.\n\n :SeeAlso:\n Stochastic, Potential, deterministic, MCMC, Lambda,\n LinearCombination, Index\n \"\"\"\n def __init__(self, eval, doc, name, parents, dtype=None, trace=True, cache_depth=2, plot=None, verbose=None):\n self.ParentDict = ParentDict\n\n # This function gets used to evaluate self's value.\n self._eval_fun = eval\n\n Variable.__init__( self,\n doc=doc,\n name=name,\n parents=parents,\n cache_depth = cache_depth,\n dtype=dtype,\n trace=trace,\n plot=plot,\n verbose=verbose)\n\n # self._value.force_compute()\n\n def gen_lazy_function(self):\n\n self._value = LazyFunction(fun = self._eval_fun,\n arguments = self.parents,\n ultimate_args = self.extended_parents,\n cache_depth = self._cache_depth)\n\n self._value.force_compute()\n\n def get_value(self):\n if self.verbose > 1:\n print '\\t' + self.__name__ + ': value accessed.'\n _value = self._value.get()\n if isinstance(_value, ndarray):\n _value.flags['W'] = False\n if self.verbose > 1:\n print '\\t' + self.__name__ + ': Returning value ',_value\n return _value\n\n def set_value(self,value):\n raise AttributeError, 'Deterministic '+self.__name__+'\\'s value cannot be set.'\n\n value = property(fget = get_value, fset=set_value, doc=\"Self's value computed from current values of parents.\")\n\nclass Stochastic(StochasticBase):\n\n \"\"\"\n A variable whose value is not determined by the values of its parents.\n\n\n Decorator instantiation:\n\n @stoch(trace=True)\n def X(value = 0., mu = B, tau = C):\n return Normal_like(value, mu, tau)\n\n @stoch(trace=True)\n def X(value=0., mu=B, tau=C):\n\n def logp(value, mu, tau):\n return Normal_like(value, mu, tau)\n\n def random(mu, tau):\n return Normal_r(mu, tau)\n\n rseed = 1.\n\n\n Direct instantiation:\n\n\n\n - logp : function\n The function that computes the variable's log-probability from\n its value and the values of its parents.\n\n - doc : string\n The docstring for this variable.\n\n - name : string\n The name of this variable.\n\n - parents: dict\n A dictionary containing the parents of this variable.\n\n - random (optional) : function\n A function that draws a new value for this\n variable given its parents' values.\n\n - trace (optional) : boolean\n A boolean indicating whether this variable's value\n should be traced (in MCMC).\n\n - value (optional) : number or array\n An initial value for this variable\n\n - dtype (optional) : type\n A type for this variable.\n\n - rseed (optional) : integer or rseed\n A seed for this variable's rng. Either value or rseed must\n be given.\n\n - observed (optional) : boolean\n A flag indicating whether this variable is data; whether\n its value is known.\n\n - cache_depth (optional) : integer\n An integer indicating how many of this variable's\n log-probability computations should be 'memoized'.\n\n - plot (optional) : boolean\n A flag indicating whether this variable is to be plotted.\n\n - verbose (optional) : integer\n Level of output verbosity: 0=none, 1=low, 2=medium, 3=high\n\n\n Externally-accessible attribute:\n\n - value: any class\n Returns this variable's current value.\n\n - logp: float\n Returns the variable's log-probability given its value and its\n parents' values. Skips computation if possible.\n\n last_value: any class\n Returns this variable's last value. Useful for rejecting\n Metropolis-Hastings jumps. See touch() and the warning below.\n\n Externally-accessible methods:\n\n random(): Draws a new value for this variable from its distribution and\n returns it.\n\n :SeeAlso: Deterministic, Node, LazyFunction, stoch, dtrm, data, Model, Container\n \"\"\"\n\n def __init__( self,\n logp,\n doc,\n name,\n parents,\n random = None,\n trace=True,\n value=None,\n dtype=None,\n rseed=False,\n observed=False,\n cache_depth=2,\n plot=None,\n verbose = None,\n isdata=None, \n check_logp=True):\n\n self.counter = Counter()\n self.ParentDict = ParentDict\n\n # Support legacy 'isdata' for a while\n if isdata is not None:\n print \"Deprecation Warning: the 'isdata' flag has been replaced by 'observed'. Please update your model accordingly.\"\n self.observed = isdata\n\n # A flag indicating whether self's value has been observed.\n self._observed = observed\n if observed and value is None:\n raise ValueError, 'Stochastic %s must be given an initial value if observed=True.'%name\n\n # This function will be used to evaluate self's log probability.\n self._logp_fun = logp\n\n # This function will be used to draw values for self conditional on self's parents.\n self._random = random\n\n # A seed for self's rng. If provided, the initial value will be drawn. Otherwise it's\n # taken from the constructor.\n self.rseed = rseed\n\n self.errmsg = \"Stochastic %s's value is outside its support,\\n or it forbids its parents' current values.\"%name\n\n dtype = np.dtype(dtype)\n\n # Initialize value, either from value provided or from random function.\n try:\n if dtype.kind != 'O' and value is not None:\n self._value = asanyarray(value, dtype=dtype)\n self._value.flags['W']=False\n else:\n self._value = value\n except:\n cls, inst, tb = sys.exc_info()\n new_inst = cls('Stochastic %s: Failed to cast initial value to required dtype.\\n\\nOriginal error message:\\n'%name + inst.message)\n raise cls, new_inst, tb\n\n # Store the shape of the stochastic value\n self._shape = np.shape(self._value)\n\n Variable.__init__( self,\n doc=doc,\n name=name,\n parents=parents,\n cache_depth=cache_depth,\n trace=trace,\n dtype=dtype,\n plot=plot,\n verbose=verbose)\n\n # self._logp.force_compute()\n\n # Store the shape of the stochastic value\n self._shape = np.shape(self._value)\n\n if isinstance(self._value, ndarray):\n self._value.flags['W'] = False\n\n if check_logp:\n # Check initial value\n if not isinstance(self.logp, float):\n raise ValueError, \"Stochastic \" + self.__name__ + \"'s initial log-probability is %s, should be a float.\" %self.logp.__repr__()\n\n\n def gen_lazy_function(self):\n \"\"\"\n Will be called by Node at instantiation.\n \"\"\"\n\n # If value argument to __init__ was None, draw value from random method.\n if self._value is None:\n\n # Use random function if provided\n if self._random is not None:\n self.value = self._random(**self._parents.value)\n\n # Otherwise leave initial value at None and warn.\n else:\n raise ValueError, 'Stochastic ' + self.__name__ + \"'s value initialized to None; no initial value or random method provided.\"\n\n arguments = {}\n arguments.update(self.parents)\n arguments['value'] = self\n arguments = DictContainer(arguments)\n\n self._logp = LazyFunction(fun = self._logp_fun,\n arguments = arguments,\n ultimate_args = self.extended_parents | set([self]),\n cache_depth = self._cache_depth)\n self._logp.force_compute()\n\n def get_value(self):\n # Define value attribute\n if self.verbose > 1:\n print '\\t' + self.__name__ + ': value accessed.'\n return self._value\n\n\n def set_value(self, value, force=False):\n # Record new value and increment counter\n\n # Value can't be updated if observed=True\n if self.observed and not force:\n raise AttributeError, 'Stochastic '+self.__name__+'\\'s value cannot be updated if observed flag is set'\n\n if self.verbose > 0:\n print '\\t' + self.__name__ + ': value set to ', value\n\n # Save current value as last_value\n # Don't copy because caching depends on the object's reference.\n self.last_value = self._value\n\n if self.dtype.kind != 'O':\n self._value = asanyarray(value, dtype=self.dtype)\n self._value.flags['W']=False\n else:\n self._value = value\n\n self.counter.click()\n\n value = property(fget=get_value, fset=set_value, doc=\"Self's current value.\")\n\n def shape():\n doc = \"The shape of the value of self.\"\n def fget(self):\n if self.verbose > 1:\n print '\\t' + self.__name__ + ': shape accessed.'\n return self._shape\n return locals()\n shape = property(**shape())\n\n def revert(self):\n \"\"\"\n Sets self's value to self's last value. Bypasses the data cleaning in\n the set_value method.\n \"\"\"\n self.counter.unclick()\n self._value = self.last_value\n\n\n def get_logp(self):\n\n if self.verbose > 0:\n print '\\t' + self.__name__ + ': logp accessed.'\n logp = self._logp.get()\n\n try:\n logp = float(logp)\n except:\n raise TypeError, self.__name__ + ': computed log-probability ' + str(logp) + ' cannot be cast to float'\n\n if logp != logp:\n raise ValueError, self.__name__ + ': computed log-probability is NaN'\n\n if self.verbose > 0:\n print '\\t' + self.__name__ + ': Returning log-probability ', logp\n\n # Check if the value is smaller than a double precision infinity:\n if logp <= d_neg_inf:\n if self.verbose > 0:\n raise ZeroProbability, self.errmsg + \"\\nValue: %s\\nParents' values:%s\" % (self._value, self._parents.value)\n else:\n raise ZeroProbability, self.errmsg\n\n return logp\n\n def set_logp(self, new_logp):\n raise AttributeError, 'Stochastic '+self.__name__+'\\'s logp attribute cannot be set'\n\n logp = property(fget = get_logp, fset=set_logp, doc=\"Log-probability or log-density of self's current value\\n given values of parents.\")\n\n\n # Sample self's value conditional on parents.\n def random(self):\n \"\"\"\n Draws a new value for a stoch conditional on its parents\n and returns it.\n\n Raises an error if no 'random' argument was passed to __init__.\n \"\"\"\n\n if self._random:\n # Get current values of parents for use as arguments for _random()\n r = self._random(**self.parents.value)\n else:\n raise AttributeError, 'Stochastic '+self.__name__+' does not know how to draw its value, see documentation'\n\n if self.shape:\n r = np.reshape(r, self.shape)\n\n # Set Stochastic's value to drawn value\n if not self.observed:\n self.value = r\n\n return r\n\n # Shortcut alias to random\n rand = random\n\n def _get_isdata(self):\n import warnings\n warnings.warn('\"isdata\" is deprecated, please use \"observed\" instead.')\n return self._observed\n def _set_isdata(self, isdata):\n raise ValueError, 'Stochastic %s: \"observed\" flag cannot be changed.'%self.__name__\n isdata = property(_get_isdata, _set_isdata)\n\n def _get_observed(self):\n return self._observed\n def _set_observed(self, observed):\n raise ValueError, 'Stochastic %s: \"observed\" flag cannot be changed.'%self.__name__\n observed = property(_get_observed, _set_observed)\n\n\n def _get_coparents(self):\n coparents = set()\n for child in self.extended_children:\n coparents |= child.extended_parents\n coparents.add(self)\n return coparents\n coparents = property(_get_coparents, doc=\"All the variables whose extended children intersect with self's.\")\n\n def _get_moral_neighbors(self):\n moral_neighbors = self.coparents | self.extended_parents | self.extended_children\n for neighbor in copy(moral_neighbors):\n if isinstance(neighbor, PotentialBase):\n moral_neighbors.remove(neighbor)\n return moral_neighbors\n moral_neighbors = property(_get_moral_neighbors, doc=\"Self's neighbors in the moral graph: self's Markov blanket with self removed.\")\n\n def _get_markov_blanket(self):\n return self.moral_neighbors | set([self])\n markov_blanket = property(_get_markov_blanket, doc=\"Self's coparents, self's extended parents, self's children and self.\")\n", "meta": {"hexsha": "60b9589437664931b7a2fcb345442567e38bdd33", "size": 24447, "ext": "py", "lang": "Python", "max_stars_repo_path": "pymc/PyMCObjects.py", "max_stars_repo_name": "matthew-brett/pymc", "max_stars_repo_head_hexsha": "3a31613f056e7993a449d89bafef5fdaa40d47e9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2015-12-03T09:42:44.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-06T19:23:29.000Z", "max_issues_repo_path": "pymc/PyMCObjects.py", "max_issues_repo_name": "matthew-brett/pymc", "max_issues_repo_head_hexsha": "3a31613f056e7993a449d89bafef5fdaa40d47e9", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2016-09-27T02:00:41.000Z", "max_issues_repo_issues_event_max_datetime": "2016-09-27T02:15:32.000Z", "max_forks_repo_path": "pymc/PyMCObjects.py", "max_forks_repo_name": "matthew-brett/pymc", "max_forks_repo_head_hexsha": "3a31613f056e7993a449d89bafef5fdaa40d47e9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2017-10-27T13:27:32.000Z", "max_forks_repo_forks_event_max_datetime": "2017-10-27T13:27:32.000Z", "avg_line_length": 33.7665745856, "max_line_length": 142, "alphanum_fraction": 0.6085818301, "include": true, "reason": "import numpy,from numpy", "num_tokens": 5232, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.37754066879814546, "lm_q1q2_score": 0.1931938291751268}} {"text": "# Copyright 2016 Raytheon BBN Technologies\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n\ntry:\n from QGL import *\n from QGL import config as QGLconfig\n from QGL.BasicSequences.helpers import create_cal_seqs, delay_descriptor, cal_descriptor\nexcept:\n print(\"Could not find QGL\")\n\nimport auspex.config as config\nfrom auspex.log import logger\nfrom copy import copy, deepcopy\nfrom adapt.refine import refine_1D\nimport os\nimport uuid\nimport pandas as pd\nimport networkx as nx\nimport scipy as sp\nimport subprocess\nimport zmq\nimport json\nimport datetime\n\nimport time\nimport bbndb\nfrom auspex.filters import DataBuffer\nfrom .qubit_exp import QubitExperiment\nfrom . import pipeline\nfrom auspex.parameter import FloatParameter\nfrom auspex.filters.plot import ManualPlotter\nfrom auspex.analysis.fits import *\nfrom auspex.analysis.qubit_fits import *\nfrom auspex.analysis.helpers import normalize_data\nfrom matplotlib import cm\nfrom scipy.optimize import curve_fit\nimport numpy as np\nfrom itertools import product\n\nimport bbndb\n\nclass Calibration(object):\n\n def __init__(self):\n self.do_plotting = True\n self.uuid = str(uuid.uuid4())\n\n def init_plots(self):\n \"\"\"Return a ManualPlotter object so we can plot calibrations. All\n plot lines, glyphs, etc. must be declared up front!\"\"\"\n return None\n\n def start_plots(self):\n # Create the descriptor and set uuids for each plot process\n plot_desc = {p.filter_name: p.desc() for p in self.plotters}\n\n for p in self.plotters:\n p.uuid = self.uuid\n try:\n time.sleep(1.0)\n context = zmq.Context()\n socket = context.socket(zmq.DEALER)\n socket.setsockopt(zmq.LINGER, 0)\n socket.identity = \"Auspex_Experiment\".encode()\n socket.connect(\"tcp://localhost:7761\")\n socket.send_multipart([self.uuid.encode(), json.dumps(plot_desc).encode('utf8')])\n\n poller = zmq.Poller()\n poller.register(socket, zmq.POLLIN)\n\n evts = dict(poller.poll(5000))\n if socket in evts:\n try:\n if socket.recv_multipart()[0] == b'ACK':\n logger.info(\"Connection established to plot server.\")\n self.do_plotting = True\n else:\n raise Exception(\"Server returned invalid message, expected ACK.\")\n except:\n logger.info(\"Could not connect to server.\")\n for p in self.plotters:\n p.do_plotting = False\n else:\n logger.info(\"Server did not respond.\")\n for p in self.plotters:\n p.do_plotting = False\n\n except Exception as e:\n logger.warning(f\"Exception {e} occured while contacting the plot server. Is it running?\")\n for p in self.plotters:\n p.do_plotting = False\n\n for p in self.plotters:\n p.start()\n\n def stop_plots(self):\n for p in self.plotters:\n p.start()\n\n def calibrate(self):\n if self.do_plotting:\n self.plotters = self.init_plots()\n self.start_plots()\n\n self._calibrate()\n\n if self.succeeded:\n self.update_settings()\n\n if self.do_plotting:\n self.stop_plots()\n\n def update_settings(self):\n # Must be overriden in child class\n pass\n\n def descriptor(self):\n return None\n\n def _calibrate(self):\n \"\"\"Runs the actual calibration routine, must be overridden to provide any useful functionality.\n This function is responsible for calling self.update_plot()\"\"\"\n pass\n\n def exp_config(self, exp):\n \"\"\"Any final experiment configuration before it gets run.\"\"\"\n pass\n\nclass QubitCalibration(Calibration):\n calibration_experiment = None\n def __init__(self, qubits, sample_name=None, output_nodes=None, stream_selectors=None, quad=\"real\", auto_rollback=True, do_plotting=True, **kwargs):\n self.qubits = qubits if isinstance(qubits, list) else [qubits]\n self.qubit = None if isinstance(qubits, list) else qubits\n self.output_nodes = output_nodes if isinstance(output_nodes, list) else [output_nodes]\n self.stream_selectors = stream_selectors if isinstance(stream_selectors, list) else [stream_selectors]\n self.filename = 'None'\n self.axis_descriptor = None\n self.leave_plots_open = True\n self.cw_mode = False\n self.quad = quad\n self.succeeded = False\n self.norm_points = None\n self.auto_rollback = True # Rollback any db changes upon calibration failure\n self.kwargs = kwargs\n self.plotters = []\n self.do_plotting = do_plotting\n self.fake_data = None\n self.sample = None\n try:\n self.quad_fun = {\"real\": np.real, \"imag\": np.imag, \"amp\": np.abs, \"phase\": np.angle}[quad]\n except:\n raise ValueError('Quadrature to calibrate must be one of (\"real\", \"imag\", \"amp\", \"phase\").')\n super(QubitCalibration, self).__init__()\n\n if sample_name:\n if not bbndb.session:\n raise Exception(\"Attempting to load Calibrations database, \\\n but no database session is open! Have the ChannelLibrary and PipelineManager been created?\")\n existing_samples = list(bbndb.session.query(bbndb.calibration.Sample).filter_by(name=sample_name).all())\n if len(existing_samples) == 0:\n logger.info(\"Creating a new sample in the calibration database.\")\n self.sample = bbndb.calibration.Sample(name=sample_name)\n bbndb.session.add(self.sample)\n elif len(existing_samples) == 1:\n self.sample = existing_samples[0]\n else:\n raise Exception(\"Multiple samples found in calibration database with the same name! How?\")\n\n def sequence(self):\n \"\"\"Returns the sequence for the given calibration, must be overridden\"\"\"\n raise NotImplementedError(\"Must run a specific qubit calibration.\")\n\n def set_fake_data(self, *args, **kwargs):\n self.fake_data = (args, kwargs)\n\n def run_sweeps(self):\n meta_file = compile_to_hardware(self.sequence(), fileName=self.filename, axis_descriptor=self.descriptor())\n exp = CalibrationExperiment(self.qubits, self.output_nodes, self.stream_selectors, meta_file, **self.kwargs)\n if self.fake_data:\n exp.set_fake_data(*self.fake_data[0], **self.fake_data[1])\n self.exp_config(exp)\n exp.run_sweeps()\n\n data = {}\n var = {}\n\n for qubit, output_buff, var_buff in zip(exp.qubits,\n [exp.proxy_to_filter[on] for on in exp.output_nodes],\n [exp.proxy_to_filter[on] for on in exp.var_buffers]):\n if not isinstance(output_buff, DataBuffer):\n raise ValueError(\"Could not find data buffer for calibration.\")\n\n dataset, descriptor = output_buff.get_data()\n if self.norm_points:\n buff_data = normalize_data(dataset, zero_id=self.norm_points[qubit.label][0],\n one_id=self.norm_points[self.qubit.label][1])\n else:\n buff_data = dataset\n\n data[qubit.label] = self.quad_fun(buff_data)\n\n var_dataset, var_descriptor = var_buff.get_data()\n # if 'Variance' in dataset.dtype.names:\n realvar = np.real(var_dataset)\n imagvar = np.imag(var_dataset)\n N = descriptor.metadata[\"num_averages\"]\n if self.quad in ['real', 'imag']:\n var[qubit.label] = self.quad_fun(var_dataset)/N\n elif self.quad == 'amp':\n var[qubit.label] = (realvar + imagvar)/N\n elif self.quad == 'phase':\n # take the approach from Qlab assuming the noise is\n # Gaussian in both quadratures i.e. 'circular' in the IQ plane.\n stddata = np.sqrt(realvar + imagvar)\n stdtheta = 180/np.pi * 2 * np.arctan(stddata/abs(data[qubit.label]))\n var[qubit.label] = (stdtheta**2)/N\n else:\n raise Exception('Variance of {} not available. Choose amp, phase, real or imag'.format(self.quad))\n\n # Return data and variance of the mean\n if len(data) == 1:\n # if single qubit, get rid of dictionary\n data = list(data.values())[0]\n var = list(var.values())[0]\n return data, var\n\nclass CalibrationExperiment(QubitExperiment):\n\n def __init__(self, qubits, output_nodes, stream_selectors, *args, **kwargs):\n self.qubits = qubits\n self.output_nodes = output_nodes\n self.input_selectors = stream_selectors # name collision otherwise\n self.var_buffers = []\n super(CalibrationExperiment, self).__init__(*args, **kwargs)\n\n def guess_output_nodes(self, graph):\n output_nodes = []\n qubit_labels = [q.label for q in self.qubits]\n for qubit in self.qubits:\n stream_sels = [ss for ss in self.stream_selectors if ss.qubit_name == qubit.label]\n if len(stream_sels) > 1:\n raise Exception(f\"More than one stream selector found for {qubit}, please explicitly define output node using output_nodes argument.\")\n ds = nx.descendants(graph, stream_sels[0].hash_val)\n outputs = [graph.nodes[d]['node_obj'] for d in ds if isinstance(graph.nodes[d]['node_obj'], (bbndb.auspex.Write, bbndb.auspex.Buffer))]\n if len(outputs) > 1:\n raise Exception(f\"More than one output node found for {qubit}, please explicitly define output node using output_nodes argument.\")\n output_nodes.append(outputs[0])\n\n return output_nodes\n\n def modify_graph(self, graph):\n \"\"\"Change the graph as needed. By default we changes all writers to buffers\"\"\"\n if None in self.output_nodes:\n self.output_nodes = self.guess_output_nodes(graph)\n\n for output_node in self.output_nodes:\n if output_node.hash_val not in graph:\n raise ValueError(f\"Could not find specified output node {output_node} in graph.\")\n\n for qubit in self.qubits:\n stream_sels = [ss for ss in self.stream_selectors if ss.qubit_name == qubit.label]\n if not any([ss.hash_val in graph for ss in stream_sels]):\n raise ValueError(f\"Could not find specified qubit {qubit} in graph.\")\n\n mapping = {}\n for i in range(len(self.output_nodes)):\n output_node = self.output_nodes[i]\n if isinstance(output_node, bbndb.auspex.Write):\n # Change the output node to a buffer\n mapping[output_node] = bbndb.auspex.Buffer(label=output_node.label, qubit_name=output_node.qubit_name)\n\n # Disable any paths not involving the buffer\n new_graph = nx.DiGraph()\n new_output_nodes = []\n for output_node, qubit in zip(self.output_nodes, self.qubits):\n new_output = mapping[output_node]\n new_output_nodes.append(new_output)\n\n ancestors = [graph.nodes[n]['node_obj'] for n in nx.ancestors(graph, output_node.hash_val)]\n stream_sels = [a for a in ancestors if isinstance(a, bbndb.auspex.StreamSelect)]\n if len(stream_sels) != 1:\n raise Exception(f\"Expected to find one stream selector for {qubit}. Instead found {len(stream_sels)}\")\n stream_sel = stream_sels[0]\n\n old_path = nx.shortest_path(graph, stream_sel.hash_val, output_node.hash_val)\n path = old_path[:-1] + [new_output.hash_val]\n nx.add_path(new_graph, path)\n for n in old_path[:-1]:\n new_graph.nodes[n]['node_obj'] = graph.nodes[n]['node_obj']\n new_graph.nodes[new_output.hash_val]['node_obj'] = mapping[output_node]\n\n # Fix connectors\n for i in range(len(path)-1):\n new_graph[path[i]][path[i+1]]['connector_in'] = graph[old_path[i]][old_path[i+1]]['connector_in']\n new_graph[path[i]][path[i+1]]['connector_out'] = graph[old_path[i]][old_path[i+1]]['connector_out']\n\n if not isinstance(new_graph.nodes(data=True)[path[-2]]['node_obj'], bbndb.auspex.Average):\n raise Exception(\"There is no averager in line.\")\n else:\n vb = bbndb.auspex.Buffer(label=f\"{output_node.label}-VarBuffer\", qubit_name=output_node.qubit_name)\n self.var_buffers.append(vb)\n new_graph.add_node(vb.hash_val, node_obj=vb)\n new_graph.add_edge(path[-2], vb.hash_val, node_obj=vb, connector_in=\"sink\", connector_out=\"final_variance\")\n # maintain standard plots\n plot_nodes = [output_node for output_node in nx.descendants(graph, path[-2]) if isinstance(graph.nodes[output_node]['node_obj'], bbndb.auspex.Display)]\n for plot_node in plot_nodes:\n plot_path = nx.shortest_path(graph, path[-2], plot_node)\n new_graph = nx.compose(new_graph, graph.subgraph(plot_path))\n\n self.output_nodes = new_output_nodes\n return new_graph\n\n def add_cal_sweep(self, method, values):\n par = FloatParameter()\n par.assign_method(method)\n self.add_sweep(par, values)\n\n\nclass CavityTuneup(QubitCalibration):\n def __init__(self, qubit, frequencies, averages=750, **kwargs):\n self.start_frequencies = frequencies\n kwargs['averages'] = averages\n super(CavityTuneup, self).__init__(qubit, **kwargs)\n self.cw_mode = True\n\n def sequence(self):\n return [[Id(self.qubit), MEAS(self.qubit)]]\n\n def exp_config(self, exp):\n exp.add_qubit_sweep(self.qubit, \"measure\", \"frequency\", self.new_frequencies)\n self.quad_fun = lambda x: x\n\n def _calibrate(self):\n # all_data = np.empty(dtype=np.complex128)\n self.new_frequencies = self.start_frequencies\n self.frequencies = np.empty(0, dtype=np.complex128)\n self.group_delays = np.empty(0, dtype=np.complex128)\n self.datas = np.empty(0, dtype=np.complex128)\n # orig_avg = self.kwargs['averages']\n # Adaptive refinement to find cavity feature\n # for i in range(self.iterations + 1):\n self.data, _ = self.run_sweeps()\n self.datas = np.append(self.datas, self.data)\n self.frequencies = np.append(self.frequencies, self.new_frequencies[:-1])\n\n ord = np.argsort(self.frequencies)\n self.datas = self.datas[ord]\n self.frequencies = self.frequencies[ord]\n\n self.phases = np.unwrap(np.angle(self.datas))\n self.group_delays = -np.diff(self.phases)/np.diff(self.frequencies)\n phase_poly = np.poly1d(np.polyfit(self.frequencies, self.phases, 6))\n # group_delay_poly = phase_poly.deriv()\n # fine_freqs = np.linspace(self.frequencies[0], self.frequencies[-1], self.iterations*len(self.frequencies))\n subtracted = self.phases - phase_poly(self.frequencies)\n group_delay = np.diff(subtracted)/np.diff(self.frequencies)\n\n # ordering = np.argsort(self.frequencies[:-1])\n self.plot1[\"Phase\"] = (self.frequencies, self.phases)\n self.plot1[\"Phase Fit\"] = (self.frequencies,phase_poly(self.frequencies))\n self.plot1B[\"Group Delay\"] = (self.frequencies[:-1],group_delay)\n self.plot2[\"Amplitude\"] = (self.frequencies,np.abs(self.datas))\n\n guess = np.abs(self.frequencies[np.argmax(np.abs(group_delay))])\n self.new_frequencies = np.arange(guess-15e6, guess+15e6, 1e6)\n self.frequencies = np.empty(0, dtype=np.complex128)\n self.group_delays = np.empty(0, dtype=np.complex128)\n self.datas = np.empty(0, dtype=np.complex128)\n\n self.data, _ = self.run_sweeps()\n self.datas = np.append(self.datas, self.data)\n self.frequencies = np.append(self.frequencies, self.new_frequencies[:-1])\n\n ord = np.argsort(self.frequencies)\n self.datas = self.datas[ord]\n self.frequencies = self.frequencies[ord]\n\n self.phases = np.unwrap(np.angle(self.datas))\n self.group_delays = -np.diff(self.phases)/np.diff(self.frequencies)\n phase_poly = np.poly1d(np.polyfit(self.frequencies, self.phases, 6))\n # group_delay_poly = phase_poly.deriv()\n # fine_freqs = np.linspace(self.frequencies[0], self.frequencies[-1], self.iterations*len(self.frequencies))\n subtracted = self.phases - phase_poly(self.frequencies)\n group_delay = np.diff(subtracted)/np.diff(self.frequencies)\n\n # ordering = np.argsort(self.frequencies[:-1])\n self.plot1[\"Phase\"] = (self.frequencies, self.phases)\n self.plot1[\"Phase Fit\"] = (self.frequencies,phase_poly(self.frequencies))\n self.plot1B[\"Group Delay\"] = (self.frequencies[:-1],group_delay)\n self.plot2[\"Amplitude\"] = (self.frequencies,np.abs(self.datas))\n\n guess = np.abs(self.frequencies[np.argmax(np.abs(group_delay))])\n self.new_frequencies = np.arange(guess-4e6, guess+4e6, 0.2e6)\n self.frequencies = np.empty(0, dtype=np.complex128)\n self.group_delays = np.empty(0, dtype=np.complex128)\n self.datas = np.empty(0, dtype=np.complex128)\n\n self.data, _ = self.run_sweeps()\n self.datas = np.append(self.datas, self.data)\n self.frequencies = np.append(self.frequencies, self.new_frequencies[:-1])\n\n ord = np.argsort(self.frequencies)\n self.datas = self.datas[ord]\n self.frequencies = self.frequencies[ord]\n\n self.phases = np.unwrap(np.angle(self.datas))\n self.group_delays = -np.diff(self.phases)/np.diff(self.frequencies)\n phase_poly = np.poly1d(np.polyfit(self.frequencies, self.phases, 6))\n # group_delay_poly = phase_poly.deriv()\n # fine_freqs = np.linspace(self.frequencies[0], self.frequencies[-1], self.iterations*len(self.frequencies))\n subtracted = self.phases - phase_poly(self.frequencies)\n group_delay = np.diff(subtracted)/np.diff(self.frequencies)\n\n # ordering = np.argsort(self.frequencies[:-1])\n self.plot1[\"Phase\"] = (self.frequencies, self.phases)\n self.plot1[\"Phase Fit\"] = (self.frequencies,phase_poly(self.frequencies))\n self.plot1B[\"Group Delay\"] = (self.frequencies[:-1],group_delay)\n\n self.plot2[\"Amplitude\"] = (self.frequencies,np.abs(self.datas))\n\n shifted_cav = np.real(self.datas) - np.mean(np.real(self.datas))\n guess = np.abs(self.frequencies[np.argmax(np.abs(shifted_cav))])\n # self.kwargs['averages'] = 2000\n\n # import pdb; pdb.set_trace()\n #\n # self.new_frequencies = refine_1D(self.frequencies, subtracted, all_points=False,\n # criterion=\"difference\", threshold = \"one_sigma\")\n # logger.info(f\"new_frequencies {self.new_frequencies}\")\n\n # n, bins = sp.histogram(np.abs(self.frequencies), bins=\"auto\")\n # f_start = bins[np.argmax(n)]\n # f_stop = bins[np.argmax(n)+1]\n # logger.info(f\"Looking in bin from {f_start} to {f_stop}\")\n\n # # self.kwargs['averages'] = orig_avg\n # self.new_frequencies = np.arange(f_start, f_stop, 2e6)\n # self.frequencies = np.empty(0, dtype=np.complex128)\n # self.group_delays = np.empty(0, dtype=np.complex128)\n # self.datas = np.empty(0, dtype=np.complex128)\n #\n # for i in range(self.iterations + 3):\n # self.data, _ = self.run_sweeps()\n # self.datas = np.append(self.datas, self.data)\n # self.frequencies = np.append(self.frequencies, self.new_frequencies[:-1])\n #\n # ord = np.argsort(self.frequencies)\n # self.datas = self.datas[ord]\n # self.frequencies = self.frequencies[ord]\n #\n # self.group_delays = -np.diff(np.unwrap(np.angle(self.datas)))/np.diff(self.frequencies)\n # # self.group_delays = group_del\n #\n # # ordering = np.argsort(self.frequencies[:-1])\n # self.plot3[\"Group Delay\"] = (self.frequencies[1:],self.group_delays)\n # # self.plot2[\"Amplitude\"] = (self.frequencies,np.abs(self.datas))\n # # self.kwargs['averages'] = 2000\n #\n # self.new_frequencies = refine_1D(self.frequencies[:-1], self.group_delays, all_points=False,\n # criterion=\"integral\", threshold = \"one_sigma\")\n # logger.info(f\"new_frequencies {self.new_frequencies}\")\n # #\n\n # # self.data, _ = self.run_sweeps()\n # # group_delay = -np.diff(np.unwrap(np.angle(self.data)))/np.diff(self.new_frequencies)\n # # self.plot3[\"Group Delay\"] = (self.new_frequencies[1:],group_delay)\n #\n # def lor_der(x, a, x0, width, offset):\n # return offset-(x-x0)*a/((4.0*((x-x0)/width)**2 + a**2)**2)\n # f0 = np.abs(self.frequencies[np.argmax(np.abs(self.group_delays))])\n # p0 = [np.max(np.abs(self.group_delays))*1e-18, np.abs(f0), 200e6, np.abs(self.group_delays)[0]]\n # popt, pcov = curve_fit(lor_der, np.abs(self.frequencies[1:]), np.abs(self.group_delays), p0=p0)\n # self.plot3[\"Group Delay Fit\"] = ( np.abs(self.frequencies[1:]), lor_der( np.abs(self.frequencies[1:]), *popt))\n\n\n def init_plots(self):\n plot1 = ManualPlotter(\"Phase\", x_label='Frequency (GHz)', y_label='Group Delay')\n plot1.add_data_trace(\"Phase\", {'color': 'C1'})\n plot1.add_fit_trace(\"Phase Fit\", {'color': 'C2'})\n\n plot1B = ManualPlotter(\"Group Delay\", x_label='Frequency (GHz)', y_label='Group Delay')\n plot1B.add_data_trace(\"Group Delay\", {'color': 'C1'})\n # plot1B.add_fit_trace(\"Phase Fit\", {'color': 'C2'})\n\n plot2 = ManualPlotter(\"Amplitude\", x_label='Frequency (GHz)', y_label='Amplitude (Arb. Units)')\n plot2.add_data_trace(\"Amplitude\", {'color': 'C2'})\n\n # plot3 = ManualPlotter(\"First refined sweep\", x_label='Frequency (GHz)', y_label='Group Delay')\n # plot3.add_data_trace(\"Group Delay\", {'color': 'C3'})\n # plot3.add_fit_trace(\"Group Delay Fit\", {'color': 'C4'})\n self.plot1 = plot1\n self.plot1B = plot1B\n self.plot2 = plot2\n # self.plot3 = plot3\n return [plot1, plot1B, plot2] #, plot3]\n\nclass QubitTuneup(QubitCalibration):\n def __init__(self, qubit, f_start=5e9, f_stop=6e9, coarse_step=0.1e9, fine_step=1.0e6, averages=500, amp=1.0, **kwargs):\n self.coarse_frequencies = np.arange(f_start, f_stop, coarse_step) - 10.0e6 # Don't stray too close to the carrier tone\n self.fine_frequencies = np.arange(10.0e6, coarse_step+10.0e6, fine_step)\n self.f_start = f_start\n self.f_stop = f_stop\n self.coarse_step = coarse_step\n self.fine_step = fine_step\n self.amp = amp\n kwargs['averages'] = averages\n super(QubitTuneup, self).__init__(qubit, **kwargs)\n\n def sequence(self):\n return [[X(self.qubit, frequency=f, amp=self.amp), MEAS(self.qubit)] for f in self.fine_frequencies]\n\n def exp_config(self, exp):\n exp.add_qubit_sweep(self.qubit, \"control\", \"frequency\", self.coarse_frequencies)\n self.quad_fun = lambda x: x\n\n def _calibrate(self):\n self.data, _ = self.run_sweeps()\n freqs = np.arange(self.f_start, self.f_stop, self.fine_step)\n self.plot[\"Data\"] = (freqs, self.data)\n\n def init_plots(self):\n plot = ManualPlotter(\"Qubit Search\", x_label='Frequency (Hz)', y_label='Amplitude (Arb. Units)')\n plot.add_data_trace(\"Data\", {'color': 'C1'})\n plot.add_fit_trace(\"Fit\", {'color': 'C1'})\n self.plot = plot\n return [plot]\n\nclass RabiAmpCalibration(QubitCalibration):\n\n amp2offset = 0.5\n\n def __init__(self, qubit, num_steps=40, **kwargs):\n if num_steps % 2 != 0:\n raise ValueError(\"Number of steps for RabiAmp calibration must be even!\")\n #for now, only do one qubit at a time\n self.num_steps = num_steps\n self.amps = np.hstack((np.arange(-1, 0, 2./num_steps),\n np.arange(2./num_steps, 1+2./num_steps, 2./num_steps)))\n super(RabiAmpCalibration, self).__init__(qubit, **kwargs)\n self.filename = 'Rabi/Rabi'\n\n def sequence(self):\n return ([[Xtheta(self.qubit, amp=a), MEAS(self.qubit)] for a in self.amps] +\n [[Ytheta(self.qubit, amp=a), MEAS(self.qubit)] for a in self.amps])\n\n def _calibrate(self):\n data, _ = self.run_sweeps()\n N = len(data)\n I_fit = RabiAmpFit(self.amps, data[N//2:])\n Q_fit = RabiAmpFit(self.amps, data[:N//2])\n #Arbitary extra division by two so that it doesn't push the offset too far.\n self.pi_amp = I_fit.pi_amp\n self.pi2_amp = I_fit.pi_amp/2.0\n self.i_offset = I_fit.fit_params[\"phi\"]*self.amp2offset\n self.q_offset = Q_fit.fit_params[\"phi\"]*self.amp2offset\n logger.info(\"Found X180 amplitude: {}\".format(self.pi_amp))\n logger.info(\"Shifting I offset by: {}\".format(self.i_offset))\n logger.info(\"Shifting Q offset by: {}\".format(self.q_offset))\n finer_amps = np.linspace(np.min(self.amps), np.max(self.amps), 4*len(self.amps))\n self.plot[\"I Data\"] = (self.amps, data[:N//2])\n self.plot[\"Q Data\"] = (self.amps, data[N//2:])\n self.plot[\"I Fit\"] = (finer_amps, I_fit.model(finer_amps))\n self.plot[\"Q Fit\"] = (finer_amps, Q_fit.model(finer_amps))\n\n if self.pi_amp <= 1.0 and self.pi2_amp <= 1.0:\n self.succeeded = True\n\n def init_plots(self):\n plot = ManualPlotter(\"Rabi Amplitude Cal\", x_label=\"I/Q Amplitude\", y_label=\"{} (Arb. Units)\".format(self.quad))\n plot.add_data_trace(\"I Data\", {'color': 'C1'})\n plot.add_data_trace(\"Q Data\", {'color': 'C2'})\n plot.add_fit_trace(\"I Fit\", {'color': 'C1'})\n plot.add_fit_trace(\"Q Fit\", {'color': 'C2'})\n self.plot = plot\n return [plot]\n\n def update_settings(self):\n s = round(self.pi_amp, 5)\n self.qubit.pulse_params['pi2Amp'] = round(self.pi2_amp, 5)\n self.qubit.pulse_params['piAmp'] = round(self.pi_amp, 5)\n awg_chan = self.qubit.phys_chan\n amp_factor = self.qubit.phys_chan.amp_factor\n awg_chan.I_channel_offset += round(amp_factor*self.amp2offset*self.i_offset, 5)\n awg_chan.Q_channel_offset += round(amp_factor*self.amp2offset*self.i_offset, 5)\n\n if self.sample:\n c1 = bbndb.calibration.Calibration(value=self.pi2_amp, sample=self.sample, name=\"Pi2Amp\", category=\"Rabi\")\n c2 = bbndb.calibration.Calibration(value=self.pi_amp, sample=self.sample, name=\"PiAmp\", category=\"Rabi\")\n c1.date = c2.date = datetime.datetime.now()\n bbndb.session.add_all([c1, c2])\n bbndb.session.commit()\n\nclass RamseyCalibration(QubitCalibration):\n def __init__(self, qubit, delays=np.linspace(0.0, 20.0, 41)*1e-6,\n two_freqs=False, added_detuning=150e3, set_source=True, AIC=True, **kwargs):\n self.delays = delays\n self.two_freqs = two_freqs\n self.added_detuning = added_detuning\n self.set_source = set_source\n self.AIC = AIC #Akaike information criterion for model choice\n\n super(RamseyCalibration, self).__init__(qubit, **kwargs)\n self.filename = 'Ramsey/Ramsey'\n\n def descriptor(self):\n return [delay_descriptor(self.delays)]\n\n def sequence(self):\n return [[X90(self.qubit), Id(self.qubit, delay), X90(self.qubit), MEAS(self.qubit)] for delay in self.delays]\n\n def init_plots(self):\n plot = ManualPlotter(\"Ramsey Fits\", x_label='Time (us)', y_label='Amplitude (Arb. Units)')\n plot.add_data_trace(\"Data 1\", {'color': 'black'})\n plot.add_fit_trace(\"Fit 1\", {'color': 'red'})\n plot.add_data_trace(\"Data 2\", {'color': 'green'})\n plot.add_fit_trace(\"Fit 2\", {'color': 'blue'})\n self.plot = plot\n return [plot]\n\n def exp_config(self, exp):\n rcvr = self.qubit.measure_chan.receiver_chan.receiver\n if self.first_ramsey:\n self.source_proxy = self.qubit.phys_chan.generator # DB object\n self.qubit_source = exp._instruments[self.source_proxy.label] # auspex instrument\n self.orig_freq = self.source_proxy.frequency\n if self.set_source:\n self.source_proxy.frequency = round(self.orig_freq + self.added_detuning, 10)\n self.qubit_source.frequency = self.source_proxy.frequency\n exp._instruments[rcvr.label].exp_step = 0\n else:\n exp._instruments[rcvr.label].exp_step = 1\n\n def _calibrate(self):\n self.first_ramsey = True\n\n if not self.set_source:\n self.qubit.frequency += float(self.added_detuning)\n data, _ = self.run_sweeps()\n try:\n ramsey_fit = RamseyFit(self.delays, data, two_freqs=self.two_freqs, AIC=self.AIC)\n fit_freqs = ramsey_fit.fit_params[\"f\"]\n except Exception as e:\n raise Exception(f\"Exception {e} while fitting in {self}\")\n\n # Plot the results\n self.plot[\"Data 1\"] = (self.delays, data)\n finer_delays = np.linspace(np.min(self.delays), np.max(self.delays), 4*len(self.delays))\n self.plot[\"Fit 1\"] = (finer_delays, ramsey_fit.model(finer_delays))\n\n #TODO: set conditions for success\n fit_freq_A = np.mean(fit_freqs) #the fit result can be one or two frequencies\n if self.set_source:\n self.source_proxy.frequency = round(self.orig_freq + self.added_detuning + fit_freq_A/2, 10)\n self.qubit_source.frequency = self.source_proxy.frequency\n else:\n self.qubit.frequency += float(fit_freq_A/2)\n\n self.first_ramsey = False\n\n # if self.plot:\n # [self.add_manual_plotter(p) for p in self.plot] if isinstance(self.plot, list) else self.add_manual_plotter(self.plot)\n # self.start_manual_plotters()\n data, _ = self.run_sweeps()\n\n try:\n ramsey_fit = RamseyFit(self.delays, data, two_freqs=self.two_freqs, AIC=self.AIC)\n fit_freqs = ramsey_fit.fit_params[\"f\"]\n except Exception as e:\n raise Exception(f\"Exception {e} while fitting in {self}\")\n\n # Plot the results\n self.plot[\"Data 2\"] = (self.delays, data)\n self.plot[\"Fit 2\"] = (finer_delays, ramsey_fit.model(finer_delays))\n\n fit_freq_B = np.mean(fit_freqs)\n if fit_freq_B < fit_freq_A:\n self.fit_freq = round(self.orig_freq + self.added_detuning + 0.5*(fit_freq_A + 0.5*fit_freq_A + fit_freq_B), 10)\n else:\n self.fit_freq = round(self.orig_freq + self.added_detuning - 0.5*(fit_freq_A - 0.5*fit_freq_A + fit_freq_B), 10)\n\n def update_settings(self):\n if self.set_source:\n self.source_proxy.frequency = float(round(self.fit_freq))\n self.qubit_source.frequency = self.source_proxy.frequency\n else:\n self.qubit.frequency += float(round(self.fit_freq - self.orig_freq))\n # update edges where this is the target qubit\n for edge in self.qubit.edge_target:\n edge_source = edge.phys_chan.generator\n edge.frequency = self.source_proxy.frequency + self.qubit_source.frequency - edge_source.frequency\n # # TODO: fix this for db backend\n\n # qubit_set_freq = self.saved_settings['instruments'][qubit_source]['frequency'] + self.saved_settings['qubits'][self.qubit.label]['control']['frequency']\n # logger.info(\"Qubit set frequency = {} GHz\".format(round(float(qubit_set_freq/1e9),5)))\n # return ('frequency', qubit_set_freq)\n\nclass PhaseEstimation(QubitCalibration):\n\n amp2offset = 0.5\n\n def __init__(self, qubit, num_pulses= 1, amplitude= 0.1, direction = 'X',\n target=np.pi/2, epsilon=1e-2, max_iter=5, **kwargs):\n #for now, only do one qubit at a time\n self.num_pulses = num_pulses\n self.amplitude = amplitude\n self.direction = direction\n\n self.target = target\n self.epsilon = epsilon\n self.max_iter = max_iter\n\n super(PhaseEstimation, self).__init__(qubit, **kwargs)\n\n self.filename = 'PhaseCal/PhaseCal'\n\n def sequence(self):\n # Determine whether it is a single- or a two-qubit pulse calibration\n if isinstance(self.qubit, list):\n qubit = self.qubit[1]\n cal_pulse = [ZX90_CR(*self.qubit, amp=self.amplitude)]\n else:\n qubit = self.qubit\n cal_pulse = [Xtheta(self.qubit, amp=self.amplitude)]\n\n # Exponentially growing repetitions of the target pulse, e.g.\n # (1, 2, 4, 8, 16, 32, 64, 128, ...) x X90\n seqs = [cal_pulse*n for n in 2**np.arange(self.num_pulses+1)]\n # measure each along Z or Y\n seqs = [s + m for s in seqs for m in [ [MEAS(qubit)], [X90m(qubit), MEAS(qubit)] ]]\n # tack on calibrations to the beginning\n seqs = [[Id(qubit), MEAS(qubit)], [X(qubit), MEAS(qubit)]] + seqs\n # repeat each\n return [copy(s) for s in seqs for _ in range(2)]\n\n def _calibrate(self):\n\n ct = 0\n done = 0\n\n start_amp = self.amplitude\n\n phase_error = []\n\n while not done and ct < self.max_iter:\n ct += 1\n data, var = self.run_sweeps()\n phase, sigma = phase_estimation(data, var)\n self.amplitude, done, error = phase_to_amplitude(phase, sigma, self.amplitude,\n self.target, epsilon=self.epsilon)\n phase_error.append(error)\n\n self.data_plot['data'] = (np.array(range(1, len(data)+1)), data)\n self.plot[\"angle_estimate\"] = (np.array(range(1, len(phase_error)+1)), np.array(phase_error))\n\n if done == -1:\n self.succeeded = False\n elif done == 1:\n self.succeeded = True\n else:\n raise Exception()\n\n def init_plots(self):\n data_plot = ManualPlotter(\"Phase Cal\", x_label=\"Sequence Number\", y_label=\"{} (Arb. Units)\".format(self.quad))\n data_plot.add_data_trace(\"data\", {'color': 'C1'})\n plot = ManualPlotter(\"Phase Angle Error\", x_label=\"Iteration\", y_label=\"Angle (rad.)\")\n plot.add_data_trace(\"angle_estimate\", {'color': 'C1'})\n self.plot = plot\n self.data_plot = data_plot\n return [data_plot, plot]\n\n def update_settings(self):\n logger.warning(\"Nothing to update.\")\n\n\nclass Pi2Calibration(PhaseEstimation):\n\n def __init__(self, qubit, num_pulses= 1, direction = 'X',\n epsilon=1e-2, max_iter=5, **kwargs):\n super(Pi2Calibration, self).__init__(qubit, num_pulses=num_pulses,\n amplitude=qubit.pulse_params['pi2Amp'], direction =direction,\n target=np.pi/2, epsilon=epsilon, max_iter=max_iter, **kwargs)\n\n def update_settings(self):\n self.qubit.pulse_params['pi2Amp'] = round(self.amplitude, 5)\n\n if self.sample:\n c = bbndb.calibration.Calibration(value=self.amplitude, sample=self.sample, name=\"Pi2Amp\", category=\"PhaseEstimation\")\n c.date = datetime.datetime.now()\n bbndb.session.add(c)\n bbndb.session.commit()\n\nclass PiCalibration(PhaseEstimation):\n\n def __init__(self, qubit, num_pulses= 1, direction = 'X',\n epsilon=1e-2, max_iter=5, **kwargs):\n super(PiCalibration, self).__init__(qubit, num_pulses=num_pulses,\n amplitude=qubit.pulse_params['piAmp'], direction =direction,\n target=np.pi, epsilon=epsilon, max_iter=max_iter, **kwargs)\n\n def update_settings(self):\n self.qubit.pulse_params['piAmp'] = round(self.amplitude, 5)\n\n if self.sample:\n c = bbndb.calibration.Calibration(value=self.amplitude, sample=self.sample, name=\"PiAmp\", category=\"PhaseEstimation\")\n c.date = datetime.datetime.now()\n bbndb.session.add(c)\n bbndb.session.commit()\n\n# class CRAmpCalibration_PhEst(PhaseEstimation):\n# def __init__(self, qubit_names, num_pulses= 9):\n# super(CRAmpCalibration_PhEst, self).__init__(qubit_names, num_pulses = num_pulses)\n# self.CRchan = ChannelLibraries.EdgeFactory(*self.qubit)\n# self.amplitude = self.CRchan.pulse_params['amp']\n# self.target = np.pi/2\n# self.edge_name = self.CRchan.label\n\nclass DRAGCalibration(QubitCalibration):\n def __init__(self, qubit, deltas = np.linspace(-1,1,21), num_pulses = np.arange(8, 48, 4), **kwargs):\n self.filename = 'DRAG/DRAG'\n self.deltas = deltas\n self.num_pulses = num_pulses\n super(DRAGCalibration, self).__init__(qubit, **kwargs)\n\n def sequence(self):\n seqs = []\n for n in self.num_pulses:\n seqs += [[X90(self.qubit, drag_scaling = d), X90m(self.qubit, drag_scaling = d)]*n + [X90(self.qubit, drag_scaling = d), MEAS(self.qubit)] for d in self.deltas]\n seqs += create_cal_seqs((self.qubit,),2)\n return seqs\n\n def init_plots(self):\n plot = ManualPlotter(\"DRAG Cal\", x_label=['DRAG parameter', 'Number of pulses'], y_label=['Amplitude (Arb. Units)', 'Fit DRAG parameter'], numplots = 2)\n cmap = cm.viridis(np.linspace(0, 1, len(self.num_pulses)))\n for n in range(len(self.num_pulses)):\n plot.add_data_trace('Data_{}'.format(n), {'color': list(cmap[n]), 'linestyle': 'None'})\n plot.add_fit_trace('Fit_{}'.format(n), {'color': list(cmap[n])})\n plot.add_data_trace('Data_opt', subplot_num = 1) #TODO: error bars\n self.plot = plot\n return [plot]\n\n def exp_config(self, exp):\n rcvr = self.qubit.measure_chan.receiver_chan.receiver\n exp._instruments[rcvr.label].exp_step = self.step #where from?\n\n def _calibrate(self):\n # run twice for different DRAG parameter ranges\n for k in range(2):\n self.step = k\n data, _ = self.run_sweeps()\n finer_deltas = np.linspace(np.min(self.deltas), np.max(self.deltas), 4*len(self.deltas))\n #normalize data with cals\n data = quick_norm_data(data)\n try:\n opt_drag, error_drag, popt_mat = fit_drag(data, self.deltas, self.num_pulses)\n if k==1:\n self.succeeded = True\n except Exception as e:\n raise Exception(f\"Exception {e} while fitting in {self}\")\n\n norm_data = data.reshape((len(self.num_pulses), len(self.deltas)))\n for n in range(len(self.num_pulses)):\n self.plot['Data_{}'.format(n)] = (self.deltas, norm_data[n, :])\n finer_deltas = np.linspace(np.min(self.deltas), np.max(self.deltas), 4*len(self.deltas))\n self.plot['Fit_{}'.format(n)] = (finer_deltas, quadf(finer_deltas, *popt_mat[:, n]))\n self.plot[\"Data_opt\"] = (self.num_pulses, opt_drag) #TODO: add error bars\n\n if k==0:\n #generate sequence with new pulses and drag parameters\n new_drag_step = 0.25*(max(self.deltas) - min(self.deltas))\n self.deltas = np.linspace(opt_drag[-1] - new_drag_step, opt_drag[-1] + new_drag_step, len(self.deltas))\n new_pulse_step = int(np.floor(2*(max(self.num_pulses)-min(self.num_pulses))/len(self.num_pulses)))\n self.num_pulses = np.arange(max(self.num_pulses) - new_pulse_step, max(self.num_pulses) + new_pulse_step*(len(self.num_pulses)-1), new_pulse_step)\n\n if not self.leave_plots_open:\n self.plot.set_quit()\n self.opt_drag = round(float(opt_drag[-1]), 5)\n\n def update_settings(self):\n logger.info(f'{self.qubit.label} DRAG parameter set to {self.opt_drag}')\n self.qubit.pulse_params['drag_scaling'] = self.opt_drag\n\n if self.sample:\n c = bbndb.calibration.Calibration(value=self.opt_drag, sample=self.sample, name=\"drag_scaling\")\n c.date = datetime.datetime.now()\n bbndb.session.add(c)\n bbndb.session.commit()\n\n# class MeasCalibration(Calibration):\n# def __init__(self, qubit_name):\n# super(MeasCalibration, self).__init__(qubit, **kwargs)\n# self.meas_name = \"M-\" + qubit_name\n\n# class CLEARCalibration(MeasCalibration):\n# '''\n# Calibration of cavity reset pulse\n# aux_qubit: auxiliary qubit used for CLEAR pulse\n# kappa: cavity linewidth (angular frequency: 1/s)\n# chi: half of the dispershive shift (angular frequency: 1/s)\n# tau: duration of each of the 2 depletion steps (s)\n# alpha: scaling factor\n# T1factor: decay due to T1 between end of msm't and start of Ramsey\n# T2: measured T2*\n# nsteps: calibration steps/sweep\n# cal_steps: choose ranges for calibration steps. 1: +-100%; 0: skip step\n# '''\n# def __init__(self, qubit, aux_qubit, kappa = 2e6, chi = 1e6, t_empty = 200e-9, ramsey_delays=np.linspace(0.0, 50.0, 51)*1e-6, ramsey_freq = 100e3, meas_delay = 0, tau = 200e-9, \\\n# alpha = 1, T1factor = 1, T2 = 30e-6, nsteps = 11, eps1 = None, eps2 = None, cal_steps = (1,1,1)):\n# super(CLEARCalibration, self).__init__(qubit, **kwargs)\n# self.filename = 'CLEAR/CLEAR'\n# self.aux_qubit = aux_qubit\n# self.kappa = kappa\n# self.chi = chi\n# self.ramsey_delays = ramsey_delays\n# self.ramsey_freq = ramsey_freq\n# self.meas_delay = meas_delay\n# self.tau = tau\n# self.alpha = alpha\n# self.T1factor = T1factor\n# self.T2 = T2\n# self.nsteps = nsteps\n# if not eps1:\n# # theoretical values as default\n# self.eps1 = (1 - 2*np.exp(kappa*t_empty/4)*np.cos(chi*t_empty/2))/(1+np.exp(kappa*t_empty/2)-2*np.exp(kappa*t_empty/4)*np.cos(chi*t_empty/2))\n# self.eps2 = 1/(1+np.exp(kappa*t_empty/2)-2*np.exp(kappa*t_empty/4)*np.cos(chi*t_empty/2))\n# self.cal_steps = cal_steps\n\n# def sequence(self, **params):\n# qM = QubitFactory(self.aux_qubit) #TODO: replace with MEAS(q) devoid of digitizer trigger\n# prep = X(self.qubit) if params['state'] else Id(self.qubit)\n# seqs = [[prep, MEAS(qM, amp1 = params['eps1'], amp2 = params['eps2'], step_length = self.tau), X90(self.qubit), Id(self.qubit,d), U90(self.qubit,phase = self.ramsey_freq*d),\n# Id(self.qubit, self.meas_delay), MEAS(self.qubit)] for d in self.ramsey_delays]\n# seqs += create_cal_seqs((self.qubit,), 2, delay = self.meas_delay)\n# return seqs\n\n# def init_plots(self): #keep in a single plot?\n# plot_raw = ManualPlotter(\"CLEAR Ramsey\", x_label='Time (us)', y_label='')\n# plot_res = ManualPlotter(\"CLEAR Cal\", x_label= ['eps1, eps2', 'eps1', 'eps2'], y_label=['Residual photons n0', '', ''], numplots=3)\n\n# plot_raw.add_data_trace('Data')\n# plot_raw.add_fit_trace('Fit')\n# for sweep_num, state in product([0,1,2], [0,1]):\n# plot_res.add_data_trace('sweep {}, state {}'.format(sweep_num, state), {'color': 'C{}'.format(state+1)}, sweep_num) #TODO: error bar\n# plot_res.add_fit_trace('Fit sweep {}, state {}'.format(sweep_num, state), {'color' : 'C{}'.format(state+1)}, sweep_num) #TODO\n# return [plot_raw, plot_res]\n\n\n# def calibrate(self):\n# cal_step = 0\n# for ct in range(3):\n# if not self.cal_steps[ct]:\n# continue\n# #generate sequence\n# xpoints = np.linspace(1-self.cal_steps[ct], 1+self.cal_steps[ct], self.nsteps)\n# n0vec = np.zeros(self.nsteps)\n# err0vec = np.zeros(self.nsteps)\n# n1vec = np.zeros(self.nsteps)\n# err1vec = np.zeros(self.nsteps)\n# for k in range(self.nsteps):\n# eps1 = self.eps1 if k==1 else xpoints[k]*self.eps1\n# eps2 = self.eps2 if k==2 else xpoints[k]*self.eps2\n# #run for qubit in 0/1\n# for state in [0,1]:\n# self.set(eps1 = eps1, eps2 = eps2, state = state, exp_step = cal_step)\n# #analyze\n# data, _ = self.run()\n# norm_data = quick_norm_data(data)\n# eval('n{}vec'.format(state))[k], eval('err{}vec'.format(state))[k], fit_curve = fit_photon_number(self.ramsey_delays, norm_data, [self.kappa, self.ramsey_freq, 2*self.chi, self.T2, self.T1factor, 0])\n# #plot\n# self.plot[0]['Data'] = (self.ramsey_delays, norm_data)\n# self.plot[0]['Fit'] = fit_curve\n# self.plot[1]['sweep {}, state 0'.format(ct)] = (xpoints, n0vec)\n# self.plot[1]['sweep {}, state 1'.format(ct)] = (xpoints, n1vec)\n# cal_step+=1\n\n# #fit for minimum photon number\n# popt_0,_ = fit_quad(xpoints, n0vec)\n# popt_1,_ = fit_quad(xpoints, n1vec)\n# finer_xpoints = np.linspace(np.min(xpoints), np.max(xpoints), 4*len(xpoints))\n# opt_scaling = np.mean(popt_0[0], popt_1[0])\n# logger.info(\"Optimal scaling factor for step {} = {}\".format(ct+1, opt_scaling))\n\n# if ct<2:\n# self.eps1*=opt_scaling\n# if ct!=1:\n# self.eps2*=opt_scaling\n# self.plot[1]['Fit sweep {}, state 0'.format(ct)] = (finer_xpoints, quadf(finer_xpoints, popt_0))\n# self.plot[1]['Fit sweep {}, state 1'.format(ct)] = (finer_xpoints, quadf(finer_xpoints, popt_1))\n\n# def update_settings(self):\n# #update library (default amp1, amp2 for MEAS)\n# self.saved_settings['qubits'][self.qubit.label]['measure']['pulse_params']['amp1'] = round(float(self.eps1), 5)\n# self.saved_settings['qubits'][self.qubit.label]['measure']['pulse_params']['amp2'] = round(float(self.eps2), 5)\n# self.saved_settings['qubits'][self.qubit.label]['measure']['pulse_params']['step_length'] = round(float(self.tau), 5)\n# super(CLEARCalibration, self).update_settings()\n\n# '''Two-qubit gate calibrations'''\n# class CRCalibration(Calibration):\n# def __init__(self, qubit_names, lengths=np.linspace(20, 1020, 21)*1e-9, phase = 0, amp = 0.8, rise_fall = 40e-9):\n# super(CRCalibration, self).__init__(qubit_names, factory)\n# self.lengths = lengths\n# self.phases = phase\n# self.amps = amp\n# self.rise_fall = rise_fall\n# self.filename = 'CR/CR'\n# self.edge_name = ChannelLibraries.EdgeFactory(*self.qubit).label\n\n# def init_plots(self):\n# plot = ManualPlotter(\"CR\"+str.lower(self.cal_type.name)+\"Fit\", x_label=str.lower(self.cal_type.name), y_label='$$', y_lim=(-1.02,1.02))\n# plot.add_data_trace(\"Data 0\", {'color': 'C1'})\n# plot.add_fit_trace(\"Fit 0\", {'color': 'C1'})\n# plot.add_data_trace(\"Data 1\", {'color': 'C2'})\n# plot.add_fit_trace(\"Fit 1\", {'color': 'C2'})\n# return plot\n\n# def calibrate(self):\n# # generate sequence\n# self.set()\n# # run and load normalized data\n# data, _ = self.run(norm_points = {self.qubit_names[0]: (0, 1), self.qubit_names[1]: (0, 2)})\n# # select target qubit\n# data_t = data[self.qubit_names[1]]\n# # fit\n# self.opt_par, all_params_0, all_params_1 = fit_CR([self.lengths, self.phases, self.amps], data_t, self.cal_type)\n# # plot the result\n# xaxis = self.lengths if self.cal_type==CR_cal_type.LENGTH else self.phases if self.cal_type==CR_cal_type.PHASE else self.amps\n# finer_xaxis = np.linspace(np.min(xaxis), np.max(xaxis), 4*len(xaxis))\n# self.plot[\"Data 0\"] = (xaxis, data_t[:len(data_t)//2])\n# self.plot[\"Fit 0\"] = (finer_xaxis, np.polyval(all_params_0, finer_xaxis) if self.cal_type == CR_cal_type.AMP else sinf(finer_xaxis, *all_params_0))\n# self.plot[\"Data 1\"] = (xaxis, data_t[len(data_t)//2:])\n# self.plot[\"Fit 1\"] = (finer_xaxis, np.polyval(all_params_1, finer_xaxis) if self.cal_type == CR_cal_type.AMP else sinf(finer_xaxis, *all_params_1))\n# return (str.lower(self.cal_type.name), self.opt_par)\n\n# def update_settings(self):\n# self.saved_settings['edges'][self.edge_name]['pulse_params'][str.lower(self.cal_type.name)] = float(self.opt_par)\n# super(CRCalibration, self).update_settings()\n\n# class CRLenCalibration(CRCalibration):\n# def __init__(self, qubit_names, factory, lengths=np.linspace(20, 1020, 21)*1e-9, phase = 0, amp = 0.8, rise_fall = 40e-9, cal_type = CR_cal_type.LENGTH):\n# self.cal_type = cal_type\n# super(CRLenCalibration, self).__init__(qubit_names, factory, lengths, phase, amp, rise_fall)\n\n# def sequence(self):\n# qc, qt = self.qubit\n# seqs = [[Id(qc)] + echoCR(qc, qt, length=l, phase = self.phases, amp=self.amps, riseFall=self.rise_fall).seq + [Id(qc), MEAS(qt)*MEAS(qc)]\n# for l in self.lengths]+ [[X(qc)] + echoCR(qc, qt, length=l, phase= self.phases, amp=self.amps, riseFall=self.rise_fall).seq + [X(qc), MEAS(qt)*MEAS(qc)]\n# for l in self.lengths] + create_cal_seqs((qt,qc), 2, measChans=(qt,qc))\n\n# self.axis_descriptor=[\n# delay_descriptor(np.concatenate((self.lengths, self.lengths))),\n# cal_descriptor(tuple(self.qubit), 2)\n# ]\n\n# return seqs\n\n# class CRPhaseCalibration(CRCalibration):\n# def __init__(self, qubit_names, factory, phases = np.linspace(0,2*np.pi,21), amp = 0.8, rise_fall = 40e-9, cal_type = CR_cal_type.PHASE):\n# self.cal_type = cal_type\n# super(CRPhaseCalibration, self).__init__(qubit_names, factory, 0, phases, amp, rise_fall)\n# CRchan = ChannelLibraries.EdgeFactory(*self.qubit)\n# self.lengths = CRchan.pulse_params['length']\n\n\n# def sequence(self):\n# qc, qt = self.qubit\n# seqs = [[Id(qc)] + echoCR(qc, qt, length=self.lengths, phase=ph, amp=self.amps, riseFall=self.rise_fall).seq + [X90(qt)*Id(qc), MEAS(qt)*MEAS(qc)]\n# for ph in self.phases]+ [[X(qc)] + echoCR(qc, qt, length=self.lengths, phase= ph, amp=self.amps, riseFall=self.rise_fall).seq + [X90(qt)*X(qc), MEAS(qt)*MEAS(qc)]\n# for ph in self.phases] + create_cal_seqs((qt,qc), 2, measChans=(qt,qc))\n\n# self.axis_descriptor = [\n# {\n# 'name': 'phase',\n# 'unit': 'radians',\n# 'points': list(self.phases)+list(self.phases),\n# 'partition': 1\n# },\n# cal_descriptor(tuple(self.qubit), 2)\n# ]\n\n# return seqs\n\n# class CRAmpCalibration(CRCalibration):\n# def __init__(self, qubit_names, factory, amp_range = 0.4, amp = 0.8, rise_fall = 40e-9, num_CR = 1, cal_type = CR_cal_type.AMP):\n# self.num_CR = num_CR\n# if num_CR % 2 == 0:\n# logger.error('The number of ZX90 must be odd')\n# self.cal_type = cal_type\n# amps = np.linspace((1-amp_range/2)*amp, (1+amp_range/2)*amp, 21)\n# super(CRAmpCalibration, self).__init__(qubit_names, factory, 0, 0, amps, rise_fall)\n# CRchan = ChannelLibraries.EdgeFactory(*self.qubit)\n# self.lengths = CRchan.pulse_params['length']\n# self.phases = CRchan.pulse_params['phase']\n\n# def sequence(self):\n# qc, qt = self.qubit\n# seqs = [[Id(qc)] + self.num_CR*echoCR(qc, qt, length=self.lengths, phase=self.phases, amp=a, riseFall=self.rise_fall).seq + [Id(qc), MEAS(qt)*MEAS(qc)]\n# for a in self.amps]+ [[X(qc)] + self.num_CR*echoCR(qc, qt, length=self.lengths, phase= self.phases, amp=a, riseFall=self.rise_fall).seq + [X(qc), MEAS(qt)*MEAS(qc)]\n# for a in self.amps] + create_cal_seqs((qt,qc), 2, measChans=(qt,qc))\n\n# self.axis_descriptor = [\n# {\n# 'name': 'amplitude',\n# 'unit': None,\n# 'points': list(self.amps)+list(self.amps),\n# 'partition': 1\n# },\n# cal_descriptor(tuple(self.qubit), 2)\n# ]\n\n# return seqs\n\ndef restrict(phase):\n out = np.mod( phase + np.pi, 2*np.pi, ) - np.pi\n return out\n\ndef phase_estimation( data_in, vardata_in, verbose=False):\n \"\"\"Estimates pulse rotation angle from a sequence of P^k experiments, where\n k is of the form 2^n. Uses the modified phase estimation algorithm from\n Kimmel et al, quant-ph/1502.02677 (2015). Every experiment i doubled.\n vardata should be the variance of the mean\"\"\"\n\n #average together pairs of data points\n avgdata = (data_in[0::2] + data_in[1::2])/2\n\n # normalize data using the first two pulses to calibrate the \"meter\"\n data = 1 + 2*(avgdata[2:] - avgdata[0]) / (avgdata[0] - avgdata[1])\n zdata = data[0::2]\n xdata = data[1::2]\n\n # similar scaling with variances\n vardata = (vardata_in[0::2] + vardata_in[1::2])/2\n vardata = vardata[2:] * 2 / abs(avgdata[0] - avgdata[1])**2\n zvar = vardata[0::2]\n xvar = vardata[1::2]\n\n phases = np.arctan2(xdata, zdata)\n distances = np.sqrt(xdata**2 + zdata**2)\n\n curGuess = phases[0]\n phase = curGuess\n sigma = np.pi\n\n if verbose == True:\n print('Current Guess: %f'%(curGuess))\n\n for k in range(1,len(phases)):\n\n if verbose == True:\n print('k: %d'%(k))\n\n # Each step of phase estimation needs to assign the measured phase to\n # the correct half circle. We will conservatively require that the\n # (x,z) tuple is long enough that we can assign it to the correct\n # quadrant of the circle with 2σ confidence\n\n if distances[k] < 2*np.sqrt(xvar[k] + zvar[k]):\n logger.info('Phase estimation terminated at %dth pulse because the (x,z) vector is too short'%(k))\n break\n\n lowerBound = restrict(curGuess - np.pi/2**(k))\n upperBound = restrict(curGuess + np.pi/2**(k))\n possiblesTest = [ restrict((phases[k] + 2*n*np.pi)/2**(k)) for n in range(0,2**(k)+1)]\n\n if verbose == True:\n logger.info('Lower Bound: %f'%lowerBound)\n logger.info('Upper Bound: %f'%upperBound)\n\n possibles=[]\n for p in possiblesTest:\n # NOTE: previous code did not handle upperbound == lowerBound\n if lowerBound >= upperBound:\n satisfiesLB = p > lowerBound or p < 0.\n satisfiesUP = p < upperBound or p > 0.\n else:\n satisfiesLB = p > lowerBound\n satisfiesUP = p < upperBound\n\n if satisfiesLB == True and satisfiesUP == True:\n possibles.append(p)\n\n curGuess = possibles[0]\n if verbose == True:\n logger.info('Current Guess: %f'%(curGuess))\n\n phase = curGuess\n sigma = np.maximum(np.abs(restrict(curGuess - lowerBound)), np.abs(restrict(curGuess - upperBound)))\n\n return phase, sigma\n\ndef phase_to_amplitude(phase, sigma, amp, target, epsilon=1e-2):\n # correct for some errors related to 2pi uncertainties\n if np.sign(phase) != np.sign(amp):\n phase += np.sign(amp)*2*np.pi\n angle_error = phase - target;\n logger.info('Angle error: %.4f'%angle_error);\n\n amp_target = target/phase * amp\n amp_error = amp - amp_target\n logger.info('Set amplitude: %.4f\\n'%amp)\n logger.info('Amplitude error: %.4f\\n'%amp_error)\n\n amp = amp_target\n done_flag = 0\n\n # check for stopping condition\n phase_error = phase - target\n if np.abs(phase_error) < epsilon or np.abs(phase_error/sigma) < 1:\n if np.abs(phase_error) < epsilon:\n logger.info('Reached target rotation angle accuracy');\n elif abs(phase_error/sigma) < 1:\n logger.info('Reached phase uncertainty limit');\n done_flag = 1\n\n if amp > 1.0 or amp < epsilon:\n logger.warning(f\"Phase estimation returned an unreasonable amplitude setting {amp}. Aborting.\")\n done_flag = -1\n\n return amp, done_flag, phase_error\n\ndef quick_norm_data(data): #TODO: generalize as in Qlab.jl\n \"\"\"Rescale data assuming 2 calibrations / single qubit state at the end of the sequence\"\"\"\n data = 2*(data-np.mean(data[-4:-2]))/(np.mean(data[-4:-2])-np.mean(data[-2:])) + 1\n data = data[:-4]\n return data\n", "meta": {"hexsha": "16e0d56b5758e241b07338b750f42970488ba51f", "size": 56946, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/auspex/qubit/pulse_calibration.py", "max_stars_repo_name": "minhhaiphys/Auspex", "max_stars_repo_head_hexsha": "3b9480120f0cdaf8a1e890a59e0e45e0fab5f1dd", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/auspex/qubit/pulse_calibration.py", "max_issues_repo_name": "minhhaiphys/Auspex", "max_issues_repo_head_hexsha": "3b9480120f0cdaf8a1e890a59e0e45e0fab5f1dd", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/auspex/qubit/pulse_calibration.py", "max_forks_repo_name": "minhhaiphys/Auspex", "max_forks_repo_head_hexsha": "3b9480120f0cdaf8a1e890a59e0e45e0fab5f1dd", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 46.3352318959, "max_line_length": 221, "alphanum_fraction": 0.6131773961, "include": true, "reason": "import numpy,import scipy,from scipy,import networkx", "num_tokens": 14805, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.3775406687981454, "lm_q1q2_score": 0.19319382917512679}} {"text": "\n\n#def write_fits(path,array):\n# from astropy.io import fits\n# hdul = fits.PrimaryHDU(array)\n# hdul.writeto(path,overwrite=True)\n# return\n\ndef write_fits(path,array):\n from astropy.io import fits\n opd = '/Users/mygouf/Python/webbpsf/webbpsf-data4/NIRCam/OPD/OPD_RevW_ote_for_NIRCam_requirements.fits.gz'\n hdul = fits.open(opd)\n hdul[0].header['BUNIT'] \n hdu2 = fits.PrimaryHDU(array)\n hdu2.header['BUNIT'] = 'micron'\n fits.writeto(path, np.nan_to_num(hdu2.data*1e6),hdu2.header,overwrite=True)\n return\n\ndef display_ote_and_psf(inst,ote, opd_vmax=500, psf_vmax=0.1, title=\"OPD and PSF\", **kwargs):\n import matplotlib.pyplot as plt\n import webbpsf\n psf = inst.calc_psf(monochromatic=2e-6,)\n plt.figure(figsize=(12,8))\n ax1=plt.subplot(121)\n ote.display_opd(ax=ax1, vmax=opd_vmax, \n colorbar_orientation='horizontal',\n title='OPD modified for mirror moves') #, cbpad=0.05)\n ax2=plt.subplot(122)\n webbpsf.display_psf(psf, ext=1, vmax=psf_vmax, vmin=psf_vmax/1e4,\n colorbar_orientation='horizontal',\n title=\"PSF sim, 2 microns\") #, cbpad=0.05)\n plt.suptitle(title, fontsize=16)\n \ndef show_telescope_wfe(instr, ax=None, title=None, ticks=True, **kwargs):\n if ax is None:\n ax=plt.gca()\n osys = instr._getOpticalSystem()\n tel_wfe = osys.planes[0]\n tel_wfe.display(what='opd', ax=ax,\n colorbar_orientation='vertical',\n **kwargs)\n if title is None:\n title=tel_wfe.name+\" for\\n\"+instr.name\n ax.set_title(title)\n if not ticks:\n ax.set_xticks([])\n ax.set_yticks([])\n \ndef show_inst_wfe(instr, ax=None, **kwargs):\n if ax is None:\n plt.gca()\n osys = instr._getOpticalSystem()\n pupils = [p for p in osys.planes if p.planetype==poppy.poppy_core.PlaneType.pupil]\n inst_wfe = pupils[-1]\n inst_wfe.display(what='opd', ax=ax, \n colorbar_orientation='vertical', **kwargs)\n plt.title(inst_wfe.name.replace(',','\\n')+ \"field point\")\n \ndef show_tel_inst_wfes(instr):\n plt.figure(figsize=(12,4))\n ax1 = plt.subplot(121)\n show_telescope_wfe(instr, ax=ax1)\n ax2 = plt.subplot(122)\n show_inst_wfe(instr, ax=ax2)\n return\n \ndef dist(yc,xc,y1,x1):\n \"\"\" Returns the Euclidean distance between two points.\n \"\"\"\n return np.sqrt((yc-y1)**2+(xc-x1)**2)\n\ndef find_coords(rad, sep, init_angle, fin_angle):\n angular_range = fin_angle-init_angle\n npoints = (np.deg2rad(angular_range)*rad)/sep #(2*np.pi*rad)/sep\n ang_step = angular_range/npoints #360/npoints\n x = []\n y = []\n for i in range(int(npoints)): \n newx = rad * np.cos(np.deg2rad(ang_step * i + init_angle))\n newy = rad * np.sin(np.deg2rad(ang_step * i + init_angle))\n x.append(newx)\n y.append(newy)\n return np.array(y), np.array(x)\n\ndef contrast_curve(data):\n\n import matplotlib.pyplot as plt\n import photutils\n \n data_crop = data\n\n fwhm = 4\n wedge=(0,360)\n init_angle, fin_angle = wedge\n init_rad=fwhm\n\n NP = data_crop.shape[0]\n print(NP)\n array = data_crop\n centery, centerx = np.array([NP/2,NP/2])\n\n separation = 1.1\n separation = 0.5\n n_annuli = int(np.floor((centery)/separation))\n\n x = centerx\n y = centery\n total = []\n mean = []\n noise = []\n vector_radd = []\n\n #plt.figure(figsize=(5,5)) \n #vmin,vmax=np.min(data_crop),np.max(data_crop)\n #plt.imshow(data_crop, cmap='CMRmap', origin = 'lower', vmin = vmin , vmax = vmax)\n\n for i in range(n_annuli-1):\n y = centery + init_rad + separation*(i)\n rad = dist(centery, centerx, y, x)\n yy, xx = find_coords(rad, fwhm, init_angle, fin_angle)\n yy += centery\n xx += centerx\n\n apertures = photutils.CircularAperture((xx, yy), fwhm/2.)\n #fluxes = photutils.aperture_photometry(array, apertures,mask = stis_mask)\n fluxes = photutils.aperture_photometry(array, apertures)\n fluxes = np.array(fluxes['aperture_sum'])\n\n noise_ann = np.std(fluxes)\n noise.append(noise_ann)\n vector_radd.append(rad)\n\n mean_ann = np.mean(fluxes)\n mean.append(mean_ann)\n\n nb_apertures = apertures.positions.shape[0]\n total_ann = np.sum(fluxes)/nb_apertures\n total.append(total_ann)\n #print(total_ann)\n if i <= 9:\n apertures.plot(color='blue', lw=1.5, alpha=0.5)\n #plt.show()\n\n total0 = np.array(total) \n mean0 = np.array(mean)\n noise0 = np.array(noise)\n vector_rad0 = np.array(vector_radd) \n total0_stis = np.array(total)\n mean0_stis = np.array(mean)\n noise0_stis = np.array(noise)\n vector_rad0_stis = np.array(vector_radd) \n \n return noise0_stis, vector_rad0_stis\n\ndef generate_wavefront_errors(nb_of_maps,errors,nb_zernikes,path):\n\n import poppy,webbpsf\n import random\n import matplotlib.pyplot as plt\n\n # intial wavefront map\n nc = webbpsf.NIRCam()\n nc, ote = webbpsf.enable_adjustable_ote(nc)\n osys = nc._get_aberrations()\n\n # perturbed wavefront map\n nc_perturb = webbpsf.NIRCam()\n nc_perturb, ote_perturb = webbpsf.enable_adjustable_ote(nc_perturb)\n osys_perturb = nc_perturb._get_aberrations()\n\n # final wavefront map\n nc_final = webbpsf.NIRCam()\n nc_final, ote_final = webbpsf.enable_adjustable_ote(nc_final)\n osys_final = nc_final._get_aberrations()\n\n tab_opd_final = []\n for n, error in zip(range(nb_of_maps), errors):\n print(n, error)\n \n # change aberrations in wavefront map: example with random zernikes\n # this map will be our perturbation map and we will add it to the initial map with a certain weight\n\n # creating the perturbation map\n #weight = 0.2\n weight = error/100\n for i in range(nb_zernikes):\n #tmp = random.randint(-10,10)\n tmp = random.randint(-1,1)\n osys_perturb.zernike_coeffs[i] = weight*tmp*osys.zernike_coeffs[i]\n osys_final.zernike_coeffs[i] = osys.zernike_coeffs[i] + weight*tmp*osys.zernike_coeffs[i]\n\n # implementing and displaying the wavefront maps \n #display_ote_and_psf(nc, ote, title=\"Initial OPD and PSF\")\n\n ote_perturb.reset()\n ote_perturb.move_global_zernikes(osys_perturb.zernike_coeffs[0:10])\n #display_ote_and_psf(nc_perturb, ote_perturb, title=\"Perturbed OPD and PSF\")\n\n ote_final.reset()\n ote_final.move_global_zernikes(osys_final.zernike_coeffs[0:10])\n #display_ote_and_psf(nc_final, ote_final, title=\"Final OPD and PSF\")\n\n rms = ote.rms()\n rms_perturb = ote_perturb.rms()\n rms_final = ote_final.rms()\n print(rms,rms_perturb,rms_final)\n print('')\n\n #print(osys.zernike_coeffs)\n #print('')\n #print(osys_perturb.zernike_coeffs)\n #print('')\n #print(osys_final.zernike_coeffs)\n #print('')\n\n opd = poppy.zernike.opd_from_zernikes(osys.zernike_coeffs[0:10],\n npix=1024, basis=poppy.zernike.zernike_basis_faster)\n\n opd_perturb = poppy.zernike.opd_from_zernikes(osys_perturb.zernike_coeffs[0:10],\n npix=1024, basis=poppy.zernike.zernike_basis_faster)\n\n opd_final = poppy.zernike.opd_from_zernikes(osys_final.zernike_coeffs[0:10],\n npix=1024, basis=poppy.zernike.zernike_basis_faster)\n \n #tab_opd_final.append(opd_final)\n \n write_fits(path+'_opd'+str(n)+'.fits',opd)\n write_fits(path+'_opd_perturb'+str(n)+'.fits',opd_perturb)\n write_fits(path+'_opd_final'+str(n)+'.fits',opd_final)\n \n #plt.figure(figsize=(12,4))\n #ax1 = plt.subplot(131)\n #ax1.imshow(opd)\n #ax1.set_title('initial wavefront map')\n #ax2 = plt.subplot(132)\n #ax2.imshow(opd_perturb)\n #ax2.set_title('perturbed wavefront map')\n #ax3 = plt.subplot(133)\n #ax3.imshow(opd_final)\n #ax3.set_title('sum of maps')\n #plt.show()\n\n wavefront_error = mse(np.nan_to_num(opd), np.nan_to_num(opd_final))\n print('mse',error,wavefront_error)\n print(\"MSE: %.2f\" % (wavefront_error*100))\n \n return tab_opd_final\n\ndef mse(image, reference):\n # the 'Mean Squared Error' between the two images is the\n # sum of the squared difference between the two images;\n # NOTE: the two images must have the same dimension\n import numpy as np\n n_points = float(image.shape[0] * image.shape[1])\n err = np.sum((image.astype(\"float\") - reference.astype(\"float\")) ** 2)\n err /= n_points\n err = np.sqrt(err)\n #norm = 1\n #norm = np.sum(reference) / n_points\n norm = np.sqrt(np.sum((np.abs(reference))**2)/n_points)\n print('erreur:',err/norm)\n \n # return the MSE, the lower the error, the more \"similar\"\n # the two images are\n return err/norm\n\ndef compare_images(imageA, imageB, title):\n # compute the mean squared error and structural similarity\n # index for the images\n m = mse(imageA, imageB)\n #s = ssim(imageA, imageB)\n # setup the figure\n fig = plt.figure(title)\n plt.suptitle(\"MSE: %.2f\" % (m))\n # show first image\n ax = fig.add_subplot(1, 2, 1)\n plt.imshow(imageA, cmap = plt.cm.gray)\n plt.axis(\"off\")\n # show the second image\n ax = fig.add_subplot(1, 2, 2)\n plt.imshow(imageB, cmap = plt.cm.gray)\n plt.axis(\"off\")\n # show the images\n plt.show()\n return m\n\ndef generate_wavefront_errors_correction(nb_of_maps,errors,nb_zernikes):\n import poppy, webbpsf\n import matplotlib.pyplot as plt\n \n # intial wavefront map\n nc = webbpsf.NIRCam()\n nc, ote = webbpsf.enable_adjustable_ote(nc)\n osys = nc._get_aberrations()\n\n # final wavefront map\n nc_final = webbpsf.NIRCam()\n nc_final, ote_final = webbpsf.enable_adjustable_ote(nc_final)\n osys_final = nc_final._get_aberrations()\n\n tab_wavefront_error = np.zeros(nb_of_maps)\n tab_error = np.zeros(nb_of_maps)\n for n, error in zip(range(nb_of_maps), errors):\n print(n, error)\n #print(zip(range(nb_of_maps)))\n #print(errors) \n # change aberrations in wavefront map: example with random zernikes\n # this map will be our perturbation map and we will add it to the initial map with a certain weight\n\n # creating the perturbation map\n #weight = 0.2\n #weight = error/100\n osys_corrected = osys.zernike_coeffs.copy()\n\n for i in range(nb_zernikes):\n if i= ngh, 'border has to be larger than ngh'\n self.border = border\n\n def __repr__(self):\n return \"NghSampler(ngh=%d, subq=%d, subd=%d, ignore=%d, border=%d)\" % (\n self.ngh, self.sub_q, self.sub_d, self.ignore, self.border)\n\n def trans(self, arr, i, j):\n s = lambda i: slice(self.border+i, i-self.border or None, self.sub_q)\n return arr[:,:,s(j),s(i)]\n\n def __call__(self, feats, confs, aflow):\n feat1, conf1 = feats[0], (confs[0] if confs else None)\n # warp with optical flow in img1 coords\n feat2, mask2, conf2 = self._warp(feats, confs, aflow)\n \n qfeat = self.trans(feat1,0,0)\n qconf = (self.trans(conf1,0,0) + self.trans(conf2,0,0)) / 2 if confs else None\n mask2 = self.trans(mask2,0,0)\n scores_at = lambda i,j: (qfeat * self.trans(feat2,i,j)).sum(dim=1)\n \n # compute scores for all neighbors\n B, D = feat1.shape[:2]\n min_d = self.ignore**2\n max_d = self.ngh**2\n rad = (self.ngh//self.sub_d) * self.ngh # make an integer multiple\n negs = []\n offsets = []\n for j in range(-rad, rad+1, self.sub_d):\n for i in range(-rad, rad+1, self.sub_d):\n if not(min_d < i*i + j*j <= max_d): \n continue # out of scope\n offsets.append((i,j)) # Note: this list is just for debug\n negs.append( scores_at(i,j) )\n \n scores = torch.stack([scores_at(0,0)] + negs, dim=-1)\n gt = scores.new_zeros(scores.shape, dtype=torch.uint8)\n gt[..., 0] = 1 # only the center point is positive\n\n return scores, gt, mask2, qconf\n\n\n\nclass FarNearSampler (FullSampler):\n \"\"\" Sample pixels from *both* a small neighborhood *and* far-away pixels.\n \n How it works?\n 1) Queries are sampled from img1,\n - at least `border` pixels from borders and \n - on a grid with step = `subq`\n \n 2) Close database pixels \n - from the corresponding image (img2),\n - within a `ngh` distance radius \n - on a grid with step = `subd_ngh`\n - ignored if distance to query is >0 and <=`ignore`\n \n 3) Far-away database pixels from ,\n - from all batch images in `img2`\n - at least `border` pixels from borders\n - on a grid with step = `subd_far`\n \"\"\"\n def __init__(self, subq, ngh, subd_ngh, subd_far, border=None, ignore=1, \n maxpool_ngh=False ):\n FullSampler.__init__(self)\n border = border or ngh\n assert ignore < ngh < subd_far, 'neighborhood needs to be smaller than far step'\n self.close_sampler = NghSampler(ngh=ngh, subq=subq, subd=subd_ngh, \n ignore=not(maxpool_ngh), border=border)\n self.faraway_sampler = SubSampler(border=border, subq=subq, subd=subd_far)\n self.maxpool_ngh = maxpool_ngh\n\n def __repr__(self):\n c,f = self.close_sampler, self.faraway_sampler\n res = \"FarNearSampler(subq=%d, ngh=%d\" % (c.sub_q, c.ngh)\n res += \", subd_ngh=%d, subd_far=%d\" % (c.sub_d, f.sub_d)\n res += \", border=%d, ign=%d\" % (f.border, c.ignore)\n res += \", maxpool_ngh=%d\" % self.maxpool_ngh\n return res+')'\n\n def __call__(self, feats, confs, aflow):\n # warp with optical flow in img1 coords\n aflow = self._warp(feats, confs, aflow)\n\n # sample ngh pixels\n scores1, gt1, msk1, conf1 = self.close_sampler(feats, confs, aflow)\n scores1, gt1 = scores1.view(-1,scores1.shape[-1]), gt1.view(-1,gt1.shape[-1])\n if self.maxpool_ngh:\n # we consider all scores from ngh as potential positives\n scores1, self._cached_maxpool_ngh = scores1.max(dim=1,keepdim=True)\n gt1 = gt1[:, 0:1]\n\n # sample far pixels\n scores2, gt2, msk2, conf2 = self.faraway_sampler(feats, confs, aflow)\n # assert (msk1 == msk2).all()\n # assert (conf1 == conf2).all()\n\n return (torch.cat((scores1,scores2),dim=1), \n torch.cat((gt1, gt2), dim=1), \n msk1, conf1 if confs else None)\n\n\nclass NghSampler2 (nn.Module):\n \"\"\" Similar to NghSampler, but doesnt warp the 2nd image.\n Distance to GT => 0 ... pos_d ... neg_d ... ngh\n Pixel label => + + + + + + 0 0 - - - - - - -\n \n Subsample on query side: if > 0, regular grid\n < 0, random points \n In both cases, the number of query points is = W*H/subq**2\n \"\"\"\n def __init__(self, ngh, subq=1, subd=1, pos_d=0, neg_d=2, border=None,\n maxpool_pos=True, subd_neg=0):\n nn.Module.__init__(self)\n assert 0 <= pos_d < neg_d <= (ngh if ngh else 99)\n self.ngh = ngh\n self.pos_d = pos_d\n self.neg_d = neg_d\n assert subd <= ngh or ngh == 0\n assert subq != 0\n self.sub_q = subq\n self.sub_d = subd\n self.sub_d_neg = subd_neg\n if border is None: border = ngh\n assert border >= ngh, 'border has to be larger than ngh'\n self.border = border\n self.maxpool_pos = maxpool_pos\n self.precompute_offsets()\n\n def precompute_offsets(self):\n pos_d2 = self.pos_d**2\n neg_d2 = self.neg_d**2\n rad2 = self.ngh**2\n rad = (self.ngh//self.sub_d) * self.ngh # make an integer multiple\n pos = []\n neg = []\n for j in range(-rad, rad+1, self.sub_d):\n for i in range(-rad, rad+1, self.sub_d):\n d2 = i*i + j*j\n if d2 <= pos_d2:\n pos.append( (i,j) )\n elif neg_d2 <= d2 <= rad2: \n neg.append( (i,j) )\n\n self.register_buffer('pos_offsets', torch.LongTensor(pos).view(-1,2).t())\n self.register_buffer('neg_offsets', torch.LongTensor(neg).view(-1,2).t())\n\n def gen_grid(self, step, aflow):\n B, two, H, W = aflow.shape\n dev = aflow.device\n b1 = torch.arange(B, device=dev)\n if step > 0:\n # regular grid\n x1 = torch.arange(self.border, W-self.border, step, device=dev)\n y1 = torch.arange(self.border, H-self.border, step, device=dev)\n H1, W1 = len(y1), len(x1)\n x1 = x1[None,None,:].expand(B,H1,W1).reshape(-1)\n y1 = y1[None,:,None].expand(B,H1,W1).reshape(-1)\n b1 = b1[:,None,None].expand(B,H1,W1).reshape(-1)\n shape = (B, H1, W1)\n else:\n # randomly spread\n n = (H - 2*self.border) * (W - 2*self.border) // step**2\n x1 = torch.randint(self.border, W-self.border, (n,), device=dev)\n y1 = torch.randint(self.border, H-self.border, (n,), device=dev)\n x1 = x1[None,:].expand(B,n).reshape(-1)\n y1 = y1[None,:].expand(B,n).reshape(-1)\n b1 = b1[:,None].expand(B,n).reshape(-1)\n shape = (B, n)\n return b1, y1, x1, shape\n\n def forward(self, feats, confs, aflow, **kw):\n B, two, H, W = aflow.shape\n assert two == 2\n feat1, conf1 = feats[0], (confs[0] if confs else None)\n feat2, conf2 = feats[1], (confs[1] if confs else None)\n \n # positions in the first image\n b1, y1, x1, shape = self.gen_grid(self.sub_q, aflow)\n\n # sample features from first image\n feat1 = feat1[b1, :, y1, x1]\n qconf = conf1[b1, :, y1, x1].view(shape) if confs else None\n \n #sample GT from second image\n b2 = b1\n xy2 = (aflow[b1, :, y1, x1] + 0.5).long().t()\n mask = (0 <= xy2[0]) * (0 <= xy2[1]) * (xy2[0] < W) * (xy2[1] < H)\n mask = mask.view(shape)\n \n def clamp(xy):\n torch.clamp(xy[0], 0, W-1, out=xy[0])\n torch.clamp(xy[1], 0, H-1, out=xy[1])\n return xy\n \n # compute positive scores\n xy2p = clamp(xy2[:,None,:] + self.pos_offsets[:,:,None])\n pscores = (feat1[None,:,:] * feat2[b2, :, xy2p[1], xy2p[0]]).sum(dim=-1).t()\n# xy1p = clamp(torch.stack((x1,y1))[:,None,:] + self.pos_offsets[:,:,None])\n# grid = FullSampler._aflow_to_grid(aflow)\n# feat2p = F.grid_sample(feat2, grid, mode='bilinear', padding_mode='border')\n# pscores = (feat1[None,:,:] * feat2p[b1,:,xy1p[1], xy1p[0]]).sum(dim=-1).t()\n if self.maxpool_pos:\n pscores, pos = pscores.max(dim=1, keepdim=True)\n if confs: \n sel = clamp(xy2 + self.pos_offsets[:,pos.view(-1)])\n qconf = (qconf + conf2[b2, :, sel[1], sel[0]].view(shape))/2\n \n # compute negative scores\n xy2n = clamp(xy2[:,None,:] + self.neg_offsets[:,:,None])\n nscores = (feat1[None,:,:] * feat2[b2, :, xy2n[1], xy2n[0]]).sum(dim=-1).t()\n\n if self.sub_d_neg:\n # add distractors from a grid\n b3, y3, x3, _ = self.gen_grid(self.sub_d_neg, aflow)\n distractors = feat2[b3, :, y3, x3]\n dscores = torch.matmul(feat1, distractors.t())\n del distractors\n \n # remove scores that corresponds to positives or nulls\n dis2 = (x3 - xy2[0][:,None])**2 + (y3 - xy2[1][:,None])**2\n dis2 += (b3 != b2[:,None]).long() * self.neg_d**2\n dscores[dis2 < self.neg_d**2] = 0\n \n scores = torch.cat((pscores, nscores, dscores), dim=1)\n else:\n # concat everything\n scores = torch.cat((pscores, nscores), dim=1)\n\n gt = scores.new_zeros(scores.shape, dtype=torch.uint8)\n gt[:, :pscores.shape[1]] = 1\n\n return scores, gt, mask, qconf\n\n\n\n\n\n\n\n\n", "meta": {"hexsha": "9fede70d3a04d7f31a1d414eace0aaf3729e8235", "size": 15031, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyslam/thirdparty/r2d2/nets/sampler.py", "max_stars_repo_name": "dysdsyd/VO_benchmark", "max_stars_repo_head_hexsha": "a7602edab934419c1ec73618ee655e18026f834f", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-09-11T09:13:31.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-03T01:39:56.000Z", "max_issues_repo_path": "pyslam/thirdparty/r2d2/nets/sampler.py", "max_issues_repo_name": "dysdsyd/VO_benchmark", "max_issues_repo_head_hexsha": "a7602edab934419c1ec73618ee655e18026f834f", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pyslam/thirdparty/r2d2/nets/sampler.py", "max_forks_repo_name": "dysdsyd/VO_benchmark", "max_forks_repo_head_hexsha": "a7602edab934419c1ec73618ee655e18026f834f", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.442455243, "max_line_length": 114, "alphanum_fraction": 0.5495309693, "include": true, "reason": "import numpy", "num_tokens": 4510, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.37754065479083276, "lm_q1q2_score": 0.19319382200735233}} {"text": "# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Thu Sep 28 09:28:15 2017\n\n@author: tkoller\n\"\"\"\nimport warnings\nimport casadi as cas\nimport numpy as np\nfrom casadi import MX, mtimes, vertcat, sum2, sqrt\nfrom casadi import reshape as cas_reshape\nfrom .gp_reachability_casadi import lin_ellipsoid_safety_distance\nfrom .gp_reachability_casadi import multi_step_reachability as cas_multistep\nfrom .uncertainty_propagation_casadi import mean_equivalent_multistep, \\\n multi_step_taylor_symbolic\nfrom .utils import dlqr, feedback_ctrl, array_of_vec_to_array_of_mat\n\nATTR_NAMES_PERF = ['type_perf_traj', 'n_perf', 'r', 'perf_has_fb']\nDEFAULT_OPT_PERF = {'type_perf_traj': 'mean_equivalent', 'n_perf': 5, 'r': 1,\n 'perf_has_fb': True}\n\nATTR_NAMES_ENV = ['l_mu', 'l_sigma', 'h_mat_safe', 'h_safe', 'lin_model', 'ctrl_bounds',\n 'safe_policy', 'h_mat_obs', 'h_obs']\nDEFAULT_OPT_ENV = {'ctrl_bounds': None, 'safe_policy': None, 'lin_model': None,\n 'h_mat_obs': None, 'h_obs': None}\n\n\nclass SimpleSafeMPC:\n \"\"\" Simplified implementation of the SafeMPC algorithm in Casadi\n\n \"\"\"\n\n def __init__(self, n_safe, ssm, opt_env, wx_cost, wu_cost, beta_safety=2.5,\n rhc=True,\n safe_policy=None, opt_perf_trajectory={}, lin_trafo_gp_input=None, opts_solver=None, verbosity=0):\n \"\"\" Initialize the SafeMPC object with dynamic model information\n\n Parameters\n ----------\n n_safe: int\n Length of the safety trajectory (number of safe controls)\n ssm: StateSpaceModel\n The underlying statistical model\n opt_env: dict\n Dictionary of environment options. List of accepted attributes are given in ATTR_NAMES_ENV.\n All values that are NOT specified in DEFAULT_OPT_ENV are mandatory.\n wx_cost: n_x x n_x np.ndarray[float]\n State cost matrix for the LQR\n wu_cost: n_u x n_u np.ndarray[float]\n Control cost matrix for the LQR\n beta_safety: float, optional\n The safety coefficient for the confidence intervals (Denoted by \\beta in paper)\n rhc: boolean, optional\n True, if we want to reinitialize the SafeMPC problem in a receding horizon fashion\n lin_model: Tuple, optional\n The linear prior model. Consists of tuple (a,b) that defines the linear system.\n Default is: x_{t+1} = x_t, i.e. (I,0)\n ctrl_bounds: n_u x 2 np.ndarray[float], optional\n Upper and lower bound per control input\n safe_policy: function, optional\n Custom safe policy u_t^safe = safe_policy(x_t)\n Default: LQR based on prior model and wx_cost,wu_cost\n opt_perf_trajectory: dict, optional\n Dictionary of environment options. List of accepted attributes are given in ATTR_NAMES_PERF.\n All values that are NOT specified in DEFAULT_OPT_PERF are mandatory.\n lin_trafo_gp_input: n_x_gp_in x n_x np.ndarray[float], optional\n Allows for a linear transformation of the gp input (e.g. removing an input)\n\n\n \"\"\"\n self.rhc = rhc\n self.ssm = ssm\n self.ssm_forward = ssm.get_forward_model_casadi(True)\n self.n_safe = n_safe\n self.n_fail = self.n_safe # initialize s.t. there is no backup strategy\n self.n_s = self.ssm.num_states\n self.n_u = self.ssm.num_actions\n self.has_openloop = False\n self.opts_solver = opts_solver\n\n self.safe_policy = safe_policy\n\n self.cost_func = None # This is updated wheenver the solver is newly initialized (possibly again with None)\n\n self._set_attributes_from_dict(ATTR_NAMES_ENV, DEFAULT_OPT_ENV, opt_env)\n\n self.lin_trafo_gp_input = lin_trafo_gp_input\n if self.lin_trafo_gp_input is None:\n self.lin_trafo_gp_input = np.eye(self.n_s)\n\n if self.h_mat_obs is None:\n m_obs_mat = 0\n else:\n m_obs_mat, n_s_obs = np.shape(self.h_mat_obs)\n assert n_s_obs == self.n_s, \" Wrong shape of obstacle matrix\"\n assert np.shape(self.h_obs) == (m_obs_mat,\n 1), \" Shapes of obstacle linear inequality matrix/vector must match \"\n self.m_obs = m_obs_mat\n\n m_safe_mat, n_s_safe = np.shape(self.h_mat_safe)\n assert n_s_safe == self.n_s, \" Wrong shape of safety matrix\"\n assert np.shape(self.h_safe) == (\n m_safe_mat,\n 1), \" Shapes of safety linear inequality matrix/vector must match \"\n self.m_safe = m_safe_mat\n\n # init safety constraints evaluator\n p_cas = MX.sym('p', (self.n_s, self.n_u))\n q_cas = MX.sym('q', (self.n_s, self.n_s))\n g_val_term_cas = lin_ellipsoid_safety_distance(p_cas, q_cas, self.h_mat_safe,\n self.h_safe)\n self.g_term_cas = cas.Function(\"g_term\", [p_cas, q_cas], [g_val_term_cas])\n\n if not self.h_mat_obs is None:\n g_val_interm_cas = lin_ellipsoid_safety_distance(p_cas, q_cas,\n self.h_mat_obs, self.h_obs)\n self.g_interm_cas = cas.Function(\"g_interm\", [p_cas, q_cas],\n [g_val_term_cas])\n\n self.has_ctrl_bounds = False\n\n if not self.ctrl_bounds is None:\n self.has_ctrl_bounds = True\n assert np.shape(self.ctrl_bounds) == (self.n_u, 2), \"\"\"control bounds need\n to be of shape n_u x 2 with i,0 lower bound and i,1 upper bound per dimension\"\"\"\n\n self.wx_cost = wx_cost\n self.wu_cost = wu_cost\n self.wx_feedback = wx_cost\n self.wu_feedback = 1 * wu_cost\n\n self.do_shift_solution = True\n self.solver_initialized = False\n\n self.beta_safety = beta_safety\n self.verbosity = verbosity\n\n # SET ALL ATTRIBUTES FOR THE ENVIRONMENT\n\n self.lin_prior = False\n self.a = np.eye(self.n_s)\n self.b = np.zeros((self.n_s, self.n_u))\n if not self.lin_model is None:\n self.a, self.b = self.lin_model\n self.lin_prior = True\n if self.safe_policy is None:\n # no safe policy specified? Use lqr as safe policy\n K = self.get_lqr_feedback()\n self.safe_policy = lambda x: np.dot(K, x)\n\n # if self.performance_trajectory is None:\n # self.performance_trajectory = mean_equivalent\n self._set_attributes_from_dict(ATTR_NAMES_PERF, DEFAULT_OPT_PERF,\n opt_perf_trajectory)\n self._set_perf_trajectory(self.type_perf_traj)\n\n self.k_fb_all = None\n if self.safe_policy is None:\n warnings.warn(\"No SafePolicy!\")\n\n # init safe\n\n def init_solver(self, cost_func=None, opt_x0=False, init_uncertainty=False):\n \"\"\" Initialize a casadi solver object corresponding to the SafeMPC optimization problem\n\n\n\n Parameters:\n -----------\n cost_func: Function\n A function which admits casadi.SX type inputs\n and returns a scalar function\n If performance controls exist function has to be of the form:\n cost_func(p_all,k_ff_all,x_perf,u_perf)\n otherwise:\n cost_func(p_all,k_ff_all)\n\n\n \"\"\"\n self.cost_func = cost_func\n self.opt_x0 = opt_x0\n self.init_uncertainty = init_uncertainty\n\n u_0 = MX.sym(\"init_control\", (self.n_u, 1))\n k_ff_all = MX.sym(\"feed-forward control\", (self.n_safe - 1, self.n_u))\n g = []\n lbg = []\n ubg = []\n g_name = []\n\n p_0 = MX.sym(\"initial state\", (self.n_s, 1))\n q_0 = None\n k_fb_0 = None\n if init_uncertainty:\n q_0 = MX.sym(\"init uncertainty\", (self.n_s, self.n_s))\n k_fb_0 = MX.sym(\"init feddback control matrix\", (self.n_u, self.n_s))\n\n k_fb_safe = MX.sym(\"feedback matrices\",\n (self.n_safe - 1, self.n_s * self.n_u))\n\n p_all, q_all, gp_sigma_pred_safe_all = cas_multistep(p_0, u_0, k_fb_safe, k_ff_all,\n self.ssm_forward, self.l_mu,\n self.l_sigma,\n self.beta_safety, self.a,\n self.b,\n self.lin_trafo_gp_input, q_0, k_fb_0)\n\n # generate open_loop trajectory function [vertcat(x_0,u_0)],[f_x])\n\n if init_uncertainty:\n self._f_multistep_eval = cas.Function(\"safe_multistep\",\n [p_0, u_0, k_fb_safe, k_ff_all, q_0, k_fb_0],\n [p_all, q_all, gp_sigma_pred_safe_all])\n else:\n self._f_multistep_eval = cas.Function(\"safe_multistep\",\n [p_0, u_0, k_fb_safe, k_ff_all],\n [p_all, q_all, gp_sigma_pred_safe_all])\n\n g_safe, lbg_safe, ubg_safe, g_names_safe = self.generate_safety_constraints(\n p_all, q_all, u_0, k_fb_safe, k_ff_all, q_0, k_fb_0)\n g = vertcat(g, g_safe)\n lbg += lbg_safe\n ubg += ubg_safe\n g_name += g_names_safe\n\n # Generate performance trajectory\n if self.n_perf > 1:\n k_ff_perf, k_fb_perf, k_ff_perf_traj, k_fb_perf_traj, mu_perf, sigma_perf, gp_sigma_pred_perf_all, g_perf, lbg_perf, ubg_perf, g_names_perf = self._generate_perf_trajectory_casadi(\n p_0, u_0, k_ff_all, k_fb_safe, self.a, self.b, self.lin_trafo_gp_input)\n g = vertcat(g, g_perf)\n lbg += lbg_perf\n ubg += ubg_perf\n g_name += g_names_perf\n else:\n k_ff_perf = np.array([])\n k_fb_perf = np.array([])\n k_fb_perf_traj = np.array([])\n k_ff_perf_traj = np.array([])\n mu_perf = np.array([])\n sigma_perf = np.array([])\n gp_sigma_pred_perf_all = None\n\n cost = self.generate_cost_function(p_0, u_0, p_all, q_all, mu_perf, sigma_perf,\n k_ff_all, k_fb_safe, gp_sigma_pred_safe_all,\n k_fb_perf=k_fb_perf_traj,\n k_ff_perf=k_ff_perf_traj,\n gp_pred_sigma_perf=gp_sigma_pred_perf_all,\n custom_cost_func=cost_func)\n\n if self.opt_x0:\n opt_vars = vertcat(p_0, u_0, k_ff_perf, k_ff_all.reshape((-1, 1)))\n opt_params = vertcat(k_fb_safe.reshape((-1, 1)), k_fb_perf.reshape((-1, 1)))\n else:\n opt_vars = vertcat(u_0, k_ff_perf, k_ff_all.reshape((-1, 1)))\n opt_params = vertcat(p_0, k_fb_safe.reshape((-1, 1)), k_fb_perf.reshape((-1, 1)))\n\n if self.init_uncertainty:\n opt_params = vertcat(opt_params, q_0.reshape((-1, 1)), k_fb_0.reshape((-1, 1)))\n\n prob = {'f': cost, 'x': opt_vars, 'p': opt_params, 'g': g}\n\n opt = self.opts_solver\n if opt is None:\n opt = {'error_on_fail': False,\n 'ipopt': {'hessian_approximation': 'limited-memory', \"max_iter\": 100,\n \"expect_infeasible_problem\": \"no\", \\\n 'acceptable_tol': 1e-4, \"acceptable_constr_viol_tol\": 1e-5,\n \"bound_frac\": 0.5, \"start_with_resto\": \"no\",\n \"required_infeasibility_reduction\": 0.85,\n \"acceptable_iter\": 8}} # ipopt\n\n # opt = {'max_iter':120,'hessian_approximation':'limited-memory'}#,\"c1\":5e-4} #sqpmethod #,\n # opt = {'max_iter':120,'qpsol':'qpoases'}\n\n solver = cas.nlpsol('solver', 'ipopt', prob, opt)\n # solver = cas.nlpsol('solver','sqpmethod',prob,opt)\n # solver = cas.nlpsol('solver','blocksqp',prob,opt)\n\n self.solver = solver\n self.lbg = lbg\n self.ubg = ubg\n self.solver_initialized = True\n self.g = g\n self.g_name = g_name\n\n def generate_cost_function(self, p_0, u_0, p_all, q_all, mu_perf, sigma_perf,\n k_ff_safe, k_fb_safe, sigma_safe, k_fb_perf=None,\n k_ff_perf=None, gp_pred_sigma_perf=None,\n custom_cost_func=None, eps_noise=0.0):\n # Generate cost function\n if custom_cost_func is None:\n cost = 0\n if self.n_perf > 1:\n\n n_cost_deviation = np.minimum(self.n_perf, self.n_safe)\n for i in range(1, n_cost_deviation):\n cost += mtimes(mu_perf[i, :] - p_all[i, :],\n mtimes(.1 * self.wx_cost,\n (mu_perf[i, :] - p_all[i, :]).T))\n\n for i in range(self.n_perf):\n cost -= sqrt(sum2(gp_pred_sigma_perf[i, :] + eps_noise))\n else:\n for i in range(self.n_safe):\n cost -= sqrt(sum2(sigma_safe[i, :] + eps_noise))\n else:\n if self.n_perf > 1:\n cost = custom_cost_func(p_0, u_0, p_all, q_all, k_ff_safe, k_fb_safe,\n sigma_safe, mu_perf, sigma_perf,\n gp_pred_sigma_perf, k_fb_perf, k_ff_perf)\n else:\n cost = custom_cost_func(p_0, u_0, p_all, q_all, k_ff_safe, k_fb_safe,\n sigma_safe)\n\n return cost\n\n def generate_safety_constraints(self, p_all, q_all, u_0, k_fb, k_ff_all, q_0=None, k_fb_0=None):\n \"\"\" Generate all safety constraints\n\n Parameters\n ----------\n p_all: n_safe x n_s casadi.SX\n The centers of the safe trajctory ellipsoids\n q_all: n_safe x n_s x n_s ndarray[float]\n\n u_0 The initial\n The shape matrices of the safe trajectory ellipsoids\n k_fb: (n_safe-1) x (n_x * n_u) casadi.SX\n Feedback control matrices\n k_ff_all: (n_safe-1) x n_u casadi.SX\n Feed-forward controls\n\n Returns\n -------\n g: list[casadi.SX]\n The constraint functions\n lbg: list[casadi.SX]\n Lower bounds for the constraints\n ubg: list[casadi.SX]\n Upper bounds for the constraints\n \"\"\"\n g = []\n lbg = []\n ubg = []\n g_name = []\n\n H = np.shape(p_all)[0]\n # control constraints\n if self.has_ctrl_bounds:\n g_u_0, lbg_u_0, ubg_u_0 = self._generate_control_constraint(u_0, q_0, k_fb_0)\n g = vertcat(g, g_u_0)\n lbg += lbg_u_0\n ubg += ubg_u_0\n g_name += [\"u_0_ctrl_constraint\"]\n\n for i in range(H - 1):\n p_i = p_all[i, :].T\n q_i = q_all[i, :].reshape((self.n_s, self.n_s))\n k_ff_i = k_ff_all[i, :].reshape((self.n_u, 1))\n k_fb_i = k_fb[i, :].reshape((self.n_u, self.n_s))\n\n g_u_i, lbg_u_i, ubg_u_i = self._generate_control_constraint(k_ff_i, q_i,\n k_fb_i)\n g = vertcat(g, g_u_i)\n lbg += lbg_u_i\n ubg += ubg_u_i\n g_name += [\"ellipsoid_ctrl_constraint_{}\".format(i)] * len(lbg_u_i)\n\n # intermediate state constraints\n if not self.h_mat_obs is None:\n for i in range(H - 1):\n p_i = p_all[i, :].T\n q_i = q_all[i, :].reshape((self.n_s, self.n_s))\n g_state = lin_ellipsoid_safety_distance(p_i, q_i, self.h_mat_obs,\n self.h_obs)\n g = vertcat(g, g_state)\n lbg += [-cas.inf] * self.m_obs\n ubg += [0] * self.m_obs\n g_name += [\"obstacle_avoidance_constraint{}\".format(i)] * self.m_obs\n\n # terminal state constraint\n p_T = p_all[-1, :].T\n q_T = q_all[-1, :].reshape((self.n_s, self.n_s))\n\n g_terminal = lin_ellipsoid_safety_distance(p_T, q_T, self.h_mat_safe,\n self.h_safe)\n g = vertcat(g, g_terminal)\n g_name += [\"terminal constraint\"] * self.m_safe\n lbg += [-cas.inf] * self.m_safe\n ubg += [0] * self.m_safe\n\n return g, lbg, ubg, g_name\n\n def _generate_perf_trajectory_casadi(self, mu_0, u_0, k_ff_ctrl, k_fb_safe, a=None,\n b=None, lin_trafo_gp_input=None,\n safety_constr=False):\n \"\"\" Generate the performance trajectory variables for the casadi solver\n\n Parameters:\n mu_0: n_x x 1 casadi.SX\n Initial state\n u_0: n_u x 1 casadi.SX\n Initial control\n k_ff_ctrl: (n_safe-1) x n_u casadi.SX\n Safe feed-forward controls\n k_fb_safe: (n_safe-1) x (n_x * n_u) casadi.SX\n Safe feedback control matrices\n a: n_x x n_x np.ndarray[float], optional\n The A-matrix of the prior linear model\n b: n_x x n_u np.ndarray[float], optional\n The B-matrix of the prior linear model\n lin_trafo_gp_input: n_x_gp_in x n_x np.ndarray[float], optional\n Allows for a linear transformation of the gp input (e.g. removing an input)\n safety_constr: boolean, optional\n True, if we want to put a constraint after (n_safe+1)th performance trajectory state to\n be inside the terminal safe set. Can potentially help with (recursive) feasibility\n \"\"\"\n if self.r > 1:\n warnings.warn(\n \"Coupling performance and safety trajectory for more than one step is UNTESTED\")\n\n # we don't have a performance trajectory, so nothing to do here. Might wanna catch this even before\n if self.n_perf <= 1:\n return np.array([]), np.array([]), np.array([]), np.array(\n []), None, np.array([]), [], [], [], [], []\n else:\n k_ff_perf = MX.sym(\"k_ff_perf\", (self.n_perf - self.r, self.n_u))\n k_ff_perf_traj = vertcat(k_ff_ctrl[:self.r - 1, :], k_ff_perf)\n\n k_fb_perf_traj = np.array([])\n for i in range(self.r - 1):\n k_fb_perf_traj = np.append(k_fb_perf_traj,\n [k_fb_safe[i, :].reshape((self.n_u, self.n_s))])\n if self.perf_has_fb and self.n_perf - self.r > 0:\n k_fb_perf = MX.sym(\"k_fb_perf\", (self.n_u, self.n_s))\n for i in range(self.n_perf - self.r):\n k_fb_perf_traj = np.append(k_fb_perf_traj, [k_fb_perf])\n\n mu_perf_all, sigma_perf_all, gp_sigma_pred_perf_all = self.perf_trajectory(\n mu_0, self.ssm_forward, vertcat(u_0, k_ff_perf_traj), k_fb_perf_traj, None, a, b,\n lin_trafo_gp_input)\n\n # evaluation trajectory (mainly for verbosity)\n mu_0_eval = MX.sym(\"mu_0\", (self.n_s, 1))\n u_0_eval = MX.sym(\"u_0\", (self.n_u, 1))\n k_fb_perf_all_eval = MX.sym(\"k_fb_perf\",\n (self.n_perf - 1, self.n_u * self.n_s))\n k_ff_perf_all_eval = MX.sym(\"k_ff_perf\", (self.n_perf - 1, self.n_u))\n\n list_kfb_perf = [cas_reshape(k_fb_perf_all_eval[i, :], (self.n_u, self.n_s))\n for i in range(self.n_perf - 1)]\n mu_perf_eval_all, sigma_perf_eval_all, gp_sigma_pred_perf_all_eval = self.perf_trajectory(\n mu_0_eval, self.ssm_forward, vertcat(u_0_eval, k_ff_perf_all_eval),\n list_kfb_perf, None, a, b, lin_trafo_gp_input)\n self._f_multistep_perf_eval = cas.Function(\"f_multistep_perf_eval\",\n [mu_0_eval, u_0_eval,\n k_fb_perf_all_eval,\n k_ff_perf_all_eval],\n [mu_perf_eval_all,\n gp_sigma_pred_perf_all_eval])\n\n # generate (approxiamte) constraints for the performance trajectory\n g_name = []\n g = []\n lbg = []\n ubg = []\n if safety_constr and self.n_perf > self.n_safe:\n g_name += [\"Terminal safety performance\"]\n g_term = lin_ellipsoid_safety_distance(\n cas_reshape(mu_perf_all[self.n_safe + 1, :], (self.n_s, 1)),\n cas_reshape(sigma_perf_all[self.n_safe + 1, :], (self.n_s, self.n_s)),\n self.h_mat_safe, self.h_safe)\n g = vertcat(g, g_term)\n lbg += [-np.inf] * self.m_safe\n ubg += [0.] * self.m_safe\n\n if self.has_ctrl_bounds:\n for i in range(self.n_perf - self.r):\n g_u_i, lbu_i, ubu_i = self._generate_control_constraint(\n k_ff_perf[i, :].T)\n g = vertcat(g, g_u_i)\n lbg += lbu_i\n ubg += ubu_i\n g_name += [\"ctrl_constr_performance_{}\".format(i)]\n\n return k_ff_perf, k_fb_perf, k_ff_perf_traj, k_fb_perf_traj, mu_perf_all, sigma_perf_all, gp_sigma_pred_perf_all, g, lbg, ubg, g_name\n\n def _generate_control_constraint(self, k_ff, q=None, k_fb=None, ctrl_bounds=None):\n \"\"\" Build control constraints from state ellipsoids and linear feedback controls\n\n k_ff: n_u x 1 ndarray[casadi.SX]\n The feed-forward control gain\n q: n_s x n_s ndarray[casadi.SX]\n The shape matrix of the state ellipsoid\n k_fb: n_u x n_s ndarray[casadi.SX]\n The feedback gain\n ctrl_bounds: n_u x 2 ndarray[float], optional\n\n Returns\n -------\n g: 2*n_u x 1 ndarray[casadi.SX]\n The control constraints (symbollicaly) evaluated at the current\n state/controls\n lbg: 2*n_u x 0 list[float]\n Lower bounds for the control constraints\n ubg: 2*n_u x 0 list[float]\n Upper bounds for the control constraints\n \"\"\"\n if ctrl_bounds is None:\n if not self.has_ctrl_bounds:\n raise ValueError(\"\"\"Either ctrl_bounds has to be specified or\n the objects' ctrl_bounds has to be specified \"\"\")\n ctrl_bounds = self.ctrl_bounds\n\n # no feedback term. Reduces to simple feed-forward control bounds\n\n n_u, _ = np.shape(ctrl_bounds)\n u_min = ctrl_bounds[:, 0]\n u_max = ctrl_bounds[:, 1]\n\n if k_fb is None:\n return k_ff, u_min.tolist(), u_max.tolist()\n\n h_vec = np.vstack((u_max[:, None], -u_min[:, None]))\n h_mat = np.vstack((np.eye(n_u), -np.eye(n_u)))\n\n p_u = k_ff\n q_u = mtimes(k_fb, mtimes(q, k_fb.T))\n\n g = lin_ellipsoid_safety_distance(p_u, q_u, h_mat, h_vec)\n\n return g, [-cas.inf] * 2 * n_u, [0] * 2 * n_u\n\n def _eval_prior_casadi(self, state, action):\n \"\"\" symbolically evaluate the prior\n\n Parameters\n ----------\n state: n x n_s array[casadi.SX]\n Symbolic array of states\n action: n x 1 array[casadi.SX]\n Symbolic array of actions\n\n Returns\n -------\n x_prior: n x n_s array[casadi.SX]\n The (state,action) pairs evaluated at the prior\n \"\"\"\n\n return mtimes(self.a, state.T) + mtimes(self.b, action.T)\n\n def eval_prior(self, state, action):\n \"\"\" Evaluate the prior numerically\n\n Parameters\n ----------\n state: n x n_s array[float]\n Array of states\n action: n x n_u array[float]\n\n Returns\n -------\n x_prior: n x n_s array[float]\n The (state,action) pairs evaluated at the prior\n \"\"\"\n\n return np.dot(state, self.a.T) + np.dot(action, self.b.T)\n\n def get_lqr_feedback(self, x_0=None, u_0=None):\n \"\"\" Get the initial feedback controller k_fb\n\n x_0: n_s x 1 ndarray[float], optional\n Current state of the system\n u_0: n_u x 1 ndarray[float], optional\n Initialization of the control input\n\n \"\"\"\n q = self.wx_feedback\n r = self.wu_feedback\n\n if x_0 is None:\n x_0 = np.zeros((self.n_s, 1))\n if u_0 is None:\n u_0 = np.zeros((self.n_u, 1))\n\n if self.lin_prior:\n a = self.a\n b = self.b\n\n k_lqr, _, _ = dlqr(a, b, q, r)\n k_fb = -k_lqr\n else:\n\n raise NotImplementedError(\n \"Cannot compute feed-back matrices without prior model\")\n\n return k_fb.reshape((1, self.n_s * self.n_u))\n\n def get_safety_trajectory_openloop(self, x_0, u_0, k_fb=None, k_ff=None, q_0=None, k_fb_0=None):\n \"\"\" Compute a trajectory of ellipsoids based on an initial state and a set of controls\n\n Parameters\n ----------\n x_0: n_s x 1 2darray[float]\n The initial state\n u_0: n_u x 1 2darray[float]\n The initial action\n k_fb: (n_safe-1) x n_u x n_s or n_u x n_s ndarray[float], optional\n The feedback controls. Uses the most recent solution to the\n MPC Problem (when calling solve()) if this parameter is not set\n k_ff: (n_safe-1) x n_u, optional\n The feed-forward controls. Uses the most recent solution to the\n MPC Problem (when calling solve()) if this parameter is not set\n get_controls: bool, optional\n Additionally returns the applied controls if this flag is set to TRUE\n Returns\n -------\n p_all: T x n_s ndarray[float]\n The centers of the trajctory ellipsoids\n q_all: T x n_s x n_s ndarray[float]\n The shape matrices of the trajectory ellipsoids\n \"\"\"\n if not self.has_openloop:\n return None, None\n\n if k_fb is None:\n k_fb = np.array(self.k_fb_all)\n\n if k_ff is None:\n k_ff = np.array(self.k_ff_all)\n\n if self.init_uncertainty:\n p_all, q_all, gp_sigma_pred_safe_all = self._f_multistep_eval(x_0, u_0, k_fb, k_ff, q_0, k_fb_0)\n else:\n p_all, q_all, gp_sigma_pred_safe_all = self._f_multistep_eval(x_0, u_0, k_fb, k_ff)\n\n return p_all, q_all, gp_sigma_pred_safe_all\n\n def get_action(self, x0_mu, lqr_only=False, sol_verbose=False):\n \"\"\" Wrapper around the solve function\n\n Parameters\n ----------\n x0_mu: n_s x 0 1darray[float]\n The current state of the system\n\n Returns\n -------\n u_apply: n_u x 0 1darray[float]\n The action to be applied to the system\n success: bool\n The control was not successful if we are outside the safezone\n AND we have to revert to the safe controller.\n \"\"\"\n safety_failure = False\n if lqr_only:\n u_apply = self.safe_policy(x0_mu)\n\n return u_apply, safety_failure\n\n if sol_verbose:\n _, u_apply, feasible, success, k_fb_apply, k_ff_all, p_all, q_all = self.solve(\n x0_mu[:, None], sol_verbose=True)\n return u_apply.reshape(\n self.n_u, ), feasible, success, k_fb_apply, k_ff_all, p_all, q_all\n\n else:\n _, u_apply, success = self.solve(x0_mu[:, None])\n\n return u_apply.reshape(self.n_u, ), success\n\n def solve(self, p_0, u_0=None, k_ff_all_0=None, k_fb_safe=None, u_perf_0=None,\n k_fb_perf_0=None, sol_verbose=False, q_0=None, k_fb_0=None):\n \"\"\" Solve the MPC problem for a given set of input parameters\n\n\n Parameters\n ----------\n p_0: n_s x 1 array[float]\n The initial (current) state\n k_ff_all_0: n_safe x n_u array[float], optional\n The initialization of the feed-forward controls\n k_fb_all_0: n_safe x (n_s * n_u) array[float], optional\n The initialization of the feedback controls\n\n Returns\n -------\n k_fb_apply: n_u x n_s array[float]\n The feedback control term to be applied to the system\n k_ff_apply: n_u x 1 array[float]\n The feed-forward control term to be applied to the system\n k_fb_all: n_safe x n_u x n_s\n The feedback control terms for all time steps\n k_ff_all: n_safe x n_u x 1\n \"\"\"\n assert self.solver_initialized, \"Need to initialize the solver first!\"\n\n u_0_init, k_ff_all_0_init, k_fb_safe_init, u_perf_0_init, k_fb_perf_0_init = self._get_init_controls()\n\n if u_0 is None:\n u_0 = u_0_init\n if k_ff_all_0 is None:\n k_ff_all_0 = k_ff_all_0_init\n if k_fb_safe is None:\n k_fb_safe = k_fb_safe_init\n if u_perf_0 is None:\n u_perf_0 = u_perf_0_init\n if k_fb_perf_0 is None:\n k_fb_perf_0 = k_fb_perf_0_init\n if q_0 is not None:\n if k_fb_0 is None:\n k_fb_0 = self.get_lqr_feedback()\n\n if self.opt_x0:\n params = np.vstack(\n (cas_reshape(k_fb_safe, (-1, 1)), cas_reshape(k_fb_perf_0, (-1, 1))))\n\n opt_vars_init = vertcat(cas_reshape(p_0, (-1, 1)), cas_reshape(u_0, (-1, 1)), u_perf_0, \\\n cas_reshape(k_ff_all_0, (-1, 1)))\n else:\n params = np.vstack(\n (p_0, cas_reshape(k_fb_safe, (-1, 1)), cas_reshape(k_fb_perf_0, (-1, 1))))\n\n opt_vars_init = vertcat(cas_reshape(u_0, (-1, 1)), u_perf_0, \\\n cas_reshape(k_ff_all_0, (-1, 1)))\n\n if self.init_uncertainty:\n params = vertcat(params, cas_reshape(q_0, (-1, 1)), cas_reshape(k_fb_0, (-1, 1)))\n\n crash = False \n sol = self.solver(x0=opt_vars_init, lbg=self.lbg, ubg=self.ubg, p=params)\n try:\n # pass\n sol = self.solver(x0=opt_vars_init, lbg=self.lbg, ubg=self.ubg, p=params)\n except:\n crash = True\n warnings.warn(\"NLP solver crashed, solution infeasible\")\n sol = None\n\n return self._get_solution(p_0, sol, k_fb_safe, k_fb_perf_0, sol_verbose, crash, q_0=q_0, k_fb_0=k_fb_0)\n\n def _get_solution(self, x_0, sol, k_fb, k_fb_perf_0, sol_verbose=False,\n crashed=False, feas_tol=1e-6, q_0=None, k_fb_0=None):\n \"\"\" Process the solution dict of the casadi solver\n\n Processes the solution dictionary of the casadi solver and\n (depending on the chosen mode) saves the solution for reuse in the next\n time step. Depending on the chosen verbosity level, it also prints\n some statistics.\n\n Parameters\n ----------\n sol: dict\n The solution dictionary returned by the casadi solver\n sol_verbose: boolean, optional\n Return additional solver results such as the constraint values\n\n Returns\n -------\n k_fb_apply: n_u x n_s array[float]\n The feedback control term to be applied to the system\n k_ff_apply: n_u x 1 array[float]\n The feed-forward control term to be applied to the system\n k_fb_all: n_safe x n_u x n_s\n The feedback control terms for all time steps\n k_ff_all: n_safe x n_u x 1\n\n h_values: (m_obs*n_safe + m_safe) x 0 array[float], optional\n The values of the constraint evaluation (distance to obstacle)\n \"\"\"\n\n success = True\n feasible = True\n if crashed:\n feasible = False\n\n if self.verbosity > 1:\n print(\"Optimization crashed, infeasible soluion!\")\n else:\n g_res = np.array(sol[\"g\"]).squeeze()\n\n # This is not sufficient, since casadi gives out wrong feasibility values\n if np.any(np.array(self.lbg) - feas_tol > g_res) or np.any(\n np.array(self.ubg) + feas_tol < g_res):\n feasible = False\n\n x_opt = sol[\"x\"]\n self.has_openloop = True\n\n if self.opt_x0:\n x_0 = x_opt[:self.n_s]\n x_opt = x_opt[self.n_s:, :]\n\n # get indices of the respective variables\n n_u_0 = self.n_u\n n_u_perf = 0\n if self.n_perf > 1:\n n_u_perf = (self.n_perf - self.r) * self.n_u\n n_k_ff = (self.n_safe - 1) * self.n_u\n\n c = 0\n idx_u_0 = np.arange(n_u_0)\n c += n_u_0\n idx_u_perf = np.arange(c, c + n_u_perf)\n c += n_u_perf\n idx_k_ff = np.arange(c, c + n_k_ff)\n c += n_k_ff\n\n u_apply = np.array(cas_reshape(x_opt[idx_u_0], (1, self.n_u)))\n k_ff_perf = np.array(\n cas_reshape(x_opt[idx_u_perf], (self.n_perf - self.r, self.n_u)))\n\n k_ff_safe = np.array(\n cas_reshape(x_opt[idx_k_ff], (self.n_safe - 1, self.n_u)))\n k_ff_safe_all = np.vstack((u_apply, k_ff_safe))\n\n k_fb_safe_output = array_of_vec_to_array_of_mat(np.copy(k_fb), self.n_u,\n self.n_s)\n\n p_safe, q_safe, gp_sigma_pred_safe_all = self.get_safety_trajectory_openloop(x_0, u_apply,\n np.copy(k_fb),\n k_ff_safe, q_0, k_fb_0)\n\n p_safe = np.array(p_safe)\n q_safe = np.array(q_safe)\n\n if self.verbosity > 1:\n print(\"=== Safe Trajectory: ===\")\n print(\"Centers:\")\n print(p_safe)\n print(\"Shape matrices:\")\n print(q_safe)\n print(\"Safety controls:\")\n print(u_apply)\n print(k_ff_safe)\n\n k_fb_perf_traj_eval = np.empty((0, self.n_s * self.n_u))\n k_ff_perf_traj_eval = np.empty((0, self.n_u))\n if self.n_safe > 1:\n k_fb_perf_traj_eval = np.vstack(\n (k_fb_perf_traj_eval, k_fb[:self.r - 1, :]))\n k_ff_perf_traj_eval = np.vstack(\n (k_ff_perf_traj_eval, k_ff_safe[:self.r - 1, :]))\n if self.n_perf > self.r:\n k_fb_perf_traj_eval = np.vstack((k_fb_perf_traj_eval,\n np.matlib.repmat(k_fb_perf_0,\n self.n_perf - self.r,\n 1)))\n k_ff_perf_traj_eval = np.vstack((k_ff_perf_traj_eval, k_ff_perf))\n\n if self.n_perf > 1:\n mu_perf, sigma_perf = self._f_multistep_perf_eval(x_0.squeeze(),\n u_apply,\n k_fb_perf_traj_eval,\n k_ff_perf_traj_eval)\n\n if self.verbosity > 1:\n print(\"=== Performance Trajectory: ===\")\n print(\"Mu perf:\")\n print(mu_perf)\n print(\"Peformance controls:\")\n print(k_ff_perf_traj_eval)\n\n feasible, _ = self.eval_safety_constraints(p_safe, q_safe)\n\n if self.rhc and feasible:\n self.k_ff_safe = k_ff_safe\n self.k_ff_perf = k_ff_perf\n self.p_safe = p_safe\n self.k_fb_safe_all = np.copy(k_fb)\n self.u_apply = u_apply\n self.k_fb_perf_0 = k_fb_perf_0\n\n if feasible:\n self.n_fail = 0\n\n if not feasible:\n self.n_fail += 1\n q_all = None\n k_fb_safe_output = None\n k_ff_all = None\n p_safe = None\n q_safe = None\n g_res = None\n\n if self.n_fail >= self.n_safe:\n # Too many infeasible solutions -> switch to safe controller\n if self.verbosity > 1:\n print(\n \"Infeasible solution. Too many infeasible solutions, switching to safe controller\")\n u_apply = self.safe_policy(x_0)\n k_ff_safe_all = u_apply\n else:\n # can apply previous solution\n if self.verbosity > 1:\n print((\n \"Infeasible solution. Switching to previous solution, n_fail = {}, n_safe = {}\".format(\n self.n_fail, self.n_safe)))\n if sol_verbose:\n u_apply, k_fb_safe_output, k_ff_safe_all, p_safe = self.get_old_solution(\n x_0, get_ctrl_traj=True)\n else:\n u_apply = self.get_old_solution(x_0)\n k_ff_safe_all = u_apply\n\n if sol_verbose:\n return x_0, u_apply, feasible, success, k_fb_safe_output, k_ff_safe_all, p_safe, q_safe, sol, gp_sigma_pred_safe_all\n\n return x_0, u_apply, success\n\n def eval_safety_constraints(self, p_all, q_all, ubg_term=0., lbg_term=-np.inf,\n ubg_interm=0., lbg_interm=-np.inf, terminal_only=False,\n eps_constraints=1e-5):\n \"\"\" Evaluate the safety constraints \"\"\"\n g_term_val = self.g_term_cas(p_all[-1, :, None],\n cas_reshape(q_all[-1, :], (self.n_s, self.n_s)))\n\n feasible_term = np.all(lbg_term - eps_constraints < g_term_val) and np.all(\n g_term_val < ubg_term + eps_constraints)\n\n feasible = feasible_term\n if terminal_only or self.h_mat_obs is None:\n\n if self.verbosity > 1:\n print((\n \"\\n===== Evaluated terminal constraint values: FEASIBLE = {} =====\".format(\n feasible)))\n print(g_term_val)\n print(\"\\n===== ===== ===== ===== ===== ===== ===== =====\")\n\n return feasible, g_term_val\n\n g_interm_val = self.g_interm_cas(p_all[-1, :, None], cas_reshape(q_all[-1, :], (\n self.n_s, self.n_s)))\n\n feasible_interm = np.all(\n lbg_interm - eps_constraints < g_interm_val) and np.all(\n g_interm_val < ubg_interm + eps_constraints)\n\n feasible = feasible_term and feasible_interm\n\n return feasible, np.vstack((g_term_val, g_interm_val))\n\n def get_old_solution(self, x, k=None, get_ctrl_traj=False):\n \"\"\" Shift previously obtained solutions in time and return solution to be applied\n\n Prameters\n ---------\n k: int, optional\n The number of steps to shift back in time. This is number is\n already tracked by the algorithm, so a custom value should be used with caution\n get_ctrl_traj: bool, optional\n Return the safety trajectory state feedback ctrl laws in terms of k_fb,k_ff,p_ctrl\n\n Returns\n -------\n u_apply: n_s x 0 1darray[float]\n The controls to be applied at the current time step\n\n if get_ctrl_traj:\n k_fb_safe_traj:\n The feedback ctrls of the remaining safety trajectory\n k_ff_safe_traj:\n The current ff ctrl and the remaining ff ctrls of the safety trajectory\n p_ctrl_safe_traj:\n The\n\n\n\n \"\"\"\n if self.n_fail > self.n_safe:\n warnings.warn(\n \"There are no previous solution to be applied. Returning None\")\n return None\n if k is None:\n k = self.n_fail\n\n if k < 1:\n warnings.warn(\"Have to shift at least one timestep back\")\n return None\n\n k_fb_old = self.k_fb_safe_all[k - 1]\n k_ff = self.k_ff_safe[k - 1, :, None]\n p_safe = self.p_safe[k - 1, :, None]\n\n u_apply = feedback_ctrl(x, k_ff, k_fb_old, p_safe)\n if get_ctrl_traj:\n k_fb_safe_traj = None\n k_ff_safe_traj = u_apply\n p_ctrl_safe_traj = None\n\n if k < self.n_safe:\n k_fb_safe_traj = self.k_fb_safe_all[k:, :]\n # in accordance to the structure current ctrl u_apply is part of the k_ff ctrl trajectory\n k_ff_safe_traj = np.vstack((u_apply, self.k_ff_safe[k + 1:, :]))\n p_ctrl_safe_traj = self.p_safe[k:, :]\n\n return u_apply, k_fb_safe_traj, \\\n k_ff_safe_traj, p_ctrl_safe_traj\n\n return u_apply\n\n def _set_attributes_from_dict(self, attrib_names, default_attribs={},\n custom_attrib={}):\n \"\"\" Set class attributes from a list of keys,values \"\"\"\n for attr_name in attrib_names:\n if attr_name in custom_attrib:\n attr_val = custom_attrib[attr_name]\n elif attr_name in default_attribs:\n attr_val = default_attribs[attr_name]\n else:\n raise ValueError(\n \"Neither a custom nor a default value is given for the requried attribute {}\".format(\n attr_name))\n\n setattr(self, attr_name, attr_val)\n\n def _set_perf_trajectory(self, name):\n \"\"\" Get the peformance trajectory function from identifier\"\"\"\n if name == 'mean_equivalent':\n self.perf_trajectory = mean_equivalent_multistep\n elif name == 'taylor':\n self.perf_trajectory = multi_step_taylor_symbolic\n else:\n raise NotImplementedError(\"Unknown uncertainty propagation method\")\n\n def _get_init_controls(self):\n \"\"\" Initialize the controls for the MPC step\n\n\n Returns\n -------\n u_0: n_u x 0 np.array[float]\n Initialization of the first (shared) input\n k_ff_safe_new: (n_safe-1) x n_u np.ndarray[float]\n Initialization of the safety feed-forward control inputs\n k_fb_new: n_u x n_x np.ndarray[float]\n Initialization of the safety feed-back control inputs\n k_ff_perf_new: (n_perf - r_1) x n_u np.ndarray[float]\n Initialization of the performance feed-forward control inputs.\n Not including the shared controls (if r > 1)\n k_fb_perf_0: n_u x n_x np.ndarray[float]\n Initialization of the safety feed-back control inputs\n\n \"\"\"\n\n u_perf_0 = None\n k_fb_perf_0 = None\n k_fb_lqr = self.get_lqr_feedback()\n\n if self.do_shift_solution and self.n_fail == 0:\n if self.n_safe > 1:\n k_fb_safe = np.copy(self.k_fb_safe_all)\n\n # Shift the safe controls\n k_ff_safe = np.copy(self.k_ff_safe)\n\n u_0 = k_ff_safe[0, :]\n\n if self.n_safe > self.r and self.n_perf > self.n_safe: # the first control after the shared controls\n k_ff_perf = np.copy(self.k_ff_perf)\n k_ff_r_last = (k_ff_perf[0, :] + k_ff_safe[self.r - 1,\n :]) / 2 # mean of first perf ctrl and safe ctrl after shared\n else:\n k_ff_r_last = k_ff_safe[-1, :] # just the last safe control\n\n k_ff_safe_new = np.vstack((k_ff_safe[1:self.r, :], k_ff_r_last))\n\n if self.n_safe > self.r + 1:\n k_ff_safe_new = np.vstack((k_ff_safe_new, k_ff_safe[self.r:, :]))\n else:\n u_0 = self.u_apply\n k_ff_safe_new = np.array([])\n\n if self.n_perf - self.r > 0:\n k_ff_perf = np.copy(self.k_ff_perf)\n k_ff_perf_new = np.vstack((k_ff_perf[1:, :], k_ff_perf[-1, :]))\n\n if self.perf_has_fb:\n k_fb_perf_0 = np.copy(self.k_fb_perf_0)\n else:\n k_fb_perf_0 = np.array([])\n else:\n k_ff_perf_new = np.array([])\n k_fb_perf_0 = np.array([])\n else:\n k_fb_safe = np.empty((self.n_safe - 1, self.n_s * self.n_u))\n for i in range(self.n_safe - 1):\n k_fb_safe[i] = cas_reshape(k_fb_lqr, (1, -1))\n\n k_ff_safe_new = np.zeros((self.n_safe - 1, self.n_u))\n u_0 = np.zeros((self.n_u, 1))\n\n k_ff_perf_new = np.array([])\n if self.n_perf > 1:\n k_ff_perf_new = np.zeros((self.n_perf - self.r, self.n_u))\n\n if self.perf_has_fb:\n k_fb_perf_0 = k_fb_lqr\n else:\n k_fb_perf_0 = np.array([])\n\n if self.n_safe > 1:\n k_fb_safe_new = np.vstack((k_fb_safe[1:, :], k_fb_safe[-1, :]))\n\n else:\n k_fb_safe_new = np.array([])\n\n return u_0, k_ff_safe_new, k_fb_safe, k_ff_perf_new, k_fb_perf_0\n\n def update_model(self, x, y, opt_hyp=False, replace_old=True,\n reinitialize_solver=True):\n \"\"\" Update the model of the dynamics\n\n Parameters\n ----------\n x: n x (n_s+n_u) array[float]\n The raw training input (state,action) pairs\n y: n x (n_s) array[float]\n The raw training targets (observations of next state)\n opt_hyp: bool\n True, if we want to re-optimize the GP hyperparameters\n replace_old: bool\n True, if we replace the current training set of the GP with x,y\n reinitialize_solver:\n True, if we re-initialize the solver (otherwise the MPC will not be updated with the new GP)\n\n \"\"\"\n n_train = np.shape(x)[0]\n x_s = x[:, :self.n_s].reshape((n_train, self.n_s))\n x_u = x[:, self.n_s:].reshape((n_train, self.n_u))\n y_prior = self.eval_prior(x_s, x_u)\n x_trafo = mtimes(x_s, self.lin_trafo_gp_input.T)\n\n x = np.hstack((x_trafo, x_u))\n\n self.ssm.update_model(x, y - y_prior, opt_hyp, replace_old)\n self.ssm_forward = self.ssm.get_forward_model_casadi(True)\n\n if reinitialize_solver:\n self.init_solver(self.cost_func)\n else:\n warnings.warn(\"\"\"Updating gp without reinitializing the solver! \\n\n This is potentially dangerous, since the new GP is not incorporated in the MPC\"\"\")\n", "meta": {"hexsha": "b22868be6c54439b37d2d417aad996319a154261", "size": 46618, "ext": "py", "lang": "Python", "max_stars_repo_path": "safe_exploration/safempc_simple.py", "max_stars_repo_name": "befelix/safe-exploration", "max_stars_repo_head_hexsha": "e6c0bc57b7b51fe3e3c97d51721893fe297b2b11", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 55, "max_stars_repo_stars_event_min_datetime": "2019-05-13T07:17:08.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-23T16:39:20.000Z", "max_issues_repo_path": "safe_exploration/safempc_simple.py", "max_issues_repo_name": "befelix/safe-exploration", "max_issues_repo_head_hexsha": "e6c0bc57b7b51fe3e3c97d51721893fe297b2b11", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2019-05-13T06:56:43.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-12T22:19:28.000Z", "max_forks_repo_path": "safe_exploration/safempc_simple.py", "max_forks_repo_name": "befelix/safe-exploration", "max_forks_repo_head_hexsha": "e6c0bc57b7b51fe3e3c97d51721893fe297b2b11", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 18, "max_forks_repo_forks_event_min_datetime": "2019-05-13T11:08:21.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-23T12:51:36.000Z", "avg_line_length": 40.7144104803, "max_line_length": 192, "alphanum_fraction": 0.5506671243, "include": true, "reason": "import numpy", "num_tokens": 11217, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6150878696277512, "lm_q2_score": 0.31405055141190724, "lm_q1q2_score": 0.19316868462337058}} {"text": "#!/home/jue/.conda/envs/ampere/bin/python \n\nimport os\nimport mock\nimport numpy as np\nimport sys\nimport datetime\n\nfrom typing import Any, Mapping, Optional, Sequence, Tuple\nimport collections\nfrom collections import OrderedDict\n\nfrom timeit import default_timer as timer\nimport argparse\n\nimport io\nfrom Bio import PDB\nfrom Bio.PDB.Polypeptide import PPBuilder\nfrom Bio.PDB import PDBParser\nfrom Bio.PDB.mmcifio import MMCIFIO\n\nsys.path.insert( 0, '/home/nrbennet/software/dl/af2/alphafold' )\n\nimport scipy\n\nimport jax\nimport jax.numpy as jnp\n\nfrom alphafold.common import residue_constants\nfrom alphafold.common import protein\nfrom alphafold.common import confidence\nfrom alphafold.data import pipeline\nfrom alphafold.data import templates\nfrom alphafold.data import mmcif_parsing\nfrom alphafold.model import data\nfrom alphafold.model import config\nfrom alphafold.model import model\nfrom alphafold.data.tools import hhsearch\n\nsys.path.append( '/home/nrbennet/software/silent_tools' )\nimport silent_tools\n\n# Run with Nate's ampere environment\nfrom pyrosetta import *\nfrom rosetta import *\ninit( '-in:file:silent_struct_type binary' )\n\ndef get_args():\n parser = argparse.ArgumentParser(formatter_class=argparse.RawTextHelpFormatter)\n parser.add_argument(\"-silent\", dest=\"silent\", required=True,\n help=\"silent file to predict\")\n parser.add_argument(\"-batch\", dest=\"batch_size\", type=int, default=1,\n help=\"Number of structures to batch together\")\n parser.add_argument(\"-recycle\", dest=\"recycle\", type=int, default=3,\n help=\"Number of recycle iterations to perform\")\n\n args = parser.parse_args()\n return args\n\nargs = get_args()\n\nmodel_name = \"model_1_ptm\"\n\nmodel_config = config.model_config(model_name)\nmodel_config.data.eval.num_ensemble = 1\n\nmodel_config.data.common.num_recycle = args.recycle\nmodel_config.model.num_recycle = args.recycle\n\nmodel_config.model.embeddings_and_evoformer.initial_guess = True\n\nmodel_config.model.global_config.mixed_precision = False\n\nmodel_config.data.common.max_extra_msa = 5\nmodel_config.data.eval.max_msa_clusters = 5\n\nmodel_params = data.get_model_haiku_params(model_name=model_name, data_dir=\"/projects/ml/alphafold\") # CHANGE THIS (directory where \"params/ folder is\")\nmodel_runner = model.RunModel(model_config, model_params)\n\ndef get_seq_from_pdb( pdb_fn ):\n to1letter = {\n \"ALA\":'A', \"ARG\":'R', \"ASN\":'N', \"ASP\":'D', \"CYS\":'C',\n \"GLN\":'Q', \"GLU\":'E', \"GLY\":'G', \"HIS\":'H', \"ILE\":'I',\n \"LEU\":'L', \"LYS\":'K', \"MET\":'M', \"PHE\":'F', \"PRO\":'P',\n \"SER\":'S', \"THR\":'T', \"TRP\":'W', \"TYR\":'Y', \"VAL\":'V' }\n\n seq = []\n seqstr = ''\n with open(pdb_fn) as fp:\n for line in fp:\n if line.startswith(\"TER\"):\n seq.append(seqstr)\n seqstr = ''\n if not line.startswith(\"ATOM\"):\n continue\n if line[12:16].strip() != \"CA\":\n continue\n resName = line[17:20]\n #\n seqstr += to1letter[resName]\n return seq\n\ndef af2_get_atom_positions( pdbfilename ) -> Tuple[np.ndarray, np.ndarray]:\n \"\"\"Gets atom positions and mask from a list of Biopython Residues.\"\"\"\n\n with open(pdbfilename, 'r') as pdb_file:\n lines = pdb_file.readlines()\n\n # indices of residues observed in the structure\n idx_s = [int(l[22:26]) for l in lines if l[:4]==\"ATOM\" and l[12:16].strip()==\"CA\"]\n num_res = len(idx_s)\n\n all_positions = np.zeros([num_res, residue_constants.atom_type_num, 3])\n all_positions_mask = np.zeros([num_res, residue_constants.atom_type_num],\n dtype=np.int64)\n\n residues = collections.defaultdict(list)\n # 4 BB + up to 10 SC atoms\n xyz = np.full((len(idx_s), 14, 3), np.nan, dtype=np.float32)\n for l in lines:\n if l[:4] != \"ATOM\":\n continue\n resNo, atom, aa = int(l[22:26]), l[12:16], l[17:20]\n\n residues[ resNo ].append( ( atom.strip(), aa, [float(l[30:38]), float(l[38:46]), float(l[46:54])] ) )\n\n for resNo in residues:\n\n pos = np.zeros([residue_constants.atom_type_num, 3], dtype=np.float32)\n mask = np.zeros([residue_constants.atom_type_num], dtype=np.float32)\n\n for atom in residues[ resNo ]:\n atom_name = atom[0]\n x, y, z = atom[2]\n if atom_name in residue_constants.atom_order.keys():\n pos[residue_constants.atom_order[atom_name]] = [x, y, z]\n mask[residue_constants.atom_order[atom_name]] = 1.0\n elif atom_name.upper() == 'SE' and res.get_resname() == 'MSE':\n # Put the coordinates of the selenium atom in the sulphur column.\n pos[residue_constants.atom_order['SD']] = [x, y, z]\n mask[residue_constants.atom_order['SD']] = 1.0\n\n idx = idx_s.index(resNo) # This is the order they show up in the pdb\n all_positions[idx] = pos\n all_positions_mask[idx] = mask\n # _check_residue_distances(\n # all_positions, all_positions_mask, max_ca_ca_distance) # AF2 checks this but if we want to allow massive truncations we don't want to check this\n\n return all_positions, all_positions_mask\n\ndef af2_all_atom_from_struct( pdbfilename, seq_list, just_target=False ):\n template_seq = ''.join( seq_list )\n\n # Parse a residue mask from the chainbreak sequence\n binder_len = len( seq_list[0] )\n residue_mask = [ int( i ) > binder_len for i in range( 1, len( template_seq ) + 1 ) ]\n\n all_atom_positions, all_atom_mask = af2_get_atom_positions( pdbfilename )\n\n all_atom_positions = np.split(all_atom_positions, all_atom_positions.shape[0])\n\n templates_all_atom_positions = []\n\n # Initially fill will all zero values\n for _ in template_seq:\n templates_all_atom_positions.append(\n jnp.zeros((residue_constants.atom_type_num, 3)))\n\n for idx, i in enumerate( template_seq ):\n if just_target and not residue_mask[ idx ]: continue\n\n templates_all_atom_positions[ idx ] = all_atom_positions[ idx ][0] # assign target indices to template coordinates\n\n return jnp.array(templates_all_atom_positions)\n\ndef template_from_struct( pdbfilename, seq_list ):\n\n template_seq = ''.join(seq_list)\n\n # Parse a residue mask from the chainbreak sequence\n binder_len = len( seq_list[0] )\n residue_mask = [ int( i ) > binder_len for i in range( 1, len( template_seq ) + 1 ) ]\n\n ret_all_atom_positions, ret_all_atom_mask = af2_get_atom_positions( pdbfilename )\n\n all_atom_positions = np.split(ret_all_atom_positions, ret_all_atom_positions.shape[0])\n all_atom_masks = np.split(ret_all_atom_mask, ret_all_atom_mask.shape[0])\n \n output_templates_sequence = []\n output_confidence_scores = []\n templates_all_atom_positions = []\n templates_all_atom_masks = []\n\n # Initially fill will all zero values\n for _ in template_seq:\n templates_all_atom_positions.append(\n np.zeros((residue_constants.atom_type_num, 3)))\n templates_all_atom_masks.append(np.zeros(residue_constants.atom_type_num))\n output_templates_sequence.append('-')\n output_confidence_scores.append(-1)\n \n confidence_scores = []\n for _ in template_seq: confidence_scores.append( 9 )\n\n for idx, i in enumerate( template_seq ):\n\n if not residue_mask[ idx ]: continue\n\n templates_all_atom_positions[ idx ] = all_atom_positions[ idx ][0] # assign target indices to template coordinates\n templates_all_atom_masks[ idx ] = all_atom_masks[ idx ][0]\n output_templates_sequence[ idx ] = template_seq[ idx ]\n output_confidence_scores[ idx ] = confidence_scores[ idx ] # 0-9 where higher is more confident\n\n output_templates_sequence = ''.join(output_templates_sequence)\n\n templates_aatype = residue_constants.sequence_to_onehot(\n output_templates_sequence, residue_constants.HHBLITS_AA_TO_ID)\n\n template_feat_dict = {'template_all_atom_positions': np.array(templates_all_atom_positions)[None],\n 'template_all_atom_masks': np.array(templates_all_atom_masks)[None],\n 'template_sequence': [output_templates_sequence.encode()],\n 'template_aatype': np.array(templates_aatype)[None],\n 'template_confidence_scores': np.array(output_confidence_scores)[None],\n 'template_domain_names': ['none'.encode()],\n 'template_release_date': [\"none\".encode()]}\n\n return template_feat_dict, ret_all_atom_positions, ret_all_atom_mask\n\ndef insert_chainbreaks( pose, binderlen ):\n\n conf = pose.conformation()\n conf.insert_chain_ending( binderlen )\n pose.set_new_conformation( conf )\n\n splits = pose.split_by_chain()\n \n newpose = splits[1]\n for i in range( 2, len( splits )+1 ):\n newpose.append_pose_by_jump( splits[i], newpose.size() )\n \n info = core.pose.PDBInfo( newpose, True )\n newpose.pdb_info( info )\n\n return newpose\n\n return final_dict\n\ndef get_final_dict(score_dict, string_dict):\n print(score_dict)\n final_dict = OrderedDict()\n keys_score = [] if score_dict is None else list(score_dict)\n keys_string = [] if string_dict is None else list(string_dict)\n\n all_keys = keys_score + keys_string\n\n argsort = sorted(range(len(all_keys)), key=lambda x: all_keys[x])\n\n for idx in argsort:\n key = all_keys[idx]\n\n if ( idx < len(keys_score) ):\n final_dict[key] = \"%8.3f\"%(score_dict[key])\n else:\n final_dict[key] = string_dict[key]\n\n return final_dict\n\ndef add2scorefile(tag, scorefilename, write_header=False, score_dict=None):\n with open(scorefilename, \"a\") as f:\n add_to_score_file_open(tag, f, write_header, score_dict)\n\ndef add_to_score_file_open(tag, f, write_header=False, score_dict=None, string_dict=None):\n final_dict = get_final_dict( score_dict, string_dict )\n if ( write_header ):\n f.write(\"SCORE: %s description\\n\"%(\" \".join(final_dict.keys())))\n scores_string = \" \".join(final_dict.values())\n f.write(\"SCORE: %s %s\\n\"%(scores_string, tag))\n\ndef generate_scoredict( outtag, start_time, binderlen, prediction_result, scorefilename ):\n\n plddt_array = prediction_result['plddt']\n plddt = np.mean( plddt_array )\n plddt_binder = np.mean( plddt_array[:binderlen] )\n plddt_target = np.mean( plddt_array[binderlen:] )\n\n pae = prediction_result['predicted_aligned_error']\n pae_interaction1 = np.mean( pae[:binderlen,binderlen:] )\n pae_interaction2 = np.mean( pae[binderlen:,:binderlen] )\n pae_binder = np.mean( pae[:binderlen,:binderlen] )\n pae_target = np.mean( pae[binderlen:,binderlen:] )\n\n pae_interaction_total = ( pae_interaction1 + pae_interaction2 ) / 2\n\n # Calculate pae_interface which is pae_interaction of only residues within 10A of the binder\n # This is all derived from some AF2 code to calculate pAE from logits\n # This turns logits to probabilites and then gets the expected value at each position\n\n edges = prediction_result['distogram']['bin_edges']\n edges = np.squeeze(edges)\n probs = scipy.special.softmax(\n prediction_result['distogram']['logits'],\n axis=-1)\n probs = np.squeeze(probs)\n\n step = (edges[1] - edges[0])\n bin_centers = edges + step / 2\n\n bin_centers = np.concatenate([bin_centers, [bin_centers[-1] + step]], axis=-1)\n\n dgram = np.sum(probs * bin_centers, axis=-1)\n\n # End AF2-derived\n\n interface_cutoff = 15 # This can be made into a commandline argument eventually\n distance_mask = np.where(dgram < interface_cutoff, 1, 0) # mask all positions that are not within the interface cutoff\n pae_masked = np.squeeze(pae) * distance_mask\n pae_interface = ( np.mean( pae_masked[:binderlen,binderlen:] ) + np.mean( pae_masked[binderlen:,:binderlen] ) ) / 2\n\n if np.isnan(pae_interface): pae_interface = 25\n if pae_interface == 0: pae_interface = 25 # If there are no residues within the interface we want to set this as a high number, not 0\n\n time = timer() - start_time\n\n score_dict = {\n \"plddt_total\" : plddt,\n \"plddt_binder\" : plddt_binder,\n \"plddt_target\" : plddt_target,\n \"pae_interaction1\" : pae_interaction1,\n \"pae_interaction2\" : pae_interaction2,\n \"pae_binder\" : pae_binder,\n \"pae_target\" : pae_target,\n \"pae_interaction\" : pae_interaction_total,\n # \"pae_interface\" : pae_interface, # Benchmarking with this metric suggests that it's not a very good predictor of binder success\n \"time\" : time\n }\n\n write_header=False\n if not os.path.isfile(scorefilename): write_header=True\n add2scorefile(outtag, scorefilename, write_header=write_header, score_dict=score_dict)\n \n print(score_dict)\n print( f\"Tag: {outtag} reported success in {time} seconds\" )\n\n return score_dict\n\ndef combine_batches(tags, feature_dict_dict, initial_guess_dict):\n print( tags )\n allkeys = feature_dict_dict[tags[0]].keys()\n processed_feature_dict = {}\n for key in allkeys:\n processed_feature_dict[key] = jnp.stack([feature_dict_dict[tag][key] for tag in tags], axis=0)\n processed_initial_guess_dict = jnp.stack([initial_guess_dict[tag] for tag in tags], axis=0)\n return processed_feature_dict, processed_initial_guess_dict\n\ndef unpack_batches( tags, binderlen_dict, start, feature_dict_dict, prediction_result, sfd_out, scorefilename ):\n\n # First unpack the structures\n all_struct_module = prediction_result['structure_module']\n proteins = {} \n for i in range(all_struct_module['final_atom_positions'].shape[0]):\n key = tags[i]\n\n proteins[key] = protein.Protein(\n aatype=feature_dict_dict[key]['aatype'][0],\n atom_positions=all_struct_module['final_atom_positions'][i,...],\n atom_mask=all_struct_module['final_atom_mask'][i,...],\n residue_index=feature_dict_dict[key]['residue_index'][0] + 1,\n b_factors=np.zeros_like(all_struct_module['final_atom_mask'][i,...]) )\n\n # Then unpack and compute confidence metrics\n confidence_metrics = {}\n for i in range(prediction_result['predicted_lddt']['logits'].shape[0]):\n key = tags[i]\n\n curr_metrics = {}\n curr_metrics['distogram'] = prediction_result['distogram']\n curr_metrics['plddt'] = confidence.compute_plddt(\n prediction_result['predicted_lddt']['logits'][i,...])\n if 'predicted_aligned_error' in prediction_result:\n curr_metrics.update(confidence.compute_predicted_aligned_error(\n prediction_result['predicted_aligned_error']['logits'][i,...],\n prediction_result['predicted_aligned_error']['breaks'][i,...]))\n\n confidence_metrics[key] = curr_metrics\n\n for tag in tags:\n\n unrelaxed_pdb_lines = protein.to_pdb(proteins[tag])\n \n outtag = f'{tag}_af2pred'\n unrelaxed_pdb_path = f'temp_af2output.pdb'\n with open(unrelaxed_pdb_path, 'w') as f: f.write(unrelaxed_pdb_lines)\n \n score_dict = generate_scoredict( outtag, start, binderlen_dict[tag], confidence_metrics[tag], scorefilename )\n\n add2silent( outtag, unrelaxed_pdb_path, score_dict, binderlen_dict[tag], sfd_out ) \n os.remove( unrelaxed_pdb_path )\n\ndef insert_truncations(residue_index, Ls):\n # Minkyung's chainbreak wizardry\n idx_res = residue_index\n for break_i in Ls:\n idx_res[break_i:] += 200\n residue_index = idx_res\n\n return residue_index\n\ndef add2silent( tag, pdb, score_dict, binderlen, sfd_out ):\n pose = pose_from_file( pdb )\n\n pose = insert_chainbreaks( pose, binderlen )\n\n struct = sfd_out.create_SilentStructOP()\n struct.fill_struct( pose, tag )\n\n for scorename, value in score_dict.items():\n struct.add_energy(scorename, value, 1)\n\n sfd_out.add_structure( struct )\n sfd_out.write_silent_struct( struct, \"out.silent\" )\n\ndef predict_structure(tags, feature_dict_dict, binderlen_dict, initial_guess_dict, sfd_out, scorefilename, random_seed=0): \n \"\"\"Predicts structure using AlphaFold for the given sequence.\"\"\"\n\n start = timer()\n print(f\"running {model_name}\")\n model_runner.params = model_params\n \n processed_feature_dict, processed_initial_guess_dict = combine_batches(tags, feature_dict_dict, initial_guess_dict)\n\n prediction_result = jax.vmap(model_runner.apply, in_axes=(None,None,0,0))(model_runner.params,\n jax.random.PRNGKey(0), processed_feature_dict, processed_initial_guess_dict)\n\n unpack_batches( tags, binderlen_dict, start, feature_dict_dict, prediction_result, sfd_out, scorefilename ) \n\n print( f\"{args.batch_size} predictions made in {timer() - start} seconds\" )\n\n# Mostly taken from af2 source\n# Going to use to detect truncation points\ndef check_residue_distances(all_positions,\n all_positions_mask,\n max_amide_distance):\n \"\"\"Checks if the distance between unmasked neighbor residues is ok.\"\"\"\n breaks = []\n\n c_position = residue_constants.atom_order['C']\n n_position = residue_constants.atom_order['N']\n prev_is_unmasked = False\n this_c = None\n for i, (coords, mask) in enumerate(zip(all_positions, all_positions_mask)):\n this_is_unmasked = bool(mask[c_position]) and bool(mask[n_position])\n if this_is_unmasked:\n this_n = coords[n_position]\n if prev_is_unmasked:\n distance = np.linalg.norm(this_n - prev_c)\n if distance > max_amide_distance:\n breaks.append(i)\n print( f'The distance between residues {i} and {i+1} is {distance:.2f} A' +\n f' > limit {max_amide_distance} A.' )\n print( f\"I'm going to insert a chainbreak after residue {i}\" )\n prev_c = coords[c_position]\n prev_is_unmasked = this_is_unmasked\n\n return breaks\n\ndef generate_feature_dict( pdbfile ):\n seq_list = get_seq_from_pdb(pdbfile)\n query_sequence = ''.join(seq_list)\n\n initial_guess = af2_all_atom_from_struct(pdbfile, seq_list, just_target=False)\n\n template_dict, all_atom_positions, all_atom_masks = template_from_struct(pdbfile, seq_list)\n \n # Gather features\n feature_dict = {\n **pipeline.make_sequence_features(sequence=query_sequence,\n description=\"none\",\n num_res=len(query_sequence)),\n **pipeline.make_msa_features(msas=[[query_sequence]],\n deletion_matrices=[[[0]*len(query_sequence)]]),\n **template_dict\n }\n \n max_amide_distance = 3\n breaks = check_residue_distances(all_atom_positions, all_atom_masks, max_amide_distance)\n\n feature_dict['residue_index'] = insert_truncations(feature_dict['residue_index'], breaks)\n\n return feature_dict, initial_guess, len(seq_list[0]) \n\ndef input_check( pdbfile, tag ):\n with open(pdbfile,'r') as f: lines = f.readlines()\n\n seen_indices = set()\n chain1 = True\n\n for line in lines:\n line = line.strip()\n \n if len(line) == 0: continue\n\n splits = line.split()\n\n if splits[0] == \"TER\":\n chain1 = False\n continue\n\n if not splits[0] == \"ATOM\": continue\n\n if splits[2] == 'CA':\n # Only checking residue index at CA atom\n residx = splits[5]\n if residx in seen_indices:\n sys.exit( f\"\\nNon-unique residue indices detected for tag: {tag}. \" +\n \"This will cause AF2 to yield garbage outputs. Exiting.\" )\n\n seen_indices.add(residx)\n\n if ( not splits[4] == \"A\" ) and chain1:\n sys.exit( f\"\\nThe first chain in the pose must be the binder and it must be chain A. \" +\n f\"Tag: {tag} does not satisfy this requirement. Exiting.\" )\n\ndef tag_buffer2features(tag_buffer, sfd_in):\n \n feature_dict_dict = {}\n initial_guess_dict = {}\n binderlen_dict = {}\n\n for tag in tag_buffer:\n # dump pdb\n pose = Pose()\n sfd_in.get_structure(tag).fill_pose(pose)\n pose.dump_pdb(tmppdb)\n\n # Input Checking\n # Must ensure that:\n # - All residue indices are unique\n # - The first chain is \"A\"\n\n input_check(tmppdb, tag)\n \n feature_dict, initial_guess, binderlen = generate_feature_dict(tmppdb)\n feature_dict_dict[tag] = model_runner.process_features(feature_dict, random_seed=0)\n initial_guess_dict[tag] = initial_guess\n binderlen_dict[tag] = binderlen\n\n os.remove( tmppdb )\n\n return feature_dict_dict, initial_guess_dict, binderlen_dict\n\n# Checkpointing Functions\n\ndef record_checkpoint( tag_buffer, checkpoint_filename ):\n with open( checkpoint_filename, 'a' ) as f:\n for tag in tag_buffer:\n f.write( tag )\n f.write( '\\n' )\n\ndef determine_finished_structs( checkpoint_filename ):\n done_set = set()\n if not os.path.isfile( checkpoint_filename ): return done_set\n\n with open( checkpoint_filename, 'r' ) as f:\n for line in f:\n done_set.add( line.strip() )\n\n return done_set\n\n# End Checkpointing Functions\n\n################## Begin Main Function ##################\n\nsfd_out = core.io.silent.SilentFileData( \"out.silent\", False, False, \"binary\", core.io.silent.SilentFileOptions())\n\nsfd_in = rosetta.core.io.silent.SilentFileData(rosetta.core.io.silent.SilentFileOptions())\nsfd_in.read_file(args.silent)\n\nalltags = silent_tools.get_silent_index(args.silent)[\"tags\"]\ntmppdb = 'tmp.pdb'\n\ncheckpoint_filename = \"check.point\"\nscorefilename = \"out.sc\"\ntag_buffer = []\n\nfinished_structs = determine_finished_structs( checkpoint_filename )\n\nfor idx,tag in enumerate(alltags):\n \n if tag in finished_structs:\n print( f\"SKIPPING {tag}, since it was already run\" )\n continue\n \n tag_buffer.append(tag)\n if (len(tag_buffer) < args.batch_size) and not idx>=(len(alltags)-1) : continue\n \n feature_dict_dict, initial_guess_dict, binderlen_dict = tag_buffer2features(tag_buffer, sfd_in)\n predict_structure(tag_buffer, feature_dict_dict, binderlen_dict, initial_guess_dict, sfd_out, scorefilename)\n\n record_checkpoint( tag_buffer, checkpoint_filename )\n tag_buffer = []\n\nprint('done predicting')\n", "meta": {"hexsha": "09438b534682db1a2a82c8acca2f601073605d70", "size": 21703, "ext": "py", "lang": "Python", "max_stars_repo_path": "scripts/af2_interface_metrics.py", "max_stars_repo_name": "RosettaCommons/RFDesign", "max_stars_repo_head_hexsha": "b404b8b2c57f89c047529c30259aeeb8f6012b61", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 45, "max_stars_repo_stars_event_min_datetime": "2022-01-12T04:39:36.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-25T12:33:36.000Z", "max_issues_repo_path": "scripts/af2_interface_metrics.py", "max_issues_repo_name": "RosettaCommons/RFDesign", "max_issues_repo_head_hexsha": "b404b8b2c57f89c047529c30259aeeb8f6012b61", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 6, "max_issues_repo_issues_event_min_datetime": "2022-01-15T16:48:39.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-15T16:20:34.000Z", "max_forks_repo_path": "scripts/af2_interface_metrics.py", "max_forks_repo_name": "RosettaCommons/RFDesign", "max_forks_repo_head_hexsha": "b404b8b2c57f89c047529c30259aeeb8f6012b61", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 10, "max_forks_repo_forks_event_min_datetime": "2022-01-12T11:28:03.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-30T11:36:41.000Z", "avg_line_length": 35.991708126, "max_line_length": 152, "alphanum_fraction": 0.6959406534, "include": true, "reason": "import numpy,import scipy,import jax", "num_tokens": 5445, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6150878555160665, "lm_q2_score": 0.31405055141190724, "lm_q1q2_score": 0.1931686801915882}} {"text": "# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\"\"\"\n此模块包含构造 MBQC 模型的常用类和配套的运算模拟工具。\n\"\"\"\n\nfrom numpy import random, pi\nfrom networkx import Graph, spring_layout, draw_networkx\nimport matplotlib.pyplot as plt\nfrom paddle import t, to_tensor, matmul, conj, real, reshape, multiply\nfrom paddle_quantum.mbqc.utils import plus_state, cz_gate, pauli_gate\nfrom paddle_quantum.mbqc.utils import basis, kron, div_str_to_float\nfrom paddle_quantum.mbqc.utils import permute_to_front, permute_systems, print_progress, plot_results\nfrom paddle_quantum.mbqc.qobject import State, Pattern\nfrom paddle_quantum.mbqc.transpiler import transpile\n\n__all__ = [\n \"MBQC\",\n \"simulate_by_mbqc\"\n]\n\n\nclass MBQC:\n r\"\"\"定义基于测量的量子计算模型 ``MBQC`` 类。\n\n 用户可以通过实例化该类来定义自己的 MBQC 模型。\n \"\"\"\n\n def __init__(self):\n r\"\"\"MBQC 类的构造函数，用于实例化一个 ``MBQC`` 对象。\n \"\"\"\n self.__graph = None # Graph in a MBQC model\n self.__pattern = None # Measurement pattern in a MBQC model\n\n self.__bg_state = State() # Background state of computation\n self.__history = [self.__bg_state] # History of background states\n self.__status = self.__history[-1] if self.__history != [] else None # latest history item\n\n self.vertex = None # Vertex class to maintain all the vertices\n self.__outcome = {} # Dictionary to store all measurement outcomes\n self.max_active = 0 # Maximum number of active vertices so far\n\n self.__draw = False # Switch to draw the dynamical running process\n self.__track = False # Switch to track the running progress\n self.__pause_time = None # Pause time for drawing\n self.__pos = None # Position for drawing\n\n class Vertex:\n r\"\"\"定义维护点列表，用于实例化一个 ``Vertex`` 对象。\n\n 将 MBQC 算法中图的节点分为三类，并进行动态维护。\n\n Note:\n 这是内部类，用户不需要直接调用到该类。\n\n Attributes:\n total (list): MBQC 算法中图上的全部节点，不随运算而改变\n pending (list): 待激活的节点，随着运算的执行而逐渐减少\n active (list): 激活的节点，与当前测量步骤直接相关的节点\n measured (list): 已被测量过的节点，随着运算的执行而逐渐增加\n \"\"\"\n\n def __init__(self, total=None, pending=None, active=None, measured=None):\n r\"\"\"``Vertex`` 类的构造函数，用于实例化一个 ``Vertex`` 对象。\n\n Args:\n total (list): MBQC 算法中图上的全部节点，不随运算而改变\n pending (list): 待激活的节点，随着运算的执行而逐渐减少\n active (list): 激活的节点，与当前测量步骤直接相关的节点\n measured (list): 已被测量过的节点，随着运算的执行而逐渐增加\n \"\"\"\n self.total = [] if total is None else total\n self.pending = [] if pending is None else pending\n self.active = [] if active is None else active\n self.measured = [] if measured is None else measured\n\n def set_graph(self, graph):\n r\"\"\"设置 MBQC 模型中的图。\n\n 该函数用于将用户自己构造的图传递给 ``MBQC`` 实例。\n \n Args:\n graph (list): MBQC 模型中的图，由列表 ``[V, E]`` 给出， 其中 ``V`` 为节点列表，``E`` 为边列表\n \"\"\"\n vertices, edges = graph\n\n vertices_of_edges = set([vertex for edge in edges for vertex in list(edge)])\n assert vertices_of_edges.issubset(vertices), \"edge must be between the graph vertices.\"\n\n self.__graph = Graph()\n self.__graph.add_nodes_from(vertices)\n self.__graph.add_edges_from(edges)\n\n self.vertex = self.Vertex(total=vertices, pending=vertices, active=[], measured=[])\n\n def get_graph(self):\n r\"\"\"获取图的信息。\n\n Returns:\n nx.Graph: 图\n \"\"\"\n return self.__graph\n\n def set_pattern(self, pattern):\n r\"\"\"设置 MBQC 模型的测量模式。\n\n 该函数用于将用户由电路图翻译得到或自己构造的测量模式传递给 ``MBQC`` 实例。\n\n Warning:\n 输入的 pattern 参数是 ``Pattern`` 类型，其中命令列表为标准 ``EMC`` 命令。\n\n Args:\n pattern (Pattern): MBQC 算法对应的测量模式\n \"\"\"\n assert isinstance(pattern, Pattern), \"please input a pattern of type 'Pattern'.\"\n\n self.__pattern = pattern\n cmds = self.__pattern.commands[:]\n\n # Check if the pattern is a standard EMC form\n cmd_map = {\"E\": 1, \"M\": 2, \"X\": 3, \"Z\": 4, \"S\": 5}\n cmd_num_wild = [cmd_map[cmd.name] for cmd in cmds]\n cmd_num_standard = cmd_num_wild[:]\n cmd_num_standard.sort(reverse=False)\n assert cmd_num_wild == cmd_num_standard, \"input pattern is not a standard EMC form.\"\n\n # Set graph by entanglement commands\n edges = [tuple(cmd.which_qubits) for cmd in cmds if cmd.name == \"E\"]\n vertices = list(set([vertex for edge in edges for vertex in list(edge)]))\n graph = [vertices, edges]\n self.set_graph(graph)\n\n def get_pattern(self):\n r\"\"\"获取测量模式的信息。\n\n Returns:\n Pattern: 测量模式\n \"\"\"\n return self.__pattern\n\n def set_input_state(self, state=None):\n r\"\"\"设置需要替换的输入量子态。\n\n Warning:\n 与电路模型不同，MBQC 模型通常默认初始态为加态。如果用户不调用此方法设置初始量子态，则默认为加态。\n 如果用户以测量模式运行 MBQC，则此处输入量子态的系统标签会被限制为从零开始的自然数，类型为整型。\n\n Args:\n state (State): 需要替换的量子态，默认为加态\n \"\"\"\n assert self.__graph is not None, \"please set 'graph' or 'pattern' before calling 'set_input_state'.\"\n assert isinstance(state, State) or state is None, \"please input a state of type 'State'.\"\n vertices = list(self.__graph.nodes)\n\n if state is None:\n vector = plus_state()\n system = [vertices[0]] # Activate the first vertex, system should be a list\n else:\n vector = state.vector\n # If a pattern is set, map the input state system to the pattern's input\n if self.__pattern is not None:\n assert all(isinstance(label, int) for label in state.system), \"please input system labels of type 'int'\"\n assert all(label >= 0 for label in state.system), \"please input system labels with non-negative values\"\n\n system = [label for label in self.__pattern.input_ if int(div_str_to_float(label[0])) in state.system]\n else:\n system = state.system\n assert set(system).issubset(vertices), \"input system labels must be a subset of graph vertices.\"\n\n self.__bg_state = State(vector, system)\n self.__history = [self.__bg_state]\n self.__status = self.__history[-1]\n self.vertex = self.Vertex(total=vertices,\n pending=list(set(vertices).difference(system)),\n active=system,\n measured=[])\n self.max_active = len(self.vertex.active)\n\n def __set_position(self, pos):\n r\"\"\"设置动态过程图绘制时节点的位置坐标。\n\n Note:\n 这是内部方法，用户并不需要直接调用到该方法。\n\n Args:\n pos (dict or bool, optional): 节点坐标的字典数据或者内置的坐标选择，\n 内置的坐标选择有：``True`` 为测量模式自带的坐标，``False`` 为 ``spring_layout`` 坐标\n \"\"\"\n assert isinstance(pos, bool) or isinstance(pos, dict), \"'pos' should be either bool or dict.\"\n if isinstance(pos, dict):\n self.__pos = pos\n elif pos:\n assert self.__pattern is not None, \"'pos=True' must be chosen after a pattern is set.\"\n self.__pos = {v: [div_str_to_float(v[1]), - div_str_to_float(v[0])] for v in list(self.__graph.nodes)}\n else:\n self.__pos = spring_layout(self.__graph) # Use 'spring_layout' otherwise\n\n def __draw_process(self, which_process, which_qubit):\n r\"\"\"根据当前节点状态绘图，用以实时展示 MBQC 模型的模拟计算过程。\n\n Note:\n 这是内部方法，用户并不需要直接调用到该方法。\n\n Args:\n which_process (str): MBQC 执行的阶段，\"measuring\", \"active\" 或者 \"measured\"\n which_qubit (any): 当前关注的节点，可以是 ``str``, ``tuple`` 等任意数据类型，但需要和图的标签类型匹配\n \"\"\"\n if self.__draw:\n assert which_process in [\"measuring\", \"active\", \"measured\"]\n assert which_qubit in self.vertex.total, \"'which_qubit' must be in the graph.\"\n\n vertex_sets = []\n # Find where the 'which_qubit' is\n if which_qubit in self.vertex.pending:\n pending = self.vertex.pending[:]\n pending.remove(which_qubit)\n vertex_sets = [pending, self.vertex.active, [which_qubit], self.vertex.measured]\n elif which_qubit in self.vertex.active:\n active = self.vertex.active[:]\n active.remove(which_qubit)\n vertex_sets = [self.vertex.pending, active, [which_qubit], self.vertex.measured]\n elif which_qubit in self.vertex.measured:\n vertex_sets = [self.vertex.pending, self.vertex.active, [], self.vertex.measured]\n\n # Indentify ancilla vertices\n ancilla_qubits = []\n if self.__pattern is not None:\n for vertex in list(self.__graph.nodes):\n row_coordinate = div_str_to_float(vertex[0])\n col_coordinate = div_str_to_float(vertex[1])\n # Ancilla vertices do not have integer coordinates\n if abs(col_coordinate - int(col_coordinate)) >= 1e-15 \\\n or abs(row_coordinate - int(row_coordinate)) >= 1e-15:\n ancilla_qubits.append(vertex)\n\n plt.cla()\n plt.title(\"MBQC Running Process\", fontsize=15)\n plt.xlabel(\"Measuring (RED) Active (GREEN) Pending (BLUE) Measured (GRAY)\", fontsize=12)\n plt.grid()\n mngr = plt.get_current_fig_manager()\n mngr.window.setGeometry(500, 100, 800, 600)\n colors = ['tab:blue', 'tab:green', 'tab:red', 'tab:gray']\n for j in range(4):\n for vertex in vertex_sets[j]:\n options = {\n \"nodelist\": [vertex],\n \"node_color\": colors[j],\n \"node_shape\": '8' if vertex in ancilla_qubits else 'o',\n \"with_labels\": False,\n \"width\": 3,\n }\n draw_networkx(self.__graph, self.__pos, **options)\n ax = plt.gca()\n ax.margins(0.20)\n plt.axis(\"on\")\n ax.set_axisbelow(True)\n plt.pause(self.__pause_time)\n\n def draw_process(self, draw=True, pos=False, pause_time=0.5):\n r\"\"\"动态过程图绘制，用以实时展示 MBQC 模型的模拟计算过程。\n\n Args:\n draw (bool, optional): 是否绘制动态过程图的布尔开关\n pos (bool or dict, optional): 节点坐标的字典数据或者内置的坐标选择，内置的坐标选择有：\n ``True`` 为测量模式自带的坐标，``False`` 为 `spring_layout` 坐标\n pause_time (float, optional): 绘制动态过程图时每次更新的停顿时间\n \"\"\"\n assert self.__graph is not None, \"please set 'graph' or 'pattern' before calling 'draw_process'.\"\n assert isinstance(draw, bool), \"'draw' must be bool.\"\n assert isinstance(pos, bool) or isinstance(pos, dict), \"'pos' should be either bool or dict.\"\n assert pause_time > 0, \"'pause_time' must be strictly larger than 0.\"\n\n self.__draw = draw\n self.__pause_time = pause_time\n\n if self.__draw:\n plt.figure()\n plt.ion()\n self.__set_position(pos)\n\n def track_progress(self, track=True):\n r\"\"\" 显示 MBQC 模型运行进度的开关。\n\n Args:\n track (bool, optional): ``True`` 打开进度条显示功能， ``False`` 关闭进度条显示功能\n \"\"\"\n assert isinstance(track, bool), \"the parameter 'track' must be bool.\"\n self.__track = track\n\n def __apply_cz(self, which_qubits_list):\n r\"\"\"对给定的两个比特作用控制 Z 门。\n\n Note:\n 这是内部方法，用户并不需要直接调用到该方法。\n\n Warning:\n 作用控制 Z 门的两个比特一定是被激活的。\n\n Args:\n which_qubits_list (list): 作用控制 Z 门的比特对标签列表，例如 ``[(1, 2), (3, 4),...]``\n \"\"\"\n for which_qubits in which_qubits_list:\n assert set(which_qubits).issubset(self.vertex.active), \\\n \"vertices in 'which_qubits_list' must be activated first.\"\n assert which_qubits[0] != which_qubits[1], \\\n 'the control and target qubits must not be the same.'\n\n # Find the control and target qubits and permute them to the front\n self.__bg_state = permute_to_front(self.__bg_state, which_qubits[0])\n self.__bg_state = permute_to_front(self.__bg_state, which_qubits[1])\n\n new_state = self.__bg_state\n new_state_len = new_state.length\n qua_length = int(new_state_len / 4)\n cz = cz_gate()\n # Reshape the state, apply CZ and reshape it back\n new_state.vector = reshape(matmul(cz, reshape(new_state.vector, [4, qua_length])), [new_state_len, 1])\n\n # Update the order of active vertices and the background state\n self.vertex.active = new_state.system\n self.__bg_state = State(new_state.vector, new_state.system)\n\n def __apply_pauli_gate(self, gate, which_qubit):\n r\"\"\"对给定的单比特作用 Pauli 门。\n\n Note:\n 这是内部方法，用户并不需要直接调用到该方法。\n\n Args:\n gate (str): Pauli 门的索引字符，\"I\", \"X\", \"Y\", \"Z\" 分别表示对应的门，在副产品处理时用 \"X\" 和 \"Z\" 门\n which_qubit (any): 作用 Pauli 门的系统标签，\n 可以是 ``str``, ``tuple`` 等任意数据类型，但需要和 MBQC 模型中节点的标签类型匹配\n \"\"\"\n new_state = permute_to_front(self.__bg_state, which_qubit)\n new_state_len = new_state.length\n half_length = int(new_state_len / 2)\n gate_mat = pauli_gate(gate)\n # Reshape the state, apply X and reshape it back\n new_state.vector = reshape(matmul(gate_mat, reshape(new_state.vector, [2, half_length])), [new_state_len, 1])\n # Update the order of active vertices and the background state\n self.vertex.active = new_state.system\n self.__bg_state = State(new_state.vector, new_state.system)\n\n def __create_graph_state(self, which_qubit):\n r\"\"\"以待测量的比特为输入参数，生成测量当前节点所需要的最小的量子图态。\n\n Note:\n 这是内部方法，用户并不需要直接调用到该方法。\n\n Args:\n which_qubit (any): 待测量比特的系统标签。\n 可以是 ``str``, ``tuple`` 等任意数据类型，但需要和 MBQC 模型中节点的标签类型匹配\n \"\"\"\n # Find the neighbors of 'which_qubit'\n which_qubit_neighbors = set(self.__graph.neighbors(which_qubit))\n # Exclude the qubits already measured\n neighbors_not_measured = which_qubit_neighbors.difference(set(self.vertex.measured))\n # Create a list of system labels that will be applied to cz gates\n cz_list = [(which_qubit, qubit) for qubit in neighbors_not_measured]\n # Get the qubits to be activated\n append_qubits = {which_qubit}.union(neighbors_not_measured).difference(set(self.vertex.active))\n # Update active and pending lists\n self.vertex.active += list(append_qubits)\n self.vertex.pending = list(set(self.vertex.pending).difference(self.vertex.active))\n\n # Compute the new background state vector\n new_bg_state_vector = kron([self.__bg_state.vector] + [plus_state() for _ in append_qubits])\n\n # Update the background state and apply cz\n self.__bg_state = State(new_bg_state_vector, self.vertex.active)\n self.__apply_cz(cz_list)\n self.__draw_process(\"active\", which_qubit)\n\n def __update(self):\n r\"\"\"更新历史列表和量子态信息。\n \"\"\"\n self.__history.append(self.__bg_state)\n self.__status = self.__history[-1]\n\n def measure(self, which_qubit, basis_list):\n r\"\"\"以待测量的比特和测量基为输入参数，对该比特进行测量。\n\n Note:\n 这是用户在实例化 MBQC 类之后最常调用的方法之一，此处我们对单比特测量模拟进行了最大程度的优化，\n 随着用户对该函数的调用，MBQC 类将自动完成激活相关节点、生成所需的图态以及对特定比特进行测量的全过程，\n 并记录测量结果和对应测量后的量子态。用户每调用一次该函数，就完成一次对单比特的测量操作。\n\n Warning:\n 当且仅当用户调用 ``measure`` 类方法时，MBQC 模型才真正进行运算。\n\n Args:\n which_qubit (any): 待测量量子比特的系统标签，\n 可以是 ``str``, ``tuple`` 等任意数据类型，但需要和 MBQC 模型的图上标签匹配\n basis_list (list): 测量基向量构成的列表，列表元素为 ``Tensor`` 类型的列向量\n\n 代码示例：\n\n .. code-block:: python\n\n from paddle_quantum.mbqc.simulator import MBQC\n from paddle_quantum.mbqc.qobject import State\n from paddle_quantum.mbqc.utils import zero_state, basis\n\n G = [['1', '2', '3'], [('1', '2'), ('2', '3')]]\n mbqc = MBQC()\n mbqc.set_graph(G)\n state = State(zero_state(), ['1'])\n mbqc.set_input_state(state)\n mbqc.measure('1', basis('X'))\n mbqc.measure('2', basis('X'))\n print(\"Measurement outcomes: \", mbqc.get_classical_output())\n\n ::\n\n Measurement outcomes: {'1': 0, '2': 1}\n \"\"\"\n self.__draw_process(\"measuring\", which_qubit)\n self.__create_graph_state(which_qubit)\n assert which_qubit in self.vertex.active, 'the qubit to be measured must be activated first.'\n\n new_bg_state = permute_to_front(self.__bg_state, which_qubit)\n self.vertex.active = new_bg_state.system\n half_length = int(new_bg_state.length / 2)\n\n eps = 10 ** (-10)\n prob = [0, 0]\n state_unnorm = [0, 0]\n\n # Calculate the probability and post-measurement states\n for result in [0, 1]:\n basis_dagger = t(conj(basis_list[result]))\n # Reshape the state, multiply the basis and reshape it back\n state_unnorm[result] = reshape(matmul(basis_dagger,\n reshape(new_bg_state.vector, [2, half_length])), [half_length, 1])\n probability = matmul(t(conj(state_unnorm[result])), state_unnorm[result])\n is_complex128 = probability.dtype == to_tensor([], dtype='complex128').dtype\n prob[result] = real(probability) if is_complex128 else probability\n\n # Randomly choose a result and its corresponding post-measurement state\n if prob[0].numpy().item() < eps:\n result = 1\n post_state_vector = state_unnorm[1]\n elif prob[1].numpy().item() < eps:\n result = 0\n post_state_vector = state_unnorm[0]\n else: # Take a random choice of outcome\n result = random.choice(2, 1, p=[prob[0].numpy().item(), prob[1].numpy().item()]).item()\n # Normalize the post-measurement state\n post_state_vector = state_unnorm[result] / prob[result].sqrt()\n\n # Write the measurement result into the dict\n self.__outcome.update({which_qubit: int(result)})\n # Update measured, active lists\n self.vertex.measured.append(which_qubit)\n self.max_active = max(len(self.vertex.active), self.max_active)\n self.vertex.active.remove(which_qubit)\n\n # Update the background state and history list\n self.__bg_state = State(post_state_vector, self.vertex.active)\n self.__update()\n\n self.__draw_process(\"measured\", which_qubit)\n\n def sum_outcomes(self, which_qubits, start=0):\n r\"\"\"根据输入的量子系统标签，在存储测量结果的字典中找到对应的测量结果，并进行求和。\n\n Note:\n 在进行副产品纠正操作和定义适应性测量角度时，用户可以调用该方法对特定比特的测量结果求和。\n\n Args:\n which_qubits (list): 需要查找测量结果并求和的比特的系统标签列表\n start (int): 对结果进行求和后需要额外相加的整数\n\n Returns:\n int: 指定比特的测量结果的和\n\n 代码示例：\n\n .. code-block:: python\n\n from paddle_quantum.mbqc.simulator import MBQC\n from paddle_quantum.mbqc.qobject import State\n from paddle_quantum.mbqc.utils import zero_state, basis\n\n G = [['1', '2', '3'], [('1', '2'), ('2', '3')]]\n mbqc = MBQC()\n mbqc.set_graph(G)\n input_state = State(zero_state(), ['1'])\n mbqc.set_input_state(input_state)\n mbqc.measure('1', basis('X'))\n mbqc.measure('2', basis('X'))\n mbqc.measure('3', basis('X'))\n print(\"All measurement outcomes: \", mbqc.get_classical_output())\n print(\"Sum of outcomes of qubits '1' and '2': \", mbqc.sum_outcomes(['1', '2']))\n print(\"Sum of outcomes of qubits '1', '2' and '3' with an extra 1: \", mbqc.sum_outcomes(['1', '2', '3'], 1))\n\n ::\n\n All measurement outcomes: {'1': 0, '2': 0, '3': 1}\n Sum of outcomes of qubits '1' and '2': 0\n Sum of outcomes of qubits '1', '2' and '3' with an extra 1: 2\n \"\"\"\n assert isinstance(start, int), \"'start' must be of type int.\"\n\n return sum([self.__outcome[label] for label in which_qubits], start)\n\n def correct_byproduct(self, gate, which_qubit, power):\n r\"\"\"对测量后的量子态进行副产品纠正。\n\n Note:\n 这是用户在实例化 MBQC 类并完成测量后，经常需要调用的一个方法。\n\n Args:\n gate (str): ``'X'`` 或者 ``'Z'``，分别表示 Pauli X 或 Z 门修正\n which_qubit (any): 待操作的量子比特的系统标签，可以是 ``str``, ``tuple`` 等任意数据类型，但需要和 MBQC 中图的标签类型匹配\n power (int): 副产品纠正算符的指数\n\n 代码示例：\n\n 此处展示的是 MBQC 模型下实现隐形传态的一个例子。\n\n .. code-block:: python\n\n from paddle_quantum.mbqc.simulator import MBQC\n from paddle_quantum.mbqc.qobject import State\n from paddle_quantum.mbqc.utils import random_state_vector, basis, compare_by_vector\n\n G = [['1', '2', '3'], [('1', '2'), ('2', '3')]]\n state = State(random_state_vector(1), ['1'])\n mbqc = MBQC()\n mbqc.set_graph(G)\n mbqc.set_input_state(state)\n mbqc.measure('1', basis('X'))\n mbqc.measure('2', basis('X'))\n outcome = mbqc.get_classical_output()\n mbqc.correct_byproduct('Z', '3', outcome['1'])\n mbqc.correct_byproduct('X', '3', outcome['2'])\n state_out = mbqc.get_quantum_output()\n state_std = State(state.vector, ['3'])\n compare_by_vector(state_out, state_std)\n\n ::\n\n Norm difference of the given states is:\n 0.0\n They are exactly the same states.\n \"\"\"\n assert gate in ['X', 'Z'], \"'gate' must be 'X' or 'Z'.\"\n assert isinstance(power, int), \"'power' must be of type 'int'.\"\n\n if power % 2 == 1:\n self.__apply_pauli_gate(gate, which_qubit)\n self.__update()\n\n def __run_cmd(self, cmd):\n r\"\"\"执行测量或副产品处理命令。\n\n Args:\n cmd (Pattern.CommandM / Pattern.CommandX / Pattern.CommandZ): 测量或副产品处理命令\n \"\"\"\n assert cmd.name in [\"M\", \"X\", \"Z\"], \"the input 'cmd' must be CommandM, CommandX or CommandZ.\"\n if cmd.name == \"M\": # Execute measurement commands\n signal_s = self.sum_outcomes(cmd.domain_s)\n signal_t = self.sum_outcomes(cmd.domain_t)\n # The adaptive angle is (-1)^{signal_s} * angle + {signal_t} * pi\n adaptive_angle = multiply(to_tensor([(-1) ** signal_s], dtype=\"float64\"), cmd.angle) \\\n + to_tensor([signal_t * pi], dtype=\"float64\")\n self.measure(cmd.which_qubit, basis(cmd.plane, adaptive_angle))\n else: # Execute byproduct correction commands\n power = self.sum_outcomes(cmd.domain)\n self.correct_byproduct(cmd.name, cmd.which_qubit, power)\n\n def __run_cmd_lst(self, cmd_lst, bar_start, bar_end):\n r\"\"\"对列表执行测量或副产品处理命令。\n\n Args:\n cmd_lst (list): 命令列表，包含测量或副产品处理命令\n bar_start (int): 进度条的开始点\n bar_end (int): 进度条的结束点\n \"\"\"\n for i in range(len(cmd_lst)):\n cmd = cmd_lst[i]\n self.__run_cmd(cmd)\n print_progress((bar_start + i + 1) / bar_end, \"Pattern Running Progress\", self.__track)\n\n def __kron_unmeasured_qubits(self):\n r\"\"\"该方法将没有被作用 CZ 纠缠的节点初始化为 |+> 态，并与当前的量子态做张量积。\n\n Warning:\n 该方法仅在用户输入测量模式时调用，当用户输入图时，如果节点没有被激活，我们默认用户没有对该节点进行任何操作。\n \"\"\"\n # Turn off the plot switch\n self.__draw = False\n # As the create_graph_state function would change the measured qubits list, we need to record it\n measured_qubits = self.vertex.measured[:]\n\n for qubit in list(self.__graph.nodes):\n if qubit not in self.vertex.measured:\n self.__create_graph_state(qubit)\n # Update vertices and backgrounds\n self.vertex.measured.append(qubit)\n self.max_active = max(len(self.vertex.active), self.max_active)\n self.__bg_state = State(self.__bg_state.vector, self.vertex.active)\n\n # Restore the measured qubits\n self.vertex.measured = measured_qubits\n\n def run_pattern(self):\n r\"\"\"按照设置的测量模式对 MBQC 模型进行模拟。\n\n Warning:\n 该方法必须在 ``set_pattern`` 调用后调用。\n \"\"\"\n assert self.__pattern is not None, \"please use this method after calling 'set_pattern'!\"\n\n # Execute measurement commands and correction commands\n cmd_m_lst = [cmd for cmd in self.__pattern.commands if cmd.name == \"M\"]\n cmd_c_lst = [cmd for cmd in self.__pattern.commands if cmd.name in [\"X\", \"Z\"]]\n bar_end = len(cmd_m_lst + cmd_c_lst)\n\n self.__run_cmd_lst(cmd_m_lst, 0, bar_end)\n # Activate unmeasured qubits before byproduct corrections\n self.__kron_unmeasured_qubits()\n self.__run_cmd_lst(cmd_c_lst, len(cmd_m_lst), bar_end)\n\n # The output state's label is messy (e.g. [(2, 0), (0, 1), (1, 3)...]),\n # so we permute the systems in order\n q_output = self.__pattern.output_[1]\n self.__bg_state = permute_systems(self.__status, q_output)\n self.__update()\n\n @staticmethod\n def __map_qubit_to_row(out_lst):\n r\"\"\"将输出比特的标签与行数对应起来，便于查找其对应关系。\n\n Returns:\n dict: 返回字典，代表行数与标签的对应关系\n \"\"\"\n return {int(div_str_to_float(qubit[0])): qubit for qubit in out_lst}\n\n def get_classical_output(self):\n r\"\"\"获取 MBQC 模型运行后的经典输出结果。\n\n Returns:\n str or dict: 如果用户输入是测量模式，则返回测量输出节点得到的比特串，与原电路的测量结果相一致，没有被测量的比特位填充 \"？\"，如果用户输入是图，则返回所有节点的测量结果\n \"\"\"\n # If the input is pattern, return the equivalent result as the circuit model\n if self.__pattern is not None:\n width = len(self.__pattern.input_)\n c_output = self.__pattern.output_[0]\n q_output = self.__pattern.output_[1]\n # Acquire the relationship between row number and corresponding output qubit label\n output_lst = c_output + q_output\n row_and_qubit = self.__map_qubit_to_row(output_lst)\n\n # Obtain the string, with classical outputs denoted as their measurement outcomes\n # and quantum outputs denoted as \"?\"\n bit_str = [str(self.__outcome[row_and_qubit[i]])\n if row_and_qubit[i] in c_output else '?'\n for i in range(width)]\n string = \"\".join(bit_str)\n return string\n\n # If the input is graph, return the outcome dictionary\n else:\n return self.__outcome\n\n def get_history(self):\n r\"\"\"获取 MBQC 计算模拟时的中间步骤信息。\n\n Returns:\n list: 生成图态、进行测量、纠正副产品后运算结果构成的列表\n \"\"\"\n return self.__history\n\n def get_quantum_output(self):\n r\"\"\"获取 MBQC 模型运行后的量子态输出结果。\n\n Returns:\n State: MBQC 模型运行后的量子态\n \"\"\"\n return self.__status\n\n\ndef simulate_by_mbqc(circuit, input_state=None):\n r\"\"\"使用等价的 MBQC 模型模拟量子电路。\n\n 该函数通过将量子电路转化为等价的 MBQC 模型并运行，从而获得等价于原始量子电路的输出结果。\n\n Warning:\n 与 ``UAnsatz`` 不同，此处输入的 ``circuit`` 参数包含了测量操作。\n 另，MBQC 模型默认初始态为加态，因此，如果用户不输入参数 ``input_state`` 设置初始量子态，则默认为加态。\n\n Args:\n circuit (Circuit): 量子电路图\n input_state (State, optional): 量子电路的初始量子态，默认为 :math:`|+\\rangle` 态\n\n Returns:\n tuple: 包含如下两个元素:\n\n - str: 经典输出\n - State: 量子输出\n \"\"\"\n if input_state is not None:\n assert isinstance(input_state, State), \"the 'input_state' must be of type 'State'.\"\n\n pattern = transpile(circuit)\n mbqc = MBQC()\n mbqc.set_pattern(pattern)\n mbqc.set_input_state(input_state)\n mbqc.run_pattern()\n c_output = mbqc.get_classical_output()\n q_output = mbqc.get_quantum_output()\n\n # Return the classical and quantum outputs\n return c_output, q_output\n\n\ndef __get_sample_dict(bit_num, mea_bits, samples):\n r\"\"\"根据比特数和测量比特索引的列表，统计采样结果。\n\n Args:\n bit_num (int): 比特数\n mea_bits (list): 测量的比特列表\n samples (list): 采样结果\n\n Returns:\n dict: 统计得到的采样结果\n \"\"\"\n sample_dict = {}\n for i in range(2 ** len(mea_bits)):\n str_of_order = bin(i)[2:].zfill(len(mea_bits))\n bit_str = []\n idx = 0\n for j in range(bit_num):\n if j in mea_bits:\n bit_str.append(str_of_order[idx])\n idx += 1\n else:\n bit_str.append('?')\n string = \"\".join(bit_str)\n sample_dict[string] = 0\n\n # Count sampling results\n for string in list(set(samples)):\n sample_dict[string] += samples.count(string)\n return sample_dict\n\n\ndef sample_by_mbqc(circuit, input_state=None, plot=False, shots=1024, print_or_not=True):\n r\"\"\"将 MBQC 模型重复运行多次，获得经典结果的统计分布。\n \n Warning:\n 与 ``UAnsatz`` 不同，此处输入的 circuit 参数包含了测量操作。\n 另，MBQC 模型默认初始态为加态，因此，如果用户不输入参数 `input_state` 设置初始量子态，则默认为加态。\n\n Args:\n circuit (Circuit): 量子电路图\n input_state (State, optional): 量子电路的初始量子态，默认为加态\n plot (bool, optional): 绘制经典采样结果的柱状图开关，默认为关闭状态\n shots (int, optional): 采样次数，默认为 1024 次\n print_or_not (bool, optional): 是否打印采样结果和绘制采样进度，默认为开启状态\n\n Returns:\n dict: 经典结果构成的频率字典\n list: 经典测量结果和所有采样结果（包括经典输出和量子输出）的列表\n \"\"\"\n # Initialize\n if shots == 1:\n print_or_not = False\n if print_or_not:\n print(\"Sampling \" + str(shots) + \" times.\" + \"\\nWill return the sampling results.\\r\\n\")\n width = circuit.get_width()\n mea_bits = circuit.get_measured_qubits()\n\n # Sampling for \"shots\" times\n samples = []\n all_outputs = []\n for shot in range(shots):\n if print_or_not:\n print_progress((shot + 1) / shots, \"Current Sampling Progress\")\n c_output, q_output = simulate_by_mbqc(circuit, input_state)\n samples.append(c_output)\n all_outputs.append([c_output, q_output])\n\n sample_dict = __get_sample_dict(width, mea_bits, samples)\n if print_or_not:\n print(\"Sample count \" + \"(\" + str(shots) + \" shots)\" + \" : \" + str(sample_dict))\n if plot:\n dict_lst = [sample_dict]\n bar_labels = [\"MBQC sample outcomes\"]\n title = 'Sampling results (MBQC)'\n xlabel = \"Measurement outcomes\"\n ylabel = \"Distribution\"\n plot_results(dict_lst, bar_labels, title, xlabel, ylabel)\n\n return sample_dict, all_outputs\n", "meta": {"hexsha": "1e6d859304913033979a2008147b061e6e640c87", "size": 30925, "ext": "py", "lang": "Python", "max_stars_repo_path": "paddle_quantum/mbqc/simulator.py", "max_stars_repo_name": "gsq7474741/Quantum", "max_stars_repo_head_hexsha": "16e7d3bf2dba7e94e6faf5c853faf0e913e1f268", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-07-14T14:10:23.000Z", "max_stars_repo_stars_event_max_datetime": "2020-07-14T14:10:23.000Z", "max_issues_repo_path": "paddle_quantum/mbqc/simulator.py", "max_issues_repo_name": "gsq7474741/Quantum", "max_issues_repo_head_hexsha": "16e7d3bf2dba7e94e6faf5c853faf0e913e1f268", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "paddle_quantum/mbqc/simulator.py", "max_forks_repo_name": "gsq7474741/Quantum", "max_forks_repo_head_hexsha": "16e7d3bf2dba7e94e6faf5c853faf0e913e1f268", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.1790123457, "max_line_length": 120, "alphanum_fraction": 0.5990622474, "include": true, "reason": "from numpy,from networkx", "num_tokens": 8977, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6150878414043816, "lm_q2_score": 0.3140505385717077, "lm_q1q2_score": 0.19316866786195516}} {"text": "'''\nDescription: 查看生成的矩形\nAuthor: Lirenjie\nDate: 2021-12-21 21:22:08\nLastEditors: Lirenjie\nLastEditTime: 2021-12-22 15:55:23\n'''\nimport cv2\nimport numpy as np\nfrom numpy.linalg import norm\nimport sys\nimport os\nimport json\n\nimport turtle as t\nimport time\n\nimg = cv2.imread(\"C:\\\\Users\\\\lirenjie\\\\Desktop\\\\cAA662F.jpg\")\noldimg = cv2.GaussianBlur(img, (3, 3), 0) # 图片分辨率调整\npic_hight, pic_width = (576, 704)\n\n\nbox = [[114, 295], [115, 259], [208, 262], [207, 298]]\n\nt.penup()\nt.goto(box[0])\n\nt.pendown()\nt.goto(box[1])\nt.goto(box[2])\nt.goto(box[3])\nt.goto(box[0])\n\nt.down()\n# time.sleep(3)\n\n\nheigth_point = right_point = [0, 0]\nleft_point = low_point = [1000, 1000]\nfor point in box:\n if left_point[0] > point[0]:\n left_point = point\n if low_point[1] > point[1]:\n low_point = point\n if heigth_point[1] < point[1]:\n heigth_point = point\n if right_point[0] < point[0]:\n right_point = point\n\n# 比较得到长边的斜率\nlength1 = (left_point[0] - low_point[0]) ** 2 + (left_point[1] - low_point[1]) ** 2\nlength2 = (right_point[0] - low_point[0]) ** 2 + (right_point[1] - low_point[1]) ** 2\nif length1 > length2:\n k = (left_point[1] - low_point[1]) / (left_point[0] - low_point[0])\nelse:\n k = (right_point[1] - low_point[1]) / (right_point[0] - low_point[0])\nprint('k', k)\n\nif k < 0: # 正角度\n new_right_point = [right_point[0], heigth_point[1]]\n pts2 = np.float32([left_point, heigth_point, new_right_point]) # 字符只是高度需要改变\n pts1 = np.float32([left_point, heigth_point, right_point])\n M = cv2.getAffineTransform(pts1, pts2) # 仿射变换\n dst = cv2.warpAffine(oldimg, M, (pic_width, pic_hight))\n cv2.imshow(\"card\", dst)\n cv2.waitKey(0)\n cv2.destroyAllWindows()\n # dst = cv2.warpAffine(oldimg, M, (pic_width, pic_hight))\n # cv2.imshow(\"card\", dst)\n # cv2.waitKey(0)\n # cv2.destroyAllWindows()\n\n # point_limit(new_right_point)\n # point_limit(heigth_point)\n # point_limit(left_point)\n # card_img = dst[\n # int(left_point[1]) : int(heigth_point[1]),\n # int(left_point[0]) : int(new_right_point[0]),\n # ]\n\n # print(card_img)\n\n # card_imgs.append(card_img)\n # cv2.imshow(\"card\", card_img)\n # cv2.waitKey(0)\n # cv2.destroyAllWindows()\nelif k > 0: # 负角度\n new_left_point = [left_point[0], heigth_point[1]]\n pts2 = np.float32([new_left_point, heigth_point, right_point]) # 字符只是高度需要改变\n pts1 = np.float32([left_point, heigth_point, right_point])\n M = cv2.getAffineTransform(pts1, pts2)\n dst = cv2.warpAffine(oldimg, M, (pic_width, pic_hight))\n cv2.imshow(\"card\", dst)\n cv2.waitKey(0)\n cv2.destroyAllWindows()\n # dst = cv2.warpAffine(oldimg, M, (pic_width, pic_hight))\n # cv2.imshow(\"card\", dst)\n # cv2.waitKey(0)\n # cv2.destroyAllWindows()\n\n # point_limit(right_point)\n # point_limit(heigth_point)\n # point_limit(new_left_point)\n # card_img = dst[\n # int(right_point[1]) : int(heigth_point[1]),\n # int(new_left_point[0]) : int(right_point[0]),\n # ]\n\n # print(card_img)\n\n # card_imgs.append(card_img)\n # cv2.imshow(\"card\", card_img)\n # cv2.waitKey(0)\n # cv2.destroyAllWindows()\n\nprint(M)\n", "meta": {"hexsha": "a0dff3229ab0c14cc030d2377dcf91295b07478b", "size": 3150, "ext": "py", "lang": "Python", "max_stars_repo_path": "vehicle-license-plate-recognition/test1.py", "max_stars_repo_name": "xin9421/vehicle-license-plate-recognition", "max_stars_repo_head_hexsha": "e8d7312c65f3e9d6bd4f571a116ee659d4651d58", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "vehicle-license-plate-recognition/test1.py", "max_issues_repo_name": "xin9421/vehicle-license-plate-recognition", "max_issues_repo_head_hexsha": "e8d7312c65f3e9d6bd4f571a116ee659d4651d58", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "vehicle-license-plate-recognition/test1.py", "max_forks_repo_name": "xin9421/vehicle-license-plate-recognition", "max_forks_repo_head_hexsha": "e8d7312c65f3e9d6bd4f571a116ee659d4651d58", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.9230769231, "max_line_length": 85, "alphanum_fraction": 0.6425396825, "include": true, "reason": "import numpy,from numpy", "num_tokens": 1088, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5428632831725052, "lm_q2_score": 0.35577490717496246, "lm_q1q2_score": 0.1931371341793934}} {"text": "from typing import Callable, NamedTuple, Tuple\n\nimport jax\nimport jax.numpy as jnp\n\nfrom blackjax.types import PyTree\n\n\nclass SMCInfo(NamedTuple):\n \"\"\"Additional information on the tempered SMC step.\n\n weights: jnp.ndarray\n The weights after the MCMC pass.\n proposals: PyTree\n The particles that were proposed by the MCMC pass.\n ancestors: jnp.ndarray\n The index of the particles proposed by the MCMC pass that were selected\n by the resampling step.\n log_likelihood_increment: float\n The log-likelihood increment due to the current step of the SMC algorithm.\n \"\"\"\n\n weights: jnp.ndarray\n proposals: PyTree\n ancestors: jnp.ndarray\n log_likelihood_increment: float\n\n\ndef kernel(\n mcmc_kernel_factory: Callable,\n mcmc_state_generator: Callable,\n resampling_fn: Callable,\n num_mcmc_iterations: int,\n):\n \"\"\"Build a generic SMC kernel.\n\n In Feynman-Kac equivalent terms, the algo goes roughly as follows:\n\n ```\n M_t = mcmc_kernel_factory(potential_fn)\n for i in range(num_mcmc_iterations):\n x_t^i = M_t(..., x_t^i)\n G_t = log_weights_fn\n log_weights = G_t(x_t)\n idx = resample(log_weights)\n x_t = x_t[idx]\n ```\n\n\n Parameters\n ----------\n mcmc_kernel_factory: Callable\n A function of the Markov potential that returns a mcmc_kernel.\n mcmc_state_generator: Callable\n A function that creates a new mcmc state from a position and a potential.\n resampling_fn: Callable\n A function that resamples the particles generated by the MCMC kernel,\n based of previously computed weights.\n num_mcmc_iterations: int\n Number of iterations of the MCMC kernel\n\n Returns\n -------\n A kernel that takes a PRNGKey, a set of particles, the log-likehood of the\n distribution and the Feynman-Kac potential at time `t`. The kernel returns\n a new set of particles.\n\n \"\"\"\n\n def one_step(\n rng_key: jnp.ndarray,\n particles: PyTree,\n logprob_fn: Callable,\n log_weight_fn: Callable,\n ) -> Tuple[PyTree, SMCInfo]:\n \"\"\"\n\n Parameters\n ----------\n rng_key: DeviceArray[int],\n JAX PRNGKey for randomness.\n particles: PyTree\n Current particles sample of the SMC algorithm.\n logprob_fn: Callable\n Log probability function we wish to sample from.\n log_weight_fn: Callable\n A function that represents the Feynman-Kac log potential at time t.\n\n Returns\n -------\n particles: PyTree,\n The updated set of particles.\n info: SMCInfo,\n Additional information on the SMC step\n \"\"\"\n\n num_particles = jax.tree_flatten(particles)[0][0].shape[0]\n scan_key, resampling_key = jax.random.split(rng_key, 2)\n\n # First advance the particles using the MCMC kernel\n mcmc_kernel = mcmc_kernel_factory(logprob_fn)\n\n def mcmc_body_fn(curr_particles, curr_key):\n keys = jax.random.split(curr_key, num_particles)\n new_particles, _ = jax.vmap(mcmc_kernel, in_axes=(0, 0))(\n keys, curr_particles\n )\n return new_particles, None\n\n mcmc_state = jax.vmap(mcmc_state_generator, in_axes=(0, None))(\n particles, logprob_fn\n )\n keys = jax.random.split(scan_key, num_mcmc_iterations)\n proposed_states, _ = jax.lax.scan(mcmc_body_fn, mcmc_state, keys)\n proposed_particles = proposed_states.position\n\n # Resample the particles depending on their respective weights\n log_weights = jax.vmap(log_weight_fn, in_axes=(0,))(proposed_particles)\n weights, log_likelihood_increment = _normalize(log_weights)\n resampling_index = resampling_fn(weights, resampling_key)\n particles = jax.tree_map(lambda x: x[resampling_index], proposed_particles)\n\n info = SMCInfo(\n weights, proposed_particles, resampling_index, log_likelihood_increment\n )\n return particles, info\n\n return one_step\n\n\ndef _normalize(log_weights):\n \"\"\"Normalize log-weights into weights and return resulting weights and log-likelihood increment.\"\"\"\n n = log_weights.shape[0]\n max_logw = jnp.max(log_weights)\n w = jnp.exp(log_weights - max_logw)\n w_mean = w.mean()\n\n log_likelihood_increment = jnp.log(w_mean) + max_logw\n\n w = w / (n * w_mean)\n return w, log_likelihood_increment\n", "meta": {"hexsha": "9db15809ca73423244d8d4e36419d330fa3fffd2", "size": 4479, "ext": "py", "lang": "Python", "max_stars_repo_path": "blackjax/smc/base.py", "max_stars_repo_name": "rlouf/blackjax", "max_stars_repo_head_hexsha": "07c345a2977ef81fc0f6d2231464bc14e0815b2f", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-02-23T20:32:31.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-23T20:32:31.000Z", "max_issues_repo_path": "blackjax/smc/base.py", "max_issues_repo_name": "rlouf/blackjax", "max_issues_repo_head_hexsha": "07c345a2977ef81fc0f6d2231464bc14e0815b2f", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "blackjax/smc/base.py", "max_forks_repo_name": "rlouf/blackjax", "max_forks_repo_head_hexsha": "07c345a2977ef81fc0f6d2231464bc14e0815b2f", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.5422535211, "max_line_length": 103, "alphanum_fraction": 0.6588524224, "include": true, "reason": "import jax", "num_tokens": 1039, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.542863297964157, "lm_q2_score": 0.3557748935136303, "lm_q1q2_score": 0.1931371320256561}} {"text": "\"\"\"\nNotes\n-----\n\nImportant attributes of continuous (order > 0) :class:`Field` and\n:class:`SurfaceField` instances:\n\n- `vertex_remap` : `econn[:, :n_vertex] = vertex_remap[conn]`\n- `vertex_remap_i` : `conn = vertex_remap_i[econn[:, :n_vertex]]`\n\nwhere `conn` is the mesh vertex connectivity, `econn` is the\nregion-local field connectivity.\n\"\"\"\nimport numpy as nm\n\nfrom sfepy.base.base import output, get_default, assert_\nfrom sfepy.base.base import Struct\nimport fea\nfrom sfepy.discrete.common.fields import parse_shape, Field\nfrom sfepy.discrete.fem.mesh import Mesh\nfrom sfepy.discrete.fem.meshio import convert_complex_output\nfrom sfepy.discrete.fem.utils import (extend_cell_data, prepare_remap,\n invert_remap, get_min_value)\nfrom sfepy.discrete.fem.fe_surface import FESurface\nfrom sfepy.discrete.integrals import Integral\nfrom sfepy.discrete.fem.linearizer import (get_eval_dofs, get_eval_coors,\n create_output)\n\ndef get_eval_expression(expression, ig,\n fields, materials, variables,\n functions=None, mode='eval', term_mode=None,\n extra_args=None, verbose=True, kwargs=None):\n \"\"\"\n Get the function for evaluating an expression given a list of elements,\n and reference element coordinates.\n \"\"\"\n from sfepy.discrete.evaluate import eval_in_els_and_qp\n\n def _eval(iels, coors):\n val = eval_in_els_and_qp(expression, ig, iels, coors,\n fields, materials, variables,\n functions=functions, mode=mode,\n term_mode=term_mode,\n extra_args=extra_args, verbose=verbose,\n kwargs=kwargs)\n return val[..., 0]\n\n return _eval\n\ndef create_expression_output(expression, name, primary_field_name,\n fields, materials, variables,\n functions=None, mode='eval', term_mode=None,\n extra_args=None, verbose=True, kwargs=None,\n min_level=0, max_level=1, eps=1e-4):\n \"\"\"\n Create output mesh and data for the expression using the adaptive\n linearizer.\n\n Parameters\n ----------\n expression : str\n The expression to evaluate.\n name : str\n The name of the data.\n primary_field_name : str\n The name of field that defines the element groups and polynomial\n spaces.\n fields : dict\n The dictionary of fields used in `variables`.\n materials : Materials instance\n The materials used in the expression.\n variables : Variables instance\n The variables used in the expression.\n functions : Functions instance, optional\n The user functions for materials etc.\n mode : one of 'eval', 'el_avg', 'qp'\n The evaluation mode - 'qp' requests the values in quadrature points,\n 'el_avg' element averages and 'eval' means integration over\n each term region.\n term_mode : str\n The term call mode - some terms support different call modes\n and depending on the call mode different values are\n returned.\n extra_args : dict, optional\n Extra arguments to be passed to terms in the expression.\n verbose : bool\n If False, reduce verbosity.\n kwargs : dict, optional\n The variables (dictionary of (variable name) : (Variable\n instance)) to be used in the expression.\n min_level : int\n The minimum required level of mesh refinement.\n max_level : int\n The maximum level of mesh refinement.\n eps : float\n The relative tolerance parameter of mesh adaptivity.\n\n Returns\n -------\n out : dict\n The output dictionary.\n \"\"\"\n field = fields[primary_field_name]\n vertex_coors = field.coors[:field.n_vertex_dof, :]\n\n coors = []\n vdofs = []\n conns = []\n mat_ids = []\n levels = []\n offset = 0\n for ig, ap in field.aps.iteritems():\n ps = ap.interp.poly_spaces['v']\n gps = ap.interp.gel.interp.poly_spaces['v']\n group = field.domain.groups[ig]\n vertex_conn = ap.econn[:, :group.shape.n_ep]\n\n eval_dofs = get_eval_expression(expression, ig,\n fields, materials, variables,\n functions=functions,\n mode=mode, extra_args=extra_args,\n verbose=verbose, kwargs=kwargs)\n eval_coors = get_eval_coors(vertex_coors, vertex_conn, gps)\n\n (level, _coors, conn,\n _vdofs, _mat_ids) = create_output(eval_dofs, eval_coors,\n group.shape.n_el, ps,\n min_level=min_level,\n max_level=max_level, eps=eps)\n\n _mat_ids[:] = field.domain.mesh.mat_ids[ig][0]\n\n coors.append(_coors)\n vdofs.append(_vdofs)\n conns.append(conn + offset)\n mat_ids.append(_mat_ids)\n levels.append(level)\n\n offset += _coors.shape[0]\n\n coors = nm.concatenate(coors, axis=0)\n vdofs = nm.concatenate(vdofs, axis=0)\n mesh = Mesh.from_data('linearized_mesh', coors, None, conns, mat_ids,\n field.domain.mesh.descs)\n\n out = {}\n out[name] = Struct(name='output_data', mode='vertex',\n data=vdofs, var_name=name, dofs=None,\n mesh=mesh, levels=levels)\n\n out = convert_complex_output(out)\n\n return out\n\nclass FEField(Field):\n \"\"\"\n Base class for finite element fields.\n\n Notes\n -----\n - Region can span over several groups -> different Aproximation\n instances\n - interps and hence node_descs are per region (must have single\n geometry!)\n - no two interps can be in a same group -> no two aps (with\n different regions) can be in a same group -> aps can be uniquely\n indexed with ig\n\n Field shape information:\n\n - ``shape`` - the shape of the base functions in a point\n - ``n_components`` - the number of DOFs per FE node\n - ``val_shape`` - the shape of field value (the product of DOFs and\n base functions) in a point\n \"\"\"\n\n def __init__(self, name, dtype, shape, region, approx_order=1):\n \"\"\"\n Create a finite element field.\n\n Parameters\n ----------\n name : str\n The field name.\n dtype : numpy.dtype\n The field data type: float64 or complex128.\n shape : int/tuple/str\n The field shape: 1 or (1,) or 'scalar', space dimension (2, or (2,)\n or 3 or (3,)) or 'vector', or a tuple. The field shape determines\n the shape of the FE base functions and is related to the number of\n components of variables and to the DOF per node count, depending\n on the field kind.\n region : Region\n The region where the field is defined.\n approx_order : int or tuple\n The FE approximation order. The tuple form is (order, has_bubble),\n e.g. (1, True) means order 1 with a bubble function.\n\n Notes\n -----\n Assumes one cell type for the whole region!\n \"\"\"\n shape = parse_shape(shape, region.domain.shape.dim)\n if not self._check_region(region):\n raise ValueError('unsuitable region for field %s! (%s)' %\n (name, region.name))\n\n Struct.__init__(self, name=name, dtype=dtype, shape=shape,\n region=region)\n self.domain = self.region.domain\n self.igs = self.region.igs\n\n self._set_approx_order(approx_order)\n self._setup_geometry()\n self._setup_kind()\n self._setup_shape()\n\n self._create_interpolant()\n self._setup_approximations()\n self._setup_global_base()\n self.setup_coors()\n self.clear_mappings(clear_all=True)\n\n def _set_approx_order(self, approx_order):\n \"\"\"\n Set a uniform approximation order.\n \"\"\"\n if isinstance(approx_order, tuple):\n self.approx_order = approx_order[0]\n self.force_bubble = approx_order[1]\n\n else:\n self.approx_order = approx_order\n self.force_bubble = False\n\n def _create_interpolant(self):\n name = '%s_%s_%s_%d%s' % (self.gel.name, self.space,\n self.poly_space_base, self.approx_order,\n 'B' * self.force_bubble)\n self.interp = fea.Interpolant(name, self.gel, self.space,\n self.poly_space_base, self.approx_order,\n self.force_bubble)\n\n def _setup_approximations(self):\n self.aps = {}\n self.aps_by_name = {}\n for ig in self.igs:\n name = self.interp.name + '_%s_ig%d' % (self.region.name, ig)\n ap = fea.Approximation(name, self.interp, self.region, ig)\n self.aps[ig] = ap\n self.aps_by_name[ap.name] = ap\n\n def get_true_order(self):\n \"\"\"\n Get the true approximation order depending on the reference\n element geometry.\n\n For example, for P1 (linear) approximation the true order is 1,\n while for Q1 (bilinear) approximation in 2D the true order is 2.\n \"\"\"\n gel = self.gel\n if (gel.dim + 1) == gel.n_vertex:\n order = self.approx_order\n\n else:\n order = gel.dim * self.approx_order\n\n if self.force_bubble:\n bubble_order = gel.dim + 1\n order = max(order, bubble_order)\n\n return order\n\n def is_higher_order(self):\n \"\"\"\n Return True, if the field's approximation order is greater than one.\n \"\"\"\n return self.force_bubble or (self.approx_order > 1)\n\n def _setup_global_base(self):\n \"\"\"\n Setup global DOF/base functions, their indices and connectivity of the\n field. Called methods implemented in subclasses.\n \"\"\"\n self._setup_facet_orientations()\n\n self._init_econn()\n\n self.n_vertex_dof, self.vertex_remap = self._setup_vertex_dofs()\n self.vertex_remap_i = invert_remap(self.vertex_remap)\n\n aux = self._setup_edge_dofs()\n self.n_edge_dof, self.edge_dofs, self.edge_remap = aux\n\n aux = self._setup_face_dofs()\n self.n_face_dof, self.face_dofs, self.face_remap = aux\n\n aux = self._setup_bubble_dofs()\n self.n_bubble_dof, self.bubble_dofs, self.bubble_remaps = aux\n\n self.n_nod = self.n_vertex_dof + self.n_edge_dof \\\n + self.n_face_dof + self.n_bubble_dof\n\n self._setup_esurface()\n\n def _setup_esurface(self):\n \"\"\"\n Setup extended surface entities (edges in 2D, faces in 3D),\n i.e. indices of surface entities into the extended connectivity.\n \"\"\"\n node_desc = self.node_desc\n\n for ig, ap in self.aps.iteritems():\n gel = ap.interp.gel\n ap.efaces = gel.get_surface_entities().copy()\n\n nd = node_desc.edge\n if nd is not None:\n efs = []\n for eof in gel.get_edges_per_face():\n efs.append(nm.concatenate([nd[ie] for ie in eof]))\n efs = nm.array(efs).squeeze()\n\n if efs.ndim < 2:\n efs = efs[:,nm.newaxis]\n ap.efaces = nm.hstack((ap.efaces, efs))\n\n efs = node_desc.face\n if efs is not None:\n efs = nm.array(efs).squeeze()\n\n if efs.ndim < 2:\n efs = efs[:,nm.newaxis]\n ap.efaces = nm.hstack((ap.efaces, efs))\n\n def setup_coors(self, coors=None):\n \"\"\"\n Setup coordinates of field nodes.\n \"\"\"\n mesh = self.domain.mesh\n self.coors = nm.empty((self.n_nod, mesh.dim), nm.float64)\n\n if coors is None:\n coors = mesh.coors\n\n # Mesh vertex nodes.\n if self.n_vertex_dof:\n indx = self.vertex_remap_i\n self.coors[:self.n_vertex_dof] = nm.take(coors,\n indx.astype(nm.int32),\n axis=0)\n\n for ig, ap in self.aps.iteritems():\n ap.eval_extra_coor(self.coors, coors)\n\n def get_vertices(self):\n \"\"\"\n Return indices of vertices belonging to the field region.\n \"\"\"\n return self.vertex_remap_i\n\n def _get_facet_dofs(self, get_facets, remap, dofs, ig):\n gfacets = get_facets(ig)\n facets = remap[gfacets]\n\n return dofs[facets[facets >= 0]].ravel()\n\n def get_data_shape(self, ig, integral,\n integration='volume', region_name=None):\n \"\"\"\n Get element data dimensions.\n\n Parameters\n ----------\n ig : int\n The element group index.\n integral : Integral instance\n The integral describing used numerical quadrature.\n integration : 'volume', 'plate', 'surface', 'surface_extra' or 'point'\n The term integration type.\n region_name : str\n The name of surface region, required when `shape_kind` is\n 'surface'.\n\n Returns\n -------\n data_shape : 4 ints\n The `(n_el, n_qp, dim, n_en)` for volume shape kind,\n `(n_fa, n_qp, dim, n_fn)` for surface shape kind and\n `(n_nod, 0, 0, 1)` for point shape kind.\n\n Notes\n -----\n - `n_el`, `n_fa` = number of elements/facets\n - `n_qp` = number of quadrature points per element/facet\n - `dim` = spatial dimension\n - `n_en`, `n_fn` = number of element/facet nodes\n - `n_nod` = number of element nodes\n \"\"\"\n ap = self.aps[ig]\n\n region = self.domain.regions[region_name]\n shape = region.shape[ig]\n dim = region.dim\n\n if integration in ('surface', 'surface_extra'):\n sd = ap.surface_data[region_name]\n\n # This works also for surface fields.\n key = sd.face_type\n weights = ap.get_qp(key, integral).weights\n n_qp = weights.shape[0]\n\n if integration == 'surface':\n data_shape = (sd.n_fa, n_qp, dim, ap.n_ep[key])\n\n else:\n data_shape = (sd.n_fa, n_qp, dim, ap.n_ep['v'])\n\n elif integration in ('volume', 'plate'):\n _, weights = integral.get_qp(self.gel.name)\n n_qp = weights.shape[0]\n\n data_shape = (shape.n_cell, n_qp, dim, ap.n_ep['v'])\n\n elif integration == 'point':\n dofs = self.get_dofs_in_region(region, merge=True)\n data_shape = (dofs.shape[0], 0, 0, 1)\n\n else:\n raise NotImplementedError('unsupported integration! (%s)'\n % integration)\n\n return data_shape\n\n def get_dofs_in_region_group(self, region, ig, merge=True):\n \"\"\"\n Return indices of DOFs that belong to the given region and group.\n \"\"\"\n node_desc = self.node_desc\n\n dofs = []\n\n vdofs = nm.empty((0,), dtype=nm.int32)\n if node_desc.vertex is not None:\n ii = region.get_vertices(ig)\n vdofs = self.vertex_remap[ii]\n vdofs = vdofs[vdofs >= 0]\n dofs.append(vdofs)\n\n edofs = nm.empty((0,), dtype=nm.int32)\n if node_desc.edge is not None:\n edofs = self._get_facet_dofs(region.get_edges,\n self.edge_remap,\n self.edge_dofs, ig)\n dofs.append(edofs)\n\n fdofs = nm.empty((0,), dtype=nm.int32)\n if node_desc.face is not None:\n fdofs = self._get_facet_dofs(region.get_faces,\n self.face_remap,\n self.face_dofs, ig)\n dofs.append(fdofs)\n\n bdofs = nm.empty((0,), dtype=nm.int32)\n if (node_desc.bubble is not None) and region.has_cells():\n ii = region.get_cells(ig)\n group_els = self.bubble_remaps[ig][ii]\n bdofs = self.bubble_dofs[ig][group_els[group_els >= 0]].ravel()\n dofs.append(bdofs)\n\n if merge:\n dofs = nm.concatenate(dofs)\n\n return dofs\n\n def extend_dofs(self, dofs, fill_value=None):\n \"\"\"\n Extend DOFs to the whole domain using the `fill_value`, or the\n smallest value in `dofs` if `fill_value` is None.\n \"\"\"\n if fill_value is None:\n if nm.isrealobj(dofs):\n fill_value = get_min_value(dofs)\n\n else:\n # Complex values - treat real and imaginary parts separately.\n fill_value = get_min_value(dofs.real)\n fill_value += 1j * get_min_value(dofs.imag)\n\n if self.approx_order != 0:\n indx = self.get_vertices()\n\n n_nod = self.domain.shape.n_nod\n new_dofs = nm.empty((n_nod, dofs.shape[1]), dtype=self.dtype)\n new_dofs.fill(fill_value)\n new_dofs[indx] = dofs[:indx.size]\n\n else:\n new_dofs = extend_cell_data(dofs, self.domain, self.region,\n val=fill_value)\n\n return new_dofs\n\n def remove_extra_dofs(self, dofs):\n \"\"\"\n Remove DOFs defined in higher order nodes (order > 1).\n \"\"\"\n if self.approx_order != 0:\n new_dofs = dofs[:self.n_vertex_dof]\n\n else:\n new_dofs = dofs\n\n return new_dofs\n\n def linearize(self, dofs, min_level=0, max_level=1, eps=1e-4):\n \"\"\"\n Linearize the solution for post-processing.\n\n Parameters\n ----------\n dofs : array, shape (n_nod, n_component)\n The array of DOFs reshaped so that each column corresponds\n to one component.\n min_level : int\n The minimum required level of mesh refinement.\n max_level : int\n The maximum level of mesh refinement.\n eps : float\n The relative tolerance parameter of mesh adaptivity.\n\n Returns\n -------\n mesh : Mesh instance\n The adapted, nonconforming, mesh.\n vdofs : array\n The DOFs defined in vertices of `mesh`.\n levels : array of ints\n The refinement level used for each element group.\n \"\"\"\n assert_(dofs.ndim == 2)\n\n n_nod, dpn = dofs.shape\n\n assert_(n_nod == self.n_nod)\n assert_(dpn == self.shape[0])\n\n vertex_coors = self.coors[:self.n_vertex_dof, :]\n\n coors = []\n vdofs = []\n conns = []\n mat_ids = []\n levels = []\n offset = 0\n for ig, ap in self.aps.iteritems():\n ps = ap.interp.poly_spaces['v']\n gps = ap.interp.gel.interp.poly_spaces['v']\n group = self.domain.groups[ig]\n vertex_conn = ap.econn[:, :group.shape.n_ep]\n\n eval_dofs = get_eval_dofs(dofs, ap.econn, ps, ori=ap.ori)\n eval_coors = get_eval_coors(vertex_coors, vertex_conn, gps)\n\n (level, _coors, conn,\n _vdofs, _mat_ids) = create_output(eval_dofs, eval_coors,\n group.shape.n_el, ps,\n min_level=min_level,\n max_level=max_level, eps=eps)\n\n _mat_ids[:] = self.domain.mesh.mat_ids[ig][0]\n\n coors.append(_coors)\n vdofs.append(_vdofs)\n conns.append(conn + offset)\n mat_ids.append(_mat_ids)\n levels.append(level)\n\n offset += _coors.shape[0]\n\n coors = nm.concatenate(coors, axis=0)\n vdofs = nm.concatenate(vdofs, axis=0)\n mesh = Mesh.from_data('linearized_mesh', coors, None, conns, mat_ids,\n self.domain.mesh.descs)\n\n return mesh, vdofs, levels\n\n def get_output_approx_order(self):\n \"\"\"\n Get the approximation order used in the output file.\n \"\"\"\n return min(self.approx_order, 1)\n\n def create_output(self, dofs, var_name, dof_names=None,\n key=None, extend=True, fill_value=None,\n linearization=None):\n \"\"\"\n Convert the DOFs corresponding to the field to a dictionary of\n output data usable by Mesh.write().\n\n Parameters\n ----------\n dofs : array, shape (n_nod, n_component)\n The array of DOFs reshaped so that each column corresponds\n to one component.\n var_name : str\n The variable name corresponding to `dofs`.\n dof_names : tuple of str\n The names of DOF components.\n key : str, optional\n The key to be used in the output dictionary instead of the\n variable name.\n extend : bool\n Extend the DOF values to cover the whole domain.\n fill_value : float or complex\n The value used to fill the missing DOF values if `extend` is True.\n linearization : Struct or None\n The linearization configuration for higher order approximations.\n\n Returns\n -------\n out : dict\n The output dictionary.\n \"\"\"\n linearization = get_default(linearization, Struct(kind='strip'))\n\n out = {}\n if linearization.kind is None:\n out[key] = Struct(name='output_data', mode='full',\n data=dofs, var_name=var_name,\n dofs=dof_names, field_name=self.name)\n\n elif ((not self.is_higher_order())\n or (linearization.kind == 'strip')):\n if extend:\n ext = self.extend_dofs(dofs, fill_value)\n\n else:\n ext = self.remove_extra_dofs(dofs)\n\n if ext is not None:\n approx_order = self.get_output_approx_order()\n\n if approx_order != 0:\n # Has vertex data.\n out[key] = Struct(name='output_data', mode='vertex',\n data=ext, var_name=var_name,\n dofs=dof_names)\n\n else:\n ext.shape = (ext.shape[0], 1, ext.shape[1], 1)\n out[key] = Struct(name='output_data', mode='cell',\n data=ext, var_name=var_name,\n dofs=dof_names)\n\n else:\n mesh, vdofs, levels = self.linearize(dofs,\n linearization.min_level,\n linearization.max_level,\n linearization.eps)\n out[key] = Struct(name='output_data', mode='vertex',\n data=vdofs, var_name=var_name, dofs=dof_names,\n mesh=mesh, levels=levels)\n\n out = convert_complex_output(out)\n\n return out\n\n def create_mesh(self, extra_nodes=True):\n \"\"\"\n Create a mesh from the field region, optionally including the field\n extra nodes.\n \"\"\"\n mesh = self.domain.mesh\n\n if self.approx_order != 0:\n conns, mat_ids, descs = [], [], []\n for ig, ap in self.aps.iteritems():\n group = self.domain.groups[ig]\n if extra_nodes:\n conn = ap.econn\n else:\n offset = group.shape.n_ep\n conn = ap.econn[:,:offset]\n conns.append(conn)\n mat_ids.append(mesh.mat_ids[ig])\n descs.append(mesh.descs[ig])\n\n if extra_nodes:\n coors = self.coors\n\n else:\n coors = self.coors[:self.n_vertex_dof]\n\n mesh = Mesh.from_data(self.name, coors, None, conns,\n mat_ids, descs)\n\n return mesh\n\n def interp_to_qp(self, dofs):\n \"\"\"\n Interpolate DOFs into quadrature points.\n\n The quadrature order is given by the field approximation order.\n\n Parameters\n ----------\n dofs : array\n The array of DOF values of shape `(n_nod, n_component)`.\n\n Returns\n -------\n data_qp : array\n The values interpolated into the quadrature points.\n integral : Integral\n The corresponding integral defining the quadrature points.\n \"\"\"\n integral = Integral('i', order=self.approx_order)\n\n data_qp = []\n for ig, ap in self.aps.iteritems():\n bf = ap.get_base('v', False, integral)\n bf = bf[:,0,:].copy()\n\n vals = nm.dot(bf, dofs[ap.econn])\n vals = nm.swapaxes(vals, 0, 1)\n vals.shape = vals.shape + (1,)\n\n data_qp.append(vals)\n\n data_qp = nm.concatenate(data_qp, axis=0)\n\n return data_qp, integral\n\n def get_coor(self, nods=None):\n \"\"\"\n Get coordinates of the field nodes.\n\n Parameters\n ----------\n nods : array, optional\n The indices of the required nodes. If not given, the\n coordinates of all the nodes are returned.\n \"\"\"\n if nods is None:\n return self.coors\n else:\n return self.coors[nods]\n\n def create_mapping(self, ig, region, integral, integration):\n \"\"\"\n Create a new reference mapping.\n \"\"\"\n ap = self.aps[ig]\n\n out = ap.describe_geometry(self, integration, region, integral,\n return_mapping=True)\n return out\n\nclass VolumeField(FEField):\n \"\"\"\n Finite element field base class over volume elements (element dimension\n equals space dimension).\n \"\"\"\n\n def _check_region(self, region):\n \"\"\"\n Check whether the `region` can be used for the\n field. Non-surface fields require the region to span whole\n element groups.\n\n Returns\n -------\n ok : bool\n True if the region is usable for the field.\n \"\"\"\n ok = True\n domain = region.domain\n for ig in region.igs:\n if domain.groups[ig].gel.dim != domain.shape.tdim:\n output('cells with a bad topological dimension! (%d == %d)'\n % (domain.groups[ig].gel.dim, domain.shape.tdim))\n ok = False\n break\n shape = domain.groups[ig].shape\n if region.shape[ig].n_vertex < shape.n_vertex:\n output('region does not span a whole element group!')\n ok = False\n break\n\n return ok\n\n def _setup_geometry(self):\n \"\"\"\n Setup the field region geometry.\n \"\"\"\n ig = self.region.domain.cmesh.cell_groups[self.region.cells[0]]\n self.gel = self.domain.groups[ig].gel\n\n self.is_surface = False\n\n def _create_interpolant(self):\n name = '%s_%s_%s_%d%s' % (self.gel.name, self.space,\n self.poly_space_base, self.approx_order,\n 'B' * self.force_bubble)\n self.interp = fea.Interpolant(name, self.gel, self.space,\n self.poly_space_base, self.approx_order,\n self.force_bubble)\n\n def _setup_approximations(self):\n self.aps = {}\n self.aps_by_name = {}\n for ig in self.igs:\n name = self.interp.name + '_%s_ig%d' % (self.region.name, ig)\n ap = fea.Approximation(name, self.interp, self.region, ig)\n self.aps[ig] = ap\n self.aps_by_name[ap.name] = ap\n\n def _init_econn(self):\n \"\"\"\n Initialize the extended DOF connectivity.\n \"\"\"\n for ig, ap in self.aps.iteritems():\n n_ep = ap.n_ep['v']\n n_cell = self.region.get_n_cells(ig)\n ap.econn = nm.zeros((n_cell, n_ep), nm.int32)\n\n def _setup_vertex_dofs(self):\n \"\"\"\n Setup vertex DOF connectivity.\n \"\"\"\n if self.node_desc.vertex is None:\n return 0, None\n\n region = self.region\n\n vertices = region.get_vertices_of_cells()\n remap = prepare_remap(vertices, region.n_v_max)\n n_dof = vertices.shape[0]\n\n ##\n # Remap vertex node connectivity to field-local numbering.\n for ig, ap in self.aps.iteritems():\n group = self.domain.groups[ig]\n offset = group.shape.n_ep\n cells = region.get_cells(ig)\n ap.econn[:,:offset] = nm.take(remap,\n nm.take(group.conn,\n cells.astype(nm.int32),\n axis=0))\n\n return n_dof, remap\n\n def setup_extra_data(self, geometry, info, is_trace):\n dct = info.dc_type.type\n\n if geometry != None:\n geometry_flag = 'surface' in geometry\n else:\n geometry_flag = False\n\n if (dct == 'surface') or (geometry_flag):\n reg = info.get_region()\n self.domain.create_surface_group(reg)\n self._setup_surface_data(reg, is_trace)\n\n elif dct == 'edge':\n raise NotImplementedError('dof connectivity type %s' % dct)\n\n elif dct == 'point':\n self._setup_point_data(self, info.region)\n\n elif dct not in ('volume', 'scalar', 'plate'):\n raise ValueError('unknown dof connectivity type! (%s)' % dct)\n\n def _setup_surface_data(self, region, is_trace=False):\n for ig, ap in self.aps.iteritems():\n if ig not in region.igs: continue\n if region.name not in ap.surface_data:\n ap.setup_surface_data(region)\n\n for ig, ap in self.aps.iteritems():\n if region.name in ap.surface_data and is_trace:\n sd = ap.surface_data[region.name]\n sd.setup_mirror_connectivity(region)\n\n def _setup_point_data(self, field, region):\n # Point data only in the first group to avoid multiple\n # assembling of nodes on group boundaries.\n ap = self.aps[self.igs[0]]\n if region.name not in ap.point_data:\n ap.setup_point_data(field, region)\n\n def get_econn(self, conn_type, region, ig, is_trace=False,\n integration=None):\n \"\"\"\n Get extended connectivity of the given type in the given region.\n \"\"\"\n ct = conn_type.type if isinstance(conn_type, Struct) else conn_type\n\n if ((ig not in self.igs) or (ig not in region.igs)\n or (ct == 'point' and (ig > self.igs[0]))):\n # Point data only in the first group to avoid multiple\n # assembling of nodes on group boundaries.\n return None\n\n ap = self.aps[ig]\n\n if ct in ('volume', 'plate'):\n if region.name == self.region.name:\n conn = ap.econn\n\n else:\n aux = integration in ('volume', 'plate')\n cells = region.get_cells(ig, true_cells_only=aux)\n conn = nm.take(ap.econn, cells.astype(nm.int32), axis=0)\n\n elif ct == 'surface':\n sd = ap.surface_data[region.name]\n conn = sd.get_connectivity(is_trace=is_trace)\n\n elif ct == 'edge':\n raise NotImplementedError('connectivity type %s' % ct)\n\n elif ct == 'point':\n conn = ap.point_data[region.name]\n\n else:\n raise ValueError('unknown connectivity type! (%s)' % ct)\n\n return conn\n\n def get_full_econn(self, ig=None):\n if ig not in self.igs:\n msg = \"The required index (%s) of element group is not available\" \\\n % (str(ig),)\n raise ValueError(msg)\n\n econn = self.aps[ig].econn\n n_econn = econn.shape[1]\n if self.n_basis == n_econn:\n full_econn = econn\n\n elif self.n_basis==self.n_components*n_econn:\n full_econn = nm.zeros([econn.shape[0], self.n_basis],\n dtype=nm.int32)\n for ii in nm.arange(self.n_components):\n slc = slice(n_econn*ii, n_econn*(ii+1))\n full_econn[:, slc] = econn*self.n_components + ii\n\n return full_econn\n\n def average_qp_to_vertices(self, data_qp, integral):\n \"\"\"\n Average data given in quadrature points in region elements into\n region vertices.\n\n .. math::\n u_n = \\sum_e (u_{e,avg} * volume_e) / \\sum_e volume_e\n = \\sum_e \\int_{volume_e} u / \\sum volume_e\n \"\"\"\n region = self.region\n\n n_cells = region.get_n_cells()\n if n_cells != data_qp.shape[0]:\n msg = 'incomatible shape! (%d == %d)' % (n_cells,\n data_qp.shape[0])\n raise ValueError(msg)\n\n n_vertex = self.n_vertex_dof\n nc = data_qp.shape[2]\n\n nod_vol = nm.zeros((n_vertex,), dtype=nm.float64)\n data_vertex = nm.zeros((n_vertex, nc), dtype=nm.float64)\n for ig, ap in self.aps.iteritems():\n vg = ap.describe_geometry(self, 'volume', ap.region, integral)\n\n volume = nm.squeeze(vg.volume)\n iels = ap.region.get_cells(ig)\n\n data_e = nm.zeros((volume.shape[0], 1, nc, 1), dtype=nm.float64)\n vg.integrate(data_e, data_qp[iels])\n\n ir = nm.arange(nc, dtype=nm.int32)\n\n conn = ap.econn[:, :self.gel.n_vertex]\n for ii, cc in enumerate(conn):\n # Assumes unique nodes in cc!\n ind2, ind1 = nm.meshgrid(ir, cc)\n data_vertex[ind1,ind2] += data_e[iels[ii],0,:,0]\n nod_vol[cc] += volume[ii]\n data_vertex /= nod_vol[:,nm.newaxis]\n\n return data_vertex\n\nclass SurfaceField(FEField):\n \"\"\"\n Finite element field base class over surface (element dimension is one\n less than space dimension).\n \"\"\"\n\n def _check_region(self, region):\n \"\"\"\n Check whether the `region` can be used for the\n field.\n\n Returns\n -------\n ok : bool\n True if the region is usable for the field.\n \"\"\"\n ok = True\n for ig in region.igs:\n n_cell = region.get_n_cells(ig, True)\n if n_cell == 0:\n ok = False\n break\n\n return ok\n\n def _setup_geometry(self):\n \"\"\"\n Setup the field region geometry.\n \"\"\"\n self.gel = self.domain.groups[self.region.igs[0]].gel.surface_facet\n if self.gel is None:\n raise ValueError('element group has no surface!')\n\n self.is_surface = True\n\n def _create_interpolant(self):\n name = '%s_%s_%s_%d%s' % (self.gel.name, self.space,\n self.poly_space_base, self.approx_order,\n 'B' * self.force_bubble)\n self.interp = fea.SurfaceInterpolant(name, self.gel, self.space,\n self.poly_space_base,\n self.approx_order,\n self.force_bubble)\n\n def _setup_approximations(self):\n self.aps = {}\n self.aps_by_name = {}\n for ig in self.igs:\n name = self.interp.name + '_%s_ig%d' % (self.region.name, ig)\n ap = fea.SurfaceApproximation(name, self.interp, self.region, ig)\n self.aps[ig] = ap\n self.aps_by_name[ap.name] = ap\n\n def setup_extra_data(self, geometry, info, is_trace):\n dct = info.dc_type.type\n\n if dct != 'surface':\n msg = \"dof connectivity type must be 'surface'! (%s)\" % dct\n raise ValueError(msg)\n\n reg = info.get_region()\n\n for ig, ap in self.aps.iteritems():\n if ig not in reg.igs: continue\n\n if reg.name not in ap.surface_data:\n # Defined in setup_vertex_dofs()\n msg = 'no surface data of surface field! (%s)' % reg.name\n raise ValueError(msg)\n\n for ig, ap in self.aps.iteritems():\n if reg.name in ap.surface_data and is_trace:\n sd = ap.surface_data[reg.name]\n sd.setup_mirror_connectivity(reg)\n\n def _init_econn(self):\n \"\"\"\n Initialize the extended DOF connectivity.\n \"\"\"\n for ig, ap in self.aps.iteritems():\n n_ep = ap.n_ep['v']\n n_cell = self.region.get_n_cells(ig, True)\n ap.econn = nm.zeros((n_cell, n_ep), nm.int32)\n\n def _setup_vertex_dofs(self):\n \"\"\"\n Setup vertex DOF connectivity.\n \"\"\"\n if self.node_desc.vertex is None:\n return 0, None\n\n region = self.region\n\n remap = prepare_remap(region.vertices, region.n_v_max)\n n_dof = region.vertices.shape[0]\n\n ##\n # Remap vertex node connectivity to field-local numbering.\n for ig, ap in self.aps.iteritems():\n group = self.domain.groups[ig]\n faces = group.gel.get_surface_entities()\n aux = FESurface('aux', region, faces, group.conn, ig)\n ap.econn[:,:aux.n_fp] = aux.leconn\n ap.surface_data[region.name] = aux\n\n return n_dof, remap\n\n def _setup_bubble_dofs(self):\n \"\"\"\n Setup bubble DOF connectivity.\n \"\"\"\n return 0, None, None\n\n def get_econn(self, conn_type, region, ig, is_trace=False,\n integration=None):\n \"\"\"\n Get extended connectivity of the given type in the given region.\n \"\"\"\n ct = conn_type.type if isinstance(conn_type, Struct) else conn_type\n\n if ct != 'surface':\n msg = 'connectivity type must be \"surface\"! (%s)' % ct\n raise ValueError(msg)\n\n ap = self.aps[ig]\n\n sd = ap.surface_data[region.name]\n conn = sd.get_connectivity(local=True, is_trace=is_trace)\n\n return conn\n\n def average_qp_to_vertices(self, data_qp, integral):\n \"\"\"\n Average data given in quadrature points in region elements into\n region vertices.\n\n .. math::\n u_n = \\sum_e (u_{e,avg} * area_e) / \\sum_e area_e\n = \\sum_e \\int_{area_e} u / \\sum area_e\n \"\"\"\n region = self.region\n\n n_cells = region.get_n_cells(None, True)\n if n_cells != data_qp.shape[0]:\n msg = 'incomatible shape! (%d == %d)' % (n_cells,\n data_qp.shape[0])\n raise ValueError(msg)\n\n n_vertex = len(region.vertices)\n nc = data_qp.shape[2]\n\n nod_vol = nm.zeros((n_vertex,), dtype=nm.float64)\n data_vertex = nm.zeros((n_vertex, nc), dtype=nm.float64)\n offset = 0\n for ig, ap in self.aps.iteritems():\n sg = ap.describe_geometry(self, 'surface', ap.region, integral)\n\n area = nm.squeeze(sg.volume)\n n_cells = region.get_n_cells(ig, True)\n iels = offset + nm.arange(n_cells, dtype=nm.int32)\n offset += n_cells\n\n data_e = nm.zeros((area.shape[0], 1, nc, 1), dtype=nm.float64)\n sg.integrate(data_e, data_qp[iels])\n\n ir = nm.arange(nc, dtype=nm.int32)\n\n sd = self.domain.surface_groups[ig][region.name]\n # Should be vertex connectivity!\n conn = sd.get_connectivity(local=True)\n for ii, cc in enumerate(conn):\n # Assumes unique nodes in cc!\n ind2, ind1 = nm.meshgrid(ir, cc)\n data_vertex[ind1,ind2] += data_e[iels[ii],0,:,0]\n nod_vol[cc] += area[ii]\n data_vertex /= nod_vol[:,nm.newaxis]\n\n return data_vertex\n\nclass H1Mixin(Struct):\n \"\"\"\n Methods of fields specific to H1 space.\n \"\"\"\n\n def _setup_shape(self):\n \"\"\"\n Setup the field's shape-related attributes, see :class:`Field`.\n \"\"\"\n self.n_components = nm.prod(self.shape)\n self.val_shape = self.shape\n", "meta": {"hexsha": "a52f8d321b4cf51f320ca8575393153db6e531ff", "size": 40389, "ext": "py", "lang": "Python", "max_stars_repo_path": "sfepy/discrete/fem/fields_base.py", "max_stars_repo_name": "vondrejc/sfepy", "max_stars_repo_head_hexsha": "8e427af699c4b2858eb096510057abb3ae7e28e8", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "sfepy/discrete/fem/fields_base.py", "max_issues_repo_name": "vondrejc/sfepy", "max_issues_repo_head_hexsha": "8e427af699c4b2858eb096510057abb3ae7e28e8", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "sfepy/discrete/fem/fields_base.py", "max_forks_repo_name": "vondrejc/sfepy", "max_forks_repo_head_hexsha": "8e427af699c4b2858eb096510057abb3ae7e28e8", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-01-14T03:12:34.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-25T11:44:50.000Z", "avg_line_length": 34.0261162595, "max_line_length": 79, "alphanum_fraction": 0.5450741539, "include": true, "reason": "import numpy", "num_tokens": 9006, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5428632831725052, "lm_q2_score": 0.3557749003442964, "lm_q1q2_score": 0.1931371304712756}} {"text": "import os\nimport numpy\n\nimport _mypath\nimport chroma\n\ndata_dir = '../../../data/'\n\ndef load_LSST_filters():\n \"\"\" Read the LSST filter definitions from disk. Also add a normalization filter that is\n only non-zero at 500nm, which is used to define the CatSim/PhoSim normalization.\n \"\"\"\n filter_dir = data_dir+'filters/'\n filter_names = 'ugrizy'\n # establish wavelength array\n filters = {}\n for filter_name in filter_names:\n ffile = filter_dir+'LSST_{}.dat'.format(filter_name)\n wave, throughput = numpy.genfromtxt(ffile).T\n filters['LSST_'+filter_name] = {'wave':wave,\n 'throughput':throughput}\n norm_throughput = numpy.zeros_like(wave)\n norm_throughput[wave==500] = 1.0\n filters['norm'] = {'wave':wave,\n 'throughput':norm_throughput}\n return filters\n\ndef load_Euclid_filters():\n \"\"\" Load Euclid filters as defined by Voigt+12, centered at 775nm with widths of 150, 250, 350,\n and 450 nm. These are stored in the data directory.\"\"\"\n\n filter_dir = data_dir+'filters/'\n filter_names = ['Euclid_{}'.format(width) for width in [150,250,350,450]]\n\n filters = {}\n for filter_name in filter_names:\n ffile = filter_dir+'{}.dat'.format(filter_name)\n wave, throughput = numpy.genfromtxt(ffile).T\n filters[filter_name] = {'wave':wave,\n 'throughput':throughput}\n norm_throughput = numpy.zeros_like(wave)\n norm_throughput[wave==500] = 1.0\n filters['norm'] = {'wave':wave,\n 'throughput':norm_throughput}\n return filters\n\ndef match_filter_wavelengths(filters, wave_match):\n for fname, f in filters.iteritems():\n new_throughput = numpy.interp(wave_match, f['wave'], f['throughput'])\n filters[fname] = {'wave':wave_match,\n 'throughput':new_throughput}\n return filters\n\ndef AB_zeropoints(filters):\n \"\"\"Compute AB zeropoints for given filters.\n \"\"\"\n # define AB source in flambda\n ABsource = 3631e-23 # 3631 Jy -> erg/s/Hz/cm^2\n c = 29979245800.0 # cm/s\n nm_to_cm = 1.0e-7\n\n zps = {}\n for filter_name, filter_ in filters.iteritems():\n fwave = filter_['wave']\n throughput = filter_['throughput']\n ABflambda = ABsource * c / fwave**2 / nm_to_cm # erg/s/Hz/cm^2*cm/s/nm^2 -> erg/s/cm^2/nm\n AB_photons = ABflambda * fwave * throughput\n dlambda = fwave[1] - fwave[0] # assuming linear wavelength bins!\n AB_sumphotons = (AB_photons * dlambda).sum()\n zps[filter_name] = -2.5 * numpy.log10(AB_sumphotons)\n return zps\n\ndef read_spec(specfile):\n wave, flambda = numpy.genfromtxt(specfile).T\n return {'wave':wave, 'flambda':flambda}\n\ndef match_wavelengths(spec, wave_match):\n \"\"\" Interpolate spectrum onto given wavelength array.\n \"\"\"\n flux_i = numpy.interp(wave_match, spec['wave'], spec['flambda'])\n return {'wave':wave_match, 'flambda':flux_i}\n\ndef apply_redshift(spec, redshift):\n flux_i = numpy.interp(spec['wave'], spec['wave'] * (1.0 + redshift), spec['flambda'])\n return {'wave':spec['wave'], 'flambda':flux_i / (1.0 + redshift)}\n\ndef scale_spec(spec, target_mag, normfilter, normzp):\n \"\"\" Multiply spectrum flux such that the normalization magnitude matches the given target\n magnitude.\n \"\"\"\n fwave = normfilter['wave']\n throughput = normfilter['throughput']\n flambda_i = numpy.interp(fwave, spec['wave'], spec['flambda'])\n photons = flambda_i * fwave * throughput\n dlambda = fwave[1] - fwave[0]\n sumphotons = (photons * dlambda).sum()\n current_mag = -2.5 * numpy.log10(sumphotons) - normzp\n multiplier = 10**(-0.4 * (target_mag - current_mag))\n spec['flambda'] *= multiplier\n return spec\n\ndef apply_extinction(spec, A_v, R_v=3.1):\n wave = spec['wave']\n valid = (wave > 92) & (wave < 1200)\n wave = wave[valid]\n ext = chroma.extinction.reddening(wave*10, a_v=A_v, r_v=R_v, model='f99')\n flambda = spec['flambda']\n flambda[valid] /= ext\n spec = {'wave':spec['wave'], 'flambda':flambda}\n return spec\n\ndef compute_mags(spec, filters, zps):\n \"\"\" Compute magnitudes from spectrum. Assume that spectrum wavelengths are already matched to\n filter wavelengths.\n \"\"\"\n mags = {}\n for filter_name, filter_ in filters.iteritems():\n fwave = filter_['wave']\n throughput = filter_['throughput']\n photons = spec['flambda'] * fwave * throughput\n dlambda = fwave[1] - fwave[0] # assuming linear wavelength bins!\n sumphotons = (photons * dlambda).sum()\n mags[filter_name] = -2.5 * numpy.log10(sumphotons) - zps[filter_name]\n return mags\n\ndef make_composite_spec(gal, filters, zps, wave_match):\n SED_dir = os.environ['CAT_SHARE_DATA']+'data/'\n\n if gal['sedPathBulge'] != 'None':\n bulge_spec = read_spec(SED_dir+gal['sedPathBulge'])\n bulge_spec = scale_spec(bulge_spec, gal['magNormBulge'],\n filters['norm'], zps['norm'])\n bulge_spec = apply_extinction(bulge_spec,\n A_v=gal['internalAVBulge'],\n R_v=gal['internalRVBulge'])\n bulge_spec = apply_redshift(bulge_spec, gal['redshift'])\n bulge_spec = match_wavelengths(bulge_spec, wave_match)\n else:\n bulge_spec = {'wave':wave_match, 'flambda':numpy.zeros_like(wave_match)}\n if gal['sedPathDisk'] != 'None':\n disk_spec = read_spec(SED_dir+gal['sedPathDisk'])\n disk_spec = scale_spec(disk_spec, gal['magNormDisk'],\n filters['norm'], zps['norm'])\n disk_spec = apply_extinction(disk_spec,\n A_v=gal['internalAVDisk'],\n R_v=gal['internalRVDisk'])\n disk_spec = apply_redshift(disk_spec, gal['redshift'])\n disk_spec = match_wavelengths(disk_spec, wave_match)\n else:\n disk_spec = {'wave':wave_match, 'flambda':numpy.zeros_like(wave_match)}\n if gal['sedPathAGN'] != 'None':\n AGN_spec = read_spec(SED_dir+gal['sedPathAGN'])\n AGN_spec = scale_spec(AGN_spec, gal['magNormAGN'],\n filters['norm'], zps['norm'])\n AGN_spec = apply_redshift(AGN_spec, gal['redshift'])\n AGN_spec = match_wavelengths(AGN_spec, wave_match)\n else:\n AGN_spec = {'wave':wave_match, 'flambda':numpy.zeros_like(wave_match)}\n return {'wave':wave_match, 'flambda':(bulge_spec['flambda'] +\n disk_spec['flambda'] +\n AGN_spec['flambda'])}\n\ndef get_UV_flux(spec):\n # flambda in erg/s/cm^2/nm\n UV_flambda = numpy.interp(230.0, spec['wave'], spec['flambda'])\n # convert to erg/s/Hz\n c = 29979245800.0 # cm/s\n nm_to_cm = 1.0e-7\n UV_fnu = UV_flambda * (230.0)**2 / c * nm_to_cm\n return UV_fnu\n\ndef add_emission_lines(spec):\n wave = spec['wave'][:]\n flambda = spec['flambda'][:]\n UV_fnu = get_UV_flux(spec)\n lines = ['OII','OIII','Hbeta','Halpha','Lya']\n multipliers = numpy.array([1.0, 0.36, 0.61, 1.77, 2.0])*1.e13\n waves = [372.7, 500.7, 486.1, 656.3, 121.5]\n velocity = 200.0 # km/s\n for line, m, w in zip(lines, multipliers, waves):\n flux = UV_fnu * m\n sigma = velocity / 299792.458 * w # sigma in Angstroms\n amplitude = flux / sigma / numpy.sqrt(2.0 * numpy.pi)\n flambda += amplitude * numpy.exp(-(w-spec['wave'])**2/(2*sigma**2))\n return {'wave':wave, 'flambda':flambda}\n\ndef make_composite_spec_with_emission_lines(gal, filters, zps, wave_match):\n SED_dir = os.environ['CAT_SHARE_DATA']+'data/'\n\n if gal['sedPathBulge'] != 'None':\n bulge_spec = read_spec(SED_dir+gal['sedPathBulge'])\n bulge_spec = scale_spec(bulge_spec, gal['magNormBulge'],\n filters['norm'], zps['norm'])\n bulge_spec = add_emission_lines(bulge_spec)\n bulge_spec = apply_extinction(bulge_spec,\n A_v=gal['internalAVBulge'],\n R_v=gal['internalRVBulge'])\n bulge_spec = apply_redshift(bulge_spec, gal['redshift'])\n bulge_spec = match_wavelengths(bulge_spec, wave_match)\n else:\n bulge_spec = {'wave':wave_match, 'flambda':numpy.zeros_like(wave_match)}\n if gal['sedPathDisk'] != 'None':\n disk_spec = read_spec(SED_dir+gal['sedPathDisk'])\n disk_spec = scale_spec(disk_spec, gal['magNormDisk'],\n filters['norm'], zps['norm'])\n disk_spec = add_emission_lines(disk_spec)\n disk_spec = apply_extinction(disk_spec,\n A_v=gal['internalAVDisk'],\n R_v=gal['internalRVDisk'])\n disk_spec = apply_redshift(disk_spec, gal['redshift'])\n disk_spec = match_wavelengths(disk_spec, wave_match)\n else:\n disk_spec = {'wave':wave_match, 'flambda':numpy.zeros_like(wave_match)}\n if gal['sedPathAGN'] != 'None':\n AGN_spec = read_spec(SED_dir+gal['sedPathAGN'])\n AGN_spec = scale_spec(AGN_spec, gal['magNormAGN'],\n filters['norm'], zps['norm'])\n AGN_spec = apply_redshift(AGN_spec, gal['redshift'])\n AGN_spec = match_wavelengths(AGN_spec, wave_match)\n else:\n AGN_spec = {'wave':wave_match, 'flambda':numpy.zeros_like(wave_match)}\n return {'wave':wave_match, 'flambda':(bulge_spec['flambda'] +\n disk_spec['flambda'] +\n AGN_spec['flambda'])}\n\ndef make_bulge_spec(gal, filters, zps, wave_match):\n SED_dir = os.environ['CAT_SHARE_DATA']+'data/'\n\n if gal['sedPathBulge'] != 'None':\n bulge_spec = read_spec(SED_dir+gal['sedPathBulge'])\n bulge_spec = scale_spec(bulge_spec, gal['magNormBulge'],\n filters['norm'], zps['norm'])\n bulge_spec = apply_extinction(bulge_spec,\n A_v=gal['internalAVBulge'],\n R_v=gal['internalRVBulge'])\n bulge_spec = apply_redshift(bulge_spec, gal['redshift'])\n bulge_spec = match_wavelengths(bulge_spec, wave_match)\n else:\n return None\n return {'wave':wave_match, 'flambda':bulge_spec['flambda']}\n\ndef make_disk_spec(gal, filters, zps, wave_match):\n SED_dir = os.environ['CAT_SHARE_DATA']+'data/'\n\n if gal['sedPathDisk'] != 'None':\n disk_spec = read_spec(SED_dir+gal['sedPathDisk'])\n disk_spec = scale_spec(disk_spec, gal['magNormDisk'],\n filters['norm'], zps['norm'])\n disk_spec = apply_extinction(disk_spec,\n A_v=gal['internalAVDisk'],\n R_v=gal['internalRVDisk'])\n disk_spec = apply_redshift(disk_spec, gal['redshift'])\n disk_spec = match_wavelengths(disk_spec, wave_match)\n else:\n return None\n return {'wave':wave_match, 'flambda':disk_spec['flambda']}\n", "meta": {"hexsha": "26302fad0c80cb03eb2da6aaa6bfb227eca102b6", "size": 11092, "ext": "py", "lang": "Python", "max_stars_repo_path": "bin/analytic/catalog/phot.py", "max_stars_repo_name": "DarkEnergyScienceCollaboration/chroma", "max_stars_repo_head_hexsha": "64fc123a065334b307654f29b3bea52885b46ec8", "max_stars_repo_licenses": ["BSD-2-Clause", "BSD-3-Clause"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2015-10-22T14:57:27.000Z", "max_stars_repo_stars_event_max_datetime": "2016-08-25T08:16:02.000Z", "max_issues_repo_path": "bin/analytic/catalog/phot.py", "max_issues_repo_name": "DarkEnergyScienceCollaboration/chroma", "max_issues_repo_head_hexsha": "64fc123a065334b307654f29b3bea52885b46ec8", "max_issues_repo_licenses": ["BSD-2-Clause", "BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2017-08-28T14:42:46.000Z", "max_issues_repo_issues_event_max_datetime": "2017-08-28T16:08:37.000Z", "max_forks_repo_path": "bin/analytic/catalog/phot.py", "max_forks_repo_name": "DarkEnergyScienceCollaboration/chroma", "max_forks_repo_head_hexsha": "64fc123a065334b307654f29b3bea52885b46ec8", "max_forks_repo_licenses": ["BSD-2-Clause", "BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.1595330739, "max_line_length": 99, "alphanum_fraction": 0.6017850703, "include": true, "reason": "import numpy", "num_tokens": 3005, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5428632831725052, "lm_q2_score": 0.35577489351363034, "lm_q1q2_score": 0.1931371267631578}} {"text": "\"\"\" Minimum working example of an SME script\n\"\"\"\n\nimport logging\nimport sys\nfrom os.path import dirname, join, realpath\n\nimport numpy as np\n\nfrom pysme import sme as SME\nfrom pysme import util\nfrom pysme.linelist.vald import ValdFile\nfrom pysme.nso import load_solar_spectrum\nfrom pysme.solve import solve\n\nlogger = logging.getLogger(\"pysme\")\n# logger.setLevel(logging.CRITICAL)\n\nif __name__ == \"__main__\":\n # Define the location of all your files\n # this will put everything into the example dir\n target = \"sun\"\n examples_dir = dirname(realpath(__file__))\n # in_file = join(examples_dir, \"../sun_6440_test.inp\")\n # in_file = join(examples_dir, \"gr8_HARPS_HD148816.inp\")\n vald_file = join(examples_dir, \"data/harps.lin\")\n out_file = join(examples_dir, f\"{target}.sme\")\n plot_file = join(examples_dir, f\"{target}.html\")\n log_file = join(examples_dir, f\"{target}.log\")\n\n # Use HARPS spectral range\n wave, flux = load_solar_spectrum()\n wmin, wmax = 3780, 6910\n idx = (wave > wmin) & (wave < wmax)\n wave, flux = wave[idx], flux[idx]\n flux[flux < 0] = 0\n\n sme = SME.SME_Structure(wave=wave, sob=flux)\n sme.uncs = np.sqrt(flux)\n sme.mask = sme.mask_values[\"line\"]\n\n sme.linelist = ValdFile(vald_file)\n\n sme.nmu = 7\n sme.vrad = 0\n sme.cscale = None\n sme.vrad_flag = \"each\"\n sme.cscale_flag = \"linear\"\n sme.cscale_type = \"match\"\n sme.atmo.source = \"marcs2014.sav\"\n sme.abund = \"asplund2009\"\n\n # elems = [\n # \"Al\",\n # \"Ba\",\n # \"Ca\",\n # \"C\",\n # \"H\",\n # \"K\",\n # \"Li\",\n # \"Mg\",\n # \"Mn\",\n # \"Na\",\n # \"N\",\n # \"O\",\n # \"Si\",\n # ]\n # for elem in elems:\n # sme.nlte.set_nlte(elem, f\"nlte_{elem}_ama51_pysme.grd\")\n # sme.nlte.set_nlte(\"Fe\", \"marcs2012_Fe2016.grd\")\n\n # Load the parameters from the command line\n if len(sys.argv) > 1:\n param = sys.argv[1:]\n else:\n param = [5000, 4.0, 0] # 5000.00, 4.00, 0.00\n sme.teff = float(param[0])\n sme.logg = float(param[1])\n sme.monh = float(param[2])\n\n # try:\n sme = solve(sme, [\"teff\", \"logg\", \"monh\"])\n print(f\"{param[0]}, {param[1]}, {param[2]}, {sme.teff}, {sme.logg}, {sme.monh}\")\n # except Exception as ex:\n # print(f\"{param[0]}, {param[1]}, {param[2]}, nan, nan, nan\")\n", "meta": {"hexsha": "9026686291bb4d67b075087aa08733a7234e2dbc", "size": 2345, "ext": "py", "lang": "Python", "max_stars_repo_path": "examples/paper/convergence_part1.py", "max_stars_repo_name": "AWehrhahn/SME", "max_stars_repo_head_hexsha": "542e880ed779381f7cbbaaacb59475fa6a6d3537", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 14, "max_stars_repo_stars_event_min_datetime": "2019-06-26T18:43:09.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-12T00:53:42.000Z", "max_issues_repo_path": "examples/paper/convergence_part1.py", "max_issues_repo_name": "AWehrhahn/SME", "max_issues_repo_head_hexsha": "542e880ed779381f7cbbaaacb59475fa6a6d3537", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 10, "max_issues_repo_issues_event_min_datetime": "2020-03-01T15:21:23.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-01T15:28:37.000Z", "max_forks_repo_path": "examples/paper/convergence_part1.py", "max_forks_repo_name": "AWehrhahn/SME", "max_forks_repo_head_hexsha": "542e880ed779381f7cbbaaacb59475fa6a6d3537", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2019-03-01T15:25:24.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-30T10:26:33.000Z", "avg_line_length": 27.2674418605, "max_line_length": 84, "alphanum_fraction": 0.5918976546, "include": true, "reason": "import numpy", "num_tokens": 767, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5428632831725052, "lm_q2_score": 0.3557748866829644, "lm_q1q2_score": 0.19313712305504008}} {"text": "'''\nContains routines to read and manipulate particle size distribution data from the\n2D-S and HVPS optical array probes during the IMPACTS experiment. Creation of 1 Hz\nPSD data requires use of UIOOPS package (doi: 10.5281/zenodo.3976291).\nSome of the arguments in the routines require radar data matched to the P-3\nlocation to determine the optional degree of riming following Leinonen & Szyrmer (2015).\n\nCopyright Joe Finlon, Univ. of Washington, 2022.\n'''\n\nimport xarray as xr\nimport numpy as np\nnp.warnings.filterwarnings('ignore', category=np.VisibleDeprecationWarning)\nnp.warnings.filterwarnings('ignore', message='Mean of empty slice')\nnp.seterr(invalid='ignore')\nfrom datetime import datetime, timedelta\nfrom scipy.optimize import least_squares\ntry: # try importing the pytmatrix package\n from forward import *\nexcept ImportError:\n print(\n 'WARNING: The pytmatrix package cannot be installed for the psdread() function.'\n )\n\n \ndef psdread(\n twodsfile, hvpsfile, datestr, size_cutoff=1., minD=0.15, maxD=30.,\n qc=False, deadtime_thresh=0.6, verbose=True,\n start_time=None, end_time=None, tres=5.,\n compute_bulk=False, compute_fits=False, Z_interp=False,\n matchedZ_W=None, matchedZ_Ka=None, matchedZ_Ku=None, matchedZ_X=None):\n '''\n Load the 2DS and HVPS PSDs processed by UIOOPS and create n-second combined PSDs with optional bulk properties.\n Inputs:\n twodsfile: Path to the 2DS data\n hvpsfile: Path to the HVPS data\n datestr: YYYYMMDD [str]\n size_cutoff: Size [mm] for the 2DS-HVPS crossover\n minD: Minimum size [mm] to consider in the combined PSD\n maxD: Maximum size [mm] to consider in the combined PSD\n qc: Boolean to optionally ignore 1-Hz data from averaging when probe dead time > deadtime_thresh\n deadtime_thresh: Deadtime hreshold [0–1] to ignore 1-Hz data when qc is True\n verbose: Boolean to optionally print all data-related warnings (e.g., high probe dead time)\n start_time: Start time [YYYY-MM-DDTHH:MM:SS as str] to consider for the PSDs (optional)\n end_time: End time [YYYY-MM-DDTHH:MM:SS as str] to consider for the PSDs (optional)\n tres: Averaging interval [s]; tres=1. skips averaging routine\n compute_bulk: Boolean to optionally compute bulk statistics such as N, IWC, Dmm, rho_e\n compute_fits: Boolean to optionally compute gamma fit parameters N0, mu, lambda\n Z_interp: Boolean to optionally simulate Z for additional degrees of riming from Leinonen & Szyrmer (2015; LS15)\n matchedZ_Ka, ...: None (skips minimization) or masked array of matched Z values to perform LS15 m-D minimization\n '''\n p3psd = {}\n\n if (twodsfile is None) and (hvpsfile is not None):\n print('Only using the HVPS data for {}'.format(datestr))\n size_cutoff = 0.4 # start HVPS PSD at 0.4 mm\n elif (hvpsfile is None) and (twodsfile is not None):\n print('Only using the 2DS data for {}'.format(datestr))\n size_cutoff = 3.2 # end 2DS PSD at 3.2 mm\n elif (twodsfile is None) and (hvpsfile is None):\n print('No input files given...exiting')\n exit()\n\n # 2DS information\n if twodsfile is not None:\n ds1 = xr.open_dataset(twodsfile)\n time_raw = ds1['time'].values # HHMMSS from flight start date or numpy.datetime64\n if np.issubdtype(time_raw.dtype, np.datetime64): # numpy.datetime64\n time = np.array(time_raw, dtype='datetime64[s]')\n else: # native HHMMSS format (from UIOOPS SD file)\n time_dt = [\n datetime(int(datestr[0:4]), int(datestr[4:6]), int(datestr[6:]))\n + timedelta(\n hours=int(str(int(time_raw[i])).zfill(6)[0:2]),\n minutes=int(str(int(time_raw[i])).zfill(6)[2:4]),\n seconds=int(str(int(time_raw[i])).zfill(6)[4:]))\n for i in range(len(time_hhmmss))\n ]\n time_str = [\n datetime.strftime(time_dt[i], '%Y-%m-%dT%H:%M:%S')\n for i in range(len(time_dt))\n ]\n time = np.array(time_str, dtype='datetime64[s]')\n bin_min_2ds = ds1['bin_min'].values # mm\n bin_max_2ds = ds1['bin_max'].values\n bin_inds = np.where((bin_min_2ds>=minD) & (bin_max_2ds<=size_cutoff))[0] # find bins within user-specified range\n bin_min_2ds = bin_min_2ds[bin_inds]; bin_max_2ds = bin_max_2ds[bin_inds]\n bin_width_2ds = ds1['bin_dD'].values[bin_inds] / 10. # cm\n bin_mid_2ds = bin_min_2ds + (bin_width_2ds * 10.) / 2.\n count_2ds = ds1['count'].values[:, bin_inds]\n sv_2ds = ds1['sample_vol'].values[:, bin_inds] # cm^3\n count_hab_2ds = ds1['habitsd'].values[:, bin_inds, :] * np.tile(np.reshape(sv_2ds, (sv_2ds.shape[0], sv_2ds.shape[1], 1)), (1, 1, 10)) * np.tile(\n np.reshape(bin_width_2ds, (1, len(bin_width_2ds), 1)), (sv_2ds.shape[0], 1, 10))\n ar_2ds = ds1['mean_area_ratio'].values[:, bin_inds] # mean area ratio (circular fit) per bin\n asr_2ds = ds1['mean_aspect_ratio_ellipse'].values[:, bin_inds] # mean aspect ratio (elliptical fit) per bin\n activetime_2ds = ds1['sum_IntArr'].values # s\n\n if hvpsfile is None:\n count = count_2ds; count_hab = count_hab_2ds; sv = sv_2ds; ar = ar_2ds; asr = asr_2ds; activetime_hvps = np.ones(count.shape[0])\n bin_min = bin_min_2ds; bin_mid = bin_mid_2ds; bin_max = bin_max_2ds; bin_width = bin_width_2ds\n\n # HVPS information\n if hvpsfile is not None:\n ds2 = xr.open_dataset(hvpsfile)\n bin_min_hvps = ds2['bin_min'].values # mm\n bin_max_hvps = ds2['bin_max'].values\n bin_inds = np.where((bin_min_hvps>=size_cutoff) & (bin_max_hvps<=maxD))[0] # find bins within user-specified range\n bin_min_hvps = bin_min_hvps[bin_inds]; bin_max_hvps = bin_max_hvps[bin_inds]\n bin_width_hvps = ds2['bin_dD'].values[bin_inds] / 10. # cm\n if size_cutoff==2.:\n bin_min_hvps = np.insert(bin_min_hvps, 0, 2.); bin_max_hvps = np.insert(bin_max_hvps, 0, 2.2); bin_width_hvps = np.insert(bin_width_hvps, 0, 0.02)\n bin_inds = np.insert(bin_inds, 0, bin_inds[0]-1)\n bin_mid_hvps = bin_min_hvps + (bin_width_hvps * 10.) / 2.\n count_hvps = ds2['count'].values[:, bin_inds]\n sv_hvps = ds2['sample_vol'].values[:, bin_inds] # cm^3\n count_hab_hvps = (ds2['habitsd'].values[:, bin_inds, :]) * np.tile(np.reshape(sv_hvps, (sv_hvps.shape[0], sv_hvps.shape[1], 1)), (1, 1, 10)) * np.tile(\n np.reshape(bin_width_hvps, (1, len(bin_width_hvps), 1)), (sv_hvps.shape[0], 1, 10))\n ar_hvps = ds2['mean_area_ratio'].values[:, bin_inds] # mean area ratio (circular fit) per bin\n asr_hvps = ds2['mean_aspect_ratio_ellipse'].values[:, bin_inds] # mean aspect ratio (elliptical fit) per bin\n activetime_hvps = ds2['sum_IntArr'].values # s\n if size_cutoff==2.: # normalize counts in first bin (1.8-2.2 mm, now only for 2-2.2 mm)\n count_hvps[:, 0] = count_hvps[:, 0] / 2.\n count_hab_hvps[:, 0, :] = count_hab_hvps[:, 0, :] / 2.\n\n if twodsfile is None:\n time_hhmmss = ds2['time'].values # HHMMSS from flight start date\n time_dt = [datetime(int(datestr[0:4]), int(datestr[4:6]), int(datestr[6:])) + timedelta(\n hours=int(str(int(time_hhmmss[i])).zfill(6)[0:2]), minutes=int(str(int(time_hhmmss[i])).zfill(6)[2:4]),\n seconds=int(str(int(time_hhmmss[i])).zfill(6)[4:])) for i in range(len(time_hhmmss))]\n time_str = [datetime.strftime(time_dt[i], '%Y-%m-%dT%H:%M:%S') for i in range(len(time_dt))]\n time = np.array(time_str, dtype='datetime64[s]')\n count = count_hvps; count_hab = count_hab_hvps; sv = sv_hvps; ar = ar_hvps; asr = asr_hvps; activetime_2ds = np.ones(count.shape[0])\n bin_min = bin_min_hvps; bin_mid = bin_mid_hvps; bin_max = bin_max_hvps; bin_width = bin_width_hvps\n\n # Combine the datasets\n if (twodsfile is not None) and (hvpsfile is not None):\n count = np.concatenate((count_2ds, count_hvps), axis=1)\n count_hab = np.concatenate((count_hab_2ds, count_hab_hvps), axis=1)\n sv = np.concatenate((sv_2ds, sv_hvps), axis=1)\n ar = np.concatenate((ar_2ds, ar_hvps), axis=1)\n asr = np.concatenate((asr_2ds, asr_hvps), axis=1)\n bin_min = np.concatenate((bin_min_2ds, bin_min_hvps))\n bin_mid = np.concatenate((bin_mid_2ds, bin_mid_hvps))\n bin_max = np.concatenate((bin_max_2ds, bin_max_hvps))\n bin_width = np.concatenate((bin_width_2ds, bin_width_hvps))\n\n # Average the data\n if start_time is None:\n start_dt64 = time[0]\n else:\n start_dt64 = np.datetime64(start_time)\n if end_time is None:\n end_dt64 = time[-1] if int(tres)>1 else time[-1]+np.timedelta64(1, 's')\n else:\n end_dt64 = np.datetime64(end_time) if int(tres)>1 else np.datetime64(end_time)+np.timedelta64(1, 's')\n dur = (end_dt64 - start_dt64) / np.timedelta64(1, 's') # dataset duration to consider [s]\n\n # Allocate arrays\n count_aver = np.zeros((int(dur/tres), len(bin_mid)))\n count_hab_aver = np.zeros((int(dur/tres), len(bin_mid), 8))\n sv_aver = np.zeros((int(dur/tres), len(bin_mid)))\n at_2ds_aver = np.ma.array(np.ones(int(dur/tres)), mask=False)\n at_hvps_aver = np.ma.array(np.ones(int(dur/tres)), mask=False)\n ND = np.zeros((int(dur/tres), len(bin_mid)))\n ar_aver = np.zeros((int(dur/tres), len(bin_mid)))\n asr_aver = np.zeros((int(dur/tres), len(bin_mid)))\n\n time_subset = start_dt64 # allocate time array of N-sec interval obs\n curr_time = start_dt64\n i = 0\n\n while curr_time+np.timedelta64(int(tres),'s')<=end_dt64:\n if curr_time>start_dt64:\n time_subset = np.append(time_subset, curr_time)\n time_inds = np.where((time>=curr_time) & (time=activetime_thresh) & (activetime_hvps[time_inds]>=activetime_thresh)]\n if len(time_inds)>0:\n count_aver[i, :] = np.nansum(count[time_inds, :], axis=0)\n count_hab_aver[i, :, 0] = np.nansum(count_hab[time_inds, :, 3], axis=0) # tiny\n count_hab_aver[i, :, 1] = np.nansum(count_hab[time_inds, :, 0], axis=0) # spherical\n count_hab_aver[i, :, 2] = np.nansum(count_hab[time_inds, :, 1:3], axis=(0, 2)) # oriented + linear\n count_hab_aver[i, :, 3] = np.nansum(count_hab[time_inds, :, 4], axis=0) # hexagonal\n count_hab_aver[i, :, 4] = np.nansum(count_hab[time_inds, :, 5], axis=0) # irregular\n count_hab_aver[i, :, 5] = np.nansum(count_hab[time_inds, :, 6], axis=0) # graupel\n count_hab_aver[i, :, 6] = np.nansum(count_hab[time_inds, :, 7], axis=0) # dendrite\n count_hab_aver[i, :, 7] = np.nansum(count_hab[time_inds, :, 8], axis=0) # aggregate\n ar_aver[i, :] = np.nanmean(ar[time_inds, :], axis=0) # binned mean of area ratio\n asr_aver[i, :] = np.nanmean(asr[time_inds, :], axis=0) # binned mean of aspect ratio\n sv_aver[i, :] = np.nansum(sv[time_inds, :], axis=0)\n at_2ds_aver[i] = np.nansum(activetime_2ds[time_inds]) / len(time_inds)\n at_hvps_aver[i] = np.nansum(activetime_hvps[time_inds]) / len(time_inds)\n ND[i, :] = np.nanmean(count[time_inds, :]/sv[time_inds, :], axis=0) / bin_width # take N(D) for each sec, then average [cm**-4]\n else: # Mask data for current period if dead (active) time from either probe > 0.8*tres (< 0.2*tres) for all 1-Hz times\n if verbose is True:\n print('All 1-Hz data for the {}-s period beginning {} has high dead time. Masking data.'.format(str(tres), np.datetime_as_string(curr_time)))\n at_2ds_aver[i] = np.nansum(activetime_2ds[np.where((time>=curr_time) & (time=curr_time) & (time0.:\n iwc_bf[time_ind] = 10.**6 * np.nansum(mass_bf / sample_vol[time_ind, :]) # g m^-3\n z_bf = 1.e12 * (0.174/0.93) * (6./np.pi/0.934)**2 * np.nansum(mass_particle**2*particle_count[time_ind, :]/sample_vol[time_ind, :]) # mm^6 m^-3\n sol = least_squares(calc_chisquare, x0, method='lm',ftol=1e-9,xtol=1e-9, max_nfev=int(1e6),\\\n args=(Nt,iwc_bf[time_ind],z_bf,bin_mid,bin_width,0.00294/1.5,1.9)) # sove the gamma params using least squares minimziation\n N0_bf[time_ind] = sol.x[0]; mu_bf[time_ind] = sol.x[1]; lam_bf[time_ind] = sol.x[2]\n asr_bf[time_ind] = np.sum(aspect_ratio[time_ind, :] * mass_bf / sample_vol[time_ind, :]) / np.sum(mass_bf / sample_vol[time_ind, :]) # mass-weighted aspect ratio\n rhoe_bf[time_ind] = (iwc_bf[time_ind] / 10.**6) / vol # effective density from Chase et al. (2018) [g cm**-3]\n rho_bf[time_ind, :] = (mass_bf / particle_count[time_ind, :]) / (np.pi / 6.) / (bin_mid/10.)**3. # rho(D) following Heymsfield et al. (2003) [g cm**-3]\n dm_bf[time_ind] = 10. * np.sum((bin_mid/10.) * mass_bf / sample_vol[time_ind, :]) / np.sum(mass_bf / sample_vol[time_ind, :]) # mass-weighted mean D from Chase et al. (2020) [mm]\n if cumMass_bf[0]>=0.5*cumMass_bf[-1]:\n dmm_bf[time_ind] = bin_mid[0]\n else:\n dmm_bf[time_ind] = bin_mid[np.where(cumMass_bf>0.5*cumMass_bf[-1])[0][0]-1]\n\n # Heymsfield (2010) products [https://doi.org/10.1175/2010JAS3507.1]\n #mass_hy = (0.0061*(bin_mid/10.)**2.05) * particle_count[time_ind, :] # g (binned) H04 definition used in GPM NCAR files\n mass_particle = 0.00528 * (bin_mid/10.)**2.1 # particle mass [g]\n mass_hy = mass_particle * particle_count[time_ind, :] # g (binned)\n cumMass_hy = np.nancumsum(mass_hy)\n if cumMass_hy[-1]>0.:\n iwc_hy[time_ind] = 10.**6 * np.nansum(mass_hy / sample_vol[time_ind, :]) # g m^-3\n z_hy = 1.e12 * (0.174/0.93) * (6./np.pi/0.934)**2 * np.nansum(mass_particle**2*particle_count[time_ind, :]/sample_vol[time_ind, :]) # mm^6 m^-3\n sol = least_squares(calc_chisquare, x0, method='lm',ftol=1e-9,xtol=1e-9, max_nfev=int(1e6),\\\n args=(Nt,iwc_hy[time_ind],z_hy,bin_mid,bin_width,0.00528,2.1)) # sove the gamma params using least squares minimziation\n N0_hy[time_ind] = sol.x[0]; mu_hy[time_ind] = sol.x[1]; lam_hy[time_ind] = sol.x[2]\n asr_hy[time_ind] = np.sum(aspect_ratio[time_ind, :] * mass_hy / sample_vol[time_ind, :]) / np.sum(mass_hy / sample_vol[time_ind, :]) # mass-weighted aspect ratio\n rhoe_hy[time_ind] = (iwc_hy[time_ind] / 10.**6) / vol # effective density from Chase et al. (2018) [g cm**-3]\n rho_hy[time_ind, :] = (mass_hy / particle_count[time_ind, :]) / (np.pi / 6.) / (bin_mid/10.)**3. # rho(D) following Heymsfield et al. (2003) [g cm**-3]\n dm_hy[time_ind] = 10. * np.sum((bin_mid/10.) * mass_hy / sample_vol[time_ind, :]) / np.sum(mass_hy / sample_vol[time_ind, :]) # mass-weighted mean D from Chase et al. (2020) [mm]\n if cumMass_hy[0]>=0.5*cumMass_hy[-1]:\n dmm_hy[time_ind] = bin_mid[0]\n else:\n dmm_hy[time_ind] = bin_mid[np.where(cumMass_hy>0.5*cumMass_hy[-1])[0][0]-1]\n\n\n # Habit-specific products\n mass_hab = np.sum(mass_tile * habit_count[time_ind, :, :], axis=1) # g (binned)\n cumMass_hab = np.nancumsum(mass_hab)\n if cumMass_hab[-1]>0.:\n if cumMass_hab[0]>=0.5*cumMass_hab[-1]:\n dmm_hab[time_ind] = bin_mid[0]\n else:\n dmm_hab[time_ind] = bin_mid[np.where(cumMass_hab>0.5*cumMass_hab[-1])[0][0]-1]\n iwc_hab[time_ind] = 10.**6 * np.nansum(mass_hab / sample_vol[time_ind, :]) # g m^-3\n asr_hab[time_ind] = np.sum(aspect_ratio[time_ind, :] * mass_hab / sample_vol[time_ind, :]) / np.sum(mass_hab / sample_vol[time_ind, :]) # mass-weighted aspect ratio\n rhoe_hab[time_ind] = (iwc_hab[time_ind] / 10.**6) / vol # effective density from Chase et al. (2018) [g cm**-3]\n rho_hab[time_ind, :] = (mass_hab / particle_count[time_ind, :]) / (np.pi / 6.) / (bin_mid/10.)**3. # rho(D) following Heymsfield et al. (2003) [g cm**-3]\n dm_hab[time_ind] = 10. * np.sum((bin_mid/10.) * mass_hab / sample_vol[time_ind, :]) / np.sum(mass_hab / sample_vol[time_ind, :]) # mass-weighted mean D from Chase et al. (2020) [mm]\n\n mu_bf = np.ma.masked_where(N0_bf==0., mu_bf)\n mu_hy = np.ma.masked_where(N0_hy==0., mu_hy)\n lam_bf = np.ma.masked_where(N0_bf==0., lam_bf)\n lam_hy = np.ma.masked_where(N0_hy==0., lam_hy)\n N0_bf = np.ma.masked_where(N0_bf==0., N0_bf)\n N0_hy = np.ma.masked_where(N0_hy==0., N0_hy)\n dmm_bf = np.ma.masked_where(dmm_bf==0., dmm_bf)\n dmm_hy = np.ma.masked_where(dmm_hy==0., dmm_hy)\n dmm_hab = np.ma.masked_where(dmm_hab==0., dmm_hab)\n dm_bf = np.ma.masked_where(dm_bf==0., dm_bf)\n dm_hy = np.ma.masked_where(dm_hy==0., dm_hy)\n dm_hab = np.ma.masked_where(dm_hab==0., dm_hab)\n asr_nw = np.ma.masked_where(np.ma.getmask(dmm_bf), asr_nw)\n asr_bf = np.ma.masked_where(np.ma.getmask(dmm_bf), asr_bf)\n asr_hy = np.ma.masked_where(np.ma.getmask(dmm_hy), asr_hy)\n asr_hab = np.ma.masked_where(np.ma.getmask(asr_hab), iwc_hab)\n rhoe_bf = np.ma.masked_where(np.ma.getmask(dmm_bf), rhoe_bf)\n rhoe_hy = np.ma.masked_where(np.ma.getmask(dmm_hy), rhoe_hy)\n rhoe_hab = np.ma.masked_where(np.ma.getmask(dmm_hab), rhoe_hab)\n iwc_bf = np.ma.masked_where(np.ma.getmask(dmm_bf), iwc_bf)\n iwc_hy = np.ma.masked_where(np.ma.getmask(dmm_hy), iwc_hy)\n iwc_hab = np.ma.masked_where(np.ma.getmask(dmm_hab), iwc_hab)\n rho_bf = np.ma.masked_where(rho_bf==0., rho_bf)\n rho_hy = np.ma.masked_where(rho_hy==0., rho_hy)\n rho_hab = np.ma.masked_where(rho_hab==0., rho_hab)\n\n return (N0_bf, N0_hy, mu_bf, mu_hy, lam_bf, lam_hy, iwc_bf, iwc_hy, iwc_hab, asr_nw, asr_bf, asr_hy, asr_hab, dmm_bf, dmm_hy, dmm_hab,\\\n dm_bf, dm_hy, dm_hab, rho_bf, rho_hy, rho_hab, rhoe_bf, rhoe_hy, rhoe_hab)\n\ndef calc_riming(p3psd, Z, matchedZ_W, matchedZ_Ka, matchedZ_Ku, matchedZ_X, compute_fits=False):\n x0 = [1.e-1, -1., 5.] # initial guess for N0 [cm**-4], mu, lambda [cm**-1]\n\n rmass = np.zeros(len(p3psd['time']))\n rfrac = np.zeros(len(p3psd['time']))\n a_coeff = np.zeros(len(p3psd['time']))\n b_coeff = np.zeros(len(p3psd['time']))\n Nw = np.zeros(len(p3psd['time']))\n N0 = np.zeros(len(p3psd['time']))\n mu = np.zeros(len(p3psd['time']))\n lam = np.zeros(len(p3psd['time']))\n iwc = np.zeros(len(p3psd['time']))\n asr = np.zeros(len(p3psd['time']))\n dm = np.zeros(len(p3psd['time']))\n dmm = np.zeros(len(p3psd['time']))\n rho_eff = np.zeros(len(p3psd['time']))\n dfr_KuKa = np.zeros(len(p3psd['time']))\n error = np.zeros((len(p3psd['time']), len(p3psd['riming_mass_array'])))\n\n for i in range(len(p3psd['time'])):\n # loop through the different possible riming masses\n for j in range(len(p3psd['riming_mass_array'])):\n if (matchedZ_W is not None) and (np.ma.is_masked(matchedZ_W[i]) is False) and (np.ma.is_masked(p3psd['dbz_W'][i, :]) is False):\n error[i, j] = error[i, j] + np.abs(matchedZ_W[i] - p3psd['dbz_W'][i, j])\n if (matchedZ_Ka is not None) and (np.ma.is_masked(matchedZ_Ka[i]) is False) and (np.ma.is_masked(p3psd['dbz_Ka'][i, :]) is False):\n error[i, j] = error[i, j] + np.abs(matchedZ_Ka[i] - p3psd['dbz_Ka'][i, j])\n if (matchedZ_Ku is not None) and (np.ma.is_masked(matchedZ_Ku[i]) is False) and (np.ma.is_masked(p3psd['dbz_Ku'][i, :]) is False):\n error[i, j] = error[i, j] + np.abs(matchedZ_Ku[i] - p3psd['dbz_Ku'][i, j])\n if (matchedZ_X is not None) and (np.ma.is_masked(matchedZ_X[i]) is False) and (np.ma.is_masked(p3psd['dbz_X'][i, :]) is False):\n error[i, j] = error[i, j] + np.abs(matchedZ_X[i] - p3psd['dbz_X'][i, j])\n\n if np.sum(error[i, :])>0.:\n rmass[i] = p3psd['riming_mass_array'][np.argmin(error[i, :])]\n a_coeff[i] = p3psd['a_coeff_array'][np.argmin(error[i, :])]\n b_coeff[i] = p3psd['b_coeff_array'][np.argmin(error[i, :])]\n\n if p3psd['count'][i, :].count()==p3psd['count'].shape[1]: # time period is not masked...continue on\n Nt = 1000.*np.nansum(p3psd['count'][i, :]/p3psd['sv'][i, :]) # concentration [L**-1]\n mass_particle = a_coeff[i] * (p3psd['bin_mid']/10.)**b_coeff[i] # particle mass [g]\n mass = mass_particle * p3psd['count'][i, :] # g (binned)\n cumMass = np.nancumsum(mass)\n if cumMass[-1]>0.:\n # Nw (follows Chase et al. 2021)\n # [log10(m**-3 mm**-1)]\n D_melt = ((6. * mass_particle) / (np.pi * 0.997))**(1./3.)\n Nw[i] = np.log10((1e5) * (4.**4 / 6) * np.nansum(\n D_melt**3 * p3psd['ND'][i, :] * p3psd['bin_width'])**5 / np.nansum(\n D_melt**4 * p3psd['ND'][i, :] * p3psd['bin_width'])**4)\n\n # IWC\n iwc[i] = 10.**6 * np.nansum(mass / p3psd['sv'][i, :]) # g m^-3\n\n # DFR\n dfr_KuKa[i] = p3psd[\n 'dbz_Ku'][i, np.argmin(error[i, :])] - p3psd[\n 'dbz_Ka'][i, np.argmin(error[i, :])] # dB\n\n # Optionally compute N0, mu, lambda\n if compute_fits:\n z = 10.**(p3psd['dbz_X'][i,np.argmin(error[i, :])]/10.) # mm^6 m^-3\n\n # solve gamma params using least squares minimziation\n sol = least_squares(\n calc_chisquare, x0, method='lm', ftol=1e-9, xtol=1e-9,\n max_nfev=int(1e6), args=(\n Nt, iwc[i], z, p3psd['bin_mid'], p3psd['bin_width'],\n a_coeff[i], b_coeff[i], np.argmin(error[i, :])))\n N0[i] = sol.x[0]; mu[i] = sol.x[1]; lam[i] = sol.x[2]\n\n # Mass-weighted mean aspect ratio\n asr[i] = np.sum(\n p3psd['aspect_ratio'][i, :] * mass / p3psd['sv'][i, :]) / np.sum(\n mass / p3psd['sv'][i, :])\n\n # Bulk riming fraction (see Eqn 1 of Morrison and Grabowski\n # [2010, https://doi.org/10.1175/2010JAS3250.1] for binned version)\n rfrac[i] = np.sum(\n np.squeeze(Z.rimefrac[0, :, np.argmin(error[i, :])])\n * mass / p3psd['sv'][i, :]) / np.nansum(\n mass / p3psd['sv'][i, :]) # SUM(rimed mass conc)/iwc\n\n # Effective density (follows Chase et al. 2018)\n vol = (np.pi / 6.) * np.sum(\n 0.6 * ((p3psd['bin_mid']/10.)**3.) * p3psd['count'][i, :]\n / p3psd['sv'][i, :]) # [cm**3 / cm**3]\n rho_eff[i] = (iwc[i] / 10.**6) / vol # [g cm**-3]\n\n # Mass-weighted mean diameter (follows Chase et al. 2020)\n # M3/M2 if b==2, more generally M(b+1)/Mb\n dm[i] = 10. * np.sum(\n (p3psd['bin_mid']/10.) * mass / p3psd['sv'][i, :]) / np.sum(\n mass / p3psd['sv'][i, :]) # [mm]\n\n # Mass-weighted median diameter [mm]\n if cumMass[0]>=0.5*cumMass[-1]:\n dmm[i] = p3psd['bin_mid'][0]\n else:\n dmm[i] = p3psd[\n 'bin_mid'][np.where(cumMass>0.5*cumMass[-1])[0][0]-1]\n\n p3psd['sclwp'] = np.ma.masked_where(np.sum(error, axis=1)==0., rmass)\n p3psd['riming_frac'] = np.ma.masked_where(np.sum(error, axis=1)==0., rfrac)\n p3psd['a_coeff'] = np.ma.masked_where(np.sum(error, axis=1)==0., a_coeff)\n p3psd['b_coeff'] = np.ma.masked_where(np.sum(error, axis=1)==0., b_coeff)\n if compute_fits:\n p3psd['mu_ls'] = np.ma.masked_where(N0==0., mu)\n p3psd['lambda_ls'] = np.ma.masked_where(N0==0., lam)\n p3psd['N0_ls'] = np.ma.masked_where(N0==0., N0)\n p3psd['Nw_ls'] = np.ma.masked_where(np.sum(error, axis=1)==0., Nw)\n p3psd['iwc_ls'] = np.ma.masked_where(np.sum(error, axis=1)==0., iwc)\n p3psd['mean_aspect_ratio_ls'] = np.ma.masked_where(np.sum(error, axis=1)==0., asr)\n p3psd['dm_ls'] = np.ma.masked_where(np.sum(error, axis=1)==0., dm)\n p3psd['dmm_ls'] = np.ma.masked_where(np.sum(error, axis=1)==0., dmm)\n p3psd['eff_density_ls'] = np.ma.masked_where(np.sum(error, axis=1)==0., rho_eff)\n p3psd['dfr_KuKa_ls'] = np.ma.masked_where(np.sum(error, axis=1)==0., dfr_KuKa)\n\n return p3psd\n\ndef calc_chisquare(\n x, Nt_obs, iwc_obs, z_obs, bin_mid, bin_width, a_coefficient, b_coefficient,\n rime_ind=None, exponential=False):\n '''\n Compute gamma fit parameters for the PSD.\n Follows McFarquhar et al. (2015) by finding N0-mu-lambda minimizing first\n (Nt), third (mass), sixth (reflectivity) moments.\n Inputs:\n x: N0, mu, lambda to test on the minimization procedure\n Nt_obs: Observed number concentration [L^-1]\n iwc_obs: Observed IWC using an assumed m-D relation [g m**-3]\n z_obs: Observed Z (following Hogan et al. 2012 definition) using assumed m-D relation [mm**6 m**-3]\n bin_mid: Midpoints for the binned particle size [mm]\n bin_width: Bin width for the binned particle size [cm]\n a_coefficient: Prefactor component to the assumed m-D reltation [cm**-b]\n b_coefficient: Exponent component to the assumed m-D reltation\n rime_ind (optional, for LS products only): Riming category index to use for the reflectivity moment\n exponential: Boolean, True if setting mu=0 for the fit (exponential form)\n Outputs:\n chi_square: Chi-square value for the provided N0-mu-lambda configuration\n '''\n Dmax = bin_mid / 10. # midpoint in cm\n dD = bin_width # bin width in cm\n mass_particle = a_coefficient * Dmax**b_coefficient # binned particle mass [g]\n\n if exponential: # exponential form with mu=0\n ND_fit = x[0] * np.exp(-x[2]*Dmax)\n else: # traditional gamma function with variable mu\n ND_fit = x[0] * Dmax**x[1] * np.exp(-x[2]*Dmax)\n \n Nt_fit = 1000.*np.nansum(ND_fit*dD) # L**-1\n iwc_fit = 10.**6 * np.nansum(mass_particle*ND_fit*dD) # g m**-3\n if rime_ind is not None:\n Z_fit = forward_Z() #initialize class\n Z_fit.set_PSD(PSD=ND_fit[np.newaxis,:]*10.**8, D=Dmax/100., dD=dD/100., Z_interp=True) # get the PSD in the format to use in the routine (mks units)\n Z_fit.load_split_L15() # Load the leinonen output\n Z_fit.fit_sigmas(Z_interp=True) # Fit the backscatter cross-sections\n Z_fit.calc_Z() # Calculate Z...outputs are Z.Z_x, Z.Z_ku, Z.Z_ka, Z.Z_w for the four radar wavelengths\n z_fit = 10.**(Z_fit.Z_x[0, rime_ind] / 10.) # mm**6 m**-3\n else:\n z_fit = 1.e12 * (0.174/0.93) * (6./np.pi/0.934)**2 * np.nansum(mass_particle**2*ND_fit*dD) # mm**6 m**-3\n\n csq_Nt = ((Nt_obs-Nt_fit) / np.sqrt(Nt_obs*Nt_fit))**2\n csq_iwc = ((iwc_obs-iwc_fit) / np.sqrt(iwc_obs*iwc_fit))**2\n csq_z = ((z_obs-z_fit) / np.sqrt(z_obs*z_fit))**2\n chi_square = [csq_Nt, csq_iwc, csq_z]\n\n return chi_square", "meta": {"hexsha": "090b631c56a8b8007055f2f54b77d15bee53fe77", "size": 35286, "ext": "py", "lang": "Python", "max_stars_repo_path": "p3.py", "max_stars_repo_name": "joefinlon/Finlon_et_al_2021_DFR", "max_stars_repo_head_hexsha": "1529df191687a12c8c6e4e1346ee0836260bc56f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "p3.py", "max_issues_repo_name": "joefinlon/Finlon_et_al_2021_DFR", "max_issues_repo_head_hexsha": "1529df191687a12c8c6e4e1346ee0836260bc56f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "p3.py", "max_forks_repo_name": "joefinlon/Finlon_et_al_2021_DFR", "max_forks_repo_head_hexsha": "1529df191687a12c8c6e4e1346ee0836260bc56f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 59.404040404, "max_line_length": 194, "alphanum_fraction": 0.6079748342, "include": true, "reason": "import numpy,from scipy", "num_tokens": 11794, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5428632831725052, "lm_q2_score": 0.35577488668296436, "lm_q1q2_score": 0.19313712305504002}} {"text": "#!/usr/bin/env python\n# -*-coding:utf8 -*\n\n\"\"\"\nModule for the definition of FunctionalData types.\n\nThis modules is used to defined different types of functional data. The\ndifferent types are: Univariate Functional Data, Irregular Functional data and\nMultivariate Functional Data.\n\"\"\"\nimport numpy as np\nimport pygam\n\nfrom abc import ABC, abstractmethod\nfrom collections import UserList\n\nfrom sklearn.metrics import pairwise_distances\n\nfrom ..preprocessing.smoothing.bandwidth import Bandwidth\nfrom ..preprocessing.smoothing.local_polynomial import LocalPolynomial\nfrom ..preprocessing.smoothing.smoothing_splines import SmoothingSpline\nfrom ..misc.utils import get_dict_dimension_, get_obs_shape_\nfrom ..misc.utils import integration_weights_, outer_\nfrom ..misc.utils import range_standardization_\n\n\n###############################################################################\n# Checkers for parameters\n\ndef _check_dict_array(argv_dict, argv_array):\n \"\"\"Raise an error in case of dimension conflicts between the arguments.\n\n An error is raised when `argv_dict` (a dictionary) and `argv_array`\n (a np.ndarray) do not have coherent common dimensions. The first dimension\n of `arg_array` is assumed to represented the number of observation.\n \"\"\"\n dim_dict = get_dict_dimension_(argv_dict)\n dim_array = argv_array.shape[1:]\n if dim_dict != dim_array:\n raise ValueError(f\"{argv_dict} and {argv_array} do not have coherent\"\n \" dimension.\")\n\n\ndef _check_dict_dict(argv1, argv2):\n \"\"\"Raise an error in case of dimension conflicts between the arguments.\n\n An error is raised when `argv1` (a nested dictonary) and `argv2` (a\n dictionary) do not have coherent common dimensions.\n \"\"\"\n has_obs_shape = [obs.shape == get_obs_shape_(argv1, idx)\n for idx, obs in argv2.items()]\n if not np.all(has_obs_shape):\n raise ValueError(f\"{argv1} and {argv2} do not\"\n \" have coherent dimension.\")\n\n\ndef _check_type(argv, category):\n \"\"\"Raise an error if `argv` is not of type category.\"\"\"\n if not isinstance(argv, category):\n raise TypeError(f\"Argument must be FunctionalData, not\"\n f\" {type(argv).__name__}\")\n\n\ndef _check_dict_type(argv, category):\n \"\"\"Raise an error if all elements of `argv` are not of type `category`.\"\"\"\n is_cat = [isinstance(obj, category) for obj in argv.values()]\n if not np.all(is_cat):\n raise TypeError(f\"Argument values must be {category.__name__}\")\n\n\ndef _check_dict_len(argv):\n \"\"\"Raise an error if all elements of `argv` do not have equal length.\"\"\"\n lengths = [len(obj) for obj in argv.values()]\n if len(set(lengths)) > 1:\n raise ValueError(\"The number of observations is different across the\"\n \" dimensions.\"\"\")\n\n\ndef _check_same_type(argv1, argv2):\n \"\"\"Raise an error if `argv1` and `argv2` have different type.\"\"\"\n if not isinstance(argv2, type(argv1)):\n raise TypeError(f\"{argv1} and {argv2} do not have the same type.\")\n\n\ndef _check_same_nobs(*argv):\n \"\"\"Raise an arror if elements in argv have different number of obs.\"\"\"\n n_obs = set(obj.n_obs for obj in argv)\n if len(n_obs) > 1:\n raise ValueError(\"Elements do not have the same number\"\n \" of observations.\")\n\n\ndef _check_same_ndim(argv1, argv2):\n \"\"\"Raise an error if `argv1` and `argv2` have different number of dim.\"\"\"\n if argv1.n_dim != argv2.n_dim:\n raise ValueError(f\"{argv1} and {argv2} do not have the same number\"\n \" of dimensions.\")\n\n\ndef _check_argvals_equality_dense(argv1, argv2):\n \"\"\"Raise an error if `argv1` and `argv2` are not equal.\"\"\"\n argvs_equal = all(np.array_equal(argv1[key], argv2[key]) for key in argv1)\n if not argvs_equal:\n raise ValueError(f\"{argv1} and {argv2} do not have the same sampling\"\n \" points.\")\n\n\ndef _check_argvals_equality_irregular(argv1, argv2):\n \"\"\"Raise an error if `argv1` and `argv2` are not equal.\"\"\"\n temp = []\n for points1, points2 in zip(argv1.values(), argv2.values()):\n temp.append(all(np.array_equal(points1[key], points2[key])\n for key in points1))\n\n argvs_equal = all(temp)\n if not argvs_equal:\n raise ValueError(f\"{argv1} and {argv2} do not have the same sampling\"\n \" points.\")\n\n\n###############################################################################\n# Class FunctionalData\n\n\nclass FunctionalData(ABC):\n \"\"\"Metaclass for the definition of diverse functional data objects.\n\n Parameters\n ----------\n argvals: list\n values: list\n category: str, {'univariate', 'irregular', 'multivariate'}\n\n \"\"\"\n\n @staticmethod\n @abstractmethod\n def _check_argvals(argvals):\n _check_type(argvals, dict)\n\n @staticmethod\n @abstractmethod\n def _check_values(values):\n pass\n\n @staticmethod\n @abstractmethod\n def _check_argvals_values(argvals, values):\n pass\n\n @staticmethod\n @abstractmethod\n def _perform_computation(fdata1, fdata2, func):\n pass\n\n def __init__(self, argvals, values, category):\n \"\"\"Initialize FunctionalData object.\"\"\"\n super().__init__()\n self.argvals = argvals\n self.values = values\n self.category = category\n\n def __repr__(self):\n \"\"\"Override print function.\"\"\"\n return (f\"{self.category.capitalize()} functional data object with\"\n f\" {self.n_obs} observations on a {self.n_dim}-dimensional\"\n \" support.\")\n\n @abstractmethod\n def __getitem__(self, index):\n \"\"\"Override getitem function, called when self[index].\"\"\"\n pass\n\n def __add__(self, obj):\n \"\"\"Override add function.\"\"\"\n return self._perform_computation(self, obj, np.add)\n\n def __sub__(self, obj):\n \"\"\"Override sub function.\"\"\"\n return self._perform_computation(self, obj, np.subtract)\n\n def __mul__(self, obj):\n \"\"\"Overrude mul function.\"\"\"\n return self._perform_computation(self, obj, np.multiply)\n\n def __rmul__(self, obj):\n \"\"\"Override rmul function.\"\"\"\n return self * obj\n\n def __truediv__(self, obj):\n \"\"\"Override truediv function.\"\"\"\n return self._perform_computation(self, obj, np.divide)\n\n def __floordiv__(self, obj):\n \"\"\"Override floordiv function.\"\"\"\n return self / obj\n\n @property\n def argvals(self):\n \"\"\"Getter for argvals.\"\"\"\n return self._argvals\n\n @argvals.setter\n def argvals(self, new_argvals):\n self._check_argvals(new_argvals)\n if hasattr(self, 'values'):\n self._check_argvals_values(new_argvals, self.values)\n self._argvals = new_argvals\n\n @property\n def argvals_stand(self):\n \"\"\"Getter for argvals_stand.\"\"\"\n return self._argvals_stand\n\n @argvals_stand.setter\n def argvals_stand(self, new_argvals_stand):\n self._argvals_stand = new_argvals_stand\n\n @property\n def values(self):\n \"\"\"Getter for values.\"\"\"\n return self._values\n\n @values.setter\n def values(self, new_values):\n self._check_values(new_values)\n if hasattr(self, 'argvals'):\n self._check_argvals_values(self.argvals, new_values)\n self._values = new_values\n\n @property\n def category(self):\n \"\"\"Getter for category.\"\"\"\n return self._category\n\n @category.setter\n def category(self, new_category):\n self._category = new_category\n\n @property\n def n_obs(self):\n \"\"\"Get the number of observations of the functional data.\n\n Returns\n -------\n n_obs: int\n Number of observations within the functional data.\n\n \"\"\"\n return len(self.values)\n\n @property\n @abstractmethod\n def range_obs(self):\n \"\"\"Get the range of the observations of the object.\"\"\"\n pass\n\n @property\n def n_dim(self):\n \"\"\"Get the number of input dimension of the functional data.\n\n Returns\n -------\n n_dim: int\n Number of input dimension with the functional data.\n\n \"\"\"\n return len(self.argvals)\n\n @property\n @abstractmethod\n def n_points(self):\n \"\"\"Get the mean number of sampling points.\"\"\"\n pass\n\n @property\n @abstractmethod\n def range_dim(self):\n \"\"\"Range of the `argvals` for each of the dimension.\"\"\"\n pass\n\n @property\n @abstractmethod\n def shape(self):\n \"\"\"Shape of the data for each dimension.\"\"\"\n pass\n\n @abstractmethod\n def is_compatible(self, fdata):\n \"\"\"Check if `fdata` is compatible with `self`.\"\"\"\n _check_same_type(self, fdata)\n _check_same_nobs(self, fdata)\n _check_same_ndim(self, fdata)\n\n @abstractmethod\n def mean(self, smooth=None, **kwargs):\n \"\"\"Compute an estimate of the mean.\"\"\"\n pass\n\n @abstractmethod\n def covariance(self, mean=None, smooth=None, **kwargs):\n \"\"\"Compute an estimate of the covariance.\"\"\"\n pass\n\n @abstractmethod\n def smooth(self, points, neighborhood, points_estim=None, degree=0,\n kernel=\"epanechnikov\", bandwidth=None):\n \"\"\"Smooth the data.\"\"\"\n pass\n\n\n###############################################################################\n# Class DenseFunctionalData\n\nclass DenseFunctionalData(FunctionalData):\n r\"\"\"A class for defining Dense Functional Data.\n\n A class used to define dense functional data. We denote by :math:`n`, the\n number of observations and by :math:`p`, the number of input dimensions.\n Here, we are in the case of univariate functional data, and so the output\n dimension will be :math:`\\mathbb{R}`.\n\n Parameters\n ----------\n argvals: dict\n The sampling points of the functional data. Each entry of the\n dictionary represents an input dimension. The shape of the :math:`j`th\n dimension is :math:`(m_j,)` for :math:`0 \\leq j \\leq p`.\n values: np.ndarray\n The values of the functional data. The shape of the array is\n :math:`(n, m_1, \\dots, m_p)`.\n\n Examples\n --------\n >>> argvals = {'input_dim_0': np.array([1, 2, 3, 4]),\n 'input_dim_1': np.array([5, 6, 7])}\n\n >>> values = np.array([[[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]],\n [[5, 6, 7], [5, 6, 7], [5, 6, 7], [5, 6, 7]],\n [[3, 4, 5], [3, 4, 5], [3, 4, 5], [3, 4, 5]],\n [[3, 4, 5], [3, 4, 5], [3, 4, 5], [3, 4, 5]],\n [[3, 4, 5], [3, 4, 5], [3, 4, 5], [3, 4, 5]]])\n\n >>> DenseFunctionalData(argvals, values)\n\n \"\"\"\n\n @staticmethod\n def _check_argvals(argvals):\n \"\"\"Check the user provided `argvals`.\"\"\"\n FunctionalData._check_argvals(argvals)\n _check_dict_type(argvals, np.ndarray)\n\n @staticmethod\n def _check_values(values):\n \"\"\"Check the use provided `values`.\"\"\"\n _check_type(values, np.ndarray)\n\n @staticmethod\n def _check_argvals_values(argvals, values):\n \"\"\"Check the compatibility of argvals and values.\"\"\"\n _check_dict_array(argvals, values)\n\n @staticmethod\n def _perform_computation(fdata1, fdata2, func):\n \"\"\"Perform computation defined by `func`.\"\"\"\n if fdata1.is_compatible(fdata2):\n new_values = func(fdata1.values, fdata2.values)\n return DenseFunctionalData(fdata1.argvals, new_values)\n\n def __init__(self, argvals, values):\n \"\"\"Initialize UnivariateFunctionalData object.\"\"\"\n super().__init__(argvals, values, 'univariate')\n\n def __getitem__(self, index):\n \"\"\"Overrride getitem function, called when self[index].\n\n Parameters\n ----------\n index: int\n The observation(s) of the object to retrive.\n\n Returns\n -------\n data: DenseFunctionalData object\n The selected observation(s) as DenseFunctionalData object.\n\n \"\"\"\n argvals = self.argvals\n values = self.values[index]\n\n if len(argvals) == len(values.shape):\n values = values[np.newaxis]\n return DenseFunctionalData(argvals, values)\n\n @property\n def argvals(self):\n \"\"\"Getter for argvals.\"\"\"\n return super().argvals\n\n @argvals.setter\n def argvals(self, new_argvals):\n super(DenseFunctionalData, self.__class__).\\\n argvals.fset(self, new_argvals)\n\n argvals_stand = {}\n for dim, points in new_argvals.items():\n argvals_stand[dim] = range_standardization_(points)\n self.argvals_stand = argvals_stand\n\n @property\n def range_obs(self):\n \"\"\"Get the range of the observations of the object.\n\n Returns\n -------\n min, max: tuple\n Tuple containing the mimimum and maximum values taken by all the\n observations for the object.\n\n \"\"\"\n return np.min(self.values), np.max(self.values)\n\n @property\n def n_points(self):\n \"\"\"Get the mean number of sampling points.\n\n Returns\n -------\n n_points: dict\n A dictionary with the same shape than argavls with the number of\n sampling points along each axis.\n\n \"\"\"\n return {i: len(points) for i, points in self.argvals.items()}\n\n @property\n def range_dim(self):\n \"\"\"Get the range of the `argvals` for each of the dimension.\n\n Returns\n -------\n ranges: dict\n Dictionary containing the range of the argvals for each of the\n input dimension.\n\n \"\"\"\n return {idx: (min(argval), max(argval))\n for idx, argval in self.argvals.items()}\n\n @property\n def shape(self):\n r\"\"\"Get the shape of the data for each dimension.\n\n Returns\n -------\n shape: dict\n Dictionary containing the number of points for each of the\n dimension. It corresponds to :math:`m_j` for\n :math:`0 \\leq j \\leq p`.\n\n \"\"\"\n return {idx: len(dim) for idx, dim in self.argvals.items()}\n\n def as_irregular(self):\n \"\"\"Convert `self` from Dense to Irregular functional data.\n\n Coerce a DenseFunctionalData object into an IrregularFunctionalData\n object.\n\n Returns\n -------\n obj: IrregularFunctionalData\n An object of the class IrregularFunctionalData\n\n \"\"\"\n new_argvals = dict.fromkeys(self.argvals.keys(), {})\n for dim in new_argvals.keys():\n temp = {}\n for idx in range(self.n_obs):\n temp[idx] = self.argvals[dim]\n new_argvals[dim] = temp\n\n new_values = {}\n for idx in range(self.n_obs):\n new_values[idx] = self.values[idx]\n\n return IrregularFunctionalData(new_argvals, new_values)\n\n def is_compatible(self, fdata):\n \"\"\"Check if `fdata` is compatible with `self`.\n\n Two DenseFunctionalData object are said to be compatible if they\n have the same number of observations and dimensions. Moreover, they\n must have (strictly) the same sampling points.\n\n Parameters\n ----------\n fdata: DenseFunctionalData object\n The object to compare with `self`.\n\n Returns\n -------\n True\n If the objects are compatible.\n\n \"\"\"\n super().is_compatible(fdata)\n _check_argvals_equality_dense(self.argvals, fdata.argvals)\n return True\n\n def mean(self, smooth=None, **kwargs):\n \"\"\"Compute an estimate of the mean.\n\n Parameters\n ----------\n smooth: str, default=None\n Name of the smoothing method to use. Currently, not implemented.\n\n Keyword Args\n ------------\n kernel_name: str, default='epanechnikov'\n Name of the kernel used for local polynomial smoothing.\n degree: int, default=1\n Degree used for local polynomial smoothing.\n bandwidth: float, default=1\n Bandwidth used for local polynomial smoothing.\n n_basis: int, default=10\n Number of splines basis used for GAM smoothing.\n\n Returns\n -------\n obj: DenseFunctionalData object\n An estimate of the mean as a DenseFunctionalData object with the\n same argvals as `self` and one observation.\n\n \"\"\"\n mean_estim = self.values.mean(axis=0)\n\n if smooth is not None:\n argvals = self.argvals['input_dim_0']\n if self.n_dim > 1:\n raise ValueError('Only one dimensional data can be smoothed.')\n if smooth == 'LocalLinear':\n p = self.n_points['input_dim_0']\n points = kwargs.get('points', 0.5)\n neigh = kwargs.get('neighborhood',\n np.int(p * np.exp(-(np.log(np.log(p)))**2)))\n data_smooth = self.smooth(points=points,\n neighborhood=neigh)\n mean_estim = data_smooth.values.mean(axis=0)\n elif smooth == 'GAM':\n n_basis = kwargs.get('n_basis', 10)\n argvals = self.argvals['input_dim_0']\n mean_estim = pygam.LinearGAM(pygam.s(0, n_splines=n_basis)).\\\n fit(argvals, mean_estim).\\\n predict(argvals)\n elif smooth == 'SmoothingSpline':\n ss = SmoothingSpline()\n mean_estim = ss.fit_predict(argvals, mean_estim)\n else:\n raise NotImplementedError('Smoothing method not implemented.')\n return DenseFunctionalData(self.argvals, mean_estim[np.newaxis])\n\n def covariance(self, mean=None, smooth=None, **kwargs):\n \"\"\"Compute an estimate of the covariance.\n\n Parameters\n ----------\n smooth: str, default=None\n Name of the smoothing method to use. Currently, not implemented.\n mean: DenseFunctionalData, default=None\n An estimate of the mean of self. If None, an estimate is computed.\n\n Returns\n -------\n obj: DenseFunctionalData object\n An estimate of the covariance as a two-dimensional\n DenseFunctionalData object with same argvals as `self`.\n\n Keyword Args\n ------------\n kernel_name: str, default='epanechnikov'\n Name of the kernel used for local polynomial smoothing.\n degree: int, default=1\n Degree used for local polynomial smoothing.\n bandwidth: float, default=1\n Bandwidth used for local polynomial smoothing.\n n_basis: int, default=10\n Number of splines basis used for GAM smoothing.\n\n References\n ----------\n * Yao, Müller and Wang (2005), Functional Data Analysis for Sparse\n Longitudinal Data,\n Journal of the American Statistical Association, Vol. 100, No. 470\n * Staniswalis, J. G., and Lee, J. J. (1998), “Nonparametric Regression\n Analysis of Longitudinal Data,” Journal of the American Statistical\n Association, 93, 1403–1418.\n\n \"\"\"\n if self.n_dim > 1:\n raise ValueError('Only one dimensional functional data are'\n ' supported')\n\n p = self.n_points['input_dim_0']\n argvals = self.argvals['input_dim_0']\n if mean is None:\n mean = self.mean(smooth)\n data = self.values - mean.values\n cov = np.dot(data.T, data) / (self.n_obs - 1)\n cov_diag = np.copy(np.diag(cov))\n\n if smooth is not None:\n # Remove covariance diagonale because of measurement errors.\n np.fill_diagonal(cov, None)\n cov = cov[~np.isnan(cov)]\n\n # Define train vector\n train_ = np.vstack((\n np.repeat(argvals, repeats=len(argvals)),\n np.tile(argvals, reps=len(argvals)))\n )\n\n train = train_[:, train_[0, :] != train_[1, :]]\n\n if smooth == 'LocalLinear':\n points = kwargs.get('points', 0.5)\n neigh = kwargs.get('neighborhood',\n np.int(p * np.exp(-(np.log(np.log(p)))**2)))\n data_smooth = self.smooth(points=points,\n neighborhood=neigh)\n data = data_smooth.values - mean.values\n cov = np.dot(data.T, data) / (self.n_obs - 1)\n elif smooth == 'GAM':\n n_basis = kwargs.get('n_basis', 10)\n\n cov = pygam.LinearGAM(pygam.te(0, 1, n_splines=n_basis)).\\\n fit(np.transpose(train), cov).\\\n predict(np.transpose(train_)).\\\n reshape((len(argvals), len(argvals)))\n else:\n raise NotImplementedError('Smoothing method not implemented.')\n\n # Ensure the covariance is symmetric.\n cov = (cov + cov.T) / 2\n\n # Smoothing the diagonal of the covariance (Yao, Müller and Wang, 2005)\n lp = LocalPolynomial(kernel_name=kwargs.get('kernel_name', 'gaussian'),\n bandwidth=kwargs.get('bandwidth', 1),\n degree=kwargs.get('degree', 1))\n var_hat = lp.fit_predict(argvals, cov_diag, argvals)\n # Estimate noise variance (Staniswalis and Lee, 1998)\n ll = argvals[len(argvals) - 1] - argvals[0]\n lower = np.sum(~(argvals >= (argvals[0] + 0.25 * ll)))\n upper = np.sum((argvals <= (argvals[len(argvals) - 1] - 0.25 * ll)))\n weights = integration_weights_(argvals[lower:upper], method='trapz')\n nume = np.dot(weights, (var_hat - cov_diag)[lower:upper])\n self.var_noise = np.maximum(nume / argvals[upper] - argvals[lower], 0)\n\n new_argvals = {'input_dim_0': argvals, 'input_dim_1': argvals}\n return DenseFunctionalData(new_argvals, cov[np.newaxis])\n\n def smooth(self, points, neighborhood, points_estim=None, degree=0,\n kernel=\"epanechnikov\", bandwidth=None):\n \"\"\"Smooth the data.\n\n Notes\n -----\n Only, one dimensional IrregularFunctionalData can be smoothed.\n\n Parameters\n ----------\n points: np.array\n Points at which the Bandwidth is estimated.\n neighborhood: np.array\n Neighborhood considered for each each points. Should have the same\n shape than points.\n points_estim: np.array, default=None\n Points at which the curves are estimated. The default is None,\n meaning we use the argvals as estimation points.\n degree: int, default=2\n Degree for the local polynomial smoothing.\n kernel: str, default='epanechnikov'\n The name of the kernel to use.\n bandwidth: Bandwidth, default=None\n An instance of Bandwidth for the smoothing.\n\n Returns\n -------\n obj: IrregularFunctionalData\n A smoothed version of the data.\n\n \"\"\"\n if self.n_dim != 1:\n raise NotImplementedError('Only one dimensional data can be'\n ' smoothed.')\n\n data = self.as_irregular()\n data_smooth = data.smooth(points, neighborhood,\n points_estim=points_estim,\n degree=degree,\n kernel=kernel,\n bandwidth=bandwidth)\n return data_smooth.as_dense()\n\n def pairwise_distance(self, metric='euclidean'):\n \"\"\"Compute the pairwise distance between the data.\n\n Parameters\n ----------\n metric: str, default='euclidean'\n The metric to use when calculating distance between instances in a\n functional data object.\n\n Returns\n -------\n D: np.ndarray, shape=(n_obs, n_obs)\n A distance matrix D such that D_{i, j} is the distance between the\n ith and jth observations of the functional data object,\n\n \"\"\"\n if self.n_dim > 1:\n raise NotImplementedError('The distance computation is not'\n ' implemented for data with dimension'\n ' greater than 1.')\n return pairwise_distances(self.values, metric=metric)\n\n def concatenate(self, data):\n \"\"\"Concatenate two DenseFunctionalData.\n\n Parameters\n ----------\n data: DenseFunctionalData\n The data to concatenate with self.\n\n Returns\n -------\n res: DenseFunctionalData\n The concatenation of self and data.\n\n \"\"\"\n return concatenate_(self, data)\n\n\n###############################################################################\n# Class IrregularFunctionalData\n\nclass IrregularFunctionalData(FunctionalData):\n r\"\"\"A class for defining Irregular Functional Data.\n\n Parameters\n ----------\n argvals: dict\n The sampling points of the functional data. Each entry of the\n dictionary represents an input dimension. Then, each dimension is a\n dictionary where entries are the different observations. So, the\n observation :math:`i` for the dimension :math:`j` is a `np.ndarray`\n with shape :math:`(m^i_j,)` for :math:`0 \\leq i \\leq n` and\n :math:`0 \\leq j \\leq p`.\n values: dict\n The values of the functional data. Each entry of the dictionary is an\n observation of the process. And, an observation is represented by a\n `np.ndarray` of shape :math:`(n, m_1, \\dots, m_p)`. It should not\n contain any missing values.\n\n Examples\n --------\n >>> argvals = {'input_dim_0': {\n 0: np.array([1, 2, 3, 4]),\n 1: np.array([2, 4])},\n 'input_dim_1': {\n 0: np.array([5, 6, 7]),\n 1: np.array([1, 2, 3])}\n }\n\n >>> values = {0: np.array([[1, 2, 3], [4, 1, 2], [3, 4, 1], [2, 3, 4]]),\n 1: np.array([[1, 2, 3], [1, 2, 3]])}\n\n >>> IrregularFunctionalData(argvals, values)\n\n \"\"\"\n\n @staticmethod\n def _check_argvals(argvals):\n \"\"\"Check the user provided `argvals`.\"\"\"\n FunctionalData._check_argvals(argvals)\n for obj in argvals.values():\n _check_type(obj, dict)\n _check_dict_type(obj, np.ndarray)\n _check_dict_len(argvals)\n\n @staticmethod\n def _check_values(values):\n \"\"\"Check the user provided `values`.\"\"\"\n _check_type(values, dict)\n for obj in values.values():\n _check_type(obj, np.ndarray)\n\n @staticmethod\n def _check_argvals_values(argvals, values):\n \"\"\"Check the compatibility of argvals and values.\"\"\"\n _check_dict_dict(argvals, values)\n\n @staticmethod\n def _perform_computation(fdata1, fdata2, func):\n \"\"\"Perform computation defined by `func`.\"\"\"\n if fdata1.is_compatible(fdata2):\n new_values = {}\n for (idx, obs1), (_, obs2) in zip(fdata1.values.items(),\n fdata2.values.items()):\n new_values[idx] = func(obs1, obs2)\n return IrregularFunctionalData(fdata1.argvals, new_values)\n\n def __init__(self, argvals, values):\n \"\"\"Initialize IrregularFunctionalData object.\"\"\"\n super().__init__(argvals, values, 'irregular')\n\n def __getitem__(self, index):\n \"\"\"Overrride getitem function, called when self[index].\n\n Parameters\n ----------\n index: int\n The observation(s) of the object to retrive.\n\n Returns\n -------\n data: IrregularFunctionalData object\n The selected observation(s) as IrregularFunctionalData object.\n\n \"\"\"\n if isinstance(index, slice):\n indices = index.indices(self.n_obs)\n\n argvals = {}\n for idx, dim in self.argvals.items():\n argvals[idx] = {i: dim.get(i) for i in range(*indices)}\n values = {i: self.values.get(i) for i in range(*indices)}\n else:\n argvals = {idx: {index: points.get(index)}\n for idx, points in self.argvals.items()}\n values = {index: self.values.get(index)}\n return IrregularFunctionalData(argvals, values)\n\n @property\n def argvals(self):\n \"\"\"Getter for argvals.\"\"\"\n return super().argvals\n\n @argvals.setter\n def argvals(self, new_argvals):\n super(IrregularFunctionalData, self.__class__).\\\n argvals.fset(self, new_argvals)\n\n points = self.gather_points()\n argvals_stand = {}\n for dim, obss in new_argvals.items():\n max_x, min_x = np.max(points[dim]), np.min(points[dim])\n\n argvals_stand[dim] = {}\n for obs, point in obss.items():\n argvals_stand[dim][obs] = range_standardization_(point,\n max_x, min_x)\n self.argvals_stand = argvals_stand\n\n @property\n def range_obs(self):\n \"\"\"Get the range of the observations of the object.\n\n Returns\n -------\n min, max: tuple\n Tuple containing the mimimum and maximum values taken by all the\n observations for the object.\n\n \"\"\"\n ranges = [(np.min(obs), np.max(obs)) for obs in self.values.values()]\n return min(min(ranges)), max(max(ranges))\n\n @property\n def n_points(self):\n \"\"\"Get the mean number of sampling points.\n\n Returns\n -------\n n_points: dict\n A dictionary with the same shape than argavls with the number of\n sampling points along each axis.\n\n \"\"\"\n n_points = {}\n for i, points in self.argvals.items():\n n_points[i] = np.mean([len(p) for p in points.values()])\n return n_points\n\n @property\n def range_dim(self):\n \"\"\"Get the range of the `argvals` for each of the dimension.\n\n Returns\n -------\n ranges: dict\n Dictionary containing the range of the argvals for each of the\n input dimension.\n\n \"\"\"\n ranges = {idx: list(argval.values())\n for idx, argval in self.argvals.items()}\n return {idx: (min(map(min, dim)), max(map(max, dim)))\n for idx, dim in ranges.items()}\n\n @property\n def shape(self):\n r\"\"\"Get the shape of the data for each dimension.\n\n Returns\n -------\n shape: dict\n Dictionary containing the number of points for each of the\n dimension. It corresponds to :math:`m_j` for\n :math:`0 \\leq j \\leq p`.\n\n \"\"\"\n return {idx: len(dim) for idx, dim in self.gather_points().items()}\n\n def gather_points(self):\n \"\"\"Gather all the `argvals` for each of the dimensions separetely.\n\n Returns\n -------\n argvals: dict\n Dictionary containing all the unique observations points for each\n of the input dimension.\n\n \"\"\"\n return {idx: np.unique(np.hstack(list(dim.values())))\n for idx, dim in self.argvals.items()}\n\n def as_dense(self):\n \"\"\"Convert `self` from Irregular to Dense functional data.\n\n Coerce an IrregularFunctionalData object into a DenseFunctionalData\n object.\n\n Note\n ----\n We coerce an IrregularFunctionalData object into a DenseFunctionalData\n object by gathering all the sampling points from the different\n dimension into one, and set the value to `np.nan` for the not observed\n points.\n\n Returns\n -------\n obj: DenseFunctionalData\n An object of the class DenseFunctionalData\n\n \"\"\"\n new_argvals = self.gather_points()\n new_values = np.full((self.n_obs,) + tuple(self.shape.values()),\n np.nan)\n\n # Create the index definition domain for each of the observation\n index_obs = {}\n for obs in self.values.keys():\n index_obs_dim = []\n for dim in new_argvals.keys():\n _, idx, _ = np.intersect1d(new_argvals[dim],\n self.argvals[dim][obs],\n return_indices=True)\n index_obs_dim.append(idx)\n index_obs[obs] = index_obs_dim\n\n # Create mask arrays\n mask_obs = {obs: np.full(tuple(self.shape.values()), False)\n for obs in self.values.keys()}\n for obs in self.values.keys():\n mask_obs[obs][tuple(np.meshgrid(*index_obs[obs]))] = True\n\n # Assign values\n for obs in self.values.keys():\n new_values[obs][mask_obs[obs]] = self.values[obs].flatten()\n\n return DenseFunctionalData(new_argvals, new_values)\n\n def is_compatible(self, fdata):\n \"\"\"Check if `fdata` is compatible with `self`.\n\n Two IrregularFunctionalData object are said to be compatible if they\n have the same number of observations and dimensions. Moreover, they\n must have (strictly) the same sampling points.\n\n Parameters\n ----------\n fdata : IrregularFunctionalData object\n The object to compare with `self`.\n\n Returns\n -------\n True\n If the objects are compatible.\n\n \"\"\"\n super().is_compatible(fdata)\n _check_argvals_equality_irregular(self.argvals, fdata.argvals)\n return True\n\n def mean(self, smooth=None, **kwargs):\n \"\"\"Compute an estimate of the mean.\n\n Parameters\n ----------\n smooth: str, default=None\n Name of the smoothing method. Currently, not implemented.\n\n Returns\n -------\n obj: DenseFunctionalData object\n An estimate of the mean as a DenseFunctionalData object with a\n concatenation of the self.argvals as argvals and one observation.\n\n \"\"\"\n dense_self = self.as_dense()\n mean_estim = np.nanmean(dense_self.values, axis=0, keepdims=True)\n return DenseFunctionalData(dense_self.argvals, mean_estim)\n\n def covariance(self, mean=None, smooth=None, **kwargs):\n \"\"\"Compute an estimate of the covariance.\"\"\"\n pass\n\n def smooth(self, points, neighborhood, points_estim=None, degree=0,\n kernel=\"epanechnikov\", bandwidth=None):\n \"\"\"Smooth the data.\n\n Notes\n -----\n Only, one dimensional IrregularFunctionalData can be smoothed.\n\n Parameters\n ----------\n points: np.array\n Points at which the Bandwidth is estimated.\n neighborhood: np.array\n Neighborhood considered for each each points. Should have the same\n shape than points.\n points_estim: np.array, default=None\n Points at which the curves are estimated. The default is None,\n meaning we use the argvals as estimation points.\n degree: int, default=0\n Degree for the local polynomial smoothing.\n kernel: str, default='epanechnikov'\n The name of the kernel to use.\n bandwidth: Bandwidth, default=None\n An instance of Bandwidth for the smoothing.\n\n Returns\n -------\n obj: IrregularFunctionalData\n A smoothed version of the data.\n\n \"\"\"\n if self.n_dim > 1:\n raise NotImplementedError('Currently, only one dimensional data'\n ' can be smoothed.')\n\n if bandwidth is None:\n band_obj = Bandwidth(points=points, neighborhood=neighborhood)\n bandwidth = band_obj(self).bandwidths\n\n argvals = self.argvals['input_dim_0'].values()\n values = self.values.values()\n smooth_argvals, smooth_values = {}, {}\n for i, (arg, val, b) in enumerate(zip(argvals, values, bandwidth)):\n if points_estim is None:\n points_estim = arg\n\n lp = LocalPolynomial(kernel_name=kernel,\n bandwidth=b,\n degree=degree)\n pred = lp.fit_predict(arg, val, points_estim)\n smooth_argvals[i] = points_estim\n smooth_values[i] = pred\n return IrregularFunctionalData({'input_dim_0': smooth_argvals},\n smooth_values)\n\n\n###############################################################################\n# Class MultivariateFunctionalData\n\nclass MultivariateFunctionalData(UserList):\n r\"\"\"A class for defining Multivariate Functional Data.\n\n An instance of MultivariateFunctionalData is a list containing objects of\n the class DenseFunctionalData or IrregularFunctionalData.\n\n Notes\n -----\n Be careful that we will not check if all the elements have the same type.\n It is possible to create MultivariateFunctionalData containing both\n Dense and Iregular functional data. However, only this two types are\n allowed to be in the list.\n\n Parameters\n ----------\n data: list\n The list containing the elements of the MultivariateFunctionalData.\n\n \"\"\"\n\n @staticmethod\n def _check_data(new_data):\n \"\"\"Check the user provided `data`.\"\"\"\n for obj in new_data:\n _check_type(obj, (DenseFunctionalData, IrregularFunctionalData))\n _check_same_nobs(*new_data)\n\n def __init__(self, initlist=None):\n \"\"\"Initialize MultivariateFunctionalData object.\"\"\"\n self.data = initlist\n\n def __repr__(self):\n \"\"\"Override print function.\"\"\"\n return (f\"Multivariate functional data object with {self.n_functional}\"\n f\" functions of {self.n_obs} observations.\")\n\n @property\n def data(self):\n \"\"\"Getter for data.\"\"\"\n return self._data\n\n @data.setter\n def data(self, new_data):\n if new_data is not None:\n self._check_data(new_data)\n self._data = new_data\n else:\n self._data = []\n\n @property\n def n_obs(self):\n \"\"\"Get the number of observations of the functional data.\n\n Returns\n -------\n n_obs: int\n Number of observations within the functional data.\n\n \"\"\"\n return self.data[0].n_obs if len(self) > 0 else 0\n\n @property\n def n_functional(self):\n \"\"\"Get the number of functional data with `self`.\n\n Returns\n -------\n n_functional: int\n Number of functions in the list.\n\n \"\"\"\n return len(self)\n\n @property\n def n_dim(self):\n \"\"\"Get the dimension of the functional data.\n\n Returns\n -------\n dim: list\n List containing the dimension of each component in the functional\n data.\n\n \"\"\"\n return [i.n_dim for i in self]\n\n @property\n def range_obs(self):\n \"\"\"Get the range of the observations of the object.\n\n Returns\n -------\n (min, max): list of tuples\n List of tuples containing the mimimum and maximum values taken by\n all the observations for the object for each function.\n\n \"\"\"\n return [i.range_obs for i in self]\n\n @property\n def n_points(self):\n \"\"\"Get the mean number of sampling points.\n\n Returns\n -------\n n_points: list of dict\n A list of dictionary with the same shape than argvals with the\n number of sampling points along each axis for each function.\n\n \"\"\"\n return [i.n_points for i in self]\n\n @property\n def range_points(self):\n \"\"\"Get the range of the `argvals` for each of the dimension.\n\n Returns\n -------\n ranges: list of dict\n List of dictionary containing the range of the argvals for each of\n the input dimension for each function.\n\n \"\"\"\n return [i.range_dim for i in self]\n\n @property\n def shape(self):\n r\"\"\"Get the shape of the data for each dimension.\n\n Returns\n -------\n shape: list of dict\n List of dictionary containing the number of points for each of the\n dimension for each function. It corresponds to :math:`m_j` for\n :math:`0 \\leq j \\leq p`.\n\n \"\"\"\n return [i.shape for i in self]\n\n def append(self, item):\n \"\"\"Add an item to `self`.\n\n Parameters\n ----------\n item: DenseFunctionalData or IrregularFunctionalData\n Item to add.\n\n \"\"\"\n if len(self.data) == 0:\n self.data = [item]\n else:\n _check_same_nobs(self, item)\n self.data.append(item)\n\n def extend(self, other):\n \"\"\"Extend the list of FunctionalData by appending from iterable.\"\"\"\n super().extend(other)\n\n def insert(self, i, item):\n \"\"\"Insert an item `item` at a given position `i`.\"\"\"\n _check_same_nobs(self, item)\n self.data.insert(i, item)\n\n def remove(self, item):\n \"\"\"Remove the first item from `self` where value is `item`.\"\"\"\n raise NotImplementedError\n\n def pop(self, i=-1):\n \"\"\"Remove the item at the given position in the list, and return it.\"\"\"\n return super().pop(i)\n\n def clear(self):\n \"\"\"Remove all items from the list.\"\"\"\n super().clear()\n\n def index(self, item, *args):\n \"\"\"Return first item of the list equald to x.\"\"\"\n raise NotImplementedError\n\n def count(self, item):\n \"\"\"Return the number of times `item` appears in the list.\"\"\"\n raise NotImplementedError\n\n def sort(self, *args, **kwds):\n \"\"\"Sort the items of the list in place.\"\"\"\n raise NotImplementedError\n\n def reverse(self):\n \"\"\"Reserve the elements of the list in place.\"\"\"\n super().reverse()\n\n def copy(self):\n \"\"\"Return a shallow copy of the list.\"\"\"\n return super().copy()\n\n def get_obs(self):\n \"\"\"Return a generator over the observation.\"\"\"\n for idx in range(self.n_obs):\n yield MultivariateFunctionalData([obs[idx] for obs in self])\n\n def mean(self, smooth=None, **kwargs):\n \"\"\"Compute an estimate of the mean.\n\n Parameters\n ----------\n smooth: str, default=None\n Name of the smoothing method. Currently, not implemented.\n\n Returns\n -------\n obj: MultivariateFunctionalData object\n An estimate of the mean as a MultivariateFunctionalData object\n with a concatenation of the self.argvals as argvals and one\n observation.\n\n \"\"\"\n return MultivariateFunctionalData([i.mean(smooth, **kwargs)\n for i in self])\n\n def covariance(self, mean=None, smooth=None, **kwargs):\n \"\"\"Compute an estimate of the covariance.\n\n Parameters\n ----------\n smooth: str, default=None\n Name of the smoothing method to use. Currently, not implemented.\n mean: MultivariateFunctionalData, default=None\n An estimate of the mean of self. If None, an estimate is computed.\n\n Returns\n -------\n obj: MultivariateFunctionalData object\n An estimate of the covariance as a two-dimensional\n MultivariateFunctionalData object with same argvals as `self`.\n\n \"\"\"\n if mean is not None:\n return MultivariateFunctionalData(\n [i.covariance(m, smooth, **kwargs)\n for i, m in zip(self, mean)])\n else:\n return MultivariateFunctionalData(\n [i.covariance(None, smooth, **kwargs) for i in self])\n\n def concatenate(self, data):\n \"\"\"Concatenate two MultivariateFunctionalData.\n\n Parameters\n ----------\n data: MultivariateFunctionalData\n The data to concatenate with self.\n\n Returns\n -------\n res: MultivariateFunctionalData\n The concatenation of self and data.\n\n \"\"\"\n new = [data1.concatenate(data2) for data1, data2 in zip(self, data)]\n return MultivariateFunctionalData(new)\n\n\n##############################################################################\n# Functional data manipulation\n\ndef concatenate_(*data):\n \"\"\"Concatenate functional data.\n\n Compute multiple DenseFunctionalData into one. It works with higher\n dimension for the input data.\n\n Parameters\n ----------\n *data: DenseFunctionalData\n DenseFunctionalData to concatenate.\n\n Returns\n -------\n data: DenseFunctionalData\n The concatenation of the input data.\n\n Notes\n -----\n TODO :\n * Add tests, in particular check that the data are compatible.\n\n \"\"\"\n new_argvals = data[0].argvals\n new_values = np.vstack([d.values for d in data])\n return DenseFunctionalData(new_argvals, new_values)\n\n\ndef tensor_product_(data1, data2):\n \"\"\"Compute the tensor product between functional data.\n\n Compute the tensor product between all the observation of data1 with all\n the observation of data2.\n\n Parameters\n ----------\n data1: DenseFunctionalData\n First functional data.\n data2: DenseFunctionalData\n Second functional data.\n\n Returns\n -------\n data: DenseFunctionalData\n The tensor product between data1 and data2. It contains data1.n_obs *\n data2.n_obs observations.\n\n Notes\n -----\n TODO:\n * Add tests.\n\n \"\"\"\n arg = {'input_dim_0': data1.argvals['input_dim_0'],\n 'input_dim_1': data2.argvals['input_dim_0']}\n val = [outer_(i, j) for i in data1.values for j in data2.values]\n return DenseFunctionalData(arg, np.array(val))\n", "meta": {"hexsha": "6a81b83b7fa09db65fe85a6f593548c90add0d8f", "size": 45898, "ext": "py", "lang": "Python", "max_stars_repo_path": "FDApy/representation/functional_data.py", "max_stars_repo_name": "vishalbelsare/FDApy", "max_stars_repo_head_hexsha": "50feb99e34f265b1c17a6f234a9d2f942ceb8f6d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 19, "max_stars_repo_stars_event_min_datetime": "2019-02-11T08:35:29.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-27T16:51:10.000Z", "max_issues_repo_path": "FDApy/representation/functional_data.py", "max_issues_repo_name": "vishalbelsare/FDApy", "max_issues_repo_head_hexsha": "50feb99e34f265b1c17a6f234a9d2f942ceb8f6d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2020-04-07T07:10:26.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-09T16:33:19.000Z", "max_forks_repo_path": "FDApy/representation/functional_data.py", "max_forks_repo_name": "vishalbelsare/FDApy", "max_forks_repo_head_hexsha": "50feb99e34f265b1c17a6f234a9d2f942ceb8f6d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2020-04-24T13:24:02.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-18T17:28:30.000Z", "avg_line_length": 32.5287030475, "max_line_length": 79, "alphanum_fraction": 0.580548172, "include": true, "reason": "import numpy", "num_tokens": 10008, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5428632831725052, "lm_q2_score": 0.35577487985229844, "lm_q1q2_score": 0.19313711934692232}} {"text": "# -*- coding:utf-8 -*-\r\nimport numpy as np\r\nfrom random import choice\r\n\r\ndef strategy(state):\r\n \"\"\" Information provided to you:\r\n state = (board, last_move, playing, board_size)\r\n board = (x_stones, o_stones)\r\n stones is a set contains positions of one player's stones. e.g.\r\n x_stones = {(8,8), (8,9), (8,10), (8,11)}\r\n playing = 0|1, the current player's index\r\n\r\n Your strategy will return a position code for the next stone, e.g. (8,7)\r\n \"\"\"\r\n board, last_move, playing, board_size = state\r\n row = board_size\r\n col = board_size\r\n # create a table to record the board state\r\n # 1: occupied by self\r\n # 2: occupied by opponent\r\n # 0: available\r\n table = np.zeros([row, col])\r\n for i in range(row):\r\n for j in range(col):\r\n if playing == 1:\r\n if (i+1, j+1) in board[0]:\r\n table[i, j] = 2\r\n elif (i+1, j+1) in board[1]:\r\n table[i, j] = 1\r\n else:\r\n if (i+1, j+1) in board[0]:\r\n table[i, j] = 1\r\n elif (i+1, j+1) in board[1]:\r\n table[i, j] = 2\r\n # 获取该点4个方向的棋型\r\n def getstring(point):\r\n x = point[0]\r\n y = point[1]\r\n # vertical\r\n getLine1 = ''\r\n for k in range(max(x - 4, 0), min(x + 5, 15)):\r\n getLine1 += str(int(table[k, y]))\r\n if x-4<0: getLine1 = '*'+getLine1\r\n if x+4>14: getLine1 = getLine1+'*'\r\n # horizonal\r\n getLine2 = ''\r\n for k in range(max(y - 4, 0), min(y + 5, 15)):\r\n getLine2 += str(int(table[x, k]))\r\n if y-4<0: getLine2 = '*'+getLine2\r\n if y+4>14: getLine2 = getLine2+'*'\r\n # Oblique 45\r\n getLine3 = ''\r\n bx = max(0, x - 4)\r\n by = max(0, y - 4)\r\n ux = min(14, x + 4)\r\n uy = min(14, y + 4)\r\n for k in range(max(bx - x, by - y), min(ux - x, uy - y)+1):\r\n getLine3 += str(int(table[x + k, y + k]))\r\n if x-4<0 or y-4<0: getLine3 = '*'+getLine3\r\n if x+4>14 or y+4>14: getLine3 = getLine3+'*'\r\n # Oblique 135\r\n getLine4 = ''\r\n for k in range(max(bx - x, y - uy), min(ux - x, y - by)+1):\r\n getLine4 += str(int(table[x + k, y - k]))\r\n if x-4<0 or y+4>14: getLine4 = '*'+getLine4\r\n if x+4>14 or y-4<0: getLine4 = getLine4+'*'\r\n\r\n return [getLine1, getLine2, getLine3, getLine4]\r\n\r\n # 判断我方棋型\r\n def judgeType1(getline):\r\n if '11111' in getline:\r\n return 'win5'\r\n if '011110' in getline:\r\n return 'alive4'\r\n if '211110' in getline or '011112' in getline\\\r\n or '*11110' in getline or '01111*' in getline:\r\n return 'lian-rush4'\r\n if '11101' in getline or '10111' in getline\\\r\n or '11011' in getline:\r\n return 'tiao-rush4'\r\n if '001110' in getline or '011100' in getline:\r\n return 'lian-alive3'\r\n if '011010' in getline or '010110' in getline:\r\n return 'tiao-alive3'\r\n if '211100' in getline or '001112' in getline\\\r\n or '*11100' in getline or '00111*' in getline:\r\n return 'lian-sleep3'\r\n if '211010' in getline or '010112' in getline\\\r\n or '*11010' in getline or '01011*' in getline\\\r\n or '210110' in getline or '011012' in getline\\\r\n or '*10110' in getline or '01101*' in getline:\r\n return 'tiao-sleep3'\r\n if '11001' in getline or '10011' in getline\\\r\n or '10101' in getline:\r\n return 'te-sleep3'\r\n if '2011102' in getline or '*011102' in getline\\\r\n or '201110*' in getline or '*01110*' in getline:\r\n return 'jia-alive3'\r\n if '001100' in getline or '011000' in getline\\\r\n or '000110' in getline or '001010' in getline\\\r\n or '010100' in getline or '010010' in getline:\r\n return 'alive2'\r\n if '211000' in getline or '000112' in getline\\\r\n or '*11000' in getline or '00011*' in getline\\\r\n or '210100' in getline or '001012' in getline\\\r\n or '*10100' in getline or '00101*' in getline\\\r\n or '210010' in getline or '010012' in getline\\\r\n or '*10010' in getline or '01001*' in getline\\\r\n or '10001' in getline or '2010102' in getline\\\r\n or '*01010*' in getline or '201010*' in getline\\\r\n or '*010102' in getline or '2011002' in getline\\\r\n or '2001102' in getline or '*011002' in getline\\\r\n or '200110*' in getline or '201100*' in getline\\\r\n or '*001102' in getline:\r\n return 'sleep2'\r\n if '010' in getline:\r\n return 'alive1'\r\n else:\r\n return 'nothreat'\r\n\r\n # 判断对方棋型\r\n def judgeType2(getline):\r\n if '22222' in getline:\r\n return 'win5'\r\n if '022220' in getline:\r\n return 'alive4'\r\n if '122220' in getline or '022221' in getline\\\r\n or '*22220' in getline or '02222*' in getline:\r\n return 'lian-rush4'\r\n if '22202' in getline or '20222' in getline\\\r\n or '22022' in getline:\r\n return 'tiao-rush4'\r\n if '002220' in getline or '022200' in getline:\r\n return 'lian-alive3'\r\n if '022020' in getline or '020220' in getline:\r\n return 'tiao-alive3'\r\n if '122200' in getline or '002221' in getline\\\r\n or '*22200' in getline or '00222*' in getline:\r\n return 'lian-sleep3'\r\n if '122020' in getline or '020221' in getline\\\r\n or '*22020' in getline or '02022*' in getline\\\r\n or '120220' in getline or '022021' in getline\\\r\n or '*20220' in getline or '02202*' in getline:\r\n return 'tiao-sleep3'\r\n if '22002' in getline or '20022' in getline\\\r\n or '20202' in getline:\r\n return 'te-sleep3'\r\n if '1022201' in getline or '*022201' in getline\\\r\n or '102220*' in getline or '*02220*' in getline:\r\n return 'jia-alive3'\r\n if '002200' in getline or '022000' in getline\\\r\n or '000220' in getline or '002020' in getline\\\r\n or '020200' in getline or '020020' in getline:\r\n return 'alive2'\r\n if '122000' in getline or '000221' in getline\\\r\n or '*22000' in getline or '00022*' in getline\\\r\n or '120200' in getline or '002021' in getline\\\r\n or '*20200' in getline or '00202*' in getline\\\r\n or '120020' in getline or '020021' in getline\\\r\n or '*20020' in getline or '02002*' in getline\\\r\n or '20002' in getline or '1020201' in getline\\\r\n or '*02020*' in getline or '102020*' in getline\\\r\n or '*020201' in getline or '1022001' in getline\\\r\n or '1002201' in getline or '*022001' in getline\\\r\n or '100220*' in getline or '102200*' in getline\\\r\n or '*002201' in getline:\r\n return 'sleep2'\r\n if '020' in getline:\r\n return 'alive1'\r\n else:\r\n return 'nothreat'\r\n\r\n # 计算我方形势分数\r\n def evaluate_self(table):\r\n row, col = table.shape\r\n myscore = 0\r\n for i in range(row):\r\n for j in range(col):\r\n if table[i, j] == 1:\r\n point = (i, j)\r\n myType={'win5':0, 'alive4':0, 'lian-rush4':0, 'tiao-rush4':0, 'lian-alive3':0, 'tiao-alive3':0,\\\r\n 'lian-sleep3':0, 'tiao-sleep3':0, 'te-sleep3':0, 'jia-alive3':0,\\\r\n 'alive2':0, 'sleep2':0, 'alive1':0, 'nothreat':0}\r\n lines = getstring(point)\r\n for item0 in lines:\r\n tmp1 = judgeType1(item0)\r\n myType[tmp1] += 1\r\n # my score\r\n myscore += 1000000*myType['win5']+20000*myType['alive4']+ \\\r\n 6100*myType['lian-rush4']+6000*myType['tiao-rush4']+ \\\r\n 1100*myType['lian-alive3']+1000*myType['tiao-alive3']+ \\\r\n 300*myType['lian-sleep3']+290*myType['tiao-sleep3']+\\\r\n 290*myType['te-sleep3']+290*myType['jia-alive3']+\\\r\n 100*myType['alive2']+10*myType['sleep2']+\\\r\n 3*myType['alive1']+1*myType['nothreat']\r\n return myscore\r\n\r\n # 计算敌方的形势分数\r\n def evaluate_op(table):\r\n row, col = table.shape\r\n opscore = 0\r\n for i in range(row):\r\n for j in range(col):\r\n if table[i, j] == 2:\r\n point = (i, j)\r\n opType = {'win5':0, 'alive4':0, 'lian-rush4':0, 'tiao-rush4':0, 'lian-alive3':0, 'tiao-alive3':0,\\\r\n 'lian-sleep3':0, 'tiao-sleep3':0, 'te-sleep3':0, 'jia-alive3':0,\\\r\n 'alive2':0, 'sleep2':0, 'alive1':0, 'nothreat':0}\r\n lines = getstring(point)\r\n for item0 in lines:\r\n tmp2 = judgeType2(item0)\r\n opType[tmp2] += 1\r\n # opponent score\r\n opscore += 1000000*opType['win5']+100000*opType['alive4']+ \\\r\n 65000*opType['lian-rush4']+65000*opType['tiao-rush4']+ \\\r\n 5500*opType['lian-alive3']+5000*opType['tiao-alive3']+ \\\r\n 200*opType['lian-sleep3']+200*opType['tiao-sleep3']+\\\r\n 200*opType['te-sleep3']+200*opType['jia-alive3']+\\\r\n 90*opType['alive2']+9*opType['sleep2']+\\\r\n 4*opType['alive1']+1*opType['nothreat']\r\n return opscore\r\n \r\n \r\n #随机返回一个score最大的位置\r\n def randomChoose(scoretable):\r\n maxValue = max(scoretable.items(), key=lambda x: x[1])[1]\r\n positions=[]\r\n for item in scoretable.items():\r\n if item[1]==maxValue:\r\n positions.append(item[0])\r\n return choice(positions)\r\n \r\n\r\n if len(board[0]) == 0 and len(board[1]) == 0:\r\n return (board_size/2 + 1, board_size/2 + 1)\r\n else:\r\n # 获得局部搜索区域的下标\r\n sumBoard = board[0] | board[1]\r\n xmax = min(max(sumBoard, key=lambda x: x[0])[0] + 2, 15)\r\n ymax = min(max(sumBoard, key=lambda x: x[1])[1] + 2, 15)\r\n xmin = max(min(sumBoard, key=lambda x: x[0])[0] - 3, 0)\r\n ymin = max(min(sumBoard, key=lambda x: x[1])[1] - 3, 0)\r\n\r\n scoretable={}\r\n for i in range(xmin, xmax):\r\n for j in range(ymin, ymax):\r\n if table[i, j] == 0:\r\n #old = evaluate_self(table)-defend*evaluate_op(table)\r\n table[i, j] = 1\r\n scoretable[(i, j)] = evaluate_self(table)-evaluate_op(table)\r\n table[i, j] = 0\r\n self_position = randomChoose(scoretable)\r\n return (self_position[0]+1, self_position[1]+1)\r\n\r\n\r\ndef finish():\r\n pass\r\n", "meta": {"hexsha": "8da52add28d251ada90d53d673a9d9608e352446", "size": 11281, "ext": "py", "lang": "Python", "max_stars_repo_path": "AI5.py", "max_stars_repo_name": "TianxiaoHu/GomokuAgent", "max_stars_repo_head_hexsha": "8cb05025059945692846cbb0541a834e9f985ce2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 15, "max_stars_repo_stars_event_min_datetime": "2017-06-29T07:47:12.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-09T05:33:59.000Z", "max_issues_repo_path": "AI5.py", "max_issues_repo_name": "TianxiaoHu/GomokuAgent", "max_issues_repo_head_hexsha": "8cb05025059945692846cbb0541a834e9f985ce2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "AI5.py", "max_forks_repo_name": "TianxiaoHu/GomokuAgent", "max_forks_repo_head_hexsha": "8cb05025059945692846cbb0541a834e9f985ce2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-12-01T07:53:48.000Z", "max_forks_repo_forks_event_max_datetime": "2019-12-01T07:53:48.000Z", "avg_line_length": 43.555984556, "max_line_length": 119, "alphanum_fraction": 0.4823153976, "include": true, "reason": "import numpy", "num_tokens": 3197, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5428632831725052, "lm_q2_score": 0.3557748798522984, "lm_q1q2_score": 0.19313711934692226}} {"text": "import numpy as np\nimport matplotlib.pyplot as plt\nimport matplotlib.colors as colors\nimport matplotlib.cm as cm\nimport pandas as pd\nimport re\nimport io\nimport os\nimport astropy.constants as cst\nimport astropy.units as units\nimport scipy.interpolate as interp\n\nfrom collections import deque\nfrom pathlib import Path \n\n\n#######################################\n# model loading functions\n#\ndef _read_model_BHAC2015(path, fname, instrument):\n '''\n (Private) Read the BHAC2015 models\n\n Parameters\n ----------\n path : str\n Full path to the directory containing the model files\n\n fname : str\n Full model file name\n\n instrument : str\n Name of the instrument (or observatory) for the file\n\n Returns\n -------\n masses : vector\n Numpy vector with unique masses, in MJup\n\n ages : vector\n Numpy vector with unique ages, in Myr\n\n values : array\n Array with names of parameters\n\n data : array\n Numpy data array\n '''\n \n # read general data\n data = pd.read_csv(path / fname, sep='\\s+', header=None, comment='!')\n\n # add ages\n data.insert(0, 'age', 0)\n\n # read column headers and age values\n p_cols = re.compile('!\\s+(mass)\\s+(Teff)')\n p_ages = re.compile('!\\s+t\\s+\\(Gyr\\)\\s+=\\s+([0-9]+\\.[0-9]+)')\n p_vals = re.compile('\\s+([0-9]+\\.[0-9]+)\\s+([0-9]+\\.[0-9]+)')\n\n cols = ['age']\n ages = []\n cage = 0\n\n file = open(path / fname, 'r')\n for line in file:\n # skip non-comment lines\n if (line[0] != '!'):\n m = p_vals.match(line)\n if (m is not None):\n ages.append(cage)\n continue\n\n # column names\n if (len(cols) == 1):\n m = p_cols.match(line)\n if (m is not None):\n cols.extend(line[1:].split())\n\n # age value\n m = p_ages.match(line)\n if (m is not None):\n cage = float(m.group(1))\n\n file.close()\n\n # rename columns and add age values\n data.columns = cols \n data.age = ages\n\n # unit conversion\n data.age *= 1000\n data.mass *= cst.M_sun / cst.M_jup\n data.radius *= cst.R_sun / cst.R_jup\n \n # reshape in final format\n masses, ages, values, dat = _reshape_data(data)\n\n return masses, ages, values, dat\n\n\ndef _read_model_PHOENIX_websim(path, fname, instrument):\n '''\n (Private) Read models from the PHOENIX web simulator\n\n Parameters\n ----------\n path : str\n Full path to the directory containing the model files\n\n fname : str\n Full model file name\n\n instrument : str\n Name of the instrument (or observatory) for the file\n\n Returns\n -------\n masses : vector\n Numpy vector with unique masses, in MJup\n\n ages : vector\n Numpy vector with unique ages, in Myr\n\n values : array\n Array with names of parameters\n\n data : array\n Numpy data array\n '''\n\n # read column headers and number of values\n p_cols = re.compile('\\s+M/Ms\\s*Teff.K.\\s+L/Ls\\s+lg\\(g\\)\\s+R.(\\w+).\\s+D\\s+Li\\s+([A-Za-z0-9\\\\s_.\\']+)')\n p_ages = re.compile('\\s+t\\s+\\(Gyr\\)\\s+=\\s+([0-9]+\\.[0-9]+)')\n p_vals = re.compile('(\\s+[+-]*[0-9]+\\.[0-9]*){3}')\n\n cols = ['age', 'mass', 'Teff', 'logL', 'logg', 'radius', 'D', 'Li']\n cage = 0\n ages = []\n unit = None\n lines = []\n \n # get column names\n file = open(path / fname, 'r')\n for line in file:\n # age value\n m = p_ages.match(line)\n if (m is not None): \n cage = float(m.group(1))\n continue\n \n # column names\n if (len(cols) == 8):\n m = p_cols.match(line)\n if (m is not None):\n unit = m.group(1)\n\n names = m.group(2)\n names = names.replace(\"'\", \"p\")\n \n cols.extend(names.split())\n \n continue\n \n # model values\n m = p_vals.match(line)\n if (m is not None):\n lines.append(line)\n ages.append(cage)\n \n file.close()\n \n # create data frame\n lines = ''.join(lines)\n data = pd.read_csv(io.StringIO(lines), sep='\\s+', header=None)\n\n # add ages\n data.insert(0, 'age', 0)\n data.age = ages\n\n # rename columns\n data.columns = cols \n \n # unit conversion\n data.age *= 1000\n data.mass *= cst.M_sun / cst.M_jup\n if unit == 'Gm':\n # data.radius /= cst.R_jup.to(units.Gm)\n pass\n elif unit == 'Gcm':\n #data.radius /= cst.R_jup.to(units.Gm*100)\n pass\n else:\n pass\n \n # reshape in final format\n masses, ages, values, dat = _reshape_data(data)\n \n return masses, ages, values, dat\n\n\ndef _read_model_sonora(path, fname, instrument):\n '''\n (Private) Read the SONORA models\n\n Parameters\n ----------\n path : str\n Full path to the directory containing the model files\n\n fname : str\n Full model file name\n\n instrument : str\n Name of the instrument (or observatory) for the file\n\n Returns\n -------\n masses : vector\n Numpy vector with unique masses, in MJup\n\n ages : vector\n Numpy vector with unique ages, in Myr\n\n values : array\n Array with names of parameters\n\n data : array\n Numpy data array\n '''\n\n df = pd.read_csv(path / fname, index_col=(0, 1))\n\n masses = np.sort(np.unique(df.index.get_level_values(0))) # MJup\n ages = np.sort(np.unique(df.index.get_level_values(1))) # yr\n values = df.columns\n\n data = np.zeros((len(masses), len(ages), len(values)))\n for iv, val in enumerate(values):\n for im, mass in enumerate(masses):\n tmp = df.loc[(mass, slice(None)), val]\n data[im, :, iv] = tmp\n \n # converts ages in Myr\n ages = ages / 1e6\n \n return masses, ages, values, data\n\n\ndef _read_model_bex(path, fname, instrument):\n '''\n (Private) Read the BEX models\n\n Parameters\n ----------\n path : str\n Full path to the directory containing the model files\n\n fname : str\n Full model file name\n\n instrument : str\n Name of the instrument (or observatory) for the file\n\n Returns\n -------\n masses : vector\n Numpy vector with unique masses, in MJup\n\n ages : vector\n Numpy vector with unique ages, in Myr\n\n values : array\n Array with names of parameters\n\n data : array\n Numpy data array\n '''\n\n df = pd.read_csv(path / fname, index_col=(0, 1))\n\n masses = np.sort(np.unique(df.index.get_level_values(0))) # MJup\n ages = np.sort(np.unique(df.index.get_level_values(1))) # yr\n values = df.columns\n\n data = np.zeros((len(masses), len(ages), len(values)))\n for iv, val in enumerate(values):\n for im, mass in enumerate(masses):\n tmp = df.loc[(mass, slice(None)), val]\n data[im, :, iv] = tmp\n \n # converts ages in Myr\n ages = ages / 1e6\n \n return masses, ages, values, data\n\n \ndef _read_model_atmo(path, fname, instrument):\n '''\n (Private) Read the ATMO models\n\n Parameters\n ----------\n path : str\n Full path to the directory containing the model files\n\n fname : str\n Full model file name\n\n instrument : str\n Name of the instrument (or observatory) for the file\n\n Returns\n -------\n masses : vector\n Numpy vector with unique masses, in MJup\n\n ages : vector\n Numpy vector with unique ages, in Myr\n\n values : array\n Array with names of parameters\n\n data : array\n Numpy data array\n '''\n\n df = pd.read_csv(path / fname, index_col=(0, 1))\n\n masses = np.sort(np.unique(df.index.get_level_values(0))) # MJup\n ages = np.sort(np.unique(df.index.get_level_values(1))) # yr\n values = df.columns\n\n data = np.zeros((len(masses), len(ages), len(values)))\n for iv, val in enumerate(values):\n for im, mass in enumerate(masses):\n tmp = df.loc[(mass, slice(None)), val]\n data[im, :, iv] = tmp\n \n # converts ages in Myr\n ages = ages / 1e6\n \n return masses, ages, values, data\n\n \ndef _reshape_data(dataframe):\n '''\n Reshape the data frame in a regular grid that can be used as input in scipy functions.\n\n Parameters\n ----------\n dataframe : pandas DataFrame\n Data frame with all the data\n\n Returns\n -------\n masses : vector\n Numpy vector with unique masses, in MJup\n\n ages : vector\n Numpy vector with unique ages, in Myr\n\n values : array\n Array with names of parameters\n\n data : array\n Numpy data array\n '''\n\n # unique ages and masses\n masses = dataframe.mass.unique()\n ages = dataframe.age.unique()\n\n # values\n values = dataframe.columns.values[2:]\n\n # fill array\n data = np.full((masses.size, ages.size, values.size), np.nan)\n for m, mass in enumerate(masses):\n for a, age in enumerate(ages):\n mask = (dataframe.mass == mass) & (dataframe.age == age)\n \n if mask.any():\n data[m, a, :] = dataframe.loc[mask, 'Teff':].values.squeeze()\n\n return masses, ages, values, data\n\n\n#######################################\n# utility functions\n#\ndef _monotonic_sublists(lst):\n '''\n (Private) Extract monotonic sublists from a list of values\n \n Given a list of values that is not sorted (such that for some valid\n indices i,j, i lst[j]), produce a new\n list-of-lists, such that in the new list, each sublist *is*\n sorted: for all sublist \\elem returnval: assert_is_sorted(sublist)\n and furthermore this is the minimal set of sublists required to\n achieve the condition.\n\n Thus, if the input list lst is actually sorted, this returns\n [list(lst)].\n\n Parameters\n ----------\n lst : list or array\n List of values\n\n Returns\n -------\n ret_i : list\n List of indices of monotonic sublists\n \n ret_v : list\n List of values of monotonic sublists\n '''\n\n # Make a copy of lst before modifying it; use a deque so that\n # we can pull entries off it cheaply.\n idx = deque(range(len(lst)))\n deq = deque(lst)\n ret_i = []\n ret_v = []\n while deq:\n sub_i = [idx.popleft()]\n sub_v = [deq.popleft()]\n\n if len(deq) > 1:\n if deq[0] <= sub_v[-1]:\n while deq and deq[0] <= sub_v[-1]:\n sub_i.append(idx.popleft())\n sub_v.append(deq.popleft())\n else:\n while deq and deq[0] >= sub_v[-1]:\n sub_i.append(idx.popleft())\n sub_v.append(deq.popleft())\n \n ret_i.append(sub_i)\n ret_v.append(sub_v)\n \n return ret_i, ret_v\n\n\ndef _interpolate_model(masses, ages, values, data, age, filt, param, Mabs, fill):\n '''\n (Private) Interpolate model grid\n\n Parameters\n ----------\n masses : array\n Mass values in the model grid\n\n ages : array\n Age values in the model grid\n \n values : array\n Name of filters (and other parameters) in the model grid\n\n data : array\n Data of the model grid\n\n age : float\n Age at which interpolation is needed\n\n filt : str\n Filter in which the magnitude is provided\n\n param : str\n Parameter to be interpolated\n\n Mabs : array\n Absolute magnitude\n\n fill : bool\n Fill interpolated values with min/max values in the models when\n trying to interpolate outside the values in the models\n \n Returns\n -------\n values : array\n Interpolated values\n '''\n\n # age indices\n ii = np.abs(ages-age).argmin()\n if age <= ages[ii]:\n imin = ii-1\n imax = ii\n elif age > ages[ii]:\n imin = ii\n imax = ii+1\n\n agemin = ages[imin]\n agemax = ages[imax]\n \n # parameter value\n if param == 'Mass':\n ifilt = np.where(values == filt)[0]\n\n Zmin = data[:, imin, ifilt].squeeze()\n Zmax = data[:, imax, ifilt].squeeze()\n\n Znew = (Zmin - Zmax) / (agemin - agemax) * (age - agemin) + Zmin\n\n # remove missing values\n masses = masses[np.isfinite(Znew)]\n Znew = Znew[np.isfinite(Znew)]\n \n # find monotonic parts of the signal\n mono_i, mono_v = _monotonic_sublists(Znew)\n \n nsub = len(mono_i)\n sub_idx = np.zeros((2*nsub-1, 2), dtype=np.int)\n for s in range(nsub):\n sub_idx[s, 0] = mono_i[s][0]\n sub_idx[s, 1] = mono_i[s][-1]\n for s in range(nsub-1):\n sub_idx[s+nsub, 0] = mono_i[s][-1]\n sub_idx[s+nsub, 1] = mono_i[s+1][0]\n\n sub_idx = np.sort(sub_idx, axis=0)\n\n # interpolate over each part\n values = np.zeros((2*nsub-1, Mabs.size))\n for i, s in enumerate(sub_idx):\n sub_Znew = Znew[s[0]:s[1]+1]\n sub_masses = masses[s[0]:s[1]+1]\n\n if len(sub_Znew) < 2:\n continue\n \n interp_func = interp.interp1d(sub_Znew, sub_masses, bounds_error=False, fill_value=np.nan)\n values[i] = interp_func(Mabs)\n\n # fill if outside of available values\n if fill:\n values[i, Mabs < sub_Znew.min()] = masses.max()\n values[i, Mabs > sub_Znew.max()] = masses.min()\n \n # combine\n values = np.nanmax(values, axis=0)\n else:\n raise ValueError('Interpolation for parameter {0} is not implemented yet.'.format(param))\n\n return values\n\n\ndef _read_model_data(paths, models, instrument, model):\n '''\n Return the data from a model and instrument\n\n Parameters\n ----------\n paths : list\n List of paths where to find the models\n\n models : dict\n Dictionary containing all the models information and data\n\n instrument : str\n Instrument name\n\n model : str\n Model name\n\n Returns\n -------\n path : str\n The complete path to the model file\n '''\n\n # lower case\n model = model.lower()\n instrument = instrument.lower()\n \n # model key\n key = instrument.lower()+'_'+model.lower()\n\n # find proper model\n data = None\n for mod in models['properties']:\n if (mod['name'] == model) and (mod['instrument'] == instrument):\n fname = mod['file']\n \n # search for path\n found = False\n for path in paths:\n if (path / fname).exists():\n mod['path'] = path\n found = True\n break\n\n if not found:\n raise ValueError('File {0} for model {1} and instrument {2} does not exists. Are you sure it is in your search path?'.format(path, model, instrument))\n \n # get data in format (masses, ages, values, data)\n data = mod['function'](path, fname, instrument)\n\n # not found\n if data is None:\n raise ValueError('Could not find model {0} for instrument {1}'.format(model, instrument))\n\n # save data\n models['data'][key] = data\n\n \n#######################################\n# models definitions\n#\nsearch_path = [(Path(__file__) / '../../data/evolution/').resolve()]\nmodels = {\n 'properties': [\n {'instrument': 'nicmos', 'name': 'dusty2000', 'file': 'model.AMES-dusty-2000.M-0.0.HST', 'function': _read_model_PHOENIX_websim},\n {'instrument': 'naco', 'name': 'dusty2000', 'file': 'model.AMES-dusty-2000.M-0.0.NaCo', 'function': _read_model_PHOENIX_websim},\n {'instrument': 'irdis', 'name': 'dusty2000', 'file': 'model.AMES-dusty-2000.M-0.0.SPHERE.Vega', 'function': _read_model_PHOENIX_websim},\n {'instrument': 'nicmos', 'name': 'cond2003', 'file': 'model.AMES-Cond-2003.M-0.0.HST', 'function': _read_model_PHOENIX_websim},\n {'instrument': 'naco', 'name': 'cond2003', 'file': 'model.AMES-Cond-2003.M-0.0.NaCo', 'function': _read_model_PHOENIX_websim},\n {'instrument': 'irdis', 'name': 'cond2003', 'file': 'model.AMES-Cond-2003.M-0.0.SPHERE.Vega', 'function': _read_model_PHOENIX_websim}, \n {'instrument': 'irdis', 'name': 'bhac2015+dusty2000', 'file': 'BHAC15_DUSTY00_iso_t10_10.SPHERE', 'function': _read_model_BHAC2015},\n {'instrument': 'irdis', 'name': 'bhac2015+cond2003', 'file': 'BHAC15_COND03_iso_t10_10.SPHERE', 'function': _read_model_BHAC2015},\n \n {'instrument': 'mko', 'name': 'sonora', 'file': 'sonora_mko.csv.gz', 'function': _read_model_sonora},\n {'instrument': '2mass', 'name': 'sonora', 'file': 'sonora_2mass.csv.gz', 'function': _read_model_sonora},\n {'instrument': 'keck', 'name': 'sonora', 'file': 'sonora_keck.csv.gz', 'function': _read_model_sonora},\n {'instrument': 'sdss', 'name': 'sonora', 'file': 'sonora_sdss.csv.gz', 'function': _read_model_sonora},\n {'instrument': 'irac', 'name': 'sonora', 'file': 'sonora_irac.csv.gz', 'function': _read_model_sonora},\n {'instrument': 'wise', 'name': 'sonora', 'file': 'sonora_wise.csv.gz', 'function': _read_model_sonora}, \n \n {'instrument': 'irdis', 'name': 'bex_cond_coldest', 'file': 'bex_ames-cond_coldest.csv.gz', 'function': _read_model_bex},\n {'instrument': 'irdis', 'name': 'bex_cond_warm', 'file': 'bex_ames-cond_warm.csv.gz', 'function': _read_model_bex},\n {'instrument': 'irdis', 'name': 'bex_cond_hot', 'file': 'bex_ames-cond_hot.csv.gz', 'function': _read_model_bex},\n {'instrument': 'irdis', 'name': 'bex_cond_hottest', 'file': 'bex_ames-cond_hottest.csv.gz', 'function': _read_model_bex},\n {'instrument': 'irdis', 'name': 'bex_dusty_coldest', 'file': 'bex_ames-dusty_coldest.csv.gz', 'function': _read_model_bex},\n {'instrument': 'irdis', 'name': 'bex_dusty_warm', 'file': 'bex_ames-dusty_warm.csv.gz', 'function': _read_model_bex},\n {'instrument': 'irdis', 'name': 'bex_dusty_hot', 'file': 'bex_ames-dusty_hot.csv.gz', 'function': _read_model_bex},\n {'instrument': 'irdis', 'name': 'bex_dusty_hottest', 'file': 'bex_ames-dusty_hottest.csv.gz', 'function': _read_model_bex},\n\n {'instrument': 'mko', 'name': 'atmo_ceq', 'file': 'ATMO_CEQ_MKO.csv.gz', 'function': _read_model_atmo},\n {'instrument': 'mko', 'name': 'atmo_neq_strong', 'file': 'ATMO_NEQ_strong_MKO.csv.gz', 'function': _read_model_atmo},\n {'instrument': 'mko', 'name': 'atmo_neq_weak', 'file': 'ATMO_NEQ_weak_MKO.csv.gz', 'function': _read_model_atmo},\n {'instrument': 'irac', 'name': 'atmo_ceq', 'file': 'ATMO_CEQ_MKO.csv.gz', 'function': _read_model_atmo},\n {'instrument': 'irac', 'name': 'atmo_neq_strong', 'file': 'ATMO_NEQ_strong_MKO.csv.gz', 'function': _read_model_atmo},\n {'instrument': 'irac', 'name': 'atmo_neq_weak', 'file': 'ATMO_NEQ_weak_MKO.csv.gz', 'function': _read_model_atmo},\n {'instrument': 'wise', 'name': 'atmo_ceq', 'file': 'ATMO_CEQ_MKO.csv.gz', 'function': _read_model_atmo},\n {'instrument': 'wise', 'name': 'atmo_neq_strong', 'file': 'ATMO_NEQ_strong_MKO.csv.gz', 'function': _read_model_atmo},\n {'instrument': 'wise', 'name': 'atmo_neq_weak', 'file': 'ATMO_NEQ_weak_MKO.csv.gz', 'function': _read_model_atmo},\n ],\n 'data': {}\n}\n\n\n#######################################\n# public functions\n#\ndef mag_to_mass(age, distance, mag, Dmag, filt,\n instrument='IRDIS', model='bhac2015+cond2003', fill=False,\n age_range=None, distance_range=None, mag_err=None, Dmag_range=None):\n '''\n Convert a contrast value into mass\n\n Parameters\n ----------\n age : float\n Age of the target in Myr\n\n distance : float\n Distance of the target in pc\n\n mag : float\n Magnitude of the target in the filter\n\n Dmag : array\n Contrast value(s) in the filter\n\n filt : str\n Name of the filter\n\n instrument : str\n Name of the instrument. The default is IRDIS\n\n model : str\n Name of the evolutionary model. The default is bhac2015+cond2003\n\n fill : bool\n Fill interpolated values with min/max values in the models when\n trying to interpolate outside the values in the models\n \n age_range : list\n [min, max] age estimations for the target\n\n distance_range : list\n [min, max] distance estimations for the target\n\n mag_err : float\n Error on the target magnitude\n\n Dmag_range : array\n [min, max] contrast estimations\n\n Returns\n -------\n mass, mass_min, mass_max : array\n Values of the mass interpolated into the model\n ''' \n \n # -------------------------------\n # get model data\n # -------------------------------\n masses, ages, values, data = model_data(instrument, model)\n\n # check ages\n if (age < ages.min()) or (age > ages.max()):\n raise ValueError('Age {0} Myr outside of model range [{1}, {2}]'.format(age, ages.min(), ages.max()))\n\n # check filter\n if filt not in values:\n raise ValueError('Filter {0} not available in list: {1}'.format(filt, values))\n \n # -------------------------------\n # explicit variable names\n # -------------------------------\n \n # age range\n if age_range is not None:\n if not isinstance(age_range, list):\n raise ValueError('Age range must be a 2-elements array')\n\n age_min = np.min(age_range)\n age_max = np.max(age_range)\n else:\n age_min = age\n age_max = age\n \n # dist range\n if distance_range is not None:\n if not isinstance(distance_range, list):\n raise ValueError('Dist range must be a 2-elements array')\n\n dist_min = np.min(distance_range)\n dist_max = np.max(distance_range)\n else:\n dist_min = distance\n dist_max = distance\n\n # Stellar mag range\n if mag_err is not None:\n if not isinstance(mag_err, (int, float)):\n raise ValueError('Stellar mag error must be a float')\n\n mag_min = mag - mag_err\n mag_max = mag + mag_err\n else:\n mag_min = mag\n mag_max = mag\n\n # delta mag range\n if Dmag_range is not None:\n raise ValueError('Dmag error not implemented')\n else:\n Dmag_faint = Dmag\n Dmag_bright = Dmag\n\n # -------------------------------\n # absolute magnitude conversion\n # -------------------------------\n\n # nominal values\n Mabs_nom = mag - 5*np.log10(distance) + 5 + Dmag\n\n # taking errors into account\n Mabs_faint = mag_min - 5*np.log10(dist_min) + 5 + Dmag_faint\n Mabs_bright = mag_max - 5*np.log10(dist_max) + 5 + Dmag_bright\n\n # -------------------------------\n # interpolate models\n # -------------------------------\n param = 'Mass' # only parameter currently available\n values_nom = _interpolate_model(masses, ages, values, data, age, filt, param, Mabs_nom, fill)\n values_min = _interpolate_model(masses, ages, values, data, age_min, filt, param, Mabs_faint, fill)\n values_max = _interpolate_model(masses, ages, values, data, age_max, filt, param, Mabs_bright, fill)\n \n values_all = np.vstack((values_min, values_nom, values_max))\n values_min = np.nanmin(values_all, axis=0)\n values_max = np.nanmax(values_all, axis=0)\n \n return values_nom, values_min, values_max\n\n\ndef list_models():\n '''\n Print the list of available models\n '''\n print()\n print('Search paths:')\n for p in search_path:\n print(' * {}'.format(p))\n print()\n\n for i in range(len(models['properties'])):\n prop = models['properties'][i]\n \n print(prop['file'])\n print(' * instrument: {0}'.format(prop['instrument']))\n print(' * name: {0}'.format(prop['name']))\n print(' * function: {0}'.format(prop['function'].__name__))\n try:\n print(' * path: {0}'.format(prop['path']))\n except KeyError:\n pass\n print()\n\n\ndef model_data(instrument, model):\n '''\n Return the model data for a given instrument\n\n Directly returns the data if it has been read and stored\n already. Otherwise read and store it before returning.\n \n Parameters\n ----------\n instrument : str\n Instrument name\n\n model : str\n Model name\n\n Returns\n -------\n data : tuple \n Tuple (masses, ages, values, data)\n '''\n \n # model key\n key = instrument.lower()+'_'+model.lower()\n\n if key not in models['data'].keys():\n print('Loading model {0} for {1}'.format(model, instrument))\n \n _read_model_data(search_path, models, instrument, model)\n\n return models['data'][key]\n\n\ndef add_search_path(path):\n '''\n Add a new location in the search path\n\n Useful to easily handle \"private\" models that are not provided\n with the public distribution of the package.\n\n Parameters\n ----------\n path : str\n Path to the additional directory\n '''\n \n path = Path(path).expanduser().resolve()\n \n # add only if necessary\n if path not in search_path:\n search_path.append(path)\n\n\ndef plot_model(instrument, model, param, age_list=None, mass_list=None):\n '''\n Plot parameter evolution as a function of age for a model and instrument\n\n Parameters\n ----------\n instrument : str\n Instrument name\n\n model : str\n Model name\n\n param : str\n Parameter of the model to be plotted\n \n age_list : array\n List of ages to use for the plots. Default is None, so it will \n use all available ages\n\n mass_list : array\n List of masses to use for the plots. Default is None, so it will \n use all available masses\n\n Returns\n -------\n path : str\n The complete path to the model file\n '''\n \n masses, ages, values, data = model_data(instrument, model)\n\n if not mass_list:\n mass_list = masses\n \n if not age_list:\n age_list = ages\n\n cmap = cm.plasma\n norm = colors.LogNorm(vmin=ages.min(), vmax=ages.max())\n \n #\n # param vs. age\n #\n fig = plt.figure(0, figsize=(12, 9))\n plt.clf()\n ax = fig.add_subplot(111)\n \n for mass in mass_list:\n if (mass <= 75):\n ax.plot(ages, data[masses == mass, :, values == param].squeeze(), \n label=r'{0:.1f} MJup'.format(mass), color=cmap(mass/75.))\n\n ax.set_xscale('log')\n ax.set_yscale('linear')\n \n ax.set_xlabel('Age [Myr]')\n ax.set_ylabel(param)\n\n ax.set_title('{0}, {1}'.format(model, instrument))\n \n ax.legend(loc='upper right')\n \n plt.tight_layout()\n\n #\n # param vs. mass\n #\n fig = plt.figure(1, figsize=(12, 9))\n plt.clf()\n ax = fig.add_subplot(111)\n \n for age in age_list:\n ax.plot(masses, data[:, ages == age, values == param].squeeze(), \n label=r'{0:.4f} Myr'.format(age), color=cmap(norm(age)))\n\n ax.set_xlim(0, 75)\n \n ax.set_xscale('linear')\n ax.set_yscale('linear')\n \n ax.set_xlabel(r'Mass [$M_{Jup}$]')\n ax.set_ylabel(param)\n\n ax.set_title('{0}, {1}'.format(model, instrument))\n \n # ax.legend(loc='upper right')\n \n plt.tight_layout()\n", "meta": {"hexsha": "659ac05c64390ed70684639ba43dc8691977bf51", "size": 28057, "ext": "py", "lang": "Python", "max_stars_repo_path": "vigan/astro/evolution.py", "max_stars_repo_name": "avigan/Python-utils", "max_stars_repo_head_hexsha": "360d6326e8336c624ab35755ae1827ebcdc71b33", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "vigan/astro/evolution.py", "max_issues_repo_name": "avigan/Python-utils", "max_issues_repo_head_hexsha": "360d6326e8336c624ab35755ae1827ebcdc71b33", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2017-08-23T13:40:34.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-25T10:11:23.000Z", "max_forks_repo_path": "vigan/astro/evolution.py", "max_forks_repo_name": "avigan/Python-utils", "max_forks_repo_head_hexsha": "360d6326e8336c624ab35755ae1827ebcdc71b33", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2017-10-26T08:06:19.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-25T09:09:18.000Z", "avg_line_length": 29.3790575916, "max_line_length": 166, "alphanum_fraction": 0.554514025, "include": true, "reason": "import numpy,import scipy,import astropy", "num_tokens": 7258, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.588889130767832, "lm_q2_score": 0.32766830738621877, "lm_q1q2_score": 0.19296030471683717}} {"text": "import numpy as np\nimport os\nimport copy\nimport galsim\nfrom galsim import DeVaucouleurs\nfrom galsim import Exponential\nimport descwl\n\nfrom .shifts import get_shifts, get_pair_shifts\nfrom .constants import SCALE\nfrom .cache_tools import cached_catalog_read\n\n\nDEFAULT_FIXED_GAL_CONFIG = {\n \"mag\": 17.0,\n \"hlr\": 0.5,\n \"morph\": \"exp\",\n}\n\n\ndef make_galaxy_catalog(\n *,\n rng,\n gal_type,\n coadd_dim=None,\n buff=0,\n layout=None,\n gal_config=None,\n sep=None,\n):\n \"\"\"\n rng: numpy.random.RandomState\n Numpy random state\n gal_type: string\n 'fixed', 'varying' or 'wldeblend'\n coadd_dim: int\n Dimensions of coadd\n buff: int, optional\n Buffer around the edge where no objects are drawn. Ignored for\n layout 'grid'. Default 0.\n layout: string, optional\n 'grid' or 'random'. Ignored for gal_type \"wldeblend\", otherwise\n required.\n gal_config: dict or None\n Can be sent for fixed galaxy catalog. See DEFAULT_FIXED_GAL_CONFIG\n for defaults mag, hlr and morph\n sep: float, optional\n Separation of pair in arcsec for layout='pair'\n \"\"\"\n if layout == 'pair':\n if sep is None:\n raise ValueError(\n f'send sep= for gal_type {gal_type} and layout {layout}'\n )\n gal_config = get_fixed_gal_config(config=gal_config)\n\n if gal_type in ['fixed', 'exp']: # TODO remove exp\n cls = FixedPairGalaxyCatalog\n else:\n cls = PairGalaxyCatalog\n\n galaxy_catalog = cls(\n rng=rng,\n mag=gal_config['mag'],\n hlr=gal_config['hlr'],\n morph=gal_config['morph'],\n sep=sep,\n )\n\n else:\n if coadd_dim is None:\n raise ValueError(\n f'send coadd_dim= for gal_type {gal_type} and layout {layout}'\n )\n\n if gal_type == 'wldeblend':\n galaxy_catalog = WLDeblendGalaxyCatalog(\n rng=rng,\n coadd_dim=coadd_dim,\n buff=buff,\n )\n elif gal_type in ['fixed', 'varying', 'exp']: # TODO remove exp\n if layout is None:\n raise ValueError(\"send layout= for gal_type '%s'\" % gal_type)\n\n gal_config = get_fixed_gal_config(config=gal_config)\n\n if gal_type == 'fixed':\n cls = FixedGalaxyCatalog\n else:\n cls = GalaxyCatalog\n\n galaxy_catalog = cls(\n rng=rng,\n coadd_dim=coadd_dim,\n buff=buff,\n layout=layout,\n mag=gal_config['mag'],\n hlr=gal_config['hlr'],\n morph=gal_config['morph'],\n )\n\n else:\n raise ValueError(f'bad gal_type \"{gal_type}\"')\n\n return galaxy_catalog\n\n\ndef get_fixed_gal_config(config=None):\n \"\"\"\n get the configuration for fixed galaxies, with defaults in place\n\n Parameters\n ----------\n config: dict, optional\n The input config. Over-rides defaults\n\n Returns\n -------\n the config dict\n \"\"\"\n out_config = copy.deepcopy(DEFAULT_FIXED_GAL_CONFIG)\n\n if config is not None:\n for key in config:\n if key not in out_config:\n raise ValueError(\"bad key for fixed gals: '%s'\" % key)\n out_config.update(config)\n return out_config\n\n\nclass FixedGalaxyCatalog(object):\n \"\"\"\n Galaxies of fixed galsim type, flux, and size and shape.\n\n Same for all bands\n\n Parameters\n ----------\n rng: np.random.RandomState\n The random number generator\n coadd_dim: int\n dimensions of the coadd\n layout: string\n The layout of objects, either 'grid' or 'random'\n mag: float\n Magnitude of all objects. Objects brighter than magntiude 17 (e.g., 14\n since mags are opposite) tend to cause the Rubin Observatory science\n pipeline detection algorithm to misdetect isolted objects in unphysical\n ways. This effect causes the shear response to be non-linear and so\n metadetect will fail. For this reason, you should use the default\n magnitude of 17 or fainter for this kind of galaxy.\n hlr: float\n Half light radius of all objects\n buff: int, optional\n Buffer region with no objects, on all sides of image. Ingored\n for layout 'grid'. Default 0.\n morph: str\n Galaxy morphology, 'exp', 'dev' or 'bd', 'bdk'. Default 'exp'\n \"\"\"\n def __init__(self, *, rng, coadd_dim, layout, mag, hlr, buff=0, morph='exp'):\n self.gal_type = 'fixed'\n self.morph = morph\n self.mag = mag\n self.hlr = hlr\n\n self.shifts_array = get_shifts(\n rng=rng,\n coadd_dim=coadd_dim,\n buff=buff,\n layout=layout,\n )\n\n def __len__(self):\n return len(self.shifts_array)\n\n def get_objlist(self, *, survey):\n \"\"\"\n get a list of galsim objects\n\n Parameters\n ----------\n band: string\n Get objects for this band. For the fixed\n catalog, the objects are the same for every band\n\n Returns\n -------\n [galsim objects], [shifts]\n \"\"\"\n\n flux = survey.get_flux(self.mag)\n\n sarray = self.shifts_array\n objlist = []\n shifts = []\n for i in range(len(self)):\n objlist.append(self._get_galaxy(flux))\n shifts.append(galsim.PositionD(sarray['dx'][i], sarray['dy'][i]))\n\n return objlist, shifts\n\n def _get_galaxy(self, flux):\n \"\"\"\n get a galaxy object\n\n Parameters\n ----------\n flux: float\n Flux of object\n\n Returns\n --------\n galsim.GSObject\n \"\"\"\n\n if self.morph == 'exp':\n gal = _generate_exp(hlr=self.hlr, flux=flux)\n elif self.morph == 'dev':\n gal = _generate_dev(hlr=self.hlr, flux=flux)\n elif self.morph == 'bd':\n gal = _generate_bd(hlr=self.hlr, flux=flux)\n elif self.morph == 'bdk':\n gal = _generate_bdk(hlr=self.hlr, flux=flux)\n else:\n raise ValueError(f\"bad gal type '{self.morph}'\")\n\n return gal\n\n\nclass GalaxyCatalog(FixedGalaxyCatalog):\n \"\"\"\n Galaxies of fixed galsim type, but varying properties.\n\n Same for all bands\n\n Parameters\n ----------\n rng: np.random.RandomState\n The random number generator\n coadd_dim: int\n dimensions of the coadd\n layout: string\n The layout of objects, either 'grid' or 'random'\n mag: float\n Magnitude of all objects. Objects brighter than magntiude 17 (e.g., 14\n since mags are opposite) tend to cause the Rubin Observatory science\n pipeline detection algorithm to misdetect isolted objects in unphysical\n ways. This effect causes the shear response to be non-linear and so\n metadetect will fail. For this reason, you should use the default\n magnitude of 17 or fainter for this kind of galaxy.\n hlr: float\n Half light radius of all objects\n buff: int, optional\n Buffer region with no objects, on all sides of image. Ingored\n for layout 'grid'. Default 0.\n morph: str\n Galaxy morphology, 'exp', 'dev' or 'bd', 'bdk'. Default 'exp'\n \"\"\"\n def __init__(self, *, rng, coadd_dim, layout, mag, hlr, buff=0, morph='exp'):\n super().__init__(\n rng=rng, coadd_dim=coadd_dim, buff=buff, layout=layout,\n mag=mag, hlr=hlr, morph=morph,\n )\n self.gal_type = 'varying'\n\n # we use this to ensure the same galaxies are generated in different\n # bands\n self.morph_seed = rng.randint(0, 2**31)\n self.gs_morph_seed = rng.randint(0, 2**31)\n\n def get_objlist(self, *, survey):\n \"\"\"\n get a list of galsim objects\n\n Parameters\n ----------\n band: string\n Get objects for this band. For the fixed\n catalog, the objects are the same for every band\n\n Returns\n -------\n [galsim objects], [shifts]\n \"\"\"\n\n self._morph_rng = np.random.RandomState(self.morph_seed)\n self._gs_morph_rng = galsim.BaseDeviate(seed=self.gs_morph_seed)\n return super().get_objlist(survey=survey)\n\n def _get_galaxy(self, flux):\n \"\"\"\n get a galaxy object\n\n Parameters\n ----------\n flux: float\n Flux of object\n\n Returns\n --------\n galsim.GSObject\n \"\"\"\n\n if self.morph == 'exp':\n gal = _generate_exp(\n hlr=self.hlr, flux=flux, vary=True, rng=self._morph_rng,\n )\n elif self.morph == 'dev':\n gal = _generate_dev(\n hlr=self.hlr, flux=flux, vary=True, rng=self._morph_rng,\n )\n elif self.morph == 'bd':\n gal = _generate_bd(\n hlr=self.hlr, flux=flux,\n vary=True, rng=self._morph_rng,\n )\n elif self.morph == 'bdk':\n gal = _generate_bdk(\n hlr=self.hlr, flux=flux,\n vary=True,\n rng=self._morph_rng, gsrng=self._gs_morph_rng,\n )\n else:\n raise ValueError(f\"bad morph '{self.morph}'\")\n\n return gal\n\n\ndef _generate_exp(hlr, flux, vary=False, rng=None):\n gal = Exponential(half_light_radius=hlr, flux=flux)\n\n if vary:\n g1, g2 = _generate_g1g2(rng)\n gal = gal.shear(g1=g1, g2=g2)\n\n return gal\n\n\ndef _generate_dev(hlr, flux, vary=False, rng=None):\n gal = DeVaucouleurs(half_light_radius=hlr, flux=flux)\n if vary:\n g1, g2 = _generate_g1g2(rng)\n gal = gal.shear(g1=g1, g2=g2)\n\n return gal\n\n\ndef _generate_bd(\n hlr, flux,\n vary=False,\n rng=None,\n max_bulge_shift_frac=0.1, # fraction of hlr\n max_bulge_rot=np.pi/4,\n):\n\n if vary:\n bulge_frac = _generate_bulge_frac(rng)\n else:\n bulge_frac = 0.5\n\n disk_frac = (1.0 - bulge_frac)\n\n bulge = DeVaucouleurs(half_light_radius=hlr, flux=flux * bulge_frac)\n disk = Exponential(half_light_radius=hlr, flux=flux * disk_frac)\n\n if vary:\n bulge = _shift_bulge(rng, bulge, hlr, max_bulge_shift_frac)\n\n if vary:\n g1disk, g2disk = _generate_g1g2(rng)\n\n g1bulge, g2bulge = g1disk, g2disk\n if vary:\n g1bulge, g2bulge = _rotate_bulge(rng, max_bulge_rot, g1bulge, g2bulge)\n\n bulge = bulge.shear(g1=g1bulge, g2=g2bulge)\n disk = disk.shear(g1=g1disk, g2=g2disk)\n\n return galsim.Add(bulge, disk)\n\n\ndef _generate_bdk(\n hlr, flux,\n vary=False,\n rng=None,\n gsrng=None,\n knots_hlr_frac=0.25,\n max_knots_disk_frac=0.1, # fraction of disk light\n max_bulge_shift_frac=0.1, # fraction of hlr\n max_bulge_rot=np.pi/4,\n):\n\n if vary:\n bulge_frac = _generate_bulge_frac(rng)\n else:\n bulge_frac = 0.5\n\n all_disk_frac = (1.0 - bulge_frac)\n\n knots_hlr = knots_hlr_frac * hlr\n if vary:\n knots_sub_frac = _generate_knots_sub_frac(rng, max_knots_disk_frac)\n else:\n knots_sub_frac = max_knots_disk_frac\n\n disk_frac = (1 - knots_sub_frac) * all_disk_frac\n knots_frac = knots_sub_frac * all_disk_frac\n\n bulge = DeVaucouleurs(half_light_radius=hlr, flux=flux * bulge_frac)\n disk = Exponential(half_light_radius=hlr, flux=flux * disk_frac)\n\n if gsrng is None:\n # fixed galaxy, so fix the rng\n gsrng = galsim.BaseDeviate(123)\n\n knots = galsim.RandomKnots(\n npoints=10,\n half_light_radius=knots_hlr,\n flux=flux * knots_frac,\n rng=gsrng,\n )\n\n if vary:\n bulge = _shift_bulge(rng, bulge, hlr, max_bulge_shift_frac)\n\n if vary:\n g1disk, g2disk = _generate_g1g2(rng)\n\n g1bulge, g2bulge = g1disk, g2disk\n if vary:\n g1bulge, g2bulge = _rotate_bulge(rng, max_bulge_rot, g1bulge, g2bulge)\n\n bulge = bulge.shear(g1=g1bulge, g2=g2bulge)\n disk = disk.shear(g1=g1disk, g2=g2disk)\n knots = knots.shear(g1=g1disk, g2=g2disk)\n\n return galsim.Add(bulge, disk, knots)\n\n\ndef _generate_bulge_frac(rng):\n assert rng is not None, 'send rng to generate bulge fraction'\n return rng.uniform(low=0.0, high=1.0)\n\n\ndef _generate_g1g2(rng, std=0.2):\n assert rng is not None, 'send rng to vary shape'\n while True:\n g1, g2 = rng.normal(scale=std, size=2)\n g = np.sqrt(g1**2 + g2**2)\n if abs(g) < 0.9999:\n break\n\n return g1, g2\n\n\ndef _generate_bulge_shift(rng, hlr, max_bulge_shift_frac):\n bulge_shift = rng.uniform(low=0.0, high=max_bulge_shift_frac*hlr)\n bulge_shift_angle = rng.uniform(low=0, high=2*np.pi)\n bulge_shiftx = bulge_shift * np.cos(bulge_shift_angle)\n bulge_shifty = bulge_shift * np.sin(bulge_shift_angle)\n\n return bulge_shiftx, bulge_shifty\n\n\ndef _shift_bulge(rng, bulge, hlr, max_bulge_shift_frac):\n bulge_shiftx, bulge_shifty = _generate_bulge_shift(\n rng, hlr, max_bulge_shift_frac,\n )\n return bulge.shift(bulge_shiftx, bulge_shifty)\n\n\ndef _rotate_bulge(rng, max_bulge_rot, g1, g2):\n assert rng is not None, 'send rng to rotate bulge'\n bulge_rot = rng.uniform(low=-max_bulge_rot, high=max_bulge_rot/4)\n return _rotate_shape(g1, g2, bulge_rot)\n\n\ndef _rotate_shape(g1, g2, theta_radians):\n twotheta = 2.0 * theta_radians\n\n cos2angle = np.cos(twotheta)\n sin2angle = np.sin(twotheta)\n g1rot = g1 * cos2angle + g2 * sin2angle\n g2rot = -g1 * sin2angle + g2 * cos2angle\n\n return g1rot, g2rot\n\n\ndef _generate_knots_sub_frac(rng, max_knots_disk_frac):\n assert rng is not None, 'send rng to generate knots sub frac'\n return rng.uniform(low=0.0, high=max_knots_disk_frac)\n\n\nclass FixedPairGalaxyCatalog(FixedGalaxyCatalog):\n \"\"\"\n A pair of galaxies of fixed galsim type, flux, and size\n\n Same for all bands\n\n Parameters\n ----------\n rng: np.random.RandomState\n The random number generator\n mag: float\n Magnitude of all objects. Objects brighter than magntiude 17 (e.g., 14\n since mags are opposite) tend to cause the Rubin Observatory science\n pipeline detection algorithm to misdetect isolted objects in unphysical\n ways. This effect causes the shear response to be non-linear and so\n metadetect will fail. For this reason, you should use the default\n magnitude of 17 or fainter for this kind of galaxy.\n hlr: float\n Half light radius of all objects\n sep: float\n Separation of pair in arcsec\n morph: str\n Galaxy morphology, 'exp', 'dev' or 'bd', 'bdk'. Default 'exp'\n \"\"\"\n def __init__(self, *, rng, mag, hlr, sep, morph='exp'):\n self.gal_type = 'fixed'\n self.morph = morph\n self.mag = mag\n self.hlr = hlr\n self.rng = rng\n\n self.shifts_array = get_pair_shifts(\n rng=rng,\n sep=sep,\n )\n\n\nclass PairGalaxyCatalog(GalaxyCatalog):\n \"\"\"\n A pair of galaxies of fixed galsim type, flux, and size\n\n Same for all bands\n\n Parameters\n ----------\n rng: np.random.RandomState\n The random number generator\n mag: float\n Magnitude of all objects. Objects brighter than magntiude 17 (e.g., 14\n since mags are opposite) tend to cause the Rubin Observatory science\n pipeline detection algorithm to misdetect isolted objects in unphysical\n ways. This effect causes the shear response to be non-linear and so\n metadetect will fail. For this reason, you should use the default\n magnitude of 17 or fainter for this kind of galaxy.\n hlr: float\n Half light radius of all objects\n sep: float\n Separation of pair in arcsec\n morph: str\n Galaxy morphology, 'exp', 'dev' or 'bd', 'bdk'. Default 'exp'\n \"\"\"\n def __init__(self, *, rng, mag, hlr, sep, morph='exp'):\n self.gal_type = 'varying'\n self.morph = morph\n self.mag = mag\n self.hlr = hlr\n self.rng = rng\n\n self.morph_seed = rng.randint(0, 2**31)\n self.gs_morph_seed = rng.randint(0, 2**31)\n\n self.shifts_array = get_pair_shifts(\n rng=rng,\n sep=sep,\n )\n\n\nclass WLDeblendGalaxyCatalog(object):\n \"\"\"\n Catalog of galaxies from wldeblend\n\n Parameters\n ----------\n rng: np.random.RandomState\n The random number generator\n coadd_dim: int\n Dimensions of the coadd\n buff: int, optional\n Buffer region with no objects, on all sides of image. Ingored\n for layout 'grid'. Default 0.\n \"\"\"\n def __init__(self, *, rng, coadd_dim, buff=0):\n self.gal_type = 'wldeblend'\n self.rng = rng\n\n self._wldeblend_cat = read_wldeblend_cat(rng)\n\n # one square degree catalog, convert to arcmin\n gal_dens = self._wldeblend_cat.size / (60 * 60)\n area = ((coadd_dim - 2*buff)*SCALE/60)**2\n nobj_mean = area * gal_dens\n nobj = rng.poisson(nobj_mean)\n\n self.shifts_array = get_shifts(\n rng=rng,\n coadd_dim=coadd_dim,\n buff=buff,\n layout=\"random\",\n nobj=nobj,\n )\n\n num = len(self)\n self.indices = self.rng.randint(\n 0,\n self._wldeblend_cat.size,\n size=num,\n )\n\n self.angles = self.rng.uniform(low=0, high=360, size=num)\n\n def __len__(self):\n return len(self.shifts_array)\n\n def get_objlist(self, *, survey):\n \"\"\"\n get a list of galsim objects\n\n Parameters\n ----------\n survey: WLDeblendSurvey\n The survey object\n\n Returns\n -------\n [galsim objects], [shifts]\n \"\"\"\n\n builder = descwl.model.GalaxyBuilder(\n survey=survey.descwl_survey,\n no_disk=False,\n no_bulge=False,\n no_agn=False,\n verbose_model=False,\n )\n\n band = survey.filter_band\n\n sarray = self.shifts_array\n objlist = []\n shifts = []\n for i in range(len(self)):\n objlist.append(self._get_galaxy(builder, band, i))\n shifts.append(galsim.PositionD(sarray['dx'][i], sarray['dy'][i]))\n\n return objlist, shifts\n\n def _get_galaxy(self, builder, band, i):\n \"\"\"\n Get a galaxy\n\n Parameters\n ----------\n builder: descwl.model.GalaxyBuilder\n Builder for this object\n band: string\n Band string, e.g. 'r'\n i: int\n Index of object\n\n Returns\n -------\n galsim.GSObject\n \"\"\"\n index = self.indices[i]\n\n angle = self.angles[i]\n\n galaxy = builder.from_catalog(\n self._wldeblend_cat[index],\n 0,\n 0,\n band,\n ).model.rotate(\n angle * galsim.degrees,\n )\n\n return galaxy\n\n\ndef read_wldeblend_cat(rng):\n \"\"\"\n Read the catalog from the cache, but update the position angles each time\n\n Parameters\n ----------\n rng: np.random.RandomState\n The random number generator\n\n Returns\n -------\n array with fields\n \"\"\"\n fname = os.path.join(\n os.environ.get('CATSIM_DIR', '.'),\n 'OneDegSq.fits',\n )\n\n # not thread safe\n cat = cached_catalog_read(fname)\n return cat\n", "meta": {"hexsha": "bbc34ac66274c1b5320626d4b853ff69b664d796", "size": 19369, "ext": "py", "lang": "Python", "max_stars_repo_path": "descwl_shear_sims/galaxies.py", "max_stars_repo_name": "LSSTDESC/descwl_shear_sims", "max_stars_repo_head_hexsha": "1c696518104b7f301dd6c69571239431c6232110", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "descwl_shear_sims/galaxies.py", "max_issues_repo_name": "LSSTDESC/descwl_shear_sims", "max_issues_repo_head_hexsha": "1c696518104b7f301dd6c69571239431c6232110", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 11, "max_issues_repo_issues_event_min_datetime": "2019-12-10T23:30:27.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-24T13:59:32.000Z", "max_forks_repo_path": "descwl_shear_sims/galaxies.py", "max_forks_repo_name": "LSSTDESC/wl-shear-testing-sims", "max_forks_repo_head_hexsha": "6e4a0baa6f664b5bc52b08b55614eaa58c8b0748", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.4737588652, "max_line_length": 82, "alphanum_fraction": 0.5898084568, "include": true, "reason": "import numpy", "num_tokens": 5129, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6076631698328916, "lm_q2_score": 0.3174262720448507, "lm_q1q2_score": 0.19288825465901174}} {"text": "from typing import List\n\nimport numpy\n\nimport torch\n\n\ndef intersect(box_a, box_b):\n \"\"\" We resize both tensors to [A,B,2] without new malloc:\n [A,2] -> [A,1,2] -> [A,B,2]\n [B,2] -> [1,B,2] -> [A,B,2]\n Then we compute the area of intersect between box_a and box_b.\n Args:\n box_a: (tensor) bounding boxes, Shape: [A,4].\n box_b: (tensor) bounding boxes, Shape: [B,4].\n Return:\n (tensor) intersection area, Shape: [A,B].\n \"\"\"\n A = box_a.size(0)\n B = box_b.size(0)\n max_xy = torch.min(box_a[:, 2:].unsqueeze(1).expand(A, B, 2),\n box_b[:, 2:].unsqueeze(0).expand(A, B, 2))\n min_xy = torch.max(box_a[:, :2].unsqueeze(1).expand(A, B, 2),\n box_b[:, :2].unsqueeze(0).expand(A, B, 2))\n inter = torch.clamp((max_xy - min_xy), min=0)\n return inter[:, :, 0] * inter[:, :, 1]\n # inter[:, :, 0] is the width of intersection and inter[:, :, 1] is height\n\n\ndef jaccard_tensor(box_a: torch.Tensor, box_b: torch.Tensor) -> torch.Tensor:\n \"\"\"Compute the jaccard overlap of two sets of boxes. The jaccard overlap\n is simply the intersection over union of two boxes. Here we operate on\n ground truth boxes and default boxes.\n E.g.:\n A ∩ B / A ∪ B = A ∩ B / (area(A) + area(B) - A ∩ B)\n Args:\n box_a: (tensor) Ground truth bounding boxes, Shape: [A,4]\n box_b: (tensor) Prior boxes from priorbox layers, Shape: [B,4]\n Return:\n jaccard overlap: (tensor) Shape: [A, B]\n \"\"\"\n inter = intersect(box_a, box_b)\n area_a = ((box_a[:, 2] - box_a[:, 0]) *\n (box_a[:, 3] - box_a[:, 1])).unsqueeze(1).expand_as(inter) # [A,B]\n area_b = ((box_b[:, 2] - box_b[:, 0]) *\n (box_b[:, 3] - box_b[:, 1])).unsqueeze(0).expand_as(inter) # [A,B]\n union = area_a + area_b - inter\n return inter / union # [A,B]\n\n\nclass YoloV3Loss(torch.nn.Module):\n \"\"\"\n YoloV3 损失函数\n \"\"\"\n\n def __init__(self, config: dict) -> None:\n super().__init__()\n\n self.lambda_xy = 1.0 # 预测框中心误差权重\n self.lambda_wh = 1.0 # 预测框大小误差权重\n self.lambda_noobj = 1.0 # 预测框置信度误差权重\n self.lambda_obj = 1.0 # 预测框置信度误差权重\n self.lambda_class = 1.0 # 预测框类别误差权重\n self.lambda_conf = 1.0 # 预测框类别误差权重\n\n self.normd_anchors = numpy.asarray(config[\"anchors\"]).astype(numpy.float)\n self.normd_anchors[:, :, 0] /= config[\"image_width\"]\n self.normd_anchors[:, :, 1] /= config[\"image_height\"]\n self.normd_anchors = self.normd_anchors.reshape((9, 2))\n self.normd_anchors_box = torch.cat(\n (\n torch.zeros((self.normd_anchors.shape[0], 2)),\n torch.from_numpy(self.normd_anchors)\n ), 1)\n\n self.classes = config[\"classes\"]\n self.bbox_attrs = 4 + 1 + self.classes\n\n self.ignore_threshold = 0.5 # iou 忽略的阈值\n\n self.cuda = config[\"cuda\"]\n\n def pyramid_target(self, tensord_target_list: List[torch.Tensor]):\n pyramid_target_list_13 = []\n pyramid_target_list_26 = []\n pyramid_target_list_52 = []\n\n for tensord_target in tensord_target_list:\n tensord_target_13 = []\n tensord_target_26 = []\n tensord_target_52 = []\n\n target_box = tensord_target[:, :4].clone().detach()\n target_box[:, 0] = 0\n target_box[:, 1] = 0\n normd_anch_ious = jaccard_tensor(target_box, self.normd_anchors_box)\n max_anch_ious_index = torch.argmax(normd_anch_ious, dim=-1)\n\n for box_index, anch_index in enumerate(max_anch_ious_index):\n if anch_index in [0, 1, 2]:\n tensord_target_13.append(tensord_target[box_index].numpy())\n elif anch_index in [3, 4, 5]:\n tensord_target_26.append(tensord_target[box_index].numpy())\n elif anch_index in [6, 7, 8]:\n tensord_target_52.append(tensord_target[box_index].numpy())\n else:\n raise Exception(\"unexpected error\")\n\n pyramid_target_list_13.append(torch.as_tensor(tensord_target_13))\n pyramid_target_list_26.append(torch.as_tensor(tensord_target_26))\n pyramid_target_list_52.append(torch.as_tensor(tensord_target_52))\n\n return pyramid_target_list_13, pyramid_target_list_26, pyramid_target_list_52\n\n def decode_pyramid_target(self,\n pyramid_target_list: List[torch.Tensor],\n pyramid_normd_anchors: numpy.ndarray,\n pyramid_features: int\n ) -> (\n torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor,\n torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor,\n torch.Tensor, torch.Tensor\n ):\n assert pyramid_features in [13, 26, 52]\n\n if pyramid_features == 13:\n pyramid_anch_index_list = [0, 1, 2]\n elif pyramid_features == 26:\n pyramid_anch_index_list = [3, 4, 5]\n elif pyramid_features == 52:\n pyramid_anch_index_list = [6, 7, 8]\n else:\n raise Exception(\"unexpected error\")\n\n batch_size = len(pyramid_target_list)\n\n target_x = torch.zeros(batch_size, 3, pyramid_features, pyramid_features)\n target_y = torch.zeros(batch_size, 3, pyramid_features, pyramid_features)\n target_w = torch.zeros(batch_size, 3, pyramid_features, pyramid_features)\n target_h = torch.zeros(batch_size, 3, pyramid_features, pyramid_features)\n\n target_loss_weight_xw = torch.zeros(batch_size, 3, pyramid_features, pyramid_features)\n target_loss_weight_yh = torch.zeros(batch_size, 3, pyramid_features, pyramid_features)\n\n target_obj_conf = torch.zeros(batch_size, 3, pyramid_features, pyramid_features)\n target_class_conf_list = torch.zeros(batch_size, 3, pyramid_features, pyramid_features,\n self.classes)\n\n target_obj_mask = torch.zeros(batch_size, 3, pyramid_features, pyramid_features)\n target_noobj_mask = torch.ones(batch_size, 3, pyramid_features, pyramid_features)\n\n # 遍历这一个批次所有的图片\n for bs_i, pyramid_target in enumerate(pyramid_target_list):\n if pyramid_target.shape[0] == 0:\n continue\n\n truth_feature_box = pyramid_target[:, 0:4] * pyramid_features\n\n truth_grid_x = torch.floor(truth_feature_box[:, 0]).int()\n truth_grid_y = torch.floor(truth_feature_box[:, 1]).int()\n\n truth_x = truth_feature_box[:, 0] - truth_grid_x\n truth_y = truth_feature_box[:, 1] - truth_grid_y\n\n target_box = pyramid_target[:, :4].clone().detach()\n target_box[:, 0] = 0\n target_box[:, 1] = 0\n normd_anch_ious = jaccard_tensor(target_box, self.normd_anchors_box)\n max_anch_ious_index = torch.argmax(normd_anch_ious, dim=-1)\n\n for box_i, anch_i in enumerate(max_anch_ious_index):\n if anch_i not in pyramid_anch_index_list:\n continue\n pyramid_anch_i = anch_i % 3\n\n truth_w_box = torch.log(pyramid_target[box_i][2] / self.normd_anchors[anch_i][0])\n truth_h_box = torch.log(pyramid_target[box_i][3] / self.normd_anchors[anch_i][1])\n\n target_x[bs_i, pyramid_anch_i, truth_grid_y[box_i], truth_grid_x[box_i]] = truth_x[box_i]\n target_y[bs_i, pyramid_anch_i, truth_grid_y[box_i], truth_grid_x[box_i]] = truth_y[box_i]\n\n target_w[bs_i, pyramid_anch_i, truth_grid_y[box_i], truth_grid_x[box_i]] = truth_w_box\n target_h[bs_i, pyramid_anch_i, truth_grid_y[box_i], truth_grid_x[box_i]] = truth_h_box\n\n target_loss_weight_xw[bs_i, pyramid_anch_i, truth_grid_y[box_i], truth_grid_x[box_i]] = \\\n pyramid_target[box_i][2]\n target_loss_weight_yh[bs_i, pyramid_anch_i, truth_grid_y[box_i], truth_grid_x[box_i]] = \\\n pyramid_target[box_i][3]\n\n target_obj_conf[bs_i, pyramid_anch_i, truth_grid_y[box_i], truth_grid_x[box_i]] = 1\n target_class_conf_list[\n bs_i, pyramid_anch_i, truth_grid_y[box_i], truth_grid_x[box_i], pyramid_target[box_i][4].int()] = 1\n\n target_obj_mask[bs_i, pyramid_anch_i, truth_grid_y[box_i], truth_grid_x[box_i]] = 1\n target_noobj_mask[bs_i, pyramid_anch_i, truth_grid_y[box_i], truth_grid_x[box_i]] = 0\n\n # print(\"loss in cuda\") if self.cuda else print(\"loss not in cuda\")\n\n if self.cuda:\n return target_x.cuda(), \\\n target_y.cuda(), \\\n target_w.cuda(), \\\n target_h.cuda(), \\\n target_loss_weight_xw.cuda(), \\\n target_loss_weight_yh.cuda(), \\\n target_obj_conf.cuda(), \\\n target_class_conf_list.cuda(), \\\n target_obj_mask.cuda(), \\\n target_noobj_mask.cuda()\n\n return target_x, \\\n target_y, \\\n target_w, \\\n target_h, \\\n target_loss_weight_xw, \\\n target_loss_weight_yh, \\\n target_obj_conf, \\\n target_class_conf_list, \\\n target_obj_mask, \\\n target_noobj_mask\n\n def compute_loss(self, predict_feature: torch.Tensor, decoded_target) -> (\n torch.Tensor, torch.Tensor):\n (target_x, target_y, target_w, target_h, target_loss_weight_xw, target_loss_weight_yh, target_obj_conf,\n target_class_conf_list, target_obj_mask, target_noobj_mask) = decoded_target\n\n predict_feature = predict_feature.view(\n predict_feature.shape[0],\n 3,\n self.bbox_attrs,\n predict_feature.shape[2],\n predict_feature.shape[3],\n ).permute(0, 1, 3, 4, 2).contiguous()\n\n predict_x = torch.sigmoid(predict_feature[..., 0])\n predict_y = torch.sigmoid(predict_feature[..., 1])\n predict_w = predict_feature[..., 2]\n predict_h = predict_feature[..., 3]\n predict_obj_conf = torch.sigmoid(predict_feature[..., 4])\n predict_class_conf_list = torch.sigmoid(predict_feature[..., 5:])\n\n target_loss_scale = 2 - target_loss_weight_xw * target_loss_weight_yh\n\n loss_x = torch.sum(torch.nn.BCELoss()(predict_x, target_x) * target_loss_scale * target_obj_mask)\n loss_y = torch.sum(torch.nn.BCELoss()(predict_y, target_y) * target_loss_scale * target_obj_mask)\n\n loss_w = torch.sum(torch.nn.MSELoss()(predict_w, target_w) * 0.5 * target_loss_scale * target_obj_mask)\n loss_h = torch.sum(torch.nn.MSELoss()(predict_h, target_h) * 0.5 * target_loss_scale * target_obj_mask)\n\n loss_conf = self.lambda_obj * torch.sum(\n torch.nn.BCELoss()(predict_obj_conf, target_obj_mask) * target_obj_mask) + \\\n self.lambda_noobj * torch.sum(\n torch.nn.BCELoss()(predict_obj_conf, target_obj_mask) * target_noobj_mask)\n\n loss_class = torch.sum(torch.nn.BCELoss()(predict_class_conf_list[target_obj_mask == 1],\n target_class_conf_list[target_obj_mask == 1]))\n\n print(\"\\n---------------------------------------\")\n print(loss_x, loss_y)\n print(loss_w, loss_h)\n print(loss_conf, loss_class)\n print(\"---------------------------------------\\n\")\n\n loss = loss_x * self.lambda_xy + loss_y * self.lambda_xy + \\\n loss_w * self.lambda_wh + loss_h * self.lambda_wh + \\\n loss_conf * self.lambda_conf + loss_class * self.lambda_class\n\n return loss, torch.sum(target_obj_mask)\n\n def forward(self, predict_feature_list,\n tensord_target_list: List[torch.Tensor]) -> torch.Tensor:\n # pyramid_target_list_13, pyramid_target_list_26, pyramid_target_list_52 = \\\n # self.pyramid_target(tensord_target_list)\n # pyramid_normd_anchors_13, pyramid_normd_anchors_26, pyramid_normd_anchors_52 = \\\n # self.normd_anchors[0:3], self.normd_anchors[3, 6], self.normd_anchors[6, 9]\n\n target_13 = self.decode_pyramid_target(tensord_target_list, None, 13)\n target_26 = self.decode_pyramid_target(tensord_target_list, None, 26)\n target_52 = self.decode_pyramid_target(tensord_target_list, None, 52)\n\n loss_13, loss_13_num = self.compute_loss(predict_feature_list[0], target_13)\n loss_26, loss_26_num = self.compute_loss(predict_feature_list[1], target_26)\n loss_52, loss_52_num = self.compute_loss(predict_feature_list[2], target_52)\n\n loss_list = []\n\n if not torch.isnan(loss_13):\n loss_list.append(loss_13)\n if not torch.isnan(loss_26):\n loss_list.append(loss_26)\n if not torch.isnan(loss_52):\n loss_list.append(loss_52)\n\n assert len(loss_list) != 0\n\n loss = sum(loss_list)\n\n loss_num = loss_13_num + loss_26_num + loss_52_num\n\n return loss / loss_num\n", "meta": {"hexsha": "0777a5b1c34021c897db562a1a7ae2583828d44c", "size": 13141, "ext": "py", "lang": "Python", "max_stars_repo_path": "model/yolov3loss.py", "max_stars_repo_name": "lilinxi/210318_SimpleYoloV3", "max_stars_repo_head_hexsha": "0fb40075cc3681a0dc46f303afd6b82f910dff52", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "model/yolov3loss.py", "max_issues_repo_name": "lilinxi/210318_SimpleYoloV3", "max_issues_repo_head_hexsha": "0fb40075cc3681a0dc46f303afd6b82f910dff52", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "model/yolov3loss.py", "max_forks_repo_name": "lilinxi/210318_SimpleYoloV3", "max_forks_repo_head_hexsha": "0fb40075cc3681a0dc46f303afd6b82f910dff52", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.657807309, "max_line_length": 119, "alphanum_fraction": 0.6077163077, "include": true, "reason": "import numpy", "num_tokens": 3387, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.607663184043154, "lm_q2_score": 0.3174262591305011, "lm_q1q2_score": 0.19288825132214757}} {"text": "import numpy as np\nimport scipy.signal as signal\nfrom scipy.interpolate import interp1d\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport matplotlib.gridspec as gridspec\nfrom astropy.io import fits\nimport emcee\nimport corner\nimport copy\nimport time\nimport os\nimport sys\nimport smart\n\ndef makeModel(teff, logg=5, metal=0, vsini=1, rv=0, tell_alpha=1.0, airmass=1.0, pwv=0.5, wave_offset=0, flux_offset=0,**kwargs):\n\t\"\"\"\n\tReturn a forward model.\n\n\tParameters\n\t----------\n\tteff : effective temperature\n\t\n\tdata : an input science data used for continuum correction\n\n\tOptional Parameters\n\t-------------------\n\t\n\n\tReturns\n\t-------\n\tmodel: a synthesized model\n\t\"\"\"\n\n\t# read in the parameters\n\torder = kwargs.get('order', '33')\n\tmodelset = kwargs.get('modelset', 'btsettl08')\n\tinstrument = kwargs.get('instrument', 'nirspec')\n\tveiling = kwargs.get('veiling', 0) # flux veiling parameter\n\tlsf = kwargs.get('lsf', 4.5) # instrumental LSF\n\tinclude_fringe_model = kwargs.get('include_fringe_model', False)\n\n\tif instrument == 'apogee':\n\t\ttry:\n\t\t\timport apogee_tools as ap\n\t\texcept ImportError:\n\t\t\tprint('Need to install the package \"apogee_tools\" (https://github.com/jbirky/apogee_tools) \\n')\n\t\txlsf = kwargs.get('xlsf', np.linspace(-7.,7.,43)) # APOGEE instrumental LSF sampling\n\t\twave_off1 = kwargs.get('wave_off1') # wavelength offset for chip a\n\t\twave_off2 = kwargs.get('wave_off2') # wavelength offset for chip b\n\t\twave_off3 = kwargs.get('wave_off3') # wavelength offset for chip c\n\t\tc0_1 = kwargs.get('c0_1') # constant flux offset for chip a\n\t\tc0_2 = kwargs.get('c0_2') # linear flux offset for chip a\n\t\tc1_1 = kwargs.get('c1_1') # constant flux offset for chip b\n\t\tc1_2 = kwargs.get('c1_2') # linear flux offset for chip b\n\t\tc2_1 = kwargs.get('c2_1') # constant flux offset for chip c\n\t\tc2_2 = kwargs.get('c2_2') # linear flux offset for chip c\n\n\ttell = kwargs.get('tell', True) # apply telluric\n\t#tell_alpha = kwargs.get('tell_alpha', 1.0) # Telluric alpha power\n\tbinary = kwargs.get('binary', False) # make a binary model\n\n\t# assume the secondary has the same metallicity\n\tif binary:\n\t\tteff2 = kwargs.get('teff2')\n\t\tlogg2 = kwargs.get('logg2')\n\t\trv2 = kwargs.get('rv2')\n\t\tvsini2 = kwargs.get('vsini2')\n\t\tflux_scale = kwargs.get('flux_scale', 0.8)\n\n\tdata = kwargs.get('data', None) # for continuum correction and resampling\n\n\toutput_stellar_model = kwargs.get('output_stellar_model', False)\n\t\n\tif data is not None and instrument == 'nirspec':\n\t\torder = data.order\n\t\t# read in a model\n\t\t#print('teff ',teff,'logg ',logg, 'z', z, 'order', order, 'modelset', modelset)\n\t\t#print('teff ',type(teff),'logg ',type(logg), 'z', type(z), 'order', type(order), 'modelset', type(modelset))\n\t\tmodel = smart.Model(teff=teff, logg=logg, metal=metal, order=str(order), modelset=modelset, instrument=instrument)\n\n\t#elif data is not None and instrument == 'apogee':\n\telif instrument == 'apogee':\n\t\tmodel = smart.Model(teff=teff, logg=logg, metal=metal, modelset=modelset, instrument=instrument)\n\t\t# Dirty fix here\n\t\tmodel.wave = model.wave[np.where(model.flux != 0)]\n\t\tmodel.flux = model.flux[np.where(model.flux != 0)]\n\n\t\t# apply vmicro\n\t\tvmicro = 2.478 - 0.325*logg\n\t\tmodel.flux = smart.broaden(wave=model.wave, flux=model.flux, vbroad=vmicro, rotate=False, gaussian=True)\n\t\n\telif data is None and instrument == 'nirspec':\n\t\tmodel = smart.Model(teff=teff, logg=logg, metal=metal, order=str(order), modelset=modelset, instrument=instrument)\n\t\n\t# wavelength offset\n\t#model.wave += wave_offset\n\n\t# apply vsini\n\tmodel.flux = smart.broaden(wave=model.wave, flux=model.flux, vbroad=vsini, rotate=True, gaussian=False)\n\t\n\t# apply rv (including the barycentric correction)\n\tmodel.wave = rvShift(model.wave, rv=rv)\n\t\n\t# flux veiling\n\tmodel.flux += veiling\n\n\t## if binary is True: make a binary model\n\tif binary:\n\t\tmodel2 = smart.Model(teff=teff2, logg=logg2, metal=metal, order=str(order), modelset=modelset, instrument=instrument)\n\t\t# apply vsini\n\t\tmodel2.flux = smart.broaden(wave=model2.wave, flux=model2.flux, vbroad=vsini2, rotate=True, gaussian=False)\n\t\t# apply rv (including the barycentric correction)\n\t\tmodel2.wave = rvShift(model2.wave, rv=rv2)\n\t\t# linearly interpolate the model2 onto the model1 grid\n\t\tfit = interp1d(model2.wave, model2.flux)\n\n\t\tselect_wavelength = np.where( (model.wave < model2.wave[-1]) & (model.wave > model2.wave[0]) )\n\t\tmodel.flux = model.flux[select_wavelength]\n\t\tmodel.wave = model.wave[select_wavelength]\n\n\t\t# combine the models together and scale the secondary flux\n\t\tmodel.flux += flux_scale * fit(model.wave)\n\n\tif output_stellar_model:\n\t\tstellar_model = copy.deepcopy(model)\n\t\tif binary:\n\t\t\tmodel2.flux = flux_scale * fit(model.wave)\n\n\t# apply telluric\n\tif tell is True:\n\t\tmodel = smart.applyTelluric(model=model, tell_alpha=tell_alpha, airmass=airmass, pwv=pwv)\n\n\t# fringe \n\tif include_fringe_model is True:\n\t\t#print('adding the fringe model')\n\t\ts1, s2, s3, s4, s5 = 0, 150, 400, 600, -1\n\t\tpiecewise_fringe_model = [s1, s2, s3, s4, s5]\n\t\tmodel.flux *= smart.double_sine_fringe(model, data, piecewise_fringe_model, teff, logg, vsini, rv, airmass, pwv, wave_offset, flux_offset, lsf, modelset)\n\n\t# instrumental LSF\n\tif instrument == 'nirspec':\n\t\tmodel.flux = smart.broaden(wave=model.wave, flux=model.flux, vbroad=lsf, rotate=False, gaussian=True)\n\telif instrument == 'apogee':\n\t\tmodel.flux = ap.apogee_hack.spec.lsf.convolve(model.wave, model.flux, lsf=lsf, xlsf=xlsf).flatten()\n\t\tmodel.wave = ap.apogee_hack.spec.lsf.apStarWavegrid()\n\t\t# Remove the NANs\n\t\tmodel.wave = model.wave[~np.isnan(model.flux)]\n\t\tmodel.flux = model.flux[~np.isnan(model.flux)]\n\n\tif output_stellar_model:\n\t\tstellar_model.flux = smart.broaden(wave=stellar_model.wave, flux=stellar_model.flux, vbroad=lsf, rotate=False, gaussian=True)\n\t\tif binary:\n\t\t\tmodel2.flux = smart.broaden(wave=model2.wave, flux=model2.flux, vbroad=lsf, rotate=False, gaussian=True)\n\n\t# wavelength offset\n\tmodel.wave += wave_offset\n\n\tif output_stellar_model: \n\t\tstellar_model.wave += wave_offset\n\t\tif binary:\n\t\t\tmodel2.wave = stellar_model.wave\n\n\t# integral resampling\n\tif data is not None:\n\t\tif instrument == 'nirspec':\n\t\t\tmodel.flux = np.array(smart.integralResample(xh=model.wave, yh=model.flux, xl=data.wave))\n\t\t\tmodel.wave = data.wave\n\n\t\t\tif output_stellar_model:\n\t\t\t\tstellar_model.flux = np.array(smart.integralResample(xh=stellar_model.wave, yh=stellar_model.flux, xl=data.wave))\n\t\t\t\tstellar_model.wave = data.wave\n\t\t\t\tif binary:\n\t\t\t\t\tmodel2.flux = np.array(smart.integralResample(xh=model2.wave, yh=model2.flux, xl=data.wave))\n\t\t\t\t\tmodel2.wave = data.wave\n\n\t\t# contunuum correction\n\t\tif data.instrument == 'nirspec':\n\t\t\tniter = 5 # continuum iteration\n\t\t\tif output_stellar_model:\n\t\t\t\tmodel, cont_factor = smart.continuum(data=data, mdl=model, prop=True)\n\t\t\t\tfor i in range(niter):\n\t\t\t\t\tmodel, cont_factor2 = smart.continuum(data=data, mdl=model, prop=True)\n\t\t\t\t\tcont_factor *= cont_factor2\n\t\t\t\tstellar_model.flux *= cont_factor\n\t\t\t\tif binary:\n\t\t\t\t\tmodel2.flux *= cont_factor\n\t\t\telse:\n\t\t\t\tmodel = smart.continuum(data=data, mdl=model)\n\t\t\t\tfor i in range(niter):\n\t\t\t\t\tmodel = smart.continuum(data=data, mdl=model)\n\t\telif data.instrument == 'apogee':\n\t\t\t## set the order in the continuum fit\n\t\t\tdeg = 5\n\t\t\t## because of the APOGEE bands, continuum is corrected from three pieces of the spectra\n\t\t\tdata0 = copy.deepcopy(data)\n\t\t\tmodel0 = copy.deepcopy(model)\n\n\t\t\t# wavelength offset\n\t\t\tmodel0.wave += wave_off1\n\n\t\t\trange0 = np.where((data0.wave >= data.oriWave0[0][-1]) & (data0.wave <= data.oriWave0[0][0]))\n\t\t\tdata0.wave = data0.wave[range0]\n\t\t\tdata0.flux = data0.flux[range0]\n\t\t\tif data0.wave[0] > data0.wave[-1]:\n\t\t\t\tdata0.wave = data0.wave[::-1]\n\t\t\t\tdata0.flux = data0.flux[::-1]\n\t\t\tmodel0.flux = np.array(smart.integralResample(xh=model0.wave, yh=model0.flux, xl=data0.wave))\n\t\t\tmodel0.wave = data0.wave\n\t\t\tmodel0 = smart.continuum(data=data0, mdl=model0, deg=deg)\n\t\t\t# flux corrections\n\t\t\tmodel0.flux = (model0.flux + c0_1) * np.e**(-c0_2)\n\n\t\t\tdata1 = copy.deepcopy(data)\n\t\t\tmodel1 = copy.deepcopy(model)\n\n\t\t\t# wavelength offset\n\t\t\tmodel1.wave += wave_off2\n\n\t\t\trange1 = np.where((data1.wave >= data.oriWave0[1][-1]) & (data1.wave <= data.oriWave0[1][0]))\n\t\t\tdata1.wave = data1.wave[range1]\n\t\t\tdata1.flux = data1.flux[range1]\n\t\t\tif data1.wave[0] > data1.wave[-1]:\n\t\t\t\tdata1.wave = data1.wave[::-1]\n\t\t\t\tdata1.flux = data1.flux[::-1]\n\t\t\tmodel1.flux = np.array(smart.integralResample(xh=model1.wave, yh=model1.flux, xl=data1.wave))\n\t\t\tmodel1.wave = data1.wave\n\t\t\tmodel1 = smart.continuum(data=data1, mdl=model1, deg=deg)\n\n\t\t\t# flux corrections\n\t\t\tmodel1.flux = (model1.flux + c1_1) * np.e**(-c1_2)\n\n\t\t\tdata2 = copy.deepcopy(data)\n\t\t\tmodel2 = copy.deepcopy(model)\n\n\t\t\t# wavelength offset\n\t\t\tmodel2.wave += wave_off3\n\n\t\t\trange2 = np.where((data2.wave >= data.oriWave0[2][-1]) & (data2.wave <= data.oriWave0[2][0]))\n\t\t\tdata2.wave = data2.wave[range2]\n\t\t\tdata2.flux = data2.flux[range2]\n\t\t\tif data2.wave[0] > data2.wave[-1]:\n\t\t\t\tdata2.wave = data2.wave[::-1]\n\t\t\t\tdata2.flux = data2.flux[::-1]\n\n\t\t\tmodel2.flux = np.array(smart.integralResample(xh=model2.wave, yh=model2.flux, xl=data2.wave))\n\t\t\tmodel2.wave = data2.wave\n\t\t\tmodel2 = smart.continuum(data=data2, mdl=model2, deg=deg)\n\t\t\t# flux corrections\n\t\t\tmodel2.flux = (model2.flux + c2_1) * np.e**(-c2_2)\n\n\t\t\t## scale the flux to be the same as the data\n\t\t\t#model0.flux *= (np.std(data0.flux)/np.std(model0.flux))\n\t\t\t#model0.flux -= np.median(model0.flux) - np.median(data0.flux)\n\n\t\t\t#model1.flux *= (np.std(data1.flux)/np.std(model1.flux))\n\t\t\t#model1.flux -= np.median(model1.flux) - np.median(data1.flux)\n\n\t\t\t#model2.flux *= (np.std(data2.flux)/np.std(model2.flux))\n\t\t\t#model2.flux -= np.median(model2.flux) - np.median(data2.flux)\n\n\t\t\tmodel.flux = np.array( list(model2.flux) + list(model1.flux) + list(model0.flux) )\n\t\t\tmodel.wave = np.array( list(model2.wave) + list(model1.wave) + list(model0.wave) )\n\n\tif instrument == 'nirspec':\n\t\t# flux offset\n\t\tmodel.flux += flux_offset\n\t\tif output_stellar_model: \n\t\t\tstellar_model.flux += flux_offset\n\t\t\tif binary:\n\t\t\t\tmodel2.flux += flux_offset\n\t#model.flux **= (1 + flux_exponent_offset)\n\n\tif output_stellar_model:\n\t\tif not binary:\n\t\t\treturn model, stellar_model\n\t\telse:\n\t\t\treturn model, stellar_model, model2\n\telse:\n\t\treturn model\n\n\n# Fringe Model; testing\n\ndef doub_sine(wave, a1, k1, a2, k2):\n # the initial guess is determined from the best frequency\n # wave (i.e. kx) multiplicative effects\n return (1 + a1**2 + 2 * a1*np.sin( k1 * wave )) * ( 1 + a2**2 + 2 * a2 * np.sin( k2*wave ))\n\ndef makeModelFringe(teff, logg=5, metal=0, vsini=1, rv=0, tell_alpha=1.0, airmass=1.0, pwv=0.5, wave_offset=0, flux_offset=0, \n\ta1_1=0.01, k1_1=2.10, a2_1=0.01, k2_1=0.85, a1_2=0.01, k1_2=2.10, a2_2=0.01, k2_2=0.85, \n\ta1_3=0.01, k1_3=2.10, a2_3=0.01, k2_3=0.85, a1_4=0.01, k1_4=2.10, a2_4=0.01, k2_4=0.85, **kwargs):\n\t\"\"\"\n\tReturn a forward model.\n\n\tParameters\n\t----------\n\tteff : effective temperature\n\t\n\tdata : an input science data used for continuum correction\n\n\tOptional Parameters\n\t-------------------\n\t\n\n\tReturns\n\t-------\n\tmodel: a synthesized model\n\t\"\"\"\n\n\t# read in the parameters\n\torder = kwargs.get('order', '33')\n\tmodelset = kwargs.get('modelset', 'btsettl08')\n\tinstrument = kwargs.get('instrument', 'nirspec')\n\tveiling = kwargs.get('veiling', 0) # flux veiling parameter\n\tlsf = kwargs.get('lsf', 4.5) # instrumental LSF\n\n\tif instrument == 'apogee':\n\t\ttry:\n\t\t\timport apogee_tools as ap\n\t\texcept ImportError:\n\t\t\tprint('Need to install the package \"apogee_tools\" (https://github.com/jbirky/apogee_tools) \\n')\n\t\txlsf = kwargs.get('xlsf', np.linspace(-7.,7.,43)) # APOGEE instrumental LSF sampling\n\t\twave_off1 = kwargs.get('wave_off1') # wavelength offset for chip a\n\t\twave_off2 = kwargs.get('wave_off2') # wavelength offset for chip b\n\t\twave_off3 = kwargs.get('wave_off3') # wavelength offset for chip c\n\t\tc0_1 = kwargs.get('c0_1') # constant flux offset for chip a\n\t\tc0_2 = kwargs.get('c0_2') # linear flux offset for chip a\n\t\tc1_1 = kwargs.get('c1_1') # constant flux offset for chip b\n\t\tc1_2 = kwargs.get('c1_2') # linear flux offset for chip b\n\t\tc2_1 = kwargs.get('c2_1') # constant flux offset for chip c\n\t\tc2_2 = kwargs.get('c2_2') # linear flux offset for chip c\n\n\ttell = kwargs.get('tell', True) # apply telluric\n\t#tell_alpha = kwargs.get('tell_alpha', 1.0) # Telluric alpha power\n\tbinary = kwargs.get('binary', False) # make a binary model\n\n\t# assume the secondary has the same metallicity\n\tif binary:\n\t\tteff2 = kwargs.get('teff2')\n\t\tlogg2 = kwargs.get('logg2')\n\t\trv2 = kwargs.get('rv2')\n\t\tvsini2 = kwargs.get('vsini2')\n\t\tflux_scale = kwargs.get('flux_scale', 0.8)\n\n\tdata = kwargs.get('data', None) # for continuum correction and resampling\n\n\toutput_stellar_model = kwargs.get('output_stellar_model', False)\n\t\n\tif data is not None and instrument == 'nirspec':\n\t\torder = data.order\n\t\t# read in a model\n\t\t#print('teff ',teff,'logg ',logg, 'z', z, 'order', order, 'modelset', modelset)\n\t\t#print('teff ',type(teff),'logg ',type(logg), 'z', type(z), 'order', type(order), 'modelset', type(modelset))\n\t\tmodel = smart.Model(teff=teff, logg=logg, metal=metal, order=str(order), modelset=modelset, instrument=instrument)\n\n\t#elif data is not None and instrument == 'apogee':\n\telif instrument == 'apogee':\n\t\tmodel = smart.Model(teff=teff, logg=logg, metal=metal, modelset=modelset, instrument=instrument)\n\t\t# Dirty fix here\n\t\tmodel.wave = model.wave[np.where(model.flux != 0)]\n\t\tmodel.flux = model.flux[np.where(model.flux != 0)]\n\n\t\t# apply vmicro\n\t\tvmicro = 2.478 - 0.325*logg\n\t\tmodel.flux = smart.broaden(wave=model.wave, flux=model.flux, vbroad=vmicro, rotate=False, gaussian=True)\n\t\n\telif data is None and instrument == 'nirspec':\n\t\tmodel = smart.Model(teff=teff, logg=logg, metal=metal, order=str(order), modelset=modelset, instrument=instrument)\n\t\n\t# wavelength offset\n\t#model.wave += wave_offset\n\n\t# apply vsini\n\tmodel.flux = smart.broaden(wave=model.wave, flux=model.flux, vbroad=vsini, rotate=True, gaussian=False)\n\t\n\t# apply rv (including the barycentric correction)\n\tmodel.wave = rvShift(model.wave, rv=rv)\n\t\n\t# flux veiling\n\tmodel.flux += veiling\n\n\t## if binary is True: make a binary model\n\tif binary:\n\t\tmodel2 = smart.Model(teff=teff2, logg=logg2, metal=metal, order=str(order), modelset=modelset, instrument=instrument)\n\t\t# apply vsini\n\t\tmodel2.flux = smart.broaden(wave=model2.wave, flux=model2.flux, vbroad=vsini2, rotate=True, gaussian=False)\n\t\t# apply rv (including the barycentric correction)\n\t\tmodel2.wave = rvShift(model2.wave, rv=rv2)\n\t\t# linearly interpolate the model2 onto the model1 grid\n\t\tfit = interp1d(model2.wave, model2.flux)\n\n\t\tselect_wavelength = np.where( (model.wave < model2.wave[-1]) & (model.wave > model2.wave[0]) )\n\t\tmodel.flux = model.flux[select_wavelength]\n\t\tmodel.wave = model.wave[select_wavelength]\n\n\t\t# combine the models together and scale the secondary flux\n\t\tmodel.flux += flux_scale * fit(model.wave)\n\n\tif output_stellar_model:\n\t\tstellar_model = copy.deepcopy(model)\n\t\tif binary:\n\t\t\tmodel2.flux = flux_scale * fit(model.wave)\n\n\t# apply telluric\n\tif tell is True:\n\t\tmodel = smart.applyTelluric(model=model, tell_alpha=tell_alpha, airmass=airmass, pwv=pwv)\n\n\t# instrumental LSF\n\tif instrument == 'nirspec':\n\t\tmodel.flux = smart.broaden(wave=model.wave, flux=model.flux, vbroad=lsf, rotate=False, gaussian=True)\n\telif instrument == 'apogee':\n\t\tmodel.flux = ap.apogee_hack.spec.lsf.convolve(model.wave, model.flux, lsf=lsf, xlsf=xlsf).flatten()\n\t\tmodel.wave = ap.apogee_hack.spec.lsf.apStarWavegrid()\n\t\t# Remove the NANs\n\t\tmodel.wave = model.wave[~np.isnan(model.flux)]\n\t\tmodel.flux = model.flux[~np.isnan(model.flux)]\n\n\tif output_stellar_model:\n\t\tstellar_model.flux = smart.broaden(wave=stellar_model.wave, flux=stellar_model.flux, vbroad=lsf, rotate=False, gaussian=True)\n\t\tif binary:\n\t\t\tmodel2.flux = smart.broaden(wave=model2.wave, flux=model2.flux, vbroad=lsf, rotate=False, gaussian=True)\n\n\t# wavelength offset\n\tmodel.wave += wave_offset\n\n\tif output_stellar_model: \n\t\tstellar_model.wave += wave_offset\n\t\tif binary:\n\t\t\tmodel2.wave = stellar_model.wave\n\n\t# integral resampling\n\tif data is not None:\n\t\tif instrument == 'nirspec':\n\t\t\tmodel.flux = np.array(smart.integralResample(xh=model.wave, yh=model.flux, xl=data.wave))\n\t\t\tmodel.wave = data.wave\n\n\t\t\tif output_stellar_model:\n\t\t\t\tstellar_model.flux = np.array(smart.integralResample(xh=stellar_model.wave, yh=stellar_model.flux, xl=data.wave))\n\t\t\t\tstellar_model.wave = data.wave\n\t\t\t\tif binary:\n\t\t\t\t\tmodel2.flux = np.array(smart.integralResample(xh=model2.wave, yh=model2.flux, xl=data.wave))\n\t\t\t\t\tmodel2.wave = data.wave\n\n\t\t# fringe modeling\n\t\tif instrument == 'nirspec':\n\t\t\t# Define the four piece-wise fringe model to include the k(wavelength) variation.\n\t\t\ts1, s2, s3, s4, s5 = 0, 200, 400, 600, -1\n\t\n\t\t\tmodel.flux[s1:s2] = model.flux[s1:s2] * doub_sine(wave=model.wave[s1:s2], a1=a1_1, k1=k1_1, a2=a2_1, k2=k2_1)\n\t\t\tmodel.flux[s2:s3] = model.flux[s2:s3] * doub_sine(wave=model.wave[s2:s3], a1=a1_2, k1=k1_2, a2=a2_2, k2=k2_2)\n\t\t\tmodel.flux[s3:s4] = model.flux[s3:s4] * doub_sine(wave=model.wave[s3:s4], a1=a1_3, k1=k1_3, a2=a2_3, k2=k2_3)\n\t\t\tmodel.flux[s4:s5] = model.flux[s4:s5] * doub_sine(wave=model.wave[s4:s5], a1=a1_4, k1=k1_4, a2=a2_4, k2=k2_4)\n\t\n\t\t\tif output_stellar_model:\n\t\t\t\tstellar_model.flux[s1:s2] = stellar_model.flux[s1:s2] * doub_sine(wave=model.wave[s1:s2], a1=a1_1, k1=k1_1, a2=a2_1, k2=k2_1)\n\t\t\t\tstellar_model.flux[s2:s3] = stellar_model.flux[s2:s3] * doub_sine(wave=model.wave[s2:s3], a1=a1_2, k1=k1_2, a2=a2_2, k2=k2_2)\n\t\t\t\tstellar_model.flux[s3:s4] = stellar_model.flux[s3:s4] * doub_sine(wave=model.wave[s3:s4], a1=a1_3, k1=k1_3, a2=a2_3, k2=k2_3)\n\t\t\t\tstellar_model.flux[s4:s5] = stellar_model.flux[s4:s5] * doub_sine(wave=model.wave[s4:s5], a1=a1_4, k1=k1_4, a2=a2_4, k2=k2_4)\n\n\t\t# contunuum correction\n\t\tif data.instrument == 'nirspec':\n\t\t\tniter = 5 # continuum iteration\n\t\t\tif output_stellar_model:\n\t\t\t\tmodel, cont_factor = smart.continuum(data=data, mdl=model, prop=True)\n\t\t\t\tfor i in range(niter):\n\t\t\t\t\tmodel, cont_factor2 = smart.continuum(data=data, mdl=model, prop=True)\n\t\t\t\t\tcont_factor *= cont_factor2\n\t\t\t\tstellar_model.flux *= cont_factor\n\t\t\t\tif binary:\n\t\t\t\t\tmodel2.flux *= cont_factor\n\t\t\telse:\n\t\t\t\tmodel = smart.continuum(data=data, mdl=model)\n\t\t\t\tfor i in range(niter):\n\t\t\t\t\tmodel = smart.continuum(data=data, mdl=model)\n\n\t\telif data.instrument == 'apogee':\n\t\t\t## set the order in the continuum fit\n\t\t\tdeg = 5\n\t\t\t## because of the APOGEE bands, continuum is corrected from three pieces of the spectra\n\t\t\tdata0 = copy.deepcopy(data)\n\t\t\tmodel0 = copy.deepcopy(model)\n\n\t\t\t# wavelength offset\n\t\t\tmodel0.wave += wave_off1\n\n\t\t\trange0 = np.where((data0.wave >= data.oriWave0[0][-1]) & (data0.wave <= data.oriWave0[0][0]))\n\t\t\tdata0.wave = data0.wave[range0]\n\t\t\tdata0.flux = data0.flux[range0]\n\t\t\tif data0.wave[0] > data0.wave[-1]:\n\t\t\t\tdata0.wave = data0.wave[::-1]\n\t\t\t\tdata0.flux = data0.flux[::-1]\n\t\t\tmodel0.flux = np.array(smart.integralResample(xh=model0.wave, yh=model0.flux, xl=data0.wave))\n\t\t\tmodel0.wave = data0.wave\n\t\t\tmodel0 = smart.continuum(data=data0, mdl=model0, deg=deg)\n\t\t\t# flux corrections\n\t\t\tmodel0.flux = (model0.flux + c0_1) * np.e**(-c0_2)\n\n\t\t\tdata1 = copy.deepcopy(data)\n\t\t\tmodel1 = copy.deepcopy(model)\n\n\t\t\t# wavelength offset\n\t\t\tmodel1.wave += wave_off2\n\n\t\t\trange1 = np.where((data1.wave >= data.oriWave0[1][-1]) & (data1.wave <= data.oriWave0[1][0]))\n\t\t\tdata1.wave = data1.wave[range1]\n\t\t\tdata1.flux = data1.flux[range1]\n\t\t\tif data1.wave[0] > data1.wave[-1]:\n\t\t\t\tdata1.wave = data1.wave[::-1]\n\t\t\t\tdata1.flux = data1.flux[::-1]\n\t\t\tmodel1.flux = np.array(smart.integralResample(xh=model1.wave, yh=model1.flux, xl=data1.wave))\n\t\t\tmodel1.wave = data1.wave\n\t\t\tmodel1 = smart.continuum(data=data1, mdl=model1, deg=deg)\n\n\t\t\t# flux corrections\n\t\t\tmodel1.flux = (model1.flux + c1_1) * np.e**(-c1_2)\n\n\t\t\tdata2 = copy.deepcopy(data)\n\t\t\tmodel2 = copy.deepcopy(model)\n\n\t\t\t# wavelength offset\n\t\t\tmodel2.wave += wave_off3\n\n\t\t\trange2 = np.where((data2.wave >= data.oriWave0[2][-1]) & (data2.wave <= data.oriWave0[2][0]))\n\t\t\tdata2.wave = data2.wave[range2]\n\t\t\tdata2.flux = data2.flux[range2]\n\t\t\tif data2.wave[0] > data2.wave[-1]:\n\t\t\t\tdata2.wave = data2.wave[::-1]\n\t\t\t\tdata2.flux = data2.flux[::-1]\n\n\t\t\tmodel2.flux = np.array(smart.integralResample(xh=model2.wave, yh=model2.flux, xl=data2.wave))\n\t\t\tmodel2.wave = data2.wave\n\t\t\tmodel2 = smart.continuum(data=data2, mdl=model2, deg=deg)\n\t\t\t# flux corrections\n\t\t\tmodel2.flux = (model2.flux + c2_1) * np.e**(-c2_2)\n\n\t\t\t## scale the flux to be the same as the data\n\t\t\t#model0.flux *= (np.std(data0.flux)/np.std(model0.flux))\n\t\t\t#model0.flux -= np.median(model0.flux) - np.median(data0.flux)\n\n\t\t\t#model1.flux *= (np.std(data1.flux)/np.std(model1.flux))\n\t\t\t#model1.flux -= np.median(model1.flux) - np.median(data1.flux)\n\n\t\t\t#model2.flux *= (np.std(data2.flux)/np.std(model2.flux))\n\t\t\t#model2.flux -= np.median(model2.flux) - np.median(data2.flux)\n\n\t\t\tmodel.flux = np.array( list(model2.flux) + list(model1.flux) + list(model0.flux) )\n\t\t\tmodel.wave = np.array( list(model2.wave) + list(model1.wave) + list(model0.wave) )\n\n\tif instrument == 'nirspec':\n\t\t# flux offset\n\t\tmodel.flux += flux_offset\n\t\tif output_stellar_model: \n\t\t\tstellar_model.flux += flux_offset\n\t\t\tif binary:\n\t\t\t\tmodel2.flux += flux_offset\n\t#model.flux **= (1 + flux_exponent_offset)\n\n\tif output_stellar_model:\n\t\tif not binary:\n\t\t\treturn model, stellar_model\n\t\telse:\n\t\t\treturn model, stellar_model, model2\n\telse:\n\t\treturn model \n\n# Fringe Model; testing\n\ndef rvShift(wavelength, rv):\n\t\"\"\"\n\tPerform the radial velocity correction.\n\n\tParameters\n\t----------\n\twavelength \t: \tnumpy array \n\t\t\t\t\tmodel wavelength (in Angstroms)\n\n\trv \t\t\t: \tfloat\n\t\t\t\t\tradial velocity shift (in km/s)\n\n\tReturns\n\t-------\n\twavelength \t: \tnumpy array \n\t\t\t\t\tshifted model wavelength (in Angstroms)\n\t\"\"\"\n\treturn wavelength * ( 1 + rv / 299792.458)\n\ndef applyTelluric(model, tell_alpha=1.0, airmass=1.5, pwv=0.5):\n\t\"\"\"\n\tApply the telluric model on the science model.\n\n\tParameters\n\t----------\n\tmodel \t:\tmodel object\n\t\t\t\tBT Settl model\n\talpha \t: \tfloat\n\t\t\t\ttelluric scaling factor (the power on the flux)\n\n\tReturns\n\t-------\n\tmodel \t: \tmodel object\n\t\t\t\tBT Settl model times the corresponding model\n\n\t\"\"\"\n\t# read in a telluric model\n\twavelow = model.wave[0] - 10\n\twavehigh = model.wave[-1] + 10\n\t#telluric_model = smart.getTelluric(wavelow=wavelow, wavehigh=wavehigh, alpha=alpha, airmass=airmass)\n\n\ttelluric_model = smart.Model()\n\ttelluric_model.wave, telluric_model.flux = \tsmart.InterpTelluricModel(wavelow=wavelow, wavehigh=wavehigh, airmass=airmass, pwv=pwv)\n\n\t# apply the telluric alpha parameter\n\ttelluric_model.flux = telluric_model.flux**(tell_alpha)\n\n\t#if len(model.wave) > len(telluric_model.wave):\n\t#\tprint(\"The model has a higher resolution ({}) than the telluric model ({}).\"\\\n\t#\t\t.format(len(model.wave),len(telluric_model.wave)))\n\t#\tmodel.flux = np.array(smart.integralResample(xh=model.wave, \n\t#\t\tyh=model.flux, xl=telluric_model.wave))\n\t#\tmodel.wave = telluric_model.wave\n\t#\tmodel.flux *= telluric_model.flux\n\n\t#elif len(model.wave) < len(telluric_model.wave):\n\t## This should be always true\n\ttelluric_model.flux = np.array(smart.integralResample(xh=telluric_model.wave, yh=telluric_model.flux, xl=model.wave))\n\ttelluric_model.wave = model.wave\n\tmodel.flux *= telluric_model.flux\n\n\t#elif len(model.wave) == len(telluric_model.wave):\n\t#\tmodel.flux *= telluric_model.flux\n\t\t\n\treturn model\n\ndef convolveTelluric(lsf, telluric_data, alpha=1.0, airmass='1.0', pwv='1.5'):\n\t\"\"\"\n\tReturn a convolved telluric transmission model given a telluric data and lsf.\n\t\"\"\"\n\t# get a telluric standard model\n\twavelow = telluric_data.wave[0] - 50\n\twavehigh = telluric_data.wave[-1] + 50\n\ttelluric_model = smart.getTelluric(wavelow=wavelow,wavehigh=wavehigh, airmass=airmass, pwv=pwv)\n\ttelluric_model.flux **= alpha\n\t# lsf\n\ttelluric_model.flux = smart.broaden(wave=telluric_model.wave, flux=telluric_model.flux, \n\t\tvbroad=lsf, rotate=False, gaussian=True)\n\t# resample\n\ttelluric_model.flux = np.array(smart.integralResample(xh=telluric_model.wave, \n\t\tyh=telluric_model.flux, xl=telluric_data.wave))\n\ttelluric_model.wave = telluric_data.wave\n\treturn telluric_model\n\ndef getLSF2(telluric_data, continuum=True, test=False, save_path=None):\n\t\"\"\"\n\tReturn a best LSF value from a telluric data.\n\t\"\"\"\n\t\n\tdata = copy.deepcopy(telluric_data)\n\n\tdef bestParams(data, i, alpha, c2, c0):\n\n\t\tdata2 = copy.deepcopy(data)\n\t\tdata2.wave = data2.wave + c0\n\t\ttelluric_model = smart.convolveTelluric(i, data2, alpha=alpha)\n\t\tmodel = smart.continuum(data=data2, mdl=telluric_model)\n\t\t#plt.figure(2)\n\t\t#plt.plot(model.wave, model.flux+c2, 'r-', alpha=0.5)\n\t\t#plt.plot(data.wave*c1+c0, data.flux, 'b-', alpha=0.5)\n\t\t#plt.close()\n\t\t#plt.show()\n\t\t#sys.exit()\n\t\treturn model.flux + c2\n\n\tdef bestParams2(theta, data):\n\n\t\ti, alpha, c2, c0, c1 = theta \n\t\tdata2 = copy.deepcopy(data)\n\t\tdata2.wave = data2.wave*c1 + c0\n\t\ttelluric_model = smart.convolveTelluric(i, data2, alpha=alpha)\n\t\tmodel = smart.continuum(data=data2, mdl=telluric_model)\n\t\treturn np.sum(data.flux - (model.flux + c2))**2\n\n\tfrom scipy.optimize import curve_fit, minimize\n\n\tpopt, pcov = curve_fit(bestParams, data, data.flux, p0=[4.01, 1.01, 0.01, 1.01], maxfev=1000000, epsfcn=0.1)\n\n\t#nll = lambda *args: bestParams2(*args)\n\t#results = minimize(nll, [3., 1., 0.1, -10., 1.], args=(data))\n\t#popt = results['x']\n\n\tdata.wave = data.wave+popt[3]\n\n\ttelluric_model = smart.convolveTelluric(popt[0], data, alpha=popt[1])\n\tmodel = smart.continuum(data=data, mdl=telluric_model)\n\n\t#model.flux * np.e**(-popt[2]) + popt[3]\n\tmodel.flux + popt[2]\n\n\treturn popt[0]\n\ndef getLSF(telluric_data, alpha=1.0, continuum=True,test=False,save_path=None):\n\t\"\"\"\n\tReturn a best LSF value from a telluric data.\n\t\"\"\"\n\tlsf_list = []\n\ttest_lsf = np.arange(3.0,13.0,0.1)\n\t\n\tdata = copy.deepcopy(telluric_data)\n\tif continuum is True:\n\t\tdata = smart.continuumTelluric(data=data)\n\n\tdata.flux **= alpha\n\tfor i in test_lsf:\n\t\ttelluric_model = smart.convolveTelluric(i,data)\n\t\tif telluric_data.order == 59:\n\t\t\ttelluric_model.flux **= 3\n\t\t\t# mask hydrogen absorption feature\n\t\t\tdata2 = copy.deepcopy(data)\n\t\t\ttell_mdl = copy.deepcopy(telluric_model)\n\t\t\tmask_pixel = 450\n\t\t\tdata2.wave = data2.wave[mask_pixel:]\n\t\t\tdata2.flux = data2.flux[mask_pixel:]\n\t\t\tdata2.noise = data2.noise[mask_pixel:]\n\t\t\ttell_mdl.wave = tell_mdl.wave[mask_pixel:]\n\t\t\ttell_mdl.flux = tell_mdl.flux[mask_pixel:]\n\n\t\t\tchisquare = smart.chisquare(data2,tell_mdl)\n\n\t\telse:\n\t\t\tchisquare = smart.chisquare(data,telluric_model)\n\t\tlsf_list.append([chisquare,i])\n\n\t\tif test is True:\n\t\t\tplt.plot(telluric_model.wave,telluric_model.flux+(i-3)*10+1,\n\t\t\t\t'r-',alpha=0.5)\n\n\tif test is True:\n\t\tplt.plot(data.wave,data.flux,\n\t\t\t'k-',label='telluric data',alpha=0.5)\n\t\tplt.title(\"Test LSF\",fontsize=15)\n\t\tplt.xlabel(\"Wavelength ($\\AA$)\",fontsize=12)\n\t\tplt.ylabel(\"Transmission + Offset\",fontsize=12)\n\t\tplt.minorticks_on()\n\t\tif save_path is not None:\n\t\t\tplt.savefig(save_path+\\\n\t\t\t\t\"/{}_O{}_lsf_data_mdl.png\"\\\n\t\t\t\t.format(data.name, data.order))\n\t\t#plt.show()\n\t\tplt.close()\n\n\t\tfig, ax = plt.subplots()\n\t\tfor i in range(len(lsf_list)):\n\t\t\tax.plot(lsf_list[i][1],lsf_list[i][0],'k.',alpha=0.5)\n\t\tax.plot(min(lsf_list)[1],min(lsf_list)[0],'r.',\n\t\t\tlabel=\"best LSF {} km/s\".format(min(lsf_list)[1]))\n\t\tax.set_xlabel(\"LSF (km/s)\",fontsize=12)\n\t\tax.set_ylabel(\"$\\chi^2$\",fontsize=11)\n\t\tplt.minorticks_on()\n\t\tplt.legend(fontsize=10)\n\t\tif save_path is not None:\n\t\t\tplt.savefig(save_path+\\\n\t\t\t\t\"/{}_O{}_lsf_chi2.png\"\\\n\t\t\t\t.format(data.name, data.order))\n\t\t#plt.show()\n\t\tplt.close()\n\n\tlsf = min(lsf_list)[1]\n\n\tif telluric_data.order == 61 or telluric_data.order == 62 \\\n\tor telluric_data.order == 63: #or telluric_data.order == 64:\n\t\tlsf = 5.5\n\t\tprint(\"The LSF is obtained from orders 60 and 65 (5.5 km/s).\")\n\n\treturn lsf\n\ndef getAlpha(telluric_data,lsf,continuum=True,test=False,save_path=None):\n\t\"\"\"\n\tReturn a best alpha value from a telluric data.\n\t\"\"\"\n\talpha_list = []\n\ttest_alpha = np.arange(0.1,7,0.1)\n\n\tdata = copy.deepcopy(telluric_data)\n\tif continuum is True:\n\t\tdata = smart.continuumTelluric(data=data)\n\n\tfor i in test_alpha:\n\t\ttelluric_model = smart.convolveTelluric(lsf,data,\n\t\t\talpha=i)\n\t\t#telluric_model.flux **= i \n\t\tif data.order == 59:\n\t\t\t# mask hydrogen absorption feature\n\t\t\tdata2 = copy.deepcopy(data)\n\t\t\ttell_mdl = copy.deepcopy(telluric_model)\n\t\t\tmask_pixel = 450\n\t\t\tdata2.wave = data2.wave[mask_pixel:]\n\t\t\tdata2.flux = data2.flux[mask_pixel:]\n\t\t\tdata2.noise = data2.noise[mask_pixel:]\n\t\t\ttell_mdl.wave = tell_mdl.wave[mask_pixel:]\n\t\t\ttell_mdl.flux = tell_mdl.flux[mask_pixel:]\n\n\t\t\tchisquare = smart.chisquare(data2,tell_mdl)\n\n\t\telse:\n\t\t\tchisquare = smart.chisquare(data,telluric_model)\n\t\talpha_list.append([chisquare,i])\n\n\t\tif test is True:\n\t\t\tplt.plot(telluric_model.wave,telluric_model.flux+i*10,\n\t\t\t\t'k-',alpha=0.5)\n\n\tif test is True:\n\t\tplt.plot(telluric_data.wave,telluric_data.flux,\n\t\t\t'r-',alpha=0.5)\n\t\tplt.rc('font', family='sans-serif')\n\t\tplt.title(\"Test Alpha\",fontsize=15)\n\t\tplt.xlabel(\"Wavelength ($\\AA$)\",fontsize=12)\n\t\tplt.ylabel(\"Transmission + Offset\",fontsize=12)\n\t\tplt.minorticks_on()\n\t\tif save_path is not None:\n\t\t\tplt.savefig(save_path+\\\n\t\t\t\t\"/{}_O{}_alpha_data_mdl.png\"\\\n\t\t\t\t.format(telluric_data.name,\n\t\t\t\t\ttelluric_data.order))\n\t\tplt.show()\n\t\tplt.close()\n\n\t\tfig, ax = plt.subplots()\n\t\tplt.rc('font', family='sans-serif')\n\t\tfor i in range(len(alpha_list)):\n\t\t\tax.plot(alpha_list[i][1],alpha_list[i][0],'k.',alpha=0.5)\n\t\tax.plot(min(alpha_list)[1],min(alpha_list)[0],'r.',\n\t\t\tlabel=\"best alpha {}\".format(min(alpha_list)[1]))\n\t\tax.set_xlabel(r\"$\\alpha$\",fontsize=12)\n\t\tax.set_ylabel(\"$\\chi^2$\",fontsize=12)\n\t\tplt.minorticks_on()\n\t\tplt.legend(fontsize=10)\n\t\tif save_path is not None:\n\t\t\tplt.savefig(save_path+\\\n\t\t\t\t\"/{}_O{}_alpha_chi2.png\"\\\n\t\t\t\t.format(telluric_data.name,\n\t\t\t\t\ttelluric_data.order))\n\t\tplt.show()\n\t\tplt.close()\n\n\talpha = min(alpha_list)[1]\n\n\treturn alpha\n\ndef getFringeFrequecy(tell_data, test=False):\n\t\"\"\"\n\tUse the Lomb-Scargle Periodogram to identify \n\tthe fringe pattern.\n\t\"\"\"\n\ttell_sp = copy.deepcopy(tell_data)\n\n\t## continuum correction\n\ttell_sp = smart.continuumTelluric(data=tell_sp, order=tell_sp.order)\n\n\t## get a telluric model\n\tlsf = smart.getLSF(tell_sp)\n\talpha = smart.getAlpha(tell_sp,lsf)\n\ttell_mdl = smart.convolveTelluric(lsf=lsf,\n\t\ttelluric_data=tell_sp,alpha=alpha)\n\n\t## fit the fringe pattern in the residual\n\tpgram_x = np.array(tell_sp.wave,float)[10:-10]\n\tpgram_y = np.array(tell_sp.flux - tell_mdl.flux,float)[10:-10]\n\toffset = np.mean(pgram_y)\n\tpgram_y -= offset\n\tmask = np.where(pgram_y - 1.5 * np.absolute(np.std(pgram_y)) > 0)\n\tpgram_x = np.delete(pgram_x, mask)\n\tpgram_y = np.delete(pgram_y, mask)\n\tpgram_x = np.array(pgram_x, float)\n\tpgram_y = np.array(pgram_y, float)\n\n\t#f = np.lismartace(0.01,10,100000)\n\tf = np.lismartace(1.0,10,100000)\n\n\t## Lomb Scargle Periodogram\n\tpgram = signal.lombscargle(pgram_x, pgram_y, f)\n\n\tif test:\n\t\tfig, ax = plt.subplots(figsize=(16,6))\n\t\tax.plot(f,pgram, 'k-', label='residual',alpha=0.5)\n\t\tax.set_xlabel('frequency')\n\t\tplt.legend()\n\t\tplt.show()\n\t\tplt.close()\n\n\treturn f[np.argmax(pgram)]\n\ndef initModelFit(sci_data, lsf, modelset='btsettl08'):\n\t\"\"\"\n\tConduct simple chisquare fit to obtain the initial parameters\n\tfor the forward modeling MCMC.\n\n\tThe function would calculate the chisquare for teff, logg, vini, rv, and alpha.\n\n\tParameters\n\t----------\n\tdata \t\t\t\t:\tspectrum object\n\t\t\t\t\t\t\tinput science data\n\n\tlsf \t\t\t\t:\tfloat\n\t\t\t\t\t\t\tline spread function for the NIRSPEC\n\n\tReturns\n\t-------\n\tbest_params_dic \t:\tdic\n\t\t\t\t\t\t\ta dictionary that stores the best parameters for \n\t\t\t\t\t\t\tteff, logg, vsini, rv, and alpha\n\n\tchisquare \t\t\t:\tint\n\t\t\t\t\t\t\tminimum chisquare\n\n\t\"\"\"\n\tdata = copy.deepcopy(sci_data)\n\n\t## set up the parameter grid for chisquare computation\n\tteff_array = np.arange(1200,3001,100)\n\tlogg_array = np.arange(3.5,5.51,0.5)\n\tvsini_array = np.arange(10,101,10)\n\trv_array = np.arange(-200,201,50)\n\talpha_array = np.arange(0.5,2.01,0.5)\n\tchisquare_array = np.empty(len(teff_array)*len(logg_array)*len(vsini_array)*len(rv_array)*len(alpha_array))\\\n\t.reshape(len(teff_array),len(logg_array),len(vsini_array),len(rv_array),len(alpha_array))\n\n\ttime1 = time.time()\n\tfor i, teff in enumerate(teff_array):\n\t\tfor j, logg in enumerate(logg_array):\n\t\t\tfor k, vsini in enumerate(vsini_array):\n\t\t\t\tfor l, rv in enumerate(rv_array):\n\t\t\t\t\tfor m, alpha in enumerate(alpha_array):\n\t\t\t\t\t\tmodel = smart.makeModel(teff, logg, 0.0, vsini, rv, alpha, 0, 0,\n\t\t\t\t\t\t\tlsf=lsf, order=str(data.order), data=data, modelset=modelset)\n\t\t\t\t\t\tchisquare_array[i,j,k,l,m] = smart.chisquare(data, model)\n\ttime2 = time.time()\n\tprint(\"total time:\",time2-time1)\n\n\tind = np.unravel_index(np.argmin(chisquare_array, axis=None), chisquare_array.shape)\n\tprint(\"ind \",ind)\n\tchisquare = chisquare_array[ind]\n\n\tbest_params_dic = {'teff':teff_array[ind[0]], 'logg':logg_array[ind[1]], \n\t'vsini':vsini_array[ind[2]], 'rv':rv_array[ind[3]], 'alpha':alpha_array[ind[4]]}\n\n\tprint(best_params_dic, chisquare)\n\n\treturn best_params_dic , chisquare\n\n", "meta": {"hexsha": "4a31a8e19d55d7ec282b17b451fbae2ca9a602b3", "size": 33577, "ext": "py", "lang": "Python", "max_stars_repo_path": "smart/forward_model/model_fit.py", "max_stars_repo_name": "chihchunhsu/smart", "max_stars_repo_head_hexsha": "c4d5668a0c44e9780290f7f7eba24726f5262b97", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 10, "max_stars_repo_stars_event_min_datetime": "2020-01-21T09:09:54.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-12T18:24:02.000Z", "max_issues_repo_path": "smart/forward_model/model_fit.py", "max_issues_repo_name": "chihchunhsu/smart", "max_issues_repo_head_hexsha": "c4d5668a0c44e9780290f7f7eba24726f5262b97", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 9, "max_issues_repo_issues_event_min_datetime": "2020-02-07T19:03:11.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-07T01:21:56.000Z", "max_forks_repo_path": "smart/forward_model/model_fit.py", "max_forks_repo_name": "chihchunhsu/smart", "max_forks_repo_head_hexsha": "c4d5668a0c44e9780290f7f7eba24726f5262b97", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-07-22T21:54:39.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-11T05:16:53.000Z", "avg_line_length": 35.2699579832, "max_line_length": 155, "alphanum_fraction": 0.683116419, "include": true, "reason": "import numpy,import scipy,from scipy,from astropy", "num_tokens": 11036, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.607663184043154, "lm_q2_score": 0.3174262591305011, "lm_q1q2_score": 0.19288825132214757}} {"text": "# Licensed under a 3-clause BSD style license - see LICENSE.rst\n\"\"\"\ndust --- Models for dust\n========================\n\n.. autosummary::\n :toctree: generated/\n\n Activity\n --------\n acrit\n\n Dust Models\n -----------\n AfrhoRadiation\n AfrhoScattered\n AfrhoThermal\n\n Phase functions\n ---------------\n phaseK\n phaseH\n phaseHM\n\n\"\"\"\n\nimport numpy as np\nimport astropy.units as u\nfrom astropy.units import Quantity\n\n__all__ = [\n 'acrit',\n\n 'AfrhoRadiation',\n 'AfrhoScattered',\n 'AfrhoThermal',\n\n 'phaseK',\n 'phaseH',\n 'phaseHM'\n]\n\ndef acrit(Q, vth, R, rho_g=Quantity(1, u.g / u.cm**3),\n rho_n=Quantity(0.3, u.g / u.cm**3), f_active=1.0):\n \"\"\"Maximum liftable grain radius from a spherical nucleus.\n\n See Meech and Svoren 2004, Comets II.\n\n Parameters\n ----------\n Q : Quantity\n Mass production rate of the driving gas.\n vth : Quantity\n Gas expansion speed.\n R : Quantity\n Nucleus radius.\n rho_g : Quantity, optional\n Grain density.\n rho_n : Quantity, optional\n Nucleus mean density.\n f_active : float, optional\n Active fraction of the nucleus.\n \n Returns\n -------\n a : Quantity\n Maximum liftable grain radius.\n\n \"\"\"\n\n from numpy import pi\n import astropy.constants as c\n\n a = 9 * Q * vth / (64 * pi**2 * rho_g * rho_n * R**3 * c.G)\n return a.to(u.um)\n\nclass AfrhoRadiation(object):\n \"\"\"Light from a comet coma parameterized by Afrho, or similar.\n\n Methods\n -------\n fluxd : Total flux density from the object.\n\n Notes\n -----\n Afrho should refer to the value at zero phase angle.\n\n Inheriting classes should override `fluxd`, and `__init__`\n functions. `__init__` should take a single argument, `Afrho` (or\n equivalent) as a Quantity.\n\n As much as possible, keyword arguments must have the same meaning\n in all derived models.\n\n \"\"\"\n\n def __init__(self, Afrho, **kwargs):\n pass\n\n def __call__(self, *args, **kwargs):\n return self.fluxd(*args, **kwargs)\n\n def fluxd(self, geom, wave, unit=None):\n pass\n\nclass AfrhoScattered(AfrhoRadiation):\n \"\"\"Scattered light from a comet coma parameterized by Afrho.\n\n If you use this model, please reference A'Hearn et al. (1984, AJ\n 89, 579-591) as the source of the Afrho parameter.\n\n Parameters\n ----------\n Afrho : Quantity\n The product of albedo at zero phase, A, dust filling factor, f,\n and observer's aperture radius, rho.\n phasef : function, optional\n The phase function of the coma. Set to `None` to use `phaseK`.\n\n Methods\n -------\n fluxd : Total flux density from the coma.\n\n \"\"\"\n\n def __init__(self, Afrho, phasef=None, **kwargs):\n self.Afrho = Afrho\n if phasef is None:\n self.phasef = phaseK\n else:\n self.phasef = phasef\n\n def fluxd(self, geom, wave, rap, unit=u.Unit('W / (m2 um)')):\n \"\"\"Flux density.\n\n Parameters\n ----------\n geom : dict of Quantities\n A dictionary-like object with the keys 'rh' (heliocentric\n distance), 'delta' (observer-target distance), and 'phase'\n (phase angle).\n wave : Quantity\n The wavelengths at which to compute the emission.\n rap : Quantity\n The aperture radius, angular or projected distance at the\n comet.\n unit : astropy Units, optional\n The return units. Must be spectral flux density.\n\n Returns\n -------\n fluxd : Quantityu\n The flux density from the coma.\n\n Raises\n ------\n ValueError : If `rap` has incorrect units.\n\n \"\"\"\n\n from ..calib import solar_flux\n\n if rap.unit.is_equivalent(u.cm):\n rho = rap.to(self.Afrho.unit)\n elif rap.unit.is_equivalent(u.arcsec):\n rho = geom['delta'].to(self.Afrho.unit) * rap.to(u.rad).value\n else:\n raise ValueError(\"rap must have angular or length units.\")\n\n fsun = solar_flux(wave, unit=unit) / geom['rh'].to(u.au).value**2\n fluxd = (self.Afrho\n * self.phasef(np.abs(geom['phase'].to(u.deg).value))\n * rho * fsun / 4.0 / geom['delta'].to(self.Afrho.unit)**2)\n\n return fluxd\n\nclass AfrhoThermal(AfrhoRadiation):\n \"\"\"Thermal emisson from a coma parameterized by efrho.\n\n If you use this model, please cite and reference Kelley et\n al. (2013, Icarus 225, 475-494). They define `epsilon-f-rho` as\n the product of IR emissivity (`epsilon`), dust filling factor\n (`f`), and observer's aperture radius (`rho`).\n\n The default `ef2af` is 3.5, which assumes `epsilion` is\n approximately 0.9, `A` is approximately 0.25, and the scattering\n and emission filling factors are the same. This value can roughly\n reproduce the spectral shape of 73P-C/Schwassmann-Wachmann in\n Fig. 16 of Sitko et al. (2011, AJ 142, 80) for `Tscale = 1.12`.\n\n The default long-wavelength slope, `beta = 0.89+/-0.10`, is from\n an analysis of Hyakutake JCMT data by Jewitt and Matthews (1997,\n AJ 113, 1145). The break-point, `wave0` = 70 um, is based on my\n own analysis, combining the Jewitt and Matthews fluxes with mid-IR\n fluxes from Mason et al. (1998, ApJ 507, 398).\n\n Parameters\n ----------\n Afrho : Quantity\n The product of albedo at zero phase, A, dust filling factor, f,\n and observer's aperture radius, rho.\n ef2af : float, optional\n The ratio of epsilon-f_therm to A-f_sca, where f_therm and f_sca\n are the effective thermal and scattered light filling factors,\n (they are not necessarily the same).\n Tscale : float, optional\n The isothermal blackbody sphere temperature scale factor that\n characterizes the spectral shape of the thermal emission.\n beta : float, optional\n wave0 : Quantity, optional\n Scale wavelengths longer than `wave0` by `(wave / wave0)**-beta`.\n\n Methods\n -------\n fluxd : Total flux density from the coma.\n\n \"\"\"\n\n def __init__(self, Afrho, ef2af=3.5, Tscale=1.1, beta=0.89,\n wave0=70 * u.um, **kwargs):\n assert isinstance(Afrho, u.Quantity)\n self.Afrho = Afrho\n self.ef2af = ef2af\n self.Tscale = Tscale\n self.beta = beta\n self.wave0 = wave0\n\n def fluxd(self, geom, wave, rap, unit=u.Unit('W / (m2 um)')):\n \"\"\"Flux density.\n\n Parameters\n ----------\n geom : dict of Quantities\n A dictionary-like object with the keys 'rh' (heliocentric\n distance), 'delta' (observer-target distance), and 'phase'\n (phase angle).\n wave : Quantity\n The wavelengths at which to compute the emission.\n rap : Quantity\n The aperture radius, angular or projected distance at the\n comet.\n unit : astropy Units, optional\n The return units. Must be spectral flux density.\n\n Returns\n -------\n fluxd : Quantity\n The flux density from the coma.\n\n Raises\n ------\n ValueError : If `rap` has incorrect units.\n\n \"\"\"\n\n from ..util import planck\n\n if rap.unit.is_equivalent(u.cm):\n rho = rap.to(self.Afrho.unit)\n elif rap.unit.is_equivalent(u.arcsec):\n rho = geom['delta'].to(self.Afrho.unit) * rap.to(u.rad).value\n else:\n raise ValueError(\"rap must have angular or length units.\")\n\n T = self.Tscale * 278 / np.sqrt(geom['rh'].to(u.au).value)\n B = planck(wave, T, unit=unit / u.sr).value\n efrho = self.Afrho * self.ef2af\n d = geom['delta'].to(self.Afrho.unit).value\n fluxd = efrho.value * np.pi * B * rho.value / d**2\n\n if any(wave > self.wave0):\n eps = np.ones(len(wave))\n i = wave > self.wave0\n eps[i] *= (wave[i] / self.wave0)**-self.beta\n fluxd *= eps\n\n return fluxd * unit\n\ndef phaseK(phase):\n \"\"\"Phase function derived from Kolokolova et al. (2004, Comets II).\n\n The phase function of K04 is scaled to phasef(0) = 1.0.\n\n Parameters\n ----------\n phase : float or array\n Phase angle. [degrees]\n\n Returns\n -------\n phi : float or ndarray\n The phase function.\n\n Notes\n -----\n To estimate the phase function, I fit a polynomial function to the\n solid line of Kolokolova et al. (2004, Comets II):\n\n a = array([0.27, 0.21, 0.17, 0.15, 0.14, 0.135, 0.135, 0.135, 0.15,\n 0.175, 0.225, 0.3, 0.43, 0.62, 0.775])\n b = array([0.0, 10, 20, 30, 40, 60, 70, 80, 100,\n 110, 120, 130, 140, 150, 156])\n fit = poly1d(polyfit(b, a / 0.27, 4))\n plot(b, a, 'o')\n plot(b, fit(b) * min(a), 'r-')\n\n \"\"\"\n\n phasef = np.poly1d([ 3.14105489e-08, -7.84714255e-06, 7.34255521e-04,\n -3.09608957e-02, 1.00920684e+00])\n return phasef(np.abs(phase))\n\ndef phaseH(phase):\n \"\"\"Halley phase function from Schleicher et al. (1998).\n\n The Halley phase function is from Schleicher et al. (1998, Icarus\n 132, 397-417). The Comet Halley observations were at phases less\n than 70 degrees.\n\n Parameters\n ----------\n phase : float or array\n Phase angle. [degrees]\n\n Returns\n -------\n phi : float or ndarray\n The phase function.\n\n \"\"\"\n\n phasef = np.poly1d([0.000177, -0.01807, 1])\n return phasef(np.abs(phase))\n\ndef phaseHM(phase):\n \"\"\"Halley-Marcus phase function from Schleicher et al. (2011).\n\n The Halley phase function is first published in Schleicher and\n Bair (2011, AJ 141, 117), but only described in detail by\n Schleicher and Marcus (May 2010) at:\n\n http://asteroid.lowell.edu/comet/dustphase.html\n\n \"To distinguish this curve from others, we designate this as the\n HM phase function, for the sources of the two components: Halley\n and Marcus, where the Halley curve for smaller phase angles\n comes from our previous work (Schleicher et al. 1998) while Joe\n Marcus has fit a Henyey-Greenstein function to a variety of mid-\n and large-phase angle data sets (Marcus 2007); see here for\n details. Note that we do not consider our composite curve to be\n a definitive result, but rather appropriate for performing\n first-order adjustments to dust measurements for changing phase\n angle.\"\n\n Parameters\n ----------\n phase : float or array\n Phase angle. [degrees]\n\n Returns\n -------\n phi : float or ndarray\n The phase function.\n\n \"\"\"\n\n from scipy.interpolate import splrep, splev\n\n th = np.arange(181)\n ph = np.array(\n [ 1.0000e+00, 9.5960e-01, 9.2170e-01, 8.8590e-01,\n 8.5220e-01, 8.2050e-01, 7.9060e-01, 7.6240e-01,\n 7.3580e-01, 7.1070e-01, 6.8710e-01, 6.6470e-01,\n 6.4360e-01, 6.2370e-01, 6.0490e-01, 5.8720e-01,\n 5.7040e-01, 5.5460e-01, 5.3960e-01, 5.2550e-01,\n 5.1220e-01, 4.9960e-01, 4.8770e-01, 4.7650e-01,\n 4.6590e-01, 4.5590e-01, 4.4650e-01, 4.3770e-01,\n 4.2930e-01, 4.2150e-01, 4.1420e-01, 4.0730e-01,\n 4.0090e-01, 3.9490e-01, 3.8930e-01, 3.8400e-01,\n 3.7920e-01, 3.7470e-01, 3.7060e-01, 3.6680e-01,\n 3.6340e-01, 3.6030e-01, 3.5750e-01, 3.5400e-01,\n 3.5090e-01, 3.4820e-01, 3.4580e-01, 3.4380e-01,\n 3.4210e-01, 3.4070e-01, 3.3970e-01, 3.3890e-01,\n 3.3850e-01, 3.3830e-01, 3.3850e-01, 3.3890e-01,\n 3.3960e-01, 3.4050e-01, 3.4180e-01, 3.4320e-01,\n 3.4500e-01, 3.4700e-01, 3.4930e-01, 3.5180e-01,\n 3.5460e-01, 3.5760e-01, 3.6090e-01, 3.6450e-01,\n 3.6830e-01, 3.7240e-01, 3.7680e-01, 3.8150e-01,\n 3.8650e-01, 3.9170e-01, 3.9730e-01, 4.0320e-01,\n 4.0940e-01, 4.1590e-01, 4.2280e-01, 4.3000e-01,\n 4.3760e-01, 4.4560e-01, 4.5400e-01, 4.6270e-01,\n 4.7200e-01, 4.8160e-01, 4.9180e-01, 5.0240e-01,\n 5.1360e-01, 5.2530e-01, 5.3750e-01, 5.5040e-01,\n 5.6380e-01, 5.7800e-01, 5.9280e-01, 6.0840e-01,\n 6.2470e-01, 6.4190e-01, 6.5990e-01, 6.7880e-01,\n 6.9870e-01, 7.1960e-01, 7.4160e-01, 7.6480e-01,\n 7.8920e-01, 8.1490e-01, 8.4200e-01, 8.7060e-01,\n 9.0080e-01, 9.3270e-01, 9.6640e-01, 1.0021e+00,\n 1.0399e+00, 1.0799e+00, 1.1223e+00, 1.1673e+00,\n 1.2151e+00, 1.2659e+00, 1.3200e+00, 1.3776e+00,\n 1.4389e+00, 1.5045e+00, 1.5744e+00, 1.6493e+00,\n 1.7294e+00, 1.8153e+00, 1.9075e+00, 2.0066e+00,\n 2.1132e+00, 2.2281e+00, 2.3521e+00, 2.4861e+00,\n 2.6312e+00, 2.7884e+00, 2.9592e+00, 3.1450e+00,\n 3.3474e+00, 3.5685e+00, 3.8104e+00, 4.0755e+00,\n 4.3669e+00, 4.6877e+00, 5.0418e+00, 5.4336e+00,\n 5.8682e+00, 6.3518e+00, 6.8912e+00, 7.4948e+00,\n 8.1724e+00, 8.9355e+00, 9.7981e+00, 1.0777e+01,\n 1.1891e+01, 1.3166e+01, 1.4631e+01, 1.6322e+01,\n 1.8283e+01, 2.0570e+01, 2.3252e+01, 2.6418e+01,\n 3.0177e+01, 3.4672e+01, 4.0086e+01, 4.6659e+01,\n 5.4704e+01, 6.4637e+01, 7.7015e+01, 9.2587e+01,\n 1.1237e+02, 1.3775e+02, 1.7060e+02, 2.1348e+02,\n 2.6973e+02, 3.4359e+02, 4.3989e+02, 5.6292e+02,\n 7.1363e+02, 8.8448e+02, 1.0533e+03, 1.1822e+03,\n 1.2312e+03])\n\n C = splrep(th, ph)\n return splev(np.abs(phase), C)\n\n\n# update module docstring\nfrom ..util import autodoc\nautodoc(globals())\ndel autodoc\n\n", "meta": {"hexsha": "bf011816b83edabf025aca46680b91cd2b7375ed", "size": 13780, "ext": "py", "lang": "Python", "max_stars_repo_path": "mskpy/models/dust.py", "max_stars_repo_name": "mkelley/mskpy", "max_stars_repo_head_hexsha": "41f41fd69bae71853abdfd2afbd535cd0b79c530", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 10, "max_stars_repo_stars_event_min_datetime": "2015-03-27T09:52:10.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-07T22:29:51.000Z", "max_issues_repo_path": "mskpy/models/dust.py", "max_issues_repo_name": "mkelley/mskpy", "max_issues_repo_head_hexsha": "41f41fd69bae71853abdfd2afbd535cd0b79c530", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2015-11-29T22:20:57.000Z", "max_issues_repo_issues_event_max_datetime": "2019-11-01T21:15:07.000Z", "max_forks_repo_path": "mskpy/models/dust.py", "max_forks_repo_name": "mkelley/mskpy", "max_forks_repo_head_hexsha": "41f41fd69bae71853abdfd2afbd535cd0b79c530", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2015-11-29T21:26:09.000Z", "max_forks_repo_forks_event_max_datetime": "2016-05-24T08:53:43.000Z", "avg_line_length": 32.2716627635, "max_line_length": 77, "alphanum_fraction": 0.576777939, "include": true, "reason": "import numpy,from numpy,from scipy,import astropy,from astropy", "num_tokens": 4784, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6076631556226292, "lm_q2_score": 0.31742626558767584, "lm_q1q2_score": 0.1928882462245139}} {"text": "from __future__ import annotations\nfrom typing import Optional, Tuple, Union, List, Dict\nimport torch\nimport numpy as np\nimport scipy.special\nfrom dqc.hamilton.base_hamilton import BaseHamilton\nfrom dqc.hamilton.hcgto_pbc import HamiltonCGTO_PBC\nfrom dqc.system.base_system import BaseSystem\nfrom dqc.grid.base_grid import BaseGrid\nfrom dqc.grid.factory import get_predefined_grid\nfrom dqc.system.mol import _parse_basis, _get_nelecs_spin, \\\n _get_orb_weights, AtomZsType, AtomPosType\nfrom dqc.utils.datastruct import CGTOBasis, AtomCGTOBasis, ZType, BasisInpType, \\\n SpinParam, DensityFitInfo\nfrom dqc.utils.safeops import safe_cdist\nfrom dqc.utils.periodictable import get_atom_mass\nfrom dqc.api.parser import parse_moldesc\nfrom dqc.hamilton.intor.lattice import Lattice\nfrom dqc.hamilton.intor.pbcintor import PBCIntOption\nfrom dqc.utils.cache import Cache\n\n__all__ = [\"Sol\"]\n\nclass Sol(BaseSystem):\n \"\"\"\n Describe the system of a solid (i.e. periodic boundary condition system).\n\n Arguments\n ---------\n * soldesc: str or 2-elements tuple\n Description of the molecule system.\n If string, it can be described like ``\"H 1 0 0; H -1 0 0\"``.\n If tuple, the first element of the tuple is the Z number of the atoms while\n the second element is the position of the atoms: ``(atomzs, atomposs)``.\n * basis: str, CGTOBasis, list of str, or CGTOBasis\n The string describing the gto basis. If it is a list, then it must have\n the same length as the number of atoms.\n * grid: int\n Describe the grid.\n If it is an integer, then it uses the default grid with specified level\n of accuracy.\n * spin: int, float, torch.Tensor, or None\n The difference between spin-up and spin-down electrons.\n It must be an integer or ``None``.\n If ``None``, then it is ``num_electrons % 2``.\n For floating point atomzs and/or charge, the ``spin`` must be specified.\n * charge: int, float, or torch.Tensor\n The charge of the molecule.\n * orb_weights: SpinParam[torch.Tensor] or None\n Specifiying the orbital occupancy (or weights) directly. If specified,\n ``spin`` and ``charge`` arguments are ignored.\n * dtype: torch.dtype\n The data type of tensors in this class.\n * device: torch.device\n The device on which the tensors in this class are stored.\n \"\"\"\n\n def __init__(self,\n soldesc: Union[str, Tuple[AtomZsType, AtomPosType]],\n alattice: torch.Tensor,\n basis: Union[str, List[CGTOBasis], List[str], List[List[CGTOBasis]]],\n *,\n grid: Union[int, str] = \"sg3\",\n spin: Optional[ZType] = None,\n lattsum_opt: Optional[Union[PBCIntOption, Dict]] = None,\n dtype: torch.dtype = torch.float64,\n device: torch.device = torch.device('cpu'),\n ):\n self._dtype = dtype\n self._device = device\n self._grid_inp = grid\n self._basis_inp = basis\n self._grid: Optional[BaseGrid] = None\n charge = 0 # we can't have charged solids for now\n\n # get the AtomCGTOBasis & the hamiltonian\n # atomzs: (natoms,) dtype: torch.int or dtype for floating point\n # atompos: (natoms, ndim)\n atomzs, atompos = parse_moldesc(soldesc, dtype, device)\n allbases = _parse_basis(atomzs, basis) # list of list of CGTOBasis\n atombases = [AtomCGTOBasis(atomz=atz, bases=bas, pos=atpos)\n for (atz, bas, atpos) in zip(atomzs, allbases, atompos)]\n self._atombases = atombases\n self._atompos = atompos # (natoms, ndim)\n self._atomzs = atomzs # (natoms,) int-type\n nelecs_tot: torch.Tensor = torch.sum(atomzs)\n\n # get the number of electrons and spin and orbital weights\n nelecs, spin, frac_mode = _get_nelecs_spin(nelecs_tot, spin, charge)\n assert not frac_mode, \"Fractional Z mode for pbc is not supported\"\n _orb_weights, _orb_weights_u, _orb_weights_d = _get_orb_weights(\n nelecs, spin, frac_mode, dtype, device)\n\n # initialize cache\n self._cache = Cache()\n\n # save the system's properties\n self._spin = spin\n self._charge = charge\n self._numel = nelecs\n self._orb_weights = _orb_weights\n self._orb_weights_u = _orb_weights_u\n self._orb_weights_d = _orb_weights_d\n self._alattice_inp = alattice\n self._lattice = Lattice(self._alattice_inp)\n self._lattsum_opt = PBCIntOption.get_default(lattsum_opt)\n\n def densityfit(self, method: Optional[str] = None,\n auxbasis: Optional[BasisInpType] = None) -> BaseSystem:\n \"\"\"\n Indicate that the system's Hamiltonian uses density fit for its integral.\n\n Arguments\n ---------\n method: Optional[str]\n Density fitting method. Available methods in this class are:\n\n * ``\"gdf\"``: Density fit with gdf compensating charge to perform\n the lattice sum. Ref https://doi.org/10.1063/1.4998644 (default)\n\n auxbasis: Optional[BasisInpType]\n Auxiliary basis for the density fit. If not specified, then it uses\n ``\"cc-pvtz-jkfit\"``.\n \"\"\"\n if method is None:\n method = \"gdf\"\n if auxbasis is None:\n # TODO: choose the auxbasis properly\n auxbasis = \"cc-pvtz-jkfit\"\n\n # get the auxiliary basis\n assert auxbasis is not None\n auxbasis_lst = _parse_basis(self._atomzs, auxbasis)\n atomauxbases = [AtomCGTOBasis(atomz=atz, bases=bas, pos=atpos)\n for (atz, bas, atpos) in zip(self._atomzs, auxbasis_lst, self._atompos)]\n\n # change the hamiltonian to have density fit\n df = DensityFitInfo(method=method, auxbases=atomauxbases)\n self._hamilton = HamiltonCGTO_PBC(self._atombases, df=df, latt=self._lattice,\n lattsum_opt=self._lattsum_opt,\n cache=self._cache.add_prefix(\"hamilton\"))\n return self\n\n def get_hamiltonian(self) -> BaseHamilton:\n \"\"\"\n Returns the Hamiltonian that corresponds to the system, i.e.\n :class:`~dqc.hamilton.HamiltonCGTO_PBC`\n \"\"\"\n return self._hamilton\n\n def set_cache(self, fname: str, paramnames: Optional[List[str]] = None) -> BaseSystem:\n \"\"\"\n Setup the cache of some parameters specified by `paramnames` to be read/written\n on a file.\n If the file exists, then the parameters will not be recomputed, but just\n loaded from the cache instead.\n Cache is usually used for repeated calculations where the cached parameters\n are not changed (e.g. running multiple systems with slightly different environment.)\n\n Arguments\n ---------\n fname: str\n The file to store the cache.\n paramnames: list of str or None\n List of parameter names to be read/write from the cache.\n \"\"\"\n self._cache.set(fname, paramnames)\n return self\n\n def get_orbweight(self, polarized: bool = False) -> Union[torch.Tensor, SpinParam[torch.Tensor]]:\n if not polarized:\n return self._orb_weights\n else:\n return SpinParam(u=self._orb_weights_u, d=self._orb_weights_d)\n\n def get_nuclei_energy(self) -> torch.Tensor:\n # self._atomzs: (natoms,)\n # self._atompos: (natoms, ndim)\n\n # r12: (natoms, natoms)\n r12_inf = safe_cdist(self._atompos, self._atompos, add_diag_eps=True, diag_inf=True)\n r12 = safe_cdist(self._atompos, self._atompos, add_diag_eps=True)\n z12 = self._atomzs.unsqueeze(-2) * self._atomzs.unsqueeze(-1) # (natoms, natoms)\n\n precision = self._lattsum_opt.precision\n eta = self._lattice.estimate_ewald_eta(precision) * 2\n vol = self._lattice.volume()\n rcut = scipy.special.erfcinv(float(vol.detach()) * eta * eta / (2 * np.pi) * precision) / eta\n gcut = scipy.special.erfcinv(precision * np.sqrt(np.pi) / 2 / eta) * 2 * eta\n\n # get the shift vector in real space and in reciprocal space\n ls = self._lattice.get_lattice_ls(rcut=rcut, exclude_zeros=True) # (nls, ndim)\n # gv: (ngv, ndim), gvweights: (ngv,)\n gv, gvweights = self._lattice.get_gvgrids(gcut=gcut, exclude_zeros=True)\n gv_norm2 = torch.einsum(\"gd,gd->g\", gv, gv) # (ngv)\n\n # get the shift in position\n atpos_shift = self._atompos - ls.unsqueeze(-2) # (nls, natoms, ndim)\n r12_ls = safe_cdist(atpos_shift, self._atompos) # (nls, natoms, natoms)\n\n # calculate the short range\n short_range_comp1 = torch.erfc(eta * r12_ls) / r12_ls # (nls, natoms, natoms)\n short_range_comp2 = torch.erfc(eta * r12) / r12_inf # (natoms, natoms)\n short_range1 = torch.sum(z12 * short_range_comp1) # scalar\n short_range2 = torch.sum(z12 * short_range_comp2) # scalar\n short_range = short_range1 + short_range2\n\n # calculate the long range sum\n coul_g = 4 * np.pi / gv_norm2 * gvweights # (ngv,)\n # this part below is quicker, but raises warning from pytorch\n si = torch.exp(1j * torch.matmul(self._atompos, gv.transpose(-2, -1))) # (natoms, ngv)\n zsi = torch.einsum(\"a,ag->g\", self._atomzs.to(si.dtype), si) # (ngv,)\n zexpg2 = zsi * torch.exp(-gv_norm2 / (4 * eta * eta))\n long_range = torch.einsum(\"a,a,a->\", zsi.conj(), zexpg2, coul_g.to(zsi.dtype)).real # (scalar)\n\n # # alternative way to compute the long-range part\n # r12_pair = self._atompos.unsqueeze(-2) - self._atompos # (natoms, natoms, ndim)\n # long_range_exp = torch.exp(-gv_norm2 / (4 * eta * eta)) * coul_g # (ngv,)\n # long_range_cos = torch.cos(torch.einsum(\"gd,abd->gab\", gv, -r12_pair)) # (ngv, natoms, natoms)\n # long_range = torch.sum(long_range_exp[:, None, None] * long_range_cos * z12) # scalar\n\n # background interaction\n vbar1 = -torch.sum(self._atomzs ** 2) * (2 * eta / np.sqrt(np.pi))\n vbar2 = -torch.sum(self._atomzs) ** 2 * np.pi / (eta * eta * vol)\n vbar = vbar1 + vbar2 # (scalar)\n\n eii = short_range + long_range + vbar\n return eii * 0.5\n\n def setup_grid(self) -> None:\n self._grid = get_predefined_grid(self._grid_inp, self._atomzs, self._atompos,\n lattice=self._lattice,\n dtype=self._dtype, device=self._device)\n\n def get_grid(self) -> BaseGrid:\n if self._grid is None:\n raise RuntimeError(\"Please run mol.setup_grid() first before calling get_grid()\")\n return self._grid\n\n def requires_grid(self) -> bool:\n return False\n\n def getparamnames(self, methodname: str, prefix: str = \"\") -> List[str]:\n pass\n\n def make_copy(self, **kwargs) -> Sol:\n \"\"\"\n Returns a copy of the system identical to the orginal except for new\n parameters set in the kwargs.\n\n Arguments\n ---------\n **kwargs\n Must be the same kwargs as Sol.\n \"\"\"\n # create dictionary of all parameters\n parameters = {\n 'soldesc': (self.atomzs, self.atompos),\n 'alattice': self._alattice_inp,\n 'basis': self._basis_inp,\n 'grid': self._grid_inp,\n 'spin': self._spin,\n 'lattsum_opt': self._lattsum_opt,\n 'dtype': self._dtype,\n 'device': self._device\n }\n # update dictionary with provided kwargs \n parameters.update(kwargs)\n # create new system\n return Sol(**parameters)\n\n ################### properties ###################\n @property\n def atompos(self) -> torch.Tensor:\n return self._atompos\n\n @property\n def atomzs(self) -> torch.Tensor:\n return self._atomzs\n\n @property\n def atommasses(self) -> torch.Tensor:\n # returns the atomic mass (only for non-isotope for now)\n return torch.tensor([get_atom_mass(int(atomz)) for atomz in self._atomzs],\n dtype=self._dtype, device=self._device)\n\n @property\n def spin(self) -> ZType:\n return self._spin\n\n @property\n def charge(self) -> ZType:\n return self._charge\n\n @property\n def numel(self) -> ZType:\n return self._numel\n\n @property\n def efield(self) -> Optional[Tuple[torch.Tensor, ...]]:\n # solid with external efield has not been implemented\n return None\n", "meta": {"hexsha": "a12bc0539f92767c6af6649384f18b1e9e0731b5", "size": 12689, "ext": "py", "lang": "Python", "max_stars_repo_path": "dqc/system/sol.py", "max_stars_repo_name": "sofroniewn/dqc", "max_stars_repo_head_hexsha": "0fe821fc92cb3457fb14f6dff0c223641c514ddb", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "dqc/system/sol.py", "max_issues_repo_name": "sofroniewn/dqc", "max_issues_repo_head_hexsha": "0fe821fc92cb3457fb14f6dff0c223641c514ddb", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "dqc/system/sol.py", "max_forks_repo_name": "sofroniewn/dqc", "max_forks_repo_head_hexsha": "0fe821fc92cb3457fb14f6dff0c223641c514ddb", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.8778877888, "max_line_length": 105, "alphanum_fraction": 0.6170699031, "include": true, "reason": "import numpy,import scipy", "num_tokens": 3287, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5312093733737563, "lm_q2_score": 0.36296921930155557, "lm_q1q2_score": 0.19281265153914087}} {"text": "##########################################################################################\n# Copyright (c) MemSQL. All rights reserved.\n# Licensed under the MIT License. See LICENSE in the project root for license information.\n##########################################################################################\n\n\"\"\"\ncycle.py\n\nDetect cyclical anomalies from a history\n\nA cyclical anomaly is a cycle in a Direct Serialization Graph (DGS) of the history,\nwhich encodes dependencies between txns.\n\nThere are three types of item dependencies:\n Write-depends (ww): T0 writes x_i and T_1 writes x_{i + 1}. There is a dependency from T0 to T1\n Read-depends (wr): T0 writes x_i and T_1 reads x_i. There is a dependency from T0 to T1\n Anti-depends (rw): T0 reads x_i and T_1 writes x_{i + 1}. There is a dependency from T0 to T1\n\nThere are also predicate dependencies. However, these are more difficult to inspect.\n\nFor instance, write predicate queries require visibility to what values were\nwritten and, more importantly, which values were *considered* when trying to match.\n\nPredicate write-read dependencies are also difficult, for the same reason: the\nonly advantage compared to regular item WR dependencies is to the values that\ndidn't match the predicate, to which we have no visibility; and the ones that\ndid match already appear in the history as regular item reads. The interesting\ncase is predicate anti-dependencies (which interestingly are the separation\nbetween REPEATABLE READ and SERIALIZABLE isolation). There is an anti dependency\nfrom the predicate read to the future writes which update objects to values\nwhich *would have matched* the predicate.\n\nThese dependencies represent edges on the DSG. One could think of a dependency\nfrom TA to TB as `TA needs to happen before TB`. As such, a topological order\nwould give a (possibly) valid ordering of the txns. However, cycles make it\nimpossible for such ordering to exist.\n\nThere are several of cyclical anomalies, whose description can be found\nin Atul Adya's PhD thesis. Some examples:\n G0 - cycle of ww dependencies\n eg: T1 writes w(0, 0) (0 -> [0]) |\n T2 writes w(0, 1) (0 -> [0,1]) | ww T1 -> T2\n T1 writes w(0, 2) (0->[0,1,2]) | ww T2 -> T1\n T1 commits, T2 commits. |\n\n G1b - cycle of ww and wr dependencies\n eg: T1 writes w(0, 0) (0 -> [0]) |\n T2 writes w(0, 1) (0 -> [0,1]) | ww T1 -> T2\n T1 reads r(0) -> [0,1] | wr T2 -> T1\n T1 commits, T2 commits. |\n\n G2 - cycle with at least one anti dependency\n eg: T1 writes w(0, 0) (0 -> [0]) |\n T2 writes w(0, 1) (0 -> [0,1]) | ww T1 -> T2\n T3 writes w(0, 2) (0 -> [0,1,2]) | ww T2 -> T3\n T3 reads r(0) -> [0,1,2] |\n T1 writes w(0, 3) (0 -> [0,1,2,3]) | rw T3 -> T1\n\n Gsingle - G2 where the cycle has exactly one anti dependency\n\"\"\"\n\nfrom frodo.domain import DBObject, Operation, Result\nfrom frodo.history import Anomaly, History, HistoryElem, ObservedTransaction\nfrom typing import Any, Dict, Iterable, List, Optional, Set, Tuple\n\nfrom abc import abstractmethod\n\nimport coloredlogs # type: ignore\nimport enum\nimport logging\nimport networkx as nx # type: ignore\n\n# setup logger\nlogger: logging.Logger = logging.getLogger(__name__)\ncoloredlogs.install(level=\"INFO\")\nlogger.setLevel(logging.INFO)\n\n\nclass DSG:\n \"\"\"\n Direct Serialization Graph of a history\n\n The direct serialization graph includes as nodes the transactions and\n as edges the dependencies. It is constructed directly from a recorded\n history of transactions.\n\n This representation allows for 3 high-level APIs:\n - find_cycles(): returns the list of *node* cycles\n - find_anomalies(anomaly_list): returns an iterable to the anomalies\n found in the graph which belong to the list\n - dump_dot() and dump_dots(): return DOT representation of the graph and\n the cycles, respectively. Accept a list of anomalies to match against\n \"\"\"\n\n class Edge:\n \"\"\"\n Edge in the DSG\n\n Note: all edges are directional\n \"\"\"\n\n class Type(enum.Enum):\n WW = enum.auto()\n WR = enum.auto()\n RW = enum.auto()\n PRW = enum.auto()\n\n def __repr__(self) -> str:\n if self.value == DSG.Edge.Type.WW.value:\n return \"ww\"\n elif self.value == DSG.Edge.Type.WR.value:\n return \"wr\"\n elif self.value == DSG.Edge.Type.RW.value:\n return \"rw\"\n else: # self.value == DSG.Edge.Type.PRW.value:\n return \"prw\"\n\n def __init__(self, etype: Type, target: Any): # cannot forward reference Node\n self._type: DSG.Edge.Type = etype\n self._target: Any = target # cannot forward reference Node\n\n def __repr__(self) -> str:\n return \"-> {}\".format(self.target)\n\n @property\n def type(self) -> Type:\n return self._type\n\n @property\n def target(self) -> Any: # cannot forward reference Node\n return self._target\n\n class Node:\n \"\"\"\n Node in the DSG\n \"\"\"\n\n def __init__(self, txn: ObservedTransaction):\n self._txn = txn\n self._edges: List[DSG.Edge] = list()\n\n def add_edge(self, etype: Any, target: Any) -> None: # surprisingly, neither Edge nor Node are in context here\n if (\n len(\n tuple(\n filter(\n lambda e: e.type == etype and e.target.txn.id == target.txn.id,\n self._edges,\n )\n )\n )\n == 0\n and self.txn.id != target.txn.id\n ): # prevent loops\n self._edges.append(DSG.Edge(etype, target))\n\n def __repr__(self) -> str:\n return \"T{}\".format(self.txn.id)\n\n @property\n def txn(self) -> ObservedTransaction:\n return self._txn\n\n @property\n def edges(self) -> List[Any]: # Edge not in context\n return self._edges\n\n def neighbours(self, edge_types: Set[Any]) -> List[Any]: # Edge and Node not in context\n \"\"\"\n Node neighbours reachable by one of the edge types in \n \"\"\"\n return list(\n set(\n map(\n lambda edge: edge.target,\n filter(lambda x: x.type in edge_types, self._edges),\n )\n )\n ) # remove duplicates\n\n class CyclicalAnomaly(Anomaly):\n \"\"\"\n An anomaly comprised of a cycle.\n It receives and identifies a cycle.\n \"\"\"\n\n # Anomaly Types\n #\n class CyclicalAnomalyType(Anomaly.Type):\n \"\"\"\n Abstract class for representing a cyclical anomaly\n\n The type needs:\n - provide a short description\n - be able to identify a cycle as matching its type\n - give the type of edges which can exist in its cycles\n (this is useful for limiting the cycles in the DSG)\n \"\"\"\n\n @abstractmethod\n def description(cls) -> str:\n pass\n\n @abstractmethod\n def identify_cycle(cls, node_cycle: List[Any], edge_cycle: List[Any]) -> bool:\n pass\n\n @abstractmethod\n def edge_types(cls) -> List[Any]:\n pass\n\n class G0(CyclicalAnomalyType):\n @classmethod\n def description(cls) -> str:\n return \"G0: write cycles\"\n\n @staticmethod\n def identify_cycle(node_cycle: List[Any], edge_cycle: List[Any]) -> bool:\n return all(e.type in DSG.CyclicalAnomaly.G0.edge_types() for e in edge_cycle)\n\n @classmethod\n def edge_types(cls) -> List[Any]:\n return [DSG.Edge.Type.WW]\n\n class G1C(CyclicalAnomalyType):\n @classmethod\n def description(cls) -> str:\n return \"G1c: circular information flow\"\n\n @staticmethod\n def identify_cycle(node_cycle: List[Any], edge_cycle: List[Any]) -> bool:\n return all(e.type in DSG.CyclicalAnomaly.G1C.edge_types() for e in edge_cycle)\n\n @classmethod\n def edge_types(cls) -> List[Any]:\n return [DSG.Edge.Type.WW, DSG.Edge.Type.WR]\n\n class G2item(CyclicalAnomalyType):\n @classmethod\n def description(cls) -> str:\n return \"G2-item: item anti dependency cycle\"\n\n @staticmethod\n def identify_cycle(node_cycle: List[Any], edge_cycle: List[Any]) -> bool:\n return all(e.type in DSG.CyclicalAnomaly.G2item.edge_types() for e in edge_cycle) and any(\n e.type == DSG.Edge.Type.RW for e in edge_cycle\n )\n\n @classmethod\n def edge_types(cls) -> List[Any]:\n return [DSG.Edge.Type.WW, DSG.Edge.Type.WR, DSG.Edge.Type.RW]\n\n class Gsingle(CyclicalAnomalyType):\n @classmethod\n def description(cls) -> str:\n return \"G-single: single anti dependency cycle\"\n\n @staticmethod\n def identify_cycle(node_cycle: List[Any], edge_cycle: List[Any]) -> bool:\n return (\n all(e.type in DSG.CyclicalAnomaly.Gsingle.edge_types() for e in edge_cycle)\n and sum(\n map(\n lambda e: 1 if e.type in [DSG.Edge.Type.RW, DSG.Edge.Type.PRW] else 0,\n edge_cycle,\n )\n )\n == 1\n )\n\n @classmethod\n def edge_types(cls) -> List[Any]:\n return [\n DSG.Edge.Type.WW,\n DSG.Edge.Type.WR,\n DSG.Edge.Type.RW,\n DSG.Edge.Type.PRW,\n ]\n\n class Gsingleitem(CyclicalAnomalyType):\n @classmethod\n def description(cls) -> str:\n return \"G-single-item: single item anti dependency cycle\"\n\n @staticmethod\n def identify_cycle(node_cycle: List[Any], edge_cycle: List[Any]) -> bool:\n return (\n all(e.type in DSG.CyclicalAnomaly.Gsingleitem.edge_types() for e in edge_cycle)\n and sum(map(lambda e: 1 if e.type == DSG.Edge.Type.RW else 0, edge_cycle)) == 1\n )\n\n @classmethod\n def edge_types(cls) -> List[Any]:\n return [DSG.Edge.Type.WW, DSG.Edge.Type.WR, DSG.Edge.Type.RW]\n\n class G2(CyclicalAnomalyType):\n @classmethod\n def description(cls) -> str:\n return \"G2: anti dependency cycle\"\n\n @staticmethod\n def identify_cycle(node_cycle: List[Any], edge_cycle: List[Any]) -> bool:\n return all(e.type in DSG.CyclicalAnomaly.G2.edge_types() for e in edge_cycle) and any(\n e.type in [DSG.Edge.Type.RW, DSG.Edge.Type.PRW] for e in edge_cycle\n )\n\n @classmethod\n def edge_types(cls) -> List[Any]:\n return [\n DSG.Edge.Type.WW,\n DSG.Edge.Type.WR,\n DSG.Edge.Type.RW,\n DSG.Edge.Type.PRW,\n ]\n\n class Gcursor(CyclicalAnomalyType):\n @classmethod\n def description(cls) -> str:\n return \"G-cursor: labeled single anti dependency cycle\"\n\n @staticmethod\n def identify_cycle(node_cycle: List[Any], edge_cycle: List[Any]) -> bool:\n return False # TODO: unimplemented\n\n @classmethod\n def edge_types(cls) -> List[Any]:\n return [] # TODO: unimplemented\n\n class GMSRA(CyclicalAnomalyType):\n @classmethod\n def description(cls) -> str:\n return \"G-MSRa: action interference\"\n\n @staticmethod\n def identify_cycle(node_cycle: List[Any], edge_cycle: List[Any]) -> bool:\n return False # TODO: unimplemented\n\n @classmethod\n def edge_types(cls) -> List[Any]:\n return [] # TODO: unimplemented\n\n class GMSRB(CyclicalAnomalyType):\n @classmethod\n def description(cls) -> str:\n return \"G-MSRb: action missed\"\n\n @staticmethod\n def identify_cycle(node_cycle: List[Any], edge_cycle: List[Any]) -> bool:\n return False # TODO: unimplemented\n\n @classmethod\n def edge_types(cls) -> List[Any]:\n return [] # TODO: unimplemented\n\n class GMSR(CyclicalAnomalyType):\n @classmethod\n def description(cls) -> str:\n return \"G-MSRb: action missed\"\n\n @staticmethod\n def identify_cycle(node_cycle: List[Any], edge_cycle: List[Any]) -> bool:\n return DSG.CyclicalAnomaly.GMSRA.identify_cycle(\n node_cycle, edge_cycle\n ) or DSG.CyclicalAnomaly.GMSRB.identify_cycle(node_cycle, edge_cycle)\n\n @classmethod\n def edge_types(cls) -> List[Any]:\n return [] # TODO: unimplemented\n\n class Gmonotonic(CyclicalAnomalyType):\n @classmethod\n def description(cls) -> str:\n return \"G-monotonic: monotonic reads\"\n\n @staticmethod\n def identify_cycle(node_cycle: List[Any], edge_cycle: List[Any]) -> bool:\n return False # TODO: unimplemented\n\n @classmethod\n def edge_types(cls) -> List[Any]:\n return [] # TODO: unimplemented\n\n class GSIA(CyclicalAnomalyType):\n @classmethod\n def description(cls) -> str:\n return \"G-SIa: interference\"\n\n @staticmethod\n def identify_cycle(node_cycle: List[Any], edge_cycle: List[Any]) -> bool:\n return False # TODO: unimplemented\n\n @classmethod\n def edge_types(cls) -> List[Any]:\n return [] # TODO: unimplemented\n\n class GSIB(CyclicalAnomalyType):\n @classmethod\n def description(cls) -> str:\n return \"G-SIb: missed effects\"\n\n @staticmethod\n def identify_cycle(node_cycle: List[Any], edge_cycle: List[Any]) -> bool:\n return False # TODO: unimplemented\n\n @classmethod\n def edge_types(cls) -> List[Any]:\n return [] # TODO: unimplemented\n\n class GSI(CyclicalAnomalyType):\n @classmethod\n def description(cls) -> str:\n return \"G-SI: snapshot isolation violation\"\n\n @staticmethod\n def identify_cycle(node_cycle: List[Any], edge_cycle: List[Any]) -> bool:\n return DSG.CyclicalAnomaly.GSIA.identify_cycle(\n node_cycle, edge_cycle\n ) or DSG.CyclicalAnomaly.GSIB.identify_cycle(node_cycle, edge_cycle)\n\n @classmethod\n def edge_types(cls) -> List[Any]:\n return [] # TODO: unimplemented\n\n class Gupdate(CyclicalAnomalyType):\n @classmethod\n def description(cls) -> str:\n return \"G-update: single anti dependency cycle with update transmission\"\n\n @staticmethod\n def identify_cycle(node_cycle: List[Any], edge_cycle: List[Any]) -> bool:\n return False # TODO: unimplemented\n\n @classmethod\n def edge_types(cls) -> List[Any]:\n return [] # TODO: unimplemented\n\n @staticmethod\n def safe_implies(anomaly_type: Any) -> Optional[List[Any]]:\n \"\"\"\n Implication between cyclical dependencies without throwing exceptions\n \"\"\"\n if anomaly_type == DSG.CyclicalAnomaly.G0:\n return [DSG.CyclicalAnomaly.G1C]\n if anomaly_type == DSG.CyclicalAnomaly.G1C:\n return [DSG.CyclicalAnomaly.G1]\n if anomaly_type == DSG.CyclicalAnomaly.Gmonotonic:\n return [DSG.CyclicalAnomaly.G2item]\n if anomaly_type == DSG.CyclicalAnomaly.Gcursor:\n return [DSG.CyclicalAnomaly.G2item, DSG.CyclicalAnomaly.Gsingle]\n if anomaly_type == DSG.CyclicalAnomaly.GMSRA:\n return [DSG.CyclicalAnomaly.GMSR]\n if anomaly_type == DSG.CyclicalAnomaly.GMSRB:\n return [DSG.CyclicalAnomaly.GMSR]\n if anomaly_type == DSG.CyclicalAnomaly.GSIA:\n return [DSG.CyclicalAnomaly.GSI]\n if anomaly_type == DSG.CyclicalAnomaly.GSIB:\n return [DSG.CyclicalAnomaly.GSI]\n if anomaly_type == DSG.CyclicalAnomaly.Gupdate:\n return [DSG.CyclicalAnomaly.G2]\n if anomaly_type == DSG.CyclicalAnomaly.GMSR:\n return [DSG.CyclicalAnomaly.G2]\n if anomaly_type == DSG.CyclicalAnomaly.GSI:\n return [DSG.CyclicalAnomaly.G2]\n if anomaly_type == DSG.CyclicalAnomaly.Gsingleitem:\n return [DSG.CyclicalAnomaly.Gsingle, DSG.CyclicalAnomaly.G2item]\n if anomaly_type == DSG.CyclicalAnomaly.Gsingle:\n return [DSG.CyclicalAnomaly.G2]\n if anomaly_type == DSG.CyclicalAnomaly.G2item:\n return [DSG.CyclicalAnomaly.G2]\n if anomaly_type == DSG.CyclicalAnomaly.G2:\n return []\n return None\n\n @staticmethod\n def cyclical_implies(cls: Any) -> List[Any]:\n \"\"\"\n Implication between cyclical dependencies\n \"\"\"\n implies: List[Any] = DSG.CyclicalAnomaly.safe_implies(cls)\n if implies is None:\n raise ValueError(\"Unknown anomaly type: {}\".format(cls))\n return implies\n\n @staticmethod\n def cyclical_closure(a: Any) -> List[Any]:\n \"\"\"\n Compute transitive closure of a cyclical anomaly type\n \"\"\"\n\n def aux(l: List[Any], additions: List[Any]) -> List[Any]:\n if len(additions) == 0:\n return l\n return aux(\n l + additions,\n list(\n sum(\n filter(\n lambda x: x is not None,\n map(\n lambda y: DSG.CyclicalAnomaly.safe_implies(y),\n additions,\n ),\n ),\n [],\n )\n ),\n )\n\n return aux(list(), [a])\n\n def __init__(\n self,\n dsg: Any,\n node_cycle: List[Any],\n edge_cycle: List[Any],\n final_txn: ObservedTransaction,\n ):\n if len(node_cycle) != len(edge_cycle):\n raise ValueError(\n \"Node cycle and edge cycles need to have the same size: {} vs {}\".format(node_cycle, edge_cycle)\n )\n elif len(node_cycle) < 2:\n raise ValueError(\"Need at least two nodes in the cycle: {}\".format(node_cycle))\n elif edge_cycle[-1].target != node_cycle[0]:\n raise ValueError(\n \"If the target of the last edge is not the first node, this isn't a cycle: {} vs {}\".format(\n edge_cycle[-1].target, node_cycle[0]\n )\n )\n\n self._node_cycle: List[DSG.Node] = node_cycle\n self._edge_cycle: List[DSG.Edge] = edge_cycle\n self._final_txn: ObservedTransaction = final_txn\n self._dsg: DSG = dsg\n\n def type(self) -> CyclicalAnomalyType:\n \"\"\"\n To identify the cycle, it gives it to each anomaly type\n After getting the matches, it finds the one which isn't implied by any\n\n This assumes that there are no cycles the implication graph of anomalies.\n Moreover, one cycle should have one (and only one) fundamental anomaly\n (ie: it shouldn't match unrelated anomalies)\n \"\"\"\n possible_types: List[Any] = [\n DSG.CyclicalAnomaly.G0,\n DSG.CyclicalAnomaly.G1C,\n DSG.CyclicalAnomaly.Gmonotonic,\n DSG.CyclicalAnomaly.Gcursor,\n DSG.CyclicalAnomaly.GMSRA,\n DSG.CyclicalAnomaly.GMSRB,\n DSG.CyclicalAnomaly.GSIA,\n DSG.CyclicalAnomaly.GSIB,\n DSG.CyclicalAnomaly.Gupdate,\n DSG.CyclicalAnomaly.GMSR,\n DSG.CyclicalAnomaly.GSI,\n DSG.CyclicalAnomaly.Gsingleitem,\n DSG.CyclicalAnomaly.Gsingle,\n DSG.CyclicalAnomaly.G2item,\n DSG.CyclicalAnomaly.G2,\n ]\n\n matched_types: List[Any] = list(\n filter(\n lambda x: x.identify_cycle(self._node_cycle, self._edge_cycle),\n possible_types,\n )\n )\n if len(matched_types) == 0:\n raise ValueError(\"Unknown anomaly: {}, {}\".format(self._node_cycle, self._edge_cycle))\n\n minimal_types: List[Any] = list()\n for idx, t in enumerate(matched_types):\n if all(\n t not in DSG.CyclicalAnomaly.cyclical_closure(s)\n for s in matched_types[:idx] + matched_types[idx + 1 :]\n ):\n minimal_types.append(t)\n\n if len(minimal_types) != 1:\n raise ValueError(\n \"It should be impossible for there to be more than one minimal type: {}\".format(minimal_types)\n )\n\n return minimal_types[0]\n\n def txns(self) -> List[ObservedTransaction]:\n if any(node.txn.id == self._final_txn.id for node in self._node_cycle):\n return [node.txn for node in self._node_cycle]\n else:\n return [node.txn for node in self._node_cycle] + [self._final_txn]\n\n def explanation(self) -> List[str]:\n def explain_dependency(dsg: DSG, orig: DSG.Node, edge: DSG.Edge) -> str:\n \"\"\"\n Explain a dependency\n \"\"\"\n obj_id: Optional[int]\n ver: Optional[List[int]]\n _, _, obj_id, ver = next(\n filter(\n lambda x: x[0] == edge.type and x[1] == edge.target.txn.id,\n dsg.find_dependencies(orig),\n ),\n (None, None, None, None),\n )\n\n if obj_id is None:\n raise RuntimeError(\n \"The {} dependency from T{} to T{} could not be recovered\".format(\n edge.type, orig.txn.id, edge.target.txn.id\n )\n )\n\n dep_msg: str\n if edge.type == DSG.Edge.Type.WW:\n dep_msg = \"T{} wrote version {} and T{} wrote version {} [object {}] (Write dependency)\".format(\n orig.txn.id, ver[:-1], edge.target.txn.id, ver, obj_id\n )\n elif edge.type == DSG.Edge.Type.WR:\n dep_msg = \"T{} wrote version {} and T{} read version {} [object {}] (Read dependency)\".format(\n orig.txn.id, ver, edge.target.txn.id, ver, obj_id\n )\n elif edge.type == DSG.Edge.Type.RW:\n dep_msg = \"T{} read version {} and T{} wrote version {} [object {}] (Item Anti dependency)\".format(\n orig.txn.id, ver[:-1], edge.target.txn.id, ver, obj_id\n )\n elif edge.type == DSG.Edge.Type.PRW:\n dep_msg = \"T{} didn't read the object because it was two small (required len > {}), and T{} wrote the first version which matched: {} [object {}] (Predicate Anti dependency)\".format(\n orig.txn.id, len(ver) - 1, edge.target.txn.id, ver, obj_id\n )\n\n return \"T{} < T{}, because {}\".format(orig.txn.id, edge.target.txn.id, dep_msg)\n\n msgs: List[str] = [\n explain_dependency(self._dsg, orig, edge) for orig, edge in zip(self._node_cycle, self._edge_cycle)\n ]\n msgs[-1] = \"But {}\".format(msgs[-1])\n msgs.append(\"This means we have a cycle (and an anomaly)\")\n return msgs\n\n def __init__(self, hist: History):\n \"\"\"\n Initialize the DSG:\n - uncommitted transactions are filtered out\n -\n \"\"\"\n self._hist: History = hist\n self._nodes: List[DSG.Node] = list()\n for txn_id in range(self._hist.txn_range()[0], self._hist.txn_range()[1] + 1):\n txn: ObservedTransaction = self._hist.get_observed_txn(txn_id)\n if self._hist.txn_state(txn_id) == History.TransactionState.COMMITTED:\n self._nodes.append(DSG.Node(txn))\n\n self._nodes = sorted(self._nodes, key=lambda n: n.txn.id)\n self._cycles: Dict[Tuple[Any, ...], List[List[DSG.Node]]] = dict() # memoization\n self._dependencies: Dict[DSG.Node, List[Tuple[DSG.Edge.Type, int, int, List[int]]]] = dict() # memoization\n\n logger.info(\"finding dependencies between {} transactions\".format(len(self._nodes)))\n for node in self._nodes:\n for etype, txn_id, _, _ in self.find_dependencies(node):\n node.add_edge(etype, self.get_node(txn_id))\n logger.info(\"constructed the Direct Serialization Graph\")\n\n def find_dependencies(self, node: Node) -> List[Tuple[Edge.Type, int, int, List[int]]]:\n \"\"\"\n Finds the dependencies originating from the node\n Returns the edge type, target txn id, obj_id, version\n \"\"\"\n\n def longest_ver(vers: List[List[int]], val: int) -> List[int]:\n \"\"\"\n find the longest version containing \n \"\"\"\n\n longest_ver: List[int] = list()\n for ver in filter(lambda v: val in v, vers):\n if len(ver) > len(longest_ver):\n longest_ver = ver\n\n if len(longest_ver) == 0:\n raise ValueError(\"Could not find any version containing {}: {}\".format(val, vers))\n\n return longest_ver\n\n def is_prefix(a: List[Any], b: List[Any]) -> bool:\n if len(a) > len(b):\n return False\n return all(a_el == b_el for a_el, b_el in zip(a, b))\n\n if node in self._dependencies:\n return self._dependencies[node]\n\n deps: List[Tuple[DSG.Edge.Type, int, int, List[int]]] = list()\n for el in filter(\n lambda e: e.op.type\n in [\n Operation.Type.WRITE,\n Operation.Type.READ,\n Operation.Type.PREDICATE_READ,\n ],\n node.txn.hist,\n ):\n if el.op.type in [Operation.Type.WRITE, Operation.Type.READ]:\n committed_vers: List[List[int]] = self._hist.committed_versions(el.op.obj.id)\n idx: int\n ver: List[int]\n if el.op.type == Operation.Type.WRITE:\n ver = longest_ver(committed_vers, el.op.value)\n idx = ver.index(el.op.value)\n if idx + 1 < len(ver):\n deps.append(\n (\n DSG.Edge.Type.WW,\n self._hist.who_wrote(el.op.obj.id, ver[idx + 1]).txn_id,\n el.op.obj.id,\n ver[: idx + 2],\n )\n )\n\n for next_el in self._hist.who_read(el.op.obj.id, el.op.value):\n deps.append(\n (\n DSG.Edge.Type.WR,\n next_el.txn_id,\n el.op.obj.id,\n ver[: idx + 1],\n )\n )\n elif el.op.type == Operation.Type.READ:\n ver = longest_ver(committed_vers, el.res.value()[-1])\n idx = ver.index(el.res.value()[-1])\n if idx + 1 < len(ver):\n deps.append(\n (\n DSG.Edge.Type.RW,\n self._hist.who_wrote(el.op.obj.id, ver[idx + 1]).txn_id,\n el.op.obj.id,\n ver[: idx + 2],\n )\n )\n elif el.op.type == Operation.Type.PREDICATE_READ:\n boundary_len = el.op.value\n # We have a predicate anti-dependency to operations\n # which write the first version of an object which would be inserted\n # but wasn't seen by the predicate read\n #\n # We ignore predicate read-dependencies because they are invisible\n # (ie: Tj pred-read-depends on Ti if Ti writes xi and Tj accesses\n # xi but doens't match the predicate).\n #\n # The values which *are* matched, have direct item-read-dependencies\n #\n for dep in filter(\n lambda x: x.op.type == Operation.Type.WRITE\n and len(x.op.value_written) == boundary_len + 1\n and not any(is_prefix(x.op.value_written, v[1]) for v in el.res.values()),\n self._hist,\n ):\n deps.append(\n (\n DSG.Edge.Type.PRW,\n dep.txn_id,\n dep.op.obj.id,\n dep.op.value_written,\n )\n )\n\n result: List[Tuple[DSG.Edge.Type, int, int, List[int]]] = list(\n filter(\n lambda x: self._hist.txn_state(x[1]) == History.TransactionState.COMMITTED,\n deps,\n )\n )\n self._dependencies[node] = result\n return result\n\n def get_node(self, txn_id: int) -> Node:\n node: Optional[DSG.Node] = next(filter(lambda n: n.txn.id == txn_id, self._nodes), None)\n if node is None:\n raise KeyError(\"Transaction T{} does not exist in the graph\".format(txn_id))\n return node\n\n def find_cycles(self, anom_types: List[Any]) -> Iterable[List[Node]]:\n \"\"\"\n Find cycles in the DSG\n \"\"\"\n\n def convert_cycle(node_map: Dict[int, DSG.Node], cycle: List[int]) -> List[DSG.Node]:\n \"\"\"\n Convert a cycle as a list of ints (txn ids) to nodes\n \"\"\"\n return [node_map[txn_id] for txn_id in cycle]\n\n anom_types = sorted(anom_types, key=lambda x: repr(x))\n if tuple(anom_types) in self._cycles:\n for c in self._cycles[tuple(anom_types)]:\n yield c\n return None\n\n edge_types: Set[DSG.Edge.Type] = set(sum((anomaly.edge_types() for anomaly in anom_types), []))\n\n graph: nx.DiGraph = nx.DiGraph()\n for node in self._nodes:\n graph.add_node(node.txn.id)\n for neigh in node.neighbours(edge_types):\n graph.add_edge(node.txn.id, neigh.txn.id)\n\n logger.info(\"finding cyclic anomalies (this might take a while)\")\n cycles: List[List[DSG.Node]] = list()\n node_map: Dict[int, DSG.Node] = {n.txn.id: n for n in self._nodes}\n for cycle in nx.simple_cycles(graph):\n converted: List[DSG.Node] = convert_cycle(node_map, cycle)\n cycles.append(converted)\n yield converted\n\n self._cycles[tuple(anom_types)] = cycles\n logger.info(\"found {} node cycles in the DSG\".format(len(self._cycles[tuple(anom_types)])))\n\n def find_anomalies(self, anomalies: List[Any]) -> Iterable[Anomaly]:\n def classify_cycle(node_cycle: List[DSG.Node], final_txn: ObservedTransaction) -> Iterable[Anomaly]:\n \"\"\"\n classify a cycle, turning it into a list of anomalies\n\n return the list of anomalies from the cycle\n note that since to transactions can be connected by more than one\n edge (of different types), it needs to be possible to return more\n than one anomaly from that cycle\n \"\"\"\n\n edge_cycles: List[List[DSG.Edge]] = [[]]\n for u, v in zip(node_cycle, node_cycle[1:] + node_cycle[0:]):\n edges: List[DSG.Edge] = list(filter(lambda e: e.target == v, u.edges))\n for edge_cycle in edge_cycles:\n # necessary because we add to edge_cycles in this loop\n #\n if len(edge_cycle) > 0 and edge_cycle[-1].target == v:\n continue\n\n edge_cycle.append(edges[0])\n for e in edges[1:]:\n edge_cycles.append(edge_cycle[:-1] + [e])\n\n for edge_cycle in edge_cycles:\n yield DSG.CyclicalAnomaly(self, node_cycle, edge_cycle, final_txn)\n\n for node_cycle in self.find_cycles(anomalies):\n for a in classify_cycle(node_cycle, self._hist.get_observed_txn(self._hist.txn_range()[1])):\n if any(anom in anomalies for anom in DSG.CyclicalAnomaly.cyclical_closure(a.type())):\n yield a\n\n @staticmethod\n def list_to_dot(stmts: List[Tuple[Node, Edge]]) -> str:\n \"\"\"\n Convert a list of (node, edge) pairs into a DOT representation\n WW and WR conflicts have solid arrows\n RW and PRW have dashed arrows (similar to how Adya represents them)\n \"\"\"\n\n return \"\"\"\ndigraph DSG {{\n{}\nedge [style=dashed]\n{}\n}}\n\"\"\".format(\n \"\\t\"\n + \"\\n\\t\".join(\n \"{} -> {} [label={}];\".format(n, edge.target, repr(edge.type))\n for n, edge in filter(\n lambda x: x[1].type not in [DSG.Edge.Type.RW, DSG.Edge.Type.PRW],\n stmts,\n )\n ),\n \"\\t\"\n + \"\\n\\t\".join(\n \"{} -> {} [label={}];\".format(n, edge.target, repr(edge.type))\n for n, edge in filter(lambda x: x[1].type in [DSG.Edge.Type.RW, DSG.Edge.Type.PRW], stmts)\n ),\n )\n\n def dump_dot(self, anomalies: List[Any], full: bool = False) -> str:\n \"\"\"\n Dump a DOT file with the DSG\n If include all *committed* transactions. Otherwise, only the cycles.\n \"\"\"\n\n stmts: List[Tuple[DSG.Node, DSG.Edge]] = list()\n if full:\n for node in self._nodes:\n for edge in node.edges:\n stmts.append((node, edge))\n else:\n cycle_nodes: Set[DSG.Node] = set(sum((c for c in self.find_cycles(anomalies)), []))\n for node in cycle_nodes:\n for edge in filter(lambda e: e.target in cycle_nodes, node.edges):\n stmts.append((node, edge))\n\n return DSG.list_to_dot(stmts)\n\n def dump_dots(self, anomalies: List[Any]) -> List[str]:\n \"\"\"\n Dump a DOT file for each cycle\n \"\"\"\n dot_list: List[str] = list()\n for cycle in self.find_cycles(anomalies):\n stmts: List[Tuple[DSG.Node, DSG.Edge]] = list()\n for node in cycle:\n for edge in filter(lambda e: e.target in cycle, node.edges):\n stmts.append((node, edge))\n\n dot_list.append(DSG.list_to_dot(stmts))\n\n return dot_list\n", "meta": {"hexsha": "0b318afd4206edf52c7396e4a03b531e835af5f0", "size": 36479, "ext": "py", "lang": "Python", "max_stars_repo_path": "frodo/cycle.py", "max_stars_repo_name": "memsql/frodo", "max_stars_repo_head_hexsha": "d7fb7f055399eb5873ea4a5a7b6780608faf2402", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2020-09-11T20:04:41.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-27T23:59:20.000Z", "max_issues_repo_path": "frodo/cycle.py", "max_issues_repo_name": "memsql/frodo", "max_issues_repo_head_hexsha": "d7fb7f055399eb5873ea4a5a7b6780608faf2402", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "frodo/cycle.py", "max_forks_repo_name": "memsql/frodo", "max_forks_repo_head_hexsha": "d7fb7f055399eb5873ea4a5a7b6780608faf2402", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.8677595628, "max_line_length": 202, "alphanum_fraction": 0.5238356315, "include": true, "reason": "import networkx", "num_tokens": 8016, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5312093733737563, "lm_q2_score": 0.36296920551961676, "lm_q1q2_score": 0.19281264421804578}} {"text": "from __future__ import annotations\n\nfrom typing import TYPE_CHECKING, Union\nfrom warnings import filterwarnings\n\nimport pyopencl as cl\nimport pyopencl.array as cla\n\nimport numpy as np\nfrom gpyfft.fft import FFT\n\nfrom ._util import get_context\n\nfilterwarnings(\"ignore\", module=\"pyopencl\")\n\n\nif TYPE_CHECKING:\n from reikna.cluda.cuda import Array as cudaArray\n from reikna.cluda.ocl import Array as oclArray\n\n Array = Union[cudaArray, oclArray]\n\ncontext = get_context()\nqueue = cl.CommandQueue(context)\n\n# plan cache\n_PLAN_CACHE = {}\n\n\ndef _normalize_axes(dshape, axes):\n \"\"\"Convert possibly negative axes to positive axes.\"\"\"\n if axes is None:\n return None\n _axes = [axes] if np.isscalar(axes) else list(axes)\n try:\n return tuple(np.arange(len(dshape))[_axes])\n except Exception as e:\n raise TypeError(f\"Cannot normalize axes {axes}: {e}\")\n\n\ndef _get_fft_plan(arr, axes=None, fast_math=False):\n \"\"\"Cache and return a reikna FFT plan suitable for `arr` type and shape.\"\"\"\n axes = _normalize_axes(arr.shape, axes)\n plan_key = (arr.shape, arr.dtype, axes, fast_math)\n\n if plan_key not in _PLAN_CACHE:\n _PLAN_CACHE[plan_key] = FFT(context, queue, arr, axes=axes, fast_math=fast_math)\n\n return _PLAN_CACHE[plan_key]\n\n\ndef _fftn(\n input_arr: np.ndarray | Array,\n output_arr: np.ndarray | Array = None,\n axes: tuple[int, ...] | None = None,\n inplace: bool = False,\n fast_math: bool = True,\n *,\n _inverse: bool = False,\n) -> Array:\n \"\"\"Perform fast Fourier transformation on `input_array`.\n\n Parameters\n ----------\n input_arr : numpy or OCL array\n A numpy or OCL array to transform. If an OCL array is provided, it must already\n be of type `complex64`. If a numpy array is provided, it will be converted\n to `float32` before the transformation is performed.\n output_arr : numpy or OCL array, optional\n An optional array/buffer to use for output, by default None\n axes : tuple of int, optional\n T tuple with axes over which to perform the transform.\n If not given, the transform is performed over all the axes., by default None\n inplace : bool, optional\n Whether to place output data in the `input_arr` buffer, by default False\n fast_math : bool, optional\n Whether to enable fast (less precise) mathematical operations during\n compilation, by default True\n _inverse : bool, optional\n Perform inverse FFT, by default False. (prefer using `ifftn`)\n\n Returns\n -------\n OCLArray\n result of transformation (still on GPU). Use `.get()` or `cle.pull`\n to retrieve from GPU.\n If `inplace` or `output_arr` where used, data will also be placed in\n the corresponding buffer as a side effect.\n\n Raises\n ------\n TypeError\n If OCL array is provided that is not of type complex64. Or if an unrecognized\n array is provided.\n ValueError\n If inplace is used for numpy array, or both `output_arr` and `inplace` are used.\n \"\"\"\n if output_arr is not None and inplace:\n raise ValueError(\"`output_arr` cannot be provided if `inplace` is True\")\n assert input_arr.dtype in (np.float32, np.float64, np.complex64, np.complex128)\n\n if not np.iscomplexobj(input_arr):\n input_arr = input_arr.astype(np.complex64) # TODO\n\n _input_array = (\n cla.to_device(queue, input_arr)\n if isinstance(input_arr, np.ndarray)\n else input_arr\n )\n transform = _get_fft_plan(_input_array, axes=axes, fast_math=fast_math)\n\n if not inplace:\n if output_arr is None:\n output_arr = cla.empty_like(_input_array)\n transform.result = output_arr\n\n (event,) = transform.enqueue(forward=not _inverse)\n event.wait()\n\n if not inplace:\n return output_arr\n return _input_array\n\n\ndef fft(\n input_arr: np.ndarray | Array,\n output_arr: np.ndarray | Array = None,\n axes: int = -1,\n inplace: bool = False,\n fast_math: bool = True,\n) -> Array:\n return fftn(input_arr, output_arr, (axes,), inplace, fast_math)\n\n\ndef ifft(\n input_arr: np.ndarray | Array,\n output_arr: np.ndarray | Array = None,\n axes: int = -1,\n inplace: bool = False,\n fast_math: bool = True,\n) -> Array:\n return ifftn(input_arr, output_arr, (axes,), inplace, fast_math)\n\n\ndef fft2(\n input_arr: np.ndarray | Array,\n output_arr: np.ndarray | Array = None,\n axes: tuple[int, int] = (-2, -1),\n inplace: bool = False,\n fast_math: bool = True,\n) -> Array:\n return fftn(input_arr, output_arr, axes, inplace, fast_math)\n\n\ndef ifft2(\n input_arr: np.ndarray | Array,\n output_arr: np.ndarray | Array = None,\n axes: tuple[int, int] = (-2, -1),\n inplace: bool = False,\n fast_math: bool = True,\n) -> Array:\n return ifftn(input_arr, output_arr, axes, inplace, fast_math)\n\n\ndef fftn(\n input_arr: np.ndarray | Array,\n output_arr: np.ndarray | Array = None,\n axes: tuple[int, ...] | None = None,\n inplace: bool = False,\n fast_math: bool = True,\n) -> Array:\n return _fftn(input_arr, output_arr, axes, inplace, fast_math)\n\n\ndef ifftn(\n input_arr,\n output_arr=None,\n axes=None,\n inplace=False,\n fast_math=True,\n):\n return _fftn(input_arr, output_arr, axes, inplace, fast_math, _inverse=True)\n\n\ndef rfft(\n input_arr: np.ndarray | Array,\n output_arr: np.ndarray | Array = None,\n axes: int = -1,\n inplace: bool = False,\n fast_math: bool = True,\n) -> Array:\n x = _fftn(input_arr, output_arr, (axes,), inplace, fast_math)\n return x[:, : input_arr.shape[-1] // 2 + 1]\n\n\n# FIXME\n# def irfft(\n# input_arr: np.ndarray | Array,\n# output_arr: np.ndarray | Array = None,\n# axes: int = -1,\n# inplace: bool = False,\n# fast_math: bool = True,\n# ) -> Array:\n# x = _fftn(input_arr, output_arr, axes, inplace, fast_math, _inverse=True)\n# shp = list(input_arr.shape)\n# n = shp[axes]\n# shp[axes] = 2 * n - 2\n# result = empty(shp, np.float32)\n# result[..., :n] = x.real\n# result[..., n - 1 :] = x.real[..., 1:][::-1]\n# return result.astype(np.float64)\n\n\ndef rfft2(\n input_arr: np.ndarray | Array,\n output_arr: np.ndarray | Array = None,\n axes: tuple[int, int] = (-2, -1),\n inplace: bool = False,\n fast_math: bool = True,\n) -> Array:\n x = _fftn(input_arr, output_arr, axes, inplace, fast_math)\n return x[:, : input_arr.shape[1] // 2 + 1]\n\n\n# FIXME\n# def irfft2(\n# input_arr: np.ndarray | Array,\n# output_arr: np.ndarray | Array = None,\n# axes: Tuple[int, int] = (-2, -1),\n# inplace: bool = False,\n# fast_math: bool = True,\n# ) -> Array:\n# x = _fftn(input_arr, output_arr, axes, inplace, fast_math)\n# return x[:, : input_arr.shape[1] // 2 + 1]\n\n\ndef rfftn(\n input_arr: np.ndarray | Array,\n output_arr: np.ndarray | Array = None,\n axes: tuple[int, ...] | None = None,\n inplace: bool = False,\n fast_math: bool = True,\n) -> Array:\n x = _fftn(input_arr, output_arr, axes, inplace, fast_math)\n return x[:, : input_arr.shape[1] // 2 + 1]\n\n\n# FIXME\n# def irfftn(\n# input_arr: np.ndarray | Array,\n# output_arr: np.ndarray | Array = None,\n# axes: tuple[int, ...] | None = None,\n# inplace: bool = False,\n# fast_math: bool = True,\n# ) -> Array:\n# x = _fftn(input_arr, output_arr, axes, inplace, fast_math)\n# return x[..., : input_arr.shape[1] // 2 + 1]\n", "meta": {"hexsha": "81071cd36ae3927f25941d70868ac2b0c4d17661", "size": 7429, "ext": "py", "lang": "Python", "max_stars_repo_path": "anyfft/gpyfft/_fft.py", "max_stars_repo_name": "tlambert03/anyfft", "max_stars_repo_head_hexsha": "2b5fb526fa96d7ed607765383adb8c198f505232", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "anyfft/gpyfft/_fft.py", "max_issues_repo_name": "tlambert03/anyfft", "max_issues_repo_head_hexsha": "2b5fb526fa96d7ed607765383adb8c198f505232", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "anyfft/gpyfft/_fft.py", "max_forks_repo_name": "tlambert03/anyfft", "max_forks_repo_head_hexsha": "2b5fb526fa96d7ed607765383adb8c198f505232", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.7945736434, "max_line_length": 88, "alphanum_fraction": 0.6393861893, "include": true, "reason": "import numpy", "num_tokens": 2024, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5312093585306514, "lm_q2_score": 0.36296920551961676, "lm_q1q2_score": 0.1928126388304558}} {"text": "#!/usr/bin/python\n# -*- coding: utf-8 -*-\n'''\n * Copyright (c) 2017, Matthias Julius Kannwischer\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * 1. Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n *\n * 2. Redistributions in binary form must reproduce the above copyright notice,\n * this list of conditions and the following disclaimer in the documentation\n * and/or other materials provided with the distribution.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n'''\n\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n\n#./simulation/simulate 500 HW_BYTE 33c0364151e93bbda2896900f18c987737593ff2abc2f8a2220f54c58aa71968\n##### SIMULATING POWER TRACE #####\n#seed=0x33c0364151e93bbda2896900f18c987737593ff2abc2f8a2220f54c58aa71968\n#leakage_type=3\n#Creating 500 traces\n#iv[0]=0x6a09e667bb67ae853c6ef372a54ff53a510e527f9b05688c1f83d9ab5be0cd19\n#iv[1]=0x13e087020936aab9a2ecc5396601faf1a919aa0e8f4074c1e21173981cce9431\n#a_0=0x13e08702\n#b_0=0x0936aab9\n#c_0=0xa2ecc539\n#d_0=0x6601faf1\n#e_0=0xa919aa0e\n#f_0=0x8f4074c1\n#g_0=0xe2117398\n#h_0=0x1cce9431\n#delta=0x21fd7822\n#T2=0x42d93dc4\n#leakage_500.bin\n\n#./analysis/analyze_8bit.py leakage_500.bin secret_data.txt\n\nR = np.load(\"../data/correlation_values.npy\")\nR[np.isnan(R)] = 0\nR = np.absolute(R)\nprint R.shape\n\ncorrect_hyp = R[:, 0x22]\nwrong_hyp = R[:, 0x42]\nprint correct_hyp[0:10];\n\n\ndef plot_overtime(d, fname):\n\n plt.plot(d)\n\n\n# correlation over time\nf, axarr = plt.subplots(2, sharex=True, figsize=(11,5))\naxarr[0].plot(correct_hyp)\naxarr[0].set_title(\"correct hypothesis (34)\")\naxarr[1].plot(wrong_hyp)\naxarr[1].set_title(\"wrong hypothesis (66)\")\nplt.xlim(xmin=17000)\nplt.xlim(xmax=32000)\nplt.ylim(ymax=1.0)\n# dummy subplot for the axis\nax = f.add_subplot(111, frameon=False)\nax.set_yticklabels([])\nax.set_xticklabels([])\nax.set_ylabel(\"Pearson correlation coefficient\",labelpad=25)\nplt.xlabel(\"index of sample\",labelpad=20)\nplt.tight_layout()\nf.savefig(\"correlation_over_time.pdf\")\n\n\n# correlation of different hyptohesis\nf = plt.figure(figsize=(11,3.5))\nprint np.where(R == 1.0)\nd = R[20980, :]\nplt.bar(range(0,256), d, edgecolor=\"none\")\nplt.xlabel(\"key hypothesis\")\nplt.ylabel(\"Pearon correlation coefficient\")\nplt.xlim(xmax=255)\nplt.tight_layout()\n\nf.savefig(\"max_correlation.pdf\");\n", "meta": {"hexsha": "bab831e6059de091f64aa0e4f4ac07e818c39574", "size": 3206, "ext": "py", "lang": "Python", "max_stars_repo_path": "plots/corr_over_time.py", "max_stars_repo_name": "mkannwischer/xmss-prng-dpa", "max_stars_repo_head_hexsha": "440ce76cda6f084e2e74c61e6fad10193bc7943f", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2017-08-23T14:45:22.000Z", "max_stars_repo_stars_event_max_datetime": "2018-02-01T23:57:27.000Z", "max_issues_repo_path": "plots/corr_over_time.py", "max_issues_repo_name": "mkannwischer/xmss-prng-dpa", "max_issues_repo_head_hexsha": "440ce76cda6f084e2e74c61e6fad10193bc7943f", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "plots/corr_over_time.py", "max_forks_repo_name": "mkannwischer/xmss-prng-dpa", "max_forks_repo_head_hexsha": "440ce76cda6f084e2e74c61e6fad10193bc7943f", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.06, "max_line_length": 99, "alphanum_fraction": 0.7679351216, "include": true, "reason": "import numpy", "num_tokens": 969, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230157, "lm_q2_score": 0.3738758367247085, "lm_q1q2_score": 0.19277782742286617}} {"text": "__VERSION__=\"ete2-2.2rev1056\" \n# -*- coding: utf-8 -*-\n# #START_LICENSE###########################################################\n#\n#\n# This file is part of the Environment for Tree Exploration program\n# (ETE). http://ete.cgenomics.org\n# \n# ETE is free software: you can redistribute it and/or modify it\n# under the terms of the GNU General Public License as published by\n# the Free Software Foundation, either version 3 of the License, or\n# (at your option) any later version.\n# \n# ETE is distributed in the hope that it will be useful, but WITHOUT\n# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\n# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public\n# License for more details.\n# \n# You should have received a copy of the GNU General Public License\n# along with ETE. If not, see .\n#\n# \n# ABOUT THE ETE PACKAGE\n# =====================\n# \n# ETE is distributed under the GPL copyleft license (2008-2011). \n#\n# If you make use of ETE in published work, please cite:\n#\n# Jaime Huerta-Cepas, Joaquin Dopazo and Toni Gabaldon.\n# ETE: a python Environment for Tree Exploration. Jaime BMC\n# Bioinformatics 2010,:24doi:10.1186/1471-2105-11-24\n#\n# Note that extra references to the specific methods implemented in \n# the toolkit are available in the documentation. \n# \n# More info at http://ete.cgenomics.org\n#\n# \n# #END_LICENSE#############################################################\n\nimport numpy\nfrom math import sqrt \n\ndef safe_mean(values):\n \"\"\" Returns mean value discarding non finite values \"\"\"\n valid_values = []\n for v in values:\n if numpy.isfinite(v):\n valid_values.append(v)\n return numpy.mean(valid_values), numpy.std(valid_values)\n\ndef safe_mean_vector(vectors):\n \"\"\" Returns mean profile discarding non finite values.\n \"\"\"\n # if only one vector, avg = itself\n if len(vectors)==1:\n return vectors[0], numpy.zeros(len(vectors[0]))\n # Takes the vector length form the first item\n length = len(vectors[0])\n\n safe_mean = []\n safe_std = []\n\n for pos in xrange(length):\n pos_mean = []\n for v in vectors:\n if numpy.isfinite(v[pos]):\n pos_mean.append(v[pos])\n safe_mean.append(numpy.mean(pos_mean))\n safe_std.append(numpy.std(pos_mean))\n return numpy.array(safe_mean), numpy.array(safe_std)\n\ndef get_silhouette_width(fdist, cluster):\n sisters = cluster.get_sisters()\n\n # Calculates silhouette\n silhouette = []\n intra_dist = []\n inter_dist = []\n for st in sisters:\n if st.profile is None:\n continue\n for i in cluster.iter_leaves():\n # Skip nodes without profile\n if i._profile is not None:\n # item intraclsuterdist -> Centroid Diameter\n a = fdist(i.profile, cluster.profile)*2\n # intracluster dist -> Centroid Linkage\n b = fdist(i.profile, st.profile)\n\n if (b-a) == 0.0:\n s = 0.0\n else:\n s = (b-a) / max(a,b)\n\n intra_dist.append(a)\n inter_dist.append(b)\n silhouette.append(s)\n\n silhouette, std = safe_mean(silhouette)\n intracluster_dist, std = safe_mean(intra_dist)\n intercluster_dist, std = safe_mean(inter_dist)\n return silhouette, intracluster_dist, intercluster_dist\n\ndef get_avg_profile(node):\n \"\"\" This internal function updates the mean profile\n associated to an internal node. \"\"\"\n\n if not node.is_leaf():\n leaf_vectors = [n._profile for n in node.get_leaves() \\\n if n._profile is not None]\n if len(leaf_vectors)>0:\n node._profile, node._std_profile = safe_mean_vector(leaf_vectors)\n else:\n node._profile, node._std_profile = None, None\n return node._profile, node._std_profile\n else:\n node._std_profile = [0.0]*len(node._profile)\n return node._profile, [0.0]*len(node._profile)\n\n\ndef get_dunn_index(fdist, *clusters):\n \"\"\"\n Returns the Dunn index for the given selection of nodes.\n\n J.C. Dunn. Well separated clusters and optimal fuzzy\n partitions. 1974. J.Cybern. 4. 95-104.\n\n \"\"\"\n\n if len(clusters)<2:\n raise ValueError, \"At least 2 clusters are required\"\n\n intra_dist = []\n for c in clusters:\n for i in c.get_leaves():\n if i is not None:\n # item intraclsuterdist -> Centroid Diameter\n a = fdist(i.profile, c.profile)*2\n intra_dist.append(a)\n max_a = numpy.max(intra_dist)\n inter_dist = []\n for i, ci in enumerate(clusters):\n for cj in clusters[i+1:]:\n # intracluster dist -> Centroid Linkage\n b = fdist(ci.profile, cj.profile)\n inter_dist.append(b)\n min_b = numpy.min(inter_dist)\n\n if max_a == 0.0:\n D = 0.0\n else:\n D = min_b / max_a\n return D\n\n\n\n# ####################\n# distance functions\n# ####################\n\ndef pearson_dist(v1, v2):\n if (v1 == v2).all():\n return 0.0\n else:\n return 1.0 - stats.pearsonr(list(v1),list(v2))[0]\n \ndef spearman_dist(v1, v2):\n if (v1 == v2).all():\n return 0.0\n else:\n return 1.0 - stats.spearmanr(list(v1),list(v2))[0]\n\ndef euclidean_dist(v1,v2):\n if (v1 == v2).all():\n return 0.0\n else:\n return sqrt( square_euclidean_dist(v1,v2) )\n\ndef square_euclidean_dist(v1,v2):\n if (v1 == v2).all():\n return 0.0\n valids = 0\n distance= 0.0\n for i in xrange(len(v1)):\n if numpy.isfinite(v1[i]) and numpy.isfinite(v2[i]):\n valids += 1\n d = v1[i]-v2[i]\n distance += d*d\n if valids==0:\n raise ValueError, \"Cannot calculate values\"\n return distance/valids\n\ntry: \n from scipy import stats\nexcept ImportError: \n try:\n import stats\n default_dist = spearman_dist\n except ImportError:\n default_dist = euclidean_dist\nelse:\n default_dist = spearman_dist\n", "meta": {"hexsha": "3afacdfa2c982a44715bd2e1b0b48fa73f8a3027", "size": 6103, "ext": "py", "lang": "Python", "max_stars_repo_path": "ete2/clustering/clustvalidation.py", "max_stars_repo_name": "csc8630Spring2014/Clusterizer", "max_stars_repo_head_hexsha": "f64b0cabfbf4fa117b73a2af9355f67cc9207fe5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2017-05-10T02:51:51.000Z", "max_stars_repo_stars_event_max_datetime": "2017-05-10T02:51:51.000Z", "max_issues_repo_path": "ete2/clustering/clustvalidation.py", "max_issues_repo_name": "csc8630Spring2014/Clusterizer", "max_issues_repo_head_hexsha": "f64b0cabfbf4fa117b73a2af9355f67cc9207fe5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ete2/clustering/clustvalidation.py", "max_forks_repo_name": "csc8630Spring2014/Clusterizer", "max_forks_repo_head_hexsha": "f64b0cabfbf4fa117b73a2af9355f67cc9207fe5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.7707317073, "max_line_length": 77, "alphanum_fraction": 0.5962641324, "include": true, "reason": "import numpy,from scipy", "num_tokens": 1519, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230157, "lm_q2_score": 0.3738758227716966, "lm_q1q2_score": 0.19277782022841536}} {"text": "\"\"\"Atmospheric soundings.\n\n--- NOTATION ---\n\nThe following letters will be used throughout this module.\n\nT = number of lead times\nn = number of storm objects\np = number of pressure levels, not including surface\nP = number of pressure levels, including surface\nF = number of sounding fields\n\nN = number of soundings = T*n\n\"\"\"\n\nimport os.path\nimport numpy\nimport pandas\nimport netCDF4\nfrom scipy.interpolate import interp1d as scipy_interp1d\nfrom gewittergefahr.gg_io import grib_io\nfrom gewittergefahr.gg_io import netcdf_io\nfrom gewittergefahr.gg_utils import geodetic_utils\nfrom gewittergefahr.gg_utils import nwp_model_utils\nfrom gewittergefahr.gg_utils import storm_tracking_utils as tracking_utils\nfrom gewittergefahr.gg_utils import interp\nfrom gewittergefahr.gg_utils import moisture_conversions\nfrom gewittergefahr.gg_utils import temperature_conversions\nfrom gewittergefahr.gg_utils import time_conversion\nfrom gewittergefahr.gg_utils import file_system_utils\nfrom gewittergefahr.gg_utils import error_checking\n\nSEPARATOR_STRING = '\\n\\n' + '*' * 50 + '\\n\\n'\nTIME_FORMAT_IN_FILE_NAMES = '%Y-%m-%d-%H%M%S'\n\nMB_TO_PASCALS = 100\nPASCALS_TO_MB = 0.01\nPERCENT_TO_UNITLESS = 0.01\n\nPRESSURE_LEVEL_KEY = 'pressure_level_mb'\nLEAD_TIME_KEY = 'lead_time_seconds'\nLAG_TIME_KEY = 'lag_time_for_convective_contamination_sec'\nINITIAL_TIME_COLUMN = 'init_time_unix_sec'\nFORECAST_TIME_COLUMN = 'forecast_time_unix_sec'\n\nFULL_IDS_KEY = 'full_storm_id_strings'\nINITIAL_TIMES_KEY = 'init_times_unix_sec'\nLEAD_TIMES_KEY = 'lead_times_seconds'\nSTORM_ELEVATIONS_KEY = 'storm_elevations_m_asl'\nSOUNDING_MATRIX_KEY = 'sounding_matrix'\nSURFACE_PRESSURES_KEY = 'surface_pressures_mb'\nPRESSURE_LEVELS_WITH_SFC_KEY = 'pressure_levels_with_surface_mb'\nHEIGHT_LEVELS_KEY = 'height_levels_m_agl'\nFIELD_NAMES_KEY = 'field_names'\n\nGEOPOTENTIAL_HEIGHT_NAME = nwp_model_utils.HEIGHT_COLUMN_FOR_SOUNDINGS\nRELATIVE_HUMIDITY_NAME = 'relative_humidity_unitless'\nTEMPERATURE_NAME = nwp_model_utils.TEMPERATURE_COLUMN_FOR_SOUNDINGS\nU_WIND_NAME = nwp_model_utils.U_WIND_COLUMN_FOR_SOUNDINGS\nV_WIND_NAME = nwp_model_utils.V_WIND_COLUMN_FOR_SOUNDINGS\nSPECIFIC_HUMIDITY_NAME = nwp_model_utils.SPFH_COLUMN_FOR_SOUNDINGS\nVIRTUAL_POTENTIAL_TEMPERATURE_NAME = 'virtual_potential_temperature_kelvins'\nPRESSURE_NAME = 'pressure_pascals'\n\nVALID_FIELD_NAMES = [\n GEOPOTENTIAL_HEIGHT_NAME, RELATIVE_HUMIDITY_NAME, TEMPERATURE_NAME,\n U_WIND_NAME, V_WIND_NAME, SPECIFIC_HUMIDITY_NAME,\n VIRTUAL_POTENTIAL_TEMPERATURE_NAME, PRESSURE_NAME\n]\n\nFIELD_NAME_TO_VERBOSE_DICT = {\n GEOPOTENTIAL_HEIGHT_NAME: 'Geopotential height (m)',\n RELATIVE_HUMIDITY_NAME: 'Relative humidity',\n TEMPERATURE_NAME: 'Temperature (K)',\n U_WIND_NAME: r'$u$-wind (m s$^{-1}$)',\n V_WIND_NAME: r'$v$-wind (m s$^{-1}$)',\n SPECIFIC_HUMIDITY_NAME: r'Specific humidity (kg kg$^{-1}$)',\n VIRTUAL_POTENTIAL_TEMPERATURE_NAME: 'Virtual potential temperature (K)',\n PRESSURE_NAME: 'Pressure (Pa)'\n}\n\nFIELD_NAME_TO_VERBOSE_UNITLESS_DICT = {\n GEOPOTENTIAL_HEIGHT_NAME: 'Geopotential height',\n RELATIVE_HUMIDITY_NAME: 'Relative humidity',\n TEMPERATURE_NAME: 'Temperature',\n U_WIND_NAME: r'$u$-wind',\n V_WIND_NAME: r'$v$-wind',\n SPECIFIC_HUMIDITY_NAME: 'Specific humidity',\n VIRTUAL_POTENTIAL_TEMPERATURE_NAME: 'Virtual potential temperature',\n PRESSURE_NAME: 'Pressure'\n}\n\nSTORM_OBJECT_DIMENSION_KEY = 'storm_object'\nFIELD_DIMENSION_KEY = 'field'\nHEIGHT_DIMENSION_KEY = 'height_level'\nSTORM_ID_CHAR_DIMENSION_KEY = 'storm_id_character'\nFIELD_NAME_CHAR_DIMENSION_KEY = 'field_name_character'\n\n# Field names for MetPy.\nPRESSURE_COLUMN_METPY = 'pressures_mb'\nTEMPERATURE_COLUMN_METPY = 'temperatures_deg_c'\nDEWPOINT_COLUMN_METPY = 'dewpoints_deg_c'\nU_WIND_COLUMN_METPY = 'u_winds_kt'\nV_WIND_COLUMN_METPY = 'v_winds_kt'\n\nDEFAULT_LEAD_TIMES_SEC = numpy.array([0], dtype=int)\nDEFAULT_LAG_TIME_FOR_CONVECTIVE_CONTAMINATION_SEC = 1800\nDEFAULT_HEIGHT_LEVELS_M_AGL = numpy.linspace(0, 12000, num=49, dtype=int)\n\n\ndef _get_nwp_fields_for_sounding(\n model_name, return_table, include_surface=False,\n minimum_pressure_mb=0.):\n \"\"\"Returns list of NWP fields needed to create sounding.\n\n :param model_name: Model name (must be accepted by\n `nwp_model_utils.check_model_name`).\n :param return_table: Boolean flag. See below for how this affects output.\n :param include_surface: Boolean flag. If True, this method will return the\n \"surface\" (2-metre or 10-metre) level for each field.\n :param minimum_pressure_mb: Leave this alone.\n\n :return: sounding_field_names: [None if return_table = True]\n length-F list with names of sounding fields (GewitterGefahr format).\n :return: sounding_field_names_grib1: [None if return_table = True]\n length-F list with names of sounding fields (grib1 format).\n :return: sounding_field_name_table: [None if return_table = False]\n pandas DataFrame with the following columns. Each row is one pressure\n level. Only one of \"relative_humidity_percent\" and \"specific_humidity\"\n (depending on the NWP model) will be present.\n sounding_field_name_table.geopotential_height_metres: Name of geopotential-\n height field.\n sounding_field_name_table.temperature_kelvins: Name of temperature field.\n sounding_field_name_table.relative_humidity_percent: Name of humidity field.\n sounding_field_name_table.specific_humidity: Name of humidity field.\n sounding_field_name_table.u_wind_m_s01: Name of u-wind field.\n sounding_field_name_table.v_wind_m_s01: Name of v-wind field.\n sounding_field_name_table.pressure_level_mb: Pressure level (millibars).\n The surface is denoted by NaN.\n \"\"\"\n\n nwp_model_utils.check_model_name(model_name)\n error_checking.assert_is_boolean(return_table)\n error_checking.assert_is_geq(minimum_pressure_mb, 0.)\n error_checking.assert_is_boolean(include_surface)\n\n pressure_levels_no_surface_mb = nwp_model_utils.get_pressure_levels(\n model_name=model_name, grid_name=nwp_model_utils.NAME_OF_130GRID\n ).astype(float)\n\n pressure_levels_no_surface_mb = pressure_levels_no_surface_mb[\n pressure_levels_no_surface_mb >= minimum_pressure_mb\n ]\n\n if include_surface:\n pressure_levels_with_surface_mb = numpy.concatenate((\n pressure_levels_no_surface_mb, numpy.array([numpy.nan])\n ))\n else:\n pressure_levels_with_surface_mb = pressure_levels_no_surface_mb + 0.\n\n num_pressure_levels_no_surface = len(pressure_levels_no_surface_mb)\n num_pressure_levels_with_surface = len(pressure_levels_with_surface_mb)\n\n field_names, field_names_grib1 = (\n nwp_model_utils.get_columns_in_sounding_table(model_name)\n )\n\n num_fields = len(field_names)\n sounding_field_name_table = None\n sounding_field_names = []\n sounding_field_names_grib1 = []\n\n if return_table:\n sounding_field_name_dict = {\n PRESSURE_LEVEL_KEY: pressure_levels_with_surface_mb\n }\n\n list_of_empty_strings = [''] * num_pressure_levels_with_surface\n for j in range(num_fields):\n sounding_field_name_dict.update({\n field_names[j]: list_of_empty_strings\n })\n\n sounding_field_name_table = pandas.DataFrame.from_dict(\n sounding_field_name_dict)\n\n for j in range(num_fields):\n for k in range(num_pressure_levels_no_surface):\n this_field_name = '{0:s}_{1:d}mb'.format(\n field_names[j],\n int(numpy.round(pressure_levels_no_surface_mb[k]))\n )\n\n if return_table:\n sounding_field_name_table[field_names[j]].values[k] = (\n this_field_name\n )\n else:\n this_field_name_grib1 = '{0:s}:{1:d} mb'.format(\n field_names_grib1[j],\n int(numpy.round(pressure_levels_no_surface_mb[k]))\n )\n\n sounding_field_names.append(this_field_name)\n sounding_field_names_grib1.append(this_field_name_grib1)\n\n if not include_surface:\n continue\n\n if field_names[j] == GEOPOTENTIAL_HEIGHT_NAME:\n this_field_name, this_field_name_grib1 = (\n nwp_model_utils.get_lowest_height_name(model_name)\n )\n\n if field_names[j] == TEMPERATURE_NAME:\n this_field_name, this_field_name_grib1 = (\n nwp_model_utils.get_lowest_temperature_name(model_name)\n )\n\n if field_names[j] in [nwp_model_utils.RH_COLUMN_FOR_SOUNDINGS,\n SPECIFIC_HUMIDITY_NAME]:\n this_field_name, this_field_name_grib1 = (\n nwp_model_utils.get_lowest_humidity_name(model_name)\n )\n\n if field_names[j] == U_WIND_NAME:\n this_field_name, this_field_name_grib1 = (\n nwp_model_utils.get_lowest_u_wind_name(model_name)\n )\n\n if field_names[j] == V_WIND_NAME:\n this_field_name, this_field_name_grib1 = (\n nwp_model_utils.get_lowest_v_wind_name(model_name)\n )\n\n if return_table:\n sounding_field_name_table[field_names[j]].values[\n num_pressure_levels_with_surface - 1\n ] = this_field_name\n else:\n sounding_field_names.append(this_field_name)\n sounding_field_names_grib1.append(this_field_name_grib1)\n\n if return_table or not include_surface:\n return (sounding_field_names, sounding_field_names_grib1,\n sounding_field_name_table)\n\n this_field_name, this_field_name_grib1 = (\n nwp_model_utils.get_lowest_pressure_name(model_name)\n )\n\n sounding_field_names.append(this_field_name)\n sounding_field_names_grib1.append(this_field_name_grib1)\n\n return (sounding_field_names, sounding_field_names_grib1,\n sounding_field_name_table)\n\n\ndef _create_target_points_for_interp(storm_object_table, lead_times_seconds):\n \"\"\"Creates target points for interpolation.\n\n Each target point consists of (latitude, longitude, time).\n\n :param storm_object_table: pandas DataFrame with columns documented in\n `storm_tracking_io.write_file`.\n :param lead_times_seconds: 1-D numpy array of lead times (non-negative\n integers). For each lead time t, each storm object will be extrapolated\n t seconds into the future, along its estimated motion vector.\n :return: target_point_table: pandas DataFrame with the following columns.\n target_point_table.full_id_string: Full storm ID.\n target_point_table.init_time_unix_sec: Initial time (storm time). Valid\n time = initial time + lead time.\n target_point_table.centroid_lat_deg: Latitude (deg N) of extrapolated storm\n object's centroid.\n target_point_table.centroid_lng_deg: Longitude (deg E) of extrapolated storm\n object's centroid.\n target_point_table.valid_time_unix_sec: Time of extrapolated storm object.\n target_point_table.lead_time_seconds: Lead time used for extrapolation.\n target_point_table.east_velocity_m_s01: Eastward component (metres per\n second) of estimated storm-motion vector.\n target_point_table.north_velocity_m_s01: Northward component.\n \"\"\"\n\n if numpy.any(lead_times_seconds > 0):\n storm_speeds_m_s01, storm_bearings_deg = (\n geodetic_utils.xy_to_scalar_displacements_and_bearings(\n x_displacements_metres=\n storm_object_table[tracking_utils.EAST_VELOCITY_COLUMN].values,\n y_displacements_metres=\n storm_object_table[tracking_utils.NORTH_VELOCITY_COLUMN].values)\n )\n\n num_storm_objects = len(storm_object_table.index)\n num_lead_times = len(lead_times_seconds)\n list_of_target_point_tables = [None] * num_lead_times\n\n for i in range(num_lead_times):\n if lead_times_seconds[i] == 0:\n list_of_target_point_tables[i] = storm_object_table[[\n tracking_utils.FULL_ID_COLUMN, tracking_utils.VALID_TIME_COLUMN,\n tracking_utils.CENTROID_LATITUDE_COLUMN,\n tracking_utils.CENTROID_LONGITUDE_COLUMN,\n tracking_utils.EAST_VELOCITY_COLUMN,\n tracking_utils.NORTH_VELOCITY_COLUMN\n ]]\n\n argument_dict = {\n LEAD_TIME_KEY: numpy.full(num_storm_objects, 0, dtype=int),\n FORECAST_TIME_COLUMN: list_of_target_point_tables[i][\n tracking_utils.VALID_TIME_COLUMN].values\n }\n\n list_of_target_point_tables[i] = (\n list_of_target_point_tables[i].assign(**argument_dict)\n )\n\n if i == 0:\n continue\n\n list_of_target_point_tables[i] = (\n list_of_target_point_tables[i].align(\n list_of_target_point_tables[0], axis=1\n )[0]\n )\n\n continue\n\n these_extrap_latitudes_deg, these_extrap_longitudes_deg = (\n geodetic_utils.start_points_and_displacements_to_endpoints(\n start_latitudes_deg=storm_object_table[\n tracking_utils.CENTROID_LATITUDE_COLUMN].values,\n start_longitudes_deg=storm_object_table[\n tracking_utils.CENTROID_LONGITUDE_COLUMN].values,\n scalar_displacements_metres=\n storm_speeds_m_s01 * lead_times_seconds[i],\n geodetic_bearings_deg=storm_bearings_deg)\n )\n\n these_times_unix_sec = (\n storm_object_table[tracking_utils.VALID_TIME_COLUMN].values +\n lead_times_seconds[i]\n )\n\n this_dict = {\n tracking_utils.FULL_ID_COLUMN:\n storm_object_table[tracking_utils.FULL_ID_COLUMN].values,\n tracking_utils.VALID_TIME_COLUMN:\n storm_object_table[tracking_utils.VALID_TIME_COLUMN].values,\n tracking_utils.CENTROID_LATITUDE_COLUMN: these_extrap_latitudes_deg,\n tracking_utils.CENTROID_LONGITUDE_COLUMN:\n these_extrap_longitudes_deg,\n FORECAST_TIME_COLUMN: these_times_unix_sec,\n tracking_utils.EAST_VELOCITY_COLUMN:\n storm_object_table[tracking_utils.EAST_VELOCITY_COLUMN].values,\n tracking_utils.NORTH_VELOCITY_COLUMN:\n storm_object_table[tracking_utils.NORTH_VELOCITY_COLUMN].values,\n LEAD_TIME_KEY: numpy.full(\n num_storm_objects, lead_times_seconds[i], dtype=int)\n }\n\n list_of_target_point_tables[i] = pandas.DataFrame.from_dict(this_dict)\n if i == 0:\n continue\n\n list_of_target_point_tables[i] = list_of_target_point_tables[i].align(\n list_of_target_point_tables[0], axis=1\n )[0]\n\n target_point_table = pandas.concat(\n list_of_target_point_tables, axis=0, ignore_index=True)\n\n column_dict_old_to_new = {\n tracking_utils.VALID_TIME_COLUMN: INITIAL_TIME_COLUMN\n }\n\n return target_point_table.rename(\n columns=column_dict_old_to_new, inplace=False)\n\n\ndef _interp_soundings_from_nwp(\n target_point_table, top_grib_directory_name, include_surface,\n model_name, use_all_grids, grid_id, wgrib_exe_name, wgrib2_exe_name,\n raise_error_if_missing):\n \"\"\"Interpolates soundings from NWP model to target points.\n\n Each target point consists of (latitude, longitude, time).\n\n :param target_point_table: pandas DataFrame created by\n `_create_target_points_for_interp`.\n :param top_grib_directory_name: See doc for\n `interp.interp_nwp_from_xy_grid`.\n :param include_surface: See doc for `_get_nwp_fields_for_sounding`.\n :param model_name: See doc for `interp.interp_nwp_from_xy_grid`.\n :param use_all_grids: Same.\n :param grid_id: Same.\n :param wgrib_exe_name: Same.\n :param wgrib2_exe_name: Same.\n :param raise_error_if_missing: Same.\n :return: interp_table: pandas DataFrame, where each column is one field and\n each row is one target point. Column names are from the list\n \"\"\"\n\n sounding_field_names, sounding_field_names_grib1 = (\n _get_nwp_fields_for_sounding(\n model_name=model_name, return_table=False,\n include_surface=include_surface\n )[:2]\n )\n \n return interp.interp_nwp_from_xy_grid(\n query_point_table=target_point_table, field_names=sounding_field_names,\n field_names_grib1=sounding_field_names_grib1, model_name=model_name,\n top_grib_directory_name=top_grib_directory_name,\n use_all_grids=use_all_grids, grid_id=grid_id,\n temporal_interp_method_string=interp.PREV_NEIGHBOUR_METHOD_STRING,\n spatial_interp_method_string=interp.NEAREST_NEIGHBOUR_METHOD_STRING,\n wgrib_exe_name=wgrib_exe_name, wgrib2_exe_name=wgrib2_exe_name,\n raise_error_if_missing=raise_error_if_missing)\n\n\ndef _convert_interp_table_to_soundings(\n interp_table, target_point_table, model_name, include_surface=False,\n minimum_pressure_mb=0.):\n \"\"\"Converts table of interpolated values to list of soundings.\n\n :param interp_table: N-row pandas DataFrame created by\n `_interp_soundings_from_nwp`.\n :param target_point_table: N-row pandas DataFrame created by\n `_create_target_points_for_interp`.\n :param model_name: Model name (must be accepted by\n `nwp_model_utils.check_model_name`).\n :param include_surface: See doc for `_get_nwp_fields_for_sounding`.\n :param minimum_pressure_mb: Same.\n :return: sounding_dict_pressure_coords: Dictionary with the following keys.\n sounding_dict_pressure_coords['full_storm_id_strings']: length-N list of\n full IDs.\n sounding_dict_pressure_coords['init_times_unix_sec']: length-N numpy array\n of initial times (storm times). Valid time = initial time + lead time.\n sounding_dict_pressure_coords['lead_times_seconds']: length-N numpy array of\n lead times.\n sounding_dict_pressure_coords['sounding_matrix']: N-by-P-by-F numpy array of\n sounding values.\n sounding_dict_pressure_coords['surface_pressures_mb']: length-N numpy array\n with surface pressure (millibars) for each storm object. If\n `include_surface = False`, this is `None`.\n sounding_dict_pressure_coords['pressure_levels_mb']: length-P numpy array of\n pressure levels (millibars). The surface is denoted by NaN.\n sounding_dict_pressure_coords['field_names']: length-F list of field names.\n \"\"\"\n\n sounding_field_name_table = _get_nwp_fields_for_sounding(\n model_name=model_name, return_table=True,\n include_surface=include_surface,\n minimum_pressure_mb=minimum_pressure_mb\n )[-1]\n\n if include_surface:\n surface_pressure_name = nwp_model_utils.get_lowest_pressure_name(\n model_name\n )[0]\n\n surface_pressures_mb = (\n PASCALS_TO_MB * interp_table[surface_pressure_name].values\n )\n else:\n surface_pressures_mb = None\n\n field_names = list(sounding_field_name_table)\n field_names.remove(PRESSURE_LEVEL_KEY)\n\n pressure_levels_with_surface_mb = sounding_field_name_table[\n PRESSURE_LEVEL_KEY\n ].values\n\n num_fields = len(field_names)\n num_pressure_levels = len(sounding_field_name_table.index)\n num_storm_objects = len(interp_table.index)\n\n sounding_matrix = numpy.full(\n (num_storm_objects, num_pressure_levels, num_fields), numpy.nan\n )\n\n for j in range(num_pressure_levels):\n for k in range(num_fields):\n this_field_name = (\n sounding_field_name_table[field_names[k]].values[j]\n )\n sounding_matrix[:, j, k] = interp_table[this_field_name].values\n\n return {\n FULL_IDS_KEY:\n target_point_table[tracking_utils.FULL_ID_COLUMN].values.tolist(),\n INITIAL_TIMES_KEY: target_point_table[INITIAL_TIME_COLUMN].values,\n LEAD_TIMES_KEY: target_point_table[LEAD_TIME_KEY].values,\n SOUNDING_MATRIX_KEY: sounding_matrix,\n SURFACE_PRESSURES_KEY: surface_pressures_mb,\n PRESSURE_LEVELS_WITH_SFC_KEY: pressure_levels_with_surface_mb,\n FIELD_NAMES_KEY: field_names\n }\n\n\ndef _get_pressures(sounding_dict):\n \"\"\"Returns pressure levels in soundings.\n\n :param sounding_dict: Dictionary created by\n `_convert_interp_table_to_soundings` or `_pressure_to_height_coords`.\n :return: pressure_matrix_pascals: N-by-P numpy array of pressures.\n \"\"\"\n\n if PRESSURE_LEVELS_WITH_SFC_KEY not in sounding_dict:\n pressure_index = sounding_dict[FIELD_NAMES_KEY].index(PRESSURE_NAME)\n return sounding_dict[SOUNDING_MATRIX_KEY][..., pressure_index]\n\n num_storm_objects = sounding_dict[SOUNDING_MATRIX_KEY].shape[0]\n num_pressure_levels = sounding_dict[SOUNDING_MATRIX_KEY].shape[1]\n pressure_matrix_pascals = numpy.full(\n (num_storm_objects, num_pressure_levels), numpy.nan)\n\n for i in range(num_storm_objects):\n pressure_matrix_pascals[i, :] = sounding_dict[\n PRESSURE_LEVELS_WITH_SFC_KEY]\n\n if sounding_dict[SURFACE_PRESSURES_KEY] is not None:\n surface_index = numpy.where(\n numpy.isnan(sounding_dict[PRESSURE_LEVELS_WITH_SFC_KEY]))[0][0]\n pressure_matrix_pascals[:, surface_index] = sounding_dict[\n SURFACE_PRESSURES_KEY]\n\n return MB_TO_PASCALS * pressure_matrix_pascals\n\n\ndef _relative_to_specific_humidity(sounding_dict, pressure_matrix_pascals):\n \"\"\"Converts relative to specific humidity in each sounding.\n\n :param sounding_dict: Dictionary created by\n `_convert_interp_table_to_soundings` or `_pressure_to_height_coords`.\n :param pressure_matrix_pascals: N-by-P numpy array of pressures.\n :return: sounding_dict: Same as input, with the following exceptions.\n [1] contains specific humidity\n [2] relative humidity is in 0...1, rather than a percentage\n\n :return: dewpoint_matrix_kelvins: N-by-P numpy array of dewpoints.\n \"\"\"\n\n field_names = sounding_dict[FIELD_NAMES_KEY]\n sounding_matrix = sounding_dict[SOUNDING_MATRIX_KEY]\n temperature_index = field_names.index(TEMPERATURE_NAME)\n\n if nwp_model_utils.RH_COLUMN_FOR_SOUNDINGS in field_names:\n relative_humidity_index = field_names.index(\n nwp_model_utils.RH_COLUMN_FOR_SOUNDINGS)\n\n sounding_matrix[..., relative_humidity_index] = (\n PERCENT_TO_UNITLESS * sounding_matrix[..., relative_humidity_index]\n )\n\n field_names[relative_humidity_index] = RELATIVE_HUMIDITY_NAME\n else:\n relative_humidity_index = field_names.index(RELATIVE_HUMIDITY_NAME)\n\n dewpoint_matrix_kelvins = (\n moisture_conversions.relative_humidity_to_dewpoint(\n relative_humidities=sounding_matrix[..., relative_humidity_index],\n temperatures_kelvins=sounding_matrix[..., temperature_index],\n total_pressures_pascals=pressure_matrix_pascals\n )\n )\n\n spec_humidity_matrix_kg_kg01 = (\n moisture_conversions.dewpoint_to_specific_humidity(\n dewpoints_kelvins=dewpoint_matrix_kelvins,\n temperatures_kelvins=sounding_matrix[..., temperature_index],\n total_pressures_pascals=pressure_matrix_pascals\n )\n )\n\n if SPECIFIC_HUMIDITY_NAME in field_names:\n sounding_matrix[\n ..., field_names.index(SPECIFIC_HUMIDITY_NAME)\n ] = spec_humidity_matrix_kg_kg01\n else:\n field_names.append(SPECIFIC_HUMIDITY_NAME)\n\n spec_humidity_matrix_kg_kg01 = numpy.reshape(\n spec_humidity_matrix_kg_kg01,\n spec_humidity_matrix_kg_kg01.shape + (1,)\n )\n\n sounding_matrix = numpy.concatenate(\n (sounding_matrix, spec_humidity_matrix_kg_kg01), axis=-1\n )\n\n sounding_dict[FIELD_NAMES_KEY] = field_names\n sounding_dict[SOUNDING_MATRIX_KEY] = sounding_matrix\n return sounding_dict, dewpoint_matrix_kelvins\n\n\ndef _specific_to_relative_humidity(sounding_dict, pressure_matrix_pascals):\n \"\"\"Converts specific to relative humidity in each sounding.\n\n :param sounding_dict: Dictionary created by\n `_convert_interp_table_to_soundings` or `_pressure_to_height_coords`.\n :param pressure_matrix_pascals: N-by-P numpy array of pressures.\n :return: sounding_dict: Same as input, but including relative humidity.\n :return: dewpoint_matrix_kelvins: N-by-P numpy array of dewpoints.\n \"\"\"\n\n field_names = sounding_dict[FIELD_NAMES_KEY]\n sounding_matrix = sounding_dict[SOUNDING_MATRIX_KEY]\n temperature_index = field_names.index(TEMPERATURE_NAME)\n specific_humidity_index = field_names.index(SPECIFIC_HUMIDITY_NAME)\n\n dewpoint_matrix_kelvins = (\n moisture_conversions.specific_humidity_to_dewpoint(\n specific_humidities_kg_kg01=\n sounding_matrix[..., specific_humidity_index],\n temperatures_kelvins=sounding_matrix[..., temperature_index],\n total_pressures_pascals=pressure_matrix_pascals\n )\n )\n\n relative_humidity_matrix = (\n moisture_conversions.dewpoint_to_relative_humidity(\n dewpoints_kelvins=dewpoint_matrix_kelvins,\n temperatures_kelvins=sounding_matrix[..., temperature_index],\n total_pressures_pascals=pressure_matrix_pascals\n )\n )\n\n if RELATIVE_HUMIDITY_NAME in field_names:\n sounding_matrix[\n ..., field_names.index(RELATIVE_HUMIDITY_NAME)\n ] = relative_humidity_matrix\n else:\n field_names.append(RELATIVE_HUMIDITY_NAME)\n\n relative_humidity_matrix = numpy.reshape(\n relative_humidity_matrix, relative_humidity_matrix.shape + (1,)\n )\n\n sounding_matrix = numpy.concatenate(\n (sounding_matrix, relative_humidity_matrix), axis=-1\n )\n\n sounding_dict[FIELD_NAMES_KEY] = field_names\n sounding_dict[SOUNDING_MATRIX_KEY] = sounding_matrix\n return sounding_dict, dewpoint_matrix_kelvins\n\n\ndef _get_virtual_potential_temperatures(\n sounding_dict, pressure_matrix_pascals, dewpoint_matrix_kelvins):\n \"\"\"Adds virtual potential temperature to each sounding.\n\n :param sounding_dict: Dictionary created by\n `_convert_interp_table_to_soundings` or `_pressure_to_height_coords`.\n :param pressure_matrix_pascals: N-by-P numpy array of pressures.\n :param dewpoint_matrix_kelvins: N-by-P numpy array of dewpoints.\n :return: sounding_dict: Same as input, but including virtual potential\n temperature.\n \"\"\"\n\n field_names = sounding_dict[FIELD_NAMES_KEY]\n sounding_matrix = sounding_dict[SOUNDING_MATRIX_KEY]\n temperature_index = field_names.index(TEMPERATURE_NAME)\n\n vapour_pressure_matrix_pascals = (\n moisture_conversions.dewpoint_to_vapour_pressure(\n dewpoints_kelvins=dewpoint_matrix_kelvins,\n temperatures_kelvins=sounding_matrix[..., temperature_index],\n total_pressures_pascals=pressure_matrix_pascals\n )\n )\n\n virtual_temperature_matrix_kelvins = (\n moisture_conversions.temperature_to_virtual_temperature(\n temperatures_kelvins=sounding_matrix[..., temperature_index],\n total_pressures_pascals=pressure_matrix_pascals,\n vapour_pressures_pascals=vapour_pressure_matrix_pascals\n )\n )\n\n theta_v_matrix_kelvins = (\n temperature_conversions.temperatures_to_potential_temperatures(\n temperatures_kelvins=virtual_temperature_matrix_kelvins,\n total_pressures_pascals=pressure_matrix_pascals)\n )\n\n if VIRTUAL_POTENTIAL_TEMPERATURE_NAME in field_names:\n sounding_matrix[\n ..., field_names.index(VIRTUAL_POTENTIAL_TEMPERATURE_NAME)\n ] = theta_v_matrix_kelvins\n else:\n field_names.append(VIRTUAL_POTENTIAL_TEMPERATURE_NAME)\n\n theta_v_matrix_kelvins = numpy.reshape(\n theta_v_matrix_kelvins, theta_v_matrix_kelvins.shape + (1,)\n )\n\n sounding_matrix = numpy.concatenate(\n (sounding_matrix, theta_v_matrix_kelvins), axis=-1\n )\n\n sounding_dict[FIELD_NAMES_KEY] = field_names\n sounding_dict[SOUNDING_MATRIX_KEY] = sounding_matrix\n return sounding_dict\n\n\ndef _fill_nans_in_soundings(\n sounding_dict_pressure_coords, pressure_matrix_pascals,\n min_num_pressure_levels_without_nan=15):\n \"\"\"Interpolates to fill NaN's in each sounding.\n\n :param sounding_dict_pressure_coords: See doc for\n `_convert_interp_table_to_soundings`.\n :param pressure_matrix_pascals: N-by-P numpy array of pressures.\n :param min_num_pressure_levels_without_nan: Minimum number of pressure\n levels without NaN. For a given sounding S, if any field has fewer\n pressure levels without NaN, S will be thrown out.\n :return: sounding_dict_pressure_coords: Same as input, with the following\n exceptions.\n [1] maybe fewer soundings\n [2] NaN's have been replaced\n \"\"\"\n\n # TODO(thunderhoser): Remove surface pressure of NaN.\n\n field_names = sounding_dict_pressure_coords[FIELD_NAMES_KEY]\n sounding_matrix = sounding_dict_pressure_coords[SOUNDING_MATRIX_KEY]\n height_index = field_names.index(GEOPOTENTIAL_HEIGHT_NAME)\n\n num_soundings = sounding_matrix.shape[0]\n keep_sounding_flags = numpy.full(num_soundings, True, dtype=bool)\n\n field_names_to_interp = [\n GEOPOTENTIAL_HEIGHT_NAME, U_WIND_NAME, V_WIND_NAME, TEMPERATURE_NAME,\n SPECIFIC_HUMIDITY_NAME\n ]\n\n for i in range(num_soundings):\n for this_field_name in field_names_to_interp:\n this_field_index = field_names.index(this_field_name)\n these_real_flags = numpy.invert(numpy.isnan(\n sounding_matrix[i, :, this_field_index]\n ))\n\n if numpy.all(these_real_flags):\n continue\n\n if (numpy.sum(these_real_flags) <\n min_num_pressure_levels_without_nan):\n keep_sounding_flags[i] = False\n break\n\n these_nan_indices = numpy.where(numpy.invert(these_real_flags))[0]\n these_real_indices = numpy.where(these_real_flags)[0]\n\n if this_field_name == GEOPOTENTIAL_HEIGHT_NAME:\n interp_object = scipy_interp1d(\n x=numpy.log(pressure_matrix_pascals[i, these_real_indices]),\n y=sounding_matrix[i, these_real_indices, this_field_index],\n kind='linear', bounds_error=False, fill_value='extrapolate',\n assume_sorted=False)\n\n sounding_matrix[i, these_nan_indices, this_field_index] = (\n interp_object(\n numpy.log(pressure_matrix_pascals[i, these_nan_indices])\n )\n )\n else:\n interp_object = scipy_interp1d(\n x=sounding_matrix[i, these_real_indices, height_index],\n y=sounding_matrix[i, these_real_indices, this_field_index],\n kind='linear', bounds_error=False, fill_value='extrapolate',\n assume_sorted=False)\n\n sounding_matrix[i, these_nan_indices, this_field_index] = (\n interp_object(\n sounding_matrix[i, these_nan_indices, height_index]\n )\n )\n\n keep_sounding_indices = numpy.where(keep_sounding_flags)[0]\n sounding_dict_pressure_coords[SOUNDING_MATRIX_KEY] = (\n sounding_matrix[keep_sounding_indices, ...]\n )\n sounding_dict_pressure_coords[FULL_IDS_KEY] = [\n sounding_dict_pressure_coords[FULL_IDS_KEY][i]\n for i in keep_sounding_indices\n ]\n\n sounding_dict_pressure_coords[INITIAL_TIMES_KEY] = (\n sounding_dict_pressure_coords[INITIAL_TIMES_KEY][keep_sounding_indices]\n )\n sounding_dict_pressure_coords[LEAD_TIMES_KEY] = (\n sounding_dict_pressure_coords[LEAD_TIMES_KEY][keep_sounding_indices]\n )\n\n if sounding_dict_pressure_coords[SURFACE_PRESSURES_KEY] is not None:\n sounding_dict_pressure_coords[SURFACE_PRESSURES_KEY] = (\n sounding_dict_pressure_coords[SURFACE_PRESSURES_KEY][\n keep_sounding_indices]\n )\n\n return sounding_dict_pressure_coords\n\n\ndef _convert_fields_and_units(sounding_dict_pressure_coords):\n \"\"\"Converts fields and units in each sounding.\n\n :param sounding_dict_pressure_coords: See doc for\n `_convert_interp_table_to_soundings`.\n :return: sounding_dict_pressure_coords: Same as input, but with different\n fields and units.\n \"\"\"\n\n pressure_matrix_pascals = _get_pressures(sounding_dict_pressure_coords)\n found_rh = (\n nwp_model_utils.RH_COLUMN_FOR_SOUNDINGS in\n sounding_dict_pressure_coords[FIELD_NAMES_KEY]\n )\n\n if found_rh:\n sounding_dict_pressure_coords, dewpoint_matrix_kelvins = (\n _relative_to_specific_humidity(\n sounding_dict=sounding_dict_pressure_coords,\n pressure_matrix_pascals=pressure_matrix_pascals)\n )\n\n sounding_dict_pressure_coords = _fill_nans_in_soundings(\n sounding_dict_pressure_coords=sounding_dict_pressure_coords,\n pressure_matrix_pascals=pressure_matrix_pascals)\n\n pressure_matrix_pascals = _get_pressures(sounding_dict_pressure_coords)\n\n if found_rh:\n field_names = sounding_dict_pressure_coords[FIELD_NAMES_KEY]\n sounding_matrix = sounding_dict_pressure_coords[SOUNDING_MATRIX_KEY]\n\n specific_humidity_index = field_names.index(SPECIFIC_HUMIDITY_NAME)\n temperature_index = field_names.index(TEMPERATURE_NAME)\n\n dewpoint_matrix_kelvins = (\n moisture_conversions.specific_humidity_to_dewpoint(\n specific_humidities_kg_kg01=\n sounding_matrix[..., specific_humidity_index],\n temperatures_kelvins=sounding_matrix[..., temperature_index],\n total_pressures_pascals=pressure_matrix_pascals\n )\n )\n else:\n sounding_dict_pressure_coords, dewpoint_matrix_kelvins = (\n _specific_to_relative_humidity(\n sounding_dict=sounding_dict_pressure_coords,\n pressure_matrix_pascals=pressure_matrix_pascals\n )\n )\n\n return _get_virtual_potential_temperatures(\n sounding_dict=sounding_dict_pressure_coords,\n pressure_matrix_pascals=pressure_matrix_pascals,\n dewpoint_matrix_kelvins=dewpoint_matrix_kelvins\n )\n\n\ndef _pressure_to_height_coords(\n sounding_dict_pressure_coords, height_levels_m_agl):\n \"\"\"Converts soundings from pressure coords to ground-relative height coords.\n\n :param sounding_dict_pressure_coords: Dictionary created by\n `_convert_fields_and_units`, but with additional keys listed below.\n sounding_dict_pressure_coords['storm_elevations_m_asl']: length-N numpy\n array of storm elevations (metres above sea level).\n\n :param height_levels_m_agl: length-H numpy array of height levels (integer\n metres above ground level). This method will interpolate each sounding\n to said heights, and the output soundings will be in ground-relative\n height coords rather than pressure coords.\n :return: sounding_dict_height_coords: Dictionary with the following keys.\n sounding_dict_height_coords['full_storm_id_strings']: length-N list of full\n IDs.\n sounding_dict_height_coords['init_times_unix_sec']: length-N numpy array of\n initial times (storm times). Valid time = initial time + lead time.\n sounding_dict_height_coords['lead_times_seconds']: length-N numpy array of\n lead times.\n sounding_dict_height_coords['storm_elevations_m_asl']: length-N numpy array\n of storm elevations (metres above sea level).\n sounding_dict_height_coords['sounding_matrix']: N-by-P-by-F numpy array of\n sounding values.\n sounding_dict_height_coords['height_levels_m_agl']: length-H numpy array of\n height levels (metres above ground level).\n sounding_dict_height_coords['field_names']: length-F list of field names.\n \"\"\"\n\n error_checking.assert_is_numpy_array(height_levels_m_agl, num_dimensions=1)\n error_checking.assert_is_geq_numpy_array(height_levels_m_agl, 0)\n height_levels_m_agl = numpy.round(height_levels_m_agl).astype(int)\n\n sounding_dict_height_coords = {\n FULL_IDS_KEY: sounding_dict_pressure_coords[FULL_IDS_KEY],\n INITIAL_TIMES_KEY: sounding_dict_pressure_coords[INITIAL_TIMES_KEY],\n LEAD_TIMES_KEY: sounding_dict_pressure_coords[LEAD_TIMES_KEY],\n STORM_ELEVATIONS_KEY:\n sounding_dict_pressure_coords[STORM_ELEVATIONS_KEY],\n SOUNDING_MATRIX_KEY: sounding_dict_pressure_coords[SOUNDING_MATRIX_KEY],\n HEIGHT_LEVELS_KEY: height_levels_m_agl,\n FIELD_NAMES_KEY: sounding_dict_pressure_coords[FIELD_NAMES_KEY]\n }\n\n field_names = sounding_dict_pressure_coords[FIELD_NAMES_KEY]\n orig_sounding_matrix = sounding_dict_pressure_coords[SOUNDING_MATRIX_KEY]\n storm_elevations_m_asl = sounding_dict_pressure_coords[STORM_ELEVATIONS_KEY]\n\n height_index = field_names.index(GEOPOTENTIAL_HEIGHT_NAME)\n orig_height_matrix_m_asl = orig_sounding_matrix[..., height_index] + 0.\n\n pressure_matrix_pascals = _get_pressures(sounding_dict_pressure_coords)\n field_names[height_index] = PRESSURE_NAME\n orig_sounding_matrix[..., height_index] = pressure_matrix_pascals + 0.\n\n field_names_to_interp = [\n PRESSURE_NAME, TEMPERATURE_NAME, U_WIND_NAME, V_WIND_NAME\n ]\n\n if RELATIVE_HUMIDITY_NAME in field_names:\n field_names_to_interp.append(RELATIVE_HUMIDITY_NAME)\n else:\n field_names_to_interp.append(SPECIFIC_HUMIDITY_NAME)\n\n num_soundings = orig_sounding_matrix.shape[0]\n num_fields = orig_sounding_matrix.shape[-1]\n num_height_levels = len(height_levels_m_agl)\n\n new_sounding_matrix = numpy.full(\n (num_soundings, num_height_levels, num_fields), numpy.nan\n )\n\n pressure_index = field_names.index(PRESSURE_NAME)\n\n for j in range(len(field_names_to_interp)):\n this_field_index = field_names.index(field_names_to_interp[j])\n\n for i in range(num_soundings):\n if field_names_to_interp[j] == PRESSURE_NAME:\n this_interp_object = scipy_interp1d(\n x=orig_height_matrix_m_asl[i, ...],\n y=numpy.log(orig_sounding_matrix[i, ..., this_field_index]),\n kind='linear', bounds_error=False, fill_value='extrapolate',\n assume_sorted=False)\n\n new_sounding_matrix[i, ..., this_field_index] = numpy.exp(\n this_interp_object(\n storm_elevations_m_asl[i] + height_levels_m_agl)\n )\n else:\n this_interp_object = scipy_interp1d(\n x=orig_sounding_matrix[i, ..., pressure_index],\n y=orig_sounding_matrix[i, ..., this_field_index],\n kind='linear', bounds_error=False, fill_value='extrapolate',\n assume_sorted=False)\n\n new_sounding_matrix[i, ..., this_field_index] = (\n this_interp_object(\n new_sounding_matrix[i, ..., pressure_index]\n )\n )\n\n sounding_dict_height_coords[FIELD_NAMES_KEY] = field_names\n sounding_dict_height_coords[SOUNDING_MATRIX_KEY] = new_sounding_matrix\n\n pressure_matrix_pascals = _get_pressures(sounding_dict_height_coords)\n\n if RELATIVE_HUMIDITY_NAME in field_names:\n sounding_dict_height_coords, dewpoint_matrix_kelvins = (\n _relative_to_specific_humidity(\n sounding_dict=sounding_dict_height_coords,\n pressure_matrix_pascals=pressure_matrix_pascals)\n )\n else:\n sounding_dict_height_coords, dewpoint_matrix_kelvins = (\n _specific_to_relative_humidity(\n sounding_dict=sounding_dict_height_coords,\n pressure_matrix_pascals=pressure_matrix_pascals)\n )\n\n rh_index = field_names.index(RELATIVE_HUMIDITY_NAME)\n sounding_matrix = sounding_dict_height_coords[SOUNDING_MATRIX_KEY]\n\n sounding_matrix[..., rh_index] = numpy.maximum(\n sounding_matrix[..., rh_index], 0.\n )\n sounding_matrix[..., rh_index] = numpy.minimum(\n sounding_matrix[..., rh_index], 1.\n )\n\n sounding_dict_height_coords[SOUNDING_MATRIX_KEY] = sounding_matrix\n\n return _get_virtual_potential_temperatures(\n sounding_dict=sounding_dict_height_coords,\n pressure_matrix_pascals=pressure_matrix_pascals,\n dewpoint_matrix_kelvins=dewpoint_matrix_kelvins)\n\n\ndef check_field_name(field_name):\n \"\"\"Error-checks name of sounding field.\n\n :param field_name: Name of sounding field.\n :raises: ValueError: if `field_name not in VALID_FIELD_NAMES`.\n \"\"\"\n\n error_checking.assert_is_string(field_name)\n\n if field_name not in VALID_FIELD_NAMES:\n error_string = (\n '\\n{0:s}\\nValid field names (listed above) do not include \"{1:s}\".'\n ).format(str(VALID_FIELD_NAMES), field_name)\n\n raise ValueError(error_string)\n\n\ndef field_name_to_verbose(field_name, include_units=True):\n \"\"\"Converts field name from underscore-separated format to verbose.\n\n :param field_name: Field name in default (underscore-separated) format.\n :param include_units: Boolean flag. If True, verbose name will include\n units.\n :return: field_name_verbose: Verbose field name.\n \"\"\"\n\n error_checking.assert_is_boolean(include_units)\n\n if include_units:\n return FIELD_NAME_TO_VERBOSE_DICT[field_name]\n\n return FIELD_NAME_TO_VERBOSE_UNITLESS_DICT[field_name]\n\n\ndef interp_soundings_to_storm_objects(\n storm_object_table, top_grib_directory_name, model_name,\n elevation_dir_name, use_all_grids=True, grid_id=None,\n height_levels_m_agl=DEFAULT_HEIGHT_LEVELS_M_AGL,\n lead_times_seconds=DEFAULT_LEAD_TIMES_SEC,\n lag_time_for_convective_contamination_sec=\n DEFAULT_LAG_TIME_FOR_CONVECTIVE_CONTAMINATION_SEC,\n wgrib_exe_name=grib_io.WGRIB_EXE_NAME_DEFAULT,\n wgrib2_exe_name=grib_io.WGRIB2_EXE_NAME_DEFAULT,\n raise_error_if_missing=False):\n \"\"\"Interpolates NWP sounding to each storm object at each lead time.\n\n :param storm_object_table: pandas DataFrame with columns listed in\n `storm_tracking_io.write_file`.\n :param top_grib_directory_name: Name of top-level directory with grib files\n for the given NWP model.\n :param model_name: Model name (must be accepted by\n `nwp_model_utils.check_grid_name`).\n :param elevation_dir_name: Name of directory with elevation data (used by\n the Python package \"srtm\").\n :param use_all_grids: Boolean flag. If True, this method will interp from\n the highest-resolution grid available at each model-initialization time.\n If False, will use only `grid_id`.\n :param grid_id: [used only if `use_all_grids = False`]\n Grid ID (must be accepted by `nwp_model_utils.check_grid_name`).\n :param height_levels_m_agl: 1-D numpy array of height levels (metres above\n ground level). These will be the height levels in each sounding.\n :param lead_times_seconds: length-T numpy array of lead times.\n :param lag_time_for_convective_contamination_sec: Lag time (used to avoid\n convective contamination of soundings, where the sounding for storm S is\n heavily influenced by storm S). This will be subtracted from each lead\n time.\n :param wgrib_exe_name: Path to wgrib executable.\n :param wgrib2_exe_name: Path to wgrib2 executable.\n :param raise_error_if_missing: Boolean flag. If any grib file is missing\n and `raise_error_if_missing = True`, this method will error out. If any\n grib file is missing and `raise_error_if_missing = False`, this method\n will carry on, leaving the affected values as NaN.\n :return: sounding_dict_by_lead_time: length-T list of dictionaries, each\n containing the keys listed in `_pressure_to_height_coords`.\n \"\"\"\n\n error_checking.assert_is_integer_numpy_array(lead_times_seconds)\n error_checking.assert_is_numpy_array(lead_times_seconds, num_dimensions=1)\n error_checking.assert_is_geq_numpy_array(lead_times_seconds, 0)\n error_checking.assert_is_integer(lag_time_for_convective_contamination_sec)\n error_checking.assert_is_geq(lag_time_for_convective_contamination_sec, 0)\n\n print((\n 'Creating target point for each storm object and lead time ({0:s} '\n 'seconds)...'\n ).format(\n str(lead_times_seconds)\n ))\n\n target_point_table = _create_target_points_for_interp(\n storm_object_table=storm_object_table,\n lead_times_seconds=lead_times_seconds)\n\n print((\n 'Subtracting lag time ({0:d} seconds) from each target point, to '\n 'account for convective contamination...'\n ).format(lag_time_for_convective_contamination_sec))\n\n target_point_table[\n FORECAST_TIME_COLUMN\n ] -= lag_time_for_convective_contamination_sec\n\n column_dict_old_to_new = {\n tracking_utils.CENTROID_LATITUDE_COLUMN: interp.QUERY_LAT_COLUMN,\n tracking_utils.CENTROID_LONGITUDE_COLUMN: interp.QUERY_LNG_COLUMN,\n FORECAST_TIME_COLUMN: interp.QUERY_TIME_COLUMN\n }\n\n target_point_table.rename(columns=column_dict_old_to_new, inplace=True)\n \n print(SEPARATOR_STRING)\n interp_table = _interp_soundings_from_nwp(\n target_point_table=target_point_table,\n top_grib_directory_name=top_grib_directory_name, include_surface=False,\n model_name=model_name, use_all_grids=use_all_grids, grid_id=grid_id,\n wgrib_exe_name=wgrib_exe_name, wgrib2_exe_name=wgrib2_exe_name,\n raise_error_if_missing=raise_error_if_missing)\n print(SEPARATOR_STRING)\n \n print(SEPARATOR_STRING)\n print('this is the interp_table')\n print(interp_table)\n print(SEPARATOR_STRING)\n\n print('Converting interpolated values to soundings...')\n sounding_dict_pressure_coords = _convert_interp_table_to_soundings(\n interp_table=interp_table, target_point_table=target_point_table,\n model_name=model_name, include_surface=False)\n\n print('Converting fields and units in each sounding...')\n orig_num_soundings = len(sounding_dict_pressure_coords[FULL_IDS_KEY])\n sounding_dict_pressure_coords = _convert_fields_and_units(\n sounding_dict_pressure_coords)\n num_soundings = len(sounding_dict_pressure_coords[FULL_IDS_KEY])\n\n print('Removed {0:d} of {1:d} soundings (too many NaN''s).'.format(\n orig_num_soundings - num_soundings, orig_num_soundings))\n\n print('Finding elevation of each storm object...')\n storm_elevations_m_asl = geodetic_utils.get_elevations(\n latitudes_deg=storm_object_table[\n tracking_utils.CENTROID_LATITUDE_COLUMN].values,\n longitudes_deg=storm_object_table[\n tracking_utils.CENTROID_LONGITUDE_COLUMN].values,\n working_dir_name=elevation_dir_name\n )\n\n these_indices = tracking_utils.find_storm_objects(\n all_id_strings=storm_object_table[\n tracking_utils.FULL_ID_COLUMN].values.tolist(),\n all_times_unix_sec=storm_object_table[\n tracking_utils.VALID_TIME_COLUMN].values,\n id_strings_to_keep=sounding_dict_pressure_coords[FULL_IDS_KEY],\n times_to_keep_unix_sec=sounding_dict_pressure_coords[INITIAL_TIMES_KEY]\n )\n\n storm_elevations_m_asl = storm_elevations_m_asl[these_indices]\n sounding_dict_pressure_coords.update({\n STORM_ELEVATIONS_KEY: storm_elevations_m_asl\n })\n\n print('Converting soundings from pressure coords to metres AGL...\\n')\n sounding_dict_height_coords = _pressure_to_height_coords(\n sounding_dict_pressure_coords=sounding_dict_pressure_coords,\n height_levels_m_agl=height_levels_m_agl)\n\n num_lead_times = len(lead_times_seconds)\n sounding_dict_by_lead_time = [None] * num_lead_times\n\n for k in range(num_lead_times):\n print((\n 'Creating separate sounding dictionary for {0:d}-second lead '\n 'time...'\n ).format(lead_times_seconds[k]))\n\n these_indices = numpy.where(\n sounding_dict_height_coords[LEAD_TIMES_KEY] ==\n lead_times_seconds[k]\n )[0]\n\n sounding_dict_by_lead_time[k] = {\n FULL_IDS_KEY: [\n sounding_dict_height_coords[FULL_IDS_KEY][i]\n for i in these_indices\n ],\n INITIAL_TIMES_KEY:\n sounding_dict_height_coords[INITIAL_TIMES_KEY][these_indices],\n LEAD_TIMES_KEY:\n sounding_dict_height_coords[LEAD_TIMES_KEY][these_indices],\n STORM_ELEVATIONS_KEY:\n sounding_dict_height_coords[STORM_ELEVATIONS_KEY][\n these_indices],\n SOUNDING_MATRIX_KEY:\n sounding_dict_height_coords[SOUNDING_MATRIX_KEY][\n these_indices, ...],\n HEIGHT_LEVELS_KEY: sounding_dict_height_coords[HEIGHT_LEVELS_KEY],\n FIELD_NAMES_KEY: sounding_dict_height_coords[FIELD_NAMES_KEY]\n }\n\n print((\n 'Dictionary for {0:d}-second lead time contains {1:d} of {2:d} '\n 'soundings.'\n ).format(lead_times_seconds[k], len(these_indices), num_soundings))\n\n return sounding_dict_by_lead_time\n\n\ndef write_soundings(\n netcdf_file_name, sounding_dict_height_coords, lead_time_seconds,\n lag_time_for_convective_contamination_sec):\n \"\"\"Writes soundings to NetCDF file.\n\n This file may contain soundings with one lead time only.\n\n :param netcdf_file_name: Path to output file.\n :param sounding_dict_height_coords: Dictionary created by\n `interp_soundings_to_storm_objects`.\n :param lead_time_seconds: Lead time for all soundings.\n :param lag_time_for_convective_contamination_sec: Lag time for all soundings\n (see doc for `interp_soundings_to_storm_objects`).\n :raises: ValueError: if `sounding_dict_height_coords` contains more than one\n unique lead time.\n :raises: ValueError: if lead time in `sounding_dict_height_coords` does not\n match the input arg `lead_time_seconds`.\n \"\"\"\n\n error_checking.assert_is_integer(lead_time_seconds)\n error_checking.assert_is_geq(lead_time_seconds, 0)\n error_checking.assert_is_integer(lag_time_for_convective_contamination_sec)\n error_checking.assert_is_geq(lag_time_for_convective_contamination_sec, 0)\n\n unique_lead_times_seconds = numpy.unique(\n sounding_dict_height_coords[LEAD_TIMES_KEY]\n )\n\n if not numpy.all(unique_lead_times_seconds == lead_time_seconds):\n error_string = (\n 'All lead times in sounding dictionary should be {0:d} seconds. '\n 'Instead, got lead times listed below.\\n{1:s}'\n ).format(lead_time_seconds, str(unique_lead_times_seconds))\n\n raise ValueError(error_string)\n\n # Create file and set global attributes.\n file_system_utils.mkdir_recursive_if_necessary(file_name=netcdf_file_name)\n netcdf_dataset = netCDF4.Dataset(\n netcdf_file_name, 'w', format='NETCDF3_64BIT_OFFSET')\n\n netcdf_dataset.setncattr(LEAD_TIME_KEY, lead_time_seconds)\n netcdf_dataset.setncattr(\n LAG_TIME_KEY, lag_time_for_convective_contamination_sec)\n\n num_storm_objects = len(sounding_dict_height_coords[FULL_IDS_KEY])\n num_height_levels = len(sounding_dict_height_coords[HEIGHT_LEVELS_KEY])\n num_fields = len(sounding_dict_height_coords[FIELD_NAMES_KEY])\n\n netcdf_dataset.createDimension(\n STORM_OBJECT_DIMENSION_KEY, num_storm_objects)\n netcdf_dataset.createDimension(HEIGHT_DIMENSION_KEY, num_height_levels)\n netcdf_dataset.createDimension(FIELD_DIMENSION_KEY, num_fields)\n\n id_lengths = [len(f) for f in sounding_dict_height_coords[FULL_IDS_KEY]]\n num_id_characters = max(id_lengths + [1])\n netcdf_dataset.createDimension(\n STORM_ID_CHAR_DIMENSION_KEY, num_id_characters)\n\n num_field_name_chars = max([\n len(f) for f in sounding_dict_height_coords[FIELD_NAMES_KEY]\n ])\n netcdf_dataset.createDimension(\n FIELD_NAME_CHAR_DIMENSION_KEY, num_field_name_chars)\n\n # Add storm IDs to file.\n netcdf_dataset.createVariable(\n FULL_IDS_KEY, datatype='S1',\n dimensions=(STORM_OBJECT_DIMENSION_KEY, STORM_ID_CHAR_DIMENSION_KEY)\n )\n\n string_type = 'S{0:d}'.format(num_id_characters)\n full_ids_char_array = netCDF4.stringtochar(numpy.array(\n sounding_dict_height_coords[FULL_IDS_KEY], dtype=string_type\n ))\n netcdf_dataset.variables[FULL_IDS_KEY][:] = numpy.array(full_ids_char_array)\n\n # Add initial times (storm times) to file.\n netcdf_dataset.createVariable(\n INITIAL_TIMES_KEY, datatype=numpy.int32,\n dimensions=STORM_OBJECT_DIMENSION_KEY)\n netcdf_dataset.variables[INITIAL_TIMES_KEY][:] = (\n sounding_dict_height_coords[INITIAL_TIMES_KEY]\n )\n\n # Add storm elevations to file.\n netcdf_dataset.createVariable(\n STORM_ELEVATIONS_KEY, datatype=numpy.float32,\n dimensions=STORM_OBJECT_DIMENSION_KEY)\n netcdf_dataset.variables[STORM_ELEVATIONS_KEY][:] = (\n sounding_dict_height_coords[STORM_ELEVATIONS_KEY]\n )\n\n # Add height levels to file.\n netcdf_dataset.createVariable(\n HEIGHT_LEVELS_KEY, datatype=numpy.int32,\n dimensions=HEIGHT_DIMENSION_KEY)\n netcdf_dataset.variables[HEIGHT_LEVELS_KEY][:] = (\n sounding_dict_height_coords[HEIGHT_LEVELS_KEY]\n )\n\n # Add field names to file.\n netcdf_dataset.createVariable(\n FIELD_NAMES_KEY, datatype='S1',\n dimensions=(FIELD_DIMENSION_KEY, FIELD_NAME_CHAR_DIMENSION_KEY)\n )\n\n string_type = 'S{0:d}'.format(num_field_name_chars)\n field_names_as_char_array = netCDF4.stringtochar(numpy.array(\n sounding_dict_height_coords[FIELD_NAMES_KEY], dtype=string_type\n ))\n netcdf_dataset.variables[FIELD_NAMES_KEY][:] = numpy.array(\n field_names_as_char_array)\n\n # Add soundings to file.\n netcdf_dataset.createVariable(\n SOUNDING_MATRIX_KEY, datatype=numpy.float32,\n dimensions=(STORM_OBJECT_DIMENSION_KEY, HEIGHT_DIMENSION_KEY,\n FIELD_DIMENSION_KEY)\n )\n\n netcdf_dataset.variables[SOUNDING_MATRIX_KEY][:] = (\n sounding_dict_height_coords[SOUNDING_MATRIX_KEY]\n )\n netcdf_dataset.close()\n\n\ndef read_soundings(\n netcdf_file_name, field_names_to_keep=None,\n full_id_strings_to_keep=None, init_times_to_keep_unix_sec=None):\n \"\"\"Reads soundings from NetCDF file.\n\n K = number of storm objects to keep\n\n If `full_id_strings_to_keep is None or init_times_to_keep_unix_sec is None`,\n this method will return soundings for all storm objects. Otherwise, will\n return only a subset of storm objects.\n\n If `field_names_to_keep is None`, this method will return all sounding\n fields. Otherwise, will return only a subset of fields.\n\n :param netcdf_file_name: Path to input file.\n :param field_names_to_keep: 1-D list with names of sounding fields.\n :param full_id_strings_to_keep: length-K list of full IDs.\n :param init_times_to_keep_unix_sec: length-K numpy array of initial times\n (storm times).\n :return: sounding_dict_height_coords: Dictionary with keys listed in\n `_pressure_to_height_coords`.\n :return: lag_time_for_convective_contamination_sec: See doc for\n `interp_soundings_to_storm_objects`.\n \"\"\"\n\n netcdf_dataset = netcdf_io.open_netcdf(\n netcdf_file_name=netcdf_file_name, raise_error_if_fails=True)\n\n lead_time_seconds = getattr(netcdf_dataset, LEAD_TIME_KEY)\n lag_time_for_convective_contamination_sec = int(getattr(\n netcdf_dataset, LAG_TIME_KEY\n ))\n\n height_levels_m_agl = numpy.array(\n netcdf_dataset.variables[HEIGHT_LEVELS_KEY][:], dtype=int\n )\n field_names = netCDF4.chartostring(\n netcdf_dataset.variables[FIELD_NAMES_KEY][:]\n )\n field_names = [str(f) for f in field_names]\n\n if field_names_to_keep is None:\n field_indices_to_keep = numpy.linspace(\n 0, len(field_names) - 1, num=len(field_names), dtype=int\n )\n else:\n error_checking.assert_is_numpy_array(\n numpy.array(field_names_to_keep), num_dimensions=1\n )\n for this_field_name in field_names_to_keep:\n check_field_name(this_field_name)\n\n field_indices_to_keep = numpy.array(\n [field_names.index(f) for f in field_names_to_keep], dtype=int\n )\n field_names = field_names_to_keep + []\n\n num_storm_objects = netcdf_dataset.variables[FULL_IDS_KEY].shape[0]\n num_height_levels = len(height_levels_m_agl)\n num_fields = len(field_names)\n\n if num_storm_objects == 0:\n full_id_strings = []\n init_times_unix_sec = numpy.array([], dtype=int)\n storm_elevations_m_asl = numpy.array([], dtype=float)\n sounding_matrix = numpy.full(\n (num_storm_objects, num_height_levels, num_fields), numpy.nan\n )\n else:\n full_id_strings = netCDF4.chartostring(\n netcdf_dataset.variables[FULL_IDS_KEY][:]\n )\n full_id_strings = [str(this_id) for this_id in full_id_strings]\n\n init_times_unix_sec = numpy.array(\n netcdf_dataset.variables[INITIAL_TIMES_KEY][:], dtype=int\n )\n storm_elevations_m_asl = numpy.array(\n netcdf_dataset.variables[STORM_ELEVATIONS_KEY][:]\n )\n sounding_matrix = numpy.array(\n netcdf_dataset.variables[SOUNDING_MATRIX_KEY][\n ..., field_indices_to_keep]\n )\n\n netcdf_dataset.close()\n\n filter_storm_objects = (\n full_id_strings_to_keep is not None and\n init_times_to_keep_unix_sec is not None and\n num_storm_objects != 0\n )\n\n if filter_storm_objects:\n these_indices = tracking_utils.find_storm_objects(\n all_id_strings=full_id_strings,\n all_times_unix_sec=init_times_unix_sec,\n id_strings_to_keep=full_id_strings_to_keep,\n times_to_keep_unix_sec=init_times_to_keep_unix_sec,\n allow_missing=True)\n\n these_indices = these_indices[these_indices != -1]\n\n full_id_strings = [full_id_strings[i] for i in these_indices]\n init_times_unix_sec = init_times_unix_sec[these_indices]\n storm_elevations_m_asl = storm_elevations_m_asl[these_indices]\n sounding_matrix = sounding_matrix[these_indices, ...]\n\n num_storm_objects = len(full_id_strings)\n lead_times_seconds = numpy.full(\n num_storm_objects, lead_time_seconds, dtype=int)\n\n sounding_dict_height_coords = {\n FULL_IDS_KEY: full_id_strings,\n INITIAL_TIMES_KEY: init_times_unix_sec,\n LEAD_TIMES_KEY: lead_times_seconds,\n STORM_ELEVATIONS_KEY: storm_elevations_m_asl,\n SOUNDING_MATRIX_KEY: sounding_matrix,\n HEIGHT_LEVELS_KEY: height_levels_m_agl,\n FIELD_NAMES_KEY: field_names\n }\n\n return (sounding_dict_height_coords,\n lag_time_for_convective_contamination_sec)\n\n\ndef find_sounding_file(\n top_directory_name, spc_date_string, lead_time_seconds,\n lag_time_for_convective_contamination_sec, init_time_unix_sec=None,\n raise_error_if_missing=True):\n \"\"\"Finds NetCDF file created by `write_soundings`.\n\n If `init_time_unix_sec is None`, this method will seek a file with all\n soundings for one SPC date. Otherwise, will seek a file with soundings for\n one time step.\n\n :param top_directory_name: Name of top-level directory with sounding files.\n :param spc_date_string: SPC date (format \"yyyymmdd\").\n :param lead_time_seconds: Lead time.\n :param lag_time_for_convective_contamination_sec: See doc for\n `interp_soundings_to_storm_objects`.\n :param init_time_unix_sec: Initial time (storm time).\n :param raise_error_if_missing: Boolean flag. If file is missing and\n `raise_error_if_missing = True`, this method will error out.\n :return: sounding_file_name: Path to sounding file. If file is missing and\n `raise_error_if_missing = False`, this is the *expected* path.\n :raises: ValueError: if file is missing and `raise_error_if_missing = True`.\n \"\"\"\n\n error_checking.assert_is_string(top_directory_name)\n time_conversion.spc_date_string_to_unix_sec(spc_date_string)\n error_checking.assert_is_boolean(raise_error_if_missing)\n\n if init_time_unix_sec is None:\n sounding_file_name = (\n '{0:s}/{1:s}/storm_soundings_{2:s}_lead-time-{3:05d}sec'\n '_lag-time-{4:04d}sec.nc'\n ).format(\n top_directory_name, spc_date_string[:4], spc_date_string,\n lead_time_seconds, lag_time_for_convective_contamination_sec\n )\n else:\n sounding_file_name = (\n '{0:s}/{1:s}/{2:s}/storm_soundings_{3:s}_lead-time-{4:05d}sec'\n '_lag-time-{5:04d}sec.nc'\n ).format(\n top_directory_name, spc_date_string[:4], spc_date_string,\n time_conversion.unix_sec_to_string(\n init_time_unix_sec, TIME_FORMAT_IN_FILE_NAMES),\n lead_time_seconds, lag_time_for_convective_contamination_sec\n )\n\n if raise_error_if_missing and not os.path.isfile(sounding_file_name):\n error_string = (\n 'Cannot find file with soundings interpolated to storm objects. '\n 'Expected at: {0:s}'\n ).format(sounding_file_name)\n\n raise ValueError(error_string)\n\n return sounding_file_name\n", "meta": {"hexsha": "4acdc093040a3684f7a9c2cde8eabc08f7092d53", "size": 61665, "ext": "py", "lang": "Python", "max_stars_repo_path": "gewittergefahr/gg_utils/soundings.py", "max_stars_repo_name": "dopplerchase/GewitterGefahr", "max_stars_repo_head_hexsha": "4415b08dd64f37eba5b1b9e8cc5aa9af24f96593", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "gewittergefahr/gg_utils/soundings.py", "max_issues_repo_name": "dopplerchase/GewitterGefahr", "max_issues_repo_head_hexsha": "4415b08dd64f37eba5b1b9e8cc5aa9af24f96593", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-03-23T21:14:00.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-23T21:14:00.000Z", "max_forks_repo_path": "gewittergefahr/gg_utils/soundings.py", "max_forks_repo_name": "dopplerchase/GewitterGefahr", "max_forks_repo_head_hexsha": "4415b08dd64f37eba5b1b9e8cc5aa9af24f96593", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.5957867018, "max_line_length": 80, "alphanum_fraction": 0.7200356766, "include": true, "reason": "import numpy,from scipy", "num_tokens": 13748, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230157, "lm_q2_score": 0.3738758227716966, "lm_q1q2_score": 0.19277782022841536}} {"text": "import os\nfrom pprint import pprint\nfrom pyomo.environ import *\nimport switch_model.utilities as utilities\nfrom util import get\n\ndef define_arguments(argparser):\n argparser.add_argument('--biofuel-limit', type=float, default=1.0,\n help=\"Maximum fraction of power that can be obtained from biofuel in any period (default=1.0)\")\n argparser.add_argument('--biofuel-switch-threshold', type=float, default=1.0,\n help=\"RPS level at which all thermal plants switch to biofuels (0.0-1.0, default=1.0); use with --rps-allocation fuel_switch_at_high_rps\")\n argparser.add_argument('--rps-activate', default='activate',\n dest='rps_level', action='store_const', const='activate',\n help=\"Activate RPS (on by default).\")\n argparser.add_argument('--rps-deactivate',\n dest='rps_level', action='store_const', const='deactivate',\n help=\"Deactivate RPS.\")\n argparser.add_argument('--rps-no-new-renewables',\n dest='rps_level', action='store_const', const='no_new_renewables',\n help=\"Deactivate RPS and don't allow any new renewables except to replace existing capacity.\")\n argparser.add_argument('--rps-no-new-wind', action='store_true', default=False,\n help=\"Don't allow any new wind capacity except to replace existing capacity.\")\n argparser.add_argument('--rps-no-wind', action='store_true', default=False,\n help=\"Don't allow any new wind capacity or replacement of existing capacity.\")\n argparser.add_argument('--rps-prefer-dist-pv', action='store_true', default=False,\n help=\"Don't allow any new large solar capacity unless 90% of distributed PV ('*DistPV') capacity has been developed.\")\n argparser.add_argument(\n '--rps-allocation', default=None,\n choices=[\n 'quadratic',\n 'fuel_switch_by_period', 'fuel_switch_by_timeseries',\n 'full_load_heat_rate',\n 'split_commit',\n 'relaxed_split_commit',\n 'fuel_switch_at_high_rps',\n ],\n help=\"Method to use to allocate power output among fuels. Default is fuel_switch_by_period for models \"\n + \"with unit commitment, full_load_heat_rate for models without.\"\n )\n argparser.add_argument('--rps-targets', nargs='*', default=None,\n help=\"Targets to use for RPS, specified as --rps-targets year1 level1 year2 level2 ..., \"\n \"where years are transition years and levels are fractions between 0 and 1. \"\n \"If not specified, values from rps_targets.tab will be used.\"\n )\n\n# TODO: make this work with progressive hedging as follows:\n# add a variable indexed over all weather scenarios and all cost scenarios,\n# which shows how much of the RPS will be allocated to each scenario.\n# Problem: we multiply the RPS target by total generation, so this will become quadratic?\n# May instead need to treat the RPS more like a limit on non-renewable production (as a fraction of loads)?\n# Designate the allocations as a first-stage variable.\n# Require each subproblem to work within its part of the allocation. Also require in each subproblem\n# that the allocations across all weather scenarios (within each cost scenario) average out to match the\n# actual target (when applying the scenario weights).\n# Then PHA will force all the scenarios to agree on how the target is allocated among them.\n# Could do the same with hydrogen storage: require average hydrogen stored across all scenarios\n# to be less than the size of the storage built.\n\ndef define_components(m):\n \"\"\"\n\n \"\"\"\n ###################\n # RPS calculation\n ##################\n\n m.f_rps_eligible = Param(m.FUELS, within=Binary)\n\n m.RPS_ENERGY_SOURCES = Set(initialize=lambda m:\n [s for s in m.NON_FUEL_ENERGY_SOURCES if s != 'Battery'] + [f for f in m.FUELS if m.f_rps_eligible[f]]\n )\n\n m.RPS_YEARS = Set(ordered=True)\n m.rps_target = Param(m.RPS_YEARS)\n\n def rps_target_for_period_rule(m, p):\n \"\"\"find the last target that is in effect before the _end_ of the period\"\"\"\n latest_target = max(y for y in m.RPS_YEARS if y < m.period_start[p] + m.period_length_years[p])\n return m.rps_target[latest_target]\n m.rps_target_for_period = Param(m.PERIODS, initialize=rps_target_for_period_rule)\n\n # maximum share of (bio)fuels in rps\n # note: using Infinity as the upper limit causes the solution to take forever\n # m.rps_fuel_limit = Param(default=float(\"inf\"), mutable=True)\n m.rps_fuel_limit = Param(initialize=m.options.biofuel_limit, mutable=True)\n\n # calculate amount of pre-existing capacity in each generation project;\n # used when we want to restrict expansion\n m.gen_pre_existing_capacity = Expression(\n m.GENERATION_PROJECTS,\n rule=lambda m, g: (\n m.GenCapacity[g, m.PERIODS.first()]\n - get(m.BuildGen, (g, m.PERIODS.first()), 0)\n )\n )\n\n # Define DispatchGenRenewableMW, which shows the amount of power produced\n # by each project from each fuel during each time step.\n define_DispatchGenRenewableMW(m)\n\n # calculate amount of power produced from renewable fuels during each period\n m.RPSFuelPower = Expression(m.PERIODS, rule=lambda m, per:\n sum(\n m.DispatchGenRenewableMW[g, tp] * m.tp_weight[tp]\n for g in m.FUEL_BASED_GENS\n for tp in m.TPS_FOR_GEN_IN_PERIOD[g, per]\n )\n )\n\n # Note: this rule ignores pumped hydro and batteries, so it could be gamed by producing extra\n # RPS-eligible power and burning it off in storage losses; on the other hand,\n # it also neglects the (small) contribution from net flow of pumped hydro projects.\n # TODO: incorporate pumped hydro into this rule, maybe change the target to refer to\n # sum(getattr(m, component)[z, t] for z in m.LOAD_ZONES) for component in m.Zone_Power_Injections)\n\n # power production that can be counted toward the RPS each period\n m.RPSEligiblePower = Expression(m.PERIODS, rule=lambda m, per:\n m.RPSFuelPower[per]\n +\n sum(\n m.DispatchGen[g, tp] * m.tp_weight[tp]\n for f in m.NON_FUEL_ENERGY_SOURCES if f in m.RPS_ENERGY_SOURCES\n for g in m.GENS_BY_NON_FUEL_ENERGY_SOURCE[f]\n for tp in m.TPS_FOR_GEN_IN_PERIOD[g, per]\n )\n )\n\n # total power production each period (against which RPS is measured)\n # note: we exclude production from storage\n m.RPSTotalPower = Expression(m.PERIODS, rule=lambda m, per:\n sum(\n m.DispatchGen[g, tp] * m.tp_weight[tp]\n for g in m.GENERATION_PROJECTS if g not in getattr(m, 'STORAGE_GENS', [])\n for tp in m.TPS_FOR_GEN_IN_PERIOD[g, per]\n )\n )\n\n if m.options.rps_level == 'activate':\n # we completely skip creating the constraint if the RPS is not activated.\n # this makes it easy for other modules to check whether there's an RPS in effect\n # (if we deactivated the RPS after it is constructed, then other modules would\n # have to postpone checking until then)\n m.RPS_Enforce = Constraint(m.PERIODS, rule=lambda m, per:\n m.RPSEligiblePower[per] >= m.rps_target_for_period[per] * m.RPSTotalPower[per]\n )\n elif m.options.rps_level == 'no_new_renewables':\n # prevent construction of any new exclusively-renewable projects, but allow\n # replacement of existing ones\n # (doesn't ban use of biofuels in existing or multi-fuel projects, but that could\n # be done with --biofuel-limit 0)\n m.No_New_Renewables = Constraint(m.NEW_GEN_BLD_YRS, rule=lambda m, g, bld_yr:\n (m.GenCapacity[g, bld_yr] <= m.gen_pre_existing_capacity[g])\n if m.gen_energy_source[g] in m.RPS_ENERGY_SOURCES\n else Constraint.Skip\n )\n\n wind_energy_sources = {'WND'}\n if m.options.rps_no_new_wind:\n # limit wind to existing capacity\n m.No_New_Wind = Constraint(m.NEW_GEN_BLD_YRS, rule=lambda m, g, bld_yr:\n (m.GenCapacity[g, bld_yr] <= m.gen_pre_existing_capacity[g])\n if m.gen_energy_source[g] in wind_energy_sources\n else Constraint.Skip\n )\n if m.options.rps_no_wind:\n # don't build any new capacity or replace existing\n m.No_Wind = Constraint(m.NEW_GEN_BLD_YRS, rule=lambda m, g, bld_yr:\n (m.BuildGen[g, bld_yr] == 0.0)\n if m.gen_energy_source[g] in wind_energy_sources\n else Constraint.Skip\n )\n\n if m.options.rps_prefer_dist_pv:\n m.DIST_PV_GENS = Set(initialize=lambda m: [\n g for g in m.GENS_BY_NON_FUEL_ENERGY_SOURCE['SUN']\n if 'DistPV' in m.gen_tech[g]\n ])\n m.LARGE_PV_GENS = Set(initialize=lambda m: [\n g for g in m.GENS_BY_NON_FUEL_ENERGY_SOURCE['SUN']\n if g not in m.DIST_PV_GENS\n ])\n # LargePVAllowed must be 1 to allow large PV to be built\n m.LargePVAllowed = Var(m.PERIODS, within=Binary) #\n # LargePVAllowed can only be 1 if 90% of the available rooftop PV has been built\n m.Set_LargePVAllowed = Constraint(\n m.PERIODS,\n rule=lambda m, p:\n sum(m.GenCapacity[g, p] for g in m.DIST_PV_GENS)\n >=\n m.LargePVAllowed[p]\n * 0.9\n * sum(m.gen_capacity_limit_mw[g] for g in m.DIST_PV_GENS)\n )\n m.Apply_LargePVAllowed = Constraint(\n m.LARGE_PV_GENS, m.PERIODS,\n rule=lambda m, g, p:\n m.GenCapacity[g, p]\n <=\n m.LargePVAllowed[p] * m.gen_capacity_limit_mw[g]\n + m.gen_pre_existing_capacity[g]\n )\n\n # Don't allow (bio)fuels to provide more than a certain percentage of the system's energy\n # Note: when the system really wants to use more biofuel, it is possible to \"game\" this limit by\n # cycling power through batteries, pumped storage, transmission lines or the hydrogen system to\n # burn off some\n # extra non-fuel energy, allowing more biofuel into the system. (This doesn't typically happen\n # with batteries due to high variable costs -- e.g., it has to cycle 4 kWh through a battery to\n # consume 1 kWh of non-biofuel power, to allow 0.05 kWh of additional biofuel into the system.\n # Even if this can save $0.5/kWh, if battery cycling costs $0.15/kWh, that means $0.60 extra to\n # save $0.025. It also doesn't happen in the hydrogen scenario, since storing intermittent power\n # directly as hydrogen can directly displace biofuel consumption. But it could happen if batteries\n # have low efficiency or low cycling cost, or if transmission losses are significant.)\n # One solution would be to only apply the RPS to the predefined load (not generation), but then\n # transmission and battery losses could be served by fossil fuels.\n # Alternatively: limit fossil fuels to (1-rps) * standard loads\n # and limit biofuels to (1-bio)*standard loads. This would force renewables to be used for\n # all losses, which is slightly inaccurate.\n # TODO: fix the problem noted above; for now we don't worry too much because there are no\n # transmission losses, the cycling costs for batteries are too high and pumped storage is only\n # adopted on a small scale.\n\n m.RPS_Fuel_Cap = Constraint(m.PERIODS, rule = lambda m, per:\n m.RPSFuelPower[per] <= m.rps_fuel_limit * m.RPSTotalPower[per]\n )\n\ndef define_DispatchGenRenewableMW(m):\n # Define DispatchGenRenewableMW, which shows the amount of power produced\n # by each project from each fuel during each time step.\n # This must be linear, because it may be used in RPS calculations.\n # This can get complex when a project uses multiple fuels and incremental\n # heat rate curves.\n if m.options.rps_allocation is None:\n if hasattr(m, 'FUEL_USE_SEGMENTS_FOR_GEN'):\n # using heat rate curves and possibly startup fuel;\n # have to do more advanced allocation of power to fuels\n m.options.rps_allocation = 'fuel_switch_by_period'\n else:\n # only using full load heat rate; use simpler allocation strategy\n m.options.rps_allocation = 'full_load_heat_rate'\n if m.options.verbose:\n print \"Using {} method to allocate DispatchGenRenewableMW\".format(m.options.rps_allocation)\n\n if m.options.rps_allocation == 'full_load_heat_rate':\n simple_DispatchGenRenewableMW(m)\n elif m.options.rps_allocation == 'quadratic':\n quadratic_DispatchGenRenewableMW(m)\n elif m.options.rps_allocation == 'fuel_switch_by_period':\n binary_by_period_DispatchGenRenewableMW(m)\n elif m.options.rps_allocation == 'fuel_switch_by_timeseries':\n binary_by_timeseries_DispatchGenRenewableMW(m)\n elif m.options.rps_allocation == 'split_commit':\n split_commit_DispatchGenRenewableMW(m)\n elif m.options.rps_allocation == 'relaxed_split_commit':\n relaxed_split_commit_DispatchGenRenewableMW(m)\n elif m.options.rps_allocation == 'fuel_switch_at_high_rps':\n fuel_switch_at_high_rps_DispatchGenRenewableMW(m)\n\ndef simple_DispatchGenRenewableMW(m):\n # Allocate the power produced during each timepoint among the fuels.\n # When not using heat rate curves, this can be calculated directly from\n # fuel usage and the full load heat rate. This also allows use of\n # multiple fuels in the same project at the same time.\n m.DispatchGenRenewableMW = Expression(\n m.FUEL_BASED_GEN_TPS,\n rule=lambda m, g, t:\n sum(\n m.GenFuelUseRate[g, t, f]\n for f in m.FUELS_FOR_GEN[g]\n if m.f_rps_eligible[f]\n )\n / m.gen_full_load_heat_rate[g]\n )\n\n\ndef split_commit_DispatchGenRenewableMW(m):\n # This approach requires the utility to designate part of their capacity for\n # renewable production and part for non-renewable, and show how they commit\n # and dispatch each part. The current version allows fractional commitment to\n # each mode, but we could use integer commitment variables to force full units\n # into each mode (more physically meaningful, but unnecessarily restrictive and\n # harder to calculate; the current version may serve as a reasonable accounting\n # method for multi-fuel projects in a partial-RPS environment).\n\n # TODO: limit this to projects that can use both renewable and non-renewable fuel\n # TODO: force CommitGenRenewable == CommitGen when there's 100% RPS\n # TODO: force DispatchGenRenewableMW == DispatchGen when there's 100% RPS\n # TODO: force CommitGenRenewable == 0 when there's 0% RPS\n # (these may not be needed: single-category projects will get dispatch forced to zero\n # in one category and forced up to total dispatch in another; non-renewable capacity\n # can't get committed in the 100% RPS due to non-zero min loads)\n\n # count amount of renewable power produced from project\n m.DispatchGenRenewableMW = Var(m.FUEL_BASED_GEN_TPS, within=NonNegativeReals)\n m.DispatchGenRenewableMW_Cap = Constraint(m.FUEL_BASED_GEN_TPS,\n rule = lambda m, g, tp:\n m.DispatchGenRenewableMW[g, tp] <= m.DispatchGen[g, tp]\n )\n # a portion of every startup and shutdown must be designated as renewable\n m.CommitGenRenewable = Var(m.FUEL_BASED_GEN_TPS, within=NonNegativeReals)\n m.CommitGenRenewable_Cap = Constraint(m.FUEL_BASED_GEN_TPS,\n rule = lambda m, g, tp:\n m.CommitGenRenewable[g, tp] <= m.CommitGen[g, tp]\n )\n m.StartupGenCapacityRenewable = Var(m.FUEL_BASED_GEN_TPS, within=NonNegativeReals)\n m.StartupGenCapacityRenewable_Cap = Constraint(m.FUEL_BASED_GEN_TPS,\n rule = lambda m, g, tp:\n m.StartupGenCapacityRenewable[g, tp] <= m.StartupGenCapacity[g, tp]\n )\n m.ShutdownGenCapacityRenewable = Var(m.FUEL_BASED_GEN_TPS, within=NonNegativeReals)\n m.ShutdownGenCapacityRenewable_Cap = Constraint(m.FUEL_BASED_GEN_TPS,\n rule = lambda m, g, tp:\n m.ShutdownGenCapacityRenewable[g, tp] <= m.ShutdownGenCapacity[g, tp]\n )\n # chain commitments, startup and shutdown for renewables\n m.Commit_StartupGenCapacity_ShutdownGenCapacity_Consistency_Renewable = Constraint(\n m.FUEL_BASED_GEN_TPS,\n rule=lambda m, g, tp:\n m.CommitGenRenewable[g, m.tp_previous[tp]]\n + m.StartupGenCapacityRenewable[g, tp]\n - m.ShutdownGenCapacityRenewable[g, tp]\n == m.CommitGenRenewable[g, tp]\n )\n # must use committed capacity for renewable production\n m.Enforce_Dispatch_Upper_Limit_Renewable = Constraint(\n m.FUEL_BASED_GEN_TPS,\n rule=lambda m, g, tp:\n m.DispatchGenRenewableMW[g, tp] <= m.CommitGenRenewable[g, tp]\n )\n # can't dispatch non-renewable capacity below its lower limit\n m.Enforce_Dispatch_Lower_Limit_Non_Renewable = Constraint(\n m.FUEL_BASED_GEN_TPS,\n rule=lambda m, g, tp:\n (m.DispatchGen[g, tp] - m.DispatchGenRenewableMW[g, tp])\n >=\n (m.CommitGen[g, tp] - m.CommitGenRenewable[g, tp])\n * m.gen_min_load_fraction_TP[g, tp]\n )\n # use standard heat rate calculations for renewable and non-renewable parts\n m.ProjRenewableFuelUseRate_Calculate = Constraint(\n m.GEN_TPS_FUEL_PIECEWISE_CONS_SET,\n rule=lambda m, g, tp, intercept, incremental_heat_rate:\n sum(\n m.GenFuelUseRate[g, tp, f]\n for f in m.FUELS_FOR_GEN[g]\n if f in m.RPS_ENERGY_SOURCES\n )\n >=\n m.StartupGenCapacityRenewable[g, tp] * m.gen_startup_fuel[g] / m.tp_duration_hrs[tp]\n + intercept * m.CommitGenRenewable[g, tp]\n + incremental_heat_rate * m.DispatchGenRenewableMW[g, tp]\n )\n m.ProjNonRenewableFuelUseRate_Calculate = Constraint(\n m.GEN_TPS_FUEL_PIECEWISE_CONS_SET,\n rule=lambda m, g, tp, intercept, incremental_heat_rate:\n sum(\n m.GenFuelUseRate[g, tp, f]\n for f in m.FUELS_FOR_GEN[g]\n if f not in m.RPS_ENERGY_SOURCES\n )\n >=\n (m.StartupGenCapacity[g, tp] - m.StartupGenCapacityRenewable[g, tp]) * m.gen_startup_fuel[g] / m.tp_duration_hrs[tp]\n + intercept * (m.CommitGen[g, tp] - m.CommitGenRenewable[g, tp])\n + incremental_heat_rate * (m.DispatchGen[g, tp] - m.DispatchGenRenewableMW[g, tp])\n )\n\ndef relaxed_split_commit_DispatchGenRenewableMW(m):\n # This is similar to the split_commit approach, but allows startup fuel\n # to be freely allocated between renewable and non-renewable fuels.\n # This eliminates the need for m.CommitGenRenewable variables, which are\n # then replaced by m.DispatchGenRenewableMW.\n # This means all startup fuel can be non-renewable, except when the RPS\n # is 100%.\n\n # count amount of renewable power produced from project\n m.DispatchGenRenewableMW = Var(m.FUEL_BASED_GEN_TPS, within=NonNegativeReals)\n m.DispatchGenRenewableMW_Cap = Constraint(m.FUEL_BASED_GEN_TPS,\n rule = lambda m, g, tp:\n m.DispatchGenRenewableMW[g, tp] <= m.DispatchGen[g, tp]\n )\n m.StartupGenCapacityRenewable = Var(m.FUEL_BASED_GEN_TPS, within=NonNegativeReals)\n m.StartupGenCapacityRenewable_Cap = Constraint(m.FUEL_BASED_GEN_TPS,\n rule = lambda m, g, tp:\n m.StartupGenCapacityRenewable[g, tp] <= m.StartupGenCapacity[g, tp]\n )\n\n # can't dispatch non-renewable capacity below its lower limit\n m.Enforce_Dispatch_Lower_Limit_Non_Renewable = Constraint(\n m.FUEL_BASED_GEN_TPS,\n rule=lambda m, g, tp:\n (m.DispatchGen[g, tp] - m.DispatchGenRenewableMW[g, tp])\n >=\n (m.CommitGen[g, tp] - m.DispatchGenRenewableMW[g, tp])\n * m.gen_min_load_fraction_TP[g, tp]\n )\n\n # rule=lambda m, g, t, intercept, incremental_heat_rate: (\n # sum(m.GenFuelUseRate[g, t, f] for f in m.FUELS_FOR_GEN[g]) >=\n # # Do the startup\n # m.StartupGenCapacity[g, t] * m.gen_startup_fuel[g] / m.tp_duration_hrs[t] +\n # intercept * m.CommitGen[g, t] +\n # incremental_heat_rate * m.DispatchGen[g, t]))\n\n # TODO: fix bug in this code that forces renewable dispatch=total committed when\n # using 100% RPS (this makes it hard to get reserves and makes it impossible to\n # use the AES plant when using discrete commitment, because the PSIP module limits\n # output to 180 MW but the plant is rated 185 MW.)\n\n # use standard heat rate calculations for renewable and non-renewable parts\n # These set a lower bound for each type of fuel, as if we committed one slice of capacity\n # for renewables and one slice for non-renewable, equal to the amount of power from each.\n m.ProjRenewableFuelUseRate_Calculate = Constraint(\n m.GEN_TPS_FUEL_PIECEWISE_CONS_SET,\n rule=lambda m, g, tp, intercept, incremental_heat_rate:\n sum(\n m.GenFuelUseRate[g, tp, f]\n for f in m.FUELS_FOR_GEN[g]\n if f in m.RPS_ENERGY_SOURCES\n )\n >=\n m.StartupGenCapacityRenewable[g, tp] * m.gen_startup_fuel[g] / m.tp_duration_hrs[tp]\n + intercept * m.DispatchGenRenewableMW[g, tp]\n + incremental_heat_rate * m.DispatchGenRenewableMW[g, tp]\n )\n m.ProjNonRenewableFuelUseRate_Calculate = Constraint(\n m.GEN_TPS_FUEL_PIECEWISE_CONS_SET,\n rule=lambda m, g, tp, intercept, incremental_heat_rate:\n sum(\n m.GenFuelUseRate[g, tp, f]\n for f in m.FUELS_FOR_GEN[g]\n if f not in m.RPS_ENERGY_SOURCES\n )\n >=\n (m.StartupGenCapacity[g, tp] - m.StartupGenCapacityRenewable[g, tp]) * m.gen_startup_fuel[g] / m.tp_duration_hrs[tp]\n + intercept * (m.DispatchGen[g, tp] - m.DispatchGenRenewableMW[g, tp])\n + incremental_heat_rate * (m.DispatchGen[g, tp] - m.DispatchGenRenewableMW[g, tp])\n )\n\n # don't allow any non-renewable fuel if RPS is 100%\n if m.options.rps_level == 'activate':\n # find all dispatch points for non-renewable fuels during periods with 100% RPS\n m.FULL_RPS_GEN_FOSSIL_FUEL_DISPATCH_POINTS = Set(\n dimen=3,\n initialize=lambda m: [\n (g, tp, f)\n for per in m.PERIODS if m.rps_target_for_period[per] == 1.0\n for g in m.FUEL_BASED_GENS if (g, per) in m.GEN_PERIODS\n for f in m.FUELS_FOR_GEN[g] if not m.f_rps_eligible[f]\n for tp in m.TPS_IN_PERIOD[per]\n ]\n )\n m.No_Fossil_Fuel_With_Full_RPS = Constraint(\n m.FULL_RPS_GEN_FOSSIL_FUEL_DISPATCH_POINTS,\n rule=lambda m, g, tp, f: m.GenFuelUseRate[g, tp, f] == 0.0\n )\n\n\ndef fuel_switch_at_high_rps_DispatchGenRenewableMW(m):\n \"\"\" switch all plants to biofuel (and count toward RPS) if and only if rps is above threshold \"\"\"\n\n if m.options.rps_level == 'activate':\n # find all dispatch points for non-renewable fuels during periods with 100% RPS\n m.HIGH_RPS_GEN_FOSSIL_FUEL_DISPATCH_POINTS = Set(\n dimen=3,\n initialize=lambda m: [\n (g, tp, f)\n for p in m.PERIODS if m.rps_target_for_period[p] >= m.options.biofuel_switch_threshold\n for g in m.FUEL_BASED_GENS if (g, p) in m.GEN_PERIODS\n for f in m.FUELS_FOR_GEN[g] if not m.f_rps_eligible[f]\n for tp in m.TPS_IN_PERIOD[p]\n ]\n )\n m.No_Fossil_Fuel_With_High_RPS = Constraint(\n m.HIGH_RPS_GEN_FOSSIL_FUEL_DISPATCH_POINTS,\n rule=lambda m, g, tp, f: m.GenFuelUseRate[g, tp, f] == 0.0\n )\n # count full dispatch toward RPS during non-fossil periods, otherwise give no credit\n def rule(m, g, tp):\n if m.rps_target_for_period[m.tp_period[tp]] >= m.options.biofuel_switch_threshold:\n return m.DispatchGen[g, tp]\n else:\n return 0.0\n m.DispatchGenRenewableMW = Expression(m.FUEL_BASED_GEN_TPS, rule=rule)\n else:\n m.DispatchGenRenewableMW = Expression(\n m.FUEL_BASED_GEN_TPS, within=NonNegativeReals,\n rule=lambda m, g, tp: 0.0\n )\n\ndef binary_by_period_DispatchGenRenewableMW(m):\n # NOTE: this could be extended to handle fuel blends (e.g., 50% biomass/50% coal)\n # by assigning an RPS eligibility level to each fuel (e.g., 50%), then\n # setting binary variables for whether to use each fuel during each period\n # (possibly treated as an SOS; or might be able to have an SOS for total\n # amount to produce from each fuel during the period, and require that total\n # consumption of each fuel <= production from that fuel * max((consumption+startup)/output across operating points)\n # This could be further simplified by creating a set of eligibility levels,\n # and choosing the amount to produce from each eligibility level (similar to the\n # renewable/non-renewable distinction here, but with a 50% renewable category)\n\n m.GEN_WITH_FUEL_ACTIVE_PERIODS = Set(dimen=2, initialize=lambda m: {\n (g, pe)\n for g in m.FUEL_BASED_GENS for pe in m.PERIODS\n if (g, m.TPS_IN_PERIOD[pe].first()) in m.FUEL_BASED_GEN_TPS\n })\n\n # choose whether to run (only) on renewable fuels during each period\n m.DispatchRenewableFlag = Var(m.GEN_WITH_FUEL_ACTIVE_PERIODS, within=Binary)\n\n # force flag on or off when the RPS is simple (to speed computation)\n def rule(m, g, p):\n if m.rps_target_for_period[pe]==1.0:\n # 100% RPS; use only renewable fuels\n return (m.DispatchRenewableFlag[g, pe] == 1)\n elif m.rps_target_for_period[pe]==0.0 or m.options.rps_level != 'activate':\n # no RPS, don't bother counting renewable fuels\n return (m.DispatchRenewableFlag[g, pe] == 0)\n else:\n return Constraint.Skip\n m.Force_DispatchRenewableFlag = Constraint(\n m.GEN_WITH_FUEL_ACTIVE_PERIODS,\n rule=lambda m, g, pe:\n (m.DispatchRenewableFlag[g, pe] == 0)\n if (m.rps_target_for_period[pe]==0.0 or m.options.rps_level != 'activate')\n else (\n (m.DispatchRenewableFlag[g, pe] == 1)\n if m.rps_target_for_period[pe]==1.0\n else Constraint.Skip\n )\n )\n\n # count amount of renewable power produced from project\n m.DispatchGenRenewableMW = Var(m.FUEL_BASED_GEN_TPS, within=NonNegativeReals)\n\n # don't overcount renewable power production\n m.Limit_DispatchGenRenewableMW = Constraint(\n m.FUEL_BASED_GEN_TPS,\n rule=lambda m, g, tp:\n m.DispatchGenRenewableMW[g, tp] <= m.DispatchGen[g, tp]\n )\n # force the flag to be set during renewable timepoints\n m.Set_DispatchRenewableFlag = Constraint(\n m.FUEL_BASED_GEN_TPS,\n rule=lambda m, g, tp:\n m.DispatchGenRenewableMW[g, tp]\n <=\n m.DispatchRenewableFlag[g, m.tp_period[tp]] * m.gen_capacity_limit_mw[g]\n )\n\n # prevent use of non-renewable fuels during renewable timepoints\n def Enforce_DispatchRenewableFlag_rule(m, g, tp, f):\n if m.f_rps_eligible[f]:\n return Constraint.Skip\n else:\n # harder to read like this, but having all numerical values on the right hand side\n # facilitates analysis of duals and reduced costs\n # note: we also add a little slack to avoid having this be the main constraint\n # on total output from any power plant (that also clarifies dual analysis)\n big_fuel = 1.01 * m.gen_capacity_limit_mw[g] * m.gen_full_load_heat_rate[g]\n return (\n m.GenFuelUseRate[g, tp, f]\n + m.DispatchRenewableFlag[g, m.tp_period[tp]] * big_fuel\n <=\n big_fuel\n )\n m.Enforce_DispatchRenewableFlag = Constraint(\n m.GEN_TP_FUELS, rule=Enforce_DispatchRenewableFlag_rule\n )\n\ndef binary_by_timeseries_DispatchGenRenewableMW(m):\n m.GEN_WITH_FUEL_ACTIVE_TIMESERIES = Set(dimen=2, initialize=lambda m: {\n (g, ts)\n for g in m.FUEL_BASED_GENS for ts in m.TIMESERIES\n if (g, m.TPS_IN_TS[ts].first()) in m.FUEL_BASED_GEN_TPS\n })\n\n # choose whether to run (only) on renewable fuels during each period\n m.DispatchRenewableFlag = Var(m.GEN_WITH_FUEL_ACTIVE_TIMESERIES, within=Binary)\n\n # force flag on or off depending on RPS status (to speed computation)\n m.Force_DispatchRenewableFlag = Constraint(\n m.GEN_WITH_FUEL_ACTIVE_TIMESERIES,\n rule=lambda m, g, ts:\n (m.DispatchRenewableFlag[g, ts] == 0) if m.rps_target_for_period[m.ts_period[ts]]==0.0\n else (\n (m.DispatchRenewableFlag[g, ts] == 1) if m.rps_target_for_period[m.ts_period[ts]]==1.0\n else Constraint.Skip\n )\n )\n\n # count amount of renewable power produced from project\n m.DispatchGenRenewableMW = Var(m.FUEL_BASED_GEN_TPS, within=NonNegativeReals)\n\n # don't overcount renewable power production\n m.Limit_DispatchGenRenewableMW = Constraint(\n m.FUEL_BASED_GEN_TPS,\n rule=lambda m, g, tp:\n m.DispatchGenRenewableMW[g, tp] <= m.DispatchGen[g, tp]\n )\n # force the flag to be set during renewable timepoints\n m.Set_DispatchRenewableFlag = Constraint(\n m.FUEL_BASED_GEN_TPS,\n rule=lambda m, g, tp:\n m.DispatchGenRenewableMW[g, tp]\n <=\n m.DispatchRenewableFlag[g, m.tp_ts[tp]] * m.gen_capacity_limit_mw[g]\n )\n\n # prevent use of non-renewable fuels during renewable timepoints\n m.Enforce_DispatchRenewableFlag = Constraint(\n m.GEN_TP_FUELS,\n rule=lambda m, g, tp, f:\n Constraint.Skip if m.f_rps_eligible[f]\n else (\n # original code, rewritten to get numerical parts on rhs\n # m.GenFuelUseRate[g, tp, f]\n # <=\n # (1-m.DispatchRenewableFlag[g, m.tp_ts[tp]]) * m.gen_capacity_limit_mw[g] * m.gen_full_load_heat_rate[g]\n m.GenFuelUseRate[g, tp, f]\n + m.DispatchRenewableFlag[g, m.tp_ts[tp]] * m.gen_capacity_limit_mw[g] * m.gen_full_load_heat_rate[g]\n <=\n m.gen_capacity_limit_mw[g] * m.gen_full_load_heat_rate[g]\n )\n )\n\n\n\ndef advanced2_DispatchGenRenewableMW(m):\n # choose whether to run (only) on renewable fuels during each timepoint\n m.DispatchRenewableFlag = Var(m.FUEL_BASED_GEN_TPS, within=Binary)\n\n # count amount of renewable power produced from project\n m.DispatchGenRenewableMW = Var(m.FUEL_BASED_GEN_TPS, within=NonNegativeReals)\n\n # don't overcount renewable power production\n m.Limit_DispatchGenRenewableMW = Constraint(\n m.FUEL_BASED_GEN_TPS,\n rule=lambda m, g, tp: m.DispatchGenRenewableMW[g, tp] <= m.DispatchGen[g, tp]\n )\n # force the flag to be set during renewable timepoints\n m.Set_DispatchRenewableFlag = Constraint(\n m.FUEL_BASED_GEN_TPS,\n rule=lambda m, g, tp:\n m.DispatchGenRenewableMW[g, tp]\n <=\n m.DispatchRenewableFlag[g, tp] * m.gen_capacity_limit_mw[g]\n )\n\n # prevent use of non-renewable fuels during renewable timepoints\n m.Enforce_DispatchRenewableFlag = Constraint(\n m.GEN_TP_FUELS,\n rule=lambda m, g, tp, f:\n Constraint.Skip if m.f_rps_eligible[f]\n else (\n m.GenFuelUseRate[g, tp, f]\n <=\n (1-m.DispatchRenewableFlag[g, tp]) * m.gen_capacity_limit_mw[g] * m.gen_full_load_heat_rate[g]\n )\n )\n\n\ndef advanced1_DispatchGenRenewableMW(m):\n # Allocate the power produced during each timepoint among the fuels.\n\n m.DispatchGenRenewableMW = Var(m.GEN_TP_FUELS, within=NonNegativeReals)\n # make sure this matches total production\n m.DispatchGenRenewableMW_Total = Constraint(\n m.FUEL_BASED_GEN_TPS,\n rule=lambda m, g, tp:\n sum(m.DispatchGenRenewableMW[g, tp, f] for f in m.FUELS_FOR_GEN[g])\n ==\n m.DispatchGen[g, tp]\n )\n\n # choose a single fuel to use during each timestep\n m.DispatchFuelFlag = Var(m.GEN_TP_FUELS, within=Binary)\n m.DispatchFuelFlag_Total = Constraint(\n m.FUEL_BASED_GEN_TPS,\n rule=lambda m, g, tp:\n sum(m.DispatchFuelFlag[g, tp, f] for f in m.FUELS_FOR_GEN[g])\n ==\n 1\n )\n\n # consume only the selected fuel and allocate all production to that fuel (big-M constraints)\n m.Allocate_Dispatch_Output = Constraint(\n m.GEN_TP_FUELS,\n rule=lambda m, g, tp, f:\n m.DispatchGenRenewableMW[g, tp, f]\n <=\n m.DispatchFuelFlag[g, tp, f] * m.gen_capacity_limit_mw[g]\n )\n m.Allocate_Dispatch_Fuel = Constraint(\n m.GEN_TP_FUELS,\n rule=lambda m, g, tp, f:\n m.GenFuelUseRate[g, tp, f]\n <=\n m.DispatchFuelFlag[g, tp, f] * m.gen_capacity_limit_mw[g] * m.gen_full_load_heat_rate[g]\n )\n\n # note: in cases where a project has a single fuel, the presolver should force\n # DispatchGenRenewableMW for that fuel to match DispatchGen, and possibly\n # eliminate the allocation constraints\n\n # possible simplifications:\n # omit binary variables and big-m constraints if len(m.FUELS_FOR_GEN[p]) == 1\n # (assign all production to the single fuel)\n # use m.GenFuelUseRate[g, t, f] / m.gen_full_load_heat_rate[g]\n # for projects with no heat rate curve and no startup fuel\n\n # note: a continuous, quadratic version of this function can be created as follows:\n # - make DispatchFuelFlag a PercentFraction instead of Binary\n # - replace gen_capacity_limit_mw with GenCapacity in Allocate_Dispatch_Output\n # - replace m.gen_capacity_limit_mw * m.gen_full_load_heat_rate with\n # sum(m.GenFuelUseRate[g, t, f] for f in m.FUELS_FOR_GEN[g])\n # in Allocate_Dispatch_Fuel (define this as an Expression in dispatch.py)\n # - replace <= with == in the allocation constraints\n # - drop the DispatchGenRenewableMW_Total constraint\n\n # or this would also work:\n # m.DispatchGenRenewableMW = Var(m.GEN_TP_FUELS)\n # m.DispatchGenRenewableMW_Allocate = Constraint(\n # m.GEN_TP_FUELS,\n # rule = lambda m, g, t, f:\n # m.DispatchGenRenewableMW[g, t, f]\n # * sum(m.GenFuelUseRate[g, t, _f] for _f in m.FUELS_FOR_GEN[g])\n # ==\n # DispatchGen[g, t]\n # * m.GenFuelUseRate[g, t, f]\n # )\n\ndef quadratic_DispatchGenRenewableMW(m):\n # choose how much power to obtain from renewables during each timepoint\n m.DispatchRenewableFraction = Var(m.FUEL_BASED_GEN_TPS, within=PercentFraction)\n\n # count amount of renewable power produced from project\n m.DispatchGenRenewableMW = Var(m.FUEL_BASED_GEN_TPS, within=NonNegativeReals)\n\n # don't overcount renewable power production\n m.Set_DispatchRenewableFraction = Constraint(\n m.FUEL_BASED_GEN_TPS,\n rule=lambda m, g, tp:\n m.DispatchGenRenewableMW[g, tp]\n <=\n m.DispatchRenewableFraction[g, tp] * m.DispatchGen[g, tp]\n )\n m.Enforce_DispatchRenewableFraction = Constraint(\n m.FUEL_BASED_GEN_TPS,\n rule=lambda m, g, tp:\n sum(\n m.GenFuelUseRate[g, tp, f]\n for f in m.FUELS_FOR_GEN[g]\n if m.f_rps_eligible[f]\n )\n >=\n m.DispatchRenewableFraction[g, tp] *\n sum(\n m.GenFuelUseRate[g, tp, f]\n for f in m.FUELS_FOR_GEN[g]\n )\n )\n\ndef quadratic1_DispatchGenRenewableMW(m):\n # Allocate the power produced during each timepoint among the fuels.\n m.DispatchGenRenewableMW = Var(m.GEN_TP_FUELS, within=NonNegativeReals)\n\n # make sure this matches total production\n m.DispatchGenRenewableMW_Total = Constraint(\n m.FUEL_BASED_GEN_TPS,\n rule=lambda m, g, tp:\n sum(m.DispatchGenRenewableMW[g, tp, f] for f in m.FUELS_FOR_GEN[g])\n ==\n m.DispatchGen[g, tp]\n )\n\n m.DispatchGenRenewableMW_Allocate = Constraint(\n m.GEN_TP_FUELS,\n rule = lambda m, g, t, f:\n m.DispatchGenRenewableMW[g, t, f]\n * sum(m.GenFuelUseRate[g, t, _f] for _f in m.FUELS_FOR_GEN[g])\n <=\n m.DispatchGen[g, t]\n * m.GenFuelUseRate[g, t, f]\n )\n\ndef load_inputs(m, switch_data, inputs_dir):\n switch_data.load_aug(\n optional=True,\n filename=os.path.join(inputs_dir, 'fuels.tab'),\n select=('fuel', 'rps_eligible'),\n param=(m.f_rps_eligible,))\n if m.options.rps_targets is None:\n switch_data.load_aug(\n optional=True,\n filename=os.path.join(inputs_dir, 'rps_targets.tab'),\n autoselect=True,\n index=m.RPS_YEARS,\n param=(m.rps_target,))\n else:\n # construct data from a target specified as 'year1 level1 year2 level2 ...'\n iterator = iter(m.options.rps_targets)\n rps_targets = {int(year): float(target) for year, target in zip(iterator, iterator)}\n switch_data.data()['RPS_YEARS'] = {None: sorted(rps_targets.keys())}\n switch_data.data()['rps_target'] = rps_targets\n", "meta": {"hexsha": "292043e748fc258a809ec823c4c46299f38b58d3", "size": 37662, "ext": "py", "lang": "Python", "max_stars_repo_path": "switch_model/hawaii/rps.py", "max_stars_repo_name": "ashutosh-pande/switch3", "max_stars_repo_head_hexsha": "769d25a42c8323f24740567aa15c980f905a03e2", "max_stars_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "switch_model/hawaii/rps.py", "max_issues_repo_name": "ashutosh-pande/switch3", "max_issues_repo_head_hexsha": "769d25a42c8323f24740567aa15c980f905a03e2", "max_issues_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "switch_model/hawaii/rps.py", "max_forks_repo_name": "ashutosh-pande/switch3", "max_forks_repo_head_hexsha": "769d25a42c8323f24740567aa15c980f905a03e2", "max_forks_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 46.7850931677, "max_line_length": 146, "alphanum_fraction": 0.6547979396, "include": true, "reason": "from pyomo", "num_tokens": 9690, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230157, "lm_q2_score": 0.3738758227716966, "lm_q1q2_score": 0.19277782022841536}} {"text": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n# coding: utf-8\n\n\n\"\"\"\nAuthor: Arnaud Ferré\nMail: arnaud.ferre.pro@gmail.com\nDescription: Training module for C-Norm method\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at: http://www.apache.org/licenses/LICENSE-2.0\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n\"\"\"\n\n\n\n\n#######################################################################################################\n# Import modules & set up logging\n#######################################################################################################\n\nfrom optparse import OptionParser\nimport json\nimport gzip\nfrom os.path import dirname, exists\nfrom os import makedirs\n\nimport numpy\nimport gensim\nfrom tensorflow.keras import layers, models, Model, Input, regularizers, optimizers, metrics, losses, initializers, backend\n\nfrom word2term import getSizeOfVST\nfrom onto import loadOnto, ontoToVec\n\n#######################################################################################################\n# Utils\n#######################################################################################################\n\n# Normalization of token embeddings:\ndef normalizeEmbedding(vst_onlyTokens):\n for token in vst_onlyTokens.keys():\n vst_onlyTokens[token] = vst_onlyTokens[token] / numpy.linalg.norm(vst_onlyTokens[token])\n return vst_onlyTokens\n\n\n# CHoose with getMatricForCNN...?\ndef prepare2D_data(vst_onlyTokens, dl_terms, dl_associations, vso, phraseMaxSize):\n\n #ToDo: Keep a constant size of the input matrix between train and prediction\n nbTerms = len(dl_terms.keys())\n sizeVST = getSizeOfVST(vst_onlyTokens)\n sizeVSO = getSizeOfVST(vso)\n\n X_train = numpy.zeros((nbTerms, phraseMaxSize, sizeVST))\n Y_train = numpy.zeros((nbTerms, 1, sizeVSO))\n\n l_unkownTokens = list()\n l_uncompleteExpressions = list()\n\n for i, id_term in enumerate(dl_associations.keys()):\n # stderr.write('id_term = %s\\n' % str(id_term))\n # stderr.write('len(dl_associations[id_term]) = %d\\n' % len(dl_associations[id_term]))\n\n for id_concept in dl_associations[id_term]:\n Y_train[i][0] = vso[id_concept]\n for j, token in enumerate(dl_terms[id_term]):\n if j < phraseMaxSize:\n if token in vst_onlyTokens.keys():\n X_train[i][j] = vst_onlyTokens[token]\n else:\n l_unkownTokens.append(token)\n else:\n l_uncompleteExpressions.append(id_term)\n break # Because it' easier to keep only one concept per mention (mainly to calculate size of matrix).\n # ToDo: switch to object to include directly size with these structures.\n\n return X_train, Y_train, l_unkownTokens, l_uncompleteExpressions\n\n\n#\ndef loadJSON(filename):\n if filename.endswith('.gz'):\n f = gzip.open(filename)\n else:\n # f = open(filename, encoding='utf-8')\n f = open(filename, \"r\", encoding=\"utf-8\")\n result = json.load(f)\n f.close()\n return result;\n\n\n\n\n#######################################################################################################\n# Concept-Normalization (C-Norm)\n#######################################################################################################\n\ndef CNorm(vst_onlyTokens, dl_terms, dl_associations, vso,\n nbEpochs=30, batchSize=64,\n l_numberOfFilters=[4000], l_filterSizes=[1],\n phraseMaxSize=15):\n\n # Preparing data for SLFNN and S-CNN components:\n dataSCNN, labels, l_unkownTokens, l_uncompleteExpressions = prepare2D_data(vst_onlyTokens, dl_terms, dl_associations, vso, phraseMaxSize)\n dataSLFNN = numpy.zeros((dataSCNN.shape[0], dataSCNN.shape[2]))\n for i in range( dataSCNN.shape[0]):\n numberOfToken = 0\n for embedding in dataSCNN[i]:\n if not numpy.any(embedding):\n pass\n else:\n numberOfToken += 1\n dataSLFNN[i] += embedding\n\n if numberOfToken > 0:\n dataSLFNN[i] = dataSLFNN[i] / numberOfToken\n\n\n # Input layers:\n inputLP = Input(shape=dataSLFNN.shape[1])\n inputCNN = Input(shape=[dataSCNN.shape[1],dataSCNN.shape[2]])\n\n\n # SLFNN component:\n ontoSpaceSize = labels.shape[2]\n denseLP = layers.Dense(units=ontoSpaceSize, use_bias=True, kernel_initializer=initializers.GlorotUniform())(inputLP)\n modelLP = Model(inputs=inputLP, outputs=denseLP)\n\n\n # Shallow-CNN component:\n l_subLayers = list()\n for i, filterSize in enumerate(l_filterSizes):\n\n convLayer = (layers.Conv1D(l_numberOfFilters[i], filterSize, strides=1, kernel_initializer=initializers.GlorotUniform()))(inputCNN)\n\n outputSize = phraseMaxSize - filterSize + 1\n pool = (layers.MaxPool1D(pool_size=outputSize))(convLayer)\n\n activationLayer = (layers.LeakyReLU(alpha=0.3))(pool)\n\n l_subLayers.append(activationLayer)\n\n if len(l_filterSizes) > 1:\n concatenateLayer = (layers.Concatenate(axis=-1))(l_subLayers) # axis=-1 // concatenating on the last dimension\n else:\n concatenateLayer = l_subLayers[0]\n\n denseLayer = layers.Dense(ontoSpaceSize, kernel_initializer=initializers.GlorotUniform())(concatenateLayer)\n modelCNN = Model(inputs=inputCNN, outputs=denseLayer)\n\n convModel = Model(inputs=inputCNN, outputs=concatenateLayer)\n fullmodel = models.Sequential()\n fullmodel.add(convModel)\n\n\n # Combination of the two components:\n combinedLayer = layers.average([modelLP.output, modelCNN.output])\n fullModel = Model(inputs=[inputLP, inputCNN], outputs=combinedLayer)\n fullModel.summary()\n\n\n # Compile and train:\n fullModel.compile(optimizer=optimizers.Nadam(), loss=losses.LogCosh(), metrics=[metrics.CosineSimilarity(), metrics.MeanSquaredError()])\n fullModel.fit([dataSLFNN, dataSCNN], labels, epochs=nbEpochs, batch_size=batchSize)\n\n\n return fullModel, vso, l_unkownTokens\n\n\n\n\n\n#######################################################################################################\n# Run class:\n#######################################################################################################\nclass Train(OptionParser):\n\n def __init__(self):\n\n OptionParser.__init__(self, usage='usage: %prog [options]')\n\n self.add_option('--word-vectors', action='store', type='string', dest='word_vectors',\n help='path to word vectors JSON file as produced by word2vec')\n self.add_option('--word-vectors-bin', action='store', type='string', dest='word_vectors_bin',\n help='path to word vectors binary file as produced by word2vec')\n self.add_option('--terms', action='store', type='string', dest='terms',\n help='path to terms file in JSON format (map: id -> array of tokens)')\n self.add_option('--attributions', action='store', type='string', dest='attributions',\n help='path to attributions file in JSON format (map: id -> array of concept ids)')\n self.add_option('--ontology', action='store', type='string', dest='ontology',\n help='path to ontology file in OBO format')\n\n self.add_option('--outputModel', action='store', type='string', dest='model', help='path to save the NN model directory')\n\n # Methods hyperparameters:\n self.add_option('--factor', action='store', type='float', dest='factors', default=0.65, help='parent concept weight factor (default=0.6).')\n self.add_option('--epochs', action='store', type='int', dest='epochs', default=150, help='number of epochs (default=150).')\n self.add_option('--batch', action='store', type='int', dest='batch', default=64, help='number of samples in batch (default=64).')\n self.add_option('--filtersSize', action='append', type='int', dest='filtersSize', help='list of the different size of filters (default=1)')\n self.add_option('--filtersNb', action='append', type='int', dest='filtersNb', help='list of the number of filters from filtersSize (default=100)')\n self.add_option('--phraseMaxSize', action='store', type='int', dest='phrase_max_size', default=15, help='max considered size of phrases in inputs (default=15).')\n self.add_option('--normalizedInputs', action='store', type='string', dest='normalizedInputs', default=\"True\", help='unit normalize embeddings if \"True\" (default: True).')\n\n\n\n def run(self):\n\n options, args = self.parse_args()\n if len(args) > 0:\n raise Exception('stray arguments: ' + ' '.join(args))\n\n if options.word_vectors is None and options.word_vectors_bin is None:\n raise Exception('missing either --word-vectors or --word-vectors-bin')\n if options.word_vectors is not None and options.word_vectors_bin is not None:\n raise Exception('incompatible --word-vectors or --word-vectors-bin')\n if options.ontology is None:\n raise Exception('missing --ontology')\n if not options.terms:\n raise Exception('missing --terms')\n if not options.attributions:\n raise Exception('missing --attributions')\n if not options.model:\n raise Exception('missing --outputModel')\n\n if options.filtersSize is None:\n options.filtersSize = [1]\n if options.filtersNb is None:\n options.filtersNb = [100]\n if options.filtersSize is not None and options.filtersNb is not None:\n if len(options.filtersSize) != len(options.filtersNb):\n raise Exception('ERROR: number of elements in --filtersSize different from number of elements in --filtersNb')\n\n\n # Selected hyperparameters (can have an important influence...):\n print(\"\\nRuning C-Norm with next hyperparameters:\")\n print(\"factor=\", options.factors)\n print(\"epochs=\", options.epochs)\n print(\"batch=\", options.batch)\n print(\"filtersSize=\", options.filtersSize)\n print(\"filtersNb=\", options.filtersNb)\n print(\"phraseMaxSize=\", options.phrase_max_size)\n print(\"normalizedInputs=\", options.normalizedInputs)\n\n\n # Loading ontology:\n print(\"\\nloading ontology:\", options.ontology)\n ontology = loadOnto(options.ontology)\n\n # Loading word embeddings:\n if options.word_vectors is not None:\n print(\"loading word embeddings:\", options.word_vectors)\n word_vectors = loadJSON(options.word_vectors)\n elif options.word_vectors_bin is not None:\n print(\"loading word embeddings:\", options.word_vectors_bin)\n EmbModel = gensim.models.Word2Vec.load(options.word_vectors_bin)\n word_vectors = dict((k, list(numpy.float_(npf32) for npf32 in EmbModel.wv[k])) for k in EmbModel.wv.vocab.keys())\n\n # Loading all mentions:\n print(\"Loading terms:\", options.terms)\n dl_terms = loadJSON(options.terms)\n\n # Loading training examples:\n print(\"Loading attributions:\", options.attributions)\n attributions = loadJSON(options.attributions)\n\n\n # Scaling of all embeddings:\n if options.normalizedInputs is not None:\n if options.normalizedInputs == \"True\":\n print(\"\\nScaling: Unit normalization of input embeddings (recommended)...\")\n word_vectors = normalizeEmbedding(word_vectors)\n print(\"Scaling done.\\n\")\n else:\n print(\"No scaling of input embeddings (not recommended, see normalizedInputs option).\")\n\n # Building ontological space\n print(\"Building ontological space (with factor applied)...\")\n vso = ontoToVec(ontology, options.factors)\n print(\"Ontological space built.\\n\")\n\n\n\n print(\"C-Norm training...\")\n model, ontology_vector, _ = CNorm(word_vectors, dl_terms, attributions, vso,\n nbEpochs=options.epochs, batchSize=options.batch,\n l_numberOfFilters=options.filtersNb, l_filterSizes=options.filtersSize,\n phraseMaxSize=options.phrase_max_size)\n print(\"C-Norm training done.\\n\")\n\n\n\n # Saving model:\n if options.model is not None:\n print(\"Saving trained Tensorflow model...\")\n d = dirname(options.model)\n if not exists(d) and d != '':\n makedirs(d)\n model.save(options.model)\n print(\"Model saved.\")\n\n\n\n#######################################################################################################\n# Test section\n#######################################################################################################\n\nif __name__ == '__main__':\n\n Train().run()\n", "meta": {"hexsha": "804df5e345a19fbd0e940f19119eaec2491a4aeb", "size": 13136, "ext": "py", "lang": "Python", "max_stars_repo_path": "train.py", "max_stars_repo_name": "ArnaudFerre/C-Norm_PostLab", "max_stars_repo_head_hexsha": "edb9462a32b3e47b38bfd62836427d3a90f510ab", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "train.py", "max_issues_repo_name": "ArnaudFerre/C-Norm_PostLab", "max_issues_repo_head_hexsha": "edb9462a32b3e47b38bfd62836427d3a90f510ab", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "train.py", "max_forks_repo_name": "ArnaudFerre/C-Norm_PostLab", "max_forks_repo_head_hexsha": "edb9462a32b3e47b38bfd62836427d3a90f510ab", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.5696202532, "max_line_length": 178, "alphanum_fraction": 0.6079476248, "include": true, "reason": "import numpy", "num_tokens": 2792, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230157, "lm_q2_score": 0.3738758227716966, "lm_q1q2_score": 0.19277782022841536}} {"text": "# -*- coding: utf-8 -*-\n# After execution of the main pipeline, files are organized in a variety of\n# locations, and some information is spread across multiple files. This\n# gathers various charts and creates tables using provided data, storing it\n# all in folders organized by paper section.\nimport utils\nimport graphUtils\nimport numpy as np\nimport scipy.stats as stats\nimport os\nimport re\nimport subprocess\n\nimport mainParams as mp\nfrom groupWords import getWordGroupsRangeTest\n\n\n# ==============================================================================\n# ==============================================================================\n\n# Color constants for heat-map tables\nCOLOR_BLUE = (66, 134, 244)\nCOLOR_ORANGE = (244, 179, 66)\nCOLOR_GRAY = (239, 239, 239)\n\n# given a start color, an end color, and a current value within a min-max\n# range, find a linear interpolation between start and end color\ndef colorConvert(min, max, current, startColor, endColor):\n sr, sg, sb = startColor\n er, eg, eb = endColor\n scale = (current - min) / (max - min)\n red = sr + scale*(er-sr)\n green = sg + scale*(eg-sg)\n blue = sb + scale*(eb-sb)\n return (red/255, green/255, blue/255)\n\n\n# create tables with information evaluating given metrics\ndef makeMetricEvalTables(suffix, topStr, comparableTopStr, topNum, poetryNum, comparableNum, simMetrics, baseFolder):\n baseScoreInfo = [\n (\"Cosine\", 0),\n (\"Burrows' Delta\", 0),\n ]\n\n bestMetricName = \"Jensen-Shannon (250)\" #Jensen-Shannon+p\n bestMetricSigWork = []\n bestMetricSigAuthor = []\n\n evalTableOutput = []\n evalTableOutput.append(\"\"\"\\\\begin{table}[!bt]\n \\\\centering\n \\\\def\\\\arraystretch{1}\n \\\\begin{tabular}{| l | r | r |}\n\\\\hline\n & \\\\multicolumn{2}{c|}{\\\\textbf{Percentage of segments most similar to a segment...}} \\\\\\\\\n\n\\\\textbf{Metric}& \\\\textbf{from the same work} & \\\\textbf{by the same author} \\\\\\\\\\\\hline\n\"\"\")\n\n\n sameWorkTableOutput = []\n sameAuthorTableOutput = []\n temp = \"\"\"\\\\begin{table}[!bt]\n \\\\centering\n \\\\def\\\\arraystretch{1}\n \\\\begin{tabular}{| l | c | c | c |}\n\\\\hline\n \"\"\"\n sameWorkTableOutput.append(temp)\n sameAuthorTableOutput.append(temp)\n\n temp = \"& & \\\\textbf{Top %d +} & \\\\\\\\\" % (topNum)\n sameWorkTableOutput.append(temp)\n sameAuthorTableOutput.append(temp)\n\n temp = \"\\\\textbf{Metric}& \\\\textbf{Top %d} & \\\\textbf{Top %d in Poetry} & \\\\textbf{Top %d} \\\\\\\\\\\\hline\" % (topNum, poetryNum, comparableNum)\n sameWorkTableOutput.append(temp)\n sameAuthorTableOutput.append(temp)\n\n workSigReport = []\n authorSigReport = []\n\n\n # & \\\\textbf{Sim to another work} & \\\\textbf{Closest to diff author} & \\\\textbf{Median}\n\n # Get the list of authors and works the metric got correct\n scoreLists = {}\n for simMetric in simMetrics:\n dir, metricName = simMetric\n scoreLists[metricName] = {}\n for i, params in enumerate([(False, False), (True, False), (False, True), ]):\n name = metricName\n addP, comparable = params\n metricTopStr = topStr\n if addP:\n metricTopStr += \"+p\"\n name += \"+p\"\n # look at comparable number of non-poetry words\n elif comparable:\n metricTopStr = comparableTopStr\n name += \" (%d)\" % comparableNum\n else:\n name += \" (%d)\" % topNum\n\n fname = \"output/greek/no_split/%s/%s/metric/Books/scores.json\" % (metricTopStr, dir)\n scores = utils.getContent(fname, True)\n scoreLists[metricName][i] = scores\n scoreLists[metricName][i][\"name\"] = name\n\n baseScores = []\n for bsi in baseScoreInfo:\n baseScoreMetric, baseScoreIndex = bsi\n baseScores.append(scoreLists[baseScoreMetric][baseScoreIndex])\n\n # Create a table of the information using the provided scores\n for metricName in scoreLists:\n cell2 = \"\\\\textbf{%s}\" % (metricName)\n cell3 = \"\\\\textbf{%s}\" % (metricName)\n for i in scoreLists[metricName]:\n currentScores = scoreLists[metricName][i]\n authorScores = currentScores[\"author\"]\n workScores = currentScores[\"work\"]\n name = currentScores[\"name\"]\n sameWork = \"%.2f%%\" % (100*np.mean(workScores))\n sameAuth = \"%.2f%%\" % (100*np.mean(authorScores))\n # sameWork = \"%.2f%%, (%d/%d)\" % (100*np.mean(workScores), np.sum(workScores), len(workScores))\n # sameAuth = \"%.2f%%, (%d/%d)\" % (100*np.mean(authorScores), np.sum(authorScores), len(authorScores))\n\n # cell = \"%s & %s & %s & %s & %s & %s\" % (name, sameAuth, sameWork, otherWork, diffAuthClosest, median)\n cell = \"%s & %s & %s\" % (name, sameWork, sameAuth)\n cell = cell.replace(\"%\", \"\\\\%\")\n evalTableOutput.append(\"%s\\\\\\\\\\\\hline\" % cell)\n\n cell2 += \" & %s\" % (sameWork) # work_p\n cell3 += \" & %s\" % (sameAuth) # , author_p)\n\n for j, baseScore in enumerate(baseScores):\n a = baseScore[\"work\"]\n b = currentScores[\"work\"]\n work_t, work_p = stats.ttest_rel(a, b)\n workSigReport.append(name)\n # Degrees of freedom\n df = len(b) - 1\n workSig = \" (M=%.3f, SD=%.3f) t(%d)=%.3f, p=%.3e\" % (np.mean(b), np.std(b), df, work_t, work_p)\n workSigReport.append(workSig)\n\n\n a = baseScore[\"author\"]\n b = currentScores[\"author\"]\n author_t, author_p = stats.ttest_rel(a, b)\n authorSigReport.append(name)\n # Degrees of freedom\n df = len(b) - 1\n authorSig = \" (M=%.3f, SD=%.3f) t(%d)=%.3f, p=%.3e\" % (np.mean(b), np.std(b), df, author_t, author_p)\n authorSigReport.append(authorSig)\n\n if (name == bestMetricName or name == baseScore[\"name\"]):\n bestMetricSigWork.append(\"%s vs %s\" % (name, baseScore[\"name\"]))\n bestMetricSigWork.append(workSig)\n\n bestMetricSigAuthor.append(\"%s vs %s\" % (name, baseScore[\"name\"]))\n bestMetricSigAuthor.append(authorSig)\n\n #print(\" Author: t-statistic = %6.3f pvalue = %f\" % stats.ttest_rel(a, b))\n\n # Significance notes\n if (j == 0):\n if (work_p < 0.01):\n cell2 += \"\\\\textbf{†}\"\n elif (work_p < 0.05):\n cell2 += \"\\\\textbf{*}\"\n if (author_p < 0.01):\n cell3 += \"\\\\textbf{†}\"\n elif (author_p < 0.05):\n cell3 += \"\\\\textbf{*}\"\n else:\n if (work_p < 0.01):\n cell2 += \"\\\\textbf{‡}\"\n if (author_p < 0.01):\n cell3 += \"\\\\textbf{‡}\"\n\n\n\n cell2 = cell2.replace(\"%\", \"\\\\%\")\n sameWorkTableOutput.append(\"%s\\\\\\\\\\\\hline\" % cell2)\n\n cell3 = cell3.replace(\"%\", \"\\\\%\")\n sameAuthorTableOutput.append(\"%s\\\\\\\\\\\\hline\" % cell3)\n\n evalTableOutput.append(\"\"\"\n \\\\end{tabular}\n \\\\caption{How well similarity metrics identify whether two segments come from the same work or the same author.}\n \\\\label{table:metric_eval}\n \\\\end{table}\n \"\"\")\n\n utils.safeWrite(\"%smetric/extraInfo/metricEvalTable%s.tex\" % (baseFolder, suffix), \"\\n\".join(evalTableOutput))\n\n sameWorkTableOutput.append(\"\\\\end{tabular}\")\n sameWorkTableOutput.append(\"\\\\caption[How well similarity metrics based on a given set of words identify whether two segments come from the same work.]{\")\n sameWorkTableOutput.append(\"How well similarity metrics based on a given set of words identify whether two segments come from the same work. \\\\newline\")\n sameWorkTableOutput.append(\"†: Results very significant (p < 0.01) when compared to %s. \\\\newline\" % baseScores[0][\"name\"])\n sameWorkTableOutput.append(\"*: Results significant (p < 0.05) when compared to %s. \\\\newline\" % baseScores[0][\"name\"])\n sameWorkTableOutput.append(\"‡: Results very significant (p < 0.01) when compared to %s. \" % baseScores[1][\"name\"])\n sameWorkTableOutput.append(\"}\")\n sameWorkTableOutput.append(\"\\\\label{table:metric_eval_work}\")\n sameWorkTableOutput.append(\"\\\\end{table}\")\n\n utils.safeWrite(\"%smetric/sameWorkEvalTable%s.tex\" % (baseFolder, suffix), \"\\n\".join(sameWorkTableOutput))\n\n\n sameAuthorTableOutput.append(\"\\\\end{tabular}\")\n sameAuthorTableOutput.append(\"\\\\caption[How well similarity metrics based on a given set of words identify whether two segments come from the same author.]{\")\n sameAuthorTableOutput.append(\"How well similarity metrics based on a given set of words identify whether two segments come from the same author. \\\\newline\")\n sameAuthorTableOutput.append(\"†: Results very significant (p < 0.01) when compared to %s. \\\\newline\" % baseScores[0][\"name\"])\n sameAuthorTableOutput.append(\"*: Results significant (p < 0.05) when compared to %s. \\\\newline\" % baseScores[0][\"name\"])\n sameAuthorTableOutput.append(\"‡: Results very significant (p < 0.01) when compared to %s. \" % baseScores[1][\"name\"])\n sameAuthorTableOutput.append(\"}\")\n sameAuthorTableOutput.append(\"\\\\label{table:metric_eval_author}\")\n sameAuthorTableOutput.append(\"\\\\end{table}\")\n\n utils.safeWrite(\"%smetric/sameAuthorEvalTable%s.tex\" % (baseFolder, suffix), \"\\n\".join(sameAuthorTableOutput))\n\n\n sigReport = \"Work:\\n\" + (\"\\n\".join(bestMetricSigWork)) + \"\\n\\n-------------\\n\\nAuthor:\\n\" + (\"\\n\".join(bestMetricSigAuthor))\n utils.safeWrite(\"%smetric/bestMetricSignificance%s.txt\" % (baseFolder, suffix), sigReport)\n # utils.safeWrite(\"%smetric/bestMetricSignificanceWork%s.txt\" % (baseFolder, suffix), \"\\n\".join(bestMetricSigWork))\n # utils.safeWrite(\"%smetric/bestMetricSignificanceAuthor%s.txt\" % (baseFolder, suffix), \"\\n\".join(bestMetricSigAuthor))\n\n\n utils.safeWrite(\"%smetric/extraInfo/metricSignificanceReportWork%s.txt\" % (baseFolder, suffix), \"\\n\".join(workSigReport))\n utils.safeWrite(\"%smetric/extraInfo/metricSignificanceReportAuthor%s.txt\" % (baseFolder, suffix), \"\\n\".join(authorSigReport))\n\n\n\n\n# create tables with information evaluating performance of each metric with/without\n# smoothing and remainder words\ndef makeMetricInternalTables(suffix, topStr, simMetrics, baseFolder):\n metricInternalTables = []\n for simMetric in simMetrics:\n dir, metricName = simMetric\n\n # skip Jensen-Shannon\n if metricName == \"Jensen-Shannon\":\n continue\n\n tableOutput = []\n temp = \"\"\"\n\\\\begin{table}[!bt]\n \\\\centering\n \\\\def\\\\arraystretch{1}\n \\\\begin{tabular}{| l | c | c | c |}\n\\\\hline\n \"\"\"\n tableOutput.append(temp)\n\n temp = \"\\\\textbf{Metric Options} & \\\\textbf{Author} & \\\\textbf{Work} & \\\\textbf{Total} \\\\\\\\\\\\hline\"\n tableOutput.append(temp)\n\n workSigReport = []\n authorSigReport = []\n totalSigReport = []\n\n # & \\\\textbf{Sim to another work} & \\\\textbf{Closest to diff author} & \\\\textbf{Median}\n\n metricOptions = [\n (\"Baseline\", \"-remainder-smoothed\"),\n (\"+1 Smoothing\", \"-remainder+smoothed\"),\n (\"Remainder\", \"+remainder-smoothed\"),\n (\"Both\", \"+remainder+smoothed\")\n ]\n\n # Get the list of authors and works the metric got correct\n scoreLists = {}\n for _, opt in metricOptions:\n scoreLists[opt] = {}\n name = opt\n # Use Poetry Words\n metricTopStr = topStr\n\n fname = \"output/greek/no_split/%s/%s/metric%s/Books/scores.json\" % (metricTopStr, dir, opt)\n scores = utils.getContent(fname, True)\n scoreLists[opt] = scores\n scoreLists[opt][\"name\"] = name\n\n baseScore = scoreLists[\"-remainder-smoothed\"]\n # baseScores = []\n # for bsi in baseScoreInfo:\n # baseScoreMetric, baseScoreIndex = bsi\n # baseScores.append(scoreLists[baseScoreMetric][baseScoreIndex])\n\n # Create a table of the information using the provided scores\n for optName, opt in metricOptions:\n cell = \"\\\\textbf{%s}\" % (optName)\n\n currentScores = scoreLists[opt]\n authorScores = currentScores[\"author\"]\n workScores = currentScores[\"work\"]\n name = currentScores[\"name\"]\n sameWork = \"%.2f%%, (%d/%d)\" % (100*np.mean(workScores), np.sum(workScores), len(workScores))\n sameAuth = \"%.2f%%, (%d/%d)\" % (100*np.mean(authorScores), np.sum(authorScores), len(authorScores))\n all = np.concatenate((workScores, authorScores))\n total = \"%.2f%%, (%d/%d)\" % (100*np.mean(all), np.sum(all), len(all))\n\n wrk = \" & %s\" % (sameWork)\n auth = \" & %s\" % (sameAuth)\n tot = \" & %s\" % (total)\n\n\n # Calculate significance\n a = baseScore[\"work\"]\n b = currentScores[\"work\"]\n work_t, work_p = stats.ttest_rel(a, b)\n workSigReport.append(name)\n # Degrees of freedom\n df = len(b) - 1\n workSig = \" (M=%.3f, SD=%.3f) t(%d)=%.3f, p=%.3e\" % (np.mean(b), np.std(b), df, work_t, work_p)\n workSigReport.append(workSig)\n\n\n a = baseScore[\"author\"]\n b = currentScores[\"author\"]\n author_t, author_p = stats.ttest_rel(a, b)\n authorSigReport.append(name)\n # Degrees of freedom\n df = len(b) - 1\n authorSig = \" (M=%.3f, SD=%.3f) t(%d)=%.3f, p=%.3e\" % (np.mean(b), np.std(b), df, author_t, author_p)\n authorSigReport.append(authorSig)\n\n\n a = np.concatenate((baseScore[\"work\"], baseScore[\"author\"]))\n b = np.concatenate((currentScores[\"work\"], currentScores[\"author\"]))\n all_t, all_p = stats.ttest_rel(a, b)\n totalSigReport.append(name)\n # Degrees of freedom\n df = len(b) - 1\n totalSig = \" (M=%.3f, SD=%.3f) t(%d)=%.3f, p=%.3e\" % (np.mean(b), np.std(b), df, all_t, all_p)\n totalSigReport.append(totalSig)\n\n\n # if (name == bestMetricName or name == baseScore[\"name\"]):\n # bestMetricSigWork.append(\"%s vs %s\" % (name, baseScore[\"name\"]))\n # bestMetricSigWork.append(workSig)\n #\n # bestMetricSigAuthor.append(\"%s vs %s\" % (name, baseScore[\"name\"]))\n # bestMetricSigAuthor.append(authorSig)\n\n #print(\" Author: t-statistic = %6.3f pvalue = %f\" % stats.ttest_rel(a, b))\n\n # Significance notes\n if (work_p < 0.01):\n wrk += \"\\\\textbf{†}\"\n elif (work_p < 0.05):\n wrk += \"\\\\textbf{*}\"\n if (author_p < 0.01):\n auth += \"\\\\textbf{†}\"\n elif (author_p < 0.05):\n auth += \"\\\\textbf{*}\"\n if (all_p < 0.01):\n tot += \"\\\\textbf{†}\"\n elif (all_p < 0.05):\n tot += \"\\\\textbf{*}\"\n\n # wrk += \" %.4f\" % work_p\n # auth += \" %.4f\" % author_p\n # tot += \" %.4f\" % all_p\n\n cell += \"%s%s%s\" % (wrk, auth, tot)\n\n cell = cell.replace(\"%\", \"\\\\%\")\n tableOutput.append(\"%s\\\\\\\\\\\\hline\" % cell)\n\n tableOutput.append(\"\\\\end{tabular}\")\n tableOutput.append(\"\\\\caption{\")\n tableOutput.append(\"How well %s performs with the remainder words and smoothing included. \" % metricName)\n tableOutput.append(\"†: Results very significant (p < 0.01) when compared to baseline. \")\n tableOutput.append(\"*: Results significant (p < 0.05) when compared to baseline. \")\n tableOutput.append(\"}\")\n tableOutput.append(\"\\\\label{table:metric_options_eval_%s}\" % dir)\n tableOutput.append(\"\\\\end{table}\")\n\n tableOutput.append(\"\")\n tableOutput.append(\"\")\n metricInternalTables.append(\"\\n\".join(tableOutput))\n utils.safeWrite(\"%smetric/%s_optionsEvalTable%s.tex\" % (baseFolder, metricName, suffix), \"\\n\".join(tableOutput))\n\n # sigReport = \"Work:\\n\" + (\"\\n\".join(bestMetricSigWork)) + \"\\n\\n-------------\\n\\nAuthor:\\n\" + (\"\\n\".join(bestMetricSigAuthor))\n # utils.safeWrite(\"%smetric/bestMetricSignificance%s_2.txt\" % (baseFolder, suffix), sigReport)\n\n # utils.safeWrite(\"%smetric/extraInfo/metricSignificanceReportWork%s_2.txt\" % (baseFolder, suffix), \"\\n\".join(workSigReport))\n # utils.safeWrite(\"%smetric/extraInfo/metricSignificanceReportAuthor%s_2.txt\" % (baseFolder, suffix), \"\\n\".join(authorSigReport))\n utils.safeWrite(\"%smetric/extraInfo/optionsEvalTables%s.tex\" % (baseFolder, suffix), \"\\n\".join(metricInternalTables))\n\n\n# Get author pairs for authors 4 centuries apart with high similarity.\ndef fourCenturiesTables(topStr, simMetrics, baseFolder):\n comparisonOutput = []\n topSimsToExamine = 100\n\n # Grab this from the best metric\n authorSims = utils.getContent(\"output/greek/no_split/%s/jensen-shannon/metric/Authors/sims.txt\" % (topStr), False).split(\"\\n\")\n topDistantSims = []\n topDistantAuthors = {}\n for i, sim in enumerate(authorSims):\n centuries_apart = int(sim.split(\"(\")[-1].split(\" \")[0])\n if (centuries_apart >= 4 and i < topSimsToExamine):\n topDistantSims.append(sim)\n topDistantAuthors[sim[11:]] = {}\n\n authors = \" (\".join(sim.split(\" - \")[1].split(\" (\")[:-1])\n if authors == \"Isocrates, Lysias\" or authors == \"Plato, Xenophon\" or authors == \"AratusSolensis, Callimachus\" or authors == \"Herodotus, Thucydides\":\n comparisonOutput.append(\"Rank %d: %s\" % (i+1, sim))\n\n fourCenturiesApartOutput = []\n fourCenturiesApartOutput.append(\"%d of the top %d are at least 4 centuries apart.\" % (len(topDistantSims), topSimsToExamine))\n fourCenturiesApartOutput.append(\"---\")\n fourCenturiesApartOutput.extend(topDistantSims)\n\n utils.safeWrite(\"%swordUse/fourCenturiesApart.txt\" % baseFolder, \"\\n\".join(fourCenturiesApartOutput))\n\n # Comparison to English and Icelandic\n numGreek = len(authorSims)\n fracGreek = topSimsToExamine/numGreek\n numDistantGreek = len(topDistantSims)\n\n englishSims = utils.getContent(\"output/english/no_split/%s/jensen-shannon/metric/Authors/sims.txt\" % (topStr), False).split(\"\\n\")\n numEnglish = len(englishSims)\n topSimsEnglish = int(np.ceil(numEnglish*fracGreek))\n fracEnglish = topSimsEnglish/numEnglish\n numDistantEnglish = 0\n num2English = 0\n for sim in englishSims[:topSimsEnglish]:\n centuries_apart = int(sim.split(\"(\")[-1].split(\" \")[0])\n if (centuries_apart >= 2):\n num2English += 1\n if (centuries_apart >= 4):\n numDistantEnglish += 1\n\n iceSims = utils.getContent(\"output/icelandic/no_split/%s/jensen-shannon/metric/Authors/sims.txt\" % (topStr), False).split(\"\\n\")\n numIcelandic = len(iceSims)\n topSimsIcelandic = int(np.ceil(numIcelandic*fracGreek))\n fracIcelandic = topSimsIcelandic/numIcelandic\n numDistantIcelandic = 0\n for sim in iceSims[:topSimsIcelandic]:\n centuries_apart = int(sim.split(\"(\")[-1].split(\" \")[0])\n if (centuries_apart >= 4):\n numDistantIcelandic += 1\n\n comparisonOutput.append(\"\\n=========\\n\")\n comparisonOutput.append(\"Top similar pairs\")\n comparisonOutput.append(\"Greek:\")\n comparisonOutput.append(\" examining top %d of %d pairs (%.2f%%)\" % (topSimsToExamine, numGreek, 100*fracGreek))\n comparisonOutput.append(\" %d (%.2f%%) are at least 4 centuries apart\" % (numDistantGreek, 100*numDistantGreek/topSimsToExamine))\n comparisonOutput.append(\"English:\")\n comparisonOutput.append(\" examining top %d of %d pairs (%.2f%%)\" % (topSimsEnglish, numEnglish, 100*fracEnglish))\n comparisonOutput.append(\" %d (%.2f%%) are at least 4 centuries apart\" % (numDistantEnglish, 100*numDistantEnglish/topSimsEnglish))\n comparisonOutput.append(\" %d (%.2f%%) are at least 2 centuries apart\" % (num2English, 100*num2English/topSimsEnglish))\n comparisonOutput.append(\"Icelandic:\")\n comparisonOutput.append(\" examining top %d of %d pairs (%.2f%%)\" % (topSimsIcelandic, numIcelandic, 100*fracIcelandic))\n comparisonOutput.append(\" %d (%.2f%%) are at least 4 centuries apart\" % (numDistantIcelandic, 100*numDistantIcelandic/topSimsIcelandic))\n\n utils.safeWrite(\"%swordUse/fourApartComparisonInfo.txt\" % baseFolder, \"\\n\".join(comparisonOutput))\n\n # Table\n for simMetric in simMetrics:\n dir, name = simMetric\n # \"\" or \"+p\" depending on which is better\n metricSims = utils.getContent(\"output/greek/no_split/%s/%s/metric/Authors/sims.txt\" % (topStr, dir), False).split(\"\\n\")\n for i, sim in enumerate(metricSims):\n pairName = sim[11:]\n if pairName in topDistantAuthors:\n topDistantAuthors[pairName][dir] = i + 1\n\n # prepare values for coloring table cells\n maxVal = 0\n minVal = 1000000\n\n for authorPair in topDistantAuthors:\n for simDir, _ in simMetrics:\n val = topDistantAuthors[authorPair][simDir]\n minVal = min(minVal, val)\n maxVal = max(maxVal, val)\n\n pairRankOutput = []\n pairRankOutputSimple = []\n pairRankOutput.append(\"\"\"\n \\\\begin{table}[!bt]\n \\\\centering\n \\\\def\\\\arraystretch{1}\n \\\\begin{tabular}{| l | c | c | c | c | c | c |}\n \\\\hline\n & \\\\multicolumn{5}{c|}{\\\\textbf{Rank according to}} \\\\\\\\\n & \\\\textbf{Jensen-} & \\\\textbf{Burrows'} & & & & \\\\\\\\\n \\\\textbf{Authors} & \\\\textbf{Shannon} & \\\\textbf{Delta} & \\\\textbf{Min-Max} & \\\\textbf{Manhattan} & \\\\textbf{Canberra} & \\\\textbf{Cosine} \\\\\\\\\\\\hline\n \"\"\")\n pairRankOutputSimple.append(\"%s,%s,%s,%s,%s,%s,%s\" % (\"Authors\", \"Jensen-Shannon\", \"Burrow's Delta\", \"Min-Max\", \"Manhattan\", \"Canberra\", \"Cosine\"))\n authorConvert = {\n \"ApolloniusRhodius\": \"Apollonius\",\n \"DionysiusOfHalicarnassus\": \"Dionysius\",\n \"EusebiusOfCaesarea\": \"Eusebius\",\n \"ClementOfAlexandria\": \"Clement\",\n \"BasilBishopOfCaesarea\": \"Basil\",\n \"Anonymous(Hymns_Aphrodite)\": \"Hymns Aphrodite\",\n \"Anonymous(Hymns_Apollo)\": \"Hymns Apollo\",\n \"Anonymous(Hymns_Demeter)\": \"Hymns Demeter\",\n \"Anonymous(Hymns_Hermes)\": \"Hymns Hermes\",\n \"Anonymous(Hymns_Rest)\": \"Hymns Rest\",\n }\n for authorPair in topDistantAuthors:\n pair = \"(\".join(authorPair.split(\" (\")[:-1])\n pairSplit = pair.split(\", \")\n author1 = pairSplit[0]\n author2 = pairSplit[1]\n\n if author1 in authorConvert:\n author1 = authorConvert[author1]\n if author2 in authorConvert:\n author2 = authorConvert[author2]\n\n pairName = author1 + \", \" + author2\n cell = \"%s &\" % pairName\n cellSimple = \"%s,\" % re.sub(\", \", \"/\", pairName)\n firstVal = None\n for simDir, _ in simMetrics:\n val = topDistantAuthors[authorPair][simDir]\n\n cutoff = 100\n if (val < cutoff):\n r, g, b = colorConvert(minVal, cutoff, val, COLOR_ORANGE, COLOR_GRAY)\n else:\n r, g, b = colorConvert(cutoff, maxVal, val, COLOR_GRAY, COLOR_BLUE)\n cell += \"\\\\cellcolor[rgb]{%.3f,%.3f,%.3f} \" % (r, g, b)\n\n if (firstVal == None):\n firstVal = val\n cell += \"%d & \" % (val)\n cellSimple += \"%d,\" % (val)\n else:\n cell += \"%d (%+d) & \" % (val, firstVal - val)\n rel = \"(%d)\" % (firstVal - val)\n cellSimple += \"%d %s,\" % (val, rel)\n cell = cell[:-2]\n pairRankOutput.append(\"%s\\\\\\\\\\\\hline\" % cell)\n pairRankOutputSimple.append(cellSimple)\n pairRankOutput.append(\"\"\"\n \\\\end{tabular}\n \\\\caption{Rank of these pair's similarity by different metrics.}\n \\\\label{table:pair_rank}\n \\\\end{table}\n \"\"\")\n\n utils.safeWrite(\"%swordUse/pairRankTable.tex\" % baseFolder, \"\\n\".join(pairRankOutput))\n utils.safeWrite(\"%swordUse/pairRankTableSimple.csv\" % baseFolder, \"\\n\".join(pairRankOutputSimple))\n\n\n# Get info on number of words used and create the table of top words\ndef getWordUseInfo(topStr, baseFolder):\n # total +p words\n tops = utils.getContent(\"output/greek/no_split/%s/wordInfo_%s.txt\" % (topStr, topStr), False).split(\"\\n\")[1:]\n poetrys = utils.getContent(\"output/greek/no_split/top_p/wordInfo_top_p.txt\", False).split(\"\\n\")[1:]\n # Top plus poetry\n totals = utils.getContent(\"output/greek/no_split/%s+p/wordInfo_%s+p.txt\" % (topStr, topStr), False).split(\"\\n\")[1:]\n\n numWordsOutput = []\n numWordsOutput.append(\"Number of Top Words: %d\" % len(tops))\n numWordsOutput.append(\"Number of Poetry Words: %d\" % len(poetrys))\n numWordsOutput.append(\"Total Number of Words: %d\" % len(totals))\n utils.safeWrite(\"%s/wordUse/totalWords.txt\" % baseFolder, \"\\n\".join(numWordsOutput))\n\n\n # Create Table of words\n topRanks = {}\n poetryRanks = {}\n\n for i, line in enumerate(tops):\n w = line.split(\":\")[0]\n topRanks[w] = i + 1\n\n for i, line in enumerate(poetrys):\n w = line.split(\":\")[0]\n poetryRanks[w] = i + 1\n\n rankInfo = []\n for line in totals:\n w = line.split(\":\")[0]\n topRank = \"\"\n if w in topRanks:\n topRank = \"%d\" % topRanks[w]\n poetryRank = \"\"\n if w in poetryRanks:\n poetryRank = \"%d\" % poetryRanks[w]\n\n rankInfo.append((w, topRank, poetryRank))\n\n\n rankTableOutput = []\n rankTableOutput.append(\"\"\"\n \\\\begin{table}[!hbt]\n \\\\centering\n \\\\def\\\\arraystretch{1}\n \\\\begin{tabular}{| l | l | l ||| l | l | l ||| l | l | l ||| l | l | l |}\n \\\\hline\n\n \\\\textbf{Token} & \\\\textbf{A} & \\\\textbf{P} & \\\\textbf{Token} & \\\\textbf{A} & \\\\textbf{P} & \\\\textbf{Token} & \\\\textbf{A} & \\\\textbf{P} & \\\\textbf{Token} & \\\\textbf{A} & \\\\textbf{P}\\\\\\\\\\\\hline\n \"\"\")\n\n\n columnHeight = 43;\n for i in range(columnHeight):\n cells = []\n for j in range(4):\n index = i + j*columnHeight\n cell = \"\"\n if (index < len(rankInfo)):\n cell = \"%s & %s & %s\" % rankInfo[index]\n\n cells.append(cell)\n rankTableOutput.append(\"%s \\\\\\\\\\\\hline\" % (\" & \".join(cells)))\n\n rankTableOutput.append(\"\"\"\n \\\\end{tabular}\n \\\\caption{List of tokens used, along with their rank in the top 150 tokens found in all texts (\\\\textbf{A}) and rank in the top 100 tokens found in poetry texts (\\\\textbf{P}).}\n \\\\label{table:top_words}\n \\\\end{table}\n \"\"\")\n\n utils.safeWrite(\"%swordUse/topWordsTable.tex\" % baseFolder, \"\\n\".join(rankTableOutput))\n\n\n# Get author and book counts for our languages for the data section\ndef getAuthorBookCounts(baseFolder):\n ab_counts_output = []\n splitter = \"\\n------\\n\"\n\n ab_counts_output.append(\"Greek:\\n\")\n ab_counts_output.append(utils.getContent(\"output/greek/numberOfAuthors_Books.txt\", False))\n ab_counts_output.append(utils.getContent(\"output/greek/numberOfTypes_Tokens.txt\", False))\n ab_counts_output.append(splitter)\n ab_counts_output.append(\"English:\\n\")\n ab_counts_output.append(utils.getContent(\"output/english/numberOfAuthors_Books.txt\", False))\n ab_counts_output.append(utils.getContent(\"output/english/numberOfTypes_Tokens.txt\", False))\n ab_counts_output.append(splitter)\n ab_counts_output.append(\"Icelandic:\\n\")\n ab_counts_output.append(utils.getContent(\"output/icelandic/numberOfAuthors_Books.txt\", False))\n ab_counts_output.append(utils.getContent(\"output/icelandic/numberOfTypes_Tokens.txt\", False))\n ab_counts_output.append(splitter)\n\n utils.safeWrite(\"%s/AuthorBookNumbers.txt\" % baseFolder, \"\\n\".join(ab_counts_output))\n\n# Get word overlap info\ndef getOverlapInfo(baseFolder):\n output = []\n splitter = \"\\n------\\n\"\n\n output.append(\"Greek:\\n\")\n output.append(utils.getContent(\"output/greek/topWordOverlapOverTime.txt\", False))\n output.append(splitter)\n output.append(\"English:\\n\")\n output.append(utils.getContent(\"output/english/topWordOverlapOverTime.txt\", False))\n output.append(splitter)\n output.append(\"Icelandic:\\n\")\n output.append(utils.getContent(\"output/icelandic/topWordOverlapOverTime.txt\", False))\n output.append(splitter)\n\n utils.safeWrite(\"%s/topWordOverlapOverTime.txt\" % baseFolder, \"\\n\".join(output))\n\n# Get information about words that were skipped\ndef getSkippedWordInfo(baseFolder):\n output = []\n splitter = \"\\n------\\n\"\n\n output.append(\"Greek:\\n\")\n output.append(utils.getContent(\"output/greek/no_split/top250/chosenWordInfo.txt\", False))\n output.append(\"\\nPoetry:\")\n output.append(utils.getContent(\"output/greek/no_split/top250+p/chosenWordInfoPoetry.txt\", False))\n output.append(splitter)\n output.append(\"English:\\n\")\n output.append(utils.getContent(\"output/english/no_split/top250/chosenWordInfo.txt\", False))\n output.append(\"\\nPoetry:\")\n output.append(utils.getContent(\"output/english/no_split/top250+p/chosenWordInfoPoetry.txt\", False))\n output.append(splitter)\n output.append(\"Icelandic:\\n\")\n output.append(utils.getContent(\"output/icelandic/no_split/top250/chosenWordInfo.txt\", False))\n output.append(splitter)\n\n utils.safeWrite(\"%s/skippedWords.txt\" % baseFolder, \"\\n\".join(output))\n\ndef getDataInfo(topStr, baseFolder):\n baseFolder = baseFolder + \"/data\"\n\n getAuthorBookCounts(baseFolder)\n\n getOverlapInfo(baseFolder)\n\n getSkippedWordInfo(baseFolder)\n\n subprocess.run(\"cp output/greek/no_split/%s/wordsTable.csv %s/wordsTableGreek_%s.csv\" % (topStr, baseFolder, topStr), shell=True)\n subprocess.run(\"cp output/english/no_split/%s/wordsTable.csv %s/wordsTableEnglish_%s.csv\" % (topStr, baseFolder, topStr), shell=True)\n subprocess.run(\"cp output/icelandic/no_split/%s/wordsTable.csv %s/wordsTableIcelandic_%s.csv\" % (topStr, baseFolder, topStr), shell=True)\n\n# Get information on the top authors\ndef makeTopAuthorTable(topStr, baseFolder):\n # Grab this from the best metric\n fname = \"output/greek/no_split/%s/jensen-shannon/metric/Authors/sims.txt\" % (topStr)\n allAuthorSims = utils.getContent(fname, False).split(\"\\n\")\n\n topAuthorPairs = []\n\n topAuthorPairs.append(\"\"\"\\\\begin{table}[!bt]\n \\\\centering\n \\\\def\\\\arraystretch{1.2}\n \\\\begin{tabular}{| r | l | l | l | l |} \\\\hline\n & \\\\textbf{Author 1} & \\\\textbf{Author 2} & \\\\textbf{Score} & \\\\textbf{Notes} \\\\\\\\\\\\hline\n\"\"\")\n\n\n for i, pair in enumerate(allAuthorSims[:10]):\n splt1 = pair.split(\" - \")\n sim = splt1[0]\n auths = splt1[1].split(\" (\")[0].split(\", \")\n topAuthorPairs.append(\" %.2d & %s & %s & %s & TODO \\\\\\\\\\\\hline\" % (i+1, auths[0], auths[1], sim))\n\n topAuthorPairs.append(\"\"\"\n \\\\end{tabular}\n \\\\caption{Top author pairs by similarity score according to Jensen-Shannon Similarity.}\n \\\\label{table:top_author_pairs}\n\\\\end{table}\n \"\"\")\n\n utils.safeWrite(\"%smetric/topAuthorPairs.tex\" % baseFolder, \"\\n\".join(topAuthorPairs))\n\n\n\n# create tables showing performance of light machine learning algorithms on predicting various categories\ndef makeMLTable(source, norm, filename):\n output = []\n\n output.append(\"\"\"\\\\begin{table}[!bt]\n \\\\centering\n \\\\def\\\\arraystretch{1.2}\n\"\"\")\n\n # No naive bayes if normed due to negative data\n if norm:\n output.append(\" \\\\begin{tabular}{| r | l | l |} \\\\hline\")\n output.append(\" \\\\textbf{Prediction Task} & \\\\textbf{Majority Class} & \\\\textbf{KNN} \\\\\\\\\\\\hline\")\n else:\n output.append(\" \\\\begin{tabular}{| r | l | l | l |} \\\\hline\")\n output.append(\" \\\\textbf{Prediction Task} & \\\\textbf{Majority Class} & \\\\textbf{KNN} & \\\\textbf{Naive Bayes} \\\\\\\\\\\\hline\")\n\n\n for t in [\"Authors\", \"Books\", \"Books_2\"]:\n cats = [\"genre\", \"dialect\", \"timeframe\"]\n if (t == \"Books\"):\n cats.append(\"author\")\n if (t == \"Books_2\"):\n cats = [\"work\", \"genre\", \"dialect\", \"timeframe\", \"author\"]\n\n for cat in cats:\n fname = source + \"res_%s_%s.txt\" % (cat, t)\n lines = utils.getContent(fname, False).split(\"\\n\")\n maj_class = lines[1].split(\" - \")[0].strip()\n knn = lines[2].split(\" - \")[0].strip()\n naive_bayes = lines[3].split(\" - \")[0].strip()\n\n t_name = t\n if t_name == \"Books\":\n t_name = \"Segments\"\n if t_name == \"Books_2\":\n t_name = \"Segments*\"\n if norm:\n output.append(\" %s of %s & %s & %s \\\\\\\\\\\\hline\" % (cat, t_name, maj_class, knn))\n else:\n output.append(\" %s of %s & %s & %s & %s \\\\\\\\\\\\hline\" % (cat, t_name, maj_class, knn, naive_bayes))\n\n output.append(\"\"\"\n \\\\end{tabular}\n \\\\caption{Results of running simple machine learning on the frequency data.}\n \\\\label{table:ml+p}\n\\\\end{table}\n \"\"\")\n\n utils.safeWrite(filename, \"\\n\".join(output))\n\n# =============================================================================\n# =============================================================================\n\n# Get information on genre\ndef getGenreInfo(topStr, baseFolder):\n # 2-dimensional tSNE projection\n subprocess.run(\"cp output/greek/no_split/%s/authors/tSNE/genre_tSNE_2D_no_labels.pdf %sgenre/tSNE_topWords_nolabels.pdf\" % (topStr, baseFolder), shell=True)\n subprocess.run(\"cp output/greek/no_split/%s/authors/tSNE/genre_tSNE_2D_labels.pdf %sgenre/tSNE_topWords_labels.pdf\" % (topStr, baseFolder), shell=True)\n\n\n# Get information on the metrics\ndef getMetricInfo(topStr, comparableTopStr, topNum, poetryNum, comparableNum, simMetrics, baseFolder):\n # Copy full eval files for jensen-shannon\n subprocess.run(\"cp output/greek/no_split/%s/jensen-shannon/metric/Books/comparisonInfo.txt %smetric/extraInfo/metricEvaluation_tops.txt\" % (topStr, baseFolder), shell=True)\n subprocess.run(\"cp output/greek/no_split/%s+p/jensen-shannon/metric/Books/comparisonInfo.txt %smetric/extraInfo/metricEvaluation_+p.txt\" % (topStr, baseFolder), shell=True)\n\n # Grab median distance\n fname = \"output/greek/no_split/%s/jensen-shannon/metric/Books/comparisonInfo.txt\" % (topStr)\n metricEvalInfo = utils.getContent(fname, False).split(\"=========\")[-2].split(\"\\n\")[2:-1]\n sameAuthorRanks = []\n for i, line in enumerate(metricEvalInfo):\n sameAuthorRank = line.split(\"with same author: \")[1].split(\".\")[0]\n sameAuthorRanks.append(int(sameAuthorRank))\n\n median = np.median(sameAuthorRanks)\n\n utils.safeWrite(\"%smetric/extraInfo/medianForDifferentAuthor.txt\" % (baseFolder), \"Median distance for closest author: %f\" % median)\n\n # get info on the indica\n subprocess.run(\"cp output/greek/no_split/%s/jensen-shannon/metric/Books/sims/Arrian.Indica.1.txt %smetric/extraInfo/arrianIndica.txt\" % (topStr, baseFolder), shell=True)\n\n\n # Info on book distance\n # Grab this from the best metric\n fname = \"output/greek/no_split/%s/jensen-shannon/metric/Books/sims.txt\" % (topStr)\n allBookSims = utils.getContent(fname, False).split(\"\\n\")\n\n utils.safeWrite(\"%smetric/lowestSimilarity.txt\" % (baseFolder), \"Lowest similarity between segments: %s\" % allBookSims[-1])\n\n # Info on top similar authors\n makeTopAuthorTable(topStr, baseFolder)\n\n # ===============================\n\n\n makeMetricEvalTables(\"\", topStr, comparableTopStr, topNum, poetryNum, comparableNum, simMetrics, baseFolder)\n\n # baseScoreMetric = \"Burrows' Delta\"\n # baseScoreIndex = 1\n # makeMetricEvalTables(\"_cmp_burrows\", topStr, comparableTopStr, topNum, poetryNum, comparableNum, simMetrics, baseScoreMetric, baseScoreIndex)\n\n# Get information comparing various texts across centuries\ndef getCenturyInfo(topStr, baseFolder):\n subprocess.run(\"cp output/greek/no_split/%s/jensen-shannon/metric/Authors/century_sims_overall_no_labels.pdf %scentury/centuriesGreek.pdf\" % (topStr, baseFolder), shell=True)\n subprocess.run(\"cp output/greek/no_split/%s/jensen-shannon/metric/Authors/century_sims_overall_labels.pdf %scentury/extraInfo/Greek_CenturyOverall_Label.pdf\" % (topStr, baseFolder), shell=True)\n\n subprocess.run(\"cp output/greek/no_split/%s/jensen-shannon/metric/Authors/simRange.txt %scentury/extraInfo/Greek_SimRange.txt\" % (topStr, baseFolder), shell=True)\n\n\n # -------------------------\n # Century similarity data\n subprocess.run(\"cp output/greek/no_split/%s/jensen-shannon/metric/Authors/century_sims_genre_no_labels.pdf %scentury/extraInfo/Greek_Century_No_Label.pdf\" % (topStr, baseFolder), shell=True)\n subprocess.run(\"cp output/greek/no_split/%s/jensen-shannon/metric/Authors/century_sims_genre_labels.pdf %scentury/extraInfo/Greek_Century_Label.pdf\" % (topStr, baseFolder), shell=True)\n subprocess.run(\"cp output/greek/no_split/%s+p/jensen-shannon/metric/Authors/century_sims_genre_no_labels.pdf %scentury/extraInfo/Greek+p_Century_No_Label.pdf\" % (topStr, baseFolder), shell=True)\n subprocess.run(\"cp output/greek/no_split/%s+p/jensen-shannon/metric/Authors/century_sims_genre_labels.pdf %scentury/extraInfo/Greek+p_Century_Label.pdf\" % (topStr, baseFolder), shell=True)\n\n subprocess.run(\"cp output/greek/no_split/%s/jensen-shannon/metric/Authors/century_sims_genre_under_9_no_labels.pdf %scentury/extraInfo/Greek_Century_Cutoff_No_Label.pdf\" % (topStr, baseFolder), shell=True)\n subprocess.run(\"cp output/greek/no_split/%s/jensen-shannon/metric/Authors/century_sims_genre_under_9_labels.pdf %scentury/extraInfo/Greek_Century_Cutoff_Label.pdf\" % (topStr, baseFolder), shell=True)\n subprocess.run(\"cp output/greek/no_split/%s+p/jensen-shannon/metric/Authors/century_sims_genre_under_9_no_labels.pdf %scentury/extraInfo/Greek+p_Century_Cutoff_No_Label.pdf\" % (topStr, baseFolder), shell=True)\n subprocess.run(\"cp output/greek/no_split/%s+p/jensen-shannon/metric/Authors/century_sims_genre_under_9_labels.pdf %scentury/extraInfo/Greek+p_Century_Cutoff_Label.pdf\" % (topStr, baseFolder), shell=True)\n\n\n\n subprocess.run(\"cp output/greek/no_split/%s/jensen-shannon/metric/Authors/century_sims_genre_under_9_no_labels.pdf %scentury/centuriesGreek2.pdf\" % (topStr, baseFolder), shell=True)\n subprocess.run(\"cp output/greek/no_split/%s/jensen-shannon/metric/Authors/century_sims_genre_under_9_no_labels_violin.pdf %scentury/centuriesGreekViolin.pdf\" % (topStr, baseFolder), shell=True)\n\n\n subprocess.run(\"cp output/english/no_split/%s/jensen-shannon/metric/Authors/simRange.txt %scentury/extraInfo/English_SimRange.txt\" % (topStr, baseFolder), shell=True)\n subprocess.run(\"cp output/english/no_split/%s/jensen-shannon/metric/Authors/century_sims_genre_no_labels.pdf %scentury/centuriesEnglish.pdf\" % (topStr, baseFolder), shell=True)\n subprocess.run(\"cp output/english/no_split/%s/jensen-shannon/metric/Authors/century_sims_genre_no_labels_violin.pdf %scentury/centuriesEnglishViolin.pdf\" % (topStr, baseFolder), shell=True)\n subprocess.run(\"cp output/english/no_split/%s/jensen-shannon/metric/Authors/century_sims_genre_labels.pdf %scentury/extraInfo/English_Century_Label.pdf\" % (topStr, baseFolder), shell=True)\n\n subprocess.run(\"cp output/icelandic/no_split/%s/jensen-shannon/metric/Authors/simRange.txt %scentury/extraInfo/Icelandic_SimRange.txt\" % (topStr, baseFolder), shell=True)\n subprocess.run(\"cp output/icelandic/no_split/%s/jensen-shannon/metric/Authors/century_sims_genre_no_labels.pdf %scentury/centuriesIcelandic.pdf\" % (topStr, baseFolder), shell=True)\n subprocess.run(\"cp output/icelandic/no_split/%s/jensen-shannon/metric/Authors/century_sims_genre_no_labels_violin.pdf %scentury/centuriesIcelandicViolin.pdf\" % (topStr, baseFolder), shell=True)\n subprocess.run(\"cp output/icelandic/no_split/%s/jensen-shannon/metric/Authors/century_sims_genre_labels.pdf %scentury/extraInfo/Icelandic_Century_Label.pdf\" % (topStr, baseFolder), shell=True)\n\n\n # Get pvalue + other regression information for charts\n greekPval = utils.getContent(\"output/greek/no_split/%s/jensen-shannon/metric/Authors/century_sims_genre_under_9_pslope.txt\" % (topStr), False)\n englishPval = utils.getContent(\"output/english/no_split/%s/jensen-shannon/metric/Authors/century_sims_genre_pslope.txt\" % (topStr), False)\n icelandicPval = utils.getContent(\"output/icelandic/no_split/%s/jensen-shannon/metric/Authors/century_sims_genre_pslope.txt\" % (topStr), False)\n\n pvalOutput = []\n pvalOutput.append(\"Greek:\")\n pvalOutput.append(greekPval)\n pvalOutput.append(\"English:\")\n pvalOutput.append(englishPval)\n pvalOutput.append(\"Icelandic:\")\n pvalOutput.append(icelandicPval)\n\n utils.safeWrite(\"%scentury/century_pvals.txt\" % baseFolder, \"\\n\".join(pvalOutput))\n\n# Get charts on word usage across authors and by specific author pairs\ndef getWordUsageInfo(topStr, baseFolder):\n # Word usage charts\n # Grab these from the best metric\n subprocess.run(\"cp output/greek/no_split/%s/wordImportance/Jensen-shannon-sorted/ignoreBestWords.pdf %swordUse/ignoreBestWords.pdf\" % (topStr, baseFolder), shell=True)\n subprocess.run(\"cp output/greek/no_split/%s/wordImportance/Jensen-shannon-sorted/all-diffs-cumul-cloud.pdf %swordUse/extraInfo/broadWordUsage.pdf\" % (topStr, baseFolder), shell=True)\n subprocess.run(\"cp output/greek/no_split/%s/wordImportance/Jensen-shannon-sorted/all-diffs-cumul.pdf %swordUse/extraInfo/all-diffs-cumul.pdf\" % (topStr, baseFolder), shell=True)\n\n\n # Word organization charts\n subprocess.run(\"cp output/greek/no_split/%s/textsOnlyTopWords/9_group/tSNE/Word_Groupings_tSNE_2D_labels.pdf %swordUse/wordGroups.pdf\" % (topStr, baseFolder), shell=True)\n\n subprocess.run(\"cp output/greek/no_split/%s/textsOnlyTopWords/9_group/images/dhct.pdf %swordUse/eightUp_9Group.pdf\" % (topStr, baseFolder), shell=True)\n subprocess.run(\"cp output/greek/no_split/%s/textsOnlyTopWords/pos_group/images/dhct.pdf %swordUse/eightUp_posGroup.pdf\" % (topStr, baseFolder), shell=True)\n\n# create each of the folders in a list if they do not exist yet\ndef createFolders(folders, baseFolder):\n for folder in folders:\n if not(os.path.exists(baseFolder + folder)):\n subprocess.run(\"mkdir \" + baseFolder + folder, shell=True)\n\n# =============================================================================\n# =============================================================================\n# =============================================================================\n\n# List of similarity metrics\nSIM_METRICS = [\n (\"jensen-shannon\", \"Jensen-Shannon\"),\n (\"burrowsdelta\", \"Burrows' Delta\"),\n (\"minmax\", \"Min-Max\"),\n (\"cityblock\", \"Manhattan\"),\n (\"canberra\", \"Canberra\"),\n (\"cosine\", \"Cosine\"),\n]\n\n\n# Gather full set of files\ndef gatherFilesFull(topStr, topNum, comparableTopStr, comparableNum, poetryNum):\n baseFolder = \"output/full/\"\n\n\n folders = [\n \"\",\n \"data\",\n \"genre\",\n \"metric\",\n \"metric/extraInfo\",\n \"century\",\n \"century/extraInfo\",\n \"wordUse\",\n \"wordUse/extraInfo\",\n \"wordUse/grouping\",\n ]\n createFolders(folders, baseFolder)\n\n # Get info for the data section\n getDataInfo(topStr, baseFolder)\n\n # Get info for approach section\n getWordUseInfo(topStr, baseFolder)\n\n # Get genre info\n getGenreInfo(topStr, baseFolder)\n # Gather 4up tsne charts for standard data and data normalized by genre\n # Grab this from the best metric\n subprocess.run(\"cp output/greek/no_split/%s/Authors/tSNE/info_no_labels_4Up.pdf %sgenre/groupings.pdf\" % (topStr, baseFolder), shell=True)\n subprocess.run(\"cp output/greek/no_split/%s/Books/tSNE/outliers4up.pdf %sgenre/bookOutliers.pdf\" % (topStr, baseFolder), shell=True)\n\n # Get book tsne charts\n # Grab this from the best metric\n subprocess.run(\"cp output/greek/no_split/%s/Books/tSNE/tSNE_2D_no_labels.pdf %sgenre/books_tSNE_no_labels.pdf\" % (topStr, baseFolder), shell=True)\n subprocess.run(\"cp output/greek/no_split/%s/Books/tSNE/tSNE_2D_labels.pdf %sgenre/books_tSNE_labels.pdf\" % (topStr, baseFolder), shell=True)\n # To get a look at these, run python3 visualizeBooks\n\n\n # Get info for standard and normalized by poetry\n makeMLTable(\"output/greek/no_split/%s/dataPreds/\" % (topStr), False, \"%sgenre/ml_table.tex\" % baseFolder)\n # makeMLTable(\"output/greek/no_split/%s+p/dataPreds/\" % (topStr), False, \"%sgenre/ml_table+p.tex\" % baseFolder)\n\n # =========================\n\n # Get info for results section\n\n # -----------\n # Metric\n getMetricInfo(topStr, comparableTopStr, topNum, poetryNum, comparableNum, SIM_METRICS, baseFolder)\n\n makeMetricInternalTables(\"\", topStr, SIM_METRICS, baseFolder)\n makeMetricInternalTables(\"\", topStr + \"+p\", SIM_METRICS, baseFolder)\n\n # -----------\n # Century\n # Get information on century comparison\n getCenturyInfo(topStr, baseFolder)\n # Get pvalue + other regression information for charts that are + p\n greekPval = utils.getContent(\"output/greek/no_split/%s+p/jensen-shannon/metric/Authors/century_sims_genre_under_9_pslope.txt\" % (topStr), False)\n englishPval = utils.getContent(\"output/english/no_split/%s+p/jensen-shannon/metric/Authors/century_sims_genre_pslope.txt\" % (topStr), False)\n\n pvalOutput = []\n pvalOutput.append(\"Greek:\")\n pvalOutput.append(greekPval)\n pvalOutput.append(\"English:\")\n pvalOutput.append(englishPval)\n\n utils.safeWrite(\"%scentury/century_pvals+p.txt\" % baseFolder, \"\\n\".join(pvalOutput))\n\n # -------------------------\n # Grab this from the best metric\n subprocess.run(\"cp output/greek/no_split/%s/jensen-shannon/metric/Authors/sims.txt %swordUse/authorSims.txt\" % (topStr, baseFolder), shell=True)\n\n fourCenturiesTables(topStr, SIM_METRICS, baseFolder)\n\n # get word usage charts and info\n getWordUsageInfo(topStr, baseFolder)\n\n # We didn't end up using grouping charts\n # groups = getWordGroupsRangeTest(topNum)\n # for g in groups:\n # subprocess.run(\"cp output/greek/no_split/%s+p/textsOnlyTopWords/%d_group/images/groupingCompare.png %swordUse/grouping/%.2d.png\" % (topStr, g, baseFolder, g), shell=True)\n\nif __name__ == \"__main__\":\n #gatherFiles(mp.topStr, mp.topNum, mp.comparableTopStr, mp.comparableTopNum, mp.poetryNum)\n gatherFilesFull(mp.topStr, mp.topNum, mp.comparableTopStr, mp.comparableTopNum, mp.poetryNum)\n", "meta": {"hexsha": "04fd8e7527a72c7f92a3463375a4e45a93e5f6a0", "size": 46348, "ext": "py", "lang": "Python", "max_stars_repo_path": "gatherFiles.py", "max_stars_repo_name": "twopis/twopis", "max_stars_repo_head_hexsha": "1f89d44c3e8481bb2da8e20187b5eeb63b96092e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-10-11T00:08:11.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-11T00:08:11.000Z", "max_issues_repo_path": "gatherFiles.py", "max_issues_repo_name": "twopis/twopis", "max_issues_repo_head_hexsha": "1f89d44c3e8481bb2da8e20187b5eeb63b96092e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "gatherFiles.py", "max_forks_repo_name": "twopis/twopis", "max_forks_repo_head_hexsha": "1f89d44c3e8481bb2da8e20187b5eeb63b96092e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 45.7984189723, "max_line_length": 213, "alphanum_fraction": 0.6381073617, "include": true, "reason": "import numpy,import scipy", "num_tokens": 12516, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230156, "lm_q2_score": 0.3738758227716966, "lm_q1q2_score": 0.19277782022841533}} {"text": "from scipy.interpolate import interp1d\nimport os\nfrom astropy.io import fits\nimport astropy.units as u\nimport h5py\nimport numpy as np\nfrom astropy.constants import h, c\n\n__all__ = ['Spectrum1D', 'ObservationArchive', 'nirspec_pixel_wavelengths',\n 'Simulation']\n\nbg_path = os.path.join(os.path.dirname(__file__), os.pardir, 'data', 'etc',\n 'image_detector.fits')\n\nwl_path = os.path.join(os.path.dirname(__file__), os.pardir, 'data', 'etc',\n 'lineplot_wave_pix.fits')\n\noutputs_dir_path = os.path.join(os.path.dirname(__file__), os.pardir, 'data',\n 'outputs')\n\nJWST_aperture_area = 25 * u.m**2\n\n\ndef nirspec_pixel_wavelengths():\n return fits.getdata(wl_path)['WAVELENGTH'] * u.um\n\n\nclass Spectrum1D(object):\n def __init__(self, wavelength, flux, error=None, header=None, t_eff=None):\n self.wavelength = wavelength\n self.flux = flux\n self.error = error\n self.header = header\n self.t_eff = t_eff\n\n def plot(self, ax=None, **kwargs):\n import matplotlib.pyplot as plt\n if ax is None:\n ax = plt.gca()\n\n ax.plot(self.wavelength, self.flux, **kwargs)\n\n return ax\n\n @u.quantity_input(new_wavelengths=u.m)\n def interp_flux(self, new_wavelengths):\n f = interp1d(self.wavelength.value, self.flux, kind='linear',\n bounds_error=False, fill_value=0)\n interped_fluxes = f(new_wavelengths)\n\n if hasattr(self.flux, 'unit') and self.flux.unit is not None:\n return interped_fluxes * self.flux.unit\n return interped_fluxes\n\n def __add__(self, other_spectrum):\n\n if not hasattr(other_spectrum, 'wavelength'):\n raise NotImplementedError()\n\n interp_flux = (np.interp(other_spectrum.wavelength.value,\n self.wavelength.value, self.flux.value) *\n self.flux.unit)\n\n return Spectrum1D(other_spectrum.wavelength,\n interp_flux + other_spectrum.flux,\n header=self.header)\n\n def __rmul__(self, multiplier):\n if not np.isscalar(multiplier):\n raise NotImplementedError()\n\n return Spectrum1D(self.wavelength, multiplier * self.flux,\n header=self.header)\n\n def n_photons(self, wavelengths, exp_time, J):\n \"\"\"\n Estimate the number of photons received from a target with J magnitude\n ``J`` over exposure time ``exp_time``.\n\n Parameters\n ----------\n wavelengths : `~astropy.units.Quantity`\n Wavelengths to test\n exp_time : `~astropy.units.Quantity`\n Exposure time\n J : float\n J-band magnitude of the target\n\n Returns\n -------\n fluxes : `~numpy.ndarray`\n Counts that reach the telescope at each wavelength\n \"\"\"\n if not hasattr(self.flux, 'unit'):\n raise NotImplementedError(\"Flux must have units\")\n\n interped_fluxes = self.interp_flux(wavelengths)\n\n delta_lambda = np.nanmedian(np.diff(wavelengths))\n n_photons_template = (interped_fluxes * wavelengths / h / c *\n JWST_aperture_area * delta_lambda *\n exp_time).decompose().value\n\n relative_target_flux = 10**(0.4 * (float(self.header['J']) - J))\n\n return relative_target_flux * n_photons_template\n\n\nclass ObservationArchive(object):\n def __init__(self, fname, mode='r', outputs_dir=None):\n\n if outputs_dir is None:\n outputs_dir = outputs_dir_path\n\n self.path = os.path.join(outputs_dir, fname + '.hdf5')\n self.target_name = fname\n self.archive = None\n self.mode = mode\n\n def __enter__(self):\n self.archive = h5py.File(self.path, self.mode)\n\n planets = [i for i in list('bcdefgh') if i in self.archive]\n\n for planet in planets:\n simulations = []\n for iteration in self.archive[planet]:\n attrs = dict(self.archive[planet][iteration].attrs)\n simulations.append(Simulation(self.archive[planet][iteration],\n attrs=attrs,\n path=\"/{0}/{1}/\".format(planet,\n iteration)))\n setattr(self, planet, simulations)\n\n return self\n\n def __exit__(self, *args):\n self.archive.close()\n\n\nclass Simulation(object):\n def __init__(self, observation, attrs=None, path=None):\n self.observation = observation\n self.attrs = attrs\n self.path = path\n\n @property\n def times(self):\n return self.observation['times'][:]\n\n @property\n def areas(self):\n return self.observation['spotted_area'][:]\n\n @property\n def spitzer_var(self):\n return self.observation['spitzer_var'][:]\n\n @property\n def flares(self):\n return self.observation['flares'][:]\n\n @property\n def fluxes(self):\n return self.observation['fluxes'][:]\n\n @property\n def spectra(self):\n return self.observation['spectra'][:]\n\n @property\n def samples_depth(self):\n return self.observation['samples/depth'][:]\n\n @property\n def samples_t0(self):\n return self.observation['samples/t0'][:]\n\n @property\n def samples_amp(self):\n return self.observation['samples/amp'][:]\n\n @property\n def samples_log_S0(self):\n return self.observation['samples/log_S0'][:]\n\n @property\n def samples_log_omega0(self):\n return self.observation['samples/log_omega0'][:]\n\n\n @property\n def samples_median(self):\n samples = (self.samples_log_S0, self.samples_log_omega0,\n self.samples_amp, self.samples_depth, self.samples_t0)\n return np.array([np.median(s) for s in samples])\n\n def plot(self):\n wl = nirspec_pixel_wavelengths()\n\n fig, ax = plt.subplots(2, 5, figsize=(14, 6))\n ax[0, 0].plot(self.times, self.areas)\n ax[0, 0].set(xlabel='Time', ylabel='Spotted area')\n\n ax[0, 1].plot(self.times, self.fluxes)\n ax[0, 1].set(xlabel='Time', ylabel='Stellar flux')\n\n monochromatic_flares = np.sum(self.flares, axis=1)\n monochromatic_flares /= np.median(monochromatic_flares)\n ax[0, 2].plot(self.times, monochromatic_flares)\n ax[0, 2].set(xlabel='Time', ylabel='Flare flux')\n\n ax[0, 3].plot(self.times, self.spitzer_var)\n ax[0, 3].set(xlabel='Time', ylabel='Spitzer var.')\n\n ax[0, 4].plot(self.times, self.transit)\n ax[0, 4].set(xlabel='Time', ylabel='Transit')\n\n ax[1, 0].imshow(self.spectra, extent=[0.6, 5.3, 0, self.times.ptp()])\n ax[1, 0].set(title='Spectrophotometry', aspect=3/(self.times.ptp()),\n xlabel='Wavelength [$\\mu$m]', ylabel='Time [d]')\n\n short_bin = np.sum(self.spectra[:, :100], axis=1)\n mid_bin = np.sum(self.spectra[:, 100:200], axis=1)\n long_bin = np.sum(self.spectra[:, 200:], axis=1)\n ax[1, 1].plot(self.times, long_bin/long_bin.max(), ',', color='C0',\n label=r'{0:.2f}-{1:.2f} $\\mu$m'\n .format(wl[0].value, wl[100].value))\n ax[1, 2].plot(self.times, mid_bin/mid_bin.max(), ',', color='C2',\n label=r'{0:.2f}-{1:.2f} $\\mu$m'\n .format(wl[100].value, wl[200].value))\n ax[1, 3].plot(self.times, short_bin/short_bin.max(), ',', color='r',\n label=r'{0:.2f}-{1:.2f} $\\mu$m'\n .format(wl[200].value, wl[-1].value))\n\n ax[1, 4].plot(self.times, np.sum(self.spectra, axis=1), ',')\n ax[1, 4].set(xlabel='Time', ylabel='NIRSpec counts',\n title='Band-integrated')\n\n for axis in [ax[1, 1], ax[1, 2], ax[1, 3]]:\n axis.get_shared_y_axes().join(axis, ax[1, 1])\n axis.legend()\n axis.set_xlabel('Time')\n axis.set_ylabel('Flux')\n\n fig.tight_layout()\n\n return fig, ax", "meta": {"hexsha": "6adbbd1f41e4f1f1c82268f5a25e9262b22dc991", "size": 8148, "ext": "py", "lang": "Python", "max_stars_repo_path": "libra/spectra/spectrum.py", "max_stars_repo_name": "jlustigy/libra", "max_stars_repo_head_hexsha": "ed260e95394f79f9b2aba3287689addc886f6972", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "libra/spectra/spectrum.py", "max_issues_repo_name": "jlustigy/libra", "max_issues_repo_head_hexsha": "ed260e95394f79f9b2aba3287689addc886f6972", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "libra/spectra/spectrum.py", "max_forks_repo_name": "jlustigy/libra", "max_forks_repo_head_hexsha": "ed260e95394f79f9b2aba3287689addc886f6972", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.8548387097, "max_line_length": 82, "alphanum_fraction": 0.5751104566, "include": true, "reason": "import numpy,from scipy,import astropy,from astropy", "num_tokens": 2004, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6477982179521103, "lm_q2_score": 0.29746994883293104, "lm_q1q2_score": 0.19270050274827819}} {"text": "# -*- coding: utf-8 -*-\n\"\"\"\nAdobe Wide Gamut RGB Colourspace\n================================\n\nDefines the *Adobe Wide Gamut RGB* colourspace:\n\n- :attr:`colour.models.RGB_COLOURSPACE_ADOBE_WIDE_GAMUT_RGB`.\n\nReferences\n----------\n- :cite:`Wikipedia2004c` : Wikipedia. (2004). Wide-gamut RGB color space.\n Retrieved April 13, 2014, from\n http://en.wikipedia.org/wiki/Wide-gamut_RGB_color_space\n\"\"\"\n\nimport numpy as np\nfrom functools import partial\n\nfrom colour.colorimetry import CCS_ILLUMINANTS\nfrom colour.models.rgb import (\n RGB_Colourspace,\n gamma_function,\n normalised_primary_matrix,\n)\n\n__author__ = 'Colour Developers'\n__copyright__ = 'Copyright (C) 2013-2021 - Colour Developers'\n__license__ = 'New BSD License - https://opensource.org/licenses/BSD-3-Clause'\n__maintainer__ = 'Colour Developers'\n__email__ = 'colour-developers@colour-science.org'\n__status__ = 'Production'\n\n__all__ = [\n 'PRIMARIES_ADOBE_WIDE_GAMUT_RGB',\n 'WHITEPOINT_NAME_ADOBE_WIDE_GAMUT_RGB',\n 'CCS_WHITEPOINT_ADOBE_WIDE_GAMUT_RGB',\n 'MATRIX_ADOBE_WIDE_GAMUT_RGB_TO_XYZ',\n 'MATRIX_XYZ_TO_ADOBE_WIDE_GAMUT_RGB',\n 'RGB_COLOURSPACE_ADOBE_WIDE_GAMUT_RGB',\n]\n\nPRIMARIES_ADOBE_WIDE_GAMUT_RGB = np.array([\n [0.7347, 0.2653],\n [0.1152, 0.8264],\n [0.1566, 0.0177],\n])\n\"\"\"\n*Adobe Wide Gamut RGB* colourspace primaries.\n\nPRIMARIES_ADOBE_WIDE_GAMUT_RGB : ndarray, (3, 2)\n\"\"\"\n\nWHITEPOINT_NAME_ADOBE_WIDE_GAMUT_RGB = 'D50'\n\"\"\"\n*Adobe Wide Gamut RGB* colourspace whitepoint name.\n\nWHITEPOINT_NAME_ADOBE_WIDE_GAMUT_RGB : str\n\"\"\"\n\nCCS_WHITEPOINT_ADOBE_WIDE_GAMUT_RGB = (\n CCS_ILLUMINANTS['CIE 1931 2 Degree Standard Observer'][\n WHITEPOINT_NAME_ADOBE_WIDE_GAMUT_RGB])\n\"\"\"\n*Adobe Wide Gamut RGB* colourspace whitepoint chromaticity coordinates.\n\nCCS_WHITEPOINT_ADOBE_WIDE_GAMUT_RGB : ndarray\n\"\"\"\n\nMATRIX_ADOBE_WIDE_GAMUT_RGB_TO_XYZ = normalised_primary_matrix(\n PRIMARIES_ADOBE_WIDE_GAMUT_RGB, CCS_WHITEPOINT_ADOBE_WIDE_GAMUT_RGB)\n\"\"\"\n*Adobe Wide Gamut RGB* colourspace to *CIE XYZ* tristimulus values matrix.\n\nMATRIX_ADOBE_WIDE_GAMUT_RGB_TO_XYZ : array_like, (3, 3)\n\"\"\"\n\nMATRIX_XYZ_TO_ADOBE_WIDE_GAMUT_RGB = np.linalg.inv(\n MATRIX_ADOBE_WIDE_GAMUT_RGB_TO_XYZ)\n\"\"\"\n*CIE XYZ* tristimulus values to *Adobe Wide Gamut RGB* colourspace matrix.\n\nMATRIX_XYZ_TO_ADOBE_WIDE_GAMUT_RGB : array_like, (3, 3)\n\"\"\"\n\nRGB_COLOURSPACE_ADOBE_WIDE_GAMUT_RGB = RGB_Colourspace(\n 'Adobe Wide Gamut RGB',\n PRIMARIES_ADOBE_WIDE_GAMUT_RGB,\n CCS_WHITEPOINT_ADOBE_WIDE_GAMUT_RGB,\n WHITEPOINT_NAME_ADOBE_WIDE_GAMUT_RGB,\n MATRIX_ADOBE_WIDE_GAMUT_RGB_TO_XYZ,\n MATRIX_XYZ_TO_ADOBE_WIDE_GAMUT_RGB,\n partial(gamma_function, exponent=1 / (563 / 256)),\n partial(gamma_function, exponent=563 / 256),\n)\nRGB_COLOURSPACE_ADOBE_WIDE_GAMUT_RGB.__doc__ = \"\"\"\n*Adobe Wide Gamut RGB* colourspace.\n\nReferences\n----------\n:cite:`Wikipedia2004c`\n\nRGB_COLOURSPACE_ADOBE_WIDE_GAMUT_RGB : RGB_Colourspace\n\"\"\"\n", "meta": {"hexsha": "7304ccdb71326949e74b5810383605443565c183", "size": 2904, "ext": "py", "lang": "Python", "max_stars_repo_path": "colour/models/rgb/datasets/adobe_wide_gamut_rgb.py", "max_stars_repo_name": "JGoldstone/colour", "max_stars_repo_head_hexsha": "6829b363d5f0682bff0f4826995e7ceac189ff28", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "colour/models/rgb/datasets/adobe_wide_gamut_rgb.py", "max_issues_repo_name": "JGoldstone/colour", "max_issues_repo_head_hexsha": "6829b363d5f0682bff0f4826995e7ceac189ff28", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "colour/models/rgb/datasets/adobe_wide_gamut_rgb.py", "max_forks_repo_name": "JGoldstone/colour", "max_forks_repo_head_hexsha": "6829b363d5f0682bff0f4826995e7ceac189ff28", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.6571428571, "max_line_length": 78, "alphanum_fraction": 0.7620523416, "include": true, "reason": "import numpy", "num_tokens": 923, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.6477982179521103, "lm_q2_score": 0.2974699363766585, "lm_q1q2_score": 0.192700494679127}} {"text": "# -*- coding: utf-8 -*-\n\nfrom __future__ import division, print_function\n\n__all__ = [\"Vetter\"]\n\nimport os\nimport h5py\nimport transit\nimport numpy as np\nfrom scipy.optimize import minimize\nfrom scipy.signal import lombscargle\n\nfrom .pipeline import Pipeline\n\n\ndef _nll_transit(p, system, lcs):\n system.set_vector(p)\n\n ll = 0.0\n for lc in lcs:\n mod = 1e3*(system.light_curve(lc.time, texp=lc.texp)-1.0)\n r = mod - lc.flux\n ll += lc.lnlike_eval(r)\n return -ll\n\n\ndef _nll_and_grad_transit(p, system, lcs):\n system.set_vector(p)\n\n ll = 0.0\n ll_grad = np.zeros_like(p)\n for lc in lcs:\n mod, grad = system.light_curve_gradient(lc.time, texp=lc.texp)\n r = 1e3 * (mod - 1.0) - lc.flux\n if np.any(~np.isfinite(r)):\n assert 0\n grad *= 1e3\n a, b = lc.grad_lnlike_eval(r, grad)\n ll += a\n ll_grad += b\n return -ll, ll_grad\n\n\ndef _ln_evidence_basic(lcs):\n ll = sum(lc.lnlike_eval(lc.flux) for lc in lcs)\n return ll, ll\n\n\ndef _ln_evidence_outlier(lcs, period, duration, t0):\n hp = 0.5 * period\n hd = 0.5 * duration\n\n lnlike = 0.0\n norm = 0.0\n depths = np.empty(len(lcs))\n ivars = np.empty(len(lcs))\n for i, lc in enumerate(lcs):\n r = lc.flux - lc.predict()\n m = np.fabs((lc.time - t0 + hp) % period - hp) < hd\n if not np.any(m):\n lnlike += lc.ll0\n continue\n tloc = lc.time[m][np.argmin(r[m])]\n\n def model(t):\n mod = np.zeros_like(t)\n mod[t == tloc] = -1.0\n return mod\n\n l0, depths[i], ivars[i] = lc.lnlike(model)\n lnlike += lc.ll0\n if ivars[i] > 0.0:\n lnlike += l0\n norm += 0.5 * (np.log(2*np.pi) - np.log(ivars[i]))\n\n return lnlike, lnlike + norm\n\n\ndef _ln_evidence_box0(lcs, period, duration, t0):\n def model(t, hp=0.5*period, hd=0.5*duration):\n mod = np.zeros_like(t)\n mod[np.fabs((t - t0 + hp) % period - hp) < hd] = -1.0\n return mod\n\n # Compute the evidence.\n lnlike = 0.0\n depths = np.empty(len(lcs))\n ivars = np.empty(len(lcs))\n for i, lc in enumerate(lcs):\n l0, depths[i], ivars[i] = lc.lnlike(model)\n lnlike += lc.ll0\n if ivars[i] > 0.0:\n lnlike += l0\n\n m = ivars > 0.0\n depths = depths[m]\n ivars = ivars[m]\n\n depth = np.sum(ivars * depths) / np.sum(ivars)\n ivar = np.sum(ivars)\n\n lnlike -= 0.5 * np.sum(depths**2 * ivars)\n lnlike += 0.5 * depth**2 * ivar\n lnlike += 0.5 * np.sum(np.log(ivars)) - 0.5*len(depths)*np.log(2*np.pi)\n\n return lnlike, lnlike - 0.5 * np.log(ivar) + 0.5 * np.log(2*np.pi)\n\n\ndef _ln_evidence_box(lcs, period, duration, t0, eps=1.123e-2):\n lnlike, f0 = _ln_evidence_box0(lcs, period, duration, t0)\n lnd2fdx2 = 0.0\n\n _, fp = _ln_evidence_box0(lcs, period + eps, duration, t0)\n _, fm = _ln_evidence_box0(lcs, period - eps, duration, t0)\n lnd2fdx2 += np.log(2*f0 - fp - fm) - 2 * np.log(eps) - np.log(2*np.pi)\n\n _, fp = _ln_evidence_box0(lcs, period, duration + eps, t0)\n _, fm = _ln_evidence_box0(lcs, period, duration - eps, t0)\n lnd2fdx2 += np.log(2*f0 - fp - fm) - 2 * np.log(eps) - np.log(2*np.pi)\n\n _, fp = _ln_evidence_box0(lcs, period, duration, t0 + eps)\n _, fm = _ln_evidence_box0(lcs, period, duration, t0 - eps)\n lnd2fdx2 += np.log(2*f0 - fp - fm) - 2 * np.log(eps) - np.log(2*np.pi)\n\n if not np.isfinite(lnd2fdx2):\n return lnlike, f0\n\n return lnlike, f0 - 0.5 * lnd2fdx2\n\n\ndef _ln_evidence_vee0(lcs, period, duration, t0):\n def model(t, hp=0.5*period, hd=0.5*duration):\n mod = np.zeros_like(t)\n dt = (t - t0 + hp) % period - hp\n m = np.fabs(dt) < hd\n mod[m] = np.abs(dt[m]) / hd - 1.0\n return mod\n\n # Compute the evidence.\n lnlike = 0.0\n depths = np.empty(len(lcs))\n ivars = np.empty(len(lcs))\n for i, lc in enumerate(lcs):\n l0, depths[i], ivars[i] = lc.lnlike(model)\n lnlike += lc.ll0\n if ivars[i] > 0.0:\n lnlike += l0\n\n m = ivars > 0.0\n depths = depths[m]\n ivars = ivars[m]\n\n depth = np.sum(ivars * depths) / np.sum(ivars)\n ivar = np.sum(ivars)\n\n lnlike -= 0.5 * np.sum(depths**2 * ivars)\n lnlike += 0.5 * depth**2 * ivar\n lnlike += 0.5 * np.sum(np.log(ivars)) - 0.5*len(depths)*np.log(2*np.pi)\n\n return lnlike, lnlike - 0.5 * np.log(ivar) + 0.5 * np.log(2*np.pi)\n\n\ndef _ln_evidence_vee(lcs, period, duration, t0, eps=1.123e-2):\n lnlike, f0 = _ln_evidence_vee0(lcs, period, duration, t0)\n lnd2fdx2 = 0.0\n\n _, fp = _ln_evidence_vee0(lcs, period + eps, duration, t0)\n _, fm = _ln_evidence_vee0(lcs, period - eps, duration, t0)\n lnd2fdx2 += np.log(2*f0 - fp - fm) - 2 * np.log(eps) - np.log(2*np.pi)\n\n _, fp = _ln_evidence_vee0(lcs, period, duration + eps, t0)\n _, fm = _ln_evidence_vee0(lcs, period, duration - eps, t0)\n lnd2fdx2 += np.log(2*f0 - fp - fm) - 2 * np.log(eps) - np.log(2*np.pi)\n\n _, fp = _ln_evidence_vee0(lcs, period, duration, t0 + eps)\n _, fm = _ln_evidence_vee0(lcs, period, duration, t0 - eps)\n lnd2fdx2 += np.log(2*f0 - fp - fm) - 2 * np.log(eps) - np.log(2*np.pi)\n\n if not np.isfinite(lnd2fdx2):\n return lnlike, f0\n\n return lnlike, f0 - 0.5 * lnd2fdx2\n\n\ndef _ln_evidence_transit(p, *args):\n h = 1.1234e-3\n x0 = np.array(p)\n lnd2fdx2 = np.empty_like(x0)\n f0 = _nll_transit(x0, *args)\n for i in range(len(x0)):\n x0[i] += h\n fp = _nll_transit(x0, *args)\n x0[i] -= 2*h\n fm = _nll_transit(x0, *args)\n x0[i] += h\n d = fp - 2*f0 + fm\n if d <= 0.0:\n lnd2fdx2[i] = np.inf\n else:\n lnd2fdx2[i] = np.log(fp - 2*f0 + fm)\n lnd2fdx2 -= 2*np.log(h)\n lnZ = -f0 - 0.5 * np.sum(lnd2fdx2) + 0.5 * len(x0) * np.log(2*np.pi)\n return -f0, lnZ\n\n\ndef _ln_evidence_period(lcs):\n if not hasattr(lcs[0], \"detrend_flux\"):\n return -np.inf, -np.inf\n x = np.concatenate([lc.time for lc in lcs])\n y = np.concatenate([lc.detrend_flux for lc in lcs])\n ivar = np.concatenate([1./lc.detrend_ferr**2 for lc in lcs])\n delta = np.max(x) - np.min(x)\n f = 2*np.pi*np.arange(max(2./24., 10./delta), 1.0 / 0.025, 0.1 / delta)\n p = lombscargle(x, y, f)\n omega = f[np.argmax(p)]\n AT = np.vstack([np.sin(omega*x), np.cos(omega*x), np.ones(len(x))])\n A = AT.T\n cov = np.dot(AT, A * ivar[:, None])\n w = np.linalg.solve(cov, np.dot(AT, y * ivar))\n\n def model(t):\n A = np.vstack([np.sin(omega*t), np.cos(omega*t)]).T\n return np.dot(A, w[:2])\n\n # Compute the evidence.\n lnlike = 0.0\n depths = np.empty(len(lcs))\n ivars = np.empty(len(lcs))\n for i, lc in enumerate(lcs):\n l0, depths[i], ivars[i] = lc.lnlike(model)\n lnlike += lc.ll0\n if ivars[i] > 0.0:\n lnlike += l0\n\n m = ivars > 0.0\n depths = depths[m]\n ivars = ivars[m]\n\n depth = np.sum(ivars * depths) / np.sum(ivars)\n ivar = np.sum(ivars)\n\n lnlike -= 0.5 * np.sum(depths**2 * ivars)\n lnlike += 0.5 * depth**2 * ivar\n lnlike += 0.5 * np.sum(np.log(ivars)) - 0.5*len(depths)*np.log(2*np.pi)\n\n return (lnlike, lnlike - 0.5 * np.log(ivar) + 0.5 * np.log(2*np.pi),\n 2*np.pi/omega)\n\n\nclass Vetter(Pipeline):\n\n cache_ext = \".h5\"\n query_parameters = dict(\n t0_rng=(0.2, False),\n period_rng=(0.1, False),\n )\n\n def get_result(self, query, parent_response):\n # Get the results from the pipeline so far.\n peaks = parent_response.peaks\n lcs = parent_response.model_light_curves\n\n # Save the initial flux values.\n flux0 = [np.array(lc.flux) for lc in lcs]\n\n # Loop over the peaks and compute the evidence for each one.\n for peak in peaks:\n # Set up the Keplerian fit.\n system = transit.SimpleSystem(\n period=peak[\"period\"], t0=peak[\"t0\"],\n ror=np.sqrt(1e-3*peak[\"depth\"]),\n duration=peak[\"duration\"],\n impact=0.5,\n )\n\n # Fit the transit model.\n p0 = system.get_vector()\n ln_period_rng = np.log((\n peak[\"period\"] - query[\"period_rng\"],\n peak[\"period\"] + query[\"period_rng\"],\n ))\n t0_rng = (\n peak[\"t0\"] - query[\"t0_rng\"],\n peak[\"t0\"] + query[\"t0_rng\"],\n )\n bounds = [(None, None), ln_period_rng, t0_rng,\n (None, None), (None, None),\n (-10.0, 10.0), (-10.0, 10.0)]\n result = minimize(_nll_and_grad_transit, p0, method=\"L-BFGS-B\",\n jac=True,\n args=(system, lcs),\n bounds=bounds)\n system.set_vector(result.x)\n\n # Compute the transit evidence.\n x = result.x\n peak[\"transit_q1\"] = system.q1\n peak[\"transit_q2\"] = system.q2\n peak[\"transit_period\"] = system.period\n peak[\"transit_ror\"] = system.ror\n peak[\"transit_duration\"] = system.duration\n peak[\"transit_t0\"] = system.t0\n peak[\"transit_b\"] = system.impact\n peak[\"lnlike_transit\"], peak[\"lnZ_transit\"] = \\\n _ln_evidence_transit(x, system, lcs)\n\n # Compute the evidence for the competing models.\n peak[\"lnlike_none\"], peak[\"lnZ_none\"] = _ln_evidence_basic(lcs)\n peak[\"lnlike_box\"], peak[\"lnZ_box\"] = _ln_evidence_box(\n lcs, peak[\"transit_period\"], peak[\"transit_duration\"],\n peak[\"transit_t0\"])\n peak[\"lnlike_vee\"], peak[\"lnZ_vee\"] = _ln_evidence_vee(\n lcs, peak[\"transit_period\"], peak[\"transit_duration\"],\n peak[\"transit_t0\"])\n peak[\"lnlike_outlier\"], peak[\"lnZ_outlier\"] = _ln_evidence_outlier(\n lcs, peak[\"transit_period\"], peak[\"transit_duration\"],\n peak[\"transit_t0\"])\n\n peak[\"lnlike_period\"], peak[\"lnZ_period\"], peak[\"osc_period\"] = \\\n _ln_evidence_period(lcs)\n\n # Subtract the best fit transit model.\n for lc in lcs:\n mod = 1e3*(system.light_curve(lc.time, texp=lc.texp)-1.0)\n lc.flux -= mod\n\n # Return the fluxes to their original values.\n for lc, f in zip(lcs, flux0):\n lc.flux[:] = f[:]\n\n return dict(\n peaks=peaks,\n )\n\n def save_to_cache(self, fn, response):\n try:\n os.makedirs(os.path.dirname(fn))\n except os.error:\n pass\n\n # Parse the peaks into a structured array.\n peaks = response[\"peaks\"]\n if len(peaks):\n dtype = [(k, np.float64) for k in sorted(peaks[0].keys())]\n peaks = [tuple(peak[k] for k, _ in dtype) for peak in peaks]\n peaks = np.array(peaks, dtype=dtype)\n\n with h5py.File(fn, \"w\") as f:\n f.create_dataset(\"peaks\", data=peaks, compression=\"gzip\")\n\n def load_from_cache(self, fn):\n if os.path.exists(fn):\n with h5py.File(fn, \"r\") as f:\n try:\n peaks = [dict((k, peak[k]) for k in peak.dtype.names)\n for peak in f[\"peaks\"]]\n return dict(\n peaks=peaks,\n )\n except KeyError:\n pass\n return None\n", "meta": {"hexsha": "3744a500d9052c107388c75e05a95e1eebab0634", "size": 11467, "ext": "py", "lang": "Python", "max_stars_repo_path": "ketu/vetter.py", "max_stars_repo_name": "dfm/turnstile", "max_stars_repo_head_hexsha": "13a9a3b489b458396a6ad1e8a2d1e89a0dd6312d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 10, "max_stars_repo_stars_event_min_datetime": "2015-02-19T09:13:24.000Z", "max_stars_repo_stars_event_max_datetime": "2020-04-25T10:50:38.000Z", "max_issues_repo_path": "ketu/vetter.py", "max_issues_repo_name": "dfm/turnstile", "max_issues_repo_head_hexsha": "13a9a3b489b458396a6ad1e8a2d1e89a0dd6312d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2015-07-10T19:50:31.000Z", "max_issues_repo_issues_event_max_datetime": "2015-07-11T03:51:15.000Z", "max_forks_repo_path": "ketu/vetter.py", "max_forks_repo_name": "dfm/turnstile", "max_forks_repo_head_hexsha": "13a9a3b489b458396a6ad1e8a2d1e89a0dd6312d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2015-04-20T06:42:28.000Z", "max_forks_repo_forks_event_max_datetime": "2019-02-25T03:04:45.000Z", "avg_line_length": 31.5027472527, "max_line_length": 79, "alphanum_fraction": 0.5386762013, "include": true, "reason": "import numpy,from scipy", "num_tokens": 3684, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583269943353745, "lm_q2_score": 0.34510528442897664, "lm_q1q2_score": 0.19268159618448505}} {"text": "\"\"\"A 1D simple velocity gradient model to calculate lines with the LVG method\n\nOriginal IDL model by Kees Dullemond, Python translation by Attila Juhasz\n\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import print_function\nimport traceback\ntry:\n import numpy as np\nexcept ImportError:\n np = None\n print(' Numpy cannot be imported ')\n print(' To use the python module of RADMC-3D you need to install Numpy')\n print(traceback.format_exc())\n\nfrom .. natconst import *\n\n\ndef getModelDesc():\n \"\"\"Provides a brief description of the model\n \"\"\"\n\n return \"Example model: A 1D simple velocity gradient model to calculate lines with the LVG method\"\n \n\ndef getDefaultParams():\n \"\"\"Provides default parameter values \n\n Returns a list whose elements are also lists with three elements:\n 1) parameter name, 2) parameter value, 3) parameter description\n All three elements should be strings. The string of the parameter\n value will be directly written out to the parameter file if requested,\n and the value of the string expression will be evaluated and be put\n to radmc3dData.ppar. The third element contains the description of the\n parameter which will be written in the comment field of the line when\n a parameter file is written. \n \"\"\"\n\n defpar = [['mstar', '1.0*ms', 'Mass of the star(s)'],\n ['pstar', '[0., 0., 0.]', 'Position of the star(s) (cartesian coordinates)'],\n ['rstar', '1.0*rs', 'Radius of the star(s)'],\n ['tstar', '1.0*ts', 'Effective temperature of the star(s)'],\n ['crd_sys', \"'car'\", 'Coordinate system used (car/sph)'],\n ['nx', '10', 'Number of grid points in the first dimension'],\n ['ny', '1', 'Number of grid points in the second dimension'],\n ['nz', '1', 'Number of grid points in the third dimension'],\n ['xbound', '[-1000.0*au, 1000.0*au]', 'Boundaries for the x-grid'],\n ['ybound', '[-1000.0*au/nx, 1000.0*au/nx]', 'Boundaries for the y-grid'],\n ['zbound', '[-1000.0*au/nx, 1000.0*au/nx]', 'Boundaries for the z-grid'],\n ['nw', '[20,100,30]', 'Number of points in the wavelength grid'],\n ['wbound', '[0.1, 7., 25., 1e4]', 'Boundaries for the wavelength grid'],\n ['dustkappa_ext', \"['silicate']\", 'Dust opacity file name extension'],\n ['nphot', '1000000', 'Number of photons in the thermal Monte Carlo simulation'],\n ['lines_mode', '3', ''],\n ['scattering_mode_max', '1', '0 - no scattering, 1 - isotropic scattering, 2 - anizotropic scattering'],\n ['gasspec_mol_name', \"['co']\", ''],\n ['gasspec_mol_abun', '[1e-4]', ''],\n ['gasspec_mol_dbase_type', \"['leiden']\", ''],\n ['gasspec_colpart_name', \"['h2']\", ''],\n ['gasspec_colpart_abun', '[1e0]', ''],\n ['gasspec_vturb', '1e5', 'Microturbulent linewidth'],\n ['abun_h2', '0.5', ''],\n ['abun_he', '0.1', ''],\n ['nh2', '1e5', ''],\n ['temp0', '30.', ''],\n ['tdust0', '30.', ''],\n ['dusttogas', '1e-2', ''],\n ['dvdau', '1e-2*1e5', '']]\n\n return defpar\n\n\ndef getGasTemperature(grid=None, ppar=None):\n \"\"\"Calculates the gas temperature\n \n Parameters\n ----------\n grid : radmc3dGrid\n An instance of the radmc3dGrid class containing the spatial and wavelength grid\n \n ppar : dictionary\n Dictionary containing all parameters of the model \n \n Returns\n -------\n Returns the gas temperature in K\n \"\"\"\n\n tgas = np.zeros([grid.nx, grid.ny, grid.nz], dtype=np.float64) + ppar['temp0']\n return tgas\n\n\ndef getDustTemperature(grid=None, ppar=None):\n \"\"\"Calculates/sets the dust temperature\n \n Parameters\n ----------\n grid : radmc3dGrid\n An instance of the radmc3dGrid class containing the spatial and wavelength grid\n \n ppar : dictionary\n Dictionary containing all parameters of the model \n \n Returns\n -------\n Returns the dust temperature in K\n \n \"\"\"\n\n tdust = np.zeros([grid.nx, grid.ny, grid.nz, 1], dtype=np.float64) + ppar['tdust0']\n return tdust\n\n\ndef getGasAbundance(grid=None, ppar=None, ispec=''):\n \"\"\"Calculates/sets the molecular abundance of species ispec \n The number density of a molecule is rhogas * abun \n \n Parameters\n ----------\n grid : radmc3dGrid\n An instance of the radmc3dGrid class containing the spatial and wavelength grid\n\n ppar : dictionary\n Dictionary containing all parameters of the model \n\n ispec : str\n The name of the gas species whose abundance should be calculated\n\n Returns\n -------\n Returns the abundance as an ndarray\n \"\"\"\n # Mass of gas per H2-molecule\n # mgas = mp*(2.0*ppar['abun_h2']+4*ppar['abun_he'])/ppar['abun_h2']\n\n if ispec in ppar['gasspec_mol_name']:\n gasabun = np.zeros([grid.nx, grid.ny, grid.nz], dtype=np.float64) \n ind = ppar['gasspec_mol_name'].index(ispec)\n gasabun[:, :, :] = ppar['gasspec_mol_abun'][ind] # /mgas\n \n elif ispec in ppar['gasspec_colpart_name']:\n gasabun = np.zeros([grid.nx, grid.ny, grid.nz], dtype=np.float64) \n ind = ppar['gasspec_colpart_name'].index(ispec)\n gasabun[:, :, :] = ppar['gasspec_colpart_abun'][ind] # /mgas\n else:\n raise ValueError(' The abundance of \"'+ispec+'\" is not specified in the parameter file')\n \n return gasabun\n\n\ndef getGasDensity(grid=None, ppar=None):\n \"\"\"Calculates the total gas density distribution \n \n Parameters\n ----------\n grid : radmc3dGrid\n An instance of the radmc3dGrid class containing the spatial and wavelength grid\n \n ppar : dictionary\n Dictionary containing all parameters of the model \n \n Returns\n -------\n Returns the gas volume density in g/cm^3\n \"\"\"\n # Mass of gas per H2-molecule\n mgas = mp*(2.0*ppar['abun_h2']+4*ppar['abun_he'])/ppar['abun_h2']\n rhogas = np.zeros([grid.nx, grid.ny, grid.nz], dtype=np.float64) + ppar['nh2'] * mgas\n return rhogas\n\n\ndef getDustDensity(grid=None, ppar=None):\n \"\"\"Calculates the dust density distribution \n \n Parameters\n ----------\n grid : radmc3dGrid\n An instance of the radmc3dGrid class containing the spatial and wavelength grid\n \n ppar : dictionary\n Dictionary containing all parameters of the model \n \n Returns\n -------\n Returns the dust volume density in g/cm^3\n \"\"\"\n rhogas = getGasDensity(grid=grid, ppar=ppar)\n rhodust = np.zeros([grid.nx, grid.ny, grid.nz, 1], dtype=np.float64) \n rhodust[:, :, :, 0] = rhogas * ppar['dusttogas']\n return rhodust\n\n\ndef getVTurb(grid=None, ppar=None):\n \"\"\"Calculates/sets the turbulent velocity field\n \n Parameters\n ----------\n grid : radmc3dGrid\n An instance of the radmc3dGrid class containing the spatial and wavelength grid\n \n ppar : dictionary\n Dictionary containing all parameters of the model \n \n Returns\n -------\n Returns the turbulent velocity in cm/s\n \"\"\"\n vturb = np.zeros([grid.nx, grid.ny, grid.nz], dtype=np.float64) + ppar['gasspec_vturb']\n return vturb\n\n\ndef getVelocity(grid=None, ppar=None):\n \"\"\"Calculates/sets the gas velocity field\n \n Parameters\n ----------\n grid : radmc3dGrid\n An instance of the radmc3dGrid class containing the spatial and wavelength grid\n \n ppar : dictionary\n Dictionary containing all parameters of the model \n \n Returns\n -------\n Returns the turbulent velocity in cm/s\n \"\"\"\n vel = np.zeros([grid.nx, grid.ny, grid.nz, 3], dtype=np.float64)\n for ix in range(grid.nx):\n vel[ix, :, :, 0] = ppar['dvdau']*grid.x[ix]/au\n \n return vel\n", "meta": {"hexsha": "3551fbb82c6c6cdf6b9dde1e75e61ed443d6b119", "size": 7931, "ext": "py", "lang": "Python", "max_stars_repo_path": "radmc-3d/version_0.41/python/radmc3dPy/models/lines_nlte_lvg_1d_1.py", "max_stars_repo_name": "dlmatra/miao", "max_stars_repo_head_hexsha": "71799811b21a4249754390a8ec00972723edab99", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-11-23T00:03:40.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-23T00:03:40.000Z", "max_issues_repo_path": "radmc-3d/version_0.41/python/radmc3dPy/models/lines_nlte_lvg_1d_1.py", "max_issues_repo_name": "dlmatra/miao", "max_issues_repo_head_hexsha": "71799811b21a4249754390a8ec00972723edab99", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2021-05-26T12:54:50.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-27T10:58:48.000Z", "max_forks_repo_path": "radmc-3d/version_0.41/python/radmc3dPy/models/lines_nlte_lvg_1d_1.py", "max_forks_repo_name": "dlmatra/miao", "max_forks_repo_head_hexsha": "71799811b21a4249754390a8ec00972723edab99", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-12-23T14:09:52.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-23T14:09:52.000Z", "avg_line_length": 34.1853448276, "max_line_length": 118, "alphanum_fraction": 0.6038330601, "include": true, "reason": "import numpy", "num_tokens": 2092, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583269943353745, "lm_q2_score": 0.34510528442897664, "lm_q1q2_score": 0.19268159618448505}} {"text": "#! /usr/bin/env python\n\nimport numpy as np\n\ndef framewiseEval(resTracks, groundTruthTracks):\n GTTracks = groundTruthTracks\n # aligning the tracks:\n Tref = GTTracks.shape[0]\n refTimes = GTTracks[:,0]\n estTimes = resTracks[:,0]\n reference = np.zeros([Tref, GTTracks.shape[1]-1])\n reference[:,:] = GTTracks[:,1:]\n print reference.shape\n \n nTracks = resTracks.shape[1] - 1\n newResTracks = np.zeros([Tref, nTracks])\n for i in range(Tref):\n indexMin = np.argmin(np.abs(refTimes[i] - estTimes))\n newResTracks[i,:] = resTracks[indexMin,1:]\n \n resTracks0 = np.copy(newResTracks)\n GTTracks0 = np.copy(reference)\n \n # Consider negative frequency values as 0:\n newResTracks[newResTracks < 0] = 0\n # Setting same number of tracks:\n ## nTracks = np.maximum(nTracks, reference.shape[1])\n\n print newResTracks.shape\n \n # setting the boundaries for tolerance of error:\n reference_low = 0.97 * reference\n reference_hig = 1.03 * reference\n \n # values for score computation\n TP = np.zeros(Tref) # True Positives\n FN = np.zeros(Tref) # False Negatives\n TN = np.zeros(Tref) # True Negatives\n \n for n in range(Tref):\n for track in range(nTracks):\n for track2 in range(reference.shape[1]):\n if reference_low[n, track2] < newResTracks[n, track] and \\\n newResTracks[n, track] < reference_hig[n, track2] and \\\n reference[n, track2] > 0:\n TP[n] += 1\n # inhibiting the TP match\n newResTracks[n, track] = -1\n reference_low[n, track2] = -1\n reference_hig[n, track2] = -1\n reference[n, track2] = -1\n \n FP = np.sum(newResTracks>0) # True Negatives\n # True Negatives - not sure if this quantity is right\n TN = np.minimum(np.sum(reference<=0,\n axis=1),\n np.sum(np.array(newResTracks==0) + \\\n np.array(newResTracks<-1),\n axis=1))\n Ncorr = np.copy(TP) # number of correctly estimated pitches for each frames (MIREX 2007 criteria)\n TP = np.sum(TP) # total TP\n FN = np.maximum(0, np.sum(np.array(newResTracks==0) + \\\n np.array(newResTracks<-1),\n axis=1) -\\\n np.sum(reference<=0,\n axis=1)) # False Negatives, per frame\n TN = np.sum(TN) # total TN\n FN = np.sum(FN) # total FN\n\n # dictionary containing all of the desired values\n resStruct = {}\n resStruct['TP'] = TP\n resStruct['TN'] = TN\n resStruct['FP'] = FP\n resStruct['FN'] = FN\n resStruct['Precision'] = 100.0 * TP / np.double(TP+FP)\n resStruct['Recall'] = 100.0 * TP / np.double(np.sum(GTTracks0>0))# np.sum(reference!=0, dtype=np.double)\n resStruct['FMeasure'] = 2.0 * resStruct['Precision'] * resStruct['Recall'] / (resStruct['Precision'] + resStruct['Recall'])\n resStruct['Accuracy'] = 100.0 * (TP + TN) / np.double(TP + TN + FN) # recall, including silence in the classes to retrieve. \n \n # Additional MIREX 2007 evaluation criteria:\n Nref = np.sum(GTTracks0>0, axis=1, dtype=np.double)\n Nsys = np.sum(resTracks0>0, axis=1, dtype=np.double)\n \n resStruct['AccuracyMirex07'] = 100.0 * TP / np.double(TP+FN+FP)\n \n NrefTotal = np.sum(Nref, dtype=np.double)\n resStruct['Mirex07Etot'] = 100.0 * \\\n np.sum(np.maximum(Nref,Nsys) - \\\n Ncorr) / \\\n NrefTotal\n resStruct['Mirex07Esub'] = 100.0 * \\\n np.sum(np.minimum(Nref,Nsys) - \\\n Ncorr) / \\\n NrefTotal\n resStruct['Mirex07Emis'] = 100.0 * \\\n np.sum(np.maximum(0, Nref-Nsys)) / \\\n NrefTotal\n resStruct['Mirex07Efal'] = 100.0 * \\\n np.sum(np.maximum(0, Nsys-Nref)) / \\\n NrefTotal\n \n return resStruct, GTTracks0, resTracks0\n\ndef framewiseMono(resTracks, groundTruthTracks):\n GTTracks = groundTruthTracks\n # aligning the tracks:\n Tref = GTTracks.shape[0]\n refTimes = GTTracks[:,0]\n estTimes = resTracks[:,0]\n reference = GTTracks[:,1]\n \n newResTracks = np.zeros(Tref)\n for i in range(Tref):\n indexMin = np.argmin(np.abs(refTimes[i] - estTimes))\n newResTracks[i] = resTracks[indexMin,1]\n \n resTracks0 = np.copy(newResTracks)\n GTTracks0 = np.copy(reference)\n \n # Consider negative frequency values as 0:\n newResTracks[newResTracks < 0] = 0\n \n errorInSemitone = np.zeros(Tref)\n for n in range(Tref):\n if reference[n] > 0 and newResTracks[n] != 0:\n errorInSemitone[n] = 12.0 * np.log2(np.abs(newResTracks[n])/np.double(reference[n]))\n \n return errorInSemitone\n\ndef compareFilesByName(fileGT, fileRes):\n GTTracks = np.loadtxt(fileGT)\n resTracks = np.loadtxt(fileRes)\n \n errorInSemitone = framewiseMono(resTracks, GTTracks)\n resStruct, GTTracks0, resTracks0 = framewiseEval(resTracks, GTTracks)\n \n return errorInSemitone, resStruct, GTTracks0, resTracks0\n", "meta": {"hexsha": "ddbb9de3b552aa18e7fd85bb2c38789761547cf6", "size": 5360, "ext": "py", "lang": "Python", "max_stars_repo_path": "code/separateLeadStereo/pitchEval.py", "max_stars_repo_name": "dkdfirefly/speaker_project", "max_stars_repo_head_hexsha": "1c129f3f4d664e6526ab5be35932c27e8b90b07d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2017-01-16T11:27:28.000Z", "max_stars_repo_stars_event_max_datetime": "2017-01-16T11:27:28.000Z", "max_issues_repo_path": "code/separateLeadStereo/pitchEval.py", "max_issues_repo_name": "dkdfirefly/speaker_project", "max_issues_repo_head_hexsha": "1c129f3f4d664e6526ab5be35932c27e8b90b07d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "code/separateLeadStereo/pitchEval.py", "max_forks_repo_name": "dkdfirefly/speaker_project", "max_forks_repo_head_hexsha": "1c129f3f4d664e6526ab5be35932c27e8b90b07d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.5611510791, "max_line_length": 128, "alphanum_fraction": 0.5619402985, "include": true, "reason": "import numpy", "num_tokens": 1428, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583269943353745, "lm_q2_score": 0.3451052709578724, "lm_q1q2_score": 0.1926815886632039}} {"text": "\"\"\"\nCopyright (c) 2021, Electric Power Research Institute\n\n All rights reserved.\n\n Redistribution and use in source and binary forms, with or without modification,\n are permitted provided that the following conditions are met:\n\n * Redistributions of source code must retain the above copyright notice,\n this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright notice,\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution.\n * Neither the name of DER-VET nor the names of its contributors\n may be used to endorse or promote products derived from this software\n without specific prior written permission.\n\n THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR\n CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\n EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\n PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF\n LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING\n NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\n SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\"\"\"\n\"\"\"\nStorage\n\nThis Python class contains methods and attributes specific for technology analysis within StorageVet.\n\"\"\"\nimport logging\nimport cvxpy as cvx\nimport numpy as np\nimport pandas as pd\nfrom storagevet.Technology.DistributedEnergyResource import DER\nfrom dervet.MicrogridDER.DERExtension import DERExtension\nfrom dervet.MicrogridDER.ContinuousSizing import ContinuousSizing\nfrom storagevet.ErrorHandling import *\n\n\nclass ElectricVehicle1(DER, ContinuousSizing, DERExtension):\n \"\"\" A general template for storage object\n\n We define \"storage\" as anything that can affect the quantity of load/power being delivered or used. Specific\n types of storage are subclasses. The storage subclass should be called. The storage class should never\n be called directly.\n\n \"\"\"\n\n def __init__(self, params):\n \"\"\" Initialize all technology with the following attributes.\n\n Args:\n params (dict): Dict of parameters\n \"\"\"\n TellUser.debug(f\"Initializing ElectricVehicle1\")\n # create generic technology object\n DER.__init__(self, params)\n ContinuousSizing.__init__(self, params)\n DERExtension.__init__(self, params)\n\n self.technology_type = 'Electric Vehicle'\n self.tag = 'ElectricVehicle1'\n\n self.ene_target = params['ene_target']\n self.ch_max_rated = params['ch_max_rated']\n self.ch_min_rated = params['ch_min_rated']\n\n self.plugin_time = params['plugin_time']\n self.plugout_time = params['plugout_time']\n\n self.capital_cost_function = params['ccost']\n\n self.fixed_om = params['fixed_om']\n self.incl_binary = False # params['binary'] #TODO\n\n self.variable_names = {'ene', 'ch', 'uene', 'uch', 'on_c'}\n\n # initialize any attributes you want to set and use later\n self.plugin_times_index = None\n self.plugout_times_index = None\n self.unplugged_index = None\n\n # def charge_capacity(self):\n # \"\"\"\n\n # Returns: the maximum charge that can be attained\n\n # \"\"\"\n # return self.ch_max_rated\n\n def initialize_variables(self, size):\n \"\"\" Adds optimization variables to dictionary\n\n Variables added: (with self.unique_ess_id as a prefix to these)\n ene (Variable): A cvxpy variable for Energy collected at the end of the time step (kWh)\n ch (Variable): A cvxpy variable for Charge Power, kW during the previous time step (kW)\n on_c (Variable/Parameter): A cvxpy variable/parameter to flag for charging in previous interval (bool)\n\n Notes:\n CVX Parameters turn into Variable when the condition to include them is active\n\n Args:\n size (Int): Length of optimization variables to create\n\n \"\"\"\n self.variables_dict = {\n 'ene': cvx.Variable(shape=size, name=self.name + '-ene'),\n 'ch': cvx.Variable(shape=size, name=self.name + '-ch'),\n 'uene': cvx.Variable(shape=size, name=self.name + '-uene'), # TODO you can switch to parameter, where value == np.zeros(size) -HN\n 'uch': cvx.Variable(shape=size, name=self.name + '-uch'), # TODO you can switch to parameter, where value == np.zeros(size) -HN\n 'on_c': cvx.Parameter(shape=size, name=self.name + '-on_c', value=np.ones(size)),\n\n }\n\n if self.incl_binary:\n self.variable_names.update(['on_c'])\n self.variables_dict.update({'on_c': cvx.Variable(shape=size, boolean=True, name=self.name + '-on_c')})\n\n def get_state_of_energy(self, mask):\n \"\"\"\n Args:\n mask (DataFrame): A boolean array that is true for indices corresponding to time_series data included\n in the subs data set\n\n Returns: the state of energy as a function of time for the\n\n \"\"\"\n return self.variables_dict['ene']\n\n def get_charge(self, mask):\n \"\"\"\n Args:\n mask (DataFrame): A boolean array that is true for indices corresponding to time_series data included\n in the subs data set\n\n Returns: the charge as a function of time for the\n\n \"\"\"\n return self.variables_dict['ch']\n\n def get_capex(self, **kwargs):\n \"\"\" Returns the capex of a given technology\n \"\"\"\n return self.capital_cost_function\n\n def get_charge_up_schedule(self, mask):\n \"\"\" the amount of charging power in the up direction (supplying power up into the grid) that\n this DER can schedule to reserve\n\n Args:\n mask (DataFrame): A boolean array that is true for indices corresponding to time_series data included\n in the subs data set\n\n Returns: CVXPY parameter/variable\n\n \"\"\"\n return self.variables_dict['ch'] - self.ch_min_rated\n\n def get_charge_down_schedule(self, mask):\n \"\"\" the amount of charging power in the up direction (pulling power down from the grid) that\n this DER can schedule to reserve\n\n Args:\n mask (DataFrame): A boolean array that is true for indices corresponding to time_series data included\n in the subs data set\n\n Returns: CVXPY parameter/variable\n\n \"\"\"\n return self.ch_max_rated - self.variables_dict['ch']\n\n def get_delta_uenegy(self, mask):\n \"\"\" the amount of energy, from the current SOE level the DER's state of energy changes\n from subtimestep energy shifting\n\n Returns: the energy throughput in kWh for this technology\n\n \"\"\"\n return self.variables_dict['uene']\n\n def get_uenergy_increase(self, mask):\n \"\"\" the amount of energy in a timestep that is provided to the distribution grid\n\n Returns: the energy throughput in kWh for this technology\n\n \"\"\"\n return self.variables_dict['uch'] * self.dt\n\n def get_active_times(self, mask):\n \"\"\"\n\n Args:\n mask:\n\n Returns:\n\n \"\"\"\n compute_plugin_index = pd.DataFrame(index=mask.index)\n compute_plugin_index['plugin'] = compute_plugin_index.index.hour == self.plugin_time\n compute_plugin_index['plugout'] = compute_plugin_index.index.hour == self.plugout_time\n compute_plugin_index['unplugged'] = False\n\n if self.plugin_time < self.plugout_time: # plugin time and plugout time must be different\n compute_plugin_index.loc[\n (compute_plugin_index.index.hour >= self.plugin_time) * (compute_plugin_index.index.hour < self.plugout_time), 'unplugged'] = True\n elif self.plugin_time > self.plugout_time:\n compute_plugin_index.loc[\n (compute_plugin_index.index.hour >= self.plugin_time) | (compute_plugin_index.index.hour < self.plugout_time), 'unplugged'] = True\n\n self.plugout_times_index = compute_plugin_index['plugout']\n self.plugin_times_index = compute_plugin_index['plugin']\n self.unplugged_index = compute_plugin_index['unplugged']\n\n def constraints(self, mask):\n \"\"\"Default build constraint list method. Used by services that do not have constraints.\n\n Args:\n mask (DataFrame): A boolean array that is true for indices corresponding to time_series data included\n in the subs data set\n\n Returns:\n A list of constraints that corresponds the EV requirement to collect the required energy to operate. It also allows\n flexibility to provide other grid services\n \"\"\"\n\n constraint_list = []\n self.get_active_times(mask.loc[mask]) # constructing the array that indicates whether the ev is plugged or not\n\n # print(self.plugin_times_index.iloc[0:24])\n # print(self.plugout_times_index.iloc[0:24])\n # print(self.unplugged_index.iloc[0:24])\n # print('Ene target :' + str(self.ene_target))\n # print('Charging max :' + str(self.ch_max_rated))\n # print('Charging min :' + str(self.ch_min_rated))\n\n # optimization variables\n ene = self.variables_dict['ene']\n ch = self.variables_dict['ch']\n uene = self.variables_dict['uene']\n uch = self.variables_dict['uch']\n on_c = self.variables_dict['on_c']\n\n # collected energy at start time is zero for all start times\n constraint_list += [cvx.Zero(ene[self.plugin_times_index])]\n\n # energy evolution generally for every time step\n\n numeric_unplugged_index = pd.Series(range(len(self.unplugged_index)), index=self.unplugged_index.index).loc[self.unplugged_index]\n ene_ini_window = 0\n\n if numeric_unplugged_index.iloc[0] == 0: # energy evolution for the EV, only during plugged times\n constraint_list += [cvx.Zero(ene[numeric_unplugged_index.iloc[0]] - ene_ini_window)]\n constraint_list += [cvx.Zero(ene[list(numeric_unplugged_index.iloc[1:])] - ene[list(numeric_unplugged_index.iloc[1:] - 1)] - (\n self.dt * ch[list(numeric_unplugged_index.iloc[1:] - 1)]))] # - uene[list(numeric_unplugged_index.iloc[1:]-1)])]\n else:\n constraint_list += [cvx.Zero(ene[list(numeric_unplugged_index)] - ene[list(numeric_unplugged_index - 1)] - (\n self.dt * ch[list(numeric_unplugged_index - 1)]))] # - uene[list(numeric_unplugged_index-1)])]\n # constraint_list += [cvx.Zero(ene[1:] - ene[:-1] - ( self.dt * ch[:-1]) - uene[:-1])]\n\n # energy at plugout times must be greater or equal to energy target\n\n numeric_plugout_time_index = pd.Series(range(len(self.plugout_times_index)), index=self.plugout_times_index.index).loc[\n self.plugout_times_index]\n\n # the next few lines make sure that the state of energy at the end of the chargign period is equal to the target\n if numeric_plugout_time_index[0] == 0:\n constraint_list += [cvx.Zero(self.ene_target - ene[list(numeric_plugout_time_index.iloc[1:] - 1)] - (\n self.dt * ch[list(numeric_plugout_time_index.iloc[1:] - 1)]))] # - uene[list(numeric_plugout_time_index.iloc[1:]-1)])]\n else:\n constraint_list += [cvx.Zero(self.ene_target - ene[list(numeric_plugout_time_index - 1)] - (\n self.dt * ch[list(numeric_plugout_time_index - 1)]))] # - uene[list(numeric_plugout_time_index-1)])]\n\n constraint_list += [cvx.Zero(ene[list(numeric_plugout_time_index)] - self.ene_target)]\n\n # constraints on the ch/dis power\n\n # make it MILP or not depending on user selection\n if self.incl_binary:\n constraint_list += [cvx.NonPos(ch - (on_c * self.ch_max_rated))]\n constraint_list += [cvx.NonPos((on_c * self.ch_min_rated) - ch)]\n else:\n constraint_list += [cvx.NonPos(ch - self.ch_max_rated)]\n constraint_list += [cvx.NonPos(- ch)]\n\n # constraints to make sure that the ev does nothing when it is unplugged\n constraint_list += [cvx.NonPos(ch[~self.unplugged_index])]\n\n # account for -/+ sub-dt energy -- this is the change in energy that the battery experiences as a result of energy option\n # constraint_list += [cvx.Zero(uene - (uch * self.dt))]\n constraint_list += [cvx.Zero(uch)] # TODO: you can set the variable to be parameters instead -HN\n constraint_list += [cvx.Zero(uene)] # TODO: you can set the variable to be parameters instead -HN\n return constraint_list\n\n def timeseries_report(self):\n \"\"\" Summaries the optimization results for this DER.\n\n Returns: A timeseries dataframe with user-friendly column headers that\n summarize the results pertaining to this instance\n\n \"\"\"\n tech_id = self.unique_tech_id()\n results = pd.DataFrame(index=self.variables_df.index)\n solve_dispatch_opt = self.variables_df.get('ch')\n if solve_dispatch_opt is not None:\n results[tech_id + ' Charge (kW)'] = self.variables_df['ch']\n results[tech_id + ' Power (kW)'] = -self.variables_df['ch']\n results[tech_id + ' State of Energy (kWh)'] = \\\n self.variables_df['ene']\n\n results[tech_id + ' Energy Option (kWh)'] = \\\n self.variables_df['uene']\n results[tech_id + ' Charge Option (kW)'] = self.variables_df['uch']\n\n return results\n\n def proforma_report(self, apply_inflation_rate_func, fill_forward_func, results):\n \"\"\" Calculates the proforma that corresponds to participation in this value stream\n\n Args:\n apply_inflation_rate_func:\n fill_forward_func:\n results (pd.DataFrame):\n\n Returns: A DateFrame of with each year in opt_year as the index and\n the corresponding value this stream provided.\n\n \"\"\"\n pro_forma = super().proforma_report(apply_inflation_rate_func, fill_forward_func, results)\n if self.variables_df.empty:\n return pro_forma\n analysis_years = self.variables_df.index.year.unique()\n om_costs = pd.DataFrame()\n for year in analysis_years:\n # add fixed o&m costs\n index_yr = pd.Period(year=year, freq='y')\n om_costs.loc[index_yr, self.fixed_column_name()] = -self.fixed_om\n # fill forward\n om_costs = fill_forward_func(om_costs, None)\n # apply inflation rates\n om_costs = apply_inflation_rate_func(om_costs, None, min(analysis_years))\n # append will super class's proforma\n pro_forma = pd.concat([pro_forma, om_costs], axis=1)\n return pro_forma\n\n def sizing_summary(self):\n \"\"\" Creates the template for sizing df that each DER must fill to report their size.\n\n Returns: A dictionary describe this DER's size and captial costs.\n\n \"\"\"\n # template = pd.DataFrame(columns=)\n sizing_dict = {\n 'DER': np.nan,\n 'Energy Rating (kWh)': np.nan,\n 'Charge Rating (kW)': np.nan,\n 'Discharge Rating (kW)': np.nan,\n 'Round Trip Efficiency (%)': np.nan,\n 'Lower Limit on SOC (%)': np.nan,\n 'Upper Limit on SOC (%)': np.nan,\n 'Duration (hours)': np.nan,\n 'Capital Cost ($)': np.nan,\n 'Capital Cost ($/kW)': np.nan,\n 'Capital Cost ($/kWh)': np.nan,\n 'Power Capacity (kW)': np.nan,\n 'Quantity': 1,\n }\n return sizing_dict\n\n\nclass ElectricVehicle2(DER, ContinuousSizing, DERExtension):\n \"\"\" A general template for storage object\n\n We define \"storage\" as anything that can affect the quantity of load/power being delivered or used. Specific\n types of storage are subclasses. The storage subclass should be called. The storage class should never\n be called directly.\n\n \"\"\"\n\n def __init__(self, params):\n \"\"\" Initialize all technology with the following attributes.\n\n Args:\n params (dict): Dict of parameters\n \"\"\"\n TellUser.debug(f\"Initializing ElectricVehicle2\")\n # create generic technology object\n DER.__init__(self, params)\n ContinuousSizing.__init__(self, params)\n DERExtension.__init__(self, params)\n\n self.technology_type = 'Electric Vehicle'\n self.tag = 'ElectricVehicle2'\n\n # input params\n # note: these should never be changed in simulation (i.e from degradation)\n\n self.max_load_ctrl = params[\n 'max_load_ctrl'] / 100.0 # maximum amount of baseline EV load that can be shed as a percentage of the original load\n # self.qualifying_cap = params['qualifying_cap'] #capacity that can be used for 'capacity' services (DR, RA) as a percentage of the baseline load\n self.lost_load_cost = params['lost_load_cost']\n self.incl_binary = params['binary']\n self.EV_load_TS = params['EV_baseline']\n\n self.capital_cost_function = params['ccost']\n\n self.fixed_om = params['fixed_om']\n\n self.variable_names = {'ch'}\n\n def qualifying_capacity(self, event_length):\n \"\"\" Describes how much power the DER can discharge to qualify for RA or DR. Used to determine\n the system's qualifying commitment.\n\n Args:\n event_length (int): the length of the RA or DR event, this is the\n total hours that a DER is expected to discharge for\n\n Returns: int/float\n\n \"\"\"\n return 0\n\n def initialize_variables(self, size):\n \"\"\" Adds optimization variables to dictionary\n\n Variables added: (with self.unique_ess_id as a prefix to these)\n ene (Variable): A cvxpy variable for Energy collected at the end of the time step (kWh)\n ch (Variable): A cvxpy variable for Charge Power, kW during the previous time step (kW)\n on_c (Variable/Parameter): A cvxpy variable/parameter to flag for charging in previous interval (bool)\n\n Notes:\n CVX Parameters turn into Variable when the condition to include them is active\n\n Args:\n size (Int): Length of optimization variables to create\n\n \"\"\"\n self.variables_dict = {\n 'ch': cvx.Variable(shape=size, name=self.name + '-ch')\n }\n\n if self.incl_binary:\n self.variable_names.update(['on_c'])\n self.variables_dict.update({'on_c': cvx.Variable(shape=size, boolean=True, name=self.name + '-on_c')})\n\n def get_charge(self, mask):\n \"\"\"\n Args:\n mask (DataFrame): A boolean array that is true for indices corresponding to time_series data included\n in the subs data set\n\n Returns: the charge as a function of time for the\n\n \"\"\"\n return self.variables_dict['ch']\n\n def get_capex(self, **kwargs):\n \"\"\" Returns the capex of a given technology\n \"\"\"\n return self.capital_cost_function\n\n def get_charge_up_schedule(self, mask):\n \"\"\" the amount of charging power in the up direction (supplying power up into the grid) that\n this DER can schedule to reserve\n\n Args:\n mask (DataFrame): A boolean array that is true for indices corresponding to time_series data included\n in the subs data set\n\n Returns: CVXPY parameter/variable\n\n\n\n \"\"\"\n return self.variables_dict['ch'] - (1 - self.max_load_ctrl) * self.EV_load_TS[mask]\n\n def get_charge_down_schedule(self, mask):\n \"\"\" the amount of charging power in the up direction (pulling power down from the grid) that\n this DER can schedule to reserve\n\n Args:\n mask (DataFrame): A boolean array that is true for indices corresponding to time_series data included\n in the subs data set\n\n Returns: CVXPY parameter/variable\n\n \"\"\"\n return -self.variables_dict['ch'] + self.EV_load_TS[mask]\n\n def objective_function(self, mask, annuity_scalar=1):\n \"\"\" Generates the objective function related to a technology. Default includes O&M which can be 0\n\n Args:\n mask (Series): Series of booleans used, the same length as case.power_kw\n annuity_scalar (float): a scalar value to be multiplied by any yearly cost or benefit that helps capture the cost/benefit over\n the entire project lifetime (only to be set iff sizing, else annuity_scalar should not affect the aobject function)\n\n Returns:\n self.costs (Dict): Dict of objective costs\n \"\"\"\n\n # create objective expression for variable om based on discharge activity\n ch = self.variables_dict['ch']\n costs = {\n self.name + ' fixed_om': self.fixed_om * annuity_scalar,\n self.name + ' lost_load_cost': cvx.sum(self.EV_load_TS[mask].values - ch) * self.lost_load_cost # added to account for lost load\n\n }\n # add startup objective costs\n\n return costs\n\n def constraints(self, mask):\n \"\"\"Default build constraint list method. Used by services that do not have constraints.\n\n Args:\n mask (DataFrame): A boolean array that is true for indices corresponding to time_series data included\n in the subs data set\n\n Returns:\n A list of constraints that corresponds the EV requirement to collect the required energy to operate. It also allows\n flexibility to provide other grid services\n \"\"\"\n constraint_list = []\n\n # optimization variables\n\n ch = self.variables_dict['ch']\n # uch = self.variables_dict['uch']\n\n # constraints on the ch/dis power\n constraint_list += [cvx.NonPos(ch - self.EV_load_TS[mask].values)]\n constraint_list += [cvx.NonPos((1 - self.max_load_ctrl) * self.EV_load_TS[mask].values - ch)]\n\n # the constraint below limits energy throughput and total discharge to less than or equal to\n # (number of cycles * energy capacity) per day, for technology warranty purposes\n # this constraint only applies when optimization window is equal to or greater than 24 hours\n\n return constraint_list\n\n def timeseries_report(self):\n \"\"\" Summaries the optimization results for this DER.\n\n Returns: A timeseries dataframe with user-friendly column headers that\n summarize the results pertaining to this instance\n\n \"\"\"\n tech_id = self.unique_tech_id()\n results = pd.DataFrame(index=self.variables_df.index)\n solve_dispatch_opt = self.variables_df.get('ch')\n if solve_dispatch_opt is not None:\n results[tech_id + ' EV Fleet Baseline Load'] = self.EV_load_TS\n results[tech_id + ' Charge (kW)'] = self.variables_df['ch']\n results[tech_id + ' Power (kW)'] = -self.variables_df['ch']\n\n return results\n\n def proforma_report(self, apply_inflation_rate_func, fill_forward_func, results):\n \"\"\" Calculates the proforma that corresponds to participation in this value stream\n\n Args:\n apply_inflation_rate_func:\n fill_forward_func:\n results (pd.DataFrame):\n\n Returns: A DateFrame of with each year in opt_year as the index and\n the corresponding value this stream provided.\n\n \"\"\"\n pro_forma = super().proforma_report(apply_inflation_rate_func, fill_forward_func, results)\n if self.variables_df.empty:\n return pro_forma\n analysis_years = self.variables_df.index.year.unique()\n om_costs = pd.DataFrame()\n for year in analysis_years:\n # add fixed o&m costs\n index_yr = pd.Period(year=year, freq='y')\n om_costs.loc[index_yr, self.fixed_column_name()] = -self.fixed_om\n # fill forward\n om_costs = fill_forward_func(om_costs, None)\n # apply inflation rates\n om_costs = apply_inflation_rate_func(om_costs, None, min(analysis_years))\n # append will super class's proforma\n pro_forma = pd.concat([pro_forma, om_costs], axis=1)\n return pro_forma\n\n def sizing_summary(self):\n \"\"\" Creates the template for sizing df that each DER must fill to report their size.\n\n Returns: A dictionary describe this DER's size and captial costs.\n\n \"\"\"\n # template = pd.DataFrame(columns=)\n sizing_dict = {\n 'DER': np.nan,\n 'Energy Rating (kWh)': np.nan,\n 'Charge Rating (kW)': np.nan,\n 'Discharge Rating (kW)': np.nan,\n 'Round Trip Efficiency (%)': np.nan,\n 'Lower Limit on SOC (%)': np.nan,\n 'Upper Limit on SOC (%)': np.nan,\n 'Duration (hours)': np.nan,\n 'Capital Cost ($)': np.nan,\n 'Capital Cost ($/kW)': np.nan,\n 'Capital Cost ($/kWh)': np.nan,\n 'Power Capacity (kW)': np.nan,\n 'Quantity': 1,\n }\n return sizing_dict\n", "meta": {"hexsha": "77952c43c72e19c901f03da6d081012a86f70d85", "size": 25446, "ext": "py", "lang": "Python", "max_stars_repo_path": "dervet/MicrogridDER/ElectricVehicles.py", "max_stars_repo_name": "epri-dev/dervet", "max_stars_repo_head_hexsha": "2d74d8b3f00fd0ebcf562900c0cb2bff0e995b42", "max_stars_repo_licenses": ["Apache-2.0", "BSD-3-Clause"], "max_stars_count": 9, "max_stars_repo_stars_event_min_datetime": "2021-04-27T18:14:46.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-27T18:56:59.000Z", "max_issues_repo_path": "dervet/MicrogridDER/ElectricVehicles.py", "max_issues_repo_name": "epri-dev/dervet", "max_issues_repo_head_hexsha": "2d74d8b3f00fd0ebcf562900c0cb2bff0e995b42", "max_issues_repo_licenses": ["Apache-2.0", "BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-09-21T13:47:41.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-21T13:47:41.000Z", "max_forks_repo_path": "dervet/MicrogridDER/ElectricVehicles.py", "max_forks_repo_name": "epri-dev/dervet", "max_forks_repo_head_hexsha": "2d74d8b3f00fd0ebcf562900c0cb2bff0e995b42", "max_forks_repo_licenses": ["Apache-2.0", "BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-06-24T14:14:30.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-23T19:17:58.000Z", "avg_line_length": 41.3756097561, "max_line_length": 153, "alphanum_fraction": 0.6467421206, "include": true, "reason": "import numpy,import cvxpy", "num_tokens": 5565, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583269796369904, "lm_q2_score": 0.3451052574867685, "lm_q1q2_score": 0.19268157606943334}} {"text": "\"\"\" \nTensorflow SMPL implementation as batch.\n\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport numpy as np\nimport pickle as pickle\n\nimport tensorflow as tf\nfrom .batch_lbs import batch_rodrigues, batch_global_rigid_transformation\n\n\n# There are chumpy variables so convert them to numpy.\ndef undo_chumpy(x):\n return x if isinstance(x, np.ndarray) else x.r\n\n\nclass SMPL(object):\n def __init__(self, pkl_path, joint_type='cocoplus', dtype=tf.float64):\n \"\"\"\n pkl_path is the path to a SMPL model\n \"\"\"\n # -- Load SMPL params --\n with open(pkl_path, 'rb') as f:\n dd = pickle.load(f, encoding=\"latin1\")\n self.dtype = dtype\n # Mean template vertices\n self.v_template = tf.Variable(undo_chumpy(dd['v_template']),\n name='v_template',\n dtype=self.dtype,\n trainable=False)\n self.f = dd['f']\n\n # Size of mesh [Number of vertices, 3]\n self.size = [self.v_template.shape[0].value, 3]\n self.num_betas = dd['shapedirs'].shape[-1]\n self.num_verts = dd['shapedirs']\n self.num_joints = dd['J'].shape[0]\n\n # Shape blend shape basis: num_verts x 3 x num_betas\n # reshaped to 3*num_verts x num_betas, transposed to num_betas x 3*num_verts\n shapedir = np.reshape(undo_chumpy(dd['shapedirs']), [-1, self.num_betas]).T\n self.shapedirs = tf.Variable(shapedir, name='shapedirs', dtype=self.dtype, trainable=False)\n\n # Regressor for joint locations given shape - num_verts x num_joints\n self.J_regressor = tf.Variable(dd['J_regressor'].T.todense(),\n name=\"J_regressor\",\n dtype=self.dtype,\n trainable=False)\n\n # Pose blend shape basis: num_verts x 3 x 9*num_joints, reshaped to 3*num_verts x 9*num_joints\n num_pose_basis = dd['posedirs'].shape[-1]\n posedirs = np.reshape(undo_chumpy(dd['posedirs']), [-1, num_pose_basis]).T\n self.posedirs = tf.Variable(posedirs, name='posedirs', dtype=self.dtype, trainable=False)\n\n # indices of parents for each joints\n self.parents = dd['kintree_table'][0].astype(np.int32)\n\n # LBS weights\n self.weights = tf.Variable(undo_chumpy(dd['weights']),\n name='lbs_weights',\n dtype=self.dtype,\n trainable=False)\n\n\n def __call__(self, trans, beta, theta, name=''):\n \"\"\"\n Obtain SMPL with shape (beta) & pose (theta) inputs.\n Theta includes the global rotation.\n Args:\n beta: N x num_betas\n theta: N x 3*num_joints (with 3-D axis-angle rep)\n\n Updates:\n self.J_transformed: N x num_joints x 3 joint location after shaping\n & posing with beta and theta\n\n Returns:\n - Verts: N x num_verts x 3\n \"\"\"\n\n with tf.name_scope(name, \"smpl_main\", [beta, theta]):\n num_batch = beta.shape[0].value\n\n # 1. Add shape blend shapes\n # (N x num_betas) x (num_betas x 3*num_verts) = N x num_verts x 3\n v_shaped = tf.reshape(tf.matmul(beta, self.shapedirs, name='shape_bs'),\n [-1, self.size[0], self.size[1]]) + self.v_template\n\n # 2. Infer shape-dependent joint locations.\n Jx = tf.matmul(v_shaped[:, :, 0], self.J_regressor)\n Jy = tf.matmul(v_shaped[:, :, 1], self.J_regressor)\n Jz = tf.matmul(v_shaped[:, :, 2], self.J_regressor)\n J = tf.stack([Jx, Jy, Jz], axis=2)\n\n # 3. Add pose blend shapes\n # N x num_joints x 3 x 3\n Rs = tf.reshape(batch_rodrigues(tf.reshape(theta, [-1, 3])), [-1, self.num_joints, 3, 3])\n with tf.name_scope(\"lrotmin\"):\n # Ignore global rotation.\n pose_feature = tf.reshape(Rs[:, 1:, :, :] - tf.eye(3, dtype=self.dtype), [-1, 9*(self.num_joints-1)])\n\n # (N x 9*(num_joints-1))) x (9*(num_joints-1), 3*num_verts) -> N x num_verts x 3\n v_posed = tf.reshape(tf.matmul(pose_feature, self.posedirs),\n [-1, self.size[0], self.size[1]]) + v_shaped\n\n #4. Get the global joint location\n self.J_transformed, A = batch_global_rigid_transformation(Rs, J, self.parents)\n\n # 5. Do skinning:\n # W is N x num_verts x num_joints\n W = tf.reshape(tf.tile(self.weights, [num_batch, 1]), [num_batch, -1, self.num_joints])\n\n # (N x num_verts x num_joints) x (N x num_joints x 16)\n T = tf.reshape(\n tf.matmul(W, tf.reshape(A, [num_batch, self.num_joints, 16])),\n [num_batch, -1, 4, 4])\n v_posed_homo = tf.concat([v_posed, tf.ones([num_batch, v_posed.shape[1], 1], dtype=self.dtype)], 2)\n v_homo = tf.matmul(T, tf.expand_dims(v_posed_homo, -1))\n\n return tf.add(v_homo[:, :, :3, 0], trans)\n", "meta": {"hexsha": "16c02cdd511bb9be499cfff3afcf56a804170218", "size": 5189, "ext": "py", "lang": "Python", "max_stars_repo_path": "tf_smpl/batch_smpl.py", "max_stars_repo_name": "samiurprapon/TF_FLAME", "max_stars_repo_head_hexsha": "23dddfd97d1ecd957495d7ab66f82a32dd980161", "max_stars_repo_licenses": ["AAL"], "max_stars_count": 300, "max_stars_repo_stars_event_min_datetime": "2019-05-25T01:12:15.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-25T13:29:02.000Z", "max_issues_repo_path": "tf_smpl/batch_smpl.py", "max_issues_repo_name": "samiurprapon/TF_FLAME", "max_issues_repo_head_hexsha": "23dddfd97d1ecd957495d7ab66f82a32dd980161", "max_issues_repo_licenses": ["AAL"], "max_issues_count": 56, "max_issues_repo_issues_event_min_datetime": "2019-06-17T05:06:09.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-09T23:30:09.000Z", "max_forks_repo_path": "tf_smpl/batch_smpl.py", "max_forks_repo_name": "samiurprapon/TF_FLAME", "max_forks_repo_head_hexsha": "23dddfd97d1ecd957495d7ab66f82a32dd980161", "max_forks_repo_licenses": ["AAL"], "max_forks_count": 66, "max_forks_repo_forks_event_min_datetime": "2019-06-12T19:52:51.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-24T11:36:30.000Z", "avg_line_length": 41.512, "max_line_length": 117, "alphanum_fraction": 0.5642705724, "include": true, "reason": "import numpy", "num_tokens": 1324, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5698526660244838, "lm_q2_score": 0.33807712415000585, "lm_q1q2_score": 0.19265415051877124}} {"text": "import os\nfrom typing import List, Dict\nimport numpy as np\nimport h5py as h5\nfrom scipy.sparse import csr_matrix\nfrom mpi4py import MPI\n\nfrom .__init__ import (\n\tpprint,\n\tcomm,\n\trank,\n\tnproc,\n)\nfrom .conversion import (\n\tcomoving_density,\n\tcomoving_length,\n\tcomoving_velocity,\n\tcomoving_mass,\n\tcomoving_kinetic_energy,\n\tcomoving_momentum,\n\tcomoving_ang_momentum,\n\tdensity_units,\n\tvelocity_units,\n\tlength_units,\n\tmass_units,\n\tmomentum_units,\n\tenergy_units,\n)\n\ndef split(nfiles):\n nfiles=int(nfiles)\n nf=int(nfiles/nproc)\n rmd=nfiles % nproc\n st=rank*nf\n fh=(rank+1)*nf\n if rank < rmd:\n st+=rank\n fh+=(rank+1)\n else:\n st+=rmd\n fh+=rmd\n return st,fh\n\ndef commune(data):\n tmp=np.zeros(nproc,dtype=np.int)\n tmp[rank]=len(data)\n cnts=np.zeros(nproc,dtype=np.int)\n comm.Allreduce([tmp,MPI.INT],[cnts,MPI.INT],op=MPI.SUM)\n del tmp\n dspl=np.zeros(nproc,dtype=np.int)\n i=0\n for j in range(nproc):\n dspl[j]=i\n i+=cnts[j]\n rslt=np.zeros(i,dtype=data.dtype)\n comm.Allgatherv([data,cnts[rank]],[rslt,cnts,dspl,MPI._typedict[data.dtype.char]])\n del data,cnts,dspl\n return rslt\n\ndef compute_M(data):\n cols = np.arange(data.size)\n return csr_matrix((cols, (data.ravel(), cols)), shape=(data.max() + 1, data.size))\n\ndef get_indices_sparse(data):\n M = compute_M(data)\n return [np.unravel_index(row.data, data.shape) for row in M]\n\ndef find_files(redshift: str) -> list:\n z_value = ['z004p688', 'z004p061', 'z003p053', 'z003p078', 'z002p688', 'z002p349',\n 'z002p053', 'z001p792', 'z001p561', 'z001p354', 'z001p168', 'z001p000', 'z000p846', 'z000p706',\n 'z000p577', 'z000p457', 'z000p345', 'z000p240', 'z000p140', 'z000p046', 'z000p000']\n z_IDNumber = ['002', '003', '004', '005', '006', '007', '008', '009', '010', '011', '012', '013',\n '014', '015', '016', '017', '018', '019', '020', '021', '022']\n sn = dict(zip(z_value, z_IDNumber))[redshift]\n path='/cosma5/data/dp004/dc-hens1/macsis/macsis_gas'\n pprint(f\"[+] Find simulation files {redshift:s}...\")\n\n halos = [x for x in os.listdir(path) if x.startswith('halo_')]\n\tmaster_files = []\n\tfor halo in halos:\n\t\tgroups = []\n\t\tfor x in os.listdir(os.path.join(path, halo, f'data/groups_{sn}')):\n\t\t\tif x.startswith('eagle_subfind_tab'):\n\t\t\t\tcomplete_path = os.path.join(path, halo, f'data/groups_{sn}/{x}')\n\t\t\t\tgroups.append(complete_path)\n\n\t\tparticle = []\n\t\tfor x in os.listdir(os.path.join(path, halo, f'data/particledata_{sn}')):\n\t\t\tif x.startswith('eagle_subfind_particles'):\n\t\t\t\tcomplete_path = os.path.join(path, halo, f'data/particledata_{sn}/{x}')\n\t\t\t\tparticle.append(complete_path)\n\n\t\tmaster_files.append([groups[0], particle[0]])\n\n\treturn master_files\n\n\n\ndef fof_header(files: list):\n\tpprint(f\"[+] Find header information...\")\n\theader = {}\n\twith h5.File(files[0][1], 'r') as f:\n\t\theader['Hub'] = f['Header'].attrs['HubbleParam']\n\t\theader['aexp'] = f['Header'].attrs['ExpansionFactor']\n\t\theader['zred'] = f['Header'].attrs['Redshift']\n\t\theader['OmgL'] = f['Header'].attrs['OmegaLambda']\n\t\theader['OmgM'] = f['Header'].attrs['Omega0']\n\t\theader['OmgB'] = f['Header'].attrs['OmegaBaryon']\n\treturn header\n\n\n\ndef fof_groups(files: list):\n\tpprint(f\"[+] Find groups information...\")\n\tgroup_files = [pair[0] for pair in files]\n\tst, fh = split(len(group_files))\n\tMfof = np.empty(0, dtype=np.float32)\n\tM2500 = np.empty(0, dtype=np.float32)\n\tM500 = np.empty(0, dtype=np.float32)\n\tM200 = np.empty(0, dtype=np.float32)\n\tR2500 = np.empty(0, dtype=np.float32)\n\tR500 = np.empty(0, dtype=np.float32)\n\tR200 = np.empty(0, dtype=np.float32)\n\tCOP = np.empty(0, dtype=np.float32)\n\tNSUB = np.empty(0, dtype=np.int)\n\tFSID = np.empty(0, dtype=np.int)\n\tSCOP = np.empty(0, dtype=np.float32)\n\tfor x in range(st, fh, 1):\n\t\twith h5.File(group_files[x], 'r') as f:\n\t\t\tMfof = np.append(Mfof, f['FOF/GroupMass'][:])\n\t\t\tM2500 = np.append(M2500, f['FOF/Group_M_Crit2500'][:])\n\t\t\tR2500 = np.append(R2500, f['FOF/Group_R_Crit2500'][:])\n\t\t\tM500 = np.append(M500, f['FOF/Group_M_Crit500'][:])\n\t\t\tR500 = np.append(R500, f['FOF/Group_R_Crit500'][:])\n\t\t\tM200 = np.append(M200, f['FOF/Group_M_Crit200'][:])\n\t\t\tR200 = np.append(R200, f['FOF/Group_R_Crit200'][:])\n\t\t\tCOP = np.append(COP, f['FOF/GroupCentreOfPotential'][:])\n\t\t\tNSUB = np.append(NSUB, f['FOF/NumOfSubhalos'][:])\n\t\t\tFSID = np.append(FSID, f['FOF/FirstSubhaloID'][:])\n\t\t\tSCOP = np.append(SCOP, f['Subhalo/CentreOfPotential'][:])\n\n\theader = {}\n\twith h5.File(group_files[0], 'r') as f:\n\t\theader['Hub'] = f['Header'].attrs['HubbleParam']\n\t\theader['aexp'] = f['Header'].attrs['ExpansionFactor']\n\t\theader['zred'] = f['Header'].attrs['Redshift']\n\n\t# Conversion\n\tMfof = comoving_mass(header, Mfof * 1.0e10)\n\tM2500 = comoving_mass(header, M2500 * 1.0e10)\n\tM500 = comoving_mass(header, M500 * 1.0e10)\n\tM200 = comoving_mass(header, M200 * 1.0e10)\n\tR2500 = comoving_length(header, R2500)\n\tR500 = comoving_length(header, R500)\n\tR200 = comoving_length(header, R200)\n\tCOP = comoving_length(header, COP)\n\tSCOP = comoving_length(header, SCOP)\n\n\tdata = {}\n\tdata['groupfiles'] = np.asarray(group_files)\n\tdata['particlefiles'] = np.asarray([pair[1] for pair in files])\n\tdata['Mfof'] = commune(Mfof)\n\tdata['M2500'] = commune(M2500)\n\tdata['R2500'] = commune(R2500)\n\tdata['M500'] = commune(M500)\n\tdata['R500'] = commune(R500)\n\tdata['M200'] = commune(M200)\n\tdata['R200'] = commune(R200)\n\tdata['COP'] = commune(COP.reshape(-1, 1)).reshape(-1, 3)\n\tdata['NSUB'] = commune(NSUB)\n\tdata['FSID'] = commune(FSID)\n\tdata['SCOP'] = commune(SCOP.reshape(-1, 1)).reshape(-1, 3)\n\n\treturn data\n\ndef fof_group(clusterID: int, fofgroups: Dict[str, np.ndarray] = None):\n\tpprint(f\"[+] Find group information for cluster {clusterID}\")\n\tnew_data = {}\n\tnew_data['clusterID'] = clusterID\n\tnew_data['Mfof'] = fofgroups['Mfof'][clusterID]\n\tnew_data['M2500'] = fofgroups['M2500'][clusterID]\n\tnew_data['R2500'] = fofgroups['R2500'][clusterID]\n\tnew_data['M500'] = fofgroups['M500'][clusterID]\n\tnew_data['R500'] = fofgroups['R500'][clusterID]\n\tnew_data['M200'] = fofgroups['M200'][clusterID]\n\tnew_data['R200'] = fofgroups['R200'][clusterID]\n\tnew_data['COP'] = fofgroups['COP'][clusterID]\n\tnew_data['NSUB'] = fofgroups['NSUB'][clusterID]\n\tnew_data['FSID'] = fofgroups['FSID'][clusterID]\n\tnew_data['SCOP'] = fofgroups['SCOP'][clusterID]\n\tnew_data['groupfiles'] = fofgroups['groupfiles'][clusterID]\n\tnew_data['particlefiles'] = fofgroups['particlefiles'][clusterID]\n\treturn new_data\n\n\ndef cluster_partgroupnumbers(fofgroup: Dict[str, np.ndarray] = None):\n\t\"\"\"\n\n\t:param fofgroups:\n\t:return:\n\t\"\"\"\n\tpgn = []\n\twith h5.File(fofgroup['particlefiles'], 'r') as h5file:\n\n\t\tfor pt in ['0', '1', '4']:\n\t\t\tNparticles = h5file['Header'].attrs['NumPart_ThisFile'][int(pt)]\n\t\t\tst, fh = split(Nparticles)\n\t\t\tpprint(f\"[+] Collecting particleType {pt} GroupNumber...\")\n\t\t\tgroupnumber = h5file[f'/PartType{pt}/GroupNumber'][st:fh]\n\n\t\t\t# Clip out negative values and exceeding values\n\t\t\tgroupnumber = np.clip(groupnumber, 0, 6)\n\t\t\tpprint(f\"\\t Computing CSR indexing matrix...\")\n\t\t\tgroupnumber_csrm = get_indices_sparse(groupnumber)\n\t\t\tdel groupnumber_csrm[0], groupnumber_csrm[-1]\n\t\t\tpgn.append(groupnumber_csrm)\n\t\t\tdel groupnumber\n\n\treturn pgn\n\ndef cluster_particles(fofgroup: Dict[str, np.ndarray] = None, groupNumbers: List[np.ndarray] = None):\n\t\"\"\"\n\n\t:param fofgroup:\n\t:param groupNumbers:\n\t:return:\n\t\"\"\"\n\tpprint(f\"[+] Find particle information for cluster {fofgroup['clusterID']}\")\n\tdata_out = {}\n\theader = {}\n\tpartTypes = ['0', '1', '4']\n\twith h5.File(fofgroup['particlefiles'], 'r') as h5file:\n\n\t\theader['Hub'] = h5file['Header'].attrs['HubbleParam']\n\t\theader['aexp'] = h5file['Header'].attrs['ExpansionFactor']\n\t\theader['zred'] = h5file['Header'].attrs['Redshift']\n\n\t\tfor pt in partTypes:\n\n\t\t\t# Initialise particledata arrays\n\t\t\tpgn_core = np.empty(0, dtype=np.int)\n\t\t\tsubgroup_number = np.empty(0, dtype=np.int)\n\t\t\tvelocity = np.empty(0, dtype=np.float32)\n\t\t\tcoordinates = np.empty(0, dtype=np.float32)\n\t\t\tmass = np.empty(0, dtype=np.float32)\n\t\t\ttemperature = np.empty(0, dtype=np.float32)\n\t\t\tsphdensity = np.empty(0, dtype=np.float32)\n\t\t\tsphlength = np.empty(0, dtype=np.float32)\n\n\t\t\t# Let each CPU core import a portion of the pgn data\n\t\t\tpgn = groupNumbers[partTypes.index(pt)]\n\t\t\tst, fh = split(len(pgn))\n\t\t\tpgn_core = np.append(pgn_core, pgn[st:fh])\n\t\t\tdel pgn\n\n\t\t\t# Filter particle data with collected groupNumber indexing\n\t\t\tsubgroup_number = np.append(subgroup_number, h5file[f'/PartType{pt}/SubGroupNumber'][pgn_core])\n\t\t\tvelocity = np.append(velocity, h5file[f'/PartType{pt}/Velocity'][pgn_core])\n\t\t\tcoordinates = np.append(coordinates, h5file[f'/PartType{pt}/Coordinates'][pgn_core])\n\t\t\tif pt == '1':\n\t\t\t\tparticle_mass_DM = h5file['Header'].attrs['MassTable'][1]\n\t\t\t\tmass = np.append(mass, np.ones(len(pgn_core), dtype=np.float32) * particle_mass_DM)\n\t\t\telse:\n\t\t\t\tmass = np.append(mass, h5file[f'/PartType{pt}/Mass'][pgn_core])\n\t\t\tif pt == '0':\n\t\t\t\ttemperature = np.append(temperature, h5file[f'/PartType{pt}/Temperature'][pgn_core])\n\t\t\t\tsphdensity = np.append(sphdensity, h5file[f'/PartType{pt}/Density'][pgn_core])\n\t\t\t\tsphlength = np.append(sphlength, h5file[f'/PartType{pt}/SmoothingLength'][pgn_core])\n\n\t\t\tdel pgn_core\n\n\t\t\t# Conversion from comoving units to physical units\n\t\t\tvelocity = comoving_velocity(header, velocity)\n\t\t\tcoordinates = comoving_length(header, coordinates)\n\t\t\tmass = comoving_mass(header, mass * 1.0e10)\n\t\t\tif pt == '0':\n\t\t\t\tden_conv = h5file[f'/PartType{pt}/Density'].attrs['CGSConversionFactor']\n\t\t\t\tsphdensity = comoving_density(header, sphdensity * den_conv)\n\t\t\t\tsphlength = comoving_length(header, sphlength)\n\n\t\t\t# Gather the imports across cores\n\t\t\tdata_out[f'partType{pt}'] = {}\n\t\t\tdata_out[f'partType{pt}']['subgroupnumber'] = commune(subgroup_number)\n\t\t\tdata_out[f'partType{pt}']['velocity'] = commune(velocity.reshape(-1, 1)).reshape(-1, 3)\n\t\t\tdata_out[f'partType{pt}']['coordinates'] = commune(coordinates.reshape(-1, 1)).reshape(-1, 3)\n\t\t\tdata_out[f'partType{pt}']['mass'] = commune(mass)\n\t\t\tif pt == '0':\n\t\t\t\tdata_out[f'partType{pt}']['temperature'] = commune(temperature)\n\t\t\t\tdata_out[f'partType{pt}']['sphdensity'] = commune(sphdensity)\n\t\t\t\tdata_out[f'partType{pt}']['sphlength'] = commune(sphlength)\n\n\t\t\tdel subgroup_number, velocity, mass, coordinates, temperature, sphdensity, sphlength\n\n\treturn data_out\n\ndef cluster_data(clusterID: int,\n header: Dict[str, float] = None,\n fofgroups: Dict[str, np.ndarray] = None):\n\t\"\"\"\n\n\t:param clusterID:\n\t:param header:\n\t:param fofgroups:\n\t:param groupNumbers:\n\t:return:\n\t\"\"\"\n\n\tgroup_data = fof_group(clusterID, fofgroups = fofgroups)\n\thalo_partgn = cluster_partgroupnumbers(fofgroup=group_data)\n\tpart_data = cluster_particles(fofgroup=group_data, groupNumbers= halo_partgn)\n\n\tout = {}\n\tout['Header'] = {**header}\n\tout['FOF'] = {**group_data}\n\tfor pt in ['0', '1', '4']:\n\t\tout[f'partType{pt}'] = {**part_data[f'partType{pt}']}\n\treturn out\n\n\ndef glance_cluster(cluster_dict: dict, verbose: bool = False, indent: int = 1) -> None:\n\t\"\"\"\n\n\t:param cluster_dict:\n\t:param verbose:\n\t:param indent:\n\t:return:\n\t\"\"\"\n\tif not verbose:\n\t\tfor key, value in cluster_dict.items():\n\t\t\tif isinstance(value, dict):\n\t\t\t\tpprint('\\t'*indent + str(key))\n\t\t\t\tglance_cluster(value, indent=indent+1)\n\t\t\telif (isinstance(value, np.ndarray) or isinstance(value, list)) and len(value) > 10:\n\t\t\t\tpprint('\\t' * indent + str(key) + ' : ' + f\"len({len(value):d})\\t val({value[0]} ... {value[-1]})\")\n\t\t\telse:\n\t\t\t\tpprint('\\t' * indent + str(key) + ' : ' + str(value))\n\n\tif verbose:\n\t\tfor key, value in cluster_dict.items():\n\t\t\tif isinstance(value, dict):\n\t\t\t\tpprint('\\t'*indent + str(key))\n\t\t\t\tglance_cluster(value, indent=indent+1)\n\t\t\telse:\n\t\t\t\tpprint('\\t'*indent + str(key) +' : '+ str(value))", "meta": {"hexsha": "f05671659d6ac7d122ac9954be24330eb0966a21", "size": 11793, "ext": "py", "lang": "Python", "max_stars_repo_path": "macsis/read.py", "max_stars_repo_name": "LBJ-Wade/C-Eagle-analysis", "max_stars_repo_head_hexsha": "d13ffb219834e11baeb5b9d863c6a6eb965ba6ad", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "macsis/read.py", "max_issues_repo_name": "LBJ-Wade/C-Eagle-analysis", "max_issues_repo_head_hexsha": "d13ffb219834e11baeb5b9d863c6a6eb965ba6ad", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "macsis/read.py", "max_forks_repo_name": "LBJ-Wade/C-Eagle-analysis", "max_forks_repo_head_hexsha": "d13ffb219834e11baeb5b9d863c6a6eb965ba6ad", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.2819767442, "max_line_length": 107, "alphanum_fraction": 0.6662426863, "include": true, "reason": "import numpy,from scipy", "num_tokens": 3728, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5698526660244838, "lm_q2_score": 0.33807711081161995, "lm_q1q2_score": 0.19265414291785646}} {"text": "'''\nMichel Lam 2015\nLoads a parameter file\n'''\nimport decimal\nimport re\nimport numpy as np\nfrom astropy.coordinates import SkyCoord\nimport astropy.units as unit\n\nnumre = re.compile('(\\d+[.]\\d+D[+]\\d+)|(-?\\d+[.]\\d+)')\nflagre = re.compile('-[a-zA-Z]')\n\nc = 2.9979e8\nPC_TO_M = 3.086e16\nMAS_TO_RAD = np.pi/(180*60*60*1000)\nYR_TO_S = 3.154e7\n\nDECIMAL = decimal.Decimal\n\n\nclass Parameter(object):\n def __init__(self, name, value=None, fit=None, error=None, flag=None,\n flagvalue=None, numwrap=float, usedecimal=False):\n if usedecimal:\n self.numwrap = DECIMAL\n else:\n self.numwrap = numwrap\n # Initialize all values just in case\n self.name = name\n self.value = value\n self.fit = fit\n self.error = error\n self.flag = flag\n self.flagvalue = flagvalue\n if value is None: #parse all arguments\n self.parstring = name\n if name[0] == \"#\":# this is a comment\n self.name = \"#\"\n self.value = name[1:]\n return\n splitstring = self.parstring.strip().split()\n if len(splitstring) == 0:\n return None #?\n self.name = splitstring[0]\n if self.name == \"C\": #this is also a comment:\n self.value = self.parstring[2:]\n return\n\n if len(splitstring) == 1: # sometimes true in PSRFITS PSREPHEM table\n return\n elif flagre.match(splitstring[1][:2]) and len(splitstring) >= 4: #flag present\n self.flag = splitstring[1]\n self.flagvalue = splitstring[2]\n self.value = self.numwrap(splitstring[3])\n if len(splitstring) >= 5:\n self.error = self.numwrap(splitstring[-1])\n if len(splitstring) == 6:\n self.fit = int(splitstring[4])\n else: #no flag present\n if numre.match(splitstring[1]):\n self.value = self.numwrap(splitstring[1].replace('D', 'e'))\n elif splitstring[1].isdigit():\n self.value = int(splitstring[1])\n elif splitstring[1][1:].isdigit() and (splitstring[1][0] == \"+\" or splitstring[1][0] == \"-\"):\n self.value = int(splitstring[1])\n else:\n self.value = splitstring[1]\n\n if len(splitstring) == 3 or len(splitstring) == 4:\n if numre.match(splitstring[-1]):\n self.error = self.numwrap(splitstring[-1].replace('D', 'e'))\n elif splitstring[1].isdigit():\n if splitstring[-1] == \"NaN\":\n self.error = np.nan\n else:\n self.error = int(splitstring[-1])\n elif splitstring[1][1:].isdigit() and (splitstring[1][0] == \"+\" or splitstring[1][0] == \"-\"):\n self.error = int(splitstring[-1])\n else:\n self.error = splitstring[-1]\n # Fit flag\n if len(splitstring) == 3 and not numre.match(splitstring[2]) and splitstring[2] != \"NaN\":\n if splitstring[2].isdigit():\n self.fit = int(splitstring[2])\n else: #this is actually NAME VAL ERROR rather than NAME VAL FLAG\n self.fit = 0\n self.error = float(splitstring[2])\n elif len(splitstring) == 4:\n self.fit = int(splitstring[2])\n\n def getName(self):\n return self.name\n\n def getValue(self):\n return self.value\n\n def getFit(self):\n return self.fit\n\n def getError(self):\n return self.error\n\n def getFlag(self):\n return self.flag\n\n def getFlagValue(self):\n return self.flagvalue\n\n def hasFlag(self):\n if self.flagvalue is not None:\n return True\n return False\n\n\nclass Par(object):\n def __init__(self, filename, numwrap=float, usedecimal=False):\n self.filename = filename\n if isinstance(filename, (list, np.ndarray)):\n lines = filename\n elif isinstance(filename, (str, np.str_)):\n FILE = open(filename, 'r')\n lines = FILE.readlines()\n else:\n return None\n\n self.usedecimal = usedecimal\n if self.usedecimal:\n self.numwrap = DECIMAL\n else:\n self.numwrap = numwrap\n self.paramlist = list() #each unique parameter\n self.paramnames = list() #the names of each parameter\n for line in lines:\n if len(line) == 0:\n continue\n p = Parameter(line, numwrap=self.numwrap)\n self.paramlist.append(p)\n self.paramnames.append(p.getName())\n self.paramnames = np.array(self.paramnames, dtype=np.str_)\n if isinstance(filename, str):\n FILE.close()\n\n def __repr__(self):\n numwrapstr = repr(self.numwrap).split(\"'\")[1]\n return \"Par(%r, numwrap=%s, usedecimal=%r)\" % (self.filename, numwrapstr, self.usedecimal)\n\n def __str__(self):\n if isinstance(self.filename, (list, np.ndarray)):\n return \"\\n\".join(self.filename)\n return self.filename\n\n def save(self, filename):\n # Crude saving attempt\n output = \"\"\n for param in self.paramlist:\n output += param.parstring\n with open(filename, 'w') as FILE:\n FILE.write(output)\n\n def getInd(self, tag):\n return np.where(self.paramnames == tag)[0]#[0]\n\n def get(self, tag, flag=False, error=False):\n if tag in self.paramnames:\n ind = self.getInd(tag)\n retval = []\n for i in ind:\n if error:\n val = self.paramlist[i].getError()\n elif flag:\n val = self.paramlist[i].getFlagValue()\n else:\n val = self.paramlist[i].getValue()\n try:\n retval.append(self.numwrap(val))\n except (ValueError, TypeError, decimal.InvalidOperation):\n retval.append(val)\n if len(retval) == 1:\n return retval[0]\n return np.array(retval)\n return None\n\n \"\"\"\n def getParameterFlags(self, tag):\n #If a parameter has flags, return all of the possible values as a list\n if tag in self.paramnames:\n ind = self.getInd(tag)\n retval = []\n for i in ind:\n retval.append(self.paramlist[i].getFlagValue())\n if len(retval) == 1:\n return retval[0]\n return np.array(retval)\n return None\n \"\"\"\n\n def getPeriod(self):\n if 'P0' in self.paramnames:\n return self.get('P0')\n if 'F0' in self.paramnames:\n F0 = self.get('F0')\n elif 'F' in self.paramnames:\n F0 = self.get('F')\n elif 'IF0' in self.paramnames:\n F0 = (self.get('IF0') + self.get('FF0'))/self.numwrap(1000.0)\n return self.numwrap(1.0)/F0\n\n def getPeriodDot(self, shklovskii=False):\n if 'P1' in self.paramnames:\n Pdot = self.get('P1')\n elif 'F1' in self.paramnames:\n Pdot = self.numwrap(-1.0)*self.get('F1') / (self.get('F0')**2)\n else:\n return None\n\n if shklovskii: #Correct for the shklovskii effect\n PM = self.getPM()\n if PM is None or \"PX\" not in self.paramnames:\n return Pdot\n\n P = self.getPeriod() #s\n PX = self.get(\"PX\") #mas\n PXerr = self.get(\"PX\", error=True)\n if PX <= 0 or (PXerr is not None and PXerr >= np.abs(PX)):\n return Pdot\n\n PM = PM * self.numwrap(MAS_TO_RAD/YR_TO_S) #mas/yr -> rad/s\n D = self.numwrap(1000*PC_TO_M)/PX #kpc -> m\n Pdot_pm = P*PM**2 *D/self.numwrap(c) #s/s\n return Pdot-Pdot_pm\n else:\n return Pdot\n\n def getFrequency(self):\n return self.numwrap(1.0)/self.getPeriod()\n\n def getFrequencyDot(self, shklovskii=False):\n return self.numwrap(-1.0) * self.getPeriodDot(shklovskii=shklovskii) / self.getPeriod()**2\n\n def getPM(self, error=False):\n keys = self.paramnames\n retval = None\n if \"PMRA\" in keys and \"PMDEC\" in keys:\n PMRA = self.get(\"PMRA\")\n PMDEC = self.get(\"PMDEC\")\n PM = np.sqrt(PMRA**2 + PMDEC**2) #mas/yr\n if error:\n PMRAerr = self.get(\"PMRA\", error=True)\n PMDECerr = self.get(\"PMDEC\", error=True)\n retval = np.sqrt((PMRAerr*PMRA/PM)**2 + (PMDECerr*PMDEC/PM)**2)\n else:\n retval = PM\n elif \"PMRA\" in keys:\n retval = abs(self.get(\"PMRA\", error=error))\n elif \"PMDEC\" in keys:\n retval = abs(self.get(\"PMDEC\", error=error))\n elif \"PMLAMBDA\" in keys and \"PMBETA\" in keys:\n PMLAMBDA = self.get(\"PMLAMBDA\")\n PMBETA = self.get(\"PMBETA\")\n PM = np.sqrt(PMLAMBDA**2 + PMBETA**2) #mas/yr\n if error:\n PMLAMBDAerr = self.get(\"PMLAMBDA\", error=True)\n PMBETAerr = self.get(\"PMBETA\", error=True)\n retval = np.sqrt((PMLAMBDAerr*PMLAMBDA/PM)**2 + (PMBETAerr*PMBETA/PM)**2)\n else:\n retval = PM\n elif \"PMLAMBDA\" in keys:\n retval = abs(self.get(\"PMLAMBDA\", error=error))\n elif \"PMBETA\" in keys:\n retval = abs(self.get(\"PMBETA\", error=error))\n return retval\n\n def getPX(self, error=False):\n return self.get('PX', error=error)\n\n def getDIST(self, error=False):\n PX = self.getPX()\n if error:\n PXerr = self.getPX(error=True)\n return PXerr/PX**2\n else:\n return self.numwrap(1.0)/PX\n\n def getVpperp(self, error=False):\n '''\n Get transverse velocity\n v = 4.74 km/s (D/kpc) (mu/ mas yr^-1)\n\n for errors: assuming PM and PX are\n '''\n PM = self.getPM() #mas yr^-1\n DIST = self.getDIST() #kpc\n retval = self.numwrap(4.74) * PM * DIST\n\n if error:\n PMerr = self.getPM(error=True)\n DISTerr = self.getDIST(error=True)\n return retval * np.sqrt((PMerr/PM)**2 + (DISTerr/DIST)**2)\n else:\n return retval\n\n\n def getCoord(self):\n '''\n Return an Astropy SkyCoord object based on the coordinates\n '''\n keys = self.paramnames\n if \"RAJ\" in keys: #return Equatorial coordinates\n RAJ = self.get(\"RAJ\")\n DECJ = self.get(\"DECJ\")\n if DECJ[0].isdigit(): #is positive\n DECJ = \"+\" + DECJ\n coord = SkyCoord(ra=RAJ, dec=DECJ, frame=\"icrs\", unit=(unit.hourangle, unit.deg))\n elif \"LAMBDA\" in keys: #return Ecliptic coordinates\n LAMBDA = self.get(\"LAMBDA\")\n BETA = self.get(\"BETA\")\n coord = SkyCoord(lon=LAMBDA, lat=BETA, frame=\"barycentrictrueecliptic\", unit=unit.deg)\n elif \"ELAT\" in keys: #return Ecliptic coordinates\n LAMBDA = self.get(\"ELONG\")\n BETA = self.get(\"ELAT\")\n coord = SkyCoord(lon=LAMBDA, lat=BETA, frame=\"barycentrictrueecliptic\", unit=unit.deg)\n return coord\n getCoords = getCoord\n\n\n def getDM(self):\n return self.get('DM')\n\n def getDMX(self, full_output=False):\n keys = self.paramnames\n Ncomponents = 0\n for key in keys:\n if key[0:4] == 'DMX_':\n Ncomponents += 1\n if Ncomponents == 0:\n return None\n #DM = self.getDM()\n ts = np.zeros(Ncomponents)\n dmxs = np.zeros(Ncomponents)\n errs = np.zeros(Ncomponents)\n if full_output:\n R1s = np.zeros(Ncomponents)\n R2s = np.zeros(Ncomponents)\n F1s = np.zeros(Ncomponents)\n F2s = np.zeros(Ncomponents)\n for i in range(Ncomponents):\n ts[i] = self.get('DMXEP_%04i'%(i+1))\n if np.isnan(ts[i]):\n ts[i] = self.numwrap(0.5)*(self.get('DMXR1_%04i'%(i+1))+self.get('DMXR2_%04i'%(i+1)))\n dmxs[i] = self.get('DMX_%04i'%(i+1))\n errs[i] = self.get('DMX_%04i'%(i+1), error=True) #check to make sure this exists?\n if full_output:\n R1s[i] = self.get('DMXR1_%04i'%(i+1))\n R2s[i] = self.get('DMXR2_%04i'%(i+1))\n F1s[i] = self.get('DMXF1_%04i'%(i+1))\n F2s[i] = self.get('DMXF2_%04i'%(i+1))\n if np.isnan(ts[i]):\n ts[i] = (R1s[i]+R2s[i])/2.0\n if full_output:\n return ts, dmxs, errs, R1s, R2s, F1s, F2s\n return ts, dmxs, errs\n\n def getXMX(self):#, full_output=False):\n keys = self.paramnames\n Ncomponents = 0\n for key in keys:\n if key[0:4] == 'XMX_':\n Ncomponents += 1\n if Ncomponents == 0:\n return None\n #DM = self.getDM()\n xmxs = np.zeros(Ncomponents)\n errs = np.zeros(Ncomponents)\n R1s = np.zeros(Ncomponents)\n R2s = np.zeros(Ncomponents)\n EXPs = np.zeros(Ncomponents)\n for i in range(Ncomponents):\n xmxs[i] = self.get('XMX_%04i'%(i+1))\n errs[i] = self.get('XMX_%04i'%(i+1), error=True) #check to make sure this exists?\n R1s[i] = self.get('XMXR1_%04i'%(i+1))\n R2s[i] = self.get('XMXR2_%04i'%(i+1))\n EXPs[i] = self.get('XMXEXP_%04i'%(i+1))\n return xmxs, errs, R1s, R2s, EXPs\n\n def getDMseries(self):\n ts, dmxs, errs = self.getDMX()\n DM = self.getDM()\n return ts, dmxs + float(DM), errs #float from possible decimal!\n\n def getFD(self):\n coeffs = []\n for param in self.paramnames:\n if \"FD\" in param:\n coeffs.append(self.get(param))\n if len(coeffs) == 0:\n return None\n return np.array(coeffs)\n\n def getFDfunc(self):\n \"\"\"\n Returns a function that provides the timing delays as a function of observing frequency\n \"\"\"\n FD = self.getFD()\n if FD is None:\n return None\n FD = FD[::-1]\n FD = np.concatenate((FD, [0]))\n f = lambda nu: 1e6*np.polyval(FD, np.log(nu)) #nu in GHz, returns values in microseconds\n return f\n\n def getName(self):\n \"\"\" Returns the pulsar name \"\"\"\n if \"PSR\" in self.paramnames:\n return self.get(\"PSR\")\n elif \"PSRJ\" in self.paramnames:\n return self.get(\"PSRJ\")\n return None\n\n def getTspan(self, years=False):\n \"\"\" Returns the total time span the par file covers \"\"\"\n start = self.get(\"START\")\n finish = self.get(\"FINISH\")\n if years:\n return (finish-start)/365.25\n return finish-start\n", "meta": {"hexsha": "4508d82cbb89a69e837b7b5e1bbb213d11ed0bde", "size": 15082, "ext": "py", "lang": "Python", "max_stars_repo_path": "pypulse/par.py", "max_stars_repo_name": "mtlam/PyPulse", "max_stars_repo_head_hexsha": "87cad878408ee5021c1092eda7d271a712f52198", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 13, "max_stars_repo_stars_event_min_datetime": "2015-10-20T14:29:46.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-19T17:17:16.000Z", "max_issues_repo_path": "pypulse/par.py", "max_issues_repo_name": "mtlam/PyPulse", "max_issues_repo_head_hexsha": "87cad878408ee5021c1092eda7d271a712f52198", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2017-08-03T19:37:42.000Z", "max_issues_repo_issues_event_max_datetime": "2019-07-17T23:58:17.000Z", "max_forks_repo_path": "pypulse/par.py", "max_forks_repo_name": "mtlam/PyPulse", "max_forks_repo_head_hexsha": "87cad878408ee5021c1092eda7d271a712f52198", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 13, "max_forks_repo_forks_event_min_datetime": "2015-10-20T14:34:51.000Z", "max_forks_repo_forks_event_max_datetime": "2021-07-14T18:28:23.000Z", "avg_line_length": 35.3208430913, "max_line_length": 113, "alphanum_fraction": 0.5170401803, "include": true, "reason": "import numpy,import astropy,from astropy", "num_tokens": 3872, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5698526514141572, "lm_q2_score": 0.33807711748081287, "lm_q1q2_score": 0.19265414177889673}} {"text": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\nfrom __future__ import division\nfrom __future__ import absolute_import\nfrom builtins import object\n\nimport numpy as np\nimport pkg_resources\nimport fsps\nimport os\nimport linecache\n#grid: 2 files: line, cont\n#columns: wavelengths\n#rows: models\n#header\n#wavelength grid\n#age, Z, logU\n#flux1\n#flux2\n#flux3\n\n###\n# reads from ZAU***.out_lines, ZAU***.out_cont\n# produces ZAU_**.lines, ZAU_**.cont\n###\nclass writeFormattedOutput(object):\n #sp = fsps.StellarPopulation()\n #fsps_lam = sp.wavelengths\n def __init__(self, dir_, mod_prefix, mod_suffix,\n use_extended_lines=False, more_info=False,**kwargs):\n '''\n writeFormattedOutput(mod_dir, 'ZAU', 'BPASS')\n '''\n self.dir_, self.mod_prefix = dir_, mod_prefix\n self.file_pr = dir_ + mod_prefix\n if mod_suffix is None:\n self.out_pr = dir_ + mod_prefix\n else:\n self.out_pr = dir_ + mod_prefix + mod_suffix\n # each model's final info will be in prefix00.lines, prefix00.cont\n self.line_out = self.out_pr + \".lines\"\n self.cont_out = self.out_pr + \".cont\"\n # load each model's parameters from prefix.pars\n self.loadModInfo()\n # print ordered emission line wavelengths + fluxes\n self.doLineOut(use_extended_lines=use_extended_lines,\n more_info=more_info)\n # interp and print neb cont onto FSPS wavelenth arr\n self.doContOut()\n return\n def loadModInfo(self, **kwargs):\n '''\n reads model parameters from \"ZAU.pars\"\n '''\n name_keys = [\"mod_num\", \"logZ\", \"Age\", \"logU\", \"logR\", \"logQ\", \"nH\", \"efrac\"]\n data = np.genfromtxt(self.file_pr+\".pars\", unpack=True)\n ddata = {}\n for i,key in enumerate(name_keys):\n ddata[key] = data[i]\n self.__setattr__(key, data[i])\n self.__setattr__(\"modpars\", ddata)\n self.NZ = len(np.unique(self.logZ))\n self.NA = len(np.unique(self.Age))\n self.NU = len(np.unique(self.logU))\n return\n def doLineOut(self, more_info=False, **kwargs):\n '''\n prints line fluxes to prefix00.lines file\n '''\n f = open(self.line_out, \"w\")\n self.printLineLam(f, **kwargs)\n for n in self.mod_num:\n self.printLineFlu(f, n.astype(int), more_info=more_info)\n f.close()\n print(\"lines: {0:.0f} models to file {1}\".format(self.mod_num[-1], self.line_out))\n return\n def printLineLam(self, f, use_extended_lines=False):\n '''\n prints the wavelength array for the emission lines as the second\n line in the output file. converts all wavelengths to vacuum.\n '''\n #read in file containing wavelength info\n if use_extended_lines:\n linefile = pkg_resources.resource_filename(__name__, \"data/orderedLinesEXT.dat\")\n else:\n linefile = pkg_resources.resource_filename(__name__, \"data/orderedLines.dat\")\n data_vac = np.genfromtxt(linefile)\n #data_vac = air_to_vac(data) # new file is already in vac\n nlines = len(data_vac)\n nmods = np.max(self.mod_num)\n #print header to file\n head_str = \"#{0} cols {1:.0f} rows {2} logZ {3} Age {4} logU\".format(nlines, nmods, self.NZ, self.NA, self.NU)\n f.write(head_str+\"\\n\")\n #print lambda array\n p_str = \" \".join([\"{0:1.6e}\".format(dat) for dat in data_vac])\n f.write(p_str+\"\\n\")\n return\n def printLineFlu(self, f, n, more_info=False):\n #write model parameters\n if more_info:\n tstr = linecache.getline(self.file_pr+'.pars', n)\n else:\n tstr = \"{0:2.4e} {1:2.4e} {2:2.4e}\\n\".format(self.logZ[n-1], self.Age[n-1], self.logU[n-1])\n f.write(tstr)\n #read in and print emission line intensities (Lsun/Q)\n nst = \"{0}\".format(n)\n filename = self.file_pr+nst+\".out_lines\"\n lam, flu = np.genfromtxt(filename, unpack=True)\n I_str = [\"{0:1.4e}\".format(s) for s in flu]\n tstr = \" \".join(I_str)\n f.write(tstr+\"\\n\")\n return\n def doContOut(self, **kwargs):\n f = open(self.cont_out, \"w\")\n self.printContLam(f)\n for num in self.modpars['mod_num']:\n iind = num.astype(int)\n pars = dict(logZ=self.logZ[iind-1],\n Age=self.Age[iind-1],\n nH=self.nH[iind-1],\n logQ=self.logQ[iind-1],\n logU=self.logU[iind-1],\n logR=self.logR[iind-1],\n mod_num=iind,\n efrac=self.efrac[iind-1])\n self.printContFlu(f, pars)\n f.close()\n print(\"cont: {0:.0f} models to file {1}\".format(self.modpars['mod_num'][-1], self.cont_out))\n return\n def printContFlu(self, f, pars):\n #write model parameters\n tstr = \"{0:2.4e} {1:2.4e} {2:2.4e}\".format(pars[\"logZ\"],\n pars[\"Age\"],\n pars[\"logU\"])\n f.write(tstr+\"\\n\")\n #read in and print emission line intensities\n nst = \"{0}\".format(pars[\"mod_num\"])\n filename = self.file_pr+nst+\".out_cont\"\n # read lambda, diffuse cont\n mdata = np.genfromtxt(filename)\n lam = mdata[:,0]\n flu = mdata[:,1]\n y_str = \" \".join([\"{0:1.4}\".format(y) for y in flu])\n f.write(y_str+\"\\n\")\n return\n def printContLam(self, f):\n '''\n prints header in first line of file, and the FSPS wavelength array\n (for the nebular continuum) as the second line in the output file.\n # nlam cols nmod rows logZ Age logU\n # fsps_lam_1 fsps_lam_2 .... fsps_lam_n\n '''\n #grab fsps wavelength info\n lamfile = pkg_resources.resource_filename(__name__, \"data/FSPSlam.dat\")\n fsps_lam = np.genfromtxt(lamfile)\n self.__setattr__(\"fsps_lam\", fsps_lam)\n nlam = len(fsps_lam)\n nmods = np.max(self.mod_num).astype(int)\n #print header to file\n head_str = \"#{0} cols {1} rows {2} logZ {3} Age {4} logU\".format(nlam, nmods, self.NZ, self.NA, self.NU)\n f.write(head_str+\"\\n\")\n #print lambda array\n p_str = \" \".join([\"{0:1.6e}\".format(lam) for lam in fsps_lam])\n f.write(p_str+\"\\n\")\n return\n\n\n\n#------------------------------------------------\ndef zmet_to_nuZ(zmet):\n '''\n zmet = 1,2,3,4,5,6,7,8\n ...corresponding to...\n m1.00, m1.02, m1.04, m1.06, p0.00, p0.02, p0.04, p0.06\n '''\n zmets = np.array([1,2,3,4,5,6,7,8])\n zs = np.array([-1.00, -1.02, -1.04, -1.06, 0.00, 0.02, 0.04, 0.06])\n if type(zmet) is float:\n ii, = np.where(zmets == zmet)[0]\n out_val = zs[ii]\n else:\n out_val = np.zeros_like(zmet, dtype='float')\n for i in range(len(zmet)):\n ii, = np.where(zmets == zmet[i])[0]\n out_val[i] = zs[ii]\n return out_val\n\nclass writeAltFormattedOutput(object):\n #sp = fsps.StellarPopulation()\n #fsps_lam = sp.wavelengths\n def __init__(self, dir_, mod_prefix, mod_suffix,\n use_extended_lines=False, more_info=False,**kwargs):\n '''\n writeFormattedOutput(mod_dir, 'ZAU', 'BPASS')\n '''\n self.dir_, self.mod_prefix = dir_, mod_prefix\n self.file_pr = dir_ + mod_prefix\n if mod_suffix is None:\n self.out_pr = dir_ + mod_prefix\n else:\n self.out_pr = dir_ + mod_prefix + mod_suffix\n # each model's final info will be in prefix00.lines, prefix00.cont\n self.line_out = self.out_pr + \".lines\"\n self.cont_out = self.out_pr + \".cont\"\n self.loadModInfo() # load each model's parameters from prefix.pars\n # print ordered emission line wavelengths + fluxes\n self.doLineOut(use_extended_lines=use_extended_lines,\n more_info=more_info)\n self.doContOut() # interp and print neb cont onto FSPS wavelenth arr\n return\n def loadModInfo(self, **kwargs):\n '''\n reads model parameters from \"ZAU.pars\"\n '''\n name_keys = [\"mod_num\", \"logZ\", \"Age\", \"logU\", \"logR\", \"logQ\", \"nH\", \"efrac\", \"zmet\"]\n data = np.genfromtxt(self.file_pr+\".pars\", unpack=True)\n ddata = {}\n for i,key in enumerate(name_keys):\n if key == 'zmet':\n temp_arr = zmet_to_nuZ(data[i])\n ddata[key] = temp_arr\n self.__setattr__(key, temp_arr)\n else:\n ddata[key] = data[i]\n self.__setattr__(key, data[i])\n self.__setattr__(\"modpars\", ddata)\n self.NZ = len(np.unique(self.zmet))\n self.NA = len(np.unique(self.Age))\n self.NU = len(np.unique(self.logU))\n return\n def doLineOut(self, more_info=False, **kwargs):\n '''\n prints line fluxes to prefix00.lines file\n '''\n f = open(self.line_out, \"w\")\n self.printLineLam(f, **kwargs)\n for n in self.mod_num:\n self.printLineFlu(f, n.astype(int), more_info=more_info)\n f.close()\n print(\"lines: {0:.0f} models to file {1}\".format(self.mod_num[-1], self.line_out))\n return\n def printLineLam(self, f, use_extended_lines=False):\n '''\n prints the wavelength array for the emission lines as the second\n line in the output file. converts all wavelengths to vacuum.\n '''\n #read in file containing wavelength info\n if use_extended_lines:\n linefile = pkg_resources.resource_filename(__name__, \"data/orderedLinesEXT.dat\")\n else:\n linefile = pkg_resources.resource_filename(__name__, \"data/orderedLines.dat\")\n data_vac = np.genfromtxt(linefile)\n #data_vac = air_to_vac(data) # new file is already in vac\n nlines = len(data_vac)\n nmods = np.max(self.mod_num)\n #print header to file\n head_str = \"#{0} cols {1:.0f} rows {2} logZ {3} Age {4} logU\".format(nlines, nmods, self.NZ, self.NA, self.NU)\n f.write(head_str+\"\\n\")\n #print lambda array\n p_str = \" \".join([\"{0:1.6e}\".format(dat) for dat in data_vac])\n f.write(p_str+\"\\n\")\n return\n def printLineFlu(self, f, n, more_info=False):\n #write model parameters\n if more_info:\n tstr = linecache.getline(self.file_pr+'.pars', n)\n f.write(tstr)\n else:\n tstr = \"{0:2.4e} {1:2.4e} {2:2.4e}\".format(self.zmet[n-1], self.Age[n-1], self.logU[n-1])\n f.write(tstr+\"\\n\")\n #read in and print emission line intensities (Lsun/Q)\n nst = \"{0}\".format(n)\n filename = self.file_pr+nst+\".out_lines\"\n lam, flu = np.genfromtxt(filename, unpack=True)\n I_str = [\"{0:1.4e}\".format(s) for s in flu]\n tstr = \" \".join(I_str)\n f.write(tstr+\"\\n\")\n return\n def doContOut(self, **kwargs):\n f = open(self.cont_out, \"w\")\n self.printContLam(f)\n for num in self.modpars['mod_num']:\n iind = num.astype(int)\n pars = dict(logZ=self.logZ[iind-1],\n Age=self.Age[iind-1],\n nH=self.nH[iind-1],\n logQ=self.logQ[iind-1],\n logU=self.logU[iind-1],\n logR=self.logR[iind-1],\n mod_num=iind,\n zmet=self.zmet[iind-1])\n self.printContFlu(f, pars)\n f.close()\n print(\"cont: {0:.0f} models to file {1}\".format(self.modpars['mod_num'][-1], self.cont_out))\n return\n def printContFlu(self, f, pars):\n #write model parameters\n tstr = \"{0:2.4e} {1:2.4e} {2:2.4e}\".format(pars[\"zmet\"],\n pars[\"Age\"],\n pars[\"logU\"])\n f.write(tstr+\"\\n\")\n #read in and print emission line intensities\n nst = \"{0}\".format(pars[\"mod_num\"])\n filename = self.file_pr+nst+\".out_cont\"\n # read lambda, diffuse cont\n mdata = np.genfromtxt(filename)\n lam = mdata[:,0]\n flu = mdata[:,1]\n y_str = \" \".join([\"{0:1.4}\".format(y) for y in flu])\n f.write(y_str+\"\\n\")\n return\n def printContLam(self, f):\n '''\n prints header in first line of file, and the FSPS wavelength array\n (for the nebular continuum) as the second line in the output file.\n # nlam cols nmod rows logZ Age logU\n # fsps_lam_1 fsps_lam_2 .... fsps_lam_n\n '''\n #grab fsps wavelength info\n lamfile = pkg_resources.resource_filename(__name__, \"data/FSPSlam.dat\")\n fsps_lam = np.genfromtxt(lamfile)\n self.__setattr__(\"fsps_lam\", fsps_lam)\n nlam = len(fsps_lam)\n nmods = np.max(self.mod_num).astype(int)\n #print header to file\n head_str = \"#{0} cols {1} rows {2} logZ {3} Age {4} logU\".format(nlam, nmods, self.NZ, self.NA, self.NU)\n f.write(head_str+\"\\n\")\n #print lambda array\n p_str = \" \".join([\"{0:1.6e}\".format(lam) for lam in fsps_lam])\n f.write(p_str+\"\\n\")\n return\n", "meta": {"hexsha": "714959e02b80dc95fe381b90d41cf3c5667d7ce3", "size": 13313, "ext": "py", "lang": "Python", "max_stars_repo_path": "cloudyfsps/outputFormatting.py", "max_stars_repo_name": "prerakgarg07/cloudyfsps", "max_stars_repo_head_hexsha": "4a6a185343ed1e09b9f201a465c37e377ef42101", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 10, "max_stars_repo_stars_event_min_datetime": "2015-12-07T01:00:26.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-18T17:50:51.000Z", "max_issues_repo_path": "cloudyfsps/outputFormatting.py", "max_issues_repo_name": "prerakgarg07/cloudyfsps", "max_issues_repo_head_hexsha": "4a6a185343ed1e09b9f201a465c37e377ef42101", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "cloudyfsps/outputFormatting.py", "max_forks_repo_name": "prerakgarg07/cloudyfsps", "max_forks_repo_head_hexsha": "4a6a185343ed1e09b9f201a465c37e377ef42101", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2016-12-08T22:57:04.000Z", "max_forks_repo_forks_event_max_datetime": "2020-08-30T15:04:33.000Z", "avg_line_length": 39.7402985075, "max_line_length": 118, "alphanum_fraction": 0.5590024788, "include": true, "reason": "import numpy", "num_tokens": 3645, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5698526514141571, "lm_q2_score": 0.33807711081162, "lm_q1q2_score": 0.19265413797843944}} {"text": "\"\"\"\n.. module:: mcmc\n :synopsis: Monte Carlo procedure\n.. moduleauthor:: Benjamin Audren \n\nThis module defines one key function, :func:`chain`, that handles the Markov\nchain. So far, the code uses only one chain, as no parallelization is done.\n\nThe following routine is also defined in this module, which is called at\nevery step:\n\n* :func:`get_new_position` returns a new point in the parameter space,\n depending on the proposal density.\n\nThe :func:`chain` in turn calls several helper routines, defined in\n:mod:`sampler`. These are called just once:\n\n* :func:`compute_lkl() ` is called at every step in the Markov chain, returning\n the likelihood at the current point in the parameter space.\n* :func:`get_covariance_matrix() `\n* :func:`read_args_from_chain() `\n* :func:`read_args_from_bestfit() `\n* :func:`accept_step() `\n\nTheir usage is described in :mod:`sampler`. On the contrary, the following\nroutines are called at every step:\n\nThe arguments of these functions will often contain **data** and/or **cosmo**.\nThey are both initialized instances of respectively :class:`data` and the\ncosmological class. They will thus not be described for every function.\n\"\"\"\n\nimport os\nimport sys\nimport math\nimport random as rd\nimport numpy as np\nimport warnings\nimport scipy.linalg as la\nfrom pprint import pprint\n\nimport io_mp\nimport sampler\n\n\ndef get_new_position(data, eigv, U, k, Cholesky, Rotation):\n \"\"\"\n Obtain a new position in the parameter space from the eigen values of the\n inverse covariance matrix, or from the Cholesky decomposition (original\n idea by Anthony Lewis, in `Efficient sampling of fast and slow\n cosmological parameters `_ )\n\n The three different jumping options, decided when starting a run with the\n flag **-j** are **global**, **sequential** and **fast** (by default) (see\n :mod:`parser_mp` for reference).\n\n .. warning::\n\n For running Planck data, the option **fast** is highly recommended, as\n it speeds up the convergence. Note that when using this option, the\n list of your likelihoods in your parameter file **must match** the\n ordering of your nuisance parameters (as always, they must come after\n the cosmological parameters, but they also must be ordered between\n likelihood, with, preferentially, the slowest likelihood to compute\n coming first).\n\n\n - **global**: varies all the parameters at the same time. Depending on the\n input covariance matrix, some degeneracy direction will be followed,\n otherwise every parameter will jump independently of each other.\n - **sequential**: varies every parameter sequentially. Works best when\n having no clue about the covariance matrix, or to understand which\n estimated sigma is wrong and slowing down the whole process.\n - **fast**: privileged method when running the Planck likelihood. Described\n in the aforementioned article, it separates slow (cosmological) and fast\n (nuisance) parameters.\n\n Parameters\n ----------\n eigv : numpy array\n Eigenvalues previously computed\n U : numpy_array\n Covariance matrix.\n k : int\n Number of points so far in the chain, is used to rotate through\n parameters\n Cholesky : numpy array\n Cholesky decomposition of the covariance matrix, and its inverse\n Rotation : numpy_array\n Not used yet\n\n \"\"\"\n\n parameter_names = data.get_mcmc_parameters(['varying'])\n vector_new = np.zeros(len(parameter_names), 'float64')\n sigmas = np.zeros(len(parameter_names), 'float64')\n\n # Write the vector of last accepted points, or if it does not exist\n # (initialization routine), take the mean value\n vector = np.zeros(len(parameter_names), 'float64')\n try:\n for elem in parameter_names:\n vector[parameter_names.index(elem)] = \\\n data.mcmc_parameters[elem]['last_accepted']\n except KeyError:\n for elem in parameter_names:\n vector[parameter_names.index(elem)] = \\\n data.mcmc_parameters[elem]['initial'][0]\n\n # Initialize random seed\n rd.seed()\n\n # Choice here between sequential and global change of direction\n if data.jumping == 'global':\n for i in range(len(vector)):\n sigmas[i] = (math.sqrt(1/eigv[i]/len(vector))) * \\\n rd.gauss(0, 1)*data.jumping_factor\n elif data.jumping == 'sequential':\n i = k % len(vector)\n sigmas[i] = (math.sqrt(1/eigv[i]))*rd.gauss(0, 1)*data.jumping_factor\n elif data.jumping == 'fast':\n #i = k % len(vector)\n j = k % len(data.over_sampling_indices)\n i = data.over_sampling_indices[j]\n ###############\n # method fast+global\n for index, elem in enumerate(data.block_parameters):\n # When the running index is below the maximum index of a block of\n # parameters, this block is varied, and **only this one** (note the\n # break at the end of the if clause, it is not a continue)\n if i < elem:\n if index == 0:\n Range = elem\n Previous = 0\n else:\n Range = elem-data.block_parameters[index-1]\n Previous = data.block_parameters[index-1]\n # All the varied parameters are given a random variation with a\n # sigma of 1. This will translate in a jump for all the\n # parameters (as long as the Cholesky matrix is non diagonal)\n for j in range(Range):\n sigmas[j+Previous] = (math.sqrt(1./Range)) * \\\n rd.gauss(0, 1)*data.jumping_factor\n break\n else:\n continue\n else:\n print('\\n\\n Jumping method unknown (accepted : ')\n print('global, sequential, fast (default))')\n\n # Fill in the new vector\n if data.jumping in ['global', 'sequential']:\n vector_new = vector + np.dot(U, sigmas)\n else:\n vector_new = vector + np.dot(Cholesky, sigmas)\n\n # Check for boundaries problems\n flag = 0\n for i, elem in enumerate(parameter_names):\n value = data.mcmc_parameters[elem]['initial']\n if((str(value[1]) != str(-1) and value[1] is not None) and\n (vector_new[i] < value[1])):\n flag += 1 # if a boundary value is reached, increment\n elif((str(value[2]) != str(-1) and value[2] is not None) and\n vector_new[i] > value[2]):\n flag += 1 # same\n\n # At this point, if a boundary condition is not fullfilled, ie, if flag is\n # different from zero, return False\n if flag != 0:\n return False\n\n # Check for a slow step (only after the first time, so we put the test in a\n # try: statement: the first time, the exception KeyError will be raised)\n try:\n data.check_for_slow_step(vector_new)\n except KeyError:\n pass\n\n # If it is not the case, proceed with normal computation. The value of\n # new_vector is then put into the 'current' point in parameter space.\n for index, elem in enumerate(parameter_names):\n data.mcmc_parameters[elem]['current'] = vector_new[index]\n\n # Propagate the information towards the cosmo arguments\n data.update_cosmo_arguments()\n\n return True\n\n\n######################\n# MCMC CHAIN\n######################\ndef chain(cosmo, data, command_line):\n \"\"\"\n Run a Markov chain of fixed length with a Metropolis Hastings algorithm.\n\n Main function of this module, this is the actual Markov chain procedure.\n After having selected a starting point in parameter space defining the\n first **last accepted** one, it will, for a given amount of steps :\n\n + choose randomly a new point following the *proposal density*,\n + compute the cosmological *observables* through the cosmological module,\n + compute the value of the *likelihoods* of the desired experiments at this\n point,\n + *accept/reject* this point given its likelihood compared to the one of\n the last accepted one.\n\n Every time the code accepts :code:`data.write_step` number of points\n (quantity defined in the input parameter file), it will write the result to\n disk (flushing the buffer by forcing to exit the output file, and reopen it\n again.\n\n .. note::\n\n to use the code to set a fiducial file for certain fixed parameters,\n you can use two solutions. The first one is to put all input 1-sigma\n proposal density to zero (this method still works, but is not\n recommended anymore). The second one consist in using the flag \"-f 0\",\n to force a step of zero amplitude.\n\n \"\"\"\n\n ## Initialisation\n loglike = 0\n\n # In case command_line.silent has been asked, outputs should only contain\n # data.out. Otherwise, it will also contain sys.stdout\n outputs = [data.out]\n if not command_line.silent:\n outputs.append(sys.stdout)\n\n use_mpi = False\n # check for MPI\n try:\n from mpi4py import MPI\n comm = MPI.COMM_WORLD\n rank = comm.Get_rank()\n # suppress duplicate output from slaves\n if rank:\n command_line.quiet = True\n use_mpi = True\n except ImportError:\n # set all chains to master if no MPI\n rank = 0\n\n # Initialise master and slave chains for superupdate.\n # Workaround in order to have one master chain and several slave chains even when\n # communication fails between MPI chains. It could malfunction on some hardware.\n # TODO: Would like to merge with MPI initialization above and make robust and logical\n # TODO: Or if keeping current scheme, store value and delete jumping_factor.txt\n # TODO: automatically if --parallel-chains is enabled\n if command_line.superupdate and data.jumping_factor:\n try:\n jump_file = open(command_line.folder + '/jumping_factor.txt','r')\n #if command_line.restart is None:\n if not use_mpi and command_line.parallel_chains:\n rank = 1\n warnings.warn('MPI not in use, flag --parallel-chains enabled, '\n 'superupdate enabled, and a jumping_factor.txt file detected. '\n 'If relaunching in the same folder or restarting a run this '\n 'will cause all chains to be assigned as slaves. In this case '\n 'instead note the value in jumping_factor.txt, delete the '\n 'file, and pass the value with flag -f . This warning '\n 'may then appear again, but you can safely disregard it.')\n else:\n # For restart runs we want to save the input jumping factor\n # as starting jumping factor, but continue from the jumping\n # factor stored in the file.\n starting_jumping_factor = data.jumping_factor\n # This will load the value irrespective of whether it starts\n # with # (i.e. the jumping factor adaptation was started) or not.\n jump_value = jump_file.read().replace('# ','')\n data.jumping_factor = float(jump_value)\n jump_file.close()\n print('rank = ',rank)\n except:\n jump_file = open(command_line.folder + '/jumping_factor.txt','w')\n jump_file.write(str(data.jumping_factor))\n jump_file.close()\n rank = 0\n print('rank = ',rank)\n starting_jumping_factor = data.jumping_factor\n\n # Recover the covariance matrix according to the input, if the varying set\n # of parameters is non-zero\n if (data.get_mcmc_parameters(['varying']) != []):\n\n # Read input covariance matrix\n sigma_eig, U, C = sampler.get_covariance_matrix(cosmo, data, command_line)\n\n # if we want to compute the starting point by minimising lnL (instead of taking it from input file or bestfit file)\n minimum = 0\n if command_line.minimize:\n minimum, min_chi2 = sampler.get_minimum(cosmo, data, command_line, C)\n\n parameter_names = data.get_mcmc_parameters(['last_accepted'])\n for index,elem in parameter_names:\n data.mcmc_parameters[elem]['last_accepted'] = minimum[index]\n\n #FK: write out the results of the minimzer:\n labels = data.get_mcmc_parameters(['varying'])\n fname = os.path.join(command_line.folder, 'results.minimized')\n with open(fname, 'w') as f:\n f.write('# minimized \\chi^2 = {:} \\n'.format(min_chi2))\n f.write('# %s\\n' % ', '.join(['%16s' % label for label in labels]))\n for idx in range(len(labels)):\n bf_value = minimum[idx]\n if bf_value > 0:\n f.write(' %.6e\\t' % bf_value)\n else:\n f.write('%.6e\\t' % bf_value)\n f.write('\\n')\n print('Results of minimizer saved to: \\n', fname)\n\n # if we want to compute Fisher matrix and then stop\n if command_line.fisher:\n sampler.get_fisher_matrix(cosmo, data, command_line, C, minimum)\n return\n\n # warning if no jumps are requested\n if data.jumping_factor == 0:\n warnings.warn(\n \"The jumping factor has been set to 0. The above covariance \" +\n \"matrix will not be used.\")\n\n # In case of a fiducial run (all parameters fixed), simply run once and\n # print out the likelihood. This should not be used any more (one has to\n # modify the log.param, which is never a good idea. Instead, force the code\n # to use a jumping factor of 0 with the option \"-f 0\".\n else:\n warnings.warn(\n \"You are running with no varying parameters... I will compute \" +\n \"only one point and exit\")\n data.update_cosmo_arguments() # this fills in the fixed parameters\n loglike = sampler.compute_lkl(cosmo, data)\n io_mp.print_vector(outputs, 1, loglike, data)\n return 1, loglike\n\n # In the fast-slow method, one need the Cholesky decomposition of the\n # covariance matrix. Return the Cholesky decomposition as a lower\n # triangular matrix\n Cholesky = None\n Rotation = None\n if command_line.jumping == 'fast':\n Cholesky = la.cholesky(C).T\n Rotation = np.identity(len(sigma_eig))\n\n # define path and covmat\n input_covmat = command_line.cov\n base = os.path.basename(command_line.folder)\n # the previous line fails when \"folder\" is a string ending with a slash. This issue is cured by the next lines:\n if base == '':\n base = os.path.basename(command_line.folder[:-1])\n command_line.cov = os.path.join(\n command_line.folder, base+'.covmat')\n\n # Fast Parameter Multiplier (fpm) for adjusting update and superupdate numbers.\n # This is equal to N_slow + f_fast N_fast, where N_slow is the number of slow\n # parameters, f_fast is the over sampling number for each fast block and f_fast\n # is the number of parameters in each fast block.\n for i in range(len(data.block_parameters)):\n if i == 0:\n fpm = data.over_sampling[i]*data.block_parameters[i]\n else:\n fpm += data.over_sampling[i]*(data.block_parameters[i] - data.block_parameters[i-1])\n\n # If the update mode was selected, the previous (or original) matrix should be stored\n if command_line.update:\n if not rank and not command_line.silent:\n print('Update routine is enabled with value %d (recommended: 50)' % command_line.update)\n print('This number is rescaled by cycle length %d (N_slow + f_fast * N_fast) to %d' % (fpm,fpm*command_line.update))\n # Rescale update number by cycle length N_slow + f_fast * N_fast to account for fast parameters\n command_line.update *= fpm\n previous = (sigma_eig, U, C, Cholesky)\n\n # Initialise adaptive\n if command_line.adaptive:\n if not command_line.silent:\n print('Adaptive routine is enabled with value %d (recommended: 10*dimension)' % command_line.adaptive)\n print('and adaptive_ts = %d (recommended: 100*dimension)' % command_line.adaptive_ts)\n print('Please note: current implementation not suitable for multiple chains')\n if rank > 0:\n raise io_mp.ConfigurationError('Adaptive routine not compatible with MPI')\n if command_line.update:\n warnings.warn('Adaptive routine not compatible with update, overwriting input update value')\n if command_line.superupdate:\n warnings.warn('Adaptive routine not compatible with superupdate, deactivating superupdate')\n command_line.superupdate = 0\n # Define needed parameters\n parameter_names = data.get_mcmc_parameters(['varying'])\n mean = np.zeros(len(parameter_names))\n last_accepted = np.zeros(len(parameter_names),'float64')\n ar = np.zeros(100)\n if command_line.cov == None:\n # If no input covmat was given, the starting jumping factor\n # should be very small until a covmat is obtained and the\n # original start jumping factor should be saved\n start_jumping_factor = command_line.jumping_factor\n data.jumping_factor = command_line.jumping_factor/100.\n # Analyze module will be forced to compute one covmat,\n # after which update flag will be set to False.\n command_line.update = command_line.adaptive\n else:\n # If an input covmat was provided, take mean values from param file\n # Question: is it better to always do this, rather than setting mean\n # to last accepted after the initial update run?\n for elem in parameter_names:\n mean[parameter_names.index(elem)] = data.mcmc_parameters[elem]['initial'][0]\n\n # Initialize superupdate\n if command_line.superupdate:\n if not rank and not command_line.silent:\n print('Superupdate routine is enabled with value %d (recommended: 20)' % command_line.superupdate)\n if command_line.superupdate < 20:\n warnings.warn('Superupdate value lower than the recommended value. This '\n 'may increase the risk of poorly converged acceptance rate')\n print('This number is rescaled by cycle length %d (N_slow + f_fast * N_fast) to %d' % (fpm,fpm*command_line.superupdate))\n # Rescale superupdate number by cycle length N_slow + f_fast * N_fast to account for fast parameters\n command_line.superupdate *= fpm\n # Define needed parameters\n parameter_names = data.get_mcmc_parameters(['varying'])\n updated_steps = 0\n stop_c = False\n jumping_factor_rescale = 0\n if command_line.restart:\n try:\n jump_file = open(command_line.cov,'r')\n jumping_factor_rescale = 1\n except:\n jumping_factor_rescale = 0\n c_array = np.zeros(command_line.superupdate) # Allows computation of mean of jumping factor\n R_minus_one = np.array([100.,100.]) # 100 to make sure max(R-1) value is high if computation failed\n # Local acceptance rate of last SU*(N_slow + f_fast * N_fast) steps\n ar = np.zeros(command_line.superupdate)\n # Store acceptance rate of last 5*SU*(N_slow + f_fast * N_fast) steps\n backup_ar = np.zeros(5*command_line.superupdate)\n # Make sure update is enabled\n if command_line.update == 0:\n if not rank and not command_line.silent:\n print('Update routine required by superupdate. Setting --update 50')\n print('This number is then rescaled by cycle length: %d (N_slow + f_fast * N_fast)' % fpm)\n command_line.update = 50 * fpm\n previous = (sigma_eig, U, C, Cholesky)\n\n # If restart wanted, pick initial value for arguments\n if command_line.restart is not None:\n sampler.read_args_from_chain(data, command_line.restart)\n\n # If restart from best fit file, read first point (overwrite settings of\n # read_args_from_chain)\n if command_line.bf is not None and not command_line.minimize:\n sampler.read_args_from_bestfit(data, command_line.bf)\n\n # Pick a position (from last accepted point if restart, from the mean value\n # else), with a 100 tries.\n for i in range(100):\n if get_new_position(data, sigma_eig, U, i,\n Cholesky, Rotation) is True:\n break\n if i == 99:\n raise io_mp.ConfigurationError(\n \"You should probably check your prior boundaries... because \" +\n \"no valid starting position was found after 100 tries\")\n\n # Compute the starting Likelihood\n loglike = sampler.compute_lkl(cosmo, data)\n\n # Choose this step as the last accepted value\n # (accept_step), and modify accordingly the max_loglike\n sampler.accept_step(data)\n max_loglike = loglike\n\n # If the jumping factor is 0, the likelihood associated with this point is\n # displayed, and the code exits.\n if data.jumping_factor == 0:\n io_mp.print_vector(outputs, 1, loglike, data)\n return 1, loglike\n\n acc, rej = 0.0, 0.0 # acceptance and rejection number count\n N = 1 # number of time the system stayed in the current position\n\n # Print on screen the computed parameters\n if not command_line.silent and not command_line.quiet:\n io_mp.print_parameters(sys.stdout, data)\n\n # Suppress non-informative output after initializing\n command_line.quiet = True\n\n k = 1\n # Main loop, that goes on while the maximum number of failure is not\n # reached, and while the expected amount of steps (N) is not taken.\n while k <= command_line.N:\n # If the number of steps reaches the number set in the adaptive method plus one,\n # then the proposal distribution should be gradually adapted.\n # If the number of steps also exceeds the number set in adaptive_ts,\n # the jumping factor should be gradually adapted.\n if command_line.adaptive and k>command_line.adaptive+1:\n # Start of adaptive routine\n # By B. Schroer and T. Brinckmann\n # Modified version of the method outlined in the PhD thesis of Marta Spinelli\n\n # Store last accepted step\n for elem in parameter_names:\n last_accepted[parameter_names.index(elem)] = data.mcmc_parameters[elem]['last_accepted']\n # Recursion formula for mean and covmat (and jumping factor after ts steps)\n # mean(k) = mean(k-1) + (last_accepted - mean(k-1))/k\n mean += 1./k*(last_accepted-mean)\n # C(k) = C(k-1) + [(last_accepted - mean(k))^T * (last_accepted - mean(k)) - C(k-1)]/k\n C +=1./k*(np.dot(np.transpose(np.asmatrix(last_accepted-mean)),np.asmatrix(last_accepted-mean))-C)\n sigma_eig, U = np.linalg.eig(np.linalg.inv(C))\n if command_line.jumping == 'fast':\n Cholesky = la.cholesky(C).T\n if k>command_line.adaptive_ts:\n # c = j^2/d\n c = data.jumping_factor**2/len(parameter_names)\n # c(k) = c(k-1) + [acceptance_rate(last 100 steps) - 0.25]/k\n c +=(np.mean(ar)-0.25)/k\n data.jumping_factor = np.sqrt(len(parameter_names)*c)\n\n # Save the covariance matrix and the jumping factor in a file\n # For a possible MPI implementation\n #if not (k-command_line.adaptive) % 5:\n # io_mp.write_covariance_matrix(C,parameter_names,str(command_line.cov))\n # jump_file = open(command_line.folder + '/jumping_factor.txt','w')\n # jump_file.write(str(data.jumping_factor))\n # jump_file.close()\n # End of adaptive routine\n\n # If the number of steps reaches the number set in the update method,\n # then the proposal distribution should be adapted.\n if command_line.update:\n # Start of update routine\n # By M. Ballardini and T. Brinckmann\n # Also used by superupdate and adaptive\n\n # master chain behavior\n if not rank:\n # Add the folder to the list of files to analyze, and switch on the\n # options for computing only the covmat\n from parser_mp import parse\n info_command_line = parse(\n 'info %s --minimal --noplot --keep-fraction 0.5 --keep-non-markovian --want-covmat' % command_line.folder)\n info_command_line.update = command_line.update\n\n if command_line.adaptive:\n # Keep all points for covmat guess in adaptive\n info_command_line = parse('info %s --minimal --noplot --keep-non-markovian --want-covmat' % command_line.folder)\n # Tell the analysis to update the covmat after t0 steps if it is adaptive\n info_command_line.adaptive = command_line.adaptive\n # Only compute covmat if no input covmat was provided\n if input_covmat != None:\n info_command_line.want_covmat = False\n\n # This is in order to allow for more frequent R-1 computation with superupdate\n compute_R_minus_one = False\n if command_line.superupdate:\n if not (k+10) % command_line.superupdate:\n compute_R_minus_one = True\n # the +10 below is here to ensure that the first master update will take place before the first slave updates,\n # but this is a detail, the code is robust against situations where updating is not possible, so +10 could be omitted\n if (not (k+10) % command_line.update or compute_R_minus_one) and k > 10:\n # Try to launch an analyze (computing a new covmat if successful)\n try:\n if not (k+10) % command_line.update:\n from .analyze import analyze\n R_minus_one = analyze(info_command_line)\n elif command_line.superupdate:\n # Compute (only, i.e. no covmat) R-1 more often when using superupdate\n info_command_line = parse(\n 'info %s --minimal --noplot --keep-fraction 0.5 --keep-non-markovian' % command_line.folder)\n info_command_line.update = command_line.update\n R_minus_one = analyze(info_command_line)\n except:\n if not command_line.silent:\n print('Step ',k,' chain ', rank,': Failed to calculate covariance matrix')\n\n if command_line.superupdate:\n # Start of superupdate routine\n # By B. Schroer and T. Brinckmann\n\n c_array[(k-1)%(command_line.superupdate)] = data.jumping_factor\n\n # If acceptance rate deviates too much from the target acceptance\n # rate we want to resume adapting the jumping factor\n # T. Brinckmann 02/2019: use mean a.r. over the last 5*len(ar) steps\n # instead or the over last len(ar), which is more stable\n if abs(np.mean(backup_ar) - command_line.superupdate_ar) > 5.*command_line.superupdate_ar_tol:\n stop_c = False\n\n # Start adapting the jumping factor after command_line.superupdate steps if R-1 < 10\n # The lower R-1 criterium is an arbitrary choice to keep from updating when the R-1\n # calculation fails (i.e. returns only zeros).\n if (k > updated_steps + command_line.superupdate) and 0.01 < (max(R_minus_one) < 10.) and not stop_c:\n c = data.jumping_factor**2/len(parameter_names)\n # To avoid getting trapped in local minima, the jumping factor should\n # not go below 0.1 (arbitrary) times the starting jumping factor.\n if (c + (np.mean(ar) - command_line.superupdate_ar)/(k - updated_steps)) > (0.1*starting_jumping_factor)**2./len(parameter_names) or ((np.mean(ar) - command_line.superupdate_ar)/(k - updated_steps) > 0):\n c += (np.mean(ar) - command_line.superupdate_ar)/(k - updated_steps)\n data.jumping_factor = np.sqrt(len(parameter_names) * c)\n\n if not (k-1) % 5:\n # Check if the jumping factor adaptation should stop.\n # An acceptance rate of 25% balances the wish for more accepted\n # points, while ensuring the parameter space is properly sampled.\n # The convergence criterium is by default (26+/-1)%, so the adaptation\n # will stop when the code reaches an acceptance rate of at least 25%.\n # T. Brinckmann 02/2019: use mean a.r. over the last 5*len(ar) steps\n # instead or the over last len(ar), which is more stable\n if (max(R_minus_one) < 0.4) and (abs(np.mean(backup_ar) - command_line.superupdate_ar) < command_line.superupdate_ar_tol) and (abs(np.mean(c_array)/c_array[(k-1) % (command_line.superupdate)] - 1) < 0.01):\n stop_c = True\n data.out.write('# After %d accepted steps: stop adapting the jumping factor at a value of %f with a local acceptance rate %f \\n' % (int(acc),data.jumping_factor,np.mean(backup_ar)))\n if not command_line.silent:\n print('After %d accepted steps: stop adapting the jumping factor at a value of %f with a local acceptance rate of %f \\n' % (int(acc), data.jumping_factor,np.mean(backup_ar)))\n jump_file = open(command_line.folder + '/jumping_factor.txt','w')\n jump_file.write('# '+str(data.jumping_factor))\n jump_file.close()\n else:\n jump_file = open(command_line.folder + '/jumping_factor.txt','w')\n jump_file.write(str(data.jumping_factor))\n jump_file.close()\n\n # Write the evolution of the jumping factor to a file\n if not k % (command_line.superupdate):\n jump_file = open(command_line.folder + '/jumping_factors.txt','a')\n for i in range(command_line.superupdate):\n jump_file.write(str(c_array[i])+'\\n')\n jump_file.close()\n # End of main part of superupdate routine\n\n if not (k-1) % (command_line.update/3):\n try:\n # Read the covmat\n sigma_eig, U, C = sampler.get_covariance_matrix(\n cosmo, data, command_line)\n if command_line.jumping == 'fast':\n Cholesky = la.cholesky(C).T\n # Test here whether the covariance matrix has really changed\n # We should in principle test all terms, but testing the first one should suffice\n if not C[0,0] == previous[2][0,0]:\n if k == 1:\n if not command_line.silent:\n if not input_covmat == None:\n warnings.warn(\n 'Appending to an existing folder: using %s instead of %s. '\n 'If new input covmat is desired, please delete previous covmat.'\n % (command_line.cov, input_covmat))\n else:\n warnings.warn(\n 'Appending to an existing folder: using %s. '\n 'If no starting covmat is desired, please delete previous covmat.'\n % command_line.cov)\n else:\n # Start of second part of superupdate routine\n if command_line.superupdate:\n # Adaptation of jumping factor should start again after the covmat is updated\n # Save the step number after it updated for superupdate and start adaption of c again\n updated_steps = k\n stop_c = False\n cov_det = np.linalg.det(C)\n prev_cov_det = np.linalg.det(previous[2])\n # Rescale jumping factor in order to keep the magnitude of the jumps the same.\n # Skip this update the first time the covmat is updated in order to prevent\n # problems due to a poor initial covmat. Rescale the jumping factor after the\n # first calculated covmat to the expected optimal one of 2.4.\n if jumping_factor_rescale:\n new_jumping_factor = data.jumping_factor * (prev_cov_det/cov_det)**(1./(2 * len(parameter_names)))\n data.out.write('# After %d accepted steps: rescaled jumping factor from %f to %f, due to updated covariance matrix \\n' % (int(acc), data.jumping_factor, new_jumping_factor))\n if not command_line.silent:\n print('After %d accepted steps: rescaled jumping factor from %f to %f, due to updated covariance matrix \\n' % (int(acc), data.jumping_factor, new_jumping_factor))\n data.jumping_factor = new_jumping_factor\n else:\n data.jumping_factor = starting_jumping_factor\n jumping_factor_rescale += 1\n # End of second part of superupdate routine\n\n # Write to chains file when the covmat was updated\n data.out.write('# After %d accepted steps: update proposal with max(R-1) = %f and jumping factor = %f \\n' % (int(acc), max(R_minus_one), data.jumping_factor))\n if not command_line.silent:\n print('After %d accepted steps: update proposal with max(R-1) = %f and jumping factor = %f \\n' % (int(acc), max(R_minus_one), data.jumping_factor))\n try:\n if stop_after_update:\n k = command_line.N\n print('Covariance matrix updated - stopping run')\n except:\n pass\n\n previous = (sigma_eig, U, C, Cholesky)\n except:\n pass\n\n command_line.quiet = True\n\n # Start of second part of adaptive routine\n # Stop updating the covmat after t0 steps in adaptive\n if command_line.adaptive and k > 1:\n command_line.update = 0\n data.jumping_factor = start_jumping_factor\n # Test if there are still enough steps left before the adaption of the jumping factor starts\n if k > 0.5*command_line.adaptive_ts:\n command_line.adaptive_ts += k\n # Set the mean for the recursion formula to the last accepted point\n for elem in parameter_names:\n mean[parameter_names.index(elem)] = data.mcmc_parameters[elem]['last_accepted']\n # End of second part of adaptive routine\n\n # slave chain behavior\n else:\n # Start of slave superupdate routine\n if command_line.superupdate:\n # If acceptance rate deviates too much from the target acceptance\n # rate we want to resume adapting the jumping factor. This line\n # will force the slave chains to check if the jumping factor\n # has been updated\n if abs(np.mean(backup_ar) - command_line.superupdate_ar) > 5.*command_line.superupdate_ar_tol:\n stop_c = False\n\n # Update the jumping factor every 5 steps in superupdate\n if not k % 5 and k > command_line.superupdate and command_line.superupdate and (not stop_c or (stop_c and k % command_line.update)):\n try:\n jump_file = open(command_line.folder + '/jumping_factor.txt','r')\n # If there is a # in the file, the master has stopped adapting c\n for line in jump_file:\n if line.find('#') == -1:\n jump_file.seek(0)\n jump_value = jump_file.read()\n data.jumping_factor = float(jump_value)\n else:\n jump_file.seek(0)\n jump_value = jump_file.read().replace('# ','')\n #if not stop_c or (stop_c and not float(jump_value) == data.jumping_factor):\n if not float(jump_value) == data.jumping_factor:\n data.jumping_factor = float(jump_value)\n stop_c = True\n data.out.write('# After %d accepted steps: stop adapting the jumping factor at a value of %f with a local acceptance rate %f \\n' % (int(acc),data.jumping_factor,np.mean(backup_ar)))\n if not command_line.silent:\n print('After %d accepted steps: stop adapting the jumping factor at a value of %f with a local acceptance rate of %f \\n' % (int(acc), data.jumping_factor,np.mean(backup_ar)))\n jump_file.close()\n except:\n if not command_line.silent:\n print('Reading jumping_factor file failed')\n pass\n # End of slave superupdate routine\n\n # Start of slave update routine\n if not (k-1) % (command_line.update/10):\n try:\n sigma_eig, U, C = sampler.get_covariance_matrix(\n cosmo, data, command_line)\n if command_line.jumping == 'fast':\n Cholesky = la.cholesky(C).T\n # Test here whether the covariance matrix has really changed\n # We should in principle test all terms, but testing the first one should suffice\n if not C[0,0] == previous[2][0,0] and not k == 1:\n if command_line.superupdate:\n # If the covmat was updated, the master has resumed adapting c\n stop_c = False\n data.out.write('# After %d accepted steps: update proposal \\n' % int(acc))\n if not command_line.silent:\n print('After %d accepted steps: update proposal \\n' % int(acc))\n try:\n if stop_after_update:\n k = command_line.N\n print('Covariance matrix updated - stopping run')\n except:\n pass\n previous = (sigma_eig, U, C, Cholesky)\n\n except:\n pass\n # End of slave update routine\n # End of update routine\n\n # Pick a new position ('current' flag in mcmc_parameters), and compute\n # its likelihood. If get_new_position returns True, it means it did not\n # encounter any boundary problem. Otherwise, just increase the\n # multiplicity of the point and start the loop again\n if get_new_position(\n data, sigma_eig, U, k, Cholesky, Rotation) is True:\n newloglike = sampler.compute_lkl(cosmo, data)\n else: # reject step\n rej += 1\n if command_line.superupdate:\n ar[k%len(ar)] = 0 # Local acceptance rate of last SU*(N_slow + f_fast * N_fast) steps\n elif command_line.adaptive:\n ar[k%len(ar)] = 0 # Local acceptance rate of last 100 steps\n N += 1\n k += 1\n continue\n\n # Harmless trick to avoid exponentiating large numbers. This decides\n # whether or not the system should move.\n if (newloglike != data.boundary_loglike):\n if (newloglike >= loglike):\n alpha = 1.\n else:\n alpha = np.exp(newloglike-loglike)\n else:\n alpha = -1\n\n if ((alpha == 1.) or (rd.uniform(0, 1) < alpha)): # accept step\n\n # Print out the last accepted step (WARNING: this is NOT the one we\n # just computed ('current' flag), but really the previous one.)\n # with its proper multiplicity (number of times the system stayed\n # there).\n io_mp.print_vector(outputs, N, loglike, data)\n\n # Report the 'current' point to the 'last_accepted'\n sampler.accept_step(data)\n loglike = newloglike\n if loglike > max_loglike:\n max_loglike = loglike\n acc += 1.0\n N = 1 # Reset the multiplicity\n if command_line.superupdate:\n ar[k%len(ar)] = 1 # Local acceptance rate of last SU*(N_slow + f_fast * N_fast) steps\n elif command_line.adaptive:\n ar[k%len(ar)] = 1 # Local acceptance rate of last 100 steps\n else: # reject step\n rej += 1.0\n N += 1 # Increase multiplicity of last accepted point\n if command_line.superupdate:\n ar[k%len(ar)] = 0 # Local acceptance rate of last SU*(N_slow + f_fast * N_fast) steps\n elif command_line.adaptive:\n ar[k%len(ar)] = 0 # Local acceptance rate of last 100 steps\n\n # Store a.r. for last 5 x SU*(N_slow + f_fast * N_fast) steps\n if command_line.superupdate:\n backup_ar[k%len(backup_ar)] = ar[k%len(ar)]\n\n # Regularly (option to set in parameter file), close and reopen the\n # buffer to force to write on file.\n if acc % data.write_step == 0:\n io_mp.refresh_file(data)\n # Update the outputs list\n outputs[0] = data.out\n k += 1 # One iteration done\n # END OF WHILE LOOP\n\n # If at this moment, the multiplicity is higher than 1, it means the\n # current point is not yet accepted, but it also mean that we did not print\n # out the last_accepted one yet. So we do.\n if N > 1:\n io_mp.print_vector(outputs, N-1, loglike, data)\n\n # Print out some information on the finished chain\n rate = acc / (acc + rej)\n sys.stdout.write('\\n# {0} steps done, acceptance rate: {1}\\n'.\n format(command_line.N, rate))\n\n # In case the acceptance rate is too low, or too high, print a warning\n if rate < 0.05:\n warnings.warn(\"The acceptance rate is below 0.05. You might want to \"\n \"set the jumping factor to a lower value than the \"\n \"default (2.4), with the option `-f 1.5` for instance.\")\n elif rate > 0.6:\n warnings.warn(\"The acceptance rate is above 0.6, which means you might\"\n \" have difficulties exploring the entire parameter space\"\n \". Try analysing these chains, and use the output \"\n \"covariance matrix to decrease the acceptance rate to a \"\n \"value between 0.2 and 0.4 (roughly).\")\n # For a restart, erase the starting point to keep only the new, longer\n # chain.\n if command_line.restart is not None:\n os.remove(command_line.restart)\n sys.stdout.write(' deleting starting point of the chain {0}\\n'.\n format(command_line.restart))\n\n return\n", "meta": {"hexsha": "72ef4e3192cfd2028e0952ae6cd345b119947cf0", "size": 45588, "ext": "py", "lang": "Python", "max_stars_repo_path": "montepython/mcmc.py", "max_stars_repo_name": "ivandebono/montepython_public_3.2dev_Python3", "max_stars_repo_head_hexsha": "16771c3d37faaa3f80b171c01d78da56a75aa3d9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "montepython/mcmc.py", "max_issues_repo_name": "ivandebono/montepython_public_3.2dev_Python3", "max_issues_repo_head_hexsha": "16771c3d37faaa3f80b171c01d78da56a75aa3d9", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "montepython/mcmc.py", "max_forks_repo_name": "ivandebono/montepython_public_3.2dev_Python3", "max_forks_repo_head_hexsha": "16771c3d37faaa3f80b171c01d78da56a75aa3d9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 52.3398392652, "max_line_length": 233, "alphanum_fraction": 0.5793849259, "include": true, "reason": "import numpy,import scipy", "num_tokens": 9573, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6619228758499942, "lm_q2_score": 0.2909808600663598, "lm_q1q2_score": 0.19260688771242962}} {"text": "import matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\nimport astropy.units as u\nimport math\nfrom eventio.simtel.simtelfile import SimTelFile\nfrom .plot_utils import sens_plot, sens_minimization_plot, plot_positions_survived_events\nfrom .mc import rate, weight, power_law_integrated_distribution\nfrom lstchain.spectra.crab import crab_hegra, crab_magic\nfrom lstchain.spectra.proton import proton_bess\nfrom gammapy.stats.poisson import excess_matching_significance_on_off\nfrom lstchain.reco.utils import reco_source_position_sky\nfrom astropy.coordinates.angle_utilities import angular_separation\nfrom astropy.coordinates import SkyCoord\nfrom lstchain.io import read_simu_info_merged_hdf5\nfrom lstchain.reco import dl1_to_dl2\n\nfrom lstchain.reco import dl1_to_dl2\n\n__all__ = ['read_sim_par',\n 'process_mc',\n 'calculate_sensitivity',\n 'calculate_sensitivity_lima',\n 'calculate_sensitivity_lima_1d',\n 'bin_definition',\n 'ring_containment',\n 'find_best_cuts_sens',\n 'sens',\n ]\n\ndef read_sim_par(dl1_file):\n \"\"\"\n Read MC simulated parameters\n\n Parameters\n ---------\n source: simtelarray file\n\n Returns\n ---------\n par: `dict` with simulated parameters\n\n \"\"\"\n simu_info = read_simu_info_merged_hdf5(dl1_file)\n emin = simu_info.energy_range_min\n emax = simu_info.energy_range_max\n sp_idx = simu_info.spectral_index\n sim_ev = simu_info.num_showers * simu_info.shower_reuse\n area_sim = (simu_info.max_scatter_range - simu_info.min_scatter_range)**2 * np.pi\n cone = simu_info.max_viewcone_radius\n\n par_var = [emin, emax, sp_idx, sim_ev, area_sim, cone]\n par_dic = ['emin', 'emax', 'sp_idx', 'sim_ev', 'area_sim', 'cone']\n par = dict(zip(par_dic, par_var))\n\n return par\n\ndef process_mc(dl1_file, dl2_file, mc_type):\n \"\"\"\n Process the MC simulated and reconstructed to extract the relevant\n parameters to compute the sensitivity\n\n Paramenters\n ---------\n simtel: simtelarray file\n dl2_file: `pandas.DataFrame` dl2 parameters\n mc_type: 'string' type of particle\n\n Returns\n ---------\n gammaness: `numpy.ndarray`\n angdist2: `numpy.ndarray` angular distance squared\n e_reco: `numpy.ndarray` reconstructed energies\n n_reco: `int` number of reconstructed events\n mc_par: `dict` with simulated parameters\n\n \"\"\"\n sim_par = read_sim_par(dl1_file)\n events = pd.read_hdf(dl2_file)\n\n #Filters:\n\n filter_good_events = (events.leakage < 0.2) & \\\n (events.intensity > np.log10(200)) & \\\n (events.wl > 0.1) & \\\n (events.tel_id==1)\n\n events = events[filter_good_events]\n\n e_reco = 10**events.mc_energy.to_numpy() * u.GeV\n e_true = 10**events.mc_energy.to_numpy() * u.GeV\n\n gammaness = events.gammaness\n\n #Get source position in radians\n\n #focal_length = source.telescope_descriptions[1]['camera_settings']['focal_length'] * u.m\n focal_length = 28 * u.m\n\n # If the particle is a gamma ray, it returns the squared angular distance\n # from the reconstructed gamma-ray position and the simulated incoming position\n if mc_type=='gamma':\n events = events[events.mc_type==0]\n alt2 = events.mc_alt\n az2 = np.arctan(np.tan(events.mc_az))\n\n # If the particle is not a gamma-ray (diffuse protons/electrons), it returns\n # the squared angular distance of the reconstructed position w.r.t. the\n # center of the camera\n else:\n events = events[events.mc_type!=0]\n alt2 = events.mc_alt_tel\n az2 = np.arctan(np.tan(events.mc_az_tel))\n\n src_pos_reco = reco_source_position_sky(events.x.values * u.m,\n events.y.values * u.m,\n events.reco_disp_dx.values * u.m,\n events.reco_disp_dy.values * u.m,\n focal_length,\n events.mc_alt_tel.values * u.rad,\n events.mc_az_tel.values * u.rad)\n\n alt1 = src_pos_reco.alt.rad\n az1 = np.arctan(np.tan(src_pos_reco.az.rad))\n\n angdist2 = (angular_separation(az1, alt1, az2, alt2).to_numpy() * u.rad)**2\n events['theta2'] = angdist2\n\n return gammaness, angdist2.to(u.deg**2), e_reco, e_true, sim_par, events\n\n\ndef calculate_sensitivity(nex, nbg, alpha):\n \"\"\"\n Sensitivity calculation using nex/sqrt(nbg)\n\n Parameters\n ---------\n nex: `float` number of excess events in the signal region\n nbg: `float` number of events in the background region\n alpha: `float` inverse of the number of off positions\n\n Returns\n ---------\n sens: `float` in percentage of Crab units\n \"\"\"\n significance = nex / np.sqrt(nbg * alpha)\n sens = 5 / significance * 100 # percentage of Crab\n\n return sens\n\ndef calculate_sensitivity_lima(nex, nbg, alpha, eb, gb, tb):\n \"\"\"\n Sensitivity calculation using the Li & Ma formula\n eq. 17 of Li & Ma (1983).\n https://ui.adsabs.harvard.edu/abs/1983ApJ...272..317L/abstract\n\n Parameters\n ---------\n nex: `float` number of excess events in the signal region\n nbg: `float` number of events in the background region\n alpha: `float` inverse of the number of off positions\n\n Returns\n ---------\n sens: `float` in percentage of Crab units\n \"\"\"\n nex_5sigma = excess_matching_significance_on_off(\\\n n_off=nbg,alpha=alpha,significance=5,method='lima')\n\n for i in range(0, eb):\n for j in range(0, gb):\n for k in range(0, tb):\n if nex_5sigma[i][j][k] < 10:\n nex_5sigma[i][j][k] = 10\n if nex_5sigma[i,j,k] < 0.05 * nbg[i][j][k]/5:\n nex_5sigma[i,j,k] = 0.05 * nbg[i][j][k]/5\n\n sens = nex_5sigma / nex * 100 # percentage of Crab\n\n return nex_5sigma, sens\n\ndef calculate_sensitivity_lima_1d(nex, nbg, alpha, eb):\n \"\"\"\n Sensitivity calculation using the Li & Ma formula\n eq. 17 of Li & Ma (1983).\n https://ui.adsabs.harvard.edu/abs/1983ApJ...272..317L/abstract\n\n Parameters\n ---------\n nex: `float` number of excess events in the signal region\n nbg: `float` number of events in the background region\n alpha: `float` inverse of the number of off positions\n\n Returns\n ---------\n sens: `float` in percentage of Crab units\n \"\"\"\n nex_5sigma = excess_matching_significance_on_off(\\\n n_off=nbg,alpha=alpha,significance=5,method='lima')\n\n for i in range(0, eb):\n if nex_5sigma[i] < 10:\n nex_5sigma[i] = 10\n if nex_5sigma[i] < 0.05 * nbg[i]/5:\n nex_5sigma[i] = 0.05 * nbg[i]/5\n\n sens = nex_5sigma / nex * 100 # percentage of Crab\n\n return nex_5sigma, sens\n\ndef bin_definition(gb, tb):\n \"\"\"\n Define binning in gammaness and theta2 for the\n optimization of the sensitivity\n\n Parameters\n ---------\n gb: `int` number of bins in gammaness\n tb: `int` number of bins in theta2\n\n Returns\n ---------\n g, t: `numpy.ndarray` binning of gammaness and theta2\n \"\"\"\n max_gam = 1\n max_th2 = 0.05 * u.deg * u.deg\n min_th2 = 0.005 * u.deg * u.deg\n\n g = np.linspace(0, max_gam, gb)\n t = np.linspace(min_th2, max_th2, tb)\n\n ####TEST####\n #g = np.full(gb, 0.0)\n #t = np.linspace(10*u.deg*u.deg, 10*u.deg*u.deg, tb)\n ###########\n \n return g, t\n\ndef ring_containment(angdist2, ring_radius, ring_halfwidth):\n \"\"\"\n Calculate containment of cosmic ray particles with reconstructed positions\n within a ring of radius=ring_radius and half width=ring_halfwidth\n Parameters\n ---------\n angdist2: `numpy.ndarray` angular distance squared w.r.t.\n the center of the camera\n ring_radius: `float` ring radius\n ring_halfwidth: `float` halfwidth of the ring\n\n Returns\n ---------\n contained: `numpy.ndarray` bool array\n area: angular area of the ring\n \"\"\"\n ring_lower_limit = ring_radius - ring_halfwidth\n ring_upper_limit = np.sqrt(2 * (ring_radius**2) - (ring_lower_limit)**2)\n\n area = np.pi * (ring_upper_limit**2 - ring_lower_limit**2)\n # For the two halfwidths to cover the same area, compute the area of\n # the internal and external rings:\n # A_internal = pi * ((ring_radius**2) - (ring_lower_limit)**2)\n # A_external = pi * ((ring_upper_limit**2) - (ring_radius)**2)\n # The areas should be equal, so we can extract the ring_upper_limit\n # ring_upper_limit = math.sqrt(2 * (ring_radius**2) - (ring_lower_limit)**2)\n\n contained = np.where((np.sqrt(angdist2) < ring_upper_limit) & (np.sqrt(angdist2) > ring_lower_limit), True, False)\n\n return contained, area\n\ndef find_best_cuts_sens(simtelfile_gammas, simtelfile_protons,\n dl2_file_g, dl2_file_p,\n nfiles_gammas, nfiles_protons,\n eb, gb, tb, noff,\n obstime = 50 * 3600 * u.s):\n \"\"\"\n Main function to calculate the sensitivity given a MC dataset\n\n Parameters\n ---------\n simtelfile_gammas: `string` path to simtelfile of gammas with mc info\n simtelfile_protons: `string` path to simtelfile of protons with mc info\n dl2_file_g: `string` path to h5 file of reconstructed gammas\n dl2_file_p: `string' path to h5 file of reconstructed protons\n nfiles_gammas: `int` number of simtel gamma files reconstructed\n nfiles_protons: `int` number of simtel proton files reconstructed\n eb: `int` number of bins in energy\n gb: `int` number of bins in gammaness\n tb: `int` number of bins in theta2\n noff: `float` ratio between the background and the signal region\n obstime: `Quantity` Observation time in seconds\n\n TODO: Give files as input in a configuration file!\n Returns\n E: `array` center of energy bins\n sensitivity: `array` sensitivity per energy bin\n ---------\n \"\"\"\n\n # Read simulated and reconstructed values\n gammaness_g, theta2_g, e_reco_g, e_true_g, mc_par_g, events_g = process_mc(simtelfile_gammas,\n dl2_file_g, 'gamma')\n gammaness_p, angdist2_p, e_reco_p, e_true_p, mc_par_p, events_p = process_mc(simtelfile_protons,\n dl2_file_p, 'proton')\n\n mc_par_g['sim_ev'] = mc_par_g['sim_ev']*nfiles_gammas\n mc_par_p['sim_ev'] = mc_par_p['sim_ev']*nfiles_protons\n\n #Pass units to GeV and cm2\n mc_par_g['emin'] = mc_par_g['emin'].to(u.GeV)\n mc_par_g['emax'] = mc_par_g['emax'].to(u.GeV)\n\n mc_par_p['emin'] = mc_par_p['emin'].to(u.GeV)\n mc_par_p['emax'] = mc_par_p['emax'].to(u.GeV)\n\n mc_par_g['area_sim'] = mc_par_g['area_sim'].to(u.cm**2)\n mc_par_p['area_sim'] = mc_par_p['area_sim'].to(u.cm**2)\n\n #Set binning for sensitivity calculation\n emin_sens = 10**1 * u.GeV #mc_par_g['emin']\n emax_sens = 10**5 * u.GeV #mc_par_g['emax']\n\n E = np.logspace(np.log10(emin_sens.to_value()),\n np.log10(emax_sens.to_value()), eb + 1) * u.GeV\n\n g, t = bin_definition(gb, tb)\n\n #Number of simulated events per energy bin\n \"\"\"\n bins, n_sim_bin = power_law_integrated_distribution(emin_sens.to_value(),\n emax_sens.to_value(),\n mc_par_g['sim_ev'],\n mc_par_g['sp_idx'], eb+1)\n\n\n \"\"\"\n # Extract spectral parameters\n dFdE, crab_par = crab_hegra(E)\n dFdEd0, proton_par = proton_bess(E)\n\n bins = np.logspace(np.log10(emin_sens.to_value()), np.log10(emax_sens.to_value()), eb+1)\n y0 = mc_par_g['sim_ev'] / (mc_par_g['emax'].to_value()**(mc_par_g['sp_idx'] + 1) \\\n - mc_par_g['emin'].to_value()**(mc_par_g['sp_idx'] + 1)) \\\n * (mc_par_g['sp_idx'] + 1)\n y = y0 * (bins[1:]**(crab_par['alpha'] + 1) - bins[:-1]**(crab_par['alpha'] + 1)) / (crab_par['alpha'] + 1)\n\n n_sim_bin = y\n\n\n # Rates and weights\n rate_g = rate(mc_par_g['emin'], mc_par_g['emax'], crab_par['alpha'],\n mc_par_g['cone'], mc_par_g['area_sim'],\n crab_par['f0'], crab_par['e0'])\n\n rate_p = rate(mc_par_p['emin'], mc_par_p['emax'], proton_par['alpha'],\n mc_par_p['cone'], mc_par_p['area_sim'],\n proton_par['f0'], proton_par['e0'])\n\n w_g = weight(mc_par_g['emin'], mc_par_g['emax'], mc_par_g['sp_idx'],\n crab_par['alpha'], rate_g,\n mc_par_g['sim_ev'], crab_par['e0'])\n\n w_p = weight(mc_par_p['emin'], mc_par_p['emax'], mc_par_p['sp_idx'],\n proton_par['alpha'], rate_p,\n mc_par_p['sim_ev'], proton_par['e0'])\n\n\n e_reco_gw = ((e_reco_g / crab_par['e0'])**(crab_par['alpha'] - mc_par_g['sp_idx'])) \\\n * w_g\n e_reco_pw = ((e_reco_p / proton_par['e0'])**(proton_par['alpha'] - mc_par_p['sp_idx'])) \\\n * w_p\n\n p_contained, ang_area_p = ring_containment(angdist2_p, 0.4 * u.deg, 0.2 * u.deg)\n # FIX: ring_radius and ring_halfwidth should have units of deg\n # FIX: hardcoded at the moment, but ring_radius should be read from\n # the gamma file (point-like) or given as input (diffuse).\n # FIX: ring_halfwidth should be given as input\n area_ratio_p = np.pi * t / ang_area_p\n # ratio between the area where we search for protons ang_area_p\n # and the area where we search for gammas math.pi * t\n\n # Arrays to contain the number of gammas and hadrons for different cuts\n final_gamma = np.ndarray(shape=(eb, gb, tb))\n final_hadrons = np.ndarray(shape=(eb, gb, tb))\n pre_gamma = np.ndarray(shape=(eb, gb, tb))\n pre_hadrons = np.ndarray(shape=(eb, gb, tb))\n\n ngamma_per_ebin = np.ndarray(eb)\n nhadron_per_ebin = np.ndarray(eb)\n\n # Weight events and count number of events per bin:\n for i in range(0,eb): # binning in energy\n for j in range(0,gb): # cut in gammaness\n for k in range(0,tb): # cut in theta2\n eg_w_sum = np.sum(e_reco_gw[(e_reco_g < E[i+1]) & (e_reco_g > E[i]) \\\n & (gammaness_g > g[j]) & (theta2_g < t[k])])\n\n ep_w_sum = np.sum(e_reco_pw[(e_reco_p < E[i+1]) & (e_reco_p > E[i]) \\\n & (gammaness_p > g[j]) & p_contained])\n final_gamma[i][j][k] = eg_w_sum * obstime\n final_hadrons[i][j][k] = ep_w_sum * obstime * area_ratio_p[k]\n\n pre_gamma[i][j][k] = e_reco_g[(e_reco_g < E[i+1]) & (e_reco_g > E[i]) \\\n & (gammaness_g > g[j]) & (theta2_g < t[k])].shape[0]\n pre_hadrons[i][j][k] = e_reco_p[(e_reco_p < E[i+1]) & (e_reco_p > E[i]) \\\n & (gammaness_p > g[j]) & p_contained].shape[0]\n\n ngamma_per_ebin[i] = np.sum(e_reco_gw[(e_reco_g < E[i+1]) & (e_reco_g > E[i])]) * obstime\n nhadron_per_ebin[i] = np.sum(e_reco_pw[(e_reco_p < E[i+1]) & (e_reco_p > E[i])]) * obstime\n\n nex_5sigma, sens = calculate_sensitivity_lima(final_gamma, final_hadrons * noff, 1/noff,\n eb, gb, tb)\n # Avoid bins which are empty or have too few events:\n min_num_events = 10\n min_pre_events = 10\n # Minimum number of gamma and proton events in a bin to be taken into account for minimization\n for i in range(0, eb):\n for j in range(0, gb):\n for k in range(0, tb):\n conditions = (not np.isfinite(sens[i,j,k])) or (sens[i,j,k]<=0) \\\n or (final_hadrons[i,j,k] < min_num_events) \\\n or (pre_gamma[i,j,k] < min_pre_events) \\\n or (pre_hadrons[i,j,k] < min_pre_events)\n if conditions:\n sens[i][j][k] = np.inf\n\n #Quantities to show in the results\n sensitivity = np.ndarray(shape=eb)\n nex_min = np.ndarray(shape=eb)\n eff_g = np.ndarray(shape=eb)\n eff_p = np.ndarray(shape=eb)\n gcut = np.ndarray(shape=eb)\n tcut = np.ndarray(shape=eb)\n ngammas = np.ndarray(shape=eb)\n nhadrons = np.ndarray(shape=eb)\n gammarate = np.ndarray(shape=eb)\n hadronrate = np.ndarray(shape=eb)\n eff_area = np.ndarray(shape=eb)\n nevents_gamma = np.ndarray(shape=eb)\n nevents_proton = np.ndarray(shape=eb)\n\n # Calculate the minimum sensitivity per energy bin\n for i in range(0,eb):\n ind = np.unravel_index(np.nanargmin(sens[i], axis=None), sens[i].shape)\n gcut[i] = g[ind[0]]\n tcut[i] = t[ind[1]].to_value()\n ngammas[i] = final_gamma[i][ind]\n nhadrons[i] = final_hadrons[i][ind]\n gammarate[i] = final_gamma[i][ind]/(obstime.to(u.min)).to_value()\n hadronrate[i] = final_hadrons[i][ind]/(obstime.to(u.min)).to_value()\n nex_min[i] = nex_5sigma[i][ind]\n sensitivity[i] = sens[i][ind]\n eff_g[i] = final_gamma[i][ind]/ngamma_per_ebin[i]\n eff_p[i] = final_hadrons[i][ind]/nhadron_per_ebin[i]\n\n e_aftercuts = e_true_g[(e_true_g < E[i+1]) & (e_true_g > E[i]) \\\n & (gammaness_g > g[ind[0]]) & (theta2_g < t[ind[1]])]\n\n e_aftercuts_p = e_true_p[(e_true_p < E[i+1]) & (e_true_p > E[i]) \\\n & (gammaness_p > g[ind[0]]) & p_contained]\n\n e_aftercuts_w = np.sum(np.power(e_aftercuts, crab_par['alpha']-mc_par_g['sp_idx']))\n\n e_w = np.sum(np.power(e_true_g[(e_true_g < E[i+1]) & (e_true_g > E[i])],\n crab_par['alpha']-mc_par_g['sp_idx']))\n\n #eff_area[i] = e_true_g[(e_true_g < E[i+1]) & (e_true_g > E[i]) & (gammaness_g > g[ind[0]]) & (theta2_g < t[ind[1]])].shape[0] / n_sim_bin[i] * mc_par_g['area_sim'].to(u.m**2).to_value()\n\n eff_area[i] = e_aftercuts_w.to_value() / n_sim_bin[i] * mc_par_g['area_sim'].to(u.m**2).to_value()\n\n nevents_gamma[i] = e_aftercuts.shape[0]\n nevents_proton[i] = e_aftercuts_p.shape[0]\n\n #Compute sensitivity in flux units\n\n emed = np.sqrt(E[1:] * E[:-1])\n dFdE, par = crab_magic(emed)\n sens_flux = sensitivity / 100 * (dFdE * emed * emed).to(u.erg / (u.cm**2 * u.s))\n\n list_of_tuples = list(zip(E[:E.shape[0]-2].to_value(), E[1:].to_value(), gcut, tcut,\n ngammas, nhadrons,\n gammarate, hadronrate,\n nex_min, sens_flux.to_value(), eff_area,\n eff_g, eff_p, nevents_gamma, nevents_proton))\n result = pd.DataFrame(list_of_tuples,\n columns=['ebin_low', 'ebin_up', 'gammaness_cut', 'theta2_cut',\n 'n_gammas', 'n_hadrons',\n 'gamma_rate', 'hadron_rate',\n 'nex_min', 'sensitivity','eff_area',\n 'eff_gamma', 'eff_hadron',\n 'nevents_g', 'nevents_p'])\n\n units = [E.unit, E.unit,\"\", t.unit,\"\", \"\",\n u.min**-1, u.min**-1, \"\",\n sens_flux.unit, mc_par_g['area_sim'].to(u.m**2).unit, \"\", \"\", \"\", \"\"]\n \"\"\"\n sens_minimization_plot(eb, gb, tb, E, sens)\n \n plot_positions_survived_events(events_g,\n events_p,\n gammaness_g, gammaness_p,\n theta2_g, p_contained, sens, E, eb, g, t)\n \n \"\"\"\n return E, sensitivity, result, units, gcut, tcut\n\n\ndef sens(simtelfile_gammas, simtelfile_protons,\n dl2_file_g, dl2_file_p,\n nfiles_gammas, nfiles_protons,\n eb, gcut, tcut, noff,\n obstime = 50 * 3600 * u.s):\n \"\"\"\n Main function to calculate the sensitivity given a MC dataset\n\n Parameters\n ---------\n simtelfile_gammas: `string` path to simtelfile of gammas with mc info\n simtelfile_protons: `string` path to simtelfile of protons with mc info\n dl2_file_g: `string` path to h5 file of reconstructed gammas\n dl2_file_p: `string' path to h5 file of reconstructed protons\n nfiles_gammas: `int` number of simtel gamma files reconstructed\n nfiles_protons: `int` number of simtel proton files reconstructed\n eb: `int` number of bins in energy\n gb: `int` number of bins in gammaness\n tb: `int` number of bins in theta2\n noff: `float` ratio between the background and the signal region\n obstime: `Quantity` Observation time in seconds\n\n TODO: Give files as input in a configuration file!\n Returns\n E: `array` center of energy bins\n sensitivity: `array` sensitivity per energy bin\n ---------\n \"\"\"\n\n # Read simulated and reconstructed values\n gammaness_g, theta2_g, e_reco_g, e_true_g, mc_par_g, events_g = process_mc(simtelfile_gammas,\n dl2_file_g, 'gamma')\n gammaness_p, angdist2_p, e_reco_p, e_true_p, mc_par_p, events_p = process_mc(simtelfile_protons,\n dl2_file_p, 'proton')\n\n mc_par_g['sim_ev'] = mc_par_g['sim_ev']*nfiles_gammas\n mc_par_p['sim_ev'] = mc_par_p['sim_ev']*nfiles_protons\n\n #Pass units to GeV and cm2\n mc_par_g['emin'] = mc_par_g['emin'].to(u.GeV)\n mc_par_g['emax'] = mc_par_g['emax'].to(u.GeV)\n\n mc_par_p['emin'] = mc_par_p['emin'].to(u.GeV)\n mc_par_p['emax'] = mc_par_p['emax'].to(u.GeV)\n\n mc_par_g['area_sim'] = mc_par_g['area_sim'].to(u.cm**2)\n mc_par_p['area_sim'] = mc_par_p['area_sim'].to(u.cm**2)\n\n #Set binning for sensitivity calculation\n emin_sens = 10**1 * u.GeV #mc_par_g['emin']\n emax_sens = 10**5 * u.GeV #mc_par_g['emax']\n\n E = np.logspace(np.log10(emin_sens.to_value()),\n np.log10(emax_sens.to_value()), eb + 1) * u.GeV\n\n #Number of simulated events per energy bin\n \"\"\"\n bins, n_sim_bin = power_law_integrated_distribution(emin_sens.to_value(),\n emax_sens.to_value(),\n mc_par_g['sim_ev'],\n mc_par_g['sp_idx'], eb+1)\n\n\n \"\"\"\n # Extract spectral parameters\n dFdE, crab_par = crab_hegra(E)\n dFdEd0, proton_par = proton_bess(E)\n\n bins = np.logspace(np.log10(emin_sens.to_value()), np.log10(emax_sens.to_value()), eb+1)\n y0 = mc_par_g['sim_ev'] / (mc_par_g['emax'].to_value()**(mc_par_g['sp_idx'] + 1) \\\n - mc_par_g['emin'].to_value()**(mc_par_g['sp_idx'] + 1)) \\\n * (mc_par_g['sp_idx'] + 1)\n y = y0 * (bins[1:]**(crab_par['alpha'] + 1) - bins[:-1]**(crab_par['alpha'] + 1)) / (crab_par['alpha'] + 1)\n\n n_sim_bin = y\n\n\n # Rates and weights\n rate_g = rate(mc_par_g['emin'], mc_par_g['emax'], crab_par['alpha'],\n mc_par_g['cone'], mc_par_g['area_sim'],\n crab_par['f0'], crab_par['e0'])\n\n rate_p = rate(mc_par_p['emin'], mc_par_p['emax'], proton_par['alpha'],\n mc_par_p['cone'], mc_par_p['area_sim'],\n proton_par['f0'], proton_par['e0'])\n\n w_g = weight(mc_par_g['emin'], mc_par_g['emax'], mc_par_g['sp_idx'],\n crab_par['alpha'], rate_g,\n mc_par_g['sim_ev'], crab_par['e0'])\n\n w_p = weight(mc_par_p['emin'], mc_par_p['emax'], mc_par_p['sp_idx'],\n proton_par['alpha'], rate_p,\n mc_par_p['sim_ev'], proton_par['e0'])\n\n\n e_reco_gw = ((e_reco_g / crab_par['e0'])**(crab_par['alpha'] - mc_par_g['sp_idx'])) \\\n * w_g\n e_reco_pw = ((e_reco_p / proton_par['e0'])**(proton_par['alpha'] - mc_par_p['sp_idx'])) \\\n * w_p\n\n p_contained, ang_area_p = ring_containment(angdist2_p, 0.4 * u.deg, 0.2 * u.deg)\n # FIX: ring_radius and ring_halfwidth should have units of deg\n # FIX: hardcoded at the moment, but ring_radius should be read from\n # the gamma file (point-like) or given as input (diffuse).\n # FIX: ring_halfwidth should be given as input\n area_ratio_p = np.pi * tcut / ang_area_p\n # ratio between the area where we search for protons ang_area_p\n # and the area where we search for gammas math.pi * t\n\n # Arrays to contain the number of gammas and hadrons for different cuts\n final_gamma = np.ndarray(shape=(eb))\n final_hadrons = np.ndarray(shape=(eb))\n pre_gamma = np.ndarray(shape=(eb))\n pre_hadrons = np.ndarray(shape=(eb))\n\n ngamma_per_ebin = np.ndarray(eb)\n nhadron_per_ebin = np.ndarray(eb)\n\n # Weight events and count number of events per bin:\n for i in range(0,eb): # binning in energy\n eg_w_sum = np.sum(e_reco_gw[(e_reco_g < E[i+1]) & (e_reco_g > E[i]) \\\n & (gammaness_g > gcut[i]) & (theta2_g < tcut[i])])\n\n ep_w_sum = np.sum(e_reco_pw[(e_reco_p < E[i+1]) & (e_reco_p > E[i]) \\\n & (gammaness_p > gcut[i]) & p_contained])\n final_gamma[i] = eg_w_sum * obstime\n final_hadrons[i] = ep_w_sum * obstime * area_ratio_p[i]\n\n pre_gamma[i] = e_reco_g[(e_reco_g < E[i+1]) & (e_reco_g > E[i]) \\\n & (gammaness_g > gcut[i]) & (theta2_g < tcut[i])].shape[0]\n pre_hadrons[i] = e_reco_p[(e_reco_p < E[i+1]) & (e_reco_p > E[i]) \\\n & (gammaness_p > gcut[i]) & p_contained].shape[0]\n\n ngamma_per_ebin[i] = np.sum(e_reco_gw[(e_reco_g < E[i+1]) & (e_reco_g > E[i])]) * obstime\n nhadron_per_ebin[i] = np.sum(e_reco_pw[(e_reco_p < E[i+1]) & (e_reco_p > E[i])]) * obstime\n\n nex_5sigma, sens = calculate_sensitivity_lima_1d(final_gamma, final_hadrons * noff, 1/noff,\n eb)\n # Avoid bins which are empty or have too few events:\n min_num_events = 10\n min_pre_events = 10\n # Minimum number of gamma and proton events in a bin to be taken into account for minimization\n for i in range(0, eb):\n conditions = (not np.isfinite(sens[i])) or (sens[i]<=0) \\\n or (final_hadrons[i] < min_num_events) \\\n or (pre_gamma[i] < min_pre_events) \\\n or (pre_hadrons[i] < min_pre_events)\n if conditions:\n sens[i] = np.inf\n\n #Quantities to show in the results\n sensitivity = np.ndarray(shape=eb)\n nex_min = np.ndarray(shape=eb)\n eff_g = np.ndarray(shape=eb)\n eff_p = np.ndarray(shape=eb)\n ngammas = np.ndarray(shape=eb)\n nhadrons = np.ndarray(shape=eb)\n gammarate = np.ndarray(shape=eb)\n hadronrate = np.ndarray(shape=eb)\n eff_area = np.ndarray(shape=eb)\n nevents_gamma = np.ndarray(shape=eb)\n nevents_proton = np.ndarray(shape=eb)\n\n # Calculate the minimum sensitivity per energy bin\n for i in range(0,eb):\n ngammas[i] = final_gamma[i]\n nhadrons[i] = final_hadrons[i]\n gammarate[i] = final_gamma[i]/(obstime.to(u.min)).to_value()\n hadronrate[i] = final_hadrons[i]/(obstime.to(u.min)).to_value()\n nex_min[i] = nex_5sigma[i]\n sensitivity[i] = sens[i]\n eff_g[i] = final_gamma[i]/ngamma_per_ebin[i]\n eff_p[i] = final_hadrons[i]/nhadron_per_ebin[i]\n\n e_aftercuts = e_true_g[(e_true_g < E[i+1]) & (e_true_g > E[i]) \\\n & (gammaness_g > gcut[i]) & (theta2_g < tcut[i])]\n\n e_aftercuts_p = e_true_p[(e_true_p < E[i+1]) & (e_true_p > E[i]) \\\n & (gammaness_p > gcut[i]) & p_contained]\n\n e_aftercuts_w = np.sum(np.power(e_aftercuts, crab_par['alpha']-mc_par_g['sp_idx']))\n\n e_w = np.sum(np.power(e_true_g[(e_true_g < E[i+1]) & (e_true_g > E[i])],\n crab_par['alpha']-mc_par_g['sp_idx']))\n\n eff_area[i] = e_aftercuts_w.to_value() / n_sim_bin[i] * mc_par_g['area_sim'].to(u.m**2).to_value()\n\n nevents_gamma[i] = e_aftercuts.shape[0]\n nevents_proton[i] = e_aftercuts_p.shape[0]\n\n #Compute sensitivity in flux units\n\n emed = np.sqrt(E[1:] * E[:-1])\n dFdE, par = crab_magic(emed)\n sens_flux = sensitivity / 100 * (dFdE * emed * emed).to(u.erg / (u.cm**2 * u.s))\n\n list_of_tuples = list(zip(E[:E.shape[0]-2].to_value(), E[1:].to_value(), gcut, tcut,\n ngammas, nhadrons,\n gammarate, hadronrate,\n nex_min, sens_flux.to_value(), eff_area,\n eff_g, eff_p, nevents_gamma, nevents_proton))\n result = pd.DataFrame(list_of_tuples,\n columns=['ebin_low', 'ebin_up', 'gammaness_cut', 'theta2_cut',\n 'n_gammas', 'n_hadrons',\n 'gamma_rate', 'hadron_rate',\n 'nex_min', 'sensitivity','eff_area',\n 'eff_gamma', 'eff_hadron',\n 'nevents_g', 'nevents_p'])\n\n units = [E.unit, E.unit,\"\", tcut.unit,\"\", \"\",\n u.min**-1, u.min**-1, \"\",\n sens_flux.unit, mc_par_g['area_sim'].to(u.m**2).unit, \"\", \"\", \"\", \"\"]\n\n \"\"\"\n sens_minimization_plot(eb, gb, tb, E, sens)\n \n plot_positions_survived_events(events_g,\n events_p,\n gammaness_g, gammaness_p,\n theta2_g, p_contained, sens, E, eb, gcut, tcut)\n \"\"\"\n # Build dataframe of events that survive the cuts:\n events = pd.concat((events_g, events_p))\n dl2 = pd.DataFrame(columns=events.keys())\n for i in range(0,eb):\n df_bin = events[(10**events.mc_energy < E[i+1]) & (10**events.mc_energy > E[i]) \\\n & (events.gammaness > gcut[i]) & (events.theta2 < tcut[i])]\n\n dl2 = pd.concat((dl2, df_bin))\n\n return E, sensitivity, result, units, dl2\n\n", "meta": {"hexsha": "6fa7e3589e02905bb6d40a11a5cc8f25d63d5cdb", "size": 30026, "ext": "py", "lang": "Python", "max_stars_repo_path": "lstchain/mc/sensitivity.py", "max_stars_repo_name": "thomasgas/cta-lstchain", "max_stars_repo_head_hexsha": "59dbc58f7dd7fb35aebce22489082ac885fac18b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lstchain/mc/sensitivity.py", "max_issues_repo_name": "thomasgas/cta-lstchain", "max_issues_repo_head_hexsha": "59dbc58f7dd7fb35aebce22489082ac885fac18b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lstchain/mc/sensitivity.py", "max_forks_repo_name": "thomasgas/cta-lstchain", "max_forks_repo_head_hexsha": "59dbc58f7dd7fb35aebce22489082ac885fac18b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.6305818674, "max_line_length": 194, "alphanum_fraction": 0.581229601, "include": true, "reason": "import numpy,import astropy,from astropy", "num_tokens": 8483, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6334102775181399, "lm_q2_score": 0.30404167496654744, "lm_q1q2_score": 0.19258312171764091}} {"text": "# isochrones.py\n# Ben Cook (bcook@cfa.harvard.edu)\n\n\"\"\"Define the Isocrhone_Model class\"\"\"\n\nimport numpy as np\nimport pandas as pd\nimport os\nimport glob\nimport sys\nfrom warnings import warn\nfrom pkg_resources import resource_filename\n\n##########################\n# Useful Utilities\n\n\ndef load_MIST_dir(dir_path, iso_append='.iso.cmd'):\n df = pd.DataFrame()\n for MIST_doc in glob.glob(os.path.join(dir_path, '*'+iso_append)):\n try:\n with open(MIST_doc, 'r') as f:\n lines = [f.readline() for _ in range(13)]\n colnames = lines[-1].strip('#\\n').split()\n assert ('EEP' in colnames)\n dtypes = {c: float for c in colnames}\n dtypes['EEP'] = int\n new_df = pd.read_table(MIST_doc, names=colnames,\n comment='#', delim_whitespace=True,\n dtype=dtypes, na_values=['Infinity'])\n new_df[new_df.isna()] = 100.\n df = df.append([new_df], ignore_index=True)\n except Exception:\n warn('File not properly formatted: %s' % (MIST_doc))\n sys.exit(1)\n return df\n\n\ndef _interp_arrays(arr1, arr2, f):\n \"\"\"Linearly interpolate between two (potentially unequal length) arrays\n \n Arguments:\n arr1 -- first (lower) array (len N1 or N1xD)\n arr2 -- second (upper) array (len N2 or N2xD, N2 doesn't have to equal N1)\n f -- linear interpolation fraction (float between 0 and 1)\n Output: interpolated array (len max(N1,N2) or max(N1,N2)xD)\n \"\"\"\n assert (arr1.ndim == arr2.ndim), (\n \"The two interpolated arrays must have same dimensions\")\n\n l1, l2 = len(arr1), len(arr2)\n # If arrays are unequal length, extrapolate shorter using trend of longer\n if (l1 < l2):\n delta = arr2[l1:] - arr2[l1-1]\n added = arr1[-1] + delta\n arr1 = np.append(arr1, added, axis=0)\n elif (l1 > l2):\n delta = arr1[l2:] - arr1[l2-1]\n added = arr2[-1] + delta\n arr2 = np.append(arr2, added, axis=0)\n return (1-f)*arr1 + f*arr2\n\n\ndef _feh_from_str(feh_str):\n \"\"\"Converts a metallicity value to MIST string\n Example Usage:\n _feh_from_str(\"m0.53\") -> -0.53\n _feh_from_str(\"p1.326\") -> 1.326\n \n Arguments:\n feh_str -- metallicity (as a string)\n Output: float value of metallicity\n \"\"\"\n value = float(feh_str[1:])\n if feh_str[0] == 'm':\n value *= -1\n elif feh_str[0] != 'p':\n raise ValueError('feh string not of valid format')\n return value\n\n\ndef _feh_to_str(feh):\n \"\"\"Converts a metallicity value to MIST string\n Example Usage:\n _feh_to_str(-0.5313) -> \"m0.53\"\n _feh_to_str(1.326) -> \"p1.33\"\n \n Arguments:\n feh -- metallicity (float)\n Output: string representing metallicity\n \"\"\"\n result = ''\n if (feh < 0):\n result += 'm'\n else:\n result += 'p'\n result += '%1.2f' % (np.abs(feh))\n return result\n\n\ndef _interp_df_by_mass(df, dm_min):\n ages = np.unique(df.age.values)\n fehs = np.unique(df['[Fe/H]_init'].values)\n new_rows = []\n for age in ages:\n for feh in fehs:\n iso_df = df[np.isclose(df.age, age) & np.isclose(df['[Fe/H]_init'], feh)]\n # add more points until reached desired spacing\n mass = iso_df.initial_mass.values\n frac_dm = np.diff(mass) / mass[:-1]\n id_too_large = np.where(frac_dm > dm_min)[0]\n for i_max in id_too_large:\n # add additional 5 points spacing by interpolating 0.1 between points\n row_low = iso_df.iloc[i_max]\n row_high = iso_df.iloc[i_max + 1]\n for f in np.linspace(0.1, 0.9, 5):\n new_rows.append(f*row_low + (1-f)*row_high)\n df = df.append(pd.DataFrame(new_rows))\n return df\n\n\nclass Isochrone_Model:\n \"\"\"Models Isochrones (IMF, and magnitudes in particular Filters) using\n linear interpolation of MIST models\n\n An Isocrhone_Model incorporates a collection of MIST models, and\n allows for interpolating the IMF and magnitudes (for given Filter\n objects) at any arbitrary metallicity and mass\n\n Attributes:\n MIST_df-- A pandas Dataframe containing all pre-computed MIST datapoints\n ages -- An array of ages (in log years) which are valid for the model\n Methods:\n get_magnitudes -- Pass a Galaxy_Model object, return IMF and magnitudes\n for each mass, age, metallicity bin\n Constructors:\n __init__ -- Pass a list of Filter objects, path to MIST model files,\n and array of metallicities.\n \"\"\"\n def __init__(self, filters, MIST_path=None, iso_append=\".iso.cmd\",\n rotating=False,\n mag_system='vega', dm_interp=-1):\n \"\"\"Creates a new Isochrone_Model, given a list of Filter objects\n \n Arguments:\n filters -- list of Filter objects\n Keyword Arguments:\n MIST_path -- directory containing MIST model files\n feh_arr -- array of MIST metallicity values to use\n dm_interp -- \n \"\"\"\n\n # Locate MIST files\n if MIST_path is None:\n if rotating:\n MIST_path = resource_filename('pcmdpy', 'isochrones/MIST_v1.2_rot/')\n else:\n MIST_path = resource_filename('pcmdpy', 'isochrones/MIST_v1.2/')\n \n # Import all MIST model files into Pandas dataframe\n self.num_filters = len(filters)\n\n # Use optional conversions from VEGA to AB or ST, etc\n self.conversions = {}\n self.conversions['vega'] = np.zeros(len(filters), dtype=float)\n self.conversions['ab'] = np.array([f._zpts['ab'] - f._zpts['vega']\n for f in filters])\n self.conversions['st'] = np.array([f._zpts['ab'] - f._zpts['vega']\n for f in filters])\n self.default_system = mag_system.lower()\n assert self.default_system in self.conversions.keys(), (\n \"the given mag_system is not valid. Please choose one of: \"\n \"['vega', 'ab', 'st']\")\n \n self.filters = filters\n self.filter_names = [f.tex_name for f in self.filters]\n # load all MIST files found in directory\n if isinstance(MIST_path, str):\n self.MIST_df = load_MIST_dir(MIST_path, iso_append=iso_append)\n elif isinstance(MIST_path, list):\n merge_cols = ['[Fe/H]_init', 'EEP', 'log10_isochrone_age_yr']\n self.MIST_df = pd.DataFrame(columns=merge_cols)\n # Merge multiple filter sets\n for pth in MIST_path:\n df_temp = load_MIST_dir(pth, iso_append=iso_append)\n self.MIST_df = self.MIST_df.merge(df_temp,\n how='outer', on=merge_cols,\n suffixes=['', '_repeat'])\n self.MIST_df.drop(\n [c for c in self.MIST_df.columns if c.endswith('_repeat')],\n axis=1, inplace=True)\n\n self._feh_arr = self.MIST_df['[Fe/H]_init'].unique()\n self.MIST_df.rename(columns={'log10_isochrone_age_yr': 'age',\n '[Fe/H]_init': 'feh'},\n inplace=True)\n # This is deprecated\n if dm_interp > 0.:\n print('starting manual interpolation')\n self.MIST_df = _interp_df_by_mass(self.MIST_df, dm_interp)\n print('done with interpolation')\n\n self.MIST_df = self.MIST_df.sort_values(by=['feh', 'age',\n 'initial_mass'])\n self.MIST_df = self.MIST_df.reset_index(drop=True)\n self.ages = self.MIST_df.age.unique()\n # The MIST columns that will be interpolated (initial, currentmass, EEP,\n # and all input filters)\n self._interp_cols = ['initial_mass', 'star_mass', 'EEP']\n for f in self.filters:\n c = f.MIST_column\n c_alt = f.MIST_column_alt\n if c in self.MIST_df.columns:\n self._interp_cols.append(c)\n elif c_alt in self.MIST_df.columns:\n self._interp_cols.append(c_alt)\n else:\n print((c, c_alt))\n raise ValueError('Filter does not have a valid MIST_column')\n self.MIST_gb = self.MIST_df.groupby(['age', 'feh'])[self._interp_cols]\n \n def get_isochrone(self, age, feh, downsample=5, mag_system=None):\n \"\"\"Interpolate MIST isochrones for given age and metallicity\n \n Arguments:\n age ---\n feh ---\n downsample ---\n mag_system ---\n Output:\n mags -- 2D array of magnitudes (DxN, where D is number of filters\n the model was initialized with)\n imass -- array of initial masses (N)\n cmass -- array of current masses (N)\n \"\"\"\n\n mag_system = mag_system or self.default_system\n mag_system = mag_system.lower()\n if mag_system not in self.conversions.keys():\n warn(('mag_system {0:s} not in list of magnitude '\n 'conversions. Reverting to Vega'.format(mag_system)))\n conversions = self.conversions['vega']\n else:\n conversions = self.conversions[mag_system]\n \n # Find closest age in MIST database\n age = self.ages[np.abs(self.ages - age).argmin()]\n nearest_feh = self._feh_arr[np.abs(self._feh_arr - feh).argmin()]\n if np.isclose(nearest_feh, feh, atol=0.05):\n feh = nearest_feh\n inter = self.MIST_gb.get_group((age, feh)).values\n # Interpolate/extrapolate for other metallicities\n else:\n this_age = self.MIST_df[np.isclose(self.MIST_df.age.values, age)]\n i = self._feh_arr.searchsorted(feh)\n if (i == 0):\n i = 1 # will extrapolate low\n elif (i == len(self._feh_arr)):\n i = -1 # will extrapolate high\n fehlow, fehhigh = self._feh_arr[i-1:i+1] # bounding metallicities\n frac_between = (feh - fehlow) / (fehhigh - fehlow)\n if (frac_between >= 2) or (frac_between <= -1):\n raise ValueError('Extrapolating metallicity more than one '\n 'entire metallicity bin')\n dflow = this_age[np.isclose(this_age.feh.values, fehlow)][self._interp_cols]\n dfhigh = this_age[np.isclose(this_age.feh.values, fehhigh)][self._interp_cols]\n inter = _interp_arrays(dflow.values, dfhigh.values, frac_between)\n \n initial_mass = inter[::downsample, 0]\n current_mass = inter[::downsample, 1]\n eep = inter[::downsample, 2]\n\n mags = (inter[::downsample, 3:] + conversions).T\n \n return mags, initial_mass, current_mass, eep\n\n def model_galaxy(self, galaxy, lum_cut=np.inf, mag_system=None,\n downsample=5, return_mass=False):\n weights = np.empty((1, 0), dtype=float)\n magnitudes = np.empty((self.num_filters, 0), dtype=float)\n initial_mass = np.empty((1, 0), dtype=float)\n current_mass = np.empty((1, 0), dtype=float)\n eeps = np.empty((1, 0), dtype=float)\n # Collect the isochrones from each bin\n for age, feh, sfh, d_mod in galaxy.iter_SSPs():\n mags, i_mass, c_mass, eep = self.get_isochrone(\n age, feh, mag_system=mag_system, downsample=downsample)\n imf = galaxy.imf_func(i_mass, **galaxy.imf_kwargs)\n weights = np.append(weights, imf*sfh)\n mags += d_mod\n magnitudes = np.append(magnitudes, mags, axis=-1)\n initial_mass = np.append(initial_mass, i_mass)\n current_mass = np.append(current_mass, c_mass)\n eeps = np.append(eeps, eep)\n if not np.isinf(lum_cut):\n lum = np.power(10., -0.4*magnitudes)\n mean_lum = np.average(lum, weights=weights, axis=1)\n to_keep = (lum.T / mean_lum >= lum_cut).sum(axis=1) == 0\n weights = weights[to_keep]\n magnitudes = magnitudes[:, to_keep]\n initial_mass = initial_mass[to_keep]\n current_mass = current_mass[to_keep]\n eeps = eeps[to_keep]\n if return_mass:\n return weights, magnitudes, initial_mass, current_mass, eeps\n else:\n return weights, magnitudes\n\n def get_stellar_mass(self, galaxy, downsample=5):\n imf, _, _, c_mass, _ = self.model_galaxy(galaxy,\n downsample=downsample,\n return_mass=True)\n return (imf * c_mass).sum()\n", "meta": {"hexsha": "ae0223ae17a5a5a24669bb5426de098ac60d48f7", "size": 12810, "ext": "py", "lang": "Python", "max_stars_repo_path": "pcmdpy/isochrones/isochrones.py", "max_stars_repo_name": "johnnygreco/pcmdpy", "max_stars_repo_head_hexsha": "fe38db999f4445c98bde168867274654b2be4dbe", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pcmdpy/isochrones/isochrones.py", "max_issues_repo_name": "johnnygreco/pcmdpy", "max_issues_repo_head_hexsha": "fe38db999f4445c98bde168867274654b2be4dbe", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pcmdpy/isochrones/isochrones.py", "max_forks_repo_name": "johnnygreco/pcmdpy", "max_forks_repo_head_hexsha": "fe38db999f4445c98bde168867274654b2be4dbe", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.7961783439, "max_line_length": 90, "alphanum_fraction": 0.5711163154, "include": true, "reason": "import numpy", "num_tokens": 3191, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5467381519846138, "lm_q2_score": 0.35220179564702847, "lm_q1q2_score": 0.19256215887771896}} {"text": "# Copyright 2016 Valentine Svensson, James Hensman, alexggmatthews, Alexis Boukouvalas\n# Copyright 2017 Artem Artemev @awav\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"\nLikelihoods are another core component of GPflow. This describes how likely the\ndata is under the assumptions made about the underlying latent functions\np(Y|F). Different likelihoods make different\nassumptions about the distribution of the data, as such different data-types\n(continuous, binary, ordinal, count) are better modelled with different\nlikelihood assumptions.\n\nUse of any likelihood other than Gaussian typically introduces the need to use\nan approximation to perform inference, if one isn't already needed. A\nvariational inference and MCMC models are included in GPflow and allow\napproximate inference with non-Gaussian likelihoods. An introduction to these\nmodels can be found :ref:`here `. Specific notebooks\nillustrating non-Gaussian likelihood regressions are available for\n`classification `_ (binary data), `ordinal\n`_ and `multiclass `_.\n\nCreating new likelihoods\n----------\nLikelihoods are defined by their\nlog-likelihood. When creating new likelihoods, the\n:func:`logp ` method (log p(Y|F)), the\n:func:`conditional_mean `,\n:func:`conditional_variance\n`.\n\nIn order to perform variational inference with non-Gaussian likelihoods a term\ncalled ``variational expectations``, ∫ q(F) log p(Y|F) dF, needs to\nbe computed under a Gaussian distribution q(F) ~ N(μ, Σ).\n\nThe :func:`variational_expectations `\nmethod can be overriden if this can be computed in closed form, otherwise; if\nthe new likelihood inherits\n:class:`Likelihood ` the default will use\nGauss-Hermite numerical integration (works well when F is 1D\nor 2D), if the new likelihood inherits from\n:class:`MonteCarloLikelihood ` the\nintegration is done by sampling (can be more suitable when F is higher dimensional).\n\"\"\"\n\nimport numpy as np\nimport tensorflow as tf\nimport abc\nimport warnings\n\nfrom .. import logdensities\nfrom ..base import Module, Parameter\nfrom ..config import default_float\nfrom ..quadrature import hermgauss, ndiag_mc, ndiagquad\nfrom ..utilities import positive, to_default_int\nfrom .robustmax import RobustMax\n\n\ndef inv_probit(x):\n jitter = 1e-3 # ensures output is strictly between 0 and 1\n return 0.5 * (1.0 + tf.math.erf(x / np.sqrt(2.0))) * (1 - 2 * jitter) + jitter\n\n\nclass Likelihood(Module, metaclass=abc.ABCMeta):\n def __init__(self, latent_dim: int, observation_dim: int):\n \"\"\"\n A base class for likelihoods, which specifies an observation model \n connecting the latent functions ('F') to the data ('Y').\n\n All of the members of this class are expected to obey some shape conventions, as specified\n by latent_dim and observation_dim.\n\n If we're operating on an array of function values 'F', then the last dimension represents\n multiple functions (preceding dimensions could represent different data points, or\n different random samples, for example). Similarly, the last dimension of Y represents a\n single data point. We check that the dimensions are as this object expects.\n\n The return shapes of all functions in this class is the broadcasted shape of the arguments,\n excluding the last dimension of each argument.\n\n :param latent_dim: the dimension of the vector F of latent functions for a single data point\n :param observation_dim: the dimension of the observation vector Y for a single data point\n \"\"\"\n super().__init__()\n self.latent_dim = latent_dim\n self.observation_dim = observation_dim\n\n def _check_last_dims_valid(self, F, Y):\n \"\"\"\n Assert that the dimensions of the latent functions F and the data Y are compatible.\n\n :param F: function evaluation Tensor, with shape [..., latent_dim]\n :param Y: observation Tensor, with shape [..., observation_dim]\n \"\"\"\n self._check_latent_dims(F)\n self._check_data_dims(Y)\n\n def _check_return_shape(self, result, F, Y):\n \"\"\"\n Check that the shape of a computed statistic of the data\n is the broadcasted shape from F and Y.\n\n :param result: result Tensor, with shape [...]\n :param F: function evaluation Tensor, with shape [..., latent_dim]\n :param Y: observation Tensor, with shape [..., observation_dim]\n \"\"\"\n expected_shape = tf.broadcast_dynamic_shape(tf.shape(F)[:-1], tf.shape(Y)[:-1])\n tf.debugging.assert_equal(tf.shape(result), expected_shape)\n\n def _check_latent_dims(self, F):\n \"\"\"\n Ensure that a tensor of latent functions F has latent_dim as right-most dimension.\n\n :param F: function evaluation Tensor, with shape [..., latent_dim]\n \"\"\"\n tf.debugging.assert_shapes([(F, (..., self.latent_dim))])\n\n def _check_data_dims(self, Y):\n \"\"\"\n Ensure that a tensor of data Y has observation_dim as right-most dimension.\n\n :param Y: observation Tensor, with shape [..., observation_dim]\n \"\"\"\n tf.debugging.assert_shapes([(Y, (..., self.observation_dim))])\n\n def log_prob(self, F, Y):\n \"\"\"\n The log probability density log p(Y|F)\n\n :param F: function evaluation Tensor, with shape [..., latent_dim]\n :param Y: observation Tensor, with shape [..., observation_dim]:\n :returns: log pdf, with shape [...]\n \"\"\"\n self._check_last_dims_valid(F, Y)\n res = self._log_prob(F, Y)\n self._check_return_shape(res, F, Y)\n return res\n\n @abc.abstractmethod\n def _log_prob(self, F, Y):\n raise NotImplementedError\n\n def conditional_mean(self, F):\n \"\"\"\n The conditional mean of Y|F: [E[Y₁|F], ..., E[Yₖ|F]]\n where K = observation_dim\n\n :param F: function evaluation Tensor, with shape [..., latent_dim]\n :returns: mean [..., observation_dim]\n \"\"\"\n self._check_latent_dims(F)\n expected_Y = self._conditional_mean(F)\n self._check_data_dims(expected_Y)\n return expected_Y\n\n def _conditional_mean(self, F):\n raise NotImplementedError\n\n def conditional_variance(self, F):\n \"\"\"\n The conditional marginal variance of Y|F: [var(Y₁|F), ..., var(Yₖ|F)]\n where K = observation_dim\n\n :param F: function evaluation Tensor, with shape [..., latent_dim]\n :returns: variance [..., observation_dim]\n \"\"\"\n self._check_latent_dims(F)\n var_Y = self._conditional_variance(F)\n self._check_data_dims(var_Y)\n return var_Y\n\n def _conditional_variance(self, F):\n raise NotImplementedError\n\n def predict_mean_and_var(self, Fmu, Fvar):\n \"\"\"\n Given a Normal distribution for the latent function,\n return the mean and marginal variance of Y,\n\n i.e. if\n q(f) = N(Fmu, Fvar)\n\n and this object represents\n\n p(y|f)\n\n then this method computes the predictive mean\n\n ∫∫ y p(y|f)q(f) df dy\n\n and the predictive variance\n\n ∫∫ y² p(y|f)q(f) df dy - [ ∫∫ y p(y|f)q(f) df dy ]²\n\n\n :param Fmu: mean function evaluation Tensor, with shape [..., latent_dim]\n :param Fvar: variance of function evaluation Tensor, with shape [..., latent_dim]\n :returns: mean and variance, both with shape [..., observation_dim]\n \"\"\"\n self._check_latent_dims(Fmu)\n self._check_latent_dims(Fvar)\n mu, var = self._predict_mean_and_var(Fmu, Fvar)\n self._check_data_dims(mu)\n self._check_data_dims(var)\n return mu, var\n\n @abc.abstractmethod\n def _predict_mean_and_var(self, Fmu, Fvar):\n raise NotImplementedError\n\n def predict_log_density(self, Fmu, Fvar, Y):\n r\"\"\"\n Given a Normal distribution for the latent function, and a datum Y,\n compute the log predictive density of Y,\n\n i.e. if\n q(F) = N(Fmu, Fvar)\n\n and this object represents\n\n p(y|F)\n\n then this method computes the predictive density\n\n log ∫ p(y=Y|F)q(F) df\n\n :param Fmu: mean function evaluation Tensor, with shape [..., latent_dim]\n :param Fvar: variance of function evaluation Tensor, with shape [..., latent_dim]\n :param Y: observation Tensor, with shape [..., observation_dim]:\n :returns: log predictive density, with shape [...]\n \"\"\"\n tf.debugging.assert_equal(tf.shape(Fmu), tf.shape(Fvar))\n self._check_last_dims_valid(Fmu, Y)\n res = self._predict_log_density(Fmu, Fvar, Y)\n self._check_return_shape(res, Fmu, Y)\n return res\n\n @abc.abstractmethod\n def _predict_log_density(self, Fmu, Fvar, Y):\n raise NotImplementedError\n\n def predict_density(self, Fmu, Fvar, Y):\n \"\"\"\n Deprecated: see `predict_log_density`\n \"\"\"\n warnings.warn(\n \"predict_density is deprecated and will be removed in GPflow 2.1, use predict_log_density instead\",\n DeprecationWarning,\n )\n return self.predict_log_density(Fmu, Fvar, Y)\n\n def variational_expectations(self, Fmu, Fvar, Y):\n r\"\"\"\n Compute the expected log density of the data, given a Gaussian\n distribution for the function values,\n\n i.e. if\n q(f) = N(Fmu, Fvar)\n\n and this object represents\n\n p(y|f)\n\n then this method computes\n\n ∫ log(p(y=Y|f)) q(f) df.\n\n This only works if the broadcasting dimension of the statistics of q(f) (mean and variance)\n are broadcastable with that of the data Y.\n\n :param Fmu: mean function evaluation Tensor, with shape [..., latent_dim]\n :param Fvar: variance of function evaluation Tensor, with shape [..., latent_dim]\n :param Y: observation Tensor, with shape [..., observation_dim]:\n :returns: expected log density of the data given q(F), with shape [...]\n \"\"\"\n tf.debugging.assert_equal(tf.shape(Fmu), tf.shape(Fvar))\n # returns an error if Y[:-1] and Fmu[:-1] do not broadcast together\n _ = tf.broadcast_dynamic_shape(tf.shape(Fmu)[:-1], tf.shape(Y)[:-1])\n self._check_last_dims_valid(Fmu, Y)\n ret = self._variational_expectations(Fmu, Fvar, Y)\n self._check_return_shape(ret, Fmu, Y)\n return ret\n\n @abc.abstractmethod\n def _variational_expectations(self, Fmu, Fvar, Y):\n raise NotImplementedError\n\n\nclass ScalarLikelihood(Likelihood):\n \"\"\"\n A likelihood class that helps with scalar likelihood functions: likelihoods where\n each scalar latent function is associated with a single scalar observation variable.\n\n If there are multiple latent functions, then there must be a corresponding number of data: we\n check for this.\n\n The `Likelihood` class contains methods to compute marginal statistics of functions\n of the latents and the data ϕ(y,f):\n * variational_expectations: ϕ(y,f) = log p(y|f)\n * predict_log_density: ϕ(y,f) = p(y|f)\n Those statistics are computed after having first marginalized the latent processes f\n under a multivariate normal distribution q(f) that is fully factorized.\n\n Some univariate integrals can be done by quadrature: we implement quadrature routines for 1D\n integrals in this class, though they may be overwritten by inheriting classes where those\n integrals are available in closed form.\n \"\"\"\n\n def __init__(self, **kwargs):\n super().__init__(latent_dim=None, observation_dim=None, **kwargs)\n self.num_gauss_hermite_points = 20\n\n def _check_last_dims_valid(self, F, Y):\n \"\"\"\n Assert that the dimensions of the latent functions and the data are compatible\n :param F: function evaluation Tensor, with shape [..., latent_dim]\n :param Y: observation Tensor, with shape [..., latent_dim]\n \"\"\"\n tf.debugging.assert_shapes([(F, (..., \"num_latent\")), (Y, (..., \"num_latent\"))])\n\n def _log_prob(self, F, Y):\n r\"\"\"\n Compute log p(Y|F), where by convention we sum out the last axis as it represented\n independent latent functions and observations.\n :param F: function evaluation Tensor, with shape [..., latent_dim]\n :param Y: observation Tensor, with shape [..., latent_dim]\n \"\"\"\n return tf.reduce_sum(self._scalar_log_density(F, Y), axis=-1)\n\n def _scalar_log_density(self, F, Y):\n raise NotImplementedError\n\n def _variational_expectations(self, Fmu, Fvar, Y):\n r\"\"\"\n Here, we implement a default Gauss-Hermite quadrature routine, but some\n likelihoods (Gaussian, Poisson) will implement specific cases.\n :param Fmu: mean function evaluation Tensor, with shape [..., latent_dim]\n :param Fvar: variance of function evaluation Tensor, with shape [..., latent_dim]\n :param Y: observation Tensor, with shape [..., latent_dim]:\n :returns: variational expectations, with shape [...]\n \"\"\"\n return tf.reduce_sum(\n ndiagquad(self._scalar_log_density, self.num_gauss_hermite_points, Fmu, Fvar, Y=Y),\n axis=-1,\n )\n\n def _predict_log_density(self, Fmu, Fvar, Y):\n r\"\"\"\n Here, we implement a default Gauss-Hermite quadrature routine, but some\n likelihoods (Gaussian, Poisson) will implement specific cases.\n :param Fmu: mean function evaluation Tensor, with shape [..., latent_dim]\n :param Fvar: variance of function evaluation Tensor, with shape [..., latent_dim]\n :param Y: observation Tensor, with shape [..., latent_dim]:\n :returns: log predictive density, with shape [...]\n \"\"\"\n return tf.reduce_sum(\n ndiagquad(\n self._scalar_log_density,\n self.num_gauss_hermite_points,\n Fmu,\n Fvar,\n logspace=True,\n Y=Y,\n ),\n axis=-1,\n )\n\n def _predict_mean_and_var(self, Fmu, Fvar):\n r\"\"\"\n Here, we implement a default Gauss-Hermite quadrature routine, but some\n likelihoods (e.g. Gaussian) will implement specific cases.\n\n :param Fmu: mean function evaluation Tensor, with shape [..., latent_dim]\n :param Fvar: variance of function evaluation Tensor, with shape [..., latent_dim]\n :returns: mean and variance, both with shape [..., observation_dim]\n \"\"\"\n\n def integrand(*X):\n return self.conditional_variance(*X) + self.conditional_mean(*X) ** 2\n\n integrands = [self.conditional_mean, integrand]\n E_y, E_y2 = ndiagquad(integrands, self.num_gauss_hermite_points, Fmu, Fvar)\n V_y = E_y2 - E_y ** 2\n return E_y, V_y\n\n\nclass Gaussian(ScalarLikelihood):\n r\"\"\"\n The Gaussian likelihood is appropriate where uncertainties associated with the data are\n believed to follow a normal distribution, with constant variance.\n\n Very small uncertainties can lead to numerical instability during the\n optimization process. A lower bound of 1e-6 is therefore imposed on the likelihood variance\n by default.\n \"\"\"\n\n def __init__(self, variance=1.0, variance_lower_bound=1e-6, **kwargs):\n super().__init__(**kwargs)\n self.variance = Parameter(variance, transform=positive(lower=variance_lower_bound))\n\n def _scalar_log_density(self, F, Y):\n return logdensities.gaussian(Y, F, self.variance)\n\n def _conditional_mean(self, F): # pylint: disable=R0201\n return tf.identity(F)\n\n def _conditional_variance(self, F):\n return tf.fill(tf.shape(F), tf.squeeze(self.variance))\n\n def _predict_mean_and_var(self, Fmu, Fvar):\n return tf.identity(Fmu), Fvar + self.variance\n\n def _predict_log_density(self, Fmu, Fvar, Y):\n return tf.reduce_sum(logdensities.gaussian(Y, Fmu, Fvar + self.variance), axis=-1)\n\n def _variational_expectations(self, Fmu, Fvar, Y):\n return tf.reduce_sum(\n -0.5 * np.log(2 * np.pi)\n - 0.5 * tf.math.log(self.variance)\n - 0.5 * ((Y - Fmu) ** 2 + Fvar) / self.variance,\n axis=-1,\n )\n\n\nclass Poisson(ScalarLikelihood):\n r\"\"\"\n Poisson likelihood for use with count data, where the rate is given by the (transformed) GP.\n\n let g(.) be the inverse-link function, then this likelihood represents\n\n p(yᵢ | fᵢ) = Poisson(yᵢ | g(fᵢ) * binsize)\n\n Note:binsize\n For use in a Log Gaussian Cox process (doubly stochastic model) where the\n rate function of an inhomogeneous Poisson process is given by a GP. The\n intractable likelihood can be approximated via a Riemann sum (with bins\n of size 'binsize') and using this Poisson likelihood.\n \"\"\"\n\n def __init__(self, invlink=tf.exp, binsize=1.0, **kwargs):\n super().__init__(**kwargs)\n self.invlink = invlink\n self.binsize = np.array(binsize, dtype=default_float())\n\n def _scalar_log_density(self, F, Y):\n return logdensities.poisson(Y, self.invlink(F) * self.binsize)\n\n def _conditional_variance(self, F):\n return self.invlink(F) * self.binsize\n\n def _conditional_mean(self, F):\n return self.invlink(F) * self.binsize\n\n def _variational_expectations(self, Fmu, Fvar, Y):\n if self.invlink is tf.exp:\n return tf.reduce_sum(\n Y * Fmu\n - tf.exp(Fmu + Fvar / 2) * self.binsize\n - tf.math.lgamma(Y + 1)\n + Y * tf.math.log(self.binsize),\n axis=-1,\n )\n return super()._variational_expectations(Fmu, Fvar, Y)\n\n\nclass Exponential(ScalarLikelihood):\n def __init__(self, invlink=tf.exp, **kwargs):\n super().__init__(**kwargs)\n self.invlink = invlink\n\n def _scalar_log_density(self, F, Y):\n return logdensities.exponential(Y, self.invlink(F))\n\n def _conditional_mean(self, F):\n return self.invlink(F)\n\n def _conditional_variance(self, F):\n return tf.square(self.invlink(F))\n\n def _variational_expectations(self, Fmu, Fvar, Y):\n if self.invlink is tf.exp:\n return tf.reduce_sum(-tf.exp(-Fmu + Fvar / 2) * Y - Fmu, axis=-1)\n return super()._variational_expectations(Fmu, Fvar, Y)\n\n\nclass StudentT(ScalarLikelihood):\n def __init__(self, scale=1.0, df=3.0, **kwargs):\n \"\"\"\n :param scale float: scale parameter\n :param df float: degrees of freedom\n \"\"\"\n super().__init__(**kwargs)\n self.df = df\n self.scale = Parameter(scale, transform=positive())\n\n def _scalar_log_density(self, F, Y):\n return logdensities.student_t(Y, F, self.scale, self.df)\n\n def _conditional_mean(self, F):\n return F\n\n def _conditional_variance(self, F):\n var = (self.scale ** 2) * (self.df / (self.df - 2.0))\n return tf.fill(tf.shape(F), tf.squeeze(var))\n\n\nclass Bernoulli(ScalarLikelihood):\n def __init__(self, invlink=inv_probit, **kwargs):\n super().__init__(**kwargs)\n self.invlink = invlink\n\n def _scalar_log_density(self, F, Y):\n return logdensities.bernoulli(Y, self.invlink(F))\n\n def _predict_mean_and_var(self, Fmu, Fvar):\n if self.invlink is inv_probit:\n p = inv_probit(Fmu / tf.sqrt(1 + Fvar))\n return p, p - tf.square(p)\n else:\n # for other invlink, use quadrature\n return super()._predict_mean_and_var(Fmu, Fvar)\n\n def _predict_log_density(self, Fmu, Fvar, Y):\n p = self.predict_mean_and_var(Fmu, Fvar)[0]\n return logdensities.bernoulli(Y, p)\n\n def _conditional_mean(self, F):\n return self.invlink(F)\n\n def _conditional_variance(self, F):\n p = self.conditional_mean(F)\n return p - (p ** 2)\n\n\nclass Gamma(ScalarLikelihood):\n \"\"\"\n Use the transformed GP to give the *scale* (inverse rate) of the Gamma\n \"\"\"\n\n def __init__(self, invlink=tf.exp, **kwargs):\n super().__init__(**kwargs)\n self.invlink = invlink\n self.shape = Parameter(1.0, transform=positive())\n\n def _scalar_log_density(self, F, Y):\n return logdensities.gamma(Y, self.shape, self.invlink(F))\n\n def _conditional_mean(self, F):\n return self.shape * self.invlink(F)\n\n def _conditional_variance(self, F):\n scale = self.invlink(F)\n return self.shape * (scale ** 2)\n\n def _variational_expectations(self, Fmu, Fvar, Y):\n if self.invlink is tf.exp:\n return tf.reduce_sum(\n -self.shape * Fmu\n - tf.math.lgamma(self.shape)\n + (self.shape - 1.0) * tf.math.log(Y)\n - Y * tf.exp(-Fmu + Fvar / 2.0),\n axis=-1,\n )\n else:\n return super()._variational_expectations(Fmu, Fvar, Y)\n\n\nclass Beta(ScalarLikelihood):\n \"\"\"\n This uses a reparameterisation of the Beta density. We have the mean of the\n Beta distribution given by the transformed process:\n\n m = invlink(f)\n\n and a scale parameter. The familiar α, β parameters are given by\n\n m = α / (α + β)\n scale = α + β\n\n so:\n α = scale * m\n β = scale * (1-m)\n \"\"\"\n\n def __init__(self, invlink=inv_probit, scale=1.0, **kwargs):\n super().__init__(**kwargs)\n self.scale = Parameter(scale, transform=positive())\n self.invlink = invlink\n\n def _scalar_log_density(self, F, Y):\n mean = self.invlink(F)\n alpha = mean * self.scale\n beta = self.scale - alpha\n return logdensities.beta(Y, alpha, beta)\n\n def _conditional_mean(self, F):\n return self.invlink(F)\n\n def _conditional_variance(self, F):\n mean = self.invlink(F)\n return (mean - tf.square(mean)) / (self.scale + 1.0)\n\n\nclass MultiClass(Likelihood):\n def __init__(self, num_classes, invlink=None, **kwargs):\n \"\"\"\n A likelihood for multi-way classification. Currently the only valid\n choice of inverse-link function (invlink) is an instance of RobustMax.\n\n For most problems, the stochastic `Softmax` likelihood may be more\n appropriate (note that you then cannot use Scipy optimizer).\n \"\"\"\n super().__init__(latent_dim=num_classes, observation_dim=None, **kwargs)\n self.num_classes = num_classes\n self.num_gauss_hermite_points = 20\n\n if invlink is None:\n invlink = RobustMax(self.num_classes)\n\n if not isinstance(invlink, RobustMax):\n raise NotImplementedError\n\n self.invlink = invlink\n\n def _log_prob(self, F, Y):\n hits = tf.equal(tf.expand_dims(tf.argmax(F, 1), 1), tf.cast(Y, tf.int64))\n yes = tf.ones(tf.shape(Y), dtype=default_float()) - self.invlink.epsilon\n no = tf.zeros(tf.shape(Y), dtype=default_float()) + self.invlink.eps_k1\n p = tf.where(hits, yes, no)\n return tf.reduce_sum(tf.math.log(p), axis=-1)\n\n def _variational_expectations(self, Fmu, Fvar, Y):\n gh_x, gh_w = hermgauss(self.num_gauss_hermite_points)\n p = self.invlink.prob_is_largest(Y, Fmu, Fvar, gh_x, gh_w)\n ve = p * tf.math.log(1.0 - self.invlink.epsilon) + (1.0 - p) * tf.math.log(\n self.invlink.eps_k1\n )\n return tf.reduce_sum(ve, axis=-1)\n\n def _predict_mean_and_var(self, Fmu, Fvar):\n possible_outputs = [\n tf.fill(tf.stack([tf.shape(Fmu)[0], 1]), np.array(i, dtype=np.int64))\n for i in range(self.num_classes)\n ]\n ps = [self._predict_non_logged_density(Fmu, Fvar, po) for po in possible_outputs]\n ps = tf.transpose(tf.stack([tf.reshape(p, (-1,)) for p in ps]))\n return ps, ps - tf.square(ps)\n\n def _predict_log_density(self, Fmu, Fvar, Y):\n return tf.reduce_sum(tf.math.log(self._predict_non_logged_density(Fmu, Fvar, Y)), axis=-1)\n\n def _predict_non_logged_density(self, Fmu, Fvar, Y):\n gh_x, gh_w = hermgauss(self.num_gauss_hermite_points)\n p = self.invlink.prob_is_largest(Y, Fmu, Fvar, gh_x, gh_w)\n den = p * (1.0 - self.invlink.epsilon) + (1.0 - p) * (self.invlink.eps_k1)\n return den\n\n def _conditional_mean(self, F):\n return self.invlink(F)\n\n def _conditional_variance(self, F):\n p = self.conditional_mean(F)\n return p - tf.square(p)\n\n\nclass SwitchedLikelihood(ScalarLikelihood):\n def __init__(self, likelihood_list, **kwargs):\n \"\"\"\n In this likelihood, we assume at extra column of Y, which contains\n integers that specify a likelihood from the list of likelihoods.\n \"\"\"\n super().__init__(**kwargs)\n for l in likelihood_list:\n assert isinstance(l, ScalarLikelihood)\n self.likelihoods = likelihood_list\n\n def _partition_and_stitch(self, args, func_name):\n \"\"\"\n args is a list of tensors, to be passed to self.likelihoods.\n\n args[-1] is the 'Y' argument, which contains the indexes to self.likelihoods.\n\n This function splits up the args using dynamic_partition, calls the\n relevant function on the likelihoods, and re-combines the result.\n \"\"\"\n # get the index from Y\n Y = args[-1]\n ind = Y[..., -1]\n ind = tf.cast(ind, tf.int32)\n Y = Y[..., :-1]\n args[-1] = Y\n\n # split up the arguments into chunks corresponding to the relevant likelihoods\n args = zip(*[tf.dynamic_partition(X, ind, len(self.likelihoods)) for X in args])\n\n # apply the likelihood-function to each section of the data\n funcs = [getattr(lik, func_name) for lik in self.likelihoods]\n results = [f(*args_i) for f, args_i in zip(funcs, args)]\n\n # stitch the results back together\n partitions = tf.dynamic_partition(tf.range(0, tf.size(ind)), ind, len(self.likelihoods))\n results = tf.dynamic_stitch(partitions, results)\n\n return results\n\n def _check_last_dims_valid(self, F, Y):\n tf.assert_equal(tf.shape(F)[-1], tf.shape(Y)[-1] - 1)\n\n def _scalar_log_density(self, F, Y):\n return self._partition_and_stitch([F, Y], \"_scalar_log_density\")\n\n def _predict_log_density(self, Fmu, Fvar, Y):\n return self._partition_and_stitch([Fmu, Fvar, Y], \"predict_log_density\")\n\n def _variational_expectations(self, Fmu, Fvar, Y):\n return self._partition_and_stitch([Fmu, Fvar, Y], \"variational_expectations\")\n\n def _predict_mean_and_var(self, Fmu, Fvar):\n mvs = [lik.predict_mean_and_var(Fmu, Fvar) for lik in self.likelihoods]\n mu_list, var_list = zip(*mvs)\n mu = tf.concat(mu_list, 1)\n var = tf.concat(var_list, 1)\n return mu, var\n\n def _conditional_mean(self, F):\n raise NotImplementedError\n\n def _conditional_variance(self, F):\n raise NotImplementedError\n\n\nclass Ordinal(ScalarLikelihood):\n \"\"\"\n A likelihood for doing ordinal regression.\n\n The data are integer values from 0 to k, and the user must specify (k-1)\n 'bin edges' which define the points at which the labels switch. Let the bin\n edges be [a₀, a₁, ... aₖ₋₁], then the likelihood is\n\n p(Y=0|F) = ɸ((a₀ - F) / σ)\n p(Y=1|F) = ɸ((a₁ - F) / σ) - ɸ((a₀ - F) / σ)\n p(Y=2|F) = ɸ((a₂ - F) / σ) - ɸ((a₁ - F) / σ)\n ...\n p(Y=K|F) = 1 - ɸ((aₖ₋₁ - F) / σ)\n\n where ɸ is the cumulative density function of a Gaussian (the inverse probit\n function) and σ is a parameter to be learned. A reference is:\n\n @article{chu2005gaussian,\n title={Gaussian processes for ordinal regression},\n author={Chu, Wei and Ghahramani, Zoubin},\n journal={Journal of Machine Learning Research},\n volume={6},\n number={Jul},\n pages={1019--1041},\n year={2005}\n }\n \"\"\"\n\n def __init__(self, bin_edges, **kwargs):\n \"\"\"\n bin_edges is a numpy array specifying at which function value the\n output label should switch. If the possible Y values are 0...K, then\n the size of bin_edges should be (K-1).\n \"\"\"\n super().__init__(**kwargs)\n self.bin_edges = bin_edges\n self.num_bins = bin_edges.size + 1\n self.sigma = Parameter(1.0, transform=positive())\n\n def _scalar_log_density(self, F, Y):\n Y = to_default_int(Y)\n scaled_bins_left = tf.concat([self.bin_edges / self.sigma, np.array([np.inf])], 0)\n scaled_bins_right = tf.concat([np.array([-np.inf]), self.bin_edges / self.sigma], 0)\n selected_bins_left = tf.gather(scaled_bins_left, Y)\n selected_bins_right = tf.gather(scaled_bins_right, Y)\n\n return tf.math.log(\n inv_probit(selected_bins_left - F / self.sigma)\n - inv_probit(selected_bins_right - F / self.sigma)\n + 1e-6\n )\n\n def _make_phi(self, F):\n \"\"\"\n A helper function for making predictions. Constructs a probability\n matrix where each row output the probability of the corresponding\n label, and the rows match the entries of F.\n\n Note that a matrix of F values is flattened.\n \"\"\"\n scaled_bins_left = tf.concat([self.bin_edges / self.sigma, np.array([np.inf])], 0)\n scaled_bins_right = tf.concat([np.array([-np.inf]), self.bin_edges / self.sigma], 0)\n return inv_probit(scaled_bins_left - tf.reshape(F, (-1, 1)) / self.sigma) - inv_probit(\n scaled_bins_right - tf.reshape(F, (-1, 1)) / self.sigma\n )\n\n def _conditional_mean(self, F):\n phi = self._make_phi(F)\n Ys = tf.reshape(np.arange(self.num_bins, dtype=default_float()), (-1, 1))\n return tf.reshape(tf.linalg.matmul(phi, Ys), tf.shape(F))\n\n def _conditional_variance(self, F):\n phi = self._make_phi(F)\n Ys = tf.reshape(np.arange(self.num_bins, dtype=default_float()), (-1, 1))\n E_y = phi @ Ys\n E_y2 = phi @ (Ys ** 2)\n return tf.reshape(E_y2 - E_y ** 2, tf.shape(F))\n\n\nclass MonteCarloLikelihood(Likelihood):\n def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self.num_monte_carlo_points = 100\n\n def _mc_quadrature(self, funcs, Fmu, Fvar, logspace: bool = False, epsilon=None, **Ys):\n return ndiag_mc(funcs, self.num_monte_carlo_points, Fmu, Fvar, logspace, epsilon, **Ys)\n\n def _predict_mean_and_var(self, Fmu, Fvar, epsilon=None):\n r\"\"\"\n Given a Normal distribution for the latent function,\n return the mean of Y\n\n if\n q(f) = N(Fmu, Fvar)\n\n and this object represents\n\n p(y|f)\n\n then this method computes the predictive mean\n\n ∫∫ y p(y|f)q(f) df dy\n\n and the predictive variance\n\n ∫∫ y² p(y|f)q(f) df dy - [ ∫∫ y p(y|f)q(f) df dy ]²\n\n Here, we implement a default Monte Carlo routine.\n \"\"\"\n integrand2 = lambda *X: self.conditional_variance(*X) + tf.square(self.conditional_mean(*X))\n E_y, E_y2 = self._mc_quadrature(\n [self.conditional_mean, integrand2], Fmu, Fvar, epsilon=epsilon\n )\n V_y = E_y2 - tf.square(E_y)\n return E_y, V_y # [N, D]\n\n def _predict_log_density(self, Fmu, Fvar, Y, epsilon=None):\n r\"\"\"\n Given a Normal distribution for the latent function, and a datum Y,\n compute the log predictive density of Y.\n\n i.e. if\n q(f) = N(Fmu, Fvar)\n\n and this object represents\n\n p(y|f)\n\n then this method computes the predictive density\n\n log ∫ p(y=Y|f)q(f) df\n\n Here, we implement a default Monte Carlo routine.\n \"\"\"\n return tf.reduce_sum(\n self._mc_quadrature(self.log_prob, Fmu, Fvar, Y=Y, logspace=True, epsilon=epsilon),\n axis=-1,\n )\n\n def _variational_expectations(self, Fmu, Fvar, Y, epsilon=None):\n r\"\"\"\n Compute the expected log density of the data, given a Gaussian\n distribution for the function values.\n\n if\n q(f) = N(Fmu, Fvar) - Fmu: [N, D] Fvar: [N, D]\n\n and this object represents\n\n p(y|f) - Y: [N, 1]\n\n then this method computes\n\n ∫ (log p(y|f)) q(f) df.\n\n\n Here, we implement a default Monte Carlo quadrature routine.\n \"\"\"\n return tf.reduce_sum(\n self._mc_quadrature(self.log_prob, Fmu, Fvar, Y=Y, epsilon=epsilon), axis=-1\n )\n\n\nclass GaussianMC(MonteCarloLikelihood, Gaussian):\n \"\"\"\n Stochastic version of Gaussian likelihood for comparison.\n \"\"\"\n\n pass\n\n\nclass Softmax(MonteCarloLikelihood):\n \"\"\"\n The soft-max multi-class likelihood. It can only provide a stochastic\n Monte-Carlo estimate of the variational expectations term, but this\n added variance tends to be small compared to that due to mini-batching\n (when using the SVGP model).\n \"\"\"\n\n def __init__(self, num_classes, **kwargs):\n super().__init__(latent_dim=num_classes, observation_dim=None, **kwargs)\n self.num_classes = self.latent_dim\n\n def _log_prob(self, F, Y):\n return -tf.nn.sparse_softmax_cross_entropy_with_logits(logits=F, labels=Y[:, 0])\n\n def _conditional_mean(self, F):\n return tf.nn.softmax(F)\n\n def _conditional_variance(self, F):\n p = self.conditional_mean(F)\n return p - p ** 2\n", "meta": {"hexsha": "8a80ab116acd3e5ad6215d6ddf35d929839173e4", "size": 34040, "ext": "py", "lang": "Python", "max_stars_repo_path": "gpflow/likelihoods/likelihoods.py", "max_stars_repo_name": "christabella/GPflow", "max_stars_repo_head_hexsha": "30824d289f8ee3f58d4249238c8b7267e6a0b2fc", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "gpflow/likelihoods/likelihoods.py", "max_issues_repo_name": "christabella/GPflow", "max_issues_repo_head_hexsha": "30824d289f8ee3f58d4249238c8b7267e6a0b2fc", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "gpflow/likelihoods/likelihoods.py", "max_forks_repo_name": "christabella/GPflow", "max_forks_repo_head_hexsha": "30824d289f8ee3f58d4249238c8b7267e6a0b2fc", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.4844587353, "max_line_length": 111, "alphanum_fraction": 0.6415393655, "include": true, "reason": "import numpy", "num_tokens": 8496, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5467381519846138, "lm_q2_score": 0.35220178204788966, "lm_q1q2_score": 0.19256215144255093}} {"text": "\"\"\" hat_model.py models the environment and components for heliotropic hat \n in 3D. \n\n Author: Jonathon Sather\n Last updated: 4/15/2017\n\"\"\"\n\nimport numpy as np\nimport pdb\n\nclass DirectionalSource:\n \"\"\" Directional light source w/ direction and intensity. \"\"\"\n\n def __init__(self, (dirX, dirY, dirZ)):\n self.direction = np.array([dirX, dirY, dirZ])\n self.intensity = np.linalg.norm(self.direction)\n\nclass PointSource:\n \"\"\" Point light source w/ position and intensity. \"\"\"\n\n def __init__(self, (x, y, z), intensity):\n self.position = np.array([x, y, z])\n self.intensity = intensity\n\nclass LightSensor:\n \"\"\" Light sensor w/ value proportional to light intensity. \"\"\"\n\n def __init__(self, (x, y, z), (dirX, dirY, dirZ)):\n self.position = np.array([x, y, z])\n self.orientation = (np.array([dirX, dirY, dirZ]) /\n np.linalg.norm(np.array([dirX, dirY, dirZ]))) # Ensure unit magnitude\n self.value = 0\n self.color = np.array([255, 255, 0])\n\nclass Hat:\n \"\"\" A standard baseball hat with spacial orientation and bill position.\n Bill is represented as circular w/ offset from center. Hat class also\n stores light sensors attached to hat as a list of light sensor objects.\n \"\"\"\n\n def __init__(self, (x, y, z), theta, scale, restricted=True):\n self.billDiam = 1.5 * scale\n self.billOffset = 0.9 * scale\n self.color = np.array([0, 0, 255]) \n self.diam = 2 * scale\n self.lightSensors = []\n self.position = np.array([x, y, z])\n self.restricted = restricted # Restricted bill rotation\n self.theta = theta\n self.thetaDot = 2 * np.pi / 100 # Constant rotational speed\n\n def getBillCenter(self):\n \"\"\" Method to find the center of the bill based on angular position\n and hat geometry.\n \"\"\"\n\n center = self.position + np.array([np.cos(self.theta) *\n self.billOffset, np.sin(self.theta) * self.billOffset, 0])\n return center\n\n\n def getLSValues(self, mode='no_noise'):\n \"\"\" Fetches values of light sensors currently attached to hat. \"\"\"\n\n num_ls = len(self.lightSensors)\n ls_vals = np.empty((1, num_ls))\n\n for ls in range(num_ls):\n ls_vals[0,ls] = self.lightSensors[ls].value\n\n if mode == 'add_noise':\n ls_vals += np.random.normal(scale=0.00001,size=(1,num_ls))\n\n return ls_vals\n\n def get_state(self, pot=True, actions=None):\n \"\"\" Returns current state of hat (light sensor values + bill angle in\n numpy array).\n \"\"\"\n \n if pot: # State w/ potentiometer\n state = np.transpose(np.hstack((self.getLSValues(),\n np.array([[self.theta]]))))\n else: # State w/ last actions\n state = np.transpose(np.hstack((self.getLSValues(),\n np.array([actions]))))\n return state\n\n def includeLightSensors(self, quantity):\n \"\"\" Adds light sensors evenly spaced around hat base. \n Note that this method gets rid of any previously included \n light sensors.\n \"\"\"\n\n self.lightSensors = []\n sectorAngle = 2 * np.pi / quantity\n\n for i in range(quantity):\n (dx, dy, dz) = (np.cos(sectorAngle * i), np.sin(sectorAngle *\n i), 0)\n (x, y, z) = (self.position[0] + dx, self.position[1] + dy,\n self.position[2] + dz)\n\n self.lightSensors.append(LightSensor((x, y, z), (dx, dy, dz)))\n\n def rotateBill(self, direction):\n \"\"\" Rotates bill based on input direction and angular velocity. \"\"\"\n \n update = self.theta + direction * self.thetaDot\n if self.restricted:\n if update < 0 or update > (2 * np.pi): # Boundary at 0/2*pi\n pass\n else: # No boundary issues\n self.theta = update\n else:\n self.theta = update % (2 * np.pi)\n\n def rotateBillCCW(self):\n \"\"\" Rotates bill counter-clockwise. Includes stop at 0 radians by\n default. Return 1 if non-restricted rotation. 0 if restricted.\n \"\"\"\n\n update = self.theta - self.thetaDot\n rotation = 1\n\n if self.restricted:\n if update < 0:\n rotation = 0\n else:\n self.theta = update\n else:\n self.theta = self.theta % (2 * np.pi)\n\n return rotation\n\n def rotateBillCW(self):\n \"\"\" Rotates bill clockwise. Includes stop at 0 radians by default.\n Return 1 if non-restricted rotation. 0 if restricted.\n \"\"\"\n\n update = self.theta + self.thetaDot\n rotation = 1\n\n if self.restricted:\n if update > (2 * np.pi): # Overflow pi to -pi\n rotation = 0\n else: \n self.theta = update\n else:\n self.theta = update % (2 * np.pi)\n\n return rotation\n\n\n def updateSpeed(self, thetaDot):\n \"\"\" Method to update self.thetadot. \"\"\"\n\n self.thetaDot = thetaDot\n\nclass Environment: \n \"\"\" Environment contains data and regarding the hat environment. \"\"\"\n\n def __init__(self, (width, height)):\n self.boundary = np.array([width, height])\n self.color = np.array([255, 255, 255])\n\n self.hat = None\n self.directionalSources = []\n self.pointSources = []\n self.ambient = 0\n\n def addHat(self, hat):\n \"\"\" Method for adding or replacing hat. \"\"\"\n\n self.hat = hat\n\n def updateColor(self, (r, g, b)):\n \"\"\" Updates the color of the environment. \"\"\"\n\n self.color = np.array([r, g, b])\n\n def updateAmbient(self, ambient):\n \"\"\" Updates the ambient light value of the environment. \"\"\"\n\n self.ambient = ambient\n\n def addDirectionalSource(self, (dirX, dirY, dirZ)):\n \"\"\" Adds a directional source to the environment. \"\"\"\n\n self.directionalSources.append(DirectionalSource((dirX, dirY, dirZ)))\n\n def addPointSource(self, (x, y, z), intensity):\n \"\"\" Adds a point light source to the environment. \"\"\"\n\n self.pointSources.append(PointSource((x, y, z), intensity))\n\n def clearSources(self):\n \"\"\" Clears the ambient, point and directional light sources from \n the environment.\n \"\"\"\n\n self.directionalSources = []\n self.pointSources = []\n self.ambient = 0\n\n def notObstructedDirectional(self, hat, lightSensor, directionalSource):\n \"\"\" Returns 0 if light sensor obstructed from directional source by\n hat bill or base.\n \"\"\"\n distance = np.linalg.norm(lightSensor.position - hat.getBillCenter())\n\n # Only account for bill if light directed downwards.\n if np.dot(directionalSource.direction, np.array([0,0,1])) < 0:\n direction_down = 1\n else:\n direction_down = 0\n\n if (((distance < hat.billDiam / 2) and direction_down) or\n (np.dot(lightSensor.orientation, directionalSource.direction) > 0)):\n return 0\n \n return 1\n\n def notObstructedPoint(self, hat, lightSensor, pointSource):\n \"\"\" Returns 0 if light sensor obstructed from point source by hat\n bill or base.\n \"\"\"\n\n distance = np.linalg.norm(lightSensor.position - hat.getBillCenter())\n\n dir = lightSensor.position - pointSource.position\n\n # Only account for bill if light directed downwards.\n if np.dot(dir, np.array([0, 0, 1])) < 0:\n direction_down = 1\n else:\n direction_down = 0\n \n if (((distance < hat.billDiam / 2) and direction_down) or\n (np.dot(lightSensor.orientation, dir) > 0)):\n return 0\n\n return 1\n\n def updateLightSensor(self, lightSensor):\n \"\"\" Updates a single light sensor's value, considering ambient, point,\n and directional components.\n \"\"\"\n\n # Ambient\n lightSensor.value = self.ambient\n\n # Point\n for p in self.pointSources:\n #pdb.set_trace()\n inv_square = (1 / \n (np.linalg.norm(p.position - lightSensor.position) ** 2))\n\n lightSensor.value += (\n inv_square * (self.notObstructedPoint(self.hat, \n lightSensor, p) * np.dot(lightSensor.orientation, - \n (lightSensor.position - p.position) * p.intensity / \n np.linalg.norm(lightSensor.position - p.position))))\n\n # Directional\n for d in self.directionalSources:\n lightSensor.value += (self.notObstructedDirectional(self.hat, \n lightSensor, d) * np.dot(lightSensor.orientation, - d.direction))\n\n def update(self):\n \"\"\" Updates all light sensors on the hat. \"\"\"\n\n for lightSensor in self.hat.lightSensors:\n self.updateLightSensor(lightSensor)\n\nif __name__ == '__main__':\n pass\n\n\n", "meta": {"hexsha": "26423ab68c1e90cad8acf3aee71b398cea9c6080", "size": 9076, "ext": "py", "lang": "Python", "max_stars_repo_path": "simulation_no_pot/hat_model.py", "max_stars_repo_name": "jsather/heliotropic-hat", "max_stars_repo_head_hexsha": "9e17dfb45e6d0d5852ef331e4dbb2511e4282dc4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "simulation_no_pot/hat_model.py", "max_issues_repo_name": "jsather/heliotropic-hat", "max_issues_repo_head_hexsha": "9e17dfb45e6d0d5852ef331e4dbb2511e4282dc4", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "simulation_no_pot/hat_model.py", "max_forks_repo_name": "jsather/heliotropic-hat", "max_forks_repo_head_hexsha": "9e17dfb45e6d0d5852ef331e4dbb2511e4282dc4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.4142857143, "max_line_length": 79, "alphanum_fraction": 0.572939621, "include": true, "reason": "import numpy", "num_tokens": 2108, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5467381519846138, "lm_q2_score": 0.35220178204788966, "lm_q1q2_score": 0.19256215144255093}} {"text": "#! /usr/bin/env python\nimport os\nimport numpy as np\nfrom PythonPhot import getpsf, aper\nfrom astropy.io import fits as pyfits\n\n\ndef getcamera(imfile):\n \"\"\" Determine the camera name (e.g. ACS-WFC or WFC3-IR)\n from the header of the given image. The input imfile\n may be a string giving a fits filename, a pyfits hdu object,\n or a pyfits header.\n :param imfile:\n :return:\n \"\"\"\n import hstphot\n hdr = hstphot.getheader(imfile)\n instrument, detector = '', ''\n if 'CAMERA' in hdr:\n instrument = hdr['CAMERA']\n detector = ''\n elif 'INSTRUME' in hdr:\n instrument = hdr['INSTRUME']\n if 'DETECTOR' in hdr:\n detector = hdr['DETECTOR']\n camera = '-'.join([instrument, detector]).rstrip('-')\n return camera\n\n\ndef mkpsfmodel_stdstar(psfimdir=\"./\", psfrad=0.3, fitrad=0.15,\n starname='g191b2b',\n pixscale=0.03,\n bandlist=['f435w', 'f606w', 'f814w'],\n verbose=True):\n \"\"\" Construct a set of psf models from drizzled HST images of a\n standard star, with the star in the center of the image.\n\n :param psfimdir: psf image directory (where the input std star images are\n and also where the output psf model images will be put)\n :param psfrad: the scalar radius, in arcsec, of the circular area within\n which the PSF will be defined. This should be slightly larger\n than the radius of the brightest star that one will be\n interested in.\n :param fitrad: the scalar radius, in arcsec, of the circular area used in\n the least-square star fits. Stetson suggest that fitrad should\n approximately equal to the FWHM, slightly less for crowded\n fields. (fitrad must be smaller than psfrad.)\n\n :return : None\n \"\"\"\n # radius of aperture and sky annulus for first-pass aperture photometry,\n # used to scale the psf\n aparcsec = 2.5\n skyradarcsec = np.array([2.5, 3.5])\n\n for band in bandlist:\n\n # convert user-supplied radii from arcsec to pixels\n appix = aparcsec / pixscale\n skyradpix = skyradarcsec / pixscale\n psfradpix = psfrad / pixscale\n fitradpix = fitrad / pixscale\n\n inputfile = os.path.join(\n psfimdir, '%s.e00/%s_%s_e00_reg_drz_sci.fits' % (\n starname, starname, band))\n outputfile = os.path.join(\n psfimdir, '%s_%s_%2imas_psf_model.fits' % (\n starname, band, int(pixscale * 1000)))\n\n hdulist = pyfits.open(inputfile)\n hdr = hdulist[0].header\n imdat = hdulist[0].data\n if 'FILTER1' in hdr:\n if 'CLEAR' in hdr['FILTER1']:\n filtname = hdr['FILTER2']\n else:\n filtname = hdr['FILTER1']\n else:\n filtname = hdr['FILTER']\n camera = getcamera(hdr)\n\n # Define the conversion factor from the values in this image\n # to photons : photons per ADU.\n if 'BUNIT' not in hdr:\n if camera == 'WFC3-IR' and 'EXPTIME' in hdr:\n phpadu = hdr['EXPTIME']\n else:\n phpadu = 1\n elif hdr['BUNIT'].lower() in ['cps', 'electrons/s']:\n phpadu = hdr['EXPTIME']\n elif hdr['BUNIT'].lower() in ['counts', 'electrons']:\n phpadu = 1\n assert (phpadu is not None), \\\n \"Can't determine units from the image header.\"\n\n rdnoise = 0\n if 'READNSEA' in hdr:\n rdnoise = np.mean([hdr[key] for key in hdr.keys()\n if key.startswith('READNSE')])\n\n xmid = np.array([hdr['NAXIS1'] / 2.]) - 1\n ymid = np.array([hdr['NAXIS2'] / 2.]) - 1\n xpos, ypos = hstphot.getxycenter(\n inputfile, xmid, ymid, ext=0, radec=False,\n fitsconvention=False, verbose=True)\n if verbose:\n print(\"PSF recentering : (%.2f,%.2f) ==> (%.2f,%.2f)\" % (\n xmid, ymid, xpos, ypos))\n xpos = np.array([xpos])\n ypos = np.array([ypos])\n\n idpsf = np.arange(len(xpos))\n image = pyfits.getdata(inputfile)\n\n # run aper to get mags and sky values for specified coords\n mag, magerr, flux, fluxerr, sky, skyerr, badflag, outstr = \\\n aper.aper(image, xpos, ypos, phpadu=phpadu, apr=appix,\n zeropoint=25,\n skyrad=skyradpix, badpix=[-12000, 60000], exact=True)\n\n # use the star at those coords to generate a PSF model\n gauss, psf, psfmag = getpsf.getpsf(image, xpos, ypos, mag,\n np.asfarray([sky]), rdnoise,\n phpadu,\n idpsf, psfradpix, fitradpix,\n outputfile, zeropoint=25,\n debug=False)\n if verbose:\n print(\"PSF image written to %s\" % outputfile)\n return\n\n\ndef bin_image_data(arr, binfactor):\n # bin an array by reshaping it into a higher-order array and taking\n # the sum over the new dimension\n old_shape = arr.shape\n new_shape = np.array(old_shape) / binfactor\n shape = (new_shape[0], arr.shape[0] // new_shape[0],\n new_shape[1], arr.shape[1] // new_shape[1])\n return arr.reshape(shape).sum(-1).sum(1)\n\n\ndef mkpsfmodel(psfimage, psfrad=0.6, fitrad=0.3, pixscale=0.03, binning=None,\n phpadu=1, rdnoise=0, mag=25, zeropoint=25, sky=0,\n verbose=True):\n \"\"\" Construct a psf model from drizzled HST images of a\n standard star or composite star, with the star in the center of the image.\n\n :param psfimage: filename of the .fits file with the star at the center in\n image array 0.\n :param psfrad: the scalar radius, in arcsec, of the circular area within\n which the PSF will be defined. This should be slightly larger\n than the radius of the brightest star that one will be\n interested in measuring photometry for.\n :param fitrad: the scalar radius, in arcsec, of the circular area used in\n the least-square star fits. Stetson suggest that fitrad should\n approximately equal to the FWHM, slightly less for crowded\n fields. (fitrad must be smaller than psfrad.)\n :param pixscale: the pixel scale of the input image [arcseconds per pixel]\n :param phpadu: the \"gain\" of the input image in photons per ADU [?]\n :param rdnoise: the readnoise of the input image, in ADU [?]\n :param mag: the magnitude of the star in the input image\n :param zeropoint: the zero point of the input image (magnitude that\n produces a flux of 1 [ADU per second?]\n :param sky: the sky brightness of the input image, in ADU per second [?]\n :return : None\n \"\"\"\n # TODO : currently the units in the __doc__ text are guesses. Need to\n # review the code in the PythonPhot source and check\n import hstphot\n\n # convert user-supplied radii from arcsec to pixels\n psfradpix = psfrad / pixscale\n fitradpix = fitrad / pixscale\n\n outputfile = psfimage.replace('.fits', '_model.fits')\n hdulist = pyfits.open(psfimage)\n hdr = hdulist[0].header\n imdat = hdulist[0].data\n\n xmid = np.array([hdr['NAXIS1'] / 2.]) - 1\n ymid = np.array([hdr['NAXIS2'] / 2.]) - 1\n xpos, ypos = hstphot.getxycenter(\n psfimage, xmid, ymid, ext=0, radec=False,\n fitsconvention=False, verbose=True)\n if verbose:\n print(\"PSF recentering : (%.2f,%.2f) ==> (%.2f,%.2f)\" % (\n xmid, ymid, xpos, ypos))\n xpos = np.array([xpos])\n ypos = np.array([ypos])\n mag = np.array([mag])\n idpsf = np.arange(len(xpos))\n\n if binning is not None:\n assert isinstance(binning, int)\n assert not (imdat.shape[0] % binning)\n assert not (imdat.shape[1] % binning)\n imdat = bin_image_data(imdat, binning)\n xpos /= binning\n ypos /= binning\n psfradpix /= binning\n fitradpix /= binning\n print(\"Binning input image %i x %i\" % (binning, binning))\n\n\n # use the star at those coords to generate a PSF model\n gauss, psf, psfmag = getpsf.getpsf(\n imdat, xpos, ypos, mag, np.asfarray([sky]), rdnoise,\n phpadu, idpsf, psfradpix, fitradpix, outputfile, zeropoint=zeropoint,\n debug=False)\n if verbose:\n print(\"PSF image written to %s\" % outputfile)\n return outputfile, gauss, psf, psfmag\n\n\ndef main():\n import argparse\n\n parser = argparse.ArgumentParser(\n description=\"Make a PythonPhot psf model from the a single-star image\")\n\n # Required positional argument\n parser.add_argument('inputimage',\n help='FITS file with a single star at the center.')\n\n # optional keyword arguments\n parser.add_argument('--pixscale', type=float,\n default=0.03,\n help=\"arcseconds per pixel.\")\n\n argv = parser.parse_args()\n\n mkpsfmodel(argv.inputimage, pixscale=argv.pixscale)\n\n\nif __name__ == '__main__':\n main()\n", "meta": {"hexsha": "9837af3530cefabfe59c432a2668298602004b3e", "size": 9172, "ext": "py", "lang": "Python", "max_stars_repo_path": "mkpsfmodel.py", "max_stars_repo_name": "koconnor4/hstphot", "max_stars_repo_head_hexsha": "04ec83fc6dce056bd6153e407446e1be4dff3923", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "mkpsfmodel.py", "max_issues_repo_name": "koconnor4/hstphot", "max_issues_repo_head_hexsha": "04ec83fc6dce056bd6153e407446e1be4dff3923", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "mkpsfmodel.py", "max_forks_repo_name": "koconnor4/hstphot", "max_forks_repo_head_hexsha": "04ec83fc6dce056bd6153e407446e1be4dff3923", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.3765690377, "max_line_length": 79, "alphanum_fraction": 0.5872219799, "include": true, "reason": "import numpy,from astropy", "num_tokens": 2480, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5467381372136563, "lm_q2_score": 0.352201788847459, "lm_q1q2_score": 0.19256214995777723}} {"text": "# /mpcutilities/mpcutilities/leapsec.py\n\"\"\"\n \n--------------------------------------------------------------\n\nNov 2018\n\nPayne\n\nOriginal code by Sonia Keys \n\nProvides leap second information by year. It requires a file\nof leap second data in the format prepared by Judah Levine at NIST.\nSee https://www.ietf.org/timezones/data/leap-seconds.list for example.\n\n*** Payne: I believe this code to be unnecessary / unused ***\n\n*** Payne: I am keeping it for archival purposes ***\n\n--------------------------------------------------------------\n\n\"\"\"\n\n# Import third-party packages\n# --------------------------------------------------------------\nimport numpy as np\nfrom pkg_resources import resource_filename\n\n__all__ = [\"LeapSeconds\"]\n\n\nclass LeapSeconds:\n \"\"\"loads leap second data from a file.\n\n Parameters\n ----------\n fn : string\n File name of leap second data, by default leap-seconds.list.\n jd_ref_utc : float\n Reference date, JD at which to start counting leap seconds.\n The default value of 2415020.5 is year 1900.0.\n \"\"\"\n\n def __init__(self, fn=resource_filename('mpcutilities','data/leap-seconds.list'), jd_ref_utc=2415020.5):\n # Create two numpy arrays, secSinceArray and leapSecArray,\n # that I can use to make a look-up table.\n # This is just reading Judah Levine's file.\n self.jd_ref_utc = jd_ref_utc\n secSinceList = []\n leapSecList = []\n with open(fn) as f:\n for line in f:\n if not line.startswith('#'):\n secondsSince, leapSeconds = line.rsplit('#')[0].split()\n secSinceList.append(int(secondsSince))\n leapSecList.append(int(leapSeconds))\n self.secSinceArray = np.array(secSinceList)\n self.leapSecArray = np.array(leapSecList)\n\n def getLeapSeconds(self, jd_utc):\n \"\"\"\n gets number of leap seconds since the reference Julian date.\n\n Parameters\n ----------\n jd_utc : float\n JD of end of period since reference date.\n\n Returns\n -------\n int\n number of leap seconds since reference date.\n \"\"\"\n # Given a Julian Date in UTC, determine the number of seconds\n # that have elapsed since the reference time. Then find the\n # correspoding number of leap seconds.\n max_idx = self.secSinceArray.shape[0] - 1\n secsSince = self.secondsSinceRef(jd_utc)\n idx = np.searchsorted(self.secSinceArray, int(secsSince),\n side='right') - 1\n if idx < 0:\n return 0\n if idx > max_idx:\n return self.leapSecArray[max_idx]\n else:\n return self.leapSecArray[idx]\n\n def secondsSinceRef(self, jd_utc):\n \"\"\"Determines the seconds (not just leap seconds) that have elapsed\n since the reference Julian date.\n\n Parameters\n ----------\n jd_utc : float\n JD of end of period since reference date.\n\n Returns\n -------\n float\n number of seconds since reference date.\n \"\"\"\n secondsSince = (jd_utc - self.jd_ref_utc) * 24.0 * 60 * 60\n return secondsSince\n", "meta": {"hexsha": "382d87ae0b3dfc37dd6f7c6922ef89d9d2b7776c", "size": 3207, "ext": "py", "lang": "Python", "max_stars_repo_path": "mpcutilities/leapsec.py", "max_stars_repo_name": "matthewjohnpayne/MPCUtilities", "max_stars_repo_head_hexsha": "3132ad43b69e9271635a20fb07f33abd1d11b7d3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-08-03T16:24:24.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-03T16:24:24.000Z", "max_issues_repo_path": "mpcutilities/leapsec.py", "max_issues_repo_name": "matthewjohnpayne/MPCUtilities", "max_issues_repo_head_hexsha": "3132ad43b69e9271635a20fb07f33abd1d11b7d3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-11-15T17:47:56.000Z", "max_issues_repo_issues_event_max_datetime": "2021-11-15T17:47:56.000Z", "max_forks_repo_path": "mpcutilities/leapsec.py", "max_forks_repo_name": "matthewjohnpayne/MPCUtilities", "max_forks_repo_head_hexsha": "3132ad43b69e9271635a20fb07f33abd1d11b7d3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.8365384615, "max_line_length": 108, "alphanum_fraction": 0.5734331151, "include": true, "reason": "import numpy", "num_tokens": 699, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.546738151984614, "lm_q2_score": 0.3522017752483203, "lm_q1q2_score": 0.192562147724967}} {"text": "#!/usr/bin/env python3\nimport configparser\nimport os, h5py, sys \nimport numpy as np\nfrom matplotlib import pyplot as plt\nthisDir = os.path.dirname(os.path.abspath(__file__))\nparentDir = os.path.dirname(thisDir)\nsys.path.insert(0,parentDir)\nfrom pyCRTM import pyCRTM, profilesCreate\n \ndef main(coefficientPath, sensor_id):\n thisDir = os.path.dirname(os.path.abspath(__file__))\n cases = os.listdir( os.path.join(thisDir,'data') )\n cases.sort()\n # create 4 profiles for each of the 4 cases\n profiles = profilesCreate( 4, 92 )\n storedTb = []\n storedEmis = []\n # populate the cases, and previously calculated Tb from crtm test program. \n for i,c in enumerate(cases):\n h5 = h5py.File(os.path.join(thisDir,'data',c) , 'r')\n profiles.Angles[i,0] = h5['zenithAngle'][()]\n profiles.Angles[i,1] = 999.9 \n profiles.Angles[i,2] = 100.0 # 100 degrees zenith below horizon.\n profiles.Angles[i,3] = 0.0 # zero solar azimuth \n profiles.Angles[i,4] = h5['scanAngle'][()]\n profiles.DateTimes[i,0] = 2001\n profiles.DateTimes[i,1] = 1\n profiles.DateTimes[i,2] = 1\n profiles.Pi[i,:] = np.asarray(h5['pressureLevels'] )\n profiles.P[i,:] = np.asarray(h5['pressureLayers'][()])\n profiles.T[i,:] = np.asarray(h5['temperatureLayers'])\n profiles.Q[i,:] = np.asarray(h5['humidityLayers'])\n profiles.O3[i,:] = np.asarray(h5['ozoneConcLayers'])\n profiles.clouds[i,:,0,0] = np.asarray(h5['cloudConcentration'])\n profiles.clouds[i,:,0,1] = np.asarray(h5['cloudEffectiveRadius'])\n profiles.aerosols[i,:,0,0] = np.asarray(h5['aerosolConcentration'])\n profiles.aerosols[i,:,0,1] = np.asarray(h5['aerosolEffectiveRadius'])\n profiles.aerosolType[i] = h5['aerosolType'][()]\n profiles.cloudType[i] = h5['cloudType'][()]\n profiles.cloudFraction[i,:] = h5['cloudFraction'][()]\n profiles.climatology[i] = h5['climatology'][()]\n profiles.surfaceFractions[i,:] = h5['surfaceFractions']\n profiles.surfaceTemperatures[i,:] = h5['surfaceTemperatures']\n profiles.S2m[i,1] = 33.0 # just use salinity out of S2m for the moment.\n profiles.windSpeed10m[i] = 5.0\n profiles.LAI[i] = h5['LAI'][()]\n profiles.windDirection10m[i] = h5['windDirection10m'][()]\n # land, soil, veg, water, snow, ice\n profiles.surfaceTypes[i,0] = h5['landType'][()]\n profiles.surfaceTypes[i,1] = h5['soilType'][()]\n profiles.surfaceTypes[i,2] = h5['vegType'][()]\n profiles.surfaceTypes[i,3] = h5['waterType'][()]\n profiles.surfaceTypes[i,4] = h5['snowType'][()]\n profiles.surfaceTypes[i,5] = h5['iceType'][()]\n storedTb.append(np.asarray(h5['Tb']))\n storedEmis.append(np.asarray(h5['emissivity_atms']))\n h5.close()\n\n crtmOb = pyCRTM()\n crtmOb.profiles = profiles\n crtmOb.coefficientPath = pathInfo['CRTM']['coeffs_dir']\n crtmOb.sensor_id = sensor_id\n crtmOb.nThreads = 4\n\n crtmOb.loadInst()\n\n crtmOb.runDirect()\n forwardTb = crtmOb.Bt\n forwardEmissivity = crtmOb.surfEmisRefl[0,:]\n crtmOb.surfEmisRefl = []\n\n crtmOb.runK()\n kTb = crtmOb.Bt\n kEmissivity = crtmOb.surfEmisRefl[0,:]\n\n if ( all( np.abs( forwardTb.flatten() - np.asarray(storedTb).flatten() ) <= 1e-5) and all( np.abs( kTb.flatten() - np.asarray(storedTb).flatten() ) <= 1e-5) ):\n print(\"Yay! all values are close enough to what CRTM test program produced!\")\n else: \n print(\"Boo! something failed. Look at cris plots\")\n wavenumbers = np.zeros([4,1305])\n wavenumbers[0:4,:] = np.linspace(1,1306,1305)\n plt.figure()\n plt.plot(wavenumbers.T,forwardTb.T-np.asarray(storedTb).T ) \n plt.legend(['1','2','3','4'])\n plt.savefig(os.path.join(thisDir,'cris'+'_spectrum_forward.png'))\n plt.figure()\n plt.plot(wavenumbers.T,forwardEmissivity.T-np.asarray(storedEmis).T)\n plt.savefig(os.path.join(thisDir,'cris'+'_emissivity_forward.png')) \n \n plt.figure()\n plt.plot(wavenumbers.T,kTb.T-np.asarray(storedTb).T)\n plt.savefig(os.path.join(thisDir,'cris'+'_spectrum_k.png'))\n plt.figure()\n plt.plot(wavenumbers.T,kEmissivity.T-np.asarray(storedEmis).T)\n plt.savefig(os.path.join(thisDir,'cris'+'_emissivity_k.png')) \n sys.exit(\"Boo! didn't pass tolerance with CRTM test program.\")\n\n\nif __name__ == \"__main__\":\n pathInfo = configparser.ConfigParser()\n pathInfo.read( os.path.join(parentDir,'crtm.cfg') ) \n coefficientPath = pathInfo['CRTM']['coeffs_dir']\n sensor_id = 'cris_npp'\n main(coefficientPath, sensor_id)\n \n", "meta": {"hexsha": "868f4befd3ff09e2f675160294422d8976c44a8a", "size": 4668, "ext": "py", "lang": "Python", "max_stars_repo_path": "testCases/test_cris.py", "max_stars_repo_name": "karpob/pycrtm", "max_stars_repo_head_hexsha": "3f32c105e4dfa087d3bc9d94934470b09005e20a", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-06-29T07:12:15.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-26T15:55:16.000Z", "max_issues_repo_path": "testCases/test_cris.py", "max_issues_repo_name": "karpob/pycrtm", "max_issues_repo_head_hexsha": "3f32c105e4dfa087d3bc9d94934470b09005e20a", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 50, "max_issues_repo_issues_event_min_datetime": "2019-07-29T14:33:14.000Z", "max_issues_repo_issues_event_max_datetime": "2020-07-01T09:34:25.000Z", "max_forks_repo_path": "testCases/test_cris.py", "max_forks_repo_name": "karpob/pycrtm", "max_forks_repo_head_hexsha": "3f32c105e4dfa087d3bc9d94934470b09005e20a", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2019-10-21T16:07:13.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-20T01:29:53.000Z", "avg_line_length": 43.6261682243, "max_line_length": 164, "alphanum_fraction": 0.6338903171, "include": true, "reason": "import numpy", "num_tokens": 1372, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5467381519846138, "lm_q2_score": 0.3522017684487511, "lm_q1q2_score": 0.19256214400738306}} {"text": "import ctypes\nimport os\nimport numpy as np\nimport time\n\nif os.name == 'nt':\n import msvcrt\n def getch():\n return msvcrt.getch().decode()\nelse:\n import sys, tty, termios\n fd = sys.stdin.fileno()\n old_settings = termios.tcgetattr(fd)\n def getch():\n try:\n tty.setraw(sys.stdin.fileno())\n ch = sys.stdin.read(1)\n finally:\n termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)\n return ch\n\nfrom dynamixel_sdk import * # Uses Dynamixel SDK library\n\n# Length of the arms\na0 \t\t\t\t= 10 \na1 \t\t\t\t= 5\na2 \t\t\t\t= 20\n# Angles of the joints\nt0 \t\t\t\t= 0\nt1\t\t\t\t= 0 \nt2\t\t\t\t= 0\n\n# Angles in radians\nt0 \t\t= t0/180*np.pi\nt1 \t\t= t1/180*np.pi\nt2 \t\t= t2/180*np.pi\n\n# Control Table address\nADDR_TORQUE_ENABLE = 64\nADDR_PROFILE_VELOCITY = 112\nADDR_PROFILE_ACCELERATION = 108\nADDR_GOAL_POSITION = 116\nADDR_PRESENT_POSITION = 132\nADDR_DRIVE_MODE = 10\nADDR_MOVING_STATUS = 123\n\n# Data Byte Length\nLEN_GOAL_POSITION = 4\nLEN_PRESENT_POSITION = 4\n\n# Protocol version\nPROTOCOL_VERSION = 2.0 # See which protocol version is used in the Dynamixel\n\n# Default setting\nDXL1_ID = 71 # Dynamixel#1 ID : 1\nDXL2_ID = 72 # Dynamixel#1 ID : 2\nBAUDRATE = 1000000 # Dynamixel default baudrate : 57600\nDEVICENAME = '/dev/ttyUSB0' # Check which port is being used on your controller\n # ex) Windows: \"COM1\" Linux: \"/dev/ttyUSB0\" Mac: \"/dev/tty.usbserial-*\"\n\nTORQUE_ENABLE = 1 # Value for enabling the torque\nTORQUE_DISABLE = 0 # Value for disabling the torque\n#DXL1_MIN_POSITION_VALUE = -1000\t\t\t# Dynamixel 1 will rotate between this value\n#DXL1_MAX_POSITION_VALUE = 1000\t\t# and this value \n#DXL2_MIN_POSITION_VALUE = -2000 \t\t# Dynamixel 2 will rotate between this value\n#DXL2_MAX_POSITION_VALUE = 2000\t\t# and this value\nDXL_MOVING_STATUS_THRESHOLD = 20 \t\t# Dynamixel moving status threshold\n\nindex = 0\ndxl1_goal_position = [DXL1_MIN_POSITION_VALUE, DXL1_MAX_POSITION_VALUE] # Goal position of dynamixel 1\ndxl2_goal_position = [DXL2_MIN_POSITION_VALUE, DXL2_MAX_POSITION_VALUE] # Goal position of dynamixel 2\n\n# Initialize PortHandler instance\n# Set the port path\n# Get methods and members of PortHandlerLinux or PortHandlerWindows\nportHandler = PortHandler(DEVICENAME)\n\n# Initialize PacketHandler instance\n# Set the protocol version\n# Get methods and members of Protocol1PacketHandler or Protocol2PacketHandler\npacketHandler = PacketHandler(PROTOCOL_VERSION)\n\n# Initialize GroupBulkWrite instance\ngroupBulkWrite = GroupBulkWrite(portHandler, packetHandler)\n\n# Initialize GroupBulkRead instace for Present Position\ngroupBulkRead = GroupBulkRead(portHandler, packetHandler)\n\n# Open port\nif portHandler.openPort():\n print(\"Succeeded to open the port\")\nelse:\n print(\"Failed to open the port\")\n print(\"Press any key to terminate...\")\n getch()\n quit()\n\n# Set port baudrate\nif portHandler.setBaudRate(BAUDRATE):\n print(\"Succeeded to change the baudrate\")\nelse:\n print(\"Failed to change the baudrate\")\n print(\"Press any key to terminate...\")\n getch()\n quit()\n\n# Enable Dynamixel Torque DXL1\ndxl_comm_result, dxl_error = packetHandler.write1ByteTxRx(portHandler, DXL1_ID, ADDR_TORQUE_ENABLE, TORQUE_ENABLE)\nif dxl_comm_result != COMM_SUCCESS:\n print(\"%s\" % packetHandler.getTxRxResult(dxl_comm_result))\nelif dxl_error != 0:\n print(\"%s\" % packetHandler.getRxPacketError(dxl_error))\nelse:\n print(\"Dynamixel 1 has been successfully connected\")\n\n# Enable Dynamixel Torque DXL2\ndxl_comm_result, dxl_error = packetHandler.write1ByteTxRx(portHandler, DXL2_ID, ADDR_TORQUE_ENABLE, TORQUE_ENABLE)\nif dxl_comm_result != COMM_SUCCESS:\n print(\"%s\" % packetHandler.getTxRxResult(dxl_comm_result))\nelif dxl_error != 0:\n print(\"%s\" % packetHandler.getRxPacketError(dxl_error))\nelse:\n print(\"Dynamixel 2 has been successfully connected\")\n\n# Add parameter storage for Dynamixel#1 present position\ndxl_addparam_result = groupBulkRead.addParam(DXL1_ID, ADDR_PRESENT_POSITION, LEN_PRESENT_POSITION)\nif dxl_addparam_result != True:\n print(\"[ID:%03d] groupBulkRead addparam failed\" % DXL1_ID)\n quit()\n\n# Add parameter storage for Dynamixel#2 present position\ndxl_addparam_result = groupBulkRead.addParam(DXL2_ID, ADDR_PRESENT_POSITION, LEN_PRESENT_POSITION)\nif dxl_addparam_result != True:\n print(\"[ID:%03d] groupBulkRead addparam failed\" % DXL2_ID)\n quit()\n\n\ndef end_eff_pos(t0,t1,te):\n # Parameter table with columns \" theta, alpha, r or a, d \n \n param_tab = [[t0 , 0 , a0 , 0 ],\n [t1 , 0 , a1 , 0 ],\n [t2 , 0 , a2 , 0 ]]\n \n # Transformation matrix\n\n i=0\n T0_1 = [[np.cos(param_tab[i][0]) , -np.cos(param_tab[i][1])*np.sin(param_tab[i][0]), np.sin(param_tab[i][1])*np.sin(param_tab[i][0]) , param_tab[i][2]*np.cos(param_tab[i][0])],\n [np.sin(param_tab[i][0]) , np.cos(param_tab[i][1])*np.cos(param_tab[i][0]) , -np.sin(param_tab[i][1])*np.cos(param_tab[i][0]) , param_tab[i][2]*np.sin(param_tab[i][0])],\n [ 0 , np.sin(param_tab[i][1]) , np.cos(param_tab[i][1]) , param_tab[i][3] ],\n [0 , 0 , 0 , 1 ]]\n\n i=1\n T1_2 = [[np.cos(param_tab[i][0]) , -np.cos(param_tab[i][1])*np.sin(param_tab[i][0]), np.sin(param_tab[i][1])*np.sin(param_tab[i][0]) , param_tab[i][2]*np.cos(param_tab[i][0])],\n [np.sin(param_tab[i][0]) , np.cos(param_tab[i][1])*np.cos(param_tab[i][0]) , -np.sin(param_tab[i][1])*np.cos(param_tab[i][0]) , param_tab[i][2]*np.sin(param_tab[i][0])],\n [ 0 , np.sin(param_tab[i][1]) , np.cos(param_tab[i][1]) , param_tab[i][3] ],\n [0 , 0 , 0 , 1 ]]\n\n i=2\n T2_3 = [[np.cos(param_tab[i][0]) , -np.cos(param_tab[i][1])*np.sin(param_tab[i][0]), np.sin(param_tab[i][1])*np.sin(param_tab[i][0]) , param_tab[i][2]*np.cos(param_tab[i][0])],\n [np.sin(param_tab[i][0]) , np.cos(param_tab[i][1])*np.cos(param_tab[i][0]) , -np.sin(param_tab[i][1])*np.cos(param_tab[i][0]) , param_tab[i][2]*np.sin(param_tab[i][0])],\n [ 0 , np.sin(param_tab[i][1]) , np.cos(param_tab[i][1]) , param_tab[i][3] ],\n [0 , 0 , 0 , 1 ]]\n \n \n \n\n\n\n\nwhile 1:\n print(\"Press any key to continue! (or press ESC to quit!)\")\n if getch() == chr(0x1b):\n break\n\n # Allocate goal position value into byte array\n param_goal_position_dxl1 = [DXL_LOBYTE(DXL_LOWORD(dxl1_goal_position[index])), DXL_HIBYTE(DXL_LOWORD(dxl1_goal_position[index])), DXL_LOBYTE(DXL_HIWORD(dxl1_goal_position[index])), DXL_HIBYTE(DXL_HIWORD(dxl1_goal_position[index]))]\n param_goal_position_dxl2 = [DXL_LOBYTE(DXL_LOWORD(dxl2_goal_position[index])), DXL_HIBYTE(DXL_LOWORD(dxl2_goal_position[index])), DXL_LOBYTE(DXL_HIWORD(dxl2_goal_position[index])), DXL_HIBYTE(DXL_HIWORD(dxl2_goal_position[index]))]\n \n # Add Dynamixel#1 goal position value to the Bulkwrite parameter storage\n dxl_addparam_result = groupBulkWrite.addParam(DXL1_ID, ADDR_GOAL_POSITION, LEN_GOAL_POSITION, param_goal_position_dxl1)\n if dxl_addparam_result != True:\n print(\"[ID:%03d] groupBulkWrite addparam failed\" % DXL1_ID)\n quit()\n # Add Dynamixel#2 goal position value to the Bulkwrite parameter storage\n dxl_addparam_result = groupBulkWrite.addParam(DXL2_ID, ADDR_GOAL_POSITION, LEN_GOAL_POSITION, param_goal_position_dxl2)\n if dxl_addparam_result != True:\n print(\"[ID:%03d] groupBulkWrite addparam failed\" % DXL2_ID)\n quit()\n\n\n # Bulkwrite goal position values for both the dynamixels\n dxl_comm_result = groupBulkWrite.txPacket()\n if dxl_comm_result != COMM_SUCCESS:\n print(\"%s\" % packetHandler.getTxRxResult(dxl_comm_result))\n\n # Clear bulkwrite parameter storage\n groupBulkWrite.clearParam()\n\n\n while 1:\n # Bulkread present positions of both dynamixels\n dxl_comm_result = groupBulkRead.txRxPacket()\n if dxl_comm_result != COMM_SUCCESS:\n print(\"%s\" % packetHandler.getTxRxResult(dxl_comm_result))\n\n # Check if groupbulkread data of Dynamixel#1 is available\n dxl_getdata_result = groupBulkRead.isAvailable(DXL1_ID, ADDR_PRESENT_POSITION, LEN_PRESENT_POSITION)\n if dxl_getdata_result != True:\n print(\"[ID:%03d] groupBulkRead getdata failed\" % DXL1_ID)\n quit()\n\n # Check if groupbulkread data of Dynamixel#2 is available\n dxl_getdata_result = groupBulkRead.isAvailable(DXL2_ID, ADDR_PRESENT_POSITION, LEN_PRESENT_POSITION)\n if dxl_getdata_result != True:\n print(\"[ID:%03d] groupBulkRead getdata failed\" % DXL2_ID)\n quit()\n\n\t# Get present position value\n dxl1_present_position = groupBulkRead.getData(DXL1_ID, ADDR_PRESENT_POSITION, LEN_PRESENT_POSITION)\n dxl2_present_position = groupBulkRead.getData(DXL2_ID, ADDR_PRESENT_POSITION, LEN_PRESENT_POSITION)\n\n\tnumber = dxl1_present_position & 0xFFFFFFFF\n dxl1_present_position = ctypes.c_long(number).value\n\n\tnumber = dxl2_present_position & 0xFFFFFFFF\n dxl2_present_position = ctypes.c_long(number).value\n\n\tprint(\"[ID:%03d] Present Position : %d \\t [ID:%03d] LED Value: %d\" % (DXL1_ID, dxl1_present_position, DXL2_ID, dxl2_present_position))\n\n\tif ((abs(dxl1_goal_position[index] - dxl1_present_position) > DXL_MOVING_STATUS_THRESHOLD) and (abs(dx2_goal_position[index] - dxl2_present_position) > DXL_MOVING_STATUS_THRESHOLD)):\n\t break\n\n # Change goal position\n if index == 0:\n index = 1\n else:\n index = 0\n\n\n# Clear bulkread parameter storage\ngroupBulkRead.clearParam()\n\n\n# Disable Dynamixel Torque DXL1\ndxl_comm_result, dxl_error = packetHandler.write1ByteTxRx(portHandler, DXL1_ID, ADDR_TORQUE_ENABLE, TORQUE_DISABLE)\nif dxl_comm_result != COMM_SUCCESS:\n print(\"%s\" % packetHandler.getTxRxResult(dxl_comm_result))\nelif dxl_error != 0:\n print(\"%s\" % packetHandler.getRxPacketError(dxl_error))\n\n# Disable Dynamixel Torque DXL2\ndxl_comm_result, dxl_error = packetHandler.write1ByteTxRx(portHandler, DXL2_ID, ADDR_TORQUE_ENABLE, TORQUE_DISABLE)\nif dxl_comm_result != COMM_SUCCESS:\n print(\"%s\" % packetHandler.getTxRxResult(dxl_comm_result))\nelif dxl_error != 0:\n print(\"%s\" % packetHandler.getRxPacketError(dxl_error))\n\n# Close port\nportHandler.closePort()\n\n", "meta": {"hexsha": "cb268d8717283622f1cf67e3ec33732380a514de", "size": 10889, "ext": "py", "lang": "Python", "max_stars_repo_path": "DynamixelWorkingMotionControl/forward_kinematics.py", "max_stars_repo_name": "tummalag/Controlled-Flight-of-High-DOF-Humanoid-Robot", "max_stars_repo_head_hexsha": "383f41c504b5a08ffd6d0b4c8f6013e4070d8458", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "DynamixelWorkingMotionControl/forward_kinematics.py", "max_issues_repo_name": "tummalag/Controlled-Flight-of-High-DOF-Humanoid-Robot", "max_issues_repo_head_hexsha": "383f41c504b5a08ffd6d0b4c8f6013e4070d8458", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "DynamixelWorkingMotionControl/forward_kinematics.py", "max_forks_repo_name": "tummalag/Controlled-Flight-of-High-DOF-Humanoid-Robot", "max_forks_repo_head_hexsha": "383f41c504b5a08ffd6d0b4c8f6013e4070d8458", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.5610687023, "max_line_length": 235, "alphanum_fraction": 0.6591055193, "include": true, "reason": "import numpy", "num_tokens": 2995, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.5467381519846138, "lm_q2_score": 0.3522017684487511, "lm_q1q2_score": 0.19256214400738306}} {"text": "import os\n\nimport numpy as np\n\nfrom astropy import units as u\nfrom astropy import wcs\nfrom astropy.coordinates import EarthLocation\nfrom astropy.coordinates import FK5\nfrom astropy.coordinates import SkyCoord\nfrom astropy.io import fits\nfrom astropy.time import Time\nfrom ccdproc import CCDData\nfrom collections import namedtuple\nfrom skimage.feature import register_translation\nfrom skimage.util import view_as_blocks\n\nfrom pocs import PanBase\nfrom pocs.utils import images as img_utils\n\nPointingError = namedtuple('PointingError', ['delta_ra', 'delta_dec', 'magnitude'])\n\n\nclass Image(PanBase):\n\n def __init__(self, fits_file, wcs_file=None):\n \"\"\"Object to represent a single image from a PANOPTES camera.\n\n Instantiate the object by providing a .cr2 (or .dng) file.\n\n Args:\n fits_file (str): Name of FITS file to be read (can be .fz)\n wcs_file (str, optional): Name of FITS file to use for WCS\n \"\"\"\n super().__init__()\n assert os.path.exists(fits_file), self.logger.warning('File does not exist: {}'.format(fits_file))\n\n if fits_file.endswith('.fz'):\n fits_file = img_utils.fpack(fits_file, unpack=True)\n\n assert fits_file.lower().endswith(('.fits')), self.logger.warning('File must end with .fits')\n\n self.wcs = None\n self._wcs_file = None\n self.fits_file = fits_file\n\n if wcs_file is not None:\n self.wcs_file = wcs_file\n else:\n self.wcs_file = fits_file\n\n with fits.open(self.fits_file, 'readonly') as hdu:\n self.header = hdu[0].header\n self.data = hdu[0].data\n\n assert 'DATE-OBS' in self.header, self.logger.warning('FITS file must contain the DATE-OBS keyword')\n assert 'EXPTIME' in self.header, self.logger.warning('FITS file must contain the EXPTIME keyword')\n\n self.RGGB = CCDData(data=self.data, unit='adu',\n meta=self.header,\n mask=np.zeros(self.data.shape))\n\n # Location Information\n cfg_loc = self.config['location']\n self.loc = EarthLocation(lat=cfg_loc['latitude'],\n lon=cfg_loc['longitude'],\n height=cfg_loc['elevation'],\n )\n # Time Information\n self.starttime = Time(self.header['DATE-OBS'], location=self.loc)\n self.exptime = float(self.header['EXPTIME']) * u.second\n self.midtime = self.starttime + (self.exptime / 2.0)\n self.sidereal = self.midtime.sidereal_time('apparent')\n self.FK5_Jnow = FK5(equinox=self.midtime)\n\n # Coordinates from header keywords\n self.header_pointing = None\n self.header_RA = None\n self.header_Dec = None\n self.header_HA = None\n\n # Coordinates from WCS\n self.pointing = None\n self.RA = None\n self.Dec = None\n self.HA = None\n\n self.get_header_pointing()\n self.get_wcs_pointing()\n\n self._luminance = None\n self._pointing = None\n self._pointing_error = None\n\n @property\n def wcs_file(self):\n \"\"\"WCS file name\n\n When setting the WCS file name, the WCS information will be read,\n setting the `wcs` property.\n \"\"\"\n return self._wcs_file\n\n @wcs_file.setter\n def wcs_file(self, filename):\n if filename is not None:\n try:\n w = wcs.WCS(filename)\n assert w.is_celestial\n\n self.wcs = w\n self._wcs_file = filename\n except Exception:\n self.logger.warn(\"Can't get WCS from FITS file (try solve_field)\")\n\n @property\n def luminance(self):\n \"\"\"Luminance for the image\n\n Bin the image 2x2 combining each RGGB set of pixels in to a single\n luminance value.\n \"\"\"\n if self._luminance is None:\n block_size = (2, 2)\n image_out = view_as_blocks(self.RGGB.data, block_size)\n\n for i in range(len(image_out.shape) // 2):\n image_out = np.average(image_out, axis=-1)\n\n self._luminance = image_out\n\n return self._luminance\n\n @property\n def pointing_error(self):\n \"\"\"Pointing error namedtuple (delta_ra, delta_dec, magnitude)\n\n Returns pointing error information. The first time this is accessed\n this will solve the field if not previously solved.\n\n Returns:\n namedtuple: Pointing error information\n \"\"\"\n if self._pointing_error is None:\n assert self.pointing is not None, self.logger.warn(\"No WCS, can't get pointing_error\")\n assert self.header_pointing is not None\n\n if self.wcs is None:\n self.solve_field()\n\n mag = self.pointing.separation(self.header_pointing)\n dDec = self.pointing.dec - self.header_pointing.dec\n dRA = self.pointing.ra - self.header_pointing.ra\n\n self._pointing_error = PointingError(dRA.to(u.degree), dDec.to(u.degree), mag)\n\n return self._pointing_error\n\n def get_header_pointing(self):\n \"\"\"Get the pointing information from the header\n\n The header should contain the `RA-MNT` and `DEC-MNT` keywords, from which\n the header pointing coordinates are built.\n \"\"\"\n try:\n self.header_pointing = SkyCoord(ra=float(self.header['RA-MNT']) * u.degree,\n dec=float(self.header['DEC-MNT']) * u.degree)\n\n self.header_RA = self.header_pointing.ra.to(u.hourangle)\n self.header_Dec = self.header_pointing.dec.to(u.degree)\n\n # Precess to the current equinox otherwise the RA - LST method will be off.\n self.header_HA = self.header_pointing.transform_to(self.FK5_Jnow).ra.to(u.hourangle) - self.sidereal\n except Exception as e:\n self.logger.warning('Cannot get header pointing information: {}'.format(e))\n\n def get_wcs_pointing(self):\n \"\"\"Get the pointing information from the WCS\n\n Builds the pointing coordinates from the plate-solved WCS. These will be\n compared with the coordinates stored in the header.\n \"\"\"\n if self.wcs is not None:\n ny, nx = self.RGGB.data.shape\n decimals = self.wcs.all_pix2world(nx // 2, ny // 2, 1)\n\n self.pointing = SkyCoord(ra=decimals[0] * u.degree,\n dec=decimals[1] * u.degree)\n\n self.RA = self.pointing.ra.to(u.hourangle)\n self.Dec = self.pointing.dec.to(u.degree)\n\n # Precess to the current equinox otherwise the RA - LST method will be off.\n self.HA = self.pointing.transform_to(self.FK5_Jnow).ra.to(u.hourangle) - self.sidereal\n\n def solve_field(self, **kwargs):\n \"\"\" Solve field and populate WCS information\n\n Args:\n **kwargs (dict): Options to be passed to `get_solve_field`\n \"\"\"\n solve_info = img_utils.get_solve_field(self.fits_file,\n ra=self.header_pointing.ra.value,\n dec=self.header_pointing.dec.value,\n **kwargs)\n\n self.wcs_file = solve_info['solved_fits_file']\n self.get_wcs_pointing()\n\n return solve_info\n\n def compute_offset(self, ref, units='arcsec', rotation=True):\n \"\"\"Offset information between this image and a reference\n\n Args:\n ref (str): Refernce image, either another `Image` instance or a\n filename that will be read\n units (str, optional): Can be either `arcsec` or `pixel`\n rotation (bool, optional): If rotation information should be included,\n defaults to True\n\n Returns:\n dict: Offset information in key/value pairs\n \"\"\"\n if isinstance(units, (u.Unit, u.Quantity, u.IrreducibleUnit)):\n units = units.name\n assert units in ['pix', 'pixel', 'arcsec']\n\n if isinstance(ref, str):\n assert os.path.exists(ref)\n ref = Image(ref)\n assert isinstance(ref, Image)\n\n offset_pix = compute_offset_rotation(ref.luminance, self.luminance)\n offset_pix['X'] *= 2\n offset_pix['Y'] *= 2\n\n if self.HA:\n selfHA = self.HA\n else:\n selfHA = self.header_HA\n if self.Dec:\n selfDec = self.Dec\n else:\n selfDec = self.header_Dec\n if ref.HA:\n refHA = ref.HA\n else:\n stime_diff = (self.midtime.sidereal_time('apparent') - ref.midtime.sidereal_time('apparent'))\n refHA = selfHA - stime_diff.to(u.hourangle)\n\n time_diff = (self.midtime - ref.midtime)\n\n info = {'image': self.fits_file,\n 'time': self.midtime.to_datetime().isoformat(),\n 'HA': selfHA.to(u.hourangle).value,\n 'HA unit': 'hours',\n 'Dec': selfDec.to(u.degree).value,\n 'Dec unit': 'deg',\n\n 'refimage': ref.fits_file,\n 'reftime': ref.midtime.to_datetime().isoformat(),\n 'refHA': refHA.to(u.hourangle).value,\n\n 'dt': time_diff.to(u.second).value,\n 'dt unit': 'seconds',\n 'angle': offset_pix['angle'].to(u.degree).value,\n 'angle unit': 'deg',\n 'offset units': units,\n }\n\n if units in ['pix', 'pixel']:\n info['offsetX'] = offset_pix['X'].to(u.pixel).value\n info['offsetY'] = offset_pix['Y'].to(u.pixel).value\n elif units == 'arcsec':\n deltapix = [offset_pix['X'].to(u.pixel).value,\n offset_pix['Y'].to(u.pixel).value]\n offset_deg = self.wcs.pixel_scale_matrix.dot(deltapix)\n info['offsetX'] = (offset_deg[0] * u.degree).to(u.arcsecond).value\n info['offsetY'] = (offset_deg[1] * u.degree).to(u.arcsecond).value\n return info\n\n\n##################################################################################################\n# Private Methods\n##################################################################################################\n\n def __str__(self):\n return \"{}: {}\".format(self.fits_file, self.header_pointing)\n\n\ndef compute_offset_rotation(im, imref, upsample_factor=20, subframe_size=200, corners=True):\n \"\"\"Determine rotation information between two images\n\n Detremine the rotation information for the center and, if `corner`, the\n four corner boxes, each of `subframe_size` pixels.\n\n Args:\n im (numpy.array): Image data\n imref (numpy.array): Comparison image data\n upsample_factor (int, optional): Subpixel fraction to compute\n subframe_size (int, optional): Box size\n corners (bool, optional): If corner boxes should be included, defaults\n to True\n\n Returns:\n dict: Rotation offset in `X`, `Y`, and `angle`\n \"\"\"\n assert im.shape == imref.shape\n ny, nx = im.shape\n\n subframe_half = int(subframe_size / 2)\n\n # Create the center point for each of our regions\n regions = {'center': (int(nx / 2), int(ny / 2)), }\n offsets = {'center': None, }\n\n if corners:\n regions.update({\n 'upper_right': (int(nx - subframe_half), int(ny - subframe_half)),\n 'upper_left': (int(subframe_half), int(ny - subframe_half)),\n 'lower_right': (int(nx - subframe_half), int(subframe_half)),\n 'lower_left': (int(subframe_half), int(subframe_half)),\n })\n\n offsets.update({\n 'upper_right': None,\n 'upper_left': None,\n 'lower_right': None,\n 'lower_left': None,\n })\n\n # Get im/imref offsets for each region\n for region, midpoint in regions.items():\n imarr = img_utils.crop_data(im, center=midpoint, box_width=subframe_size)\n imrefarr = img_utils.crop_data(imref, center=midpoint, box_width=subframe_size)\n\n shifts, err, h = register_translation(imrefarr, imarr, upsample_factor=upsample_factor)\n offsets[region] = shifts\n\n # Rotate the offsets according to region\n angles = []\n for region in regions.keys():\n if region != 'center':\n offsets[region] -= offsets['center']\n\n relpos = (regions[region][0] - regions['center'][0],\n regions[region][1] - regions['center'][1])\n\n theta1 = np.arctan(relpos[1] / relpos[0])\n theta2 = np.arctan((relpos[1] + offsets[region][1]) / (relpos[0] + offsets[region][0]))\n angles.append(theta2 - theta1)\n\n angle = np.mean(angles)\n\n result = {'X': offsets['center'][0] * u.pix,\n 'Y': offsets['center'][1] * u.pix,\n 'angle': (angle * u.radian).to(u.degree)}\n\n return result\n", "meta": {"hexsha": "3f5dc527e0b6f6b6897ea63fdafc69750c3b47d7", "size": 12954, "ext": "py", "lang": "Python", "max_stars_repo_path": "pocs/images.py", "max_stars_repo_name": "brendan-o/POCS", "max_stars_repo_head_hexsha": "243d0acf1ade7a96f71d83ad13fb141ee1ea9781", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pocs/images.py", "max_issues_repo_name": "brendan-o/POCS", "max_issues_repo_head_hexsha": "243d0acf1ade7a96f71d83ad13fb141ee1ea9781", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pocs/images.py", "max_forks_repo_name": "brendan-o/POCS", "max_forks_repo_head_hexsha": "243d0acf1ade7a96f71d83ad13fb141ee1ea9781", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.9833333333, "max_line_length": 112, "alphanum_fraction": 0.5790489424, "include": true, "reason": "import numpy,from astropy", "num_tokens": 2946, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.600188359260205, "lm_q2_score": 0.32082131381216084, "lm_q1q2_score": 0.19255321795262414}} {"text": "#!/usr/bin/env python\n\n# A library of stuff used for getting Balrog data from the databse,\n# HEALPixifying it, and general munging.\n\n\nimport desdb\nimport numpy as np\nimport esutil\nimport sys\nimport healpy as hp\nimport os\nimport numpy.lib.recfunctions as rf\n\n\ndef GetDepthMap(depth_file):\n map = hp.read_map(depth_file, nest=True)\n nside = hp.npix2nside(map.size)\n return map, nside\n\ndef GetPhi(ra):\n return ra * np.pi / 180.0\n\ndef GetRa(phi):\n return phi*180.0/np.pi\n\ndef GetTheta(dec):\n return (90.0 - dec) * np.pi / 180.0\n\ndef GetDec(theta):\n return 90.0 - theta*180.0/np.pi\n\ndef GetRaDec(theta, phi):\n return [GetRa(phi), GetDec(theta)]\n\ndef GetPix(nside, ra, dec, nest=True):\n phi = GetPhi(ra)\n theta = GetTheta(dec)\n pix = hp.ang2pix(nside, theta, phi, nest=nest)\n return pix\n\ndef GetDepthCut(map, nside, ra, dec, depth = 0.0):\n pix = GetPix(nside, ra, dec)\n depths = map[pix]\n ok_depths = (depths > depth)\n return ok_depths\n\ndef ValidDepth(map, nside, arr, rakey='ra', deckey='dec', depth = 0.0):\n ok_depths = GetDepthCut(map, nside, arr[rakey], arr[deckey], depth = depth)\n arr = arr[ok_depths]\n return arr\n\ndef InTile(data, ura, udec, rakey='ra', deckey='dec'):\n inside = (data[rakey] > ura[0]) & (data[rakey] < ura[1]) & (data[deckey] > udec[0]) & (data[deckey] < udec[1])\n return inside\n\ndef RemoveTileOverlap(tilestuff, data, col='tilename', rakey='ra', deckey='dec'):\n datatile = data[col]\n tiles = np.unique(datatile)\n keep = np.zeros( len(data), dtype=np.bool_)\n for tile in tiles:\n cut = (datatile==tile)\n entry = tilestuff[tile]\n ura = (entry['urall'], entry['uraur'])\n udec = (entry['udecll'], entry['udecur'])\n u = InTile(data[cut], ura, udec, rakey=rakey, deckey=deckey)\n keep[cut] = u\n return data[keep]\n\ndef NoSimFields(band='i'):\n q = \"\"\"\n SELECT\n balrog_index,\n mag_auto,\n flags\n FROM\n SUCHYTA1.balrog_sva1v2_nosim_%s\n \"\"\" %(band)\n return q\n\n\n\ndef SimFields(band='i',table='sva1v2'):\n q = \"\"\"\n SELECT\n t.tilename as tilename,\n m.xwin_image as xwin_image,\n m.ywin_image as ywin_image,\n m.xmin_image as xmin_image,\n m.ymin_image as ymin_image,\n m.xmax_image as xmax_image,\n m.ymax_image as ymax_image,\n m.balrog_index as balrog_index,\n m.alphawin_j2000 as ra,\n m.deltawin_j2000 as dec,\n m.mag_auto as mag_auto,\n m.spread_model as spread_model,\n m.spreaderr_model as spreaderr_model,\n m.class_star as class_star,\n m.mu_max as mu_max,\n t.sersicindex_0 as sersic_index,\n m.disk_scale_image as disk_scale,\n m.flux_radius as flux_radius,\n m.mag_disk as mag_disk,\n m.mag_psf as mag_psf,\n t.mag as truth_mag_auto,\n m.flags as flags\n FROM\n SUCHYTA1.balrog_%s_sim_%s m\n JOIN SUCHYTA1.balrog_%s_truth_%s t ON t.balrog_index = m.balrog_index\n \"\"\" %(table, band, table, band)\n return q\n\n\n\n\n\ndef DESFields(tilestuff, band='i'):\n q = \"\"\"\n SELECT\n tilename,\n coadd_objects_id,\n mag_auto_%s as mag_auto,\n alphawin_j2000_%s as ra,\n deltawin_j2000_%s as dec,\n spread_model_%s as spread_model,\n spreaderr_model_%s as spreaderr_model,\n class_star_%s as class_star,\n mag_psf_%s as mag_psf,\n flux_radius_%s as flux_radius,\n flags_%s as flags\n FROM\n sva1_coadd_objects\n WHERE\n tilename in %s\n \"\"\" % (band,band,band,band,band,band,band,band,band,str(tuple(np.unique(tilestuff['tilename']))))\n return q\n\n\ndef TruthFields(band='i', table = 'sva1v2'):\n q = \"\"\"\n SELECT\n balrog_index,\n tilename,\n ra,\n dec,\n objtype,\n HALFLIGHTRADIUS_0 as radius,\n mag,\n z,\n sersicindex_0\n FROM\n SUCHYTA1.balrog_%s_truth_%s \n \"\"\"%(table,band)\n return q\n \n\ndef GetDESCat( depthmap, nside, tilestuff, tileinfo, band='i',depth = 0.0):\n cur = desdb.connect()\n q = DESFields(tileinfo, band=band)\n detcat = cur.quick(q, array=True)\n detcat = ValidDepth(depthmap, nside, detcat, rakey='ra', deckey='dec',depth = depth)\n detcat = RemoveTileOverlap(tilestuff, detcat, col='tilename', rakey='ra', deckey='dec')\n return detcat\n\n\n\ndef getTileInfo(catalog, HealConfig=None):\n if HealConfig is None:\n HealConfig = getHealConfig()\n \n tiles = np.unique(catalog['tilename'])\n cur = desdb.connect()\n q = \"SELECT tilename, udecll, udecur, urall, uraur FROM coaddtile\"\n tileinfo = cur.quick(q, array=True)\n tilestuff = {}\n for i in range(len(tileinfo)):\n tilestuff[ tileinfo[i]['tilename'] ] = tileinfo[i]\n max = np.power(map_nside/float(HealConfig['out_nside']), 2.0)\n depthmap, nside = GetDepthMap(HealConfig['depthfile'])\n return depthmap, nside\n\n\ndef cleanCatalog(catalog, tag='mag_auto'):\n # We should get rid of obviously wrong things.\n keep = np.where( (catalog[tag] > 15. ) & (catalog[tag] < 30.) & (catalog['flags'] < 2) )\n return catalog[keep]\n\ndef removeBadTilesFromTruthCatalog(truth, tag='mag_auto', goodfrac = 0.8):\n tileList = np.unique(truth['tilename'])\n number = np.zeros(tileList.size)\n for tile, i in zip(tileList,xrange(number.size)):\n number[i] = np.sum(truth['tilename'] == tile)\n tileList = tileList[number > goodfrac*np.max(number)]\n keep = np.in1d( truth['tilename'], tileList )\n return truth[keep]\n\n\n\ndef mergeCatalogsUsingPandas(sim=None, truth=None, key='balrog_index', suffixes = ['_sim','']):\n import pandas as pd\n simData = pd.DataFrame(sim)\n truthData = pd.DataFrame(truth)\n matched = pd.merge(simData, truthData, on=key, suffixes = suffixes)\n matched_arr = matched.to_records(index=False)\n # This last step is necessary because Pandas converts strings to Objects when eating structured arrays.\n # And np.recfunctions flips out when it has one.\n oldDtype = matched_arr.dtype.descr\n newDtype = oldDtype\n for thisOldType,i in zip(oldDtype, xrange(len(oldDtype) )):\n if 'O' in thisOldType[1]:\n newDtype[i] = (thisOldType[0], 'S12')\n matched_arr = np.array(matched_arr,dtype=newDtype)\n return matched_arr\n\n\n\ndef GetFromDB( band='i', depth = 0.0,tables =['sva1v2','sva1v3','sva1v3_2','sva1v3_3']): \n depthfile = '../../Data/sva1_gold_1.0.2-4_nside4096_nest_i_auto_weights.fits'\n\n cur = desdb.connect()\n q = \"SELECT tilename, udecll, udecur, urall, uraur FROM coaddtile\"\n tileinfo = cur.quick(q, array=True)\n tilestuff = {}\n for i in range(len(tileinfo)):\n tilestuff[ tileinfo[i]['tilename'] ] = tileinfo[i]\n depthmap, nside = GetDepthMap(depthfile)\n truths = []\n sims = []\n truthMatcheds = []\n \n for tableName in tables:\n q = TruthFields(band=band,table=tableName)\n truth = cur.quick(q, array=True)\n\n truth = removeBadTilesFromTruthCatalog(truth)\n truth = ValidDepth(depthmap, nside, truth, depth = depth)\n truth = RemoveTileOverlap(tilestuff, truth)\n #truth = cleanCatalog(truth,tag='mag')\n unique_binds, unique_inds = np.unique(truth['balrog_index'],return_index=True)\n truth = truth[unique_inds]\n\n q = SimFields(band=band, table=tableName)\n sim = cur.quick(q, array=True)\n sim = cleanCatalog(sim,tag='mag_auto')\n unique_binds, unique_inds = np.unique(sim['balrog_index'],return_index=True)\n sim = sim[unique_inds]\n \n \n truthMatched = mergeCatalogsUsingPandas(sim=sim,truth=truth)\n \n sim = sim[np.in1d(sim['balrog_index'],truthMatched['balrog_index'])]\n sim.sort(order='balrog_index')\n truthMatched.sort(order='balrog_index')\n \n truthMatcheds.append(truthMatched)\n truths.append(truth)\n sims.append(sim)\n\n sim = np.hstack(sims)\n truth = np.hstack(truths)\n truthMatched = np.hstack(truthMatcheds)\n \n des = GetDESCat(depthmap, nside, tilestuff, sim, band=band,depth = depth)\n des = cleanCatalog(des, tag='mag_auto')\n \n return des, sim, truthMatched, truth, tileinfo\n\n\ndef hpRaDecToHEALPixel(ra, dec, nside= 4096, nest= True):\n phi = ra * np.pi / 180.0\n theta = (90.0 - dec) * np.pi / 180.0\n hpInd = hp.ang2pix(nside, theta, phi, nest= nest)\n return hpInd\n\ndef convertThetaPhiToRaDec(theta, phi):\n ra = phi*180.0/np.pi\n dec = 90.0 - theta*180.0/np.pi\n return ra,dec\n\ndef convertRaDecToThetaPhi(ra, dec):\n theta = (90.0 - dec) * np.pi / 180.0\n phi = ra * np.pi / 180.0\n return theta, phi\n\ndef HealPixifyCatalogs(catalog=None, healConfig=None, ratag='ra', dectag = 'dec'):\n HealInds = hpRaDecToHEALPixel( catalog[ratag],catalog[dectag], nside= healConfig['out_nside'], nest= healConfig['nest'])\n if 'HEALIndex' in catalog.dtype.fields:\n healCat = catalog.copy()\n healCat['HEALIndex'] = HealInds\n else:\n healCat = rf.append_fields(catalog,'HEALIndex',HealInds,dtypes=HealInds.dtype)\n return healCat\n\n\ndef getHealConfig(map_nside = 4096, out_nside = 128, depthfile = '../../Data/sva1_gold_1.0.2-4_nside4096_nest_i_auto_weights.fits'):\n HealConfig = {}\n HealConfig['map_nside'] = map_nside\n HealConfig['out_nside'] = out_nside\n HealConfig['finer_nside'] = map_nside\n HealConfig['depthfile'] = depthfile\n HealConfig['nest'] = True\n return HealConfig\n\n\ndef getGoodRegionIndices(catalog=None, badHPInds=None, nside=4096,band=None, raTag = 'ra', decTag = 'dec'):\n hpInd = hpRaDecToHEALPixel(catalog[raTag], catalog[decTag], nside=nside, nest= True)\n keep = ~np.in1d(hpInd, badHPInds)\n return keep\n\n\ndef excludeBadRegions(des,balrogObs, balrogTruthMatched, balrogTruth, band=None):\n eliMap = hp.read_map(\"sva1_gold_1.0.4_goodregions_04_equ_nest_4096.fits\", nest=True)\n nside = hp.npix2nside(eliMap.size)\n maskIndices = np.arange(eliMap.size)\n badIndices = maskIndices[eliMap == 1]\n if band is not None:\n raTag = 'ra_'+band\n decTag = 'dec_'+band\n else:\n raTag = 'ra'\n decTag = 'dec'\n obsKeepIndices = getGoodRegionIndices(catalog=balrogObs, badHPInds=badIndices, nside=nside, raTag = raTag, decTag = decTag)\n truthKeepIndices = getGoodRegionIndices(catalog=balrogTruth, badHPInds=badIndices, nside=nside, raTag = raTag, decTag = decTag)\n desKeepIndices = getGoodRegionIndices(catalog=des, badHPInds=badIndices, nside=nside, raTag = raTag, decTag = decTag)\n\n balrogObs = balrogObs[obsKeepIndices]\n balrogTruthMatched = balrogTruthMatched[obsKeepIndices]\n balrogTruth = balrogTruth[truthKeepIndices]\n des = des[desKeepIndices]\n\n return des,balrogObs, balrogTruthMatched, balrogTruth\n\n\ndef removeNeighbors(thing1, thing2, radius= 2./3600,\n raTag1 = 'ra', decTag1 = 'dec', raTag2 = 'ra', decTag2 = 'dec'):\n # Returns the elements of thing 1 that are outside of the matching radius from thing 2\n \n depth=10\n h = esutil.htm.HTM(depth)\n m1, m2, d12 = h.match(thing1[raTag1],thing1[decTag1],thing2[raTag2],thing2[decTag2],radius,maxmatch=0)\n keep = ~np.in1d(thing1['balrog_index'],thing1['balrog_index'][m1])\n return keep\n\n\ndef getCatalogs(reload=False,band='i', path = '../../Data/'):\n # Check to see whether the catalog files exist. If they do, then\n # use the files. If at least one does not, then get what we need\n # from the database\n\n fileNames = ['desCatalogFile-'+band+'.fits','BalrogObsFile-'+band+'.fits',\n 'BalrogTruthFile-'+band+'.fits', 'BalrogTruthMatchedFile-'+band+'.fits',\n 'BalrogTileInfo.fits']\n exists = True\n for thisFile in fileNames:\n print \"Checking for existence of: \"+path+thisFile\n if not os.path.isfile(path+thisFile): exists = False\n if exists and not reload:\n\n desCat = esutil.io.read(path+fileNames[0])\n BalrogObs = esutil.io.read(path+fileNames[1])\n BalrogTruth = esutil.io.read(path+fileNames[2])\n BalrogTruthMatched = esutil.io.read(path+fileNames[3])\n BalrogTileInfo = esutil.io.read(path+fileNames[4])\n else:\n print \"Cannot find files, or have been asked to reload. Getting data from DESDB.\"\n desCat, BalrogObs, BalrogTruthMatched, BalrogTruth, BalrogTileInfo = GetFromDB(band=band)\n esutil.io.write( path+fileNames[0], desCat , clobber=True)\n esutil.io.write( path+fileNames[1], BalrogObs , clobber=True)\n esutil.io.write( path+fileNames[2], BalrogTruth , clobber=True)\n esutil.io.write( path+fileNames[3], BalrogTruthMatched , clobber=True)\n esutil.io.write( path+fileNames[4], BalrogTileInfo, clobber=True)\n \n return desCat, BalrogObs, BalrogTruthMatched, BalrogTruth, BalrogTileInfo\n\n\ndef modestify(data):\n modest = np.zeros(len(data), dtype=np.int32)\n\n galcut = (data['flags'] <=3) & -( ((data['class_star'] > 0.3) & (data['mag_auto'] < 18.0)) | ((data['spread_model'] + 3*data['spreaderr_model']) < 0.003) | ((data['mag_psf'] > 30.0) & (data['mag_auto'] < 21.0)))\n modest[galcut] = 1\n\n starcut = (data['flags'] <=3) & ((data['class_star'] > 0.3) & (data['mag_auto'] < 18.0) & (data['mag_psf'] < 30.0) | (((data['spread_model'] + 3*data['spreaderr_model']) < 0.003) & ((data['spread_model'] +3*data['spreaderr_model']) > -0.003)))\n modest[starcut] = 3\n\n neither = -(galcut | starcut)\n modest[neither] = 5\n\n data = rf.append_fields(data, 'modtype', modest)\n print len(data), np.sum(galcut), np.sum(starcut), np.sum(neither)\n return data\n\n\ndef getCleanCatalogs( reload = False, band=None, isolated=False, nside=None):\n \n if band is None:\n print \"Please specify a filter using the 'band' keyword argument.\"\n print \"Choose one of [grizY].\"\n \n \n des, balrogObs, balrogTruthMatched, balrogTruth, balrogTileInfo = getCatalogs(reload=reload, band=band)\n\n # Remove things in regions that are officially masked.\n des, balrogObs, balrogTruthMatched, balrogTruth = excludeBadRegions(des,balrogObs, balrogTruthMatched, balrogTruth)\n \n # if the isolated keyword is set, exclude things within some\n # separation from a pre-existing DES detection.\n if isolated is not False:\n print \"isolated keyword should be set to a number, in arcseconds.\"\n keep = removeNeighbors(balrogTruthMatched, des, radius= float(isolated)/3600)\n balrogTruthMatched = balrogTruthMatched[keep]\n balrogObs = balrogObs[keep]\n \n # nside is set, then create a HEALPixel configuration and\n # assign pixel indices to each object.\n if nside is not None:\n HEALConfig = getHealConfig(map_nside = 4096, out_nside = nside )\n des = HealPixifyCatalogs(catalog=des, healConfig=HEALConfig)\n balrogObs = HealPixifyCatalogs(catalog=balrogObs, healConfig=HEALConfig)\n balrogTruth = HealPixifyCatalogs(catalog=balrogTruth, healConfig=HEALConfig)\n balrogTruthMatched = HealPixifyCatalogs(catalog=balrogTruthMatched, healConfig=HEALConfig)\n return des, balrogObs, balrogTruthMatched, balrogTruth,HEALConfig\n else:\n return des, balrogObs, balrogTruthMatched, balrogTruth\n\ndef matchCatalogs(cat1, cat2 ,tag = 'balrog_index'):\n ind1, ind2 = esutil.numpy_util.match(cat1[tag], cat2[tag])\n return cat1[ind1], cat2[ind2]\n \ndef getStellarityCatalogs( reload = False, band = None, nside = None):\n \n des, balrogObs, balrogTruthMatched, balrogTruth = getCleanCatalogs(reload=reload,band=band)\n des = modestify(des)\n balrogObs = modestify(balrogObs)\n\n return des, balrogObs, balrogTruthMatched, balrogTruth\n", "meta": {"hexsha": "53a924acbe096dc12753bdc91e179d2aa9b132a3", "size": 15709, "ext": "py", "lang": "Python", "max_stars_repo_path": "cfunc.py", "max_stars_repo_name": "emhuff/regularizedInversion", "max_stars_repo_head_hexsha": "bb6ef71c041ee9a91a8ef625e0d228458cc8e0e0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "cfunc.py", "max_issues_repo_name": "emhuff/regularizedInversion", "max_issues_repo_head_hexsha": "bb6ef71c041ee9a91a8ef625e0d228458cc8e0e0", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "cfunc.py", "max_forks_repo_name": "emhuff/regularizedInversion", "max_forks_repo_head_hexsha": "bb6ef71c041ee9a91a8ef625e0d228458cc8e0e0", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.9473684211, "max_line_length": 247, "alphanum_fraction": 0.6563753262, "include": true, "reason": "import numpy", "num_tokens": 4697, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.600188373563072, "lm_q2_score": 0.3208213008246071, "lm_q1q2_score": 0.19255321474630996}} {"text": "\"\"\"\nInference with different ADC precisions\n\"\"\"\nimport math\nimport numpy as np\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torch import Tensor\nfrom .utee import wage_quantizer\nfrom .quant_modules import WQ, AQ, stats_quant\n\ndef decimal2binary(weight_q, bitWeight, cellBit):\n cellRange = 2**cellBit\n remainder_list = torch.Tensor([]).type_as(weight_q)\n \n for k in range(int(bitWeight/cellBit)):\n remainder = torch.fmod(weight_q, cellRange)\n remainder = remainder.unsqueeze(0)\n remainder_list = torch.cat((remainder_list, remainder), dim=0)\n weight_q = torch.round((weight_q-remainder.squeeze(0))/cellRange)\n return remainder_list\n\ndef bit2cond(bitWeight, hrs, lrs):\n \"\"\"\n Draft: replace the binary values to conductance measurement\n \"\"\"\n level0 = torch.ones(bitWeight[bitWeight==0].size()).mul(hrs)\n level1 = torch.ones(bitWeight[bitWeight==1].size()).mul(lrs)\n\n bitWeight[bitWeight==0] = level0.cuda()\n bitWeight[bitWeight==1] = level1.cuda()\n\n bitWeight = bitWeight.clamp(0)\n return bitWeight\n\ndef program_noise_cond(weight_q, weight_b, hrs, lrs, sensitive_lv):\n wb = torch.zeros_like(weight_b)\n weight_cond = bit2cond(weight_b, hrs, lrs) # typical values\n\n for ii in range(len(weight_q.unique())):\n \n if len(weight_q.unique()) == 1:\n ii = int(weight_q.unique().item())\n\n idx_4b = weight_q.eq(ii)\n wb_ii = weight_cond[:, idx_4b]\n wbin_ii = weight_b[:, idx_4b]\n \n # noises\n noise = np.load(f\"/home/mengjian/Desktop/ASU_research/SWIPE_analysis/prob/SWIPE/noSWIPE_25Times_raw/level{ii}_raw.npy\") # 1.66\n # swipe = np.load(f\"/home/mengjian/Desktop/ASU_research/SWIPE_analysis/prob/SWIPE/Level_4x16_SWIPE_250nPW_chip14_raw_in_16lvl/level{ii}_raw.npy\")\n \n # rescale the programming noise with new lrs （1.66 to 1.11)\n # noise = noise * (1.11e-4/1.66e-4)\n # swipe = swipe * (1.11e-4/1.66e-4)\n \n # noise = np.load(f\"/home/mengjian/Desktop/ASU_research/SWIPE_analysis/prob/SWIPE/DNN_SWIPE_101021/Level_4x16_noSWIPE_250nPW_chip14_raw_in_16lvl_10080928/level{ii}_raw.npy\")\n # swipe = np.load(f\"/home/mengjian/Desktop/ASU_research/SWIPE_analysis/prob/SWIPE/DNN_SWIPE_102021/Level_4x16_SWIPE_250nPW_chip14_raw_in_16lvl_10201845/level{ii}_raw.npy\")\n # swipe = np.load(f\"/home/mengjian/Desktop/ASU_research/SWIPE_analysis/prob/SWIPE/DNN_SWIPE_102021/09191845/level{ii}_raw.npy\") # 1.11\n swipe = np.load(f\"/home/mengjian/Desktop/ASU_research/SWIPE_analysis/prob/SWIPE/DNN_SWIPE_102021/Level_4x16_SWIPE_250nPW_chip14_raw_in_16lvl_10201845/level{ii}_raw.npy\") # 1.11\n swipe = swipe * (1.66e-4/1.11e-4)\n \n \n # sizes\n _, numel = wb_ii.size()\n \n bit_idx = np.arange(noise.shape[0])\n random_idx = np.random.choice(bit_idx, size=(numel))\n \n bit_random_noise = noise[random_idx, :].T\n swipe_random_noise = swipe[random_idx, :].T\n\n wb_cond = torch.from_numpy(bit_random_noise).float()\n swipe_cond = torch.from_numpy(swipe_random_noise).float()\n\n wb_cond = torch.flip(wb_cond, dims=[0])\n swipe_cond = torch.flip(swipe_cond, dims=[0])\n\n if not ii in sensitive_lv:\n wb[:, idx_4b] = swipe_cond.cuda() # SWIPE scheme\n else:\n wb[:, idx_4b] = wb_cond.cuda() # Non SWIPE scheme\n \n # # statistics\n # hrs = wb_cond[wb_ii == 0]\n # lrs = wb_cond[wb_ii == 1]\n # print(\"\\nLevel {}; Average HRS={}; Average LRS={}; dummy={}\".format(ii, hrs.mean(), lrs.mean(), dummy))\n return wb\n\nclass RRAMConv2d(nn.Conv2d):\n r\"\"\"\n NeuroSim-based RRAM inference with low precision weights and activations\n \"\"\"\n def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, \n wl_input=8, wl_weight=8, subArray=128, inference=0, cellBit=1, ADCprecision=5, sensitive_lv=0):\n super(RRAMConv2d, self).__init__(in_channels, out_channels, kernel_size,\n stride, padding, dilation, groups, bias)\n self.wl_input = wl_input\n self.inference = inference\n self.wl_weight = wl_weight\n self.cellBit = cellBit\n self.ADCprecision = ADCprecision\n self.layer_idx = 0\n self.iter = 0\n self.init = True\n self.subArray = subArray\n \n # quantization\n self.wbit = wl_weight\n self.abit = wl_input \n self.weight_quant = WQ(wbit=wl_weight)\n self.act_quant = AQ(abit=wl_input, act_alpha=torch.tensor(10.0))\n\n # conductance\n self.hrs = 1e-6\n # self.lrs = 1.11e-04\n self.lrs = 1.66e-04\n self.nonideal_unit = self.lrs - self.hrs\n self.sensitive_lv = sensitive_lv\n \n def _act_quant(self, input):\n act_alpha = self.act_quant.act_alpha \n input = torch.where(input < act_alpha, input, act_alpha)\n\n with torch.no_grad():\n scale = (2**self.abit - 1) / act_alpha\n \n input_div = input.mul(scale)\n input_q = input_div.round()\n return input_q, scale\n\n def forward(self, input: Tensor) -> Tensor: \n # quantization\n wq, w_scale = stats_quant(self.weight.data, nbit=self.wbit, dequantize=False)\n wq = wq.add(2 ** (self.wbit - 1) - 1)\n wd = torch.ones_like(wq).mul(2 ** (self.wbit - 1) - 1)\n \n # decomposition\n wqb_list = decimal2binary(wq, bitWeight=self.wbit, cellBit=self.cellBit)\n wdb_list = decimal2binary(wd, bitWeight=self.wbit, cellBit=self.cellBit)\n\n wqb_list = program_noise_cond(wq, wqb_list, hrs=self.hrs, lrs=self.lrs, sensitive_lv=self.sensitive_lv)\n wdb_list = program_noise_cond(wd, wdb_list, hrs=self.hrs, lrs=self.lrs, sensitive_lv=self.sensitive_lv)\n\n # input quantization\n xq, x_scale = self._act_quant(input)\n cellRange = 2**self.cellBit\n\n # targeted output size\n odim = math.floor((xq.size(2) + 2*self.padding[0] - self.dilation[0] * (wq.size(2)-1)-1)/self.stride[0] + 1)\n output = torch.zeros((xq.size(0), wq.size(0), odim, odim)).cuda()\n for i in range(wq.size(2)):\n for j in range(wq.size(3)):\n numSubArray = wq.shape[1] // self.subArray\n \n if numSubArray == 0:\n mask = torch.zeros_like(wq)\n mask[:,:,i,j] = 1\n xq, x_scale = self._act_quant(input)\n outputIN = torch.zeros_like(output)\n xb_list = []\n for z in range(int(self.abit)):\n xb = torch.fmod(xq, 2)\n xq = torch.round((xq-xb)/2)\n macs = torch.zeros_like(output).cuda()\n\n xb_list.append(xb)\n for k in range(int(self.wbit/self.cellBit)):\n wqb = wqb_list[k]\n wdb = wdb_list[k]\n\n outputPartial = F.conv2d(xb, wqb*mask, self.bias, self.stride, self.padding, self.dilation, self.groups)\n outputOffset = F.conv2d(xb, wdb*mask, self.bias, self.stride, self.padding, self.dilation, self.groups)\n scaler = cellRange**k\n\n maci = outputPartial - outputOffset\n maci = maci.div(self.nonideal_unit)\n\n macs = macs + maci * scaler\n \n scalerIN = 2**z\n outputIN = outputIN + macs * scalerIN\n output = output + outputIN / x_scale \n else:\n xq, x_scale = self._act_quant(input)\n outputIN = torch.zeros_like(output)\n for z in range(int(self.abit)):\n xb = torch.fmod(xq, 2)\n xq = torch.round((xq-xb)/2)\n total_macs = torch.zeros_like(output)\n\n for s in range(numSubArray):\n mask = torch.zeros_like(wq)\n mask[:,(s*self.subArray):(s+1)*self.subArray, i, j] = 1\n macs = torch.zeros_like(output).cuda()\n\n for k in range(int(self.wbit/self.cellBit)):\n wqb = wqb_list[k]\n wdb = wdb_list[k]\n\n outputPartial = F.conv2d(xb, wqb*mask, self.bias, self.stride, self.padding, self.dilation, self.groups)\n outputOffset = F.conv2d(xb, wdb*mask, self.bias, self.stride, self.padding, self.dilation, self.groups)\n scaler = cellRange**k\n\n maci = outputPartial - outputOffset\n # ADC\n maci = wage_quantizer.LinearQuantizeOut(maci, bit=self.ADCprecision, lb=maci.min(), ub=maci.max())\n maci = maci.div(self.nonideal_unit)\n macs = macs + maci * scaler\n \n total_macs = total_macs.add(macs)\n scalerIN = 2**z\n outputIN = outputIN + total_macs * scalerIN\n output = output + outputIN / x_scale \n output = output / w_scale\n return output", "meta": {"hexsha": "01288ed66a2c91a45d61ce7a98e6d01db39e8c2c", "size": 9569, "ext": "py", "lang": "Python", "max_stars_repo_path": "models/quant/neurosim_modules.py", "max_stars_repo_name": "mengjian0502/TorchInference_RRAM", "max_stars_repo_head_hexsha": "3fb556dcfb6d9284012613d9c46a595ea3c93f5f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "models/quant/neurosim_modules.py", "max_issues_repo_name": "mengjian0502/TorchInference_RRAM", "max_issues_repo_head_hexsha": "3fb556dcfb6d9284012613d9c46a595ea3c93f5f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "models/quant/neurosim_modules.py", "max_forks_repo_name": "mengjian0502/TorchInference_RRAM", "max_forks_repo_head_hexsha": "3fb556dcfb6d9284012613d9c46a595ea3c93f5f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-04-06T05:47:46.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-22T23:30:34.000Z", "avg_line_length": 44.0967741935, "max_line_length": 186, "alphanum_fraction": 0.5667258857, "include": true, "reason": "import numpy", "num_tokens": 2495, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.600188359260205, "lm_q2_score": 0.32082130731838393, "lm_q1q2_score": 0.19255321405513484}} {"text": "import logging\nimport multiprocessing\nimport sys\nimport traceback\nfrom multiprocessing import Pool\n\nimport numpy as np\nimport ellc\nimport matplotlib.pyplot as plt\nfrom lcbuilder.lcbuilder_class import LcBuilder\nfrom lcbuilder.objectinfo.InputObjectInfo import InputObjectInfo\nfrom lcbuilder.objectinfo.MissionInputObjectInfo import MissionInputObjectInfo\nfrom lcbuilder.objectinfo.preparer.MissionLightcurveBuilder import MissionLightcurveBuilder\nfrom lcbuilder.objectinfo.MissionObjectInfo import MissionObjectInfo\nimport wotan\nfrom matplotlib.ticker import FormatStrFormatter\nfrom foldedleastsquares import transitleastsquares, DefaultTransitTemplateGenerator\nfrom foldedleastsquares import transit_mask, cleaned_array\nimport astropy.constants as ac\nimport astropy.units as u\nimport lightkurve as lk\nimport os\nimport re\nimport pandas as pd\n\nfrom tkmatrix.inject_model import InjectModel\n\n\nclass MATRIX:\n \"\"\"\n MATRIX: Multi-phAse Transits Recovery from Injected eXoplanets\n \"\"\"\n object_info = None\n SDE_ROCHE = 2000\n lcbuilder = LcBuilder()\n MIN_SEARCH_PERIOD = 0.5\n\n def __init__(self, target, sectors, dir, preserve=False, star_info=None, file=None, exposure_time=None,\n initial_mask=None, initial_transit_mask=None,\n eleanor_corr_flux='pca_flux', outliers_sigma=None, high_rms_enabled=True, high_rms_threshold=2.5,\n high_rms_bin_hours=4, smooth_enabled=False,\n auto_detrend_enabled=False, auto_detrend_method=\"cosine\", auto_detrend_ratio=0.25,\n auto_detrend_period=None, prepare_algorithm=None, cache_dir=os.path.expanduser('~') + \"/\",\n oscillation_reduction=False, oscillation_min_snr=4, oscillation_amplitude_threshold=0.001,\n oscillation_ws_percent=0.01, oscillation_min_period=0.002, oscillation_max_period=0.2,\n cores=multiprocessing.cpu_count() - 1\n ):\n assert target is not None and isinstance(target, str)\n assert sectors is not None and (sectors == 'all' or isinstance(sectors, list))\n assert exposure_time is not None and isinstance(exposure_time, (int, float))\n assert initial_transit_mask is None or isinstance(initial_transit_mask, list)\n self.id = target\n self.dir = dir\n self.sectors = sectors\n self.star_info = star_info\n self.exposure_time = exposure_time\n self.preserve = preserve\n self.file = file\n self.eleanor_corr_flux = eleanor_corr_flux\n self.initial_mask = initial_mask\n self.initial_transit_mask = initial_transit_mask\n self.star_info = star_info\n self.outliers_sigma = outliers_sigma\n self.high_rms_enabled = high_rms_enabled\n self.high_rms_threshold = high_rms_threshold\n self.high_rms_bin_hours = high_rms_bin_hours\n self.smooth_enabled = smooth_enabled\n self.auto_detrend_enabled = auto_detrend_enabled\n self.auto_detrend_method = auto_detrend_method\n self.auto_detrend_ratio = auto_detrend_ratio\n self.auto_detrend_period = auto_detrend_period\n self.oscillation_reduction = oscillation_reduction\n self.oscillation_min_snr = oscillation_min_snr\n self.oscillation_amplitude_threshold = oscillation_amplitude_threshold\n self.oscillation_ws_percent = oscillation_ws_percent\n self.oscillation_min_period = oscillation_min_period\n self.oscillation_max_period = oscillation_max_period\n self.prepare_algorithm = prepare_algorithm\n self.cache_dir = cache_dir\n self.cores = cores\n\n def retrieve_object_data(self, inject_dir=None):\n self.object_info = self.lcbuilder.build_object_info(self.id, None, self.sectors, self.file, self.exposure_time,\n None, None,\n self.star_info, None,\n self.eleanor_corr_flux, self.outliers_sigma,\n False, self.high_rms_threshold,\n self.high_rms_bin_hours, False,\n False, self.auto_detrend_method,\n self.auto_detrend_ratio, self.auto_detrend_period,\n self.prepare_algorithm, False,\n self.oscillation_min_snr, self.oscillation_amplitude_threshold,\n self.oscillation_ws_percent, self.oscillation_min_period,\n self.oscillation_max_period)\n if inject_dir is None:\n inject_dir = self.build_inject_dir()\n self.lc_build = self.lcbuilder.build(self.object_info, inject_dir, self.cache_dir)\n if self.star_info is None:\n self.star_info = self.lc_build.star_info\n self.ab = self.star_info.ld_coefficients\n self.mass = self.star_info.mass\n self.massmin = self.star_info.mass_min\n self.massmax = self.star_info.mass_max\n self.radius = self.star_info.radius\n self.radiusmin = self.star_info.radius_min\n self.radiusmax = self.star_info.radius_max\n # units for ellc\n self.rstar = self.star_info.radius * u.R_sun\n self.mstar = self.star_info.mass * u.M_sun\n self.mstar_min = self.star_info.mass_min * u.M_sun\n self.mstar_max = self.star_info.mass_max * u.M_sun\n self.rstar_min = self.star_info.radius_min * u.R_sun\n self.rstar_max = self.star_info.radius_max * u.R_sun\n return inject_dir\n\n def retrieve_object_data_for_recovery(self, inject_dir, recovery_file):\n self.__setup_logging(inject_dir)\n self.object_info = self.lcbuilder.build_object_info(\"\", None, None, recovery_file, self.exposure_time,\n self.initial_mask, self.initial_transit_mask,\n self.star_info, None,\n self.eleanor_corr_flux, self.outliers_sigma,\n self.high_rms_enabled, self.high_rms_threshold,\n self.high_rms_bin_hours, self.smooth_enabled,\n self.auto_detrend_enabled, self.auto_detrend_method,\n self.auto_detrend_ratio, self.auto_detrend_period,\n self.prepare_algorithm, self.oscillation_reduction,\n self.oscillation_min_snr, self.oscillation_amplitude_threshold,\n self.oscillation_ws_percent, self.oscillation_min_period,\n self.oscillation_max_period)\n\n if self.object_info.reduce_simple_oscillations and \\\n self.object_info.oscillation_max_period < self.object_info.oscillation_min_period:\n logging.info(\"Stellar oscillation period has been set to empty. Defaulting to 1/3 the minimum search period\")\n self.object_info.oscillation_max_period = self.MIN_SEARCH_PERIOD / 3\n self.lc_build = self.lcbuilder.build(self.object_info, inject_dir, self.cache_dir)\n\n def build_inject_dir(self):\n inject_dir = self.dir + \"/\" + self.object_info.mission_id().replace(\" \", \"\") + \"_ir/\"\n index = 0\n while os.path.exists(inject_dir) or os.path.isdir(inject_dir):\n inject_dir = self.dir + \"/\" + self.object_info.mission_id().replace(\" \", \"\") + \"_ir_\" + str(index) + \"/\"\n index = index + 1\n os.mkdir(inject_dir)\n self.__setup_logging(inject_dir)\n return inject_dir\n\n def __setup_logging(self, inject_dir):\n file_dir = inject_dir + \"matrix.log\"\n formatter = logging.Formatter('%(message)s')\n logger = logging.getLogger()\n while len(logger.handlers) > 0:\n logger.handlers.pop()\n logger.setLevel(logging.INFO)\n handler = logging.StreamHandler(sys.stdout)\n handler.setLevel(logging.INFO)\n handler.setFormatter(formatter)\n logger.addHandler(handler)\n handler = logging.FileHandler(file_dir)\n handler.setLevel(logging.INFO)\n handler.setFormatter(formatter)\n logger.addHandler(handler)\n logging.info(\"Setup injection directory\")\n\n def inject(self, phases, min_period, max_period, steps_period, min_radius, max_radius, steps_radius,\n period_grid_geom=\"lin\", radius_grid_geom=\"lin\"):\n assert phases is not None and isinstance(phases, int) and phases > 0\n assert min_period is not None and isinstance(min_period, (int, float)) and min_period > 0\n assert max_period is not None and isinstance(max_period, (int, float)) and max_period > 0\n assert steps_period is not None and isinstance(steps_period, (int)) and steps_period > 0\n assert min_radius is not None and isinstance(min_radius, (int, float)) and min_radius > 0\n assert max_radius is not None and isinstance(max_radius, (int, float)) and max_radius > 0\n assert steps_radius is not None and isinstance(steps_radius, (int)) and steps_radius > 0\n assert max_period >= min_period\n assert max_radius >= min_radius\n inject_dir = self.retrieve_object_data()\n flux0 = self.lc_build.lc.flux.value\n time = self.lc_build.lc.time.value\n flux_err = self.lc_build.lc.flux_err.value\n period_grid = np.linspace(min_period, max_period, steps_period) if period_grid_geom == \"lin\" \\\n else np.logspace(np.log10(min_period), np.log10(max_period), steps_period)\n radius_grid = np.linspace(min_radius, max_radius, steps_radius) if radius_grid_geom == \"lin\" \\\n else np.logspace(np.log10(min_radius), np.log10(max_radius), steps_period)\n inject_models = []\n for period in period_grid:\n for t0 in np.arange(time[60], time[60] + period - 0.1, period / phases):\n for rplanet in radius_grid:\n rplanet = np.around(rplanet, decimals=2) * u.R_earth\n inject_models.append(InjectModel(inject_dir, time, flux0, flux_err, self.rstar, self.mstar, t0,\n period, rplanet, self.exposure_time, self.ab))\n with Pool(processes=self.cores) as pool:\n pool.map(InjectModel.make_model, inject_models)\n return inject_dir\n\n\n def recovery(self, inject_dir, snr_threshold=5, sherlock_samples=0, detrend_ws=0,\n transit_template='tls', run_limit=5, custom_search_algorithm=None, max_period_search=25):\n assert detrend_ws is not None and isinstance(detrend_ws, (int, float))\n assert transit_template in ('tls', 'bls')\n assert inject_dir is not None and isinstance(inject_dir, str)\n if transit_template == 'tls':\n transit_template = 'default'\n elif transit_template == 'bls':\n transit_template = 'box'\n reports_df = pd.DataFrame(columns=['period', 'radius', 'epoch', 'duration_found', 'period_found', 'epoch_found',\n 'found', 'snr', 'sde', 'run'])\n for file in sorted(os.listdir(inject_dir)):\n file_name_matches = re.search(\"P([0-9]+\\\\.[0-9]+)+_R([0-9]+\\\\.[0-9]+)_([0-9]+\\\\.[0-9]+)\\\\.csv\", file)\n if file_name_matches is not None:\n try:\n period = float(file_name_matches[1])\n r_planet = float(file_name_matches[2])\n epoch = float(file_name_matches[3])\n df = pd.read_csv(inject_dir + file, float_precision='round_trip', sep=',',\n usecols=['#time', 'flux', 'flux_err'])\n if len(df) == 0:\n found = True\n snr = 20\n sde = self.SDE_ROCHE\n run = 1\n duration_found = 20\n epoch_found = 0\n period_found = 0\n else:\n self.retrieve_object_data_for_recovery(inject_dir + \"/\", inject_dir + file)\n found, snr, sde, run, duration_found, period_found, epoch_found = \\\n self.__search(self.lc_build.lc.time.value, self.lc_build.lc.flux.value, self.radius, self.radiusmin,\n self.radiusmax, self.mass, self.massmin,\n self.massmax, self.ab, epoch, period, self.MIN_SEARCH_PERIOD,\n max_period_search, snr_threshold,\n transit_template, detrend_ws, self.lc_build.transits_min_count,\n run_limit, custom_search_algorithm)\n new_report = {\"period\": period, \"radius\": r_planet, \"epoch\": epoch, \"found\": found, \"snr\": snr,\n \"sde\": sde, \"run\": run, \"duration_found\": duration_found,\n \"period_found\": period_found, \"epoch_found\": epoch_found}\n reports_df = reports_df.append(new_report, ignore_index=True)\n print(\"P=\" + str(period) + \", R=\" + str(r_planet) + \", T0=\" + str(epoch) + \", FOUND WAS \" + str(\n found) +\n \" WITH SNR \" + str(snr) + \" AND SDE \" + str(sde))\n reports_df = reports_df.sort_values(['period', 'radius', 'epoch'], ascending=[True, True, True])\n reports_df.to_csv(inject_dir + \"a_tls_report.csv\", index=False)\n except Exception as e:\n traceback.print_exc()\n print(\"File not valid: \" + file)\n # tls_report_df = pd.read_csv(inject_dir + \"a_tls_report.csv\", float_precision='round_trip', sep=',',\n # usecols=['period', 'radius', 'epoch', 'found', 'duration', 'snr', 'sde', 'run'])\n if sherlock_samples > 0:\n from sherlockpipe import sherlock\n from sherlockpipe.scoring.QuorumSnrBorderCorrectedSignalSelector import QuorumSnrBorderCorrectedSignalSelector\n\n class QuorumSnrBorderCorrectedStopWhenMatchSignalSelector(QuorumSnrBorderCorrectedSignalSelector):\n def __init__(self, strength=1, min_quorum=0, per=None, t0=None):\n super().__init__()\n self.strength = strength\n self.min_quorum = min_quorum\n self.per = per\n self.t0 = t0\n\n def select(self, transit_results, snr_min, detrend_method, wl):\n signal_selection = super(QuorumSnrBorderCorrectedStopWhenMatchSignalSelector, self) \\\n .select(transit_results, snr_min, detrend_method, wl)\n if signal_selection.score == 0 or (\n self.is_harmonic(signal_selection.transit_result.period, self.per) and\n self.isRightEpoch(signal_selection.transit_result.t0, self.t0, self.per)):\n signal_selection.score = 0\n return signal_selection\n\n def is_harmonic(self, a, b, tolerance=0.05):\n a = np.float(a)\n b = np.float(b)\n mod_ab = a % b\n mod_ba = b % a\n return (a > b and a < b * 3 + tolerance * 3 and (\n abs(mod_ab % 1) <= tolerance or abs((b - mod_ab) % 1) <= tolerance)) or \\\n (b > a and a > b / 3 - tolerance / 3 and (\n abs(mod_ba % 1) <= tolerance or abs((a - mod_ba) % 1) <= tolerance))\n\n def isRightEpoch(self, t0, known_epoch, known_period):\n right_epoch = False\n for i in range(-5, 5):\n right_epoch = right_epoch or (np.abs(t0 - known_epoch + i * known_period) < (\n 1. / 24.))\n return right_epoch\n report = {}\n reports_df = pd.DataFrame(columns=['period', 'radius', 'epoch', 'found', 'snr', 'sde', 'run'])\n a = False\n samples_analysed = sherlock_samples\n for index, row in tls_report_df[::-1].iterrows():\n file = os.path.join(\n 'P' + str(row['period']) + '_R' + str(row['radius']) + '_' + str(row['epoch']) + '.csv')\n first_false = index > 0 and tls_report_df.iloc[index - 1]['found'] and \\\n not tls_report_df.iloc[index]['found']\n if first_false:\n samples_analysed = 0\n elif tls_report_df.iloc[index]['found']:\n samples_analysed = sherlock_samples\n if samples_analysed < sherlock_samples:\n try:\n samples_analysed = samples_analysed + 1\n period = float(re.search(\"P([0-9]+\\\\.[0-9]+)\", file)[1])\n r_planet = float(re.search(\"R([0-9]+\\\\.[0-9]+)\", file)[1])\n epoch = float(re.search(\"_([0-9]+\\\\.[0-9]+)\\\\.csv\", file)[1])\n signal_selection_algorithm = QuorumSnrBorderCorrectedStopWhenMatchSignalSelector(1, 0, period,\n epoch)\n df = pd.read_csv(inject_dir + file, float_precision='round_trip', sep=',',\n usecols=['#time', 'flux', 'flux_err'])\n if len(df) == 0:\n found = True\n snr = 20\n sde = 20\n run = 1\n else:\n sherlock.Sherlock(False, object_infos=[MissionInputObjectInfo(self.id, inject_dir + file)]) \\\n .setup_detrend(True, True, 1.5, 4, 12, \"biweight\", 0.2, 1.0, 20, False,\n 0.25, \"cosine\", None) \\\n .setup_transit_adjust_params(5, None, None, 10, None, None, 0.4, 14, 10,\n 20, 5, 5.5, 0.05, \"mask\", \"quorum\", 1, 0,\n signal_selection_algorithm) \\\n .run()\n df = pd.read_csv(self.id.replace(\" \", \"\") + \"_INP/candidates.csv\", float_precision='round_trip', sep=',',\n usecols=['curve', 'period', 't0', 'run', 'snr', 'sde', 'rad_p',\n 'transits'])\n snr = df[\"snr\"].iloc[len(df) - 1]\n run = df[\"run\"].iloc[len(df) - 1]\n sde = df[\"sde\"].iloc[len(df) - 1]\n per_run = 0\n found_period = False\n j = 0\n for per in df[\"period\"]:\n if signal_selection_algorithm.is_harmonic(per, period / 2.):\n found_period = True\n t0 = df[\"t0\"].iloc[j]\n break\n j = j + 1\n right_epoch = False\n if found_period:\n for i in range(-5, 5):\n right_epoch = right_epoch or (np.abs(t0 - epoch + i * period) < (\n 1. / 24.))\n if right_epoch:\n snr = df[\"snr\"].iloc[j]\n run = df[\"run\"].iloc[j]\n sde = df[\"sde\"].iloc[j]\n break\n found = right_epoch\n new_report = {\"period\": period, \"radius\": r_planet, \"epoch\": epoch, \"found\": found, \"sde\": sde,\n \"snr\": snr,\n \"run\": int(run)}\n reports_df = reports_df.append(new_report, ignore_index=True)\n reports_df.to_csv(inject_dir + \"a_sherlock_report.csv\", index=False)\n print(\"P=\" + str(period) + \", R=\" + str(r_planet) + \", T0=\" + str(epoch) + \", FOUND WAS \" + str(\n found) +\n \" WITH SNR \" + str(snr) + \"and SDE \" + str(sde))\n except Exception as e:\n print(e)\n print(\"File not valid: \" + file)\n\n # If preserve parameter is not True, we remove inject files:\n if not self.preserve:\n for file in os.listdir(inject_dir):\n if file.endswith(\".csv\") and file.startswith(\"P\"):\n os.remove(inject_dir + file)\n\n def transit_masks(self, transit_masks, time):\n if transit_masks is None:\n transit_masks = []\n result = np.full(len(time), False)\n for mask in transit_masks:\n intransit = transit_mask(time, mask[\"P\"], 2 * mask[\"D\"], mask[\"T0\"])\n result[intransit] = True\n\n return result\n\n def __clean(self, lc, detrend_period, detrend_period_method, custom_clean_algorithm):\n clean_flux = lc.flux.value\n time = lc.time.value\n if custom_clean_algorithm is not None:\n clean_flux = custom_clean_algorithm.clean(time, clean_flux)\n elif detrend_period:\n periodogram = lc.to_periodogram(minimum_period=0.05, maximum_period=15, oversample_factor=10)\n ws = self.__calculate_max_significant_period(lc, periodogram)\n clean_flux = wotan.flatten(time, clean_flux, window_length=ws, return_trend=False,\n method=detrend_period_method, break_tolerance=0.5)\n return clean_flux\n\n def __calculate_max_significant_period(self, lc, periodogram):\n #max_accepted_period = (lc.time[len(lc.time) - 1] - lc.time[0]) / 4\n max_accepted_period = np.float64(10)\n # TODO related to https://github.com/franpoz/SHERLOCK/issues/29 check whether this fits better\n max_power_index = np.argmax(periodogram.power)\n period = periodogram.period[max_power_index]\n if max_power_index > 0.0008:\n period = period.value\n logging.info(\"Auto-Detrend found the strong period: \" + str(period) + \".\")\n else:\n logging.info(\"Auto-Detrend did not find relevant periods.\")\n period = None\n return period\n\n @staticmethod\n def plot_results(object_id, inject_dir, binning=1, xticks=None, yticks=None, period_grid_geom=\"lin\",\n radius_grid_geom=\"lin\"):\n df = pd.read_csv(inject_dir + '/a_tls_report.csv', float_precision='round_trip', sep=',',\n usecols=['period', 'radius', 'found', 'sde'])\n min_period = df[\"period\"].min()\n max_period = df[\"period\"].max()\n min_rad = df[\"radius\"].min()\n max_rad = df[\"radius\"].max()\n phases = len(df[df[\"period\"] == df[\"period\"].min()][df[\"radius\"] == df[\"radius\"].min()])\n phases_str = \"phase\" if phases == 1 else \"phases\"\n bin_nums = int(np.ceil(len(df[\"period\"].unique()) / binning))\n if period_grid_geom == 'lin':\n step_period = (max_period - min_period) / (len(df[\"period\"].unique()) - 1)\n step_period = step_period * binning\n if step_period <= 0:\n step_period = 0.1\n period_grid = np.linspace(min_period, max_period, bin_nums)\\\n if max_period - min_period > 0 else np.full((1), min_period)\n else:\n period_grid = np.logspace(np.log10(min_period), np.log10(max_period), bin_nums)\n bin_nums = int(np.ceil(len(df[\"radius\"].unique()) / binning))\n if radius_grid_geom == 'lin':\n step_radius = (max_rad - min_rad) / (len(df[\"radius\"].unique()) - 1)\n step_radius = step_radius * binning\n if step_radius <= 0:\n step_radius = 0.1\n radius_grid = np.round(np.linspace(min_rad, max_rad, bin_nums), 2)\\\n if max_rad - min_rad > 0 else np.full((1), min_rad)\n else:\n radius_grid = np.round(np.logspace(np.log10(min_rad), np.log10(max_rad), 2), bin_nums)\n f = len(period_grid) / len(radius_grid)\n bins = [period_grid, radius_grid]\n h1, x, y = np.histogram2d(df['period'][df['found'] == 1], df['radius'][df['found'] == 1], bins=bins)\n h2, x, y = np.histogram2d(df['period'][df['found'] == 0], df['radius'][df['found'] == 0], bins=bins)\n normed_hist = (100. * h1 / (h1 + h2))\n fig, ax = plt.subplots(figsize=(2.7 * 5, 5))\n im = plt.imshow(normed_hist.T, origin='lower', extent=(x[0], x[-1], y[0], y[-1]), interpolation='none',\n aspect='auto', cmap='viridis', vmin=0, vmax=100, rasterized=True)\n plt.colorbar(im, label='Recovery rate (%)')\n plt.xlabel('Injected period (days)')\n plt.ylabel(r'Injected radius (R$_\\oplus$)')\n ax.set_title(object_id + \" - P/R recovery (\" + str(phases) + \" \" + phases_str + \")\")\n if xticks is not None:\n plt.xticks(xticks)\n else:\n period_ticks_decimals = MATRIX.num_of_zeros(max_period - min_period) + 1\n plot_bins = 10 if 10 < len(period_grid) else len(period_grid)\n plt.locator_params(axis=\"x\", nbins=plot_bins)\n ax.xaxis.set_major_formatter(FormatStrFormatter('%.' + str(period_ticks_decimals) + 'f'))\n if yticks is not None:\n plt.xticks(yticks)\n plt.savefig(inject_dir + '/inj-rec.png', bbox_inches='tight', dpi=200)\n plt.close()\n\n @staticmethod\n def plot_diff(object_id, inject_dir1, inject_dir2, output_dir, binning=1, xticks=None, yticks=None,\n period_grid_geom=\"lin\", radius_grid_geom=\"lin\"):\n df1 = pd.read_csv(inject_dir1 + '/a_tls_report.csv', float_precision='round_trip', sep=',',\n usecols=['period', 'radius', 'found', 'sde'])\n df2 = pd.read_csv(inject_dir2 + '/a_tls_report.csv', float_precision='round_trip', sep=',',\n usecols=['period', 'radius', 'found', 'sde'])\n min_period = df1[\"period\"].min()\n max_period = df1[\"period\"].max()\n min_rad = df1[\"radius\"].min()\n max_rad = df1[\"radius\"].max()\n phases = len(df1[df1[\"period\"] == df1[\"period\"].min()][df1[\"radius\"] == df1[\"radius\"].min()])\n phases_str = \"phase\" if phases == 1 else \"phases\"\n bin_nums = int(np.ceil(len(df1[\"period\"].unique()) / binning))\n if period_grid_geom == 'lin':\n step_period = (max_period - min_period) / (len(df1[\"period\"].unique()) - 1)\n step_period = step_period * binning\n if step_period <= 0:\n step_period = 0.1\n period_grid = np.linspace(min_period, max_period, bin_nums)\\\n if max_period - min_period > 0 else np.full((1), min_period)\n else:\n period_grid = np.logspace(np.log10(min_period), np.log10(max_period), bin_nums)\n bin_nums = int(np.ceil(len(df1[\"radius\"].unique()) / binning))\n if radius_grid_geom == 'lin':\n step_radius = (max_rad - min_rad) / (len(df1[\"radius\"].unique()) - 1)\n step_radius = step_radius * binning\n if step_radius <= 0:\n step_radius = 0.1\n radius_grid = np.round(np.linspace(min_rad, max_rad, bin_nums), 2)\\\n if max_rad - min_rad > 0 else np.full((1), min_rad)\n else:\n radius_grid = np.round(np.logspace(np.log10(min_rad), np.log10(max_rad), 2), bin_nums)\n f = len(period_grid) / len(radius_grid)\n bins = [period_grid, radius_grid]\n h11, x1, y1 = np.histogram2d(df1['period'][df1['found'] == 1], df1['radius'][df1['found'] == 1], bins=bins)\n h12, x1, y1 = np.histogram2d(df1['period'][df1['found'] == 0], df1['radius'][df1['found'] == 0], bins=bins)\n h21, x2, y2 = np.histogram2d(df2['period'][df2['found'] == 1], df2['radius'][df2['found'] == 1], bins=bins)\n h22, x2, y2 = np.histogram2d(df2['period'][df2['found'] == 0], df2['radius'][df2['found'] == 0], bins=bins)\n h1 = h11 - h12\n h2 = h21 - h22\n normed_hist1 = phases * h11 / (h11 + h12)\n normed_hist2 = phases * h21 / (h21 + h22)\n normed_hist = normed_hist1 - normed_hist2\n fig, ax = plt.subplots(figsize=(2.7 * 5, 5))\n im = plt.imshow(normed_hist.T, origin='lower', extent=(x1[0], x1[-1], y1[0], y1[-1]), interpolation='none',\n aspect='auto', cmap='viridis', vmin=-phases, vmax=phases, rasterized=True)\n plt.colorbar(im, label='# Found samples diff.')\n plt.xlabel('Injected period (days)')\n plt.ylabel(r'Injected radius (R$_\\oplus$)')\n ax.set_title(object_id + \" - P/R recovery diff(\" + str(phases) + \" \" + phases_str + \")\")\n if xticks is not None:\n plt.xticks(xticks)\n else:\n period_ticks_decimals = MATRIX.num_of_zeros(max_period - min_period) + 1\n plot_bins = 10 if 10 < len(period_grid) else len(period_grid)\n plt.locator_params(axis=\"x\", nbins=plot_bins)\n ax.xaxis.set_major_formatter(FormatStrFormatter('%.' + str(period_ticks_decimals) + 'f'))\n if yticks is not None:\n plt.xticks(yticks)\n plt.savefig(output_dir + '/inj-rec-diff.png', bbox_inches='tight', dpi=200)\n plt.close()\n\n def __search(self, time, flux, rstar, rstar_min, rstar_max, mass, mstar_min, mstar_max, ab, epoch,\n period, min_period, max_period, min_snr, transit_template, ws, transits_min_count,\n run_limit, custom_search_algorithm):\n tls_period_grid = self.__calculate_period_grid(time, min_period, max_period, 3, self.star_info,\n transits_min_count)\n if custom_search_algorithm is not None:\n return custom_search_algorithm.search(time, flux, rstar, rstar_min, rstar_max, mass, mstar_min, mstar_max,\n ab, epoch, period, min_period, max_period, min_snr, self.cores,\n transit_template, ws, transits_min_count, run_limit)\n else:\n return self.__tls_search(time, flux, rstar, rstar_min, rstar_max, mass, mstar_min, mstar_max, ab, epoch,\n period, min_period, max_period, min_snr, self.cores, transit_template, ws, transits_min_count,\n run_limit, tls_period_grid)\n\n def __tls_search(self, time, flux, rstar, rstar_min, rstar_max, mass, mstar_min, mstar_max, ab, epoch,\n period, min_period, max_period, min_snr, cores, transit_template, ws, transits_min_count,\n run_limit, tls_period_grid):\n snr = 1e12\n found_signal = False\n time, flux = cleaned_array(time, flux)\n run = 0\n if ws > 0:\n flux = wotan.flatten(time, flux, window_length=ws, return_trend=False, method='biweight', break_tolerance=0.5)\n while snr >= min_snr and not found_signal and (run_limit > 0 and run < run_limit):\n model = transitleastsquares(time, flux)\n # R_starx = rstar / u.R_sun\n results = model.power(u=ab,\n R_star=rstar, # rstar/u.R_sun,\n R_star_min=rstar_min, # rstar_min/u.R_sun,\n R_star_max=rstar_max, # rstar_max/u.R_sun,\n M_star=mass, # mstar/u.M_sun,\n M_star_min=mstar_min, # mstar_min/u.M_sun,\n M_star_max=mstar_max, # mstar_max/u.M_sun,\n period_min=min_period,\n period_max=max_period,\n n_transits_min=transits_min_count,\n show_progress_bar=False,\n use_threads=cores,\n transit_template=transit_template,\n period_grid=tls_period_grid\n )\n snr = results.snr\n if results.snr >= min_snr:\n intransit_result = transit_mask(time, results.period, 2 * results.duration, results.T0)\n time = time[~intransit_result]\n flux = flux[~intransit_result]\n time, flux = cleaned_array(time, flux)\n right_period = self.__is_multiple_of(results.period, period / 2.)\n right_epoch = False\n for tt in results.transit_times:\n for i in range(-5, 5):\n right_epoch = right_epoch or (np.abs(tt - epoch + i * period) < (1. / 24.))\n # right_depth = (np.abs(np.sqrt(1.-results.depth)*rstar - rplanet)/rplanet < 0.05) #check if the depth matches\n if right_period and right_epoch:\n found_signal = True\n break\n run = run + 1\n return found_signal, results.snr, results.SDE, run, results.duration, results.period, results.T0\n\n def __equal(self, a, b, tolerance=0.01):\n return np.abs(a - b) < tolerance\n\n def __calculate_period_grid(self, time, min_period, max_period, oversampling, star_info, transits_min_count):\n dif = time[1:] - time[:-1]\n jumps = np.where(dif > 1)[0]\n jumps = np.append(jumps, len(time))\n previous_jump_index = 0\n time_span_all_sectors = 0\n for jumpIndex in jumps:\n time_chunk = time[previous_jump_index + 1:jumpIndex] # ignoring first measurement as could be the last from the previous chunk\n time_span_all_sectors = time_span_all_sectors + (time_chunk[-1] - time_chunk[0])\n previous_jump_index = jumpIndex\n return DefaultTransitTemplateGenerator() \\\n .period_grid(star_info.radius, star_info.mass, time[-1] - time[0], min_period, max_period, oversampling,\n transits_min_count, time_span_all_sectors)\n\n @staticmethod\n def num_of_zeros(n):\n if n.is_integer():\n return 0\n s = '{:.16f}'.format(n).split('.')[1]\n return len(s) - len(s.lstrip('0'))\n\n def __is_multiple_of(self, a, b, tolerance=0.05):\n a = np.float(a)\n b = np.float(b)\n mod_ab = a % b\n mod_ba = b % a\n return (a > b and a < b * 3 + tolerance * 3 and (\n abs(mod_ab % 1) <= tolerance or abs((b - mod_ab) % 1) <= tolerance)) or \\\n (b > a and a > b / 3 - tolerance / 3 and (\n abs(mod_ba % 1) <= tolerance or abs((a - mod_ba) % 1) <= tolerance))\n", "meta": {"hexsha": "6fbd522ea90b7c4e944b212685ac9c71f3598c87", "size": 35620, "ext": "py", "lang": "Python", "max_stars_repo_path": "tkmatrix/tkmatrix_class.py", "max_stars_repo_name": "PlanetHunters/tkmatrix", "max_stars_repo_head_hexsha": "7c112e2cbcd1e75753828a334720ddf7972c8551", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-03-09T18:50:23.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-09T18:50:23.000Z", "max_issues_repo_path": "tkmatrix/tkmatrix_class.py", "max_issues_repo_name": "PlanetHunters/tkmatrix", "max_issues_repo_head_hexsha": "7c112e2cbcd1e75753828a334720ddf7972c8551", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 15, "max_issues_repo_issues_event_min_datetime": "2021-03-24T14:13:02.000Z", "max_issues_repo_issues_event_max_datetime": "2021-10-16T06:37:45.000Z", "max_forks_repo_path": "tkmatrix/tkmatrix_class.py", "max_forks_repo_name": "martindevora/tkmatrix", "max_forks_repo_head_hexsha": "7c112e2cbcd1e75753828a334720ddf7972c8551", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-03-09T18:50:26.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-09T18:50:26.000Z", "avg_line_length": 58.4893267652, "max_line_length": 139, "alphanum_fraction": 0.5521617069, "include": true, "reason": "import numpy,import astropy", "num_tokens": 8024, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.600188359260205, "lm_q2_score": 0.32082130731838393, "lm_q1q2_score": 0.19255321405513484}} {"text": "import torch\nimport numpy as np\nimport os\nfrom skimage import draw\nfrom geotnf.transformation import GeometricTnf\nfrom geotnf.flow import th_sampling_grid_to_np_flow, write_flo_file\nimport torch.nn.functional as F\nfrom data.pf_dataset import PFDataset, PFPascalDataset\nfrom data.caltech_dataset import CaltechDataset\nfrom torch.autograd import Variable\nfrom geotnf.point_tnf import PointTnf, PointsToUnitCoords, PointsToPixelCoords\nfrom util.py_util import create_file_path\nfrom model.loss import WeakInlierCount, TwoStageWeakInlierCount\n\n\ndef compute_metric(metric,model,dataset,dataloader,batch_tnf,batch_size,two_stage=True,do_aff=False,do_tps=False,args=None):\n # Initialize stats\n N=len(dataset)\n stats={}\n # decide which results should be computed aff/tps/aff+tps\n if two_stage or do_aff:\n stats['aff']={}\n if not two_stage and do_tps:\n stats['tps']={}\n if two_stage:\n stats['aff_tps']={}\n # choose metric function and metrics to compute\n if metric=='pck': \n metrics = ['pck']\n metric_fun = pck_metric\n if metric=='dist':\n metrics = ['dist']\n metric_fun = point_dist_metric\n elif metric=='area':\n metrics = ['intersection_over_union',\n 'label_transfer_accuracy',\n 'localization_error']\n metric_fun = area_metrics\n elif metric=='pascal_parts':\n metrics = ['intersection_over_union','pck']\n metric_fun = pascal_parts_metrics\n elif metric=='flow':\n metrics = ['flow']\n metric_fun = flow_metrics\n elif metric=='inlier_count':\n metrics = ['inlier_count']\n metric_fun = inlier_count\n model.return_correlation = True\n # initialize vector for storing results for each metric\n for key in stats.keys():\n for metric in metrics:\n stats[key][metric] = np.zeros((N,1))\n\n # Compute\n for i, batch in enumerate(dataloader):\n batch = batch_tnf(batch) \n batch_start_idx=batch_size*i\n batch_end_idx=np.minimum(batch_start_idx+batch_size,N)\n\n model.eval()\n theta_aff=None\n theta_tps=None\n theta_aff_tps=None\n \n if two_stage:\n if model.return_correlation==False:\n theta_aff,theta_aff_tps=model(batch)\n else:\n theta_aff,theta_aff_tps,corr_aff,corr_aff_tps=model(batch)\n elif do_aff:\n theta_aff=model(batch)\n if isinstance(theta_aff,tuple):\n theta_aff=theta_aff[0]\n elif do_tps:\n theta_tps=model(batch) \n if isinstance(theta_tps,tuple):\n theta_tps=theta_tps[0]\n \n if metric=='inlier_count':\n stats = inlier_count(batch,batch_start_idx,theta_aff,theta_tps,theta_aff_tps,corr_aff,corr_aff_tps,stats,args)\n elif metric_fun is not None:\n stats = metric_fun(batch,batch_start_idx,theta_aff,theta_tps,theta_aff_tps,stats,args)\n \n print('Batch: [{}/{} ({:.0f}%)]'.format(i, len(dataloader), 100. * i / len(dataloader)))\n\n # Print results\n if metric == 'flow':\n print('Flow files have been saved to '+args.flow_output_dir)\n return stats\n\n for key in stats.keys():\n print('=== Results '+key+' ===')\n for metric in metrics:\n # print per-class brakedown for PFPascal, or caltech\n if isinstance(dataset,PFPascalDataset):\n N_cat = int(np.max(dataset.category))\n for c in range(N_cat):\n cat_idx = np.nonzero(dataset.category==c+1)[0]\n print(dataset.category_names[c].ljust(15)+': ','{:.2%}'.format(np.mean(stats[key][metric][cat_idx])))\n\n # print mean value\n results=stats[key][metric]\n good_idx = np.flatnonzero((results!=-1) * ~np.isnan(results))\n print('Total: '+str(results.size))\n print('Valid: '+str(good_idx.size)) \n filtered_results = results[good_idx]\n print(metric+':','{:.2%}'.format(np.mean(filtered_results)))\n\n print('\\n')\n \n return stats\n\ndef pck(source_points,warped_points,L_pck,alpha=0.1):\n # compute precentage of correct keypoints\n batch_size=source_points.size(0)\n pck=torch.zeros((batch_size))\n for i in range(batch_size):\n p_src = source_points[i,:]\n p_wrp = warped_points[i,:]\n N_pts = torch.sum(torch.ne(p_src[0,:],-1)*torch.ne(p_src[1,:],-1))\n point_distance = torch.pow(torch.sum(torch.pow(p_src[:,:N_pts]-p_wrp[:,:N_pts],2),0),0.5)\n L_pck_mat = L_pck[i].expand_as(point_distance)\n correct_points = torch.le(point_distance,L_pck_mat*alpha)\n pck[i]=torch.mean(correct_points.float())\n return pck\n\ndef mean_dist(source_points,warped_points,L_pck):\n # compute precentage of correct keypoints\n batch_size=source_points.size(0)\n dist=torch.zeros((batch_size))\n for i in range(batch_size):\n p_src = source_points[i,:]\n p_wrp = warped_points[i,:]\n N_pts = torch.sum(torch.ne(p_src[0,:],-1)*torch.ne(p_src[1,:],-1))\n point_distance = torch.pow(torch.sum(torch.pow(p_src[:,:N_pts]-p_wrp[:,:N_pts],2),0),0.5)\n L_pck_mat = L_pck[i].expand_as(point_distance)\n dist[i]=torch.mean(torch.div(point_distance,L_pck_mat))\n return dist\n\ndef point_dist_metric(batch,batch_start_idx,theta_aff,theta_tps,theta_aff_tps,stats,args,use_cuda=True):\n do_aff = theta_aff is not None\n do_tps = theta_tps is not None\n do_aff_tps = theta_aff_tps is not None\n \n source_im_size = batch['source_im_size']\n target_im_size = batch['target_im_size']\n\n source_points = batch['source_points']\n target_points = batch['target_points']\n \n # Instantiate point transformer\n pt = PointTnf(use_cuda=use_cuda,\n tps_reg_factor=args.tps_reg_factor)\n\n # warp points with estimated transformations\n target_points_norm = PointsToUnitCoords(target_points,target_im_size)\n\n if do_aff:\n # do affine only\n warped_points_aff_norm = pt.affPointTnf(theta_aff,target_points_norm)\n warped_points_aff = PointsToPixelCoords(warped_points_aff_norm,source_im_size)\n\n if do_tps:\n # do tps only\n warped_points_tps_norm = pt.tpsPointTnf(theta_tps,target_points_norm)\n warped_points_tps = PointsToPixelCoords(warped_points_tps_norm,source_im_size)\n \n if do_aff_tps:\n # do tps+affine\n warped_points_aff_tps_norm = pt.tpsPointTnf(theta_aff_tps,target_points_norm)\n warped_points_aff_tps_norm = pt.affPointTnf(theta_aff,warped_points_aff_tps_norm)\n warped_points_aff_tps = PointsToPixelCoords(warped_points_aff_tps_norm,source_im_size)\n \n L_pck = batch['L_pck'].data\n \n current_batch_size=batch['source_im_size'].size(0)\n indices = range(batch_start_idx,batch_start_idx+current_batch_size)\n\n# import pdb; pdb.set_trace()\n\n if do_aff:\n dist_aff = mean_dist(source_points.data, warped_points_aff.data, L_pck)\n \n if do_tps:\n dist_tps = mean_dist(source_points.data, warped_points_tps.data, L_pck)\n \n if do_aff_tps:\n dist_aff_tps = mean_dist(source_points.data, warped_points_aff_tps.data, L_pck)\n \n if do_aff:\n stats['aff']['dist'][indices] = dist_aff.unsqueeze(1).cpu().numpy()\n if do_tps:\n stats['tps']['dist'][indices] = dist_tps.unsqueeze(1).cpu().numpy()\n if do_aff_tps:\n stats['aff_tps']['dist'][indices] = dist_aff_tps.unsqueeze(1).cpu().numpy() \n \n return stats\n\ndef inlier_count(batch,batch_start_idx,theta_aff,theta_tps,theta_aff_tps,corr_aff,corr_aff_tps,stats,args,use_cuda=True):\n inliersComposed = TwoStageWeakInlierCount(use_cuda=torch.cuda.is_available(),dilation_filter=0,normalize_inlier_count=True)\n inliers_comp = inliersComposed(matches=corr_aff,theta_aff=theta_aff,theta_aff_tps=theta_aff_tps)\n current_batch_size=batch['source_im_size'].size(0)\n indices = range(batch_start_idx,batch_start_idx+current_batch_size)\n \n stats['aff_tps']['inlier_count'][indices] = inliers_comp.unsqueeze(1).cpu().data.numpy()\n\n return stats\n\n\ndef pck_metric(batch,batch_start_idx,theta_aff,theta_tps,theta_aff_tps,stats,args,use_cuda=True):\n alpha = args.pck_alpha\n do_aff = theta_aff is not None\n do_tps = theta_tps is not None\n do_aff_tps = theta_aff_tps is not None\n \n source_im_size = batch['source_im_size']\n target_im_size = batch['target_im_size']\n\n source_points = batch['source_points']\n target_points = batch['target_points']\n \n # Instantiate point transformer\n pt = PointTnf(use_cuda=use_cuda,\n tps_reg_factor=args.tps_reg_factor)\n\n # warp points with estimated transformations\n target_points_norm = PointsToUnitCoords(target_points,target_im_size)\n\n if do_aff:\n # do affine only\n warped_points_aff_norm = pt.affPointTnf(theta_aff,target_points_norm)\n warped_points_aff = PointsToPixelCoords(warped_points_aff_norm,source_im_size)\n\n if do_tps:\n # do tps only\n warped_points_tps_norm = pt.tpsPointTnf(theta_tps,target_points_norm)\n warped_points_tps = PointsToPixelCoords(warped_points_tps_norm,source_im_size)\n \n if do_aff_tps:\n # do tps+affine\n warped_points_aff_tps_norm = pt.tpsPointTnf(theta_aff_tps,target_points_norm)\n warped_points_aff_tps_norm = pt.affPointTnf(theta_aff,warped_points_aff_tps_norm)\n warped_points_aff_tps = PointsToPixelCoords(warped_points_aff_tps_norm,source_im_size)\n \n L_pck = batch['L_pck'].data\n \n current_batch_size=batch['source_im_size'].size(0)\n indices = range(batch_start_idx,batch_start_idx+current_batch_size)\n\n # import pdb; pdb.set_trace()\n\n if do_aff:\n pck_aff = pck(source_points.data, warped_points_aff.data, L_pck, alpha)\n \n if do_tps:\n pck_tps = pck(source_points.data, warped_points_tps.data, L_pck, alpha)\n \n if do_aff_tps:\n pck_aff_tps = pck(source_points.data, warped_points_aff_tps.data, L_pck, alpha)\n \n if do_aff:\n stats['aff']['pck'][indices] = pck_aff.unsqueeze(1).cpu().numpy()\n if do_tps:\n stats['tps']['pck'][indices] = pck_tps.unsqueeze(1).cpu().numpy()\n if do_aff_tps:\n stats['aff_tps']['pck'][indices] = pck_aff_tps.unsqueeze(1).cpu().numpy() \n \n return stats\n\ndef pascal_parts_metrics(batch,batch_start_idx,theta_aff,theta_tps,theta_aff_tps,stats,args,use_cuda=True):\n do_aff = theta_aff is not None\n do_tps = theta_tps is not None\n do_aff_tps = theta_aff_tps is not None\n\n batch_size=batch['source_im_size'].size(0)\n for b in range(batch_size):\n idx = batch_start_idx+b\n h_src = int(batch['source_im_size'][b,0].data.cpu().numpy())\n w_src = int(batch['source_im_size'][b,1].data.cpu().numpy())\n h_tgt = int(batch['target_im_size'][b,0].data.cpu().numpy())\n w_tgt = int(batch['target_im_size'][b,1].data.cpu().numpy())\n \n # do pck\n if batch['keypoint_A'][b].size!=0:\n src_points = Variable(torch.FloatTensor(batch['keypoint_A'][b])).unsqueeze(0)\n tgt_points = Variable(torch.FloatTensor(batch['keypoint_B'][b])).unsqueeze(0)\n L_pck = Variable(torch.FloatTensor([batch['L_pck'][b]])).unsqueeze(1)\n if use_cuda:\n src_points=src_points.cuda()\n tgt_points=tgt_points.cuda()\n L_pck = L_pck.cuda()\n\n batch_b = {'source_im_size': batch['source_im_size'][b,:].unsqueeze(0),\n 'target_im_size': batch['target_im_size'][b,:].unsqueeze(0),\n 'source_points': src_points,\n 'target_points': tgt_points,\n 'L_pck': L_pck}\n args.pck_alpha = 0.05\n stats = pck_metric(batch_b,\n idx,\n theta_aff[b,:].unsqueeze(0) if do_aff else None,\n theta_tps[b,:].unsqueeze(0) if do_tps else None,\n theta_aff_tps[b,:].unsqueeze(0) if do_aff_tps else None,\n stats,args,use_cuda)\n else:\n if do_aff:\n stats['aff']['pck'][idx] = -1\n if do_tps:\n stats['tps']['pck'][idx] = -1\n if do_aff_tps:\n stats['aff_tps']['pck'][idx] = -1\n \n # do area\n source_mask = Variable(torch.FloatTensor(batch['part_A'][b].astype(np.float32)).unsqueeze(0).transpose(2,3).transpose(1,2))\n target_mask = Variable(torch.FloatTensor(batch['part_B'][b].astype(np.float32)).unsqueeze(0).transpose(2,3).transpose(1,2))\n \n if use_cuda:\n source_mask = source_mask.cuda()\n target_mask = target_mask.cuda()\n \n grid_aff,grid_tps,grid_aff_tps=theta_to_sampling_grid(h_tgt,w_tgt,\n theta_aff[b,:] if do_aff else None,\n theta_tps[b,:] if do_tps else None,\n theta_aff_tps[b,:] if do_aff_tps else None,\n use_cuda=use_cuda,\n tps_reg_factor=args.tps_reg_factor)\n\n \n if do_aff:\n warped_mask_aff = F.grid_sample(source_mask, grid_aff) \n stats['aff']['intersection_over_union'][idx] = intersection_over_union(warped_mask_aff,target_mask) \n if do_tps:\n warped_mask_tps = F.grid_sample(source_mask, grid_tps) \n stats['tps']['intersection_over_union'][idx] = intersection_over_union(warped_mask_tps,target_mask)\n if do_aff_tps:\n warped_mask_aff_tps = F.grid_sample(source_mask, grid_aff_tps) \n stats['aff_tps']['intersection_over_union'][idx] = intersection_over_union(warped_mask_aff_tps,target_mask)\n\n return stats\n\ndef area_metrics(batch,batch_start_idx,theta_aff,theta_tps,theta_aff_tps,stats,args,use_cuda=True):\n do_aff = theta_aff is not None\n do_tps = theta_tps is not None\n do_aff_tps = theta_aff_tps is not None\n \n batch_size=batch['source_im_size'].size(0)\n\n pt=PointTnf(use_cuda=use_cuda)\n\n for b in range(batch_size):\n h_src = int(batch['source_im_size'][b,0].data.cpu().numpy())\n w_src = int(batch['source_im_size'][b,1].data.cpu().numpy())\n h_tgt = int(batch['target_im_size'][b,0].data.cpu().numpy())\n w_tgt = int(batch['target_im_size'][b,1].data.cpu().numpy())\n\n target_mask_np,target_mask = poly_str_to_mask(batch['target_polygon'][0][b],\n batch['target_polygon'][1][b],\n h_tgt,w_tgt,use_cuda=use_cuda)\n\n source_mask_np,source_mask = poly_str_to_mask(batch['source_polygon'][0][b],\n batch['source_polygon'][1][b],\n h_src,w_src,use_cuda=use_cuda)\n\n grid_X,grid_Y = np.meshgrid(np.linspace(-1,1,w_tgt),np.linspace(-1,1,h_tgt))\n grid_X = torch.FloatTensor(grid_X).unsqueeze(0).unsqueeze(3)\n grid_Y = torch.FloatTensor(grid_Y).unsqueeze(0).unsqueeze(3)\n grid_X = Variable(grid_X,requires_grad=False)\n grid_Y = Variable(grid_Y,requires_grad=False)\n\n if use_cuda:\n grid_X = grid_X.cuda()\n grid_Y = grid_Y.cuda()\n\n grid_X_vec = grid_X.view(1,1,-1)\n grid_Y_vec = grid_Y.view(1,1,-1)\n\n grid_XY_vec = torch.cat((grid_X_vec,grid_Y_vec),1) \n\n def pointsToGrid (x,h_tgt=h_tgt,w_tgt=w_tgt): return x.contiguous().view(1,2,h_tgt,w_tgt).transpose(1,2).transpose(2,3)\n\n idx = batch_start_idx+b\n \n if do_aff:\n grid_aff = pointsToGrid(pt.affPointTnf(theta_aff[b,:].unsqueeze(0),grid_XY_vec))\n warped_mask_aff = F.grid_sample(source_mask, grid_aff) \n flow_aff = th_sampling_grid_to_np_flow(source_grid=grid_aff,h_src=h_src,w_src=w_src)\n \n stats['aff']['intersection_over_union'][idx] = intersection_over_union(warped_mask_aff,target_mask)\n stats['aff']['label_transfer_accuracy'][idx] = label_transfer_accuracy(warped_mask_aff,target_mask)\n stats['aff']['localization_error'][idx] = localization_error(source_mask_np, target_mask_np, flow_aff)\n if do_tps:\n grid_tps = pointsToGrid(pt.tpsPointTnf(theta_tps[b,:].unsqueeze(0),grid_XY_vec))\n warped_mask_tps = F.grid_sample(source_mask, grid_tps)\n flow_tps = th_sampling_grid_to_np_flow(source_grid=grid_tps,h_src=h_src,w_src=w_src)\n \n stats['tps']['intersection_over_union'][idx] = intersection_over_union(warped_mask_tps,target_mask)\n stats['tps']['label_transfer_accuracy'][idx] = label_transfer_accuracy(warped_mask_tps,target_mask)\n stats['tps']['localization_error'][idx] = localization_error(source_mask_np, target_mask_np, flow_tps)\n if do_aff_tps:\n grid_aff_tps = pointsToGrid(pt.affPointTnf(theta_aff[b,:].unsqueeze(0),pt.tpsPointTnf(theta_aff_tps[b,:].unsqueeze(0),grid_XY_vec)))\n warped_mask_aff_tps = F.grid_sample(source_mask, grid_aff_tps)\n flow_aff_tps = th_sampling_grid_to_np_flow(source_grid=grid_aff_tps,h_src=h_src,w_src=w_src)\n \n stats['aff_tps']['intersection_over_union'][idx] = intersection_over_union(warped_mask_aff_tps,target_mask)\n stats['aff_tps']['label_transfer_accuracy'][idx] = label_transfer_accuracy(warped_mask_aff_tps,target_mask)\n stats['aff_tps']['localization_error'][idx] = localization_error(source_mask_np, target_mask_np, flow_aff_tps)\n \n return stats\n\n\ndef flow_metrics(batch,batch_start_idx,theta_aff,theta_tps,theta_aff_tps,stats,args,use_cuda=True):\n result_path=args.flow_output_dir\n \n do_aff = theta_aff is not None\n do_tps = theta_tps is not None\n do_aff_tps = theta_aff_tps is not None\n\n pt=PointTnf(use_cuda=use_cuda)\n \n batch_size=batch['source_im_size'].size(0)\n for b in range(batch_size):\n h_src = int(batch['source_im_size'][b,0].data.cpu().numpy())\n w_src = int(batch['source_im_size'][b,1].data.cpu().numpy())\n h_tgt = int(batch['target_im_size'][b,0].data.cpu().numpy())\n w_tgt = int(batch['target_im_size'][b,1].data.cpu().numpy())\n\n grid_X,grid_Y = np.meshgrid(np.linspace(-1,1,w_tgt),np.linspace(-1,1,h_tgt))\n grid_X = torch.FloatTensor(grid_X).unsqueeze(0).unsqueeze(3)\n grid_Y = torch.FloatTensor(grid_Y).unsqueeze(0).unsqueeze(3)\n grid_X = Variable(grid_X,requires_grad=False)\n grid_Y = Variable(grid_Y,requires_grad=False)\n if use_cuda:\n grid_X = grid_X.cuda()\n grid_Y = grid_Y.cuda()\n\n grid_X_vec = grid_X.view(1,1,-1)\n grid_Y_vec = grid_Y.view(1,1,-1)\n\n grid_XY_vec = torch.cat((grid_X_vec,grid_Y_vec),1) \n\n def pointsToGrid (x,h_tgt=h_tgt,w_tgt=w_tgt): return x.contiguous().view(1,2,h_tgt,w_tgt).transpose(1,2).transpose(2,3)\n\n idx = batch_start_idx+b\n \n if do_aff:\n grid_aff = pointsToGrid(pt.affPointTnf(theta_aff[b,:].unsqueeze(0),grid_XY_vec))\n flow_aff = th_sampling_grid_to_np_flow(source_grid=grid_aff,h_src=h_src,w_src=w_src)\n flow_aff_path = os.path.join(result_path,'aff',batch['flow_path'][b])\n create_file_path(flow_aff_path)\n write_flo_file(flow_aff,flow_aff_path)\n if do_tps:\n grid_tps = pointsToGrid(pt.tpsPointTnf(theta_tps[b,:].unsqueeze(0),grid_XY_vec))\n flow_tps = th_sampling_grid_to_np_flow(source_grid=grid_tps,h_src=h_src,w_src=w_src)\n flow_tps_path = os.path.join(result_path,'tps',batch['flow_path'][b])\n create_file_path(flow_tps_path)\n write_flo_file(flow_tps,flow_tps_path)\n if do_aff_tps:\n grid_aff_tps = pointsToGrid(pt.affPointTnf(theta_aff[b,:].unsqueeze(0),pt.tpsPointTnf(theta_aff_tps[b,:].unsqueeze(0),grid_XY_vec)))\n flow_aff_tps = th_sampling_grid_to_np_flow(source_grid=grid_aff_tps,h_src=h_src,w_src=w_src)\n flow_aff_tps_path = os.path.join(result_path,'aff_tps',batch['flow_path'][b])\n create_file_path(flow_aff_tps_path)\n write_flo_file(flow_aff_tps,flow_aff_tps_path)\n\n idx = batch_start_idx+b\n return stats\n\ndef poly_to_mask(vertex_row_coords, vertex_col_coords, shape):\n fill_row_coords, fill_col_coords = draw.polygon(vertex_row_coords, vertex_col_coords, shape)\n mask = np.zeros(shape, dtype=np.bool)\n mask[fill_row_coords, fill_col_coords] = True\n return mask\n\ndef poly_str_to_mask(poly_x_str,poly_y_str,out_h,out_w,use_cuda=True):\n polygon_x = np.fromstring(poly_x_str,sep=',')\n polygon_y = np.fromstring(poly_y_str,sep=',')\n mask_np = poly_to_mask(vertex_col_coords=polygon_x,\n vertex_row_coords=polygon_y,shape=[out_h,out_w])\n mask = Variable(torch.FloatTensor(mask_np.astype(np.float32)).unsqueeze(0).unsqueeze(0))\n if use_cuda:\n mask = mask.cuda()\n return (mask_np,mask)\n\n#def intersection_over_union(warped_mask,target_mask): \n# return torch.sum(warped_mask.data.gt(0.5) & target_mask.data.gt(0.5))/torch.sum(warped_mask.data.gt(0.5) | target_mask.data.gt(0.5))\ndef intersection_over_union(warped_mask,target_mask): \n relative_part_weight = torch.sum(torch.sum(target_mask.data.gt(0.5).float(),2,True),3,True)/torch.sum(target_mask.data.gt(0.5).float())\n part_iou = torch.sum(torch.sum((warped_mask.data.gt(0.5) & target_mask.data.gt(0.5)).float(),2,True),3,True)/torch.sum(torch.sum((warped_mask.data.gt(0.5) | target_mask.data.gt(0.5)).float(),2,True),3,True)\n weighted_iou = torch.sum(torch.mul(relative_part_weight,part_iou))\n return weighted_iou\n\ndef label_transfer_accuracy(warped_mask,target_mask): \n return torch.mean((warped_mask.data.gt(0.5) == target_mask.data.gt(0.5)).double())\n\ndef localization_error(source_mask_np, target_mask_np, flow_np):\n h_tgt, w_tgt = target_mask_np.shape[0],target_mask_np.shape[1]\n h_src, w_src = source_mask_np.shape[0],source_mask_np.shape[1]\n\n # initial pixel positions x1,y1 in target image\n x1, y1 = np.meshgrid(range(1,w_tgt+1), range(1,h_tgt+1))\n # sampling pixel positions x2,y2\n x2 = x1 + flow_np[:,:,0]\n y2 = y1 + flow_np[:,:,1]\n\n # compute in-bound coords for each image\n in_bound = (x2 >= 1) & (x2 <= w_src) & (y2 >= 1) & (y2 <= h_src)\n row,col = np.where(in_bound)\n row_1=y1[row,col].flatten().astype(np.int)-1\n col_1=x1[row,col].flatten().astype(np.int)-1\n row_2=y2[row,col].flatten().astype(np.int)-1\n col_2=x2[row,col].flatten().astype(np.int)-1\n\n # compute relative positions\n target_loc_x,target_loc_y = obj_ptr(target_mask_np)\n source_loc_x,source_loc_y = obj_ptr(source_mask_np)\n x1_rel=target_loc_x[row_1,col_1]\n y1_rel=target_loc_y[row_1,col_1]\n x2_rel=source_loc_x[row_2,col_2]\n y2_rel=source_loc_y[row_2,col_2]\n\n # compute localization error\n loc_err = np.mean(np.abs(x1_rel-x2_rel)+np.abs(y1_rel-y2_rel))\n \n return loc_err\n\ndef obj_ptr(mask):\n # computes images of normalized coordinates around bounding box\n # kept function name from DSP code\n h,w = mask.shape[0],mask.shape[1]\n y, x = np.where(mask>0.5)\n left = np.min(x);\n right = np.max(x);\n top = np.min(y);\n bottom = np.max(y);\n fg_width = right-left + 1;\n fg_height = bottom-top + 1;\n x_image,y_image = np.meshgrid(range(1,w+1), range(1,h+1));\n x_image = (x_image - left)/fg_width;\n y_image = (y_image - top)/fg_height;\n return (x_image,y_image)\n\n", "meta": {"hexsha": "2d0da244246766918bc64e38fef3ac72c9c9dea7", "size": 23991, "ext": "py", "lang": "Python", "max_stars_repo_path": "util/eval_util.py", "max_stars_repo_name": "hukim1112/weakalign", "max_stars_repo_head_hexsha": "4d2c5a275fd50f34418734198b32de3c8ce749a8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "util/eval_util.py", "max_issues_repo_name": "hukim1112/weakalign", "max_issues_repo_head_hexsha": "4d2c5a275fd50f34418734198b32de3c8ce749a8", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "util/eval_util.py", "max_forks_repo_name": "hukim1112/weakalign", "max_forks_repo_head_hexsha": "4d2c5a275fd50f34418734198b32de3c8ce749a8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.3456561922, "max_line_length": 210, "alphanum_fraction": 0.6504105706, "include": true, "reason": "import numpy", "num_tokens": 6121, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5813030906443134, "lm_q2_score": 0.33111974622959367, "lm_q1q2_score": 0.19248093185662354}} {"text": "# Copyright 2020 Makani Technologies LLC\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\"\"\"Python dynamics helpers.\n\nProvides a simplified control-oriented model of the wing and tether.\n\"\"\"\nimport collections\nimport copy\n\nfrom makani.analysis.control import actuator_util\nfrom makani.analysis.control import catenary\nfrom makani.analysis.control import geometry\nfrom makani.analysis.control import type_util\nfrom makani.control import control_types\nfrom makani.control import system_types\nfrom makani.sim.physics import physics\nimport numpy as np\n\n# Structure storing a force, moment, and position at which that force\n# is applied.\nForceMomentPos = collections.namedtuple('ForceMomentPos',\n ['force', 'moment', 'pos'])\n\n# Structure for storing forces and moment.\nForceMoment = collections.namedtuple('ForceMoment', ['force', 'moment'])\n\n# Structure representing the inputs to the wing.\n# thrust: Motor thrust [N] (1-by-1 np.matrix).\n# motor_moment: Motor moments [N-m] (3-by-1 np.matrix).\n# flaps: Flaps [rad] (kNumFlaps-by-1 np.matrix).\n# wind_g: Wind speed [m/s] in ground coordinates (3-by-1 np.matrix).\nWingInputs = type_util.MakeNamedVectorClass( # pylint: disable=invalid-name\n 'WingInputs', [('thrust', range(0, 1)),\n ('motor_moment', range(1, 4)),\n ('flaps', range(4, 4 + system_types.kNumFlaps)),\n ('wind_g', range(4 + system_types.kNumFlaps,\n 7 + system_types.kNumFlaps))])\n\n\nclass WingState(type_util.MakeStateClass(\n 'WingState', [('omega_b', range(0, 3)),\n ('dcm_g2b', range(3, 6)),\n ('wing_vel_g', range(6, 9)),\n ('wing_pos_g', range(9, 12))])):\n \"\"\"Class representing the state of the wing.\n\n Attributes:\n omega_b: Body angular rates.\n dcm_g2b: Ground to body rotation DCM. Increments in the DCM are represented\n by an Euler vector.\n wing_vel_g: Velocity of the wing in ground coordinates.\n wing_pos_g: Position of the wing in ground coordinates.\n \"\"\"\n\n def Increment(self, tangent, step=1.0):\n \"\"\"Return a state evolved from this state along a tangent direction.\n\n Args:\n tangent: A WingState.Tangent along which to move.\n step: A scaling of how far to move.\n\n Returns:\n A new WingState.\n \"\"\"\n return WingState(omega_b=self.omega_b + step * tangent.domega_b,\n dcm_g2b=(geometry.AxisToDcm(step * tangent.ddcm_g2b)\n * self.dcm_g2b),\n wing_vel_g=self.wing_vel_g + step * tangent.dwing_vel_g,\n wing_pos_g=self.wing_pos_g + step * tangent.dwing_pos_g)\n\n def Difference(self, other_state):\n \"\"\"Inverse operation of Increment with a step size of 1.0.\"\"\"\n return WingState.Tangent(\n domega_b=other_state.omega_b - self.omega_b,\n ddcm_g2b=geometry.DcmToAxis(other_state.dcm_g2b * self.dcm_g2b.T),\n dwing_vel_g=other_state.wing_vel_g - self.wing_vel_g,\n dwing_pos_g=other_state.wing_pos_g - self.wing_pos_g)\n\n @type_util.RequireMatrixArguments(None, (3, 1))\n def CalcAerodynamicAngles(self, wind_g):\n \"\"\"Calculates (v_rel, alpha, beta) from the current wing state.\n\n Args:\n wind_g: A 3-by-1 matrix storing the wind in g coordinates.\n\n Returns:\n A tuple (v_rel, alpha, beta).\n \"\"\"\n return geometry.VelocitiesToAerodynamicAngles(\n self.dcm_g2b, self.wing_vel_g, wind_g)\n\n\n@type_util.RequireMatrixArguments((3, 1), (3, 2), None, None)\ndef _CalcBridleKnotPos(tether_force_b, bridle_pos, bridle_y_offset,\n bridle_radius):\n \"\"\"Calculate the bridle knot position in body coordinates.\"\"\"\n if np.linalg.norm(tether_force_b) == 0.0:\n tether_force_b = np.matrix([[0.0], [0.0], [1.0]])\n\n # Calculate the knot point location. Here we use a bridle\n # coordinate system with its origin at the bridle pivot, its\n # y-axis pointing toward the starboard bridle point and its z-axis\n # pointed at the knot.\n bridle_coord_y = bridle_pos[:, 1] - bridle_pos[:, 0]\n bridle_coord_y /= np.linalg.norm(bridle_coord_y)\n\n bridle_coord_z = copy.copy(tether_force_b)\n bridle_coord_z -= bridle_coord_y * (np.transpose(bridle_coord_y)\n * tether_force_b)\n bridle_coord_z /= np.linalg.norm(bridle_coord_z)\n\n bridle_coord_origin = (bridle_pos[:, 1] + bridle_pos[:, 0]) * 0.5\n bridle_coord_origin[1] += bridle_y_offset\n\n return bridle_coord_origin + bridle_coord_z * bridle_radius\n\n\nclass MotorModel(object):\n\n # pylint: disable=unused-argument\n def CalcMotorForceMomentPos(self, v_rel, alpha, beta, omega_b,\n thrust, motor_moment_r):\n raise NotImplementedError()\n\n\nclass PureForceMomentMotorModel(MotorModel):\n\n def __init__(self, rotor_params, pos_com_b):\n self._dcm_r2b = geometry.AngleToDcm(\n 0.0, np.arctan2(rotor_params[0]['axis'][2],\n rotor_params[0]['axis'][0]), 0.0)\n self._pos_com_b = np.matrix(pos_com_b).T\n\n # pylint: disable=unused-argument\n @type_util.RequireMatrixArguments(None, None, None, None, (3, 1), (1, 1),\n (3, 1))\n def CalcMotorForceMomentPos(self, v_rel, alpha, beta, omega_b,\n thrust, motor_moment_r):\n # NOTE: This neglects motor reaction torques, and assumes that\n # MixRotors cancels the non-zero torque about the center-of-mass\n # that results from pure thrusting.\n motor_force_r = np.matrix([[thrust[0, 0]], [0.0], [0.0]])\n return ForceMomentPos(\n self._dcm_r2b * motor_force_r, self._dcm_r2b * motor_moment_r,\n self._pos_com_b)\n\n\nclass MotorMixerMotorModel(MotorModel):\n \"\"\"Model the commanded thrust and moment by calling MixRotors.\"\"\"\n\n def __init__(self, rotor_databases, air_density, weights, rotor_params,\n rotor_control_params, hover_flight_mode=False):\n self._dcm_r2b = geometry.AngleToDcm(\n 0.0, np.arctan2(rotor_params[0]['axis'][2],\n rotor_params[0]['axis'][0]), 0.0)\n self._rotor_databases = rotor_databases\n self._air_density = air_density\n self._weights = weights\n self._rotor_params = rotor_params\n self._rotor_control_params = rotor_control_params\n self._hover_flight_mode = hover_flight_mode\n\n @type_util.RequireMatrixArguments(None, None, (3, 1), (1, 1), (3, 1))\n def CalcRotorSpeeds(self, v_rel, omega_b, thrust, motor_moment_r):\n thrust_moment = {\n 'thrust': thrust[0, 0],\n 'moment': [motor_moment_r[i, 0] for i in range(3)]\n }\n\n return actuator_util.MixRotors(\n thrust_moment, self._weights, v_rel, [omega_b[i, 0] for i in range(3)],\n control_types.kStackingStateNormal, self._hover_flight_mode,\n self._air_density, self._rotor_params, self._rotor_control_params)\n\n @type_util.RequireMatrixArguments(None, None, None, None, (3, 1), (1, 1),\n (3, 1))\n def CalcMotorForceMomentPos(self, v_rel, alpha, beta, omega_b,\n thrust, motor_moment_r):\n rotor_speeds = self.CalcRotorSpeeds(v_rel, omega_b, thrust, motor_moment_r)\n total_force = np.matrix(np.zeros((3, 1)))\n total_moment = np.matrix(np.zeros((3, 1)))\n\n v_rel_b = geometry.AerodynamicAnglesToRelativeVelocity(v_rel, alpha, beta)\n for i in range(rotor_speeds.shape[0]):\n rotor_speed = rotor_speeds[i, 0]\n if self._rotor_params[i]['dir'] == system_types.kPositiveX:\n direction = 1.0\n else:\n direction = -1.0\n rotor_velocity = direction * rotor_speed\n\n rotor_pos_b = np.matrix(self._rotor_params[i]['pos']).T\n v_freestream = np.dot(\n self._dcm_r2b[:, 0].T, v_rel_b + np.cross(omega_b.T, rotor_pos_b.T).T)\n v_freestream *= (1.0 - self._rotor_params[i]['local_pressure_coeff'])**0.5\n\n rotor_thrust = self._rotor_databases[i].CalcThrust(\n rotor_speed, v_freestream[0, 0], self._air_density)\n rotor_torque = direction * self._rotor_databases[i].CalcTorque(\n rotor_speed, v_freestream[0, 0], self._air_density)\n\n motor_force_b = self._dcm_r2b * np.matrix([[rotor_thrust], [0.0], [0.0]])\n\n lever_arm_moment_b = np.cross(\n rotor_pos_b.T, motor_force_b.T).T\n aero_moment_b = self._dcm_r2b * np.matrix([[rotor_torque], [0.0], [0.0]])\n gyro_moment_b = np.cross(\n self._rotor_params[i]['I'] * rotor_velocity * self._dcm_r2b[:, 0].T,\n omega_b.T).T\n\n total_force += motor_force_b\n total_moment += lever_arm_moment_b + aero_moment_b + gyro_moment_b\n\n return ForceMomentPos(\n total_force, total_moment, np.matrix(np.zeros((3, 1))))\n\n\nclass TetherForceModel(object):\n\n # pylint: disable=unused-argument\n def CalcBodyForce(self, dcm_g2b, wing_pos_g, wing_vel_g, wind_g):\n raise NotImplementedError()\n\n\nclass ConstantTetherForceModel(TetherForceModel):\n \"\"\"Simple model of tether force as constant in ground coordinates.\"\"\"\n\n def __init__(self, force_g):\n self.SetForce(force_g)\n\n # pylint: disable=unused-argument\n @type_util.RequireMatrixArguments(None, (3, 3), (3, 1), (3, 1), (3, 1))\n def CalcBodyForce(self, dcm_g2b, wing_pos_g, wing_vel_g, wind_g):\n \"\"\"Calculate the tether force in body coordinates.\n\n Args:\n dcm_g2b: DCM rotating ground to body coordinates (3-by-3 np.matrix).\n wing_pos_g: Wing positon [m] in ground coordinates (unused\n 3-by-1 np.matrix).\n wing_vel_g: Wing velocity [m/s] in ground coordinates (unused\n 3-by-1 np.matrix).\n wind_g: Wind velocity [m/s] in ground coordinates (unused 3-by-1\n np.matrix).\n\n Returns:\n A 3-by-1 np.matrix storing the tether force in body coordinates.\n \"\"\"\n return dcm_g2b * self._force_g\n\n @type_util.RequireMatrixArguments(None, (3, 1))\n def SetForce(self, force_g):\n \"\"\"Update the force vector.\n\n Args:\n force_g: New tether force in ground coordinates.\n \"\"\"\n self._force_g = copy.copy(force_g)\n\n\nclass SimpleSpringTetherForceModel(TetherForceModel):\n \"\"\"Model of tether force as a simple spring, including bridle interactions.\"\"\"\n\n def __init__(self, spring_const, system_params):\n tether_params = system_params['tether']\n wing_params = system_params['wing']\n\n self._spring_const = spring_const\n self._tether_length = tether_params['length']\n self._tether_drag_area = (0.25 * tether_params['section_drag_coeff']\n * tether_params['length']\n * tether_params['outer_diameter'])\n self._air_density = system_params['phys']['rho']\n self._bridle_pos = np.matrix(wing_params['bridle_pos']).T\n self._bridle_y_offset = wing_params['bridle_y_offset']\n self._bridle_radius = wing_params['bridle_rad']\n\n # pylint: disable=unused-argument\n @type_util.RequireMatrixArguments(None, (3, 3), (3, 1), (3, 1), (3, 1))\n def CalcBodyForce(self, dcm_g2b, wing_pos_g, wing_vel_g, wind_g):\n \"\"\"Calculate the tether force in body coordinates.\n\n Args:\n dcm_g2b: DCM rotating ground to body coordinates (3-by-3 np.matrix).\n wing_pos_g: Wing positon [m] in ground coordinates (3-by-1 np.matrix).\n wing_vel_g: Wing velocity [m/s] in ground coordinates (3-by-1 np.matrix).\n wind_g: Wind velocity [m/s] in ground coordinates (3-by-1 np.matrix).\n\n Returns:\n A 3-by-1 np.matrix storing the tether force in body coordinates.\n \"\"\"\n # This intentionally ignores the small offset from the GSG\n # position for simplicity.\n bridle_knot_b = _CalcBridleKnotPos(dcm_g2b * -wing_pos_g,\n self._bridle_pos,\n self._bridle_y_offset,\n self._bridle_radius)\n bridle_knot_g = wing_pos_g + dcm_g2b.T * bridle_knot_b\n tension = self._spring_const * (np.linalg.norm(bridle_knot_g)\n - self._tether_length)\n spring_force_g = -tension * bridle_knot_g / np.linalg.norm(bridle_knot_g)\n\n airspeed = np.linalg.norm(wing_vel_g - wind_g)\n drag = 0.5 * self._air_density * airspeed**2.0 * self._tether_drag_area\n drag_force_g = drag * (wind_g - wing_vel_g) / max(airspeed, 0.1)\n return dcm_g2b * (spring_force_g + drag_force_g)\n\n\nclass CatenaryTetherForceModel(TetherForceModel):\n \"\"\"Model of tether force using catenary tension and rigid-rod drag.\"\"\"\n\n def __init__(self, tether_params, gsg_pos_g, bridle_radius, g, air_density):\n \"\"\"Create a catenary tether force model.\n\n Args:\n tether_params: TetherParams dictionary.\n gsg_pos_g: Position [m] of the GSG in the g-frame.\n bridle_radius: Bridle radius [m] of the kite.\n g: Gravitational acceleration [m/s^2].\n air_density: Air density [kg/m^3].\n \"\"\"\n self._gsg_pos_g = np.matrix(np.reshape(gsg_pos_g, (3, 1)))\n self._length = tether_params['length'] + bridle_radius\n self._weight = tether_params['length'] * tether_params['linear_density'] * g\n self._section_drag_coeff = tether_params['section_drag_coeff']\n self._outer_diameter = tether_params['outer_diameter']\n self._air_density = air_density\n\n # pylint: disable=unused-argument\n @type_util.RequireMatrixArguments(None, (3, 3), (3, 1), (3, 1), (3, 1))\n def CalcBodyForce(self, dcm_g2b, wing_pos_g, wing_vel_g, wind_g):\n \"\"\"Calculate the tether force in body coordinates.\n\n Args:\n dcm_g2b: DCM rotating ground to body coordinates (3-by-3 np.matrix).\n wing_pos_g: Wing positon [m] in ground coordinates (3-by-1 np.matrix).\n wing_vel_g: Wing velocity [m/s] in ground coordinates (3-by-1 np.matrix).\n wind_g: Wind velocity [m/s] in ground coordinates (unused 3-by-1\n np.matrix).\n\n Returns:\n A 3-by-1 np.matrix storing the tether force in body coordinates.\n \"\"\"\n # Calculate catenary tension.\n horizontal_distance = (wing_pos_g[0, 0]**2.0 + wing_pos_g[1, 0]**2.0)**0.5\n vertical_distance = self._gsg_pos_g[2, 0] - wing_pos_g[2, 0]\n (h, v) = catenary.DimensionlessTensionsFromPoint(\n horizontal_distance / self._length,\n vertical_distance / self._length)\n azi = np.arctan2(wing_pos_g[1, 0], wing_pos_g[0, 0])\n tension_g = self._weight * np.matrix(\n [[-h * np.cos(azi)], [-h * np.sin(azi)], [v]])\n\n # Calculate drag reaction force on the wing. This is calculated by modeling\n # the tether as a rigid rod that is pinned at the GSG and rotating at fixed\n # angular velocity.\n #\n # Let\n # CD = cross-sectional drag coefficient\n # s = diameter of the rod\n # L = length of rod\n # V = velocity of the free end of the rod\n # rho = air density\n # The drag dD along a segment of the rod with length dx at distance x from\n # the fixed end is\n # dD(x) = 1/2 * rho * v(x)^2 * CD * s * dx.\n # Therefore,\n # dD/dx = 1/2 * rho * v(x)^2 * CD * s.\n # The velocity of the segment is v(x) = x/L * V, so\n # dD/dx = 1/2 * rho * x^2 / L^2 * V^2 * CD * s\n # From this, we obtain the differential moment about the fixed end:\n # dM/dx = x * dD/dx = 1/2 * rho * x^3 / L^2 * V^2 * CD * s.\n # Integrating from x=0 to x=L yields the total moment due to drag,\n # M = 1/8 * rho * L^2 * V^2 * CD * s.\n # Force at the fixed end induces no moment, so the drag moment must be\n # entirely balanced by a reaction force at the free end (i.e. the kite).\n # The magnitude of this force, R, is\n # R = M / L = 1/8 * rho * L * V^2 * CD * s.\n #\n # Here, we treat the rod as extending from the GSG to the body frame origin,\n # and we use the wing velocity normal to the rod to determine V.\n gsg_to_wing_g = wing_pos_g - self._gsg_pos_g\n gsg_to_wing_dir_g = gsg_to_wing_g / np.linalg.norm(gsg_to_wing_g)\n\n normal_vel_g = (wing_vel_g\n - float(wing_vel_g.T * gsg_to_wing_dir_g)\n * gsg_to_wing_dir_g)\n normal_vel_mag = np.linalg.norm(normal_vel_g)\n drag_direction_g = -normal_vel_g / normal_vel_mag\n drag_g = (1.0 / 8.0 * self._air_density * np.linalg.norm(gsg_to_wing_g)\n * normal_vel_mag**2.0 * self._section_drag_coeff\n * self._outer_diameter * drag_direction_g)\n\n return dcm_g2b * (tension_g + drag_g)\n\n\nclass SwigAeroModel(object):\n \"\"\"Swig import of the simulator aerodynamics model.\"\"\"\n\n def __init__(self):\n self._aero = physics.Aero(physics.GetAeroSimParams())\n\n @type_util.RequireMatrixArguments(None, None, None, None,\n (system_types.kNumFlaps, 1), (3, 1),\n None)\n def CalcFMCoeff(self, alpha, beta, reynolds_number, flaps, omega_hat,\n thrust_coeff):\n \"\"\"Calculates force and moment coefficients from the Swig database.\"\"\"\n omega_hat_vec3 = physics.Vec3()\n omega_hat_vec3.x = omega_hat[0, 0]\n omega_hat_vec3.y = omega_hat[1, 0]\n omega_hat_vec3.z = omega_hat[2, 0]\n flaps_vec = physics.VecWrapper(system_types.kNumFlaps)\n for i in range(system_types.kNumFlaps):\n flaps_vec.SetValue(i, flaps[i, 0])\n force_moment = physics.ForceMoment()\n self._aero.CalcForceMomentCoeff(alpha, beta, omega_hat_vec3.this,\n flaps_vec.GetVec(), reynolds_number,\n force_moment.this, thrust_coeff)\n force_moment_coeff = (np.matrix([[force_moment.force.x],\n [force_moment.force.y],\n [force_moment.force.z]]),\n np.matrix([[force_moment.moment.x],\n [force_moment.moment.y],\n [force_moment.moment.z]]))\n return force_moment_coeff\n\n\nclass Wing(object):\n \"\"\"Simplified model of the wing for control design.\n\n The Wing class stores parameters defined by the environment (air\n density, gravitational constant), a stateless tether force model,\n a stateless aerodynamic model, and a nominal orientation.\n\n It provides functions for calculating the ODEs that govern a 6-DOF\n rigid body model.\n \"\"\"\n\n def __init__(self, system_params, sim_params, aero_model, motor_model,\n tether_force_model):\n \"\"\"Constructs a Wing model.\n\n Args:\n system_params: A system parameters structure from mconfig.\n sim_params: A simulator parameters structure from mconfig.\n aero_model: A Python class implementing a function CalcFMCoeff. See\n SwigAeroModel in this module as an example.\n motor_model: A MotorModel.\n tether_force_model: A TetherForceModel.\n \"\"\"\n self._wing_area = system_params['wing']['A']\n self._wing_span = system_params['wing']['b']\n self._wing_chord = system_params['wing']['c']\n self._wing_mass = system_params['wing']['m']\n self._wing_inertia_matrix = np.matrix(system_params['wing']['I']['d'])\n self._pos_com_b = np.matrix(system_params['wing']['center_of_mass_pos']).T\n\n # Bridle parameters.\n self._bridle_pos = np.matrix(system_params['wing']['bridle_pos']).T\n self._bridle_y_offset = system_params['wing']['bridle_y_offset']\n self._bridle_radius = system_params['wing']['bridle_rad']\n\n # Physics parameters.\n self._g_g = np.matrix([[0.0], [0.0], [system_params['phys']['g']]])\n self._air_density = system_params['phys']['rho']\n self._dynamic_viscosity = sim_params['phys_sim']['dynamic_viscosity']\n\n self._aero_model = aero_model\n self._motor_model = motor_model\n self._tether_force_model = tether_force_model\n\n @type_util.RequireMatrixArguments(None, (3, 3))\n def _CalcGravityForceMomentPos(self, dcm_g2b):\n return ForceMomentPos(dcm_g2b * (self._wing_mass * self._g_g),\n np.matrix(np.zeros((3, 1))), self._pos_com_b)\n\n @type_util.RequireMatrixArguments(None, None, None, None, (3, 1), (1, 1),\n (3, 1))\n def _CalcMotorForceMomentPos(self, v_rel, alpha, beta, omega_b,\n thrust, motor_moment):\n \"\"\"Calculates the motor forces and moments.\"\"\"\n return self._motor_model.CalcMotorForceMomentPos(\n v_rel, alpha, beta, omega_b, thrust, motor_moment)\n\n @type_util.RequireMatrixArguments(None, (3, 3), (3, 1), (3, 1), (3, 1))\n def _CalcTetherForceMomentPos(self, dcm_g2b, wing_pos_g, wing_vel_g, wind_g):\n tether_force_b = self._tether_force_model.CalcBodyForce(dcm_g2b, wing_pos_g,\n wing_vel_g, wind_g)\n return ForceMomentPos(tether_force_b, np.matrix(np.zeros((3, 1))),\n _CalcBridleKnotPos(tether_force_b, self._bridle_pos,\n self._bridle_y_offset,\n self._bridle_radius))\n\n def CalcTetherForceG(self, state, inputs):\n return state.dcm_g2b.T * self._tether_force_model.CalcBodyForce(\n state.dcm_g2b, state.wing_pos_g, state.wing_vel_g, inputs.wind_g)\n\n def CalcTetherTensionRollPitch(self, state, inputs):\n tether_force_b = self._tether_force_model.CalcBodyForce(\n state.dcm_g2b, state.wing_pos_g, state.wing_vel_g, inputs.wind_g)\n return geometry.TetherForceCartToSph(tether_force_b)\n\n @type_util.RequireMatrixArguments(None, None, None, None, (3, 1),\n (system_types.kNumFlaps, 1), None)\n def CalcAeroForceMomentPos(self, v_rel, alpha, beta, omega_b, flaps,\n thrust_coeff):\n \"\"\"Calculate the aerodynamic force and moments on the wing.\n\n Args:\n v_rel: Airspeed [m/s].\n alpha: Angle-of-attack [rad].\n beta: Angle-of-sideslip [rad].\n omega_b: Wing body-rates [rad/s] (3-by-1 np.matrix).\n flaps: Flap deflections (kNumFlaps-by-1 np.matrix).\n thrust_coeff: Thrust coefficient [#] using wind turbine convention.\n\n Returns:\n (ForceMomentPos in body coordinates, force coeffs., moment coeffs.)\n \"\"\"\n reynolds_number = ((v_rel * self._wing_chord * self._air_density)\n / self._dynamic_viscosity)\n dynamic_pressure = 0.5 * self._air_density * v_rel**2.0\n\n length_scale = np.matrix([[self._wing_span],\n [self._wing_chord],\n [self._wing_span]])\n omega_hat = np.multiply(omega_b, length_scale) / (2.0 * v_rel)\n (cf, cm) = self._aero_model.CalcFMCoeff(alpha, beta, reynolds_number,\n flaps, omega_hat, thrust_coeff)\n\n return (ForceMomentPos(dynamic_pressure * self._wing_area * cf,\n (dynamic_pressure * self._wing_area\n * np.multiply(length_scale, cm)),\n np.matrix(np.zeros((3, 1)))),\n cf, cm)\n\n def _BodyForceMomentPosToComForceMoment(self, force_moment_pos_list):\n force = np.matrix(np.zeros((3, 1)))\n moment = np.matrix(np.zeros((3, 1)))\n for force_moment_pos in force_moment_pos_list:\n force += force_moment_pos.force\n moment += force_moment_pos.moment\n moment += np.cross(force_moment_pos.pos - self._pos_com_b,\n force_moment_pos.force, axis=0)\n return ForceMoment(force, moment)\n\n def CalcDeriv(self, state, inputs):\n \"\"\"Calculates the derivative of the wing state vector.\n\n Args:\n state: A WingState.\n inputs: A WingInputs.\n\n Returns:\n A WingState.Tangent containing the derivative of the state.\n \"\"\"\n euler_moment = np.cross(self._wing_inertia_matrix * state.omega_b,\n state.omega_b, axis=0)\n\n v_rel, alpha, beta = state.CalcAerodynamicAngles(inputs.wind_g)\n\n # Fixing total thrust coefficient to 0.0 for this application.\n # NOTE: By accounting for the rotor wake effect on the tail,\n # we found that the synthesized gains yield worse flight quality than when\n # the effect is ignored (see b/110491871 for details).\n thrust_coeff = 0.0\n aero_force_moment_pos, _, _ = self.CalcAeroForceMomentPos(\n v_rel, alpha, beta, state.omega_b, inputs.flaps, thrust_coeff)\n\n force_moment_com = self._BodyForceMomentPosToComForceMoment([\n self._CalcGravityForceMomentPos(state.dcm_g2b),\n self._CalcMotorForceMomentPos(\n v_rel, alpha, beta, state.omega_b, inputs.thrust,\n inputs.motor_moment),\n self._CalcTetherForceMomentPos(state.dcm_g2b, state.wing_pos_g,\n state.wing_vel_g, inputs.wind_g),\n aero_force_moment_pos,\n ForceMomentPos(np.matrix(np.zeros((3, 1))), euler_moment,\n np.matrix(np.zeros((3, 1))))\n ])\n\n # Calculate center-of-mass acceleration.\n accel_com_g = (state.dcm_g2b.T * force_moment_com.force) / self._wing_mass\n\n # Calculate body angular acceleration.\n omega_b_dot = np.matrix(np.linalg.solve(self._wing_inertia_matrix,\n force_moment_com.moment))\n\n wing_accel_g = accel_com_g - state.dcm_g2b.T * (\n np.cross(state.omega_b,\n np.cross(state.omega_b, self._pos_com_b, axis=0), axis=0)\n + np.cross(omega_b_dot, self._pos_com_b, axis=0))\n\n return WingState.Tangent(domega_b=omega_b_dot, ddcm_g2b=state.omega_b,\n dwing_vel_g=wing_accel_g,\n dwing_pos_g=state.wing_vel_g)\n\n def CalcDVbCom(self, state, state_dot):\n \"\"\"Calculates the rate of change of Vb for unit tests.\"\"\"\n return (state.dcm_g2b * state_dot.dwing_vel_g\n - np.cross(state.omega_b, state.dcm_g2b * state.wing_vel_g, axis=0)\n + np.cross(state_dot.domega_b, self._pos_com_b, axis=0))\n\n def CalcEnergy(self, state):\n \"\"\"Calculates energy of the rigid body model for unit tests.\"\"\"\n wing_com_pos_g = state.wing_pos_g + state.dcm_g2b.T * self._pos_com_b\n wing_com_vel_g = (state.wing_vel_g\n + (state.dcm_g2b.T\n * np.cross(state.omega_b, self._pos_com_b, axis=0)))\n return ((0.5 * np.transpose(state.omega_b)\n * self._wing_inertia_matrix * state.omega_b)\n + (0.5 * self._wing_mass * np.transpose(wing_com_vel_g)\n * wing_com_vel_g)\n - self._wing_mass * np.transpose(self._g_g) * wing_com_pos_g)[0, 0]\n\n\ndef CalcLinearization(f, state, inputs, state_step_sizes, input_step_sizes):\n \"\"\"Calculate the system matrices for the Wing model.\n\n Produces a linearized model:\n\n f(x + dx, u + du) ~ f(x) + A * dx + B * du\n\n where f is an arbitrary function, x is the wing state and u are\n the wing inputs.\n\n Args:\n f: A function mapping an n-by-1 np.matrix and an m-by-1 np.matrix to\n a n-by-1 np.matrix.\n state: An instance of a state class from type_util.\n inputs: An instance of a named vector from type_util.\n state_step_sizes: A vector of step sizes for the state.\n input_step_sizes: A vector of step sizes for the inputs.\n\n Returns:\n A tuple (A, B) where A and B are both of type np.matrix.\n \"\"\"\n num_states = state.Tangent.GetDim()\n num_inputs = inputs.GetDim()\n num_outputs = f(state, inputs).shape[0]\n\n dfdx = np.matrix(np.zeros((num_outputs, num_states)))\n dfdu = np.matrix(np.zeros((num_outputs, num_inputs)))\n for i in range(num_states):\n h = state_step_sizes[i, 0]\n e = state.Tangent.FromVector(np.matrix([\n [1.0 if j == i else 0.0] for j in range(num_states)]))\n\n dfdx[:, i] = (f(state.Increment(e, step=h), inputs)\n - f(state.Increment(e, step=-h), inputs)) / (2.0 * h)\n\n for i in range(num_inputs):\n h = input_step_sizes[i, 0]\n e = np.matrix([[1.0 if j == i else 0.0] for j in range(num_inputs)])\n dfdu[:, i] = (\n f(state, inputs.FromVector(inputs.ToVector() + h * e))\n - f(state, inputs.FromVector(inputs.ToVector() - h * e))) / (2.0 * h)\n\n return (dfdx, dfdu)\n", "meta": {"hexsha": "5286751a8b9c851a5bcf3823508a7b079e480f30", "size": 28331, "ext": "py", "lang": "Python", "max_stars_repo_path": "analysis/control/dynamics.py", "max_stars_repo_name": "leozz37/makani", "max_stars_repo_head_hexsha": "c94d5c2b600b98002f932e80a313a06b9285cc1b", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1178, "max_stars_repo_stars_event_min_datetime": "2020-09-10T17:15:42.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T14:59:35.000Z", "max_issues_repo_path": "analysis/control/dynamics.py", "max_issues_repo_name": "leozz37/makani", "max_issues_repo_head_hexsha": "c94d5c2b600b98002f932e80a313a06b9285cc1b", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-05-22T05:22:35.000Z", "max_issues_repo_issues_event_max_datetime": "2020-05-22T05:22:35.000Z", "max_forks_repo_path": "analysis/control/dynamics.py", "max_forks_repo_name": "leozz37/makani", "max_forks_repo_head_hexsha": "c94d5c2b600b98002f932e80a313a06b9285cc1b", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 107, "max_forks_repo_forks_event_min_datetime": "2020-09-10T17:29:30.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-18T09:00:14.000Z", "avg_line_length": 42.1592261905, "max_line_length": 80, "alphanum_fraction": 0.6498182203, "include": true, "reason": "import numpy", "num_tokens": 7610, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5813031051514762, "lm_q2_score": 0.3311197264277872, "lm_q1q2_score": 0.19248092514938}} {"text": "\"\"\"\nadaptive.py\n\nfunctions relating to simulating an AO system with Proper\nmostly code copied from the original MEDIS from Rupert\n\nGenerally, the optical prescription will call the deformable_mirror function, which will compile all information and\nrun sequentially all functions related to creating the adaptive optic correction (main AO functionality, relating to\natmospheric and common-path aberrations) as well as using or not CDI probes, DM corrections or errors, etc\n\nTODO\n Add astrogrid pattern functionality from MEDIS0\n\n\"\"\"\n\nimport numpy as np\nfrom scipy import interpolate, ndimage\nfrom inspect import getframeinfo, stack\nfrom skimage.restoration import unwrap_phase\nimport matplotlib.pylab as plt\nimport proper\nimport datetime\n\nfrom medis.params import sp, tp, ap\nfrom medis.CDI import cdi, config_probe\nfrom medis.optics import check_sampling\nfrom medis.utils import dprint\nfrom medis.plot_tools import quick2D\n\n\n################################################################################\n# Deformable Mirror\n################################################################################\ndef deformable_mirror(wf, WFS_map, iter, previous_output=None, apodize=False, plane_name='', debug=False):\n \"\"\"\n combine different DM actuator commands into single map to send to prop_dm\n\n prop_dm needs an input map of n_actuators x n_actuators in units of actuator command height. quick_ao will handle\n the conversion to actuator command height, and the CDI probe must be scaled in cdi.probe_amp in params in\n units of m. Each subroutine is also responsible for creating a map of n_actuators x n_actuators spacing. prop_dm\n handles the resampling of this map onto the wavefront, including the influence function. Its some wizardry that\n happens in c, and presumably it is taken care of so you don't have to worry about it.\n\n In the call to proper.prop_dm, we apply the flag tp.fit_dm, which switches between two 'modes' of proper's DM\n surface fitting. If FALSE, the DM is driven to the heights specified by dm_map, and the influence function will\n act on these heights to define the final surface shape applied to the DM, which may differ substantially from\n the initial heights specified by dm_map. If TRUE, proper will iterate applying the influence function to the\n input heights, and adjust the heights until the difference between the influenced-map and input map meets some\n proper-defined convergence criterea. Setting tp.fit_dm=TRUE will obviously slow down the code, but will (likely)\n more accurately represent a well-calibrated DM response function.\n\n much of this code copied over from example from Proper manual on pg 94\n\n :param wf: single wavefront\n :param WFS_map: wavefront sensor map, should be in units of phase delay\n :param previous_output:\n :param iter: the current index of iteration (which timestep this is)\n :param plane_name: name of plane (should be 'woofer' or 'tweeter' for best functionality)\n :return: nothing is returned, but the probe map has been applied to the DM via proper.prop_dm. DM plane post DM\n application can be saved via the sp.save_list functionality\n \"\"\"\n assert np.logical_xor(WFS_map is None, previous_output is None)\n\n # AO Actuator Count from DM Type\n if plane_name == 'tweeter' and hasattr(tp,'act_tweeter'):\n nact = tp.act_tweeter\n elif plane_name == 'woofer' and hasattr(tp,'act_woofer'):\n nact = tp.act_woofer\n else:\n nact = tp.ao_act\n\n # DM Coordinates\n nact_across_pupil = nact - 2 # number of full DM actuators across pupil (oversizing DM extent)\n dm_xc = (nact / 2) # The location of the optical axis (center of the wavefront) on the DM in\n dm_yc = (nact / 2) # actuator units. First actuator is centered on (0.0, 0.0). The 0.5 is a\n # parameter introduced/tuned by Rupert to remove weird errors (address this).\n # KD verified this needs to be here or else suffer weird errors 9/19\n # TODO address/remove the 0.5 in DM x,y coordinates\n\n ############################\n # Creating DM Surface Map\n ############################\n d_beam = 2 * proper.prop_get_beamradius(wf) # beam diameter\n act_spacing = d_beam / nact_across_pupil # actuator spacing [m]\n\n #######\n # AO\n #######\n if previous_output is not None and WFS_map is None:\n dm_map = update_dm(previous_output)\n else:\n dm_map = quick_ao(wf, nact, WFS_map[wf.iw])\n\n #########\n # Waffle\n #########\n if tp.satelite_speck['apply'] and plane_name is not 'woofer':\n waffle = make_speckle_kxy(tp.satelite_speck['xloc'], tp.satelite_speck['yloc'],\n tp.satelite_speck['amp'], tp.satelite_speck['phase'])\n waffle += make_speckle_kxy(tp.satelite_speck['xloc'], -tp.satelite_speck['yloc'],\n tp.satelite_speck['amp'], tp.satelite_speck['phase'])\n dm_map += waffle\n\n #######\n # CDI\n ######\n if cdi.use_cdi and plane_name == cdi.which_DM:\n theta = cdi.phase_series[iter]\n if not np.isnan(theta):\n # dprint(f\"Applying CDI probe, lambda = {wfo.wsamples[iw]*1e9:.2f} nm\")\n cdi.save_tseries(iter, datetime.datetime.now())\n probe = config_probe(theta, nact, iw=wf.iw, ib=wf.ib, tstep=iter)\n dm_map = dm_map + probe # Add Probe to DM map\n\n #########################\n # Applying Piston Error\n #########################\n if tp.piston_error:\n mean_dm_map = np.mean(np.abs(dm_map))\n var = 1e-4 # 1e-11\n dm_map = dm_map + np.random.normal(0, var, (dm_map.shape[0], dm_map.shape[1]))\n\n #########################\n # proper.prop_dm\n #########################\n dmap = proper.prop_dm(wf, dm_map, dm_xc, dm_yc, act_spacing, FIT=tp.fit_dm) #\n\n if debug and wf.iw == 0 and wf.ib == 0 and iter==0:\n dprint(plane_name)\n check_sampling(wf, iter, plane_name+' DM pupil plane', getframeinfo(stack()[0][0]), units='mm')\n\n quick2D(WFS_map[wf.iw], title=f\"WFS map after masking\",\n zlabel='unwrapped phase (rad)',\n vlim=[-3 * np.pi, 3 * np.pi])\n\n fig, ax = plt.subplots(1,1)\n cax = ax.imshow(dm_map*1e9, interpolation='none', origin='lower')\n plt.title(f'{plane_name} dm_map (actuator coordinates)')\n cb = plt.colorbar(cax)\n cb.set_label('nm')\n\n plt.show()\n\n post_ao = unwrap_phase(proper.prop_get_phase(wf)) * wf.lamda / (2 * np.pi)\n # quick2D(pre_ao_dist*1e9, title='unwrapped wavefront before DM', zlabel='nm', show=False) # , vlim=(-0.5e-7,0.5e-7))\n # quick2D(np.abs(pre_ao_amp)**2, title='Pre-AO Intensity', show=False)#, vlim=(-0.5e-7,0.5e-7))\n # quick2D(dmap, title='the phase map prop_dm is applying', zlabel='distance (m)', show=False)#, vlim=(-0.5e-7,0.5e-7))\n # plt.figure()\n # plt.plot(pre_ao_dist[len(pre_ao_dist)//2], label=f'pre_ao 1D cut, row {len(pre_ao_dist)//2}')\n # plt.plot(2*dmap[len(dmap)//2], label=f'dmap 1D cut (x2), row {len(dmap)//2}')\n # plt.plot((pre_ao_dist + (2*dmap))[len(dmap)//2], label='difference')\n # plt.legend()\n # plt.xlim(sp.grid_size//2*np.array([1-sp.beam_ratio*1.1, 1+sp.beam_ratio*1.1]))\n # quick2D(pre_ao + (2*dmap), title='diff', zlabel='m', show=False, vlim=(-0.5e-7,0.5e-7))\n # quick2D(post_ao, title='unwrapped wavefront after DM', zlabel='m', show=True, vlim=(-0.5e-7,0.5e-7))\n # quick2D(np.abs(proper.prop_get_amplitude(wf))**2, title='wavefront after DM intensity', show=False)\n # quick2D(proper.prop_get_phase(wf), title='wavefront after DM in phase units', zlabel='Phase',\n # show=True) # colormap='sunlight',\n\n if apodize:\n hardmask_pupil(wf)\n\n return dmap\n\n\n################################################################################\n# Ideal AO\n################################################################################\ndef quick_ao(wf, nact, WFS_map):\n \"\"\"\n calculate the offset map to send to the DM from the WFS map\n\n The main idea is to apply the DM only to the region of the wavefront that contains the beam. The phase map from\n the wfs saved the whole wavefront, so that must be cropped. During the wavefront initialization in\n wavefront.initialize_proper, the beam ratio set in sp.beam_ratio is scaled per wavelength (to achieve constant\n sampling sto create white light images), so the cropped value must also be scaled by wavelength. Note, beam ratio\n is scaled differently depending on if sp.focused_sys is True or not. See params-->sp.focused_sys and Proper\n manual pg 36 for more info.\n\n Then, we interpolate the cropped beam onto a grid of (n_actuators,n_actuators), such that the DM can apply a\n actuator height to each represented actuator, not a over or sub-sampled form. If the number of actuators is low\n compared to the number of samples on the beam, you should anti-alias the WFS map via a lowpass filter before\n interpolating. There is a discrepancy between the sampling of the wavefront at this location (the size you cropped)\n vs the size of the DM. proper.prop_dm handles this, so just plug in the n_actuator sized DM map with specified\n parameters, and assume that prop_dm handles the resampling correctly via the spacing or n_act_across_pupil flag.\n FYI the resampling is done via a c library you installed/compiled when installing proper.\n\n The WFS map is a map of real values in units of phase delay in radians. However, the AO map that gets passed to\n proper.prop_dm wants input in nm height of each actuator. Therefore, you need to convert the phase delay to\n a DM height. For the ideal AO, you would do this individually for each wavelength. However, for a 'real' AO system\n you do this for the median wavelength. You also need to account for a factor of 2, since the DM is modeled as\n a mirror so it travels the length of the phase delay twice.\n\n much of this code copied over from example from Proper manual on pg 94\n\n :param wfo: wavefront object created by optics.Wavefronts() [n_wavelengths, n_objects] of tp.gridsize x tp.gridsize\n :param WFS_map: returned from quick_wfs (as of Aug 2019, its an idealized image)\n :return: ao_map: map of DM actuator command heights in units of m\n \"\"\"\n\n nact_across_pupil = nact-2 # number of full DM actuators across pupil (oversizing DM extent)\n # Note: oversample by 2 actuators hardcoded here, check if this is appropriate \n \n ############################\n # Creating AO Surface Map\n ############################\n d_beam = 2 * proper.prop_get_beamradius(wf) # beam diameter\n act_spacing = d_beam / nact_across_pupil # actuator spacing [m]\n\n ###################################\n # Cropping the Beam from WFS map\n ###################################\n # cropping here by beam_ratio rather than d_beam is valid since the beam size was initialized\n # using the scaled beam_ratios when the wfo was created\n # crop should be -1,+1 on either side of the center because for an even sp.grid_size\n ao_map = WFS_map[\n sp.grid_size//2 - np.int_(wf.beam_ratio*sp.grid_size//2)-1:\n sp.grid_size//2 + np.int_(wf.beam_ratio*sp.grid_size//2)+2,\n sp.grid_size//2 - np.int_(wf.beam_ratio*sp.grid_size//2)-1:\n sp.grid_size//2 + np.int_(wf.beam_ratio*sp.grid_size//2)+2]\n # dprint(f\"WFS map coordinates are {sp.grid_size//2 - np.int_(wf.beam_ratio*sp.grid_size//2)-1},\"\n # f\"{sp.grid_size//2 + np.int_(wf.beam_ratio*sp.grid_size//2)+1}\")\n\n ########################################################\n # Interpolating the WFS map onto the actuator spacing\n # (tp.nact,tp.nact)\n ########################################################\n # Lowpass Filter- prevents aliasing; uses Gaussian filter\n nyquist_dm = nact/2 * act_spacing # [m]\n sigma = [nyquist_dm/2.355, nyquist_dm/2.355] # assume we want sigma to be twice the HWHM\n ao_map = ndimage.gaussian_filter(ao_map, sigma=sigma, mode='nearest')\n\n f = interpolate.interp2d(range(ao_map.shape[0]), range(ao_map.shape[0]), ao_map, kind='cubic')\n ao_map = f(np.linspace(0,ao_map.shape[0],nact), np.linspace(0,ao_map.shape[0], nact))\n # map_spacing = proper.prop_get_sampling(wf)\n # ao_map = proper.prop_magnify(ao_map, map_spacing / act_spacing, nact, QUICK=True)\n\n ################################################\n # Converting phase delay to DM actuator height\n ################################################\n # Apply the inverse of the WFS image to the DM, so use -dm_map (dm_map is in phase units, divide by k=2pi/lambda)\n surf_height = proper.prop_get_wavelength(wf) / (4 * np.pi) # [m/rad]\n ao_map = -ao_map * surf_height # Converts DM map to units of [m] of actuator heights\n\n return ao_map\n\n\ndef retro_wfs(star_fields, wfo, plane_name='wfs'):\n \"\"\"\n Retrospective wfs (measure an old field)\n\n :param star_fields:\n :param wfo:\n :param plane_name:\n :return:\n \"\"\"\n WFS_map = np.zeros((len(star_fields), sp.grid_size, sp.grid_size))\n from skimage.restoration import unwrap_phase\n for iw in range(len(star_fields)):\n quick2D(np.angle(star_fields), title='before mask', colormap='sunlight')\n phasemap = np.angle(star_fields[iw])\n masked_phase = np.ma.masked_equal(phasemap, 0)\n quick2D(masked_phase, title='before unwrap', colormap='sunlight')\n WFS_map[iw] = unwrap_phase(masked_phase, wrap_around=[False, False])\n WFS_map[iw][phasemap == 0] = 0\n quick2D(WFS_map[iw], title='after')\n if 'retro_closed_wfs' in sp.save_list:\n wfo.save_plane(location='WFS_map')\n\n return WFS_map\n\n\ndef open_loop_wfs(wfo, plane_name='wfs'):\n \"\"\"\n saves the unwrapped phase [arctan2(imag/real)] of the wfo.wf_collection at each wavelength\n\n It is an idealized image (exact copy) of the wavefront phase per wavelength. Only the map for the first object\n (the star) is saved. We have initialized\n\n Here we hardmask on the WFS map to be a circle around the beam in the pupil plane. This hard masking prevents the\n DM from acting on non-beam signal, since the DM modelled by proper is a nxn square array, but the beam is nominally\n circular for circular apertures.\n\n #TODO the way this is saved for naming the WFS_map is going to break if you want to do closed loop WFS on a\n #TODO woofer-tweeter system\n\n :param wfo: wavefront object\n :param plane_name: name of the plane to enable or disable saving the WFS map\n :return: array containing only the unwrapped phase delay of the wavefront; shape=[n_wavelengths], units=radians\n \"\"\"\n star_wf = wfo.wf_collection[:, 0]\n WFS_map = np.zeros((len(star_wf), sp.grid_size, sp.grid_size))\n\n for iw in range(len(star_wf)): # for each wavelength\n hardmask_pupil(star_wf[iw])\n phasemap = proper.prop_get_phase(star_wf[iw])\n WFS_map[iw] = unwrap_phase(phasemap, wrap_around=[False, False])\n WFS_map[iw][phasemap==0] = 0 #TODO is this still necessary?\n\n # if sp.verbose:\n # quick2D(WFS_map[iw], title=f\"WFS map after masking, lambda={wfo.wsamples[iw]*1e9:.2f}\",\n # zlabel='unwrapped phase (rad)',\n # vlim=[-3*np.pi, 3*np.pi])\n #\n\n if 'WFS' in sp.save_list or sp.closed_loop:\n wfo.save_plane(location='WFS')\n\n return WFS_map\n\n\ndef hardmask_pupil(wf):\n \"\"\"\n hard-edged circular mask of the pupil plane.\n\n Masks out the WFS map outside of the beam since the DM modeled by proper can only be a square nxn grid of actuators,\n and thus the influence function surrounding each DM actuator could be affecting on-beam pixels, even if the\n actuator is acting on off-beam signal. In other words, even if a cornerDM actuator doesn't actuate on the beam,\n if there was non-zero signal in the WFS map, it will try to act on it, and it could 'influence' nearby DM actuators\n that are acting on the beam.\n\n This hard-edged mask is different from prop_circular_aperture in that it does not anti-alias the edges of the mask\n based on the 'fill factor' of the edge pixels. Instead, it has a boolean mask to zero everything > a fixed radius,\n in this case determined by the grid size and beam ratio of each wavefront passed into it.\n\n :param wf: a single wavefront\n :return: nothing is returned but the wf passed into it has been masked\n\n \"\"\"\n phase_map = proper.prop_get_phase(wf)\n amp_map = proper.prop_get_amplitude(wf)\n\n # Sizing the Mask\n h, w = wf.wfarr.shape[:2]\n center = (int(w / 2), int(h / 2))\n radius = np.floor(sp.grid_size * wf.beam_ratio / 2) # Should scale with wavelength if sp.focused_system=False,\n # np.ceil used to oversize map so don't clip the beam\n # Making the Circular Boolean Mask\n Y, X = np.mgrid[:h, :w]\n dist_from_center = np.sqrt((X - center[0]) ** 2 + (Y - center[1]) ** 2)\n inds = dist_from_center <= radius\n\n # Applying the Mask to the Complex Array\n mask = np.zeros_like(phase_map)\n mask[inds] = 1\n masked = phase_map * mask\n wf.wfarr = proper.prop_shift_center(amp_map * np.cos(masked) + 1j * amp_map * np.sin(masked))\n\n # if sp.verbose:\n # dprint(f\"Radius of hard-edge pupil mask is {radius} pixels\")\n # quick2D(masked, title=f\"Masked phase map in hardmask_pupil, lambda={wf.lamda*1e9} nm\", zlabel='phase (rad)')\n # plt.show()\n\n\ndef make_speckle_kxy(kx, ky, amp, dm_phase):\n \"\"\"given an kx and ky wavevector,\n generates a NxN flatmap that has\n a speckle at that position\"\"\"\n N = tp.ao_act\n dmx, dmy = np.meshgrid(\n np.linspace(-0.5, 0.5, N),\n np.linspace(-0.5, 0.5, N))\n\n xm=dmx*kx*2.0*np.pi\n ym=dmy*ky*2.0*np.pi\n # print 'DM phase', dm_phase\n ret = amp*np.cos(xm + ym + dm_phase)\n return ret\n\n\n# def ao(wf, WFS_map, theta):\n# if sp.closed_loop:\n# deformable_mirror(wf, WFS_map, theta)\n# else:\n# WFS_map = open_loop_wfs(wf) # overwrite WFS_map\n# # dprint(f\"WFS_ma.shape = {WFS_map.shape}\")\n# deformable_mirror(wf, WFS_map, theta)\n#\n################################################################################\n# Full AO\n################################################################################\n# not implemented. Full AO implies a time delay, and maybe non-ideal WFS\n", "meta": {"hexsha": "c410b2ae01f468257a5ebd205edceea3603f59f4", "size": 18590, "ext": "py", "lang": "Python", "max_stars_repo_path": "medis/adaptive.py", "max_stars_repo_name": "jessmos/MEDIS", "max_stars_repo_head_hexsha": "eeea1904d31878fb3ad6444af144ee6f1d3ab705", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "medis/adaptive.py", "max_issues_repo_name": "jessmos/MEDIS", "max_issues_repo_head_hexsha": "eeea1904d31878fb3ad6444af144ee6f1d3ab705", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "medis/adaptive.py", "max_forks_repo_name": "jessmos/MEDIS", "max_forks_repo_head_hexsha": "eeea1904d31878fb3ad6444af144ee6f1d3ab705", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 48.5378590078, "max_line_length": 126, "alphanum_fraction": 0.6445938677, "include": true, "reason": "import numpy,from scipy", "num_tokens": 4875, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.519521321952093, "lm_q2_score": 0.37022540649291935, "lm_q1q2_score": 0.19233999260145246}} {"text": "#! /usr/bin/env python\n\n# Eureka! Stage 3 reduction pipeline\n\n# Proposed Steps\n# --------------\n# 1. Read in all data frames and header info from Stage 2 data products DONE\n# 2. Record JD and other relevant header information DONE\n# 3. Apply light-time correction (if necessary) DONE\n# 4. Calculate trace and 1D+2D wavelength solutions (if necessary)\n# 5. Make flats, apply flat field correction (Stage 2)\n# 6. Manually mask regions DONE\n# 7. Compute difference frames OR slopes (Stage 1)\n# 8. Perform outlier rejection of BG region DONE\n# 9. Background subtraction DONE\n# 10. Compute 2D drift, apply rough (integer-pixel) correction\n# 11. Full-frame outlier rejection for time-series stack of NDRs\n# 12. Apply sub-pixel 2D drift correction\n# 13. Extract spectrum through summation DONE\n# 14. Compute median frame DONE\n# 15. Optimal spectral extraction DONE\n# 16. Save Stage 3 data products\n# 17. Produce plots DONE\n\n\nimport os, time, glob\nimport numpy as np\nfrom astropy.io import fits\nfrom tqdm import tqdm\nfrom . import optspex\nfrom . import plots_s3, source_pos\nfrom . import background as bg\nfrom . import bright2flux as b2f\nfrom ..lib import sort_nicely as sn\nfrom ..lib import logedit\nfrom ..lib import readECF as rd\nfrom ..lib import manageevent as me\nfrom ..lib import astropytable\nfrom ..lib import util\n\n\nclass MetaClass:\n '''A class to hold Eureka! metadata.\n '''\n\n def __init__(self):\n return\n\n\nclass DataClass:\n '''A class to hold Eureka! image data.\n '''\n\n def __init__(self):\n return\n\n\ndef reduceJWST(eventlabel, s2_meta=None):\n '''Reduces data images and calculates optimal spectra.\n\n Parameters\n ----------\n eventlabel: str\n The unique identifier for these data.\n s2_meta: MetaClass\n The metadata object from Eureka!'s S2 step (if running S2 and S3 sequentially).\n\n Returns\n -------\n meta: MetaClass\n The metadata object with attributes added by S3.\n\n Notes\n -------\n History:\n\n - May 2021 Kevin Stevenson\n Initial version\n - October 2021 Taylor Bell\n Updated to allow for inputs from S2\n '''\n\n # Initialize data object\n data = DataClass()\n\n # Initialize a new metadata object\n meta = MetaClass()\n meta.eventlabel = eventlabel\n\n # Load Eureka! control file and store values in Event object\n ecffile = 'S3_' + eventlabel + '.ecf'\n ecf = rd.read_ecf(ecffile)\n rd.store_ecf(meta, ecf)\n meta.eventlabel=eventlabel\n \n # S3 is not being called right after S2 - try to load a metadata in case S2 was previously run\n if s2_meta == None:\n # Search for the S2 output metadata in the inputdir provided in\n rootdir = os.path.join(meta.topdir, *meta.inputdir.split(os.sep))\n if rootdir[-1]!='/':\n rootdir += '/'\n fnames = glob.glob(rootdir+'**/S2_'+meta.eventlabel+'_Meta_Save.dat', recursive=True)\n fnames = sn.sort_nicely(fnames)\n\n if len(fnames)==0:\n # There may be no metafiles in the inputdir - raise an error and give a helpful message\n print('WARNING: Unable to find an output metadata file from Eureka!\\'s S2 step '\n +'in the inputdir: \\n\"{}\"!\\n'.format(meta.inputdir)\n +'Assuming this S2 data was produced by the JWST pipeline instead.')\n else:\n if len(fnames)>1:\n # There may be multiple runs - use the most recent but warn the user\n print('WARNING: There are multiple metadata save files in your inputdir: \\n\"{}\"\\n'.format(meta.inputdir)\n +'Using the metadata file: \\n\"{}\"'.format(fnames[-1]))\n\n fname = fnames[-1] # Pick the last file name\n fname = fname[:-4] # Strip off the .dat ending\n\n s2_meta = me.loadevent(fname)\n\n # Locate the exact output folder from the previous S2 run (since there is a procedurally generated subdirectory for each run)\n if s2_meta != None:\n # Need to remove the topdir from the outputdir\n if os.path.isdir(s2_meta.outputdir):\n s2_outputdir = s2_meta.outputdir[len(s2_meta.topdir):]\n if s2_outputdir[0]=='/':\n s2_outputdir = s2_outputdir[1:]\n\n meta = s2_meta\n\n # Load Eureka! control file and store values in the S2 metadata object\n ecffile = 'S3_' + eventlabel + '.ecf'\n ecf = rd.read_ecf(ecffile)\n rd.store_ecf(meta, ecf)\n\n # Overwrite the inputdir with the exact output directory from S2\n meta.inputdir = s2_outputdir\n else:\n raise AssertionError(\"Unable to find output data files from Eureka!'s S2 step! \"\n + \"Looked in the folder: \\n{}\".format(s2_meta.outputdir))\n\n meta.inputdir_raw = meta.inputdir\n meta.outputdir_raw = meta.outputdir\n\n # check for range of spectral apertures\n if isinstance(meta.spec_hw, list):\n meta.spec_hw_range = range(meta.spec_hw[0], meta.spec_hw[1]+meta.spec_hw[2], meta.spec_hw[2])\n else:\n meta.spec_hw_range = [meta.spec_hw]\n\n #check for range of background apertures\n if isinstance(meta.bg_hw, list):\n meta.bg_hw_range = range(meta.bg_hw[0], meta.bg_hw[1]+meta.spec_hw[2], meta.bg_hw[2])\n else:\n meta.bg_hw_range = [meta.bg_hw]\n\n # create directories to store data\n meta.runs = [] # Used to make sure we're always looking at the right run for each aperture/annulus pair\n for spec_hw_val in meta.spec_hw_range:\n\n for bg_hw_val in meta.bg_hw_range:\n\n meta.eventlabel = eventlabel\n\n meta.runs.append(util.makedirectory(meta, 'S3', ap=spec_hw_val, bg=bg_hw_val))\n\n # begin process\n run_i = 0\n for spec_hw_val in meta.spec_hw_range:\n\n for bg_hw_val in meta.bg_hw_range:\n\n t0 = time.time()\n\n meta.spec_hw = spec_hw_val\n\n meta.bg_hw = bg_hw_val\n\n meta.outputdir = util.pathdirectory(meta, 'S3', meta.runs[run_i], ap=spec_hw_val, bg=bg_hw_val)\n run_i += 1\n\n event_ap_bg = meta.eventlabel + \"_ap\" + str(spec_hw_val) + '_bg' + str(bg_hw_val)\n\n # Open new log file\n meta.logname = meta.outputdir + 'S3_' + event_ap_bg + \".log\"\n log = logedit.Logedit(meta.logname)\n log.writelog(\"\\nStarting Stage 3 Reduction\\n\")\n log.writelog(f\"Input directory: {meta.inputdir}\")\n log.writelog(f\"Output directory: {meta.outputdir}\")\n log.writelog(\"Using ap=\" + str(spec_hw_val) + \", bg=\" + str(bg_hw_val))\n\n # Copy ecf (and update inputdir in case S3 is being called sequentially with S2)\n log.writelog('Copying S3 control file')\n new_ecfname = meta.outputdir + ecffile.split('/')[-1]\n with open(new_ecfname, 'w') as new_file:\n with open(ecffile, 'r') as file:\n for line in file.readlines():\n if len(line.strip())==0 or line.strip()[0]=='#':\n new_file.write(line)\n else:\n line_segs = line.strip().split()\n if line_segs[0]=='inputdir':\n new_file.write(line_segs[0]+'\\t\\t/'+meta.inputdir+'\\t'+' '.join(line_segs[2:])+'\\n')\n else:\n new_file.write(line)\n\n # Create list of file segments\n meta = util.readfiles(meta)\n num_data_files = len(meta.segment_list)\n if num_data_files==0:\n rootdir = os.path.join(meta.topdir, *meta.inputdir.split(os.sep))\n if rootdir[-1]!='/':\n rootdir += '/'\n raise AssertionError(f'Unable to find any \"{meta.suffix}.fits\" files in the inputdir: \\n\"{rootdir}\"!')\n else:\n log.writelog(f'\\nFound {num_data_files} data file(s) ending in {meta.suffix}.fits')\n\n with fits.open(meta.segment_list[-1]) as hdulist:\n # Figure out which instrument we are using\n meta.inst = hdulist[0].header['INSTRUME'].lower()\n # Load instrument module\n if meta.inst == 'miri':\n from . import miri as inst\n elif meta.inst == 'nircam':\n from . import nircam as inst\n elif meta.inst == 'nirspec':\n from . import nirspec as inst\n elif meta.inst == 'niriss':\n raise ValueError('NIRISS observations are currently unsupported!')\n else:\n raise ValueError('Unknown instrument {}'.format(meta.inst))\n\n stdspec = np.array([])\n # Loop over each segment\n # Only reduce the last segment/file if testing_S3 is set to True in ecf\n if meta.testing_S3:\n istart = num_data_files - 1\n else:\n istart = 0\n for m in range(istart, num_data_files):\n # Keep track if this is the first file - otherwise MIRI will keep swapping x and y windows\n if m==istart:\n meta.firstFile = True\n else:\n meta.firstFile = False\n # Report progress\n log.writelog(f'Reading file {m + 1} of {num_data_files}')\n # Read in data frame and header\n data, meta = inst.read(meta.segment_list[m], data, meta)\n # Get number of integrations and frame dimensions\n meta.n_int, meta.ny, meta.nx = data.data.shape\n if meta.testing_S3:\n # Only process the last 5 integrations when testing\n meta.int_start = np.max((0,meta.n_int-5))\n else:\n meta.int_start = 0\n # Locate source postion\n meta.src_ypos = source_pos.source_pos(data, meta, m, header=('SRCYPOS' in data.shdr))\n log.writelog(f' Source position on detector is row {meta.src_ypos}.')\n # Trim data to subarray region of interest\n data, meta = util.trim(data, meta)\n # Create bad pixel mask (1 = good, 0 = bad)\n # FINDME: Will want to use DQ array in the future to flag certain pixels\n data.submask = np.ones(data.subdata.shape)\n\n # Convert flux units to electrons (eg. MJy/sr -> DN -> Electrons)\n data, meta = b2f.convert_to_e(data, meta, log)\n\n # Check if arrays have NaNs\n data.submask = util.check_nans(data.subdata, data.submask, log, name='SUBDATA')\n data.submask = util.check_nans(data.suberr, data.submask, log, name='SUBERR')\n data.submask = util.check_nans(data.subv0, data.submask, log, name='SUBV0')\n\n # Manually mask regions [colstart, colend, rowstart, rowend]\n if hasattr(meta, 'manmask'):\n log.writelog(\" Masking manually identified bad pixels\")\n for i in range(len(meta.manmask)):\n ind, colstart, colend, rowstart, rowend = meta.manmask[i]\n data.submask[rowstart:rowend, colstart:colend] = 0\n\n # Perform outlier rejection of sky background along time axis\n log.writelog(' Performing background outlier rejection')\n meta.bg_y2 = int(meta.src_ypos + bg_hw_val)\n meta.bg_y1 = int(meta.src_ypos - bg_hw_val)\n data = inst.flag_bg(data, meta)\n\n data = bg.BGsubtraction(data, meta, log, meta.isplots_S3)\n\n # Calulate drift2D\n # print(\"Calculating 2D drift...\")\n\n # print(\"Performing rough, pixel-scale drift correction...\")\n\n # Outlier rejection of full frame along time axis\n # print(\"Performing full-frame outlier rejection...\")\n\n if meta.isplots_S3 >= 3:\n log.writelog(' Creating figures for background subtraction')\n for n in tqdm(range(meta.int_start,meta.n_int)):\n # make image+background plots\n plots_s3.image_and_background(data, meta, n)\n\n # print(\"Performing sub-pixel drift correction...\")\n\n # Select only aperture region\n ap_y1 = int(meta.src_ypos - spec_hw_val)\n ap_y2 = int(meta.src_ypos + spec_hw_val)\n data.apdata = data.subdata[:, ap_y1:ap_y2]\n data.aperr = data.suberr[:, ap_y1:ap_y2]\n data.apmask = data.submask[:, ap_y1:ap_y2]\n data.apbg = data.subbg[:, ap_y1:ap_y2]\n data.apv0 = data.subv0[:, ap_y1:ap_y2]\n # Extract standard spectrum and its variance\n data.stdspec = np.sum(data.apdata, axis=1)\n data.stdvar = np.sum(data.aperr ** 2, axis=1) # FINDME: stdvar >> stdspec, which is a problem\n # Compute fraction of masked pixels within regular spectral extraction window\n # numpixels = 2.*meta.spec_width*subnx\n # fracMaskReg = (numpixels - np.sum(apmask,axis=(2,3)))/numpixels\n\n # Compute median frame\n data.medsubdata = np.median(data.subdata, axis=0)\n data.medapdata = np.median(data.apdata, axis=0)\n\n # Extract optimal spectrum with uncertainties\n log.writelog(\" Performing optimal spectral extraction\")\n data.optspec = np.zeros(data.stdspec.shape)\n data.opterr = np.zeros(data.stdspec.shape)\n gain = 1 # Already converted DN to electrons, so gain = 1 for optspex\n for n in tqdm(range(meta.int_start,meta.n_int)):\n data.optspec[n], data.opterr[n], mask = optspex.optimize(data.apdata[n], data.apmask[n], data.apbg[n],\n data.stdspec[n], gain, data.apv0[n],\n p5thresh=meta.p5thresh, p7thresh=meta.p7thresh,\n fittype=meta.fittype, window_len=meta.window_len,\n deg=meta.prof_deg, n=data.intstart + n,\n isplots=meta.isplots_S3, eventdir=meta.outputdir,\n meddata=data.medapdata, hide_plots=meta.hide_plots)\n\n # Plot results\n if meta.isplots_S3 >= 3:\n log.writelog(' Creating figures for optimal spectral extraction')\n for n in tqdm(range(meta.int_start,meta.n_int)):\n # make optimal spectrum plot\n plots_s3.optimal_spectrum(data, meta, n)\n\n # Append results\n if len(stdspec) == 0:\n wave_2d = data.subwave\n wave_1d = data.subwave[meta.src_ypos]\n stdspec = data.stdspec\n stdvar = data.stdvar\n optspec = data.optspec\n opterr = data.opterr\n bjdtdb = data.bjdtdb\n else:\n stdspec = np.append(stdspec, data.stdspec, axis=0)\n stdvar = np.append(stdvar, data.stdvar, axis=0)\n optspec = np.append(optspec, data.optspec, axis=0)\n opterr = np.append(opterr, data.opterr, axis=0)\n bjdtdb = np.append(bjdtdb, data.bjdtdb, axis=0)\n\n # Calculate total time\n total = (time.time() - t0) / 60.\n log.writelog('\\nTotal time (min): ' + str(np.round(total, 2)))\n\n if meta.testing_S3 == False:\n log.writelog('Saving results as astropy table')\n meta.tab_filename = meta.outputdir + 'S3_' + event_ap_bg + \"_Table_Save.txt\"\n astropytable.savetable_S3(meta.tab_filename, bjdtdb, wave_1d, stdspec, stdvar, optspec, opterr)\n\n if meta.isplots_S3 >= 1:\n log.writelog('Generating figure')\n # 2D light curve without drift correction\n plots_s3.lc_nodriftcorr(meta, wave_1d, optspec)\n\n # Save results\n if meta.testing_S3 == False:\n log.writelog('Saving Metadata')\n me.saveevent(meta, meta.outputdir + 'S3_' + event_ap_bg + \"_Meta_Save\", save=[])\n\n log.closelog()\n\n return meta\n", "meta": {"hexsha": "b971415f54fe2aa56d79034d9abc4995f9208026", "size": 16732, "ext": "py", "lang": "Python", "max_stars_repo_path": "eureka/S3_data_reduction/s3_reduce.py", "max_stars_repo_name": "evamariaa/Eureka", "max_stars_repo_head_hexsha": "a3e739a528fbe85ec588bca996188765649b7778", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 15, "max_stars_repo_stars_event_min_datetime": "2020-08-07T12:12:17.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T10:20:38.000Z", "max_issues_repo_path": "eureka/S3_data_reduction/s3_reduce.py", "max_issues_repo_name": "evamariaa/Eureka", "max_issues_repo_head_hexsha": "a3e739a528fbe85ec588bca996188765649b7778", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 159, "max_issues_repo_issues_event_min_datetime": "2020-08-05T14:34:59.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T21:02:10.000Z", "max_forks_repo_path": "eureka/S3_data_reduction/s3_reduce.py", "max_forks_repo_name": "evamariaa/Eureka", "max_forks_repo_head_hexsha": "a3e739a528fbe85ec588bca996188765649b7778", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 17, "max_forks_repo_forks_event_min_datetime": "2021-06-16T09:40:41.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-22T18:28:07.000Z", "avg_line_length": 43.6866840731, "max_line_length": 129, "alphanum_fraction": 0.5622161128, "include": true, "reason": "import numpy,import astropy,from astropy", "num_tokens": 3892, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5195213219520929, "lm_q2_score": 0.3702253925955866, "lm_q1q2_score": 0.19233998538149175}} {"text": "\"\"\"The Mine class.\"\"\"\n\n__docformat__ = \"reStructuredText\"\n\nfrom functools import reduce\nfrom typing import List, Dict, Optional, Union, Callable, Tuple\nfrom abc import ABC, abstractmethod\nfrom collections import defaultdict\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport networkx as nx\nfrom prettytable import PrettyTable\nfrom qiskit.opflow import PauliOp, I, Z, Plus, MatrixOp\nfrom qiskit.algorithms import (\n MinimumEigensolver,\n AlgorithmResult,\n NumPyMinimumEigensolver,\n)\n\nfrom ..algorithms import Pseudoflow, PEPSITE\nfrom ..benchmark import Benchmark\nfrom ..utils import null_operator, z_projector, single_qubit_pauli, int_to_bitstr\n\n\nclass BaseMine(ABC):\n \"\"\"\n Abstract Mine class\n \"\"\"\n\n def __init__(self) -> None:\n pass\n\n @abstractmethod\n def solve(self) -> \"MiningProblemResult\":\n raise NotImplementedError()\n\n\nclass Mine(BaseMine):\n \"\"\"This class stores the mine configurations.\"\"\"\n\n def __init__(self, mine_config: Union[str, np.ndarray]) -> None:\n \"\"\"Initialize the Mine class.\n\n Parameters\n ----------\n mine_config : str\n Path to the mine configuration file.\n\n Raises\n ------\n IOError\n Invalid path to the mine configuration file.\n\n \"\"\"\n if isinstance(mine_config, str):\n try:\n self.dat = np.loadtxt(mine_config, dtype=float)\n except:\n raise IOError(\"Invalid Mine Configuration File\")\n elif isinstance(mine_config, np.ndarray):\n if len(mine_config.shape) != 2:\n raise ValueError(\"`mine_config` must be two-demensional\")\n self.dat = np.array(mine_config, dtype=float)\n else:\n raise ValueError(\"Unrecognized `mine_config` type\")\n\n self.rows, self.cols = self.dat.shape\n self.graph = defaultdict(list) # p:c\n self.graph_r = defaultdict(list) # c:p\n self.idx2cord = []\n self.cord2idx = {}\n self._init_mapping()\n self.nqubits: int = len(self.idx2cord)\n self.valid_configs = None\n self._Hs = None\n self._Hp = None\n\n @property\n def Hs(self) -> float:\n if self._Hs is None:\n self._Hs = self.gen_Hs()\n return self._Hs\n\n @property\n def Hp(self) -> float:\n if self._Hp is None:\n self._Hp = self.gen_Hp()\n return self._Hp\n\n @staticmethod\n def gen_random_mine(\n size: Tuple[int, int], distribution: Optional[str] = \"normal\", seed: Optional[int] = None, **kwargs\n ) -> \"Mine\":\n distribution = distribution.lower()\n rng = np.random.default_rng(seed)\n if distribution == \"gaussian\" or distribution == \"normal\":\n return Mine(rng.normal(size=size, **kwargs))\n if distribution == \"uniform\":\n return Mine(rng.uniform(size=size, **kwargs))\n raise ValueError(\"Distribution not supported.\")\n\n def _init_mapping(self) -> None:\n \"\"\"Assign a unique id to each valid node and store the graph structure with ``self.graph``.\"\"\"\n for r in range(self.rows):\n for c in range(self.cols):\n if c < r or c > self.cols - r - 1:\n self.dat[r, c] = float(\"inf\")\n if self.dat[r, c] < float(\"inf\"):\n self.idx2cord.append((r, c))\n self.cord2idx[(r, c)] = len(self.idx2cord) - 1\n idx = self.cord2idx[(r, c)]\n for pr, pc in [(r - 1, c - 1), (r - 1, c), (r - 1, c + 1)]:\n if (\n 0 <= pr < self.rows\n and 0 <= pc < self.cols\n and self.dat[pr, pc] < float(\"inf\")\n ):\n self.graph[idx].append(self.cord2idx[(pr, pc)])\n self.graph_r[self.cord2idx[(pr, pc)]].append(idx)\n\n def plot_mine(self) -> None:\n \"\"\"Plot the mine configuration.\"\"\"\n x = PrettyTable([\" \"] + [str(ic) for ic in range(self.cols)])\n for ir in range(self.rows):\n x.add_row([ir] + [\"%.3f\" % self.dat[ir, ic] for ic in range(self.cols)])\n print(str(x))\n\n def plot_mine_graph(\n self, color: str = \"r\", pos_func: Callable = nx.spring_layout\n ) -> None:\n \"\"\"Plot a graph representing the mine configuration.\n\n Parameters\n ----------\n color : str\n Color of the nodes.\n pos_func : Callable\n A Callable that returns positions of nodes.\n\n \"\"\"\n G = nx.Graph()\n G.add_nodes_from(np.arange(self.nqubits))\n elist = [[i, j] for i, jl in self.graph.items() for j in jl]\n # tuple is (i,j,weight) where (i,j) is the edge\n G.add_edges_from(elist)\n\n colors = [color for node in G.nodes()]\n pos = pos_func(G)\n\n default_axes = plt.axes(frameon=True)\n nx.draw_networkx(\n G, node_color=colors, node_size=600, alpha=0.8, ax=default_axes, pos=pos\n )\n\n def gen_Hs(self) -> PauliOp:\n \"\"\"Generate the smoothess Hamiltonian\n :math:`H_{s}=\\sum_{i}\\sum_{j:Parent(i)} (1-Z_{i})/2*(1+Z_{j})/2`\n\n Returns\n ----------\n qiskit.opflow.PauliOp\n Smoothness Hamiltonian.\n\n \"\"\"\n Hs = 0 * I ^ self.nqubits\n for i in range(self.nqubits):\n for j in self.graph[i]:\n Hs += (\n (I ^ self.nqubits) - ((I ^ self.nqubits - i - 1) ^ Z ^ (I ^ i))\n ) @ ((I ^ self.nqubits) + ((I ^ self.nqubits - j - 1) ^ Z ^ (I ^ j)))\n return 0.25 * Hs\n\n def gen_Hp(self) -> PauliOp:\n \"\"\"Generate the profit Hamiltonian\n :math:`H_{p}=\\sum_{i}w(i)(1-Z_{i})/2`\n\n Returns\n ----------\n qiskit.opflow.PauliOp\n Profit Hamiltonian.\n\n \"\"\"\n Hp = 0 * I ^ self.nqubits\n for i in range(self.nqubits):\n # Qiskit opflow doesn't support multiplying types other than python built-in ones (e.g. np.float64)\n Hp += float(self.dat[self.idx2cord[i]]) * (\n (I ^ self.nqubits) - ((I ^ self.nqubits - i - 1) ^ Z ^ (I ^ i))\n )\n return 0.5 * Hp\n\n def gen_Hamiltonian(self, penalty: Union[float, bool, None]) -> PauliOp:\n \"\"\"Generate the Hamiltonian with penalty weight :math:`\\gamma`.\n\n :math:`H=-H_{p}+\\gamma H_{s}`\n\n Parameter s\n ----------\n penalty : float\n Penalty for the smoothness term in the Hamiltonian.\n\n Returns\n ----------\n qiskit.opflow.PauliOp\n Hamiltonian with penalty weight :math:`\\gamma`.\n\n \"\"\"\n if penalty is True:\n penalty = self.heuristic_penalty()\n if penalty:\n return (-self.Hp + penalty * self.Hs).reduce()\n return self.gen_projected_Hamiltonian()\n\n def gen_projected_Hamiltonian(self) -> PauliOp:\n \"\"\"Generate the profit Hamiltonian projected onto valid states.\n\n Returns\n ----------\n qiskit.opflow.PauliOp\n :math:`H=-PH_{p}P`\n\n \"\"\"\n state_fn = (-self.Hs @ (Plus ^ self.nqubits)).reduce().eval().to_dict_fn()\n self.valid_configs = [\n int(k, 2) for k, v in state_fn.primitive.items() if abs(v) < 1e-8\n ]\n p_op = np.zeros((2 ** self.nqubits))\n p_op[np.array(self.valid_configs, dtype=int)] = 1\n p_op = MatrixOp(np.diag(p_op))\n\n return (p_op @ -self.Hp @ p_op).reduce().to_matrix_op()\n\n def gen_pseudoflow_graph(self, MAX_FLOW: int) -> Tuple[nx.DiGraph, int, int]:\n G = nx.DiGraph()\n G.add_nodes_from(np.arange(self.nqubits))\n source = -1\n sink = self.nqubits\n\n for p in self.graph:\n for c in self.graph[p]:\n G.add_edge(p, c, const=MAX_FLOW)\n\n if self.dat[self.idx2cord[p]] >= 0:\n G.add_edge(source, p, const=self.dat[self.idx2cord[p]])\n else:\n G.add_edge(p, sink, const=-self.dat[self.idx2cord[p]])\n\n return G, source, sink\n\n def plot_mine_state(\n self, bitstring: str, bit_ordering: Optional[str] = \"R\"\n ) -> None:\n \"\"\"Plot the mining state represented by the bitstring.\n\n Parameters\n ----------\n bitstring : str\n A 0/1 string represents the state. Length of the string is the same as the number of qubits.\n bit_ordering : str\n Available options ``[\\'L\\', \\'R\\']``. ``\\'L\\'`` means the least significant bit (LSB) is on the left, and ``\\'R\\'`` means LSB is on the right. LSB represents the qubit with index 0.\n \"\"\"\n assert (\n len(bitstring) == self.nqubits\n ), \"Length of the bitstring should be the same as the number of qubits.\"\n assert bit_ordering in [\"L\", \"R\"], \"bit_ordering options: 'L', 'R'.\"\n if bit_ordering == \"R\":\n bitstring = \"\".join(list(bitstring)[::-1])\n\n x = PrettyTable([\" \"] + [str(ic) for ic in range(self.cols)])\n for ir in range(self.rows):\n x.add_row(\n [ir]\n + [\n bitstring[self.cord2idx[(ir, ic)]]\n if (ir, ic) in self.cord2idx\n else \"x\"\n for ic in range(self.cols)\n ]\n )\n print(str(x))\n\n def get_profit(self, bitstring: str, bit_ordering: Optional[str] = \"R\") -> int:\n \"\"\"Return profit for a vector state.\n\n Parameters\n ----------\n bitstring : str\n A 0/1 string represents the state. Length of the string is the same as the number of qubits.\n bit_ordering : str\n Available options ``[\\'L\\', \\'R\\']``. ``\\'L\\'`` means the least significant bit (LSB) is on the left, and ``\\'R\\'`` means LSB is on the right. LSB represents the qubit with index 0.\n \"\"\"\n assert (\n len(bitstring) == self.nqubits\n ), \"Length of the bitstring should be the same as the number of qubits.\"\n assert bit_ordering in [\"L\", \"R\"], \"bit_ordering options: 'L', 'R'.\"\n if bit_ordering == \"R\":\n bitstring = \"\".join(list(bitstring)[::-1])\n\n return sum(\n [\n self.dat[self.idx2cord[i]]\n for i in range(self.nqubits)\n if bitstring[i] == \"1\"\n ]\n )\n\n def get_violation(self, bitstring: str, bit_ordering: Optional[str] = \"R\") -> int:\n \"\"\"Return violation for a vector state.\n\n Parameters\n ----------\n bitstring : str\n A 0/1 string represents the state. Length of the string is the same as the number of qubits.\n bit_ordering : str\n Available options ``[\\'L\\', \\'R\\']``. ``\\'L\\'`` means the least significant bit (LSB) is on the left, and ``\\'R\\'`` means LSB is on the right. LSB represents the qubit with index 0.\n \"\"\"\n assert (\n len(bitstring) == self.nqubits\n ), \"Length of the bitstring should be the same as the number of qubits.\"\n assert bit_ordering in [\"L\", \"R\"], \"bit_ordering options: 'L', 'R'.\"\n if bit_ordering == \"R\":\n bitstring = \"\".join(list(bitstring)[::-1])\n\n dig = list(map(lambda x: -1 if x == \"1\" else 1, list(bitstring)))\n res = 0\n for i in range(self.nqubits):\n for j in self.graph[i]:\n res += 0.25 * (1.0 - dig[i]) * (1.0 + dig[j])\n return int(res)\n\n def heuristic_penalty(self, coeff: float = 3.8) -> float:\n return (\n float(\n np.linalg.norm(np.where(self.dat.flat != np.inf), ord=2) / self.nqubits\n )\n * coeff\n )\n\n def solve(\n self,\n algorithm: Union[MinimumEigensolver, Pseudoflow],\n penalty: Union[float, bool, None] = None,\n benchmark: Union[Benchmark, bool, None] = None,\n ) -> \"MiningProblemResult\":\n if benchmark is True:\n benchmark = Benchmark()\n elif benchmark is False or benchmark is None:\n benchmark = Benchmark(activate=False)\n\n with benchmark:\n self._ret = MiningProblemResult()\n\n if isinstance(algorithm, MinimumEigensolver):\n res = algorithm.compute_minimum_eigenvalue(\n self.gen_Hamiltonian(penalty), [self.Hp, self.Hs]\n )\n\n if isinstance(algorithm, NumPyMinimumEigensolver):\n self._ret.optimal_config = format(\n np.argwhere(res.eigenstate.primitive.data.real == 1.0).item(),\n f\"0{self.nqubits + 2}b\",\n )[2:]\n self._ret.optimal_config_prob = 1.0\n\n else:\n if isinstance(res.eigenstate, dict):\n self._ret.optimal_config, self._ret.optimal_config_prob = max(\n (\n item\n for item in res.eigenstate.items()\n if self.valid_configs is None\n or int(item[0], 2) in self.valid_configs\n ),\n key=lambda item: item[1],\n )\n elif isinstance(res.eigenstate, np.ndarray):\n idx = np.argmax(res.eigenstate * res.eigenstate.conj())\n self._ret.optimal_config = int_to_bitstr(idx, self.nqubits)\n self._ret.optimal_config_prob = res.eigenstate[idx]\n\n if isinstance(self._ret.optimal_config_prob, complex):\n self._ret.optimal_config_prob = (\n self._ret.optimal_config_prob.real ** 2\n - self._ret.optimal_config_prob.imag ** 2\n )\n else:\n self._ret.optimal_config_prob **= 2\n\n self._ret.ground_state = res.eigenstate\n if (\n res.aux_operator_eigenvalues is not None\n ): # Remove after implemented ASP expectation value\n (\n self._ret._expected_profit,\n self._ret._expected_violation,\n ) = res.aux_operator_eigenvalues\n\n elif isinstance(algorithm, Pseudoflow):\n self._ret.optimal_config = algorithm.run(\n *self.gen_pseudoflow_graph(algorithm.MAX_FLOW)\n )\n self._ret.optimal_config_prob = 1.0\n\n elif isinstance(algorithm, PEPSITE):\n self._ret.optimal_config = algorithm.run(self)\n self._ret.optimal_config_prob = 1.0\n \n else:\n raise ValueError(f\"{type(algorithm)} is not a valid algorithm.\")\n\n print(\n \"The most probable configuration and the corresponding probability:\"\n f\" {self._ret.optimal_config, self._ret.optimal_config_prob}\"\n )\n self.plot_mine_state(self._ret.optimal_config)\n return self._ret\n\n\nclass SubMine(BaseMine):\n def __init__(self, mine: Mine, node_list: List) -> None:\n self.node_list = node_list\n self.nqubits = len(self.node_list)\n self.node_c = {} # key: a node in this frag, value: child node in another frag\n self.node_p = {} # key: a node in this frag, value: parent node in another frag\n self.node_bd = [] # submine idx of bd nodes\n self.zb = [] # pauli z op of bd nodes\n\n self._init_nodes(mine)\n self.Hp = self.gen_Hp(mine) # profit\n self.Hs = self.gen_Hs(mine) # smoothness, inner nodes\n self.Hb = null_operator(self.nqubits) # boundary\n\n def _init_nodes(self, mine: Mine) -> None:\n for idx, i in enumerate(self.node_list):\n self.node_c[i] = [j for j in mine.graph[i] if j not in self.node_list]\n self.node_p[i] = [j for j in mine.graph_r[i] if j not in self.node_list]\n if len(self.node_c[i]) + len(self.node_p[i]) > 0:\n self.node_bd.append(idx)\n self.zb.append(single_qubit_pauli(\"z\", idx, self.nqubits))\n\n def gen_Hs(self, mine: Mine) -> PauliOp:\n Hs = null_operator(self.nqubits)\n for sub_i, i in enumerate(self.node_list):\n for j in mine.graph[i]:\n try:\n sub_j = self.node_list.index(j)\n Hs += z_projector(1, sub_i, self.nqubits) @ z_projector(\n 0, sub_j, self.nqubits\n )\n except:\n continue\n return Hs\n\n def gen_Hp(self, mine: Mine) -> PauliOp:\n Hp = null_operator(self.nqubits)\n for sub_idx, idx in enumerate(self.node_list):\n Hp += float(mine.dat[mine.idx2cord[idx]]) * z_projector(\n 1, sub_idx, self.nqubits\n )\n return Hp\n\n def _update_Hb(self, z_val: Dict) -> None:\n self.Hb = null_operator(self.nqubits)\n for sub_idx in self.node_bd:\n mine_idx = self.node_list[sub_idx]\n for j in self.node_c[mine_idx]:\n self.Hb += float(0.5 * (1 + z_val[j])) * z_projector(\n 1, sub_idx, self.nqubits\n )\n for j in self.node_p[mine_idx]:\n self.Hb += float(0.5 * (1 - z_val[j])) * z_projector(\n 0, sub_idx, self.nqubits\n )\n\n def gen_Hamiltonian(self, penalty: float, z_val: Dict) -> PauliOp:\n self._update_Hb(z_val)\n H_res = -self.Hp + penalty * (self.Hs + self.Hb)\n return H_res\n\n def solve(\n self, algorithm: MinimumEigensolver, penalty: Union[float, None], z_val: Dict\n ) -> \"MiningProblemResult\":\n if isinstance(algorithm, MinimumEigensolver):\n res = algorithm.compute_minimum_eigenvalue(\n self.gen_Hamiltonian(penalty, z_val), self.zb + [self.Hp, self.Hs]\n )\n self._ret = MiningProblemResult()\n self._ret.optimal_config, self._ret.optimal_config_prob = max(\n res.eigenstate.items(), key=lambda item: item[1]\n )\n # self._ret.ground_state = res.eigenstate\n for sub_idx, zi in zip(self.node_bd, res.aux_operator_eigenvalues[:-2]):\n z_val[self.node_list[sub_idx]] = zi\n self._ret.expected_profit = res.aux_operator_eigenvalues[-2]\n self._ret.expected_violation = res.aux_operator_eigenvalues[-1]\n return self._ret\n else:\n raise ValueError()\n\n\nclass SubMine(BaseMine):\n def __init__(self, mine: Mine, node_list: List) -> None:\n super.__init__()\n self.node_list = node_list\n self.nqubits = len(self.node_list)\n self.node_c = {} # key: a node in this frag, value: child node in another frag\n self.node_p = {} # key: a node in this frag, value: parent node in another frag\n self.node_bd = [] # submine idx of bd nodes\n self.zb = [] # pauli z op of bd nodes\n\n self._init_nodes(mine)\n self.Hp = self.gen_Hp(mine) # profit\n self.Hs = self.gen_Hs(mine) # smoothness, inner nodes\n self.Hb = null_operator(self.nqubits) # boundary\n\n def _init_nodes(self, mine: Mine) -> None:\n for idx, i in enumerate(self.node_list):\n self.node_c[i] = [j for j in mine.graph[i] if j not in self.node_list]\n self.node_p[i] = [j for j in mine.graph_r[i] if j not in self.node_list]\n if len(self.node_c[i]) + len(self.node_p[i]) > 0:\n self.node_bd.append(idx)\n self.zb.append(single_qubit_pauli(\"z\", idx, self.nqubits))\n\n def gen_Hs(self, mine: Mine) -> PauliOp:\n Hs = null_operator(self.nqubits)\n for sub_i, i in enumerate(self.node_list):\n for j in mine.graph[i]:\n try:\n sub_j = self.node_list.index(j)\n Hs += z_projector(1, sub_i, self.nqubits) @ z_projector(\n 0, sub_j, self.nqubits\n )\n except:\n continue\n return Hs\n\n def gen_Hp(self, mine: Mine) -> PauliOp:\n Hp = null_operator(self.nqubits)\n for sub_idx, idx in enumerate(self.node_list):\n Hp += float(mine.dat[mine.idx2cord[idx]]) * z_projector(\n 1, sub_idx, self.nqubits\n )\n return Hp\n\n def _update_Hb(self, z_val: Dict) -> None:\n self.Hb = null_operator(self.nqubits)\n for sub_idx in self.node_bd:\n mine_idx = self.node_list[sub_idx]\n for j in self.node_c[mine_idx]:\n self.Hb += float(0.5 * (1 + z_val[j])) * z_projector(\n 1, sub_idx, self.nqubits\n )\n for j in self.node_p[mine_idx]:\n self.Hb += float(0.5 * (1 - z_val[j])) * z_projector(\n 0, sub_idx, self.nqubits\n )\n\n def gen_Hamiltonian(self, penalty: float, z_val: Dict) -> PauliOp:\n self._update_Hb(z_val)\n H_res = -self.Hp + penalty * (self.Hs + self.Hb)\n return H_res\n\n def solve(\n self, algorithm: MinimumEigensolver, penalty: Union[float, None], z_val: Dict\n ) -> \"MiningProblemResult\":\n if isinstance(algorithm, MinimumEigensolver):\n res = algorithm.compute_minimum_eigenvalue(\n self.gen_Hamiltonian(penalty, z_val), self.zb + [self.Hp, self.Hs]\n )\n self._ret = MiningProblemResult()\n self._ret.optimal_config, self._ret.optimal_config_prob = max(\n res.eigenstate.items(), key=lambda item: item[1]\n )\n # self._ret.ground_state = res.eigenstate\n for sub_idx, zi in zip(self.node_bd, res.aux_operator_eigenvalues[:-2]):\n z_val[self.node_list[sub_idx]] = zi\n self._ret.expected_profit = res.aux_operator_eigenvalues[-2]\n self._ret.expected_violation = res.aux_operator_eigenvalues[-1]\n return self._ret\n else:\n raise ValueError()\n\n\nclass MiningProblemResult(AlgorithmResult):\n def __init__(self) -> None:\n super().__init__()\n self._optimal_config = None\n self._optimal_config_prob = None\n self._ground_state = None\n self._expected_profit = None\n self._expected_violation = None\n\n @property\n def optimal_config(self) -> Optional[str]:\n return self._optimal_config\n\n @optimal_config.setter\n def optimal_config(self, optimal_config: str) -> None:\n self._optimal_config = optimal_config\n\n @property\n def optimal_config_prob(self) -> Optional[float]:\n return self._optimal_config_prob\n\n @optimal_config_prob.setter\n def optimal_config_prob(self, optimal_config_prob: float) -> None:\n self._optimal_config_prob = optimal_config_prob\n\n @property\n def ground_state(self) -> Optional[np.ndarray]:\n return self._ground_state\n\n @ground_state.setter\n def ground_state(self, ground_state: np.ndarray) -> None:\n self._ground_state = ground_state\n\n @property\n def expected_profit(self) -> Optional[float]:\n return self._expected_profit\n\n @expected_profit.setter\n def expected_profit(self, expected_profit: float) -> None:\n self._expected_profit = expected_profit\n\n @property\n def expected_violation(self) -> Optional[float]:\n return self._expected_violation\n\n @expected_violation.setter\n def expected_violation(self, expected_violation: float) -> None:\n self._expected_violation = expected_violation\n", "meta": {"hexsha": "e4637f9cc14f460a2a4899e57a788eed1d34a349", "size": 23744, "ext": "py", "lang": "Python", "max_stars_repo_path": "qore/model/mine.py", "max_stars_repo_name": "HaoTy/qore", "max_stars_repo_head_hexsha": "2d866615bb05c5b8a5d6f6c7a2c1ca1008e7851b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "qore/model/mine.py", "max_issues_repo_name": "HaoTy/qore", "max_issues_repo_head_hexsha": "2d866615bb05c5b8a5d6f6c7a2c1ca1008e7851b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "qore/model/mine.py", "max_forks_repo_name": "HaoTy/qore", "max_forks_repo_head_hexsha": "2d866615bb05c5b8a5d6f6c7a2c1ca1008e7851b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.5696202532, "max_line_length": 193, "alphanum_fraction": 0.5496546496, "include": true, "reason": "import numpy,import networkx", "num_tokens": 5802, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5195213219520929, "lm_q2_score": 0.3702253786982541, "lm_q1q2_score": 0.1923399781615312}} {"text": "\"\"\"\npretrain using qt, to get neural representation, then run kmeans on various\ncombinations of the resulting representations\n\nthis was forked initially from train.py, then modified\n\"\"\"\nimport argparse\nimport datetime\nimport copy\nimport time\nimport numpy as np\nimport sklearn.cluster\nimport warnings\nimport torch\nfrom torch import autograd\n\nfrom proc_data import Dataset\nfrom model.multiview_encoders import MultiviewEncoders\nfrom metrics import cluster_metrics\nimport pretrain\n\n\nwarnings.filterwarnings(action='ignore', category=RuntimeWarning)\n\ntorch.manual_seed(0)\nnp.random.seed(0)\n\nLSTM_LAYER = 1\nLSTM_HIDDEN = 300\nWORD_DROPOUT_RATE = 0.\nDROPOUT_RATE = 0.\nBATCH_SIZE = 32\nLEARNING_RATE = 0.001\n\ndevice = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n\n\ndef transform(data, model):\n model.eval()\n latent_zs = []\n n_batch = (len(data) + BATCH_SIZE - 1) // BATCH_SIZE\n for i in range(n_batch):\n data_batch = data[i*BATCH_SIZE:(i+1)*BATCH_SIZE]\n with autograd.no_grad():\n latent_z = model(data_batch, encoder='v1')\n latent_zs.append(latent_z.cpu().data.numpy())\n latent_zs = np.concatenate(latent_zs)\n return latent_zs\n\n\ndef calc_prec_rec_f1_acc(preds, golds):\n lgolds, lpreds = [], []\n for g, p in zip(golds, list(preds)):\n if g > 0:\n lgolds.append(g)\n lpreds.append(p)\n prec, rec, f1 = cluster_metrics.calc_prec_rec_f1(\n gnd_assignments=torch.LongTensor(lgolds).to(device),\n pred_assignments=torch.LongTensor(lpreds).to(device))\n acc = cluster_metrics.calc_ACC(\n torch.LongTensor(lpreds).to(device), torch.LongTensor(lgolds).to(device))\n return prec, rec, f1, acc\n\n\ndef main():\n parser = argparse.ArgumentParser()\n parser.add_argument('--data-path', type=str, default='./data/airlines_processed.csv')\n parser.add_argument('--glove-path', type=str, default='./data/glove.840B.300d.txt')\n parser.add_argument('--pre-epoch', type=int, default=5)\n parser.add_argument('--pt-batch', type=int, default=100)\n parser.add_argument('--scenarios', type=str, default='view1,view2,concatviews,wholeconv',\n help='comma-separated, from [view1|view2|concatviews|wholeconv|mvsc]')\n parser.add_argument('--mvsc-no-unk', action='store_true',\n help='only feed non-unk data to MVSC (to avoid oom)')\n\n parser.add_argument('--view1-col', type=str, default='view1')\n parser.add_argument('--view2-col', type=str, default='view2')\n parser.add_argument('--label-col', type=str, default='tag')\n args = parser.parse_args()\n\n print('loading dataset')\n dataset = Dataset(args.data_path, view1_col=args.view1_col, view2_col=args.view2_col,\n label_col=args.label_col)\n n_cluster = len(dataset.id_to_label) - 1\n print(\"num of class = %d\" % n_cluster)\n\n id_to_token, token_to_id = dataset.id_to_token, dataset.token_to_id\n vocab_size = len(dataset.token_to_id)\n print('vocab_size', vocab_size)\n\n # Load pre-trained GloVe vectors\n pretrained = {}\n word_emb_size = 0\n print('loading glove')\n for line in open(args.glove_path):\n parts = line.strip().split()\n if len(parts) % 100 != 1:\n continue\n word = parts[0]\n if word not in token_to_id:\n continue\n vector = [float(v) for v in parts[1:]]\n pretrained[word] = vector\n word_emb_size = len(vector)\n pretrained_list = []\n scale = np.sqrt(3.0 / word_emb_size)\n print('loading oov')\n for word in id_to_token:\n # apply lower() because all GloVe vectors are for lowercase words\n if word.lower() in pretrained:\n pretrained_list.append(np.array(pretrained[word.lower()]))\n else:\n random_vector = np.random.uniform(-scale, scale, [word_emb_size])\n pretrained_list.append(random_vector)\n\n model = MultiviewEncoders.from_embeddings(\n embeddings=torch.FloatTensor(pretrained_list),\n num_layers=LSTM_LAYER,\n embedding_size=word_emb_size,\n lstm_hidden_size=LSTM_HIDDEN,\n word_dropout=WORD_DROPOUT_RATE,\n dropout=DROPOUT_RATE,\n vocab_size=vocab_size\n )\n model.to(device)\n optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE)\n\n expressions = (model, optimizer)\n pre_acc, pre_state = 0., None\n pretrain_method = pretrain.pretrain_qt\n for epoch in range(1, args.pre_epoch + 1):\n model.train()\n perm_idx = np.random.permutation(dataset.trn_idx)\n trn_loss, _ = pretrain_method(dataset, perm_idx, expressions, train=True)\n model.eval()\n _, tst_acc = pretrain_method(dataset, dataset.tst_idx, expressions, train=False)\n if tst_acc > pre_acc:\n pre_state = copy.deepcopy(model.state_dict())\n pre_acc = tst_acc\n print(f'{datetime.datetime.now()} epoch {epoch}, train_loss={trn_loss:.4f} '\n f'test_acc={tst_acc:.4f}')\n\n if args.pre_epoch > 0:\n # load best state\n model.load_state_dict(pre_state)\n\n # deepcopy pretrained views into v1 and/or view2\n pretrain.after_pretrain_qt(model)\n\n kmeans = sklearn.cluster.KMeans(n_clusters=n_cluster, max_iter=300, verbose=0, random_state=0)\n\n golds = [dataset[idx][1] for idx in dataset.trn_idx]\n for rep in args.scenarios.split(','):\n if rep == 'view1':\n data = [dataset[idx][0][0] for idx in dataset.trn_idx]\n encoded = transform(data=data, model=model)\n preds = kmeans.fit_predict(encoded)\n elif rep == 'view2':\n data = [dataset[idx][0][1] for idx in dataset.trn_idx]\n encoded = []\n for conv in data:\n encoded_conv = transform(data=conv, model=model)\n encoded_conv = torch.from_numpy(encoded_conv)\n encoded_conv = encoded_conv.mean(dim=0)\n encoded.append(encoded_conv)\n encoded = torch.stack(encoded, dim=0)\n # print('encoded.size()', encoded.size())\n encoded = encoded.numpy()\n preds = kmeans.fit_predict(encoded)\n elif rep == 'concatviews':\n v1_data = [dataset[idx][0][0] for idx in dataset.trn_idx]\n v1_encoded = torch.from_numpy(transform(data=v1_data, model=model))\n\n v2_data = [dataset[idx][0][1] for idx in dataset.trn_idx]\n v2_encoded = []\n for conv in v2_data:\n encoded_conv = transform(data=conv, model=model)\n encoded_conv = torch.from_numpy(encoded_conv)\n encoded_conv = encoded_conv.mean(dim=0)\n v2_encoded.append(encoded_conv)\n v2_encoded = torch.stack(v2_encoded, dim=0)\n concatview = torch.cat([v1_encoded, v2_encoded], dim=-1)\n print('concatview.size()', concatview.size())\n encoded = concatview.numpy()\n preds = kmeans.fit_predict(encoded)\n elif rep == 'wholeconv':\n encoded = []\n for idx in dataset.trn_idx:\n v1 = dataset[idx][0][0]\n v2 = dataset[idx][0][1]\n conv = [v1] + v2\n encoded_conv = transform(data=conv, model=model)\n encoded_conv = torch.from_numpy(encoded_conv)\n encoded_conv = encoded_conv.mean(dim=0)\n encoded.append(encoded_conv)\n encoded = torch.stack(encoded, dim=0)\n print('encoded.size()', encoded.size())\n encoded = encoded.numpy()\n preds = kmeans.fit_predict(encoded)\n elif rep == 'mvsc':\n try:\n import multiview\n except Exception:\n print('please install https://github.com/mariceli3/multiview')\n return\n print('imported multiview ok')\n\n idx = dataset.trn_idx_no_unk if args.mvsc_no_unk else dataset.trn_idx\n v1_data = [dataset[idx][0][0] for idx in idx]\n v1_encoded = torch.from_numpy(transform(data=v1_data, model=model))\n\n v2_data = [dataset[idx][0][1] for idx in idx]\n v2_encoded = []\n for conv in v2_data:\n encoded_conv = transform(data=conv, model=model)\n encoded_conv = torch.from_numpy(encoded_conv)\n encoded_conv = encoded_conv.mean(dim=0)\n v2_encoded.append(encoded_conv)\n v2_encoded = torch.stack(v2_encoded, dim=0)\n\n mvsc = multiview.mvsc.MVSC(\n k=n_cluster\n )\n print('running mvsc', end='', flush=True)\n start = time.time()\n preds, eivalues, eivectors, sigmas = mvsc.fit_transform(\n [v1_encoded, v2_encoded], [False] * 2\n )\n print('...done')\n mvsc_time = time.time() - start\n print('time taken %.3f' % mvsc_time)\n else:\n raise Exception('unimplemented rep', rep)\n\n prec, rec, f1, acc = calc_prec_rec_f1_acc(preds, golds)\n print(f'{datetime.datetime.now()} {rep}: eval prec={prec:.4f} rec={rec:.4f} f1={f1:.4f} '\n f'acc={acc:.4f}')\n\n\nif __name__ == '__main__':\n main()\n", "meta": {"hexsha": "01d18f8e1f4e9d666911006a8ec6c5d3a742d89d", "size": 9201, "ext": "py", "lang": "Python", "max_stars_repo_path": "train_qt.py", "max_stars_repo_name": "asappresearch/dialog-intent-induction", "max_stars_repo_head_hexsha": "6396f3153b0fda7e170b1df6b68e969b5e4eb16e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 60, "max_stars_repo_stars_event_min_datetime": "2019-09-11T12:05:15.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-14T13:19:53.000Z", "max_issues_repo_path": "train_qt.py", "max_issues_repo_name": "asappresearch/dialog-intent-induction", "max_issues_repo_head_hexsha": "6396f3153b0fda7e170b1df6b68e969b5e4eb16e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2020-01-17T19:34:09.000Z", "max_issues_repo_issues_event_max_datetime": "2021-01-08T04:10:27.000Z", "max_forks_repo_path": "train_qt.py", "max_forks_repo_name": "asappresearch/dialog-intent-induction", "max_forks_repo_head_hexsha": "6396f3153b0fda7e170b1df6b68e969b5e4eb16e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 24, "max_forks_repo_forks_event_min_datetime": "2019-09-06T08:44:58.000Z", "max_forks_repo_forks_event_max_datetime": "2021-07-23T10:36:58.000Z", "avg_line_length": 38.020661157, "max_line_length": 98, "alphanum_fraction": 0.6188457776, "include": true, "reason": "import numpy", "num_tokens": 2205, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5195213219520929, "lm_q2_score": 0.37022537869825406, "lm_q1q2_score": 0.19233997816153117}} {"text": "# -*- coding: utf-8 -*-\nimport os\nimport fnmatch\nimport copy\nimport datetime\nimport pickle\nimport pathlib\n\nimport numpy as np\nfrom numpy.lib.format import open_memmap\nimport mpmath\nimport PIL\nimport PIL.PngImagePlugin\nimport numba\n\nimport fractalshades as fs\nimport fractalshades.numpy_utils.xrange as fsx\nimport fractalshades.settings as fssettings\nimport fractalshades.utils as fsutils\n\nfrom fractalshades.mprocessing import Multiprocess_filler\n\n\n\nclass _Pillow_figure:\n def __init__(self, img, pnginfo):\n \"\"\"\n This class is a wrapper that can be used to redirect a Fractal_plotter\n output, for instance when generating the documentation.\n \"\"\"\n self.img = img\n self.pnginfo = pnginfo\n\n def save_png(self, im_path):\n \"\"\"\n Saves as a png with Lanczos antialiasing if exceeds the max width\n \"\"\"\n im = self.img\n width, height = im.size\n max_width = fs.settings.output_context[\"doc_max_width\"]\n \n if width > max_width:\n ratio = float(width) / float(max_width)\n new_height = int(height / ratio)\n im = im.resize((max_width, new_height), PIL.Image.LANCZOS)\n im.save(im_path, format=\"png\", pnginfo=self.pnginfo)\n\n\nclass Fractal_plotter:\n def __init__(self, postproc_batch):\n \"\"\"\n The base plotting class.\n \n A Fractal plotter :\n\n - points to a single Fractal\n - can hold several `fractalshades.postproc.Postproc_batch` each one\n point to a single\n (`Fracal`, ``calculation``) couple\n - can hold several post-processing layers\n \n Parameters\n ----------\n postproc_batch\n A single `fractalshades.postproc.Postproc_batch` or a list of \n these\n\n Notes\n -----\n\n .. warning::\n When passed a list of `fractalshades.postproc.Postproc_batch`\n objects, each one shall point to\n the same `Fractal`.\n \"\"\"\n # postproc_batchescan be single or an enumeration\n postproc_batches = postproc_batch\n if isinstance(postproc_batch, fs.postproc.Postproc_batch):\n postproc_batches = [postproc_batch]\n for i, postproc_batch in enumerate(postproc_batches):\n if i == 0:\n self.postproc_batches = [postproc_batch]\n self.posts = copy.copy(postproc_batch.posts)\n self.postnames_2d = postproc_batch.postnames_2d\n # iterator :\n self.fractal = postproc_batch.fractal\n else:\n self.add_postproc_batch(postproc_batch)\n\n self.chunk_slices = self.fractal.chunk_slices\n # layer data\n self.layers = []\n self.scalings = None # to be computed !\n # Plotting directory\n self.plot_dir = self.fractal.directory\n \n @property\n def postnames(self):\n return self.posts.keys()\n \n @property\n def size(self):\n f = self.fractal\n return (f.nx, f.ny)\n\n def add_postproc_batch(self, postproc_batch):\n \"\"\"\n Adds another post-processing batch & register the associated postproc\n names. `postproc_batch` shall map to the same fractal.\n Note : several postproc_batches are needed whenever different \n calculations need to be combined in an output plot, as a postproc\n batch can only map to a unique calc_name.\n :meta private:\n \"\"\"\n if postproc_batch.fractal != self.fractal:\n raise ValueError(\"Attempt to add a postproc_batch from a different\"\n \"fractal: {} from {}\".format(\n postproc_batch.fractal, postproc_batch.calc_name))\n self.postproc_batches += [postproc_batch]\n self.posts.update(postproc_batch.posts)\n self.postnames_2d += postproc_batch.postnames_2d\n\n def add_layer(self, layer):\n \"\"\"\n Adds a layer field to allow subsequent graphical operations or outputs.\n \n Parameters\n ----------\n layer : `fractalshades.colors.layers.Virtual_layer` or a derived class\n The layer to add\n \n Notes\n -----\n\n .. warning::\n Layer `postname` shall have been already registered in one of the\n plotter batches.\n\n .. warning::\n When a layer is added, a link layer -> Fractal_plotter is \n created ; a layer can only point to a single `Fractal_plotter`.\n \"\"\"\n postname = layer.postname\n if postname not in (list(self.postnames) + self.postnames_2d):\n raise ValueError(\"Layer `{}` shall be registered in \"\n \"Fractal_plotter postproc_batches: {}\".format(\n postname, list(self.postnames) + self.postnames_2d))\n self.layers += [layer]\n layer.link_plotter(self)\n\n def __getitem__(self, layer_name):\n \"\"\" Get the layer by its postname\n \"\"\"\n for layer in self.layers:\n if layer.postname == layer_name:\n return layer\n raise KeyError(\"Layer {} not in available layers: {}\".format(\n layer_name, list(l.postname for l in self.layers)))\n\n def plot(self):\n \"\"\"\n The base method to produce images.\n \n When called, it will got through all the instance-registered layers\n and plot each layer for which the `output` attribute is set to `True`.\n \"\"\"\n self.store_postprocs()\n self.compute_scalings()\n self.write_postproc_report()\n self.open_images()\n self.push_layers_to_images()\n self.save_images()\n self.clean_up()\n\n def store_postprocs(self):\n \"\"\" Computes and stores posprocessed data in a temporary mmap\n :meta private:\n \"\"\"\n if fs.settings.optimize_RAM:\n self.has_memmap = True\n self.open_temporary_mmap()\n else:\n self.has_memmap = False\n self.open_RAM_data()\n\n inc_posproc_rank = 0\n self.postname_rank = dict()\n \n for batch in self.postproc_batches:\n if self.has_memmap:\n self.store_temporary_mmap(\n chunk_slice=None,\n batch=batch,\n inc_posproc_rank=inc_posproc_rank\n )\n else:\n self.store_data(\n chunk_slice=None,\n batch=batch,\n inc_posproc_rank=inc_posproc_rank\n )\n for i, postname in enumerate(batch.postnames):\n self.postname_rank[postname] = inc_posproc_rank + i\n inc_posproc_rank += len(batch.posts)\n\n def temporary_mmap_path(self):\n \"\"\" Path to the temporary memmap used to stored plotting arrays\"\"\"\n # from tempfile import mkdtemp\n return os.path.join(\n self.fractal.directory, \"data\", \"_plotter.tpm\")\n\n def open_temporary_mmap(self):\n \"\"\"\n Creates the memory mappings for postprocessed arrays\n Note: We expand to 2d format\n \"\"\"\n f = self.fractal\n nx, ny = (f.nx, f.ny)\n n_pp = len(self.posts)\n mmap = open_memmap(\n filename=self.temporary_mmap_path(), \n mode='w+',\n dtype=f.float_postproc_type,\n shape=(n_pp, nx, ny),\n fortran_order=False,\n version=None)\n del mmap\n\n def open_RAM_data(self):\n \"\"\"\n Same as open_temporary_mmap but in RAM\n \"\"\"\n f = self.fractal\n nx, ny = (f.nx, f.ny)\n n_pp = len(self.posts)\n self._RAM_data = np.zeros(\n shape=(n_pp, nx, ny),\n dtype=f.float_postproc_type\n )\n\n\n @Multiprocess_filler(iterable_attr=\"chunk_slices\",\n iter_kwargs=\"chunk_slice\", veto_multiprocess=False)\n def store_temporary_mmap(self, chunk_slice, batch, inc_posproc_rank):\n \"\"\" Compute & store temporary arrays for this postproc batch\n Note : inc_posproc_rank rank shift to take into account potential\n other batches for this plotter.\n (memory mapping version)\n \"\"\"\n f = self.fractal\n inc = inc_posproc_rank\n post_array, chunk_mask = self.fractal.postproc(batch, chunk_slice)\n arr_2d = f.reshape2d(post_array, chunk_mask, chunk_slice)\n n_posts, cx, cy = arr_2d.shape\n (ix, ixx, iy, iyy) = chunk_slice\n mmap = open_memmap(filename=self.temporary_mmap_path(), mode='r+')\n mmap[inc:inc+n_posts, ix:ixx, iy:iyy] = arr_2d\n\n\n @Multiprocess_filler(iterable_attr=\"chunk_slices\",\n iter_kwargs=\"chunk_slice\", veto_multiprocess=True)\n def store_data(self, chunk_slice, batch, inc_posproc_rank):\n \"\"\" Compute & store temporary arrays for this postproc batch\n (in-RAM version -> shall not use multiprocessing)\n \"\"\"\n f = self.fractal\n inc = inc_posproc_rank\n post_array, chunk_mask = self.fractal.postproc(batch, chunk_slice)\n arr_2d = f.reshape2d(post_array, chunk_mask, chunk_slice)\n n_posts, cx, cy = arr_2d.shape\n (ix, ixx, iy, iyy) = chunk_slice\n self._RAM_data[inc:inc+n_posts, ix:ixx, iy:iyy] = arr_2d\n\n # All methods needed for plotting\n def compute_scalings(self):\n \"\"\" Compute the scaling for all layer field\n (needed for mapping to color) \"\"\"\n for layer in self.layers:\n self.compute_layer_scaling(chunk_slice=None, layer=layer)\n \n def write_postproc_report(self):\n report_path = os.path.join(\n self.fractal.directory, type(self).__name__ + \".txt\")\n\n def write_layer_report(i, layer, report):\n report.write(\" - Layer #{} :\\n\".format(i))\n postname = layer.postname\n report.write(\"post-processing: `{}`\\n\".format(postname))\n report.write(\"kind: {}\\n\".format(type(layer).__name__))\n report.write(\"func: {}\\n\".format(layer._func_arg))\n\n mask = layer.mask\n if mask is None:\n mask_str = \"None\"\n else:\n mask_str = \"{} `{}` with mask color: {}\".format(\n type(mask[0]).__name__,\n mask[0].postname,\n mask[1])\n report.write(\"mask: {}\\n\".format(mask_str))\n\n report.write(\"output: {}\\n\".format(layer.output))\n report.write(\"min: {}\\n\".format(layer.min))\n report.write(\"max: {}\\n\\n\".format(layer.max))\n \n with open(report_path, 'w', encoding='utf-8') as report:\n for i, layer in enumerate(self.layers):\n write_layer_report(i, layer, report)\n\n\n @Multiprocess_filler(iterable_attr=\"chunk_slices\",\n iter_kwargs=\"chunk_slice\", veto_multiprocess=True)\n def compute_layer_scaling(self, chunk_slice, layer):\n \"\"\" Compute the scaling for this layer \"\"\"\n layer.update_scaling(chunk_slice)\n\n def open_images(self):\n self._im = []\n for layer in self.layers:\n if layer.output:\n self._im += [PIL.Image.new(mode=layer.mode, size=self.size)]\n else:\n self._im += [None]\n\n def save_images(self):\n for i, layer in enumerate(self.layers):\n if not(layer.output):\n continue\n file_name = \"{}_{}\".format(type(layer).__name__, layer.postname)\n base_img_path = os.path.join(self.plot_dir, file_name + \".png\")\n self.save_tagged(self._im[i], base_img_path, self.fractal.params)\n\n def save_tagged(self, img, img_path, tag_dict):\n \"\"\"\n Saves *img* to png format at *path*, tagging with *tag_dict*.\n https://dev.exiv2.org/projects/exiv2/wiki/The_Metadata_in_PNG_files\n \"\"\"\n pnginfo = PIL.PngImagePlugin.PngInfo()\n for k, v in tag_dict.items():\n pnginfo.add_text(k, str(v))\n if (fssettings.output_context[\"doc\"]\n and not(fssettings.output_context[\"gui_iter\"] > 0)):\n fssettings.add_figure(_Pillow_figure(img, pnginfo))\n else:\n img.save(img_path, pnginfo=pnginfo)\n\n def push_layers_to_images(self):\n for i, layer in enumerate(self.layers):\n if not(layer.output):\n continue\n self.push_cropped(chunk_slice=None, layer=layer, im=self._im[i])\n\n @Multiprocess_filler(iterable_attr=\"chunk_slices\",\n iter_kwargs=\"chunk_slice\", veto_multiprocess=True)\n def push_cropped(self, chunk_slice, layer, im):\n \"\"\" push \"cropped image\" from layer for this chunk to the image\"\"\"\n (ix, ixx, iy, iyy) = chunk_slice\n ny = self.fractal.ny\n crop_slice = (ix, ny-iyy, ixx, ny-iy)\n paste_crop = layer.crop(chunk_slice)\n im.paste(paste_crop, box=crop_slice)\n \n def clean_up(self):\n if self.has_memmap:\n os.unlink(self.temporary_mmap_path())\n else:\n del self._RAM_data\n\n\n\nclass Fractal:\n \n REPORT_ITEMS = [\n \"chunk1d_begin\",\n \"chunk1d_end\",\n \"iref\",\n \"glitch_max_attempt\",\n \"chunk_pts\",\n \"total-glitched\",\n \"dyn-glitched\"]\n\n # Note : chunk_mask is pre-computed and saved also but not at the same \n # stage (at begining of calculation)\n SAVE_ARRS = [\n \"Z\",\n \"U\",\n \"stop_reason\",\n \"stop_iter\"]\n\n def __init__(self, directory):\n \"\"\"\nThe base class for all escape-time fractals calculations.\n\nDerived class should implement the actual calculation methods used in the\ninnner loop. This class provides the outer looping (calculation is run on \nsuccessive tiles), enables multiprocessing, and manage raw-result storing \nand retrieving.\n\nParameters\n----------\ndirectory : str\n Path for the working base directory\n\nAttributes\n----------\ndirectory : str\n the working directory\niref : int\n the reference point index, when using perturbation technique (if\n not, shall be None)\nglitch_max_attempt : int\n The maximal number of glitch correction loops\nsubset\n A boolean array-like of the size of the image, when False the\n calculation is skipped for this point. It is usually the result\n of a previous calculation that can be passed via a Fractal_array\n wrapper.\n If None (default) all points will be calculated.\nglitch_stop_index : int\n A calculation can exit for several reasons which are tracked in \n `stop_reason` int-array (see below the description of the raw data\n arrays). Values of `stop_reason` above `glitch_stop_index` indicate\n glitched pixels, for which the calculation is deemed invalid.\ncomplex_type :\n the datatype used for Z output arrays\ncodes :\n the string identifier codes for the saved arrays:\n (`complex_codes`, `int_codes`, `termination_codes`)\n\nNotes\n-----\n\nThese notes describe implementation details and should be useful mostly to\nadvanced users when subclassing.\n\n.. note::\n\n **Special methods**\n \n this class and its subclasses may define several methods decorated with\n specific tags:\n \n `fractalshades.zoom_options`\n decorates the methods used to define the zoom\n `fractalshades.calc_options`\n decorates the methods defining the calculation inner-loop\n `fractalshades.interactive_options` \n decorates the methods that can be called\n interactively from the GUI (right-click then context menu selection).\n The coordinates of the click are passed to the called method.\n\n.. note::\n \n **Calculation parameters**\n\n To lanch a calculation, call `~fractalshades.Fractal.run`. The parameters\n from the last \n @ `fractalshades.zoom_options` call and last \n @ `fractalshades.calc_options` call will be used. \n They are stored as class attributes, above a list of such attributes and\n their meaning (non-exhaustive as derived class cmay define their own).\n Note that they should normally not be directly accessed but defined in\n derived class through zoom and calc methods.\n\n.. note::\n\n **Saved data**\n \n The calculation results (raw output of the inner loop at exit) are\n saved to disk and internally accessed during plotting phase through\n memory-mapping. These are:\n\n chunk_mask \n boolean - alias for `subset`\n Saved to disk as ``calc_name``\\_Z.arr in ``data`` folder\n Z\n Complex fields, several fields can be defined and accessed through\n a field string identifier.\n Saved to disk as ``calc_name``\\_Z.arr in ``data`` folder\n U\n Integer fields, several fields can be defined and accessed through\n a field string identifier.\n Saved to disk as ``calc_name``\\_U.arr in ``data`` folder\n stop_reason\n Byte codes: the reasons for loop exit (max iteration reached ?\n overflow ? other ?) A string identifier\n Saved to disk as ``calc_name``\\_stop_reason.arr in ``data`` folder\n stop_iter\n Integer: iterations count at loop exit\n Saved to disk as ``calc_name``\\_stop_iter.arr in ``data`` folder\n\n The string identifiers are stored in ``codes`` attributes.\n\"\"\"\n self.directory = directory\n self.iref = None # None when no reference point used / needed\n self.glitch_max_attempt = 0\n self.subset = None\n self.glitch_stop_index = None\n\n def init_data_types(self, complex_type):\n if type(complex_type) is tuple:\n type_modifier, _ = complex_type\n if type_modifier != \"Xrange\":\n raise ValueError(type_modifier)\n self.complex_type = complex_type\n self.float_postproc_type = np.float32\n self.termination_type = np.int8\n self.int_type = np.int32\n\n @fsutils.zoom_options\n def zoom(self, *,\n x: float,\n y: float,\n dx: float,\n nx: int,\n xy_ratio: float,\n theta_deg: float,\n projection: str=\"cartesian\",\n antialiasing: bool=False):\n \"\"\"\n Define and stores as class-attributes the zoom parameters for the next\n calculation.\n \n Parameters\n ----------\n x : float\n x-coordinate of the central point\n y : float \n y-coordinate of the central point\n dx : float\n span of the view rectangle along the x-axis\n nx : int\n number of pixels of the image along the x-axis\n xy_ratio: float\n ratio of dx / dy and nx / ny\n theta_deg : float\n Pre-rotation of the calculation domain, in degree\n projection : \"cartesian\" | \"spherical\" | \"exp_map\"\n Kind of projection used (default to cartesian)\n antialiasing : bool\n If True, some degree of randomization is applied\n \"\"\"\n # We're all set, the job is done by `zoom_options` wrapper...\n\n def run(self):\n \"\"\"\n Lauch a full calculation.\n \n The parameters from the last \n @ `fractalshades.zoom_options`\\-tagged method call and last\n @ `fractalshades.calc_options`\\-tagged method call will be used.\n\n If calculation results are already there, the parameters will be\n compared and if identical, the calculation will be skipped. This is\n done for each tile and each glitch correction iteration, so i enables\n calculation to restart from an unfinished status.\n \"\"\"\n if not(self.res_available()):\n # We write the param file and initialize the\n # memmaps for progress reports and calc arrays\n # It is not process safe so we dot it before entering multi-processing\n # loop\n fsutils.mkdir_p(os.path.join(self.directory, \"data\"))\n self.open_report_mmap()\n self.open_data_mmaps()\n self.save_params()\n \n # Lazzy compilation of subset boolean array chunk-span\n self._mask_beg_end = None\n\n # JIT-compiled function\n # self.jitted_numba_cycles = numba.njit(numba_cycles)\n self._iterate = self.iterate()\n self.cycles()\n \n # Export to human-readable format\n if fs.settings.inspect_calc:\n self.inspect_calc()\n\n\n @property\n def interrupt_path(self):\n return os.path.join(self.directory, \"data\", \"_interrupt.lck\")\n\n def raise_interruption(self):\n pathlib.Path(self.interrupt_path).touch()\n \n def lower_interruption(self):\n if os.path.isfile(self.interrupt_path):\n os.unlink(self.interrupt_path)\n \n def is_interrupted(self):\n \"\"\" Either programmatically 'interrupted' (from the GUI) or by the user \n in batch mode through fs.settings.skip_calc \"\"\"\n return (os.path.isfile(self.interrupt_path)\n or fs.settings.skip_calc)\n\n @property\n def ny(self):\n return int(self.nx / self.xy_ratio + 0.5)\n\n @property\n def dy(self):\n return self.dx / self.xy_ratio\n\n @property\n def px(self):\n if not(hasattr(self, \"_px\")): # is None:\n self._px = self.dx / self.nx\n return self._px\n\n @property\n def multiprocess_dir(self):\n \"\"\" Directory used for multiprocess stdout stderr streams redirection\n :meta private:\n \"\"\"\n return os.path.join(self.directory, \"multiproc_calc\")\n\n @property\n def Xrange_complex_type(self):\n \"\"\" Return True if the data type is a xrange array\n :meta private:\n \"\"\"\n if type(self.complex_type) is tuple:\n type_modifier, _ = self.complex_type\n return type_modifier == \"Xrange\"\n return False\n\n @property\n def base_complex_type(self):\n complex_type = self.complex_type\n if type(complex_type) is tuple:\n _, complex_type = complex_type\n return complex_type\n\n @property\n def base_float_type(self):\n select = {np.dtype(np.complex64): np.float32,\n np.dtype(np.complex128): np.float64}\n return select[np.dtype(self.base_complex_type)]\n\n @property \n def params(self):\n \"\"\" Used to tag an output image or check if data is already computed\n and stored\n :meta private:\n \"\"\"\n software_params = {\n \"Software\": \"fractalshades \" + fs.__version__,\n \"fractal_type\": type(self).__name__,\n # \"debug\": (\"1234567890\" * 10), # tested 10000 chars ok\n \"datetime\": datetime.datetime.today().strftime(\n '%Y-%m-%d_%H:%M:%S')}\n zoom_params = self.zoom_options\n calc_function = self.calc_options_lastcall # TODO rename to calc_callable\n calc_params = self.calc_options\n\n res = dict(software_params)\n res.update(zoom_params)\n res[\"calc-function\"] = calc_function\n res.update({\"calc-param_\" + k: v for (k, v) in calc_params.items()})\n\n return res\n\n\n def clean_up(self, calc_name):\n \"\"\"\n Deletes all saved data files associated with a given ``calc_name``.\n \n Parameters\n ----------\n calc_name : str\n The string identifying the calculation run for which we want to\n delete the files. \n \"\"\"\n for pattern in [\n calc_name + \"_*.arr\",\n calc_name + \".params\",\n calc_name + \".report\",\n calc_name + \"_pt*.ref\",\n calc_name + \"_pt*.sa\"\n ]:\n data_dir = os.path.join(self.directory, \"data\")\n if not os.path.isdir(data_dir):\n return\n with os.scandir(data_dir) as it:\n for entry in it:\n if (fnmatch.fnmatch(entry.name, pattern)):\n os.unlink(entry.path)\n \n @property\n def pts_count(self):\n \"\"\" Return the total number of points for the current calculation \n taking into account the `subset` parameter\n :meta private:\n \"\"\"\n if self.subset is not None:\n# print(\"in pts_count\", self.subset)\n# print(\"in pts_count\", np.sum(self.subset[None]),\n# np.count_nonzero(self.subset[None]))\n return np.count_nonzero(self.subset[None])\n else:\n return self.nx * self.ny\n\n\n # The various method associated with chunk mgmt ===========================\n def chunk_slices(self): #, chunk_size=None):\n \"\"\"\n Generator function\n Yields the chunks spans (ix, ixx, iy, iyy)\n with each chunk of size chunk_size x chunk_size\n \"\"\"\n # if chunk_size is None:\n chunk_size = fssettings.chunk_size\n\n for ix in range(0, self.nx, chunk_size):\n ixx = min(ix + chunk_size, self.nx)\n for iy in range(0, self.ny, chunk_size):\n iyy = min(iy + chunk_size, self.ny)\n yield (ix, ixx, iy, iyy)\n\n @property\n def chunks_count(self):\n \"\"\"\n Return the total number of chunks (tiles) for the current image\n \"\"\"\n chunk_size = fssettings.chunk_size\n (cx, r) = divmod(self.nx, chunk_size)\n if r != 0:\n cx += 1\n (cy, r) = divmod(self.ny, chunk_size)\n if r != 0: cy += 1\n return cx * cy\n\n def chunk_rank(self, chunk_slice):\n \"\"\"\n Return the generator yield index for chunk_slice\n \"\"\"\n chunk_size = fssettings.chunk_size\n (ix, _, iy, _) = chunk_slice\n chunk_item_x = ix // chunk_size\n chunk_item_y = iy // chunk_size\n (cy, r) = divmod(self.ny, chunk_size)\n if r != 0: cy += 1\n return chunk_item_x * cy + chunk_item_y\n\n def chunk_from_rank(self, rank):\n \"\"\"\n Return the chunk_slice from the generator yield index\n \"\"\"\n chunk_size = fssettings.chunk_size\n (cy, r) = divmod(self.ny, chunk_size)\n if r != 0: cy += 1\n chunk_item_x, chunk_item_y = divmod(rank, cy)\n ix = chunk_item_x * chunk_size\n iy = chunk_item_y * chunk_size\n ixx = min(ix + chunk_size, self.nx)\n iyy = min(iy + chunk_size, self.ny)\n return (ix, ixx, iy, iyy)\n\n def mask_beg_end(self, rank):\n \"\"\" Return the span for the boolean mask index for the chunk index\n `rank` \"\"\"\n if self._mask_beg_end is None:\n arr = np.empty((self.chunks_count + 1,), dtype=np.int32)\n arr[0] = 0\n for i, chunk_slice in enumerate(self.chunk_slices()):\n (ix, ixx, iy, iyy) = chunk_slice\n arr[i + 1] = arr[i] + (ixx - ix) * (iyy - iy)\n self._mask_beg_end = arr\n return self._mask_beg_end[rank: rank + 2]\n\n def chunk_pts(self, chunk_slice):\n \"\"\"\n Return the number of compressed 1d points for this chunk_slice\n (taking into account 2d subset bool if available)\n \"\"\"\n subset = self.subset\n (ix, ixx, iy, iyy) = chunk_slice\n if subset is not None:\n subset_pts = np.count_nonzero(subset[chunk_slice]) # TODO : test this\n return subset_pts\n else:\n return (ixx - ix) * (iyy - iy)\n\n @property\n def chunk_mask(self):#, chunk_slice):\n \"\"\" Legacy - simple alias \"\"\"\n return self.subset\n# subset = self.subset\n# if subset is not None:\n# return ~subset # np.ravel(subset[chunk_slice])\n# else:\n# return None\n\n def c_chunk(self, chunk_slice):\n \"\"\"\n Returns a chunk of c_vec for the calculation\n Parameters\n - chunk_span\n - data_type: expected one of np.float64, np.longdouble\n \n Returns: \n c_vec : [chunk_size x chunk_size] 2d-vec of type datatype\n\n Projection availables cases :\n - cartesian : standard cartesisan\n - spherical : uses a spherical projection\n - exp_map : uses an exponential map projection\n - mixed_exp_map : a mix of cartesian, exponential\n\n Note : return type is always standard prec - standard range\n \"\"\"\n \n (x, y) = (self.x, self.y)\n\n offset = self.chunk_offset(chunk_slice)\n return (x + offset[0]) + (y + offset[1]) * 1j # TODO test this\n\n\n def chunk_offset(self, chunk_slice, ensure_Xr=False):\n \"\"\"\n Only computes the delta around ref central point for different projections\n Note : return type is always standard prec - standard or extended range\n \n ensure_Xr : enforce extended range if True\n \"\"\"\n# select = {np.complex256: np.float128,\n# np.complex128: np.float64}\n data_type = self.base_float_type # select[self.base_complex_type]\n\n (xy_ratio, theta_deg) = (self.xy_ratio, self.theta_deg)\n (nx, ny, dx, dy) = (self.nx, self.ny, self.dx, self.dy)\n\n if self.Xrange_complex_type or ensure_Xr:\n dx_m, dx_exp = mpmath.frexp(dx)\n dx_m = np.array(dx_m, data_type)\n dx = fsx.Xrange_array(dx_m, dx_exp)\n dy_m, dy_exp = mpmath.frexp(dy)\n dy_m = np.array(dy_m, data_type)\n dy = fsx.Xrange_array(dy_m, dy_exp)\n else:\n dx = float(dx)\n dy = float(dy)\n \n (ix, ixx, iy, iyy) = chunk_slice\n theta = theta_deg / 180. * np.pi\n\n dx_grid = np.linspace(-0.5, 0.5, num=nx, dtype=data_type)\n dy_grid = np.linspace(-0.5, 0.5, num=ny, dtype=data_type)\n dy_vec, dx_vec = np.meshgrid(dy_grid[iy:iyy], dx_grid[ix:ixx])\n\n if self.antialiasing:\n rg = np.random.default_rng(0)\n dx_vec += (0.5 - rg.random(dx_vec.shape, dtype=data_type)) * 0.5 / nx\n dy_vec += (0.5 - rg.random(dy_vec.shape, dtype=data_type)) * 0.5 / ny\n\n dx_vec = dx * dx_vec\n dy_vec = dy * dy_vec\n\n if self.projection == \"cartesian\":\n offset = [(dx_vec * np.cos(theta)) - (dy_vec * np.sin(theta)),\n (dx_vec * np.sin(theta)) + (dy_vec * np.cos(theta))]\n\n elif self.projection == \"spherical\":\n dr_sc = np.sqrt(dx_vec**2 + dy_vec**2) / max(dx, dy) * np.pi\n k = np.where(dr_sc >= np.pi * 0.5, np.nan, # outside circle\n np.where(dr_sc < 1.e-12, 1., np.tan(dr_sc) / dr_sc))\n dx_vec *= k\n dy_vec *= k\n offset = [(dx_vec * np.cos(theta)) - (dy_vec * np.sin(theta)),\n (dx_vec * np.sin(theta)) + (dy_vec * np.cos(theta))]\n\n elif self.projection == \"mixed_exp_map\":\n # square + exp. map\n h_max = 2. * np.pi * xy_ratio # max h reached on the picture\n xbar = (dx_vec + 0.5 * dx - dy) / dx * h_max # 0 .. hmax\n ybar = dy_vec / dy * 2. * np.pi # -pi .. +pi\n rho = dx * 0.5 * np.where(xbar > 0., np.exp(xbar), 0.)\n phi = ybar + theta\n dx_vec = (dx_vec + 0.5 * dx - 0.5 * dy) * xy_ratio\n dy_vec = dy_vec * xy_ratio\n offset = [np.where(xbar <= 0.,\n (dx_vec * np.cos(theta)) - (dy_vec * np.sin(theta)),\n rho * np.cos(phi)),\n np.where(xbar <= 0.,\n (dx_vec * np.sin(theta)) + (dy_vec * np.cos(theta)),\n rho * np.sin(phi))]\n\n elif self.projection == \"exp_map\":\n # only exp. map\n h_max = 2. * np.pi * xy_ratio # max h reached on the picture\n xbar = (dx_vec + 0.5 * dx - dy) / dx * h_max # 0 .. hmax\n ybar = dy_vec / dy * 2. * np.pi # -pi .. +pi\n rho = dx * 0.5 * np.exp(xbar)\n phi = ybar + theta\n offset = [rho * np.cos(phi), rho * np.sin(phi)]\n\n else:\n raise ValueError(\"Projection not implemented: {}\".format(\n self.projection))\n return offset\n\n def px_chunk(self, chunk_slice):\n \"\"\"\n Local size of pixel for different projections\n \"\"\"\n data_type = self.base_float_type\n\n xy_ratio = self.xy_ratio\n (nx, ny, dx, dy) = (self.nx, self.ny, self.dx, self.dy)\n (ix, ixx, iy, iyy) = chunk_slice\n \n if not(self.Xrange_complex_type):\n dx = float(dx)\n dy = float(dy)\n else:\n dx_m, dx_exp = mpmath.frexp(dx)\n dx_m = np.array(dx_m, data_type)\n dx = fsx.Xrange_array(dx_m, dx_exp)\n dy_m, dy_exp = mpmath.frexp(dy)\n dy_m = np.array(dy_m, data_type)\n dy = fsx.Xrange_array(dy_m, dy_exp)\n\n dx_grid = dx * np.linspace(-0.5, 0.5, num=nx, dtype=data_type)\n dy_grid = dy * np.linspace(-0.5, 0.5, num=ny, dtype=data_type)\n dy_vec, dx_vec = np.meshgrid(dy_grid[iy:iyy], dx_grid[ix:ixx])\n\n if self.projection == \"cartesian\":\n px = (dx / (nx - 1.)) #* np.ones_like(dx_vec)\n\n elif self.projection == \"spherical\":\n raise NotImplementedError()\n\n elif self.projection == \"mixed_exp_map\":\n raise NotImplementedError()\n\n elif self.projection == \"exp_map\":\n h_max = 2. * np.pi * xy_ratio\n xbar = (dx_vec + 0.5 * dx - dy) / dx * h_max\n px = (dx / (nx - 1.)) * 0.5 * h_max * np.exp(xbar)\n\n else:\n raise ValueError(\"Projection not implemented: {}\".format(\n self.projection))\n return px\n\n\n\n def param_matching(self, dparams):\n \"\"\"\n Test if the stored parameters match those of new calculation\n /!\\ modified in subclass\n \"\"\"\n print(\"**CALLING param_matching +++\", self.params)\n # TODO : note: when comparing iref should be disregarded ? \n # or subclass specific implementation\n UNTRACKED = [\"datetime\", \"debug\"] \n for key, val in self.params.items():\n if not(key in UNTRACKED) and dparams[key] != val:\n print(\"Unmatching\", key, val, \"-->\", dparams[key])\n return False\n# print(\"its a match\", key, val, dparams[key] )\n print(\"** all good\")\n return True\n\n def res_available(self, chunk_slice=None):\n \"\"\" \n If chunk_slice is None, check that stored calculation parameters\n matches.\n If chunk_slice is provided, checks that calculation results are\n available up to current self.iref\n \"\"\"\n try:\n params, codes = self.reload_params()\n except IOError:\n return False\n matching = self.param_matching(params)\n if not(matching):\n return False\n if chunk_slice is None:\n return matching # True\n\n try:\n report = self.reload_report(chunk_slice)\n except IOError:\n return False\n\n if self.iref is None:\n return report[\"iref\"] >= -1 # -2 means not yet calculated\n else:\n completed = (report[\"iref\"] >= self.iref)\n not_needed = (report[\"total-glitched\"] == 0)\n return (not_needed or completed)\n\n\n @Multiprocess_filler(iterable_attr=\"chunk_slices\",\n redirect_path_attr=\"multiprocess_dir\",\n iter_kwargs=\"chunk_slice\")\n def cycles(self, chunk_slice=None, SA_params=None):\n \"\"\"\n Fast-looping for Julia and Mandelbrot sets computation.\n\n Parameters\n *initialize* function(Z, U, c) modify in place Z, U (return None)\n *iterate* function(Z, U, c, n) modify place Z, U (return None)\n\n *subset* bool arrays, iteration is restricted to the subset of current\n chunk defined by this array. In the returned arrays the size\n of axis \":\" is np.sum(subset[ix:ixx, iy:iyy]) - see below\n *codes* = complex_codes, int_codes, termination_codes\n *calc_name* prefix identifig the data files\n *chunk_slice_c* None - provided by the looping wrapper\n \n *iref* *ref_path* : defining the reference path, for iterations with\n perturbation method. if iref > 0 : means glitch correction loop.\n \n\n \n *gliched* boolean Fractal_Data_array of pixels that should be updated\n with a new ref point\n *irefs* integer Fractal_Data_array of pixels current ref points\n \n \n Returns \n None - save to a file. \n *raw_data* = (chunk_mask, Z, U, stop_reason, stop_iter) where\n *chunk_mask* 1d mask\n *Z* Final values of iterated complex fields shape [ncomplex, :]\n *U* Final values of int fields [nint, :] np.int32\n *stop_reason* Byte codes -> reasons for termination [:] np.int8\n *stop_iter* Numbers of iterations when stopped [:] np.int32\n \"\"\"\n if self.is_interrupted():\n return\n if self.res_available(chunk_slice):\n return\n\n if self.iref is None:\n (c, Z, U, stop_reason, stop_iter, n_stop, bool_active,\n index_active, n_iter) = self.init_cycling_arrays(chunk_slice)\n SA_iter = 0\n else:\n (c, Z, U, stop_reason, stop_iter, n_stop, bool_active,\n index_active, n_iter, SA_iter, ref_div_iter, ref_path\n ) = self.init_cycling_arrays(chunk_slice, SA_params)\n # print(\"n_iter, SA_iter, ref_div_iter\", n_iter, SA_iter, ref_div_iter)\n modified_in_cycle = np.copy(bool_active)\n\n iterate = self._iterate\n iref = self.iref\n\n print(\"**/CALLING cycles looping, n_stop\", n_stop)\n\n if iref is None:\n # Standard iterations\n numba_cycles(Z, U, c, stop_reason, stop_iter, bool_active,\n n_iter, iterate)\n else:\n # Perturbation iterations\n last_iref = (iref == self.glitch_max_attempt) \n numba_cycles_perturb(Z, U, c, stop_reason, stop_iter, bool_active,\n iref, n_iter, SA_iter, ref_div_iter, ref_path, iterate,\n last_iref)\n\n # Saving the results after cycling\n self.update_report_mmap(chunk_slice, stop_reason)\n print(\"#### saving\", Z.dtype)\n print(\"#### stop_reason\", stop_reason)\n self.update_data_mmaps(chunk_slice, Z, U, stop_reason, stop_iter,\n modified_in_cycle)\n\n\n\n def init_cycling_arrays(self, chunk_slice):\n \"\"\"\n Prepared the chunk arrays for subsequent looping\n \"\"\"\n c = np.ravel(self.c_chunk(chunk_slice))\n if self.subset is not None:\n c = c[self.chunk_mask[chunk_slice]]\n# c = self._2d_to_1d(self.c_chunk(chunk_slice), chunk_slice)\n\n (n_pts,) = c.shape\n n_Z, n_U, n_stop = (len(code) for code in self.codes)\n\n if self.Xrange_complex_type:\n Z = fsx.Xrange_array.zeros([n_Z, n_pts], # [n_Z, n_pts],\n dtype=self.base_complex_type)\n else:\n Z = np.zeros([n_Z, n_pts], dtype=self.complex_type)\n U = np.zeros([n_U, n_pts], dtype=self.int_type)\n stop_reason = -np.ones([1, n_pts], dtype=self.termination_type)\n stop_iter = np.zeros([1, n_pts], dtype=self.int_type)\n\n self.initialize()(Z, U, c, chunk_slice)\n\n # We start at 0 with all index active\n n_iter = 0\n index_active = np.arange(c.size, dtype=self.int_type)\n bool_active = np.ones(c.size, dtype=np.bool)\n\n return (c, Z, U, stop_reason, stop_iter, n_stop, bool_active,\n index_active, n_iter)\n\n\n # ======== The various storing files for a calculation ====================\n @staticmethod\n def filter_stored_codes(codes):\n \"\"\" Don't store temporary codes - i.e. those which starts with \"_\" \"\"\"\n return list(filter(lambda x: not(x.startswith(\"_\")), codes))\n\n def params_path(self, calc_name=None):\n if calc_name is None:\n calc_name = self.calc_name\n return os.path.join(\n self.directory, \"data\", calc_name + \".params\")\n \n def serializable_params(self, params):\n \"\"\" Some params we do not want to save as-is but only keep partial\n information. Saving them would duplicate information + require coding\n ad-hoc __getstate__, __setstate__ methods.\n \"\"\"\n unserializable = (\"calc-param_subset\",)\n ret = {}\n for k, v in params.items():\n if k in unserializable:\n if v is None:\n ret[k] = v\n else:\n ret[k] = repr(v)\n else:\n ret[k] = v\n # print(\"modified params ready to save\", ret)\n return ret\n\n def save_params(self):\n \"\"\"\n Save (pickle) current calculation parameters in data file,\n Don't save temporary codes - i.e. those which startwith \"_\"\n This should only be used to tag images and not to re-run a calculation.\n \"\"\"\n (complex_codes, int_codes, stop_codes) = self.codes\n f_complex_codes = self.filter_stored_codes(complex_codes)\n f_int_codes = self.filter_stored_codes(int_codes)\n saved_codes = (f_complex_codes, f_int_codes, stop_codes)\n\n save_path = self.params_path()\n fsutils.mkdir_p(os.path.dirname(save_path))\n with open(save_path, 'wb+') as tmpfile:\n s_params = self.serializable_params(self.params)\n pickle.dump(s_params, tmpfile, pickle.HIGHEST_PROTOCOL)\n pickle.dump(saved_codes, tmpfile, pickle.HIGHEST_PROTOCOL)\n# print(\"Saved calc params\", save_path)\n\n def reload_params(self, calc_name=None): # public\n save_path = self.params_path(calc_name)\n with open(save_path, 'rb') as tmpfile:\n params = pickle.load(tmpfile)\n codes = pickle.load(tmpfile)\n return (params, codes)\n\n def report_path(self, calc_name=None): # public\n if calc_name is None:\n calc_name = self.calc_name\n return os.path.join(\n self.directory, \"data\", calc_name + \".report\")\n\n def open_report_mmap(self): # private\n \"\"\"\n Create the memory mapping for calculation reports by chunks\n [chunk1d_begin, chunk1d_end,\n iref, glitch_max_attempt, chunk_pts, chunk_glitched]\n\n Initialized as:\n [chunk1d_begin, chunk1d_end,\n -2, self.glitch_max_attempt, pts_total, -2]\n \"\"\"\n items = self.REPORT_ITEMS\n chunks_count = self.chunks_count\n report_cols_count = len(items)\n\n mmap = open_memmap(\n filename=self.report_path(), \n mode='w+',\n dtype=np.int32,\n shape=(chunks_count, report_cols_count),\n fortran_order=False,\n version=None)\n\n mmap[:, items.index(\"iref\")] = -2 # -1 used if calculated\n mmap[:, items.index(\"total-glitched\")] = -1\n mmap[:, items.index(\"dyn-glitched\")] = -1\n mmap[:, items.index(\"glitch_max_attempt\")] = self.glitch_max_attempt\n\n # Number of points per chunk\n chunk_pts = np.empty((chunks_count,), dtype=np.int32)\n for i, chunk_slice in enumerate(self.chunk_slices()):\n chunk_pts[i] = self.chunk_pts(chunk_slice)\n mmap[:, items.index(\"chunk_pts\")] = chunk_pts\n\n # full_cumsum is np.cumsum(chunk_pts) with inserted 0\n full_cumsum = np.empty((chunks_count + 1,), dtype=np.int32)\n np.cumsum(chunk_pts, out=full_cumsum[1:])\n full_cumsum[0] = 0\n mmap[:, items.index(\"chunk1d_begin\")] = full_cumsum[:-1]\n mmap[:, items.index(\"chunk1d_end\")] = full_cumsum[1:]\n\n del mmap\n\n def update_report_mmap(self, chunk_slice, stop_reason): # private\n \"\"\"\n \"\"\"\n items = self.REPORT_ITEMS\n chunk_rank = self.chunk_rank(chunk_slice)\n glitch_stop_index = self.glitch_stop_index\n mmap = open_memmap(filename=self.report_path(), mode='r+')\n total_glitched = dyn_glitched = 0 # Default if no glitch correction \n if glitch_stop_index is not None:\n total_glitched = np.count_nonzero(stop_reason >= glitch_stop_index)\n dyn_glitched = np.count_nonzero(stop_reason == glitch_stop_index)\n mmap[chunk_rank, items.index(\"total-glitched\")] = total_glitched\n mmap[chunk_rank, items.index(\"dyn-glitched\")] = dyn_glitched\n mmap[chunk_rank, items.index(\"iref\")] = (\n self.iref if (self.iref is not None) else -1)\n# print(\"report updated\", chunk_slice, \"iref:\", self.iref, \"chunk_glitched:\", total_glitched)\n \n del mmap\n\n def reload_report(self, chunk_slice, calc_name=None): # public\n \"\"\" Return a report extract for the given chunk, as a dict\n If no chunk provided, return the full report (header, report)\n# \"\"\"\n items = self.REPORT_ITEMS\n mmap = open_memmap(filename=self.report_path(calc_name), mode='r')\n if chunk_slice is None:\n report = np.empty(mmap.shape, mmap.dtype)\n # print(mmap.shape, mmap.dtype)\n report[:, :] = mmap[:, :]\n return self.REPORT_ITEMS, report\n rank = self.chunk_rank(chunk_slice)\n report = dict(zip(\n items,\n (mmap[rank, items.index(it)] for it in items)\n ))\n return report\n\n\n def inspect_calc(self):\n \"\"\"\n Outputs a report for the current calculation\n \"\"\"\n REPORT_ITEMS, report = self.reload_report(None)\n report_header = (\"chnk_beg|chnk_end|iref|atmt|chnk_pts|\"\n \"glitched|dyn glit|\")\n\n # There are other interesting items to inspect\n chunks_count = self.chunks_count\n\n stop_ITEMS = [\"min_stop_iter\", \"max_stop_iter\", \"mean_stop_iter\"]\n stop_report = np.zeros([chunks_count, 3], dtype = np.int32)\n stop_header = \"min_stop|max_stop|mean_stp|\"\n\n reason_ITEMS = []\n reason_reports = []\n reason_header = \"\"\n reason_template = np.zeros([chunks_count, 1], dtype = np.int32)\n\n for i, chunk_slice in enumerate(self.chunk_slices()):\n chunk_mask, Z, U, stop_reason, stop_iter = self.reload_data(\n chunk_slice)\n # Outputs a summary of the stop iter\n has_item = (stop_iter.size != 0)\n \n# print(\"len(stop_iter)\" , len(stop_iter), stop_iter.shape, \"\\n\" , stop_iter)\n for j, it in enumerate(stop_ITEMS):\n if it == \"min_stop_iter\" and has_item:\n stop_report[i, j] = np.min(stop_iter)\n elif it == \"max_stop_iter\" and has_item:\n stop_report[i, j] = np.max(stop_iter)\n elif it == \"mean_stop_iter\" and has_item:\n stop_report[i, j] = int(np.mean(stop_iter))\n else:\n stop_report[i, j] = -1\n\n # Outputs a summary of the stop reason\n if (stop_reason.size == 0): # Nothing to report\n continue\n max_chunk_reason = np.max(stop_reason)\n for r in range(len(reason_ITEMS), max_chunk_reason + 1):\n reason_ITEMS += [\"reason_\" + str(r)]\n reason_reports += [reason_template.copy()]\n reason_header += (\"reason_\" + str(r) + \"|\")\n bc = np.bincount(np.ravel(stop_reason))\n for r, bc_r in enumerate(bc): #range(len(reason_ITEMS)):\n# print(\"r\", r, \"i\", i, \"len\", len(reason_ITEMS), len(reason_reports), max_chunk_reason)\n reason_reports[r][i, 0] = bc_r\n\n # Stack the results\n header = REPORT_ITEMS + stop_ITEMS + reason_ITEMS\n n_header = len(header)\n# print(\"header\", header, n_header)\n# print(\"report\", report)\n# print(\"stop_report\", stop_report)\n# print(\"reason_reports\", reason_reports)\n full_report = np.empty((chunks_count, n_header), dtype = np.int32)\n l1 = len(REPORT_ITEMS)\n l2 = l1 + len(stop_ITEMS)\n full_report[:, :l1] = report\n full_report[:, l1:l2] = stop_report\n for i in range(l2, n_header):\n r = i - l2\n full_report[:, i] = reason_reports[r][:, 0]\n# print(\"full_report\", full_report)\n\n # https://numpy.org/doc/stable/reference/generated/numpy.savetxt.html\n outpath = os.path.join(self.directory, self.calc_name + \".inspect\")\n np.savetxt(\n outpath,\n full_report,\n fmt=('%8i|%8i|%4i|%4i|%8i|%8i|%8i|%8i|%8i|%8i|'\n + '%8i|' * len(reason_ITEMS)),\n header=(report_header + stop_header + reason_header),\n comments=''\n )\n\n\n def data_path(self, calc_name=None):\n if calc_name is None:\n calc_name = self.calc_name\n keys = [\"chunk_mask\"] + self.SAVE_ARRS \n def file_map(key):\n return os.path.join(self.directory, \"data\",\n calc_name + \"_\" + key + \".arr\")\n return dict(zip(keys, map(file_map, keys)))\n\n def open_data_mmaps(self):\n \"\"\"\n Creates the memory mappings for calculated arrays\n [chunk_mask, Z, U, stop_reason, stop_iter]\n \n Note : chunk_mask can be initialized here\n \"\"\"\n# items = self.REPORT_ITEMS\n keys = self.SAVE_ARRS #[\"\"Z\", \"U\", \"stop_reason\", \"stop_iter\"]\n data_type = {\n # \"chunk_mask\": np.bool,\n \"Z\": self.complex_type, # TODO Xrange array\n \"U\": self.int_type,\n \"stop_reason\": self.termination_type,\n \"stop_iter\": self.int_type,\n }\n if self.Xrange_complex_type:\n data_type[\"Z\"] = np.dtype([\n ('mantissa', self.base_complex_type),\n ('exp', np.int32)\n ], align=False)\n data_path = self.data_path()\n\n pts_count = self.pts_count # the memmap 1st dim\n (complex_codes, int_codes, stop_codes) = self.codes\n # keep only the one which do not sart with \"_\"\n f_complex_codes = self.filter_stored_codes(complex_codes)\n f_int_codes = self.filter_stored_codes(int_codes)\n n_Z, n_U, n_stop = (len(codes) for codes in \n (f_complex_codes, f_int_codes, stop_codes))\n # Followin C row-major order --> arr[x, :] shall be fast\n data_dim = {\n # \"chunk_mask\": (pts_count,),\n \"Z\": (n_Z, pts_count),\n \"U\": (n_U, pts_count),\n \"stop_reason\": (1, pts_count),\n \"stop_iter\": (1, pts_count),\n }\n\n for key in keys:\n mmap = open_memmap(\n filename=data_path[key], \n mode='w+',\n dtype=data_type[key],\n shape=data_dim[key],\n fortran_order=False,\n version=None)\n del mmap\n\n # Store the chunk_mask (if there is one) at this stage : it is already\n # known\n # /!\\ the size of the chunk_mask is always the same, irrespective of\n # the number of items masked\n if self.subset is not None:\n \n mmap = open_memmap(\n filename=data_path[\"chunk_mask\"], \n mode='w+',\n dtype=np.bool,\n shape=(self.nx * self.ny,),\n fortran_order=False,\n version=None)\n for i, chunk_slice in enumerate(self.chunk_slices()):\n beg_end = self.mask_beg_end(i)\n mmap[beg_end[0]: beg_end[1]] = self.chunk_mask[chunk_slice]\n\n\n def update_data_mmaps(self, chunk_slice, Z, U, stop_reason, stop_iter,\n modified_in_cycle):\n keys = self.SAVE_ARRS\n items = self.REPORT_ITEMS\n data_path = self.data_path()\n arr_map = {\n \"Z\": Z,\n \"U\": U,\n \"stop_reason\": stop_reason,\n \"stop_iter\": stop_iter,\n }\n report_mmap = open_memmap(filename=self.report_path(), mode='r')\n rank = self.chunk_rank(chunk_slice)\n beg = report_mmap[rank, items.index(\"chunk1d_begin\")]\n end = report_mmap[rank, items.index(\"chunk1d_end\")]\n\n # codes mapping - taking into account suppressed fields (starting with\n # \"_\")\n (complex_codes, int_codes, stop_codes) = self.codes\n # keep only the one which do not sart with \"_\"\n f_complex_codes = self.filter_stored_codes(complex_codes)\n f_int_codes = self.filter_stored_codes(int_codes)\n n_Z, n_U, n_stop = (len(codes) for codes in \n (f_complex_codes, f_int_codes, stop_codes))\n codes_index_map = {\n \"Z\": (range(n_Z), list(complex_codes.index(f_complex_codes[i]) \n for i in range(n_Z))),\n \"U\": (range(n_U), list(int_codes.index(f_int_codes[i])\n for i in range(n_U))),\n \"stop_reason\": (range(1), range(1)),\n \"stop_iter\": (range(1), range(1))\n }\n\n for key in keys:\n mmap = open_memmap(filename=data_path[key], mode='r+')\n arr = arr_map[key]\n\n fancy_indexing = np.arange(beg, end, dtype=np.int32)\n fancy_indexing = fancy_indexing[modified_in_cycle]\n\n for (field, f_field) in zip(*codes_index_map[key]):\n mmap[field, fancy_indexing] = arr[f_field, modified_in_cycle]\n\n def reload_data(self, chunk_slice, calc_name=None): # public\n \"\"\" Reload all strored raw arrays for this chunk : \n raw_data = chunk_mask, Z, U, stop_reason, stop_iter\n \"\"\"\n keys = self.SAVE_ARRS\n items = self.REPORT_ITEMS\n # Retrieve 1d-coordinates for this chunck\n report_mmap = open_memmap(filename=self.report_path(calc_name),\n mode='r')\n rank = self.chunk_rank(chunk_slice)\n beg = report_mmap[rank, items.index(\"chunk1d_begin\")]\n end = report_mmap[rank, items.index(\"chunk1d_end\")]\n\n arr = dict()\n data_path = self.data_path(calc_name)\n for key in keys:\n mmap = open_memmap(filename=data_path[key], mode='r')\n arr[key] = mmap[:, beg:end]\n\n # Here we can t always rely on self.subset, it has to be consistent\n # with calc_name ie loaded from params options\n subset = self.subset\n if calc_name is not None:\n params, _ = self.reload_params(calc_name)\n subset = params[\"calc-param_subset\"]\n \n if subset is not None:\n # /!\\ fixed-size irrespective of the mask\n mmap = open_memmap(filename=data_path[\"chunk_mask\"], mode='r')\n beg_end = self.mask_beg_end(rank)\n arr[\"chunk_mask\"] = mmap[beg_end[0]: beg_end[1]]\n else:\n arr[\"chunk_mask\"] = None\n \n return (arr[\"chunk_mask\"], arr[\"Z\"], arr[\"U\"], arr[\"stop_reason\"],\n arr[\"stop_iter\"])\n\n\n @staticmethod\n def kind_from_code(code, codes):\n \"\"\"\n codes as returned by \n (params, codes) = self.reload_data_chunk(chunk_slice, calc_name)\n Used for \"raw\" post-processing\n \"\"\"\n complex_codes, int_codes, _ = codes\n if code in complex_codes:\n kind = \"complex\"\n elif code in int_codes:\n kind = \"int\"\n elif code == \"stop_reason\":\n kind = code\n elif code == \"stop_iter\":\n kind = code\n else:\n raise KeyError(\"raw data code unknow: \" + code, complex_codes,\n int_codes, \"stop_reason\", \"stop_iter\")\n return kind\n\n @staticmethod\n def reshape2d(chunk_array, chunk_mask, chunk_slice):\n \"\"\"\n Returns 2d versions of the 1d stored vecs\n chunk_array of size (n_post, n_pts)\n \n # note : to get a 2-dimensionnal vec do:\n if bool_mask is not None:\n we need to inverse\n chunk_mask = np.ravel(subset[chunk_size])\n c = c[chunk_mask]\n \"\"\"\n (ix, ixx, iy, iyy) = chunk_slice\n nx, ny = ixx - ix, iyy - iy\n\n n_post, n_pts = chunk_array.shape\n if chunk_mask is None:\n chunk_2d = np.copy(chunk_array)\n else:\n indices = np.arange(nx * ny)[chunk_mask]\n chunk_2d = np.empty([n_post, nx * ny], dtype=chunk_array.dtype)\n chunk_2d[:] = np.nan\n chunk_2d[:, indices] = chunk_array\n\n return np.reshape(chunk_2d, [n_post, nx, ny])\n \n @staticmethod\n def index2d(index_1d, chunk_mask, chunk_slice):\n \"\"\" Return the 2d-indexing from 1d + mask \n chunk_mask = None | self.subset[chunk_slice]\n \"\"\"\n # chunk_size = fssettings.chunk_size\n (ix, ixx, iy, iyy) = chunk_slice\n nx, ny = ixx - ix, iyy - iy\n ix, iy = np.indices((nx, ny))\n ix = np.ravel(ix)\n iy = np.ravel(iy)\n if chunk_mask is not None:\n ix = ix[chunk_mask]\n iy = iy[chunk_mask]\n return ix[index_1d], iy[index_1d]\n\n @staticmethod\n def codes_mapping(complex_codes, int_codes, termination_codes):\n \"\"\"\n Utility function, returns the inverse mapping code -> int\n \"\"\"\n complex_dic, int_dic, termination_dic = [dict(\n zip(tab, range(len(tab)))) for tab in [\n complex_codes, int_codes, termination_codes]]\n return complex_dic, int_dic, termination_dic\n\n @staticmethod\n def subsubset(bool_set, bool_subset_of_set):\n \"\"\"\n Returns boolean array for a subset\n Parameters \n - *bool_set* bool array of shape N, defines a set \n - *bool_subset_of_set* bool array of shape Card(set)\n Returns\n - *bool_subset* bool array of shape N\n \"\"\"\n set_count = np.sum(bool_set)\n Card_set, = np.shape(bool_subset_of_set)\n if Card_set != set_count:\n raise ValueError(\"Expected bool_subset_of_set of shape\"\n \" [Card(set)]\")\n bool_subset = np.copy(bool_set)\n bool_subset[bool_set] = bool_subset_of_set\n return bool_subset\n\n def postproc(self, postproc_batch, chunk_slice):\n \"\"\" Computes the output of ``postproc_batch`` for chunk_slice\n Return\n post_array of shape(nposts, chunk_n_pts)\n chunk_mask\n \"\"\"\n if postproc_batch.fractal is not self:\n raise ValueError(\"Postproc batch from a different factal provided\")\n\n # Input data\n calc_name = postproc_batch.calc_name\n chunk_mask, Z, U, stop_reason, stop_iter = self.reload_data(\n chunk_slice, calc_name)\n # View casting Z as extended-range if needed\n if self.Xrange_complex_type:\n Z = Z.view(fsx.Xrange_array)\n\n params, codes = self.reload_params(calc_name)\n complex_dic, int_dic, termination_dic = self.codes_mapping(*codes)\n postproc_batch.set_chunk_data(chunk_slice, chunk_mask, Z, U,\n stop_reason, stop_iter, complex_dic, int_dic, termination_dic)\n\n # Output data\n n_pts = Z.shape[1] # Z of shape [n_Z, n_pts]\n post_array = np.empty((len(postproc_batch.posts), n_pts),\n dtype=self.float_postproc_type)\n\n for i, postproc in enumerate(postproc_batch.posts.values()):\n\n val, context_update = postproc[chunk_slice]\n # Debug\n# if np.iscomplexobj(val):\n# raise ValueError(val, \"i\", i, postproc.key)\n post_array[i, :] = val\n postproc_batch.update_context(chunk_slice, context_update)\n\n postproc_batch.clear_chunk_data()\n\n return post_array, chunk_mask\n\n\n# Numba JIT functions =========================================================\n@numba.njit\ndef numba_cycles_perturb(Z, U, c, stop_reason, stop_iter, bool_active, iref,\n n_iter, SA_iter, ref_div_iter, ref_path, iterate,\n last_iref):\n \"\"\" Run the perturbation cycles\n \"\"\"\n npts = c.size\n n_iter_init = n_iter\n for ipt in range(npts):\n # skip this ipt if pixel not active\n if not(bool_active[ipt]):\n continue\n Zpt = Z[:, ipt]\n Upt = U[:, ipt]\n cpt = c[ipt]\n stop_pt = stop_reason[:, ipt]\n n_iter = n_iter_init\n cycling = True\n while cycling:\n n_iter += 1 \n iterate(Zpt, Upt, cpt, stop_pt, n_iter, SA_iter,\n ref_div_iter, ref_path[n_iter - 1 , :],\n ref_path[n_iter, :], last_iref)\n cycling = (stop_pt[0] == -1)\n if not(cycling):\n stop_iter[0, ipt] = n_iter\n stop_reason[0, ipt] = stop_pt[0]\n\n@numba.njit\ndef numba_cycles(Z, U, c, stop_reason, stop_iter, bool_active,\n n_iter, iterate):\n \"\"\" Run the standard cycles\n \"\"\"\n npts = c.size\n n_iter_init = n_iter\n for ipt in range(npts):\n # skip this ipt if pixel not active\n if not(bool_active[ipt]):\n continue\n Zpt = Z[:, ipt]\n Upt = U[:, ipt]\n cpt = c[ipt]\n stop_pt = stop_reason[:, ipt]\n n_iter = n_iter_init\n cycling = True\n while cycling:\n n_iter += 1 \n iterate(Zpt, Upt, cpt, stop_pt, n_iter)\n cycling = (stop_pt[0] == -1)\n if not(cycling):\n stop_iter[0, ipt] = n_iter\n stop_reason[0, ipt] = stop_pt[0]\n", "meta": {"hexsha": "7a025344944be81853088bb33d1b0b5131c9a63b", "size": 61759, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/fractalshades/core.py", "max_stars_repo_name": "GBillotey/Fractal-shades", "max_stars_repo_head_hexsha": "99c690cb1114ab7edcbfd9836af585fed2b133e8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-03-06T18:32:51.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-07T01:35:21.000Z", "max_issues_repo_path": "src/fractalshades/core.py", "max_issues_repo_name": "GBillotey/Fractal-shades", "max_issues_repo_head_hexsha": "99c690cb1114ab7edcbfd9836af585fed2b133e8", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/fractalshades/core.py", "max_forks_repo_name": "GBillotey/Fractal-shades", "max_forks_repo_head_hexsha": "99c690cb1114ab7edcbfd9836af585fed2b133e8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.9593058049, "max_line_length": 103, "alphanum_fraction": 0.57525219, "include": true, "reason": "import numpy,from numpy,import numba,import mpmath", "num_tokens": 14361, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5350984286266115, "lm_q2_score": 0.3593641588823761, "lm_q1q2_score": 0.19229519672268341}} {"text": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\n# TODO\n\"\"\"\n\n\"\"\"\n\nimport argparse\nimport json\n\nimport numpy as np\n\nimport apbs as apbs\nimport MDAnalysis as mda\n\n\ndef main(argdict):\n \"\"\" Main function for entry point checking.\n\n Expects a dictionary of command line arguments.\n \"\"\"\n\n # make sure ionic strength arrays have same length:\n if len(argdict[\"ionic_radii\"]) is not len(argdict[\"ionic_charges\"]):\n raise ValueError(\"need as many ionic_radii as ionic_charges\")\n if (\n len(argdict[\"ionic_concentrations\"])\n is not len(argdict[\"ionic_charges\"])\n ):\n raise ValueError(\"need as many ionic_concentrations as ionic_charges\")\n\n # make ionic parameters a list of tuples:\n ionic_params = zip(\n argdict[\"ionic_charges\"],\n argdict[\"ionic_concentrations\"],\n argdict[\"ionic_radii\"]\n )\n\n # make sure there are no signs in filename that apbs dislikes:\n if \"=\" in argdict[\"out_basename\"]:\n raise RuntimeError(\"out_basename may not contain '=' character\")\n\n # write log of the parameters used to call this script:\n logfile = argdict[\"out_basename\"] + \"_gromacs2apbs_logfile_.json\"\n with open(logfile, \"w\") as f:\n print(json.dumps(argdict, sort_keys=True, indent=4),\n file=f)\n\n # load input PQR file:\n u = mda.Universe(argdict[\"in_pqr\"])\n\n # select atoms for coarse and fine regions:\n sel_coarse = u.select_atoms(argdict[\"sel_coarse\"])\n sel_fine = u.select_atoms(argdict[\"sel_fine\"])\n\n # determine center of coarse and fine grid:\n cog_coarse = sel_coarse.center_of_geometry()\n cog_fine = sel_fine.center_of_geometry()\n\n # determine length of coarse and fine grid:\n # (scaling factor is used to ensure the boundary is far from the atoms)\n bb_coarse = sel_coarse.bbox()\n bb_fine = sel_fine.bbox()\n len_coarse = (bb_coarse[1] - bb_coarse[0]) * argdict[\"scale_coarse\"]\n len_fine = (bb_fine[1] - bb_fine[0]) * argdict[\"scale_fine\"]\n\n # estimate minimal integer constant that will ensure specified grid spacing:\n nlev = 4 # for mg-auto this is always 4!\n c = np.ceil((len_fine/argdict[\"grid_spacing\"] - 1)/(pow(2, nlev + 1)))\n\n # calculate number of grid points according to this:\n dime = c*pow(2, nlev + 1) + 1\n\n # write coarse selection to a PQR file:\n out_pqr_name = argdict[\"out_basename\"] + \"_.pqr\"\n sel_coarse.write(out_pqr_name)\n\n # will read data from the modified PQR file set up above:\n read_block = apbs.ApbsInputReadBlock()\n read_block.add_mol_input(\"pqr\", argdict[\"out_basename\"] + \"_.pqr\")\n\n # set up focusing finite difference calculation:\n elec_block = apbs.ApbsInputElecBlock()\n\n # which outputs to calculate and write out:\n elec_block.set_calcenergy(argdict[\"calc_energy\"])\n elec_block.set_calcforce(argdict[\"calc_force\"]) # requires spline surfaces\n elec_block.add_output(\n \"charge\", \"dx\", (argdict[\"out_basename\"] + \"_gridval-charge_\")\n )\n elec_block.add_output(\n \"pot\", \"dx\", (argdict[\"out_basename\"] + \"_gridval-potential_\")\n )\n elec_block.add_output(\n \"lap\", \"dx\", (argdict[\"out_basename\"] + \"_gridval-laplacian_\")\n )\n\n # grid size:\n elec_block.set_cgcent(list(cog_coarse))\n elec_block.set_cglen(list(len_coarse))\n elec_block.set_fgcent(list(cog_fine))\n elec_block.set_fglen(list(len_fine))\n elec_block.set_dime(dime[0], dime[1], dime[2])\n\n # methods to use and algorithmic parameters:\n elec_block.set_chgm(argdict[\"chgm\"])\n elec_block.set_pbetype(argdict[\"pbetype\"])\n elec_block.set_sdens(argdict[\"sdens\"])\n\n # physical parameters:\n elec_block.set_pdie(argdict[\"pdie\"])\n elec_block.set_sdie(argdict[\"sdie\"])\n elec_block.set_srad(argdict[\"srad\"])\n elec_block.set_temp(argdict[\"temp\"])\n\n # ionic strength:\n for charge, conc, radius in ionic_params:\n elec_block.add_ionic_species(charge, conc, radius)\n\n # molecules to consider:\n elec_block.set_mol(1)\n\n # will print energy to screen if it is calculated:\n if argdict[\"calc_energy\"] is \"total\":\n print_block = apbs.ApbsInputPrintBlock(\"elecEnergy\", 1)\n\n # write APBS input file:\n apbs_input = apbs.ApbsInput()\n apbs_input.add_block(read_block)\n apbs_input.add_block(elec_block)\n apbs_input.add_block(print_block)\n apbs_input.write(argdict[\"out_basename\"] + \"_.in\")\n\n\nif __name__ == \"__main__\":\n\n # parse command line arguments:\n parser = argparse.ArgumentParser(\n description=__doc__,\n formatter_class=argparse.ArgumentDefaultsHelpFormatter\n )\n\n parser.add_argument(\n \"-sel_coarse\",\n type=str,\n nargs=None,\n default=\"all and not resname SOL WAT HOH NA CL\",\n help=\"Selection of the system defining the coarse grid.\"\n )\n parser.add_argument(\n \"-sel_fine\",\n type=str,\n nargs=None,\n default=\"protein\",\n help=\"Selection of system defining the fine grid.\"\n )\n parser.add_argument(\n \"-scale_coarse\",\n type=float,\n nargs=None,\n default=1.75,\n help=\"Length coarse of grid will be this parameter times the bounding \"\n \"box of the coarse selection.\"\n )\n parser.add_argument(\n \"-scale_fine\",\n type=float,\n nargs=None,\n default=1.30,\n help=\"Length of fine grid will be this parameter times the bounding box\"\n \" of the fine selection.\"\n )\n parser.add_argument(\n \"-in_pqr\",\n type=str,\n nargs=None,\n default=\"production.pqr\",\n help=\"Input PQR file generated from a TPR file via editconf.\"\n )\n parser.add_argument(\n \"-out_basename\",\n type=str,\n nargs=None,\n default=\"apbs\",\n help=\"Base name for output files, to with .pqr or .in will be added as\"\n \" appropriate.\"\n )\n parser.add_argument(\n \"-calc_energy\",\n type=str,\n choices=[\"no\", \"total\", \"comps\"],\n nargs=1,\n default=\"total\",\n help=\"This optional keyword controls energy output from an apolar \"\n \"solvation calculation.\"\n )\n parser.add_argument(\n \"-calc_force\",\n type=str,\n choices=[\"no\", \"total\", \"comps\"],\n nargs=1,\n default=\"no\",\n help=\"This optional keyword controls force output from an apolar \"\n \"solvation calculation.\"\n )\n parser.add_argument(\n \"-pdie\",\n type=float,\n nargs=None,\n default=2.0,\n help=\"Specify the dielectric constant of the solute molecule. This is\"\n \" usually a value between 2 to 20, where lower values consider only\"\n \" electronic polarization and higher values consider additional\"\n \" polarization due to intramolecular motion.\"\n )\n parser.add_argument(\n \"-sdie\",\n type=float,\n nargs=None,\n default=78.5,\n help=\"Specify the dielectric constant of the solvent. Bulk water at\"\n \" biologically-relevant temperatures is usually modeled with a\"\n \" dielectric constant of 78-80.\"\n )\n parser.add_argument(\n \"-srad\",\n type=float,\n nargs=None,\n default=1.4,\n help=\"This keyword specifies the radius (in Å) of the solvent\"\n \" molecules; this parameter is used to define various solvent-related\"\n \" surfaces and volumes (see srfm (elec)). This value is usually set to\"\n \" 1.4 Å for a water-like molecular surface and set to 0 Å for a van der\"\n \" Waals surface.\"\n )\n parser.add_argument(\n \"-temp\",\n type=float,\n nargs=None,\n default=310,\n help=\"This keyword specifies the temperature (in K) for the\"\n \" calculation.\"\n )\n parser.add_argument(\n \"-ionic_charges\",\n type=float,\n nargs=\"+\",\n default=[+1, -1],\n help=\"Array of ionic species charges (in elementary charge). Must have\"\n \" same length as -ionic_concentrations and -ionic_radii. Default\"\n \" parameters are for physiological NaCl.\"\n )\n parser.add_argument(\n \"-ionic_concentrations\",\n type=float,\n nargs=\"+\",\n default=[0.150, 0.150],\n help=\"Array of ionic species concentrations (in M). Must have same\"\n \"length as -ionic_charges and -ionic_radii. Default parameters are for\"\n \"physiological NaCl.\"\n )\n parser.add_argument(\n \"-ionic_radii\",\n type=float,\n nargs=\"+\",\n default=[1.680, 1.937],\n help=\"Array of ionic species radii (in Å). Must have same length as\"\n \" -ionic_concentrations and -ionic_charges. Default parameters are for\"\n \" physiological NaCl.\"\n )\n parser.add_argument(\n \"-grid_spacing\",\n type=float,\n nargs=None,\n default=1.0,\n help=\"Desired spacing of points on the fine grid (in Å). The actual\"\n \" grid spacing is determined internally by APBS, which for numerical\"\n \" reasons needs a magical number of grid points in each dimension. This\"\n \" parameter will be used to ensure that there are at least as many grid\"\n \" points as is necessary for the grid spacing to be at least this fine\"\n \" (but it may be finer). The grid spacing is determined individually\"\n \" for each grid dimension. The coarse grid will use the same number of\"\n \" grid points, but with different edge lengths.\"\n )\n parser.add_argument(\n \"-chgm\",\n type=str,\n choices=[\"spl0\", \"spl2\", \"spl4\"],\n nargs=None,\n default=\"spl2\",\n help=\"Specify the method by which the biomolecular point charges (i.e.,\"\n \" Dirac delta functions) by which charges are mapped to the grid for a\"\n \" multigrid (mg-manual, mg-auto, mg-para) Poisson-Boltzmann\"\n \" calculation. As we are attempting to model delta functions, the\"\n \" support (domain) of these discretized charge distributions is always\"\n \" strongly dependent on the grid spacing.\"\n )\n parser.add_argument(\n \"-pbetype\",\n type=str,\n choices=[\"lpbe\", \"npbe\", \"lrpbe\", \"nrpbe\"],\n nargs=None,\n default=\"lpbe\", # TODO: default sensible?\n help=\"Which equation to solve: linearised Poisson-Boltzmann (lpbe),\"\n \" full (non-linear) Poisson-Boltzmann (npbe), or the respective\"\n \" regularised variants (lrpbe, nrpbe).\"\n )\n parser.add_argument(\n \"-sdens\",\n type=float,\n nargs=None,\n default=10.0,\n help=\"This keyword specifies the number of quadrature points per Å2 to\"\n \" use in calculation surface terms (e.g., molecular surface, solvent\"\n \" accessible surface). This keyword is ignored when srad is 0.0 (e.g.,\"\n \" for van der Waals surfaces) or when srfm (elec) is spl2 (e.g., for\"\n \" spline surfaces). A typical value is 10.0.\"\n )\n\n # parse arguments:\n args = parser.parse_args()\n argdict = vars(args)\n\n main(argdict)\n", "meta": {"hexsha": "b4691c46d8de64c0ac2bcedd1c345f04d4cf2e84", "size": 10957, "ext": "py", "lang": "Python", "max_stars_repo_path": "scripts/poisson-boltzmann/gromacs2apbs.py", "max_stars_repo_name": "Inniag/nanopore-electrowetting-scripts", "max_stars_repo_head_hexsha": "5539a2b6f7b06ae8b386cf3cb1d9b9bce2c5828f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-01-24T17:09:36.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-24T17:09:36.000Z", "max_issues_repo_path": "scripts/poisson-boltzmann/gromacs2apbs.py", "max_issues_repo_name": "Inniag/nanopore-electrowetting-scripts", "max_issues_repo_head_hexsha": "5539a2b6f7b06ae8b386cf3cb1d9b9bce2c5828f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "scripts/poisson-boltzmann/gromacs2apbs.py", "max_forks_repo_name": "Inniag/nanopore-electrowetting-scripts", "max_forks_repo_head_hexsha": "5539a2b6f7b06ae8b386cf3cb1d9b9bce2c5828f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-11-28T13:52:33.000Z", "max_forks_repo_forks_event_max_datetime": "2020-11-28T13:52:33.000Z", "avg_line_length": 33.6104294479, "max_line_length": 80, "alphanum_fraction": 0.6327461897, "include": true, "reason": "import numpy", "num_tokens": 2714, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5350984137988773, "lm_q2_score": 0.35936415888237616, "lm_q1q2_score": 0.19229519139412724}} {"text": "# -*- coding: UTF-8 -*-\nimport os\nimport time\nimport numpy as np\nimport tensorflow as tf\nfrom scipy.optimize import fmin_ncg\n\nfrom my_utils import load_data_for_HGNN\nfrom hessians import hessian_vector_product\n\n\ndef add_layer(input_data, in_size, out_size, act_func=None, name=None):\n weights = tf.Variable(tf.random.normal([in_size, out_size]), name=name + '_weight')\n biases = tf.Variable(tf.random.normal([1, out_size]) + 0.001, name=name + '_biases')\n result = tf.matmul(input_data, weights) + biases\n if act_func is None:\n outputs = result\n else:\n outputs = act_func(result)\n return outputs\n\n\n# def geo_eval(y_pred, U_ture, classLatMedian, classLonMedian, userLocation):\n#\n# assert len(y_pred) == len(U_ture), \"#preds: %d, #users: %d\" % (len(y_pred), len(U_ture))\n#\n# distances = []\n# latlon_pred = []\n# latlon_true = []\n# for i in range(0, len(y_pred)):\n# user = U_ture[i]\n# location = userLocation[user].split(',')\n# lat, lon = float(location[0]), float(location[1])\n# latlon_true.append([lat, lon])\n# prediction = str(y_pred[i])\n# lat_pred, lon_pred = classLatMedian[prediction], classLonMedian[prediction]\n# latlon_pred.append([lat_pred, lon_pred, y_pred[i]])\n# distance = haversine((lat, lon), (lat_pred, lon_pred))\n# distances.append(distance)\n#\n# acc_at_161 = 100 * len([d for d in distances if d < 161]) / float(len(distances))\n# # return np.mean(distances), np.median(distances), acc_at_161, distances, latlon_true, latlon_pred\n# return np.mean(distances), np.median(distances), acc_at_161, distances, latlon_true, latlon_pred\n\n\n\"\"\" load data for HGNN model \"\"\"\ndump_file = \"../data/cmu/dump_doc_dim_128_for_hgnn.pkl\"\ndata = load_data_for_HGNN(dump_file, feature_norm='None')\n(adj, features, labels, idx_train, idx_val, idx_test, U_train, U_dev, U_test,\n classLatMedian, classLonMedian, userLocation, cluster_nodes, cluster_adj, node2cluster_arr) = data\n\n\"\"\" HGNN + influence by using tensorflow. \"\"\"\nlearning_rate = 0.01\ngraph_emb_size = 128\ncontent_emb_size = 512\nclass_num = 129\ntraining_epochs = 100\ndisplay_epoch = 10\npatience = 10\n\nx_input = tf.compat.v1.placeholder(tf.float32, [None, content_emb_size], name='contentEmbedding')\ny_label = tf.compat.v1.placeholder(tf.int64, [None, class_num], name='LabelData')\n\nhidden_1 = add_layer(x_input, content_emb_size, 512, act_func=tf.nn.relu, name='MLP_1')\noutput_x = add_layer(hidden_1, 512, class_num, act_func=None, name='MLP_2')\n\nloss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(labels=y_label, logits=output_x))\n\noptimizer = tf.compat.v1.train.AdamOptimizer(learning_rate).minimize(loss)\n\npred = tf.argmax(output_x, axis=1)\nacc = tf.equal(tf.argmax(output_x, 1), tf.argmax(y_label, 1))\nacc = tf.reduce_mean(tf.cast(acc, tf.float32))\n\n'''calculate influence '''\nall_params = tf.compat.v1.trainable_variables()\nparams = [tf.compat.v1.trainable_variables()[2]] # only last layer's params\ngradients = tf.gradients(loss, params)\nv_placeholder = params\nhessian_vector = hessian_vector_product(loss, params, v_placeholder)\n'''calculate influence '''\n\n# Initialize the variables (i.e. assign their default value)\ninit = tf.compat.v1.global_variables_initializer()\n\n# 'Saver' op to save and restore all the variables\nsaver = tf.compat.v1.train.Saver()\n\n\ndef get_influence(test_x, test_y):\n # Done --> predicted_loss_diffs == First step：S test(for test point which interested)、\n # Done --> Second step：I up,loss(calculate the effect of each training point)\n inverse_hvp = get_inverse_hvp_cg(get_test_grad_loss(test_x, test_y)[0])\n\n num_to_remove = len(idx_train)\n predicted_loss_diffs = list()\n for idx_to_remove in range(0, num_to_remove):\n single_train_feed_dict = fill_feed_dict_with_one_ex(idx_to_remove)\n train_grad_loss_val = sess.run(gradients, feed_dict=single_train_feed_dict)\n predicted_loss_diffs.append(np.dot(inverse_hvp, train_grad_loss_val[0].flatten()) / num_to_remove)\n return np.array(predicted_loss_diffs)\n\n\ndef get_test_grad_loss(test_x, test_y):\n return sess.run(gradients, {x_input: test_x, y_label: test_y})\n\n\ndef get_inverse_hvp_cg(v):\n fmin_loss_fn = get_fmin_loss_fn(v)\n fmin_grad_fn = get_fmin_grad_fn(v)\n\n fmin_results = fmin_ncg(\n f=fmin_loss_fn,\n x0=np.concatenate(v),\n fprime=fmin_grad_fn, # gradient\n fhess_p=get_fmin_hvp,\n callback=None,\n avextol=1e-8,\n maxiter=20)\n\n return get_vec_to_list_fn()(fmin_results)\n\n\ndef get_fmin_loss_fn(v):\n def get_fmin_loss(x):\n hessian_vector_val = minibatch_hessian_vector_val(get_vec_to_list_fn()(x))\n\n return 0.5 * np.dot(np.concatenate(hessian_vector_val), x) - np.dot(np.concatenate(v), x)\n\n return get_fmin_loss\n\n\ndef get_fmin_grad_fn(v):\n def get_fmin_grad(x):\n hessian_vector_val = minibatch_hessian_vector_val(get_vec_to_list_fn()(x))\n\n return np.concatenate(hessian_vector_val) - np.concatenate(v)\n\n return get_fmin_grad\n\n\ndef minibatch_hessian_vector_val(v):\n feed_dict = fill_feed_dict_with_all_ex()\n # Can optimize this\n feed_dict = update_feed_dict_with_v_placeholder(feed_dict, v)\n hessian_vector_val = sess.run(hessian_vector, feed_dict=feed_dict)\n hessian_vector_val = np.reshape(hessian_vector_val,\n np.shape(hessian_vector_val[0])[0] * np.shape(hessian_vector_val[0])[1])\n return [hessian_vector_val]\n\n\ndef get_fmin_hvp(x, p):\n hessian_vector_val = minibatch_hessian_vector_val(get_vec_to_list_fn()(p))\n\n return np.concatenate(hessian_vector_val)\n\n\ndef fill_feed_dict_with_all_ex():\n feed_dict = {\n x_input: features[idx_train],\n y_label: get_one_hot(labels[idx_train])\n }\n return feed_dict\n\n\ndef fill_feed_dict_with_one_ex(target_idx):\n feed_dict = {\n x_input: [features[target_idx]],\n y_label: get_one_hot([labels[target_idx]])\n }\n return feed_dict\n\n\ndef update_feed_dict_with_v_placeholder(feed_dict, vec):\n for pl_block, vec_block in zip(v_placeholder, [np.reshape(vec, v_placeholder[0].get_shape())]):\n feed_dict[pl_block] = vec_block\n return feed_dict\n\n\ndef get_vec_to_list_fn():\n def vec_to_list(v):\n return v\n\n return vec_to_list\n\n\ndef get_one_hot(y_label):\n one_hot_index = np.arange(len(y_label)) * class_num + y_label\n one_hot = np.zeros((len(y_label), class_num))\n one_hot.flat[one_hot_index] = 1\n return one_hot\n\n\n\"\"\" start running the framework ...\"\"\"\ntf_config = tf.compat.v1.ConfigProto()\ntf_config.gpu_options.per_process_gpu_memory_fraction = 0.5 # 分配50%\ntf_config.gpu_options.allow_growth = True # 自适应\nos.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'\n\n\"\"\"\"for each test sample, calculate it's influence on each training sample, i.e. inf_of_a_test_point\"\"\"\nfeatures_test, labels_test = features[idx_test], labels[idx_test]\nerror_index = list() # !!! store the error index which should rerun after.\nfor i in range(0, len(idx_test)):\n with tf.compat.v1.Session(config=tf_config) as sess:\n sess.run(init)\n try:\n inf_of_a_test_point = get_influence([features_test[i]], get_one_hot([labels_test[i]]))\n except Exception:\n error_index.append(i)\n print(\"-----------------------------------------There is a RuntimeWarning at index:\", i)\n with open(\"./error_index.txt\", 'a') as f:\n f.write(\"\\nTime:\" + str(time.asctime(time.localtime(time.time()))) + \"\\t\\tError_at_index:\" + str(i))\n continue\n else:\n np.savetxt(\"./Res_inf_HGNN/inf_of_a_test_point{}.txt\".format(i), inf_of_a_test_point)\n print(\"Time:\", time.asctime(time.localtime(time.time())),\n \"has done ---------------------------- {}\".format(i))\n\n# show and save the whole error_index\nerror_index_str = \"\\n\\nTime:\" + str(time.asctime(time.localtime(time.time()))) + \\\n \" \\t\\tModel:HGNN \\nAll_Error_index:\" + str(error_index)\nprint(error_index_str)\nwith open(\"./error_index.txt\", 'a') as f:\n f.write(error_index_str)\n", "meta": {"hexsha": "a6d4b47428f8ccc6fc36e58c71bc900d54ca2f78", "size": 8122, "ext": "py", "lang": "Python", "max_stars_repo_path": "influence/main_HGNN_inf.py", "max_stars_repo_name": "duzhizhai/HGNN", "max_stars_repo_head_hexsha": "1d219f9eb773e0d2f585295d6fc13c2eb093d908", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "influence/main_HGNN_inf.py", "max_issues_repo_name": "duzhizhai/HGNN", "max_issues_repo_head_hexsha": "1d219f9eb773e0d2f585295d6fc13c2eb093d908", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "influence/main_HGNN_inf.py", "max_forks_repo_name": "duzhizhai/HGNN", "max_forks_repo_head_hexsha": "1d219f9eb773e0d2f585295d6fc13c2eb093d908", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.0977777778, "max_line_length": 116, "alphanum_fraction": 0.6972420586, "include": true, "reason": "import numpy,from scipy", "num_tokens": 2097, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5350984286266116, "lm_q2_score": 0.35936414516010196, "lm_q1q2_score": 0.1922951893799161}} {"text": "class class_FibersData:\n def __init__(self, endo_fiber_angle,epi_fiber_angle,endo_beta_angle,epi_beta_angle,gamma_angle):\n self.endo_fiber_angle = endo_fiber_angle\n self.epi_fiber_angle = epi_fiber_angle\n self.endo_beta_angle = endo_beta_angle\n self.epi_beta_angle = epi_beta_angle\n self.gamma_angle = gamma_angle\n\nclass matParameters:\n def __init__(self, a_iso, b_iso, a_f, b_f, a_s, b_s, a_fs, b_fs, k):\n self.a_iso = a_iso\n self.b_iso = b_iso\n self.a_f = a_f\n self.b_f = b_f\n self.a_s = a_s\n self.b_s = b_s\n self.a_fs = a_fs\n self.b_fs = b_fs\n self.k = k\n\ndef LoadModelAnatomy(vtk_mean):\n\n import numpy as np\n import vtk\n from vtk.util.numpy_support import vtk_to_numpy\n\n reader = vtk.vtkUnstructuredGridReader()\n reader.SetFileName(vtk_mean)\n reader.ReadAllScalarsOn()\n reader.ReadAllVectorsOn()\n reader.Update()\n data = reader.GetOutput()\n\n n_points = data.GetNumberOfPoints()\n n_el = data.GetNumberOfCells()\n Coords = vtk_to_numpy(data.GetPoints().GetData())\n Els = np.zeros((n_el,4),dtype=int)\n for i in range(n_el):\n cell_type = data.GetCellType(i)\n n_nodes_el = data.GetCell(i).GetPointIds().GetNumberOfIds()\n for n_sel in range(n_nodes_el):\n Els[i,n_sel] = int(data.GetCell(i).GetPointId(n_sel))\n\n labels = vtk_to_numpy(data.GetPointData().GetArray('labels'))\n x_c = vtk_to_numpy(data.GetPointData().GetArray('x_c'))\n x_l = vtk_to_numpy(data.GetPointData().GetArray('x_l'))\n x_t = vtk_to_numpy(data.GetPointData().GetArray('x_t'))\n e_c = vtk_to_numpy(data.GetPointData().GetVectors('e_c'))\n e_l = vtk_to_numpy(data.GetPointData().GetVectors('e_l'))\n e_t = vtk_to_numpy(data.GetPointData().GetVectors('e_t'))\n\n Node_par_coords = np.zeros((n_points,4))\n Node_par_coords[:,0] = labels\n Node_par_coords[:,1] = x_c\n Node_par_coords[:,2] = x_l\n Node_par_coords[:,3] = x_t\n\n faces_connectivity = np.array([[0,2,1],[0,1,3],[1,2,3],[2,0,3]])\n Faces_Endo = []\n start_faces = True\n for kk in range(n_el):\n el_points = Els[kk,:]\n for jj in range(4):\n if all(labels[int(v)] == 2 for v in el_points[faces_connectivity[jj]]):\n if start_faces:\n Faces_Endo = np.array(el_points[faces_connectivity[jj]],dtype=int).reshape(1,-1)\n start_faces = False\n else:\n Faces_Endo = np.concatenate((Faces_Endo,np.array(el_points[faces_connectivity[jj]],dtype=int).reshape(1,-1)),0)\n\n return Coords, Els, n_points, n_el, Node_par_coords, e_t, e_l, e_c, Faces_Endo\n\ndef GenerateNodalAreas(Faces_Endo,Coords):\n\n import numpy as np\n \n Nodal_area = np.zeros((Coords.shape[0],3))\n for jj in range(Faces_Endo.shape[0]):\n area_vector = 0.5*(np.cross(Coords[Faces_Endo[jj][1],:]-Coords[Faces_Endo[jj][0],:],Coords[Faces_Endo[jj][2],:]-Coords[Faces_Endo[jj][0],:]))\n for ll in range(3):\n Nodal_area[Faces_Endo[jj][ll],:] += area_vector/3.0\n return Nodal_area\n\ndef GradientOperator_AvgBased(Coords,Els,Node_par_coords):\n # Claudio Mancinellia , Marco Livesub and Enrico Puppoa (2019), \n # A Comparison of Methods for Gradient Field Estimation on Simplicial Meshes\n # in Computers & Graphics (80), 37-50, doi.org/10.1016/j.cag.2019.03.005 \n\n import numpy as np\n\n n_el = Els.shape[0]\n n_points = Coords.shape[0]\n\n Vol_el = np.zeros((n_el,1))\n Nodal_volume = np.zeros((n_points,1))\n\n dFcdx = np.zeros((n_el,n_points))\n dFcdy = np.zeros((n_el,n_points))\n dFcdz = np.zeros((n_el,n_points))\n\n dFdx = np.zeros((n_points,n_points))\n dFdy = np.zeros((n_points,n_points))\n dFdz = np.zeros((n_points,n_points))\n\n W = np.zeros((n_points,n_el))\n\n for sel_el in range(n_el):\n AA = np.zeros((3,3))\n AA[0,0] = Coords[Els[sel_el,1],0] - Coords[Els[sel_el,0],0]\n AA[0,1] = Coords[Els[sel_el,1],1] - Coords[Els[sel_el,0],1]\n AA[0,2] = Coords[Els[sel_el,1],2] - Coords[Els[sel_el,0],2]\n AA[1,0] = Coords[Els[sel_el,2],0] - Coords[Els[sel_el,0],0]\n AA[1,1] = Coords[Els[sel_el,2],1] - Coords[Els[sel_el,0],1]\n AA[1,2] = Coords[Els[sel_el,2],2] - Coords[Els[sel_el,0],2]\n AA[2,0] = Coords[Els[sel_el,3],0] - Coords[Els[sel_el,0],0]\n AA[2,1] = Coords[Els[sel_el,3],1] - Coords[Els[sel_el,0],1]\n AA[2,2] = Coords[Els[sel_el,3],2] - Coords[Els[sel_el,0],2]\n\n invA = np.linalg.inv(AA)\n\n dFcdx[sel_el,Els[sel_el,0]] = - np.sum(invA[0,:])\n dFcdx[sel_el,Els[sel_el,1]] = invA[0,0]\n dFcdx[sel_el,Els[sel_el,2]] = invA[0,1]\n dFcdx[sel_el,Els[sel_el,3]] = invA[0,2]\n\n dFcdy[sel_el,Els[sel_el,0]] = -np.sum(invA[1,:])\n dFcdy[sel_el,Els[sel_el,1]] = invA[1,0]\n dFcdy[sel_el,Els[sel_el,2]] = invA[1,1]\n dFcdy[sel_el,Els[sel_el,3]] = invA[1,2]\n\n dFcdz[sel_el,Els[sel_el,0]] = -np.sum(invA[2,:])\n dFcdz[sel_el,Els[sel_el,1]] = invA[2,0]\n dFcdz[sel_el,Els[sel_el,2]] = invA[2,1]\n dFcdz[sel_el,Els[sel_el,3]] = invA[2,2]\n\n # dFcdx, dFcdy,dFcdz are correct, validated with FEniCs and relative errors are around 10-5\n # only at apex they are around 1% (mesh distortion)\n\n # Volume weighted projection\n for i in range(n_el):\n Vol_el[i] = 1.0/6.0*abs((Coords[Els[i,3],:]-Coords[Els[i,0],:]).dot( np.cross(Coords[Els[i,2],:]-Coords[Els[i,0],:],Coords[Els[i,1],:]-Coords[Els[i,0],:])))\n for n_sel in Els[i]:\n Nodal_volume[n_sel] += Vol_el[i]/4.0\n\n for i in range(n_points):\n Els_per_node = np.where(Els == i)[0]\n\n for sel_el in Els_per_node: \n dFdx[i,:] += dFcdx[sel_el,:].copy()*Vol_el[sel_el]/4.0/Nodal_volume[i]\n dFdy[i,:] += dFcdy[sel_el,:].copy()*Vol_el[sel_el]/4.0/Nodal_volume[i]\n dFdz[i,:] += dFcdz[sel_el,:].copy()*Vol_el[sel_el]/4.0/Nodal_volume[i]\n\n return dFcdx, dFcdy, dFcdz,dFdx, dFdy, dFdz, Nodal_volume,Vol_el\n\ndef LoadPODmodes_FunctionalModel(POD_folder,n_modes):\n\n import sys,os\n import numpy as np\n\n snapshots = np.sort(next(os.walk(POD_folder))[2])\n n_snapshots = len(snapshots)-1\n n_modes = np.min([n_modes,n_snapshots])\n\n for m_sel in range(n_modes):\n Phi_matrix = np.load(POD_folder+'/Phi'+str(m_sel)+'_points.npy')\n if m_sel == 0:\n PHI = np.concatenate((Phi_matrix[:,0].reshape(-1,1),Phi_matrix[:,1].reshape(-1,1),Phi_matrix[:,2].reshape(-1,1)),0)\n else:\n pp_sel = np.concatenate((Phi_matrix[:,0].reshape(-1,1),Phi_matrix[:,1].reshape(-1,1),Phi_matrix[:,2].reshape(-1,1)),0)\n PHI = np.concatenate((PHI,pp_sel),1)\n\n if os.path.isfile(POD_folder+'/Amplitudes_min_max.txt'):\n amplitudes = np.loadtxt(POD_folder+'/Amplitudes_min_max.txt')\n return PHI,n_modes, amplitudes[:n_modes,:]\n elif os.path.isfile(POD_folder+'/Amplitude_range.txt'):\n amplitudes = np.loadtxt(POD_folder+'/Amplitude_range.txt')\n return PHI,n_modes, amplitudes[:n_modes,:]\n else:\n return PHI,n_modes, 0.0\n\ndef GenerateFibers(e_t_vector,e_l_vector,e_c_vector,Node_par_coords,FiberData):\n\n import numpy as np\n\n n_points = Node_par_coords.shape[0]\n\n fx = np.zeros((n_points,1))\n fy = np.zeros((n_points,1))\n fz = np.zeros((n_points,1))\n\n sx = np.zeros((n_points,1))\n sy = np.zeros((n_points,1))\n sz = np.zeros((n_points,1))\n\n # Normalize fibers\n for i in range(n_points):\n x_c = Node_par_coords[i,1]\n x_l = Node_par_coords[i,2]\n x_t = Node_par_coords[i,3]\n e_c = e_c_vector[i,:]\n e_l = e_l_vector[i,:]\n e_t = e_t_vector[i,:]\n\n e_c = e_c/np.linalg.norm(e_c)\n e_t = np.cross(e_c,e_l)\n e_t = e_t/np.linalg.norm(e_t)\n e_l = e_l - np.dot(e_c,e_l)*e_c\n e_l = e_l/np.linalg.norm(e_l)\n\n alfa_angle = np.pi/180.0*(FiberData.epi_fiber_angle*x_t + FiberData.endo_fiber_angle*(1.0 - x_t))\n gamma_angle = FiberData.gamma_angle*np.pi/180.0\n\n vf_dir = np.cos(alfa_angle)*e_c + np.sin(alfa_angle)*e_l\n vf_dir = vf_dir/np.linalg.norm(vf_dir)\n vs0_dir = - np.cos(gamma_angle)*e_t + np.sin(gamma_angle)*e_l\n if np.linalg.norm(vs0_dir) > 0:\n vs_dir = vs0_dir/np.linalg.norm(vs0_dir)\n else:\n vs_dir = vs_0_dir\n vs_dir = vs_dir - np.dot(vf_dir,vs_dir)*vf_dir\n vs_dir = vs_dir / np.linalg.norm(vs_dir)\n\n fx[i] = vf_dir[0]\n fy[i] = vf_dir[1]\n fz[i] = vf_dir[2]\n sx[i] = vs_dir[0]\n sy[i] = vs_dir[1]\n sz[i] = vs_dir[2]\n\n return fx[:,0],fy[:,0],fz[:,0],sx[:,0],sy[:,0],sz[:,0]\n\ndef WriteFibers2VTK(Coords,Els,fx,fy,fz,sx,sy,sz,out_file):\n import numpy as np\n\n outFile = open(out_file,'w')\n outFile.write('# vtk DataFile Version 4.0\\n')\n outFile.write('vtk output\\n')\n outFile.write('ASCII\\n')\n outFile.write('DATASET UNSTRUCTURED_GRID \\n')\n outFile.write('POINTS '+str(Coords.shape[0])+' float\\n')\n for j in range(Coords.shape[0]):\n outFile.write(str(Coords[j,0])+' ')\n outFile.write(str(Coords[j,1])+' ')\n outFile.write(str(Coords[j,2])+' ')\n outFile.write('\\n')\n outFile.write( 'CELLS ' + str( Els.shape[0] ) + ' ' + str( (Els.shape[0]) * 5 ) )\n outFile.write('\\n')\n for k in range( Els.shape[0] ):\n outFile.write( '4 ' )\n for j in range( 4 ):\n outFile.write( str( Els[k,j]) + ' ' )\n outFile.write('\\n')\n # write cell types\n outFile.write( '\\n\\nCELL_TYPES ' + str( Els.shape[0] ) )\n for k in range( Els.shape[0] ):\n outFile.write( '\\n10' )\n outFile.write('\\nPOINT_DATA '+str(Coords.shape[0])+'\\n')\n outFile.write('VECTORS f float \\n')\n for k in range(Coords.shape[0]):\n outFile.write(str(fx[k])+' '+str(fy[k])+' '+str(fz[k])+' '+'\\n')\n outFile.write('VECTORS s float \\n')\n for k in range(Coords.shape[0]):\n outFile.write(str(sx[k])+' '+str(sy[k])+' '+str(sz[k])+' '+'\\n')\n outFile.close()\n return 0", "meta": {"hexsha": "fcbbdb9d47182c62ef6e1d4bac0261b1eb39d26d", "size": 10159, "ext": "py", "lang": "Python", "max_stars_repo_path": "DeepCardioFunctions.py", "max_stars_repo_name": "sbuoso/Cardio-PINN", "max_stars_repo_head_hexsha": "c3215d91e0a637aaf6f3faf63c780dcb24141468", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2021-04-24T17:23:23.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-12T17:12:09.000Z", "max_issues_repo_path": "DeepCardioFunctions.py", "max_issues_repo_name": "sbuoso/Cardio-PINN", "max_issues_repo_head_hexsha": "c3215d91e0a637aaf6f3faf63c780dcb24141468", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "DeepCardioFunctions.py", "max_forks_repo_name": "sbuoso/Cardio-PINN", "max_forks_repo_head_hexsha": "c3215d91e0a637aaf6f3faf63c780dcb24141468", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-07-28T08:52:21.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-12T17:34:50.000Z", "avg_line_length": 38.3358490566, "max_line_length": 164, "alphanum_fraction": 0.6044886308, "include": true, "reason": "import numpy", "num_tokens": 3391, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5350984137988772, "lm_q2_score": 0.35936415202123906, "lm_q1q2_score": 0.1922951877227436}} {"text": "# -*- coding: utf-8 -*-\n# vim: tabstop=4 shiftwidth=4 softtabstop=4\n#\n# Copyright (C) 2012-2018 GEM Foundation\n#\n# OpenQuake is free software: you can redistribute it and/or modify it\n# under the terms of the GNU Affero General Public License as published\n# by the Free Software Foundation, either version 3 of the License, or\n# (at your option) any later version.\n#\n# OpenQuake is distributed in the hope that it will be useful,\n# but WITHOUT ANY WARRANTY; without even the implied warranty of\n# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n# GNU Affero General Public License for more details.\n#\n# You should have received a copy of the GNU Affero General Public License\n# along with OpenQuake. If not, see .\n\n\"\"\"\nModule exports :class:`ChiouYoungs2014`.\n\"\"\"\nimport numpy as np\nimport math\n\nfrom openquake.hazardlib.gsim.base import GMPE, CoeffsTable\nfrom openquake.hazardlib import const\nfrom openquake.hazardlib.imt import PGA, PGV, SA\n\n\nclass ChiouYoungs2014(GMPE):\n \"\"\"\n Implements GMPE developed by Brian S.-J. Chiou and Robert R. Youngs\n and published as \"Updated of the Chiou and Youngs NGA Model for the\n Average Horizontal Component of Peak Ground Motion and Response Spectra\"\n (2014, Earthquake Spectra).\n \"\"\"\n #: Supported tectonic region type is active shallow crust\n DEFINED_FOR_TECTONIC_REGION_TYPE = const.TRT.ACTIVE_SHALLOW_CRUST\n\n #: Supported intensity measure types are spectral acceleration,\n #: peak ground velocity and peak ground acceleration\n DEFINED_FOR_INTENSITY_MEASURE_TYPES = set([\n PGA,\n PGV,\n SA\n ])\n\n #: Supported intensity measure component is orientation-independent\n #: measure :attr:`~openquake.hazardlib.const.IMC.RotD50`,\n DEFINED_FOR_INTENSITY_MEASURE_COMPONENT = const.IMC.RotD50\n\n #: Supported standard deviation types are inter-event, intra-event\n #: and total, see chapter \"Variance model\".\n DEFINED_FOR_STANDARD_DEVIATION_TYPES = set([\n const.StdDev.TOTAL,\n const.StdDev.INTER_EVENT,\n const.StdDev.INTRA_EVENT\n ])\n\n #: Required site parameters are Vs30, Vs30 measured flag\n #: and Z1.0.\n REQUIRES_SITES_PARAMETERS = set(('vs30', 'vs30measured', 'z1pt0'))\n\n #: Required rupture parameters are magnitude, rake,\n #: dip and ztor.\n REQUIRES_RUPTURE_PARAMETERS = set(('dip', 'rake', 'mag', 'ztor'))\n\n #: Required distance measures are RRup, Rjb and Rx.\n REQUIRES_DISTANCES = set(('rrup', 'rjb', 'rx'))\n\n def get_mean_and_stddevs(self, sites, rup, dists, imt, stddev_types):\n \"\"\"\n See :meth:`superclass method\n <.base.GroundShakingIntensityModel.get_mean_and_stddevs>`\n for spec of input and result values.\n \"\"\"\n # extracting dictionary of coefficients specific to required\n # intensity measure type.\n C = self.COEFFS[imt]\n # intensity on a reference soil is used for both mean\n # and stddev calculations.\n ln_y_ref = self._get_ln_y_ref(rup, dists, C)\n # exp1 and exp2 are parts of eq. 12 and eq. 13,\n # calculate it once for both.\n exp1 = np.exp(C['phi3'] * (sites.vs30.clip(-np.inf, 1130) - 360))\n exp2 = np.exp(C['phi3'] * (1130 - 360))\n mean = self._get_mean(sites, C, ln_y_ref, exp1, exp2)\n stddevs = self._get_stddevs(sites, rup, C, stddev_types,\n ln_y_ref, exp1, exp2)\n\n return mean, stddevs\n\n def _get_mean(self, sites, C, ln_y_ref, exp1, exp2):\n \"\"\"\n Add site effects to an intensity.\n\n Implements eq. 13b.\n \"\"\"\n # we do not support estimating of basin depth and instead\n # rely on it being available (since we require it).\n # centered_z1pt0\n centered_z1pt0 = self._get_centered_z1pt0(sites)\n # we consider random variables being zero since we want\n # to find the exact mean value.\n eta = epsilon = 0.\n\n ln_y = (\n # first line of eq. 12\n ln_y_ref + eta\n # second line\n + C['phi1'] * np.log(sites.vs30 / 1130).clip(-np.inf, 0)\n # third line\n + C['phi2'] * (exp1 - exp2)\n * np.log((np.exp(ln_y_ref) * np.exp(eta) + C['phi4']) / C['phi4'])\n # fourth line\n + C['phi5']\n * (1.0 - np.exp(-1. * centered_z1pt0 / C['phi6']))\n # fifth line\n + epsilon\n )\n\n return ln_y\n\n def _get_stddevs(self, sites, rup, C, stddev_types, ln_y_ref, exp1, exp2):\n \"\"\"\n Get standard deviation for a given intensity on reference soil.\n\n Implements equations 13 for inter-event, intra-event\n and total standard deviations.\n \"\"\"\n Fmeasured = sites.vs30measured\n Finferred = 1 - sites.vs30measured\n\n # eq. 13 to calculate inter-event standard error\n mag_test = min(max(rup.mag, 5.0), 6.5) - 5.0\n tau = C['tau1'] + (C['tau2'] - C['tau1']) / 1.5 * mag_test\n\n # b and c coeffs from eq. 10\n b = C['phi2'] * (exp1 - exp2)\n c = C['phi4']\n\n y_ref = np.exp(ln_y_ref)\n # eq. 13\n NL = b * y_ref / (y_ref + c)\n sigma = ((C['sig1'] + (C['sig2'] - C['sig1']) * mag_test / 1.5)\n * np.sqrt((C['sig3'] * Finferred + 0.7 * Fmeasured) +\n (1. + NL) ** 2.))\n\n ret = []\n for stddev_type in stddev_types:\n assert stddev_type in self.DEFINED_FOR_STANDARD_DEVIATION_TYPES\n if stddev_type == const.StdDev.TOTAL:\n # eq. 13\n ret += [np.sqrt(((1 + NL) ** 2) * (tau ** 2) + (sigma ** 2))]\n elif stddev_type == const.StdDev.INTRA_EVENT:\n ret.append(sigma)\n elif stddev_type == const.StdDev.INTER_EVENT:\n # this is implied in eq. 21\n ret.append(np.abs((1 + NL) * tau))\n return ret\n\n def _get_ln_y_ref(self, rup, dists, C):\n \"\"\"\n Get an intensity on a reference soil.\n\n Implements eq. 13a.\n \"\"\"\n # reverse faulting flag\n Frv = 1. if 30 <= rup.rake <= 150 else 0.\n # normal faulting flag\n Fnm = 1. if -120 <= rup.rake <= -60 else 0.\n # hanging wall flag\n\n Fhw = np.zeros_like(dists.rx)\n idx = np.nonzero(dists.rx >= 0.)\n Fhw[idx] = 1.\n\n # a part in eq. 11\n mag_test1 = np.cosh(2. * max(rup.mag - 4.5, 0))\n\n # centered DPP\n centered_dpp = self._get_centered_cdpp(dists)\n # centered_ztor\n centered_ztor = self._get_centered_ztor(rup, Frv)\n #\n dist_taper = np.fmax(1 - (np.fmax(dists.rrup - 40,\n np.zeros_like(dists)) / 30.),\n np.zeros_like(dists))\n dist_taper = dist_taper.astype(np.float64)\n ln_y_ref = (\n # first part of eq. 11\n C['c1']\n + (C['c1a'] + C['c1c'] / mag_test1) * Frv\n + (C['c1b'] + C['c1d'] / mag_test1) * Fnm\n + (C['c7'] + C['c7b'] / mag_test1) * centered_ztor\n + (C['c11'] + C['c11b'] / mag_test1) *\n np.cos(math.radians(rup.dip)) ** 2\n # second part\n + C['c2'] * (rup.mag - 6)\n + ((C['c2'] - C['c3']) / C['cn'])\n * np.log(1 + np.exp(C['cn'] * (C['cm'] - rup.mag)))\n # third part\n + C['c4']\n * np.log(dists.rrup + C['c5']\n * np.cosh(C['c6'] * max(rup.mag - C['chm'], 0)))\n + (C['c4a'] - C['c4'])\n * np.log(np.sqrt(dists.rrup ** 2 + C['crb'] ** 2))\n # forth part\n + (C['cg1'] + C['cg2'] / (np.cosh(max(rup.mag - C['cg3'], 0))))\n * dists.rrup\n # fifth part\n + C['c8'] * dist_taper\n * min(max(rup.mag - 5.5, 0) / 0.8, 1.0)\n * np.exp(-1 * C['c8a'] * (rup.mag - C['c8b']) ** 2) * centered_dpp\n # sixth part\n + C['c9'] * Fhw * np.cos(math.radians(rup.dip)) *\n (C['c9a'] + (1 - C['c9a']) * np.tanh(dists.rx / C['c9b']))\n * (1 - np.sqrt(dists.rjb ** 2 + rup.ztor ** 2)\n / (dists.rrup + 1.0))\n )\n\n return ln_y_ref\n\n def _get_centered_z1pt0(self, sites):\n \"\"\"\n Get z1pt0 centered on the Vs30- dependent avarage z1pt0(m)\n California and non-Japan regions\n\n \"\"\"\n #: California and non-Japan regions\n\n mean_z1pt0 = (-7.15 / 4.) * np.log(((sites.vs30) ** 4. + 570.94 ** 4.)\n / (1360 ** 4. + 570.94 ** 4.))\n centered_z1pt0 = sites.z1pt0 - np.exp(mean_z1pt0)\n\n return centered_z1pt0\n\n def _get_centered_ztor(self, rup, Frv):\n \"\"\"\n Get ztor centered on the M- dependent avarage ztor(km)\n by different fault types.\n \"\"\"\n if Frv == 1:\n\n mean_ztor = max(2.704 - 1.226 * max(rup.mag - 5.849, 0.0), 0.) ** 2\n centered_ztor = rup.ztor - mean_ztor\n else:\n\n mean_ztor = max(2.673 - 1.136 * max(rup.mag - 4.970, 0.0), 0.) ** 2\n centered_ztor = rup.ztor - mean_ztor\n\n return centered_ztor\n\n def _get_centered_cdpp(self, dists):\n \"\"\"\n Get directivity prediction parameter centered on the avgerage\n directivity prediction parameter. Here we set the centered_dpp\n equals to zero, since the near fault directivity effect prediction is\n off in our calculation.\n\n \"\"\"\n centered_dpp = 0.\n\n return centered_dpp\n\n #: Coefficient tables are constructed from values in tables 1 - 5\n\n COEFFS = CoeffsTable(sa_damping=5, table=\"\"\"\\\nIMT c1 c1a c1b c1c c1d cn cm c2 c3 c4 c4a crb c5 chm c6 c7 c7b c8 c8a c8b c9 c9a c9b c11 c11b cg1 cg2 cg3 phi1 phi2 phi3 phi4 phi5 phi6 gjpit gwn phi1jp phi5jp phi6jp tau1 tau2 sig1 sig2 sig3 sig2jp\npga -1.5065 0.165 -0.255 -0.165 0.255 16.0875 4.9993 1.06 1.9636 -2.1 -0.5 50 6.4551 3.0956 0.4908 0.0352 0.0462 0. 0.2695 0.4833 0.9228 0.1202 6.8607 0. -0.4536 -0.007146 -0.006758 4.2542 -0.521 -0.1417 -0.00701 0.102151 0. 300 1.5817 0.7594 -0.6846 0.459 800. 0.4 0.26 0.4912 0.3762 0.8 0.4528\npgv 2.3549 0.165 -0.0626 -0.165 0.0626 3.3024 5.423 1.06 2.3152 -2.1 -0.5 50 5.8096 3.0514 0.4407 0.0324 0.0097 0.2154 0.2695 5. 0.3079 0.1 6.5 0 -0.3834 -0.001852 -0.007403 4.3439 -0.7936 -0.0699 -0.008444 5.41 0.0202 300. 2.2306 0.335 -0.7966 0.9488 800. 0.3894 0.2578 0.4785 0.3629 0.7504 0.3918\n0.01 -1.5065 0.165 -0.255 -0.165 0.255 16.0875 4.9993 1.06 1.9636 -2.1 -0.5 50 6.4551 3.0956 0.4908 0.0352 0.0462 0. 0.2695 0.4833 0.9228 0.1202 6.8607 0. -0.4536 -0.007146 -0.006758 4.2542 -0.521 -0.1417 -0.00701 0.102151 0. 300 1.5817 0.7594 -0.6846 0.459 800. 0.4 0.26 0.4912 0.3762 0.8 0.4528\n0.02 -1.4798 0.165 -0.255 -0.165 0.255 15.7118 4.9993 1.06 1.9636 -2.1 -0.5 50 6.4551 3.0963 0.4925 0.0352 0.0472 0. 0.2695 1.2144 0.9296 0.1217 6.8697 0. -0.4536 -0.007249 -0.006758 4.2386 -0.5055 -0.1364 -0.007279 0.10836 0. 300 1.574 0.7606 -0.6681 0.458 800. 0.4026 0.2637 0.4904 0.3762 0.8 0.4551\n0.03 -1.2972 0.165 -0.255 -0.165 0.255 15.8819 4.9993 1.06 1.9636 -2.1 -0.5 50 6.4551 3.0974 0.4992 0.0352 0.0533 0. 0.2695 1.6421 0.9396 0.1194 6.9113 0. -0.4536 -0.007869 -0.006758 4.2519 -0.4368 -0.1403 -0.007354 0.119888 0. 300 1.5544 0.7642 -0.6314 0.462 800. 0.4063 0.2689 0.4988 0.3849 0.8 0.4571\n0.04 -1.1007 0.165 -0.255 -0.165 0.255 16.4556 4.9993 1.06 1.9636 -2.1 -0.5 50 6.4551 3.0988 0.5037 0.0352 0.0596 0. 0.2695 1.9456 0.9661 0.1166 7.0271 0. -0.4536 -0.008316 -0.006758 4.296 -0.3752 -0.1591 -0.006977 0.133641 0. 300 1.5502 0.7676 -0.5855 0.453 800. 0.4095 0.2736 0.5049 0.391 0.8 0.4642\n0.05 -0.9292 0.165 -0.255 -0.165 0.255 17.6453 4.9993 1.06 1.9636 -2.1 -0.5 50 6.4551 3.1011 0.5048 0.0352 0.0639 0. 0.2695 2.181 0.9794 0.1176 7.0959 0. -0.4536 -0.008743 -0.006758 4.3578 -0.3469 -0.1862 -0.006467 0.148927 0. 300 1.5391 0.7739 -0.5457 0.436 800. 0.4124 0.2777 0.5096 0.3957 0.8 0.4716\n0.075 -0.658 0.165 -0.254 -0.165 0.254 20.1772 5.0031 1.06 1.9636 -2.1 -0.5 50 6.4551 3.1094 0.5048 0.0352 0.063 0. 0.2695 2.6087 1.026 0.1171 7.3298 0. -0.4536 -0.009537 -0.00619 4.5455 -0.3747 -0.2538 -0.005734 0.190596 0. 300 1.4804 0.7956 -0.4685 0.383 800. 0.4179 0.2855 0.5179 0.4043 0.8 0.5022\n0.1 -0.5613 0.165 -0.253 -0.165 0.253 19.9992 5.0172 1.06 1.9636 -2.1 -0.5 50 6.8305 3.2381 0.5048 0.0352 0.0532 0. 0.2695 2.9122 1.0177 0.1146 7.2588 0. -0.4536 -0.00983 -0.005332 4.7603 -0.444 -0.2943 -0.005604 0.230662 0. 300 1.4094 0.7932 -0.4985 0.375 800. 0.4219 0.2913 0.5236 0.4104 0.8 0.523\n0.12 -0.5342 0.165 -0.252 -0.165 0.252 18.7106 5.0315 1.06 1.9795 -2.1 -0.5 50 7.1333 3.3407 0.5048 0.0352 0.0452 0. 0.2695 3.1045 1.0008 0.1128 7.2372 0. -0.4536 -0.009913 -0.004732 4.8963 -0.4895 -0.3077 -0.005696 0.253169 0. 300 1.3682 0.7768 -0.5603 0.377 800. 0.4244 0.2949 0.527 0.4143 0.8 0.5278\n0.15 -0.5462 0.165 -0.25 -0.165 0.25 16.6246 5.0547 1.06 2.0362 -2.1 -0.5 50 7.3621 3.43 0.5045 0.0352 0.0345 0. 0.2695 3.3399 0.9801 0.1106 7.2109 0. -0.4536 -0.009896 -0.003806 5.0644 -0.5477 -0.3113 -0.005845 0.266468 0. 300 1.3241 0.7437 -0.6451 0.379 800. 0.4275 0.2993 0.5308 0.4191 0.8 0.5304\n0.17 -0.5858 0.165 -0.248 -0.165 0.248 15.3709 5.0704 1.06 2.0823 -2.1 -0.5 50 7.4365 3.4688 0.5036 0.0352 0.0283 0. 0.2695 3.4719 0.9652 0.115 7.2491 0. -0.4536 -0.009787 -0.00328 5.1371 -0.5922 -0.3062 -0.005959 0.26506 0. 300 1.3071 0.7219 -0.6981 0.38 800. 0.4292 0.3017 0.5328 0.4217 0.8 0.531\n0.2 -0.6798 0.165 -0.2449 -0.165 0.2449 13.7012 5.0939 1.06 2.1521 -2.1 -0.5 50 7.4972 3.5146 0.5016 0.0352 0.0202 0. 0.2695 3.6434 0.9459 0.1208 7.2988 0. -0.444 -0.009505 -0.00269 5.188 -0.6693 -0.2927 -0.006141 0.255253 0. 300 1.2931 0.6922 -0.7653 0.384 800. 0.4313 0.3047 0.5351 0.4252 0.8 0.5312\n0.25 -0.8663 0.165 -0.2382 -0.165 0.2382 11.2667 5.1315 1.06 2.2574 -2.1 -0.5 50 7.5416 3.5746 0.4971 0.0352 0.009 0. 0.2695 3.8787 0.9196 0.1208 7.3691 0. -0.3539 -0.008918 -0.002128 5.2164 -0.7766 -0.2662 -0.006439 0.231541 0. 300 1.315 0.6579 -0.8469 0.393 800. 0.4341 0.3087 0.5377 0.4299 0.7999 0.5309\n0.3 -1.0514 0.165 -0.2313 -0.165 0.2313 9.1908 5.167 1.06 2.344 -2.1 -0.5 50 7.56 3.6232 0.4919 0.0352 -0.0004 0. 0.2695 4.0711 0.8829 0.1175 6.8789 0. -0.2688 -0.008251 -0.001812 5.1954 -0.8501 -0.2405 -0.006704 0.207277 0.001 300 1.3514 0.6362 -0.8999 0.408 800. 0.4363 0.3119 0.5395 0.4338 0.7997 0.5307\n0.4 -1.3794 0.165 -0.2146 -0.165 0.2146 6.5459 5.2317 1.06 2.4709 -2.1 -0.5 50 7.5735 3.6945 0.4807 0.0352 -0.0155 0. 0.2695 4.3745 0.8302 0.106 6.5334 0. -0.1793 -0.007267 -0.001274 5.0899 -0.9431 -0.1975 -0.007125 0.165464 0.004 300 1.4051 0.6049 -0.9618 0.462 800. 0.4396 0.3165 0.5422 0.4399 0.7988 0.531\n0.5 -1.6508 0.165 -0.1972 -0.165 0.1972 5.2305 5.2893 1.06 2.5567 -2.1 -0.5 50 7.5778 3.7401 0.4707 0.0352 -0.0278 0.0991 0.2695 4.6099 0.7884 0.1061 6.526 0. -0.1428 -0.006492 -0.001074 4.7854 -1.0044 -0.1633 -0.007435 0.133828 0.01 300 1.4402 0.5507 -0.9945 0.524 800. 0.4419 0.3199 0.5433 0.4446 0.7966 0.5313\n0.75 -2.1511 0.165 -0.162 -0.165 0.162 3.7896 5.4109 1.06 2.6812 -2.1 -0.5 50 7.5808 3.7941 0.4575 0.0352 -0.0477 0.1982 0.2695 5.0376 0.6754 0.1 6.5 0. -0.1138 -0.005147 -0.001115 4.3304 -1.0602 -0.1028 -0.00812 0.085153 0.034 300 1.528 0.3582 -1.0225 0.658 800. 0.4459 0.3255 0.5294 0.4533 0.7792 0.5309\n1 -2.5365 0.165 -0.14 -0.165 0.14 3.3024 5.5106 1.06 2.7474 -2.1 -0.5 50 7.5814 3.8144 0.4522 0.0352 -0.0559 0.2154 0.2695 5.3411 0.6196 0.1 6.5 0. -0.1062 -0.004277 -0.001197 4.1667 -1.0941 -0.0699 -0.008444 0.058595 0.067 300 1.6523 0.2003 -1.0002 0.78 800. 0.4484 0.3291 0.5105 0.4594 0.7504 0.5302\n1.5 -3.0686 0.165 -0.1184 -0.165 0.1184 2.8498 5.6705 1.06 2.8161 -2.1 -0.5 50 7.5817 3.8284 0.4501 0.0352 -0.063 0.2154 0.2695 5.7688 0.5101 0.1 6.5 0. -0.102 -0.002979 -0.001675 4.0029 -1.1142 -0.0425 -0.007707 0.031787 0.143 300 1.8872 0.0356 -0.9245 0.96 800. 0.4515 0.3335 0.4783 0.468 0.7136 0.5276\n2 -3.4148 0.1645 -0.11 -0.1645 0.11 2.5417 5.7981 1.06 2.8514 -2.1 -0.5 50 7.5818 3.833 0.45 0.0352 -0.0665 0.2154 0.2695 6.0723 0.3917 0.1 6.5 0. -0.1009 -0.002301 -0.002349 3.8949 -1.1154 -0.0302 -0.004792 0.019716 0.203 300 2.1348 0. -0.8626 1.11 800. 0.4534 0.3363 0.4681 0.4681 0.7035 0.5167\n3 -3.9013 0.1168 -0.104 -0.1168 0.104 2.1488 5.9983 1.06 2.8875 -2.1 -0.5 50 7.5818 3.8361 0.45 0.016 -0.0516 0.2154 0.2695 6.5 0.1244 0.1 6.5 0. -0.1003 -0.001344 -0.003306 3.7928 -1.1081 -0.0129 -0.001828 0.009643 0.277 300 3.5752 0. -0.7882 1.291 800. 0.4558 0.3398 0.4617 0.4617 0.7006 0.4917\n4 -4.2466 0.0732 -0.102 -0.0732 0.102 1.8957 6.1552 1.06 2.9058 -2.1 -0.5 50 7.5818 3.8369 0.45 0.0062 -0.0448 0.2154 0.2695 6.8035 0.0086 0.1 6.5 0. -0.1001 -0.001084 -0.003566 3.7443 -1.0603 -0.0016 -0.001523 0.005379 0.309 300 3.8646 0. -0.7195 1.387 800. 0.4574 0.3419 0.4571 0.4571 0.7001 0.4682\n5 -4.5143 0.0484 -0.101 -0.0484 0.101 1.7228 6.2856 1.06 2.9169 -2.1 -0.5 50 7.5818 3.8376 0.45 0.0029 -0.0424 0.2154 0.2695 7.0389 0. 0.1 6.5 0. -0.1001 -0.00101 -0.00364 3.709 -0.9872 0. -0.00144 0.003223 0.321 300 3.7292 0. -0.656 1.433 800. 0.4584 0.3435 0.4535 0.4535 0.7 0.4517\n7.5 -5.0009 0.022 -0.101 -0.022 0.101 1.5737 6.5428 1.06 2.932 -2.1 -0.5 50 7.5818 3.838 0.45 0.0007 -0.0348 0.2154 0.2695 7.4666 0. 0.1 6.5 0. -0.1 -0.000964 -0.003686 3.6632 -0.8274 0. -0.001369 0.001134 0.329 300 2.3763 0. -0.5202 1.46 800. 0.4601 0.3459 0.4471 0.4471 0.7 0.4167\n10 -5.3461 0.0124 -0.1 -0.0124 0.1 1.5265 6.7415 1.06 2.9396 -2.1 -0.5 50 7.5818 3.838 0.45 0.0003 -0.0253 0.2154 0.2695 7.77 0. 0.1 6.5 0. -0.1 -0.00095 -0.0037 3.623 -0.7053 0. -0.001361 0.000515 0.33 300 1.7679 0. -0.4068 1.464 800. 0.4612 0.3474 0.4426 0.4426 0.7 0.3755\n\"\"\")\n\n\nclass ChiouYoungs2014PEER(ChiouYoungs2014):\n \"\"\"\n This implements the Chiou & Youngs (2014) GMPE for use with the PEER\n tests. In this version the total standard deviation is fixed at 0.65\n \"\"\"\n #: Only the total standars deviation is defined\n DEFINED_FOR_STANDARD_DEVIATION_TYPES = set([\n const.StdDev.TOTAL,\n ])\n #: The PEER tests requires only PGA\n DEFINED_FOR_INTENSITY_MEASURE_TYPES = set([\n PGA,\n ])\n\n def _get_stddevs(self, sites, rup, C, stddev_types, ln_y_ref, exp1, exp2):\n \"\"\"\n Returns the standard deviation, which is fixed at 0.65 for every site\n \"\"\"\n ret = []\n for stddev_type in stddev_types:\n assert stddev_type in self.DEFINED_FOR_STANDARD_DEVIATION_TYPES\n if stddev_type == const.StdDev.TOTAL:\n # eq. 13\n ret.append(0.65 * np.ones_like(sites.vs30))\n return ret\n\n\nclass ChiouYoungs2014NearFaultEffect(ChiouYoungs2014):\n \"\"\"\n This implements the Chiou & Youngs (2014) GMPE include the near fault\n effect prediction. In this version, we add the distance measure, rcdpp\n for directivity prediction.\n\n \"\"\"\n #: Required distance measures are RRup, Rjb, Rx, and Rcdpp\n REQUIRES_DISTANCES = set(('rrup', 'rjb', 'rx', 'rcdpp'))\n\n def _get_centered_cdpp(self, dists):\n \"\"\"\n Get directivity prediction parameter centered on the avgerage\n directivity prediction parameter.\n\n \"\"\"\n centered_dpp = dists.rcdpp\n\n return centered_dpp\n", "meta": {"hexsha": "0d94052ccb25ebdfea12d9aec56ef610fe609fd4", "size": 21330, "ext": "py", "lang": "Python", "max_stars_repo_path": "openquake/hazardlib/gsim/chiou_youngs_2014.py", "max_stars_repo_name": "gfzriesgos/shakyground-lfs", "max_stars_repo_head_hexsha": "2caf67cc32e6800286eded2df1efb05973ccf41b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-08-01T00:28:24.000Z", "max_stars_repo_stars_event_max_datetime": "2019-08-01T00:28:24.000Z", "max_issues_repo_path": "openquake/hazardlib/gsim/chiou_youngs_2014.py", "max_issues_repo_name": "gfzriesgos/shakyground-lfs", "max_issues_repo_head_hexsha": "2caf67cc32e6800286eded2df1efb05973ccf41b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2018-08-31T14:14:35.000Z", "max_issues_repo_issues_event_max_datetime": "2021-10-11T12:53:13.000Z", "max_forks_repo_path": "openquake/hazardlib/gsim/chiou_youngs_2014.py", "max_forks_repo_name": "gfzriesgos/shakyground-lfs", "max_forks_repo_head_hexsha": "2caf67cc32e6800286eded2df1efb05973ccf41b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2018-08-31T14:11:00.000Z", "max_forks_repo_forks_event_max_datetime": "2019-07-17T10:06:02.000Z", "avg_line_length": 61.8260869565, "max_line_length": 373, "alphanum_fraction": 0.5499765588, "include": true, "reason": "import numpy", "num_tokens": 9804, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5350984434543458, "lm_q2_score": 0.35936413143782797, "lm_q1q2_score": 0.19229518736570467}} {"text": "# -----------------------------------------------------------------------------\n# @author:\n# Tingwu Wang\n# @brief:\n# -----------------------------------------------------------------------------\nimport numpy as np\n\nfrom .base_reward import base_reward_network\nfrom mbbl.config import init_path\nfrom mbbl.util.common import tf_networks\nfrom mbbl.util.common import tf_utils\nfrom mbbl.util.common import logger\nfrom mbbl.util.il import expert_data_util\nimport tensorflow as tf\n\n\nclass reward_network(base_reward_network):\n '''\n @brief:\n '''\n\n def __init__(self, args, session, name_scope,\n observation_size, action_size):\n '''\n @input:\n @ob_placeholder:\n if this placeholder is not given, we will make one in this\n class.\n\n @trainable:\n If it is set to true, then the policy weights will be\n trained. It is useful when the class is a subnet which\n is not trainable\n '''\n super(reward_network, self).__init__(\n args, session, name_scope, observation_size, action_size\n )\n self._base_dir = init_path.get_abs_base_dir()\n # load the expert data\n self._expert_trajectory_obs = expert_data_util.load_expert_trajectory(\n self.args.expert_data_name, self.args.traj_episode_num\n )\n\n def build_network(self):\n self._build_ph()\n self._tensor = {}\n\n self._tensor['normalized_start_state'] = (\n self._input_ph['start_state'] -\n self._whitening_operator['state_mean']\n ) / self._whitening_operator['state_std']\n self._tensor['net_input'] = self._tensor['normalized_start_state']\n\n # the mlp for policy\n network_shape = [self._observation_size] + \\\n self.args.reward_network_shape + [1]\n num_layer = len(network_shape) - 1\n act_type = \\\n [self.args.reward_activation_type] * (num_layer - 1) + [None]\n norm_type = \\\n [self.args.reward_normalizer_type] * (num_layer - 1) + [None]\n init_data = []\n for _ in range(num_layer):\n init_data.append(\n {'w_init_method': 'normc', 'w_init_para': {'stddev': 1.0},\n 'b_init_method': 'constant', 'b_init_para': {'val': 0.0}}\n )\n # init_data[-1]['w_init_para']['stddev'] = 0.01 # the output layer std\n self._MLP = tf_networks.MLP(\n dims=network_shape, scope='discriminator_mlp', train=True,\n activation_type=act_type, normalizer_type=norm_type,\n init_data=init_data\n )\n\n self._tensor['logits'] = self._MLP(self._tensor['net_input'])\n self._tensor['discriminator_output'] = \\\n tf.nn.sigmoid(self._tensor['logits'])\n # the self.discriminator_output is the sigmoid(logit)\n self._tensor['logOfD'] = \\\n tf.log(self._tensor['discriminator_output'] + 1e-8)\n self._tensor['logOf1minusD'] = \\\n tf.log(1 - self._tensor['discriminator_output'] + 1e-8)\n\n self._tensor['reward_output'] = tf.minimum(\n -self._tensor['logOf1minusD'], self.args.GAN_reward_clip_value\n )\n\n def build_loss(self):\n self._update_operator = {}\n self._input_ph['if_expert_data'] = tf.placeholder(tf.float32, [None, 1],\n name='observation_gt')\n self._tensor['if_fake_data'] = 1 - self._input_ph['if_expert_data']\n\n # calculate the entropy\n self._update_operator['entropy'] = tf.reduce_mean(\n tf_utils.logit_bernoulli_entropy(self._tensor['logits'])\n )\n self._update_operator['entropy_loss'] = \\\n -self.args.GAN_ent_coeff * self._update_operator['entropy']\n\n self._update_operator['loss'] = \\\n -tf.reduce_mean(self._tensor['if_fake_data'] *\n self._tensor['logOf1minusD']) + \\\n -tf.reduce_mean(self._input_ph['if_expert_data'] *\n self._tensor['logOfD']) + \\\n self._update_operator['entropy_loss']\n\n # logging stats, real traj should be 1\n self._tensor['expert_traj_accuracy'] = tf.reduce_sum(\n tf.to_float(self._tensor['discriminator_output'] > 0.5)\n * self._input_ph['if_expert_data']\n ) / tf.reduce_sum(self._input_ph['if_expert_data'])\n\n self._tensor['expert_average_reward'] = tf.reduce_sum(\n self._tensor['reward_output'] * self._input_ph['if_expert_data']\n ) / tf.reduce_sum(self._input_ph['if_expert_data'])\n\n self._tensor['agent_traj_accuracy'] = tf.reduce_sum(\n tf.to_float(self._tensor['discriminator_output'] < 0.5) *\n self._tensor['if_fake_data']\n ) / tf.reduce_sum(self._tensor['if_fake_data']) # fake traj should be 0\n\n self._tensor['agent_average_reward'] = tf.reduce_sum(\n self._tensor['reward_output'] * self._tensor['if_fake_data']\n ) / tf.reduce_sum(self._tensor['if_fake_data'])\n\n self._update_operator['update_gan_op'] = tf.train.AdamOptimizer(\n learning_rate=self.args.reward_lr\n ).minimize(self._update_operator['loss'])\n\n def train(self, data_dict, replay_buffer, training_info={}):\n \"\"\" @brief:\n The GAN training of the reward function\n \"\"\"\n\n agent_obs = data_dict['start_state']\n training_stats = []\n\n for i_epoch in range(self.args.reward_epochs):\n # we start from 1 since the first state will be fixed to be 0 reward\n agent_sample_id = self._npr.randint(\n 1, agent_obs.shape[0], self.args.gan_timesteps_per_epoch\n )\n # sample and process the positive data-samples\n expert_sample_id = self._npr.randint(\n 0, self._expert_trajectory_obs.shape[0],\n self.args.positive_negative_ratio *\n self.args.gan_timesteps_per_epoch\n )\n\n feed_dict = {\n self._input_ph['if_expert_data']: np.reshape(\n np.concatenate(\n [np.zeros(len(agent_sample_id)),\n np.ones(len(expert_sample_id))],\n ),\n [-1, 1]\n ),\n self._input_ph['start_state']: np.concatenate(\n [agent_obs[agent_sample_id],\n self._expert_trajectory_obs[expert_sample_id]]\n )\n }\n\n # train the network\n fetch_dict = {\n 'update_op': self._update_operator['update_gan_op'],\n 'reward_gan_loss': self._update_operator['loss'],\n 'expert_traj_accuracy': self._tensor['expert_traj_accuracy'],\n 'agent_traj_accuracy': self._tensor['agent_traj_accuracy'],\n 'expert_average_reward': self._tensor['expert_average_reward'],\n 'agent_average_reward': self._tensor['agent_average_reward'],\n 'entropy': self._update_operator['entropy']\n }\n i_training_stats = self._session.run(fetch_dict, feed_dict=feed_dict)\n training_stats.append(i_training_stats)\n\n training_stats = {\n key: np.mean([training_stats[i_epoch][key]\n for i_epoch in range(len(training_stats))])\n for key in training_stats[-1] if key != 'update_op'\n }\n self._set_whitening_var(data_dict['whitening_stats'])\n return training_stats\n\n def eval(self, data_dict):\n pass\n\n def pred(self, data_dict):\n logger.info('This function should not be used!')\n reward = []\n for i_data in range(len(data_dict['action'])):\n i_reward = self._env.reward(\n {key: data_dict[key][i_data]\n for key in ['start_state', 'action']}\n )\n reward.append(i_reward)\n return np.stack(reward), -1, -1\n\n def use_groundtruth_network(self):\n return False\n\n def generate_rewards(self, rollout_data):\n \"\"\"@brief:\n This function should be called before _preprocess_data\n \"\"\"\n for path in rollout_data:\n # the predicted value function (baseline function)\n path[\"raw_rewards\"] = path['rewards'] # preserve the raw reward\n # from mbbl.util.common.fpdb import fpdb; fpdb().set_trace()\n\n # generate the observation pairs\n ob_pairs = path['obs'][1: len(path['obs'])]\n\n path[\"rewards\"] = self._session.run(\n self._tensor['reward_output'],\n feed_dict={self._input_ph['start_state']: ob_pairs}\n ).flatten()\n assert len(path[\"rewards\"]) == len(path['raw_rewards'])\n return rollout_data\n", "meta": {"hexsha": "4dffc103c2f16423c5db61b13f9b1b68454169a8", "size": 8913, "ext": "py", "lang": "Python", "max_stars_repo_path": "mbbl_envs/mbbl/network/reward/GAN_reward.py", "max_stars_repo_name": "hbutsuak95/iv_rl", "max_stars_repo_head_hexsha": "0f72a8f077a238237027ea96b7d1160c35ac9959", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 9, "max_stars_repo_stars_event_min_datetime": "2022-01-16T11:27:00.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-13T14:04:48.000Z", "max_issues_repo_path": "mbbl_envs/mbbl/network/reward/GAN_reward.py", "max_issues_repo_name": "hbutsuak95/iv_rl", "max_issues_repo_head_hexsha": "0f72a8f077a238237027ea96b7d1160c35ac9959", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "mbbl_envs/mbbl/network/reward/GAN_reward.py", "max_forks_repo_name": "hbutsuak95/iv_rl", "max_forks_repo_head_hexsha": "0f72a8f077a238237027ea96b7d1160c35ac9959", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.3303167421, "max_line_length": 81, "alphanum_fraction": 0.5738808482, "include": true, "reason": "import numpy", "num_tokens": 1941, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6187804337438501, "lm_q2_score": 0.31069439597968646, "lm_q1q2_score": 0.1922516131060939}} {"text": "\"\"\" Module for mean-flux regulation\nPort of K-G Lee IDL code\n\"\"\"\nimport pdb\n\nimport numpy as np\n\nfrom astropy.table import Table\nfrom astropy import units as u\nfrom astropy.coordinates import SkyCoord\nfrom astropy.modeling import FittableModel, Parameter\n\nfrom pyigm.fN import tau_eff as pyteff\n\ntry:\n basestring\nexcept NameError: # For Python 3\n basestring = str\n\n\ndef fit_forest(wave, flux, sigma, zqso, wavemin=3200., normfac=None,\n user_mask=None, mask_dlas=None, coord=None,\n for_lohi=(1041.,1185)):\n \"\"\" Perform mean-flux regulation on an input spectrum\n\n Parameters\n ----------\n wave : ndarray\n Observed wavelength values in Ang\n flux : ndarray\n flux array\n sigma : ndarray\n sigma array. 0 values are masked\n zqso : float\n Quasar emission redshift\n wavemin : float, optional\n Minimum wavelength to include in analysis\n normfac : float, optional\n optional scaling factor\n user_mask : list (of lists)\n User can mask out regions in the anaylsis `by-hand'\n mask_dlas : Table or str, optional\n Table of DLAs to mask based on coordinates and redshift\n Required columns are RA, DEC, z\n Can be the filename of the table to input\n coord : SkyCoord, optional\n Coordinate of the sightline. Used to match against DLAs\n for_lohi : tuple\n wavemin, wavemax that define the forest for analysis\n\n Returns\n -------\n new_ff : ndarray\n Mean-flux regulated flux\n parm : FittableModel\n astropy model of the continuum\n \"\"\"\n from astropy.modeling import fitting\n\n # invvar\n ivar = (sigma != 0.) / (sigma**2 + (sigma == 0))\n\n # Scale?\n if normfac is not None:\n ivar = ivar * normfac**2\n flux = flux / normfac\n\n # User Mask?\n if user_mask is not None:\n for imask in user_mask:\n msk = (wave >= imask[0]) & (wave <= imask[1])\n ivar[msk] = 0.\n\n # DLA mask?\n if mask_dlas is not None:\n if coord is None:\n raise IOError(\"Must input coord to mask DLAs\")\n # Load DLAs, as needed\n if isinstance(mask_dlas, basestring):\n dlas = Table.read(mask_dlas)\n elif isinstance(mask_dlas, Table):\n dlas = mask_dlas\n # Check for coord column\n if 'coord' not in dlas.keys():\n dla_coord = SkyCoord(ra=dlas['RA'], dec=dlas['DEC'], unit='deg')\n else:\n dla_coord = dlas['coord']\n else:\n raise IOError(\"Not ready for this type of DLA input\")\n\n # Search\n sep = coord.separation(dla_coord)\n match = np.where(sep < 2*u.arcsec)[0]\n for imatch in match:\n zdla = dlas['z'][imatch]\n skip_fg = np.abs(wave-1215.6701*(1+zdla)) < 100.\n ivar[skip_fg] = 0.\n #print, 'Removed a DLA'\n\n # Isolate forest for analysis\n lambda_r = wave / (1+zqso)\n forestrange = (lambda_r >= for_lohi[0]) & (lambda_r <= for_lohi[1]) & (\n wave > wavemin)\n lamb_forest = lambda_r[forestrange]\n z_for = (lamb_forest/1215.67)*(1.+zqso) -1. # Redshift at each pixel\n fforest = flux[forestrange]\n ivarforest = ivar[forestrange]\n\n # Estimate weights for each pixel\n var_F = forestvar(z_for) * (np.exp(-pyteff.lyman_alpha_obs(z_for)))**2\n #var_F = forestvar(z_for) * (np.exp(-old_taueff_evo(z_for)))**2\n var_noise = (ivarforest != 0) / (ivarforest + (ivarforest == 0))\n var_total = var_F + var_noise\n weights_forest = (var_total != 0) / (var_total + (var_total == 0))\n\n # But need to make sure that masked pixels remain masked...\n maskedpix = ivarforest == 0\n weights_forest[maskedpix] = 0\n\n # Astropy modeling\n model = mflux_tauevo(p0=0., p1=0., zqso=zqso, lamb_piv=1113.)\n fitter = fitting.LevMarLSQFitter()\n parm = fitter(model, lamb_forest, fforest, weights=weights_forest)\n\n # Apply\n full_forest = lambda_r < 1220.\n new_ff = flux\n new_ff[full_forest] = flux[full_forest] / mfluxcorr(lambda_r[full_forest],\n parm.p0.value, parm.p1.value,\n lamb_piv=parm.lamb_piv.value)\n # Return\n return new_ff, parm\n\n\ndef forestvar(z_in):\n \"\"\" Return intrinsic variance of LyaF variance for weighting. This\n estimate is roughly from McDonald et al 2006\n\n Parameters\n ----------\n z_in : float or ndarray\n\n Returns\n -------\n fvar : float or ndarray\n Variance\n \"\"\"\n fvar = 0.065 * ((1.+z_in)/(1.+2.25))**3.8\n # Return\n return fvar\n\n\ndef mfluxcorr(lambda_r, p0, p1, lamb_piv=1113.):\n \"\"\" Correction factor to power-law fit\n Parameters\n ----------\n lambda_r\n p\n lamb_piv\n\n Returns\n -------\n\n \"\"\"\n lamb_piv = 1113. # This is the pivot point in the restframe spectrum\n return p0 + p1*(lambda_r/lamb_piv - 1.)\n\n\nclass mflux_tauevo(FittableModel):\n \"\"\" Mean flux evolution * exp(delta*(lambda/1280-1)),\n Meant for use with astropy.modeling to correct the fitted Lya forest continuum\n Abscissa parameter x is the restframe wavelength, and free parameters p0, p1\n set the power law.\n This function NEEDS the quasar redshift zqso to be set\n\n input: lambda_r :: Rest wavelength Assumed in Angstroms\n output: absorbed, normalized flux\n Parameters: logN,b,z,wrest,f,gamma,fwhm\n \"\"\"\n inputs = ('lambda_r',)\n outputs = ('flux',)\n\n # Free parameters (generally)\n p0 = Parameter()\n p1 = Parameter()\n\n # Fixed parameters\n zqso = Parameter(fixed=True)\n lamb_piv = Parameter(fixed=True)\n\n @staticmethod\n def evaluate(lambda_r, p0, p1, zqso, lamb_piv): #logN,b,z,wrest,f,gamma,fwhm):\n zfor = (lambda_r/1216.) * (1. + zqso) - 1.\n tau = pyteff.lyman_alpha_obs(zfor)\n #tau = old_taueff_evo(zfor)\n fmean = np.exp(-1*tau)\n\n mfluxtauevo = fmean * mfluxcorr(lambda_r, p0, p1, lamb_piv=lamb_piv)\n return mfluxtauevo\n\n\ndef old_taueff_evo(z):\n \"\"\" F-G taueff.\n Mainly for testing\n\n Parameters\n ----------\n z\n\n Returns\n -------\n\n \"\"\"\n tauevo = 0.001845 * (1+z)**3.924\n return tauevo", "meta": {"hexsha": "78a5e769cee19c48af7721e7278a94c99c20bc30", "size": 6209, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyigm/igm/mfr.py", "max_stars_repo_name": "pyigm/pyigm", "max_stars_repo_head_hexsha": "8b4bc7f7f1c9f1c280720a4cc0693cd7cb79e9cb", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 16, "max_stars_repo_stars_event_min_datetime": "2016-02-12T19:03:38.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-11T15:16:25.000Z", "max_issues_repo_path": "pyigm/igm/mfr.py", "max_issues_repo_name": "pyigm/pyigm", "max_issues_repo_head_hexsha": "8b4bc7f7f1c9f1c280720a4cc0693cd7cb79e9cb", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 204, "max_issues_repo_issues_event_min_datetime": "2015-12-06T13:40:05.000Z", "max_issues_repo_issues_event_max_datetime": "2021-02-11T21:48:39.000Z", "max_forks_repo_path": "pyigm/igm/mfr.py", "max_forks_repo_name": "pyigm/pyigm", "max_forks_repo_head_hexsha": "8b4bc7f7f1c9f1c280720a4cc0693cd7cb79e9cb", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 16, "max_forks_repo_forks_event_min_datetime": "2015-12-06T23:27:49.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-01T10:08:24.000Z", "avg_line_length": 28.8790697674, "max_line_length": 85, "alphanum_fraction": 0.6075052343, "include": true, "reason": "import numpy,from astropy", "num_tokens": 1770, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6187804478040617, "lm_q2_score": 0.31069438321455395, "lm_q1q2_score": 0.19225160957570844}} {"text": "import numpy as np\nfrom scipy import interpolate\nimport matplotlib\nfrom datetime import datetime\nfrom scipy.stats.mstats import mquantiles\nimport os\nfrom astropy.io import fits\nimport glob\nfrom parameters import *\nimport sys\nimport argparse\nfrom astropy.table import Table\n##sys.path.insert(0, 'python')\n# matplotlib.rc('text', usetex=True)\n# matplotlib.rcParams['text.latex.preamble'] = [r\"\\usepackage{amsmath}\",\n# r\"\\usepackage{color}\"]\n# matplotlib.use('Agg')\nfrom ptemcee import Sampler as PTSampler\nimport matplotlib.pyplot as plt\n##import corner\nstartTime = datetime.now()\n\n\nparser = argparse.ArgumentParser(description=\"Calculate radial velocities and stellar parameters of WEAVE target spectra.\")\n\nparser.add_argument(\"--infile\", type=str, required=True, help=\"input file\", nargs=1)\nparser.add_argument(\"--outdir\", type=str, required=True, help=\"output directory\", nargs=1)\nparser.add_argument(\"--targlist\", type=str, required=True, help=\"path to list of FIBREIDs or TARGIDs to be analysed. To analyse all BA stars, enter 'all'.\", nargs=1)\nparser.add_argument(\"--params\", type=str, required=False, default='parameters.py', help=\"path to parameter file\", nargs=1)\n\n#parser.add_argument(\"--setups\", type=str, default=None, required=True, help=\"input setups\", nargs='*')\n\nargs = parser.parse_args()\nwrite_directory = args.outdir[0]\ntarget_list = args.targlist[0]\ndata_file = args.infile[0]\n\n\n# processing (cropping, smoothing, rebinning, rotational broadening) templates if required \n\nif process_templates==True:\n\tprint('Beginning processing of templates')\n\tfrom PyAstronomy import pyasl\n\timport scipy.stats\n\ttemplatelist = np.genfromtxt(template_list_file, dtype=None, encoding=None)\n\n\t# Ensuring the number of templates to be processed matches the number of points on the grid. \n\tnotemps = len(templatelist)\n\td_size = len(Teff) * len(logg) * len(vsini)\n\tif notemps < d_size:\n\t\tprint('ERROR: The amount of templates to be processed is less than the amount of points in the grid. Add more templates to the list or reduce the grid as necessary (see PARAMETER BOUNDARIES in parameters file).')\n\t\tsys.exit()\n\tif notemps > d_size: \n\t\tprint('ERROR: The amount of templates to be processed is greater than the amount of points in the grid. Remove templates from the list or expand the grid as necessary (see PARAMETER BOUNDARIES in parameters file).')\n\t\tsys.exit()\n\n\tdef restrict_range(w, f):\t\t# to crop the templates\n\t\tour_range = (w > template_crop_min_wav) & (w < template_crop_max_wav)\n\t\tw, f = w[our_range], f[our_range]\n\t\treturn w, f\n\n\tdef smooth(w, f, sig):\t\t# to smooth/broaden templates to match resolution of observed spectrum\n\t\tf = pyasl.broadGaussFast(w, f, sig)\n\t\treturn f\n\n\tdef rotbroad(w, f, vsini):\t\t# to rotationally broaden the templates\n\t\tf = pyasl.rotBroad(w, f, 0.6, float(vsini))\n\t\treturn f\n\n\tdef rebin(w, f, samp):\t\t# to rebin the templates to match the sampling of the observed spectrum\n\t\tf, bin_edges, binnumber = scipy.stats.binned_statistic(w, f, statistic = 'mean', bins = (w[-1] - w[0]) / samp)\n\t\tbin_width = bin_edges[1] - bin_edges[0]\n\t\tw = bin_edges[1:] - bin_width/2\n\t\treturn w, f\n\n\tdef process_template(w, f, sig=sigma, samp=sampling):\n\t\tif sigma != None:\n\t\t\tf = smooth(w, f, sig)\n\t\tif sampling != None:\n\t\t\tw, f = rebin(w, f, samp)\n\t\tfile = open(template_write_directory + '/'+ os.path.splitext(os.path.basename(i))[0] + '_processed', \"w\")\n\t\tfor index in range(len(w)):\n\t\t\tfile.write(str(w[index]) + \" \" + str(f[index]) + \"\\n\")\n\t\tfile.close()\n\t\treturn w, f\n\n\tdef process_template_vsini(w, f, vsini, sig=sigma, samp=sampling):\n\t\tf = rotbroad(w, f, vsini)\n\t\tif sigma != None:\n\t\t\tf = smooth(w, f, sig)\n\t\tif sampling != None:\n\t\t\tw, f = rebin(w, f, samp)\n\t\tfile = open(template_write_directory + '/' + os.path.splitext(os.path.basename(i))[0] + '_processed_vsini' + str(int(vsini)), \"w\")\n\t\tfor index in range(len(w)):\n\t\t\tfile.write(str(w[index]) + \" \" + str(f[index]) + \"\\n\")\n\t\tfile.close()\n\t\treturn w, f\n\n\tdef write_to_grid(templatename, f, t_ind=temp_ind, l_ind=logg_ind, v_ind=vsini_ind, vsini0=None):\n\t\t# finding the teff and logg information from the template name, to write to corresponding grid point\n\t\tt1 = float(templatename[temp_ind[0]:temp_ind[1]])\n\t\tl1 = float(templatename[logg_ind[0]:logg_ind[1]])\n\t\tif vsini0==None:\n\t\t\tv1 = float(templatename[vsini_ind[0]:vsini_ind[1]])\n\t\telse: \n\t\t\tv1 = float(vsini0)\n\n\t\tprint('Teff: ' + str(t1) + ', logg: ' + str(l1) + ', vsini: ' + str(v1))\n\n\t\td[np.where(Teff == t1)[0][0], np.where(logg == l1)[0][0], np.where(vsini == v1)[0][0]] = f\n\n\tt_wavelength_0, t_flux_0 = np.genfromtxt(templatelist[0], unpack=True, usecols=(wav_ind, flux_ind), dtype=None, encoding=None)\n\tt_wavelength_0, t_flux_0 = restrict_range(t_wavelength_0, t_flux_0)\n\tif sampling != None:\n\t\tt_wavelength_0, t_flux_0 = rebin(t_wavelength_0, t_flux_0, sampling)\n\n\td = np.zeros((len(Teff), len(logg), len(vsini), len(t_wavelength_0)))\n\td_filled = 0\n\n\tfor i in templatelist:\n\t\tprint('Processing: ' + i)\n\t\tt_wavelength, t_flux = np.genfromtxt(i, unpack=True, usecols=(wav_ind, flux_ind), dtype=None, encoding=None)\n\t\tt_wavelength, t_flux = restrict_range(t_wavelength, t_flux)\n\t\tif rotbroads == None:\n\t\t\t_, t_flux = process_template(t_wavelength, t_flux, sigma, sampling)\n\t\t\tprint('template processed, writing to grid at:')\n\t\t\twrite_to_grid(i, t_flux)\n\t\t\td_filled += 1\n\t\t\tprint('grid is ' + str(\"{0:.1f}\".format(float(d_filled)/float(d_size) * 100.)) + ' percent full')\n\n\n\n\t\telse:\n\t\t\tprint('processing for vsini: 0')\n\t\t\t_, t_flux_v0 = process_template(t_wavelength, t_flux, sig=sigma, samp=sampling)\n\t\t\tprint('template processed, writing to grid at:')\n\t\t\twrite_to_grid(i, t_flux_v0, vsini0=0.)\n\t\t\td_filled += 1\n\t\t\tprint('grid is ' + str(\"{0:.1f}\".format(float(d_filled)/float(d_size) * 100.)) + ' percent full')\n\n\t\t\tfor j in rotbroads:\n\t\t\t\tif j == 0:\n\t\t\t\t\tcontinue\n\t\t\t\tprint('processing for vsini: ' + str(j))\n\t\t\t\t_, t_flux_vj = process_template_vsini(t_wavelength, t_flux, j, sig=sigma, samp=sampling)\n\t\t\t\tprint('template processed, writing to grid at:')\n\t\t\t\twrite_to_grid(i, t_flux_vj, vsini0=j)\n\t\t\t\td_filled += 1\n\t\t\t\tprint('grid is ' + str(\"{0:.1f}\".format(float(d_filled)/float(d_size) * 100.)) + ' percent full')\n\n\n\tnp.save(template_write_directory + 'template_grid.npy', d)\n\n\n# creating /plots and /results folders in write_directory if they dont already exist \nif not os.path.exists(write_directory + '/plots'):\n os.mkdir(write_directory + '/plots')\n print(write_directory + 'plots folder created')\nif not os.path.exists(write_directory + '/results'):\n os.mkdir(write_directory + '/results')\n print(write_directory + 'results folder created')\n\nif process_templates==False:\n\t# location of folder containing this script\n\ttemplatedirectory = os.path.dirname(os.path.abspath(__file__)) + '/templates/'\n\t# loading the template flux grid\n\tflux_data_all = np.load(templatedirectory + 'template_grid.npy')\n\t#loading the wavelength data\n\ttemplatewavelength = np.loadtxt(templatedirectory + 'wavelength_data.dat')\nelse:\n\t# the first template for the template wavelength data\n\tflux_data_all = np.load(template_write_directory + 'template_grid.npy')\n\ttemplatewavelength = t_wavelength_0\n\ntemplate_min_wav = min_wav*(1.0 + (min(drv)/299792.458)) - 10.\ntemplate_max_wav = max_wav*(1.0 + (max(drv)/299792.458)) + 10.\n\ntemplatemask = (templatewavelength > template_min_wav) & (templatewavelength < template_max_wav)\nflux_data = np.zeros((len(Teff), len(logg), len(vsini), len(templatewavelength[templatemask])))\ntemplatewavelength = templatewavelength[templatemask]\n\nfor ii in range(len(Teff)):\n\tfor jj in range(len(logg)):\n\t\tfor kk in range(len(vsini)):\n\t\t\tflux_data[ii,jj,kk] = flux_data_all[ii,jj,kk][templatemask]\n\n\nipo = interpolate.RegularGridInterpolator((Teff, logg, vsini), flux_data, method='linear')\n\n# grid of parameters for walker initial positions\nini_grid = [Teff, logg, vsini, drv, slopes, intercepts]\nndim=6\n\n# define edges of parameter space\nteffmin, teffmax, loggmin, loggmax, vsinimin, vsinimax, rvmin, rvmax, slopemin, slopemax, interceptmin, interceptmax = min(Teff), max(Teff), min(logg), max(logg), min(vsini), max(vsini), min(drv), max(drv), min(slopes), max(slopes), min(intercepts), max(intercepts)\n\ndef model(X, wavelength):\n\ti, j, k, l, m, n = X \n\t# interpolating template grid with teff (i), logg (j), vsini (k) trial parameter\n\ttemplateflux = ipo([i, j, k])[0]\n\t# interpolating on wavelength axis for trial RV (l)\n\tfi = interpolate.interp1d(templatewavelength*(1.0 + l/299792.458), templateflux)\n\treturn fi(wavelength)\n\ndef lnprior(X):\n\ti, j, k, l, m, n = X\n\t# flat prior, edges should corespond to template grid\n\tif (teffmin <= i <= teffmax) & (loggmin <= j <= loggmax) & (vsinimin <= k <= vsinimax) & (rvmin <= l <= rvmax) & (slopemin <= m <= slopemax) & (interceptmin <= n <= interceptmax):\n\t\treturn 0.0\n\telse:\n\t\treturn -np.inf\n\ndef lnlike(X, wavelength, flux, noisespec, mask):\n\ti, j, k, l, m, n = X\n\tz = m, n \n\tf = np.poly1d(z)\n\tif exclude_region == False:\n\t\treturn -(np.sum((flux - (model(X, wavelength)*f(wavelength)))**2/(2*PPRE*noisespec**2)))\n\telse:\n\t\treturn -(np.sum((flux[mask] - (model(X, wavelength)*f(wavelength))[mask])**2/(2*PPRE*noisespec[mask]**2)))\n\ndef mcmc_one(t):\n\n\tprint(\"Processing: \" + t) \n\ttarg_start = datetime.now()\n\n\t# checking if spectrum file exists, and if result already written\n\tif os.path.exists(write_directory + '/results/' + os.path.splitext(os.path.basename(t))[0] + '_results'):\n\t\tprint('WARNING: result for '+t+' already exists, skipping')\n\t\treturn\n\n\t# specify unnormalised calibrated flux\n\twith fits.open(data_file) as ALLDATA:\n\t\tfinal_spectra = ALLDATA[1].data[info['TARGID'] == t][0]\n\t\tspectra_before_sky_subtraction = ALLDATA[3].data[info['TARGID'] == t][0]\n\t\tCalibration_function = ALLDATA[5].data[info['TARGID'] == t][0]\n\t\ttry: \n\t\t\tidx=list(ALLDATA[6].data['FIBREID']).index(t)\n\t\texcept:\n\t\t\tidx=list(ALLDATA[6].data['TARGID']).index(t)\n\t\tNSPEC = ALLDATA[6].data['Nspec'][idx]\n\t\tFIBREID = ALLDATA[6].data['FIBREID'][idx]\n\t\tCNAME = ALLDATA[6].data['CNAME'][idx]\n\tflux = final_spectra * Calibration_function * 1.0e18\n\n\t# restrict to desired wavelength range\n\tflux = flux[targetmask]\n\n\t# create corresponsing noise spectrum\n\tnoisespec = np.sqrt((2.*spectra_before_sky_subtraction - final_spectra)*Calibration_function*1.0e18)\n\tnoisespec = noisespec[targetmask]\n\n\t# mask for excluding a wavelength region\n\tif exclude_region == True:\n\t\tmask = np.zeros(len(wavelength), dtype=bool)\n\t\tfor line in lines:\n\t\t\tmask |= (wavelength >= line[0]) & (wavelength <= line[1])\n\telse:\n\t\tmask = np.ones(len(wavelength), dtype=bool)\n\n\t# choose initial walker positions\n\tpos = [[[np.random.choice(i) for i in ini_grid] for i in range(nwalkers)] for i in range(ntemps)]\n\n\t# initialise MCMC sampler\n\tsampler = PTSampler(ntemps=ntemps, nwalkers=nwalkers, dim=ndim, logl=lnlike, logp=lnprior, Tmax=np.inf, loglargs=[wavelength, flux, noisespec, mask])\n\n\t# run MCMC sampler for burn period\n\tif progress_bar==True:\n\t\tprint(\"running burn\")\n\tpos, prob, state = sampler.run_mcmc(pos, burn, adapt=True, progress_bar=progress_bar)\n\t# reset sampler, run MCMC sampler for run period with walkers starting at their positions at the end of burn\n\tsampler.reset()\n\tif progress_bar==True:\n\t\tprint(\"running runs\")\n\tsampler.run_mcmc(pos, runs, adapt=True, progress_bar=progress_bar)\n\tsamples=sampler.chain[0, :, :, :].reshape((-1, ndim))\n\n\t# plot walker paths\n\tylabels = ['Teff', 'logg', 'vsini', 'RV', 'slope', 'intercept']\n\tfor m in range(ndim):\n\t\tplt.subplot(ndim,1,m+1)\n\t\tplt.plot(sampler.chain[0,:,:,m].transpose(), alpha=0.2)\n\t\tplt.ylabel(ylabels[m])\n\tplt.xlabel('Step')\n\tplt.savefig(write_directory + '/plots/' + t + '_walkers.png', bbox_inches='tight')\n\tplt.close()\n\n\t# calculate 16th, 50th, 84th quantiles of the parameter samples\n\tquantiles = mquantiles(samples, prob=[0.16, 0.50, 0.84], axis=0)\n\n\ttargetname = os.path.splitext(os.path.basename(t))[0]\n\tacceptance_r = np.mean(sampler.acceptance_fraction)\n\n\t# print acceptance fraction, should be between 0.2-0.5 for efficient sampling\n\tprint(\"Mean acceptance fraction: {0:.3f}\"\n .format(acceptance_r))\n\n\t# The parameter results\n\tTeff_r = quantiles[1][0]\n\tTeffminus_r = quantiles[1][0] - quantiles[0][0]\n\tTeffplus_r = quantiles[2][0] - quantiles[1][0]\n\tlogg_r = quantiles[1][1]\n\tloggminus_r = quantiles[1][1] - quantiles[0][1]\n\tloggplus_r = quantiles[2][1] - quantiles[1][1]\n\tvsini_r = quantiles[1][2]\n\tvsiniminus_r = quantiles[1][2] - quantiles[0][2]\n\tvsiniplus_r = quantiles[2][2] - quantiles[1][2]\n\tRV_r = quantiles[1][3]\n\tRVminus_r = quantiles[1][3] - quantiles[0][3]\n\tRVplus_r = quantiles[2][3] - quantiles[1][3]\n\tslope_r = quantiles[1][4]\n\tslopeminus_r = quantiles[1][4] - quantiles[0][4]\n\tslopeplus_r = quantiles[2][4] - quantiles[1][4]\n\tintercept_r = quantiles[1][5]\n\tinterceptminus_r = quantiles[1][5] - quantiles[0][5]\n\tinterceptplus_r = quantiles[2][5] - quantiles[1][5]\n\n\t#fig = corner.corner(samples, quantiles=[0.16, 0.50, 0.84], labels=['Teff', 'log(g)', 'vsini', 'RV', 'slope', 'intercept'], show_titles=True, title_kwargs={\"fontsize\": 10}, plot_datapoints=True, plot_contours=True, auto_bars=True, data_kwargs={\"alpha\": 0.005})\n\t# fig.savefig(write_directory + t + '_cornerplot.png', bbox_inches='tight')\n\t# plt.close()\n\n\t# parameters of best fit (for plotting)\n\tXp = Teff_r, logg_r, vsini_r, RV_r, slope_r, intercept_r\n\tfp = np.poly1d(Xp[-2:])\n\tfitp = fp(wavelength)\n\n\t# plot spectrum and best-fit\n\tplt.plot(wavelength, flux, wavelength, model(Xp, wavelength) * fitp)\n\tif exclude_region == True:\n\t\tfor n,line in enumerate(lines):\n\t\t\tif n == 0:\n\t\t\t\tplt.vlines([line[1]], flux.min()*0.8, flux.max()*1.2, colors='r', linestyles='dashed')\n\t\t\telif n == (len(lines)-1):\n\t\t\t\tplt.vlines([line[0]], flux.min()*0.8, flux.max()*1.2, colors='r', linestyles='dashed')\n\t\t\telse:\n\t\t\t\tplt.vlines([line[0], line[1]], flux.min()*0.8, flux.max()*1.2, colors='r', linestyles='dashed')\n\n\tplt.xlim(min_wav, max_wav)\n\tplt.ylim(flux.min()*0.8, flux.max()*1.2)\n\tplt.xlabel(r'Wavelength ($\\AA$)')\n\tplt.ylabel('Calibrated counts')\n\tplt.savefig(write_directory + '/plots/' + t + '_spectrum.png', bbox_inches='tight')\n\tplt.close()\n\n\t# plot mapping function\n\tplt.plot(wavelength, fitp, wavelength, flux / model(Xp, wavelength))\n\tplt.xlim(min_wav, max_wav)\n\tplt.xlabel(r'Wavelength ($\\AA$)')\n\tplt.ylabel('Calibrated counts')\n\tplt.savefig(write_directory + '/plots/' + t + '_mapping_function.png', bbox_inches='tight')\n\tplt.close()\n\n\t# write results\n\ttab = open(write_directory + '/results/' + t + '_results', \"w\")\n\ttab.write(np.str(NSPEC) + \" \" + np.str(FIBREID) + \" \" + np.str(CNAME) + \" \" + t + \" \" + np.str(acceptance_r) + \" \" + np.str(Teff_r) + \" \" + np.str(Teffminus_r) + \" \" + np.str(Teffplus_r) + \" \" + np.str(logg_r) + \" \" + np.str(loggminus_r) + \" \" + np.str(loggplus_r) + \" \" + np.str(vsini_r) + \" \" + np.str(vsiniminus_r) + \" \" + np.str(vsiniplus_r) + \" \" + np.str(RV_r) + \" \" + np.str(RVminus_r) + \" \" + np.str(RVplus_r) + \" \" + np.str(slope_r) + \" \" + np.str(slopeminus_r) + \" \" + np.str(slopeplus_r) + \" \" + np.str(intercept_r) + \" \" + np.str(interceptminus_r) + \" \" + np.str(interceptplus_r) + \"\\n\")\n\ttab.close()\n\n\ttarg_end = datetime.now() - targ_start\n\tprint(targ_end)\n\ndef make_output_fits():\n\toutput_files = glob.glob(write_directory + 'results/*_results')\n\tall_res = []\n\tfor i in output_files:\n\t\twith open(i) as outf:\n\t\t\tall_res.append(outf.read().split())\n\tt = Table(rows=all_res, names=('NSPEC', 'FIBREID', 'CNAME', 'TARGID', 'Acceptance', 'Teff', 'Teff_minus', 'Teff_plus', 'logg', 'logg_minus', 'logg_plus', 'vsini', 'vsini_minus', 'vsini_plus', 'RV', 'RV_minus', 'RV_plus', 'slope', 'slope_minus', 'slope_plus', 'intercept', 'intercept_minus', 'intercept_plus'))\n\tt.write(write_directory+'results/'+os.path.splitext(os.path.basename(args.infile[0]))[0]+'_ptmcmc.fits', format='fits', overwrite=False)\n\n\n\n\nif __name__ == '__main__':\n\t# checking if results table already exists\n\tif os.path.exists(write_directory+'results/'+os.path.splitext(os.path.basename(args.infile[0]))[0]+'_ptmcmc.fits'):\n\t\tprint('WARNING: result table already exists, ending process.')\n\t\tsys.exit()\n\tif target_list == 'all':\n\t\tprint(\"Processing all BA stars in fits file\")\n\t\tBA = []\n\t\twith fits.open(data_file) as ALLDATA:\n\t\t\tfor n,i in enumerate(ALLDATA[6].data['TARGID']):\n\t\t\t\tif 'LR-BA' in i:\n\t\t\t\t\tBA.append(i)\n\telse:\n\t\tprint(\"Processing BA stars specified in target list\")\n\t\ttarglist = np.genfromtxt(target_list, dtype=None, encoding=None)\n\t\tBA = []\n\t\twith fits.open(data_file) as ALLDATA:\n\t\t\tfor targ in targlist:\n\t\t\t\ttry: \n\t\t\t\t\tidx=list(ALLDATA[6].data['FIBREID']).index(targ)\n\t\t\t\t\tBA.append(ALLDATA[6].data['TARGID'][idx])\n\t\t\t\texcept:\n\t\t\t\t\ttry:\n\t\t\t\t\t\tidx=list(ALLDATA[6].data['TARGID']).index(targ)\n\t\t\t\t\t\tBA.append(ALLDATA[6].data['TARGID'][idx])\n\t\t\t\t\texcept:\t\n\t\t\t\t\t\tprint(str(targ)+\": Cant find either FIBREID or TARGID in input table.\")\n\nALLDATA = None\ninfo = None\nwavelength = None\ntargetmask = None\n\ndef set_globals():\n global ALLDATA\n global info \n global wavelength\n global targetmask\n\n with fits.open(data_file) as ALLDATA:\n\t head0 = ALLDATA[0].header\n\t info = ALLDATA[6].data\n\t data1 = ALLDATA[1].data\n\t head1 = ALLDATA[1].header\n\t wave0 = head1['CRVAL1'] \n\t increm = head1['CD1_1']\n\t wavelength = np.array([wave0+increm*a for a in range(len(data1[1]))])\n\t targetmask = (wavelength > min_wav) & (wavelength < max_wav)\n\t wavelength = wavelength[targetmask]\n\nif multiprocess==True:\n\tfrom multiprocessing import Pool\n\tif __name__ == '__main__':\n\t\tpool = Pool(processes=process_no, initializer=set_globals)\n\t\tit = pool.imap_unordered(mcmc_one, BA)\n\t\tfor nn,i in enumerate(range(len(BA))):\n\t\t\tit.next()\n\t\tmake_output_fits()\n\t\tprint(datetime.now() - startTime)\n\nelse:\n\tset_globals()\n\tfor nn,i in enumerate(BA):\n\t\tmcmc_one(i)\n\tmake_output_fits()\n\tprint(datetime.now() - startTime)", "meta": {"hexsha": "8e9be3bc96550dcc8fffac2fcc143ef9bf445575", "size": 17806, "ext": "py", "lang": "Python", "max_stars_repo_path": "ptmcmc.py", "max_stars_repo_name": "amyharris2/ptmcmc", "max_stars_repo_head_hexsha": "f19c60faa3c60ec5899f210e3d7345cc9a66b568", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "ptmcmc.py", "max_issues_repo_name": "amyharris2/ptmcmc", "max_issues_repo_head_hexsha": "f19c60faa3c60ec5899f210e3d7345cc9a66b568", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ptmcmc.py", "max_forks_repo_name": "amyharris2/ptmcmc", "max_forks_repo_head_hexsha": "f19c60faa3c60ec5899f210e3d7345cc9a66b568", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.6529680365, "max_line_length": 600, "alphanum_fraction": 0.6926316972, "include": true, "reason": "import numpy,import scipy,from scipy,from astropy", "num_tokens": 5379, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6187804337438501, "lm_q2_score": 0.3106943768319878, "lm_q1q2_score": 0.1922516012578726}} {"text": "from __future__ import division\nimport numpy as np\nfrom functools import partial\nfrom builtins import zip\n\nfrom pybasicbayes.distributions import DiagonalRegression, Gaussian, Regression\n\nimport pyhsmm\nfrom pyhsmm.util.general import list_split\n\nfrom pyslds.states import HMMSLDSStatesPython, HMMSLDSStatesEigen, HSMMSLDSStatesPython, HSMMSLDSStatesEigen\nfrom pyslds.states import HMMCountSLDSStatesPython, HMMCountSLDSStatesEigen, HSMMCountSLDSStatesPython, \\\n HSMMCountSLDSStatesEigen\nfrom pyslds.util import gaussian_map_estimation, regression_map_estimation, gaussian_logprior, regression_logprior\n\n\nclass _SLDSMixin(object):\n def __init__(self,dynamics_distns,emission_distns,init_dynamics_distns,**kwargs):\n self.init_dynamics_distns = init_dynamics_distns\n self.dynamics_distns = dynamics_distns\n\n # Allow for a single, shared emission distribution\n if not isinstance(emission_distns, list):\n self._single_emission = True\n self._emission_distn = emission_distns\n self.emission_distns = [emission_distns] * len(self.dynamics_distns)\n else:\n assert isinstance(emission_distns, list) and \\\n len(emission_distns) == len(dynamics_distns)\n self._single_emission = False\n self.emission_distns = emission_distns\n\n super(_SLDSMixin,self).__init__(\n obs_distns=self.dynamics_distns,**kwargs)\n\n def generate(self, T=100, keep=True, with_noise=True, initial_condition=None, stateseq=None, **kwargs):\n s = self._states_class(model=self, T=T, initialize_from_prior=True, **kwargs)\n s.generate_states(with_noise=with_noise, initial_condition=initial_condition, stateseq=stateseq)\n data = self._generate_obs(s)\n if keep:\n self.states_list.append(s)\n return data + (s.stateseq,)\n\n def _generate_obs(self,s):\n if s.data is None:\n s.data = s.generate_obs()\n else:\n # TODO: Handle missing data\n raise NotImplementedError\n\n return s.data, s.gaussian_states\n\n def smooth(self, data, inputs=None, mask=None):\n self.add_data(data, inputs=inputs, mask=mask)\n s = self.states_list.pop()\n return s.smooth()\n\n @property\n def diagonal_noise(self):\n return all([isinstance(ed, DiagonalRegression) for ed in self.emission_distns])\n\n @property\n def has_missing_data(self):\n return any([s.mask is not None for s in self.states_list])\n\n def heldout_log_likelihood(self, test_masks=None):\n test_masks = [None] * len(self.states_list) if test_masks is None else test_masks\n assert len(test_masks) == len(self.states_list)\n\n hll = 0\n for mask, states in zip(test_masks, self.states_list):\n hll += states.heldout_log_likelihood(test_mask=mask)\n return hll\n\n\nclass _SLDSGibbsMixin(_SLDSMixin):\n def resample_parameters(self):\n self.resample_lds_parameters()\n self.resample_hmm_parameters()\n\n def resample_lds_parameters(self):\n self.resample_init_dynamics_distns()\n self.resample_dynamics_distns()\n self.resample_emission_distns()\n\n def resample_hmm_parameters(self):\n super(_SLDSGibbsMixin,self).resample_parameters()\n\n def resample_init_dynamics_distns(self):\n for state, d in enumerate(self.init_dynamics_distns):\n d.resample(\n [s.gaussian_states[0] for s in self.states_list\n if s.stateseq[0] == state])\n self._clear_caches()\n\n def resample_dynamics_distns(self):\n zs = [s.stateseq[:-1] for s in self.states_list]\n xs = [np.hstack((s.gaussian_states[:-1], s.inputs[:-1]))\n for s in self.states_list]\n ys = [s.gaussian_states[1:] for s in self.states_list]\n\n for state, d in enumerate(self.dynamics_distns):\n d.resample(\n [(x[z == state], y[z == state])\n for x, y, z in zip(xs, ys, zs)])\n self._clear_caches()\n\n def resample_emission_distns(self):\n if self._single_emission:\n data = [(np.hstack((s.gaussian_states, s.inputs)), s.data)\n for s in self.states_list]\n mask = [s.mask for s in self.states_list] if self.has_missing_data else None\n\n if self.has_missing_data:\n self._emission_distn.resample(data=data, mask=mask)\n else:\n self._emission_distn.resample(data=data)\n else:\n for state, d in enumerate(self.emission_distns):\n data = [(np.hstack((s.gaussian_states[s.stateseq == state],\n s.inputs[s.stateseq == state])),\n s.data[s.stateseq == state])\n for s in self.states_list]\n\n mask = [s.mask[s.stateseq == state] for s in self.states_list] \\\n if self.has_missing_data else None\n\n if self.has_missing_data:\n d.resample(data=data, mask=mask)\n else:\n d.resample(data=data)\n\n\n self._clear_caches()\n\n def resample_obs_distns(self):\n pass # handled in resample_parameters\n\n ### joblib parallel\n\n def _joblib_resample_states(self,states_list,num_procs):\n from joblib import Parallel, delayed\n import pyslds.parallel as parallel\n\n if len(states_list) > 0:\n joblib_args = list(map(self._get_joblib_pair, states_list))\n\n parallel.model = self\n parallel.args = list_split(joblib_args, num_procs)\n\n idxs = range(len(parallel.args))\n raw_stateseqs = Parallel(n_jobs=num_procs,backend='multiprocessing')\\\n (list(map(delayed(parallel._get_sampled_stateseq), idxs)))\n\n flatten = lambda lst: [x for y in lst for x in y]\n raw_stateseqs = flatten(raw_stateseqs)\n\n # since list_split might reorder things, do the same to states_list\n states_list = flatten(list_split(states_list, num_procs))\n\n for s, tup in zip(states_list, raw_stateseqs):\n s.stateseq, s.gaussian_states, s._normalizer = tup\n\n\nclass _SLDSVBEMMixin(_SLDSMixin):\n\n def _vb_E_step(self):\n # update the variational approximation for the states\n for state in self.states_list:\n state.vb_E_step()\n\n def _vb_M_step(self):\n # Update the HMM parameters\n self._M_step_init_state_distn()\n self._M_step_trans_distn()\n\n # Update the LDS parameters\n self._M_step_init_dynamics_distn()\n self._M_step_dynamics_distn()\n self._M_step_emission_distn()\n\n def _M_step_init_dynamics_distn(self):\n sum_tuples = lambda lst: list(map(sum, zip(*lst)))\n E_init_stats = lambda i, s: \\\n tuple(s.expected_states[0, i] * stat for stat in s.E_init_stats)\n\n for state, d in enumerate(self.init_dynamics_distns):\n gaussian_map_estimation(sum_tuples(E_init_stats(state, s) for s in self.states_list), d)\n\n def _M_step_dynamics_distn(self):\n contract = partial(np.tensordot, axes=1)\n sum_tuples = lambda lst: list(map(sum, zip(*lst)))\n\n E_dyn_stats = lambda i, s: \\\n tuple(contract(s.expected_states[:-1, i], stat) for stat in s.E_dynamics_stats)\n\n for state, d in enumerate(self.dynamics_distns):\n regression_map_estimation(sum_tuples(E_dyn_stats(state, s) for s in self.states_list), d)\n\n def _M_step_emission_distn(self):\n contract = partial(np.tensordot, axes=1)\n sum_tuples = lambda lst: list(map(sum, zip(*lst)))\n\n if self._single_emission:\n E_emi_stats = lambda s: \\\n tuple(np.sum(stat, axis=0) for stat in s.E_emission_stats)\n stats = sum_tuples(E_emi_stats(s) for s in self.states_list)\n regression_map_estimation(stats, self._emission_distn)\n else:\n E_emi_stats = lambda i, s: \\\n tuple(contract(s.expected_states[:, i], stat) for stat in s.E_emission_stats)\n for state, d in enumerate(self.emission_distns):\n regression_map_estimation(sum_tuples(E_emi_stats(state, s) for s in self.states_list), d)\n\n def VBEM_step(self, n_iter=1):\n for _ in range(n_iter):\n self._vb_E_step()\n self._vb_M_step()\n\n def VBEM_ELBO(self):\n # log p(theta)\n # todo: include transition distribution and init state distribution!\n elbo = np.sum([gaussian_logprior(id) for id in self.init_dynamics_distns])\n elbo += np.sum([regression_logprior(dd) for dd in self.dynamics_distns])\n\n if self._single_emission:\n elbo += regression_logprior(self.emission_distns[0])\n else:\n elbo += np.sum([regression_logprior(ed) for ed in self.emission_distns])\n\n # E_q [log p(z, x, y, theta)]\n elbo += sum(s.vb_elbo() for s in self.states_list)\n return elbo\n\n\nclass _SLDSMeanFieldMixin(_SLDSMixin):\n def meanfield_update_parameters(self):\n self.meanfield_update_init_dynamics_distns()\n self.meanfield_update_dynamics_distns()\n self.meanfield_update_emission_distns()\n super(_SLDSMeanFieldMixin, self).meanfield_update_parameters()\n\n def meanfield_update_init_dynamics_distns(self):\n sum_tuples = lambda lst: list(map(sum, zip(*lst)))\n E_stats = lambda i, s: \\\n tuple(s.expected_states[0,i] * stat for stat in s.E_init_stats)\n\n for state, d in enumerate(self.init_dynamics_distns):\n d.meanfieldupdate(\n stats=sum_tuples(E_stats(state, s) for s in self.states_list))\n\n def meanfield_update_dynamics_distns(self):\n contract = partial(np.tensordot, axes=1)\n sum_tuples = lambda lst: list(map(sum, zip(*lst)))\n E_stats = lambda i, s: \\\n tuple(contract(s.expected_states[1:,i], stat) for stat in s.E_dynamics_stats)\n\n for state, d in enumerate(self.dynamics_distns):\n d.meanfieldupdate(\n stats=sum_tuples(E_stats(state, s) for s in self.states_list))\n\n def meanfield_update_emission_distns(self):\n sum_tuples = lambda lst: list(map(sum, zip(*lst)))\n\n if self._single_emission:\n E_stats = lambda s: \\\n tuple(np.sum(stat, axis=0) for stat in s.E_emission_stats)\n\n self._emission_distn.meanfieldupdate(\n stats=sum_tuples(E_stats(s) for s in self.states_list))\n else:\n contract = partial(np.tensordot, axes=1)\n E_stats = lambda i, s: \\\n tuple(contract(s.expected_states[:, i], stat) for stat in s.E_emission_stats)\n\n for state, d in enumerate(self.emission_distns):\n d.meanfieldupdate(\n stats=sum_tuples(E_stats(state, s) for s in self.states_list))\n\n def meanfield_update_obs_distns(self):\n pass # handled in meanfield_update_parameters\n\n ### init\n def _init_mf_from_gibbs(self):\n # Now also update the emission and dynamics params\n for ed in self.emission_distns:\n if hasattr(ed, \"_initialize_mean_field\"):\n ed._initialize_mean_field()\n for dd in self.dynamics_distns:\n if hasattr(dd, \"_initialize_mean_field\"):\n dd._initialize_mean_field()\n\n for s in self.states_list:\n s._init_mf_from_gibbs()\n\n ### vlb\n\n def vlb(self, states_last_updated=False):\n vlb = 0.\n vlb += sum(s.get_vlb(states_last_updated) for s in self.states_list)\n vlb += self.trans_distn.get_vlb()\n vlb += self.init_state_distn.get_vlb()\n vlb += sum(d.get_vlb() for d in self.init_dynamics_distns)\n vlb += sum(d.get_vlb() for d in self.dynamics_distns)\n if self._single_emission:\n vlb += self._emission_distn.get_vlb()\n else:\n vlb += sum(d.get_vlb() for d in self.emission_distns)\n return vlb\n\n\nclass HMMSLDSPython(_SLDSGibbsMixin, _SLDSVBEMMixin, _SLDSMeanFieldMixin, pyhsmm.models.HMMPython):\n _states_class = HMMSLDSStatesPython\n\n\nclass HMMSLDS(_SLDSGibbsMixin, _SLDSVBEMMixin, _SLDSMeanFieldMixin, pyhsmm.models.HMM):\n _states_class = HMMSLDSStatesEigen\n\n\nclass HSMMSLDSPython(_SLDSGibbsMixin, _SLDSVBEMMixin, _SLDSMeanFieldMixin, pyhsmm.models.HSMMPython):\n _states_class = HSMMSLDSStatesPython\n\n\nclass HSMMSLDS(_SLDSGibbsMixin, _SLDSVBEMMixin, _SLDSMeanFieldMixin, pyhsmm.models.HSMM):\n _states_class = HSMMSLDSStatesEigen\n\n\nclass WeakLimitHDPHMMSLDS(_SLDSGibbsMixin, _SLDSVBEMMixin, _SLDSMeanFieldMixin,\n pyhsmm.models.WeakLimitHDPHMM):\n _states_class = HMMSLDSStatesEigen\n\n\nclass WeakLimitStickyHDPHMMSLDS(\n _SLDSGibbsMixin, _SLDSVBEMMixin, _SLDSMeanFieldMixin,\n pyhsmm.models.WeakLimitStickyHDPHMM):\n _states_class = HMMSLDSStatesEigen\n\n\nclass WeakLimitHDPHSMMSLDS(_SLDSGibbsMixin, _SLDSVBEMMixin, _SLDSMeanFieldMixin,\n pyhsmm.models.WeakLimitHDPHSMM):\n _states_class = HSMMSLDSStatesEigen\n\n\n## Default constructors\n\ndef _default_model(model_class, K, D_obs, D_latent, D_input=0,\n mu_inits=None, sigma_inits=None,\n As=None, Bs=None, sigma_statess=None,\n Cs=None, Ds=None, sigma_obss=None,\n alpha=3.0, init_state_distn='uniform',\n **kwargs):\n\n # Initialize init_dynamics_distns\n init_dynamics_distns = \\\n [Gaussian(nu_0=D_latent+3,\n sigma_0=3.*np.eye(D_latent),\n mu_0=np.zeros(D_latent),\n kappa_0=0.01)\n for _ in range(K)]\n\n if mu_inits is not None:\n assert isinstance(mu_inits, list) and len(mu_inits) == K\n for id, mu in zip(init_dynamics_distns, mu_inits):\n id.mu = mu\n\n if sigma_inits is not None:\n assert isinstance(sigma_inits, list) and len(sigma_inits) == K\n for id, sigma in zip(init_dynamics_distns, sigma_inits):\n id.sigma = sigma\n\n # Initialize dynamics distributions\n dynamics_distns = [Regression(\n nu_0=D_latent + 1,\n S_0=D_latent * np.eye(D_latent),\n M_0=np.hstack((.99 * np.eye(D_latent), np.zeros((D_latent, D_input)))),\n K_0=D_latent * np.eye(D_latent + D_input))\n for _ in range(K)]\n if As is not None:\n assert isinstance(As, list) and len(As) == K\n if D_input > 0:\n assert isinstance(Bs, list) and len(Bs) == K\n As = [np.hstack((A, B)) for A,B in zip(As, Bs)]\n else:\n # As = [random_rotation(D_latent) for _ in range(K)]\n As = [np.eye(D_latent) for _ in range(K)]\n if D_input > 0:\n As = [np.hstack((A, np.zeros((D_latent, D_input))))\n for A in As]\n for dd, A in zip(dynamics_distns, As):\n dd.A = A\n\n if sigma_statess is not None:\n assert isinstance(sigma_statess, list) and len(sigma_statess) == K\n else:\n sigma_statess = [np.eye(D_latent) for _ in range(K)]\n\n for dd, sigma in zip(dynamics_distns, sigma_statess):\n dd.sigma = sigma\n\n # Initialize emission distributions\n _single_emission = (Cs is not None) and (not isinstance(Cs, list))\n\n if _single_emission:\n if D_input > 0:\n assert Ds is not None and not isinstance(Ds, list)\n Cs = np.hstack((Cs, Ds))\n\n if sigma_obss is None:\n sigma_obss = np.eye(D_obs)\n\n emission_distns = Regression(\n nu_0=D_obs + 3,\n S_0=D_obs * np.eye(D_obs),\n M_0=np.zeros((D_obs, D_latent + D_input)),\n K_0=D_obs * np.eye(D_latent + D_input),\n A=Cs, sigma=sigma_obss)\n\n else:\n emission_distns = [Regression(\n nu_0=D_obs + 1,\n S_0=D_obs * np.eye(D_obs),\n M_0=np.zeros((D_obs, D_latent + D_input)),\n K_0=D_obs * np.eye(D_latent + D_input))\n for _ in range(K)]\n\n if Cs is not None and sigma_obss is not None:\n assert isinstance(Cs, list) and len(Cs) == K\n assert isinstance(sigma_obss, list) and len(sigma_obss) == K\n if D_input > 0:\n assert isinstance(Ds, list) and len(Ds) == K\n Cs = [np.hstack((C, D)) for C,D in zip(Cs, Ds)]\n else:\n Cs = [np.zeros((D_obs, D_latent + D_input)) for _ in range(K)]\n sigma_obss = [0.05 * np.eye(D_obs) for _ in range(K)]\n\n for ed, C, sigma in zip(emission_distns, Cs, sigma_obss):\n ed.A = C\n ed.sigma = sigma\n\n model = model_class(\n init_dynamics_distns=init_dynamics_distns,\n dynamics_distns=dynamics_distns,\n emission_distns=emission_distns,\n init_state_distn=init_state_distn,\n alpha=alpha,\n **kwargs)\n\n return model\n\ndef DefaultSLDS(K, D_obs, D_latent, D_input=0,\n mu_inits=None, sigma_inits=None,\n As=None, Bs=None, sigma_statess=None,\n Cs=None, Ds=None, sigma_obss=None,\n alpha=3.,\n **kwargs):\n return _default_model(HMMSLDS, K, D_obs, D_latent, D_input=D_input,\n mu_inits=mu_inits, sigma_inits=sigma_inits,\n As=As, Bs=Bs, sigma_statess=sigma_statess,\n Cs=Cs, Ds=Ds, sigma_obss=sigma_obss,\n alpha=alpha,\n **kwargs)\n\n\ndef DefaultWeakLimitHDPSLDS(K, D_obs, D_latent, D_input=0,\n mu_inits=None, sigma_inits=None,\n As=None, Bs=None, sigma_statess=None,\n Cs=None, Ds=None, sigma_obss=None,\n alpha=3., gamma=3.,\n **kwargs):\n return _default_model(WeakLimitHDPHMMSLDS, K, D_obs, D_latent, D_input=D_input,\n mu_inits=mu_inits, sigma_inits=sigma_inits,\n As=As, Bs=Bs, sigma_statess=sigma_statess,\n Cs=Cs, Ds=Ds, sigma_obss=sigma_obss,\n alpha=alpha, gamma=gamma,\n **kwargs)\n\ndef DefaultWeakLimitStickyHDPSLDS(K, D_obs, D_latent, D_input=0,\n mu_inits=None, sigma_inits=None,\n As=None, Bs=None, sigma_statess=None,\n Cs=None, Ds=None, sigma_obss=None,\n alpha=3., gamma=3., kappa=10.,\n **kwargs):\n return _default_model(WeakLimitStickyHDPHMMSLDS, K, D_obs, D_latent, D_input=D_input,\n mu_inits=mu_inits, sigma_inits=sigma_inits,\n As=As, Bs=Bs, sigma_statess=sigma_statess,\n Cs=Cs, Ds=Ds, sigma_obss=sigma_obss,\n kappa=kappa, alpha=alpha, gamma=gamma,\n **kwargs)\n\n\nclass _CountSLDSMixin(_SLDSGibbsMixin):\n\n def resample_emission_distns(self):\n if self._single_emission:\n data = [(np.hstack((s.gaussian_states, s.inputs)), s.data)\n for s in self.states_list]\n mask = [s.mask for s in self.states_list] if self.has_missing_data else None\n omega = [s.omega for s in self.states_list]\n self._emission_distn.resample(data=data, mask=mask, omega=omega)\n\n else:\n for state, d in enumerate(self.emission_distns):\n data = [(np.hstack((s.gaussian_states[s.stateseq == state],\n s.inputs[s.stateseq == state])),\n s.data[s.stateseq == state])\n for s in self.states_list]\n mask = [s.mask[s.stateseq == state] for s in self.states_list] \\\n if self.has_missing_data else None\n omega = [s.omega[s.stateseq == state] for s in self.states_list]\n d.resample(data=data, mask=mask, omega=omega)\n\n self._clear_caches()\n\n\nclass HMMCountSLDSPython(_CountSLDSMixin, pyhsmm.models.HMMPython):\n _states_class = HMMCountSLDSStatesPython\n\n\nclass HMMCountSLDS(_CountSLDSMixin, pyhsmm.models.HMM):\n _states_class = HMMCountSLDSStatesEigen\n\n\nclass HSMMCountSLDSPython(_CountSLDSMixin, pyhsmm.models.HSMMPython):\n _states_class = HSMMCountSLDSStatesPython\n\n\nclass HSMMCountSLDS(_CountSLDSMixin, pyhsmm.models.HSMM):\n _states_class = HSMMCountSLDSStatesEigen\n\n\nclass WeakLimitHDPHMMCountSLDS(_CountSLDSMixin, pyhsmm.models.WeakLimitHDPHMM):\n _states_class = HMMCountSLDSStatesEigen\n\n\nclass WeakLimitStickyHDPHMMCountSLDS(\n _CountSLDSMixin, pyhsmm.models.WeakLimitStickyHDPHMM):\n _states_class = HMMCountSLDSStatesEigen\n\n\nclass WeakLimitHDPHSMMCountSLDS(\n _CountSLDSMixin, pyhsmm.models.WeakLimitHDPHSMM):\n _states_class = HSMMCountSLDSStatesEigen\n", "meta": {"hexsha": "f558be22a0b1ae00e56382c2073d87634c8f4764", "size": 20741, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyslds/models.py", "max_stars_repo_name": "nitinshyamk/pyslds", "max_stars_repo_head_hexsha": "a90ce829e807a5ae0bacda806a8c516e4ff3cba7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 77, "max_stars_repo_stars_event_min_datetime": "2016-12-14T18:35:41.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-21T23:27:43.000Z", "max_issues_repo_path": "pyslds/models.py", "max_issues_repo_name": "nitinshyamk/pyslds", "max_issues_repo_head_hexsha": "a90ce829e807a5ae0bacda806a8c516e4ff3cba7", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 29, "max_issues_repo_issues_event_min_datetime": "2016-11-18T14:02:10.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-16T22:02:41.000Z", "max_forks_repo_path": "pyslds/models.py", "max_forks_repo_name": "nitinshyamk/pyslds", "max_forks_repo_head_hexsha": "a90ce829e807a5ae0bacda806a8c516e4ff3cba7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 31, "max_forks_repo_forks_event_min_datetime": "2017-02-21T10:43:25.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-08T17:00:33.000Z", "avg_line_length": 38.197053407, "max_line_length": 114, "alphanum_fraction": 0.6278385806, "include": true, "reason": "import numpy", "num_tokens": 5252, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5926665999540697, "lm_q2_score": 0.3242354055108441, "lm_q1q2_score": 0.192163495368841}} {"text": "from __future__ import annotations\n\nfrom collections import defaultdict\nfrom dataclasses import dataclass\nfrom functools import cache\nfrom itertools import permutations\nfrom itertools import product\nfrom typing import Literal\n\nimport numpy as np\n\nfrom chemex.model import model\n\n_BASES = {\n \"ixy\": [\"ix\", \"iy\"],\n \"iz\": [\"iz\"],\n \"izsz\": [\"iz\", \"2izsz\"],\n \"iz_eq\": [\"ie\", \"iz\"],\n \"ixyz\": [\"ix\", \"iy\", \"iz\"],\n \"ixyz_eq\": [\"ie\", \"ix\", \"iy\", \"iz\"],\n \"ixysxy\": [\"2ixsx\", \"2ixsy\", \"2iysx\", \"2iysy\"],\n \"ixy_ixysxy\": [\"ix\", \"iy\", \"2ixsx\", \"2ixsy\", \"2iysx\", \"2iysy\"],\n \"ixyzsz\": [\"ix\", \"iy\", \"iz\", \"2ixsz\", \"2iysz\", \"2izsz\"],\n \"ixyzsz_diff\": [\"ix\", \"iy\", \"iz\", \"2ixsz\", \"2iysz\", \"2izsz\"],\n \"ixyzsz_eq\": [\"ie\", \"ix\", \"iy\", \"iz\", \"2ixsz\", \"2iysz\", \"2izsz\"],\n \"ixyzsxyz\": [\n \"ix\",\n \"iy\",\n \"iz\",\n \"sx\",\n \"sy\",\n \"sz\",\n \"2ixsz\",\n \"2iysz\",\n \"2izsx\",\n \"2izsy\",\n \"2ixsx\",\n \"2ixsy\",\n \"2iysx\",\n \"2iysy\",\n \"2izsz\",\n ],\n \"ixyzsxyz_eq\": [\n \"ie\",\n \"se\",\n \"ix\",\n \"iy\",\n \"iz\",\n \"sx\",\n \"sy\",\n \"sz\",\n \"2ixsz\",\n \"2iysz\",\n \"2izsx\",\n \"2izsy\",\n \"2ixsx\",\n \"2ixsy\",\n \"2iysx\",\n \"2iysy\",\n \"2izsz\",\n ],\n}\n_TRANSITIONS: dict[str, tuple[tuple[str, str, float], ...]] = {\n \"r2_i_{state}\": ((\"ix\", \"ix\", -1.0), (\"iy\", \"iy\", -1.0)),\n \"r2_s_{state}\": ((\"sx\", \"sx\", -1.0), (\"sy\", \"sy\", -1.0)),\n \"r1_i_{state}\": ((\"iz\", \"iz\", -1.0), (\"iz\", \"ie\", +1.0)),\n \"r1_s_{state}\": ((\"sz\", \"sz\", -1.0), (\"sz\", \"se\", +1.0)),\n \"r2a_i_{state}\": ((\"2ixsz\", \"2ixsz\", -1.0), (\"2iysz\", \"2iysz\", -1.0)),\n \"r2a_s_{state}\": ((\"2izsx\", \"2izsx\", -1.0), (\"2izsy\", \"2izsy\", -1.0)),\n \"r2mq_is_{state}\": (\n (\"2ixsx\", \"2ixsx\", -1.0),\n (\"2ixsy\", \"2ixsy\", -1.0),\n (\"2iysx\", \"2iysx\", -1.0),\n (\"2iysy\", \"2iysy\", -1.0),\n ),\n \"r1a_is_{state}\": ((\"2izsz\", \"2izsz\", -1.0),),\n \"etaxy_i_{state}\": (\n (\"ix\", \"2ixsz\", -1.0),\n (\"iy\", \"2iysz\", -1.0),\n (\"2ixsz\", \"ix\", -1.0),\n (\"2iysz\", \"iy\", -1.0),\n ),\n \"etaxy_s_{state}\": (\n (\"sx\", \"2izsx\", -1.0),\n (\"sy\", \"2izsy\", -1.0),\n (\"2izsx\", \"sx\", -1.0),\n (\"2izsy\", \"sy\", -1.0),\n ),\n \"etaz_i_{state}\": (\n (\"iz\", \"2izsz\", -1.0),\n (\"2izsz\", \"iz\", -1.0),\n (\"2izsz\", \"ie\", +1.0),\n ),\n \"etaz_s_{state}\": (\n (\"sz\", \"2izsz\", -1.0),\n (\"2izsz\", \"sz\", -1.0),\n (\"2izsz\", \"se\", +1.0),\n ),\n \"sigma_is_{state}\": (\n (\"iz\", \"sz\", -1.0),\n (\"sz\", \"iz\", -1.0),\n (\"sz\", \"ie\", +1.0),\n (\"iz\", \"se\", +1.0),\n ),\n \"mu_is_{state}\": (\n (\"2ixsx\", \"2iysy\", +1.0),\n (\"2ixsy\", \"2iysx\", -1.0),\n (\"2iysx\", \"2ixsy\", -1.0),\n (\"2iysy\", \"2ixsx\", +1.0),\n ),\n \"rotz_i\": (\n (\"ix\", \"iy\", -1.0),\n (\"iy\", \"ix\", +1.0),\n (\"2ixsx\", \"2iysx\", -1.0),\n (\"2iysx\", \"2ixsx\", +1.0),\n (\"2ixsy\", \"2iysy\", -1.0),\n (\"2iysy\", \"2ixsy\", +1.0),\n (\"2ixsz\", \"2iysz\", -1.0),\n (\"2iysz\", \"2ixsz\", +1.0),\n ),\n \"rotz_s\": (\n (\"sx\", \"sy\", -1.0),\n (\"sy\", \"sx\", +1.0),\n (\"2ixsx\", \"2ixsy\", -1.0),\n (\"2ixsy\", \"2ixsx\", +1.0),\n (\"2iysx\", \"2iysy\", -1.0),\n (\"2iysy\", \"2iysx\", +1.0),\n (\"2izsx\", \"2izsy\", -1.0),\n (\"2izsy\", \"2izsx\", +1.0),\n ),\n \"cs_i_{state}\": (\n (\"ix\", \"iy\", -1.0),\n (\"iy\", \"ix\", +1.0),\n (\"2ixsx\", \"2iysx\", -1.0),\n (\"2iysx\", \"2ixsx\", +1.0),\n (\"2ixsy\", \"2iysy\", -1.0),\n (\"2iysy\", \"2ixsy\", +1.0),\n (\"2ixsz\", \"2iysz\", -1.0),\n (\"2iysz\", \"2ixsz\", +1.0),\n ),\n \"cs_s_{state}\": (\n (\"sx\", \"sy\", -1.0),\n (\"sy\", \"sx\", +1.0),\n (\"2ixsx\", \"2ixsy\", -1.0),\n (\"2ixsy\", \"2ixsx\", +1.0),\n (\"2iysx\", \"2iysy\", -1.0),\n (\"2iysy\", \"2iysx\", +1.0),\n (\"2izsx\", \"2izsy\", -1.0),\n (\"2izsy\", \"2izsx\", +1.0),\n ),\n \"carrier_i\": (\n (\"ix\", \"iy\", +1.0),\n (\"iy\", \"ix\", -1.0),\n (\"2ixsx\", \"2iysx\", +1.0),\n (\"2iysx\", \"2ixsx\", -1.0),\n (\"2ixsy\", \"2iysy\", +1.0),\n (\"2iysy\", \"2ixsy\", -1.0),\n (\"2ixsz\", \"2iysz\", +1.0),\n (\"2iysz\", \"2ixsz\", -1.0),\n ),\n \"carrier_s\": (\n (\"sx\", \"sy\", +1.0),\n (\"sy\", \"sx\", -1.0),\n (\"2ixsx\", \"2ixsy\", +1.0),\n (\"2ixsy\", \"2ixsx\", -1.0),\n (\"2iysx\", \"2iysy\", +1.0),\n (\"2iysy\", \"2iysx\", -1.0),\n (\"2izsx\", \"2izsy\", +1.0),\n (\"2izsy\", \"2izsx\", -1.0),\n ),\n \"offset_i\": (\n (\"ix\", \"iy\", +2.0 * np.pi),\n (\"iy\", \"ix\", -2.0 * np.pi),\n (\"2ixsx\", \"2iysx\", +2.0 * np.pi),\n (\"2iysx\", \"2ixsx\", -2.0 * np.pi),\n (\"2ixsy\", \"2iysy\", +2.0 * np.pi),\n (\"2iysy\", \"2ixsy\", -2.0 * np.pi),\n (\"2ixsz\", \"2iysz\", +2.0 * np.pi),\n (\"2iysz\", \"2ixsz\", -2.0 * np.pi),\n ),\n \"offset_s\": (\n (\"sx\", \"sy\", +2.0 * np.pi),\n (\"sy\", \"sx\", -2.0 * np.pi),\n (\"2ixsx\", \"2ixsy\", +2.0 * np.pi),\n (\"2ixsy\", \"2ixsx\", -2.0 * np.pi),\n (\"2iysx\", \"2iysy\", +2.0 * np.pi),\n (\"2iysy\", \"2iysx\", -2.0 * np.pi),\n (\"2izsx\", \"2izsy\", +2.0 * np.pi),\n (\"2izsy\", \"2izsx\", -2.0 * np.pi),\n ),\n \"jeff_i\": (\n (\"ix\", \"iy\", -2.0 * np.pi),\n (\"iy\", \"ix\", +2.0 * np.pi),\n (\"2ixsx\", \"2iysx\", -2.0 * np.pi),\n (\"2iysx\", \"2ixsx\", +2.0 * np.pi),\n (\"2ixsy\", \"2iysy\", -2.0 * np.pi),\n (\"2iysy\", \"2ixsy\", +2.0 * np.pi),\n (\"2ixsz\", \"2iysz\", -2.0 * np.pi),\n (\"2iysz\", \"2ixsz\", +2.0 * np.pi),\n ),\n \"j_is_{state}\": (\n (\"ix\", \"2iysz\", -np.pi),\n (\"2iysz\", \"ix\", +np.pi),\n (\"2ixsz\", \"iy\", -np.pi),\n (\"iy\", \"2ixsz\", +np.pi),\n (\"sx\", \"2izsy\", -np.pi),\n (\"2izsy\", \"sx\", +np.pi),\n (\"2izsx\", \"sy\", -np.pi),\n (\"sy\", \"2izsx\", +np.pi),\n ),\n \"d_{state}\": (\n (\"ix\", \"ix\", -1.0),\n (\"iy\", \"iy\", -1.0),\n (\"iz\", \"iz\", -1.0),\n (\"sx\", \"sx\", -1.0),\n (\"sy\", \"sy\", -1.0),\n (\"sz\", \"sz\", -1.0),\n (\"2ixsz\", \"2ixsz\", -1.0),\n (\"2iysz\", \"2iysz\", -1.0),\n (\"2izsx\", \"2izsx\", -1.0),\n (\"2izsy\", \"2izsy\", -1.0),\n (\"2ixsx\", \"2ixsx\", -1.0),\n (\"2ixsy\", \"2ixsy\", -1.0),\n (\"2iysx\", \"2iysx\", -1.0),\n (\"2iysy\", \"2iysy\", -1.0),\n (\"2izsz\", \"2izsz\", -1.0),\n ),\n \"b1x_i\": (\n (\"iy\", \"iz\", -2.0 * np.pi),\n (\"iz\", \"iy\", +2.0 * np.pi),\n (\"2iysx\", \"2izsx\", -2.0 * np.pi),\n (\"2izsx\", \"2iysx\", +2.0 * np.pi),\n (\"2iysy\", \"2izsy\", -2.0 * np.pi),\n (\"2izsy\", \"2iysy\", +2.0 * np.pi),\n (\"2iysz\", \"2izsz\", -2.0 * np.pi),\n (\"2izsz\", \"2iysz\", +2.0 * np.pi),\n ),\n \"b1y_i\": (\n (\"iz\", \"ix\", -2.0 * np.pi),\n (\"ix\", \"iz\", +2.0 * np.pi),\n (\"2izsx\", \"2ixsx\", -2.0 * np.pi),\n (\"2ixsx\", \"2izsx\", +2.0 * np.pi),\n (\"2izsy\", \"2ixsy\", -2.0 * np.pi),\n (\"2ixsy\", \"2izsy\", +2.0 * np.pi),\n (\"2izsz\", \"2ixsz\", -2.0 * np.pi),\n (\"2ixsz\", \"2izsz\", +2.0 * np.pi),\n ),\n \"b1x_s\": (\n (\"sy\", \"sz\", -2.0 * np.pi),\n (\"sz\", \"sy\", +2.0 * np.pi),\n (\"2ixsy\", \"2ixsz\", -2.0 * np.pi),\n (\"2ixsz\", \"2ixsy\", +2.0 * np.pi),\n (\"2iysy\", \"2iysz\", -2.0 * np.pi),\n (\"2iysz\", \"2iysy\", +2.0 * np.pi),\n (\"2izsy\", \"2izsz\", -2.0 * np.pi),\n (\"2izsz\", \"2izsy\", +2.0 * np.pi),\n ),\n \"b1y_s\": (\n (\"sz\", \"sx\", -2.0 * np.pi),\n (\"sx\", \"sz\", +2.0 * np.pi),\n (\"2ixsz\", \"2ixsx\", -2.0 * np.pi),\n (\"2ixsx\", \"2ixsz\", +2.0 * np.pi),\n (\"2iysz\", \"2iysx\", -2.0 * np.pi),\n (\"2iysx\", \"2iysz\", +2.0 * np.pi),\n (\"2izsz\", \"2izsx\", -2.0 * np.pi),\n (\"2izsx\", \"2izsz\", +2.0 * np.pi),\n ),\n}\n_ATOMS = {\n atoms: {\"i\": atoms[0], \"s\": atoms[1]} for atoms in (\"hn\", \"hc\", \"nh\", \"ch\", \"cn\")\n}\n\n\n@cache\ndef _build_vectors(basis: Basis) -> dict[str, np.ndarray]:\n size = len(basis) * len(model.states)\n vectors: defaultdict[str, np.ndarray] = defaultdict(lambda: np.zeros((size, 1)))\n for index, (state, name) in enumerate(product(model.states, basis.components)):\n vectors[f\"{name}_{state}\"][index] = 1.0\n vectors[name][index] = 1.0\n return dict(vectors)\n\n\ndef _get_indices(\n basis: Basis, transition_name: str, state: str\n) -> tuple[tuple[list[int], list[int]], list[float]]:\n rows: list[int] = []\n cols: list[int] = []\n vals: list[float] = []\n offset = model.states.index(state) * len(basis)\n for start, end, value in _TRANSITIONS[transition_name]:\n if {start, end}.issubset(basis.components):\n rows.append(basis.components.index(start) + offset)\n cols.append(basis.components.index(end) + offset)\n vals.append(value)\n return (rows, cols), vals\n\n\ndef _build_spin_matrices(basis: Basis) -> dict[str, np.ndarray]:\n size = len(basis) * len(model.states)\n matrices: dict[str, np.ndarray] = defaultdict(lambda: np.zeros((size, size)))\n for transition_name, state in product(_TRANSITIONS, model.states):\n if not basis.type.endswith(\"_diff\") and transition_name.startswith(\"d_\"):\n continue\n name = transition_name.format(state=state)\n indices, values = _get_indices(basis, transition_name, state)\n if values:\n matrices[name][indices] = values\n return matrices\n\n\ndef _build_exchange_matrices(basis: Basis) -> dict[str, np.ndarray]:\n matrices: dict[str, np.ndarray] = {}\n for (i1, s1), (i2, s2) in permutations(enumerate(model.states), r=2):\n name = f\"k{s1}{s2}\"\n matrix = np.zeros((len(model.states), len(model.states)))\n matrix[((i1, i2), i1)] = -1.0, 1.0\n matrices[name] = np.kron(matrix, np.eye(len(basis)))\n return matrices\n\n\n@cache\ndef _build_matrices(basis: Basis) -> dict[str, np.ndarray]:\n return _build_exchange_matrices(basis) | _build_spin_matrices(basis)\n\n\n@dataclass(frozen=True)\nclass Basis:\n type: str\n extension: Literal[\"\", \"dq\", \"tq\"] = \"\"\n spin_system: str = \"\"\n\n @property\n def name(self):\n return \".\".join([self.type, self.extension, self.spin_system])\n\n @property\n def components(self):\n return _BASES[self.type]\n\n @property\n def atoms(self):\n return {\n letter: atom\n for letter, atom in _ATOMS.get(self.spin_system, {}).items()\n if letter in self.type\n }\n\n @property\n def vectors(self) -> dict[str, np.ndarray]:\n return dict(_build_vectors(self))\n\n @property\n def matrices(self) -> dict[str, np.ndarray]:\n return _build_matrices(self)\n\n @property\n def required_names(self) -> set[str]:\n required_names = set(self.matrices)\n required_names |= {f\"p{state}\" for state in model.states}\n return required_names\n\n def __len__(self):\n return len(self.components)\n", "meta": {"hexsha": "6871d242a87563196769668b49bf737e1f7830fb", "size": 10945, "ext": "py", "lang": "Python", "max_stars_repo_path": "chemex/nmr/basis.py", "max_stars_repo_name": "gbouvignies/chemex", "max_stars_repo_head_hexsha": "b021650928b6db930281957222529bc6bcab8aa2", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 11, "max_stars_repo_stars_event_min_datetime": "2015-03-16T16:45:42.000Z", "max_stars_repo_stars_event_max_datetime": "2018-09-17T08:43:58.000Z", "max_issues_repo_path": "chemex/nmr/basis.py", "max_issues_repo_name": "gbouvignies/chemex", "max_issues_repo_head_hexsha": "b021650928b6db930281957222529bc6bcab8aa2", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 33, "max_issues_repo_issues_event_min_datetime": "2015-01-12T16:46:48.000Z", "max_issues_repo_issues_event_max_datetime": "2018-03-29T15:01:15.000Z", "max_forks_repo_path": "chemex/nmr/basis.py", "max_forks_repo_name": "gbouvignies/chemex", "max_forks_repo_head_hexsha": "b021650928b6db930281957222529bc6bcab8aa2", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2015-01-15T21:53:16.000Z", "max_forks_repo_forks_event_max_datetime": "2018-01-04T15:33:52.000Z", "avg_line_length": 29.9863013699, "max_line_length": 85, "alphanum_fraction": 0.4339881224, "include": true, "reason": "import numpy", "num_tokens": 4224, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5926666143434, "lm_q2_score": 0.3242353924510608, "lm_q1q2_score": 0.1921634922942738}} {"text": "from collections import OrderedDict\n\nimport torch\nimport torchvision\n\nimport torch.nn.functional as F\nfrom torch import nn, Tensor\n\nfrom torchvision.ops import boxes as box_ops\n\nfrom torchvision.ops import roi_align\n\nfrom torchvision.models.detection import _utils as det_utils\n\nfrom torch.jit.annotations import Optional, List, Dict, Tuple\nimport numpy as np\n\nfrom TorchUtils import tensor_isin\nfrom nucls_model.torchvision_detection_utils.transforms import \\\n remove_degenerate_bboxes\n\n\n@torch.jit._script_if_tracing\ndef global_nms(boxes, scores, iou_threshold):\n # type: (Tensor, Tensor, float) -> Tensor\n \"\"\"\n Performs non-maximum suppression globally (regardless of category).\n\n Parameters\n ----------\n boxes : Tensor[N, 4]\n boxes where NMS will be performed. They\n are expected to be in (x1, y1, x2, y2) format\n scores : Tensor[N]\n scores for each one of the boxes\n iou_threshold : float\n discards all overlapping boxes\n with IoU > iou_threshold\n\n Returns\n -------\n keep : Tensor\n int64 tensor with the indices of\n the elements that have been kept by NMS, sorted\n in decreasing order of scores\n \"\"\"\n if boxes.numel() == 0:\n return torch.empty((0,), dtype=torch.int64, device=boxes.device)\n else:\n keep = box_ops.nms(boxes, scores, iou_threshold)\n return keep\n\n\n# noinspection LongLine,PyTypeHints\ndef fastrcnn_loss(\n class_logits, box_regression, labels, regression_targets,\n ignore_label=None, batched_nms=True):\n # type: (Tensor, Tensor, List[Tensor], List[Tensor]) -> Tuple[Tensor, Tensor]\n \"\"\"\n Computes the loss for Faster R-CNN.\n\n Arguments:\n class_logits (Tensor)\n box_regression (Tensor)\n labels (list[BoxList])\n regression_targets (Tensor)\n ignore_label (int)\n batched_nms (bool)\n\n Returns:\n classification_loss (Tensor)\n box_loss (Tensor)\n \"\"\"\n\n labels = torch.cat(labels, dim=0)\n regression_targets = torch.cat(regression_targets, dim=0)\n\n # Mohamed: Ignore certain nuclei from classification loss.\n # Do not to modify in-place since labels are used later here!!\n clkeep = labels != ignore_label\n classification_loss = F.cross_entropy(class_logits[clkeep], labels[clkeep])\n\n # get indices that correspond to the regression targets for\n # the corresponding ground truth labels, to be used with\n # advanced indexing\n sampled_pos_inds_subset = torch.nonzero(labels > 0).squeeze(1)\n if batched_nms:\n labels_pos = labels[sampled_pos_inds_subset]\n else:\n # Mohamed: only two classes (bckgrnd, frgrnd) for box regression\n labs = 0 + labels\n labs[labs > 1] = 1\n labels_pos = labs[sampled_pos_inds_subset]\n N, num_classes = class_logits.shape\n box_regression = box_regression.reshape(N, -1, 4)\n\n box_loss = det_utils.smooth_l1_loss(\n box_regression[sampled_pos_inds_subset, labels_pos],\n regression_targets[sampled_pos_inds_subset],\n beta=1 / 9,\n size_average=False,\n )\n box_loss = box_loss / labels.numel()\n\n return classification_loss, box_loss\n\n\ndef maskrcnn_inference(x, labels):\n # type: (Tensor, List[Tensor]) -> List[Tensor]\n \"\"\"\n From the results of the CNN, post process the masks\n by taking the mask corresponding to the class with max\n probability (which are of fixed size and directly output\n by the CNN) and return the masks in the mask field of the BoxList.\n\n Arguments:\n x (Tensor): the mask logits\n labels (list[BoxList]): bounding boxes that are used as\n reference, one for ech image\n\n Returns:\n results (list[BoxList]): one BoxList for each image, containing\n the extra field mask\n \"\"\"\n mask_prob = x.sigmoid()\n\n # select masks corresponding to the predicted classes\n num_masks = x.shape[0]\n boxes_per_image = [label.shape[0] for label in labels]\n labels = torch.cat(labels)\n index = torch.arange(num_masks, device=labels.device)\n mask_prob = mask_prob[index, labels][:, None]\n mask_prob = mask_prob.split(boxes_per_image, dim=0)\n\n return mask_prob\n\n\ndef project_masks_on_boxes(gt_masks, boxes, matched_idxs, M):\n # type: (Tensor, Tensor, Tensor, int) -> Tensor\n \"\"\"\n Given segmentation masks and the bounding boxes corresponding\n to the location of the masks in the image, this function\n crops and resizes the masks in the position defined by the\n boxes. This prepares the masks for them to be fed to the\n loss computation as the targets.\n \"\"\"\n matched_idxs = matched_idxs.to(boxes)\n rois = torch.cat([matched_idxs[:, None], boxes], dim=1)\n gt_masks = gt_masks[:, None].to(rois)\n return roi_align(gt_masks, rois, (M, M), 1.)[:, 0]\n\n\n# noinspection LongLine,PyTypeHints\ndef maskrcnn_loss(\n mask_logits, proposals, gt_masks, gt_labels, mask_matched_idxs,\n gt_ismask=None):\n # type: (Tensor, List[Tensor], List[Tensor], List[Tensor], List[Tensor]) -> Tensor\n \"\"\"\n Arguments:\n mask_logits (Tensor)\n proposals (list[BoxList])\n\n Return:\n mask_loss (Tensor): scalar tensor containing the loss\n\n Parameters\n ----------\n gt_ismask\n mask_matched_idxs\n gt_labels\n proposals\n mask_logits\n gt_masks\n \"\"\"\n\n discretization_size = mask_logits.shape[-1]\n labels = [gt_label[idxs] for gt_label, idxs in zip(gt_labels, mask_matched_idxs)]\n mask_targets = [\n project_masks_on_boxes(m, p, i, discretization_size)\n for m, p, i in zip(gt_masks, proposals, mask_matched_idxs)\n ]\n\n labels = torch.cat(labels, dim=0)\n mask_targets = torch.cat(mask_targets, dim=0)\n\n # Mohamed: added this to disregard nuclei without masks (bboxes)\n if gt_ismask is not None:\n keep_idxs = [torch.where(t > 0)[0] for t in gt_ismask]\n keep_list = [\n tensor_isin(idxs, keep_idx)\n for idxs, keep_idx in zip(mask_matched_idxs, keep_idxs)\n ]\n keep_array = torch.cat(keep_list).type(torch.bool)\n mask_logits = mask_logits[keep_array, ...]\n mask_targets = mask_targets[keep_array, ...]\n labels = labels[keep_array]\n\n # torch.mean (in binary_cross_entropy_with_logits) doesn't\n # accept empty tensors, so handle it separately\n if mask_targets.numel() == 0:\n return mask_logits.sum() * 0\n\n mask_loss = F.binary_cross_entropy_with_logits(\n mask_logits[torch.arange(labels.shape[0], device=labels.device), labels], mask_targets\n )\n return mask_loss\n\n\ndef keypoints_to_heatmap(keypoints, rois, heatmap_size):\n # type: (Tensor, Tensor, int) -> Tuple[Tensor, Tensor]\n offset_x = rois[:, 0]\n offset_y = rois[:, 1]\n scale_x = heatmap_size / (rois[:, 2] - rois[:, 0])\n scale_y = heatmap_size / (rois[:, 3] - rois[:, 1])\n\n offset_x = offset_x[:, None]\n offset_y = offset_y[:, None]\n scale_x = scale_x[:, None]\n scale_y = scale_y[:, None]\n\n x = keypoints[..., 0]\n y = keypoints[..., 1]\n\n x_boundary_inds = x == rois[:, 2][:, None]\n y_boundary_inds = y == rois[:, 3][:, None]\n\n x = (x - offset_x) * scale_x\n x = x.floor().long()\n y = (y - offset_y) * scale_y\n y = y.floor().long()\n\n x[x_boundary_inds] = heatmap_size - 1\n y[y_boundary_inds] = heatmap_size - 1\n\n valid_loc = (x >= 0) & (y >= 0) & (x < heatmap_size) & (y < heatmap_size)\n vis = keypoints[..., 2] > 0\n valid = (valid_loc & vis).long()\n\n lin_ind = y * heatmap_size + x\n heatmaps = lin_ind * valid\n\n return heatmaps, valid\n\n\n# noinspection LongLine\ndef _onnx_heatmaps_to_keypoints(maps, maps_i, roi_map_width, roi_map_height,\n widths_i, heights_i, offset_x_i, offset_y_i):\n num_keypoints = torch.scalar_tensor(maps.size(1), dtype=torch.int64)\n\n width_correction = widths_i / roi_map_width\n height_correction = heights_i / roi_map_height\n\n roi_map = F.interpolate(\n maps_i[:, None], size=(int(roi_map_height), int(roi_map_width)), mode='bicubic', align_corners=False)[:, 0]\n\n w = torch.scalar_tensor(roi_map.size(2), dtype=torch.int64)\n pos = roi_map.reshape(num_keypoints, -1).argmax(dim=1)\n\n x_int = (pos % w)\n y_int = ((pos - x_int) // w)\n\n x = (torch.tensor(0.5, dtype=torch.float32) + x_int.to(dtype=torch.float32)) * \\\n width_correction.to(dtype=torch.float32)\n y = (torch.tensor(0.5, dtype=torch.float32) + y_int.to(dtype=torch.float32)) * \\\n height_correction.to(dtype=torch.float32)\n\n xy_preds_i_0 = x + offset_x_i.to(dtype=torch.float32)\n xy_preds_i_1 = y + offset_y_i.to(dtype=torch.float32)\n xy_preds_i_2 = torch.ones((xy_preds_i_1.shape), dtype=torch.float32) # noqa\n xy_preds_i = torch.stack([xy_preds_i_0.to(dtype=torch.float32),\n xy_preds_i_1.to(dtype=torch.float32),\n xy_preds_i_2.to(dtype=torch.float32)], 0)\n\n # mTODO: simplify when indexing without rank will be supported by ONNX\n base = num_keypoints * num_keypoints + num_keypoints + 1\n ind = torch.arange(num_keypoints)\n ind = ind.to(dtype=torch.int64) * base\n end_scores_i = roi_map.index_select(1, y_int.to(dtype=torch.int64)) \\\n .index_select(2, x_int.to(dtype=torch.int64)).view(-1).index_select(0, ind.to(dtype=torch.int64))\n\n return xy_preds_i, end_scores_i\n\n\n# noinspection LongLine\n@torch.jit._script_if_tracing\ndef _onnx_heatmaps_to_keypoints_loop(maps, rois, widths_ceil, heights_ceil,\n widths, heights, offset_x, offset_y, num_keypoints):\n xy_preds = torch.zeros((0, 3, int(num_keypoints)), dtype=torch.float32, device=maps.device)\n end_scores = torch.zeros((0, int(num_keypoints)), dtype=torch.float32, device=maps.device)\n\n for i in range(int(rois.size(0))):\n xy_preds_i, end_scores_i = _onnx_heatmaps_to_keypoints(maps, maps[i],\n widths_ceil[i], heights_ceil[i],\n widths[i], heights[i],\n offset_x[i], offset_y[i])\n xy_preds = torch.cat((xy_preds.to(dtype=torch.float32),\n xy_preds_i.unsqueeze(0).to(dtype=torch.float32)), 0)\n end_scores = torch.cat((end_scores.to(dtype=torch.float32),\n end_scores_i.to(dtype=torch.float32).unsqueeze(0)), 0)\n return xy_preds, end_scores\n\n\n# noinspection LongLine\ndef heatmaps_to_keypoints(maps, rois):\n \"\"\"Extract predicted keypoint locations from heatmaps. Output has shape\n (#rois, 4, #keypoints) with the 4 rows corresponding to (x, y, logit, prob)\n for each keypoint.\n \"\"\"\n # This function converts a discrete image coordinate in a HEATMAP_SIZE x\n # HEATMAP_SIZE image to a continuous keypoint coordinate. We maintain\n # consistency with keypoints_to_heatmap_labels by using the conversion from\n # Heckbert 1990: c = d + 0.5, where d is a discrete coordinate and c is a\n # continuous coordinate.\n offset_x = rois[:, 0]\n offset_y = rois[:, 1]\n\n widths = rois[:, 2] - rois[:, 0]\n heights = rois[:, 3] - rois[:, 1]\n widths = widths.clamp(min=1)\n heights = heights.clamp(min=1)\n widths_ceil = widths.ceil()\n heights_ceil = heights.ceil()\n\n num_keypoints = maps.shape[1]\n\n if torchvision._is_tracing():\n xy_preds, end_scores = _onnx_heatmaps_to_keypoints_loop(maps, rois,\n widths_ceil, heights_ceil, widths, heights,\n offset_x, offset_y,\n torch.scalar_tensor(num_keypoints, dtype=torch.int64))\n return xy_preds.permute(0, 2, 1), end_scores\n\n xy_preds = torch.zeros((len(rois), 3, num_keypoints), dtype=torch.float32, device=maps.device)\n end_scores = torch.zeros((len(rois), num_keypoints), dtype=torch.float32, device=maps.device)\n for i in range(len(rois)):\n roi_map_width = int(widths_ceil[i].item())\n roi_map_height = int(heights_ceil[i].item())\n width_correction = widths[i] / roi_map_width\n height_correction = heights[i] / roi_map_height\n roi_map = F.interpolate(\n maps[i][:, None], size=(roi_map_height, roi_map_width), mode='bicubic', align_corners=False)[:, 0]\n # roi_map_probs = scores_to_probs(roi_map.copy())\n w = roi_map.shape[2]\n pos = roi_map.reshape(num_keypoints, -1).argmax(dim=1)\n\n x_int = pos % w\n y_int = (pos - x_int) // w\n # assert (roi_map_probs[k, y_int, x_int] ==\n # roi_map_probs[k, :, :].max())\n x = (x_int.float() + 0.5) * width_correction\n y = (y_int.float() + 0.5) * height_correction\n xy_preds[i, 0, :] = x + offset_x[i]\n xy_preds[i, 1, :] = y + offset_y[i]\n xy_preds[i, 2, :] = 1\n end_scores[i, :] = roi_map[torch.arange(num_keypoints), y_int, x_int]\n\n return xy_preds.permute(0, 2, 1), end_scores\n\n\n# noinspection LongLine\ndef keypointrcnn_loss(keypoint_logits, proposals, gt_keypoints, keypoint_matched_idxs):\n # type: (Tensor, List[Tensor], List[Tensor], List[Tensor]) -> Tensor\n N, K, H, W = keypoint_logits.shape\n assert H == W\n discretization_size = H\n heatmaps = []\n valid = []\n for proposals_per_image, gt_kp_in_image, midx in zip(proposals, gt_keypoints, keypoint_matched_idxs):\n kp = gt_kp_in_image[midx]\n heatmaps_per_image, valid_per_image = keypoints_to_heatmap(\n kp, proposals_per_image, discretization_size\n )\n heatmaps.append(heatmaps_per_image.view(-1))\n valid.append(valid_per_image.view(-1))\n\n keypoint_targets = torch.cat(heatmaps, dim=0)\n valid = torch.cat(valid, dim=0).to(dtype=torch.uint8)\n valid = torch.nonzero(valid).squeeze(1)\n\n # torch.mean (in binary_cross_entropy_with_logits) does'nt\n # accept empty tensors, so handle it sepaartely\n if keypoint_targets.numel() == 0 or len(valid) == 0:\n return keypoint_logits.sum() * 0\n\n keypoint_logits = keypoint_logits.view(N * K, H * W)\n\n keypoint_loss = F.cross_entropy(keypoint_logits[valid], keypoint_targets[valid])\n return keypoint_loss\n\n\n# noinspection LongLine\ndef keypointrcnn_inference(x, boxes):\n # type: (Tensor, List[Tensor]) -> Tuple[List[Tensor], List[Tensor]]\n kp_probs = []\n kp_scores = []\n\n boxes_per_image = [box.size(0) for box in boxes] # noqa\n x2 = x.split(boxes_per_image, dim=0)\n\n for xx, bb in zip(x2, boxes):\n kp_prob, scores = heatmaps_to_keypoints(xx, bb)\n kp_probs.append(kp_prob)\n kp_scores.append(scores)\n\n return kp_probs, kp_scores\n\n\n# noinspection LongLine,DuplicatedCode\ndef _onnx_expand_boxes(boxes, scale):\n # type: (Tensor, float) -> Tensor\n w_half = (boxes[:, 2] - boxes[:, 0]) * .5\n h_half = (boxes[:, 3] - boxes[:, 1]) * .5\n x_c = (boxes[:, 2] + boxes[:, 0]) * .5\n y_c = (boxes[:, 3] + boxes[:, 1]) * .5\n\n w_half = w_half.to(dtype=torch.float32) * scale\n h_half = h_half.to(dtype=torch.float32) * scale\n\n boxes_exp0 = x_c - w_half\n boxes_exp1 = y_c - h_half\n boxes_exp2 = x_c + w_half\n boxes_exp3 = y_c + h_half\n boxes_exp = torch.stack((boxes_exp0, boxes_exp1, boxes_exp2, boxes_exp3), 1)\n return boxes_exp\n\n\n# the next two functions should be merged inside Masker\n# but are kept here for the moment while we need them\n# temporarily for paste_mask_in_image\n# noinspection DuplicatedCode\ndef expand_boxes(boxes, scale):\n # type: (Tensor, float) -> Tensor\n if torchvision._is_tracing():\n return _onnx_expand_boxes(boxes, scale)\n w_half = (boxes[:, 2] - boxes[:, 0]) * .5\n h_half = (boxes[:, 3] - boxes[:, 1]) * .5\n x_c = (boxes[:, 2] + boxes[:, 0]) * .5\n y_c = (boxes[:, 3] + boxes[:, 1]) * .5\n\n w_half *= scale\n h_half *= scale\n\n boxes_exp = torch.zeros_like(boxes)\n boxes_exp[:, 0] = x_c - w_half\n boxes_exp[:, 2] = x_c + w_half\n boxes_exp[:, 1] = y_c - h_half\n boxes_exp[:, 3] = y_c + h_half\n return boxes_exp\n\n\n# noinspection LongLine\n@torch.jit.unused\ndef expand_masks_tracing_scale(M, padding):\n # type: (int, int) -> float\n return torch.tensor(M + 2 * padding).to(torch.float32) / torch.tensor(M).to(torch.float32)\n\n\n# noinspection LongLine\ndef expand_masks(mask, padding):\n # type: (Tensor, int) -> Tuple[Tensor, float]\n M = mask.shape[-1]\n if torch._C._get_tracing_state(): # could not import is_tracing(), not sure why\n scale = expand_masks_tracing_scale(M, padding)\n else:\n scale = float(M + 2 * padding) / M\n padded_mask = torch.nn.functional.pad(mask, (padding,) * 4)\n return padded_mask, scale\n\n\n# noinspection LongLine\ndef paste_mask_in_image(mask, box, im_h, im_w, im_mask=None, ocode=None):\n # type: (Tensor, Tensor, int, int) -> Tensor\n TO_REMOVE = 1\n w = int(box[2] - box[0] + TO_REMOVE)\n h = int(box[3] - box[1] + TO_REMOVE)\n w = max(w, 1)\n h = max(h, 1)\n\n # Set shape to [batchxCxHxW]\n mask = mask.expand((1, 1, -1, -1))\n\n # Resize mask\n mask = F.interpolate(mask, size=(h, w), mode='bilinear', align_corners=False)\n mask = mask[0][0]\n\n x_0 = max(box[0], 0)\n x_1 = min(box[2] + 1, im_w)\n y_0 = max(box[1], 0)\n y_1 = min(box[3] + 1, im_h)\n\n if im_mask is None:\n # sparse mask (only one object per channel)\n im_mask = torch.zeros((im_h, im_w), dtype=mask.dtype, device=mask.device)\n im_mask[y_0:y_1, x_0:x_1] = mask[\n (y_0 - box[1]):(y_1 - box[1]), (x_0 - box[0]):(x_1 - box[0])\n ]\n else:\n # Mohamed: dense mask (just one channel, where code represents object)\n # IMPORTANT NOTE: this means we threshold probabilities.\n patch = im_mask[y_0:y_1, x_0:x_1]\n omask = mask[\n (y_0 - box[1]):(y_1 - box[1]), (x_0 - box[0]):(x_1 - box[0])\n ]\n patch[omask > 0.5] = ocode\n\n return im_mask\n\n\n# noinspection LongLine\ndef _onnx_paste_mask_in_image(mask, box, im_h, im_w):\n one = torch.ones(1, dtype=torch.int64)\n zero = torch.zeros(1, dtype=torch.int64)\n\n w = (box[2] - box[0] + one)\n h = (box[3] - box[1] + one)\n w = torch.max(torch.cat((w, one)))\n h = torch.max(torch.cat((h, one)))\n\n # Set shape to [batchxCxHxW]\n mask = mask.expand((1, 1, mask.size(0), mask.size(1)))\n\n # Resize mask\n mask = F.interpolate(mask, size=(int(h), int(w)), mode='bilinear', align_corners=False)\n mask = mask[0][0]\n\n x_0 = torch.max(torch.cat((box[0].unsqueeze(0), zero)))\n x_1 = torch.min(torch.cat((box[2].unsqueeze(0) + one, im_w.unsqueeze(0))))\n y_0 = torch.max(torch.cat((box[1].unsqueeze(0), zero)))\n y_1 = torch.min(torch.cat((box[3].unsqueeze(0) + one, im_h.unsqueeze(0))))\n\n unpaded_im_mask = mask[(y_0 - box[1]):(y_1 - box[1]),\n (x_0 - box[0]):(x_1 - box[0])]\n\n # mTODO : replace below with a dynamic padding when support is added in ONNX\n\n # pad y\n zeros_y0 = torch.zeros(y_0, unpaded_im_mask.size(1))\n zeros_y1 = torch.zeros(im_h - y_1, unpaded_im_mask.size(1))\n concat_0 = torch.cat((zeros_y0,\n unpaded_im_mask.to(dtype=torch.float32),\n zeros_y1), 0)[0:im_h, :]\n # pad x\n zeros_x0 = torch.zeros(concat_0.size(0), x_0)\n zeros_x1 = torch.zeros(concat_0.size(0), im_w - x_1)\n im_mask = torch.cat((zeros_x0,\n concat_0,\n zeros_x1), 1)[:, :im_w]\n return im_mask\n\n\n@torch.jit._script_if_tracing\ndef _onnx_paste_masks_in_image_loop(masks, boxes, im_h, im_w):\n res_append = torch.zeros(0, im_h, im_w)\n for i in range(masks.size(0)):\n mask_res = _onnx_paste_mask_in_image(masks[i][0], boxes[i], im_h, im_w)\n mask_res = mask_res.unsqueeze(0)\n res_append = torch.cat((res_append, mask_res))\n return res_append\n\n\n# noinspection LongLine\ndef paste_masks_in_image(masks, boxes, img_shape, padding=1):\n # type: (Tensor, Tensor, Tuple[int, int], int) -> Tensor\n masks, scale = expand_masks(masks, padding=padding)\n boxes = expand_boxes(boxes, scale).to(dtype=torch.int64)\n im_h, im_w = img_shape\n\n if torchvision._is_tracing():\n return _onnx_paste_masks_in_image_loop(masks, boxes,\n torch.scalar_tensor(im_h, dtype=torch.int64),\n torch.scalar_tensor(im_w, dtype=torch.int64))[:, None]\n res = [\n paste_mask_in_image(m[0], b, im_h, im_w)\n for m, b in zip(masks, boxes)\n ]\n if len(res) > 0:\n ret = torch.stack(res, dim=0)[:, None]\n else:\n ret = masks.new_empty((0, 1, im_h, im_w))\n return ret\n\n# Mohamed: dense mask (code represents object)\ndef paste_and_densify_masks_in_image(masks, boxes, img_shape, padding=1):\n # type: (Tensor, Tensor, Tuple[int, int], int) -> Tensor\n\n masks, scale = expand_masks(masks, padding=padding)\n boxes = expand_boxes(boxes, scale).to(dtype=torch.int64)\n im_h, im_w = img_shape\n\n if torchvision._is_tracing():\n raise NotImplementedError(\n \"I didn't support tracing yet. See paste_masks_in_image().\"\n )\n\n # IMPORTANT NOTE: in the dense mask, each object id encoded by a code\n # that corresponds to (1 + idx), where idx is the index of the object\n # in the labels/bbox tensors. For example, where im_mask == 5 corresponds\n # to the nucleus whose label is in the 4th index in the labels tensor\n\n # Find the order in which to overlay objects in the mask, from big to small\n # This prevents a big object from covering a small one. Noe, however, that\n # 1. This is still a \"lossy\" process, but it saves up on speed and makes\n # the memory requirement less dependent on the no of objects\n # 2. We maintain the object codes' correspondence to (1 + idx)\n areas = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])\n idxs = torch.argsort(areas, descending=True)\n\n im_mask = torch.zeros((im_h, im_w), dtype=torch.int64, device=masks.device)\n for idx in idxs:\n im_mask = paste_mask_in_image(\n mask=masks[idx][0], box=boxes[idx], im_h=im_h, im_w=im_w,\n im_mask=im_mask, ocode=idx + 1)\n\n return im_mask\n\n# noinspection LongLine\nclass RoIHeads(torch.nn.Module):\n __annotations__ = {\n 'box_coder': det_utils.BoxCoder,\n 'proposal_matcher': det_utils.Matcher,\n 'fg_bg_sampler': det_utils.BalancedPositiveNegativeSampler,\n }\n\n def __init__(self,\n box_roi_pool,\n box_head,\n box_predictor,\n # Faster R-CNN training\n fg_iou_thresh, bg_iou_thresh,\n batch_size_per_image, positive_fraction,\n bbox_reg_weights,\n # Faster R-CNN inference\n score_thresh,\n nms_thresh,\n detections_per_img,\n # Mask\n mask_roi_pool=None,\n mask_head=None,\n mask_predictor=None,\n keypoint_roi_pool=None,\n keypoint_head=None,\n keypoint_predictor=None,\n # added by Mohamed\n batched_nms=True, # inference nms independently per class?\n indep_classif_boxes=False,\n classification_bbox_size=None, # float\n cconvhead=None, # extra conv layers for classification\n sattention_head=None, # nuclei are aware of each other\n ignore_label: int = None, # label to ignore in classif. loss\n ):\n super(RoIHeads, self).__init__()\n\n if indep_classif_boxes:\n assert classification_bbox_size is not None\n\n self.box_similarity = box_ops.box_iou\n # assign ground-truth boxes for each proposal\n self.proposal_matcher = det_utils.Matcher(\n fg_iou_thresh,\n bg_iou_thresh,\n allow_low_quality_matches=False)\n\n self.fg_bg_sampler = det_utils.BalancedPositiveNegativeSampler(\n batch_size_per_image,\n positive_fraction)\n\n if bbox_reg_weights is None:\n bbox_reg_weights = (10., 10., 5., 5.)\n self.box_coder = det_utils.BoxCoder(bbox_reg_weights)\n\n self.box_roi_pool = box_roi_pool\n self.box_head = box_head\n self.box_predictor = box_predictor\n\n self.score_thresh = score_thresh\n self.nms_thresh = nms_thresh\n self.detections_per_img = detections_per_img\n\n self.mask_roi_pool = mask_roi_pool\n self.mask_head = mask_head\n self.mask_predictor = mask_predictor\n\n self.keypoint_roi_pool = keypoint_roi_pool\n self.keypoint_head = keypoint_head\n self.keypoint_predictor = keypoint_predictor\n\n # added by Mohamed\n self.batched_nms = batched_nms\n self.indep_classif_boxes = indep_classif_boxes\n self.classification_bbox_size = classification_bbox_size\n self.halfclbox = self.classification_bbox_size / 2 if \\\n classification_bbox_size is not None else None\n self.cconvhead = cconvhead\n self.sattention_head = sattention_head\n self.ignore_label = ignore_label\n\n def has_mask(self):\n if self.mask_roi_pool is None:\n return False\n if self.mask_head is None:\n return False\n if self.mask_predictor is None:\n return False\n return True\n\n def has_keypoint(self):\n if self.keypoint_roi_pool is None:\n return False\n if self.keypoint_head is None:\n return False\n if self.keypoint_predictor is None:\n return False\n return True\n\n def assign_targets_to_proposals(self, proposals, gt_boxes, gt_labels):\n # type: (List[Tensor], List[Tensor], List[Tensor]) -> Tuple[List[Tensor], List[Tensor]]\n matched_idxs = []\n labels = []\n for proposals_in_image, gt_boxes_in_image, gt_labels_in_image in zip(proposals, gt_boxes, gt_labels):\n\n if gt_boxes_in_image.numel() == 0:\n # Background image\n device = proposals_in_image.device\n clamped_matched_idxs_in_image = torch.zeros(\n (proposals_in_image.shape[0],), dtype=torch.int64, device=device\n )\n labels_in_image = torch.zeros(\n (proposals_in_image.shape[0],), dtype=torch.int64, device=device\n )\n else:\n # set to self.box_similarity when https://github.com/pytorch/pytorch/issues/27495 lands\n match_quality_matrix = box_ops.box_iou(gt_boxes_in_image, proposals_in_image)\n matched_idxs_in_image = self.proposal_matcher(match_quality_matrix)\n\n clamped_matched_idxs_in_image = matched_idxs_in_image.clamp(min=0)\n\n labels_in_image = gt_labels_in_image[clamped_matched_idxs_in_image]\n labels_in_image = labels_in_image.to(dtype=torch.int64)\n\n # Label background (below the low threshold)\n bg_inds = matched_idxs_in_image == self.proposal_matcher.BELOW_LOW_THRESHOLD\n labels_in_image[bg_inds] = 0\n\n # Label ignore proposals (between low and high thresholds)\n ignore_inds = matched_idxs_in_image == self.proposal_matcher.BETWEEN_THRESHOLDS\n labels_in_image[ignore_inds] = -1 # -1 is ignored by sampler\n\n matched_idxs.append(clamped_matched_idxs_in_image)\n labels.append(labels_in_image)\n return matched_idxs, labels\n\n def subsample(self, labels):\n # type: (List[Tensor]) -> List[Tensor]\n sampled_pos_inds, sampled_neg_inds = self.fg_bg_sampler(labels)\n sampled_inds = []\n for img_idx, (pos_inds_img, neg_inds_img) in enumerate(\n zip(sampled_pos_inds, sampled_neg_inds)\n ):\n img_sampled_inds = torch.nonzero(pos_inds_img | neg_inds_img).squeeze(1)\n sampled_inds.append(img_sampled_inds)\n return sampled_inds\n\n # noinspection PyMethodMayBeStatic\n def add_gt_proposals(self, proposals, gt_boxes):\n # type: (List[Tensor], List[Tensor]) -> List[Tensor]\n proposals = [\n torch.cat((proposal, gt_box))\n for proposal, gt_box in zip(proposals, gt_boxes)\n ]\n\n return proposals\n\n def check_targets(self, targets):\n # type: (Optional[List[Dict[str, Tensor]]]) -> None\n assert targets is not None\n assert all([\"boxes\" in t for t in targets])\n assert all([\"labels\" in t for t in targets])\n if self.has_mask():\n assert all([\"masks\" in t for t in targets])\n\n def select_training_samples(self,\n proposals, # type: List[Tensor]\n targets # type: Optional[List[Dict[str, Tensor]]]\n ):\n # type: (...) -> Tuple[List[Tensor], List[Tensor], List[Tensor], List[Tensor]]\n self.check_targets(targets)\n assert targets is not None\n dtype = proposals[0].dtype\n device = proposals[0].device\n\n gt_boxes = [t[\"boxes\"].to(dtype) for t in targets]\n gt_labels = [t[\"labels\"] for t in targets]\n\n # append ground-truth bboxes to propos\n proposals = self.add_gt_proposals(proposals, gt_boxes)\n\n # get matching gt indices for each proposal\n matched_idxs, labels = self.assign_targets_to_proposals(proposals, gt_boxes, gt_labels)\n # sample a fixed proportion of positive-negative proposals\n sampled_inds = self.subsample(labels)\n matched_gt_boxes = []\n num_images = len(proposals)\n for img_id in range(num_images):\n img_sampled_inds = sampled_inds[img_id]\n proposals[img_id] = proposals[img_id][img_sampled_inds]\n labels[img_id] = labels[img_id][img_sampled_inds]\n matched_idxs[img_id] = matched_idxs[img_id][img_sampled_inds]\n\n gt_boxes_in_image = gt_boxes[img_id]\n if gt_boxes_in_image.numel() == 0:\n gt_boxes_in_image = torch.zeros((1, 4), dtype=dtype, device=device)\n matched_gt_boxes.append(gt_boxes_in_image[matched_idxs[img_id]])\n\n regression_targets = self.box_coder.encode(matched_gt_boxes, proposals)\n return proposals, matched_idxs, labels, regression_targets\n\n def postprocess_detections_globalnms(self,\n class_logits, # type: Tensor\n box_regression, # type: Tensor\n proposals, # type: List[Tensor]\n image_shapes # type: List[Tuple[int, int]]\n ):\n # type: (...) -> Tuple[List[Tensor], List[Tensor], List[Tensor]]\n device = class_logits.device\n hdim = class_logits.shape[0]\n num_classes = class_logits.shape[-1]\n\n boxes_per_image = [boxes_in_image.shape[0] for boxes_in_image in proposals]\n pred_boxes = self.box_coder.decode(box_regression, proposals)\n\n pred_scores = F.softmax(class_logits, -1)\n\n pred_boxes_list = pred_boxes.split(boxes_per_image, 0)\n pred_scores_list = pred_scores.split(boxes_per_image, 0)\n\n all_boxes = []\n all_objectness = [] # probability this is an object\n all_labels = []\n all_probabs = [] # probabilities for each class\n all_keptidxs = []\n for boxes, scores, image_shape in zip(pred_boxes_list, pred_scores_list, image_shapes):\n\n boxes = box_ops.clip_boxes_to_image(boxes, image_shape)\n\n # remove predictions with the background label\n boxes = boxes[:, 1, :]\n scores = scores[:, 1:]\n\n # we define the \"objectness\" as the sum of non-background scores\n objectness = scores.sum(1)\n\n # indices of detections that are kept nms and postprocessing\n keptidxs = torch.arange(hdim, device=device)\n\n # Mohamed: prevent (set as zero prob.) ignore_label prediction\n if self.ignore_label is not None:\n ignore = [j == self.ignore_label for j in range(1, num_classes)]\n scores[:, ignore] = 0.\n\n # remove low scoring boxes (i.e. low \"objectness\").\n inds = torch.nonzero(objectness > self.score_thresh).squeeze(1)\n boxes, scores, objectness, keptidxs = boxes[inds], scores[inds], objectness[inds], keptidxs[inds]\n\n # remove empty boxes\n keep = box_ops.remove_small_boxes(boxes, min_size=1e-2)\n boxes, scores, objectness, keptidxs = boxes[keep], scores[keep], objectness[keep], keptidxs[keep]\n\n # global nms, regardless of class\n keep = global_nms(boxes=boxes, scores=objectness, iou_threshold=self.nms_thresh)\n\n # keep only topk scoring predictions\n keep = keep[:self.detections_per_img]\n boxes, scores, objectness, keptidxs = boxes[keep], scores[keep], objectness[keep], keptidxs[keep]\n\n if boxes.shape[0] > 0:\n # make sure probabilities add to 1, while preserving the\n # ignore_label columns as zero, so we divide by total instead\n # of using softmax\n scores = scores / scores.sum(1)[:, None]\n\n # label is argmax, just like ordinary classification tasks. Keep\n # in mind that we got rid of the background channel, so add 1\n labels = torch.argmax(scores, dim=1) + 1\n else:\n # empty tensor; nothing was left after filtering out junk\n labels = scores[:, 0].type(torch.int64)\n\n all_boxes.append(boxes)\n all_objectness.append(objectness)\n all_labels.append(labels)\n all_probabs.append(scores)\n all_keptidxs.append(keptidxs)\n\n return all_boxes, all_objectness, all_labels, all_probabs, all_keptidxs\n\n\n def postprocess_detections(self,\n class_logits, # type: Tensor\n box_regression, # type: Tensor\n proposals, # type: List[Tensor]\n image_shapes # type: List[Tuple[int, int]]\n ):\n # type: (...) -> Tuple[List[Tensor], List[Tensor], List[Tensor]]\n device = class_logits.device\n num_classes = class_logits.shape[-1]\n\n boxes_per_image = [boxes_in_image.shape[0] for boxes_in_image in proposals]\n pred_boxes = self.box_coder.decode(box_regression, proposals)\n\n pred_scores = F.softmax(class_logits, -1)\n\n pred_boxes_list = pred_boxes.split(boxes_per_image, 0)\n pred_scores_list = pred_scores.split(boxes_per_image, 0)\n\n all_boxes = []\n all_scores = []\n all_labels = []\n for boxes, scores, image_shape in zip(pred_boxes_list, pred_scores_list, image_shapes):\n boxes = box_ops.clip_boxes_to_image(boxes, image_shape)\n\n # create labels for each prediction\n labels = torch.arange(num_classes, device=device)\n labels = labels.view(1, -1).expand_as(scores)\n\n # remove predictions with the background label\n boxes = boxes[:, 1:]\n scores = scores[:, 1:]\n labels = labels[:, 1:]\n\n # Mohamed: remove self.ignore_label predictions\n if self.ignore_label is not None:\n keep = [j != self.ignore_label for j in range(1, num_classes)]\n boxes = boxes[:, keep]\n scores = scores[:, keep]\n labels = labels[:, keep]\n\n # batch everything, by making every class prediction be a separate instance\n boxes = boxes.reshape(-1, 4)\n scores = scores.reshape(-1)\n labels = labels.reshape(-1)\n\n # remove low scoring boxes\n inds = torch.nonzero(scores > self.score_thresh).squeeze(1)\n boxes, scores, labels = boxes[inds], scores[inds], labels[inds]\n\n # remove empty boxes\n keep = box_ops.remove_small_boxes(boxes, min_size=1e-2)\n boxes, scores, labels = boxes[keep], scores[keep], labels[keep]\n\n # independent nms per class\n keep = box_ops.batched_nms(\n boxes=boxes, scores=scores, idxs=labels,\n iou_threshold=self.nms_thresh)\n\n # keep only topk scoring predictions\n keep = keep[:self.detections_per_img]\n boxes, scores, labels = boxes[keep], scores[keep], labels[keep]\n\n all_boxes.append(boxes)\n all_scores.append(scores)\n all_labels.append(labels)\n\n return all_boxes, all_scores, all_labels\n\n def get_classification_proposals(self, proposals, image_shapes):\n\n classification_proposals = []\n for pno, prop in enumerate(proposals):\n xmins, ymins, xmaxs, ymaxs = torch.chunk(prop, 4, dim=1)\n xs = xmins + (xmaxs - xmins) / 2\n ys = ymins + (ymaxs - ymins) / 2\n boxes = torch.cat(\n [xs - self.halfclbox, ys - self.halfclbox,\n xs + self.halfclbox, ys + self.halfclbox],\n dim=1)\n\n # adjust boxes\n dim0, dim1 = image_shapes[pno]\n boxes, _ = remove_degenerate_bboxes(\n boxes=boxes, dim0=dim0, dim1=dim1, min_boxside=0)\n\n classification_proposals.append(boxes)\n\n return classification_proposals\n\n def forward(self,\n features, # type: Dict[str, Tensor]\n proposals, # type: List[Tensor]\n image_shapes, # type: List[Tuple[int, int]]\n targets=None, # type: Optional[List[Dict[str, Tensor]]]\n _just_return_probabs=False, # type: bool\n _cprobabs=None, # type: List[Tensor]\n _return_prepr=False, # type: bool\n ):\n # type: (...) -> Tuple[List[Dict[str, Tensor]], Dict[str, Tensor]]\n \"\"\"\n Arguments:\n features (List[Tensor])\n proposals (List[Tensor[N, 4]])\n image_shapes (List[Tuple[H, W]])\n targets (List[Dict])\n _just_return_probabs (bool): If true, just returns logits for each\n of the proposals without postprocessing. This is only applies\n if not self.training.\n _cprobabs (List[Tensor]): If given, these \"past logits\" (obtained\n from variations of the proposals) would be aggregated to\n the class_logits as a form of test-time augmentation. This\n obviously only applies if not self.training\n _return_prepr (bool): also return intermediate representations?\n \"\"\"\n if targets is not None:\n for t in targets:\n # mTODO: https://github.com/pytorch/pytorch/issues/26731\n floating_point_types = (torch.float, torch.double, torch.half)\n assert t[\"boxes\"].dtype in floating_point_types, 'target boxes must of float type'\n assert t[\"labels\"].dtype == torch.int64, 'target labels must of int64 type'\n if self.has_keypoint():\n assert t[\"keypoints\"].dtype == torch.float32, 'target keypoints must of float type'\n\n if self.training:\n proposals, matched_idxs, labels, regression_targets = self.select_training_samples(proposals, targets)\n else:\n labels = None\n regression_targets = None\n matched_idxs = None\n\n # Added by Mohamed: Classification proposals use an\n # independent (possibly wider) region beyond object boundary\n cproposals = None if not self.indep_classif_boxes else \\\n self.get_classification_proposals(proposals=proposals, image_shapes=image_shapes)\n\n # Mohamed: Independent, extra convolutions for classification\n cfeatures = None if self.cconvhead is None else OrderedDict(\n {k: self.cconvhead(v) for k, v in features.items()}\n )\n\n # roi pooling for the object bbox\n box_features = self.box_roi_pool(features, proposals, image_shapes)\n if (cproposals is not None) or (cfeatures is not None):\n cbox_features = self.box_roi_pool(\n cfeatures or features, cproposals or proposals, image_shapes)\n else:\n cbox_features = None\n\n # flatten\n box_features = self.box_head(box_features)\n cbox_features = self.box_head(cbox_features) \\\n if cbox_features is not None else None\n\n # Mohamed: per-fov nuclei attentive to each other\n if self.sattention_head is not None:\n\n # this only applies for classification\n if cbox_features is None:\n cbox_features = 0. + box_features\n\n # get the start index for each group of proposals from one FOV\n fov_start_idxs = np.cumsum(\n [0] + [j.shape[0] for j in proposals[:-1]]).tolist()\n\n # pass through self-attention head\n cbox_features = self.sattention_head(\n cbox_features, fov_start_idxs=fov_start_idxs)\n\n # pass through fully-connected layers\n if cbox_features is None:\n class_logits, box_regression = self.box_predictor(box_features)\n else:\n _, box_regression = self.box_predictor(box_features, get_scores=False)\n class_logits, _ = self.box_predictor(cbox_features, get_deltas=False)\n\n result = torch.jit.annotate(List[Dict[str, torch.Tensor]], [])\n losses = {}\n if self.training:\n assert labels is not None and regression_targets is not None\n loss_classifier, loss_box_reg = fastrcnn_loss(\n class_logits=class_logits,\n box_regression=box_regression,\n labels=labels,\n regression_targets=regression_targets,\n ignore_label=self.ignore_label,\n batched_nms=self.batched_nms,\n )\n losses = {\n \"loss_classifier\": loss_classifier,\n \"loss_box_reg\": loss_box_reg\n }\n else:\n # Mohamed: maybe just return class probabs without postprocessing\n # Note that this INCLUDES the background class\n if _just_return_probabs:\n return F.softmax(class_logits, -1)\n\n # Mohamed: \"past logits\" (obtained from variations of proposals)\n # would be aggregated to the class_logits as a form of test-time\n # augmentation. This obviously only applies if not self.training\n if _cprobabs is not None:\n class_logits = F.softmax(class_logits, -1)\n class_logits += _cprobabs\n\n if self.batched_nms:\n boxes, scores, labels = self.postprocess_detections(class_logits, box_regression, proposals, image_shapes)\n probabs = [None] * len(boxes)\n keptidxs = [None] * len(boxes)\n else:\n boxes, scores, labels, probabs, keptidxs = self.postprocess_detections_globalnms(class_logits, box_regression, proposals, image_shapes)\n num_images = len(boxes)\n\n if _return_prepr:\n bperim = [boxes_in_image.shape[0] for boxes_in_image in proposals]\n bfeats = box_features.split(bperim, 0)\n cbfeats = None if cbox_features is None else cbox_features.split(bperim, 0)\n clogits = class_logits.split(bperim, 0)\n\n for i in range(num_images):\n out = {\n \"boxes\": boxes[i],\n \"labels\": labels[i],\n \"scores\": scores[i],\n \"probabs\": probabs[i],\n }\n if _return_prepr:\n out.update({\n \"box_features\": bfeats[i][keptidxs[i], :],\n \"cbox_features\": None if cbfeats is None else cbfeats[i][keptidxs[i], :],\n \"clogits\": clogits[i][keptidxs[i], :],\n })\n result.append(out)\n\n if self.has_mask():\n mask_proposals = [p[\"boxes\"] for p in result]\n if self.training:\n assert matched_idxs is not None\n # during training, only focus on positive boxes\n num_images = len(proposals)\n mask_proposals = []\n pos_matched_idxs = []\n for img_id in range(num_images):\n pos = torch.nonzero(labels[img_id] > 0).squeeze(1)\n mask_proposals.append(proposals[img_id][pos])\n pos_matched_idxs.append(matched_idxs[img_id][pos])\n else:\n pos_matched_idxs = None\n\n if self.mask_roi_pool is not None:\n mask_features = self.mask_roi_pool(features, mask_proposals, image_shapes)\n mask_features = self.mask_head(mask_features)\n mask_logits = self.mask_predictor(mask_features)\n else:\n # noinspection PyUnusedLocal\n mask_logits = torch.tensor(0)\n raise Exception(\"Expected mask_roi_pool to be not None\")\n\n loss_mask = {}\n if self.training:\n assert targets is not None\n assert pos_matched_idxs is not None\n assert mask_logits is not None\n\n # Mohamed: if not self.batched_nms, just one mask per object\n gt_labels = [0 + t[\"labels\"] for t in targets]\n if not self.batched_nms:\n for labs in gt_labels:\n labs[labs > 1] = 1\n\n gt_masks = [t[\"masks\"] for t in targets]\n # Mohamed: added to ignore bboxes (false masks)\n # so that they don't contribute to the mask loss\n if 'ismask' in targets[0]:\n gt_ismask = [t['ismask'] for t in targets]\n else:\n gt_ismask = None\n rcnn_loss_mask = maskrcnn_loss(\n mask_logits=mask_logits, proposals=mask_proposals,\n gt_masks=gt_masks, gt_labels=gt_labels,\n mask_matched_idxs=pos_matched_idxs,\n gt_ismask=gt_ismask)\n loss_mask = {\n \"loss_mask\": rcnn_loss_mask\n }\n else:\n # Mohamed: if not self.batched_nms, just one mask per object\n mask_labels = [0 + r[\"labels\"] for r in result]\n if not self.batched_nms:\n for labs in mask_labels:\n labs[labs > 1] = 1\n masks_probs = maskrcnn_inference(mask_logits, mask_labels)\n for mask_prob, r in zip(masks_probs, result):\n r[\"masks\"] = mask_prob\n\n losses.update(loss_mask)\n\n # keep none checks in if conditional so torchscript will conditionally\n # compile each branch\n if self.keypoint_roi_pool is not None and self.keypoint_head is not None \\\n and self.keypoint_predictor is not None:\n keypoint_proposals = [p[\"boxes\"] for p in result]\n if self.training:\n # during training, only focus on positive boxes\n num_images = len(proposals)\n keypoint_proposals = []\n pos_matched_idxs = []\n assert matched_idxs is not None\n for img_id in range(num_images):\n pos = torch.nonzero(labels[img_id] > 0).squeeze(1)\n keypoint_proposals.append(proposals[img_id][pos])\n pos_matched_idxs.append(matched_idxs[img_id][pos])\n else:\n pos_matched_idxs = None\n\n keypoint_features = self.keypoint_roi_pool(features, keypoint_proposals, image_shapes)\n keypoint_features = self.keypoint_head(keypoint_features)\n keypoint_logits = self.keypoint_predictor(keypoint_features)\n\n loss_keypoint = {}\n if self.training:\n assert targets is not None\n assert pos_matched_idxs is not None\n\n gt_keypoints = [t[\"keypoints\"] for t in targets]\n rcnn_loss_keypoint = keypointrcnn_loss(\n keypoint_logits, keypoint_proposals,\n gt_keypoints, pos_matched_idxs)\n loss_keypoint = {\n \"loss_keypoint\": rcnn_loss_keypoint\n }\n else:\n assert keypoint_logits is not None\n assert keypoint_proposals is not None\n\n keypoints_probs, kp_scores = keypointrcnn_inference(keypoint_logits, keypoint_proposals)\n for keypoint_prob, kps, r in zip(keypoints_probs, kp_scores, result):\n r[\"keypoints\"] = keypoint_prob\n r[\"keypoints_scores\"] = kps\n\n losses.update(loss_keypoint)\n\n return result, losses\n", "meta": {"hexsha": "f0dbbadf1bcb335c606491f6ccb3c001a8c57b5b", "size": 49387, "ext": "py", "lang": "Python", "max_stars_repo_path": "nucls_model/ROIHeads.py", "max_stars_repo_name": "CancerDataScience/NuCLS", "max_stars_repo_head_hexsha": "c172b55b18d4ea78c3f51a8fd28ee6c2595c8360", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7, "max_stars_repo_stars_event_min_datetime": "2021-02-18T18:24:45.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-02T07:37:27.000Z", "max_issues_repo_path": "nucls_model/ROIHeads.py", "max_issues_repo_name": "CancerDataScience/NuCLS", "max_issues_repo_head_hexsha": "c172b55b18d4ea78c3f51a8fd28ee6c2595c8360", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2021-03-06T03:26:15.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-27T07:45:29.000Z", "max_forks_repo_path": "nucls_model/ROIHeads.py", "max_forks_repo_name": "CancerDataScience/NuCLS", "max_forks_repo_head_hexsha": "c172b55b18d4ea78c3f51a8fd28ee6c2595c8360", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2021-02-24T14:06:46.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-18T09:26:58.000Z", "avg_line_length": 39.8603712672, "max_line_length": 151, "alphanum_fraction": 0.6081357442, "include": true, "reason": "import numpy", "num_tokens": 11874, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5926665855647395, "lm_q2_score": 0.3242353924510608, "lm_q1q2_score": 0.19216348296321353}} {"text": "\"\"\"A module containing the core message-passing functions for belief propagation\"\"\"\n\nimport functools\nimport inspect\nfrom dataclasses import dataclass\nfrom typing import Any, Callable, Dict, Hashable, Mapping, Optional, Tuple\n\nimport jax\nimport jax.numpy as jnp\nimport numpy as np\nfrom jax.scipy.special import logsumexp\n\nfrom pgmax.factor import FAC_TO_VAR_UPDATES\n\nfrom . import bp_state as bpstate\nfrom . import bp_utils\nfrom .bp_state import BPArrays, BPState, Evidence, FToVMessages, LogPotentials\n\n\n@dataclass(frozen=True, eq=False)\nclass BeliefPropagation:\n \"\"\"Belief propagation functions.\n\n Arguments:\n init: Function to create log_potentials, ftov_msgs and evidence.\n Args:\n log_potentials_updates: Optional dictionary containing log_potentials updates.\n ftov_msgs_updates: Optional dictionary containing ftov_msgs updates.\n evidence_updates: Optional dictionary containing evidence updates.\n Returns:\n A BPArrays with the log_potentials, ftov_msgs and evidence.\n\n update: Function to update log_potentials, ftov_msgs and evidence.\n Args:\n bp_arrays: Optional arrays of log_potentials, ftov_msgs, evidence.\n log_potentials_updates: Optional dictionary containing log_potentials updates.\n ftov_msgs_updates: Optional dictionary containing ftov_msgs updates.\n evidence_updates: Optional dictionary containing evidence updates.\n Returns:\n A BPArrays with the updated log_potentials, ftov_msgs and evidence.\n\n run_bp: Function to run belief propagation for num_iters with a damping_factor.\n Args:\n bp_arrays: Initial arrays of log_potentials, ftov_msgs, evidence.\n num_iters: Number of belief propagation iterations.\n damping: The damping factor to use for message updates between one timestep and the next.\n Returns:\n A BPArrays containing the updated ftov_msgs.\n\n get_bp_state: Function to reconstruct the BPState from a BPArrays.\n Args:\n bp_arrays: A BPArrays containing log_potentials, ftov_msgs, evidence.\n Returns:\n The reconstructed BPState\n\n get_beliefs: Function to calculate beliefs from a BPArrays.\n Args:\n bp_arrays: A BPArrays containing log_potentials, ftov_msgs, evidence.\n Returns:\n beliefs: Beliefs returned by belief propagation.\n \"\"\"\n\n init: Callable\n update: Callable\n run_bp: Callable\n to_bp_state: Callable\n get_beliefs: Callable\n\n\ndef BP(bp_state: BPState, temperature: float = 0.0) -> BeliefPropagation:\n \"\"\"Function for generating belief propagation functions.\n\n Args:\n bp_state: Belief propagation state.\n temperature: Temperature for loopy belief propagation.\n 1.0 corresponds to sum-product, 0.0 corresponds to max-product.\n\n Returns:\n Belief propagation functions.\n \"\"\"\n wiring = bp_state.fg_state.wiring\n edges_num_states = np.concatenate(\n [wiring[factor_type].edges_num_states for factor_type in FAC_TO_VAR_UPDATES]\n )\n max_msg_size = int(np.max(edges_num_states))\n\n var_states_for_edges = np.concatenate(\n [wiring[factor_type].var_states_for_edges for factor_type in FAC_TO_VAR_UPDATES]\n )\n\n # Inference argumnets per factor type\n inference_arguments: Dict[type, Mapping] = {}\n for factor_type in FAC_TO_VAR_UPDATES:\n this_inference_arguments = inspect.getfullargspec(\n FAC_TO_VAR_UPDATES[factor_type]\n ).args\n this_inference_arguments.remove(\"vtof_msgs\")\n this_inference_arguments.remove(\"log_potentials\")\n this_inference_arguments.remove(\"temperature\")\n this_inference_arguments = {\n key: getattr(wiring[factor_type], key) for key in this_inference_arguments\n }\n inference_arguments[factor_type] = this_inference_arguments\n\n factor_type_to_msgs_range = bp_state.fg_state.factor_type_to_msgs_range\n factor_type_to_potentials_range = bp_state.fg_state.factor_type_to_potentials_range\n\n def update(\n bp_arrays: Optional[BPArrays] = None,\n log_potentials_updates: Optional[Dict[Any, jnp.ndarray]] = None,\n ftov_msgs_updates: Optional[Dict[Any, jnp.ndarray]] = None,\n evidence_updates: Optional[Dict[Any, jnp.ndarray]] = None,\n ) -> BPArrays:\n \"\"\"Function to update belief propagation log_potentials, ftov_msgs, evidence.\n\n Args:\n bp_arrays: Optional arrays of log_potentials, ftov_msgs, evidence.\n log_potentials_updates: Optional dictionary containing log_potentials updates.\n ftov_msgs_updates: Optional dictionary containing ftov_msgs updates.\n evidence_updates: Optional dictionary containing evidence updates.\n\n Returns:\n A BPArrays with the updated log_potentials, ftov_msgs and evidence.\n \"\"\"\n if bp_arrays is not None:\n log_potentials = bp_arrays.log_potentials\n evidence = bp_arrays.evidence\n ftov_msgs = bp_arrays.ftov_msgs\n else:\n log_potentials = jax.device_put(bp_state.log_potentials.value)\n ftov_msgs = bp_state.ftov_msgs.value\n evidence = bp_state.evidence.value\n\n if log_potentials_updates is not None:\n log_potentials = bpstate.update_log_potentials(\n log_potentials, log_potentials_updates, bp_state.fg_state\n )\n\n if ftov_msgs_updates is not None:\n ftov_msgs = bpstate.update_ftov_msgs(\n ftov_msgs, ftov_msgs_updates, bp_state.fg_state\n )\n\n if evidence_updates is not None:\n evidence = bpstate.update_evidence(\n evidence, evidence_updates, bp_state.fg_state\n )\n\n return BPArrays(\n log_potentials=log_potentials, ftov_msgs=ftov_msgs, evidence=evidence\n )\n\n def run_bp(\n bp_arrays: BPArrays,\n num_iters: int,\n damping: float = 0.5,\n ) -> BPArrays:\n \"\"\"Function to run belief propagation for num_iters with a damping_factor.\n\n Args:\n bp_arrays: Initial arrays of log_potentials, ftov_msgs, evidence.\n num_iters: Number of belief propagation iterations.\n damping: The damping factor to use for message updates between one timestep and the next.\n\n Returns:\n A BPArrays containing the updated ftov_msgs.\n \"\"\"\n log_potentials = bp_arrays.log_potentials\n evidence = bp_arrays.evidence\n ftov_msgs = bp_arrays.ftov_msgs\n\n # Normalize the messages to ensure the maximum value is 0.\n ftov_msgs = normalize_and_clip_msgs(ftov_msgs, edges_num_states, max_msg_size)\n\n @jax.checkpoint\n def update(msgs: jnp.ndarray, _) -> Tuple[jnp.ndarray, None]:\n # Compute new variable to factor messages by message passing\n vtof_msgs = pass_var_to_fac_messages(\n msgs,\n evidence,\n var_states_for_edges,\n )\n ftov_msgs = jnp.zeros_like(vtof_msgs)\n for factor_type in FAC_TO_VAR_UPDATES:\n msgs_start, msgs_end = factor_type_to_msgs_range[factor_type]\n potentials_start, potentials_end = factor_type_to_potentials_range[\n factor_type\n ]\n ftov_msgs_type = FAC_TO_VAR_UPDATES[factor_type](\n vtof_msgs=vtof_msgs[msgs_start:msgs_end],\n log_potentials=log_potentials[potentials_start:potentials_end],\n temperature=temperature,\n **inference_arguments[factor_type],\n )\n ftov_msgs = ftov_msgs.at[msgs_start:msgs_end].set(ftov_msgs_type)\n\n # Use the results of message passing to perform damping and\n # update the factor to variable messages\n delta_msgs = ftov_msgs - msgs\n msgs = msgs + (1 - damping) * delta_msgs\n # Normalize and clip these damped, updated messages before returning them.\n msgs = normalize_and_clip_msgs(msgs, edges_num_states, max_msg_size)\n return msgs, None\n\n ftov_msgs, _ = jax.lax.scan(update, ftov_msgs, None, num_iters)\n\n return BPArrays(\n log_potentials=log_potentials, ftov_msgs=ftov_msgs, evidence=evidence\n )\n\n def to_bp_state(bp_arrays: BPArrays) -> BPState:\n \"\"\"Function to reconstruct the BPState from a BPArrays\n\n Args:\n bp_arrays: A BPArrays containing log_potentials, ftov_msgs, evidence.\n\n Returns:\n The reconstructed BPState\n \"\"\"\n return BPState(\n log_potentials=LogPotentials(\n fg_state=bp_state.fg_state, value=bp_arrays.log_potentials\n ),\n ftov_msgs=FToVMessages(\n fg_state=bp_state.fg_state,\n value=bp_arrays.ftov_msgs,\n ),\n evidence=Evidence(fg_state=bp_state.fg_state, value=bp_arrays.evidence),\n )\n\n def unflatten_beliefs(flat_beliefs, variable_groups) -> Dict[Hashable, Any]:\n \"\"\"Function that returns unflattened beliefs from the flat beliefs\n\n Args:\n flat_beliefs: Flattened array of beliefs\n variable_groups: All the variable groups in the FactorGraph.\n \"\"\"\n beliefs = {}\n start = 0\n for variable_group in variable_groups:\n num_states = variable_group.num_states\n assert isinstance(num_states, np.ndarray)\n length = num_states.sum()\n\n beliefs[variable_group] = variable_group.unflatten(\n flat_beliefs[start : start + length]\n )\n start += length\n return beliefs\n\n @jax.jit\n def get_beliefs(bp_arrays: BPArrays) -> Dict[Hashable, Any]:\n \"\"\"Function to calculate beliefs from a BPArrays\n\n Args:\n bp_arrays: A BPArrays containing log_potentials, ftov_msgs, evidence.\n\n Returns:\n beliefs: Beliefs returned by belief propagation.\n \"\"\"\n\n flat_beliefs = (\n jax.device_put(bp_arrays.evidence)\n .at[jax.device_put(var_states_for_edges)]\n .add(bp_arrays.ftov_msgs)\n )\n return unflatten_beliefs(flat_beliefs, bp_state.fg_state.variable_groups)\n\n bp = BeliefPropagation(\n init=functools.partial(update, None),\n update=update,\n run_bp=run_bp,\n to_bp_state=to_bp_state,\n get_beliefs=get_beliefs,\n )\n return bp\n\n\n@jax.jit\ndef pass_var_to_fac_messages(\n ftov_msgs: jnp.array,\n evidence: jnp.array,\n var_states_for_edges: jnp.array,\n) -> jnp.array:\n \"\"\"Passes messages from Variables to Factors.\n\n The update works by first summing the evidence and neighboring factor to variable messages for\n each variable. Next, it subtracts messages from the correct elements of this sum to yield the\n correct updated messages.\n\n Args:\n ftov_msgs: Array of shape (num_edge_state,). This holds all the flattened factor to variable\n messages.\n evidence: Array of shape (num_var_states,) representing the flattened evidence for each variable\n var_states_for_edges: Array of shape (num_edge_states,)\n Global variable state indices for each edge state\n Returns:\n Array of shape (num_edge_state,). This holds all the flattened variable to factor messages.\n \"\"\"\n var_sums_arr = evidence.at[var_states_for_edges].add(ftov_msgs)\n vtof_msgs = var_sums_arr[var_states_for_edges] - ftov_msgs\n return vtof_msgs\n\n\n@functools.partial(jax.jit, static_argnames=(\"max_msg_size\"))\ndef normalize_and_clip_msgs(\n msgs: jnp.ndarray,\n edges_num_states: jnp.ndarray,\n max_msg_size: int,\n) -> jnp.ndarray:\n \"\"\"Performs normalization and clipping of flattened messages\n\n Normalization is done by subtracting the maximum value of every message from every element of every message,\n clipping is done to keep every message value in the range [-1000, 0].\n\n Args:\n msgs: Array of shape (num_edge_state,). This holds all the flattened factor to variable messages.\n edges_num_states: Array of shape (num_edges,). Number of states for the variables connected to each edge\n max_msg_size: the max of edges_num_states\n\n Returns:\n Array of shape (num_edge_state,). This holds all the flattened factor to variable messages\n after normalization and clipping\n \"\"\"\n msgs = msgs - jnp.repeat(\n bp_utils.segment_max_opt(msgs, edges_num_states, max_msg_size),\n edges_num_states,\n total_repeat_length=msgs.shape[0],\n )\n # Clip message values to be always greater than -1000\n msgs = jnp.clip(msgs, -1000, None)\n return msgs\n\n\n@jax.jit\ndef decode_map_states(beliefs: Dict[Hashable, Any]) -> Any:\n \"\"\"Function to decode MAP states given the calculated beliefs.\n\n Args:\n beliefs: An array or a PyTree container containing beliefs for different variables.\n\n Returns:\n An array or a PyTree container containing the MAP states for different variables.\n \"\"\"\n return jax.tree_util.tree_map(lambda x: jnp.argmax(x, axis=-1), beliefs)\n\n\n@jax.jit\ndef get_marginals(beliefs: Dict[Hashable, Any]) -> Any:\n \"\"\"Function to get marginal probabilities given the calculated beliefs.\n\n Args:\n beliefs: An array or a PyTree container containing beliefs for different variables.\n\n Returns:\n An array or a PyTree container containing the marginal probabilities different variables.\n \"\"\"\n return jax.tree_util.tree_map(\n lambda x: jnp.exp(x - logsumexp(x, axis=-1, keepdims=True)), beliefs\n )\n", "meta": {"hexsha": "67aceb3ac01316416999efe445cd1dae380b8a10", "size": 13879, "ext": "py", "lang": "Python", "max_stars_repo_path": "pgmax/infer/bp.py", "max_stars_repo_name": "NishanthJKumar/PGMax", "max_stars_repo_head_hexsha": "7c71b1456cd84e40b4974649adbf6eecaf0276a7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 45, "max_stars_repo_stars_event_min_datetime": "2021-11-18T15:54:01.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T01:28:06.000Z", "max_issues_repo_path": "pgmax/infer/bp.py", "max_issues_repo_name": "NishanthJKumar/PGMax", "max_issues_repo_head_hexsha": "7c71b1456cd84e40b4974649adbf6eecaf0276a7", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 54, "max_issues_repo_issues_event_min_datetime": "2021-11-07T03:49:21.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-30T23:19:22.000Z", "max_forks_repo_path": "pgmax/infer/bp.py", "max_forks_repo_name": "NishanthJKumar/PGMax", "max_forks_repo_head_hexsha": "7c71b1456cd84e40b4974649adbf6eecaf0276a7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2021-11-03T18:25:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-10T02:55:12.000Z", "avg_line_length": 38.4459833795, "max_line_length": 112, "alphanum_fraction": 0.6685640176, "include": true, "reason": "import numpy,import jax,from jax", "num_tokens": 2963, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5039061705290806, "lm_q2_score": 0.3812195803163618, "lm_q1q2_score": 0.19209889884792114}} {"text": "# coding: utf-8\n# Copyright (c) Pymatgen Development Team.\n# Distributed under the terms of the MIT License.\n\n\"\"\"\nThis module provides core classes needed by all define electronic structure,\nsuch as the Spin, Orbital, etc.\n\"\"\"\n\nfrom monty.json import MSONable\nfrom enum import Enum, unique\nimport numpy as np\n\n__author__ = \"Shyue Ping Ong\"\n__copyright__ = \"Copyright 2011, The Materials Project\"\n__version__ = \"1.0\"\n__maintainer__ = \"Shyue Ping Ong\"\n__email__ = \"shyuep@gmail.com\"\n__status__ = \"Production\"\n__date__ = \"Sep 23, 2011\"\n\n\n@unique\nclass Spin(Enum):\n \"\"\"\n Enum type for Spin. Only up and down.\n Usage: Spin.up, Spin.down.\n \"\"\"\n up, down = (1, -1)\n\n def __int__(self):\n return self.value\n\n def __float__(self):\n return float(self.value)\n\n def __str__(self):\n return str(self.value)\n\n\n@unique\nclass OrbitalType(Enum):\n \"\"\"\n Enum type for orbital type. Indices are basically the azimuthal quantum\n number, l.\n \"\"\"\n\n s = 0\n p = 1\n d = 2\n f = 3\n\n def __str__(self):\n return self.name\n\n\n@unique\nclass Orbital(Enum):\n \"\"\"\n Enum type for specific orbitals. The indices are basically the order in\n which the orbitals are reported in VASP and has no special meaning.\n \"\"\"\n\n s = 0\n py = 1\n pz = 2\n px = 3\n dxy = 4\n dyz = 5\n dz2 = 6\n dxz = 7\n dx2 = 8\n f_3 = 9\n f_2 = 10\n f_1 = 11\n f0 = 12\n f1 = 13\n f2 = 14\n f3 = 15\n\n def __int__(self):\n return self.value\n\n def __str__(self):\n return self.name\n\n @property\n def orbital_type(self):\n \"\"\"\n Returns OrbitalType of an orbital.\n \"\"\"\n return OrbitalType[self.name[0]]\n\n\nclass Magmom(MSONable):\n \"\"\"\n New class in active development. Use with caution, feedback is\n appreciated.\n\n Class to handle magnetic moments. Defines the magnetic moment of a\n site or species relative to a spin quantization axis. Designed for\n use in electronic structure calculations.\n\n * For the general case, Magmom can be specified by a vector,\n e.g. m = Magmom([1.0, 1.0, 2.0]), and subscripts will work as\n expected, e.g. m[0] gives 1.0\n\n * For collinear calculations, Magmom can assumed to be scalar-like,\n e.g. m = Magmom(5.0) will work as expected, e.g. float(m) gives 5.0\n\n Both of these cases should be safe and shouldn't give any surprises,\n but more advanced functionality is available if required.\n\n There also exist useful static methods for lists of magmoms:\n\n * Magmom.are_collinear(magmoms) - if true, a collinear electronic\n structure calculation can be safely initialized, with float(Magmom)\n giving the expected scalar magnetic moment value\n\n * Magmom.get_consistent_set_and_saxis(magmoms) - for non-collinear\n electronic structure calculations, a global, consistent spin axis\n has to be used. This method returns a list of Magmoms which all\n share a common spin axis, along with the global spin axis.\n\n All methods that take lists of magmoms will accept magmoms either as\n Magmom objects or as scalars/lists and will automatically convert to\n a Magmom representation internally.\n\n The following methods are also particularly useful in the context of\n VASP calculations:\n\n * Magmom.get_xyz_magmom_with_001_saxis()\n * Magmom.get_00t_magmom_with_xyz_saxis()\n\n See VASP documentation for more information:\n\n https://cms.mpi.univie.ac.at/wiki/index.php/SAXIS\n \"\"\"\n\n def __init__(self, moment, saxis=(0, 0, 1)):\n \"\"\"\n :param moment: magnetic moment, supplied as float or list/np.ndarray\n :param saxis: spin axis, supplied as list/np.ndarray, parameter will\n be converted to unit vector (default is [0, 0, 1])\n :return: Magmom object\n \"\"\"\n # to init from another Magmom instance\n if isinstance(moment, Magmom):\n saxis = moment.saxis\n moment = moment.moment\n\n moment = np.array(moment, dtype='d')\n if moment.ndim == 0:\n moment = moment * [0, 0, 1]\n\n self.moment = moment\n\n saxis = np.array(saxis, dtype='d')\n\n self.saxis = saxis / np.linalg.norm(saxis)\n\n @classmethod\n def from_global_moment_and_saxis(cls, global_moment, saxis):\n \"\"\"\n Convenience method to initialize Magmom from a given global\n magnetic moment, i.e. magnetic moment with saxis=(0,0,1), and\n provided saxis.\n\n Method is useful if you do not know the components of your\n magnetic moment in frame of your desired saxis.\n\n :param global_moment:\n :param saxis: desired saxis\n :return:\n \"\"\"\n magmom = Magmom(global_moment)\n return cls(magmom.get_moment(saxis=saxis), saxis=saxis)\n\n def _get_transformation_matrix(self, saxis):\n\n saxis = saxis / np.linalg.norm(saxis)\n\n alpha = np.arctan2(saxis[1], saxis[0])\n beta = np.arctan2(np.sqrt(saxis[0] ** 2 + saxis[1] ** 2), saxis[2])\n\n cos_a = np.cos(alpha)\n cos_b = np.cos(beta)\n sin_a = np.sin(alpha)\n sin_b = np.sin(beta)\n\n m = [[cos_b * cos_a, -sin_a, sin_b * cos_a],\n [cos_b * sin_a, cos_a, sin_b * sin_a],\n [-sin_b, 0, cos_b]]\n\n return m\n\n def _get_transformation_matrix_inv(self, saxis):\n\n saxis = saxis / np.linalg.norm(saxis)\n\n alpha = np.arctan2(saxis[1], saxis[0])\n beta = np.arctan2(np.sqrt(saxis[0] ** 2 + saxis[1] ** 2), saxis[2])\n\n cos_a = np.cos(alpha)\n cos_b = np.cos(beta)\n sin_a = np.sin(alpha)\n sin_b = np.sin(beta)\n\n m = [[cos_b * cos_a, cos_b * sin_a, -sin_b],\n [-sin_a, cos_a, 0],\n [sin_b * cos_a, sin_b * sin_a, cos_b]]\n\n return m\n\n def get_moment(self, saxis=(0, 0, 1)):\n \"\"\"\n Get magnetic moment relative to a given spin quantization axis.\n If no axis is provided, moment will be given relative to the\n Magmom's internal spin quantization axis, i.e. equivalent to\n Magmom.moment\n\n :param axis: (list/numpy array) spin quantization axis\n :return: np.ndarray of length 3\n \"\"\"\n\n # transform back to moment with spin axis [0, 0, 1]\n m_inv = self._get_transformation_matrix_inv(self.saxis)\n moment = np.matmul(self.moment, m_inv)\n\n # transform to new saxis\n m = self._get_transformation_matrix(saxis)\n moment = np.matmul(moment, m)\n\n # round small values to zero\n moment[np.abs(moment) < 1e-8] = 0\n\n return moment\n\n @property\n def global_moment(self):\n \"\"\"\n Get the magnetic moment defined in an arbitrary global reference frame.\n\n :return: np.ndarray of length 3\n \"\"\"\n return self.get_moment()\n\n @property\n def projection(self):\n \"\"\"\n Projects moment along spin quantisation axis. Useful for obtaining\n collinear approximation for slightly non-collinear magmoms.\n\n :return: float\n \"\"\"\n return np.dot(self.moment, self.saxis)\n\n def get_xyz_magmom_with_001_saxis(self):\n \"\"\"\n Returns a Magmom in the default setting of saxis = [0, 0, 1] and\n the magnetic moment rotated as required.\n\n :return: Magmom\n \"\"\"\n return Magmom(self.get_moment())\n\n def get_00t_magmom_with_xyz_saxis(self):\n \"\"\"\n For internal implementation reasons, in non-collinear calculations\n VASP prefers:\n\n MAGMOM = 0 0 total_magnetic_moment\n SAXIS = x y z\n\n to an equivalent:\n\n MAGMOM = x y z\n SAXIS = 0 0 1\n\n This method returns a Magmom object with magnetic moment [0, 0, t],\n where t is the total magnetic moment, and saxis rotated as required.\n\n A consistent direction of saxis is applied such that t might be positive\n or negative depending on the direction of the initial moment. This is useful\n in the case of collinear structures, rather than constraining assuming\n t is always positive.\n\n :return: Magmom\n \"\"\"\n # reference direction gives sign of moment\n # entirely arbitrary, there will always be a pathological case\n # where a consistent sign is not possible if the magnetic moments\n # are aligned along the reference direction, but in practice this\n # is unlikely to happen\n ref_direction = np.array([1.01, 1.02, 1.03])\n t = abs(self)\n if t != 0:\n new_saxis = self.moment / np.linalg.norm(self.moment)\n if np.dot(ref_direction, new_saxis) < 0:\n t = -t\n new_saxis = -new_saxis\n return Magmom([0, 0, t], saxis=new_saxis)\n else:\n return Magmom(self)\n\n @staticmethod\n def have_consistent_saxis(magmoms):\n \"\"\"\n This method checks that all Magmom objects in a list have a\n consistent spin quantization axis. To write MAGMOM tags to a\n VASP INCAR, a global SAXIS value for all magmoms has to be used.\n If saxis are inconsistent, can create consistent set with:\n Magmom.get_consistent_set(magmoms)\n\n :param magmoms: list of magmoms (Magmoms, scalars or vectors)\n :return: bool\n \"\"\"\n magmoms = [Magmom(magmom) for magmom in magmoms]\n ref_saxis = magmoms[0].saxis\n match_ref = [magmom.saxis == ref_saxis for magmom in magmoms]\n if np.all(match_ref):\n return True\n else:\n return False\n\n @staticmethod\n def get_consistent_set_and_saxis(magmoms, saxis=None):\n \"\"\"\n Method to ensure a list of magmoms use the same spin axis.\n Returns a tuple of a list of Magmoms and their global spin axis.\n\n :param magmoms: list of magmoms (Magmoms, scalars or vectors)\n :param saxis: can provide a specific global spin axis\n :return: (list of Magmoms, global spin axis) tuple\n \"\"\"\n magmoms = [Magmom(magmom) for magmom in magmoms]\n if saxis is None:\n saxis = Magmom.get_suggested_saxis(magmoms)\n else:\n saxis = saxis / np.linalg.norm(saxis)\n magmoms = [magmom.get_moment(saxis=saxis) for magmom in magmoms]\n return (magmoms, saxis)\n\n @staticmethod\n def get_suggested_saxis(magmoms):\n \"\"\"\n This method returns a suggested spin axis for a set of magmoms,\n taking the largest magnetic moment as the reference. For calculations\n with collinear spins, this would give a sensible saxis for a ncl\n calculation.\n\n :param magmoms: list of magmoms (Magmoms, scalars or vectors)\n :return: np.ndarray of length 3\n \"\"\"\n # heuristic, will pick largest magmom as reference\n # useful for creating collinear approximations of\n # e.g. slightly canted magnetic structures\n # for fully collinear structures, will return expected\n # result\n\n magmoms = [Magmom(magmom) for magmom in magmoms]\n # filter only non-zero magmoms\n magmoms = [magmom for magmom in magmoms if abs(magmom)]\n magmoms.sort(reverse=True)\n if len(magmoms) > 0:\n return magmoms[0].get_00t_magmom_with_xyz_saxis().saxis\n else:\n return np.array([0, 0, 1], dtype=\"d\")\n\n @staticmethod\n def are_collinear(magmoms):\n \"\"\"\n Method checks to see if a set of magnetic moments are collinear\n with each other.\n :param magmoms: list of magmoms (Magmoms, scalars or vectors)\n :return: bool\n \"\"\"\n magmoms = [Magmom(magmom) for magmom in magmoms]\n if not Magmom.have_consistent_saxis(magmoms):\n magmoms = Magmom.get_consistent_set(magmoms)\n\n # convert to numpy array for convenience\n magmoms = np.array([list(magmom) for magmom in magmoms])\n magmoms = magmoms[np.any(magmoms, axis=1)] # remove zero magmoms\n if len(magmoms) == 0:\n return True\n\n # use first moment as reference to compare against\n ref_magmom = magmoms[0]\n # magnitude of cross products != 0 if non-collinear with reference\n num_ncl = np.count_nonzero(np.linalg.norm(np.cross(ref_magmom, magmoms), axis=1))\n if num_ncl > 0:\n return False\n else:\n return True\n\n @classmethod\n def from_moment_relative_to_crystal_axes(cls, moment, lattice):\n \"\"\"\n Obtaining a Magmom object from a magnetic moment provided\n relative to crystal axes.\n\n Used for obtaining moments from magCIF file.\n :param magmom: list of floats specifying vector magmom\n :param lattice: Lattice\n :return: Magmom\n \"\"\"\n # get matrix representing unit lattice vectors\n unit_m = lattice.matrix / np.linalg.norm(lattice.matrix, axis=1)[:, None]\n moment = np.matmul(list(moment), unit_m)\n # round small values to zero\n moment[np.abs(moment) < 1e-8] = 0\n return cls(moment)\n\n def get_moment_relative_to_crystal_axes(self, lattice):\n \"\"\"\n If scalar magmoms, moments will be given arbitrarily along z.\n Used for writing moments to magCIF file.\n\n :param magmom: Magmom\n :param lattice: Lattice\n :return: vector as list of floats\n \"\"\"\n # get matrix representing unit lattice vectors\n unit_m = lattice.matrix / np.linalg.norm(lattice.matrix, axis=1)[:, None]\n # note np.matmul() requires numpy version >= 1.10\n moment = np.matmul(self.global_moment, np.linalg.inv(unit_m))\n # round small values to zero\n moment[np.abs(moment) < 1e-8] = 0\n return moment\n\n def __getitem__(self, key):\n return self.moment[key]\n\n def __iter__(self):\n return iter(self.moment)\n\n def __abs__(self):\n return np.linalg.norm(self.moment)\n\n def __eq__(self, other):\n \"\"\"\n Equal if 'global' magnetic moments are the same, saxis can differ.\n \"\"\"\n other = Magmom(other)\n return np.allclose(self.global_moment, other.global_moment)\n\n def __ne__(self, other):\n return not self.__eq__(other)\n\n def __lt__(self, other):\n return abs(self) < abs(other)\n\n def __neg__(self):\n return Magmom(-self.moment, saxis=self.saxis)\n\n def __hash__(self):\n return (tuple(self.moment) + tuple(self.saxis)).__hash__()\n\n def __float__(self):\n \"\"\"\n Returns magnitude of magnetic moment with a sign with respect to\n an arbitrary direction.\n\n Should give unsurprising output if Magmom is treated like a\n scalar or if a set of Magmoms describes a collinear structure.\n\n Implemented this way rather than simpler abs(self) so that\n moments will have a consistent sign in case of e.g.\n antiferromagnetic collinear structures without additional\n user intervention.\n\n However, should be used with caution for non-collinear\n structures and might give non-sensical results except in the case\n of only slightly non-collinear structures (e.g. small canting).\n\n This approach is also used to obtain \"diff\" VolumetricDensity\n in pymatgen.io.vasp.outputs.VolumetricDensity when processing\n Chgcars from SOC calculations.\n \"\"\"\n return float(self.get_00t_magmom_with_xyz_saxis()[2])\n\n def __str__(self):\n return str(float(self))\n\n def __repr__(self):\n if np.allclose(self.saxis, (0, 0, 1)):\n return 'Magnetic moment {0}'.format(self.moment)\n else:\n return 'Magnetic moment {0} (spin axis = {1})'.format(self.moment,\n self.saxis)\n", "meta": {"hexsha": "43fd11e90aedf70d0585348a5525036ada39e121", "size": 15748, "ext": "py", "lang": "Python", "max_stars_repo_path": "pymatgen/electronic_structure/core.py", "max_stars_repo_name": "cajfisher/pymatgen", "max_stars_repo_head_hexsha": "286c304e38102d567723a71f733e0c304b72035d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2015-02-06T08:27:09.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-28T14:42:52.000Z", "max_issues_repo_path": "pymatgen/electronic_structure/core.py", "max_issues_repo_name": "cajfisher/pymatgen", "max_issues_repo_head_hexsha": "286c304e38102d567723a71f733e0c304b72035d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pymatgen/electronic_structure/core.py", "max_forks_repo_name": "cajfisher/pymatgen", "max_forks_repo_head_hexsha": "286c304e38102d567723a71f733e0c304b72035d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2018-10-17T19:08:09.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-02T20:26:58.000Z", "avg_line_length": 32.0081300813, "max_line_length": 89, "alphanum_fraction": 0.625984252, "include": true, "reason": "import numpy", "num_tokens": 4038, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5039061705290806, "lm_q2_score": 0.3812195803163617, "lm_q1q2_score": 0.1920988988479211}} {"text": "\"\"\"\nNAME:\n\tplotting_functions.py\n\nAUTHOR:\n\tBronwyn Reichardt Chu\n\tSwinburne\n\t2021\n\nEMAIL:\n\t\n\nPURPOSE:\n\tTo hold useful plotting functions\n\tWritten on MacOS Mojave 10.14.5, with Python 3.7\n\nFUNCTIONS INLCUDED:\n get_rc_params\n chen_et_al_2010\n murray_et_al_2011\n davies_et_al_2019\n kim_et_al_2020\n fitting_function\n running_mean\n lower_quantile\n upper_quantile\n binned_median_quantile_log\n binned_median_quantile_lin\n pearson_correlation\n read_in_create_wcs\n plot_continuum_contours\n\nMODIFICATION HISTORY:\n\t\tv.1.0 - first created January 2021\n\n\"\"\"\nimport numpy as np\nimport scipy.stats as stats\n\nfrom astropy.io import fits\nfrom astropy.wcs import WCS\n\n\n#===============================================================================\n# DEFINE PLOTTING PARAMETERS\n#===============================================================================\n\n\ndef get_rc_params():\n \"\"\"\n Define the rcParams that will be used in all the plots.\n\n Returns\n -------\n rc_params dictionary object\n \"\"\"\n\n rc_params = {\n \"text.usetex\": False,\n \"axes.facecolor\": 'white',\n\n #\"figure.dpi\": 125,\n #\"legend.fontsize\": 12,\n \"legend.frameon\": False,\n #\"legend.markerscale\": 1.0,\n\n \"axes.labelsize\": 'large',\n\n \"xtick.direction\": 'in',\n \"xtick.labelsize\": 'medium',\n \"xtick.minor.visible\": True,\n \"xtick.top\": True,\n \"xtick.major.width\": 1,\n\n \"ytick.direction\": 'in',\n \"ytick.labelsize\": 'medium',\n \"ytick.minor.visible\": True,\n \"ytick.right\": True,\n \"ytick.major.width\": 1,\n }\n\n return rc_params\n\n\n#===============================================================================\n# RELATIONS FROM OTHER PAPERS\n#===============================================================================\n\n\ndef chen_et_al_2010(sfr_surface_density_min, sfr_surface_density_max, scale_factor=1):\n \"\"\"\n The trendline from Chen et al. (2010) where v_out is proportional to (SFR surface density)^0.1\n (Energy driven winds - SNe feedback)\n\n Parameters\n ----------\n sfr_surface_density_min : float\n The minimum value of the SFR surface density\n\n sfr_surface_density_max : float\n The maximum value of the SFR surface density\n\n scale_factor : float\n The number by which to scale the trend, can be used to bring the trend\n into the range of the data on the plot (Default = 1)\n\n Returns\n -------\n sfr_surface_density : :obj:'~numpy.ndarray'\n vector of SFR surface densities\n\n v_out : :obj:'~numpy.ndarray'\n vector of outflow velocities following the trend\n \"\"\"\n #create a vector for sfr surface density\n sfr_surface_density = np.linspace(sfr_surface_density_min, sfr_surface_density_max+4, num=1000)\n\n #use the relationship to predict the v_out\n v_out = scale_factor*sfr_surface_density**0.1\n\n return sfr_surface_density, v_out\n\n\ndef murray_et_al_2011(sfr_surface_density_min, sfr_surface_density_max, scale_factor=1):\n \"\"\"\n The trendline from Murray et al. (2011) where v_out is proportional to (SFR surface density)^2\n (Momentum driven winds - radiative feedback from young stars)\n\n Parameters\n ----------\n sfr_surface_density_min : float\n The minimum value of the SFR surface density\n\n sfr_surface_density_max : float\n The maximum value of the SFR surface density\n\n scale_factor : float\n The number by which to scale the trend, can be used to bring the trend\n into the range of the data on the plot (Default = 1)\n\n Returns\n -------\n sfr_surface_density : :obj:'~numpy.ndarray'\n vector of SFR surface densities\n\n v_out : :obj:'~numpy.ndarray'\n vector of outflow velocities following the trend\n \"\"\"\n #create a vector for sfr surface density\n sfr_surface_density = np.linspace(sfr_surface_density_min, sfr_surface_density_max+4, num=1000)\n\n #use the relationship to predict the v_out\n v_out = scale_factor*sfr_surface_density**2\n\n return sfr_surface_density, v_out\n\ndef davies_et_al_2019(sfr_surface_density_min, sfr_surface_density_max):\n \"\"\"\n The trendline from Davies et al. (2019) where the flow velocity dispersion\n is proportional to SFR surface density.\n\n Parameters\n ----------\n sfr_surface_density_min : float\n The minimum value of the SFR surface density\n\n sfr_surface_density_max : float\n The maximum value of the SFR surface density\n\n Returns\n -------\n sfr_surface_density : :obj:'~numpy.ndarray'\n vector of SFR surface densities\n\n vel_disp : :obj:'~numpy.ndarray'\n vector of outflow velocity dispersions following the trend\n \"\"\"\n #create a vector for sfr surface density\n sfr_surface_density = np.linspace(sfr_surface_density_min, sfr_surface_density_max+4, num=1000)\n\n #use the relationship to predict the v_out\n vel_disp = 241*sfr_surface_density**0.3\n\n return sfr_surface_density, vel_disp\n\ndef kim_et_al_2020(sfr_surface_density_min, sfr_surface_density_max, scale_factor=1):\n \"\"\"\n The trendline from Kim et al. (2020) where mass the loading factor is proportional\n to (SFR surface density)^-0.44\n\n Parameters\n ----------\n sfr_surface_density_min : float\n The minimum value of the SFR surface density\n\n sfr_surface_density_max : float\n The maximum value of the SFR surface density\n\n scale_factor : float\n The number by which to scale the trend, can be used to bring the trend\n into the range of the data on the plot (Default = 1)\n\n Returns\n -------\n sfr_surface_density : :obj:'~numpy.ndarray'\n vector of SFR surface densities\n\n mlf : :obj:'~numpy.ndarray'\n vector of mass loading factors following the trend\n \"\"\"\n #create a vector for sfr surface density\n sfr_surface_density = np.linspace(sfr_surface_density_min, sfr_surface_density_max+4, num=1000)\n\n #use the relationship to predict the v_out\n mlf = scale_factor*sfr_surface_density**-0.44\n\n return sfr_surface_density, mlf\n\n\n#===============================================================================\n# USEFUL LITTLE FUNCTIONS\n#===============================================================================\n\ndef fitting_function(x, a, b):\n \"\"\"\n My fitting function to be fit to the v_out to sfr surface density data\n\n Parameters\n ----------\n x : (vector)\n the SFR surface density\n\n a, b : (int)\n constants to be fit\n\n Returns\n -------\n y : (vector)\n the outflow velocity\n \"\"\"\n return a*(x**b)\n\ndef running_mean(x, N):\n \"\"\"\n Calculates the running mean\n\n Parameters\n ----------\n x : :obj:'~numpy.ndarray'\n data\n N : integer\n bin size\n \"\"\"\n\n cumsum = np.cumsum(np.insert(x, 0, 0))\n return (cumsum[N:] - cumsum[:-N]) / float(N)\n\ndef lower_quantile(x):\n \"\"\"\n Calculate the lower quantile of x (data :obj:'~numpy.nd:obj:'~numpy.ndarray'')\n \"\"\"\n return np.nanquantile(x, 0.33)\n\ndef upper_quantile(x):\n \"\"\"\n Calculate the upper quantile of x (data :obj:'~numpy.ndarray')\n \"\"\"\n return np.nanquantile(x, 0.66)\n\n\ndef binned_median_quantile_log(x, y, num_bins, weights=None, min_bin=None, max_bin=None):\n \"\"\"\n Calculate the median, upper and lower quantile for an array of data in\n logarithmically increasing bins\n\n Parameters\n ----------\n x : :obj:'~numpy.ndarray'\n x-axis logarithmic data\n\n y : :obj:'~numpy.ndarray'\n y-axis data\n\n num_bins : integer\n the number of bins to divide the data into\n\n weights : :obj:'~numpy.ndarray'\n array to multiply x by, usually the error (Default = None)\n\n min_bin : float\n starting value of the first bin (Default = None)\n\n max_bin : float\n ending value of the last bin (Default = None)\n\n Returns\n -------\n logspace : :obj:'~numpy.ndarray'\n the logarithmic array of bin edges in x\n\n bin_center : :obj:'~numpy.ndarray'\n values indicating the centres of the bins in x\n\n bin_avg : :obj:'~numpy.ndarray'\n values of the median of the bins in y\n\n lower_quantile : :obj:'~numpy.ndarray'\n values for the lower quantile of each bin in y\n\n upper_quantile : :obj:'~numpy.ndarray'\n values for the upper quantile of each bin in y\n\n bin_stdev : :obj:'~numpy.ndarray'\n values for the standard deviation of each bin in y\n \"\"\"\n if min_bin == None:\n min_bin = np.nanmin(x)\n\n if max_bin == None:\n max_bin = np.nanmax(x)\n\n #create the logspace - these are the bin edges\n logspace = np.logspace(np.log10(min_bin), np.log10(max_bin), num=num_bins+1)\n\n #calculate the average\n bin_avg = np.zeros(len(logspace)-1)\n upper_quantile = np.zeros(len(logspace)-1)\n lower_quantile = np.zeros(len(logspace)-1)\n bin_stdev = np.zeros(len(logspace)-1)\n\n for i in range(0, len(logspace)-1):\n left_bound = logspace[i]\n right_bound = logspace[i+1]\n items_in_bin = y[(x>left_bound)&(x<=right_bound)]\n print('Number of items in bin '+str(i)+': '+str(items_in_bin.shape))\n #calculate the median of the bin\n if weights == None:\n bin_avg[i] = np.nanmedian(items_in_bin)\n else:\n weights_in_bin = weights[0][(x>left_bound)&(x<=right_bound)]\n weights_in_bin = 1.0 - weights_in_bin/items_in_bin\n bin_avg[i] = np.average(items_in_bin, weights=weights_in_bin)\n\n #calculate the quartiles of the bin\n if items_in_bin.shape[0] < 10:\n upper_quantile[i] = np.nanquantile(items_in_bin, 0.80)\n lower_quantile[i] = np.nanquantile(items_in_bin, 0.20)\n else:\n upper_quantile[i] = np.nanquantile(items_in_bin, 0.66)\n lower_quantile[i] = np.nanquantile(items_in_bin, 0.33)\n\n #calculate the standard deviation of the bin\n bin_stdev[i] = np.nanstd(items_in_bin)\n\n #calculate the bin center for plotting\n bin_center = np.zeros(len(logspace)-1)\n for i in range(0, len(logspace)-1):\n bin_center[i] = np.nanmean([logspace[i],logspace[i+1]])\n\n return logspace, bin_center, bin_avg, lower_quantile, upper_quantile, bin_stdev\n\n\ndef binned_median_quantile_lin(x, y, num_bins, weights=None, min_bin=None, max_bin=None):\n \"\"\"\n Calculate the median, upper and lower quantile for an array of data in\n linearly increasing bins\n\n Parameters\n ----------\n x : :obj:'~numpy.ndarray'\n x-axis linear data\n\n y : :obj:'~numpy.ndarray'\n y-axis data\n\n num_bins : integer\n the number of bins to divide the data into\n\n weights : :obj:'~numpy.ndarray'\n array to multiply x by, usually the error (Default = None)\n\n min_bin : float\n starting value of the first bin (Default = None)\n\n max_bin : float\n ending value of the last bin (Default = None)\n\n Returns\n -------\n linspace : :obj:'~numpy.ndarray'\n the array of linear bin edges in x\n\n bin_center : :obj:'~numpy.ndarray'\n values indicating the centres of the bins in x\n\n bin_avg : :obj:'~numpy.ndarray'\n values of the median of the bins in y\n\n lower_quantile : :obj:'~numpy.ndarray'\n values for the lower quantile of each bin in y\n\n upper_quantile : :obj:'~numpy.ndarray'\n values for the upper quantile of each bin in y\n\n bin_stdev : :obj:'~numpy.ndarray'\n values for the standard deviation of each bin in y\n \"\"\"\n if min_bin == None:\n min_bin = np.nanmin(x)\n if max_bin == None:\n max_bin = np.nanmax(x)\n\n #create the logspace - these are the bin edges\n linspace = np.linspace(min_bin, max_bin, num=num_bins+1)\n\n #calculate the average\n bin_avg = np.zeros(len(linspace)-1)\n upper_quantile = np.zeros(len(linspace)-1)\n lower_quantile = np.zeros(len(linspace)-1)\n bin_stdev = np.zeros(len(linspace)-1)\n\n for i in range(0, len(linspace)-1):\n left_bound = linspace[i]\n right_bound = linspace[i+1]\n items_in_bin = y[(x>left_bound)&(x<=right_bound)]\n print('Number of items in bin '+str(i)+': '+str(items_in_bin.shape))\n if weights == None:\n bin_avg[i] = np.nanmedian(items_in_bin)\n else:\n weights_in_bin = weights[0][(x>left_bound)&(x<=right_bound)]\n weights_in_bin = 1.0 - weights_in_bin/items_in_bin\n bin_avg[i] = np.average(items_in_bin, weights=weights_in_bin)\n\n if items_in_bin.shape[0] < 10:\n upper_quantile[i] = np.nanquantile(items_in_bin, 0.80)\n lower_quantile[i] = np.nanquantile(items_in_bin, 0.20)\n else:\n upper_quantile[i] = np.nanquantile(items_in_bin, 0.66)\n lower_quantile[i] = np.nanquantile(items_in_bin, 0.33)\n\n #calculate the standard deviation of the bin\n bin_stdev[i] = np.nanstd(items_in_bin)\n\n #calculate the bin center for plotting\n bin_center = np.zeros(len(linspace)-1)\n for i in range(0, len(linspace)-1):\n bin_center[i] = np.nanmean([linspace[i],linspace[i+1]])\n\n return linspace, bin_center, bin_avg, lower_quantile, upper_quantile, bin_stdev\n\n\ndef pearson_correlation(x, y):\n \"\"\"\n Calculate the Pearson correlation coefficient and p-value\n\n Parameters\n ----------\n x : :obj:'~numpy.ndarray'\n Input array - x values\n\n y : :obj:'~numpy.ndarray'\n Input array - y values\n\n Returns\n -------\n r : float\n Pearson's correlation coefficient\n\n p_value : float\n Two-tailed p-value\n \"\"\"\n r, p_value = stats.pearsonr(x, y)\n\n return r, p_value\n\n\ndef read_in_create_wcs(fits_file, index=0, shift=None):\n \"\"\"\n Reads in the fits file and creates the wcs\n\n Parameters\n ----------\n fits_file : string\n the filepath for the fits file to read in\n\n index : int\n the index of the extension to be loaded (default is 0)\n\n shift : list or None\n how to alter the header if the wcs is going to be wrong.\n e.g. ['CRPIX2', 32.0] will change the header value of CRPIX2 to 32.0\n\n Returns\n -------\n fits_data : :obj:'~numpy.ndarray'\n the fits data as a numpy array\n\n fits_wcs : astropy WCS object\n the world coordinate system for the fits file\n \"\"\"\n #read the data in from fits\n with fits.open(fits_file) as hdu:\n hdu.info()\n fits_data = hdu[index].data\n fits_header = hdu[index].header\n hdu.close()\n\n #shift the header\n if shift:\n fits_header[shift[0]] = shift[1]\n\n #create the WCS\n fits_wcs = WCS(fits_header)\n\n return fits_data, fits_header, fits_wcs\n\n\ndef plot_continuum_contours(lamdas, xx, yy, data, z, ax):\n \"\"\"\n Plots the continuum contours, using the rest wavelengths between 4600 and 4800 to define the continuum.\n\n Parameters\n ----------\n lamdas : :obj:'~numpy.ndarray'\n wavelength vector (1D)\n\n xx : :obj:'~numpy.ndarray'\n x coordinate array (2D)\n\n yy : :obj:'~numpy.ndarray'\n y coordinate array (2D)\n\n data : :obj:'~numpy.ndarray'\n data array (3D)\n\n z : float\n redshift of the galaxy\n\n ax : matplotlib axis instance\n axis for matplotlib to draw on\n\n Returns\n -------\n cont_contours : matplotlib.contour.QuadContourSet instance\n\n \"\"\"\n #create a mask for the continuum\n cont_mask = (lamdas>4600*(1+z))&(lamdas<4800*(1+z))\n\n #find the median of the continuum\n cont_median = np.median(data[cont_mask,:,:], axis=0)\n\n #create the contours\n cont_contours = ax.contour(xx, yy, cont_median, colors='black', linewidths=0.7, alpha=0.7, levels=(0.2,0.3,0.4,0.7,1.0,2.0,4.0))\n\n return cont_contours\n", "meta": {"hexsha": "9b3b5fcaf89e9020a1ea408f8556f481a8a2cd49", "size": 15748, "ext": "py", "lang": "Python", "max_stars_repo_path": "plotting_functions.py", "max_stars_repo_name": "bronreichardtchu/koffee", "max_stars_repo_head_hexsha": "7fc9ee53b940aecf716c23ec8003aa138d60aabc", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "plotting_functions.py", "max_issues_repo_name": "bronreichardtchu/koffee", "max_issues_repo_head_hexsha": "7fc9ee53b940aecf716c23ec8003aa138d60aabc", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "plotting_functions.py", "max_forks_repo_name": "bronreichardtchu/koffee", "max_forks_repo_head_hexsha": "7fc9ee53b940aecf716c23ec8003aa138d60aabc", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-06-21T22:55:28.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-21T22:55:28.000Z", "avg_line_length": 28.2728904847, "max_line_length": 132, "alphanum_fraction": 0.6268732537, "include": true, "reason": "import numpy,import scipy,from astropy", "num_tokens": 4015, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5039061705290806, "lm_q2_score": 0.38121956625615, "lm_q1q2_score": 0.19209889176289366}} {"text": "import os\nfrom pyscf import lib,pbc\nfrom pyscf.lib import param\nfrom pyscf.pbc.lib.kpts_helper import gamma_point\nimport numpy as np\nimport ctypes\nimport math\nfrom multiprocessing import Pool\nimport time,gc\nfrom pydmfet import tools\n\nlib_wannier90 = np.ctypeslib.load_library('libwannier90', os.path.dirname(__file__))\nlibmisc = np.ctypeslib.load_library('libmisc', os.path.dirname(__file__))\nnum_nnmax = 12\n\nsqrt = math.sqrt\n\n\ndef assign_wf2atm(wf,filename=None,num_wf=None,natom=None):\n\n if filename is None: filename = wf.seedname+'_centres.xyz'\n if num_wf is None: num_wf = wf.num_wann\n if natom is None: natom = wf.num_atoms\n\n wf_c = np.zeros((num_wf,3))\n atm_cart = np.zeros((natom,3))\n with open( filename, 'r' ) as f:\n tmp = next(f)\n tmp = next(f)\n for i in range(num_wf):\n a,x,y,z = [tmp for tmp in next(f).split()]\n wf_c[i,0] = float(x)\n wf_c[i,1] = float(y)\n wf_c[i,2] = float(z)\n for i in range(natom):\n a,x,y,z = [tmp for tmp in next(f).split()]\n atm_cart[i,0] = float(x)\n atm_cart[i,1] = float(y)\n atm_cart[i,2] = float(z)\n\n dist_table = np.zeros((natom,num_wf))\n for i in range(natom):\n for j in range(num_wf):\n dist_table[i,j] = np.linalg.norm(atm_cart[i] - wf_c[j])\n\n #print dist_table\n aoslice = wf.cell.aoslice_by_atom()\n assign_table = []\n assign_list = []\n for i in range(natom):\n seq = dist_table[i].argsort()\n nao = aoslice[i,3] - aoslice[i,2]\n assign_table.append(seq[:nao])\n for j in range(nao):\n assign_list.append(seq[j])\n\n print (assign_table)\n print (assign_list)\n\n for i in range(num_wf):\n exist = False\n for j in range(num_wf):\n if(assign_list[j] == i):\n exist = True\n\n assert(exist == True)\n\n return assign_list\n\n\ndef read_umat(wannier,filename):\n\n nk = 0\n nw = 0\n nw1 = 0\n kpts = None\n umat = None\n with open( filename, 'r' ) as f:\n tmp = next(f)\n nk,nw,nw1 = [int(x) for x in next(f).split()]\n tmp = next(f)\n kpts = np.zeros((nk,3))\n umat = np.zeros((nk,nw,nw), dtype = np.complex128)\n for k in range(nk):\n kpts[k] = [float(x) for x in next(f).split()]\n for j in range(nw):\n for i in range(nw):\n u_r, u_i = [float(x) for x in next(f).split()]\n umat[k,i,j] = u_r + 1j*u_i\n if(k0.0001:\n print ('k=',k,' iband=',i, ' nelec=',nelec)\n\n u2_r *= -1.0\n u2_r.sort()\n u2_r *= -1.0\n rho = 0.0\n index = -1\n for j in range(ngs):\n rho += weight * u2_r[j]\n if(rho > thresh):\n index = j\n break\n\n c[i] = sqrt(0.5*(u2_r[j] + u2_r[j-1]))\n print (c[i])\n\n\n \ndef get_nnkpts(nntot, nnlist, nncell):\n\n nk = nnlist.shape[0]\n nnkpts = np.zeros((nk,nntot,5), dtype=np.int32) \n\n for k in range(nk):\n for i in range(nntot):\n nnkpts[k,i,0] = k+1\n nnkpts[k,i,1] = nnlist[k,i]\n nnkpts[k,i,2:5] = nncell[0:3,k,i] \n\n return nnkpts\n\ndef get_bpts(wannier, nnkpts=None, kpts = np.zeros((1,3)) ):\n\n if nnkpts is None: nnkpts = wannier.nnkpts\n nk = len(kpts)\n nb = nnkpts.shape[1]\n\n cell = wannier.cell\n b = cell.reciprocal_vectors()\n\n bpts = np.zeros((nk,nb,3))\n for k in range(nk):\n for i in range(nb):\n kk = nnkpts[k,i,0]-1\n k2 = nnkpts[k,i,1]-1\n kb = kpts[k2] + np.dot(nnkpts[k,i,2:5], b) \n bpts[k,i,:] = kb - kpts[kk]\n\n return bpts\n\n\ndef write_Amn(wannier, filename, nk, nband = None, Amn = None):\n\n if Amn is None: Amn = wannier.Amn\n if nband is None: nband = wannier.nband\n\n with open( filename, 'w' ) as fout:\n fout.write('Amn file\\n')\n fout.write('%d %d %d\\n' % (nband, nk, nband))\n\n for k in range(nk):\n for n in range(nband):\n for m in range(nband):\n fout.write('%d %d %d %16.10f %16.10f\\n' % (m+1, n+1, k+1, Amn[k,m,n].real, Amn[k,m,n].imag) )\n\n\n\ndef write_Mmn(wannier, filename, nk, nband = None, Mmn = None, nnkpts=None):\n\n if Mmn is None: Mmn = wannier.Mmn\n if nnkpts is None: nnkpts = wannier.nnkpts\n if nband is None: nband = wannier.nband\n\n nntot = nnkpts.shape[1]\n\n with open( filename, 'w' ) as fout:\n\n fout.write('Mmn file\\n')\n fout.write('%d %d %d\\n' % (nband, nk, nntot))\n\n for k in range(nk):\n for i in range(nntot):\n fout.write('%d %d %d %d %d\\n' % tuple(nnkpts[k,i]) )\n for n in range(nband):\n for m in range(nband):\n fout.write('%16.10f %16.10f\\n' % (Mmn[k,i,m,n].real, Mmn[k,i,m,n].imag) ) \n\n\ndef comput_Mmn(wannier, bands = None, nband = None, bpts=None, kpts = np.zeros((1,3)) ):\n\n #only works for Gamma point\n\n if bands is None: bands = wannier.bands\n if nband is None: nband = wannier.nband\n if bpts is None: bpts = wannier.bpts\n mf = wannier.mf\n mo_coeff = mf.mo_coeff\n\n cell = wannier.cell\n mydf = mf.with_df\n gs = mydf.gs\n\n coords = cell.gen_uniform_grids(gs)\n ngs = len(coords)\n\n ni = mydf._numint\n\n weight = cell.vol / ngs\n\n aoR = ni.eval_ao(cell, coords, kpts, non0tab=None)\n\n \n nk = len(kpts) \n nntot = bpts.shape[1]\n phase_b = np.zeros((nk,nntot,ngs), dtype = np.complex128)\n for k in range(nk):\n for i in range(nntot):\n for j in range(ngs):\n br = np.dot(bpts[k,i], coords[j])\n phase_b[k,i,j] = np.exp(-1j*br)\n\n nbas = cell.nao_nr()\n Mmunu = np.zeros((nk,nntot,nbas,nbas), dtype = np.complex128)\n Mmn = np.zeros((nk,nntot,nband,nband), dtype = np.complex128)\n for k, aoR_k in enumerate(aoR):\n for i in range(nntot):\n Mmunu[k,i] = weight * lib.dot(aoR_k.T.conj()*phase_b[k,i], aoR_k)\n\n for k in range(nk):\n for i in range(nntot):\n Mmn[k,i] = lib.dot(lib.dot(mo_coeff[:,bands].T.conj(), Mmunu[k,i]), mo_coeff[:,bands])\n\n return Mmn\n\ndef read_proj_data(filename):\n\n nband = 0\n with open( filename, 'r' ) as f:\n tmp = next(f)\n nband = int(next(f))\n R = np.zeros((nband,3))\n lmr = np.zeros((nband,3),dtype=np.int32)\n zaxis = np.zeros((nband,3))\n xaxis = np.zeros((nband,3))\n zona = np.zeros(nband)\n for i in range(nband):\n tmp = [float(x) for x in next(f).split()]\n R[i,0:3] = tmp[0:3]\n lmr[i,0:3] = [int(x) for x in tmp[3:6]]\n tmp = [float(x) for x in next(f).split()]\n zaxis[i,0:3] = tmp[0:3]\n xaxis[i,0:3] = tmp[3:6]\n zona[i] = tmp[6]\n zona[i] *= param.BOHR\n\n return (R,lmr,zaxis,xaxis,zona) \n\n\ndef comput_g_r_para(i, R,lmr,zaxis,xaxis,zona,coords):\n\n ngs = len(coords)\n g_r = np.zeros((ngs))\n\n l=lmr[i,0]\n m=lmr[i,1]\n r=lmr[i,2]\n zax = zaxis[i]\n xax = xaxis[i] \n\n r_rel = coords - R[i]\n radial = g_r_radial(r,zona[i],r_rel)\n ang = None\n if(l<0):\n if(l == -1):\n s = g_r_ang(0,1,r_rel,zax,xax)\n px = g_r_ang(1,2,r_rel,zax,xax)\n fac = 1.0/sqrt(2.0)\n if(m == 1):\n ang = fac*(s+px)\n elif(m == 2):\n ang = fac*(s-px)\n\n elif(l == -2):\n s = g_r_ang(0,1,r_rel,zax,xax)\n px = g_r_ang(1,2,r_rel,zax,xax)\n if(m == 1):\n py = g_r_ang(1,3,r_rel,zax,xax)\n ang = 1.0/sqrt(3.0)*s - 1.0/sqrt(6.0)*px + 1.0/sqrt(2.0)*py\n elif(m == 2):\n py = g_r_ang(1,3,r_rel,zax,xax)\n ang = 1.0/sqrt(3.0)*s - 1.0/sqrt(6.0)*px - 1.0/sqrt(2.0)*py\n elif(m == 3):\n ang = 1.0/sqrt(3.0)*s + 2.0/sqrt(6.0)*px\n\n elif(l == -3):\n s = g_r_ang(0,1,r_rel,zax,xax)\n px = g_r_ang(1,2,r_rel,zax,xax)\n py = g_r_ang(1,3,r_rel,zax,xax)\n pz = g_r_ang(1,1,r_rel,zax,xax)\n \n if(m == 1):\n ang = 0.5*(s+px+py+pz)\n elif(m == 2):\n ang = 0.5*(s+px-py-pz)\n elif(m == 3):\n ang = 0.5*(s-px+py-pz)\n elif(m == 4):\n ang = 0.5*(s-px-py+pz)\n\n else:\n raise Exception(\"NYI\")\n else:\n ang = g_r_ang(l,m,r_rel,zax,xax)\n\n g_r = radial * ang\n\n del radial, ang, r_rel\n return g_r\n\n\n\ndef comput_g_r(R,lmr,zaxis,xaxis,zona,nband,coords):\n\n ngs = len(coords)\n g_r = np.zeros((nband,ngs))\n \n for i in range(nband):\n l=lmr[i,0]\n m=lmr[i,1]\n r=lmr[i,2]\n zax = zaxis[i]\n xax = xaxis[i] \n\n r_rel = coords - R[i]\n radial = g_r_radial(r,zona[i],r_rel)\n ang = None\n if(l<0):\n if(l == -1):\n s = g_r_ang(0,1,r_rel,zax,xax)\n px = g_r_ang(1,2,r_rel,zax,xax)\n fac = 1.0/sqrt(2.0)\n if(m == 1):\n ang = fac*(s+px)\n elif(m == 2):\n ang = fac*(s-px)\n\n elif(l == -2):\n s = g_r_ang(0,1,r_rel,zax,xax)\n px = g_r_ang(1,2,r_rel,zax,xax)\n if(m == 1):\n py = g_r_ang(1,3,r_rel,zax,xax)\n ang = 1.0/sqrt(3.0)*s - 1.0/sqrt(6.0)*px + 1.0/sqrt(2.0)*py\n elif(m == 2):\n py = g_r_ang(1,3,r_rel,zax,xax)\n ang = 1.0/sqrt(3.0)*s - 1.0/sqrt(6.0)*px - 1.0/sqrt(2.0)*py\n elif(m == 3):\n ang = 1.0/sqrt(3.0)*s + 2.0/sqrt(6.0)*px\n\n elif(l == -3):\n s = g_r_ang(0,1,r_rel,zax,xax)\n px = g_r_ang(1,2,r_rel,zax,xax)\n py = g_r_ang(1,3,r_rel,zax,xax)\n pz = g_r_ang(1,1,r_rel,zax,xax)\n \n if(m == 1):\n ang = 0.5*(s+px+py+pz)\n elif(m == 2):\n ang = 0.5*(s+px-py-pz)\n elif(m == 3):\n ang = 0.5*(s-px+py-pz)\n elif(m == 4):\n ang = 0.5*(s-px-py+pz)\n\n else:\n raise Exception(\"NYI\")\n else:\n ang = g_r_ang(l,m,r_rel,zax,xax)\n\n g_r[i] = radial * ang\n\n return g_r\n\ndef g_r_ang(l,m,r_rel,zaxis,xaxis):\n\n ngs = len(r_rel)\n ang = np.zeros(ngs)\n if(l==0):\n ang[:] = 1.0/sqrt(4.0*np.pi)\n return ang\n\n yaxis = np.cross(zaxis,xaxis)\n yaxis = yaxis*(1.0/np.linalg.norm(yaxis))\n xy_perp = np.cross(xaxis,yaxis)\n\n if(l==1):\n fac = sqrt(0.75*np.pi)\n if(m==1):\n ang = fac*cos_theta(r_rel,zaxis)\n elif(m==2):\n ang = fac*sin_theta(r_rel,zaxis)*cos_phi(r_rel,xy_perp,xaxis,yaxis)\n elif(m==3):\n ang = fac*sin_theta(r_rel,zaxis)*sin_phi(r_rel,xy_perp,xaxis,yaxis)\n else:\n raise Exception(\"NYI\")\n\n return ang\n\ndef sin_phi(r_rel,xy_perp,xaxis,yaxis):\n\n return sin_cos_phi(r_rel,xy_perp,xaxis,yaxis)[0]\n\ndef cos_phi(r_rel,xy_perp,xaxis,yaxis):\n\n return sin_cos_phi(r_rel,xy_perp,xaxis,yaxis)[1]\n\ndef sin_cos_phi(r_rel,xy_perp,xaxis,yaxis):\n\n ngs = len(r_rel)\n sin_phi = np.zeros(ngs)\n cos_phi = np.zeros(ngs)\n x_norm = np.linalg.norm(xaxis)\n\n for i in range(ngs):\n r_proj_xy = np.cross(np.cross(xy_perp, r_rel[i]), xy_perp)\n dot = np.dot(r_proj_xy, xaxis)\n ab = np.linalg.norm(r_proj_xy) * x_norm\n if(ab == 0.0):\n cos_phi[i] = 0.0\n else:\n cos_phi[i] = dot/ab\n\n sin_phi[i] = sqrt(1.0-cos_phi[i]**2)\n dot = np.dot(r_proj_xy, yaxis)\n if(dot < 0.0):\n sin_phi[i] *= -1.0\n\n return(sin_phi, cos_phi)\n\n\ndef sin_theta(r_rel,zaxis):\n\n cos = cos_theta(r_rel,zaxis)\n sin_theta = np.sqrt(1.0-np.square(cos))\n del cos\n return sin_theta\n\ndef cos_theta(r_rel,zaxis):\n\n ngs = len(r_rel)\n cos_theta = np.zeros(ngs)\n z_norm = np.linalg.norm(zaxis)\n\n for i in range(ngs):\n dot = np.dot(r_rel[i],zaxis)\n ab = np.linalg.norm(r_rel[i]) * z_norm\n if(ab == 0.0):\n cos_theta[i] = 0.0\n else:\n cos_theta[i] = dot/ab\n\n return cos_theta\n\n\ndef g_r_radial(r,zona,r_rel):\n\n ngs = len(r_rel)\n radial = np.zeros(ngs)\n\n r_norm = np.zeros(ngs)\n for i in range(ngs):\n r_norm[i] = np.linalg.norm(r_rel[i])\n\n if(r==1):\n fac = 2.0*math.pow(zona, 1.5)\n radial = fac*np.exp(-1.0*zona*r_norm)\n elif(r==2):\n fac = 0.5/sqrt(2.0)*math.pow(zona, 1.5)\n radial = fac*(2.0-zona*r_norm)*np.exp(-0.5*zona*r_norm)\n elif(r==3):\n fac = sqrt(4.0/27.0)*math.pow(zona, 1.5)\n radial = fac*(1.0-2.0/3.0*zona*r_norm+2.0/27.0*zona**2*np.square(r_norm))*np.exp(-1.0/3.0*zona*r_norm)\n else:\n raise Exception(\"NYI\")\n\n del r_norm\n return radial\n\ndef comput_Amn(wf, Rc=None,lmr=None,zaxis=None,xaxis=None,zona=None, bands = None, nband = None, kpts = np.zeros((1,3)),max_memory=None):\n\n if Rc is None: Rc = wf.Rc\n if lmr is None: lmr = wf.lmr\n if zaxis is None: zaxis = wf.zaxis\n if xaxis is None: xaxis = wf.xaxis\n if zona is None: zona = wf.zona\n if bands is None: bands = wf.bands\n if nband is None: nband = wf.nband\n if max_memory is None: max_memory = wf.max_memory\n\n nk = len(kpts)\n mf = wf.mf\n mo_coeff = mf.mo_coeff\n\n cell = wf.cell\n mydf = mf.with_df\n gs = mydf.gs\n\n coords = cell.gen_uniform_grids(gs)\n ngs = len(coords)\n\n ni = mydf._numint\n\n weight = cell.vol / ngs\n\n aoR = ni.eval_ao(cell, coords, kpts, non0tab=None)\n\n a = cell.lattice_vectors()\n R = np.dot(Rc,a)\n #g_r = comput_g_r(R,lmr,zaxis,xaxis,zona,nband,coords)\n \n #parallel block \n g_r = np.ndarray((nband*ngs))\n\n from pyscf import lib\n max_mem = wf.max_memory - lib.current_memory()[0]\n print ('available mem (Mb) = ', max_mem)\n\n blk_size = min(ngs,(max_mem*1e6/8-nband*ngs*3)/12/16)\n nblks = ngs//blk_size\n if(nblks <= 1):\n nblks = lib.num_threads()\n blk_size = ngs//nblks\n #g_r_blks = np.concatenate(tuple[g_r_split[i] for i in range(nblks)],axis=0)\n\n\n libmisc.comput_g_r(ctypes.c_int(blk_size), ctypes.c_int(nblks), \\\n g_r.ctypes.data_as(ctypes.c_void_p), coords.ctypes.data_as(ctypes.c_void_p),ctypes.c_int(ngs), ctypes.c_int(nband), \\\n R.ctypes.data_as(ctypes.c_void_p),lmr.ctypes.data_as(ctypes.c_void_p), zaxis.ctypes.data_as(ctypes.c_void_p), \\\n xaxis.ctypes.data_as(ctypes.c_void_p),zona.ctypes.data_as(ctypes.c_void_p))\n\n\n g_r_split = np.split(g_r,[i*nband*blk_size for i in range(1,nblks)])\n for i in range(nblks):\n g_r_split[i] = np.reshape(g_r_split[i],(nband,-1))\n\n g_r = np.concatenate([g_r_split[i] for i in range(nblks)],axis=1)\n\n\n \n '''\n pool = Pool()\n results = [pool.apply_async(comput_g_r_para, (i, R,lmr,zaxis,xaxis,zona,coords,)) for i in range(nband) ]\n pool.close()\n pool.join()\n for i in range(nband):\n g_r[i] = results[i].get()\n '''\n '''\n #assume 8 proc\n blk_size = ngs//8\n tmp = np.split(coords,[blk_size,blk_size*2,blk_size*3,blk_size*4,blk_size*5,blk_size*6,blk_size*7])\n for i in range(nband):\n pool = Pool(8,maxtasksperchild=1)\n results = [pool.apply_async(comput_g_r_para, (i, R,lmr,zaxis,xaxis,zona,coords_blk,)) for blk,coords_blk in enumerate(tmp) ]\n pool.close()\n pool.join()\n for blk in range(8):\n index1 = blk*blk_size\n index2 = index1+blk_size\n if(blk == 7):\n index2 = ngs\n g_r[i][index1:index2] = results[blk].get()\n\n del tmp\n #end parallel block\n ''' \n\n print ('available mem (Mb) = ', wf.max_memory - lib.current_memory()[0])\n \n nao = cell.nao_nr()\n Amun = np.zeros((nk,nao,nband), dtype = np.complex128)\n Amn = np.zeros((nk,nband,nband), dtype = np.complex128)\n for k, aoR_k in enumerate(aoR):\n Amun[k] = weight * lib.dot(aoR_k.T.conj(), g_r.T)\n\n for k in range(nk):\n Amn[k] = lib.dot(mo_coeff[:,bands].T.conj(), Amun[k])\n\n return Amn\n\n\ndef wannier90_setup(wf, seedname=None, mp_grid_dim=None, num_kpts=None, real_lattice=None, recip_lattice=None, \\\n kpt_latt=None, num_bands_tot=None, num_atoms=None, atom_symbols=None, atoms_cart=None, \\\n gamma_only=None, spinors=False):\n\n if seedname is None: seedname = wf.seedname\n if mp_grid_dim is None: mp_grid_dim = wf.mp_grid_dim\n if num_kpts is None: num_kpts = wf.num_kpts\n if real_lattice is None: real_lattice = wf.real_lattice\n if recip_lattice is None: recip_lattice = wf.recip_lattice\n if kpt_latt is None: kpt_latt = wf.kpt_latt\n if num_bands_tot is None: num_bands_tot = wf.num_bands_tot\n if num_atoms is None: num_atoms = wf.num_atoms\n if atom_symbols is None: atom_symbols = wf.atom_symbols\n if atoms_cart is None: atoms_cart = wf.atoms_cart\n if gamma_only is None: gamma_only = wf.gamma_only\n\n real_lattice = real_lattice * param.BOHR #unit: Angstrom\n recip_lattice = recip_lattice / param.BOHR #unit: 1/Angstrom\n real_lattice_T = real_lattice.T\n recip_lattice_T = recip_lattice.T\n\n atoms_cart = atoms_cart * param.BOHR #unit: Angstrom\n\n #output\n nnlist = np.ndarray((num_kpts,num_nnmax), dtype = np.int32, order='F')\n nncell = np.ndarray((3,num_kpts,num_nnmax), dtype = np.int32, order='F')\n nntot = np.ndarray((1), dtype = np.int32)\n num_bands = np.ndarray((1), dtype = np.int32)\n num_wann = np.ndarray((1), dtype = np.int32)\n proj_site = np.ndarray((num_bands_tot,3))\n proj_l = np.ndarray((num_bands_tot), dtype = np.int32)\n proj_m = np.ndarray((num_bands_tot), dtype = np.int32)\n proj_radial = np.ndarray((num_bands_tot), dtype = np.int32)\n proj_z = np.ndarray((num_bands_tot,3))\n proj_x = np.ndarray((num_bands_tot,3))\n proj_zona = np.ndarray((num_bands_tot))\n exclude_bands = np.ndarray((num_bands_tot), dtype = np.int32)\n proj_s = np.ndarray((num_bands_tot), dtype = np.int32)\n proj_s_qaxis = np.ndarray((num_bands_tot,3))\n\n arr = (ctypes.c_char_p * num_atoms)()\n arr[:] = atom_symbols\n #fn_setup = getattr(lib_wannier90, 'wannier90_setup')\n lib_wannier90.wannier90_setup(ctypes.c_char_p(seedname), mp_grid_dim.ctypes.data_as(ctypes.c_void_p),ctypes.c_int(num_kpts), \\\n real_lattice_T.ctypes.data_as(ctypes.c_void_p),recip_lattice_T.ctypes.data_as(ctypes.c_void_p), \\\n kpt_latt.ctypes.data_as(ctypes.c_void_p), ctypes.c_int(num_bands_tot), \\\n ctypes.c_int(num_atoms), arr, atoms_cart.ctypes.data_as(ctypes.c_void_p), \\\n ctypes.c_int(gamma_only), ctypes.c_int(spinors), \\\n nntot.ctypes.data_as(ctypes.c_void_p),nnlist.ctypes.data_as(ctypes.c_void_p),\\\n nncell.ctypes.data_as(ctypes.c_void_p),num_bands.ctypes.data_as(ctypes.c_void_p),num_wann.ctypes.data_as(ctypes.c_void_p), \\\n proj_site.ctypes.data_as(ctypes.c_void_p),proj_l.ctypes.data_as(ctypes.c_void_p),proj_m.ctypes.data_as(ctypes.c_void_p), \\\n proj_radial.ctypes.data_as(ctypes.c_void_p), proj_z.ctypes.data_as(ctypes.c_void_p), \\\n proj_x.ctypes.data_as(ctypes.c_void_p),proj_zona.ctypes.data_as(ctypes.c_void_p), \\\n exclude_bands.ctypes.data_as(ctypes.c_void_p),proj_s.ctypes.data_as(ctypes.c_void_p), \\\n proj_s_qaxis.ctypes.data_as(ctypes.c_void_p))\n\n nntot = nntot[0]\n num_bands = num_bands[0]\n num_wann = num_wann[0]\n\n proj_zona *= param.BOHR\n\n return (nnlist,nncell,nntot,num_bands,num_wann,\\\n proj_site,proj_l,proj_m,proj_radial,\\\n proj_z,proj_x,proj_zona,exclude_bands,\\\n proj_s,proj_s_qaxis)\n\n\ndef wannier90_run(wf, Mmn=None, Amn=None, eigenvalues=None, \\\n seedname=None, mp_grid_dim=None, num_kpts=None, real_lattice=None, recip_lattice=None, \\\n kpt_latt=None, num_bands=None,num_wann=None,nntot=None,num_atoms=None, atom_symbols=None, atoms_cart=None, \\\n gamma_only=None):\n\n if Mmn is None: Mmn = wf.Mmn\n if Amn is None: Amn = wf.Amn\n if eigenvalues is None: eigenvalues = wf.eig\n\n if seedname is None: seedname = wf.seedname\n if mp_grid_dim is None: mp_grid_dim = wf.mp_grid_dim\n if num_kpts is None: num_kpts = wf.num_kpts\n if real_lattice is None: real_lattice = wf.real_lattice\n if recip_lattice is None: recip_lattice = wf.recip_lattice\n if kpt_latt is None: kpt_latt = wf.kpt_latt\n if num_bands is None: num_bands = wf.num_bands\n if num_wann is None: num_wann = wf.num_wann\n if nntot is None: nntot = wf.nntot\n if num_atoms is None: num_atoms = wf.num_atoms\n if atom_symbols is None: atom_symbols = wf.atom_symbols\n if atoms_cart is None: atoms_cart = wf.atoms_cart\n if gamma_only is None: gamma_only = wf.gamma_only\n\n real_lattice = real_lattice * param.BOHR #unit: Angstrom\n recip_lattice = recip_lattice / param.BOHR #unit: 1/Angstrom\n real_lattice_T = real_lattice.T\n recip_lattice_T = recip_lattice.T\n\n atoms_cart = atoms_cart * param.BOHR #unit: Angstrom\n\n arr = (ctypes.c_char_p * num_atoms)()\n arr[:] = atom_symbols\n\n M_matrix = np.zeros((num_kpts, nntot, num_bands, num_bands), dtype=np.complex128)\n for k in range(num_kpts):\n for i in range(nntot):\n M_matrix[k,i] = Mmn[k,i].T\n\n A_matrix = np.zeros((num_kpts,num_wann,num_bands),dtype=np.complex128)\n for k in range(num_kpts):\n A_matrix[k] = Amn[k].T\n\n\n #output\n U_matrix = np.ndarray((num_kpts,num_wann,num_wann), dtype = np.complex128)\n U_matrix_opt = np.ndarray((num_kpts,num_wann,num_bands), dtype = np.complex128)\n lwindow = np.ndarray((num_kpts,num_bands), dtype=np.int32)\n wann_centres = np.ndarray((num_wann,3))\n wann_spreads = np.ndarray((num_wann))\n spread = np.ndarray((3))\n\n lib_wannier90.wannier90_run(ctypes.c_char_p(seedname),mp_grid_dim.ctypes.data_as(ctypes.c_void_p),ctypes.c_int(num_kpts), \\\n real_lattice_T.ctypes.data_as(ctypes.c_void_p),recip_lattice_T.ctypes.data_as(ctypes.c_void_p), \\\n kpt_latt.ctypes.data_as(ctypes.c_void_p), ctypes.c_int(num_bands), ctypes.c_int(num_wann), \\\n ctypes.c_int(nntot),ctypes.c_int(num_atoms), \\\n arr,atoms_cart.ctypes.data_as(ctypes.c_void_p),\\\n ctypes.c_int(gamma_only),\\\n M_matrix.ctypes.data_as(ctypes.c_void_p),A_matrix.ctypes.data_as(ctypes.c_void_p),\\\n eigenvalues.ctypes.data_as(ctypes.c_void_p),\\\n U_matrix.ctypes.data_as(ctypes.c_void_p),U_matrix_opt.ctypes.data_as(ctypes.c_void_p),\\\n lwindow.ctypes.data_as(ctypes.c_void_p),wann_centres.ctypes.data_as(ctypes.c_void_p),\\\n wann_spreads.ctypes.data_as(ctypes.c_void_p),spread.ctypes.data_as(ctypes.c_void_p))\n for k in range(num_kpts):\n U_matrix[k] = U_matrix[k].T\n\n #print U_matrix\n\n return U_matrix\n\nclass wannier2:\n\n def __init__(self, the_mf, mp_grid_dim, seedname, bands=None, plot=False, reorder=False, max_memory=None):\n\n self.mp_grid_dim = np.asarray(mp_grid_dim, dtype=np.int32)\n self.num_kpts = mp_grid_dim[0]*mp_grid_dim[1]*mp_grid_dim[2]\n\n self.seedname = seedname\n self.plot = plot\n self.reorder = reorder\n\n self.mf = the_mf\n self.cell = self.mf.cell\n self.real_lattice = self.cell.lattice_vectors()\n self.recip_lattice = self.cell.reciprocal_vectors()\n \n self.max_memory = max_memory\n if self.max_memory is None: self.max_memory = self.cell.max_memory\n\n self.num_bands_tot = self.cell.nao_nr() \n self.bands = bands\n if self.bands is None: self.bands = np.arange(self.num_bands_tot)\n\n self.num_atoms = self.cell.natm\n self.atom_symbols = [x[0] for x in self.cell._atom]\n self.atoms_cart = np.asarray([x[1] for x in self.cell._atom])\n\n self.kpts = None\n if isinstance(self.mf, pbc.scf.khf.KSCF) : self.kpts = self.mf.kpts\n elif isinstance(self.mf, pbc.scf.hf.SCF) : self.kpts = self.mf.kpt\n self.kpts = self.kpts.reshape((-1,3))\n self.kpt_latt = self.cell.get_scaled_kpts(self.kpts)\n\n assert(len(self.kpt_latt) == self.num_kpts)\n\n self.gamma_only = False\n if gamma_point(self.kpts) : self.gamma_only = True\n\n eig = self.mf.mo_energy\n eig *= param.HARTREE2EV #in eV\n self.eig = eig.reshape((-1,self.num_bands_tot))\n\n self.nnlist,self.nncell,self.nntot,self.num_bands,self.num_wann,\\\n self.proj_site,self.proj_l,self.proj_m,self.proj_radial,\\\n self.proj_z,self.proj_x,self.proj_zona,self.exclude_bands,\\\n self.proj_s,self.proj_s_qaxis = self.wannier90_setup()\n\n #print self.proj_site\n #print self.proj_l\n #print self.proj_m\n #print self.proj_radial\n\n def kernel(self):\n\n nnkpts = get_nnkpts(self.nntot, self.nnlist, self.nncell)\n self.bpts = get_bpts(self, nnkpts, self.kpts)\n\n if(self.plot):\n write_bloch_u_r(self, self.bands, self.num_bands_tot, self.kpts)\n\n t0 = (time.clock(),time.time())\n self.Mmn = comput_Mmn(self, self.bands, self.num_bands, self.bpts, self.kpts)\n #write_Mmn(self, self.seedname+'.mmn', self.num_kpts, self.num_bands, self.Mmn, nnkpts)\n t1 = tools.timer(\"Mmn\",t0)\n\n self.lmr = np.column_stack((self.proj_l,self.proj_m,self.proj_radial))\n\n t0 = (time.clock(),time.time()) \n self.Amn = comput_Amn(self, self.proj_site, self.lmr, self.proj_z, self.proj_x, self.proj_zona, self.bands, self.num_bands, self.kpts)\n t1 = tools.timer(\"Amn\",t0)\n\n u_mat = self.wannier90_run()\n self.u_mat = u_mat\n if (self.reorder):\n seq = self.assign_wf2atm()\n self.u_mat = u_mat[:,:,seq]\n\n #calc_iso_cutoff(self, self.u_mat, self.bands, self.num_bands, self.kpts)\n\n wannier90_setup = wannier90_setup\n wannier90_run = wannier90_run\n assign_wf2atm = assign_wf2atm\n\nclass wannier:\n\n def __init__(self, the_mf, nnkpts, seedname,bands, has_proj_data=False, kpts = np.zeros((1,3))):\n\n self.mf = the_mf\n self.cell = self.mf.cell\n self.nnkpts = nnkpts\n self.bands = bands\n self.nband = len(self.bands)\n self.kpts = kpts\n self.file_mmn = seedname+'.mmn'\n self.file_amn = seedname+'.amn'\n self.file_ene = seedname+'.eig'\n\n self.bpts = self.get_bpts()\n self.Mmn = self.comput_Mmn()\n self.write_Mmn(self.file_mmn, len(self.kpts))\n self.write_bloch_u_r()\n self.write_eig(self.file_ene)\n\n self.Rc = None \n self.lmr = None\n self.zaxis = None\n self.xaxis = None\n self.zona = None\n self.Amn = None\n if(has_proj_data):\n self.file_proj_data = seedname+'.proj'\n self.Rc,self.lmr,self.zaxis,self.xaxis,self.zona = read_proj_data(self.file_proj_data)\n self.Amn = self.comput_Amn()\n self.write_Amn(self.file_amn, len(self.kpts))\n\n get_bpts = get_bpts\n comput_Mmn = comput_Mmn\n write_Mmn = write_Mmn\n comput_Amn = comput_Amn\n write_Amn = write_Amn\n write_bloch_u_r = write_bloch_u_r\n write_eig = write_eig\n", "meta": {"hexsha": "a7ef25932b00902eb92ced439df3b4a1ac627178", "size": 31087, "ext": "py", "lang": "Python", "max_stars_repo_path": "pydmfet/locints/mmn_wannier90.py", "max_stars_repo_name": "fishjojo/pydmfe", "max_stars_repo_head_hexsha": "93cfc655314933d3531b5733521a1f95a044f6cb", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-02-26T06:26:00.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-20T08:58:20.000Z", "max_issues_repo_path": "pydmfet/locints/mmn_wannier90.py", "max_issues_repo_name": "fishjojo/pydmfet", "max_issues_repo_head_hexsha": "93cfc655314933d3531b5733521a1f95a044f6cb", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pydmfet/locints/mmn_wannier90.py", "max_forks_repo_name": "fishjojo/pydmfet", "max_forks_repo_head_hexsha": "93cfc655314933d3531b5733521a1f95a044f6cb", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.5859538784, "max_line_length": 142, "alphanum_fraction": 0.5735516454, "include": true, "reason": "import numpy", "num_tokens": 9788, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5039061705290806, "lm_q2_score": 0.38121956625614994, "lm_q1q2_score": 0.19209889176289363}} {"text": "# SPDX-License-Identifier: Apache-2.0\n# SPDX-FileCopyrightText: © 2019- d3p Developers and their Assignees\n\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n\n# http://www.apache.org/licenses/LICENSE-2.0\n\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\"\"\" Stochastic Variational Inference implementation with per-example gradient\n manipulation capability.\n\"\"\"\nimport functools\nfrom typing import Any, NamedTuple, Sequence, Tuple\n\nimport jax\nimport jax.numpy as jnp\nimport numpy as np\n\nfrom numpyro.infer.svi import SVI, SVIState\nfrom numpyro.infer.elbo import ELBO\nfrom numpyro.handlers import seed, trace, substitute, block\n\nfrom d3p.util import example_count\nimport d3p.random as strong_rng\n\nfrom fourier_accountant.compute_eps import get_epsilon_R\nfrom fourier_accountant.compute_delta import get_delta_R\n\nPRNGState = Any\n\n\nclass DPSVIState(NamedTuple):\n optim_state: Any\n rng_key: PRNGState\n observation_scale: float\n\n\ndef get_observations_scale(model, model_args, model_kwargs, params):\n \"\"\"\n Traces through a model to extract the scale applied to observation log-likelihood.\n \"\"\"\n\n # todo(lumip): is there a way to avoid tracing through the entire model?\n # need to experiment with effect handlers and what exactly blocking achieves\n model = substitute(seed(model, 0), data=params)\n model = block(model, lambda msg: msg['type'] != 'sample' or not msg['is_observed'])\n model_trace = trace(model).get_trace(*model_args, **model_kwargs)\n scales = np.unique(\n [msg['scale'] if msg['scale'] is not None else 1 for msg in model_trace.values()]\n )\n\n if len(scales) > 1:\n raise ValueError(\n \"The model received several observation sites with different example counts.\"\n \" This is not supported in DPSVI.\"\n )\n elif len(scales) == 0:\n return 1.\n\n return scales[0]\n\n\nclass CombinedLoss(object):\n\n def __init__(self, per_example_loss: ELBO, combiner_fn=jnp.mean):\n self.px_loss = per_example_loss\n self.combiner_fn = combiner_fn\n\n def loss(self, rng_key, param_map, model, guide, *args, **kwargs):\n return self.combiner_fn(self.px_loss.loss(\n rng_key, param_map, model, guide, *args, **kwargs\n ))\n\n\ndef full_norm(list_of_parts_or_tree, ord=2):\n \"\"\"Computes the total norm over a list of values (of any shape) or a jax\n tree by treating them as a single large vector.\n\n :param list_of_parts_or_tree: The list or jax tree of values that make up\n the vector to compute the norm over.\n :param ord: Order of the norm. May take any value possible for\n `numpy.linalg.norm`.\n :return: The indicated norm over the full vector.\n \"\"\"\n if isinstance(list_of_parts_or_tree, list):\n list_of_parts = list_of_parts_or_tree\n else:\n list_of_parts = jax.tree_leaves(list_of_parts_or_tree)\n\n if list_of_parts is None or len(list_of_parts) == 0:\n return 0.\n\n ravelled = [g.ravel() for g in list_of_parts]\n gradients = jnp.concatenate(ravelled)\n assert(len(gradients.shape) == 1)\n norm = jnp.linalg.norm(gradients, ord=ord)\n return norm\n\n\ndef normalize_gradient(list_of_gradient_parts, ord=2):\n \"\"\"Normalizes a gradient by its total norm.\n\n The norm is computed by interpreting the given list of parts as a single\n vector (see `full_norm`).\n\n :param list_of_gradient_parts: A list of values (of any shape) that make up\n the overall gradient vector.\n :return: Normalized gradients given in the same format/layout/shape as\n list_of_gradient_parts.\n \"\"\"\n norm_inv = 1./full_norm(list_of_gradient_parts, ord=ord)\n normalized = [norm_inv * g for g in list_of_gradient_parts]\n return normalized\n\n\ndef clip_gradient(list_of_gradient_parts, c, rescale_factor=1.):\n \"\"\"Clips the total norm of a gradient by a given value C.\n\n The norm is computed by interpreting the given list of parts as a single\n vector (see `full_norm`). Each entry is then scaled by the factor\n (1/max(1, norm/C)) which effectively clips the norm to C. Additionally,\n the gradient can be scaled by a given factor before clipping.\n\n :param list_of_gradient_parts: A list of values (of any shape) that make up\n the overall gradient vector.\n :param c: The clipping threshold C.\n :param rescale_factor: Factor to scale the gradient by before clipping.\n :return: Clipped gradients given in the same format/layout/shape as\n list_of_gradient_parts.\n \"\"\"\n if c == 0.:\n raise ValueError(\"The clipping threshold must be greater than 0.\")\n norm = full_norm(list_of_gradient_parts) * rescale_factor # norm of rescale_factor * grad\n normalization_constant = 1./jnp.maximum(1., norm/c)\n f = rescale_factor * normalization_constant # to scale grad to max(rescale_factor * grad, C)\n clipped_grads = [f * g for g in list_of_gradient_parts]\n return clipped_grads\n\n\ndef get_gradients_clipping_function(c, rescale_factor):\n \"\"\"Factory function to obtain a gradient clipping function for a fixed\n clipping threshold C.\n\n :param c: The clipping threshold C.\n :param rescale_factor: Factor to scale the gradient by before clipping.\n :return: `clip_gradient` function with fixed threshold C. Only takes a\n list_of_gradient_parts as argument.\n \"\"\"\n @functools.wraps(clip_gradient)\n def gradient_clipping_fn_inner(list_of_gradient_parts):\n return clip_gradient(list_of_gradient_parts, c, rescale_factor)\n return gradient_clipping_fn_inner\n\n\nclass DPSVI(SVI):\n \"\"\"\n Differentially-Private Stochastic Variational Inference given a per-example\n loss objective and a gradient clipping threshold.\n\n This is identical to numpyro's `SVI` but adds differential privacy by\n clipping gradients per example to the given clipping_threshold and\n perturbing the batch gradient with noise determined by sigma*clipping_threshold.\n\n To obtain the per-example gradients, the `per_example_loss_fn` is evaluated\n for (and the gradient take wrt) each example in a vectorized manner (using\n `jax.vmap`).\n\n For this to work `per_example_loss_fn` must be able to deal with batches\n of single examples. The leading batch dimension WILL NOT be stripped away,\n however, so a `per_example_loss_fn` that can deal with arbitrarily sized batches\n suffices. Take special care that the loss function scales the likelihood\n contribution of the data properly wrt to batch size and total example count\n (use e.g. the `numpyro.scale` or the convenience `minibatch` context managers\n in the `model` and `guide` functions where appropriate).\n\n :param model: Python callable with Pyro primitives for the model.\n :param guide: Python callable with Pyro primitives for the guide\n (recognition network).\n :param per_example_loss_fn: ELBo loss, i.e. negative Evidence Lower Bound,\n to minimize, per example.\n :param optim: an instance of :class:`~numpyro.optim._NumPyroOptim`.\n :param clipping_threshold: The clipping threshold C to which the norm\n of each per-example gradient is clipped.\n :param dp_scale: Scale parameter for the Gaussian mechanism applied to\n each dimension of the batch gradients.\n :param static_kwargs: static arguments for the model / guide, i.e. arguments\n that remain constant during fitting.\n \"\"\"\n\n def __init__(\n self,\n model,\n guide,\n optim,\n per_example_loss,\n clipping_threshold,\n dp_scale,\n rng_suite=strong_rng,\n **static_kwargs\n ): # noqa: E121, E125\n\n self._clipping_threshold = clipping_threshold\n self._dp_scale = dp_scale\n self._rng_suite = rng_suite\n\n if (not np.isfinite(clipping_threshold)):\n raise ValueError(\"clipping_threshold must be finite!\")\n\n total_loss = CombinedLoss(per_example_loss, combiner_fn=jnp.mean)\n super().__init__(model, guide, optim, total_loss, **static_kwargs)\n\n @staticmethod\n def _update_state_rng(dp_svi_state: DPSVIState, rng_key: PRNGState) -> DPSVIState:\n return DPSVIState(\n dp_svi_state.optim_state,\n rng_key,\n dp_svi_state.observation_scale\n )\n\n @staticmethod\n def _update_state_optim_state(dp_svi_state: DPSVIState, optim_state: Any) -> DPSVIState:\n return DPSVIState(\n optim_state,\n dp_svi_state.rng_key,\n dp_svi_state.observation_scale\n )\n\n def _split_rng_key(self, dp_svi_state: DPSVIState) -> Tuple[DPSVIState, PRNGState]:\n rng_key = dp_svi_state.rng_key\n rng_key, split_key = self._rng_suite.split(rng_key)\n return DPSVI._update_state_rng(dp_svi_state, rng_key), split_key\n\n def init(self, rng_key, *args, **kwargs):\n jax_rng_key = self._rng_suite.convert_to_jax_rng_key(rng_key)\n svi_state = super().init(jax_rng_key, *args, **kwargs)\n\n if svi_state.mutable_state is not None:\n raise RuntimeError(\"Mutable state is not supported.\")\n\n model_kwargs = dict(kwargs)\n model_kwargs.update(self.static_kwargs)\n\n one_element_batch = [\n jnp.expand_dims(a[0], 0) for a in args\n ]\n\n # note: DO use super().get_params here to get constrained/transformed params\n # for use in get_observations_scale (svi_state.optim_state holds unconstrained params)\n params = super().get_params(svi_state)\n observation_scale = get_observations_scale(\n self.model, one_element_batch, model_kwargs, params\n )\n\n return DPSVIState(svi_state.optim_state, rng_key, observation_scale)\n\n def _compute_per_example_gradients(self, dp_svi_state, *args, **kwargs):\n \"\"\" Computes the raw per-example gradients of the model.\n\n This is the first step in a full update iteration.\n\n :param dp_svi_state: The current state of the DPSVI algorithm.\n :param args: Arguments to the loss function.\n :param kwargs: All keyword arguments to model or guide.\n :returns: tuple consisting of the updated DPSVI state, an array of loss\n values per example, and a jax tuple tree of per-example gradients\n per parameter site (each site's gradients have shape (batch_size, *parameter_shape))\n \"\"\"\n dp_svi_state, rng_key_step = self._split_rng_key(dp_svi_state)\n jax_rng_key = self._rng_suite.convert_to_jax_rng_key(rng_key_step)\n\n # note: do NOT use self.get_params here; that applies constraint transforms for end-consumers of the parameters\n # but internally we maintain and optimize on unconstrained params\n # (they are constrained in the loss function so that we get the correct\n # effect of the constraint transformation in the gradient)\n params = self.optim.get_params(dp_svi_state.optim_state)\n\n # we wrap the per-example loss (ELBO) to make it easier \"digestable\"\n # for jax.vmap(jax.value_and_grad()): slighly reordering parameters; fixing kwargs, model and guide\n def wrapped_px_loss(prms, rng_key, loss_args):\n # vmap removes leading dimensions, we re-add those in a wrapper for fun so\n # that fun can be oblivious of this\n new_args = (jnp.expand_dims(arg, 0) for arg in loss_args)\n return self.loss.px_loss.loss(\n rng_key, self.constrain_fn(prms), self.model, self.guide,\n *new_args, **kwargs, **self.static_kwargs\n )\n\n batch_size = jnp.shape(args[0])[0] # todo: need checks to ensure this indexing is okay\n px_rng_keys = jax.random.split(jax_rng_key, batch_size)\n\n px_value_and_grad = jax.vmap(jax.value_and_grad(wrapped_px_loss), in_axes=(None, 0, 0))\n per_example_loss, per_example_grads = px_value_and_grad(params, px_rng_keys, args)\n\n return dp_svi_state, per_example_loss, per_example_grads\n\n def _clip_gradients(self, dp_svi_state, px_gradients):\n \"\"\" Clips each per-example gradient.\n\n This is the second step in a full update iteration.\n\n :param dp_svi_state: The current state of the DPSVI algorithm.\n :param px_gradients: Jax tuple tree of per-example gradients as returned\n by `_compute_per_example_gradients`\n :returns: tuple consisting of the updated svi state, a list of\n transformed per-example gradients per site and the jax tree structure\n definition. The list is a flattened representation of the jax tree,\n the shape of per-example gradients per parameter is unaffected.\n \"\"\"\n obs_scale = dp_svi_state.observation_scale\n\n # px_gradients is a jax tree of jax jnp.arrays of shape\n # [batch_size, (param_shape)] for each parameter. flatten it out!\n px_grads_list, px_grads_tree_def = jax.tree_flatten(\n px_gradients\n )\n\n # scale the gradients by 1/obs_scale then clip them:\n # in the loss, every single examples loss contribution is scaled by obs_scale\n # but the clipping threshold assumes no scaling.\n # we scale by the reciprocal to ensure that clipping is correct.\n clip_fn = get_gradients_clipping_function(self._clipping_threshold, 1./obs_scale)\n px_grads_list = jax.vmap(clip_fn, in_axes=0)(px_grads_list)\n\n return dp_svi_state, px_grads_list, px_grads_tree_def\n\n def _combine_gradients(self, px_grads_list, px_loss):\n \"\"\" Combines the per-example gradients into the batch gradient and\n applies the batch gradient transformation given as\n `batch_grad_manipulation_fn`.\n\n This is the third step of a full update iteration.\n\n :param px_grads_list: List of transformed per-example gradients as returned\n by `_apply_per_example_gradient_transformations`\n :param px_loss: Array of per-example loss values as output by\n `_compute_per_example_gradients`.\n :returns: tuple consisting of the updated svi state, the loss value for\n the batch and a jax tree of batch gradients per parameter site.\n \"\"\"\n\n assert(self.loss.combiner_fn == jnp.mean)\n\n loss_val = jnp.mean(px_loss, axis=0)\n grads_list = tuple(map(lambda px_grad_site: jnp.mean(px_grad_site, axis=0), px_grads_list))\n\n return loss_val, grads_list\n\n def _perturb_and_reassemble_gradients(self, dp_svi_state, gradient_list, batch_size, px_grads_tree_def):\n \"\"\" Perturbs the gradients using Gaussian noise and reassembles the gradient tree.\n\n This is the fourth step of a full update iteration.\n\n :param dp_svi_state: The current state of the DPSVI algorithm.\n :param gradient_list: List of batch gradients for each parameter site\n :param batch_size: Size of the training batch.\n :param px_grads_tree_def: Jax tree definition for the gradient tree as\n returned by `_apply_per_example_gradient_transformations`.\n \"\"\"\n dp_svi_state, perturbation_rng = self._split_rng_key(dp_svi_state)\n\n perturbation_scale = self._dp_scale * self._clipping_threshold / batch_size\n perturbed_grads_list = self.perturbation_function(\n self._rng_suite, perturbation_rng, gradient_list, perturbation_scale\n )\n\n # we multiply each parameter site by obs_scale to revert the downscaling\n # performed before clipping, so that the final gradient is scaled as\n # expected without DP\n obs_scale = dp_svi_state.observation_scale\n perturbed_grads_list = tuple(\n grad * obs_scale\n for grad in perturbed_grads_list\n )\n\n # reassemble the jax tree used by optimizer for the final gradients\n perturbed_grads = jax.tree_unflatten(\n px_grads_tree_def, perturbed_grads_list\n )\n\n return dp_svi_state, perturbed_grads\n\n def _apply_gradient(self, dp_svi_state, batch_gradient):\n \"\"\" Takes a (batch) gradient step in parameter space using the specified\n optimizer.\n\n This is the fifth and last step of a full update iteration.\n :param dp_svi_state: The current state of the DPSVI algorithm.\n :param batch_gradient: Jax tree of batch gradients per parameter site,\n as returned by `_combine_and_transform_gradient`.\n :returns: tuple consisting of the updated svi state.\n \"\"\"\n optim_state = dp_svi_state.optim_state\n new_optim_state = self.optim.update(batch_gradient, optim_state)\n\n dp_svi_state = self._update_state_optim_state(dp_svi_state, new_optim_state)\n return dp_svi_state\n\n def update(self, svi_state, *args, **kwargs):\n svi_state, per_example_loss, per_example_grads = \\\n self._compute_per_example_gradients(svi_state, *args, **kwargs)\n\n batch_size = example_count(per_example_loss)\n\n svi_state, per_example_grads, tree_def = \\\n self._clip_gradients(\n svi_state, per_example_grads\n )\n\n loss, gradient = self._combine_gradients(\n per_example_grads, per_example_loss\n )\n\n svi_state, gradient = self._perturb_and_reassemble_gradients(\n svi_state, gradient, batch_size, tree_def\n )\n\n svi_state = self._apply_gradient(svi_state, gradient)\n\n return svi_state, loss\n\n def evaluate(self, svi_state: DPSVIState, *args, **kwargs):\n \"\"\"\n Take a single step of SVI (possibly on a batch / minibatch of data).\n\n :param svi_state: current state of DPSVI.\n :param args: arguments to the model / guide (these can possibly vary during\n the course of fitting).\n :param kwargs: keyword arguments to the model / guide.\n :return: evaluate ELBO loss given the current parameter values\n (held within `svi_state.optim_state`).\n \"\"\"\n # we split to have the same seed as `update_fn` given an svi_state\n jax_rng_key = self._rng_suite.convert_to_jax_rng_key(self._rng_suite.split(svi_state.rng_key, 1)[0])\n numpyro_svi_state = SVIState(svi_state.optim_state, None, jax_rng_key)\n return super().evaluate(numpyro_svi_state, *args, **kwargs)\n\n def _validate_epochs_and_iter(self, num_epochs, num_iter, q):\n if num_epochs is not None:\n num_iter = num_epochs / q\n if num_iter is None:\n raise ValueError(\"A value must be supplied for either num_iter or num_epochs\")\n return num_iter\n\n def get_epsilon(self, target_delta, q, num_epochs=None, num_iter=None):\n num_iter = self._validate_epochs_and_iter(num_epochs, num_iter, q)\n\n eps = get_epsilon_R(target_delta, self._dp_scale, q, ncomp=num_iter)\n return eps\n\n def get_delta(self, target_epsilon, q, num_epochs=None, num_iter=None):\n num_iter = self._validate_epochs_and_iter(num_epochs, num_iter, q)\n\n eps = get_delta_R(target_epsilon, self._dp_scale, q, ncomp=num_iter)\n return eps\n\n @staticmethod\n def perturbation_function(\n rng_suite, rng: PRNGState, values: Sequence[jnp.ndarray], perturbation_scale: float\n ) -> Sequence[jnp.ndarray]: # noqa: E121, E125\n \"\"\" Perturbs given values using Gaussian noise.\n\n `values` can be a list of array-like objects. Each value is independently\n perturbed by adding noise sampled from a Gaussian distribution with a\n standard deviation of `perturbation_scale`.\n\n :param rng: Jax PRNGKey for perturbation randomness.\n :param values: Iterable of array-like where each value will be perturbed.\n :param perturbation_scale: The scale/standard deviation of the noise\n distribution.\n \"\"\"\n def perturb_one(a: jnp.ndarray, site_rng: PRNGState) -> jnp.ndarray:\n \"\"\" perturbs a single gradient site \"\"\"\n noise = rng_suite.normal(site_rng, a.shape) * perturbation_scale\n return a + noise\n\n per_site_rngs = rng_suite.split(rng, len(values))\n values = tuple(\n perturb_one(grad, site_rng)\n for grad, site_rng in zip(values, per_site_rngs)\n )\n return values\n", "meta": {"hexsha": "2cb9b8c9c90236d57c3fe649c3da497bf3ab66a2", "size": 20627, "ext": "py", "lang": "Python", "max_stars_repo_path": "d3p/svi.py", "max_stars_repo_name": "DPBayes/d3p", "max_stars_repo_head_hexsha": "af3ba4eb5243494bd5e223c60e81f32a8dca1eab", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2021-05-07T06:42:47.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-10T13:19:54.000Z", "max_issues_repo_path": "d3p/svi.py", "max_issues_repo_name": "DPBayes/d3p", "max_issues_repo_head_hexsha": "af3ba4eb5243494bd5e223c60e81f32a8dca1eab", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "d3p/svi.py", "max_forks_repo_name": "DPBayes/d3p", "max_forks_repo_head_hexsha": "af3ba4eb5243494bd5e223c60e81f32a8dca1eab", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-03-26T04:32:17.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-09T16:30:05.000Z", "avg_line_length": 42.18200409, "max_line_length": 119, "alphanum_fraction": 0.6955446745, "include": true, "reason": "import numpy,from numpy,import jax", "num_tokens": 4745, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5039061705290805, "lm_q2_score": 0.38121955219593834, "lm_q1q2_score": 0.1920988846778662}} {"text": "##############################################\n# This code is based on samples from pytorch #\n##############################################\n# Writer: Kimin Lee \n\nfrom __future__ import print_function\nimport argparse\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.optim as optim\nimport data_loader\nimport numpy as np\nimport torchvision.utils as vutils\nimport models\nfrom torchvision import datasets, transforms\nfrom torch.autograd import Variable\n\nimport os\n\nos.environ[\"CUDA_DEVICE_ORDER\"] = \"PCI_BUS_ID\" # see issue #152\nos.environ[\"CUDA_VISIBLE_DEVICES\"] = \"5\"\n\n# Training settings\nparser = argparse.ArgumentParser(description='Training code - joint confidence')\nparser.add_argument('--batch-size', type=int, default=128, help='input batch size for training')\nparser.add_argument('--epochs', type=int, default=100, help='number of epochs to train')\nparser.add_argument('--lr', type=float, default=0.0002, help='learning rate')\nparser.add_argument('--no-cuda', action='store_true', default=False, help='disables CUDA training')\nparser.add_argument('--seed', type=int, default=1, help='random seed')\nparser.add_argument('--log-interval', type=int, default=100,\n help='how many batches to wait before logging training status')\nparser.add_argument('--nz', type=int, default=100, help='size of the latent z vector')\nparser.add_argument('--ngf', type=int, default=180)\nparser.add_argument('--ndf', type=int, default=80)\nparser.add_argument('--beta1', type=float, default=0.5, help='beta1 for adam. default=0.5')\nparser.add_argument('--netG', default='', help=\"path to netG (to continue training)\")\nparser.add_argument('--netD', default='', help=\"path to netD (to continue training)\")\n\nparser.add_argument('--dataset', default='svhn', help='cifar10 | svhn')\nparser.add_argument('--dataroot', required=True, help='path to dataset')\nparser.add_argument('--imageSize', type=int, default=32, help='the height / width of the input image to network')\nparser.add_argument('--outf', default='.', help='folder to output images and model checkpoints')\nparser.add_argument('--wd', type=float, default=0.0, help='weight decay')\nparser.add_argument('--droprate', type=float, default=0.1, help='learning rate decay')\nparser.add_argument('--decreasing_lr', default='60', help='decreasing strategy')\nparser.add_argument('--num_classes', type=int, default=10, help='the # of classes')\nparser.add_argument('--beta', type=float, default=1, help='penalty parameter for KL term')\n\nargs = parser.parse_args()\n\nif args.dataset == 'cifar10':\n args.beta = 0.1\n args.batch_size = 64\n\nprint(args)\nargs.cuda = not args.no_cuda and torch.cuda.is_available()\nprint(\"Random Seed: \", args.seed)\ntorch.manual_seed(args.seed)\n\nif args.cuda:\n torch.cuda.manual_seed(args.seed)\n\nkwargs = {'num_workers': 1, 'pin_memory': True} if args.cuda else {}\n\nprint('load data: ', args.dataset)\nif args.dataset=='mnist':\n transform = transforms.Compose([\n transforms.Scale(32),\n transforms.ToTensor(),\n transforms.Lambda(lambda x: x.repeat(3, 1, 1)),\n transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))\n ])\n train_loader = torch.utils.data.DataLoader(\n datasets.MNIST('data', train=True, download=True, transform=transform),\n batch_size=128, shuffle=True)\n test_loader = None\nelse:\n train_loader, test_loader = data_loader.getTargetDataSet(args.dataset, args.batch_size, args.imageSize, args.dataroot)\n\n\n\nprint('Load model')\nmodel = models.vgg13()\nprint(model)\n\nprint('load GAN')\n\n\nnz = int(args.nz)\nngf = int(args.ngf)\nndf = int(args.ndf)\nif args.dataset == 'mnist':\n #nc = 1\n nc=3\n nb_label = 10\nelse:\n nc = 3\n nb_label = 10\n\nnetG = models.acnetG(nz, ngf, nc)\n\nif args.netG != '':\n netG.load_state_dict(torch.load(args.netG))\nprint(netG)\n\nnetD = models.acnetD(ndf, nc, nb_label)\n\nif args.netD != '':\n netD.load_state_dict(torch.load(args.netD))\nprint(netD)\n\n\nprint('Setup optimizer')\noptimizer = optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.wd)\n\ndecreasing_lr = list(map(int, args.decreasing_lr.split(',')))\n\nnum_labels = 10\n# os.environ[\"CUDA_LAUNCH_BLOCKING\"]=\"1\"\nbatchSize = 128\nimageSize = 32\ninput = torch.FloatTensor(batchSize, 3, imageSize, imageSize)\nnoise = torch.FloatTensor(batchSize, nz, 1, 1)\nfixed_noise = torch.FloatTensor(batchSize, nz, 1, 1).normal_(0, 1)\ns_label = torch.FloatTensor(batchSize)\nc_label = torch.LongTensor(batchSize)\n\nreal_label = 1\nfake_label = 0\n\n\ns_criterion = nn.BCELoss()\nc_criterion = nn.NLLLoss()\n\nif args.cuda:\n netD.cuda()\n netG.cuda()\n s_criterion.cuda()\n c_criterion.cuda()\n input, s_label = input.cuda(), s_label.cuda()\n c_label = c_label.cuda()\n noise, fixed_noise = noise.cuda(), fixed_noise.cuda()\n\ninput = Variable(input)\ns_label = Variable(s_label)\nc_label = Variable(c_label)\nnoise = Variable(noise)\nfixed_noise = Variable(fixed_noise)\nfixed_noise_ = np.random.normal(0, 1, (batchSize, nz))\nrandom_label = np.random.randint(0, nb_label, batchSize)\nprint('fixed label:{}'.format(random_label))\nrandom_onehot = np.zeros((batchSize, nb_label))\nrandom_onehot[np.arange(batchSize), random_label] = 1\nfixed_noise_[np.arange(batchSize), :nb_label] = random_onehot[np.arange(batchSize)]\n\n\nfixed_noise_ = (torch.from_numpy(fixed_noise_))\nfixed_noise_ = fixed_noise_.resize_(batchSize, nz, 1, 1)\nfixed_noise.data.copy_(fixed_noise_)\n\n# setup optimizer\noptimizerD = optim.Adam(netD.parameters(), lr=args.lr, betas=(args.beta1, 0.999))\noptimizerG = optim.Adam(netG.parameters(), lr=args.lr, betas=(args.beta1, 0.999))\n\n\ndef train(epoch):\n model.train()\n # D_train_loss = 0\n # G_train_loss = 3\n trg = 0\n trd = 0\n\n global first\n global fixed_noise\n global fixed_label\n global fixed_label_base\n global one_hot_zero\n for batch_idx, (img, label) in enumerate(train_loader):\n ###########################\n # (1) Update D network\n ###########################\n # train with real\n if img.shape[0] != batchSize:\n print('shape problem')\n break\n netD.zero_grad()\n batch_size = img.size(0)\n input.data.resize_(img.size()).copy_(img)\n s_label.data.resize_(batch_size).fill_(real_label)\n c_label.data.resize_(batch_size).copy_(label.squeeze())\n s_output, c_output = netD(input)\n s_errD_real = s_criterion(s_output, s_label)\n c_errD_real = c_criterion(c_output, c_label)\n errD_real = s_errD_real + 2.0*c_errD_real\n errD_real.backward()\n D_x = s_output.data.mean()\n\n #correct, length = test(c_output, c_label)\n\n # train with fake\n noise.data.resize_(batch_size, nz, 1, 1)\n noise.data.normal_(0, 1)\n\n label = np.random.randint(0, nb_label, batch_size)\n noise_ = np.random.normal(0, 1, (batch_size, nz))\n label_onehot = np.zeros((batch_size, nb_label))\n label_onehot[np.arange(batch_size), label] = 1\n noise_[np.arange(batch_size), :nb_label] = label_onehot[np.arange(batch_size)]\n\n noise_ = (torch.from_numpy(noise_))\n noise_ = noise_.resize_(batch_size, nz, 1, 1)\n noise.data.copy_(noise_)\n\n c_label.data.resize_(batch_size).copy_(torch.from_numpy(label))\n\n fake = netG(noise)\n s_label.data.fill_(fake_label)\n s_output, c_output = netD(fake.detach())\n s_errD_fake = s_criterion(s_output, s_label)\n c_errD_fake = c_criterion(c_output, c_label)\n errD_fake = s_errD_fake + 2.0*c_errD_fake\n\n errD_fake.backward()\n D_G_z1 = s_output.data.mean()\n errD = s_errD_real + s_errD_fake\n optimizerD.step()\n trd += 1\n ###########################\n # (2) Update G network\n ###########################\n netG.zero_grad()\n s_label.data.fill_(real_label) # fake labels are real for generator cost\n s_output, c_output = netD(fake)\n s_errG = s_criterion(s_output, s_label)\n c_errG = c_criterion(c_output, c_label)\n\n errG = s_errG + 2.0*c_errG\n errG.backward()\n D_G_z2 = s_output.data.mean()\n\n if errG > 0:\n optimizerG.step()\n trg+=1\n # minimize the true distribution\n # KL_fake_output = F.log_softmax(model(G_result))\n # errG_KL = F.kl_div(KL_fake_output, uniform_dist)*args.num_classes\n # generator_loss = G_train_loss + args.beta*errG_KL # 12.0, .65, 0e-8\n # generator_loss.backward()\n #G_train_loss.backward()\n #G_optimizer.step()\n # G_losses.append(G_train_loss.item())\n ###########################\n # (3) Update classifier #\n ###########################\n # cross entropy loss\n \"\"\" \n optimizer.zero_grad()\n x_ = Variable(x_)\n\n output = F.log_softmax(model(x_))\n loss = F.nll_loss(output.cuda(), label.type(torch.cuda.LongTensor).squeeze())\n\n # KL divergence\n\n ####\n z_ = torch.randn((img.shape[0], 100)).view(-1, 100, 1, 1).cuda()\n y_ = (torch.rand(img.shape[0], 1) * num_labels).type(torch.LongTensor).squeeze().cuda()\n y_label_ = onehot[y_]\n y_fill_ = fill[y_]\n\n assert y_label_[0, y_[0]] == 1\n assert y_label_.shape == (data.shape[0], 10, 1, 1)\n\n assert y_fill_[0, y_[0], :, :].sum() == (img_size ) ** 2\n assert y_fill_.sum() == (img_size ) ** 2 * data.shape[0]\n\n G_result = G(z_, y_label_)\n # !!!#D_result = D(G_result, y_fill_).squeeze()\n\n ####\n KL_fake_output = F.log_softmax(model(G_result))\n KL_loss_fake = F.kl_div(KL_fake_output, uniform_dist) * args.num_classes\n\n total_loss = loss + args.beta * KL_loss_fake\n # total_loss = loss\n total_loss.backward()\n optimizer.step()\n \"\"\"\n if batch_idx % args.log_interval == 0:\n print(\n \"Epoch {} , Descriminator loss {:.6f} Generator loss {:.6f} traingenerator {:.6f} traindiscriminator {:.6f}\".format(\n epoch, errD, errG, trg, trd))\n #print('Classification Train Epoch: {} [{}/{} ({:.0f}%)]\\tLoss: {:.6f}, KL fake Loss: {:.6f}'.format(\n # epoch, batch_idx * len(data), len(train_loader.dataset),\n # 100. * batch_idx / len(train_loader), loss.data.item(), KL_loss_fake.data.item()))\n\n # print('Classification Train Epoch: {} [{}/{} ({:.0f}%)]\\tLoss: {:.6f}, KL fake Loss: {:.6f}'.format(\n # epoch, batch_idx * len(data), len(train_loader.dataset),\n # 100. * batch_idx / len(train_loader), loss.data.item(), KL_loss_fake.data.item()))\n fake = netG(fixed_noise)\n vutils.save_image(fake.data, '%s/SVHNcDCgan_samples_epoch_%03d.png' % (args.outf, epoch), normalize=True)\n\n\n\ndef test(epoch):\n model.eval()\n test_loss = 0\n correct = 0\n total = 0\n for data, target in test_loader:\n total += data.size(0)\n if args.cuda:\n data, target = data.cuda(), target.cuda()\n # data, target = Variable(data, volatile=True), Variable(target)\n output = F.log_softmax(model(data))\n target = target.type(\n torch.LongTensor) # https://discuss.pytorch.org/t/runtimeerror-multi-target-not-supported-newbie/10216/4\n if args.cuda:\n output = output.cuda()\n target = target.cuda()\n target = torch.squeeze(target)\n\n test_loss += F.nll_loss(output, target).data.item()\n pred = output.data.max(1)[1] # get the index of the max log-probability\n correct += pred.eq(target.data).cpu().sum()\n\n test_loss = test_loss\n test_loss /= len(test_loader) # loss function already averages over batch size\n print('\\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\\n'.format(\n test_loss, correct, total,\n 100. * correct / total))\n\n\nfor epoch in range(1, args.epochs + 1):\n train(epoch)\n# test(epoch)\n if epoch in decreasing_lr:\n optimizerG.param_groups[0]['lr'] *= args.droprate\n optimizerD.param_groups[0]['lr'] *= args.droprate\n optimizer.param_groups[0]['lr'] *= args.droprate\n if epoch % 20 == 0:\n # do checkpointing\n torch.save(netG.state_dict(), '%s/netG_epoch_%d.pth' % (args.outf, epoch))\n torch.save(netD.state_dict(), '%s/netD_epoch_%d.pth' % (args.outf, epoch))\n torch.save(model.state_dict(), '%s/model_epoch_%d.pth' % (args.outf, epoch))\n", "meta": {"hexsha": "087ffbfe4e98f6ce8d8765809011f570cb3929e5", "size": 12485, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/run_joint_confidence_condgan.py", "max_stars_repo_name": "williamsashbee/Confident_classifier", "max_stars_repo_head_hexsha": "cba3ef862b310afc3af6c4a62b524f032f45549e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/run_joint_confidence_condgan.py", "max_issues_repo_name": "williamsashbee/Confident_classifier", "max_issues_repo_head_hexsha": "cba3ef862b310afc3af6c4a62b524f032f45549e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/run_joint_confidence_condgan.py", "max_forks_repo_name": "williamsashbee/Confident_classifier", "max_forks_repo_head_hexsha": "cba3ef862b310afc3af6c4a62b524f032f45549e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.9798270893, "max_line_length": 132, "alphanum_fraction": 0.6358029636, "include": true, "reason": "import numpy", "num_tokens": 3250, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5621765155565326, "lm_q2_score": 0.34158251284363395, "lm_q1q2_score": 0.19202966684547867}} {"text": "import numpy as np\nimport math\nimport torch\nfrom typing import Any\nimport jax\nfrom jax import numpy as jnp\n\nfrom torch.utils import dlpack as tdlpack\nfrom jax import dlpack as jdlpack\n\nfrom flax import struct\n\nimport uuid\nimport pykeops\ntry:\n pykeops.set_bin_folder(f'/scratch/wwhitney/pykeops_bin/{uuid.uuid4()}')\nexcept:\n pykeops.set_bin_folder(f'/scratch/ww1114/pykeops_bin/{uuid.uuid4()}')\nfrom pykeops.torch import LazyTensor\n\nfrom environments import jax_specs\nimport utils\n\n\nJ_DTYPE = jnp.float32\nT_DTYPE = torch.float32\n\n\n@struct.dataclass\nclass DensityState:\n observations: Any\n weights: Any\n device: Any\n state_rescale: jnp.ndarray\n action_rescale: jnp.ndarray\n state_shift: jnp.ndarray\n action_shift: jnp.ndarray\n max_obs: int = 100000\n tolerance: float = 0.95\n reweight_dropped: bool = False\n conserve_weight: bool = False\n total: int = 0\n next_slot: int = 0\n\n\n\ndef new(observation_spec, action_spec, max_obs=100000,\n state_scale=1, action_scale=1, tolerance=0.95,\n reweight_dropped=False, conserve_weight=False,\n **kwargs):\n flat_ospec = utils.flatten_observation_spec(observation_spec)\n j_flat_ospec = jax_specs.convert_dm_spec(flat_ospec)\n j_aspec = jax_specs.convert_dm_spec(action_spec)\n\n state_rescale = state_scale * (j_flat_ospec.maximum - j_flat_ospec.minimum)\n action_rescale = action_scale * (j_aspec.maximum - j_aspec.minimum)\n state_shift = j_flat_ospec.minimum\n action_shift = j_aspec.minimum\n\n state_rescale = jax.device_put(state_rescale,\n jax.local_devices(backend='cpu')[0])\n action_rescale = jax.device_put(action_rescale,\n jax.local_devices(backend='cpu')[0])\n state_shift = jax.device_put(state_shift,\n jax.local_devices(backend='cpu')[0])\n action_shift = jax.device_put(action_shift,\n jax.local_devices(backend='cpu')[0])\n\n key_dim = j_flat_ospec.shape[0] + j_aspec.shape[0]\n\n if torch.cuda.is_available():\n device = torch.device('cuda')\n else:\n device = torch.device('cpu')\n\n # pykeops.clean_pykeops() # just in case old build files are still present\n\n # initialize this to some reasonable size\n # starting_size = 65536\n starting_size = 4096\n observations = torch.zeros((starting_size, key_dim))\n observations = observations.type(T_DTYPE).to(device)\n weights = torch.zeros((starting_size,))\n weights = weights.type(T_DTYPE).to(device)\n\n return DensityState(observations, weights, device,\n state_rescale, action_rescale,\n state_shift, action_shift,\n max_obs=max_obs, tolerance=tolerance,\n reweight_dropped=reweight_dropped,\n conserve_weight=conserve_weight)\n\n\n@jax.profiler.trace_function\ndef update_batch(density_state: DensityState, states, actions):\n # increase the size of weights vector if needed\n observations = density_state.observations\n weights = density_state.weights\n needed_size = density_state.next_slot + states.shape[0]\n while ((needed_size >= observations.shape[0]) and\n (observations.shape[0] < density_state.max_obs)):\n observations, weights = _grow_observations(observations, weights,\n density_state.max_obs)\n density_state = density_state.replace(observations=observations,\n weights=weights)\n\n # compute which states are new and which weights to update\n keys = _make_key_batch(density_state, states, actions)\n new_keys, weight_updates = _compute_updates(density_state, keys)\n\n # update weights\n if weight_updates.sum() > 0:\n weights = density_state.weights + weight_updates.to(density_state.device)\n density_state = density_state.replace(weights=weights)\n\n # add all the new observations to the index\n if len(new_keys) > 0:\n density_state = _add_observations(density_state, new_keys)\n\n return density_state\n\n\n@jax.profiler.trace_function\ndef _compute_updates(density_state: DensityState, keys):\n if density_state.total <= 0:\n # if True:\n weight_update = torch.zeros_like(density_state.weights)\n return keys, weight_update\n\n obs = density_state.observations\n\n x_o = LazyTensor( obs[:, None, :] ) # obs_size x 1 x dim\n x_q = LazyTensor( keys[None, :, :] ) # 1 x batch_size x dim\n\n D_oq = ((x_o - x_q)**2).sum(dim=2) # obs_size x batch_size\n K_oq = (-0.5 * D_oq).exp()\n\n # want:\n # (1) the keys that have no close neighbors,\n # (2) the close neighbors & distances of the others\n\n mins, inds = (-K_oq).Kmin_argKmin(16, dim=1)\n sims_per_neighbor = -mins.cpu().numpy()\n new_keys = []\n weight_updates = torch.zeros((obs.shape[0],))\n\n for (key, sims, ind) in zip(keys, sims_per_neighbor, inds):\n similar_mask = sims > density_state.tolerance\n n_similar_obs = similar_mask.sum()\n\n if n_similar_obs >= 1:\n similar_meta_indices = np.flatnonzero(similar_mask)\n similar_indices = ind[similar_meta_indices]\n weight_updates[similar_indices] += 1 / n_similar_obs\n else:\n new_keys.append(key)\n\n if len(new_keys) > 0:\n new_keys = torch.stack(new_keys)\n return new_keys, weight_updates\n\n\n@jax.profiler.trace_function\ndef _add_observations(density_state: DensityState, keys):\n bsize = keys.shape[0]\n next_slot = density_state.next_slot\n observations = density_state.observations\n weights = density_state.weights\n\n if density_state.total >= density_state.max_obs:\n indices = torch.randint(low=0, high=int(density_state.max_obs - 1),\n size=(bsize,))\n else:\n indices = torch.arange(next_slot, next_slot + bsize)\n indices = indices % density_state.max_obs\n indices = indices.long()\n\n if density_state.conserve_weight:\n removed_weight = weights[indices].sum()\n max_key = min(density_state.total, density_state.max_obs)\n weights[:int(max_key)] += removed_weight / max_key\n\n # update the observations\n observations[indices] = keys\n weights[indices] = 1\n total = density_state.total + bsize\n next_slot = (next_slot + bsize) % observations.shape[0]\n return density_state.replace(observations=observations, weights=weights,\n total=total, next_slot=next_slot)\n\n\n@jax.profiler.trace_function\ndef _grow_observations(observations, weights, max_size):\n current_size = observations.shape[0]\n print(f\"Growing KDE observations from {current_size}.\")\n\n observations = torch.cat([observations, torch.zeros_like(observations)],\n dim=0)\n weights = torch.cat([weights, torch.zeros_like(weights)],\n dim=0)\n return observations, weights\n\n\n@jax.profiler.trace_function\ndef get_count(density_state: DensityState, state, action):\n states = np.expand_dims(state, axis=0)\n actions = np.expand_dims(action, axis=0)\n return get_count_batch(density_state, states, actions)[0]\n\n\n@jax.profiler.trace_function\ndef get_count_batch(density_state: DensityState, states, actions):\n\n with jax.profiler.TraceContext(\"check density size\"):\n # prevent the index from segfaulting if queried when empty\n if density_state.total <= 0:\n return np.zeros((states.shape[0],))\n\n\n with jax.profiler.TraceContext(\"access density obs + weights\"):\n obs = density_state.observations\n weights = density_state.weights\n\n\n with jax.profiler.TraceContext(\"make keys\"):\n keys = _make_key_batch(density_state, states, actions)\n\n\n with jax.profiler.TraceContext(\"construct keops computation\"):\n x_o = LazyTensor( obs[:, None, :] ) # obs_size x 1 x dim\n x_q = LazyTensor( keys[None, :, :] ) # 1 x batch_size x dim\n x_w = LazyTensor( weights[:, None], axis=0 ) # obs_size x 1\n\n D_oq = ((x_o - x_q)**2).sum(dim=2) # obs_size x batch_size\n K_oq = (-0.5 * D_oq).exp()\n C_oq = x_w * K_oq # multiply the row for each obs by its weight\n\n\n with jax.profiler.TraceContext(\"do keops computation\"):\n counts = C_oq.sum(dim=0) # batch_size\n\n # reweight counts to account for dropped entries\n if density_state.reweight_dropped:\n counts = counts * (density_state.total / weights.sum())\n\n with jax.profiler.TraceContext(\"convert types\"):\n counts = utils.t_to_j(counts.reshape(-1))\n return counts\n\n\n@jax.profiler.trace_function\n@jax.partial(jax.jit, backend='cpu')\ndef _make_key_jax(state_rescale, action_rescale, state_shift, action_shift,\n s, a):\n flat_s = utils.flatten_observation(s)\n flat_a = jnp.array(a).reshape((-1,))\n normalized_s = (flat_s - state_shift) / state_rescale\n normalized_a = (flat_a - action_shift) / action_rescale\n return jnp.concatenate([normalized_s, normalized_a], axis=0).astype(J_DTYPE)\n_make_key_jax_batch = jax.vmap(_make_key_jax, in_axes=(None, None, None, None,\n 0, 0))\n_make_key_jax_batch = jax.profiler.trace_function(_make_key_jax_batch,\n \"_make_key_jax_batch\")\n\n\n@jax.profiler.trace_function\ndef _make_key_batch(density_state: DensityState, s, a):\n j_key = _make_key_jax_batch(density_state.state_rescale,\n density_state.action_rescale,\n density_state.state_shift,\n density_state.action_shift,\n s, a)\n return utils.j_to_t(j_key).to(density_state.device)\n\n\nif __name__ == \"__main__\":\n from dm_control import suite\n from observation_domains import DOMAINS\n import jax_specs\n import point\n\n env_name = 'point'\n task_name = 'velocity'\n env = suite.load(env_name, task_name)\n ospec = DOMAINS[env_name][task_name]\n\n aspec = env.action_spec()\n j_aspec = jax_specs.convert_dm_spec(aspec)\n j_ospec = jax_specs.convert_dm_spec(ospec)\n density_state = new(ospec, aspec, state_scale=0.01, action_scale=1)\n\n timestep = env.reset()\n state = utils.flatten_observation(timestep.observation)\n actions = utils.sample_uniform_actions(j_aspec, jax.random.PRNGKey(0), 1)\n action = actions[0]\n\n\n # ---------- sanity checking counts --------------------\n timestep2 = env.step(jnp.ones(aspec.shape))\n state2 = utils.flatten_observation(timestep2.observation)\n\n print(\"S1 count:\", get_count(density_state, state, action))\n\n print(\"S2 count:\", get_count(density_state, state2, action))\n density_state_updated = update_batch(density_state,\n jnp.expand_dims(state2, axis=0),\n jnp.expand_dims(action, axis=0))\n print(\"S2 count after self update:\", get_count(density_state_updated,\n state2, action))\n\n print(\"Batch of counts:\", get_count_batch(density_state_updated,\n jnp.stack([state, state2]),\n jnp.stack([action, action])))\n", "meta": {"hexsha": "d2c6f1affde73a9cb0067b3f73df6917b8829dd3", "size": 11323, "ext": "py", "lang": "Python", "max_stars_repo_path": "densities/keops_kernel_count.py", "max_stars_repo_name": "willwhitney/exploration-reimplementation", "max_stars_repo_head_hexsha": "5e2ca54119529b8bf9235bfbad92e38a6781fbd5", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-08-24T15:59:59.000Z", "max_stars_repo_stars_event_max_datetime": "2020-08-24T17:03:30.000Z", "max_issues_repo_path": "densities/keops_kernel_count.py", "max_issues_repo_name": "willwhitney/exploration-reimplementation", "max_issues_repo_head_hexsha": "5e2ca54119529b8bf9235bfbad92e38a6781fbd5", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "densities/keops_kernel_count.py", "max_forks_repo_name": "willwhitney/exploration-reimplementation", "max_forks_repo_head_hexsha": "5e2ca54119529b8bf9235bfbad92e38a6781fbd5", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.0605095541, "max_line_length": 81, "alphanum_fraction": 0.6550384174, "include": true, "reason": "import numpy,import jax,from jax", "num_tokens": 2678, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5621765008857981, "lm_q2_score": 0.34158251284363395, "lm_q1q2_score": 0.1920296618342123}} {"text": "\"\"\"\nThe POVMEffect class and supporting functionality.\n\"\"\"\n#***************************************************************************************************\n# Copyright 2015, 2019 National Technology & Engineering Solutions of Sandia, LLC (NTESS).\n# Under the terms of Contract DE-NA0003525 with NTESS, the U.S. Government retains certain rights\n# in this software.\n# Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except\n# in compliance with the License. You may obtain a copy of the License at\n# http://www.apache.org/licenses/LICENSE-2.0 or in the LICENSE file in the root pyGSTi directory.\n#***************************************************************************************************\n\nimport numpy as _np\n\nfrom pygsti.modelmembers import modelmember as _modelmember\nfrom pygsti.tools import optools as _ot\nfrom pygsti.baseobjs.opcalc import bulk_eval_compact_polynomials_complex as _bulk_eval_compact_polynomials_complex\n\n\nclass POVMEffect(_modelmember.ModelMember):\n \"\"\"\n TODO: update docstring\n A parameterized state preparation OR POVM effect vector (operator).\n\n This class is the common base class for all specific\n parameterizations of a POVM effect vector.\n\n Parameters\n ----------\n rep : object\n A representation object containing the core data for this spam vector.\n\n evotype : Evotype\n The evolution type of this operator, for matching with forward simulators.\n\n Attributes\n ----------\n size : int\n The number of independent elements in this POVM effect vector (when viewed as a dense array).\n \"\"\"\n\n def __init__(self, rep, evotype):\n \"\"\" Initialize a new POVM effect Vector \"\"\"\n super(POVMEffect, self).__init__(rep.state_space, evotype)\n self._rep = rep\n\n @property\n def outcomes(self):\n \"\"\"\n The z-value outcomes corresponding to this effect POVM effect vector.\n\n (Used in the context of a stabilizer-state simulation.)\n\n Returns\n -------\n numpy.ndarray\n \"\"\"\n raise NotImplementedError(\"'outcomes' property is not implemented for %s objects\" % self.__class__.__name__)\n\n @property\n def dim(self):\n \"\"\"\n Return the dimension of this effect (when viewed as a dense array)\n\n Returns\n -------\n int\n \"\"\"\n return self.state_space.dim\n\n @property\n def hilbert_schmidt_size(self):\n \"\"\"\n Return the number of independent elements in this effect as a dense Hilbert-Schmidt super-bra.\n\n Returns\n -------\n int\n \"\"\"\n return self.state_space.dim\n\n def set_dense(self, vec):\n \"\"\"\n Set the dense-vector value of this POVM effect vector.\n\n Attempts to modify this POVM effect vector's parameters so that the raw\n POVM effect vector becomes `vec`. Will raise ValueError if this operation\n is not possible.\n\n Parameters\n ----------\n vec : array_like or POVMEffect\n A numpy array representing a POVM effect vector, or a POVMEffect object.\n\n Returns\n -------\n None\n \"\"\"\n raise ValueError(\"Cannot set the value of a %s directly!\" % self.__class__.__name__)\n\n def set_time(self, t):\n \"\"\"\n Sets the current time for a time-dependent operator.\n\n For time-independent operators (the default), this function does absolutely nothing.\n\n Parameters\n ----------\n t : float\n The current time.\n\n Returns\n -------\n None\n \"\"\"\n pass\n\n ## PUT term calc methods here if appropriate...\n\n def frobeniusdist_squared(self, other_spam_vec, transform=None,\n inv_transform=None):\n \"\"\"\n Return the squared frobenius difference between this operation and `other_spam_vec`.\n\n Optionally transforms this vector first using `transform` and\n `inv_transform`.\n\n Parameters\n ----------\n other_spam_vec : POVMEffect\n The other spam vector\n\n transform : numpy.ndarray, optional\n Transformation matrix.\n\n inv_transform : numpy.ndarray, optional\n Inverse of `tranform`.\n\n Returns\n -------\n float\n \"\"\"\n vec = self.to_dense()\n if transform is None:\n return _ot.frobeniusdist_squared(vec, other_spam_vec.to_dense())\n else:\n return _ot.frobeniusdist_squared(_np.dot(_np.transpose(transform),\n vec), other_spam_vec.to_dense())\n\n def residuals(self, other_spam_vec, transform=None, inv_transform=None):\n \"\"\"\n Return a vector of residuals between this spam vector and `other_spam_vec`.\n\n Optionally transforms this vector first using `transform` and\n `inv_transform`.\n\n Parameters\n ----------\n other_spam_vec : POVMEffect\n The other spam vector\n\n transform : numpy.ndarray, optional\n Transformation matrix.\n\n inv_transform : numpy.ndarray, optional\n Inverse of `tranform`.\n\n Returns\n -------\n float\n \"\"\"\n vec = self.to_dense()\n if transform is None:\n return _ot.residuals(vec, other_spam_vec.to_dense())\n else:\n return _ot.residuals(_np.dot(_np.transpose(transform),\n vec), other_spam_vec.to_dense())\n\n def transform_inplace(self, s):\n \"\"\"\n Update POVM effect (column) vector V => s^T * V\n\n Note that this is equivalent to the *transpose* of effect vectors\n being mapped as `E^T -> E^T * s`.\n\n Generally, the transform function updates the *parameters* of\n the POVM effect vector such that the resulting vector is altered as\n described above. If such an update cannot be done (because\n the gate parameters do not allow for it), ValueError is raised.\n\n Parameters\n ----------\n s : GaugeGroupElement\n A gauge group element which specifies the \"s\" matrix\n (and it's inverse) used in the above similarity transform.\n\n typ : { 'prep', 'effect' }\n Which type of POVM effect vector is being transformed (see above).\n\n Returns\n -------\n None\n \"\"\"\n #Evec^T --> ( Evec^T * s )^T\n Smx = s.transform_matrix\n self.set_dense(_np.dot(_np.transpose(Smx), self.to_dense()))\n\n @property\n def num_params(self):\n \"\"\"\n Get the number of independent parameters which specify this POVM effect vector.\n\n Returns\n -------\n int\n the number of independent parameters.\n \"\"\"\n return 0 # no parameters\n\n def to_vector(self):\n \"\"\"\n Get the POVM effect vector parameters as an array of values.\n\n Returns\n -------\n numpy array\n The parameters as a 1D array with length num_params().\n \"\"\"\n return _np.array([], 'd') # no parameters\n\n def from_vector(self, v, close=False, dirty_value=True):\n \"\"\"\n Initialize the POVM effect vector using a 1D array of parameters.\n\n Parameters\n ----------\n v : numpy array\n The 1D vector of POVM effect vector parameters. Length\n must == num_params()\n\n close : bool, optional\n Whether `v` is close to this POVM effect vector's current\n set of parameters. Under some circumstances, when this\n is true this call can be completed more quickly.\n\n dirty_value : bool, optional\n The value to set this object's \"dirty flag\" to before exiting this\n call. This is passed as an argument so it can be updated *recursively*.\n Leave this set to `True` unless you know what you're doing.\n\n Returns\n -------\n None\n \"\"\"\n assert(len(v) == 0) # should be no parameters, and nothing to do\n\n def deriv_wrt_params(self, wrt_filter=None):\n \"\"\"\n The element-wise derivative this POVM effect vector.\n\n Construct a matrix whose columns are the derivatives of the POVM effect vector\n with respect to a single param. Thus, each column is of length\n dimension and there is one column per POVM effect vector parameter.\n\n Parameters\n ----------\n wrt_filter : list or numpy.ndarray\n List of parameter indices to take derivative with respect to.\n (None means to use all the this operation's parameters.)\n\n Returns\n -------\n numpy array\n Array of derivatives, shape == (dimension, num_params)\n \"\"\"\n dtype = complex if self._evotype == 'statevec' else 'd'\n derivMx = _np.zeros((self.dim, 0), dtype)\n if wrt_filter is None:\n return derivMx\n else:\n return _np.take(derivMx, wrt_filter, axis=1)\n\n def has_nonzero_hessian(self):\n \"\"\"\n Whether this POVM effect vector has a non-zero Hessian with respect to its parameters.\n\n Returns\n -------\n bool\n \"\"\"\n #Default: assume Hessian can be nonzero if there are any parameters\n return self.num_params > 0\n\n def hessian_wrt_params(self, wrt_filter1=None, wrt_filter2=None):\n \"\"\"\n Construct the Hessian of this POVM effect vector with respect to its parameters.\n\n This function returns a tensor whose first axis corresponds to the\n flattened operation matrix and whose 2nd and 3rd axes correspond to the\n parameters that are differentiated with respect to.\n\n Parameters\n ----------\n wrt_filter1 : list or numpy.ndarray\n List of parameter indices to take 1st derivatives with respect to.\n (None means to use all the this operation's parameters.)\n\n wrt_filter2 : list or numpy.ndarray\n List of parameter indices to take 2nd derivatives with respect to.\n (None means to use all the this operation's parameters.)\n\n Returns\n -------\n numpy array\n Hessian with shape (dimension, num_params1, num_params2)\n \"\"\"\n if not self.has_nonzero_hessian():\n return _np.zeros(self.size, self.num_params, self.num_params)\n\n # FUTURE: create a finite differencing hessian method?\n raise NotImplementedError(\"hessian_wrt_params(...) is not implemented for %s objects\" % self.__class__.__name__)\n\n def taylor_order_terms(self, order, max_polynomial_vars=100, return_coeff_polys=False):\n \"\"\"\n Get the `order`-th order Taylor-expansion terms of this effect vector.\n\n This function either constructs or returns a cached list of the terms at\n the given order. Each term is \"rank-1\", meaning that it is a state\n preparation followed by or POVM effect preceded by actions on a\n density matrix `rho` of the form:\n\n `rho -> A rho B`\n\n The coefficients of these terms are typically polynomials of the\n State's parameters, where the polynomial's variable indices index the\n *global* parameters of the State's parent (usually a :class:`Model`)\n , not the State's local parameter array (i.e. that returned from\n `to_vector`).\n\n Parameters\n ----------\n order : int\n The order of terms to get.\n\n max_polynomial_vars : int, optional\n maximum number of variables the created polynomials can have.\n\n return_coeff_polys : bool\n Whether a parallel list of locally-indexed (using variable indices\n corresponding to *this* object's parameters rather than its parent's)\n polynomial coefficients should be returned as well.\n\n Returns\n -------\n terms : list\n A list of :class:`RankOneTerm` objects.\n\n coefficients : list\n Only present when `return_coeff_polys == True`.\n A list of *compact* polynomial objects, meaning that each element\n is a `(vtape,ctape)` 2-tuple formed by concatenating together the\n output of :method:`Polynomial.compact`.\n \"\"\"\n #NOTE: exact copy of State method - consolidate in FUTURE?\n raise NotImplementedError(\"taylor_order_terms(...) not implemented for %s objects!\" %\n self.__class__.__name__)\n\n def highmagnitude_terms(self, min_term_mag, force_firstorder=True, max_taylor_order=3, max_polynomial_vars=100):\n \"\"\"\n Get terms with magnitude above `min_term_mag`.\n\n Get the terms (from a Taylor expansion of this state vector) that have\n magnitude above `min_term_mag` (the magnitude of a term is taken to\n be the absolute value of its coefficient), considering only those\n terms up to some maximum Taylor expansion order, `max_taylor_order`.\n\n Note that this function also *sets* the magnitudes of the returned\n terms (by calling `term.set_magnitude(...)`) based on the current\n values of this state vector's parameters. This is an essential step\n to using these terms in pruned-path-integral calculations later on.\n\n Parameters\n ----------\n min_term_mag : float\n the threshold for term magnitudes: only terms with magnitudes above\n this value are returned.\n\n force_firstorder : bool, optional\n if True, then always return all the first-order Taylor-series terms,\n even if they have magnitudes smaller than `min_term_mag`. This\n behavior is needed for using GST with pruned-term calculations, as\n we may begin with a guess model that has no error (all terms have\n zero magnitude!) and still need to compute a meaningful jacobian at\n this point.\n\n max_taylor_order : int, optional\n the maximum Taylor-order to consider when checking whether term-\n magnitudes exceed `min_term_mag`.\n\n max_polynomial_vars : int, optional\n maximum number of variables the created polynomials can have.\n\n Returns\n -------\n highmag_terms : list\n A list of the high-magnitude terms that were found. These\n terms are *sorted* in descending order by term-magnitude.\n\n first_order_indices : list\n A list of the indices into `highmag_terms` that mark which\n of these terms are first-order Taylor terms (useful when\n we're forcing these terms to always be present).\n \"\"\"\n #NOTE: SAME as for LinearOperator class and State class -- TODO consolidate in FUTURE\n #print(\"DB: state get_high_magnitude_terms\")\n v = self.to_vector()\n taylor_order = 0\n terms = []; last_len = -1; first_order_magmax = 1.0\n while len(terms) > last_len: # while we keep adding something\n if taylor_order > 1 and first_order_magmax**taylor_order < min_term_mag:\n break # there's no way any terms at this order reach min_term_mag - exit now!\n\n MAX_CACHED_TERM_ORDER = 1\n if taylor_order <= MAX_CACHED_TERM_ORDER:\n #print(\"order \",taylor_order,\" : \",len(terms), \"terms\")\n terms_at_order, cpolys = self.taylor_order_terms(taylor_order, max_polynomial_vars, True)\n coeffs = _bulk_eval_compact_polynomials_complex(\n cpolys[0], cpolys[1], v, (len(terms_at_order),)) # an array of coeffs\n mags = _np.abs(coeffs)\n last_len = len(terms)\n #OLD: terms_at_order = [ t.copy_with_magnitude(abs(coeff)) for coeff, t in zip(coeffs, terms_at_order) ]\n\n if taylor_order == 1:\n #OLD: first_order_magmax = max([t.magnitude for t in terms_at_order])\n first_order_magmax = max(mags)\n\n if force_firstorder:\n terms.extend([(taylor_order, t.copy_with_magnitude(mag))\n for coeff, mag, t in zip(coeffs, mags, terms_at_order)])\n else:\n for mag, t in zip(mags, terms_at_order):\n if mag >= min_term_mag:\n terms.append((taylor_order, t.copy_with_magnitude(mag)))\n else:\n for mag, t in zip(mags, terms_at_order):\n if mag >= min_term_mag:\n terms.append((taylor_order, t.copy_with_magnitude(mag)))\n\n else:\n eff_min_term_mag = 0.0 if (taylor_order == 1 and force_firstorder) else min_term_mag\n terms.extend([(taylor_order, t) for t in\n self.taylor_order_terms_above_mag(taylor_order,\n max_polynomial_vars, eff_min_term_mag)])\n\n taylor_order += 1\n if taylor_order > max_taylor_order: break\n\n #Sort terms based on magnitude\n sorted_terms = sorted(terms, key=lambda t: t[1].magnitude, reverse=True)\n first_order_indices = [i for i, t in enumerate(sorted_terms) if t[0] == 1]\n return [t[1] for t in sorted_terms], first_order_indices\n\n def taylor_order_terms_above_mag(self, order, max_polynomial_vars, min_term_mag):\n \"\"\"\n Get the `order`-th order Taylor-expansion terms of this state vector that have magnitude above `min_term_mag`.\n\n This function constructs the terms at the given order which have a magnitude (given by\n the absolute value of their coefficient) that is greater than or equal to `min_term_mag`.\n It calls :method:`taylor_order_terms` internally, so that all the terms at order `order`\n are typically cached for future calls.\n\n Parameters\n ----------\n order : int\n The order of terms to get.\n\n max_polynomial_vars : int, optional\n maximum number of variables the created polynomials can have.\n\n min_term_mag : float\n the minimum term magnitude.\n\n Returns\n -------\n list\n \"\"\"\n #NOTE: exact copy of State method - consolidate in FUTURE?\n v = self.to_vector()\n terms_at_order, cpolys = self.taylor_order_terms(order, max_polynomial_vars, True)\n coeffs = _bulk_eval_compact_polynomials_complex(\n cpolys[0], cpolys[1], v, (len(terms_at_order),)) # an array of coeffs\n terms_at_order = [t.copy_with_magnitude(abs(coeff)) for coeff, t in zip(coeffs, terms_at_order)]\n return [t for t in terms_at_order if t.magnitude >= min_term_mag]\n", "meta": {"hexsha": "3d09103d5ff0bfa05134ac261f2327c12ccc92a5", "size": 18791, "ext": "py", "lang": "Python", "max_stars_repo_path": "pygsti/modelmembers/povms/effect.py", "max_stars_repo_name": "pyGSTi-Developers/pyGSTi", "max_stars_repo_head_hexsha": "bfedc1de4d604f14b0f958615776fb80ddb59e33", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pygsti/modelmembers/povms/effect.py", "max_issues_repo_name": "pyGSTi-Developers/pyGSTi", "max_issues_repo_head_hexsha": "bfedc1de4d604f14b0f958615776fb80ddb59e33", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pygsti/modelmembers/povms/effect.py", "max_forks_repo_name": "pyGSTi-Developers/pyGSTi", "max_forks_repo_head_hexsha": "bfedc1de4d604f14b0f958615776fb80ddb59e33", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.0384615385, "max_line_length": 120, "alphanum_fraction": 0.6068330584, "include": true, "reason": "import numpy", "num_tokens": 3932, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.5621765008857981, "lm_q2_score": 0.34158250614097546, "lm_q1q2_score": 0.19202965806613523}} {"text": "# ======================================================================\n# Imports\n# ======================================================================\nimport copy\nfrom collections import OrderedDict\nimport numpy as np\nfrom scipy import sparse\nfrom mpi4py import MPI\nfrom pyspline import Curve\nfrom pyspline.utils import openTecplot, closeTecplot, writeTecplot1D, writeTecplot3D\nfrom . import pyNetwork, pyBlock, geo_utils\nimport os\nimport warnings\n\n\nclass Error(Exception):\n \"\"\"\n Format the error message in a box to make it clear this\n was a explicitly raised exception.\n \"\"\"\n\n def __init__(self, message):\n msg = \"\\n+\" + \"-\" * 78 + \"+\" + \"\\n\" + \"| DVGeometry Error: \"\n i = 19\n for word in message.split():\n if len(word) + i + 1 > 78: # Finish line and start new one\n msg += \" \" * (78 - i) + \"|\\n| \" + word + \" \"\n i = 1 + len(word) + 1\n else:\n msg += word + \" \"\n i += len(word) + 1\n msg += \" \" * (78 - i) + \"|\\n\" + \"+\" + \"-\" * 78 + \"+\" + \"\\n\"\n print(msg)\n Exception.__init__(self)\n\n\nclass DVGeometry(object):\n \"\"\"\n A class for manipulating geometry.\n\n The purpose of the DVGeometry class is to provide a mapping from\n user-supplied design variables to an arbitrary set of discrete,\n three-dimensional coordinates. These three-dimensional coordinates\n can in general represent anything, but will typically be the\n surface of an aerodynamic mesh, the nodes of a FE mesh or the\n nodes of another geometric construct.\n\n In a very general sense, DVGeometry performs two primary\n functions:\n\n 1. Given a new set of design variables, update the\n three-dimensional coordinates: :math:`X_{DV}\\\\rightarrow\n X_{pt}` where :math:`X_{pt}` are the coordinates and :math:`X_{DV}`\n are the user variables.\n\n 2. Determine the derivative of the coordinates with respect to the\n design variables. That is the derivative :math:`\\\\frac{dX_{pt}}{dX_{DV}}`\n\n DVGeometry uses the *Free-Form Deformation* approach for goemetry\n manipulation. The basic idea is the coordinates are *embedded* in\n a clear-flexible jelly-like block. Then by stretching moving and\n 'poking' the volume, the coordinates that are embedded inside move\n along with overall deformation of the volume.\n\n Parameters\n ----------\n fileName : str\n filename of FFD file. This must be a ascii formatted plot3D file\n in fortran ordering.\n\n complex : bool\n Make the entire object complex. This should **only** be used when\n debugging the entire tool-chain with the complex step method.\n\n child : bool\n Flag to indicate that this object is a child of parent DVGeo object\n\n\n Examples\n --------\n The general sequence of operations for using DVGeometry is as follows::\n >>> from pygeo import *\n >>> DVGeo = DVGeometry('FFD_file.fmt')\n >>> # Embed a set of coordinates Xpt into the object\n >>> DVGeo.addPointSet(Xpt, 'myPoints')\n >>> # Associate a 'reference axis' for large-scale manipulation\n >>> DVGeo.addRefAxis('wing_axis', axis_curve)\n >>> # Define a global design variable function:\n >>> def twist(val, geo):\n >>> geo.rot_z['wing_axis'].coef[:] = val[:]\n >>> # Now add this as a global variable:\n >>> DVGeo.addGlobalDV('wing_twist', 0.0, twist, lower=-10, upper=10)\n >>> # Now add local (shape) variables\n >>> DVGeo.addLocalDV('shape', lower=-0.5, upper=0.5, axis='y')\n >>>\n \"\"\"\n\n def __init__(self, fileName, complex=False, child=False, faceFreeze=None, name=None, *args, **kwargs):\n\n self.DV_listGlobal = OrderedDict() # Global Design Variable List\n self.DV_listLocal = OrderedDict() # Local Design Variable List\n self.DV_listSectionLocal = OrderedDict() # Local Normal Design Variable List\n self.DV_listSpanwiseLocal = OrderedDict() # Local Normal Design Variable List\n\n # Coefficient rotation matrix dict for Section Local variables\n self.coefRotM = {}\n\n # Name (used for ensuring design variables names are unique to pyoptsparse)\n self.name = name\n\n # Flags to determine if this DVGeometry is a parent or child\n self.isChild = child\n self.children = []\n self.iChild = None\n self.points = OrderedDict()\n self.updated = {}\n self.masks = None\n self.finalized = False\n self.complex = complex\n if self.complex:\n self.dtype = \"D\"\n else:\n self.dtype = \"d\"\n\n # Load the FFD file in FFD mode. Also note that args and\n # kwargs are passed through in case additional pyBlock options\n # need to be set.\n self.FFD = pyBlock(\"plot3d\", fileName=fileName, FFD=True, *args, **kwargs)\n self.origFFDCoef = self.FFD.coef.copy()\n\n # Jacobians:\n self.ptSetNames = []\n self.JT = {}\n self.nPts = {}\n\n # Derivatives of Xref and Coef provided by the parent to the\n # children\n self.dXrefdXdvg = None\n self.dCoefdXdvg = None\n\n self.dXrefdXdvl = None\n self.dCoefdXdvl = None\n\n # derivative counters for offsets\n self.nDV_T = None # total number of design variables\n self.nDVG_T = None\n self.nDVL_T = None\n self.nDVSL_T = None\n self.nDVSW_T = None\n self.nDVG_count = 0 # number of global (G) variables\n self.nDVL_count = 0 # number of local (L) variables\n self.nDVSL_count = 0 # number of section (SL) local variables\n self.nDVSW_count = 0 # number of spanwise (SW) local variables\n\n # The set of user supplied axis.\n self.axis = OrderedDict()\n\n # Generate coefMask regardless\n coefMask = []\n for iVol in range(self.FFD.nVol):\n coefMask.append(\n np.zeros((self.FFD.vols[iVol].nCtlu, self.FFD.vols[iVol].nCtlv, self.FFD.vols[iVol].nCtlw), dtype=bool)\n )\n # Now do the faceFreeze\n if faceFreeze is not None:\n for iVol in range(self.FFD.nVol):\n key = \"%d\" % iVol\n if key in faceFreeze.keys():\n if \"iLow\" in faceFreeze[key]:\n coefMask[iVol][0, :, :] = True\n coefMask[iVol][1, :, :] = True\n if \"iHigh\" in faceFreeze[key]:\n coefMask[iVol][-1, :, :] = True\n coefMask[iVol][-2, :, :] = True\n if \"jLow\" in faceFreeze[key]:\n coefMask[iVol][:, 0, :] = True\n coefMask[iVol][:, 1, :] = True\n if \"jHigh\" in faceFreeze[key]:\n coefMask[iVol][:, -1, :] = True\n coefMask[iVol][:, -2, :] = True\n if \"kLow\" in faceFreeze[key]:\n coefMask[iVol][:, :, 0] = True\n coefMask[iVol][:, :, 1] = True\n if \"kHigh\" in faceFreeze[key]:\n coefMask[iVol][:, :, -1] = True\n coefMask[iVol][:, :, -2] = True\n\n # Finally we need to convert coefMask to the flattened global\n # coef type:\n tmp = np.zeros(len(self.FFD.coef), dtype=bool)\n for iVol in range(self.FFD.nVol):\n for i in range(coefMask[iVol].shape[0]):\n for j in range(coefMask[iVol].shape[1]):\n for k in range(coefMask[iVol].shape[2]):\n ind = self.FFD.topo.lIndex[iVol][i, j, k]\n if coefMask[iVol][i, j, k]:\n tmp[ind] = True\n self.masks = tmp\n\n def addRefAxis(\n self,\n name,\n curve=None,\n xFraction=None,\n yFraction=None,\n zFraction=None,\n volumes=None,\n rotType=5,\n axis=\"x\",\n alignIndex=None,\n rotAxisVar=None,\n rot0ang=None,\n rot0axis=[1, 0, 0],\n xFractionOrder=2,\n includeVols=[],\n ignoreInd=[],\n raySize=1.5,\n ):\n \"\"\"\n This function is used to add a 'reference' axis to the\n DVGeometry object. Adding a reference axis is only required\n when 'global' design variables are to be used, i.e. variables\n like span, sweep, chord etc --- variables that affect many FFD\n control points.\n\n There are two different ways that a reference can be\n specified:\n\n #. The first is explicitly a pySpline curve object using the\n keyword argument curve=.\n\n #. The second is to specify the xFraction variable. There are a\n few caveats with the use of this method. First, DVGeometry\n will try to determine automatically the orientation of the FFD\n volume. Then, a reference axis will consist of the same number of\n control points as the number of span-wise sections in the FFD volume\n and will be oriented in the streamwise (x-direction) according to the\n xPercent keyword argument.\n\n Parameters\n ----------\n name : str\n Name of the reference axis. This name is used in the\n user-supplied design variable functions to determine what\n axis operations occur on.\n\n curve : pySpline curve object\n Supply exactly the desired reference axis\n\n xFraction : float\n Specify the stream-wise extent\n\n volumes : list or array or integers\n List of the volume indices, in 0-based ordering that this\n reference axis should manipulate. If xFraction is\n specified, the volumes argument must contain at most 1\n volume. If the volumes is not given, then all volumes are\n taken.\n\n rotType : int\n Integer in range 0->6 (inclusive) to determine the order\n that the rotations are made.\n\n 0. Intrinsic rotation, rot_theta is rotation about axis\n 1. x-y-z\n 2. x-z-y\n 3. y-z-x\n 4. y-x-z\n 5. z-x-y Default (x-streamwise y-up z-out wing)\n 6. z-y-x\n 7. z-x-y + rot_theta\n 8. z-x-y + rotation about section axis (to allow for winglet rotation)\n\n axis: str\n Axis along which to project points/control points onto the\n ref axis. Default is `x` which will project rays.\n\n alignIndex: str\n FFD axis along which the reference axis will lie. Can be `i`, `j`,\n or `k`. Only necessary when using xFraction.\n\n rotAxisVar: str\n If rotType == 8, then you must specify the name of the section local\n variable which should be used to compute the orientation of the theta\n rotation.\n\n rot0ang: float\n If rotType == 0, defines the offset angle of the (child) FFD with respect\n to the main system of reference. This is necessary to use the scaling functions\n `scale_x`, `scale_y`, and `scale_z` with rotType == 0. The axis of rotation is\n defined by `rot0axis`.\n\n rot0axis: list\n If rotType == 0, defines the rotation axis for the rotation offset of the\n FFD grid given by `rot0ang`. The variable has to be a list of 3 floats\n defining the [x,y,z] components of the axis direction.\n This is necessary to use the scaling functions `scale_x`, `scale_y`,\n and `scale_z` with rotType == 0.\n\n xFractionOrder : int (NOT USED?)\n Order of spline used for refaxis curve.\n\n includeVols : list\n List of additional volumes to add to reference axis after the\n automatic generation of the ref axis based on the volumes list using\n xFraction.\n\n ignoreInd : list\n List of indices that should be ignored from the volumes that were\n added to this reference axis. This can be handy if you have a single\n volume but you want to link different sets of indices to different\n reference axes.\n\n raySize : float\n Used in projection to find attachment point on reference axis.\n See full description in pyNetwork.projectRays function doc string.\n In most cases the default value is sufficient. In the case of highly\n swept wings its sometimes necessary to increase this value.\n\n Notes\n -----\n One of curve or xFraction must be specified.\n\n Examples\n --------\n >>> # Simple wing with single volume FFD, reference axis at 1/4 chord:\n >>> DVGeo.addRefAxis('wing', xFraction=0.25)\n >>> # Multiblock FFD, wing is volume 6.\n >>> DVGeo.addRefAxis('wing', xFraction=0.25, volumes=[6])\n >>> # Multiblock FFD, multiple volumes attached refAxis\n >>> DVGeo.addRefAxis('wing', myCurve, volumes=[2,3,4])\n\n Returns\n -------\n nAxis : int\n The number of control points on the reference axis.\n \"\"\"\n\n # We don't do any of the final processing here; we simply\n # record the information the user has supplied into a\n # dictionary structure.\n if axis is None:\n pass\n elif axis.lower() == \"x\":\n axis = np.array([1, 0, 0], \"d\")\n elif axis.lower() == \"y\":\n axis = np.array([0, 1, 0], \"d\")\n elif axis.lower() == \"z\":\n axis = np.array([0, 0, 1], \"d\")\n\n if curve is not None:\n # Explicit curve has been supplied:\n if self.FFD.symmPlane is None:\n if volumes is None:\n volumes = np.arange(self.FFD.nVol)\n self.axis[name] = {\n \"curve\": curve,\n \"volumes\": volumes,\n \"rotType\": rotType,\n \"axis\": axis,\n \"rot0ang\": rot0ang,\n \"rot0axis\": rot0axis,\n }\n\n else:\n # get the direction of the symmetry plane\n if self.FFD.symmPlane.lower() == \"x\":\n index = 0\n elif self.FFD.symmPlane.lower() == \"y\":\n index = 1\n elif self.FFD.symmPlane.lower() == \"z\":\n index = 2\n\n # mirror the axis and attach the mirrored vols\n if volumes is None:\n volumes = np.arange(self.FFD.nVol / 2)\n\n volumesSymm = []\n for volume in volumes:\n volumesSymm.append(volume + self.FFD.nVol / 2)\n\n curveSymm = copy.deepcopy(curve)\n curveSymm.reverse()\n for coef in curveSymm.coef:\n curveSymm.coef[:, index] = -curveSymm.coef[:, index]\n self.axis[name] = {\n \"curve\": curve,\n \"volumes\": volumes,\n \"rotType\": rotType,\n \"axis\": axis,\n \"rot0ang\": rot0ang,\n \"rot0axis\": rot0axis,\n }\n self.axis[name + \"Symm\"] = {\n \"curve\": curveSymm,\n \"volumes\": volumesSymm,\n \"rotType\": rotType,\n \"axis\": axis,\n \"rot0ang\": rot0ang,\n \"rot0axis\": rot0axis,\n }\n nAxis = len(curve.coef)\n elif xFraction or yFraction or zFraction:\n # Some assumptions\n # - FFD should be a close approximation of geometry surface so that\n # xFraction roughly corresponds to airfoil LE, TE, or 1/4 chord\n # - User provides 'i', 'j' or 'k' to specify which block direction\n # the reference axis should project\n # - if no volumes are listed, it is assumed that all volumes are\n # included\n # - 'x' is streamwise direction\n\n # Default to \"mean\" ref axis location along non-user specified direction\n\n # This is the block direction along which the reference axis will lie\n # alignIndex = 'k'\n if alignIndex is None:\n raise Error(\"Must specify alignIndex to use xFraction.\")\n\n # Get index direction along which refaxis will be aligned\n if alignIndex.lower() == \"i\":\n alignIndex = 0\n faceCol = 2\n elif alignIndex.lower() == \"j\":\n alignIndex = 1\n faceCol = 4\n elif alignIndex.lower() == \"k\":\n alignIndex = 2\n faceCol = 0\n\n if volumes is None:\n volumes = range(self.FFD.nVol)\n\n # Reorder the volumes in sequential order and check if orientation is correct\n v = list(volumes)\n nVol = len(v)\n volOrd = [v.pop(0)]\n faceLink = self.FFD.topo.faceLink\n for iter in range(nVol):\n for vInd, i in enumerate(v):\n for pInd, j in enumerate(volOrd):\n if faceLink[i, faceCol] == faceLink[j, faceCol + 1]:\n volOrd.insert(pInd + 1, v.pop(vInd))\n break\n elif faceLink[i, faceCol + 1] == faceLink[j, faceCol]:\n volOrd.insert(pInd, v.pop(vInd))\n break\n\n if len(volOrd) < nVol:\n raise Error(\n \"The volumes are not ordered with matching faces\" \" in the direction of the reference axis.\"\n )\n\n # Count total number of sections and check if volumes are aligned\n # face to face along refaxis direction\n lIndex = self.FFD.topo.lIndex\n nSections = []\n for i in range(len(volOrd)):\n if i == 0:\n nSections.append(lIndex[volOrd[i]].shape[alignIndex])\n else:\n nSections.append(lIndex[volOrd[i]].shape[alignIndex] - 1)\n\n refaxisNodes = np.zeros((sum(nSections), 3))\n\n # Loop through sections and compute node location\n place = 0\n for j, vol in enumerate(volOrd):\n # sectionArr: indices of FFD points grouped by section\n sectionArr = np.rollaxis(lIndex[vol], alignIndex, 0)\n skip = 0\n if j > 0:\n skip = 1\n for i in range(nSections[j]):\n # getting all the section control points coordinates\n pts_tens = self.FFD.coef[sectionArr[i + skip, :, :], :] # shape=(xAxisNodes,yAxisnodes,3)\n\n # reshaping into vector to allow rotation (if needed) - leveraging on pts_tens.shape[2]=3 (FFD cp coordinates)\n pts_vec = np.copy(pts_tens.reshape(-1, 3)) # new shape=(xAxisNodes*yAxisnodes,3)\n\n if rot0ang:\n # rotating the FFD to be aligned with main axes\n for ct_ in range(np.shape(pts_vec)[0]):\n # here we loop over the pts_vec, rotate them and insert them inplace in pts_vec again\n p_ = np.copy(pts_vec[ct_, :])\n p_rot = geo_utils.rotVbyW(p_, rot0axis, np.pi / 180 * (rot0ang))\n pts_vec[ct_, :] = p_rot\n\n # Temporary ref axis node coordinates - aligned with main system of reference\n if xFraction:\n # getting the bounds of the FFD section\n x_min = np.min(pts_vec[:, 0])\n x_max = np.max(pts_vec[:, 0])\n x_node = xFraction * (x_max - x_min) + x_min # chordwise\n else:\n x_node = np.mean(pts_vec[:, 0])\n\n if yFraction:\n y_min = np.min(pts_vec[:, 1])\n y_max = np.max(pts_vec[:, 1])\n y_node = y_max - yFraction * (y_max - y_min) # top-bottom\n else:\n y_node = np.mean(pts_vec[:, 1])\n\n if zFraction:\n z_min = np.min(pts_vec[:, 2])\n z_max = np.max(pts_vec[:, 2])\n z_node = z_max - zFraction * (z_max - z_min) # top-bottom\n else:\n z_node = np.mean(pts_vec[:, 2])\n\n # This is the FFD ref axis node - if the block has not been rotated\n nd = [x_node, y_node, z_node]\n nd_final = np.copy(nd)\n\n if rot0ang:\n # rotating the non-aligned FFDs back in position\n nd_final[:] = geo_utils.rotVbyW(nd, rot0axis, np.pi / 180 * (-rot0ang))\n\n # insert the final coordinates in the var to be passed to pySpline:\n refaxisNodes[place + i, 0] = nd_final[0]\n refaxisNodes[place + i, 1] = nd_final[1]\n refaxisNodes[place + i, 2] = nd_final[2]\n\n place += i + 1\n\n # Add additional volumes\n for iVol in includeVols:\n if iVol not in volumes:\n volumes.append(iVol)\n\n # Generate reference axis pySpline curve\n curve = Curve(X=refaxisNodes, k=2)\n nAxis = len(curve.coef)\n self.axis[name] = {\n \"curve\": curve,\n \"volumes\": volumes,\n \"rotType\": rotType,\n \"axis\": axis,\n \"rot0ang\": rot0ang,\n \"rot0axis\": rot0axis,\n \"rotAxisVar\": rotAxisVar,\n }\n else:\n raise Error(\"One of 'curve' or 'xFraction' must be \" \"specified for a call to addRefAxis\")\n\n # Specify indices to be ignored\n self.axis[name][\"ignoreInd\"] = ignoreInd\n\n # Add the raySize multiplication factor for this axis\n self.axis[name][\"raySize\"] = raySize\n\n return nAxis\n\n def addPointSet(self, points, ptName, origConfig=True, **kwargs):\n \"\"\"\n Add a set of coordinates to DVGeometry\n\n The is the main way that geometry, in the form of a coordinate\n list is given to DVGeoemtry to be manipulated.\n\n Parameters\n ----------\n points : array, size (N,3)\n The coordinates to embed. These cordinates *should* all\n project into the interior of the FFD volume.\n ptName : str\n A user supplied name to associate with the set of\n coordinates. This name will need to be provided when\n updating the coordinates or when getting the derivatives\n of the coordinates.\n origConfig : bool\n Flag determine if the coordinates are projected into the\n undeformed or deformed configuration. This should almost\n always be True except in circumstances when the user knows\n exactly what they are doing.\"\"\"\n\n # save this name so that we can zero out the jacobians properly\n self.ptSetNames.append(ptName)\n self.zeroJacobians([ptName])\n self.nPts[ptName] = None\n\n points = np.array(points).real.astype(\"d\")\n self.points[ptName] = points\n\n # Ensure we project into the undeformed geometry\n if origConfig:\n tmpCoef = self.FFD.coef.copy()\n self.FFD.coef = self.origFFDCoef\n self.FFD._updateVolumeCoef()\n\n # Project the last set of points into the volume\n if self.isChild:\n self.FFD.attachPoints(self.points[ptName], ptName, interiorOnly=True, **kwargs)\n else:\n self.FFD.attachPoints(self.points[ptName], ptName, interiorOnly=False)\n\n if origConfig:\n self.FFD.coef = tmpCoef\n self.FFD._updateVolumeCoef()\n\n # Now embed into the children:\n for child in self.children:\n child.addPointSet(points, ptName, origConfig, **kwargs)\n\n self.FFD.calcdPtdCoef(ptName)\n self.updated[ptName] = False\n\n def addChild(self, childDVGeo):\n \"\"\"Embed a child FFD into this object.\n\n An FFD child is a 'sub' FFD that is fully contained within\n another, parent FFD. A child FFD is also an instance of\n DVGeometry which may have its own global and/or local design\n variables. Coordinates do **not** need to be added to the\n children. The parent object will take care of that in a call\n to addPointSet().\n\n See https://github.com/mdolab/pygeo/issues/7 for a description of an\n issue with Child FFDs that you should be aware of if you are combining\n shape changes of a parent FFD with rotation or shape changes of a child FFD.\n\n Parameters\n ----------\n childDVGeo : instance of DVGeometry\n DVGeo object to use as a sub-FFD\n \"\"\"\n\n # Make sure the DVGeo being added is flaged as a child:\n if childDVGeo.isChild is False:\n raise Error(\"Trying to add a child FFD that has NOT been \" \"created as a child. This operation is illegal.\")\n\n # Extract the coef from the child FFD and ref axis and embed\n # them into the parent and compute their derivatives\n iChild = len(self.children)\n childDVGeo.iChild = iChild\n\n self.FFD.attachPoints(childDVGeo.FFD.coef, \"child%d_coef\" % (iChild))\n self.FFD.calcdPtdCoef(\"child%d_coef\" % (iChild))\n\n # We must finalize the Child here since we need the ref axis\n # coefficients\n childDVGeo._finalizeAxis()\n self.FFD.attachPoints(childDVGeo.refAxis.coef, \"child%d_axis\" % (iChild))\n self.FFD.calcdPtdCoef(\"child%d_axis\" % (iChild))\n\n # Add the child to the parent and return\n self.children.append(childDVGeo)\n\n def addGlobalDV(self, dvName, value, func, lower=None, upper=None, scale=1.0, config=None):\n \"\"\"\n Add a global design variable to the DVGeometry object. This\n type of design variable acts on one or more reference axis.\n\n Parameters\n ----------\n dvName : str\n A unique name to be given to this design variable group\n\n value : float, or iterable list of floats\n The starting value(s) for the design variable. This\n parameter may be a single variable or a numpy array\n (or list) if the function requires more than one\n variable. The number of variables is determined by the\n rank (and if rank ==1, the length) of this parameter.\n\n lower : float, or iterable list of floats\n The lower bound(s) for the variable(s). A single variable\n is permissable even if an array is given for value. However,\n if an array is given for 'lower', it must be the same length\n as 'value'\n\n func : python function\n The python function handle that will be used to apply the\n design variable\n\n upper : float, or iterable list of floats\n The upper bound(s) for the variable(s). Same restrictions as\n 'lower'\n\n scale : float, or iterable list of floats\n The scaling of the variables. A good approximate scale to\n start with is approximately 1.0/(upper-lower). This gives\n variables that are of order ~1.0.\n\n config : str or list\n Define what configurations this design variable will be applied to\n Use a string for a single configuration or a list for multiple\n configurations. The default value of None implies that the design\n variable appies to *ALL* configurations.\n \"\"\"\n # if the parent DVGeometry object has a name attribute, prepend it\n if self.name is not None:\n dvName = self.name + \"_\" + dvName\n\n if type(config) == str:\n config = [config]\n self.DV_listGlobal[dvName] = geoDVGlobal(dvName, value, lower, upper, scale, func, config)\n\n def addGeoDVGlobal(self, *args, **kwargs):\n warnings.warn(\"addGeoDVGlobal will be deprecated, use addGlobalDV instead\")\n self.addGlobalDV(*args, **kwargs)\n\n def addLocalDV(\n self, dvName, lower=None, upper=None, scale=1.0, axis=\"y\", volList=None, pointSelect=None, config=None\n ):\n \"\"\"\n Add one or more local design variables ot the DVGeometry\n object. Local variables are used for small shape modifications.\n\n Parameters\n ----------\n dvName : str\n A unique name to be given to this design variable group\n\n lower : float\n The lower bound for the variable(s). This will be applied to\n all shape variables\n\n upper : float\n The upper bound for the variable(s). This will be applied to\n all shape variables\n\n scale : flot\n The scaling of the variables. A good approximate scale to\n start with is approximately 1.0/(upper-lower). This gives\n variables that are of order ~1.0.\n\n axis : str. Default is `y`\n The coordinate directions to move. Permissible values are `x`,\n `y` and `z`. If more than one direction is required, use multiple\n calls to addLocalDV with different axis values.\n\n volList : list\n Use the control points on the volume indicies given in volList.\n You should use pointSelect = None, otherwise this will not work.\n\n pointSelect : pointSelect object. Default is None Use a\n pointSelect object to select a subset of the total number\n of control points. See the documentation for the\n pointSelect class in geo_utils. Using pointSelect discards everything in\n volList.\n\n config : str or list\n Define what configurations this design variable will be applied to\n Use a string for a single configuration or a list for multiple\n configurations. The default value of None implies that the design\n variable appies to *ALL* configurations.\n\n Returns\n -------\n N : int\n The number of design variables added.\n\n Examples\n --------\n >>> # Add all variables in FFD as local shape variables\n >>> # moving in the y direction, within +/- 1.0 units\n >>> DVGeo.addLocalDV('shape_vars', lower=-1.0, upper= 1.0, axis='y')\n >>> # As above, but moving in the x and y directions.\n >>> nVar = DVGeo.addLocalDV('shape_vars_x', lower=-1.0, upper= 1.0, axis='x')\n >>> nVar = DVGeo.addLocalDV('shape_vars_y', lower=-1.0, upper= 1.0, axis='y')\n >>> # Create a point select to use: (box from (0,0,0) to (10,0,10) with\n >>> # any point projecting into the point along 'y' axis will be selected.\n >>> PS = geo_utils.PointSelect(type = 'y', pt1=[0,0,0], pt2=[10, 0, 10])\n >>> nVar = DVGeo.addLocalDV('shape_vars', lower=-1.0, upper=1.0, pointSelect=PS)\n \"\"\"\n if self.name is not None:\n dvName = self.name + \"_\" + dvName\n\n if type(config) == str:\n config = [config]\n\n if pointSelect is not None:\n if pointSelect.type != \"ijkBounds\":\n pts, ind = pointSelect.getPoints(self.FFD.coef)\n else:\n pts, ind = pointSelect.getPoints_ijk(self)\n elif volList is not None:\n if self.FFD.symmPlane is not None:\n volListTmp = []\n for vol in volList:\n volListTmp.append(vol)\n for vol in volList:\n volListTmp.append(vol + self.FFD.nVol / 2)\n volList = volListTmp\n\n volList = np.atleast_1d(volList).astype(\"int\")\n ind = []\n for iVol in volList:\n ind.extend(self.FFD.topo.lIndex[iVol].flatten())\n ind = geo_utils.unique(ind)\n else:\n # Just take'em all\n ind = np.arange(len(self.FFD.coef))\n\n self.DV_listLocal[dvName] = geoDVLocal(dvName, lower, upper, scale, axis, ind, self.masks, config)\n\n return self.DV_listLocal[dvName].nVal\n\n def addGeoDVLocal(self, *args, **kwargs):\n warnings.warn(\"addGeoDVLocal will be deprecated, use addLocalDV instead\")\n self.addLocalDV(*args, **kwargs)\n\n def addSpanwiseLocalDV(\n self,\n dvName,\n spanIndex,\n axis=\"y\",\n lower=None,\n upper=None,\n scale=1.0,\n pointSelect=None,\n volList=None,\n config=None,\n ):\n \"\"\"\n Add one or more spanwise local design variables to the DVGeometry\n object. Spanwise local variables are alternative form of local shape\n variables used to apply equal DV changes in a chosen direction.\n Some scenarios were this could be useful are:\n\n 1. 2D airfoil shape optimization. Because adflow works with 3D meshes,\n 2D problems are represented my a mesh a single cell wide. Therefor,\n to change the 2D representation of the airfoil both sides of the\n mesh must be moved equally. This can be done with the addition of\n linear constraints on a set of local shape variables, however this\n approach requires more DVs than necessary (which complicates DV\n sweeps) and the constaints are only enforced to a tolerance. Using\n spanwise local design variables insures the airfoil is always\n correctly represented in the 3D mesh using the correct amount of\n design variables.\n\n 2. 3D wing optimization with constant airfoil shape. If the initial\n wing geometry has a constant airfoil shape and constant chord, then\n spanwise local dvs can be used to change the airfoil shape of the\n wing while still keeping it constant along the span of the wing.\n\n Parameters\n ----------\n dvName : str\n A unique name to be given to this design variable group\n\n spanIndex : str, ('i', 'j', 'k')\n the axis of the FFD along which the DVs are constant\n all shape variables\n\n axis : str. Default is `y`\n The coordinate directions to move. Permissible values are `x`,\n `y` and `z`. If more than one direction is required, use multiple\n calls to addLocalDV with different axis values.\n\n lower : float\n The lower bound for the variable(s). This will be applied to\n all shape variables\n\n upper : float\n The upper bound for the variable(s). This will be applied to\n all shape variables\n\n scale : flot\n The scaling of the variables. A good approximate scale to\n start with is approximately 1.0/(upper-lower). This gives\n variables that are of order ~1.0.\n\n pointSelect : pointSelect object. Default is None Use a\n pointSelect object to select a subset of the total number\n of control points. See the documentation for the\n pointSelect class in geo_utils. Using pointSelect discards everything in\n volList.\n\n volList : list\n Use the control points on the volume indicies given in volList.\n You should use pointSelect = None, otherwise this will not work.\n\n config : str or list\n Define what configurations this design variable will be applied to\n Use a string for a single configuration or a list for multiple\n configurations. The default value of None implies that the design\n variable applies to *ALL* configurations.\n\n Returns\n -------\n N : int\n The number of design variables added.\n\n Examples\n --------\n >>> # Add all spanwise local variables\n >>> # moving in the y direction, within +/- 0.5 units\n >>> DVGeo.addSpanwiseLocalDV(\"shape\", 'k', lower=-0.5, upper=0.5, axis=\"z\", scale=1.0)\n \"\"\"\n if type(config) == str:\n config = [config]\n\n if pointSelect is not None:\n if pointSelect.type != \"ijkBounds\":\n pts, ind = pointSelect.getPoints(self.FFD.coef)\n else:\n pts, ind = pointSelect.getPoints_ijk(self)\n elif volList is not None:\n if self.FFD.symmPlane is not None:\n volListTmp = []\n for vol in volList:\n volListTmp.append(vol)\n for vol in volList:\n volListTmp.append(vol + self.FFD.nVol / 2)\n volList = volListTmp\n\n volList = np.atleast_1d(volList).astype(\"int\")\n ind = []\n for iVol in volList:\n ind.extend(self.FFD.topo.lIndex[iVol].flatten())\n ind = geo_utils.unique(ind)\n else:\n # Just take'em all\n volList = np.arange(self.FFD.nVol)\n ind = np.arange(len(self.FFD.coef))\n\n # secLink = np.zeros(self.FFD.coef.shape[0], dtype=int)\n # secTransform = [np.eye(3)]\n\n if type(spanIndex) is str:\n spanIndex = [spanIndex] * len(volList)\n elif type(spanIndex) is list:\n if len(spanIndex) != len(volList):\n raise Error(\"If a list is given for spanIndex, the length must be\" \" equal to the length of volList.\")\n\n ijk_2_idx = {\"i\": 0, \"j\": 1, \"k\": 2}\n\n volDVMap = []\n for ivol in volList:\n\n spanIdx = ijk_2_idx[spanIndex[ivol]]\n lIndex = self.FFD.topo.lIndex[ivol]\n\n topo_shape = lIndex.shape\n\n # remove the span axis since all dv in that axis are linked\n n_linked_coef = topo_shape[spanIdx]\n dvs_shape = np.delete(topo_shape, spanIdx)\n\n # get total number of dvs\n n_dvs = np.product(dvs_shape)\n\n # make a map from dvs to the ind that are controlled by that dv.\n # (phrased another way) map from dv to all ind in the same span size position\n dv_to_coef_ind = np.zeros((n_dvs, n_linked_coef), dtype=\"intc\")\n\n # slice lIndex to get the indices of the coeffs that are in the same\n # spanwise position\n dv_idx = 0\n for i in range(dvs_shape[0]):\n for j in range(dvs_shape[1]):\n # no need to use fancy axis manipulation, since it doesn't need\n # to be fast and if statements are expressive\n if spanIndex[ivol] == \"i\":\n coef_ind = lIndex[:, i, j]\n elif spanIndex[ivol] == \"j\":\n coef_ind = lIndex[i, :, j]\n elif spanIndex[ivol] == \"k\":\n coef_ind = lIndex[i, j, :]\n\n dv_to_coef_ind[dv_idx] = coef_ind\n dv_idx += 1\n\n # the for this volume is complete and can be added to the list of maps\n volDVMap.append(dv_to_coef_ind)\n\n self.DV_listSpanwiseLocal[dvName] = geoDVSpanwiseLocal(\n dvName, lower, upper, scale, axis, volDVMap, self.masks, config\n )\n\n return self.DV_listSpanwiseLocal[dvName].nVal\n\n def addGeoDVSpanwiseLocal(self, *args, **kwargs):\n warnings.warn(\"addGeoDVSpanwiseLocal will be deprecated, use addSpanwiseLocalDV instead\")\n self.addSpanwiseLocalDV(*args, **kwargs)\n\n def addLocalSectionDV(\n self,\n dvName,\n secIndex,\n lower=None,\n upper=None,\n scale=1.0,\n axis=1,\n pointSelect=None,\n volList=None,\n orient0=None,\n orient2=\"svd\",\n config=None,\n ):\n \"\"\"\n Add one or more section local design variables to the DVGeometry\n object. Section local variables are used as an alternative to local\n variables when it is desirable to deform a cross-section shape within a\n plane that is consistent with the original cross-section orientation.\n This is helpful in at least two common scenarios:\n\n 1. The original geometry has cross-sections that are not aligned with\n the global coordinate axes. For instance, with a winglet, we want\n the shape variables to deform normal to the winglet surface\n instead of in the x, y, or z directions.\n 2. The global design variables cause changes in the geometry that\n rotate the orientation of the original cross-section planes. In\n this case, we want the shape variables to deform in directions\n aligned with the rotated cross-section plane, which may not be\n the x, y, or z directions.\n\n ** Warnings **\n - Rotations in an upper level (parent) FFD will not propagate down\n to the lower level FFDs due to limitations of the current\n implementation.\n - Section local design variables should not be specified at the same\n time as local design variables. This will most likely not result\n in the desired behavior.\n\n Parameters\n ----------\n dvName : str\n A unique name to be given to this design variable group\n\n lower : float\n The lower bound for the variable(s). This will be applied to\n all shape variables\n\n upper : float\n The upper bound for the variable(s). This will be applied to\n all shape variables\n\n scale : flot\n The scaling of the variables. A good approximate scale to\n start with is approximately 1.0/(upper-lower). This gives\n variables that are of order ~1.0.\n\n axis : int\n The coordinate directions to move. Permissible values are\n 0: longitudinal direction (in section plane)\n 1: latitudinal direction (in section plane)\n 2: transverse direction (out of section plane)\n\n If more than one direction is required, use multiple calls to\n `addLocalSectionDV` with different axis values.\n ::\n\n 1\n ^\n |\n o-----o--------o----|----o--------o--------o-----o\n | | | j\n | x---------> 0 | ^\n | / | |\n o-----o--------o--/------o--------o--------o-----o\n / ----> i\n /\n 2\n\n pointSelect : pointSelect object. Default is None\n Use a pointSelect object to select a subset of the total number\n of control points. See the documentation for the pointSelect\n class in geo_utils. Using pointSelect discards everything in volList.\n You can create a PointSelect object by using, for instance:\n >>> PS = geo_utils.PointSelect(type = `y`, pt1=[0,0,0], pt2=[10, 0, 10])\n Check the other PointSelect options in geo_utils.py\n\n volList : list\n Use the control points on the volume indicies given in volList. If\n None, all volumes will be included.\n PointSelect has priority over volList. So if you use PointSelect, the values\n defined in volList will have no effect.\n\n secIndex : char or list of chars\n For each volume, we need to specify along which index we would like\n to subdivide the volume into sections. Entries in list can be `i`,\n `j`, or `k`. This index will be designated as the transverse (2)\n direction in terms of the direction of perturbation for the 'axis'\n parameter.\n\n orient0 : None, `i`, `j`, `k`, or numpy vector. Default is None.\n Although secIndex defines the `2` axis, the `0` and `1` axes are still\n free to rotate within the section plane. We will choose the orientation\n of the `0` axis and let `1` be orthogonal. We have three options:\n\n 1. (default) If nothing is prescribed, the `0` direction will\n be the best fit line through the section points. In the case\n of an airfoil, this would roughly align with the chord.\n 2. <`i`,`j` or `k`> In this case, the `0` axis will be aligned\n with the mean vector between the FFD edges corresponding to\n this index. In the ascii art above, if `j` were given for this\n option, we would average the vectors between the points on the\n top and bottom surfaces and project this vector on to the\n section plane as the `0` axis. If a list is given, each index\n will be applied to its corresponding volume in volList.\n 3. <[`x`, `y`, `z`]> If a numpy vector is given, the `0` axis\n will be aligned with a projection of this vector onto the\n section plane. If a numpy array of len(volList) x 3 is given,\n each vector will apply to its corresponding volume.\n\n orient2 : `svd` or `ffd`. Default is `svd`\n How to compute the orientation `2` axis. SVD is the\n default bevaviour and is taken from the svd of the plane\n points. `ffd` Uses the vector along the FFD direction of\n secIndex. This is requied to get consistent normals if you\n have a circular-type FFD when the SVD will swap the\n normals.\n\n config : str or list\n Define what configurations this design variable will be applied to\n Use a string for a single configuration or a list for multiple\n configurations. The default value of None implies that the design\n variable appies to *ALL* configurations.\n\n Returns\n -------\n N : int\n The number of design variables added.\n\n Examples\n --------\n >>> # Add all control points in FFD as local shape variables\n >>> # moving in the 1 direction, within +/- 1.0 units\n >>> DVGeo.addLocalSectionDV('shape_vars', secIndex='k', lower=-1, upper=1, axis=1)\n \"\"\"\n if self.name is not None:\n dvName = self.name + \"_\" + dvName\n\n if type(config) == str:\n config = [config]\n\n # Pick out control points\n if pointSelect is not None:\n if pointSelect.type != \"ijkBounds\":\n pts, ind = pointSelect.getPoints(self.FFD.coef)\n volList = np.arange(self.FFD.nVol) # Select all volumes\n else:\n pts, ind = pointSelect.getPoints_ijk(self)\n volList = pointSelect.ijkBounds.keys() # Select only volumes used by pointSelect\n elif volList is not None:\n if self.FFD.symmPlane is not None:\n volListTmp = []\n for vol in volList:\n volListTmp.append(vol)\n for vol in volList:\n volListTmp.append(vol + self.FFD.nVol / 2)\n volList = volListTmp\n\n volList = np.atleast_1d(volList).astype(\"int\")\n ind = []\n for iVol in volList:\n ind.extend(self.FFD.topo.lIndex[iVol].flatten()) # Get all indices from this block\n ind = geo_utils.unique(ind)\n else:\n # Just take'em all\n volList = np.arange(self.FFD.nVol)\n ind = np.arange(len(self.FFD.coef))\n\n secLink = np.zeros(self.FFD.coef.shape[0], dtype=int)\n secTransform = [np.eye(3)]\n\n if type(secIndex) is str:\n secIndex = [secIndex] * len(volList)\n elif type(secIndex) is list:\n if len(secIndex) != len(volList):\n raise Error(\"If a list is given for secIndex, the length must be\" \" equal to the length of volList.\")\n\n if orient0 is not None:\n # 'i', 'j', or 'k'\n if type(orient0) is str:\n orient0 = [orient0] * len(volList)\n # ['k', 'k', 'i', etc.]\n elif type(orient0) is list:\n if len(orient0) != len(volList):\n raise Error(\"If a list is given for orient0, the length must\" \" be equal to the length of volList.\")\n # np.array([1.0, 0.0, 0.0])\n elif type(orient0) is np.ndarray:\n # vector\n if len(orient0.shape) == 1:\n orient0 = np.reshape(orient0, (1, 3))\n orient0 = np.repeat(orient0, len(volList), 0)\n elif orient0.shape[0] == 1:\n orient0 = np.repeat(orient0, len(volList), 0)\n elif orient0.shape[0] != len(volList):\n raise Error(\n \"If an array is given for orient0, the row dimension\" \" must be equal to the length of volList.\"\n )\n for i, iVol in enumerate(volList):\n self.sectionFrame(secIndex[i], secTransform, secLink, iVol, orient0[i], orient2=orient2)\n else:\n for i, iVol in enumerate(volList):\n self.sectionFrame(secIndex[i], secTransform, secLink, iVol, orient2=orient2)\n\n self.DV_listSectionLocal[dvName] = geoDVSectionLocal(\n dvName, lower, upper, scale, axis, ind, self.masks, config, secTransform, secLink\n )\n\n return self.DV_listSectionLocal[dvName].nVal\n\n def addGeoDVSectionLocal(self, *args, **kwargs):\n warnings.warn(\"addGeoDVSectionLocal will be deprecated, use addLocalSectionDV instead\")\n self.addLocalSectionDV(*args, **kwargs)\n\n def getSymmetricCoefList(self, volList=None, pointSelect=None, tol=1e-8):\n \"\"\"\n Determine the pairs of coefs that need to be constrained for symmetry.\n\n Parameters\n ----------\n volList : list\n Use the control points on the volume indicies given in volList\n\n pointSelect : pointSelect object. Default is None Use a\n pointSelect object to select a subset of the total number\n of control points. See the documentation for the\n pointSelect class in geo_utils.\n tol : float\n Tolerance for ignoring nodes around the symmetry plane. These should be\n merged by the network/connectivity anyway\n\n Returns\n -------\n indSetA : list of ints\n One half of the coefs to be constrained\n\n indSetB : list of ints\n Other half of the coefs to be constrained\n\n Examples\n --------\n\n \"\"\"\n\n if self.FFD.symmPlane is None:\n # nothing to be done\n indSetA = []\n indSetB = []\n else:\n # get the direction of the symmetry plane\n if self.FFD.symmPlane.lower() == \"x\":\n index = 0\n elif self.FFD.symmPlane.lower() == \"y\":\n index = 1\n elif self.FFD.symmPlane.lower() == \"z\":\n index = 2\n\n # get the points to be matched up\n if pointSelect is not None:\n pts, ind = pointSelect.getPoints(self.FFD.coef)\n elif volList is not None:\n volListTmp = []\n for vol in volList:\n volListTmp.append(vol)\n for vol in volList:\n volListTmp.append(vol + self.FFD.nVol / 2)\n volList = volListTmp\n\n volList = np.atleast_1d(volList).astype(\"int\")\n ind = []\n for iVol in volList:\n ind.extend(self.FFD.topo.lIndex[iVol].flatten())\n ind = geo_utils.unique(ind)\n pts = self.FFD.coef[ind]\n else:\n # Just take'em all\n ind = np.arange(len(self.FFD.coef))\n pts = self.FFD.coef\n\n # Create the base points for the KD tree search. We will take the abs\n # value of the symmetry direction, that way when we search we will get\n # back index pairs which is what we want.\n baseCoords = copy.copy(pts)\n baseCoords[:, index] = abs(baseCoords[:, index])\n\n # now use the baseCoords to create a KD tree\n try:\n from scipy.spatial import cKDTree\n except ImportError:\n raise Error(\"scipy.spatial \" \"must be available to use detect symmetry\")\n\n # Now make a KD-tree so we can use it to find the unique nodes\n tree = cKDTree(baseCoords)\n\n # Now search through the +ve half of the points, ignoring anything within\n # tol of the symmetry plane to find pairs\n indSetA = []\n indSetB = []\n for pt in pts:\n if pt[index] > tol:\n # Now find any matching nodes within tol. there should be 2 and\n # only 2 if the mesh is symmtric\n Ind = tree.query_ball_point(pt, tol) # should this be a separate tol\n if not (len(Ind) == 2):\n raise Error(\"more than 2 coefs found that match pt\")\n else:\n indSetA.append(Ind[0])\n indSetB.append(Ind[1])\n\n return indSetA, indSetB\n\n def setDesignVars(self, dvDict):\n \"\"\"\n Standard routine for setting design variables from a design\n variable dictionary.\n\n Parameters\n ----------\n dvDict : dict\n Dictionary of design variables. The keys of the dictionary\n must correspond to the design variable names. Any\n additional keys in the dfvdictionary are simply ignored.\n \"\"\"\n\n # Coefficients must be complexifed from here on if complex\n if self.complex:\n self._finalize()\n self._complexifyCoef()\n\n for key in dvDict:\n if key in self.DV_listGlobal:\n vals_to_set = np.atleast_1d(dvDict[key]).astype(\"D\")\n if len(vals_to_set) != self.DV_listGlobal[key].nVal:\n raise Error(\n \"Incorrect number of design variables \"\n \"for DV: %s.\\nExpecting %d variables and \"\n \"received %d variabes\" % (key, self.DV_listGlobal[key].nVal, len(vals_to_set))\n )\n\n self.DV_listGlobal[key].value = vals_to_set\n\n if key in self.DV_listLocal:\n vals_to_set = np.atleast_1d(dvDict[key]).astype(\"D\")\n if len(vals_to_set) != self.DV_listLocal[key].nVal:\n raise Error(\n \"Incorrect number of design variables \\\n for DV: %s.\\nExpecting %d variables and received \\\n %d variabes\"\n % (key, self.DV_listLocal[key].nVal, len(vals_to_set))\n )\n self.DV_listLocal[key].value = vals_to_set\n\n if key in self.DV_listSectionLocal:\n vals_to_set = np.atleast_1d(dvDict[key]).astype(\"D\")\n if len(vals_to_set) != self.DV_listSectionLocal[key].nVal:\n raise Error(\n \"Incorrect number of design variables \\\n for DV: %s.\\nExpecting %d variables and received \\\n %d variabes\"\n % (key, self.DV_listSectionLocal[key].nVal, len(vals_to_set))\n )\n self.DV_listSectionLocal[key].value = vals_to_set\n\n if key in self.DV_listSpanwiseLocal:\n vals_to_set = np.atleast_1d(dvDict[key]).astype(\"D\")\n if len(vals_to_set) != self.DV_listSpanwiseLocal[key].nVal:\n raise Error(\n \"Incorrect number of design variables \\\n for DV: %s.\\nExpecting %d variables and received \\\n %d variabes\"\n % (key, self.DV_listSpanwiseLocal[key].nVal, len(vals_to_set))\n )\n self.DV_listSpanwiseLocal[key].value = vals_to_set\n\n # Jacobians are, in general, no longer up to date\n self.zeroJacobians(self.ptSetNames)\n\n # Flag all the pointSets as not being up to date:\n for pointSet in self.updated:\n self.updated[pointSet] = False\n\n # Now call setValues on the children. This way the\n # variables will be set on the children\n for child in self.children:\n child.setDesignVars(dvDict)\n\n def zeroJacobians(self, ptSetNames):\n \"\"\"\n set stored jacobians to None for ptSetNames\n\n Parameters\n ----------\n ptSetNames : list\n list of ptSetNames to zero the jacobians.\n \"\"\"\n for name in ptSetNames:\n self.JT[name] = None # J is no longer up to date\n\n def getValues(self):\n \"\"\"\n Generic routine to return the current set of design\n variables. Values are returned in a dictionary format\n that would be suitable for a subsequent call to setValues()\n\n Returns\n -------\n dvDict : dict\n Dictionary of design variables\n \"\"\"\n\n dvDict = {}\n for key in self.DV_listGlobal:\n dvDict[key] = self.DV_listGlobal[key].value\n\n # and now the local DVs\n for key in self.DV_listLocal:\n dvDict[key] = self.DV_listLocal[key].value\n\n # and now the section local DVs\n for key in self.DV_listSectionLocal:\n dvDict[key] = self.DV_listSectionLocal[key].value\n\n # and now the Spanwise local DVs\n for key in self.DV_listSpanwiseLocal:\n dvDict[key] = self.DV_listSpanwiseLocal[key].value\n\n # Now call getValues on the children. This way the\n # returned dictionary will include the variables from\n # the children\n for child in self.children:\n childdvDict = child.getValues()\n dvDict.update(childdvDict)\n\n return dvDict\n\n def extractCoef(self, axisID):\n \"\"\"Extract the coefficients for the selected reference\n axis. This should be used only inside design variable functions\"\"\"\n\n axisNumber = self._getAxisNumber(axisID)\n C = np.zeros((len(self.refAxis.topo.lIndex[axisNumber]), 3), self.coef.dtype)\n\n C[:, 0] = np.take(self.coef[:, 0], self.refAxis.topo.lIndex[axisNumber])\n C[:, 1] = np.take(self.coef[:, 1], self.refAxis.topo.lIndex[axisNumber])\n C[:, 2] = np.take(self.coef[:, 2], self.refAxis.topo.lIndex[axisNumber])\n\n return C\n\n def restoreCoef(self, coef, axisID):\n \"\"\"Restore the coefficients for the selected reference\n axis. This should be used inside design variable functions\"\"\"\n\n # Reset\n axisNumber = self._getAxisNumber(axisID)\n np.put(self.coef[:, 0], self.refAxis.topo.lIndex[axisNumber], coef[:, 0])\n np.put(self.coef[:, 1], self.refAxis.topo.lIndex[axisNumber], coef[:, 1])\n np.put(self.coef[:, 2], self.refAxis.topo.lIndex[axisNumber], coef[:, 2])\n\n def extractS(self, axisID):\n \"\"\"Extract the parametric positions of the control\n points. This is usually used in conjunction with extractCoef()\"\"\"\n axisNumber = self._getAxisNumber(axisID)\n return self.refAxis.curves[axisNumber].s.copy()\n\n def _getAxisNumber(self, axisID):\n \"\"\"Get the sequential axis number from the name tag axisID\"\"\"\n try:\n return list(self.axis.keys()).index(axisID)\n except IndexError:\n raise Error(\"'The 'axisID' was invalid!\")\n\n def updateCalculations(self, new_pts, isComplex, config):\n \"\"\"\n The core update rountine. pulled out here to eliminate duplication between update and\n update_deriv.\n \"\"\"\n\n if self.isChild:\n # If this is a child, update the links between the ref axis and the\n # coefficients on the nested FFD now that the nested FFD has been\n # moved.\n # **Important**: this expects the FFD coef to be clean on this level,\n # meaning that the only changes to FFD.coef can be coming from\n # higher levels.\n\n # just use complex dtype here. we will convert to real in the end\n self.links_x = self.links_x.astype(\"D\")\n\n for ipt in range(self.nPtAttach):\n base_pt = self.refAxis.curves[self.curveIDs[ipt]](self.links_s[ipt])\n self.links_x[ipt] = self.FFD.coef[self.ptAttachInd[ipt], :] - base_pt\n\n # Run Global Design Vars\n for key in self.DV_listGlobal:\n self.DV_listGlobal[key](self, config)\n\n # update the reference axis now that the new global vars have been run\n self.refAxis.coef = self.coef.copy()\n self.refAxis._updateCurveCoef()\n\n for ipt in range(self.nPtAttach):\n base_pt = self.refAxis.curves[self.curveIDs[ipt]](self.links_s[ipt])\n # Variables for rotType = 0 rotation + scaling\n ang = self.axis[self.curveIDNames[ipt]][\"rot0ang\"]\n ax_dir = self.axis[self.curveIDNames[ipt]][\"rot0axis\"]\n\n scale = self.scale[self.curveIDNames[ipt]](self.links_s[ipt])\n scale_x = self.scale_x[self.curveIDNames[ipt]](self.links_s[ipt])\n scale_y = self.scale_y[self.curveIDNames[ipt]](self.links_s[ipt])\n scale_z = self.scale_z[self.curveIDNames[ipt]](self.links_s[ipt])\n\n rotType = self.axis[self.curveIDNames[ipt]][\"rotType\"]\n if rotType == 0:\n bp_ = np.copy(base_pt) # copy of original pointset - will not be rotated\n if isinstance(ang, (float, int)): # rotation active only if a non-default value is provided\n ang *= np.pi / 180 # conv to [rad]\n # Rotating the FFD according to inputs\n # The FFD points should now be aligned with the main system of reference\n base_pt = geo_utils.rotVbyW(bp_, ax_dir, ang)\n deriv = self.refAxis.curves[self.curveIDs[ipt]].getDerivative(self.links_s[ipt])\n deriv /= geo_utils.euclideanNorm(deriv) # Normalize\n new_vec = -np.cross(deriv, self.links_n[ipt])\n if isComplex:\n new_pts[ipt] = bp_ + new_vec * scale # using \"unrotated\" bp_ vector\n else:\n new_pts[ipt] = np.real(bp_ + new_vec * scale)\n\n if isinstance(ang, (float, int)):\n # Rotating to be aligned with main sys ref\n nv_ = np.copy(new_vec)\n new_vec = geo_utils.rotVbyW(nv_, ax_dir, ang)\n\n # Apply scaling\n new_vec[0] *= scale_x\n new_vec[1] *= scale_y\n new_vec[2] *= scale_z\n\n if isinstance(ang, (float, int)):\n # Rotating back the scaled pointset to its original position\n nv_rot = np.copy(new_vec) # nv_rot is scaled and rotated\n new_vec = geo_utils.rotVbyW(nv_rot, ax_dir, -ang)\n\n new_vec = geo_utils.rotVbyW(\n new_vec, deriv, self.rot_theta[self.curveIDNames[ipt]](self.links_s[ipt]) * np.pi / 180\n )\n\n if isComplex:\n new_pts[ipt] = bp_ + new_vec\n else:\n new_pts[ipt] = np.real(bp_ + new_vec)\n\n else:\n rotX = geo_utils.rotxM(self.rot_x[self.curveIDNames[ipt]](self.links_s[ipt]))\n rotY = geo_utils.rotyM(self.rot_y[self.curveIDNames[ipt]](self.links_s[ipt]))\n rotZ = geo_utils.rotzM(self.rot_z[self.curveIDNames[ipt]](self.links_s[ipt]))\n\n D = self.links_x[ipt]\n\n rotM = self._getRotMatrix(rotX, rotY, rotZ, rotType)\n\n # if necessary, assign rotation matrix for each ffd coef\n if self.coefRotM is not None:\n attachedPoint = self.ptAttachInd[ipt]\n if isComplex:\n self.coefRotM[attachedPoint] = rotM\n else:\n self.coefRotM[attachedPoint] = np.real(rotM)\n\n D = np.dot(rotM, D)\n if rotType == 7:\n # only apply the theta rotations in certain cases\n deriv = self.refAxis.curves[self.curveIDs[ipt]].getDerivative(self.links_s[ipt])\n deriv /= geo_utils.euclideanNorm(deriv) # Normalize\n D = geo_utils.rotVbyW(\n D, deriv, np.pi / 180 * self.rot_theta[self.curveIDNames[ipt]](self.links_s[ipt])\n )\n\n elif rotType == 8:\n varname = self.axis[self.curveIDNames[ipt]][\"rotAxisVar\"]\n slVar = self.DV_listSectionLocal[varname]\n attachedPoint = self.ptAttachInd[ipt]\n W = slVar.sectionTransform[slVar.sectionLink[attachedPoint]][:, 2]\n D = geo_utils.rotVbyW(D, W, np.pi / 180 * self.rot_theta[self.curveIDNames[ipt]](self.links_s[ipt]))\n\n D[0] *= scale_x\n D[1] *= scale_y\n D[2] *= scale_z\n\n if isComplex:\n new_pts[ipt] = base_pt + D * scale\n else:\n new_pts[ipt] = np.real(base_pt + D * scale)\n\n def update(self, ptSetName, childDelta=True, config=None):\n \"\"\"\n This is the main routine for returning coordinates that have\n been updated by design variables.\n\n Parameters\n ----------\n ptSetName : str\n Name of point-set to return. This must match ones of the\n given in an :func:`addPointSet()` call.\n\n childDelta : bool\n Return updates on child as a delta. The user should not\n need to ever change this parameter.\n\n config : str or list\n Define what configurations this design variable will be applied to\n Use a string for a single configuration or a list for multiple\n configurations. The default value of None implies that the design\n variable appies to *ALL* configurations.\n\n \"\"\"\n self.curPtSet = ptSetName\n # We've postponed things as long as we can...do the finialization.\n self._finalize()\n\n # Make sure coefficients are complex\n self._complexifyCoef()\n\n # Set all coef Values back to initial values\n if not self.isChild:\n self.FFD.coef = self.origFFDCoef.copy()\n self._setInitialValues()\n else:\n # Update all coef\n self.FFD._updateVolumeCoef()\n\n # Evaluate starting pointset\n Xstart = self.FFD.getAttachedPoints(ptSetName)\n\n if self.complex:\n # Now we have to propagate the complex part through Xstart\n tempCoef = self.FFD.coef.copy().astype(\"D\")\n Xstart = Xstart.astype(\"D\")\n imag_part = np.imag(tempCoef)\n imag_j = 1j\n\n dPtdCoef = self.FFD.embededVolumes[ptSetName].dPtdCoef\n if dPtdCoef is not None:\n for ii in range(3):\n Xstart[:, ii] += imag_j * dPtdCoef.dot(imag_part[:, ii])\n\n # Step 1: Call all the design variables IFF we have ref axis:\n if len(self.axis) > 0:\n if self.complex:\n new_pts = np.zeros((self.nPtAttach, 3), \"D\")\n else:\n new_pts = np.zeros((self.nPtAttach, 3), \"d\")\n\n # Apply the global design variables\n self.updateCalculations(new_pts, isComplex=self.complex, config=config)\n\n # Put the update FFD points in their proper place\n temp = np.real(new_pts)\n np.put(self.FFD.coef[:, 0], self.ptAttachInd, temp[:, 0])\n np.put(self.FFD.coef[:, 1], self.ptAttachInd, temp[:, 1])\n np.put(self.FFD.coef[:, 2], self.ptAttachInd, temp[:, 2])\n\n # Now add in the spanwise local DVs\n for key in self.DV_listSpanwiseLocal:\n self.DV_listSpanwiseLocal[key](self.FFD.coef, config)\n\n # Now add in the section local DVs\n for key in self.DV_listSectionLocal:\n self.DV_listSectionLocal[key](self.FFD.coef, self.coefRotM, config)\n\n # Now add in the local DVs\n for key in self.DV_listLocal:\n self.DV_listLocal[key](self.FFD.coef, config)\n\n # Update all coef\n self.FFD._updateVolumeCoef()\n\n # Evaluate coordinates from the parent\n Xfinal = self.FFD.getAttachedPoints(ptSetName)\n\n # Propagate the complex part through the volume artificially\n if self.complex:\n # Above, we only took the real part of the coef because\n # _updateVolumeCoef gets rid of it anyway. Here, we need to include\n # the complex part because we want to propagate it through\n tempCoef = self.FFD.coef.copy().astype(\"D\")\n if len(self.axis) > 0:\n np.put(tempCoef[:, 0], self.ptAttachInd, new_pts[:, 0])\n np.put(tempCoef[:, 1], self.ptAttachInd, new_pts[:, 1])\n np.put(tempCoef[:, 2], self.ptAttachInd, new_pts[:, 2])\n\n # Apply just the complex part of the local varibales\n for key in self.DV_listSpanwiseLocal:\n self.DV_listSpanwiseLocal[key].updateComplex(tempCoef, config)\n for key in self.DV_listSectionLocal:\n self.DV_listSectionLocal[key].updateComplex(tempCoef, self.coefRotM, config)\n for key in self.DV_listLocal:\n self.DV_listLocal[key].updateComplex(tempCoef, config)\n\n Xfinal = Xfinal.astype(\"D\")\n imag_part = np.imag(tempCoef)\n imag_j = 1j\n\n dPtdCoef = self.FFD.embededVolumes[ptSetName].dPtdCoef\n if dPtdCoef is not None:\n for ii in range(3):\n Xfinal[:, ii] += imag_j * dPtdCoef.dot(imag_part[:, ii])\n\n # Now loop over the children set the FFD and refAxis control\n # points as evaluated from the parent\n for iChild in range(len(self.children)):\n child = self.children[iChild]\n child._finalize()\n self.applyToChild(iChild)\n\n if self.complex:\n # need to propagate the sensitivity to the children Xfinal here to do this\n # correctly\n child._complexifyCoef()\n child.FFD.coef = child.FFD.coef.astype(\"D\")\n\n dXrefdCoef = self.FFD.embededVolumes[\"child%d_axis\" % (iChild)].dPtdCoef\n dCcdCoef = self.FFD.embededVolumes[\"child%d_coef\" % (iChild)].dPtdCoef\n\n if dXrefdCoef is not None:\n for ii in range(3):\n child.coef[:, ii] += imag_j * dXrefdCoef.dot(imag_part[:, ii])\n\n if dCcdCoef is not None:\n for ii in range(3):\n child.FFD.coef[:, ii] += imag_j * dCcdCoef.dot(imag_part[:, ii])\n child.refAxis.coef = child.coef.copy()\n child.refAxis._updateCurveCoef()\n\n Xfinal += child.update(ptSetName, childDelta=True, config=config)\n\n self._unComplexifyCoef()\n\n # Finally flag this pointSet as being up to date:\n self.updated[ptSetName] = True\n\n if self.isChild and childDelta:\n return Xfinal - Xstart\n else:\n return Xfinal\n\n def applyToChild(self, iChild):\n \"\"\"\n This function is used to apply the changes in the parent FFD to the\n child FFD points and child reference axis points.\n \"\"\"\n child = self.children[iChild]\n\n # Set FFD points and reference axis points from parent\n child.FFD.coef = self.FFD.getAttachedPoints(\"child%d_coef\" % (iChild))\n child.coef = self.FFD.getAttachedPoints(\"child%d_axis\" % (iChild))\n\n # Update the reference axes on the child\n child.refAxis.coef = child.coef.copy()\n child.refAxis._updateCurveCoef()\n\n def pointSetUpToDate(self, ptSetName):\n \"\"\"\n This is used externally to query if the object needs to update\n its pointset or not. Essentially what happens, is when\n update() is called with a point set, it the self.updated dict\n entry for pointSet is flagged as true. Here we just return\n that flag. When design variables are set, we then reset all\n the flags to False since, when DVs are set, nothing (in\n general) will up to date anymore.\n\n Parameters\n ----------\n ptSetName : str\n The name of the pointset to check.\n \"\"\"\n if ptSetName in self.updated:\n return self.updated[ptSetName]\n else:\n return True\n\n def convertSensitivityToDict(self, dIdx, out1D=False):\n \"\"\"\n This function takes the result of totalSensitivity and\n converts it to a dict for use in pyOptSparse\n\n Parameters\n ----------\n dIdx : array\n Flattened array of length getNDV(). Generally it comes from\n a call to totalSensitivity()\n\n out1D : boolean\n If true, creates a 1D array in the dictionary instead of 2D.\n This function is used in the matrix-vector product calculation.\n\n Returns\n -------\n dIdxDict : dictionary\n Dictionary of the same information keyed by this object's\n design variables\n \"\"\"\n\n # compute the various DV offsets\n DVCountGlobal, DVCountLocal, DVCountSecLoc, DVCountSpanLoc = self._getDVOffsets()\n\n i = DVCountGlobal\n dIdxDict = {}\n for key in self.DV_listGlobal:\n dv = self.DV_listGlobal[key]\n if out1D:\n dIdxDict[dv.name] = np.ravel(dIdx[:, i : i + dv.nVal])\n else:\n dIdxDict[dv.name] = dIdx[:, i : i + dv.nVal]\n i += dv.nVal\n\n i = DVCountSpanLoc\n for key in self.DV_listSpanwiseLocal:\n dv = self.DV_listSpanwiseLocal[key]\n if out1D:\n dIdxDict[dv.name] = np.ravel(dIdx[:, i : i + dv.nVal])\n else:\n dIdxDict[dv.name] = dIdx[:, i : i + dv.nVal]\n i += dv.nVal\n\n i = DVCountSecLoc\n for key in self.DV_listSectionLocal:\n dv = self.DV_listSectionLocal[key]\n if out1D:\n dIdxDict[dv.name] = np.ravel(dIdx[:, i : i + dv.nVal])\n else:\n dIdxDict[dv.name] = dIdx[:, i : i + dv.nVal]\n i += dv.nVal\n\n i = DVCountLocal\n for key in self.DV_listLocal:\n dv = self.DV_listLocal[key]\n if out1D:\n dIdxDict[dv.name] = np.ravel(dIdx[:, i : i + dv.nVal])\n else:\n dIdxDict[dv.name] = dIdx[:, i : i + dv.nVal]\n\n i += dv.nVal\n\n # Add in child portion\n for iChild in range(len(self.children)):\n childdIdx = self.children[iChild].convertSensitivityToDict(dIdx, out1D=out1D)\n # update the total sensitivities with the derivatives from the child\n for key in childdIdx:\n if key in dIdxDict.keys():\n dIdxDict[key] += childdIdx[key]\n else:\n dIdxDict[key] = childdIdx[key]\n\n return dIdxDict\n\n def convertDictToSensitivity(self, dIdxDict):\n \"\"\"\n This function performs the reverse operation of\n convertSensitivityToDict(); it transforms the dictionary back\n into an array. This function is important for the matrix-free\n interface.\n\n Parameters\n ----------\n dIdxDict : dictionary\n Dictionary of information keyed by this object's\n design variables\n\n Returns\n -------\n dIdx : array\n Flattened array of length getNDV().\n \"\"\"\n DVCountGlobal, DVCountLocal, DVCountSecLoc, DVCountSpanLoc = self._getDVOffsets()\n dIdx = np.zeros(self.nDV_T, self.dtype)\n i = DVCountGlobal\n for key in self.DV_listGlobal:\n dv = self.DV_listGlobal[key]\n dIdx[i : i + dv.nVal] = dIdxDict[dv.name]\n i += dv.nVal\n\n i = DVCountLocal\n for key in self.DV_listLocal:\n dv = self.DV_listLocal[key]\n dIdx[i : i + dv.nVal] = dIdxDict[dv.name]\n i += dv.nVal\n\n i = DVCountSecLoc\n for key in self.DV_listSectionLocal:\n dv = self.DV_listSectionLocal[key]\n dIdx[i : i + dv.nVal] = dIdxDict[dv.name]\n i += dv.nVal\n\n i = DVCountSpanLoc\n for key in self.DV_listSpanwiseLocal:\n dv = self.DV_listSpanwiseLocal[key]\n dIdx[i : i + dv.nVal] = dIdxDict[dv.name]\n i += dv.nVal\n\n # Note: not sure if this works with (multiple) sibling child FFDs\n for iChild in range(len(self.children)):\n childdIdx = self.children[iChild].convertDictToSensitivity(dIdxDict)\n # update the total sensitivities with the derivatives from the child\n dIdx += childdIdx\n return dIdx\n\n def getVarNames(self):\n \"\"\"\n Return a list of the design variable names. This is typically\n used when specifying a wrt= argument for pyOptSparse.\n\n Examples\n --------\n optProb.addCon(.....wrt=DVGeo.getVarNames())\n \"\"\"\n names = list(self.DV_listGlobal.keys())\n names.extend(list(self.DV_listLocal.keys()))\n names.extend(list(self.DV_listSectionLocal.keys()))\n names.extend(list(self.DV_listSpanwiseLocal.keys()))\n\n # Call the children recursively\n for iChild in range(len(self.children)):\n names.extend(self.children[iChild].getVarNames())\n\n return names\n\n def totalSensitivity(self, dIdpt, ptSetName, comm=None, config=None):\n \"\"\"\n This function computes sensitivty information.\n\n Specificly, it computes the following:\n :math:`\\\\frac{dX_{pt}}{dX_{DV}}^T \\\\frac{dI}{d_{pt}}`\n\n Parameters\n ----------\n dIdpt : array of size (Npt, 3) or (N, Npt, 3)\n\n This is the total derivative of the objective or function\n of interest with respect to the coordinates in\n 'ptSetName'. This can be a single array of size (Npt, 3)\n **or** a group of N vectors of size (Npt, 3, N). If you\n have many to do, it is faster to do many at once.\n\n ptSetName : str\n The name of set of points we are dealing with\n\n comm : MPI.IntraComm\n The communicator to use to reduce the final derivative. If\n comm is None, no reduction takes place.\n\n config : str or list\n Define what configurations this design variable will be applied to\n Use a string for a single configuration or a list for multiple\n configurations. The default value of None implies that the design\n variable appies to *ALL* configurations.\n\n\n Returns\n -------\n dIdxDict : dic\n The dictionary containing the derivatives, suitable for\n pyOptSparse\n\n Notes\n -----\n The ``child`` and ``nDVStore`` options are only used\n internally and should not be changed by the user.\n \"\"\"\n\n # Make dIdpt at least 3D\n if len(dIdpt.shape) == 2:\n dIdpt = np.array([dIdpt])\n N = dIdpt.shape[0]\n\n # generate the total Jacobian self.JT\n self.computeTotalJacobian(ptSetName, config=config)\n\n # now that we have self.JT compute the Mat-Mat multiplication\n nDV = self._getNDV()\n dIdx_local = np.zeros((N, nDV), \"d\")\n for i in range(N):\n if self.JT[ptSetName] is not None:\n dIdx_local[i, :] = self.JT[ptSetName].dot(dIdpt[i, :, :].flatten())\n\n if comm: # If we have a comm, globaly reduce with sum\n dIdx = comm.allreduce(dIdx_local, op=MPI.SUM)\n else:\n dIdx = dIdx_local\n\n # Now convert to dict:\n dIdx = self.convertSensitivityToDict(dIdx)\n\n return dIdx\n\n def totalSensitivityProd(self, vec, ptSetName, comm=None, child=False, nDVStore=0, config=None):\n \"\"\"\n This function computes sensitivty information.\n\n Specifically, it computes the following:\n :math:`\\\\frac{dX_{pt}}{dX_{DV}} \\\\ vec`\n\n This is useful for forward AD mode.\n\n Parameters\n ----------\n vec : dictionary whose keys are the design variable names, and whose\n values are the derivative seeds of the corresponding design variable.\n\n ptSetName : str\n The name of set of points we are dealing with\n\n comm : MPI.IntraComm\n The communicator to use to reduce the final derivative. If\n comm is None, no reduction takes place.\n\n config : str or list\n Define what configurations this design variable will be applied to\n Use a string for a single configuration or a list for multiple\n configurations. The default value of None implies that the design\n variable appies to *ALL* configurations.\n\n Returns\n -------\n xsdot : array (Nx3) -> Array with derivative seeds of the surface nodes.\n\n Notes\n -----\n The ``child`` and ``nDVStore`` options are only used\n internally and should not be changed by the user.\n \"\"\"\n\n self.computeTotalJacobian(ptSetName, config=config)\n\n names = self.getVarNames()\n newvec = np.zeros(self.getNDV(), self.dtype)\n i = 0\n for key in names:\n if key in self.DV_listGlobal:\n dv = self.DV_listGlobal[key]\n elif key in self.DV_listSpanwiseLocal:\n dv = self.DV_listSpanwiseLocal[key]\n elif key in self.DV_listSectionLocal:\n dv = self.DV_listSectionLocal[key]\n else:\n dv = self.DV_listLocal[key]\n\n if key in vec:\n newvec[i : i + dv.nVal] = vec[key]\n\n i += dv.nVal\n\n # perform the product\n if self.JT[ptSetName] is None:\n xsdot = np.zeros((0, 3))\n else:\n xsdot = self.JT[ptSetName].T.dot(newvec)\n xsdot.reshape(len(xsdot) // 3, 3)\n # Maybe this should be:\n # xsdot = xsdot.reshape(len(xsdot)//3, 3)\n\n return xsdot\n\n def totalSensitivityTransProd(self, vec, ptSetName, comm=None, child=False, nDVStore=0, config=None):\n \"\"\"\n This function computes sensitivty information.\n\n Specifically, it computes the following:\n :math:`\\\\frac{dX_{pt}}{dX_{DV}}^T \\\\ vec`\n\n This is useful for reverse AD mode.\n\n Parameters\n ----------\n dIdpt : array of size (Npt, 3) or (N, Npt, 3)\n\n This is the total derivative of the objective or function\n of interest with respect to the coordinates in\n 'ptSetName'. This can be a single array of size (Npt, 3)\n **or** a group of N vectors of size (Npt, 3, N). If you\n have many to do, it is faster to do many at once.\n\n ptSetName : str\n The name of set of points we are dealing with\n\n comm : MPI.IntraComm\n The communicator to use to reduce the final derivative. If\n comm is None, no reduction takes place.\n\n config : str or list\n Define what configurations this design variable will be applied to\n Use a string for a single configuration or a list for multiple\n configurations. The default value of None implies that the design\n variable appies to *ALL* configurations.\n\n Returns\n -------\n dIdxDict : dic\n The dictionary containing the derivatives, suitable for\n pyOptSparse\n\n Notes\n -----\n The ``child`` and ``nDVStore`` options are only used\n internally and should not be changed by the user.\n \"\"\"\n\n self.computeTotalJacobian(ptSetName, config=config)\n\n # perform the product\n if self.JT[ptSetName] is None:\n xsdot = np.zeros((0, 3))\n else:\n xsdot = self.JT[ptSetName].dot(np.ravel(vec))\n\n # Pack result into dictionary\n xsdict = {}\n names = self.getVarNames()\n i = 0\n for key in names:\n if key in self.DV_listGlobal:\n dv = self.DV_listGlobal[key]\n elif key in self.DV_listSpanwiseLocal:\n dv = self.DV_listSpanwiseLocal[key]\n elif key in self.DV_listSectionLocal:\n dv = self.DV_listSectionLocal[key]\n else:\n dv = self.DV_listLocal[key]\n xsdict[key] = xsdot[i : i + dv.nVal]\n i += dv.nVal\n\n return xsdict\n\n def computeDVJacobian(self, config=None):\n \"\"\"\n return J_temp for a given config\n \"\"\"\n # These routines are not recursive. They compute the derivatives at this level and\n # pass information down one level for the next pass call from the routine above\n\n # This is going to be DENSE in general\n J_attach = self._attachedPtJacobian(config=config)\n\n # Compute local normal jacobian\n J_spanwiselocal = self._spanwiselocalDVJacobian(config=config)\n\n # Compute local normal jacobian\n J_sectionlocal = self._sectionlocalDVJacobian(config=config)\n\n # This is the sparse jacobian for the local DVs that affect\n # Control points directly.\n J_local = self._localDVJacobian(config=config)\n\n # this is the jacobian from accumulated derivative dependence from parent to child\n J_casc = self._cascadedDVJacobian(config=config)\n\n J_temp = None\n\n # add them together\n if J_attach is not None:\n J_temp = sparse.lil_matrix(J_attach)\n\n if J_spanwiselocal is not None:\n if J_temp is None:\n J_temp = sparse.lil_matrix(J_spanwiselocal)\n else:\n J_temp += J_spanwiselocal\n\n if J_sectionlocal is not None:\n if J_temp is None:\n J_temp = sparse.lil_matrix(J_sectionlocal)\n else:\n J_temp += J_sectionlocal\n\n if J_local is not None:\n if J_temp is None:\n J_temp = sparse.lil_matrix(J_local)\n else:\n J_temp += J_local\n\n if J_casc is not None:\n if J_temp is None:\n J_temp = sparse.lil_matrix(J_casc)\n else:\n J_temp += J_casc\n\n return J_temp\n\n def computeTotalJacobian(self, ptSetName, config=None):\n \"\"\"Return the total point jacobian in CSR format since we\n need this for TACS\"\"\"\n\n # Finalize the object, if not done yet\n self._finalize()\n self.curPtSet = ptSetName\n\n if not (self.JT[ptSetName] is None):\n return\n\n # compute the derivatives of the coeficients of this level wrt all of the design\n # variables at this level and all levels above\n J_temp = self.computeDVJacobian(config=config)\n\n # now get the derivative of the points for this level wrt the coefficients(dPtdCoef)\n if self.FFD.embededVolumes[ptSetName].dPtdCoef is not None:\n dPtdCoef = self.FFD.embededVolumes[ptSetName].dPtdCoef.tocoo()\n # We have a slight problem...dPtdCoef only has the shape\n # functions, so it size Npt x Coef. We need a matrix of\n # size 3*Npt x 3*nCoef, where each non-zero entry of\n # dPtdCoef is replaced by value * 3x3 Identity matrix.\n\n # Extract IJV Triplet from dPtdCoef\n row = dPtdCoef.row\n col = dPtdCoef.col\n data = dPtdCoef.data\n\n new_row = np.zeros(3 * len(row), \"int\")\n new_col = np.zeros(3 * len(row), \"int\")\n new_data = np.zeros(3 * len(row))\n\n # Loop over each entry and expand:\n for j in range(3):\n new_data[j::3] = data\n new_row[j::3] = row * 3 + j\n new_col[j::3] = col * 3 + j\n\n # Size of New Matrix:\n Nrow = dPtdCoef.shape[0] * 3\n Ncol = dPtdCoef.shape[1] * 3\n\n # Create new matrix in coo-dinate format and convert to csr\n new_dPtdCoef = sparse.coo_matrix((new_data, (new_row, new_col)), shape=(Nrow, Ncol)).tocsr()\n\n # Do Sparse Mat-Mat multiplication and resort indices\n if J_temp is not None:\n self.JT[ptSetName] = (J_temp.T * new_dPtdCoef.T).tocsr()\n self.JT[ptSetName].sort_indices()\n\n # Add in child portion\n for iChild in range(len(self.children)):\n\n # Reset control points on child for child link derivatives\n self.applyToChild(iChild)\n self.children[iChild].computeTotalJacobian(ptSetName, config=config)\n\n if self.JT[ptSetName] is not None:\n self.JT[ptSetName] = self.JT[ptSetName] + self.children[iChild].JT[ptSetName]\n else:\n self.JT[ptSetName] = self.children[iChild].JT[ptSetName]\n else:\n self.JT[ptSetName] = None\n\n def computeTotalJacobianCS(self, ptSetName, config=None):\n \"\"\"Return the total point jacobian in CSR format since we\n need this for TACS\"\"\"\n\n self._finalize()\n self.curPtSet = ptSetName\n\n if not (self.JT[ptSetName] is None):\n return\n\n if self.isChild:\n refFFDCoef = copy.copy(self.FFD.coef)\n refCoef = copy.copy(self.coef)\n\n if self.nPts[ptSetName] is None:\n self.nPts[ptSetName] = len(self.update(ptSetName).flatten())\n for child in self.children:\n child.nPts[ptSetName] = self.nPts[ptSetName]\n\n DVGlobalCount, DVLocalCount, DVSecLocCount, DVSpanLocCount = self._getDVOffsets()\n\n h = 1e-40j\n\n self.JT[ptSetName] = np.zeros([self.nDV_T, self.nPts[ptSetName]])\n self._complexifyCoef()\n for key in self.DV_listGlobal:\n for j in range(self.DV_listGlobal[key].nVal):\n if self.isChild:\n self.FFD.coef = refFFDCoef.copy()\n self.coef = refCoef.copy()\n self.refAxis.coef = refCoef.copy()\n self.refAxis._updateCurveCoef()\n\n refVal = self.DV_listGlobal[key].value[j]\n\n self.DV_listGlobal[key].value[j] += h\n\n deriv = np.imag(self._update_deriv_cs(ptSetName, config=config).flatten()) / np.imag(h)\n\n self.JT[ptSetName][DVGlobalCount, :] = deriv\n\n DVGlobalCount += 1\n self.DV_listGlobal[key].value[j] = refVal\n\n self._unComplexifyCoef()\n for key in self.DV_listSpanwiseLocal:\n for j in range(self.DV_listSpanwiseLocal[key].nVal):\n if self.isChild:\n self.FFD.coef = refFFDCoef.copy()\n self.coef = refCoef.copy()\n self.refAxis.coef = refCoef.copy()\n self.refAxis._updateCurveCoef()\n\n refVal = self.DV_listSpanwiseLocal[key].value[j]\n\n self.DV_listSpanwiseLocal[key].value[j] += h\n deriv = np.imag(self._update_deriv_cs(ptSetName, config=config).flatten()) / np.imag(h)\n\n self.JT[ptSetName][DVSpanLocCount, :] = deriv\n\n DVSpanLocCount += 1\n self.DV_listSpanwiseLocal[key].value[j] = refVal\n\n for key in self.DV_listSectionLocal:\n for j in range(self.DV_listSectionLocal[key].nVal):\n if self.isChild:\n self.FFD.coef = refFFDCoef.copy()\n self.coef = refCoef.copy()\n self.refAxis.coef = refCoef.copy()\n self.refAxis._updateCurveCoef()\n\n refVal = self.DV_listSectionLocal[key].value[j]\n\n self.DV_listSectionLocal[key].value[j] += h\n deriv = np.imag(self._update_deriv_cs(ptSetName, config=config).flatten()) / np.imag(h)\n\n self.JT[ptSetName][DVSecLocCount, :] = deriv\n\n DVSecLocCount += 1\n self.DV_listSectionLocal[key].value[j] = refVal\n\n for key in self.DV_listLocal:\n for j in range(self.DV_listLocal[key].nVal):\n if self.isChild:\n self.FFD.coef = refFFDCoef.copy()\n self.coef = refCoef.copy()\n self.refAxis.coef = refCoef.copy()\n self.refAxis._updateCurveCoef()\n\n refVal = self.DV_listLocal[key].value[j]\n\n self.DV_listLocal[key].value[j] += h\n deriv = np.imag(self._update_deriv_cs(ptSetName, config=config).flatten()) / np.imag(h)\n\n self.JT[ptSetName][DVLocalCount, :] = deriv\n\n DVLocalCount += 1\n self.DV_listLocal[key].value[j] = refVal\n\n for iChild in range(len(self.children)):\n child = self.children[iChild]\n child._finalize()\n\n # In the updates applied previously, the FFD points on the children\n # will have been set as deltas. We need to set them as absolute\n # coordinates based on the changes in the parent before moving down\n # to the next level\n self.applyToChild(iChild)\n\n # Now get jacobian from child and add to parent jacobian\n child.computeTotalJacobianCS(ptSetName, config=config)\n self.JT[ptSetName] = self.JT[ptSetName] + child.JT[ptSetName]\n\n return\n\n def addVariablesPyOpt(\n self,\n optProb,\n globalVars=True,\n localVars=True,\n sectionlocalVars=True,\n spanwiselocalVars=True,\n ignoreVars=None,\n freezeVars=None,\n ):\n \"\"\"\n Add the current set of variables to the optProb object.\n\n Parameters\n ----------\n optProb : pyOpt_optimization class\n Optimization problem definition to which variables are added\n\n globalVars : bool\n Flag specifying whether global variables are to be added\n\n localVars : bool\n Flag specifying whether local variables are to be added\n\n sectionlocalVars : bool\n Flag specifying whether section local variables are to be added\n\n spanwiselocalVars : bool\n Flag specifying whether spanwiselocal variables are to be added\n\n ignoreVars : list of strings\n List of design variables the user DOESN'T want to use\n as optimization variables.\n\n freezeVars : list of string\n List of design variables the user WANTS to add as optimization\n variables, but to have the lower and upper bounds set at the current\n variable. This effectively eliminates the variable, but it the variable\n is still part of the optimization.\n \"\"\"\n if ignoreVars is None:\n ignoreVars = set()\n if freezeVars is None:\n freezeVars = set()\n\n # Add design variables from the master:\n varLists = OrderedDict(\n [\n (\"globalVars\", self.DV_listGlobal),\n (\"localVars\", self.DV_listLocal),\n (\"sectionlocalVars\", self.DV_listSectionLocal),\n (\"spanwiselocalVars\", self.DV_listSpanwiseLocal),\n ]\n )\n for lst in varLists:\n if (\n lst == \"globalVars\"\n and globalVars\n or lst == \"localVars\"\n and localVars\n or lst == \"sectionlocalVars\"\n and sectionlocalVars\n or lst == \"spanwiselocalVars\"\n and spanwiselocalVars\n ):\n for key in varLists[lst]:\n if key not in ignoreVars:\n dv = varLists[lst][key]\n if key not in freezeVars:\n optProb.addVarGroup(\n dv.name, dv.nVal, \"c\", value=dv.value, lower=dv.lower, upper=dv.upper, scale=dv.scale\n )\n else:\n optProb.addVarGroup(\n dv.name, dv.nVal, \"c\", value=dv.value, lower=dv.value, upper=dv.value, scale=dv.scale\n )\n\n # Add variables from the children\n for child in self.children:\n child.addVariablesPyOpt(\n optProb, globalVars, localVars, sectionlocalVars, spanwiselocalVars, ignoreVars, freezeVars\n )\n\n def writeTecplot(self, fileName):\n \"\"\"Write the (deformed) current state of the FFD's to a tecplot file,\n including the children\n\n Parameters\n ----------\n fileName : str\n Filename for tecplot file. Should have a .dat extension\n \"\"\"\n\n # Name here doesn't matter, just take the first one\n if len(self.points) > 0:\n keyToUpdate = list(self.points.keys())[0]\n self.update(keyToUpdate, childDelta=False)\n\n f = openTecplot(fileName, 3)\n vol_counter = 0\n\n # Write master volumes:\n vol_counter += self._writeVols(f, vol_counter)\n\n closeTecplot(f)\n if len(self.points) > 0:\n self.update(keyToUpdate, childDelta=True)\n\n def writeRefAxes(self, fileName):\n \"\"\"Write the (deformed) current state of the RefAxes to a tecplot file,\n including the children\n\n Parameters\n ----------\n fileName : str\n Filename for tecplot file. Should have a no extension,an\n extension will be added.\n \"\"\"\n # Name here doesnt matter, just take the first one\n self.update(self.points.keys()[0], childDelta=False)\n\n gFileName = fileName + \"_parent.dat\"\n if not len(self.axis) == 0:\n self.refAxis.writeTecplot(gFileName, orig=True, curves=True, coef=True)\n # Write children axes:\n for iChild in range(len(self.children)):\n cFileName = fileName + \"_child{:03d}.dat\".format(iChild)\n self.children[iChild].refAxis.writeTecplot(cFileName, orig=True, curves=True, coef=True)\n\n def writeLinks(self, fileName):\n \"\"\"Write the links attaching the control points to the reference axes\n\n Parameters\n ----------\n fileName : str\n Filename for tecplot file. Should have .dat extension\n \"\"\"\n self._finalize()\n f = openTecplot(fileName, 3)\n f.write(\"ZONE NODES=%d ELEMENTS=%d ZONETYPE=FELINESEG\\n\" % (self.nPtAttach * 2, self.nPtAttach))\n f.write(\"DATAPACKING=POINT\\n\")\n for ipt in range(self.nPtAttach):\n pt1 = self.refAxis.curves[self.curveIDs[ipt]](self.links_s[ipt])\n pt2 = self.links_x[ipt] + pt1\n\n f.write(\"%.12g %.12g %.12g\\n\" % (pt1[0], pt1[1], pt1[2]))\n f.write(\"%.12g %.12g %.12g\\n\" % (pt2[0], pt2[1], pt2[2]))\n for i in range(self.nPtAttach):\n f.write(\"%d %d\\n\" % (2 * i + 1, 2 * i + 2))\n\n closeTecplot(f)\n\n def writePointSet(self, name, fileName):\n \"\"\"\n Write a given point set to a tecplot file\n\n Parameters\n ----------\n name : str\n The name of the point set to write to a file\n\n fileName : str\n Filename for tecplot file. Should have no extension, an\n extension will be added\n \"\"\"\n if self.isChild:\n raise Error('Must call \"writePointSet\" from parent DVGeo.')\n else:\n coords = self.update(name, childDelta=True)\n fileName = fileName + \"_%s.dat\" % name\n f = openTecplot(fileName, 3)\n writeTecplot1D(f, name, coords)\n closeTecplot(f)\n\n def writePlot3d(self, fileName):\n \"\"\"Write the (deformed) current state of the FFD object into a\n plot3D file. This file could then be used as the base-line FFD\n for a subsequent optimization. This function is not typically\n used in a regular basis, but may be useful in certain\n situaions, i.e. a sequence of optimizations\n\n Parameters\n ----------\n fileName : str\n Filename of the plot3D file to write. Should have a .fmt\n file extension.\n \"\"\"\n self.FFD.writePlot3dCoef(fileName)\n\n def updatePyGeo(self, geo, outputType, fileName, nRefU=0, nRefV=0):\n \"\"\"Deform a pyGeo object and write to a file of specified type\n given the (deformed) current state of the FFD object.\n\n Parameters\n ----------\n geo : pyGeo object\n A pyGeo object containing an initialized object\n outputType: str\n Type of output file to be written. Can be `iges` or `tecplot`\n fileName: str\n Filename for the output file. Should have no extension, an\n extension will be added\n nRefU: int or list of ints\n Number of spline refinement points to add in the surface B-Spline u-direction.\n If scalar, it is applied across each surface. If list, the length must match the\n number of surfaces in the object and corresponding entries are matched with surfaces.\n nRefV: int or list of ints\n Number of spline refinement points to add in the surface B-Spline v-direction.\n If scalar, it is applied across each surface. If list, the length must match the\n number of surfaces in the object and corresponding entries are matched with surfaces\n \"\"\"\n # Function to check if value matches a knot point\n # (set to 1e-12 to match pySpline mult. tolerance)\n def check_mult(val, knots):\n for iKnot in range(len(knots)):\n if np.isclose(val, knots[iKnot], atol=1e-12):\n return True\n return False\n\n # Refine Surface -- U-Direction\n if isinstance(nRefU, int):\n # Refine BSplines by adding knot points\n Refine_U = np.linspace(0.0, 1.0, nRefU + 2)\n for iSurf in range(geo.nSurf):\n for iX in Refine_U:\n if not check_mult(iX, geo.surfs[iSurf].tu):\n geo.surfs[iSurf].insertKnot(\"u\", iX, 1)\n elif isinstance(nRefU, list):\n if len(nRefU) != geo.nSurf:\n raise RuntimeError(\"Length of nRefU does not match number of surfaces in object\")\n # Refine BSplines by adding knot points\n for iSurf in range(geo.nSurf):\n Refine_U = np.linspace(0.0, 1.0, nRefU[iSurf] + 2)\n for iX in Refine_U:\n if not check_mult(iX, geo.surfs[iSurf].tu):\n geo.surfs[iSurf].insertKnot(\"u\", iX, 1)\n else:\n raise TypeError(\"nRefU type not recognized, must be: integer or list of integers\")\n\n # Refine Surface -- V-Direction\n if isinstance(nRefV, int):\n # Refine BSplines by adding knot points\n Refine_V = np.linspace(0.0, 1.0, nRefV + 2)\n for iSurf in range(geo.nSurf):\n for iY in Refine_V:\n if not check_mult(iY, geo.surfs[iSurf].tv):\n geo.surfs[iSurf].insertKnot(\"v\", iY, 1)\n elif isinstance(nRefV, list):\n if len(nRefU) != geo.nSurf:\n raise RuntimeError(\"Length of nRefV does not match number of surfaces in object\")\n # Refine BSplines by adding knot points\n for iSurf in range(geo.nSurf):\n Refine_V = np.linspace(0.0, 1.0, nRefV[iSurf] + 2)\n for iY in Refine_V:\n if not check_mult(iY, geo.surfs[iSurf].tv):\n geo.surfs[iSurf].insertKnot(\"v\", iY, 1)\n else:\n raise TypeError(\"nRefV type not recognized, must be: integer or list of integers\")\n\n # Update Coefficients\n for iSurf in range(geo.nSurf):\n # Add Point Sets\n npt = geo.surfs[iSurf].nCtlu * geo.surfs[iSurf].nCtlv\n self.addPointSet(geo.surfs[iSurf].coef.reshape((npt, 3)), \"coef%d\" % iSurf)\n\n # Update and Overwrite Old Values\n geo.surfs[iSurf].coef = self.update(\"coef%d\" % iSurf).reshape(geo.surfs[iSurf].coef.shape)\n\n # Write File\n if outputType == \"iges\":\n geo.writeIGES(fileName + \".igs\")\n elif outputType == \"tecplot\":\n geo.writeTecplot(fileName + \".plt\")\n else:\n raise ValueError(\"Type {} not recognized. Must be either 'iges' or 'tecplot'\".format(outputType))\n\n def getLocalIndex(self, iVol):\n \"\"\"Return the local index mapping that points to the global\n coefficient list for a given volume\"\"\"\n return self.FFD.topo.lIndex[iVol].copy()\n\n def getFlattenedChildren(self):\n \"\"\"\n Return a flattened list of all DVGeo objects in the family heirarchy.\n \"\"\"\n flatChildren = [self]\n for child in self.children:\n flatChildren += child.getFlattenedChildren()\n\n return flatChildren\n\n def demoDesignVars(self, directory, includeLocal=True, includeGlobal=True, pointSet=None, callBack=None, freq=2):\n \"\"\"\n This function can be used to \"test\" the design variable parametrization\n for a given optimization problem. It should be called in the script\n after DVGeo has been set up. The function will loop through all the\n design variables and write out a deformed FFD volume for the upper\n and lower bound of every design variable. It will also write out the\n deformed pointset of choice.\n\n Parameters\n ----------\n directory : str\n The directory where the FFD files should be written.\n includeLocal : boolean\n False if you don't want to include the shape variables.\n pointSet : str\n Name of the pointset to write out. If this is not specified, it will\n take the first one in the list.\n callBack : function\n This allows the user to perform an additional task at each new design\n variable iteration (e.g. write out a deformed mesh). The callback\n function must take two inputs: 1) the output directory name (str) and\n 2) the iteration count (int).\n freq : int\n Number of snapshots to take between the upper and lower bounds of\n a given variable. If greater than 2, will do a sinusoidal sweep.\n \"\"\"\n # Generate directories\n os.system(\"mkdir -p {:s}/ffd\".format(directory))\n os.system(\"mkdir -p {:s}/pointset\".format(directory))\n\n # Get design variables\n dvDict = self.getValues()\n\n # Get pointSet\n if pointSet is None:\n writePointSet = False\n if self.ptSetNames:\n pointSet = self.ptSetNames[0]\n else:\n raise Error(\"DVGeo must have a point set to update for \" \"demoDesignVars to work.\")\n else:\n writePointSet = True\n\n # Loop through design variables on self and children\n geoList = self.getFlattenedChildren()\n count = 0\n for geo in geoList:\n for key in dvDict:\n lower = []\n if key in geo.DV_listLocal:\n if not includeLocal:\n continue\n lower = geo.DV_listLocal[key].lower\n upper = geo.DV_listLocal[key].upper\n\n elif key in geo.DV_listSpanwiseLocal:\n if not includeLocal:\n continue\n lower = geo.DV_listSpanwiseLocal[key].lower\n upper = geo.DV_listSpanwiseLocal[key].upper\n\n elif key in geo.DV_listSectionLocal:\n if not includeLocal:\n continue\n lower = geo.DV_listSectionLocal[key].lower\n upper = geo.DV_listSectionLocal[key].upper\n\n elif key in geo.DV_listGlobal:\n if not includeGlobal:\n continue\n lower = geo.DV_listGlobal[key].lower\n upper = geo.DV_listGlobal[key].upper\n\n if lower is None or upper is None:\n raise Error(\"demoDesignVars requires upper and lower bounds\" \"on all design variables.\")\n\n x = dvDict[key].flatten()\n nDV = len(lower)\n for j in range(nDV):\n if freq == 2:\n stops = [lower[j], upper[j]]\n elif freq > 2:\n sinusoid = np.sin(np.linspace(0, np.pi, freq))\n down_swing = x[j] + (lower[j] - x[j]) * sinusoid\n up_swing = x[j] + (upper[j] - x[j]) * sinusoid\n stops = np.concatenate((down_swing[:-1], up_swing[:-1]))\n\n for val in stops:\n # Add perturbation to the design variable and update\n old_val = x[j]\n x[j] = val\n dvDict.update({key: x})\n self.setDesignVars(dvDict)\n self.update(pointSet)\n\n # Write FFD\n self.writeTecplot(\"{}/ffd/dv_{}_{:03d}_iter_{:03d}.dat\".format(directory, key, j, count))\n\n # Write pointset\n if writePointSet:\n self.writePointSet(pointSet, \"{}/pointset/iter_{:03d}\".format(directory, count))\n\n # Call user function\n if callBack is not None:\n callBack(directory, count)\n\n # Reset variable\n x[j] = old_val\n dvDict.update({key: x})\n\n # Iterate counter\n count += 1\n\n # ----------------------------------------------------------------------\n # THE REMAINDER OF THE FUNCTIONS NEED NOT BE CALLED BY THE USER\n # ----------------------------------------------------------------------\n\n def _finalizeAxis(self):\n \"\"\"\n Internal function that sets up the collection of curve that\n the user has added one at a time. This will create the\n internal pyNetwork object\n \"\"\"\n if len(self.axis) == 0:\n return\n\n curves = []\n for axis in self.axis:\n curves.append(self.axis[axis][\"curve\"])\n\n # Setup the network of reference axis curves\n self.refAxis = pyNetwork(curves)\n # These are the rotations\n self.rot_x = OrderedDict()\n self.rot_y = OrderedDict()\n self.rot_z = OrderedDict()\n self.rot_theta = OrderedDict()\n self.scale = OrderedDict()\n self.scale_x = OrderedDict()\n self.scale_y = OrderedDict()\n self.scale_z = OrderedDict()\n self.coef = self.refAxis.coef # pointer\n self.coef0 = self.coef.copy().astype(self.dtype)\n\n i = 0\n for key in self.axis:\n # curves in ref axis are indexed sequentially...this is ok\n # since self.axis is an ORDERED dict\n t = self.refAxis.curves[i].t\n k = self.refAxis.curves[i].k\n N = len(self.refAxis.curves[i].coef)\n z = np.zeros((N, 1), self.dtype)\n o = np.ones((N, 1), self.dtype)\n self.rot_x[key] = Curve(t=t, k=k, coef=z.copy())\n self.rot_y[key] = Curve(t=t, k=k, coef=z.copy())\n self.rot_z[key] = Curve(t=t, k=k, coef=z.copy())\n self.rot_theta[key] = Curve(t=t, k=k, coef=z.copy())\n self.scale[key] = Curve(t=t, k=k, coef=o.copy())\n self.scale_x[key] = Curve(t=t, k=k, coef=o.copy())\n self.scale_y[key] = Curve(t=t, k=k, coef=o.copy())\n self.scale_z[key] = Curve(t=t, k=k, coef=o.copy())\n i += 1\n\n # Need to keep track of initail scale values\n self.scale0 = self.scale.copy()\n self.scale_x0 = self.scale_x.copy()\n self.scale_y0 = self.scale_y.copy()\n self.scale_z0 = self.scale_z.copy()\n self.rot_x0 = self.rot_x.copy()\n self.rot_y0 = self.rot_y.copy()\n self.rot_z0 = self.rot_z.copy()\n self.rot_theta0 = self.rot_theta.copy()\n\n def _finalize(self):\n if self.finalized:\n return\n self._finalizeAxis()\n if len(self.axis) == 0:\n self.finalized = True\n self.nPtAttachFull = len(self.FFD.coef)\n return\n # What we need to figure out is which of the control points\n # are connected to an axis, and which ones are not connected\n # to an axis.\n\n # Retrieve all the pointset masks\n coefMask = self.masks\n\n self.ptAttachInd = []\n self.ptAttach = []\n curveIDs = []\n s = []\n curveID = 0\n # Loop over the axis we have:\n for key in self.axis:\n vol_list = np.atleast_1d(self.axis[key][\"volumes\"]).astype(\"intc\")\n temp = []\n for iVol in vol_list:\n for i in range(self.FFD.vols[iVol].nCtlu):\n for j in range(self.FFD.vols[iVol].nCtlv):\n for k in range(self.FFD.vols[iVol].nCtlw):\n ind = self.FFD.topo.lIndex[iVol][i, j, k]\n if (not coefMask[ind]) and (ind not in self.axis[key][\"ignoreInd\"]):\n temp.append(ind)\n\n # Unique the values and append to the master list\n curPtAttach = geo_utils.unique(temp)\n self.ptAttachInd.extend(curPtAttach)\n\n curPts = self.FFD.coef.take(curPtAttach, axis=0).real\n self.ptAttach.extend(curPts)\n\n # Now do the projections for *just* the axis defined by my\n # key.\n if self.axis[key][\"axis\"] is None:\n tmpIDs, tmpS0 = self.refAxis.projectPoints(curPts, curves=[curveID])\n else:\n tmpIDs, tmpS0 = self.refAxis.projectRays(\n curPts, self.axis[key][\"axis\"], curves=[curveID], raySize=self.axis[key][\"raySize\"]\n )\n\n curveIDs.extend(tmpIDs)\n s.extend(tmpS0)\n curveID += 1\n\n self.ptAttachFull = self.FFD.coef.copy().real\n self.nPtAttach = len(self.ptAttach)\n self.nPtAttachFull = len(self.ptAttachFull)\n\n self.curveIDs = curveIDs\n self.curveIDNames = []\n axisKeys = list(self.axis.keys())\n for i in range(len(curveIDs)):\n self.curveIDNames.append(axisKeys[self.curveIDs[i]])\n\n self.links_s = np.array(s)\n self.links_x = []\n self.links_n = []\n\n for i in range(self.nPtAttach):\n self.links_x.append(self.ptAttach[i] - self.refAxis.curves[self.curveIDs[i]](s[i]))\n deriv = self.refAxis.curves[self.curveIDs[i]].getDerivative(self.links_s[i])\n deriv /= geo_utils.euclideanNorm(deriv) # Normalize\n self.links_n.append(np.cross(deriv, self.links_x[-1]))\n\n self.links_x = np.array(self.links_x)\n self.links_s = np.array(self.links_s)\n self.finalized = True\n\n def _setInitialValues(self):\n if len(self.axis) > 0:\n self.coef[:, :] = copy.deepcopy(self.coef0)\n for key in self.axis:\n self.scale[key].coef[:] = copy.deepcopy(self.scale0[key].coef)\n self.scale_x[key].coef[:] = copy.deepcopy(self.scale_x0[key].coef)\n self.scale_y[key].coef[:] = copy.deepcopy(self.scale_y0[key].coef)\n self.scale_z[key].coef[:] = copy.deepcopy(self.scale_z0[key].coef)\n self.rot_x[key].coef[:] = copy.deepcopy(self.rot_x0[key].coef)\n self.rot_y[key].coef[:] = copy.deepcopy(self.rot_y0[key].coef)\n self.rot_z[key].coef[:] = copy.deepcopy(self.rot_z0[key].coef)\n self.rot_theta[key].coef[:] = copy.deepcopy(self.rot_theta0[key].coef)\n\n def _getRotMatrix(self, rotX, rotY, rotZ, rotType):\n if rotType == 1:\n D = np.dot(rotZ, np.dot(rotY, rotX))\n elif rotType == 2:\n D = np.dot(rotY, np.dot(rotZ, rotX))\n elif rotType == 3:\n D = np.dot(rotX, np.dot(rotZ, rotY))\n elif rotType == 4:\n D = np.dot(rotZ, np.dot(rotX, rotY))\n elif rotType == 5:\n D = np.dot(rotY, np.dot(rotX, rotZ))\n elif rotType == 6:\n D = np.dot(rotX, np.dot(rotY, rotZ))\n elif rotType == 7:\n D = np.dot(rotY, np.dot(rotX, rotZ))\n elif rotType == 8:\n D = np.dot(rotY, np.dot(rotX, rotZ))\n return D\n\n def _getNDV(self):\n \"\"\"Return the actual number of design variables, global + local\n + section local + spanwise local\n \"\"\"\n return self._getNDVGlobal() + self._getNDVLocal() + self._getNDVSectionLocal() + self._getNDVSpanwiseLocal()\n\n def getNDV(self):\n \"\"\"\n Return the total number of design variables this object has.\n\n Returns\n -------\n nDV : int\n Total number of design variables\n \"\"\"\n return self._getNDV()\n\n def _getNDVGlobal(self):\n \"\"\"\n Get total number of global variables, inclding any children\n \"\"\"\n nDV = 0\n for key in self.DV_listGlobal:\n nDV += self.DV_listGlobal[key].nVal\n\n for child in self.children:\n nDV += child._getNDVGlobal()\n\n return nDV\n\n def _getNDVLocal(self):\n \"\"\"\n Get total number of local variables, inclding any children\n \"\"\"\n nDV = 0\n for key in self.DV_listLocal:\n nDV += self.DV_listLocal[key].nVal\n\n for child in self.children:\n nDV += child._getNDVLocal()\n\n return nDV\n\n def _getNDVSectionLocal(self):\n \"\"\"\n Get total number of local variables, inclding any children\n \"\"\"\n nDV = 0\n for key in self.DV_listSectionLocal:\n nDV += self.DV_listSectionLocal[key].nVal\n\n for child in self.children:\n nDV += child._getNDVSectionLocal()\n\n return nDV\n\n def _getNDVSpanwiseLocal(self):\n \"\"\"\n Get total number of local variables, inclding any children\n \"\"\"\n nDV = 0\n for key in self.DV_listSpanwiseLocal:\n nDV += self.DV_listSpanwiseLocal[key].nVal\n\n for child in self.children:\n nDV += child._getNDVSpanwiseLocal()\n\n return nDV\n\n def _getNDVSelf(self):\n \"\"\"\n Get total number of local and global variables, not including\n children\n \"\"\"\n return self._getNDVGlobalSelf() + self._getNDVLocalSelf()\n\n def _getNDVGlobalSelf(self):\n \"\"\"\n Get total number of global variables, not including\n children\n \"\"\"\n nDV = 0\n for key in self.DV_listGlobal:\n nDV += self.DV_listGlobal[key].nVal\n\n return nDV\n\n def _getNDVLocalSelf(self):\n \"\"\"\n Get total number of local variables, not including\n children\n \"\"\"\n nDV = 0\n for key in self.DV_listLocal:\n nDV += self.DV_listLocal[key].nVal\n\n return nDV\n\n def _getNDVSectionLocalSelf(self):\n \"\"\"\n Get total number of local variables, not including\n children\n \"\"\"\n nDV = 0\n for key in self.DV_listSectionLocal:\n nDV += self.DV_listSectionLocal[key].nVal\n\n return nDV\n\n def _getNDVSpanwiseLocalSelf(self):\n \"\"\"\n Get total number of local variables, not including\n children\n \"\"\"\n nDV = 0\n for key in self.DV_listSpanwiseLocal:\n nDV += self.DV_listSpanwiseLocal[key].nVal\n\n return nDV\n\n def _getDVOffsets(self):\n \"\"\"\n return the global and local DV offsets for this FFD\n \"\"\"\n\n # figure out the split between local and global Variables\n # All global vars at all levels come first\n # then spanwise, then section local vars and then local vars.\n # Parent Vars come before child Vars\n\n # get the global and local DV numbers on the parents if we don't have them\n if (\n self.nDV_T is None\n or self.nDVG_T is None\n or self.nDVL_T is None\n or self.nDVSL_T is None\n or self.nDVSW_T is None\n ):\n self.nDV_T = self._getNDV()\n self.nDVG_T = self._getNDVGlobal()\n self.nDVL_T = self._getNDVLocal()\n self.nDVSL_T = self._getNDVSectionLocal()\n self.nDVSW_T = self._getNDVSpanwiseLocal()\n self.nDVG_count = 0\n self.nDVSL_count = self.nDVG_T\n self.nDVL_count = self.nDVG_T + self.nDVSL_T\n\n nDVG = self._getNDVGlobalSelf()\n nDVL = self._getNDVLocalSelf()\n nDVSL = self._getNDVSectionLocalSelf()\n nDVSW = self._getNDVSpanwiseLocalSelf()\n\n # Set the total number of global and local DVs into any children of this parent\n for child in self.children:\n # now get the numbers for the current parent child\n\n child.nDV_T = self.nDV_T\n child.nDVG_T = self.nDVG_T\n child.nDVL_T = self.nDVL_T\n child.nDVSL_T = self.nDVSL_T\n child.nDVSW_T = self.nDVSW_T\n child.nDVG_count = self.nDVG_count + nDVG\n child.nDVL_count = self.nDVL_count + nDVL\n child.nDVSL_count = self.nDVSL_count + nDVSL\n child.nDVSW_count = self.nDVSW_count + nDVSL\n\n # Increment the counters for the children\n nDVG += child._getNDVGlobalSelf()\n nDVL += child._getNDVLocalSelf()\n nDVSL += child._getNDVSectionLocalSelf()\n nDVSW += child._getNDVSpanwiseLocalSelf()\n\n return self.nDVG_count, self.nDVL_count, self.nDVSL_count, self.nDVSW_count\n\n def _update_deriv(self, iDV=0, h=1.0e-40j, oneoverh=1.0 / 1e-40, config=None, localDV=False):\n\n \"\"\"Copy of update function for derivative calc\"\"\"\n new_pts = np.zeros((self.nPtAttach, 3), \"D\")\n\n # Step 1: Call all the design variables IFF we have ref axis:\n if len(self.axis) > 0:\n\n # Recompute changes due to global dvs at current point + h\n self.updateCalculations(new_pts, isComplex=True, config=config)\n\n # create a vector of the size of the full FFD\n np.put(self.FFD.coef[:, 0], self.ptAttachInd, new_pts[:, 0])\n np.put(self.FFD.coef[:, 1], self.ptAttachInd, new_pts[:, 1])\n np.put(self.FFD.coef[:, 2], self.ptAttachInd, new_pts[:, 2])\n\n # Add dependence of section variables on the global dv rotations\n for key in self.DV_listSectionLocal:\n self.DV_listSectionLocal[key].updateComplex(self.FFD.coef, self.coefRotM, config)\n\n # Send values back to new_pts\n new_pts[:, 0] = self.FFD.coef[self.ptAttachInd, 0]\n new_pts[:, 1] = self.FFD.coef[self.ptAttachInd, 1]\n new_pts[:, 2] = self.FFD.coef[self.ptAttachInd, 2]\n\n # set the forward effect of the global design vars in each child\n for iChild in range(len(self.children)):\n\n # get the derivative of the child axis and control points wrt the parent\n # control points\n dXrefdCoef = self.FFD.embededVolumes[\"child%d_axis\" % (iChild)].dPtdCoef\n dCcdCoef = self.FFD.embededVolumes[\"child%d_coef\" % (iChild)].dPtdCoef\n\n # create a vector with the derivative of the parent control points wrt the\n # parent global variables\n tmp = np.zeros(self.FFD.coef.shape, dtype=\"d\")\n np.put(tmp[:, 0], self.ptAttachInd, np.imag(new_pts[:, 0]) * oneoverh)\n np.put(tmp[:, 1], self.ptAttachInd, np.imag(new_pts[:, 1]) * oneoverh)\n np.put(tmp[:, 2], self.ptAttachInd, np.imag(new_pts[:, 2]) * oneoverh)\n\n # create variables for the total derivative of the child axis and control\n # points wrt the parent global variables\n dXrefdXdv = np.zeros((dXrefdCoef.shape[0] * 3), \"d\")\n dCcdXdv = np.zeros((dCcdCoef.shape[0] * 3), \"d\")\n\n # multiply the derivative of the child axis wrt the parent control points\n # by the derivative of the parent control points wrt the parent global vars.\n # this is just chain rule\n dXrefdXdv[0::3] = dXrefdCoef.dot(tmp[:, 0])\n dXrefdXdv[1::3] = dXrefdCoef.dot(tmp[:, 1])\n dXrefdXdv[2::3] = dXrefdCoef.dot(tmp[:, 2])\n\n # do the same for the child control points\n dCcdXdv[0::3] = dCcdCoef.dot(tmp[:, 0])\n dCcdXdv[1::3] = dCcdCoef.dot(tmp[:, 1])\n dCcdXdv[2::3] = dCcdCoef.dot(tmp[:, 2])\n if localDV and self._getNDVLocalSelf():\n self.children[iChild].dXrefdXdvl[:, iDV] += dXrefdXdv\n self.children[iChild].dCcdXdvl[:, iDV] += dCcdXdv\n elif self._getNDVGlobalSelf():\n self.children[iChild].dXrefdXdvg[:, iDV] += dXrefdXdv.real\n self.children[iChild].dCcdXdvg[:, iDV] += dCcdXdv.real\n return new_pts\n\n def _update_deriv_cs(self, ptSetName, config=None):\n\n \"\"\"\n A version of the update_deriv function specifically for use\n in the computeTotalJacobianCS function.\"\"\"\n new_pts = np.zeros((self.nPtAttachFull, 3), \"D\")\n\n # Make sure coefficients are complex\n self._complexifyCoef()\n\n # Set all coef Values back to initial values\n if not self.isChild:\n self.FFD.coef = self.FFD.coef.astype(\"D\")\n self._setInitialValues()\n else:\n # Update all coef\n self.FFD.coef = self.FFD.coef.astype(\"D\")\n self.FFD._updateVolumeCoef()\n\n # Evaluate starting pointset\n Xstart = self.FFD.getAttachedPoints(ptSetName)\n\n # Now we have to propagate the complex part through Xstart\n tempCoef = self.FFD.coef.copy().astype(\"D\")\n Xstart = Xstart.astype(\"D\")\n imag_part = np.imag(tempCoef)\n imag_j = 1j\n\n dPtdCoef = self.FFD.embededVolumes[ptSetName].dPtdCoef\n if dPtdCoef is not None:\n for ii in range(3):\n Xstart[:, ii] += imag_j * dPtdCoef.dot(imag_part[:, ii])\n\n # Step 1: Call all the design variables IFF we have ref axis:\n if len(self.axis) > 0:\n\n # Compute changes due to global design vars\n self.updateCalculations(new_pts, isComplex=True, config=config)\n\n # Put the update FFD points in their proper place\n np.put(self.FFD.coef[:, 0], self.ptAttachInd, new_pts[:, 0])\n np.put(self.FFD.coef[:, 1], self.ptAttachInd, new_pts[:, 1])\n np.put(self.FFD.coef[:, 2], self.ptAttachInd, new_pts[:, 2])\n\n # Apply the real and complex parts separately\n for key in self.DV_listSpanwiseLocal:\n self.DV_listSpanwiseLocal[key](self.FFD.coef, self.coefRotM, config)\n self.DV_listSpanwiseLocal[key].updateComplex(self.FFD.coef, self.coefRotM, config)\n\n for key in self.DV_listSectionLocal:\n self.DV_listSectionLocal[key](self.FFD.coef, self.coefRotM, config)\n self.DV_listSectionLocal[key].updateComplex(self.FFD.coef, self.coefRotM, config)\n\n for key in self.DV_listLocal:\n self.DV_listLocal[key](self.FFD.coef, config)\n self.DV_listLocal[key].updateComplex(self.FFD.coef, config)\n\n # Update all coef\n self.FFD._updateVolumeCoef()\n\n # Evaluate coordinates from the parent\n Xfinal = self.FFD.getAttachedPoints(ptSetName)\n\n # now project derivs through from the coef to the pts\n Xfinal = Xfinal.astype(\"D\")\n imag_part = np.imag(self.FFD.coef)\n imag_j = 1j\n\n dPtdCoef = self.FFD.embededVolumes[ptSetName].dPtdCoef\n if dPtdCoef is not None:\n for ii in range(3):\n Xfinal[:, ii] += imag_j * dPtdCoef.dot(imag_part[:, ii])\n\n # now do the same for the children\n for iChild in range(len(self.children)):\n # first, update the coef. to their new locations\n child = self.children[iChild]\n child._finalize()\n self.applyToChild(iChild)\n\n # now cast forward the complex part of the derivative\n child._complexifyCoef()\n child.FFD.coef = child.FFD.coef.astype(\"D\")\n\n dXrefdCoef = self.FFD.embededVolumes[\"child%d_axis\" % (iChild)].dPtdCoef\n dCcdCoef = self.FFD.embededVolumes[\"child%d_coef\" % (iChild)].dPtdCoef\n\n if dXrefdCoef is not None:\n for ii in range(3):\n child.coef[:, ii] += imag_j * dXrefdCoef.dot(imag_part[:, ii])\n\n if dCcdCoef is not None:\n for ii in range(3):\n child.FFD.coef[:, ii] += imag_j * dCcdCoef.dot(imag_part[:, ii])\n child.refAxis.coef = child.coef.copy()\n child.refAxis._updateCurveCoef()\n Xfinal += child._update_deriv_cs(ptSetName, config=config)\n child._unComplexifyCoef()\n\n self.FFD.coef = self.FFD.coef.real.astype(\"d\")\n\n if self.isChild:\n return Xfinal - Xstart\n else:\n return Xfinal\n\n def _complexifyCoef(self):\n \"\"\"Convert coef to complex temporarily\"\"\"\n if len(self.axis) > 0:\n for key in self.axis:\n self.rot_x[key].coef = self.rot_x[key].coef.astype(\"D\")\n self.rot_y[key].coef = self.rot_y[key].coef.astype(\"D\")\n self.rot_z[key].coef = self.rot_z[key].coef.astype(\"D\")\n self.rot_theta[key].coef = self.rot_theta[key].coef.astype(\"D\")\n\n self.scale[key].coef = self.scale[key].coef.astype(\"D\")\n self.scale_x[key].coef = self.scale_x[key].coef.astype(\"D\")\n self.scale_y[key].coef = self.scale_y[key].coef.astype(\"D\")\n self.scale_z[key].coef = self.scale_z[key].coef.astype(\"D\")\n\n for i in range(self.refAxis.nCurve):\n self.refAxis.curves[i].coef = self.refAxis.curves[i].coef.astype(\"D\")\n self.coef = self.coef.astype(\"D\")\n\n def _unComplexifyCoef(self):\n \"\"\"Convert coef back to reals\"\"\"\n if len(self.axis) > 0 and not self.complex:\n for key in self.axis:\n self.rot_x[key].coef = self.rot_x[key].coef.real.astype(\"d\")\n self.rot_y[key].coef = self.rot_y[key].coef.real.astype(\"d\")\n self.rot_z[key].coef = self.rot_z[key].coef.real.astype(\"d\")\n self.rot_theta[key].coef = self.rot_theta[key].coef.real.astype(\"d\")\n\n self.scale[key].coef = self.scale[key].coef.real.astype(\"d\")\n self.scale_x[key].coef = self.scale_x[key].coef.real.astype(\"d\")\n self.scale_y[key].coef = self.scale_y[key].coef.real.astype(\"d\")\n self.scale_z[key].coef = self.scale_z[key].coef.real.astype(\"d\")\n\n for i in range(self.refAxis.nCurve):\n self.refAxis.curves[i].coef = self.refAxis.curves[i].coef.real.astype(\"d\")\n\n self.coef = self.coef.real.astype(\"d\")\n\n def computeTotalJacobianFD(self, ptSetName, config=None):\n \"\"\"This function takes the total derivative of an objective,\n I, with respect the points controlled on this processor using FD.\n We take the transpose prodducts and mpi_allreduce them to get the\n resulting value on each processor. Note that this function is slow\n and should eventually be replaced by an analytic version.\n \"\"\"\n\n self._finalize()\n self.curPtSet = ptSetName\n\n if not (self.JT[ptSetName] is None):\n return\n\n if self.isChild:\n refFFDCoef = copy.copy(self.FFD.coef)\n refCoef = copy.copy(self.coef)\n\n # Here we set childDelta as False, but it really doesn't matter\n # whether it is True or False because we take a difference\n # between coordsph and coords0, so the Xstart would be cancelled\n # out in the end.\n coords0 = self.update(ptSetName, childDelta=False, config=config).flatten()\n\n if self.nPts[ptSetName] is None:\n self.nPts[ptSetName] = len(coords0.flatten())\n for child in self.children:\n child.nPts[ptSetName] = self.nPts[ptSetName]\n\n DVGlobalCount, DVLocalCount, DVSecLocCount, DVSpanLocCount = self._getDVOffsets()\n\n h = 1e-6\n\n self.JT[ptSetName] = np.zeros([self.nDV_T, self.nPts[ptSetName]])\n\n for key in self.DV_listGlobal:\n for j in range(self.DV_listGlobal[key].nVal):\n if self.isChild:\n self.FFD.coef = refFFDCoef.copy()\n self.coef = refCoef.copy()\n self.refAxis.coef = refCoef.copy()\n self.refAxis._updateCurveCoef()\n\n refVal = self.DV_listGlobal[key].value[j]\n\n self.DV_listGlobal[key].value[j] += h\n\n coordsph = self.update(ptSetName, childDelta=False, config=config).flatten()\n\n deriv = (coordsph - coords0) / h\n self.JT[ptSetName][DVGlobalCount, :] = deriv\n\n DVGlobalCount += 1\n self.DV_listGlobal[key].value[j] = refVal\n\n for key in self.DV_listSpanwiseLocal:\n for j in range(self.DV_listSpanwiseLocal[key].nVal):\n if self.isChild:\n self.FFD.coef = refFFDCoef.copy()\n self.coef = refCoef.copy()\n self.refAxis.coef = refCoef.copy()\n self.refAxis._updateCurveCoef()\n\n refVal = self.DV_listSpanwiseLocal[key].value[j]\n\n self.DV_listSpanwiseLocal[key].value[j] += h\n coordsph = self.update(ptSetName, childDelta=False, config=config).flatten()\n\n deriv = (coordsph - coords0) / h\n self.JT[ptSetName][DVSpanLocCount, :] = deriv\n\n DVSpanLocCount += 1\n self.DV_listSpanwiseLocal[key].value[j] = refVal\n\n for key in self.DV_listSectionLocal:\n for j in range(self.DV_listSectionLocal[key].nVal):\n if self.isChild:\n self.FFD.coef = refFFDCoef.copy()\n self.coef = refCoef.copy()\n self.refAxis.coef = refCoef.copy()\n self.refAxis._updateCurveCoef()\n\n refVal = self.DV_listSectionLocal[key].value[j]\n\n self.DV_listSectionLocal[key].value[j] += h\n coordsph = self.update(ptSetName, childDelta=False, config=config).flatten()\n\n deriv = (coordsph - coords0) / h\n self.JT[ptSetName][DVSecLocCount, :] = deriv\n\n DVSecLocCount += 1\n self.DV_listSectionLocal[key].value[j] = refVal\n\n for key in self.DV_listLocal:\n for j in range(self.DV_listLocal[key].nVal):\n if self.isChild:\n self.FFD.coef = refFFDCoef.copy()\n self.coef = refCoef.copy()\n self.refAxis.coef = refCoef.copy()\n self.refAxis._updateCurveCoef()\n\n refVal = self.DV_listLocal[key].value[j]\n\n self.DV_listLocal[key].value[j] += h\n coordsph = self.update(ptSetName, childDelta=False, config=config).flatten()\n\n deriv = (coordsph - coords0) / h\n self.JT[ptSetName][DVLocalCount, :] = deriv\n\n DVLocalCount += 1\n self.DV_listLocal[key].value[j] = refVal\n\n for iChild in range(len(self.children)):\n child = self.children[iChild]\n child._finalize()\n\n # In the updates applied previously, the FFD points on the children\n # will have been set as deltas. We need to set them as absolute\n # coordinates based on the changes in the parent before moving down\n # to the next level\n self.applyToChild(iChild)\n\n # Now get jacobian from child and add to parent jacobian\n child.computeTotalJacobianFD(ptSetName, config=config)\n self.JT[ptSetName] = self.JT[ptSetName] + child.JT[ptSetName]\n\n return\n\n def _attachedPtJacobian(self, config):\n \"\"\"\n Compute the derivative of the the attached points\n \"\"\"\n nDV = self._getNDVGlobalSelf()\n\n self._getDVOffsets()\n\n h = 1.0e-40j\n oneoverh = 1.0 / 1e-40\n # Just do a CS loop over the coef\n # First sum the actual number of globalDVs\n if nDV != 0: # check this\n # create a jacobian the size of nPtAttached full by self.nDV_T, the total number of\n # dvs\n Jacobian = np.zeros((self.nPtAttachFull * 3, self.nDV_T))\n\n # Create the storage arrays for the information that must be\n # passed to the children\n for iChild in range(len(self.children)):\n N = self.FFD.embededVolumes[\"child%d_axis\" % (iChild)].N\n # Derivative of reference axis points wrt global DVs at this level\n self.children[iChild].dXrefdXdvg = np.zeros((N * 3, self.nDV_T))\n\n N = self.FFD.embededVolumes[\"child%d_coef\" % (iChild)].N\n # derivative of the control points wrt the global DVs at this level\n self.children[iChild].dCcdXdvg = np.zeros((N * 3, self.nDV_T))\n\n # We need to save the reference state so that we can always start\n # from the same place when calling _update_deriv\n refFFDCoef = copy.copy(self.FFD.coef)\n refCoef = copy.copy(self.coef)\n\n iDV = self.nDVG_count\n for key in self.DV_listGlobal:\n if (\n self.DV_listGlobal[key].config is None\n or config is None\n or any(c0 == config for c0 in self.DV_listGlobal[key].config)\n ):\n nVal = self.DV_listGlobal[key].nVal\n for j in range(nVal):\n\n refVal = self.DV_listGlobal[key].value[j]\n\n self.DV_listGlobal[key].value[j] += h\n\n # Reset coefficients\n self.FFD.coef = refFFDCoef.astype(\"D\") # ffd coefficients\n self.coef = refCoef.astype(\"D\")\n self.refAxis.coef = refCoef.astype(\"D\")\n self._complexifyCoef() # Make sure coefficients are complex\n self.refAxis._updateCurveCoef()\n\n deriv = oneoverh * np.imag(self._update_deriv(iDV, h, oneoverh, config=config)).flatten()\n # reset the FFD and axis\n self._unComplexifyCoef()\n self.FFD.coef = self.FFD.coef.real.astype(\"d\")\n\n np.put(Jacobian[0::3, iDV], self.ptAttachInd, deriv[0::3])\n np.put(Jacobian[1::3, iDV], self.ptAttachInd, deriv[1::3])\n np.put(Jacobian[2::3, iDV], self.ptAttachInd, deriv[2::3])\n\n iDV += 1\n\n self.DV_listGlobal[key].value[j] = refVal\n else:\n iDV += self.DV_listGlobal[key].nVal\n else:\n Jacobian = None\n\n return Jacobian\n\n def _spanwiselocalDVJacobian(self, config=None):\n \"\"\"\n Return the derivative of the coefficients wrt the local normal design\n variables\n \"\"\"\n # This is relatively straight forward, since the matrix is\n # entirely one's or zeros\n nDV = self._getNDVSpanwiseLocalSelf()\n self._getDVOffsets()\n\n if nDV != 0:\n Jacobian = sparse.lil_matrix((self.nPtAttachFull * 3, self.nDV_T))\n\n # Create the storage arrays for the information that must be\n # passed to the children\n\n for iChild in range(len(self.children)):\n N = self.FFD.embededVolumes[\"child%d_axis\" % (iChild)].N\n self.children[iChild].dXrefdXdvl = np.zeros((N * 3, self.nDV_T))\n\n N = self.FFD.embededVolumes[\"child%d_coef\" % (iChild)].N\n self.children[iChild].dCcdXdvl = np.zeros((N * 3, self.nDV_T))\n\n iDVSpanwiseLocal = self.nDVSW_count\n for key in self.DV_listSpanwiseLocal:\n dv = self.DV_listSpanwiseLocal[key]\n\n # check that the dv is active for this config\n if dv.config is None or config is None or any(c0 == config for c0 in dv.config):\n nVal = dv.nVal\n\n # apply this dv to FFD\n self.DV_listSpanwiseLocal[key](self.FFD.coef, config)\n\n # loop over value of the dv\n # (for example a single shape dv may have 20 values that\n # control the shape of the FFD at 20 points)\n for j in range(nVal):\n coefs = dv.dv_to_coefs[j] # affected control points of FFD\n\n # this is map from dvs to coef\n for coef in coefs:\n irow = coef * 3 + dv.axis\n # *3 because the jacobian has a row for each x,y,z of the FFD\n # It is basically\n # row number = coef index * n dimensions + dimension index\n\n # value of FFD node location = x0 + dv_SWLocal[j]\n # so partial(FFD node location)/partial(dv_SWLocal) = 1\n # for each node effected by the dv_SWLocal[j]\n Jacobian[irow, iDVSpanwiseLocal] = 1.0\n\n for iChild in range(len(self.children)):\n # Get derivatives of child ref axis and FFD control\n # points w.r.t. parent's FFD control points\n dXrefdCoef = self.FFD.embededVolumes[\"child%d_axis\" % (iChild)].dPtdCoef\n dCcdCoef = self.FFD.embededVolumes[\"child%d_coef\" % (iChild)].dPtdCoef\n\n # derivative of Change in the FFD coef due to DVs\n # same as Jacobian above, but differnt ordering\n dCoefdXdvl = np.zeros(self.FFD.coef.shape, dtype=\"d\")\n\n for coef in coefs:\n dCoefdXdvl[coef, dv.axis] = 1.0\n\n dXrefdXdvl = np.zeros((dXrefdCoef.shape[0] * 3), \"d\")\n dCcdXdvl = np.zeros((dCcdCoef.shape[0] * 3), \"d\")\n\n dXrefdXdvl[0::3] = dXrefdCoef.dot(dCoefdXdvl[:, 0])\n dXrefdXdvl[1::3] = dXrefdCoef.dot(dCoefdXdvl[:, 1])\n dXrefdXdvl[2::3] = dXrefdCoef.dot(dCoefdXdvl[:, 2])\n\n dCcdXdvl[0::3] = dCcdCoef.dot(dCoefdXdvl[:, 0])\n dCcdXdvl[1::3] = dCcdCoef.dot(dCoefdXdvl[:, 1])\n dCcdXdvl[2::3] = dCcdCoef.dot(dCoefdXdvl[:, 2])\n\n # TODO: the += here is to allow recursion check this with multiple nesting\n # levels\n self.children[iChild].dXrefdXdvl[:, iDVSpanwiseLocal] += dXrefdXdvl\n self.children[iChild].dCcdXdvl[:, iDVSpanwiseLocal] += dCcdXdvl\n\n iDVSpanwiseLocal += 1\n else:\n iDVSpanwiseLocal += self.DV_listSectionLocal[key].nVal\n\n # end if config check\n # end for\n else:\n Jacobian = None\n\n return Jacobian\n\n def _sectionlocalDVJacobian(self, config=None):\n \"\"\"\n Return the derivative of the coefficients wrt the local normal design\n variables\n \"\"\"\n # This is relatively straight forward, since the matrix is\n # entirely one's or zeros\n nDV = self._getNDVSectionLocalSelf()\n self._getDVOffsets()\n\n if nDV != 0:\n Jacobian = sparse.lil_matrix((self.nPtAttachFull * 3, self.nDV_T))\n\n # Create the storage arrays for the information that must be\n # passed to the children\n\n for iChild in range(len(self.children)):\n N = self.FFD.embededVolumes[\"child%d_axis\" % (iChild)].N\n self.children[iChild].dXrefdXdvl = np.zeros((N * 3, self.nDV_T))\n\n N = self.FFD.embededVolumes[\"child%d_coef\" % (iChild)].N\n self.children[iChild].dCcdXdvl = np.zeros((N * 3, self.nDV_T))\n\n iDVSectionLocal = self.nDVSL_count\n for key in self.DV_listSectionLocal:\n dv = self.DV_listSectionLocal[key]\n if dv.config is None or config is None or any(c0 == config for c0 in dv.config):\n nVal = dv.nVal\n\n self.DV_listSectionLocal[key](self.FFD.coef, self.coefRotM, config)\n\n for j in range(nVal):\n coef = dv.coefList[j] # affected control point\n T = dv.sectionTransform[dv.sectionLink[coef]]\n inFrame = np.zeros((3, 1))\n # Set axis that is being perturbed to 1.0\n inFrame[dv.axis] = 1.0\n\n R = np.real(self.coefRotM[coef])\n # this is a bug fix for scipy 1.3+ related to fancy indexing\n # the original was:\n # rows = range(coef*3,(coef+1)*3)\n # Jacobian[rows, iDVSectionLocal] += R.dot(T.dot(inFrame))\n Jacobian[coef * 3 : (coef + 1) * 3, iDVSectionLocal] += R.dot(T.dot(inFrame))\n for iChild in range(len(self.children)):\n\n dXrefdCoef = self.FFD.embededVolumes[\"child%d_axis\" % (iChild)].dPtdCoef\n dCcdCoef = self.FFD.embededVolumes[\"child%d_coef\" % (iChild)].dPtdCoef\n\n tmp = np.zeros(self.FFD.coef.shape, dtype=\"d\")\n\n tmp[coef, :] = R.dot(T.dot(inFrame)).flatten()\n\n dXrefdXdvl = np.zeros((dXrefdCoef.shape[0] * 3), \"d\")\n dCcdXdvl = np.zeros((dCcdCoef.shape[0] * 3), \"d\")\n\n dXrefdXdvl[0::3] = dXrefdCoef.dot(tmp[:, 0])\n dXrefdXdvl[1::3] = dXrefdCoef.dot(tmp[:, 1])\n dXrefdXdvl[2::3] = dXrefdCoef.dot(tmp[:, 2])\n\n dCcdXdvl[0::3] = dCcdCoef.dot(tmp[:, 0])\n dCcdXdvl[1::3] = dCcdCoef.dot(tmp[:, 1])\n dCcdXdvl[2::3] = dCcdCoef.dot(tmp[:, 2])\n\n # TODO: the += here is to allow recursion check this with multiple nesting\n # levels\n self.children[iChild].dXrefdXdvl[:, iDVSectionLocal] += dXrefdXdvl\n self.children[iChild].dCcdXdvl[:, iDVSectionLocal] += dCcdXdvl\n iDVSectionLocal += 1\n else:\n iDVSectionLocal += self.DV_listSectionLocal[key].nVal\n\n # end if config check\n # end for\n else:\n Jacobian = None\n\n return Jacobian\n\n def _localDVJacobian(self, config=None):\n \"\"\"\n Return the derivative of the coefficients wrt the local design\n variables\n \"\"\"\n\n # This is relatively straight forward, since the matrix is\n # entirely one's or zeros\n nDV = self._getNDVLocalSelf()\n self._getDVOffsets()\n\n if nDV != 0:\n Jacobian = sparse.lil_matrix((self.nPtAttachFull * 3, self.nDV_T))\n\n # Create the storage arrays for the information that must be\n # passed to the children\n for iChild in range(len(self.children)):\n N = self.FFD.embededVolumes[\"child%d_axis\" % (iChild)].N\n self.children[iChild].dXrefdXdvl = np.zeros((N * 3, self.nDV_T))\n\n N = self.FFD.embededVolumes[\"child%d_coef\" % (iChild)].N\n self.children[iChild].dCcdXdvl = np.zeros((N * 3, self.nDV_T))\n\n iDVLocal = self.nDVL_count\n for key in self.DV_listLocal:\n if (\n self.DV_listLocal[key].config is None\n or config is None\n or any(c0 == config for c0 in self.DV_listLocal[key].config)\n ):\n\n self.DV_listLocal[key](self.FFD.coef, config)\n\n nVal = self.DV_listLocal[key].nVal\n for j in range(nVal):\n pt_dv = self.DV_listLocal[key].coefList[j]\n irow = pt_dv[0] * 3 + pt_dv[1]\n Jacobian[irow, iDVLocal] = 1.0\n\n for iChild in range(len(self.children)):\n # Get derivatives of child ref axis and FFD control\n # points w.r.t. parent's FFD control points\n dXrefdCoef = self.FFD.embededVolumes[\"child%d_axis\" % (iChild)].dPtdCoef\n dCcdCoef = self.FFD.embededVolumes[\"child%d_coef\" % (iChild)].dPtdCoef\n\n tmp = np.zeros(self.FFD.coef.shape, dtype=\"d\")\n\n tmp[pt_dv[0], pt_dv[1]] = 1.0\n\n dXrefdXdvl = np.zeros((dXrefdCoef.shape[0] * 3), \"d\")\n dCcdXdvl = np.zeros((dCcdCoef.shape[0] * 3), \"d\")\n\n dXrefdXdvl[0::3] = dXrefdCoef.dot(tmp[:, 0])\n dXrefdXdvl[1::3] = dXrefdCoef.dot(tmp[:, 1])\n dXrefdXdvl[2::3] = dXrefdCoef.dot(tmp[:, 2])\n\n dCcdXdvl[0::3] = dCcdCoef.dot(tmp[:, 0])\n dCcdXdvl[1::3] = dCcdCoef.dot(tmp[:, 1])\n dCcdXdvl[2::3] = dCcdCoef.dot(tmp[:, 2])\n\n # TODO: the += here is to allow recursion check this with multiple nesting\n # levels\n self.children[iChild].dXrefdXdvl[:, iDVLocal] += dXrefdXdvl\n self.children[iChild].dCcdXdvl[:, iDVLocal] += dCcdXdvl\n iDVLocal += 1\n else:\n iDVLocal += self.DV_listLocal[key].nVal\n\n # end if config check\n # end for\n else:\n Jacobian = None\n\n return Jacobian\n\n def _cascadedDVJacobian(self, config=None):\n \"\"\"\n Compute the cascading derivatives from the parent to the child\n \"\"\"\n\n if not self.isChild:\n return None\n\n # we are now on a child. Add in dependence passed from parent\n Jacobian = sparse.lil_matrix((self.nPtAttachFull * 3, self.nDV_T))\n\n # Save reference values (these are necessary so that we always start\n # from the base state on the current DVGeo, and then apply the design\n # variables from there).\n refFFDCoef = copy.copy(self.FFD.coef)\n refCoef = copy.copy(self.coef)\n\n h = 1.0e-40j\n oneoverh = 1.0 / 1e-40\n if self.dXrefdXdvg is not None:\n for iDV in range(self.dXrefdXdvg.shape[1]):\n nz1 = np.count_nonzero(self.dXrefdXdvg[:, iDV])\n nz2 = np.count_nonzero(self.dCcdXdvg[:, iDV])\n if nz1 + nz2 == 0:\n continue\n\n # Complexify all of the coefficients\n self.FFD.coef = refFFDCoef.astype(\"D\")\n self.coef = refCoef.astype(\"D\")\n self._complexifyCoef()\n\n # Add a complex pertubation representing the change in the child\n # reference axis wrt the parent global DVs\n self.coef[:, 0] += self.dXrefdXdvg[0::3, iDV] * h\n self.coef[:, 1] += self.dXrefdXdvg[1::3, iDV] * h\n self.coef[:, 2] += self.dXrefdXdvg[2::3, iDV] * h\n\n # insert the new coef into the refAxis\n self.refAxis.coef = self.coef.copy()\n self.refAxis._updateCurveCoef()\n\n # Complexify the child FFD coords\n tmp1 = np.zeros_like(self.FFD.coef, dtype=\"D\")\n\n # add the effect of the global coordinates on the actual control points\n tmp1[:, 0] = self.dCcdXdvg[0::3, iDV] * h\n tmp1[:, 1] = self.dCcdXdvg[1::3, iDV] * h\n tmp1[:, 2] = self.dCcdXdvg[2::3, iDV] * h\n\n self.FFD.coef += tmp1\n\n # Store the original FFD coordinates so that we can get the delta\n oldCoefLocations = self.FFD.coef.copy()\n\n # compute the deriv of the child FFD coords wrt the parent by processing\n # the above CS perturbation\n new_pts = self._update_deriv(iDV, h, oneoverh, config=config)\n\n # insert this result in the the correct locations of a vector the correct\n # size\n np.put(self.FFD.coef[:, 0], self.ptAttachInd, new_pts[:, 0])\n np.put(self.FFD.coef[:, 1], self.ptAttachInd, new_pts[:, 1])\n np.put(self.FFD.coef[:, 2], self.ptAttachInd, new_pts[:, 2])\n\n # We have to subtract off the oldCoefLocations because we only\n # want the cascading effect on the current design variables. The\n # complex part on oldCoefLocations was already accounted for on\n # the parent.\n self.FFD.coef -= oldCoefLocations\n\n # sum up all of the various influences\n Jacobian[0::3, iDV] += oneoverh * np.imag(self.FFD.coef[:, 0:1])\n Jacobian[1::3, iDV] += oneoverh * np.imag(self.FFD.coef[:, 1:2])\n Jacobian[2::3, iDV] += oneoverh * np.imag(self.FFD.coef[:, 2:3])\n\n # decomplexify the coefficients\n self.coef = self.coef.real.astype(\"d\")\n self.FFD.coef = self.FFD.coef.real.astype(\"d\")\n self._unComplexifyCoef()\n\n if self.dXrefdXdvl is not None:\n # Now repeat for the local variables\n for iDV in range(self.dXrefdXdvl.shape[1]):\n # check if there is any dependence on this DV\n nz1 = np.count_nonzero(self.dXrefdXdvl[:, iDV])\n nz2 = np.count_nonzero(self.dCcdXdvl[:, iDV])\n if nz1 + nz2 == 0:\n continue\n\n # Complexify all of the coefficients\n self.FFD.coef = refFFDCoef.astype(\"D\")\n self.coef = refCoef.astype(\"D\")\n self._complexifyCoef()\n\n # Add a complex pertubation representing the change in the child\n # reference axis wrt the parent local DVs\n self.coef[:, 0] += self.dXrefdXdvl[0::3, iDV] * h\n self.coef[:, 1] += self.dXrefdXdvl[1::3, iDV] * h\n self.coef[:, 2] += self.dXrefdXdvl[2::3, iDV] * h\n\n # insert the new coef into the refAxis\n self.refAxis.coef = self.coef.copy()\n self.refAxis._updateCurveCoef()\n\n # Complexify the child FFD coords\n tmp1 = np.zeros_like(self.FFD.coef, dtype=\"D\")\n\n # add the effect of the global coordinates on the actual control points\n tmp1[:, 0] = self.dCcdXdvl[0::3, iDV] * h\n tmp1[:, 1] = self.dCcdXdvl[1::3, iDV] * h\n tmp1[:, 2] = self.dCcdXdvl[2::3, iDV] * h\n\n self.FFD.coef += tmp1\n\n # Store the original FFD coordinates so that we can get the delta\n oldCoefLocations = self.FFD.coef.copy()\n\n # compute the deriv of the child FFD coords wrt the parent by processing\n # the above CS perturbation\n new_pts = self._update_deriv(iDV, h, oneoverh, config=config, localDV=True)\n np.put(self.FFD.coef[:, 0], self.ptAttachInd, new_pts[:, 0])\n np.put(self.FFD.coef[:, 1], self.ptAttachInd, new_pts[:, 1])\n np.put(self.FFD.coef[:, 2], self.ptAttachInd, new_pts[:, 2])\n\n # We have to subtract off the oldCoefLocations because we only\n # want the cascading effect on the current design variables. The\n # complex part on oldCoefLocations was already accounted for on\n # the parent.\n self.FFD.coef -= oldCoefLocations\n\n # sum up all of the various influences\n Jacobian[0::3, iDV] += oneoverh * np.imag(self.FFD.coef[:, 0:1])\n Jacobian[1::3, iDV] += oneoverh * np.imag(self.FFD.coef[:, 1:2])\n Jacobian[2::3, iDV] += oneoverh * np.imag(self.FFD.coef[:, 2:3])\n\n # decomplexify the coefficients\n self.coef = self.coef.real.astype(\"d\")\n self.FFD.coef = self.FFD.coef.real.astype(\"d\")\n self._unComplexifyCoef()\n\n return Jacobian\n\n def _writeVols(self, handle, vol_counter):\n for i in range(len(self.FFD.vols)):\n writeTecplot3D(handle, \"vol%d\" % i, self.FFD.vols[i].coef)\n vol_counter += 1\n\n # Write children volumes:\n for iChild in range(len(self.children)):\n vol_counter += self.children[iChild]._writeVols(handle, vol_counter)\n\n return vol_counter\n\n def checkDerivatives(self, ptSetName):\n \"\"\"\n Run a brute force FD check on ALL design variables\n\n Parameters\n ----------\n ptSetName : str\n name of the point set to check\n \"\"\"\n\n print(\"Computing Analytic Jacobian...\")\n self.zeroJacobians(ptSetName)\n for child in self.children:\n child.zeroJacobians(ptSetName)\n\n self.computeTotalJacobian(ptSetName)\n # self.computeTotalJacobian_fast(ptSetName)\n\n Jac = copy.deepcopy(self.JT[ptSetName])\n\n # Global Variables\n print(\"========================================\")\n print(\" Global Variables \")\n print(\"========================================\")\n\n if self.isChild:\n refFFDCoef = copy.copy(self.FFD.coef)\n refCoef = copy.copy(self.coef)\n\n coords0 = self.update(ptSetName).flatten()\n\n h = 1e-6\n\n # figure out the split between local and global Variables\n DVCountGlob, DVCountLoc, DVCountSecLoc, DVCountSpanLoc = self._getDVOffsets()\n\n for key in self.DV_listGlobal:\n for j in range(self.DV_listGlobal[key].nVal):\n\n print(\"========================================\")\n print(\" GlobalVar(%s), Value(%d)\" % (key, j))\n print(\"========================================\")\n\n if self.isChild:\n self.FFD.coef = refFFDCoef.copy()\n self.coef = refCoef.copy()\n self.refAxis.coef = self.coef.copy()\n self.refAxis._updateCurveCoef()\n\n refVal = self.DV_listGlobal[key].value[j]\n\n self.DV_listGlobal[key].value[j] += h\n\n coordsph = self.update(ptSetName).flatten()\n\n deriv = (coordsph - coords0) / h\n\n for ii in range(len(deriv)):\n\n relErr = (deriv[ii] - Jac[DVCountGlob, ii]) / (1e-16 + Jac[DVCountGlob, ii])\n absErr = deriv[ii] - Jac[DVCountGlob, ii]\n\n if abs(relErr) > h * 10 and abs(absErr) > h * 10:\n print(ii, deriv[ii], Jac[DVCountGlob, ii], relErr, absErr)\n\n DVCountGlob += 1\n self.DV_listGlobal[key].value[j] = refVal\n\n for key in self.DV_listLocal:\n for j in range(self.DV_listLocal[key].nVal):\n\n print(\"========================================\")\n print(\" LocalVar(%s), Value(%d) \" % (key, j))\n print(\"========================================\")\n\n if self.isChild:\n self.FFD.coef = refFFDCoef.copy()\n self.coef = refCoef.copy()\n self.refAxis.coef = self.coef.copy()\n self.refAxis._updateCurveCoef()\n\n refVal = self.DV_listLocal[key].value[j]\n\n self.DV_listLocal[key].value[j] += h\n coordsph = self.update(ptSetName).flatten()\n\n deriv = (coordsph - coords0) / h\n\n for ii in range(len(deriv)):\n relErr = (deriv[ii] - Jac[DVCountLoc, ii]) / (1e-16 + Jac[DVCountLoc, ii])\n absErr = deriv[ii] - Jac[DVCountLoc, ii]\n\n if abs(relErr) > h and abs(absErr) > h:\n print(ii, deriv[ii], Jac[DVCountLoc, ii], relErr, absErr)\n\n DVCountLoc += 1\n self.DV_listLocal[key].value[j] = refVal\n\n for key in self.DV_listSectionLocal:\n for j in range(self.DV_listSectionLocal[key].nVal):\n\n print(\"========================================\")\n print(\" SectionLocalVar(%s), Value(%d) \" % (key, j))\n print(\"========================================\")\n\n if self.isChild:\n self.FFD.coef = refFFDCoef.copy()\n self.coef = refCoef.copy()\n self.refAxis.coef = self.coef.copy()\n self.refAxis._updateCurveCoef()\n\n refVal = self.DV_listSectionLocal[key].value[j]\n\n self.DV_listSectionLocal[key].value[j] += h\n coordsph = self.update(ptSetName).flatten()\n\n deriv = (coordsph - coords0) / h\n\n for ii in range(len(deriv)):\n relErr = (deriv[ii] - Jac[DVCountSecLoc, ii]) / (1e-16 + Jac[DVCountSecLoc, ii])\n absErr = deriv[ii] - Jac[DVCountSecLoc, ii]\n\n if abs(relErr) > h and abs(absErr) > h:\n print(ii, deriv[ii], Jac[DVCountSecLoc, ii], relErr, absErr)\n\n DVCountSecLoc += 1\n self.DV_listSectionLocal[key].value[j] = refVal\n\n for key in self.DV_listSpanwiseLocal:\n for j in range(self.DV_listSpanwiseLocal[key].nVal):\n\n print(\"========================================\")\n print(\" SpanwiseLocalVar(%s), Value(%d) \" % (key, j))\n print(\"========================================\")\n\n if self.isChild:\n self.FFD.coef = refFFDCoef.copy()\n self.coef = refCoef.copy()\n self.refAxis.coef = self.coef.copy()\n self.refAxis._updateCurveCoef()\n\n refVal = self.DV_listSpanwiseLocal[key].value[j]\n\n self.DV_listSpanwiseLocal[key].value[j] += h\n coordsph = self.update(ptSetName).flatten()\n\n deriv = (coordsph - coords0) / h\n\n for ii in range(len(deriv)):\n relErr = (deriv[ii] - Jac[DVCountSpanLoc, ii]) / (1e-16 + Jac[DVCountSpanLoc, ii])\n absErr = deriv[ii] - Jac[DVCountSpanLoc, ii]\n\n if abs(relErr) > h and abs(absErr) > h:\n print(ii, deriv[ii], Jac[DVCountSpanLoc, ii], relErr, absErr)\n # print(ii, deriv[ii], Jac[DVCountSpanLoc, ii], relErr, absErr)\n\n DVCountSpanLoc += 1\n self.DV_listSpanwiseLocal[key].value[j] = refVal\n\n for child in self.children:\n child.checkDerivatives(ptSetName)\n\n def printDesignVariables(self):\n \"\"\"\n Print a formatted list of design variables to the screen\n \"\"\"\n for dg in self.DV_listGlobal:\n print(\"%s\" % (self.DV_listGlobal[dg].name))\n for i in range(self.DV_listGlobal[dg].nVal):\n print(\"%20.15f\" % (self.DV_listGlobal[dg].value[i]))\n\n for dl in self.DV_listLocal:\n print(\"%s\" % (self.DV_listLocal[dl].name))\n for i in range(self.DV_listLocal[dl].nVal):\n print(\"%20.15f\" % (self.DV_listLocal[dl].value[i]))\n\n for dsl in self.DV_listSectionLocal:\n print(\"%s\" % (self.DV_listSectionLocal[dsl].name))\n for i in range(self.DV_listSectionLocal[dsl].nVal):\n print(\"%20.15f\" % (self.DV_listSectionLocal[dsl].value[i]))\n\n for child in self.children:\n child.printDesignVariables()\n\n def sectionFrame(self, sectionIndex, sectionTransform, sectionLink, ivol=0, orient0=None, orient2=\"svd\"):\n \"\"\"\n This function computes a unique reference coordinate frame for each\n section of an FFD volume. You can choose which axis of the FFD you would\n like these sections to be defined by. For example, if we have a wing\n with a winglet, the airfoil sections which make up the wing will not all\n lie in parallel planes. We want to find a reference frame for each of\n these airfoil sections so that we can constrain local control points to\n deform within the sectional plane. Let's say the wing FFD is oriented\n with indices:\n\n `i`\n along chord\n `j`\n normal to wing surface\n `k`\n along span\n\n If we choose `sectionIndex='k'`, this function will compute a frame which\n has two axes aligned with the k-planes of the FFD volume. This is useful\n because in some cases (as with a winglet), we want to perturb sectional\n control points within the section plane instead of in the global\n coordinate directions.\n\n Assumptions:\n\n * the normal direction is computed along the block index with size 2\n * all point for a given sectionIndex lie within a plane\n\n Parameters\n ----------\n sectionIndex : `i`, `j`, or `k`\n This the index of the FFD which defines a section plane.\n\n orient0 : None, `i`, `j`, `k`, or numpy vector. Default is None.\n Although secIndex defines the '2' axis, the '0' and '1' axes are still\n free to rotate within the section plane. We will choose the orientation\n of the '0' axis and let '1' be orthogonal. See `addLocalSectionDV`\n for a more detailed description.\n\n ivol : integer\n Volume ID for the volume in which section normals will be computed.\n\n alignStreamwise : `x`, `y`, or `z` (optional)\n If given, section frames are rotated about the k-plane normal\n so that the longitudinal axis is parallel with the given streamwise\n direction.\n\n rootGlobal : list\n List of sections along specified axis that will be fixed to the\n global coordinate frame.\n\n Returns\n -------\n sectionTransform : list of 3x3 arrays\n List of transformation matrices for the sections of a given volume.\n Transformations are set up from local section frame to global frame.\n \"\"\"\n # xyz_2_idx = {\"x\": 0, \"y\": 1, \"z\": 2}\n ijk_2_idx = {\"i\": 0, \"j\": 1, \"k\": 2}\n lIndex = self.FFD.topo.lIndex[ivol]\n\n # Get normal index\n orient0idx = False\n orient0vec = False\n if orient0 is not None:\n if type(orient0) is str:\n orient0 = ijk_2_idx[orient0.lower()]\n orient0idx = True\n elif type(orient0) is np.ndarray:\n orient0vec = True\n else:\n raise Error(\"orient0 must be an index (i, j, or k) or a \" \"vector.\")\n # Get section index and number of sections\n sectionIndex = ijk_2_idx[sectionIndex.lower()]\n nSections = lIndex.shape[sectionIndex]\n\n # Roll lIndex so that 0th index is sectionIndex and 1st index is orient0\n rolledlIndex = np.rollaxis(lIndex, sectionIndex, 0)\n if orient0idx:\n if orient0 != 2:\n orient0 += 1\n rolledlIndex = np.rollaxis(rolledlIndex, orient0, 1)\n\n # Length of sectionTransform\n Tcount = len(sectionTransform)\n\n for i in range(nSections):\n # Compute singular value decomposition of points in section (the\n # U matrix should provide us with a pretty good approximation\n # of the transformation matrix)\n pts = self.FFD.coef[rolledlIndex[i, :, :]]\n nJ, nI = pts.shape[:-1]\n X = np.reshape(pts, (nI * nJ, 3))\n c = np.mean(X, 0)\n A = X - c\n U, S, V = np.linalg.svd(A.T)\n\n # Choose section plane normal axis\n if orient2 == \"svd\":\n ax2 = U[:, 2]\n elif orient2 == \"ffd\":\n # Use a centered FD approximation (first order at the boundaries)\n if i == 0:\n pt = np.mean(self.FFD.coef[rolledlIndex[i, :, :]].reshape(nI * nJ, 3), 0)\n ptp = np.mean(self.FFD.coef[rolledlIndex[i + 1, :, :]].reshape(nI * nJ, 3), 0)\n ax2 = ptp - pt\n elif i == nSections - 1:\n pt = np.mean(self.FFD.coef[rolledlIndex[i, :, :]].reshape(nI * nJ, 3), 0)\n ptm = np.mean(self.FFD.coef[rolledlIndex[i - 1, :, :]].reshape(nI * nJ, 3), 0)\n ax2 = pt - ptm\n else:\n ptp = np.mean(self.FFD.coef[rolledlIndex[i + 1, :, :]].reshape(nI * nJ, 3), 0)\n ptm = np.mean(self.FFD.coef[rolledlIndex[i - 1, :, :]].reshape(nI * nJ, 3), 0)\n ax2 = ptp - ptm\n ax2 /= np.linalg.norm(ax2)\n else:\n raise Error(\"orient2 must be 'svd' or 'ffd'\")\n\n # Options for choosing in-plane axes\n # 1. Align axis '0' with projection of the given vector on section\n # plane.\n # 2. Align axis '0' with the projection of an average\n # difference vector between opposing edges of FFD block\n # section plane\n # 3. Use the default SVD decomposition (in general this will work).\n # It will choose the chordwise direction as the best fit line\n # through the section points.\n if orient0vec or orient0idx:\n if orient0vec:\n u = orient0 / np.linalg.norm(orient0)\n else:\n u = np.mean((pts[-1, :] - pts[0, :]), axis=0)\n u = u / np.linalg.norm(u)\n ax0 = u - u.dot(ax2) * ax2\n ax1 = np.cross(ax2, ax0)\n else:\n ax0 = U[:, 0]\n ax1 = U[:, 1]\n\n T = np.vstack((ax0, ax1, ax2)).T\n sectionTransform.append(T)\n # Designate section transformation matrix for each control point in\n # section\n sectionLink[rolledlIndex[i, :, :]] = Tcount\n Tcount += 1\n\n # Need to initialize coefRotM to identity matrix for case with no\n # global design variables\n for slice in rolledlIndex[i, :, :]:\n for coef in slice:\n self.coefRotM[coef] = np.eye(3)\n\n return nSections\n\n\nclass geoDVGlobal(object):\n def __init__(self, dv_name, value, lower, upper, scale, function, config):\n \"\"\"Create a geometric design variable (or design variable group)\n See addGlobalDV in DVGeometry class for more information\n \"\"\"\n self.name = dv_name\n self.value = np.atleast_1d(np.array(value)).astype(\"D\")\n self.nVal = len(self.value)\n self.lower = None\n self.upper = None\n self.config = config\n self.function = function\n if lower is not None:\n self.lower = _convertTo1D(lower, self.nVal)\n if upper is not None:\n self.upper = _convertTo1D(upper, self.nVal)\n if scale is not None:\n self.scale = _convertTo1D(scale, self.nVal)\n\n def __call__(self, geo, config):\n \"\"\"When the object is called, actually apply the function\"\"\"\n # Run the user-supplied function\n d = np.dtype(complex)\n\n if self.config is None or config is None or any(c0 == config for c0 in self.config):\n # If the geo object is complex, which is indicated by .coef\n # being complex, run with complex numbers. Otherwise, convert\n # to real before calling. This eliminates casting warnings.\n if geo.coef.dtype == d or geo.complex:\n return self.function(self.value, geo)\n else:\n return self.function(np.real(self.value), geo)\n\n\nclass geoDVLocal(object):\n def __init__(self, dvName, lower, upper, scale, axis, coefListIn, mask, config):\n\n \"\"\"Create a set of geometric design variables which change the shape\n of a surface surface_id. Local design variables change the surface\n in all three axis.\n See addLocalDV for more information\n \"\"\"\n\n coefList = []\n # create a new coefficent list that excludes any values that are masked\n for i in range(len(coefListIn)):\n if not mask[coefListIn[i]]:\n coefList.append(coefListIn[i])\n\n N = len(axis)\n self.nVal = len(coefList) * N\n self.value = np.zeros(self.nVal, \"D\")\n self.name = dvName\n self.lower = None\n self.upper = None\n self.config = config\n if lower is not None:\n self.lower = _convertTo1D(lower, self.nVal)\n if upper is not None:\n self.upper = _convertTo1D(upper, self.nVal)\n if scale is not None:\n self.scale = _convertTo1D(scale, self.nVal)\n\n self.coefList = np.zeros((self.nVal, 2), \"intc\")\n j = 0\n\n for i in range(len(coefList)):\n if \"x\" in axis.lower():\n self.coefList[j] = [coefList[i], 0]\n j += 1\n elif \"y\" in axis.lower():\n self.coefList[j] = [coefList[i], 1]\n j += 1\n elif \"z\" in axis.lower():\n self.coefList[j] = [coefList[i], 2]\n j += 1\n\n def __call__(self, coef, config):\n \"\"\"When the object is called, apply the design variable values to\n coefficients\"\"\"\n if self.config is None or config is None or any(c0 == config for c0 in self.config):\n for i in range(self.nVal):\n coef[self.coefList[i, 0], self.coefList[i, 1]] += self.value[i].real\n\n return coef\n\n def updateComplex(self, coef, config):\n if self.config is None or config is None or any(c0 == config for c0 in self.config):\n for i in range(self.nVal):\n coef[self.coefList[i, 0], self.coefList[i, 1]] += self.value[i].imag * 1j\n\n return coef\n\n def mapIndexSets(self, indSetA, indSetB):\n \"\"\"\n Map the index sets from the full coefficient indices to the local set.\n \"\"\"\n # Temp is the list of FFD coefficients that are included\n # as shape variables in this localDV \"key\"\n temp = self.coefList\n cons = []\n for j in range(len(indSetA)):\n # Try to find this index # in the coefList (temp)\n up = None\n down = None\n\n # Note: We are doing inefficient double looping here\n for k in range(len(temp)):\n if temp[k][0] == indSetA[j]:\n up = k\n if temp[k][0] == indSetB[j]:\n down = k\n\n # If we haven't found up AND down do nothing\n if up is not None and down is not None:\n cons.append([up, down])\n\n return cons\n\n\ndef _convertTo1D(value, dim1):\n \"\"\"\n Generic function to process 'value'. In the end, it must be\n array of size dim1. value is already that shape, excellent,\n otherwise, a scalar will be 'upcast' to that size\n \"\"\"\n\n if np.isscalar:\n return value * np.ones(dim1)\n else:\n temp = np.atleast_1d(value)\n if temp.shape[0] == dim1:\n return value\n else:\n raise Error(\"The size of the 1D array was the incorret shape\")\n\n\nclass geoDVSpanwiseLocal(geoDVLocal):\n def __init__(self, dvName, lower, upper, scale, axis, vol_dv_to_coefs, mask, config):\n\n \"\"\"Create a set of geometric design variables which change the shape\n of a surface surface_id. Local design variables change the surface\n in all three axis.\n See addLocalDV for more information\n \"\"\"\n\n self.dv_to_coefs = []\n\n # add all the coefs to a flat array, but check that it isn't masked first\n for ivol in range(len(vol_dv_to_coefs)):\n for loc_dv in range(len(vol_dv_to_coefs[ivol])):\n coefs = vol_dv_to_coefs[ivol][loc_dv]\n\n loc_dv_to_coefs = []\n\n # loop through each of coefs to see if it is masked\n for coef in coefs:\n if not mask[coef]:\n loc_dv_to_coefs.append(coef)\n\n self.dv_to_coefs.append(loc_dv_to_coefs)\n\n if \"x\" == axis.lower():\n self.axis = 0\n elif \"y\" == axis.lower():\n self.axis = 1\n elif \"z\" == axis.lower():\n self.axis = 2\n else:\n raise NotImplementedError\n\n self.nVal = len(self.dv_to_coefs)\n self.value = np.zeros(self.nVal, \"D\")\n\n self.name = dvName\n self.lower = None\n self.upper = None\n self.config = config\n\n if lower is not None:\n self.lower = _convertTo1D(lower, self.nVal)\n if upper is not None:\n self.upper = _convertTo1D(upper, self.nVal)\n if scale is not None:\n self.scale = _convertTo1D(scale, self.nVal)\n\n def __call__(self, coef, config):\n \"\"\"When the object is called, apply the design variable values to\n coefficients\"\"\"\n if self.config is None or config is None or any(c0 == config for c0 in self.config):\n for i in range(self.nVal):\n coef[self.dv_to_coefs[i], self.axis] += self.value[i].real\n\n return coef\n\n def updateComplex(self, coef, config):\n if self.config is None or config is None or any(c0 == config for c0 in self.config):\n for i in range(self.nVal):\n coef[self.dv_to_coefs[i], self.axis] += self.value[i].imag * 1j\n\n return coef\n\n def mapIndexSets(self, indSetA, indSetB):\n \"\"\"\n Map the index sets from the full coefficient indices to the local set.\n \"\"\"\n\n cons = []\n for j in range(len(indSetA)):\n # Try to find this index # in the coefList (temp)\n up = None\n down = None\n\n # Note: We are doing inefficient double looping here\n for idx_dv, coefs in enumerate(self.dv_to_coefs):\n\n for coef in coefs:\n\n if coef == indSetA[j]:\n up = idx_dv\n if coef == indSetB[j]:\n down = idx_dv\n\n # If we haven't found up AND down do nothing\n if up is not None and down is not None:\n cons.append([up, down])\n\n return cons\n\n\nclass geoDVSectionLocal(object):\n def __init__(self, dvName, lower, upper, scale, axis, coefListIn, mask, config, sectionTransform, sectionLink):\n \"\"\"\n Create a set of geometric design variables which change the shape\n of a surface.\n See `addLocalSectionDV` for more information\n \"\"\"\n\n self.coefList = []\n # create a new coefficent list that excludes any values that are masked\n for i in range(len(coefListIn)):\n if not mask[coefListIn[i]]:\n self.coefList.append(coefListIn[i])\n\n self.nVal = len(self.coefList)\n self.value = np.zeros(self.nVal, \"D\")\n self.name = dvName\n self.lower = None\n self.upper = None\n self.config = config\n if lower is not None:\n self.lower = _convertTo1D(lower, self.nVal)\n if upper is not None:\n self.upper = _convertTo1D(upper, self.nVal)\n if scale is not None:\n self.scale = _convertTo1D(scale, self.nVal)\n\n self.sectionTransform = sectionTransform\n self.sectionLink = sectionLink\n\n self.axis = axis\n\n def __call__(self, coef, coefRotM, config):\n \"\"\"When the object is called, apply the design variable values to\n coefficients\"\"\"\n if self.config is None or config is None or any(c0 == config for c0 in self.config):\n for i in range(len(self.coefList)):\n T = self.sectionTransform[self.sectionLink[self.coefList[i]]]\n inFrame = np.zeros(3)\n inFrame[self.axis] = self.value[i].real\n\n R = coefRotM[self.coefList[i]].real\n coef[self.coefList[i]] += R.dot(T.dot(inFrame))\n return coef\n\n def updateComplex(self, coef, coefRotM, config):\n if self.config is None or config is None or any(c0 == config for c0 in self.config):\n for i in range(len(self.coefList)):\n T = self.sectionTransform[self.sectionLink[self.coefList[i]]]\n inFrame = np.zeros(3, \"D\")\n inFrame[self.axis] = self.value[i]\n\n R = coefRotM[self.coefList[i]]\n coef[self.coefList[i]] += R.dot(T.dot(inFrame)).imag * 1j\n return coef\n\n def mapIndexSets(self, indSetA, indSetB):\n \"\"\"\n Map the index sets from the full coefficient indices to the local set.\n \"\"\"\n # Temp is the list of FFD coefficients that are included\n # as shape variables in this localDV \"key\"\n temp = self.coefList\n cons = []\n for j in range(len(indSetA)):\n # Try to find this index # in the coefList (temp)\n up = None\n down = None\n\n # Note: We are doing inefficient double looping here\n for k in range(len(temp)):\n if temp[k] == indSetA[j]:\n up = k\n if temp[k] == indSetB[j]:\n down = k\n\n # If we haven't found up AND down do nothing\n if up is not None and down is not None:\n cons.append([up, down])\n\n return cons\n", "meta": {"hexsha": "718933829080484959d2188a9d94db8f2ce3df1b", "size": 183778, "ext": "py", "lang": "Python", "max_stars_repo_path": "pygeo/DVGeometry.py", "max_stars_repo_name": "kanekosh/pygeo", "max_stars_repo_head_hexsha": "5bd69ee47d9483d851bd2bfdc2a6135c94ad0343", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pygeo/DVGeometry.py", "max_issues_repo_name": "kanekosh/pygeo", "max_issues_repo_head_hexsha": "5bd69ee47d9483d851bd2bfdc2a6135c94ad0343", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pygeo/DVGeometry.py", "max_forks_repo_name": "kanekosh/pygeo", "max_forks_repo_head_hexsha": "5bd69ee47d9483d851bd2bfdc2a6135c94ad0343", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.3021929825, "max_line_length": 130, "alphanum_fraction": 0.552596067, "include": true, "reason": "import numpy,from scipy", "num_tokens": 43412, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5621765008857981, "lm_q2_score": 0.3415825061409754, "lm_q1q2_score": 0.19202965806613517}} {"text": "import sys\nimport csv\nimport collections\nimport math\nimport numpy as np\nimport pandas as pd\n\ndef delete_false_co(codict,mdict):\n '''Remove false positive crossover events\n based on nTypedBetween and return filtered\n dict.\n '''\n print(\"Crossovers before filtering: \" + str(len(codict)))\n # Use set as there can be quadruple crossovers\n # This leads to duplicate bad keys\n bad_keys = set()\n for key, value in codict.items():\n #nTypedBetween \n ntb = value[9]\n ind = value[1]\n genpos = value[2]\n # Skip last CO for individual\n # These can't be used for filtering\n if ntb != \"NA\":\n chr_pos1 = value[0] + \"_\" + value[3]\n co_index1 = codict.keys().index(key)\n # Get following crossover entry\n co_index2 = co_index1 + 1\n co_key2 = list(codict)[co_index2]\n chr_pos2 = codict[co_key2][0] + \"_\" + codict[co_key2][3]\n\n #Physical marker positions\n phypos1 = mdict[chr_pos1].split(\"_\")[1]\n phypos2 = mdict[chr_pos2].split(\"_\")[1]\n phychr1 = mdict[chr_pos1].split(\"_\")[0]\n phychr2 = mdict[chr_pos2].split(\"_\")[0]\n if phychr1 == phychr2:\n phydist = int(phypos2) - int(phypos1)\n # Use absolute numbers\n phydist = abs(phydist)\n else:\n # If adjacent marker is from different chromosome\n # Set arbitrary high physical distance\n phydist = 1000000\n # Genetic distance between breakpoints \n gendist = float(codict[co_key2][2]) - float(genpos)\n # Recombinations separated by less than 5 markers are false\n # Recombinations <10kb are considered gene conversions\n if int(ntb) < 5 or phydist < 10000 or gendist < 0.02:\n co_index1 = codict.keys().index(key)\n # Get following crossover entry\n co_index2 = co_index1 + 1\n co_key2 = list(codict)[co_index2]\n bad_keys.add(key)\n if ind == codict[co_key2][1]:\n bad_keys.add(co_key2)\n else:\n print(\"Aborted. Expected paired false positives.\")\n break\n # delete all the bad entries\n for bkey in bad_keys:\n codict.pop(bkey, None) \n print(\"Crossovers after filtering: \" + str(len(codict)))\n return codict\n\n# Read marker positions and crossover into dicts\n# These tables are generated with r/qtl locateXO and a custom script\n\ncrossovers = sys.argv[1] \n# Example of head -2 of input file:\n#chr,IND,location,left,right,ileft,iright,gleft,gright,nTypedBetween\n#A01,1,111.50960844248,109.290254466964,113.728962417996,402,403,3,2,323\n\nmarkers = sys.argv[2]\n# Example of head -3 of input file:\n#chr,name,value\n#A01,A01_3072290,0\n#A01,A01_3071845,1.35449890934482\n\n# Values in the markers file are genetic map positions in cM\n\nwith open(crossovers, mode='r') as co:\n reader1 = csv.reader(co)\n next(reader1, None)\n # Use chr_ind_pos as unique key and all row as values\n codict = collections.OrderedDict((row[0] + \"_\" + row[1] + \"_\" + row[2], row[0:]) for row in reader1)\nwith open(markers, mode='r') as mark:\n reader2 = csv.reader(mark)\n next(reader2, None)\n mdict = collections.OrderedDict((row[0] + \"_\" + row[2], row[1]) for row in reader2)\n\n# Filter false positive CO\nfiltdict = delete_false_co(codict,mdict)\n# Physical distances between CO\nind_list = []\nco = {}\nfor key, value in filtdict.items():\n ind = value[1]\n chrom = value[0]\n lchrpos = value[0] + \"_\" + value[3]\n lphypos = mdict[lchrpos].split(\"_\")[1]\n lphychr = mdict[lchrpos].split(\"_\")[0]\n rchrpos = value[0] + \"_\" + value[4]\n rphypos = mdict[rchrpos].split(\"_\")[1]\n rphychr = mdict[rchrpos].split(\"_\")[0]\n \n if rphychr == chrom and lphychr == chrom:\n breakpoint = int((int(lphypos) + int(rphypos)) / 2)\n if chrom in co:\n # append CO to list\n breaklist = co[chrom]\n breaklist.append(breakpoint)\n co[chrom] = breaklist\n else:\n co[chrom] = [breakpoint]\n\n ind_list.append(ind)\n\n# CO counts per individual\ncounter=collections.Counter(ind_list)\nind_list = []\nfrq = []\nfor ind in counter.most_common():\n ind_list.append(ind[0])\n frq.append(ind[1])\ninddf = pd.DataFrame({'Ind' : ind_list, 'CO' : frq})\ninddf.sort_values(['Ind'], ascending=True, axis=0,inplace=True)\ninddf.to_csv('Individual_CO_Frequency.csv', index=False, encoding='utf-8', columns=['Ind','CO'])\n\n# Histogram of CO across chromsomes\nchromlist = []\nhistlist = []\nbinlist = []\n\nfor key, value in co.items():\n chrom = key\n breakpoints = np.array(value)\n # Round highest position up to nearest 500kb\n toprange = math.ceil(breakpoints.max() / 500000.0) * 500000.0\n # Number of bins\n binnum = int(toprange / 500000.0)\n # Calculate histogram\n hist,bins = np.histogram(breakpoints,bins=binnum,range=(0, toprange))\n histlist.extend(np.ndarray.tolist(hist))\n bins_tidy = np.ndarray.tolist(bins)[:-1]\n binlist.extend(bins_tidy)\n for bin in bins_tidy:\n chromlist.append(chrom)\ncodf = pd.DataFrame({'Chr' : chromlist, 'Bin' : binlist, 'Histogram' : histlist})\ncodf.sort_values(['Chr', 'Bin'], ascending=True, axis=0,inplace=True)\ncodf.to_csv('CO_hist.csv', index=False, encoding='utf-8', columns=['Chr','Bin','Histogram'])\n", "meta": {"hexsha": "aef2f5cde06004b3e833a00508ee952e4e774738", "size": 5468, "ext": "py", "lang": "Python", "max_stars_repo_path": "scripts/crossover.py", "max_stars_repo_name": "ascheben/bn_gbs", "max_stars_repo_head_hexsha": "cb70234e81874392f041ac51f7cb695ce183e252", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "scripts/crossover.py", "max_issues_repo_name": "ascheben/bn_gbs", "max_issues_repo_head_hexsha": "cb70234e81874392f041ac51f7cb695ce183e252", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "scripts/crossover.py", "max_forks_repo_name": "ascheben/bn_gbs", "max_forks_repo_head_hexsha": "cb70234e81874392f041ac51f7cb695ce183e252", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.9736842105, "max_line_length": 104, "alphanum_fraction": 0.6181419166, "include": true, "reason": "import numpy", "num_tokens": 1535, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5621765008857981, "lm_q2_score": 0.34158249943831703, "lm_q1q2_score": 0.19202965429805816}} {"text": "#!/usr/bin/python3\n\n\"\"\"Projection class\nImplements a class for 2D phantoms. The Golosio phantom is coded in terms of\ngeometry and composition data, with class methods supplied to instantiate it.\nAlternatively, phantoms can be defined as a pair of files, one containing\ngeometry data as a greyscale bitmap and the other containing the composition\ndata structure defined in a yaml file.\n\n\"\"\"\n\nfrom __future__ import absolute_import, division, print_function\nfrom . import config\nimport logging\nimport os\nimport glob\nimport fnmatch\nfrom progressbar import ProgressBar\n\nimport numpy as np\nfrom numpy import exp, pi\nimport scipy.constants as sc\nfrom scipy.special import expm1\nimport matplotlib.pyplot as plt\nimport xraylib as xrl\n\nfrom . import helpers\nfrom .helpers import write_tiff32, zero_outside_circle, rotate, imshow\nfrom .data_helpers import MatrixProperties\n\nlogger = logging.getLogger(__name__)\n\n\nUM_PER_CM = 1e4\nJ_PER_KEV = 1e3 * sc.eV\ndeg_to_rad = lambda x: x / 180. * pi\nrad_to_deg = lambda x: x * 180. / pi\n\n# maia_d = Maia() # Maia detector object (should be a singleton)\n\n\ndef absorption_sinogram(p, anglelist):\n \"\"\"Generates the absorption sinogram for absorption by the full\n elemental content of the Phantom2d object.\n\n Parameters\n ----------\n p : Phantom2d object\n anglelist : list of float\n Ordered list of sinogram projection angles in degrees.\n\n Returns\n -------\n array of float\n Sinogram of requested scattering or fluorescence.\n This is a 2d x-theta map of dimensionless values.\n\n \"\"\"\n sinogram = np.empty((p.cols, len(anglelist)))\n if config.show_progress:\n pbar = ProgressBar(maxval=max(1, len(anglelist)-1), term_width=80).start()\n for i, angle in enumerate(anglelist):\n if config.show_progress:\n pbar.update(i)\n\n increasing_ix = True # Set True to accumulate cmam along increasing y\n n_map = irradiance_map(p, angle, n0=1.0, increasing_ix=increasing_ix)\n if increasing_ix:\n sinogram[:, i] = np.log(n_map[0] / n_map[-1])\n else:\n sinogram[:, i] = np.log(n_map[-1] / n_map[0])\n return sinogram\n\n\ndef outgoing_cmam(p, q, maia_d, angle, energy, increasing_ix=True):\n \"\"\"Compute and return the outgoing cumulative multiplicative absorption map\n (cmam), aka xi'.\n\n Parameters\n ----------\n p : Phantom2d object\n p.energy - incident beam photon energy (keV).\n p.um_per_px - length of one pixel of the map (um).\n q : int\n Maia detector channel id\n maia_d : Maia() instance\n angle : float\n Tomography projection angle (degree)\n energy : float\n outgoing radiation energy (keV)\n increasing_ix : bool, optional\n If False, performs cumulative sum in opposite direction (in direction of\n decreasing y-index). Note, for the standard Radon transform,\n this direction is unimportant, but for the Radon transform with\n attenuation, we should project in the beam propagation direction.\n (default True).\n\n Returns\n -------\n 2d ndarray of float\n cumulative multiplicative absorption map.\n\n \"\"\"\n # The linear absorption map mu = ma_M * mu_M + sum_k ( ma_k * mu_k )\n mu = p.matrix.ma(energy) * p.el_maps['matrix']\n for el in p.el_maps:\n if el == 'matrix':\n continue\n Z = xrl.SymbolToAtomicNumber(el)\n mu += xrl.CS_Total(Z, energy) * p.el_maps[el]\n\n # project at angle theta by rotating the phantom by angle -theta and\n # projecting along the z-axis (along columns)\n\n # rotate by the sum of the projection angle and local detector angle\n # Get angle to rotate maps so that propagation toward detector plane\n # corresponds with direction to maia detector element\n phi_x = maia_d.pads[q].angle_X_rad\n phix_deg = rad_to_deg(phi_x)\n\n # Apply local rotation, accumulation and rotation operators\n\n # Apply R_{-theta} operator to mu\n # Apply R_{-phi} operator\n mu = rotate(mu, angle + 180 - phix_deg)\n\n saveflag = np.isclose(angle, config.cmam_angle_save) and config.save_projection_images\n if saveflag:\n path = os.path.join(config.mlem_im_path, 'project_cmam1_%03d.tif' % config.i)\n helpers.write_tiff32(path, mu)\n\n # Apply C_z operator\n if increasing_ix:\n mu = np.cumsum(mu, axis=0)\n else:\n mu = np.cumsum(mu[::-1], axis=0)[::-1]\n\n if saveflag:\n path = os.path.join(config.mlem_im_path, 'project_cmam2_%03d.tif' % config.i)\n helpers.write_tiff32(path, mu)\n\n # Apply R_{phi} operator\n mu = rotate(mu, 180 + phix_deg)\n t = p.um_per_px / UM_PER_CM\n\n if saveflag:\n path = os.path.join(config.mlem_im_path, 'project_cmam3_%03d.tif' % config.i)\n helpers.write_tiff32(path, mu)\n\n phi = maia_d.pads[q].out_of_xz_plane_angle\n cmam = mu * t / np.cos(phi)\n return cmam\n\n\ndef project_sinogram(event_type, p, q, maia_d, anglelist, el=None):\n \"\"\"Generates the sinogram of the requested element accounting for\n absorption by the Phantom2d composition and the geometry.\n\n Parameters\n ----------\n event_type : string\n One of ['rayleigh', 'compton', 'fluoro'].\n p : Phantom2d object\n p.energy - incident beam photon energy (keV).\n p.um_per_px - length of one pixel of the map (um).\n q : int\n Maia detector channel id\n maia_d : Maia() instance\n anglelist : list of float\n Ordered list of sinogram projection angles in degrees.\n el : string, optional\n Name of element (e.g. 'Fe') used if projecting that element's\n fluorescence.\n\n Returns\n -------\n array of float\n Sinogram of requested scattering or fluorescence.\n\n \"\"\"\n assert event_type in ['rayleigh', 'compton', 'fluoro']\n\n sinogram = np.empty((p.cols, len(anglelist)))\n if config.show_progress:\n if len(anglelist) > 1:\n pbar = ProgressBar(maxval=len(anglelist)-1).start()\n else:\n pbar = ProgressBar(maxval=1).start()\n for i, angle in enumerate(anglelist):\n if config.show_progress:\n pbar.update(i)\n\n increasing_ix = True # Set True to accumulate cmam along increasing y\n n_map = irradiance_map(p, angle, n0=1.0, increasing_ix=increasing_ix)\n e_map = channel_fluoro_map(p, q, maia_d, n_map, angle, el)\n energy = outgoing_photon_energy(event_type, p, q, maia_d, el)\n c = outgoing_cmam(p, q, maia_d, angle, energy, increasing_ix=increasing_ix)\n if config.no_out_absorption:\n sinogram[:, i] = e_map.sum(axis=0)\n else:\n sinogram[:, i] = (e_map * np.exp(-c)).sum(axis=0)\n\n if i == config.angle_save_index and config.save_projection_images:\n path = os.path.join(config.mlem_im_path, 'project_%s_map_%03d.tif' % (el, config.i))\n helpers.write_tiff32(path, p.el_maps[el])\n path = os.path.join(config.mlem_im_path, 'project_n_map_%03d.tif' % config.i)\n helpers.write_tiff32(path, n_map)\n path = os.path.join(config.mlem_im_path, 'project_e_map_%03d.tif' % config.i)\n helpers.write_tiff32(path, e_map)\n path = os.path.join(config.mlem_im_path, 'project_c_map_%03d.tif' % config.i)\n helpers.write_tiff32(path, c)\n\n return sinogram\n\n\ndef irradiance_map(p, angle, n0=1.0, increasing_ix=True, matrix_only=False):\n \"\"\"Generates the image-sized map of irradiance [1/(cm2 s)] at each 2d pixel\n for a given angle accounting for absorption at the incident energy by the\n full elemental distribution.\n Note: In the full biological approximation, where we only need to consider absorption by\n the matrix and not by the full elemental composition, we could cache this result,\n possibly by adding the memoization decorator I use in Sakura here:\n https://github.com/AustralianSynchrotron/Sakura/blob/master/utils.py\n https://github.com/AustralianSynchrotron/Sakura/blob/master/memoize_core.py\n\n Parameters\n ----------\n p : phantom object\n p.energy - incident beam energy (keV)\n p.um_per_px - length of one pixel of the map (um)\n angle : float\n tomography angle in degrees. The rotation axis is the y-axis in a conventional xyz\n right-handed coordinate system, so positive rotation in the xz-plane is ccw. i.e.\n with y(out-of-page) o--> x\n |\n v\n z\n therefore, using our rotate function, which assumes 2d rotation\n n0 : float\n incident irradiance (default 1.0).\n increasing_ix : bool, optional\n If False, performs cumulative sum in opposite direction (in direction of\n decreasing y-index). Note, for the standard Radon transform,\n this direction is unimportant, but for the Radon transform with\n attenuation, we should project in the beam propagation direction.\n (default True).\n matrix_only : bool, optional\n If True, the map only considers the matrix and doesn't consider the\n other elements in the model.\n (default False).\n\n Returns\n -------\n 2d ndarray of float\n The irradiance map.\n\n \"\"\"\n # matrix_map = zero_outside_circle(p.el_maps['matrix'])\n\n # The linear absorption map mu0 = ma_M * mu_M + sum_k ( ma_k * mu_k )\n mu0 = p.matrix.ma(p.energy) * p.el_maps['matrix']\n if not config.absorb_with_matrix_only:\n for el in p.el_maps:\n if el == 'matrix':\n continue\n Z = xrl.SymbolToAtomicNumber(el)\n mu0 += xrl.CS_Total(Z, p.energy) * p.el_maps[el]\n\n # project at angle theta by rotating the phantom by angle -theta and\n # projecting along the z-axis (along columns)\n im = rotate(mu0, angle) # rotate by angle degrees ccw\n t = p.um_per_px / UM_PER_CM\n # accumulate along z-axis (image defined in xz-coordinates, so accumulate\n # along image rows), consistent with matlab sinogram convention.\n # See http://www.mathworks.com/help/images/radon-transform.html\n if increasing_ix:\n cmam = t * np.cumsum(im, axis=0)\n else:\n cmam = t * np.cumsum(im[::-1], axis=0)[::-1]\n if config.no_in_absorption:\n n_map = n0 + np.zeros_like(cmam)\n else:\n n_map = n0 * exp(-cmam)\n return n_map\n\n'''\ndef scattering_ma(event_type, p, maia_d, row, col):\n \"\"\"Return the Rayleigh or Compton differential mass attenuation coefficients\n (cm2/g/sr) for icru44 brain tissue with density described by the 'matrix'\n map of phantom p into the Maia detector element indexed by row, col. This\n needs to be multiplied later by the Maia-channel-dependent solid angle.\n\n Arguments:\n event_type - string, one of ['rayleigh', 'compton']\n p - phantom instance (matrix plus elements)\n maia_d - Maia instance\n\n row, col - maia detector element indices\n\n Returns:\n The (rayleigh, compton) differential mass attenuation coefficient\n\n \"\"\"\n assert event_type in ['rayleigh', 'compton']\n\n # Get spherical angles (polar theta & azimuthal phi) to detector element\n theta = maia_d.pads[q].theta\n phi = maia_d.pads[q].phi\n\n compound = p.matrix.cp # elemental data for matrix compound\n\n # Get the contribution to Rayleigh and Compton scattering from each\n # element in the matrix compound and sum these.\n ma = 0.0\n for el in compound:\n # Assuming propagation along z, coordinate system used by the DCSP_Rayl\n # and DCSP_Compt methods is shown here:\n # http://upload.wikimedia.org/wikipedia/commons/thumb/4/4f/\n # 3D_Spherical.svg/200px-3D_Spherical.svg.png\n # i.e. spherical coordinates with polar angle theta, azimuthal angle phi\n z = xrl.SymbolToAtomicNumber(compound[el])\n\n # Mass attenuation coefficients from cross-sections. See\n # http://physics.nist.gov/PhysRefData/XrayMassCoef/chap2.html\n # Units of the following expression:\n # elemental fraction by weight * differential mass attenuation coefft\n # unitless * cm2/g/sr\n if event_type == 'rayleigh':\n f = xrl.DCSP_Rayl\n else:\n f = xrl.DCSP_Compt\n ma += compound[el] * f(z, p.energy, theta, phi)\n return ma\n\n\ndef compton_scattered_energy(energy_in, q, maia_d):\n \"\"\"Energy of the Compton photons scattered into the direction of the Maia\n detector element.\n\n Parameters\n ----------\n energy_in : float\n Incident beam photon energy (keV).\n q : int\n Maia detector channel id\n maia_d : Maia instance\n\n Returns\n -------\n float\n Energy of scattered photons (keV)\n\n \"\"\"\n # Get polar scattering angle (theta) to detector element\n # Get spherical angles (polar theta & azimuthal phi) to detector element\n theta = maia_d.pads[q].theta\n\n # energy_out = 1.0 / (1.0/energy_in +\n # (1 - np.cos(theta))*J_PER_KEV/sc.m_e/sc.c/sc.c)\n return xrl.ComptonEnergy(energy_in, theta)\n'''\n\n'''\ndef old_emission_map(event_type, p, n_map, angle, el=None):\n \"\"\"Compute the maia-detector-shaped map of Rayleigh, Compton or K-edge\n fluorescence from the element map for an incident irradiance map n_map.\n\n Parameters\n ----------\n event_type : string\n One of ['rayleigh', 'compton', 'fluoro'].\n p : Phantom2d object\n p.energy - incident beam photon energy (keV).\n p.um_per_px - length of one pixel of the map (um).\n n_map : 2d ndarray of float\n Map of incident irradiance.\n angle : float\n Stage rotation angle (degrees).\n el : string, optional\n Name of element (e.g. 'Fe') used if projecting that element's\n fluorescence.\n\n Returns\n -------\n 1d ndarray of float\n The accumulated flux in Maia detector row 7 for the requested edge.\n\n \"\"\"\n assert event_type in ['rayleigh', 'compton', 'fluoro']\n\n # Get matrix map and, for fluorescence, the map for the requested element,\n # and rotate them to the same angle as the intensity map since these all\n # need to be in registration.\n matrix_map = zero_outside_circle(p.el_maps['matrix'])\n matrix_map_r = rotate(matrix_map, -angle)\n del matrix_map\n\n k_alpha_energy = -1\n if event_type == 'fluoro':\n edge_map = zero_outside_circle(p.el_maps[el])\n edge_map_r = rotate(edge_map, -angle)\n del edge_map\n\n # Do this here because we're outside the detector channel loop.\n # Get Z for the fluorescing element and check that its K_alpha is\n # below the incident energy.\n el_z = xrl.SymbolToAtomicNumber(el)\n line = xrl.KA_LINE\n k_alpha_energy = xrl.LineEnergy(el_z, line)\n assert k_alpha_energy < p.energy\n\n # 2d accumulator for results\n accumulator = np.empty((maia_d.shape[1], n_map.shape[0]))\n\n # Iterate over maia detector elements in theta, i.e. maia columns\n # This should be parallelizable\n row = 7\n # Get multiplication factor for additional distance that an outgoing photon\n # must travel as it passes out-of-plane to the detector.\n delta_theta_yx_radian = maia_d.yx_angles_radian(row, col=0)\n delta_theta_y_radian = delta_theta_yx_radian[0]\n y_distance_factor = 1.0 / np.cos(delta_theta_y_radian)\n\n for channel_id in maia_d.channel_selection(row=row):\n col = maia_d.maia_data_column_from_id(channel_id, 'Column')\n # Get angle to rotate maps so that propagation toward detector plane\n # corresponds with direction to maia detector element\n delta_theta_yx_radian = maia_d.yx_angles_radian(row, col)\n delta_theta_x = rad_to_deg(delta_theta_yx_radian[1])\n\n # For every maia detector element, get the solid angle (parallelize?)\n # Orient the maps toward the maia element\n # TODO: check sign of delta: +ve or -ve?\n imap_rm = rotate(n_map, -delta_theta_x)\n matrix_map_rm = rotate(matrix_map_r, -delta_theta_x)\n\n # Rotate the geometry so that the detector is on the bottom, so we can\n # integrate by stepping through the row indices.\n imap_rm = np.rot90(imap_rm)\n matrix_map_rm = np.rot90(matrix_map_rm)\n\n # Solid angle of Maia channel\n omega = maia_d.solid_angle(row, col)\n\n # mass attenuation coefft. (cm2/g)\n if event_type == 'fluoro':\n edge_map_rm = rotate(edge_map_r, -delta_theta_x)\n edge_map_rm = np.rot90(edge_map_rm)\n\n # Simulate fluorescence event:\n # Generate the initial fluorescence intensity\n # Start with the highest-energy edge or a mean factor accounting for\n # all edges first (move to other edges later?)\n mac = fluoro_ma(p, el_z)\n\n # Scale for propagation over one voxel\n # *_mac_t = *_mac * p.um_per_px/UM_PER_CM\n # (cm3/g/sr) = (cm2/g/sr) * cm\n mac_t = mac * p.um_per_px / UM_PER_CM * y_distance_factor\n # Generate outgoing radiation.\n # This is the fluorescence intensity map.\n imap_rm *= -expm1(-edge_map_rm * omega * mac_t)\n del edge_map_rm\n else:\n mac = scattering_ma(event_type, p, row, col)\n mac_t = mac * p.um_per_px / UM_PER_CM * y_distance_factor\n # Generate outgoing radiation.\n # This is the scattering radiation intensity map.\n imap_rm *= -expm1(-matrix_map_rm * omega * mac_t)\n\n # Now we've \"evented,\" we use the mass attenuation coefficients of the\n # matrix for propagation with absorption out to the detector, but this\n # is at a new energy depending on the event type.\n energy = {\n 'rayleigh': p.energy,\n 'compton': compton_scattered_energy(p.energy, row, col),\n 'fluoro': k_alpha_energy,\n }[event_type]\n mac_t = brain.ma(energy) * p.um_per_px / UM_PER_CM * y_distance_factor\n\n # Propagate all intensity to the detector, accumulating (+) and\n # absorbing [exp(-mu/rho rho t)] as we go.\n cmam_matrix = np.cumsum(matrix_map_rm, axis=0) * mac_t\n i_out = (imap_rm * exp(-cmam_matrix * omega)).sum(axis=0)\n\n # Store the result for this detector element.\n accumulator[col] = i_out\n\n return accumulator\n'''\n\n\ndef outgoing_photon_energy(event_type, p, q=None, maia_d=None, el=None):\n \"\"\"Return the interaction-type-dependent outgoing photon energy in keV.\n\n Parameters\n ----------\n event_type : string\n One of ['rayleigh', 'compton', 'fluoro'].\n p : Phantom2d object\n p.energy - incident beam photon energy (keV).\n p.um_per_px - length of one pixel of the map (um).\n q : int (optional, required for compton interaction)\n Maia detector channel id\n maia_d : Maia() instance (optional, required for compton interaction)\n el : string (optional, required for fluoro interaction)\n Name of fluorescing element (e.g. 'Fe').\n\n Returns\n -------\n float\n Outgoing photon energy (keV)\n\n \"\"\"\n assert event_type in ['rayleigh', 'compton', 'fluoro']\n\n def k_alpha_energy(el):\n el_z = xrl.SymbolToAtomicNumber(el)\n line = xrl.KA_LINE\n energy = xrl.LineEnergy(el_z, line)\n # assert energy < p.energy\n return energy\n\n '''\n if event_type == 'rayleigh':\n energy = p.energy\n elif event_type == 'compton':\n energy = compton_scattered_energy(p.energy, q, maia_d)\n else: # 'fluoro'\n '''\n if True: # Just support 'fluoro' for now\n energy = k_alpha_energy(el)\n\n return energy\n\n\ndef fluoro_emission_map(p, n_map, angle, el):\n \"\"\"Compute the maia-detector-shaped map of K-edge\n fluorescence from the element map for an incident irradiance map n_map.\n\n Parameters\n ----------\n p : Phantom2d object\n p.energy - incident beam photon energy (keV).\n p.um_per_px - length of one pixel of the map (um).\n n_map : 2d ndarray of float\n Map of incident irradiance.\n angle : float\n Stage rotation angle (degrees).\n el : string\n Name of fluorescing element (e.g. 'Fe').\n\n Returns\n -------\n 2d ndarray of float\n The fluorescence emission map for the requested edge.\n\n \"\"\"\n # edge_map = zero_outside_circle(p.el_maps[el])\n edge_map = p.el_maps[el]\n edge_map_r = rotate(edge_map, angle)\n del edge_map\n\n # Get Z for the fluorescing element\n el_z = xrl.SymbolToAtomicNumber(el)\n line = xrl.KA_LINE\n\n # Sanity check that el K_alpha is below the incident energy.\n k_alpha_energy = xrl.LineEnergy(el_z, line)\n # assert k_alpha_energy < p.energy\n if k_alpha_energy >= p.energy:\n Q = 0.0\n else:\n # Simulate fluorescence event:\n # CS_FluorLine_Kissel_Cascade is the XRF cross section Q_{i,YX} in Eq. (12)\n # of Schoonjans et al.\n Q = xrl.CS_FluorLine_Kissel_Cascade(el_z, line, p.energy)\n # print(el, end=' ')\n\n # 2d array for results\n emission_map = n_map * Q * edge_map_r * p.um_per_px / UM_PER_CM\n\n return emission_map\n\n\ndef channel_emission_map(event_type, p, q, maia_d, n_map, angle, el):\n \"\"\"Select and defer to the interaction-type-specific emission map\n computation.\n\n Parameters\n ----------\n event_type : string\n One of ['rayleigh', 'compton', 'fluoro'].\n p : Phantom2d object\n p.energy - incident beam photon energy (keV).\n p.um_per_px - length of one pixel of the map (um).\n q : int\n Maia detector channel id\n maia_d : Maia() instance\n n_map : 2d ndarray of float\n Map of incident irradiance.\n angle : float\n Stage rotation angle (degrees).\n el : string\n Name of fluorescing element (e.g. 'Fe').\n\n Returns\n -------\n 2d ndarray of float\n The fluorescence emission map for the requested edge.\n\n \"\"\"\n assert event_type in ['rayleigh', 'compton', 'fluoro']\n\n if event_type == 'fluoro':\n e_map = channel_fluoro_map(p, q, maia_d, n_map, angle, el)\n elif event_type == 'rayleigh':\n e_map = channel_rayleigh_map(p, q, maia_d, n_map, angle)\n elif event_type == 'compton':\n e_map = channel_compton_map(p, q, maia_d, n_map, angle)\n else:\n raise RuntimeError('Brain explodes')\n\n return e_map\n\n\ndef channel_fluoro_map(p, q, maia_d, n_map, angle, el):\n \"\"\"Compute the maia-detector-shaped map of K-edge\n fluorescence from the element map for an incident irradiance map n_map.\n\n Parameters\n ----------\n p : Phantom2d object\n p.energy - incident beam photon energy (keV).\n p.um_per_px - length of one pixel of the map (um).\n q : int\n Maia detector channel id\n maia_d : Maia instance\n n_map : 2d ndarray of float\n Map of incident irradiance.\n angle : float\n Stage rotation angle (degrees).\n el : string\n Name of fluorescing element (e.g. 'Fe').\n\n Returns\n -------\n 2d ndarray of float\n The fluorescence emission map for the requested edge.\n\n \"\"\"\n solid_angle = maia_d.pads[q].omega\n return (solid_angle / 4 / np.pi *\n fluoro_emission_map(p, n_map, angle, el))\n\n\ndef channel_rayleigh_map(p, q, maia_d, n_map, angle):\n \"\"\"Compute the maia-detector-shaped map of Rayleigh scattering\n from the element map for an incident irradiance map n_map.\n\n Parameters\n ----------\n p : Phantom2d object\n p.energy - incident beam photon energy (keV).\n p.um_per_px - length of one pixel of the map (um).\n q : int\n Maia detector channel id\n maia_d : Maia() instance\n n_map : 2d ndarray of float\n Map of incident irradiance.\n angle : float\n Stage rotation angle (degrees).\n\n Returns\n -------\n 2d ndarray of float\n The fluorescence emission map for the requested edge.\n\n \"\"\"\n solid_angle = maia_d.pads[q].omega\n\n # Get spherical angles (polar theta & azimuthal phi) to detector element\n theta = maia_d.pads[q].theta\n phi = maia_d.pads[q].phi\n\n energy = outgoing_photon_energy('rayleigh', p)\n\n # get a list of all elements el and their weights w_el\n\n # The absorption map mu = ma_M * mu_M + sum_k ( ma_k * mu_k )\n mu = p.matrix.ma(energy) * p.el_maps['matrix']\n for el in p.el_maps:\n if el == 'matrix':\n continue\n Z = xrl.SymbolToAtomicNumber(el)\n mu += p.matrix.cp[el] * xrl.DCSP_Rayl(Z, energy, theta, phi) * \\\n p.el_maps[el]\n\n ma += xrl.DCSP_Rayl(Z, energy, theta, phi)\n\n # edge_map = zero_outside_circle(p.el_maps[el])\n edge_map_r = rotate(edge_map, angle)\n del edge_map\n\n # Get Z for the fluorescing element\n el_z = xrl.SymbolToAtomicNumber(el)\n line = xrl.KA_LINE\n\n # Sanity check that el K_alpha is below the incident energy.\n k_alpha_energy = xrl.LineEnergy(el_z, line)\n assert k_alpha_energy < p.energy\n\n # Simulate fluorescence event:\n # CS_FluorLine_Kissel_Cascade is the XRF cross section Q_{i,YX} in Eq. (12)\n # of Schoonjans et al.\n Q = xrl.CS_FluorLine_Kissel_Cascade(el_z, line, p.energy)\n\n # 2d array for results\n emission_map = n_map * Q * edge_map_r * p.um_per_px / UM_PER_CM\n\n return emission_map\n\n\ndef write_sinogram(im, p, event_type, el='matrix'):\n \"\"\"Project and write sinogram for element map el\n Creates a filename by prepending s_ to the filename and appending r or c\n if writing the rayleigh or compton sinogram, respectively.\n\n Parameters\n ----------\n im : 2d ndarray of float\n sinogram.\n p : Phantom2d object\n event_type : string\n One of ['absorption', 'rayleigh', 'compton', 'fluoro'].\n el : string\n name of current element, e.g. 'Fe'. (default 'matrix').\n\n \"\"\"\n # Get the filename that matches the glob pattern for this element\n # and prepend s_ to it\n pattern = p.filename\n\n matches = helpers.match_pattern(pattern, glob.glob(pattern))\n if matches:\n # Just get the filename that's a match for the element el\n match_base = [m[0] for m in matches if el==m[1]][0]\n else:\n raise Exception('Element {} not found in {}'.format(el, matches))\n path = os.path.dirname(pattern)\n base = os.path.basename(match_base)\n s_filename = os.path.join(path, 's_'+base)\n\n # Write sinogram (absorption map)\n\n # append r, c, f, a to -matrix suffix so sinograms read in as unique images\n if '-matrix' in s_filename:\n s_filename = s_filename.replace('-matrix', '-matrix-' + event_type[0])\n write_tiff32(s_filename, im)\n\n return im\n", "meta": {"hexsha": "d9b81de1e77471884e4ff743f07af4f6788506a6", "size": 26528, "ext": "py", "lang": "Python", "max_stars_repo_path": "acsemble/projection.py", "max_stars_repo_name": "gazzar/tmm_model", "max_stars_repo_head_hexsha": "b50a8cb2d58e70333015c0ecf5759d887f785047", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2016-11-14T02:30:24.000Z", "max_stars_repo_stars_event_max_datetime": "2016-11-14T02:30:24.000Z", "max_issues_repo_path": "acsemble/projection.py", "max_issues_repo_name": "gazzar/tmm_model", "max_issues_repo_head_hexsha": "b50a8cb2d58e70333015c0ecf5759d887f785047", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "acsemble/projection.py", "max_forks_repo_name": "gazzar/tmm_model", "max_forks_repo_head_hexsha": "b50a8cb2d58e70333015c0ecf5759d887f785047", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.813648294, "max_line_length": 96, "alphanum_fraction": 0.6491254524, "include": true, "reason": "import numpy,from numpy,import scipy,from scipy", "num_tokens": 6765, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.5621765008857981, "lm_q2_score": 0.34158248603300034, "lm_q1q2_score": 0.19202964676190412}} {"text": "# hst.py\n\nimport os\nimport numpy as np\nimport pandas as pd\n\nfrom ..io.read_hst import read_hst\nfrom ..load_sim import LoadSim\n\nclass Hst:\n\n @LoadSim.Decorators.check_pickle_hst\n def read_hst(self, savdir=None, merge_mhd=True, force_override=False):\n \"\"\"Function to read hst and convert quantities to convenient units\n \"\"\"\n \n hst = read_hst(self.files['hst'], force_override=force_override)\n \n # delete the first row (post-processing)\n hst.drop(hst.index[:1], inplace=True)\n\n u = self.u\n domain = self.domain\n\n # volume of resolution element (code unit)\n dvol = domain['dx'].prod()\n # total volume of domain (code unit)\n vol = domain['Lx'].prod()\n # Area of domain (code unit)\n LxLy = domain['Lx'][0]*domain['Lx'][1]\n\n # Time in code unit\n hst['time_code'] = hst['time']\n # Time in Myr\n hst['time'] *= u.Myr\n # Total gas mass in Msun\n hst['mass'] *= vol*u.Msun\n # Gas surface density in Msun/pc^2\n hst['Sigma_gas'] = hst['mass']/(LxLy*u.pc**2)\n # H mass/surface density in Msun\n hst['MH'] = hst['mass']/u.muH\n hst['Sigma_H'] = hst['MH']/(LxLy*u.pc**2)\n \n # H2 mass in Msun\n try:\n hst['MH2'] = hst['MH2']*vol*u.Msun/u.muH\n hst['Sigma_H2'] = hst['MH2']/(LxLy*u.pc**2)\n hst['MH2_noLW'] = hst['MH2_noLW']*vol*u.Msun/u.muH\n hst['Sigma_H2_noLW'] = hst['MH2_noLW']/(LxLy*u.pc**2)\n except KeyError:\n pass\n\n # Neutral gas mass in Msun \n try:\n hst['Mneu'] = hst['scalar{:d}'.format(domain['IHI'])]*vol*u.Msun\n except KeyError:\n pass\n\n # Star formation rate per area [Msun/kpc^2/yr]\n hst['sfr10'] = hst['sfr10']/(LxLy*u.pc**2)\n hst['sfr40'] = hst['sfr40']/(LxLy*u.pc**2)\n hst['sfr100'] = hst['sfr100']/(LxLy*u.pc**2)\n \n # Cosmic ray ionization rate without attenuation\n hst['xi_CR0'] = 2e-16*self.par['problem']['xi_CR_amp']*(hst['sfr40']/3e-3)\n \n hst.index = hst['time_code']\n #hst.index.name = 'index'\n \n # Merge with mhd history dump\n if merge_mhd:\n try:\n hst_mhd = self.read_hst_mhd()\n hst = hst_mhd.reindex(hst.index, method='nearest',\n tolerance=0.1).combine_first(hst)\n except FileNotFoundError:\n pass\n \n self.hst = hst\n \n return hst\n \n # # Ionized gas mass in Msun\n # hst['Mion'] *= vol*u.Msun\n # # Collisionally ionized gas (before ray tracing) in Msun\n # hst['Mion_coll'] *= vol*u.Msun\n # # Total photoionization rate [#/sec]\n # hst['Qiphot'] *= vol*(u.length**3).cgs\n # # Total collisional ionization rate [#/sec]\n # hst['Qicoll'] *= vol*(u.length**3).cgs\n # # Total dust absorption rate [#/sec]\n # hst['Qidust'] *= vol*(u.length**3).cgs\n\n # # Mass fraction ionized gas\n # hst['mf_ion'] = hst['Mion']/hst['mass']\n # hst['mf_ion_coll'] = hst['Mion_coll']/hst['mass']\n\n # for f in range(self.par['radps']['nfreq']):\n # # Total luminosity [Lsun]\n # hst['Ltot_cl{:d}'.format(f)] *= vol*u.Lsun\n # hst['Ltot_ru{:d}'.format(f)] *= vol*u.Lsun\n # hst['Ltot{:d}'.format(f)] = \\\n # hst['Ltot_cl{:d}'.format(f)] + hst['Ltot_ru{:d}'.format(f)]\n # # Total luminosity included in simulation\n # hst['L_cl{:d}'.format(f)] *= vol*u.Lsun\n # hst['L_ru{:d}'.format(f)] *= vol*u.Lsun\n # hst['L{:d}'.format(f)] = \\\n # hst['L_cl{:d}'.format(f)] + hst['L_ru{:d}'.format(f)]\n # # Luminosity that escaped boundary\n # hst['Lesc{:d}'.format(f)] *= vol*u.Lsun\n # # Luminosity lost due to dmax\n # hst['Llost{:d}'.format(f)] *= vol*u.Lsun\n # # Escape fraction, lost fraction\n # # Estimation of true escape fraction estimation (upper bound)\n # hst['fesc{:d}'.format(f)] = hst['Lesc{:d}'.format(f)] / \\\n # hst['L{:d}'.format(f)]\n # hst['flost{:d}'.format(f)] = hst['Llost{:d}'.format(f)] / \\\n # hst['L{:d}'.format(f)]\n # hst['fesc{:d}_est'.format(f)] = hst['fesc{:d}'.format(f)] + \\\n # hst['flost{:d}'.format(f)]\n # hst['fesc{:d}_cum_est'.format(f)] = \\\n # (hst['Lesc{:d}'.format(f)] + hst['Llost{:d}'.format(f)]).cumsum() / \\\n # hst['L{:d}'.format(f)].cumsum()\n\n # return hst\n\n # # Scale heights of [warm] ionized gas, nesq\n # # Check if columns exist\n\n # # nesq\n # if 'H2nesq' in hst.columns and 'nesq' in hst.columns:\n # hst['H_nesq'] = np.sqrt(hst['H2nesq'] / hst['nesq'])\n # hst.drop(columns=['H2nesq', 'nesq'], inplace=True)\n\n # # Warm nesq\n # if 'H2wnesq' in hst.columns and 'wnesq' in hst.columns:\n # hst['H_wnesq'] = np.sqrt(hst['H2wnesq'] / hst['wnesq'])\n # hst.drop(columns=['H2wnesq', 'wnesq'], inplace=True)\n\n # # For warm medium, \n # # append _ to distinguish from mhd history variable\n # if 'H2w' in hst.columns and 'massw' in hst.columns:\n # hst['H_w_'] = np.sqrt(hst['H2w'] / hst['massw'])\n # hst['Mw_'] = hst['massw']*vol*u.Msun\n # hst['mf_w_'] = hst['Mw_']/hst['mass']\n # hst.drop(columns=['H2w', 'massw'], inplace=True)\n\n # # Warm ionized\n # if 'H2wi' in hst.columns and 'masswi' in hst.columns:\n # hst['H_wi'] = np.sqrt(hst['H2wi'] / hst['masswi'])\n # hst['Mwion'] = hst['masswi']*vol*u.Msun\n # hst['mf_wion'] = hst['Mwion']/hst['mass']\n # hst.drop(columns=['H2wi', 'masswi'], inplace=True)\n \n # ##########################\n # # With ionizing radiation\n # ##########################\n # if self.par['radps']['nfreq'] == 2 and \\\n # self.par['radps']['nfreq_ion'] == 1:\n # hnu0 = self.par['radps']['hnu[0]']/u.eV\n # hnu1 = self.par['radps']['hnu[1]']/u.eV\n # # Total luminosity\n # hst['Qitot_cl'] = hst['Ltot_cl0']/u.Lsun/hnu0/u.s\n # hst['Qitot_ru'] = hst['Ltot_ru0']/u.Lsun/hnu0/u.s\n # hst['Qitot'] = hst['Qitot_ru'] + hst['Qitot_cl']\n # # Total Q included as source\n # hst['Qi_cl'] = hst['L_cl0']/u.Lsun/hnu0/u.s\n # hst['Qi_ru'] = hst['L_ru0']/u.Lsun/hnu0/u.s\n # hst['Qi'] = hst['Qi_ru'] + hst['Qi_cl']\n # hst['Qiesc'] = hst['Lesc0']/u.Lsun/hnu0/u.s\n # hst['Qilost'] = hst['Llost0']/u.Lsun/hnu0/u.s\n # hst['Qiesc_est'] = hst['Qilost'] + hst['Qiesc']\n\n # else:\n # self.logger.error('Unrecognized option nfreq={0:d}, nfreq_ion={1:d}'.\\\n # format(self.par['radps']['nfreq'],\n # self.par['radps']['nfreq_ion']))\n\n # # midplane radiation energy density in cgs units\n # hst['Erad0_mid'] *= u.energy_density\n # hst['Erad1_mid'] *= u.energy_density\n\n\n # try:\n # hst.to_pickle(fpkl)\n # except IOError:\n # self.logger.warning('[read_hst]: Could not pickle hst to {0:s}.'.format(fpkl))\n\n # self.hst = hst\n # return self.hst\n\n def read_hst_mhd(self):\n\n # Read original mhd history dump from /tigress/changgoo\n hst = read_hst('/tigress/changgoo/{0:s}/hst/{0:s}.hst'.\\\n format(self.problem_id), force_override=True)\n\n u = self.u\n domain = self.par['domain1']\n Lx = domain['x1max'] - domain['x1min']\n Ly = domain['x2max'] - domain['x2min']\n Lz = domain['x3max'] - domain['x3min']\n Nx = domain['Nx1']\n Ny = domain['Nx2']\n Nz = domain['Nx3']\n Ntot = Nx*Ny*Nz\n vol = Lx*Ly*Lz\n LxLy = Lx*Ly\n dz = Lz/Nz\n Omega = self.par['problem']['Omega']\n time_orb = 2*np.pi/Omega*u.Myr # Orbital time in Myr\n\n if 'x1Me' in hst:\n mhd = True\n else:\n mhd = False\n\n h = pd.DataFrame()\n h['time_code'] = hst['time']\n h['time'] = h['time_code']*u.Myr # time in Myr\n h['time_orb'] = h['time']/time_orb\n\n h['mass'] = hst['mass']*u.Msun*vol\n h['Sigma'] = h['mass']/LxLy\n h['mass_sp'] = hst['msp']*u.Msun*vol\n h['Sigma_sp'] = h['mass_sp']/LxLy\n\n # Mass, volume fraction, scale height\n h['H'] = np.sqrt(hst['H2'] / hst['mass'])\n for ph in ['c','u','w','h1','h2']:\n h['mf_{}'.format(ph)] = hst['M{}'.format(ph)]/hst['mass']\n h['vf_{}'.format(ph)] = hst['V{}'.format(ph)]\n h['H_{}'.format(ph)] = \\\n np.sqrt(hst['H2{}'.format(ph)] / hst['M{}'.format(ph)])\n\n # mf, vf, H of thermally bistable (cold + unstable + warm) medium\n h['mf_2p'] = h['mf_c'] + h['mf_u'] + h['mf_w']\n h['vf_2p'] = h['vf_c'] + h['vf_u'] + h['vf_w']\n h['H_2p'] = np.sqrt((hst['H2c'] + hst['H2u'] + hst['H2w']) / \\\n (hst['Mc'] + hst['Mu'] + hst['Mw']))\n\n # Kinetic and magnetic energy\n h['KE'] = hst['x1KE'] + hst['x2KE'] + hst['x3KE']\n if mhd:\n h['ME'] = hst['x1ME'] + hst['x2ME'] + hst['x3ME']\n\n hst['x2KE'] = hst['x2dke']\n for ax in ('1','2','3'):\n Ekf = 'x{}KE'.format(ax)\n if ax == '2':\n Ekf = 'x2dke'\n # Mass weighted velocity dispersion??\n h['v{}'.format(ax)] = np.sqrt(2*hst[Ekf]/hst['mass'])\n if mhd:\n h['vA{}'.format(ax)] = \\\n np.sqrt(2*hst['x{}ME'.format(ax)]/hst['mass'])\n h['v{}_2p'.format(ax)] = \\\n np.sqrt(2*hst['x{}KE_2p'.format(ax)]/hst['mass']/h['mf_2p'])\n \n h['cs'] = np.sqrt(hst['P']/hst['mass'])\n h['Pth_mid'] = hst['Pth']*u.pok\n h['Pth_mid_2p'] = hst['Pth_2p']*u.pok/hst['Vmid_2p']\n h['Pturb_mid'] = hst['Pturb']*u.pok\n h['Pturb_mid_2p'] = hst['Pturb_2p']*u.pok/hst['Vmid_2p']\n\n # Midplane number density\n h['nmid'] = hst['nmid']\n h['nmid_2p'] = hst['nmid_2p']/hst['Vmid_2p']\n\n # Star formation rate per unit area [Msun/kpc^2/yr]\n h['sfr10']=hst['sfr10']\n h['sfr40']=hst['sfr40']\n h['sfr100']=hst['sfr100']\n\n h.index = h['time_code']\n #h.index.name = 'index'\n \n self.hst_mhd = h\n\n return self.hst_mhd\n \n # return pd.read_pickle(\n # '/tigress/changgoo/{0:s}/hst/{0:s}.hst_cal.p'.format(self.problem_id))\n", "meta": {"hexsha": "04b561832ee1eff6fb842475314e5f4a81ebbee5", "size": 10901, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyathena/tigress_xco/hst.py", "max_stars_repo_name": "changgoo/pyathena-1", "max_stars_repo_head_hexsha": "c461ac3390d773537ce52393e3ebf68a3282aa46", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-10-03T13:59:14.000Z", "max_stars_repo_stars_event_max_datetime": "2019-10-03T13:59:14.000Z", "max_issues_repo_path": "pyathena/tigress_xco/hst.py", "max_issues_repo_name": "changgoo/pyathena-1", "max_issues_repo_head_hexsha": "c461ac3390d773537ce52393e3ebf68a3282aa46", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2020-09-23T23:36:17.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-11T06:16:56.000Z", "max_forks_repo_path": "pyathena/tigress_xco/hst.py", "max_forks_repo_name": "changgoo/pyathena-1", "max_forks_repo_head_hexsha": "c461ac3390d773537ce52393e3ebf68a3282aa46", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-06-10T04:26:16.000Z", "max_forks_repo_forks_event_max_datetime": "2019-12-04T22:27:02.000Z", "avg_line_length": 38.3838028169, "max_line_length": 92, "alphanum_fraction": 0.4801394367, "include": true, "reason": "import numpy", "num_tokens": 3617, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6113819874558603, "lm_q2_score": 0.3140505385717077, "lm_q1q2_score": 0.19200484243355398}} {"text": "#!/usr/bin/env python\n\n\"\"\"\n Does some simple calculations to test trace gas PACE calculations\n\n Adapted from benchmark4Amir.py\n Patricia Castellanos, April 2020\n\n\"\"\"\n\nimport os\nimport sys\nfrom netCDF4 import Dataset\nfrom netCDF4 import Dataset as ncread\nimport numpy as np\nfrom MAPL.constants import *\nfrom py_leo_vlidort import VLIDORT_POLAR_\nfrom scipy.interpolate import interp1d\nimport scipy.integrate as integrate\nfrom pyhdf.SD import SD, SDC\nfrom multiprocessing import Pool\n\nformat = 'NETCDF4_CLASSIC'\nplane_parallel = True\nMISSING = -1.e+20\n\n\nWrapperFuncs = {'MODIS_BRDF' : VLIDORT_POLAR_.vector_brdf_modis,\n 'MODIS_BRDF_BPDF' : VLIDORT_POLAR_.vector_brdf_modis_bpdf,\n 'BPDF' : VLIDORT_POLAR_.vector_bpdf,\n 'LAMBERTIAN' : VLIDORT_POLAR_.vector_lambert,\n 'LAMBERTIAN_BPDF' : VLIDORT_POLAR_.vector_lambert_bpdf,\n 'GissCX' : VLIDORT_POLAR_.vector_gisscx,\n 'CX' : VLIDORT_POLAR_.vector_cx,\n 'OCICX' : VLIDORT_POLAR_.vector_ocicx,\n 'OCIGissCX' : VLIDORT_POLAR_.vector_ocigisscx,\n 'OCIGissCX_NOBM_CLOUD' : VLIDORT_POLAR_.vector_ocigisscx_nobm_cloud,\n 'ROT_CALC' : VLIDORT_POLAR_.rot_calc}\n\n\n\ndef get_geom(Iscan,Icross):\n inFile = '/nobackup/PACE/L1B/Y2020/M03/D24/OCI2020084005000.L1B_PACE.nc'\n nc = Dataset(inFile)\n grp = nc.groups['geolocation_data']\n sza = grp.variables['solar_zenith'][:]\n saa = grp.variables['solar_azimuth'][:]\n vza = grp.variables['sensor_zenith'][:]\n vaa = grp.variables['sensor_azimuth'][:]\n\n # make azimuths clockwise from north\n I = saa < 0\n saa[I] = 360. + saa[I]\n\n I = vaa < 0\n vaa[I] = 360. + vaa[I]\n\n # define SAA according to photon travel direction\n saa = saa + 180.0\n I = saa >= 360.\n saa[I] = saa[I] - 360.\n\n raa = vaa - saa \n\n I = raa < 0\n raa[I] = raa[I] + 360.0\n\n saa = grp.variables['solar_azimuth'][:]\n vaa = grp.variables['sensor_azimuth'][:]\n\n\n sza = np.array([sza[Iscan,Icross]])\n vza = np.array([vza[Iscan,Icross]])\n raa = np.array([raa[Iscan,Icross]])\n saa = np.array([saa[Iscan,Icross]])\n vaa = np.array([vaa[Iscan,Icross]])\n\n return sza,vza,raa,saa,vaa\n\ndef get_ROT(ch,pe,te,ze,verbose=True):\n \"\"\"\n calculate ROT and depol ratio\n \"\"\"\n\n args = [ch, pe, ze, te, MISSING, verbose]\n ROT, depol_ratio, rc = VLIDORT_POLAR_.rot_calc(*args)\n\n\n return ROT,depol_ratio\n\ndef get_TOA_unpack(args):\n return get_TOA(*args)\n\ndef get_TOA(channel,\n F0,\n ROT,depol_ratio,\n tau,ssa,pmom,\n alpha,\n SZA,VZA,RAA, \n km,pe,te,ze,\n nstreams, \n albedoType,\n sleave,\n U10m,V10m,mr,\n verbose):\n \"\"\"\n Do RT calculation to get TOA\n \"\"\"\n\n # wrapper function based on albedo\n vlidortWrapper = WrapperFuncs[albedoType]\n \n if albedoType == 'OCIGissCX':\n args = [channel, nstreams, plane_parallel, ROT, depol_ratio, alpha, tau, ssa, pmom,\n pe, ze, te,\n U10m, V10m, mr,\n SZA, RAA, VZA,\n F0,\n MISSING,\n verbose]\n I, reflectance, surf_reflectance, Q, U, BR_Q, BR_U, rc = vlidortWrapper(*args)\n else:\n args = [channel, nstreams, plane_parallel, ROT, depol_ratio, alpha, tau, ssa, pmom,\n tau, ssa, pmom,\n tau, ssa, pmom,\n pe, ze, te,\n U10m, V10m, mr,\n sleave, False,\n SZA, RAA, VZA,\n F0,\n MISSING,\n verbose]\n I, reflectance, surf_reflectance, Q, U, BR_Q, BR_U, rc, adjusted_sleave = vlidortWrapper(*args)\n\n\n return I,reflectance,surf_reflectance\n\n\ndef writenc(outFile,channels,\n F0,\n SZA,SAA,VZA,VAA,\n I,BR,reflectance,\n ROD,depol_ratio,\n alphaD,\n pe,te,ze,\n U10m,V10m,mr):\n\n\n\n nch = len(channels)\n km = len(pe)\n\n # Write data to netcdf file\n nc = Dataset(outFile,'w',format='NETCDF4_CLASSIC')\n nc.title = 'Line-by-Line TOA radiance calculation for one OCI pixel. Model 5 - US Standard 1962'\n\n dc = nc.createDimension('channels',nch)\n dn = nc.createDimension('npixel',1)\n dk = nc.createDimension('leve',km)\n\n ch = nc.createVariable('channels','f4',('channels',))\n ch.long_name = \"Wavelength in nm\"\n ch[:] = channels\n\n f = nc.createVariable('solar_irradiance','f4',('channels',))\n f.long_name = 'Thuillier solar irradiance spectrum'\n f.units = 'uW/cm^2/nm'\n f[:] = F0\n\n rad = nc.createVariable('I','f4',('channels',))\n rad.long_name = \"sun normalized TOA radiance\"\n rad[:] = I\n\n ref = nc.createVariable('R','f4',('channels',))\n ref.long_name = \"TOA reflectance\"\n ref[:] = reflectance\n\n sr = nc.createVariable('surface_reflectance','f4',('channels',))\n sr.long_name = \"surface bidirectional reflectance\"\n sr[:] = BR \n\n a = nc.createVariable('sza','f4',('npixel',))\n a.long_name = \"solar zenith angle\"\n a.units = 'degrees'\n a[:] = SZA \n\n a = nc.createVariable('saa','f4',('npixel',))\n a.long_name = \"solar azimiuth angle\"\n a.units = 'degrees 0-360 clockwise from north'\n a[:] = SAA\n\n a = nc.createVariable('vza','f4',('npixel',))\n a.long_name = \"sensor zenith angle\"\n a.units = 'degrees'\n a[:] = VZA\n\n a = nc.createVariable('vaa','f4',('npixel',))\n a.long_name = \"sensor azimiuth angle\"\n a.units = 'degrees 0-360 clockwise from north'\n a[:] = SAA \n\n rod = nc.createVariable('ROD','f4',('channels',))\n rod.long_name = \"Rayleigh Optical Depth\"\n rod[:] = ROD\n\n depol = nc.createVariable('depol_ratio','f4',('channels',))\n depol.long_name = 'Rayleigh depolarization ratio'\n depol[:] = depol_ratio\n\n alpha = nc.createVariable('ALPHA','f4',('channels',))\n alpha.long_name = \"Trace Gas Absorption Optical Depth\"\n alpha[:] = alphaD\n\n ke = nc.createVariable('PE','f4',('leve',))\n ke.long_name = 'Pressure at layer edge'\n ke.units = 'Pa'\n ke[:] = pe\n\n ke = nc.createVariable('TE','f4',('leve',))\n ke.long_name = 'Temperature at layer edge'\n ke.units = 'K'\n ke[:] = te\n\n ke = nc.createVariable('ZE','f4',('leve',))\n ke.long_name = 'height above surface'\n ke.units = 'm'\n ke[:] = ze\n\n wi = nc.createVariable('U10M','f4',('npixel',))\n wi.long_name = 'U10M wind speed'\n wi.units = 'm/s'\n wi[:] = U10m\n\n wi = nc.createVariable('V10M','f4',('npixel',))\n wi.long_name = 'V10M wind speed'\n wi.units = 'm/s'\n wi[:] = V10m\n\n wi = nc.createVariable('mr','f4',('npixel',))\n wi.long_name = 'ocean water refractive index'\n wi[:] = mr\n\n nc.close() \n\ndef get_PTWV_profile(inFile,model=5):\n \"\"\"\n Read in height [km],pressure [mb], temperature [K], water vapor vmr profile [ppm]\n for selected model:\n 0:Tropical\n 1:Mid Latitude Summer\n 2:Mid Latitude Winter\n 3:Subarctic Summer\n 4:Subarctic Winter\n 5:US Standard 1962\n 6:User Defined Model\n \"\"\"\n nc = Dataset(inFile)\n # make array because interp doesn't take masked arrays\n pe = np.array(nc.variables['p'][model,:]) \n te = np.array(nc.variables['t'][model,:])\n ze = np.array(nc.variables['h'][model,:]) \n vmre =np.array( nc.variables['vmr'][model,:])\n\n km = len(ze) - 1\n\n # get DP, from Amir's code\n DP= np.empty([km])\n for i in range(km):\n DP[i] = (pe[i] - pe[i+1])/1013\n\n # convert mb to Pascal\n pe = pe *100\n DELP = pe[:-1] - pe[1:]\n\n # get T middles\n DELP = pe[:-1] - pe[1:]\n pm = pe[:-1] - 0.5*DELP\n f = interp1d(pe,te)\n tm = f(pm)\n\n\n # convert km to m\n ze = ze*1000.\n dz = ze[1:] - ze[:-1]\n\n # calculate air number density [molecules/m3]\n g = 9.80616 # gravity m/s2\n Na = 6.022e23 # avogadro's number\n MW_AIR = 28.964*1e-3 # kg/mole\n\n AIRDENS = DELP/(dz*g) # kg/m3\n rho = AIRDENS/MW_AIR # moles/m3\n rho = rho*Na #[molecules/m3]\n\n return km, pe, te, tm, ze, dz, rho, vmre, DP, AIRDENS \n\n\ndef get_abs(inFile):\n \"\"\"\n Read aborption coefficients from Amir's HITRAN calculations\n \"\"\"\n nc = Dataset(inFile)\n # wavenumber [cm-1]\n waveno = np.array(nc.variables['waveno'][:])\n # abosrption coefficients [not sure about units]\n abs_o2 = nc.variables['abscf_o2'][:]\n abs_h2o = nc.variables['abscf_h2o'][:]\n abs_co = nc.variables['abscf_co'][:]\n abs_co2 = nc.variables['abscf_co2'][:]\n abs_ch4 = nc.variables['abscf_ch4'][:]\n abs_n2o = nc.variables['abscf_n2o'][:]\n\n nc.close()\n\n return abs_o2, abs_h2o, abs_co, abs_co2, abs_ch4, abs_n2o, waveno\n\n\ndef get_rsr(inFile):\n \"\"\"\n Read in OCI RSR File\n \"\"\"\n hdf = SD(inFile, SDC.READ)\n rsr = hdf.select('RSR')[:]\n wav_rsr = hdf.select('rsrwave')[:]\n wav_oci = hdf.select('wave')[:]\n hdf.end()\n\n return rsr, wav_rsr, wav_oci\n\ndef get_alpha(A,VMR,rho,dz):\n \"\"\"\n Calculate Absorption optical depth profile\n A - absorption coefficient [m2/molecule]\n VMR - trace gas mixing ratio [vol/vol, dimensionless]\n rho - air number density [molecules/m3]\n ze - profile layer thickness [m]\n \"\"\"\n\n # convert vmr to molecules/m3\n nxe = VMR*rho\n\n # get the optical depth subcolumns\n km, nch = A.shape\n alpha = np.zeros([km,nch])\n for i in range(km):\n alpha[i,:] = nxe[i]*dz[i]*A[i,:]\n\n return alpha\n\n\n# ---\ndef read_o3(inFile,te):\n f = open(inFile)\n nhead = 10\n for i in range(nhead):\n hh = f.readline()\n\n wav_o3, c0, c1, c2 = [],[],[],[]\n for l in f:\n a = np.array(l.split()).astype(float)\n wav_o3.append(a[0])\n c0.append(a[1])\n c1.append(a[2])\n c2.append(a[3])\n f.close()\n\n wav_o3 = np.array(wav_o3)\n c0 = np.array(c0)\n c1 = np.array(c1)\n c2 = np.array(c2)\n T0 = 273.15\n\n # calculate xsec for te\n nwav = len(wav_o3)\n km = len(te)\n xsec_o3 = np.zeros([km,nwav])\n\n for i,t in enumerate(te):\n xsec_o3[i,:] = c0 + c1*(t-T0) + c2*(t-T0)**2\n\n xsec_o3 = xsec_o3*1e-20\n\n # convert from cm2/molecule to m2/molecule\n xsec_o3 = xsec_o3*1e-4\n\n return wav_o3, xsec_o3\n\n# --\ndef read_ROD_table(inFile):\n f = open(inFile)\n\n for i in range(16):\n f.readline() #header\n\n wav = []\n rod = []\n depol = []\n for l in f:\n w, r, d = l.split()\n wav.append(w)\n rod.append(r)\n depol.append(d)\n\n f.close()\n\n wav = np.array(wav).astype('float')\n rod = np.array(rod).astype('float')\n depol = np.array(depol).astype('float')\n\n return wav, rod, depol\n\n#------------------------------------ M A I N ------------------------------------\n\nif __name__ == \"__main__\":\n\n outRoot = 'hyperTest/'\n outFile = '{}/outputs/hyperTest_CK_Thuillier_g5nr.nc4'.format(outRoot)\n\n\n # Pressure [Pa], temperature [K], height [m], water vapor [ppm] profile - standard atmosphere\n # used to make OCI look up tables\n # rhoe = air number density [molecules/m3]\n inFile = '{}/atrem_tpvmr.nc'.format(outRoot)\n km, pe, te, tm, ze, dz, rho, h2oe, DP, AIRDENS = get_PTWV_profile(inFile)\n\n # Read in G5NR CO, CO2, O3, RH\n Iscan = 600\n Icross = 1000\n LevelB = '/nobackup/PACE/LevelB/Y2006/M03/D24'\n inFile = '{}/pace-g5nr-std.lb.chm_Nv.20060324_005000.nc4'.format(LevelB)\n nc = Dataset(inFile)\n co = nc.variables['CO'][0,:,Iscan,Icross] # VMR\n co2 = nc.variables['CO2'][0,:,Iscan,Icross] # VMR\n o3 = nc.variables['O3'][0,:,Iscan,Icross] #kg/kg\n nc.close()\n inFile = '{}/pace-g5nr-std.lb.aer_Nv.20060324_005000.nc4'.format(LevelB)\n nc = Dataset(inFile)\n h2o = nc.variables['WV_VMR'][0,:,Iscan,Icross] #ppm\n nc.close()\n \n # flip from bottom to top\n co = co[::-1]\n co2 = co2[::-1]\n o3 = o3[::-1]\n h2o = h2o[::-1]\n\n # Read in alpha_table\n inFile = 'alphaTable_v0/alpha_CK_Thuillier_o3.nc4'\n nc = Dataset(inFile)\n all_wl = np.array(nc.variables['channels'][:])\n g_bins = nc.variables['g_bins'][:]\n alpha_o2 = nc.variables['alpha_o2'][:]\n ROD = nc.variables['ROD'][:]\n depol = nc.variables['depol_ratio'][:]\n F0_int = nc.variables['solar_irradiance'][:]\n\n nc.close()\n\n alpha = alpha_o2\n\n# # integrate air density in each layer\n# rhoint = rho*dz\n\n\n # get absorption optical depth with new aborption coefficient\n# co_vmr = 0.1*1e-6\n# co_vmr = co\n# alpha_co = get_alpha(abs_co_z,co_vmr,rho,dz)\n \n# o2_vmr = 0.21\n# alpha_o2 = get_alpha(abs_o2_z,o2_vmr,rho,dz)\n \n# co2_vmr = 400.*1.0E-06\n# co2_vmr = co2\n# alpha_co2 = get_alpha(abs_co2_z,co2_vmr,rho,dz)\n\n# ch4_vmr = 1.8*1.0E-06\n# alpha_ch4 = get_alpha(abs_ch4_z,ch4_vmr,rho,dz)\n\n# n2o_vmr = 0.3*1.0E-06\n# alpha_n2o = get_alpha(abs_n2o_z,n2o_vmr,rho,dz)\n\n# h2o_vmr = h2o*1.0e-6\n# alpha_h2o = get_alpha(abs_h2o_z,h2o_vmr,rho,dz)\n\n # add up all the alphas\n# alpha = alpha_h2o + alpha_n2o + alpha_ch4 + alpha_co2 + alpha_o2 + alpha_co\n\n# # ----\n# # OZONE Stuff\n# # ---\n# # read xsec\n# inFile = 'hyperTest/o3_bremen/Ozone_abs_x_wTemperatureFit.dat'\n# # wav [nm], C0, C1(T), C2(T^2)\n# # xsec is in m2/molecule\n# wav_o3,abs_o3 = read_o3(inFile,tm)\n# # reverse so going from max to min wavelength\n# wav_o3 = wav_o3[::-1]\n# abs_o3 = abs_o3[:,::-1]\n\n# # interpolate to LBL wavelengths\n# # append zeros to max lbl wavelength\n# wav_new = np.arange(wav_o3.max()+0.1,wav_abs.max()+0.1,0.1)\n# # reverse\n# wav_new = wav_new[::-1]\n# wav_o3 = np.append(wav_new,wav_o3)\n# nnew = len(wav_new)\n# abs_o3 = np.append(np.zeros([km,nnew]),abs_o3,axis=1)\n\n# abs_o3_lbl = np.zeros(abs_h2o_z.shape)\n# for k in range(km):\n# # xsec_f = interp1d(wav_o3,abs_o3[k,:],kind='linear')\n# abs_o3_lbl[k,:] = xsec_f(wav_abs)\n \n# # append UV-Vis to LBL that stops at 555\n# i = wav_o3 < wav_abs.min()\n# all_wl = np.append(wav_abs,wav_o3[i])\n# abs_o3_lbl = np.append(abs_o3_lbl,abs_o3[:,i],axis=1)\n \n# # convert mass mixing ratio to molecules/m3\n# Na = 6.022e23 # avogadro's number\n# O3_MW = 48.0*1e-3 # kg/mole\n\n# o3_conc = o3*AIRDENS # kg/m3\n# o3_conc = o3_conc*Na/O3_MW # molecules/m3\n\n# # get the optical depth subcolumns\n# alpha_o3 = np.zeros(abs_o3_lbl.shape)\n# for i in range(km):\n# alpha_o3[i,:] = o3_conc[i]*dz[i]*abs_o3_lbl[i,:]\n\n nwav = len(all_wl)\n \n# # add ozone to total alpha\n# # extend array down to uv\n# nnew = nwav - len(wav_abs)\n# alpha = np.append(alpha,np.zeros([km,nnew]),axis=1)\n# alpha = alpha + alpha_o3\n \n# # limit to wavelengths covered by RSR\n# I = all_wl <= wav_rsr.max()+1.0\n# all_wl = all_wl[I]\n# alpha = alpha[:,I]\n# alpha[:] = 0.0\n\n\n# # get ROD from oci_tables\n# inFile = 'oci_tables/rayleigh_bodhaine.txt'\n# wav,rod,depol = read_ROD_table(inFile)\n\n# # interpolate to lbl wavelengths\n# rod_f = interp1d(wav,rod,kind='linear')\n# rod_lbl = rod_f(all_wl)\n# depol_f = interp1d(wav,depol,kind='linear')\n# depol_lbl = depol_f(all_wl)\n \n # flip everything vertically so going from top of atmosphere to surface\n pe = pe[-1::-1]\n te = te[-1::-1]\n ze = ze[-1::-1]\n# alpha = alpha[-1::-1,:]\n\n # add dimension to be in km+1,nobs\n pe.shape = (km+1,1)\n te.shape = (km+1,1)\n ze.shape = (km+1,1)\n\n\n # read in granule geometry\n SZA,VZA,RAA,SAA,VAA = get_geom(Iscan,Icross)\n csza = np.cos(np.radians(SZA))\n\n# # Read in solar irradiance spectrum\n# # second dim = wavelength, irradiance\n# # units=nm, uW/cm^2/nm\n# inFile = '{}/Thuillier_F0.npy'.format(outRoot)\n# F0 = np.load(inFile)\n# # interpolate to wavelengths \n# F0_f = interp1d(F0[:,0],F0[:,1],kind='linear',fill_value=\"extrapolate\")\n# F0_int = F0_f(all_wl)\n\n # --------------\n # surface stuff\n # --------------\n\n # SLEAVE\n LevelB = '/nobackup/PACE/LevelB/surface/SLEAVE/NOBM/Y2006/M03/D24'\n inFile = '{}/pace-g5nr.lb.sleave.20060324_005000.nc4'.format(LevelB)\n nc = Dataset(inFile)\n nobm_wav = nc.variables['wavelength'][:]\n rrs = nc.variables['rrs'][0,:,Iscan,Icross]\n nc.close()\n rrs_f = interp1d(nobm_wav,rrs,kind='linear',fill_value=0.0,bounds_error=False)\n sleave = rrs_f(all_wl)*csza\n \n # wind speed\n LevelB = '/nobackup/PACE/LevelB/Y2006/M03/D24'\n inFile = '{}/pace-g5nr-std.lb.met_Nv.20060324_005000.nc4'.format(LevelB)\n nc = Dataset(inFile)\n U10m = np.array([nc.variables['U10M'][0,Iscan,Icross]])\n V10m = np.array([nc.variables['V10M'][0,Iscan,Icross]])\n\n # water refractive index\n mr = 1.334\n\n # RT stuff\n nstreams = 12\n albedoType = 'OCIGissCX_NOBM_CLOUD'\n albedoType = 'OCIGissCX'\n\n # loop through channels\n nproc = 50\n nwl = len(all_wl)\n# nwl = 100\n# wlstep = int(nwl/nproc)\n wlstep = 10\n sys.exit()\n args = []\n ROD = []\n depol = []\n sys.exit()\n for ich in np.arange(0,nwl,wlstep):\n endch = ich + wlstep\n if endch > nwl:\n endch = nwl\n nch = endch - ich\n ch = all_wl[ich:endch]\n\n # Get Rayleigh\n # ROT shape is nlev,1,nch\n ROT, depol_ratio = get_ROT(ch,pe,te,ze,verbose=False) \n \n ROT = ROT*rod_lbl[ich:endch]/np.squeeze(ROT.sum(axis=0))\n ROD.append(np.squeeze(ROT.sum(axis=0)))\n\n depol_ratio = depol_lbl[ich:endch]\n depol.append(depol_ratio)\n\n # trace gas\n alpha_ch = alpha[:,ich:endch]\n alpha_ch.shape = (km,1,nch)\n\n # AOP vectors [km,nch,nobs]\n tau = np.zeros([km,nch,1])\n ssa = np.zeros([km,nch,1])\n pmom = np.zeros([km,nch,1,30,6])\n \n # water refractive index\n mr_in = np.ones(nch)\n mr_in = mr_in*mr\n\n # solar irradiance\n F0_in = F0_int[ich:endch]\n F0_in.shape = (nch,1)\n\n # sleave\n sleave_ch = sleave[ich:endch]\n\n args.append([ch,\n F0_in,\n ROT,depol_ratio,\n tau,ssa,pmom,\n alpha_ch,\n SZA,VZA,RAA,\n km,pe,te,ze,\n nstreams,\n albedoType,\n sleave_ch,\n U10m,V10m,mr_in,\n False])\n\n# I,reflectance,BR = get_TOA(ch,\n# ROT,depol_ratio,\n# tau,ssa,pmom,\n# alpha_ch,\n# SZA,VZA,RAA,\n# km,pe,te,ze,\n# nstreams,\n# albedoType,\n# U10m=U10m,V10m=V10m,mr=np.array([1.334]),\n# verbose=False)\n\n\n \n # use multiprocessing\n p = Pool(nproc)\n result = p.map(get_TOA_unpack,args)\n I = []\n reflectance = []\n BR = []\n for r in result: \n I_r,reflectance_r,BR_r = r\n I.append(np.squeeze(I_r))\n reflectance.append(np.squeeze(reflectance_r))\n BR.append(np.squeeze(BR_r))\n\n p.close()\n p.join()\n \n # concatenate arrays\n ROD = np.concatenate(ROD)\n depol_ratio = np.concatenate(depol)\n\n I = np.concatenate(I)\n reflectance = np.concatenate(reflectance)\n BR = np.concatenate(BR)\n \n alphaD = alpha.sum(axis=0) \n # write to outFile\n writenc(outFile,all_wl,\n F0_int,\n SZA,SAA,VZA,VAA,\n I,BR,reflectance,\n ROD,depol_ratio,\n alphaD,\n pe,te,ze,\n U10m,V10m,mr) \n\n", "meta": {"hexsha": "9592620b57c68258aa14e6dbe02f79360dcc64cf", "size": 19986, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/Components/missions/PACE/hyperTest_ck_g5nr.py", "max_stars_repo_name": "GEOS-ESM/AeroApps", "max_stars_repo_head_hexsha": "874dad6f34420c014d98eccbe81a061bdc0110cf", "max_stars_repo_licenses": ["NASA-1.3", "ECL-2.0", "Apache-2.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-12-02T14:23:30.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-31T15:39:30.000Z", "max_issues_repo_path": "src/Components/missions/PACE/hyperTest_ck_g5nr.py", "max_issues_repo_name": "GEOS-ESM/AeroApps", "max_issues_repo_head_hexsha": "874dad6f34420c014d98eccbe81a061bdc0110cf", "max_issues_repo_licenses": ["NASA-1.3", "ECL-2.0", "Apache-2.0"], "max_issues_count": 9, "max_issues_repo_issues_event_min_datetime": "2020-04-15T16:22:14.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-24T13:59:25.000Z", "max_forks_repo_path": "src/Components/missions/PACE/hyperTest_ck_g5nr.py", "max_forks_repo_name": "GEOS-ESM/AeroApps", "max_forks_repo_head_hexsha": "874dad6f34420c014d98eccbe81a061bdc0110cf", "max_forks_repo_licenses": ["NASA-1.3", "ECL-2.0", "Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.7969401947, "max_line_length": 103, "alphanum_fraction": 0.5610427299, "include": true, "reason": "import numpy,import scipy,from scipy", "num_tokens": 6425, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6113819732941511, "lm_q2_score": 0.3140505385717077, "lm_q1q2_score": 0.19200483798606158}} {"text": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n################################################################################\n#\n# CanTherm\n# \n# Copyright (c) 2010 by Joshua W. Allen (jwallen@mit.edu)\n#\n# Permission is hereby granted, free of charge, to any person obtaining a\n# copy of this software and associated documentation files (the 'Software'),\n# to deal in the Software without restriction, including without limitation\n# the rights to use, copy, modify, merge, publish, distribute, sublicense,\n# and/or sell copies of the Software, and to permit persons to whom the\n# Software is furnished to do so, subject to the following conditions:\n#\n# The above copyright notice and this permission notice shall be included in\n# all copies or substantial portions of the Software.\n#\n# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n# DEALINGS IN THE SOFTWARE.\n#\n################################################################################\n\nimport math\nimport numpy\nimport logging\n\nfrom rmgpy.quantity import constants\nfrom rmgpy.statmech import *\n\n################################################################################\n\ndef applyEnergyCorrections(E0, modelChemistry, atoms, bonds):\n \"\"\"\n Given an energy `E0` in J/mol as read from the output of a quantum chemistry\n calculation at a given `modelChemistry`, adjust the energy such that it\n is consistent with the normal gas-phase reference states. `atoms` is a\n dictionary associating element symbols with the number of that element in\n the molecule. `bonds` is a dictionary associating bond types with the number\n of that bond in the molecule.\n \"\"\"\n \n # Spin orbit correction (SOC) in Hartrees\n # Values taken from note 22 of http://jcp.aip.org/resource/1/jcpsa6/v109/i24/p10570_s1 and converted to hartrees\n # Values in millihartree are also available (with fewer significant figures) from http://jcp.aip.org/resource/1/jcpsa6/v106/i3/p1063_s1\n SOC = {'H':0.0, 'N':0.0, 'O': -0.000355, 'C': -0.000135, 'P': 0.0, 'S': -0.000893} \n \n # Step 1: Reference all energies to a model chemistry-independent basis\n # by subtracting out that model chemistry's atomic energies\n # Note: If your model chemistry does not include spin orbit coupling, you should add the corrections to the energies here\n if modelChemistry == 'CBS-QB3':\n atomEnergies = {'H':-0.499818 , 'N':-54.520543, 'O':-74.987624, 'C':-37.785385, 'P':-340.817186, 'S': -397.657360}\n elif modelChemistry == 'G3':\n atomEnergies = {'H':-0.5010030, 'N':-54.564343, 'O':-75.030991, 'C':-37.827717, 'P':-341.116432}\n elif modelChemistry == 'Klip_1':\n atomEnergies = {'H':-0.50003976 + SOC['H'], 'O':-75.00915718 + SOC['O'], 'C':-37.79249556 + SOC['C']}\n elif modelChemistry == 'Klip_2':\n #Klip QCI(tz,qz)\n atomEnergies = {'H':-0.50003976 + SOC['H'], 'O':-75.00692746 + SOC['O'], 'C':-37.79044863 + SOC['C']}\n elif modelChemistry == 'Klip_2_cc':\n #Klip CCSD(T)(tz,qz)\n atomEnergies = {'H':-0.50003976 + SOC['H'], 'O':-75.00681155 + SOC['O'], 'C':-37.79029443 + SOC['C']}\n else:\n logging.warning('Unknown model chemistry \"{0}\"; not applying energy corrections.'.format(modelChemistry))\n return E0\n for symbol, count in atoms.iteritems():\n if symbol in atomEnergies: E0 -= count * atomEnergies[symbol] * 4.35974394e-18 * constants.Na\n else:\n logging.warning('Ignored unknown atom type \"{0}\".'.format(symbol))\n \n # Step 2: Atom energy corrections to reach gas-phase reference state\n # Experimental enthalpy of formation at 0 K \n # See Gaussian thermo whitepaper at http://www.gaussian.com/g_whitepap/thermo.htm)\n # Note: these values are relatively old and some improvement may be possible by using newer values, particularly for carbon\n # However, care should be taken to ensure that they are compatible with the BAC values (if BACs are used)\n atomHf = {'H': 51.63 , 'N': 112.53 ,'O': 58.99 ,'C': 169.98, 'S': 65.66 }\n # Thermal contribution to enthalpy Hss(298 K) - Hss(0 K) reported by Gaussian thermo whitepaper\n # This will be subtracted from the corresponding value in atomHf to produce an enthalpy used in calculating the enthalpy of formation at 298 K\n atomThermal = {'H': 1.01 , 'N': 1.04, 'O': 1.04 ,'C': 0.25, 'S': 1.05 }\n # Total energy correction used to reach gas-phase reference state\n # Note: Spin orbit coupling no longer included in these energies, since some model chemistries include it automatically\n atomEnergies = {}\n for element in atomHf:\n atomEnergies[element] = atomHf[element] - atomThermal[element]\n for symbol, count in atoms.iteritems():\n if symbol in atomEnergies: E0 += count * atomEnergies[symbol] * 4184\n \n # Step 3: Bond energy corrections\n bondEnergies = { 'C-H': -0.11, 'C-C': -0.3, 'C=C': -0.08, 'C#C': -0.64,\n 'O-H': 0.02, 'C-O': 0.33, 'C=O': 0.55, 'N#N': -2.0, 'O=O': -0.2, \n 'H-H': 1.1, 'C#N': -0.89, 'S-H': 0.0, 'C-S': 0.43, 'S=O': -0.78 }\n for symbol, count in bonds.iteritems():\n if symbol in bondEnergies: E0 += count * bondEnergies[symbol] * 4184\n else:\n logging.warning('Ignored unknown bond type \"{0}\".'.format(symbol))\n \n return E0\n\n################################################################################\n\ndef projectRotors(geom, F, rotors, linear, TS):\n \"\"\"\n For a given geometry `geom` with associated force constant matrix `F`,\n lists of rotor information `rotors`, `pivots`, and `top1`, and the linearity\n of the molecule `linear`, project out the nonvibrational modes from the\n force constant matrix and use this to determine the vibrational frequencies.\n The list of vibrational frequencies is returned in cm^-1.\n \"\"\"\n \n Nrotors = len(rotors)\n Natoms = len(geom.mass)\n Nvib = 3 * Natoms - (5 if linear else 6) - Nrotors - (1 if (TS) else 0)\n \n if linear:\n D = numpy.zeros((Natoms*3,5+Nrotors), numpy.float64)\n else:\n D = numpy.zeros((Natoms*3,6+Nrotors), numpy.float64)\n\n for i in range(Natoms):\n # Projection vectors for translation\n D[3*i+0,0] = 1.0\n D[3*i+1,1] = 1.0\n D[3*i+2,2] = 1.0\n # Projection vectors for [external] rotation\n D[3*i:3*i+3,3] = numpy.array([0, -geom.coordinates[i,2], geom.coordinates[i,1]], numpy.float64)\n D[3*i:3*i+3,4] = numpy.array([geom.coordinates[i,2], 0, -geom.coordinates[i,0]], numpy.float64)\n if not linear:\n D[3*i:3*i+3,5] = numpy.array([-geom.coordinates[i,1], geom.coordinates[i,0], 0], numpy.float64)\n for i, rotor in enumerate(rotors):\n scanLog, pivots, top, symmetry = rotor\n # Determine pivot atom\n if pivots[0] in top: pivot = pivots[0]\n elif pivots[1] in top: pivot = pivots[1]\n else: raise Exception('Could not determine pivot atom.')\n # Projection vectors for internal rotation\n e12 = geom.coordinates[pivots[0],:] - geom.coordinates[pivots[1],:]\n e12 /= numpy.linalg.norm(e12)\n for atom in top:\n e31 = geom.coordinates[atom,:] - geom.coordinates[pivot,:]\n D[3*atom:3*atom+3,-Nrotors+i] = numpy.cross(e31, e12)\n\n # Make sure projection matrix is orthonormal\n import scipy.linalg\n D = scipy.linalg.orth(D)\n\n # Project out the non-vibrational modes from the force constant matrix\n P = numpy.dot(D, D.transpose())\n I = numpy.identity(Natoms*3, numpy.float64)\n F = numpy.dot(I - P, numpy.dot(F, I - P))\n\n # Generate mass-weighted force constant matrix\n # This converts the axes to mass-weighted Cartesian axes\n # Units of Fm are J/m^2*kg = 1/s^2\n Fm = F.copy()\n for i in range(Natoms):\n for j in range(Natoms):\n for u in range(3):\n for v in range(3):\n Fm[3*i+u,3*j+v] /= math.sqrt(geom.mass[i] * geom.mass[j]) / constants.Na\n\n # Get eigenvalues of mass-weighted force constant matrix\n eig, V = numpy.linalg.eigh(Fm)\n eig.sort()\n\n # Convert eigenvalues to vibrational frequencies in cm^-1\n # Only keep the modes that don't correspond to translation, rotation, or internal rotation\n return numpy.sqrt(eig[-Nvib:]) / (2 * math.pi * constants.c * 100)\n\n################################################################################ \n\ndef saveStates(species, geometry, label, path):\n \"\"\"\n Append the molecular degrees of freedom for `species` with associated\n string `label` to the file located at `path` on disk.\n \"\"\"\n \n f = open(path, 'a')\n\n coordinates = geometry.coordinates * 1e10\n number = geometry.number\n numbers = {1: 'H', 6: 'C', 7: 'N', 8: 'O', 14: 'Si', 15: 'P', 16: 'S'}\n\n f = open(path, 'a')\n f.write('# Coordinates for {0} (angstroms):\\n'.format(label))\n for i in range(coordinates.shape[0]):\n x = coordinates[i,0] - coordinates[0,0]\n y = coordinates[i,1] - coordinates[0,1]\n z = coordinates[i,2] - coordinates[0,2]\n f.write('# {0} {1:9.4f} {2:9.4f} {3:9.4f}\\n'.format(numbers[number[i]], x, y, z))\n \n f.write('states(\\n')\n f.write(' label = \"{0}\",\\n'.format(label))\n f.write(' E0 = {0!r},\\n'.format(species.E0))\n f.write(' modes = [\\n')\n for mode in species.states.modes:\n f.write(' {0!r},\\n'.format(mode))\n f.write(' ],\\n')\n f.write(' spinMultiplicity = {0:d},\\n'.format(species.states.spinMultiplicity))\n try:\n f.write(' frequency={0!r},\\n'.format(species.frequency))\n except AttributeError: pass\n f.write(' short_comment = \"\",\\n')\n f.write(' long_comment = \\n')\n f.write('\"\"\"\\n')\n f.write('\\n')\n f.write('\"\"\",\\n')\n f.write(')\\n\\n')\n \n f.close()\n", "meta": {"hexsha": "828a0e36e5672d9dc0847b58586a308bf5398adf", "size": 10178, "ext": "py", "lang": "Python", "max_stars_repo_path": "rmgpy/cantherm/states.py", "max_stars_repo_name": "sean-v8/RMG-Py", "max_stars_repo_head_hexsha": "7cc7c3bfb330786526c56113d98c785bcaaa161a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "rmgpy/cantherm/states.py", "max_issues_repo_name": "sean-v8/RMG-Py", "max_issues_repo_head_hexsha": "7cc7c3bfb330786526c56113d98c785bcaaa161a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "rmgpy/cantherm/states.py", "max_forks_repo_name": "sean-v8/RMG-Py", "max_forks_repo_head_hexsha": "7cc7c3bfb330786526c56113d98c785bcaaa161a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 47.1203703704, "max_line_length": 146, "alphanum_fraction": 0.6123992926, "include": true, "reason": "import numpy,import scipy", "num_tokens": 2919, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073802837478, "lm_q2_score": 0.3486451488696663, "lm_q1q2_score": 0.1919665920677642}} {"text": "# -*- coding: utf-8 -*-\r\n\"\"\"\r\n\r\nMachine Learning applied to defeat a 30 years old DOS game... \r\n\r\nGame mechanics \r\n\"Imbiss\" v. 5.4 by T. Bauer for IBM PC, Public Domain\r\n\r\nCustom Environments in OpenAI’s Gym\r\n\r\nPocs (2020), Beginner’s Guide to Custom Environments in OpenAI’s Gym\r\nHow to set up, verify, and use a custom environment in reinforcement learning training with Python\r\nhttps://towardsdatascience.com/beginners-guide-to-custom-environments-in-openai-s-gym-989371673952\r\nhttps://github.com/MatePocs/gym-basic/blob/main/gym_basic/envs/basic_env_2.py\r\n\r\n@author: Seinheilig, 2021\r\n\"\"\"\r\n\r\n\r\nimport gym\r\nimport numpy as np \r\n\r\nclass ImbissEnv(gym.Env):\r\n \r\n def __init__(self):\r\n self.action_space = gym.spaces.Box(np.array([0,0,0,0,0,0,0]),np.array([300,300,300,300,1300,1300,1300]),dtype=np.int16) # price tags of all 7 elements\r\n self.observation_space = gym.spaces.Box(np.array([1,-9]),np.array([7,40])) # day of week / temperature\r\n \r\n #### ToDo: Observations better MultiDiscrete? // requre different logic for TE... \r\n ### self.observation_space = gym.spaces.MultiDiscrete([ 1, 49 ]) # day of week / temperature\r\n \r\n def rnd_state(self):\r\n #self.state = np.array([np.random.randint(1,7),np.random.randint(0,49)-9],dtype=np.int16) # full state (all days)\r\n self.state = np.array([1,np.random.randint(0,49)-9],dtype=np.int16) # only weekday...\r\n \r\n def step(self, action):\r\n '''\r\n single step\r\n return \r\n '''\r\n V = action # price tags (actions)\r\n T = self.state[0] # day of the week \r\n TE = self.state[1] # temperatur\r\n K = 0 # money before selling \r\n reward = self.Customer_Simulation(V,T,TE,K,Version=3) \r\n self.rnd_state()\r\n done = True \r\n info = {} \r\n return self.state, reward, done, info\r\n \r\n def reset(self):\r\n self.rnd_state()\r\n return self.state\r\n \r\n def render(self, mode='human'):\r\n pass\r\n\r\n def Kaufen(self,WS,V,S,K): \r\n \"\"\" reduced game mechanics for buying (DE: \"kaufen\")\r\n \"\"\"\r\n debug_ = False \r\n H = [10,10,10,20,200,35,55] # lowest price possible \r\n H = [10,10,10,20,200,50,70] # good price..\r\n if debug_:\r\n Waren = ['Schokoeis','Vanilleeis','Erdbeereis','Cola','Zigaretten','Bratwurst','Pommes']\r\n print('Kunde: Könnten Sie mir bitte',S,Waren[WS],'geben')\r\n \r\n return K + S*V[WS] - S*H[WS] # return new net balance after selling (income-expense)\r\n \r\n def Customer_Simulation(self,V,T,TE,K,Version=3):\r\n \"\"\" Spielmechanik - Kunden Simulation\r\n \r\n Args:\r\n V: Verkaufspreise\r\n T: Wochentag in [1:7]\r\n TE: Temperatur \r\n K: Kontostand vor der Simulation\r\n Version: 1) \"Imbiss-Bude\" von F. Brall 1983 für Apple II\r\n 2) \"Imbiss\" von O. Schwald 1984 für Commodore C64\r\n 3) \"Imbiss\" von T. Bauer 1991 für PC\r\n \r\n Returns:\r\n K: Kontostand nach der Simulation\r\n \r\n \"\"\" \r\n debug_ = False\r\n if Version <3:\r\n EK = 10 # Eis Kunden\r\n ZK = 10 # Zigaretten Kunden \r\n BK = 30 # Bratwurst Kunden \r\n if T == 6: # Samstag\r\n EK = 15\r\n ZK = 13\r\n BK = 40\r\n if T == 7: # Sonntag\r\n EK = 20\r\n ZK = 18\r\n BK = 40\r\n \r\n # Korrektur der Kunden als Funktion des Preise \r\n EK -= int(np.min(V[0:3])/10) # bugfix!!\r\n ZK -= int(V[4]/100)\r\n BK -= int(np.min(V[5:7])/20) # bugfix!!\r\n \r\n # Temperatur Korrektur\r\n EK += int(TE/2)\r\n BK -= int(TE/2)\r\n else:\r\n ##### \"Imbiss\" PC 1991 \r\n # 5 Änderungen zum Orginal:\r\n # 1) nutze max V der Warengruppe für Korrektur\r\n # 2) ZK = [10,12,15], ZK Basis Wochentag/Sa/So\r\n # 3) EK += 10 / andere Temperaturabhängigkeit\r\n # 4) BK andere Temperaturabhängigkeit \r\n # 5) if ZK/EK/BK < 0 --> ZK/EK/BK = 0 bevor AK berechnet wird \r\n EK = 20 # Eis Kunden \r\n ZK = 10 # Zigaretten Kunden \r\n BK = 30 # Bratwurst Kunden \r\n if T == 6: # Samstag\r\n EK = 25\r\n ZK = 12\r\n BK = 40\r\n if T == 7: # Sonntag\r\n EK = 30\r\n ZK = 15\r\n BK = 40\r\n \r\n # Korrektur der Kunden als Funktion des Preise \r\n EK -= int(np.max(V[0:4])/10) # bugfix!!\r\n ZK -= int(V[4]/100)\r\n BK -= int(np.max(V[5:7])/20) # bugfix!!\r\n \r\n # Temperatur Korrektur\r\n EK += int(TE/4)\r\n BK -= int(TE/3)\r\n \r\n # zu hoher Preis in einer Warengruppe (neg Kundenwert) führt nicht(!) zu einer Reduktion der Gesamtzahl der Kunden\r\n if BK < 0:\r\n BK = 0\r\n if ZK < 0:\r\n ZK = 0\r\n if EK < 0:\r\n EK = 0 \r\n \r\n AK = ZK+BK+EK \r\n if debug_:\r\n print(\"Customer_Simulation:\",V,T,TE,K)\r\n print('Kunden gesamt:\\t\\t',AK)\r\n print('Eis Kunden:\\t\\t',EK)\r\n print('Zigaret. Kunden:\\t',ZK)\r\n print('Bratwurst Kunden:\\t',BK)\r\n if AK < 0:\r\n AK = 0 \r\n \r\n if AK < 2:\r\n return K\r\n \r\n for Kunde in range(AK):\r\n #print('Kunde',Kunde)\r\n kauf = False\r\n E = np.random.randint(0,9) # eine Zufallsvariabe für Anzahl Einheiten zu kaufen und Preise ignorieren \r\n if E == 2:\r\n S = 2\r\n else: \r\n S = 1 \r\n \r\n while not(kauf):\r\n # eine zufällige Ware wählen \r\n Z = np.random.randint(0,7)\r\n \r\n if Z < 4 and EK == 0: # keine Eiskunden mehr \r\n #print('keine Eiskunden mehr')\r\n kauf = False \r\n continue\r\n \r\n if Z == 4 and ZK == 0: # keine Zigarettenkunden mehr \r\n continue\r\n \r\n if Z > 4 and BK == 0: # keine Bratwurstkunden mehr \r\n continue\r\n \r\n if Z == 0: # Schokoeis\r\n if E != 3: # Preisprüfung überspringen? (in 10% der Fälle)\r\n if V[0]-V[1] > 20:\r\n K = self.Kaufen(1,V,S,K)\r\n EK -= 1; kauf = True \r\n break\r\n if V[0]-V[2] > 20:\r\n K = self.Kaufen(2,V,S,K)\r\n EK -= 1; kauf = True \r\n break \r\n K = self.Kaufen(0,V,S,K) \r\n EK -= 1; kauf = True \r\n \r\n if Z == 1: # Vanilleeis\r\n if E != 3: # Preisprüfung überspringen? (in 10% der Fälle)\r\n if V[1]-V[0] > 20:\r\n K = self.Kaufen(0,V,S,K)\r\n EK -= 1; kauf = True \r\n break \r\n if V[1]-V[2] > 20:\r\n K = self.Kaufen(2,V,S,K)\r\n EK -= 1; kauf = True \r\n break\r\n K = self.Kaufen(1,V,S,K) \r\n EK -= 1; kauf = True \r\n \r\n if Z == 2: # Erdbeereis\r\n if E != 3: # Preisprüfung überspringen? (in 10% der Fälle)\r\n if V[2]-V[0] > 20:\r\n K = K = self.Kaufen(0,V,S,K)\r\n EK -= 1; kauf = True \r\n break \r\n if V[2]-V[1] > 20:\r\n K = self.Kaufen(1,V,S,K)\r\n EK -= 1; kauf = True \r\n break \r\n K = self.Kaufen(2,V,S,K) \r\n EK -= 1; kauf = True \r\n \r\n if Z == 3: # Cola ## KEINE PREISPRÜFUNG COLA!!!\r\n K = self.Kaufen(3,V,S,K) \r\n EK -= 1; kauf = True \r\n \r\n if Z == 4: # Zigarette ## PREISPRÜFUNG indirekt über ZK \r\n K = self.Kaufen(4,V,S,K) \r\n ZK -= 1; kauf = True \r\n \r\n if Z == 5: # Bratwurst\r\n if E != 3: # Preisprüfung überspringen? (in 10% der Fälle)\r\n if V[5]-V[6] > 30:\r\n K = self.Kaufen(6,V,S,K)\r\n BK -= 1; kauf = True \r\n break\r\n K = self.Kaufen(5,V,S,K) \r\n BK -= 1; kauf = True \r\n \r\n if Z == 6: # Pommes\r\n if E != 3: # Preisprüfung überspringen? (in 10% der Fälle)\r\n if V[6]-V[5] > 30:\r\n K = self.Kaufen(5,V,S,K)\r\n BK -= 1; kauf = True \r\n break\r\n K = self.Kaufen(6,V,S,K) \r\n BK -= 1; kauf = True \r\n \r\n return K\r\n", "meta": {"hexsha": "3c12a5c1e32ff1b2cef47a8d73023d7b3d94fd65", "size": 10397, "ext": "py", "lang": "Python", "max_stars_repo_path": "imbiss_env.py", "max_stars_repo_name": "Steinheilig/Imbiss", "max_stars_repo_head_hexsha": "49f6ae865cef05b4999569cecaf5931db0fb2113", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "imbiss_env.py", "max_issues_repo_name": "Steinheilig/Imbiss", "max_issues_repo_head_hexsha": "49f6ae865cef05b4999569cecaf5931db0fb2113", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "imbiss_env.py", "max_forks_repo_name": "Steinheilig/Imbiss", "max_forks_repo_head_hexsha": "49f6ae865cef05b4999569cecaf5931db0fb2113", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.9233870968, "max_line_length": 164, "alphanum_fraction": 0.3776089257, "include": true, "reason": "import numpy", "num_tokens": 2574, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073655352404, "lm_q2_score": 0.3486451353339458, "lm_q1q2_score": 0.19196657947290124}} {"text": "#!/usr/bin/env python\n#\n# See top-level LICENSE file for Copyright information\n#\n# -*- coding: utf-8 -*-\n\"\"\"\nThis script enables the user to convert spec2D FITS files\nfrom IFU instruments into a 3D cube with a defined WCS.\n\"\"\"\n\nimport argparse\n\nfrom astropy import units\nfrom astropy.io import fits\nfrom astropy.coordinates import SkyCoord\nfrom astropy.wcs import WCS\nimport numpy as np\nimport copy, os\n\nfrom pypeit import msgs, par, io, spec2dobj\nfrom pypeit.spectrographs.util import load_spectrograph\nfrom pypeit.core import datacube as dc_utils\nfrom pypeit.core.flux_calib import load_extinction_data, extinction_correction\nfrom pypeit.core.flexure import calculate_image_offset\nfrom pypeit.core import parse\n\nfrom IPython import embed\n\n\ndef parse_args(options=None, return_parser=False):\n\n parser = argparse.ArgumentParser(description='Read in an array of spec2D files and convert them into a datacube',\n formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n\n parser.add_argument('file', type = str, default=None, help='filename.coadd3d file')\n parser.add_argument('--det', default=1, type=int, help=\"Detector\")\n parser.add_argument('-o', '--overwrite', default=False, action='store_true',\n help='Overwrite any existing files/directories')\n\n if return_parser:\n return parser\n\n return parser.parse_args() if options is None else parser.parse_args(options)\n\n\ndef coadd_cube(files, parset, overwrite=False):\n \"\"\" Main routine to coadd spec2D files into a 3D datacube\n\n Args:\n files (list):\n List of all spec2D files\n parset (:class:`pypeit.par.core.PypeItPar`):\n An instance of the parameter set.\n overwrite (bool):\n Overwrite the output file, if it exists?\n \"\"\"\n # Get the detector number\n det = 1 if parset is None else parset['rdx']['detnum']\n\n # Load the spectrograph\n spec2DObj = spec2dobj.Spec2DObj.from_file(files[0], det)\n specname = spec2DObj.head0['PYP_SPEC']\n spec = load_spectrograph(specname)\n\n # Grab the parset, if not provided\n if parset is None: parset = spec.default_pypeit_par()\n cubepar = parset['reduce']['cube']\n\n # Check the output file\n outfile = cubepar['output_filename'] if \".fits\" in cubepar['output_filename'] else cubepar['output_filename']+\".fits\"\n out_whitelight = outfile.replace(\".fits\", \"_whitelight.fits\")\n if os.path.exists(outfile) and not overwrite:\n msgs.error(\"Output filename already exists:\"+msgs.newline()+outfile)\n elif os.path.exists(out_whitelight) and cubepar['save_whitelight'] and not overwrite:\n msgs.error(\"Output filename already exists:\"+msgs.newline()+out_whitelight)\n # Check the reference cube and image exist, if requested\n ref_scale = None # This will be used to correct relative scaling among the various input frames\n if cubepar['standard_cube'] is not None:\n if not os.path.exists(cubepar['standard_cube']):\n msgs.error(\"Standard cube does not exist:\" + msgs.newline() + cubepar['reference_cube'])\n cube = fits.open(cubepar['standard_cube'])\n ref_scale = cube['REFSCALE'].data\n if cubepar['reference_image'] is not None:\n if not os.path.exists(cubepar['reference_image']):\n msgs.error(\"Reference cube does not exist:\" + msgs.newline() + cubepar['reference_image'])\n if cubepar['flux_calibrate']:\n msgs.error(\"Flux calibration is not currently implemented\" + msgs.newline() +\n \"Please set 'flux_calibrate = False'\")\n\n # prep\n numfiles = len(files)\n combine = cubepar['combine']\n\n all_ra, all_dec, all_wave = np.array([]), np.array([]), np.array([])\n all_sci, all_ivar, all_idx, all_wghts = np.array([]), np.array([]), np.array([]), np.array([])\n all_wcs = []\n dspat = None if cubepar['spatial_delta'] is None else cubepar['spatial_delta']/3600.0 # binning size on the sky (/3600 to convert to degrees)\n dwv = cubepar['wave_delta'] # binning size in wavelength direction (in Angstroms)\n wave_ref = None\n whitelight_img = None # This is the whitelight image based on all input spec2d frames\n weights = np.ones(numfiles) # Weights to use when combining cubes\n for ff, fil in enumerate(files):\n # Load it up\n spec2DObj = spec2dobj.Spec2DObj.from_file(fil, det)\n detector = spec2DObj.detector\n\n # Setup for PypeIt imports\n msgs.reset(verbosity=2)\n\n if ref_scale is None:\n ref_scale = spec2DObj.scaleimg.copy()\n # Extract the information\n sciimg = (spec2DObj.sciimg-spec2DObj.skymodel) * (ref_scale/spec2DObj.scaleimg) # Subtract sky and apply relative sky\n ivar = spec2DObj.ivarraw / (ref_scale/spec2DObj.scaleimg)**2\n waveimg = spec2DObj.waveimg\n bpmmask = spec2DObj.bpmmask\n\n # Grab the slit edges\n slits = spec2DObj.slits\n\n wave0 = waveimg[waveimg != 0.0].min()\n diff = waveimg[1:, :] - waveimg[:-1, :]\n dwv = float(np.median(diff[diff != 0.0]))\n msgs.info(\"Using wavelength solution: wave0={0:.3f}, dispersion={1:.3f} Angstrom/pixel\".format(wave0, dwv))\n\n msgs.info(\"Constructing slit image\")\n slitid_img_init = slits.slit_img(pad=0, initial=True, flexure=spec2DObj.sci_spat_flexure)\n onslit_gpm = (slitid_img_init > 0) & (bpmmask == 0)\n\n # Grab the WCS of this frame\n wcs = spec.get_wcs(spec2DObj.head0, slits, detector.platescale, wave0, dwv)\n all_wcs.append(copy.deepcopy(wcs))\n\n # Find the largest spatial scale of all images being combined\n # TODO :: probably need to put this in the DetectorContainer\n pxscl = detector.platescale * parse.parse_binning(detector.binning)[1] / 3600.0 # This should be degrees/pixel\n slscl = spec.get_meta_value([spec2DObj.head0], 'slitwid')\n if dspat is None:\n dspat = max(pxscl, slscl)\n elif max(pxscl, slscl) > dspat:\n dspat = max(pxscl, slscl)\n\n # Generate an RA/DEC image\n msgs.info(\"Generating RA/DEC image\")\n raimg, decimg, minmax = slits.get_radec_image(wcs, initial=True, flexure=spec2DObj.sci_spat_flexure)\n\n # Perform the DAR correction\n if wave_ref is None:\n wave_ref = 0.5*(np.min(waveimg[onslit_gpm]) + np.max(waveimg[onslit_gpm]))\n # Get DAR parameters\n raval = spec.get_meta_value([spec2DObj.head0], 'ra')\n decval = spec.get_meta_value([spec2DObj.head0], 'dec')\n obstime = spec.get_meta_value([spec2DObj.head0], 'obstime')\n pressure = spec.get_meta_value([spec2DObj.head0], 'pressure')\n temperature = spec.get_meta_value([spec2DObj.head0], 'temperature')\n rel_humidity = spec.get_meta_value([spec2DObj.head0], 'humidity')\n coord = SkyCoord(raval, decval, unit=(units.deg, units.deg))\n location = spec.location # TODO :: spec.location should probably end up in the TelescopePar (spec.telescope.location)\n ra_corr, dec_corr = dc_utils.dar_correction(waveimg[onslit_gpm], coord, obstime, location,\n pressure, temperature, rel_humidity, wave_ref=wave_ref)\n raimg[onslit_gpm] += ra_corr\n decimg[onslit_gpm] += dec_corr\n\n # Get copies of arrays to be saved\n wave_ext = waveimg[onslit_gpm].copy()\n flux_ext = sciimg[onslit_gpm].copy()\n ivar_ext = ivar[onslit_gpm].copy()\n\n # Perform extinction correction\n msgs.info(\"Applying extinction correction\")\n longitude = spec.telescope['longitude']\n latitude = spec.telescope['latitude']\n airmass = spec2DObj.head0[spec.meta['airmass']['card']]\n extinct = load_extinction_data(longitude, latitude)\n # extinction_correction requires the wavelength is sorted\n wvsrt = np.argsort(wave_ext)\n ext_corr = extinction_correction(wave_ext[wvsrt] * units.AA, airmass, extinct)\n # Correct for extinction\n flux_sav = flux_ext[wvsrt] * ext_corr\n ivar_sav = ivar_ext[wvsrt] / ext_corr ** 2\n # sort back to the original ordering\n resrt = np.argsort(wvsrt)\n\n # Calculate the weights relative to the zeroth cube\n if ff != 0:\n weights[ff] = np.median(flux_sav[resrt]*np.sqrt(ivar_sav[resrt]))**2\n\n # Store the information\n numpix = raimg[onslit_gpm].size\n all_ra = np.append(all_ra, raimg[onslit_gpm].copy())\n all_dec = np.append(all_dec, decimg[onslit_gpm].copy())\n all_wave = np.append(all_wave, wave_ext.copy())\n all_sci = np.append(all_sci, flux_sav[resrt].copy())\n all_ivar = np.append(all_ivar, ivar_sav[resrt].copy())\n all_idx = np.append(all_idx, ff*np.ones(numpix))\n all_wghts = np.append(all_wghts, weights[ff]*np.ones(numpix))\n\n # Grab cos(dec) for convenience\n cosdec = np.cos(np.mean(all_dec) * np.pi / 180.0)\n\n # Register spatial offsets between all frames if several frames are being combined\n if combine:\n\n # Check if a reference whitelight image should be used to register the offsets\n if cubepar[\"reference_image\"] is None:\n # Generate white light images\n whitelight_imgs, _, _ = dc_utils.make_whitelight(all_ra, all_dec, all_wave, all_sci, all_wghts, all_idx,\n dspat)\n # ref_idx will be the index of the cube with the highest S/N\n ref_idx = np.argmax(weights)\n reference_image = whitelight_imgs[:, :, ref_idx].copy()\n msgs.info(\"Calculating spatial translation of each cube relative to cube #{0:d})\".format(ref_idx+1))\n else:\n ref_idx = -1 # Don't use an index\n # Load reference information\n reference_image, whitelight_imgs, wlwcs = \\\n dc_utils.make_whitelight_fromref(all_ra, all_dec, all_wave, all_sci, all_wghts, all_idx, dspat,\n cubepar['reference_image'])\n msgs.info(\"Calculating the spatial translation of each cube relative to user-defined 'reference_image'\")\n # Calculate the image offsets - check the reference is a zero shift\n ra_shift_ref, dec_shift_ref = calculate_image_offset(reference_image.copy(), reference_image.copy())\n for ff in range(numfiles):\n # Don't correlate the reference image with itself\n if ff == ref_idx:\n continue\n # Calculate the shift\n ra_shift, dec_shift = calculate_image_offset(whitelight_imgs[:, :, ff], reference_image.copy())\n # Convert to reference\n ra_shift -= ra_shift_ref\n dec_shift -= dec_shift_ref\n # Convert pixel shift to degress shift\n ra_shift *= dspat/cosdec\n dec_shift *= dspat\n msgs.info(\"Spatial shift of cube #{0:d}: RA, DEC (arcsec) = {1:+0.3f}, {2:+0.3f}\".format(ff+1, ra_shift*3600.0, dec_shift*3600.0))\n # Apply the shift\n all_ra[all_idx == ff] += ra_shift\n all_dec[all_idx == ff] += dec_shift\n\n # Generate a white light image of *all* data\n msgs.info(\"Generating global white light image\")\n if cubepar[\"reference_image\"] is None:\n whitelight_img, _, wlwcs = dc_utils.make_whitelight(all_ra, all_dec, all_wave, all_sci, all_wghts,\n np.zeros(all_ra.size), dspat)\n else:\n _, whitelight_img, wlwcs = \\\n dc_utils.make_whitelight_fromref(all_ra, all_dec, all_wave, all_sci, all_wghts, np.zeros(all_ra.size),\n dspat, cubepar['reference_image'])\n\n # Calculate the relative spectral weights of all pixels\n all_wghts = dc_utils.compute_weights(all_ra, all_dec, all_wave, all_sci, all_ivar, all_idx,\n whitelight_img[:, :, 0], dspat, dwv,\n relative_weights=cubepar['relative_weights'])\n # Check if a whitelight image should be saved\n if cubepar['save_whitelight']:\n # Check if the white light image still needs to be generated - if so, generate it now\n if whitelight_img is None:\n msgs.info(\"Generating global white light image\")\n if cubepar[\"reference_image\"] is None:\n whitelight_img, _, wlwcs = dc_utils.make_whitelight(all_ra, all_dec, all_wave, all_sci, all_wghts,\n np.zeros(all_ra.size), dspat)\n else:\n _, whitelight_img, wlwcs = \\\n dc_utils.make_whitelight_fromref(all_ra, all_dec, all_wave, all_sci, all_wghts,\n np.zeros(all_ra.size),\n dspat, cubepar['reference_image'])\n # Prepare and save the fits file\n msgs.info(\"Saving white light image as: {0:s}\".format(out_whitelight))\n img_hdu = fits.PrimaryHDU(whitelight_img.T, header=wlwcs.to_header())\n img_hdu.writeto(out_whitelight, overwrite=overwrite)\n\n # Setup the cube ranges\n ra_min = cubepar['ra_min'] if cubepar['ra_min'] is not None else np.min(all_ra)\n ra_max = cubepar['ra_max'] if cubepar['ra_max'] is not None else np.max(all_ra)\n dec_min = cubepar['dec_min'] if cubepar['dec_min'] is not None else np.min(all_dec)\n dec_max = cubepar['dec_max'] if cubepar['dec_max'] is not None else np.max(all_dec)\n wav_min = cubepar['wave_min'] if cubepar['wave_min'] is not None else np.min(all_wave)\n wav_max = cubepar['wave_max'] if cubepar['wave_max'] is not None else np.max(all_wave)\n if cubepar['wave_delta'] is not None: dwv = cubepar['wave_delta']\n # Generate a master WCS to register all frames\n coord_min = [ra_min, dec_min, wav_min]\n coord_dlt = [dspat, dspat, dwv]\n masterwcs = dc_utils.generate_masterWCS(coord_min, coord_dlt, name=specname)\n msgs.info(msgs.newline()+\"-\"*40 +\n msgs.newline() + \"Parameters of the WCS:\" +\n msgs.newline() + \"RA min, max = {0:f}, {1:f}\".format(ra_min, ra_max) +\n msgs.newline() + \"DEC min, max = {0:f}, {1:f}\".format(dec_min, dec_max) +\n msgs.newline() + \"WAVE min, max = {0:f}, {1:f}\".format(wav_min, wav_max) +\n msgs.newline() + \"Spaxel size = {0:f}''\".format(3600.0*dspat) +\n msgs.newline() + \"Wavelength step = {0:f} A\".format(dwv) +\n msgs.newline() + \"-\" * 40)\n\n # Generate the output binning\n if combine:\n numra = int((ra_max-ra_min) * cosdec / dspat)\n numdec = int((dec_max-dec_min)/dspat)\n numwav = int((wav_max-wav_min)/dwv)\n xbins = np.arange(1+numra)-0.5\n ybins = np.arange(1+numdec)-0.5\n spec_bins = np.arange(1+numwav)-0.5\n else:\n slitlength = int(np.round(np.median(slits.get_slitlengths(initial=True, median=True))))\n numwav = int((np.max(waveimg) - wave0) / dwv)\n xbins, ybins, spec_bins = spec.get_datacube_bins(slitlength, minmax, numwav)\n\n # Make the cube\n msgs.info(\"Generating pixel coordinates\")\n if combine:\n pix_coord = masterwcs.wcs_world2pix(all_ra, all_dec, all_wave * 1.0E-10, 0)\n hdr = masterwcs.to_header()\n else:\n pix_coord = wcs.wcs_world2pix(np.vstack((all_ra, all_dec, all_wave*1.0E-10)).T, 0)\n hdr = wcs.to_header()\n\n # Find the NGP coordinates for all input pixels\n msgs.info(\"Generating data cube\")\n bins = (xbins, ybins, spec_bins)\n datacube, edges = np.histogramdd(pix_coord, bins=bins, weights=all_sci*all_wghts)\n norm, edges = np.histogramdd(pix_coord, bins=bins, weights=all_wghts)\n norm_cube = (norm > 0) / (norm + (norm == 0))\n datacube *= norm_cube\n # Create the variance cube, including weights\n msgs.info(\"Generating variance cube\")\n all_var = (all_ivar > 0) / (all_ivar + (all_ivar == 0))\n var_cube, edges = np.histogramdd(pix_coord, bins=bins, weights=all_var * all_wghts**2)\n var_cube *= norm_cube**2\n\n # Save the datacube\n debug = False\n if debug:\n datacube_resid, edges = np.histogramdd(pix_coord, bins=(xbins, ybins, spec_bins), weights=all_sci*np.sqrt(all_ivar))\n norm, edges = np.histogramdd(pix_coord, bins=(xbins, ybins, spec_bins))\n norm_cube = (norm > 0) / (norm + (norm == 0))\n outfile = \"datacube_resid.fits\"\n msgs.info(\"Saving datacube as: {0:s}\".format(outfile))\n hdu = fits.PrimaryHDU((datacube_resid*norm_cube).T, header=masterwcs.to_header())\n hdu.writeto(outfile, overwrite=overwrite)\n\n msgs.info(\"Saving datacube as: {0:s}\".format(outfile))\n final_cube = dc_utils.DataCube(datacube.T, var_cube.T, specname,\n refscale=ref_scale, fluxed=cubepar['flux_calibrate'])\n final_cube.to_file(outfile, hdr=hdr, overwrite=overwrite)\n\n\ndef main(args):\n if args.file is None:\n msgs.error('You must input a coadd3d file')\n else:\n spectrograph_name, config_lines, spec2d_files = io.read_spec2d_file(args.file, filetype=\"coadd3d\")\n spectrograph = load_spectrograph(spectrograph_name)\n\n # Parameters\n spectrograph_def_par = spectrograph.default_pypeit_par()\n parset = par.PypeItPar.from_cfg_lines(cfg_lines=spectrograph_def_par.to_config(),\n merge_with=config_lines)\n # If detector was passed as an argument override whatever was in the coadd3d file\n if args.det is not None:\n msgs.info(\"Restricting to detector={}\".format(args.det))\n parset['rdx']['detnum'] = int(args.det)\n\n # Coadd the files\n coadd_cube(spec2d_files, parset, overwrite=args.overwrite)\n", "meta": {"hexsha": "fc160bcea27c34433d77fd970a778e1b9415f68d", "size": 17834, "ext": "py", "lang": "Python", "max_stars_repo_path": "pypeit/scripts/coadd_datacube.py", "max_stars_repo_name": "NathanSandford/PypeIt", "max_stars_repo_head_hexsha": "89470d27422b7f8662642060b5687a5b2fda27ed", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pypeit/scripts/coadd_datacube.py", "max_issues_repo_name": "NathanSandford/PypeIt", "max_issues_repo_head_hexsha": "89470d27422b7f8662642060b5687a5b2fda27ed", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pypeit/scripts/coadd_datacube.py", "max_forks_repo_name": "NathanSandford/PypeIt", "max_forks_repo_head_hexsha": "89470d27422b7f8662642060b5687a5b2fda27ed", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 49.2651933702, "max_line_length": 147, "alphanum_fraction": 0.6391723674, "include": true, "reason": "import numpy,from astropy", "num_tokens": 4591, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073655352404, "lm_q2_score": 0.3486451217982255, "lm_q1q2_score": 0.19196657202003395}} {"text": "# Lint as: python2, python3\n# Copyright 2020 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Implementation for distributed Shampoo optimizer.\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport functools\nimport lingvo.compat as tf\nfrom lingvo.core import matrix_functions\nfrom lingvo.core import ops as x_ops\nimport numpy as np\n\n# pylint: disable=g-direct-tensorflow-import\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.ops import array_ops\nfrom tensorflow.python.ops import math_ops\nfrom tensorflow.python.ops import state_ops\nfrom tensorflow.python.training import optimizer\n# pylint: enable=g-direct-tensorflow-import\n\n\nclass PartitionConfig(object):\n \"\"\"Config for tensor partitioning.\"\"\"\n\n def __init__(self, max_dim_size, partition_size):\n \"\"\"Initialize the `PartitionConfig`.\n\n Args:\n max_dim_size: Partitions dimensions with size greater than this value.\n partition_size: Size of each partition\n \"\"\"\n self.max_dim_size = max_dim_size\n self.partition_size = partition_size\n\n\nclass PartitionMetadata(object):\n \"\"\"Metadata for partitioning.\"\"\"\n\n def __init__(self, split_sizes_per_dim, num_splits_per_dim):\n \"\"\"Initialize the `PartitionMetadata`.\n\n Args:\n split_sizes_per_dim: Split sizes per dimemsion.\n num_splits_per_dim: Number of splits per dimension ( inferred from\n split_sizes_per_dim).\n \"\"\"\n self.split_sizes_per_dim = split_sizes_per_dim\n self.num_splits_per_dim = num_splits_per_dim\n\n\nclass TensorPartitioner(object):\n \"\"\"Shards Tensor's across its axis.\n\n In cases of TPUs, these partitions are zero cost, and does not involve data\n movement.\n \"\"\"\n\n @classmethod\n def partition_metadata(cls, tensor, partition_info):\n \"\"\"Returns metadata required for partitioning and reforming tensors.\n\n Args:\n tensor: Tensor to partition.\n partition_info: Partitioning info.\n\n Returns:\n split_sizes_per_dim and num_splits_per_dim.\n \"\"\"\n shape = tensor.get_shape()\n # Split if dim is greater than max_dim.\n axis_to_shard = [s > partition_info.max_dim_size for s in shape]\n split_sizes_per_dim = []\n # Compute the number of splits, and the sizes of the splits for\n # each dimension\n for sharded, dim in zip(axis_to_shard, shape):\n dim = int(dim)\n split_sizes_per_dim.append([dim])\n if sharded:\n split_sizes = []\n num_shards = dim // partition_info.partition_size\n if num_shards > 0:\n split_sizes = [partition_info.partition_size] * num_shards\n last_shard_size = dim % partition_info.partition_size\n if last_shard_size > 0:\n split_sizes.append(last_shard_size)\n else:\n split_sizes.append(dim)\n split_sizes_per_dim[-1] = split_sizes\n num_splits_per_dim = [len(v) for v in split_sizes_per_dim]\n return PartitionMetadata(split_sizes_per_dim, num_splits_per_dim)\n\n @classmethod\n def partition_tensor(cls, tensor, partition_info):\n \"\"\"Returns partitioned tensors.\"\"\"\n metadata = (TensorPartitioner.partition_metadata(tensor, partition_info))\n # Split from last to first axis.\n partitioned_tensors = [tensor]\n rank = len(metadata.num_splits_per_dim)\n for raxis, (num_splits, sizes) in enumerate(\n zip(\n reversed(metadata.num_splits_per_dim),\n reversed(metadata.split_sizes_per_dim))):\n if num_splits > 1:\n tmp_partitioned_tensors = []\n for item in partitioned_tensors:\n tmp_partitioned_tensors += tf.split(\n item, sizes, axis=rank - raxis - 1)\n partitioned_tensors = tmp_partitioned_tensors\n return partitioned_tensors\n\n @classmethod\n def reform_tensor(cls, partitioned_tensors, num_splits_per_dim):\n \"\"\"Returns a tensor concatenated from the given partitions.\"\"\"\n # Concatenates tensors across all dimension. Assumes the `partitions` tensor\n # was created by partition_tensor.\n for axis, num_splits in enumerate(num_splits_per_dim):\n if num_splits > 1:\n tmp_partitioned_tensors = []\n num_concat = len(partitioned_tensors) // num_splits\n for i in range(num_concat):\n tensors_to_concat = (\n partitioned_tensors[i * num_splits:(i + 1) * num_splits])\n tmp_partitioned_tensors.append(\n tf.concat(tensors_to_concat, axis=axis))\n partitioned_tensors = tmp_partitioned_tensors\n return partitioned_tensors[0]\n\n\nclass DistributedShampoo(optimizer.Optimizer):\n \"\"\"Approximates full-matrix AdaGrad per layer.\n\n Approximates full-matrix AdaGrad with kronecker-products of two statistics\n matrices based on only the first-order gradients of the layer.\n\n \"Second-order optimization made practical.\", 2019\n Rohan Anil, Vineet Gupta, Tomer Koren, Kevin Regan, Yoram Singer.\n \"\"\"\n\n def __init__(self,\n learning_rate,\n momentum=0.0,\n initial_accumulator_value=0.0,\n start_preconditioning_steps=1000,\n statistics_computation_frequency=1,\n matrix_epsilon=1e-6,\n synchronous_preconditioning=False,\n second_moment_averaging=1.0,\n fallback_to_diagonal_dim=4096,\n max_any_dim=6656,\n block_size=4096,\n block_partition_threshold_size=1000000,\n global_step=None,\n exponent_multiplier=1.0,\n name=\"DistributedShampoo\"):\n \"\"\"Construct a DistributedShampoo optimizer.\n\n Args:\n learning_rate: A `Tensor` or a floating point value. The learning rate.\n momentum: A `Tensor` or a floating point value. Momentum is not applied to\n sparse updates.\n initial_accumulator_value: A floating point value.\n start_preconditioning_steps: A int32 value which indicates when to start\n preconditioning.\n statistics_computation_frequency: A int32 step value which indicates how\n often to compute statistics for preconditioning.\n matrix_epsilon: An epsilon regularizer to make the matrices positive\n definite.\n synchronous_preconditioning: Whether to run preconditioning synchronously.\n second_moment_averaging: 1.0 means sum of gradients squares, while less\n than 1.0 switches to RMSProp style exponential moving averages of the\n second moments.\n fallback_to_diagonal_dim: Fallback to diagonal version of AFMA if the any\n of the dimension is larger than fallback_to_diagonal_dim.\n max_any_dim: If maximum value for any dimension is greater than this value\n we skip preconditioning and fall back to the diagonal.\n block_size: Dimension of the partitioned tensors.\n block_partition_threshold_size: Partitions diemnsions beyond this size.\n global_step: Global step for training.\n exponent_multiplier: A multiplier 'e` for the exponent for the inverse\n calculation. e * -1/(2*rank). Only applies when calculating inverses\n through svd.\n name: Optional name prefix for the operations created when applying\n gradients.\n \"\"\"\n super(DistributedShampoo, self).__init__(False, name)\n self._learning_rate = learning_rate\n self._momentum = momentum\n self._initial_accumulator_value = initial_accumulator_value\n self._start_preconditioning_steps = start_preconditioning_steps\n self._matrix_epsilon = matrix_epsilon\n self._synchronous_preconditioning = synchronous_preconditioning\n self._second_moment_averaging = second_moment_averaging\n self._fallback_to_diagonal_dim = fallback_to_diagonal_dim\n self._max_any_dim = max_any_dim\n self._block_size = block_size\n # NOTE: On XLA - int64 is not handled properly.\n if global_step is not None:\n self._global_step = tf.cast(tf.identity(global_step), tf.int32)\n else:\n self._global_step = tf.cast(\n tf.identity(tf.train.get_or_create_global_step()), tf.int32)\n self._run_nondiagonal_update = tf.greater_equal(\n self._global_step, self._start_preconditioning_steps)\n start_steps_f = tf.cast(self._start_preconditioning_steps, tf.float32)\n global_step_f = tf.cast(self._global_step, tf.float32)\n self._run_nondiagonal_update_warmup = tf.minimum(\n 1.0, tf.maximum((global_step_f - start_steps_f) / start_steps_f, 0.0))\n # Computes statistics every K steps.\n self._statistics_computation_frequency = statistics_computation_frequency\n self._run_statistics_computation = tf.equal(\n tf.math.floormod(self._global_step,\n self._statistics_computation_frequency), 0)\n # All vars that are preconditioned.\n self._all_vars_for_preconditioning = []\n self._exponent_multiplier = exponent_multiplier\n self._partition_info = PartitionConfig(block_partition_threshold_size,\n block_size)\n self._partitioner_metadata = {}\n\n def _fallback_to_diagonal_for_shape(self, shape):\n \"\"\"Returns whether we should fallback to the diagonal update given shape.\"\"\"\n # We fallback to diagonal for the following usecases:\n #\n # (a) Rank <= 1 tensors\n # (b) if any dim of Tensor is > max_any_dim.\n # (c) if all dims are 1 or are greater than fallback_to_diagonal_dim\n #\n if len(shape) <= 1:\n return True\n if any([d > self._max_any_dim for d in shape]):\n return True\n if all([d == 1 for d in shape]):\n return True\n return False\n\n def _preconditioner_available_for_dims(self, shape):\n \"\"\"Returns indicator vector if preconditioner exists for each axis.\"\"\"\n # If any of the dims < fallback_to_diagonal_dim and not 1, we run a\n # a preconditioner for that particular dimension.\n return [d <= self._fallback_to_diagonal_dim and d != 1 for d in shape]\n\n def _preconditioner_indices(self, shape):\n \"\"\"Returns indices of the available preconditioner.\"\"\"\n preconditioners_available_for_dims = (\n self._preconditioner_available_for_dims(shape))\n indices = []\n index = 0\n for is_avail_for_dim_i in preconditioners_available_for_dims:\n indices.append(index)\n if is_avail_for_dim_i:\n index += 1\n return indices\n\n def _make_named_slot(self, var, val, slot_name):\n _ = self._get_or_make_slot(var, val, slot_name,\n self._name + \"_\" + slot_name)\n\n def make_named_zeros_slot(self, var, slot_name):\n self._zeros_slot(var, slot_name, self._name + \"_\" + slot_name)\n\n def _generalized_inverse_pth_root(self, input_t, exponent, epsilon=1e-12):\n input_t_f64 = tf.cast(input_t, tf.float64)\n s, u, v = tf.linalg.svd(\n input_t_f64 +\n tf.eye(tf.shape(input_t_f64)[0], dtype=tf.float64) * epsilon,\n full_matrices=True)\n inv_s = tf.reshape(\n tf.pow(tf.maximum(s, epsilon), tf.cast(exponent, tf.float64)), [1, -1])\n val = tf.matmul(u * inv_s, v, adjoint_b=True)\n return tf.cast(val, tf.float32), tf.reduce_max(tf.abs(u - v))\n\n def _specialized_inverse_pth_root(self, input_t, exponent, epsilon=1e-12):\n input_t_f64 = tf.cast(input_t, tf.float64)\n val, error = matrix_functions.inlined_matrix_inverse_pth_root(\n input_t_f64,\n tf.shape(input_t_f64)[0],\n exponent,\n iter_count=40,\n ridge_epsilon=epsilon)\n return tf.cast(val, tf.float32), error\n\n def _inverse_pth_root_graph(self, epsilon):\n graph = tf.Graph()\n with graph.as_default():\n exponent_t = tf.reshape(\n tf.placeholder(dtype=tf.float32, name=\"exponent\", shape=None), [])\n # Apply exponent multiplier.\n exponent_t = exponent_t * self._exponent_multiplier\n input_t = tf.placeholder(dtype=tf.float32, name=\"input\", shape=None)\n # For p = 2, 4 or 8, we use the iterative Newton-Schur method for\n # computing the inverse-pth root.\n either_p_2_4_8 = tf.math.logical_or(\n tf.math.logical_or(\n tf.equal(-1.0 / exponent_t, 2), tf.equal(-1.0 / exponent_t, 4)),\n tf.equal(-1.0 / exponent_t, 8))\n # 4096 is the larger dimension SVD is tractable for.\n greater_than_4096 = tf.greater(tf.shape(input_t)[0], 4096)\n run_specialized_iterative_method = tf.math.logical_and(\n greater_than_4096, either_p_2_4_8)\n specialized_fn = functools.partial(self._specialized_inverse_pth_root,\n input_t, exponent_t, epsilon)\n generalized_fn = functools.partial(self._generalized_inverse_pth_root,\n input_t, exponent_t, epsilon)\n output, diff = tf.cond(run_specialized_iterative_method, specialized_fn,\n generalized_fn)\n\n tf.identity(output, \"output\")\n tf.identity(tf.cast(diff, tf.float32), \"diff\")\n return graph.as_graph_def().SerializeToString()\n\n def _create_slots(self, var_list):\n self._preconditioner_compute_graphdef = self._inverse_pth_root_graph(\n epsilon=self._matrix_epsilon)\n for v in var_list:\n self._make_named_slot(v,\n tf.ones_like(v) * self._initial_accumulator_value,\n \"accumulator\")\n\n if self._momentum > 0.0:\n self.make_named_zeros_slot(v, \"momentum\")\n shape = np.array(v.get_shape())\n self._partitioner_metadata[v] = TensorPartitioner.partition_metadata(\n v, self._partition_info)\n partitioned_v = TensorPartitioner.partition_tensor(\n v, self._partition_info)\n if not self._fallback_to_diagonal_for_shape(shape):\n self._all_vars_for_preconditioning.append(v)\n if self._momentum > 0.0:\n self.make_named_zeros_slot(v, \"precond_grad_momentum\")\n num_partitions = len(partitioned_v)\n for pt_idx, pt_v in enumerate(partitioned_v):\n pt_v_shape = pt_v.get_shape()\n preconditioner_exists_for_dim = (\n self._preconditioner_available_for_dims(pt_v_shape))\n for i, d in enumerate(pt_v_shape):\n if preconditioner_exists_for_dim[i]:\n mat_stat_init = array_ops.zeros([d, d], dtype=pt_v.dtype)\n self._make_named_slot(\n v, mat_stat_init,\n self._statistics_key_for_partition_and_dim(\n i, pt_idx, num_partitions))\n self._make_named_slot(\n v, mat_stat_init,\n self._preconditioner_key_for_partition_and_dim(\n i, pt_idx, num_partitions))\n\n def _prepare(self):\n learning_rate = self._call_if_callable(self._learning_rate)\n self._learning_rate_tensor = ops.convert_to_tensor(\n learning_rate, name=\"learning_rate\")\n momentum = self._call_if_callable(self._momentum)\n self._momentum_tensor = ops.convert_to_tensor(momentum, name=\"momentum\")\n\n def invoke_async_preconditioner_computation(self, global_step_int32):\n \"\"\"Invokes SVD preconditioner and graph runs on the CPU.\"\"\"\n keys_stats_and_rank = []\n for var in self._all_vars_for_preconditioning:\n shape = var.get_shape()\n if not self._fallback_to_diagonal_for_shape(shape):\n partitioned_v = TensorPartitioner.partition_tensor(\n var, self._partition_info)\n num_partitions = len(partitioned_v)\n for pt_idx, pt_v in enumerate(partitioned_v):\n pt_v_shape = pt_v.get_shape()\n preconditioner_exists_for_dim = (\n self._preconditioner_available_for_dims(pt_v_shape))\n for i in range(len(pt_v_shape)):\n if preconditioner_exists_for_dim[i]:\n rank = sum(preconditioner_exists_for_dim)\n key = self._key_for_var(var, i, pt_idx)\n stat = self.get_slot(\n var,\n self._statistics_key_for_partition_and_dim(\n i, pt_idx, num_partitions))\n keys_stats_and_rank.append((key, stat, rank))\n\n if not keys_stats_and_rank:\n return tf.no_op()\n keys, stats, ranks = zip(*keys_stats_and_rank)\n\n return x_ops.compute_preconditioners(\n stats, [-1.0 / (2.0 * r) for r in ranks],\n global_step_int32,\n keys=keys,\n sync=self._synchronous_preconditioning,\n preconditioner_compute_graphdef=self._preconditioner_compute_graphdef)\n\n def assign_preconditioner_to_host_vars(self):\n \"\"\"Assign/Grab latest copy of preconditioners.\"\"\"\n keys_shapes_and_preconditioner_vars = []\n assign_ops = []\n for var in self._all_vars_for_preconditioning:\n shape = var.get_shape()\n if not self._fallback_to_diagonal_for_shape(shape):\n partitioned_v = TensorPartitioner.partition_tensor(\n var, self._partition_info)\n num_partitions = len(partitioned_v)\n for pt_idx, pt in enumerate(partitioned_v):\n pt_shape = pt.get_shape()\n preconditioner_exists_for_dim = (\n self._preconditioner_available_for_dims(pt_shape))\n var_rank = len(pt_shape)\n for i in range(var_rank):\n if preconditioner_exists_for_dim[i]:\n key = self._key_for_var(var, i, pt_idx)\n preconditioner = self.get_slot(\n var,\n self._preconditioner_key_for_partition_and_dim(\n i, pt_idx, num_partitions))\n keys_shapes_and_preconditioner_vars.append(\n (key, tf.shape(preconditioner), preconditioner))\n\n if not keys_shapes_and_preconditioner_vars:\n return tf.no_op()\n\n keys, shapes, preconditioner_vars = zip(\n *keys_shapes_and_preconditioner_vars)\n\n preconditioner_vals, successes = x_ops.get_preconditioners(\n shapes,\n keys=keys,\n preconditioner_compute_graphdef=(\n self._preconditioner_compute_graphdef))\n\n for preconditioner_var, preconditioner_val, success in zip(\n preconditioner_vars, preconditioner_vals, successes):\n success_mult = tf.cast(success, preconditioner.dtype)\n assign_ops.append(\n state_ops.assign(preconditioner_var,\n (1.0 - success_mult) * preconditioner_var +\n success_mult * preconditioner_val))\n return tf.group(*assign_ops)\n\n def _statistics_key_for_partition_and_dim(self, dim_index, partition_index,\n num_partitions):\n if num_partitions == 1:\n return \"mat_statistics_\" + str(dim_index)\n else:\n return str(partition_index) + \"_mat_statistics_\" + str(dim_index)\n\n def _preconditioner_key_for_partition_and_dim(self, dim_index,\n partition_index,\n num_partitions):\n if num_partitions == 1:\n return \"mat_preconditioner_\" + str(dim_index)\n else:\n return str(partition_index) + \"_mat_preconditioner_\" + str(dim_index)\n\n def _key_for_var(self, var, dim_index, partition_index):\n return \"P_\" + str(partition_index) + \"_D_\" + str(dim_index) + \"_\" + var.name\n\n def _updated_statistics(self, var, partitioned_grads):\n \"\"\"Returns updated Shampoo statistics L_t, R_t, etc.\n\n Args:\n var: tf.Variable associated with the gradient.\n partitioned_grads: Partitioned gradient tensor.\n\n Returns:\n A list of updated statistics matrices.\n \"\"\"\n precond_statistics_update = []\n num_partitions = len(partitioned_grads)\n mat_stats = []\n mat_grads = []\n mat_dims = []\n for pt_idx, pt_grad in enumerate(partitioned_grads):\n pt_shape = pt_grad.get_shape()\n preconditioner_exists_for_dim = (\n self._preconditioner_available_for_dims(pt_shape))\n rank = len(pt_shape)\n # Calculates the preconditioner statistics for each tensor.\n for i in range(rank):\n if preconditioner_exists_for_dim[i]:\n mat_stats.append(\n self.get_slot(\n var,\n self._statistics_key_for_partition_and_dim(\n i, pt_idx, num_partitions)))\n mat_grads.append(pt_grad)\n mat_dims.append(i)\n\n # axes is the list of indices to reduce - everything but\n # the current i.\n def _update_statistics(dim, stat_var, grad):\n \"\"\"Update preconditioner statistics.\"\"\"\n with tf.variable_scope(\"GradientStatistics\"):\n var_rank = len(grad.get_shape())\n axes = list(range(dim)) + list(range(dim + 1, var_rank))\n new_stat = math_ops.tensordot(grad, grad, axes=(axes, axes))\n if self._second_moment_averaging == 1.0:\n updated_stat = state_ops.assign_add(stat_var, new_stat)\n else:\n updated_stat = state_ops.assign_add(\n stat_var, (self._second_moment_averaging - 1.0) * stat_var +\n (1.0 - self._second_moment_averaging) * new_stat)\n return updated_stat\n\n if self._statistics_computation_frequency <= 1:\n for mat_stat, mat_grad, dim in zip(mat_stats, mat_grads, mat_dims):\n precond_statistics_update.append(\n _update_statistics(dim, mat_stat, mat_grad))\n else:\n\n # NOTE: We rewrite tf.cond() as a while loop to avoid certain overheads\n # in XLA from buffer allocation.\n def _loop_body(mat_stats, mat_grads, mat_dims, unused_perform_step):\n precond_statistics_update_ops = []\n for mat_stat, mat_grad, dim in zip(mat_stats, mat_grads, mat_dims):\n precond_statistics_update_ops.append(\n _update_statistics(dim, mat_stat, mat_grad))\n with tf.control_dependencies(precond_statistics_update_ops):\n return tf.constant(False)\n\n loop_body_fn = functools.partial(_loop_body, mat_stats, mat_grads,\n mat_dims)\n precond_statistics_update.append(\n tf.while_loop(lambda perform_step: perform_step, loop_body_fn,\n [self._run_statistics_computation]))\n\n return precond_statistics_update\n\n def _compute_preconditioned_raw_grad(self, var, partitioned_grads):\n \"\"\"Returns preconditioned gradient.\n\n Args:\n var: tf.Variable associated with the gradient.\n partitioned_grads: Partitioned gradient tensor.\n\n Returns:\n A preconditioned gradient tensor.\n \"\"\"\n\n partitioned_preconditioned_grads = []\n num_partitions = len(partitioned_grads)\n for pt_idx, pt_grad in enumerate(partitioned_grads):\n pt_shape = pt_grad.get_shape()\n rank = len(pt_shape)\n preconditioner_exists_for_dim = (\n self._preconditioner_available_for_dims(pt_shape))\n preconditioner_indices = self._preconditioner_indices(pt_shape)\n mat_preconditioner_list = []\n for i in range(rank):\n if preconditioner_exists_for_dim[i]:\n mat_preconditioner_list.append(\n self.get_slot(\n var,\n self._preconditioner_key_for_partition_and_dim(\n i, pt_idx, num_partitions)))\n precond_grad = pt_grad\n if rank == 2 and all(preconditioner_exists_for_dim):\n # Fast path for speedup.\n precond_grad = tf.matmul(\n tf.matmul(mat_preconditioner_list[0], precond_grad),\n mat_preconditioner_list[1])\n else:\n for i in range(rank):\n if preconditioner_exists_for_dim[i]:\n precond_grad = tf.tensordot(\n precond_grad,\n mat_preconditioner_list[preconditioner_indices[i]],\n axes=([0], [0]))\n else:\n # if preconditioner is not available we transpose it to\n # permute the axis for the next preconditioner.\n precond_grad = tf.transpose(\n precond_grad, perm=list(range(1, rank)) + [0])\n partitioned_preconditioned_grads.append(precond_grad)\n return TensorPartitioner.reform_tensor(\n partitioned_preconditioned_grads,\n self._partitioner_metadata[var].num_splits_per_dim)\n\n def _preconditioned_update(self, var, partitioned_grads,\n diagonal_grad_update):\n \"\"\"Computes the matrix preconditioned update.\n\n Args:\n var: Variable for which we are computing the preconditioned gradient.\n partitioned_grads: Partitioned gradients.\n diagonal_grad_update: Update as given by diagonal adagrad.\n\n Returns:\n scaled preconditioned gradient.\n \"\"\"\n\n def _l2_norm(v):\n return tf.sqrt(tf.reduce_sum(tf.square(v)))\n\n precond_grad = self._compute_preconditioned_raw_grad(var, partitioned_grads)\n if self._momentum > 0.0:\n gbar = self.get_slot(var, \"precond_grad_momentum\")\n matrix_preconditioned_grad = state_ops.assign(\n gbar, gbar * self._momentum_tensor + precond_grad *\n (1.0 - self._momentum_tensor))\n else:\n matrix_preconditioned_grad = precond_grad\n\n # We use the direction from Shampoo while using the step size scale from\n # diagonal AdaGrad.\n precond_l2_norm = _l2_norm(matrix_preconditioned_grad)\n diagonal_l2_norm = _l2_norm(diagonal_grad_update)\n multiplier = tf.where(\n tf.greater(precond_l2_norm, 0.0),\n tf.maximum(diagonal_l2_norm, 1e-30) /\n (tf.maximum(precond_l2_norm, 1e-30)), 1.0)\n return matrix_preconditioned_grad * multiplier\n\n def _apply_dense(self, grad, var):\n # Calculates the preconditioner statistics for each tensor.\n partitioned_grads = TensorPartitioner.partition_tensor(\n grad, self._partition_info)\n shape = var.get_shape()\n fallback_to_diagonal = self._fallback_to_diagonal_for_shape(shape)\n\n precond_statistics_update = []\n if not fallback_to_diagonal:\n precond_statistics_update = self._updated_statistics(\n var, partitioned_grads)\n\n accumulator = self.get_slot(var, \"accumulator\")\n accumulator_updated = state_ops.assign_add(accumulator, grad * grad)\n accumulator_inv_sqrt = math_ops.rsqrt(accumulator_updated + 1e-30)\n if self._momentum > 0.0:\n scaled_g = (1.0 - self._momentum_tensor) * (grad * accumulator_inv_sqrt)\n gbar = self.get_slot(var, \"momentum\")\n gbar_updated = state_ops.assign_add(\n gbar,\n gbar * (self._momentum_tensor - 1.0) + scaled_g)\n else:\n gbar_updated = (grad * accumulator_inv_sqrt)\n\n if not fallback_to_diagonal:\n # Update the preconditioner statistics followed by computing the\n # preconditioned gradient.\n with ops.control_dependencies(precond_statistics_update):\n s = tf.cast(self._run_nondiagonal_update, tf.float32)\n preconditioned_grad = self._preconditioned_update(\n var, partitioned_grads, gbar_updated)\n # slowly adapt from diagonal to preconditioned gradient.\n w = self._run_nondiagonal_update_warmup\n warmup_update = s * self._learning_rate_tensor * (\n w * preconditioned_grad + (1.0 - w) * gbar_updated)\n fallback_update = (1 - s) * (self._learning_rate_tensor * gbar_updated)\n return state_ops.assign_sub(var, warmup_update + fallback_update)\n else:\n return state_ops.assign_sub(var,\n self._learning_rate_tensor * gbar_updated)\n\n def _resource_apply_dense(self, grad, var):\n return self._apply_dense(grad, var)\n\n # Sparse gradients are not handled currently and is part of future work.\n def _resource_apply_sparse(self, grad_values, var, grad_indices):\n return tf.no_op()\n\n def _apply_sparse(self, grad, var):\n return tf.no_op()\n", "meta": {"hexsha": "ed6b64ff4a0c506ac18bdad5dabb28205bc754ec", "size": 27983, "ext": "py", "lang": "Python", "max_stars_repo_path": "lingvo/core/distributed_shampoo.py", "max_stars_repo_name": "Singed-jj/lingvo", "max_stars_repo_head_hexsha": "a2a4ac8bd835ffc2f95fc38ee3e9bc17c30fcc56", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lingvo/core/distributed_shampoo.py", "max_issues_repo_name": "Singed-jj/lingvo", "max_issues_repo_head_hexsha": "a2a4ac8bd835ffc2f95fc38ee3e9bc17c30fcc56", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lingvo/core/distributed_shampoo.py", "max_forks_repo_name": "Singed-jj/lingvo", "max_forks_repo_head_hexsha": "a2a4ac8bd835ffc2f95fc38ee3e9bc17c30fcc56", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.6413690476, "max_line_length": 80, "alphanum_fraction": 0.6791266126, "include": true, "reason": "import numpy", "num_tokens": 6278, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5736784220301065, "lm_q2_score": 0.334589441253186, "lm_q1q2_score": 0.1919467426860628}} {"text": "# -*- coding: utf-8 -*-\n\"\"\"\nThis provides the basis for torque computation via two additional\nclasses: TorqueMap which has data for a torque derivation and \nGalacticTorque which derives from GalacticDisc and contains the torque\nmaps.\n\"\"\"\nimport numpy as np\n\n__author__ = \"Eric Emsellem\"\n__copyright__ = \"Eric Emsellem\"\n__license__ = \"mit\"\n\nfrom .disc import GalacticDisc\nfrom .misc_io import add_suffix, AttrDict, guess_stepx\nfrom .transform import extract_radial_profile_fromXY\nfrom .maps_grammar import remap_suffix, _is_flag_density\nfrom .local_units import km_pc\nfrom . import fit_functions as ff\nfrom . import gravpot_functions as gpot\n\nclass TorqueMap(object):\n \"\"\"Main map class for the torques\n \"\"\"\n def __init__(self, massmap, mass_dname, comp_dname,\n velprof, vel_dname, pc_per_xyunit=1.0, PAnodes=0.0,\n factor_hz=12.0):\n \"\"\"\n \"\"\"\n self.massmap = massmap\n self.mass_dname = mass_dname\n self.comp_dname = comp_dname\n self.velprof = velprof\n self.vel_dname = vel_dname\n self.factor_hz = factor_hz\n\n self.dmass = self.massmap.dmaps[self.mass_dname]\n self.dcomp = self.massmap.dmaps[self.comp_dname]\n self.dvel = self.velprof.dprofiles[self.vel_dname]\n self.pc_per_xyunit = pc_per_xyunit\n\n # Check the coordinates\n self.Xdep = self.massmap.X_londep\n self.Ydep = self.massmap.Y_londep\n self.Rdep = np.sqrt(self.Xdep**2 + self.Ydep**2)\n self.Xdep_pc = self.Xdep * self.pc_per_xyunit\n self.Ydep_pc = self.Ydep * self.pc_per_xyunit\n self.Rdep_pc = self.Rdep * self.pc_per_xyunit\n self.pc_per_x = guess_stepx(self.Xdep_pc)\n self.pc_per_y = guess_stepx(self.Ydep_pc)\n\n # We also need a maximised X and Y grid to help with the kernel\n self.Xdep_pcexp, self.Ydep_pcexp = self.get_XYpcexp()\n self.Rdep_pcexp = np.sqrt(self.Xdep_pcexp**2 + self.Ydep_pcexp**2)\n\n # Using the average between the x and y step in parsec\n self.pc_per_pixel = (self.pc_per_x + self.pc_per_y) / 2.\n self.PAnodes = PAnodes\n\n @property\n def XY_extent(self):\n \"\"\"Provide the extent - a la matplotlib - for\n the given map grid\n \"\"\"\n return [np.min(self.Xdep), np.max(self.Xdep),\n np.min(self.Ydep), np.max(self.Ydep)]\n\n @property\n def XYpc_extent(self):\n \"\"\"Provide the extent in parsec - a la matplotlib - for\n the given map grid\n \"\"\"\n return [np.min(self.Xdep_pc), np.max(self.Xdep_pc),\n np.min(self.Ydep_pc), np.max(self.Ydep_pc)]\n\n def get_XYpcexp(self):\n \"\"\"Provided an expanded grid for X and Y\n which will be used later for the kernel convolution\n \"\"\"\n maxXpc = np.max(np.abs(self.Xdep_pc))\n maxYpc = np.max(np.abs(self.Ydep_pc))\n maxX = np.max(np.abs(self.Xdep_pc))\n stepX = self.Xdep_pc[0,1] - self.Xdep_pc[0,0]\n stepY = self.Ydep_pc[1,0] - self.Ydep_pc[0,0]\n npixX = np.int(maxXpc // stepX) + 1\n npixY = np.int(maxYpc // stepY) + 1\n nmaxXpc = npixX * stepX\n nmaxYpc = npixY * stepY\n xlin = np.linspace(-nmaxXpc, nmaxXpc, npixX * 2 + 1)\n ylin = np.linspace(-nmaxYpc, nmaxYpc, npixY * 2 + 1)\n eX, eY = np.meshgrid(xlin, ylin)\n return eX, eY\n\n def get_mass_profile(self, wedge_size=0.0, wedge_angle=0):\n \"\"\"Compute the 1d mass profile using the dmass.data\n and a number of bins. A wedge-angle and size can be used to indicate\n where to extract the data. Uses the extract_radial_profile_fromXY\n function.\n\n Input\n -----\n wedge_size (float): size of the wedge in degrees [0]\n wedge_angle (float): angle of the central wedge (in degrees) [0]\n\n Creates\n -------\n self.Rmass1d and self.mass1d following the deprojected grid Xdep, Ydep\n and the dmass.data map.\n \"\"\"\n self.Rmass1d, self.mass1d = extract_radial_profile_fromXY(self.Xdep, self.Ydep,\n self.dmass.data,\n nbins=None, verbose=True,\n wedge_size=wedge_size, \n wedge_angle=wedge_angle)\n\n def fit_mass_profile(self):\n \"\"\"Fit the 1d mass profile\n \"\"\"\n self.opt_mass, self.fsphe1d, self.fdisc1d, self.fmass1d = ff.fit_disc_sphe(self.Rmass1d, self.mass1d)\n self.bfit_mass1d = self.fmass1d(self.Rmass1d, self.opt_mass[0])\n self.bfit_mass1d_sphe = self.fsphe1d(self.Rmass1d, self.opt_mass[0])\n self.bfit_mass1d_disc = self.fdisc1d(self.Rmass1d, self.opt_mass[0])\n self.bfit_sphe1d = self.fsphe1d(self.massmap._R, self.opt_mass[0])\n self.bfit_sphe1d_dep = self.fsphe1d(self.Rdep, self.opt_mass[0])\n self.massmap.faceon = self.dmass.data - self.bfit_sphe1d_dep + self.bfit_sphe1d\n self.Rl_disc = self.opt_mass[0][3]\n\n def get_kernel(self, softening=0.0, function=\"sech2\"):\n \"\"\"Get the kernel array\n \"\"\"\n hz_pc = self.Rl_disc * self.pc_per_xyunit / self.factor_hz\n self.kernel = gpot.get_gravpot_kernel(self.Rdep_pcexp, hz_pc,\n pc_per_pixel=self.pc_per_pixel,\n softening=softening,\n function=function)\n\n def get_gravpot(self):\n \"\"\"Calculate the gravitational potential\n \"\"\"\n self.gravpot = gpot.get_potential(self.massmap.faceon \n * self.pc_per_x * self.pc_per_y, \n self.kernel)\n\n def get_forces(self):\n \"\"\"Calculate the forces from the potential\n Units should be in km^2.s^-2.pc^-2\n \"\"\"\n self.Fgrad, self.Fx, self.Fy, self.Frad, self.Ftan = \\\n gpot.get_forces(self.Xdep_pc, self.Ydep_pc,\n self.gravpot, self.PAnodes)\n\n def get_vrot_from_forces(self):\n \"\"\"Calculate the velocities from forces\n \"\"\"\n self.VcU = gpot.get_vrot_from_force(self.Rdep_pc, self.Frad)\n\n def get_torque_map(self):\n \"\"\"Compute the torque map\n\n Units back are units of X * F (hence pc * F)\n Since F is in (km/s)^2 pc-1 -> torque in (km/s)^2\n \"\"\"\n self.torque_map = gpot.get_torque(self.Xdep_pc, self.Ydep_pc,\n self.Fx, self.Fy)\n\n def get_weighted_torque_map(self):\n \"\"\"Compute the torque map\n \"\"\"\n self.torque_w_map = gpot.get_weighted_torque(self.Xdep_pc, self.Ydep_pc,\n self.Fx, self.Fy, self.dcomp.data)\n\n def get_torque_profiles(self, n_rbins=300):\n \"\"\"Get the profiles from the torque\n \"\"\"\n self.r_mean, self.v_mean, self.torque_mean, self.torque_mean_w, \\\n self.ang_mom_mean, self.dm, self.dm_sum = \\\n gpot.get_torque_profiles(self.Xdep_pc, self.Ydep_pc, self.VcU,\n self.Fx, self.Fy, self.dcomp.data,\n n_rbins=n_rbins, pc_per_pixel=self.pc_per_pixel)\n # T in s\n self.Trot = 2. * np.pi * self.r_mean * km_pc / self.v_mean\n # dloL adimensional\n self.dloL = self.torque_mean_w * self.Trot / self.ang_mom_mean\n\n def get_torques(self, n_rbins=300):\n \"\"\"Calculate the torques from existing forces\n\n Args:\n n_rbins:\n \"\"\"\n self.get_torque_map()\n self.get_weighted_torque_map()\n self.get_torque_profiles(n_rbins=n_rbins)\n\n def run_torques(self, softening=0.0, func_kernel=\"sech2\", n_rbins=200):\n \"\"\"Running the torque calculation from start to end\n\n Args:\n softening:\n func_kernel:\n n_rbins:\n\n \"\"\"\n # Step 1 - extract the radial profile and fit it with bulge and disc\n self.get_mass_profile()\n\n # Step 2 - Now doing the fit of the spheroid (and disc)\n self.fit_mass_profile()\n\n # Step 3 - calculate the kernel\n self.get_kernel(softening=softening, function=func_kernel)\n\n # Step 4 - calculate the potential\n self.get_gravpot()\n\n # Step 5 - Calculate the forces\n self.get_forces()\n\n # Step 6 - Get the rotation velocities\n self.get_vrot_from_forces()\n\n # Step 7 - Normalise the fields with M/L\n # For the moment = passed\n\n # Step 8 - Calculate the torques\n self.get_torques(n_rbins=n_rbins)\n\n\nclass GalacticTorque(GalacticDisc):\n \"\"\"Class for functionalities associated with Torques\n \"\"\"\n\n def __init__(self, vcfile_name=None, vcfile_type=\"ROTCUR\",\n Rfinestep=0, vprof_name=\"Velocity\", **kwargs):\n \"\"\"\n\n Args:\n vcfile_name:\n vcfile_type:\n **kwargs:\n \"\"\"\n self.verbose = kwargs.pop(\"verbose\", False)\n\n # Using GalacticDisc class attributes\n super().__init__(**kwargs)\n\n # Now the velocity file\n if vcfile_name is not None:\n print(\"INFO: Adding the provided Vc file\")\n velname = self.add_vprofile(filename=vcfile_name, filetype=vcfile_type,\n Rfinestep=Rfinestep, vprof_name=vprof_name)\n else:\n velname = kwargs.pop(\"velname\", \"vel_vel01\")\n\n # And checking the maps\n compname = kwargs.pop(\"compname\", \"comp_comp01\")\n massname = kwargs.pop(\"massname\", \"mass_mass01\")\n self.init_torque_components(velname=velname, compname=compname,\n massname=massname)\n\n # Make sure we start with a clean set of torque maps\n self._reset_torquemaps()\n\n\n @property\n def velname(self):\n return self.profiles[self.vel_pname]._fullname(self.vel_dname)\n\n @property\n def massname(self):\n return self.maps[self.mass_mname]._fullname(self.mass_dname)\n\n @property\n def compname(self):\n return self.maps[self.comp_mname]._fullname(self.comp_dname)\n\n def init_torque_components(self, **kwargs):\n \"\"\"Initialise the torque maps components\n\n Args:\n **kwargs: velname, compname, massname\n\n \"\"\"\n self._decode_torque_names(**kwargs)\n self.check_torque_components()\n if self._check_all:\n self.match_comp_mass()\n\n def _decode_torque_names(self, velname=None, compname=None, massname=None):\n \"\"\"\n\n Args:\n velname (str): composite name for the velocity profile\n compname (str): composite name for the component map\n massname (str): composite name for the mass map\n\n \"\"\"\n # Decoding the names\n self.vel_pname, self.vel_dname = self._decode_prof_name(velname)\n self.comp_mname, self.comp_dname = self._decode_map_name(compname)\n self.mass_mname, self.mass_dname = self._decode_map_name(massname)\n\n def check_torque_components(self):\n \"\"\"Find the components for the torque calculations using the composite\n names for the velocities, component (e.g., gas flux) and mass.\n\n \"\"\"\n # Checking the maps and profiles\n # And making sure they are density maps\n if self._check_mass():\n thismap = self.massmap\n if not _is_flag_density(self.massdmap.flag):\n self.mass_dname = thismap.intmap_to_densitymap(self.mass_dname, self)\n\n if self._check_comp():\n thismap = self.compmap\n if not _is_flag_density(self.compdmap.flag):\n self.comp_dname = thismap.intmap_to_densitymap(self.comp_dname, self)\n\n @property\n def veldprof(self):\n return self.profiles[self.vel_pname].dprofiles[self.vel_dname]\n\n @property\n def velprof(self):\n return self.profiles[self.vel_pname]\n\n @property\n def compdmap(self):\n return self.maps[self.comp_mname].dmaps[self.comp_dname]\n\n @property\n def compmap(self):\n return self.maps[self.comp_mname]\n\n @property\n def massdmap(self):\n return self.maps[self.mass_mname].dmaps[self.mass_dname]\n\n @property\n def massmap(self):\n return self.maps[self.mass_mname]\n\n @property\n def _matched(self):\n return (self.mass_mname == self.comp_mname)\n\n @property\n def _check_all(self):\n return all((self._check_comp(), self._check_mass(), self._check_vel()))\n\n def _check_vel(self):\n return self._has_profile_data(self.vel_pname, self.vel_dname,\n order=1)\n\n def _check_comp(self):\n return self._has_map_data(self.comp_mname, self.comp_dname,\n order=0)\n\n def _check_mass(self):\n return self._has_map_data(self.mass_mname, self.mass_dname,\n order=0)\n\n def _reset_torquemaps(self):\n \"\"\"Initalise the torquemap Profiles by setting an empty\n 'torquemaps' dictionary\n \"\"\"\n # set up the torquemaps\n self.tmaps = AttrDict()\n\n @property\n def ntorquemaps(self):\n \"\"\"Number of existing torquemap profiles\n \"\"\"\n if hasattr(self, 'tmaps'):\n return len(self.tmaps)\n else:\n return -1\n\n def match_comp_mass(self, odname1=\"dmass\", odname2=\"dcomp\", **kwargs):\n \"\"\"Aligning the gas onto the mass map\n \"\"\"\n if not self._check_all:\n print(\"WARNING[match_comp_mass]: cannot proceed with match \"\n \"as all maps are not yet set up. Please check\")\n return\n\n if not self._matched:\n match_name = self.match_datamaps(self.mass_mname, self.comp_mname,\n self.mass_dname, self.comp_dname,\n odname1, odname2)\n print(\"INFO[match_comp_mass]: new map is {}\".format(match_name))\n self.mass_mname = match_name\n self.comp_mname = match_name\n self.mass_dname = odname1\n self.comp_dname = odname2\n self.deproject_nodes(match_name)\n else:\n print(\"WARNING[match_comp_mass]: nothing to match as the data are \"\n \"associated with the same map {}\".format(self.mass_mname))\n\n def run_torques(self, torquemap_name=None, softening=0, func_kernel=\"sech2\",\n n_rbins=200, **kwargs):\n \"\"\"Running the torques recipes\n\n Args:\n gas_name:\n mass_name:\n vel_name:\n torquemap_name:\n\n Returns:\n\n \"\"\"\n if torquemap_name is None:\n torquemap_name = \"Torq{0:02d}\".format(self.ntorquemaps+1)\n\n # Step 0 - finding the gas, mass and vel if not defined\n # and match the maps\n if not self._check_all:\n # Try to read the maps\n velname = kwargs.pop(\"velname\", self.velname)\n compname = kwargs.pop(\"compname\", self.compname)\n massname = kwargs.pop(\"massname\", self.massname)\n self.init_torque_components(velname=velname, compname=compname,\n massname=massname)\n\n pc_per_xy = self.pc_per_xyunit(self.massmap.XYunit)\n\n # Defining the structure in which the torques will be calculated\n # Note that PAnodes is now -90 as we put the nodes along the X axis - horizontal\n # During the matching\n newT = TorqueMap(self.massmap, self.mass_dname, self.comp_dname,\n self.velprof, self.vel_dname, pc_per_xyunit=pc_per_xy,\n PAnodes=-90.0)\n\n # Running the torque calculation\n newT.run_torques(softening=softening, n_rbins=n_rbins,\n func_kernel=func_kernel)\n\n # Now allocating it to the torquemaps\n self.tmaps[torquemap_name] = newT\n", "meta": {"hexsha": "ec63d45214321b570248a40f79fa588c5aa3a0c6", "size": 16071, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/pydisc/torques.py", "max_stars_repo_name": "emsellem/pydisc", "max_stars_repo_head_hexsha": "a8737b6c84d150774612f50e6607fd0dcfe6e677", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/pydisc/torques.py", "max_issues_repo_name": "emsellem/pydisc", "max_issues_repo_head_hexsha": "a8737b6c84d150774612f50e6607fd0dcfe6e677", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/pydisc/torques.py", "max_forks_repo_name": "emsellem/pydisc", "max_forks_repo_head_hexsha": "a8737b6c84d150774612f50e6607fd0dcfe6e677", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.2776523702, "max_line_length": 109, "alphanum_fraction": 0.5943002925, "include": true, "reason": "import numpy", "num_tokens": 3963, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5736784074525096, "lm_q2_score": 0.334589441253186, "lm_q1q2_score": 0.1919467378085528}} {"text": "# -*- coding: UTF-8 -*-\n# !/usr/bin/python\n# @time :2019/8/31 21:33\n# @author :Mo\n# @function :topic model of LDA\n# @paper :Latent Dirichlet Allocation\n\n\nfrom nlg_yongzhuo.data_preprocess.text_preprocess import extract_chinese\nfrom nlg_yongzhuo.data_preprocess.text_preprocess import cut_sentence\nfrom nlg_yongzhuo.data_preprocess.text_preprocess import jieba_cut\nfrom nlg_yongzhuo.data.stop_words.stop_words import stop_words\n# sklearn\nfrom sklearn.feature_extraction.text import CountVectorizer\nfrom sklearn.decomposition import LatentDirichletAllocation\nimport numpy as np\n\nclass LDASum:\n def __init__(self):\n self.stop_words = stop_words.values()\n self.algorithm = 'lda'\n\n def summarize(self, text, num=8, topic_min=6, judge_topic=None):\n \"\"\"\n\n :param text: str\n :param num: int\n :return: list\n \"\"\"\n # 切句\n if type(text) == str:\n self.sentences = cut_sentence(text)\n elif type(text) == list:\n self.sentences = text\n else:\n raise RuntimeError(\"text type must be list or str\")\n len_sentences_cut = len(self.sentences)\n # 切词\n sentences_cut = [[word for word in jieba_cut(extract_chinese(sentence))\n if word.strip()] for sentence in self.sentences]\n # 去除停用词等\n self.sentences_cut = [list(filter(lambda x: x not in self.stop_words, sc)) for sc in sentences_cut]\n self.sentences_cut = [\" \".join(sc) for sc in self.sentences_cut]\n # 计算每个句子的tf\n vector_c = CountVectorizer(ngram_range=(1, 2), stop_words=self.stop_words)\n tf_ngram = vector_c.fit_transform(self.sentences_cut)\n # 主题数, 经验判断\n topic_num = min(topic_min, int(len(sentences_cut) / 2)) # 设定最小主题数为3\n lda = LatentDirichletAllocation(n_components=topic_num, max_iter=32,\n learning_method='online',\n learning_offset=50.,\n random_state=2019)\n res_lda_u = lda.fit_transform(tf_ngram.T)\n res_lda_v = lda.components_\n\n if judge_topic:\n ### 方案一, 获取最大那个主题的k个句子\n ##################################################################################\n topic_t_score = np.sum(res_lda_v, axis=-1)\n # 对每列(一个句子topic_num个主题),得分进行排序,0为最大\n res_nmf_h_soft = res_lda_v.argsort(axis=0)[-topic_num:][::-1]\n # 统计为最大每个主题的句子个数\n exist = (res_nmf_h_soft <= 0) * 1.0\n factor = np.ones(res_nmf_h_soft.shape[1])\n topic_t_count = np.dot(exist, factor)\n # 标准化\n topic_t_count /= np.sum(topic_t_count, axis=-1)\n topic_t_score /= np.sum(topic_t_score, axis=-1)\n # 主题最大个数占比, 与主题总得分占比选择最大的主题\n topic_t_tc = topic_t_count + topic_t_score\n topic_t_tc_argmax = np.argmax(topic_t_tc)\n # 最后得分选择该最大主题的\n res_nmf_h_soft_argmax = res_lda_v[topic_t_tc_argmax].tolist()\n res_combine = {}\n for l in range(len_sentences_cut):\n res_combine[self.sentences[l]] = res_nmf_h_soft_argmax[l]\n score_sen = [(rc[1], rc[0]) for rc in sorted(res_combine.items(), key=lambda d: d[1], reverse=True)]\n #####################################################################################\n else:\n ### 方案二, 获取最大主题概率的句子, 不分主题\n res_combine = {}\n for i in range(len_sentences_cut):\n res_row_i = res_lda_v[:, i]\n res_row_i_argmax = np.argmax(res_row_i)\n res_combine[self.sentences[i]] = res_row_i[res_row_i_argmax]\n score_sen = [(rc[1], rc[0]) for rc in sorted(res_combine.items(), key=lambda d: d[1], reverse=True)]\n num_min = min(num, len(self.sentences))\n return score_sen[0:num_min]\n\n\nif __name__ == '__main__':\n lda = LDASum()\n doc = \"多知网5月26日消息，今日，方直科技发公告，拟用自有资金人民币1.2亿元，\" \\\n \"与深圳嘉道谷投资管理有限公司、深圳嘉道功程股权投资基金（有限合伙）共同发起设立嘉道方直教育产业投资基金（暂定名）。\" \\\n \"该基金认缴出资总规模为人民币3.01亿元。\" \\\n \"基金的出资方式具体如下：出资进度方面，基金合伙人的出资应于基金成立之日起四年内分四期缴足，每期缴付7525万元；\" \\\n \"各基金合伙人每期按其出资比例缴付。合伙期限为11年，投资目标为教育领域初创期或成长期企业。\" \\\n \"截止公告披露日，深圳嘉道谷投资管理有限公司股权结构如下:截止公告披露日，深圳嘉道功程股权投资基金产权结构如下:\" \\\n \"公告还披露，方直科技将探索在中小学教育、在线教育、非学历教育、学前教育、留学咨询等教育行业其他分支领域的投资。\" \\\n \"方直科技2016年营业收入9691万元，营业利润1432万元，归属于普通股股东的净利润1847万元。（多知网 黎珊）}}\"\n\n doc = \"PageRank算法简介。\" \\\n \"是上世纪90年代末提出的一种计算网页权重的算法! \" \\\n \"当时，互联网技术突飞猛进，各种网页网站爆炸式增长。 \" \\\n \"业界急需一种相对比较准确的网页重要性计算方法。 \" \\\n \"是人们能够从海量互联网世界中找出自己需要的信息。 \" \\\n \"百度百科如是介绍他的思想:PageRank通过网络浩瀚的超链接关系来确定一个页面的等级。 \" \\\n \"Google把从A页面到B页面的链接解释为A页面给B页面投票。 \" \\\n \"Google根据投票来源甚至来源的来源，即链接到A页面的页面。 \" \\\n \"和投票目标的等级来决定新的等级。简单的说， \" \\\n \"一个高等级的页面可以使其他低等级页面的等级提升。 \" \\\n \"具体说来就是，PageRank有两个基本思想，也可以说是假设。 \" \\\n \"即数量假设：一个网页被越多的其他页面链接，就越重）。 \" \\\n \"质量假设：一个网页越是被高质量的网页链接，就越重要。 \" \\\n \"总的来说就是一句话，从全局角度考虑，获取重要的信。 \"\n\n sum = lda.summarize(doc)\n for i in sum:\n print(i)\n", "meta": {"hexsha": "ab3509c399d9f09cfd02965f7461914b66c81208", "size": 5113, "ext": "py", "lang": "Python", "max_stars_repo_path": "nlg_yongzhuo/text_summarization/extractive_sum/topic_base/topic_lda.py", "max_stars_repo_name": "yongzhuo/nlg-yongzhuo", "max_stars_repo_head_hexsha": "937bfa750486294b333e685da6c34914948590b2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 280, "max_stars_repo_stars_event_min_datetime": "2019-08-31T16:48:58.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-25T08:08:21.000Z", "max_issues_repo_path": "nlg_yongzhuo/text_summarization/extractive_sum/topic_base/topic_lda.py", "max_issues_repo_name": "Mindyu/nlg-yongzhuo", "max_issues_repo_head_hexsha": "937bfa750486294b333e685da6c34914948590b2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2019-09-11T01:51:52.000Z", "max_issues_repo_issues_event_max_datetime": "2020-10-21T07:58:11.000Z", "max_forks_repo_path": "nlg_yongzhuo/text_summarization/extractive_sum/topic_base/topic_lda.py", "max_forks_repo_name": "Mindyu/nlg-yongzhuo", "max_forks_repo_head_hexsha": "937bfa750486294b333e685da6c34914948590b2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 43, "max_forks_repo_forks_event_min_datetime": "2019-10-21T11:58:08.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-28T09:39:34.000Z", "avg_line_length": 42.6083333333, "max_line_length": 112, "alphanum_fraction": 0.5883043223, "include": true, "reason": "import numpy", "num_tokens": 1952, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5736783928749127, "lm_q2_score": 0.33458944125318596, "lm_q1q2_score": 0.19194673293104275}} {"text": "import numpy as np\nimport time\nimport matplotlib.pyplot as plt\n\nfrom sklearn.model_selection import train_test_split\nfrom sklearn import datasets\n\nfrom Py_FS.wrapper.nature_inspired._utilities import Solution, Data, initialize, sort_agents, display, compute_fitness, Conv_plot\nfrom Py_FS.wrapper.nature_inspired._transfer_functions import get_trans_function\n\ndef MA(num_agents, max_iter, train_data, train_label, obj_function=compute_fitness, trans_function_shape='s', prob_mut=0.2, save_conv_graph=False):\n \n # Mayfly Algorithm\n ############################### Parameters ####################################\n # #\n # num_agents: number of mayflies #\n # max_iter: maximum number of generations #\n # train_data: training samples of data #\n # train_label: class labels for the training samples # \n # obj_function: the function to maximize while doing feature selection #\n # prob_mut: probability of mutation #\n # trans_function_shape: shape of the transfer function used #\n # save_conv_graph: boolean value for saving convergence graph #\n # #\n ###############################################################################\n\n short_name = 'MA'\n agent_name = 'Mayfly'\n train_data, train_label = np.array(train_data), np.array(train_label)\n num_features = train_data.shape[1]\n trans_function = get_trans_function(trans_function_shape)\n\n # setting up the objectives\n weight_acc = None\n if(obj_function==compute_fitness):\n weight_acc = float(input('Weight for the classification accuracy [0-1]: '))\n obj = (obj_function, weight_acc)\n compute_accuracy = (compute_fitness, 1) # compute_accuracy is just compute_fitness with accuracy weight as 1\n \n # control parameters\n a1 = 1\n a2 = 1.5\n d = 0.1\n fl = 0.1\n g = 0.8\n beta = 2\n delta = 0.9\n \n # initialize position and velocities of male and female mayflies' and Leader (the agent with the max fitness)\n male_pos = initialize(num_agents, num_features)\n female_pos = initialize(num_agents, num_features)\n male_vel = np.random.uniform(low = -1, high = 1, size = (num_agents, num_features))\n female_vel = np.random.uniform(low = -1, high = 1, size = (num_agents, num_features))\n male_fitness = np.zeros((num_agents))\n male_accuracy = np.zeros(num_agents)\n female_fitness = np.zeros((num_agents))\n Leader_agent = np.zeros((num_features))\n Leader_fitness = float(\"-inf\")\n Leader_accuracy = float(\"-inf\")\n male_personal_best = np.zeros((num_agents, num_features))\n male_offspring = np.zeros((num_agents, num_features))\n female_offspring = np.zeros((num_agents, num_features))\n vmax_male = np.zeros((num_features))\n vmax_female = np.zeros((num_features))\n \n # initialize convergence curves\n convergence_curve = {}\n convergence_curve['fitness'] = np.zeros(max_iter)\n \n # initialize data class\n data = Data()\n val_size = float(input('Enter the percentage of data wanted for valdiation [0, 100]: '))/100\n data.train_X, data.val_X, data.train_Y, data.val_Y = train_test_split(train_data, train_label, stratify=train_label, test_size=val_size)\n \n # create a solution object\n solution = Solution()\n solution.num_agents = num_agents\n solution.max_iter = max_iter\n solution.num_features = num_features\n solution.obj_function = obj_function\n \n # rank initial population\n male_pos, male_fitness = sort_agents(male_pos, obj, data)\n female_pos, female_fitness = sort_agents(female_pos, obj, data)\n \n # start timer\n start_time = time.time()\n \n # main loop\n for iter_no in range(max_iter):\n print('\\n================================================================================')\n print(' Iteration - {}'.format(iter_no+1))\n print('================================================================================\\n')\n \n #updating velocity limits\n vmax_male, vmax_female = update_max_velocity(male_pos, female_pos)\n \n for agent in range(num_agents):\n \n #updating Leader fitness and personal best fitnesses\n if male_fitness[agent] > Leader_fitness:\n Leader_fitness = male_fitness[agent]\n Leader_agent = male_pos[agent]\n \n if male_fitness[agent] > obj_function(male_personal_best[agent], data.train_X, data.val_X, data.train_Y, data.val_Y):\n male_personal_best[agent] = male_pos[agent]\n\n #update velocities of male and female mayflies\n male_vel[agent], female_vel[agent] = update_velocity(male_pos[agent], female_pos[agent], male_vel[agent], female_vel[agent], Leader_agent, male_personal_best[agent], a1, a2, d, fl, g, beta, agent, data, obj_function)\n \n #check boundary condition of velocities of male and female mayflies\n male_vel[agent], female_vel[agent] = check_velocity_limits(male_vel[agent], female_vel[agent], vmax_male, vmax_female)\n \n #applying transfer functions to update positions of male and female mayflies\n #the updation is done based on their respective velocity values\n for j in range(num_features):\n trans_value = trans_function(male_vel[agent][j])\n if trans_value > np.random.normal(0,1):\n male_pos[agent][j]=1\n else:\n male_pos[agent][j]=0\n\n trans_value = trans_function(female_vel[agent][j])\n if trans_value > np.random.random():\n female_pos[agent][j]=1\n else:\n female_pos[agent][j]=0\n \n #sorting \n male_pos, male_fitness = sort_agents(male_pos, obj, data)\n female_pos, female_fitness = sort_agents(female_pos, obj, data)\n \n for agent in range(num_agents):\n \n #generation of offsprings by crossover and mutation between male and female parent mayflies\n male_offspring[agent], female_offspring[agent] = cross_mut(male_pos[agent], female_pos[agent],prob_mut)\n \n #comparing parents and offsprings and replacing parents wherever necessary\n male_pos = compare_and_replace(male_pos, male_offspring, male_fitness, data, obj)\n female_pos = compare_and_replace(female_pos, female_offspring, female_fitness, data, obj)\n \n #updating fitness values\n male_pos, male_fitness = sort_agents(male_pos, obj, data)\n female_pos, female_fitness = sort_agents(female_pos, obj, data)\n \n #updating values of nuptial dance\n d = d * delta\n fl = fl * delta\n \n #update final information\n display(male_pos, male_fitness, agent_name)\n if(male_fitness[0] > Leader_fitness):\n Leader_agent = male_pos[0].copy()\n Leader_fitness = male_fitness[0].copy()\n\n convergence_curve['fitness'][iter_no] = np.mean(male_fitness)\n \n # compute final accuracy\n Leader_agent, Leader_accuracy = sort_agents(Leader_agent, compute_accuracy, data)\n male_pos, male_accuracy = sort_agents(male_pos, compute_accuracy, data)\n\n print('\\n================================================================================')\n print(' Final Result ')\n print('================================================================================\\n')\n print('Leader ' + agent_name + ' Dimension : {}'.format(int(np.sum(Leader_agent))))\n print('Leader ' + agent_name + ' Fitness : {}'.format(Leader_fitness))\n print('Leader ' + agent_name + ' Classification Accuracy : {}'.format(Leader_accuracy))\n print('\\n================================================================================\\n')\n\n # stop timer\n end_time = time.time()\n exec_time = end_time - start_time\n \n # plot convergence graph\n fig, axes = Conv_plot(convergence_curve)\n if(save_conv_graph):\n plt.savefig('convergence_graph_'+ short_name + '.jpg')\n plt.show()\n \n # update attributes of solution\n solution.best_agent = Leader_agent\n solution.best_fitness = Leader_fitness\n solution.best_accuracy = Leader_accuracy\n solution.convergence_curve = convergence_curve\n solution.final_population = male_pos\n solution.final_fitness = male_fitness\n solution.final_accuracy = male_accuracy\n solution.execution_time = exec_time\n\n return solution\n\n\ndef update_max_velocity(male, female):\n size, length = male.shape\n agent1 = []\n agent2 = []\n r = np.random.normal(0,1 , size=(length))\n for j in range(length):\n r[j] *= 2\n agent1.append((male[0][j]-male[size-1][j])*r[j])\n agent2.append((female[0][j]-female[size-1][j])*r[j])\n \n return (agent1, agent2)\n\ndef update_velocity(m_pos, f_pos, m_vel, f_vel, Leader_agent, pbest, a1, a2, d, fl, g, b, i, data, obj_function):\n tot_features = m_pos.shape[0]\n agent1 = np.zeros((tot_features))\n agent2 = np.zeros((tot_features))\n tot_features = len(m_pos)\n if i==0:\n for j in range(tot_features):\n agent1[j] = m_vel[j]+d*np.random.uniform(-1,1)\n else:\n sum = 0 \n for j in range(tot_features):\n sum = sum+(m_pos[j]-Leader_agent[j])*(m_pos[j]-Leader_agent[j])\n rg = np.sqrt(sum)\n sum = 0\n for j in range(tot_features):\n sum = sum+(m_pos[j]-pbest[j])*(m_pos[j]-pbest[j])\n rp = np.sqrt(sum)\n for j in range(tot_features):\n agent1[j] = g*m_vel[j]+a1*np.exp(-b*rp*rp)*(pbest[j]-m_pos[j])+a2*np.exp(-b*rg*rg)*(Leader_agent[j]-m_pos[j])\n if obj_function(m_pos, data.train_X, data.val_X, data.train_Y, data.val_Y) >= obj_function(f_pos, data.train_X, data.val_X, data.train_Y, data.val_Y):\n sum = 0\n for j in range(tot_features):\n sum = sum+(m_pos[j]-f_pos[j])*(m_pos[j]-f_pos[j])\n rmf = np.sqrt(sum)\n agent2[j] = g*f_vel[j]+a2*np.exp(-b*rmf*rmf)*(m_pos[j]-f_pos[j])\n else:\n for j in range(tot_features):\n agent2[j] = g*f_vel[j]+fl*np.random.uniform(-1,1)\n \n return (agent1, agent2)\n\ndef check_velocity_limits(m_vel, f_vel, vmax_m, vmax_f):\n tot_features = len(m_vel)\n for j in range(tot_features):\n m_vel[j] = np.minimum(m_vel[j], vmax_m[j])\n m_vel[j] = np.maximum(m_vel[j], -vmax_m[j])\n f_vel[j] = np.minimum(f_vel[j], vmax_f[j])\n f_vel[j] = np.maximum(f_vel[j], -vmax_f[j])\n \n return (m_vel, f_vel)\n\ndef cross_mut(m_pos, f_pos,prob_mut):\n tot_features = len(m_pos)\n offspring1 = np.zeros((tot_features))\n offspring2 = np.zeros((tot_features))\n # partition defines the midpoint of the crossover\n partition = np.random.randint(tot_features//4, np.floor((3*tot_features//4)+1))\n\n # starting crossover\n for i in range(partition):\n offspring1[i] = m_pos[i]\n offspring2[i] = f_pos[i]\n\n for i in range(partition, tot_features):\n offspring1[i] = f_pos[i]\n offspring2[i] = m_pos[i]\n # crossover ended\n\n\n # starting mutation\n if np.random.random() <= prob_mut:\n percent = 0.2\n numChange = int(tot_features*percent)\n pos = np.random.randint(0,tot_features-1,numChange)\n \n for j in pos:\n offspring1[j] = 1-offspring1[j]\n pos=np.random.randint(0,tot_features-1,numChange)\n for j in pos:\n offspring2[j] = 1-offspring2[j]\n\n # mutation ended\n \n if np.random.random() >= 0.5:\n return (offspring1, offspring2)\n else:\n return (offspring2, offspring1)\n\n\ndef compare_and_replace(pos, off, fit, data, obj):\n agents, features = pos.shape\n newfit = np.zeros((agents))\n temp_pos = np.zeros((agents, features))\n pos, fit = sort_agents(pos, obj, data)\n # finding fitnesses of offsprings\n off, newfit = sort_agents(off, obj, data)\n i=0\n j=0\n cnt=0\n # merging offsprings and parents and finding the next generation of mayflies\n while(cnt < agents):\n if fit[i] > newfit[j]:\n temp_pos[cnt] = pos[i].copy()\n i+=1\n else:\n temp_pos[cnt] = off[i].copy()\n j+=1\n cnt+=1\n return temp_pos\n\n\nif __name__ == '__main__':\n data = datasets.load_digits()\n MA(20, 30, data.data, data.target, save_conv_graph=True)\n", "meta": {"hexsha": "2294d45063ef101f67cac2a09e6826215e25e083", "size": 12832, "ext": "py", "lang": "Python", "max_stars_repo_path": "Other Optimization Algorithms/MA.py", "max_stars_repo_name": "stochasticmaterialism/Dendritic-Non-Dendritic-Classification", "max_stars_repo_head_hexsha": "cb0f68377b0d7cfdbb091bb2df898ecbcb0e44e8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-08-04T14:48:49.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-04T14:48:49.000Z", "max_issues_repo_path": "Other Optimization Algorithms/MA.py", "max_issues_repo_name": "stochasticmaterialism/Dendritic-Non-Dendritic-Classification", "max_issues_repo_head_hexsha": "cb0f68377b0d7cfdbb091bb2df898ecbcb0e44e8", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2022-03-26T16:06:32.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-26T16:07:14.000Z", "max_forks_repo_path": "Other Optimization Algorithms/MA.py", "max_forks_repo_name": "stochasticmaterialism/Dendritic-Non-Dendritic-Classification", "max_forks_repo_head_hexsha": "cb0f68377b0d7cfdbb091bb2df898ecbcb0e44e8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-09-28T15:18:26.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-28T15:18:26.000Z", "avg_line_length": 41.5275080906, "max_line_length": 228, "alphanum_fraction": 0.5931265586, "include": true, "reason": "import numpy", "num_tokens": 2967, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.523420348936324, "lm_q2_score": 0.36658973632215985, "lm_q1q2_score": 0.19188052770221994}} {"text": "import random\nimport copy\nimport numpy as np\nimport pandas as pd\nimport os\n\nfrom models.MultiGMPmodel import MultiCopyGMPmodel\nfrom models.MultiGGHPmodel import MultiCopyGGHPmodel\nfrom models.GGHPmodel import GGHPmodel\nfrom util.calculateFissionsAndFusions import calculateFissionAndFussions\n\ndef readSequence(file):\n chr = []\n with open(file,'r') as rf:\n while True:\n line = rf.readline()[:-2]\n if not line:\n break\n itemset = line.split(' ')\n header = itemset[0]\n new_itemset = [header]\n for i in itemset[1:]:\n item = i.split('_')\n new_itemset.append(item[0])\n chr.append(new_itemset)\n return chr\n\ndef outSequence(sequence,outfile):\n outfile = open(outfile,'w')\n for i in sequence:\n for j in i:\n outfile.write(j+' ')\n outfile.write('\\n')\n outfile.close()\n\ndef sequence2adjacency(sequence):\n adjacency = []\n for i in sequence:\n block = i[0]\n if block.startswith('-'):\n adjacency.append(['$',block[1:] + 'b'])\n start = block[1:] + 'a'\n else:\n adjacency.append(['$', block + 'a'])\n start = block + 'b'\n for j in range(len(i)-1):\n block = i[j+1]\n if block.startswith('-'):\n adjacency.append([start, block[1:] + 'b'])\n start = block[1:] + 'a'\n else:\n adjacency.append([start, block + 'a'])\n start = block + 'b'\n adjacency.append([start,'$'])\n return adjacency\n\ndef reverse(item):\n if item[-1] == 'a':\n return item[:-1] + 'b'\n else:\n return item[:-1] + 'a'\n\ndef assemble(adjacency_list):\n # build adj M\n matrix_items = []\n for i in adjacency_list:\n for j in i:\n if j not in matrix_items:\n matrix_items.append(j)\n matrix_items = sorted(matrix_items)\n adjacency_matrix = {} # 创建初始邻接矩阵\n for i in matrix_items:\n adjacency_matrix[i] = {}\n for j in matrix_items:\n adjacency_matrix[i][j] = 0\n for i in adjacency_list:\n adjacency_matrix[i[0]][i[1]] = 1\n adjacency_matrix[i[1]][i[0]] = 1\n adjacency_matrix = pd.DataFrame(adjacency_matrix)\n index = adjacency_matrix.index.tolist()\n columns = adjacency_matrix.columns.tolist()\n np_adjacency_matrix = np.asarray(adjacency_matrix)\n adjacencies = {}\n for i in range(len(index)):\n for j in range(len(index)):\n if int(np_adjacency_matrix[i][j]) == 1:\n if '$' == index[i] or '$' == index[j]:\n continue\n pair = sorted([index[i], index[j]])\n key = pair[0] + '@' + pair[1]\n if key not in adjacencies.keys():\n adjacencies[key] = 1\n else:\n adjacencies[key] += 1\n adjs = {}\n for i in adjacencies.keys():\n itemset = i.split('@')\n if itemset[0] not in adjs.keys():\n adjs[itemset[0]] = itemset[1]\n if itemset[1] not in adjs.keys():\n adjs[itemset[1]] = itemset[0]\n startpoint = []\n # 遍历矩阵第一行，不是0的加入start:\n for j in range(len(columns)):\n if np_adjacency_matrix[0][j] == 1:\n startpoint.append(columns[j])\n markerstartpoint = []\n chr = []\n for i in startpoint:\n if i not in markerstartpoint:\n path = []\n if i[-1] == 'a':\n path.append(i[:-1])\n else:\n path.append('-' + i[:-1])\n start = reverse(i)\n if start in startpoint:\n markerstartpoint.append(start)\n chr.append(path)\n else:\n while True:\n next = adjs[start]\n if next[-1] == 'a':\n path.append(next[:-1])\n else:\n path.append('-' + next[:-1])\n start = reverse(next)\n if start in startpoint:\n markerstartpoint.append(start)\n break\n chr.append(path)\n vector = []\n for i in chr:\n for j in i:\n if j.startswith('-'):\n vector.append(j[1:])\n else:\n vector.append(j)\n cyclepoint = []\n for i in adjs.keys():\n if i[:-1] not in vector:\n cyclepoint.append(i)\n cyclechr = []\n markercycle = []\n for i in cyclepoint:\n if i not in markercycle:\n startpoint = i\n cycle = []\n markercycle.append(i)\n start = i\n while True:\n next = adjs[start]\n if next[-1] == 'a':\n cycle.append(next[:-1])\n else:\n cycle.append('-' + next[:-1])\n markercycle.append(start)\n markercycle.append(next)\n start = reverse(next)\n if start == startpoint:\n break\n cyclechr.append(cycle)\n return chr,cyclechr\n\ndef changeAdj(adj_list):\n change = copy.deepcopy(adj_list)\n endpoints = []\n for j in change:\n for k in j:\n endpoints.append(k)\n random.shuffle(endpoints)\n change_part = []\n for j in range(int(len(endpoints) / 2)):\n change_part.append([endpoints[j * 2], endpoints[2 * j + 1]])\n return change_part\n\n\n\ndef buildNoCRBSimulations(prefix_adjacencies,\n suffix_adjacencies, save_final_species_adjacencies, change_adjacency_number,\n divergence_level, current_level):\n split_adjacency = []\n divergence_change_adjacencies_group_number = len(suffix_adjacencies) * 2\n for i in suffix_adjacencies:\n one_change_adjacencies = []\n for j in range(divergence_change_adjacencies_group_number):\n one_change_adjacencies.append(copy.deepcopy(i[j * change_adjacency_number:(j + 1) * change_adjacency_number]))\n one_change_adjacencies.append(copy.deepcopy(i[divergence_change_adjacencies_group_number * change_adjacency_number:]))\n split_adjacency.append(one_change_adjacencies)\n\n sub_species_1 = []\n sub_species_2 = []\n copy_number = 0\n\n for i in split_adjacency:\n sp1_copy = []\n sp2_copy = []\n sp1_change = copy_number\n sp2_change = copy_number+len(split_adjacency)\n for j in range(len(i)):\n # change different part, no CRBs\n if j == sp1_change:\n change = copy.deepcopy(i[j])\n change_part = changeAdj(change)\n sp1_copy.append(change_part)\n else:\n sp1_copy.append(copy.deepcopy(i[j]))\n if j == sp2_change:\n change = copy.deepcopy(i[j])\n change_part = changeAdj(change)\n sp2_copy.append(change_part)\n else:\n sp2_copy.append(copy.deepcopy(i[j]))\n\n sub_species_1.append(sp1_copy)\n sub_species_2.append(sp2_copy)\n copy_number += 1\n\n species_1 = []\n for i in range(len(sub_species_1)):\n one_copy = []\n one_copy += copy.deepcopy(prefix_adjacencies[i])\n for j in copy.deepcopy(sub_species_1[i]):\n one_copy += j\n species_1.append(one_copy)\n # save first species\n save_final_species_adjacencies.append(species_1)\n species_2 = []\n for i in range(len(sub_species_2)):\n one_copy = []\n one_copy += copy.deepcopy(prefix_adjacencies[i])\n for j in copy.deepcopy(sub_species_2[i]):\n one_copy += j\n species_2.append(one_copy)\n # save second species\n save_final_species_adjacencies.append(species_2)\n\n # duplication\n dup_flag = 1\n species_2_dup = []\n if dup_flag == 1:\n for i in range(len(sub_species_2)):\n change_list = copy.deepcopy(sub_species_2[i][:-1])\n unchange = copy.deepcopy(sub_species_2[i][-1])\n\n split_unchange = []\n for j in range(len(sub_species_2)*2):\n split_unchange.append(copy.deepcopy(unchange[j * change_adjacency_number:(j + 1) * change_adjacency_number]))\n split_unchange.append(unchange[len(sub_species_2) * 2 * change_adjacency_number:])\n # change adjacencies\n change_1 = i*len(sub_species_2)\n change_2 = i*len(sub_species_2) + 1\n new_change_list_copy1 = []\n new_change_list_copy2 = []\n for j in range(len(split_unchange)):\n if j == change_1:\n change = copy.deepcopy(split_unchange[j])\n change_part = changeAdj(change)\n new_change_list_copy1.append(change_part)\n else:\n new_change_list_copy1.append(copy.deepcopy(split_unchange[j]))\n if j == change_2:\n change = copy.deepcopy(split_unchange[j])\n change_part = changeAdj(change)\n new_change_list_copy2.append(change_part)\n else:\n new_change_list_copy2.append(copy.deepcopy(split_unchange[j]))\n final_change_list_1 = copy.deepcopy(change_list) + new_change_list_copy1\n final_change_list_2 = copy.deepcopy(change_list) + new_change_list_copy2\n species_2_dup.append(final_change_list_1)\n species_2_dup.append(final_change_list_2)\n\n if current_level == divergence_level:\n species_2_dup_sequence = []\n for i in range(len(species_2_dup)):\n one_copy = []\n one_copy += copy.deepcopy(prefix_adjacencies[int(i / 2)])\n for j in copy.deepcopy(species_2_dup[i]):\n one_copy += j\n species_2_dup_sequence.append(one_copy)\n save_final_species_adjacencies.append(species_2_dup_sequence)\n\n else:\n species_2_dup_sequence = []\n for i in range(len(species_2_dup)):\n one_copy = []\n one_copy += copy.deepcopy(prefix_adjacencies[int(i / 2)])\n for j in copy.deepcopy(species_2_dup[i]):\n one_copy += j\n species_2_dup_sequence.append(one_copy)\n # save duplicated species\n save_final_species_adjacencies.append(species_2_dup_sequence)\n new_prefix_adjacency = []\n new_suffix_adjacency = []\n for i in range(len(species_2_dup)):\n one_copy = copy.deepcopy(prefix_adjacencies[int(i / 2)])\n change_part = species_2_dup[i][:-1]\n unchange_part = species_2_dup[i][-1]\n for j in change_part:\n one_copy += copy.deepcopy(j)\n new_prefix_adjacency.append(one_copy)\n new_suffix_adjacency.append(copy.deepcopy(unchange_part))\n # recursion build next level species, level += 1\n buildNoCRBSimulations(new_prefix_adjacency, new_suffix_adjacency,\n save_final_species_adjacencies, change_adjacency_number,\n divergence_level, current_level + 1)\n\n\ndef simulateNoCRB(workdir):\n chromosome_number = 5\n block_number = 100\n ancestor_sequence = []\n one_chromosome = int(block_number / chromosome_number)\n block = 100\n for i in range(chromosome_number):\n sequence = []\n for j in range(one_chromosome):\n if block % 2 == 0:\n sequence.append('-' + str(block))\n else:\n sequence.append(str(block))\n block += 1\n ancestor_sequence.append(sequence)\n ancestor_adjacency = sequence2adjacency(ancestor_sequence)\n random.shuffle(ancestor_adjacency)\n print('ancestor adjacency number:')\n print(len(ancestor_adjacency))\n divergence_level = 2\n change_adjacency_number = 5\n save_final_species_adjacencies = []\n buildNoCRBSimulations([[]], [ancestor_adjacency],\n save_final_species_adjacencies, change_adjacency_number, divergence_level, current_level=0)\n species_count = 1\n # output species\n for i in save_final_species_adjacencies:\n copy_count = 1\n outfile = workdir + 'species.sequence.' + str(species_count)\n\n outfile = open(outfile,'w')\n for j in i:\n filter_tel2tel = []\n for k in j:\n # filter ($,$)\n if k[0] == '$' and k[1] == '$':\n continue\n else:\n if k[0] != '$':\n newendpoint1 = k[0][:-1]+'_'+str(copy_count)+k[0][-1]\n else:\n newendpoint1 = '$'\n if k[1] != '$':\n newendpoint2 = k[1][:-1]+'_'+str(copy_count)+k[1][-1]\n else:\n newendpoint2 = '$'\n filter_tel2tel.append([newendpoint1,newendpoint2])\n chrs,cycles = assemble(filter_tel2tel)\n for k in chrs:\n outfile.write('s ')\n for l in k:\n outfile.write(l+' ')\n outfile.write('\\n')\n for k in cycles:\n outfile.write('c ')\n min_index = -1\n min_value = 1000000\n for l in range(len(k)):\n if k[l].startswith('-'):\n item = k[l][1:].split('_')\n block = int(item[0])\n else:\n item = k[l].split('_')\n block = int(item[0])\n if block < min_value:\n min_index = l\n min_value = block\n if k[min_index].startswith('-'):\n half1 = k[min_index + 1:]\n half2 = k[:min_index + 1]\n new_string = half1 + half2\n else:\n half1 = k[min_index:]\n half2 = k[:min_index]\n new_string = half1 + half2\n for l in new_string:\n outfile.write(l+' ')\n outfile.write('\\n')\n copy_count += 1\n outfile.close()\n species_count += 1\n\n\ndef doubled(infile,outfile):\n outfile = open(outfile,'w')\n sequence = []\n with open(infile,'r') as f:\n while True:\n line = f.readline()\n if not line:\n break\n sequence.append(line)\n for i in sequence:\n outfile.write(i)\n for i in sequence:\n outfile.write(i)\n\n\nworkdir = 'D:/InferAncestorGenome/realData/IAGS_version1.0/simulations/NonCRBs/inferring/repeat/'\n# simulate No CRB species\nif not os.path.exists(workdir):\n os.makedirs(workdir)\nresultfile = open(workdir + 'result.xls', 'w')\nresultfile.write('Repeat\\tAncestor\\tFissions\\tFusions\\n')\nfor i in range(200):\n repeatdir = workdir + str(i+1) + '/'\n if not os.path.exists(repeatdir):\n os.makedirs(repeatdir)\n simulateNoCRB(repeatdir)\n filelist = ['species.sequence.1', 'species.sequence.2', 'species.sequence.3',\n 'species.sequence.4', 'species.sequence.5', 'species.sequence.6',\n 'species.sequence.7', 'species.sequence.8', 'species.sequence.9']\n for j in filelist:\n sequence = readSequence(repeatdir + j)\n outSequence(sequence, repeatdir + j + '.noBar')\n \"\"\"\n Ancestor 8: Multi-copy GGHP model\n \"\"\"\n dup_child_file = repeatdir + 'species.sequence.9.noBar'\n outgroup_file = repeatdir + 'species.sequence.7.noBar'\n outAncestor8dir = repeatdir + 'Ancestor8/'\n if not os.path.exists(outAncestor8dir):\n os.makedirs(outAncestor8dir)\n\n dup_copy_number = 8\n out_copy_number = 4\n ancestor_target_copy_number = 4\n ancestor_name = 'Ancestor8'\n MultiCopyGGHPmodel(dup_child_file, outgroup_file, outAncestor8dir,\n ancestor_name, dup_copy_number, out_copy_number,\n ancestor_target_copy_number)\n\n ancestor_file = outAncestor8dir + ancestor_name + '.block'\n\n fissions, fusions = calculateFissionAndFussions(ancestor_file,\n repeatdir + 'species.sequence.8.noBar',\n ancestor_target_copy_number, ancestor_target_copy_number,\n outAncestor8dir)\n resultfile.write(str(i+1)+'\\tAncestor8\\t' + str(fissions) + '\\t' + str(fusions) + '\\n')\n\n \"\"\"\n Ancestor 5: Multi-copy GGHP model\n \"\"\"\n dup_child_file = repeatdir + 'species.sequence.7.noBar'\n outgroup_file = repeatdir + 'species.sequence.4.noBar'\n outAncestor5dir = repeatdir + 'Ancestor5/'\n if not os.path.exists(outAncestor5dir):\n os.makedirs(outAncestor5dir)\n dup_copy_number = 4\n out_copy_number = 2\n ancestor_target_copy_number = 2\n ancestor_name = 'Ancestor5'\n MultiCopyGGHPmodel(dup_child_file, outgroup_file, outAncestor5dir,\n ancestor_name, dup_copy_number, out_copy_number,\n ancestor_target_copy_number)\n\n ancestor_file = outAncestor5dir + ancestor_name + '.block'\n\n fissions, fusions = calculateFissionAndFussions(ancestor_file,\n repeatdir + 'species.sequence.5.noBar',\n ancestor_target_copy_number, ancestor_target_copy_number,\n outAncestor5dir)\n resultfile.write(str(i+1)+'\\tAncestor5\\t' + str(fissions) + '\\t' + str(fusions) + '\\n')\n\n \"\"\"\n Ancestor 6: Multi-copy GMP model\n \"\"\"\n outAncestor6dir = repeatdir + 'Ancestor6/'\n if not os.path.exists(outAncestor6dir):\n os.makedirs(outAncestor6dir)\n doubled(outAncestor5dir + 'Ancestor5.block', outAncestor6dir + 'Ancestor5.doubled.block')\n species_file_list = [repeatdir + 'species.sequence.7.noBar',\n outAncestor8dir + 'Ancestor8.block',\n outAncestor6dir + 'Ancestor5.doubled.block']\n guided_species_for_matching = repeatdir + 'species.sequence.7.noBar'\n ancestor_target_copy_number = 4\n ancestor_name = 'Ancestor6'\n MultiCopyGMPmodel(species_file_list, outAncestor6dir, guided_species_for_matching,\n ancestor_name, ancestor_target_copy_number)\n\n ancestor_file = outAncestor6dir + ancestor_name + '.block'\n\n fissions, fusions = calculateFissionAndFussions(ancestor_file,\n repeatdir + 'species.sequence.6.noBar',\n ancestor_target_copy_number, ancestor_target_copy_number,\n outAncestor6dir)\n resultfile.write(str(i+1)+'\\tAncestor6\\t' + str(fissions) + '\\t' + str(fusions) + '\\n')\n\n \"\"\"\n Ancestor 2: GGHP model\n \"\"\"\n dup_child_file = repeatdir + 'species.sequence.4.noBar'\n outgroup_file = repeatdir + 'species.sequence.1.noBar'\n outAncestor2dir = repeatdir + 'Ancestor2/'\n if not os.path.exists(outAncestor2dir):\n os.makedirs(outAncestor2dir)\n dup_copy_number = 2\n out_copy_number = 1\n ancestor_target_copy_number = 1\n ancestor_name = 'Ancestor2'\n GGHPmodel(dup_child_file=dup_child_file,\n outgroup_file=outgroup_file,\n outdir=outAncestor2dir,\n ancestor_name=ancestor_name,\n dup_copy_number=dup_copy_number,\n out_copy_number=out_copy_number)\n\n ancestor_file = outAncestor2dir + ancestor_name + '.block'\n\n fissions, fusions = calculateFissionAndFussions(ancestor_file,\n repeatdir + 'species.sequence.2.noBar',\n ancestor_target_copy_number, ancestor_target_copy_number,\n outAncestor2dir)\n resultfile.write(str(i+1)+'\\tAncestor2\\t' + str(fissions) + '\\t' + str(fusions) + '\\n')\n\n \"\"\"\n Ancestor 3: Multi-copy GMP model\n \"\"\"\n outAncestor3dir = repeatdir + 'Ancestor3/'\n outAncestor2dir = repeatdir + 'Ancestor2/'\n if not os.path.exists(outAncestor3dir):\n os.makedirs(outAncestor3dir)\n doubled(outAncestor2dir + 'Ancestor2.block', outAncestor3dir + 'Ancestor2.doubled.block')\n species_file_list = [repeatdir + 'species.sequence.4.noBar',\n outAncestor5dir + 'Ancestor5.block',\n outAncestor3dir + 'Ancestor2.doubled.block']\n guided_species_for_matching = repeatdir + 'species.sequence.4.noBar'\n ancestor_target_copy_number = 2\n ancestor_name = 'Ancestor3'\n MultiCopyGMPmodel(species_file_list, outAncestor3dir, guided_species_for_matching,\n ancestor_name, ancestor_target_copy_number)\n\n ancestor_file = outAncestor3dir + ancestor_name + '.block'\n\n fissions, fusions = calculateFissionAndFussions(ancestor_file,\n repeatdir + 'species.sequence.3.noBar',\n ancestor_target_copy_number, ancestor_target_copy_number,\n outAncestor3dir)\n resultfile.write(str(i+1)+'\\tAncestor3\\t' + str(fissions) + '\\t' + str(fusions) + '\\n')\n resultfile.flush()\n\nresultfile.close()\n\n\n\n\n\n\n\n\n\n\n\n", "meta": {"hexsha": "9c5cbd4a8f5c56245deac9bf789100ec49349459", "size": 21373, "ext": "py", "lang": "Python", "max_stars_repo_path": "simulations/NonCRBs/NonCRBSimulateion.py", "max_stars_repo_name": "865699871/IAGS_version1.0", "max_stars_repo_head_hexsha": "f5b2f30cef9b809a9ece91abf5b1d56367512f58", "max_stars_repo_licenses": ["AFL-1.1"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2021-08-04T07:38:04.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-07T16:56:57.000Z", "max_issues_repo_path": "simulations/NonCRBs/NonCRBSimulateion.py", "max_issues_repo_name": "xjtu-omics/IAGS", "max_issues_repo_head_hexsha": "1e9de501e1f7875e0cea6da5954aa034445eae77", "max_issues_repo_licenses": ["AFL-1.1"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "simulations/NonCRBs/NonCRBSimulateion.py", "max_forks_repo_name": "xjtu-omics/IAGS", "max_forks_repo_head_hexsha": "1e9de501e1f7875e0cea6da5954aa034445eae77", "max_forks_repo_licenses": ["AFL-1.1"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2022-03-03T03:10:01.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-28T01:49:19.000Z", "avg_line_length": 38.0302491103, "max_line_length": 126, "alphanum_fraction": 0.5603799186, "include": true, "reason": "import numpy", "num_tokens": 4849, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5234203340678567, "lm_q2_score": 0.3665897363221598, "lm_q1q2_score": 0.19188052225159238}} {"text": "#!/usr/bin/env python\n# TODO: how do we choose the simulation box?\n\nimport numpy as np\nimport numpy.linalg as la\nimport sys\nimport os\nfrom libs import topology as top\nfrom libs import base\nfrom libs import utils\n\n\t\nclass Options(object):\n\n\tdef __init__(self):\n\t\tobject.__init__(self)\n\t\t\n\t\tself.closed = True\n\t\tself.double = True\n\t\tself.nicked = False\n\t\tself.supercoiling = 0.\n\t\tself.writhe = 0.\n\t\tself.seed = None\n\t\tself.sequence_file = None\n\t\t\n\tdef check(self):\n\t\tif self.nicked and not self.double:\n\t\t\tprint >> sys.stderr, \"The --nicked and --ssDNA options are incompatible\"\n\t\t\texit(1)\n\t\t\n\t\t\ndef print_usage():\n\tprint >> sys.stderr, \"USAGE:\"\n\tprint >> sys.stderr, \"\\t%s centerline_file\" % sys.argv[0]\n\tprint >> sys.stderr, \"\\t[-c\\--closed] [-o\\--open] [-h\\--help] [-d\\--dsDNA] [-s\\--ssDNA] [-n\\--nicked] [-p\\--supercoiling VALUE] [-w\\--writhe VALUE] [-e\\--seed VALUE] [-q\\--sequence FILE]\"\n\texit(1)\n\t\t\n\t\t\ndef parse_options():\n\tshortArgs = 'cohdsnp:w:e:q:'\n\tlongArgs = ['closed', 'open', 'help', 'dsDNA', 'ssDNA', 'nicked', 'supercoiling=', 'writhe=', 'seed=', 'sequence=']\n\t\n\topts = Options()\n\t\n\ttry:\n\t\timport getopt\n\t\targs, files = getopt.gnu_getopt(sys.argv[1:], shortArgs, longArgs)\n\t\tfor k in args:\n\t\t\tif k[0] == '-c' or k[0] == '--closed': opts.closed = True\n\t\t\tif k[0] == '-o' or k[0] == '--open': opts.closed = False\n\t\t\tif k[0] == '-h' or k[0] == '--help': print_usage()\n\t\t\tif k[0] == '-d' or k[0] == '--dsDNA': opts.double = True\n\t\t\tif k[0] == '-s' or k[0] == \"--ssDNA\": opts.double = False\n\t\t\tif k[0] == '-n' or k[0] == \"--nicked\": opts.nicked = True\n\t\t\tif k[0] == '-p' or k[0] == \"--supercoiling\": opts.supercoiling = float(k[1])\n\t\t\tif k[0] == '-w' or k[0] == \"--writhe\": opts.writhe = float(k[1])\n\t\t\tif k[0] == '-e' or k[0] == \"--seed\": opts.seed = int(k[1])\n\t\t\tif k[0] == '-q' or k[0] == \"--sequence\": opts.sequence_file = k[1]\n\t\t\t\n\t\topts.centerline_file = files[0]\n\texcept Exception:\n\t\tprint_usage()\n\t\t\n\treturn opts\n\n\n# base-base distance along the helical pitch\nBASE_BASE = 0.3897628551303122\n# distance between the helix centre and the nucleotides' centre of mass\nCM_CENTER_DS = 0.6\n\nif __name__ == '__main__':\n\topts = parse_options()\n\topts.check()\n\t\n\tif opts.seed != None:\n\t\tnp.random.seed(opts.seed)\n\t\n\t# import the coordinates from the user-provided file\n\tcoordxyz = np.loadtxt(opts.centerline_file, float)\n\t\n\t# number of base pairs\n\tnbases = len(coordxyz)\n\t\n\t# use the model parameters to scale the distances \n\tscaling = BASE_BASE / la.norm(coordxyz[1, :] - coordxyz[0, :]) \n\tcoordxyz *= scaling\n\n\t#initialize vectors\n\tdist = np.copy(coordxyz)\n\tdist_norm = np.copy(coordxyz)\n\tp = np.copy(coordxyz)\n\t\n\tssdna1 = np.copy(coordxyz)\n\tv_perp_ssdna1 = np.copy(coordxyz)\n\t\n\tssdna2 = np.copy(coordxyz)\n\tv_perp_ssdna2 = np.copy(coordxyz)\n\t\n\t\n\t# take the bounding box as the simulation box for the output configuration\n\tboxx = max(coordxyz[:nbases, 0]) - min(coordxyz[:nbases, 0])\n\tboxy = max(coordxyz[:nbases, 1]) - min(coordxyz[:nbases, 1])\n\tboxz = max(coordxyz[:nbases, 2]) - min(coordxyz[:nbases, 2])\n\tboxmax = 1.5 * max(boxx, boxy, boxz)\n\t\n\t# centerline base_to_base vectors\n\tfor c in range(0, nbases): \n\t\tind = c \n\t\tind1 = (c + 1) % nbases\n\t\t#open chain cannot compute dist at c=nbases-1 \n\t\t#so we use as reference the previus dist\n\t\tif opts.closed or (not opts.closed and c!=nbases-1):\t\n\t\t\tdist[ind, :] = coordxyz[ind1, :] - coordxyz[ind, :]\n\t\t\tdist_norm[ind, :] = dist[ind, :] / la.norm(dist[ind, :])\n\t\telse:\n\t\t\tdist[ind, :] = dist[ind-1, :]\n\t\t\tdist_norm[ind, :] = dist_norm[ind-1, :]\n\n\t# vectors perpendicular between two consecutive centerline vectors (normalized)\n\tfor c in range(0, nbases): \n\t\tind_1 = (c - 1 + nbases) % nbases \n\t\tind = c\n\t\t\t\n\t\t#opens chain have random p at c=0 and at c=nbases-1 due to absence of neighbours\n\t\tif opts.closed or (not opts.closed and c!=0 and c!=nbases-1):\n\t\t\t#check that dist[ind_1, :] and dist[ind, :] are not equals\n\t\t\tif not np.all(np.isclose( dist[ind_1, :] , dist[ind, :]) ):\n\t\t\t\tp[ind, :] = np.cross(dist[ind_1, :] , dist[ind, :])\n\t\t\t\tp[ind, :] /= la.norm(p[ind, :])\n\t\t\t#else assign random p\n\t\t\telse:\n\t\t\t\trv=np.random.uniform(-1,1,3)\n\t\t\t\tp[ind, :] = rv - (np.dot(dist_norm[ind, :],rv)) * dist_norm[ind, :]\n\t\t\t\tp[ind, :] /= la.norm(p[ind, :])\n\t\telse:\n\t\t\trv=np.random.uniform(-1,1,3)\n\t\t\tp[ind, :] = rv - (np.dot(dist_norm[ind, :],rv)) * dist_norm[ind, :]\n\t\t\tp[ind, :] /= la.norm(p[ind, :])\n\n\t# chain writhe\n\tWR = 0.\n\tif opts.closed:\n\t\tWR = top.get_writhe(coordxyz)\n\n\t#oxdna equiibrium pitch\n\tpitch = 10.5\n\n\t#global linking number\n\tLK = round((nbases / pitch) * (opts.supercoiling + 1) + opts.writhe) \n\t\n\tTW = LK - WR \n\n\t#twisting angle between two consecutive bases\n\trot_base = TW * 2.0 * np.pi / nbases \n\n\t#recap\n\tif opts.closed:\n\t\tprint >> sys.stderr, \"Total Linking Number (LK) %f, composed of:\" % ((nbases / pitch) * (opts.supercoiling + 1) + opts.writhe)\n\t\tprint >> sys.stderr, \"1) Equilibrium number of DNA turns %f\" % (nbases / pitch)\n\t\tprint >> sys.stderr, \"2) Target writhe %f = Topological writhe %f + Turns imposed by supercoiling %f \" % (opts.writhe+(nbases / pitch) *opts.supercoiling,opts.writhe,(nbases / pitch) *opts.supercoiling)\n\t\tprint >> sys.stderr, \"LK has been rounded to %f\" % LK\n\t\tprint >> sys.stderr, \"Initial chain writhe %f\" % WR\n\n\n\t####################################\n\t# Initialize DNA strand \n\t####################################\n\t\n\t#First hydrogen-hydrogen bond vector\n\tv_perp_ssdna1[0, :] = np.cross(dist_norm[0, :], p[0, :]) \n\tv_perp_ssdna1[0, :] /= la.norm(v_perp_ssdna1[0, :])\n\tv_perp_ssdna2[0, :] = -v_perp_ssdna1[0, :]\n\t\n\tfor c in range(nbases): \n\t\t#dna center of mass positions\n\t\tssdna1[c, :] = coordxyz[c, :] - CM_CENTER_DS * v_perp_ssdna1[c, :] \n\t\tssdna2[c, :] = coordxyz[c, :] + CM_CENTER_DS * v_perp_ssdna1[c, :] \n\t\n\t\t#Update v_perp_ssdna1\n\t\t\n\t\tind_1 = c \n\t\tind = (c + 1) % nbases \n\t\t\n\t\talpha = top.py_ang(v_perp_ssdna1[ind_1, :] , p[ind, :] , dist[ind_1, :])\n\t\tgamma = rot_base - alpha\n\t\t#prevent change when ind=0 on open chain\n\t\tif c!=nbases-1:\t\t\n\t\t\tR = utils.get_rotation_matrix(dist[ind, :], gamma)\n\t\t\tv_perp_ssdna1[ind, :] = np.dot(R , p[ind, :]) \n\t\t\tv_perp_ssdna2[ind, :] = -v_perp_ssdna1[ind, :]\n\t\t\n\t# check LK imposed and measured\n\tif opts.closed:\n\t\tTW_measured = top.get_twist(coordxyz, ssdna1)\n\tbox = np.array([boxmax, boxmax, boxmax])\n\tsystem = base.System(box)\n\t\n\tif opts.sequence_file == None:\n\t\tssdna1_base = np.zeros(nbases, int)\n\t\tfor c in range(nbases):\n\t\t\tssdna1_base[c] = np.random.randint(0, 4)\n\telse:\n\t\ttry:\n\t\t\tseq_file = open(opts.sequence_file)\n\t\texcept Exception:\n\t\t\tprint >> sys.stderr, \"The sequence file '%s' is unreadable\" % opts.sequence_file\n\t\t\texit(1)\n\t\t\t\n\t\tcontents = seq_file.read()\n\t\t# remove all whitespace from the file's contents\n\t\tsequence = ''.join(contents.split())\n\t\tif len(sequence) != nbases:\n\t\t\tprint >> sys.stderr, \"The length of the given sequence (%d) should be equal to the number of coordinates in the centerline file (%d)\" % (len(sequence), nbases)\n\t\t\texit(1)\n\t\t\t\n\t\tssdna1_base = map(lambda x: base.base_to_number[x], sequence)\t\t\n\t\t\t\n\t\tseq_file.close()\n\n\tstrand1 = base.Strand()\t\n\tfor c in range(nbases):\n\t\tb = ssdna1_base[c]\n\t\tstrand1.add_nucleotide(base.Nucleotide(ssdna1[c], v_perp_ssdna1[c], dist_norm[c], b, b))\n\tif opts.closed:\n\t\tstrand1.make_circular()\n\tsystem.add_strand(strand1)\n\n\tif opts.double:\n\t\tstrand2 = base.Strand()\n\t\tfor c in range(nbases):\n\t\t\treverse_idx = nbases - 1 - c\n\t\t\tb = 3 - ssdna1_base[reverse_idx]\n\t\t\tstrand2.add_nucleotide(base.Nucleotide(ssdna2[reverse_idx], v_perp_ssdna2[reverse_idx], -dist_norm[reverse_idx], b, b))\n\t\tif opts.closed and not opts.nicked:\n\t\t\tstrand2.make_circular()\n\t\tsystem.add_strand(strand2)\n\t\t\n\tbasename = os.path.basename(sys.argv[1])\n\ttopology_file = basename + \".top\"\n\tconfiguration_file = basename + \".oxdna\"\n\tsystem.print_lorenzo_output(configuration_file, topology_file)\n\t\n\tprint >> sys.stderr, \"## Wrote data to '%s' / '%s'\" % (configuration_file, topology_file)\n\tprint >> sys.stderr, \"## DONE\"\n", "meta": {"hexsha": "4523e9f7beea5df8778e16a6ff45f5b4d74c6223", "size": 7913, "ext": "py", "lang": "Python", "max_stars_repo_path": "supporting_scripts/tacoxDNA/src/XYZ_oxDNA.py", "max_stars_repo_name": "ItsTheSebbe/4vHelix_GUI", "max_stars_repo_head_hexsha": "6626d29bf9a2150b2ab49104918ab2faa5f45c30", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "supporting_scripts/tacoxDNA/src/XYZ_oxDNA.py", "max_issues_repo_name": "ItsTheSebbe/4vHelix_GUI", "max_issues_repo_head_hexsha": "6626d29bf9a2150b2ab49104918ab2faa5f45c30", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "supporting_scripts/tacoxDNA/src/XYZ_oxDNA.py", "max_forks_repo_name": "ItsTheSebbe/4vHelix_GUI", "max_forks_repo_head_hexsha": "6626d29bf9a2150b2ab49104918ab2faa5f45c30", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.1666666667, "max_line_length": 206, "alphanum_fraction": 0.6407178061, "include": true, "reason": "import numpy", "num_tokens": 2576, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.523420348936324, "lm_q2_score": 0.36658972248186, "lm_q1q2_score": 0.19188052045792536}} {"text": "#-------------------------------------------------------------------------------\n#\n# IGRF format parser\n#\n# Author: Martin Paces \n#\n#-------------------------------------------------------------------------------\n# Copyright (C) 2018 EOX IT Services GmbH\n#\n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# in the Software without restriction, including without limitation the rights\n# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n# copies of the Software, and to permit persons to whom the Software is\n# furnished to do so, subject to the following conditions:\n#\n# The above copyright notice and this permission notice shall be included in\n# all\n# copies of this Software or works derived from this Software.\n#\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n# THE SOFTWARE.\n#-------------------------------------------------------------------------------\n\nfrom numpy import array\n\nIGRF_EXTRAPOLATION_PERIOD = 5.0 # years\n\n\ndef parse_igrf_file(file_in):\n \"\"\" Parse IGRF file format and return a dictionary containing the parsed\n model data.\n \"\"\"\n lines = strip_igrf_comments(file_in)\n data = {}\n data[\"labels\"] = parse_igrf_header(next(lines))\n data[\"t\"] = parse_igrf_times(next(lines))\n data[\"nm\"], data[\"gh\"] = parse_igrf_coefficients(lines)\n data[\"degree_min\"] = data[\"nm\"][:, 0].min()\n data[\"degree_max\"] = data[\"nm\"][:, 0].max()\n return data\n\n\ndef parse_igrf_coefficients(lines):\n \"\"\" Parse IGRF coefficients. \"\"\"\n nm_idx = []\n coeff = []\n for line in lines:\n fields = line.split()\n label, n_idx, m_idx = fields[0], int(fields[1]), int(fields[2])\n if label == \"h\":\n m_idx = -m_idx\n nm_idx.append((n_idx, m_idx))\n coeff.append([float(v) for v in fields[3:]])\n coeff = array(coeff)\n coeff[:, -1] = coeff[:, -2] + coeff[:, -1] * IGRF_EXTRAPOLATION_PERIOD\n return array(nm_idx), coeff\n\n\ndef parse_igrf_times(line):\n \"\"\" Parse SHC times. \"\"\"\n times = [float(v) for v in line.split()[3:-1]]\n times.append(times[-1] + IGRF_EXTRAPOLATION_PERIOD)\n return array(times)\n\n\ndef parse_igrf_header(line):\n \"\"\" Parse IGRF header with the column labels. \"\"\"\n return line.split()\n\n\ndef strip_igrf_comments(file_in):\n \"\"\" Strip initial comments and empty lines from a text file stream. \"\"\"\n for line in file_in:\n line = line.partition(\"#\")[0].strip()\n if line:\n yield line\n break\n for line in file_in:\n line = line.strip()\n yield line\n", "meta": {"hexsha": "2eaa2aac5b543109e62edff366b82bfa32b762c3", "size": 3072, "ext": "py", "lang": "Python", "max_stars_repo_path": "geoist/magmod/magnetic_model/parser_igrf.py", "max_stars_repo_name": "CHEN-Zhaohui/geoist", "max_stars_repo_head_hexsha": "06a00db3e0ed3d92abf3e45b7b3bfbef6a858a5b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 53, "max_stars_repo_stars_event_min_datetime": "2018-11-17T03:29:55.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-18T02:36:25.000Z", "max_issues_repo_path": "geoist/magmod/magnetic_model/parser_igrf.py", "max_issues_repo_name": "CHEN-Zhaohui/geoist", "max_issues_repo_head_hexsha": "06a00db3e0ed3d92abf3e45b7b3bfbef6a858a5b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2018-11-28T11:37:51.000Z", "max_issues_repo_issues_event_max_datetime": "2019-01-30T01:52:45.000Z", "max_forks_repo_path": "geoist/magmod/magnetic_model/parser_igrf.py", "max_forks_repo_name": "CHEN-Zhaohui/geoist", "max_forks_repo_head_hexsha": "06a00db3e0ed3d92abf3e45b7b3bfbef6a858a5b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 35, "max_forks_repo_forks_event_min_datetime": "2018-11-17T03:29:57.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-23T17:57:06.000Z", "avg_line_length": 35.3103448276, "max_line_length": 80, "alphanum_fraction": 0.6236979167, "include": true, "reason": "from numpy", "num_tokens": 722, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.523420348936324, "lm_q2_score": 0.36658972248186, "lm_q1q2_score": 0.19188052045792536}} {"text": "#! /usr/bin/env python\n\"\"\"\nagilent4155_matlab_param.py\nPrarmeter extractor for matlab generated .xlsx files\n\nCreated by Jeremy Smith on 2015-07-07\nUniversity of California, Berkeley\nj-smith@eecs.berkeley.edu\n\"\"\"\n\nimport os\nimport sys\nimport xlrd\nimport numpy as np\nimport myfunctions as mf\nfrom scipy import stats\n\n__author__ = \"Jeremy Smith\"\n__version__ = \"1.5\"\n\ndata_path = os.path.dirname(__file__) # Path name for location of script\n\nfiles = os.listdir(data_path) # All files in directory\ndata_summary = []\ncolheads = ['VG', 'ID1', 'ID2', 'IG1', 'IG2']\nskipinit = 3 # skip initial data points \nrangefittop = 20.0 # % from max for fit range\nrangefitbot = 20.0 # % from min for fit range\nmobilitycorrection = 1.000 # K_actual/K_file\nsummary_list_header = [[\"filename\", \"satmob_tmax\", \"vthsat_tmax\", \"satmob_rev_tmax\", \"vthsat_rev_tmax\",\n\t\t\t\t\t\t\"linmob_tmax\", \"vthlin_tmax\", \"linmob_rev_tmax\", \"vthlin_rev_tmax\",\n\t\t\t\t\t\t\"hysteresis_lin\", \"hysteresis_sat\",\n\t\t\t\t\t\t\"onoffratio_lin\", \"onoffratio_sat\",\n\t\t\t\t\t\t\"leakage_ratio_lin\", \"leakage_ratio_sat\",\n\t\t\t\t\t\t\"Slin\", \"Slin_rev\", \"Ssat\", \"Ssat_rev\",\n\t\t\t\t\t\t\"satmob_FITTED\", \"vthsat_FITTED\", \"r_value\"]]\nsweepfwddirection = True # True if sweeping from depletion to accumulation\n\ndef main():\n\t\"\"\"Main function\"\"\"\n\n\tprint \"\\nBatch importing .xlsx files...\"\n\tprint data_path, '\\n'\n\n\tfor f in files:\n\t\tprint f\n\t\t# Loops through all transfer files\n\t\tif \"IDVG.xlsx\" in f:\n\n\t\t\tworkbook = xlrd.open_workbook(f, logfile=open(os.devnull, 'w'))\n\n\t\t\tfor dev in workbook.sheet_names():\n\t\t\t\tif \"Sheet\" in dev:\n\t\t\t\t\tcontinue\n\t\t\t\tprint \" - device {:s}\".format(dev)\n\t\t\t\tdatasheet = workbook.sheet_by_name(dev)\n\t\t\t\trun_numbers = [str(int(x)) for x in datasheet.row_values(2) if x]\n\n\t\t\t\tfor i, run in enumerate(run_numbers):\n\t\t\t\t\tprint \" - run {:s}\".format(run)\n\t\t\t\t\tdata = {}\n\t\t\t\t\t# File name for outputs\n\t\t\t\t\toutname = f[:-5] + '_' + dev + '_' + run\n\t\t\t\t\t# Constant parameters taken from header of .xlsx file\n\t\t\t\t\tvd1 = float(datasheet.cell_value(3, 6*i + 3))\n\t\t\t\t\tvd2 = float(datasheet.cell_value(4, 6*i + 3))\n\t\t\t\t\tchl = float(datasheet.cell_value(1, 1))\n\t\t\t\t\tchw = float(datasheet.cell_value(0, 1))\n\t\t\t\t\ttox = float(datasheet.cell_value(1, 3))\n\t\t\t\t\tkox = float(datasheet.cell_value(0, 3))\n\t\t\t\t\tldr = float(datasheet.cell_value(1, 5))\n\t\t\t\t\tlso = float(datasheet.cell_value(0, 5))\n\t\t\t\t\t# Calculation of geometric capacitance\n\t\t\t\t\tci = 8.85418782e-7*kox/tox\n\t\t\t\t\t# Extract data\n\t\t\t\t\tfor h in colheads:\n\t\t\t\t\t\tdata[h] = []\n\t\t\t\t\tfor row in range(datasheet.nrows - 9):\n\t\t\t\t\t\tfor col, h in enumerate(colheads):\n\t\t\t\t\t\t\tif datasheet.cell_type(9 + row, 6*i + col) is 0:\n\t\t\t\t\t\t\t\tcontinue\n\t\t\t\t\t\t\tdata[h].append(float(datasheet.cell_value(9 + row, 6*i + col)))\n\t\t\t\t\tp = len(data['VG'])/2\n\t\t\t\t\t# Forward scan\n\t\t\t\t\tif sweepfwddirection:\n\t\t\t\t\t\tvg = np.array(data['VG'][:p])\n\t\t\t\t\t\tid1 = np.array(data['ID1'][:p])\n\t\t\t\t\t\tid2 = np.array(data['ID2'][:p])\n\t\t\t\t\t\tig1 = np.array(data['IG1'][:p])\n\t\t\t\t\t\tig2 = np.array(data['IG2'][:p])\n\t\t\t\t\telse:\n\t\t\t\t\t\tvg = np.array(data['VG'][:p][::-1])\n\t\t\t\t\t\tid1 = np.array(data['ID1'][:p][::-1])\n\t\t\t\t\t\tid2 = np.array(data['ID2'][:p][::-1])\n\t\t\t\t\t\tig1 = np.array(data['IG1'][:p][::-1])\n\t\t\t\t\t\tig2 = np.array(data['IG2'][:p][::-1])\n\t\t\t\t\t# Reverse scan\n\t\t\t\t\tif sweepfwddirection:\n\t\t\t\t\t\tvg_r = np.array(data['VG'][p:][::-1])\n\t\t\t\t\t\tid1_r = np.array(data['ID1'][p:][::-1])\n\t\t\t\t\t\tid2_r = np.array(data['ID2'][p:][::-1])\n\t\t\t\t\t\tig1_r = np.array(data['IG1'][p:][::-1])\n\t\t\t\t\t\tig2_r = np.array(data['IG2'][p:][::-1])\n\t\t\t\t\telse:\n\t\t\t\t\t\tvg_r = np.array(data['VG'][p:])\n\t\t\t\t\t\tid1_r = np.array(data['ID1'][p:])\n\t\t\t\t\t\tid2_r = np.array(data['ID2'][p:])\n\t\t\t\t\t\tig1_r = np.array(data['IG1'][p:])\n\t\t\t\t\t\tig2_r = np.array(data['IG2'][p:])\n\n\t\t\t\t\t# Smoothing Id for fitting\n\t\t\t\t\tid1_smoothed = mf.adjAvSmooth(abs(id1), N=1)\n\t\t\t\t\tid2_smoothed = mf.adjAvSmooth(abs(id2), N=1)\n\t\t\t\t\tid1_r_smoothed = mf.adjAvSmooth(abs(id1_r), N=1)\n\t\t\t\t\tid2_r_smoothed = mf.adjAvSmooth(abs(id2_r), N=1)\n\t\t\t\t\t# On-off ratio\n\t\t\t\t\tonoffratio1 = np.log10(max(id1[skipinit:-1])/min(abs(id1[skipinit:-1])))\n\t\t\t\t\tonoffratio2 = np.log10(max(id2[skipinit:-1])/min(abs(id2[skipinit:-1])))\n\t\t\t\t\t# Leakage ratio\n\t\t\t\t\tleakage_ratio1 = np.log10(abs(id1/ig1))\n\t\t\t\t\tleakage_ratio2 = np.log10(abs(id2/ig2))\n\n\t\t\t\t\t# Finding max saturation transconductance\n\t\t\t\t\tsqrtid2 = np.sqrt(id2_smoothed)\n\t\t\t\t\tsqrtid2_r = np.sqrt(id2_r_smoothed)\n\t\t\t\t\tdiff_sqrt_id2_smoothed = np.array(mf.numDiff(sqrtid2, vg))\n\t\t\t\t\tdiff_sqrt_id2_r_smoothed = np.array(mf.numDiff(sqrtid2_r, vg_r))\n\t\t\t\t\ttsmaxarg = np.argmax(diff_sqrt_id2_smoothed[skipinit:-1]) + skipinit\n\t\t\t\t\ttsmaxarg_r = np.argmax(diff_sqrt_id2_r_smoothed[skipinit:-1]) + skipinit\n\t\t\t\t\t# Saturation mobility (max transconductance)\n\t\t\t\t\tsatmob_t = mobilitycorrection * (2*chl/(chw*ci))*(diff_sqrt_id2_smoothed)**2\n\t\t\t\t\tsatmob_r_t = mobilitycorrection * (2*chl/(chw*ci))*(diff_sqrt_id2_r_smoothed)**2\n\t\t\t\t\tsatmob_tmax = satmob_t[tsmaxarg]\n\t\t\t\t\tsatmob_r_tmax = satmob_r_t[tsmaxarg_r]\n\t\t\t\t\t# Saturation threshold voltage (max transconductance)\n\t\t\t\t\tvthsat_tmax = vg[tsmaxarg] - sqrtid2[tsmaxarg]/diff_sqrt_id2_smoothed[tsmaxarg]\n\t\t\t\t\tvthsat_r_tmax = vg_r[tsmaxarg_r] - sqrtid2_r[tsmaxarg_r]/diff_sqrt_id2_r_smoothed[tsmaxarg_r]\n\t\t\t\t\t# Hysteresis\n\t\t\t\t\thysteresissat = vthsat_tmax - vthsat_r_tmax\n\t\t\t\t\t# Calculate subthreshold slopes\n\t\t\t\t\tsts_sat = min(abs(1/np.array(mf.numDiff([np.log10(abs(x)) for x in id2_smoothed[skipinit:-1]], vg[skipinit:-1]))))\n\t\t\t\t\tsts_r_sat = min(abs(1/np.array(mf.numDiff([np.log10(abs(x)) for x in id2_r_smoothed[skipinit:-1]], vg_r[skipinit:-1]))))\n\n\t\t\t\t\t# Finding max linear transconductance\n\t\t\t\t\tdiff_id1_smoothed = np.array(mf.numDiff(id1_smoothed, vg))\n\t\t\t\t\tdiff_id1_r_smoothed = np.array(mf.numDiff(id1_r_smoothed, vg_r))\n\t\t\t\t\ttlmaxarg = np.argmax(diff_id1_smoothed[skipinit:-1]) + skipinit\n\t\t\t\t\ttlmaxarg_r = np.argmax(diff_id1_r_smoothed[skipinit:-1]) + skipinit\n\t\t\t\t\t# Linear mobility (max transconductance)\n\t\t\t\t\tlinmob_t = mobilitycorrection * (chl/(chw*ci*vd1))*(diff_id1_smoothed)\n\t\t\t\t\tlinmob_r_t = mobilitycorrection * (chl/(chw*ci*vd1))*(diff_id1_r_smoothed)\n\t\t\t\t\tlinmob_tmax = linmob_t[tlmaxarg]\n\t\t\t\t\tlinmob_r_tmax = linmob_r_t[tlmaxarg_r]\n\t\t\t\t\t# Linear threshold voltage (max transconductance)\n\t\t\t\t\tvthlin_tmax = vg[tlmaxarg] - id1_smoothed[tlmaxarg]/diff_id1_smoothed[tlmaxarg]\n\t\t\t\t\tvthlin_r_tmax = vg_r[tlmaxarg_r] - id1_r_smoothed[tlmaxarg_r]/diff_id1_r_smoothed[tlmaxarg_r]\n\t\t\t\t\t# Hysteresis\n\t\t\t\t\thysteresislin = vthlin_tmax - vthlin_r_tmax\n\t\t\t\t\t# Calculate subthreshold slopes\n\t\t\t\t\tsts_lin = min(abs(1/np.array(mf.numDiff([np.log10(abs(x)) for x in id1_smoothed[skipinit:-1]], vg[skipinit:-1]))))\n\t\t\t\t\tsts_r_lin = min(abs(1/np.array(mf.numDiff([np.log10(abs(x)) for x in id1_r_smoothed[skipinit:-1]], vg_r[skipinit:-1]))))\n\n\t\t\t\t\t# Finds range of data that lies within the minimum+x% and the maximum-x% and also has a positive transconductance\n\t\t\t\t\tfitrange_id_lo = (1-rangefitbot/100.0)*min(sqrtid2[skipinit:-1]) + (rangefitbot/100.0)*max(sqrtid2[skipinit:-1])\n\t\t\t\t\tfitrange_id_hi = (1-rangefittop/100.0)*max(sqrtid2[skipinit:-1]) + (rangefittop/100.0)*min(sqrtid2[skipinit:-1])\n\t\t\t\t\tfitrange_bool = np.bitwise_and(np.bitwise_and(sqrtid2 > fitrange_id_lo, sqrtid2 < fitrange_id_hi), diff_sqrt_id2_smoothed > 0)\n\t\t\t\t\t# Checks that there are at least 3 data points to fit\n\t\t\t\t\tif sum(fitrange_bool) < 3:\n\t\t\t\t\t\tprint \" NOT ENOUGH DATA TO FIT\"\n\t\t\t\t\t\tsatmob_FITTED = np.nan\n\t\t\t\t\t\tvthsat_FITTED = np.nan\n\t\t\t\t\t\tr_value = np.nan\n\t\t\t\t\telse:\n\t\t\t\t\t\t# Linear Fitting to sqrt(Idrain)\n\t\t\t\t\t\tslope, intercept, r_value, p_value, std_err = stats.linregress(vg[fitrange_bool][skipinit:-1], sqrtid2[fitrange_bool][skipinit:-1])\n\t\t\t\t\t\tfitline = slope*vg + intercept\n\t\t\t\t\t\t# Saturation mobility (from slope of sqrt(Idrain) fit)\n\t\t\t\t\t\tsatmob_FITTED = mobilitycorrection * (2*chl/(chw*ci))*slope**2\n\t\t\t\t\t\t# Threshold Voltage (from slope of sqrt(Idrain) fit)\n\t\t\t\t\t\tvthsat_FITTED = -intercept/slope\n\t\t\t\t\t\t# Plot sqrt(Isd)\n\t\t\t\t\t\tmf.quickPlot(outname+\"_SQRTplot\", data_path, [vg, sqrtid2, fitline],\n\t\t\t\t\t\txlabel=\"VG [V]\", ylabel=\"sqrt(Id) [A^0.5]\", yrange=[0, 'auto'])\n\n\t\t\t\t\t# Output data\n\t\t\t\t\tdata_summary.append([outname,\n\t\t\t\t\t\tsatmob_tmax, vthsat_tmax,\n\t\t\t\t\t\tsatmob_r_tmax, vthsat_r_tmax,\n\t\t\t\t\t\tlinmob_tmax, vthlin_tmax,\n\t\t\t\t\t\tlinmob_r_tmax, vthlin_r_tmax,\n\t\t\t\t\t\thysteresislin, hysteresissat,\n\t\t\t\t\t\tonoffratio1, onoffratio2,\n\t\t\t\t\t\tleakage_ratio1[-skipinit],\n\t\t\t\t\t\tleakage_ratio2[-skipinit],\n\t\t\t\t\t\tsts_lin, sts_r_lin, sts_sat, sts_r_sat,\n\t\t\t\t\t\tsatmob_FITTED, vthsat_FITTED, r_value**2])\n\n\t\t\t\t\t# Ouput files\n\t\t\t\t\tmf.dataOutputHead(outname+\"_transfer.txt\", data_path, [np.array(data['VG']), abs(np.array(data['ID1'])), abs(np.array(data['ID2'])), abs(np.array(data['IG1'])), abs(np.array(data['IG2'])),\n\t\t\t\t\t\tnp.concatenate((linmob_t, linmob_r_t[::-1])), np.concatenate((satmob_t, satmob_r_t[::-1]))],\n\t\t\t\t\t\t[[\"vg\", \"idlin\", \"idsat\", \"iglin\", \"igsat\", \"LINMOB\", \"SATMOB\"]], \n\t\t\t\t\t\tformat_d=\"%.3f\\t %.5e\\t %.5e\\t %.5e\\t %.5e\\t %.5e\\t %.5e\\n\", \n\t\t\t\t\t\tformat_h=\"%s\\t\")\n\t\t\t\t\t\n\t\t\t\t\t# Plot transfer\n\t\t\t\t\tmf.quickPlot(outname+\"_TRANSFERplot\", data_path, [vg, id1_smoothed, id1_r_smoothed, abs(ig1), id2_smoothed, id2_r_smoothed, abs(ig2)],\n\t\t\t\t\t\txlabel=\"VG [V]\", ylabel=\"Id,g [A]\", yscale=\"log\", yrange=[1e-12, 1e-2], col=[\"r\", \"r\", \"r\", \"b\", \"b\", \"b\"])\n\n\tmf.dataOutputHead(\"SUMMARY.txt\", data_path, map(list, zip(*data_summary)), summary_list_header,\n\t\tformat_d=\"%s\\t %.5e\\t %.5f\\t %.5e\\t %.5f\\t %.5e\\t %.5f\\t %.5e\\t %.5f\\t %.5f\\t %.5f\\t %.5f\\t %.5f\\t %.5f\\t %.5f\\t %.5f\\t %.5f\\t %.5f\\t %.5f\\t %.5e\\t %.5f\\t %.6f\\n\", \n\t\tformat_h=\"%s\\t\")\n\n\treturn\n\n\nif __name__ == \"__main__\":\n\tsys.exit(main())\n", "meta": {"hexsha": "5ae5ad84fb48f9d07029041d84f361fa6d1f6203", "size": 9549, "ext": "py", "lang": "Python", "max_stars_repo_path": "agilent4155_matlab_param.py", "max_stars_repo_name": "jzmnd/fet-py-scripts", "max_stars_repo_head_hexsha": "c3709c1ed3078d3f9cc1eebc658814842a59e380", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "agilent4155_matlab_param.py", "max_issues_repo_name": "jzmnd/fet-py-scripts", "max_issues_repo_head_hexsha": "c3709c1ed3078d3f9cc1eebc658814842a59e380", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "agilent4155_matlab_param.py", "max_forks_repo_name": "jzmnd/fet-py-scripts", "max_forks_repo_head_hexsha": "c3709c1ed3078d3f9cc1eebc658814842a59e380", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.8027522936, "max_line_length": 193, "alphanum_fraction": 0.6526337836, "include": true, "reason": "import numpy,from scipy", "num_tokens": 3254, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5389832206876841, "lm_q2_score": 0.3557749071749625, "lm_q1q2_score": 0.19175670530902317}} {"text": "# coding=utf-8\n# Copyright (c) 2015-2018, UT-BATTELLE, LLC\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or without\n# modification, are permitted provided that the following conditions are met:\n#\n# 1. Redistributions of source code must retain the above copyright notice, this\n# list of conditions and the following disclaimer.\n#\n# 2. Redistributions in binary form must reproduce the above copyright notice,\n# this list of conditions and the following disclaimer in the documentation\n# and/or other materials provided with the distribution.\n#\n# 3. Neither the name of the copyright holder nor the names of its contributors\n# may be used to endorse or promote products derived from this software without\n# specific prior written permission.\n#\n# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\n# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\"\"\"\nCISM_glissade module for numerics analysis\n\"\"\"\nfrom __future__ import absolute_import, division, print_function, unicode_literals\n\nimport math\n\nimport numpy as np\n\nfrom netCDF4 import Dataset\nfrom scipy import interpolate\n\n\nclass DataGrid:\n \"\"\"\n Class to handle the CISM_glissade grids, which are cell-centered grids.\n \"\"\"\n def __init__(self, data):\n self.y = data.variables['y1']\n self.ny = self.y[:].shape[0]\n self.dy = self.y[1] - self.y[0]\n\n # NOTE: cell centered grids, hence the dy.\n self.Ly = self.y[-1] - self.y[0] + self.dy\n\n self.x = data.variables['x1']\n self.nx = self.x[:].shape[0]\n self.dx = self.x[1] - self.x[0]\n\n # NOTE: cell centered grids, hence the dx.\n self.Lx = self.x[-1] - self.x[0] + self.dx\n\n self.y_hat = (self.y[:] + self.y[0])/self.Ly\n self.x_hat = (self.x[:] + self.x[0])/self.Lx\n\n\nclass RotatedGrid:\n \"\"\"\n For the ISMIP-HOM f tests, CISM computes the flow of a glacier down an\n inclined plane:\n\n ::\n\n z\n ^\n |\n * .\n . .\n . .\n * .\n | . .\n | . ICE .\n | . .\n | . .\n | BED . .\n | . *\n | . .\n | . .\n | . .\n | *\n | |\n | |\n | |\n 0------------------------------------->x\n\n\n The origin is at point 0 in the above figure, and the topmost point of the\n glacier is at x=0, z=7 (in km). The slope is 3 degrees. The ice is 1000 m\n tall and flows down the inclined plane.\n\n ISMIP-HOM, however, defines the coordinate system with the origin located at\n the topmost point of the glacier (0,7) with the x' axis pointing down slope\n and z' pointing perpendicular to the slope. So the coordinate system is\n shifted, and rotated by a=3 degrees from the CISM glissade grid.\n\n An additional complication is that the surface is computed in CISM on the\n standard grid, but velocities are computed on a staggered, grid.\n\n This class converts the CISM_glissade coordinate system to the ISMIP-HOM\n coordinate system.\n \"\"\"\n def __init__(self, alpha, data):\n self.alpha = alpha\n self.y0 = data.variables['y0'][:]\n self.x0 = data.variables['x0'][:]\n\n self.usurf_ustag = data.variables['usurf'][-1,:,:]\n self.usurf_stag = ( self.usurf_ustag[1: , 1: ] + self.usurf_ustag[1: , :-1]\n + self.usurf_ustag[:-1, :-1] + self.usurf_ustag[:-1, 1: ]) / 4.0\n\n self.usurf = -(self.x0)*math.sin(alpha) + (self.usurf_stag-7000.0)*math.cos(alpha)\n\n self.uvel_stag = data.variables['uvel'][-1,0,:,:]\n self.vvel_stag = data.variables['uvel'][-1,0,:,:]\n\n try:\n self.wvel_ustag = data.variables['wvel_ho'][-1,0,:,:]\n except:\n self.wvel_ustag = data.variables['wvel'][-1,0,:,:]\n self.wvel_stag = ( self.wvel_ustag[1: , 1: ] + self.wvel_ustag[1: , :-1]\n + self.wvel_ustag[:-1, :-1] + self.wvel_ustag[:-1, 1: ]) / 4.0\n\n self.uvel = self.uvel_stag*math.cos(alpha) + self.wvel_stag*math.sin(alpha)\n self.vvel = -self.uvel_stag*math.sin(alpha) + self.wvel_stag*math.cos(alpha)\n\n self.x = (self.x0*math.cos(alpha)\n + (self.usurf_stag[20,:]-7000.0)*math.sin(alpha)\n )/1000.0 - 50.0\n self.y = self.y0/1000.0 - 50.0\n\n\ndef get_plot_data(test_file, bench_file, setup, config):\n test_plot_data = {}\n bench_plot_data = {}\n exp = config['name'].split('-')[-1]\n test_data = Dataset(test_file, 'r')\n bench_data = Dataset(bench_file, 'r')\n\n test = DataGrid(test_data)\n bench = DataGrid(bench_data)\n\n x_coord = setup['interp_points']\n y_coord = np.linspace(setup['y'][0], setup['y'][1], len(x_coord))\n\n test_plot_data['y_hat'] = y_coord\n test_plot_data['x_hat'] = x_coord\n bench_plot_data['y_hat'] = y_coord\n bench_plot_data['x_hat'] = x_coord\n\n if exp in ['a', 'c']:\n for var in config['interp_vars']:\n if var == 'usurf':\n # regular 2d linear interp. but faster.\n test2plot = interpolate.RectBivariateSpline(test.y_hat, test.x_hat,\n test_data.variables[var][-1,:,:],\n kx=1, ky=1, s=0)\n bench2plot = interpolate.RectBivariateSpline(bench.y_hat, bench.x_hat,\n bench_data.variables[var][-1,:,:],\n kx=1, ky=1, s=0)\n else:\n # regular 2d linear interp. but faster.\n test2plot = interpolate.RectBivariateSpline(test.y_hat, test.x_hat,\n test_data.variables[var][-1,0,:,:],\n kx=1, ky=1, s=0)\n bench2plot = interpolate.RectBivariateSpline(bench.y_hat, bench.x_hat,\n bench_data.variables[var][-1,0,:,:],\n kx=1, ky=1, s=0)\n\n test_plot_data[var] = test2plot(y_coord, x_coord, grid=False)\n bench_plot_data[var] = bench2plot(y_coord, x_coord, grid=False)\n\n test_plot_data['velnorm_extend'] = \\\n np.linalg.norm(\n np.array([test_plot_data['uvel_extend'],\n test_plot_data['vvel_extend'] ]),\n axis=0)\n bench_plot_data['velnorm_extend'] = \\\n np.linalg.norm(\n np.array([bench_plot_data['uvel_extend'],\n bench_plot_data['vvel_extend'] ]),\n axis=0)\n else: # f\n alpha = math.radians(-3.0)\n\n test_rotated = RotatedGrid(alpha, test_data)\n bench_rotated = RotatedGrid(alpha, bench_data)\n\n for var in config['interp_vars']:\n # regular 2d linear interp. but faster.\n test2plot = interpolate.RectBivariateSpline(test_rotated.x, test_rotated.y,\n getattr(test_rotated, var),\n kx=1, ky=1, s=0)\n bench2plot = interpolate.RectBivariateSpline(bench_rotated.x, bench_rotated.y,\n getattr(bench_rotated, var),\n kx=1, ky=1, s=0)\n\n test_plot_data[var] = test2plot(y_coord, x_coord, grid=False)\n bench_plot_data[var] = bench2plot(y_coord, x_coord, grid=False)\n\n test_plot_data['velnorm'] = \\\n np.linalg.norm(\n np.array([test_plot_data['uvel'],\n test_plot_data['vvel'] ]),\n axis=0)\n bench_plot_data['velnorm'] = \\\n np.linalg.norm(\n np.array([bench_plot_data['uvel'],\n bench_plot_data['vvel'] ]),\n axis=0)\n\n return {'test': test_plot_data, 'bench': bench_plot_data}\n", "meta": {"hexsha": "1fbd088aa0f95e399caa0a71d6259ce024ccfab8", "size": 9063, "ext": "py", "lang": "Python", "max_stars_repo_path": "livvkit/bundles/CISM_glissade/numerics.py", "max_stars_repo_name": "jhkennedy/LIVVkit", "max_stars_repo_head_hexsha": "680120cd437e408673e62e535fc0a246c7fc17db", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "livvkit/bundles/CISM_glissade/numerics.py", "max_issues_repo_name": "jhkennedy/LIVVkit", "max_issues_repo_head_hexsha": "680120cd437e408673e62e535fc0a246c7fc17db", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "livvkit/bundles/CISM_glissade/numerics.py", "max_forks_repo_name": "jhkennedy/LIVVkit", "max_forks_repo_head_hexsha": "680120cd437e408673e62e535fc0a246c7fc17db", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.1954545455, "max_line_length": 97, "alphanum_fraction": 0.5407701644, "include": true, "reason": "import numpy,from scipy", "num_tokens": 2149, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5389832206876841, "lm_q2_score": 0.35577490034429643, "lm_q1q2_score": 0.19175670162740874}} {"text": "\"\"\"\n Qunantum Transport simulator using QUEST.\n Copyright (C) 2014 K M Masum Habib \n\n Last update: 05/12/2014\n\"\"\"\n\nimport os\nimport pickle as pk\nimport numpy as np\nimport random as rn\n\nfrom quest import setVerbosity, greet, vprint\nfrom quest.vprint import nprint, dprint, eprint\nfrom quest.linspace import linspace\nfrom quest.atoms import AtomicStruct, SVec, LCoord\nfrom quest.hamiltonian import TISurfKpParams4, TISurfKpParams, TI3DKpParams, GrapheneKpParams, GrapheneOneValleyKpParams, GrapheneTwoValleyKpParams, GrapheneTbParams, generateHamOvl\nfrom quest.negf import CohRgfLoop\nfrom quest.kpoints import KPoints\nfrom quest.potential import LinearPot\nfrom quest.utils import Timer, Workers, Quadrilateral, Point\n\nclass Transport(object):\n \"\"\"\n Qunantum Transport simulator using QUEST.\n \n * Device geometry:\n ----------------------------------------\n ... |-1 | 0 | 1 | ... | N |N+1|N+2| ...\n ----------------------------------------\n ^ <------^------> ^\n left Device right\n contact contact\n\n Notes:\n 1. Coherent RGF calculation for non-uniform devices requires at least \n 5 blocks: 1 source block, 1 drain block and 3 device blocks as \n shown in the following fig:\n\n --------------------------\n | 0 | 1 | 2 | 3 | 4 |\n --------------------------\n ^ <---------> ^\n source Device drain \n\n Block 0 and block 1 has to be identical. \n Simularly, block 3 and block 4 hast to be identical.\n\n 2. Any uniform device needs atleast 3 blocks: two contact\n blocks and one device block.\n \n Attributes:\n \n \n \"\"\"\n\n def __init__(self, workers = None): \n \"\"\" \n Class constructor. \n param:\n workers: mpi.world - MPI world communicator.\n \"\"\" \n\n self.verbosity = vprint.MSG_NORMAL # Verbosity level\n \n # MPI stuff\n if workers is None:\n self.workers = Workers()\n else:\n self.workers = Workers(workers)\n vprint.IAmMaster = self.workers.IAmMaster()\n \n # Timer\n self.clock = Timer()\n\n # output path settings\n self.OutPath = \"./out/\" # Output path\n self.OutFileName = \"TR\" # Output file name prefix\n \n # Bias\n self.VDD = np.zeros(1) # Drain bias\n self.VGG = np.zeros(1) # Gate bias\n self.Vo = 0.0 # Built in potential\n \n # Device geometry\n self.nb = 11 # Length of the device+contacts\n self.nw = 9 # Width of the device\n self.nh = 1\n self.nbw = [] # Width of all layers\n\n # for k-loop\n self.nk2 = 0 # number of k points along a2 \n self.kp = KPoints() # K point generator\n \n # Hamiltonian type\n self.HAM_TI_SURF_KP = 10 # TI surface k.p hamiltonian\n self.HAM_TI_SURF_KP4 = 11 # TI surface k.p hamiltonian with 4 spin basis set\n self.HAM_TI_3D_KP = 15 # TI 3D k.p hamiltonian with 4 spin basis set \n self.HAM_GRAPHENE_KP = 20 # Graphene k.p Hamiltonian\n self.HAM_GRAPHENE_TWO_VALLEY_KP = 21 # Graphene k.p Hamiltonian\n self.HamType = self.HAM_TI_SURF_KP \n \n # Device types\n self.COH_RGF_UNI = 10 # Coherent uniform RGF type device\n self.COH_RGF_NON_UNI= 20 # Coherent Non-uniform RGF type device\n self.DevType = self.COH_RGF_UNI\n \n # Potential profile type\n self.POT_LINEAR = 10 # Linear potential model\n self.PotType = self.POT_LINEAR \n \n # Calculations\n self.Calculations = {}\n self.Calculations[\"TE\"] = 1\n \n # \n self.kT = 0.0259 # Temperature in eV (300 K)\n self.ieta = 1E-3j # Contact imaginary potential\n self.mu = 0.0 # Device Fermi level\n self.OrthoBasis = True # Orthogonal basis?\n self.Emin =-1.0 # Minimum energy \n self.Emax = 1.0 # Maximum energy\n self.dE = 0.005 # Energy step\n self.AutoGenE = False # Generate grid automatically?\n \n # Debug stuffs\n self.DebugPotFile = \"dbg_pot.dat\"\n self.DebugGeomFile = \"dbg_geom.svg\"\n \n # Dry run\n self.DryRun = False\n \n # Skip if resulting dat file already exists?\n self.SkipExistingSimulation = False\n\n # Print welcome message.\n nprint(greet())\n\n @property \n def verbosity(self):\n return self._verbosity \n @verbosity.setter\n def verbosity(self, value):\n self._verbosity = value\n # Set verbosity level of QUEST library.\n setVerbosity(self._verbosity)\n vprint.verbosity = self._verbosity\n \n def muS(self, VDD):\n \"\"\"Calculates the fermi energy level of the source.\"\"\"\n return self.mu - VDD*self.V.rVS\n \n def muD(self, VDD):\n \"\"\"Calculates the drain energy level of the source.\"\"\"\n return self.mu - VDD*self.V.rVD\n \n \n def VG(self, VGG, Vo, ig):\n \"\"\" Computes the gate voltage of gate #ig. \"\"\"\n # Set gate voltages\n return VGG*self.V.rVG[ig] + Vo*self.V.rVo[ig]\n \n def addSource(self, sql, rVS = -0.5):\n \"\"\" Adds a source contact to the device for electrostatics calculation.\"\"\"\n self.V.addSource(sql)\n self.V.rVS = rVS\n # just for pickling\n self.V.sql = sql \n \n def addDrain(self, dql, rVD = 0.5):\n \"\"\" Adds a drain contact to the device for electrostatics calculation.\"\"\"\n self.V.addDrain(dql)\n self.V.rVD = rVD\n # just for pickling\n self.V.dql = dql \n\n def addGate(self, gql, rVo = 1, rVG = 1):\n \"\"\" Adds a gate to the device for electrostatics calculation.\"\"\"\n self.V.addGate(gql)\n self.V.rVG.append(rVG)\n self.V.rVo.append(rVo)\n # just for pickling\n self.V.gql.append(gql) \n\n def addLinearRegion(self, lql):\n \"\"\" Adds a linear region to the device for electrostatics calculation.\"\"\"\n self.V.addLinearRegion(lql)\n # just for pickling\n self.V.lql.append(lql) \n \n def createAtomicGeom(self):\n \"\"\" Creates atomistic geometry. \"\"\"\n\n nprint(\"\\n Creating atomistic geometry ...\")\n\n if not hasattr(self, \"hp\"): # if hp does not exist, create it.\n if self.HamType == self.HAM_TI_SURF_KP:\n self.hp = TISurfKpParams()\n elif self.HamType == self.HAM_TI_SURF_KP4:\n self.hp = TISurfKpParams4()\n elif self.HamType == self.HAM_TI_3D_KP:\n self.hp = TI3DKpParams()\n elif self.HamType == self.HAM_GRAPHENE_KP:\n self.hp = GrapheneOneKpParams()\n elif self.HamType == self.HAM_GRAPHENE_TWO_VALLEY_KP:\n self.hp = GrapheneTwoKpParams()\n else:\n raise RuntimeError(\" Unsupported Hamiltonian type. \")\n\n dev = AtomicStruct(self.hp.ptable)\n dev.genSimpleCubicStruct(self.hp.ptable[0], self.hp.a, self.nb-2, self.nw, self.nh)\n\n if not hasattr(self, \"nlc\"):\n self.nlc = self.nw\n\n if not hasattr(self, \"nrc\"):\n self.nrc = self.nw\n\n cont_left = AtomicStruct(self.hp.ptable)\n cont_left.genSimpleCubicStruct(self.hp.ptable[0], self.hp.a, 1, self.nlc, self.nh)\n xs = dev.xmin\n cont_left += np.array([xs, 0, 0])\n cont_left += LCoord(-1, 0, 0)\n\n cont_right = AtomicStruct(self.hp.ptable)\n cont_right.genSimpleCubicStruct(self.hp.ptable[0], self.hp.a, 1, self.nrc, self.nh)\n xs = dev.xmax\n cont_right += np.array([xs, 0, 0])\n cont_right += LCoord(1, 0, 0)\n\n self.geom = cont_left + dev + cont_right\n self.lyr_0 = cont_left\n self.lyr_nbm1 = cont_right\n cont_left += LCoord(-1, 0, 0)\n cont_right += LCoord(1, 0, 0)\n self.lyr_0m1 = cont_left\n self.lyr_nb = cont_right\n\n self.nbw = [self.nw]*self.nb\n self.nbw[0] = self.nlc\n self.nbw[self.nb-1] = self.nrc\n self.updateBoundingBox()\n\n nprint(\" done.\")\n\n def createRoughEdges(self, sigma):\n \"\"\" \n Creates rough edges. Works only for sorted lattice points.\n For rectangular lattice \n \"\"\"\n\n nprint(\"\\n Creating rough edges ...\")\n\n if (self.HamType == self.HAM_TI_SURF_KP \n or self.HamType == self.HAM_TI_SURF_KP4\n or self.HamType == self.HAM_GRAPHENE_KP\n or self.HamType == self.HAM_GRAPHENE_TWO_VALLEY_KP):\n nw = []\n geom = AtomicStruct()\n beg = 0\n # loop through the layers and \n # remove some atoms randomly from the edges.\n for ib in range(0, self.nb):\n end = beg + self.nw - 1\n lyr = self.geom.span(beg, end)\n beg = end + 1\n \n if ( ib > 1 and ib < self.nb - 2):\n # Remove or add some atoms from the bottom edge.\n nr = int(rn.gauss(0, sigma))\n while abs(nr) > 3*sigma:\n nr = int(rn.gauss(0, sigma))\n if nr <= 0: \n lyr = lyr.span(abs(nr), lyr.NumOfAtoms - 1)\n else:\n xtra = lyr.span(0, nr-1)\n lv = SVec(0, - self.hp.ay*nr, 0)\n xtra = xtra + lv\n lyr = xtra + lyr \n \n # Remove or add some atoms from the top edge\n nr = int(rn.gauss(0, sigma))\n while abs(nr) > 3*sigma:\n nr = int(rn.gauss(0, sigma))\n if nr <= 0: \n lyr = lyr.span(0, lyr.NumOfAtoms - 1 - abs(nr))\n else:\n xtra = lyr.span(lyr.NumOfAtoms - nr, lyr.NumOfAtoms - 1)\n lv = SVec(0, self.hp.ay*nr, 0)\n xtra = xtra + lv\n lyr = lyr + xtra\n \n # save this layer\n geom = geom + lyr\n nw.append(lyr.NumOfAtoms)\n \n # save geometry\n self.geom = geom\n self.nbw = nw\n self.DevType = self.COH_RGF_NON_UNI\n \n # update bounding box\n self.updateBoundingBox()\n\n else: \n raise RuntimeError(\" Unsupported Hamiltonian type. \")\n\n nprint(\" done.\")\n \n def generateHamiltonian(self):\n \"\"\" Generates hamiltonian and overlap matrices. \"\"\"\n\n nprint(\"\\n Generating Hamiltonian matrix ...\")\n\n # For uniform RGF blocks\n if (self.DevType == self.COH_RGF_UNI): \n # no k-loop, real space hamiltonian only\n if self.kp.N == 0:\n \n lyr0 = self.geom.span(0, self.nw*self.nh-1) # extract block # 0\n lyr1 = self.geom.span(self.nw*self.nh, 2*self.nw*self.nh-1) # extract block # 1\n \n self.H0, self.S0 = generateHamOvl(self.hp, lyr0, lyr0)\n\n self.Hl, S = generateHamOvl(self.hp, lyr1, lyr0)\n\n# np.set_printoptions(linewidth=200)\n# print \"\\nS0\\n\"\n# print self.S0\n# print \"\\nH0\\n\"\n# print self.H0\n# print \"\\nHl\\n\"\n# print self.Hl\n# self.geom.exportGjf('dbg_geom.gjf')\n# lyr0.exportGjf('lyr0.gjf')\n# lyr1.exportGjf('lyr1.gjf')\n# lyr01 = lyr0+lyr1;\n# lyr01.exportGjf('lyr01.gjf')\n \n # nearest neighbors in transverse direction for k-loop\n else:\n self.H0 = []\n self.S0 = []\n self.Hl = []\n self.pv = []\n self.pvl = []\n \n lv = self.geom.LatticeVector\n self.pv.append(lv*LCoord(0,0,0))\n self.pvl.append(lv*LCoord(0,0,0))\n lyr0 = self.geom.span(0, self.nw*self.nh-1) # extract block # 0\n lyr1 = self.geom.span(self.nw*self.nh, 2*self.nw*self.nh-1) # extract block # 1\n \n H, S = generateHamOvl(self.hp, lyr0, lyr0)\n self.H0.append(H); self.S0.append(S)\n H, S = generateHamOvl(self.hp, lyr1, lyr0)\n self.Hl.append(H)\n \n self.pv.append(lv*LCoord(0,1,0))\n lyr0top = lyr0 + self.pv[1] # top neighbor of layer 0\n H, S = generateHamOvl(self.hp, lyr0, lyr0top)\n self.H0.append(H)\n \n self.pv.append(lv*LCoord(0, -1, 0))\n lyr0bot = lyr0 + self.pv[2] # bottom neighbor of layer 0\n H, S = generateHamOvl(self.hp, lyr0, lyr0bot)\n self.H0.append(H)\n \n self.pvl.append(lv*LCoord(-1,1,0))\n H, S = generateHamOvl(self.hp, lyr1, lyr0top)\n self.Hl.append(H)\n \n self.pvl.append(lv*LCoord(-1,-1,0))\n H, S = generateHamOvl(self.hp, lyr1, lyr0bot) \n self.Hl.append(H)\n # Non-uniform RGF blocks \n elif (self.DevType == self.COH_RGF_NON_UNI):\n self.H0 = []\n self.S0 = []\n self.Hl = []\n beg = 0\n for ib in range(0, self.nb): # setup the block hamiltonian\n end = beg + self.nbw[ib] - 1\n \n # generate H_i,i and S_i,i\n lyri = self.geom.span(beg, end) # extract block # i\n H0,S0 = generateHamOvl(self.hp, lyri, lyri)\n self.H0.append(H0)\n self.S0.append(S0)\n\n # generate H_i,i-1\n if ib > 0:\n Hl,Sl = generateHamOvl(self.hp, lyri, lyrim1)\n self.Hl.append(Hl)\n \n lyrim1 = lyri\n beg = end + 1\n # Coupling matrix between two blocks of left contact\n Hl,Sl = generateHamOvl(self.hp, self.lyr_0, self.lyr_0m1)\n self.Hl.insert(0, Hl)\n # Coupling matrix between two blocks of right contact\n Hl,Sl = generateHamOvl(self.hp, self.lyr_nb, self.lyr_nbm1)\n self.Hl.append(Hl)\n\n nprint(\" done.\")\n \n def setupPotential(self):\n \"\"\" Sets up the potential profile \"\"\"\n\n nprint(\"\\n Setting up potential ...\")\n # Linear\n if (self.PotType == self.POT_LINEAR):\n self.V = LinearPot(self.geom)\n nprint(\" done.\")\n \n def check(self):\n ret = True\n if (self.DevType == self.COH_RGF_UNI):\n ret = ret and (self.nb >= 3)\n if (self.DevType == self.COH_RGF_NON_UNI):\n ret = ret and (self.nb >= 5)\n \n return ret\n\n def runBiasStep(self, VGG, Vo, VDD): \n \"\"\"Runs the sumulation.\"\"\"\n\n # Set drain and Fermi levels\n self.rgf.mu(self.muD(VDD), self.muS(VDD))\n \n nprint(\"\\n Bias loop:\") \n nprint(\"\\n VGG = \" + str(VGG) + \", Vo = \" + str(Vo) \n + \", VDD = \" + str(VDD) + \".\")\n \n fileName = self.OutFileName + \"_VGG{0:2.3f}_Vo{1:2.3f}_VDD{2:2.3f}\".format(VGG, Vo, VDD)\n\n # skip calculation if result file exists.\n if self.SkipExistingSimulation == True:\n if os.path.isfile(self.OutPath + fileName + \".dat\"):\n nprint(\"\\n Result exists, skipping.\")\n return\n \n # Set gate voltages\n for ig in range(self.V.NG):\n VG = self.VG(VGG, Vo, ig)\n # bias voltage for gate # ig\n self.V.VG(ig, VG)\n # For linear potential profile\n if (self.PotType == self.POT_LINEAR):\n # set potential of source\n if (ig == 0):\n self.V.VS(VG)\n # set potential of drain\n if (ig == self.V.NG - 1):\n self.V.VD(VG)\n \n # Potential of linear region\n if (self.PotType == self.POT_LINEAR):\n for il in range(self.V.NLR):\n VG1 = self.VG(VGG, Vo, il)\n VG2 = self.VG(VGG, Vo, il+1)\n self.V.VLR(il, VG1, VG2) \n\n # Print some useful information\n nprint(\"\\n\")\n nprint(self.dynamicnstr())\n \n # Compute the electrostatic potential\n self.V.compute()\n eprint(self.V)\n \n # Save the calculated potential.\n if (self.verbosity >= vprint.MSG_DEBUG):\n if (self.workers.IAmMaster()):\n # Create directory if not exist.\n if not os.path.exists(self.OutPath):\n os.makedirs(self.OutPath) \n self.V.exportPotential(self.OutPath + self.DebugPotFile)\n \n # Export potential to NEGF\n beg = 0\n self.Vo = []\n for ib in range(self.nb): # setup the block hamiltonian\n end = beg + self.nbw[ib]*self.nh - 1\n self.Vo.append(self.V.toOrbPot(beg, end)) \n self.rgf.V(self.Vo[ib], ib)\n beg = end + 1\n \n \n # Create energy grid\n if (self.AutoGenE):\n Emin = self.muD(VDD) - 10*self.kT\n Emax = self.muS(VDD) + 10*self.kT\n else:\n Emin = self.Emin\n Emax = self.Emax\n \n EE = linspace(Emin, Emax, self.dE)\n\n \n nprint(\"\\n Energy grid:\\n Min: \" + str(Emin) + \", max: \" \n + str(Emax) + \", interval \" + str(self.dE)\n + \".\")\n nprint(\"\\n Total \" + str(len(EE)) + \" energy point(s) \" \n + \"running on \" + str(self.workers.N()) + \" CPU(s): \" \n + str(int(round(len(EE)/self.workers.N()))) + \" pts/CPU ... \\n\")\n \n # Set energy\n self.rgf.E(EE)\n\n # Run the simulation\n if (self.DryRun == False):\n self.rgf.run()\n nprint(\"\\n done.\")\n \n nprint(\"\\n Saving results to disk ...\")\n # save results\n if (self.workers.IAmMaster()):\n # Create directory if not exist.\n if not os.path.exists(self.OutPath):\n os.makedirs(self.OutPath) \n # save results to file.\n if (self.DryRun == False):\n fo = open(self.OutPath + fileName + \".dat\", \"wt\")\n fo.close()\n self.rgf.save(self.OutPath + fileName + \".dat\") \n\n nprint(\" done.\\n\")\n nprint(\" ------------------------------------------------------------------\")\n \n def run(self):\n \"\"\"Runs the sumulation.\"\"\"\n\n self.clock.tic()\n \n nprint(\"\\n\\n Starting simulation ...\")\n\n # Print simulation info\n nprint(self.staticnstr())\n eprint(self.debugstr())\n \n if (self.check() == False):\n raise error(\" ERROR: Check failed !!!\") \n \n # Debug print\n dprint(\"\\n\" + str(self.VDD))\n dprint(\"\\n\" + str(self.VGG))\n\n # save simulation parameters\n if (self.workers.IAmMaster()):\n # Create directory if not exist.\n if not os.path.exists(self.OutPath):\n os.makedirs(self.OutPath) \n # save simulation parameters to a pickle file\n fp = open(self.OutPath + self.OutFileName + \".pkl\", 'wb')\n pk.dump(self, fp)\n fp.close() \n\n # Save electrostatic geometry\n if (self.verbosity >= vprint.MSG_DEBUG):\n if (self.workers.IAmMaster()):\n # Create directory if not exist.\n if not os.path.exists(self.OutPath):\n os.makedirs(self.OutPath) \n self.V.exportSvg(self.OutPath + self.DebugGeomFile)\n \n # Configure the RGF solver\n if self.kp.N == 0: # without k-loop\n self.rgf = CohRgfLoop(self.workers, self.nb, self.kT, self.ieta, \n self.OrthoBasis)\n else:# with k-loop\n self.rgf = CohRgfLoop(self.workers, self.nb, self.kT, self.ieta, \n self.OrthoBasis, 2)\n\n # Setup H and S \n if (self.DevType == self.COH_RGF_UNI): # for uniform RGF blocks\n\n for ib in range(0, self.nb+1): # setup the block hamiltonian\n if self.kp.N == 0: # no k-loop\n if (ib != self.nb):\n self.rgf.H0(self.H0, ib) # H0: 0 to N+1\n self.rgf.S0(self.S0, ib) # S0: 0 to N+1\n self.rgf.Hl(self.Hl, ib) # Hl: 0 to N+2\n \n else: # we have k-loop, add transverse neighbors\n self.rgf.k(self.kp.kp) # set k-points\n if (ib != self.nb):\n self.rgf.H0(self.H0[0], ib, 0) # H0_i,i: 0 to N+1 \n self.rgf.H0(self.H0[1], ib, 1) # H0_i,i+1: 0 to N+1\n self.rgf.H0(self.H0[2], ib, 2) # H0_i,i-1: 0 to N+1\n self.rgf.S0(self.S0[0], ib, 0) # S0_i,i: 0 to N+1\n self.rgf.pv0(self.pv[0], ib, 0)\n self.rgf.pv0(self.pv[1], ib, 1)\n self.rgf.pv0(self.pv[2], ib, 2)\n self.rgf.Hl(self.Hl[0], ib, 0) # Hl_i,i: 0 to N+2\n self.rgf.Hl(self.Hl[1], ib, 1) # Hl_i,i: 0 to N+2\n self.rgf.Hl(self.Hl[2], ib, 2) # Hl_i,i: 0 to N+2\n self.rgf.pvl(self.pvl[0], ib, 0)\n self.rgf.pvl(self.pvl[1], ib, 1)\n self.rgf.pvl(self.pvl[2], ib, 2) \n \n elif (self.DevType == self.COH_RGF_NON_UNI): # Non-uniform RGF blocks \n for ib in range(0, self.nb): # setup the block hamiltonian\n self.rgf.H0(self.H0[ib], ib) # H0: 0 to N+1=nb-1\n self.rgf.S0(self.S0[ib], ib) # S0: just the identity matrix stored in S0(0)\n if ib > 0:\n self.rgf.Hl(self.Hl[ib], ib) # Hl: 1 to N+1=nb-1\n self.rgf.Hl(self.Hl[0], 0) # Hl(0) = H_0,-1\n self.rgf.Hl(self.Hl[ib+1], ib+1) # Set H_N+2,N+1 = H_N+1,N\n # Clean up unused memory; we alredy have copies of these variables\n # in self.rgf.\n self.H0 = None\n self.Hl = None\n self.S0 = None\n self.Sl = None\n\n # Enable calculations\n for type, value in self.Calculations.items():\n # transmission\n if (type == \"TE\"):\n self.rgf.enableTE(value)\n # current\n if (type == \"I\"):\n if (isinstance( value, int)):\n self.rgf.enableI(value, 0, 1)\n else:\n for I in self.Calculations[\"I\"]:\n if (\"Block\" in I and I[\"Block\"] == \"All\"):\n for ib in range(0, self.nb-1):\n self.rgf.enableI(I[\"N\"], ib, ib+1)\n else:\n self.rgf.enableI(I[\"N\"], I[\"From\"], I[\"To\"])\n if (type == \"DOS\"):\n self.rgf.enableDOS(value)\n if (type == \"n\"):\n if (isinstance( value, int)):\n self.rgf.enablen(value)\n else:\n for n in self.Calculations[\"n\"]:\n if (n[\"Block\"] == \"All\"):\n for ib in range(1, self.nb-1):\n self.rgf.enablen(n[\"N\"], ib) \n else:\n self.rgf.enablen(n[\"N\"], n[\"Block\"])\n if hasattr(self, \"atomsTracedOver\"):\n self.rgf.atomsTracedOver(self.atomsTracedOver);\n \n # Loop over drain and gate bias\n for VDD in self.VDD:\n for VGG in self.VGG:\n self.runBiasStep(VGG, self.Vo, VDD)\n pass\n self.clock.toc() \n nprint(\"\\n\" + str(self.clock) + \"\\n\")\n \n def updateBoundingBox(self):\n \"\"\"Updates the bounding box of atomistic geometry.\"\"\"\n # Just to make sure that no point of gate regions is \n # at the border\n a = self.hp.a\n delta = a*7.0/220.0\n self.xmn = self.geom.xmin - delta \n self.xmx = self.geom.xmax + delta\n self.ymn = self.geom.ymin - delta\n self.ymx = self.geom.ymax + delta \n \n def __str__(self):\n msg = self.staticnstr()\n msg += self.dynamicnstr()\n return msg\n \n def staticnstr(self):\n msg = \"\\n Transport simulation parameters:\"\n \n msg += \"\\n Device geometry:\"\n msg += \"\\n ---------------------------------------------\"\n msg += \"\\n ... |-1 | 0 | 1 | ... | \" + str(self.nb-2) + \" | \" + str(self.nb-1) + \" | \" + str(self.nb) + \" | ...\"\n msg += \"\\n ---------------------------------------------\"\n msg += \"\\n ^ <-------^-------> ^\"\n msg += \"\\n left Device right\"\n msg += \"\\n contact contact\"\n \n # Bias information\n msg += \"\\n Bias: \"\n msg += \"\\n VDD: min \" + str(min(self.VDD)) + \", max \" + str(max(self.VDD)) \n msg += \", number \" + str(len(self.VDD))\n msg += \"\\n VGG: min \" + str(min(self.VGG)) + \", max \" + str(max(self.VGG)) \n msg += \", number \" + str(len(self.VGG))\n msg += \"\\n Vo: \" + str(self.Vo)\n \n # Device information\n msg += \"\\n Device:\"\n msg += \"\\n Lengh: \" + str(self.geom.xl) + \"(\" + str(self.geom.xl/10.0) + \" nm)\"\n msg += \", Width: \" + str(self.geom.yl) + \"(\" + str(self.geom.yl/10.0) + \" nm)\"\n msg += \", Height: \" + str(self.geom.zl)+ \"(\" + str(self.geom.zl/10.0) + \" nm)\"\n msg += \"\\n Num of atoms: \" + str(self.geom.NumOfAtoms) \n msg += \", Num of orbitals: \" + str(self.geom.NumOfOrbitals)\n \n # Print Hamiltonian parameters.\n msg += \"\\n\"\n msg += str(self.hp)\n \n # Calculations to perform\n msg += \" Calculations:\\n\"\n for type, value in self.Calculations.items():\n if (type == \"TE\"):\n msg += \" Transmission.\\n\"\n if (type == \"I\"):\n if (isinstance( value, int)):\n msg += \" Current at left contact\"\n msg += \" (\" + str(I[\"N\"]) + \").\\n\"\n else:\n for I in self.Calculations[\"I\"]:\n if (\"Block\" in I and I[\"Block\"] == \"All\"):\n msg += \" Current of all blocks\"\n msg += \" (\" + str(I[\"N\"]) + \").\\n\"\n else:\n msg += \" Current from block # \" + str(I[\"From\"])\n msg += \" to block # \" + str(I[\"To\"]) \n msg += \" (\" + str(I[\"N\"]) + \").\\n\"\n if (type == \"n\"):\n if (isinstance( value, int)):\n msg += \" Electron density of the device\"\n msg += \" (\" + str(n[\"N\"]) + \").\\n\"\n else:\n for n in self.Calculations[\"n\"]:\n if (n[\"Block\"] == \"All\"):\n msg += \" Electron density of all blocks\"\n msg += \" (\" + str(n[\"N\"]) + \").\\n\"\n else:\n msg += \" Electron density of block # \" + str(n[\"Block\"])\n msg += \" (\" + str(n[\"N\"]) + \").\\n\"\n \n msg += \" Save output at: \" + self.OutPath + self.OutFileName + \"*\\n\"\n \n # End of info section\n msg += \" ------------------------------------------------------------------\"\n \n return msg\n \n def dynamicnstr(self):\n # NEGF parameters\n msg = str(self.rgf)\n # Electrostatics\n msg += \"\\n\"\n msg += str(self.V)\n\n return msg\n \n\n def debugstr(self):\n msg = \" Debugging information: \\n\"\n msg = \" Atomic structure: \\n\"\n msg += str(self.geom)\n msg += \" ------------------------------------------------------------------\"\n return msg\n \n def __getstate__(self):\n dct = dict(self.__dict__)\n del dct['workers']\n del dct['clock']\n del dct['kp']\n #del dct['H0']\n #del dct['Hl']\n #del dct['S0']\n #del dct['Sl']\n #del dct['geom']\n #del dct['rgf']\n return dct\n \n def __setstate__(self, dct):\n self.__dict__.update(dct)\n \n\"\"\"\n Loads and returns a Transport object from pickle file\n\"\"\"\ndef loadTransport(fileName):\n pf = open(fileName)\n tr = pk.load(pf)\n pf.close()\n return tr\n\n\n\n\n\n\n", "meta": {"hexsha": "0c5cf5e108444ebd00e5e47a8c8da2998ba71f69", "size": 29929, "ext": "py", "lang": "Python", "max_stars_repo_path": "simulators/python/dirackp/Transport.py", "max_stars_repo_name": "masumhabib/quest", "max_stars_repo_head_hexsha": "afef1166b361236144be83f07303a3ec0d5c187c", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2017-04-04T20:57:41.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-23T02:08:22.000Z", "max_issues_repo_path": "simulators/python/dirackp/Transport.py", "max_issues_repo_name": "masumhabib/quest", "max_issues_repo_head_hexsha": "afef1166b361236144be83f07303a3ec0d5c187c", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 14, "max_issues_repo_issues_event_min_datetime": "2016-10-06T03:00:24.000Z", "max_issues_repo_issues_event_max_datetime": "2017-05-30T06:43:32.000Z", "max_forks_repo_path": "simulators/python/dirackp/Transport.py", "max_forks_repo_name": "masumhabib/quest", "max_forks_repo_head_hexsha": "afef1166b361236144be83f07303a3ec0d5c187c", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2016-10-03T04:09:25.000Z", "max_forks_repo_forks_event_max_datetime": "2016-10-03T04:09:25.000Z", "avg_line_length": 37.980964467, "max_line_length": 181, "alphanum_fraction": 0.4582177821, "include": true, "reason": "import numpy", "num_tokens": 7530, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5389832206876841, "lm_q2_score": 0.35577487985229844, "lm_q1q2_score": 0.19175669058256567}} {"text": "#!/usr/bin/python3\n\n\"\"\"Read .out files from ORCA IRC calculations and create graphs.\"\"\"\n\nimport argparse\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom scipy.constants import calorie\nfrom scipy.constants import kilo\nfrom scipy.constants import N_A\nfrom scipy.constants import physical_constants\nfrom scipy import interpolate\n\nfrom rmsd import calc_rmsd\nfrom rmsd import read_xyz\n\nhartree, _, _ = physical_constants[\"Hartree energy\"]\n\n\ndef main():\n \"\"\"Run main procedure.\"\"\"\n parser = argparse.ArgumentParser()\n parser.add_argument(\"out_file\", type=argparse.FileType(\"r\"), default=\"-\")\n parser.add_argument(\"--classic\", action=\"store_true\")\n args = parser.parse_args()\n\n irc = False\n data = []\n for line in args.out_file:\n if \"Step E(Eh) dE(kcal/mol) max(|G|) RMS(G)\" in line:\n irc = True\n elif irc:\n line = line.strip()\n if line:\n fields = line.split()\n data.append([float(x) for x in fields[:5]])\n if len(fields) > 5 and fields[5] == \"<=\":\n ts_step = int(data[-1][0]) - 1 # first step is one\n else:\n break\n\n try:\n coords = read_xyz(args.out_file.name.replace(\".out\", \"_TSOpt_IRC_Full_trj.xyz\"))[2]\n except ValueError:\n coords = read_xyz(args.out_file.name.replace(\".out\", \"_IRC_Full_trj.xyz\"))[2]\n\n rmsd = [0.0]\n for i in range(1, len(coords)):\n rmsd.append(rmsd[-1] + calc_rmsd(coords[i - 1], coords[i]))\n rmsd = np.array(rmsd)\n\n data = np.array(data)\n # xi = (data[:, 0] - data[:, 0].min()) / data[:, 0].max()\n xi = rmsd\n y = data[:, 1] - data[:, 1].min()\n\n forward_barrier = y.max() - y[0]\n backward_barrier = y.max() - y[-1]\n print(\n f\"forward barrier = {forward_barrier:6.4f} Eh = {forward_barrier * hartree * N_A / kilo:5.1f} kJ/mol = {forward_barrier * hartree * N_A / (kilo * calorie):5.1f} kcal/mol\"\n )\n print(\n f\"backward barrier = {backward_barrier:6.4f} Eh = {backward_barrier * hartree * N_A / kilo:5.1f} kJ/mol = {backward_barrier * hartree * N_A / (kilo * calorie):5.1f} kcal/mol\"\n )\n\n if not args.classic:\n xi_new = np.linspace(xi.min(), xi.max(), 10000)\n\n # points = ~np.isclose(xi, xi[ts_step])\n # f = interpolate.InterpolatedUnivariateSpline(xi[points], y[points])\n f = interpolate.InterpolatedUnivariateSpline(xi, y, k=4)\n fp = f.derivative()\n fpp = f.derivative(n=2)\n\n plt.subplot(311)\n else:\n plt.subplot(211)\n\n plt.plot(xi, y, \"o\", label=\"calculated\")\n plt.vlines(xi[ts_step], y.min(), y.max())\n plt.xlabel(r\"IRC ($\\xi$)\")\n plt.ylabel(r\"Potential Energy, V($\\xi$) [Eh]\")\n\n if not args.classic:\n # add interpolation\n pass\n plt.plot(xi_new, f(xi_new), \"--\", label=\"interpolated\")\n plt.legend()\n\n plt.subplot(312)\n rf = -fp(xi_new)\n plt.plot(xi_new, rf, \"--\")\n plt.vlines(xi[ts_step], rf.min(), rf.max())\n plt.xlabel(r\"IRC ($\\xi$)\")\n plt.ylabel(r\"Reaction Force, F($\\xi$) [Eh/$\\Delta\\xi$]\")\n\n # TODO(schneiderfelipe): get max and min force along the coordinate\n # and do the usual analysis\n plt.subplot(313)\n rfc = fpp(xi_new)\n plt.plot(xi_new, rfc, \"--\")\n plt.vlines(xi[ts_step], rfc.min(), rfc.max())\n plt.xlabel(r\"IRC ($\\xi$)\")\n plt.ylabel(r\"Reaction Force Constant, $\\kappa$($\\xi$) [Eh/$\\Delta\\xi^2$]\")\n else:\n plt.subplot(212)\n plt.plot(xi, data[:, 3], \"o\", label=\"max(|G|)\")\n plt.vlines(xi[ts_step], 0, data[:, 3].max())\n plt.plot(xi, data[:, 4], \"o\", label=\"RMS(G)\")\n plt.xlabel(r\"IRC ($\\xi$)\")\n plt.ylabel(r\"Gradient, G($\\xi$) [Eh/Bohr]\")\n plt.legend()\n\n # plt.tight_layout()\n plt.show()\n\n\nif __name__ == \"__main__\":\n main()\n", "meta": {"hexsha": "1ad135d15f1ff5360272a04517585d949988d65e", "size": 3886, "ext": "py", "lang": "Python", "max_stars_repo_path": "irc.py", "max_stars_repo_name": "schneiderfelipe/scripts", "max_stars_repo_head_hexsha": "43bb3d02d0b043f80a4840f4cc222944aad683c4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "irc.py", "max_issues_repo_name": "schneiderfelipe/scripts", "max_issues_repo_head_hexsha": "43bb3d02d0b043f80a4840f4cc222944aad683c4", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "irc.py", "max_forks_repo_name": "schneiderfelipe/scripts", "max_forks_repo_head_hexsha": "43bb3d02d0b043f80a4840f4cc222944aad683c4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.1157024793, "max_line_length": 182, "alphanum_fraction": 0.5717961915, "include": true, "reason": "import numpy,from scipy", "num_tokens": 1123, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5389832058771036, "lm_q2_score": 0.3557748798522984, "lm_q1q2_score": 0.19175668531333312}} {"text": "#!/usr/bin/env python\n\n# ----------------------------------------------------------------------------\n# Copyright (c) 2015--, The WGS-HGT Development Team.\n#\n# Distributed under the terms of the Modified BSD License.\n#\n# The full license is in the file COPYING.txt, distributed with this software.\n# ----------------------------------------------------------------------------\n\n# Implement Distance Method for HGT detection based on algorithm described\n# in:\n# Wei. X et al., \"A Distance-Based Method for Detecting HGT in Whole\n# Genomes\", International Symposium on Bioinformatics Research and\n# Applications (ISBRA), 2008, pages 26-37\n#\n# The workflow follows the algorithm:\n# 1. For each gene in target genome,\n# i. BLAST sequence against all other genes in the reference\n# genomes;\n# ii. Go to step 3 if gene has more than threshold number of homologs\n# (min-num-homologs), otherwise go to next gene in target genome;\n# iii. Compute multiple sequence alignment on homolog genes using\n# CLUSTAL;\n# iv. Compute pairwise distance matrix using PHYLIP's protdist\n# function and Z-score normalize the set of pairwise distances\n# for each gene family and species;\n# v. Add distance matrix for all pairwise distances into global\n# distance matrix storing results for all genes\n#\n# 2. Cluster gene families by species,\n# vi. Compute all species sets (sets of genes whose orthologs are\n# detectable in exactly the same subset of the considered\n# species);\n# vii. Cluster genes to each core species set cluster using the\n# Hamming distance clustering algorithm;\n# viii. Run outlier detection algorithm on each cluster (paragraph 2\n# of section 'Detecting Outlier Genes' in original paper)\n#\n# Requires protdist version 3.696\n#\n\nimport sys\nimport click\nimport numpy\nimport operator\nimport threading\nimport subprocess\nimport traceback\nimport shlex\nfrom os.path import join, basename, isdir, exists, getsize\nfrom os import mkdir\n\nfrom glob import glob\n\nimport skbio.io\n\n\nclass Command(object):\n \"\"\"Run subprocess commands in a different thread with TIMEOUT option.\n\n Based on jcollado's solution:\n http://stackoverflow.com/questions/1191374/subprocess-with-timeout/4825933#4825933\n https://gist.github.com/kirpit/1306188\n \"\"\"\n process = None\n status = None\n output, error = '', ''\n\n def __init__(self, command):\n if isinstance(command, str):\n command = shlex.split(command)\n self.command = command\n\n def run(self, timeout=None, **kwargs):\n \"\"\" Run a command then return: (status, output, error). \"\"\"\n def target(**kwargs):\n try:\n self.process = subprocess.Popen(self.command, **kwargs)\n self.output, self.error = self.process.communicate()\n self.status = self.process.returncode\n except subprocess.CalledProcessError:\n self.error = traceback.format_exc()\n self.status = -1\n # default stdout and stderr\n if 'stdout' not in kwargs:\n kwargs['stdout'] = subprocess.PIPE\n if 'stderr' not in kwargs:\n kwargs['stderr'] = subprocess.PIPE\n # thread\n thread = threading.Thread(target=target, kwargs=kwargs)\n thread.start()\n thread.join(timeout)\n if thread.is_alive():\n self.process.terminate()\n thread.join()\n return self.status, self.output, self.error\n\n\ndef hamming(str1, str2):\n \"\"\"Compute the Hamming distance between two strings.\n\n Parameters\n ----------\n str1: string\n string\n str2: string\n string\n \"\"\"\n assert len(str1) == len(str2)\n return sum(map(operator.ne, str1, str2))\n\n\ndef preprocess_data(working_dir,\n target_proteomes_dir,\n extensions,\n verbose=False):\n \"\"\" Map each gene to sudo name (ex. 1_1 for species 1, gene 1).\n\n Parameters\n ----------\n working_dir: string\n path to working directory\n target_proteomes_dir: string\n path to directory holding proteomes for all target organisms\n extensions: list\n list of extensions for reference proteomes\n verbose: boolean, optional\n output details about the running processes of this function\n\n Returns\n -------\n gene_map: dictionary\n \"two-way\" dictionary storing gene names as keys and their pseudo\n names as values, and vica versa\n ref_db: dictionary\n dictionary storing FASTA label as key and sequence as value for the\n reference databases\n species: integer\n the number of species in the reference databases\n\n Notes\n -----\n This will facilitate easier output comparison and the 10 character\n name limitation in PHYLIP output. This format is limited up to 9999\n species and 99999 genes per species.\n \"\"\"\n gene_map = {}\n ref_db = {}\n if verbose:\n sys.stdout.write(\"Target organism\\tNumber of genes\\n\")\n # each file contains genes for species\n files = [f\n for ext in extensions\n for f in glob(\"%s/*%s\" % (target_proteomes_dir, ext))]\n for species, _file in enumerate(files):\n if verbose:\n sys.stdout.write(\"%s. %s\\t\" % (\n species+1, basename(_file)))\n for gene, seq in enumerate(skbio.io.read(_file, format='fasta')):\n label = seq.metadata['id']\n ref_db[label] = seq\n sudo_label = \"%s_%s\" % (species, gene)\n if label in gene_map:\n raise ValueError(\"Duplicate sequence labels are \"\n \"not allowed: %s\" % label)\n gene_map[label] = sudo_label\n gene_map[sudo_label] = label\n if verbose:\n sys.stdout.write(\"%s\\n\" % gene)\n return gene_map, ref_db, species+1\n\n\ndef launch_diamond(query_proteome_fp,\n ref_fp,\n working_dir,\n tmp_dir,\n e_value=10e-20,\n threads=1,\n debug=False):\n \"\"\" Launch DIAMOND for a query and a reference database of proteomes.\n\n Parameters\n ----------\n query_proteome_fp: string\n filepath to query proteome\n ref_fp: string\n filepath to reference proteome\n working_dir: string\n working directory path\n tmp_dir:\n temporary working directory for DIAMOND\n e_value: float, optional\n the cutoff E-value for BLASTP results\n threads: integer\n number of threads to use for running DIAMOND BLASTP\n debug: boolean\n if True, run function in debug mode\n\n Returns\n -------\n out_file_fp: string\n filepath to tabular alignment file output by DIAMOND\n \"\"\"\n db_file_fp = join(working_dir, \"%s\" % basename(ref_fp))\n # build DIAMOND database\n makediamonddb_command = [\"diamond\",\n \"makedb\",\n \"--in\", ref_fp,\n \"-d\", db_file_fp,\n \"--threads\", str(threads)]\n proc = subprocess.Popen(makediamonddb_command,\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE,\n close_fds=True)\n proc.wait()\n stdout, stderr = proc.communicate()\n if (stderr and debug):\n print(\"[DEBUG] %s\\n\" % stderr)\n\n # launch DIAMOND\n out_file_fp = join(\n working_dir, \"%s.daa\" % basename(query_proteome_fp))\n diamond_command = [\"diamond\",\n \"blastp\",\n \"-t\", tmp_dir,\n \"--db\", \"%s.dmnd\" % db_file_fp,\n \"--query\", query_proteome_fp,\n \"--evalue\", str(e_value),\n \"--threads\", str(threads),\n \"--daa\", out_file_fp,\n \"--sensitive\"]\n proc = subprocess.Popen(diamond_command,\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE,\n close_fds=True)\n proc.wait()\n stdout, stderr = proc.communicate()\n if (stderr and debug):\n print(\"[DEBUG] %s\\n\" % stderr)\n\n # convert output to tab delimited file\n out_file_conv_fp = join(\n working_dir, \"%s.m8\" % basename(query_proteome_fp))\n diamond_convert_command = [\"diamond\",\n \"view\",\n \"--daa\", out_file_fp,\n \"-f\", \"tab\",\n \"-o\", out_file_conv_fp]\n proc = subprocess.Popen(diamond_convert_command,\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE,\n close_fds=True)\n proc.wait()\n stdout, stderr = proc.communicate()\n if (stderr and debug):\n print(\"[DEBUG] %s\\n\" % stderr)\n\n return out_file_conv_fp\n\n\ndef launch_blast(query_proteome_fp,\n ref_fp,\n working_dir,\n e_value=10e-20,\n threads=1,\n debug=False):\n \"\"\" Launch BLASTp for a query and a reference database of proteomes.\n\n Parameters\n ----------\n query_proteome_fp: string\n filepath to query proteome\n ref_fp: string\n filepath to reference proteome\n working_dir: string\n working directory path\n e_value: float, optional\n the cutoff E-value for BLASTP results\n threads: integer\n number of threads to use for running BLASTP\n debug: boolean\n if True, run function in debug mode\n\n Returns\n -------\n out_file_fp: string\n filepath to tabular alignment file output by\n BLASTP\n \"\"\"\n db_file_fp = join(working_dir, \"%s\" % basename(ref_fp))\n # build blast database\n makeblastdb_command = [\"makeblastdb\",\n \"-in\", ref_fp,\n \"-out\", db_file_fp,\n \"-dbtype\", \"prot\"]\n proc = subprocess.Popen(makeblastdb_command,\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE,\n close_fds=True)\n proc.wait()\n stdout, stderr = proc.communicate()\n if (stderr and debug):\n print(\"[DEBUG] %s\\n\" % stderr)\n\n # launch blast\n out_file_fp = join(\n working_dir, \"%s.blast\" % basename(query_proteome_fp))\n blastp_command = [\"blastp\",\n \"-db\", db_file_fp,\n \"-query\", query_proteome_fp,\n \"-evalue\", str(e_value),\n \"-num_threads\", str(threads),\n \"-outfmt\", \"6 std qcovs\",\n \"-task\", \"blastp\",\n \"-out\", out_file_fp]\n proc = subprocess.Popen(blastp_command,\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE,\n close_fds=True)\n proc.wait()\n stdout, stderr = proc.communicate()\n if (stderr and debug):\n print(\"[DEBUG] %s\\n\" % stderr)\n\n return out_file_fp\n\n\ndef parse_blast(alignments_fp,\n hits,\n gene_map,\n debug=False):\n \"\"\" Parse BLASTp alignment file into a dictionary.\n\n Parameters\n ----------\n alignments_fp: string\n filepath to tabular alignment file output by BLASTP\n hits: dictionary\n dictionary storing query (gene) names as keys and the best aligning\n reference sequences as values (one alignment per reference sequence)\n gene_map: dictionary\n \"two-way\" dictionary storing gene names as keys and their pseudo\n names as values, and vica versa\n debug: boolean\n if True, run function in debug mode\n\n Notes\n -----\n The keys are the queries and the values are all the reference\n sequences to which the query mapped with E-value cutoff score.\n \"\"\"\n # read blastp results\n with open(alignments_fp, 'r') as alignments_f:\n for line in alignments_f:\n if debug:\n sys.stdout.write(\"[DEBUG] %s\" % line)\n query, ref = line.split()[:2]\n if query not in hits:\n hits[query] = [ref]\n else:\n # check that the query mapped to a different species\n # since we only want the best homolog per species\n if gene_map[ref].split('_')[0] not in [\n gene_map[gene].split('_')[0] for gene in hits[query]]:\n hits[query].append(ref)\n\n\ndef launch_msa(fasta_in_fp,\n clustal_command_fp,\n gene_map,\n ref_db,\n hits,\n query,\n timeout):\n \"\"\" Create MSA for all gene othologs using Clustalw.\n\n Parameters\n ----------\n fasta_in_fp: string\n filepath to FASTA file of protein sequences to use as input to\n Clustalw\n clustal_command_fp: string\n filepath to Clustalw command (interactive)\n gene_map: dictionary\n \"two-way\" dictionary storing gene names as keys and their pseudo\n names as values, and vica versa\n ref_db: dictionary\n dictionary storing FASTA label as key and sequence as value for the\n reference databases\n hits: dictionary\n dictionary storing query (gene) names as keys and the best aligning\n reference sequences as values (one alignment per reference sequence)\n query: string\n query gene name\n timeout: integer\n number of seconds to allow Clustalw to run before terminating the\n process\n \"\"\"\n with open(fasta_in_fp, 'w') as in_f:\n for ref in hits[query]:\n in_f.write(\">%s\\n%s\\n\" % (gene_map[ref], ref_db[ref]))\n\n with open(clustal_command_fp, 'r') as clustal_command_f:\n clustalw_command = Command(\"clustalw\")\n status, output, error = clustalw_command.run(\n timeout=timeout,\n stdin=clustal_command_f,\n close_fds=True)\n if status < 0:\n sys.stdout.write(\n \"status: %s\\noutput: %s\\terror: %s\\t\" % (\n status, output, error))\n\n\ndef compute_distances(phylip_command_fp,\n warnings=False):\n \"\"\" Compute distances between each pair of sequences in the MSA.\n\n Parameters\n ----------\n phylip_command_fp: string\n filepath to the PHYLIP command (interactive)\n warnings: boolean, optional\n print warnings output by PHYLIP\n\n Notes\n -----\n Use PHYLIP's protdist function.\n \"\"\"\n with open(phylip_command_fp, 'r') as phylip_command_f:\n proc = subprocess.Popen(\"protdist\",\n stdin=phylip_command_f,\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE,\n close_fds=True)\n proc.wait()\n stdout, stderr = proc.communicate()\n if stderr and warnings:\n print(stderr)\n\n\ndef normalize_distances(phylip_fp,\n full_distance_matrix,\n num_species,\n full_distance_matrix_offset,\n species_set_dict,\n gene_bitvector_map,\n debug=False):\n \"\"\" Parse and normalize the output file of PHYLIP's protdist function.\n\n Parameters\n ----------\n phylip_fp: string\n filepath to distance matrix output by PHYLIP's protdist function\n full_distance_matrix: dictionary\n complete distance matrix for pairwise alignments between all species\n for every gene\n num_species: integer\n number of species in the reference database\n full_distance_matrix_offset: integer\n the index offset for elements in full_distance_matrix where to write\n the next array\n species_set_dict: dictionary\n dictionary containing the binary indicator vectors as keys and the\n number of genes with identical species set represented by the binary\n vectors as values\n gene_bitvector_map: list\n list containing the binary indicator vector for each query gene\n debug: boolean\n if True, run function in debug mode\n\n Notes\n -----\n Parse PHYLIP's protdist output containing the distance matrix, Z-score\n normalize the set of pairwise distances between the gene in a species\n and all other species and stores the results in a separate array.\n\n Each normalized distance matrix is then sorted by species name and\n added to the complete array storing distance matrices for all genes.\n In addition, a list of missing species (species which did not include\n a certain gene) is also maintained and used for setting nan's in array\n cells which represent those species.\n\n Below is an example of a parsed distance matrix\n for 3 genes and 3 species:\n 0 1 2 (genes)\n 0_0 nan nan nan\n 0_1 0.53099 0.878855 0.83673\n 0_2 0.642856 1.083039 1.083039\n 1_0 0.300297 0.300297 0.702003\n 1_1 nan nan nan\n 1_2 0.399722 0.379156 0.356543\n 2_0 0.53099 0.53099 0.83673\n 2_1 0.399722 0.399722 0.356543\n 2_2 nan nan nan\n\n (species pairs)\n\n Example of Z-score normalized distance matrix from\n above:\n 0 1 2 (genes)\n 0_0 nan nan nan\n 0_1 -1.40548346 0.83861735 0.56686611\n 0_2 -1.41421356 0.70710678 0.70710678\n 1_0 -0.70710678 -0.70710678 1.41421356\n 1_1 nan nan nan\n 1_2 1.20493966 0.03869341 -1.24363308\n 2_0 -0.70710678 -0.70710678 1.41421356\n 2_1 0.70710678 0.70710678 -1.41421356\n 2_2 nan nan nan\n\n (species pairs)\n \"\"\"\n # assume a pairwise alignment exists for all species\n missing_species = [str(x) for x in range(0, num_species)]\n # scan through file and remove species that exist\n # from missing_species list\n if exists(phylip_fp) and getsize(phylip_fp) > 0:\n with open(phylip_fp, 'r') as phylip_f:\n next(phylip_f)\n for line in phylip_f:\n if not line.startswith(' '):\n species = line.split()[0].split('_')[0]\n missing_species.remove(species)\n else:\n raise ValueError('%s does not exist or is empty' % phylip_fp)\n\n # scan through file again, collecting alignment\n # distances\n orig_order_labels = []\n p = numpy.empty(shape=(num_species, num_species))\n p.fill(numpy.nan)\n idx = 0\n with open(phylip_fp, 'r') as phylip_f:\n alignment_list = []\n # skip first line containing number of lines in\n # the file\n next(phylip_f)\n for line in phylip_f:\n if debug:\n sys.stdout.write(\"[DEBUG] %s\" % line)\n alignment_dist = line.strip().split()\n if line.startswith(' '):\n alignment_list.extend(alignment_dist)\n else:\n # new species alignment pairs\n if alignment_list:\n for i in range(0, len(missing_species)):\n alignment_list.append(None)\n a = numpy.asarray(alignment_list[1:], dtype=float)\n a[idx] = numpy.nan\n p[idx] = (a - numpy.nanmean(a)) / numpy.nanstd(a)\n idx += 1\n orig_order_labels.append(alignment_list[0])\n alignment_list = alignment_dist\n\n # add distance on final line\n for i in range(0, len(missing_species)):\n alignment_list.append(None)\n a = numpy.asarray(alignment_list[1:], dtype=float)\n a[idx] = numpy.nan\n p[idx] = (a - numpy.nanmean(a)) / numpy.nanstd(a)\n orig_order_labels.append(alignment_list[0])\n\n # add the missing species names to the labels array\n bitvector_gene = 'I' * num_species\n for species in missing_species:\n orig_order_labels.append(\"%s_X\" % species)\n # indicate missing gene for current species\n x = list(bitvector_gene)\n x[int(species)] = 'O'\n bitvector_gene = ''.join(x)\n\n # update species set counts\n if bitvector_gene not in species_set_dict:\n species_set_dict[bitvector_gene] = 1\n else:\n species_set_dict[bitvector_gene] += 1\n\n gene_bitvector_map[full_distance_matrix_offset] = bitvector_gene\n\n # sort the distance matrix based on species names (S1, S2, S3 ..)\n # in order to be consistent across all gene families\n x = numpy.argsort(numpy.array(orig_order_labels))\n\n # re-order rows and columns by ordered species name (0,1,2 ..)\n p2 = numpy.zeros(shape=(num_species, num_species))\n for idx_a, arr in enumerate(p):\n t = numpy.zeros(shape=num_species)\n for idx_b, el in enumerate(arr):\n t[x[idx_b]] = el\n p2[x[idx_a]] = t\n del p\n\n # add normalized distance matrix for current gene\n # to full distance matrix\n full_distance_matrix[full_distance_matrix_offset] = p2\n\n\ndef cluster_distances(species_set_dict,\n species_set_size,\n hamming_distance):\n \"\"\" Hamming distance clustering algorithm\n\n Parameters\n ----------\n species_set_dict: dictionary\n dictionary containing the binary indicator vectors as\n keys and the number of genes with identical species\n set represented by the binary vectors as values\n species_set_size: integer\n threshold number of genes in a species set to\n allow it to form a core cluster\n hamming_distance: integer\n maximum number of mismatches between two binary\n indicator vectors (ex. IIII and I0II) for the\n genes in a candidate vector to be merged into the\n core cluster\n\n Returns\n -------\n gene_clusters_list: list of tuples\n list of tuples containing core species sets and all belonging species\n sets (determined by the Hamming distance clustering algorithm)\n\n Notes\n -----\n Cluster gene families by species with detectable orthologs in exactly\n the same subset of the considered species.\n\n Ex. Assume we have 4 genes and 5 species with the following distance\n matrix:\n\n 0 1 2 3\n 0_0 nan nan nan nan\n 0_1 -1.59564844 -1.388031632 -0.9634704748 -1.342272936\n 0_2 -0.4259542606 nan 0.7035215923 1.223837777\n 0_3 -1.55041393 -1.51499567 -0.9634704748 -1.330178178\n 0_4 -0.3659762821 0.8346037464 0.6565725705 1.15274682\n ..\n ..\n\n There are two binary indicator vectors to represent the species\n present in the four genes: IIIII (gene 0, 2 and 3), II0II (gene 1). If\n the core set threshold was 3, then there would be 1 core species set\n represented by IIIII.\n \"\"\"\n sorted_species_set = sorted(list(species_set_dict.items()),\n key=operator.itemgetter(1), reverse=True)\n # determine core clusters (initial species sets with more than\n # species_set_size genes)\n gene_clusters_list = []\n # if the largest species set contains less than threshold\n # (species_set_size) elements, set the only core cluster to the largest\n # species set\n if sorted_species_set[0][1] < species_set_size:\n cluster_core = (sorted_species_set[0][0], [])\n gene_clusters_list = []\n for bitvector in sorted_species_set:\n if bitvector[1] >= species_set_size:\n cluster_core = (bitvector[0], [])\n gene_clusters_list.append(cluster_core)\n # assign species sets with fewer than species_set_size species to core\n # clusters if the Hamming distance between the two bitvectors is less than\n # hamming_distance\n species_set_assigned = []\n for idx, cluster_core in enumerate(gene_clusters_list):\n for bitvector in sorted_species_set:\n bv = bitvector[0]\n if (bv not in species_set_assigned and\n hamming(cluster_core[0], bv) <= hamming_distance):\n gene_clusters_list[idx][1].append(bv)\n species_set_assigned.append(bv)\n # assign the remaining species sets to the cluster with the closest core\n # Hamming distance\n for bitvector in sorted_species_set:\n bv = bitvector[0]\n if bv not in species_set_assigned:\n min_hamming_cluster = -1\n min_hamming_distance = sys.maxsize\n # find cluster core with smallest Hamming distance to species set\n for idx, cluster_core in enumerate(gene_clusters_list):\n dist = hamming(cluster_core[0], bv)\n if dist < min_hamming_distance:\n min_hamming_distance = dist\n min_hamming_cluster = idx\n if min_hamming_cluster >= 0:\n gene_clusters_list[min_hamming_cluster][1].append(bv)\n\n return gene_clusters_list\n\n\ndef detect_outlier_genes(species_set,\n gene_bitvector_map,\n full_distance_matrix,\n stdev_offset,\n outlier_hgt,\n num_species,\n total_genes,\n debug=False):\n \"\"\" Detect outlier genes.\n\n Parameters\n ----------\n species_set: list\n list of bitvectors representing species clusters to use in detecting\n outlier genes\n gene_bitvector_map: list\n list containing the binary indicator vector for each query gene\n full_distance_matrix: dictionary\n complete distance matrix for pairwise alignments between all species\n for every gene\n stdev_offset: integer\n the number of standard deviations a gene's normalized distance is from\n the mean to identify it as an outlier for a species pair\n outlier_hgt: float\n the fraction (value between (0,1]) of normalized pairwise distances\n over all species-pair vectors belonging to the same gene that are\n z-score standard deviations from the mean\n num_species: integer\n number of species in the reference database\n total_genes: integer\n total number of genes in the query genome with at least\n min_num_homologs (determined by BLAST search)\n debug: boolean\n if True, run function in debug mode\n\n Returns\n -------\n outlier_genes: set\n set of atypical genes\n\n Notes\n -----\n Algorithm described in section \"Detecting `Outlier' Genes\" of the Wei.\n X et al. paper. The full distance matrix is represented in the format:\n\n full_distance_matrix[#genes][#species][#species] =\n [[[0_0, 0_1, 0_2, .., 0_n]\n [1_0, 1_1, 1_2, .., 1_n]\n ..\n [n_0, n_1, n_2, .., n_n]]\n\n [[0_0, 0_1, 0_2, .., 0_n]\n [1_0, 1_1, 1_2, .., 1_n]\n ..\n [n_0, n_1, n_2, .., n_n]]\n\n ..\n [[0_0, 0_1, 0_2, .., 0_n]\n [1_0, 1_1, 1_2, .., 1_n]\n ..\n [n_0, n_1, n_2, .., n_n]]]\n\n The mean and standard deviation are computed for each species pair\n including all genes.\n \"\"\"\n numpy.around(full_distance_matrix, decimals=5, out=full_distance_matrix)\n outlier_flag_matrix = numpy.zeros(\n shape=(total_genes, num_species, num_species), dtype=bool)\n distance_vector = numpy.zeros(total_genes)\n if debug:\n sys.stdout.write(\"[DEBUG] species_species\\t\")\n for k in range(total_genes):\n sys.stdout.write(\"gene # %s\".ljust(12) % k)\n sys.stdout.write(\"[low_bound, up_bound]\\n\")\n for i in range(num_species):\n for j in range(num_species):\n if i != j:\n for k in range(total_genes):\n distance_vector[k] = full_distance_matrix[k][i][j]\n mean = numpy.nanmean(distance_vector)\n stdev = numpy.nanstd(distance_vector)\n low_bound = round(mean - stdev_offset*stdev, 5)\n up_bound = round(mean + stdev_offset*stdev, 5)\n if debug:\n sys.stdout.write(\"[DEBUG] %s_%s\\t\".ljust(20) % (i, j))\n for k, distance in enumerate(distance_vector):\n spaces = \"\".ljust(2)\n if distance < 0:\n spaces = \"\".ljust(1)\n if (distance != numpy.nan and\n ((distance < low_bound) or (distance > up_bound))):\n outlier_flag_matrix[k][i][j] = 1\n if debug:\n sys.stdout.write(\n \"%s\\033[92m%s\\033[0m\" % (spaces, distance))\n elif debug:\n sys.stdout.write(\"%s%s\" % (spaces, distance))\n if debug:\n sys.stdout.write(\"\\t[%s, %s]\\n\" % (low_bound, up_bound))\n\n # traverse outlier_matrix by gene and count the number of outlier\n # distances by species\n outlier_count_matrix = numpy.zeros(\n shape=(total_genes, num_species), dtype=int)\n for i in range(total_genes):\n for j in range(num_species):\n for k in range(num_species):\n if outlier_flag_matrix[i][j][k]:\n outlier_count_matrix[i][k] += 1\n\n # if number of outlier distances exceeds threshold, label gene as outlier\n outlier_genes = set()\n for i in range(total_genes):\n for j in range(num_species):\n if outlier_count_matrix[i][j] > num_species*outlier_hgt:\n outlier_genes.add(i)\n\n return outlier_genes\n\n\ndef output_full_matrix(matrix, num_species):\n \"\"\" Output distance matrix to stdout\n \"\"\"\n for i in range(num_species):\n for j in range(num_species):\n # for gene number\n for k in range(len(matrix)):\n sys.stdout.write(\"%s\\t\" % matrix[k][i][j])\n sys.stdout.write(\"\\n\")\n\n\ndef distance_method(query_proteome_fp,\n target_proteomes_dir,\n working_dir,\n output_hgt_fp,\n align_software,\n tabular_alignments_fp=None,\n ext=['fa', 'fasta', 'faa'],\n min_num_homologs=3,\n e_value=10e-20,\n threads=1,\n stdev_offset=2.326,\n outlier_hgt=0.5,\n species_set_size=30,\n hamming_distance=2,\n verbose=False,\n debug=False,\n warnings=False,\n timeout=120):\n \"\"\" Run Distance Method algorithm\n\n Parameters\n ----------\n query_proteome_fp: string\n filepath to query proteome\n target_proteomes_dir: string\n dirpath to target proteomes\n working_dir: string\n dirpath to working directory\n output_hgt_fp: string\n filepath to output file for storing detected HGTs\n align_software: string\n software to use for sequence alignment (BLAST or DIAMOND)\n tabular_alignments_fp: string, optional\n filepath to tabular sequence alignments\n ext: list, optional\n list of file extensions to open in the target proteomes directory\n min_num_homologs: integer, optional\n the mininum number of homologs (determined by BLAST search)\n for each gene to test\n e_value: float, optional\n the E-value cutoff to identify orthologous genes using BLASTP\n threads: integer, optional\n number of threads to use for sequence alignment\n stdev_offset: float, optional\n the number of standard deviations a gene's normalized distance\n is from the mean to identify it as an outlier for a species pair\n outlier_hgt: float, optional\n the fraction (value between (0,1]) of normalized pairwise distances\n over all species-pair vectors belonging to the same gene that are\n z-score standard deviations from the mean\n species_set_size: integer, optional\n threshold number of genes to consider a species set large (a species\n set is a set of genes whose orthologs are detectable in exactly the\n same subset of the considered species)\n hamming_distance: integer, optional\n distance between two binary vectors indicating the species in which\n the corresponding ortholog gene appears\n verbose: boolean, optional\n if True, run in verbose mode\n debug: boolean, optional\n if True, run in debug mode\n warnings: boolean, optional\n if True, output warnings\n timeout: integer, optional\n number of seconds to allow Clustalw to run per call\n \"\"\"\n if verbose:\n sys.stdout.write(\n \"Begin whole-genome HGT detection using the Distance method.\\n\\n\")\n sys.stdout.write(\"Query genome: %s\\n\" % query_proteome_fp)\n\n extensions = set(['fa', 'fasta', 'faa'])\n extensions.update(ext)\n\n # create working directory if doesn't exist\n if not isdir(working_dir):\n mkdir(working_dir)\n\n gene_map, ref_db, num_species = preprocess_data(\n working_dir=working_dir,\n target_proteomes_dir=target_proteomes_dir,\n extensions=extensions,\n verbose=verbose)\n\n if debug:\n sys.stdout.write(\"\\n[DEBUG] gene map:\\n\")\n for gene in gene_map:\n sys.stdout.write(\"[DEBUG] %s: %s\\n\" % (gene, gene_map[gene]))\n\n if verbose:\n sys.stdout.write(\"\\nRunning BLASTp ..\\n\")\n hits = {}\n\n # tabular alignments provided\n if tabular_alignments_fp is not None:\n # generate a dictionary of orthologous genes\n parse_blast(alignments_fp=tabular_alignments_fp,\n hits=hits,\n gene_map=gene_map,\n debug=debug)\n # tabular alignments to be created\n else:\n files = [f\n for e in extensions\n for f in glob(\"%s/*%s\" % (target_proteomes_dir, e))]\n for _file in files:\n # launch BLASTp\n if align_software == \"blast\":\n alignments_fp = launch_blast(\n query_proteome_fp=query_proteome_fp,\n ref_fp=_file,\n working_dir=working_dir,\n e_value=e_value,\n threads=threads,\n debug=debug)\n elif align_software == \"diamond\":\n alignments_fp = launch_diamond(\n query_proteome_fp=query_proteome_fp,\n ref_fp=_file,\n working_dir=working_dir,\n tmp_dir=working_dir,\n e_value=e_value,\n threads=threads,\n debug=debug)\n else:\n raise ValueError(\n \"Software not supported: %s\" % align_software)\n\n # generate a dictionary of orthologous genes\n parse_blast(alignments_fp=alignments_fp,\n hits=hits,\n gene_map=gene_map,\n debug=debug)\n\n # keep only genes with >= min_num_homologs\n hits_min_num_homologs = {}\n max_homologs = 0\n for query in hits:\n len_hits = len(hits[query])\n if query in hits[query]:\n len_hits -= 1\n if len_hits >= min_num_homologs:\n if query in hits_min_num_homologs:\n raise ValueError(\"Duplicate gene names found: %s\" % query)\n hits_min_num_homologs[query] = hits[query]\n if len_hits > max_homologs:\n max_homologs = len_hits\n hits.clear()\n\n if verbose:\n sys.stdout.write(\n \"Total number of orthologous gene families with at \"\n \"least %s genes: %s\\n\" % (\n min_num_homologs, len(hits_min_num_homologs)))\n if debug:\n sys.stdout.write(\"[DEBUG] Blast matches:\\n\")\n for query in hits_min_num_homologs:\n sys.stdout.write(\n \"[DEBUG] %s: %s\\n\" % (query, hits_min_num_homologs[query]))\n # generate command for CLUSTALW\n phy_msa_fp = join(working_dir, \"msa.phy\")\n open(phy_msa_fp, 'a').close()\n dnd_msa_fp = join(working_dir, \"msa.dnd\")\n open(dnd_msa_fp, 'a').close()\n phylip_fp = join(working_dir, \"msa.dis\")\n open(phylip_fp, 'a').close()\n # create fasta file for each gene family and run CLUSTALW\n fasta_in_fp = join(working_dir, \"input.faa\")\n clustal_command_fp = join(working_dir, \"clustal_command.txt\")\n with open(clustal_command_fp, 'w') as clustal_command_f:\n clustal_command_f.write(\n '1\\n%s\\n2\\n9\\n1\\n4\\n\\n1\\n%s\\n%s\\nX\\n\\nX\\n' % (\n fasta_in_fp, phy_msa_fp, dnd_msa_fp))\n phylip_command_fp = join(working_dir, \"phylip_command.txt\")\n with open(phylip_command_fp, 'w') as phylip_command_f:\n phylip_command_f.write('%s\\nF\\n%s\\nR\\nY\\n' % (phy_msa_fp, phylip_fp))\n\n total_genes = len(hits_min_num_homologs)\n if verbose:\n sys.stdout.write(\"\\nRunning CLUSTALW and PROTDIST ..\\n\")\n if max_homologs > num_species:\n raise ValueError(\n \"max_homologs > num_species: %s > %s \" % (\n max_homologs, num_species))\n # distance matrix containing distances between all ortholog genes\n full_distance_matrix = numpy.zeros(\n shape=(total_genes, num_species, num_species), dtype=float)\n # dictionary to store all subsets of orthologs (keys) and\n # their number of occurrences (values) (maximum occurrences\n # is equal to the number of genes)\n species_set_dict = {}\n gene_bitvector_map = {}\n gene_id = {}\n for i, query in enumerate(hits_min_num_homologs):\n if verbose:\n print(\"Computing MSA and distances for gene %s .. (%s/%s)\" % (\n query, i+1, total_genes))\n gene_id[i] = query\n # generate a multiple sequence alignment\n # for each orthologous gene family\n launch_msa(fasta_in_fp=fasta_in_fp,\n clustal_command_fp=clustal_command_fp,\n ref_db=ref_db,\n gene_map=gene_map,\n hits=hits_min_num_homologs,\n query=query,\n timeout=timeout)\n\n # compute distances between each pair of sequences in MSA\n compute_distances(phylip_command_fp=phylip_command_fp,\n warnings=warnings)\n\n # Z-score normalize distance matrix and add results\n # to full distance matrix (for all genes)\n normalize_distances(phylip_fp=phylip_fp,\n full_distance_matrix=full_distance_matrix,\n num_species=num_species,\n full_distance_matrix_offset=i,\n species_set_dict=species_set_dict,\n gene_bitvector_map=gene_bitvector_map,\n debug=debug)\n\n # output_full_matrix(full_distance_matrix, num_species)\n\n # cluster gene families by species\n gene_clusters_dict = cluster_distances(\n species_set_dict=species_set_dict,\n species_set_size=species_set_size,\n hamming_distance=hamming_distance)\n\n # detect outlier genes per core cluster of genes\n with open(output_hgt_fp, 'w') as output_hgt_f:\n output_hgt_f.write(\"\\n# Candidate HGT genes: \\n\")\n for core_cluster in gene_clusters_dict:\n outlier_genes = detect_outlier_genes(\n species_set=gene_clusters_dict[core_cluster],\n gene_bitvector_map=gene_bitvector_map,\n full_distance_matrix=full_distance_matrix,\n stdev_offset=stdev_offset,\n outlier_hgt=outlier_hgt,\n num_species=num_species,\n total_genes=total_genes,\n debug=debug)\n\n if outlier_genes:\n for gene in outlier_genes:\n output_hgt_f(\"%s\\n\" % gene_id[gene])\n\n # output_full_matrix(outlier_genes, num_species)\n\n\n@click.command()\n@click.argument('query-proteome-fp', required=True,\n type=click.Path(resolve_path=True, readable=True, exists=True,\n file_okay=True))\n@click.argument('target-proteomes-dir', required=True,\n type=click.Path(resolve_path=True, readable=True, exists=True,\n file_okay=True))\n@click.argument('working-dir', required=True,\n type=click.Path(resolve_path=True, readable=True, exists=False,\n file_okay=True))\n@click.argument('output-hgt-fp', required=True,\n type=click.Path(resolve_path=True, readable=True, exists=False,\n file_okay=True))\n@click.option('--align-software', type=click.Choice(['diamond', 'blast']),\n required=False, default=['diamond'], show_default=True,\n help=\"Software to use for blasting sequences\")\n@click.option('--tabular-alignments-fp', required=False,\n type=click.Path(resolve_path=True, readable=True, exists=False,\n file_okay=True),\n help=\"Tabular alignments in m6 format (output from BLAST or \"\n \"DIAMOND)\")\n@click.option('--ext', multiple=True, type=str, required=False,\n default=['fa', 'fasta', 'faa'], show_default=True,\n help=\"File extensions of target proteomes (multiple extensions \"\n \"can be given by calling --ext ext1 --ext ext2)\")\n@click.option('--min-num-homologs', type=int, required=False, default=3,\n show_default=True, help=\"The mininum number of homologs \"\n \"(determined by BLAST search) for each \"\n \"gene to test\")\n@click.option('--e-value', type=float, required=False, default=10e-20,\n show_default=True, help=\"The E-value cutoff to identify \"\n \"orthologous genes using BLASTP\")\n@click.option('--threads', type=int, required=False, default=1,\n show_default=True, help=\"Number of threads to use\")\n@click.option('--stdev-offset', type=float, required=False, default=2.326,\n show_default=True, help=\"The number of standard deviations a \"\n \"gene's normalized distance is from \"\n \"the mean to identify it as an outlier \"\n \"for a species pair\")\n@click.option('--outlier-hgt', type=float, default=0.5, show_default=True,\n required=False, help=\"The fraction (value between (0,1]) of \"\n \"normalized pairwise distances over all \"\n \"species-pair vectors belonging to the \"\n \"same gene that are z-score standard \"\n \"deviations from the mean\")\n@click.option('--species-set-size', type=int, required=False, default=30,\n show_default=True, help=\"Threshold number of genes to consider \"\n \"a species set large (a species set is \"\n \"a set of genes whose orthologs are \"\n \"detectable in exactly the same subset \"\n \"of the considered species)\")\n@click.option('--hamming-distance', type=int, required=False, default=2,\n show_default=True, help=\"Distance between two binary vectors \"\n \"indicating the species in which the \"\n \"corresponding ortholog gene appears\")\n@click.option('--verbose', type=bool, required=False, default=False,\n show_default=True, help=\"Run in verbose mode\")\n@click.option('--debug', type=bool, required=False, default=False,\n show_default=True, help=\"Run in debug mode\")\n@click.option('--warnings', type=bool, required=False, default=False,\n show_default=True, help=\"Print program warnings\")\n@click.option('--timeout', type=int, required=False, default=120,\n show_default=True, help=\"Number of seconds to allow Clustalw \"\n \"to run per call\")\ndef distance_method_main(query_proteome_fp,\n target_proteomes_dir,\n working_dir,\n output_hgt_fp,\n align_software,\n tabular_alignments_fp,\n ext,\n min_num_homologs,\n e_value,\n threads,\n stdev_offset,\n outlier_hgt,\n species_set_size,\n hamming_distance,\n verbose,\n debug,\n warnings,\n timeout):\n \"\"\" Run the Distance-Method HGT detection algorithm.\n \"\"\"\n distance_method(query_proteome_fp=query_proteome_fp,\n target_proteomes_dir=target_proteomes_dir,\n working_dir=working_dir,\n output_hgt_fp=output_hgt_fp,\n align_software=align_software,\n tabular_alignments_fp=tabular_alignments_fp,\n ext=ext,\n min_num_homologs=min_num_homologs,\n e_value=e_value,\n threads=threads,\n stdev_offset=stdev_offset,\n outlier_hgt=outlier_hgt,\n species_set_size=species_set_size,\n hamming_distance=hamming_distance,\n verbose=verbose,\n debug=debug,\n warnings=warnings,\n timeout=timeout)\n\n\nif __name__ == \"__main__\":\n distance_method_main()\n", "meta": {"hexsha": "7e7e2e42028d4d52007ec63cc34fb75d38a5c747", "size": 46259, "ext": "py", "lang": "Python", "max_stars_repo_path": "horizomer/misc/distance-method/distance_method.py", "max_stars_repo_name": "biocore/horizomer", "max_stars_repo_head_hexsha": "6b30d7f3b79f4f4ce7cc6502f5b820c9b53ab52e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2017-10-17T12:27:07.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-09T14:34:05.000Z", "max_issues_repo_path": "horizomer/misc/distance-method/distance_method.py", "max_issues_repo_name": "biocore/WGS-HGT", "max_issues_repo_head_hexsha": "6b30d7f3b79f4f4ce7cc6502f5b820c9b53ab52e", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 59, "max_issues_repo_issues_event_min_datetime": "2015-09-11T22:22:39.000Z", "max_issues_repo_issues_event_max_datetime": "2017-05-30T18:31:15.000Z", "max_forks_repo_path": "horizomer/misc/distance-method/distance_method.py", "max_forks_repo_name": "biocore/WGS-HGT", "max_forks_repo_head_hexsha": "6b30d7f3b79f4f4ce7cc6502f5b820c9b53ab52e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 9, "max_forks_repo_forks_event_min_datetime": "2015-09-10T17:55:22.000Z", "max_forks_repo_forks_event_max_datetime": "2017-02-22T05:47:13.000Z", "avg_line_length": 39.1362098139, "max_line_length": 86, "alphanum_fraction": 0.5794764262, "include": true, "reason": "import numpy", "num_tokens": 10150, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.5078118642792043, "lm_q2_score": 0.37754068280545827, "lm_q1q2_score": 0.1917196379766835}} {"text": "\"\"\"\n\nThis module is used for constructing a `PyMC3' model of the power spectrum using\nthe outputs from asy_peakbag as priors. \n\n\"\"\"\n\nimport numpy as np\nimport pymc3 as pm\nimport warnings\nfrom .plotting import plotting\n\nclass peakbag(plotting):\n \"\"\" Class for the final peakbagging.\n\n This class is used after getting the frequency intervals from asy_peakbag,\n that include the $l=0,2$ mode pairs. \n \n The\n\n Examples\n --------\n Using peakbag from the star class instance (recommended) \n \n >>> st = pbjam.star(ID='KIC4448777', pg=pg, numax=[220.0, 3.0], \n dnu=[16.97, 0.01], teff=[4750, 100],\n bp_rp = [1.34, 0.01])\n >>> st.run_kde()\n >>> st.run_asy_peakbag(norders=7)\n >>> st.run_peakbag()\n\n Using peakbag on it's own. Requires output from `asy_peakbag'.\n \n >>> pb = pbjam.peakbag(st.asy_fit)\n >>> pb()\n \n Parameters\n ----------\n f : float, array\n Array of frequency bins of the spectrum (muHz). Truncated to the range\n around numax.\n snr : float, array\n Array of SNR values for the frequency bins in f (dimensionless).\n asy_fit : asy_fit\n The result from the asy_peakbag method.\n init : bool\n If true runs make_start and trim_ladder to prepare starting\n guesses for sampling and transforms the data onto a ladder.\n\n Attributes\n ----------\n f : float, ndarray\n Array of frequency bins of the spectrum (muHz). Truncated to the range\n around numax.\n snr : float, ndarray\n Array of SNR values for the frequency bins in f (dimensionless).\n asy_fit : asy_fit\n The result from the asy_peakbag method.\n This is a dictionary of 'modeID' and 'summary'.\n 'modeID' is a DataFrame with a list of modes and basic properties.\n 'summary' are summary statistics from the asymptotic_fit.\n See asy_peakbag asymptotic_fit for more details.\n\n \"\"\"\n\n def __init__(self, starinst, init=True, path=None, verbose=False):\n\n self.pg = starinst.pg\n self.f = starinst.f\n self.s = starinst.s\n self.asy_fit = starinst.asy_fit\n self.norders = self.asy_fit.norders\n if init:\n self.make_start()\n self.trim_ladder(verbose=verbose)\n self.gp0 = [] # Used for gp linewidth info.\n\n starinst.references._addRef('pymc3')\n \n starinst.peakbag = self\n\n\n def make_start(self):\n \"\"\" Set the starting model for peakbag\n \n Function uses the result of the asymptotic peakbagging and builds a \n dictionary of starting values for the peakbagging methods.\n\n \"\"\"\n\n idxl0 = self.asy_fit.modeID.ell == 0\n idxl2 = self.asy_fit.modeID.ell == 2\n\n l0 = self.asy_fit.modeID.loc[idxl0, 'nu_med'].values.flatten()\n l2 = self.asy_fit.modeID.loc[idxl2, 'nu_med'].values.flatten()\n\n l0, l2 = self.remove_outsiders(l0, l2)\n\n width = 10**(np.ones(len(l0)) * self.asy_fit.summary.loc['mode_width', 'mean']).flatten()\n height = (10**self.asy_fit.summary.loc['env_height', 'mean'] * \\\n np.exp(-0.5 * (l0 - 10**self.asy_fit.summary.loc['numax', 'mean'])**2 /\n (10**self.asy_fit.summary.loc['env_width', 'mean'])**2)).flatten()\n back = np.ones(len(l0))\n\n self.parnames = ['l0', 'l2', 'width0', 'width2', 'height0', 'height2',\n 'back']\n\n pars = [l0, l2, width, width, height, 0.7*height, back]\n\n self.start ={x:y for x,y in zip(self.parnames, pars)}\n\n self.n = np.linspace(0.0, 1.0, len(self.start['l0']))[:, None]\n\n def remove_outsiders(self, l0, l2):\n \"\"\" Drop outliers\n\n Drops modes where the guess frequency is outside of the supplied\n frequency range.\n \n Parameters\n ----------\n \n l0 : ndarray\n Array of l0 mode frequencies\n l2 : ndarray\n Array of l2 mode frequencies\n\n \"\"\"\n\n sel = np.where(np.logical_and(l0 < self.f.max(), l0 > self.f.min()))\n return l0[sel], l2[sel]\n\n def trim_ladder(self, lw_fac=10, extra=0.01, verbose=False):\n \"\"\" Turns mode frequencies into list of pairs\n \n This function turns the list of mode frequencies into pairs and then \n selects only the pairs in the ladder that have modes that are to be fit.\n\n Each pair is constructed so that the central frequency is\n the mid point between the l=0 and l=2 modes as determined by the\n information in the asy_fit dictionary.\n\n Parameters\n ----------\n lw_fac: float\n The factor by which the mode line width is multiplied in order\n to contribute to the pair width.\n extra: float\n The factor by which dnu is multiplied in order to contribute to\n the pair width.\n\n \"\"\"\n\n d02 = 10**self.asy_fit.summary.loc['d02', 'mean']\n d02_lw = d02 + lw_fac * 10**self.asy_fit.summary.loc['mode_width', 'mean']\n w = d02_lw + (extra * 10**self.asy_fit.summary.loc['dnu', 'mean'])\n bw = self.f[1] - self.f[0]\n w /= bw\n if verbose:\n print(f'w = {int(w)}')\n print(f'bw = {bw}')\n ladder_trim_f = np.zeros([len(self.start['l0']), int(w)])\n ladder_trim_s = np.zeros([len(self.start['l0']), int(w)])\n for idx, freq in enumerate(self.start['l0']):\n loc_mid_02 = np.argmin(np.abs(self.f - (freq - d02/2.0)))\n if loc_mid_02 == 0:\n warnings.warn('Did not find optimal pair location')\n if verbose:\n print(f'loc_mid_02 = {loc_mid_02}')\n print(f'w/2 = {int(w/2)}')\n ladder_trim_f[idx, :] = \\\n self.f[loc_mid_02 - int(w/2): loc_mid_02 - int(w/2) + int(w)]\n ladder_trim_s[idx, :] = \\\n self.s[loc_mid_02 - int(w/2): loc_mid_02 - int(w/2) + int(w) ]\n self.ladder_f = ladder_trim_f\n self.ladder_s = ladder_trim_s\n\n def lor(self, freq, w, h):\n \"\"\" Simple Lorentzian profile\n \n Calculates N Lorentzian profiles, where N is the number of pairs in the\n frequency list. \n \n Parameters\n ----------\n freq : float, ndarray\n Central frequencies the N Lorentzians\n w : float, ndarray\n Widths of the N Lorentzians\n h : float, ndarray\n Heights of the N Lorentzians \n \n Returns\n -------\n lors : ndarray\n A list containing one Lorentzian per pair.\n\n \"\"\"\n\n norm = 1.0 + 4.0 / w**2 * (self.ladder_f.T - freq)**2\n \n return h / norm\n\n def model(self, l0, l2, width0, width2, height0, height2, back):\n \"\"\"\n Calcuates a simple model of a flat backgroud plus two lorentzians\n for each of the N pairs in the list of frequencies under consideration.\n\n Parameters\n ----------\n l0 : ndarray\n Array of length N, of the l=0 mode frequencies.\n l2 : ndarray\n Array of length N, of the l=2 mode frequencies.\n width0 : ndarray\n Array of length N, of the l=0 mode widths.\n width2 : ndarray\n Array of length N, of the l=2 mode widths.\n height0 : ndarray\n Array of length N, of the l=0 mode heights.\n height2 : ndarray\n Array of length N, of the l=2 mode heights.\n back : ndarray\n Array of length N, of the background levels.\n\n Returns\n -------\n mod : ndarray\n A 2D array (or 'ladder') containing the calculated models for each\n of the N pairs.\n\n \"\"\"\n\n mod = np.ones(self.ladder_f.shape).T * back\n mod += self.lor(l0, width0, height0)\n mod += self.lor(l2, width2, height2)\n return mod.T\n\n def init_model(self, model_type):\n \"\"\" Initialize the pymc3 model for peakbag\n \n Sets up the pymc3 model to sample, to perform the final peakbagging. \n \n Two treatements of the mode widths are available, the default\n independent mode widths for each pair, or modeling the mode widths as\n a function of freqeuency as a Gaussian Process. \n\n Parameters\n ----------\n model_type : str\n Model choice for the mode widths. The default is to treat the all\n mode widths independently. Alternatively they can be modeled as\n a GP.\n\n \"\"\"\n\n self.pm_model = pm.Model()\n\n dnu = 10**self.asy_fit.summary.loc['dnu', 'mean']\n dnu_fac = 0.03 # Prior on mode frequency has width 3% of Dnu.\n height_fac = 0.4 # Lognorrmal prior on height has std=0.4.\n width_fac = 1.0 # Lognorrmal prior on width has std=1.0.\n back_fac = 0.5 # Lognorrmal prior on back has std=0.5.\n N = len(self.start['l2'])\n\n with self.pm_model:\n\n if model_type != 'model_gp':\n if model_type != 'simple': # defaults to simple if bad input\n warnings.warn('Model not defined - using simple model')\n width0 = pm.Lognormal('width0', mu=np.log(self.start['width0']),\n sigma=width_fac, shape=N)\n width2 = pm.Lognormal('width2', mu=np.log(self.start['width2']),\n sigma=width_fac, shape=N)\n\n self.init_sampler = 'adapt_diag'\n self.target_accept = 0.9\n\n elif model_type == 'model_gp':\n warnings.warn('This model is developmental - use carefully')\n # Place a GP over the l=0 mode widths ...\n m0 = pm.Normal('gradient0', 0, 10)\n c0 = pm.Normal('intercept0', 0, 10)\n sigma0 = pm.Lognormal('sigma0', np.log(1.0), 1.0)\n ls = pm.Lognormal('ls', np.log(0.3), 1.0)\n mean_func0 = pm.gp.mean.Linear(coeffs=m0, intercept=c0)\n cov_func0 = sigma0 * pm.gp.cov.ExpQuad(1, ls=ls)\n self.gp0 = pm.gp.Latent(cov_func=cov_func0, mean_func=mean_func0)\n ln_width0 = self.gp0.prior('ln_width0', X=self.n)\n width0 = pm.Deterministic('width0', pm.math.exp(ln_width0))\n # and on the l=2 mode widths\n m2 = pm.Normal('gradient2', 0, 10)\n c2 = pm.Normal('intercept2', 0, 10)\n sigma2 = pm.Lognormal('sigma2', np.log(1.0), 1.0)\n mean_func2 = pm.gp.mean.Linear(coeffs=m2, intercept=c2)\n cov_func2 = sigma2 * pm.gp.cov.ExpQuad(1, ls=ls)\n self.gp2 = pm.gp.Latent(cov_func=cov_func2, mean_func=mean_func2)\n ln_width2 = self.gp2.prior('ln_width2', X=self.n)\n width2 = pm.Deterministic('width2', pm.math.exp(ln_width2))\n\n self.init_sampler = 'advi+adapt_diag'\n self.target_accept = 0.99\n\n\n l0 = pm.Normal('l0', self.start['l0'], dnu*dnu_fac, shape=N)\n\n l2 = pm.Normal('l2', self.start['l2'], dnu*dnu_fac, shape=N)\n\n height0 = pm.Lognormal('height0', mu=np.log(self.start['height0']),\n sigma=height_fac, shape=N)\n height2 = pm.Lognormal('height2', mu=np.log(self.start['height2']),\n sigma=height_fac, shape=N)\n back = pm.Lognormal('back', mu=np.log(1.0), sigma=back_fac, shape=N)\n\n limit = self.model(l0, l2, width0, width2, height0, height2, back)\n \n pm.Gamma('yobs', alpha=1, beta=1.0/limit, observed=self.ladder_s)\n\n\n def _addPPRatio(self):\n \"\"\" Add the prior/posterior width ratio to summary\n \n Computes the ratio of the prior width and the posterior width. This is a\n quantity which indicates which probability predominantly informs the \n resulting mode frequency. If the ratio is < 1 the prior dominates, and\n vice versa for ratios > 1. \n \n No cut-off is made based on this ratio, it is merely to inform the user.\n \n \"\"\"\n \n dnu = 10**self.asy_fit.summary.loc['dnu', 'mean']\n \n log_ppr = np.log10((0.03*dnu))-np.log10(self.summary['sd'])\n \n idx = np.array(['l' in name for name in self.summary.index], dtype = 'bool')\n \n self.summary['log_ppr'] = np.nan\n \n self.summary.at[idx, 'log_ppr'] = log_ppr[idx]\n\n\n def __call__(self, model_type='simple', tune=1500, nthreads=1, maxiter=4,\n advi=False):\n \"\"\" Perform all the steps in peakbag.\n \n Initializes and samples the `PyMC3' model that is set up using the\n outputs from asy_peakbag as priors. \n\n Parameters\n ----------\n model_type : str\n Defaults to 'simple'.\n Can be either 'simple' or 'model_gp' which sets the type of model\n to be fitted to the data.\n tune : int, optional\n Numer of tuning steps passed to pym3.sample. Default is 1500.\n nthreads : int, optional\n Number of cores to use - passed to pym3.sample. Default is 1.\n maxiter : int, optional\n Number of times to attempt to reach convergence. Default is 4.\n advi : bool, optional\n Whether or not to fit using the fullrank_advi option in pymc3. \n Default is False.\n\n \"\"\"\n\n self.init_model(model_type=model_type)\n \n # REMOVE THIS WHEN pymc3 v3.8 is a bit older. \n try:\n rhatfunc = pm.diagnostics.gelman_rubin\n warnings.warn('pymc3.diagnostics.gelman_rubin is depcrecated; upgrade pymc3 to v3.8 or newer.', DeprecationWarning)\n except:\n rhatfunc = pm.stats.rhat\n \n\n if advi:\n with self.pm_model:\n cb = pm.callbacks.CheckParametersConvergence(every=1000,\n diff='absolute',\n tolerance=0.01)\n\n mean_field = pm.fit(n=200000, method='fullrank_advi',\n start=self.start,\n callbacks=[cb])\n self.traces = mean_field.sample(1000)\n else:\n Rhat_max = 10\n niter = 1\n while Rhat_max > 1.05:\n if niter > maxiter:\n warnings.warn('Did not converge!')\n break\n with self.pm_model:\n self.traces = pm.sample(tune=tune * niter, cores=nthreads,\n start=self.start,\n init=self.init_sampler,\n target_accept=self.target_accept,\n progressbar=False)\n Rhat_max = np.max([v.max() for k, v in rhatfunc(self.traces).items()])\n niter += 1\n \n # REMOVE THIS WHEN pymc3 v3.8 is a bit older\n try:\n self.summary = pm.summary(self.traces)\n except:\n self.summary = pm.stats.summary(self.traces)\n \n self.par_names = self.summary.index\n \n samps = np.array([self.traces[x] for x in self.traces.varnames if not x.endswith('_log__')])\n self.samples = np.array([]).reshape((samps.shape[1], 0))\n for i in range(samps.shape[0]): \n self.samples = np.concatenate((self.samples, samps[i, :, :]), axis =1)\n ", "meta": {"hexsha": "860a02fbea497abb0458922a5df57529e2730bcd", "size": 15648, "ext": "py", "lang": "Python", "max_stars_repo_path": "pbjam/peakbag.py", "max_stars_repo_name": "nielsenmb/PBjam", "max_stars_repo_head_hexsha": "973625e0cea1b8bf9cbdd621ec3483ac02ce8907", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 11, "max_stars_repo_stars_event_min_datetime": "2019-11-19T13:45:22.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-21T10:44:56.000Z", "max_issues_repo_path": "pbjam/peakbag.py", "max_issues_repo_name": "nielsenmb/PBjam", "max_issues_repo_head_hexsha": "973625e0cea1b8bf9cbdd621ec3483ac02ce8907", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 138, "max_issues_repo_issues_event_min_datetime": "2019-07-17T18:37:27.000Z", "max_issues_repo_issues_event_max_datetime": "2021-11-12T09:39:12.000Z", "max_forks_repo_path": "pbjam/peakbag.py", "max_forks_repo_name": "nielsenmb/PBjam", "max_forks_repo_head_hexsha": "973625e0cea1b8bf9cbdd621ec3483ac02ce8907", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 54, "max_forks_repo_forks_event_min_datetime": "2019-07-17T10:09:00.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-29T08:39:57.000Z", "avg_line_length": 37.6153846154, "max_line_length": 127, "alphanum_fraction": 0.5499744376, "include": true, "reason": "import numpy,import pymc3", "num_tokens": 3880, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792044, "lm_q2_score": 0.3775406687981454, "lm_q1q2_score": 0.19171963086360388}} {"text": "from __future__ import print_function\n\nimport string\nimport sys\nfrom collections import deque\n\nimport numpy as np\nfrom sklearn.base import BaseEstimator\nfrom sklearn.utils import check_array, check_random_state\nfrom sklearn.utils.validation import check_is_fitted\n\nfrom . import _hmmc\nfrom .utils import normalize, logsumexp, iter_from_X_lengths\n\n\nDECODER_ALGORITHMS = frozenset((\"viterbi\", \"map\"))\n\n\nclass ConvergenceMonitor(object):\n \"\"\"Monitors and reports convergence to :data:`sys.stderr`.\n\n Parameters\n ----------\n thresh : double\n Convergence threshold. The algorithm has convereged eitehr if\n the maximum number of iterations is reached or the log probability\n improvement between the two consecutive iterations is less than\n threshold.\n\n n_iter : int\n Maximum number of iterations to perform.\n\n verbose : bool\n If ``True`` then per-iteration convergence reports are printed,\n otherwise the monitor is mute.\n\n Attributes\n ----------\n history : deque\n The log probability of the data for the last two training\n iterations. If the values are not strictly increasing, the\n model did not converge.\n\n iter : int\n Number of iterations performed while training the model.\n \"\"\"\n fmt = \"{iter:>10d} {logprob:>16.4f} {delta:>+16.4f}\"\n\n def __init__(self, thresh, n_iter, verbose):\n self.thresh = thresh\n self.n_iter = n_iter\n self.verbose = verbose\n self.history = deque(maxlen=2)\n self.iter = 1\n\n def report(self, logprob):\n if self.history and self.verbose:\n delta = logprob - self.history[-1]\n message = self.fmt.format(\n iter=self.iter, logprob=logprob, delta=delta)\n print(message, file=sys.stderr)\n\n self.history.append(logprob)\n self.iter += 1\n\n @property\n def converged(self):\n return (self.iter == self.n_iter or\n (len(self.history) == 2 and\n self.history[1] - self.history[0] < self.thresh))\n\n\nclass _BaseHMM(BaseEstimator):\n \"\"\"Hidden Markov Model base class.\n\n Representation of a hidden Markov model probability distribution.\n This class allows for easy evaluation of, sampling from, and\n maximum-likelihood estimation of the parameters of a HMM.\n\n See the instance documentation for details specific to a\n particular object.\n\n Parameters\n ----------\n n_components : int\n Number of states in the model.\n\n startprob_prior : array, shape (n_components, )\n Initial state occupation prior distribution.\n\n transmat_prior : array, shape (n_components, n_components)\n Matrix of prior transition probabilities between states.\n\n algorithm : string, one of the ``DECODER_ALGORITHMS```\n Decoder algorithm.\n\n random_state: RandomState or an int seed (0 by default)\n A random number generator instance.\n\n n_iter : int, optional\n Maximum number of iterations to perform.\n\n thresh : float, optional\n Convergence threshold.\n\n verbose : bool, optional\n When ``True`` per-iteration convergence reports are printed\n to :data:`sys.stderr`. You can diagnose convergence via the\n :attr:`monitor_` attribute.\n\n params : string, optional\n Controls which parameters are updated in the training\n process. Can contain any combination of 's' for startprob,\n 't' for transmat, and other characters for subclass-specific\n emmission parameters. Defaults to all parameters.\n\n init_params : string, optional\n Controls which parameters are initialized prior to\n training. Can contain any combination of 's' for\n startprob, 't' for transmat, and other characters for\n subclass-specific emmission parameters. Defaults to all\n parameters.\n\n Attributes\n ----------\n startprob_ : array, shape (n_components, )\n Initial state occupation distribution.\n\n transmat_ : array, shape (n_components, n_components)\n Matrix of transition probabilities between states.\n \"\"\"\n\n # This class implements the public interface to all HMMs that\n # derive from it, including all of the machinery for the\n # forward-backward and Viterbi algorithms. Subclasses need only\n # implement _generate_sample_from_state(), _compute_log_likelihood(),\n # _init(), _initialize_sufficient_statistics(),\n # _accumulate_sufficient_statistics(), and _do_mstep(), all of\n # which depend on the specific emission distribution.\n #\n # Subclasses will probably also want to implement properties for\n # the emission distribution parameters to expose them publicly.\n\n def __init__(self, n_components=1,\n startprob_prior=1.0, transmat_prior=1.0,\n algorithm=\"viterbi\", random_state=None,\n n_iter=10, thresh=1e-2, verbose=False,\n params=string.ascii_letters,\n init_params=string.ascii_letters):\n self.n_components = n_components\n self.monitor_ = ConvergenceMonitor(thresh, n_iter, verbose)\n self.params = params\n self.init_params = init_params\n self.startprob_prior = startprob_prior\n self.transmat_prior = transmat_prior\n self.algorithm = algorithm\n self.random_state = random_state\n self.n_iter = n_iter\n self.thresh = thresh\n\n def score_samples(self, X, lengths=None):\n \"\"\"Compute the log probability under the model and compute posteriors.\n\n Parameters\n ----------\n X : array-like, shape (n_samples, n_features)\n Feature matrix of individual samples.\n lengths : array-like of integers, shape (n_sequences, ), optional\n Lengths of the individual sequences in ``X``. The sum of\n these should be ``n_samples``.\n\n Returns\n -------\n logprob : float\n Log likelihood of ``X``.\n\n posteriors : array, shape (n_samples, n_components)\n State-membership probabilities for each sample in ``X``.\n\n See Also\n --------\n score : Compute the log probability under the model.\n decode : Find most likely state sequence corresponding to ``X``.\n \"\"\"\n check_is_fitted(self, \"startprob_\")\n self._check()\n\n X = check_array(X)\n n_samples = X.shape[0]\n logprob = 0\n posteriors = np.zeros((n_samples, self.n_components))\n for i, j in iter_from_X_lengths(X, lengths):\n framelogprob = self._compute_log_likelihood(X[i:j])\n logprobij, fwdlattice = self._do_forward_pass(framelogprob)\n logprob += logprobij\n\n bwdlattice = self._do_backward_pass(framelogprob)\n posteriors[i:j] = self._compute_posteriors(fwdlattice, bwdlattice)\n return logprob, posteriors\n\n def score(self, X, lengths=None):\n \"\"\"Compute the log probability under the model.\n\n Parameters\n ----------\n X : array-like, shape (n_samples, n_features)\n Feature matrix of individual samples.\n lengths : array-like of integers, shape (n_sequences, ), optional\n Lengths of the individual sequences in ``X``. The sum of\n these should be ``n_samples``.\n\n Returns\n -------\n logprob : float\n Log likelihood of ``X``.\n\n See Also\n --------\n score_samples : Compute the log probability under the model and\n posteriors.\n decode : Find most likely state sequence corresponding to ``X``.\n \"\"\"\n check_is_fitted(self, \"startprob_\")\n self._check()\n\n # XXX we can unroll forward pass for speed and memory efficiency.\n logprob = 0\n for i, j in iter_from_X_lengths(X, lengths):\n framelogprob = self._compute_log_likelihood(X[i:j])\n logprobij, _fwdlattice = self._do_forward_pass(framelogprob)\n logprob += logprobij\n return logprob\n\n def _decode_viterbi(self, X):\n framelogprob = self._compute_log_likelihood(X)\n return self._do_viterbi_pass(framelogprob)\n\n def _decode_map(self, X):\n _, posteriors = self.score_samples(X)\n logprob = np.max(posteriors, axis=1).sum()\n state_sequence = np.argmax(posteriors, axis=1)\n return logprob, state_sequence\n\n def decode(self, X, lengths=None, algorithm=None):\n \"\"\"Find most likely state sequence corresponding to ``X``.\n\n Parameters\n ----------\n X : array-like, shape (n_samples, n_features)\n Feature matrix of individual samples.\n lengths : array-like of integers, shape (n_sequences, ), optional\n Lengths of the individual sequences in ``X``. The sum of\n these should be ``n_samples``.\n algorithm : string, one of the ``DECODER_ALGORITHMS``\n decoder algorithm to be used\n\n Returns\n -------\n logprob : float\n Log probability of the produced state sequence.\n\n state_sequence : array, shape (n_samples, )\n Labels for each sample from ``X`` obtained via a given\n decoder ``algorithm``.\n\n See Also\n --------\n score_samples : Compute the log probability under the model and\n posteriors.\n\n score : Compute the log probability under the model.\n \"\"\"\n check_is_fitted(self, \"startprob_\")\n self._check()\n\n algorithm = algorithm or self.algorithm\n if algorithm not in DECODER_ALGORITHMS:\n raise ValueError(\"Unknown decoder {0!r}\".format(algorithm))\n\n decoder = {\n \"viterbi\": self._decode_viterbi,\n \"map\": self._decode_map\n }[algorithm]\n\n X = check_array(X)\n n_samples = X.shape[0]\n logprob = 0\n state_sequence = np.empty(n_samples, dtype=int)\n for i, j in iter_from_X_lengths(X, lengths):\n # XXX decoder works on a single sample at a time!\n logprobij, state_sequenceij = decoder(X[i:j])\n logprob += logprobij\n state_sequence[i:j] = state_sequenceij\n\n return logprob, state_sequence\n\n def predict(self, X, lengths=None):\n \"\"\"Find most likely state sequence corresponding to ``X``.\n\n Parameters\n ----------\n X : array-like, shape (n_samples, n_features)\n Feature matrix of individual samples.\n lengths : array-like of integers, shape (n_sequences, ), optional\n Lengths of the individual sequences in ``X``. The sum of\n these should be ``n_samples``.\n\n Returns\n -------\n state_sequence : array, shape (n_samples, )\n Labels for each sample from ``X``.\n \"\"\"\n _, state_sequence = self.decode(X, lengths)\n return state_sequence\n\n def predict_proba(self, X, lengths=None):\n \"\"\"Compute the posterior probability for each state in the model.\n\n X : array-like, shape (n_samples, n_features)\n Feature matrix of individual samples.\n lengths : array-like of integers, shape (n_sequences, ), optional\n Lengths of the individual sequences in ``X``. The sum of\n these should be ``n_samples``.\n\n Returns\n -------\n posterios : array, shape (n_samples, n_components)\n State-membership probabilities for each sample from ``X``.\n \"\"\"\n _, posteriors = self.score_samples(X, lengths)\n return posteriors\n\n def sample(self, n_samples=1, random_state=None):\n \"\"\"Generate random samples from the model.\n\n Parameters\n ----------\n n_samples : int\n Number of samples to generate.\n\n random_state: RandomState or an int seed (0 by default)\n A random number generator instance. If ``None``, the object's\n random_state is used.\n\n Returns\n -------\n X : array, shape (n_samples, n_features)\n Feature matrix.\n state_sequence : array, shape (n_samples, )\n State sequence produced by the model.\n \"\"\"\n check_is_fitted(self, \"startprob_\")\n\n if random_state is None:\n random_state = self.random_state\n random_state = check_random_state(random_state)\n\n startprob_cdf = np.cumsum(self.startprob_)\n transmat_cdf = np.cumsum(self.transmat_, axis=1)\n\n currstate = (startprob_cdf > random_state.rand()).argmax()\n state_sequence = [currstate]\n X = [self._generate_sample_from_state(\n currstate, random_state=random_state)]\n\n for t in range(n_samples - 1):\n currstate = (transmat_cdf[currstate] > random_state.rand()) \\\n .argmax()\n state_sequence.append(currstate)\n X.append(self._generate_sample_from_state(\n currstate, random_state=random_state))\n\n return np.atleast_2d(X), np.array(state_sequence, dtype=int)\n\n def fit(self, X, lengths=None):\n \"\"\"Estimate model parameters.\n\n An initialization step is performed before entering the\n EM-algorithm. If you want to avoid this step for a subset of\n the parameters, pass proper ``init_params`` keyword argument\n to estimator's constructor.\n\n Parameters\n ----------\n X : array-like, shape (n_samples, n_features)\n Feature matrix of individual samples.\n lengths : array-like of integers, shape (n_sequences, )\n Lengths of the individual sequences in ``X``. The sum of\n these should be ``n_samples``.\n\n Returns\n -------\n self : object\n Returns self.\n \"\"\"\n X = check_array(X)\n self._init(X, lengths=lengths, params=self.init_params)\n self._check()\n\n for iter in range(self.n_iter):\n stats = self._initialize_sufficient_statistics()\n curr_logprob = 0\n for i, j in iter_from_X_lengths(X, lengths):\n framelogprob = self._compute_log_likelihood(X[i:j])\n logprob, fwdlattice = self._do_forward_pass(framelogprob)\n curr_logprob += logprob\n bwdlattice = self._do_backward_pass(framelogprob)\n posteriors = self._compute_posteriors(fwdlattice, bwdlattice)\n self._accumulate_sufficient_statistics(\n stats, X[i:j], framelogprob, posteriors, fwdlattice,\n bwdlattice, self.params)\n\n self.monitor_.report(curr_logprob)\n if self.monitor_.converged:\n break\n\n self._do_mstep(stats, self.params)\n\n return self\n\n def _do_viterbi_pass(self, framelogprob):\n n_observations, n_components = framelogprob.shape\n state_sequence, logprob = _hmmc._viterbi(\n n_observations, n_components, np.log(self.startprob_),\n np.log(self.transmat_), framelogprob)\n return logprob, state_sequence\n\n def _do_forward_pass(self, framelogprob):\n n_observations, n_components = framelogprob.shape\n fwdlattice = np.zeros((n_observations, n_components))\n _hmmc._forward(n_observations, n_components, np.log(self.startprob_),\n np.log(self.transmat_), framelogprob, fwdlattice)\n return logsumexp(fwdlattice[-1]), fwdlattice\n\n def _do_backward_pass(self, framelogprob):\n n_observations, n_components = framelogprob.shape\n bwdlattice = np.zeros((n_observations, n_components))\n _hmmc._backward(n_observations, n_components, np.log(self.startprob_),\n np.log(self.transmat_), framelogprob, bwdlattice)\n return bwdlattice\n\n def _compute_posteriors(self, fwdlattice, bwdlattice):\n log_gamma = fwdlattice + bwdlattice\n # gamma is guaranteed to be correctly normalized by logprob at\n # all frames, unless we do approximate inference using pruning.\n # So, we will normalize each frame explicitly in case we\n # pruned too aggressively.\n log_gamma += np.finfo(float).eps\n log_gamma -= logsumexp(log_gamma, axis=1)[:, np.newaxis]\n out = np.exp(log_gamma)\n normalize(out, axis=1)\n return out\n\n def _compute_log_likelihood(self, X):\n pass\n\n def _generate_sample_from_state(self, state, random_state=None):\n pass\n\n def _init(self, X, lengths, params):\n init = 1. / self.n_components\n if 's' in params or not hasattr(self, \"startprob_\"):\n self.startprob_ = np.full(self.n_components, init)\n if 't' in params or not hasattr(self, \"transmat_\"):\n self.transmat_ = np.full((self.n_components, self.n_components),\n init)\n\n def _check(self):\n self.startprob_ = np.asarray(self.startprob_)\n if len(self.startprob_) != self.n_components:\n raise ValueError(\"startprob_ must have length n_components\")\n if not np.allclose(self.startprob_.sum(), 1.0):\n raise ValueError(\"startprob_ must sum to 1.0 (got {0:.4f})\"\n .format(self.startprob_.sum()))\n\n self.transmat_ = np.asarray(self.transmat_)\n if self.transmat_.shape != (self.n_components, self.n_components):\n raise ValueError(\n \"transmat_ must have shape (n_components, n_components)\")\n if not np.allclose(self.transmat_.sum(axis=1), 1.0):\n raise ValueError(\"rows of transmat_ must sum to 1.0 (got {0})\"\n .format(self.transmat_.sum(axis=1)))\n\n # Methods used by self.fit()\n\n def _initialize_sufficient_statistics(self):\n stats = {'nobs': 0,\n 'start': np.zeros(self.n_components),\n 'trans': np.zeros((self.n_components, self.n_components))}\n return stats\n\n def _accumulate_sufficient_statistics(self, stats, seq, framelogprob,\n posteriors, fwdlattice, bwdlattice,\n params):\n stats['nobs'] += 1\n if 's' in params:\n stats['start'] += posteriors[0]\n if 't' in params:\n n_observations, n_components = framelogprob.shape\n # when the sample is of length 1, it contains no transitions\n # so there is no reason to update our trans. matrix estimate\n if n_observations <= 1:\n return\n\n lneta = np.zeros((n_observations - 1, n_components, n_components))\n _hmmc._compute_lneta(n_observations, n_components, fwdlattice,\n np.log(self.transmat_),\n bwdlattice, framelogprob, lneta)\n stats['trans'] += np.exp(logsumexp(lneta, axis=0))\n\n def _do_mstep(self, stats, params):\n # Based on Huang, Acero, Hon, \"Spoken Language Processing\",\n # p. 443 - 445\n if 's' in params:\n self.startprob_ = self.startprob_prior - 1.0 + stats['start']\n normalize(self.startprob_)\n if 't' in params:\n self.transmat_ = self.transmat_prior - 1.0 + stats['trans']\n normalize(self.transmat_, axis=1)\n", "meta": {"hexsha": "057861527b53a09ce99297455edda45c079d4ca2", "size": 19245, "ext": "py", "lang": "Python", "max_stars_repo_path": "hmmlearn/base.py", "max_stars_repo_name": "paschalidoud/hmmlearn", "max_stars_repo_head_hexsha": "9d1ef3e82f0ff4bc5fc81b0c2e928692d0c0f90d", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "hmmlearn/base.py", "max_issues_repo_name": "paschalidoud/hmmlearn", "max_issues_repo_head_hexsha": "9d1ef3e82f0ff4bc5fc81b0c2e928692d0c0f90d", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "hmmlearn/base.py", "max_forks_repo_name": "paschalidoud/hmmlearn", "max_forks_repo_head_hexsha": "9d1ef3e82f0ff4bc5fc81b0c2e928692d0c0f90d", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-05-14T08:41:28.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-14T08:41:28.000Z", "avg_line_length": 37.0096153846, "max_line_length": 78, "alphanum_fraction": 0.6196934269, "include": true, "reason": "import numpy", "num_tokens": 4243, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792043, "lm_q2_score": 0.37754066879814546, "lm_q1q2_score": 0.19171963086360388}} {"text": "from stuff import *\nimport sys,re,argparse,pickle\nfrom scipy.optimize import minimize\nfrom scipy.stats import norm\nfrom scipy.special import gammaln\nfrom math import log,exp,sqrt,sin,pi\nimport numpy as np\nfrom subprocess import Popen,PIPE\nfrom datetime import datetime\n\n# (Make it auto download files?)\n# Get ltla.csv from https://coronavirus.data.gov.uk/api/v2/data?areaType=ltla&metric=newCasesBySpecimenDate&format=csv\n# Sanger data from https://covid-surveillance-data.cog.sanger.ac.uk/download/lineages_by_ltla_and_week.tsv\n# COG-UK data from https://cog-uk.s3.climb.ac.uk/phylogenetics/latest/cog_metadata.csv\n# SGTF data from Fig.16 Tech Briefing 12: https://assets.publishing.service.gov.uk/government/uploads/system/uploads/attachment_data/file/988608/Variants_of_Concern_Technical_Briefing_12_Data_England.xlsx\n\n# LTLA_age.csv from https://api.coronavirus.data.gov.uk/v2/data?areaType=ltla&metric=newCasesBySpecimenDateAgeDemographics&format=csv\n\ndef sanitise(fn): return fn.replace(' ','_').replace(\"'\",\"\")\n\nltlaengdata=loadcsv(\"Local_Authority_District_to_Region__December_2020__Lookup_in_England.csv\")\nltla2region=dict(zip(ltlaengdata['LAD20CD'],ltlaengdata['RGN20NM']))\nltla2name=dict(zip(ltlaengdata['LAD20CD'],map(sanitise,ltlaengdata['LAD20NM'])))\nltlapopdata=loadcsv(\"LTLA-NIMS-populations.csv\")\n\n# 1. Sanger uses LAD19 except E06000053 (Isles of Scilly) isn't present. I assume it's fused into E06000052 (Cornwall).\n# 2. Dashboard/api use LAD19 except that E09000001 (City of London) has been fused into E09000012 (Hackney).\n# and E06000053 (Isles of Scilly) is fused into E06000052 (Cornwall).\n# 3. NIMS (population and vaccine data) uses LAD20 (E070000[4567] fused into E06000060).\n# Easier to fuse than to split, so standardise on LAD20 with E09000001 fused into E09000012 and E06000053 fused into E06000052.\nfuseltla=dict(zip(ltlaengdata['LAD20CD'],ltlaengdata['LAD20CD']))\nfuseltla['E07000004']='E06000060'\nfuseltla['E07000005']='E06000060'\nfuseltla['E07000006']='E06000060'\nfuseltla['E07000007']='E06000060'\nfuseltla['E09000001']='E09000012'\nfuseltla['E06000053']='E06000052'\n\ndef coglab2uk(x): return \"UK\"\ndef coglab2country(x): return x.split('/')[0].replace('_',' ')\ndef coglab2coglab(x): return x\ndef sgtf2region(x):\n if x=='Yorkshire and Humber': return 'Yorkshire and The Humber'\n return x\ndef sgtf2country(x): return 'England'\ndef includeltla(ltla,ltlaset):\n if ltlaset==\"London\":\n return ltla2region[ltla]=='London'\n elif ltlaset==\"test\":\n return ltla2region[ltla]=='London' and ltla<'E09000010'\n elif ltlaset==\"Bolton\":\n return ltla=='E08000001'\n elif ltlaset==\"Hartlepool\":\n return ltla=='E06000001'\n elif ltlaset==\"NE\":\n return ltla2region[ltla]=='North East'\n elif ltlaset==\"All\":\n return True\n else:\n raise RuntimeError(\"Unrecognised ltla set \"+ltlaset)\n\nparser=argparse.ArgumentParser()\nparser.add_argument('-l', '--load-options', help='Load options from a file')\nparser.add_argument('-s', '--save-options', help='Save options to a file')\nparser.add_argument('-g', '--graph-filename', help='Stem of graph filenames')\nargs=parser.parse_args()\n\n# Up to 5 parameters to be optimised:\n# 0: g Difference of weekly growth rates (g(V1)-g(V0)) for unvaccinated people\n# 1: rw Weight of region counts in hierarchy\n# 2: tw Weight of total counts in hierarchy\n# 3: r1 RR (= 1-VE) of vaccine for variant 1 (delta)\n# 4: r0 RR (= 1-VE) of vaccine for variant 0 (alpha)\n\ndesc=[\"Δg_week\",\"region_wt\",\"eng_wt\",\"r1\",\"r0\"]\n\n### Model ###\n### End Model ###\n\n\n### Options ###\n\nsource=\"Sanger\"\n#source=\"COG-UK\"\n#source=\"SGTF\"\n\n# Number of parameters to optimise\nN=4;r0=0.3\n#N=3\n#N=5\n\nvaxeffecttime=20# Days before vaccine is presumed to have a decent effect\n\n# Can choose location size from \"LTLA\", \"region\", \"country\", \"UK\"\n# Sanger works with LTLA, region, country\n# COG-UK works with country, UK\n# SGTF works with region, country\nlocationsize=\"LTLA\"\n\nltlaexclude=set()\n#ltlaexclude=set(['E08000001','E12000002'])# Bolton, Manchester\nltlaset=\"All\"\n#ltlaset=\"London\"\n#ltlaset=\"Bolton\"\n#ltlaset=\"Hartlepool\"\n\n# Will plot graph of these locations even if only encountered during subdivision of global growth mode\nspecialinterest=set(['E08000001'])\n\nmgt=5# Mean generation time in days\n\n# Earliest day to use case data\nminday=datetoday('2021-04-01')# Inclusive\n\n# Earliest day to use VOC count data, given as end-of-week. Will be rounded up to match same day of week as lastweek.\n#firstweek=minday+6\nfirstweek=datetoday('2021-05-01')\n\nnif1=0.048 # Non-independence factor (1/overdispersion) for cases (less than 1 means information is downweighted)\nnif2=0.255 # Non-independence factor (1/overdispersion) for VOC counts (ditto)\nisd0=1.0 # Inverse sd for prior on starting number of cases of non-B.1.617.2: assume starts off similar to total number of cases\nisd1=0.3 # Inverse sd for prior on starting number of cases of B.1.617.2 (0.3 is very weak)\nisd2=1 # Inverse sd for prior on transmission advantage (as growth rate per day). 0 means uniform prior. 1 is very weak.\n\n# Prior linking initial daily growth rate to estimate from pre-B.1.617.2 era\nsig0=0.004\n\n# Timescale in days over which growth rate can change significantly\n# (lower = more wiggles)\nbmsig=25\n\n# Lengthscale for filtered Brownian motion\n# (higher = greater amplitude for the wiggles)\nbmscale=0.01\n\n# Case ascertainment rate\nasc=0.4\n\n# Discard this many cases at the end of the list of cases by specimen day\ndiscardcasedays=3# Pro tem to allow for Wales and NI late reporting at weekends and bank holidays\n\n# Discard this many days of the latest COG data\ndiscardcogdays=2\n\nminopts={\"maxiter\":10000,\"eps\":1e-4}\n\nmode=\"local growth rates\"\n#mode=\"global growth rate\"\n#mode=\"fixed growth rate\",0.1\n\nvoclen=(1 if source==\"COG-UK\" else 7)\n\nconf=0.95\n\nmodel=\"scaledpoisson\"\n#model=\"NBBB\"\n#model=\"NBBB+magicprior\"\n\n### End options ###\n\nopts={\n \"Source\": source,\n \"Location size\": locationsize,\n \"LTLA set\": ltlaset,\n \"LTLA exclude\": list(ltlaexclude),\n \"Generation time (days)\": mgt,\n \"Earliest day for case data\": daytodate(minday),\n \"Earliest week (using end of week date) to use VOC count data\": daytodate(firstweek),\n \"Optimisation mode\": mode,\n \"nif1\": nif1,\n \"nif2\": nif2,\n \"Inverse sd for prior on initial non-B.1.617.2\": isd0,\n \"Inverse sd for prior on initial B.1.617.2\": isd1,\n \"Inverse sd for prior on growth\": isd2,\n \"Timescale of growth rate change (days)\": bmsig,\n \"Lengthscale for filtered Brownian motion\": bmscale,\n \"Case ascertainment rate\": asc,\n \"Number of days of case data to discard\": discardcasedays,\n \"Number of days of COG-UK data to discard\": discardcogdays,\n \"Minimiser options\": minopts,\n \"Length of time period over which VOC counts are given (days)\": voclen,\n \"Confidence level\": conf,\n \"Model\": model\n}\n\nif args.save_options!=None:\n with open(args.save_options,'w') as fp: json.dump(opts,fp,indent=2)\n\nif args.load_options!=None:\n with open(args.load_options,'r') as fp: lopts=json.load(fp)\n for x in lopts: opts[x]=lopts[x]\n \nsource=opts[\"Source\"]\nlocationsize=opts[\"Location size\"]\nltlaset=opts[\"LTLA set\"]\nltlaexclude=set(opts[\"LTLA exclude\"])\nmgt=opts[\"Generation time (days)\"]\nminday=datetoday(opts[\"Earliest day for case data\"])\nfirstweek=datetoday(opts[\"Earliest week (using end of week date) to use VOC count data\"])\nmode=opts[\"Optimisation mode\"]\nnif1=opts[\"nif1\"]\nnif2=opts[\"nif2\"]\nisd0=opts[\"Inverse sd for prior on initial non-B.1.617.2\"]\nisd1=opts[\"Inverse sd for prior on initial B.1.617.2\"]\nisd2=opts[\"Inverse sd for prior on growth\"]\nbmsig=opts[\"Timescale of growth rate change (days)\"]\nbmscale=opts[\"Lengthscale for filtered Brownian motion\"]\nasc=opts[\"Case ascertainment rate\"]\ndiscardcasedays=opts[\"Number of days of case data to discard\"]\ndiscardcogdays=opts[\"Number of days of COG-UK data to discard\"]\nminopts=opts[\"Minimiser options\"]\nvoclen=opts[\"Length of time period over which VOC counts are given (days)\"]\nconf=opts[\"Confidence level\"]\nmodel=opts[\"Model\"]\n\nzconf=norm.ppf((1+conf)/2)\n\nprint(\"Options:\")\nprint()\nfor x in sorted(list(opts)): print(\"%s:\"%x,opts[x])\nprint()\nsys.stdout.flush()\n\nnp.set_printoptions(precision=3,linewidth=150)\n\nokplaces=set(ltla for ltla in fuseltla.values() if includeltla(ltla,ltlaset) and not ltla in ltlaexclude)\nplaces=sorted(list(okplaces))\n\nif source==\"Sanger\":\n fullsource=\"Wellcome Sanger Institute\"\n assert voclen==7\n sanger=loadcsv(\"lineages_by_ltla_and_week.tsv\",sep='\\t')\n \n lastweek=datetoday(max(sanger['WeekEndDate']))\n nweeks=(lastweek-firstweek)//voclen+1\n # Sanger week number is nweeks-1-(lastweek-day)//voclen\n\n # Get Sanger (variant) data into a suitable form\n vocnum={}#ltla: np.zeros([nweeks,2],dtype=int) for ltla in ltla2region if ltla[0]=='E'}\n rvocnum={}\n for (date,lad19,var,n) in zip(sanger['WeekEndDate'],sanger['LTLA'],sanger['Lineage'],sanger['Count']):\n day=datetoday(date)\n week=nweeks-1-(lastweek-day)//voclen\n if week>=0 and week=4:\n r1=xx[3]\n if N>=5: r0_=xx[4]\n else: r0_=r0\n pp=pvax[place][w]\n if pp==[]:\n print(place,w,CD);raise RuntimeError(\"Shouldn't happen: Sanger[%s] has a case but api shows none\"%place)\n #if pic: print(\"%s.%d %8.5f %12g %12g\"%(place,w,p,CD[0]/AB[0],CD[1]/AB[1]),file=fp)\n else:\n r1=r0_=0\n pp=[(1,0)]\n tl=0;tn=0\n for (n,p) in pp:\n rho_=rho*(1-p+p*r1)/(1-p+p*r0_)\n s=AB[0]+rho_*AB[1]\n #print(AB,CD,rho_,s,p,r0_,r1)\n tl+=n*(CD[0]*log(AB[0]/s)+CD[1]*log(rho_*AB[1]/s))\n tn+=n\n assert tn>0\n tot+=tl/tn\n if const: tot+=gammaln(CD[0]+CD[1]+1)-gammaln(CD[0]+1)-gammaln(CD[1]+1)# Could make a table\n if pic: fp.close()\n return -tot\n\ndef Hessian(xx):\n eps=1e-3\n H=np.zeros([N,N])\n for i in range(N-1):\n for j in range(i+1,N):\n v=0\n eps1=eps/condition[i]\n eps2=eps/condition[j]\n for (s1,s2) in [(-1,-1),(-1,1),(1,-1),(1,1)]:\n x=np.copy(xx)\n x[i]+=s1*eps1\n x[j]+=s2*eps2\n v+=s1*s2*NLL(x*condition)\n e=v/(4*eps1*eps2)\n H[i,j]=e\n H[j,i]=e\n for i in range(N):\n x=np.copy(xx)\n v=0\n eps1=eps/condition[i]\n for s in [-1,0,1]:\n x=np.copy(xx)\n x[i]+=s*eps1\n v+=(s*s*3-2)*NLL(x*condition)\n H[i,i]=v/eps1**2\n return H\n\n# Returns log likelihood\ndef optimise(hint=[0.7,.25,.2,0.3,0.3][:N],statphase=False):\n xx=np.copy(hint)\n bounds=[(-5,10),(1e-2,100),(1e-2,100),(0.01,5),(0.01,5)][:N]\n res=minimize(NLL,xx*condition,bounds=bounds,method=\"SLSQP\",options=minopts)\n if not res.success:\n print(res)\n print(place)\n print(\"xx =\",xx)\n for x in sorted(list(opts)): print(\"%s:\"%x,opts[x])\n print(\"bounds =\",bounds)\n raise RuntimeError(res.message)\n xx=res.x/condition\n\n # Work out log likelihood including constant terms\n LL=-NLL(res.x,const=True)\n \n # If 'statphase', make the log likelihood a better approximation to log(integral over all parameters) using stationary phase approximation\n if statphase:\n H=Hessian(xx)\n det=np.linalg.det(H)\n if det<=0: print(\"Warning: Hessian not positive for %s. Can't make corrected log likelihood.\"%place);det=1\n LL+=N*log(2*pi)/2-log(det)/2\n\n # Return optimum xx log likelihood\n return res.x/condition,LL\n\n# Assumes xx is at a local max of log likelihood\ndef makesamples(xx,H=None):\n if H is None: H=Hessian(xx)\n Hcond=H/condition/condition[:,None]\n eig=np.linalg.eigh(Hcond)\n # np.diag(np.matmul(np.matmul(np.transpose(eig[1]),Hcond),eig[1])) ~= eig[0]\n if not (eig[0]>0).all(): print(\"Hessian not +ve definite so can't do full confidence calculation\");return None,None\n nsamp=100000\n t=norm.rvs(size=[nsamp,N])# nsamp x N\n sd=eig[0]**(-.5)# N\n u=t*sd# nsamp x N\n samp_cond=np.matmul(u,np.transpose(eig[1]))# nsamp x N\n samp=samp_cond/condition+xx\n cc=[]\n n0=int((1-conf)/2*nsamp)\n n1=int((1+conf)/2*nsamp)\n for i in range(N):\n a=list(samp[:,i])\n a.sort()\n cc.append((a[nsamp//2],a[n0],a[n1]))\n return samp,cc\n\ndef printplaceinfo(place,using=''):\n name=ltla2name.get(place,place)+using\n print()\n print(name)\n print(\"=\"*len(name))\n print()\n print(\" Nonvar Var Seen\")\n for w in range(nweeks):\n day0,day1=lastweek-(nweeks-w)*voclen+1,lastweek-(nweeks-1-w)*voclen\n print(daytodate(day0),\"-\",daytodate(day1),\"%6d %6d %6.0f\"%(vocnum[place][w][0],vocnum[place][w][1],sum(cases[place][day0-minday:day1-minday+1])))\n print()\n\nvaxdir='VaccinationData'\nvaxdat={}\nfor x in sorted(os.listdir(vaxdir)):\n f=x.find('20')\n vaxdat[x[f:f+10]]=loadcsv(os.path.join(vaxdir,x))\n\ndef parseage_api(age):\n if '_' in age: x=age.split('_');return int(x[0]),int(x[1])+1\n if age[-1]=='+': return int(age[:-1]),150\n if age=='unassigned': return 0,150\n else: raise RuntimeError(\"Unrecognised age band: \"+age)\n\n# D*.0-50,D*.50-55,...,D1.0-30,D1.30-35,D1.35-40,D1.40-45,...,D2.40-45,D2.45-50,...\ndef parseage_nimsvax(age):\n if age[:1]!='D': return None,None\n f=age.find('.')\n g=age.find('-',f+1)\n return (age[:f],(int(age[f+1:g]),int(age[g+1:])))\n\n# Under 16,16-29,30-34,35-39,40-44,45-49,50-54,55-59,60-64,65-69,70-74,75-79,80+,16+\ndef parseage_nimspop(age):\n if '-' in age: x=age.split('-');return int(x[0]),int(x[1])+1\n if age[:5]=='Under': return 0,int(age[6:])\n if age[-1]=='+': return int(age[:-1]),150\n return None\n\nltlaagecachedir=\"LTLA_age_cache\"\nltlaagecachename=\"LTLA_age_weekly_%s_+%dweeks.pickle\"%(daytodate(firstweek),nweeks)\nfn=os.path.join(ltlaagecachedir,ltlaagecachename)\nos.makedirs(ltlaagecachedir,exist_ok=True)\nif os.path.isfile(fn):\n with open(fn,'rb') as fp:\n caseages=pickle.load(fp)\nelse:\n print(\"Loading and processing case-age data from api\")\n # Todo: automate loading of LTLA_age.csv if not present or out of date.\n la=loadcsv(\"LTLA_age.csv\")\n date0=daytodate(lastweek)\n date1=max(la['date'])\n if date1=0 and w w/e %s\"%(id,daytodate(firstweek+w*7),daytodate(firstweek+w*7+7)))\n v=vaxdat[id]\n \n vaxnum={}# Map from LTLA -> age -> numvaxed\n for (i,lad20) in enumerate(v['LTLA Code']):\n ltla=fuseltla[lad20]\n if ltla in okplaces:\n if ltla not in vaxnum: vaxnum[ltla]={}\n for age in v:\n d,a=parseage_nimsvax(age)\n if a!=None:\n vaxnum[ltla][a]=vaxnum[ltla].get(a,0)+v[age][i]\n\n vaxpop={}# Map from LTLA -> age -> population\n for (i,lad20) in enumerate(ltlapopdata['LTLA Code']):\n ltla=fuseltla[lad20]\n if ltla in okplaces:\n if ltla not in vaxpop: vaxpop[ltla]={}\n for age in ltlapopdata:\n a=parseage_nimspop(age)\n if a!=None:\n vaxpop[ltla][a]=vaxpop[ltla].get(a,0)+ltlapopdata[age][i]\n \n for ltla in caseages:\n if ltla in okplaces:\n cas=caseages[ltla]\n vax=vaxnum[ltla]\n pop=vaxpop[ltla]\n pp=[]\n for ca in cas:\n n=cas[ca][w+1]\n if n==0: continue\n num=den=0\n for va in vax:\n # Want (vax number) as weighted by P(case age interval|vax age interval) = |ca intersect va|/|va|\n num+=max(min(va[1],ca[1],100)-max(va[0],ca[0]),0)/(min(va[1],100)-va[0])*vax[va]\n for pa in pop:\n den+=max(min(pa[1],ca[1],100)-max(pa[0],ca[0]),0)/(min(pa[1],100)-pa[0])*pop[pa]\n pp.append((n,min(num/den,1)))\n pvax[ltla][w]=pp\n\nxx,L=optimise()\nprint()\n\nprint(\"Variables:\",xx)\nprint(\"Log likelihood:\",L)\nNLL(xx*condition,const=True,pic=True)\nH=Hessian(xx)\nprint(\"Hessian:\");print(H)\neig=np.linalg.eigh(H)\nprint(\"Eigenvalues:\",eig[0])\nprint()\n\nh=xx[0]/7;dh=1/sqrt(H[0,0])/7\nprint(\"Logarithmic growth rate advantage/day: %.1f%% (%.1f%% - %.1f%%)\"%(h*100,(h-zconf*dh)*100,(h+zconf*dh)*100))\nprint(\"Multiplicative growth rate advantage/day: %.1f%% (%.1f%% - %.1f%%)\"%((exp(h)-1)*100,(exp(h-zconf*dh)-1)*100,(exp(h+zconf*dh)-1)*100))\nprint(\"R-number advantage: %.2f (%.2f - %.2f)\"%(exp(mgt*h),exp(mgt*(h-zconf*dh)),exp(mgt*(h+zconf*dh))))\nprint()\n\nprint(\"Confidence intervals from single variables:\")\nfor i in range(N):\n x=xx[i];dx=1/sqrt(H[i,i])\n print(\"%10s: %5.3f (%5.3f - %5.3f)\"%(desc[i],x,x-zconf*dx,x+zconf*dx))\nprint()\n\nprint(\"Confidence intervals from multivariate calculation:\")\nC=np.linalg.inv(H)\nfor i in range(N):\n x=xx[i];dx=sqrt(C[i,i])\n print(\"%10s: %5.3f (%5.3f - %5.3f)\"%(desc[i],x,x-zconf*dx,x+zconf*dx))\nprint()\n\nsamp,cc=makesamples(xx,H)\nprint(\"Confidence intervals from multivariate simulation:\")\nfor i in range(N):\n print(\"%10s: %5.3f (%5.3f - %5.3f)\"%((desc[i],)+cc[i]))\n\nif 0:\n l=list(pvax)\n l.sort(key=lambda x: pvax[x][3])\n for x in l:\n print(x,\"%5.0f %5.0f %5.0f %5.0f\"%tuple([z*100 for z in pvax[x]]),\" \",ltla2name[x])\n", "meta": {"hexsha": "a1fa2ecb6910e236b506bfecc716f7f47ba6e799", "size": 19767, "ext": "py", "lang": "Python", "max_stars_repo_path": "VOCgrowth/vocfit2.py", "max_stars_repo_name": "alex1770/Covid-19", "max_stars_repo_head_hexsha": "0212593bf5d9bcbb7009c7d1fb1710116ad8bf32", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2021-06-26T09:22:45.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-20T21:29:22.000Z", "max_issues_repo_path": "VOCgrowth/vocfit2.py", "max_issues_repo_name": "alex1770/Covid-19", "max_issues_repo_head_hexsha": "0212593bf5d9bcbb7009c7d1fb1710116ad8bf32", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-12-21T09:45:17.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-21T09:45:17.000Z", "max_forks_repo_path": "VOCgrowth/vocfit2.py", "max_forks_repo_name": "alex1770/Covid-19", "max_forks_repo_head_hexsha": "0212593bf5d9bcbb7009c7d1fb1710116ad8bf32", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-06-25T18:27:56.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-12T17:49:31.000Z", "avg_line_length": 34.497382199, "max_line_length": 206, "alphanum_fraction": 0.6741033035, "include": true, "reason": "import numpy,from scipy", "num_tokens": 6834, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792044, "lm_q2_score": 0.3775406687981454, "lm_q1q2_score": 0.19171963086360388}} {"text": "#!/usr/bin/env python3\n#\n# gw2wannier90 interface\n#\n# This file is distributed as part of the Wannier90 code and\n# under the terms of the GNU General Public License. See the\n# file `LICENSE' in the root directory of the Wannier90\n# distribution, or http://www.gnu.org/copyleft/gpl.txt\n#\n# The webpage of the Wannier90 code is www.wannier.org\n#\n# The Wannier90 code is hosted on GitHub:\n#\n# https://github.com/wannier-developers/wannier90\n#\n# Designed and tested with: Quantum Espresso and Yambo\n# This interface should work with any G0W0 code\n# Originally written by Stepan Tsirkin\n# Extended, developed and documented by Antimo Marrazzo\n#\n# Updated on February 19th, 2017 by Antimo Marrazzo (antimo.marrazzo@epfl.ch)\n# Updated on October 7th, 2019 by Junfeng Qiao (qiaojunfeng@outlook.com)\n#\nimport argparse\nfrom dataclasses import dataclass\nimport datetime\nimport glob\nimport os\nimport shutil\nimport subprocess\n\nimport numpy as np\nfrom scipy.io import FortranFile\n\n\ndef parse_args(args=None):\n\n parser = argparse.ArgumentParser(\n description=r\"\"\"### gw2wannier90 interface ###\n\nUsage: gw2wannier90.py seedname options\n\nOptions can be:\n mmn, amn, spn, unk, uhu, uiu,\n spn_formatted, unk_formatted, uhu_formatted, uiu_formatted,\n write_formatted\n\nIf no options are specified, all the files are considered.\n\nBe careful with unformatted files, they are compiler-dependent.\nA safer choice is to use (bigger) formatted files, with options:\n spn_formatted, uiu_formatted, uhu_formatted, unk_formatted\n\nIn default, the output format is the same as the input format.\nTo generate formatted files with unformatted input, use option:\n write_formatted\n\"\"\",\n formatter_class=argparse.RawTextHelpFormatter,\n )\n parser.add_argument(\n \"seedname\",\n metavar=\"seedname\",\n type=str,\n help=\"Seedname of Wannier90 files.\",\n )\n parser.add_argument(\n \"-o\",\n \"--output_seedname\",\n type=str,\n help=\"The seedname of output files. Default is input_seedname.gw\",\n )\n parser.add_argument(\n \"-e\",\n \"--extensions\",\n type=str,\n help=(\n \"Comma separated list of file extensions to be converted, \"\n \"e.g. `-e amn,mmn` will only convert seedname.amn and seedname.mmn files. \"\n \"If nothing provided, all files will be converted.\"\n ),\n )\n parser.add_argument(\n \"--no_sort\",\n action=\"store_true\",\n help=\"No sorting, only add GW corrections to eig.\",\n )\n\n parsed_args = parser.parse_args(args)\n\n return parsed_args\n\n\ndef get_path_to_executable(executable: str) -> str:\n \"\"\"Get path to local executable.\n :param executable: Name of executable in the $PATH variable\n :type executable: str\n :return: path to executable\n :rtype: str\n \"\"\"\n path = shutil.which(executable)\n if path is None:\n raise ValueError(f\"'{executable}' executable not found in PATH.\")\n return path\n\n\n@dataclass\nclass Chk:\n \"\"\"Class for storing matrices in seedname.chk file.\"\"\"\n\n header: str = None\n num_bands: int = None\n num_exclude_bands: int = None\n exclude_bands: np.ndarray = None\n real_lattice: np.ndarray = None\n recip_lattice: np.ndarray = None\n num_kpts: int = None\n mp_grid: list = None\n kpt_latt: np.ndarray = None\n nntot: int = None\n num_wann: int = None\n checkpoint: str = None\n have_disentangled: bool = None\n omega_invariant: float = None\n lwindow: np.ndarray = None\n ndimwin: np.ndarray = None\n u_matrix_opt: np.ndarray = None\n u_matrix: np.ndarray = None\n m_matrix: np.ndarray = None\n wannier_centres: np.ndarray = None\n wannier_spreads: np.ndarray = None\n\n def __eq__(self, other):\n if not isinstance(other, Chk):\n return NotImplemented(f\"comparing {self} {other}\")\n\n if other is self:\n return True\n\n eq = True\n\n eq = self.header == other.header\n if not eq:\n return False\n\n eq = self.num_bands == other.num_bands\n if not eq:\n return False\n\n eq = self.num_exclude_bands == other.num_exclude_bands\n if not eq:\n return False\n\n eq = np.allclose(self.exclude_bands, other.exclude_bands)\n if not eq:\n return False\n\n eq = np.allclose(self.real_lattice, other.real_lattice)\n if not eq:\n return False\n\n eq = np.allclose(self.recip_lattice, other.recip_lattice)\n if not eq:\n return False\n\n eq = self.num_kpts == other.num_kpts\n if not eq:\n return False\n\n eq = np.allclose(self.mp_grid, other.mp_grid)\n if not eq:\n return False\n\n eq = np.allclose(self.kpt_latt, other.kpt_latt)\n if not eq:\n return False\n\n eq = self.nntot == other.nntot\n if not eq:\n return False\n\n eq = self.num_wann == other.num_wann\n if not eq:\n return False\n\n eq = self.checkpoint == other.checkpoint\n if not eq:\n return False\n\n eq = self.have_disentangled == other.have_disentangled\n if not eq:\n return False\n\n eq = np.allclose(self.omega_invariant, other.omega_invariant)\n if not eq:\n return False\n\n eq = np.allclose(self.lwindow, other.lwindow)\n if not eq:\n return False\n\n eq = np.allclose(self.ndimwin, other.ndimwin)\n if not eq:\n return False\n\n eq = np.allclose(self.u_matrix_opt, other.u_matrix_opt)\n if not eq:\n return False\n\n eq = np.allclose(self.u_matrix, other.u_matrix)\n if not eq:\n return False\n\n eq = np.allclose(self.m_matrix, other.m_matrix)\n if not eq:\n return False\n\n eq = np.allclose(self.wannier_centres, other.wannier_centres)\n if not eq:\n return False\n\n eq = np.allclose(self.wannier_spreads, other.wannier_spreads)\n if not eq:\n return False\n\n return True\n\n\ndef read_chk(filename: str, formatted: bool = None, keep_temp: bool = False) -> Chk:\n \"\"\"Read seedname.chk file.\n\n :param filename: filename\n :type filename: str\n :param formatted: defaults to None, auto detect from filename.\n :type formatted: bool, optional\n :param keep_temp: for unformatted file, creat a tempdir and run w90chk2chk.x\n in it. If True, do not remove this tempdir. Defaults to False\n :type keep_temp: bool, optional\n :return: Chk\n :rtype: Chk\n \"\"\"\n import pathlib\n import tempfile\n\n chk = Chk()\n\n # From str to pathlib.Path\n filename = pathlib.Path(filename)\n\n if formatted is None:\n if filename.name.endswith(\".chk\"):\n formatted = False\n elif filename.name.endswith(\".chk.fmt\"):\n formatted = True\n else:\n raise ValueError(f\"Cannot detect the format of {filename}\")\n\n valid_exts = [\".chk\", \".chk.fmt\"]\n for ext in valid_exts:\n if filename.name.endswith(ext):\n seedname = filename.name[: -len(ext)]\n break\n else:\n raise ValueError(f\"{filename} not ends with {valid_exts}?\")\n\n if not formatted:\n w90chk2chk = get_path_to_executable(\"w90chk2chk.x\")\n tmpdir = pathlib.Path(tempfile.mkdtemp(dir=\".\"))\n # cd tmpdir so that `w90chk2chk.log` is inside tmpdir\n os.chdir(tmpdir)\n if filename.root == \"/\":\n os.symlink(filename, filename.name)\n else:\n os.symlink(pathlib.Path(\"..\") / filename, filename.name)\n call_args = [w90chk2chk, \"-export\", str(seedname)]\n # Some times need mpirun -n 1\n # call_args = ['mpirun', '-n', '1'] + call_args\n subprocess.check_call(call_args)\n os.chdir(\"..\")\n filename_fmt = f\"{tmpdir / filename.name}.fmt\"\n else:\n filename_fmt = filename\n\n # Read formatted chk file\n with open(filename_fmt) as handle:\n #\n chk.header = handle.readline().strip()\n #\n chk.num_bands = int(handle.readline().strip())\n #\n chk.num_exclude_bands = int(handle.readline().strip())\n #\n chk.exclude_bands = np.zeros(chk.num_exclude_bands, dtype=int)\n #\n if chk.num_exclude_bands > 0:\n # line = handle.readline().strip().split()\n # chk.exclude_bands[:] = [int(_) for _ in line]\n for i in range(chk.num_exclude_bands):\n line = handle.readline().strip()\n chk.exclude_bands[i] = int(line)\n # Just store as a 1D array\n chk.real_lattice = np.zeros(9)\n line = handle.readline().strip().split()\n chk.real_lattice[:] = [float(_) for _ in line]\n #\n chk.recip_lattice = np.zeros(9)\n line = handle.readline().strip().split()\n chk.recip_lattice[:] = [float(_) for _ in line]\n #\n chk.num_kpts = int(handle.readline().strip())\n #\n chk.mp_grid = [int(_) for _ in handle.readline().strip().split()]\n #\n chk.kpt_latt = np.zeros((3, chk.num_kpts))\n for ik in range(chk.num_kpts):\n chk.kpt_latt[:, ik] = [float(_) for _ in handle.readline().strip().split()]\n #\n chk.nntot = int(handle.readline().strip())\n #\n chk.num_wann = int(handle.readline().strip())\n #\n chk.checkpoint = handle.readline().strip()\n # 1 -> True, 0 -> False\n chk.have_disentangled = bool(handle.readline().strip())\n if chk.have_disentangled:\n #\n chk.omega_invariant = float(handle.readline().strip())\n #\n chk.lwindow = np.zeros((chk.num_bands, chk.num_kpts), dtype=bool)\n for ik in range(chk.num_kpts):\n for ib in range(chk.num_bands):\n # 1 -> True, 0 -> False\n chk.lwindow[ib, ik] = bool(int(handle.readline().strip()))\n #\n chk.ndimwin = np.zeros(chk.num_kpts, dtype=int)\n for ik in range(chk.num_kpts):\n chk.ndimwin[ik] = int(handle.readline().strip())\n #\n chk.u_matrix_opt = np.zeros(\n (chk.num_bands, chk.num_wann, chk.num_kpts), dtype=complex\n )\n for ik in range(chk.num_kpts):\n for iw in range(chk.num_wann):\n for ib in range(chk.num_bands):\n line = [float(_) for _ in handle.readline().strip().split()]\n chk.u_matrix_opt[ib, iw, ik] = line[0] + 1j * line[1]\n #\n chk.u_matrix = np.zeros(\n (chk.num_wann, chk.num_wann, chk.num_kpts), dtype=complex\n )\n for ik in range(chk.num_kpts):\n for iw in range(chk.num_wann):\n for ib in range(chk.num_wann):\n line = [float(_) for _ in handle.readline().strip().split()]\n chk.u_matrix[ib, iw, ik] = line[0] + 1j * line[1]\n #\n chk.m_matrix = np.zeros(\n (chk.num_wann, chk.num_wann, chk.nntot, chk.num_kpts), dtype=complex\n )\n for ik in range(chk.num_kpts):\n for inn in range(chk.nntot):\n for iw in range(chk.num_wann):\n for ib in range(chk.num_wann):\n line = [float(_) for _ in handle.readline().strip().split()]\n chk.m_matrix[ib, iw, inn, ik] = line[0] + 1j * line[1]\n #\n chk.wannier_centres = np.zeros((3, chk.num_wann), dtype=float)\n for iw in range(chk.num_wann):\n chk.wannier_centres[:, iw] = [\n float(_) for _ in handle.readline().strip().split()\n ]\n #\n chk.wannier_spreads = np.zeros(chk.num_wann, dtype=float)\n for iw in range(chk.num_wann):\n chk.wannier_spreads[iw] = float(handle.readline().strip())\n\n # Read binary chk file, however its compiler dependent,\n # and it seems scipy.io.FortranFile cannot handle bool type?\n #\n # handle = FortranFile(filename, \"r\")\n # #\n # chk.header = b\"\".join(handle.read_record(dtype=\"c\"))\n # #\n # chk.num_bands = handle.read_record(dtype=np.int32).item()\n # #\n # chk.num_exclude_bands = handle.read_record(dtype=np.int32).item()\n # #\n # chk.exclude_bands = np.zeros(chk.num_exclude_bands, dtype=int)\n # #\n # if chk.num_exclude_bands > 0:\n # line = handle.read_record(dtype=np.int32).reshape(chk.num_exclude_bands)\n # chk.exclude_bands[:] = line[:]\n # else:\n # # read empty record\n # handle.read_record(dtype=np.int32)\n # # Just store as a 1D array\n # chk.real_lattice = np.zeros(9)\n # line = handle.read_record(dtype=np.float64).reshape(9)\n # chk.real_lattice[:] = line[:]\n # #\n # chk.recip_lattice = np.zeros(9)\n # line = handle.read_record(dtype=float).reshape(9)\n # chk.recip_lattice[:] = line[:]\n # #\n # chk.num_kpts = handle.read_record(dtype=np.int32).item()\n # #\n # chk.mp_grid = handle.read_record(dtype=np.int32).reshape(3).tolist()\n # #\n # chk.kpt_latt = np.zeros((3, chk.num_kpts))\n # line = handle.read_record(dtype=float).reshape((3, chk.num_kpts), order='F')\n # chk.kpt_latt[:, :] = line[:, :]\n # #\n # chk.nntot = handle.read_record(dtype=np.int32).item()\n # #\n # chk.num_wann = handle.read_record(dtype=np.int32).item()\n # #\n # chk.checkpoint = b\"\".join(handle.read_record(dtype=\"c\"))\n # # 1 -> True, 0 -> False\n # chk.have_disentangled = bool(handle.read_record(dtype=np.int32))\n # if chk.have_disentangled:\n # #\n # chk.omega_invariant = handle.read_record(dtype=float).item()\n # #\n # chk.lwindow = np.zeros((chk.num_bands, chk.num_kpts), dtype=bool)\n # line = handle.read_record(dtype=np.int32)\n # line = line.reshape((chk.num_bands, chk.num_kpts), order='F')\n # chk.lwindow[:, :] = line[:, :]\n # #\n # chk.ndimwin = np.array(chk.num_kpts, dtype=int)\n # line = handle.read_record(dtype=int).reshape(chk.num_kpts)\n # chk.ndimwin[:] = line[:]\n # #\n # chk.u_matrix_opt = np.array((chk.num_bands, chk.num_wann, chk.num_kpts), dtype=complex)\n # line = handle.read_record(dtype=complex).reshape((chk.num_bands, chk.num_wann, chk.num_kpts), order='F')\n # chk.u_matrix_opt[:, :, :] = line[:, :, :]\n # #\n # chk.u_matrix = np.array((chk.num_wann, chk.num_wann, chk.num_kpts), dtype=complex)\n # line = handle.read_record(dtype=complex).reshape((chk.num_wann, chk.num_wann, chk.num_kpts), order='F')\n # chk.u_matrix[:, :, :] = line[:, :, :]\n # #\n # chk.m_matrix = np.array((chk.num_wann, chk.num_wann, chk.nntot, chk.num_kpts), dtype=complex)\n # line = handle.read_record(dtype=complex).reshape((chk.num_wann, chk.num_wann, chk.nntot, chk.num_kpts), order='F')\n # chk.m_matrix[:, :, :, :] = line[:, :, :, :]\n # #\n # chk.wannier_centres = np.array((3, chk.num_wann), dtype=float)\n # line = handle.read_record(dtype=float).reshape((3, chk.num_wann), order='F')\n # chk.wannier_centres[:, :] = line[:, :]\n # #\n # chk.wannier_spreads = np.array(chk.num_wann, dtype=float)\n # line = handle.read_record(dtype=float).reshape(chk.num_wann)\n # chk.wannier_spreads[:] = line[:]\n # #\n # handle.close()\n\n if not formatted:\n if not keep_temp:\n shutil.rmtree(tmpdir)\n\n return chk\n\n\ndef write_chk(\n chk: Chk, filename: str, formatted: bool = None, keep_temp: bool = False\n) -> None:\n \"\"\"Write chk file.\n\n :param chk: _description_\n :type chk: Chk\n :param filename: output filename\n :type filename: str\n :param formatted: defaults to None, i.e. auto detect by filename\n :type formatted: bool, optional\n :param keep_temp: _description_, defaults to False\n :type keep_temp: bool, optional\n \"\"\"\n import pathlib\n import tempfile\n\n # From str to pathlib.Path\n filename = pathlib.Path(filename)\n\n if formatted is None:\n if filename.name.endswith(\".chk\"):\n formatted = False\n elif filename.name.endswith(\".chk.fmt\"):\n formatted = True\n else:\n raise ValueError(f\"Cannot detect the format of {filename}\")\n\n valid_exts = [\".chk\", \".chk.fmt\"]\n for ext in valid_exts:\n if filename.name.endswith(ext):\n seedname = filename.name[: -len(ext)]\n break\n else:\n raise ValueError(f\"{filename} not ends with {valid_exts}?\")\n\n if not formatted:\n tmpdir = pathlib.Path(tempfile.mkdtemp(dir=\".\"))\n filename_fmt = f\"{tmpdir / filename.name}.fmt\"\n else:\n filename_fmt = filename\n\n # Write formatted chk file\n with open(filename_fmt, \"w\") as handle:\n #\n handle.write(f\"{chk.header}\\n\")\n #\n handle.write(f\"{chk.num_bands}\\n\")\n #\n handle.write(f\"{chk.num_exclude_bands}\\n\")\n #\n if chk.num_exclude_bands > 0:\n # line = \" \".join([str(_) for _ in chk.exclude_bands])\n # handle.write(f\"{line}\\n\")\n for i in range(chk.num_exclude_bands):\n line = f\"{chk.exclude_bands[i]}\"\n handle.write(f\"{line}\\n\")\n # Just store as a 1D array\n line = \" \".join([f\"{_:22.16f}\" for _ in chk.real_lattice])\n handle.write(f\"{line}\\n\")\n #\n line = \" \".join([f\"{_:22.16f}\" for _ in chk.recip_lattice])\n handle.write(f\"{line}\\n\")\n #\n handle.write(f\"{chk.num_kpts}\\n\")\n #\n line = \" \".join([f\"{_}\" for _ in chk.mp_grid])\n handle.write(f\"{line}\\n\")\n #\n for ik in range(chk.num_kpts):\n line = \" \".join([f\"{_:22.16f}\" for _ in chk.kpt_latt[:, ik]])\n handle.write(f\"{line}\\n\")\n #\n handle.write(f\"{chk.nntot}\\n\")\n #\n handle.write(f\"{chk.num_wann}\\n\")\n #\n handle.write(f\"{chk.checkpoint}\\n\")\n # 1 -> True, 0 -> False\n line = 1 if chk.have_disentangled else 0\n handle.write(f\"{line}\\n\")\n if chk.have_disentangled:\n #\n handle.write(f\"{chk.omega_invariant:22.16f}\\n\")\n #\n for ik in range(chk.num_kpts):\n for ib in range(chk.num_bands):\n # 1 -> True, 0 -> False\n line = 1 if chk.lwindow[ib, ik] else 0\n handle.write(f\"{line}\\n\")\n #\n for ik in range(chk.num_kpts):\n handle.write(f\"{chk.ndimwin[ik]}\\n\")\n #\n for ik in range(chk.num_kpts):\n for iw in range(chk.num_wann):\n for ib in range(chk.num_bands):\n line = chk.u_matrix_opt[ib, iw, ik]\n line = \" \".join([f\"{_:22.16f}\" for _ in [line.real, line.imag]])\n handle.write(f\"{line}\\n\")\n #\n for ik in range(chk.num_kpts):\n for iw in range(chk.num_wann):\n for ib in range(chk.num_wann):\n line = chk.u_matrix[ib, iw, ik]\n line = \" \".join([f\"{_:22.16f}\" for _ in [line.real, line.imag]])\n handle.write(f\"{line}\\n\")\n #\n for ik in range(chk.num_kpts):\n for inn in range(chk.nntot):\n for iw in range(chk.num_wann):\n for ib in range(chk.num_wann):\n line = chk.m_matrix[ib, iw, inn, ik]\n line = \" \".join([f\"{_:22.16f}\" for _ in [line.real, line.imag]])\n handle.write(f\"{line}\\n\")\n #\n for iw in range(chk.num_wann):\n line = \" \".join([f\"{_:22.16f}\" for _ in chk.wannier_centres[:, iw]])\n handle.write(f\"{line}\\n\")\n #\n for iw in range(chk.num_wann):\n line = f\"{chk.wannier_spreads[iw]:22.16f}\"\n handle.write(f\"{line}\\n\")\n\n if not formatted:\n w90chk2chk = get_path_to_executable(\"w90chk2chk.x\")\n # cd tmpdir so that `w90chk2chk.log` is inside tmpdir\n os.chdir(tmpdir)\n call_args = [w90chk2chk, \"-import\", str(seedname)]\n # Some times need mpirun -n 1\n # call_args = ['mpirun', '-n', '1'] + call_args\n subprocess.check_call(call_args)\n os.chdir(\"..\")\n shutil.copy(tmpdir / f\"{seedname}.chk\", filename.name)\n\n if not keep_temp:\n shutil.rmtree(tmpdir)\n\n\ndef reorder_chk(seedname_in: str, seedname_out: str, bandsort: np.ndarray) -> None:\n print(\"----------\\n CHK module \\n----------\")\n filename_in = f\"{seedname_in}.chk\"\n filename_out = f\"{seedname_out}.chk\"\n\n if not os.path.exists(filename_in):\n print(f\"WARNING: {filename_out} not written\")\n return\n\n chk = read_chk(filename_in, formatted=False)\n\n # if chk.num_exclude_bands > 0:\n # # chk.exclude_bands =\n # # raise NotImplementedError(\"does not support exclude bands\")\n\n if chk.have_disentangled:\n for ik in range(chk.num_kpts):\n chk.lwindow[:, ik] = chk.lwindow[bandsort[ik], ik]\n chk.u_matrix_opt[:, :, ik] = chk.u_matrix_opt[bandsort[ik], :, ik]\n else:\n chk.u_matrix[:, :, ik] = chk.u_matrix[bandsort[ik], :, ik]\n\n write_chk(chk, filename_out, formatted=False)\n\n print(\"----------\\n CHK - OK \\n----------\\n\")\n\n\ndef _test_chk():\n import os\n import pathlib\n\n from gw2wannier90 import read_chk, write_chk\n\n PATH = os.environ[\"PATH\"]\n w90_path = \"/home/jqiao/git/wannier90\"\n os.environ[\"PATH\"] = f\"{w90_path}:{PATH}\"\n\n LD_LIBRARY_PATH = os.environ.get(\"LD_LIBRARY_PATH\", \"\")\n mkl_path = \"/opt/intel/oneapi/mpi/2021.4.0/libfabric/lib:/opt/intel/oneapi/mpi/2021.4.0/lib/release:/opt/intel/oneapi/mpi/2021.4.0/lib:/opt/intel/oneapi/mkl/2021.4.0/lib/intel64:/opt/intel/oneapi/compiler/2021.4.0/linux/lib:/opt/intel/oneapi/compiler/2021.4.0/linux/lib/x64:/opt/intel/oneapi/compiler/2021.4.0/linux/lib/emu:/opt/intel/oneapi/compiler/2021.4.0/linux/compiler/lib/intel64_lin\"\n os.environ[\"LD_LIBRARY_PATH\"] = f\"{mkl_path}:{LD_LIBRARY_PATH}\"\n\n curdir = pathlib.Path(__file__).parent\n\n chk = read_chk(curdir / \"read_chk/silicon.chk\")\n\n write_chk(chk, curdir / \"osilicon.chk.fmt\", formatted=True)\n\n chk2 = read_chk(curdir / \"osilicon.chk.fmt\")\n\n write_chk(chk2, curdir / \"osilicon.chk\")\n\n print(chk == chk2)\n\n\ndef gw2wannier90(\n seedname: str, seednameGW: str, targets: list, no_sort: bool = False\n) -> None:\n print(\"------------------------------\")\n print(\"##############################\")\n print(\"### gw2wannier90 interface ###\")\n print(\"##############################\")\n print(f\"Started on {datetime.datetime.now()}\")\n\n # In case of formatted spn, uIu, uHu and UNK (mmn, amn, eig are formatted by default)\n # NB: Formatted output is strongly reccommended! Fortran binaries are compilers dependent.\n SPNformatted = \"spn_formatted\" in targets\n UIUformatted = \"uiu_formatted\" in targets\n UHUformatted = \"uhu_formatted\" in targets\n UNKformatted = \"unk_formatted\" in targets\n write_formatted = \"write_formatted\" in targets\n\n if set(targets).intersection({\"spn\", \"uhu\", \"mmn\", \"amn\", \"unk\", \"uiu\", \"chk\"}):\n calcAMN = \"amn\" in targets\n calcMMN = \"mmn\" in targets\n calcUHU = \"uhu\" in targets\n calcUIU = \"uiu\" in targets\n calcSPN = \"spn\" in targets\n calcUNK = \"unk\" in targets\n calcCHK = \"chk\" in targets\n else:\n calcAMN = True\n calcMMN = True\n calcUHU = True\n calcUIU = True\n calcSPN = True\n calcUNK = True\n calcCHK = True\n\n if calcUHU:\n calcMMN = True\n if calcUIU:\n calcMMN = True\n\n if no_sort:\n calcAMN = False\n calcMMN = False\n calcUHU = False\n calcUIU = False\n calcSPN = False\n calcUNK = False\n calcCHK = False\n\n # Here we open a file to dump all the intermediate steps (mainly for debugging)\n f_raw = open(seednameGW + \".gw2wannier90.raw\", \"w\")\n # Opening seedname.nnkp file\n f = open(seedname + \".nnkp\")\n # It copies the seedname.win for GW, we should make this optional\n # shutil.copy(seedname+\".win\",seednameGW+\".win\")\n while True:\n s = f.readline()\n if \"begin kpoints\" in s:\n break\n NKPT = int(f.readline())\n print(\"Kpoints number:\", NKPT)\n n1 = np.array(NKPT, dtype=int)\n IKP = [\n tuple(\n np.array(\n np.round(np.array(f.readline().split(), dtype=float) * n1), dtype=int\n )\n )\n for i in range(NKPT)\n ]\n\n while True:\n s = f.readline()\n if \"begin nnkpts\" in s:\n break\n NNB = int(f.readline())\n\n KPNB = np.array(\n [\n [int(f.readline().split()[1]) - 1 for inb in range(NNB)]\n for ikpt in range(NKPT)\n ]\n )\n\n while True:\n s = f.readline()\n if \"begin exclude_bands\" in s:\n break\n exbands = np.array(f.readline().split(), dtype=int)\n if len(exbands) > 1 or exbands[0] != 0:\n print(\n \"Exclude bands option is used: be careful to be consistent \"\n \"with the choice of bands for the GW QP corrections.\"\n )\n nexbands = exbands[0]\n exbands = np.zeros(nexbands, dtype=int)\n for i in range(nexbands):\n exbands[i] = int(f.readline().strip())\n # 0-based indexing\n exbands -= 1\n else:\n exbands = np.array([], dtype=int)\n\n eigenDFT = np.loadtxt(seedname + \".eig\")\n nk = int(eigenDFT[:, 1].max())\n assert nk == NKPT\n nbndDFT = int(eigenDFT[:, 0].max())\n eigenDFT = eigenDFT[:, 2].reshape(NKPT, nbndDFT, order=\"C\")\n # print(eigenDFT)\n f_raw.write(\"------------------------------\\n\")\n f_raw.write(\"Writing DFT eigenvalues\\n\")\n for line in eigenDFT:\n f_raw.write(str(line) + \"\\n\")\n f_raw.write(\"------------------------------\\n\")\n\n corrections = np.loadtxt(seedname + \".gw.unsorted.eig\")\n # Indexing with dict is too slow, use np.array instead.\n # corrections = {(int(l[1]) - 1, int(l[0]) - 1): l[2] for l in corrections}\n # print(corrections)\n corrections_val = np.zeros((nk, nbndDFT + len(exbands)))\n corrections_mask = np.zeros_like(corrections_val, dtype=bool)\n idx_b = corrections[:, 0].astype(int) - 1\n idx_k = corrections[:, 1].astype(int) - 1\n corrections_val[idx_k, idx_b] = corrections[:, 2]\n corrections_mask[idx_k, idx_b] = True\n # Strip excluded bands\n if len(exbands) > 0:\n corrections_val = np.delete(corrections_val, exbands, axis=1)\n corrections_mask = np.delete(corrections_mask, exbands, axis=1)\n print(\"G0W0 QP corrections read from \", seedname + \".gw.unsorted.eig\")\n\n # providedGW = [\n # ib\n # for ib in range(nbndDFT)\n # if all((ik, ib) in list(corrections.keys()) for ik in range(NKPT))\n # ]\n providedGW = [ib for ib in range(nbndDFT) if np.all(corrections_mask[:, ib])]\n # print(providedGW)\n f_raw.write(\"------------------------------\\n\")\n f_raw.write(\"List of provided GW corrections (bands indexes)\\n\")\n f_raw.write(str(providedGW) + \"\\n\")\n f_raw.write(\"------------------------------\\n\")\n NBND = len(providedGW)\n print(\"Adding GW QP corrections to KS eigenvalues\")\n # eigenDE = np.array(\n # [[corrections[(ik, ib)] for ib in providedGW] for ik in range(NKPT)]\n # )\n # eigenDFTGW = np.array(\n # [\n # [eigenDFT[ik, ib] + corrections[(ik, ib)] for ib in providedGW]\n # for ik in range(NKPT)\n # ]\n # )\n eigenDE = corrections_val[:, providedGW]\n eigenDFTGW = eigenDFT[:, providedGW] + eigenDE\n\n f_raw.write(\"------------------------------\\n\")\n f_raw.write(\"Writing GW eigenvalues unsorted (KS + QP correction)\\n\")\n for line in eigenDFTGW:\n f_raw.write(str(line) + \"\\n\")\n f_raw.write(\"------------------------------\\n\")\n\n if no_sort:\n print(\"No sorting\")\n else:\n print(\"Sorting\")\n bsort = np.array([np.argsort(eigenDFTGW[ik, :]) for ik in range(NKPT)])\n\n # Even if no_sort, I still output sorting list for reference\n f_raw.write(\"------------------------------\\n\")\n f_raw.write(\"Writing sorting list\\n\")\n for line in bsort:\n f_raw.write(str(line) + \"\\n\")\n f_raw.write(\"------------------------------\\n\")\n\n if not no_sort:\n eigenDE = np.array([eigenDE[ik][bsort[ik]] for ik in range(NKPT)])\n eigenDFTGW = np.array([eigenDFTGW[ik][bsort[ik]] for ik in range(NKPT)])\n BANDSORT = np.array([np.array(providedGW)[bsort[ik]] for ik in range(NKPT)])\n\n f_raw.write(\"------------------------------\\n\")\n f_raw.write(\"Writing sorted GW eigenvalues\\n\")\n for line in eigenDFTGW:\n f_raw.write(str(line) + \"\\n\")\n f_raw.write(\"------------------------------\\n\")\n\n print(\"GW eigenvalues sorted\")\n\n # print eigenDFT\n print(\"------------------------------\")\n print(\"writing \" + seednameGW + \".eig\")\n feig_out = open(seednameGW + \".eig\", \"w\")\n for ik in range(NKPT):\n for ib in range(NBND):\n feig_out.write(f\" {ib + 1:4d} {ik + 1:4d} {eigenDFTGW[ik, ib]:17.12f}\\n\")\n feig_out.close()\n print(seednameGW + \".eig\", \" written.\")\n print(\"------------------------------\\n\")\n\n if calcAMN:\n try:\n print(\"----------\\n AMN module \\n----------\")\n f_amn_out = open(seednameGW + \".amn\", \"w\")\n f_amn_in = open(seedname + \".amn\")\n s = f_amn_in.readline().strip()\n print(s)\n f_amn_out.write(\n \"{}, sorted by GW quasi-particle energies on {} \\n\".format(\n s, datetime.datetime.now().isoformat()\n )\n )\n s = f_amn_in.readline()\n nb, nk, npr = np.array(s.split(), dtype=int)\n assert nk == NKPT\n assert nb == nbndDFT\n f_amn_out.write(f\" {NBND} {nk} {npr} \\n\")\n\n AMN = np.loadtxt(f_amn_in, dtype=float)[:, 3:5]\n AMN = np.reshape(AMN[:, 0] + AMN[:, 1] * 1j, (nb, npr, nk), order=\"F\")\n for ik in range(nk):\n amn = AMN[BANDSORT[ik], :, ik]\n for ipr in range(npr):\n for ib in range(NBND):\n f_amn_out.write(\n \" {:4d} {:4d} {:4d} {:16.12f} {:16.12f}\\n\".format(\n ib + 1,\n ipr + 1,\n ik + 1,\n amn[ib, ipr].real,\n amn[ib, ipr].imag,\n )\n )\n f_amn_in.close()\n f_amn_out.close()\n print(\"----------\\n AMN - OK \\n----------\\n\")\n except OSError as err:\n print(f\"WARNING: {seednameGW}.amn not written : \", err)\n\n if calcMMN:\n try:\n print(\"----------\\n MMN module \\n----------\")\n\n f_mmn_out = open(os.path.join(seednameGW + \".mmn\"), \"w\")\n f_mmn_in = open(os.path.join(seedname + \".mmn\"))\n\n s = f_mmn_in.readline().strip()\n print(s)\n f_mmn_out.write(\n \"{}, sorted by GW quasi-particle energies on {} \\n\".format(\n s, datetime.datetime.now().isoformat()\n )\n )\n s = f_mmn_in.readline()\n nb, nk, nnb = np.array(s.split(), dtype=int)\n assert nb == nbndDFT\n assert nk == NKPT\n f_mmn_out.write(f\" {NBND} {nk} {nnb} \\n\")\n\n MMN = np.zeros((nk, nnb, NBND, NBND), dtype=complex)\n for ik in range(nk):\n for ib in range(nnb):\n s = f_mmn_in.readline()\n f_mmn_out.write(s)\n ik1, ik2 = (int(i) - 1 for i in s.split()[:2])\n assert ik == ik1\n assert KPNB[ik][ib] == ik2\n tmp = np.array(\n [\n [f_mmn_in.readline().split() for m in range(nb)]\n for n in range(nb)\n ],\n dtype=str,\n )\n tmp = np.array(\n tmp[BANDSORT[ik2], :, :][:, BANDSORT[ik1], :], dtype=float\n )\n tmp = (tmp[:, :, 0] + 1j * tmp[:, :, 1]).T\n MMN[ik, ib, :, :] = tmp\n for n in range(NBND):\n for m in range(NBND):\n f_mmn_out.write(\n \" {:16.12f} {:16.12f}\\n\".format(\n tmp[m, n].real, tmp[m, n].imag\n )\n )\n print(\"----------\\n MMN OK \\n----------\\n\")\n except OSError as err:\n print(f\"WARNING: {seednameGW}.mmn not written : \", err)\n if calcUHU:\n print(f\"WARNING: {seednameGW}.uHu file also will not be written : \")\n calcUHU = False\n\n def reorder_uXu(ext, formatted=False):\n try:\n print(f\"----------\\n {ext} module \\n----------\")\n\n if formatted:\n f_uXu_in = open(seedname + \".\" + ext)\n f_uXu_out = open(seednameGW + \".\" + ext, \"w\")\n header = f_uXu_in.readline()\n f_uXu_out.write(header)\n nbnd, NK, nnb = np.array(f_uXu_in.readline().split(), dtype=int)\n f_uXu_out.write(\" \".join(str(x) for x in [NBND, NK, nnb]) + \"\\n\")\n else:\n f_uXu_in = FortranFile(seedname + \".\" + ext, \"r\")\n header = f_uXu_in.read_record(dtype=\"c\")\n nbnd, NK, nnb = np.array(f_uXu_in.read_record(dtype=np.int32))\n if write_formatted:\n f_uXu_out = open(seednameGW + \".\" + ext, \"w\")\n f_uXu_out.write(\"\".join(header.astype(str)))\n f_uXu_out.write(\"\\n\")\n f_uXu_out.write(\" \".join(str(x) for x in [NBND, NK, nnb]))\n f_uXu_out.write(\"\\n\")\n else:\n f_uXu_out = FortranFile(seednameGW + \".\" + ext, \"w\")\n f_uXu_out.write_record(header)\n f_uXu_out.write_record(np.array([NBND, NK, nnb], dtype=np.int32))\n header = \"\".join(header.astype(str))\n\n print(header.strip())\n print(nbnd, NK, nnb)\n\n assert nbnd == nbndDFT\n\n if formatted:\n uXu = np.loadtxt(f_uXu_in).reshape(-1)\n start = 0\n length = nbnd * nbnd\n\n for ik in range(NKPT):\n for ib2 in range(nnb):\n for ib1 in range(nnb):\n if formatted:\n A = uXu[start : start + length]\n start += length\n else:\n A = f_uXu_in.read_record(dtype=np.complex)\n A = (\n A.reshape(nbnd, nbnd, order=\"F\")[\n BANDSORT[KPNB[ik][ib2]], :\n ][:, BANDSORT[KPNB[ik][ib1]]]\n + np.einsum(\n \"ln,lm,l->nm\",\n MMN[ik][ib2].conj(),\n MMN[ik][ib1],\n eigenDE[ik],\n )\n ).reshape(-1, order=\"F\")\n if formatted or write_formatted:\n f_uXu_out.write(\n \"\".join(\n f\"{x.real:26.16e} {x.imag:26.16e}\\n\" for x in A\n )\n )\n else:\n f_uXu_out.write_record(A)\n f_uXu_out.close()\n f_uXu_in.close()\n print(f\"----------\\n {ext} OK \\n----------\\n\")\n except OSError as err:\n print(f\"WARNING: {seednameGW}.{ext} not written : \", err)\n\n if calcUHU:\n reorder_uXu(\"uHu\", UHUformatted)\n if calcUIU:\n reorder_uXu(\"uIu\", UIUformatted)\n\n if calcSPN:\n try:\n print(\"----------\\n SPN module \\n----------\")\n\n if SPNformatted:\n f_spn_in = open(seedname + \".spn\")\n f_spn_out = open(seednameGW + \".spn\", \"w\")\n header = f_spn_in.readline()\n f_spn_out.write(header)\n nbnd, NK = np.array(f_spn_in.readline().split(), dtype=np.int32)\n f_spn_out.write(\" \".join(str(x) for x in (NBND, NKPT)))\n f_spn_out.write(\"\\n\")\n else:\n f_spn_in = FortranFile(seedname + \".spn\", \"r\")\n header = f_spn_in.read_record(dtype=\"c\")\n nbnd, NK = f_spn_in.read_record(dtype=np.int32)\n if write_formatted:\n f_spn_out = open(seednameGW + \".spn\", \"w\")\n f_spn_out.write(\"\".join(header.astype(str)))\n f_spn_out.write(\"\\n\")\n f_spn_out.write(\" \".join(str(x) for x in (NBND, NKPT)))\n f_spn_out.write(\"\\n\")\n else:\n f_spn_out = FortranFile(seednameGW + \".spn\", \"w\")\n f_spn_out.write_record(header)\n f_spn_out.write_record(np.array([NBND, NKPT], dtype=np.int32))\n header = \"\".join(header.astype(str))\n\n print(header.strip())\n assert nbnd == nbndDFT\n\n indm, indn = np.tril_indices(nbnd)\n indmQP, indnQP = np.tril_indices(NBND)\n\n if SPNformatted:\n SPN = np.loadtxt(f_spn_in).view(complex).reshape(-1)\n start = 0\n length = (3 * nbnd * (nbnd + 1)) // 2\n\n for ik in range(NK):\n A = np.zeros((3, nbnd, nbnd), dtype=np.complex)\n if SPNformatted:\n A[:, indn, indm] = SPN[start : (start + length)].reshape(\n 3, nbnd * (nbnd + 1) // 2, order=\"F\"\n )\n start += length\n else:\n A[:, indn, indm] = f_spn_in.read_record(dtype=np.complex).reshape(\n 3, nbnd * (nbnd + 1) // 2, order=\"F\"\n )\n A[:, indm, indn] = A[:, indn, indm].conj()\n check = np.einsum(\"ijj->\", np.abs(A.imag))\n if check > 1e-10:\n raise RuntimeError(f\"REAL DIAG CHECK FAILED for spn: {check}\")\n A = A[:, :, BANDSORT[ik]][:, BANDSORT[ik], :][\n :, indnQP, indmQP\n ].reshape((3 * NBND * (NBND + 1) // 2), order=\"F\")\n if SPNformatted or write_formatted:\n f_spn_out.write(\n \"\".join(f\"{x.real:26.16e} {x.imag:26.16e}\\n\" for x in A)\n )\n else:\n f_spn_out.write_record(A)\n\n f_spn_in.close()\n f_spn_out.close()\n print(\"----------\\n SPN OK \\n----------\\n\")\n except OSError as err:\n print(f\"WARNING: {seednameGW}.spn not written : \", err)\n\n if calcUNK:\n print(\"----------\\n UNK module \\n----------\")\n\n unkgwdir = \"UNK_GW\"\n unkdftdir = \"UNK_DFT\"\n files_list = []\n for f_unk_name in glob.glob(\"UNK*.*\"):\n files_list.append(f_unk_name)\n\n try:\n os.mkdir(unkgwdir)\n os.mkdir(unkdftdir)\n except OSError:\n pass\n\n for f_unk_name in files_list:\n try:\n NC = os.path.splitext(f_unk_name)[1] == \".NC\"\n shutil.move(\"./\" + f_unk_name, \"./\" + unkdftdir + \"/\")\n if UNKformatted:\n f_unk_out = open(os.path.join(unkgwdir, f_unk_name), \"w\")\n f_unk_in = open(os.path.join(unkdftdir, f_unk_name))\n nr1, nr2, nr3, ik, nbnd = np.array(\n f_unk_in.readline().split(), dtype=int\n )\n NR = nr1 * nr2 * nr3\n if NC:\n NR *= 2\n f_unk_out.write(\n \" \".join(str(x) for x in (nr1, nr2, nr3, ik, NBND)) + \"\\n\"\n )\n f_unk_out.write(\n \"\\n\".join(\n np.array([l.rstrip() for l in f_unk_in], dtype=str)\n .reshape((nbnd, NR), order=\"C\")[BANDSORT[ik - 1], :]\n .reshape(-1, order=\"C\")\n )\n )\n else:\n f_unk_in = FortranFile(os.path.join(unkdftdir, f_unk_name), \"r\")\n nr1, nr2, nr3, ik, nbnd = f_unk_in.read_record(dtype=np.int32)\n NR = nr1 * nr2 * nr3\n unk = np.zeros((nbnd, NR), dtype=np.complex)\n if NC:\n unk2 = np.zeros((nbnd, NR), dtype=np.complex)\n for ib in range(nbnd):\n unk[ib, :] = f_unk_in.read_record(dtype=np.complex)\n if NC:\n unk2[ib, :] = f_unk_in.read_record(dtype=np.complex)\n unk = unk[BANDSORT[ik - 1], :]\n if NC:\n unk2 = unk2[BANDSORT[ik - 1], :]\n if write_formatted:\n f_unk_out = open(os.path.join(unkgwdir, f_unk_name), \"w\")\n f_unk_out.write(\n \" \".join(str(x) for x in (nr1, nr2, nr3, ik, NBND))\n )\n for i in range(NBND):\n for j in range(NR):\n f_unk_out.write(\n \"\\n{:21.10e} {:21.10e}\".format(\n unk[ib, j].real, unk[ib, j].imag\n )\n )\n if NC:\n for j in range(NR):\n f_unk_out.write(\n \"\\n{:21.10e} {:21.10e}\".format(\n unk2[ib, j].real, unk2[ib, j].imag\n )\n )\n else:\n f_unk_out = FortranFile(os.path.join(unkgwdir, f_unk_name), \"w\")\n f_unk_out.write_record(\n np.array([nr1, nr2, nr3, ik, NBND], dtype=np.int32)\n )\n for i in range(NBND):\n f_unk_out.write_record(unk[ib])\n if NC:\n f_unk_out.write_record(unk2[ib])\n f_unk_in.close()\n f_unk_out.close()\n shutil.move(\"./\" + unkgwdir + \"/\" + f_unk_name, \"./\")\n except OSError as err:\n if err.errno == 21:\n pass\n else:\n raise err\n os.rmdir(unkgwdir)\n print(\n \"UNK files have been reordered, \"\n + \"old files coming from DFT are available in UNK_DFT folder.\"\n )\n print(\"----------\\n UNK OK \\n----------\\n\")\n\n if calcCHK:\n reorder_chk(seedname, seednameGW, BANDSORT)\n\n f_raw.close()\n\n\nif __name__ == \"__main__\":\n args = parse_args()\n\n seedname = args.seedname # for instance \"silicon\"\n\n if args.output_seedname is None:\n seednameGW = seedname + \".gw\" # for instance \"silicon.gw\"\n else:\n seednameGW = args.output_seedname\n\n targets = []\n if args.extensions is not None:\n targets = args.extensions.split(\",\")\n targets = [s.lower() for s in targets] # options read from command line\n\n gw2wannier90(seedname, seednameGW, targets, args.no_sort)\n", "meta": {"hexsha": "6cec7cec54ce5f481f13b8d10379c90faff61dfc", "size": 44420, "ext": "py", "lang": "Python", "max_stars_repo_path": "utils/gw2wannier90.py", "max_stars_repo_name": "epfl-theos/aiida-yambo-wannier90", "max_stars_repo_head_hexsha": "dabfa402e779e9fc797dda15ec748b0c6c25d647", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "utils/gw2wannier90.py", "max_issues_repo_name": "epfl-theos/aiida-yambo-wannier90", "max_issues_repo_head_hexsha": "dabfa402e779e9fc797dda15ec748b0c6c25d647", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2022-02-21T14:59:22.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-21T15:57:49.000Z", "max_forks_repo_path": "utils/gw2wannier90.py", "max_forks_repo_name": "epfl-theos/aiida-yambo-wannier90", "max_forks_repo_head_hexsha": "dabfa402e779e9fc797dda15ec748b0c6c25d647", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.801988401, "max_line_length": 395, "alphanum_fraction": 0.5104007204, "include": true, "reason": "import numpy,from scipy", "num_tokens": 11399, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792044, "lm_q2_score": 0.3775406687981454, "lm_q1q2_score": 0.19171963086360388}} {"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# In[1]:\n\n\nfrom tc_python import *\nimport itertools as itertool\nimport time\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n\n# In[4]:\n\n\ndef manyPoints(database,T,P,components,phases=[\"bcc\"],point_compositions=[(99.02,0.08)]):\n \"\"\"\n Single point equilibrium calculations\n \n ## input: \n database name: [string],\n Temperature float,\n Pressure float,\n elements: [string], \n phases [string], if empty all phases from the database are included\n point_compositions [(float,float,...)]\n \n ## output: Dictionary {\"stable_phases\",\"npms\",\"vpvs\",\"ws\",\"xiphs\",\"ys\", \"acs\",\"mus\",\"bineries\" }\n stable_phases: [string],\n npms: phase fractions [float],\n vpvs: volume fractions of phases [float], \n ws: weight fractions of elements [float],\n xiphs: mole fractions of elements in phases [float],\n ys: y fractions of elements is phases [float], \n bineries: binary list of all elements and stable phases [tuple (component,phase)]\n acs: activities of elements with respect to all phases \n mus: chemical potentials of all components\n \"\"\"\n with TCPython() as start:\n if not phases:\n system_int = start.select_database_and_elements(database,components)\n else: \n system_int = start.select_database_and_elements(database,components).without_default_phases()\n for phase in phases:\n system_int.select_phase(phase)\n system = system_int.get_system()\n calc = system.with_single_equilibrium_calculation()\n \n volume_fractions,phase_fractions,weight_fractions,xs_in_phases,ys_in_phases,activities,chemical_potentials,sps,bn = [],[],[],[],[],[],[],[],[]\n for point_composition in point_compositions:\n ticc=time.time()\n for i in range(len(components)-1):\n calc.set_condition(ThermodynamicQuantity.mole_fraction_of_a_component((components[i])), point_composition[i])\n calc.set_condition(ThermodynamicQuantity.temperature(), 1723.15)\n calc.set_condition(ThermodynamicQuantity.pressure(), 1e5)\n calc_res = calc.calculate()\n stable_phases = calc_res.get_stable_phases()\n sps.append(stable_phases)\n for phase in stable_phases:\n volume_fractions.append(calc_res.get_value_of('vpv({})'.format(phase))) \n phase_fractions.append(calc_res.get_value_of('npm({})'.format(phase)))\n for element in components:\n weight_fractions.append(calc_res.get_value_of('w({})'.format(element)))\n chemical_potentials.append(calc_res.get_value_of('mu({})'.format(element)))\n binaries = list(itertool.product(stable_phases, components))\n bn.append(binaries)\n for binary in binaries:\n xs_in_phases.append(calc_res.get_value_of('x({},{})'.format(binary[0], binary[1])))\n try:\n ys_in_phases.append(calc_res.get_value_of('y({},{})'.format(binary[0], binary[1])))\n except Exception as error:\n a=1\n #ys_in_phases.append(-1)\n try:\n activities.append(calc_res.get_value_of('ac({},{})'.format(binary[1], binary[0]))) \n except Exception as error:\n a=1\n #ys_in_phases.append(-1)\n tocc=time.time()\n print(tocc-ticc)\n weight_fractions = np.reshape(weight_fractions,(-1,len(components)))\n chemical_potentials = np.reshape(chemical_potentials,(-1,len(components)))\n \n return {\"stable_phases\":sps,\"npms\":phase_fractions, \"vpvs\":volume_fractions,\"ws\":weight_fractions,\"xiph\":xs_in_phases, \"ys\":ys_in_phases,\"acs\":activities,\"mus\":chemical_potentials,\"binaries\":bn}\n\n\n# In[5]:\n\n\nhelp(manyPoints)\n\n\n# In[6]:\n\n\ndatabase = \"TCFE8\"\nelements = [\"C\",\"Co\",\"N\",\"Ti\",\"W\"]\nphases = [\"liquid\", \"fcc\", \"mc_shp\", \"graphite\"]\nmole_fractions=[]\nfor i in np.arange(0.1,0.5,0.01):\n mole_fractions.append((0.43,i,0.02,0.02,0.43))\noutputs=[\"ws\"]\n\n\n# In[7]:\n\n\ntic=time.time()\na=manyPoints(database,1750,1e5,elements,phases,mole_fractions)\ntoc = time.time()\nprint(toc-tic)\n\n\n# In[ ]:\n\n\n\n\n", "meta": {"hexsha": "ec31b1c1cfd4e161f0d514aaab336a54456f9cff", "size": 4377, "ext": "py", "lang": "Python", "max_stars_repo_path": "manypoints.py", "max_stars_repo_name": "arminsalmasi/tc_python", "max_stars_repo_head_hexsha": "0f1b5194bdf2a73cead490532eecd1b7da0823e9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "manypoints.py", "max_issues_repo_name": "arminsalmasi/tc_python", "max_issues_repo_head_hexsha": "0f1b5194bdf2a73cead490532eecd1b7da0823e9", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "manypoints.py", "max_forks_repo_name": "arminsalmasi/tc_python", "max_forks_repo_head_hexsha": "0f1b5194bdf2a73cead490532eecd1b7da0823e9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.475, "max_line_length": 234, "alphanum_fraction": 0.6132053918, "include": true, "reason": "import numpy", "num_tokens": 1032, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792044, "lm_q2_score": 0.3775406617944891, "lm_q1q2_score": 0.19171962730706413}} {"text": "# coding=utf-8\nfrom collections import defaultdict, OrderedDict\nfrom material_parser.core.utils import simplify\n\nimport regex as re\nimport sympy as smp\nimport material_parser.core.regex_parser as rp\nimport material_parser.core.chemical_sets as cs\nimport material_parser.core.constants as cnst\n\nfrom pprint import pprint\n\n\ndef process_formula(formula, regex_parser):\n \"\"\"\n :param regex_parser:\n :param formula: str\n :return: chemical_structure\n \"\"\"\n for s, r in cs.species_acronyms.items():\n formula = formula.replace(s, r)\n \"\"\"\n build dictionary of elements and stoichiometries\n \"\"\"\n formula_data = parse_formula(formula, regex_parser)\n\n \"\"\"\n looking for variables in elements and stoichiometry\n \"\"\"\n for el, amt in formula_data[\"composition\"].items():\n if el not in cs.list_of_elements | formula_data[\"elements_x\"].keys() | cnst.VACANCIES:\n formula_data[\"elements_x\"][el] = []\n for var in re.findall(rp.re_variables, amt):\n formula_data[\"amounts_x\"][var] = {}\n\n formula, \\\n elements, \\\n elements_x, \\\n stoichiometry_x, \\\n oxygen_deficiency = __refine_variables(formula_data[\"formula\"],\n formula_data[\"composition\"],\n formula_data[\"elements_x\"],\n formula_data[\"amounts_x\"],\n formula_data[\"oxygen_deficiency\"],\n formula_data[\"oxygen_deficiency_sym\"])\n\n if __is_acronym(formula, elements, elements_x) or __has_negative_composition(elements):\n return dict(formula=formula,\n elements=OrderedDict(),\n species=OrderedDict(),\n oxygen_deficiency=\"\",\n phase=\"\",\n amounts_x={},\n elements_x={})\n\n species = __get_species(formula, regex_parser) if len(elements) > 2 or formula == \"H2O\" else elements\n\n # print (formula)\n # pprint(elements)\n\n return dict(formula=formula,\n elements=elements,\n species=species,\n oxygen_deficiency=oxygen_deficiency,\n phase=formula_data[\"phase\"],\n amounts_x={x: v for x, v in stoichiometry_x.items()},\n elements_x={e: v for e, v in elements_x.items()})\n\n\ndef parse_formula(formula, regex_parser):\n formula = formula.replace(\" \", \"\")\n \"\"\"\n separate phase, e.g. g-ABC\n \"\"\"\n phase, formula = regex_parser.separate_phase(formula)\n\n \"\"\"\n separate oxygen deficiency\n \"\"\"\n formula, oxygen_deficiency, oxygen_deficiency_sym = regex_parser.separate_oxygen_deficiency(formula)\n\n \"\"\"\n converting fractions a(b+x)/c into (a/c*b+a/c*x)\n \"\"\"\n formula = regex_parser.make_fraction_convertion(formula)\n\n \"\"\"\n check for any weird syntax (A,B)zElxEly...\n replacing with MzElxEly... and M = [A, B]\n \"\"\"\n elements_x = defaultdict(str)\n stoichiometry_x = defaultdict(str)\n formula, variables = regex_parser.convert_weird_syntax(formula)\n if variables:\n elements_x[\"M\"] = variables\n\n composition = __get_composition(formula)\n\n return dict(formula=formula,\n composition=composition,\n oxygen_deficiency=oxygen_deficiency,\n oxygen_deficiency_sym = oxygen_deficiency_sym,\n phase=phase,\n amounts_x={x: v for x, v in stoichiometry_x.items()},\n elements_x={e: v for e, v in elements_x.items()})\n\n\ndef __get_composition(init_formula):\n \"\"\"\n\n :param init_formula:\n :return:\n \"\"\"\n \"\"\"\n if more than 4 repeating lowercase letters encountered then it is not chemical formula\n \"\"\"\n if re.findall(\"[a-z]{4,}\", init_formula):\n return OrderedDict()\n\n formula_dict = OrderedDict()\n formula_dict = __parse_parentheses(init_formula, \"1\", formula_dict)\n\n \"\"\"\n refinement of non-variable values\n \"\"\"\n incorrect = []\n for el, amt in formula_dict.items():\n formula_dict[el] = simplify(amt)\n if any(len(c) > 1 for c in re.findall(\"[A-Za-z]+\", formula_dict[el])):\n incorrect.append(el)\n\n for el in incorrect:\n del formula_dict[el]\n\n return formula_dict\n\n\ndef __parse_parentheses(init_formula, init_factor, curr_dict):\n re_in_parentheses = r\"\\(((?>[^\\(\\)]+|(?R))*)\\)\\s*([-*\\.\\da-z\\+/]*)\"\n for m in re.finditer(re_in_parentheses, init_formula):\n factor = m.group(2) if m.group(2) != \"\" else \"1\"\n factor = simplify(\"(\" + str(init_factor) + \")*(\" + str(factor) + \")\")\n unit_sym_dict = __parse_parentheses(m.group(1), factor, curr_dict)\n init_formula = init_formula.replace(m.group(0), \"\")\n\n unit_sym_dict = __get_sym_dict(init_formula, init_factor)\n for el, amt in unit_sym_dict.items():\n if el in curr_dict:\n if len(curr_dict[el]) != 0:\n curr_dict[el] = \"(\" + str(curr_dict[el]) + \")\" + \"+\" + \"(\" + str(amt) + \")\"\n else:\n curr_dict[el] = amt\n else:\n curr_dict[el] = amt\n\n return curr_dict\n\n\ndef __get_sym_dict(f, factor):\n re_sym_dict = r\"([A-Z□]{1}[a-z]{0,1})\\s*([\\-\\*\\.\\da-z\" + \"\".join(cnst.GREEK_CHARS) + r\"\\+\\/]*)\"\n sym_dict = OrderedDict()\n\n def get_code_value(code, iterator):\n code_mapping = {\"01\": (iterator.group(1), iterator.group(2)),\n \"11\": (iterator.group(1), iterator.group(2)),\n \"10\": (iterator.group(1)[0], iterator.group(1)[1:] + iterator.group(2)),\n \"00\": (iterator.group(1)[0], iterator.group(1)[1:] + iterator.group(2))}\n return code_mapping[code]\n\n for m in re.finditer(re_sym_dict, f):\n \"\"\"\n checking for correct elements names\n \"\"\"\n el_bin = \"{0}{1}\".format(str(int(m.group(1)[0] in cs.list_of_elements_1 | {\"M\"} | cnst.VACANCIES)),\n str(int(m.group(1) in cs.list_of_elements | {\"Ln\", \"M\"} | cnst.VACANCIES)))\n el, amt = get_code_value(el_bin, m)\n if amt.strip() == \"\":\n amt = \"1\"\n if el in sym_dict:\n sym_dict[el] = \"(\" + sym_dict[el] + \")\" + \"+\" + \"(\" + amt + \")\" + \"*\" + \"(\" + str(factor) + \")\"\n else:\n sym_dict[el] = \"(\" + amt + \")\" + \"*\" + \"(\" + str(factor) + \")\"\n f = f.replace(m.group(), \"\", 1)\n if f.strip():\n return OrderedDict()\n\n \"\"\"\n refinement of non-variable values\n \"\"\"\n try:\n for el, amt in sym_dict.items():\n sym_dict[el] = simplify(amt)\n except:\n sym_dict = OrderedDict()\n return sym_dict\n\n\ndef __get_species(formula, regex_parser):\n species_in_material, species_indexs, species_dict = OrderedDict(), OrderedDict(), OrderedDict()\n material_formula = formula\n i = 0\n for species in cs.species:\n while species in material_formula:\n # print(species)\n material_formula = material_formula.replace(species, \"specie\" + str(i) + \"_\")\n species_in_material[\"specie\" + str(i) + \"_\"] = species\n i += 1\n\n if not species_in_material:\n return OrderedDict()\n\n for species in cs.number_to_alphabet_dict:\n while species in material_formula:\n material_formula = material_formula.replace(species, cs.number_to_alphabet_dict[species])\n species_indexs[cs.number_to_alphabet_dict[species]] = species_in_material[species]\n species_info = parse_formula(material_formula, regex_parser)[\"composition\"]\n for species_index in species_info:\n species_dict[species_indexs[species_index]] = species_info[species_index]\n return species_dict\n\n\ndef __refine_variables(formula, composition, elements_vars, stoichiometry_vars, oxy_def, oxy_def_sym):\n \"\"\"\n :return:\n \"\"\"\n \"\"\"\n combining [RE, AE, TM] into one variable\n \"\"\"\n rename_variables = [(\"R\", \"E\"), (\"A\", \"E\"), (\"T\", \"M\")]\n for v1, v2 in rename_variables:\n if v1 in elements_vars and v2 in elements_vars and v1 + v2 in formula:\n elements_vars[v1 + v2] = []\n del elements_vars[v2]\n del elements_vars[v1]\n composition[v1 + v2] = composition[v2]\n del composition[v1]\n del composition[v2]\n\n \"\"\"\n correction for Me variable\n \"\"\"\n if \"M\" in elements_vars and \"e\" in stoichiometry_vars:\n elements_vars[\"Me\"] = []\n del elements_vars[\"M\"]\n del stoichiometry_vars[\"e\"]\n c = composition[\"M\"][1:]\n composition[\"Me\"] = c if c != \"\" else \"1.0\"\n del composition[\"M\"]\n\n \"\"\"\n remove oxygen deficiency from variables\n \"\"\"\n if not oxy_def and oxy_def_sym in stoichiometry_vars:\n oxy_def = None\n variables = [v for v in stoichiometry_vars.keys()\n if [e for e, s in composition.items() if v in s] == [\"O\"]]\n oxy_def = chr(177) if len(variables) > 0 else oxy_def\n for var in variables:\n del stoichiometry_vars[var]\n composition[\"O\"] = \"1\" if composition[\"O\"] == var else composition[\"O\"].replace(var, \"\").strip()\n formula = formula.replace(var, \"\")\n return formula, composition, elements_vars, stoichiometry_vars, oxy_def\n\n\ndef __is_acronym(formula, composition, variables):\n\n if formula in cs.ions:\n return False\n\n if any(ion in formula and len(ion) > 1 for ion in cs.ions):\n return False\n\n if len(composition) == 2 and variables:\n return True\n\n capital_letters = cnst.LATIN_CAPITAL - set(cs.list_of_elements_1) - {\"M\", \"L\"}\n if [r for c in capital_letters for r in re.findall(c + \"[A-Z0-9\\-]\", formula)] \\\n and all(w not in formula for w in [\"RE\", \"OAC\", \"TM\", \"ME\"]):\n return True\n\n if all(e.isupper() and s in [\"1.0\", \"1\"] for e, s in composition.items()):\n return True\n\n elements_x = [el for el in variables.keys() if len(el) == 1 and el.isupper()]\n if len(elements_x) > 1:\n return True\n\n if all(c.isupper() for c in formula) and any(c not in cs.list_of_elements_1 for c in formula):\n return True\n\n if re.findall(\"[A-Z]{3,}\", formula) != [] and \\\n all(w not in formula for w in [\"CH\", \"COO\", \"OH\", \"NH\"] + [a for a in cs.default_abbreviations.keys()]):\n return True\n\n if \"PV\" == formula[0:2]:\n return True\n\n return False\n\n\ndef __has_negative_composition(composition):\n\n flag = False\n try:\n flag = any(float(amt) < 0 for el, amt in composition.items())\n except:\n pass\n\n return flag\n", "meta": {"hexsha": "cbc436ac6bfd9b40df4d2b3104747f6f64bd1407", "size": 10562, "ext": "py", "lang": "Python", "max_stars_repo_path": "material_parser/core/formula_processing.py", "max_stars_repo_name": "CederGroupHub/MaterialParser", "max_stars_repo_head_hexsha": "a747a30bbf36b59b44eaa2fd5bc0203d70fe12e8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2019-12-17T23:51:38.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-06T17:44:40.000Z", "max_issues_repo_path": "material_parser/core/formula_processing.py", "max_issues_repo_name": "CederGroupHub/MaterialParser", "max_issues_repo_head_hexsha": "a747a30bbf36b59b44eaa2fd5bc0203d70fe12e8", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2019-01-10T00:07:38.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-16T23:52:41.000Z", "max_forks_repo_path": "material_parser/core/formula_processing.py", "max_forks_repo_name": "CederGroupHub/MaterialParser", "max_forks_repo_head_hexsha": "a747a30bbf36b59b44eaa2fd5bc0203d70fe12e8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2020-02-28T22:03:53.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-11T15:12:40.000Z", "avg_line_length": 34.0709677419, "max_line_length": 112, "alphanum_fraction": 0.5907025185, "include": true, "reason": "import sympy", "num_tokens": 2563, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5851011686727231, "lm_q2_score": 0.3276683139517237, "lm_q1q2_score": 0.19171911343017428}} {"text": "from typing import Union, Optional, Tuple, Dict, Any\nimport os\n\nimport numpy as np\nimport torch as th\nfrom torch.cuda.amp import autocast\n\nfrom ail.agents.rl_agent.rl_core import OnPolicyAgent\nfrom ail.common.math import normalize\nfrom ail.common.pytorch_util import asarray_shape2d, obs_as_tensor, disable_gradient\nfrom ail.common.type_alias import AlgoTags, DoneMask, GymEnv, GymSpace, TensorDict\n\n\nclass PPO(OnPolicyAgent):\n \"\"\"\n Proximal Policy Optimization algorithm (PPO) (clip version)\n Paper: https://arxiv.org/abs/1707.06347\n\n :param state_space: state space.\n :param action_space: action space.\n :param device: PyTorch device to which the values will be converted.\n :param seed: random seed.\n :param batch_size: size of the batch (we assume batch_size == buffer_size).\n :param policy_kwargs: arguments to be passed to the policy on creation.\n e.g. : {\n pi: [64, 64],\n vf: [64, 64],\n activation: 'relu',\n lr_actor: 3e-4,\n lr_critic: 3e-4,\n critic_type=\"V\",\n orthogonal_init: True,\n }\n :param epoch_ppo: Number of epoch when optimizing the surrogate loss.\n :param gamma: Discount factor.\n :param clip_eps: PPO clipping parameter.\n :param coef_ent: Entropy coefficient for the loss calculation.\n :param max_grad_norm: Maximum norm for the gradient clipping.\n :param fp16: Whether to use float16 mixed precision training.\n :optim_kwargs: arguments to be passed to the optimizer.\n eg. : {\n \"optim_cls\": adam,\n \"optim_set_to_none\": True, # which set grad to None instead of zero.\n }\n :param buffer_kwargs: Arguments to be passed to the buffer.\n eg. : {\n with_reward: True,\n extra_data: [\"log_pis\"]\n }\n :param init_buffer: Whether to create the buffer during initialization.\n :param init_models: Whether to create the models during initialization.\n \"\"\"\n\n def __init__(\n self,\n state_space: GymSpace,\n action_space: GymSpace,\n device: Union[th.device, str],\n seed: int,\n policy_kwargs: Dict[str, Any],\n batch_size: int = 2_000,\n epoch_ppo: int = 10,\n gamma: float = 0.99,\n gae_lambda: float = 0.97,\n clip_eps: float = 0.2,\n coef_ent: float = 0.01,\n max_grad_norm: Optional[float] = None,\n fp16: bool = False,\n optim_kwargs: Optional[dict] = None,\n buffer_kwargs: Optional[Dict[str, Any]] = None,\n init_buffer: bool = True,\n init_models: bool = True,\n expert_mode: bool = False,\n **kwargs,\n ):\n super().__init__(\n state_space,\n action_space,\n device,\n fp16,\n seed,\n gamma,\n max_grad_norm,\n batch_size,\n batch_size, # * (Yifan) here assumes batch_size == buffer_size\n policy_kwargs,\n optim_kwargs,\n buffer_kwargs,\n init_buffer,\n init_models,\n expert_mode,\n )\n\n # learning rate scheduler.\n # TODO: add learning rate scheduler.\n # ? (Yifan) Is there one suitable for RL?\n\n \"\"\"alpha_t = alpha_0 (1 - t/T)\"\"\"\n # schedule = lambda epoch: 1 - epoch/(self.param.evaluation['total_timesteps'] // self.batch_size)\n # self.scheduler_actor = optim.lr_scheduler.LambdaLR(self.optim_actor, schedule)\n # self.scheduler_critic = optim.lr_scheduler.LambdaLR(self.optim_critic, schedule)\n\n # Other algo params.\n self.learning_steps_ppo = 0\n self.epoch_ppo = epoch_ppo\n self.clip_eps = clip_eps\n self.gae_lambda = gae_lambda\n self.coef_ent = coef_ent\n\n self.tag = AlgoTags.PPO\n\n def __repr__(self) -> str:\n return f\"{self.__class__.__name__}\"\n\n def is_update(self, step: int) -> bool:\n \"\"\"Whether or not to update the agent\"\"\"\n return step % self.batch_size == 0\n\n def step(\n self,\n env: GymEnv,\n state: th.Tensor,\n episode_timesteps: th.Tensor,\n global_timesteps: Optional[int] = None,\n add_absorbing_state: bool = False,\n ) -> Tuple[np.ndarray, int]:\n \"\"\"\n Intereact with environment and store the transition.\n\n :param env: gym environment\n :param state: orginal state return by the environment\n :param episode_timesteps: number of timesteps this episode\n :param total_timesteps: total number of timesteps to run in outer loop\n :return: next_state, episode length\n \"\"\"\n episode_timesteps += 1\n\n # Sample actions from action distribution.\n # which is then wrapped by tanh transform to keep it in range [-1, 1].\n action, log_pi = self.explore(obs_as_tensor(state, self.device), scale=False)\n\n # Resacle actions to match original action space.\n scale_action = (\n self.scale_action(action) if not self.normalized_action_space else action\n )\n\n # Interact with environment (Info might be useful for some special env).\n next_state, reward, done, info = env.step(scale_action)\n\n # Done mask removes the time limit constrain of some env to keep makorvian.\n # Agent keeps alive should not be done by env's time limit.\n # See: https://github.com/sfujim/TD3/blob/master/main.py#L127\n # * Here we use an inverse convention in which DONE = 0 and NOT_DONE = 1\n # * to match absorbing state implementation in DAC paper.\n done_mask: float\n if (episode_timesteps == env._max_episode_steps) or not done:\n done_mask = DoneMask.NOT_DONE.value\n else:\n done_mask = DoneMask.DONE.value\n\n absorbing_cond = all(\n [add_absorbing_state, done, episode_timesteps < env._max_episode_steps]\n )\n if absorbing_cond:\n next_state = env.get_absorbing_state()\n\n data = {\n \"obs\": asarray_shape2d(state),\n \"acts\": asarray_shape2d(action),\n \"rews\": asarray_shape2d(reward),\n \"dones\": asarray_shape2d(done_mask),\n \"log_pis\": asarray_shape2d(log_pi),\n \"next_obs\": asarray_shape2d(next_state),\n }\n\n # Store transition.\n # * NOT ALLOW size larger than buffer capcity.\n self.buffer.store(data, truncate_ok=False)\n\n # Reset env if encounter done signal (not done mask!)\n if done:\n episode_timesteps = 0\n next_state = env.reset()\n # Add a absorbing state to buffer when done.\n if add_absorbing_state and (episode_timesteps < env._max_episode_steps):\n # A fake action for the absorbing state.\n zero_action = np.zeros(env.action_space.shape)\n absorbing_state = env.get_absorbing_state()\n absorbing_data = {\n \"obs\": asarray_shape2d(absorbing_state),\n \"acts\": asarray_shape2d(zero_action),\n \"rews\": asarray_shape2d(0.0),\n \"dones\": asarray_shape2d(DoneMask.ABSORBING.value),\n \"log_pis\": asarray_shape2d(log_pi), # TODO: what to do with log_pi?\n \"next_obs\": asarray_shape2d(absorbing_state),\n }\n self.buffer.store(absorbing_data, truncate_ok=False)\n return next_state, episode_timesteps\n\n def update(self, log_this_batch: bool = False) -> Dict[str, Any]:\n \"\"\"\n A general road map for updating the model.\n Obtain the training batch and perform update.\n :return train_logs: dict of training logs\n \"\"\"\n self.learning_steps += 1\n rollout_data = self.buffer.get()\n\n # Clear buffer after getting entire buffer.\n self.buffer.reset()\n train_logs = self.update_algo(rollout_data, log_this_batch)\n return train_logs\n\n def update_algo(\n self, data: TensorDict, log_this_batch: bool = False\n ) -> Dict[str, Any]:\n \"\"\"\n Update the actor and critic.\n :param data: a batch of randomly sampled transitions\n :return train_logs: dict of training logs\n \"\"\"\n states, actions, rewards, dones, next_states, log_pis = (\n data[\"obs\"],\n data[\"acts\"],\n data[\"rews\"],\n data[\"dones\"],\n data[\"next_obs\"],\n data[\"log_pis\"],\n )\n with th.no_grad():\n values = self.critic(states)\n next_values = self.critic(next_states)\n\n targets, gaes = calculate_gae(\n rewards, (1.0 - dones), values, next_values, self.gamma, self.gae_lambda\n )\n\n for _ in range(self.epoch_ppo):\n self.learning_steps_ppo += 1\n loss_critic = self._update_critic(states, targets)\n loss_actor, pi_info = self._update_actor(states, actions, log_pis, gaes)\n\n if log_this_batch:\n # Return log changes(key used for logging name).\n return {\n \"actor_loss\": loss_actor,\n \"critic_loss\": loss_critic,\n \"approx_kl\": pi_info[\"kl\"],\n \"entropy\": pi_info[\"ent\"],\n \"clip_fraction\": pi_info[\"cf\"],\n \"pi_lr\": self.lr_actor,\n \"vf_lr\": self.lr_critic,\n \"learn_steps_ppo\": self.learning_steps_ppo,\n }\n else:\n return {}\n\n def _update_critic(self, states: th.Tensor, targets: th.Tensor) -> th.Tensor:\n \"\"\"\n Update critic. (value function approximation)\n :param states:\n :param targets: should be gae + v_pred\n return: critic loss\n \"\"\"\n self.optim_critic.zero_grad(set_to_none=self.optim_set_to_none)\n with autocast(enabled=self.fp16):\n loss_critic = (self.critic(states) - targets).pow(2).mean()\n self.one_gradient_step(loss_critic, self.optim_critic, self.critic)\n return loss_critic.detach()\n\n def _update_actor(\n self,\n states: th.Tensor,\n actions: th.Tensor,\n log_pis_old: th.Tensor,\n gaes: th.Tensor,\n ) -> Tuple[th.Tensor, Dict[str, Any]]:\n \"\"\"\n Update actor. (function for computing PPO policy loss)\n :param states:\n :param actions:\n :param log_pis_old:\n :param gaes: general advantage estimation\n : return: actor loss, policy_info\n \"\"\"\n log_pis = self.actor.evaluate_log_pi(states, actions)\n\n # * (Yifan) Since we bounded the mean action with tanh(),\n # * there is no analytical form of entropy\n # Approximate entropy.\n approx_ent = -log_pis.mean()\n\n # ratio between old and new policy, should be one at the first iteration\n log_ratios = log_pis - log_pis_old\n ratios = (log_ratios).exp()\n\n # clipped surrogate loss\n loss_actor1 = ratios * gaes\n loss_actor2 = th.clamp(ratios, 1.0 - self.clip_eps, 1.0 + self.clip_eps) * gaes\n loss_actor = -th.min(loss_actor1, loss_actor2).mean()\n\n self.optim_actor.zero_grad(set_to_none=self.optim_set_to_none)\n with autocast(enabled=self.fp16):\n loss_actor_ent = loss_actor - self.coef_ent * approx_ent\n self.one_gradient_step(loss_actor_ent, self.optim_actor, self.actor)\n\n \"\"\"\n Calculate approximate form of reverse KL Divergence for early stopping.\n See issue #417: https://github.com/DLR-RM/stable-baselines3/issues/417\n and discussion in PR #419: https://github.com/DLR-RM/stable-baselines3/pull/419\n and Schulman blog: https://joschu.net/blog/kl-approx.html\n KL(q||p): (r-1) - log(r), where r = p(x)/q(x)\n \"\"\"\n # ! (Yifan) Deprecated :\n # ! Naive version: approx_kl = (log_pi_old - log_pi).mean().item()\n # ! This is an unbiased estimator, but it has large variance.\n # ! Since it can take on negative values.\n # ! as opposed to the actual KL Divergence measure\n # Useful extra info\n with th.no_grad():\n approx_kl = ((ratios - 1) - log_ratios).mean()\n clipped = ratios.gt(1 + self.clip_eps) | ratios.lt(1 - self.clip_eps)\n clip_frac = th.as_tensor(clipped, dtype=th.float32).mean()\n pi_info = {\"kl\": approx_kl, \"ent\": approx_ent.detach(), \"cf\": clip_frac}\n return loss_actor.detach(), pi_info\n\n def save_models(self, save_dir: str) -> None:\n \"\"\"\n Save the model. (Only save actor to reduce workloads)\n \"\"\"\n super().save_models(save_dir)\n th.save(self.actor.state_dict(), os.path.join(save_dir, \"actor.pth\"))\n\n @classmethod\n def load(\n cls,\n path: str,\n policy_kwargs: Dict[str, Any],\n env: Union[GymEnv, str, None] = None,\n state_space: Optional[GymSpace] = None,\n action_space: Optional[GymSpace] = None,\n device: Union[th.device, str] = \"cpu\",\n seed: int = 42,\n **kwargs,\n ) -> \"PPO\":\n \"\"\"\n Load the model from a saved model directory.\n we only load actor.\n \"\"\"\n super().load(env, state_space, action_space)\n if env is not None:\n if isinstance(env, str):\n import gym\n\n env = gym.make(env)\n state_space, action_space = env.observation_space, env.action_space\n\n ppo_expert = cls(\n state_space,\n action_space,\n device,\n seed,\n policy_kwargs,\n init_buffer=False,\n init_models=False,\n expert_mode=True,\n **kwargs,\n )\n state_dict = th.load(path)\n ppo_expert.actor.load_state_dict(state_dict)\n disable_gradient(ppo_expert.actor)\n ppo_expert.actor.eval()\n return ppo_expert\n\n\ndef calculate_gae(\n rewards: th.Tensor,\n dones: th.Tensor,\n values: th.Tensor,\n next_values: th.Tensor,\n gamma: float,\n lambd: float,\n normal: bool = True,\n) -> Tuple[th.Tensor, th.Tensor]:\n \"\"\"\n Compute the lambda-return (TD(lambda) estimate) and GAE(lambda) advantage.\n\n Uses Generalized Advantage Estimation (https://arxiv.org/abs/1506.02438)\n to compute the advantage. To obtain vanilla advantage (A(s) = R - V(S))\n where R is the discounted reward with value bootstrap,\n set `lambd=1.0`.\n https://github.com/openai/baselines/blob/ea25b9e8b234e6ee1bca43083f8f3cf974143998/baselines/ppo1/pposgd_simple.py#L66\n \"\"\"\n # Calculate TD errors.\n deltas = rewards + gamma * next_values * (1.0 - dones) - values\n # Initialize gae.\n gaes = th.empty_like(rewards)\n\n # Calculate gae recursively from behind.\n gaes[-1] = deltas[-1]\n for t in reversed(range(rewards.size(0) - 1)):\n gaes[t] = deltas[t] + gamma * lambd * (1.0 - dones[t]) * gaes[t + 1]\n\n targets = values + gaes\n\n if normal:\n return targets, normalize(gaes, gaes.mean(), gaes.std())\n else:\n return targets, gaes\n", "meta": {"hexsha": "37825ea0dd14a4963475fe770abf3d679851e111", "size": 15056, "ext": "py", "lang": "Python", "max_stars_repo_path": "ail/agents/rl_agent/ppo.py", "max_stars_repo_name": "tianyudwang/adversarial_imitation_learning", "max_stars_repo_head_hexsha": "1d5b0ce16cf6453ed29650b6ef565664d6742680", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "ail/agents/rl_agent/ppo.py", "max_issues_repo_name": "tianyudwang/adversarial_imitation_learning", "max_issues_repo_head_hexsha": "1d5b0ce16cf6453ed29650b6ef565664d6742680", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ail/agents/rl_agent/ppo.py", "max_forks_repo_name": "tianyudwang/adversarial_imitation_learning", "max_forks_repo_head_hexsha": "1d5b0ce16cf6453ed29650b6ef565664d6742680", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.7219512195, "max_line_length": 121, "alphanum_fraction": 0.6007571732, "include": true, "reason": "import numpy", "num_tokens": 3590, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.585101139733739, "lm_q2_score": 0.3276683073862188, "lm_q1q2_score": 0.19171910010630178}} {"text": "import os\nimport sys\nimport numpy as np\n\nimport pycuda.driver as cuda\nimport pycuda.autoinit\nfrom pycuda.compiler import SourceModule\n\nclass gpu_context:\n \"\"\"\n GPU context which manages the allocation of memory, the movement of memory between python and the GPU, \n and the calling of GPU funcitons\n\n Written: Devin Cody, 2021\n \"\"\"\n def __init__(self, len_gpu_arrays = 10000000):\n self.gpu_initalized = False\n self.len_gpu_arrays = len_gpu_arrays\n\n try:\n print(\"Compiling kernel\")\n if \"win\" in sys.platform:\n f_newton = open(os.path.dirname(__file__) + \"\\\\kernels\\\\newton.cu\", 'r')\n f_mikkola = open(os.path.dirname(__file__) + \"\\\\kernels\\\\mikkola.cu\", 'r')\n else:\n f_newton = open(os.path.dirname(__file__) + \"/kernels/newton.cu\", 'r')\n f_mikkola = open(os.path.dirname(__file__) + \"/kernels/mikkola.cu\", 'r')\n\n fstr_newton = \"\".join(f_newton.readlines())\n mod_newton = SourceModule(fstr_newton)\n self.newton_gpu = mod_newton.get_function(\"newton_gpu\")\n\n fstr_mikkola = \"\".join(f_mikkola.readlines())\n mod_mikkola = SourceModule(fstr_mikkola)\n self.mikkola_gpu = mod_mikkola.get_function(\"mikkola_gpu\")\n\n print(\"Allocating with {} bytes\".format(self.len_gpu_arrays))\n self.tolerance = np.array([1e-9], dtype = np.float64)\n self.max_iter = np.array([100])\n self.eanom = None\n\n self.d_manom = cuda.mem_alloc(self.len_gpu_arrays)\n self.d_ecc = cuda.mem_alloc(self.len_gpu_arrays)\n self.d_eanom = cuda.mem_alloc(self.len_gpu_arrays)\n\n self.d_tol = cuda.mem_alloc(self.tolerance.nbytes)\n self.d_max_iter = cuda.mem_alloc(self.max_iter.nbytes)\n \n print(\"Copying parameters to GPU\")\n cuda.memcpy_htod(self.d_tol, self.tolerance)\n cuda.memcpy_htod(self.d_max_iter, self.max_iter)\n gpu_initalized = True\n except Exception as e:\n print(\"Error: KEPLER: Unable to initialize Kepler GPU solver context\")\n raise(e)\n\n def newton(self, manom, ecc, eanom, eanom0 = None, tolerance=1e-9, max_iter=100):\n \"\"\"\n Moves numpy arrays onto the GPU memory, calls the Newton-Raphson solver for eccentric anomaly\n and copies the result back into a numpy array.\n\n Args:\n manom (np.array): array of mean anomalies\n ecc (np.array): array of eccentricities\n eanom (np.array): array of eccentric anomalies (return by reference)\n eanom0 (np.array, optional): array of first guess for eccentric anomaly, same shape as manom (optional)\n Return:\n None: eanom is changed by reference\n\n Written: Devin Cody, 2021\n\n \"\"\"\n # Check to make sure we have enough data to process orbits\n if (self.len_gpu_arrays < manom.nbytes):\n self.len_gpu_arrays = manom.nbytes\n self.d_manom = cuda.mem_alloc(self.len_gpu_arrays)\n self.d_ecc = cuda.mem_alloc(self.len_gpu_arrays)\n self.d_eanom = cuda.mem_alloc(self.len_gpu_arrays)\n\n cuda.memcpy_htod(self.d_manom, manom)\n cuda.memcpy_htod(self.d_ecc, ecc)\n cuda.memcpy_htod(self.d_tol, tolerance)\n cuda.memcpy_htod(self.d_max_iter, max_iter)\n\n # Initialize at E=M, E=pi is better at very high eccentricities\n if eanom0 is None:\n cuda.memcpy_dtod(self.d_eanom, self.d_manom, self.len_gpu_arrays)\n else:\n cuda.memcpy_htod(self.d_eanom, eanom0)\n\n self.newton_gpu(self.d_manom, self.d_ecc, self.d_eanom, self.d_max_iter, self.d_tol, grid = (len(manom)//64+1,1,1), block = (64,1,1))\n cuda.memcpy_dtoh(eanom, self.d_eanom)\n\n def mikkola(self, manom, ecc, eanom):\n \"\"\"\n Moves numpy arrays onto the GPU memory, calls the analtyical Mikkola solver for eccentric anomaly\n and copies the result back into a numpy array.\n \n Args:\n manom (np.array): array of mean anomalies between 0 and 2pi\n ecc (np.array): eccentricity\n eanom (np.array): array of eccentric anomalies (return by reference)\n Return:\n None: eanom is changed by reference\n\n Written: Devin Cody, 2021\n \"\"\"\n # Check to make sure we have enough data to process orbits\n if (self.len_gpu_arrays < manom.nbytes):\n self.len_gpu_arrays = manom.nbytes\n self.d_manom = cuda.mem_alloc(self.len_gpu_arrays)\n self.d_ecc = cuda.mem_alloc(self.len_gpu_arrays)\n\n cuda.memcpy_htod(self.d_manom, manom)\n cuda.memcpy_htod(self.d_ecc, ecc)\n\n self.mikkola_gpu(self.d_manom, self.d_ecc, self.d_eanom, grid = (len(manom)//64+1,1,1), block = (64,1,1))\n cuda.memcpy_dtoh(eanom, self.d_eanom)", "meta": {"hexsha": "da0eae7fd927810bc42e850c31086f093b93750e", "size": 4919, "ext": "py", "lang": "Python", "max_stars_repo_path": "orbitize/gpu_context.py", "max_stars_repo_name": "sblunt/orbitize", "max_stars_repo_head_hexsha": "665ca4843d10ee1593665254354d934f37e1b5fc", "max_stars_repo_licenses": ["BSD-3-Clause-Clear"], "max_stars_count": 60, "max_stars_repo_stars_event_min_datetime": "2018-01-12T17:16:53.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-14T01:39:39.000Z", "max_issues_repo_path": "orbitize/gpu_context.py", "max_issues_repo_name": "sblunt/orbitize", "max_issues_repo_head_hexsha": "665ca4843d10ee1593665254354d934f37e1b5fc", "max_issues_repo_licenses": ["BSD-3-Clause-Clear"], "max_issues_count": 278, "max_issues_repo_issues_event_min_datetime": "2018-01-12T17:25:47.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T21:28:27.000Z", "max_forks_repo_path": "orbitize/gpu_context.py", "max_forks_repo_name": "sblunt/orbitize", "max_forks_repo_head_hexsha": "665ca4843d10ee1593665254354d934f37e1b5fc", "max_forks_repo_licenses": ["BSD-3-Clause-Clear"], "max_forks_count": 49, "max_forks_repo_forks_event_min_datetime": "2018-10-30T19:34:05.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-31T13:28:45.000Z", "avg_line_length": 41.686440678, "max_line_length": 141, "alphanum_fraction": 0.6306159789, "include": true, "reason": "import numpy,import pycuda,from pycuda", "num_tokens": 1248, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6039318337259583, "lm_q2_score": 0.31742625267332647, "lm_q1q2_score": 0.19170381884976143}} {"text": "\"\"\"TODO.\"\"\"\n\nfrom __future__ import print_function, absolute_import\nimport numba\nfrom numba import jit\nimport numpy as np\nimport math\nimport random\nfrom numbskull_extend.inference import draw_sample, eval_factor\n\n\n@jit(cache=True, nogil=True)\ndef learnthread(shardID, nshards, step, regularization, reg_param,\n truncation,var_copy, weight_copy, weight,variable,\n factor, fmap,vmap, factor_index, Z,\n fids,var_value, var_value_evid,weight_value, learn_non_evidence,\n poential_weight,alpha_bound,tau_bound,sample_list=None, wmap=None,wfactor=None):\n \"\"\"TODO.\"\"\"\n # Identify start and end variable\n nvar = variable.shape[0]\n start = (shardID * nvar) // nshards\n end = ((shardID + 1) * nvar) // nshards\n if sample_list == None: #sample_list为None表示不需要平衡化\n for var_samp in range(start, end):\n if variable[var_samp][\"isEvidence\"] == 4:\n # This variable is not owned by this machine\n continue\n sample_and_sgd(var_samp, step, regularization, reg_param, truncation,\n var_copy, weight_copy, weight, variable,factor,\n fmap, vmap,factor_index, Z[shardID], fids[shardID],\n var_value,var_value_evid, weight_value, learn_non_evidence,poential_weight,\n alpha_bound,tau_bound)\n else: #需要平衡化\n sample_num = sample_list.shape[0]\n start = (shardID * sample_num) // nshards\n end = ((shardID + 1) * sample_num) // nshards\n for i in range(0,sample_num) :\n var_samp = sample_list[i]['vid']\n if variable[var_samp][\"isEvidence\"] == 4:\n # This variable is not owned by this machine\n continue\n sample_and_sgd(var_samp, step, regularization, reg_param, truncation,\n var_copy, weight_copy, weight, variable,factor,\n fmap, vmap,factor_index, Z[shardID],fids[shardID],\n var_value,var_value_evid,weight_value, learn_non_evidence,poential_weight,\n alpha_bound,tau_bound)\n\n\n@jit(cache=True, nogil=True)\ndef learnthread_bgd(shardID, nshards, step, regularization, reg_param,\n truncation,var_copy, weight_copy, weight,variable,\n factor, fmap,vmap, factor_index, Z,\n fids,var_value, var_value_evid,weight_value, learn_non_evidence,\n poential_weight,alpha_bound,tau_bound,sample_list=None,wmap=None,wfactor=None):\n nweight = weight.shape[0]\n start = (shardID * nweight) // nshards\n end = ((shardID + 1) * nweight) // nshards\n for wid in range(start,end):\n if weight[wid][\"isFixed\"]:\n continue\n else:\n sample_and_bgd(wid,step, regularization, reg_param, truncation,\n var_copy, weight_copy, weight, variable,factor,\n fmap,vmap, factor_index, Z[shardID],fids[shardID],\n var_value, var_value_evid,weight_value, learn_non_evidence,poential_weight,\n alpha_bound,tau_bound,wmap,wfactor)\n\n\n@jit(nopython=True, cache=True, nogil=True)\ndef sample_and_bgd(wid,step, regularization, reg_param, truncation,\n var_copy, weight_copy, weight, variable,factor,\n fmap,vmap, factor_index, Z,fids,\n var_value, var_value_evid,weight_value, learn_non_evidence,poential_weight,\n alpha_bound,tau_bound,wmap,wfactor): #批量梯度下降不需要考虑poential_weight\n #1.计算梯度和\n weight_id = wmap[wid][\"weightId\"]\n weight_index_offset = wmap[wid][\"weight_index_offset\"]\n weight_index_length = wmap[wid][\"weight_index_length\"]\n #找到此权重相关的每一个factor\n factor_count = weight_index_length #此权重拥有的因子个数\n for fIndex in range(weight_index_offset,weight_index_offset+weight_index_length):\n factor_id = wfactor[fIndex][\"factorId\"]\n ftv_offset = factor[factor_id][\"ftv_offset\"]\n ftv_length = factor[factor_id][\"arity\"]\n var_count = ftv_length #此因子拥有的变量个数\n gradient_sum = 0 #不需要参数化时，所有梯度的和\n gradient1_sum = 0 #需要参数化时，参数1的梯度和\n gradient2_sum = 0 # 需要参数化时，参数2的梯度和\n # 找到每一个factor相关的每一个变量\n for vIndex in range(ftv_offset,ftv_offset+ftv_length):\n var_samp = fmap[vIndex][\"vid\"]\n if variable[var_samp][\"isEvidence\"] != 1:\n evidence = draw_sample(var_samp, var_copy, weight_copy,\n weight, variable, factor,\n fmap, vmap, factor_index, Z,\n var_value_evid, weight_value)\n # If evidence then store the initial value in a tmp variable\n # then sample and compute the gradient.\n else:\n evidence = variable[var_samp][\"initialValue\"]\n var_value_evid[var_copy][var_samp] = evidence\n # Sample the variable\n proposal = draw_sample(var_samp, var_copy, weight_copy, weight,\n variable, factor, fmap, vmap,\n factor_index, Z, var_value, weight_value)\n var_value[var_copy][var_samp] = proposal\n if not learn_non_evidence and variable[var_samp][\"isEvidence\"] != 1:\n return\n truncate = random.random() < 1.0 / truncation if regularization == 1 else False\n p0 = eval_factor(factor_id, var_samp,\n evidence, var_copy,\n variable, factor, fmap,\n var_value_evid)\n p1 = eval_factor(factor_id, var_samp,\n proposal, var_copy,\n variable, factor, fmap,\n var_value)\n # if need parameterize\n if weight[factor[factor_id]['weightId']]['parameterize']:\n x = fmap[factor[factor_id][\"ftv_offset\"]]['x']\n theta = fmap[factor[factor_id][\"ftv_offset\"]]['theta']\n a = weight[factor[factor_id]['weightId']]['a']\n b = weight[factor[factor_id]['weightId']]['b']\n gradient1 = (p1 - p0) * theta * factor[factor_id][\"featureValue\"] * (x - b)\n gradient2 = (p1 - p0) * theta * factor[factor_id][\"featureValue\"] * (-a)\n gradient1_sum += gradient1\n gradient2_sum += gradient2\n # if not need parameterize\n else:\n gradient = (p1 - p0) * factor[factor_id][\"featureValue\"]\n gradient_sum += gradient\n #求平均值\n # print(\"权重开始平均\")\n gradient1_sum /= var_count\n gradient2_sum /= var_count\n gradient_sum /= var_count\n\n #2.更新参数，分为需要参数化的和不需要参数化的\n #if need parameterize\n if weight[factor[factor_id]['weightId']]['parameterize'] == 1:\n if regularization == 2: # 是否需要正则化\n a *= (1.0 / (1.0 + reg_param * step))\n a -= step * gradient1_sum/factor_count\n b *= (1.0 / (1.0 + reg_param * step))\n b -= step * gradient2_sum/factor_count\n elif regularization == 1:\n # Truncated Gradient\n # \"Sparse Online Learning via Truncated Gradient\"\n # Langford et al. 2009\n a -= step * gradient1_sum/factor_count\n b -= step * gradient2_sum/factor_count\n if truncate:\n l1delta = reg_param * step * truncation\n a = max(0, a - l1delta) if a > 0 else min(0, a + l1delta)\n b = max(0, b - l1delta) if b > 0 else min(0, b + l1delta)\n else:\n a -= step * gradient1_sum/factor_count\n b -= step * gradient2_sum/factor_count\n if a < tau_bound[factor[factor_id]['weightId']]['lowerBound']:\n a = tau_bound[factor[factor_id]['weightId']]['lowerBound']\n elif a > tau_bound[factor[factor_id]['weightId']]['upperBound']:\n a = tau_bound[factor[factor_id]['weightId']]['upperBound']\n if b > alpha_bound[factor[factor_id]['weightId']]['upperBound']:\n b = alpha_bound[factor[factor_id]['weightId']]['upperBound']\n elif b < alpha_bound[factor[factor_id]['weightId']]['lowerBound']:\n b = alpha_bound[factor[factor_id]['weightId']]['lowerBound']\n w = theta * a * (x - b)\n weight[factor[factor_id]['weightId']]['a'] = a\n weight[factor[factor_id]['weightId']]['b'] = b\n # if not need parameterize\n elif weight[factor[factor_id]['weightId']]['parameterize'] == 0:\n w = weight_value[weight_copy][weight_id]\n if regularization == 2:\n w *= (1.0 / (1.0 + reg_param * step))\n w -= step * gradient_sum /factor_count\n elif regularization == 1:\n # Truncated Gradient\n # \"Sparse Online Learning via Truncated Gradient\"\n # Langford et al. 2009\n w -= step * gradient_sum /factor_count\n if truncate:\n l1delta = reg_param * step * truncation\n w = max(0, w - l1delta) if w > 0 else min(0, w + l1delta)\n else:\n w -= step * gradient_sum /factor_count\n weight_value[weight_copy][weight_id] = w\n weight[factor[factor_id]['weightId']]['initialValue'] = w\n if variable[var_samp][\"isEvidence\"] != 1:\n poential_weight[factor[factor_id]['weightId']] = w\n\n\n@jit(nopython=True, cache=True, nogil=True)\ndef get_factor_id_range(variable, vmap, var_samp, val):\n \"\"\"TODO.\"\"\"\n varval_off = val\n if variable[var_samp][\"dataType\"] == 0:\n varval_off = 0\n vtf = vmap[variable[var_samp][\"vtf_offset\"] + varval_off]\n start = vtf[\"factor_index_offset\"]\n end = start + vtf[\"factor_index_length\"]\n return (start, end)\n\n@jit(nopython=True, cache=True, nogil=True)\ndef sample_and_sgd(var_samp, step, regularization, reg_param, truncation,\n var_copy, weight_copy, weight, variable,\n factor, fmap,vmap, factor_index, Z,\n fids, var_value, var_value_evid,\n weight_value, learn_non_evidence,\n poential_weight,alpha_bound,tau_bound):\n \"\"\"TODO.\"\"\"\n # If learn_non_evidence sample twice.\n # The method corresponds to expectation-conjugate descent.\n if variable[var_samp][\"isEvidence\"] != 1:\n evidence = draw_sample(var_samp, var_copy, weight_copy,\n weight, variable, factor,\n fmap, vmap, factor_index, Z,\n var_value_evid, weight_value)\n # If evidence then store the initial value in a tmp variable\n # then sample and compute the gradient.\n else:\n evidence = variable[var_samp][\"initialValue\"]\n\n var_value_evid[var_copy][var_samp] = evidence\n # Sample the variabl e\n proposal = draw_sample(var_samp, var_copy, weight_copy, weight,\n variable, factor, fmap, vmap,\n factor_index, Z, var_value, weight_value)\n\n var_value[var_copy][var_samp] = proposal\n if not learn_non_evidence and variable[var_samp][\"isEvidence\"] != 1:\n return\n # Compute the gradient and update the weights\n # Iterate over corresponding factors\n\n range_fids = get_factor_id_range(variable, vmap, var_samp, evidence)\n # TODO: is it possible to avoid copying around fids\n if evidence != proposal:\n range_prop = get_factor_id_range(variable, vmap, var_samp, proposal)\n s1 = range_fids[1] - range_fids[0]\n s2 = range_prop[1] - range_prop[0]\n s = s1 + s2\n fids[:s1] = factor_index[range_fids[0]:range_fids[1]]\n fids[s1:s] = factor_index[range_prop[0]:range_prop[1]]\n fids[:s].sort()\n else:\n s = range_fids[1] - range_fids[0]\n fids[:s] = factor_index[range_fids[0]:range_fids[1]]\n\n truncate = random.random() < 1.0 / truncation if regularization == 1 else False\n # go over all factor ids, ignoring dupes\n last_fid = -1 # numba 0.28 would complain if this were None\n for factor_id in fids[:s]:\n if factor_id == last_fid:\n continue\n last_fid = factor_id\n weight_id = factor[factor_id][\"weightId\"]\n if weight[weight_id][\"isFixed\"]:\n continue\n # Compute Gradient\n p0 = eval_factor(factor_id, var_samp,\n evidence, var_copy,\n variable, factor, fmap,\n var_value_evid)\n p1 = eval_factor(factor_id, var_samp,\n proposal, var_copy,\n variable, factor, fmap,\n var_value)\n #if need parameterize\n if weight[factor[factor_id]['weightId']]['parameterize'] == 1:\n x = fmap[factor[factor_id][\"ftv_offset\"]]['x']\n theta = fmap[factor[factor_id][\"ftv_offset\"]]['theta']\n a = weight[factor[factor_id]['weightId']]['a']\n b = weight[factor[factor_id]['weightId']]['b']\n gradient1 = (p1 - p0) * theta * factor[factor_id][\"featureValue\"] * (x - b)\n gradient2 = (p1 - p0) * theta * factor[factor_id][\"featureValue\"] * (-a)\n if regularization == 2: # 是否需要正则化\n a *= (1.0 / (1.0 + reg_param * step))\n a -= step * gradient1\n b *= (1.0 / (1.0 + reg_param * step))\n b -= step * gradient2\n elif regularization == 1:\n # Truncated Gradient\n # \"Sparse Online Learning via Truncated Gradient\"\n # Langford et al. 2009\n a -= step * gradient1\n b -= step * gradient2\n if truncate:\n l1delta = reg_param * step * truncation\n a = max(0, a - l1delta) if a > 0 else min(0, a + l1delta)\n b = max(0, b - l1delta) if b > 0 else min(0, b + l1delta)\n else:\n a -= step * gradient1\n b -= step * gradient2\n\n # if alpha_bound != None and tau_bound != None:\n if a < tau_bound[factor[factor_id]['weightId']]['lowerBound']:\n a = tau_bound[factor[factor_id]['weightId']]['lowerBound']\n elif a > tau_bound[factor[factor_id]['weightId']]['upperBound']:\n a = tau_bound[factor[factor_id]['weightId']]['upperBound']\n if b > alpha_bound[factor[factor_id]['weightId']]['upperBound']:\n b = alpha_bound[factor[factor_id]['weightId']]['upperBound']\n elif b < alpha_bound[factor[factor_id]['weightId']]['lowerBound']:\n b = alpha_bound[factor[factor_id]['weightId']]['lowerBound']\n w = theta * a * (x - b)\n weight[factor[factor_id]['weightId']]['a'] = a\n weight[factor[factor_id]['weightId']]['b'] = b\n #如果不需要参数化\n elif weight[factor[factor_id]['weightId']]['parameterize'] == 0:\n gradient = (p1 - p0) * factor[factor_id][\"featureValue\"]\n # Update weight\n w = weight_value[weight_copy][weight_id]\n if regularization == 2:\n w *= (1.0 / (1.0 + reg_param * step))\n w -= step * gradient\n elif regularization == 1:\n # Truncated Gradient\n # \"Sparse Online Learning via Truncated Gradient\"\n # Langford et al. 2009\n w -= step * gradient\n if truncate:\n l1delta = reg_param * step * truncation\n w = max(0, w - l1delta) if w > 0 else min(0, w + l1delta)\n else:\n w -= step * gradient\n weight_value[weight_copy][weight_id] = w\n weight[factor[factor_id]['weightId']]['initialValue'] = w\n if variable[var_samp][\"isEvidence\"] != 1:\n poential_weight[factor[factor_id]['weightId']] = w\n", "meta": {"hexsha": "43c30cfc83b96d165a88831b9deb36641496ab5f", "size": 16040, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/gradual-ml/numbskull_extend/learning.py", "max_stars_repo_name": "gml-explore/gradual-ml", "max_stars_repo_head_hexsha": "cc3b0806498798c394f844980d268a7ceac2228d", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-12-22T13:29:43.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-08T02:09:00.000Z", "max_issues_repo_path": "src/gradual-ml/numbskull_extend/learning.py", "max_issues_repo_name": "gml-explore/gradual-ml", "max_issues_repo_head_hexsha": "cc3b0806498798c394f844980d268a7ceac2228d", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/gradual-ml/numbskull_extend/learning.py", "max_forks_repo_name": "gml-explore/gradual-ml", "max_forks_repo_head_hexsha": "cc3b0806498798c394f844980d268a7ceac2228d", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-05-11T01:34:48.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-02T08:12:44.000Z", "avg_line_length": 48.7537993921, "max_line_length": 102, "alphanum_fraction": 0.5670822943, "include": true, "reason": "import numpy,import numba,from numba", "num_tokens": 3988, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6513548646660542, "lm_q2_score": 0.2942149597859341, "lm_q1q2_score": 0.19163834531409568}} {"text": "from __future__ import division\nfrom __future__ import print_function\nfrom __future__ import absolute_import\n\nimport sys\nimport numpy as np\n\nimport torch\nimport torch.nn as nn\nfrom torch.nn import functional as F\nimport torch.nn.utils.rnn as rnn_utils\n\nfrom .loss import (\n gaussian_log_pdf,\n unit_gaussian_log_pdf,\n bernoulli_log_pdf,\n categorical_program_log_pdf,\n)\nfrom .utils import log_mean_exp\n\n\nclass ProgramRNN(nn.Module):\n r\"\"\"Supervised recurrent neural network for predicting feedback labels.\n Parameterizes p(label|program). \n\n @param z_dim: integer\n size of latent vector\n @param label_dim: integer\n number of (binary) labels\n @param vocab_size: integer\n size of vocabulary\n @param embedding_dim: integer [default: 300]\n size of learned embedding\n @param hidden_dim: integer [default: 256]\n size of hidden layer\n @param word_dropout: float [default: 0.5]\n probability to dropout input sequences to decoder\n @param num_layers: integer [default: 2]\n number of hidden layers in GRU\n \"\"\"\n def __init__( self, z_dim, label_dim, vocab_size, embedding_dim=300, \n hidden_dim=256, num_layers=2):\n super(ProgramRNN, self).__init__()\n\n self.z_dim = z_dim\n self.label_dim = label_dim\n self.vocab_size = vocab_size\n self.embedding_dim = embedding_dim\n self.hidden_dim = hidden_dim\n self.num_layers = num_layers\n\n self.embedding_module = nn.Embedding(self.vocab_size, self.embedding_dim)\n self.encoder = ProgramEncoder( self.embedding_module, self.z_dim, \n hidden_dim=self.hidden_dim, \n num_layers=self.num_layers)\n self.decoder = LabelDecoder(self.z_dim, self.label_dim, \n hidden_dim=self.hidden_dim)\n\n def forward(self, seq, length):\n z_mu, _ = self.encoder(seq, length)\n return self.decoder(z_mu)\n\n\nclass ProgramMVAE(nn.Module):\n r\"\"\"Multimodal Variational Autoencoder (MVAE) with Expert Supervision.\n The MVAE is the equivalent of a soft transformation of the expert pCFG graph.\n\n @param z_dim: integer\n size of latent vector\n @param label_dim: integer\n number of (binary) labels\n @param vocab_size: integer\n size of vocabulary\n @param sutilos_idx: integer\n index for start-of-sentence\n @param eos_idx: integer\n index for end-of-sentence\n @param pad_idx: integer\n index for padding\n @param unk_idx: integer\n index for unknown tokens\n @param embedding_dim: integer [default: 300]\n size of learned embedding\n @param hidden_dim: integer [default: 256]\n size of hidden layer\n @param word_dropout: float [default: 0.5]\n probability to dropout input sequences to decoder\n @param num_layers: integer [default: 2]\n number of hidden layers in GRU\n \"\"\"\n def __init__(self, z_dim, label_dim, vocab_size, sos_idx, eos_idx, pad_idx, unk_idx,\n embedding_dim=300, hidden_dim=256, word_dropout=0.5, num_layers=2):\n super(ProgramMVAE, self).__init__()\n\n self.z_dim = z_dim\n self.label_dim = label_dim\n self.embedding_dim = embedding_dim\n self.hidden_dim = hidden_dim\n self.vocab_size = vocab_size\n self.sos_idx = sos_idx\n self.eos_idx = eos_idx\n self.pad_idx = pad_idx\n self.unk_idx = unk_idx\n self.word_dropout = word_dropout\n self.num_layers = num_layers\n\n self.product_experts = ProductOfExperts()\n self.embedding_module = nn.Embedding(self.vocab_size, self.embedding_dim)\n\n self.program_encoder = ProgramEncoder( self.embedding_module, self.z_dim, \n hidden_dim=self.hidden_dim, \n num_layers=self.num_layers)\n self.program_decoder = ProgramDecoder(\n self.embedding_module, self.z_dim, self.sos_idx, self.eos_idx, self.pad_idx, self.unk_idx,\n hidden_dim=self.hidden_dim, word_dropout=self.word_dropout, num_layers=self.num_layers)\n \n self.label_encoder = LabelEncoder(\n self.z_dim, self.label_dim, hidden_dim=self.hidden_dim)\n self.label_decoder = LabelDecoder(\n self.z_dim, self.label_dim, hidden_dim=self.hidden_dim)\n \n def reparameterize(self, z_mu, z_logvar):\n std = torch.exp(0.5 * z_logvar)\n eps = torch.randn_like(std)\n return eps.mul(std).add_(z_mu)\n\n def forward(self, seq, length, label, hide_seq=False):\n if hide_seq:\n z_mu, z_logvar = self.inference(None, None, label)\n else:\n z_mu, z_logvar = self.inference(seq, length, label)\n\n z = self.reparameterize(z_mu, z_logvar)\n seq_logits = self.program_decoder(z, seq, length)\n label_out = self.label_decoder(z)\n\n return seq_logits, label_out, z, z_mu, z_logvar\n\n def prior_expert(self, mu):\n p_mu = torch.zeros_like(mu)\n p_logvar = torch.zeros_like(mu)\n return p_mu, p_logvar\n\n def inference(self, seq, length, label):\n z_mu, z_logvar = [], []\n \n if seq is not None:\n program_mu, program_logvar = self.program_encoder(seq, length)\n z_mu.append(program_mu.unsqueeze(0))\n z_logvar.append(program_logvar.unsqueeze(0))\n\n if label is not None:\n label_mu, label_logvar = self.label_encoder(label)\n z_mu.append(label_mu.unsqueeze(0))\n z_logvar.append(label_logvar.unsqueeze(0))\n\n prior_mu, prior_logvar = self.prior_expert(z_mu[0])\n z_mu.append(prior_mu)\n z_logvar.append(prior_logvar)\n\n z_mu = torch.cat(z_mu, dim=0)\n z_logvar = torch.cat(z_logvar, dim=0)\n\n z_mu, z_logvar = self.product_experts(z_mu, z_logvar)\n\n return z_mu, z_logvar\n\n def get_joint_marginal(self, seq, length, label, n_samples=100):\n z_mu, z_logvar = self.inference(seq, length, label)\n\n log_w = []\n for i in xrange(n_samples):\n z_i = self.reparameterize(z_mu, z_logvar)\n x_logits_i = self.program_decoder(z_i, seq, length)\n y_out_i = self.label_decoder(z_i)\n\n log_p_x_given_z_i = categorical_program_log_pdf(seq[:, 1:], x_logits_i[:, :-1])\n log_p_y_given_z_i = bernoulli_log_pdf(label, y_out_i)\n log_q_z_given_x_y_i = gaussian_log_pdf(z_i, z_mu, z_logvar)\n log_p_z_i = unit_gaussian_log_pdf(z_i)\n\n log_w_i = log_p_x_given_z_i + log_p_y_given_z_i + log_p_z_i - log_q_z_given_x_y_i\n log_w.append(log_w_i.unsqueeze(1))\n\n log_w = torch.cat(log_w, dim=1)\n log_p_x_y = log_mean_exp(log_w, dim=1)\n log_p_x_y = -torch.mean(log_p_x_y)\n\n return log_p_x_y\n\n def get_program_marginal(self, seq, length, n_samples=100):\n z_mu, z_logvar = self.inference(seq, length, None)\n\n log_w = []\n for i in xrange(n_samples):\n z_i = self.reparameterize(z_mu, z_logvar)\n seq_logits_i = self.program_decoder(z_i, seq, length)\n\n # probability of text is product of probabilities of each word\n log_p_x_given_z_i = categorical_program_log_pdf(seq[:, 1:], seq_logits_i[:, :-1])\n log_q_z_given_x_i = gaussian_log_pdf(z_i, z_mu, z_logvar)\n log_p_z_i = unit_gaussian_log_pdf(z_i)\n\n log_w_i = log_p_x_given_z_i + log_p_z_i - log_q_z_given_x_i\n log_w.append(log_w_i.unsqueeze(1))\n\n log_w = torch.cat(log_w, dim=1)\n log_p_x = log_mean_exp(log_w, dim=1)\n log_p_x = -torch.mean(log_p_x)\n\n return log_p_x\n\n def get_label_marginal(self, y, n_samples=100):\n z_mu, z_logvar = self.inference(None, None, y)\n\n log_w = []\n for i in xrange(n_samples):\n z_i = self.reparameterize(z_mu, z_logvar)\n y_out_i = self.label_decoder(z_i)\n\n log_p_y_given_z_i = bernoulli_log_pdf(y, y_out_i)\n log_q_z_given_y_i = gaussian_log_pdf(z_i, z_mu, z_logvar)\n log_p_z_i = unit_gaussian_log_pdf(z_i)\n\n log_w_i = log_p_y_given_z_i + log_p_z_i - log_q_z_given_y_i\n log_w.append(log_w_i.unsqueeze(1))\n\n log_w = torch.cat(log_w, dim=1)\n log_p_y = log_mean_exp(log_w, dim=1)\n log_p_y = -torch.mean(log_p_y)\n\n return log_p_y\n\n\nclass ProgramEncoder(nn.Module):\n r\"\"\"Parameterizes q(z|program) with RNN.\n\n Inspired by Bowman et. al. (https://arxiv.org/abs/1511.06349).\n\n @param embedding_module: nn.Embedding\n we initialize this separately from the encoder\n @param z_dim: integer\n size of latent vector\n @param hidden_dim: integer [default: 256]\n size of hidden layer\n @param num_layers: integer [default: 2]\n number of hidden layers in GRU\n \"\"\"\n def __init__(self, embedding_module, z_dim, hidden_dim=256, num_layers=2):\n super(ProgramEncoder, self).__init__()\n\n self.embedding = embedding_module\n self.embedding_dim = self.embedding.embedding_dim\n self.z_dim = z_dim\n self.hidden_dim = hidden_dim\n self.num_layers = num_layers\n\n self.gru = nn.GRU(self.embedding_dim, self.hidden_dim, num_layers=num_layers)\n self.h2mu = nn.Linear(self.hidden_dim * self.num_layers, self.z_dim)\n self.h2logvar = nn.Linear(self.hidden_dim * self.num_layers, self.z_dim)\n\n def forward(self, seq, length):\n batch_size = seq.size(0)\n\n if batch_size > 1:\n # sort in decreasing order of length in order to pack\n # sequence; if only 1 element in batch, nothing to do.\n sorted_lengths, sorted_idx = torch.sort(length, descending=True)\n seq = seq[sorted_idx]\n\n embed_seq = self.embedding(seq)\n # reorder from (B,L,D) to (L,B,D)\n embed_seq = embed_seq.transpose(0, 1)\n\n packed = rnn_utils.pack_padded_sequence(\n embed_seq,\n sorted_lengths.data.tolist() if batch_size > 1 else length.data.tolist())\n\n _, hidden = self.gru(packed)\n hidden = hidden.permute(1, 0, 2).contiguous()\n hidden = hidden.view(batch_size, self.hidden_dim * self.num_layers)\n\n if batch_size > 1:\n _, reversed_idx = torch.sort(sorted_idx)\n hidden = hidden[reversed_idx]\n\n z_mu = self.h2mu(hidden)\n z_logvar = self.h2logvar(hidden)\n\n return z_mu, z_logvar\n\n\nclass ProgramDecoder(nn.Module):\n r\"\"\"Parameterizes p(program|z) with RNN to generate a distribution of a \n sequence of tokens. Assumes a maximum sequence length and a fixed vocabulary.\n\n We return logits to a categorical so please use\n nn.CrossEntropy\n instead of\n nn.NLLLoss\n\n Inspired by Bowman et. al. (https://arxiv.org/abs/1511.06349).\n\n @param embedding_module: nn.Embedding\n pass the embedding module (share with encoder)\n @param z_dim: integer\n size of latent vector\n @param sos_idx: integer\n index for start-of-sentence\n @param eos_idx: integer\n index for end-of-sentence\n @param pad_idx: integer\n index for padding\n @param unk_idx: integer\n index for unknown tokens\n @param hidden_dim: integer [default: 256]\n size of hidden layer\n @param word_dropout: float [default: 0.5]\n probability to dropout input sequences to decoder\n @param num_layers: integer [default: 2]\n number of hidden layers in GRU\n \"\"\"\n def __init__( self, embedding_module, z_dim, sos_idx, eos_idx, pad_idx, unk_idx,\n hidden_dim=256, word_dropout=0.5, num_layers=2):\n super(ProgramDecoder, self).__init__()\n\n self.embedding = embedding_module\n self.embedding_dim = embedding_module.embedding_dim\n self.vocab_size = embedding_module.num_embeddings\n self.z_dim = z_dim\n self.hidden_dim = hidden_dim\n self.sos_idx = sos_idx\n self.eos_idx = eos_idx\n self.pad_idx = pad_idx\n self.unk_idx = unk_idx\n self.word_dropout = word_dropout\n self.num_layers = num_layers\n self.gru = nn.GRU( self.embedding_dim, self.hidden_dim,\n num_layers=self.num_layers)\n self.z2h = nn.Linear(self.z_dim, self.hidden_dim * self.num_layers)\n self.outputs2vocab = nn.Linear(self.hidden_dim, self.vocab_size)\n\n def forward(self, z, seq, length):\n batch_size = z.size(0)\n\n if batch_size > 1:\n sorted_lengths, sorted_idx = torch.sort(length, descending=True)\n\n z = z[sorted_idx]\n seq = seq[sorted_idx]\n\n if self.word_dropout > 0:\n # randomly replace with unknown tokens\n prob = torch.rand(seq.size())\n prob[(seq.cpu().data - self.sos_idx) & \\\n (seq.cpu().data - self.pad_idx) == 0] = 1\n mask_seq = seq.clone()\n mask_seq[(prob < self.word_dropout).to(z.device)] = self.unk_idx\n seq = mask_seq\n\n embed_seq = self.embedding(seq)\n # reorder from (B,L,D) to (L,B,D)\n embed_seq = embed_seq.transpose(0, 1)\n\n packed = rnn_utils.pack_padded_sequence(\n embed_seq,\n sorted_lengths.data.tolist() if batch_size > 1 else length.data.tolist())\n\n hidden = self.z2h(z)\n hidden = hidden.view(batch_size, self.num_layers, self.hidden_dim)\n hidden = hidden.permute(1, 0, 2).contiguous()\n\n outputs, _ = self.gru(packed, hidden)\n outputs = rnn_utils.pad_packed_sequence(outputs, batch_first=True)[0]\n outputs = outputs.contiguous()\n\n # reorder from (L,B,D) to (B,L,D)\n outputs = outputs.transpose(0, 1)\n\n if batch_size > 1:\n _, reversed_idx = torch.sort(sorted_idx)\n outputs = outputs[reversed_idx]\n\n max_length = outputs.size(1)\n outputs_2d = outputs.view(batch_size * max_length, self.hidden_dim)\n outputs_2d = self.outputs2vocab(outputs_2d)\n outputs = outputs_2d.view(batch_size, max_length, self.vocab_size)\n\n return outputs.contiguous()\n\n def sample(self, z, max_seq_len, greedy=False):\n r\"\"\"Sample tokens in an auto-regressive framework.\n \n @param z: torch.Tensor\n sample of latent variables\n @param max_seq_len: integer\n maximum size of sequence\n @param greedy: boolean [default: False]\n pick most likely token or sample token?\n \"\"\"\n with torch.no_grad():\n batch_size = z.size(0) \n\n # initialize hidden state\n hidden = self.z2h(z)\n hidden = hidden.view(batch_size, self.num_layers, self.hidden_dim)\n hidden = hidden.permute(1, 0, 2).contiguous()\n\n # first input is SOS token\n inputs = np.array([self.sos_idx for _ in xrange(batch_size)])\n inputs = torch.from_numpy(inputs)\n inputs = inputs.unsqueeze(1)\n inputs = inputs.to(z.device)\n \n # save SOS as first generated token\n inputs_npy = inputs.squeeze(1).cpu().numpy()\n sampled_ids = [[w] for w in inputs_npy]\n\n # (B,L,D) to (L,B,D)\n inputs = inputs.transpose(0, 1)\n\n # compute embeddings\n inputs = self.embedding(inputs)\n\n for i in xrange(max_seq_len):\n outputs, hidden = self.gru(inputs, hidden) # outputs: (L=1,B,H)\n outputs = outputs.squeeze(0) # outputs: (B,H)\n outputs = self.outputs2vocab(outputs) # outputs: (B,V)\n\n if greedy:\n predicted = outputs.max(1)[1]\n predicted = predicted.unsqueeze(1)\n else:\n outputs = F.softmax(outputs, dim=1)\n predicted = torch.multinomial(outputs, 1)\n\n predicted_npy = predicted.squeeze(1).cpu().numpy()\n predicted_lst = predicted_npy.tolist()\n\n for w, so_far in zip(predicted_lst, sampled_ids):\n if so_far[-1] != self.eos_idx:\n so_far.append(w)\n\n inputs = predicted.transpose(0, 1) # inputs: (L=1,B)\n inputs = self.embedding(inputs) # inputs: (L=1,B,E)\n\n sampled_lengths = [len(text) for text in sampled_ids]\n sampled_lengths = np.array(sampled_lengths)\n\n max_length = max(sampled_lengths)\n padded_ids = np.ones((batch_size, max_length)) * self.pad_idx\n\n for i in xrange(batch_size):\n padded_ids[i, :sampled_lengths[i]] = sampled_ids[i]\n\n sampled_lengths = torch.from_numpy(sampled_lengths).long()\n sampled_ids = torch.from_numpy(padded_ids).long()\n\n return sampled_ids, sampled_lengths\n\n\nclass LabelEncoder(nn.Module):\n r\"\"\"Parameterizes q(z|label).\n\n @param z_dim: integer\n number of latent dimensions\n @param label_dim: integer\n number of label dimensions\n @param hidden_dim: integer [default: 256]\n number of hidden dimensions\n \"\"\"\n def __init__(self, z_dim, label_dim, hidden_dim=256):\n super(LabelEncoder, self).__init__()\n self.z_dim = z_dim\n self.label_dim = label_dim\n self.hidden_dim = hidden_dim\n\n self.net = nn.Sequential(\n nn.Linear(self.label_dim, self.hidden_dim),\n Swish(),\n nn.Linear(self.hidden_dim, self.hidden_dim),\n Swish(),\n # here we don't explicitly separate into (mu, logvar)\n # but equivalent thing\n nn.Linear(self.hidden_dim, self.z_dim * 2))\n\n def forward(self, x):\n h = self.net(x)\n z_mu, z_logvar = torch.chunk(h, 2, dim=1)\n\n return z_mu, z_logvar\n\n\nclass LabelDecoder(nn.Module):\n r\"\"\"Parameterizes p(label|z).\n \n @param z_dim: integer\n number of latent dimensions\n @param label_dim: integer\n number of label dimensions\n @param hidden_dim: integer [default: 256]\n number of hidden dimensions\n \"\"\"\n def __init__(self, z_dim, label_dim, hidden_dim=256):\n super(LabelDecoder, self).__init__()\n\n self.z_dim = z_dim\n self.label_dim = label_dim\n self.hidden_dim = hidden_dim\n\n self.net = nn.Sequential(\n nn.Linear(self.z_dim, self.hidden_dim),\n Swish(),\n nn.Linear(self.hidden_dim, self.hidden_dim),\n Swish(),\n nn.Linear(self.hidden_dim, self.hidden_dim),\n Swish(),\n nn.Linear(self.hidden_dim, self.label_dim))\n\n def forward(self, z):\n # we assume binary labels\n return torch.sigmoid(self.net(z))\n\n\nclass ProductOfExperts(nn.Module):\n r\"\"\"Return parameters for product of independent experts.\n See https://arxiv.org/pdf/1410.7827.pdf for equations.\n\n @param mu: M x D for M experts\n @param logvar: M x D for M experts\n \"\"\"\n def forward(self, mu, logvar, eps=1e-8):\n var = torch.exp(logvar) + eps\n T = 1 / var # precision of i-th Gaussian expert at point x\n pd_mu = torch.sum(mu * T, dim=0) / torch.sum(T, dim=0)\n pd_var = 1 / torch.sum(T, dim=0)\n pd_logvar = torch.log(pd_var)\n\n return pd_mu, pd_logvar\n\n\nclass Swish(nn.Module):\n def forward(self, x):\n return x * torch.sigmoid(x)\n\n\ndef swish(x):\n return x * torch.sigmoid(x)\n", "meta": {"hexsha": "4e684a0622546775a0d35bbba5c380a5adf9ee1c", "size": 20086, "ext": "py", "lang": "Python", "max_stars_repo_path": "rubric_sampling/experiments/models.py", "max_stars_repo_name": "YangAzure/rubric-sampling-public", "max_stars_repo_head_hexsha": "24e8c6bc154633566f93a20661c67484029c3591", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 20, "max_stars_repo_stars_event_min_datetime": "2019-01-29T03:21:40.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-04T08:52:24.000Z", "max_issues_repo_path": "rubric_sampling/experiments/models.py", "max_issues_repo_name": "YangAzure/rubric-sampling-public", "max_issues_repo_head_hexsha": "24e8c6bc154633566f93a20661c67484029c3591", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "rubric_sampling/experiments/models.py", "max_forks_repo_name": "YangAzure/rubric-sampling-public", "max_forks_repo_head_hexsha": "24e8c6bc154633566f93a20661c67484029c3591", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2019-08-31T11:49:23.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-18T13:22:58.000Z", "avg_line_length": 36.5865209472, "max_line_length": 102, "alphanum_fraction": 0.6031564274, "include": true, "reason": "import numpy", "num_tokens": 4683, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6442250928250375, "lm_q2_score": 0.29746994883293104, "lm_q1q2_score": 0.19163760539955416}} {"text": "#!/usr/bin/env python\n# -*- coding:utf8 -*-\n\"\"\"\n@author: ruohua\n@file: eval.py\n@time: 2021/2/22 8:03 PM\n\"\"\"\nimport numpy as np\nimport argparse\nfrom multiprocessing.dummy import Pool as ThreadPool\nimport os\nimport cv2\nfrom functools import partial\nimport glob\n\n\ndef single_eval_boundary(fg_boundary, gt_boundary, bound_pix=0):\n \"\"\"\n Compute mean,recall and decay from per-frame evaluation.\n Calculates precision/recall for boundaries between foreground_mask and\n gt_mask using morphological operators to speed it up.\n\n Arguments:\n fg_boundary (ndarray): binary boundary prediction image. Shape: H x W Value: 0 and 255\n gt_boundary (ndarray): binary annotated boundary image. Shape: H x W Value: 0 and 255\n bound_pix: half of the thickness of boundary.\n A morphology dilation will make the thickness of edge to what we set here\n this is the radius of disk\n\n Returns:\n F (float): boundaries F-measure\n P (float): boundaries precision\n R (float): boundaries recall\n \"\"\"\n assert np.atleast_3d(fg_boundary).shape[2] == 1\n\n from skimage.morphology import binary_dilation, disk\n\n fg_dil = binary_dilation(fg_boundary, disk(bound_pix))\n gt_dil = binary_dilation(gt_boundary, disk(bound_pix))\n\n # Get the intersection\n gt_match = gt_boundary * fg_dil\n fg_match = fg_boundary * gt_dil\n\n # Area of the intersection\n n_fg = np.sum(fg_boundary)\n n_gt = np.sum(gt_boundary)\n\n # % Compute precision and recall\n if n_fg == 0 and n_gt > 0:\n precision = 1\n recall = 0\n elif n_fg > 0 and n_gt == 0:\n precision = 0\n recall = 1\n elif n_fg == 0 and n_gt == 0:\n precision = 1\n recall = 1\n else:\n precision = np.sum(fg_match) / float(n_fg)\n recall = np.sum(gt_match) / float(n_gt)\n\n # Compute F meas\n # ure\n if precision + recall == 0:\n F = 0\n else:\n F = 2 * precision * recall / (precision + recall)\n\n return F, precision, recall\n\n\ndef reverse_black_and_white(img):\n \"\"\"\n reverse black and white color\n :param img: binary img\n :return:\n \"\"\"\n img = 255 - img\n\n return img\n\n\ndef check_if_white_back_black_edge(pred):\n \"\"\"\n check if the prediction image is binary\n 1. 0 for membrane; 255 for not manbrane\n 2. check if binary\n \"\"\"\n values = np.unique(pred)\n # print(values)\n\n # check if binary\n if len(values) > 2:\n print(\"Your prediction result has not been binarized, please prompt them to choose the appropriate threshold for binarization.\")\n raise ValueError\n\n white_pos = np.where(pred == 255)\n # print(len(white_pos[0]))\n white_count = len(white_pos[0])\n black_pos = np.where(pred == 0)\n # print(len(black_pos[0]))\n black_count = len(black_pos[0])\n # print(black_count / white_count)\n rate = black_count / white_count\n if rate < 5:\n print(\"The results must be submitted with white background and black edge. Please submit after correction.\")\n raise ValueError\n\n\ndef single_eval_wrapper(bound_pix, result_matrix, data_list_line):\n id_, pred_path, gt_path = data_list_line\n\n print(\"Now evaluating the %s prediction, path = %s\" % (id_, pred_path))\n\n pred_ = cv2.imread(pred_path, 0)\n gt_ = cv2.imread(gt_path, 0)\n\n pred_ = reverse_black_and_white(pred_)\n gt_ = reverse_black_and_white(gt_)\n\n check_if_white_back_black_edge(pred_)\n\n F, precision, recall = single_eval_boundary(pred_, gt_, bound_pix)\n\n result_matrix[int(id_)] = [F, precision, recall]\n\n\ndef eval_on_whole_dataset(pred_folder_path, gt_folder_path, bound_pix, thread_num):\n pred_list_all = glob.glob(pred_folder_path + '/*.png')\n print(pred_list_all)\n\n gt_list_all = []\n for pre in pred_list_all:\n gt_list_all.append(pre.replace(pred_folder_path,gt_folder_path))\n print(gt_list_all)\n\n id_list = [x for x in range(len(gt_list_all))]\n\n gt_list = np.asarray(gt_list_all)\n pred_list = np.asarray(pred_list_all)\n id_list = np.asarray(id_list)\n\n gt_list = np.expand_dims(gt_list, 1)\n pred_list = np.expand_dims(pred_list, 1)\n id_list = np.expand_dims(id_list, 1)\n\n data_list = np.concatenate([id_list, pred_list, gt_list], axis=1) # data list for pool\n\n result_matrix = np.zeros_like(data_list) # each line contains: F-score, precision, recall\n\n pool = ThreadPool(thread_num) \n\n pool.map(partial(single_eval_wrapper, bound_pix, result_matrix), data_list)\n\n pool.close()\n pool.join()\n\n result_matrix = np.asarray(result_matrix, dtype=np.float)\n F_score = result_matrix[:, 0]\n print(F_score)\n mean_F = np.mean(F_score)\n\n return mean_F\n\ndef eval_on_onepic(pred_path, gt_path, bound_pix=0):\n pred_ = cv2.imread(pred_path, 0)\n gt_ = cv2.imread(gt_path, 0)\n\n pred_ = 255 - pred_\n gt_ = 255 - gt_\n\n check_if_white_back_black_edge(pred_)\n print(\"Check format: OK!\")\n\n F, precision, recall = single_eval_boundary(pred_, gt_, bound_pix=0)\n return F\n\ndef calc_ap(prec, rec):\n mrec = np.array([0, rec, 1])\n mpre = np.array([0, prec, 0])\n\n for i in range(mrec.size - 2, -1, -1):\n mpre[i] = max(mpre[i], mpre[i+1]);\n #print mpre[i]\n\n idx1 = np.where(mrec[1 : ] != mrec[0 : 2])\n idx2 = [x + 1 for x in idx1]\n\n ap = sum((mrec.take(idx2) - mrec.take(idx1)) * mpre.take(idx2))\n print(\"ap = \" + str(ap[0]))\n return ap[0]\n\n\nif __name__ == '__main__':\n\n parser = argparse.ArgumentParser()\n parser.add_argument('--evalon1pic', type=str,\n default='True', help='if evaluate on one image, True or False')\n parser.add_argument('--pre_path', type=str,\n default='./pre.png', help='prediction path')\n parser.add_argument('--gt_path', type=str,\n default='./gt.png', help='ground truth path')\n args = parser.parse_args()\n \n \n pre_path = args.pre_path\n gt_path = args.gt_path\n bound_pix = 0 # the thickness of boundary\n thread_num = 4 # number of parallel threads\n\n print(\"Evaluate on one image? {}\".format(args.evalon1pic))\n\n if args.evalon1pic == 'True':\n # eval on single image\n print(\"evaluate {} and {}\".format(pre_path,gt_path))\n mean_F = eval_on_onepic(pre_path, gt_path, bound_pix)\n print(\"The F1-score of prediction is : {}\".format(mean_F))\n\n if args.evalon1pic == 'False':\n # eval on folder\n mean_F = eval_on_whole_dataset(pre_path, gt_path, bound_pix, thread_num)\n print(\"Mean F_score of all prediction is {}\".format(mean_F))\n\n\n", "meta": {"hexsha": "5cb023fa94c81fa7959e75615012c1c4ce6056e7", "size": 6627, "ext": "py", "lang": "Python", "max_stars_repo_path": "Evaluation/eval.py", "max_stars_repo_name": "EmmaSRH/U-RISC-Data-Code", "max_stars_repo_head_hexsha": "eaddb4a883f1db784834a457fafabad340717bcc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-07-08T01:11:17.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-08T01:11:17.000Z", "max_issues_repo_path": "Evaluation/eval.py", "max_issues_repo_name": "EmmaSRH/U-RISC-Data-Code", "max_issues_repo_head_hexsha": "eaddb4a883f1db784834a457fafabad340717bcc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-01-07T14:04:44.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-08T08:16:50.000Z", "max_forks_repo_path": "Evaluation/eval.py", "max_forks_repo_name": "EmmaSRH/U-RISC-Data-Code", "max_forks_repo_head_hexsha": "eaddb4a883f1db784834a457fafabad340717bcc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.1938325991, "max_line_length": 136, "alphanum_fraction": 0.6487098234, "include": true, "reason": "import numpy", "num_tokens": 1755, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5273165233795671, "lm_q2_score": 0.3629691986286475, "lm_q1q2_score": 0.19139965591472596}} {"text": "# -*- coding: utf-8 -*-\n# Author: Daniel Ryan \n\n\"\"\"Some IRIS instrument tools.\"\"\"\n\nimport datetime\nimport warnings\nimport os.path\n\nimport numpy as np\nimport astropy.units as u\nfrom astropy.units.quantity import Quantity\nfrom astropy.modeling import fitting\nfrom astropy.modeling.models import custom_model\nfrom astropy import constants\nimport scipy.io\nfrom scipy import ndimage\nfrom scipy import interpolate\nfrom sunpy.time import parse_time\nimport sunpy.util.config\nfrom sunpy.util.net import check_download_file\nfrom ndcube import NDCube\n\n# Define some properties of IRIS detectors. Source: IRIS instrument\n# paper.\nDETECTOR_GAIN = {\"NUV\": 18., \"FUV\": 6., \"SJI\": 18.}\nDETECTOR_YIELD = {\"NUV\": 1., \"FUV\": 1.5, \"SJI\": 1.}\nSJI_DEFAULT_BSCALE = 0.25\nSJI_DEFAULT_BZERO = 7992.0\nDN_UNIT = {\n \"NUV\": u.def_unit(\"DN_IRIS_NUV\",\n DETECTOR_GAIN[\"NUV\"] / DETECTOR_YIELD[\"NUV\"]*u.photon),\n \"FUV\": u.def_unit(\"DN_IRIS_FUV\",\n DETECTOR_GAIN[\"FUV\"]/DETECTOR_YIELD[\"FUV\"]*u.photon),\n \"SJI\": u.def_unit(\"DN_IRIS_SJI\",\n DETECTOR_GAIN[\"SJI\"]/DETECTOR_YIELD[\"SJI\"]*u.photon),\n \"SJI_UNSCALED\": u.def_unit(\"DN_IRIS_SJI_UNSCALED\", u.ct)}\n# Define an equivalency between SJI and SJI_UNSCALED units\nSJI_SCALING = [(DN_UNIT[\"SJI\"],\n DN_UNIT[\"SJI_UNSCALED\"],\n lambda x: (x - SJI_DEFAULT_BZERO) / SJI_DEFAULT_BSCALE,\n lambda x: x * SJI_DEFAULT_BSCALE + SJI_DEFAULT_BZERO)]\n\nREADOUT_NOISE = {\"NUV\": 1.2*DN_UNIT[\"NUV\"],\n \"FUV\": 3.1*DN_UNIT[\"FUV\"],\n \"SJI\": 1.2*DN_UNIT[\"SJI\"]}\nRADIANCE_UNIT = u.erg / u.cm ** 2 / u.s / u.steradian / u.Angstrom\nSLIT_WIDTH = 0.33*u.arcsec\n\nIRIS_RESPONSE_REMOTE_PATH = \"https://sohowww.nascom.nasa.gov/solarsoft/iris/response/\"\nRESPONSE_VERSION_FILENAMES = {\"1\": \"iris_sra_20130211.geny\",\n \"2\": \"iris_sra_20130715.geny\",\n \"3\": \"iris_sra_c_20150331.geny\",\n \"4\": \"iris_sra_c_20161022.geny\"}\n\n# Define some custom error messages.\nAPPLY_EXPOSURE_TIME_ERROR = (\"Exposure time correction has probably already \"\n \"been applied since the unit already includes \"\n \"inverse time. To apply exposure time correction \"\n \"anyway, set 'force' kwarg to True.\")\nUNDO_EXPOSURE_TIME_ERROR = (\"Exposure time correction has probably already \"\n \"been undone since the unit does not include \"\n \"inverse time. To undo exposure time correction \"\n \"anyway, set 'force' kwarg to True.\")\n\n# Define whether IRIS WCS is 0 or 1 origin based.\nWCS_ORIGIN = 1\n\ndef get_iris_response(pre_launch=False, response_file=None, response_version=None,\n force_download=False):\n \"\"\"Returns IRIS response structure.\n\n One and only one of pre_launch, response_file and response_version must be set.\n\n Parameters\n ----------\n pre_launch: `bool`\n Equivalent to setting response_version=2. Cannot be set\n simultaneously with response_file kwarg. Default=False\n response_file: `str`\n Version number of effective area file to be used. Cannot be set\n simultaneously with pre_launch kwarg. Default=latest\n response_version : `int`\n Version number of effective area file to be used. Cannot be set\n simultaneously with response_file or pre_launch kwarg. Default=latest\n\n Returns\n -------\n iris_response: `dict`\n Various parameters regarding IRIS response. The following keys:\n date_obs: `datetime.datetime`\n lambda: `astropy.units.Quantity`\n area_sg: `astropy.units.Quantity`\n name_sg: `str`\n dn2phot_sg: `tuple` of length 2\n area_sji: `astropy.units.Quantity`\n name_sji: `str`\n dn2phot_sji: `tuple` of length 4\n comment: `str`\n version: `int`\n version_date: `datetime.datetime`\n\n Notes\n -----\n This routine does not calculate time dependent effective areas using\n version 3 and above of the response functions as is done in the SSW version\n of this code. Therefore, asking it to read a version 3 or above response\n function will result in an error. This code should be updated in future\n versions to calculate time dependent effective areas.\n\n \"\"\"\n # Ensures the file exits in the path given.\n if response_file is not None:\n if not(os.path.isfile(response_file)):\n raise KeyError(\"Not a valid file path\")\n\n # Ensure conflicting kwargs are not set.\n if response_file:\n response_file_set = True\n else:\n response_file_set = False\n if response_version:\n response_version_set = True\n else:\n response_version_set = False\n if response_file_set+pre_launch+response_version_set != 1:\n raise ValueError(\"One and only one of kwargs pre_launch, response_file \"\n \"and response_version must be set.\")\n # If pre_launch set, define response_version to 2.\n if pre_launch:\n response_version = 2\n # If response_file not set, define appropriate response file\n # based on version.\n if not response_file:\n try:\n response_filename = RESPONSE_VERSION_FILENAMES[str(response_version)]\n except KeyError:\n raise KeyError(\"Version number not recognized.\")\n if response_version > 2:\n warnings.warn(\"Effective areas are not available (i.e. set to zero). \"\n \"For response file versions > 2 time dependent effective \"\n \"areas must be calculated via fitting, which is not supported \"\n \"by this function at this time. \"\n \"Version of this response file = {0}\".format(response_version))\n # Define the directory in which the response file should exist\n # to be the sunpy download directory.\n config = sunpy.util.config.load_config()\n download_dir = config.get('downloads', 'download_dir')\n # Check response file exists in download_dir. If not, download it.\n check_download_file(response_filename, IRIS_RESPONSE_REMOTE_PATH, download_dir,\n replace=force_download)\n # Define response file as path + filename.\n response_file = os.path.join(download_dir, response_filename)\n\n # Read response file and store in a dictionary.\n raw_response_data = scipy.io.readsav(response_file)\n iris_response = dict([(name, raw_response_data[\"p0\"][name][0])\n for name in raw_response_data[\"p0\"].dtype.names])\n # Convert some properties to more convenient types.\n iris_response[\"LAMBDA\"] = Quantity(iris_response[\"LAMBDA\"], unit=u.nm)\n iris_response[\"AREA_SG\"] = Quantity(iris_response[\"AREA_SG\"], unit=u.cm**2)\n iris_response[\"AREA_SJI\"] = Quantity(iris_response[\"AREA_SJI\"], unit=u.cm**2)\n iris_response[\"GEOM_AREA\"] = Quantity(iris_response[\"GEOM_AREA\"], unit=u.cm**2)\n iris_response[\"VERSION\"] = int(iris_response[\"VERSION\"])\n # Convert some properties not found in version below version 3 to\n # more convenient types.\n if iris_response[\"VERSION\"] > 2:\n # If DATE_OBS has a value, convert to datetime, else set to\n # None.\n try:\n iris_response[\"DATE_OBS\"] = parse_time(iris_response[\"DATE_OBS\"])\n except:\n iris_response[\"DATE_OBS\"] = None\n # Convert C_F_TIME to array of datetime objects while\n # conserving shape.\n c_f_time = np.empty(iris_response[\"C_F_TIME\"].shape, dtype=object)\n for i, row in enumerate(iris_response[\"C_F_TIME\"]):\n for j, t in enumerate(row):\n c_f_time[i][j] = parse_time(float(t))\n iris_response[\"C_F_TIME\"] = c_f_time\n # Convert C_F_LAMBDA to Quantity.\n iris_response[\"C_F_LAMBDA\"] = Quantity(iris_response[\"C_F_LAMBDA\"], unit=\"nm\")\n # Convert C_N_TIME to array of datetime objects while\n # conserving shape.\n c_n_time = np.empty(iris_response[\"C_N_TIME\"].shape, dtype=object)\n for i, row in enumerate(iris_response[\"C_N_TIME\"]):\n for j, t in enumerate(row):\n c_n_time[i][j] = parse_time(float(t))\n iris_response[\"C_N_TIME\"] = c_n_time\n # Convert C_N_LAMBDA to Quantity.\n iris_response[\"C_N_LAMBDA\"] = Quantity(iris_response[\"C_N_LAMBDA\"], unit=\"nm\")\n # Convert C_S_TIME to array of datetime objects while\n # conserving shape.\n c_s_time = np.empty(iris_response[\"C_S_TIME\"].shape, dtype=object)\n for i, row in enumerate(iris_response[\"C_S_TIME\"]):\n for j, column in enumerate(row):\n for k, t in enumerate(column):\n c_s_time[i][j][k] = parse_time(float(t))\n iris_response[\"C_S_TIME\"] = c_s_time\n # Convert DATE in ELEMENTS array to array of datetime objects.\n for i, t in enumerate(iris_response[\"ELEMENTS\"][\"DATE\"]):\n iris_response[\"ELEMENTS\"][\"DATE\"][i] = parse_time(t.decode())\n # Convert VERSION_DATE to datetime object.\n iris_response[\"VERSION_DATE\"] = parse_time(iris_response[\"VERSION_DATE\"].decode())\n else:\n # Change DATE tag in data with version < 2 to VERSION_DATE to\n # be consistent with more recent versions.\n iris_response[\"VERSION_DATE\"] = datetime.datetime(int(iris_response[\"DATE\"][0:4]),\n int(iris_response[\"DATE\"][4:6]),\n int(iris_response[\"DATE\"][6:8]))\n del(iris_response[\"DATE\"])\n return iris_response\n\n\n@custom_model\ndef _gaussian1d_on_linear_bg(x, amplitude=None, mean=None, standard_deviation=None,\n constant_term=None, linear_term=None):\n return amplitude * np.exp(-((x - mean) / standard_deviation) ** 2) + constant_term + linear_term * x\n\n\ndef _calculate_orbital_wavelength_variation(data_array, date_data_created, slit_pixel_range=None,\n spline_smoothing=False, fit_individual_profiles=False,\n spacecraft_velocity=None, orbital_phase=None, roll_angle=None):\n \"\"\"Calculates orbital corrections of spectral line positions using level 2 files.\n\n For data generated from the April 2014 pipeline, thermal and spacecraft velocity components\n have both been subtracted in the level 2 files. Therefore, this routine calculates the\n residual orbital (thermal) variation. For data generated from the Oct 2013 pipeline,\n this routine calculates the total of thermal and spacecraft velocity components.\n\n Parameters\n ----------\n data_array: `xarray.DataArray`\n IRIS spectrograph data from spectral window Mg II k 2796 as generated by\n `sunpy.spectra.sources.IRISRaster.`\n date_data_created: `datetime.datetime`\n Date the data was created by IRIS pipeline. Used to determine where spacecraft\n velocity etc. needs to be accounted for.\n spacecraft_velocity: `astropy.units.quantity.Quantity`\n Velocity of spacecraft at each exposure in data_array.\n Must be set if date_data_created < 1 April 2014.\n orbital_phase: `numpy.array`\n Orbital phase of spacecraft at each exposure in data_array. Available from\n auxiliary data in IRIS spectrograph fits files.\n Must be set if date_data_created < 1 April 2014.\n roll_angle: `astropy.units.quantity.Quantity`\n Roll angle of spacecraft. Must be set if date_data_created < 1 April 2014.\n\n Returns\n -------\n orbital_wavelength_variation: `astropy.table.Table`\n Contains the following columns:\n time: `datetime.datetime` objects\n Observation times of wavelength variations.\n FUV: `astropy.quantity.Quantity`\n Wavelength variation in the FUV.\n NUV: `astropy.quantity.Quantity`\n Wavelength variation in the NUV.\n\n \"\"\"\n # Define vacuum rest wavelength of Ni I 2799 line.\n wavelength_nii = 2799.474 * u.Angstrom\n # Define factor converting NUV spectral pixel size to Angstrom\n specsize = 0.0255\n # Define date of new pipeline.\n date_new_pipeline = datetime.datetime(2014, 4, 1)\n if date_data_created < date_new_pipeline:\n # Check that there are measurement times with good values of\n # spacecraft velocity and orbital phase.\n bad_aux = np.asarray(np.isfinite(spacecraft_velocity) * np.isfinite(orbital_phase) * (-1), dtype=bool)\n # Generate wavelength vector containing only Ni I line.\n wavelength_window = Quantity(data_array.coords[\"wavelength\"].values,\n unit=data_array.attrs[\"units\"][\"wavelength\"])\n wavelength_roi_index = np.arange(len(wavelength_window))[\n np.logical_and(wavelength_window >= 2799.3 * u.Angstrom, wavelength_window <= 2799.8 * u.Angstrom)]\n # Check that there are at least 5 points in wavelength region.\n # Must have at least this many for a gaussian fit.\n if len(wavelength_roi_index) < 5:\n wavelength_roi_index = np.arange(5) + wavelength_roi_index[0]\n # Extract wavelength of region around Ni I line as array in units\n # of Angstroms.\n wavelength_roi = wavelength_window.to(u.Angstrom).value[wavelength_roi_index]\n # Keep only data within wavelength region of interest.\n data_array = data_array.isel(spectral_axis=slice(wavelength_roi_index[0], wavelength_roi_index[-1] + 1))\n # If user selected a sub-region of the slit, reduce data to just\n # that region.\n if slit_pixel_range:\n if len(slit_pixel_range) == 2:\n data_array = data_array.isel(slit_axis, slice(slit_pixel_range[0], slit_pixel_range[1]))\n else:\n raise TypeError(\"slit_pixel_range must be tuple of length 2 giving lower and \" +\n \"upper bounds of section of slit over which to average line fits.\")\n\n # Derive residual orbital variation.\n # Define array to hold averaged position of Ni I line at different\n # times.\n mean_line_wavelengths = np.empty(len(data_array.time)) * np.nan\n # Define initial guess for gaussian model.\n g_init = _gaussian1d_on_linear_bg(amplitude=-2., mean=wavelength_nii.value,\n standard_deviation=2., constant_term=50., linear_term=1.5)\n # Define fitting method.\n fit_g = fitting.LevMarLSQFitter()\n # Depending on user choice, either fit line as measured by each\n # pixel then average line position, or fit average line spectrum\n # from all slit pixels.\n if fit_individual_profiles:\n pixels_in_slit = len(raster.slit_axis)\n for k in range(len(raster.time)):\n pixel_line_wavelengths = np.empty(pixels_in_slit)*np.nan\n data_single_time = raster.isel(raster_axis=k)\n # Iterate through each pixel along slit and perform fit to\n # Ni I line.\n for j in range(2, pixels_in_slit-2):\n # Average over 5 pixels to improve signal-to-noise.\n intensity_mean_5pix = data_single_time.isel(slit_axis=slice(j-2, j+3)).mean(axis=0)\n # Fit gaussian to Ni I line.\n g = fit_g(g_init, wavelength_roi, intensity_mean_5pix)\n # Check that fit is within physically reasonable\n # limits. If so, store line center wavelength in\n # mean_line_wavelengths array. Else leave element as\n # defined, i.e. NaN.\n if np.isfinite(g.amplitude) and g.amplitude < 0. and \\\n wavelength_roi[0] < g.mean < wavelength_roi[-1]:\n pixel_line_wavelengths[j] = g.mean\n # Take average of Ni I line position from fits in each\n # pixel.\n mean_line_wavelengths[k] = np.nanmean(pixel_line_wavelengths)\n else:\n # Else average all line profiles then perform fit.\n # Iterate through each measurement time and fit a gaussian to\n # Ni I line.\n for k in range(len(raster.time)):\n # Get data averaged over slit.\n data_single_time = raster.isel(raster_axis=k)\n data_slit_averaged = data_single_time.to_masked_array().mean(axis=0).data\n # Fit Ni I line with a gaussian.\n # Perform fit.\n g = fit_g(g_init, wavelength_roi, data_slit_averaged)\n # Check that fit is within physically reasonable limits.\n # If so, store line center wavelength in\n # mean_line_wavelengths array. Else leave element as\n # defined, i.e. NaN.\n if np.isfinite(g.amplitude) and g.amplitude < 0. and \\\n wavelength_roi[0] < g.mean < wavelength_roi[-1]:\n mean_line_wavelengths[k] = g.mean\n # If data produced by old pipeline, subtract spacecraft velocity\n # from the line position.\n if date_created < date_new_pipeline:\n mean_line_wavelengths[k] = \\\n mean_line_wavelengths[k]-spacecraft_velocity[k]/3e8*wavelength_nii.to(u.Angstrom).value\n\n # Mark abnormal values. Thermal drift is of the order of 2\n # unsummed wavelength pixels peak-to-peak.\n w_abnormal = np.where(np.abs(mean_line_wavelengths-np.nanmedian(mean_line_wavelengths)) >= specsize*2)[0]\n if len(w_abnormal) > 0:\n mean_line_wavelengths[w_abnormal] = np.nan\n # Further data reduction required for files from old pipeline.\n if date_created < date_new_pipeline:\n dw_th_A = mean_line_wavelengths - np.nanmean(mean_line_wavelengths)\n # Change the unit from Angstrom into unsummed wavelength pixel.\n dw_th_p = dw_th_A/specsize\n # Adjust reference wavelength using orbital phase information.\n if not(np.isfinite(orbital_phase)).all():\n warnings.warn(\"Orbital phase values are invalid. Thermal drift may be offset by at most one pixel.\")\n dw_th = dw_th\n # For absolute wavelength calibration of NUV, the\n # following amount (unit Angstrom) has to be\n # subtracted from the wavelengths.\n abswvl_nuv = np.nanmean(mean_line_wavelengths)-wavelength_nii.to(u.Angstrom).value\n else:\n # Define empirical sine fitting at 0 roll angle shifted by\n # different phase.\n sine_params = [-0.66615146, -1.0, 53.106583-roll_angle/360.*2*np.pi]\n phase_adj=np.nanmean(sine_params[0]*np.sin(sine_params[1]*orbital_phase+sine_params[2]))\n # thermal component of the orbital variation, in the unit of unsummed wavelength pixel\n dw_th=dw_th_p+phase_adj\n # For absolute wavelength calibration of NUV the following\n # amount (unit Angstrom) has to be subtracted from the\n # wavelengths.\n abswvl_nuv = np.nanmean(mean_line_wavelengths)-wavelength_nii.to(u.Angstrom).value-phase_adj*specsize\n else:\n # Calculate relative variation of the line position.\n dw_th = mean_line_wavelengths-np.nanmean(mean_line_wavelengths)\n\n # If spline_smoothing=True, perform spline fit a smoothing to\n # eliminate the 5 minute photospheric oscillation.\n if spline_smoothing:\n # Define spacing of spline knots in seconds.\n spline_knot_spacing = 300.\n # Create array of time in seconds from first time and\n # calculate duration of fitting period.\n time_s = np.asarray(x.coords[\"time\"]-x.coords[\"time\"][0], dtype=float)/1e9\n duration = time_s[-1]-time_s[0]\n # Check whether there is enough good data for a spline fit.\n if duration < spline_knot_spacing:\n raise ValueError(\"Not enough data for spline fit.\")\n # Check whether there is enough good data for a spline fit.\n wgood = np.isfinite(mean_line_wavelengths)\n ngood = float(sum(wgood))\n wbad = not(np.isfinite(mean_line_wavelengths))\n nbad = float(sum(wbad))\n if nbad/ngood > 0.25:\n raise ValuError(\"Not enough good data for spline fit.\")\n # Smooth residual thermal variation curve to eliminate the\n # 5-min photospheric oscillation.\n # Determine number of smoothing point using 3 point\n # lagrangian derivative.\n deriv_time = np.array([(time_s[i+1]-time_s[i-1])/2. for i in range(1,len(time_s)-1)])\n deriv_time = np.insert(deriv_time, 0, (-3*time_s[0]+4*time_s[1]-time_s[2])/2)\n deriv_time = np.insert(deriv_time, -1, (3*time_s[-1]-4*time_s[-2]+time_s[-3])/2)\n n_smooth = int(spline_knot_spacing/deriv_time.mean())\n if n_smooth < len(wgood):\n dw_good = convolve(dw_th[good], Box1DKernel(n_smooth))\n else:\n dw_good = dw_th[good]\n time_good = time_s[good]\n # Fit spline.\n tck = interpolate.splrep(time_good, dw_good, s=0)\n dw_th = interpolate.splev(time_s, tck)\n\n # Derive residual orbital curves in FUV and NUV and store\n # in a table.\n times = [datetime.datetime.utcfromtimestamp(t/1e9) for t in raster.coords[\"time\"].values.tolist()]\n # Depeding on which pipeline produced the files...\n if date_created < date_new_pipeline:\n dw_orb_fuv = dw_th * (-0.013) + spacecraft_velocity.to(u.km/u.s).value / (3.e5) * 1370. * u.Angstrom\n dw_orb_nuv = dw_th * 0.0255 + spacecraft_velocity.to(u.km/u.s).value / (3.e5) * 2800. * u.Angstrom\n else:\n dw_orb_fuv = dw_th*(-1)*u.Angstrom\n dw_orb_nuv = dw_th*u.Angstrom\n\n orbital_wavelength_variation = Table([times, dw_orb_fuv, dw_orb_nuv],\n names=(\"time\", \"wavelength variation FUV\", \"wavelength variation NUV\"))\n return orbital_wavelength_variation\n\ndef get_detector_type(meta):\n \"\"\"\n Gets the IRIS detector type from a meta dictionary.\n\n In this function, FUV1 and FUV2 are just assigned as FUV.\n\n Parameters\n ----------\n meta: dict-like\n Dictionary-like object containing entry for \"detector type\"\n\n Returns\n -------\n detector_type: `str`\n Detector type.\n\n \"\"\"\n if \"FUV\" in meta[\"detector type\"]:\n detector_type = \"FUV\"\n else:\n detector_type = meta[\"detector type\"]\n return detector_type\n\ndef convert_between_DN_and_photons(old_data_arrays, old_unit, new_unit):\n \"\"\"Converts arrays from IRIS DN to photons or vice versa.\n\n In this function, an inverse time component due to exposure time\n correction is ignored during calculations but preserved in final unit.\n\n Parameters\n ----------\n old_data_arrays: iterable of `numpy.ndarray`s\n Arrays of data to be converted.\n\n old_unit: `astropy.unit.Unit`\n Unit of data arrays.\n\n new_unit: `astropy.unit.Unit`\n Unit to convert data arrays to.\n\n Returns\n -------\n new_data_arrays: `list` of `numpy.ndarray`s\n Data arrays converted to new_unit.\n\n new_unit_time_accounted: `astropy.unit.Unit`\n Unit of new data arrays with any inverse time component preserved.\n\n \"\"\"\n if old_unit == new_unit or old_unit == new_unit / u.s:\n new_data_arrays = [data for data in old_data_arrays]\n new_unit_time_accounted = old_unit\n else:\n # During calculations, the time component due to exposure\n # time correction, if it has been applied, is ignored.\n # Check here whether the time correction is present in the\n # original unit so that is carried through to new unit.\n if u.s not in (old_unit * u.s).decompose().bases:\n old_unit_without_time = old_unit * u.s\n new_unit_time_accounted = new_unit / u.s\n else:\n old_unit_without_time = old_unit\n new_unit_time_accounted = new_unit\n # Convert data and uncertainty to new unit.\n new_data_arrays = [(data * old_unit_without_time).to(new_unit).value\n for data in old_data_arrays]\n return new_data_arrays, new_unit_time_accounted\n\ndef calculate_exposure_time_correction(old_data_arrays, old_unit, exposure_time,\n force=False):\n \"\"\"\n Applies exposure time correction to data arrays.\n\n Parameters\n ----------\n old_data_arrays: iterable of `numpy.ndarray`s\n Arrays of data to be converted.\n\n old_unit: `astropy.unit.Unit`\n Unit of data arrays.\n\n exposure_time: `numpy.ndarray`\n Exposure time in seconds for each exposure in data arrays.\n\n Returns\n -------\n new_data_arrays: `list` of `numpy.ndarray`s\n Data arrays with exposure time corrected for.\n\n new_unit_time_accounted: `astropy.unit.Unit`\n Unit of new data arrays after exposure time correction.\n\n \"\"\"\n # If force is not set to True and unit already includes inverse time,\n # raise error as exposure time correction has probably already been\n # applied and should not be applied again.\n if force is not True and u.s in old_unit.decompose().bases:\n raise ValueError(APPLY_EXPOSURE_TIME_ERROR)\n else:\n # Else, either unit does not include inverse time and so\n # exposure does need to be applied, or\n # user has set force=True and wants the correction applied\n # regardless of the unit.\n new_data_arrays = [old_data/exposure_time for old_data in old_data_arrays]\n new_unit = old_unit/u.s\n return new_data_arrays, new_unit\n\ndef uncalculate_exposure_time_correction(old_data_arrays, old_unit, exposure_time,\n force=False):\n \"\"\"\n Removes exposure time correction from data arrays.\n\n Parameters\n ----------\n old_data_arrays: iterable of `numpy.ndarray`s\n Arrays of data to be converted.\n\n old_unit: `astropy.unit.Unit`\n Unit of data arrays.\n\n exposure_time: `numpy.ndarray`\n Exposure time in seconds for each exposure in data arrays.\n\n Returns\n -------\n new_data_arrays: `list` of `numpy.ndarray`s\n Data arrays with exposure time correction removed.\n\n new_unit_time_accounted: `astropy.unit.Unit`\n Unit of new data arrays after exposure time correction removed.\n\n \"\"\"\n # If force is not set to True and unit does not include inverse time,\n # raise error as exposure time correction has probably already been\n # undone and should not be undone again.\n if force is not True and u.s in (old_unit*u.s).decompose().bases:\n raise ValueError(UNDO_EXPOSURE_TIME_ERROR)\n else:\n # Else, either unit does include inverse time and so\n # exposure does need to be removed, or\n # user has set force=True and wants the correction removed\n # regardless of the unit.\n new_data_arrays = [old_data * exposure_time for old_data in old_data_arrays]\n new_unit = old_unit*u.s\n return new_data_arrays, new_unit\n\ndef convert_or_undo_photons_per_sec_to_radiance(\n data_quantities, obs_wavelength, detector_type,\n spectral_dispersion_per_pixel, solid_angle, undo=False):\n \"\"\"\n Converts data quantities from counts/s to radiance (or vice versa).\n\n Parameters\n ----------\n data_quantities: iterable of `astropy.units.Quantity`s\n Quantities to be converted. Must have units of counts/s or\n radiance equivalent counts, e.g. erg / cm**2 / s / sr / Angstrom.\n\n obs_wavelength: `astropy.units.Quantity`\n Wavelength at each element along spectral axis of data quantities.\n\n detector_type: `str`\n Detector type: 'FUV', 'NUV', or 'SJI'.\n\n spectral_dispersion_per_pixel: scalar `astropy.units.Quantity`\n spectral dispersion (wavelength width) of a pixel.\n\n solid_angle: scalar `astropy.units.Quantity`\n Solid angle corresponding to a pixel.\n\n undo: `bool`\n If False, converts counts/s to radiance.\n If True, converts radiance to counts/s.\n Default=False\n\n Returns\n -------\n new_data_quantities: `list` of `astropy.units.Quantity`s\n Data quantities converted to radiance or counts/s\n depending on value of undo kwarg.\n\n \"\"\"\n # Check data quantities are in the right units.\n if undo is True:\n for i, data in enumerate(data_quantities):\n if not data.unit.is_equivalent(RADIANCE_UNIT):\n raise ValueError(\n \"Invalid unit provided. As kwarg undo=True, \"\n \"unit must be equivalent to {0}. Error found for {1}th element \"\n \"of data_quantities. Unit: {2}\".format(RADIANCE_UNIT, i, data.unit))\n else:\n for data in data_quantities:\n if data.unit != u.photon/u.s:\n raise ValueError(\n \"Invalid unit provided. As kwarg undo=False, \"\n \"unit must be equivalent to {0}. Error found for {1}th element \"\n \"of data_quantities. Unit: {2}\".format(u.photon/u.s, i, data.unit))\n photons_per_sec_to_radiance_factor = calculate_photons_per_sec_to_radiance_factor(\n obs_wavelength, detector_type, spectral_dispersion_per_pixel, solid_angle)\n # Change shape of arrays so they are compatible for broadcasting\n # with data and uncertainty arrays.\n photons_per_sec_to_radiance_factor = \\\n _reshape_1D_wavelength_dimensions_for_broadcast(photons_per_sec_to_radiance_factor,\n data_quantities[0].ndim)\n # Perform (or undo) radiometric conversion.\n if undo is True:\n new_data_quantities = [(data / photons_per_sec_to_radiance_factor).to(u.photon/u.s)\n for data in data_quantities]\n else:\n new_data_quantities = [(data*photons_per_sec_to_radiance_factor).to(RADIANCE_UNIT)\n for data in data_quantities]\n return new_data_quantities\n\ndef calculate_photons_per_sec_to_radiance_factor(\n wavelength, detector_type, spectral_dispersion_per_pixel, solid_angle):\n \"\"\"\n Calculates multiplicative factor that converts counts/s to radiance for given wavelengths.\n\n Parameters\n ----------\n wavelength: `astropy.units.Quantity`\n Wavelengths for which counts/s-to-radiance factor is to be calculated\n\n detector_type: `str`\n Detector type: 'FUV' or 'NUV'.\n\n spectral_dispersion_per_pixel: scalar `astropy.units.Quantity`\n spectral dispersion (wavelength width) of a pixel.\n\n solid_angle: scalar `astropy.units.Quantity`\n Solid angle corresponding to a pixel.\n\n Returns\n -------\n radiance_factor: `astropy.units.Quantity`\n Mutliplicative conversion factor from counts/s to radiance units\n for input wavelengths.\n\n \"\"\"\n # Get effective area and interpolate to observed wavelength grid.\n eff_area_interp = _get_interpolated_effective_area(detector_type, wavelength)\n # Return radiometric conversed data assuming input data is in units of photons/s.\n return constants.h * constants.c / wavelength / u.photon / \\\n spectral_dispersion_per_pixel / eff_area_interp / solid_angle\n\ndef _get_interpolated_effective_area(detector_type, obs_wavelength):\n # Get effective area\n ########### This needs to be generalized to the time of OBS once that functionality is written #########\n iris_response = get_iris_response(pre_launch=True)\n if detector_type == \"FUV\":\n detector_type_index = 0\n elif detector_type == \"NUV\":\n detector_type_index = 1\n else:\n raise ValueError(\"Detector type not recognized.\")\n eff_area = iris_response[\"AREA_SG\"][detector_type_index, :]\n response_wavelength = iris_response[\"LAMBDA\"]\n # Interpolate the effective areas to cover the wavelengths\n # at which the data is recorded:\n eff_area_interp_base_unit = u.Angstrom\n tck = interpolate.splrep(response_wavelength.to(eff_area_interp_base_unit).value,\n eff_area.to(eff_area_interp_base_unit ** 2).value, s=0)\n eff_area_interp = interpolate.splev(\n obs_wavelength.to(eff_area_interp_base_unit).value, tck) * eff_area_interp_base_unit ** 2\n return eff_area_interp\n\ndef _reshape_1D_wavelength_dimensions_for_broadcast(wavelength, n_data_dim):\n if n_data_dim == 1:\n pass\n elif n_data_dim == 2:\n wavelength = wavelength[np.newaxis, :]\n elif n_data_dim == 3:\n wavelength = wavelength[np.newaxis, np.newaxis, :]\n else:\n raise ValueError(\"IRISSpectrogram dimensions must be 2 or 3.\")\n return wavelength\n\ndef _convert_iris_sequence(sequence, new_unit):\n \"\"\"Converts data and uncertainty in an IRISSpectrogramSequence between units.\n\n Parameters\n ----------\n sequence: `NDCubeSequence`, `SpectrogramSequence` or `IRISSpectrogramSequence`\n Sequence whose constituent NDCubes are be converted to new units.\n\n new_unit: `astropy.units.Unit` or `str`\n Unit to which the data is to be converted.\n\n Returns\n -------\n converted_data_list: `list` of `NDCube`s.\n List of NDCubes with data and uncertainty attributes converted to new_unit.\n\n \"\"\"\n # Define empty list to hold NDCubes with converted data and uncertainty.\n converted_data_list = []\n # Cycle through each NDCube, convert data and uncertainty to new\n # units, and append to list.\n for i, cube in enumerate(sequence.data):\n # Determine what type of DN unit is needed based on detector type.\n detector_type = _get_detector_type(cube.meta)\n if new_unit == \"DN\":\n new_unit = DN_UNIT[detector_type]\n # If NDCube is already in new unit, add NDCube as is to list.\n if cube.unit is new_unit or cube.unit is new_unit / u.s:\n converted_data_list.append(cube)\n # Else convert data and uncertainty to new unit.\n if cube.unit != new_unit or cube.unit != new_unit / u.s:\n # During calculations, the time component due to exposure\n # time correction, if it has been applied, is ignored.\n # Check here whether the time correction is present in the\n # original unit so that is carried through to new unit.\n if u.s not in (cube.unit.decompose() * u.s).bases:\n new_unit_time_accounted = new_unit / u.s\n else:\n new_unit_time_accounted = new_unit\n # Convert data and uncertainty to new unit.\n data = (cube.data * cube.unit).to(new_unit).value\n uncertainty = (cube.uncertainty.array * cube.unit).to(new_unit).value\n # Append new instance of NDCube in new unit to list.\n converted_data_list.append(NDCube(\n data, wcs=cube.wcs, meta=cube.meta, mask=cube.mask,\n unit=new_unit_time_accounted, uncertainty=uncertainty,\n extra_coords=_extra_coords_to_input_format(cube._extra_coords)))\n return converted_data_list\n\ndef _apply_or_undo_exposure_time_correction(sequence, correction_function):\n \"\"\"Applies or undoes exposure time correction to a sequence of NDCubes.\n\n Correction is applied (or undone) to both data and uncertainty attributes of NDCubes.\n\n Parameters\n ----------\n sequence: `NDCubeSequence`, `SpectrogramSequence` or `IRISSpectrogramSequence`\n Sequence whose constituent NDCubes are be converted to new units.\n NDCubes with sequence must have an 'exposure time' entry in its extra\n coords attribute.\n\n correction_function: function\n Function applying or undoing exposure time correction.\n\n Returns\n -------\n converted_data_list: `list` of `NDCube`s.\n List of NDCubes with data and uncertainty corrected (or uncorrected)\n for exposure time.\n\n \"\"\"\n converted_data_list = []\n for i, cube in enumerate(sequence.data):\n if u.s not in cube.unit.decompose().bases:\n exposure_time_s = cube._extra_coords[\"exposure time\"][\"value\"].to(u.s).value\n if len(cube.dimensions.shape) == 1:\n pass\n elif len(cube.dimensions.shape) == 2:\n exposure_time_s = exposure_time_s[:, np.newaxis]\n elif len(cube.dimensions.shape) == 3:\n exposure_time_s = exposure_time_s[:, np.newaxis, np.newaxis]\n else:\n raise ValueError(\"NDCube dimensions must be 2 or 3. Dimensions={0}\".format(\n len(cube.dimensions.shape)))\n data = correction_function(cube.data, exposure_time_s)\n uncertainty = correction_function(cube.uncertainty.array, exposure_time_s)\n converted_data_list.append(NDCube(\n data, wcs=cube.wcs, meta=cube.meta, mask=cube.mask, unit=cube.unit / u.s,\n uncertainty=uncertainty,\n extra_coords=_extra_coords_to_input_format(cube._extra_coords)))\n else:\n converted_data_list.append(cube)\n return converted_data_list\n\ndef calculate_dust_mask(data_array):\n \"\"\"Calculate a mask with the dust positions in a given arrayself.\n\n Parameters\n ----------\n data_array : `numpy.ndarray`\n This array contains some dust poisition that will be calculated. The array\n must have scaled values.\n\n Returns\n -------\n dust : `numpy.ndarray` of `bool`\n This array has the same shape than data_array and contains the dust positions\n when the value is True.\n\n \"\"\"\n # Creating a mask with the same shape than the inputed data array.\n mask = np.zeros_like(data_array, dtype=bool)\n # Set the pixel value to True is the pixel is recognized as a dust pixel.\n mask[(data_array < 0.5) & (data_array > -200)] = True\n # Extending the mask to avoid the neighbours pixel influenced by the dust pixels.\n struct = np.array([np.zeros((3, 3)), np.ones((3, 3)), np.zeros((3, 3))], dtype=bool)\n mask = ndimage.binary_dilation(mask, structure=struct).astype(mask.dtype)\n return mask\n", "meta": {"hexsha": "14c181ea4b1d5a7b1f58c2576725bd50d0e8babf", "size": 37900, "ext": "py", "lang": "Python", "max_stars_repo_path": "irispy/iris_tools.py", "max_stars_repo_name": "DanRyanIrish/slitspectrographpy", "max_stars_repo_head_hexsha": "63d0c35c562551079608a5e89b72f9607711f43a", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-04-03T13:29:58.000Z", "max_stars_repo_stars_event_max_datetime": "2020-04-03T13:29:58.000Z", "max_issues_repo_path": "irispy/iris_tools.py", "max_issues_repo_name": "DanRyanIrish/slitspectrographpy", "max_issues_repo_head_hexsha": "63d0c35c562551079608a5e89b72f9607711f43a", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2020-04-04T06:28:32.000Z", "max_issues_repo_issues_event_max_datetime": "2020-04-11T15:34:42.000Z", "max_forks_repo_path": "irispy/iris_tools.py", "max_forks_repo_name": "DanRyanIrish/sunraster", "max_forks_repo_head_hexsha": "63d0c35c562551079608a5e89b72f9607711f43a", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-03-09T18:39:57.000Z", "max_forks_repo_forks_event_max_datetime": "2020-03-09T18:39:57.000Z", "avg_line_length": 45.6077015644, "max_line_length": 113, "alphanum_fraction": 0.6578100264, "include": true, "reason": "import numpy,import scipy,from scipy,import astropy,from astropy", "num_tokens": 8714, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5660185351961015, "lm_q2_score": 0.33807711748081287, "lm_q1q2_score": 0.19135791481981002}} {"text": "\n\nfrom __future__ import division, print_function, absolute_import\n\nfrom tmm.tmm_core import (coh_tmm, unpolarized_RT, ellips,\n position_resolved, find_in_structure_with_inf)\n\n\nimport tmm.tmm_core as tmm\n\nimport numpy\nfrom numpy import pi, linspace, inf, array\nimport pandas\nfrom scipy.interpolate import interp1d\nimport matplotlib.pyplot as plt\n\ntry:\n import colorpy.illuminants\n import colorpy.colormodels\n from . import color\n colors_were_imported = True\nexcept ImportError:\n # without colorpy, you can't run sample5(), but everything else is fine.\n colors_were_imported = False\n\n\nfrom matplotlib.pyplot import show\nfrom argparse import ArgumentParser\nimport lowtran\nfrom lowtran.lowtran.plots import plottrans\n\nimport xarray\n\n\n#def main():\np = ArgumentParser(description='Lowtran 7 interface')\np.add_argument('-z', '--obsalt', help='altitude of observer [km]', type=float, default=0.)\np.add_argument('-a', '--zenang', help='observer zenith angle [deg]', type=float, nargs='+', default=[0, 45, 60, 80])\np.add_argument('-s', '--short', help='shortest wavelength nm ', type=float, default=200)\np.add_argument('-l', '--long', help='longest wavelength cm^-1 ', type=float, default=30000)\np.add_argument('-step', help='wavelength step size cm^-1', type=float, default=20)\np.add_argument('--model', help='0-6, see Card1 \"model\" reference. 6 = 1976 US Standard', type=int, default=6)\nP = p.parse_args()\n\nc1 = {'model': P.model,\n 'h1': P.obsalt,\n 'angle': P.zenang,\n 'wlshort': P.short,\n 'wllong': P.long,\n 'wlstep': P.step,\n }\n\ntr = lowtran.transmittance(c1)\nwl = tr.wavelength_nm.data # This gives the wavelength range\n#a_transmission_data = tr.transmission.data.squeeze() # Transmission data as a funciton of angle. \n\n#a = tr.transmission # make a DataArray from a DataSet from Xarray package\n#a2 = a.values # make \n#a3 = a.to_dataset\n#a4 = a.to_dataframe\n#a5 = a.to_series\n#a6 = a.to_pandas\n# to convert to pandas series to tr.transmission.to_series()\n\n\nplottrans(tr, c1)\n#\nshow()\n\n\n\n\n\"\"\"\nHere's a thin non-absorbing layer, on top of a thick absorbing layer, with\nair on both sides. Plotting reflected intensity versus wavenumber, at two\ndifferent incident angles.\n\"\"\"\ndegree = pi/180\n\n# list of layer thicknesses in nm\nd_list = [inf, 100, 300, inf]\n# list of refractive indices\nn_list = [1, 2.2, 3.3+0.3j, 1]\n# list of wavenumbers to plot in nm^-1\nks = linspace(0.0001, .01, num=400)\n# initialize lists of y-values to plot\nrnorm = []\nr45 = []\nfor k in ks:\n\t\t# For normal incidence, s and p polarizations are identical.\n\t\t# I arbitrarily decided to use 's'.\n rnorm.append(tmm.coh_tmm('s', n_list, d_list, 0, 1/k)['R'])\n r45.append(tmm.unpolarized_RT(n_list, d_list, 45*degree, 1/k)['R'])\nkcm = ks * 1e7 #ks in cm^-1 rather than nm^-1\nplt.figure()\nplt.plot(kcm, rnorm, 'blue', kcm, r45, 'purple')\nplt.xlabel('k (cm$^{-1}$)')\nplt.ylabel('Fraction reflected')\nplt.title('Reflection of unpolarized light at 0$^\\circ$ incidence (blue), '\n '45$^\\circ$ (purple)')\nplt.show() \n\n \n\n#if __name__ == '__main__':\n# main()\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n", "meta": {"hexsha": "d27187a6b4a0bb38428daaf9a52103b6d18b20a6", "size": 3123, "ext": "py", "lang": "Python", "max_stars_repo_path": "test_lowtran_tmm_integration.py", "max_stars_repo_name": "parkerwray/tmm", "max_stars_repo_head_hexsha": "8c27a56163d33de5955611eee35864c4485d1b2b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "test_lowtran_tmm_integration.py", "max_issues_repo_name": "parkerwray/tmm", "max_issues_repo_head_hexsha": "8c27a56163d33de5955611eee35864c4485d1b2b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "test_lowtran_tmm_integration.py", "max_forks_repo_name": "parkerwray/tmm", "max_forks_repo_head_hexsha": "8c27a56163d33de5955611eee35864c4485d1b2b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 24.0230769231, "max_line_length": 116, "alphanum_fraction": 0.6913224464, "include": true, "reason": "import numpy,from numpy,from scipy", "num_tokens": 902, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5660185205547239, "lm_q2_score": 0.33807711748081287, "lm_q1q2_score": 0.1913579098698953}} {"text": "#!/usr/bin/python\n# -*- coding: latin-1 -*-\n\"\"\"\nMaterials define the surface properties and specify how light rays get coloured and reflected. All materials are callables - they implement the __call__ method\nand can be used like functions.\n\n.. moduleauthor:: Adrian Köring\n\"\"\"\n\nimport numpy as np\n\nfrom padvinder.util import normalize\nfrom padvinder.util import check_finite\n\nclass Material(object):\n \"\"\"\n An emission material consists of an emitted colour only.\n Without gradients, lighting or anything.\n\n Parameters\n ----------\n color : numpy.ndarray_like\n of three dimensions and contains colors as (Red, Green, Blue) where\n (0,0,0) is black and (1,1,1) is white\n\n Raises\n ------\n ValueError\n if the color contains any non-finite (inf, nan) values\n\n Examples\n --------\n >>> Material((0.8, 0.8, 0.8))\n Material(color=[.8 .8 .8])\n \"\"\"\n def __init__(self, color = (.5, .5, .5)):\n check_finite(color)\n self._color = np.array(color).astype(np.float64)\n\n @property\n def color(self):\n \"\"\"\n Returns the color of the material.\n \"\"\"\n return self._color\n\n def __call__(self, surface_normal,\n incoming_color,\n incoming_direction,\n outgoing_direction):\n \"\"\"\n Calculate light reflected from the material toward the outgoing\n direction. Keep in mind, while pathtracing starts at the camera and\n heads into the scene, the rays contribution is accumulated 'backwards'.\n Therefore the incoming direction is further down the path and\n outgoing_direction is closer towards the camera.\n\n Parameters\n ----------\n surface_normal : numpy.ndarray_like\n normal vector at the geometries surface\n incoming_color : numpy.ndarray_like\n the color the ray has accumulated up to this point\n incoming_direction : numpy.ndarray_like\n the direction from where the 'light shines' onto the surface\n outgoing_direction : numpy.ndarray_like\n the direction into which the 'light gets reflected' from the surface\n\n Returns\n -------\n color : numpy.ndarray_like\n the light color 'getting reflected' from the surface\n \"\"\"\n return self._color\n\n def outgoing_direction(self, normal, incoming_direction):\n \"\"\"\n Given a surface normal and an incoming direction, determine the\n direction in which the path continues.\n\n normal : numpy.ndarray_like of shape (3, )\n the surface normal at the intersection point\n\n incoming_direction : numpy.ndarray_like of shape (3, )\n the direction from which light hits the surface\n\n Returns\n -------\n outgoing direction : numpy.ndarray_like of shape (3, 0)\n the direction in which light is reflected from the surface\n \"\"\"\n # BaseClass randomly (not uniformly) samples the hemisphere\n point_on_sphere = normalize(np.random.uniform(0, 1, size=(3, )))\n # ensure it is in the same hemisphere as the normal\n if np.dot(normal, point_on_sphere) < 0:\n point_on_sphere = -point_on_sphere\n return normalize(normal + point_on_sphere)\n\n\n def __repr__(self):\n return \"Material(color={})\".format(self._color)\n\n\nclass Emission(Material):\n \"\"\"\n Emission is equivalent to the abstract base class Material. Due to semantics\n this class exists and merely inherits without modifications.\n\n Parameters\n ----------\n color : numpy.ndarray_like\n of three dimensions and contains colors as (Red, Green, Blue) where\n (0,0,0) is black and (1,1,1) is white\n\n Raises\n ------\n ValueError\n if the color contains any non-finite (inf, nan) values\n\n Examples\n --------\n >>> Emission()\n Emission(color=[10.0, 10.0, 10.0])\n \"\"\"\n def __init__(self, color = (10, 10, 10)):\n super().__init__(color)\n\n def __repr__(self):\n return \"Emission(color={})\".format(self._color)\n\n\nclass Lambert(Material):\n def __init__(self, color = (0.5, 0.5, 0.5), diffuse = 1):\n \"\"\"\n A lambert material consists of a colour value and a diffuse coefficient.\n\n Parameters\n ----------\n color : numpy.ndarray_like\n of three dimensions and contains colors as (Red, Green, Blue) where\n (0,0,0) is black and (1,1,1) is white\n diffuse : number in [0, 1]\n percentage of incoming light that is reflected again\n\n Raises\n ------\n ValueError\n if the color contains any non-finite (inf, nan) values\n\n Examples\n --------\n >>> Lambert((0.8, 0.8, 0.8), 1)\n Lambert(color=[0.8, 0.8, 0.8], diffuse=1)\n \"\"\"\n super().__init__(color)\n self._diffuse = diffuse\n\n @property\n def diffuse(self):\n \"\"\"\n Returns the diffuse value of the material.\n \"\"\"\n return self._diffuse\n\n # def __call__(self, surface_normal,\n # incoming_light,\n # incoming_direction,\n # outgoing_direction):\n # \"\"\"\n # Calculate light reflected from the material toward the outgoing\n # direction. Keep in mind, while pathtracing starts at the camera and\n # heads into the scene, the rays contribution is accumulated 'backwards'.\n # Therefore the incoming direction is further down the path and\n # outgoing_direction is closer towards the camera.\n #\n # Parameters\n # ----------\n # surface_normal : numpy.ndarray_like\n # normal vector at the geometries surface\n # incoming_color : numpy.ndarray_like\n # the color the ray has accumulated up to this point\n # incoming_direction : numpy.ndarray_like\n # the direction from where the 'light shines' onto the surface\n # outgoing_direction : numpy.ndarray_like\n # the direction into which the 'light gets reflected' from the surface\n #\n # Returns\n # -------\n # color : numpy.ndarray_like\n # the light color 'getting reflected' from the surface\n # \"\"\"\n # raise NotImplemented()\n\n def __repr__(self):\n c, d = self._color, self._diffuse\n return \"Lambert(color={0}, diffuse={1})\".format(c, d)\n", "meta": {"hexsha": "a460999e30fb82bd5259d9bf97915e5ded54b443", "size": 6450, "ext": "py", "lang": "Python", "max_stars_repo_path": "padvinder/material.py", "max_stars_repo_name": "adriankoering/padvinder", "max_stars_repo_head_hexsha": "eaebd80867f22c8ca8cc3b97bf0b726f408d928a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "padvinder/material.py", "max_issues_repo_name": "adriankoering/padvinder", "max_issues_repo_head_hexsha": "eaebd80867f22c8ca8cc3b97bf0b726f408d928a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "padvinder/material.py", "max_forks_repo_name": "adriankoering/padvinder", "max_forks_repo_head_hexsha": "eaebd80867f22c8ca8cc3b97bf0b726f408d928a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.7411167513, "max_line_length": 159, "alphanum_fraction": 0.6069767442, "include": true, "reason": "import numpy", "num_tokens": 1429, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5544704649604273, "lm_q2_score": 0.34510527769342453, "lm_q1q2_score": 0.1913506837829705}} {"text": "#!/bin/python\n#\n# Create a plot of free energy vs temperature for a polymorph\n# \n# Copyright Michael R. Shirts, University of Virginia, 2014\n#\nfrom __future__ import print_function\nimport numpy as np\nimport pymbar # multistate Bennett acceptance ratio\nfrom pymbar import timeseries # timeseries analysis\nfrom optparse import OptionParser # for parsing command-line options\nimport mdtraj as md\nimport MBARBootstrap # Bootstrapping algorithm\nimport random\nimport os\nimport usefulFuncs #Useful math functions\nimport Harvist #Hamiltonian Reweighting Visualization Toolkik\nimport pdb\nimport sys\nimport panedr\nimport matplotlib\nimport subprocess \nimport matplotlib.pyplot as plt\n\nfont = {'family': 'normal',\n 'weight': 'normal',\n 'size': 16}\n\n\n\ndef old_systems_dictionary(potential, molecule):\n Polys = dict() # Name of the polymorphs\n refTs = dict() # Reference temperatures for the PSCP for each system\n refdGs = dict() # Reference free energies for the PSCP for each system\n refddGs = dict() # Reference uncertainties for the PSCP for each system\n refdUs = dict() # Reference lattice minima for each system\n absolutedUs = dict() # Absolute lattice energy for each system\n \n \n # Oplsaa\n if potential == \"oplsaa\":\n Potentials = ['oplsaa']\n PotNAME = 'OPLS'\n Charges = ['0.1150', '0.1150', '0.0700', '0.0850', '0.1000', '0.1150', '0.1300', '0.1450', '0.1600', '0.1750',\n '0.1900', '0.1000', '0.0900', '0.0800', '0.0700', '0.0600', '0.0500', '0.0400', '0.0300', '0.0200',\n '0.0100']\n Chargenames = ['', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',\n '', '', '', '', '', '', '', '']\n #Chargenames=['C01150', 'C01150', 'C00700', 'C00850', 'C01000', 'C01150', 'C01300', 'C01450', 'C01600', 'C01750', 'C01900', 'C00900', 'C00800', 'C00700', 'C00600', 'C00500', 'C00400', 'C00300', 'C00200', 'C00100']\n PotNAMES=['OPLS']\n SimNAMES=['GRO']\n Temperatures = np.array([50, 100, 200, 300])\n \n #Temperatures=np.array([45,50]) #Overlap Check\n #Temperatures=np.array([10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,70,80,90,100,110,120,130,140])#,80,90,100,110])#Zzzvye\n #Temperatures=np.array([10,15,20,25,30,35,40,45,50,60,70,80,90,100,110])#Zzzvye\n #Temperatures = np.array([10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,70,80,90,100,110,120,130,140,150,160,170,180,190,200,210,220,230,240,250,260,270,280,290,300])#,320,340])#,360,380,400,420,440,460,480,500])#,320,340,360,380,400]) #benzene\n #Temperatures=np.array([10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,80,90,100,110,120,130,140,150,160,170,180,190,200,210,220,230,240,250,260,270,280,290,300])#,320,340])#,360,380,400,420,440,460,480,500])#,320,340,360,380,400]) #kobfud\n #Temperatures=np.array([10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,90,100,110,120,130,140,150,160,170,180,190,200,210,220,230,240,250,260,270,280,290,300])#,320,340,360,380,400,420,440,460,480,500])#,320,340,360,380,400]) #cbmzpn\n #Temperatures=np.array([10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,110,120,130,140,150,160,170,180,190,200,210,220,230,240,250,260,270,280,290,300])#,320,340])#,360,380,400,420,440,460,480,500])#,320,340,360,380,400]) #melfit\n #Temperatures=np.array([10,20,30,40,50,60,70,80,90,100,110,120,130,140,150,160,170,180,190,200,210,220,230,240,250,260,270,280,290,300])#,320,340,360,380,400,420,440,460,480,500])\n #Temperatures=np.array([100,130,140,160,180,200,220,240,260,280,300,340,360,380,400])\n #Temperatures=np.array([100,120,140,160,180,200]) #MelfitTest\n #ExtraPressures=np.array([5000,15000,35000]) #benzene\n #Temperatures=np.array([40,50,60,70,80,90,100,110,120,130,140,150,160,170,180,190,200,210,220,230,240,250,260,270,280,290,300]) #imazol\n #ExtraPressures=np.array([5000,10000,16000,20000,26000,31000,36000,40000]) #imazol\n #Temperatures=np.array([20,30,40,50,60,70,80,90,100,110,120,130,140,150,160,170,180,190,200,210,220,230,240,250,220,240,260,280,300,300,300,300,300,300,300,300]) #acetac\n #ExtraPressures=np.array([5000,5000,5000,5000,5000,10000,16000,20000,26000,31000,36000,40000]) #acetac\n #Temperatures=np.array([20,30,40,50,60,70,80,90,100,110,120,130,140,150,160,170,180,190,200,210,220,230,240,250,200,200,200,200,220,240,260,280,300,300,300,300,300,300,300,300]) #formam\n #ExtraPressures=np.array([1500,2000,5000,10000,10000,10000,10000,10000,5000,10000,15000,20000,26000,31000,36000,40000]) #formam\n #Temperatures=np.array([20,30,40,50,60,70,80,90,100,110,120,130,140,150,160,170,180,190,200,220,240,250,270,290,300,320,340,360,380,400,420,440,460,480,500]) #glycin\n ExtraPressures = []\n Pressures = np.ones(len(Temperatures), int)\n Pressures[len(Pressures) - len(ExtraPressures): len(Pressures)] = ExtraPressures\n #Temperatures=np.array([200,200,200,200,200])\n #Pressures=np.array([1,500,1000,1500,2000,2500,3000,3500,4000,4500,5000])\n refPot = 0\n \n #Benzene\n Polys['benzene']=['p1', 'p2', 'p3']\n refTs['benzene']=200\n refdGs['benzene']=[0.000, 0.185, 0.306]\n refddGs['benzene']=[0.000, 0.019, 0.019]\n refdUs['benzene'] = [0.000, 0.267, 0.240]\n absolutedUs['benzene'] = [-5.624, -5.362, -5.380]\n \n #Formam\n Polys['formam']=['p1', 'p2']\n refTs['formam']=200\n refdGs['formam']=[0.000, 0.118]\n refddGs['formam']=[0.005, 0.005]\n refdUs['formam'] = [0.000, 0.343]\n absolutedUs['formam'] = [-41.04733, -40.7076] \n \n #Acetac\n Polys['acetac']=['p1', 'p2']\n refTs['acetac']=200\n refdGs['acetac']=[0.000, 0.001]\n refddGs['acetac']=[0.005, 0.005]\n refdUs['acetac'] = [0.000, 0.020]\n absolutedUs['acetac'] = [-36.4858, -36.466]\n \n \n #Imazol\n Polys['imazol']=['p1', 'p2']\n refTs['imazol']=100\n refdGs['imazol']=[0.000, -0.436]\n refddGs['imazol']=[0.005, 0.005]\n refdUs['imazol'] = [0.000, -0.464]\n absolutedUs['imazol'] = [-15.399, -15.863]\n \n #Glycin\n Polys['glycin']=['p1', 'p2', 'p4']#, 'p3']\n refTs['glycin']=200\n refdGs['glycin']=[0.000, -0.034, -0.067]#, 1.087]\n refddGs['glycin']=[0.005, 0.005, 0.005]#, 0.005]\n refdUs['glycin'] = [0.000, 0.117, 0.288]#, 1.235]\n absolutedUs['glycin'] = [-131.950, -131.778, -131.609]#, -130.715]\n \n #Bismev\n Polys['bismev']=['p3', 'p1', 'p2']\n refTs['bismev']=200\n refdGs['bismev']=[0.000, -1.474, -0.186]\n refddGs['bismev']=[0.005, 0.005, 0.005]#, 0.005]\n refdUs['bismev'] = [0.000, -1.459, -0.245]#, 1.235]\n absolutedUs['bismev'] = [-64.3467, -65.8055, -64.5916]#, -130.715]\n \n #Cbmzpn\n Polys['cbmzpn']=['p3', 'p1']\n refTs['cbmzpn']=200\n refdGs['cbmzpn']=[0.000, 0.195]\n refddGs['cbmzpn']=[0.0, 0.005]\n refdUs['cbmzpn'] = [0.000, 0.565]\n absolutedUs['cbmzpn'] = [-34.3933, -33.8283]\n \n #Hxacan\n Polys['hxacan']=['p2', 'p1']\n refTs['hxacan']=200\n refdGs['hxacan']=[0.000, -0.619]\n refddGs['hxacan']=[0.005, 0.005]\n refdUs['hxacan'] = [0.000, -0.446]\n absolutedUs['hxacan'] = [-46.965, -47.411]\n \n #Kobfud\n Polys['kobfud']=['p1', 'p2']\n refTs['kobfud']=200\n refdGs['kobfud']=[0.000, 1.832]\n refddGs['kobfud']=[0.005, 0.005]\n refdUs['kobfud'] = [0.000, 2.255]\n absolutedUs['kobfud'] = [-49.974, -47.719]\n \n ##Pyrzin\n #Polys['pyrzin']=['p2']#, 'p3', 'p1', 'p5', 'p2']\n #refTs['pyrzin']=200\n #refdGs['pyrzin']=[0.000] #, -0.483, -0.689, -1.055, -1.056]\n #refddGs['pyrzin']=[0.005] #, 0.005, 0.005, 0.005, 0.005]\n #refdUs['pyrzin'] = [0.000] #, -0.176, -0.695, -1.246, 0.951]\n #absolutedUs['pyrzin'] = [-13.348] #, -14.475, -14.993, -15.545, -13.348]\n \n \n #Pyrzin\n Polys['pyrzin']=['p4', 'p3', 'p1', 'p5', 'p2']\n refTs['pyrzin']=200\n refdGs['pyrzin']=[0.000, -0.483, -0.689, -1.055, -1.056]\n refddGs['pyrzin']=[0.005, 0.005, 0.005, 0.005, 0.005]\n refdUs['pyrzin'] = [0.000, -0.176, -0.695, -1.246, 0.951]\n absolutedUs['pyrzin'] = [-14.299, -14.475, -14.993, -15.545, -13.348]\n \n #Qopbed\n Polys['qopbed']=['p1', 'p3']#, 'p2']\n refTs['qopbed']=200\n refdGs['qopbed']=[0.000, 0.878] #1.699]\n refddGs['qopbed']=[0.005, 0.005]\n refdUs['qopbed'] = [0.000, 1.235]# 2.778]\n absolutedUs['qopbed'] = [-41.135, -39.900] # -38.357]\n \n #Zzzvye\n Polys['zzzvye']=['p3', 'p1']\n refTs['zzzvye']=50\n refdGs['zzzvye']=[0.000, 0.190]\n refddGs['zzzvye']=[0.005, 0.005]\n refdUs['zzzvye'] = [0.000, 0.351]\n absolutedUs['zzzvye'] = [11.103, 11.454]\n \n #Resora\n Polys['resora']=['p1', 'p2']\n refTs['resora']=200\n refdGs['resora']=[0.000, -0.337]\n refddGs['resora']=[0.005, 0.005]\n refdUs['resora'] = [0.000, -0.278]\n absolutedUs['resora'] = [-22.506, -22.784]\n \n #Zzzpro\n Polys['zzzpro']=['p1', 'p3']#, 'p2']\n refTs['zzzpro']=200\n refdGs['zzzpro']=[0.000, 0.223]#, 0.409]\n refddGs['zzzpro']=[0.01, 0.01]#, 0.01]\n refdUs['zzzpro'] = [0.000, 0.258]#, 0.480]\n absolutedUs['zzzpro'] = [-19.393, -19.135]#, -18.913]\n \n #Zzzpus\n Polys['zzzpus']=['p6', 'p2'] #, 'p1']#, 'p3', 'p7']\n refTs['zzzpus']=200\n refdGs['zzzpus']=[0.000, -1.713] #, -1.713]#, -1.713, -1.713]\n refddGs['zzzpus']=[0.00, 0.028] #, 0.02]#, 0.02, 0.02]\n refdUs['zzzpus'] = [0.000, -2.226] #, 1.4102]#, -2.249, -3.067]\n absolutedUs['zzzpus'] = [-84.917, -87.143] #, -83.507]#, -87.166, -87.985]\n \n ##Melfit\n #Polys['melfit']=['p7', 'p6']#, 'p8']\n #refTs['melfit']=200\n #refdGs['melfit']=[0.000, 0.52]#, 0.52]\n #refddGs['melfit']=[0.00, 0.015]#, 0.02]\n #refdUs['melfit'] = [0.000, 0.596]#, 1.187]\n #absolutedUs['melfit'] = [-12.456, -11.818]#, -11.268]\n \n #Melfit\n Polys['melfit']=['p7', 'p6', 'p8', 'p1', 'p5']\n refTs['melfit']=200\n refdGs['melfit']=[0.000, 0.52, 0.52, 0.52, 0.52]\n refddGs['melfit']=[0.02, 0.02, 0.02, 0.02, 0.02]\n refdUs['melfit'] = [0.000, 0.637, 1.187, 1.966, 0.927]\n absolutedUs['melfit'] = [-12.456, -11.818, -11.268, -10.489, -11.529]\n \n \n \n ##Melfit\n #Polys['melfit']=['p7', 'p6', 'p1', 'p5']#, 'p2', 'p3']#, 'p4']\n #refTs['melfit']=200\n #refdGs['melfit']=[0.000, 0.279, 1.581, 0.542]#, -0.962, 1.361]#, -0.679]\n #refddGs['melfit']=[0.02, 0.02, 0.02, 0.02]#, 0.02, 0.02]#, 0.02]\n #refdUs['melfit'] = [0.000, 0.279, 1.581, 0.542]#, -0.962, 1.361]#, -0.679]\n #absolutedUs['melfit'] = [-12.070, -11.792, -10.489, -11.529]#, -13.032, -10.709]#, -12.749]\n \n ##Bedmig\n #Polys['bedmig']=['p1', 'p2', 'p6', 'p4', 'p7', 'p3', 'p5']\n #refTs['bedmig']=200\n #refdGs['bedmig']=[0.000, 1.678, -0.372, -2.878, 1.955, -0.322, -1.146]\n #refddGs['bedmig']=[0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02]\n #refdUs['bedmig'] = [0.000, 3.803, -0.649, -1.217, 2.772, 2.777, 5.638]\n #absolutedUs['bedmig'] = [-92.82, -89.01, -93.46, -94.03, -90.03, -90.0378, -87.1763]\n \n #Bedmig\n Polys['bedmig']=['p1', 'p7']\n refTs['bedmig']=200\n refdGs['bedmig']=[0.000, 1.955]\n refddGs['bedmig']=[0.00, 0.016]\n refdUs['bedmig'] = [0.000, 2.789]\n absolutedUs['bedmig'] = [-92.814, -90.025]\n \n ##Bedmig\n #Polys['bedmig']=['p5']\n #refTs['bedmig']=200\n #refdGs['bedmig']=[0.000]\n #refddGs['bedmig']=[0.00]\n #refdUs['bedmig'] = [0.000]\n #absolutedUs['bedmig'] = [-87.1763]\n \n \n ##Bedmig\n #Polys['bedmig']=['p1', 'p7', 'p3', 'p5', 'p6']\n #refTs['bedmig']=200\n #refdGs['bedmig']=[0.000, 1.955, -0.322, -1.146, -0.372]\n #refddGs['bedmig']=[0.02, 0.02, 0.02, 0.02, 0.02]\n #refdUs['bedmig'] = [0.000, 2.772, 2.777, 5.638, -0.649]\n #absolutedUs['bedmig'] = [-92.82, -90.03, -90.0378, -87.1763, -93.46]\n \n #Cafine\n Polys['cafine']=['p1', 'p2']\n refTs['cafine']=200\n refdGs['cafine']=[0.000, 1.846]\n refddGs['cafine']=[0.005, 0.005]\n refdUs['cafine'] = [0.000, 2.375]\n absolutedUs['cafine'] = [-28.737, -26.362]\n \n SystemNAME = \"OPLSAA\"\n \n # Amoeba Reweighting\n if potential == \"amoeba09\":\n #Potentials=['amoeba09','designeda']#, 'designeda', 'designeda', 'designeda', 'designeda', 'designeda']\n Potentials=['amoeba09']\n PotNAME='AMO'\n Charges=['0.1150', '0.1150', '0.0700', '0.0850', '0.1000', '0.1150', '0.1300', '0.1450', '0.1600', '0.1750', '0.1900', '0.1000', '0.0900', '0.0800', '0.0700','0.0600','0.0500','0.0400','0.0300','0.0200','0.0100']\n Chargenames=['', '', 'C00700', 'C00850', 'C01000', 'C01150', 'C01300', 'C01450', 'C01600', 'C01750', 'C01900', 'C00900', 'C00800', 'C00700', 'C00600', 'C00500', 'C00400', 'C00300', 'C00200', 'C00100']\n PotNAMES=['AMO', 'DESA']\n SimNAMES=['TIN', 'GRO']\n #PotNAMES=['AMO']\n #SimNAMES=['TIN']\n refPot=0\n Temperatures=np.array([30,40,50,60,70,80,90,100,110,130,140,150,160,170,180,190,200,210,220,230,240,250])\n Pressures=np.ones(len(Temperatures),int);\n #Temperatures=np.array([60,100,140,200])\n \n #Benzene\n Polys['benzene']=['p1', 'p2', 'p3']\n refTs['benzene']=200\n refdGs['benzene']=[0.000, -0.362, -0.291]\n #refdGs['benzene']=[0.000, 0.390, 0.330]\n refddGs['benzene']=[0.000, 0.031, 0.032]\n refdUs['benzene'] = [0.000, 0.781, 0.643]\n absolutedUs['benzene'] = [-3.587, -2.807, -2.944]\n \n #Formam\n Polys['formam']=['p1', 'p2']\n refTs['formam']=100\n refdGs['formam']=[0.000, 0.293]\n refddGs['formam']=[0.000, 0.020]\n refdUs['formam'] = [0.000, 0.487]\n absolutedUs['formam'] = [-26.237, -25.750]\n \n #Acetac\n Polys['acetac']=['p1', 'p2']\n refTs['acetac']=50\n refdGs['acetac']=[0.000, -0.106]\n refddGs['acetac']=[0.02, 0.02]\n refdUs['acetac'] = [0.000, -0.136]\n absolutedUs['acetac'] = [-34.028, -34.163]\n \n #Imazol\n Polys['imazol']=['p1', 'p2']\n refTs['imazol']=200\n refdGs['imazol']=[0.000, 0.125]\n refddGs['imazol']=[0.020, 0.020]\n refdUs['imazol'] = [0.000, 0.201]\n absolutedUs['imazol'] = [-23.186, -22.985]\n \n #Glycin\n Polys['glycin']=['p1', 'p2', 'p3']\n refTs['glycin']=10\n refdGs['glycin']=[0.000, 0.163, 1.222]\n refddGs['glycin']=[0.000, 0.000, 0.000]\n refdUs['glycin'] = [0.000, 0.163, 1.222]\n absolutedUs['glycin'] = [0.000, 0.000, 0.000]\n \n SystemName = \"AMOEBA\"\n \n #Gromos\n if potential == \"gromos\":\n Potentials=['gromos54a7']\n PotNAME='GROM'\n Charges=['0.1150', '0.1150', '0.0700', '0.0850', '0.1000', '0.1150', '0.1300', '0.1450', '0.1600', '0.1750', '0.1900', '0.1000', '0.0900', '0.0800', '0.0700','0.0600','0.0500','0.0400','0.0300','0.0200','0.0100']\n Chargenames=['C01150', 'C01150', 'C00700', 'C00850', 'C01000', 'C01150', 'C01300', 'C01450', 'C01600', 'C01750', 'C01900', 'C00900', 'C00800', 'C00700', 'C00600', 'C00500', 'C00400', 'C00300', 'C00200', 'C00100']\n PotNAMES=['GROM']\n SimNAMES=['GRO']\n Temperatures=np.array([10,20,30,40,50,60,70,80,90,100,110,120,130,140,150,160,170,180,190,200,210,220,230,240,250])\n refPot=0\n \n #Benzene\n Polys['benzene']=['p1', 'p2', 'p3']\n refTs['benzene']=200\n refdGs['benzene']=[0.000, 0.251, 0.345]\n refddGs['benzene']=[0.000, 0.019, 0.018]\n refdUs['benzene'] = [0.000, 0.314, 0.328]\n absolutedUs['benzene'] = [-10.184, -9.869, -9.853]\n \n SystemName = \"GROMOS\"\n \n Polymorphs = Polys[molecule]\n refT = refTs[molecule]\n refdG = refdGs[molecule]\n refddG = refddGs[molecule]\n refdU = refdUs[molecule]\n absolutedU = absolutedUs[molecule]\n return Polymorphs, refT, refdG, refddG, refdU, absolutedU\n\ndef get_potential_info(potential):\n if potential == 'oplsaa':\n SimNAMES=['GRO']\n Chargenames = ['', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',\n '', '', '', '', '', '', '', '', '']\n PotNAMES = ['OPLS']\n elif potential == 'amoeba09':\n SimNAMES=['TIN', 'GRO']\n Chargenames = ['', '', 'C00700', 'C00850', 'C01000', 'C01150', 'C01300', 'C01450', 'C01600', 'C01750', 'C01900',\n 'C00900', 'C00800', 'C00700', 'C00600', 'C00500', 'C00400', 'C00300', 'C00200', 'C00100']\n PotNAMES = ['AMO', 'DESA']\n elif potential == \"gromos\":\n SimNAMES = ['GRO']\n Chargenames = ['C01150', 'C01150', 'C00700', 'C00850', 'C01000', 'C01150', 'C01300', 'C01450', 'C01600',\n 'C01750', 'C01900', 'C00900', 'C00800', 'C00700', 'C00600', 'C00500', 'C00400', 'C00300',\n 'C00200', 'C00100']\n PotNAMES = ['GROM']\n return SimNAMES, Chargenames, PotNAMES\n\n\ndef crystal_matrix_to_lattice_parameters(crystal_matrix):\n \"\"\"\n This function takes any strained crystal lattice matrix and return the lattice parameters\n\n **Required Inputs\n crystal_matrix = crystal lattice matrix ([[Vxx,Vxy,Vxz],\n [Vyx,Vyy,Vyz],\n [Vzx,Vzy,Vzz]])\n \"\"\"\n # Computing lattice parameters\n a = np.linalg.norm(crystal_matrix[:, 0])\n b = np.linalg.norm(crystal_matrix[:, 1])\n c = np.linalg.norm(crystal_matrix[:, 2])\n\n gamma = np.arccos(np.dot(np.squeeze(np.asarray(crystal_matrix[:, 0])), np.squeeze(np.asarray(crystal_matrix[:, 1])))\n / (a * b)) * 180. / np.pi\n alpha = np.arccos(np.dot(np.squeeze(np.asarray(crystal_matrix[:, 1])), np.squeeze(np.asarray(crystal_matrix[:, 2])))\n / (b * c)) * 180. / np.pi\n beta = np.arccos(np.dot(np.squeeze(np.asarray(crystal_matrix[:, 2])), np.squeeze(np.asarray(crystal_matrix[:, 0])))\n / (c * a)) * 180. / np.pi\n\n # Creating an array of lattice parameters\n lattice_parameters = np.array([a, b, c, alpha, beta, gamma])\n return lattice_parameters\n\n\ndef dGvsT(plot_out=False, Temperatures=np.array([100,200,300]), Temperatures_unsampled=[], Pressure=1, Molecules=72, molecule='benzene', \n Independent=0, potential='oplsaa', ignoreframes=200, includeframes=100000,\n simulation='gromacs', directory='', ensemble='NVT', spacing=1, hinge='DefaultHinge', phase='solid',\n Polymorphs=['p1', 'p2', 'p3'], refT=200, refdG=[0.000, 0.185, 0.306], refddG=[0.000, 0.019, 0.019],\n refdU=[0.000, 0.267, 0.240], absolutedU=[-5.624, -5.362, -5.380], output_directory='output'):\n#NSA: Is this needed?\n Colors = ['b', 'g', 'r', 'm', 'c', 'y', 'k', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g']\n\n if Independent == 0:\n Independent = Molecules\n\n # Hard set from old dictionary funciton\n refPot = 0\n ExtraPressures = []\n\n if np.all(Temperatures_unsampled == None):\n Temperatures_unsampled = np.array([])\n\n if (not np.any(Temperatures == refT)) and (not np.any(Temperatures_unsampled == refT)):\n Temperatures_unsampled = np.append(Temperatures_unsampled, refT)\n\n Temperatures = np.sort(np.append(Temperatures, Temperatures_unsampled))\n Pressures = np.ones(len(Temperatures), int)\n Pressures[len(Pressures) - len(ExtraPressures): len(Pressures)] = ExtraPressures\n Potentials = [potential]\n\n if (plot_out):\n# import matplotlib.cm as cm\n# from matplotlib.font_manager import FontProperties as FP\n font = {'family': 'normal',\n 'weight': 'normal',\n 'size': 14}\n matplotlib.rc('font', **font)\n \n # =============================================================================================\n # ENSURE THAT USER INPUTS ARE SENSIBLE\n # =============================================================================================\n # Pressure\n if Pressure < 0:\n print(\"Invalid Pressure: \" + str(Pressure))\n sys.exit()\n \n # ENSEMBLE\n if ensemble != \"NVE\" and ensemble != \"NVT\" and ensemble != \"NPT\":\n print(\"Invalid Ensemble\")\n print(\"Supported Ensembles: NVE NVT NPT\")\n sys.exit()\n \n # =============================================================================================\n # FORMAT INPUTS\n # =============================================================================================\n # TEMPERATURE\n refk = -1\n for k, temp in enumerate(Temperatures):\n if temp == refT and refk == -1:\n refk = k + refPot * len(Temperatures)\n\n # =============================================================================================\n # READ IN RAW DATA\n # =============================================================================================\n # Constants.\n kB = 1.3806488e-23 * 6.0221413e23 / (1000.0 * 4.184) # Boltzmann constant in kcal/mol/K\n \n # Parameters\n # How many states?\n K = len(Potentials) * len(Temperatures)\n \n # maximum number of snapshots/simulation (could make this automated) - doesn't matter, as long as it's long enough.\n N_max = 5000\n \n # beta factor for the different temperatures\n beta_k = 1.0 / (kB * Temperatures)\n beta_k = np.tile(beta_k, (1, len(Potentials)))[0]\n \n # Conversion from kJ to kcal\n kJ_to_kcal = 0.2390057\n\n # This is the sampling efficiency for each potential in each combination of potentials\n Efficiency = np.zeros(K, float)\n \n # Allocate storage for simulation data\n # u_pklnT is the complete matrix of all energy data. 'p' is the polymorph, 'k' is the sampled state, 'l' is the\n # evaluated state, 'n' is the sample number, and T is the energy term\n #u_pklnT = np.zeros([len(Polymorphs), K, K, N_max, 20])\n \n # N_k[k] is the total number of snapshots from alchemical state k\n N_k = np.zeros(K, np.int32)\n \n # Terms_l is the list of all energy terms for the 'l' state\n Terms_l = []\n \n # dA[p,i,k] is the free energy between potential 0 and state k for spacing i in polymorph p\n dA = np.zeros([len(Polymorphs), spacing + 1, K], float)\n \n # ddA[p,i,k] is the uncertainty in the free energy between potential 0 and state k for spacing i in polymorph p\n ddA = np.zeros([len(Polymorphs), spacing + 1, K], float)\n \n # dG[p,i,t] is the free energy between polymorph 1 and polymorph p for spacing i and temperature t\n dG = np.zeros([len(Polymorphs), spacing + 1, len(Temperatures)])\n \n # ddG[p,i,t] is the uncertanity in the free energy between polymorph 1 and polymorph p for spacing i and temperature t\n ddG = np.zeros([len(Polymorphs), spacing + 1, len(Temperatures)])\n \n # dS[p,i,t] is the relative entropy between polymorph 1 and polymorph p for spacing i and temperature t\n dS = np.zeros([len(Polymorphs), spacing + 1, len(Temperatures)])\n \n # ddS[p,i,t] is the uncertanity in the relative entropy between polymorph 1 and polymorph p for spacing i and temperature t\n ddS = np.zeros([len(Polymorphs), spacing + 1, len(Temperatures)])\n \n dS_mbar = np.zeros([len(Polymorphs), spacing + 1, len(Temperatures)])\n ddS_mbar = np.zeros([len(Polymorphs), spacing + 1, len(Temperatures)])\n dH_mbar = np.zeros([len(Polymorphs), spacing + 1, len(Temperatures)])\n \n # O_pij[p,i,j] is the overlap within polymorph p between temperature state i and temperature state j\n O_pij = np.zeros([len(Polymorphs), len(Temperatures), len(Temperatures)])\n dU = np.zeros([len(Polymorphs), len(Temperatures)])\n ddU = np.zeros([len(Polymorphs), len(Temperatures)])\n \n # u_kln[k,l,n] is the reduced potential energy of configuration n from potential k in potential l\n u_kln = np.zeros([K, K, N_max], np.float64)\n \n # V_pkn is the volume of configuration n of polymorph p at temperature k\n V_pkn = np.zeros([len(Polymorphs), len(Temperatures), N_max], float)\n\n # V_avg is the average volume of polymorph p at temperature k\n V_avg = np.zeros([len(Polymorphs), len(Temperatures)], float)\n \n # ddV_avg is the standard deviation of the volume of polymorph p at temperature k\n ddV_avg = np.zeros([len(Polymorphs), len(Temperatures)], float)\n\n # C_pkn is the lattice tensor of the polymorph p at temperature k\n box_place = np.matrix([[0, 0], [1, 1], [2, 2], [0, 1], [0, 2], [1, 2]])\n C_pkn = np.zeros([len(Polymorphs), len(Temperatures), N_max, 3, 3], float)\n\n # h_avg is the average lattice parameters of polymorph p at temperature k\n h_avg = np.zeros([len(Polymorphs), len(Temperatures), 6], float)\n \n # dh is the standard deviation of the lattice parameters of polymorph p at temperature k\n dh = np.zeros([len(Polymorphs), len(Temperatures), 6], float)\n\n # Cycle through all polymorphs\n for p, polymorph in enumerate(Polymorphs):\n # Cycle through all sampled potentials\n for i, potential_k in enumerate(Potentials):\n count = 0\n for t in range(len(Temperatures)):\n k = len(Temperatures) * i + t\n # Cycle through all evaluated potentials\n for j, potential_l in enumerate(Potentials):\n l = len(Temperatures) * j\n \n dirpath = polymorph + '/temperature/' + str(count) + '/'\n if os.path.isfile(dirpath + 'PROD.edr') and (Temperatures[t] not in Temperatures_unsampled):\n count += 1\n print(\"loading \" + dirpath + 'PROD.edr')\n all_energy = panedr.edr_to_df(dirpath + 'PROD.edr')\n if len(all_energy['Potential'].values) > N_max:\n [start_production, _, _] = timeseries.detectEquilibration(all_energy['Potential'].values[::10])\n start_production *= 10\n else:\n [start_production, _, _] = timeseries.detectEquilibration(all_energy['Potential'].values)\n\n # Now read in the lattice tensor and average them\n if 'Box-XX' in list(all_energy):\n box_letters = ['XX', 'YY', 'ZZ', 'YX', 'ZX', 'ZY']\n else:\n box_letters = ['X', 'Y', 'Z']\n \n for b in range(len(box_letters)):\n if len(all_energy['Potential'].values) > N_max:\n [hold,_,_] = timeseries.detectEquilibration(all_energy['Box-' + box_letters[b]].values[::10])\n hold *= 10\n else:\n [hold,_,_] = timeseries.detectEquilibration(all_energy['Box-' + box_letters[b]].values)\n\n if hold > start_production:\n start_production = hold\n\n if len(all_energy['Total Energy'].values[start_production:]) > N_max:\n start_production = len(all_energy['Total Energy'].values) - N_max\n\n # Setting the end point of the simulation\n N = len(all_energy['Total Energy'].values[start_production:])\n N_k[k] = N\n \n u_kln[k, l, :N] = all_energy['Potential'].values[start_production:]\n \n # Now set these energies over all temperatures\n u_kln[k, l:(l + len(Temperatures)), :N] = u_kln[k, l, :N]\n \n # Now read in the volumes and average them\n V_pkn[p, t, :N] = all_energy['Volume'].values[start_production:]\n V_avg[p, t] = np.average(V_pkn[p, t, :N]) / float(Independent)\n ddV_avg[p, t] = np.std(V_pkn[p, t, :N]) / float(Independent)\n \n # Making the lattice tensor all the correct sign with time \n if count == 1:\n sign = np.sign(md.load(dirpath + 'pre_EQ.gro').unitcell_vectors[0].T)\n #sign = np.sign(md.load(polymorph + '/temperature/0/ANNEAL.gro').unitcell_vectors[0].T)\n for s in range(3):\n for j in range(3):\n if sign[s, j] == 0.:\n # Correcting for the sign of the lattice parameters\n sign[s, j] = 1.\n\n for b in range(len(box_letters)):\n C_pkn[p, t, :N, box_place[b, 0], box_place[b, 1]] = np.absolute(all_energy['Box-' + box_letters[b]].values[start_production:]) * \\\n sign[box_place[b, 0], box_place[b, 1]] * 10\n C_avg = np.average(C_pkn[p, t, :N], axis=0)\n dC = np.std(C_pkn[p, t, :N], axis=0)\n h_avg[p, t] = crystal_matrix_to_lattice_parameters(C_avg) \n dh[p, t] = np.absolute(crystal_matrix_to_lattice_parameters(C_avg + dC) - h_avg[p, t])\n else:\n N_k[k] = 0\n V_avg[p, t] = np.nan\n ddV_avg[p, t] = np.nan\n h_avg[p, t] = np.nan\n dh[p, t] = np.nan\n\n print(\"Start1\")\n # Convert all units to kcal\n #u_pklnT[p, :, :, :] *= kJ_to_kcal\n u_kln *= kJ_to_kcal\n \n print(\"Start2\")\n # If this was already in kcal or already fully independent, revert\n for j in range(len(Potentials)):\n if Potentials[j][:6] == \"amoeba\":\n #u_pklnT[p, :, j * len(Temperatures):(j + 1) * len(Temperatures), :, :] /= kJ_to_kcal\n u_kln[:, j * len(Temperatures):(j + 1) * len(Temperatures), :] /= kJ_to_kcal\n \n print(\"Start3\")\n # Remove dependent molecules\n for j in range(len(Potentials)):\n if Potentials[j][:6] != \"amoeba\":\n #u_pklnT[p, :, j * len(Temperatures):(j + 1) * len(Temperatures), :, :] *= float(Independent) / Molecules\n u_kln[:, j * len(Temperatures):(j + 1) * len(Temperatures), :] *= float(Independent) / Molecules\n \n print(\"Start4\")\n # Now average together the energies and volumes at each state\n for t in range(len(Temperatures)):\n dU[p, t] = np.average(u_kln[t, t, :N_k[t]]) / float(Independent)\n ddU[p, t] = np.std(u_kln[t, t, :N_k[t]]) / N_k[t] ** 0.5 / float(Independent)\n \n print(\"Start5\")\n # convert to nondimensional units from kcal/mol\n for k, beta in enumerate(beta_k):\n u_kln[:, k, :] *= beta\n \n u_kln_save = u_kln.copy()\n N_k_save = N_k.copy()\n print(\"End!\")\n \n print(\"Number of retained samples\")\n print(N_k)\n \n # Now create the full N_k matrix including the roll-backs as well as the free energy container\n # N_k_matrix[i,k] is the total number of snapshots from alchemical state k using in spacing i\n N_k_matrix = np.zeros([spacing + 1, K], np.int32)\n for i in range(spacing + 1):\n N_k_matrix[i, :] = N_k_save.copy()\n N_k_matrix[i, 0: len(Temperatures)] = N_k_matrix[i, 0:len(Temperatures)] * float(i) / float(spacing)\n \n # =============================================================================================\n # COMPUTE FREE ENERGY DIFFERENCE USING MBAR FOR EACH SPACING\n # =============================================================================================\n for i in range(spacing+1):\n if i == 0 and len(Potentials) == 1:\n continue\n # Initialize MBAR.\n print(\"Running MBAR...\")\n\n # generate the weights of each of the umbrella set\n mbar = pymbar.MBAR(u_kln, N_k_matrix[i, :], verbose=True)\n print(\"MBAR Converged...\")\n \n hold = mbar.computeEffectiveSampleNumber(verbose=True)\n print(hold)\n \n # extract self-consistent weights and uncertainties\n (df_i, ddf_i, theta_i) = mbar.getFreeEnergyDifferences()\n\n # extract entropy\n [_, _, Delta_u_ij, _, Delta_s_ij, dDelta_s_ij] = mbar.computeEntropyAndEnthalpy()\n print(\"Free Energies Optained...\")\n \n # Store the dimensionless results in the dA container\n dA[p, i, :] = df_i[refk]\n dH_mbar[p, i, :] = Delta_u_ij[0]\n dS_mbar[p, i, :] = Delta_s_ij[0]\n ddS_mbar[p, i, :] = dDelta_s_ij[0]\n print(dA)\n \n # =============================================================================================\n # COMPUTE UNCERTAINTY USING MBAR\n # =============================================================================================\n g_k = np.zeros([K])\n for i in range(spacing + 1):\n if i == 0 and len(Potentials) == 1:\n continue\n\n for k in range(K):\n # subsample correlated data - for now, use energy from current state\n if N_k_matrix[i, k] > 0:\n print(N_k_matrix[i, k])\n g_k[k] = timeseries.statisticalInefficiency(u_kln_save[k, k, 0:100])\n print(\"Correlation time for phase (%s), sampled state %d is %10.3f\" % (phase, k, g_k[k]))\n\n # subsample the data to get statistically uncorrelated data\n indices = np.array(timeseries.subsampleCorrelatedData(u_kln_save[k, k, 0:N_k_matrix[i, k]],\n g=g_k[k]))\n N_k_matrix[i, k] = len(indices)\n u_kln[k, :, 0:N_k_matrix[i, k]] = u_kln_save[k, :, indices].transpose() # not sure why we have to transpose\n \n print(\"Number of retained samples\")\n print(N_k)\n \n print(\"Running MBAR...\")\n \n # generate the weights of each state\n mbar = pymbar.MBAR(u_kln, N_k_matrix[i, :], verbose=True)\n print(\"MBAR Converged...\") \n \n # extract self-consistent weights and uncertainties\n (df_u, ddf_u, theta_u) = mbar.getFreeEnergyDifferences()\n \n # calculate the overlap it necessary\n if len(Temperatures) == 2:\n O_pij[p, :, :] = mbar.computeOverlap()[2]\n \n # testing\n weights_in_gromos = np.zeros(K, float)\n for k in range(K):\n w = np.exp(mbar.Log_W_nk[:, k])\n print(\"max weight in state %d is %12.7f\" % (k, np.max(w)))\n neff = 1 / np.sum(w ** 2)\n\n print(\"Effective number of sample in state %d is %10.3f\" % (k, neff))\n print(\"Efficiency for state %d is %d/%d = %10.4f\" % (k, neff, len(w), neff / len(w)))\n Efficiency[k] = neff / len(w) # Store the efficiency\n w_0 = np.exp(mbar.Log_W_nk[:, 0]) # Weights in gromos\n initial_configs = np.sum(N_k[0:k])\n final_configs = np.sum(N_k[0:k + 1])\n\n print(\"Total weight in gromos \" + str(np.sum(w_0[initial_configs:final_configs])))\n weights_in_gromos[k] = np.sum(w_0[initial_configs:final_configs])\n \n # Write out free energy differences\n print(\"Free Energy Difference (in units of kcal/mol)\")\n for k in range(K):\n print(\"%8.3f %8.3f\" % (-df_i[k, 0], ddf_u[k, 0]))\n \n # Store the dimensionless results in the ddA container\n ddA[p, i, :] = ddf_u[refk]\n\n # Check the overlap it necessary\n if len(Temperatures) == 2:\n print(\"Overlap:\")\n print(O_pij)\n pdb.set_trace()\n \n # =============================================================================================\n # FINALIZE THE RELATIVE FREE ENERGY AND ENTROPY\n # =============================================================================================\n for i in range(spacing + 1):\n for t, T in enumerate(Temperatures):\n for p in range(len(Polymorphs)):\n #print('HERE!!!!!', dA[p, i, t], dA[0, i, t], (dA[p, i, t] - dA[0, i, t]), (beta_k[t] * float(Independent)), float(T), float(refT), refdG[p])\n dG[p, i, t] = (dA[p, i, t] - dA[0, i, t]) / (beta_k[t] * float(Independent)) + float(T) / float(refT) * \\\n refdG[p]\n ddG[p, i, t] = ((ddA[p, i, t] ** 2 + ddA[0, i, t] ** 2) / (beta_k[t] * float(Independent)) ** 2 +\n float(T) / float(refT) * float(refddG[p]) ** 2) ** 0.5\n if p == 0:\n continue\n dS[p, i, t] = (dU[p, t] - dU[0, t] - dG[p, i, t]) / float(T)\n ddS[p, i, t] = (ddU[p, t] ** 2 + ddU[p, t] ** 2 + ddG[p, i, t] ** 2) ** 0.5 / float(T)\n \n print(\"Polymorph Free Energy:\")\n for p in range(len(Polymorphs)):\n print(\"%8.3f %8.3f\" % (dG[p, spacing, len(Temperatures) - 1], ddG[p, spacing, len(Temperatures) - 1]))\n \n # =============================================================================================\n # PLOT THE RELATIVE FREE ENERGY VS TEMPERATURE\n # =============================================================================================\n\n# Temperatures2 = np.array([0] + [j for j in Temperatures])\n# Pressures2 = np.array([1] + [j for j in Pressures])\n# dG2 = np.insert(dG, 0, np.transpose(np.tile(refdU, (1, 1))), axis=2)\n# ddG2 = np.insert(ddG, 0, np.zeros([len(Polymorphs), spacing + 1]), axis=2)\n# dS2 = np.insert(dS, 0, np.zeros([len(Polymorphs), spacing + 1]), axis=2)\n# ddS2 = np.insert(ddS, 0, np.zeros([len(Polymorphs), spacing + 1]), axis=2)\n PlotPress = 1 # Pressure to plot the dGvT curve at\n Temperatures_P = Temperatures[Pressures == PlotPress]\n\n if plot_out == True:\n f, a = plt.subplots(1, 1)\n xlabel = 'Temperature (K)'\n ylabel = 'Relative Free Energy (kcal/mol)'\n\n a.errorbar(Temperatures, dG[0, 0, :], yerr=np.zeros(len(dG[0, 0, :]), float), linestyle='--', marker='.',\n linewidth=2, alpha=0.6, color='b', label=Polymorphs[0])\n for p in range(len(Polymorphs)):\n if p == 0:\n continue\n if len(Potentials) > 1:\n a.errorbar(Temperatures, dG[p, 0, :], yerr=ddG[p, 0, :], linestyle='--', marker='.', linewidth=2,\n alpha=0.6, color=Colors[p], label=Polymorphs[p])\n a.errorbar(Temperatures_P, dG[p, 1, Pressures == PlotPress], yerr=ddG[p, 1, Pressures == PlotPress],\n linestyle='-', marker='.', linewidth=2, alpha=0.6, color=Colors[p], label=Polymorphs[p])\n \n a.set_xlabel(xlabel)\n a.set_ylabel(ylabel)\n\n if not os.path.isdir(output_directory):\n subprocess.call(['mkdir', output_directory])\n\n np.save(output_directory + '/T_' + molecule + '_' + potential, Temperatures_P)\n for p, Poly in enumerate(Polymorphs):\n np.save(output_directory + '/dGvT_' + molecule + '_' + Poly + '_' + potential, dG[p, spacing, Pressures == PlotPress])\n np.save(output_directory + '/ddGvT_' + molecule + '_' + Poly + '_' + potential, ddG[p, spacing, Pressures == PlotPress])\n if len(Potentials) > 1:\n np.save(output_directory + '/dGvT_' + molecule + '_' + Poly + '_' + potential + '_indirect', dG[p, 0, :])\n np.save(output_directory + '/ddGvT_' + molecule + '_' + Poly + '_' + potential + '_indirect', ddG[p, 0, :])\n if spacing > 1:\n np.save(output_directory + '/dGvT_' + molecule + '_' + Poly + '_' + potential + '_convergence', dG[p, :, :])\n np.save(output_directory + '/ddGvT_' + molecule + '_' + Poly + '_' + potential + '_convergence', ddG[p, :, :])\n np.save(output_directory + '/dS_' + molecule + '_' + Poly + '_' + potential, dS[p, spacing, :])\n np.save(output_directory + '/ddS_' + molecule + '_' + Poly + '_' + potential, ddS[p, spacing, :])\n \n # =============================================================================================\n # PLOT THE RELATIVE ENTROPY VS TEMPERATURE\n # =============================================================================================\n\n if plot_out == True:\n f, a = plt.subplots(1, 1)\n plt.xlabel('Temperature (K)', fontsize=20)\n plt.ylabel('Relative Entropy (kcal/molK)', fontsize=20)\n for p in range(len(Polymorphs)):\n a.errorbar(Temperatures2, dS[p, spacing, :], yerr=ddS[p, spacing, :], linestyle='--', marker='.', linewidth=2,\n alpha=0.6, color=Colors[p], label=Polymorphs[p])\n \n # =============================================================================================\n # PLOT THE AVERAGE ENERGY VS TEMPERATURE\n # =============================================================================================\n\n# dU2 = np.insert(dU, 0, np.transpose(absolutedU), axis=1)\n# ddU2 = np.insert(ddU, 0, 0, axis=1)\n\n if plot_out == True:\n f, a = plt.subplots(1, 1)\n plt.xlabel('Temperature (K)', fontsize=20)\n plt.ylabel('Average Energy (kcal/mol)', fontsize=20)\n for p in range(len(Polymorphs)):\n a.errorbar(Temperatures2, dU[p, :], yerr=ddU[p, :], linestyle='--', marker='.', linewidth=2, alpha=0.6,\n color=Colors[p], label=Polymorphs[p])\n plt.legend(loc='upper left')\n\n for p, Poly in enumerate(Polymorphs):\n np.save(output_directory + '/UvT_' + molecule + '_' + Poly + '_' + potential, dU[p, :])\n \n # =============================================================================================\n # PLOT THE AVERAGE BOX VOLUME VS TEMPERATURE\n # =============================================================================================\n \n if plot_out == True:\n f, a = plt.subplots(1, 1)\n plt.xlabel('Temperature (K)', fontsize=20)\n for p in range(len(Polymorphs)):\n a.errorbar(Temperatures, V_avg[p, :], yerr=ddV_avg[p, :], linestyle='--', marker='.', linewidth=2,\n alpha=0.6, color=Colors[p], label=Polymorphs[p])\n\n for p, Poly in enumerate(Polymorphs):\n np.save(output_directory + '/VvT_' + molecule + '_' + Poly + '_' + potential, V_avg[p, :])\n np.save(output_directory + '/dVvT_' + molecule + '_' + Poly + '_' + potential, ddV_avg[p, :])\n\n # =============================================================================================\n # SAVE THE AVERAGE BOX VECTORS AND ANGLES VS TEMPERATURE\n # =============================================================================================\n\n for p, Poly in enumerate(Polymorphs):\n np.save(output_directory + '/hvT_' + molecule + '_' + Poly + '_' + potential, h_avg[p, :])\n np.save(output_directory + '/dhvT_' + molecule + '_' + Poly + '_' + potential, dh[p, :])\n\n # =============================================================================================\n # PLOT THE DIFFERENCE IN AVERAGE ENERGY VS TEMPERATURE\n # =============================================================================================\n \n if plot_out == True:\n f, a = plt.subplots(1, 1)\n plt.xlabel('Temperature (K)', fontsize=20)\n plt.ylabel('Average Energy Difference (kcal/mol)', fontsize=20)\n for p in range(len(Polymorphs)):\n if p == 0:\n yerror = np.zeros(len(ddU[0, :]))\n else:\n yerror = []\n for t in range(len(ddU[0, :])):\n yerror.append(float((ddU[0, t] ** 2 + ddU[p, t] ** 2) ** 0.5))\n a.errorbar(Temperatures2, dU[p, :] - dU[0, :], yerr=yerror, linestyle='--', marker='.', linewidth=2,\n alpha=0.6, color=Colors[p], label=Polymorphs[p])\n \n # Save the data for future use.\n for p, Poly in enumerate(Polymorphs):\n np.save(output_directory + '/dUvT_' + molecule + '_' + Poly + '_' + potential, dU[p, :] - dU[0, :])\n np.save(output_directory + '/ddUvT_' + molecule + '_' + Poly + '_' + potential, (ddU[p, :] ** 2 + ddU[0, :] ** 2) ** 0.5)\n\n if plot_out == True:\n plt.tight_layout()\n plt.show()\n\n\nif __name__ == '__main__':\n # =============================================================================================\n # READ IN USER INPUTS\n # =============================================================================================\n parser = OptionParser()\n parser.add_option('-p', '--plot', dest='plot', help='Plot output (default false)', default=True, action='store_true')\n# parser.add_option('-T', dest='temp', help='Temperature', default=200)\n parser.add_option('-P', dest='Pressure', help='Pressure', default=1)\n# parser.add_option('-n', dest='polymorphs', help='Polymorphs to analyze', default='p1 p2 p3')\n parser.add_option('-N', dest='molecules', help='number of supercell molecules', default=72)\n parser.add_option('-M', dest='molecule', help='name of the molecule', default='benzene')\n parser.add_option('-I', dest='independent', help='number of independent molecules', default='Same')\n parser.add_option('-u', dest='potential', help='potential to create the phase diagram in', default='oplsaa')\n parser.add_option('-i', dest='ignoreframes', help='Initial frames to ignore', default=200)\n parser.add_option('-j', dest='includeframes', help='Number of frames to include', default=100000)\n parser.add_option('-z', dest='simulation', help='The simulation package that was used', default='gromacs')\n parser.add_option('-d', dest='directory', help='Parent directory of the reweight directories', default='None')\n parser.add_option('-E', dest='ensemble', help='Simulation Ensemble', default='NVT')\n parser.add_option('-s', dest='spacing', help='spacing for the plot rolling back the state 0 sampling', default=1)\n parser.add_option('-H', '--hinge', dest='hinge', help='Optional string at end of jobs', default='DefaultHinge')\n \n (options, args) = parser.parse_args()\n plot_out = options.plot\n Temp = options.temp\n Pressure = int(options.Pressure)\n Molecules = int(options.molecules)\n molecule = options.molecule\n if options.independent == 'Same':\n Independent = Molecules\n else:\n Independent = int(options.independent)\n potential = options.potential\n ignoreframes = int(options.ignoreframes)\n includeframes = int(options.includeframes)\n simulation = options.simulation\n directory = options.directory\n if directory == 'None':\n directory = ''\n ensemble = options.ensemble\n spacing = int(options.spacing)\n hinge = options.hinge\n phase = \"solid\"\n \n Polymorphs, refT, refdG, refddG, refdU, absolutedU = old_systems_dictionary(potential, molecule)\n dGvsT(plot_out=plot_out, Temperatures=Temp, Temperatures_unsampled=[], Pressure=Pressure, Molecules=Molecules, molecule=molecule,\n Independent=Independent, potential=potential, ignoreframes=ignoreframes, includeframes=includeframes, \n simulation=simulation, directory=directory, ensemble=ensemble, spacing=spacing, hinge=hinge, phase=phase, \n Polymorphs=Polymorphs, refT=refT, refdG=refdG, refddG=refddG, refdU=refdU, absolutedU=absolutedU)\n\n", "meta": {"hexsha": "071b35ca7b8d9f41a488c9aa9d06b59c079e1728", "size": 48962, "ext": "py", "lang": "Python", "max_stars_repo_path": "PSCP/analysis-scripts/dGvsT.py", "max_stars_repo_name": "shirtsgroup/finite-temperature-crystal-scripts", "max_stars_repo_head_hexsha": "799bc882d958d9afa264a168dae0b3051bafaf0b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "PSCP/analysis-scripts/dGvsT.py", "max_issues_repo_name": "shirtsgroup/finite-temperature-crystal-scripts", "max_issues_repo_head_hexsha": "799bc882d958d9afa264a168dae0b3051bafaf0b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 8, "max_issues_repo_issues_event_min_datetime": "2017-07-25T04:59:35.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-25T22:48:53.000Z", "max_forks_repo_path": "PSCP/analysis-scripts/dGvsT.py", "max_forks_repo_name": "shirtsgroup/finite-temperature-crystal-scripts", "max_forks_repo_head_hexsha": "799bc882d958d9afa264a168dae0b3051bafaf0b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-01-04T07:01:25.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-04T07:01:25.000Z", "avg_line_length": 50.3724279835, "max_line_length": 458, "alphanum_fraction": 0.5242228667, "include": true, "reason": "import numpy", "num_tokens": 15796, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5544704649604273, "lm_q2_score": 0.34510527095787247, "lm_q1q2_score": 0.1913506800483058}} {"text": "\"\"\" Parameters module. \"\"\"\n\n# ISC License\n#\n# Copyright (c) 2020–2022, Paul Wilhelm \n#\n# Permission to use, copy, modify, and/or distribute this software for any\n# purpose with or without fee is hereby granted, provided that the above\n# copyright notice and this permission notice appear in all copies.\n#\n# THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES\n# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF\n# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR\n# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\n# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\n# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF\n# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n\nfrom __future__ import annotations\nfrom typing import Callable\nimport numpy as np\nfrom numba import jit, prange\nfrom magneticalc.Backend_Types import get_jit_enabled\nfrom magneticalc.ConditionalDecorator import ConditionalDecorator\nfrom magneticalc.Constants import Constants\nfrom magneticalc.Debug import Debug\nfrom magneticalc.Field_Types import FIELD_TYPE_A, FIELD_TYPE_B\nfrom magneticalc.Metric import Metric\nfrom magneticalc.Validatable import Validatable, require_valid, validator\n\n\nclass Parameters(Validatable):\n \"\"\" Parameters class. \"\"\"\n\n def __init__(self) -> None:\n \"\"\"\n Initializes parameters class.\n \"\"\"\n Validatable.__init__(self)\n Debug(self, \": Init\", init=True)\n\n self._energy: float = 0.0\n self._self_inductance: float = 0.0\n self._magnetic_dipole_moment: float = 0.0\n\n def set(self, *args, **kwargs):\n \"\"\"\n Sets the parameters\n \"\"\"\n\n # ------------------------------------------------------------------------------------------------------------------\n\n def _get_squared_field(\n self,\n sampling_volume: SamplingVolume, # type: ignore\n field: Field # type: ignore\n ) -> float:\n \"\"\"\n Returns the \"squared\" field scalar.\n\n @param sampling_volume: SamplingVolume\n @param field: B-field\n @return: Float\n \"\"\"\n return self._get_squared_field_worker(sampling_volume.permeabilities, field.vectors)\n\n @staticmethod\n @ConditionalDecorator(get_jit_enabled(), jit, nopython=True, parallel=True)\n def _get_squared_field_worker(sampling_volume_permeabilities: np.ndarray, field_vectors: np.ndarray) -> float:\n \"\"\"\n Returns the \"squared\" field scalar.\n\n @param sampling_volume_permeabilities: Ordered list of sampling volume's relative permeabilities µ_r\n @param field_vectors: Ordered list of 3D vectors (B-field)\n @return: Float\n \"\"\"\n squared = 0\n for i in prange(len(field_vectors)):\n squared += np.dot(field_vectors[i], field_vectors[i] / sampling_volume_permeabilities[i])\n return squared\n\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n\n def _get_magnetic_dipole_moment(\n self, wire: Wire, # type: ignore\n length_scale: float\n ) -> float:\n \"\"\"\n Returns the magnetic dipole moment scalar.\n\n @param wire: Wire\n @param length_scale: Length scale (m)\n @return: Float\n \"\"\"\n elements_center = np.array([element[0] for element in wire.elements])\n elements_direction = np.array([element[1] for element in wire.elements])\n vector = self._get_magnetic_dipole_moment_worker(elements_center, elements_direction, length_scale)\n return np.abs(wire.dc * np.linalg.norm(vector) / 2)\n\n @staticmethod\n @ConditionalDecorator(get_jit_enabled(), jit, nopython=True, parallel=True)\n def _get_magnetic_dipole_moment_worker(\n elements_center: np.ndarray,\n elements_direction: np.ndarray,\n length_scale: float\n ):\n \"\"\"\n Returns the (unscaled) magnetic dipole moment vector.\n\n @param elements_center: Current element centers\n @param elements_direction: Current element directions\n @param length_scale: Length scale (m)\n @return: Magnetic dipole moment vector\n \"\"\"\n squared = np.zeros(3)\n for i in prange(len(elements_center)):\n squared += np.cross(elements_center[i] * length_scale, elements_direction[i] * length_scale)\n return squared\n\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n\n @validator\n def recalculate(\n self,\n wire: Wire, # type: ignore\n sampling_volume: SamplingVolume, # type: ignore\n field: Field, # type: ignore\n progress_callback: Callable\n ) -> bool:\n \"\"\"\n Recalculates parameters.\n\n @param wire: Wire\n @param sampling_volume: SamplingVolume\n @param field: Field\n @param progress_callback: Progress callback\n @return: True (currently non-interruptable)\n \"\"\"\n Debug(self, \".recalculate()\")\n\n progress_callback(0)\n\n self._magnetic_dipole_moment = self._get_magnetic_dipole_moment(wire, Metric.LengthScale)\n\n progress_callback(33)\n\n if field.type == FIELD_TYPE_A:\n\n pass\n\n elif field.type == FIELD_TYPE_B:\n\n dV = (Metric.LengthScale / sampling_volume.resolution) ** 3 # Sampling volume element\n self._energy = self._get_squared_field(sampling_volume, field) * dV / Constants.mu_0\n\n progress_callback(66)\n\n self._self_inductance = self._energy / np.square(wire.dc)\n\n progress_callback(100)\n\n return True\n\n @property\n @require_valid\n def energy(self) -> float:\n \"\"\"\n Returns calculated energy.\n\n @return: Float\n \"\"\"\n return self._energy\n\n @property\n @require_valid\n def self_inductance(self) -> float:\n \"\"\"\n Returns calculated self-inductance.\n\n @return: Float\n \"\"\"\n return self._self_inductance\n\n @property\n @require_valid\n def magnetic_dipole_moment(self) -> float:\n \"\"\"\n Returns calculated magnetic dipole moment.\n\n @return: Float\n \"\"\"\n return self._magnetic_dipole_moment\n", "meta": {"hexsha": "db2cc2af3baaa00b689c36b5a4bb58675112e371", "size": 6416, "ext": "py", "lang": "Python", "max_stars_repo_path": "magneticalc/Parameters.py", "max_stars_repo_name": "CSChisholm/MagnetiCalc", "max_stars_repo_head_hexsha": "19b6897677c334de18ba2ea82395f941c77a2849", "max_stars_repo_licenses": ["0BSD"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "magneticalc/Parameters.py", "max_issues_repo_name": "CSChisholm/MagnetiCalc", "max_issues_repo_head_hexsha": "19b6897677c334de18ba2ea82395f941c77a2849", "max_issues_repo_licenses": ["0BSD"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "magneticalc/Parameters.py", "max_forks_repo_name": "CSChisholm/MagnetiCalc", "max_forks_repo_head_hexsha": "19b6897677c334de18ba2ea82395f941c77a2849", "max_forks_repo_licenses": ["0BSD"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.2435233161, "max_line_length": 120, "alphanum_fraction": 0.6206359102, "include": true, "reason": "import numpy,from numba", "num_tokens": 1488, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5964331462646254, "lm_q2_score": 0.3208212878370535, "lm_q1q2_score": 0.19134845009332282}} {"text": "# ------------------------------------------------------------------------------\n# Copyright (c) Microsoft\n# Licensed under the MIT License.\n# Some code is from https://github.com/princeton-vl/pose-ae-train/blob/454d4ba113bbb9775d4dc259ef5e6c07c2ceed54/utils/group.py\n# Written by Bin Xiao (leoxiaobin@gmail.com)\n# Modified by Bowen Cheng (bcheng9@illinois.edu)\n# ------------------------------------------------------------------------------\n\"\"\"\n############################################################################\n将检测分组为个体实例姿态。为此, 网络将在每个关节的像素位置生成一个标记。\n换句话说, 每个关节热图都有相应的 \"tag标签\" 热图。\n因此, 如果有m个人体关节需要预测, 那么网络将输出总共2m通道, m用于检测和m用于分组。\n为了将检测解析成个体实例, \n我们使用非最大抑制来获取每个关节的峰值检测, 并在相同的像素位置检索其相应的tag标记。\n然后, 我们通过比较检测的标记值和匹配足够接近的标记值, 对整个人体关节点检测进行分组。\n而后一组检测形成了一个人的姿势估计。\n############################################################################\n为了产生最后一个最终预测集合，我们对每个关节点进行迭代。\n迭代的顺序是先考虑头和躯干而后逐渐像肢体移动。\n我们从第一个关节点开始，NMS后得到每个超过阈值的关节点。\n这些关键点组组成了我们待检测人的最初候选池。\n我们之后考虑检测后续的关节点。我们将后续关节点与我们现有关节点候选池相比，得到其最优匹配。\n只有当两个标记相差小于一个特别的阈值时才会被匹配。\n除此之外，我们因此基于标记距离和检测分数的最大匹配。\n如果没有任何检测额被匹配，则被视为一个新的人体实例。这种情况可能是因为某个特定人体只有手或脚可见。\n我们在每类关节点上循环匹配，直到每个检测都被匹配到一个人。\n##########################################################################################\n\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nfrom munkres import Munkres\nimport numpy as np\nimport torch\n\n\ndef py_max_match(scores):\n m = Munkres() # 匈牙利算法\n \"\"\"\n ##################################################################\n Compute the indexes for the lowest-cost pairings between rows and\n columns in the database. Returns a list of `(row, column)` tuples\n that can be used to traverse the matrix.\n ##################################################################\n \"\"\"\n tmp = m.compute(scores)\n tmp = np.array(tmp).astype(np.int32)\n return tmp\n\n\n\"\"\"\n##########################\n# 通过tag值，对节点进行匹配\n##########################\n# 一张图片检测出了几个人，最终有几个人，就有几个tag键，最后在\n # grouped_keys中就会有几个不同的值，每个人对应一个值，\n # grouped_keys: [ tag1,tag2,...,tag_?? ]\n # joints_dict: { tag1: array(17*5) , tag2: array(17*5), .... ,tag_??: array(17*5) } ，\n # 最终有几个人，就有几个tag键\n # grouped_key中的值和joints_dict中的键一致。\n # grouped_tags形如:[array([ 3.0320523, -2.9441261] ), array([-3.2409573, 3.267928 ] ), array([-0.46144685, 0.43847117] ), array([-6.7198505, 6.6868863] )]\n # tag_dict形如:\n # {3.0482664: [array([ 3.0482664, -2.942074 ] ), array([ 3.0499892, -2.9416664] ), array([ 3.04908 , -2.946251] ), array([ 3.0546198, -2.9452639] ), array([ 3.0284576, -2.9707832] ), array([ 3.011262 , -2.9344423] ), array([ 3.0276155, -2.9461455] ), array([ 3.022631, -2.930122] ), array([ 3.0320063, -2.947176 ] ), array([ 3.0340366, -2.9682217] ), array([ 3.0116858, -2.9123354] ), array([ 3.0149767, -2.9450297] ), array([ 3.0390344, -2.9229352] )], \n # -3.204033: [array([-3.204033 , 3.2672586] ), array([-3.224389 , 3.2966106] ), array([-3.2322555, 3.254828 ] ), array([-3.2290933, 3.2748113] ), array([-3.2254848, 3.290883 ] ), array([-3.2734041, 3.2389045] ), array([-3.262566 , 3.2427683] ), array([-3.270686, 3.308473] ), array([-3.240734 , 3.2396798] ), array([-3.22856 , 3.2748213] ), array([-3.2633042, 3.247148 ] ), array([-3.2369757, 3.2789457] ), array([-3.2354915, 3.1973739] )], \n # -0.48780698: [array([-0.48780698, 0.4803399 ] ), array([-0.4915051 , 0.48355848] ), array([-0.47469807, 0.46150476] ), array([-0.43962345, 0.45701584] ), array([-0.47148287, 0.45973817] ), array([-0.38883165, 0.44795612] ), array([-0.39312 , 0.29450473] ), array([-0.49791056, 0.4785707 ] ), array([-0.4475416 , 0.36834407] ), array([-0.47388119, 0.49372977] ), array([-0.47124237, 0.3472029 ] ), array([-0.49971843, 0.48918843] ), array([-0.49369287, 0.46173176] )], \n # -6.7378864: [array([-6.7378864, 6.6715736] ), array([-6.738204, 6.720743] ), array([-6.7024045, 6.702105 ] ), array([-6.674477 , 6.6906085] ), array([-6.7082214, 6.6431236] ), array([-6.8019643, 6.791915 ] ), array([-6.6872525, 6.6337585] ), array([-6.708395 , 6.6412625] ), array([-6.686763, 6.692321] )]\n # }\n##################################################\n\"\"\"\n\ndef match_by_tag(inp, params):\n assert isinstance(params, Params), 'params should be class Params()'\n \"\"\"\n # zip后的inp，使得：\n # tag_k.shape=(17,30,2)\n # loc_k.shape=(17,30,2)\n # val_k.shape=(17,30)\n \"\"\"\n tag_k, loc_k, val_k = inp \n \n default_ = np.zeros((params.num_joints, 3 + tag_k.shape[2])) # shape=(17,5)\n\n joint_dict = {}\n tag_dict = {}\n for i in range(params.num_joints): # 17\n idx = params.joint_order[i]\n \"\"\"\n # 17类中的第idx类节点\n \"\"\" \n # tags.shape=(30,2) \n tags = tag_k[idx] \n # joints.shape=(30,2+1+2) , 二维坐标 + value值 + tag值\n joints = np.concatenate(\n (loc_k[idx], val_k[idx, :, None], tags), 1\n )\n # 从30个节点中选择val值大于阈值的节点,\n # 这些关键点组组成了我们待检测人的最初候选池. \n # mask.shape=(30) \n mask = joints[:, 2] > params.detection_threshold\n\n \"\"\"\n ##############################################\n # 从该类节点的30个中，\n # 挑选出val大于阈值的节点对应的tags和joints\n # 假设有m个节点满足阈值条件，则\n # tags.shape=(k,2)\n # joints.shape=(k,5) \n ##############################################\n \"\"\"\n # tags.shape=(k,2)\n tags = tags[mask] \n # joints.shape=(k,5) , 二维坐标 + value值 + tag值\n print('joints.shape:{}'.format(joints.shape))\n\n if joints.shape[0] == 0:\n continue\n\n \"\"\"\n 注意：注意：注意：注意：\n 这些键tag都是第一次出现的值（所以几乎都是第一类节点中的tag值，不过如果某些人的第一类节点可能被遮挡，这些人的tag键开始时就没有出现）\n \"\"\"\n # 当此时访问的是第一类节点\n if i == 0 or len(joint_dict) == 0:\n for tag, joint in zip(tags, joints): # 逐一访问第一类节点的30个中的k=m个\n # tag.shape=2 , joint.shape=5 \n # 以该点的tag值作为字典的键\n # 共生成m个键值对\n key = tag[0]\n # Python字典setdefault()方法和get()方法类似,如果键不已经存在于字典中,将会添加键并将值设为默认值。\n\n joint_dict.setdefault(key, np.copy(default_))[idx] = joint\n tag_dict[key] = [tag]\n \n # 当该类节点不是第一类节点时\n # 假设此时访问第二类节点\n else:\n # grouped_keys和grouped_tags为之前的值\n # grouped_keys = [ tag_1 , tag_2 , ... , tag_?? ]\n grouped_keys = list(joint_dict.keys())[:params.max_num_people]\n\n # grouped_tags = [ array([a_1,b_1]) , array([a_2,b_2]) , ... , array([a_????,b_????]) ]\n \"\"\"\n tag_dict: 不同的键tag代表不同一个人，而在一个键tag中，保存着该人存在的节点的真实tag值，\n 因为一个人的节点最多有17个，所以一个键tag最多会有17个节点的tag值,最少一个tag值。\n \"\"\"\n grouped_tags = [np.mean(tag_dict[i], axis=0) for i in grouped_keys] \n \n # False\n if params.ignore_too_much \\\n and len(grouped_keys) == params.max_num_people:\n continue\n \n \"\"\" \n ##########################################################\n # joints为当前节点，假设有k=n个候选点，则joints.shape=(n,5)，\n # grouped_tags为之前的tags值。np.array(grouped_tags) = array([[a_1,b_1],[a_2,b_2],...,[a_m,b_m]]) , shape=(m,2)\n ################################################################################################################## \n \"\"\"\n \"\"\"\n $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n # 计算了“当前类别的n个节点”分别与“之前的m个节点”差值diff=(n,1,2)-(1,m,2),再求L2范数\n # 得到diff.shape=(n,m) \n $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n 注意：\n 注意：\n 注意：\n 当前类别的节点是与到目前为止已存在的人的代表节点的tag(即：已存在的字典的键)。\n 注意：\n 注意：\n 注意：\n 当前类别的节点是与到目前为止已存在的人的代表节点的tag(即：已存在的字典的键)。\n 注意：\n \"\"\" \n diff = joints[:, None, 3:] - np.array(grouped_tags)[None, :, :] # diff.shape=(n,m,2)\n diff_normed = np.linalg.norm(diff, ord=2, axis=2) # diff_normed.shape=(n,m)\n\n diff_saved = np.copy(diff_normed)\n\n if params.use_detection_val: # True\n diff_normed = np.round(diff_normed) * 100 - joints[:, 2:3]\n\n num_added = diff.shape[0] # 当前类节点的 k2 个值\n num_grouped = diff.shape[1] # 之前类节点的 k1 个值\n\n # 如果 “当前类节点数n” 比 “之前类别节点m” 大。\n if num_added > num_grouped:\n # np.concatenate(([n,m],[n,n-m]),axis=1) ----> diff_normed.shape=( n , n )\n diff_normed = np.concatenate(\n (\n diff_normed,\n np.zeros((num_added, num_added-num_grouped))+1e10\n ),\n axis=1\n )\n\n \"\"\"\n ###########################################\n # 运用匈牙利算法寻找相邻节点的最优匹配。\n # 获取相邻节点的匹配对,pair.shape=(n,2) \n ###########################################\n \"\"\"\n pairs = py_max_match(diff_normed) # 运用匈牙利算法\n \n for row, col in pairs:\n if (row < num_added and col < num_grouped and diff_saved[row][col] < params.tag_threshold): \n \"\"\"\n # 注意：\n # 注意：\n # 注意：\n # 注意：\n # 当前的tag值与之前的键tag相匹配。\n # 说明当前值为tag的节点属于已经存在的一个人。\n # 注意：\n # 注意：\n \"\"\"\n key = grouped_keys[col] # grouped_ksys[col]是之前已检测到的人的键tag , 其与当前的tag是最佳匹配。 \n joint_dict[key][idx] = joints[row] # joints[row]是当前的n个节点的第row个节点的joint ，将其添加到joint_dict[前tag][第idx类节点]\n tag_dict[key].append(tags[row]) # tags[row]是当前的n个节点的第row个节点的tag ，将其添加到tag_dict[前tag] \n else: \n \"\"\"\n # 注意：\n # 注意：\n # 注意：\n # 当当前类别的某一节点的tag与已存在的人的代表tag(即：已存在的字典键tag)都不匹配时，\n # 说明：当前出现的不能匹配tag值表明了一个新的人体出现，\n # 所以，需要更新旧的字典，添加新的键tag，并将该节点(即该人体)的joints和tagsdian加入该键值中。\n # 注意：\n # 注意：\n \"\"\" \n key = tags[row][0]\n joint_dict.setdefault(key, np.copy(default_))[idx] = \\\n joints[row]\n tag_dict[key] = [tags[row]]\n\n \"\"\"\n ####################################################################################################################################\n # 最终，\n # 得到该幅图片的所有检测到的一个一个单独的人体肢体节点集合。 \n # joint_dict:{tag1:array(x1,5),tag2:array(x2,5),...,tag_i:array(xi,5)}\n # 其中，有几个人体就有几个tag键，并且每个人体出现的关节点数也是不相同的，即每个\"x\"的数值是不定的，x在(1-->17)之间。\n # 注意：\n # 注意：\n # 注意：这里的idx不是一个连续的数值，每一类的节点都有对应的idx，并且初始化的数组default_=np.zeros(17,5)！！！！！！！！！！！！！！！\n # 注意：因此，最后的joint_dict中的数组array是有全零行的；最终的每个人体的数组shape=(17,5)！！！！！！！！！！！！！！！！！！！！！！\n # 注意：\n # 注意：\n ------------------------------------------------------------------------------------------------------------------------------------\n # 其中，tag_dict和joint_dict是相对应的，joint_dict包含tag_dict , \n # tag_dict:{tag1:[array(tag11),..,array(tag_x1)],tag2:[array(tag22),..,array(tag_x2)],....,tag_i:[array(tagii),..,array(tag_xi)]}\n #####################################################################################################################################\n \"\"\"\n\n ans = np.array([joint_dict[i] for i in joint_dict]).astype(np.float32)\n # ans.shape=(人体数目，17，5)\n print('ans.shape={}'.format(ans.shape))\n return ans\n\n\nclass Params(object):\n def __init__(self, cfg):\n self.num_joints = cfg.DATASET.NUM_JOINTS\n self.max_num_people = cfg.DATASET.MAX_NUM_PEOPLE # 30\n\n self.detection_threshold = cfg.TEST.DETECTION_THRESHOLD\n self.tag_threshold = cfg.TEST.TAG_THRESHOLD\n self.use_detection_val = cfg.TEST.USE_DETECTION_VAL\n self.ignore_too_much = cfg.TEST.IGNORE_TOO_MUCH\n\n if cfg.DATASET.WITH_CENTER and cfg.TEST.IGNORE_CENTER:\n self.num_joints -= 1\n\n if cfg.DATASET.WITH_CENTER and not cfg.TEST.IGNORE_CENTER:\n self.joint_order = [\n i-1 for i in [18, 1, 2, 3, 4, 5, 6, 7, 12, 13, 8, 9, 10, 11, 14, 15, 16, 17]\n ]\n else:\n self.joint_order = [\n i-1 for i in [1, 2, 3, 4, 5, 6, 7, 12, 13, 8, 9, 10, 11, 14, 15, 16, 17]\n ]\n\n\nclass HeatmapParser(object):\n def __init__(self, cfg):\n self.params = Params(cfg)\n self.tag_per_joint = cfg.MODEL.TAG_PER_JOINT\n self.pool = torch.nn.MaxPool2d(\n cfg.TEST.NMS_KERNEL, 1, cfg.TEST.NMS_PADDING\n )\n\n def nms(self, det):\n \"\"\"\n # # 对热力图进行最大池化torch.nn.MaxPool2d(5,1,2)\n \"\"\"\n maxm = self.pool(det)\n \"\"\"\n # 挑选出最大值位置，maxm在该处值为1\n \"\"\" \n maxm = torch.eq(maxm, det).float()\n \"\"\"\n # 将热力图det中的极大值保留，去除非极大值\n \"\"\"\n det = det * maxm\n return det\n\n def match(self, tag_k, loc_k, val_k):\n # tag_k.shape=(1,17,30,2)\n # loc_k.shape=(1,17,30,2)二维坐标(x,y)\n # val_k.shape=(1,17,30)\n match = lambda x: match_by_tag(x, self.params)\n \"\"\"\n # zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象 \n # 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同\n \"\"\"\n \"\"\"\n # match函数返回该幅图片的所有检测到的一个一个单独的人体肢体节点集合。 \n # joint_dict:{tag1:array(x1,5),tag2:array(x2,5),...,tag_i:array(xi,5)}\n # 其中，有几个人体就有几个tag键，并且每个人体出现的关节点数也是不相同的，所以每个人体对应的array(17,5)中的“一些行是全零行”。\n # 接着再将其转换为numpy数组ans,ans.shape=(人体数，17，5),其中ans.shape[0]等于检测到的人体数。\n # 最后，再将其第0维的每个array(17，5)变为list列表元素。\n ################################################################\n\n \"\"\"\n return list(map(match, zip(tag_k, loc_k, val_k)))\n\n\n\n \"\"\"\n #############################################\n # tensor张量：热力图det.shape=(1,17,h,w)\n # tensor张量：tag图tag.shape=(1,17,h,w,2)\n #############################################\n \"\"\"\n def top_k(self, det, tag):\n # det = torch.Tensor(det, requires_grad=False)\n # tag = torch.Tensor(tag, requires_grad=False)\n\n \"\"\"\n ##################################\n # 对热力图进行NMS非极大值抑制，\n # 通过最大池化操作，找到极大值位置，\n # 保留热力图中的极大值，去除非极大值 \n ##################################\n \"\"\"\n det = self.nms(det)\n num_images = det.size(0) # 1\n num_joints = det.size(1) # 17\n h = det.size(2) # 512\n w = det.size(3) # 512\n\n \"\"\"\n #######################################\n # 将每个节点的二维(h,w)热力图展开为一维 \n # det.shape=(1,17,262144)\n #######################################\n \"\"\"\n det = det.view(num_images, num_joints, -1) # shape=(1,17,262144)\n\n \"\"\"\n ###########################################################################\n # topk:沿给定dim=2维度返回输入张量input中 k=30 个最大值。\n # 如果不指定dim，则默认为input的最后一维,\n # 返回一个元组 (values,indices)，其中indices是原始输入张量input中测元素下标\n ##########################################################################\n # 得到每个节点的前30个最大值，及其对应的下标\n # val_k.shape=(1,17,30)\n # ind.shape=(1,17,30) \n # ind为“一维坐标值”\n ############################################\n \"\"\"\n val_k, ind = det.topk(self.params.max_num_people, dim=2) # 得到每个节点的前30个最大值，及其对应位置一维坐标\n\n \"\"\"\n ###################################################\n # 将tag.shape=(1,17,512,512,2) ---> (1,17,262144,2)\n ###################################################\n \"\"\"\n tag = tag.view(tag.size(0), tag.size(1), w*h, -1)\n\n if not self.tag_per_joint: # not True\n tag = tag.expand(-1, self.params.num_joints, -1, -1)\n\n \"\"\"\n ######################################################################\n # torch.gather(input,dim,index),从原tensor中获取指定dim和指定index的数据,\n # 在tag图中索取热力图中前30个人每个节点位置对应的tag值\n # tag_k.shape=(1,17,30,2)\n ######################################################################\n \"\"\"\n tag_k = torch.stack(\n [\n torch.gather(tag[:, :, :, i], 2, ind)\n for i in range(tag.size(3))\n ],\n dim=3\n )\n\n \"\"\"\n ################################\n # 将“一维坐标ind”转换为二维坐标(x,y)\n # ind.shape=(1,17,30)\n # --->\n # ind_k.shape=(1,17,30,2)\n ################################\n \"\"\"\n x = ind % w\n y = (ind / w).long() # self.long() is equivalent to self.to(torch.int64)\n ind_k = torch.stack((x, y), dim=3) # ind_k.shape=(1,17,30,2)\n\n \"\"\"\n ####################################\n # tag_k.shape=(1,17,30,2)\n # ind_k.shape=(1,17,30,2)二维坐标(x,y)\n # val_k.shape=(1,17,30)\n ####################################\n \"\"\"\n ans = {\n 'tag_k': tag_k.cpu().numpy(),\n 'loc_k': ind_k.cpu().numpy(),\n 'val_k': val_k.cpu().numpy()\n }\n\n return ans\n\n def adjust(self, ans, det):\n # ans为列表，图片batch_size数目len(ans)=1 ，ans=[array(num_people，17，5),]\n for batch_id, peoples in enumerate(ans): \n # 对一张图片中的所有人 \n # peoples.shape=(num_people,17,5)\n for people_id, people in enumerate(peoples):\n # people.shape=(17,5) \n for joint_id, joint in enumerate(people):\n # joint.shape=(5,) , 二维节点坐标(x,y) + 一维热图value值 + 二维(tag,tag')值\n if joint[2] > 0:\n # 该节点在对应的热力图中的坐标\n y, x = joint[0:2]\n xx, yy = int(x), int(y)\n # print(batch_id, joint_id, det[batch_id].shape)\n # 热力图det.shape=(1,17,h,w) \n # 该节点所在的热力图tmp\n # tmp.shape=(h,w)\n tmp = det[batch_id][joint_id]\n\n # 微调该节点的y坐标\n if tmp[xx, min(yy+1, tmp.shape[1]-1)] > tmp[xx, max(yy-1, 0)]:\n y += 0.25\n else:\n y -= 0.25\n\n # 微调该节点的x坐标 \n if tmp[min(xx+1, tmp.shape[0]-1), yy] > tmp[max(0, xx-1), yy]:\n x += 0.25\n else:\n x -= 0.25\n # 更新节点坐标(x,y)\n ans[batch_id][people_id, joint_id, 0:2] = (y+0.5, x+0.5)\n return ans\n\n def refine(self, det, tag, keypoints):\n \"\"\"\n Given initial keypoint predictions, we identify missing joints\n :param det: numpy.ndarray of size (17, 128, 128)\n :param tag: numpy.ndarray of size (17, 128, 128) if not flip\n :param keypoints: numpy.ndarray of size (17, 4) if not flip, last dim is (x, y, det score, tag score)\n :return: \n \"\"\"\n if len(tag.shape) == 3:\n # tag shape: (17, 128, 128, 1)\n tag = tag[:, :, :, None]\n\n tags = []\n for i in range(keypoints.shape[0]):\n if keypoints[i, 2] > 0:\n # save tag value of detected keypoint\n x, y = keypoints[i][:2].astype(np.int32)\n tags.append(tag[i, y, x])\n\n # mean tag of current detected people\n prev_tag = np.mean(tags, axis=0)\n ans = []\n\n for i in range(keypoints.shape[0]):\n # score of joints i at all position\n tmp = det[i, :, :]\n # distance of all tag values with mean tag of current detected people\n tt = (((tag[i, :, :] - prev_tag[None, None, :]) ** 2).sum(axis=2) ** 0.5)\n tmp2 = tmp - np.round(tt)\n\n # find maximum position\n y, x = np.unravel_index(np.argmax(tmp2), tmp.shape)\n xx = x\n yy = y\n # detection score at maximum position\n val = tmp[y, x]\n # offset by 0.5\n x += 0.5\n y += 0.5\n\n # add a quarter offset\n if tmp[yy, min(xx + 1, tmp.shape[1] - 1)] > tmp[yy, max(xx - 1, 0)]:\n x += 0.25\n else:\n x -= 0.25\n\n if tmp[min(yy + 1, tmp.shape[0] - 1), xx] > tmp[max(0, yy - 1), xx]:\n y += 0.25\n else:\n y -= 0.25\n\n ans.append((x, y, val))\n ans = np.array(ans)\n\n if ans is not None:\n for i in range(det.shape[0]):\n # add keypoint if it is not detected\n if ans[i, 2] > 0 and keypoints[i, 2] == 0:\n # if ans[i, 2] > 0.01 and keypoints[i, 2] == 0:\n keypoints[i, :2] = ans[i, :2]\n keypoints[i, 2] = ans[i, 2]\n\n return keypoints\n\n \n \"\"\"\n #############################################\n # tensor张量：热力图det.shape=(1,17,h,w)\n # tensor张量：tag图tag.shape=(1,17,h,w,2)\n #############################################\n \"\"\"\n def parse(self, det, tag, adjust=True, refine=True):\n \"\"\"\n ####################################\n topk返回值：\n # tag_k.shape=(1,17,30,2)\n # ind_k.shape=(1,17,30,2)二维坐标(x,y)\n # val_k.shape=(1,17,30)\n ####################################\n match返回值：\n # ans为列表，图片batch_size数目len(ans)=1\n # ans=[array(num_people,17,5),] ，一张图有num_people个人 ，每个人体对应一个17*5的array数组。 \n #######################################################################################\n \"\"\"\n # ans为列表，图片batch_size数目len(ans)=1 ，ans=[array(num_people，17，5),]\n ans = self.match(**self.top_k(det, tag))\n\n if adjust:\n # 微调整每个节点的(x,y)坐标\n ans = self.adjust(ans, det)\n\n\n \"\"\"\n 求一个人的所有17节点的热图值的均值，\n 并将每个人的热图均值加入到scores列表中。\n \"\"\"\n # ans[0]是一个numpy数组，ans[0]=array(num_people,17,5)\n # len(scores)=num_people\n # scores=[ heatpoint1,heatpoint2,...,heatpoint_numpeople ]\n scores = [i[:, 2].mean() for i in ans[0]]\n\n if refine:\n ans = ans[0]\n # for every detected person\n for i in range(len(ans)):\n det_numpy = det[0].cpu().numpy()\n tag_numpy = tag[0].cpu().numpy()\n if not self.tag_per_joint: # self.tag_per_joint=True\n tag_numpy = np.tile(\n tag_numpy, (self.params.num_joints, 1, 1, 1)\n )\n ans[i] = self.refine(det_numpy, tag_numpy, ans[i])\n ans = [ans]\n\n \"\"\"\n ##################################\n ans = [ans]\n 得到ans=[ array(num_people,17,5),]\n ##################################\n len(scores)=num_people\n scores=[ heatpoint1,heatpoint2,...,heatpoint_numpeople ]\n ##########################################################\n \"\"\"\n return ans, scores\n\n\n\n\n\n", "meta": {"hexsha": "c49ff533e83dcb24c81dd3e51b434b0e4029587a", "size": 23830, "ext": "py", "lang": "Python", "max_stars_repo_path": "lib/core/group.py", "max_stars_repo_name": "MingheWang/HigherHRNet-Human-Pose-Estimation", "max_stars_repo_head_hexsha": "65bf3a5654999d5349c1103e43334118bda136c7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-10-17T19:01:30.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-17T19:01:30.000Z", "max_issues_repo_path": "lib/core/group.py", "max_issues_repo_name": "MingheWang/HigherHRNet-Human-Pose-Estimation", "max_issues_repo_head_hexsha": "65bf3a5654999d5349c1103e43334118bda136c7", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lib/core/group.py", "max_forks_repo_name": "MingheWang/HigherHRNet-Human-Pose-Estimation", "max_forks_repo_head_hexsha": "65bf3a5654999d5349c1103e43334118bda136c7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.5272108844, "max_line_length": 508, "alphanum_fraction": 0.4315568611, "include": true, "reason": "import numpy", "num_tokens": 7697, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.3738758227716966, "lm_q1q2_score": 0.19131846660970886}} {"text": "# -*- coding: utf-8 -*-\n\"\"\"\nContains helper code for running spatial nulls models\n\"\"\"\n\nfrom pathlib import Path\nimport warnings\n\nimport numpy as np\nfrom scipy import optimize, spatial\ntry: # scipy >= 1.8.0\n from scipy.ndimage._measurements import _stats, labeled_comprehension\nexcept ImportError: # scipy < 1.8.0\n from scipy.ndimage.measurements import _stats, labeled_comprehension\nfrom sklearn.utils.validation import check_random_state\n\nfrom neuromaps.images import load_gifti, PARCIGNORE\nfrom neuromaps.points import _geodesic_parcel_centroid\n\n\ndef load_spins(fn, n_perm=None):\n \"\"\"\n Loads spins from `fn`\n\n Parameters\n ----------\n fn : os.PathLike\n Filepath to file containing spins to load\n n_perm : int, optional\n Number of spins to retain (i.e., subset data)\n\n Returns\n -------\n spins : (N, P) array_like\n Loaded spins\n \"\"\"\n\n try:\n npy = Path(fn).with_suffix('.npy')\n if npy.exists():\n spins = np.load(npy, allow_pickle=False, mmap_mode='c')\n else:\n spins = np.loadtxt(fn, delimiter=',', dtype='int32')\n except TypeError:\n spins = np.asarray(fn, dtype='int32')\n\n if n_perm is not None:\n spins = spins[..., :n_perm]\n\n return spins\n\n\ndef get_parcel_centroids(surfaces, parcellation=None, method='surface',\n drop=None):\n \"\"\"\n Returns vertex coordinates corresponding to parcel centroids\n\n If `parcellation` is not specified then returned `centroids` are vertex\n coordinates of `surfaces`\n\n Parameters\n ----------\n surfaces : (2,) list-of-str\n Surfaces on which to compute parcel centroids; generally spherical\n surfaces are recommended. Surfaces should be (left, right) hemisphere.\n If no parcellations are provided then returned `centroids` represent\n all vertices in `surfaces`\n parcellation : (2,) list-of-str, optional\n Path to GIFTI label files containing labels of parcels on the\n (left, right) hemisphere. If not specified then vertex coordinates from\n `surfaces` are returned instead. Default: None\n method : {'average', 'surface', 'geodesic'}, optional\n Method for calculation of parcel centroid. See Notes for more\n information. Default: 'surface'\n drop : list, optional\n Specifies regions in `parcellation` for which the parcel centroid\n should not be calculated. If not specified, centroids for parcels\n defined in `PARCIGNORE` are not calculated. Default: None\n\n Returns\n -------\n centroids : (N, 3) numpy.ndarray\n Coordinates of parcel centroids. If `parcellation` is not specified\n these are simply the vertex coordinates\n hemiid : (N,) numpy.ndarray\n Array denoting hemisphere designation of coordinates in `centroids`,\n where `hemiid=0` denotes the left and `hemiid=1` the right hemisphere\n\n Notes\n -----\n The following methods can be used for finding parcel centroids:\n\n 1. ``method='average'``\n\n Uses the arithmetic mean of the coordinates for the vertices in each\n parcel. Note that in this case the calculated centroids will not act\n actually fall on the surface of `surf`.\n\n 2. ``method='surface'``\n\n Calculates the 'average' coordinates and then finds the closest vertex\n on `surf`, where closest is defined as the vertex with the minimum\n Euclidean distance.\n\n 3. ``method='geodesic'``\n\n Uses the coordinates of the vertex with the minimum average geodesic\n distance to all other vertices in the parcel. Note that this is slightly\n more time-consuming than the other two methods, especially for\n high-resolution meshes.\n \"\"\"\n\n methods = ['average', 'surface', 'geodesic']\n if method not in methods:\n raise ValueError('Provided method for centroid calculation {} is '\n 'invalid. Must be one of {}'.format(methods, methods))\n\n if drop is None:\n drop = PARCIGNORE\n if parcellation is None:\n parcellation = (None, None)\n\n centroids, hemiid = [], []\n for n, (parc, surf) in enumerate(zip(parcellation, surfaces)):\n vertices, faces = load_gifti(surf).agg_data()\n if parc is not None:\n labels = load_gifti(parc).agg_data()\n labeltable = parc.labeltable.get_labels_as_dict()\n\n for lab in np.unique(labels):\n if labeltable.get(lab) in drop:\n continue\n\n mask = labels == lab\n if method in ('average', 'surface'):\n roi = np.atleast_2d(vertices[mask].mean(axis=0))\n if method == 'surface': # find closest vertex on surf\n idx = np.argmin(spatial.distance_matrix(vertices, roi),\n axis=0)[0]\n roi = vertices[idx]\n elif method == 'geodesic':\n inds, = np.where(mask)\n roi = _geodesic_parcel_centroid(vertices, faces, inds)\n\n centroids.append(roi)\n hemiid.append(n)\n else:\n centroids.append(vertices)\n hemiid.extend([n] * len(vertices))\n\n return np.row_stack(centroids), np.asarray(hemiid)\n\n\ndef _gen_rotation(seed=None):\n \"\"\"\n Generates random matrix for rotating spherical coordinates\n\n Parameters\n ----------\n seed : {int, np.random.RandomState instance, None}, optional\n Seed for random number generation\n\n Returns\n -------\n rotate_{l,r} : (3, 3) numpy.ndarray\n Rotations for left and right hemisphere coordinates, respectively\n \"\"\"\n\n rs = check_random_state(seed)\n\n # for reflecting across Y-Z plane\n reflect = np.array([[-1, 0, 0], [0, 1, 0], [0, 0, 1]])\n\n # generate rotation for left\n rotate_l, temp = np.linalg.qr(rs.normal(size=(3, 3)))\n rotate_l = rotate_l @ np.diag(np.sign(np.diag(temp)))\n if np.linalg.det(rotate_l) < 0:\n rotate_l[:, 0] = -rotate_l[:, 0]\n\n # reflect the left rotation across Y-Z plane\n rotate_r = reflect @ rotate_l @ reflect\n\n return rotate_l, rotate_r\n\n\ndef gen_spinsamples(coords, hemiid, n_rotate=1000, check_duplicates=True,\n method='original', seed=None, verbose=False,\n return_cost=False):\n \"\"\"\n Returns a resampling array for `coords` obtained from rotations / spins\n\n Using the method initially proposed in [ST1]_ (and later modified + updated\n based on findings in [ST2]_ and [ST3]_), this function applies random\n rotations to the user-supplied `coords` in order to generate a resampling\n array that preserves its spatial embedding. Rotations are generated for one\n hemisphere and mirrored for the other (see `hemiid` for more information).\n\n Due to irregular sampling of `coords` and the randomness of the rotations\n it is possible that some \"rotations\" may resample with replacement (i.e.,\n will not be a true permutation). The likelihood of this can be reduced by\n either increasing the sampling density of `coords` or changing the\n ``method`` parameter (see Notes for more information on the latter).\n\n Parameters\n ----------\n coords : (N, 3) array_like\n X, Y, Z coordinates of `N` nodes/parcels/regions/vertices defined on a\n sphere\n hemiid : (N,) array_like\n Array denoting hemisphere designation of coordinates in `coords`, where\n values should be {0, 1} denoting the different hemispheres. Rotations\n are generated for one hemisphere and mirrored across the y-axis for the\n other hemisphere.\n n_rotate : int, optional\n Number of rotations to generate. Default: 1000\n check_duplicates : bool, optional\n Whether to check for and attempt to avoid duplicate resamplings. A\n warnings will be raised if duplicates cannot be avoided. Setting to\n True may increase the runtime of this function! Default: True\n method : {'original', 'vasa', 'hungarian'}, optional\n Method by which to match non- and rotated coordinates. Specifying\n 'original' will use the method described in [ST1]_. Specfying 'vasa'\n will use the method described in [ST4]_. Specfying 'hungarian' will use\n the Hungarian algorithm to minimize the global cost of reassignment\n (will dramatically increase runtime). Default: 'original'\n seed : {int, np.random.RandomState instance, None}, optional\n Seed for random number generation. Default: None\n verbose : bool, optional\n Whether to print occasional status messages. Default: False\n return_cost : bool, optional\n Whether to return cost array (specified as Euclidean distance) for each\n coordinate for each rotation Default: True\n\n Returns\n -------\n spinsamples : (N, `n_rotate`) numpy.ndarray\n Resampling matrix to use in permuting data based on supplied `coords`.\n cost : (N, `n_rotate`,) numpy.ndarray\n Cost (specified as Euclidean distance) of re-assigning each coordinate\n for every rotation in `spinsamples`. Only provided if `return_cost` is\n True.\n\n Notes\n -----\n By default, this function uses the minimum Euclidean distance between the\n original coordinates and the new, rotated coordinates to generate a\n resampling array after each spin. Unfortunately, this can (with some\n frequency) lead to multiple coordinates being re-assigned the same value:\n\n >>> from neuromaps.nulls.spins import gen_spinsamples\n >>> coords = [[0, 0, 1], [1, 0, 0], [0, 0, 1], [1, 0, 0]]\n >>> hemi = [0, 0, 1, 1]\n >>> gen_spinsamples(coords, hemi, n_rotate=1, seed=1,\n ... check_duplicates=False)\n array([[0],\n [0],\n [2],\n [3]])\n\n While this is reasonable in most circumstances, if you feel incredibly\n strongly about having a perfect \"permutation\" (i.e., all indices appear\n once and exactly once in the resampling), you can set the ``method``\n parameter to either 'vasa' or 'hungarian':\n\n >>> gen_spinsamples(coords, hemi, n_rotate=1, seed=1,\n ... method='vasa', check_duplicates=False)\n array([[1],\n [0],\n [2],\n [3]])\n >>> gen_spinsamples(coords, hemi, n_rotate=1, seed=1,\n ... method='hungarian', check_duplicates=False)\n array([[0],\n [1],\n [2],\n [3]])\n\n Note that setting this parameter may increase the runtime of the function\n (especially for `method='hungarian'`). Refer to [ST1]_ for information on\n why the default suffices in most cases.\n\n For the original MATLAB implementation of this function refer to [ST5]_.\n\n References\n ----------\n .. [ST1] Alexander-Bloch, A., Shou, H., Liu, S., Satterthwaite, T. D.,\n Glahn, D. C., Shinohara, R. T., Vandekar, S. N., & Raznahan, A. (2018).\n On testing for spatial correspondence between maps of human brain\n structure and function. NeuroImage, 178, 540-51.\n\n .. [ST2] Blaser, R., & Fryzlewicz, P. (2016). Random Rotation Ensembles.\n Journal of Machine Learning Research, 17(4), 1–26.\n\n .. [ST3] Lefèvre, J., Pepe, A., Muscato, J., De Guio, F., Girard, N.,\n Auzias, G., & Germanaud, D. (2018). SPANOL (SPectral ANalysis of Lobes):\n A Spectral Clustering Framework for Individual and Group Parcellation of\n Cortical Surfaces in Lobes. Frontiers in Neuroscience, 12, 354.\n\n .. [ST4] Váša, F., Seidlitz, J., Romero-Garcia, R., Whitaker, K. J.,\n Rosenthal, G., Vértes, P. E., ... & Jones, P. B. (2018). Adolescent\n tuning of association cortex in human structural brain networks.\n Cerebral Cortex, 28(1), 281-294.\n\n .. [ST5] https://github.com/spin-test/spin-test\n \"\"\"\n\n methods = ['original', 'vasa', 'hungarian']\n if method not in methods:\n raise ValueError('Provided method \"{}\" invalid. Must be one of {}.'\n .format(method, methods))\n\n seed = check_random_state(seed)\n\n coords = np.asanyarray(coords)\n hemiid = np.squeeze(np.asanyarray(hemiid, dtype='int8'))\n\n # check supplied coordinate shape\n if coords.shape[-1] != 3 or coords.squeeze().ndim != 2:\n raise ValueError('Provided `coords` must be of shape (N, 3), not {}'\n .format(coords.shape))\n\n # ensure hemisphere designation array is correct\n if hemiid.ndim != 1:\n raise ValueError('Provided `hemiid` array must be one-dimensional.')\n if len(coords) != len(hemiid):\n raise ValueError('Provided `coords` and `hemiid` must have the same '\n 'length. Provided lengths: coords = {}, hemiid = {}'\n .format(len(coords), len(hemiid)))\n if np.max(hemiid) > 1 or np.min(hemiid) < 0:\n raise ValueError('Hemiid must have values in {0, 1} denoting left and '\n 'right hemisphere coordinates, respectively. '\n + 'Provided array contains values: {}'\n .format(np.unique(hemiid)))\n\n # empty array to store resampling indices\n spinsamples = np.zeros((len(coords), n_rotate), dtype=int)\n cost = np.zeros((len(coords), n_rotate))\n inds = np.arange(len(coords), dtype=int)\n\n # generate rotations and resampling array!\n msg, warned = '', False\n for n in range(n_rotate):\n count, duplicated = 0, True\n\n if verbose:\n msg = 'Generating spin {:>5} of {:>5}'.format(n, n_rotate)\n print(msg, end='\\r', flush=True)\n\n while duplicated and count < 500:\n count, duplicated = count + 1, False\n resampled = np.zeros(len(coords), dtype='int32')\n\n # rotate each hemisphere separately\n for h, rot in enumerate(_gen_rotation(seed=seed)):\n hinds = (hemiid == h)\n coor = coords[hinds]\n if len(coor) == 0:\n continue\n\n # if we need an \"exact\" mapping (i.e., each node needs to be\n # assigned EXACTLY once) then we have to calculate the full\n # distance matrix which is a nightmare with respect to memory\n # for anything that isn't parcellated data.\n # that is, don't do this with vertex coordinates!\n if method == 'vasa':\n dist = spatial.distance_matrix(coor, coor @ rot)\n # min of max a la Vasa et al., 2018\n col = np.zeros(len(coor), dtype='int32')\n for r in range(len(dist)):\n # find parcel whose closest neighbor is farthest away\n # overall; assign to that\n row = dist.min(axis=1).argmax()\n col[row] = dist[row].argmin()\n cost[inds[hinds][row], n] = dist[row, col[row]]\n # set to -inf and inf so they can't be assigned again\n dist[row] = -np.inf\n dist[:, col[row]] = np.inf\n # optimization of total cost using Hungarian algorithm. this\n # may result in certain parcels having higher cost than with\n # `method='vasa'` but should always result in the total cost\n # being lower #tradeoffs\n elif method == 'hungarian':\n dist = spatial.distance_matrix(coor, coor @ rot)\n row, col = optimize.linear_sum_assignment(dist)\n cost[hinds, n] = dist[row, col]\n # if nodes can be assigned multiple targets, we can simply use\n # the absolute minimum of the distances (no optimization\n # required) which is _much_ lighter on memory\n # huge thanks to https://stackoverflow.com/a/47779290 for this\n # memory-efficient method\n elif method == 'original':\n dist, col = spatial.cKDTree(coor @ rot).query(coor, 1)\n cost[hinds, n] = dist\n\n resampled[hinds] = inds[hinds][col]\n\n # if we want to check for duplicates ensure that we don't have any\n if check_duplicates:\n if np.any(np.all(resampled[:, None] == spinsamples[:, :n], 0)):\n duplicated = True\n # if our \"spin\" is identical to the input then that's no good\n elif np.all(resampled == inds):\n duplicated = True\n\n # if we broke out because we tried 500 rotations and couldn't generate\n # a new one, warn that we're using duplicate rotations and give up.\n # this should only be triggered if check_duplicates is set to True\n if count == 500 and not warned:\n warnings.warn('Duplicate rotations used. Check resampling array '\n 'to determine real number of unique permutations.')\n warned = True\n\n spinsamples[:, n] = resampled\n\n if verbose:\n print(' ' * len(msg) + '\\b' * len(msg), end='', flush=True)\n\n if return_cost:\n return spinsamples, cost\n\n return spinsamples\n\n\ndef spin_parcels(surfaces, parcellation, method='surface', n_rotate=1000,\n spins=None, verbose=False, **kwargs):\n \"\"\"\n Rotates parcels in `parcellation` and re-assigns based on maximum overlap\n\n Vertex labels are rotated and a new label is assigned to each *parcel*\n based on the region maximally overlapping with its boundaries.\n\n Parameters\n ----------\n surfaces : (2,) list-of-str\n Surfaces to use for rotating parcels; generally spherical surfaces\n are recommended. Surfaces should be (left, right) hemisphere\n parcellation : (2,) list-of-str, optional\n Path to GIFTI label files containing parcel labels on the (left, right)\n hemisphere of `surfaces`\n n_rotate : int, optional\n Number of rotations to generate. Default: 1000\n spins : array_like, optional\n Pre-computed spins to use instead of generating them on the fly. If not\n provided will use other provided parameters to create them. Default:\n None\n seed : {int, np.random.RandomState instance, None}, optional\n Seed for random number generation. Default: None\n verbose : bool, optional\n Whether to print occasional status messages. Default: False\n return_cost : bool, optional\n Whether to return cost array (specified as Euclidean distance) for each\n coordinate for each rotation. Default: True\n kwargs : key-value pairs\n Keyword arguments passed to :func:`~.gen_spinsamples`\n\n Returns\n -------\n spinsamples : (N, `n_rotate`) numpy.ndarray\n Resampling matrix to use in permuting data parcellated with labels from\n `parcellation`, where `N` is the number of parcels. Indices of -1\n indicate that the parcel was completely encompassed by regions in\n `drop` and should be ignored.\n \"\"\"\n\n def overlap(vals):\n \"\"\" Returns most common positive value in `vals`; -1 if all negative\n \"\"\"\n vals = np.asarray(vals)\n vals, counts = np.unique(vals[vals > 0], return_counts=True)\n try:\n return vals[counts.argmax()] - 1\n except ValueError:\n return -1\n\n # get vertex-level labels (set drop labels to - values)\n vertices = np.hstack([\n load_gifti(parc).agg_data() for parc in parcellation\n ])\n labels = np.unique(vertices)\n mask = labels != 0\n\n # get spins + cost (if requested)\n if spins is None:\n coords, hemiid = get_parcel_centroids(surfaces, method=method)\n spins = gen_spinsamples(coords, hemiid, n_rotate=n_rotate,\n verbose=verbose, **kwargs)\n if kwargs.get('return_cost'):\n spins, cost = spins\n spins = load_spins(spins)\n\n if len(vertices) != len(spins):\n raise ValueError('Provided annotation files have a different '\n 'number of vertices than the specified fsaverage '\n 'surface.\\n ANNOTATION: {} vertices\\n '\n 'FSAVERAGE: {} vertices'\n .format(len(vertices), len(spins)))\n\n # spin and assign regions based on max overlap\n regions = np.zeros((len(labels[mask]), n_rotate), dtype='int32')\n for n in range(n_rotate):\n if verbose:\n msg = f'Calculating parcel overlap: {n:>5}/{n_rotate}'\n print(msg, end='\\b' * len(msg), flush=True)\n regions[:, n] = labeled_comprehension(vertices[spins[:, n]], vertices,\n labels, overlap, int, -1)[mask]\n\n if kwargs.get('return_cost'):\n return regions, cost\n\n return regions\n\n\ndef parcels_to_vertices(data, parcellation):\n \"\"\"\n Projects parcellated `data` to vertices as defined by `parcellation`\n\n Parameters\n ----------\n data : (N,) numpy.ndarray\n Parcellated data to be projected to vertices\n parcellation : tuple-of-str or os.PathLike\n Filepaths to parcellation images to project `data` to vertices\n\n Reurns\n ------\n projected : numpy.ndarray\n Vertex-level data\n \"\"\"\n\n data = np.vstack(data).astype(float)\n vertices = np.hstack([\n load_gifti(parc).agg_data() for parc in parcellation\n ])\n expected = np.unique(vertices)[1:].size\n n_vert = vertices.shape[0]\n if expected != len(data):\n raise ValueError('Number of parcels in provided annotation files '\n 'differs from size of parcellated data array.\\n'\n ' EXPECTED: {} parcels\\n'\n ' RECEIVED: {} parcels'\n .format(expected, len(data)))\n\n projected = np.zeros((n_vert, data.shape[-1]), dtype=data.dtype)\n n_vert = 0\n for parc in parcellation:\n labels = load_gifti(parc).agg_data().astype('int')\n currdata = np.append([[np.nan]], data, axis=0)\n projected[n_vert:n_vert + len(labels), :] = currdata[labels, :]\n n_vert += len(labels)\n\n return np.squeeze(projected)\n\n\ndef vertices_to_parcels(data, parcellation):\n \"\"\"\n Reduces vertex-level `data` to parcels defined by `parcellation`\n\n Takes average of vertices within each parcel (excluding NaN values).\n Assigns NaN to parcels for which *all* vertices are NaN.\n\n Parameters\n ----------\n data : (N,) numpy.ndarray\n Vertex-level data to be reduced to parcels\n parcellation : tuple-of-str or os.PathLike\n Filepaths to parcellation images to parcellate `data`\n\n Reurns\n ------\n reduced : numpy.ndarray\n Parcellated `data`\n \"\"\"\n\n data = np.vstack(data)\n vertices = np.hstack([\n load_gifti(parc).agg_data() for parc in parcellation\n ])\n n_parc = np.unique(vertices).size\n expected = vertices.shape[0]\n if expected != len(data):\n raise ValueError('Number of vertices in provided annotation files '\n 'differs from size of vertex-level data array.\\n'\n ' EXPECTED: {} vertices\\n'\n ' RECEIVED: {} vertices'\n .format(expected, len(data)))\n\n numerator = np.zeros((n_parc, data.shape[-1]), dtype=data.dtype)\n denominator = np.zeros((n_parc, data.shape[-1]), dtype=data.dtype)\n start = end = 0\n for parc in parcellation:\n labels = load_gifti(parc).agg_data().astype('int')\n indices = np.unique(labels)\n end += len(labels)\n\n for idx in range(data.shape[-1]):\n currdata = np.squeeze(data[start:end, idx])\n counts, sums = _stats(np.nan_to_num(currdata), labels, indices)\n _, nacounts = _stats(np.isnan(currdata), labels, indices)\n counts = (np.asanyarray(counts, dtype=float)\n - np.asanyarray(nacounts, dtype=float))\n\n numerator[indices, idx] += sums\n denominator[indices, idx] += counts\n\n start = end\n\n with np.errstate(divide='ignore', invalid='ignore'):\n reduced = np.squeeze(numerator / denominator)[1:]\n\n return reduced\n\n\ndef spin_data(data, surfaces, parcellation, method='surface', n_rotate=1000,\n spins=None, verbose=False, **kwargs):\n \"\"\"\n Projects parcellated `data` to `surfaces`, rotates, and re-parcellates\n\n Projection of `data` to `surfaces` uses provided `parcellation` files.\n Re-parcellated data will not be exactly identical to original values due to\n re-averaging process. Parcels subsumed by regions in `drop` will be listed\n as NaN.\n\n Parameters\n ----------\n data : (N,) numpy.ndarray\n Parcellated data to be rotated. Parcels should be ordered by [left,\n right] hemisphere; ordering within hemisphere should correspond to the\n provided `parcellation` files.\n surfaces : (2,) list-of-str\n Surfaces to use for rotating parcels; generally spherical surfaces\n are recommended. Surfaces should be (left, right) hemisphere\n parcellation : (2,) list-of-str, optional\n Path to GIFTI label files containing parcel labels on the (left, right)\n hemisphere of `surfaces` mapping `data` to vertices in `surfaces`\n n_rotate : int, optional\n Number of rotations to generate. Default: 1000\n spins : array_like, optional\n Pre-computed spins to use instead of generating them on the fly. If not\n provided will use other provided parameters to create them. Default:\n None\n\n verbose : bool, optional\n Whether to print occasional status messages. Default: False\n kwargs : key-value pairs\n Keyword arguments passed to function used to generate rotations\n\n Returns\n -------\n rotated : (N, `n_rotate`) numpy.ndarray\n Rotated `data\n \"\"\"\n\n # get coordinates and hemisphere designation for spin generation\n vertices = parcels_to_vertices(data, parcellation)\n\n if spins is None:\n coords, hemiid = get_parcel_centroids(surfaces, method=method)\n spins = gen_spinsamples(coords, hemiid, n_rotate=n_rotate,\n verbose=verbose, **kwargs)\n if kwargs.get('return_cost'):\n spins, cost = spins\n spins = load_spins(spins)\n\n if len(vertices) != len(spins):\n raise ValueError('Provided parcellation files have a different '\n 'number of vertices than the specified surfaces.\\n'\n ' ANNOTATION: {} vertices\\n'\n ' FSAVERAGE: {} vertices'\n .format(len(vertices), len(spins)))\n\n spun = np.zeros(data.shape + (n_rotate,))\n for n in range(n_rotate):\n if verbose:\n msg = f'Reducing vertices to parcels: {n:>5}/{n_rotate}'\n print(msg, end='\\b' * len(msg), flush=True)\n spun[..., n] = vertices_to_parcels(vertices[spins[:, n]], parcellation)\n\n if verbose:\n print(' ' * len(msg) + '\\b' * len(msg), end='', flush=True)\n\n if kwargs.get('return_cost'):\n return spun, cost\n\n return spun\n", "meta": {"hexsha": "75e5a2eb4c4d95dac1a50cfa3debaa3d8940004c", "size": 27271, "ext": "py", "lang": "Python", "max_stars_repo_path": "neuromaps/nulls/spins.py", "max_stars_repo_name": "VinceBaz/neuromaps", "max_stars_repo_head_hexsha": "6758b53e127d1563fa06eb26bc5f08a4e24ae7e7", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "neuromaps/nulls/spins.py", "max_issues_repo_name": "VinceBaz/neuromaps", "max_issues_repo_head_hexsha": "6758b53e127d1563fa06eb26bc5f08a4e24ae7e7", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "neuromaps/nulls/spins.py", "max_forks_repo_name": "VinceBaz/neuromaps", "max_forks_repo_head_hexsha": "6758b53e127d1563fa06eb26bc5f08a4e24ae7e7", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.8116788321, "max_line_length": 79, "alphanum_fraction": 0.6110887023, "include": true, "reason": "import numpy,from scipy", "num_tokens": 6290, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.3738758227716966, "lm_q1q2_score": 0.19131846660970886}} {"text": "from pyscf import scf, dft, gto, ao2mo, df, lib, cc\nfrom pyscf.dft.numint import eval_ao, eval_rho\nfrom pyscf.dft.gen_grid import Grids\nfrom pyscf.pbc.tools.pyscf_ase import atoms_from_ase\nimport numpy as np\nimport logging\n\n\nCALC_TYPES = {\n 'RHF' : scf.hf.RHF,\n 'UHF' : scf.uhf.UHF,\n 'RKS' : dft.rks.RKS,\n 'UKS' : dft.uks.UKS,\n 'CCSD' : cc.ccsd.CCSD,\n 'UCCSD' : cc.uccsd.UCCSD\n}\n\nSCF_TYPES = {\n 'RHF' : scf.hf.RHF,\n 'ROHF' : scf.rohf.ROHF,\n 'UHF' : scf.uhf.UHF,\n 'RKS' : dft.RKS,\n 'UKS' : dft.UKS\n}\n\n########################################################\n# BASIC HELPER ROUTINES FOR RUNNING PYSCF CALCULATIONS #\n########################################################\n\ndef mol_from_ase(atoms, basis, spin=0, charge=0):\n \"\"\"\n Get a pyscf gto.Mole object from an ase Atoms object (atoms).\n Assign it the atomic basis set (basis).\n Return the Mole object.\n \"\"\"\n mol = gto.Mole()\n mol.atom = atoms_from_ase(atoms)\n mol.basis = basis\n mol.spin = spin\n mol.charge = charge\n mol.build()\n return mol\n\ndef setup_rks_calc(mol, xc, grid_level=3, vv10=False, **kwargs):\n \"\"\"\n Set up a PySCF RKS calculation with sensible defaults.\n \"\"\"\n rks = dft.RKS(mol)\n rks.xc = xc\n rks.grids.level = grid_level\n rks.grids.build()\n logging.warning('xc: {}, grid level: {}'.format(xc, grid_level))\n if vv10:\n logging.warning('Using VV10 in UKS setup')\n rks.nlc = 'VV10'\n if np.array([gto.charge(mol.atom_symbol(i)) <= 18 for i in range(mol.natm)]).all():\n rks.nlcgrids.prune = dft.gen_grid.sg1_prune\n else:\n rks.nlcgrids.prune = None\n rks.nlcgrids.level = 1\n return rks\n\ndef setup_uks_calc(mol, xc, grid_level=3, vv10=False, **kwargs):\n \"\"\"\n Set up a PySCF UKS calculation with sensible defaults.\n \"\"\"\n uks = dft.UKS(mol)\n uks.xc = xc\n uks.grids.level = grid_level\n uks.grids.build()\n logging.warning('xc: {}, grid level: {}'.format(xc, grid_level))\n if vv10:\n logging.warning('Using VV10 in UKS setup')\n uks.nlc = 'VV10'\n if np.array([gto.charge(mol.atom_symbol(i)) <= 18 for i in range(mol.natm)]).all():\n uks.nlcgrids.prune = dft.gen_grid.sg1_prune\n else:\n uks.nlcgrids.prune = None\n uks.nlcgrids.level = 1\n return uks\n\ndef run_scf(mol, calc_type, functional=None, remove_ld=False, dm0=None):\n \"\"\"\n Run an SCF calculation on a gto.Mole object (Mole)\n of a given calc_type in SCF_TYPES. Return the calc object.\n Note, if RKS or UKS is the calc_type, default functional is used.\n \"\"\"\n if not calc_type in SCF_TYPES:\n raise ValueError('Calculation type must be in {}'.format(list(SCF_TYPES.keys())))\n\n calc = SCF_TYPES[calc_type](mol)\n if remove_ld:\n logging.info(\"Removing linear dependence from overlap matrix\")\n calc = scf.addons.remove_linear_dep_(calc)\n if 'KS' in calc_type and functional is not None:\n calc.xc = functional\n if 'MN' in functional:\n logging.info('MN grid level 4')\n calc.grids.level = 4\n if functional == 'wB97M_V':\n logging.info('Using Specialized wB97M-V params')\n calc.nlc = 'VV10'\n calc.grids.prune = None\n calc.grids.level = 4\n if np.array([gto.charge(mol.atom_symbol(i)) <= 18 for i in range(mol.natm)]).all():\n calc.nlcgrids.prune = dft.gen_grid.sg1_prune\n else:\n calc.nlcgrids.prune = None\n calc.nlcgrids.level = 1\n\n calc.kernel(dm0 = dm0)\n return calc\n\ndef run_cc(hf):\n \"\"\"\n Run and return a restricted CCSD calculation on mol,\n with HF molecular orbital coefficients in the RHF object hf.\n \"\"\"\n if type(hf) == SCF_TYPES['RHF']:\n calc_cls = cc.CCSD\n elif type(hf) == SCF_TYPES['UHF']:\n calc_cls = cc.UCCSD\n else:\n raise NotImplementedError('HF type {} not supported'.format(type(hf)) +\\\n '\\nSupported Types: {}'.format(SCF_TYPES['RHF'], SCF_TYPES['UHF']))\n calc = calc_cls(hf)\n calc.kernel()\n return calc\n\n\n\n#############################################\n# HELPER FUNCTIONS FOR THE analyzers MODULE #\n#############################################\n\n\ndef get_grid(mol, level=3):\n \"\"\"\n Get the real-space grid of a molecule for numerical integration.\n \"\"\"\n grid = Grids(mol)\n grid.level = level\n grid.kernel()\n return grid\n\ndef get_ha_total(rdm1, eeint):\n return np.sum(np.sum(eeint * rdm1, axis=(2,3)) * rdm1)\n\ndef get_hf_coul_ex_total(mol, hf):\n rdm1 = hf.make_rdm1()\n jmat, kmat = hf.get_jk(mol, rdm1)\n return np.sum(jmat * rdm1) / 2, -np.sum(kmat * rdm1) / 4\n\ndef get_hf_coul_ex_total2(rdm1, jmat, kmat):\n if len(rdm1.shape) == 2:\n return np.sum(jmat * rdm1) / 2, -np.sum(kmat * rdm1) / 4\n else:\n return np.sum(jmat * np.sum(rdm1, axis=0)) / 2, -np.sum(kmat * rdm1) / 2\n\ndef get_hf_coul_ex_total_unrestricted(mol, hf):\n rdm1 = hf.make_rdm1()\n jmat, kmat = hf.get_jk(mol, rdm1)\n return np.sum(jmat * np.sum(rdm1, axis=0)) / 2, -np.sum(kmat * rdm1) / 2\n\ndef transform_basis_1e(mat, coeff):\n \"\"\"\n Transforms the 1-electron matrix mat into the basis\n described by coeff (with the basis vectors being the columns).\n To transform AO operator to MO operator, pass mo_coeff.\n To transform MO operator to AO operator, pass inv(mo_coeff).\n To transform AO density matrix to MO density matrix, pass inv(transpose(mo_coeff)).\n To transform MO density matrix to AO density matrix, pass transpose(mo_coeff).\n \"\"\"\n if len(coeff.shape) == 2:\n return np.matmul(coeff.transpose(), np.matmul(mat, coeff))\n else:\n if len(coeff) != 2 or len(mat) != 2:\n raise ValueError('Need two sets of orbitals, two mats for unrestricted case.')\n part0 = np.matmul(coeff[0].transpose(), np.matmul(mat[0], coeff[0]))\n part1 = np.matmul(coeff[1].transpose(), np.matmul(mat[1], coeff[1]))\n return np.array([part0, part1])\n\ndef make_rdm2_from_rdm1(rdm1):\n \"\"\"\n For an RHF calculation, return the 2-RDM from\n a given 1-RDM. Given D2(ijkl)=,\n and D(ij)=, then\n D2(ijkl) = D(ij) * D(kl) - 0.5 * D(lj) * D(ki)\n \"\"\"\n rdm1copy = rdm1.copy()\n part1 = np.einsum('ij,kl->ijkl', rdm1, rdm1copy)\n part2 = np.einsum('lj,ki->ijkl', rdm1, rdm1copy)\n return part1 - 0.5 * part2\n\ndef make_rdm2_from_rdm1_unrestricted(rdm1):\n \"\"\"\n For a UHF calculation, return the 2-RDM from\n a given 1-RDM. Given D2(ijkl)=,\n and D(ij)=, then:\n For like spin, D2(ijkl) = D(ij) * D(kl) - D(lj) * D(ki).\n For opposite spin, D2(ijkl) = D(ij) * D(kl)\n Return D(uu,ijkl), D(ud,ijkl), D(dd,ijkl)\n \"\"\"\n spinparts = []\n rdm1copy = rdm1.copy()\n for s in [0,1]:\n part1 = np.einsum('ij,kl->ijkl', rdm1[s], rdm1copy[s])\n part2 = np.einsum('lj,ki->ijkl', rdm1[s], rdm1copy[s])\n spinparts.append(part1 - part2)\n mixspinpart = np.einsum('ij,kl->ijkl', rdm1[0], rdm1copy[1])\n return np.array([spinparts[0], mixspinpart, spinparts[1]])\n\ndef get_ao_vals(mol, points):\n return eval_ao(mol, points)\n\ndef get_mgga_data(mol, grid, rdm1):\n \"\"\"\n Get atomic orbital and density data.\n See eval_ao and eval_rho docs for details.\n Briefly, returns 0-3 derivatives of the atomic orbitals\n in ao_data;\n and the density, first derivatives of density,\n Laplacian of density, and kinetic energy density\n in rho_data.\n \"\"\"\n ao_data = eval_ao(mol, grid.coords, deriv=3)\n if len(rdm1.shape) == 2:\n rho_data = eval_rho(mol, ao_data, rdm1, xctype='mGGA')\n else:\n part0 = eval_rho(mol, ao_data, rdm1[0], xctype='mGGA')\n part1 = eval_rho(mol, ao_data, rdm1[1], xctype='mGGA')\n rho_data = np.array([part0, part1])\n return ao_data, rho_data\n\ndef get_tau_and_grad_helper(mol, grid, rdm1, ao_data):\n \"\"\"\n Passes the derivatives of the atomic orbitals\n to eval_rho to get the kinetic energy density and its\n derivatives. Not sure if this works.\n \"\"\"\n # 0 1 2 3 4 5 6 7 8 9\n # 0 x y z xx xy xz yy yz zz\n aox = ao_data[[1, 4, 5, 6]]\n aoy = ao_data[[2, 5, 7, 8]]\n aoz = ao_data[[3, 6, 8, 9]]\n tau = eval_rho(mol, aox, rdm1, xctype='GGA')\n tau += eval_rho(mol, aoy, rdm1, xctype='GGA')\n tau += eval_rho(mol, aoz, rdm1, xctype='GGA')\n return 0.5 * tau\n\ndef get_tau_and_grad(mol, grid, rdm1, ao_data):\n if len(rdm1.shape) == 2:\n return get_tau_and_grad_helper(mol, grid, rdm1, ao_data)\n else:\n return np.array([get_tau_and_grad_helper(mol, grid, rdm1[0], ao_data),\\\n get_tau_and_grad_helper(mol, grid, rdm1[1], ao_data)])\n\ndef get_rho_second_deriv_helper(mol, grid, dm, ao):\n from pyscf.dft.numint import _contract_rho, _dot_ao_dm\n from pyscf.dft.gen_grid import make_mask, BLKSIZE\n\n nao = mol.nao_nr()\n N = grid.weights.shape[0]\n non0tab = np.ones(((N+BLKSIZE-1)//BLKSIZE, mol.nbas),\n dtype=np.uint8)\n shls_slice = (0, mol.nbas)\n ao_loc = mol.ao_loc_nr()\n c0 = _dot_ao_dm(mol, ao[0], dm, non0tab, shls_slice, ao_loc)\n c1 = np.zeros((3, N, nao))\n # 0 1 2 3 4 5 6 7 8 9\n # 0 x y z xx xy xz yy yz zz\n # - - - - 0 1 2 3 4 5\n # - - - - 11 12 13 22 23 33\n ddrho = np.zeros((6, N))\n alphas = [0, 0, 0, 1, 1, 2]\n betas = [0, 1, 2, 1, 2, 2]\n for i in range(3):\n c1[i] = _dot_ao_dm(mol, ao[i+1], dm.T, non0tab, shls_slice, ao_loc)\n for i in range(6):\n term1 = _contract_rho(c0, ao[i + 4])\n term2 = _contract_rho(c1[alphas[i]], ao[betas[i]+1])\n total = term1 + term2\n ddrho[i] = total + total.conj()\n return ddrho\n\ndef get_rho_second_deriv(mol, grid, rdm1, ao_data):\n if len(rdm1.shape) == 2:\n return get_rho_second_deriv_helper(mol, grid, rdm1, ao_data)\n else:\n return np.array([get_rho_second_deriv_helper(mol, grid, rdm1[0], ao_data),\\\n get_rho_second_deriv_helper(mol, grid, rdm1[1], ao_data)])\n\ndef get_vele_mat(mol, points):\n \"\"\"\n Return shape (N, nao, nao)\n \"\"\"\n auxmol = gto.fakemol_for_charges(points)\n vele_mat = df.incore.aux_e2(mol, auxmol)\n return np.ascontiguousarray(np.transpose(vele_mat, axes=(2,0,1)))\n\ndef get_mo_vals(ao_vals, mo_coeff):\n \"\"\"\n Args:\n ao_vals shape (N,nao)\n mo_coeff shape (nao,nao)\n Returns\n shape (N,nao)\n \"\"\"\n return np.matmul(ao_vals, mo_coeff)\n\ndef get_mo_vele_mat(vele_mat, mo_coeff):\n \"\"\"\n Convert the return value of get_vele_mat to the MO basis.\n \"\"\"\n if len(mo_coeff.shape) == 2:\n return np.matmul(mo_coeff.transpose(),\n np.matmul(vele_mat, mo_coeff))\n else:\n tmp = np.einsum('puv,svj->spuj', vele_mat, mo_coeff)\n return np.einsum('sui,spuj->spij', mo_coeff, tmp)\n\ndef get_vele_mat_chunks(mol, points, num_chunks, orb_vals, mo_coeff=None):\n \"\"\"\n Generate chunks of vele_mat on the fly to reduce memory load.\n \"\"\"\n num_pts = points.shape[0]\n for i in range(num_chunks):\n start = (i * num_pts) // num_chunks\n end = ((i+1) * num_pts) // num_chunks\n auxmol = gto.fakemol_for_charges(points[start:end])\n orb_vals_chunk = orb_vals[start:end]\n vele_mat_chunk = df.incore.aux_e2(mol, auxmol)\n vele_mat_chunk = np.ascontiguousarray(np.transpose(\n vele_mat_chunk, axes=(2,0,1)))\n if mo_coeff is not None:\n vele_mat_chunk = get_mo_vele_mat(vele_mat_chunk, mo_coeff)\n yield vele_mat_chunk, orb_vals_chunk\n\ndef get_vele_mat_generator(mol, points, num_chunks, mo_coeff=None):\n get_generator = lambda orb_vals: get_vele_mat_chunks(mol, points,\n num_chunks, orb_vals, mo_coeff)\n return get_generator\n\ndef get_ha_energy_density(mol, rdm1, vele_mat, ao_vals):\n \"\"\"\n Get the classical Hartree energy density on a real-space grid,\n for a given molecular structure with basis set (mol),\n for a given 1-electron reduced density matrix (rdm1).\n Returns the Hartree energy density.\n \"\"\"\n if len(rdm1.shape) == 2:\n Vele = np.einsum('pij,ij->p', vele_mat, rdm1)\n else:\n rdm1 = np.array(rdm1)\n Vele = np.einsum('pij,sij->p', vele_mat, rdm1)\n rho = eval_rho(mol, ao_vals, rdm1)\n return 0.5 * Vele * rho\n\ndef get_fx_energy_density(mol, mo_occ, mo_vele_mat, mo_vals):\n \"\"\"\n Get the Hartree Fock exchange energy density on a real-space grid,\n for a given molecular structure with basis set (mol),\n for a given atomic orbital (AO) 1-electron reduced density matrix (rdm1).\n Returns the exchange energy density, which is negative.\n \"\"\"\n A = mo_occ * mo_vals\n tmp = np.einsum('pi,pij->pj', A, mo_vele_mat)\n return -0.25 * np.sum(A * tmp, axis=1)\n\n\n# The following functions are helpers that check whether vele_mat\n# is a numpy array or a generator before passing to the methods\n# above. This allows one to integrate the memory-saving (but slower)\n# chunk-generating approach smoothly.\n\ndef get_ha_energy_density2(mol, rdm1, vele_mat, ao_vals):\n if isinstance(vele_mat, np.ndarray):\n return get_ha_energy_density(mol, rdm1, vele_mat, ao_vals)\n else:\n ha_energy_density = np.array([])\n for vele_mat_chunk, orb_vals_chunk in vele_mat(ao_vals):\n ha_energy_density = np.append(ha_energy_density,\n get_ha_energy_density(mol, rdm1,\n vele_mat_chunk, orb_vals_chunk))\n return ha_energy_density\n\ndef get_fx_energy_density2(mol, mo_occ, mo_vele_mat, mo_vals):\n # make sure to test that the grids end up the same\n if isinstance(mo_vele_mat, np.ndarray):\n return get_fx_energy_density(mol, mo_occ, mo_vele_mat, mo_vals)\n else:\n fx_energy_density = np.array([])\n for vele_mat_chunk, orb_vals_chunk in mo_vele_mat(mo_vals):\n fx_energy_density = np.append(fx_energy_density,\n get_fx_energy_density(mol, mo_occ,\n vele_mat_chunk, orb_vals_chunk))\n return fx_energy_density\n\n\ndef mol_from_dict(mol_dict):\n for item in ['charge', 'spin', 'symmetry', 'verbose']:\n if type(mol_dict[item]).__module__ == np.__name__:\n mol_dict[item] = mol_dict[item].item()\n mol = gto.mole.unpack(mol_dict)\n mol.build()\n return mol\n\ndef get_scf(calc_type, mol, calc_data = None):\n calc = CALC_TYPES[calc_type](mol)\n calc.__dict__.update(calc_data)\n return calc\n\ndef get_ccsd(calc_type, mol, calc_data = None):\n if calc_type == 'CCSD':\n hf = scf.hf.RHF(mol)\n else:\n hf = scf.uhf.UHF(mol)\n hf.e_tot = calc_data.pop('e_tot') - calc_data['e_corr']\n calc = CALC_TYPES[calc_type](hf)\n calc.__dict__.update(calc_data)\n return calc\n\ndef load_calc(fname):\n analyzer_dict = lib.chkfile.load(fname, 'analyzer')\n mol = mol_from_dict(analyzer_dict['mol'])\n calc_type = analyzer_dict['calc_type']\n if 'CCSD' in calc_type:\n return get_ccsd(calc_type, mol, analyzer_dict['calc']), calc_type\n else:\n return get_scf(calc_type, mol, analyzer_dict['calc']), calc_type\n\ndef load_analyzer_data(fname):\n data_file = os.path.join(dirname, fname)\n return lib.chkfile.load(data_file, 'analyzer/data')\n\n\n\n\n##################################################\n# HELPER FUNCTIONS FOR COMPUTING DFT INGREDIENTS #\n##################################################\n\n\ndef get_ws_radii(rho):\n return (3.0 / (4 * np.pi * rho + 1e-16))**(1.0/3)\n\ndef get_gradient_magnitude(rho_data):\n return np.linalg.norm(rho_data[1:4,:], axis=0)\n\ndef get_normalized_grad(rho, mag_grad):\n sprefac = 2 * (3 * np.pi * np.pi)**(1.0/3)\n n43 = rho**(4.0/3)\n s = mag_grad / (sprefac * n43 + 1e-16)\n return s\n\ndef get_single_orbital_tau(rho, mag_grad):\n return mag_grad**2 / (8 * rho + 1e-16)\n\ndef get_uniform_tau(rho):\n return (3.0/10) * (3*np.pi**2)**(2.0/3) * rho**(5.0/3)\n\ndef get_regularized_tau(tau, tau_w, tau_unif):\n alpha = (tau - tau_w) / (tau_unif + 1e-4)\n return alpha**3 / (alpha**2 + 1e-3)\n\ndef get_normalized_tau(tau, tau_w, tau_unif):\n return (tau - tau_w) / (tau_unif + 1e-16)\n\ndef get_dft_input(rho_data):\n rho = rho_data[0,:]\n r_s = get_ws_radii(rho)\n mag_grad = get_gradient_magnitude(rho_data)\n s = get_normalized_grad(rho, mag_grad)\n tau_w = get_single_orbital_tau(rho, mag_grad)\n tau_unif = get_uniform_tau(rho)\n alpha = get_regularized_tau(rho_data[5], tau_w, tau_unif)\n return rho, s, alpha, tau_w, tau_unif\n\ndef get_dft_input2(rho_data):\n rho = rho_data[0,:]\n r_s = get_ws_radii(rho)\n mag_grad = get_gradient_magnitude(rho_data)\n s = get_normalized_grad(rho, mag_grad)\n tau_w = get_single_orbital_tau(rho, mag_grad)\n tau_unif = get_uniform_tau(rho)\n alpha = get_normalized_tau(rho_data[5], tau_w, tau_unif)\n return rho, s, alpha, tau_w, tau_unif\n\ndef squish_density(rho_data, coords, weights, alpha):\n new_coords = coords / alpha\n new_weights = weights / alpha**3\n rho_data = rho_data.copy()\n rho_data[0,:] *= alpha**3\n rho_data[1:4,:] *= alpha**4\n rho_data[4:6,:] *= alpha**5\n return new_coords, new_weights, rho_data\n\ndef squish_tau(tau_data, alpha):\n tau_data = tau_data.copy()\n tau_data[0,:] *= alpha**5\n tau_data[1:4] *= alpha**6\n return tau_data\n", "meta": {"hexsha": "ede53793a8e56890916db1147c97448128e05d73", "size": 17511, "ext": "py", "lang": "Python", "max_stars_repo_path": "mldftdat/pyscf_utils.py", "max_stars_repo_name": "mir-group/CiderPress", "max_stars_repo_head_hexsha": "bf2b3536e6bd7432645c18dce5a745d63bc9df59", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 10, "max_stars_repo_stars_event_min_datetime": "2021-09-09T06:51:57.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-17T09:48:41.000Z", "max_issues_repo_path": "mldftdat/pyscf_utils.py", "max_issues_repo_name": "mir-group/CiderPress", "max_issues_repo_head_hexsha": "bf2b3536e6bd7432645c18dce5a745d63bc9df59", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "mldftdat/pyscf_utils.py", "max_forks_repo_name": "mir-group/CiderPress", "max_forks_repo_head_hexsha": "bf2b3536e6bd7432645c18dce5a745d63bc9df59", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.8131212724, "max_line_length": 95, "alphanum_fraction": 0.6190965679, "include": true, "reason": "import numpy", "num_tokens": 5467, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.3738758227716966, "lm_q1q2_score": 0.19131846660970886}} {"text": "#########################################################################\n# Dicomifier - Copyright (C) Universite de Strasbourg\n# Distributed under the terms of the CeCILL-B license, as published by\n# the CEA-CNRS-INRIA. Refer to the LICENSE file or to\n# http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html\n# for details.\n#########################################################################\n\n\"\"\"\nExtract diffusion-related information from JSON meta-data and convert it to \nother formats. Unless otherwise specified, all b-values extracted from meta-data\nare expressed in :math:`s/m^2` (i.e. SI units).\n\"\"\"\n\nimport base64\nimport binascii\nimport re\n\nimport numpy\n\nfrom .. import dicom_to_nifti\nfrom .. import logger\n\ndef from_standard(data):\n \"\"\" Extract diffusion gradient direction and b-value from standard DICOM\n elements (MR Diffusion Sequence).\n \"\"\"\n \n diffusion_data = data[\"MRDiffusionSequence\"]\n \n scheme = []\n for entry in diffusion_data:\n entry = entry[0]\n if \"DiffusionBValue\" not in entry:\n raise Exception(\"Missing b-value\")\n b_value = entry[\"DiffusionBValue\"][0]\n # Convert from s/mm^2 to s/m^2\n b_value *= 1e6\n \n if \"DiffusionGradientDirectionSequence\" not in entry:\n if b_value != 0:\n raise Exception(\"Missing direction\")\n else:\n entry[\"DiffusionGradientDirectionSequence\"] = [{\n \"DiffusionGradientOrientation\": [0,0,0]}]\n direction = entry[\"DiffusionGradientDirectionSequence\"][0]\n if \"DiffusionGradientOrientation\" not in direction:\n raise Exception(\"Missing direction\")\n direction = numpy.array(direction[\"DiffusionGradientOrientation\"])\n norm = numpy.linalg.norm(direction)\n if norm > 0:\n direction /= norm\n \n scheme.append((b_value, direction))\n \n return scheme\n\ndef from_siemens_csa(data):\n \"\"\" Extract diffusion gradient direction and b-value from Siemens-specific\n elements (CSA Image Header Info (0029,xx10)).\n \"\"\"\n \n logger.warning(\n \"The coordinate system of the gradient direction is unspecified. \"\n \"Results may be wrong on non-axial images.\")\n \n scheme = []\n \n # Look for \"SIEMENS CSA HEADER\" private creator and get the concrete tag\n # of CSA Image Header Info (0029,xx10)\n element = None\n for tag, item in data.items():\n match = re.match(r\"([\\da-f]{4})00([\\da-f]{2})\", tag)\n if match:\n try:\n item = [base64.b64decode(item[0]).decode()]\n except binascii.Error:\n pass\n except UnicodeDecodeError:\n pass\n if item[0] == \"SIEMENS CSA HEADER\":\n element = match.group(1)+match.group(2)+\"10\"\n break\n \n item = data[element]\n for entry in numpy.ravel(item):\n siemens_data = dicom_to_nifti.siemens.parse_csa(base64.b64decode(entry))\n \n b_value = siemens_data[\"B_value\"][0]\n # Convert from s/mm^2 to s/m^2\n b_value *= 1e6\n \n direction = siemens_data[\"DiffusionGradientDirection\"]\n if len(direction) == 0:\n direction = [0,0,0]\n norm = numpy.linalg.norm(direction)\n if norm > 0:\n direction /= norm\n \n scheme.append((b_value, direction))\n return scheme\n\ndef from_ge_private(data):\n \"\"\" Extract diffusion gradient direction and b-value from GE-specific\n elements (0019,xxbb, 0019,xxbc, 0019,xxbd, and 0043,xx39).\n \"\"\"\n \n # Look for \"GEMS_ACQU_01\" and \"GEMS_PARM_01\" private creators and build base\n # tags.\n gems_acq = None\n gems_parm = None\n for tag, item in sorted(data.items()):\n if tag[:4] == \"0019\" and tag[-4:-2] == \"00\":\n if item and item[0] == \"GEMS_ACQU_01\":\n gems_acq = \"0019\"+tag[-2:]\n if tag[:4] == \"0043\" and tag[-4:-2] == \"00\":\n if item and item[0] == \"GEMS_PARM_01\":\n gems_parm = \"0043\"+tag[-2:]\n if tag>\"004300ff\" or None not in [gems_acq, gems_parm]:\n break\n \n directions = None\n if gems_acq is not None:\n directions = numpy.squeeze(\n numpy.transpose([data[gems_acq+x] for x in [\"bb\", \"bc\", \"bd\"]]))\n norm = numpy.maximum(1e-30, numpy.linalg.norm(directions, axis=1))\n directions /= norm[:,None]\n \n b_values = None\n if gems_parm is not None:\n b_values = data.get(gems_parm+\"39\")\n if b_values is not None:\n b_values = [x[0] for x in b_values]\n if b_values is None:\n b_values = [x[0] if x else 0 for x in data.get(\"DiffusionBValue\")]\n # Convert from s/mm^2 to s/m^2\n b_values = [x*1e6 for x in b_values]\n \n return list(zip(b_values, directions))\n\ndef to_mrtrix(scheme, fd):\n \"\"\" Save a diffusion scheme in MRtrix format to a file-like object.\n \"\"\"\n \n # https://mrtrix.readthedocs.io/en/latest/concepts/dw_scheme.html\n # > the direction vectors are assumed to be provided with respect to real \n # > or scanner coordinates. This is the same convention as is used in the \n # > DICOM format.\n # NOTE: DICOM uses *patient* coordinates, not *scanner* coordinates\n for b_value, direction in scheme:\n # Convert from s/m^2 to s/mm^2\n b_value /= 1e6\n print(*direction, b_value, file=fd)\n\ndef to_fsl(scheme, transform, bvecs_fd, bvals_fd):\n \"\"\" Save a diffusion scheme in FSL bvecs+bvals format. A reference \n transform is required as the bvecs are store in image coordinates, not \n in patient coordinates. This transform must correspond to an \n image-to-patient transform, e.g. what is stored in the *affine* member\n of nibabel images.\n \"\"\"\n \n # https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/FDT/UserGuide#Diffusion_data_in_FSL\n # https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/FDT/FAQ#What_conventions_do_the_bvecs_use.3F\n \n directions = numpy.array([direction for b_value, direction in scheme])\n # Convert from patient coordinates to image coordinates\n # WARNING: for highly anisotropic images and non axis-aligned transforms,\n # this seem to introduce a slight bias in the directions.\n bvecs = numpy.array([numpy.linalg.inv(transform) @ d for d in directions])\n \n if numpy.linalg.det(transform)>0:\n bvecs[:,0] *= -1\n \n bvecs[bvecs == numpy.NZERO] = 0\n \n # Re-normalize (not required by FSL)\n norm = numpy.maximum(1e-20, numpy.linalg.norm(bvecs, axis=1))\n bvecs /= norm[:,None]\n for row in bvecs.T:\n print(*row, file=bvecs_fd)\n \n # Convert from s/m^2 to s/mm^2\n b_values = numpy.array([b_value for b_value, direction in scheme]) / 1e6\n print(*b_values, file=bvals_fd)\n", "meta": {"hexsha": "8794722504438bf5894296c7cb9a9036508501b7", "size": 6802, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/python/dicomifier/nifti/diffusion.py", "max_stars_repo_name": "DimitriPapadopoulos/dicomifier", "max_stars_repo_head_hexsha": "708e4e1c932f6411200aa010f857823dfcc495f1", "max_stars_repo_licenses": ["CECILL-B"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/python/dicomifier/nifti/diffusion.py", "max_issues_repo_name": "DimitriPapadopoulos/dicomifier", "max_issues_repo_head_hexsha": "708e4e1c932f6411200aa010f857823dfcc495f1", "max_issues_repo_licenses": ["CECILL-B"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/python/dicomifier/nifti/diffusion.py", "max_forks_repo_name": "DimitriPapadopoulos/dicomifier", "max_forks_repo_head_hexsha": "708e4e1c932f6411200aa010f857823dfcc495f1", "max_forks_repo_licenses": ["CECILL-B"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.5698924731, "max_line_length": 89, "alphanum_fraction": 0.608056454, "include": true, "reason": "import numpy", "num_tokens": 1715, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.37387582277169656, "lm_q1q2_score": 0.19131846660970883}} {"text": "import sys\n# from bfuncs import *\nfrom math import *\nimport copy\nimport re\nimport numpy\n\nfrom Scientific.Geometry import Vector, isVector, Tensor, isTensor\nfrom Scientific.indexing import index_expression\nfrom Scientific import N\n\nfrom MMTK import *\nfrom MMTK.MoleculeFactory import *\nfrom MMTK.ForceFields import Amber99ForceField\nfrom MMTK import Universe\nfrom MMTK.InternalCoordinates import *\nfrom MMTK.ChemicalObjects import *\n\n\n########################################\n########## AUX FUNCTIONS ###############\n########################################\n\n# START FUNC bsubstr @@@@@\ndef bsubstr(astring, pos, nchar):\n\t\"\"\"Awk substr equivalent\"\"\" \n\tresult = 0;\n\tl = len(astring);\n\tif((pos > 0) & (nchar <= l)):\n\t\tf = pos+nchar-1;\n\t\tif(f <= l):\n\t\t\treturn astring[(pos-1):f];\n\telse:\n\t\treturn result;\n\n# END FUNC bsubstr @@@@@\n\n\n# START FUNC bsubstr @@@@@\ndef bcontains(basket, apple):\n\t\"\"\"\n\tChecks if apple is in the basket\n\t@basket: container\n\t@basket type: list\n\t@apple: subset\n\t@apple type type: list\n\t@returns 1 if apple is contained in basket\n\t\"\"\"\n\tfound = 0\n\tlapple = len(apple)\n\tlbasket = len(basket)\n\n\tif lapple >= lbasket : return 0\n\n\tfor i in range(lapple) :\n\t\tfound = 0\n\t\tfor j in range(lbasket) :\n\t\t\tif apple[i] == basket[j]:\n\t\t\t\tfound = 1\n\t\t\t\tbreak\n\t\tif found == 0 :\n\t\t\treturn 0\n\n\treturn 1\n\n# START FUNC bdiff @@@@@\ndef bPDBprint_atom(record, name, position):\n\tserial = 1\n\taltLoc = ' '\n\tresName = 'LIG'\n\tchainID = 'X'\n\tresSeq = 1\n\toccupancy = 1.0\n\ttempFactor = 0.0\n\tprint '{0:<6}{1:>5}{2:>4}{3} {4} {5}{6:>4} {7:8.3f}{8:8.3f}{9:8.3f} {10:4.2f}{11:6.2f}'.format\\\n\t\t(record, serial, name, altLoc, resName, chainID, resSeq, \\\n\t\tposition.x(), position.y(), position.z(), occupancy, tempFactor)\n# END FUNC bdiff @@@@@\n\n\n# START FUNC bisSaturated @@@@@\ndef bisSaturated(element, bonds):\n\t\"\"\"\n\tChecks if an atom is involved in multiple bonds\n\t@element: the atom\n\t@element type: string\n\t@bonds: how many bonds is the atom involved in\n\t@bonds type: integer\n\t@rvalue: difference between the valence and bonds (unsaturated value)\n\t@rtype: integer\n\t\"\"\"\n\tif element == 'C' :\n\t\treturn 4 - bonds\n\telif element == 'Si' :\n\t\treturn 4 - bonds\n\telif element == 'N' :\n\t\treturn 3 - bonds\n\telif element == 'O' :\n\t\treturn 2 - bonds\n\telif element == 'S' :\n\t\treturn 2 - bonds\n\telif element == 'P' :\n\t\treturn 5 - bonds\n\telif element == 'Se' :\n\t\treturn 2 - bonds\n\telse :\n\t\treturn 0\n\n####################################\n########## FUNCTIONS ###############\n####################################\n\ndef anchor(universe):\n\t\"\"\"Anchor a universe\"\"\"\n\tif(universe.numberOfAtoms() >=3):\n\t\t#set anchor atoms indexes\t\n\t\ta1i\t= 0\n\t\tfor i in range(len(universe.atomList()[a1i].bondedTo())):\n\t\t\tfor j in range(len(universe.atomList()[a1i].bondedTo()[i].bondedTo())):\n\t\t\t\tif universe.atomList()[a1i] is not \\\n\t\t\t\t\tuniverse.atomList()[a1i].bondedTo()[i].bondedTo()[j] :\n\t\t\t\t\ta2i = i;\n\t\t\t\t\ta3i = j;\n\t\t\t\t\tbreak\n\t\tprint 'anchor using: ', a1i, a2i, a3i\n\t\t\n\t\tv1 = universe.atomList()[a1i].position();\n\t\tv2 = universe.atomList()[a1i].bondedTo()[a2i].position();\n\t\tv3 = universe.atomList()[a1i].bondedTo()[a2i].bondedTo()[a3i].position();\n\t\n\t\tvT01 = -v1;\n\t\ttra01 = Translation(vT01);\n\t\tuniverse.applyTransformation(tra01);\n\t\n\t\n\t\tx = universe.atomList()[a1i].bondedTo()[a2i].position().x();\n\t\ty = 0;\n\t\tz = universe.atomList()[a1i].bondedTo()[a2i].position().z();\n\t\tvR01 = Vector(x,y,z);\n\t\tvR02 = Vector(1,0,0);\n\t\n\t\tsign = 1.0\n\t\tif ((z > 0) and (x > 0)) or ((z < 0) and (x < 0)):\n\t\t\tsign = -1.0\n\t\t\n\t\trot01 = Rotation(Vector(0,1,0), sign*vR01.angle(vR02));\n\t\tuniverse.applyTransformation(rot01);\n\t\n\t\tv4 = universe.atomList()[a1i].bondedTo()[a2i].position();\n\t\n\t\tsign = -1.0\n\t\tif ((x > 0) and (y > 0)) or ((x < 0) and (y < 0)):\n\t\t\tsign = 1.0\n\t\trot02 = Rotation(Vector(0,0,1), sign*v4.angle(Vector(1,0,0)));\n\t\tuniverse.applyTransformation(rot02);\n\t\n\t\tx = 0;\n\t\ty = universe.atomList()[a1i].bondedTo()[a2i].bondedTo()[a3i].position().y();\n\t\tz = universe.atomList()[a1i].bondedTo()[a2i].bondedTo()[a3i].position().z();\n\t\n\t\tsign = 1.0\n\t\tif ((z > 0) and (y > 0)) or ((z < 0) and (y < 0)):\n\t\t\tsign = -1.0\n\t\n\t\tvR03 = Vector(x,y,z);\n\t\tvR04 = Vector(0,1,0);\n\t\trot03 = Rotation(Vector(1,0,0), sign*vR03.angle(vR04));\n\t\tuniverse.applyTransformation(rot03);\n\t\n\telse:\n\t\tprint \"Molecule too little to be anchored\";\n#--------------------------------------------------\n\n\n\n####################################\n############ CLASSES ###############\n####################################\n\nclass bConvertor():\n\t\"\"\"\n\tConverts from cartesian coordinates\n\tfound in universe to bonds, angles, dihedrals\n\tlists found within self\n\t\"\"\"\n\tdef __init__(self, universe):\n\t\t\"\"\"\n\t\t:param universe: an MMTK universe\n\t\t:type universe: MMTK universe\n\t\t\"\"\"\n\t\t#Variables\n\t\tself.bonds = []\t\t#list of bonds\n\t\tself.angles = []\t#list of angles\n\t\tself.dihedrals = [] #list of dihedrals\n\n\tdef cart2all_internals(self):\n\t\tk = -1\n\t\t# Bonds\n\t\tfor i in universe[0].bonds :\n\t\t\tk += 1;\n\t\t\tx = universe.distance(i.a1, i.a2);\n\t\t\tself.bonds.append([i.a1, i.a2, x]);\n\t\t\n\t\t# Angles\n\t\tk = -1;\n\t\tfor i in self.bonds :\n\t\t\tfor j in self.bonds:\n\t\t\t\tif j != i :\n\t\t\t\t\tif (i[0] == j[0]):\n\t\t\t\t\t\tk += 1;\n\t\t\t\t\t\tx = universe.angle(i[1], i[0], j[1]);\n\t\t\t\t\t\tself.angles.append([[i[1], i[0], i[2]],\\\n\t\t\t\t\t\t\t\t\t\t\t[i[0], j[1], j[2]],\\\n\t\t\t\t\t\t\t\t\t\t \tx]);\n\t\t\t\t\telif (i[0] == j[1]):\n\t\t\t\t\t\tk += 1;\n\t\t\t\t\t\tx = universe.angle(i[1], i[0], j[0]);\n\t\t\t\t\t\tself.angles.append([[i[1], i[0], i[2]],\\\n\t\t\t\t\t\t\t\t\t\t\t[i[0], j[0], j[2]],\\\n\t\t\t\t\t\t\t\t\t\t \tx]);\n\t\t\t\t\telif (i[1] == j[0]):\n\t\t\t\t\t\tk += 1;\n\t\t\t\t\t\tx = universe.angle(i[0], i[1], j[1]);\n\t\t\t\t\t\tself.angles.append([[i[0], i[1], i[2]],\\\n\t\t\t\t\t\t\t\t\t\t\t[i[1], j[1], j[2]],\\\n\t\t\t\t\t\t\t\t\t\t \tx]);\n\t\t\t\t\telif (i[1] == j[1]):\n\t\t\t\t\t\tk += 1;\n\t\t\t\t\t\tx = universe.angle(i[0], i[1], j[0]);\n\t\t\t\t\t\tself.angles.append([[i[0], i[1], i[2]],\\\n\t\t\t\t\t\t\t\t\t\t\t[i[1], j[0], j[2]],\\\n\t\t\t\t\t\t\t\t\t\t \tx]);\n\t\t\n\t\t# Dihedrals\n\t\tk = -1;\n\t\tfor i in self.angles :\n\t\t\tfor j in self.angles:\n\t\t\t\tif j < i :\n\t\t\t\t\tif (i[0] == j[1]) :\n\t\t\t\t\t\tk += 1;\n\t\t\t\t\t\tx = universe.dihedral(j[0][0], j[0][1], j[1][1], i[1][1]);\n\t\t\t\t\t\tself.dihedrals.append([j,i,x])\n\t\t\t\t\tif (i[1] == j[0]) :\n\t\t\t\t\t\tk += 1;\n\t\t\t\t\t\tx = universe.dihedral(i[0][0], i[0][1], i[1][1], j[1][1]);\n\t\t\t\t\t\tself.dihedrals.append([i,j,x])\n\t#---------------------------------------------\n\t\n\tdef print_internals(self):\n\t\t\"\"\"Writes Bonds, Angles & Dihedrals to stdout\"\"\"\n\t\tprint \"Bonds\";\n\t\tfor i in self.bonds :\n\t\t\tprint i;\n\t\tprint \"Angles\";\n\t\tfor i in self.angles :\n\t\t\tprint i\n\t\tprint \"Dihedrals\"\n\t\tfor i in self.dihedrals :\n\t\t\tprint i;\n\t#---------------------------------------------\n\t\n\tdef swap_bond(self, bond):\n\t\t\"\"\"Reverses the atoms order\"\"\"\n\t\t\"\"\"in a [a1,a2,val] type bond\"\"\"\n\t\trbond = copy.deepcopy(bond)\n\t\tx = rbond[0]\n\t\trbond[0] = rbond[1]\n\t\trbond[1] = x\n\t\treturn rbond\n\t#---------------------------------------------\n\t\n\tdef swap_angle(self, angle):\n\t\t\"\"\"Reverses the atoms order in a\"\"\"\n\t\t\"\"\"[[a1,a2,bval], [a2,a3,bval], aval] type angle\"\"\"\n\t\trangle = copy.deepcopy(angle)\n\t\ta1 = angle[0][0]\n\t\ta2l = angle[0][1]\n\t\tbvall = angle[0][2]\n\t\ta2r = angle[1][0]\n\t\ta3 = angle[1][1]\n\t\tbvalr = angle[1][2]\n\t\t\n\t\trangle[0][0] = a3\n\t\trangle[0][1] = a2r\n\t\trangle[0][2] = bvalr\n\t\trangle[1][0] = a2l\n\t\trangle[1][1] = a1\n\t\trangle[1][2] = bvall\n\t\treturn rangle\n\t#---------------------------------------------\n\t\n\tdef swap_dihe(self, dihe):\n\t\t\"\"\"Reverses the atoms order in a\"\"\"\n\t\t\"\"\"[ [[a1,a2,bv1],[a2l,a3l,bv2l], av1],\"\"\"\n\t\t\"\"\" [[a2r,a3r,bv2r],[a3,a4,bv3], av2],\"\"\"\n\t\t\"\"\" dv ] type dihedral angle\"\"\"\n\t\trdihe = copy.deepcopy(dihe)\n\t\n\t\ta1 = dihe[0][0][0]\n\t\ta2 = dihe[0][0][1]\n\t\tbv1 = dihe[0][0][2]\n\t\ta2l = dihe[0][1][0]\n\t\ta3l = dihe[0][1][1]\n\t\tbv2l = dihe[0][1][2]\n\t\tav1 = dihe[0][2]\n\t\ta2r = dihe[1][0][0]\n\t\ta3r = dihe[1][0][1]\n\t\tbv2r = dihe[1][0][2]\n\t\ta3 = dihe[1][1][0]\n\t\ta4 = dihe[1][1][1]\n\t\tbv3 = dihe[1][1][2]\n\t\tav2 = dihe[1][2]\n\t\n\t\trdihe[0][0][0] = a4\n\t\trdihe[0][0][1] = a3\n\t\trdihe[0][0][2] = bv3\n\t\trdihe[0][1][0] = a3r\n\t\trdihe[0][1][1] = a2r\n\t\trdihe[0][1][2] = bv2r\n\t\trdihe[0][2] = av2\n\t\trdihe[1][0][0] = a3l\n\t\trdihe[1][0][1] = a2l\n\t\trdihe[1][0][2] = bv2l\n\t\trdihe[1][1][0] = a2\n\t\trdihe[1][1][1] = a1\n\t\trdihe[1][1][2] = bv1\n\t\trdihe[1][2] = av1\n\t\treturn rdihe\n\t#---------------------------------------------\n\n\tdef sprint_zmat_dihe(self, dihe):\n\t\t\"\"\"Write dihedral to stdout\"\"\"\n\t\t\"\"\" in Z-matrix format\"\"\"\n\t\ta1 = dihe[0][0][0]\n\t\ta2 = dihe[0][0][1]\n\t\tbv1 = dihe[0][0][2]\n\t\ta2l = dihe[0][1][0]\n\t\ta3l = dihe[0][1][1]\n\t\tbv2l = dihe[0][1][2]\n\t\tav1 = dihe[0][2]\n\t\ta2r = dihe[1][0][0]\n\t\ta3r = dihe[1][0][1]\n\t\tbv2r = dihe[1][0][2]\n\t\ta3 = dihe[1][1][0]\n\t\ta4 = dihe[1][1][1]\n\t\tbv3 = dihe[1][1][2]\n\t\tav2 = dihe[1][2]\n\t\treturn '{0:>4} {1:>4} {2:>4} {3:>4} {4:>10.6f} {5:>4} {6:>10.6f} {7:>4} {8:>10.6f}'.format(a1.index+1, a1.name, a1.name[0], a2.index+1, bv1*10.0, a3.index+1, av1, a4.index+1, dihe[2])\n\t#---------------------------------------------\n\t\n\t\n\tdef print_zmat_dihe(self, dihe):\n\t\t\"\"\"Write dihedral to stdout\"\"\"\n\t\t\"\"\" in Z-matrix format\"\"\"\n\t\ta1 = dihe[0][0][0]\n\t\ta2 = dihe[0][0][1]\n\t\tbv1 = dihe[0][0][2]\n\t\ta2l = dihe[0][1][0]\n\t\ta3l = dihe[0][1][1]\n\t\tbv2l = dihe[0][1][2]\n\t\tav1 = dihe[0][2]\n\t\ta2r = dihe[1][0][0]\n\t\ta3r = dihe[1][0][1]\n\t\tbv2r = dihe[1][0][2]\n\t\ta3 = dihe[1][1][0]\n\t\ta4 = dihe[1][1][1]\n\t\tbv3 = dihe[1][1][2]\n\t\tav2 = dihe[1][2]\n\t\tprint '{0:>4} {1:>4} {2:>4} {3:>4} {4:>10.6f} {5:>4} {6:>10.6f} {7:>4} {8:>10.6f}'.format(a1.index+1, a1.name, a1.name[0], a2.index+1, bv1*10.0, a3.index+1, av1, a4.index+1, dihe[2])\n\t#---------------------------------------------\n\n\n\tdef NeRFinte2cart(self, dihe):\t# Needs debug\n\t\t\"\"\"\n\t\tReconstructs atomlist positions\n\t\t2005 Parsons et al - NeRF algorithm\n\t\t:param universe: MMTK universe\n\t\t:type universe: MMTK universe\n\t\t:param dihe: list of dihedrals\n\t\t:type dihe: [[[],[],aval] , [[],[],aval] , dval] where [] is a bond\n\t\t\"\"\"\n\t\tknown_atoms = []\n\t\tunknown_atoms = copy.deepcopy(universe.atomList())\n\t\tC = Vector(0,0,0)\n\t\tD = Vector(0,0,0)\n\t\tD2 = Vector(0,0,0)\n\t\tl = len(dihe)\n\t\tfor di in range(l):\t# Create the START stack\n\t\t\tdihe.append(self.swap_dihe(dihe[di]))\n\t\n\t\t#for i in dihe:\n\t\t#\tprint_zmat_dihe(i)\n\t\n\t\t# Assign initial values\n\t\ti = dihe[0]\n\t\ta1 = i[0][0][0]\n\t\ta2 = i[0][0][1]\n\t\ta3 = i[1][1][0]\n\t\ta4 = i[1][1][1]\n\t\tR1 = i[0][0][2]\n\t\tR2 = i[1][1][2]\n\t\ttheta1 = i[0][2]\n\t\tphi = i[2]\n\t\tuniverse.atomList()[a1.index].setPosition(Vector(0,0,0))\n\t\tuniverse.atomList()[a2.index].setPosition(Vector(R1,0,0))\n\t\tuniverse.atomList()[a3.index].setPosition(Vector(R1-R2*cos(theta1), R2*sin(theta1), 0))\n\t\tknown_atoms.append(a1)\n\t\tknown_atoms.append(a2)\n\t\tknown_atoms.append(a3)\n\t\t#print 'initialize at: ', a1, a2, a3\n\t\t#bPDBprint_atom('HETATM', a1.name, 10*a1.position())\n\t\t#bPDBprint_atom('HETATM', a2.name, 10*a2.position())\n\t\t#bPDBprint_atom('HETATM', a3.name, 10*a3.position())\n\t\t# Main loop\n\t\tcnt=0;\n\t\twhile len(known_atoms) < len(universe.atomList()):\n\t\t\tcnt += 1\n\t\t\tif cnt > 9999:\n\t\t\t\tprint 'NeRFinte2cart() cnt EXCEEDED: 9999'\n\t\t\t\tbreak\n\t\t\tai = -1\n\t\t\tfor a in unknown_atoms:\n\t\t\t\tai += 1\n\t\t\t\tfor i in dihe:\t\t\t\t# Search if atom a is a4 in any dihe\n\t\t\t\t\ta1 = i[0][0][0]\n\t\t\t\t\ta2 = i[0][0][1]\n\t\t\t\t\ta3 = i[1][0][1]\n\t\t\t\t\ta4 = i[1][1][1]\n\t\t\t\t\ta1known = 0\n\t\t\t\t\ta2known = 0\n\t\t\t\t\ta3known = 0\n\t\t\t\t\ta4known = 0\n\t\t\t\t\tif a4.index == a.index:\n\t\t\t\t\t\tfor k in known_atoms:\t# Check if atom is in KNOWN stack\n\t\t\t\t\t\t\tif a4.index == k.index:\n\t\t\t\t\t\t\t\ta4known = 1\n\t\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\t\tif a1.index == k.index :\n\t\t\t\t\t\t\t\ta1known = 1\n\t\t\t\t\t\t\tif a2.index == k.index :\n\t\t\t\t\t\t\t\ta2known = 1\n\t\t\t\t\t\t\tif a3.index == k.index :\n\t\t\t\t\t\t\t\ta3known = 1\n\t\t\t\t\t\tif ((a4known == 0) and \\\n\t\t\t\t\t\t\t(a1known == 1) and (a2known == 1) and (a3known == 1)):\n\t\t\t\t\t\t\t\t# Move everything so that a3 is in the center\n\t\t\t\t\t\t\t\tM = Translation(-1*a3.position())\n\t\t\t\t\t\t\t\tuniverse.applyTransformation(M)\n\t\t\t\t\t\t\t\tfor k in known_atoms:\n\t\t\t\t\t\t\t\t\tM(k.position())\n\t\t\t\t\t\t\t\t# Solve a4\n\t\t\t\t\t\t\t\t#print 'SOLVE: ', a4\n\t\t\t\t\t\t\t\tprint_zmat_dihe(i)\n\t\t\t\t\t\t\t\tA = a1.position()\n\t\t\t\t\t\t\t\tB = a2.position()\n\t\t\t\t\t\t\t\tC = a3.position()\n\t\t\t\t\t\t\t\t#print 'A = ', A, '(', a1.name , ')'\n\t\t\t\t\t\t\t\t#print 'B = ', B, '(', a2.name , ')'\n\t\t\t\t\t\t\t\t#print 'C = ', C, '(', a3.name , ')'\n\t\t\t\t\t\t\t\tR = i[1][1][2]\n\t\t\t\t\t\t\t\t#print 'R = ', R\n\t\t\t\t\t\t\t\ttheta = i[1][2]\n\t\t\t\t\t\t\t\tif theta > pi/2:\n\t\t\t\t\t\t\t\t\ttheta = pi - theta\n\t\t\t\t\t\t\t\t#print 'theta = ', theta, numpy.rad2deg(theta)\n\t\t\t\t\t\t\t\tphi = i[2]\n\t\t\t\t\t\t\t\tif phi < 0:\n\t\t\t\t\t\t\t\t\tphi = pi - phi\n\t\t\t\t\t\t\t\t#print 'phi = ', phi, numpy.rad2deg(phi)\n\t\t\t\t\t\t\t\tAB = B - A\t# B - A\n\t\t\t\t\t\t\t\t#print 'AB = ', AB\n\t\t\t\t\t\t\t\tBC = C - B\t# C - B\n\t\t\t\t\t\t\t\t#print 'BC = ', BC\n\t\t\t\t\t\t\t\tbc = BC.normal()\n\t\t\t\t\t\t\t\t#print 'bc = ', bc\n\t\t\t\t\t\t\t\tn = AB.cross(bc)\n\t\t\t\t\t\t\t\tn = n.normal()\n\t\t\t\t\t\t\t\t#print 'n = ', n\n\t\t\t\t\t\t\t\tMx = bc\n\t\t\t\t\t\t\t\t#print 'Mx = ', Mx\n\t\t\t\t\t\t\t\tMy = n.cross(bc)\n\t\t\t\t\t\t\t\tMy = My.normal()\n\t\t\t\t\t\t\t\t#print 'My = ', My\n\t\t\t\t\t\t\t\tMz = n\n\t\t\t\t\t\t\t\t#print 'Mz = ', Mz\n\t\t\t\t\t\t\t\tM = Tensor([ [Mx.x(), Mx.y(), Mx.z()],\\\n\t\t\t\t\t\t\t\t\t\t\t [My.x(), My.y(), My.z()],\\\n\t\t\t\t\t\t\t\t\t\t\t [Mz.x(), Mz.y(), Mz.z()] ])\n\t\t\t\t\t\t\t\t#print 'M: '\n\t\t\t\t\t\t\t\t#print M\n\t\t\t\t\t\t\t\tD2 = Vector(R*cos(theta), R*cos(phi)*sin(theta), R*sin(phi)*sin(theta))\n\t\t\t\t\t\t\t\t#print 'D2: '\n\t\t\t\t\t\t\t\t#print D2\n\t\t\t\t\t\t\t\tD = M*D2\n\t\t\t\t\t\t\t\tD = D + C\n\t\t\t\t\t\t\t\t#print 'D: '\n\t\t\t\t\t\t\t\t#print D\n\t\t\t\t\t\t\t\ta.setPosition(D)\n\t\t\t\t\t\t\t\tuniverse.atomList()[a4.index].setPosition(D)\n\t\t\t\t\t\t\t\t# Add a4 to KNOWN\n\t\t\t\t\t\t\t\tknown_atoms.append(a4)\n\t\t\t\t\t\t\t\tunknown_atoms.pop(ai)\n\t\t\t\t\t\t\t\t#print '========================'\n\t\t\t\t\t\t\t\tbreak\n\t\n\t\tfor k in known_atoms:\n\t\t\tbPDBprint_atom('HETATM', k.name, 10*k.position())\n\t\n\t\n\t# -----------------------------------\n\t\n\t\n\tdef inte2cart(self, dihe):\n\t\t\"\"\"\n\t\tReconstructs atomlist positions\n\t\tClassic\n\t\t:param universe: MMTK universe\n\t\t:type universe: MMTK universe\n\t\t:param dihe: list of dihedrals\n\t\t:type dihe: [[[],[],aval] , [[],[],aval] , dval] where [] is a bond\n\t\t\"\"\"\n\t\tknown_atoms = []\n\t\tunknown_atoms = copy.deepcopy(universe.atomList())\n\t\tC = Vector(0,0,0)\n\t\tD0 = Vector(0,0,0)\n\t\tD1 = Vector(0,0,0)\n\t\tD = Vector(0,0,0)\n\t\tD2 = Vector(0,0,0)\n\t\tl = len(dihe)\n\t\tfor di in range(l):\t# Create the START stack\n\t\t\tdihe.append(self.swap_dihe(dihe[di]))\n\t\n\t\n\t\t# Assign initial values\n\t\ti = dihe[0]\n\t\ta1 = i[0][0][0]\n\t\ta2 = i[0][0][1]\n\t\ta3 = i[1][1][0]\n\t\ta4 = i[1][1][1]\n\t\tR1 = i[0][0][2]\n\t\tR2 = i[1][1][2]\n\t\ttheta1 = i[0][2]\n\t\tphi = i[2]\n\t\tuniverse.atomList()[a1.index].setPosition(Vector(0,0,0))\n\t\tuniverse.atomList()[a2.index].setPosition(Vector(R1,0,0))\n\t\tuniverse.atomList()[a3.index].setPosition(Vector(R1-R2*cos(theta1), R2*sin(theta1), 0))\n\t\tknown_atoms.append(a1)\n\t\tknown_atoms.append(a2)\n\t\tknown_atoms.append(a3)\n\t\n\t\t# Main loop\n\t\tcnt=0;\n\t\twhile len(known_atoms) < len(universe.atomList()):\n\t\t\tcnt += 1\n\t\t\tif cnt > 9999:\n\t\t\t\tprint 'inte2cart() cnt EXCEEDED: 9999'\n\t\t\t\tbreak\n\t\t\tai = -1\n\t\t\tfor a in unknown_atoms:\n\t\t\t\tai += 1\n\t\t\t\tfor i in dihe:\t\t\t\t# Search if atom a is a4 in any dihe\n\t\t\t\t\ta1 = i[0][0][0]\n\t\t\t\t\ta2 = i[0][0][1]\n\t\t\t\t\ta3 = i[1][0][1]\n\t\t\t\t\ta4 = i[1][1][1]\n\t\t\t\t\ta1known = 0\n\t\t\t\t\ta2known = 0\n\t\t\t\t\ta3known = 0\n\t\t\t\t\ta4known = 0\n\t\t\t\t\tif a4.index == a.index:\n\t\t\t\t\t\tfor k in known_atoms:\t# Check if atom is in KNOWN stack\n\t\t\t\t\t\t\tif a4.index == k.index:\n\t\t\t\t\t\t\t\ta4known = 1\n\t\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\t\tif a1.index == k.index :\n\t\t\t\t\t\t\t\ta1known = 1\n\t\t\t\t\t\t\tif a2.index == k.index :\n\t\t\t\t\t\t\t\ta2known = 1\n\t\t\t\t\t\t\tif a3.index == k.index :\n\t\t\t\t\t\t\t\ta3known = 1\n\t\t\t\t\t\tif ((a4known == 0) and \\\n\t\t\t\t\t\t\t(a1known == 1) and (a2known == 1) and (a3known == 1)):\n\t\t\t\t\t\t\t\t# Move everything so that a3 is in the center\n\t\t\t\t\t\t\t\tM = Translation(-1*a3.position())\n\t\t\t\t\t\t\t\tuniverse.applyTransformation(M)\n\t\t\t\t\t\t\t\tfor k in known_atoms:\n\t\t\t\t\t\t\t\t\tM(k.position())\n\t\t\t\t\t\t\t\t# Solve a4\n\t\t\t\t\t\t\t\tA = a1.position()\n\t\t\t\t\t\t\t\tB = a2.position()\n\t\t\t\t\t\t\t\tC = a3.position()\n\t\t\t\t\t\t\t\t#print 'SOLVE: ', a4\n\t\t\t\t\t\t\t\tR = i[1][1][2]\n\t\t\t\t\t\t\t\ttheta = pi-i[1][2]\n\t\t\t\t\t\t\t\tphi = i[2]\n\t\t\t\t\t\t\t\tAB = B - A\t# B - A\n\t\t\t\t\t\t\t\tBC = C - B\t# C - B\n\t\t\t\t\t\t\t\tbc = BC.normal()\n\t\t\t\t\t\t\t\tn = AB.cross(bc)\n\t\t\t\t\t\t\t\tn = n.normal()\n\t\t\t\t\t\t\t\tD0 = C + (bc*R)\n\t\t\t\t\t\t\t\tM = Rotation(n, theta)\n\t\t\t\t\t\t\t\tD1 = M(D0)\n\t\t\t\t\t\t\t\tM = Rotation(bc, phi)\n\t\t\t\t\t\t\t\tD = M(D1)\n\t\t\t\t\t\t\t\ta.setPosition(D)\n\t\t\t\t\t\t\t\tuniverse.atomList()[a4.index].setPosition(D)\n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t# Add a4 to KNOWN\n\t\t\t\t\t\t\t\tknown_atoms.append(a4)\n\t\t\t\t\t\t\t\tunknown_atoms.pop(ai)\n\t\t\t\t\t\t\t\tbreak\n\t\n\t\tfor k in known_atoms:\n\t\t\tbPDBprint_atom('HETATM', k.name, 10*k.position())\n\t\n\t# -----------------------------------\n\n\nclass bRBSelector():\n\t\"\"\"\n\tFinds and writes rigid bodies as lists\n\t\"\"\"\n\tdef __init__(self, universe, convertor):\n\t\t\"\"\"\n\t\t:param universe: an MMTK universe\n\t\t:type universe: MMTK universe\n\t\t:param bonds: lists of precomputed bonds\n\t\t:type bonds: a list of 3 element lists: [a1,a2,bval]\n\t\t\"\"\"\n\t\t#Variables\n\t\tself.bonds = convertor.bonds\t#\n\t\tself.dihedrals = convertor.dihedrals\n\t\tself.convertor = convertor #\n\t\tself.cnt = 0\t\t#checks if infinite loop\n\t\tself.bibonds = []\t#an element is a bond with an index attached\n\t\tself.bibonds_dict = {}\n\t\tself.wostack = []\t#stack which uses bibonds element types (work)\n\t\tself.rings = []\t\t#stack which uses bibonds element types\t(rings deposit)\n\t\tself.trash = []\t\t#stack which uses bibonds element types (recovery)\n\t\tself.index = 0\t\t#used to identify bonds !not the same as Atom.index\n\t\tself.inbuff = []\t#indexes buffer used in inrings\n\t\tself.inrings = []\t#list of sorted lists of indexes\n\t\tself.buff = []\n\t\tself.conv = 0\n\t\tself.atring = []\t#list of lists of atom indexes in rings\n\t\tself.atbond = []\t#list of 2-tuples atom indexes in rigid bonds\n\t\tself.atatom = []\t#list of 2 tuples [atom, valence]\n\t\tself.atconj = []\t#list of conjugate multiple bonds\n\t\tself.atrb = []\n\t\tself.stickbonds = []\n\n\tdef __getstate__(self):\n\t\treturn self.atring\n\n\tdef findPaths(self):\n\t\t# Fill the START stack (bibonds)\n\t\tself.index = 0\n\t\tfor i in self.bonds :\n\t\t\tself.index += 1\n\t\t\tself.bibonds.append([i, self.index])\n\t\t\tself.bibonds.append([convertor.swap_bond(i), self.index])\n\t\t\tself.bibonds_dict[self.index] = i\n\t\t# Kickstart - put the first element in WORK stack (wostack)\n\t\tself.wostack.append(self.bibonds[-1])\n\t\tself.bibonds.pop()\n\t\t# Main\n\t\twhile True:\n\t\t\tif not self.bibonds:\n\t\t\t\tbreak\n\t\t\telif not self.wostack:\n\t\t\t\tself.wostack.append(self.bibonds[-1])\n\t\t\t\tself.bibonds.pop()\n\t\t\telse:\n\t\t\t\tself.cnt += 1\n\t\t\t\tif self.cnt > (universe.numberOfAtoms()*universe.numberOfAtoms()):\n\t\t\t\t\tprint 'findPaths(): cnt EXCEEDED!'\n\t\t\t\t\tbreak\n\t\t\t\tif not self.wostack:\n\t\t\t\t\tbreak\n\t\t\t\telse:\n\t\t\t\t\tfound_link = 0\n\t\t\t\t\tfor i in range(len(self.bibonds)) :\n\t\t\t\t\t\tif ( (self.wostack[-1][0][1].index == self.bibonds[i][0][0].index) and \\\n\t\t\t\t\t\t\t (self.wostack[-1][1] != self.bibonds[i][1])):\n\t\t\t\t\t\t\tfound_link = 1\n\t\t\t\t\t\t\tself.wostack.append(self.bibonds[i])\n\t\t\t\t\t\t\tself.bibonds.pop(i)\n\t\t\t\t\t\t\t# Check for rings\n\t\t\t\t\t\t\twolen = len(self.wostack)\n\t\t\t\t\t\t\tif(wolen >=3):\n\t\t\t\t\t\t\t\tfor j in range(-3, -1 * wolen, -1) :\n\t\t\t\t\t\t\t\t\t#print 'wostack[',j,']:',wostack[j]\n\t\t\t\t\t\t\t\t\t#Check for circular path\n\t\t\t\t\t\t\t\t\tif ((self.wostack[-1][0][1].index == self.wostack[j][0][0].index) and\\\n\t\t\t\t\t\t\t\t\t\t(self.wostack[-1][1] != self.wostack[j][1])):\n\t\t\t\t\t\t\t\t\t\tself.inbuff = []\n\t\t\t\t\t\t\t\t\t\tfor k in range(wolen+j, wolen):\n\t\t\t\t\t\t\t\t\t\t\tself.inbuff.append(self.wostack[k][1])\n\t\t\t\t\t\t\t\t\t\t#Check if path has two way bonds\n\t\t\t\t\t\t\t\t\t\tbonds_doubled = 0\n\t\t\t\t\t\t\t\t\t\tif len(self.inbuff) > len(set(self.inbuff)) :\n\t\t\t\t\t\t\t\t\t\t\tbonds_doubled = 1\n\t\t\t\t\t\t\t\t\t\t#Check if ring is already in the rings stack\n\t\t\t\t\t\t\t\t\t\tself.inbuff.sort()\n\t\t\t\t\t\t\t\t\t\tring_already_in = 0\n\t\t\t\t\t\t\t\t\t\tfor t in self.inrings :\n\t\t\t\t\t\t\t\t\t\t\tif self.inbuff == t:\n\t\t\t\t\t\t\t\t\t\t\t\tring_already_in = 1\n\t\t\t\t\t\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\t\t\t\t\t#Copy a new ring to rings\n\t\t\t\t\t\t\t\t\t\tif (ring_already_in == 0) and (bonds_doubled == 0):\n\t\t\t\t\t\t\t\t\t\t\tfor k in range(wolen+j, wolen):\n\t\t\t\t\t\t\t\t\t\t\t\tself.rings.append(self.wostack[k])\n\t\t\t\t\t\t\t\t\t\t\tself.inrings.append(self.inbuff)\n\t\t\t\t\t\t\t\t\t\tbreak\n\t\t\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\tif found_link == 0:\n\t\t\t\t\t\tself.trash.append(self.wostack[-1])\n\t\t\t\t\t\tself.wostack.pop()\n\n\t\t# Prepare a list of names\n\t\ti = 0\n\t\tfor m in self.inrings :\n\t\t\tself.buff = []\n\t\t\tfor n in m :\n\t\t\t\tself.buff.append(self.bibonds_dict[n][0].index)\n\t\t\t\tself.buff.append(self.bibonds_dict[n][1].index)\n\t\t\tself.buff = set(self.buff)\n\t\t\tself.atring.append(list(self.buff))\n\n\t\t# ---------------------------------------------------------------\n\n\tdef check_for_cond_rings(self, bonds, conv) :\n\t\tfor mi in range(len(self.atring)) :\n\t\t\tfor ni in range(len(self.atring)) :\n\t\t\t\tself.buff = []\n\t\t\t\tif bcontains(self.atring[mi], self.atring[ni]) == 1 :\n\t\t\t\t\t# Extract the hidden ring\n\t\t\t\t\tself.buff = list(set(self.atring[mi])-set(self.atring[ni]))\n\t\t\t\t\tbuffbuff = []\n\t\t\t\t\tfor o in self.atring[ni] :\t# closed ring\n\t\t\t\t\t\tfor p in self.buff :\t\t# diff\n\t\t\t\t\t\t\tfound_bond = 0\n\t\t\t\t\t\t\tif (p != o) :\n\t\t\t\t\t\t\t\tfor r in bonds :\n\t\t\t\t\t\t\t\t\tif ( ((r[0].index == o) and (r[1].index == p)) or\\\n\t\t\t\t\t\t\t\t\t\t ((r[1].index == o) and (r[0].index == p)) ):\n\t\t\t\t\t\t\t\t\t\tbuffbuff.append(o)\n\t\t\t\t\t\t\t\t\t\tfound_bond = 1\n\t\t\t\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\t\tif found_bond == 1 :\n\t\t\t\t\t\t\t\tbreak\n\t\t\t\t\tfor s in list(set(buffbuff)) :\n\t\t\t\t\t\tself.buff.append(s)\n\t\t\t\t\t\n\t\t\t\t\tself.atring.append(self.buff)\n\t\t\t\t\tself.atring.pop(mi)\n\t\n\t\t\t\t\tc = 0\n\t\t\t\t\tfor zi in (range(len(self.atring))) :\n\t\t\t\t\t\tc += len(self.atring[zi])\n\t\t\t\t\tif c == conv : # check for convergence\n\t\t\t\t\t\treturn\n\t\n\t\t\t\t\tself.check_for_cond_rings( bonds, c)\t#recursivity\n\t\t\t\t\t#break\n\t\n\tdef untangleCondensed(self):\n\t\tself.conv = 0\t#convergence\n\t\tself.check_for_cond_rings(self.bonds, self.conv)\n\t\t# Sort atring\n\t\tfor i in self.atring:\n\t\t\ti.sort()\n\t\tself.atring.sort()\n\n\tdef find_rings(self):\n\t\tself.findPaths()\n\t\tself.untangleCondensed()\n\n\tdef print_atring(self):\n\t\t\"\"\"Prints atring list to stdout\"\"\"\n\t\tif(len(self.atring) > 1) :\n\t\t\tif(self.atring[0] != self.atring[1]) :\n\t\t\t\tprint self.atring[0]\n\t\t\tfor i in range(1,len(self.atring)):\n\t\t\t\tif self.atring[i] != self.atring[i-1] :\n\t\t\t\t\tprint self.atring[i]\n\t\telif (len(self.atring) == 1):\n\t\t\tprint self.atring[0]\n\t\telse:\n\t\t\tprint 'No rings found'\n\t#---------------------------------------------\n\n\tdef print_rings(self):\n\t\t\"\"\"Prints ring atom names to stdout\"\"\"\n\t\tfin_string = \"\"\n\t\tfin_string += 'rings = ['\n\t\tt = 0\n\t\tif(len(self.atring) > 1) :\n\t\t\tif(self.atring[0] != self.atring[1]) :\n\t\t\t\t#print self.atring[0]\n\t\t\t\tif t != 0: fin_string += ', '\n\t\t\t\tt += 1\n\t\t\t\tfin_string += '['\n\t\t\t\tk = 0\n\t\t\t\tfor z in self.atring[0]:\n\t\t\t\t\tif k != 0: fin_string += ', '\n\t\t\t\t\tfin_string += universe.atomList()[z].name\n\t\t\t\t\tk += 1\n\t\t\t\tfin_string += ']'\n\t\t\tfor i in range(1,len(self.atring)):\n\t\t\t\tif self.atring[i] != self.atring[i-1] :\n\t\t\t\t\t#print self.atring[i]\n\t\t\t\t\tif t != 0: fin_string += ', '\n\t\t\t\t\tt += 1\n\t\t\t\t\tfin_string += '['\n\t\t\t\t\tk = 0\n\t\t\t\t\tfor z in self.atring[i]:\n\t\t\t\t\t\tif k != 0: fin_string += ', '\n\t\t\t\t\t\tfin_string += universe.atomList()[z].name\n\t\t\t\t\t\tk += 1\n\t\t\t\t\tfin_string += ']'\n\t\telif (len(self.atring) == 1):\n\t\t\t#print self.atring[0]\n\t\t\tif t != 0: fin_string += ', '\n\t\t\tt += 1\n\t\t\tfin_string += '['\n\t\t\tk = 0\n\t\t\tfor z in self.atring[0]:\n\t\t\t\tif k != 0: fin_string += ', '\n\t\t\t\tfin_string += universe.atomList()[z].name\n\t\t\t\tk += 1\n\t\t\tfin_string += ']'\n\t\telse:\n\t\t\tpass\n\t\t\t#print 'No rings found'\n\t\tfin_string += ']'\n\t\tprint fin_string\n\t#---------------------------------------------\n\n\n\tdef growRB(self):\n\t\t\"\"\"\n\t\tGrows rigid bodies starting from\n\t\trigid bonds (C-H, X=X) and rings\n\t\t\"\"\"\n#\t\tprint 'BEGIN growRB ============='\n\t\t# Build atatom list ([atom, unsaturated rank])\n\t\tfor ai in universe.atomList():\n\t\t\tunsat = bisSaturated(ai.type.symbol, len(ai.bondedTo()))\n\t\t\tif unsat > 0:\n\t\t\t\tself.atatom.append([ai.index, unsat])\n\n\t\t# Build atbond list (bonds with sp2 or sp atoms)\n\t\tself.atbond = []\n\t\tfor ata in self.atatom:\n\t\t\tring_found1 = 0\n\t\t\tfor ri in self.atring:\t\t# Check if ata is in any ring\n\t\t\t\tfor rj in ri:\n\t\t\t\t\tif ata[0] == rj:\n\t\t\t\t\t\tring_found1 = 1\n\t\t\t\t\t\t#break\t\t\t# Atom 1 touches a ring\n\t\t\t\tif ring_found1 == 1:\n\t\t\t\t\tpass\n\t\t\t\t\t#break\t\t\t\t# Checked\n\t\t\tfor atb in self.atatom:\t# Check if atb is in any ring\n\t\t\t\tring_found2 = 0\n\t\t\t\tfor ri in self.atring:\n\t\t\t\t\tfor rj in ri:\n\t\t\t\t\t\tif atb[0] == rj:\n\t\t\t\t\t\t\tring_found2 = 1\n\t\t\t\t\t\t\t#break\t# Atom 2 touches a ring\n\t\t\t\tif (ring_found2 == 0) or (ring_found1 == 0):\n\t\t\t\t\tif ata.index < atb.index:\n\t\t\t\t\t\tfor bo in universe.atomList()[ata[0]].bondedTo():\n\t\t\t\t\t\t\tif bo.index == atb[0]:\n\t\t\t\t\t\t\t\tself.atbond.append([ata[0],atb[0]])\n\t\t\t\t\t\t\t\tbreak\n\n\n\t\tfin_str = \"\"\n\t\tfin_str += 'non_ring_pi_bonds = [' # len(self.atbond)\n\t\tk = 0\n\t\tfor bo in self.atbond:\n\t\t\t#print universe.atomList()[bo[0]].name, universe.atomList()[bo[1]].name\n\t\t\tif k != 0: fin_str += ', '\n\t\t\tfin_str += 'Bond('\n\t\t\tfin_str += universe.atomList()[bo[0]].name\n\t\t\tfin_str += ', '\n\t\t\tfin_str += universe.atomList()[bo[1]].name\n\t\t\tfin_str += ')'\n\t\t\tk += 1\n\t\tfin_str += ']'\n\t\tprint fin_str\n#\t\t\tprint bo\n#\t\tprint '------------------'\n\n\n# THE FOLLOWING CODE IS NOT NECESSARY\n#\t\tfor ri in self.atring:\t# Eliminates bonds sticked into rings BUG !!\n#\t\t\tfor rj in ri:\n#\t\t\t\tle = len(self.atbond)\n#\t\t\t\tfor bi in range(le):\n#\t\t\t\t\tif (self.atbond[bi][0] == rj) or (self.atbond[bi][1] == rj):\n#\t\t\t\t\t\tself.atbond.pop(bi)\n#\t\t\t\t\t\tbreak\n#\n#\t\tprint len(self.atbond), ': multiple bonds without sticked: '\n#\t\tfor bo in self.atbond:\n#\t\t\tprint universe.atomList()[bo[0]].name, universe.atomList()[bo[1]].name\n#\t\t\t#print bo\n#\t\tprint '------------------'\n\n\t\t# Build atconj - merge multiple bonds in conjugated systems\n\t\tself.atconj = copy.deepcopy(self.atbond)\n\t\tbuff = []\n\t\tcnt = 0\n\t\tmerge_found = 1\n\t\twhile (merge_found == 1) and (cnt < 100):\n\t\t\tcnt += 1\n\t\t\tmerge_found = 0\n\t\t\tfor coi in range(len(self.atconj)):\n\t\t\t\tfor coj in range(len(self.atconj)):\n\t\t\t\t\tif coj != coi:\n\t\t\t\t\t\t# Check if they have a common atom (to merge them)\n\t\t\t\t\t\tfor i in self.atconj[coi]:\n\t\t\t\t\t\t\tfor j in self.atconj[coj]:\n\t\t\t\t\t\t\t\tif i == j:\n\t\t\t\t\t\t\t\t\tmerge_found = 1\n\t\t\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\t\tif merge_found == 1:\n\t\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\tif merge_found == 1:\t# Add coj to coi (merge)\n\t\t\t\t\t\t\tbuff = []\n\t\t\t\t\t\t\tfor j in self.atconj[coj]:\n\t\t\t\t\t\t\t\tcommon = 0\n\t\t\t\t\t\t\t\tfor i in self.atconj[coi]:\n\t\t\t\t\t\t\t\t\tif i == j:\n\t\t\t\t\t\t\t\t\t\tcommon = 1\n\t\t\t\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\t\t\tif common == 0:\n\t\t\t\t\t\t\t\t\tbuff.append(j)\n\t\t\t\t\t\t\tfor t in buff:\n\t\t\t\t\t\t\t\tself.atconj[coi].append(t)\n\t\t\t\t\t\t\t# Print the new conj\n\t\t\t\t\t\t\t# Remove bond coj \n\t\t\t\t\t\t\tself.atconj.pop(coj) # Eliminate coj from atconj\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\tif merge_found == 1:\n\t\t\t\t\t\tbreak\n\t\t\t\tif merge_found == 1:\n\t\t\t\t\tbreak\n\n\n#\t\tprint 'Conjugated systems: '\n#\t\tfor coi in self.atconj:\n#\t\t\t\tfor k in coi:\n#\t\t\t\t\tprint universe.atomList()[k].name, ' ',\n#\t\t\t\tprint\n\t\t\t\n#\t\tprint 'END growRB ================'\n\n\n\tdef diffPseudoDihe(self):\n\t\t\"\"\"\n\t\tEliminates correlated dihedrals by \n\t\treplacing them with differences\n\t\t\"\"\"\n\t\tprint 'BEGIN diffPseudoDihe() =========='\n\t\t#for ai in universe.atomList():\n\t\t#\tprint ai.position()\n\n\t\t#for bi in self.atbond:\n\t\t#\tprint 'atbond', universe.atomList()[bi[0]].name, universe.atomList()[bi[1]].name\n\n\t\t#for di in self.dihedrals:\n\t\t#\tconvertor.print_zmat_dihe(di)\n\n\t\t#Stickbonds\n\t\tself.stickbonds = []\n\t\tfor bi in self.bonds:\n\t\t\tat1found = -1\n\t\t\tat2found = -1\n\t\t\tfor ri in self.atring: # Search the rings\n\t\t\t\tfor rj in ri:\n\t\t\t\t\tif (bi[0].index == rj) and \\\n\t\t\t\t\t\t(universe.atomList()[bi[1].index].type.symbol != 'H'):\n\t\t\t\t\t\tat1found = rj\n\t\t\t\t\telif (bi[1].index == rj) and \\\n\t\t\t\t\t\t(universe.atomList()[bi[0].index].type.symbol != 'H'):\n\t\t\t\t\t\tat2found = rj\n\t\t\tif ((at1found >= 0) and (at2found == -1) or\\\n\t\t\t\t(at1found == -1) and (at2found >= 0)):\n\t\t\t\tself.stickbonds.append([bi[0].index, bi[1].index])\n\t\t\n#\t\tprint 'Sticked bonds:'\t\t\t\t\n#\t\tfor bi in self.stickbonds:\n#\t\t\tprint universe.atomList()[bi[0]].name, universe.atomList()[bi[1]].name\n\n\n\t\tfor ri in self.atring:\n\t\t\tprint ri\n\t\t\tfor rj in ri:\n\t\t\t\tstick = -1\n\t\t\t\tfor bi in self.stickbonds:\n\t\t\t\t\tif bi[0] == rj:\n\t\t\t\t\t\tstick = 1\n\t\t\t\t\telif bi[1] == rj:\n\t\t\t\t\t\tstick = 0\n\t\t\t\t\tif stick >= 0:\n\t\t\t\t\t\tprint '[',universe.atomList()[bi[0]].name,\\\n\t\t\t\t\t\t\t\tuniverse.atomList()[bi[1]].name, '] :'\n\t\t\t\t\t\t# Search dihedrals\n\t\t\t\t\t\tfor di in self.dihedrals:\n\t\t\t\t\t\t\ta2 = di[0][0][1]\n\t\t\t\t\t\t\ta3 = di[1][0][1]\n\t\t\t\t\t\t\tif ((a2.index == bi[0] and a3.index == bi[1]) or\\\n\t\t\t\t\t\t\t\t(a2.index == bi[1] and a3.index == bi[0])):\n\t\t\t\t\t\t\t\t\tconvertor.print_zmat_dihe(di)\n\t\t\t\t\t\tprint '+++++++++++++++'\n\t\t\t\t\t\tbreak\n\n\t\tprint 'END diffPseudoDihe() =========='\n\n#-------------------------------------------------------------------------\n\n\n########\n# MAIN #\n########\n\n# BUILD MOLECULE #\n\n# \"Declare\" some variables\nnatm = 0;\natmi = 0;\nx = .0;\ny = .0;\nz = .0;\nelem = '--';\nname = [];\n##################\n\nfpo1 = open(sys.argv[1], 'r');\n\nfactory = MoleculeFactory();\nfactory.createGroup('main');\n\nlinecnt = 0;\nwhile True:\n\tline = fpo1.readline();\n\tif not line: break;\n\tlinecnt += 1;\n\tif linecnt == 4:\n\t\tnatm = int(bsubstr(line, 1, 3));\n\tif (linecnt >= 5) and (linecnt < (5 + natm)): # Read cart coords\n\t\tatmi += 1;\n\t\tx = float(bsubstr(line, 2, 9));\n\t\ty = float(bsubstr(line, 12, 9));\n\t\tz = float(bsubstr(line, 22, 9));\n\t\telem = bsubstr(line, 32, 2);\n\t\tif elem[1] == ' ':\n\t\t\telem = elem[0];\n\t\tname.append(elem + str(atmi));\n\t\tfactory.addAtom('main',name[atmi-1],elem);\n\t\tfactory.setPosition('main',name[atmi-1],Vector\\\n\t\t\t(x*Units.Ang, y*Units.Ang, z*Units.Ang));\n\tif linecnt >= (5 + natm):\n\t\tif line[0] == 'M': break\n\t\tfactory.addBond('main',\\\n\t\t\tname[int(bsubstr(line,1,3))-1], name[int(bsubstr(line,4,3))-1]);\n\nfpo1.close();\n\nnewmol = factory.retrieveMolecule('main');\nuniverse = InfiniteUniverse(Amber99ForceField(mod_files=['frcmod.ff99SB']));\nuniverse.addObject(newmol);\nuniverse.configuration();\n\n# -------------------------------------------\n\n#anchor(universe)\t# BUG pseudo01.sdf when first atom has only one bond\n\n#universe.writeXML(file('out.xml', 'w'));\n#universe.writeToFile('out.pdb');\n\nconvertor = bConvertor(universe)\nconvertor.cart2all_internals()\n#convertor.print_internals()\n\n#print '\\n++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\\n'\n#for i in convertor.dihedrals:\n#\tconvertor.print_zmat_dihe(i)\n#convertor.inte2cart(convertor.dihedrals)\n\n# Print rings\nrb_selector = bRBSelector(universe, convertor)\nrb_selector.find_rings()\n#rb_selector.print_atring()\nrb_selector.print_rings()\nrb_selector.growRB()\n#rb_selector.diffPseudoDihe()\n\n\n\n\n\n\n\n", "meta": {"hexsha": "c7aa64e124bba8575a3c48fac02aca0f9eae1a48", "size": 29770, "ext": "py", "lang": "Python", "max_stars_repo_path": "Pipeline/32rigid_bodies.py", "max_stars_repo_name": "CCBatIIT/AlGDock", "max_stars_repo_head_hexsha": "25c376e9d860d50696f5e20f1b107d289ec0903c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 15, "max_stars_repo_stars_event_min_datetime": "2015-06-16T19:25:07.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-27T05:50:47.000Z", "max_issues_repo_path": "Pipeline/32rigid_bodies.py", "max_issues_repo_name": "biocheming/AlGDock", "max_issues_repo_head_hexsha": "25c376e9d860d50696f5e20f1b107d289ec0903c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 8, "max_issues_repo_issues_event_min_datetime": "2015-05-06T21:05:09.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-11T09:51:45.000Z", "max_forks_repo_path": "Pipeline/32rigid_bodies.py", "max_forks_repo_name": "biocheming/AlGDock", "max_forks_repo_head_hexsha": "25c376e9d860d50696f5e20f1b107d289ec0903c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 23, "max_forks_repo_forks_event_min_datetime": "2015-04-13T21:11:03.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-11T00:25:42.000Z", "avg_line_length": 26.7715827338, "max_line_length": 185, "alphanum_fraction": 0.5418878065, "include": true, "reason": "import numpy", "num_tokens": 10424, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041652, "lm_q2_score": 0.3738758227716966, "lm_q1q2_score": 0.19131846660970883}} {"text": "# %% [markdown]\n\"\"\"\ncalculate ODNP using DNPLab\n===========================\n\nThis example demonstrates how to use the dnplab.dnpHydration module\n\n\"\"\"\n# %%\n\n# %% [markdown]\n# First import dnplab and numpy,\nimport dnplab\nimport numpy as np\n\n# %%\n\n# %% [markdown]\n# To use the dnpHydration module first create a dictionary with the necessary inputs. Start by creating a workspace and assinging an inputs dictionary to the key **'hydration_inputs'**. For example,\n\nEnhancements = [] # list of signal enhancements\nEnhancement_powers = [] # list of powers in Watts corresponding to Enhancements\nT1s = [] # list of T1 values in seconds\nT1_powers = [] # list of powers in Watts corresponding to T1s\n\ninputs = {\n 'E_array' : np.array(Enhancements),\n 'E_powers' : np.array(Enhancement_powers),\n 'T1_array' : np.array(T1s),\n 'T1_powers' : np.array(T1_powers),\n 'T10': 2.0, # T1 measured with power=0\n 'T100': 2.5, # T1 measured with SL=0 and power=0\n 'spin_C': 100, # spin concentration in micromolar\n 'field': 350, # magnetic field in mT\n 'smax_model': 'tethered', # choice of smax model\n 'interpolate_method': 'second_order' # choice of interpolation method\n }\n# %%\n\n# %% [markdown]\n# Now you can either create a workspace and add the dictionary under the key **'hydration_inputs'**,\nworkspace = dnplab.create_workspace('hydration_inputs', inputs)\n# %%\n\n# %% [markdown]\n# Or add to an existing workspace,\nworkspace.add('hydration_inputs', inputs)\n# %%\n\n# %% [markdown]\n# In rare cases the bulk water or second order T1 interpolation constants may need to be altered. This is not necessary for the odnp module to operate, but if needed this can be done by adding the dictionary **'hydration_constants'** to the workspace. For example,\nconstants = {\n 'ksigma_bulk': 95.4, # bulk ksigma value\n 'krho_bulk': 353.4, # bulk krho value\n 'klow_bulk': 366, # bulk klow value\n 'tcorr_bulk': 54, # bulk tcorr value\n 'D_H2O': 2.3e-9, # bulk water diffusivity\n 'D_SL': 4.1e-10, # diffusivity of spin probe in bulk water\n 'delta_T1_water': 1, # change in water proton T1 due to microwaves\n 'T1_water': 2.5, # T1 of bulk water protons\n 'macro_C': 100, # concentration of macromolecule in uM\n }\n\nworkspace.add('hydration_constants', constants)\n# %%\n\n# %% [markdown]\n# Next, pass the workspace to dnplab.dnpHydration.hydration to perform calculations using,\nhydration_results = dnplab.dnpHydration.hydration(workspace)\n# %%\n\n# %% [markdown]\n# or operate in-place with:\ndnplab.dnpHydration.hydration(workspace)\n# %%\n\n\n# %% [markdown]\n# For use without creating a DNPLab workspace simply skip the above steps and pass the dictionaries to dnpHydration directly,\nhydration_results = dnplab.dnpHydration.odnp(inputs=inputs, constants=constants)\n# %%\n", "meta": {"hexsha": "c292bab0e7c7679344fccdab60453dda562e57c5", "size": 2938, "ext": "py", "lang": "Python", "max_stars_repo_path": "examples/calculate_ODNP.py", "max_stars_repo_name": "tkeller12/hanlab", "max_stars_repo_head_hexsha": "9ce9d2545106b08256cc5bf16ea7e950c0603af6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "examples/calculate_ODNP.py", "max_issues_repo_name": "tkeller12/hanlab", "max_issues_repo_head_hexsha": "9ce9d2545106b08256cc5bf16ea7e950c0603af6", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "examples/calculate_ODNP.py", "max_forks_repo_name": "tkeller12/hanlab", "max_forks_repo_head_hexsha": "9ce9d2545106b08256cc5bf16ea7e950c0603af6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-02-22T22:04:26.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-22T22:04:26.000Z", "avg_line_length": 35.8292682927, "max_line_length": 264, "alphanum_fraction": 0.6678012253, "include": true, "reason": "import numpy", "num_tokens": 779, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.3738758157951908, "lm_q1q2_score": 0.191318463039715}} {"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# ### Hill Climber algorithm to generate a team\n# \n# - takes in the list of available players for the gameweek with their predicted scores from the player model\n# - constructs a 15-man squad adhering to budget connstraints and team constraints set by FPL\n\n# In[ ]:\n\n\nimport numpy as np\nimport pandas as pd\nimport random as rd\nimport random\nfrom random import randint\nfrom random import sample\nimport matplotlib.pyplot as plt\nimport requests\npd.options.display.max_rows = None\npd.options.display.max_columns = None\nimport itertools\n\n\n# In[78]:\n\n\nclass generate_team():\n \n def __init__(self, players):\n self.players = players\n self.initiate()\n \n def init_player_lists(self,players):\n #Method to initialise four vectors of 0, where each defines the position and is the length of the amount of\n #players in that position. Randomly assign 1's to an index in each list to initiate a squad\n #@params players = the list of available players\n #@return goalkeeper, defender, midfielder, attacker lists\n \n #make the lists from the actual players\n goalks, defs, mids, atts = [], [], [], []\n for i in players:\n if i[1] == 1:\n goalks.append(i)\n elif i[1] == 2:\n defs.append(i)\n elif i[1] == 3:\n mids.append(i)\n elif i[1] == 4:\n atts.append(i)\n \n #initialise each vector to have a random player, goalkeepers 2 players, def 5, mid 5, atk 3.\n goalkeepers = [0 for i in range(len(goalks))]\n x = [i for i in range(len(goalks))]\n random_numbers = random.sample(x, 2)\n for random_number in random_numbers:\n goalkeepers[random_number] = 1\n\n defenders = [0 for i in range(len(defs))]\n x = [i for i in range(len(defs))]\n random_numbers = random.sample(x, 5)\n for random_number in random_numbers:\n defenders[random_number] = 1\n\n midfielders = [0 for i in range(len(mids))]\n x = [i for i in range(len(mids))]\n random_numbers = random.sample(x, 5)\n for random_number in random_numbers:\n midfielders[random_number] = 1\n\n attackers = [0 for i in range(len(atts))]\n x = [i for i in range(len(atts))]\n random_numbers = random.sample(x, 3)\n for random_number in random_numbers:\n attackers[random_number] = 1\n\n return goalkeepers, defenders, midfielders ,attackers\n \n def init_hc(self,max_threshold, players):\n #Method to call initialise squad vectors. If the constraints are not met, repeat the initialisation\n #@params max_threshold = the budget constraint, players = the available players\n #@return goalkeeper, defender, midfielder, attacker lists\n \n goalkeeper, defender, midfielder, attacker = [], [], [], []\n for i in players:\n if i[1] == 1:\n goalkeeper.append(i)\n elif i[1] == 2:\n defender.append(i)\n elif i[1] == 3:\n midfielder.append(i)\n elif i[1] == 4:\n attacker.append(i)\n\n total_weight = max_threshold +1\n total_points = 51\n #total_weight cannot go over budget constraint\n while (total_weight > 100 or total_points < 50):\n gkp, defs, mids, atks = self.init_player_lists(players)\n g_weight = (sum([goalkeeper[i][4] for i in range(len(goalkeeper)) if gkp[i] == 1]))\n d_weight = (sum([defender[i][4] for i in range(len(defender)) if defs[i] == 1]))\n m_weight = (sum([midfielder[i][4] for i in range(len(midfielder)) if mids[i] == 1]))\n a_weight = (sum([attacker[i][4] for i in range(len(attacker)) if atks[i] == 1]))\n total_weight = g_weight + d_weight + m_weight + a_weight \n\n team_points = []\n team_points.append([goalkeeper[i][3] for i in range(len(goalkeeper)) if gkp[i] == 1])\n team_points.append([defender[i][3] for i in range(len(defender)) if defs[i] == 1])\n team_points.append([midfielder[i][3] for i in range(len(midfielder)) if mids[i] == 1]) \n team_points.append([attacker[i][3] for i in range(len(attacker)) if atks[i] == 1])\n team_points = list(itertools.chain(*team_points))\n total_points = sum(team_points)\n return gkp, defs, mids, atks\n\n def evaluate_fitness(self,max_threshold, players, gkp, defs, mids, atks):\n #Method to evaluate fitness by looking at the weight of the squad. Similarly, to see if any team has\n #more than 3 players in the squad. This is not allowed in FPL rules\n #@params max-threshold = budget, players = available players, gkp,defs,mids,atks = squad player vectors\n #@return fitness = how many projected points, team_weight = cost of squad, team_points = indiv player points\n team_weight= []\n team_points = []\n fitness = 0\n\n goalkeeper, defender, midfielder, attacker = [], [], [], []\n for i in players:\n if i[1] == 1:\n goalkeeper.append(i)\n elif i[1] == 2:\n defender.append(i)\n elif i[1] == 3:\n midfielder.append(i)\n elif i[1] == 4:\n attacker.append(i)\n \n #calculate weight of squad (total cost)\n team_weight.append([goalkeeper[i][4] for i in range(len(goalkeeper)) if gkp[i] == 1])\n team_weight.append([defender[i][4] for i in range(len(defender)) if defs[i] == 1])\n team_weight.append([midfielder[i][4] for i in range(len(midfielder)) if mids[i] == 1]) \n team_weight.append([attacker[i][4] for i in range(len(attacker)) if atks[i] == 1])\n team_weight = list(itertools.chain(*team_weight))\n\n #calculate total team points predicted \n team_points.append([goalkeeper[i][3] for i in range(len(goalkeeper)) if gkp[i] == 1])\n team_points.append([defender[i][3] for i in range(len(defender)) if defs[i] == 1])\n team_points.append([midfielder[i][3] for i in range(len(midfielder)) if mids[i] == 1]) \n team_points.append([attacker[i][3] for i in range(len(attacker)) if atks[i] == 1])\n team_points = list(itertools.chain(*team_points))\n\n #calculate how many players are from each team to see if gone over\n team_code = []\n team_code.append([goalkeeper[i][2] for i in range(len(goalkeeper)) if gkp[i] == 1])\n team_code.append([defender[i][2] for i in range(len(defender)) if defs[i] == 1])\n team_code.append([midfielder[i][2] for i in range(len(midfielder)) if mids[i] == 1]) \n team_code.append([attacker[i][2] for i in range(len(attacker)) if atks[i] == 1])\n team_code = list(itertools.chain(*team_code))\n overkill_team = False\n for team in range(1,21):\n i = 0\n for team_ in team_code:\n if team == team_:\n i+= 1\n if i > 3:\n #overkill = too many players from one team\n overkill_team = True\n \n #If team weight is too high or overkill is true, fitness of the squad is 0\n if sum(team_weight) > max_threshold or overkill_team is True:\n fitness = 0\n else:\n fitness = sum(team_points)\n return fitness, team_weight, team_points\n \n def mutate(self,mutation_rate, gkp, defs, mids, atks):\n #Method to mutate the squad in a certain way to find new better squads\n #@params mutation_rate = the likelihood of change, gkp,def,mids,atks = squad vectors\n #@return gkp,defs,mids,atks = new mutated squad\n \n a = rd.random()\n b = rd.random()\n c = rd.random()\n d = rd.random()\n \n #For each position, get a random number, swap out a current player and change a position in the vector\n #from zero to one to add a new player\n\n if a <= mutation_rate:\n x = [i for i in range(len(gkp))]\n random_number = random.sample(x, 1)\n present_numbers = [i for i in range(len(gkp))if gkp[i] == 1]\n #if player is already in the squad, dont do anything, if not carry on\n if random_number[0] not in present_numbers:\n #choose which player to remove randomly out of 2 players\n r = [i for i in range(0,2)]\n #remove the player\n remove_index = random.sample(r,1)\n for player in range(len(gkp)):\n if player == present_numbers[remove_index[0]]:\n gkp[player] = 0\n if player == random_number[0]:\n gkp[player] = 1\n\n if b <= mutation_rate:\n x = [i for i in range(len(defs))]\n random_number = random.sample(x, 1)\n present_numbers = [i for i in range(len(defs))if defs[i] == 1]\n #if player is already in the squad, dont do anything, if not carry on\n if random_number[0] not in present_numbers:\n #choose which player to remove randomly out of 5 players\n r = [i for i in range(0,5)]\n #remove the player\n remove_index = random.sample(r,1)\n for player in range(len(defs)):\n if player == present_numbers[remove_index[0]]:\n defs[player] = 0\n if player == random_number[0]:\n defs[player] = 1\n\n if c <= mutation_rate:\n x = [i for i in range(len(mids))]\n random_number = random.sample(x, 1)\n present_numbers = [i for i in range(len(mids))if mids[i] == 1]\n #if player is already in the squad, dont do anything, if not carry on\n if random_number[0] not in present_numbers:\n r = [i for i in range(0,5)]\n #choose which player to remove randomly out of 5 players\n remove_index = random.sample(r,1)\n #remove the player\n for player in range(len(mids)):\n if player == present_numbers[remove_index[0]]:\n mids[player] = 0\n if player == random_number[0]:\n mids[player] =1\n\n if d <= mutation_rate:\n x = [i for i in range(len(atks))]\n random_number = random.sample(x, 1)\n present_numbers = [i for i in range(len(atks))if atks[i] == 1]\n #if player is already in the squad, dont do anything, if not carry on\n if random_number[0] not in present_numbers:\n #choose which player to remove randomly out of 3 players\n r = [i for i in range(0,3)]\n #remove the player\n remove_index = random.sample(r,1)\n for player in range(len(atks)):\n if player == present_numbers[remove_index[0]]:\n atks[player] = 0\n if player == random_number[0]:\n atks[player] = 1\n\n return gkp, defs, mids, atks\n\n def hillclimber(self,gkp, defs, mids, atks, players, max_threshold, generations, mutation_rate):\n #Method to call hill climber algorithm with each individual method, used to rretrieve new better squads\n #@params gkp,defs,mids,atks = player vectors, max_threshold = budget, generations, mutation_rate\n #@return gkp,defs,mids,atks = player vectors, fitness = list of squad projected points over time\n \n fitness = []\n for i in range(generations):\n #if (i % 50000) == 0:\n #print(i/50000, \"% completed\")\n \n #make a copy of the exisiting squad\n gkp1 = gkp.copy()\n defs1 = defs.copy()\n mids1 = mids.copy()\n atks1 = atks.copy()\n\n #mutate copied squad, calc fitness of both new and old squads\n gkp1, defs1, mids1, atks1 = self.mutate(mutation_rate, gkp1, defs1, mids1, atks1)\n g0_fitness, team_weight, team_points = self.evaluate_fitness(max_threshold, players, gkp, defs, mids, atks)\n g1_fitness, team_weight, team_points = self.evaluate_fitness(max_threshold, players, gkp1, defs1, mids1, atks1)\n\n #if new squad has better fitness, this becomes the main squad\n if g1_fitness > g0_fitness:\n gkp = gkp1\n mids = mids1\n defs = defs1\n atks = atks1\n\n fitness.append(g0_fitness)\n\n return gkp, defs, mids, atks, fitness\n \n def graph(self,fitness,mutation_rate, players, gkp, defs, mids, atks,generations):\n #Method to call a visual representation of the graph\n #@params fitness = squad fitness, mutation_rate, players = available players, squad vectors, generations\n #@return total team points and total team weight\n \n #print(\"Mutation rate = \", mutation_rate)\n team_weight= []\n team_points = []\n\n goalkeeper, defender, midfielder, attacker = [], [], [], []\n for i in players:\n if i[1] == 1:\n goalkeeper.append(i)\n elif i[1] == 2:\n defender.append(i)\n elif i[1] == 3:\n midfielder.append(i)\n elif i[1] == 4:\n attacker.append(i)\n\n team_weight.append([goalkeeper[i][4] for i in range(len(goalkeeper)) if gkp[i] == 1])\n team_weight.append([defender[i][4] for i in range(len(defender)) if defs[i] == 1])\n team_weight.append([midfielder[i][4] for i in range(len(midfielder)) if mids[i] == 1]) \n team_weight.append([attacker[i][4] for i in range(len(attacker)) if atks[i] == 1])\n team_weight = list(itertools.chain(*team_weight))\n\n team_points.append([goalkeeper[i][3] for i in range(len(goalkeeper)) if gkp[i] == 1])\n team_points.append([defender[i][3] for i in range(len(defender)) if defs[i] == 1])\n team_points.append([midfielder[i][3] for i in range(len(midfielder)) if mids[i] == 1]) \n team_points.append([attacker[i][3] for i in range(len(attacker)) if atks[i] == 1])\n team_points = list(itertools.chain(*team_points))\n\n #print(\"Total final points:\", sum(team_points))\n #print(\"Total final cost:\", sum(team_weight))\n\n #plt.plot(range(generations), fitness, label = 'Fitness')\n #plt.legend()\n #plt.title('Fitness level of hill Climber over 500 generations')\n #plt.xlabel('Generations')\n #plt.ylabel('Fitness')\n #plt.show()\n\n return (sum(team_points)), (sum(team_weight))\n \n def project_squad(self,players, top_choice):\n #Method to get the best squad vector and change it from the labels back into the real projected points\n #@params players = available players, top_choice = top squad vectors\n #@return None\n\n goalks, defs, mids, atts = [], [], [], []\n for i in players:\n if i[1] == 1:\n goalks.append(i)\n elif i[1] == 2:\n defs.append(i)\n elif i[1] == 3:\n mids.append(i)\n elif i[1] == 4:\n atts.append(i)\n\n squad = []\n for i in range(len(top_choice[0])):\n if top_choice[0][i] == 1:\n squad.append(goalks[i])\n for i in range(len(top_choice[1])):\n if top_choice[1][i] == 1:\n squad.append(defs[i])\n for i in range(len(top_choice[2])):\n if top_choice[2][i] == 1:\n squad.append(mids[i])\n for i in range(len(top_choice[3])):\n if top_choice[3][i] == 1:\n squad.append(atts[i])\n\n #amend dataframe to change labels into actual predicted FPL poinnts\n full_squad = pd.DataFrame(squad, columns= [\"Player Name\", \"Element Type\", \"Team\", \"Predicted_Points\", \"Cost\"])\n full_squad.insert(loc = 3, column = \"Xg_Points\", value = \"0\")\n for index,row in full_squad.iterrows():\n po = full_squad[\"Predicted_Points\"][index]\n if po == 1:\n full_squad.at[index,\"Xg_Points\"] = \"-1\"\n elif po == 2:\n full_squad.at[index,\"Xg_Points\"] = \"0\"\n elif po == 3:\n full_squad.at[index,\"Xg_Points\"] = \"1\"\n elif po == 4:\n full_squad.at[index,\"Xg_Points\"] = \"2\"\n elif po == 5:\n full_squad.at[index,\"Xg_Points\"] = \"3\"\n elif po == 6:\n full_squad.at[index,\"Xg_Points\"] = \"4\"\n elif po == 7:\n full_squad.at[index,\"Xg_Points\"] = \"5\"\n elif po == 8:\n full_squad.at[index,\"Xg_Points\"] = \"6\"\n elif po == 9:\n full_squad.at[index,\"Xg_Points\"] = \"7\"\n elif po == 10:\n full_squad.at[index,\"Xg_Points\"] = \"8 - 9\" \n elif po == 11:\n full_squad.at[index,\"Xg_Points\"] = \"10 - 12\" \n elif po == 12:\n full_squad.at[index,\"Xg_Points\"] = \"12 - 14\"\n elif po == 13:\n full_squad.at[index,\"Xg_Points\"] = \"15+\"\n elif po >= 14:\n full_squad.at[index,\"Xg_Points\"] = str(po+2)\n del full_squad[\"Predicted_Points\"]\n\n\n return full_squad, squad\n \n def initiate(self):\n #Method to initiate the hillcimber \n #@params None\n #@return None\n \n max_threshold = 100\n generations = 10000\n #mutation rates chosen\n mutation_rates =[0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1]\n iterations = 3\n\n fit_group = []\n totalp = [0]\n totalc = [0] \n final_choices = []\n #make a new squad\n gkp, defs, mids, atks = self.init_hc(max_threshold, self.players)\n for i in range(iterations):\n for mutation_rate in mutation_rates:\n \n final_choices = []\n #make a copy of the init hill climber so each iteration has the same initial starting squad\n gkp1 = gkp\n mids1 = mids\n defs1 = defs\n atks1 = atks\n fitness_history = []\n #call the hillclimber on the squad\n gkp1, defs1, mids1, atks1, fitness = self.hillclimber(gkp1, defs1, mids1, atks1, self.players, max_threshold, generations, mutation_rate)\n fit_group.append(fitness)\n final_points, final_cost = self.graph(fitness,mutation_rate, self.players, gkp1, defs1, mids1, atks1,generations)\n final_choices.append([gkp1, defs1, mids1, atks1])\n #if squad is optimal, append to optimal squad\n if final_points >= max(totalp):\n if final_points == max(totalp) and final_cost < max(totalc):\n continue\n else:\n top_choice = [gkp1,defs1,mids1,atks1]\n top_cost = final_cost\n top_points = final_points\n totalp.append(final_points) \n totalc.append(final_cost)\n full_squad, squad = self.project_squad(self.players,top_choice)\n self.full_squad = full_squad\n self.squad = squad\n #top choice is the vector representation of the best squad, used for transfer model\n self.top_choice = top_choice\n print(\"Squad Selection is Completed\")\n\n\n# In[ ]:\n\n\n\n\n", "meta": {"hexsha": "5f3eed145700af55558775746e0884ec99f322da", "size": 19605, "ext": "py", "lang": "Python", "max_stars_repo_path": "generate_team.py", "max_stars_repo_name": "jesperdj9/FantasyFootballProj", "max_stars_repo_head_hexsha": "0cefa051d7c77d3786f239806887ee5b7be72bda", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "generate_team.py", "max_issues_repo_name": "jesperdj9/FantasyFootballProj", "max_issues_repo_head_hexsha": "0cefa051d7c77d3786f239806887ee5b7be72bda", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "generate_team.py", "max_forks_repo_name": "jesperdj9/FantasyFootballProj", "max_forks_repo_head_hexsha": "0cefa051d7c77d3786f239806887ee5b7be72bda", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.4700665188, "max_line_length": 153, "alphanum_fraction": 0.5611833716, "include": true, "reason": "import numpy", "num_tokens": 4866, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.373875808818685, "lm_q1q2_score": 0.19131845946972112}} {"text": "\"\"\"Boundary condition implementations.\n\nBoundary Conditions\n^^^^^^^^^^^^^^^^^^^\n\n.. autoclass:: PrescribedBoundary\n.. autoclass:: DummyBoundary\n.. autoclass:: AdiabaticSlipBoundary\n\"\"\"\n\n__copyright__ = \"\"\"\nCopyright (C) 2020 University of Illinois Board of Trustees\n\"\"\"\n\n__license__ = \"\"\"\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n\"\"\"\n\nimport numpy as np\nfrom meshmode.dof_array import thaw\nfrom meshmode.mesh import BTAG_ALL, BTAG_NONE # noqa\n# from mirgecom.eos import IdealSingleGas\nfrom grudge.symbolic.primitives import TracePair\nfrom mirgecom.euler import split_conserved, join_conserved\n\n\nclass PrescribedBoundary:\n \"\"\"Boundary condition prescribes boundary soln with user-specified function.\n\n .. automethod:: __init__\n .. automethod:: boundary_pair\n \"\"\"\n\n def __init__(self, userfunc):\n \"\"\"Set the boundary function.\n\n Parameters\n ----------\n userfunc\n User function must take two parameters: time and nodal\n coordinates, and produce the solution at each node.\n \"\"\"\n self._userfunc = userfunc\n\n def boundary_pair(\n self, discr, q, btag, eos, t=0.0\n ):\n \"\"\"Get the interior and exterior solution on the boundary.\"\"\"\n actx = q[0].array_context\n\n boundary_discr = discr.discr_from_dd(btag)\n nodes = thaw(actx, boundary_discr.nodes())\n ext_soln = self._userfunc(t, nodes)\n int_soln = discr.project(\"vol\", btag, q)\n return TracePair(btag, interior=int_soln, exterior=ext_soln)\n\n\nclass DummyBoundary:\n \"\"\"Boundary condition that assigns boundary-adjacent soln as the boundary solution.\n\n .. automethod:: boundary_pair\n \"\"\"\n\n def boundary_pair(\n self, discr, q, btag, eos, t=0.0\n ):\n \"\"\"Get the interior and exterior solution on the boundary.\"\"\"\n dir_soln = discr.project(\"vol\", btag, q)\n return TracePair(btag, interior=dir_soln, exterior=dir_soln)\n\n\nclass AdiabaticSlipBoundary:\n r\"\"\"Boundary condition implementing inviscid slip boundary.\n\n a.k.a. Reflective inviscid wall boundary\n\n This class implements an adiabatic reflective slip boundary given\n by\n $\\mathbf{q^{+}} = [\\rho^{-}, (\\rho{E})^{-}, (\\rho\\vec{V})^{-}\n - 2((\\rho\\vec{V})^{-}\\cdot\\hat{\\mathbf{n}}) \\hat{\\mathbf{n}}]$\n wherein the normal component of velocity at the wall is 0, and\n tangential components are preserved. These perfectly reflecting\n conditions are used by the forward-facing step case in\n [Hesthaven_2008]_, Section 6.6, and correspond to the characteristic\n boundary conditions described in detail in [Poinsot_1992]_.\n\n .. automethod:: boundary_pair\n \"\"\"\n\n def boundary_pair(\n self, discr, q, btag, eos, t=0.0\n ):\n \"\"\"Get the interior and exterior solution on the boundary.\n\n The exterior solution is set such that there will be vanishing\n flux through the boundary, preserving mass, momentum (magnitude) and\n energy.\n rho_plus = rho_minus\n v_plus = v_minus - 2 * (v_minus . n_hat) * n_hat\n mom_plus = rho_plus * v_plus\n E_plus = E_minus\n \"\"\"\n # Grab some boundary-relevant data\n dim = discr.dim\n cv = split_conserved(dim, q)\n actx = cv.mass.array_context\n\n # Grab a unit normal to the boundary\n nhat = thaw(actx, discr.normal(btag))\n\n # Get the interior/exterior solns\n int_soln = discr.project(\"vol\", btag, q)\n int_cv = split_conserved(dim, int_soln)\n\n # Subtract out the 2*wall-normal component\n # of velocity from the velocity at the wall to\n # induce an equal but opposite wall-normal (reflected) wave\n # preserving the tangential component\n mom_normcomp = np.dot(int_cv.momentum, nhat) # wall-normal component\n wnorm_mom = nhat * mom_normcomp # wall-normal mom vec\n ext_mom = int_cv.momentum - 2.0 * wnorm_mom # prescribed ext momentum\n\n # Form the external boundary solution with the new momentum\n bndry_soln = join_conserved(dim=dim, mass=int_cv.mass,\n energy=int_cv.energy,\n momentum=ext_mom)\n\n return TracePair(btag, interior=int_soln, exterior=bndry_soln)\n", "meta": {"hexsha": "b7146adc6cdc26c7787f7d7b186a8700aef2a733", "size": 5250, "ext": "py", "lang": "Python", "max_stars_repo_path": "mirgecom/boundary.py", "max_stars_repo_name": "anderson2981/mirgecom", "max_stars_repo_head_hexsha": "8d5d44145b5984f27a3dcda30956756a9cbcd284", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "mirgecom/boundary.py", "max_issues_repo_name": "anderson2981/mirgecom", "max_issues_repo_head_hexsha": "8d5d44145b5984f27a3dcda30956756a9cbcd284", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "mirgecom/boundary.py", "max_forks_repo_name": "anderson2981/mirgecom", "max_forks_repo_head_hexsha": "8d5d44145b5984f27a3dcda30956756a9cbcd284", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.2068965517, "max_line_length": 87, "alphanum_fraction": 0.6805714286, "include": true, "reason": "import numpy", "num_tokens": 1259, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.373875808818685, "lm_q1q2_score": 0.19131845946972112}} {"text": "#! /usr/bin/env python\n\n\"\"\"\nInstrumentData Class -- defines data format, wavelength info, mask geometry\n\nInstruments/masks supported:\nNIRISS AMI\nGPI, VISIR, NIRC2 removed - too much changed for the JWST NIRISS class\n\"\"\"\n\n# Standard Imports\nimport numpy as np\nfrom astropy.io import fits\nimport os, sys, time\nimport copy\n# Module imports\nimport synphot\n# import stsynphot\n# mask geometries, GPI, NIRISS, VISIR supported...\nfrom nrm_analysis.misctools.mask_definitions import NRM_mask_definitions \nfrom nrm_analysis.misctools import utils\nfrom nrm_analysis.misctools import lpl_ianc\n\n\n\num = 1.0e-6\n\n# utility routines for InstrumentData classes\n\ndef show_cvsupport_threshold(instr):\n \"\"\" Show threshold for where 'splodge' data in CV space contains signal \"\"\"\n print(\"InstrumentData: \", \"cvsupport_threshold is: \", instr.cvsupport_threshold)\n print(\"InstrumentData: \", instr.cvsupport_threshold)\n\ndef set_cvsupport_threshold(instr, k, v):\n \"\"\" Set threshold for where 'splodge' data in CV space contains signal\n \n Parameters\n ----------\n instr: InstrumentData instance\n thresh: Threshold for the absolute value of the FT(interferogram).\n Normalize abs(CV = FT(a)) for unity peak, and define the support \n of \"good\" CV when this is above threshold\n \"\"\"\n \n instr.cvsupport_threshold[k] = v\n print(\"InstrumentData: \", \"New cvsupport_threshold is: \", instr.cvsupport_threshold)\n\n\n\nclass NIRISS:\n def __init__(self, filt, \n objname=\"obj\", \n src='A0V', \n chooseholes=None, \n affine2d=None, \n bandpass=None,\n nbadpix=4,\n usebp=True,\n firstfew=None,\n nspecbin=None,\n **kwargs):\n \"\"\"\n Initialize NIRISS class\n\n ARGUMENTS:\n\n kwargs:\n UTR\n Or just look at the file structure\n Either user has webbpsf and filter file can be read, or...\n chooseholes: None, or e.g. ['B2', 'B4', 'B5', 'B6'] for a four-hole mask\n filt: Filter name string like \"F480M\"\n bandpass: None or [(wt,wlen),(wt,wlen),...]. Monochromatic would be e.g. [(1.0, 4.3e-6)]\n Explicit bandpass arg will replace *all* niriss filter-specific variables with \n the given bandpass (src, nspecbin, filt), so you can simulate 21cm psfs through \n something called \"F430M\". Can also be synphot.spectrum.SourceSpectrum object.\n firstfew: None or the number of slices to truncate input cube to in memory,\n the latter for fast developmpent\n nbadpix: Number of good pixels to use when fixing bad pixels DEPRECATED\n usebp: Convert to usedq during initialization\n Internally this is changed to sellf.usedq = usebp immediately for code clarity\n True (default) do not use DQ with DO_NOT_USE flag in input MAST data when\n fitting data with model. False: Assume no bad pixels in input\n noise: standard deviation of noise added to perfect images to enable candid\n plots without crashing on np.inf limits! Image assumed to be in (np.float64) dn.\n Suggested noise: 1e-6.\n src: source spectral type string e.g. \"A0V\" OR user-defined synphot.spectrum.SourceSpectrum object\n nspecbin: Number of wavelength bins to use across the bandpass. Replaces deprecated `usespecbin` which \n set **number of wavelengths to into each bin**, not nbins.\n\n \"\"\"\n\n self.verbose = False\n if \"verbose\" in kwargs:\n self.verbose = kwargs[\"verbose\"]\n\n self.noise = None\n if \"noise\" in kwargs:\n self.noise = kwargs[\"noise\"]\n if \"usespecbin\" in kwargs: # compatability with previous arg\n # but not really, usespecbin was binning factor, not number of bins\n nspecbin = kwargs[\"usespecbin\"]\n # change how many wavelength bins will be used across the bandpass\n if nspecbin is None:\n nspecbin = 19\n\n self.lam_bin = nspecbin\n\n # src can be either a spectral type string or a user-defined synphot spectrum object\n if isinstance(src, synphot.spectrum.SourceSpectrum):\n print(\"Using user-defined synphot SourceSpectrum\")\n\n if chooseholes:\n print(\"InstrumentData.NIRISS: \", chooseholes)\n self.chooseholes = chooseholes\n\n \n # USEBP is USEDQ in the rest of code - use\n self.usedq = usebp\n print(\"Fitting omits bad pixels (identified by DO_NOT_USE value in the DQ extension)\")\n self.jwst_dqflags() # creates dicts self.bpval, self.bpgroup\n # self.bpexist set True/False if DQ fits image extension exists/doesn't\n\n self.firstfew = firstfew\n if firstfew is not None: print(\"InstrumentData.NIRISS: analysing firstfew={:d} slices\".format(firstfew))\n\n self.objname = objname\n\n self.filt = filt\n\n if bandpass is not None:\n print(\"InstrumentData.NIRISS: OVERRIDING BANDPASS WITH USER-SUPPLIED VALUES.\")\n print(\"\\t src, filt, nspecbin parameters will not be used\")\n # check type of bandpass. can be synphot spectrum\n # if so, get throughput and wavelength arrays\n if isinstance(bandpass, synphot.spectrum.SpectralElement):\n wl, wt = bandpass._get_arrays(bandpass.waveset)\n self.throughput = np.array((wt,wl)).T\n else:\n self.throughput = np.array(bandpass) # type simplification\n else:\n filt_spec = utils.get_filt_spec(self.filt)\n src_spec = utils.get_src_spec(src)\n # **NOTE**: As of WebbPSF version 1.0.0 filter is trimmed to where throughput is 10% of peak\n # For consistency with WebbPSF simultions, use trim=0.1\n self.throughput = utils.combine_src_filt(filt_spec, \n src_spec, \n trim=0.01, \n nlambda=nspecbin,\n verbose=self.verbose, \n plot=False)\n\n self.lam_c, self.lam_w = utils.get_cw_beta(self.throughput)\n\n if self.verbose: print(\"InstrumentData.NIRISS: \", self.filt, \n \": central wavelength {:.4e} microns, \".format(self.lam_c/um), end=\"\")\n if self.verbose: print(\"InstrumentData.NIRISS: \", \"fractional bandpass {:.3f}\".format(self.lam_w))\n\n self.wls = [self.throughput,] \n\n if self.verbose: print(\"self.throughput:\\n\", self.throughput)\n\n # Wavelength info for NIRISS bands F277W, F380M, F430M, or F480M\n self.wavextension = ([self.lam_c,], [self.lam_w,])\n self.nwav=1 # these are 'slices' if the data is pure imaging integrations - \n # nwav is old nomenclature from GPI IFU data. Refactor one day...\n #############################\n\n # only one NRM on JWST:\n self.telname = \"JWST\"\n self.instrument = \"NIRISS\"\n self.arrname = \"jwst_g7s6c\" # implaneia mask set with this - unify to short form later \n self.holeshape=\"hex\"\n self.mask = NRM_mask_definitions(maskname=self.arrname, chooseholes=chooseholes, \n holeshape=self.holeshape )\n\n # save affine deformation of pupil object or create a no-deformation object. \n # We apply this when sampling the PSF, not to the pupil geometry.\n # This will set a default Ideal or a measured rotation, for example,\n # and include pixel scale changes due to pupil distortion.\n # Separating detector tilt pixel scale effects from pupil distortion effects is \n # yet to be determined... see comments in Affine class definition.\n # AS AZG 2018 08 15 Ann Arbor\n if affine2d is None:\n self.affine2d = utils.Affine2d(mx=1.0,my=1.0, \n sx=0.0,sy=0.0, \n xo=0.0,yo=0.0, name=\"Ideal\")\n else:\n self.affine2d = affine2d\n\n # finding centroid from phase slope only considered cv_phase data \n # when cv_abs data exceeds this cvsupport_threshold. \n # Absolute value of cv data normalized to unity maximum\n # for the threshold application.\n # Data reduction gurus: tweak the threshold value with experience...\n # Gurus: tweak cvsupport with use...\n self.cvsupport_threshold = {\"F277W\":0.02, \"F380M\": 0.02, \"F430M\": 0.02, \"F480M\": 0.02}\n if self.verbose: show_cvsupport_threshold(self)\n self.threshold = self.cvsupport_threshold[filt]\n\n\n def set_pscale(self, pscalex_deg=None, pscaley_deg=None):\n \"\"\"\n Override pixel scale in header\n \"\"\"\n if pscalex_deg is not None:\n self.pscalex_deg = pscalex_deg\n if pscaley_deg is not None:\n self.pscaley_deg = pscaley_deg\n self.pscale_mas = 0.5 * (pscalex_deg + pscaley_deg) * (60*60*1000)\n self.pscale_rad = utils.mas2rad(self.pscale_mas)\n\n def read_data(self, fn, mode=\"slice\"):\n # mode options are slice or UTR\n # for single slice data, need to read as 3D (1, npix, npix)\n # for utr data, need to read as 3D (ngroup, npix, npix)\n # fix bad pixels using DQ extension and LPL local averaging, \n # but send bad pixel array down to where fringes are fit so they can be ignored.\n # For perfectly noiseless data we add GFaussian zero mean self.noise std dev\n # to imagge data. Then std devs don't cause plot crashes with limits problems.\n \n with fits.open(fn, memmap=False, do_not_scale_image_data=True) as fitsfile:\n # use context manager, memmap=False, deepcopy to avoid memory leaks\n scidata = copy.deepcopy(fitsfile[1].data)\n if self.noise is not None: scidata += np.random.normal(0, self.noise, scidata.shape)\n \n # usually DQ ext in MAST file... make it non-fatal for DQ to be missing\n try:\n bpdata=copy.deepcopy(fitsfile['DQ'].data).astype(np.uint32) # bad pixel extension, forced to uint32\n self.bpexist = True\n dqmask = bpdata & self.bpval[\"DO_NOT_USE\"] == self.bpval[\"DO_NOT_USE\"] #\n del bpdata # free memory\n\n # True => driver wants to omit using pixels with dqflag raised in fit,\n if self.usedq == True:\n print('InstrumentData.NIRISS.read_data: will not use flagged DQ pixels in fit')\n except Exception as e:\n print('InstrumentData.NIRISS.read_data: raised exception', e)\n self.bpexist = False\n dqmask = np.zeros(scidata.shape, dtype=np.uint32) # so it doesn't break if issues with DQ data\n\n if scidata.ndim == 3: #len(scidata.shape)==3:\n print(\"read_data() input: 3D cube\")\n\n # Truncate all but the first few slices od data and DQ array for rapid development\n if self.firstfew is not None:\n if scidata.shape[0] > self.firstfew:\n scidata = scidata[:self.firstfew, :, :]\n dqmask = dqmask[:self.firstfew, :, :]\n # 'nwav' name (historical) is actually number of data slices in the 3Dimage cube\n self.nwav=scidata.shape[0]\n [self.wls.append(self.wls[0]) for f in range(self.nwav-1)]\n\n elif len(scidata.shape)==2: # 'cast' 2d array to 3d with shape[0]=1\n print(\"'InstrumentData.NIRISS.read_data: 2D data array converting to 3D one-slice cube\")\n scidata = np.array([scidata,])\n dqmask = np.array([dqmask,])\n else:\n sys.exit(\"InstrumentData.NIRISS.read_data: invalid data dimensions for NIRISS. \\nShould have dimensionality of 2 or 3.\")\n\n # refpix removal by trimming\n scidata = scidata[:,4:, :] # [all slices, imaxis[0], imaxis[1]]\n print('\\tRefpix-trimmed scidata:', scidata.shape)\n #### fix pix using bad pixel map - runs now. Need to sanity-check.\n if self.bpexist:\n # refpix removal by trimming to match image trim\n dqmask = dqmask[:,4:, :] # dqmask bool array to match image trimmed shape\n print('\\tRefpix-trimmed dqmask: ', dqmask.shape)\n\n prihdr=fitsfile[0].header\n scihdr=fitsfile[1].header\n # MAST header or similar kwds info for oifits writer:\n self.updatewithheaderinfo(prihdr, scihdr)\n\n # Directory name into which to write txt observables & optional fits diagnostic files\n # The input fits image or cube of images file rootname is used to create the output\n # text&fits dir, using the data file's root name as the directory name: for example,\n # /abc/.../imdir/xyz_calints.fits results in a directory /abc/.../imdir/xyz_calints/\n self.rootfn = fn.split('/')[-1].replace('.fits', '')\n return prihdr, scihdr, scidata, dqmask\n\n\n def cdmatrix_to_sky(self, vec, cd11, cd12, cd21, cd22):\n \"\"\" use the global header values explicitly, for clarity \n vec is 2d, units of pixels\n cdij 4 scalars, conceptually 2x2 array in units degrees/pixel\n \"\"\"\n return np.array((cd11*vec[0] + cd12*vec[1], cd21*vec[0] + cd22*vec[1]))\n\n\n def degrees_per_pixel(self, hdr):\n \"\"\"\n input: hdr: fits data file's header with or without CDELT1, CDELT2 (degrees per pixel)\n returns: cdelt1, cdelt2: tuple, degrees per pixel along axes 1, 2\n EITHER: read from header CDELT[12] keywords \n OR: calculated using CD matrix (Jacobian of RA-TAN, DEC-TAN degrees\n to pixel directions 1,2. No deformation included in this routine,\n but the CD matric includes non-linear field distortion.\n No pupil distortion or rotation here.\n MISSING: If keywords are missing default hardcoded cdelts are returned.\n The exact algorithm may substitute this later.\n Below seems good to ~5th significant figure when compared to \n cdelts header values prior to replacement by cd matrix approach.\n N.D. at stsci 11 Mar 20212\n\n We start in Level 1 with the PC matrix and CDELT.\n CDELTs come from the SIAF.\n\n The PC matrix is computed from the roll angle, V3YANG and the parity.\n The code is here\n https://github.com/spacetelescope/jwst/blob/master/jwst/assign_wcs/util.py#L153\n\n In the level 2 imaging pipeline, assign_wcs adds the distortion to the files.\n At the end it computes an approximation of the entire distortion transformation\n by fitting a polynomial. This approximated distortion is represented as SIP\n polynomials in the FITS headers.\n\n Because SIP, by definition, uses a CD matrix, the PC + CDELT are replaced by CD.\n\n How to get CDELTs back?\n\n I think once the rotation, skew and scale are in the CD matrix it's very hard to\n disentangle them. The best way IMO is to calculate the local scale using three\n point difference. There is a function in jwst that does this.\n\n Using a NIRISS image as an example:\n\n from jwst.assign_wcs import util\n from jwst import datamodels\n\n im=datamodels.open('niriss_image_assign_wcs.fits')\n\n util.compute_scale(im.meta.wcs, (im.meta.wcsinfo.ra_ref, im.meta.wcsinfo.dec_ref))\n\n 1.823336635353374e-05\n\n The function returns a constant scale. Is this sufficient for what you need or\n do you need scales and sheer along each axis? The code in util.compute_scale can\n help with figuring out how to get scales along each axis.\n\n I hope this answers your question.\n \"\"\"\n\n if 'CD1_1' in hdr.keys() and 'CD1_2' in hdr.keys() and \\\n 'CD2_1' in hdr.keys() and 'CD2_2' in hdr.keys():\n cd11 = hdr['CD1_1']\n cd12 = hdr['CD1_2']\n cd21 = hdr['CD2_1']\n cd22 = hdr['CD2_2']\n # Create unit vectors in detector pixel X and Y directions, units: detector pixels\n dxpix = np.array((1.0, 0.0)) # axis 1 step\n dypix = np.array((0.0, 1.0)) # axis 2 step\n # transform pixel x and y steps to RA-tan, Dec-tan degrees\n dxsky = self.cdmatrix_to_sky(dxpix, cd11, cd12, cd21, cd22)\n dysky = self.cdmatrix_to_sky(dypix, cd11, cd12, cd21, cd22)\n print(\"Used CD matrix for pixel scales\")\n return np.linalg.norm(dxsky, ord=2), np.linalg.norm(dysky, ord=2)\n elif 'CDELT1' in hdr.keys() and 'CDELT2' in hdr.keys():\n return hdr['CDELT1'], hdr['CDELT2']\n print(\"Used CDDELT[12] for pixel scales\")\n else:\n print('InstrumentData.NIRISS: Warning: NIRISS pixel scales not in header. Using 65.6 mas in deg/pix')\n return 65.6/(60.0*60.0*1000), 65.6/(60.0*60.0*1000)\n\n \n def updatewithheaderinfo(self, ph, sh):\n \"\"\" input: primary header, science header MAST\"\"\"\n\n # The info4oif_dict will get pickled to disk when we write txt files of results.\n # That way we don't drag in objects like InstrumentData into code that reads text results\n # and writes oifits files - a simple built-in dictionary is the only object used in this transfer.\n info4oif_dict = {}\n info4oif_dict['telname'] = self.telname\n\n info4oif_dict['filt'] = self.filt\n info4oif_dict['lam_c'] = self.lam_c\n info4oif_dict['lam_w'] = self.lam_w\n info4oif_dict['lam_bin'] = self.lam_bin\n\n\n # Target information - 5/21 targname UNKNOWN in nis019 rehearsal data\n # Name in the proposal always non-trivial, targname still UNKNOWN...:\n if ph[\"TARGNAME\"] == 'UNKNOWN': objname = ph['TARGPROP']\n else: objname = ph['TARGNAME'] # allegedly apt name for archive, standard form\n #\n # if target name has confusing-to-astroquery dash\n self.objname = objname.replace('-', ' '); info4oif_dict['objname'] = self.objname\n # AB Dor, ab dor, AB DOR, ab dor are all acceptable.\n #\n self.ra = ph[\"TARG_RA\"]; info4oif_dict['ra'] = self.ra\n self.dec = ph[\"TARG_DEC\"]; info4oif_dict['dec'] = self.dec\n\n # / axis 1 DS9 coordinate of the reference pixel (always POS1)\n # / axis 2 DS9 coordinate of the reference pixel (always POS1)\n self.crpix1 = sh[\"CRPIX1\"]; info4oif_dict['crpix1'] = self.crpix1\n self.crpix2 = sh[\"CRPIX2\"]; info4oif_dict['crpix2'] = self.crpix2\n # need Paul Goudfrooij's table for actual crval[1,2] for true pointing to detector pixel coords (DS9)\n\n self.instrument = ph[\"INSTRUME\"]; info4oif_dict['instrument'] = self.instrument\n self.pupil = ph[\"PUPIL\"]; info4oif_dict['pupil'] = self.pupil\n # \"ImPlaneIA internal mask name\" - oifwriter looks for 'mask'...\n self.arrname = \"jwst_g7s6c\" # implaneia internal name - historical\n info4oif_dict['arrname'] = 'g7s6' # for oif\n info4oif_dict['mask'] = info4oif_dict['arrname'] # Soulain mask goes into oif arrname\n\n # if data was generated on the average pixel scale of the header\n # then this is the right value that gets read in, and used in fringe fitting\n pscalex_deg, pscaley_deg = self.degrees_per_pixel(sh)\n #\n info4oif_dict['pscalex_deg'] = pscalex_deg\n info4oif_dict['pscaley_deg'] = pscaley_deg\n # Whatever we did set is averaged for isotropic pixel scale here\n self.pscale_mas = 0.5 * (pscalex_deg + pscaley_deg) * (60*60*1000); \\\n info4oif_dict['pscale_mas'] = self.pscale_mas\n self.pscale_rad = utils.mas2rad(self.pscale_mas); info4oif_dict['pscale_rad'] = self.pscale_rad\n\n self.mask = NRM_mask_definitions(maskname=self.arrname, chooseholes=self.chooseholes,\n holeshape=self.holeshape) # for STAtions x y in oifs\n\n self.date = ph[\"DATE-OBS\"] + \"T\" + ph[\"TIME-OBS\"]; info4oif_dict['date'] = self.date\n datestr = ph[\"DATE-OBS\"]\n self.year = datestr[:4]; info4oif_dict['year'] = self.year\n self.month = datestr[5:7]; info4oif_dict['month'] = self.month\n self.day = datestr[8:10]; info4oif_dict['day'] = self.day\n self.parangh= sh[\"ROLL_REF\"]; info4oif_dict['parangh'] = self.parangh\n self.pa = sh[\"PA_V3\"]; info4oif_dict['pa'] = self.pa\n self.vparity = sh[\"VPARITY\"]; info4oif_dict['vparity'] = self.vparity\n\n # An INTegration is NGROUPS \"frames\", not relevant here but context info.\n # 2d => \"cal\" file combines all INTegrations (ramps)\n # 3d=> \"calints\" file is a cube of all INTegrations (ramps)\n if sh[\"NAXIS\"] == 2:\n # all INTegrations or 'ramps'\n self.itime = ph[\"EFFINTTM\"] * ph[\"NINTS\"]; info4oif_dict['itime'] = self.itime\n elif sh[\"NAXIS\"] == 3:\n # each slice is one INTegration or 'ramp'\n self.itime = ph[\"EFFINTTM\"]; info4oif_dict['itime'] = self.itime\n\n\n np.set_printoptions(precision=5, suppress=True, linewidth=160, \n formatter={'float': lambda x: \"%10.5f,\" % x})\n self.v3i_yang = sh['V3I_YANG'] # Angle from V3 axis to Ideal y axis (deg)\n # rotate mask hole center coords by PAV3 # RAC 2021\n ctrs_sky = self.mast2sky()\n oifctrs = np.zeros(self.mask.ctrs.shape)\n oifctrs[:,0] = ctrs_sky[:,1].copy() * -1\n oifctrs[:,1] = ctrs_sky[:,0].copy() * -1\n info4oif_dict['ctrs_eqt'] = oifctrs # mask centers rotated by PAV3 (equatorial coords)\n info4oif_dict['ctrs_inst'] = self.mask.ctrs # as-built instrument mask centers\n info4oif_dict['hdia'] = self.mask.hdia\n info4oif_dict['nslices'] = self.nwav # nwav: number of image slices or IFU cube slices - AMI is imager\n self.info4oif_dict = info4oif_dict # save it when writing extracted observables txt\n\n\n # rather than calling InstrumentData in the niriss example just to reset just call this routine\n def reset_nwav(self, nwav):\n print(\"InstrumentData.NIRISS: \", \"Resetting InstrumentData instantiation's nwave to\", nwav)\n self.nwav = nwav\n\n\n def jwst_dqflags(self):\n \"\"\" \n dqdata is a 2d (32-bit U?)INT array from the DQ extension of the input file.\n We ignore all data with a non-zero DQ flag. I copied all values from a 7.5 build jwst...\n but we ignore any non-zero flag meaning, and ignore the pixel in fringe-fitting\n The refpix are non-zero DQ, btw...\n I changed \"pixel\" to self.pbval and \"group\" to self.bpgroup. We may use these later, \n so here they are but initially we just discriminate between good (zero value) and non-good.\n \"\"\"\n\n \"\"\" JWST Data Quality Flags\n The definitions are documented in the JWST RTD:\n https://jwst-pipeline.readthedocs.io/en/latest/jwst/references_general/references_general.html#data-quality-flags \n \"\"\"\n \"\"\" JWST Data Quality Flags\n The definitions are documented in the JWST RTD:\n https://jwst-pipeline.readthedocs.io/en/latest/jwst/references_general/references_general.html#data-quality-flags\n Implementation\n -------------\n The flags are implemented as \"bit flags\": Each flag is assigned a bit position\n in a byte, or multi-byte word, of memory. If that bit is set, the flag assigned\n to that bit is interpreted as being set or active.\n The data structure that stores bit flags is just the standard Python `int`,\n which provides 32 bits. Bits of an integer are most easily referred to using\n the formula `2**bit_number` where `bit_number` is the 0-index bit of interest.\n 2**n is gauche but not everyone loves 1<\n ctrs_rot = utils.rotate2dccw(mask_ctrs, np.deg2rad(-rot_ang))\n print(f'InstrumentData.mast2sky: Rotating mask hole centers clockwise by {rot_ang:.3f} degrees')\n else:\n # counterclockwise \n ctrs_rot = utils.rotate2dccw(mask_ctrs, np.deg2rad(rot_ang))\n print('InstrumentData.mast2sky: Rotating mask hole centers counterclockwise by {rot_ang:.3f} degrees')\n else:\n ctrs_rot = mask_ctrs\n return ctrs_rot\n", "meta": {"hexsha": "3ab46632f2488904ed4e0bf9faed6b2a0899ecf6", "size": 29326, "ext": "py", "lang": "Python", "max_stars_repo_path": "nrm_analysis/InstrumentData.py", "max_stars_repo_name": "vandalt/ImPlaneIA", "max_stars_repo_head_hexsha": "72b22e487ef45a8a665e4a6a88a91e99e382fdd0", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "nrm_analysis/InstrumentData.py", "max_issues_repo_name": "vandalt/ImPlaneIA", "max_issues_repo_head_hexsha": "72b22e487ef45a8a665e4a6a88a91e99e382fdd0", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "nrm_analysis/InstrumentData.py", "max_forks_repo_name": "vandalt/ImPlaneIA", "max_forks_repo_head_hexsha": "72b22e487ef45a8a665e4a6a88a91e99e382fdd0", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 50.6493955095, "max_line_length": 136, "alphanum_fraction": 0.6009002251, "include": true, "reason": "import numpy,from astropy", "num_tokens": 7486, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5774953651858118, "lm_q2_score": 0.331119752830196, "lm_q1q2_score": 0.19122012258090978}} {"text": "import argparse\nimport glob\nimport itertools\nfrom nuosc.tools import cache, progress\nimport numpy\nimport ROOT\nimport math\nimport simplot.io\nimport nuosc.model\nfrom simplot import histogram\nimport matplotlib.pyplot as plt \nimport os\nimport scipy.stats\nimport matplotlib\nfrom nuosc.model import constants, runtime\nimport collections\nimport re\nimport scipy.interpolate\n\n###############################################################################\n\nGenEvFile = collections.namedtuple(\"GenEvFile\", [\"polarity\", \"ndid\", \"r\", \"z\", \"n\", \"orientation\"])\nBeamFile = collections.namedtuple(\"BeamFile\", [\"polarity\"])\n\n###############################################################################\n\nclass FileNameParser:\n def __init__(self, patterns):\n self._flist = _expandfilelist(patterns)\n \n def __call__(self):\n r = None\n fname = self._flist[0]\n for f in [self._parse_genev, self._parse_beam]:\n r = f(fname)\n if r is not None:\n break\n #check for success\n if r is None:\n raise ValueError(\"cannot parse \", fname)\n return r\n \n def _parse_genev(self, fname):\n pat = \"genev_(.*?)_(.*?)_(.*?)_.(.*?)_z(.*?)_(.)_(.*?).root\"\n match = re.search(pat, fname)\n if not match:\n return None\n polarity = match.group(1)\n det = match.group(2)\n ndid = nuosc.model.constants.DetectorId.tostring(det)\n geo = match.group(3)\n r = float(int(match.group(4))) / 100.0\n z = float(int(match.group(5))) / 100.0\n orientation = match.group(6)\n n = match.group(7)\n return GenEvFile(polarity=polarity,\n ndid=ndid,\n r=r,\n z=z,\n n=n,\n orientation=orientation,\n )\n \n def _parse_beam(self, fname):\n pat = \"merged_beamfiles_(.*?).root\"\n match = re.search(pat, fname)\n if not match:\n return None\n polarity = match.group(1)\n return BeamFile(polarity=polarity)\n\n###############################################################################\n\nclass Record:\n pdg = \"pdg\"\n reactioncode = \"reactioncode\"\n enu = \"enu\"\n x = \"x\"\n y = \"y\"\n z = \"z\"\n weight = \"weight\"\n ndid = \"ndid\"\n \n ALL = (pdg, reactioncode, enu, x, y, z, weight)\n \n _axis_labels = {pdg : \"PDG code\",\n reactioncode : \"NEUT reaction code\",\n enu : r\"$E_{\\nu}$ [GeV]\",\n x : \"$x$ [m]\",\n y : \"$y$ [m]\",\n z : \"$z$ [m]\",\n weight : \"event weight\",\n ndid : \"near detector ID\",\n }\n\n @classmethod\n def label(cls, field):\n return cls._axis_labels[field]\n\ndef _expandfilelist(filelist):\n return list(itertools.chain.from_iterable(map(glob.glob, filelist)))\n\n###############################################################################\n\nclass NeutEventReader:\n \n def __call__(self, event):\n x, y, z = self._pos(event)\n return [event.StdHepPdg[0],\n event.NEneutmode,\n self._enu(event),\n x,\n y,\n z,\n 1.0,\n 0.0,\n ]\n \n def _pos(self, event):\n r = event.EvtVtx\n return (r[0],\n r[1],\n r[2],\n )\n \n def _convert2Darray(self, arr, nrows, ncols):\n out = numpy.zeros(shape=(nrows,ncols))\n for i in xrange(nrows):\n for j in xrange(ncols):\n out[i, j] = arr[(i * ncols) + j]\n return out\n \n def _enu(self, event):\n arr = self._convert2Darray(event.StdHepP4, event.StdHepN, 4)\n return arr[0][3]\n \n def indices(self):\n return [Record.pdg,\n Record.reactioncode,\n Record.enu,\n Record.x,\n Record.y,\n Record.z,\n Record.weight,\n Record.ndid,\n ]\n\n\n###############################################################################\n\nclass FluxEventReader:\n \n def __call__(self, event):\n return [event.pdg,\n 0.0,\n event.enu,\n event.xnu,\n event.ynu,\n 0.0,\n event.norm,\n event.ndid,\n ]\n \n def indices(self):\n return [Record.pdg,\n Record.reactioncode,\n Record.enu,\n Record.x,\n Record.y,\n Record.z,\n Record.weight,\n Record.ndid,\n ]\n\n###############################################################################\n\nclass Reader(object):\n def __init__(self, filelist, treename, func, prescale=1):\n self._filenames = _expandfilelist(filelist)\n self._func = func\n self._treename = treename\n self._prescale = prescale\n \n def read(self):\n indices = self._func.indices()\n uniquestr = \"_\".join(indices \n + self._filenames\n + [type(self._func).__name__,\n str(self._prescale),\n ]\n )\n cachetool = cache.CacheNumpy(uniquestr, prefix=\"tmp_verify_genev\")\n if cachetool.exists():\n data = cachetool.read()\n else:\n data = self._load_data()\n cachetool.write(data)\n indices = dict(zip(indices, xrange(len(indices))))\n return indices, data\n \n def _load_data(self):\n data = []\n for fname in self._filenames:\n tfile = ROOT.TFile(fname, \"READ\")\n treename = self._treename\n tree = tfile.Get(treename)\n if not tree:\n raise Exception(\"Input file does not contain tree with name\", treename, fname)\n for event in tree:\n data.append(self._func(event))\n print len(data), data[0]\n data = numpy.array(data)\n return data\n \n def _iterprescale(self, tree, prescale):\n n = tree.GetEntries()\n for i in xrange(n):\n if i % prescale == 0:\n tree.GetEntry(i)\n yield tree\n \n def _load_data(self):\n data = []\n for fname in self._filenames:\n tfile = ROOT.TFile(fname, \"READ\")\n treename = self._treename\n tree = tfile.Get(treename)\n if not tree:\n raise Exception(\"Input file does not contain tree with name\", treename, fname)\n prescale = self._prescale\n iterevents = progress.printProgress(\"Reading \" + treename, tree.GetEntries()/prescale, self._iterprescale(tree, prescale))\n for event in iterevents:\n data.append(self._func(event))\n print len(data), data[0]\n data = numpy.array(data)\n return data\n\n###############################################################################\n\nclass NeutFileReader(Reader):\n def __init__(self, filelist):\n super(NeutFileReader, self).__init__(filelist, \"nRooTracker\", NeutEventReader(), prescale=1)\n\n###############################################################################\n\nclass FluxFileReader(Reader):\n def __init__(self, filelist):\n super(FluxFileReader, self).__init__(filelist, \"flux\", FluxEventReader(), prescale=20)\n \n\n###############################################################################\n\nclass PlotInteractionRate:\n def __init__(self, outdir, indices, data, scale_to_m=1.0, namemod=None, numbins=25):\n self._scale_to_m = scale_to_m\n self._outdir = outdir\n self._data = data\n self._indices = indices\n self._namemod = namemod\n self._numbins = numbins\n \n def __iter__(self):\n if len(self._data):\n for p in self._plot_xy_hist():\n yield p\n for p in self._plot_xz_hist():\n yield p\n# for p in self._plot_histograms():\n# yield p\n \n def _plot_histograms(self):\n for var in Record.ALL:\n fig = plt.figure()\n d = self._data[:, self._indices[var]]\n weights = self._data[:, self._indices[Record.weight]]\n y, xbinning = numpy.histogram(d, weights=weights)\n ax = fig.add_subplot(1, 1, 1)\n histogram.plot_hist_points(ax, xbinning, y)\n ax.set_xlabel(Record.label(var))\n ax.set_ylabel(\"N events\")\n name = os.sep.join((self._outdir, \"hist_1d\", var))\n if self._namemod is not None:\n name += \"_\" + self._namemod\n yield name, fig\n plt.close(fig)\n \n def _plot_xy_hist(self):\n fig = plt.figure()\n name = os.sep.join((self._outdir, \"hist_2d\", \"xy\"))\n if self._namemod is not None:\n name += \"_\" + self._namemod\n ax = fig.add_subplot(1, 1, 1)\n ax.set_xlabel(Record.label(Record.x))\n ax.set_ylabel(Record.label(Record.y))\n #Get data\n dx = self._data[:, self._indices[Record.x]]\n dy = self._data[:, self._indices[Record.y]]\n #scale dx and dy\n dx *= self._scale_to_m\n dy *= self._scale_to_m\n weights = self._data[:, self._indices[Record.weight]]\n #Plot data\n xmin = -10.0\n xmax = 10.0\n prange = ((xmin, xmax), (xmin, xmax))\n ret = ax.hist2d(dx, dy, bins=self._numbins, weights=weights, cmap=matplotlib.cm.get_cmap(\"hot\"), range=prange)\n img = ret[-1]\n fig.colorbar(img)\n yield name, fig\n\n def _plot_xz_hist(self):\n fig = plt.figure()\n name = os.sep.join((self._outdir, \"hist_2d\", \"xz\"))\n if self._namemod is not None:\n name += \"_\" + self._namemod\n ax = fig.add_subplot(1, 1, 1)\n ax.set_xlabel(Record.label(Record.x))\n ax.set_ylabel(Record.label(Record.z))\n #Get data\n dx = self._data[:, self._indices[Record.x]]\n dz = self._data[:, self._indices[Record.z]]\n #scale dx and dy\n dx *= self._scale_to_m\n dz *= self._scale_to_m\n weights = self._data[:, self._indices[Record.weight]]\n #Plot data\n #xmin = -4.0\n #xmax = 4.0\n #prange = ((xmin, xmax), (xmin, xmax))\n ret = ax.hist2d(dx, dz, bins=self._numbins, weights=weights, cmap=matplotlib.cm.get_cmap(\"hot\"), )#range=prange)\n img = ret[-1]\n fig.colorbar(img)\n yield name, fig\n \n# def _plot_xy_kernel(self):\n# fig = plt.figure()\n# ax = fig.add_subplot(1, 1, 1)\n# ax.set_xlabel(Record.label(Record.x))\n# ax.set_ylabel(Record.label(Record.y))\n# #Get data\n# dx = self._data[:, self._indices[Record.x]]\n# dy = self._data[:, self._indices[Record.y]]\n# #Plot histogram\n# heatmap, xedges, yedges = numpy.histogram2d(dx, dy, bins=20)\n# extent = [min(xedges), max(xedges), min(yedges), max(yedges)]\n# ax.imshow(heatmap, extent=extent, interpolation=\"nearest\")\n# dataset = numpy.row_stack((dx, dy))\n# x = numpy.linspace(min(dx), max(dx))\n# y = numpy.linspace(min(dy), max(dy))\n# X, Y = numpy.meshgrid(x, y)\n# kernel = scipy.stats.gaussian_kde(dataset)\n# Z = kernel(numpy.row_stack((X.ravel(), Y.ravel()))).reshape(X.shape)\n# ax.contour(X, Y, Z, color=\"black\", linecolor=\"black\")\n# name = os.sep.join((\"hist_2d\", \"xy\"))\n# yield name, fig\n\n###############################################################################\n\nclass Flux:\n def __init__(self, data, weights):\n #bin the data\n nbins = 100.0\n enurange = (0.0, 5.0)\n hist, edge = numpy.histogram(data, bins=nbins, range=enurange, density=True, weights=weights)\n y = hist\n x = (edge[1:] + edge[:-1] ) / 2.0\n self.f = scipy.interpolate.interp1d(x, y)\n \n def __call__(self, x):\n return self.f(x)\n\n###############################################################################\n\nclass Xsec:\n def __init__(self):\n pass\n \n def __call__(self, x):\n return 1.0\n\n###############################################################################\n\nclass FluxIntXsec:\n def __init__(self, flux, xsec):\n enu = numpy.linspace(start=0.01, stop=5.0, num=1000)\n ff = numpy.vectorize(flux)\n fa = ff(enu)\n xf = numpy.vectorize(xsec)\n xa = xf(enu)\n avg = numpy.average(xa, weights=fa)\n self._result = avg\n \n def __call__(self):\n return self._result\n\n###############################################################################\n\nclass Ratio(object):\n def __init__(self, numerator, denominator):\n self._n = numerator\n self._d = denominator\n try:\n self._r = float(self._n) / float(self._d)\n except ZeroDivisionError:\n self._r = 0.0\n \n def __div__(self, rhs):\n return Ratio(self, rhs)\n \n def __sub__(self, rhs):\n return Difference(self, rhs)\n \n def __float__(self):\n return self._r\n \n def __str__(self):\n #return \"{0:.3e} +- {1:.3e}\".format(self._r, self.error())\n return \"{0:.3f} +- {1:.3f}\".format(self._r, self.error())\n# return \"\\n\".join((\"Num=\"+str(self._n),\n# \"Den=\"+str(self._d),\n# \"R=\"+str(self._r),\n# ))\n \n def error(self):\n err = 0.0\n try:\n n = float(self._n)\n d = float(self._d)\n ne = self._n.error()\n de = self._d.error()\n err = self._r * math.sqrt((ne/n)**2 + (de/d)**2) \n except AttributeError:\n #assume binomial error\n eff = self._r\n err = 0.0\n if self._d > 0:\n var = eff * (1.0 - eff) / float(self._n)\n err = math.sqrt(var)\n return err\n \nclass Difference(Ratio):\n def __init__(self, numerator, denominator):\n self._n = numerator\n self._d = denominator\n self._r = float(self._n) - float(self._d)\n \n def error(self):\n err = 0.0\n n = float(self._n)\n d = float(self._d)\n ne = self._n.error()\n de = self._d.error()\n err = math.sqrt((ne)**2 + (de)**2)\n return err\n\n###############################################################################\n\n\nclass PlotFluxIntXsec:\n def __init__(self, neutindices, neutdata, fluxindices, fluxdata, scale_to_m = 1.0/100.0):\n self._neut_indices = neutindices\n self._neut_data = neutdata\n self._fluxindices = fluxindices\n self._fluxdata = fluxdata\n self._scale_to_m = scale_to_m\n \n def __iter__(self):\n rad = 4.0\n outer_xmax = rad / math.sqrt(2.0)\n outer_ymax = outer_xmax\n outer_xmin = -outer_xmax\n outer_ymin = -outer_ymax\n #get fiducial flux\n fvflux = _spacecut(self._fluxindices, self._fluxdata, outer_xmin, outer_xmax, outer_ymin, outer_ymax, scale_to_m=self._scale_to_m)\n fvneut = _spacecut(self._neut_indices, self._neut_data, outer_xmin, outer_xmax, outer_ymin, outer_ymax)\n #divide square into quadrants\n rad = 4.0\n outer_xmax = rad / math.sqrt(2.0)\n outer_ymax = outer_xmax\n outer_xmin = -outer_xmax\n outer_ymin = -outer_ymax\n for name, xmin, xmax, ymin, ymax in [(\"(+x, +y)\", 0.0, outer_xmax, 0.0, outer_ymax),\n (\"(+x, -y)\", 0.0, outer_xmax, outer_ymin, 0.0),\n (\"(-x, +y)\", outer_xmin, 0.0, 0.0, outer_ymax),\n (\"(-x, -y)\",outer_xmin, 0.0, outer_ymin, 0.0),\n \n \n ]:\n #print \"Plotting \", name\n for p in self._plot(xmin, xmax, ymin, ymax, fvflux, fvneut, self._fluxindices, self._neut_indices):\n yield p\n return\n \n def _plot(self, xmin, xmax, ymin, ymax, fluxdata, neut_data, fluxindices, neut_indices):\n fd = _spacecut(fluxindices, fluxdata, xmin, xmax, ymin, ymax, scale_to_m=self._scale_to_m)\n gd = _spacecut(neut_indices, neut_data, xmin, xmax, ymin, ymax)\n# #calc flux integrated xsec\n# flux = Flux(fd[:, Record.enu], fd[:, Record.weight])\n# xsec = Xsec()\n# fluxintxsec = FluxIntXsec(flux, xsec)\n #yield figname, fig\n expected_frac = Ratio(self._sumflux(fluxindices, fd), self._sumflux(fluxindices, fluxdata))\n observed_frac = Ratio(len(gd), len(neut_data))\n diff = observed_frac - expected_frac\n #print \"expected=\", str(expected_frac), \", observed=\", str(observed_frac),\", diff=\",(diff)\n l = [(100.0*float(v), 100.0*v.error()) for v in (expected_frac, observed_frac, diff)]\n for t in l: \n print t,\",\"\n yield None\n \n def _sumflux(self, indices, fd):\n return numpy.sum(fd[:, indices[Record.weight]])\n \ndef _spacecut(indices, fd, xmin, xmax, ymin, ymax, scale_to_m=1.0):\n xmin, xmax, ymin, ymax = [[v / scale_to_m] for v in [xmin, xmax, ymin, ymax]]\n #x-cut\n ix = indices[Record.x]\n fd = fd[fd[:, ix] > xmin]\n fd = fd[fd[:, ix] < xmax]\n #y cut\n iy = indices[Record.y]\n fd = fd[fd[:, iy] > ymin]\n fd = fd[fd[:, iy] < ymax]\n return fd\n \n\n###############################################################################\n\ndef plot_interaction_rate(args):\n parser = FileNameParser(args.patterns)\n f = parser()\n reader = NeutFileReader(args.patterns)\n indices, data = reader.read()\n out = simplot.io.FigureWriter()\n name = \"_\".join([f.polarity, f.ndid])\n plotter = PlotInteractionRate(\"evgen\", indices, data,\n namemod=name,\n numbins=100,\n )\n out(plotter)\n return\n\n###############################################################################\n\ndef plot_flux(args):\n ntuple = nuosc.model.beam.FluxNtuple(runtime.getcontext().beamcontext)\n reader = FluxFileReader([ntuple.filename()])\n indices, data = reader.read()\n DetectorId = nuosc.model.beam.constants.DetectorId\n out = simplot.io.FigureWriter()\n for polarity in nuosc.model.constants.Polarity.ALL:\n for ndid in DetectorId.ALL:\n #filter out particular near detector\n indid = DetectorId.toint(ndid)\n fluxdata = data[data[:, indices[Record.ndid]] == indid]\n if len(fluxdata) > 0:\n if polarity > 0:\n fluxdata = fluxdata[fluxdata[:, indices[Record.pdg]] > 0]\n else:\n fluxdata = fluxdata[fluxdata[:, indices[Record.pdg]] < 0]\n detstr = DetectorId.tostring(ndid)\n cm_to_m = 1.0 / 100.0\n name = \"_\".join((detstr, str(polarity)))\n plotter = PlotInteractionRate(\"flux\", indices, fluxdata, \n scale_to_m=cm_to_m, \n namemod=name,\n numbins=10,\n )\n out(plotter)\n\n###############################################################################\n\ndef plot_flux_int_xsec(args):\n parser = FileNameParser(args.patterns)\n f = parser()\n #load neut data\n reader = NeutFileReader(args.patterns)\n neutindices, neutdata = reader.read()\n #load flux data\n ntuple = nuosc.model.beam.FluxNtuple(runtime.getcontext().beamcontext)\n reader = FluxFileReader([ntuple.filename()])\n fluxindices, fluxdata = reader.read()\n DetectorId = nuosc.model.beam.constants.DetectorId\n ndid = DetectorId.toint(f.ndid)\n #filter out particular near detector\n fluxdata = fluxdata[fluxdata[:, fluxindices[Record.ndid]] == ndid]\n #make plot\n out = simplot.io.FigureWriter()\n cm_to_m = 1.0 / 100.0\n #cut on flux energy\n plotter = PlotFluxIntXsec(neutindices, neutdata, fluxindices, fluxdata, \n scale_to_m=cm_to_m,\n )\n #out(plotter)\n for p in plotter:\n pass \n\ndef testcut(indices, d, scale_to_m):\n rad = 3.0\n outer_xmax = rad / math.sqrt(2.0)\n outer_ymax = outer_xmax\n outer_xmin = -outer_xmax\n outer_ymin = -outer_ymax\n #get fiducial flux\n return _spacecut(indices, d, outer_xmin, outer_xmax, outer_ymin, outer_ymax, scale_to_m=scale_to_m)\n\n###############################################################################\n\ndef parsecml():\n parser = argparse.ArgumentParser(description=\"Verify genev.\")\n parser.add_argument(\"patterns\", metavar=\"M\", type=str, nargs='+', help=\"Input file list.\")\n #parser.add_argument(\"-f\", \"--flux\", metavar=\"F\", dest=\"fluxpatterns\", type=str, nargs='+', help=\".\")\n parser.add_argument(\"-p\", \"--plot\", metavar=\"P\", dest=\"plot\", type=str, choices=[\"flux\", \"rate\", \"ratio\"], help=\"Choose which plot to make.\")\n args = parser.parse_args()\n return args\n\n###############################################################################\n\ndef sanitize(args):\n for p in args.patterns:\n if len(glob.glob(p)) < 1:\n raise Exception(\"Input file does not exist or no matches to the pattern.\", p)\n return\n\n###############################################################################\n\ndef main():\n #ROOT.gROOT.ProcessLine(\".L rootrackerhelper.cxx++\")\n args = parsecml()\n sanitize(args)\n if args.plot == \"flux\":\n plot_flux(args)\n elif args.plot == \"rate\":\n plot_interaction_rate(args)\n elif args.plot == \"ratio\":\n plot_flux_int_xsec(args)\n return\n\n###############################################################################\n\nif __name__ == \"__main__\":\n main()\n\n###############################################################################\n", "meta": {"hexsha": "80f05e3ce9364668a95b1175c0d0eb713f2e5e7b", "size": 22349, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/vectorgen/verify_genev.py", "max_stars_repo_name": "davehadley/hk-vectorgen", "max_stars_repo_head_hexsha": "620a17b6a36357188e8d5b74867c497114edb178", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/vectorgen/verify_genev.py", "max_issues_repo_name": "davehadley/hk-vectorgen", "max_issues_repo_head_hexsha": "620a17b6a36357188e8d5b74867c497114edb178", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/vectorgen/verify_genev.py", "max_forks_repo_name": "davehadley/hk-vectorgen", "max_forks_repo_head_hexsha": "620a17b6a36357188e8d5b74867c497114edb178", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.6496124031, "max_line_length": 145, "alphanum_fraction": 0.4923710233, "include": true, "reason": "import numpy,import scipy", "num_tokens": 5323, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5774953797290153, "lm_q2_score": 0.33111973962899144, "lm_q1q2_score": 0.19122011977281708}} {"text": "import numpy as np\n\n'''\nLower body model\n\tstate vector\n\tx = [\n\t\troot: \t\t\t3D(6)\tp(x,y,z), u(x,y,z), \t \t,\n\n\t\tl_root: \t\t3D(6)\t\t\t\t\t\ttheta(x,y,z), \tw(x,y,z),\n\t\tl-hip: \t\t\t3D(6) \t\t\t\t\t\ttheta(x,y,z), \tw(x,y,z)\t,\n\t\tl-knee: \t\t1D(2) \t\t\t\t\t\ttheta(z), \t\tw(z)\t\t,\n\t\tl-ankle: \t\t2D(4) \t\t\t\t\t\ttheta(y,z), \tw(y,z)\t\t,\n\n r_root: 3D(6) theta(x,y,z), w(x,y,z),\n\t\tr-hip: \t\t\t3D(6)\t\t\t\t\t\ttheta(x,y,z), \tw(x,y,z)\t,\n\t\tr-knee: \t\t1D(2)\t\t\t\t\t\ttheta(z), \t\tw(z)\t\t,\n\t\tr-ankle: \t\t2D(4) \t\t\t\t\t\ttheta(y,z), \tw(y,z)\t\t,\n\n\t\tD_l_root_hip: \t1D(1)\tL\t\t\t\t\t\t\t\t\t\t\t\t,\n\t\tD_l_hip_knee: \t1D(1)\tL\t\t\t\t\t\t\t\t\t\t\t\t,\n\t\tD_l_knee_ankle: \t1D(1)\tL\t\t\t\t\t\t\t\t\t\t\t\t,\n\t\tD_l_ankle_foot: \t1D(1)\tL\t\t\t\t\t\t\t\t\t\t\t\t,\n\t\tD_r_root_hip: \t1D(1)\tL\t\t\t\t\t\t\t\t\t\t\t\t,\n\t\tD_r_hip_knee: \t1D(1)\tL\t\t\t\t\t\t\t\t\t\t\t\t,\n\t\tD_r_knee_ankle: \t1D(1)\tL\t\t\t\t\t\t\t\t\t\t\t\t,\n\t\tD_r_ankle_foot: \t1D(1)\tL\t\t\t\t\t\t\t\t\t\t\t\t,\n\t]\n cal: 42 + 8\n\ttotal vector length(DP): 50\n\n\tmeasurement vector\n\ty = [\n\t\tx_root: \t\t3D(3)\n\t\tx_l_hip: \t\t3D(3)\n\t\tx_l-knee:\t\t3D(3)\n\t\tx_l-ankle:\t\t3D(3)\n\t\tx_l-foot:\t\t3D(3)\n\t\tx_r-hip:\t\t3D(3)\n\t\tx_r-knee:\t\t3D(3)\n\t\tx_r-ankle:\t\t3D(3)\n\t\tx_r-foot:\t\t3D(3)\n\t]\n\ttotal vector length(MP): 27\n'''\nclass ukf_Lower_Params:\n def __init__(self, init_mean, init_cov=[1e-6, 1e-4, 1e-6, 1e-4, 1e-6, 1e-1, 1e-6, 1e-1, 1e-6, 1e-4, 1e-9, 1e-4, 100]):\n \tself.set_trans_covariance(init_cov[:11])\n \tself.set_obs_covariance(init_cov[11])\n \tself.set_mean(init_mean)\n \tself.set_init_trans_cov(init_cov[12])\n \tself.set_trans_matrix()\n\n def set_state_covariance(self, init_cov):\n root_p = init_cov[0]\n root_v = init_cov[1]\n root_l_t = root_r_t = init_cov[2]\n root_l_w = root_r_w = init_cov[3]\n hip_l_t = hip_r_t = init_cov[4]\n hip_l_w = hip_r_w = init_cov[5]\n knee_l_t = knee_r_t = init_cov[6]\n knee_l_w = knee_r_w = init_cov[7]\n ankle_l_t = ankle_r_t = init_cov[8]\n ankle_l_w = ankle_r_w = init_cov[9]\n link_length = init_cov[10]\n self.state_cov_list = [root_p,root_v,root_l_t,root_l_w,hip_l_t,hip_l_w,knee_l_t,knee_l_w,ankle_l_t,ankle_l_w,root_r_t,root_r_w,hip_r_t,hip_r_w,knee_r_t,knee_r_w,ankle_r_t,ankle_r_w,link_length]\n\n def set_state_dim(self):\n root_dim = 3\n root_l_dim = root_r_dim = 3\n hip_l_dim = hip_r_dim = 3\n knee_l_dim = knee_r_dim = 1\n ankle_l_dim = ankle_r_dim = 2\n link_length = 8\n self.state_cov_dim_list = [root_dim,root_dim,root_l_dim,root_l_dim,hip_l_dim,hip_l_dim,knee_l_dim,knee_l_dim,ankle_l_dim,ankle_l_dim,root_r_dim,root_r_dim,hip_r_dim,hip_r_dim,knee_r_dim,knee_r_dim,ankle_r_dim,ankle_r_dim,link_length]\n self.state_cov_total_dim = sum(self.state_cov_dim_list)\n\n def gen_trans_covariance(self):\n tmp = np.eye(self.state_cov_total_dim)\n\n idx = 0\n for i in range(len(self.state_cov_list)):\n for j in range(self.state_cov_dim_list[i]):\n tmp[idx+j][idx+j] = self.state_cov_list[i]\n idx = idx + self.state_cov_dim_list[i]\n\n self.trans_cov = tmp\n\n def set_trans_covariance(self, init_cov):\n self.set_state_covariance(init_cov)\n self.set_state_dim()\n self.gen_trans_covariance()\n\n def set_obs_covariance(self, init_obs_cov_factor):\n self.obs_cov_dim = 27\n self.obs_cov_factor = init_obs_cov_factor\n self.obs_cov = np.eye(self.obs_cov_dim)*self.obs_cov_factor\n\n def set_mean(self, init_mean):\n self.mean = init_mean\n\n def set_init_trans_cov(self, t_factor):\n \tself.init_trans_cov_factor = t_factor\n \tself.init_trans_cov = self.trans_cov * self.init_trans_cov_factor\n\n def set_trans_matrix(self):\n self.fps = 10\n self.is_velocity = [0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0]\n tmp = np.eye(self.state_cov_total_dim)\n\n idx = 0\n for i in range(len(self.state_cov_list)):\n \tif self.is_velocity[i] == 1:\n\t \tfor j in range(self.state_cov_dim_list[i]):\n\t \t\ttmp[idx+j-self.state_cov_dim_list[i]][idx+j] = 1/self.fps\n \tidx = idx + self.state_cov_dim_list[i]\n\n self.trans_matrx = tmp\n\n'''\nUpper body model\n state vector\n x = [\n root: 3D(6) p(x,y,z), u(x,y,z), ;\n s_root: 3D(6) theta(x,y,z), w(x,y,z), ;\n spine_naval: 3D(6) theta(x,y,z), w(x,y,z), ;\n l_spine_chest: 3D(6) theta(x,y,z), w(x,y,z), ;\n l_shoulder: 3D(6) theta(x,y,z), w(x,y,z), ;\n l_shoulder_center: 3D(6) theta(x,y,z), w(x,y,z), ;\n l_elbow: 3D(6) theta(x,y,z), w(x,y,z), ;\n l_wrist_u: 3D(6) theta(x,y,z), w(x,y,z), ;\n l_hand: 3D(6) theta(x,y,z), w(x,y,z), ;\n l_wrist_d: 3D(6) theta(x,y,z), w(x,y,z), ;\n\n r_spine_chest: 3D(6) theta(x,y,z), w(x,y,z), ;\n r_shoulder: 3D(6) theta(x,y,z), w(x,y,z), ;\n r_shoulder_center: 3D(6) theta(x,y,z), w(x,y,z), ;\n r_elbow: 3D(6) theta(x,y,z), w(x,y,z), ;\n r_wrist_u: 3D(6) theta(x,y,z), w(x,y,z), ;\n r_hand: 3D(6) theta(x,y,z), w(x,y,z), ;\n r_wrist_d: 3D(6) theta(x,y,z), w(x,y,z), ;\n u_spine_chest: 3D(6) theta(x,y,z), w(x,y,z), ;\n neck: 3D(6) theta(x,y,z), w(x,y,z), ;\n head: 3D(6) theta(x,y,z), w(x,y,z), ;\n\n l_nose: 3D(6) theta(x,y,z), w(x,y,z), ;\n l_eye: 3D(6) theta(x,y,z), w(x,y,z), ;\n r_nose: 3D(6) theta(x,y,z), w(x,y,z), ;\n r_eye: 3D(6) theta(x,y,z), w(x,y,z), ;\n\n D_root_spine: 1D(1) ,\n D_spine_chest: 1D(1) ,\n D_l_chest_sh: 1D(1) ,\n D_l_sh_shc: 1D(1) ,\n D_l_shc_elbow: 1D(1) ,\n D_l_elbow_wrist: 1D(1) ,\n D_l_wrist_hand 1D(1) ,\n D_l_hand_handtip: 1D(1) ,\n D_l_wrist_thumb: 1D(1) ,\n D_r_chest_sh: 1D(1) ,\n\n D_r_sh_shc: 1D(1) ,\n D_r_shc_elbow: 1D(1) ,\n D_r_elbow_wrist: 1D(1) ,\n D_r_wrist_hand: 1D(1) ,\n D_r_hand_handtip: 1D(1) ,\n D_r_wrist_thumb: 1D(1) ,\n D_chest_neck: 1D(1) ,\n D_neck_head: 1D(1) ,\n D_head_nose: 1D(1) ,\n D_l_nose_eye: 1D(1) ,\n\n D_l_eye_ear: 1D(1) ,\n D_r_nose_eye: 1D(1) ,\n D_r_eye_ear: 1D(1) ,\n ]\n cal: 24*6 - 8 + 23 = 144 + 23 = 167\n total vector length(DP): 167\n\n measurement vector\n y = [\n root: 3D(3) 0\n spine_naval: 3D(3) 1\n spine_chest: 3D(3) 2\n l_shoulder: 3D(3) 4\n l_shoulder_center: 3D(3) 5\n l_elbow: 3D(3) 6\n l_wrist: 3D(3) 7\n l_hand: 3D(3) 8\n l_handtip: 3D(3) 9\n l_thumb: 3D(3) 10\n\n r_shoulder: 3D(3) 11\n r_shoulder_center: 3D(3) 12\n r_elbow: 3D(3) 13\n r_wrist: 3D(3) 14\n r_hand: 3D(3) 15\n r_handtip: 3D(3) 16\n r_thumb: 3D(3) 17\n neck: 3D(3) 3\n head: 3D(3) 26\n nose: 3D(3) 27\n\n l_eye: 3D(3) 28\n l_ear: 3D(3) 29\n r_eye: 3D(3) 30\n r_ear: 3D(3) 31\n ]\n cal: 24 * 3 = 72\n total vector length(MP): 72\n'''\n\nclass ukf_Upper_Params:\n def __init__(self, init_mean, init_cov=[]):\n self.set_trans_covariance(init_cov[:35])\n self.set_obs_covariance(init_cov[35])\n self.set_mean(init_mean)\n self.set_init_trans_cov(init_cov[36])\n self.set_trans_matrix()\n\n def set_state_covariance(self, init_cov):\n root_p, root_v = init_cov[0:2]\n s_root_t, s_root_w = init_cov[2:4]\n spine_naval_t, spine_naval_w = init_cov[4:6]\n\n l_spine_chest_t, l_spine_chest_w = init_cov[6:8]\n l_shoulder_t, l_shoulder_w = init_cov[8:10]\n l_shoulder_center_t, l_shoulder_center_w = init_cov[10:12]\n l_elbow_t, l_elbow_w = init_cov[12:14]\n l_wrist_u_t, l_wrist_u_w = init_cov[14:16]\n l_hand_t, l_hand_w = init_cov[16:18]\n l_wrist_d_t, l_wrist_d_w = init_cov[18:20]\n\n r_spine_chest_t, r_spine_chest_w = init_cov[6:8]\n r_shoulder_t, r_shoulder_w = init_cov[8:10]\n r_shoulder_center_t, r_shoulder_center_w = init_cov[10:12]\n r_elbow_t, r_elbow_w = init_cov[12:14]\n r_wrist_u_t, r_wrist_u_w = init_cov[14:16]\n r_hand_t, r_hand_w = init_cov[16:18]\n r_wrist_d_t, r_wrist_d_w = init_cov[18:20]\n\n u_spine_chest_t, u_spine_chest_w = init_cov[20:22]\n neck_t, neck_w = init_cov[22:24]\n head_t, head_w = init_cov[24:26]\n l_nose_t, l_nose_w = init_cov[26:28]\n l_eye_t, l_eye_w = init_cov[28:30]\n r_nose_t, r_nose_w = init_cov[30:32]\n r_eye_t, r_eye_w = init_cov[32:34]\n\n link_length = init_cov[34]\n\n self.state_cov_list = [root_p,root_v,s_root_t,s_root_w,spine_naval_t,spine_naval_w,l_spine_chest_t,l_spine_chest_w,l_shoulder_t,l_shoulder_w,l_shoulder_center_t,l_shoulder_center_w,l_elbow_t,l_elbow_w,l_wrist_u_t,l_wrist_u_w,l_hand_t,l_hand_w,l_wrist_d_t,l_wrist_d_w,r_spine_chest_t,r_spine_chest_w,r_shoulder_t,r_shoulder_w,r_shoulder_center_t,r_shoulder_center_w,r_elbow_t,r_elbow_w,r_wrist_u_t,r_wrist_u_w,r_hand_t,r_hand_w,r_wrist_d_t,r_wrist_d_w,u_spine_chest_t,u_spine_chest_w,neck_t,neck_w,head_t,head_w,l_nose_t,l_nose_w,l_eye_t,l_eye_w,r_nose_t,r_nose_w,r_eye_t,r_eye_w,link_length]\n\n def set_state_dim(self):\n root_dim = 3\n s_root_dim = 3\n spine_naval_dim = 3\n\n l_spine_chest_dim = 3\n l_shoulder_dim = 3\n l_shoulder_center_dim = 3\n l_elbow_dim = 3\n l_wrist_u_dim = 3\n l_hand_dim = 3\n l_wrist_d_dim = 3\n\n r_spine_chest_dim = 3\n r_shoulder_dim = 3\n r_shoulder_center_dim = 3\n r_elbow_dim = 3\n r_wrist_u_dim = 3\n r_hand_dim = 3\n r_wrist_d_dim = 3\n\n u_spine_chest_dim = 3\n neck_dim = 3\n head_dim = 3\n l_nose_dim = 3\n l_eye_dim = 3\n r_nose_dim = 3\n r_eye_dim = 3\n\n link_length_dim = 23\n\n self.state_cov_dim_list = [root_dim,root_dim,s_root_dim,s_root_dim,spine_naval_dim,spine_naval_dim,l_spine_chest_dim,l_spine_chest_dim,l_shoulder_dim,l_shoulder_dim,l_shoulder_center_dim,l_shoulder_center_dim,l_elbow_dim,l_elbow_dim,l_wrist_u_dim,l_wrist_u_dim,l_hand_dim,l_hand_dim,l_wrist_d_dim,l_wrist_d_dim,r_spine_chest_dim,r_spine_chest_dim,r_shoulder_dim,r_shoulder_dim,r_shoulder_center_dim,r_shoulder_center_dim,r_elbow_dim,r_elbow_dim,r_wrist_u_dim,r_wrist_u_dim,r_hand_dim,r_hand_dim,r_wrist_d_dim,r_wrist_d_dim,u_spine_chest_dim,u_spine_chest_dim,neck_dim,neck_dim,head_dim,head_dim,l_nose_dim,l_nose_dim,l_eye_dim,l_eye_dim,r_nose_dim,r_nose_dim,r_eye_dim,r_eye_dim,link_length_dim]\n self.state_cov_total_dim = sum(self.state_cov_dim_list)\n\n def gen_trans_covariance(self):\n tmp = np.eye(self.state_cov_total_dim)\n\n idx = 0\n for i in range(len(self.state_cov_list)):\n for j in range(self.state_cov_dim_list[i]):\n tmp[idx+j][idx+j] = self.state_cov_list[i]\n idx = idx + self.state_cov_dim_list[i]\n\n self.trans_cov = tmp\n\n def set_trans_covariance(self, init_cov):\n self.set_state_covariance(init_cov)\n self.set_state_dim()\n self.gen_trans_covariance()\n\n def set_obs_covariance(self, init_obs_cov_factor):\n self.obs_cov_dim = 72\n self.obs_cov_factor = init_obs_cov_factor\n self.obs_cov = np.eye(self.obs_cov_dim)*self.obs_cov_factor\n\n def set_mean(self, init_mean):\n self.mean = init_mean\n\n def set_init_trans_cov(self, t_factor):\n self.init_trans_cov_factor = t_factor\n self.init_trans_cov = self.trans_cov * self.init_trans_cov_factor\n\n def set_trans_matrix(self):\n self.fps = 10\n self.is_velocity = [0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0]\n tmp = np.eye(self.state_cov_total_dim)\n\n idx = 0\n for i in range(len(self.state_cov_list)):\n if self.is_velocity[i] == 1:\n for j in range(self.state_cov_dim_list[i]):\n tmp[idx+j-self.state_cov_dim_list[i]][idx+j] = 1/self.fps\n idx = idx + self.state_cov_dim_list[i]\n\n self.trans_matrx = tmp\n", "meta": {"hexsha": "c2ebb461cc355c886ef46ebc9e87aa3468978c55", "size": 14973, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/ukf_params.py", "max_stars_repo_name": "fbdp1202/pyukf_kinect_body_tracking", "max_stars_repo_head_hexsha": "c44477149cfc22abfe9121c2604dc284c93fbd42", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7, "max_stars_repo_stars_event_min_datetime": "2020-04-23T06:03:10.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-16T21:16:23.000Z", "max_issues_repo_path": "src/ukf_params.py", "max_issues_repo_name": "fbdp1202/pyukf_kinect_body_tracking", "max_issues_repo_head_hexsha": "c44477149cfc22abfe9121c2604dc284c93fbd42", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/ukf_params.py", "max_forks_repo_name": "fbdp1202/pyukf_kinect_body_tracking", "max_forks_repo_head_hexsha": "c44477149cfc22abfe9121c2604dc284c93fbd42", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-07-12T15:07:52.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-05T09:27:18.000Z", "avg_line_length": 45.6493902439, "max_line_length": 703, "alphanum_fraction": 0.490549656, "include": true, "reason": "import numpy", "num_tokens": 4586, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5774953651858118, "lm_q2_score": 0.3311197462295937, "lm_q1q2_score": 0.19122011876909256}} {"text": "#!/usr/bin/env python\n\n\"\"\"main Absorb routines\n Copyright: 2009, Robert B. Von Dreele (Argonne National Laboratory)\n\"\"\"\nfrom __future__ import division, print_function\nimport platform\nimport math\nimport wx\nimport numpy as np\nimport sys\nimport matplotlib as mpl\nimport GSASIIpath\nGSASIIpath.SetVersionNumber(\"$Revision: 4672 $\")\nimport GSASIIElem as G2elem\nimport GSASIIElemGUI as G2elemGUI\n\ntry:\n wx.NewIdRef\n wx.NewId = wx.NewIdRef\nexcept AttributeError:\n pass\n\nif '2' in platform.python_version_tuple()[0]:\n Gktheta = unichr(0x3b8)\n Gklambda = unichr(0x3bb)\n GkDelta = unichr(0x0394)\n Pwr10 = unichr(0x0b9)+unichr(0x2070)\n Pwr20 = unichr(0x0b2)+unichr(0x2070)\n Pwrm1 = unichr(0x207b)+unichr(0x0b9)\n Pwrm2 = unichr(0x207b)+unichr(0x0b2)\n Pwrm6 = unichr(0x207b)+unichr(0x2076)\n Pwrm4 = unichr(0x207b)+unichr(0x2074)\n Angstr = unichr(0x00c5)\n Gkmu = unichr(0x3bc)\n Pwr3 = unichr(0x0b3)\n Pwr4 = unichr(0x2074)\n Pwr20 = unichr(0x0b2)+unichr(0x0b0)\n Pwrm1 = unichr(0x207b)+unichr(0x0b9)\n\nelse:\n Gktheta = chr(0x3b8)\n Gklambda = chr(0x3bb)\n GkDelta = chr(0x0394)\n Pwr10 = chr(0x0b9)+chr(0x2070)\n Pwr20 = chr(0x0b2)+chr(0x2070)\n Pwrm1 = chr(0x207b)+chr(0x0b9)\n Pwrm2 = chr(0x207b)+chr(0x0b2)\n Pwrm6 = chr(0x207b)+chr(0x2076)\n Pwrm4 = chr(0x207b)+chr(0x2074)\n Angstr = chr(0x00c5) \n Gkmu = chr(0x3bc)\n Pwr3 = chr(0x0b3)\n Pwr4 = chr(0x2074)\n Pwr20 = chr(0x0b2)+chr(0x0b0)\n Pwrm1 = chr(0x207b)+chr(0x0b9)\n\n[wxID_CHOICE1, wxID_SPINTEXT1, wxID_SPINTEXT2, wxID_SPINTEXT3, wxID_SPINTEXT4,\n wxID_RESULTS,wxID_SLIDER1, wxID_SPINBUTTON, wxID_NUMELEM, wxID_SPINTEXT5,wxID_SPINTEXT6,\n] = [wx.NewId() for _init_ctrls in range(11)]\n\n[wxID_EXIT, wxID_DELETE, wxID_NEW, \n] = [wx.NewId() for _init_coll_ABSORB_Items in range(3)]\n \n[wxID_KALPHAAGKA, wxID_KALPHACOKA, wxID_KALPHACRKA, \n wxID_KALPHACUKA, wxID_KALPHAFEKA, wxID_KALPHAMNKA, \n wxID_KALPHAMOKA, wxID_KALPHANIKA, wxID_KALPHAZNKA, \n] = [wx.NewId() for _init_coll_KALPHA_Items in range(9)]\n\n[wxID_ABSORBABOUT] = [wx.NewId() for _init_coll_ABOUT_Items in range(1)]\n\nclass Absorb(wx.Frame):\n ''' '''\n Elems = []\n Wave = 1.5405 #CuKa default\n Kev = 12.397639 #keV for 1A x-rays\n for arg in sys.argv:\n if '-w' in arg:\n Wave = float(arg.split('-w')[1])\n elif '-e' in arg:\n E = float(arg.split('-e')[1])\n Wave = Kev/E\n elif '-h' in arg:\n print ('''\nAbsorb.py can take the following arguments:\n-h - this help listing\n-wv - set default wavelength to v, e.g. -w1.54 sets wavelength to 1.54A\n-ev - set default energy to v, e.g. -e27 sets energy to 27keV\nwithout arguments Absorb uses CuKa as default (Wave=1.54052A, E=8.0478keV)\n''')\n sys.exit()\n Wmin = 0.05 #wavelength range\n Wmax = 3.0\n Wres = 0.004094 #plot resolution step size as const delta-lam/lam - gives 1000 steps for Wmin to Wmax\n Eres = 1.5e-4 #typical energy resolution for synchrotron x-ray sources\n Energy = Kev/Wave\n ifWave = True\n Volume = 0\n ifVol = False\n Zcell = 1\n Pack = 0.50\n Radius = 0.4\n def _init_coll_ABOUT_Items(self, parent):\n\n parent.Append(wxID_ABSORBABOUT,'About')\n self.Bind(wx.EVT_MENU, self.OnABOUTItems0Menu, id=wxID_ABSORBABOUT)\n\n def _init_coll_menuBar1_Menus(self, parent):\n\n parent.Append(menu=self.ABSORB, title='Absorb')\n parent.Append(menu=self.KALPHA, title='Kalpha')\n parent.Append(menu=self.ABOUT, title='About')\n\n def _init_coll_KALPHA_Items(self, parent):\n \"Set of characteristic radiation from sealed tube sources\"\n def OnCrkaMenu(event):\n self.SetWaveEnergy(2.28962)\n \n def OnMnkaMenu(event):\n self.SetWaveEnergy(2.10174)\n \n def OnFekaMenu(event):\n self.SetWaveEnergy(1.93597)\n \n def OnCokaMenu(event):\n self.SetWaveEnergy(1.78896)\n \n def OnNikaMenu(event):\n self.SetWaveEnergy(1.65784)\n \n def OnCukaMenu(event):\n self.SetWaveEnergy(1.54052)\n \n def OnZnkaMenu(event):\n self.SetWaveEnergy(1.43510)\n \n def OnMokaMenu(event):\n self.SetWaveEnergy(0.70926)\n \n def OnAgkaMenu(event):\n self.SetWaveEnergy(0.55936)\n \n parent.Append(wxID_KALPHACRKA, 'CrKa')\n parent.Append(wxID_KALPHAMNKA, 'MnKa')\n parent.Append(wxID_KALPHAFEKA, 'FeKa')\n parent.Append(wxID_KALPHACOKA, 'CoKa')\n parent.Append(wxID_KALPHANIKA, 'NiKa')\n parent.Append(wxID_KALPHACUKA, 'CuKa')\n parent.Append(wxID_KALPHAZNKA, 'ZnKa')\n parent.Append(wxID_KALPHAMOKA, 'MoKa')\n parent.Append(wxID_KALPHAAGKA, 'AgKa')\n self.Bind(wx.EVT_MENU, OnCrkaMenu, id=wxID_KALPHACRKA)\n self.Bind(wx.EVT_MENU, OnMnkaMenu, id=wxID_KALPHAMNKA)\n self.Bind(wx.EVT_MENU, OnFekaMenu, id=wxID_KALPHAFEKA)\n self.Bind(wx.EVT_MENU, OnCokaMenu, id=wxID_KALPHACOKA)\n self.Bind(wx.EVT_MENU, OnNikaMenu, id=wxID_KALPHANIKA)\n self.Bind(wx.EVT_MENU, OnCukaMenu, id=wxID_KALPHACUKA)\n self.Bind(wx.EVT_MENU, OnZnkaMenu, id=wxID_KALPHAZNKA)\n self.Bind(wx.EVT_MENU, OnMokaMenu, id=wxID_KALPHAMOKA)\n self.Bind(wx.EVT_MENU, OnAgkaMenu, id=wxID_KALPHAAGKA)\n\n def _init_coll_ABSORB_Items(self, parent):\n parent.Append(wxID_NEW,'&New Element','Add new element')\n self.Delete = parent.Append(wxID_DELETE,'&Delete Element','Delete an element')\n self.Delete.Enable(False)\n parent.Append(wxID_EXIT,'&Exit','Exit Fprime')\n self.Bind(wx.EVT_MENU, self.OnExitMenu, id=wxID_EXIT)\n self.Bind(wx.EVT_MENU, self.OnNewMenu, id=wxID_NEW)\n self.Bind(wx.EVT_MENU, self.OnDeleteMenu, id=wxID_DELETE)\n \n def _init_utils(self):\n self.ABSORB = wx.Menu(title='')\n\n self.KALPHA = wx.Menu(title='')\n self.KALPHA.SetEvtHandlerEnabled(True)\n\n self.ABOUT = wx.Menu(title='')\n\n self.menuBar1 = wx.MenuBar()\n\n self._init_coll_ABSORB_Items(self.ABSORB)\n self._init_coll_KALPHA_Items(self.KALPHA)\n self._init_coll_ABOUT_Items(self.ABOUT)\n self._init_coll_menuBar1_Menus(self.menuBar1)\n\n def _init_ctrls(self, parent):\n wx.Frame.__init__(self, parent=parent,\n size=wx.Size(500, 400),style=wx.DEFAULT_FRAME_STYLE ^ wx.CLOSE_BOX, title='Absorb') \n self._init_utils()\n self.SetMenuBar(self.menuBar1)\n self.DrawPanel()\n \n def SetSize(self):\n w,h = self.GetClientSize()\n self.panel.SetSize(wx.Size(w,h))\n\n def DrawPanel(self):\n self.panel = wx.Panel(self)\n\n mainSizer = wx.BoxSizer(wx.VERTICAL)\n self.Results = wx.TextCtrl( parent=self.panel,\n style=wx.TE_MULTILINE|wx.TE_DONTWRAP )\n self.Results.SetEditable(False)\n mainSizer.Add(self.Results,1,wx.EXPAND)\n mainSizer.Add((10,15),0)\n \n if self.Elems:\n lablSizer = wx.BoxSizer(wx.HORIZONTAL)\n lablSizer.Add((5,10),0)\n lablSizer.Add(wx.StaticText(parent=self.panel,label='Chemical Formula:'),0,\n wx.ALIGN_CENTER_VERTICAL|wx.ALIGN_LEFT)\n mainSizer.Add(lablSizer,0)\n mainSizer.Add((5,5),0)\n nRow = len(self.Elems)/5\n compSizer = wx.FlexGridSizer(nRow+1,10,0,0)\n for Elem in self.Elems:\n compSizer.Add(wx.StaticText(parent=self.panel,label=\" \"+Elem[0].capitalize(),\n size=wx.Size(30,20)),0,wx.ALIGN_CENTER_VERTICAL|wx.ALIGN_RIGHT)\n numElem = wx.TextCtrl(id=wxID_NUMELEM,parent=self.panel,name=Elem[0],\n size=wx.Size(70,20),value=\"%.2f\" % (Elem[2]),style=wx.TE_PROCESS_ENTER)\n compSizer.Add(numElem,0)\n numElem.Bind(wx.EVT_TEXT_ENTER, self.OnNumElem, id=wxID_NUMELEM)\n mainSizer.Add(compSizer,0)\n mainSizer.Add((10,15),0) \n\n selSizer = wx.BoxSizer(wx.HORIZONTAL)\n selSizer.Add((5,10),0)\n selSizer.Add(wx.StaticText(parent=self.panel, label='Wavelength:'),0,wx.EXPAND)\n selSizer.Add((5,10),0)\n self.SpinText1 = wx.TextCtrl(id=wxID_SPINTEXT1, parent=self.panel, \n size=wx.Size(100,20), value = \"%.4f\" % (self.Wave),style=wx.TE_PROCESS_ENTER )\n selSizer.Add(self.SpinText1,0)\n selSizer.Add((5,10),0)\n self.SpinText1.Bind(wx.EVT_TEXT_ENTER, self.OnSpinText1, id=wxID_SPINTEXT1)\n \n selSizer.Add(wx.StaticText(parent=self.panel, label='Energy:'),0,wx.EXPAND)\n selSizer.Add((5,10),0)\n self.SpinText2 = wx.TextCtrl(id=wxID_SPINTEXT2, parent=self.panel, \n size=wx.Size(100,20), value = \"%.4f\" % (self.Energy),style=wx.TE_PROCESS_ENTER) \n selSizer.Add(self.SpinText2,0)\n selSizer.Add((5,10),0)\n self.SpinText2.Bind(wx.EVT_TEXT_ENTER, self.OnSpinText2, id=wxID_SPINTEXT2)\n \n selSizer.Add(wx.StaticText(parent=self.panel, label='Plot scale:'),0,wx.EXPAND)\n selSizer.Add((5,10),0)\n self.choice1 = wx.ComboBox(id=wxID_CHOICE1, parent=self.panel, value='Wavelength',\n choices=['Wavelength','Energy'],style=wx.CB_READONLY|wx.CB_DROPDOWN)\n selSizer.Add(self.choice1,0)\n selSizer.Add((10,10),0)\n self.choice1.Bind(wx.EVT_COMBOBOX, self.OnChoice1, id=wxID_CHOICE1)\n mainSizer.Add(selSizer,0)\n mainSizer.Add((10,10),0)\n \n slideSizer = wx.BoxSizer(wx.HORIZONTAL)\n self.SpinButton = wx.SpinButton(id=wxID_SPINBUTTON, parent=self.panel, \n size=wx.Size(25,24), style=wx.SP_VERTICAL | wx.SP_ARROW_KEYS)\n slideSizer.Add(self.SpinButton,0,wx.ALIGN_RIGHT)\n self.SpinButton.SetRange(-1,1)\n self.SpinButton.SetValue(0)\n self.SpinButton.Bind(wx.EVT_SPIN, self.OnSpinButton, id=wxID_SPINBUTTON)\n\n self.slider1 = wx.Slider(id=wxID_SLIDER1, maxValue=int(1000.*self.Wmax),\n minValue=int(1000.*self.Wmin), parent=self.panel,style=wx.SL_HORIZONTAL,\n value=int(self.Wave*1000.), )\n slideSizer.Add(self.slider1,1,wx.EXPAND)\n self.slider1.Bind(wx.EVT_SLIDER, self.OnSlider1, id=wxID_SLIDER1)\n mainSizer.Add(slideSizer,0,wx.EXPAND)\n mainSizer.Add((10,10),0)\n \n cellSizer = wx.BoxSizer(wx.HORIZONTAL)\n cellSizer.Add((5,10),0)\n cellSizer.Add(wx.StaticText(parent=self.panel, label='Volume:'),0,wx.EXPAND)\n cellSizer.Add((5,10),0)\n self.SpinText3 = wx.TextCtrl(id=wxID_SPINTEXT3, parent=self.panel, \n size=wx.Size(100,20), value = \"%.2f\" % (self.Volume),style=wx.TE_PROCESS_ENTER )\n cellSizer.Add(self.SpinText3,0)\n cellSizer.Add((5,10),0)\n self.SpinText3.Bind(wx.EVT_TEXT_ENTER, self.OnSpinText3, id=wxID_SPINTEXT3)\n \n cellSizer.Add((5,10),0)\n cellSizer.Add(wx.StaticText(parent=self.panel, label='Z(vol):'),0,wx.EXPAND)\n cellSizer.Add((5,10),0)\n self.SpinText4 = wx.TextCtrl(id=wxID_SPINTEXT4, parent=self.panel, \n size=wx.Size(50,20), value = \"%d\" % (self.Zcell),style=wx.TE_PROCESS_ENTER )\n cellSizer.Add(self.SpinText4,0)\n cellSizer.Add((5,10),0)\n self.SpinText4.Bind(wx.EVT_TEXT_ENTER, self.OnSpinText4, id=wxID_SPINTEXT4)\n \n cellSizer.Add((5,10),0)\n cellSizer.Add(wx.StaticText(parent=self.panel, label='Sample R:'),0,wx.EXPAND)\n cellSizer.Add((5,10),0)\n self.SpinText5 = wx.TextCtrl(id=wxID_SPINTEXT5, parent=self.panel, \n size=wx.Size(50,20), value = \"%.2f\" % (self.Radius),style=wx.TE_PROCESS_ENTER )\n cellSizer.Add(self.SpinText5,0)\n cellSizer.Add((5,10),0)\n self.SpinText5.Bind(wx.EVT_TEXT_ENTER, self.OnSpinText5, id=wxID_SPINTEXT5)\n\n cellSizer.Add((5,10),0)\n cellSizer.Add(wx.StaticText(parent=self.panel, label='packing:'),0,wx.EXPAND)\n cellSizer.Add((5,10),0)\n self.SpinText6 = wx.TextCtrl(id=wxID_SPINTEXT6, parent=self.panel, \n size=wx.Size(50,20), value = \"%.2f\" % (self.Pack),style=wx.TE_PROCESS_ENTER )\n cellSizer.Add(self.SpinText6,0)\n cellSizer.Add((5,10),0)\n self.SpinText6.Bind(wx.EVT_TEXT_ENTER, self.OnSpinText6, id=wxID_SPINTEXT6)\n\n mainSizer.Add(cellSizer,0)\n mainSizer.Add((10,10),0)\n self.panel.SetSizer(mainSizer)\n self.panel.Fit()\n self.panel.GetParent().SetSize()\n\n def __init__(self, parent):\n self._init_ctrls(parent)\n self.parent = parent\n self.Lines = []\n self.Elems = []\n self.linePicked = None\n\n def OnExitMenu(self, event):\n self.parent.G2plotNB.Delete('Absorb')\n self.Close()\n self.Destroy()\n\n def OnNewMenu(self, event):\n ElList = []\n for Elem in self.Elems: ElList.append(Elem[0])\n PE = G2elemGUI.PickElements(self,ElList)\n if PE.ShowModal() == wx.ID_OK:\n Elem = PE.Elem\n PE.Destroy()\n if Elem:\n for El in Elem:\n ElemSym = El.strip().upper()\n if ElemSym not in ElList:\n atomData = G2elem.GetAtomInfo(ElemSym.capitalize())\n FormFactors = G2elem.GetFormFactorCoeff(ElemSym)\n for FormFac in FormFactors:\n FormSym = FormFac['Symbol'].strip()\n if FormSym == ElemSym:\n Z = FormFac['Z'] #At. No.\n N = 1. #no atoms / formula unit\n Orbs = G2elem.GetXsectionCoeff(ElemSym)\n Elem = [ElemSym,Z,N,FormFac,Orbs,atomData]\n self.Elems.append(Elem)\n self.Delete.Enable(True)\n self.panel.Destroy()\n self.DrawPanel()\n self.NewFPPlot = True\n self.SetWaveEnergy(self.Wave)\n \n def OnDeleteMenu(self, event):\n if len(self.Elems):\n ElList = []\n for Elem in self.Elems: ElList.append(Elem[0])\n S = []\n DE = G2elemGUI.DeleteElement(self,ElList)\n if DE.ShowModal() == wx.ID_OK:\n El = DE.GetDeleteElement().strip().upper()\n for Elem in self.Elems:\n if Elem[0] != El:\n S.append(Elem)\n self.Elems = S\n self.CalcFPPS()\n if not self.Elems:\n self.Delete.Enable(False)\n self.panel.Destroy()\n self.DrawPanel()\n self.NewFPPlot = True\n self.SetWaveEnergy(self.Wave)\n \n def OnNumElem(self, event):\n for Elem in self.Elems:\n if event.GetEventObject().GetName() == Elem[0]:\n Elem[2] = float(event.GetEventObject().GetValue())\n event.GetEventObject().SetValue(\"%8.2f\" % (Elem[2]))\n self.SetWaveEnergy(self.Wave) \n \n def OnSpinText1(self, event):\n self.SetWaveEnergy(float(self.SpinText1.GetValue()))\n \n def OnSpinText2(self, event):\n self.SetWaveEnergy(self.Kev/(float(self.SpinText2.GetValue())))\n \n def OnSpinText3(self,event):\n self.Volume = max(10.,float(self.SpinText3.GetValue()))\n self.ifVol = True\n self.SetWaveEnergy(self.Wave)\n \n def OnSpinText4(self,event):\n self.Zcell = max(1,float(self.SpinText4.GetValue()))\n self.SetWaveEnergy(self.Wave)\n \n def OnSpinText5(self, event):\n self.Radius = max(0.01,float(self.SpinText5.GetValue()))\n self.SetWaveEnergy(self.Wave)\n \n def OnSpinText6(self, event):\n self.Pack = min(1.0,max(0.01,float(self.SpinText6.GetValue())))\n self.SetWaveEnergy(self.Wave)\n \n def OnSpinButton(self, event):\n move = self.SpinButton.GetValue()/10000.\n self.Wave = min(max(self.Wave+move,self.Wmin),self.Wmax)\n self.SpinButton.SetValue(0)\n self.SetWaveEnergy(self.Wave)\n\n def OnSlider1(self, event):\n if self.ifWave:\n Wave = float(self.slider1.GetValue())/1000.\n else:\n Wave = self.Kev/(float(self.slider1.GetValue())/1000.)\n self.SetWaveEnergy(Wave)\n \n def SetWaveEnergy(self,Wave):\n self.Wave = Wave\n self.Energy = self.Kev/self.Wave\n self.Energy = round(self.Energy,4)\n E = self.Energy\n DE = E*self.Eres #smear by defined source resolution\n self.SpinText1.SetValue(\"%.4f\" % (self.Wave))\n self.SpinText2.SetValue(\"%.4f\" % (self.Energy))\n self.SpinText1.Update()\n self.SpinText2.Update()\n if self.ifWave:\n self.slider1.SetValue(int(1000.*self.Wave))\n else:\n self.slider1.SetValue(int(1000.*self.Energy))\n Text = ''\n if not self.ifVol:\n self.Volume = 0\n for Elem in self.Elems:\n self.Volume += 10.*Elem[2]\n muT = 0\n Mass = 0\n Fo = 0\n Fop = 0\n for Elem in self.Elems:\n Mass += self.Zcell*Elem[2]*Elem[5]['Mass']\n r1 = G2elem.FPcalc(Elem[4],E+DE)\n r2 = G2elem.FPcalc(Elem[4],E-DE)\n Els = Elem[0]\n Els = Els.ljust(2).lower().capitalize()\n mu = 0\n Fo += Elem[2]*Elem[1]\n if Elem[1] > 78 and self.Energy+DE > self.Kev/0.16:\n mu = self.Zcell*Elem[2]*(r1[2]+r2[2])/2.0\n Text += \"%s\\t%s%8.2f %s%6s %s%6.3f %s%10.2f %s\\n\" % (\n 'Element= '+str(Els),\"N = \",Elem[2],\" f'=\",'not valid',\n ' f\"=',(r1[1]+r2[1])/2.0,' '+Gkmu+'=',mu,'barns')\n elif Elem[1] > 94 and self.Energy-DE < self.Kev/2.67:\n mu = 0\n Text += \"%s\\t%s%8.2f %s%6s %s%6s %s%10s%s\\n\" % (\n 'Element= '+str(Els),\"N = \",Elem[2],\" f'=\",'not valid',\n ' f\"=','not valid',' '+Gkmu+'=','not valid')\n else:\n mu = self.Zcell*Elem[2]*(r1[2]+r2[2])/2.0\n Fop += Elem[2]*(Elem[1]+(r1[0]+r2[0])/2.0)\n Text += \"%s\\t%s%8.2f %s%6.3f %s%6.3f %s%10.2f %s\\n\" % (\n 'Element= '+str(Els),\"N = \",Elem[2],\" f'=\",(r1[0]+r2[0])/2.0,\n ' f\"=',(r1[1]+r2[1])/2.0,' '+Gkmu+'=',mu,'barns')\n muT += mu\n \n if self.Volume:\n Text += \"%s %s%10.2f %s\" % (\"Total\",' '+Gkmu+'=',self.Pack*muT/self.Volume,'cm'+Pwrm1+', ')\n Text += \"%s%10.2f%s\" % ('Total '+Gkmu+'R=',self.Radius*self.Pack*muT/(10.0*self.Volume),', ')\n Text += \"%s%10.4f%s\\n\" % ('Transmission exp(-2'+Gkmu+'R)=', \\\n 100.0*math.exp(-2*self.Radius*self.Pack*muT/(10.0*self.Volume)),'%')\n self.Results.SetValue(Text)\n den = Mass/(0.602*self.Volume) \n if self.ifVol:\n Text += '%s' % ('Theor. density=')\n else: \n Text += '%s' % ('Est. density=')\n Text += '%6.3f %s%.3f %s\\n' % (den,'g/cm'+Pwr3+', Powder density=',self.Pack*den,'g/cm'+Pwr3)\n Text += '%s%10.2f%s\\n'%('X-ray small angle scattering contrast',(28.179*Fo/self.Volume)**2,'*10'+Pwr20+'/cm'+Pwr4)\n if Fop:\n Text += '%s%10.2f%s\\n'%('Anomalous X-ray small angle scattering contrast',(28.179*Fop/self.Volume)**2,'*10'+Pwr20+'/cm'+Pwr4)\n self.Results.SetValue(Text)\n self.Results.Update()\n self.SpinText3.SetValue(\"%.2f\" % (self.Volume))\n self.SpinText3.Update()\n self.SpinText4.SetValue(\"%d\" % (self.Zcell))\n self.SpinText4.Update()\n self.SpinText5.SetValue(\"%.2f\" % (self.Radius))\n self.SpinText5.Update()\n self.SpinText6.SetValue(\"%.2f\" % (self.Pack))\n self.SpinText6.Update()\n if len(self.Elems):\n self.CalcFPPS()\n self.UpDateAbsPlot(Wave,rePlot=True)\n\n def CalcFPPS(self):\n \"\"\"generate f\" curves for selected elements\n does constant delta-lambda/lambda steps over defined range\n \"\"\"\n FPPS = []\n if self.Elems:\n wx.BeginBusyCursor()\n Corr = self.Zcell*self.Radius*self.Pack/(10.0*self.Volume)\n try:\n muT = []\n for iE,Elem in enumerate(self.Elems):\n Els = Elem[0]\n Els = Els = Els.ljust(2).lower().capitalize()\n Wmin = self.Wmin\n Wmax = self.Wmax\n lWmin = math.log(Wmin)\n N = int(round(math.log(Wmax/Wmin)/self.Wres)) #number of constant delta-lam/lam steps\n I = range(N+1)\n Ws = []\n for i in I: Ws.append(math.exp(i*self.Wres+lWmin))\n mus = []\n Es = []\n for j,W in enumerate(Ws):\n E = self.Kev/W\n DE = E*self.Eres #smear by defined source resolution\n res1 = G2elem.FPcalc(Elem[4],E+DE)\n res2 = G2elem.FPcalc(Elem[4],E-DE)\n muR = Corr*Elem[2]*(res1[2]+res2[2])/2.0\n mus.append(muR)\n if iE:\n muT[j] += muR\n else:\n muT.append(muR)\n Es.append(E)\n if self.ifWave:\n Fpps = (Els,Ws,mus)\n else:\n Fpps = (Els,Es,mus)\n FPPS.append(Fpps)\n if self.ifWave:\n Fpps = ('Total',Ws,muT)\n else:\n Fpps = ('Total',Es,muT)\n FPPS.append(Fpps)\n finally:\n wx.EndBusyCursor()\n self.FPPS = FPPS\n\n def OnChoice1(self, event):\n if event.GetString() == \"Wavelength\":\n self.ifWave = True\n self.NewFPPlot = True\n self.Wave = round(self.Wave,4)\n self.slider1.SetRange(int(1000.*self.Wmin),int(1000.*self.Wmax))\n self.slider1.SetValue(int(1000.*self.Wave))\n self.SpinText1.SetValue(\"%6.4f\" % (self.Wave))\n self.SpinText2.SetValue(\"%7.4f\" % (self.Energy))\n else:\n self.ifWave = False\n self.NewFPPlot = True\n Emin = self.Kev/self.Wmax\n Emax = self.Kev/self.Wmin\n self.Energy = round(self.Energy,4)\n self.slider1.SetRange(int(1000.*Emin),int(1000.*Emax))\n self.slider1.SetValue(int(1000.*self.Energy))\n self.SpinText1.SetValue(\"%6.4f\" % (self.Wave))\n self.SpinText2.SetValue(\"%7.4f\" % (self.Energy))\n if len(self.Elems):\n self.CalcFPPS()\n self.UpDateAbsPlot(self.Wave,rePlot=False)\n \n def OnKeyPress(self,event):\n if event.key == 'g':\n mpl.rcParams['axes.grid'] = not mpl.rcParams['axes.grid']\n self.UpDateAbsPlot(self.Wave,rePlot=False)\n\n def UpDateAbsPlot(self,Wave,rePlot=True):\n \"\"\"Plot mu vs wavelength 0.05-3.0A\"\"\"\n xylim = []\n try:\n if rePlot:\n asb = self.Page.figure.get_axes()[1]\n xylim = asb.get_xlim(),asb.get_ylim()\n newPlot = False\n except:\n new,plotNum,self.Page,self.fplot,lim = self.parent.G2plotNB.FindPlotTab('Absorb','mpl')\n self.Page.canvas.mpl_connect('pick_event', self.OnPick)\n self.Page.canvas.mpl_connect('button_release_event', self.OnRelease)\n self.Page.canvas.mpl_connect('motion_notify_event', self.OnMotion)\n self.Page.canvas.mpl_connect('key_press_event', self.OnKeyPress)\n newPlot = True\n self.ax = self.Page.figure.add_subplot(111,label='absorb')\n self.fplot.set_visible(False)\n self.Page.Choice = (' key press','g: toggle grid',)\n self.Page.keyPress = self.OnKeyPress \n self.ax.clear()\n self.ax.set_title('X-Ray Absorption',x=0,ha='left')\n self.ax.set_ylabel(r\"$\\mu R$\",fontsize=14)\n Ymin = 0.0\n Ymax = 0.0\n if self.FPPS: \n for Fpps in self.FPPS:\n Ymin = min(Ymin,min(Fpps[2]))\n Ymax = max(Ymax,max(Fpps[2]))\n fppsP1 = np.array(Fpps[1])\n fppsP2 = np.array(Fpps[2])\n self.ax.plot(fppsP1,fppsP2,label=r'$\\mu R$ '+Fpps[0])\n if self.ifWave: \n self.ax.set_xlabel(r'$\\mathsf{\\lambda, \\AA}$',fontsize=14)\n self.ax.axvline(x=Wave,picker=3,color='black')\n else:\n self.ax.set_xlabel(r'$\\mathsf{E, keV}$',fontsize=14)\n self.ax.set_xscale('log')\n self.ax.axvline(x=self.Kev/Wave,picker=3,color='black')\n self.ax.axhline(y=1.0,color='b')\n self.ax.axhline(y=5.0,color='r')\n self.ax.set_ylim(Ymin,Ymax)\n if self.FPPS:\n self.ax.legend(loc='best')\n if newPlot:\n newPlot = False\n self.Page.canvas.draw()\n else:\n if rePlot:\n tb = self.Page.canvas.toolbar\n tb.push_current()\n self.ax.set_xlim(xylim[0])\n self.ax.set_ylim(xylim[1])\n xylim = []\n tb.push_current()\n self.Page.canvas.draw()\n \n def OnPick(self, event):\n self.linePicked = event.artist\n \n def OnMotion(self,event):\n xpos = event.xdata\n if xpos and xpos>0.1:\n ypos = event.ydata\n if self.ifWave:\n Wave = xpos\n else:\n Wave = self.Kev/xpos\n Wave = min(max(Wave,self.Wmin),self.Wmax)\n self.parent.G2plotNB.status.SetStatusText('Wavelength: %.4f, Energy: %.3f, %sR: %.3f'%(Wave,self.Kev/Wave,Gkmu,ypos),1)\n if self.linePicked:\n self.SetWaveEnergy(Wave)\n \n def OnRelease(self, event):\n if self.linePicked is None: return\n self.linePicked = None\n xpos = event.xdata\n if xpos:\n if self.ifWave:\n Wave = xpos\n else:\n Wave = self.Kev/xpos \n self.SetWaveEnergy(Wave)\n \n def OnABOUTItems0Menu(self, event):\n ''' '''\n try:\n import wx.adv as wxadv # AboutBox moved here in Phoenix\n except:\n wxadv = wx\n info = wxadv.AboutDialogInfo()\n info.Name = 'Absorb'\n info.Copyright = '''\nRobert B. Von Dreele, 2009(C)\nArgonne National Laboratory\nThis product includes software developed \nby the UChicago Argonne, LLC, as \nOperator of Argonne National Laboratory. '''\n info.Description = '''\nFor calculating X-ray absorption factors to 250keV for cylindrical \npowder samples; based on Fortran program Fprime of Cromer & Liberman \n(D. T. Cromer and D. A. Liberman, Acta Cryst. (1981). A37, 267-268.)\ncorrected for Kissel & Pratt energy term; Jensen term not included\n '''\n wxadv.AboutBox(info)\n\n", "meta": {"hexsha": "dcf957eb5707da00eedd3d2582260535317d898f", "size": 27235, "ext": "py", "lang": "Python", "max_stars_repo_path": "Xerus/GSASII/Absorb.py", "max_stars_repo_name": "pedrobcst/Xerus", "max_stars_repo_head_hexsha": "09df088e0207176df0d20715e1c9778d09d28250", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 18, "max_stars_repo_stars_event_min_datetime": "2021-12-10T03:05:49.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-25T15:48:35.000Z", "max_issues_repo_path": "Xerus/GSASII/Absorb.py", "max_issues_repo_name": "pedrobcst/Xerus", "max_issues_repo_head_hexsha": "09df088e0207176df0d20715e1c9778d09d28250", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 14, "max_issues_repo_issues_event_min_datetime": "2022-02-24T11:09:26.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-30T07:42:17.000Z", "max_forks_repo_path": "Xerus/GSASII/Absorb.py", "max_forks_repo_name": "pedrobcst/Xerus", "max_forks_repo_head_hexsha": "09df088e0207176df0d20715e1c9778d09d28250", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-02-25T16:26:54.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-25T16:26:54.000Z", "avg_line_length": 40.4080118694, "max_line_length": 141, "alphanum_fraction": 0.5625481917, "include": true, "reason": "import numpy", "num_tokens": 7776, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5774953651858117, "lm_q2_score": 0.33111973962899144, "lm_q1q2_score": 0.19122011495727528}} {"text": "\"\"\"\nBEACON\n\"\"\"\n\nimport sys, os\nimport numpy as np\nimport libraries as lib\n\ndef parameters_generator(Filename='Options'):\n import imp\n\n options = imp.load_source(os.path.splitext(os.path.basename(Filename))[0], Filename)\n\n class galaxy:\n def __init__(self):\n self.Name = options.Galaxy_Name\n self.Sky_Coo = np.array(options.Galaxy_Coordinates)\n self.Distance = options.Galaxy_Distance\n self.RH = options.Galaxy_rh\n self.RT = options.Galaxy_rt\n self.PA = options.Galaxy_pa\n self.E = options.Galaxy_e\n self.Sky_Vel = options.Galaxy_Velocity\n \n class read_data_options:\n def __init__(self):\n self.Data_file = options.Galaxy_Data_file\n self.Clean_sample = options.Clean_sample\n self.Admisible_range_Vel = options.Admisible_range_Velocity\n self.Admisible_max_error_Vel = options.Admisible_max_error_Velocity\n self.Admisible_max_error_Extra_Coo = options.Admisible_max_error_Extra_Coo\n \n class beacon_options:\n def __init__(self):\n self.Smoothing = options.Smoothing\n self.Min_cluster_size = options.Min_cluster_size\n self.Maxima_ratio = options.Maxima_ratio\n self.Epsilon = options.Epsilon\n self.Standarization_Method = options.Standarization_Method\n self.Standarization_Weights = np.array(options.Standarization_Weights)\n self.Coordinate_system = options.Coordinate_system\n self.Velocity_system = options.Velocity_system\n self.Uniqueness_Method = options.Uniqueness_Method\n self.NStars_normed = options.NStars_normed\n \n class sref_options:\n def __init__(self):\n self.WCS = options.Galaxy_WCS\n self.Extra_Coo_is_FeH = options.Extra_Coo_is_FeH\n self.Use_elliptical_coordinates = options.Use_elliptical_coordinates\n self.Find_centre_sky_radius = options.Find_centre_sky_radius\n self.Find_centre_sky_resolution = options.Find_centre_sky_resolution\n self.Find_centre_vhel_radius = options.Find_centre_vhel_radius\n self.Find_centre_vhel_resolution = options.Find_centre_vhel_resolution\n\n class plotting_options:\n def __init__(self):\n self.Plot_maps = options.Plot_maps\n self.wcs = options.Galaxy_WCS\n self.Maps_plotting_radius = options.Maps_plotting_radius\n self.Maps_vlos_limits = options.Maps_vlos_limits\n self.Auxiliar_axes_limits = options.Auxiliar_axes_limits\n self.Draw_markers = options.Draw_markers\n self.Markers_color = options.Markers_color\n self.Markers_size = options.Markers_size\n self.Markers_linewidth = options.Markers_linewidth\n self.Plot_angular_momenta = options.Plot_angular_momenta\n self.Plot_extra_coo = options.Plot_extra_coo\n self.Plot_elliptical_radius = options.Use_elliptical_coordinates \n if options.Auxiliar_axes_label: \t\n self.Auxiliar_axes_label = options.Auxiliar_axes_label\n\n return galaxy(), read_data_options(), beacon_options(), sref_options(), plotting_options()\n \ndef stars_generator(Rest_frame_coo):\n class stars_data(object):\n def __init__(self):\n self.Sky_Coo = Rest_frame_coo[0]\n self.Gref_car_Coo = Rest_frame_coo[1]\n self.Gref_car_Vel = Rest_frame_coo[2]\n self.Gref_car_eVel = Rest_frame_coo[3]\n self.Gref_pol_Coo = Rest_frame_coo[4]\n self.Gref_pol_Vel = Rest_frame_coo[5] \n self.Gref_pol_eVel = Rest_frame_coo[6]\n try:\n self.Z = Rest_frame_coo[7]\n self.eZ = Rest_frame_coo[8]\n self.FeH = Rest_frame_coo[9]\n self.eFeH = Rest_frame_coo[10]\n except:\n pass\n try:\n self.Extra_Coo = Rest_frame_coo[7]\n self.eExtra_Coo = Rest_frame_coo[8]\n except:\n pass\n\n return stars_data\n\ndef read_data(read_data_options):\n \n Stars_data = np.loadtxt(read_data_options.Data_file, skiprows=1)\n\n try:\n Sky_Coo = Stars_data[:,0:2]\n Sky_Vel = Stars_data[:,2:7:2]\n Sky_eVel = Stars_data[:,3:8:2]\n Extra_Coo = Stars_data[:,-2:7:-2]\n Extra_eCoo = Stars_data[:,-1:7:-2]\n except:\n print 'Bad format in input table.\\n'\n print 'Format shoud be:\\n'\n print 'RA Dec VRA eVRA VDec eVDec Vlos eVlos Extra_Coo eExtra_Coo Extra_Coo_2 eExtra_Coo_2 ...'\n print 'Quitting now...'\n sys.exit(0)\n\n Sky_eVel = np.where(Sky_eVel < 1e-5, np.average(Sky_eVel), Sky_eVel)\n Extra_eCoo = np.where(Extra_eCoo < 1e-5, np.average(Extra_eCoo), Extra_eCoo)\n\n Std_stars_data = [Sky_Coo, Sky_Vel, Sky_eVel, Extra_Coo, Extra_eCoo]\n\n return Std_stars_data\n\ndef ref_frame(Std_data, galaxy, sref_options):\n\n \"\"\"\n Sky, WCS and physical coordinates\n \"\"\"\n if sref_options.WCS:\n Sky_Coo = Std_data[0]\n Gref_car_Coo = lib.wcs2xy(Sky_Coo, galaxy.Sky_Coo, galaxy.Distance)\n\n else:\n Gref_car_Coo = Std_data[0]\n Sky_Coo = lib.xy2wcs(Gref_car_Coo, galaxy.Sky_Coo, galaxy.Distance)\n\n \"\"\"\n Galactic velocity rest frame\n \"\"\"\n Gref_car_Vel = Std_data[1] - galaxy.Sky_Vel\n Gref_car_eVel = Std_data[2]\n\n if sref_options.Use_elliptical_coordinates:\n Gref_car_Coo = lib.deproject_ellip(Gref_car_Coo, Ellipticity = galaxy.E, PA = galaxy.PA)\n try:\n Gref_car_Vel[:,0:2] = lib.deproject_ellip(Gref_car_Vel[:,0:2], Ellipticity = galaxy.E, PA = galaxy.PA)\n Gref_car_eVel[:,0:2] = lib.deproject_ellip(Gref_car_eVel[:,0:2], Ellipticity = galaxy.E, PA = galaxy.PA)\n except:\n pass\n \"\"\"\n Galactic elliptical coordinates\n \"\"\"\n Gref_pol_Coo = lib.polar_coo(Gref_car_Coo)\n Gref_pol_Vel = lib.polar_vel(Gref_car_Coo, Gref_car_Vel)\n Gref_pol_eVel = np.abs(lib.polar_vel(Gref_car_Coo, Gref_car_eVel))\n \n print 'Right now beacon accepts either FeH and eFeH, or whatever linear coordinates user may provide, but NOT both (FeH and linear coordinates) at the same time!'\n try:\n Extra_Coo, Extra_eCoo = Std_data[3], Std_data[4]\n if sref_options.Extra_Coo_is_FeH:\n Z, eZ = lib.log2lin_metal(Extra_Coo, Extra_eCoo)\n FeH, eFeH = Extra_Coo, Extra_eCoo\n Rest_frame_coo = [Sky_Coo, Gref_car_Coo, Gref_car_Vel, Gref_car_eVel, Gref_pol_Coo, Gref_pol_Vel, Gref_pol_eVel, Z, eZ, FeH, eFeH]\n else:\n Rest_frame_coo = [Sky_Coo, Gref_car_Coo, Gref_car_Vel, Gref_car_eVel, Gref_pol_Coo, Gref_pol_Vel, Gref_pol_eVel, Extra_Coo, Extra_eCoo]\n except:\n Rest_frame_coo = [Sky_Coo, Gref_car_Coo, Gref_car_Vel, Gref_car_eVel, Gref_pol_Coo, Gref_pol_Vel, Gref_pol_eVel]\n\n Stars_data_rf = stars_generator(Rest_frame_coo)\n \n return Stars_data_rf()\n\ndef rest_frame_generator(galaxy, read_data_options, sref_options):\n \n if (sref_options.Find_centre_sky_radius != 0) and (sref_options.Find_centre_vhel_radius !=0):\n Find_centre_coordinates_list = np.mgrid[galaxy.Sky_Coo[0]-sref_options.Find_centre_sky_radius/60. : galaxy.Sky_Coo[0]+sref_options.Find_centre_sky_radius/60. : sref_options.Find_centre_sky_resolution/60., galaxy.Sky_Coo[1]-sref_options.Find_centre_sky_radius/60. : galaxy.Sky_Coo[1]+sref_options.Find_centre_sky_radius/60. : sref_options.Find_centre_sky_resolution/60., galaxy.Sky_Vel-sref_options.Find_centre_vhel_radius : galaxy.Sky_Vel+sref_options.Find_centre_vhel_radius: sref_options.Find_centre_vhel_resolution]\n \n Find_centre_RA_sky_coordinates_List = Find_centre_coordinates_list[0].flatten()\n Find_centre_Dec_sky_coordinates_List = Find_centre_coordinates_list[1].flatten()\n Find_centre_Vhel_sky_coordinates_List = Find_centre_coordinates_list[2].flatten()\n Dimensions = np.shape(Find_centre_coordinates_list[0])\n \n elif (sref_options.Find_centre_sky_radius != 0) and (sref_options.Find_centre_vhel_radius == 0):\n Sky_coo_list = np.mgrid[galaxy.Sky_Coo[0]-sref_options.Find_centre_sky_radius/60. : galaxy.Sky_Coo[0]+sref_options.Find_centre_sky_radius/60. : sref_options.Find_centre_sky_resolution/60., galaxy.Sky_Coo[1]-sref_options.Find_centre_sky_radius/60. : galaxy.Sky_Coo[1]+sref_options.Find_centre_sky_radius/60. : sref_options.Find_centre_sky_resolution/60.]\n \n Find_centre_RA_sky_coordinates_List = Sky_coo_list[0].flatten()\n Find_centre_Dec_sky_coordinates_List = Sky_coo_list[1].flatten()\n Find_centre_Vhel_sky_coordinates_List = np.ones(len(Sky_coo_list[0].flatten()))*galaxy.Sky_Vel\n Dimensions = np.shape(Sky_coo_list[0])\n \n elif (sref_options.Find_centre_sky_radius == 0) and (sref_options.Find_centre_vhel_radius != 0): \n Find_centre_RA_sky_coordinates_List = np.ones(len(Vhel_coo_list))*galaxy.Sky_Coo[0]\n Find_centre_Dec_sky_coordinates_List = np.ones(len(Vhel_coo_list))*galaxy.Sky_Coo[1]\n Find_centre_Vhel_sky_coordinates_List = np.arange(galaxy.Sky_Vel-sref_options.Find_centre_vhel_radius, galaxy.Sky_Vel+sref_options.Find_centre_vhel_radius, sref_options.Find_centre_vhel_resolution)\n Dimensions = 1\n\n else:\n Find_centre_RA_sky_coordinates_List = [galaxy.Sky_Coo[0]]\n Find_centre_Dec_sky_coordinates_List = [galaxy.Sky_Coo[1]]\n Find_centre_Vhel_sky_coordinates_List = [galaxy.Sky_Vel]\n Dimensions = 0\n \n Std_data = read_data(read_data_options)\n \n Stars_data_lis = []\n \n for Find_centre_RA_sky_coordinates, Find_centre_Dec_sky_coordinates, Find_centre_Vhel_coordinates in zip(Find_centre_RA_sky_coordinates_List, Find_centre_Dec_sky_coordinates_List, Find_centre_Vhel_sky_coordinates_List):\n \n galaxy.Sky_Coo = np.array([Find_centre_RA_sky_coordinates, Find_centre_Dec_sky_coordinates])\n galaxy.Sky_Vel = np.array([Find_centre_Vhel_coordinates])\n \n Stars_data_lis.append(ref_frame(Std_data, galaxy, sref_options))\n \n return Stars_data_lis, Find_centre_RA_sky_coordinates_List, Find_centre_Dec_sky_coordinates_List, Find_centre_Vhel_sky_coordinates_List, Dimensions\n\ndef autoorder(Possible_Circular_Stream_Indices, Possible_NonCircular_Stream_Indices, stars_data):\n\n try:\n OV = stars_data.Z\n except:\n OV = stars_data.Extra_Coo\n \n Possible_Circular_Stream_Mean_OV = []\n for Circ_Index in Possible_Circular_Stream_Indices:\n Possible_Circular_Stream_Mean_OV.append(np.mean(OV[list(Circ_Index)]))\n\n Possible_NonCircular_Stream_Mean_OV = []\n for NonCirc_Index in Possible_NonCircular_Stream_Indices:\n Possible_NonCircular_Stream_Mean_OV.append(np.mean(OV[list(NonCirc_Index)])) \n \n \"\"\"\n Order Results By OV\n \"\"\"\n Possible_Circular_Stream_Sorted_Indices = sorted(range(len(Possible_Circular_Stream_Mean_OV)), key=lambda k: Possible_Circular_Stream_Mean_OV[k])\n Possible_NonCircular_Stream_Sorted_Indices = sorted(range(len(Possible_NonCircular_Stream_Mean_OV)), key=lambda k: Possible_NonCircular_Stream_Mean_OV[k])\n\n Possible_Circular_Stream_Indices = [Possible_Circular_Stream_Indices[i] for i in Possible_Circular_Stream_Sorted_Indices]\n\n Possible_NonCircular_Stream_Indices = [Possible_NonCircular_Stream_Indices[i] for i in Possible_NonCircular_Stream_Sorted_Indices]\n\n return Possible_Circular_Stream_Indices, Possible_NonCircular_Stream_Indices\n \ndef beacon(Rest_frame_coo, beacon_options):\n\n \"\"\"\n This routine will call OPTICS with an apropiate set of coordinates. \n Tipically coordinates, velocities, and chemical abundances\n \"\"\"\n\n if (beacon_options.Coordinate_system == 'pol'):\n \"\"\"\n Coo are the coordinates of the stars. The angle (Theta), must be inverted, but not the radius\n \"\"\"\n Coo = Rest_frame_coo.Gref_pol_Coo\n Simmet_Coo = np.array([Rest_frame_coo.Gref_pol_Coo[:,0], (Rest_frame_coo.Gref_pol_Coo[:,1]+np.pi) % (2.*np.pi)]).T\n \n if (beacon_options.Velocity_system == 'pol'):\n \"\"\"\n Polar velocities are expected to be the same at both sides of\n the CM, except for the line-of-sight (z) component, that shoud be inverted.\n \"\"\"\n Vel = Rest_frame_coo.Gref_pol_Vel\n Simmet_Vel = np.array([Vel[:,0], Vel[:,1], -1.*Vel[:,2]]).T\n\n if (beacon_options.Coordinate_system == 'car'):\n \"\"\"\n If one prefers cartesian coordinates, then both have to be inverted\n \"\"\"\n Coo = Rest_frame_coo.Gref_car_Coo\n Simmet_Coo = np.array([(-Rest_frame_coo.Gref_car_Coo[:,0]), -Rest_frame_coo.Gref_car_Coo[:,1]]).T\n\n if (beacon_options.Velocity_system == 'car'):\n \"\"\"\n All cartesian components of the velocity are expected to be the\n oposite at the other side of the CM.\n \"\"\"\n Vel = Rest_frame_coo.Gref_car_Vel\n Simmet_Vel = -1.*Vel \n\n \"\"\"\n Extra properties should be consistently equal at both sides of the CM (In case they exist)\n \"\"\"\n try:\n Extra = Rest_frame_coo.Z\n except:\n pass\n try:\n Extra = Rest_frame_coo.Extra_Coo\n except:\n pass\n try:\n if Extra.ndim == 1:\n Extra = np.expand_dims(Extra, axis=1)\n\n Direct_Clustering_Data = np.hstack([Coo, Vel, Extra])\n Simmet_Clustering_Data = np.hstack([Simmet_Coo, Simmet_Vel, Extra])\n except:\n Direct_Clustering_Data = np.hstack([Coo, Vel])\n Simmet_Clustering_Data = np.hstack([Simmet_Coo, Simmet_Vel])\n\n OAL = len(Direct_Clustering_Data) # Original Array Length\n\n \"\"\"\n If the only coordinates being used are v_rot and v_rad then don't use the simmetric vector\n \"\"\"\n if (beacon_options.Velocity_system == 'pol') & (beacon_options.Standarization_Weights[4] == 0):\n Clustering_Data = Direct_Clustering_Data\n mcs = beacon_options.Min_cluster_size\n else:\n Clustering_Data = np.vstack([Direct_Clustering_Data, Simmet_Clustering_Data])\n mcs = float(beacon_options.Min_cluster_size)*2.\n\n if not Clustering_Data.size:\n print 'No stars remain after cleaning, check option file!'\n quit()\n \"\"\"\n Standardization\n \"\"\"\n if beacon_options.Standarization_Method == 'ptp':\n Clustering_Data /= np.ptp(Direct_Clustering_Data, axis=0)\n elif beacon_options.Standarization_Method == 'std':\n Clustering_Data /= np.std(Direct_Clustering_Data, axis=0)\n elif beacon_options.Standarization_Method == 'var':\n Clustering_Data /= np.var(Direct_Clustering_Data, axis=0)\n\n else:\n print \"Non standarization was applied!\"\n \n try:\n Clustering_Data *= beacon_options.Standarization_Weights\n except:\n print \"Incorrect dimension of weights. Same weight applied to all coordinates.\"\n \n Clustering_Data = Clustering_Data[:,np.where(beacon_options.Standarization_Weights != 0)[0]]\n\n \"\"\"\n OPTICS call\n \"\"\"\n Indices = optics_launcher(Clustering_Data, beacon_options.Smoothing, min_cluster_size = mcs, maxima_ratio = beacon_options.Maxima_ratio)\n \n Possible_Circular_Stream_Indices = []\n Possible_NonCircular_Stream_Indices = []\n for ii, Index in enumerate(Indices):\n if (sum(1 for i in Index if i >= OAL) > len(Index)/beacon_options.Epsilon) & (sum(1 for i in Index if i < OAL) > len(Index)/beacon_options.Epsilon):\n Possible_Circular_Stream = True\n Possible_Nonirc_streams = False\n elif ((Index < OAL).all()) or ((Index >= OAL).all()):\n Possible_Circular_Stream = False\n Possible_Nonirc_streams = True\n else:\n Possible_Circular_Stream = False\n Possible_Nonirc_streams = False \n Index[Index >= OAL] -= OAL\n if Possible_Circular_Stream:\n Possible_Circular_Stream_Indices.append(set(Index))\n elif Possible_Nonirc_streams:\n Possible_NonCircular_Stream_Indices.append(set(Index))\n \n \"\"\"\n Uniqueness of the groups\n \"\"\"\n if beacon_options.Uniqueness_Method == 'all': \n Possible_Circular_Stream_Indices = [list(i) for i in set(tuple(i) for i in Possible_Circular_Stream_Indices)]\n Possible_NonCircular_Stream_Indices = [list(i) for i in set(tuple(i) for i in Possible_NonCircular_Stream_Indices)]\n \n if beacon_options.Uniqueness_Method == 'any':\n from networkx.algorithms.components.connected import connected_components\n Possible_Circular_Stream_Indices = list(connected_components(lib.to_graph(Possible_Circular_Stream_Indices)))\n Possible_NonCircular_Stream_Indices = list(connected_components(lib.to_graph(Possible_NonCircular_Stream_Indices)))\n \n \"\"\"\n If there are many groups, exit program\n \"\"\"\n if (len(Possible_Circular_Stream_Indices) > 1000) or (len(Possible_NonCircular_Stream_Indices) > 1000):\n print 'To many groups: ',len(Possible_Circular_Stream_Indices),' aborting to prevent computer failure...'\n sys.exit(0)\n\n return Possible_Circular_Stream_Indices, Possible_NonCircular_Stream_Indices \n\n\ndef useful_quantities(stars_data, galaxy, sref_options, Indices_list=None):\n \"\"\"\n This routine calculates some useful quantities for plotting and arranging results\n \"\"\"\n if Indices_list is None:\n Indices_list = [list(np.arange(len(stars_data.Gref_car_Coo)))]\n\n \"\"\"\n Averages must be derived using linear quantities\n \"\"\"\n N_Stars = []\n Velocities_stars = []\n Extra_Coo_stars = []\n Radius_stars = []\n \n Velocity_groups = []\n Extra_Coo_groups = []\n Radius_groups = []\n Angular_Momenta_groups = []\n\n print 'WARNING: Projected angular momentum (line-of-sight velocities) with no error!'\n\n for ii, Indices in enumerate(Indices_list):\n Indices = list(Indices)\n \"\"\"\n Angular Momentum\n \"\"\"\n L_k = lib.kinetic_pa(stars_data.Gref_car_Coo[Indices, :], stars_data.Gref_car_Vel[Indices, 2], 1./stars_data.Gref_car_eVel[Indices, 2])\n\n kl = lib.kinetic_pa(stars_data.Gref_car_Coo[Indices, :], stars_data.Gref_car_Vel[Indices, 2], 1./stars_data.Gref_car_eVel[Indices, 2])\n if sref_options.Use_elliptical_coordinates:\n kl[0:2] = lib.deproject_ellip(kl[0:2], Ellipticity = 1./(1.-1./galaxy.E), PA = galaxy.PA)\n\n Angular_Momenta_groups.append(kl)\n\n try:\n Extra_Coo_stars.append([stars_data.FeH[Indices], stars_data.eFeH[Indices]])\n\n Avg_Std_Z = lib.avg_std(stars_data.Z[Indices], 1./(stars_data.eZ[Indices])**2)\n\n Extra_Coo_groups.append(lib.lin2log_metal(Avg_Std_Z[0], Avg_Std_Z[1]))\n except:\n pass\n try:\n Extra_Coo_stars.append([stars_data.Extra_Coo[Indices], stars_data.Extra_eCoo[Indices]])\n \n Extra_Coo_groups.append(lib.avg_std(stars_data.Extra_Coo[Indices], 1./(stars_data.Extra_eCoo[Indices])**2))\n except:\n pass\n\n\n N_Stars.append(len(Indices))\n Velocities_stars.append([stars_data.Gref_car_Vel[Indices],stars_data.Gref_car_eVel[Indices]])\n \n Radius_stars.append(np.sqrt(np.sum(stars_data.Gref_car_Coo[Indices, :]**2, axis = 1)))\n \n Velocity_groups.append(lib.avg_std((stars_data.Gref_car_Coo[Indices]), 1./(stars_data.Gref_car_Coo[Indices])**2))\n\n Radius_groups.append(np.average(np.sqrt(np.sum(stars_data.Gref_car_Coo[Indices, :]**2, axis = 1))))\n\n \"\"\"\n CONVERTING LISTS TO ARRAYS\n \"\"\"\n N_Stars = np.array(N_Stars)\n Angular_Momenta_groups = np.array(Angular_Momenta_groups)\n\n Radius_stars = np.array(Radius_stars)\n Velocity_groups = np.array(Velocity_groups)\n\n \"\"\"\n These quantities may be optional\n \"\"\"\n Extra_Coo_stars = np.array(Extra_Coo_stars) \n Extra_Coo_groups = np.array(Extra_Coo_groups)\n \n\n Mean_quantities = [Extra_Coo_groups, Velocity_groups, Radius_groups, Angular_Momenta_groups]\n Raw_quantities = [N_Stars, Extra_Coo_stars, Velocities_stars, Radius_stars]\n\n return Raw_quantities, Mean_quantities\n\ndef save_clusters(Circ_mean_quantities, File_name = 'Output/Clusters.dat'):\n Circ_Mean_Metallicity, Circ_Mean_Velocity, Circ_Mean_rDistance, Circ_KL = Circ_mean_quantities\n\n np.savetxt(File_name, np.array([np.arange(len(Circ_Mean_Metallicity))+1, Circ_Mean_Metallicity[:,0], Circ_Mean_Metallicity[:,1], Circ_KL[:,0], Circ_KL[:,1]]).T, fmt='%i %.3f %.3f %.3f %.3f', header='Pop Metal eMetal L_angle L_modulus')\n\ndef save_clustered_stars(stars_data, Stream_Indices, File_name = 'Output/Stars.dat'):\n Circ_clustered_stars = []\n for kk, Indices in enumerate(Stream_Indices):\n Indices = list(Indices)\n\n Cluster = np.array([np.array(Indices)+1., stars_data.Sky_Coo[Indices,0], stars_data.Sky_Coo[Indices,1], stars_data.Gref_car_Vel[Indices,2], stars_data.Gref_car_eVel[Indices,2], np.squeeze(stars_data.FeH[Indices]), np.squeeze(stars_data.eFeH[Indices]), np.ones(len(stars_data.FeH[Indices]))*(kk+1)]).T\n\n Circ_clustered_stars.append(Cluster)\n Circ_clustered_stars = np.array([item for sublist in Circ_clustered_stars for item in sublist])\n\n np.savetxt(File_name, Circ_clustered_stars, fmt='%i %.8f %.8f %.3f %.3f %.3f %.3f %i', header='Indices RA DEC V_los eV_los Metal eMetal Pop')\n\n\ndef optics_launcher(Data, Smoothing, min_cluster_size = 5., maxima_ratio = 0.75):\n import optics_core as core\n\n RD, CD, Order = core.optics(Data,Smoothing)\n\n Reach_Plot = []\n Reach_Points = []\n\n for item in Order:\n Reach_Plot.append(RD[item])\n Reach_Points.append(Data[item])\n\n min_cluster_size_ratio = min_cluster_size / float(len(Data))\n\n rootNode = core.auto_cluster(Reach_Plot, Reach_Points, min_cluster_size_ratio, maxima_ratio)\n\n #get only the leaves of the tree\n leaves = core.get_leaves(rootNode, [])\n\n index_ordered = []\n for item in leaves:\n index_ordered.append(np.array(Order[item.start:item.end]))\n return index_ordered\n\n\n\"\"\"\nAndres del Pino Molina\n\"\"\"\n", "meta": {"hexsha": "8fe0333f43c50ef112da5211dcbe25765a7aecde", "size": 22062, "ext": "py", "lang": "Python", "max_stars_repo_path": "beacon.py", "max_stars_repo_name": "AndresdPM/BEACON", "max_stars_repo_head_hexsha": "f0206fb67ae900e676b0f4476b7274ee7a6adfc9", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "beacon.py", "max_issues_repo_name": "AndresdPM/BEACON", "max_issues_repo_head_hexsha": "f0206fb67ae900e676b0f4476b7274ee7a6adfc9", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "beacon.py", "max_forks_repo_name": "AndresdPM/BEACON", "max_forks_repo_head_hexsha": "f0206fb67ae900e676b0f4476b7274ee7a6adfc9", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.4291338583, "max_line_length": 528, "alphanum_fraction": 0.6980328166, "include": true, "reason": "import numpy,from networkx", "num_tokens": 5866, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5774953651858117, "lm_q2_score": 0.3311197264277872, "lm_q1q2_score": 0.19122010733364103}} {"text": "import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport numpy as np\n\nfrom .module import *\n\nAlign_Corners_Range = False\n\n\nclass DepthNet(nn.Module):\n def __init__(self, mode=\"regression\"):\n super(DepthNet, self).__init__()\n self.mode = mode\n assert self.mode in (\"regression\", \"classification\", \"unification\"), \"Don't support {}!\".format(mode)\n\n def forward(self, cost_reg, depth_values, num_depth, interval, prob_volume_init=None):\n prob_volume_pre = cost_reg.squeeze(1) # (b, d, h, w)\n\n if prob_volume_init is not None:\n prob_volume_pre += prob_volume_init\n\n if self.mode == \"regression\":\n prob_volume = F.softmax(prob_volume_pre, dim=1) # (b, ndepth, h, w)\n depth = depth_regression(prob_volume, depth_values=depth_values) # (b, h, w)\n with torch.no_grad():\n # photometric confidence\n prob_volume_sum4 = 4 * F.avg_pool3d(F.pad(prob_volume.unsqueeze(1), pad=(0, 0, 0, 0, 1, 2)), (4, 1, 1), stride=1,\n padding=0).squeeze(1)\n depth_index = depth_regression(prob_volume,\n depth_values=torch.arange(num_depth, device=prob_volume.device, dtype=torch.float)).long()\n depth_index = depth_index.clamp(min=0, max=num_depth - 1)\n photometric_confidence = torch.gather(prob_volume_sum4, 1, depth_index.unsqueeze(1)).squeeze(1)\n elif self.mode == \"classification\":\n prob_volume = F.softmax(prob_volume_pre, dim=1) # (b, ndepth, h, w)\n depth = winner_take_all(prob_volume, depth_values) # (b, h, w)\n photometric_confidence, _ = torch.max(prob_volume, dim=1)\n elif self.mode == \"unification\":\n prob_volume = torch.sigmoid(prob_volume_pre) # (b, ndepth, h, w)\n depth = unity_regression(prob_volume, depth_values, interval)\n photometric_confidence, _ = torch.max(F.softmax(prob_volume_pre, dim=1), dim=1)\n # photometric_confidence = torch.max(prob_volume, dim=1)[0] / torch.sum(prob_volume, dim=1)\n else:\n raise NotImplementedError(\"Don't support {}!\".format(self.mode))\n\n return {\"depth\": depth, \"photometric_confidence\": photometric_confidence, \"prob_volume\": prob_volume,\n \"depth_values\": depth_values, \"interval\": interval}\n\n\nclass CostAgg(nn.Module):\n def __init__(self, mode=\"variance\", in_channels=None):\n super(CostAgg, self).__init__()\n self.mode = mode\n assert mode in (\"variance\", \"adaptive\"), \"Don't support {}!\".format(mode)\n if self.mode == \"adaptive\":\n self.weight_net = nn.ModuleList([AggWeightNetVolume(in_channels[i]) for i in range(len(in_channels))])\n\n def forward(self, features, proj_matrices, depth_values, stage_idx):\n \"\"\"\n :param stage_idx: stage\n :param features: [ref_fea, src_fea1, src_fea2, ...], fea shape: (b, c, h, w)\n :param proj_matrices: (b, nview, ...) [ref_proj, src_proj1, src_proj2, ...]\n :param depth_values: (b, ndepth, h, w)\n :return: matching cost volume (b, c, ndepth, h, w)\n \"\"\"\n ref_feature, src_features = features[0], features[1:]\n proj_matrices = torch.unbind(proj_matrices, 1) # to list\n ref_proj, src_projs = proj_matrices[0], proj_matrices[1:]\n\n num_views = len(features)\n num_depth = depth_values.shape[1]\n\n ref_volume = ref_feature.unsqueeze(2).repeat(1, 1, num_depth, 1, 1)\n if self.mode == \"variance\":\n volume_sum = ref_volume\n volume_sq_sum = ref_volume ** 2\n del ref_volume\n elif self.mode == \"adaptive\":\n volume_adapt = None\n\n for src_fea, src_proj in zip(src_features, src_projs):\n # warpped features\n src_proj_new = src_proj[:, 0].clone()\n src_proj_new[:, :3, :4] = torch.matmul(src_proj[:, 1, :3, :3], src_proj[:, 0, :3, :4])\n ref_proj_new = ref_proj[:, 0].clone()\n ref_proj_new[:, :3, :4] = torch.matmul(ref_proj[:, 1, :3, :3], ref_proj[:, 0, :3, :4])\n warped_volume = homo_warping(src_fea, src_proj_new, ref_proj_new, depth_values)\n\n if self.mode == \"variance\":\n volume_sum = volume_sum + warped_volume\n volume_sq_sum = volume_sq_sum + warped_volume ** 2\n elif self.mode == \"adaptive\":\n # (b, c, d, h, w)\n warped_volume = (ref_volume - warped_volume).pow_(2)\n weight = self.weight_net[stage_idx](warped_volume)\n if volume_adapt is None:\n volume_adapt = (weight + 1) * warped_volume\n else:\n volume_adapt = volume_adapt + (weight + 1) * warped_volume\n\n del warped_volume\n\n # aggregate multiple feature volumes by variance\n if self.mode == \"variance\":\n volume_variance = volume_sq_sum.div_(num_views).sub_(volume_sum.div_(num_views).pow_(2))\n return volume_variance\n elif self.mode == \"adaptive\":\n return volume_adapt / (num_views - 1)\n\n\nclass MVSNet(nn.Module):\n def __init__(self, ndepths, depth_interval_ratio, cr_base_chs=None, fea_mode=\"fpn\", agg_mode=\"variance\", depth_mode=\"regression\"):\n super(MVSNet, self).__init__()\n\n if cr_base_chs is None:\n cr_base_chs = [8] * len(ndepths)\n self.ndepths = ndepths\n self.depth_interval_ratio = depth_interval_ratio\n self.fea_mode = fea_mode\n self.cr_base_chs = cr_base_chs\n self.num_stage = len(ndepths)\n\n print(\"netphs:\", ndepths)\n print(\"depth_intervals_ratio:\", depth_interval_ratio)\n print(\"cr_base_chs:\", cr_base_chs)\n print(\"fea_mode:\", fea_mode)\n print(\"agg_mode:\", agg_mode)\n print(\"depth_mode:\", depth_mode)\n\n assert len(ndepths) == len(depth_interval_ratio)\n\n self.feature = FeatureNet(base_channels=8, stride=4, num_stage=self.num_stage, mode=self.fea_mode)\n self.cost_aggregation = CostAgg(agg_mode, self.feature.out_channels)\n\n self.cost_regularization = nn.ModuleList(\n [CostRegNet(in_channels=self.feature.out_channels[i], base_channels=self.cr_base_chs[i]) for i in range(self.num_stage)])\n\n self.DepthNet = DepthNet(depth_mode)\n\n def forward(self, imgs, proj_matrices, depth_values):\n \"\"\"\n :param is_flip: augment only for 3D-UNet\n :param imgs: (b, nview, c, h, w)\n :param proj_matrices:\n :param depth_values:\n :return:\n \"\"\"\n depth_interval = (depth_values[0, -1] - depth_values[0, 0]) / depth_values.size(1)\n\n # step 1. feature extraction\n features = []\n for nview_idx in range(imgs.size(1)): # imgs shape (B, N, C, H, W)\n img = imgs[:, nview_idx]\n features.append(self.feature(img))\n\n ori_shape = imgs[:, 0].shape[2:] # (H, W)\n\n outputs = {}\n last_depth = None\n for stage_idx in range(self.num_stage):\n # print(\"*********************stage{}*********************\".format(stage_idx + 1))\n # stage feature, proj_mats, scales\n features_stage = [feat[\"stage{}\".format(stage_idx + 1)] for feat in features]\n proj_matrices_stage = proj_matrices[\"stage{}\".format(stage_idx + 1)]\n # stage1: 1/4, stage2: 1/2, stage3: 1\n stage_scale = 2 ** (3 - stage_idx - 1)\n\n stage_shape = [ori_shape[0] // int(stage_scale), ori_shape[1] // int(stage_scale)]\n\n if stage_idx == 0:\n last_depth = depth_values\n else:\n last_depth = last_depth.detach()\n\n # (B, D, H, W)\n depth_range_samples, interval = get_depth_range_samples(last_depth=last_depth,\n ndepth=self.ndepths[stage_idx],\n depth_inteval_pixel=self.depth_interval_ratio[\n stage_idx] * depth_interval,\n shape=stage_shape # only for first stage\n )\n\n if stage_idx > 0:\n depth_range_samples = F.interpolate(depth_range_samples, stage_shape, mode='bilinear', align_corners=Align_Corners_Range)\n\n # (b, c, d, h, w)\n cost_volume = self.cost_aggregation(features_stage, proj_matrices_stage, depth_range_samples, stage_idx)\n # cost volume regularization\n # (b, 1, d, h, w)\n cost_reg = self.cost_regularization[stage_idx](cost_volume)\n\n # depth\n outputs_stage = self.DepthNet(cost_reg, depth_range_samples, num_depth=self.ndepths[stage_idx], interval=interval)\n\n last_depth = outputs_stage['depth']\n\n outputs[\"stage{}\".format(stage_idx + 1)] = outputs_stage\n outputs.update(outputs_stage)\n\n return outputs\n", "meta": {"hexsha": "46ba0b06354ee1c63842cdd0c6c94d51dd1af738", "size": 9193, "ext": "py", "lang": "Python", "max_stars_repo_path": "networks/mvsnet.py", "max_stars_repo_name": "prstrive/UniMVSNet", "max_stars_repo_head_hexsha": "7c1c9862cc6f2eb0b74c0569d58826d9416195b5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 75, "max_stars_repo_stars_event_min_datetime": "2022-01-06T05:23:00.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T09:14:29.000Z", "max_issues_repo_path": "networks/mvsnet.py", "max_issues_repo_name": "prstrive/UniMVSNet", "max_issues_repo_head_hexsha": "7c1c9862cc6f2eb0b74c0569d58826d9416195b5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2022-02-15T03:19:04.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T04:42:39.000Z", "max_forks_repo_path": "networks/mvsnet.py", "max_forks_repo_name": "prstrive/UniMVSNet", "max_forks_repo_head_hexsha": "7c1c9862cc6f2eb0b74c0569d58826d9416195b5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2022-03-11T11:45:12.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-30T02:43:39.000Z", "avg_line_length": 45.736318408, "max_line_length": 137, "alphanum_fraction": 0.5820733167, "include": true, "reason": "import numpy", "num_tokens": 2200, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5428632979641571, "lm_q2_score": 0.35220178204788966, "lm_q1q2_score": 0.19119742095137066}} {"text": "# Copyright (c) 2018 Patricio Cubillos and contributors.\n# eclipse is open-source software under the MIT license (see LICENSE).\n\n__all__ = [\"eclipse\", \"mandelecl\"]\n\n\nimport os\nimport sys\nimport numpy as np\n\nlibdir = os.path.realpath(os.path.dirname(__file__) + \"/lib\")\nsys.path.append(libdir)\nimport _eclipse as ecl\n\n\nclass Ecl(object):\n \"\"\"\n Eclipse-model superclass.\n \"\"\"\n def __init__(self, time=None, mask=None, params=None):\n self.type = \"astro\"\n self.npars = len(self.pnames)\n self.params = np.zeros(self.npars)\n if params is not None:\n self.params[:] = params\n self.pmin = np.tile(-np.inf, self.npars)\n self.pmax = np.tile( np.inf, self.npars)\n self.pstep = np.zeros(self.npars)\n if time is not None:\n self.setup(time)\n\n\n def __call__(self, params, time=None, mask=None, update=False):\n \"\"\"\n Call function using self values as defaults.\n\n Parameters\n ----------\n params: 1D float ndarray\n Model parameters (see class docstring for details).\n time: 1D float ndarray\n Phase/times where to evaluate the model.\n mask: 1D bool ndarray\n Times good-value mask.\n update: Bool\n If True, updated the object's attributes.\n \"\"\"\n if update:\n self.setup(time, mask, params)\n\n if time is None:\n time = self.time\n\n if mask is not None:\n return self.eval(params, time[mask])\n elif self.mask is not None:\n return self.eval(params, time[self.mask])\n\n return self.eval(params, time)\n\n\n def setup(self, time=None, mask=None, params=None, obj=None):\n \"\"\"\n Set the model's attributes (when not None).\n\n Parameters\n ----------\n time: 1D float ndarray\n Phase/times where to evaluate the model.\n mask: 1D bool ndarray\n Times good-value mask.\n params: 1D float ndarray\n Model parameters.\n obj: An object\n If not None, extract the time and mask values from the\n object's attributes.\n \"\"\"\n if obj is not None:\n time = obj.time\n if mask is None: # Input mask takes priority over obj.mask\n mask = obj.mask\n # FINDME: do I want params?\n\n # Independent variables:\n if time is not None:\n if mask is None:\n mask = np.ones(len(time), bool)\n self.time = time\n self.mask = mask\n # Model parameters:\n if params is not None:\n self.params[:] = params\n\n\nclass eclipse(Ecl):\n \"\"\"\n A secondary-eclipse model for the times of the Webb.\n\n This class implements a Mandel & Agol eclipse model with independent\n ingress and egress depths, and the out-of-eclipse flux as a second-\n degree polynomial.\n\n This model has nine parameters (self.params, see also self.pnames):\n - midpt: Mid-eclipse epoch.\n - width: Eclipse duration between first and fourth contacts (T14).\n - idepth: Normalized eclipse depth at ingress (T1) relative to a\n stellar flux of 1.0. That is,\n idepth = (flux(T1) - flux(T2))/flux(T2).\n - edepth: Normalized eclipse depth at egress (T4) relative to a\n stellar flux of 1.0. That is,\n edepth = (flux(T4) - flux(T3))/flux(T3).\n - ting: Ingress duration (time between first and second contacts, T12).\n - tegr: Egress duration (time between third and fourth contacts, T34).\n - flux: Stellar flux level. That is, flux during eclipse:\n flux = flux(T2) = flux(T3).\n - slope: Out-of-eclipse linear slope.\n - quad: Out-of-eclipse quadratic term slope.\n\n The time units are arbitrary, and thus, a user's choice. Note that\n midpt, width, ting, terg, and time must have consistent units.\n\n Attributes\n ----------\n name: String\n The model's name.\n type: String\n The type of model.\n pnames: 1D string list\n Names of the model parameters.\n npars: Integer\n The number of model parameters.\n params: 1D float ndarray\n The model parameter values.\n pmin: 1D float ndarray\n Minimum-value boundary of the parameters (for MCMCs).\n pmax: 1D float ndarray\n Maximum-value boundary of the parameters (for MCMCs).\n pstep: 1D float ndarray\n Parameter stepsize (for MCMCs).\n time: 1D float ndarray\n The model's independent variable (timestamps where to evaluate).\n mask: 1D bool ndarray\n Time good-value mask.\n\n Example\n -------\n >>> import sys\n >>> import numpy as np\n >>> import matplotlib.pyplot as plt\n\n >>> sys.path.append(\"../eclipse\")\n >>> import eclipse as ecl\n\n >>> # Create an eclipse model with given orbital-phase timestamps:\n >>> phase = np.linspace(0.35, 0.65, 300)\n >>> model = ecl.eclipse(time=phase)\n >>> # Define eclipse parameters:\n >>> # [midpt width idepth edepth ting tegr flux slope quad]\n >>> params = np.array([0.5, 0.1, 0.01, 0.008, 0.01, 0.01, 1.0, -0.02, -0.03])\n >>> # One can call the eval function:\n >>> eclipse1 = model.eval(params, phase)\n >>> # Or directly call the object (no need to pass the phase):\n >>> params[8] = 0.0 # Linear-slope model\n >>> eclipse2 = model(params)\n\n >>> # Show results:\n >>> plt.figure(0)\n >>> plt.clf()\n >>> plt.plot(phase, eclipse1, \".-\", color='b')\n >>> plt.plot(phase, eclipse2, \".-\", color='orange')\n >>> plt.xlim(0.34, 0.66)\n >>> plt.ylim(0.999, 1.013)\n >>> plt.xlabel(\"Orbital phase\")\n >>> plt.ylabel(\"Flux\")\n \"\"\"\n def __init__(self, time=None, mask=None, params=None):\n \"\"\"\n Class constructor.\n\n Parameters\n ----------\n time: 1D float ndarray\n Phase/times where to evaluate the model.\n mask: 1D bool ndarray\n Times good-value mask.\n params: 1D float ndarray\n Model parameters (see class docstring for details).\n \"\"\"\n self.name = \"eclipse\"\n self.pnames = [\"midpt\", \"width\", \"idepth\", \"edepth\", \"ting\", \"tegr\",\n \"flux\", \"slope\", \"quad\"]\n super(eclipse, self).__init__(time, mask, params)\n # Update pmin:\n self.pmin = np.array([-np.inf, 0, 0, 0, 0, 0, 0, -np.inf, -np.inf])\n\n\n def eval(self, params, time):\n \"\"\"\n Evaluate the eclipse function at the specified times.\n\n Parameters\n ----------\n params: 1D float ndarray\n Model parameters (see class docstring for details).\n time: 1D float ndarray\n Phase/times where to evaluate the model.\n \"\"\"\n return ecl.eclipse_quad(params, time)\n\n\nclass mandelecl(Ecl):\n \"\"\"\n Secondary-eclipse model from Mandel & Agol (2002).\n\n This model has six parameters (self.params, see also self.pnames):\n - midpt: mid-eclipse epoch.\n - width: Eclipse duration between first and fourth contacts (T14).\n - depth: Normalized eclipse depth relative to a stellar flux of 1.0.\n That is, depth = dflux/flux.\n - ting: Ingress duration (time between first and second contacts, T12).\n - tegr: Egress duration (time between third and fourth contacts, T34).\n - flux: Stellar flux level, i.e., flux during eclipse.\n\n The time units are arbitrary, and thus, a user's choice. Note that\n midpt, width, ting, terg, and time must have consistent units.\n\n Attributes\n ----------\n name: String\n The model's name.\n type: String\n The type of model.\n pnames: 1D string list\n Names of the model parameters.\n npars: Integer\n The number of model parameters.\n params: 1D float ndarray\n The model parameter values.\n pmin: 1D float ndarray\n Minimum-value boundary of the parameters (for MCMCs).\n pmax: 1D float ndarray\n Maximum-value boundary of the parameters (for MCMCs).\n pstep: 1D float ndarray\n Parameter stepsize (for MCMCs).\n time: 1D float ndarray\n The model's independent variable (timestamps where to evaluate).\n mask: 1D bool ndarray\n Time good-value mask.\n\n Example\n -------\n >>> import sys\n >>> import numpy as np\n >>> import matplotlib.pyplot as plt\n\n >>> sys.path.append(\"../eclipse\")\n >>> import eclipse as ecl\n\n >>> # Create a mandelecl model (setting model.time):\n >>> phase = np.linspace(0.35, 0.65, 300)\n >>> model = ecl.mandelecl(phase)\n >>> # Define eclipse parameters:\n >>> # midpt width depth ting tegr flux\n >>> params = np.array([0.5, 0.1, 0.01, 0.01, 0.01, 1.0])\n >>> # One can call the eval function:\n >>> eclipse1 = model.eval(params, phase)\n >>> # Or directly call the object:\n >>> params[2] = 0.015 # Change eclipse depth\n >>> eclipse2 = model(params, phase)\n >>> # This call can use the default phase, so no need to pass as argument:\n >>> params[5] = 1.005 # Change flux level\n >>> eclipse3 = model(params)\n\n >>> # Show results:\n >>> plt.figure(0)\n >>> plt.clf()\n >>> plt.plot(phase, eclipse1, \".-\", color='b')\n >>> plt.plot(phase, eclipse2, \".-\", color='orange')\n >>> plt.plot(phase, eclipse3, \".-\", color='limegreen')\n >>> plt.xlim(0.34, 0.66)\n >>> plt.xlabel(\"Orbital phase\")\n >>> plt.ylabel(\"Flux\")\n \"\"\"\n def __init__(self, time=None, mask=None, params=None):\n \"\"\"\n Class constructor.\n\n Parameters\n ----------\n time: 1D float ndarray\n Phase/times where to evaluate the model.\n mask: 1D bool ndarray\n Times good-value mask.\n params: 1D float ndarray\n Model parameters (see class docstring for details).\n \"\"\"\n self.name = \"mandelecl\"\n self.pnames = [\"midpt\", \"width\", \"depth\", \"ting\", \"tegr\", \"flux\"]\n super(mandelecl, self).__init__(time, mask, params)\n # Update pmin:\n self.pmin = np.array([-np.inf, 0.0, 0.0, 0.0, 0.0, -np.inf])\n\n\n def eval(self, params, time):\n \"\"\"\n Evaluate the eclipse function at the specified times.\n\n Parameters\n ----------\n params: 1D float ndarray\n Model parameters (see class docstring for details).\n time: 1D float ndarray\n Phase/times where to evaluate the model.\n \"\"\"\n return ecl.mandelecl(params, time)\n", "meta": {"hexsha": "6181c2877688353c02eff3287ff7a4f4b0633e1c", "size": 9671, "ext": "py", "lang": "Python", "max_stars_repo_path": "eclipse/eclmodels.py", "max_stars_repo_name": "pcubillos/eclipse", "max_stars_repo_head_hexsha": "3a8da9cbdac4782bfe286b3a4a6582c157ef1625", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "eclipse/eclmodels.py", "max_issues_repo_name": "pcubillos/eclipse", "max_issues_repo_head_hexsha": "3a8da9cbdac4782bfe286b3a4a6582c157ef1625", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "eclipse/eclmodels.py", "max_forks_repo_name": "pcubillos/eclipse", "max_forks_repo_head_hexsha": "3a8da9cbdac4782bfe286b3a4a6582c157ef1625", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.6044303797, "max_line_length": 80, "alphanum_fraction": 0.6326129666, "include": true, "reason": "import numpy", "num_tokens": 2646, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.542863297964157, "lm_q2_score": 0.35220177524832036, "lm_q1q2_score": 0.19119741726013398}} {"text": "\"\"\"\nCoordinateMaps map (transform) an image from an input space to an output space.\n\nA CoordinateMap object contains all the details about an input\nCoordinateSystem, an output CoordinateSystem and the mappings between\nthem. The *mapping* transforms an image from the input coordinate\nsystem to the output coordinate system. And the *inverse_mapping*\nperforms the opposite transformation. The *inverse_mapping* can be\nspecified explicity when creating the CoordinateMap or implicitly in the\ncase of an Affine CoordinateMap.\n\n\"\"\"\n\n\"\"\"\nMatthew, Cindee thoughts\n\nShould we change the order of input args to CoordinateMap to:\n\nCoordinateMap(input_coords, output_coords, mapping, inverse_mapping=None)\nor keep as\nCoordinateMap(mapping, input_coords, output_coords, inverse_mapping=None)\n\nCoordinateMap.ndim should be renamed to CoordinateMap.ndims, because it returns more than one value.\n\nAffine should be renamed to AffineMap, or AffineCoordMap, or something\n\nWe need to think about whether coordinate values should be N by 3\n(where 3 is the number of coordinates in the coordinate system), or 3\nby N.\n\n3 by N makes more sense when we think of applying an affine matrix to the points.\n\nWe might think, that if we have a matrix ``arr`` with points in, then\n``arr[0]`` should be the first point [x,y,z], rather then the first coordinate\nvalue of all the points - N values of [x]\n\nConsider renaming reorder_input to self.input_reordered() or\nsomething. reorder_output similarly.\n\nThat's as far as we got.\n\n\"\"\"\n\n\nimport warnings\n\nimport numpy as np\n\nimport nipy.core.transforms.affines as affines\nfrom nipy.core.reference.coordinate_system import(CoordinateSystem, \n safe_dtype)\nfrom nipy.core.reference.coordinate_system import product as coordsys_product\n\n__docformat__ = 'restructuredtext'\n\nclass CoordinateMap(object):\n \"\"\"A set of input and output CoordinateSystems and a mapping between them.\n\n For example, the mapping may represent the mapping of an image\n from voxel space (the input coordinates) to real space (the output\n coordinates). The mapping may be an affine or non-affine\n transformation.\n\n Attributes\n ----------\n input_coords : :class:`CoordinateSystem`\n The input coordinate system.\n output_coords : :class:`CoordinateSystem`\n The output coordinate system.\n mapping : callable\n A callable that maps the input_coords to the output_coords.\n inverse_mapping : None or callable\n A callable that maps the output_coords to the input_coords.\n Not all mappings have an inverse, in which case\n inverse_mapping is None.\n \n Examples\n --------\n >>> input_coords = CoordinateSystem('ijk', 'voxels')\n >>> output_coords = CoordinateSystem('xyz', 'world')\n >>> mni_orig = np.array([-90.0, -126.0, -72.0])\n >>> mapping = lambda x: x + mni_orig\n >>> inv_mapping = lambda x: x - mni_orig\n >>> cm = CoordinateMap(mapping, input_coords, output_coords, inv_mapping)\n\n Map the first 3 voxel coordinates, along the x-axis, to mni space:\n\n >>> x = np.array([[0,0,0], [1,0,0], [2,0,0]])\n >>> cm.mapping(x)\n array([[ -90., -126., -72.],\n [ -89., -126., -72.],\n [ -88., -126., -72.]])\n\n\n \"\"\"\n def __init__(self, mapping, \n input_coords, \n output_coords, \n inverse_mapping=None):\n \"\"\"Create a CoordinateMap given the input/output coords and mappings.\n\n Parameters\n ----------\n mapping : callable\n The mapping between input and output coordinates\n input_coords : :class:`CoordinateSystem`\n The input coordinate system\n output_coords : :class:`CoordinateSystem`\n The output coordinate system\n inverse_mapping : None or callable, optional\n The optional inverse of mapping, with the intention being\n ``x = inverse_mapping(mapping(x))``. If the mapping is\n affine and invertible, then this is true for all x. The\n default is None\n\n Returns\n -------\n coordmap : CoordinateMap\n \"\"\"\n # These attrs define the structure of the coordmap.\n self._mapping = mapping\n self._input_coords = input_coords\n self._output_coords = output_coords\n self._inverse_mapping = inverse_mapping\n\n if not callable(mapping):\n raise ValueError('The mapping must be callable.')\n if inverse_mapping is not None:\n if not callable(inverse_mapping):\n raise ValueError('The inverse_mapping must be callable.')\n self._checkmapping()\n\n @property\n def input_coords(self):\n 'input coordinate system'\n return self._input_coords\n\n @property\n def output_coords(self):\n 'output coordinate system'\n return self._output_coords\n\n @property\n def mapping(self):\n 'The mapping from input_coords to output_coords.'\n return self._mapping\n\n @property\n def inverse_mapping(self):\n 'The mapping from output_coords to input_coords'\n return self._inverse_mapping\n\n @property\n def inverse(self):\n \"\"\"\n Return a new CoordinateMap with the mappings reversed\n \"\"\"\n if self._inverse_mapping is None:\n return None\n return CoordinateMap(self._inverse_mapping, \n self._output_coords, \n self._input_coords, \n inverse_mapping=self._mapping)\n\n @property\n def ndim(self):\n 'Number of dimensions of input and output coordinates.'\n return (self._input_coords.ndim, self._output_coords.ndim)\n\n def _checkmapping(self):\n \"\"\"Verify that the input and output dimensions of self.mapping work.\n\n We do this by passing something that should work, through __call__\n \"\"\"\n inp = np.zeros((10, self.ndim[0]),\n dtype=self._input_coords.coord_dtype)\n out = self(inp)\n\n def __call__(self, x):\n \"\"\"Return mapping evaluated at x\n\n Check input and output of mapping for compatiblity with input\n and output coordinate systems respectively.\n\n Parameters\n ----------\n x : array-like\n Values in input coordinate system space that will be mapped\n to the output coordinate system space, using\n ``self.mapping``\n \n Returns\n -------\n y : array\n Values in output coordinate system space\n\n Examples\n --------\n >>> input_cs = CoordinateSystem('ijk')\n >>> output_cs = CoordinateSystem('xyz')\n >>> mapping = lambda x:x+1\n >>> inverse = lambda x:x-1\n >>> cm = CoordinateMap(mapping, input_cs, output_cs, inverse)\n >>> cm([2,3,4])\n array([[3, 4, 5]])\n >>> cmi = cm.inverse\n >>> cmi([2,6,12])\n array([[ 1, 5, 11]])\n\n \"\"\"\n\n in_vals = self._input_coords._checked_values(x)\n out_vals = self._mapping(in_vals)\n return self._output_coords._checked_values(out_vals)\n\n def copy(self):\n \"\"\"Create a copy of the coordmap.\n\n Returns\n -------\n coordmap : CoordinateMap\n\n \"\"\"\n\n return CoordinateMap(self._mapping, \n self._input_coords,\n self._output_coords, \n inverse_mapping=self._inverse_mapping)\n\nclass Affine(CoordinateMap):\n \"\"\"\n A class representing an affine transformation from an input\n coordinate system to an output coordinate system.\n \n This class has an affine property, which is a matrix representing\n the affine transformation in homogeneous coordinates. This matrix\n is used to perform mappings, rather than having an explicit\n mapping function.\n\n >>> inp_cs = CoordinateSystem('ijk')\n >>> out_cs = CoordinateSystem('xyz')\n >>> cm = Affine(np.diag([1, 2, 3, 1]), inp_cs, out_cs)\n >>> cm.affine\n array([[ 1., 0., 0., 0.],\n [ 0., 2., 0., 0.],\n [ 0., 0., 3., 0.],\n [ 0., 0., 0., 1.]])\n >>> cm([1,1,1])\n array([[ 1., 2., 3.]])\n >>> icm = cm.inverse\n >>> icm([1,2,3])\n array([[ 1., 1., 1.]])\n \"\"\"\n\n def __init__(self, affine, input_coords, output_coords):\n \"\"\"\n Return an CoordinateMap specified by an affine transformation\n in homogeneous coordinates.\n \n Parameters\n ----------\n affine : array-like\n affine homogenous coordinate matrix\n input_coords : :class:`CoordinateSystem`\n input coordinates\n output_coords : :class:`CoordinateSystem`\n output coordinates\n\n Notes\n -----\n The dtype of the resulting matrix is determined by finding a\n safe typecast for the input_coords, output_coords and affine.\n \"\"\"\n affine = np.asarray(affine)\n dtype = safe_dtype(affine.dtype,\n input_coords.coord_dtype,\n output_coords.coord_dtype)\n inaxes = input_coords.coord_names\n outaxes = output_coords.coord_names\n self._input_coords = CoordinateSystem(inaxes,\n input_coords.name,\n dtype)\n self._output_coords = CoordinateSystem(outaxes,\n output_coords.name,\n dtype)\n affine = np.asarray(affine, dtype=dtype)\n if affine.shape != (self.ndim[1]+1, self.ndim[0]+1):\n raise ValueError('coordinate lengths do not match '\n 'affine matrix shape')\n self._affine = affine\n A, b = affines.to_matrix_vector(affine)\n def _mapping(x):\n value = np.dot(x, A.T)\n value += b\n return value\n self._mapping = _mapping\n\n @property\n def affine(self):\n \"\"\"The affine transform matrix of the Affine CoordinateMap.\"\"\"\n return self._affine\n \n @property\n def inverse_mapping(self):\n \"\"\"The inverse affine mapping from the Affine CoordinateMap.\"\"\"\n inverse = self.inverse\n if inverse is None:\n raise ValueError('There is no inverse for this affine')\n return inverse.mapping\n\n @property\n def inverse(self):\n \"\"\"\n Return the inverse coordinate map.\n \"\"\"\n try:\n return Affine(np.linalg.inv(self.affine), \n self.output_coords, \n self.input_coords)\n except np.linalg.linalg.LinAlgError:\n pass\n\n @staticmethod\n def from_params(innames, outnames, params):\n \"\"\"\n Create an `Affine` instance from sequences of innames and outnames.\n\n Parameters\n ----------\n innames : ``tuple`` of ``string``\n The names of the axes of the input coordinate systems\n outnames : ``tuple`` of ``string``\n The names of the axes of the output coordinate systems\n params : `Affine`, `ndarray` or `(ndarray, ndarray)`\n An affine mapping between the input and output coordinate\n systems. This can be represented either by a single\n ndarray (which is interpreted as the representation of the\n mapping in homogeneous coordinates) or an (A,b) tuple.\n\n Returns\n -------\n aff : `Affine` object instance\n \n Notes\n -----\n :Precondition: ``len(shape) == len(names)``\n \n :Raises ValueError: ``if len(shape) != len(names)``\n \"\"\"\n if type(params) == type(()):\n A, b = params\n params = affines.from_matrix_vector(A, b)\n\n ndim = (len(innames) + 1, len(outnames) + 1)\n if params.shape != ndim[::-1]:\n raise ValueError('shape and number of axis names do not agree')\n dtype = params.dtype\n\n input_coords = CoordinateSystem(innames, \"input\")\n output_coords = CoordinateSystem(outnames, 'output')\n return Affine(params, input_coords, output_coords)\n\n @staticmethod\n def from_start_step(innames, outnames, start, step):\n \"\"\"\n Create an `Affine` instance from sequences of names, start\n and step.\n\n Parameters\n ----------\n innames : ``tuple`` of ``string``\n The names of the axes of the input coordinate systems\n outnames : ``tuple`` of ``string``\n The names of the axes of the output coordinate systems\n start : ``tuple`` of ``float``\n Start vector used in constructing affine transformation\n step : ``tuple`` of ``float``\n Step vector used in constructing affine transformation\n\n Returns\n -------\n cm : `CoordinateMap`\n\n Examples\n --------\n >>> cm = Affine.from_start_step('ijk', 'xyz', [1, 2, 3], [4, 5, 6])\n >>> cm.affine\n array([[ 4., 0., 0., 1.],\n [ 0., 5., 0., 2.],\n [ 0., 0., 6., 3.],\n [ 0., 0., 0., 1.]])\n \n Notes\n -----\n ``len(names) == len(start) == len(step)``\n \n \"\"\"\n ndim = len(innames)\n if len(outnames) != ndim:\n raise ValueError('len(innames) != len(outnames)')\n return Affine.from_params(innames, \n outnames, \n (np.diag(step), start))\n\n @staticmethod\n def identity(names):\n \"\"\"\n Return an identity coordmap of the given shape.\n \n Parameters\n ----------\n names : ``tuple`` of ``string`` \n Names of Axes in output CoordinateSystem\n\n Returns\n -------\n cm : `CoordinateMap` \n ``CoordinateMap`` with `CoordinateSystem` input and an\n identity transform, with identical input and output coords.\n\n Examples\n --------\n >>> cm = Affine.identity('ijk')\n >>> cm.affine\n array([[ 1., 0., 0., 0.],\n [ 0., 1., 0., 0.],\n [ 0., 0., 1., 0.],\n [ 0., 0., 0., 1.]])\n >>> print cm.input_coords\n name: 'input', coord_names: ('i', 'j', 'k'), coord_dtype: float64\n >>> print cm.output_coords\n name: 'output', coord_names: ('i', 'j', 'k'), coord_dtype: float64\n \"\"\"\n return Affine.from_start_step(names, names, [0]*len(names),\n [1]*len(names))\n\n def copy(self):\n \"\"\"\n Create a copy of the coordmap.\n\n Returns\n -------\n cm : `CoordinateMap`\n\n Examples\n --------\n >>> cm = Affine(np.eye(4), CoordinateSystem('ijk'), CoordinateSystem('xyz'))\n >>> cm_copy = cm.copy()\n >>> cm is cm_copy\n False\n\n Note that the matrix (affine) is not a pointer to the\n same data, it's a full independent copy\n\n >>> cm.affine[0,0] = 2.0\n >>> cm_copy.affine[0,0]\n 1.0\n \"\"\"\n return Affine(self._affine.copy(), self._input_coords,\n self._output_coords)\n\n\ndef reorder_input(coordmap, order=None):\n \"\"\"\n Create a new coordmap with reversed input_coords.\n Default behaviour is to reverse the order of the input_coords.\n If the coordmap has a shape, the resulting one will as well.\n\n Inputs:\n -------\n order: sequence\n Order to use, defaults to reverse. The elements\n can be integers, strings or 2-tuples of strings.\n If they are strings, they should be in coordmap.input_coords.coord_names.\n\n Returns:\n --------\n\n newcoordmap: `CoordinateMap`\n A new CoordinateMap with reversed input_coords.\n\n >>> input_cs = CoordinateSystem('ijk')\n >>> output_cs = CoordinateSystem('xyz')\n >>> cm = Affine(np.identity(4), input_cs, output_cs)\n >>> print reorder_input(cm, 'ikj').input_coords\n name: '-reordered', coord_names: ('i', 'k', 'j'), coord_dtype: float64\n \"\"\"\n ndim = coordmap.ndim[0]\n if order is None:\n order = range(ndim)[::-1]\n elif type(order[0]) == type(''):\n order = [coordmap.input_coords.index(s) for s in order]\n\n newaxes = [coordmap.input_coords.coord_names[i] for i in order]\n newincoords = CoordinateSystem(newaxes, \n coordmap.input_coords.name + '-reordered', \n coord_dtype=coordmap.input_coords.coord_dtype)\n perm = np.zeros((ndim+1,)*2)\n perm[-1,-1] = 1.\n\n for i, j in enumerate(order):\n perm[j,i] = 1.\n\n perm = perm.astype(coordmap.input_coords.coord_dtype)\n A = Affine(perm, newincoords, coordmap.input_coords)\n return compose(coordmap, A)\n\n\ndef reorder_output(coordmap, order=None):\n \"\"\"\n Create a new coordmap with reversed output_coords.\n Default behaviour is to reverse the order of the input_coords.\n \n Inputs:\n -------\n\n order: sequence\n Order to use, defaults to reverse. The elements\n can be integers, strings or 2-tuples of strings.\n If they are strings, they should be in coordmap.output_coords.coord_names.\n\n Returns:\n --------\n \n newcoordmap: `CoordinateMap`\n A new CoordinateMap with reversed output_coords.\n\n >>> input_cs = CoordinateSystem('ijk')\n >>> output_cs = CoordinateSystem('xyz')\n >>> cm = Affine(np.identity(4), input_cs, output_cs)\n >>> print reorder_output(cm, 'xzy').output_coords\n name: '-reordered', coord_names: ('x', 'z', 'y'), coord_dtype: float64\n >>> print reorder_output(cm, [0,2,1]).output_coords.coord_names\n ('x', 'z', 'y')\n\n >>> newcm = reorder_output(cm, 'yzx')\n >>> newcm.output_coords.coord_names\n ('y', 'z', 'x')\n\n \"\"\"\n\n ndim = coordmap.ndim[1]\n if order is None:\n order = range(ndim)[::-1]\n elif type(order[0]) == type(''):\n order = [coordmap.output_coords.index(s) for s in order]\n\n newaxes = [coordmap.output_coords.coord_names[i] for i in order]\n newoutcoords = CoordinateSystem(newaxes, coordmap.output_coords.name + '-reordered', coordmap.output_coords.coord_dtype)\n \n perm = np.zeros((ndim+1,)*2)\n perm[-1,-1] = 1.\n\n for i, j in enumerate(order):\n perm[j,i] = 1.\n\n perm = perm.astype(coordmap.output_coords.coord_dtype)\n A = Affine(perm, coordmap.output_coords, newoutcoords)\n return compose(A, coordmap)\n\n\ndef product(*cmaps):\n \"\"\"\n Return the \"topological\" product of two or more CoordinateMaps.\n\n Inputs:\n -------\n cmaps : sequence of CoordinateMaps\n\n Returns:\n --------\n cmap : ``CoordinateMap``\n\n >>> inc1 = Affine.from_params('i', 'x', np.diag([2,1]))\n >>> inc2 = Affine.from_params('j', 'y', np.diag([3,1]))\n >>> inc3 = Affine.from_params('k', 'z', np.diag([4,1]))\n\n >>> cmap = product(inc1, inc3, inc2)\n >>> cmap.input_coords.coord_names\n ('i', 'k', 'j')\n >>> cmap.output_coords.coord_names\n ('x', 'z', 'y')\n >>> cmap.affine\n array([[ 2., 0., 0., 0.],\n [ 0., 4., 0., 0.],\n [ 0., 0., 3., 0.],\n [ 0., 0., 0., 1.]])\n\n \"\"\"\n ndimin = [cmap.ndim[0] for cmap in cmaps]\n ndimin.insert(0,0)\n ndimin = tuple(np.cumsum(ndimin))\n\n def mapping(x):\n x = np.asarray(x)\n y = []\n for i in range(len(ndimin)-1):\n cmap = cmaps[i]\n if x.ndim == 2:\n yy = cmaps[i](x[:,ndimin[i]:ndimin[i+1]])\n else:\n yy = cmaps[i](x[ndimin[i]:ndimin[i+1]])\n y.append(yy)\n yy = np.hstack(y)\n return yy\n\n notaffine = filter(lambda x: not isinstance(x, Affine), cmaps)\n\n incoords = coordsys_product(*[cmap.input_coords for cmap in cmaps])\n outcoords = coordsys_product(*[cmap.output_coords for cmap in cmaps])\n\n if not notaffine:\n\n affine = linearize(mapping, ndimin[-1], dtype=incoords.coord_dtype)\n return Affine(affine, incoords, outcoords)\n return CoordinateMap(mapping, incoords, outcoords)\n\n\ndef compose(*cmaps):\n \"\"\"\n Return the composition of two or more CoordinateMaps.\n\n Inputs:\n -------\n cmaps : sequence of CoordinateMaps\n\n Returns:\n --------\n cmap : ``CoordinateMap``\n The resulting CoordinateMap has input_coords == cmaps[-1].input_coords\n and output_coords == cmaps[0].output_coords\n\n >>> cmap = Affine.from_params('i', 'x', np.diag([2.,1.]))\n >>> cmapi = cmap.inverse\n >>> id1 = compose(cmap,cmapi)\n >>> print id1.affine\n [[ 1. 0.]\n [ 0. 1.]]\n\n >>> id2 = compose(cmapi,cmap)\n >>> id1.input_coords.coord_names\n ('x',)\n >>> id2.input_coords.coord_names\n ('i',)\n >>> \n\n \"\"\"\n\n def _compose2(cmap1, cmap2):\n forward = lambda input: cmap1.mapping(cmap2.mapping(input))\n if cmap1.inverse is not None and cmap2.inverse is not None:\n backward = lambda output: cmap2.inverse.mapping(cmap1.inverse.mapping(output))\n else:\n backward = None\n return forward, backward\n\n cmap = cmaps[-1]\n for i in range(len(cmaps)-2,-1,-1):\n m = cmaps[i]\n if m.input_coords == cmap.output_coords:\n forward, backward = _compose2(m, cmap)\n cmap = CoordinateMap(forward, \n cmap.input_coords, \n m.output_coords, \n inverse_mapping=backward)\n else:\n raise ValueError(\n 'input and output coordinates do not match: '\n 'input=%s, output=%s' % \n (`m.input_coords.dtype`, `cmap.output_coords.dtype`))\n\n notaffine = filter(lambda cmap: not isinstance(cmap, Affine), cmaps)\n if not notaffine:\n affine = linearize(cmap, \n cmap.ndim[0], \n dtype=cmap.output_coords.coord_dtype)\n return Affine(affine, cmap.input_coords,\n cmap.output_coords)\n return cmap\n \n\ndef replicate(coordmap, n, concataxis='concat'):\n \"\"\"\n Create a CoordinateMap by taking the product\n of coordmap with a 1-dimensional 'concat' CoordinateSystem\n\n :Parameters:\n coordmap : `CoordinateMap`\n The coordmap to be used\n n : ``int``\n The number of tiems to concatenate the coordmap\n concataxis : ``string``\n The name of the new dimension formed by concatenation\n \"\"\"\n\n raise NotImplementedError('The method this function depends on' \n 'no longer exists.')\n \"\"\"\n concat = CoordinateMap.from_affine([concataxis], [concataxis], \n Affine(np.identity(2)), (n,))\n return product(concat, coordmap)\n \"\"\"\n\n\ndef linearize(mapping, ndimin, step=1, origin=None, dtype=None):\n \"\"\"\n Given a Mapping of ndimin variables, return the linearization of\n mapping at origin based on a given step size in each coordinate\n axis.\n\n If not specified, origin defaults to np.zeros(ndimin, dtype=dtype).\n \n Parameters\n ----------\n mapping : callable\n A function to linearize\n ndimin : int\n Number of input dimensions to mapping\n step : scalar, optional\n step size over which to calculate linear components. Default 1\n origin : None or array, optional\n Origin at which to linearize mapping. If None, origin is\n ``np.zeros(ndimin)``\n dtype : None or np.dtype, optional\n dtype for return. Default is None. If ``dtype`` is None, and\n ``step`` is an ndarray, use ``step.dtype``. Otherwise use\n np.float.\n\n Returns\n -------\n C : array \n Linearization of mapping in homogeneous coordinates, i.e. an\n array of size (ndimout+1, ndimin+1) where ndimout =\n mapping(origin).shape[0].\n \"\"\"\n if dtype is None:\n try:\n dtype = step.dtype\n except AttributeError:\n dtype = np.float\n step = np.array(step, dtype=dtype)\n if origin is None:\n origin = np.zeros(ndimin, dtype)\n else:\n if origin.dtype != dtype:\n warnings.warn('origin.dtype != dtype in function linearize, using input dtype')\n origin = np.asarray(origin, dtype=dtype)\n if origin.shape != (ndimin,):\n raise ValueError('origin.shape != (%d,)' % ndimin)\n b = mapping(origin)\n\n origin = np.multiply.outer(np.ones(ndimin, dtype), origin)\n y1 = mapping(step*np.eye(ndimin, dtype=dtype) + origin)\n y0 = mapping(origin)\n\n ndimout = y1.shape[1]\n C = np.zeros((ndimout+1, ndimin+1), (y0/step).dtype)\n C[-1,-1] = 1\n C[:ndimout,-1] = b\n C[:ndimout,:ndimin] = (y1 - y0).T / step\n return C\n\n\ndef drop_io_dim(cm, name):\n ''' Drop dimension from coordinate map, if orthogonal to others\n\n Drops both input and corresponding output dimension. Thus there\n should be a corresponding input dimension for a selected output\n dimension, or a corresponding output dimension for an input\n dimension. \n\n Parameters\n ----------\n cm : Affine\n Affine coordinate map instance\n name : str\n Name of input or output dimension to drop. If this is an input\n dimension, there must be a corresponding output dimension with\n the same index, and vica versa. The check for orthogonality\n ensures that the input and output dimensions are only related to\n each other, and not to the other dimensions.\n\n Returns\n -------\n cm_redux : Affine\n Affine coordinate map with orthogonal input + output dimension\n dropped\n\n Examples\n --------\n Typical use is in getting a 3D coordinate map from 4D\n\n >>> cm4d = Affine.from_params('ijkl', 'xyzt', np.diag([1,2,3,4,1]))\n >>> cm3d = drop_io_dim(cm4d, 't')\n >>> cm3d.affine\n array([[ 1., 0., 0., 0.],\n [ 0., 2., 0., 0.],\n [ 0., 0., 3., 0.],\n [ 0., 0., 0., 1.]])\n '''\n aff = cm.affine\n in_dims = list(cm.input_coords.coord_names)\n nin = len(in_dims)\n out_dims = list(cm.output_coords.coord_names)\n nout = len(out_dims)\n try:\n i = in_dims.index(name)\n except ValueError:\n try:\n i = out_dims.index(name)\n except ValueError:\n raise ValueError('No input or output dimension '\n 'with name (%s)' % name)\n col_inds = range(nin)\n row_inds = range(nout)\n try:\n col_inds.remove(i)\n except IndexError:\n raise ValueError('Should be corresponding input and '\n 'output dims')\n try:\n row_inds.remove(i)\n except IndexError:\n raise ValueError('Should be corresponding input and '\n 'output dims')\n removed_col = aff[row_inds, i]\n if np.any(removed_col):\n raise ValueError('Elements in dimension %d to remove (%s) '\n 'appear not to be orthogonal '\n 'to remaining dimensions' % (i, removed_col))\n aff = aff[:, col_inds + [nin]]\n aff = aff[row_inds + [nout],:]\n in_dims = [n for i, n in enumerate(in_dims) if i in col_inds]\n out_dims = [n for i, n in enumerate(out_dims) if i in row_inds]\n return Affine.from_params(in_dims, out_dims, aff)\n\n\ndef append_io_dim(cm, in_name, out_name, start=0, step=1):\n ''' Append input and output dimension to coordmap\n\n Parameters\n ----------\n cm : Affine\n Affine coordinate map instance to which to append dimension\n in_name : str\n Name for new input dimension\n out_name : str\n Name for new output dimension\n start : float, optional\n Offset for transformed values in new dimension\n step : float, optional\n Step, or scale factor for transformed values in new dimension\n\n Returns\n -------\n cm_plus : Affine\n New coordinate map with appended dimension\n\n Examples\n --------\n Typical use is creating a 4D coordinate map from a 3D\n\n >>> cm3d = Affine.from_params('ijk', 'xyz', np.diag([1,2,3,1]))\n >>> cm4d = append_io_dim(cm3d, 'l', 't', 9, 5)\n >>> cm4d.affine\n array([[ 1., 0., 0., 0., 0.],\n [ 0., 2., 0., 0., 0.],\n [ 0., 0., 3., 0., 0.],\n [ 0., 0., 0., 5., 9.],\n [ 0., 0., 0., 0., 1.]])\n '''\n aff = cm.affine\n in_dims = list(cm.input_coords.coord_names)\n nin = len(in_dims)\n out_dims = list(cm.output_coords.coord_names)\n nout = len(out_dims)\n in_dims.append(in_name)\n out_dims.append(out_name)\n aff_plus = np.zeros((nout+2, nin+2))\n aff_plus[:nout,:nin] = aff[:nout, :nin]\n aff_plus[:nout,-1] = aff[:nout,-1]\n aff_plus[nout,nin] = step\n aff_plus[-1,-1] = 1\n aff_plus[nout,-1] = start\n return Affine.from_params(in_dims, out_dims, aff_plus)\n\n \n", "meta": {"hexsha": "a27272d664ba5b7dedba65a098bb3abf5e6011a6", "size": 28946, "ext": "py", "lang": "Python", "max_stars_repo_path": "nipy/core/reference/coordinate_map.py", "max_stars_repo_name": "yarikoptic/NiPy-OLD", "max_stars_repo_head_hexsha": "8759b598ac72d3b9df7414642c7a662ad9c55ece", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2015-08-22T16:14:45.000Z", "max_stars_repo_stars_event_max_datetime": "2015-08-22T16:14:45.000Z", "max_issues_repo_path": "nipy/core/reference/coordinate_map.py", "max_issues_repo_name": "yarikoptic/NiPy-OLD", "max_issues_repo_head_hexsha": "8759b598ac72d3b9df7414642c7a662ad9c55ece", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "nipy/core/reference/coordinate_map.py", "max_forks_repo_name": "yarikoptic/NiPy-OLD", "max_forks_repo_head_hexsha": "8759b598ac72d3b9df7414642c7a662ad9c55ece", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.5968468468, "max_line_length": 124, "alphanum_fraction": 0.578421889, "include": true, "reason": "import numpy", "num_tokens": 6957, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.5428632831725052, "lm_q2_score": 0.35220177524832036, "lm_q1q2_score": 0.19119741205048796}} {"text": "\"\"\"\nProcedures needed for Common support estimation.\n\nCreated on Thu Dec 8 15:48:57 2020.\n\n@author: MLechner\n\n# -*- coding: utf-8 -*-\n\"\"\"\nimport copy\nimport numpy as np\nimport pandas as pd\nfrom mcf import mcf_data_functions as mcf_data\nfrom mcf import general_purpose as gp\nfrom mcf import general_purpose_estimation as gp_est\n\n\ndef common_support(predict_file, tree_file, fill_y_file, fs_file, var_x_type,\n v_dict, c_dict, cs_list=None, prime_values_dict=None,\n pred_tr_np=None, d_tr_np=None):\n \"\"\"\n Remove observations from data files that are off-support.\n\n Parameters\n ----------\n predict_file : String of csv-file. Data to predict the RF.\n train_file : String of csv-file. Data to train the RF.\n fill_y_file : String of csv-file. Data with y to be used by RF.\n fs_file : String of csv-file. Data with y to be used by RF.\n var_x_type : Dict. Features.\n v_dict : Dict. Variables.\n c_dict : Dict. Parameters.\n cs_list: Tuple. Contains the information from estimated propensity score\n needed to predict for other data. Default is None.\n prime_values_dict: Dict. List of unique values for variables to dummy.\n Default is None.\n pred_t: Numpy array. Predicted treatment probabilities in training data.\n Needed to define cut-offs.\n d_train: Numpy series. Observed treatment in training data (tree_file).\n\n Returns\n -------\n predict_file_new : String of csv-file. Adjusted data.\n cs_list: Tuple. Contains the information from estimated propensity score\n needed to predict for other data.\n pred_t: Numpy array. Predicted treatment probabilities in training data.\n d_train_tree: estimated tree by sklearn.\n\n \"\"\"\n def r2_obb(c_dict, idx, oob_best):\n if c_dict['with_output']:\n print('\\n')\n print('-' * 80)\n print('Treatment: {:2}'.format(c_dict['d_values'][idx]),\n 'OOB Score (R2 in %): {:6.3f}'.format(oob_best * 100))\n print('-' * 80)\n\n def get_data(file_name, x_name):\n data = pd.read_csv(file_name)\n x_all = data[x_name] # deep copies\n obs = len(x_all.index)\n return data, x_all, obs\n\n def check_cols(x_1, x_2, name1, name2):\n var1 = set(x_1.columns)\n var2 = set(x_2.columns)\n if var1 != var2:\n if len(var1-var2) > 0:\n print('Variables in ', name1, 'not contained in ', name2,\n *(var1-var2))\n if len(var2-var1) > 0:\n print('Variables in ', name2, 'not contained in ', name1,\n *(var2-var1))\n raise Exception(name1 + ' data and ' + name2 + ' data contain' +\n ' differnt variables. Programm stopped.')\n\n def mean_by_treatment(treat_pd, data_pd):\n treat_pd = treat_pd.squeeze()\n treat_vals = pd.unique(treat_pd)\n print('--------------- Mean by treatment status ------------------')\n if len(treat_vals) > 0:\n mean = data_pd.groupby(treat_pd).mean()\n print(mean.transpose())\n else:\n print('All obs have same treatment:', treat_vals)\n\n def on_support_data_and_stats(obs_to_del_np, data_pd, x_data_pd, out_file,\n upper_l, lower_l, c_dict, header=False,\n d_name=None):\n obs_to_keep = np.invert(obs_to_del_np)\n data_keep = data_pd[obs_to_keep]\n gp.delete_file_if_exists(out_file)\n data_keep.to_csv(out_file, index=False)\n if c_dict['with_output']:\n x_keep = x_data_pd[obs_to_keep]\n x_delete = x_data_pd[obs_to_del_np]\n if header:\n print('\\n')\n print('=' * 80)\n print('Common support check')\n print('-' * 80)\n print('Upper limits on treatment probabilities: ', upper_l)\n print('Lower limits on treatment probabilities: ', lower_l)\n print('-' * 80)\n print('Data investigated and saved:', out_file)\n print('-' * 80)\n print('Observations deleted: {:4}'.format(np.sum(obs_to_del_np)),\n ' ({:6.3f}%)'.format(np.mean(obs_to_del_np)*100))\n with pd.option_context(\n 'display.max_rows', 500,\n 'display.max_columns', 500,\n 'display.expand_frame_repr', True,\n 'display.width', 150,\n 'chop_threshold', 1e-13):\n all_var_names = [name.upper() for name in data_pd.columns]\n if d_name[0].upper() in all_var_names:\n d_keep = data_keep[d_name]\n d_delete = data_pd[d_name]\n d_delete = d_delete[obs_to_del_np]\n d_keep_count = d_keep.value_counts(sort=False)\n d_delete_count = d_delete.value_counts(sort=False)\n d_keep_count = pd.concat(\n [d_keep_count,\n d_keep_count / np.sum(obs_to_keep) * 100], axis=1)\n d_delete_count = pd.concat(\n [d_delete_count,\n d_delete_count / np.sum(obs_to_del_np) * 100], axis=1)\n d_keep_count.columns = ['Obs.', 'Share in %']\n d_delete_count.columns = ['Obs.', 'Share in %']\n if c_dict['panel_data']:\n cluster_id = data_pd[v_dict['cluster_name']].squeeze()\n cluster_keep = cluster_id[obs_to_keep].squeeze()\n cluster_delete = cluster_id[obs_to_del_np].squeeze()\n print('-' * 80)\n print('Observations kept by treatment')\n print(d_keep_count)\n print('- ' * 20)\n print('Observations deleted by treatment')\n print(d_delete_count)\n if c_dict['panel_data']:\n print('- ' * 20)\n print('Total number of panel unit:',\n len(cluster_id.unique()))\n print('Observations belonging to ',\n len(cluster_keep.unique()),\n 'panel units are ON support')\n print('Observations belonging to ',\n len(cluster_delete.unique()),\n 'panel units are OFF support')\n if d_name[0].upper() in all_var_names:\n print()\n print('Full sample (ON and OFF support observations)')\n mean_by_treatment(data_pd[d_name], x_data_pd)\n print('-' * 80)\n print('Data ON support')\n print('-' * 80)\n print(x_keep.describe().transpose())\n if d_name[0].upper() in all_var_names:\n print()\n mean_by_treatment(d_keep, x_keep)\n print('-' * 80)\n print('Data OFF support')\n print('-' * 80)\n print(x_delete.describe().transpose())\n if d_name[0].upper() in all_var_names:\n print()\n if np.sum(obs_to_del_np) > 1:\n mean_by_treatment(d_delete, x_delete)\n else:\n print('Only single observation deleted.')\n if np.mean(obs_to_del_np) > c_dict['support_max_del_train']:\n raise Exception(\n 'Less than {:3}%'.format(\n 100-c_dict['support_max_del_train']*100)\n + ' observations left after common support check of'\n + ' training data. Programme terminated. Improve'\n + ' balance of input data for forest building.')\n\n x_name, x_type = gp.get_key_values_in_list(var_x_type)\n names_unordered = [] # Split ordered variables into dummies\n for j, val in enumerate(x_type):\n if val > 0:\n names_unordered.append(x_name[j])\n fs_adjust = False\n obs_fs = 0\n if c_dict['train_mcf']:\n data_tr, x_tr, obs_tr = get_data(tree_file, x_name) # train,adj.\n data_fy, x_fy, obs_fy = get_data(fill_y_file, x_name) # adj.\n if c_dict['fs_yes']:\n # if not ((fs_file == tree_file) or (fs_file == fill_y_file)):\n if fs_file not in (tree_file, fill_y_file):\n data_fs, x_fs, obs_fs = get_data(fs_file, x_name) # adj.\n fs_adjust = True\n if c_dict['pred_mcf']:\n data_pr, x_pr, obs_pr = get_data(predict_file, x_name)\n else:\n obs_pr = 0\n if names_unordered: # List is not empty\n if c_dict['train_mcf'] and c_dict['pred_mcf']:\n x_total = pd.concat([x_tr, x_fy, x_pr], axis=0)\n if fs_adjust:\n x_total = pd.concat([x_total, x_fs], axis=0)\n x_dummies = pd.get_dummies(x_total[names_unordered],\n columns=names_unordered)\n x_total = pd.concat([x_total, x_dummies], axis=1)\n x_tr = x_total[:obs_tr]\n x_fy = x_total[obs_tr:obs_tr+obs_fy]\n x_pr = x_total[obs_tr+obs_fy:obs_tr+obs_fy+obs_pr]\n if fs_adjust:\n x_fs = x_total[obs_tr+obs_fy+obs_pr:]\n elif c_dict['train_mcf'] and not c_dict['pred_mcf']:\n x_total = pd.concat([x_tr, x_fy], axis=0)\n if fs_adjust:\n x_total = pd.concat([x_total, x_fs], axis=0)\n x_dummies = pd.get_dummies(x_total[names_unordered],\n columns=names_unordered)\n x_total = pd.concat([x_total, x_dummies], axis=1)\n x_tr = x_total[:obs_tr]\n x_fy = x_total[obs_tr:obs_tr+obs_fy]\n if fs_adjust:\n x_fs = x_total[obs_tr+obs_fy:]\n else:\n x_add_tmp = check_if_obs_needed(names_unordered, x_pr,\n prime_values_dict)\n if x_add_tmp is not None:\n x_total = pd.concat([x_pr, x_add_tmp], axis=0)\n else:\n x_total = x_pr\n x_dummies = pd.get_dummies(x_total[names_unordered],\n columns=names_unordered)\n x_pr = pd.concat([x_total, x_dummies], axis=1)\n if x_add_tmp is not None: # remove add_temp\n x_pr = x_pr[:obs_pr]\n if c_dict['train_mcf']:\n x_name_all = x_tr.columns.values.tolist()\n else:\n x_name_all = x_pr.columns.values.tolist()\n if c_dict['train_mcf']:\n x_tr_np = x_tr.to_numpy(copy=True)\n d_all_in = pd.get_dummies(data_tr[v_dict['d_name']],\n columns=v_dict['d_name'])\n d_tr_np = d_all_in.to_numpy(copy=True)\n pred_tr_np = np.empty((np.shape(x_tr_np)[0], c_dict['no_of_treat']))\n if c_dict['train_mcf']:\n x_pred_all = x_fy.copy()\n if c_dict['pred_mcf']:\n x_pred_all = pd.concat([x_pred_all, x_pr], axis=0)\n if fs_adjust:\n x_pred_all = pd.concat([x_pred_all, x_fs], axis=0)\n else:\n obs_fy = 0\n x_pred_all = x_pr.copy()\n x_pred_all_np = x_pred_all.to_numpy(copy=True)\n pred_all_np = np.empty((obs_fy+obs_fs+obs_pr, c_dict['no_of_treat']))\n if c_dict['no_parallel'] > 1:\n workers_mp = copy.copy(c_dict['no_parallel'])\n else:\n workers_mp = None\n if c_dict['train_mcf']:\n check_cols(x_tr, x_fy, 'Tree', 'Fill_y')\n if fs_adjust:\n check_cols(x_tr, x_fs, 'Tree', 'Feature selection')\n if c_dict['train_mcf'] and c_dict['pred_mcf']:\n check_cols(x_tr, x_pr, 'Tree', 'Prediction')\n if c_dict['train_mcf']:\n if c_dict['with_output'] and c_dict['verbose']:\n print('\\n')\n print('-' * 80)\n print('Computing random forest based common support')\n if c_dict['train_mcf']:\n cs_list = []\n c_dict_new = mcf_data.m_n_grid(copy.deepcopy(c_dict), # dict only\n len(x_pred_all.columns)) # used here\n for idx in range(c_dict['no_of_treat']):\n return_forest = bool(c_dict['save_forest'])\n ret_rf = gp_est.RandomForest_scikit(\n x_tr_np, d_tr_np[:, idx], x_pred_all_np, boot=c_dict['boot'],\n n_min=c_dict_new['grid_n_min'],\n no_features=c_dict_new['grid_m'], workers=workers_mp,\n pred_p_flag=True, pred_t_flag=True, pred_oob_flag=True,\n with_output=False, variable_importance=True, x_name=x_name_all,\n var_im_with_output=c_dict['with_output'],\n return_forest_object=return_forest)\n pred_all_np[:, idx] = np.copy(ret_rf[0])\n pred_tr_np[:, idx] = np.copy(ret_rf[1])\n oob_best = np.copy(ret_rf[2])\n if c_dict['save_forest']:\n cs_list.append(ret_rf[6])\n r2_obb(c_dict, idx, oob_best)\n if c_dict['no_of_treat'] == 2:\n pred_all_np[:, idx+1] = 1 - pred_all_np[:, idx]\n pred_tr_np[:, idx+1] = 1 - pred_tr_np[:, idx]\n break\n else:\n for idx in range(c_dict['no_of_treat']):\n pred_all_np[:, idx] = cs_list[idx].predict(x_pred_all_np)\n if c_dict['no_of_treat'] == 2:\n pred_all_np[:, idx+1] = 1 - pred_all_np[:, idx]\n break\n obs_to_del_all, obs_to_del_tr, upper_l, lower_l = indicate_off_support(\n pred_tr_np, pred_all_np, d_tr_np, c_dict)\n # split obs_to_del_all into its parts\n obs_to_del_fs, obs_to_del_fy, obs_to_del_pr = False, False, False\n predict_file_new = None\n if c_dict['train_mcf']:\n obs_to_del_fy = obs_to_del_all[:obs_fy]\n if c_dict['pred_mcf']:\n obs_to_del_pr = obs_to_del_all[obs_fy:obs_fy+obs_pr]\n if fs_adjust:\n obs_to_del_fs = obs_to_del_all[obs_fy+obs_pr:]\n else:\n obs_to_del_pr = obs_to_del_all\n if c_dict['train_mcf']:\n if np.any(obs_to_del_tr):\n on_support_data_and_stats(obs_to_del_tr, data_tr, x_tr, tree_file,\n upper_l, lower_l, c_dict, header=True,\n d_name=v_dict['d_name'])\n if np.any(obs_to_del_fs):\n on_support_data_and_stats(obs_to_del_fs, data_fs, x_fs, fs_file,\n upper_l, lower_l, c_dict,\n d_name=v_dict['d_name'])\n if np.any(obs_to_del_fy):\n on_support_data_and_stats(obs_to_del_fy, data_fy, x_fy,\n fill_y_file, upper_l, lower_l, c_dict,\n d_name=v_dict['d_name'])\n if c_dict['pred_mcf']:\n if np.any(obs_to_del_pr):\n on_support_data_and_stats(\n obs_to_del_pr, data_pr, x_pr, c_dict['preddata3_temp'],\n upper_l, lower_l, c_dict, d_name=v_dict['d_name'])\n predict_file_new = c_dict['preddata3_temp']\n else:\n predict_file_new = predict_file\n else:\n predict_file_new = None\n return predict_file_new, cs_list, pred_tr_np, d_tr_np\n\n\ndef check_if_obs_needed(names_unordered, x_all_p, prime_values_dict):\n \"\"\"Generate new rows -> all values of unordered variables are in data.\"\"\"\n no_change = True\n max_length = 1\n for name in names_unordered:\n length = len(prime_values_dict[name])\n if length > max_length:\n max_length = length\n x_add_tmp = x_all_p[:max_length].copy()\n for name in names_unordered:\n unique_vals_p = np.sort(x_all_p[name].unique())\n unique_vals_t = np.sort(prime_values_dict[name])\n if len(unique_vals_p) > len(unique_vals_t) or (\n (len(unique_vals_p) == len(unique_vals_t))\n and not np.all(unique_vals_p == unique_vals_t)):\n print(name, 'Training values: ', unique_vals_t,\n 'Prediction values:', unique_vals_p)\n raise Exception('Common support variable value error')\n add_vals_in_train = np.setdiff1d(unique_vals_t, unique_vals_p)\n if add_vals_in_train.size > 0:\n for i, val in enumerate(add_vals_in_train):\n x_add_tmp[i, name] = val\n no_change = False\n if no_change:\n return None\n return x_add_tmp\n\n\ndef indicate_off_support(pred_t, pred_p, d_t, c_dict):\n \"\"\"\n Indicate which observations are off support.\n\n Parameters\n ----------\n pred_t : N x no of treat Numpy array. Predictions of treat probs in train.\n pred_p : N x no of treat Numpy array. Predictions of treat probs in pred.\n d_t: N x no of treat Numpy array. Treatment dummies.\n c_dict : Dict. Parameters.\n\n Returns\n -------\n off_support_p : N x 1 Numpy array of boolean. True if obs is off support.\n off_support_t : N x 1 Numpy array of boolean. True if obs is off support.\n upper : No of treatment x 1 Numpy array of float. Upper limits.\n lower : No of treatment x 1 Numpy array of float. Lower limits.\n\n \"\"\"\n # Normalize such that probabilities add up to 1\n pred_t = pred_t / pred_t.sum(axis=1, keepdims=True)\n pred_p = pred_p / pred_p.sum(axis=1, keepdims=True)\n n_p = np.shape(pred_p)[0]\n n_t = np.shape(pred_t)[0]\n q_s = c_dict['support_quantil']\n if c_dict['common_support'] == 1:\n upper_limit = np.empty((c_dict['no_of_treat'], c_dict['no_of_treat']))\n lower_limit = np.empty_like(upper_limit)\n for idx in range(c_dict['no_of_treat']):\n if q_s == 1:\n upper_limit[idx, :] = np.max(pred_t[d_t[:, idx] == 1], axis=0)\n lower_limit[idx, :] = np.min(pred_t[d_t[:, idx] == 1], axis=0)\n else:\n upper_limit[idx, :] = np.quantile(pred_t[d_t[:, idx] == 1],\n q_s, axis=0)\n lower_limit[idx, :] = np.quantile(pred_t[d_t[:, idx] == 1],\n 1-q_s, axis=0)\n if c_dict['with_output']:\n print('Treatment sample Treatment probabilities in %')\n print('--------------------- Upper limits ----------------')\n for idx, ival in enumerate(c_dict['d_values']):\n print('D = {:2}'.format(ival), end=' ')\n for jdx in range(c_dict['no_of_treat']):\n print('{:7.4f} '.format(upper_limit[idx, jdx]), end=' ')\n print(' ')\n print('--------------------- Lower limits ----------------')\n for idx, ival in enumerate(c_dict['d_values']):\n print('D = {:2}'.format(ival), end=' ')\n for jdx in range(c_dict['no_of_treat']):\n print('{:7.4f} '.format(lower_limit[idx, jdx]), end=' ')\n print(' ')\n upper = np.min(upper_limit, axis=0)\n lower = np.max(lower_limit, axis=0)\n else:\n # Normalize such that probabilities add up to 1\n upper = np.ones(\n c_dict['no_of_treat']) * (1 - c_dict['support_min_p'])\n lower = np.ones(c_dict['no_of_treat']) * c_dict['support_min_p']\n off_support_p = np.empty(n_p, dtype=bool)\n off_support_t = np.empty(n_t, dtype=bool)\n off_upper = np.empty(c_dict['no_of_treat'], dtype=bool)\n off_lower = np.empty_like(off_upper)\n for i in range(n_p):\n off_upper = np.any(pred_p[i, :] > upper)\n off_lower = np.any(pred_p[i, :] < lower)\n off_support_p[i] = off_upper or off_lower\n for i in range(n_t):\n off_upper = np.any(pred_t[i, :] > upper)\n off_lower = np.any(pred_t[i, :] < lower)\n off_support_t[i] = off_upper or off_lower\n return off_support_p, off_support_t, upper, lower\n", "meta": {"hexsha": "4efdf6cdcc649b6f98c8d2592a526ff01e70b56a", "size": 19989, "ext": "py", "lang": "Python", "max_stars_repo_path": "mcf/mcf_cs_functions.py", "max_stars_repo_name": "MCFpy/mcf", "max_stars_repo_head_hexsha": "dac9056ed63620e3225903582d50e89af87b6896", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2021-06-19T08:27:17.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-27T17:51:39.000Z", "max_issues_repo_path": "mcf/mcf_cs_functions.py", "max_issues_repo_name": "MCFpy/mcf", "max_issues_repo_head_hexsha": "dac9056ed63620e3225903582d50e89af87b6896", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-07-21T11:40:50.000Z", "max_issues_repo_issues_event_max_datetime": "2021-08-13T11:14:12.000Z", "max_forks_repo_path": "mcf/mcf_cs_functions.py", "max_forks_repo_name": "MCFpy/mcf", "max_forks_repo_head_hexsha": "dac9056ed63620e3225903582d50e89af87b6896", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-11-05T08:08:21.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-19T15:39:09.000Z", "avg_line_length": 45.6369863014, "max_line_length": 79, "alphanum_fraction": 0.5519535745, "include": true, "reason": "import numpy", "num_tokens": 4760, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5428632831725052, "lm_q2_score": 0.3522017684487511, "lm_q1q2_score": 0.19119740835925148}} {"text": "import os\nimport time\nfrom datetime import datetime\n\nimport numpy as np\nimport tensorflow as tf\n\nfrom ops import *\n\n\"\"\"\ncppgan-vae\n\ncompositional pattern-producing generative adversarial network combined with variational autoencoder\n\nUPDATE: modified to get rid of likelihood function, and use pure GAN to draw to correct class.\n\nI learned a lot from studying the below pages:\n\nhttps://github.com/carpedm20/DCGAN-tensorflow\nhttps://jmetzen.github.io/2015-11-27/vae.html\n\nit wouldn't have been possible without referencing those two guy's code!\n\nDescription of CPPNs:\n\nhttps://en.wikipedia.org/wiki/Compositional_pattern-producing_network\n\n\"\"\"\n\n\nclass CPPNResnet:\n def __init__(\n self,\n batch_size=1,\n z_dim=32,\n x_dim=26,\n y_dim=26,\n c_dim=1,\n scale=8.0,\n learning_rate_g=0.01,\n learning_rate_d=0.001,\n learning_rate_vae=0.0001,\n beta1=0.9,\n net_size_g=6,\n net_depth_g=24,\n subnet_depth_g=4,\n net_size_q=512,\n keep_prob=1.0,\n df_dim=32,\n model_name=\"cppn_resnet\",\n grad_clip=5.0,\n logdir=\"save\",\n ):\n \"\"\"\n\n Args:\n z_dim dimensionality of the latent vector\n x_dim, y_dim default resolution of generated images for training\n c_dim 1 for monotone, 3 for colour\n learning_rate_g learning rate for the generator\n _d learning rate for the discriminiator\n _vae learning rate for the variational autoencoder\n net_size_g number of activations per layer for cppn generator function\n net_depth_g depth of generator\n net_size_q number of activations per layer for decoder (real image -> z). 2 layers.\n df_dim discriminiator is a convnet. higher -> more activtions -> smarter.\n keep_prob dropout probability\n\n when training, use I used dropout on training the decoder, batch norm on discriminator, nothing on cppn\n choose training parameters so that over the long run, decoder and encoder log errors hover around 0.7 each (so they are at the same skill level)\n while the error for vae should slowly move lower over time with D and G balanced.\n\n \"\"\"\n\n self.batch_size = batch_size\n self.learning_rate_g = learning_rate_g\n self.learning_rate_d = learning_rate_d\n self.learning_rate_vae = learning_rate_vae\n self.beta1 = beta1\n self.net_size_g = net_size_g\n self.net_size_q = net_size_q\n self.x_dim = x_dim\n self.y_dim = y_dim\n self.scale = scale\n self.c_dim = c_dim\n self.z_dim = z_dim\n self.net_depth_g = net_depth_g\n self.subnet_depth_g = subnet_depth_g\n self.model_name = model_name\n self.keep_prob = keep_prob\n self.df_dim = df_dim\n self.num_class = 11 # 0->9 are MNIST classes, 10 are fake digits.\n self.grad_clip = grad_clip\n self.logdir = logdir\n\n # tf Graph batch of image (batch_size, height, width, depth)\n self.batch = tf.placeholder(tf.float32, [batch_size, x_dim, y_dim, c_dim])\n self.batch_flatten = tf.reshape(self.batch, [batch_size, -1])\n self.batch_label = tf.placeholder(\n tf.float32, [batch_size, self.num_class]\n ) # mnist labels for the batch (one-hot)\n self.fake_label = np.array(\n self.batch_size * [10], dtype=np.int32\n ) # label of fake batches\n self.fake_label_one_hot = self.to_one_hot(self.fake_label)\n\n n_points = x_dim * y_dim\n self.n_points = n_points\n\n self.x_vec, self.y_vec, self.r_vec = self.coordinates(x_dim, y_dim, scale)\n\n # latent vector\n # self.z = tf.placeholder(tf.float32, [self.batch_size, self.z_dim])\n # inputs to cppn, like coordinates and radius from centre\n self.x = tf.placeholder(tf.float32, [self.batch_size, None, 1])\n self.y = tf.placeholder(tf.float32, [self.batch_size, None, 1])\n self.r = tf.placeholder(tf.float32, [self.batch_size, None, 1])\n\n # batch normalization : deals with poor initialization helps gradient flow\n self.d_bn1 = batch_norm(batch_size, name=self.model_name + \"_d_bn1\")\n self.d_bn2 = batch_norm(batch_size, name=self.model_name + \"_d_bn2\")\n\n # Use recognition network to determine mean and\n # (log) variance of Gaussian distribution in latent\n # space\n self.z_mean, self.z_log_sigma_sq = self.encoder()\n\n # Draw one sample z from Gaussian distribution\n eps = tf.random_normal((self.batch_size, self.z_dim), 0, 1, dtype=tf.float32)\n # z = mu + sigma*epsilon\n self.z = tf.add(\n self.z_mean, tf.multiply(tf.sqrt(tf.exp(self.z_log_sigma_sq)), eps)\n )\n\n # Use generator to determine mean of\n # Bernoulli distribution of reconstructed input\n self.G = self.generator()\n # self.batch_reconstruct_flatten = tf.reshape(self.G, [batch_size, -1]) # not needed\n\n self.predict_real_samples = self.discriminator(\n self.batch\n ) # discriminiator on correct examples\n self.predict_fake_samples = self.discriminator(\n self.G, reuse=True\n ) # feed generated images into D\n\n self.create_vae_loss_terms()\n self.create_gan_loss_terms()\n\n self.balanced_loss = (\n 1.0 * self.g_loss + 10.0 * self.vae_loss\n ) # can try to weight these.\n\n self.t_vars = tf.trainable_variables()\n\n self.q_vars = [\n var for var in self.t_vars if (self.model_name + \"_q_\") in var.name\n ]\n self.g_vars = [\n var for var in self.t_vars if (self.model_name + \"_g_\") in var.name\n ]\n self.d_vars = [\n var for var in self.t_vars if (self.model_name + \"_d_\") in var.name\n ]\n self.both_vars = self.q_vars + self.g_vars\n # self.vae_vars = self.q_vars # in this version, g_vars don't concern vae_loss\n\n # clip gradients\n d_opt_real_grads, _ = tf.clip_by_global_norm(\n tf.gradients(self.d_loss_real, self.d_vars), self.grad_clip\n )\n d_opt_grads, _ = tf.clip_by_global_norm(\n tf.gradients(self.d_loss, self.d_vars), self.grad_clip\n )\n g_opt_grads, _ = tf.clip_by_global_norm(\n tf.gradients(self.balanced_loss, self.both_vars), self.grad_clip\n )\n vae_opt_grads, _ = tf.clip_by_global_norm(\n tf.gradients(self.vae_loss, self.q_vars), self.grad_clip\n )\n\n # Use ADAM optimizer\n with tf.variable_scope(self.model_name + \"_opt\", reuse=tf.AUTO_REUSE) as scope:\n d_real_optimizer = tf.train.AdamOptimizer(\n self.learning_rate_d, beta1=self.beta1\n )\n d_optimizer = tf.train.AdamOptimizer(self.learning_rate_d, beta1=self.beta1)\n g_optimizer = tf.train.AdamOptimizer(self.learning_rate_g, beta1=self.beta1)\n vae_optimizer = tf.train.AdamOptimizer(\n self.learning_rate_vae, beta1=self.beta1\n )\n\n self.d_opt_real = d_real_optimizer.apply_gradients(\n zip(d_opt_real_grads, self.d_vars)\n )\n self.d_opt = d_optimizer.apply_gradients(zip(d_opt_grads, self.d_vars))\n self.g_opt = g_optimizer.apply_gradients(zip(g_opt_grads, self.both_vars))\n self.vae_opt = vae_optimizer.apply_gradients(\n zip(vae_opt_grads, self.q_vars)\n )\n\n \"\"\"\n self.d_opt_real = tf.train.AdamOptimizer(self.learning_rate_d, beta1=self.beta1) \\\n .minimize(self.d_loss_real, var_list=self.d_vars)\n self.d_opt = tf.train.AdamOptimizer(self.learning_rate_d, beta1=self.beta1) \\\n .minimize(self.d_loss, var_list=self.d_vars)\n self.g_opt = tf.train.AdamOptimizer(self.learning_rate_g, beta1=self.beta1) \\\n .minimize(self.g_loss, var_list=self.both_vars)\n self.vae_opt = tf.train.AdamOptimizer(self.learning_rate_vae, beta1=self.beta1) \\\n .minimize(self.vae_loss, var_list=self.q_vars)\n \"\"\"\n\n \"\"\"\n tvars = tf.trainable_variables()\n grads, _ = tf.clip_by_global_norm(tf.gradients(self.cost, tvars), args.grad_clip)\n optimizer = tf.train.AdamOptimizer(self.lr, epsilon=0.001)\n self.train_op = optimizer.apply_gradients(zip(grads, tvars))\n \"\"\"\n\n self.init()\n # self.saver = tf.train.Saver(tf.all_variables())\n\n def init(self):\n # Launch the session\n self.sess = tf.InteractiveSession()\n\n # init all vars\n self.all_vars = tf.get_collection_ref(tf.GraphKeys.GLOBAL_VARIABLES)\n self.sess.run(tf.variables_initializer(self.all_vars))\n\n # filter to trainable vars, and include only those in the Saver\n self.trainable_vars = [\n v\n for v in self.all_vars\n if \"beta1_power\" not in v.name and \"beta2_power\" not in v.name\n ]\n self.saver = tf.train.Saver(var_list=self.trainable_vars, max_to_keep=50)\n\n # initialize writer for tensorboard logs\n self.writer = tf.summary.FileWriter(self.logdir)\n\n def reinit(self):\n self.all_vars = tf.get_collection_ref(tf.GraphKeys.GLOBAL_VARIABLES)\n self.sess.run(tf.variables_initializer(self.all_vars))\n\n def to_one_hot(self, label):\n # convert labels, a numpy list of labels (of size batch_size) to the one hot equivalent\n return np.eye(self.num_class)[label]\n\n def create_vae_loss_terms(self):\n # The loss is composed of two terms:\n # 1.) The reconstruction loss (the negative log probability\n # of the input under the reconstructed Bernoulli distribution\n # induced by the decoder in the data space).\n # This can be interpreted as the number of \"nats\" required\n # for reconstructing the input when the activation in latent\n # is given.\n # Adding 1e-10 to avoid evaluatio of log(0.0)\n\n # stop using likelihood function for similarity\n # reconstr_loss = \\\n # -tf.reduce_sum(self.batch_flatten * tf.log(1e-10 + self.batch_reconstruct_flatten)\n # + (1-self.batch_flatten) * tf.log(1e-10 + 1 - self.batch_reconstruct_flatten), 1)\n\n # 2.) The latent loss, which is defined as the Kullback Leibler divergence\n ## between the distribution in latent space induced by the encoder on\n # the data and some prior. This acts as a kind of regularizer.\n # This can be interpreted as the number of \"nats\" required\n # for transmitting the the latent space distribution given\n # the prior.\n\n latent_loss = -0.5 * tf.reduce_sum(\n 1\n + self.z_log_sigma_sq\n - tf.square(self.z_mean)\n - tf.exp(self.z_log_sigma_sq),\n 1,\n )\n\n # self.vae_loss = tf.reduce_mean(reconstr_loss + latent_loss) / self.n_points # average over batch and pixel\n\n # vae loss is now purely kl divergence loss term. let GAN take care of mnist class accuracy.\n self.vae_loss = (\n tf.reduce_mean(latent_loss) / self.n_points\n ) # average over batch and pixel\n self.summ_vae_loss = tf.summary.scalar(\"vae_loss\", self.vae_loss)\n\n def create_gan_loss_terms(self):\n # Define loss function and optimiser\n \"\"\"replace below with class-based disriminiator\n self.d_loss_real = binary_cross_entropy_with_logits(tf.ones_like(self.D_right), self.D_right)\n self.d_loss_fake = binary_cross_entropy_with_logits(tf.zeros_like(self.D_wrong), self.D_wrong)\n self.d_loss = 1.0*(self.d_loss_real + self.d_loss_fake)/ 2.0\n self.g_loss = 1.0*binary_cross_entropy_with_logits(tf.ones_like(self.D_wrong), self.D_wrong)\n \"\"\"\n\n # cross entropy loss of predicting real mnist to real classes\n self.d_loss_real = tf.reduce_mean(\n -tf.reduce_sum(\n self.batch_label * tf.log(self.predict_real_samples),\n reduction_indices=[1],\n )\n )\n # accuracy of using discriminiator as a normal mnist classifier\n self.d_loss_real_accuracy = tf.reduce_mean(\n tf.cast(\n tf.equal(\n tf.argmax(self.predict_real_samples, 1),\n tf.argmax(self.batch_label, 1),\n ),\n tf.float32,\n )\n )\n # cross entropy loss of predicting that fake generated mnist are in fact fake\n self.d_loss_fake = tf.reduce_mean(\n -tf.reduce_sum(\n self.fake_label_one_hot * tf.log(self.predict_fake_samples),\n reduction_indices=[1],\n )\n )\n # accuracy of discriminator predicting a fake mnist digit\n self.d_loss_fake_accuracy = tf.reduce_mean(\n tf.cast(\n tf.equal(\n tf.argmax(self.predict_fake_samples, 1),\n tf.argmax(self.fake_label_one_hot, 1),\n ),\n tf.float32,\n )\n )\n # take the average of two d_loss to be the defacto d_loss\n self.d_loss = (\n 10.0 * self.d_loss_real + self.d_loss_fake\n ) / 11.0 # balance out the classes\n self.summ_d_loss = tf.summary.scalar(\"d_loss\", self.d_loss)\n self.summ_d_loss_fake = tf.summary.scalar(\"d_loss_fake\", self.d_loss_fake)\n self.summ_d_loss_real = tf.summary.scalar(\"d_loss_real\", self.d_loss_real)\n self.summ_d_loss_fake_accuracy = tf.summary.scalar(\n \"d_loss_fake_accuracy\", self.d_loss_fake_accuracy\n )\n self.summ_d_loss_real_accuracy = tf.summary.scalar(\n \"d_loss_real_accuracy\", self.d_loss_real_accuracy\n )\n\n # cross entropy of generator fooling discriminiator that its shit is real.\n self.g_loss = tf.reduce_mean(\n -tf.reduce_sum(\n self.batch_label * tf.log(self.predict_fake_samples),\n reduction_indices=[1],\n )\n )\n # accuracy of generated samples being fooled to be classified as their supposed ground truth labels\n self.g_loss_accuracy = tf.reduce_mean(\n tf.cast(\n tf.equal(\n tf.argmax(self.predict_fake_samples, 1),\n tf.argmax(self.batch_label, 1),\n ),\n tf.float32,\n )\n )\n self.summ_g_loss = tf.summary.scalar(\"g_loss\", self.g_loss)\n self.summ_g_loss_accuracy = tf.summary.scalar(\n \"g_loss_accuracy\", self.g_loss_accuracy\n )\n\n def coordinates(self, x_dim=32, y_dim=32, scale=1.0):\n n_pixel = x_dim * y_dim\n x_range = scale * (np.arange(x_dim) - (x_dim - 1) / 2.0) / (x_dim - 1) / 0.5\n y_range = scale * (np.arange(y_dim) - (y_dim - 1) / 2.0) / (y_dim - 1) / 0.5\n x_mat = np.matmul(np.ones((y_dim, 1)), x_range.reshape((1, x_dim)))\n y_mat = np.matmul(y_range.reshape((y_dim, 1)), np.ones((1, x_dim)))\n r_mat = np.sqrt(x_mat * x_mat + y_mat * y_mat)\n x_mat = np.tile(x_mat.flatten(), self.batch_size).reshape(\n self.batch_size, n_pixel, 1\n )\n y_mat = np.tile(y_mat.flatten(), self.batch_size).reshape(\n self.batch_size, n_pixel, 1\n )\n r_mat = np.tile(r_mat.flatten(), self.batch_size).reshape(\n self.batch_size, n_pixel, 1\n )\n return x_mat, y_mat, r_mat\n\n def show_image(self, image):\n \"\"\"\n image is in [height width depth]\n \"\"\"\n plt.subplot(1, 1, 1)\n y_dim = image.shape[0]\n x_dim = image.shape[1]\n if self.c_dim > 1:\n plt.imshow(image, interpolation=\"nearest\")\n else:\n plt.imshow(\n image.reshape(y_dim, x_dim), cmap=\"Greys\", interpolation=\"nearest\"\n )\n plt.axis(\"off\")\n plt.show()\n\n def encoder(self):\n # Generate probabilistic encoder (recognition network), which\n # maps inputs onto a normal distribution in latent space.\n # The transformation is parametrized and can be learned.\n H1 = tf.nn.dropout(\n tf.nn.softplus(\n linear(self.batch_flatten, self.net_size_q, self.model_name + \"_q_lin1\")\n ),\n self.keep_prob,\n )\n H2 = tf.nn.dropout(\n tf.nn.softplus(linear(H1, self.net_size_q, self.model_name + \"_q_lin2\")),\n self.keep_prob,\n )\n z_mean = linear(H2, self.z_dim, self.model_name + \"_q_lin3_mean\")\n z_log_sigma_sq = linear(\n H2, self.z_dim, self.model_name + \"_q_lin3_log_sigma_sq\"\n )\n return (z_mean, z_log_sigma_sq)\n\n def discriminator(self, image, reuse=False):\n\n if reuse:\n tf.get_variable_scope().reuse_variables()\n\n h0 = lrelu(conv2d(image, self.df_dim, name=self.model_name + \"_d_h0_conv\"))\n h1 = lrelu(\n self.d_bn1(conv2d(h0, self.df_dim * 2, name=self.model_name + \"_d_h1_conv\"))\n )\n h2 = lrelu(\n self.d_bn2(conv2d(h1, self.df_dim * 4, name=self.model_name + \"_d_h2_conv\"))\n )\n h3 = linear(\n tf.reshape(h2, [self.batch_size, -1]),\n self.num_class,\n self.model_name + \"_d_h2_lin\",\n )\n\n return tf.nn.softmax(h3)\n\n def generator(self, gen_x_dim=26, gen_y_dim=26, reuse=False):\n\n if reuse:\n tf.get_variable_scope().reuse_variables()\n\n n_network = self.net_size_g\n gen_n_points = gen_x_dim * gen_y_dim\n\n z_scaled = (\n tf.reshape(self.z, [self.batch_size, 1, self.z_dim])\n * tf.ones([gen_n_points, 1], dtype=tf.float32)\n * self.scale\n )\n z_unroll = tf.reshape(z_scaled, [self.batch_size * gen_n_points, self.z_dim])\n x_unroll = tf.reshape(self.x, [self.batch_size * gen_n_points, 1])\n y_unroll = tf.reshape(self.y, [self.batch_size * gen_n_points, 1])\n r_unroll = tf.reshape(self.r, [self.batch_size * gen_n_points, 1])\n\n U = (\n fully_connected(z_unroll, n_network, self.model_name + \"_g_0_z\")\n + fully_connected(\n x_unroll, n_network, self.model_name + \"_g_0_x\", with_bias=False\n )\n + fully_connected(\n y_unroll, n_network, self.model_name + \"_g_0_y\", with_bias=False\n )\n + fully_connected(\n r_unroll, n_network, self.model_name + \"_g_0_r\", with_bias=False\n )\n )\n\n # H = tf.nn.relu(U)\n H = tf.nn.tanh(U)\n\n for i in range(0, self.net_depth_g):\n H0 = H\n for j in range(0, self.subnet_depth_g):\n H0 = tf.nn.relu(\n fully_connected(\n H0,\n n_network,\n self.model_name + \"_g_relu_skip_\" + str(i) + \"_\" + str(j),\n stddev=1.0,\n )\n )\n H0 = tf.nn.tanh(\n fully_connected(\n H0,\n n_network,\n self.model_name + \"_g_tanh_skip_\" + str(i),\n stddev=0.001,\n )\n )\n H = H + H0\n\n output = tf.sigmoid(\n fully_connected(\n H, self.c_dim, self.model_name + \"_g_\" + str(self.net_depth_g)\n )\n )\n\n result = tf.reshape(output, [self.batch_size, gen_y_dim, gen_x_dim, self.c_dim])\n\n return result\n\n def partial_train(self, batch, label):\n \"\"\"Train model based on mini-batch of input data.\n\n Return cost of mini-batch.\n\n I should really seperate the below tricks into parameters, like number of times/pass\n and also the regulator threshold levels.\n \"\"\"\n\n counter = 0\n\n label_one_hot = self.to_one_hot(label)\n\n \"\"\"\n for i in range(1):\n counter += 1\n _, vae_loss = self.sess.run((self.vae_opt, self.vae_loss),\n feed_dict={self.batch: batch, self.x: self.x_vec, self.y: self.y_vec, self.r: self.r_vec, self.batch_label: label_one_hot})\n \"\"\"\n\n for i in range(16):\n counter += 1\n _, g_loss, vae_loss, g_accuracy = self.sess.run(\n (self.g_opt, self.g_loss, self.vae_loss, self.g_loss_accuracy),\n feed_dict={\n self.batch: batch,\n self.x: self.x_vec,\n self.y: self.y_vec,\n self.r: self.r_vec,\n self.batch_label: label_one_hot,\n },\n )\n if g_accuracy > 0.98:\n break\n\n # train classifier on only real mnist digits\n # _ = self.sess.run((self.d_opt_real), feed_dict={self.batch: batch, self.x: self.x_vec, self.y: self.y_vec, self.r: self.r_vec, self.batch_label: label_one_hot})\n\n # calculate accuracy before deciding whether to train discriminator\n (\n d_loss,\n d_loss_real,\n d_loss_fake,\n d_real_accuracy,\n d_fake_accuracy,\n ) = self.sess.run(\n (\n self.d_loss,\n self.d_loss_real,\n self.d_loss_fake,\n self.d_loss_real_accuracy,\n self.d_loss_fake_accuracy,\n ),\n feed_dict={\n self.batch: batch,\n self.x: self.x_vec,\n self.y: self.y_vec,\n self.r: self.r_vec,\n self.batch_label: label_one_hot,\n },\n )\n\n if (\n d_fake_accuracy < 0.7 and g_accuracy > 0.6\n ): # only train discriminiator if generator is good and d is behind.\n for i in range(8):\n counter += 1\n (\n _,\n d_loss,\n d_loss_real,\n d_loss_fake,\n d_real_accuracy,\n d_fake_accuracy,\n ) = self.sess.run(\n (\n self.d_opt,\n self.d_loss,\n self.d_loss_real,\n self.d_loss_fake,\n self.d_loss_real_accuracy,\n self.d_loss_fake_accuracy,\n ),\n feed_dict={\n self.batch: batch,\n self.x: self.x_vec,\n self.y: self.y_vec,\n self.r: self.r_vec,\n self.batch_label: label_one_hot,\n },\n )\n if d_fake_accuracy > 0.75:\n break\n elif d_real_accuracy < 0.6:\n for i in range(8):\n counter += 1\n _, d_real_accuracy = self.sess.run(\n (self.d_opt_real, self.d_loss_real_accuracy),\n feed_dict={\n self.batch: batch,\n self.x: self.x_vec,\n self.y: self.y_vec,\n self.r: self.r_vec,\n self.batch_label: label_one_hot,\n },\n )\n if d_real_accuracy > 0.7:\n break\n\n return (\n d_loss,\n g_loss,\n vae_loss,\n counter,\n d_real_accuracy,\n d_fake_accuracy,\n g_accuracy,\n d_loss_real,\n d_loss_fake,\n )\n\n def encode(self, X):\n \"\"\"Transform data by mapping it into the latent space.\"\"\"\n # Note: This maps to mean of distribution, we could alternatively\n # sample from Gaussian distribution\n return self.sess.run(self.z_mean, feed_dict={self.batch: X})\n\n def generate(self, z=None, x_dim=26, y_dim=26, scale=5.0):\n \"\"\"Generate data by sampling from latent space.\n\n If z is not None, data for this point in latent space is\n generated. Otherwise, z is drawn from prior in latent\n space.\n \"\"\"\n if z is None:\n z = np.random.normal(size=self.z_dim).astype(np.float32)\n # Note: This maps to mean of distribution, we could alternatively\n # sample from Gaussian distribution\n\n z = np.reshape(z, (self.batch_size, self.z_dim))\n\n G = self.generator(gen_x_dim=x_dim, gen_y_dim=y_dim, reuse=True)\n gen_x_vec, gen_y_vec, gen_r_vec = self.coordinates(x_dim, y_dim, scale=scale)\n image = self.sess.run(\n G,\n feed_dict={\n self.z: z,\n self.x: gen_x_vec,\n self.y: gen_y_vec,\n self.r: gen_r_vec,\n },\n )\n return image\n\n def save_model(self, checkpoint_path, epoch):\n \"\"\" saves the model to a file \"\"\"\n self.saver.save(self.sess, checkpoint_path, global_step=epoch)\n\n def load_model(self, checkpoint_path):\n\n ckpt = tf.train.get_checkpoint_state(checkpoint_path)\n print(\"loading model: \", ckpt.model_checkpoint_path)\n\n # self.saver.restore(self.sess, checkpoint_path+'/'+ckpt.model_checkpoint_path)\n # use the below line for tensorflow 0.7\n self.saver.restore(self.sess, ckpt.model_checkpoint_path)\n\n def close(self):\n self.sess.close()\n", "meta": {"hexsha": "b0091a9aaeaf3d6f931b768ae578a2d3731ca206", "size": 25589, "ext": "py", "lang": "Python", "max_stars_repo_path": "model.py", "max_stars_repo_name": "andrewlook/resnet-cppn-gan-tensorflow", "max_stars_repo_head_hexsha": "92491254795a85c41c1365ed3629f89d45d238d1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "model.py", "max_issues_repo_name": "andrewlook/resnet-cppn-gan-tensorflow", "max_issues_repo_head_hexsha": "92491254795a85c41c1365ed3629f89d45d238d1", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "model.py", "max_forks_repo_name": "andrewlook/resnet-cppn-gan-tensorflow", "max_forks_repo_head_hexsha": "92491254795a85c41c1365ed3629f89d45d238d1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.9096296296, "max_line_length": 170, "alphanum_fraction": 0.5750908594, "include": true, "reason": "import numpy", "num_tokens": 5874, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5428632831725052, "lm_q2_score": 0.35220176844875106, "lm_q1q2_score": 0.19119740835925145}} {"text": "\"\"\"\noptimize.py: Driver and core functions for geometry optimization\n\nCopyright 2016-2020 Regents of the University of California and the Authors\n\nAuthors: Lee-Ping Wang, Chenchen Song\n\nContributors: Yudong Qiu, Daniel G. A. Smith, Alberto Gobbi, Josh Horton\n\nRedistribution and use in source and binary forms, with or without modification,\nare permitted provided that the following conditions are met:\n\n1. Redistributions of source code must retain the above copyright notice,\nthis list of conditions and the following disclaimer.\n\n2. Redistributions in binary form must reproduce the above copyright notice,\nthis list of conditions and the following disclaimer in the documentation\nand/or other materials provided with the distribution.\n \n3. Neither the name of the copyright holder nor the names of its contributors\nmay be used to endorse or promote products derived from this software\nwithout specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\nIN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,\nINDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\nNOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\nPROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,\nWHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\nARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\nPOSSIBILITY OF SUCH DAMAGE.\n\"\"\"\n\nfrom __future__ import print_function, division\n\nimport os\nimport sys\nimport time\nimport traceback\nimport pkg_resources\nfrom copy import deepcopy\n\nimport numpy as np\nfrom numpy.linalg import multi_dot\n\nimport geometric\nfrom .info import print_logo, print_citation\nfrom .internal import CartesianCoordinates, PrimitiveInternalCoordinates, DelocalizedInternalCoordinates\nfrom .ic_tools import check_internal_grad, check_internal_hess, write_displacements\nfrom .normal_modes import calc_cartesian_hessian, frequency_analysis\nfrom .step import brent_wiki, Froot, calc_drms_dmax, get_cartesian_norm, rebuild_hessian, get_delta_prime, trust_step, force_positive_definite\nfrom .prepare import get_molecule_engine, parse_constraints\nfrom .params import OptParams, parse_optimizer_args\nfrom .nifty import row, col, flat, bohr2ang, ang2bohr, logger, bak, createWorkQueue\nfrom .errors import InputError, HessianExit, EngineError, GeomOptNotConvergedError, GeomOptStructureError, LinearTorsionError\n\nclass Optimizer(object):\n def __init__(self, coords, molecule, IC, engine, dirname, params):\n \"\"\"\n Object representing the geometry optimization of a molecular system.\n\n Parameters\n ----------\n coords : np.ndarray\n Nx3 array of Cartesian coordinates in atomic units\n molecule : Molecule\n Molecule object (Units Angstrom)\n IC : InternalCoordinates\n Object describing the internal coordinate system\n engine : Engine\n Object containing methods for calculating energy and gradient\n dirname : str\n Directory name for files to be written\n params : OptParams object\n Contains optimization parameters (really just a struct)\n Includes xyzout and qdata output file names (written if not None)\n \"\"\"\n # Copies of data passed into constructor\n self.coords = coords\n self.molecule = deepcopy(molecule)\n self.IC = IC\n self.engine = engine\n self.dirname = dirname\n self.params = params\n # Set initial value of the trust radius.\n self.trust = self.params.trust\n # Copies of molecule object for preserving the optimization trajectory and the last frame\n self.progress = deepcopy(self.molecule)\n self.progress.xyzs = []\n self.progress.qm_energies = []\n self.progress.qm_grads = []\n self.progress.comms = []\n # Cartesian coordinates\n self.X = self.coords.copy()\n # Loop of optimization\n self.Iteration = 0\n # Counts how many steps it has been since checking the coordinate system\n self.CoordCounter = 0\n # Current state, used to control logic of optimization loop.\n self.state = OPT_STATE.NEEDS_EVALUATION\n # Some more variables to be updated throughout the course of the optimization\n self.trustprint = \"=\"\n self.ForceRebuild = False\n # Sanity check - if there's only one atom, it will probably crash\n if self.molecule.na < 2:\n raise InputError(\"Geometry optimizer assumes there are at least two atoms in the system\")\n\n def get_cartesian_norm(self, dy, verbose=None):\n if not verbose: verbose = self.params.verbose\n return get_cartesian_norm(self.X, dy, self.IC, self.params.enforce, self.params.verbose)\n\n def get_delta_prime(self, v0, verbose=None):\n # This method can be called at a different verbose level than the master\n # because it can occur inside a nested loop\n if not verbose: verbose = self.params.verbose\n return get_delta_prime(v0, self.X, self.G, self.H, self.IC, self.params.transition, verbose)\n\n def createFroot(self, v0):\n return Froot(self.trust, v0, self.X, self.G, self.H, self.IC, self.params)\n\n def refreshCoordinates(self):\n \"\"\"\n Refresh the Cartesian coordinates used to define parts of the internal coordinate system.\n These include definitions of delocalized internal coordinates and reference coordinates for rotators.\n \"\"\"\n logger.info(\"Refreshing coordinate system and resetting rotations\\n\")\n # Resetting of rotations\n self.IC.resetRotations(self.X)\n if isinstance(self.IC, DelocalizedInternalCoordinates):\n self.IC.build_dlc(self.X)\n # With redefined internal coordinates, the Hessian needs to be rebuilt\n self.H0 = self.IC.guess_hessian(self.coords)\n self.rebuild_hessian()\n # Current values of internal coordinates and IC gradient are recalculated\n self.Y = self.IC.calculate(self.X)\n self.G = self.IC.calcGrad(self.X, self.gradx)\n\n def checkCoordinateSystem(self, recover=False, cartesian=False):\n \"\"\"\n Build a new internal coordinate system from current Cartesians and replace the current one if different.\n \"\"\"\n # Reset the check counter\n self.CoordCounter = 0\n # Build a new molecule object and connectivity graph\n newmol = deepcopy(self.molecule)\n newmol.xyzs[0] = self.X.reshape(-1,3) * bohr2ang\n newmol.build_topology()\n # Build the new internal coordinate system\n if cartesian:\n if self.IC.haveConstraints():\n raise ValueError(\"Cannot continue a constrained optimization; please implement constrained optimization in Cartesian coordinates\")\n IC1 = CartesianCoordinates(newmol)\n else:\n IC1 = self.IC.__class__(newmol, connect=self.IC.connect, addcart=self.IC.addcart, build=False, conmethod=self.IC.conmethod)\n if self.IC.haveConstraints(): IC1.getConstraints_from(self.IC)\n # Check for differences\n changed = (IC1 != self.IC)\n if changed:\n logger.info(\"\\x1b[1;94mInternal coordinate system may have changed\\x1b[0m\\n\")\n if self.IC.repr_diff(IC1) != \"\":\n logger.info(self.IC.repr_diff(IC1)+'\\n')\n # Set current ICs to the new one\n if changed or recover or cartesian:\n self.IC = IC1\n self.refreshCoordinates()\n return True\n else: return False\n\n def trust_step(self, iopt, v0, verbose=None):\n # This method can be called at a different verbose level than the master\n # because it can occur inside a nested loop\n if not verbose: verbose = self.params.verbose\n return trust_step(iopt, v0, self.X, self.G, self.H, self.IC, self.params.transition, verbose)\n\n def newCartesian(self, dy):\n if self.IC.haveConstraints() and self.params.enforce:\n self.X = self.IC.newCartesian_withConstraint(self.X, dy, thre=self.params.enforce, verbose=self.params.verbose)\n else:\n self.X = self.IC.newCartesian(self.X, dy, self.params.verbose)\n\n def calcGradNorm(self):\n gradxc = self.IC.calcGradProj(self.X, self.gradx) if self.IC.haveConstraints() else self.gradx.copy()\n atomgrad = np.sqrt(np.sum((gradxc.reshape(-1,3))**2, axis=1))\n rms_gradient = np.sqrt(np.mean(atomgrad**2))\n max_gradient = np.max(atomgrad)\n return rms_gradient, max_gradient\n\n def rebuild_hessian(self):\n self.H = rebuild_hessian(self.IC, self.H0, self.X_hist, self.Gx_hist, self.params)\n\n def frequency_analysis(self, hessian, suffix, afterOpt):\n do_wigner = False\n if self.params.wigner:\n # Wigner sampling should only be performed on the final Hessian calculation of a run\n if self.params.hessian in ['last', 'first+last', 'each'] and afterOpt:\n do_wigner = True\n elif self.params.hessian in ['first', 'stop']:\n do_wigner = True\n if do_wigner:\n logger.info(\"Requesting %i samples from Wigner distribution.\\n\" % self.params.wigner)\n prefix = self.params.xyzout.replace(\"_optim.xyz\", \"\").replace(\".xyz\", \"\")\n # Call the frequency analysis function with an input Hessian, with most arguments populated from self.params\n frequency_analysis(self.X, hessian, self.molecule.elem, energy=self.E, temperature=self.params.temperature, pressure=self.params.pressure, verbose=self.params.verbose, \n outfnm='%s.vdata_%s' % (prefix, suffix), note='Iteration %i Energy % .8f%s' % (self.Iteration, self.E, ' (Optimized Structure)' if afterOpt else ''),\n wigner=((self.params.wigner, os.path.join(self.dirname, 'wigner')) if do_wigner else None))\n\n\n def calcEnergyForce(self):\n \"\"\"\n Calculate the energy and Cartesian gradients of the current structure.\n \"\"\"\n # Check to confirm that the structure has nothing that would cause a cryptic error\n self.checkStructure()\n ### Calculate Energy and Gradient ###\n # Dictionary containing single point properties (energy, gradient)\n # For frequency calculations and multi-step jobs, the gradient from an existing\n # output file may be read in.\n spcalc = self.engine.calc(self.X, self.dirname, read_data=(self.Iteration==0))\n self.E = spcalc['energy']\n self.gradx = spcalc['gradient']\n # Calculate Hessian at the first step, or at each step if desired\n if self.params.hessian == 'each':\n # Hx is assumed to be the Cartesian Hessian at the current step.\n # Otherwise we use the variable name Hx0 to avoid almost certain confusion.\n self.Hx = calc_cartesian_hessian(self.X, self.molecule, self.engine, self.dirname, read_data=True, verbose=self.params.verbose)\n if self.params.frequency:\n self.frequency_analysis(self.Hx, 'iter%03i' % self.Iteration, False)\n elif self.Iteration == 0:\n if self.params.hessian in ['first', 'stop', 'first+last']:\n self.Hx0 = calc_cartesian_hessian(self.X, self.molecule, self.engine, self.dirname, read_data=True, verbose=self.params.verbose)\n if self.params.frequency:\n self.frequency_analysis(self.Hx0, 'first', False)\n if self.params.hessian == 'stop':\n logger.info(\"Exiting as requested after Hessian calculation.\\n\")\n logger.info(\"Cartesian Hessian is stored in %s/hessian/hessian.txt.\\n\" % self.dirname)\n raise HessianExit\n # sys.exit(0)\n elif hasattr(self.params, 'hess_data') and self.Iteration == 0:\n self.Hx0 = self.params.hess_data.copy()\n if self.params.frequency:\n self.frequency_analysis(self.Hx0, 'first', False)\n if self.Hx0.shape != (self.X.shape[0], self.X.shape[0]):\n raise IOError('hess_data passed in via OptParams does not have the right shape')\n # self.Hx = self.Hx0.copy()\n # Add new Cartesian coordinates, energies, and gradients to history\n self.progress.xyzs.append(self.X.reshape(-1,3) * bohr2ang)\n self.progress.qm_energies.append(self.E)\n self.progress.qm_grads.append(self.gradx.copy())\n self.progress.comms.append('Iteration %i Energy % .8f' % (self.Iteration, self.E))\n\n def prepareFirstStep(self):\n \"\"\"\n After computing the initial set of energies and forces, carry out some preparatory tasks\n prior to entering the optimization loop.\n \"\"\"\n # Initial internal coordinates (optimization variables) and internal gradient\n self.Y = self.IC.calculate(self.coords)\n self.G = self.IC.calcGrad(self.X, self.gradx).flatten()\n # Print initial iteration\n rms_gradient, max_gradient = self.calcGradNorm()\n msg = \"Step %4i :\" % self.Iteration\n logger.info(msg + \" Gradient = %.3e/%.3e (rms/max) Energy = % .10f\\n\" % (rms_gradient, max_gradient, self.E))\n # Initial history\n self.X_hist = [self.X]\n self.Gx_hist = [self.gradx]\n # Initial Hessian\n if hasattr(self, 'Hx'):\n # Compute IC Hessian from Cartesian Hessian at the current step\n self.H0 = self.IC.calcHess(self.X, self.gradx, self.Hx)\n elif hasattr(self, 'Hx0'):\n # Compute IC Hessian from input Cartesian Hessian\n self.H0 = self.IC.calcHess(self.X, self.gradx, self.Hx0)\n else:\n # Form guess Hessian if initial Hessian is not provided\n self.H0 = self.IC.guess_hessian(self.coords)\n self.H = self.H0.copy()\n\n def SortedEigenvalues(self):\n Eig = sorted(np.linalg.eigh(self.H)[0])\n if self.params.transition and len(Eig) >= 12:\n # logger.info(\"Hessian Eigenvalues: %.3e %.3e %.3e %.3e %.3e %.3e %.3e %.3e %.3e ... %.3e %.3e %.3e\\n\" %\n # (Eig[0],Eig[1],Eig[2],Eig[3],Eig[4],Eig[5],Eig[6],Eig[7],Eig[8],Eig[-3],Eig[-2],Eig[-1]))\n logger.info(\"Hessian Eigenvalues: % .3e % .3e % .3e % .3e % .3e % .3e % .3e\\n\" % (Eig[0],Eig[1],Eig[2],Eig[3],Eig[4],Eig[5],Eig[6])),\n logger.info(\"% .3e % .3e % .3e % .3e % .3e ..... % .3e % .3e % .3e\\n\" % (Eig[7],Eig[8],Eig[9],Eig[10],Eig[11],Eig[-3],Eig[-2],Eig[-1])),\n elif len(Eig) >= 6:\n logger.info(\"Hessian Eigenvalues: %.5e %.5e %.5e ... %.5e %.5e %.5e\\n\" % (Eig[0],Eig[1],Eig[2],Eig[-3],Eig[-2],Eig[-1]))\n else:\n logger.info(\"Hessian Eigenvalues: \" + ' '.join(\"%.5e\" % i for i in Eig) + '\\n')\n return Eig\n \n def step(self):\n \"\"\"\n Perform one step of the optimization.\n \"\"\"\n params = self.params\n if np.isnan(self.G).any():\n raise RuntimeError(\"Gradient contains nan - check output and temp-files for possible errors\")\n if np.isnan(self.H).any():\n raise RuntimeError(\"Hessian contains nan - check output and temp-files for possible errors\")\n self.Iteration += 1\n if (self.Iteration%5) == 0:\n self.engine.clearCalcs()\n self.IC.clearCache()\n\n # At the start of the loop, the optimization variables, function value, gradient and Hessian are known.\n # (i.e. self.Y, self.E, self.G, self.H)\n if params.verbose: self.IC.printRotations(self.X)\n Eig = self.SortedEigenvalues()\n Emin = Eig[0].real\n if params.transition:\n v0 = 1.0\n elif Emin < params.epsilon:\n v0 = params.epsilon-Emin\n else:\n v0 = 0.0\n # Are we far from constraint satisfaction?\n self.farConstraints = self.IC.haveConstraints() and self.IC.maxConstraintViolation(self.X) > 1e-1\n ### OBTAIN AN OPTIMIZATION STEP ###\n # The trust radius is to be computed in Cartesian coordinates.\n # First take a full-size optimization step\n if params.verbose: logger.info(\" Optimizer.step : Attempting full-size optimization step\\n\")\n dy, _, __ = self.get_delta_prime(v0, verbose=self.params.verbose)\n # Internal coordinate step size\n inorm = np.linalg.norm(dy)\n # Cartesian coordinate step size\n self.cnorm = self.get_cartesian_norm(dy)\n # If the full-size step is within the trust radius, then call get_delta_prime again with diagnostic messages if needed\n if (self.params.verbose >= 2 and self.params.verbose < 4 and self.cnorm <= 1.1*self.trust):\n self.get_delta_prime(v0, verbose=self.params.verbose+2)\n if params.verbose: logger.info(\" Optimizer.step : Internal-step: %.4f Cartesian-step: %.4f Trust-radius: %.4f\\n\" % (inorm, self.cnorm, self.trust))\n # If the step is above the trust radius in Cartesian coordinates, then\n # do the following to reduce the step length:\n if self.cnorm > 1.1 * self.trust:\n # This is the function f(inorm) = cnorm-target that we find a root\n # for obtaining a step with the desired Cartesian step size.\n froot = self.createFroot(v0)\n froot.stores[inorm] = self.cnorm\n ### Find the internal coordinate norm that matches the desired Cartesian coordinate norm\n if params.verbose: logger.info(\" Optimizer.step : Using Brent algorithm to target Cartesian trust radius\\n\")\n iopt = brent_wiki(froot.evaluate, 0.0, inorm, self.trust, cvg=0.1, obj=froot, verbose=params.verbose)\n if froot.brentFailed and froot.stored_arg is not None:\n # If Brent fails but we obtained an IC step that is smaller than the Cartesian trust radius, use it\n if params.verbose: logger.info(\" Optimizer.step : \\x1b[93mUsing stored solution at %.3e\\x1b[0m\\n\" % froot.stored_val)\n iopt = froot.stored_arg\n elif self.IC.bork:\n # Decrease the target Cartesian step size and try again\n for i in range(3):\n froot.target /= 2\n if params.verbose: logger.info(\" Optimizer.step : \\x1b[93mReducing target to %.3e\\x1b[0m\\n\" % froot.target)\n froot.above_flag = True # Stop at any valid step between current target step size and trust radius\n iopt = brent_wiki(froot.evaluate, 0.0, iopt, froot.target, cvg=0.1, verbose=params.verbose)\n if not self.IC.bork: break\n LastForce = self.ForceRebuild\n self.ForceRebuild = False\n if self.IC.bork:\n logger.info(\"\\x1b[91mInverse iteration for Cartesians failed\\x1b[0m\\n\")\n # This variable is added because IC.bork is unset later.\n self.ForceRebuild = True\n else:\n if params.verbose: logger.info(\" Optimizer.step : \\x1b[93mBrent algorithm requires %i evaluations\\x1b[0m\\n\" % froot.counter)\n ##### If IC failed to produce valid Cartesian step, it is \"borked\" and we need to rebuild it.\n if self.ForceRebuild:\n # Force a rebuild of the coordinate system and skip the energy / gradient and evaluation steps.\n if LastForce:\n logger.warning(\"\\x1b[1;91mFailed twice in a row to rebuild the coordinate system; continuing in Cartesian coordinates\\x1b[0m\\n\")\n self.checkCoordinateSystem(recover=True, cartesian=LastForce)\n logger.info(\"\\x1b[1;93mSkipping optimization step\\x1b[0m\\n\")\n self.Iteration -= 1\n self.state = OPT_STATE.SKIP_EVALUATION\n return\n ##### End Rebuild\n # Finally, take an internal coordinate step of the desired length.\n dy, _ = self.trust_step(iopt, v0, verbose=(self.params.verbose+1 if self.params.verbose >= 2 else 0))\n self.cnorm = self.get_cartesian_norm(dy)\n ### DONE OBTAINING THE STEP ###\n if isinstance(self.IC, PrimitiveInternalCoordinates):\n idx = np.argmax(np.abs(dy))\n iunit = np.zeros_like(dy)\n iunit[idx] = 1.0\n self.prim_msg = \"Along %s %.3f\" % (self.IC.Internals[idx], np.dot(dy/np.linalg.norm(dy), iunit))\n ### These quantities, computed previously, are no longer used.\n # Dot product of the gradient with the step direction\n # Dot = -np.dot(dy/np.linalg.norm(dy), self.G/np.linalg.norm(self.G))\n # Whether the Cartesian norm comes close to the trust radius\n # bump = cnorm > 0.8 * self.trust\n ### Before updating any of our variables, copy current variables to \"previous\"\n self.Yprev = self.Y.copy()\n self.Xprev = self.X.copy()\n self.Gxprev = self.gradx.copy()\n self.Gprev = self.G.copy()\n self.Eprev = self.E\n ### Update the Internal Coordinates ###\n X0 = self.X.copy()\n self.newCartesian(dy)\n ## The \"actual\" dy may be different from the one passed to newCartesian(),\n ## for example if we enforce constraints or don't get the step we expect.\n dy = self.IC.calcDiff(self.X, X0)\n # dyp = self.IC.Prims.calcDiff(self.X, X0)\n # print(\"Actual dy:\", dy)\n self.Y += dy\n self.expect = flat(0.5*multi_dot([row(dy),self.H,col(dy)]))[0] + np.dot(dy,self.G)\n self.state = OPT_STATE.NEEDS_EVALUATION\n\n def evaluateStep(self):\n ### At this point, the state should be NEEDS_EVALUATION\n assert self.state == OPT_STATE.NEEDS_EVALUATION\n # Shorthand for self.params\n params = self.params\n # Write current optimization trajectory to file\n if self.params.xyzout is not None: self.progress.write(self.params.xyzout)\n if self.params.qdata is not None: self.progress.write(self.params.qdata, ftype='qdata')\n # Project out the degrees of freedom that are constrained\n rms_gradient, max_gradient = self.calcGradNorm()\n rms_displacement, max_displacement = calc_drms_dmax(self.X, self.Xprev)\n # The ratio of the actual energy change to the expected change\n Quality = (self.E-self.Eprev)/self.expect\n colors = {}\n colors['quality'] = \"\\x1b[0m\"\n # 2020-03-10: Step quality thresholds are hard-coded here.\n # At the moment, no need to set them as variables.\n if params.transition:\n if Quality > 0.8 and Quality < 1.2: step_state = StepState.Good\n elif Quality > 0.5 and Quality < 1.5: step_state = StepState.Okay\n elif Quality > 0.0 and Quality < 2.0: step_state = StepState.Poor\n else:\n colors['energy'] = \"\\x1b[91m\"\n colors['quality'] = \"\\x1b[91m\"\n step_state = StepState.Reject\n else:\n if Quality > 0.75: step_state = StepState.Good\n elif Quality > 0.25: step_state = StepState.Okay\n elif Quality > 0.0: step_state = StepState.Poor\n else:\n colors['energy'] = \"\\x1b[91m\"\n colors['quality'] = \"\\x1b[91m\"\n step_state = StepState.Poor if Quality > -1.0 else StepState.Reject\n # Check convergence criteria\n Converged_energy = np.abs(self.E-self.Eprev) < params.Convergence_energy\n Converged_grms = rms_gradient < params.Convergence_grms\n Converged_gmax = max_gradient < params.Convergence_gmax\n Converged_drms = rms_displacement < params.Convergence_drms\n Converged_dmax = max_displacement < params.Convergence_dmax\n if 'energy' not in colors: colors['energy'] = \"\\x1b[92m\" if Converged_energy else \"\\x1b[0m\"\n colors['grms'] = \"\\x1b[92m\" if Converged_grms else \"\\x1b[0m\"\n colors['gmax'] = \"\\x1b[92m\" if Converged_gmax else \"\\x1b[0m\"\n colors['drms'] = \"\\x1b[92m\" if Converged_drms else \"\\x1b[0m\"\n colors['dmax'] = \"\\x1b[92m\" if Converged_dmax else \"\\x1b[0m\"\n # Molpro defaults for convergence\n Converged_molpro_gmax = max_gradient < params.Convergence_molpro_gmax\n Converged_molpro_dmax = max_displacement < params.Convergence_molpro_dmax\n self.conSatisfied = not self.IC.haveConstraints() or self.IC.maxConstraintViolation(self.X) < 1e-2\n # Print status\n msg = \"Step %4i :\" % self.Iteration\n msg += \" Displace = %s%.3e\\x1b[0m/%s%.3e\\x1b[0m (rms/max)\" % (colors['drms'], rms_displacement, colors['dmax'], max_displacement)\n msg += \" Trust = %.3e (%s)\" % (self.trust, self.trustprint)\n msg += \" Grad%s = %s%.3e\\x1b[0m/%s%.3e\\x1b[0m (rms/max)\" % (\"_T\" if self.IC.haveConstraints() else \"\", colors['grms'], rms_gradient, colors['gmax'], max_gradient)\n logger.info(msg + \" E (change) = % .10f (%s%+.3e\\x1b[0m) Quality = %s%.3f\\x1b[0m\" % (self.E, colors['energy'], self.E-self.Eprev, colors['quality'], Quality) + \"\\n\")\n\n if self.IC is not None and self.IC.haveConstraints():\n self.IC.printConstraints(self.X, thre=1e-3)\n if isinstance(self.IC, PrimitiveInternalCoordinates):\n logger.info(self.prim_msg + '\\n')\n\n ### Check convergence criteria ###\n if Converged_energy and Converged_grms and Converged_drms and Converged_gmax and Converged_dmax and self.conSatisfied:\n self.SortedEigenvalues()\n logger.info(\"Converged! =D\\n\")\n self.state = OPT_STATE.CONVERGED\n return\n\n if self.Iteration > params.maxiter:\n self.SortedEigenvalues()\n logger.info(\"Maximum iterations reached (%i); increase --maxiter for more\\n\" % params.maxiter)\n self.state = OPT_STATE.FAILED\n return\n\n if params.qccnv and Converged_grms and (Converged_drms or Converged_energy) and self.conSatisfied:\n self.SortedEigenvalues()\n logger.info(\"Converged! (Q-Chem style criteria requires grms and either drms or energy)\\n\")\n self.state = OPT_STATE.CONVERGED\n return\n\n if params.molcnv and Converged_molpro_gmax and (Converged_molpro_dmax or Converged_energy) and self.conSatisfied:\n self.SortedEigenvalues()\n logger.info(\"Converged! (Molpro style criteria requires gmax and either dmax or energy)\\nThis is approximate since convergence checks are done in cartesian coordinates.\\n\")\n self.state = OPT_STATE.CONVERGED\n return\n\n assert self.state == OPT_STATE.NEEDS_EVALUATION\n \n ### Adjust Trust Radius and/or Reject Step ###\n prev_trust = self.trust\n if step_state in (StepState.Poor, StepState.Reject):\n new_trust = max(params.tmin, min(self.trust, self.cnorm)/2)\n self.trustprint = \"\\x1b[91m-\\x1b[0m\" if new_trust < self.trust else \"=\"\n self.trust = new_trust\n elif step_state == StepState.Good:\n new_trust = min(params.tmax, np.sqrt(2)*self.trust)\n self.trustprint = \"\\x1b[92m+\\x1b[0m\" if new_trust > self.trust else \"=\"\n self.trust = new_trust\n elif step_state == StepState.Okay:\n self.trustprint = \"=\"\n\n if step_state == StepState.Reject:\n if prev_trust <= params.thre_rj:\n logger.info(\"\\x1b[93mNot rejecting step - trust below %.3e\\x1b[0m\\n\" % params.thre_rj)\n elif (not params.transition) and self.E < self.Eprev:\n logger.info(\"\\x1b[93mNot rejecting step - energy decreases during minimization\\x1b[0m\\n\")\n elif self.farConstraints:\n logger.info(\"\\x1b[93mNot rejecting step - far from constraint satisfaction\\x1b[0m\\n\")\n else:\n logger.info(\"\\x1b[93mStep Is Rejected\\x1b[0m\\n\")\n self.trustprint = \"\\x1b[1;91mx\\x1b[0m\"\n self.Y = self.Yprev.copy()\n self.X = self.Xprev.copy()\n self.gradx = self.Gxprev.copy()\n self.G = self.Gprev.copy()\n self.E = self.Eprev\n return\n\n # Append steps to history (for rebuilding Hessian)\n self.X_hist.append(self.X)\n self.Gx_hist.append(self.gradx)\n\n ### Rebuild Coordinate System if Necessary ###\n UpdateHessian = (not self.params.hessian == 'each')\n if self.IC.bork:\n logger.info(\"Failed inverse iteration - checking coordinate system\\n\")\n self.checkCoordinateSystem(recover=True)\n UpdateHessian = False\n elif self.CoordCounter == (params.check - 1):\n logger.info(\"Checking coordinate system as requested every %i cycles\\n\" % params.check)\n if self.checkCoordinateSystem(): UpdateHessian = False\n else:\n self.CoordCounter += 1\n # Check for large rotations (debugging purposes)\n if self.params.verbose >= 1: self.IC.largeRots()\n # Check for large rotations in linear molecules\n if self.IC.linearRotCheck():\n logger.info(\"Large rotations in linear molecules - refreshing Rotator reference points and DLC vectors\\n\")\n self.refreshCoordinates()\n UpdateHessian = False\n self.G = self.IC.calcGrad(self.X, self.gradx).flatten()\n\n ### Update the Hessian ###\n if UpdateHessian:\n self.UpdateHessian()\n if hasattr(self, 'Hx'):\n self.H = self.IC.calcHess(self.X, self.gradx, self.Hx)\n # Then it's on to the next loop iteration!\n return\n\n def UpdateHessian(self):\n params = self.params\n\n if params.transition:\n ts_bfgs = False\n if ts_bfgs: # pragma: no cover\n logger.info(\"TS-BFGS Hessian update\\n\")\n # yk = Dg; dk = Dy\n dk = col(self.Y - self.Yprev)\n yk = col(self.G - self.Gprev)\n jk = yk - np.dot(self.H, dk)\n B = force_positive_definite(self.H)\n # Scalar 1: dk^T |Bk| dk\n s1 = multi_dot([dk.T, B, dk])\n # Scalar 2: (yk^T dk)^2 + (dk^T |Bk| dk)^2\n s2 = np.dot(yk.T, dk)**2 + s1**2\n # Vector quantities\n v2 = np.dot(yk.T, dk)*yk + s1*np.dot(B, dk)\n uk = v2/s2\n Ek = np.dot(jk, uk.T) + np.dot(uk, jk.T) + np.dot(jk.T, dk) * np.dot(uk, uk.T)\n self.H += Ek\n else:\n Dy = col(self.Y - self.Yprev)\n Dg = col(self.G - self.Gprev)\n # Murtagh-Sargent-Powell update\n Xi = Dg - np.dot(self.H,Dy)\n # ndy2 = np.dot(Dy.T,Dy)\n dH_MS = np.dot(Xi, Xi.T)/np.dot(Dy.T, Xi)\n dH_P = np.dot(Xi, Dy.T) + np.dot(Dy, Xi.T) - np.dot(Dy, Dy.T)*np.dot(Xi.T, Dy)/np.dot(Dy.T, Dy)\n dH_P /= np.dot(Dy.T, Dy)\n phi = 1.0 - np.dot(Dy.T,Xi)**2/(np.dot(Dy.T,Dy)*np.dot(Xi.T,Xi))\n # phi = 1.0\n self.H += (1.0-phi)*dH_MS + phi*dH_P\n if params.verbose:\n logger.info(\"Hessian update: %.5f Powell + %.5f Murtagh-Sargent\\n\" % (phi, 1.0-phi))\n else:\n Dy = col(self.Y - self.Yprev)\n Dg = col(self.G - self.Gprev)\n # Catch some abnormal cases of extremely small changes.\n if np.linalg.norm(Dg) < 1e-6: return\n if np.linalg.norm(Dy) < 1e-6: return\n # BFGS Hessian update\n Mat1 = np.dot(Dg,Dg.T)/np.dot(Dg.T,Dy)[0,0]\n Mat2 = np.dot(np.dot(self.H,Dy), np.dot(self.H,Dy).T)/multi_dot([Dy.T,self.H,Dy])[0,0]\n Eig = np.linalg.eigh(self.H)[0]\n Eig.sort()\n ndy = np.array(Dy).flatten()/np.linalg.norm(np.array(Dy))\n ndg = np.array(Dg).flatten()/np.linalg.norm(np.array(Dg))\n nhdy = np.dot(self.H,Dy).flatten()/np.linalg.norm(np.dot(self.H,Dy))\n if params.verbose:\n msg = \"Denoms: %.3e %.3e\" % (np.dot(Dg.T,Dy)[0,0], multi_dot((Dy.T,self.H,Dy))[0,0])\n msg +=\" Dots: %.3e %.3e\" % (np.dot(ndg, ndy), np.dot(ndy, nhdy))\n #H1 = H.copy()\n self.H += Mat1-Mat2\n Eig1 = np.linalg.eigh(self.H)[0]\n Eig1.sort()\n if params.verbose:\n msg += \" Eig-ratios: %.5e ... %.5e\" % (np.min(Eig1)/np.min(Eig), np.max(Eig1)/np.max(Eig))\n logger.info(msg+'\\n')\n if np.min(Eig1) <= params.epsilon and params.reset:\n logger.info(\"Eigenvalues below %.4e (%.4e) - returning guess\\n\" % (params.epsilon, np.min(Eig1)))\n self.H = self.IC.guess_hessian(self.coords)\n\n def optimizeGeometry(self):\n \"\"\"\n High-level optimization loop.\n This allows calcEnergyForce() to be separated from the rest of the codes\n \"\"\"\n self.calcEnergyForce()\n self.prepareFirstStep()\n while self.state not in [OPT_STATE.CONVERGED, OPT_STATE.FAILED]:\n self.step()\n if self.state == OPT_STATE.NEEDS_EVALUATION:\n self.calcEnergyForce()\n self.evaluateStep()\n if self.state == OPT_STATE.FAILED:\n raise GeomOptNotConvergedError(\"Optimizer.optimizeGeometry() failed to converge.\")\n # If we want to save the Hessian used by the optimizer (in Cartesian coordinates)\n if self.params.write_cart_hess:\n # One last Hessian update before writing it out\n self.UpdateHessian()\n logger.info(\"Saving current approximate Hessian (Cartesian coordinates) to %s\" % self.params.write_cart_hess)\n Hx = self.IC.calcHessCart(self.X, self.G, self.H)\n np.savetxt(self.params.write_cart_hess, Hx, fmt='% 14.10f')\n if self.params.hessian in ['last', 'first+last', 'each']:\n Hx = calc_cartesian_hessian(self.X, self.molecule, self.engine, self.dirname, read_data=False, verbose=self.params.verbose)\n if self.params.frequency:\n self.frequency_analysis(Hx, 'last', True)\n return self.progress\n\n def checkStructure(self):\n \"\"\"\n A function that checks for problematic structures and throws an error before\n calling any QC method.\n \"\"\"\n # Check for three consecutive atoms in torsion angle becoming linear\n torsion_constraint_linear_angles = self.IC.torsionConstraintLinearAngles(self.X)\n if torsion_constraint_linear_angles:\n errorStr = \"> Atoms Angle\\n\"\n for key, val in torsion_constraint_linear_angles.items():\n errorStr += \"> %i-%i-%i %6.2f\\n\" % (key[0]+1, key[1]+1, key[2]+1, val)\n raise LinearTorsionError(\"A constrained torsion has three consecutive atoms\\n\"\n \"forming a nearly linear angle, making the torsion angle poorly defined.\\n\"+errorStr)\n \n\nclass OPT_STATE(object):\n \"\"\" This describes the state of an OptObject during the optimization process\n \"\"\"\n NEEDS_EVALUATION = 0 # convergence has not been evaluated -> calcualte Energy, Forces\n SKIP_EVALUATION = 1 # We know this is not yet converged -> skip Energy\n CONVERGED = 2\n FAILED = 3 # optimization failed with no recovery option\n\nclass StepState(object):\n \"\"\" This describes the state of an OptObject during the optimization process\n \"\"\"\n Reject = 0 # Reject the step\n Poor = 1 # Poor step; decrease the trust radius down to the lower limit.\n Okay = 2 # Okay step; do not change the trust radius.\n Good = 3 # Good step; increase the trust radius up to the limit.\n \ndef Optimize(coords, molecule, IC, engine, dirname, params):\n \"\"\"\n Optimize the geometry of a molecule. This function used to contain the whole\n optimization loop, which has since been moved to the Optimizer() class;\n now a wrapper and kept for compatibility.\n\n Parameters\n ----------\n coords : np.ndarray\n Nx3 array of Cartesian coordinates in atomic units\n molecule : Molecule\n Molecule object\n IC : InternalCoordinates\n Object describing the internal coordinate system\n engine : Engine\n Object containing methods for calculating energy and gradient\n dirname : str\n Directory name for files to be written\n params : OptParams object\n Contains optimization parameters (really just a struct)\n hessian : np.ndarray, optional\n 3Nx3N array of Cartesian Hessian of initial structure\n\n Returns\n -------\n progress: Molecule\n A molecule object for opt trajectory and energies\n \"\"\"\n optimizer = Optimizer(coords, molecule, IC, engine, dirname, params)\n return optimizer.optimizeGeometry()\n\ndef run_optimizer(**kwargs):\n \"\"\"\n Run geometry optimization, constrained optimization, or\n constrained scan job given arguments from command line.\n \"\"\"\n #==============================#\n #| Log file configuration |#\n #==============================#\n # By default, output should be written to .log and also printed to the terminal.\n # This behavior may be changed by editing the log.ini file.\n # Output will only be written to log files after the 'logConfig' line is called!\n if kwargs.get('logIni') is None:\n import geometric.optimize\n logIni = pkg_resources.resource_filename(geometric.optimize.__name__, 'config/log.ini')\n else:\n logIni = kwargs.get('logIni')\n logfilename = kwargs.get('prefix')\n # Input file for optimization; QC input file or OpenMM .xml file\n inputf = kwargs.get('input')\n verbose = kwargs.get('verbose', False)\n # Get calculation prefix and temporary directory name\n arg_prefix = kwargs.get('prefix', None) #prefix for output file and temporary directory\n prefix = arg_prefix if arg_prefix is not None else os.path.splitext(inputf)[0]\n logfilename = prefix + \".log\"\n # Create a backup if the log file already exists\n backed_up = bak(logfilename)\n import logging.config\n logging.config.fileConfig(logIni,defaults={'logfilename': logfilename},disable_existing_loggers=False)\n #==============================#\n #| End log file configuration |#\n #==============================#\n\n import geometric\n logger.info('geometric-optimize called with the following command line:\\n')\n logger.info(' '.join(sys.argv)+'\\n')\n print_logo(logger)\n logger.info('-=# \\x1b[1;94m geomeTRIC started. Version: %s \\x1b[0m #=-\\n' % geometric.__version__)\n if backed_up:\n logger.info('Backed up existing log file: %s -> %s\\n' % (logfilename, os.path.basename(backed_up)))\n\n t0 = time.time()\n\n # Create the params object, containing data to be passed into the optimizer\n params = OptParams(**kwargs)\n params.printInfo()\n\n # Create \"dirname\" folder for writing\n dirname = prefix+\".tmp\"\n if not os.path.exists(dirname):\n os.makedirs(dirname)\n kwargs['dirname'] = dirname\n \n # Get the Molecule and engine objects needed for optimization\n M, engine = get_molecule_engine(**kwargs)\n\n # Create Work Queue object\n if kwargs.get('port', 0):\n logger.info(\"Creating Work Queue object for distributed Hessian calculation\\n\")\n createWorkQueue(kwargs['port'], debug=verbose>1)\n\n # Get initial coordinates in bohr\n coords = M.xyzs[0].flatten() * ang2bohr\n\n # Read in the constraints\n constraints = kwargs.get('constraints', None) #Constraint input file (optional)\n\n if constraints is not None:\n Cons, CVals = parse_constraints(M, open(constraints).read())\n else:\n Cons = None\n CVals = None\n\n #=========================================#\n #| Set up the internal coordinate system |#\n #=========================================#\n # First item in tuple: The class to be initialized\n # Second item in tuple: Whether to connect nonbonded fragments\n # Third item in tuple: Whether to throw in all Cartesians (no effect if second item is True)\n CoordSysDict = {'cart':(CartesianCoordinates, False, False),\n 'prim':(PrimitiveInternalCoordinates, True, False),\n 'dlc':(DelocalizedInternalCoordinates, True, False),\n 'hdlc':(DelocalizedInternalCoordinates, False, True),\n 'tric-p':(PrimitiveInternalCoordinates, False, False),\n 'tric':(DelocalizedInternalCoordinates, False, False)}\n coordsys = kwargs.get('coordsys', 'tric')\n CoordClass, connect, addcart = CoordSysDict[coordsys.lower()]\n\n IC = CoordClass(M, build=True, connect=connect, addcart=addcart, constraints=Cons, cvals=CVals[0] if CVals is not None else None,\n conmethod=params.conmethod)\n #========================================#\n #| End internal coordinate system setup |#\n #========================================#\n\n # Auxiliary functions (will not do optimization):\n displace = kwargs.get('displace', False) # Write out the displacements of the coordinates.\n if displace:\n write_displacements(coords, M, IC, dirname, verbose)\n return\n\n fdcheck = kwargs.get('fdcheck', False) # Check internal coordinate gradients using finite difference..\n if fdcheck:\n IC.Prims.checkFiniteDifferenceGrad(coords)\n IC.Prims.checkFiniteDifferenceHess(coords)\n check_internal_grad(coords, M, IC.Prims, engine, dirname, verbose)\n check_internal_hess(coords, M, IC.Prims, engine, dirname, verbose)\n return\n\n # Print out information about the coordinate system\n if isinstance(IC, CartesianCoordinates):\n logger.info(\"%i Cartesian coordinates being used\\n\" % (3*M.na))\n else:\n logger.info(\"%i internal coordinates being used (instead of %i Cartesians)\\n\" % (len(IC.Internals), 3*M.na))\n logger.info(IC)\n logger.info(\"\\n\")\n\n if Cons is None:\n # Run a standard geometry optimization\n params.xyzout = prefix+\"_optim.xyz\"\n progress = Optimize(coords, M, IC, engine, dirname, params)\n else:\n # Run a single constrained geometry optimization or scan over a grid of values\n if isinstance(IC, (CartesianCoordinates, PrimitiveInternalCoordinates)):\n raise RuntimeError(\"Constraints only work with delocalized internal coordinates\")\n Mfinal = None\n for ic, CVal in enumerate(CVals):\n if len(CVals) > 1:\n logger.info(\"---=== Scan %i/%i : Constrained Optimization ===---\\n\" % (ic+1, len(CVals)))\n IC = CoordClass(M, build=True, connect=connect, addcart=addcart, constraints=Cons, cvals=CVal, conmethod=params.conmethod)\n IC.printConstraints(coords, thre=-1)\n if len(CVals) > 1:\n params.xyzout = prefix+\"_scan-%03i.xyz\" % (ic+1)\n # In the special case of a constraint scan, we write out multiple qdata.txt files\n if params.qdata is not None: params.qdata = 'qdata_scan-%03i.txt' % (ic+1)\n else:\n params.xyzout = prefix+\"_optim.xyz\"\n if ic == 0:\n progress = Optimize(coords, M, IC, engine, dirname, params)\n else:\n progress += Optimize(coords, M, IC, engine, dirname, params)\n # update the structure for next optimization in SCAN (by CNH)\n M.xyzs[0] = progress.xyzs[-1]\n coords = progress.xyzs[-1].flatten() * ang2bohr\n if Mfinal:\n Mfinal += progress[-1]\n else:\n Mfinal = progress[-1]\n cNames = IC.getConstraintNames()\n cVals = IC.getConstraintTargetVals()\n comment = ', '.join([\"%s = %.2f\" % (cName, cVal) for cName, cVal in zip(cNames, cVals)])\n Mfinal.comms[-1] = \"Scan Cycle %i/%i ; %s ; %s\" % (ic+1, len(CVals), comment, progress.comms[-1])\n #print\n if len(CVals) > 1:\n Mfinal.write('scan-final.xyz')\n if params.qdata is not None: Mfinal.write('qdata-final.txt')\n print_citation(logger)\n logger.info(\"Time elapsed since start of run_optimizer: %.3f seconds\\n\" % (time.time()-t0))\n return progress\n\ndef main(): # pragma: no cover\n # Read user input (look in params.py for full list of options).\n # args is a dictionary containing only user-specified arguments\n # (i.e. keys without provided values are removed.)\n args = parse_optimizer_args(sys.argv[1:])\n\n # Run the optimizer.\n try:\n run_optimizer(**args)\n except EngineError:\n logger.info(\"EngineError:\\n\" + traceback.format_exc())\n sys.exit(51)\n except GeomOptNotConvergedError:\n logger.info(\"Geometry Converge Failed Error:\\n\" + traceback.format_exc())\n sys.exit(50)\n except GeomOptStructureError:\n logger.info(\"Structure Error:\\n\" + traceback.format_exc())\n sys.exit(50)\n except HessianExit:\n logger.info(\"Exiting normally.\\n\")\n sys.exit(0)\n except:\n logger.info(\"Unknown Error:\\n\" + traceback.format_exc())\n raise\n\nif __name__ == \"__main__\":\n main()\n", "meta": {"hexsha": "7fea845d0ac92f83cf209e5e3a865224d49d5b9d", "size": 45320, "ext": "py", "lang": "Python", "max_stars_repo_path": "geometric/optimize.py", "max_stars_repo_name": "AnthoniAlcaraz/geomeTRIC", "max_stars_repo_head_hexsha": "de6d688a7c4928b7afe89493b3cb8cfc25d580f1", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "geometric/optimize.py", "max_issues_repo_name": "AnthoniAlcaraz/geomeTRIC", "max_issues_repo_head_hexsha": "de6d688a7c4928b7afe89493b3cb8cfc25d580f1", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "geometric/optimize.py", "max_forks_repo_name": "AnthoniAlcaraz/geomeTRIC", "max_forks_repo_head_hexsha": "de6d688a7c4928b7afe89493b3cb8cfc25d580f1", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 50.8071748879, "max_line_length": 184, "alphanum_fraction": 0.625419241, "include": true, "reason": "import numpy,from numpy", "num_tokens": 10968, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5888891163376235, "lm_q2_score": 0.3242353989809524, "lm_q1q2_score": 0.19093869759126986}} {"text": "# Radau ODE system\nfrom __future__ import division, absolute_import, print_function\n\nimport imp\n\nfrom .allimports import *\nfrom PyDSTool.Generator import ODEsystem as ODEsystem\nfrom .baseclasses import theGenSpecHelper, genDB, _pollInputs\nfrom .mixins import CompiledMixin, full_path\nfrom PyDSTool.utils import *\nfrom PyDSTool.common import *\n# for future cleanup of * imports\nfrom PyDSTool import utils\nfrom PyDSTool import common\nfrom PyDSTool.ModelSpec import QuantSpec\nfrom PyDSTool.integrator import integrator\nimport numpy as npy\n\n# Other imports\nfrom numpy import Inf, NaN, isfinite, int, int32, float, float64, \\\n sometrue, alltrue, any, all, concatenate, transpose, array, zeros\nimport operator\nfrom copy import copy, deepcopy\n\n\nclass radau(integrator):\n \"\"\"Radau 5 specialization of the basic integrator class.\"\"\"\n\n def __init__(self, modname, rhs='default_name', phaseDim=0, paramDim=0,\n nAux=0, nEvents=0, nExtInputs=0, hasJac=0, hasJacP=0,\n hasMass=0, extraSpace=0, defaultBound=1e8):\n integrator.__init__(self, rhs=rhs, phaseDim=phaseDim, paramDim=paramDim,\n nAux=nAux, nEvents=nEvents, nExtInputs=nExtInputs, hasJac=hasJac,\n hasJacP=hasJacP, hasMass=hasMass, extraSpace=extraSpace,\n defaultBound=defaultBound)\n self.modname = modname\n try:\n self._integMod = imp.load_module(\n modname, *imp.find_module(modname, [\"radau5_temp\"]))\n except:\n print(\"Error in importing compiled vector field and integrator.\")\n print(\"Did you compile the RHS C code?\")\n raise\n # check module's directory\n assert 'Integrate' in dir(self._integMod), \\\n \"radau library does not contain Integrate()\"\n\n self.safety = []\n self.jacRecompute = []\n self.newtonStop = []\n self.stepChangeLB = []\n self.stepChangeUB = []\n self.stepSizeLB = []\n self.stepSizeUB = []\n self.hessenberg = []\n self.maxNewton = []\n self.newtonStart = []\n self.index1dim = []\n self.index2dim = []\n self.index3dim = []\n self.stepSizeStrategy = []\n self.DAEstructureM1 = []\n self.DAEstructureM2 = []\n\n retval = self._integMod.InitBasic(self.phaseDim, self.paramDim, self.nAux,\n self.nEvents, self.nExtInputs, self.hasJac,\n self.hasJacP, self.hasMass, self.extraSpace)\n\n if retval[0] != 1:\n raise PyDSTool_InitError('Call to InitBasic failed! (radau)')\n\n self.initBasic = True\n\n\n def Run(self, hinit=0, hmax=1.0, checkAux=0, calcSpecTimes=0, verbose=0,\n safety=0.9, jacRecompute=0.001, newtonStop=-1, stepChangeLB=1,\n stepChangeUB=1.2, stepSizeLB=0.2, stepSizeUB=8.0, hessenberg=0,\n maxNewton=7, newtonStart=0, index1dim=-1, index2dim=0, index3dim=0,\n stepSizeStrategy=1, DAEstructureM1=0, DAEstructureM2=0, useJac=0, useMass=0):\n if not self.initBasic:\n raise PyDSTool_InitError('initBasic is False (radau)')\n if not self.initEvents:\n raise PyDSTool_InitError('initEvents is False (radau)')\n if not self.initIntegrate:\n raise PyDSTool_InitError('initInteg is False (radau)')\n if not self.setParams:\n raise PyDSTool_InitError('setParams is False (radau)')\n if self.nExtInputs > 0 and not self.initExtInputs:\n raise PyDSTool_InitError('initExtInputs is False (radau)')\n\n self.setRadauParams(hinit=hinit, hmax=hmax, checkAux=checkAux,\n calcSpecTimes=calcSpecTimes,\n verbose=verbose, safety=safety,\n jacRecompute=jacRecompute, newtonStop=newtonStop,\n stepChangeLB=stepChangeLB, stepChangeUB=stepChangeUB,\n stepSizeLB=stepSizeLB, stepSizeUB=stepSizeUB,\n hessenberg=hessenberg,maxNewton=maxNewton,\n newtonStart=newtonStart, index1dim=index1dim,\n index2dim=index2dim, index3dim=index3dim,\n stepSizeStrategy=stepSizeStrategy,\n DAEstructureM1=DAEstructureM1,\n DAEstructureM2=DAEstructureM2,\n useJac=useJac,useMass=useMass)\n\n # For a run, we want to ensure indices are set to 0\n self.Reset()\n T, P, A, Stats, H, Err, EvtT, EvtP = self._integMod.Integrate(self.ic,\n self.t0,\n self.hinit,\n self.hmax,\n self.safety,\n self.jacRecompute,\n self.newtonStop,\n self.stepChangeLB,\n self.stepChangeUB,\n self.stepSizeLB,\n self.stepSizeUB,\n self.hessenberg,\n self.maxNewton,\n self.newtonStart,\n self.index1dim,\n self.index2dim,\n self.index3dim,\n self.stepSizeStrategy,\n self.DAEstructureM1,\n self.DAEstructureM2,\n self.useJac,\n self.useMass,\n self.verbose,\n self.checkAux,\n self.calcSpecTimes)\n self.points = P\n self.times = T\n self.auxPoints = A\n self.eventTimes = EvtT\n self.eventPoints = EvtP\n self.errors = Err\n self.stats = Stats\n self.step = H\n\n try:\n self.lastTime = self.times[-1]\n self.lastPoint = [self.points[i][-1] for i in range(self.phaseDim)]\n self.lastStep = self.step\n except IndexError:\n self.lastTime = self.t0\n self.lastPoint = self.ic\n self.lastStep = self.hinit\n self.numRuns += 1\n self.canContinue = True\n\n return T, P, A, Stats, H, Err, EvtT, EvtP\n\n\n def Continue(self, tend, params=[], calcSpecTimes=0, verbose=0,\n extInputChanged=False, extInputVals=[], extInputTimes=[],\n bounds=[]):\n if not self.initBasic:\n raise PyDSTool_InitError('initBasic is False (radau)')\n if not self.initEvents:\n raise PyDSTool_InitError('initEvents is False (radau)')\n if not self.initIntegrate:\n raise PyDSTool_InitError('initInteg is False (radau)')\n if not self.setParams:\n raise PyDSTool_InitError('setParams is False (radau)')\n if self.nExtInputs > 0 and not self.initExtInputs:\n raise PyDSTool_InitError('initExtInputs is False (radau)')\n\n if not self.canContinue:\n raise PyDSTool_ContError('Unable to continue trajectory -- '\n 'have you run the integrator and reset events, etc?')\n\n self.setContParams(tend=tend, params=copy(params),\n calcSpecTimes=calcSpecTimes, verbose=verbose, extInputChanged=extInputChanged,\n extInputVals=copy(extInputVals), extInputTimes=copy(extInputTimes),\n bounds=copy(bounds))\n\n # For a continue, we do not set indices to 0\n T, P, A, Stats, H, Err, EvtT, EvtP = \\\n self._integMod.Integrate(self.lastPoint,\n self.lastTime,\n self.lastStep, self.hmax,\n self.safety,\n self.jacRecompute,\n self.newtonStop,\n self.stepChangeLB,\n self.stepChangeUB,\n self.stepSizeLB,\n self.stepSizeUB,\n self.hessenberg,\n self.maxNewton,\n self.newtonStart,\n self.index1dim,\n self.index2dim,\n self.index3dim,\n self.stepSizeStrategy,\n self.DAEstructureM1,\n self.DAEstructureM2,\n self.useJac,\n self.useMass,\n self.verbose,\n self.checkAux,\n self.calcSpecTimes)\n\n self.points = P\n self.times = T\n self.auxPoints = A\n self.eventTimes = EvtT\n self.eventPoints = EvtP\n self.errors = Err\n self.stats = Stats\n self.step = H\n\n try:\n self.lastTime = self.times[-1]\n self.lastPoint = [self.points[i][-1] for i in range(self.phaseDim)]\n self.lastStep = self.step\n except IndexError:\n self.lastTime = self.t0\n self.lastPoint = self.ic\n self.lastStep = self.hinit\n self.numRuns += 1\n self.numContinues += 1\n self.canContinue = True\n\n return T, P, A, Stats, H, Err, EvtT, EvtP\n\n\n def setRadauParams(self, hinit, hmax, checkAux, calcSpecTimes,\n verbose, safety, jacRecompute, newtonStop,\n stepChangeLB, stepChangeUB, stepSizeLB, stepSizeUB,\n hessenberg, maxNewton, newtonStart, index1dim,\n index2dim, index3dim, stepSizeStrategy,\n DAEstructureM1, DAEstructureM2, useJac, useMass):\n useJac = int(useJac)\n useMass = int(useMass)\n checkAux = int(checkAux)\n calcSpecTimes = int(calcSpecTimes)\n hessenberg = int(hessenberg)\n\n if not isinstance(hinit, _num_types):\n raise TypeError(\"hinit must be int, float\")\n\n if not isinstance(hmax, _num_types):\n raise TypeError(\"hmax must be int, float\")\n\n if abs(hinit) > abs(hmax):\n raise ValueError(\"Abs value of hinit (%g) must be less than hmax (%g)\"%(hinit,hmax))\n\n if not isinstance(checkAux, _int_types):\n raise TypeError(\"checkAux must be int\")\n if checkAux not in (0,1):\n raise TypeError(\"checkAux must be 0 or 1\")\n if checkAux == 1 and self.nAux <= 0:\n raise ValueError(\"checkAux cannot be 1 if nAux is 0\")\n\n if not isinstance(verbose, _int_types):\n raise TypeError(\"verbose must be int\")\n if verbose not in (0,1):\n if verbose >= 2:\n # interpret all greater values as 1\n verbose = 1\n else:\n raise TypeError(\"verbose must be 0 or 1\")\n\n if not isinstance(calcSpecTimes, _int_types):\n raise TypeError(\"calcSpecTimes must be int\")\n if calcSpecTimes not in (0,1):\n raise TypeError(\"calcSpecTimes must be 0 or 1\")\n if calcSpecTimes == 1 and len(self.specTimes) <= 0:\n raise ValueError(\"calcSpecTimes cannot be 1 if specTimes is empty\")\n\n if safety < 0:\n raise ValueError(\"safety must be non-negative\")\n if jacRecompute <= 0.0:\n raise ValueError(\"jacRecompute must be positive\")\n if newtonStop < 0:\n newtonStop = 0\n if stepChangeLB <= 0:\n raise ValueError(\"stepChangeLB must be positive\")\n if stepChangeUB <= 0:\n raise ValueError(\"stepChangeUB must be positive\")\n if stepSizeLB <= 0:\n raise ValueError(\"stepSizeLB must be positive\")\n if stepSizeUB <= 0:\n raise ValueError(\"stepSizeUB must be positive\")\n\n if stepChangeLB > stepChangeUB: # was >= but this allows fac1=fac2=1\n raise ValueError(\"stepChangeLB must be less than stepChangeUB\")\n if stepSizeLB >= stepSizeUB:\n raise ValueError(\"stepSizeLB must be less than stepSizeUB\")\n\n if hessenberg not in (0,1):\n raise ValueError(\"hessenberg must be 0 or 1\")\n if hessenberg == 1 and useMass != 0:\n raise ValueError(\"hessenberg form cannot be used for implicit systems (mass matrix)\")\n if not isinstance(maxNewton, _int_types):\n raise TypeError(\"maxNewton must be int\")\n if maxNewton <= 0:\n raise ValueError(\"maxNewton must be positive\")\n\n if newtonStart not in (0,1):\n raise ValueError(\"newtonStart must be 0 or 1\")\n\n if index1dim <= 0:\n index1dim = self.phaseDim\n if index2dim != 0:\n raise ValueError(\"Currently index2dim must be 0\")\n if index3dim != 0:\n raise ValueError(\"Currently index3dim must be 0\")\n\n if stepSizeStrategy not in (1,2):\n raise ValueError(\"stepSizeStrategy must be 1 or 2\")\n\n if DAEstructureM1 != 0:\n raise ValueError(\"Currently DAEstructureM1 must be 0\")\n if DAEstructureM2 != 0:\n raise ValueError(\"Currently DAEstructureM2 must be 0\")\n\n if useJac not in (0,1):\n raise ValueError(\"useJac must be 0 or 1\")\n if useMass not in (0,1):\n raise ValueError(\"useMass must be 0 or 1\")\n\n if useJac == 1 and self.hasJac != 1:\n raise ValueError(\"useJac must be 0 if hasJac is not 1\")\n if useMass == 1 and self.hasMass != 1:\n raise ValueError(\"useMass must be 0 if hasMass is not 1\")\n\n self.hinit = hinit\n self.hmax = hmax\n self.safety = safety\n self.jacRecompute = jacRecompute\n self.newtonStop = newtonStop\n self.stepChangeLB = stepChangeLB\n self.stepChangeUB = stepChangeUB\n self.stepSizeLB = stepSizeLB\n self.stepSizeUB = stepSizeUB\n self.hessenberg = hessenberg\n self.maxNewton = maxNewton\n self.newtonStart = newtonStart\n self.index1dim = index1dim\n self.index2dim = index2dim\n self.index3dim = index3dim\n self.stepSizeStrategy = stepSizeStrategy\n self.DAEstructureM1 = DAEstructureM1\n self.DAEstructureM2 = DAEstructureM2\n self.useJac = useJac\n self.useMass = useMass\n self.verbose = verbose\n self.checkAux = checkAux\n self.calcSpecTimes = calcSpecTimes\n\n\nclass Radau_ODEsystem(ODEsystem, CompiledMixin):\n \"\"\"Wrapper for Radau integrator (with support for differential-algebraic equations).\n\n Uses C target language only for functional specifications\"\"\"\n _paraminfo = {'rtol': 'Relative error tolerance.',\n 'atol': 'Absolute error tolerance.',\n 'safety': 'Safety factor in the step size prediction, default 0.9.',\n 'max_step': 'Maximal step size, default tend-tstart.',\n 'init_step': 'Initial step size, default is a guess computed by the function init_step.',\n 'fac1': 'Parameter for step size selection; the new step size is chosen subject to the restriction fac1 <= new_step/old_step <= fac2. Default value is 1.0.',\n 'fac2': 'Parameter for step size selection; the new step size is chosen subject to the restriction fac1 <= new_step/old_step <= fac2. Default value is 1.2.',\n 'stepLB': '',\n 'stepUB': '',\n 'refine': 'Refine output by adding points interpolated using the RK4 polynomial (0, 1 or 2).',\n 'step_strategy': \"\"\"Switch for step size strategy;\nIf step_strategy=1 mod. predictive controller (Gustafsson).\nIf step_strategy=2 classical step size control.\nThe default value (for step_strategy=0) is step_strategy=1.\nthe choice step_strategy=1 seems to produce safer results;\nfor simple problems, the choice step_strategy=2 produces\noften slightly faster runs.\"\"\",\n 'jac_recompute': \"\"\"Decides whether the Jacobian should be recomputed;\nincrease jac_recompute to 0.1 say, when Jacobian evaluations\nare costly. for small systems jac_recompute should be smaller\n(0.001, say). negative jac_recompute forces the code to\ncompute the Jacobian after every accepted step.\nDefault 0.001.\"\"\",\n 'newton_start': \"\",\n 'newton_stop': \"\",\n 'max_newton': \"Maximum number of Newton iterations to take in solving the implicit system at each step (default 7)\",\n 'DAEstructureM1': \"\",\n 'DAEstructureM2': \"\",\n 'hessenberg': \"\",\n 'index1dim': \"\",\n 'index2dim': \"\",\n 'index3dim': \"\",\n 'use_special': \"Switch for using special times\",\n 'specialtimes': \"List of special times to use during integration\",\n 'check_aux': \"Switch\",\n 'extraspace': \"\"\n }\n\n def __init__(self, kw):\n \"\"\"Use the nobuild key to postpone building of the library, e.g. in\n order to provide additional build options to makeLibSource and\n compileLib methods or to make changes to the C code by hand.\n No build options can be specified otherwise.\"\"\"\n\n # delete because not covered in ODEsystem\n nobuild = kw.pop('nobuild', False)\n ODEsystem.__init__(self, kw)\n self._solver = None\n self.diagnostics._errorcodes = {\n 0: 'Unrecognized error code returned (see stderr output)',\n -1 : 'input is not consistent',\n -2 : 'larger nmax is needed',\n 2 : 'larger nmax or maxevtpts is probably needed (error raised by solout)',\n -3 : 'step size becomes too small',\n -4 : 'the matrix is repeatedly singular (interrupted)',\n -8 : 'The solution exceeded a magbound (poor choice of initial step)'}\n self.diagnostics.outputStatsInfo = {\n 'last_step': 'Predicted step size of the last accepted step (useful for a subsequent call to radau).',\n 'num_steps': 'Number of used steps.',\n 'num_accept': 'Number of accepted steps.',\n 'num_reject': 'Number of rejected steps.',\n 'num_fcns': 'Number of function evaluations.',\n 'num_jacs': 'Number of Jacobian evaluations.',\n 'num_dec': 'Number of LU-decompositions',\n 'num_subs': 'Number of forward-backward substitutions',\n 'errorStatus': 'Error status on completion.'\n }\n\n # currently the final four of these params are for event handling\n algparams_def = {'poly_interp': False,\n 'init_step': 0,\n 'max_step': 0,\n 'rtol': [1e-9 for i in range(self.dimension)],\n 'atol': [1e-12 for i in range(self.dimension)],\n 'fac1': 1.0,\n 'fac2': 1.2,\n 'stepLB': 0.2,\n 'stepUB': 8.0,\n 'safety': 0.9,\n 'max_pts': 10000,\n 'refine': 0,\n 'maxbisect': [], # for events\n 'maxevtpts': 1000, # for events\n 'eventInt': [], # set using setEventInterval only\n 'eventDelay': [], # set using setEventDelay only\n 'eventTol': [], # set using setEventTol only\n 'use_special': 0,\n 'specialtimes': [],\n 'check_aux': 1,\n 'extraspace': 100,\n 'verbose': 0,\n 'jac_recompute': 0.001,\n 'step_strategy': 1,\n 'index1dim': -1,\n 'index2dim': 0,\n 'index3dim': 0,\n 'DAEstructureM1': 0,\n 'DAEstructureM2': 0,\n 'hessenberg': 0,\n 'newton_start': 0,\n 'newton_stop': -1,\n 'max_newton': 7,\n 'hasJac': 0,\n 'hasJacP': 0,\n 'checkBounds': self.checklevel\n }\n for k, v in algparams_def.items():\n if k not in self.algparams:\n self.algparams[k] = v\n # verify that no additional keys are present in algparams, after\n # defaults are added above\n if len(self.algparams) != len(algparams_def):\n raise ValueError(\"Invalid keys present in algparams argument: \" \\\n + str(remain(self.algparams.keys(),algparams_def.keys())))\n # Check for non-constant mass matrix\n if self.haveMass():\n mspec = self.funcspec.auxfns['massMatrix']\n lensig = len(mspec[1])\n body_str = mspec[0][lensig:].replace('\\n','')\n qbody = QuantSpec('__body__', body_str, treatMultiRefs=False,\n ignoreSpecial=['[',']','{','}'])\n self._const_massmat = intersect(['Y_','t'], qbody.usedSymbols) == []\n else:\n self._const_massmat = True\n\n self._prepareEventSpecs()\n self._inputVarList = []\n self._inputTimeList = []\n\n if nobuild:\n print(\"Build the library using the makeLib method, or in \")\n print(\"stages using the makeLibSource and compileLib methods.\")\n else:\n self.makeLib()\n\n @property\n def integrator(self):\n return {\n 'name': ('radau5' if self._const_massmat else 'radau5v', 'Radau'),\n 'description': \"Radau5 integrator\" + \\\n \"\" if self._const_massmat else \" (version for non-constant mass matrices)\",\n 'src': [\"radau5mod.c\"],\n 'cflags': [\"-D__RADAU__\"],\n 'libs': [\n ('radau5', {\n 'sources': full_path(['radau5.f' if self._const_massmat else 'radau5v.f']),\n 'extra_f77_compile_args': utils.extra_arch_arg(['-w']),\n }),\n ('lapack_lite', {\n 'sources': full_path(['lapackc.f', 'lapack.f', 'dc_lapack.f']),\n 'extra_f77_compile_args': utils.extra_arch_arg(['-w']),\n })\n ],\n }\n\n def _prepareEventSpecs(self):\n eventActive = []\n eventTerm = []\n eventDir = []\n eventDelay = []\n eventTol = []\n maxbisect = []\n eventInt = []\n # convert event specs (term, active, etc.) into integparam specs\n self._eventNames = self.eventstruct.sortedEventNames()\n for evname in self._eventNames:\n ev = self.eventstruct.events[evname]\n assert isinstance(ev, LowLevelEvent), (\"Radau can only \"\n \"accept low level events\")\n # if event 'precise' flags set to False then set their tolerances\n # to be > max_step\n maxstep = self.algparams['max_step']\n for evname in self._eventNames:\n ev = self.eventstruct.events[evname]\n eventActive.append(int(ev.activeFlag))\n eventTerm.append(int(ev.termFlag))\n eventDir.append(ev.dircode)\n eventInt.append(ev.eventinterval)\n eventDelay.append(ev.eventdelay)\n if ev.preciseFlag:\n eventTol.append(ev.eventtol)\n maxbisect.append(ev.bisectlimit)\n else:\n eventTol.append(maxstep*1.5)\n maxbisect.append(1)\n self.algparams['eventTol'] = eventTol\n self.algparams['eventDelay'] = eventDelay\n self.algparams['eventInt'] = eventInt\n self.algparams['maxbisect'] = maxbisect\n self.algparams['eventActive'] = eventActive\n self.algparams['eventTerm'] = eventTerm\n self.algparams['eventDir'] = eventDir\n\n def compute(self, trajname, dirn='f', ics=None):\n continue_integ = ODEsystem.prepDirection(self, dirn)\n if ics is not None:\n self.set(ics=ics)\n self.validateICs()\n self.diagnostics.clearWarnings()\n self.diagnostics.clearErrors()\n if isinstance(self.algparams['rtol'], list):\n if len(self.algparams['rtol']) != self.dimension:\n raise ValueError('rtol list must have same length as phase dimension')\n else:\n rtol = self.algparams['rtol']\n self.algparams['rtol'] = [rtol for i in range(self.dimension)]\n if isinstance(self.algparams['atol'], list):\n if len(self.algparams['atol']) != self.dimension:\n raise ValueError('atol list must have same length as phase dimension')\n else:\n atol = self.algparams['atol']\n self.algparams['atol'] = [atol for i in range(self.dimension)]\n anames = self.funcspec.auxvars\n # Check i.c.'s are well defined (finite)\n self.checkInitialConditions()\n self.setEventICs(self.initialconditions, self.globalt0)\n # update event params in case changed since last run\n self._prepareEventSpecs()\n # Main integration\n t0 = self.indepvariable.depdomain[0]\n t1 = self.indepvariable.depdomain[1]\n plist = sortedDictValues(self.pars)\n self.algparams['hasJac'] = self.haveJacobian()\n self.algparams['hasJacP'] = self.haveJacobian_pars()\n self._ensure_solver()\n if self._dircode == 1:\n tbegin = t0\n tend = t1\n elif self._dircode == -1:\n # radau does reverse time integration simply by switching t0 and t1\n tbegin = t1\n tend = t0\n if len(self.algparams['specialtimes'])>0:\n use_special = self.algparams['use_special']\n else:\n use_special = 0\n bounds = [[],[]] # lower, then upper\n for v in self.funcspec.vars:\n bds = self.xdomain[v]\n try:\n bounds[0].append(bds[0])\n bounds[1].append(bds[1])\n except TypeError:\n print(\"%r %s %r\" % (v, type(bds), bds))\n print(self.xdomain)\n raise\n for p in self.funcspec.pars:\n bds = self.pdomain[p]\n try:\n bounds[0].append(bds[0])\n bounds[1].append(bds[1])\n except TypeError:\n print(\"%s %r\" % (type(bds), bds))\n raise\n if continue_integ:\n x0 = self._solver.lastPoint\n # overwrite t0 from self.indepvariable.domain, but use its t1\n tbegin = self._solver.lastTime\n if abs(self._solver.lastStep) < abs(self.algparams['init_step']):\n self.algparams['init_step'] = self._solver.lastStep\n if abs(t1-tbegin) < abs(self.algparams['init_step']):\n raise ValueError(\"Integration end point too close to initial \"\n \"point\")\n# if self.inputs and self._extInputsChanged:\n# self._extInputsChanged = False\n# self._solver.setContParams(tend, plist,\n# use_special,\n# self.algparams['verbose'],\n# True, deepcopy(self._inputVarList),\n# deeppcopy(self._inputTimeList))\n else:\n if self._solver.numRuns > 0:\n self._solver.clearAll()\n x0 = sortedDictValues(self.initialconditions, self.funcspec.vars)\n self._solver.setInteg(maxpts=self.algparams['max_pts'],\n rtol=self.algparams['rtol'], atol=self.algparams['atol'])\n self._solver.setRunParams(ic=x0, params=plist,\n t0=tbegin, tend=tend, gt0=self.globalt0,\n refine=self.algparams['refine'],\n specTimes=self.algparams['specialtimes'],\n bounds=bounds)\n if self.inputs:\n # self._extInputsChanged if global t0 changed so that can\n # adjust times given to the integrator (it is blind to global t0\n # when accesses input variable times)\n self._ensure_inputs(self._extInputsChanged)\n # hinit only set if not continue_integ\n if len(anames)>0:\n check_aux = self.algparams['check_aux']\n else:\n check_aux = 0\n if self.algparams['max_step'] == 0:\n max_step = abs(tend-tbegin)\n else:\n max_step = self.algparams['max_step']\n init_step = self.algparams['init_step']\n if self._dircode == 1:\n if init_step < 0:\n init_step = -init_step\n if max_step < 0:\n max_step = -max_step\n else:\n if init_step > 0:\n init_step = -init_step\n if max_step > 0:\n max_step = -max_step\n if continue_integ:\n # record needed for bounds checking and truncation\n old_highest_ix = self._solver.points.shape[1]\n alltData, X, A, Stats, H, Err, Evtimes, \\\n Evpoints = self._solver.Continue(tend, plist,\n use_special, self.algparams['verbose'],\n self._extInputsChanged,\n deepcopy(self._inputVarList),\n deepcopy(self._inputTimeList), bounds)\n else:\n old_highest_ix = 0\n self._solver.setEvents(eventActive=self.algparams['eventActive'],\n eventTerm=self.algparams['eventTerm'],\n eventDir=self.algparams['eventDir'],\n eventDelay=self.algparams['eventDelay'],\n eventInt=self.algparams['eventInt'],\n eventTol=self.algparams['eventTol'],\n maxevtpts=self.algparams['maxevtpts'],\n maxbisect=self.algparams['maxbisect'])\n alltData, X, A, Stats, H, Err, Evtimes, \\\n Evpoints = self._solver.Run(init_step,\n max_step,\n check_aux,\n use_special,\n self.algparams['verbose'],\n self.algparams['safety'],\n self.algparams['jac_recompute'],\n self.algparams['newton_stop'],\n self.algparams['fac1'],\n self.algparams['fac2'],\n self.algparams['stepLB'],\n self.algparams['stepUB'],\n self.algparams['hessenberg'],\n self.algparams['max_newton'],\n self.algparams['newton_start'],\n self.algparams['index1dim'],\n self.algparams['index2dim'],\n self.algparams['index3dim'],\n self.algparams['step_strategy'],\n self.algparams['DAEstructureM1'],\n self.algparams['DAEstructureM2'],\n self.haveJacobian(),\n self.haveMass())\n self._extInputsChanged = False # reset this now\n self.diagnostics.outputStats = {'last_step': H,\n 'last_time': self._solver.lastTime,\n 'last_point': self._solver.lastPoint,\n 'num_fcns': Stats[0],\n 'num_jacs': Stats[1],\n 'num_steps': Stats[2],\n 'num_accept': Stats[3],\n 'num_reject': Stats[4],\n 'num_dec': Stats[5],\n 'num_subs': Stats[6],\n 'errorStatus': Err\n }\n if self._dircode == -1:\n # reverse the array object (no reverse method!)\n alltData = alltData[::-1]\n X = X[:,::-1]\n if anames != []:\n A = A[:,::-1]\n xnames = self._var_ixmap\n # Package up computed trajectory in Variable variables\n # Add external inputs warnings to self.diagnostics.warnings, if any\n## for f in inputVarList:\n## for winfo in f.diagnostics.warnings:\n## self.diagnostics.warnings.append((W_NONTERMSTATEBD,\n## (winfo[0], f.name, winfo[1],\n## f.depdomain)))\n eventslist = self.eventstruct.query(['lowlevel', 'active'])\n termevents = self.eventstruct.query(['term'], eventslist)\n if self._eventNames != []:\n # build self.diagnostics.warnings because events happened --\n # and keep a record of which times terminal events happened because\n # Model.py's event handling procedure assumes multiple events\n # happening at one time are listed in one warning\n termevtimes = {}\n nontermevtimes = {}\n try:\n for evix in range(len(self._eventNames)):\n if Evpoints[evix] is None:\n continue\n evname = self._eventNames[evix]\n numevs = len(Evtimes[evix])\n if self.algparams['eventTerm'][evix]:\n if numevs > 1:\n print(\"Event info: %r %r\" % (Evpoints, Evtimes))\n assert numevs <= 1, (\"Internal error: more than one \"\n \"terminal event of same type found\")\n # For safety, we should assert that this event\n # also appears in termevents, but we don't\n if Evtimes[evix][0] in termevtimes.keys():\n # append event name to this warning\n warning_ix = termevtimes[Evtimes[evix][0]]\n self.diagnostics.warnings[warning_ix][1][1].append(evname)\n else:\n # make new termevtime entry for the new warning\n termevtimes[Evtimes[evix][0]] = \\\n len(self.diagnostics.warnings)\n self.diagnostics.warnings.append((W_TERMEVENT,\n (Evtimes[evix][0],\n [evname])))\n else:\n for ev in range(numevs):\n if Evtimes[evix][ev] in nontermevtimes.keys():\n # append event name to this warning\n warning_ix = nontermevtimes[Evtimes[evix][ev]]\n self.diagnostics.warnings[warning_ix][1][1].append(evname)\n else:\n # make new nontermevtime entry for the new warning\n nontermevtimes[Evtimes[evix][ev]] = \\\n len(self.diagnostics.warnings)\n self.diagnostics.warnings.append((W_NONTERMEVENT,\n (Evtimes[evix][ev],\n [evname])))\n except IndexError:\n print(\"Events returned from integrator are the wrong size.\")\n print(\" Did you change the system and not refresh the C \" \\\n + \"library using the forcelibrefresh() method?\")\n raise\n termcount = 0\n for (w,i) in self.diagnostics.warnings:\n if w == W_TERMEVENT or w == W_TERMSTATEBD:\n if termcount > 0:\n raise ValueError(\"Internal error: more than one terminal \"\n \"event found\")\n termcount += 1\n # post-process check of variable bounds (if defined and algparams['checkBounds'] True)\n if self._dircode > 0:\n compare = operator.lt\n last_ix = Inf\n else:\n compare = operator.gt\n last_ix = -Inf\n highest_ix = X.shape[1]-1\n last_t = Inf\n if self.algparams['checkBounds'] > 0:\n # temp storage for repeatedly used object attributes (for lookup efficiency)\n depdomains = dict(zip(range(self.dimension),\n [self.variables[xn].depdomain for xn in xnames]))\n offender_ix = None\n for xi in range(self.dimension):\n if not any(depdomains[xi].isfinite()):\n # no point in checking when the bounds are +/- infinity\n continue\n next_last_ix = array_bounds_check(X[xi][old_highest_ix:],\n depdomains[xi], self._dircode) + old_highest_ix\n if compare(next_last_ix, last_ix):\n # won't count as truncating unless the following checks\n # hold\n last_ix = next_last_ix\n offender_ix = xi\n if not isfinite(last_ix) and last_ix < 0:\n # only use +Inf hereon to flag no truncation needed\n last_ix = Inf\n elif last_ix >= 0 and last_ix < highest_ix:\n # truncate data\n last_t = alltData[last_ix]\n print(\"Warning; domain bound reached (because algparams['checkBounds'] > 0)\")\n self.diagnostics.warnings.append((W_TERMSTATEBD,\n (last_t, xnames[offender_ix],\n X[offender_ix, last_ix],\n depdomains[offender_ix].get())))\n # Create variables (self.variables contains no actual data)\n variables = copyVarDict(self.variables)\n # build event pointset information (reset previous trajectory's)\n # don't include events after any truncation due to state bound violation\n self.trajevents = {}\n for evix in range(len(self._eventNames)):\n evname = self._eventNames[evix]\n if Evpoints[evix] is None:\n self.trajevents[evname] = None\n else:\n try:\n ev_a_list = []\n for t in Evtimes[evix]:\n tix = find(alltData, t)\n ev_a_list.append(A[:,tix])\n ev_array = concatenate((Evpoints[evix],\n transpose(array(ev_a_list, 'd'))))\n del ev_a_list, tix\n except TypeError:\n # A is empty\n ev_array = Evpoints[evix]\n if last_ix >= 0 and last_ix < highest_ix:\n # don't count last_ix = -1 which is the same as highest_ix\n last_ev_tix = npy.argmax(Evtimes[evix] >= alltData[last_ix])\n if last_ev_tix == 0 and Evtimes[evix][0] >= last_t:\n # checks that there was actually a violation\n # - so no events to record\n self.trajevents[evname] = None\n else:\n # truncation needed\n ev_array = ev_array[:, :last_ev_tix+1]\n ev_times = Evtimes[evix][:last_ev_tix+1]\n self.trajevents[evname] = Pointset({'coordnames': xnames+anames,\n 'indepvarname': 't',\n 'coordarray': ev_array,\n 'indepvararray': ev_times})\n else:\n # no truncation needed\n self.trajevents[evname] = Pointset({'coordnames': xnames+anames,\n 'indepvarname': 't',\n 'coordarray': ev_array,\n 'indepvararray': Evtimes[evix]})\n if last_ix >= 0 and last_ix < highest_ix:\n # truncate\n X = X[:, :last_ix]\n alltData = alltData[:last_ix]\n try:\n allxDataDict = dict(zip(xnames,X))\n except IndexError:\n print(\"Integration returned variable values of unexpected dimensions.\")\n print(\" Did you change the system and not refresh the C library\" \\\n + \" using the forcelibrefresh() method?\")\n raise\n # storage of all auxiliary variable data\n anames = self.funcspec.auxvars\n try:\n if anames != []:\n if last_ix < highest_ix:\n A = A[:, :last_ix]\n try:\n allaDataDict = dict(zip(anames,A))\n except TypeError:\n print(\"Internal error! Type of A: %s\" % type(A))\n raise\n except IndexError:\n print(\"Integration returned auxiliary values of unexpected dimensions.\")\n print(\" Did you change the system and not refresh the C library\" \\\n + \" using the forcelibrefresh() method?\")\n raise\n if int(Err) == 1 or (int(Err) == 2 and termcount == 1):\n # output OK\n if self.algparams['poly_interp']:\n rhsfn = self._solver.Rhs\n # when Dopri can output the Rhs values alongside variable\n # values then this won't be necessary\n dxvals = zeros((len(alltData),self.dimension),float)\n for tix, tval in enumerate(alltData):\n # solver's Rhs function already contains the inputs so no\n # need to recompute and provide here.\n #i = _pollInputs(sortedDictValues(self.inputs), tval,\n # self.checklevel)\n # X is the output variable array, but rhsfn demands a list\n dxvals[tix] = rhsfn(tval, list(X[:,tix]), plist)[0]\n for xi, x in enumerate(xnames):\n if len(alltData) > 1:\n if self.algparams['poly_interp']:\n interp = PiecewisePolynomial(alltData,\n array([allxDataDict[x], dxvals[:,xi]]).T, 2)\n else:\n interp = interp1d(alltData, allxDataDict[x])\n variables[x] = Variable(interp, 't', x, x)\n else:\n raise PyDSTool_ValueError(\"Fewer than 2 data points computed\")\n for a in anames:\n if len(alltData) > 1:\n variables[a] = Variable(interp1d(alltData,allaDataDict[a]),\n 't', a, a)\n else:\n raise PyDSTool_ValueError(\"Fewer than 2 data points computed\")\n # final checks\n #self.validateSpec()\n self.defined = True\n return Trajectory(trajname, list(variables.values()),\n abseps=self._abseps, globalt0=self.globalt0,\n checklevel=self.checklevel,\n FScompatibleNames=self._FScompatibleNames,\n FScompatibleNamesInv=self._FScompatibleNamesInv,\n events=self.trajevents,\n modelNames=self.name,\n modelEventStructs=self.eventstruct)\n else:\n try:\n diagnost_info = self.diagnostics._errorcodes[int(Err)]\n except TypeError:\n # errcode messed up from Radau\n print(\"Error code: %d\" % Err)\n diagnost_info = self.diagnostics._errorcodes[0]\n if self._solver.verbose:\n info(self.diagnostics.outputStats, \"Output statistics\")\n self.defined = False\n # Did the solver run out of memory?\n if (len(alltData) == self.algparams['max_pts'] or \\\n self.diagnostics.outputStats['num_steps'] >= self.algparams['max_pts']) \\\n and alltData[-1] < tend:\n print(\"max_pts algorithmic parameter too small: current \" + \\\n \"value is %i\"%self.algparams['max_pts'])\n# avstep = (self.algparams['init_step']+self.diagnostics.outputStats['last_step'])/2.\n if self.diagnostics.outputStats['last_time']-tbegin > 0:\n ms = str(int(round(self.algparams['max_pts'] / \\\n (self.diagnostics.outputStats['last_time'] - \\\n tbegin)*(tend-tbegin))))\n else:\n ms = 'Inf'\n print(\"(recommended value for this trajectory segment is \" + \\\n \"estimated to be %s (saved in diagnostics.errors attribute))\"%str(ms))\n diagnost_info += \" -- recommended value is \" + ms\n self.diagnostics.errors.append((E_COMPUTFAIL,\n (self._solver.lastTime, diagnost_info)))\n raise PyDSTool_ExistError(\"No trajectory created\")\n\n\n def Rhs(self, t, xdict, pdict=None, asarray=True):\n \"\"\"asarray is an unused, dummy argument for compatibility with Model.Rhs\"\"\"\n # must convert names to FS-compatible as '.' sorts before letters\n # while '_' sorts after!\n x = sortedDictValues(filteredDict(self._FScompatibleNames(xdict),\n self.funcspec.vars))\n if pdict is None:\n pdict = self.pars\n # internal self.pars already is FS-compatible\n p = sortedDictValues(pdict)\n else:\n p = sortedDictValues(self._FScompatibleNames(pdict))\n i = _pollInputs(sortedDictValues(self.inputs),\n t, self.checklevel)\n self._ensure_solver({'params': p, 't0': 0, 'tend': 1})\n self._ensure_inputs()\n return self._solver.Rhs(t, x, p+i)[0]\n\n\n def Jacobian(self, t, xdict, pdict=None, asarray=True):\n \"\"\"asarray is an unused, dummy argument for compatibility with\n Model.Jacobian\"\"\"\n if self.haveJacobian():\n x = sortedDictValues(filteredDict(self._FScompatibleNames(xdict),\n self.funcspec.vars))\n if pdict is None:\n pdict = self.pars\n # internal self.pars already is FS-compatible\n p = sortedDictValues(pdict)\n else:\n p = sortedDictValues(self._FScompatibleNames(pdict))\n i = _pollInputs(sortedDictValues(self.inputs),\n t, self.checklevel)\n self._ensure_solver({'params': p, 't0': 0, 'tend': 1})\n self._ensure_inputs()\n return self._solver.Jacobian(t, x, p+i)[0]\n else:\n raise PyDSTool_ExistError(\"Jacobian not defined\")\n\n\n def JacobianP(self, t, xdict, pdict=None, asarray=True):\n \"\"\"asarray is an unused, dummy argument for compatibility with\n Model.JacobianP\"\"\"\n if self.haveJacobian_pars():\n x = sortedDictValues(filteredDict(self._FScompatibleNames(xdict),\n self.funcspec.vars))\n if pdict is None:\n pdict = self.pars\n # internal self.pars already is FS-compatible\n p = sortedDictValues(pdict)\n else:\n p = sortedDictValues(self._FScompatibleNames(pdict))\n i = _pollInputs(sortedDictValues(self.inputs),\n t, self.checklevel)\n self._ensure_solver({'params': p, 't0': 0, 'tend': 1})\n self._ensure_inputs()\n return self._solver.JacobianP(t, x, p+i)[0]\n else:\n raise PyDSTool_ExistError(\"Jacobian w.r.t. parameters not defined\")\n\n\n def AuxVars(self, t, xdict, pdict=None, asarray=True):\n \"\"\"asarray is an unused, dummy argument for compatibility with\n Model.AuxVars\"\"\"\n x = sortedDictValues(filteredDict(self._FScompatibleNames(xdict),\n self.funcspec.vars))\n if pdict is None:\n pdict = self.pars\n # internal self.pars already is FS-compatible\n p = sortedDictValues(pdict)\n else:\n p = sortedDictValues(self._FScompatibleNames(pdict))\n i = _pollInputs(sortedDictValues(self.inputs),\n t, self.checklevel)\n self._ensure_solver({'params': p, 't0': 0, 'tend': 1})\n self._ensure_inputs()\n return self._solver.AuxFunc(t, x, p+i)[0]\n\n\n def MassMatrix(self, t, xdict, pdict=None, asarray=True):\n \"\"\"asarray is an unused, dummy argument for compatibility with\n Model.MassMatrix\"\"\"\n if self.haveMass():\n x = sortedDictValues(filteredDict(self._FScompatibleNames(xdict),\n self.funcspec.vars))\n if pdict is None:\n pdict = self.pars\n # internal self.pars already is FS-compatible\n p = sortedDictValues(pdict)\n else:\n p = sortedDictValues(self._FScompatibleNames(pdict))\n i = _pollInputs(sortedDictValues(self.inputs),\n t, self.checklevel)\n self._ensure_solver({'params': p, 't0': 0, 'tend': 1})\n self._ensure_inputs()\n return self._solver.MassMatrix(t, x, p+i)[0]\n else:\n raise PyDSTool_ExistError(\"Mass matrix not defined\")\n\n\n def _ensure_solver(self, pars=None):\n if self._solver is None:\n x0 = sortedDictValues(filteredDict(self.initialconditions, self.funcspec.vars))\n# _integMod = self._ensureLoaded(self.modname)\n self._solver = radau(self.modname,\n rhs=self.name, phaseDim=self.dimension,\n paramDim=self.numpars,\n nAux=len(self.funcspec.auxvars),\n nEvents=len(self._eventNames),\n nExtInputs=len(self.inputs),\n hasJac=self.haveJacobian(),\n hasJacP=self.haveJacobian_pars(),\n hasMass=self.haveMass(),\n extraSpace=self.algparams['extraspace'])\n try:\n genDB.register(self)\n except PyDSTool_KeyError:\n errstr = \"Generator \" + self.name + \": this vector field's \" +\\\n \"DLL is already in use\"\n raise RuntimeError(errstr)\n if pars is not None:\n # tend value doesn't matter\n self._solver.setRunParams(\n ic=sortedDictValues(filteredDict(self.initialconditions,\n self.funcspec.vars)),\n params=pars['params'],\n t0=pars['t0'], tend=pars['tend'],\n gt0=self.globalt0,\n refine=0, specTimes=[])\n\n def _ensure_inputs(self, force=False):\n if not self.inputs:\n return\n if force:\n listOK = False\n else:\n try:\n listOK = self._inputTimest0 == self.globalt0\n except AttributeError:\n # not yet defined, so proceed\n listOK = False\n if not listOK:\n self._inputVarList = []\n self._inputTimeList = []\n self._inputTimest0 = self.globalt0\n # inputVarList is a list of Variables or Pointsets\n for inp in sortedDictValues(self.inputs):\n if isinstance(inp, Variable):\n pts = inp.getDataPoints()\n if pts is None:\n raise TypeError(\"Can only pass external input Variable objects if based on\"\n \" an underlying mesh\")\n else:\n tvals = copy(pts[inp.indepvarname])\n tvals -= self.globalt0\n self._inputVarList.append(pts[inp.coordname].tolist())\n self._inputTimeList.append(tvals.tolist())\n elif isinstance(inp, Pointset):\n tvals = copy(inp.indepvararray)\n tvals -= self.globalt0\n self._inputVarList.append(inp[inp.coordname].tolist())\n self._inputTimeList.append(tvals.tolist())\n else:\n raise TypeError(\"Invalid type of input\")\n if not self._solver.initExtInputs:\n self._solver.setExtInputs(True, deepcopy(self._inputVarList),\n deepcopy(self._inputTimeList))\n elif not listOK:\n self._solver.clearExtInputs()\n self._solver.setExtInputs(True, deepcopy(self._inputVarList),\n deepcopy(self._inputTimeList))\n self._solver.canContinue=True\n\n\n def __del__(self):\n genDB.unregister(self)\n ODEsystem.__del__(self)\n\n\n\n# Register this Generator with the database\n\nsymbolMapDict = {'abs': 'fabs', 'sign': 'signum', 'mod': 'fmod'}\n# in future, provide appropriate mappings for libraries math,\n# random, etc. (for now it's left to FuncSpec)\ntheGenSpecHelper.add(Radau_ODEsystem, symbolMapDict, 'c')\n", "meta": {"hexsha": "4f2d91bd498bab45830c07a60ea7863b59e2a2a7", "size": 55116, "ext": "py", "lang": "Python", "max_stars_repo_path": "PyDSTool/Generator/Radau_ODEsystem.py", "max_stars_repo_name": "mdlama/pydstool", "max_stars_repo_head_hexsha": "3d298e908ff55340cd3612078508be0c791f63a8", "max_stars_repo_licenses": ["Python-2.0", "OLDAP-2.7"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-02-04T15:01:31.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-25T16:08:43.000Z", "max_issues_repo_path": "PyDSTool/Generator/Radau_ODEsystem.py", "max_issues_repo_name": "mdlama/pydstool", "max_issues_repo_head_hexsha": "3d298e908ff55340cd3612078508be0c791f63a8", "max_issues_repo_licenses": ["Python-2.0", "OLDAP-2.7"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "PyDSTool/Generator/Radau_ODEsystem.py", "max_forks_repo_name": "mdlama/pydstool", "max_forks_repo_head_hexsha": "3d298e908ff55340cd3612078508be0c791f63a8", "max_forks_repo_licenses": ["Python-2.0", "OLDAP-2.7"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-02-25T14:43:36.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-25T14:43:36.000Z", "avg_line_length": 47.678200692, "max_line_length": 176, "alphanum_fraction": 0.5091806372, "include": true, "reason": "import numpy,from numpy", "num_tokens": 11686, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.531209388216861, "lm_q2_score": 0.35936414516010196, "lm_q1q2_score": 0.190897607697573}} {"text": "\"\"\" Starting point for DEM retrieval utilities.\n\"\"\"\nfrom math import pi, sin, cos\nfrom os import unlink, close\nfrom itertools import product\nfrom tempfile import mkstemp\nfrom sys import modules\n\nimport NED10m, NED100m, NED1km, SRTM1, SRTM3, VFP, Worldwide\n\nfrom ModestMaps.Core import Coordinate\nfrom TileStache.Geography import SphericalMercator\nfrom TileStache.Core import Layer, Metatile\nfrom TileStache.Config import Configuration\nfrom TileStache.Caches import Disk\n\nfrom osgeo import gdal, osr\nfrom PIL import Image\nimport numpy\n\nfrom .. import save_slope_aspect\n\n# used to prevent clobbering in /vsimem/, see:\n# http://osgeo-org.1803224.n2.nabble.com/gdal-dev-Outputting-to-vsimem-td6221295.html\nvsimem_counter = 1\n\n#\n# Set up some useful projections.\n#\n\nosr.UseExceptions() # <-- otherwise errors will be silent and useless.\n\nwebmerc_proj = SphericalMercator()\nwebmerc_sref = osr.SpatialReference()\nwebmerc_sref.ImportFromProj4(webmerc_proj.srs)\n\nclass SeedingLayer (Layer):\n \"\"\" Tilestache-compatible seeding layer for preparing tiled data.\n \n Intended for use in hillup-seed.py script for preparing a tile directory.\n \"\"\"\n def __init__(self, demdir, tiledir, tmpdir, source, size):\n \"\"\"\n \"\"\"\n cache = Disk(tiledir, dirs='safe')\n config = Configuration(cache, '.')\n Layer.__init__(self, config, SphericalMercator(), Metatile(), tile_height=size)\n \n self.provider = Provider(self, demdir, tmpdir, source)\n\n def name(self):\n return '.'\n\nclass Provider:\n \"\"\" TileStache provider for generating tiles of DEM slope and aspect data.\n \n Source parameter can be \"srtm-ned\" (default) or \"ned-only\".\n\n See http://tilestache.org/doc/#custom-providers for information\n on how the Provider object interacts with TileStache.\n \"\"\"\n def __init__(self, layer, demdir, tmpdir=None, source='srtm-ned'):\n self.tmpdir = tmpdir\n self.demdir = demdir\n self.source = source\n \n def getTypeByExtension(self, ext):\n if ext.lower() != 'tiff':\n raise Exception()\n \n return 'image/tiff', 'TIFF'\n \n def renderArea(self, width, height, srs, xmin, ymin, xmax, ymax, zoom):\n \"\"\" Return an instance of SlopeAndAspect for requested area.\n \"\"\"\n assert srs == webmerc_proj.srs # <-- good enough for now\n \n if self.source == 'srtm-ned':\n providers = choose_providers_srtm(zoom)\n \n elif self.source == 'ned-only':\n providers = choose_providers_ned(zoom)\n\n elif self.source == 'vfp':\n providers = [(VFP, 1)]\n\n elif self.source == 'worldwide':\n providers = [(Worldwide, 1)]\n\n else:\n providers = load_func_path(self.source)(zoom)\n \n assert sum([proportion for (mod, proportion) in providers]) == 1.0\n \n #\n # Prepare information for datasets of the desired extent and projection.\n #\n \n xres = (xmax - xmin) / width\n yres = (ymin - ymax) / height\n\n area_wkt = webmerc_sref.ExportToWkt()\n buffered_xform = xmin - xres, xres, 0, ymax - yres, 0, yres\n \n #\n # Reproject and merge DEM datasources into destination datasets.\n #\n \n driver = gdal.GetDriverByName('GTiff')\n \n composite_ds = make_empty_datasource(width+2, height+2, buffered_xform, area_wkt, self.tmpdir)\n proportion_complete = 0.\n\n for (module, proportion) in providers:\n \n cs2cs = osr.CoordinateTransformation(webmerc_sref, module.sref)\n \n # get a lat/lon bbox buffered by one pixel on all sides\n minlon, minlat, z = cs2cs.TransformPoint(xmin - xres, ymin + yres)\n maxlon, maxlat, z = cs2cs.TransformPoint(xmax + xres, ymax - yres)\n \n #\n # Keep a version of the composite without the\n # current layer applied for later alpha-blending.\n #\n do_blending = bool(proportion_complete > 0 and proportion < 1)\n \n if do_blending:\n composite_without = composite_ds.ReadAsArray()\n \n ds_args = minlon, minlat, maxlon, maxlat, self.demdir\n \n for ds_dem in module.datasources(*ds_args):\n \n # estimate the raster density across source DEM and output\n dem_samples = (maxlon - minlon) / ds_dem.GetGeoTransform()[1]\n area_pixels = (xmax - xmin) / composite_ds.GetGeoTransform()[1]\n \n if dem_samples > area_pixels:\n # cubic looks better squeezing down\n resample = gdal.GRA_Cubic\n else:\n # cubic spline looks better stretching out\n resample = gdal.GRA_CubicSpline\n\n gdal.ReprojectImage(ds_dem, composite_ds, ds_dem.GetProjection(), composite_ds.GetProjection(), resample)\n ds_dem = None\n \n #\n # Perform alpha-blending if needed.\n #\n if do_blending:\n proportion_with = proportion / (proportion_complete + proportion)\n proportion_without = 1 - proportion_with\n \n composite_with = composite_ds.ReadAsArray() * proportion_with\n composite_with += composite_without * proportion_without\n\n composite_ds.GetRasterBand(1).WriteArray(composite_with, 0, 0)\n \n proportion_complete += proportion\n \n elevation = composite_ds.ReadAsArray()\n\n unlink(composite_ds.GetFileList()[0])\n composite_ds = None\n \n #\n # Calculate and save slope and aspect.\n #\n \n slope, aspect = calculate_slope_aspect(elevation, xres, yres)\n\n tile_xform = xmin, xres, 0, ymax, 0, yres\n \n return SlopeAndAspect(self.tmpdir, slope, aspect, area_wkt, tile_xform)\n\nclass SlopeAndAspect:\n \"\"\" TileStache response object with PIL-like save() and crop() methods.\n \n This object knows only how to save two-band 8-bit GeoTIFFs.\n \n See http://tilestache.org/doc/#custom-providers for information\n on how the SlopeAndAspect object interacts with TileStache.\n \"\"\"\n def __init__(self, tmpdir, slope, aspect, wkt, xform):\n \"\"\" Instantiate with array of slope and aspect, and minimal geographic information.\n \"\"\"\n self.tmpdir = tmpdir\n \n self.slope = slope\n self.aspect = aspect\n \n self.w, self.h = self.slope.shape\n\n self.wkt = wkt\n self.xform = xform\n \n def save(self, output, format):\n \"\"\" Save a two-band GeoTIFF to output file-like object.\n \"\"\"\n if format != 'TIFF':\n raise Exception('File format other than TIFF for slope and aspect: \"%s\"' % format)\n \n save_slope_aspect(self.slope, self.aspect, self.wkt, self.xform, output, self.tmpdir)\n \n def crop(self, box):\n \"\"\" Returns a rectangular region from the current image.\n \n Box is a 4-tuple with left, upper, right, and lower pixels.\n Not yet implemented!\n \"\"\"\n raise NotImplementedError()\n\ndef choose_providers_srtm(zoom):\n \"\"\" Return a list of data sources and proportions for given zoom level.\n \n Each data source is a module such as SRTM1 or SRTM3, and the proportions\n must all add up to one. Return list has either one or two items.\n \"\"\"\n if zoom <= SRTM3.ideal_zoom:\n return [(SRTM3, 1)]\n\n elif SRTM3.ideal_zoom < zoom and zoom < SRTM1.ideal_zoom:\n #bottom, top = SRTM3, SRTM1 # SRTM1 looks terrible\n bottom, top = SRTM3, NED10m\n\n elif zoom == SRTM1.ideal_zoom:\n #return [(SRTM1, 1)] # SRTM1 looks terrible\n bottom, top = SRTM3, NED10m\n\n elif SRTM1.ideal_zoom < zoom and zoom < NED10m.ideal_zoom:\n #bottom, top = SRTM1, NED10m # SRTM1 looks terrible\n bottom, top = SRTM3, NED10m\n\n elif zoom >= NED10m.ideal_zoom:\n return [(NED10m, 1)]\n\n difference = float(top.ideal_zoom) - float(bottom.ideal_zoom)\n proportion = 1. - (zoom - float(bottom.ideal_zoom)) / difference\n\n return [(bottom, proportion), (top, 1 - proportion)]\n\ndef choose_providers_ned(zoom):\n \"\"\" Return a list of data sources and proportions for given zoom level.\n \n Each data source is a module such as NED10m or NED1km, and the proportions\n must all add up to one. Return list has either one or two items.\n \"\"\"\n if zoom <= NED1km.ideal_zoom:\n return [(NED1km, 1)]\n\n elif NED1km.ideal_zoom < zoom and zoom < NED100m.ideal_zoom:\n #bottom, top = NED1km, NED100m\n bottom, top = NED1km, NED100m\n\n elif zoom == NED100m.ideal_zoom:\n return [(NED100m, 1)]\n\n elif NED100m.ideal_zoom < zoom and zoom < NED10m.ideal_zoom:\n #bottom, top = NED100m, NED10m\n bottom, top = NED100m, NED10m\n\n elif zoom >= NED10m.ideal_zoom:\n return [(NED10m, 1)]\n\n difference = float(top.ideal_zoom) - float(bottom.ideal_zoom)\n proportion = 1. - (zoom - float(bottom.ideal_zoom)) / difference\n\n return [(bottom, proportion), (top, 1 - proportion)]\n\ndef make_empty_datasource(width, height, xform, wkt, tmpdir):\n '''\n '''\n driver = gdal.GetDriverByName('GTiff')\n handle, filename = mkstemp(dir=tmpdir, prefix='dem-tools-hillup-data-render-', suffix='.tif')\n close(handle)\n\n ds = driver.Create(filename, width, height, 1, gdal.GDT_Float32)\n ds.SetGeoTransform(xform)\n ds.SetProjection(wkt)\n \n ds.GetRasterBand(1).WriteArray(numpy.ones((width, height), numpy.float32) * -9999, 0, 0)\n ds.GetRasterBand(1).SetNoDataValue(-9999)\n \n return ds\n\ndef calculate_slope_aspect(elevation, xres, yres, z=1.0):\n \"\"\" Return a pair of arrays 2 pixels smaller than the input elevation array.\n \n Slope is returned in radians, from 0 for sheer face to pi/2 for\n flat ground. Aspect is returned in radians, counterclockwise from -pi\n at north around to pi.\n \n Logic here is borrowed from hillshade.cpp:\n http://www.perrygeo.net/wordpress/?p=7\n \"\"\"\n width, height = elevation.shape[0] - 2, elevation.shape[1] - 2\n \n window = [z * elevation[row:(row + height), col:(col + width)]\n for (row, col)\n in product(range(3), range(3))]\n \n x = ((window[0] + window[3] + window[3] + window[6]) \\\n - (window[2] + window[5] + window[5] + window[8])) \\\n / (8.0 * xres);\n \n y = ((window[6] + window[7] + window[7] + window[8]) \\\n - (window[0] + window[1] + window[1] + window[2])) \\\n / (8.0 * yres);\n\n # in radians, from 0 to pi/2\n slope = pi/2 - numpy.arctan(numpy.sqrt(x*x + y*y))\n \n # in radians counterclockwise, from -pi at north back to pi\n aspect = numpy.arctan2(x, y)\n \n return slope, aspect\n\ndef load_func_path(funcpath):\n \"\"\" Load external function based on a path.\n \n Example funcpath: \"Module.Submodule:Function\".\n \"\"\"\n modname, objname = funcpath.split(':', 1)\n\n __import__(modname)\n module = modules[modname]\n _func = eval(objname, module.__dict__)\n \n if _func is None:\n raise Exception('eval(%(objname)s) in %(modname)s came up None' % locals())\n\n return _func\n", "meta": {"hexsha": "6e15a0914d68c0d6c9d36849ccdb771ea1ea077d", "size": 11459, "ext": "py", "lang": "Python", "max_stars_repo_path": "Hillup/data/__init__.py", "max_stars_repo_name": "migurski/DEM-Tools", "max_stars_repo_head_hexsha": "5462f35f3ec1fec6fbe8288019a3af92d53ac310", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 17, "max_stars_repo_stars_event_min_datetime": "2015-01-17T19:03:04.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-14T15:25:16.000Z", "max_issues_repo_path": "Hillup/data/__init__.py", "max_issues_repo_name": "migurski/DEM-Tools", "max_issues_repo_head_hexsha": "5462f35f3ec1fec6fbe8288019a3af92d53ac310", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Hillup/data/__init__.py", "max_forks_repo_name": "migurski/DEM-Tools", "max_forks_repo_head_hexsha": "5462f35f3ec1fec6fbe8288019a3af92d53ac310", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 10, "max_forks_repo_forks_event_min_datetime": "2015-05-18T18:57:42.000Z", "max_forks_repo_forks_event_max_datetime": "2020-06-10T10:08:48.000Z", "avg_line_length": 34.2059701493, "max_line_length": 121, "alphanum_fraction": 0.6109608168, "include": true, "reason": "import numpy", "num_tokens": 2925, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5312093733737563, "lm_q2_score": 0.359364152021239, "lm_q1q2_score": 0.19089760600819367}} {"text": "#!/usr/bin/env python\n\"\"\"Random sequences and random evolution of sequences in a tree\"\"\"\n\nimport bisect\n\nimport numpy\n\n\n__author__ = \"Peter Maxwell\"\n__copyright__ = \"Copyright 2007-2020, The Cogent Project\"\n__credits__ = [\"Peter Maxwell\"]\n__license__ = \"BSD-3\"\n__version__ = \"2020.6.30a\"\n__maintainer__ = \"Peter Maxwell\"\n__email__ = \"pm67nz@gmail.com\"\n__status__ = \"Production\"\n\n\ndef argpicks(freqs, random_series):\n partition = numpy.add.accumulate(freqs)\n assert abs(partition[-1] - 1.0) < 1e-6, (freqs, partition)\n while True:\n x = random_series.uniform(0.0, 1.0)\n i = bisect.bisect_left(partition, x)\n yield i\n\n\ndef argpick(freqs, random_series):\n return next(argpicks(freqs, random_series))\n\n\ndef _randomMotifGenerator(random_series, motif_probs):\n motifs = list(motif_probs.keys())\n freqs = [motif_probs[m] for m in motifs]\n for i in argpicks(freqs, random_series):\n yield motifs[i]\n\n\ndef evolve_sequence(\n random_series, motifs, parent_seq, site_cats, psubs, preserved_sites=()\n):\n \"\"\"Evolve a new sequence derived from parent_seq. Uses psubs[site_cats[i]]\n to pick a new motif derived from parent_seq[i]\"\"\"\n seq = []\n randomMotifSources = {}\n for (i, parent_motif) in enumerate(parent_seq):\n if i in preserved_sites:\n edge_motif = preserved_sites[i]\n else:\n if parent_motif not in randomMotifSources:\n mprobs = {}\n parent_motif_index = motifs.index(parent_motif)\n site_cat = site_cats[i]\n psub = psubs[site_cat]\n for (dest_motif_index, dest_motif) in enumerate(motifs):\n prob = psub[parent_motif_index, dest_motif_index]\n mprobs[dest_motif] = prob\n randomMotifSources[site_cat, parent_motif] = _randomMotifGenerator(\n random_series, mprobs\n )\n edge_motif = next(randomMotifSources[site_cat, parent_motif])\n seq.append(edge_motif)\n return seq\n\n\ndef random_sequence(random_series, motif_probs, sequence_length):\n getRootRandomMotif = _randomMotifGenerator(random_series, motif_probs).__next__\n return [getRootRandomMotif() for i in range(sequence_length)]\n\n\nclass AlignmentEvolver(object):\n # Encapsulates settings that are constant throughout the recursive generation\n # of a synthetic alignment.\n\n def __init__(\n self,\n random_series,\n orig_ambig,\n exclude_internal,\n bin_names,\n site_bins,\n psub_for,\n motifs,\n ):\n self.random_series = random_series\n self.orig_ambig = orig_ambig\n self.exclude_internal = exclude_internal\n self.bin_names = bin_names\n self.site_bins = site_bins\n self.psub_for = psub_for\n self.motifs = motifs\n\n def __call__(self, tree, root_sequence):\n # probsd = dict(enumerate(self.bin_probs))\n # bprobs = _randomMotifGenerator(self.random_series, probsd)\n # site_bins = [bprobs.next() for c in range(len(root_sequence))]\n return self.generate_simulated_seqs(tree, root_sequence)\n\n def generate_simulated_seqs(self, parent, parent_seq):\n \"\"\"recursively generate the descendant sequences by descending the tree\n from root.\n Each child will be set by mutating the parent motif based on the probs\n in the psub matrix of this edge.\n\n random_series - get a random numer 0-1 by calling random_series.random()\n length - the desired alignment length\n parent - the edge structure.\n parent_seq - the corresponding sequence. This will be mutated for each\n of its children, based on their psub matricies.\n \"\"\"\n\n # This depends on parameter names 'mprobs', 'alignment2', 'bprobs' and\n # 'psubs'. Might be better to integrate it into likelihood_calculation.\n\n if self.exclude_internal and parent.children:\n simulated_sequences = {}\n else:\n simulated_sequences = {parent.name: \"\".join(parent_seq)}\n\n for edge in parent.children:\n # The result for this edge - a list of motifs\n\n # Keep original ambiguity codes\n if edge.name in self.orig_ambig:\n orig_seq_ambig = self.orig_ambig[edge.name]\n else:\n orig_seq_ambig = {}\n\n # Matrix of substitution probabilities\n psubs = [self.psub_for(edge.name, bin) for bin in self.bin_names]\n\n # Make the semi-random sequence for this edge.\n edge_seq = evolve_sequence(\n self.random_series,\n self.motifs,\n parent_seq,\n self.site_bins,\n psubs,\n orig_seq_ambig,\n )\n\n # Pass this new edge sequence on down the tree\n descendant_sequences = self.generate_simulated_seqs(edge, edge_seq)\n simulated_sequences.update(descendant_sequences)\n\n return simulated_sequences\n", "meta": {"hexsha": "b9d84092b0a46605edbbf2b287da75ed7114bdca", "size": 5037, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/cogent3/evolve/simulate.py", "max_stars_repo_name": "wjjmjh/cogent3", "max_stars_repo_head_hexsha": "e10f4f933921d52b000096b7c016190a1602add6", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/cogent3/evolve/simulate.py", "max_issues_repo_name": "wjjmjh/cogent3", "max_issues_repo_head_hexsha": "e10f4f933921d52b000096b7c016190a1602add6", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/cogent3/evolve/simulate.py", "max_forks_repo_name": "wjjmjh/cogent3", "max_forks_repo_head_hexsha": "e10f4f933921d52b000096b7c016190a1602add6", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.2653061224, "max_line_length": 83, "alphanum_fraction": 0.6426444312, "include": true, "reason": "import numpy", "num_tokens": 1147, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.531209388216861, "lm_q2_score": 0.3593641382989649, "lm_q1q2_score": 0.1908976040528726}} {"text": "import xarray as xr\nimport pandas as pd\nimport numpy as np\nimport os\nimport numba as nb\nimport time\nimport dask.array as da\n\n\ndef compute_all(work_dir, memory_to_allocate_gb, date_strings):\n array_size_bytes = 3060 # Based on 15 x 51 member array\n memory_to_allocate_bytes = memory_to_allocate_gb * 1e9\n\n files = [os.path.join(work_dir, i + \".nc\") for i in date_strings]\n\n chunk_size = int(np.floor(memory_to_allocate_bytes / ((array_size_bytes * len(files)) + len(files))))\n\n print(\"Chunk Size:\", chunk_size)\n\n list_of_dask_q_arrays = []\n list_of_dask_init_arrays = []\n\n # Creating a large dask array with all of the data in it\n start = time.time()\n for file in files:\n ds = xr.open_dataset(file, chunks={\"rivid\": chunk_size})\n\n tmp_dask_q_array = ds[\"Qout\"].data\n list_of_dask_q_arrays.append(tmp_dask_q_array)\n\n tmp_dask_init_array = ds[\"initialization_values\"].data\n list_of_dask_init_arrays.append(tmp_dask_init_array)\n\n ds.close()\n end = time.time()\n\n big_dask_q_array = da.stack(list_of_dask_q_arrays)\n big_dask_init_array = da.stack(list_of_dask_init_arrays)\n\n print(big_dask_q_array.shape)\n print(big_dask_init_array.shape)\n\n print(\"Time to create dask arrays: \", end - start)\n\n # Retrieving the number of streams and their corresponding Rivids\n tmp_dataset = xr.open_dataset(files[0])\n\n num_of_streams = tmp_dataset['rivid'].size\n rivids = tmp_dataset['rivid'].data\n\n tmp_dataset.close()\n\n num_chunk_iterations = int(np.ceil(num_of_streams / chunk_size))\n start_chunk = 0\n end_chunk = chunk_size\n list_of_tuples_with_metrics = []\n\n for chunk_number in range(num_chunk_iterations):\n\n start = time.time()\n big_forecast_data_array = np.asarray(big_dask_q_array[:, start_chunk:end_chunk, :, :])\n big_init_data_array = np.asarray(big_dask_init_array[:, start_chunk:end_chunk])\n end = time.time()\n print(\"Time to read from disk:\", end - start)\n\n rivids_chunk = rivids[start_chunk:end_chunk]\n\n start = time.time()\n results_array = numba_calculate_metrics(\n big_forecast_data_array, big_init_data_array, len(files), big_forecast_data_array.shape[1], 15\n )\n end = time.time()\n print(\"Numba Calculation Time: \", end - start)\n\n for rivid in range(results_array.shape[1]):\n for forecast_day in range(results_array.shape[0]):\n tmp_array = results_array[forecast_day, rivid, :]\n tuple_to_append = (rivids_chunk[rivid], '{} Day Forecast'.format(str(forecast_day + 1).zfill(2)),\n tmp_array[0], tmp_array[1], tmp_array[2])\n list_of_tuples_with_metrics.append(tuple_to_append)\n\n start_chunk += chunk_size\n end_chunk += chunk_size\n\n final_df = pd.DataFrame(list_of_tuples_with_metrics,\n columns=['Rivid', 'Forecast Day', 'CRPS', 'CRPS BENCH', 'CRPSS'])\n final_df.to_csv(r'/Users/wade/PycharmProjects/Forecast_Validation/South_America_Test_DF.csv', index=False)\n\n\n@nb.njit(parallel=True)\ndef numba_calculate_metrics(forecast_array, initialization_array, number_of_start_dates, number_of_streams,\n num_forecast_days):\n \"\"\"\n Parameters\n ----------\n\n forecast_array: 4D ndarray\n A 4 dimensional numPy array with the following dimensions: 1) Start Date Number (365 if there are a year's\n forecasts), 2) Unique stream ID, 3) Forecast Days (e.g. 1-15 in a 15 day forecast), 4) Ensembles\n\n initialization_array: 2D ndarray\n A 2 dimenensional NumPy array with the following dimensions: 1) Start Dates, 2) Unique stream ID\n\n number_of_start_dates: The number of start dates for the analysis to perform\n\n number_of_streams:\n The number of streams in the analysis\n\n num_forecast_days:\n The number of forecast days in the analysis\n\n Returns\n -------\n ndarray\n An ndarray with the folowing dimenstions:\n 1) Forecast Day: 1-15 in the case of a 15 day forecast\n 2) Rivid: The stream unique ID\n 3) Metrics: CRPS, CRPS_BENCH, CRPSS\n\n \"\"\"\n return_array = np.zeros((num_forecast_days, number_of_streams, 3), dtype=np.float32)\n\n for stream in nb.prange(number_of_streams):\n for forecast_day in range(num_forecast_days):\n initialization_vals = initialization_array[(forecast_day + 1):, stream]\n # np.savetxt(\"init_test.txt\", initialization_vals)\n forecasts = forecast_array[:(number_of_start_dates - (forecast_day + 1)), stream, forecast_day, :]\n # np.savetxt(\"forecasts_test.txt\", forecasts)\n benchmark_forecasts = initialization_array[:(number_of_start_dates - (forecast_day + 1)), stream]\n # np.savetxt(\"benchmark_forecasts_test.txt\", benchmark_forecasts)\n\n crps = ens_crps(initialization_vals, forecasts)\n crps_bench = mae(initialization_vals, benchmark_forecasts)\n if crps_bench == 0:\n crpss = np.inf\n print(\"Warning: Division by zero on: \", stream)\n else:\n crpss = 1 - crps / crps_bench\n\n return_array[forecast_day, stream, 0] = crps\n return_array[forecast_day, stream, 1] = crps_bench\n return_array[forecast_day, stream, 2] = crpss\n\n # print(crps, crps_bench, crpss)\n if (stream % 1000) == 0:\n print(\"Count: \", stream)\n\n return return_array\n\n\n@nb.njit()\ndef mae(sim, obs):\n return np.mean(np.abs(sim - obs))\n\n\n@nb.njit()\ndef ens_crps(obs, fcst_ens, adj=np.nan):\n\n rows = obs.size\n cols = fcst_ens.shape[1]\n\n col_len_array = np.ones(rows) * cols\n sad_ens_half = np.zeros(rows)\n sad_obs = np.zeros(rows)\n crps = np.zeros(rows)\n\n crps = numba_crps(\n fcst_ens, obs, rows, cols, col_len_array, sad_ens_half, sad_obs, crps, np.float64(adj)\n )\n\n # Calc mean crps as simple mean across crps[i]\n crps_mean = np.mean(crps)\n\n return crps_mean\n\n\n@nb.njit()\ndef numba_crps(ens, obs, rows, cols, col_len_array, sad_ens_half, sad_obs, crps, adj):\n for i in range(rows):\n the_obs = obs[i]\n the_ens = ens[i, :]\n the_ens = np.sort(the_ens)\n sum_xj = 0.\n sum_jxj = 0.\n\n j = 0\n while j < cols:\n sad_obs[i] += np.abs(the_ens[j] - the_obs)\n sum_xj += the_ens[j]\n sum_jxj += (j + 1) * the_ens[j]\n j += 1\n\n sad_ens_half[i] = 2.0 * sum_jxj - (col_len_array[i] + 1) * sum_xj\n\n if np.isnan(adj):\n for i in range(rows):\n crps[i] = sad_obs[i] / col_len_array[i] - sad_ens_half[i] / \\\n (col_len_array[i] * col_len_array[i])\n elif adj > 1:\n for i in range(rows):\n crps[i] = sad_obs[i] / col_len_array[i] - sad_ens_half[i] / \\\n (col_len_array[i] * (col_len_array[i] - 1)) * (1 - 1 / adj)\n elif adj == 1:\n for i in range(rows):\n crps[i] = sad_obs[i] / col_len_array[i]\n else:\n for i in range(rows):\n crps[i] = np.nan\n\n return crps\n\n\nif __name__ == \"__main__\":\n\n starting_date = \"2018-08-19\"\n ending_date = \"2018-12-16\"\n\n dates_range = pd.date_range(starting_date, ending_date)\n dates_strings = dates_range.strftime(\"%Y%m%d\").tolist()\n\n workspace = r'/Users/wade/Documents/South_America_Forecasts'\n MEMORY_TO_ALLOCATE = 1.0 # GB\n\n start = time.time()\n compute_all(workspace, MEMORY_TO_ALLOCATE, dates_strings)\n end = time.time()\n print(end - start)\n", "meta": {"hexsha": "7e8d5dc539cf5cde78ac4c683aa89c61bb068cf0", "size": 7609, "ext": "py", "lang": "Python", "max_stars_repo_path": "validate_forecasts.py", "max_stars_repo_name": "jorgessanchez7/Global_Forecast_Validation", "max_stars_repo_head_hexsha": "d3178acaa2a67801e832554a3f871b36c266fe3a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "validate_forecasts.py", "max_issues_repo_name": "jorgessanchez7/Global_Forecast_Validation", "max_issues_repo_head_hexsha": "d3178acaa2a67801e832554a3f871b36c266fe3a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "validate_forecasts.py", "max_forks_repo_name": "jorgessanchez7/Global_Forecast_Validation", "max_forks_repo_head_hexsha": "d3178acaa2a67801e832554a3f871b36c266fe3a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.3728070175, "max_line_length": 114, "alphanum_fraction": 0.6395058483, "include": true, "reason": "import numpy,import numba", "num_tokens": 1999, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5312093733737562, "lm_q2_score": 0.35936414516010196, "lm_q1q2_score": 0.19089760236349332}} {"text": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\nimport numpy\nfrom PIL import Image, ImageFile\n__version__ = \"1.0\"\n\n\"\"\"Visualization of 2-dimensional numpy arrays.\"\"\"\n\n\ndef array2im(a, brightness=1, contrast=1):\n P = (a.real * (a.real > 0) * brightness) ** contrast\n N = (-a.real * (a.real < 0) * brightness) ** contrast\n R = numpy.array(\n (256 * (1 - numpy.float64(0.5) ** P)).clip(max=255), dtype=numpy.uint8)[::-1]\n G = numpy.zeros(R.shape, dtype=numpy.uint8)\n B = numpy.array(\n (256 * (1 - numpy.float64(0.5) ** N)).clip(max=255), dtype=numpy.uint8)[::-1]\n return Image.fromarray(numpy.array([R, G, B]).swapaxes(0, 1).swapaxes(1, 2))\n\nif __name__ == \"__main__\":\n import argparse\n import struct\n import os\n import sys\n import time\n from numpy import dtype, fromfile\n from numpy import save as npsave\n from numpy import load as npload\n import warnings\n warnings.filterwarnings('ignore')\n\n parser = argparse.ArgumentParser(\n description=\"Converts a two-dimensional numpy array into an image.\")\n parser.add_argument(\"--in\", \"-i\", dest=\"input\", action=\"store\",\n help=\"Input file. Default: .\", default=\"-\")\n parser.add_argument(\"--out\", \"-o\", dest=\"output\", action=\"store\",\n help=\"Output file. Default: .\", default=\"-\")\n parser.add_argument(\"--brightness\", \"-b\", dest=\"brightness\",\n action=\"store\", help=\"Adjust brightness. Default: 1.\", default=1)\n parser.add_argument(\"--contrast\", \"-c\", dest=\"contrast\",\n action=\"store\", help=\"Adjust contrast. Default: 1.\", default=1)\n parser.add_argument(\"--quality\", \"-q\", dest=\"quality\", action=\"store\",\n help=\"JPEG quality, between 1 and 100. Only valid when saving image as a JPEG. Default: 95.\", default=95)\n parser.add_argument(\"--progressive\", \"-p\", dest=\"progressive\", action=\"store_const\",\n help=\"Save progressive JPEG. Only valid when saving image as a JPEG.\", const=True)\n parser.add_argument(\"--overwrite\", \"-y\", dest=\"overwrite\",\n action='store_const', help=\"Overwrite output file, if it exists.\", const=True)\n parser.add_argument(\"--no-overwrite\", \"-n\", dest=\"nooverwrite\", action='store_const',\n help=\"Do not overwrite output file, if it exists.\", const=True)\n args = parser.parse_args()\n\n msgout = sys.stdout if sys.stdout.isatty() else sys.stderr\n\n if args.overwrite and args.nooverwrite:\n print >>sys.stderr, \"Cannot specify both '-y' and '-n'!\"\n sys.exit()\n\n if args.input == \"-\":\n if sys.stdin.isatty():\n print >>sys.stderr, \"Surely you are not typing the raw data into the terminal. Please specify input file, or pipe input from another program.\\n\"\n parser.print_help(sys.stderr)\n sys.exit()\n infile = sys.stdin\n else:\n infile = open(args.input, \"rb\")\n\n if args.output == \"-\":\n if sys.stdout.isatty():\n print >>sys.stderr, \"Cowardly refusing to write binary data to terminal. Please specify output file, or redirect output to a pipe.\\n\"\n parser.print_help(sys.stderr)\n sys.exit()\n outfile = sys.stdout\n print >>sys.stderr, \"Writing data to .\"\n else:\n if os.path.exists(args.output):\n if args.nooverwrite:\n print >>sys.stderr, \"Error: Output file '%s' exists. Terminating because '-n' was specified.\" % args.output\n sys.exit()\n elif args.overwrite:\n print >>msgout, \"Warning: Output file '%s' exists. Overwriting because '-y' was specified.\" % args.output\n elif sys.stdin.isatty() and sys.stdout.isatty():\n overwrite = raw_input(\n \"Warning: Output file '%s' exists. Do you wish to overwrite file? (Y/N) \" % args.output)\n while overwrite.upper() not in (\"Y\", \"N\", \"YES\", \"NO\"):\n print >>msgout, \"Invalid answer: '%s'\" % overwrite\n overwrite = raw_input(\n \"Warning: Output file '%s' exists. Do you wish to overwrite file? (Y/N) \" % args.output)\n\n if overwrite.upper() in (\"Y\", \"YES\"):\n print >>msgout, \"Overwriting '%s'.\" % args.output\n print >>msgout, \"\"\n elif overwrite.upper() in (\"N\", \"NO\"):\n print >>msgout, \"Operation aborted.\"\n sys.exit()\n else:\n print >>sys.stderr, \"Operation aborted. Cowardly refusing to overwrite '%s'.\" % args.output\n sys.exit()\n\n outfile = args.output\n\n tag = npload(infile)\n metadata = npload(infile)\n data = npload(infile)\n if infile is not sys.stdin:\n infile.close()\n\n if len(data.shape) != 2:\n print >>sys.stderr, \"Expected a two-dimensional array. Got an array with shape %s instead.\" % (\n data.shape,)\n sys.exit()\n\n kind_str = {\n \"f\": \"floating point\",\n \"i\": \"integer\",\n \"u\": \"unsigned integer\",\n \"b\": \"boolean\",\n \"c\": \"complex\"\n }\n\n if data.dtype.kind in \"iub\":\n print >>sys.stderr, \"Error: Data type '%s' not supported.\" % kind_str[\n data.dtype.kind]\n sys.exit()\n elif data.dtype.kind == \"c\":\n print >>msgout, \"Warning: Discarding imaginary part of 'complex' array.\"\n\n try:\n args.brightness = float(args.brightness)\n except ValueError:\n print >>sys.stderr, \"Bad parameter for brightness. Expected floating point or integer, got '%s' instead.\" % args.brightness\n sys.exit()\n\n try:\n args.contrast = float(args.contrast)\n except ValueError:\n print >>sys.stderr, \"Bad parameter for contrast. Expected floating point or integer, got '%s' instead.\" % args.contrast\n sys.exit()\n\n try:\n args.quality = int(args.quality)\n except ValueError:\n print >>sys.stderr, \"Bad parameter for quality. Expected integer between 1 and 100, got '%s' instead.\" % args.quality\n sys.exit()\n\n if not (1 <= args.quality <= 100):\n print >>sys.stderr, \"Bad parameter for quality. Expected integer between 1 and 100, got '%s' instead.\" % args.quality\n sys.exit()\n\n H, W = data.shape\n\n t0 = time.time()\n print >>msgout, u\"Saving %d×%d image to '%s'...\" % (W, H, args.output),\n msgout.flush()\n img = array2im(data, brightness=args.brightness, contrast=args.contrast)\n ImageFile.MAXBLOCK = img.size[0] * img.size[1]\n img.save(outfile, progressive=args.progressive, quality=args.quality)\n print >>msgout, \"%.2f seconds\" % (time.time() - t0)\n", "meta": {"hexsha": "1f16cddb95e5616b13b1205a28d4fa7512a8af6f", "size": 6737, "ext": "py", "lang": "Python", "max_stars_repo_path": "array2im.py", "max_stars_repo_name": "shersonb/python-array2im", "max_stars_repo_head_hexsha": "6af0e5fb88d2e31fb906a5c29c32e9008ab24ed8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "array2im.py", "max_issues_repo_name": "shersonb/python-array2im", "max_issues_repo_head_hexsha": "6af0e5fb88d2e31fb906a5c29c32e9008ab24ed8", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "array2im.py", "max_forks_repo_name": "shersonb/python-array2im", "max_forks_repo_head_hexsha": "6af0e5fb88d2e31fb906a5c29c32e9008ab24ed8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.6392405063, "max_line_length": 156, "alphanum_fraction": 0.584236307, "include": true, "reason": "import numpy,from numpy", "num_tokens": 1612, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5312093733737563, "lm_q2_score": 0.35936413829896496, "lm_q1q2_score": 0.19089759871879308}} {"text": "''' FSL IO '''\n\nfrom __future__ import with_statement\n\nimport os\nfrom os.path import join as pjoin\nfrom subprocess import Popen,PIPE\n\nimport numpy as np\nimport numpy.linalg as npl\nfrom numpy import newaxis\n\nfrom scipy.ndimage import map_coordinates as mc\nfrom scipy.ndimage import affine_transform\nfrom dipy.io.dpy import Dpy\n\nimport nibabel as nib\nfrom nibabel.tmpdirs import InTemporaryDirectory\n\n_VAL_FMT = ' %e'\n\nclass FSLError(Exception):\n \"\"\" Class signals error in FSL processing \"\"\"\n\n\ndef have_flirt():\n \"\"\" Return True if we can call flirt without error\n\n Relies on the fact that flirt produces text on stdout when called with no\n arguments\n \"\"\"\n p = Popen('flirt', stdout=PIPE, stderr=PIPE, shell=True)\n stdout, stderr = p.communicate()\n return stdout != ''\n\n\ndef write_bvals_bvecs(bvals, bvecs, outpath=None, prefix=''):\n ''' Write FSL FDT bvals and bvecs files\n\n Parameters\n -------------\n bvals : (N,) sequence\n Vector with diffusion gradient strength (one per diffusion\n acquisition, N=no of acquisitions)\n bvecs : (N, 3) array-like\n diffusion gradient directions\n outpath : None or str\n path to write FDT bvals, bvecs text files\n None results in current working directory.\n prefix : str\n prefix for bvals, bvecs files in directory. Defaults to ''\n '''\n if outpath is None:\n outpath = os.getcwd()\n bvals = tuple(bvals)\n bvecs = np.asarray(bvecs)\n bvecs[np.isnan(bvecs)] = 0\n N = len(bvals)\n fname = pjoin(outpath, prefix + 'bvals')\n fmt = _VAL_FMT * N + '\\n'\n open(fname, 'wt').write(fmt % bvals)\n fname = pjoin(outpath, prefix + 'bvecs')\n bvf = open(fname, 'wt')\n for dim_vals in bvecs.T:\n bvf.write(fmt % tuple(dim_vals))\n\n\ndef flirt2aff(mat, in_img, ref_img):\n \"\"\" Transform from `in_img` voxels to `ref_img` voxels given `mat`\n\n Parameters\n ----------\n mat : (4,4) array\n contents (as array) of output ``-omat`` transformation file from flirt\n in_img : img\n image passed (as filename) to flirt as ``-in`` image\n ref_img : img\n image passed (as filename) to flirt as ``-ref`` image\n\n Returns\n -------\n aff : (4,4) array\n Transform from voxel coordinates in ``in_img`` to voxel coordinates in\n ``ref_img``\n\n Notes\n -----\n Thanks to Mark Jenkinson and Jesper Andersson for the correct statements\n here, apologies for any errors we've added.\n\n ``flirt`` registers an ``in`` image to a ``ref`` image. It can produce\n (with the ``-omat`` option) - a 4 x 4 affine matrix giving the mapping from\n *inspace* to *refspace*.\n\n The rest of this note is to specify what *inspace* and *refspace* are.\n\n In what follows, a *voxtrans* for an image is the 4 by 4 affine\n ``np.diag([vox_i, vox_j, vox_k, 1])`` where ``vox_i`` etc are the voxel\n sizes for the first second and third voxel dimension. ``vox_i`` etc are\n always positive.\n\n If the input image has an affine with a negative determinant, then the\n mapping from voxel coordinates in the input image to *inspace* is simply\n *voxtrans* for the input image. If the reference image has a negative\n determinant, the mapping from voxel space in the reference image to\n *refspace* is simply *voxtrans* for the reference image.\n\n A negative determinant for the image affine is the common case, of an image\n with a x voxel flip. Analyze images don't store affines and flirt assumes a\n negative determinant in these cases.\n\n For positive determinant affines, flirt starts *inspace* and / or *refspace*\n with an x voxel flip. The mapping implied for an x voxel flip for image\n with shape (N_i, N_j, N_k) is:\n\n [[-1, 0, 0, N_i - 1],\n [ 0, 1, 0, 0],\n [ 0, 0, 1, 0],\n [ 0, 0, 0, 1]]\n\n If the input image has an affine with a positive determinant, then mapping\n from input image voxel coordinates to *inspace* is ``np.dot(input_voxtrans,\n input_x_flip)`` - where ``input_x_flip`` is the matrix above with ``N_i``\n given by the input image first axis length. Similarly the mapping from\n reference voxel coordinates to *refspace*, if the reference image has a\n positive determinant, is ``np.dot(ref_voxtrans, ref_x_flip)`` - where\n ``ref_x_flip`` is the matrix above with ``N_i`` given by the reference image\n first axis length.\n \"\"\"\n in_hdr = in_img.get_header()\n ref_hdr = ref_img.get_header()\n # get_zooms gets the positive voxel sizes as returned in the header\n inspace = np.diag(in_hdr.get_zooms() + (1,))\n refspace = np.diag(ref_hdr.get_zooms() + (1,))\n if npl.det(in_img.get_affine())>=0:\n inspace = np.dot(inspace, _x_flipper(in_hdr.get_data_shape()[0]))\n if npl.det(ref_img.get_affine())>=0:\n refspace = np.dot(refspace, _x_flipper(ref_hdr.get_data_shape()[0]))\n # Return voxel to voxel mapping\n return np.dot(npl.inv(refspace), np.dot(mat, inspace))\n\n\ndef _x_flipper(N_i):\n flipr = np.diag([-1, 1, 1, 1])\n flipr[0,3] = N_i - 1\n return flipr\n\n\ndef flirt2aff_files(matfile, in_fname, ref_fname):\n \"\"\" Map from `in_fname` image voxels to `ref_fname` voxels given `matfile`\n\n See :func:`flirt2aff` docstring for details.\n\n Parameters\n ------------\n matfile : str\n filename of output ``-omat`` transformation file from flirt\n in_fname : str\n filename for image passed to flirt as ``-in`` image\n ref_fname : str\n filename for image passed to flirt as ``-ref`` image\n\n Returns\n -------\n aff : (4,4) array\n Transform from voxel coordinates in image for ``in_fname`` to voxel\n coordinates in image for ``ref_fname``\n \"\"\"\n mat = np.loadtxt(matfile)\n in_img = nib.load(in_fname)\n ref_img = nib.load(ref_fname)\n return flirt2aff(mat, in_img, ref_img)\n\n\ndef warp_displacements(ffa,flaff,fdis,fref,ffaw,order=1):\n ''' Warp an image using fsl displacements \n\n Parameters\n ------------\n ffa : filename of nifti to be warped\n flaff : filename of .mat (flirt)\n fdis : filename of displacements (fnirtfileutils)\n fref : filename of reference volume e.g. (FMRIB58_FA_1mm.nii.gz)\n ffaw : filename for the output warped image\n '''\n refaff=nib.load(fref).get_affine() \n disdata=nib.load(fdis).get_data()\n imgfa=nib.load(ffa)\n fadata=imgfa.get_data()\n fazooms=imgfa.get_header().get_zooms() \n #from fa index to ref index\n res=flirt2aff_files(flaff,ffa,fref)\n #from ref index to fa index\n ires=np.linalg.inv(res) \n #create the 4d volume which has the indices for the reference image \n reftmp=np.zeros(disdata.shape)\n ''' \n #create the grid indices for the reference\n #refinds = np.ndindex(disdata.shape[:3]) \n for ijk_t in refinds:\n i,j,k = ijk_t \n reftmp[i,j,k,0]=i\n reftmp[i,j,k,1]=j\n reftmp[i,j,k,2]=k\n '''\n #same as commented above but much faster\n reftmp[...,0] = np.arange(disdata.shape[0])[:,newaxis,newaxis]\n reftmp[...,1] = np.arange(disdata.shape[1])[newaxis,:,newaxis]\n reftmp[...,2] = np.arange(disdata.shape[2])[newaxis,newaxis,:]\n \n #affine transform from reference index to the fa index\n A = np.dot(reftmp,ires[:3,:3].T)+ires[:3,3]\n #add the displacements but first devide them by the voxel sizes\n A2=A+disdata/fazooms\n #hold the displacements' shape reshaping\n di,dj,dk,dl=disdata.shape\n #do the interpolation using map coordinates\n #the list of points where the interpolation is done given by the reshaped in 2D A2 (list of 3d points in fa index)\n W=mc(fadata,A2.reshape(di*dj*dk,dl).T,order=order).reshape(di,dj,dk) \n #save the warped image\n Wimg=nib.Nifti1Image(W,refaff)\n nib.save(Wimg,ffaw)\n \n \ndef warp_displacements_tracks(fdpy,ffa,fmat,finv,fdis,fdisa,fref,fdpyw):\n \"\"\" Warp tracks from native space to the FMRIB58/MNI space\n \n We use here the fsl displacements. Have a look at create_displacements to\n see an example of how to use these displacements. \n \n Parameters\n ------------\n fdpy : filename of the .dpy file with the tractography\n ffa : filename of nifti to be warped\n fmat : filename of .mat (flirt)\n fdis : filename of displacements (fnirtfileutils)\n fdisa : filename of displacements (fnirtfileutils + affine)\n finv : filename of invwarp displacements (invwarp)\n fref : filename of reference volume e.g. (FMRIB58_FA_1mm.nii.gz)\n fdpyw : filename of the warped tractography\n \n \n See also\n -----------\n dipy.external.fsl.create_displacements\n \n \"\"\" \n \n #read the tracks from the image space \n dpr=Dpy(fdpy,'r')\n T=dpr.read_tracks()\n dpr.close() \n \n #copy them in a new file\n dpw=Dpy(fdpyw,'w',compression=1)\n dpw.write_tracks(T)\n dpw.close()\n \n #from fa index to ref index\n res=flirt2aff_files(fmat,ffa,fref)\n \n #load the reference img \n imgref=nib.load(fref)\n refaff=imgref.get_affine()\n \n #load the invwarp displacements\n imginvw=nib.load(finv)\n invwdata=imginvw.get_data()\n invwaff = imginvw.get_affine()\n \n #load the forward displacements\n imgdis=nib.load(fdis)\n disdata=imgdis.get_data()\n \n #load the forward displacements + affine\n imgdis2=nib.load(fdisa)\n disdata2=imgdis2.get_data()\n \n #from their difference create the affine\n disaff=disdata2-disdata\n \n del disdata\n del disdata2\n \n shape=nib.load(ffa).get_data().shape\n \n #transform the displacements affine back to image space\n disaff0=affine_transform(disaff[...,0],res[:3,:3],res[:3,3],shape,order=1)\n disaff1=affine_transform(disaff[...,1],res[:3,:3],res[:3,3],shape,order=1)\n disaff2=affine_transform(disaff[...,2],res[:3,:3],res[:3,3],shape,order=1)\n \n #remove the transformed affine from the invwarp displacements\n di=invwdata[:,:,:,0] + disaff0\n dj=invwdata[:,:,:,1] + disaff1\n dk=invwdata[:,:,:,2] + disaff2 \n \n dprw=Dpy(fdpyw,'r+')\n rows=len(dprw.f.root.streamlines.tracks) \n blocks=np.round(np.linspace(0,rows,10)).astype(int)#lets work in blocks\n #print rows\n for i in range(len(blocks)-1): \n #print blocks[i],blocks[i+1] \n #copy a lot of tracks together\n caboodle=dprw.f.root.streamlines.tracks[blocks[i]:blocks[i+1]]\n mci=mc(di,caboodle.T,order=1) #interpolations for i displacement\n mcj=mc(dj,caboodle.T,order=1) #interpolations for j displacement\n mck=mc(dk,caboodle.T,order=1) #interpolations for k displacement \n D=np.vstack((mci,mcj,mck)).T\n #go back to mni image space \n WI2=np.dot(caboodle,res[:3,:3].T)+res[:3,3]+D\n #and then to mni world space\n caboodlew=np.dot(WI2,refaff[:3,:3].T)+refaff[:3,3]\n #write back \n dprw.f.root.streamlines.tracks[blocks[i]:blocks[i+1]]=caboodlew.astype('f4')\n dprw.close()\n \ndef pipe(cmd):\n \"\"\" A tine pipeline system to run external tools.\n \n For more advanced pipelining use nipype http://www.nipy.org/nipype \n \"\"\"\n p = Popen(cmd, shell=True,stdout=PIPE,stderr=PIPE)\n sto=p.stdout.readlines()\n ste=p.stderr.readlines()\n print(sto)\n print(ste)\n\n\ndef dcm2nii(dname,outdir,filt='*.dcm',options='-d n -g n -i n -o'):\n cmd='dcm2nii '+options +' ' + outdir +' ' + dname + '/' + filt\n print(cmd)\n pipe(cmd)\n\n\ndef eddy_correct(in_nii,out_nii,ref=0):\n cmd='eddy_correct '+in_nii+' '+ out_nii + ' '+str(ref)\n print(cmd)\n pipe(cmd)\n\n\ndef bet(in_nii,out_nii,options=' -F -f .2 -g 0'):\n cmd='bet '+in_nii+' '+ out_nii + options\n print(cmd)\n pipe(cmd)\n\n\ndef run_flirt_imgs(in_img, ref_img, dof=6, flags=''):\n \"\"\" Run flirt on nibabel images, returning affine\n\n Parameters\n ----------\n in_img : `SpatialImage'\n image to register\n ref_img : `SpatialImage`\n image to register to\n dof : int, optional\n degrees of freedom for registration (default 6)\n flags : str, optional\n other flags to pass to flirt command string\n\n Returns\n -------\n in_vox2out_vox : (4,4) ndarray\n affine such that, if [i, j, k] is a coordinate in voxels in the\n `in_img`, and [p, q, r] are the equivalent voxel coordinates in the\n reference image, then [p, q, r] = np.dot(in_vox2out_vox[:3,:3]), [i, j,\n k] + in_vox2out_vox[:3,3])\n \"\"\"\n omat = 'reg.mat'\n with InTemporaryDirectory():\n nib.save(in_img, 'in.nii')\n nib.save(ref_img, 'ref.nii')\n cmd = 'flirt %s -dof %d -in in.nii -ref ref.nii -omat %s' % (\n flags, dof, omat)\n proc = Popen(cmd, shell=True,stdout=PIPE,stderr=PIPE)\n stdout, stderr = proc.communicate()\n if not os.path.isfile(omat):\n raise FSLError('Command \"%s\" failed somehow - stdout: %s\\n'\n 'and stderr: %s\\n' % (cmd, stdout, stderr))\n res = np.loadtxt(omat)\n return flirt2aff(res, in_img, ref_img)\n\n\ndef apply_warp(in_nii,affine_mat,nonlin_nii,out_nii):\n cmd='applywarp --ref=${FSLDIR}/data/standard/FMRIB58_FA_1mm --in='+in_nii+' --warp='+nonlin_nii+' --out='+out_nii\n print(cmd)\n pipe(cmd)\n\ndef create_displacements(in_nii,affine_mat,nonlin_nii,invw_nii,disp_nii,dispa_nii):\n commands=[] \n commands.append('flirt -ref ${FSLDIR}/data/standard/FMRIB58_FA_1mm -in '+in_nii+' -omat ' + affine_mat)\n commands.append('fnirt --in='+in_nii+' --aff='+affine_mat+' --cout='+nonlin_nii+' --config=FA_2_FMRIB58_1mm')\n commands.append('invwarp --ref='+in_nii+' --warp='+nonlin_nii+' --out='+invw_nii)\n commands.append('fnirtfileutils --in='+nonlin_nii+' --ref=${FSLDIR}/data/standard/FMRIB58_FA_1mm --out='+disp_nii)\n commands.append('fnirtfileutils --in='+nonlin_nii+' --ref=${FSLDIR}/data/standard/FMRIB58_FA_1mm --out='+dispa_nii + ' --withaff')\n for c in commands:\n print(c)\n pipe(c)\n", "meta": {"hexsha": "c46e7e99471ce546c423d0da75768827c46b33eb", "size": 13988, "ext": "py", "lang": "Python", "max_stars_repo_path": "dipy/external/fsl.py", "max_stars_repo_name": "stefanv/dipy", "max_stars_repo_head_hexsha": "4d4518861a796502826f053c17161487db126487", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2015-07-31T20:43:18.000Z", "max_stars_repo_stars_event_max_datetime": "2019-07-26T13:58:07.000Z", "max_issues_repo_path": "dipy/external/fsl.py", "max_issues_repo_name": "stefanv/dipy", "max_issues_repo_head_hexsha": "4d4518861a796502826f053c17161487db126487", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 9, "max_issues_repo_issues_event_min_datetime": "2015-05-13T17:44:42.000Z", "max_issues_repo_issues_event_max_datetime": "2018-05-27T20:09:55.000Z", "max_forks_repo_path": "dipy/external/fsl.py", "max_forks_repo_name": "stefanv/dipy", "max_forks_repo_head_hexsha": "4d4518861a796502826f053c17161487db126487", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2016-08-05T22:43:16.000Z", "max_forks_repo_forks_event_max_datetime": "2017-06-23T18:35:13.000Z", "avg_line_length": 35.0576441103, "max_line_length": 134, "alphanum_fraction": 0.6426222476, "include": true, "reason": "import numpy,from numpy,from scipy", "num_tokens": 4050, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5312093585306515, "lm_q2_score": 0.359364145160102, "lm_q1q2_score": 0.19089759702941372}} {"text": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\n\nCreated on Sun Aug 23 12:11:15 2020\n\nModified from the cornstover biorefinery constructed in Cortes-Peña et al., 2020,\nwith modification of fermentation system for 2,3-Butanediol instead of the original ethanol\n\n[1] Cortes-Peña et al., BioSTEAM: A Fast and Flexible Platform for the Design, \n Simulation, and Techno-Economic Analysis of Biorefineries under Uncertainty. \n ACS Sustainable Chem. Eng. 2020, 8 (8), 3302–3310. \n https://doi.org/10.1021/acssuschemeng.9b07040.\n\nAll units are explicitly defined here for transparency and easy reference\n\n[1] Cortes-Peña et al., BioSTEAM: A Fast and Flexible Platform for the Design, \n Simulation, and Techno-Economic Analysis of Biorefineries under Uncertainty. \n ACS Sustainable Chem. Eng. 2020, 8 (8), 3302–3310. \n https://doi.org/10.1021/acssuschemeng.9b07040.\n\nNaming conventions:\n D = Distillation column\n F = Flash tank\n H = Heat exchange\n M = Mixer\n P = Pump (including conveying belt)\n R = Reactor\n S = Splitter (including solid/liquid separator)\n T = Tank or bin for storage\n U = Other units\n PS = Process specificiation, not physical units, but for adjusting streams\n\nProcesses:\n 100: Feedstock preprocessing\n 200: Pretreatment\n 300: Conversion\n 400: Separation\n 500: Wastewater treatment\n 600: Facilities\n\n@author: sarangbhagwat\n\"\"\"\n\n\n# %% Setup\n\nimport biosteam as bst\nimport thermosteam as tmo\nimport flexsolve as flx\nimport numpy as np\nfrom biosteam import main_flowsheet as F\nfrom biorefineries import BST222\nfrom biorefineries.cornstover import CellulosicEthanolTEA\nfrom biosteam import System\nfrom thermosteam import Stream\nfrom biorefineries import BDO as bdo\nfrom biorefineries.BDO import units, facilities\nfrom biorefineries.BDO._process_specification import ProcessSpecification\nfrom biorefineries.BDO.process_settings import price, CFs\nfrom biorefineries.BDO.utils import find_split, splits_df, baseline_feedflow\nfrom biorefineries.BDO.chemicals_data import BDO_chemicals, chemical_groups, \\\n soluble_organics, combustibles\nfrom biorefineries.BDO.tea import BDOTEA\nfrom biorefineries.HP.lca import LCA\n\nbst.speed_up()\nflowsheet = bst.Flowsheet('BDO')\nbst.main_flowsheet.set_flowsheet(flowsheet)\nbst.System.default_relative_molar_tolerance = 1e-4\nbst.System.default_maxiter = 100\nbst.System.default_molar_tolerance = 0.1\n\n# Speeds up ShortcutDistillation\nbst.units.ShortcutColumn.minimum_guess_distillate_recovery = 0\n\n# Baseline cost year is 2016\nbst.CE = 541.7\n# _labor_2007to2016 = 22.71 / 19.55\n\n# Set default thermo object for the system\ntmo.settings.set_thermo(BDO_chemicals)\n\nBDO_sys = bdo.create_system_broth()\nu = flowsheet.unit\nfeedstock = BDO_sys.ins[0]\n# feedstock.mol[:] = baseline_feedflow[:]\nconc_aqueous_broth, = BDO_sys.outs\nget_flow_tpd = lambda: (feedstock.F_mass-feedstock.imass['H2O'])*24/907.185\nu = F.unit\ns = F.stream\n# globals().update(F.to_dict())\n\n# %%\n# =============================================================================\n# TEA\n# =============================================================================\n\n# BDO_tea = bst.CombinedTEA([BDO_no_BT_tea, BT_tea], IRR=0.10)\nBDO_tea = CellulosicEthanolTEA(system=BDO_sys, IRR=0.10, duration=(2016, 2046),\n depreciation='MACRS7', income_tax=0.21, operating_days=0.9*365,\n lang_factor=None, construction_schedule=(0.08, 0.60, 0.32),\n startup_months=3, startup_FOCfrac=1, startup_salesfrac=0.5,\n startup_VOCfrac=0.75, WC_over_FCI=0.05,\n finance_interest=0.08, finance_years=10, finance_fraction=0.4,\n # biosteam Splitters and Mixers have no cost, \n # cost of all wastewater treatment units are included in WWT_cost,\n # BT is not included in this TEA\n OSBL_units=bst.get_OSBL(BDO_sys.units),\n warehouse=0.04, site_development=0.09, additional_piping=0.045,\n proratable_costs=0.10, field_expenses=0.10, construction=0.20,\n contingency=0.10, other_indirect_costs=0.10, \n labor_cost=3212962*get_flow_tpd()/2205,\n labor_burden=0.90, property_insurance=0.007, maintenance=0.03,\n steam_power_depreciation='MACRS20', boiler_turbogenerator=u.BT701)\n\n# sub_units = BDO_sys.units[:BDO_sys.units.index(u.R401)]\n# sub_sys = bst.System(sub_units)\n# sub_tea = CellulosicEthanolTEA(system=sub_sys, IRR=0.10, duration=(2016, 2046),\n# depreciation='MACRS7', income_tax=0.21, operating_days=0.9*365,\n# lang_factor=None, construction_schedule=(0.08, 0.60, 0.32),\n# startup_months=3, startup_FOCfrac=1, startup_salesfrac=0.5,\n# startup_VOCfrac=0.75, WC_over_FCI=0.05,\n# finance_interest=0.08, finance_years=10, finance_fraction=0.4,\n# # biosteam Splitters and Mixers have no cost, \n# # cost of all wastewater treatment units are included in WWT_cost,\n# # BT is not included in this TEA\n# OSBL_units=bst.get_OSBL(sub_sys.units),\n# warehouse=0.04, site_development=0.09, additional_piping=0.045,\n# proratable_costs=0.10, field_expenses=0.10, construction=0.20,\n# contingency=0.10, other_indirect_costs=0.10, \n# labor_cost=3212962*get_flow_tpd()/2205,\n# labor_burden=0.90, property_insurance=0.007, maintenance=0.03,\n# steam_power_depreciation='MACRS20', boiler_turbogenerator=u.BT)\n\narea_names = [\n 'feedstock',\n 'pretreatment',\n 'conversion',\n 'separation',\n 'wastewater',\n 'storage',\n 'co-heat and power',\n 'cooling tower and chilled water package',\n 'other facilities',\n 'heat exchanger network',\n]\n# u.CWP901.ID = 'CWP802' \nfor ui in u:\n if type(ui) == bst.ChilledWaterPackage:\n ui.ID = 'CWP802' # group with CT for system cooling demand\n break\nunit_groups = bst.UnitGroup.group_by_area(BDO_sys.units)\nfor i, j in zip(unit_groups, area_names): i.name = j\nfor i in unit_groups: i.autofill_metrics(shorthand=True, \n electricity_production=True, \n material_cost=True)\nfor i in unit_groups:\n if i.name == 'storage' or i.name=='other facilities' or i.name == 'cooling tower and chilled water package':\n i.metrics[-1].getter = lambda: 0. # Material cost\n if i.name == 'cooling tower and chilled water package':\n i.metrics[1].getter = lambda: 0. # Cooling duty\nHXN = None\nfor HXN_group in unit_groups:\n if HXN_group.name == 'heat exchanger network':\n HXN_group.filter_savings = False\n HXN = HXN_group.units[0]\n assert isinstance(HXN, bst.HeatExchangerNetwork)\n\nunit_groups_dict = {}\nfor i in unit_groups:\n unit_groups_dict[i.name] = i\n# HXN.force_ideal_thermo = True\nCT = u.CT801\nBT = u.BT701\nCWP = u.CWP802\n\n# %% \n# =============================================================================\n# Simulate system and get results\n# =============================================================================\n\nTEA_feeds = set([i for i in BDO_sys.feeds if i.price])\n\nTEA_products = set([i for i in BDO_sys.products if i.price])\nconc_aqueous_broth.price = 0.\ndef get_conc_aqueous_broth_MPSP():\n BDO_sys.simulate()\n \n for i in range(3):\n conc_aqueous_broth.price = BDO_tea.solve_price(conc_aqueous_broth)\n return conc_aqueous_broth.price\n\nM401, F401 = flowsheet('M401'), flowsheet('F401')\ndef set_target_BDO_x(target_BDO_x):\n F401.target_BDO_x = target_BDO_x\n M401.target_BDO_x = target_BDO_x\n \ndef get_x(chem_ID, stream):\n return stream.imol[chem_ID]/sum(stream.imol[tuple([i.ID for i in stream.vle_chemicals])])\n\n# get_conc_aqueous_broth_MPSP()\n\n# R301 = F('R301') # Fermentor\nseed_train_system = bst.System('seed_train_system', path=(u.S302, u.R303, u.T301))\n\n# yearly_production = 125000 # ton/yr\nspec = ProcessSpecification(\n evaporator = u.F301,\n evaporator_pump = u.F301_P,\n pump = u.M304_H_P,\n mixer = u.M304,\n heat_exchanger = u.M304_H,\n seed_train_system = seed_train_system,\n reactor= u.R302,\n reaction_name='fermentation_reaction',\n substrates=('Xylose', 'Glucose'),\n products=('BDO',),\n spec_1=0.36,\n spec_2=109.9,\n spec_3=1.,\n xylose_utilization_fraction = 0.80,\n feedstock = feedstock,\n dehydration_reactor = None,\n byproduct_streams = [],\n HXN = u.HXN1001,\n tolerable_HXN_energy_balance_percent_error=5,\n maximum_inhibitor_concentration = 1.,\n # pre_conversion_units = process_groups_dict['feedstock_group'].units + process_groups_dict['pretreatment_group'].units + [u.H301], # if the line below does not work (depends on BioSTEAM version)\n # pre_conversion_units = BDO_sys.split(u.F301.ins[0])[0],\n baseline_titer = 54.8,\n feedstock_mass = feedstock.F_mass,\n pretreatment_reactor = u.R201)\n\n\n\nspec.load_spec_1 = spec.load_yield\nspec.load_spec_2 = spec.load_titer\nspec.load_spec_3 = spec.load_productivity\n\n\n# spec = ProcessSpecification(\n# evaporator = u.F301,\n# mixer = u.M304,\n# reactor=u.R302,\n# reaction_name='fermentation_reaction',\n# substrates=('Xylose', 'Glucose'),\n# products=('BDO',),\n# spec_1=0.8,\n# spec_2=109.9,\n# spec_3=1.,\n# path = (u.M304_H, u.M304_H_P),\n# xylose_utilization_fraction = 0.80,\n# feedstock = feedstock,\n# dehydration_reactor = u.R401,\n# byproduct_streams = [s.isobutanol],\n# evaporator_pump = u.F301_P)\n\npath = (u.F301, u.R302)\n@np.vectorize\ndef calculate_titer(V):\n u.F301.V = V\n for i in path: i._run()\n return spec._calculate_titer()\n\n@np.vectorize \ndef calculate_MPSP(V):\n u.F301.V = V\n BDO_sys.simulate()\n MPSP = conc_aqueous_broth.price = BDO_tea.solve_price(conc_aqueous_broth)\n return MPSP\n\n# vapor_fractions = np.linspace(0.20, 0.80)\n# titers = calculate_titer(vapor_fractions)\n# MPSPs = calculate_MPSP(vapor_fractions)\n# import matplotlib.pyplot as plt\n# plt.plot(vapor_fractions, titers)\n# plt.show()\n\n# plt.plot(titers, MPSPs)\n# plt.show() \n\n# %%\n\n# =============================================================================\n# Life cycle analysis (LCA), waste disposal emission not included\n# =============================================================================\n\n# 100-year global warming potential (GWP) from material flows\nLCA_streams = TEA_feeds.copy()\nLCA_stream = Stream('LCA_stream', units='kg/hr')\n\nget_Isobutanol_GWP = lambda: 0.\nget_Isobutanol_FEC = lambda: 0.\n\ndef get_material_GWP():\n LCA_stream.mass = sum(i.mass for i in LCA_streams)\n chemical_GWP = LCA_stream.mass*CFs['GWP_CF_stream'].mass\n # feedstock_GWP = feedstock.F_mass*CFs['GWP_CFs']['Corn stover']\n return chemical_GWP.sum()/conc_aqueous_broth.F_mass\n\n# GWP from combustion of non-biogenic carbons\nget_non_bio_GWP = lambda: (s.natural_gas.get_atomic_flow('C') \n + s.oleyl_alcohol.get_atomic_flow('C')) \\\n * BDO_chemicals.CO2.MW / conc_aqueous_broth.F_mass\n\n# GWP from electricity\nget_electricity_use = lambda: sum(i.power_utility.rate for i in BDO_sys.units)\nget_electricity_GWP = lambda: get_electricity_use()*CFs['GWP_CFs']['Electricity'] \\\n / conc_aqueous_broth.F_mass\n\n# CO2 fixed in lactic acid product\nget_fixed_GWP = lambda: \\\n conc_aqueous_broth.get_atomic_flow('C')*BDO_chemicals.CO2.MW/conc_aqueous_broth.F_mass\n\nget_GWP = lambda: get_material_GWP()+get_non_bio_GWP()+get_electricity_GWP() - get_Isobutanol_GWP()\n\n# Fossil energy consumption (FEC) from materials\ndef get_material_FEC():\n LCA_stream.mass = sum(i.mass for i in LCA_streams)\n chemical_FEC = LCA_stream.mass*CFs['FEC_CF_stream'].mass\n # feedstock_FEC = feedstock.F_mass*CFs['FEC_CFs']['Corn stover']\n return chemical_FEC.sum()/conc_aqueous_broth.F_mass\n\n# FEC from electricity\nget_electricity_FEC = lambda: \\\n get_electricity_use()*CFs['FEC_CFs']['Electricity']/conc_aqueous_broth.F_mass\n\n# Total FEC\nget_FEC = lambda: get_material_FEC() + get_electricity_FEC() - get_Isobutanol_FEC()\n\nget_SPED = lambda: u.BT.system_heating_demand*0.001/conc_aqueous_broth.F_mass\nconc_aqueous_broth_LHV = 31.45 # MJ/kg conc_aqueous_broth\n\nBDO_lca = LCA(BDO_sys, BDO_chemicals, CFs, feedstock, 'Corn stover', conc_aqueous_broth, [CT, CWP], BT=BT, CT=CT)\n\n#%% TEA breakdown\ndef TEA_breakdown():\n metric_breakdowns = {i.name: {} for i in unit_groups[0].metrics}\n for ug in unit_groups:\n for metric in ug.metrics:\n # storage_metric_val = None\n if not ug.name=='storage':\n if ug.name=='other facilities':\n metric_breakdowns[metric.name]['storage and ' + ug.name] = metric() + unit_groups[5].metrics[ug.metrics.index(metric)]()\n else:\n metric_breakdowns[metric.name][ug.name] = metric()\n # else:\n # storage_metric_val = metric()\n \n # return metric_breakdowns\n for i in unit_groups[0].metrics:\n print(f\"\\n\\n----- {i.name} ({i.units}) -----\")\n metric_breakdowns_i = metric_breakdowns[i.name]\n for j in metric_breakdowns_i.keys():\n print(f\"{j}: {format(metric_breakdowns_i[j], '.3f')}\")\n\n# %% LCA breakdown\n\ndef FEC_breakdown():\n return {\n 'feedstock': BDO_lca.feedstock_FEC,\n 'heating demand': BDO_lca.heating_demand_FEC,\n 'cooling demand': BDO_lca.cooling_demand_FEC,\n 'electricity demand (non-cooling)': BDO_lca.electricity_demand_non_cooling_FEC,\n 'other materials': BDO_lca.material_FEC,\n }\n\ndef GWP_breakdown():\n return {\n 'feedstock': BDO_lca.FGHTP_GWP,\n 'heating demand': BDO_lca.heating_demand_GWP,\n 'cooling demand': BDO_lca.cooling_demand_GWP,\n 'electricity demand (non-cooling)': BDO_lca.electricity_demand_non_cooling_GWP,\n 'other direct non-biogenic emissions': BDO_lca.non_BT_direct_emissions_GWP,\n 'other materials': BDO_lca.material_GWP,\n }\n\n\n# %% Full analysis\nget_conc_aqueous_broth_MPSP()\n\nR302 = flowsheet('R302')\nset_target_BDO_x(250e-6)\n# Overall yield assuming yield on xylose is 80% of yield on glucose:\n# (0.64*0.36+0.36*0.8*0.36) * 2 = 0.33408 * 2\n# saccharified stream mass ratio of glucose:xylose is 0.64:0.36\n\n\n# to achieve $1.98/kg: spec_1=0.353*2\nspec.load_specifications(0.33408*2, 109.9, 1.0)\n\ndef print_recycles():\n sys = BDO_sys.copy()\n sys.flatten()\n for i in sys.recycle:\n print(i, i.imass['OleylAlcohol'] / 1e3)\n\ndef print_capital_cost():\n print('TCI', BDO_tea.TCI / 1e6, 'MM$')\n print('Fermentation installed cost', u.R302.installed_cost / 1e6, 'MM$')\n print(u.R302.results())\n\ndef print_specs():\n print(spec.spec_1, spec.spec_2, spec.spec_3)\n\ndef simulate_and_print():\n get_conc_aqueous_broth_MPSP()\n print('\\n---------- Simulation Results ----------')\n # print_recycles()\n # print_specs()\n # print_capital_cost()\n print(f'MPSP is ${get_conc_aqueous_broth_MPSP():.3f}/kg')\n print(f'GWP is {BDO_lca.GWP:.3f} kg CO2-eq/kg conc_aqueous_broth')\n # print(f'Non-bio GWP is {():.3f} kg CO2-eq/kg conc_aqueous_broth')\n print(f'FEC is {BDO_lca.FEC:.2f} MJ/kg conc_aqueous_broth or {get_FEC()/conc_aqueous_broth_LHV:.2f} MJ/MJ conc_aqueous_broth')\n # print(f'SPED is {get_SPED():.2f} MJ/kg conc_aqueous_broth or {get_SPED()/conc_aqueous_broth_LHV:.2f} MJ/MJ conc_aqueous_broth')\n print('--------------------\\n')\n\nsimulate_and_print()\n# spec.load_specifications(0.36, 13.7, 1.0)\n# simulate_and_print()\n# spec.load_specifications(0.36, 109.9, 1.0)\n# simulate_and_print()\n\n# %% Maximum BDO titer (given by maximum sugar concentration)\n\n\n\n# %%% conc_aqueous_broth environmental impacts\n\n# GREET 2020:\n# GHG100 = 1.04 kgCO2-eq/kg\n# FEC = 43 MJ/kg\n# Ecoinvent 3.7.1:\n# IPCC 2013 GWP100 = 1.9166 kgCO2-eq/kg\n# CED-f = 58.707 MJ/kg\n\n# %%\n\n# =============================================================================\n# For Monte Carlo and analyses\n# =============================================================================\n\n# BDO_sub_sys = {\n# 'feedstock_sys': (U101,),\n# 'pretreatment_sys': (T201, M201, M202, M203, \n# R201, R201_H, T202, T203,\n# F201, F201_H,\n# M204, T204, T204_P,\n# M205, M205_P),\n# 'conversion_sys': (H301, M301, M302, R301, R302, T301),\n # 'separation_sys': (u.S401, u.M401, u.M401_P,\n # u.S402, \n # # F401, F401_H, F401_P,\n # u.D401, u.D401_H, u.D401_P, u.S403,\n # u.M402_P, u.S403,\n # u.D403, u.D403_H, u.D403_P,\n # u.M501,\n # u.T606, u.T606_P)\n # F402, F402_H, F402_P,\n # D405, D405_H1, D405_H2, D405_P,\n # M401, M401_P)\n# 'wastewater_sys': (M501, WWT_cost, R501,\n# M502, R502, S501, S502, M503,\n# M504, S503, S504, M505),\n# 'HXN': (HXN,),\n# 'BT': (BT,),\n# 'CT': (CT,),\n# 'other_facilities': (T601, S601,\n# T602, T603,\n# T604, T604_P,\n# T605, T605_P,\n# T606, T606_P,\n# PWC, CIP, ADP, FWT)\n # }\n\n\n\n\n", "meta": {"hexsha": "9c552353811c9079fed9657b8f8f612f988860ee", "size": 17275, "ext": "py", "lang": "Python", "max_stars_repo_path": "BioSTEAM 2.x.x/biorefineries/BDO/system_broth.py", "max_stars_repo_name": "yoelcortes/Bioindustrial-Complex", "max_stars_repo_head_hexsha": "d39edfec88e443ef7a62218ca0215e3b105f4b96", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-01-03T21:04:41.000Z", "max_stars_repo_stars_event_max_datetime": "2020-01-09T01:15:48.000Z", "max_issues_repo_path": "BioSTEAM 2.x.x/biorefineries/BDO/system_broth.py", "max_issues_repo_name": "yoelcortes/Bioindustrial-Complex", "max_issues_repo_head_hexsha": "d39edfec88e443ef7a62218ca0215e3b105f4b96", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 6, "max_issues_repo_issues_event_min_datetime": "2020-01-03T21:31:27.000Z", "max_issues_repo_issues_event_max_datetime": "2020-02-28T13:53:56.000Z", "max_forks_repo_path": "BioSTEAM 2.x.x/biorefineries/BDO/system_broth.py", "max_forks_repo_name": "yoelcortes/Bioindustrial-Complex", "max_forks_repo_head_hexsha": "d39edfec88e443ef7a62218ca0215e3b105f4b96", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-01-07T14:04:06.000Z", "max_forks_repo_forks_event_max_datetime": "2020-01-08T23:05:25.000Z", "avg_line_length": 35.9147609148, "max_line_length": 199, "alphanum_fraction": 0.6475253256, "include": true, "reason": "import numpy", "num_tokens": 5133, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5312093585306515, "lm_q2_score": 0.35936413143782797, "lm_q1q2_score": 0.19089758974001333}} {"text": "# -*- coding: utf-8 -*-\n# vim: tabstop=4 shiftwidth=4 softtabstop=4\n\n#\n# LICENSE\n#\n# Copyright (C) 2010-2018 GEM Foundation, G. Weatherill, M. Pagani,\n# D. Monelli.\n#\n# The Hazard Modeller's Toolkit is free software: you can redistribute\n# it and/or modify it under the terms of the GNU Affero General Public\n# License as published by the Free Software Foundation, either version\n# 3 of the License, or (at your option) any later version.\n#\n# You should have received a copy of the GNU Affero General Public License\n# along with OpenQuake. If not, see \n#\n# DISCLAIMER\n#\n# The software Hazard Modeller's Toolkit (openquake.hmtk) provided herein\n# is released as a prototype implementation on behalf of\n# scientists and engineers working within the GEM Foundation (Global\n# Earthquake Model).\n#\n# It is distributed for the purpose of open collaboration and in the\n# hope that it will be useful to the scientific, engineering, disaster\n# risk and software design communities.\n#\n# The software is NOT distributed as part of GEM’s OpenQuake suite\n# (https://www.globalquakemodel.org/tools-products) and must be considered as a\n# separate entity. The software provided herein is designed and implemented\n# by scientific staff. It is not developed to the design standards, nor\n# subject to same level of critical review by professional software\n# developers, as GEM’s OpenQuake software suite.\n#\n# Feedback and contribution to the software is welcome, and can be\n# directed to the hazard scientific staff of the GEM Model Facility\n# (hazard@globalquakemodel.org).\n#\n# The Hazard Modeller's Toolkit (openquake.hmtk) is therefore distributed WITHOUT\n# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\n# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License\n# for more details.\n#\n# The GEM Foundation, and the authors of the software, assume no\n# liability for use of the software.\n\nimport numpy as np\n\nfrom openquake.hmtk.seismicity.declusterer.base import (\n BaseCatalogueDecluster, DECLUSTERER_METHODS)\nfrom openquake.hmtk.seismicity.utils import decimal_year, haversine\nfrom openquake.hmtk.seismicity.declusterer.distance_time_windows import (\n TIME_DISTANCE_WINDOW_FUNCTIONS)\n\n\n@DECLUSTERER_METHODS.add(\n \"decluster\",\n time_distance_window=TIME_DISTANCE_WINDOW_FUNCTIONS,\n time_window=np.float)\nclass Afteran(BaseCatalogueDecluster):\n \"\"\"\n This implements the Afteran algorithm as described in this paper:\n Musson, R. (1999), Probabilistic seismic hazard maps for the North\n Balkan Region, Annali Di Geofisica, 42(6), 1109 - 1124\n \"\"\"\n\n def decluster(self, catalogue, config):\n \"\"\"\n catalogue_matrix, window_opt=TDW_GARDNERKNOPOFF, time_window=60.):\n\n :param catalogue: a catalogue object\n :type catalogue: Instance of the openquake.hmtk.seismicity.catalogue.Catalogue()\n class\n :keyword window_opt: method used in calculating distance and time\n windows\n :type window_opt: string\n :keyword time_window: Length (in days) of moving time window\n :type time_window: positive float\n :returns: **vcl vector** indicating cluster number,\n **flagvector** indicating which earthquakes belong to a\n cluster\n :rtype: numpy.ndarray\n \"\"\"\n # Convert time window from days to decimal years\n time_window = config['time_window'] / 365.\n # Pre-processing steps are the same as for Gardner & Knopoff\n # Get relevent parameters\n mag = catalogue.data['magnitude']\n neq = np.shape(mag)[0] # Number of earthquakes\n # Get decimal year (needed for time windows)\n year_dec = decimal_year(catalogue.data['year'],\n catalogue.data['month'],\n catalogue.data['day'])\n # Get space windows corresponding to each event\n sw_space, _ = (\n config['time_distance_window'].calc(catalogue.data['magnitude']))\n\n # Pre-allocate cluster index vectors\n vcl = np.zeros(neq, dtype=int)\n flagvector = np.zeros(neq, dtype=int)\n # Rank magnitudes into descending order\n id0 = np.flipud(np.argsort(mag, kind='heapsort'))\n\n clust_index = 0\n for imarker in id0:\n # Earthquake not allocated to cluster - perform calculation\n if vcl[imarker] == 0:\n # Perform distance calculation\n mdist = haversine(\n catalogue.data['longitude'],\n catalogue.data['latitude'],\n catalogue.data['longitude'][imarker],\n catalogue.data['latitude'][imarker]).flatten()\n\n # Select earthquakes inside distance window, later than\n # mainshock and not already assigned to a cluster\n vsel1 = np.where(\n np.logical_and(vcl == 0,\n np.logical_and(\n mdist <= sw_space[imarker],\n year_dec > year_dec[imarker])))[0]\n has_aftershocks = False\n if len(vsel1) > 0:\n # Earthquakes after event inside distance window\n temp_vsel1, has_aftershocks = self._find_aftershocks(\n vsel1,\n year_dec,\n time_window,\n imarker,\n neq)\n if has_aftershocks:\n flagvector[temp_vsel1] = 1\n vcl[temp_vsel1] = clust_index + 1\n\n # Select earthquakes inside distance window, earlier than\n # mainshock and not already assigned to a cluster\n has_foreshocks = False\n vsel2 = np.where(\n np.logical_and(\n vcl == 0,\n np.logical_and(mdist <= sw_space[imarker],\n year_dec < year_dec[imarker])))[0]\n if len(vsel2) > 0:\n # Earthquakes before event inside distance window\n temp_vsel2, has_foreshocks = self._find_foreshocks(\n vsel2,\n year_dec,\n time_window,\n imarker,\n neq)\n if has_foreshocks:\n flagvector[temp_vsel2] = -1\n vcl[temp_vsel2] = clust_index + 1\n\n if has_aftershocks or has_foreshocks:\n # Assign mainshock to cluster\n vcl[imarker] = clust_index + 1\n clust_index += 1\n\n return vcl, flagvector\n\n def _find_aftershocks(self, vsel, year_dec, time_window, imarker, neq):\n '''\n Function to identify aftershocks from a set of potential\n events inside the distance window of an earthquake.\n :param vsel: Pointer vector to the location of the events in distance\n window\n :type vsel: numpy.ndarray\n :param year_dec: Vector of decimal catalogue event times\n :type year_dec: numpy.ndarray\n :param time_window: Moving time window for selection of time clusters\n :type time_window: float\n :param imarker: Index of the mainshock in the catalogue vector\n :type imarker: Integer\n :param neq: Number of events in distance window of mainshock\n :type neq: Integer\n '''\n temp_vsel1 = np.zeros(neq, dtype=bool)\n has_aftershocks = False\n\n # Finds the time difference between events\n delta_time = np.diff(\n np.hstack([year_dec[imarker], year_dec[vsel]]))\n for iloc in range(0, len(vsel)):\n # If time difference between event is smaller than\n # time window - is an aftershock -> continue\n\n if delta_time[iloc] < time_window:\n temp_vsel1[vsel[iloc]] = True\n has_aftershocks = True\n else:\n # Time difference between events is larger than\n # window -> no more aftershocks -> return\n return temp_vsel1, has_aftershocks\n\n return temp_vsel1, has_aftershocks\n\n def _find_foreshocks(self, vsel, year_dec, time_window, imarker, neq):\n '''\n Finds foreshocks from a set of potential events within\n the distance window of a mainshock.\n :param vsel: Pointer vector to the location of the events in distance\n window\n :type vsel: numpy.ndarray\n :param year_dec: Vector of decimal catalogue event times\n :type year_dec: numpy.ndarray\n :param time_window: Moving time window for selection of time clusters\n :type time_window: float\n :param imarker: Index of the mainshock in the catalogue vector\n :type imarker: Integer\n :param neq: Number of events in distance window of mainshock\n :type neq: Integer\n '''\n\n temp_vsel2 = np.zeros(neq, dtype=bool)\n has_foreshocks = False\n\n # The initial time is the time of the mainshock\n initial_time = year_dec[imarker]\n year_dec = year_dec[vsel]\n for jloc in range(len(vsel) - 1, -1, -1):\n # If the time between the mainshock and the preceeding\n # event is smaller than the time_window then event\n # is a foreshock\n\n if (initial_time - year_dec[jloc]) < time_window:\n temp_vsel2[vsel[jloc]] = True\n has_foreshocks = True\n # Update target time to consider current foreshock\n # Then continue\n initial_time = year_dec[jloc]\n else:\n # No events inside time window\n # end of foreshock sequence - return\n return temp_vsel2, has_foreshocks\n\n return temp_vsel2, has_foreshocks\n", "meta": {"hexsha": "3536056b7535f3e05be260f13c2beccf10a07146", "size": 10043, "ext": "py", "lang": "Python", "max_stars_repo_path": "openquake/hmtk/seismicity/declusterer/dec_afteran.py", "max_stars_repo_name": "gfzriesgos/shakyground-lfs", "max_stars_repo_head_hexsha": "2caf67cc32e6800286eded2df1efb05973ccf41b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-08-01T00:28:24.000Z", "max_stars_repo_stars_event_max_datetime": "2019-08-01T00:28:24.000Z", "max_issues_repo_path": "openquake/hmtk/seismicity/declusterer/dec_afteran.py", "max_issues_repo_name": "gfzriesgos/shakyground-lfs", "max_issues_repo_head_hexsha": "2caf67cc32e6800286eded2df1efb05973ccf41b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2018-08-31T14:14:35.000Z", "max_issues_repo_issues_event_max_datetime": "2021-10-11T12:53:13.000Z", "max_forks_repo_path": "openquake/hmtk/seismicity/declusterer/dec_afteran.py", "max_forks_repo_name": "gfzriesgos/shakyground-lfs", "max_forks_repo_head_hexsha": "2caf67cc32e6800286eded2df1efb05973ccf41b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2018-08-31T14:11:00.000Z", "max_forks_repo_forks_event_max_datetime": "2019-07-17T10:06:02.000Z", "avg_line_length": 42.0209205021, "max_line_length": 88, "alphanum_fraction": 0.6089813801, "include": true, "reason": "import numpy", "num_tokens": 2234, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230157, "lm_q2_score": 0.37022540649291935, "lm_q1q2_score": 0.1908955928943983}} {"text": "# Helper functions for running autoencoder\n\nimport os\nimport argparse\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport tensorflow as tf\n\n# To ensure reproducibility using Keras during development\n# https://keras.io/getting-started/faq/#how-can-i-obtain-reproducible-results-using-keras-during-development\nimport numpy as np\nimport random as rn\n\n# The below is necessary in Python 3.2.3 onwards to\n# have reproducible behavior for certain hash-based operations.\n# See these references for further details:\n# https://docs.python.org/3.4/using/cmdline.html#envvar-PYTHONHASHSEED\n# https://github.com/keras-team/keras/issues/2280#issuecomment-306959926\nrandomState = 123\nimport os\nos.environ['PYTHONHASHSEED'] = '0'\n\n# The below is necessary for starting Numpy generated random numbers\n# in a well-defined initial state.\n\nnp.random.seed(42)\n\n# The below is necessary for starting core Python generated random numbers\n# in a well-defined state.\n\nrn.seed(12345)\n\n# Force TensorFlow to use single thread.\n# Multiple threads are a potential source of\n# non-reproducible results.\n# For further details, see: https://stackoverflow.com/questions/42022950/which-seeds-have-to-be-set-where-to-realize-100-reproducibility-of-training-res\n\nsession_conf = tf.ConfigProto(\n intra_op_parallelism_threads=1, inter_op_parallelism_threads=1)\n\nfrom keras import backend as K\n\n# The below tf.set_random_seed() will make random number generation\n# in the TensorFlow backend have a well-defined initial state.\n# For further details, see: https://www.tensorflow.org/api_docs/python/tf/set_random_seed\n\ntf.set_random_seed(1234)\n\nsess = tf.Session(graph=tf.get_default_graph(), config=session_conf)\nK.set_session(sess)\n\nfrom keras.layers import Input, Dense, Lambda, Layer, Activation\nfrom keras.layers.normalization import BatchNormalization\nfrom keras.models import Model, Sequential\nfrom keras import metrics, optimizers\nfrom keras.callbacks import Callback\n\n# Functions\n#\n# Based on publication by Way et. al. (https://www.ncbi.nlm.nih.gov/pmc/articles/PMC5728678/)\n# Github repo (https://github.com/greenelab/tybalt/blob/master/scripts/vae_pancancer.py)\n\n\n# Function for reparameterization trick to make model differentiable\n\n\ndef sampling_maker(epsilon_std):\n def sampling(args):\n # Function with args required for Keras Lambda function\n z_mean, z_log_var = args\n\n # Draw epsilon of the same shape from a standard normal distribution\n epsilon = K.random_normal(shape=tf.shape(z_mean), mean=0.,\n stddev=epsilon_std)\n\n # The latent vector is non-deterministic and differentiable\n # in respect to z_mean and z_log_var\n z = z_mean + K.exp(z_log_var / 2) * epsilon\n return z\n return sampling\n\n\nclass CustomVariationalLayer(Layer):\n \"\"\"\n Define a custom layer that learns and performs the training\n \"\"\"\n\n def __init__(self, original_dim, z_log_var_encoded,\n z_mean_encoded, beta, **kwargs):\n # https://keras.io/layers/writing-your-own-keras-layers/\n self.is_placeholder = True\n self.original_dim = original_dim\n self.z_log_var_encoded = z_log_var_encoded\n self.z_mean_encoded = z_mean_encoded\n self.beta = beta\n\n super(CustomVariationalLayer, self).__init__(**kwargs)\n\n def vae_loss(self, x_input, x_decoded):\n reconstruction_loss = self.original_dim * \\\n metrics.binary_crossentropy(x_input, x_decoded)\n \n kl_loss = - 0.5 * K.sum(1 + self.z_log_var_encoded \n - K.square(self.z_mean_encoded) \n - K.exp(self.z_log_var_encoded), axis=-1)\n \n return K.mean(reconstruction_loss + (K.get_value(self.beta) * kl_loss))\n\n def call(self, inputs):\n x = inputs[0]\n x_decoded = inputs[1]\n loss = self.vae_loss(x, x_decoded)\n self.add_loss(loss, inputs=inputs)\n # We won't actually use the output.\n return x\n\n\nclass WarmUpCallback(Callback):\n def __init__(self, beta, kappa):\n self.beta = beta\n self.kappa = kappa\n\n # Behavior on each epoch\n def on_epoch_end(self, epoch, logs={}):\n if K.get_value(self.beta) <= 1:\n K.set_value(self.beta, K.get_value(self.beta) + self.kappa)\n", "meta": {"hexsha": "6fac04b808c6527b91cc29f97f88a4236f5887be", "size": 4316, "ext": "py", "lang": "Python", "max_stars_repo_path": "archive/scripts/functions/helper_ae.py", "max_stars_repo_name": "ajlee21/Batch_effects_simulation", "max_stars_repo_head_hexsha": "d707321346de48de5e63cf251280bdf9372be59c", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2020-05-04T15:16:32.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-28T04:49:21.000Z", "max_issues_repo_path": "archive/scripts/functions/helper_ae.py", "max_issues_repo_name": "ajlee21/Batch_effects_simulation", "max_issues_repo_head_hexsha": "d707321346de48de5e63cf251280bdf9372be59c", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-02-27T20:12:36.000Z", "max_issues_repo_issues_event_max_datetime": "2021-04-07T20:28:35.000Z", "max_forks_repo_path": "archive/scripts/functions/helper_ae.py", "max_forks_repo_name": "ajlee21/Batch_effects_simulation", "max_forks_repo_head_hexsha": "d707321346de48de5e63cf251280bdf9372be59c", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-06-02T18:29:17.000Z", "max_forks_repo_forks_event_max_datetime": "2020-02-13T09:33:37.000Z", "avg_line_length": 33.9842519685, "max_line_length": 152, "alphanum_fraction": 0.7099165894, "include": true, "reason": "import numpy", "num_tokens": 1013, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230156, "lm_q2_score": 0.37022540649291935, "lm_q1q2_score": 0.19089559289439825}} {"text": "# Copyright (c) Pymatgen Development Team.\n# Distributed under the terms of the MIT License.\n\n\"\"\"\nThis module implements a FloatWithUnit, which is a subclass of float. It\nalso defines supported units for some commonly used units for energy, length,\ntemperature, time and charge. FloatWithUnit also support conversion to one\nanother, and additions and subtractions perform automatic conversion if\nunits are detected. An ArrayWithUnit is also implemented, which is a subclass\nof numpy's ndarray with similar unit features.\n\"\"\"\n\nimport collections\nimport numbers\nfrom functools import partial\n\nimport numpy as np\nimport scipy.constants as const\n\n__author__ = \"Shyue Ping Ong, Matteo Giantomassi\"\n__copyright__ = \"Copyright 2011, The Materials Project\"\n__version__ = \"1.0\"\n__maintainer__ = \"Shyue Ping Ong, Matteo Giantomassi\"\n__status__ = \"Production\"\n__date__ = \"Aug 30, 2013\"\n\n\"\"\"\nSome conversion factors\n\"\"\"\nHa_to_eV = 1 / const.physical_constants[\"electron volt-hartree relationship\"][0]\neV_to_Ha = 1 / Ha_to_eV\nRy_to_eV = Ha_to_eV / 2\namu_to_kg = const.physical_constants[\"atomic mass unit-kilogram relationship\"][0]\nmile_to_meters = const.mile\nbohr_to_angstrom = const.physical_constants[\"Bohr radius\"][0] * 1e10\nbohr_to_ang = bohr_to_angstrom\nang_to_bohr = 1 / bohr_to_ang\nkCal_to_kJ = const.calorie\nkb = const.physical_constants[\"Boltzmann constant in eV/K\"][0]\n\n\"\"\"\nDefinitions of supported units. Values below are essentially scaling and\nconversion factors. What matters is the relative values, not the absolute.\nThe SI units must have factor 1.\n\"\"\"\nBASE_UNITS = {\n \"length\": {\n \"m\": 1,\n \"km\": 1000,\n \"mile\": mile_to_meters,\n \"ang\": 1e-10,\n \"cm\": 1e-2,\n \"pm\": 1e-12,\n \"bohr\": bohr_to_angstrom * 1e-10,\n },\n \"mass\": {\n \"kg\": 1,\n \"g\": 1e-3,\n \"amu\": amu_to_kg,\n },\n \"time\": {\n \"s\": 1,\n \"min\": 60,\n \"h\": 3600,\n \"d\": 3600 * 24,\n },\n \"current\": {\"A\": 1},\n \"temperature\": {\n \"K\": 1,\n },\n \"amount\": {\"mol\": 1, \"atom\": 1 / const.N_A},\n \"intensity\": {\"cd\": 1},\n \"memory\": {\n \"byte\": 1,\n \"Kb\": 1024,\n \"Mb\": 1024**2,\n \"Gb\": 1024**3,\n \"Tb\": 1024**4,\n },\n}\n\n# Accept kb, mb, gb ... as well.\nBASE_UNITS[\"memory\"].update({k.lower(): v for k, v in BASE_UNITS[\"memory\"].items()})\n\n# This current list are supported derived units defined in terms of powers of\n# SI base units and constants.\nDERIVED_UNITS = {\n \"energy\": {\n \"eV\": {\"kg\": 1, \"m\": 2, \"s\": -2, const.e: 1},\n \"meV\": {\"kg\": 1, \"m\": 2, \"s\": -2, const.e * 1e-3: 1},\n \"Ha\": {\"kg\": 1, \"m\": 2, \"s\": -2, const.e * Ha_to_eV: 1},\n \"Ry\": {\"kg\": 1, \"m\": 2, \"s\": -2, const.e * Ry_to_eV: 1},\n \"J\": {\"kg\": 1, \"m\": 2, \"s\": -2},\n \"kJ\": {\"kg\": 1, \"m\": 2, \"s\": -2, 1000: 1},\n \"kCal\": {\"kg\": 1, \"m\": 2, \"s\": -2, 1000: 1, kCal_to_kJ: 1},\n },\n \"charge\": {\n \"C\": {\"A\": 1, \"s\": 1},\n \"e\": {\"A\": 1, \"s\": 1, const.e: 1},\n },\n \"force\": {\n \"N\": {\"kg\": 1, \"m\": 1, \"s\": -2},\n \"KN\": {\"kg\": 1, \"m\": 1, \"s\": -2, 1000: 1},\n \"MN\": {\"kg\": 1, \"m\": 1, \"s\": -2, 1e6: 1},\n \"GN\": {\"kg\": 1, \"m\": 1, \"s\": -2, 1e9: 1},\n },\n \"frequency\": {\n \"Hz\": {\"s\": -1},\n \"KHz\": {\"s\": -1, 1000: 1},\n \"MHz\": {\"s\": -1, 1e6: 1},\n \"GHz\": {\"s\": -1, 1e9: 1},\n \"THz\": {\"s\": -1, 1e12: 1},\n },\n \"pressure\": {\n \"Pa\": {\"kg\": 1, \"m\": -1, \"s\": -2},\n \"KPa\": {\"kg\": 1, \"m\": -1, \"s\": -2, 1000: 1},\n \"MPa\": {\"kg\": 1, \"m\": -1, \"s\": -2, 1e6: 1},\n \"GPa\": {\"kg\": 1, \"m\": -1, \"s\": -2, 1e9: 1},\n },\n \"power\": {\n \"W\": {\"m\": 2, \"kg\": 1, \"s\": -3},\n \"KW\": {\"m\": 2, \"kg\": 1, \"s\": -3, 1000: 1},\n \"MW\": {\"m\": 2, \"kg\": 1, \"s\": -3, 1e6: 1},\n \"GW\": {\"m\": 2, \"kg\": 1, \"s\": -3, 1e9: 1},\n },\n \"emf\": {\"V\": {\"m\": 2, \"kg\": 1, \"s\": -3, \"A\": -1}},\n \"capacitance\": {\"F\": {\"m\": -2, \"kg\": -1, \"s\": 4, \"A\": 2}},\n \"resistance\": {\"ohm\": {\"m\": 2, \"kg\": 1, \"s\": -3, \"A\": -2}},\n \"conductance\": {\"S\": {\"m\": -2, \"kg\": -1, \"s\": 3, \"A\": 2}},\n \"magnetic_flux\": {\"Wb\": {\"m\": 2, \"kg\": 1, \"s\": -2, \"A\": -1}},\n \"cross_section\": {\"barn\": {\"m\": 2, 1e-28: 1}, \"mbarn\": {\"m\": 2, 1e-31: 1}},\n}\n\nALL_UNITS = dict(list(BASE_UNITS.items()) + list(DERIVED_UNITS.items())) # type: ignore\nSUPPORTED_UNIT_NAMES = tuple(i for d in ALL_UNITS.values() for i in d.keys())\n\n# Mapping unit name --> unit type (unit names must be unique).\n_UNAME2UTYPE = {} # type: ignore\nfor utype, d in ALL_UNITS.items():\n assert not set(d.keys()).intersection(_UNAME2UTYPE.keys())\n _UNAME2UTYPE.update({uname: utype for uname in d})\ndel utype, d\n\n\ndef _get_si_unit(unit):\n unit_type = _UNAME2UTYPE[unit]\n si_unit = filter(lambda k: BASE_UNITS[unit_type][k] == 1, BASE_UNITS[unit_type].keys())\n return list(si_unit)[0], BASE_UNITS[unit_type][unit]\n\n\nclass UnitError(BaseException):\n \"\"\"\n Exception class for unit errors.\n \"\"\"\n\n\ndef _check_mappings(u):\n for v in DERIVED_UNITS.values():\n for k2, v2 in v.items():\n if all(v2.get(ku, 0) == vu for ku, vu in u.items()) and all(\n u.get(kv2, 0) == vv2 for kv2, vv2 in v2.items()\n ):\n return {k2: 1}\n return u\n\n\nclass Unit(collections.abc.Mapping):\n \"\"\"\n Represents a unit, e.g., \"m\" for meters, etc. Supports compound units.\n Only integer powers are supported for units.\n \"\"\"\n\n Error = UnitError\n\n def __init__(self, unit_def):\n \"\"\"\n Constructs a unit.\n\n Args:\n unit_def: A definition for the unit. Either a mapping of unit to\n powers, e.g., {\"m\": 2, \"s\": -1} represents \"m^2 s^-1\",\n or simply as a string \"kg m^2 s^-1\". Note that the supported\n format uses \"^\" as the power operator and all units must be\n space-separated.\n \"\"\"\n\n if isinstance(unit_def, str):\n unit = collections.defaultdict(int)\n import re\n\n for m in re.finditer(r\"([A-Za-z]+)\\s*\\^*\\s*([\\-0-9]*)\", unit_def):\n p = m.group(2)\n p = 1 if not p else int(p)\n k = m.group(1)\n unit[k] += p\n else:\n unit = {k: v for k, v in dict(unit_def).items() if v != 0}\n self._unit = _check_mappings(unit)\n\n def __mul__(self, other):\n new_units = collections.defaultdict(int)\n for k, v in self.items():\n new_units[k] += v\n for k, v in other.items():\n new_units[k] += v\n return Unit(new_units)\n\n def __rmul__(self, other):\n return self.__mul__(other)\n\n def __div__(self, other):\n new_units = collections.defaultdict(int)\n for k, v in self.items():\n new_units[k] += v\n for k, v in other.items():\n new_units[k] -= v\n return Unit(new_units)\n\n def __truediv__(self, other):\n return self.__div__(other)\n\n def __pow__(self, i):\n return Unit({k: v * i for k, v in self.items()})\n\n def __iter__(self):\n return self._unit.__iter__()\n\n def __getitem__(self, i):\n return self._unit[i]\n\n def __len__(self):\n return len(self._unit)\n\n def __repr__(self):\n sorted_keys = sorted(self._unit.keys(), key=lambda k: (-self._unit[k], k))\n return \" \".join(\n [f\"{k}^{self._unit[k]}\" if self._unit[k] != 1 else k for k in sorted_keys if self._unit[k] != 0]\n )\n\n def __str__(self):\n return self.__repr__()\n\n @property\n def as_base_units(self):\n \"\"\"\n Converts all units to base SI units, including derived units.\n\n Returns:\n (base_units_dict, scaling factor). base_units_dict will not\n contain any constants, which are gathered in the scaling factor.\n \"\"\"\n b = collections.defaultdict(int)\n factor = 1\n for k, v in self.items():\n derived = False\n for d in DERIVED_UNITS.values():\n if k in d:\n for k2, v2 in d[k].items():\n if isinstance(k2, numbers.Number):\n factor *= k2 ** (v2 * v)\n else:\n b[k2] += v2 * v\n derived = True\n break\n if not derived:\n si, f = _get_si_unit(k)\n b[si] += v\n factor *= f**v\n return {k: v for k, v in b.items() if v != 0}, factor\n\n def get_conversion_factor(self, new_unit):\n \"\"\"\n Returns a conversion factor between this unit and a new unit.\n Compound units are supported, but must have the same powers in each\n unit type.\n\n Args:\n new_unit: The new unit.\n \"\"\"\n uo_base, ofactor = self.as_base_units\n un_base, nfactor = Unit(new_unit).as_base_units\n units_new = sorted(un_base.items(), key=lambda d: _UNAME2UTYPE[d[0]])\n units_old = sorted(uo_base.items(), key=lambda d: _UNAME2UTYPE[d[0]])\n factor = ofactor / nfactor\n for uo, un in zip(units_old, units_new):\n if uo[1] != un[1]:\n raise UnitError(f\"Units {uo} and {un} are not compatible!\")\n c = ALL_UNITS[_UNAME2UTYPE[uo[0]]]\n factor *= (c[uo[0]] / c[un[0]]) ** uo[1]\n return factor\n\n\nclass FloatWithUnit(float):\n \"\"\"\n Subclasses float to attach a unit type. Typically, you should use the\n pre-defined unit type subclasses such as Energy, Length, etc. instead of\n using FloatWithUnit directly.\n\n Supports conversion, addition and subtraction of the same unit type. E.g.,\n 1 m + 20 cm will be automatically converted to 1.2 m (units follow the\n leftmost quantity). Note that FloatWithUnit does not override the eq\n method for float, i.e., units are not checked when testing for equality.\n The reason is to allow this class to be used transparently wherever floats\n are expected.\n\n >>> e = Energy(1.1, \"Ha\")\n >>> a = Energy(1.1, \"Ha\")\n >>> b = Energy(3, \"eV\")\n >>> c = a + b\n >>> print(c)\n 1.2102479761938871 Ha\n >>> c.to(\"eV\")\n 32.932522246000005 eV\n \"\"\"\n\n Error = UnitError\n\n @classmethod\n def from_string(cls, s):\n \"\"\"\n Initialize a FloatWithUnit from a string. Example Memory.from_string(\"1. Mb\")\n \"\"\"\n # Extract num and unit string.\n s = s.strip()\n for i, char in enumerate(s):\n if char.isalpha() or char.isspace():\n break\n else:\n raise Exception(f\"Unit is missing in string {s}\")\n num, unit = float(s[:i]), s[i:]\n\n # Find unit type (set it to None if it cannot be detected)\n for unit_type, d in BASE_UNITS.items():\n if unit in d:\n break\n else:\n unit_type = None\n\n return cls(num, unit, unit_type=unit_type)\n\n def __new__(cls, val, unit, unit_type=None):\n \"\"\"Overrides __new__ since we are subclassing a Python primitive/\"\"\"\n new = float.__new__(cls, val)\n new._unit = Unit(unit)\n new._unit_type = unit_type\n return new\n\n def __init__(self, val, unit, unit_type=None):\n \"\"\"\n Initializes a float with unit.\n\n Args:\n val (float): Value\n unit (Unit): A unit. E.g., \"C\".\n unit_type (str): A type of unit. E.g., \"charge\"\n \"\"\"\n if unit_type is not None and str(unit) not in ALL_UNITS[unit_type]:\n raise UnitError(f\"{unit} is not a supported unit for {unit_type}\")\n self._unit = Unit(unit)\n self._unit_type = unit_type\n\n def __repr__(self):\n return super().__repr__()\n\n def __str__(self):\n s = super().__str__()\n return f\"{s} {self._unit}\"\n\n def __add__(self, other):\n if not hasattr(other, \"unit_type\"):\n return super().__add__(other)\n if other.unit_type != self._unit_type:\n raise UnitError(\"Adding different types of units is not allowed\")\n val = other\n if other.unit != self._unit:\n val = other.to(self._unit)\n return FloatWithUnit(float(self) + val, unit_type=self._unit_type, unit=self._unit)\n\n def __sub__(self, other):\n if not hasattr(other, \"unit_type\"):\n return super().__sub__(other)\n if other.unit_type != self._unit_type:\n raise UnitError(\"Subtracting different units is not allowed\")\n val = other\n if other.unit != self._unit:\n val = other.to(self._unit)\n return FloatWithUnit(float(self) - val, unit_type=self._unit_type, unit=self._unit)\n\n def __mul__(self, other):\n if not isinstance(other, FloatWithUnit):\n return FloatWithUnit(float(self) * other, unit_type=self._unit_type, unit=self._unit)\n return FloatWithUnit(float(self) * other, unit_type=None, unit=self._unit * other._unit)\n\n def __rmul__(self, other):\n if not isinstance(other, FloatWithUnit):\n return FloatWithUnit(float(self) * other, unit_type=self._unit_type, unit=self._unit)\n return FloatWithUnit(float(self) * other, unit_type=None, unit=self._unit * other._unit)\n\n def __pow__(self, i):\n return FloatWithUnit(float(self) ** i, unit_type=None, unit=self._unit**i)\n\n def __truediv__(self, other):\n val = super().__truediv__(other)\n if not isinstance(other, FloatWithUnit):\n return FloatWithUnit(val, unit_type=self._unit_type, unit=self._unit)\n return FloatWithUnit(val, unit_type=None, unit=self._unit / other._unit)\n\n def __neg__(self):\n return FloatWithUnit(super().__neg__(), unit_type=self._unit_type, unit=self._unit)\n\n def __getnewargs__(self):\n \"\"\"Function used by pickle to recreate object.\"\"\"\n # print(self.__dict__)\n # FIXME\n # There's a problem with _unit_type if we try to unpickle objects from file.\n # since self._unit_type might not be defined. I think this is due to\n # the use of decorators (property and unitized). In particular I have problems with \"amu\"\n # likely due to weight in core.composition\n if hasattr(self, \"_unit_type\"):\n args = float(self), self._unit, self._unit_type\n else:\n args = float(self), self._unit, None\n\n return args\n\n def __getstate__(self):\n state = self.__dict__.copy()\n state[\"val\"] = float(self)\n return state\n\n def __setstate__(self, state):\n self._unit = state[\"_unit\"]\n\n @property\n def unit_type(self) -> str:\n \"\"\"\n :return: The type of unit. Energy, Charge, etc.\n \"\"\"\n return self._unit_type\n\n @property\n def unit(self) -> str:\n \"\"\"\n :return: The unit, e.g., \"eV\".\n \"\"\"\n return self._unit\n\n def to(self, new_unit):\n \"\"\"\n Conversion to a new_unit. Right now, only supports 1 to 1 mapping of\n units of each type.\n\n Args:\n new_unit: New unit type.\n\n Returns:\n A FloatWithUnit object in the new units.\n\n Example usage:\n >>> e = Energy(1.1, \"eV\")\n >>> e = Energy(1.1, \"Ha\")\n >>> e.to(\"eV\")\n 29.932522246 eV\n \"\"\"\n return FloatWithUnit(\n self * self.unit.get_conversion_factor(new_unit),\n unit_type=self._unit_type,\n unit=new_unit,\n )\n\n @property\n def as_base_units(self):\n \"\"\"\n Returns this FloatWithUnit in base SI units, including derived units.\n\n Returns:\n A FloatWithUnit object in base SI units\n \"\"\"\n return self.to(self.unit.as_base_units[0])\n\n @property\n def supported_units(self):\n \"\"\"\n Supported units for specific unit type.\n \"\"\"\n return tuple(ALL_UNITS[self._unit_type].keys())\n\n\nclass ArrayWithUnit(np.ndarray):\n \"\"\"\n Subclasses `numpy.ndarray` to attach a unit type. Typically, you should\n use the pre-defined unit type subclasses such as EnergyArray,\n LengthArray, etc. instead of using ArrayWithFloatWithUnit directly.\n\n Supports conversion, addition and subtraction of the same unit type. E.g.,\n 1 m + 20 cm will be automatically converted to 1.2 m (units follow the\n leftmost quantity).\n\n >>> a = EnergyArray([1, 2], \"Ha\")\n >>> b = EnergyArray([1, 2], \"eV\")\n >>> c = a + b\n >>> print(c)\n [ 1.03674933 2.07349865] Ha\n >>> c.to(\"eV\")\n array([ 28.21138386, 56.42276772]) eV\n \"\"\"\n\n Error = UnitError\n\n def __new__(cls, input_array, unit, unit_type=None):\n \"\"\"\n Override __new__.\n \"\"\"\n # Input array is an already formed ndarray instance\n # We first cast to be our class type\n obj = np.asarray(input_array).view(cls)\n # add the new attributes to the created instance\n obj._unit = Unit(unit)\n obj._unit_type = unit_type\n return obj\n\n def __array_finalize__(self, obj):\n \"\"\"\n See http://docs.scipy.org/doc/numpy/user/basics.subclassing.html for\n comments.\n \"\"\"\n if obj is None:\n return\n self._unit = getattr(obj, \"_unit\", None)\n self._unit_type = getattr(obj, \"_unit_type\", None)\n\n @property\n def unit_type(self) -> str:\n \"\"\"\n :return: The type of unit. Energy, Charge, etc.\n \"\"\"\n return self._unit_type\n\n @property\n def unit(self) -> str:\n \"\"\"\n :return: The unit, e.g., \"eV\".\n \"\"\"\n return self._unit\n\n def __reduce__(self):\n # print(\"in reduce\")\n reduce = list(super().__reduce__())\n # print(\"unit\",self._unit)\n # print(reduce[2])\n reduce[2] = {\"np_state\": reduce[2], \"_unit\": self._unit}\n return tuple(reduce)\n\n def __setstate__(self, state):\n # pylint: disable=E1101\n super().__setstate__(state[\"np_state\"])\n self._unit = state[\"_unit\"]\n\n def __repr__(self):\n return f\"{np.array(self).__repr__()} {self.unit}\"\n\n def __str__(self):\n return f\"{np.array(self).__str__()} {self.unit}\"\n\n def __add__(self, other):\n if hasattr(other, \"unit_type\"):\n if other.unit_type != self.unit_type:\n raise UnitError(\"Adding different types of units is not allowed\")\n\n if other.unit != self.unit:\n other = other.to(self.unit)\n\n return self.__class__(np.array(self) + np.array(other), unit_type=self.unit_type, unit=self.unit)\n\n def __sub__(self, other):\n if hasattr(other, \"unit_type\"):\n if other.unit_type != self.unit_type:\n raise UnitError(\"Subtracting different units is not allowed\")\n\n if other.unit != self.unit:\n other = other.to(self.unit)\n\n return self.__class__(np.array(self) - np.array(other), unit_type=self.unit_type, unit=self.unit)\n\n def __mul__(self, other):\n # FIXME\n # Here we have the most important difference between FloatWithUnit and\n # ArrayWithFloatWithUnit:\n # If other does not have units, I return an object with the same units\n # as self.\n # if other *has* units, I return an object *without* units since\n # taking into account all the possible derived quantities would be\n # too difficult.\n # Moreover Energy(1.0) * Time(1.0, \"s\") returns 1.0 Ha that is a\n # bit misleading.\n # Same protocol for __div__\n if not hasattr(other, \"unit_type\"):\n return self.__class__(\n np.array(self).__mul__(np.array(other)),\n unit_type=self._unit_type,\n unit=self._unit,\n )\n # Cannot use super since it returns an instance of self.__class__\n # while here we want a bare numpy array.\n return self.__class__(np.array(self).__mul__(np.array(other)), unit=self.unit * other.unit)\n\n def __rmul__(self, other):\n # pylint: disable=E1101\n if not hasattr(other, \"unit_type\"):\n return self.__class__(\n np.array(self).__rmul__(np.array(other)),\n unit_type=self._unit_type,\n unit=self._unit,\n )\n return self.__class__(np.array(self).__rmul__(np.array(other)), unit=self.unit * other.unit)\n\n def __div__(self, other):\n # pylint: disable=E1101\n if not hasattr(other, \"unit_type\"):\n return self.__class__(\n np.array(self).__div__(np.array(other)),\n unit_type=self._unit_type,\n unit=self._unit,\n )\n return self.__class__(np.array(self).__div__(np.array(other)), unit=self.unit / other.unit)\n\n def __truediv__(self, other):\n # pylint: disable=E1101\n if not hasattr(other, \"unit_type\"):\n return self.__class__(\n np.array(self).__truediv__(np.array(other)),\n unit_type=self._unit_type,\n unit=self._unit,\n )\n return self.__class__(np.array(self).__truediv__(np.array(other)), unit=self.unit / other.unit)\n\n def __neg__(self):\n return self.__class__(np.array(self).__neg__(), unit_type=self.unit_type, unit=self.unit)\n\n def to(self, new_unit):\n \"\"\"\n Conversion to a new_unit.\n\n Args:\n new_unit:\n New unit type.\n\n Returns:\n A ArrayWithFloatWithUnit object in the new units.\n\n Example usage:\n >>> e = EnergyArray([1, 1.1], \"Ha\")\n >>> e.to(\"eV\")\n array([ 27.21138386, 29.93252225]) eV\n \"\"\"\n return self.__class__(\n np.array(self) * self.unit.get_conversion_factor(new_unit),\n unit_type=self.unit_type,\n unit=new_unit,\n )\n\n @property\n def as_base_units(self):\n \"\"\"\n Returns this ArrayWithUnit in base SI units, including derived units.\n\n Returns:\n An ArrayWithUnit object in base SI units\n \"\"\"\n return self.to(self.unit.as_base_units[0])\n\n # TODO abstract base class property?\n @property\n def supported_units(self):\n \"\"\"\n Supported units for specific unit type.\n \"\"\"\n return ALL_UNITS[self.unit_type]\n\n # TODO abstract base class method?\n def conversions(self):\n \"\"\"\n Returns a string showing the available conversions.\n Useful tool in interactive mode.\n \"\"\"\n return \"\\n\".join(str(self.to(unit)) for unit in self.supported_units)\n\n\ndef _my_partial(func, *args, **kwargs):\n \"\"\"\n Partial returns a partial object and therefore we cannot inherit class\n methods defined in FloatWithUnit. This function calls partial and patches\n the new class before returning.\n \"\"\"\n newobj = partial(func, *args, **kwargs)\n # monkey patch\n newobj.from_string = FloatWithUnit.from_string\n return newobj\n\n\nEnergy = partial(FloatWithUnit, unit_type=\"energy\")\n\"\"\"\nA float with an energy unit.\n\nArgs:\n val (float): Value\n unit (Unit): E.g., eV, kJ, etc. Must be valid unit or UnitError is raised.\n\"\"\"\nEnergyArray = partial(ArrayWithUnit, unit_type=\"energy\")\n\nLength = partial(FloatWithUnit, unit_type=\"length\")\n\"\"\"\nA float with a length unit.\n\nArgs:\n val (float): Value\n unit (Unit): E.g., m, ang, bohr, etc. Must be valid unit or UnitError is\n raised.\n\"\"\"\nLengthArray = partial(ArrayWithUnit, unit_type=\"length\")\n\nMass = partial(FloatWithUnit, unit_type=\"mass\")\n\"\"\"\nA float with a mass unit.\n\nArgs:\n val (float): Value\n unit (Unit): E.g., amu, kg, etc. Must be valid unit or UnitError is\n raised.\n\"\"\"\nMassArray = partial(ArrayWithUnit, unit_type=\"mass\")\n\nTemp = partial(FloatWithUnit, unit_type=\"temperature\")\n\"\"\"\nA float with a temperature unit.\n\nArgs:\n val (float): Value\n unit (Unit): E.g., K. Only K (kelvin) is supported.\n\"\"\"\nTempArray = partial(ArrayWithUnit, unit_type=\"temperature\")\n\nTime = partial(FloatWithUnit, unit_type=\"time\")\n\"\"\"\nA float with a time unit.\n\nArgs:\n val (float): Value\n unit (Unit): E.g., s, min, h. Must be valid unit or UnitError is\n raised.\n\"\"\"\nTimeArray = partial(ArrayWithUnit, unit_type=\"time\")\n\nCharge = partial(FloatWithUnit, unit_type=\"charge\")\n\"\"\"\nA float with a charge unit.\n\nArgs:\n val (float): Value\n unit (Unit): E.g., C, e (electron charge). Must be valid unit or UnitError\n is raised.\n\"\"\"\nChargeArray = partial(ArrayWithUnit, unit_type=\"charge\")\n\nMemory = _my_partial(FloatWithUnit, unit_type=\"memory\")\n\"\"\"\nA float with a memory unit.\n\nArgs:\n val (float): Value\n unit (Unit): E.g., Kb, Mb, Gb, Tb. Must be valid unit or UnitError\n is raised.\n\"\"\"\n\n\ndef obj_with_unit(obj, unit):\n \"\"\"\n Returns a `FloatWithUnit` instance if obj is scalar, a dictionary of\n objects with units if obj is a dict, else an instance of\n `ArrayWithFloatWithUnit`.\n\n Args:\n unit: Specific units (eV, Ha, m, ang, etc.).\n \"\"\"\n unit_type = _UNAME2UTYPE[unit]\n\n if isinstance(obj, numbers.Number):\n return FloatWithUnit(obj, unit=unit, unit_type=unit_type)\n if isinstance(obj, collections.abc.Mapping):\n return {k: obj_with_unit(v, unit) for k, v in obj.items()}\n return ArrayWithUnit(obj, unit=unit, unit_type=unit_type)\n\n\ndef unitized(unit):\n \"\"\"\n Useful decorator to assign units to the output of a function. You can also\n use it to standardize the output units of a function that already returns\n a FloatWithUnit or ArrayWithUnit. For sequences, all values in the sequences\n are assigned the same unit. It works with Python sequences only. The creation\n of numpy arrays loses all unit information. For mapping types, the values\n are assigned units.\n\n Args:\n unit: Specific unit (eV, Ha, m, ang, etc.).\n\n Example usage::\n\n @unitized(unit=\"kg\")\n def get_mass():\n return 123.45\n\n \"\"\"\n\n def wrap(f):\n def wrapped_f(*args, **kwargs):\n val = f(*args, **kwargs)\n unit_type = _UNAME2UTYPE[unit]\n\n if isinstance(val, (FloatWithUnit, ArrayWithUnit)):\n return val.to(unit)\n\n if isinstance(val, collections.abc.Sequence):\n # TODO: why don't we return a ArrayWithUnit?\n # This complicated way is to ensure the sequence type is\n # preserved (list or tuple).\n return val.__class__([FloatWithUnit(i, unit_type=unit_type, unit=unit) for i in val])\n if isinstance(val, collections.abc.Mapping):\n for k, v in val.items():\n val[k] = FloatWithUnit(v, unit_type=unit_type, unit=unit)\n elif isinstance(val, numbers.Number):\n return FloatWithUnit(val, unit_type=unit_type, unit=unit)\n elif val is None:\n pass\n else:\n raise TypeError(f\"Don't know how to assign units to {str(val)}\")\n return val\n\n return wrapped_f\n\n return wrap\n\n\nif __name__ == \"__main__\":\n import doctest\n\n doctest.testmod()\n", "meta": {"hexsha": "ab2b3048e485e2cca443facf01ae2cb7362b293e", "size": 27043, "ext": "py", "lang": "Python", "max_stars_repo_path": "pymatgen/core/units.py", "max_stars_repo_name": "dskoda/pymatgen", "max_stars_repo_head_hexsha": "ba23f32abd857c92d5fdd19a8b62b17af6697841", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-03-24T04:12:16.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T04:12:16.000Z", "max_issues_repo_path": "pymatgen/core/units.py", "max_issues_repo_name": "dskoda/pymatgen", "max_issues_repo_head_hexsha": "ba23f32abd857c92d5fdd19a8b62b17af6697841", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pymatgen/core/units.py", "max_forks_repo_name": "dskoda/pymatgen", "max_forks_repo_head_hexsha": "ba23f32abd857c92d5fdd19a8b62b17af6697841", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.9279811098, "max_line_length": 108, "alphanum_fraction": 0.5765632511, "include": true, "reason": "import numpy,import scipy", "num_tokens": 7224, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230156, "lm_q2_score": 0.37022540649291935, "lm_q1q2_score": 0.19089559289439825}} {"text": "import torch\nimport torch.utils.data\nimport math\nimport numpy as np\nfrom collections import defaultdict\n\n\ndef pad(species):\n \"\"\"Put different species together into single tensor.\n\n If the species are from molecules of different number of total atoms, then\n ghost atoms with atom type -1 will be added to make it fit into the same\n shape.\n\n Arguments:\n species (:class:`collections.abc.Sequence`): sequence of species.\n Species must be of shape ``(N, A)``, where ``N`` is the number of\n 3D structures, ``A`` is the number of atoms.\n\n Returns:\n :class:`torch.Tensor`: species batched together.\n \"\"\"\n max_atoms = max([s.shape[1] for s in species])\n padded_species = []\n for s in species:\n natoms = s.shape[1]\n if natoms < max_atoms:\n padding = torch.full((s.shape[0], max_atoms - natoms), -1,\n dtype=torch.long, device=s.device)\n s = torch.cat([s, padding], dim=1)\n padded_species.append(s)\n return torch.cat(padded_species)\n\n\ndef pad_atomic_properties(atomic_properties, padding_values=defaultdict(lambda: 0.0, species=-1)):\n \"\"\"Put a sequence of atomic properties together into single tensor.\n\n Inputs are `[{'species': ..., ...}, {'species': ..., ...}, ...]` and the outputs\n are `{'species': padded_tensor, ...}`\n\n Arguments:\n species_coordinates (:class:`collections.abc.Sequence`): sequence of\n atomic properties.\n padding_values (dict): the value to fill to pad tensors to same size\n \"\"\"\n keys = list(atomic_properties[0])\n anykey = keys[0]\n max_atoms = max(x[anykey].shape[1] for x in atomic_properties)\n padded = {k: [] for k in keys}\n for p in atomic_properties:\n num_molecules = 1\n for v in p.values():\n assert num_molecules in {1, v.shape[0]}, 'Number of molecules in different atomic properties mismatch'\n if v.shape[0] != 1:\n num_molecules = v.shape[0]\n for k, v in p.items():\n shape = list(v.shape)\n padatoms = max_atoms - shape[1]\n shape[1] = padatoms\n padding = v.new_full(shape, padding_values[k])\n v = torch.cat([v, padding], dim=1)\n shape = list(v.shape)\n shape[0] = num_molecules\n v = v.expand(*shape)\n padded[k].append(v)\n return {k: torch.cat(v) for k, v in padded.items()}\n\n\n# @torch.jit.script\ndef present_species(species):\n \"\"\"Given a vector of species of atoms, compute the unique species present.\n\n Arguments:\n species (:class:`torch.Tensor`): 1D vector of shape ``(atoms,)``\n\n Returns:\n :class:`torch.Tensor`: 1D vector storing present atom types sorted.\n \"\"\"\n # present_species, _ = species.flatten()._unique(sorted=True)\n present_species = species.flatten().unique(sorted=True)\n if present_species[0].item() == -1:\n present_species = present_species[1:]\n return present_species\n\n\ndef strip_redundant_padding(atomic_properties):\n \"\"\"Strip trailing padding atoms.\n\n Arguments:\n atomic_properties (dict): properties to strip\n\n Returns:\n dict: same set of properties with redundant padding atoms stripped.\n \"\"\"\n species = atomic_properties['species']\n non_padding = (species >= 0).any(dim=0).nonzero().squeeze()\n for k in atomic_properties:\n atomic_properties[k] = atomic_properties[k].index_select(1, non_padding)\n return atomic_properties\n\n\ndef map2central(cell, coordinates, pbc):\n \"\"\"Map atoms outside the unit cell into the cell using PBC.\n\n Arguments:\n cell (:class:`torch.Tensor`): tensor of shape (3, 3) of the three\n vectors defining unit cell:\n\n .. code-block:: python\n\n tensor([[x1, y1, z1],\n [x2, y2, z2],\n [x3, y3, z3]])\n\n coordinates (:class:`torch.Tensor`): Tensor of shape\n ``(molecules, atoms, 3)``.\n\n pbc (:class:`torch.Tensor`): boolean vector of size 3 storing\n if pbc is enabled for that direction.\n\n Returns:\n :class:`torch.Tensor`: coordinates of atoms mapped back to unit cell.\n \"\"\"\n # Step 1: convert coordinates from standard cartesian coordinate to unit\n # cell coordinates\n inv_cell = torch.inverse(cell)\n coordinates_cell = torch.matmul(coordinates, inv_cell)\n # Step 2: wrap cell coordinates into [0, 1)\n coordinates_cell -= coordinates_cell.floor() * pbc.to(coordinates_cell.dtype)\n # Step 3: convert from cell coordinates back to standard cartesian\n # coordinate\n return torch.matmul(coordinates_cell, cell)\n\n\nclass EnergyShifter(torch.nn.Module):\n \"\"\"Helper class for adding and subtracting self atomic energies\n\n This is a subclass of :class:`torch.nn.Module`, so it can be used directly\n in a pipeline as ``[input->AEVComputer->ANIModel->EnergyShifter->output]``.\n\n Arguments:\n self_energies (:class:`collections.abc.Sequence`): Sequence of floating\n numbers for the self energy of each atom type. The numbers should\n be in order, i.e. ``self_energies[i]`` should be atom type ``i``.\n fit_intercept (bool): Whether to calculate the intercept during the LSTSQ\n fit. The intercept will also be taken into account to shift energies.\n \"\"\"\n\n def __init__(self, self_energies, fit_intercept=False):\n super(EnergyShifter, self).__init__()\n\n self.fit_intercept = fit_intercept\n if self_energies is not None:\n self_energies = torch.tensor(self_energies, dtype=torch.double)\n\n self.register_buffer('self_energies', self_energies)\n\n def sae_from_dataset(self, atomic_properties, properties):\n \"\"\"Compute atomic self energies from dataset.\n\n Least-squares solution to a linear equation is calculated to output\n ``self_energies`` when ``self_energies = None`` is passed to\n :class:`torchani.EnergyShifter`\n \"\"\"\n species = atomic_properties['species']\n energies = properties['energies']\n present_species_ = present_species(species)\n X = (species.unsqueeze(-1) == present_species_).sum(dim=1).to(torch.double)\n # Concatenate a vector of ones to find fit intercept\n if self.fit_intercept:\n X = torch.cat((X, torch.ones(X.shape[0], 1).to(torch.double)), dim=-1)\n y = energies.unsqueeze(dim=-1)\n coeff_, _, _, _ = np.linalg.lstsq(X, y, rcond=None)\n return coeff_.squeeze()\n\n def sae(self, species):\n \"\"\"Compute self energies for molecules.\n\n Padding atoms will be automatically excluded.\n\n Arguments:\n species (:class:`torch.Tensor`): Long tensor in shape\n ``(conformations, atoms)``.\n\n Returns:\n :class:`torch.Tensor`: 1D vector in shape ``(conformations,)``\n for molecular self energies.\n \"\"\"\n intercept = 0.0\n if self.fit_intercept:\n intercept = self.self_energies[-1]\n\n self_energies = self.self_energies[species]\n self_energies[species == -1] = 0\n return self_energies.sum(dim=1) + intercept\n\n def subtract_from_dataset(self, atomic_properties, properties):\n \"\"\"Transformer for :class:`torchani.data.BatchedANIDataset` that\n subtract self energies.\n \"\"\"\n if self.self_energies is None:\n self_energies = self.sae_from_dataset(atomic_properties, properties)\n self.self_energies = torch.tensor(self_energies, dtype=torch.double)\n\n species = atomic_properties['species']\n energies = properties['energies']\n device = energies.device\n energies = energies.to(torch.double) - self.sae(species).to(device)\n properties['energies'] = energies\n return atomic_properties, properties\n\n def forward(self, species_energies):\n \"\"\"(species, molecular energies)->(species, molecular energies + sae)\n \"\"\"\n species, energies = species_energies\n sae = self.sae(species).to(energies.dtype).to(energies.device)\n return species, energies + sae\n\n\nclass ChemicalSymbolsToInts:\n \"\"\"Helper that can be called to convert chemical symbol string to integers\n\n Arguments:\n all_species (:class:`collections.abc.Sequence` of :class:`str`):\n sequence of all supported species, in order.\n \"\"\"\n\n def __init__(self, all_species):\n self.rev_species = {}\n for i, s in enumerate(all_species):\n self.rev_species[s] = i\n\n def __call__(self, species):\n \"\"\"Convert species from squence of strings to 1D tensor\"\"\"\n rev = [self.rev_species[s] for s in species]\n return torch.tensor(rev, dtype=torch.long)\n\n\ndef hessian(coordinates, energies=None, forces=None):\n \"\"\"Compute analytical hessian from the energy graph or force graph.\n\n Arguments:\n coordinates (:class:`torch.Tensor`): Tensor of shape `(molecules, atoms, 3)`\n energies (:class:`torch.Tensor`): Tensor of shape `(molecules,)`, if specified,\n then `forces` must be `None`. This energies must be computed from\n `coordinates` in a graph.\n forces (:class:`torch.Tensor`): Tensor of shape `(molecules, atoms, 3)`, if specified,\n then `energies` must be `None`. This forces must be computed from\n `coordinates` in a graph.\n\n Returns:\n :class:`torch.Tensor`: Tensor of shape `(molecules, 3A, 3A)` where A is the number of\n atoms in each molecule\n \"\"\"\n if energies is None and forces is None:\n raise ValueError('Energies or forces must be specified')\n if energies is not None and forces is not None:\n raise ValueError('Energies or forces can not be specified at the same time')\n if forces is None:\n forces = -torch.autograd.grad(energies.sum(), coordinates, create_graph=True)[0]\n flattened_force = forces.flatten(start_dim=1)\n force_components = flattened_force.unbind(dim=1)\n return -torch.stack([\n torch.autograd.grad(f.sum(), coordinates, retain_graph=True)[0].flatten(start_dim=1)\n for f in force_components\n ], dim=1)\n\n\ndef vibrational_analysis(masses, hessian, unit='cm^-1'):\n \"\"\"Computing the vibrational wavenumbers from hessian.\"\"\"\n if unit != 'cm^-1':\n raise ValueError('Only cm^-1 are supported right now')\n assert hessian.shape[0] == 1, 'Currently only supporting computing one molecule a time'\n # Solving the eigenvalue problem: Hq = w^2 * T q\n # where H is the Hessian matrix, q is the normal coordinates,\n # T = diag(m1, m1, m1, m2, m2, m2, ....) is the mass\n # We solve this eigenvalue problem through Lowdin diagnolization:\n # Hq = w^2 * Tq ==> Hq = w^2 * T^(1/2) T^(1/2) q\n # Letting q' = T^(1/2) q, we then have\n # T^(-1/2) H T^(-1/2) q' = w^2 * q'\n inv_sqrt_mass = (1 / masses.sqrt()).repeat_interleave(3, dim=1) # shape (molecule, 3 * atoms)\n mass_scaled_hessian = hessian * inv_sqrt_mass.unsqueeze(1) * inv_sqrt_mass.unsqueeze(2)\n if mass_scaled_hessian.shape[0] != 1:\n raise ValueError('The input should contain only one molecule')\n mass_scaled_hessian = mass_scaled_hessian.squeeze(0)\n eigenvalues, eigenvectors = torch.symeig(mass_scaled_hessian, eigenvectors=True)\n angular_frequencies = eigenvalues.sqrt()\n frequencies = angular_frequencies / (2 * math.pi)\n # converting from sqrt(hartree / (amu * angstrom^2)) to cm^-1\n wavenumbers = frequencies * 17092\n modes = (eigenvectors.t() * inv_sqrt_mass).reshape(frequencies.numel(), -1, 3)\n return wavenumbers, modes\n\n\n__all__ = ['pad', 'pad_atomic_properties', 'present_species', 'hessian',\n 'vibrational_analysis', 'strip_redundant_padding',\n 'ChemicalSymbolsToInts']\n", "meta": {"hexsha": "db8718b1d759a050e935374b60385e0c250ffd40", "size": 11821, "ext": "py", "lang": "Python", "max_stars_repo_path": "torchani/utils.py", "max_stars_repo_name": "chc273/torchani", "max_stars_repo_head_hexsha": "bbcd7bedc254796f0c2f839c4868ac211ad9078d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "torchani/utils.py", "max_issues_repo_name": "chc273/torchani", "max_issues_repo_head_hexsha": "bbcd7bedc254796f0c2f839c4868ac211ad9078d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "torchani/utils.py", "max_forks_repo_name": "chc273/torchani", "max_forks_repo_head_hexsha": "bbcd7bedc254796f0c2f839c4868ac211ad9078d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.6677852349, "max_line_length": 114, "alphanum_fraction": 0.6444463243, "include": true, "reason": "import numpy", "num_tokens": 2840, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230156, "lm_q2_score": 0.3702254064929193, "lm_q1q2_score": 0.19089559289439822}} {"text": "\"\"\"\nFile: pylinex/util/RectangularBinner.py\nAuthor: Keith Tauscher\nDate: 20 Sep 2018\n\nDescription: File containing a class and function which bins using a\n rectangular window function defined by bin edges.\n\"\"\"\nfrom __future__ import division\nimport numpy as np\nfrom distpy import Savable, Loadable, sequence_types, create_hdf5_dataset,\\\n get_hdf5_value\n\nclass RectangularBinner(Savable, Loadable):\n \"\"\"\n Class which bins using a rectangular window function defined by bin edges.\n \"\"\"\n def __init__(self, unbinned_x_values, bin_edges):\n \"\"\"\n Initializes a RectangularBinner with unbinned x values and edges of\n bins with which to define new points.\n \n unbinned_x_values: x_values associated with points to bin\n bin_edges: edges of bins with which to create new x values\n \"\"\"\n self.unbinned_x_values = unbinned_x_values\n self.bin_edges = bin_edges\n self.digitize()\n \n def digitize(self):\n \"\"\"\n Digitizes the bins so that binning can proceed quickly once data values\n are given.\n \"\"\"\n bin_indices = np.digitize(self.unbinned_x_values, self.bin_edges)\n (bins_to_keep, unique_indices, unique_counts) =\\\n np.unique(bin_indices, return_index=True, return_counts=True)\n if bins_to_keep[0] == 0:\n bins_to_keep = bins_to_keep[1:]\n unique_indices = unique_indices[1:]\n unique_counts = unique_counts[1:]\n if bins_to_keep[-1] == len(self.bin_edges):\n bins_to_keep = bins_to_keep[:-1]\n unique_indices = unique_indices[:-1]\n unique_counts = unique_counts[:-1]\n self._bins_to_keep = bins_to_keep - 1\n self._unique_indices = unique_indices\n self._unique_counts = unique_counts\n \n @property\n def unique_indices(self):\n \"\"\"\n Property storing indices in the space of unbinned_x_values which share\n bins.\n \"\"\"\n if not hasattr(self, '_unique_indices'):\n raise AttributeError(\"unique_indices was referenced before \" +\\\n \"bins were digitized.\")\n return self._unique_indices\n \n @property\n def unique_counts(self):\n \"\"\"\n \"\"\"\n if not hasattr(self, '_unique_counts'):\n raise AttributeError(\"unique_counts was referenced before bins \" +\\\n \"were digitized.\")\n return self._unique_counts\n \n @property\n def unbinned_x_values(self):\n \"\"\"\n Property storing the x values of the unbinned points.\n \"\"\"\n if not hasattr(self, '_unbinned_x_values'):\n raise AttributeError(\"unbinned_x_values was referenced before \" +\\\n \"it was set.\")\n return self._unbinned_x_values\n \n @unbinned_x_values.setter\n def unbinned_x_values(self, value):\n \"\"\"\n Setter for the independent variable of the underlying model.\n \"\"\"\n if type(value) in sequence_types:\n value = np.array(value)\n if value.ndim == 1:\n self._unbinned_x_values = value\n else:\n raise ValueError(\"unbinned_x_values was set to something \" +\\\n \"other than a 1D numpy.ndarray.\")\n else:\n raise TypeError(\"unbinned_x_values was set to something other \" +\\\n \"than a 1D numpy.ndarray.\")\n \n @property\n def bin_edges(self):\n \"\"\"\n Property storing the bin edges.\n \"\"\"\n if not hasattr(self, '_bin_edges'):\n raise AttributeError(\"bin_edges was referenced before it was set.\")\n return self._bin_edges\n \n @bin_edges.setter\n def bin_edges(self, value):\n \"\"\"\n Setter for the bin edges.\n \n value: 1D array of bin edges (must be of length num_channels+1)\n \"\"\"\n if type(value) in sequence_types:\n value = np.array(value)\n if value.ndim == 1:\n self._bin_edges = value\n else:\n raise ValueError(\"bin_edges was set to something other \" +\\\n \"than a 1D numpy.ndarray.\")\n else:\n raise TypeError(\"bin_edges was set to something other than a \" +\\\n \"1D numpy.ndarray.\")\n \n @property\n def nbins(self):\n \"\"\"\n Property storing the number of bins implied by the bin edges.\n \"\"\"\n if not hasattr(self, '_nbins'):\n self._nbins = len(self.bin_edges) - 1\n return self._nbins\n \n @property\n def bins_to_keep(self):\n \"\"\"\n Property storing the indices of bin with nonzero weight in order.\n \"\"\"\n if not hasattr(self, '_bins_to_keep'):\n raise AttributeError(\"bins_to_keep referenced before it was set.\")\n return self._bins_to_keep\n \n @property\n def nbins_to_keep(self):\n \"\"\"\n Property storing the number of bins in the results of this binner.\n \"\"\"\n if not hasattr(self, '_nbins_to_keep'):\n self._nbins_to_keep = len(self.bins_to_keep)\n return self._nbins_to_keep\n \n @property\n def binned_x_values(self):\n \"\"\"\n Property storing the binned x values.\n \"\"\"\n if not hasattr(self, '_binned_x_values'):\n self._binned_x_values = (self.bin_edges[self.bins_to_keep] +\\\n self.bin_edges[self.bins_to_keep+1]) / 2\n return self._binned_x_values\n \n @property\n def x_samples(self):\n \"\"\"\n Property storing the x values in each bin. It is a list of arrays.\n \"\"\"\n if not hasattr(self, '_x_samples'):\n self._x_samples = [np.array([])] * self.nbins\n for (final_bin_index, original_bin_index) in\\\n enumerate(self.bins_to_keep):\n index = self.unique_indices[final_bin_index]\n count = self.unique_counts[final_bin_index]\n self._x_samples[original_bin_index] =\\\n self.unbinned_x_values[index:index+count]\n return self._x_samples\n \n def bin(self, old_y_values, weights=None, return_weights=False):\n \"\"\"\n Bins the given data.\n \n old_y_values: data to bin\n weights: weights to associate with each unbinned y value (should be of\n same shape as old_y_values)\n return_weights: if True, weights are returned alongside binned data\n \n returns: if return_weights is False, new_y_values\n if return_weights is True, (new_y_values, new_weights)\n \"\"\"\n shape = old_y_values.shape[:-1] + (len(self.bins_to_keep),)\n new_y_values = np.zeros(shape)\n if type(weights) is type(None):\n weights = np.ones_like(old_y_values)\n if return_weights:\n new_weights = np.zeros(shape)\n for final_bin_index in range(len(self.bins_to_keep)):\n unique_index = self.unique_indices[final_bin_index]\n unique_count = self.unique_counts[final_bin_index]\n where = slice(unique_index, unique_index + unique_count)\n old_y_slice = old_y_values[...,where]\n weight_slice = weights[...,where]\n new_weight = np.sum(weight_slice, axis=-1)\n new_y_values[...,final_bin_index] =\\\n np.sum(old_y_slice * weight_slice, axis=-1) / new_weight\n if return_weights:\n new_weights[...,final_bin_index] = new_weight\n if return_weights:\n return (new_y_values, new_weights)\n else:\n return new_y_values\n \n def bin_error(self, old_error, weights=None, return_weights=False):\n \"\"\"\n Bins the given error vector(s).\n \n old_error: error to bin containing positive numbers with the last axis\n being the binning axis.\n weights: weights to associate with each unbinned y value (should be of\n same shape as old_y_values)\n return_weights: if True, weights are returned alongside binned data\n \n returns: if return_weights is False, new_y_values\n if return_weights is True, (new_y_values, new_weights)\n \"\"\"\n shape = old_error.shape[:-1] + (self.nbins_to_keep,)\n new_error = np.zeros(shape)\n if type(weights) is type(None):\n weights = np.ones_like(old_error)\n if return_weights:\n new_weights = np.zeros(shape)\n for final_bin_index in range(self.nbins_to_keep):\n unique_index = self.unique_indices[final_bin_index]\n unique_count = self.unique_counts[final_bin_index]\n where = slice(unique_index, unique_index + unique_count)\n old_error_slice = old_error[...,where]\n weight_slice = weights[...,where]\n new_weight = np.sum(weight_slice, axis=-1)\n new_error[...,final_bin_index] = np.sqrt(np.sum(np.power(\\\n weight_slice * old_error_slice, 2), axis=-1)) / new_weight\n if return_weights:\n new_weights[...,final_bin_index] = new_weight\n if return_weights:\n return (new_error, new_weights)\n else:\n return new_error\n \n def __call__(self, old_y_values, weights=None, return_weights=False):\n \"\"\"\n Bins the given data.\n \n old_y_values: data to bin\n weights: weights to associate with each unbinned y value (should be of\n same shape as old_y_values)\n return_weights: if True, weights are returned alongside binned data\n \n returns: if return_weights is False, new_y_values\n if return_weights is True, (new_y_values, new_weights)\n \"\"\"\n return self.bin(old_y_values, weights=weights,\\\n return_weights=return_weights)\n \n def fill_hdf5_group(self, group):\n \"\"\"\n Fills the given hdf5 file group with data about this RectangularBinner.\n \"\"\"\n create_hdf5_dataset(group, 'unbinned_x_values',\\\n data=self.unbinned_x_values)\n create_hdf5_dataset(group, 'bin_edges', data=self.bin_edges)\n \n @staticmethod\n def load_from_hdf5_group(group):\n \"\"\"\n Loads a RectangularBinner from the given hdf5 file group.\n \n group: group where RectangularBinner was once saved\n \n returns: RectangularBinner whose info was saved in the given group\n \"\"\"\n unbinned_x_values = get_hdf5_value(group['unbinned_x_values'])\n bin_edges = get_hdf5_value(group['bin_edges'])\n return RectangularBinner(unbinned_x_values, bin_edges)\n \n def __eq__(self, other):\n \"\"\"\n Checks if other is the same binner as this.\n \n other: object to check for equality\n \n returns: True only if other is a RectangularBinner with the same\n unbinned x values and bin edges. False otherwise\n \"\"\"\n if not isinstance(other, RectangularBinner):\n return False\n if (self.unbinned_x_values.shape != other.unbinned_x_values.shape) or\\\n np.any(self.unbinned_x_values != other.unbinned_x_values):\n return False\n if (self.bin_edges.shape != other.bin_edges.shape) or\\\n np.any(self.bin_edges != other.bin_edges):\n return False\n return True\n \n def __ne__(self, other):\n \"\"\"\n Checks if other is not the same binner as this.\n \n other: object to check for inequality\n \n returns: False only if other is a RectangularBinner with the same\n unbinned x values and bin edges. True otherwise\n \"\"\"\n return (not self.__eq__(other))\n\ndef rect_bin(bin_edges, unbinned_x_values, old_y_values, weights=None,\\\n return_weights=False):\n \"\"\"\n Bins on final axis.\n \n bin_edges: 1D numpy.ndarray of length Nafter+1 containing bin edges\n unbinned_x_values: 1D numpy.ndarray of length Nbefore containing x values\n of points\n old_y_values: ND numpy.ndarray whose final axis length is Nbefore\n return_weights: if True, extra array of new weights is returned\n (Default False)\n \n returns: (binned_x_values, new_y_values[, new_weights])\n binned_x_values: 1D numpy.ndarray of length Nafter\n new_y_values: ND numpy.ndarray of the same shape as old_y_values\n with Nafter instead of Nbefore as the final axis\n length\n [new_weights]: new weights to associate with the binned data\n points, given by the sum of the weights that went\n into each bin (returned only if return_weights is\n True)\n \"\"\"\n binner = RectangularBinner(unbinned_x_values, bin_edges)\n bin_results =\\\n binner(old_y_values, weights=weights, return_weights=return_weights)\n if return_weights:\n return (binner.binned_x_values,) + bin_results\n else:\n return (binner.binned_x_values, binner.new_y_values)\n\n", "meta": {"hexsha": "dcd9b7e275e9e35c10bf6368b4c7b535af64b9f0", "size": 13120, "ext": "py", "lang": "Python", "max_stars_repo_path": "pylinex/util/RectangularBinner.py", "max_stars_repo_name": "CU-NESS/pylinex", "max_stars_repo_head_hexsha": "b6f342595b6a154e129eb303782e5268088f34d5", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pylinex/util/RectangularBinner.py", "max_issues_repo_name": "CU-NESS/pylinex", "max_issues_repo_head_hexsha": "b6f342595b6a154e129eb303782e5268088f34d5", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pylinex/util/RectangularBinner.py", "max_forks_repo_name": "CU-NESS/pylinex", "max_forks_repo_head_hexsha": "b6f342595b6a154e129eb303782e5268088f34d5", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.5882352941, "max_line_length": 79, "alphanum_fraction": 0.6089176829, "include": true, "reason": "import numpy", "num_tokens": 2813, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230157, "lm_q2_score": 0.3702253925955866, "lm_q1q2_score": 0.19089558572865678}} {"text": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated by Kleber Noel for disseration: \n inversion mapping using a Local Linear embedding\nJune 2019\n\"\"\"\nimport numpy as np \nfrom numpy import mean\n\n#import pandas as pd \nimport os, pdb, argparse, re\nfrom random import shuffle\nfrom tqdm import tqdm\nfrom collections import defaultdict, OrderedDict\nfrom time import time\nimport torch, torch.nn as nn\nimport torch.optim as optim\nfrom torch import FloatTensor\nfrom torch.autograd import Variable\nfrom torch.nn.utils.rnn import pad_sequence, pack_padded_sequence, pad_packed_sequence\n\nget_seq_lens = lambda l : [x[-1] for x in l]\nget_names = lambda l : [x[0] for x in l]\ndim1_list = lambda l : [x.shape[1] for x in l]\nreport = 'count:{}, batch_size:{}, loss:{:.4}; mm:{:.4}, frames:{}, cor:{:.4}'\n\n# GET CUDA STATUS:\n\ndef get_args():\n \"\"\"\n Args define program usage.\n \"\"\"\n info = 'Script preprocesses data and saves, given i/o directories.'\n parser = argparse.ArgumentParser(info)\n parser.add_argument('--train', action='store_true', default=False)\n parser.add_argument('--test', action='store_true', default=False)\n \n parser.add_argument('--lsf-dir', help='path to lsf directory')\n parser.add_argument('--mfcc-dir', help='path to mfcc directory')\n parser.add_argument('--ema-dir', help='path to ema directory')\n parser.add_argument('--bilstm-layers', type=int, default=2, help='number of bi-directional LSTM layers')\n\n parser.add_argument('--shuffle', default=False, action='store_true', help='shuffle batches')\n parser.add_argument('--batch-size', type=int, default=6, help='shuffle batches')\n \n parser.add_argument('--cuda', action='store_true', default=False, help='GPU support')\n\n parser.add_argument('--load-dir', help='directory to load a saved model from')\n parser.add_argument('--save-dir', help='directory to save a final model in')\n \n parser.add_argument('--checkpoint-dir', default = '', help='checkpoint directory to load/save model from/in')\n parser.add_argument('--patience', type=int, default=10, help='save model after n epochs without improvement')\n parser.add_argument('--save-internal', default=5, help='epoch arg to save the model parameters every *n* times')\n\n parser.add_argument('--graph-data', action='store_true', help='graph data')\n \n return parser.parse_args()\n\nclass LoadInputOutput():\n def __init__(self, args, d):\n if args.lsf_dir: self.lsf_dict = self.load_data(args.lsf_dir)\n if args.mfcc_dir: self.mfcc_dict= self.load_data(args.mfcc_dir)\n self.ema_dict = self.load_data(args.ema_dir)\n self.device = d\n self.shuffle = args.shuffle\n self.input_dim, self.output_dim = self.get_io_dims()\n print('input dimensionality of lsfs:\\t\\t{} '.format(self.input_dim))\n print('output dimensionality of emas:\\t\\t{}'.format(self.output_dim))\n \n def get_io_dims(self):\n n_input_dims = set(dim1_list(self.lsf_dict['channel_lsfd'].values()))\n n_output_dims = set(dim1_list(self.ema_dict['channel_ema'].values()))\n assert {len(n_output_dims),len(n_input_dims)}.pop()==1 # sanity check\n return n_input_dims.pop(), n_output_dims.pop()\n\n def load_means(self):\n return np.array([float(i[0])*10**int(i[1]) for i in self.norm])\n \n def load_4xSTDs(self):\n return np.array([4*(float(i[0])*10**int(i[1])) for i in self.norm])\n \n def load_data(self, directory):\n ema_norm_str, data_dict = '(\\d+\\.\\d+)e([\\-\\+]\\d+)', defaultdict(dict)\n for d1 in os.listdir(\"./{}\".format(directory)):\n print('loading data to dict from {} : {}'.format(directory, d1))\n if not \"channel\" in d1: continue\n for d2 in os.listdir(\"./{}/{}\".format(directory,d1)):\n key = d2.split('.')[0]\n if re.match('ema_.*.txt',d2): \n with open(os.path.join(directory, d1, d2), 'r') as f:\n self.norm = re.findall(ema_norm_str,f.readlines()[0])\n if 'means' in d2: data_dict.update({key:FloatTensor(self.load_means())})\n elif 'stds' in d2:data_dict.update({key:FloatTensor(self.load_4xSTDs())})\n continue\n np_array = np.load(os.path.join(directory, d1, d2), \n allow_pickle = True)\n if d1=='channel_name': data_dict.update({key:np_array})\n else: data_dict[d1].update({key:FloatTensor(np_array)})\n return data_dict\n \n def get_batches(self):\n total_samples = len(self.lsf_dict['channel_lsfd'].values())\n # currently just choose a validation index: 10%, training 90%\n self.val_idx = int(total_samples * (1 - 0.1))\n self.sample_names = sorted([k for k in self.lsf_dict['channel_lsfd'].keys()])\n report = 'minimum batch target size = {}\\nsegmenting data into batches...'\n print(report.format(args.batch_size))\n # define batch TRAINING (t) and VALIDATION (v) for...\n # SOURCE set (s) & TARGET set (t)\n self.bts, self.bvs = self.make_batches(self.lsf_dict['channel_lsfd'])\n self.btt, self.bvt = self.make_batches(self.ema_dict['channel_ema'])\n # Normalize outputs to millimeters (for calculating RMSE in mm)\n ### DO FOR WHOLE BATCH\n batch_list_tt = [i for i in self.btt[0]]\n batch_list_vt = [i for i in self.bvt[0]]\n self.bttm = self.unnormalize_output(batch_list_tt, True)\n self.bvtm = self.unnormalize_output(batch_list_vt, True)\n \n def reorder(self, t, i, tup=False):\n if tup: return ([t[0][n] for n in i],[t[1][n] for n in i])\n if not tup: return [t[n] for n in i]\n \n def shuffle_batches(self):\n \"\"\"\n Shuffles batches based on numpy:\n get len of training/validation batches -> 0,1, ... len(batch).\n \"\"\"\n t, v = np.arange(len(self.bts[0])), np.arange(len(self.bvs[0]))\n np.random.shuffle(t), np.random.shuffle(v) # new order for t & v.\n t, v = t.tolist(), v.tolist()\n self.bts = self.reorder(self.bts, t, tup=True)\n self.bvs = self.reorder(self.bvs, v, tup=True)\n self.btt = self.reorder(self.btt, t, tup=True)\n self.bvt = self.reorder(self.bvt, v, tup=True)\n self.bttm = self.reorder(self.bttm, t, tup=False)\n self.bvtm = self.reorder(self.bvtm, v, tup=False)\n \n def make_batches(self, in_dict, split=True):\n \"\"\"\n Makes and pads a batch using data dictionary\n \"\"\"\n if split: #split into train, validation sets\n t, v = self.return_train_valid(in_dict) #INSERT NEW make_batch var to give random sequence for train/val\n return self.make_batches(t, False), self.make_batches(v, False)\n batches, batch, = [], []\n frames_to_names, mxfr2nmfr = defaultdict(set), defaultdict(int)\n for k,s in [(k,v.shape[0]) for k,v in in_dict.items()]: frames_to_names[s].add(k)\n # Run through k:frames --> v:names dict in order (lowest to highest)\n for frames, names in sorted(frames_to_names.items(), key=lambda x:x[0]):\n batch.extend([(n,frames) for n in names])\n ### Aim to get up to or above batch size... issue: dif batch sizes.\n if len(batch) >= args.batch_size and batch!=0: ## why batch=0? FIX!\n mxfr2nmfr.update({frames:sorted(batch,reverse=True, key=lambda x:x[1])})\n batch = []\n if len(batch) > 0: # remainder that didn't fit into target batch sizes\n mxfr2nmfr.update({frames:sorted(batch,reverse=True, key=lambda x:x[1])})\n n2f=[]\n for batch in mxfr2nmfr.values():\n if batch==0: continue\n t = [FloatTensor(in_dict[k]).to(self.device) for k, f in batch]\n batches.append(pad_sequence(t, batch_first=True))\n n2f.append([(k,in_dict[k].shape[0]) for k, f in batch])\n return batches, n2f\n \n def return_train_valid(self, in_dict):\n t, v, = defaultdict(str), defaultdict(str)\n t = {k:in_dict[k] for k in self.sample_names[:self.val_idx]}\n v = {k:in_dict[k] for k in self.sample_names[self.val_idx:]} \n return t,v\n \n def unnormalize_output(self, batches, batches_set=True):\n unnormalized_data = []\n stds_tensor = FloatTensor(self.ema_dict['ema_stds']).to(self.device)\n if batches_set==True: # A WHOLE BATCH\n for b in batches:\n norm = stds_tensor.repeat(b.shape[0],b.shape[1],1)\n unnormalized_data.append(torch.mul(norm, b))\n return unnormalized_data\n else:\n b = batches\n norm = stds_tensor.repeat(b.shape[0],b.shape[1],1)\n return torch.mul(norm, b)\n\n def zip_validation_batches(self):\n \"\"\"\n Val args in zip: 1. src; 2. tgt; 3. tgt (mm), 4. names & sizes\n \"\"\"\n return zip(self.bvs[0], self.bvt[0], self.bvtm, self.bvt[1])\n\n def zip_training_batches(self):\n \"\"\"\n Train args in zip: 1. src; 2. tgt; 3. tgt (mm), 4. names & sizes\n \"\"\"\n return zip(self.bts[0], self.btt[0], self.bttm, self.btt[1])\n\n def get_prog_bar(self, zipped_batches, batches_type, epoch):\n t = len(self.bts[0]) if batches_type=='training' else len(self.bvs[0])\n bar = tqdm(iterable = zipped_batches, \n total = t,\n desc = '| {} Epoch {:03d}'.format(batches_type, epoch),\n leave = False,\n disable = False)\n return bar\n\nclass BuildModel(nn.Module):\n def __init__(self, args, d, input_dim, output_dim):\n super(BuildModel, self).__init__()\n self.args = args\n self.device = d\n self.input_dim = input_dim\n self.output_dim = output_dim\n self.hidden_dim = 256\n self.fc_hidden_dim = 512\n self.bilstm_layers = args.bilstm_layers\n self.batch_size = args.batch_size # default: 6\n # L1 lstm cell: should use sigmoid as R activation and tanh as final\n self.bidirlstm = nn.LSTM(input_size = self.input_dim, \n hidden_size = self.hidden_dim,\n bidirectional = True,\n num_layers = self.bilstm_layers)\n \n self.fc = nn.Linear(in_features = self.fc_hidden_dim,\n out_features = self.output_dim)\n self.hc = None\n self.criterion, self.criterion_mm = nn.MSELoss(), nn.MSELoss()\n self.optimizer = optim.Adam(self.parameters(), lr=0.001)\n self.is_new = False # assume model loaded from chkpnt til proven otherwise\n\n def forward(self, padded_seq_batch):\n \"\"\"\n padded_seq_batch: padded sequence\n hc: hidden and cell states\n tuple of hidden and cell state\n \"\"\"\n self.get_len(padded_seq_batch.shape[0])\n self.out_seq = torch.empty((self.sequence_len,\n self.batch_size,\n self.output_dim))\n packed_seq_batch = pack_padded_sequence(padded_seq_batch, \n lengths=self.seq_lens, \n batch_first=True)\n \n ## Reinitialize hidden state, WRT to the dimensions of the LSTM\n ## as LSTM input dim1 changes due to packed sequence dim1 changes in \n ## batch. Some batches are dif sizes, hidden state size changes \n ## Before, I was only passing the packed_seq_batch to bidirlstm.\n\n self.hc = self.init_hidden(2*self.bilstm_layers, \n max(packed_seq_batch[1].tolist()), \n self.hc)\n packed_outputs, self.hc = self.bidirlstm(packed_seq_batch, self.hc)\n lstm_out, _ = pad_packed_sequence(packed_outputs, batch_first=True)\n self.out_seq = self.fc(lstm_out)\n \n def init_hidden(self, a, b, x = None):\n return (Variable(torch.randn(a, b, self.hidden_dim,device=self.device)),\n Variable(torch.randn(a, b, self.hidden_dim,device=self.device)))\n\n def init_history(self):\n if self.args.checkpoint_dir:\n print('checkpoint \"{}\" not found'.format(args.checkpoint_dir))\n print('initialising history and creating new model...')\n self.history, self.is_new = defaultdict(dict), True \n self.history['training'], self.history['validation'] = OrderedDict(), OrderedDict()\n\n def get_len(self, length):\n self.sequence_len = length\n \n def get_cor(self, output, target):\n \"\"\"\n function for correlations between target and output in a batch\n normalized over the number of frames samples\n \"\"\"\n self.av_cor = float(0)\n for frames, o, t in zip(self.seq_lens, output, target):\n vo = o - torch.mean(o[:frames,:])\n vt = t - torch.mean(o[:frames,:])\n numerator = torch.sum(vo * vt)\n denominator = (torch.sqrt(torch.sum(vo ** 2)) * torch.sqrt(torch.sum(vt ** 2)))\n cor = numerator/denominator\n self.av_cor += cor.item()*frames/sum(self.seq_lens)\n \n def get_lens_names_frames(self, names_to_frames):\n \"\"\"\n computed batch-wise\n \"\"\"\n self.seq_lens = get_seq_lens(names_to_frames)\n self.names = get_names(names_to_frames)\n self.frames = sum(self.seq_lens)\n\n def get_losses(self, out_seqm, pad_tgt_seq, pad_tgt_seqm):\n self.loss = self.criterion(self.out_seq, pad_tgt_seq)\n self.loss_mm = self.criterion_mm(out_seqm, pad_tgt_seqm).item()*1000\n\n def propagate_loss(self):\n self.loss.backward()\n self.optimizer.step()\n \n def update_info(self, epoch, phase):\n \"\"\"\n phase is either training or testing.\n info during epoch is updated as a set of loss values (mm and norm), \n frame number, correlation, sample number for each minibatch\n at end, average loss is computed.\n \"\"\"\n self.epoch = epoch\n sample_number = len(self.names)\n s = tuple([sample_number, self.frames, self.loss.item(), self.loss_mm, self.av_cor])\n if self.history[phase].get(epoch): self.history[phase][epoch].append(s)\n else: self.history[phase].update({epoch:[s]})\n\n def set_prog_bar_desc(self, prog_bar, c):\n batch_size = len(self.names)\n prog_bar.set_description(report.format(c, batch_size, self.loss.item(), \n self.loss_mm, self.frames, \n self.av_cor))\n \n def get_epoch(self):\n \"\"\"\n since checkpoints/models are only saved after validation,\n we only look into epoch of validation set here.\n If process was cancelled in 1st train, start new history\n \"\"\"\n if dict(self.history.get('validation'))=={}: \n self.init_history()\n self.__init__(self.args, self.input_dim, self.output_dim)\n return 0\n else:\n last_epoch = max(dict(self.history.get('validation')).keys())\n return last_epoch\n \n def compute_batch_averages(self, phase):\n \"\"\"\n average loss (norm & mm), and cor calculated over batch for phase\n normalize over entire batch instead of retaining single batch samples\n \"\"\"\n b_lm, b_l, b_c = float(0), float(0), float(0)\n total_in_batch = sum([i[0] for i in dict(self.history[phase])[self.epoch]])\n for n, f, l, lm, c in dict(self.history[phase])[self.epoch]:\n b_c += c * n / total_in_batch\n b_l += l * n / total_in_batch \n b_lm += lm * n / total_in_batch \n del self.history[phase][self.epoch]\n self.history[phase].update({self.epoch:{b_l, b_c, b_lm}})\n print('\\nOverall {0}: lossmm = {1:.3f} cor = {2:.3f}'.format(phase, b_lm, b_c))\n if phase=='validation': return b_l\n\ndef save_model(model, model_path):\n torch.save(model.state_dict(), model_path)\n\ndef load_model(model, model_path, device):\n model.load_state_dict(torch.load(model_path, device.type))\n\ndef save_checkpoint(model, history, filepath):\n state = {'epoch': model.epoch,\n 'state_dict': model.state_dict(),\n 'optimizer': model.optimizer.state_dict(),\n 'history': model.history}\n torch.save(state, filepath)\n\ndef load_checkpoint(model, args, device):\n checkpoint = torch.load(args.checkpoint_dir, map_location = device.type)\n model.epoch = checkpoint['epoch']\n model.load_state_dict(checkpoint['state_dict'])\n model.to(device)\n model.optimizer.load_state_dict(checkpoint['optimizer'])\n model.history = checkpoint['history']\n\ndef get_knn(batch_out_seq, seq_lens, kneighbors):\n from sklearn.manifold import locally_linear_embedding as lle\n from sklearn.neighbors import NearestNeighbors\n import numpy.matlib as matlib\n from numpy.linalg import inv\n \n # By default the knn function below will return the same vector.\n # e.g. k = 4 vector: 0, neighbors [0, 1, 2, 3]. We want [1, 2, 3, 4]\n # therefore add one to get distinct from the reference.\n knn = NearestNeighbors(n_neighbors = kneighbors + 1)\n pdb.set_trace()\n for sample, l in zip(batch_out_seq, seq_lens):\n W = np.zeros((kneighbors,sample.shape[0]))\n knn.fit(sample[:l,:])\n k_nn, k_ni = knn.kneighbors(sample[:l,:], return_distance=True)\n k_nn, k_ni = k_nn[:,1:], k_ni[:,1:]\n for i in range(l):\n Z = sample[:l,][k_ni[i]] - matlib.repmat(sample[:l,][i], kneighbors, 1)\n C = Z @ Z.T\n W[:,i] = inv(C)*np.ones((kneighbors, 1))\n W[:,i] = W[:,i]/W[:,i].sum(axis=1,keepdims=1)\n \n\ndef get_device(cuda):\n if torch.cuda.is_available() and cuda: return torch.device('cuda')\n else: return torch.device('cpu')\n\ndef validate(model, data, epoch, count):\n val_prog_bar = data.get_prog_bar(data.zip_validation_batches(), \n 'validation', epoch)\n torch.no_grad(), model.eval()\n for pad_src_seq, pad_tgt_seq, pad_tgt_seqm, n2f in val_prog_bar:\n count += 1\n\n #if count > 4: break # CODE TO STOP AND TEST \n #k_nearest_neighbors = get_knn(model.out_seq.detach().numpy(), model.seq_lens)\n model.get_lens_names_frames(n2f)\n model.forward(Variable(pad_src_seq)) # pass thru model\n model.get_cor(model.out_seq, pad_tgt_seq) # get correlation\n out_seq_mm = data.unnormalize_output(model.out_seq, False) #MSE(mm)\n model.get_losses(out_seq_mm, pad_tgt_seq, pad_tgt_seqm)\n \n model.update_info(epoch, 'validation')\n model.set_prog_bar_desc(val_prog_bar, count)\n\ndef train(model, data, epoch, count):\n train_prog_bar = data.get_prog_bar(data.zip_training_batches(), \n 'training', epoch)\n model.train()\n for pad_src_seq, pad_tgt_seq, pad_tgt_seqm, n2f in train_prog_bar:\n count += 1\n #if count > 2: break # CODE TO STOP AND TEST\n model.get_lens_names_frames(n2f)\n model.forward(Variable(pad_src_seq)) # pass thru model\n model.get_cor(model.out_seq, pad_tgt_seq) # get correlation\n out_seq_mm = data.unnormalize_output(model.out_seq, False) #MSE(mm)\n model.get_losses(out_seq_mm, pad_tgt_seq, pad_tgt_seqm)\n model.propagate_loss()\n model.optimizer.zero_grad()\n model.update_info(epoch, 'training')\n model.set_prog_bar_desc(train_prog_bar, count)\n\ndef train_val_loop(model, data):\n bad_epochs = 0\n best_valid_loss = float('inf')\n print('Model Overview:\\n\\n{}'.format(model))\n while bad_epochs < args.patience:\n count = 0\n epoch += 1\n if args.shuffle: data.shuffle_batches()\n train(model, data, epoch, count)\n validate(model, data, epoch, count)\n model.compute_batch_averages('training')\n bv_l = model.compute_batch_averages('validation')\n if bv_l < best_valid_loss: # Decide whether to terminate training while loop\n best_valid_loss, bad_epochs = bv_l, 0\n if epoch % args.save_internal ==0: save_checkpoint(model, model.history, args.checkpoint_dir)\n else: bad_epochs += 1\n print('No validation set improvements observed for {:d} epochs. Early stop!'.format(args.patience))\n print('Saving Model...')\n try: save_model(model, args.save_model)\n except: save_checkpoint(model, model.history, args.checkpoint_dir)\n\n\ndef test(model, data, count, epoch):\n val_prog_bar = data.get_prog_bar(data.zip_validation_batches(), \n 'validation', epoch)\n torch.no_grad(), model.eval()\n for pad_src_seq, pad_tgt_seq, pad_tgt_seqm, n2f in val_prog_bar:\n count += 1\n model.get_lens_names_frames(n2f)\n model.forward(Variable(pad_src_seq)) # pass thru model\n model.get_cor(model.out_seq, pad_tgt_seq) # get correlation\n out_seq_mm = data.unnormalize_output(model.out_seq, False) #MSE(mm)\n model.get_losses(out_seq_mm, pad_tgt_seq, pad_tgt_seqm)\n if count > 0: # break # CODE TO STOP AND TEST \n k_nearest_neighbors = get_knn(model.out_seq.detach().numpy(), \n model.seq_lens,\n kneighbors = 5)\n pdb.set_trace()\n model.out_seq.detach()\n k_nearest_neighbors\n \n \n model.set_prog_bar_desc(val_prog_bar, count)\n\ndef run():\n \"\"\"\n Run Training and Validation over a number of epochs\n \"\"\"\n d = get_device(args.cuda)\n data = LoadInputOutput(args, d)\n model = BuildModel(args, d, data.input_dim, data.output_dim)\n data.get_batches()\n if args.cuda: model = model.cuda()\n if args.load_dir: load_model(model, args.load_dir, d)\n elif os.path.isfile(args.checkpoint_dir): load_checkpoint(model, args, d) \n else: model.init_history()\n \n epoch = 0 if model.is_new else model.get_epoch()\n if args.train: train_val_loop(model, data, epoch)\n if args.test: test(model, data, 0, epoch)\n\ndef main(args):\n run()\n\nif __name__ == '__main__':\n args = get_args()\n main(args)\n", "meta": {"hexsha": "d69484993f919620baa892afb8a02616be3d833b", "size": 22380, "ext": "py", "lang": "Python", "max_stars_repo_path": "model1e.py", "max_stars_repo_name": "klebster2/inversion_mapping_dissertation", "max_stars_repo_head_hexsha": "568a043086207d1170410068213179b437b26e80", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "model1e.py", "max_issues_repo_name": "klebster2/inversion_mapping_dissertation", "max_issues_repo_head_hexsha": "568a043086207d1170410068213179b437b26e80", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "model1e.py", "max_forks_repo_name": "klebster2/inversion_mapping_dissertation", "max_forks_repo_head_hexsha": "568a043086207d1170410068213179b437b26e80", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.8496993988, "max_line_length": 116, "alphanum_fraction": 0.6127792672, "include": true, "reason": "import numpy,from numpy", "num_tokens": 5386, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230157, "lm_q2_score": 0.37022539259558657, "lm_q1q2_score": 0.19089558572865675}} {"text": "from __future__ import print_function\nimport abc\n\nimport numpy as np\nimport logging\nimport torch\nimport torch.utils.data\nfrom torch import nn\nfrom torch.autograd import Variable\nfrom torch.nn import functional as F\n\nfrom .nearest_embed import NearestEmbed\n\n\nclass AbstractAutoEncoder(nn.Module):\n __metaclass__ = abc.ABCMeta\n\n @abc.abstractmethod\n def encode(self, x):\n return\n\n @abc.abstractmethod\n def decode(self, z):\n return\n\n @abc.abstractmethod\n def forward(self, x):\n \"\"\"model return (reconstructed_x, *)\"\"\"\n return\n\n @abc.abstractmethod\n def sample(self, size):\n \"\"\"sample new images from model\"\"\"\n return\n\n @abc.abstractmethod\n def loss_function(self, **kwargs):\n \"\"\"accepts (original images, *) where * is the same as returned from forward()\"\"\"\n return\n\n @abc.abstractmethod\n def latest_losses(self):\n \"\"\"returns the latest losses in a dictionary. Useful for logging.\"\"\"\n return\n\n\nclass VAE(nn.Module):\n \"\"\"Variational AutoEncoder for MNIST\n Taken from pytorch/examples: https://github.com/pytorch/examples/tree/master/vae\"\"\"\n def __init__(self, kl_coef=1, **kwargs):\n super(VAE, self).__init__()\n\n self.fc1 = nn.Linear(784, 400)\n self.fc21 = nn.Linear(400, 20)\n self.fc22 = nn.Linear(400, 20)\n self.fc3 = nn.Linear(20, 400)\n self.fc4 = nn.Linear(400, 784)\n\n self.relu = nn.ReLU()\n self.sigmoid = nn.Sigmoid()\n self.kl_coef = kl_coef\n self.bce = 0\n self.kl = 0\n\n def encode(self, x):\n h1 = self.relu(self.fc1(x))\n return self.fc21(h1), self.fc22(h1)\n\n def reparameterize(self, mu, logvar):\n if self.training:\n std = logvar.mul(0.5).exp_()\n eps = Variable(std.new(std.size()).normal_())\n return eps.mul(std).add_(mu)\n else:\n return mu\n\n def decode(self, z):\n h3 = self.relu(self.fc3(z))\n return self.tanh(self.fc4(h3))\n\n def forward(self, x):\n mu, logvar = self.encode(x.view(-1, 784))\n z = self.reparameterize(mu, logvar)\n return self.decode(z), mu, logvar\n\n def sample(self, size):\n sample = Variable(torch.randn(size, 20))\n if self.cuda():\n sample = sample.cuda()\n sample = self.decode(sample).cpu()\n return sample\n\n def loss_function(self, x, recon_x, mu, logvar):\n self.bce = F.binary_cross_entropy(recon_x, x.view(-1, 784), size_average=False)\n batch_size = x.size(0)\n\n # see Appendix B from VAE paper:\n # Kingma and Welling. Auto-Encoding Variational Bayes. ICLR, 2014\n # https://arxiv.org/abs/1312.6114\n # 0.5 * sum(1 + log(sigma^2) - mu^2 - sigma^2)\n self.kl = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())\n\n return self.bce + self.kl_coef*self.kl\n\n def latest_losses(self):\n return {'bce': self.bce, 'kl': self.kl}\n\n\nclass VQ_VAE(nn.Module):\n \"\"\"Vector Quantized AutoEncoder for mnist\"\"\"\n def __init__(self, hidden=200, k=10, vq_coef=0.2, comit_coef=0.4, **kwargs):\n super(VQ_VAE, self).__init__()\n\n self.emb_size = k\n self.fc1 = nn.Linear(784, 400)\n self.fc2 = nn.Linear(400, hidden)\n self.fc3 = nn.Linear(hidden, 400)\n self.fc4 = nn.Linear(400, 784)\n\n self.emb = NearestEmbed(k, self.emb_size)\n\n self.relu = nn.ReLU()\n self.sigmoid = nn.Sigmoid()\n self.vq_coef = vq_coef\n self.comit_coef = comit_coef\n self.hidden = hidden\n self.ce_loss = 0\n self.vq_loss = 0\n self.commit_loss = 0\n\n def encode(self, x):\n h1 = self.relu(self.fc1(x))\n h2 = self.fc2(h1)\n return h2.view(-1, self.emb_size, int(self.hidden / self.emb_size))\n\n def decode(self, z):\n h3 = self.relu(self.fc3(z))\n return self.tanh(self.fc4(h3))\n\n def forward(self, x):\n z_e = self.encode(x.view(-1, 784))\n z_q, _ = self.emb(z_e, weight_sg=True).view(-1, self.hidden)\n emb, _ = self.emb(z_e.detach()).view(-1, self.hidden)\n return self.decode(z_q), z_e, emb\n\n def sample(self, size):\n sample = Variable(torch.randn(size, self.emb_size, int(self.hidden / self.emb_size)))\n if self.cuda():\n sample = sample.cuda()\n emb, _ = self.emb(sample)\n sample = self.decode(emb(sample).view(-1, self.hidden)).cpu()\n return sample\n\n def loss_function(self, x, recon_x, z_e, emb):\n self.ce_loss = F.binary_cross_entropy(recon_x, x.view(-1, 784))\n self.vq_loss = F.mse_loss(emb, z_e.detach())\n self.commit_loss = F.mse_loss(z_e, emb.detach())\n\n return self.ce_loss + self.vq_coef*self.vq_loss + self.comit_coef*self.commit_loss\n\n def latest_losses(self):\n return {'cross_entropy': self.ce_loss, 'vq': self.vq_loss, 'commitment': self.commit_loss}\n\n\nclass ResBlock(nn.Module):\n def __init__(self, in_channels, channels, bn=False):\n super(ResBlock, self).__init__()\n\n layers = [\n nn.ReLU(),\n nn.Conv2d(in_channels, channels, kernel_size=3, stride=1, padding=1),\n nn.ReLU(),\n nn.Conv2d(in_channels, channels, kernel_size=1, stride=1, padding=0)]\n if bn:\n layers.insert(2, nn.BatchNorm2d(channels))\n self.convs = nn.Sequential(*layers)\n\n def forward(self, x):\n return x + self.convs(x)\n\n\nclass CVAE(AbstractAutoEncoder):\n def __init__(self, d, kl_coef=0.1, **kwargs):\n super(CVAE, self).__init__()\n\n self.encoder = nn.Sequential(\n nn.Conv2d(3, d // 2, kernel_size=4, stride=2, padding=1, bias=False),\n nn.BatchNorm2d(d // 2),\n nn.ReLU(inplace=True),\n nn.Conv2d(d // 2, d, kernel_size=4, stride=2, padding=1, bias=False),\n nn.BatchNorm2d(d),\n nn.ReLU(inplace=True),\n ResBlock(d, d, bn=True),\n nn.BatchNorm2d(d),\n ResBlock(d, d, bn=True),\n )\n self.decoder = nn.Sequential(\n ResBlock(d, d, bn=True),\n nn.BatchNorm2d(d),\n ResBlock(d, d, bn=True),\n nn.BatchNorm2d(d),\n\n nn.ConvTranspose2d(d, d // 2, kernel_size=4, stride=2, padding=1, bias=False),\n nn.BatchNorm2d(d//2),\n nn.ReLU(inplace=True),\n nn.ConvTranspose2d(d // 2, 3, kernel_size=4, stride=2, padding=1, bias=False),\n )\n self.f = 8\n self.d = d\n self.fc11 = nn.Linear(d * self.f ** 2, d * self.f ** 2)\n self.fc12 = nn.Linear(d * self.f ** 2, d * self.f ** 2)\n self.kl_coef = kl_coef\n self.kl_loss = 0\n self.mse = 0\n\n def encode(self, x):\n h1 = self.encoder(x)\n h1 = h1.view(-1, self.d * self.f ** 2)\n return self.fc11(h1), self.fc12(h1)\n\n def reparameterize(self, mu, logvar):\n if self.training:\n std = logvar.mul(0.5).exp_()\n eps = Variable(std.new(std.size()).normal_())\n return eps.mul(std).add_(mu)\n else:\n return mu\n\n def decode(self, z):\n z = z.view(-1, self.d, self.f, self.f)\n h3 = self.decoder(z)\n return F.tanh(h3)\n\n def forward(self, x):\n mu, logvar = self.encode(x)\n z = self.reparameterize(mu, logvar)\n return self.decode(z), mu, logvar\n\n def sample(self, size):\n sample = Variable(torch.randn(size, self.d * self.f ** 2), requires_grad=False)\n if self.cuda():\n sample = sample.cuda()\n return self.decode(sample).cpu()\n\n def loss_function(self, x, recon_x, mu, logvar):\n self.mse = F.mse_loss(recon_x, x)\n batch_size = x.size(0)\n\n # see Appendix B from VAE paper:\n # Kingma and Welling. Auto-Encoding Variational Bayes. ICLR, 2014\n # https://arxiv.org/abs/1312.6114\n # 0.5 * sum(1 + log(sigma^2) - mu^2 - sigma^2)\n self.kl_loss = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())\n # Normalise by same number of elements as in reconstruction\n self.kl_loss /= batch_size * 3 * 1024\n\n # return mse\n return self.mse + self.kl_coef * self.kl_loss\n\n def latest_losses(self):\n return {'mse': self.mse, 'kl': self.kl_loss}\n\n\nclass VQ_CVAE(nn.Module):\n def __init__(self, d, k=10, bn=True, vq_coef=1, commit_coef=0.5, num_channels=3, **kwargs):\n super(VQ_CVAE, self).__init__()\n\n self.encoder = nn.Sequential(\n nn.Conv2d(num_channels, d, kernel_size=4, stride=2, padding=1),\n nn.BatchNorm2d(d),\n nn.ReLU(inplace=True),\n nn.Conv2d(d, d, kernel_size=4, stride=2, padding=1),\n nn.BatchNorm2d(d),\n nn.ReLU(inplace=True),\n ResBlock(d, d, bn),\n nn.BatchNorm2d(d),\n ResBlock(d, d, bn),\n nn.BatchNorm2d(d),\n )\n self.decoder = nn.Sequential(\n ResBlock(d, d),\n nn.BatchNorm2d(d),\n ResBlock(d, d),\n nn.ConvTranspose2d(d, d, kernel_size=4, stride=2, padding=1),\n nn.BatchNorm2d(d),\n nn.ReLU(inplace=True),\n nn.ConvTranspose2d(d, num_channels, kernel_size=4, stride=2, padding=1),\n )\n self.d = d\n self.emb = NearestEmbed(k, d)\n self.vq_coef = vq_coef\n self.commit_coef = commit_coef\n self.mse = 0\n self.vq_loss = Variable(torch.zeros(1))\n self.commit_loss = 0\n\n for l in self.modules():\n if isinstance(l, nn.Linear) or isinstance(l, nn.Conv2d):\n l.weight.detach().normal_(0, 0.02)\n torch.fmod(l.weight, 0.04)\n nn.init.constant_(l.bias, 0)\n\n self.encoder[-1].weight.detach().fill_(1 / 40)\n\n self.emb.weight.detach().normal_(0, 0.02)\n torch.fmod(self.emb.weight, 0.04)\n\n def encode(self, x):\n return self.encoder(x)\n\n def decode(self, x):\n return F.tanh(self.decoder(x))\n\n def forward(self, x):\n z_e = self.encode(x)\n self.f = z_e.shape[-1]\n z_q, argmin = self.emb(z_e, weight_sg=True)\n emb, _ = self.emb(z_e.detach())\n return self.decode(z_q), z_e, emb, argmin\n\n def sample(self, size):\n sample = Variable(torch.randn(size, self.d, self.f, self.f), requires_grad=False)\n if self.cuda():\n sample = sample.cuda()\n emb, _ = self.emb(sample)\n return self.decode(emb.view(size, self.d, self.f, self.f)).cpu()\n\n def loss_function(self, x, recon_x, z_e, emb, argmin):\n self.mse = F.mse_loss(recon_x, x)\n\n self.vq_loss = torch.mean(torch.norm((emb - z_e.detach())**2, 2, 1))\n self.commit_loss = torch.mean(torch.norm((emb.detach() - z_e)**2, 2, 1))\n\n return self.mse + self.vq_coef*self.vq_loss + self.commit_coef*self.commit_loss\n\n def latest_losses(self):\n return {'mse': self.mse, 'vq': self.vq_loss, 'commitment': self.commit_loss}\n\n def print_atom_hist(self, argmin):\n\n argmin = argmin.detach().cpu().numpy()\n unique, counts = np.unique(argmin, return_counts=True)\n logging.info(counts)\n logging.info(unique)\n", "meta": {"hexsha": "86a542fbcd4700f90b5dc302a0fe6391f21ec9e0", "size": 11184, "ext": "py", "lang": "Python", "max_stars_repo_path": "vq_vae/auto_encoder.py", "max_stars_repo_name": "pedrodiamel/VQ-VAE", "max_stars_repo_head_hexsha": "32268f783f54305f234d205ad12ff5a02b3fa191", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "vq_vae/auto_encoder.py", "max_issues_repo_name": "pedrodiamel/VQ-VAE", "max_issues_repo_head_hexsha": "32268f783f54305f234d205ad12ff5a02b3fa191", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "vq_vae/auto_encoder.py", "max_forks_repo_name": "pedrodiamel/VQ-VAE", "max_forks_repo_head_hexsha": "32268f783f54305f234d205ad12ff5a02b3fa191", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.4173913043, "max_line_length": 98, "alphanum_fraction": 0.576269671, "include": true, "reason": "import numpy", "num_tokens": 3063, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230157, "lm_q2_score": 0.3702253856469203, "lm_q1q2_score": 0.19089558214578603}} {"text": "\"\"\"Example to perform the combination between ANTARES and Super-Kamiokande.\n\nThis is taking benefit of the the specific formats described in ANTARES and Super-Kamiokande examples.\nAll provided values are dummy.\n\"\"\"\n\nimport healpy as hp\nimport numpy as np\n\nimport jang.gw\nimport jang.limits\nimport jang.results\nfrom jang.parameters import Parameters\nfrom jang.neutrinos import BackgroundFixed, Detector, SuperDetector\n\nfrom examples.superkamiokande import EffectiveAreaSK\n\n\ndef single_event(\n gwname: str,\n gwdbfile: str,\n ant_results: dict,\n sk_results: dict,\n pars: Parameters,\n dbfile: str = None,\n):\n\n database_gw = jang.gw.Database(gwdbfile)\n database_res = jang.results.Database(dbfile)\n\n antares = Detector(\"examples/input_files/detector_antares.yaml\")\n sk = Detector(\"examples/input_files/detector_superk.yaml\")\n effarea_sk = [\n EffectiveAreaSK(filename=sk_results[\"effarea\"], sample=s) for s in sk.samples\n ]\n\n # Combination\n ant_sk = SuperDetector(\"ANTARES + Super-Kamiokande\")\n ant_sk.add_detector(antares)\n ant_sk.add_detector(sk)\n\n gw = database_gw.find_gw(gwname)\n\n antares.set_acceptances(ant_results[\"acceptances\"], pars.spectrum, pars.nside)\n bkg_ant = [BackgroundFixed(b) for b in ant_results[\"nbkg\"]]\n antares.set_observations(ant_results[\"nobs\"], bkg_ant)\n pars.nside = antares.get_acceptances(pars[\"spectrum\"])[0].nside\n\n accs = [\n effarea.to_acceptance(sk, pars.nside, gw.jd, pars.spectrum)\n for effarea in effarea_sk\n ]\n sk.set_acceptances(accs, pars.spectrum, pars.nside)\n bkg_sk = [BackgroundFixed(b) for b in sk_results[\"nbkg\"]]\n sk.set_observations(sk_results[\"nobs\"], bkg_sk)\n\n limit_flux = jang.limits.get_limit_flux(ant_sk, gw, pars)\n limit_etot = jang.limits.get_limit_etot(ant_sk, gw, pars)\n limit_fnu = jang.limits.get_limit_fnu(ant_sk, gw, pars)\n database_res.add_entry(\n ant_sk, gw, pars, limit_flux, limit_etot, limit_fnu, None, None, None\n )\n\n if dbfile is not None:\n database_res.save()\n\n\nif __name__ == \"__main__\":\n\n pars = Parameters(\"examples/input_files/config.yaml\")\n pars.set_models(\"x**-2\", jang.conversions.JetIsotropic())\n\n gw_db_file = \"examples/input_files/gw_catalogs/database_example.csv\"\n npix = hp.nside2npix(8)\n ant_results = {\n \"nobs\": [0, 0, 0, 0],\n \"nbkg\": [0, 0, 0, 0],\n \"acceptances\": [np.ones(npix), np.zeros(npix), np.ones(npix), np.zeros(npix)],\n }\n sk_results = {\n \"nobs\": [0, 0, 0],\n \"nbkg\": [0, 0, 0],\n \"effarea\": \"examples/input_files/effarea_superk.root\",\n }\n single_event(\"GW190412\", gw_db_file, ant_results, sk_results, pars)\n", "meta": {"hexsha": "b3ccee223eb846fcbc7a11b1b8f02d28f484e57c", "size": 2694, "ext": "py", "lang": "Python", "max_stars_repo_path": "examples/combination.py", "max_stars_repo_name": "mlamo/pyjang", "max_stars_repo_head_hexsha": "7aa5c9ef8b14d672c4f231e25b809eaa4ca1015d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "examples/combination.py", "max_issues_repo_name": "mlamo/pyjang", "max_issues_repo_head_hexsha": "7aa5c9ef8b14d672c4f231e25b809eaa4ca1015d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "examples/combination.py", "max_forks_repo_name": "mlamo/pyjang", "max_forks_repo_head_hexsha": "7aa5c9ef8b14d672c4f231e25b809eaa4ca1015d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-19T22:02:24.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-19T22:02:24.000Z", "avg_line_length": 31.3255813953, "max_line_length": 102, "alphanum_fraction": 0.6948775056, "include": true, "reason": "import numpy", "num_tokens": 765, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583269943353745, "lm_q2_score": 0.34158251284363395, "lm_q1q2_score": 0.19071473771351058}} {"text": "#!/usr/bin/env python3\n#--coding:utf-8 --\n\"\"\"\ncallTransLoops.py\n\"\"\"\n\n#sys\nimport os\nimport sys\nimport json\nfrom glob import glob\nfrom datetime import datetime\nfrom collections import Counter\n\n#3rd\nimport joblib\nimport numpy as np\nimport pandas as pd\nfrom tqdm import tqdm\nfrom joblib import Parallel, delayed\nfrom sklearn import linear_model\nfrom scipy.stats import hypergeom, binom, poisson, combine_pvalues\n\n#cLoops\nfrom cLoops2.ds import Loop, XY\nfrom cLoops2.io import parseIxy, ixy2pet, loops2juiceTxt, loops2washuTxt, ixy2pet, updateJson, loops2txt\nfrom cLoops2.geo import checkLoopOverlap, combineLoops\nfrom cLoops2.settings import *\nfrom cLoops2.blockDBSCAN import blockDBSCAN as DBSCAN\nfrom cLoops2.callCisLoops import getPerRegions, selSigLoops, estAnchorSig\n\n\ndef runTransDBSCANLoops(fixy, eps, minPts):\n \"\"\"\n Run DBSCAN to detect interactions for one .ixy file.\n @param fixy: str, .ixy file name \n @param eps: int, eps for DBSCAN\n @param minPts: int, minPts for DBSCAN\n \"\"\"\n loops, loopReads = [], []\n key, mat = parseIxy(fixy, cut=0)\n #gave mat each PET a id\n mat2 = np.zeros((mat.shape[0],3))\n mat2[:,0] = np.arange(mat.shape[0])\n mat2[:,1] = mat[:,0]\n mat2[:,2] = mat[:,1]\n mat = mat2\n\n #data for interaction records, read for readId\n report = \"%s \\t Clustering %s and %s using eps %s, minPts %s\\n\" % (\n datetime.now(), key[0], key[1], eps, minPts)\n sys.stderr.write(report)\n db = DBSCAN(mat, eps, minPts)\n labels = pd.Series(db.labels)\n mat = pd.DataFrame(mat[:, 1:].astype(\"int\"),\n index=mat[:, 0],\n columns=[\"X\", \"Y\"])\n nlabels = set(labels.values)\n #collect clusters\n for label in nlabels:\n los = list(labels[labels == label].index)\n loopReads.extend(los)\n sub = mat.loc[los, :]\n if int(np.min(sub[\"X\"])) == int(np.max(sub[\"X\"])) or int(\n np.min(sub[\"Y\"])) == int(np.max(sub[\"Y\"])):\n continue\n #define loops\n loop = Loop()\n loop.rab = sub.shape[0]\n loop.chromX = key[0]\n loop.chromY = key[1]\n loop.x_start = int(np.min(sub[\"X\"]))\n loop.x_end = int(np.max(sub[\"X\"]))\n loop.x_center = (loop.x_start + loop.x_end) / 2\n loop.y_start = int(np.min(sub[\"Y\"]))\n loop.y_end = int(np.max(sub[\"Y\"]))\n loop.y_center = (loop.y_start + loop.y_end) / 2\n loop.distance = -1\n loop.cis = False\n loops.append(loop)\n report = \"%s \\t Clustering %s and %s finished. Estimated %s reads for %s candidate loops. \\n\" % (\n datetime.now(), key[0], key[1], len(loopReads), len(loops))\n sys.stderr.write(report)\n return \"-\".join(key), loops\n\n\n#related\ndef parallelRunTransDBSCANLoops(meta, eps, minPts, cpu=1):\n \"\"\"\n Paralle version of runCisDBSCANLoops\n @param meta: meta information parsed form petMeta.json\n @param eps: int, eps for DBSCAN\n @param minPts: int, minPts for DBSCAN\n \"\"\"\n ds = Parallel(n_jobs=cpu,backend=\"multiprocessing\")(delayed(runTransDBSCANLoops)(\n meta[\"data\"][\"trans\"][key][\"ixy\"], eps, minPts)\n for key in meta[\"data\"][\"trans\"].keys())\n loops = {}\n for d in ds:\n if d is not None and len(d[1]) > 0:\n key, di = d[0], d[1]\n loops[key] = di\n return loops\n\n\ndef estLoopSig(key,\n loops,\n fixy,\n minPts=5,\n pseudo=1,\n peakPcut=1e-5,\n peakFccut=2,\n countDiffCut=10):\n \"\"\"\n Estimate the loop statstical significance for one chromosomal.\n @param loops: list of Loop object\n @param fixy: cLoops2 pre generated .ixy file\n @param minPts: int, minPts\n \"\"\"\n xy = ixy2pet(fixy, cut=0)\n N = xy.number\n print(\"%s \\t Estimate significance for %s candidate interactions in %s.\" %\n (datetime.now(), len(loops), key))\n nloops = []\n for loop in tqdm(loops):\n ra, rb, rab = xy.queryLoop(loop.x_start, loop.x_end, loop.y_start,\n loop.y_end)\n ra, rb, rab = len(ra), len(rb), len(rab)\n if rab < minPts:\n continue\n loop.ra = ra\n loop.rb = rb\n loop.rab = rab\n #unbalanced anchor density, to avoid lines, unknow reason for lines, maybe stripes\n if ra / float(rb) > countDiffCut or rb / float(ra) > countDiffCut:\n continue\n if (loop.x_end -\n loop.x_start) / (loop.y_end - loop.y_start) > countDiffCut or (\n loop.y_end - loop.y_start) / (loop.x_end -\n loop.x_start) > countDiffCut:\n continue\n lowerra, lowerrb, lowerrab = xy.queryLoop(\n loop.x_start - (loop.x_end - loop.x_start), loop.x_start,\n loop.y_start - (loop.y_end - loop.y_start), loop.y_start) #p2ll\n loop.P2LL = float(rab) / max(len(lowerrab), pseudo)\n px, esx = estAnchorSig(xy, loop.x_start, loop.x_end)\n py, esy = estAnchorSig(xy, loop.y_start, loop.y_end)\n loop.x_peak_poisson_p_value = px\n loop.x_peak_es = esx\n loop.y_peak_poisson_p_value = py\n loop.y_peak_es = esy\n #hypergeometric p-value\n hyp = max([1e-300, hypergeom.sf(rab - 1.0, N, ra, rb)])\n #start caculate the permutated background\n rabs, nbps = [], []\n nas, nbs = getPerRegions(loop, xy)\n for na in nas:\n nac = float(len(na))\n for nb in nbs:\n nbc = float(len(nb))\n nrab = float(len(na.intersection(nb)))\n #collect the value for poisson test\n rabs.append(nrab)\n #collect the possibility for following binomial test\n if nac > 0 and nbc > 0:\n den = nrab / (nac * nbc)\n nbps.append(den)\n else:\n nbps.append(0.0)\n rabs, nbps = np.array(rabs), np.array(nbps)\n mrabs = float(np.mean(rabs))\n mbps = np.mean(nbps)\n #local fdr\n fdr = len(rabs[rabs > rab]) / float(len(rabs))\n #enrichment score\n es = rab / max(mrabs, pseudo)\n #simple possion test\n pop = max([1e-300, poisson.sf(rab - 1.0, mrabs)])\n #simple binomial test\n nbp = max([\n 1e-300, binom.sf(rab - 1.0, ra * rb, mbps)\n ]) #the p-value is quit similar to that of cLoops 1 binomial test\n loop.FDR = fdr\n loop.ES = es\n loop.density = float(\n loop.rab) / (loop.x_end - loop.x_start + loop.y_end -\n loop.y_start) / N * 10.0**9\n loop.hypergeometric_p_value = hyp\n loop.poisson_p_value = pop\n loop.binomial_p_value = nbp\n nloops.append(loop)\n #print(ra,rb,rab,mrabs,es,fdr,hyp,pop,nbp,n,nbp2)\n return key, nloops\n\n\ndef markSigLoops(key, loops):\n \"\"\"\n Mark the significance of different loops.\n \"\"\"\n sig = lambda x: True if x.binomial_p_value <= 1e-10 and x.FDR <= 0.05 and loop.ES >= 2 else False\n for loop in loops:\n if sig(loop):\n loop.significant = 1\n else:\n loop.significant = 0\n return key, loops\n\n\ndef callTransLoops(\n predir,\n fout,\n logger,\n eps=[2000, 5000],\n minPts=[5, 10],\n cpu=1,\n filter=False,\n washU=False,\n juicebox=False,\n):\n \"\"\"\n Call inter-chromosomal loops parallel.\n @param metaf: str, petMeta.json file for calling peaks\n @param eps: list\n @param minPts: list\n \"\"\"\n\n metaf = predir + \"/petMeta.json\"\n meta = json.loads(open(metaf).read())\n ## step 1 find the candidate loops by running multiple times of clustering\n loops = {} #candidate loops\n for ep in eps:\n for minPt in minPts:\n loops_2 = parallelRunTransDBSCANLoops(meta, ep, minPt, cpu=cpu)\n loops = combineLoops(loops, loops_2)\n ## step 2 determine the statstical significance of candidate loops\n logger.info(\"Estimating loop statstical significance.\")\n ds = Parallel(n_jobs=cpu,backend=\"multiprocessing\")(delayed(estLoopSig)(\n key,\n loops[key],\n meta[\"data\"][\"trans\"][key][\"ixy\"],\n minPts=max(minPts),\n ) for key in loops.keys())\n nds = {}\n for d in ds:\n nds[d[0]] = d[1]\n\n #mark the significant loops\n ds = Parallel(n_jobs=cpu,backend=\"multiprocessing\")(delayed(markSigLoops)(key, nds[key])\n for key in nds.keys())\n nds = {}\n for d in ds:\n nds[d[0]] = d[1]\n\n ## step 4 for the overlapped loops, output the most significant one\n logger.info(\"Selecting the most significant loops of overlapped ones. \")\n ds = Parallel(n_jobs=cpu,backend=\"multiprocessing\")(delayed(selSigLoops)(key, nds[key])\n for key in nds.keys())\n nds = {}\n for d in ds:\n nds[d[0]] = d[1]\n ds = Parallel(n_jobs=cpu,backend=\"multiprocessing\")(delayed(selSigLoops)(key, nds[key])\n for key in nds.keys())\n nds = {}\n for d in ds:\n nds[d[0]] = d[1]\n loops = []\n for d in ds:\n loops.extend(d[1])\n ## step 5 output\n logger.info(\"Output %s loops to %s_loops.txt\" % (len(loops), fout))\n loops2txt(loops, fout + \"_trans_loops.txt\")\n if washU:\n loops2washuTxt(loops, fout + \"_trans_loops_washU.txt\")\n if juicebox:\n loops2juiceTxt(loops, fout + \"_trans_loops_juicebox.txt\")\n", "meta": {"hexsha": "ff16627b9a8237e598a037f05e540d69240b678d", "size": 9513, "ext": "py", "lang": "Python", "max_stars_repo_path": "cLoops2/callTransLoops.py", "max_stars_repo_name": "KejiZhaoLab/cLoops2", "max_stars_repo_head_hexsha": "2a1ce6b63a912cdd282dc40718d2c7333e3c16b2", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 16, "max_stars_repo_stars_event_min_datetime": "2021-07-17T07:39:26.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-10T05:35:59.000Z", "max_issues_repo_path": "cLoops2/callTransLoops.py", "max_issues_repo_name": "KejiZhaoLab/cLoops2", "max_issues_repo_head_hexsha": "2a1ce6b63a912cdd282dc40718d2c7333e3c16b2", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-01-31T07:56:29.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-01T16:20:29.000Z", "max_forks_repo_path": "cLoops2/callTransLoops.py", "max_forks_repo_name": "KejiZhaoLab/cLoops2", "max_forks_repo_head_hexsha": "2a1ce6b63a912cdd282dc40718d2c7333e3c16b2", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2021-07-22T03:56:38.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-13T05:52:14.000Z", "avg_line_length": 34.4673913043, "max_line_length": 104, "alphanum_fraction": 0.5724797645, "include": true, "reason": "import numpy,from scipy", "num_tokens": 2675, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583269943353744, "lm_q2_score": 0.3415825061409754, "lm_q1q2_score": 0.19071473397123534}} {"text": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Thu May 10 10:32:04 2018\n\n@author: smrak\n\"\"\"\nimport numpy as np\nfrom datetime import datetime\nimport apexpy as ap\nimport igrf12\nimport cartopy.crs as ccrs\nimport cartopy.feature as cfeature\nfrom cartopy.feature.nightshade import Nightshade\nimport matplotlib.pyplot as plt\nimport matplotlib.ticker as mticker\nfrom sunrise import terminator as ter\n\nprojection_dict = {'stereo': ccrs.Stereographic(), \n 'merc': ccrs.Mercator(),\n 'plate': ccrs.PlateCarree(),\n 'lambert': ccrs.LambertConformal(),\n 'mollweide': ccrs.Mollweide(),\n 'north': ccrs.NorthPolarStereo(),\n 'south': ccrs.NorthPolarStereo(),\n 'ortographic': ccrs.Orthographic()\n }\n\ndef plotCartoMap(latlim=[0, 75], lonlim=[-40, 40], parallels=None, meridians=None,\n pole_center_lon=0,figsize=(12, 8), terrain=False, ax=False,\n projection='stereo', title='', resolution='110m', lon0=None,lat0=None,\n states=True, grid_linewidth=0.5, grid_color='black', \n grid_linestyle='--', background_color=None, border_color='k',\n figure=False, nightshade=False, ns_alpha=0.1,\n apex=False, igrf=False, date=None, \n mlat_levels=None, mlon_levels=None, alt_km=0.0,\n mlon_colors='blue', mlat_colors='red', mgrid_width=1,\n mgrid_labels=True, mgrid_fontsize=12, mlon_cs='mlon',\n incl_levels=None, decl_levels=None, igrf_param='incl',\n mlon_labels=True, mlat_labels=True, mgrid_style='--',\n label_colors='k', apex_alt=0,\n decl_colors='k', incl_colors='k',\n terminator=False, terminator_altkm=350,\n polarization_terminator=False, pt_hemisphere='north',\n ter_color='red', ter_style='--', ter_width=2,\n midnight=False, midnight_colors='m', midnight_width=2,\n midnight_style='--'):\n if lonlim is None or lonlim == []:\n lonlim = [-180, 180]\n STATES = cfeature.NaturalEarthFeature(\n category='cultural',\n name='admin_1_states_provinces_lines',\n scale='50m',\n facecolor='none')\n \n \n if not ax:\n if figsize is None:\n fig = plt.figure()\n else:\n fig = plt.figure(figsize=figsize)\n \n if projection == 'stereo':\n ax = plt.axes(projection=ccrs.Stereographic(central_longitude=(sum(lonlim)/2)))\n elif projection == 'merc':\n ax = plt.axes(projection=ccrs.Mercator())\n elif projection == 'plate':\n ax = plt.axes(projection=ccrs.PlateCarree(central_longitude=(sum(lonlim)/2)))\n elif projection == 'lambert':\n ax = plt.axes(projection=ccrs.LambertConformal(central_longitude=(sum(lonlim)/2),\n central_latitude=(sum(latlim)/2)))\n elif projection == 'mollweide':\n ax = plt.axes(projection=ccrs.Mollweide(central_longitude=(sum(lonlim)/2)))\n elif projection == 'north':\n if lon0 is None:\n lon0 = 0\n ax = plt.axes(projection=ccrs.NorthPolarStereo(central_longitude=lon0))\n elif projection == 'south':\n if lon0 is None:\n lon0 = 0\n ax = plt.axes(projection=ccrs.SouthPolarStereo(central_longitude=lon0))\n elif projection == 'ortographic':\n if lon0 is None:\n lon0 = 0\n if lat0 is None:\n lat0 = 0\n ax = plt.axes(projection=ccrs.Orthographic(central_longitude=lon0, central_latitude=lat0))\n else:\n print (\"Projection is invalid. Please enter the right one. \\n \\\n 'stereo', 'merc', 'plate', 'lambret', mollweide', 'north, 'south', 'ortographic'\")\n return 0\n if background_color is not None:\n ax.background_patch.set_facecolor(background_color)\n ax.set_title(title)\n ax.coastlines(color=border_color, resolution=resolution) # 110m, 50m or 10m\n if states:\n ax.add_feature(STATES, edgecolor=border_color)\n ax.add_feature(cfeature.BORDERS, edgecolor=border_color)\n if terrain:\n ax.stock_img()\n if nightshade:\n assert date is not None\n assert ns_alpha is not None\n ax.add_feature(Nightshade(date, ns_alpha))\n # Draw Parralels\n if projection == 'merc' or projection == 'plate':\n if isinstance(meridians, np.ndarray):\n meridians = list(meridians)\n if isinstance(parallels, np.ndarray):\n parallels = list(parallels)\n \n gl = ax.gridlines(crs=ccrs.PlateCarree(), color=grid_color, draw_labels=False,\n linestyle=grid_linestyle, linewidth=grid_linewidth)\n if meridians is None:\n gl.xlines = False\n else:\n if len(meridians) > 0:\n gl.xlocator = mticker.FixedLocator(meridians)\n gl.xlabels_bottom = True\n else:\n gl.ylines = False\n \n if parallels is None:\n gl.ylines = False\n else:\n if len(parallels) > 0:\n gl.ylocator = mticker.FixedLocator(parallels)\n gl.ylabels_left = True\n else:\n gl.ylines = False\n else:\n gl = ax.gridlines(crs=ccrs.PlateCarree(), color=grid_color, draw_labels=False,\n linestyle=grid_linestyle, linewidth=grid_linewidth)\n if meridians is None:\n gl.xlines = False\n else:\n gl.xlocator = mticker.FixedLocator(meridians)\n if parallels is not None: \n if isinstance(parallels, np.ndarray):\n parallels = list(parallels)\n gl.ylocator = mticker.FixedLocator(parallels)\n else:\n gl.ylines = False\n \n # Geomagnetic coordinates @ Apex\n if apex:\n if date is None:\n date = datetime(2017, 12, 31, 0, 0, 0)\n assert isinstance(date, datetime)\n \n A = ap.Apex(date = date)\n # Define levels and ranges for conversion\n if mlon_cs == 'mlt':\n if mlon_levels is None:\n mlon_levels = np.array([])\n mlon_range = np.arange(0, 24.01, 0.01)\n elif isinstance(mlon_levels, bool):\n if mlon_levels == False:\n mlon_levels = np.array([])\n mlon_range = np.arange(0, 24.01, 0.01)\n else:\n mlon_range = np.arange(mlon_levels[0], mlon_levels[-1]+0.1, 0.01)\n else:\n if mlon_levels is None:\n mlon_levels = np.array([])\n mlon_range = np.arange(-180,180,0.5)\n elif isinstance(mlon_levels, bool):\n if mlon_levels == False:\n mlon_levels = np.array([])\n mlon_range = np.arange(-180, 181, 0.1)\n else:\n mlon_range = np.arange(mlon_levels[0], mlon_levels[0]+362, 0.1)\n if mlat_levels is None:\n mlat_levels = np.arange(-90, 90.1, 1)\n mlat_range = np.arange(mlat_levels[0], mlat_levels[-1]+0.1, 0.1)\n \n # Do meridans\n for mlon in mlon_levels:\n MLON = mlon * np.ones(mlat_range.size)\n if mlon_cs == 'mlt':\n y, x = A.convert(mlat_range, MLON, 'mlt', 'geo', datetime=date, height=apex_alt)\n else:\n y, x = A.convert(mlat_range, MLON, 'apex', 'geo', height=apex_alt)\n mlat_mask_extent = (y >= latlim[0] + 0.2) & (y <= latlim[1] - 0.2)\n # Plot meridian\n inmap = np.logical_and(x >= lonlim[0], x <= lonlim[1])\n if np.sum(inmap) > 10:\n ax.plot(np.unwrap(x[mlat_mask_extent], 180), \n np.unwrap(y[mlat_mask_extent], 90), c=mlon_colors, \n lw=mgrid_width, linestyle=mgrid_style, zorder=90,\n transform=ccrs.PlateCarree())\n \n # Labels\n if mlon_labels:\n ix = abs(y-np.mean(latlim)).argmin()\n mx = x[ix] - 1 if mlon >=10 else x[ix] - 0.5\n my = np.mean(latlim)\n if np.logical_and(mx >= lonlim[0], mx <= lonlim[1]):\n if mlon_cs == 'mlt' and mlon != 0:\n ax.text(mx, my, str(int(mlon)), color=label_colors, \n fontsize=14, backgroundcolor='white',\n transform=ccrs.PlateCarree())\n elif mlon_cs != 'mlt' and mlon != 360:\n ax.text(mx, my, str(int(mlon)), color=label_colors, \n fontsize=14, backgroundcolor='white',\n transform=ccrs.PlateCarree())\n # Do parallels\n for mlat in mlat_levels:\n MLAT = mlat * np.ones(mlon_range.size)\n if mlon_cs == 'mlt':\n gy, gx = A.convert(MLAT, mlon_range, 'mlt', 'geo', datetime=date, height=apex_alt)\n else:\n \n gy, gx = A.convert(MLAT, mlon_range, 'apex', 'geo', datetime=date, height=apex_alt)\n inmap = np.logical_and(gy >= latlim[0], gy <= latlim[1])\n if np.sum(inmap) > 20:\n ax.plot(np.unwrap(gx, 180), np.unwrap(gy, 90), c=mlat_colors,\n lw=mgrid_width, linestyle=mgrid_style, zorder=90,\n transform=ccrs.PlateCarree())\n \n # Labels\n if mlat_labels:\n ix = abs(gx-np.mean(lonlim)).argmin()\n mx = np.mean(lonlim)\n my = gy[ix] - 0.5\n if np.logical_and(mx >= lonlim[0], mx <= lonlim[1]) and \\\n np.logical_and(my >= latlim[0], my <= latlim[1]):\n ax.text(mx, my, str(int(mlat)), color=label_colors, \n fontsize=14, backgroundcolor='white',\n transform=ccrs.PlateCarree())\n if igrf:\n glon = np.arange(lonlim[0]-40, lonlim[1] + 40.1, 0.5)\n glat = np.arange(-90, 90 + 0.1, 0.5)\n longrid, latgrid = np.meshgrid(glon, glat)\n mag = igrf12.gridigrf12(t=date, glat=latgrid, glon=longrid, alt_km=alt_km)\n if decl_levels is not None:\n z = mag.decl.values\n for declination in decl_levels:\n ax.contour(longrid, latgrid, z, levels=declination, zorder=90,\n colors=decl_colors, transform=ccrs.PlateCarree())\n if incl_levels is not None:\n z = mag.incl.values\n for inclination in incl_levels:\n ax.contour(longrid, latgrid, z, levels=declination, zorder=90,\n colors=incl_colors, transform=ccrs.PlateCarree())\n # Terminators\n if terminator:\n assert date is not None\n if not isinstance(terminator_altkm, list):\n terminator_altkm = [terminator_altkm]\n for takm in terminator_altkm:\n try:\n glon_ter, glat_ter = ter.get_terminator(date, alt_km = takm)\n if glon_ter is not None and glat_ter is not None:\n if isinstance(glon_ter, list):\n for i in range(len(glon_ter)):\n ax.plot(np.unwrap(glon_ter[i], 180), np.unwrap(glat_ter[i], 90),\n c=ter_color, lw=ter_width, ls=ter_style, zorder=90,\n transform=ccrs.PlateCarree())\n else:\n ax.plot(np.unwrap(glon_ter, 180), np.unwrap(glat_ter, 90),\n c=ter_color, lw=ter_width, ls=ter_style, zorder=90,\n transform=ccrs.PlateCarree())\n except:\n pass\n if midnight:\n mlat_range = np.arange(-89.9, 90.1, 0.1)\n MLON = 0 * np.ones(mlat_range.size)\n if mlon_cs == 'mlt':\n y, x = A.convert(mlat_range, MLON, 'mlt', 'geo', datetime=date, height=apex_alt)\n else:\n y, x = A.convert(mlat_range, MLON, 'apex', 'geo', height=apex_alt)\n mlat_mask_extent = (y >= latlim[0] + 0.2) & (y <= latlim[1] - 0.2)\n # Plot meridian\n inmap = np.logical_and(x >= lonlim[0], x <= lonlim[1])\n if np.sum(inmap) > 10:\n ax.plot(np.unwrap(x[mlat_mask_extent], 180), \n np.unwrap(y[mlat_mask_extent], 90), c=midnight_colors, \n lw=midnight_width, linestyle=midnight_style, zorder=90,\n transform=ccrs.PlateCarree())\n # Set Extent\n if projection == 'north' or projection == 'south':\n import matplotlib.path as mpath\n ax.set_extent([-180, 181, latlim[0], latlim[1]], crs=ccrs.PlateCarree())\n theta = np.linspace(0, 2*np.pi, 100)\n center, radius = [0.5, 0.5], 0.5\n verts = np.vstack([np.sin(theta), np.cos(theta)]).T\n circle = mpath.Path(verts * radius + center)\n ax.set_boundary(circle, transform=ax.transAxes)\n elif lonlim[0] != -180 and lonlim[1] != 180:\n ax.set_extent([lonlim[0], lonlim[1], latlim[0], latlim[1]], crs=ccrs.PlateCarree())#ccrs.PlateCarree())\n \n if 'fig' in locals():\n return fig, ax\n else:\n return ax\n", "meta": {"hexsha": "dbc17ca8255edefea09cbad613cd0a9e66e9700e", "size": 13445, "ext": "py", "lang": "Python", "max_stars_repo_path": "cartomap/geogmap.py", "max_stars_repo_name": "gregstarr/cartomap", "max_stars_repo_head_hexsha": "46f0917c4315dede1a12a663de80cdde0ae73393", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2019-06-21T01:18:20.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-21T22:17:40.000Z", "max_issues_repo_path": "cartomap/geogmap.py", "max_issues_repo_name": "gregstarr/cartomap", "max_issues_repo_head_hexsha": "46f0917c4315dede1a12a663de80cdde0ae73393", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-06-10T13:05:18.000Z", "max_issues_repo_issues_event_max_datetime": "2019-06-10T13:05:18.000Z", "max_forks_repo_path": "cartomap/geogmap.py", "max_forks_repo_name": "gregstarr/cartomap", "max_forks_repo_head_hexsha": "46f0917c4315dede1a12a663de80cdde0ae73393", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2018-08-29T00:08:39.000Z", "max_forks_repo_forks_event_max_datetime": "2020-06-02T21:51:19.000Z", "avg_line_length": 45.2693602694, "max_line_length": 111, "alphanum_fraction": 0.5373744887, "include": true, "reason": "import numpy", "num_tokens": 3458, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583269943353745, "lm_q2_score": 0.34158249943831703, "lm_q1q2_score": 0.1907147302289603}} {"text": "\n# WaveformToVolume Paraview filter\n\n# Load the `WaveformDataReader` to access its VTK keys\n# sys.path.append(os.path.dirname(__file__))\n# from WaveformDataReader import WaveformDataReader\n\nimport numpy as np\nimport logging\nimport time\nfrom vtkmodules.vtkCommonDataModel import vtkUniformGrid\nfrom vtkmodules.vtkCommonCore import vtkDataArraySelection\nfrom vtkmodules.util.vtkAlgorithm import VTKPythonAlgorithmBase\nfrom vtkmodules.numpy_interface import dataset_adapter as dsa\nfrom paraview.util.vtkAlgorithm import smproxy, smproperty, smdomain\nfrom paraview import util\nfrom paraview.vtk.util import numpy_support as vtknp\nimport gwpv.plugin_util.timesteps as timesteps_util\nimport gwpv.plugin_util.data_array_selection as das_util\nfrom gwpv import swsh_cache\nimport h5py\nfrom os.path import exists\nlogger = logging.getLogger(__name__)\n\n# A grid is created here, and if analytical data created by creator.py\n# is recognized iti is loaded into the grid...\n\ngb_path = None\n\nif exists(\"timeseparated.h5\"):\n gb_path = \"timeseparated.h5\"\nelif exists(\"gwpv/timeseparated.h5\"):\n gb_path = \"gwpv/timeseparated.h5\"\nelse:\n gb_path = None\n\nlogger.warning(\"Retrieving data from \"+str(gb_path)+\".\")\n\nif gb_path != None:\n with h5py.File(gb_path, \"r\") as f:\n h = f['Extrapolated_N2.dir']\n tick = np.real(h['t_values.dir'])\n strains = np.zeros((len(tick), 1000000), dtype=np.complex)\n for i in range(len(tick)):\n strains[i] += np.real(h['t_{}.dir'.format(tick[i])]) + 1j*np.imag(h['t_{}.dir'.format(tick[i])])\nelse:\n logger.warning('No Bremsstrahlung data found, proceeding with merger visualization.')\n\n\n \ndef get_mode_name(l, abs_m):\n return \"({}, {}) Mode\".format(l, abs_m)\n\n\n# Reproduces `spherical_functions.LM_index` so we don't need to import the\n# `spherical_functions` module when using a cached SWSH grid\ndef LM_index(ell, m, ell_min):\n return ell * (ell + 1) - ell_min ** 2 + m\n\n\ndef smoothstep(x):\n return np.where(x < 0, 0, np.where(x <= 1, 3 * x**2 - 2 * x**3, 1))\n\n\ndef activation(x, width):\n return smoothstep(x / width)\n\n\ndef deactivation(x, width, outer):\n return smoothstep((outer - x) / width)\n\n\n# Caching\n# When using SwshGrid input this is not necessary anymore\n# These are global variables because setting them on the filter object appears\n# to trigger a \"ModifiedEvent\" so the data is recomputed.\n_cached_swsh_grid = None\n_cached_r = None\n_cached_grid_id = None\ndef cached_swsh_grid(size, radial_scale, activation_offset, activation_width, deactivation_width, add_one_over_r_scaling, **swsh_grid_kwargs):\n global _cached_swsh_grid, _cached_r, _cached_grid_id\n grid_id = dict(size=size,\n radial_scale=radial_scale,\n activation_offset=activation_offset,\n activation_width=activation_width,\n deactivation_width=deactivation_width,\n add_one_over_r_scaling=add_one_over_r_scaling)\n grid_id.update(swsh_grid_kwargs)\n if _cached_grid_id == grid_id:\n logger.debug(\"Using cached SWSHs grid from memory.\")\n return _cached_swsh_grid, _cached_r\n else:\n logger.debug(\"No SWSH grid in memory, retrieving from disk cache.\")\n swsh_grid, r = swsh_cache.cached_swsh_grid(size=size,\n **swsh_grid_kwargs)\n # Apply screening\n screen = activation(r - activation_offset,\n activation_width) * deactivation(\n r, deactivation_width, size)\n swsh_grid *= screen.reshape(screen.shape + (1, ))\n # Apply radial scale\n r *= radial_scale\n if add_one_over_r_scaling:\n swsh_grid /= (r + 1.e-30).reshape(r.shape + (1,))\n # Cache and return\n _cached_swsh_grid = swsh_grid\n _cached_r = r\n _cached_grid_id = grid_id\n return swsh_grid, r\n\n\nhas_shown_warning_nonuniformly_sampled = False\n\n\n@smproxy.filter(label=\"Waveform To Volume\")\n@smproperty.input(name=\"WaveformData\", port_index=0)\n@smdomain.datatype(dataTypes=[\"vtkTable\"])\n# TODO: We should be able to use a `SwshGrid` as a second input to this filter\n# and use this class to compute the volume data for the waveform without having\n# to generate the grid. Multiple inputs work fine, but for some reason\n# `pv.LoadPlugin` doesn't load `SwshGrid`.\n# @smproperty.input(name=\"GridData\", port_index=1)\n# @smdomain.datatype(dataTypes=[\"vtkUniformGrid\"])\nclass WaveformToVolume(VTKPythonAlgorithmBase):\n def __init__(self):\n VTKPythonAlgorithmBase.__init__(\n self,\n # nInputPorts=2,\n nInputPorts=1,\n nOutputPorts=1,\n # Choosing `vtkUniformGrid` for the output for the following reasons:\n # - `vtkRectilinearGrid` doesn't support volume rendering\n # (in Paraview v5.7.0 at least)\n # - The unstructured grids don't support the 'GPU Based'\n # volume rendering mode, which can do shading and looks nice\n outputType='vtkUniformGrid')\n self.modes_selection = vtkDataArraySelection()\n # TODO: We should really retrieve the available modes from the input\n # info in `RequestInformation`, but the `WAVEFORM_MODES` keys is not\n # propagating downstream for some reason...\n # modes_arrays_key = WaveformDataReader.MODES_ARRAYS_KEY\n # if waveform_data_info.Has(modes_arrays_key):\n # for i in range(waveform_data_info.Length(modes_arrays_key)):\n # self.modes_selection.AddArray(waveform_data_info.Get(\n # modes_arrays_key, i))\n for l in range(2, 5 + 1):\n for m in range(0, l + 1):\n self.modes_selection.AddArray(get_mode_name(l, m))\n self.modes_selection.AddObserver(\n \"ModifiedEvent\", das_util.create_modified_callback(self))\n self.polarizations_selection = vtkDataArraySelection()\n self.polarizations_selection.AddArray(\"Plus\")\n self.polarizations_selection.AddArray(\"Cross\")\n self.polarizations_selection.AddObserver(\n \"ModifiedEvent\", das_util.create_modified_callback(self))\n\n def FillInputPortInformation(self, port, info):\n # When using multiple inputs we (may) have to set their data types here\n # info.Set(self.INPUT_REQUIRED_DATA_TYPE(),\n # 'vtkTable' if port == 0 else 'vtkUniformGrid')\n info.Set(self.INPUT_REQUIRED_DATA_TYPE(), 'vtkTable')\n\n def _get_waveform_data(self):\n return dsa.WrapDataObject(self.GetInputDataObject(0, 0))\n\n # def _get_grid_data(self):\n # return dsa.WrapDataObject(self.GetInputDataObject(1, 0))\n\n @smproperty.dataarrayselection(name=\"Modes\")\n def GetModes(self):\n return self.modes_selection\n\n @smproperty.intvector(name=\"StoreIndividualModes\", default_values=False)\n def SetStoreIndividualModes(self, value):\n self.store_individual_modes = value\n self.Modified()\n\n @smproperty.intvector(name=\"NormalizeEachMode\", default_values=False)\n def SetNormalizeEachMode(self, value):\n self.normalize_each_mode = value\n self.Modified()\n\n @smproperty.dataarrayselection(name=\"Polarizations\")\n def GetPolarizations(self):\n return self.polarizations_selection\n\n # Not needed when using SwshGrid input\n @smproperty.doublevector(name=\"Size\", default_values=100)\n def SetSize(self, value):\n self.size = value\n self.Modified()\n\n # Not needed when using SwshGrid input\n @smproperty.intvector(name=\"SpatialResolution\", default_values=100)\n def SetSpatialResolution(self, value):\n self.num_points_per_dim = value\n self.Modified()\n\n @smproperty.intvector(name=\"KeepEveryNthTimestep\", default_values=1)\n def SetKeepEveryNthTimestep(self, value):\n self.keep_every_n_timestep = value\n self.Modified()\n\n # Not needed when using SwshGrid input\n @smproperty.intvector(name=\"EllMax\", default_values=2)\n def SetEllMax(self, value):\n self.ell_max = value\n self.Modified()\n\n @smproperty.doublevector(name=\"RadialScale\", default_values=10)\n def SetRadialScale(self, value):\n self.radial_scale = value\n self.Modified()\n\n @smproperty.intvector(name=\"ClipYNormal\", default_values=False)\n @smdomain.xml('')\n def SetClipYNormal(self, value):\n self.clip_y_normal = value\n self.Modified()\n\n @smproperty.intvector(name=\"ClipZNormal\", default_values=False)\n @smdomain.xml('')\n def SetClipZNormal(self, value):\n self.clip_z_normal = value\n self.Modified()\n\n @smproperty.intvector(name=\"OneOverRScaling\", default_values=False)\n @smdomain.xml('')\n def SetOneOverRScaling(self, value):\n self.add_one_over_r_scaling = value\n self.Modified()\n\n @smproperty.intvector(name=\"InvertRotationDirection\", default_values=False)\n @smdomain.xml('')\n def SetInvertRotationDirection(self, value):\n self.invert_rotation_direction = value\n self.Modified()\n\n @smproperty.doublevector(name=\"ActivationOffset\", default_values=10)\n def SetActivationOffset(self, value):\n self.activation_offset = value\n self.Modified()\n\n @smproperty.doublevector(name=\"ActivationWidth\", default_values=10)\n def SetActivationWidth(self, value):\n self.activation_width = value\n self.Modified()\n\n @smproperty.doublevector(name=\"DeactivationWidth\", default_values=10)\n def SetDeactivationWidth(self, value):\n self.deactivation_width = value\n self.Modified()\n\n @smproperty.stringvector(name=\"SwshCacheDirectory\", default_values=\"\")\n def SetSwshCacheDirectory(self, value):\n self.swsh_cache_dir = value\n self.Modified()\n\n def _get_timesteps(self):\n logger.debug(\"Getting time range from data...\")\n waveform_data = self._get_waveform_data()\n ts = waveform_data.RowData['Time']\n # Using a few timesteps within the data range so we can animate through\n # them in the GUI\n return np.linspace(ts[0], ts[-1], 100)\n\n @smproperty.doublevector(name=\"TimestepValues\",\n information_only=\"1\",\n si_class=\"vtkSITimeStepsProperty\")\n def GetTimestepValues(self):\n return self._get_timesteps().tolist()\n\n def RequestInformation(self, request, inInfo, outInfo):\n logger.debug(\"Requesting information...\")\n waveform_data_info = inInfo[0].GetInformationObject(0)\n # Careful with printing these information objects, their stream operator\n # may randomly crash...\n # logger.debug(\"Waveform data info: {}\".format(waveform_data_info))\n # grid_info = inInfo[1].GetInformationObject(0)\n info = outInfo.GetInformationObject(0)\n\n # For the `vtkUniformGrid` output we need to provide extents\n # so that it gets rendered at all.\n # When using the SwshGrid input we can retrieve them from the\n # information object and pass them on.\n # grid_extents = grid_info.Get(self.GetExecutive().WHOLE_EXTENT())\n N = self.num_points_per_dim\n N_y = N // 2 if self.clip_y_normal else N\n N_z = N // 2 if self.clip_z_normal else N\n grid_extents = [0, N - 1, 0, N_y - 1, 0, N_z - 1]\n util.SetOutputWholeExtent(self, grid_extents)\n\n # This needs the time data from the waveform file, so we may have to\n # set the `TIME_RANGE` and `TIME_STEPS` already in the\n # WaveformDataReader.\n timesteps_util.set_timesteps(self,\n self._get_timesteps(),\n logger=logger)\n\n # logger.debug(\"Information object: {}\".format(info))\n return 1\n\n def RequestData(self, request, inInfo, outInfo):\n logger.debug(\"Requesting data...\")\n waveform_data = self._get_waveform_data()\n # grid_data = self._get_grid_data()\n output = dsa.WrapDataObject(vtkUniformGrid.GetData(outInfo))\n\n t = timesteps_util.get_timestep(self, logger=logger)\n N = self.num_points_per_dim\n D = self.size\n\n # We may have to forward the grid data here when using SwshGrid input\n # output.SetDimensions(*grid_data.GetDimensions())\n # output.SetOrigin(*grid_data.GetOrigin())\n # output.SetSpacing(*grid_data.GetSpacing())\n dx = 2. * D / N\n N_y = N // 2 if self.clip_y_normal else N\n N_z = N // 2 if self.clip_z_normal else N\n output.SetDimensions(N, N_y, N_z)\n output.SetOrigin(-D, -D, -D)\n output.SetSpacing(dx, dx, dx)\n\n # Compute the SWSHs on the grid\n # This section can be deleted when using SwshGrid input\n spin_weight = -2\n ell_max = self.ell_max\n \n # We skip this section of the code if non-simulation data is handled\n # since it becomes simply unnecessary.\n if type(waveform_data.RowData['Y_l2_m2'][5]) is not dsa.VTKNoneArray:\n swsh_grid, r = cached_swsh_grid(\n size=D,\n num_points=N,\n spin_weight=spin_weight,\n ell_max=ell_max,\n radial_scale=self.radial_scale,\n clip_y_normal=self.clip_y_normal,\n clip_z_normal=self.clip_z_normal,\n activation_offset=self.activation_offset,\n activation_width=self.activation_width,\n deactivation_width=self.deactivation_width,\n add_one_over_r_scaling=self.add_one_over_r_scaling,\n cache_dir=self.swsh_cache_dir)\n\n logger.info(\"Computing volume data at t={}...\".format(t))\n start_time = time.time()\n \n # We skip this section of the code if non-simulation data is handled\n # since it becomes simply unnecessary.\n if type(waveform_data.RowData['Y_l2_m2'][5]) is not dsa.VTKNoneArray:\n\n # Compute scaled waveform phase on the grid\n # r = vtknp.vtk_to_numpy(grid_data.GetPointData()['RadialCoordinate'])\n phase = t - r\n\n # Invert rotation direction\n rotation_direction = -1. if self.invert_rotation_direction else 1.\n\n # Compute strain in the volume from the input waveform data\n skip_timesteps = self.keep_every_n_timestep\n waveform_timesteps = waveform_data.RowData['Time'][::skip_timesteps]\n strain = np.zeros(len(r), dtype=np.complex)\n # Optimization for when the waveform is sampled uniformly\n # TODO: Cache this\n \n # Here the code checks if non-simulation data was passed and visualizes the\n # analytical data loaded erlier\n\n if type(waveform_data.RowData['Y_l2_m2'][5]) is dsa.VTKNoneArray:\n strain = np.zeros(1000000, dtype=np.complex)\n # generate the index of the current timestep...\n indexx = list(map(abs, list(waveform_data.RowData['Time'] - t + 1000))).index(\n np.min(list(map(abs, list(waveform_data.RowData['Time'] - t + 1000)))))\n # ...and pass the associated column of the strains grid to teh starin value\n # which is then visualized at the bottom\n strain += 100*strains[indexx]\n \n else:\n\n\n dt = np.diff(waveform_timesteps)\n waveform_uniformly_sampled = np.allclose(dt, dt[0])\n global has_shown_warning_nonuniformly_sampled\n if waveform_uniformly_sampled:\n dt = dt[0]\n logger.debug(\"Waveform sampled uniformly with dt={:.2e}, using optimized interpolation:\".format(dt))\n waveform_start_time = waveform_timesteps[0]\n waveform_start_index = min(len(waveform_timesteps) - 2, max(\n 0, int(np.floor((np.min(phase) - waveform_start_time) / dt))))\n waveform_stop_index = max(waveform_start_index + 1, min(\n len(waveform_timesteps),\n int(np.ceil((np.max(phase) - waveform_start_time) / dt))))\n if waveform_stop_index == len(waveform_timesteps):\n waveform_stop_index = -1\n logger.debug(\n \"Restricting interpolation to waveform indices {}, that's between waveform times {}. We will interpolate to times between {} (should be contained in restricted waveform range except for boundary effects).\"\n .format((waveform_start_index, waveform_stop_index),\n (waveform_timesteps[waveform_start_index],\n waveform_timesteps[waveform_stop_index]),\n (np.min(phase), np.max(phase))))\n waveform_timesteps = waveform_timesteps[waveform_start_index:waveform_stop_index]\n elif not has_shown_warning_nonuniformly_sampled:\n logger.warning(\"Waveform is not sampled uniformly so interpolation is slightly more expensive.\")\n has_shown_warning_nonuniformly_sampled = True\n # for i in range(self.modes_selection.GetNumberOfArrays()):\n # mode_name = self.modes_selection.GetArrayName(i)\n for l in range(abs(spin_weight), ell_max + 1):\n for abs_m in range(0, l + 1):\n mode_name = get_mode_name(l, abs_m)\n strain_mode = np.zeros(len(r), dtype=np.complex)\n if not self.modes_selection.ArrayIsEnabled(mode_name):\n continue\n for sign_m in (-1, 1):\n m = abs_m * sign_m\n dataset_name = \"Y_l{}_m{}\".format(l, m)\n mode_profile = swsh_grid[:, LM_index(l, m, 0)]\n # mode_profile = vtknp.vtk_to_numpy(grid_data.GetPointData()[dataset_name])\n waveform_mode_data = waveform_data.RowData[dataset_name][::skip_timesteps]\n if isinstance(waveform_mode_data, dsa.VTKNoneArray):\n logger.warning(\n \"Dataset '{}' for mode {} not available in waveform data, skipping.\"\n .format(dataset_name, (l, m)))\n continue\n # TODO: Make sure inverting the rotation direction like this\n # is correct.\n waveform_mode_data = waveform_mode_data[:, 0] + rotation_direction * 1j * waveform_mode_data[:, 1]\n if self.normalize_each_mode:\n waveform_mode_data /= np.max(np.abs(waveform_mode_data))\n if waveform_uniformly_sampled:\n waveform_mode_data = waveform_mode_data[waveform_start_index:waveform_stop_index]\n mode_data = np.interp(phase,\n waveform_timesteps,\n waveform_mode_data,\n left=0.,\n right=0.)\n strain_mode += mode_data * mode_profile\n strain += strain_mode\n # Expose individual modes in output\n if self.store_individual_modes:\n if self.polarizations_selection.ArrayIsEnabled(\"Plus\"):\n strain_mode_real_vtk = vtknp.numpy_to_vtk(\n np.real(strain_mode), deep=True)\n strain_mode_real_vtk.SetName(mode_name + ' Plus')\n output.GetPointData().AddArray(strain_mode_real_vtk)\n if self.polarizations_selection.ArrayIsEnabled(\"Cross\"):\n strain_mode_imag_vtk = vtknp.numpy_to_vtk(\n np.imag(strain_mode), deep=True)\n strain_mode_imag_vtk.SetName(mode_name + ' Cross')\n output.GetPointData().AddArray(strain_mode_imag_vtk)\n if self.polarizations_selection.ArrayIsEnabled(\"Plus\"):\n strain_real_vtk = vtknp.numpy_to_vtk(np.real(strain), deep=True)\n strain_real_vtk.SetName('Plus strain')\n output.GetPointData().AddArray(strain_real_vtk)\n if self.polarizations_selection.ArrayIsEnabled(\"Cross\"):\n strain_imag_vtk = vtknp.numpy_to_vtk(np.imag(strain), deep=True)\n strain_imag_vtk.SetName('Cross strain')\n output.GetPointData().AddArray(strain_imag_vtk)\n\n logger.info(\"Volume data computed in {:.3f}s.\".format(time.time() -\n start_time))\n return 1\n \n", "meta": {"hexsha": "91c499e78b818def32e0d6a54bb6c3483bed7449", "size": 20906, "ext": "py", "lang": "Python", "max_stars_repo_path": "paraview_plugins/WaveformToVolume.py", "max_stars_repo_name": "damibabayemi/gwpv", "max_stars_repo_head_hexsha": "e6705787fc2e25b72eaef2508357b1f0b9258581", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "paraview_plugins/WaveformToVolume.py", "max_issues_repo_name": "damibabayemi/gwpv", "max_issues_repo_head_hexsha": "e6705787fc2e25b72eaef2508357b1f0b9258581", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "paraview_plugins/WaveformToVolume.py", "max_forks_repo_name": "damibabayemi/gwpv", "max_forks_repo_head_hexsha": "e6705787fc2e25b72eaef2508357b1f0b9258581", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-10-30T19:37:13.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-30T19:37:13.000Z", "avg_line_length": 45.0560344828, "max_line_length": 225, "alphanum_fraction": 0.631732517, "include": true, "reason": "import numpy", "num_tokens": 4631, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583269943353744, "lm_q2_score": 0.3415824927356586, "lm_q1q2_score": 0.1907147264866851}} {"text": "# all lifetimes in years\n\nimport numpy as np\n\nCO2 = np.nan # dummy - to preserve indexing order\nCH4 = 9.3 # for constant lifetime runs\nN2O = 121.\nCF4 = 50000.\nC2F6 = 10000.\nC3F8 = 2600. \nC4F10 = 2600.\nC5F12 = 4100.\nC6F14 = 3100.\nC7F16 = 3000.\nC8F18 = 3000.\nC_C4F8 = 3200.\nHFC23 = 222.\nHFC32 = 5.2\nHFC43_10 = 16.1\nHFC43_10MEE = HFC43_10\nHFC125 = 28.2\nHFC134A = 13.4\nHFC143A = 47.1\nHFC152A = 1.5\nHFC227EA = 38.9\nHFC236FA = 242.\nHFC245FA = 7.7\nHFC365MFC = 8.7\nSF6 = 3200.\nNF3 = 500.\nSO2F2 = 36.\nCFC11 = 45.\nCFC12 = 100.\nCFC113 = 85.\nCFC114 = 190.\nCFC115 = 1020.\nCARB_TET = 26.\nCCL4 = CARB_TET\nMCF = 5.\nCH3CCL3 = MCF\nHCFC22 = 11.9\nHCFC141B = 9.2\nHCFC142B = 17.2\nHALON1211 = 16.\nHALON1202 = 2.9\nHALON1301 = 65.\nHALON2402 = 20.\nCH3BR = 0.8\nCH3CL = 1.\nCH2CL2 = 0.3945 # from Hodnebrog et al., 2013\nCHCL3 = 0.4082 # from Hodnebrog et al., 2013\n\n# This is the list of gases included in the RCPs/AR5/CMIP5.\naslist = [CO2, CH4, N2O, CF4, C2F6, C6F14, HFC23, HFC32, HFC43_10, HFC125,\n HFC134A, HFC143A, HFC227EA, HFC245FA, SF6, CFC11, CFC12, CFC113,\n CFC114, CFC115, CARB_TET, MCF, HCFC22, HCFC141B, HCFC142B,\n HALON1211, HALON1202, HALON1301, HALON2402, CH3BR, CH3CL]\n", "meta": {"hexsha": "86f0c1c572942a092023270beb99cef1a587a2aa", "size": 1433, "ext": "py", "lang": "Python", "max_stars_repo_path": "fair/constants/lifetime.py", "max_stars_repo_name": "markperri/FAIR", "max_stars_repo_head_hexsha": "4aa7c6137a07585b7d56044a3e4506ca9c7de03c", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 66, "max_stars_repo_stars_event_min_datetime": "2017-06-20T10:30:11.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-03T19:11:06.000Z", "max_issues_repo_path": "fair/constants/lifetime.py", "max_issues_repo_name": "juliaeis/FAIR", "max_issues_repo_head_hexsha": "997fb82f954a41196808ec74113207de38d4b295", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 99, "max_issues_repo_issues_event_min_datetime": "2017-03-29T01:59:56.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-23T08:45:23.000Z", "max_forks_repo_path": "fair/constants/lifetime.py", "max_forks_repo_name": "juliaeis/FAIR", "max_forks_repo_head_hexsha": "997fb82f954a41196808ec74113207de38d4b295", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 33, "max_forks_repo_forks_event_min_datetime": "2017-03-30T04:02:51.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-02T17:13:43.000Z", "avg_line_length": 24.7068965517, "max_line_length": 76, "alphanum_fraction": 0.5540823447, "include": true, "reason": "import numpy", "num_tokens": 670, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5583269796369904, "lm_q2_score": 0.341582499438317, "lm_q1q2_score": 0.1907147252082495}} {"text": "# This script computes the relative hydration free energy with a single topology protocol.\n# It checks to make sure the estimated dG is in agreement between the following three methods:\n# 1) Two seperate absolute free energy calculations\n# 2) Relative free energy with full atom-mapping\n# 3) Relative free energy with partial atom-mapping (4D-decoupling)\n\nimport os\nimport argparse\nimport numpy as np\n\nfrom rdkit import Chem\nfrom rdkit.Chem import rdFMCS\nfrom rdkit.Chem import AllChem\n\nfrom fe import topology\nfrom md import builders\nfrom md import minimizer\n\nimport functools\n\nfrom ff import Forcefield\nfrom ff.handlers.deserialize import deserialize_handlers\n\nimport multiprocessing\n\nfrom fe import free_energy\n\n\ndef wrap_method(args, fn):\n gpu_idx = args[0]\n os.environ['CUDA_VISIBLE_DEVICES'] = str(gpu_idx)\n return fn(*args[1:])\n\nif __name__ == \"__main__\":\n\n parser = argparse.ArgumentParser(\n description=\"Relative Hydration Free Energy Consistency Testing\",\n formatter_class=argparse.ArgumentDefaultsHelpFormatter,\n )\n\n parser.add_argument(\n \"--num_gpus\",\n type=int,\n help=\"number of gpus\",\n required=True\n )\n\n parser.add_argument(\n \"--num_vacuum_windows\",\n type=int,\n help=\"number of vacuum lambda windows\",\n required=True\n )\n\n parser.add_argument(\n \"--num_solvent_windows\",\n type=int,\n help=\"number of solvent lambda windows\",\n required=True\n )\n\n parser.add_argument(\n \"--num_equil_steps\",\n type=int,\n help=\"number of equilibration steps for each lambda window\",\n required=True\n )\n\n parser.add_argument(\n \"--num_prod_steps\",\n type=int,\n help=\"number of production steps for each lambda window\",\n required=True\n )\n\n parser.add_argument(\n \"--num_absolute_windows\",\n type=int,\n help=\"number of absolute lambda windows\",\n required=True\n )\n\n cmd_args = parser.parse_args()\n\n multiprocessing.set_start_method('spawn') # CUDA runtime is not forkable\n pool = multiprocessing.Pool(cmd_args.num_gpus)\n\n suppl = Chem.SDMolSupplier('tests/data/benzene_fluorinated.sdf', removeHs=False)\n all_mols = [x for x in suppl]\n mol_a = all_mols[0]\n mol_b = all_mols[1]\n\n ff_handlers = deserialize_handlers(open('ff/params/smirnoff_1_1_0_ccc.py').read())\n ff = Forcefield(ff_handlers)\n\n # the water system first.\n solvent_system, solvent_coords, solvent_box, omm_topology = builders.build_water_system(4.0)\n solvent_box += np.eye(3)*0.1 # BFGS this later\n\n print(\"Minimizing the host structure to remove clashes.\")\n minimized_solvent_coords = minimizer.minimize_host_4d([mol_a], solvent_system, solvent_coords, ff, solvent_box)\n\n absolute_lambda_schedule = np.concatenate([\n np.linspace(0.0, 0.333, cmd_args.num_absolute_windows - cmd_args.num_absolute_windows//3, endpoint=False),\n np.linspace(0.333, 1.0, cmd_args.num_absolute_windows//3),\n ])\n\n abs_dGs = []\n\n for idx, mol in enumerate([mol_a, mol_b]):\n\n afe = free_energy.AbsoluteFreeEnergy(mol, ff)\n absolute_args = []\n\n for lambda_idx, lamb in enumerate(absolute_lambda_schedule):\n gpu_idx = lambda_idx % cmd_args.num_gpus\n absolute_args.append((gpu_idx, lamb, solvent_system, minimized_solvent_coords, solvent_box, cmd_args.num_equil_steps, cmd_args.num_prod_steps))\n\n results = pool.map(functools.partial(wrap_method, fn=afe.host_edge), absolute_args, chunksize=1)\n\n for lamb, (bonded_du_dl, nonbonded_du_dl) in zip(absolute_lambda_schedule, results):\n print(\"final absolute\", idx, \"lambda\", lamb, \"bonded:\", bonded_du_dl[0], bonded_du_dl[1], \"nonbonded:\", nonbonded_du_dl[0], nonbonded_du_dl[1])\n\n dG = np.trapz([x[0][0]+x[1][0] for x in results], absolute_lambda_schedule)\n print(\"mol\", idx, \"dG absolute:\", dG)\n abs_dGs.append(dG)\n\n print(\"Absolute Difference\", abs_dGs[0] - abs_dGs[1])\n\n # relative free energy, compare two different core approaches\n\n core_full = np.stack([\n np.arange(mol_a.GetNumAtoms()),\n np.arange(mol_b.GetNumAtoms())\n ], axis=1)\n\n core_part = np.stack([\n np.arange(mol_a.GetNumAtoms() - 1),\n np.arange(mol_b.GetNumAtoms() - 1)\n ], axis=1)\n\n for core_idx, core in enumerate([core_full, core_part]):\n single_topology = topology.SingleTopology(mol_a, mol_b, core, ff)\n\n rfe = free_energy.RelativeFreeEnergy(single_topology)\n\n vacuum_lambda_schedule = np.linspace(0.0, 1.0, cmd_args.num_vacuum_windows)\n solvent_lambda_schedule = np.linspace(0.0, 1.0, cmd_args.num_solvent_windows)\n\n # vacuum leg\n vacuum_args = []\n for lambda_idx, lamb in enumerate(vacuum_lambda_schedule):\n gpu_idx = lambda_idx % cmd_args.num_gpus\n vacuum_args.append((gpu_idx, lamb, cmd_args.num_equil_steps, cmd_args.num_prod_steps))\n\n results = pool.map(functools.partial(wrap_method, fn=rfe.vacuum_edge), vacuum_args, chunksize=1)\n\n # TODO: update this to reflect new return type of rfe.vacuum_edge\n for lamb, (bonded_du_dl, nonbonded_du_dl) in zip(vacuum_lambda_schedule, results):\n print(\"final vacuum lambda\", lamb, \"bonded:\", bonded_du_dl[0], bonded_du_dl[1], \"nonbonded:\", nonbonded_du_dl[0], nonbonded_du_dl[1])\n\n dG_vacuum = np.trapz([x[0][0]+x[1][0] for x in results], vacuum_lambda_schedule)\n print(\"dG vacuum:\", dG_vacuum)\n\n # solvent leg\n solvent_args = []\n for lambda_idx, lamb in enumerate(solvent_lambda_schedule):\n gpu_idx = lambda_idx % cmd_args.num_gpus\n solvent_args.append((gpu_idx, lamb, solvent_system, minimized_solvent_coords, solvent_box, cmd_args.num_equil_steps, cmd_args.num_prod_steps))\n \n results = pool.map(functools.partial(wrap_method, fn=rfe.host_edge), solvent_args, chunksize=1)\n # TODO: update this to reflect new return type of rfe.vacuum_edge\n\n for lamb, (bonded_du_dl, nonbonded_du_dl) in zip(solvent_lambda_schedule, results):\n print(\"final solvent lambda\", lamb, \"bonded:\", bonded_du_dl[0], bonded_du_dl[1], \"nonbonded:\", nonbonded_du_dl[0], nonbonded_du_dl[1])\n\n dG_solvent = np.trapz([x[0][0]+x[1][0] for x in results], solvent_lambda_schedule)\n print(\"dG solvent:\", dG_solvent)\n\n print(\"Core map\", core_idx, \"Difference\", dG_solvent - dG_vacuum)\n\n", "meta": {"hexsha": "ca46f5061e5c48a87ac168e5a70d90b5d47eb596", "size": 6491, "ext": "py", "lang": "Python", "max_stars_repo_path": "examples/rhfe_single.py", "max_stars_repo_name": "fehomi/timemachine", "max_stars_repo_head_hexsha": "594b10c03a6688c008eb4d35e612dbd98f5eede4", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "examples/rhfe_single.py", "max_issues_repo_name": "fehomi/timemachine", "max_issues_repo_head_hexsha": "594b10c03a6688c008eb4d35e612dbd98f5eede4", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "examples/rhfe_single.py", "max_forks_repo_name": "fehomi/timemachine", "max_forks_repo_head_hexsha": "594b10c03a6688c008eb4d35e612dbd98f5eede4", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.6648351648, "max_line_length": 155, "alphanum_fraction": 0.6871052226, "include": true, "reason": "import numpy", "num_tokens": 1660, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5698526660244838, "lm_q2_score": 0.33458943461801643, "lm_q1q2_score": 0.1906666813407014}} {"text": "#!/usr/bin/env python\r\n#-*- coding:utf-8 -*-\r\n\"\"\"\r\n Author: Benjamin Rumeau (intern at CLS in 2014 under supervision\r\n of Philippe Gaspard and Anne-Cecile Dragon.\r\n Module description: Library containing all the geographical classes and fun-\r\n ctions.\r\n\"\"\"\r\nimport numpy as np\r\n\r\n\r\n# ||==========================================\r\n# || || \r\n# || Objets géographiques ||\r\n# || et biologiques ||\r\n# || ||\r\n# ==========================================||\r\n\r\n\r\nclass NestingPeriod :\r\n \"\"\"\r\n class nesting_period used as a structure\r\n contains the begin, end and peak of the nesting season\r\n \"\"\"\r\n def __init__(self,first=0.,last=0.,peak=0.,incubation_time=60):\r\n self.begin = np.float32(first)\r\n self.end = np.float32(last)\r\n self.peak = np.float32(peak)\r\n self.incubation_time=incubation_time\r\n\r\n def incubation(self):\r\n \"\"\" \r\n Corrects nesting period to take into account incubation time.\r\n Incubation time must be expressed in days.\r\n \"\"\"\r\n print(\"\\n=> correcting nesting periods with incubation times\")\r\n self.begin+=self.incubation_time\r\n self.end+=self.incubation_time\r\n self.peak+=self.incubation_time\r\n \r\n\r\nclass Beach :\r\n \"\"\"\r\n class beach is used as a structure\r\n contains all information needed about the nesting beach\r\n => launching area\r\n => nesting season\r\n => geographic coordinates of the beach\r\n => name of the beach\r\n => eventually the reference of those information\r\n \"\"\"\r\n def __init__(self,\r\n nesting_period=NestingPeriod(),\r\n north_pt=[1,1],\r\n south_pt=[0,0],\r\n orientation=\"east\",\r\n d_min=30,\r\n d_max=50,\r\n ref=\"no reference\",\r\n beach_name=\"no name\",\r\n file_name=\"no name\"):\r\n self.nesting_period=nesting_period\r\n self.north_pt=north_pt\r\n self.south_pt=south_pt\r\n if orientation==\"east\":\r\n self.orientation=1\r\n elif orientation==\"west\":\r\n self.orientation=-1\r\n else:\r\n print(\"Error: orientation must be east or west\")\r\n self.d_min=d_min\r\n self.d_max=d_max\r\n self.ref=str(ref)\r\n self.beach_name=str(beach_name)\r\n self.nesting_period.incubation()\r\n\r\n\r\nclass Geolocation:\r\n \"\"\" \r\n class position_4D contains the a 4 uplet x,y,z,t giving the time ans space\r\n localisation of a particle, as well as an information about the coordinate\r\n system.\r\n \"\"\"\r\n def __init__(self,x=0.,y=0.,t=0.,z=-1.0,coord_sys=\"geo\"):\r\n self.x=np.float32(x)\r\n self.y=np.float32(y)\r\n self.z=np.float32(z)\r\n self.t=np.float32(t)\r\n self.coord_sys=coord_sys\r\n \r\n def geo_to_grid(self,lon_mat,lat_mat):\r\n \"\"\"\r\n converts (lon,lat) geographical coordinate to grid coordinates (conti-\r\n nuous conversion as coordinates of the closest neighbour are computed\r\n in Ariane.\r\n - lon,lat are the geographical coordinate of the point.\r\n - lon_mat, lat are matrices containing the longitudes (resp. latitudes) of the centers of the cells of the Arakawa C grid.\r\n NB : this function is only appropriate for regular, square grids.\r\n \"\"\"\r\n if self.coord_sys==\"grid\":\r\n print(\"\\n Warning: already in grid coordinates\")\r\n else:\r\n # Read extreme coordinates\r\n lon_max=np.max(lon_mat)\r\n lon_min=np.min(lon_mat)\r\n lat_max=np.max(lat_mat)\r\n lat_min=np.min(lat_mat)\r\n # Converts to grid coordinate\r\n if ((self.x> lon_max) or (self.x< lon_min) or (self.y>lat_max) or (self.y lon_max) or (lon< lon_min) or (lat>lat_max) or (lat should be a {Time} object.'\n )\n if time.isscalar:\n time = Time([time.isot, time.isot])\n\n self._localSiderealTime(time)\n self._positionAtEquinox(time)\n self._computeHourAngle()\n self._computeHorizontalCoords()\n\n\n # --------------------------------------------------------- #\n # ----------------------- Internal ------------------------ #\n def _localSiderealTime(self, time):\n \"\"\"\n \"\"\"\n # Number of days since 2000 January 1, 12h UT\n nDays = time.jd - 2451545.\n # Greenwich mean sidereal time\n gmst = 18.697374558 + 24.06570982441908 * nDays\n gmst %= 24.\n # Local Sidereal Time\n lst = gmst + NENUFAR_LOC.lon.hour\n if np.isscalar(lst):\n if lst < 0:\n lst += 24\n else:\n lst[lst < 0] += 24. \n self._lst = Angle(lst, 'hour')\n\n\n def _positionAtEquinox(self, time):\n \"\"\"\n \"\"\"\n fk5 = self.target.transform_to(\n FK5(equinox=time)\n )\n self._fk5 = fk5\n\n\n def _computeHourAngle(self):\n \"\"\"\n \"\"\"\n twoPi = Angle(360.000000, unit='deg')\n ha = self._lst - self._fk5.ra\n if ha.isscalar:\n if ha.deg < 0:\n ha += twoPi\n elif ha.deg > 360:\n ha -= twoPi\n else:\n ha[ha.deg < 0] += twoPi\n ha[ha.deg > 360] -= twoPi\n self._hourAngle = ha\n\n\n def _computeHorizontalCoords(self):\n \"\"\"\n \"\"\"\n twoPi = Angle(360.000000, unit='deg')\n\n decRad = self._fk5.dec.rad\n sinDec = np.sin(decRad)\n haRad = self._hourAngle.rad\n latRad = NENUFAR_LOC.lat.rad\n sinLat = np.sin(latRad)\n cosLat = np.cos(latRad)\n sinEl = sinDec * sinLat +\\\n np.cos(decRad) * cosLat * np.cos(haRad)\n self._elevation = Angle(\n np.arcsin(sinEl),\n unit='rad'\n ).to('deg')\n\n elRad = self._elevation.rad\n cosAz = (sinDec - np.sin(elRad) * sinLat)/\\\n (np.cos(elRad) * cosLat)\n azRad = Angle(np.arccos(cosAz), unit='rad')\n\n if azRad.isscalar:\n if np.sin(self._hourAngle.rad) > 0:\n azRad *= -1\n azRad += twoPi\n else:\n posMask = np.sin(self._hourAngle.rad) > 0\n azRad[posMask] *= -1\n azRad[posMask] += twoPi\n\n self._azimuth = azRad.to('deg')\n\n\n # --------------------------------------------------------- #\n # ----------------------- Internal ------------------------ #\n @staticmethod\n def _attrWarning(self, attr):\n \"\"\"\n \"\"\"\n log.warning(\n 'Target position must be computed using '\n '<.computePosition(time)> method, prior to asking'\n f' for the <{attr}> attribute.'\n )\n# ============================================================= #\n# ============================================================= #\n\n\n# ============================================================= #\n# ------------------------- SSTarget -------------------------- #\n# ============================================================= #\nclass SSTarget(_Target):\n \"\"\" Solar System target\n \"\"\"\n\n def __init__(self, target):\n super().__init__(target=target)\n\n\n # --------------------------------------------------------- #\n # --------------------- Getter/Setter --------------------- #\n @property\n def isCircumpolar(self):\n \"\"\"\n \"\"\"\n ninetyDeg = Angle(90, 'deg')\n decAndLat = self._fk5.dec + NENUFAR_LOC.lat\n return any(decAndLat > ninetyDeg) # not sure about that\n\n\n # --------------------------------------------------------- #\n # ------------------------ Methods ------------------------ #\n @classmethod\n def fromName(cls, sourceName):\n \"\"\"\n \"\"\"\n if not isinstance(sourceName, str):\n raise TypeError(\n f\" '{sourceName}' must be a {str}.\"\n )\n sourceName = sourceName.lower()\n if sourceName not in SS_SOURCES:\n raise ValueError(\n f\"Solar System target '{sourceName}'' not in \"\n f\"{SS_SOURCES}.\"\n )\n\n log.debug(\n f\"Solar System target '{sourceName}' loaded.\"\n )\n return cls(\n target=sourceName\n )\n\n\n # --------------------------------------------------------- #\n # ----------------------- Internal ------------------------ #\n def _positionAtEquinox(self, time):\n \"\"\" Over define this _Target method\n \"\"\"\n with solar_system_ephemeris.set('builtin'):\n source = get_body(\n self.target,\n time,\n NENUFAR_LOC\n ) # GCRS\n ssSource = SkyCoord(source.ra, source.dec)\n\n fk5 = ssSource.transform_to(\n FK5(equinox=time)\n )\n self._fk5 = fk5\n# ============================================================= #\n# ============================================================= #\n\n\n# ============================================================= #\n# ------------------------- ESTarget -------------------------- #\n# ============================================================= #\nclass ESTarget(_Target):\n \"\"\" ExtraSolar System target\n \"\"\"\n\n def __init__(self, target):\n super().__init__(target=target)\n\n\n # --------------------------------------------------------- #\n # --------------------- Getter/Setter --------------------- #\n @property\n def isCircumpolar(self):\n \"\"\"\n \"\"\"\n return self.target.dec + NENUFAR_LOC.lat > Angle(90, 'deg')\n\n\n # --------------------------------------------------------- #\n # ------------------------ Methods ------------------------ #\n @classmethod\n def fromName(cls, sourceName):\n \"\"\"\n \"\"\"\n if not isinstance(sourceName, str):\n raise TypeError(\n f\" '{sourceName}'' must be a {str}.\"\n )\n esSource = SkyCoord.from_name(sourceName)\n log.debug(\n f\"ExtraSolar target '{sourceName}' loaded.\"\n )\n return cls(\n target=esSource\n )\n\n\n @classmethod\n def fromCoordinates(cls, coordinates):\n \"\"\"\n \"\"\"\n if isinstance(coordinates, str):\n esSource = SkyCoord(coordinates, unit=(u.hourangle, u.deg))\n else:\n esSource = SkyCoord(*coordinates, unit=u.deg)\n return cls(\n target=esSource\n )\n# ============================================================= #\n# ============================================================= #\n\n", "meta": {"hexsha": "4f68cef903df92a025d0c88acdd844954418bfbe", "size": 9406, "ext": "py", "lang": "Python", "max_stars_repo_path": "nenupy/schedule/targets.py", "max_stars_repo_name": "coutouly/nenupy", "max_stars_repo_head_hexsha": "76cf9f6a6a93e9eed16f8450e3cfe385440a212e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2018-10-02T16:32:32.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-08T10:55:36.000Z", "max_issues_repo_path": "nenupy/schedule/targets.py", "max_issues_repo_name": "coutouly/nenupy", "max_issues_repo_head_hexsha": "76cf9f6a6a93e9eed16f8450e3cfe385440a212e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 54, "max_issues_repo_issues_event_min_datetime": "2018-10-16T14:48:29.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-24T11:02:59.000Z", "max_forks_repo_path": "nenupy/schedule/targets.py", "max_forks_repo_name": "coutouly/nenupy", "max_forks_repo_head_hexsha": "76cf9f6a6a93e9eed16f8450e3cfe385440a212e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-10-12T14:29:17.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-24T13:11:16.000Z", "avg_line_length": 26.6458923513, "max_line_length": 71, "alphanum_fraction": 0.3943227727, "include": true, "reason": "import numpy,import astropy,from astropy", "num_tokens": 1975, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5467381519846138, "lm_q2_score": 0.3486451217982255, "lm_q1q2_score": 0.19061758959041242}} {"text": "# - * - coding: utf-8 - * -\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport matplotlib.patches\nimport matplotlib.gridspec as gridspec\nimport scipy.signal\nimport scipy.stats\n\n\ndef ecg_fixpeaks(rpeaks, sampling_rate=1000, iterative=True, show=False):\n \"\"\"Correct R-peaks location based on their interval (RRi).\n\n Identify erroneous inter-beat-intervals. Lipponen & Tarvainen (2019).\n\n Parameters\n ----------\n rpeaks : dict\n The samples at which the R-peak occur. Dict returned by\n `ecg_findpeaks()`.\n sampling_rate : int\n The sampling frequency of the signal that contains the peaks (in Hz,\n i.e., samples/second).\n iterative : bool\n Whether or not to apply the artifact correction repeatedly (results\n in superior artifact correction).\n show : bool\n Whether or not to visualize artifacts and artifact thresholds.\n\n Returns\n -------\n artifacts : dict\n A dictionary containing the indices of artifacts, accessible with the\n keys \"ectopic\", \"missed\", \"extra\", and \"longshort\".\n\n See Also\n --------\n ecg_clean, ecg_findpeaks, ecg_peaks, ecg_rate, ecg_process, ecg_plot\n\n Examples\n --------\n >>> import neurokit2 as nk\n >>> import matplotlib.pyplot as plt\n\n >>> ecg = nk.ecg_simulate(duration=240, noise=0.1, heart_rate=70,\n >>> random_state=41)\n >>> rpeaks_uncorrected = nk.ecg_findpeaks(ecg)\n >>> artifacts, rpeaks_corrected = nk.ecg_fixpeaks(rpeaks_uncorrected,\n >>> iterative=True,\n >>> show=True)\n >>> rate_corrected = nk.ecg_rate(rpeaks_uncorrected,\n >>> desired_length=len(ecg))\n >>> rate_uncorrected = nk.ecg_rate(rpeaks, desired_length=len(ecg_signal))\n >>>\n >>> fig, ax = plt.subplots()\n >>> ax.plot(rate_uncorrected, label=\"heart rate without artifact correction\")\n >>> ax.plot(rate_corrected, label=\"heart rate with artifact correction\")\n >>> ax.legend(loc=\"upper right\")\n\n References\n ----------\n - Lipponen, J. A., & Tarvainen, M. P. (2019). A robust algorithm for heart\n rate variability time series artefact correction using novel beat\n classification. Journal of medical engineering & technology, 43(3),\n 173-181. 10.1080/03091902.2019.1640306\n\n \"\"\"\n # Format input.\n rpeaks = rpeaks[\"ECG_R_Peaks\"]\n artifacts, subspaces = _find_artifacts_lipponen2019(rpeaks, sampling_rate)\n rpeaks_corrected = _fix_artifacts_lipponen2019(rpeaks, artifacts,\n sampling_rate)\n\n if iterative:\n # Iteratively apply the artifact correction until the number of\n # artifact reaches an equilibrium (i.e., the number of artifacts\n # does not change anymore from one iteration to the next)\n n_artifacts_previous = np.inf\n n_artifacts_current = sum([len(i) for i in artifacts.values()])\n\n previous_diff = 0\n\n while n_artifacts_current - n_artifacts_previous != previous_diff:\n\n previous_diff = n_artifacts_previous - n_artifacts_current\n\n artifacts, subspaces = _find_artifacts_lipponen2019(rpeaks_corrected,\n sampling_rate)\n rpeaks_corrected = _fix_artifacts_lipponen2019(rpeaks_corrected,\n artifacts,\n sampling_rate)\n\n n_artifacts_previous = n_artifacts_current\n n_artifacts_current = sum([len(i) for i in artifacts.values()])\n\n if show:\n _plot_artifacts_lipponen2019(artifacts, subspaces)\n\n return artifacts, {\"ECG_R_Peaks\": rpeaks_corrected}\n\n\n# =============================================================================\n# Lipponen & Tarvainen (2019).\n# =============================================================================\ndef _find_artifacts_lipponen2019(rpeaks, sampling_rate=1000):\n\n # Set fixed parameters.\n c1 = 0.13\n c2 = 0.17\n alpha = 5.2\n window_half = 45\n medfilt_order = 11\n\n # Compute period series (make sure it has same numer of elements as peaks);\n # peaks are in samples, convert to seconds.\n rr = np.ediff1d(rpeaks, to_begin=0) / sampling_rate\n # For subsequent analysis it is important that the first element has\n # a value in a realistic range (e.g., for median filtering).\n rr[0] = np.mean(rr[1:])\n\n # Compute differences of consecutive periods.\n drrs = np.ediff1d(rr, to_begin=0)\n drrs[0] = np.mean(drrs[1:])\n # Normalize by threshold.\n drrs, _ = _threshold_normalization(drrs, alpha, window_half)\n\n # Pad drrs with one element.\n padding = 2\n drrs_pad = np.pad(drrs, padding, \"reflect\")\n # Cast drrs to two-dimesnional subspace s1.\n s12 = np.zeros(drrs.size)\n for d in np.arange(padding, padding + drrs.size):\n\n if drrs_pad[d] > 0:\n s12[d - padding] = np.max([drrs_pad[d - 1], drrs_pad[d + 1]])\n elif drrs_pad[d] < 0:\n s12[d - padding] = np.min([drrs_pad[d - 1], drrs_pad[d + 1]])\n\n # Cast drrs to two-dimensional subspace s2 (looping over d a second\n # consecutive time is choice to be explicit rather than efficient).\n s22 = np.zeros(drrs.size)\n for d in np.arange(padding, padding + drrs.size):\n\n if drrs_pad[d] > 0:\n s22[d - padding] = np.max([drrs_pad[d + 1], drrs_pad[d + 2]])\n elif drrs_pad[d] < 0:\n s22[d - padding] = np.min([drrs_pad[d + 1], drrs_pad[d + 2]])\n\n # Compute deviation of RRs from median RRs.\n padding = medfilt_order // 2 # pad RR series before filtering\n rr_pad = np.pad(rr, padding, \"reflect\")\n medrr = scipy.signal.medfilt(rr_pad, medfilt_order)\n medrr = medrr[padding:padding + rr.size] # remove padding\n mrrs = rr - medrr\n mrrs[mrrs < 0] = mrrs[mrrs < 0] * 2\n mrrs, th2 = _threshold_normalization(mrrs, alpha, window_half) # normalize by threshold\n\n # Artifact identification\n #########################\n # Keep track of indices that need to be interpolated, removed, or added.\n extra_idcs = []\n missed_idcs = []\n ectopic_idcs = []\n longshort_idcs = []\n\n for i in range(rpeaks.size - 2):\n\n # Check for ectopic peaks.\n if np.abs(drrs[i]) <= 1:\n continue\n\n # Based on Figure 2a.\n eq1 = np.logical_and(drrs[i] > 1, s12[i] < (-c1 * drrs[i] - c2))\n eq2 = np.logical_and(drrs[i] < -1, s12[i] > (-c1 * drrs[i] + c2))\n\n if np.any([eq1, eq2]):\n # If any of the two equations is true.\n ectopic_idcs.append(i)\n continue\n\n # If none of the two equations is true.\n # Based on Figure 2b.\n if ~np.any([np.abs(drrs[i]) > 1, np.abs(mrrs[i]) > 3]):\n continue\n\n # Long beat.\n eq3 = np.logical_and(drrs[i] > 1, s22[i] < -1)\n eq4 = np.abs(mrrs[i]) > 3\n # Short beat.\n eq5 = np.logical_and(drrs[i] < -1, s22[i] > 1)\n\n if ~np.any([eq3, eq4, eq5]):\n # If none of the three equations is true: normal beat.\n continue\n\n # If any of the three equations is true: check for missing or extra\n # peaks.\n\n # Missing.\n eq6 = np.abs(rr[i] / 2 - medrr[i]) < th2[i]\n # Extra.\n eq7 = np.abs(rr[i] + rr[i + 1] - medrr[i]) < th2[i]\n\n # Check if short or extra.\n if eq5:\n if eq7:\n extra_idcs.append(i)\n else:\n longshort_idcs.append(i)\n if np.abs(drrs[i + 1]) < np.abs(drrs[i + 2]):\n longshort_idcs.append(i + 1)\n # Check if long or missing.\n if np.any([eq3, eq4]):\n if eq6:\n missed_idcs.append(i)\n else:\n longshort_idcs.append(i)\n if np.abs(drrs[i + 1]) < np.abs(drrs[i + 2]):\n longshort_idcs.append(i + 1)\n\n # Prepare output\n artifacts = {\"ectopic\": ectopic_idcs, \"missed\": missed_idcs,\n \"extra\": extra_idcs, \"longshort\": longshort_idcs}\n\n subspaces = {\"rr\": rr, \"drrs\": drrs, \"mrrs\": mrrs, \"s12\": s12, \"s22\": s22,\n \"c1\": c1, \"c2\": c2}\n\n return artifacts, subspaces\n\n\ndef _fix_artifacts_lipponen2019(rpeaks, artifacts, sampling_rate):\n\n extra_idcs = artifacts[\"extra\"]\n missed_idcs = artifacts[\"missed\"]\n ectopic_idcs = artifacts[\"ectopic\"]\n longshort_idcs = artifacts[\"longshort\"]\n\n # Delete extra peaks.\n if extra_idcs:\n rpeaks = np.delete(rpeaks, extra_idcs)\n # Update remaining indices.\n missed_idcs = _update_indices(extra_idcs, missed_idcs, -1)\n ectopic_idcs = _update_indices(extra_idcs, ectopic_idcs, -1)\n longshort_idcs = _update_indices(extra_idcs, longshort_idcs, -1)\n\n # Add missing peaks.\n if missed_idcs:\n # Calculate the position(s) of new beat(s). Make sure to not generate\n # negative indices. prev_peaks and next_peaks must have the same\n # number of elements.\n missed_idcs = np.array(missed_idcs)\n valid_idcs = np.logical_and(missed_idcs > 1, missed_idcs < len(rpeaks))\n missed_idcs = missed_idcs[valid_idcs]\n prev_rpeaks = rpeaks[[i - 1 for i in missed_idcs]]\n next_rpeaks = rpeaks[missed_idcs]\n added_rpeaks = prev_rpeaks + (next_rpeaks - prev_rpeaks) / 2\n # Add the new peaks before the missed indices (see numpy docs).\n rpeaks = np.insert(rpeaks, missed_idcs, added_rpeaks)\n # Update remaining indices.\n ectopic_idcs = _update_indices(missed_idcs, ectopic_idcs, 1)\n longshort_idcs = _update_indices(missed_idcs, longshort_idcs, 1)\n\n # Interpolate ectopic as well as long or short peaks (important to do\n # this after peaks are deleted and/or added).\n interp_idcs = np.concatenate((ectopic_idcs, longshort_idcs)).astype(int)\n if interp_idcs.size > 0:\n interp_idcs.sort(kind='mergesort')\n # Make sure to not generate negative indices, or indices that exceed\n # the total number of peaks.\n # Make sure to not generate negative indices, or indices that exceed\n # the total number of peaks. prev_peaks and next_peaks must have the\n # same number of elements.\n valid_idcs = np.logical_and(interp_idcs > 1, interp_idcs < len(rpeaks))\n interp_idcs = interp_idcs[valid_idcs]\n prev_rpeaks = rpeaks[[i - 1 for i in interp_idcs]]\n next_rpeaks = rpeaks[[i + 1 for i in interp_idcs]]\n rpeaks_interp = prev_rpeaks + (next_rpeaks - prev_rpeaks) / 2\n # Shift the R-peaks from the old to the new position.\n rpeaks = np.delete(rpeaks, interp_idcs)\n rpeaks = np.concatenate((rpeaks, rpeaks_interp)).astype(int)\n rpeaks.sort(kind=\"mergesort\")\n rpeaks = np.unique(rpeaks)\n\n return rpeaks\n\n\ndef _plot_artifacts_lipponen2019(artifacts, info):\n \"\"\"\n \"\"\"\n # Extract parameters\n longshort_idcs = artifacts[\"longshort\"]\n ectopic_idcs = artifacts[\"ectopic\"]\n extra_idcs = artifacts[\"extra\"]\n missed_idcs = artifacts[\"missed\"]\n\n rr = info[\"rr\"]\n drrs = info[\"drrs\"]\n mrrs = info[\"mrrs\"]\n s12 = info[\"s12\"]\n s22 = info[\"s22\"]\n c1 = info[\"c1\"]\n c2 = info[\"c2\"]\n\n # Visualize artifact type indices.\n\n # Set grids\n gs = matplotlib.gridspec.GridSpec(ncols=4, nrows=3,\n width_ratios=[1, 2, 2, 2])\n fig = plt.figure(constrained_layout=False)\n ax0 = fig.add_subplot(gs[0, :-2])\n ax1 = fig.add_subplot(gs[1, :-2])\n ax2 = fig.add_subplot(gs[2, :-2])\n ax3 = fig.add_subplot(gs[:, -1])\n ax4 = fig.add_subplot(gs[:, -2])\n\n ax0.set_title(\"Artifact types\", fontweight=\"bold\")\n ax0.plot(rr, label=\"heart period\")\n ax0.scatter(longshort_idcs, rr[longshort_idcs], marker='x', c='m',\n s=100, zorder=3, label=\"long/short\")\n ax0.scatter(ectopic_idcs, rr[ectopic_idcs], marker='x', c='g', s=100,\n zorder=3, label=\"ectopic\")\n ax0.scatter(extra_idcs, rr[extra_idcs], marker='x', c='y', s=100,\n zorder=3, label=\"false positive\")\n ax0.scatter(missed_idcs, rr[missed_idcs], marker='x', c='r', s=100,\n zorder=3, label=\"false negative\")\n ax0.legend(loc=\"upper right\")\n\n # Visualize first threshold.\n ax1.set_title(\"Consecutive-difference criterion\", fontweight=\"bold\")\n ax1.plot(np.abs(drrs), label=\"difference consecutive heart periods\")\n ax1.axhline(1, c='r', label=\"artifact threshold\")\n ax1.legend(loc=\"upper right\")\n\n # Visualize second threshold.\n ax2.set_title(\"Difference-from-median criterion\", fontweight=\"bold\")\n ax2.plot(np.abs(mrrs), label=\"difference from median over 11 periods\")\n ax2.axhline(3, c=\"r\", label=\"artifact threshold\")\n ax2.legend(loc=\"upper right\")\n\n # Visualize subspaces.\n ax4.set_title(\"Subspace 1\", fontweight=\"bold\")\n ax4.set_xlabel(\"S11\")\n ax4.set_ylabel(\"S12\")\n ax4.scatter(drrs, s12, marker=\"x\", label=\"heart periods\")\n verts0 = [(min(drrs), max(s12)),\n (min(drrs), -c1 * min(drrs) + c2),\n (-1, -c1 * -1 + c2),\n (-1, max(s12))]\n poly0 = matplotlib.patches.Polygon(verts0, alpha=0.3, facecolor=\"r\",\n edgecolor=None, label=\"ectopic periods\")\n ax4.add_patch(poly0)\n verts1 = [(1, -c1 * 1 - c2),\n (1, min(s12)),\n (max(drrs), min(s12)),\n (max(drrs), -c1 * max(drrs) - c2)]\n poly1 = matplotlib.patches.Polygon(verts1, alpha=0.3, facecolor=\"r\",\n edgecolor=None)\n ax4.add_patch(poly1)\n ax4.legend(loc=\"upper right\")\n\n ax3.set_title(\"Subspace 2\", fontweight=\"bold\")\n ax3.set_xlabel(\"S21\")\n ax3.set_ylabel(\"S22\")\n ax3.scatter(drrs, s22, marker=\"x\", label=\"heart periods\")\n verts2 = [(min(drrs), max(s22)),\n (min(drrs), 1),\n (-1, 1),\n (-1, max(s22))]\n poly2 = matplotlib.patches.Polygon(verts2, alpha=0.3, facecolor=\"r\",\n edgecolor=None, label=\"short periods\")\n ax3.add_patch(poly2)\n verts3 = [(1, -1),\n (1, min(s22)),\n (max(drrs), min(s22)),\n (max(drrs), -1)]\n poly3 = matplotlib.patches.Polygon(verts3, alpha=0.3, facecolor=\"y\",\n edgecolor=None, label=\"long periods\")\n ax3.add_patch(poly3)\n ax3.legend(loc=\"upper right\")\n\n\ndef _threshold_normalization(data, alpha, window_half):\n wh = window_half\n # compute threshold\n th = np.zeros(data.size)\n if data.size <= 2 * wh:\n th[:] = alpha * (scipy.stats.iqr(np.abs(data)) / 2)\n # normalize data by threshold\n data_th = np.divide(data, th)\n else:\n data_pad = np.pad(data, wh, \"reflect\")\n for i in np.arange(wh, wh + data.size):\n th[i - wh] = alpha * (scipy.stats.iqr(np.abs(data_pad[i - wh:i + wh])) / 2)\n # normalize data by threshold (remove padding)\n data_th = np.divide(data_pad[wh:wh + data.size], th)\n return data_th, th\n\n\ndef _update_indices(source_idcs, update_idcs, update):\n \"\"\"\n for every element s in source_idcs, change every element u in update_idcs\n according to update, if u is larger than s\n \"\"\"\n update_idcs_buffer = update_idcs\n for s in source_idcs:\n # find the indices (of indices) that need to be updated\n updates = [i for i, j in enumerate(update_idcs) if j > s]\n for u in updates:\n update_idcs_buffer[u] += update\n return update_idcs_buffer\n", "meta": {"hexsha": "604280cb5b0369e2fb3a217a613eb90d966cbd58", "size": 15688, "ext": "py", "lang": "Python", "max_stars_repo_path": "neurokit2/ecg/ecg_fixpeaks.py", "max_stars_repo_name": "purpl3F0x/NeuroKit", "max_stars_repo_head_hexsha": "bd41f2bf7692bc8ed4c85608daa535293a33a1d6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "neurokit2/ecg/ecg_fixpeaks.py", "max_issues_repo_name": "purpl3F0x/NeuroKit", "max_issues_repo_head_hexsha": "bd41f2bf7692bc8ed4c85608daa535293a33a1d6", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "neurokit2/ecg/ecg_fixpeaks.py", "max_forks_repo_name": "purpl3F0x/NeuroKit", "max_forks_repo_head_hexsha": "bd41f2bf7692bc8ed4c85608daa535293a33a1d6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.2634146341, "max_line_length": 94, "alphanum_fraction": 0.5936384498, "include": true, "reason": "import numpy,import scipy", "num_tokens": 4343, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5467381372136563, "lm_q2_score": 0.34864512856608554, "lm_q1q2_score": 0.19061758814083732}} {"text": "# AUTOGENERATED! DO NOT EDIT! File to edit: nbs/06_bilateral_filtering.ipynb (unless otherwise specified).\n\n__all__ = ['sparse_bilateral_filtering', 'vis_depth_discontinuity', 'bilateral_filter', 'rolling_window']\n\n# Cell\nimport numpy as np\nfrom functools import reduce\n\n# Cell\ndef sparse_bilateral_filtering(\n depth, image, config, HR=False, mask=None, gsHR=True, edge_id=None, num_iter=None, num_gs_iter=None, spdb=False\n):\n \"\"\"\n config:\n - filter_size\n \"\"\"\n import time\n\n save_images = []\n save_depths = []\n save_discontinuities = []\n vis_depth = depth.copy()\n backup_vis_depth = vis_depth.copy()\n\n depth_max = vis_depth.max()\n depth_min = vis_depth.min()\n vis_image = image.copy()\n for i in range(num_iter):\n if isinstance(config[\"filter_size\"], list):\n window_size = config[\"filter_size\"][i]\n else:\n window_size = config[\"filter_size\"]\n vis_image = image.copy()\n save_images.append(vis_image)\n save_depths.append(vis_depth)\n u_over, b_over, l_over, r_over = vis_depth_discontinuity(vis_depth, config, mask=mask)\n vis_image[u_over > 0] = np.array([0, 0, 0])\n vis_image[b_over > 0] = np.array([0, 0, 0])\n vis_image[l_over > 0] = np.array([0, 0, 0])\n vis_image[r_over > 0] = np.array([0, 0, 0])\n\n discontinuity_map = (u_over + b_over + l_over + r_over).clip(0.0, 1.0)\n discontinuity_map[depth == 0] = 1\n save_discontinuities.append(discontinuity_map)\n if mask is not None:\n discontinuity_map[mask == 0] = 0\n vis_depth = bilateral_filter(\n vis_depth, config, discontinuity_map=discontinuity_map, HR=HR, mask=mask, window_size=window_size\n )\n\n return save_images, save_depths\n\n# Cell\ndef vis_depth_discontinuity(depth, config, vis_diff=False, label=False, mask=None):\n \"\"\"\n config:\n -\n \"\"\"\n if label == False:\n disp = 1./depth\n u_diff = (disp[1:, :] - disp[:-1, :])[:-1, 1:-1]\n b_diff = (disp[:-1, :] - disp[1:, :])[1:, 1:-1]\n l_diff = (disp[:, 1:] - disp[:, :-1])[1:-1, :-1]\n r_diff = (disp[:, :-1] - disp[:, 1:])[1:-1, 1:]\n if mask is not None:\n u_mask = (mask[1:, :] * mask[:-1, :])[:-1, 1:-1]\n b_mask = (mask[:-1, :] * mask[1:, :])[1:, 1:-1]\n l_mask = (mask[:, 1:] * mask[:, :-1])[1:-1, :-1]\n r_mask = (mask[:, :-1] * mask[:, 1:])[1:-1, 1:]\n u_diff = u_diff * u_mask\n b_diff = b_diff * b_mask\n l_diff = l_diff * l_mask\n r_diff = r_diff * r_mask\n u_over = (np.abs(u_diff) > config['depth_threshold']).astype(np.float32)\n b_over = (np.abs(b_diff) > config['depth_threshold']).astype(np.float32)\n l_over = (np.abs(l_diff) > config['depth_threshold']).astype(np.float32)\n r_over = (np.abs(r_diff) > config['depth_threshold']).astype(np.float32)\n else:\n disp = depth\n u_diff = (disp[1:, :] * disp[:-1, :])[:-1, 1:-1]\n b_diff = (disp[:-1, :] * disp[1:, :])[1:, 1:-1]\n l_diff = (disp[:, 1:] * disp[:, :-1])[1:-1, :-1]\n r_diff = (disp[:, :-1] * disp[:, 1:])[1:-1, 1:]\n if mask is not None:\n u_mask = (mask[1:, :] * mask[:-1, :])[:-1, 1:-1]\n b_mask = (mask[:-1, :] * mask[1:, :])[1:, 1:-1]\n l_mask = (mask[:, 1:] * mask[:, :-1])[1:-1, :-1]\n r_mask = (mask[:, :-1] * mask[:, 1:])[1:-1, 1:]\n u_diff = u_diff * u_mask\n b_diff = b_diff * b_mask\n l_diff = l_diff * l_mask\n r_diff = r_diff * r_mask\n u_over = (np.abs(u_diff) > 0).astype(np.float32)\n b_over = (np.abs(b_diff) > 0).astype(np.float32)\n l_over = (np.abs(l_diff) > 0).astype(np.float32)\n r_over = (np.abs(r_diff) > 0).astype(np.float32)\n u_over = np.pad(u_over, 1, mode='constant')\n b_over = np.pad(b_over, 1, mode='constant')\n l_over = np.pad(l_over, 1, mode='constant')\n r_over = np.pad(r_over, 1, mode='constant')\n u_diff = np.pad(u_diff, 1, mode='constant')\n b_diff = np.pad(b_diff, 1, mode='constant')\n l_diff = np.pad(l_diff, 1, mode='constant')\n r_diff = np.pad(r_diff, 1, mode='constant')\n\n if vis_diff:\n return [u_over, b_over, l_over, r_over], [u_diff, b_diff, l_diff, r_diff]\n else:\n return [u_over, b_over, l_over, r_over]\n\n# Cell\ndef bilateral_filter(depth, config, discontinuity_map=None, HR=False, mask=None, window_size=False):\n sort_time = 0\n replace_time = 0\n filter_time = 0\n init_time = 0\n filtering_time = 0\n sigma_s = config['sigma_s']\n sigma_r = config['sigma_r']\n if window_size == False:\n window_size = config['filter_size']\n midpt = window_size//2\n ax = np.arange(-midpt, midpt+1.)\n xx, yy = np.meshgrid(ax, ax)\n if discontinuity_map is not None:\n spatial_term = np.exp(-(xx**2 + yy**2) / (2. * sigma_s**2))\n\n # padding\n depth = depth[1:-1, 1:-1]\n depth = np.pad(depth, ((1,1), (1,1)), 'edge')\n pad_depth = np.pad(depth, (midpt,midpt), 'edge')\n if discontinuity_map is not None:\n discontinuity_map = discontinuity_map[1:-1, 1:-1]\n discontinuity_map = np.pad(discontinuity_map, ((1,1), (1,1)), 'edge')\n pad_discontinuity_map = np.pad(discontinuity_map, (midpt,midpt), 'edge')\n pad_discontinuity_hole = 1 - pad_discontinuity_map\n # filtering\n output = depth.copy()\n pad_depth_patches = rolling_window(pad_depth, [window_size, window_size], [1,1])\n if discontinuity_map is not None:\n pad_discontinuity_patches = rolling_window(pad_discontinuity_map, [window_size, window_size], [1,1])\n pad_discontinuity_hole_patches = rolling_window(pad_discontinuity_hole, [window_size, window_size], [1,1])\n\n if mask is not None:\n pad_mask = np.pad(mask, (midpt,midpt), 'constant')\n pad_mask_patches = rolling_window(pad_mask, [window_size, window_size], [1,1])\n from itertools import product\n if discontinuity_map is not None:\n pH, pW = pad_depth_patches.shape[:2]\n for pi in range(pH):\n for pj in range(pW):\n if mask is not None and mask[pi, pj] == 0:\n continue\n if discontinuity_map is not None:\n if bool(pad_discontinuity_patches[pi, pj].any()) is False:\n continue\n discontinuity_patch = pad_discontinuity_patches[pi, pj]\n discontinuity_holes = pad_discontinuity_hole_patches[pi, pj]\n depth_patch = pad_depth_patches[pi, pj]\n depth_order = depth_patch.ravel().argsort()\n patch_midpt = depth_patch[window_size//2, window_size//2]\n if discontinuity_map is not None:\n coef = discontinuity_holes.astype(np.float32)\n if mask is not None:\n coef = coef * pad_mask_patches[pi, pj]\n else:\n range_term = np.exp(-(depth_patch-patch_midpt)**2 / (2. * sigma_r**2))\n coef = spatial_term * range_term\n if coef.max() == 0:\n output[pi, pj] = patch_midpt\n continue\n if discontinuity_map is not None and (coef.max() == 0):\n output[pi, pj] = patch_midpt\n else:\n coef = coef/(coef.sum())\n coef_order = coef.ravel()[depth_order]\n cum_coef = np.cumsum(coef_order)\n ind = np.digitize(0.5, cum_coef)\n output[pi, pj] = depth_patch.ravel()[depth_order][ind]\n else:\n pH, pW = pad_depth_patches.shape[:2]\n for pi in range(pH):\n for pj in range(pW):\n if discontinuity_map is not None:\n if pad_discontinuity_patches[pi, pj][window_size//2, window_size//2] == 1:\n continue\n discontinuity_patch = pad_discontinuity_patches[pi, pj]\n discontinuity_holes = (1. - discontinuity_patch)\n depth_patch = pad_depth_patches[pi, pj]\n depth_order = depth_patch.ravel().argsort()\n patch_midpt = depth_patch[window_size//2, window_size//2]\n range_term = np.exp(-(depth_patch-patch_midpt)**2 / (2. * sigma_r**2))\n if discontinuity_map is not None:\n coef = spatial_term * range_term * discontinuity_holes\n else:\n coef = spatial_term * range_term\n if coef.sum() == 0:\n output[pi, pj] = patch_midpt\n continue\n if discontinuity_map is not None and (coef.sum() == 0):\n output[pi, pj] = patch_midpt\n else:\n coef = coef/(coef.sum())\n coef_order = coef.ravel()[depth_order]\n cum_coef = np.cumsum(coef_order)\n ind = np.digitize(0.5, cum_coef)\n output[pi, pj] = depth_patch.ravel()[depth_order][ind]\n\n return output\n\n# Cell\ndef rolling_window(a, window, strides):\n assert len(a.shape)==len(window)==len(strides), \"\\'a\\', \\'window\\', \\'strides\\' dimension mismatch\"\n shape_fn = lambda i,w,s: (a.shape[i]-w)//s + 1\n shape = [shape_fn(i,w,s) for i,(w,s) in enumerate(zip(window, strides))] + list(window)\n def acc_shape(i):\n if i+1>=len(a.shape):\n return 1\n else:\n return reduce(lambda x,y:x*y, a.shape[i+1:])\n _strides = [acc_shape(i)*s*a.itemsize for i,s in enumerate(strides)] + list(a.strides)\n\n return np.lib.stride_tricks.as_strided(a, shape=shape, strides=_strides)", "meta": {"hexsha": "fe2fcd494ed44b2986890531adbb8b5c033d64c2", "size": 9729, "ext": "py", "lang": "Python", "max_stars_repo_path": "pomerantz/bilateral_filtering.py", "max_stars_repo_name": "bitcloud2/3d-photo-inpainting", "max_stars_repo_head_hexsha": "5570e95f699effa0fbae3f49abf2b5f505831e30", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-02-25T07:08:05.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-25T07:08:05.000Z", "max_issues_repo_path": "pomerantz/bilateral_filtering.py", "max_issues_repo_name": "bitcloud2/pomerantz", "max_issues_repo_head_hexsha": "5570e95f699effa0fbae3f49abf2b5f505831e30", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pomerantz/bilateral_filtering.py", "max_forks_repo_name": "bitcloud2/pomerantz", "max_forks_repo_head_hexsha": "5570e95f699effa0fbae3f49abf2b5f505831e30", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.6278026906, "max_line_length": 115, "alphanum_fraction": 0.5610031864, "include": true, "reason": "import numpy", "num_tokens": 2668, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6001883592602051, "lm_q2_score": 0.3174262785020255, "lm_q1q2_score": 0.19051555728020358}} {"text": "# -*- coding: utf-8 -*-\n\ntry:\n from ducc0.wgridder import dirty2ms, ms2dirty\nexcept ImportError as e:\n ducc_import_error = e\nelse:\n ducc_import_error = None\n\nimport numpy as np\nfrom africanus.util.docs import DocstringTemplate\nfrom africanus.util.requirements import requires_optional\n\n\n@requires_optional('ducc0.wgridder', ducc_import_error)\ndef _hessian_internal(uvw, freq, image, freq_bin_idx, freq_bin_counts,\n cell, weights, flag, celly, epsilon, nthreads,\n do_wstacking, double_accum):\n\n # adjust for chunking\n # need a copy here if using multiple row chunks\n freq_bin_idx2 = freq_bin_idx - freq_bin_idx.min()\n nband = freq_bin_idx.size\n _, nx, ny = image.shape\n # the extra dimension is required to allow for chunking over row\n convolvedim = np.zeros((1, nband, nx, ny), dtype=image.dtype)\n for i in range(nband):\n ind = slice(freq_bin_idx2[i], freq_bin_idx2[i] + freq_bin_counts[i])\n if weights is not None:\n wgt = weights[:, ind]\n else:\n wgt = None\n if flag is not None:\n mask = flag[:, ind]\n else:\n mask = None\n modelvis = dirty2ms(uvw=uvw, freq=freq[ind],\n dirty=image[i], wgt=None,\n pixsize_x=cell, pixsize_y=celly,\n nu=0, nv=0, epsilon=epsilon,\n nthreads=nthreads, mask=mask,\n do_wstacking=do_wstacking)\n convolvedim[0, i] = ms2dirty(\n uvw=uvw, freq=freq[ind], ms=modelvis,\n wgt=wgt, npix_x=nx, npix_y=ny,\n pixsize_x=cell, pixsize_y=celly,\n nu=0, nv=0, epsilon=epsilon,\n nthreads=nthreads, mask=mask,\n do_wstacking=do_wstacking,\n double_precision_accumulation=double_accum)\n return convolvedim\n\n\n# This additional wrapper is required to allow the dask wrappers\n# to chunk over row\n@requires_optional('ducc0.wgridder', ducc_import_error)\ndef hessian(uvw, freq, image, freq_bin_idx, freq_bin_counts, cell,\n weights=None, flag=None, celly=None, epsilon=1e-5, nthreads=1,\n do_wstacking=True, double_accum=False):\n\n if celly is None:\n celly = cell\n\n if not nthreads:\n import multiprocessing\n nthreads = multiprocessing.cpu_count()\n\n residim = _hessian_internal(uvw, freq, image, freq_bin_idx,\n freq_bin_counts, cell, weights, flag,\n celly, epsilon, nthreads, do_wstacking,\n double_accum)\n return residim[0]\n\n\nHESSIAN_DOCS = DocstringTemplate(\n r\"\"\"\n Compute action of Hessian on an image using ducc\n\n .. math::\n\n\n R^\\dagger \\Sigma^{-1} R x\n\n where :math:`R` is an implicit degridding operator and\n :math:`x` is the image of shape :code:`(band, nx, ny)`.\n\n The number of imaging bands :code:`(band)` must\n be less than or equal to the number of channels\n :code:`(chan)` at which the data were obtained.\n The mapping from :code:`(chan)` to :code:`(band)` is described\n by :code:`freq_bin_idx` and :code:`freq_bin_counts` as\n described below.\n\n\n Parameters\n ----------\n uvw : $(array_type)\n uvw coordinates at which visibilities were\n obtained with shape :code:`(row, 3)`.\n freq : $(array_type)\n Observational frequencies of shape :code:`(chan,)`.\n model : $(array_type)\n Model image to degrid of shape :code:`(band, nx, ny)`.\n weights : $(array_type)\n Imaging weights of shape :code:`(row, chan)`.\n freq_bin_idx : $(array_type)\n Starting indices of frequency bins for each imaging\n band of shape :code:`(band,)`.\n freq_bin_counts : $(array_type)\n The number of channels in each imaging band of shape :code:`(band,)`.\n cell : float\n The cell size of a pixel along the :math:`x` direction in radians.\n flag: $(array_type), optional\n Flags of shape :code:`(row,chan)`. Will only process visibilities\n for which flag!=0\n celly : float, optional\n The cell size of a pixel along the :math:`y` direction in radians.\n By default same as cell size along :math:`x` direction.\n nu : int, optional\n The number of pixels in the padded grid along the :math:`x` direction.\n Chosen automatically by default.\n nv : int, optional\n The number of pixels in the padded grid along the :math:`y` direction.\n Chosen automatically by default.\n epsilon : float, optional\n The precision of the gridder with respect to the direct Fourier\n transform. By deafult, this is set to :code:`1e-5` for single\n precision and :code:`1e-7` for double precision.\n nthreads : int, optional\n The number of threads to use. Defaults to one.\n do_wstacking : bool, optional\n Whether to correct for the w-term or not. Defaults to True\n double_accum : bool, optional\n If true ducc will accumulate in double precision regardless of\n the input type.\n\n Returns\n -------\n residual : $(array_type)\n Residual image corresponding to :code:`model` of shape\n :code:`(band, nx, ny)`.\n \"\"\")\n\ntry:\n hessian.__doc__ = HESSIAN_DOCS.substitute(\n array_type=\":class:`numpy.ndarray`\")\nexcept AttributeError:\n pass\n", "meta": {"hexsha": "fd367813f9487c8ce3cb907eefa9301883a9bca8", "size": 5540, "ext": "py", "lang": "Python", "max_stars_repo_path": "africanus/gridding/wgridder/hessian.py", "max_stars_repo_name": "JoshVStaden/codex-africanus", "max_stars_repo_head_hexsha": "4a38994431d51510b1749fa0e4b8b6190b8b530f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 13, "max_stars_repo_stars_event_min_datetime": "2018-04-06T09:36:13.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-13T13:11:00.000Z", "max_issues_repo_path": "africanus/gridding/wgridder/hessian.py", "max_issues_repo_name": "JoshVStaden/codex-africanus", "max_issues_repo_head_hexsha": "4a38994431d51510b1749fa0e4b8b6190b8b530f", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 153, "max_issues_repo_issues_event_min_datetime": "2018-03-28T14:13:48.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-03T07:49:17.000Z", "max_forks_repo_path": "africanus/gridding/wgridder/hessian.py", "max_forks_repo_name": "JoshVStaden/codex-africanus", "max_forks_repo_head_hexsha": "4a38994431d51510b1749fa0e4b8b6190b8b530f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 14, "max_forks_repo_forks_event_min_datetime": "2018-03-29T13:30:52.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-12T02:56:55.000Z", "avg_line_length": 37.1812080537, "max_line_length": 78, "alphanum_fraction": 0.6064981949, "include": true, "reason": "import numpy", "num_tokens": 1351, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6334102636778401, "lm_q2_score": 0.3007455726738824, "lm_q1q2_score": 0.1904953324873069}} {"text": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nHelper functions and variables for the MVA analysis\n\nIn case some other isotopes are of interest, the isotopes variable can be extended.\n\nzs. elter 2020\n\"\"\"\n\nimport numpy as np\nimport pandas as pd\nimport matplotlib\n\nimport matplotlib.pyplot as plt\nimport random\nimport os\nimport math\nimport re\n\nfrom sklearn import preprocessing\nfrom sklearn import decomposition\n\nisotopes={'Cs134': {'hl':2.065*365,\n 'energies': [0.563,0.569,0.604,0.795,0.801,1.038,1.167,1.365],\n 'strength': [8.338,15.373,97.62,85.46,8.688,0.990,1.790,3.017]},\n 'Cs137': {'hl':30.1*365,\n 'energies': [0.662],\n 'strength': [85.1]},\n 'Eu154': {'hl':8.6*365,\n 'energies': [0.723,0.756,0.873,0.996,1.004,1.246,1.274,1.494,1.596],\n 'strength': [20.06,4.52,12.08,10.48,18.01,0.856,34.8,0.698,1.797]}}\n \n\ndef AssemblyMap(deftype):\n \"\"\"Function to produce a 17x17 assembly map with partial defects in it.\n '1' represents fuel, '2' represent control rod guide, and '3' represents dummy rods.\n \n Parameters\n ----------\n deftype : str\n String variable to describe the assembly map (it takes values 'A', 'B', etc) \n \n Returns\n -------\n mapArray : list of lists\n A list of list to represent a matrix describing the rod types in the assembly.\n \"\"\"\n \n import random\n import math\n SubAsStr=''\n CrPos=[40,43,46,55,65,88,91,94,97,100,139,142,145,148,151,190,193,196,199,202,225,235,244,247,250]\n FuelPos=[]\n for i in range(17*17):\n j=i+1\n if j not in CrPos: \n FuelPos.append(j)\n \n if deftype=='A':\n DummyPos=[1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33,35,37,39,41,45,47,49,51,53,57,59,61,63,67,69,71,73,75,77,79,81,83,85,87,89,93,95,99,101,103,105,107,109,111,113,115,117,119,121,123,125,127,129,131,133,135,137,141,143,147,149,153,155,157,159,161,163,165,167,169,171,173,175,177,179,181,183,185,187,189,191,195,197,201,203,205,207,209,211,213,215,217,219,221,223,227,229,231,233,237,239,241,243,245,249,251,253,255,257,259,261,263,265,267,269,271,273,275,277,279,281,283,285,287,289]\n elif deftype=='B':\n DummyPos=[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,21,23,25,27,29,31,33,34,35,37,39,41,45,47,49,51,52,53,57,59,61,63,67,68,69,71,73,81,83,85,86,87,89,99,101,102,103,105,117,119,120,121,123,133,135,136,137,153,154,155,157,167,169,170,171,173,185,187,188,189,191,201,203,204,205,207,209,217,219,221,222,223,227,229,231,233,237,238,239,241,243,245,249,251,253,255,256,257,259,261,263,265,267,269,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289]\n elif deftype=='C':\n DummyPos=[2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,18,19,21,23,25,27,29,31,33,34,35,37,39,41,45,47,49,51,52,53,57,59,61,63,67,68,69,71,73,75,79,81,83,85,86,87,89,99,101,102,103,105,117,119,120,121,123,133,135,136,137,153,154,155,157,167,169,170,171,173,185,187,188,189,191,201,203,204,205,207,209,211,215,217,219,221,222,223,227,229,231,233,237,238,239,241,243,245,249,251,253,255,256,257,259,261,263,265,267,269,271,272,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288]\n elif deftype=='D':\n DummyPos=[2,3,4,5,6,7,8,10,11,12,13,14,15,16,18,21,23,25,27,29,31,34,35,37,39,41,45,47,49,51,52,53,57,59,61,63,67,68,69,71,73,75,79,81,83,85,86,87,89,99,101,102,103,105,107,109,113,115,117,119,120,121,123,133,135,136,154,155,157,167,169,170,171,173,175,177,181,183,185,187,188,189,191,201,203,204,205,207,209,211,215,217,219,221,222,223,227,229,231,233,237,238,239,241,243,245,249,251,253,255,256,259,261,263,265,267,269,272,274,275,276,277,278,279,280,282,283,284,285,286,287,288]\n elif deftype=='E':\n DummyPos=[22,24,25,27,28,30,37,49,58,59,61,62,70,73,75,76,78,79,81,84,104,106,107,109,110,112,113,115,116,118,121,123,124,126,127,129,130,132,133,135,155,157,158,160,161,163,164,166,167,169,172,174,175,177,178,180,181,183,184,186,206,209,211,212,214,215,217,220,228,229,231,232,241,253,260,262,263,265,266,268]\n elif deftype=='F':\n DummyPos=[2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,48,50,52,54,58,62,66,68,70,73,81,84,86,102,104,106,116,118,120,136,138,152,154,170,172,174,184,186,188,204,206,209,217,220,222,224,228,232,236,238,240,242,252,254,256,258,260,262,264,266,268,270,272,274,276,278,280,282,284,286,288]\n elif deftype=='G':\n DummyPos=[1,2,3,4,7,8,9,10,11,14,15,16,17,18,19,22,30,33,34,35,37,49,51,52,68,70,84,103,109,113,119,120,136,137,153,154,170,171,177,181,187,206,220,222,238,239,241,253,255,256,257,260,268,271,272,273,274,275,276,279,280,281,282,283,286,287,288,289] \n elif deftype=='H':\n DummyPos=[1,2,4,6,8,9,10,12,14,16,17,18,20,24,28,32,34,36,50,52,58,62,68,73,81,86,102,104,106,116,118,120,136,137,153,154,170,172,174,184,186,188,204,209,217,222,228,232,238,240,254,256,258,262,266,270,272,273,274,276,278,280,281,282,284,286,288,289]\n elif deftype=='I':\n DummyPos=[1,2,3,5,8,9,10,13,15,16,17,18,19,33,34,35,51,56,64,69,75,79,85,120,136,137,153,154,170,205,211,215,221,226,234,239,255,256,257,271,272,273,274,275,277,280,281,282,285,287,288,289] \n elif deftype=='J':\n DummyPos=[1,2,4,6,8,10,12,14,16,17,18,20,24,28,32,34,36,50,52,68,86,102,104,118,120,136,154,170,172,186,188,204,222,238,240,254,256,258,262,266,270,272,273,274,276,278,280,282,284,286,288,289] \n elif deftype=='K':\n DummyPos=[1,2,3,5,8,10,13,15,16,17,18,19,33,34,35,51,69,85,120,136,154,170,205,221,239,255,256,257,271,272,273,274,275,277,280,282,285,287,288,289] \n elif deftype=='L':\n DummyPos=[1,2,5,9,13,16,17,18,19,24,28,33,34,37,49,69,85,104,118,137,153,172,186,205,221,241,253,256,257,262,266,271,272,273,274,277,281,285,288,289]\n elif deftype=='M':\n DummyPos=[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,51,52,68,69,85,86,102,103,119,120,136,137,153,154,170,171,187,188,204,205,221,222,238,239,255,256,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289]\n elif deftype=='N':\n DummyPos=[37,38,39,41,45,47,48,49,54,57,59,61,63,66,71,73,75,77,79,81,83,89,93,95,99,105,107,109,111,113,115,117,123,125,127,129,131,133,141,143,147,149,157,159,161,163,165,167,173,175,177,179,181,183,185,191,195,197,201,207,209,211,213,215,217,219,224,227,229,231,233,236,241,242,243,245,249,251,252,253]\n elif deftype=='O':\n DummyPos=[]\n elif deftype=='P':\n DummyPos=[37,38,39,41,42,54,56,57,58,59,60,71,72,73,74,75,76,77,89,90,92,93,105,106,107,108,109,110,111,122,123,124,125,126,127,128,140,141,143,144]\n elif deftype=='Q':\n DummyPos=[92,93,95,96,108,109,110,111,112,113,114,125,126,127,128,129,130,131,143,144,146,147,159,160,161,162,163,164,165,176,177,178,179,180,181,182,194,195,197,198]\n elif deftype=='R':\n DummyPos=[5,14,21,24,27,28,30,37,42,44,45,49,50,53,58,64,69,70,72,75,76,78,79,82,85,89,90,92,96,98,101,106,107,110,115,116,123,124,129,134,140,144,147,156,158,159,163,167,168,171,174,177,178,180,181,194,205,211,213,215,216,219,222,224,232,236,237,239,240,246,257,260,261,268,276,278,282,283,285,286]\n elif deftype=='S':\n DummyPos=[1,2,3,4,5,6,7,8,9,18,19,20,21,22,23,24,25,35,36,37,38,39,41,42,52,53,54,56,57,58,59,60,69,70,71,72,73,74,75,76,86,87,89,90,92,93,103,104,105,106,107,108,109,110,111,120,121,122,123,124,125,126,127,138,141,144,146,149,152,163,164,165,166,167,168,169,170,179,180,181,182,183,184,185,186,187,197,198,200,201,203,204,214,215,216,217,218,219,220,221,230,231,232,233,234,236,237,238,248,249,251,252,253,254,255,265,266,267,268,269,270,271,272,281,282,283,284,285,286,287,288,289]\n elif deftype=='T':\n DummyPos=[1,2,3,4,5,6,7,8,9,18,19,20,21,22,23,24,25,35,36,37,38,39,41,42,52,53,54,56,57,58,59,60,69,70,71,72,73,74,75,76,86,87,89,90,92,93,103,104,105,106,107,108,109,110,111,120,121,122,123,124,125,126,127,137,138,140,141,143,144,154,155,156,157,158,159,160,161,162,171,172,173,174,175,176,177,178,188,189,191,192,194,195,205,206,207,208,209,210,211,212,213,222,223,224,226,227,228,229,239,240,241,242,243,245,246,256,257,258,259,260,261,262,263,264,273,274,275,276,277,278,279,280]\n ND=len(DummyPos)\n mapArray=[]\n col=1\n for i in range(17*17):\n j=i+1\n if col==1:\n SubAsStr=SubAsStr+' '\n mapArray.append([])\n if j in CrPos:\n SubAsStr=SubAsStr+' '+str(3)#str(random.choice([4,6]))\n mapArray[-1].append('3')\n elif j in DummyPos:\n SubAsStr=SubAsStr+' '+str(2)\n mapArray[-1].append('2')\n else:\n SubAsStr=SubAsStr+' '+str(1)\n mapArray[-1].append('1')\n if col==17:\n SubAsStr=SubAsStr+'\\n'\n col=0\n col=col+1\n SubAsStr=SubAsStr[:-1]\n \n return mapArray\n\n\ndef detectorEff(E):\n \"\"\"Function to describe the detector efficiency. It is based on a fit of \n Serpent2 results.\n \n Parameters\n ----------\n E : float or list\n Energy in MeV\n \n Returns\n -------\n Eps : float or list\n Detector efficiency at energy/energies E\n \"\"\"\n E=E*1000 #change MeV to keV\n a=-8.02741343e-02\n b=-1.49151904e-01\n c=-2.84160334e-01\n d=4.39778388e-02\n e=1.19674986e-03\n f=1.26102944e+02\n \n lnEps=a+b*np.log(E/f)+c*(np.log(E/f))**2+d*(np.log(E/f))**3+e*(np.log(E/f))**4\n \n Eps=np.exp(lnEps)\n return Eps\n \ndef gammaLines(row,nuclides=['Cs137','Cs134','Eu154']):\n \"\"\"\n Function to return the energy line intensities. For this the concentrations of nuclides\n are converted into activity concentrations, and then into the intensity of the lines. This\n value is basically in emission/cm3/s units.\n \n Parameters\n ----------\n row : dict or pandas dataframe row\n dictionary to keep track of the spent fuel inventory.\n nuclides : list\n list of the nuclide identifiers for which the gamma line intensities are to be evaluated\n \n Returns\n -------\n lines : dict\n nested dictionary to store the gamma line intensities. outer keys are nuclide identifiers,\n inner keys are 'energies' and 'strength'. \n energies : numpy array\n List of gamma line energies.\n \"\"\"\n d2s=86400\n \n lines={}\n for iso in isotopes:\n lines[iso]={'energies':[],'strength':[]}\n conci=row[iso]\n acti=conci*1e24*(np.log(2)/(isotopes[iso]['hl']*d2s))\n for en,br in zip(isotopes[iso]['energies'],isotopes[iso]['strength']):\n enfreq=acti*br\n lines[iso]['energies'].append(en)\n lines[iso]['strength'].append(enfreq)\n \n energies=[]\n for key in nuclides:\n for en in isotopes[key]['energies']:\n energies.append(key+': '+str(en))\n energies=np.array(energies)\n return lines,energies\n\n\ndef prepareX(fuellib=None, cases=['O','R'],nuclides=['Cs137','Cs134','Eu154'],ratio=False,scaling=True,normalization=True,\n encoding={'O':0,'R':1},gefffilestem='outs/geomEff_',fresh=False):\n \"\"\"\n Function to create the X matrix, which has the feature vectors as its rows.\n This is not a very straightforward function, it is just to wrap up some data \n management.\n \n Parameters\n ----------\n fuellib : pandas dataframe\n Fuel library. For further details see https://doi.org/10.1016/j.dib.2020.106429\n cases : list of strings\n The assembly types in the analysis. It is important that the geometric efficiency files\n include these strings in it.\n ratio : bool\n if True the pairwise ratios of the features are returned.\n scaling : bool\n if True standard scaling is performed on the data\n normalization : bool\n if True, the feature vectors are normalized to sum to 1\n encoding : dictionary\n For classification numeric labels are preferred, thuse the cases need to be ecoded.\n Here one can also make sure whether several cases should be encoded into only 2 classes.\n gefffilestem : str\n The path and filename stem of the geometric efficiency curves. This will be \n extended with the string describing the case.\n fresh : bool\n If True, always the geometric efficiency of fresh fuel is used.\n \n Returns\n -------\n data : numpy array\n The data matrix. If the ratios are requested, then the matrix of the ratios\n labels : numpy array\n Encoded labels for all samples\n energies : numpy array\n Array of energies or energie ratios to identify the columns of the data matrix\n \"\"\"\n if fuellib is None:\n raise TypeError('No fuel library is added.')\n colN=0\n for nucl in nuclides:\n colN=colN+len(isotopes[nucl]['energies'])\n \n data=np.empty((0,colN))\n dataratio=np.empty((0,int((colN**2-colN)/2)))\n labels=[] \n \n \n for index, fuel in fuellib.iterrows():\n lines,energies=gammaLines(fuel)\n peaks=['']\n for c in cases:\n if fresh:\n engeff=np.loadtxt(gefffilestem+'%s_orig.dat'%c)\n else:\n engeff=np.loadtxt(gefffilestem+'%s_%d.dat'%(c,fuel['id']))\n peaks={}\n for iso in lines:\n peaks[iso]={'energies': [], 'strength':[]}\n for en,st in zip(lines[iso]['energies'],lines[iso]['strength']):\n peaks[iso]['energies'].append(en)\n peaki=st*np.interp(en,engeff[:,0],engeff[:,1])*detectorEff(en)\n peaks[iso]['strength'].append(peaki)\n\n feature=[]\n for nucl in nuclides:\n for strength in peaks[nucl]['strength']:\n feature.append(strength)\n feature=np.array(feature)\n \n featureratio=[]\n energiesratio=[]\n for i,(fi,ei) in enumerate(zip(feature,energies)):\n for j,(fj,ej) in enumerate(zip(feature,energies)):\n if j>i:\n if fi/fj >= fj/fi:\n featureratio.append(fi/fj)\n else:\n featureratio.append(fj/fi)\n energiesratio.append(ei+' / '+ej)\n featureratio=np.array(featureratio)\n\n if normalization:\n feature=feature/sum(feature)\n featureratio=featureratio/sum(featureratio)\n \n data=np.vstack([data,feature])\n dataratio=np.vstack([dataratio,featureratio])\n \n labels.append(encoding[c]) \n #TODO bring normalization here, to see the impact of doing scaling first\n labels=np.array(labels)\n \n if scaling:\n data = preprocessing.scale(data)\n dataratio = preprocessing.scale(dataratio)\n \n if ratio:\n return dataratio,labels,np.array(energiesratio)\n else:\n return data,labels,energies\n\ndef AtConc_to_ZWeightPer(row):\n \"\"\"Function to convert spent fuel inventory from nuclidewise atom concentration\n to elementwise weight percentage. \n The function expects a pandas row from the MVA dataset.\n 1, calculates the mass per cm3 for each isotope\n 2, changes the ZAID into elements and sums the mass of each element\n 3, returns the normalized mass (ie w%) for each element\n \n Parameters\n ----------\n row : pandas dataframe\n Row in dataframe describing the fuel inventory\n \n Returns\n -------\n masspervolume : dict\n Dictionary which stores the mass percentage for each element (which are the keys).\n \"\"\"\n \n #precondition row into dictionary\n inventory = row.to_dict()\n inventory.pop('Unnamed: 0') #note this is highly specific\n inventory.pop('BU')\n inventory.pop('CT')\n inventory.pop('IE')\n inventory.pop('fuelType')\n inventory.pop('TOT_SF')\n inventory.pop('TOT_GSRC')\n inventory.pop('TOT_A')\n inventory.pop('TOT_H')\n \n NA = 6.022140857E23\n masspervolume = {}\n \n \n for iso in inventory:\n isoText = re.findall('\\D+', iso)\n isoNum = re.findall('\\d+', iso)\n Z=isoText[0]\n A=float(isoNum[0])\n \n massconci = A*((inventory[iso]*1e24)/NA) #this gives the mass of that isotope in g/cm3\n \n if Z in masspervolume:\n masspervolume[Z]=masspervolume[Z]+massconci\n else:\n masspervolume[Z]=massconci\n \n \n #getting weight%\n summass=sum(masspervolume.values())\n for element in masspervolume:\n masspervolume[element]=masspervolume[element]/summass\n return masspervolume\n \n\n \ndef XCOMmaterial(massdic):\n \"\"\"\n Function to convert the mass percentages into XCOM readable input string\n \n Parameters\n ----------\n massdic : dict\n Dictionary which stores the mass percentage for each element (which are the keys).\n \n Returns\n -------\n xcomstr : str\n String which includes the elementwise mass percentages in an XCOM readable form.\n \"\"\"\n #printf 'spentfuel\\n4\\n2\\nH\\n0.1\\nO\\n0.9\\n1\\n3\\n1\\n3\\n0.6\\n0.8\\n0.9\\nN\\ntestauto.out\\n1\\n' | ./XCOMtest\n xcomstr='' \n for element in massdic:\n xcomstr=xcomstr+element+'\\n'+str(massdic[element])+'\\n'\n return xcomstr\n \n\n#Variable to match element symbol to Z. not used in these functions!\nnametoZ= {'Mt': 109,\n 'Hs': 108,\n 'Bh': 107,\n 'Sg': 106,\n 'Db': 105,\n 'Rf': 104,\n 'Lr': 103,\n 'No': 102,\n 'Md': 101,\n 'Fm': 100,\n 'Es': 99,\n 'Cf': 98,\n 'Bk': 97,\n 'Cm': 96,\n 'Am': 95,\n 'Pu': 94,\n 'Np': 93,\n 'U': 92,\n 'Pa': 91,\n 'Th': 90,\n 'Ac': 89,\n 'Ra': 88,\n 'Fr': 87,\n 'Rn': 86,\n 'At': 85,\n 'Po': 84,\n 'Bi': 83,\n 'Pb': 82,\n 'Tl': 81,\n 'Hg': 80,\n 'Au': 79,\n 'Pt': 78,\n 'Ir': 77,\n 'Os': 76,\n 'Re': 75,\n 'W': 74,\n 'Ta': 73,\n 'Hf': 72,\n 'Lu': 71,\n 'Yb': 70,\n 'Tm': 69,\n 'Er': 68,\n 'Ho': 67,\n 'Dy': 66,\n 'Tb': 65,\n 'Gd': 64,\n 'Eu': 63,\n 'Sm': 62,\n 'Pm': 61,\n 'Nd': 60,\n 'Pr': 59,\n 'Ce': 58,\n 'La': 57,\n 'Ba': 56,\n 'Cs': 55,\n 'Xe': 54,\n 'I': 53,\n 'Te': 52,\n 'Sb': 51,\n 'Sn': 50,\n 'In': 49,\n 'Cd': 48,\n 'Ag': 47,\n 'Pd': 46,\n 'Rh': 45,\n 'Ru': 44,\n 'Tc': 43,\n 'Mo': 42,\n 'Nb': 41,\n 'Zr': 40,\n 'Y': 39,\n 'Sr': 38,\n 'Rb': 37,\n 'Kr': 36,\n 'Br': 35,\n 'Se': 34,\n 'As': 33,\n 'Ge': 32,\n 'Ga': 31,\n 'Zn': 30,\n 'Cu': 29,\n 'Ni': 28,\n 'Co': 27,\n 'Fe': 26,\n 'Mn': 25,\n 'Cr': 24,\n 'V': 23,\n 'Ti': 22,\n 'Sc': 21,\n 'Ca': 20,\n 'K': 19,\n 'Ar': 18,\n 'Cl': 17,\n 'S': 16,\n 'P': 15,\n 'Si': 14,\n 'Al': 13,\n 'Mg': 12,\n 'Na': 11,\n 'Ne': 10,\n 'F': 9,\n 'O': 8,\n 'N': 7,\n 'C': 6,\n 'B': 5,\n 'Be': 4,\n 'Li': 3,\n 'He': 2,\n 'H': 1}", "meta": {"hexsha": "cf906f1bb92b9c6837c45fa33afada7ad67e588c", "size": 19619, "ext": "py", "lang": "Python", "max_stars_repo_path": "MVAfunctions.py", "max_stars_repo_name": "ezsolti/PartialDefect", "max_stars_repo_head_hexsha": "06b7ddfc17fac64a8f540502e9c1422003e48ae2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "MVAfunctions.py", "max_issues_repo_name": "ezsolti/PartialDefect", "max_issues_repo_head_hexsha": "06b7ddfc17fac64a8f540502e9c1422003e48ae2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "MVAfunctions.py", "max_forks_repo_name": "ezsolti/PartialDefect", "max_forks_repo_head_hexsha": "06b7ddfc17fac64a8f540502e9c1422003e48ae2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-12-09T13:28:57.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-09T13:28:57.000Z", "avg_line_length": 40.5351239669, "max_line_length": 496, "alphanum_fraction": 0.5784188797, "include": true, "reason": "import numpy", "num_tokens": 7038, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5813030906443134, "lm_q2_score": 0.32766831395172374, "lm_q1q2_score": 0.19047460360634821}} {"text": "#!/usr/bin/env python\n# coding: utf-8\n\n# OSeMOSYS-PLEXOS global model: Powerplant data\n\n# Import modules\nimport pandas as pd\nimport os\npd.options.mode.chained_assignment = None # default='warn'\nimport numpy as np\nimport itertools\nfrom urllib import request\n\nPLEXOS_URL = \"https://dataverse.harvard.edu/api/access/datafile/4008393?format=original&gbrecs=true\"\nPLEXOS_DATA = \"PLEXOS_World_2015_Gold_V1.1.xlsx\"\n\nMODE_LIST = [1, 2]\n\n\ndef get_data(INPUT_PATH):\n # Import data files and user input\n # Checks whether PLEXOS-World 2015 data needs to be retrieved from the PLEXOS-World Harvard Dataverse.\n path = os.path.join(INPUT_PATH, PLEXOS_DATA)\n try:\n workbook = open(path, 'rb')\n except IOError:\n request.urlretrieve(PLEXOS_URL, path)\n workbook = open(path, 'rb')\n finally:\n df = pd.read_excel(workbook, sheet_name=\"Properties\")\n df_dict = pd.read_excel(workbook, sheet_name=\"Memberships\")\n workbook.close()\n\n df_dict = df_dict[df_dict[\"parent_class\"] == \"Generator\"].rename(\n {\"parent_object\": \"powerplant\"}, axis=1\n )\n return df, df_dict\n\n\ndef create_main_generator_table(df):\n # Create main generator table\n gen_cols_1 = [\"child_class\", \"child_object\", \"property\", \"value\"]\n df_gen = df[gen_cols_1]\n df_gen = df_gen[df_gen[\"child_class\"] == \"Generator\"]\n df_gen.rename(columns={\"child_object\": \"powerplant\"}, inplace=True)\n df_gen.drop(\"child_class\", axis=1, inplace=True)\n df_gen = pd.pivot_table(df_gen,\n index=\"powerplant\",\n columns=\"property\",\n values=\"value\",\n aggfunc=np.sum,\n fill_value=0,\n )\n df_gen[\"total_capacity\"] = (df_gen[\"Max Capacity\"].astype(float)) * (\n df_gen[\"Units\"].astype(int)\n )\n\n gen_cols_2 = [\"Commission Date\", \"Heat Rate\", \"Max Capacity\", \"total_capacity\"]\n df_gen_2 = df_gen[gen_cols_2]\n return df_gen_2\n\n\ndef compile_powerplants_nodes_fuels(df_dict):\n ## Compile dataframe with powerplants, nodes, and fuels\n df_dict_fuel = df_dict[df_dict[\"collection\"] == \"Fuels\"]\n df_dict_fuel = df_dict_fuel[[\"powerplant\", \"child_object\"]]\n df_dict_nodes = df_dict[df_dict[\"collection\"] == \"Nodes\"]\n df_dict_nodes = df_dict_nodes[[\"powerplant\", \"child_object\"]]\n df_dict_2 = pd.merge(df_dict_fuel, df_dict_nodes, how=\"outer\", on=\"powerplant\")\n return df_dict_2\n\n\ndef calculate_activity_ratios(thermal_fuel_list, region_name, thermal_fuel_list_iar, renewables_list,\n df_gen_2, df, model_start_year, model_end_year, df_trn_efficiencies):\n # Create master table for activity ratios\n years = get_years(model_start_year, model_end_year)\n df_ratios = ratio_master_table(df_gen_2, years)\n # Calculate Input and OutputActivityRatio for: Power Generation\n df_oar, df_oar_final = output_activity_ratios(df_ratios, thermal_fuel_list, region_name)\n df_iar_final = input_activity_ratio(df_oar, thermal_fuel_list_iar, renewables_list, df_gen_2, region_name)\n # Upstream,\n df_oar_upstream = upstream_output_activity_ratios(df_iar_final, renewables_list)\n # international markets,\n df_oar_int = international_output_activity_ratios(df_oar_upstream)\n df_iar_int = international_input_activity_ratio(df_oar_int)\n # domestic transmission and\n df_iar_trn = domestic_transmission_iar(df_oar_final)\n df_oar_trn = domestic_transmission_oar(df_iar_trn)\n # international transmission\n df_int_trn = create_international_transmission(df, region_name, model_start_year, model_end_year)\n df_int_trn_iar = international_transmission_iar(df_int_trn)\n df_trn_efficiencies = transmission_efficiency(df_trn_efficiencies)\n df_int_trn_oar = international_transmission_oar(df_int_trn, df_trn_efficiencies)\n\n # Combine the pieces from above and output to csv:\n df_oar_final = pd.concat([df_oar_final, df_oar_upstream, df_oar_int, df_oar_trn, df_int_trn_oar])\n\n # Select columns for final output table\n df_oar_final = df_oar_final.dropna()\n df_oar_final = df_oar_final[['REGION', 'TECHNOLOGY', 'FUEL', 'MODE_OF_OPERATION', 'YEAR', 'VALUE']]\n\n df_iar_final = pd.concat([df_iar_final, df_iar_int, df_iar_trn, df_int_trn_iar])\n\n # Select columns for final output table\n df_iar_final = df_iar_final.dropna()\n df_iar_final = df_iar_final[['REGION', 'TECHNOLOGY', 'FUEL', 'MODE_OF_OPERATION', 'YEAR', 'VALUE']]\n return df_oar_final, df_iar_final\n\n\ndef international_transmission_oar(df_int_trn, df_trn_efficiencies):\n df_int_trn_oar = df_int_trn.copy()\n # OAR Mode 2 is output to first country:\n df_int_trn_oar.loc[df_int_trn_oar[\"MODE_OF_OPERATION\"] == 2, \"FUEL\"] = (\n \"ELC\" + df_int_trn_oar[\"TECHNOLOGY\"].str[3:8] + \"01\"\n )\n # OAR Mode 1 is out to the second country:\n df_int_trn_oar.loc[df_int_trn_oar[\"MODE_OF_OPERATION\"] == 1, \"FUEL\"] = (\n \"ELC\" + df_int_trn_oar[\"TECHNOLOGY\"].str[8:13] + \"01\"\n )\n\n # and add values into OAR matrix\n df_int_trn_oar = df_int_trn_oar.drop([\"VALUE\"], axis=1)\n df_int_trn_oar = pd.merge(\n df_int_trn_oar, df_trn_efficiencies, how=\"outer\", on=\"TECHNOLOGY\"\n )\n return df_int_trn_oar\n\n\ndef transmission_efficiency(df_trn_efficiencies):\n # Drop unneeded columns\n df_trn_efficiencies = df_trn_efficiencies.drop(\n [\n \"Line\",\n \"KM distance\",\n \"HVAC/HVDC/Subsea\",\n \"Build Cost ($2010 in $000)\",\n \"Annual FO&M (3.5% of CAPEX) ($2010 in $000)\",\n \"Unnamed: 8\",\n \"Line Max Size (MW)\",\n \"Unnamed: 10\",\n \"Unnamed: 11\",\n \"Unnamed: 12\",\n \"Subsea lines\",\n ],\n axis=1,\n )\n\n # Drop NaN values\n df_trn_efficiencies = df_trn_efficiencies.dropna(subset=[\"From\"])\n\n # Create To and From Codes:\n # If from column has length 6 then it's the last three chars plus XX\n df_trn_efficiencies.loc[df_trn_efficiencies[\"From\"].str.len() == 6, \"From\"] = (\n df_trn_efficiencies[\"From\"].str[3:6] + \"XX\"\n )\n # If from column has length 9 then it's the 3:6 and 7:9 three chars plus XX\n df_trn_efficiencies.loc[df_trn_efficiencies[\"From\"].str.len() == 9, \"From\"] = (\n df_trn_efficiencies[\"From\"].str[3:6] + df_trn_efficiencies[\"From\"].str[7:9]\n )\n # If from column has length 6 then it's the last three chars plus XX\n df_trn_efficiencies.loc[df_trn_efficiencies[\"To\"].str.len() == 6, \"To\"] = (\n df_trn_efficiencies[\"To\"].str[3:6] + \"XX\"\n )\n # If from column has length 9 then it's the 3:6 and 7:9 three chars plus XX\n df_trn_efficiencies.loc[df_trn_efficiencies[\"To\"].str.len() == 9, \"To\"] = (\n df_trn_efficiencies[\"To\"].str[3:6] + df_trn_efficiencies[\"To\"].str[7:9]\n )\n\n # Combine From and To columns.\n # If the From is earlier in the alphabet the technology is in order, add tech with mode 1.\n df_trn_efficiencies[\"TECHNOLOGY\"] = (\"TRN\" + df_trn_efficiencies[\"From\"] + df_trn_efficiencies[\"To\"])\n\n # Drop to and from columns\n df_trn_efficiencies = df_trn_efficiencies.drop([\"From\", \"To\"], axis=1)\n\n # Rename column 'VALUES'\n df_trn_efficiencies = df_trn_efficiencies.rename(columns={\"Losses\": \"VALUE\"})\n\n # And adjust OAR values to be output amounts vs. losses:\n df_trn_efficiencies['VALUE'] = 1.0 - df_trn_efficiencies['VALUE']\n return df_trn_efficiencies\n\n\ndef international_transmission_iar(df_int_trn):\n # Now create the input and output activity ratios\n df_int_trn_iar = df_int_trn.copy()\n # IAR Mode 1 is input from first country:\n df_int_trn_iar.loc[df_int_trn_iar[\"MODE_OF_OPERATION\"] == 1, \"FUEL\"] = (\n \"ELC\" + df_int_trn_iar[\"TECHNOLOGY\"].str[3:8] + \"02\"\n )\n # IAR Mode 2 is input from second country:\n df_int_trn_iar.loc[df_int_trn_iar[\"MODE_OF_OPERATION\"] == 2, \"FUEL\"] = (\n \"ELC\" + df_int_trn_iar[\"TECHNOLOGY\"].str[8:13] + \"02\"\n )\n return df_int_trn_iar\n\n\ndef create_international_transmission(df, region_name, model_start_year, model_end_year):\n # Build international transmission system from original input data, but for Line rather than Generator:\n int_trn_cols = [\"child_class\", \"child_object\", \"property\", \"value\"]\n df_int_trn = df[int_trn_cols]\n df_int_trn = df_int_trn[df_int_trn[\"child_class\"] == \"Line\"]\n\n # For IAR and OAR we can drop the value:\n df_int_trn = df_int_trn.drop([\"child_class\", \"value\"], axis=1)\n\n # Create MofO column based on property:\n df_int_trn[\"MODE_OF_OPERATION\"] = 1\n df_int_trn.loc[df_int_trn[\"property\"] == \"Min Flow\", \"MODE_OF_OPERATION\"] = 2\n\n # Use the child_object column to build the technology names:\n df_int_trn[\"codes\"] = df_int_trn[\"child_object\"].str.split(pat=\"-\")\n\n # If there are only two locations, then the node is XX\n df_int_trn.loc[df_int_trn[\"codes\"].str.len() == 2, \"TECHNOLOGY\"] = (\n \"TRN\" + df_int_trn[\"codes\"].str[0] + \"XX\" + df_int_trn[\"codes\"].str[1] + \"XX\"\n )\n # If there are four locations, the node is already included\n df_int_trn.loc[df_int_trn[\"codes\"].str.len() == 4, \"TECHNOLOGY\"] = (\n \"TRN\"\n + df_int_trn[\"codes\"].str[0]\n + df_int_trn[\"codes\"].str[1]\n + df_int_trn[\"codes\"].str[2]\n + df_int_trn[\"codes\"].str[3]\n )\n # If there are three items, and the last item is two characters, then the second item is an XX:\n df_int_trn.loc[\n (df_int_trn[\"codes\"].str.len() == 3) & (df_int_trn[\"codes\"].str[2].str.len() == 2),\n \"TECHNOLOGY\",\n ] = (\n \"TRN\"\n + df_int_trn[\"codes\"].str[0]\n + \"XX\"\n + df_int_trn[\"codes\"].str[1]\n + df_int_trn[\"codes\"].str[2]\n )\n # If there are three items, and the last item is three characters, then the last item is an XX:\n df_int_trn.loc[\n (df_int_trn[\"codes\"].str.len() == 3) & (df_int_trn[\"codes\"].str[2].str.len() == 3),\n \"TECHNOLOGY\",\n ] = (\n \"TRN\"\n + df_int_trn[\"codes\"].str[0]\n + df_int_trn[\"codes\"].str[1]\n + df_int_trn[\"codes\"].str[2]\n + \"XX\"\n )\n\n # Set the value (of either IAR or OAR) to 1\n df_int_trn[\"VALUE\"] = 1\n df_int_trn[\"REGION\"] = region_name\n\n df_int_trn = df_int_trn.drop([\"property\", \"child_object\", \"codes\"], axis=1)\n df_int_trn[\"YEAR\"] = model_start_year\n # Add in the years:\n df_temp = df_int_trn.copy()\n for year in range(model_start_year + 1, model_end_year + 1):\n df_temp[\"YEAR\"] = year\n df_int_trn = df_int_trn.append(df_temp)\n\n df_int_trn = df_int_trn.reset_index(drop=True)\n return df_int_trn\n\n\ndef domestic_transmission_oar(df_iar_trn):\n # OAR for transmission technologies is IAR, but the fuel is 02 instead of 01:\n df_oar_trn = df_iar_trn.copy()\n df_oar_trn[\"FUEL\"] = df_oar_trn[\"FUEL\"].str[0:8] + \"02\"\n return df_oar_trn\n\n\ndef domestic_transmission_iar(df_oar_final):\n # Build transmission system outputs\n\n df_iar_trn = df_oar_final.copy()\n\n # Change the technology name to PWRTRNXXXXX\n df_iar_trn[\"TECHNOLOGY\"] = \"PWRTRN\" + df_iar_trn[\"FUEL\"].str[3:8]\n # Make all modes of operation 1\n df_iar_trn[\"MODE_OF_OPERATION\"] = 1\n # And remove all the duplicate entries\n df_iar_trn.drop_duplicates(keep=\"first\", inplace=True)\n return df_iar_trn\n\n\ndef international_input_activity_ratio(df_oar_int):\n # All we need to do is take in the thermal fuels for the MINXXXINT technologies. This already exists as df_oar_int with the XXINT fuel so we can simply copy that:\n df_iar_int = df_oar_int.copy()\n df_iar_int['FUEL'] = df_iar_int['FUEL'].str[0:3]\n return df_iar_int\n\n\ndef international_output_activity_ratios(df_oar_upstream):\n # Now we have to create the MINXXXINT technologies. They are all based on the MODE_OF_OPERATION == 2:\n df_oar_int = pd.DataFrame(df_oar_upstream.loc[df_oar_upstream['MODE_OF_OPERATION'] == 2, :])\n\n # At this point we should have only the internationally traded fuels since they're all mode 2. So we can make the tech MINXXXINT and that's that.\n df_oar_int['TECHNOLOGY'] = 'MIN'+df_oar_int['FUEL']+'INT'\n # And rename the fuel to XXXINT\n df_oar_int['FUEL'] = df_oar_int['FUEL']+'INT'\n df_oar_int['MODE_OF_OPERATION'] = 1 # This is probably not strictly necessary as long as they're always the same in and out...\n\n # and de-duplicate this list:\n df_oar_int.drop_duplicates(keep='first',inplace=True)\n return df_oar_int\n\n\ndef upstream_output_activity_ratios(df_iar_final, renewables_list):\n # #### OutputActivityRatios - Upstream\n\n thermal_fuels = ['COA', 'COG', 'GAS', 'PET', 'URN', 'OIL', 'OTH']\n\n # We have to create a technology to produce every fuel that is input into any of the power technologies:\n\n df_oar_upstream = df_iar_final.copy()\n\n # All mining and resource technologies have an OAR of 1...\n df_oar_upstream['VALUE'] = 1\n\n # Renewables - set the technology as RNW + FUEL\n df_oar_upstream.loc[df_oar_upstream['FUEL'].str[0:3].isin(renewables_list),\n 'TECHNOLOGY'] = 'RNW'+df_oar_upstream['FUEL']\n\n # If the fuel is a thermal fuel, we need to create the OAR for the mining technology... BUT NOT FOR THE INT FUELS...\n df_oar_upstream.loc[df_oar_upstream['FUEL'].str[0:3].isin(thermal_fuels) & ~(df_oar_upstream['FUEL'].str[3:6] == \"INT\"),\n 'TECHNOLOGY'] = 'MIN'+df_oar_upstream['FUEL']\n\n # Above should get all the outputs for the MIN technologies, but we need to adjust the mode 2 ones to just the fuel code (rather than MINCOAINT)\n df_oar_upstream.loc[df_oar_upstream['MODE_OF_OPERATION']==2,\n 'TECHNOLOGY'] = 'MIN'+df_oar_upstream['FUEL'].str[0:3]+df_oar_upstream['TECHNOLOGY'].str[6:9]\n df_oar_upstream.loc[df_oar_upstream['MODE_OF_OPERATION']==2,\n 'FUEL'] = df_oar_upstream['FUEL'].str[0:3]\n\n # Now remove the duplicate fuels that the above created (because there's now a COA for each country, not each region, and GAS is repeated twice for each region as well):\n df_oar_upstream.drop_duplicates(keep='first',inplace=True)\n return df_oar_upstream\n\n\ndef input_activity_ratio(df_oar, thermal_fuel_list_iar, renewables_list, df_gen_2, region_name):\n # #### InputActivityRatio - Power Generation Technologies\n # Copy OAR table with all columns to IAR\n df_iar = df_oar.copy()\n\n df_iar['FUEL'] = 0\n\n # Deal with GAS techs first... OCG and CCG\n # OCG Mode 1: Domestic GAS\n df_iar.loc[(df_iar['MODE_OF_OPERATION'] == 1) &\n (df_iar['TECHNOLOGY'].str[3:6].isin(['OCG'])),\n 'FUEL'] = 'GAS'+df_iar['TECHNOLOGY'].str[6:9]\n # OCG Mode 2: International GAS\n df_iar.loc[(df_iar['MODE_OF_OPERATION'] == 2) &\n (df_iar['TECHNOLOGY'].str[3:6].isin(['OCG'])),\n 'FUEL'] = 'GASINT'\n\n # CCG Mode 1: Domestic GAS\n df_iar.loc[(df_iar['MODE_OF_OPERATION'] == 1) &\n (df_iar['TECHNOLOGY'].str[3:6].isin(['CCG'])),\n 'FUEL'] = 'GAS'+df_iar['TECHNOLOGY'].str[6:9]\n\n # CCG Mode 2: International GAS\n df_iar.loc[(df_iar['MODE_OF_OPERATION'] == 2) &\n (df_iar['TECHNOLOGY'].str[3:6].isin(['CCG'])),\n 'FUEL'] = 'GASINT'\n\n # For non-GAS thermal fuels, domestic fuel input by country in mode 1 and\n # 'international' fuel input in mode 2\n df_iar.loc[(df_iar['MODE_OF_OPERATION'] == 1) &\n (df_iar['TECHNOLOGY'].str[3:6].isin(thermal_fuel_list_iar)),\n 'FUEL'] = df_iar['TECHNOLOGY'].str[3:9]\n\n df_iar.loc[(df_iar['MODE_OF_OPERATION'] == 2) &\n (df_iar['TECHNOLOGY'].str[3:6].isin(thermal_fuel_list_iar)),\n 'FUEL'] = df_iar['TECHNOLOGY'].str[3:6] + 'INT'\n\n # For renewable fuels, input by node in mode 1\n df_iar.loc[(df_iar['MODE_OF_OPERATION'] == 1) &\n (df_iar['TECHNOLOGY'].str[3:6].isin(renewables_list)),\n 'FUEL'] = df_iar['TECHNOLOGY'].str[3:11]\n\n # Remove mode 2 when not used\n df_iar = df_iar.loc[df_iar['FUEL'] != 0]\n\n # ### Calculate average InputActivityRatio by node+technology and only by technology\n df_eff_node, df_eff_tech = average_inputactivityratio_by_node_tech(df_gen_2)\n\n # Join efficiency columns: one with node and technology average, and the\n # other with technology average\n df_iar = df_iar.join(df_eff_node.set_index(['tech_code', 'node_code']),\n on=['tech_code', 'node_code'])\n\n df_iar = df_iar.join(df_eff_tech.set_index('tech_code'),\n on='tech_code')\n\n # When available, choose node and technology average. Else,\n # choose technology average\n df_iar['VALUE'] = df_iar['node_average_iar']\n df_iar.loc[df_iar['VALUE'].isna(),\n 'VALUE'] = df_iar['tech_average_iar']\n\n # Add 'REGION' column and fill 'GLOBAL' throughout\n df_iar['REGION'] = region_name\n\n # Select columns for final output table\n df_iar_final = df_iar[['REGION',\n 'TECHNOLOGY',\n 'FUEL',\n 'MODE_OF_OPERATION',\n 'YEAR',\n 'VALUE',]]\n\n # Don't write this yet - we'll write both IAR and OAR at the end...\n # df_iar_final.to_csv(r\"output/InputActivityRatio.csv\", index = None)\n return df_iar_final\n\n\ndef output_activity_ratios(df_ratios, thermal_fuel_list, region_name):\n \"\"\"OutputActivityRatio - Power Generation Technologies\n \"\"\"\n df_oar = df_ratios.copy()\n mask = df_oar['TECHNOLOGY'].apply(lambda x: x[3:6] in thermal_fuel_list)\n df_oar['FUEL'] = 0\n df_oar['FUEL'][mask] = 1\n df_oar = df_oar.loc[~((df_oar['MODE_OF_OPERATION'] > 1) &\n (df_oar['FUEL'] == 0))]\n df_oar['FUEL'] = ('ELC' +\n df_oar['TECHNOLOGY'].str[6:11] +\n '01'\n )\n df_oar['VALUE'] = 1\n\n # Add 'REGION' column and fill 'GLOBAL' throughout\n df_oar['REGION'] = region_name\n\n # Select columns for final output table\n df_oar_final = df_oar[['REGION',\n 'TECHNOLOGY',\n 'FUEL',\n 'MODE_OF_OPERATION',\n 'YEAR',\n 'VALUE',]]\n return df_oar, df_oar_final\n\n\ndef create_generators(df, df_dict, model_start_year, df_op_life, df_tech_code):\n df_gen_2 = create_main_generator_table(df)\n df_dict_2 = compile_powerplants_nodes_fuels(df_dict)\n\n ## Merge original generator dataframe with nodes and fuels\n df_gen_2 = pd.merge(df_gen_2, df_dict_2, how=\"outer\", on=\"powerplant\")\n df_gen_2.rename(\n {\"child_object_x\": \"fuel\", \"child_object_y\": \"node\"}, axis=1, inplace=True\n )\n\n ## Extract start year from Commission Date\n df_gen_2[\"Commission Date\"] = pd.to_datetime(df_gen_2[\"Commission Date\"])\n df_gen_2[\"start_year\"] = df_gen_2[\"Commission Date\"].dt.year\n df_gen_2.drop(\"Commission Date\", axis=1, inplace=True)\n\n ## Calculate efficiency from heat rate. Units of heat rate in MJ/kWh\n df_gen_2[\"efficiency\"] = 3.6 / df_gen_2[\"Heat Rate\"].astype(float)\n df_gen_2.drop(\"Heat Rate\", axis=1, inplace=True)\n\n ## Calcluate years of operation from start year until 2015\n df_gen_2[\"years_of_operation\"] = model_start_year - df_gen_2[\"start_year\"]\n\n ## Fix blank spaces in 'fuels' columns. Appearing for 'Oil' powerplants in certain countries\n df_gen_2.loc[df_gen_2[\"fuel\"].isna(), \"fuel\"] = (\n df_gen_2[\"node\"].str.split(\"-\").str[:2].str.join(\"-\")\n + \" \"\n + df_gen_2[\"powerplant\"].str.split(\"_\", expand=True)[1]\n )\n\n ## Create column for technology\n df_gen_2[\"technology\"] = df_gen_2[\"powerplant\"].str.split(\"_\").str[1]\n df_gen_2[\"technology\"] = df_gen_2[\"technology\"].str.title()\n\n ## Divide Gas into CCGT and OCGT based on max capacity\n df_gen_2.loc[\n (df_gen_2[\"technology\"] == \"Gas\") & (df_gen_2[\"Max Capacity\"].astype(float) > 130),\n \"technology\",\n ] = \"Gas-CCGT\"\n df_gen_2.loc[\n (df_gen_2[\"technology\"] == \"Gas\") & (df_gen_2[\"Max Capacity\"].astype(float) <= 130),\n \"technology\",\n ] = \"Gas-OCGT\"\n\n # Add region and country code columns\n df_gen_2['region_code'] = df_gen_2['node'].str[:2]\n df_gen_2['country_code'] = df_gen_2['node'].str[3:]\n\n # ### Add operational life column\n op_life_dict = dict(zip(list(df_op_life['tech']),\n list(df_op_life['years'])))\n\n df_gen_2['operational_life'] = df_gen_2['technology'].map(op_life_dict)\n df_gen_2['retirement_year_data'] = (df_gen_2['operational_life']\n + df_gen_2['start_year'])\n df_gen_2['retirement_diff'] = ((df_gen_2['years_of_operation']\n - df_gen_2['operational_life'])/\n df_gen_2['operational_life'])\n\n ''' Set retirement year based on years of operation.\n If (years of operation - operational life) is more than 50% of\n operational life, set retirement year\n '''\n df_gen_2.loc[df_gen_2['retirement_diff'] >= 0.5,\n 'retirement_year_model'] = 2025\n df_gen_2.loc[(df_gen_2['retirement_diff'] < 0.5) &\n (df_gen_2['retirement_diff'] > 0),\n 'retirement_year_model'] = 2030\n df_gen_2.loc[df_gen_2['retirement_diff'] <= 0,\n 'retirement_year_model'] = df_gen_2['retirement_year_data']\n\n # ### Add naming convention\n tech_code_dict = dict(zip(list(df_tech_code['tech']),\n list(df_tech_code['code'])))\n df_gen_2['tech_code'] = df_gen_2['technology'].map(tech_code_dict)\n\n df_gen_2.loc[df_gen_2['node'].str.len() <= 6,\n 'node_code'] = (df_gen_2['node'].\n str.split('-').\n str[1:].\n str.join(\"\") +\n 'XX')\n df_gen_2.loc[df_gen_2['node'].str.len() > 6,\n 'node_code'] = (df_gen_2['node'].\n str.split('-').\n str[1:].\n str.join(\"\")\n )\n\n df_gen_2 = df_gen_2.loc[~df_gen_2['tech_code'].isna()]\n\n return df_gen_2\n\n\ndef residual_capacity(df_gen_2, model_start_year, model_end_year, region_name):\n \"\"\"Calculate residual capacity\"\"\"\n res_cap_cols = [\n \"node_code\",\n \"tech_code\",\n \"total_capacity\",\n \"start_year\",\n \"retirement_year_model\",\n ]\n\n df_res_cap = df_gen_2[res_cap_cols]\n\n for each_year in range(model_start_year, model_end_year+1):\n df_res_cap[str(each_year)] = 0\n\n df_res_cap = pd.melt(\n df_res_cap,\n id_vars=res_cap_cols,\n value_vars=[x for x in df_res_cap.columns if x not in res_cap_cols],\n var_name=\"model_year\",\n value_name=\"value\",\n )\n df_res_cap[\"model_year\"] = df_res_cap[\"model_year\"].astype(int)\n df_res_cap.loc[\n (df_res_cap[\"model_year\"] >= df_res_cap[\"start_year\"])\n & (df_res_cap[\"model_year\"] <= df_res_cap[\"retirement_year_model\"]),\n \"value\",\n ] = df_res_cap[\"total_capacity\"]\n\n df_res_cap = df_res_cap.groupby(\n [\"node_code\", \"tech_code\", \"model_year\"], as_index=False\n )[\"value\"].sum()\n\n # Add column with naming convention\n df_res_cap['node_code'] = df_res_cap['node_code']\n df_res_cap['tech'] = ('PWR' +\n df_res_cap['tech_code'] +\n df_res_cap['node_code'] + '01'\n )\n # Convert total capacity from MW to GW\n df_res_cap['value'] = df_res_cap['value'].div(1000)\n\n\n df_res_cap_plot = df_res_cap[['node_code',\n 'tech_code',\n 'model_year',\n 'value']]\n\n # Rename 'model_year' to 'year' and 'total_capacity' to 'value'\n df_res_cap.rename({'tech':'TECHNOLOGY',\n 'model_year':'YEAR',\n 'value':'VALUE'},\n inplace = True,\n axis=1)\n # Drop 'tech_code' and 'node_code'\n df_res_cap.drop(['tech_code', 'node_code'], inplace = True, axis=1)\n\n # Add 'REGION' column and fill 'GLOBAL' throughout\n df_res_cap['REGION'] = region_name\n\n #Reorder columns\n df_res_cap = df_res_cap[['REGION', 'TECHNOLOGY', 'YEAR', 'VALUE']]\n return df_res_cap\n\n\ndef average_inputactivityratio_by_node_tech(df_gen_2):\n \"\"\"Calculate average InputActivityRatio by node+technology and only by technology\n \"\"\"\n df_eff = df_gen_2[['node_code',\n 'efficiency',\n 'tech_code']]\n\n # Average efficiency by node and technology\n df_eff_node = df_eff.groupby(['tech_code',\n 'node_code'],\n as_index = False).agg('mean')\n\n df_eff_node['node_average_iar'] = ((1 / df_eff_node['efficiency']).\n round(2))\n\n df_eff_node.drop('efficiency',\n axis = 1,\n inplace = True)\n\n # Average efficiency by technology\n df_eff_tech = df_eff.groupby('tech_code',\n as_index = False).agg('mean')\n\n df_eff_tech['tech_average_iar'] = ((1 / df_eff_tech['efficiency']).\n round(2))\n\n df_eff_tech.drop('efficiency',\n axis = 1,\n inplace = True)\n return df_eff_node, df_eff_tech\n\n\ndef final_costs(each_cost, df_costs, df_oar_final, weo_regions_dict):\n df_costs_temp = df_costs.loc[df_costs['parameter'].str.contains(each_cost)]\n df_costs_temp.drop(['technology', 'parameter'],\n axis = 1,\n inplace = True)\n df_costs_final = df_oar_final[['REGION',\n 'TECHNOLOGY',\n 'YEAR'\n ]]\n df_costs_final['YEAR'] = df_costs_final['YEAR'].astype(int)\n df_costs_final = df_costs_final.drop_duplicates()\n df_costs_final = (df_costs_final\n .loc[(df_costs_final['TECHNOLOGY']\n .str.startswith('PWR')\n ) &\n (~df_costs_final['TECHNOLOGY']\n .str.contains('TRN')\n )\n ]\n )\n df_costs_final['technology_code'] = df_costs_final['TECHNOLOGY'].str[3:6]\n df_costs_final['weo_region'] = df_costs_final['TECHNOLOGY'].str[6:9]\n df_costs_final['weo_region'] = (df_costs_final['weo_region']\n .replace(weo_regions_dict))\n\n df_costs_final = pd.merge(df_costs_final,\n df_costs_temp,\n on = ['technology_code', 'weo_region', 'YEAR'],\n how = 'left'\n )\n df_costs_final.drop(['technology_code', 'weo_region'],\n axis = 1,\n inplace = True)\n df_costs_final = df_costs_final.fillna(-9)\n df_costs_final = pd.pivot_table(df_costs_final,\n index = ['REGION', 'YEAR'],\n columns = 'TECHNOLOGY',\n values = 'value').reset_index()\n df_costs_final = df_costs_final.replace([-9],[np.nan])\n #df_costs_final.set_index(['REGION', 'YEAR'],\n # inplace = True)\n\n\n df_costs_final = df_costs_final.interpolate(method = 'linear',\n limit_direction='forward').round(2)\n df_costs_final = df_costs_final.interpolate(method = 'linear',\n limit_direction='backward').round(2)\n df_costs_final = pd.melt(df_costs_final,\n id_vars = ['REGION', 'YEAR'],\n value_vars = [x for x in df_costs_final.columns\n if x not in ['REGION', 'YEAR']\n ],\n var_name = 'TECHNOLOGY',\n value_name = 'VALUE'\n )\n df_costs_final = df_costs_final[['REGION', 'TECHNOLOGY', 'YEAR', 'VALUE']]\n df_costs_final = df_costs_final[~df_costs_final['VALUE'].isnull()]\n return df_costs_final\n\n\ndef create_weo_region_mapping(df_weo_regions):\n weo_regions_dict = dict([(k, v)\n for k, v\n in zip(df_weo_regions['technology_code'],\n df_weo_regions['weo_region']\n )\n ]\n )\n return weo_regions_dict\n\n\ndef capital_fixed_var_costs(df_weo_data):\n # ### Costs: Capital, fixed, and variable\n\n df_costs = pd.melt(df_weo_data,\n id_vars = ['technology', 'weo_region', 'parameter'],\n value_vars = ['2017', '2030', '2040'],\n var_name = ['YEAR'])\n df_costs['parameter'] = df_costs['parameter'].str.split('\\r\\n').str[0]\n df_costs['value'] = df_costs['value'].replace({'n.a.':0})\n df_costs['value'] = df_costs['value'].astype(float)\n df_costs = df_costs.pivot_table(index = ['technology', 'parameter', 'YEAR'],\n columns = 'weo_region',\n values = 'value').reset_index()\n df_costs['AS_average'] = (df_costs['China'] +\n df_costs['India'] +\n df_costs['Japan'] +\n df_costs['Middle East']).div(4)\n df_costs['NA_average'] = (df_costs['United States'])\n df_costs['SA_average'] = (df_costs['Brazil'])\n df_costs['Global_average'] = (df_costs['Africa'] +\n df_costs['Brazil'] +\n df_costs['Europe'] +\n df_costs['China'] +\n df_costs['India'] +\n df_costs['Japan'] +\n df_costs['Middle East'] +\n df_costs['Russia'] +\n df_costs['United States']).div(9)\n df_costs = pd.melt(df_costs,\n id_vars = ['technology', 'parameter', 'YEAR'],\n value_vars = [x\n for x\n in df_costs.columns\n if x not in ['technology', 'parameter', 'YEAR']\n ]\n )\n df_costs['YEAR'] = df_costs['YEAR'].astype(int)\n costs_dict = {'Biomass - waste incineration - CHP':'WAS',\n 'Biomass Power plant':'BIO',\n 'CCGT':'CCG',\n 'CCGT - CHP':'COG',\n 'Concentrating solar power':'CSP',\n 'Gas turbine':'OCG',\n 'Geothermal':'GEO',\n 'Hydropower - large-scale':'HYD',\n 'Marine':'WAV',\n 'Nuclear':'URN',\n 'Solar photovoltaics - Large scale':'SPV',\n 'Steam Coal - SUBCRITICAL':'COA',\n 'Steam Coal - SUPERCRITICAL':'COA',\n 'Steam Coal - ULTRASUPERCRITICAL':'COA',\n 'Wind onshore':'WON'} # Missing OIL, OTH, PET, WOF\n\n df_costs = df_costs.loc[df_costs['technology'].isin(costs_dict.keys())]\n df_costs['technology_code'] = df_costs['technology'].replace(costs_dict)\n return df_costs\n\n\ndef ratio_master_table(df_gen_2, years):\n # Create master table for activity ratios\n node_list = list(df_gen_2['node_code'].unique())\n\n # Add extra nodes which are not present in 2015 but will be by 2050\n nodes_extra_list = ['AF-SOM', 'AF-TCD', 'AS-TLS', 'EU-MLT', 'NA-BLZ', 'NA-HTI', 'SA-BRA-J1', 'SA-BRA-J2', 'SA-BRA-J3', 'SA-SUR']\n for each_node in nodes_extra_list:\n if len(each_node) <= 6:\n node_list.append(\"\".join(each_node.split('-')[1:]) + 'XX')\n else:\n node_list.append(\"\".join(each_node.split('-')[1:]))\n\n master_fuel_list = list(df_gen_2['tech_code'].unique())\n\n df_ratios = pd.DataFrame(list(itertools.product(node_list,\n master_fuel_list,\n MODE_LIST,\n years)\n ),\n columns=['node_code', 'tech_code', 'MODE_OF_OPERATION', 'YEAR']\n )\n\n df_ratios['TECHNOLOGY'] = ('PWR' +\n df_ratios['tech_code'] +\n df_ratios['node_code'] + '01'\n )\n return df_ratios\n\n\ndef get_years(model_start_year, model_end_year):\n return list(range(model_start_year,\n model_end_year + 1))\n\n\ndef main(INPUT_PATH, OUTPUT_PATH, model_start_year=2015, model_end_year=2050, region_name='GLOBAL'):\n df, df_dict = get_data(INPUT_PATH)\n\n df_weo_data = pd.read_csv(os.path.join(INPUT_PATH, \"weo_2018_powerplant_costs.csv\"))\n df_op_life = pd.read_csv(os.path.join(INPUT_PATH, \"operational_life.csv\"))\n df_tech_code = pd.read_csv(os.path.join(INPUT_PATH, \"naming_convention_tech.csv\"))\n df_trn_efficiencies = pd.read_excel(os.path.join(INPUT_PATH, \"Costs Line expansion.xlsx\"))\n df_weo_regions = pd.read_csv(os.path.join(INPUT_PATH, \"weo_region_mapping.csv\"))\n\n emissions = []\n\n # Create 'output' directory if it doesn't exist\n if not os.path.exists(OUTPUT_PATH):\n os.makedirs(OUTPUT_PATH)\n\n df_gen_2 = create_generators(df, df_dict, model_start_year, df_op_life, df_tech_code)\n\n df_res_cap = residual_capacity(df_gen_2, model_start_year, model_end_year, region_name)\n\n filepath = os.path.join(OUTPUT_PATH, 'ResidualCapacity.csv')\n df_res_cap.to_csv(filepath, index=None)\n\n # ### Add input and output activity ratios\n\n\n\n thermal_fuel_list = ['COA', 'COG', 'OCG', 'CCG', 'PET', 'URN', 'OIL', 'OTH']\n thermal_fuel_list_iar = ['COA', 'COG', 'PET', 'URN', 'OIL', 'OTH']\n renewables_list = ['BIO', 'GEO', 'HYD', 'SPV', 'CSP', 'WAS', 'WAV', 'WON', 'WOF']\n\n # Calculate Input and OutputActivityRatio for: Power Generation\n df_oar_final, df_iar_final = calculate_activity_ratios(thermal_fuel_list, region_name,\n thermal_fuel_list_iar, renewables_list,\n df_gen_2, df, model_start_year,\n model_end_year, df_trn_efficiencies)\n\n filepath = os.path.join(OUTPUT_PATH, \"OutputActivityRatio.csv\")\n df_oar_final.to_csv(filepath, index=None)\n filepath = os.path.join(OUTPUT_PATH, \"InputActivityRatio.csv\")\n df_iar_final.to_csv(filepath, index=None)\n\n\n # ### Costs: Capital, fixed, and variable\n df_costs = capital_fixed_var_costs(df_weo_data)\n weo_regions_dict = create_weo_region_mapping(df_weo_regions)\n capex = final_costs(\"Capital\", df_costs, df_oar_final, weo_regions_dict)\n capex.to_csv(os.path.join(OUTPUT_PATH, 'CapitalCost.csv'), index=None)\n fixed = final_costs(\"O&M\", df_costs, df_oar_final, weo_regions_dict)\n fixed.to_csv(os.path.join(OUTPUT_PATH, 'FixedCost.csv'), index=None)\n\n # ## Create sets for TECHNOLOGIES, FUELS\n def create_sets(x: str) -> None:\n set_elements = list(df_iar_final[x].unique()) + list(df_oar_final[x].unique())\n set_elements = list(set(set_elements))\n set_elements.sort()\n set_elements_df = pd.DataFrame(set_elements, columns=['VALUE'])\n return set_elements_df.to_csv(os.path.join(OUTPUT_PATH, str(x) + '.csv'),\n index=None\n )\n\n create_sets('TECHNOLOGY')\n create_sets('FUEL')\n\n # ## Create set for YEAR, REGION, MODE_OF_OPERATION\n years = get_years(model_start_year, model_end_year)\n years_df = pd.DataFrame(years, columns=['VALUE'])\n years_df.to_csv(os.path.join(OUTPUT_PATH, 'YEAR.csv'),\n index=None)\n\n mode_list_df = pd.DataFrame(MODE_LIST, columns=['VALUE'])\n mode_list_df.to_csv(os.path.join(OUTPUT_PATH, 'MODE_OF_OPERATION.csv'),\n index=None)\n\n regions_df = pd.DataFrame(columns=['VALUE'])\n regions_df.loc[0] = region_name\n regions_df.to_csv(os.path.join(OUTPUT_PATH, 'REGION.csv'),\n index=None)\n\n # ## Create set for EMISSION\n emissions_df = pd.DataFrame(emissions, columns=['VALUE'])\n emissions_df.to_csv(os.path.join(OUTPUT_PATH, 'EMISSION.csv'),\n index=None)\n\n\n\nif __name__ == \"__main__\":\n\n args = sys.argv[1:]\n if len(args) != 2:\n print(\"Usage: python OPG_powerplant_data \")\n exit(1)\n\n input_path = args[0]\n output_path = args[1]\n\n main(input_path, output_path)", "meta": {"hexsha": "2b6089554cc58f31c96f9b84e924a2f525fef962", "size": 36952, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/osemosys_global/OPG_powerplant_data.py", "max_stars_repo_name": "ClimateCompatibleGrowth/osemosys_global", "max_stars_repo_head_hexsha": "a7ac030c21aec75e39aa3cba5cb2b92860fd6ab5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/osemosys_global/OPG_powerplant_data.py", "max_issues_repo_name": "ClimateCompatibleGrowth/osemosys_global", "max_issues_repo_head_hexsha": "a7ac030c21aec75e39aa3cba5cb2b92860fd6ab5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/osemosys_global/OPG_powerplant_data.py", "max_forks_repo_name": "ClimateCompatibleGrowth/osemosys_global", "max_forks_repo_head_hexsha": "a7ac030c21aec75e39aa3cba5cb2b92860fd6ab5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.3796192609, "max_line_length": 173, "alphanum_fraction": 0.5999134012, "include": true, "reason": "import numpy", "num_tokens": 9715, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5195213368305399, "lm_q2_score": 0.36658975016245987, "lm_q1q2_score": 0.1904511970727748}} {"text": "# Copyright (c) Stanford University, The Regents of the University of\n# California, and others.\n#\n# All Rights Reserved.\n#\n# See Copyright-SimVascular.txt for additional details.\n#\n# Permission is hereby granted, free of charge, to any person obtaining\n# a copy of this software and associated documentation files (the\n# \"Software\"), to deal in the Software without restriction, including\n# without limitation the rights to use, copy, modify, merge, publish,\n# distribute, sublicense, and/or sell copies of the Software, and to\n# permit persons to whom the Software is furnished to do so, subject\n# to the following conditions:\n#\n# The above copyright notice and this permission notice shall be included\n# in all copies or substantial portions of the Software.\n#\n# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS\n# IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED\n# TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A\n# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER\n# OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\n# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\n# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF\n# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING\n# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\n# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n#\nimport os\nfrom sv_ml.base.model import AbstractModel\nimport numpy as np\nimport tensorflow as tf\nimport sv_ml.modules.layers as tf_util\n\n# import matplotlib\n# matplotlib.use('Agg')\n# import matplotlib.pyplot as plt\n\nimport sv_ml.modules.vessel_regression as vr\n\ndef get_batch(X,Y, batch_size=16):\n ids = np.random.choice(X.shape[0], size=batch_size)\n\n x = np.array([X[i] for i in ids])\n y = np.array([Y[i] for i in ids])\n\n return x,y\n\nclass Model(AbstractModel):\n def setup(self):\n self.start_iter = 0\n self.build_model()\n self.configure_trainer()\n self.finalize()\n\n self.losses = []\n self.iters = []\n\n def train_step(self,x,y):\n self.global_step = self.global_step+1\n\n if np.sum(np.isnan(x)) > 0: return\n if np.sum(np.isnan(y)) > 0: return\n\n self.sess.run(self.train_op,{self.x:x,self.y:y})\n\n def save(self, model_path=None):\n if model_path == None:\n model_path = os.path.join(self.config['MODEL_DIR'], self.config['MODEL_NAME'])\n else:\n model_path = os.path.join(model_path, self.config['MODEL_NAME'])\n self.saver.save(self.sess,model_path)\n\n def load(self, model_path=None):\n if model_path == None:\n model_path = os.path.join(self.config['MODEL_DIR'],self.config['MODEL_NAME'])\n else:\n model_path = os.path.join(model_path,self.config['MODEL_NAME'])\n self.saver.restore(self.sess, model_path)\n\n def predict(self,x):\n S = list(x.shape)\n if len(S) == 3:\n x_ = x.reshape([1]+S)\n return self._predict(x_)[0]\n else:\n out = []\n for i in range(S[0]):\n x_ = x[i].reshape([1]+S[1:4])\n y = self._predict(x_)[0].copy()\n out.append(y)\n return np.array(out)\n\n def calculate_loss(self,x,y):\n return self.sess.run(self.loss,{self.x:x,self.y:y})\n\n def build_model(self):\n raise RuntimeError(\"Abstract not implemented\")\n\n def build_loss(self):\n self.loss = tf.reduce_mean(tf.square(self.y-self.yhat))\n\n def configure_trainer(self):\n LEARNING_RATE = self.config[\"LEARNING_RATE\"]\n self.global_step = tf.Variable(0, trainable=False)\n boundaries = [2000,\n 5000,\n 10000,\n 15000,\n 150000]\n\n values = [LEARNING_RATE,\n LEARNING_RATE/3,\n LEARNING_RATE/10,\n LEARNING_RATE/100,\n LEARNING_RATE/1000,\n LEARNING_RATE/10000,]\n\n learning_rate = tf.train.piecewise_constant(self.global_step, boundaries, values)\n\n\n self.opt = tf.train.AdamOptimizer(learning_rate)\n\n #self.opt = tf.train.MomentumOptimizer(learning_rate, momentum=0.9)\n self.train_op = self.opt.minimize(self.loss)\n\n def train(self, X,Y):\n for i in range(self.start_iter,\n self.config['TRAIN_STEPS']+self.start_iter):\n x,y = get_batch(X,Y, self.config['BATCH_SIZE'])\n\n\n\n self.train_step(x,y)\n\n if i % self.config['LOG_STEP'] == 0:\n l = self.calculate_loss(x,y)\n self.losses.append(l)\n self.iters.append(i)\n\n self.log(i,x,y)\n self.log(i,X[:4],Y[:4])\n self.save()\n\n def _predict(self,x):\n return self.sess.run(self.yhat,{self.x:x})\n\n def finalize(self):\n self.sess = tf.Session()\n self.sess.run(tf.global_variables_initializer())\n\n def log(self,i,x,y):\n pass\n # f = open(self.config['ITER_FILE'], 'w')\n # f.write(str(i))\n # f.close()\n #\n # l = self.calculate_loss(x,y)\n # yhat = self.predict(x)[0]\n #\n # print(\"{}: loss={}\\n\".format(i,l))\n # print(\"yhat = {}\".format(yhat))\n #\n # f = open(self.config[\"LOG_FILE\"],\"a+\")\n # f.write(\"{}: loss={}\\n\".format(i,l))\n # f.write(\"{}: yhat={}\\n\".format(i,yhat))\n # f.close()\n #\n # self.save()\n #\n # x_ = x[0,:,:,0]\n # y_ = y[0]\n # if self.config['DATASET'] == 'axial2d_point':\n # ctrue = vr.point_pred_to_contour(y_)\n # cpred = vr.point_pred_to_contour(yhat)\n #\n # else:\n # ctrue = vr.pred_to_contour(y_)\n # cpred = vr.pred_to_contour(yhat)\n #\n # plt.figure()\n # plt.imshow(x_,cmap='gray',extent=[-1, 1, 1, -1])\n # plt.colorbar()\n # plt.scatter(cpred[:,0], cpred[:,1], color='r', label='predicted',s=4)\n # plt.scatter(ctrue[:,0], ctrue[:,1], color='y', label='true', s=4)\n # plt.show()\n # plt.close()\n #\n # W = x_.shape[0]\n # s = int(0.25*W)\n # e = int(0.75*W)\n #\n # plt.figure()\n # plt.imshow(x_[s:e,s:e],cmap='gray',extent=[-0.5, 0.5, 0.5, -0.5])\n # plt.colorbar()\n # plt.scatter(cpred[:,0], cpred[:,1], color='r', label='predicted',s=4)\n # plt.scatter(ctrue[:,0], ctrue[:,1], color='y', label='true', s=4)\n # plt.show()\n # plt.close()\n #\n #\n # c = self.config\n # log_dir = c['RESULTS_DIR']+'/'+c['NAME']+'/log/'\n #\n # plt.figure()\n # plt.plot(self.iters, self.losses)\n # plt.savefig(log_dir+'loss.png',dpi=300)\n # plt.close()\n #\n # plt.figure()\n # plt.plot(self.iters, self.losses)\n # plt.ylim(0,1)\n # plt.savefig(log_dir+'loss_1.png',dpi=300)\n # plt.close()\n #\n # plt.figure()\n # plt.plot(self.iters, self.losses)\n # plt.ylim(0,0.1)\n # plt.savefig(log_dir+'loss_2.png',dpi=300)\n # plt.close()\n #\n # plt.figure()\n # plt.plot(self.iters, self.losses)\n # plt.ylim(0,0.01)\n # plt.savefig(log_dir+'loss_3.png',dpi=300)\n # plt.close()\n\nclass FcNet(Model):\n def build_model(self):\n CROP_DIMS = self.config['CROP_DIMS']\n LEAK = self.config['LEAK']\n C = self.config['NUM_CHANNELS']\n LAMBDA = self.config['L2_REG']\n INIT = self.config['INIT']\n NUM_POINTS = self.config['NUM_CONTOUR_POINTS']\n\n leaky_relu = tf.contrib.keras.layers.LeakyReLU(LEAK)\n\n self.x = tf.placeholder(shape=[None,CROP_DIMS,CROP_DIMS,C],dtype=tf.float32)\n self.y = tf.placeholder(shape=[None,NUM_POINTS],dtype=tf.float32)\n\n o = self.x\n if \"INPUT_POOL\" in self.config:\n d = self.config['INPUT_POOL']\n\n o = tf.nn.pool(o, [d,d], \"MAX\", \"VALID\", strides=[d,d])\n\n s = o.get_shape().as_list()\n\n o_vec = tf.reshape(o,shape=[-1,s[1]*s[2]*s[3]])\n\n for i,h in enumerate(self.config['HIDDEN_SIZES']):\n\n o_vec = tf_util.fullyConnected(o_vec, h,\n leaky_relu, std=INIT, scope='fc_'+str(i))\n\n if \"DROPOUT\" in self.config:\n o_vec = tf.nn.dropout(o_vec, self.config['DROPOUT'])\n\n self.yhat = tf_util.fullyConnected(o_vec, NUM_POINTS,\n tf.sigmoid, std=INIT, scope='fc_final')\n\n self.build_loss()\n\n self.saver = tf.train.Saver()\n\nclass I2INetReg(Model):\n def build_model(self):\n CROP_DIMS = self.config['CROP_DIMS']\n C = self.config['NUM_CHANNELS']\n LEAK = self.config['LEAK']\n NUM_FILTERS = self.config['NUM_FILTERS']\n LAMBDA = self.config['L2_REG']\n INIT = self.config['INIT']\n NUM_POINTS = self.config['NUM_CONTOUR_POINTS']\n\n leaky_relu = tf.contrib.keras.layers.LeakyReLU(LEAK)\n\n self.x = tf.placeholder(shape=[None,CROP_DIMS,CROP_DIMS,C],dtype=tf.float32)\n self.y = tf.placeholder(shape=[None,NUM_POINTS],dtype=tf.float32)\n\n self.yclass,self.yhat,_,_ = tf_util.I2INet(self.x,nfilters=NUM_FILTERS,\n activation=leaky_relu,init=INIT)\n\n o = leaky_relu(self.yhat)\n\n s = o.get_shape().as_list()\n\n o_vec = tf.reshape(o,shape=[-1,s[1]*s[2]*s[3]])\n\n for i in range(self.config['FC_LAYERS']-1):\n if \"HIDDEN_SIZES\" in self.config:\n h = self.config['HIDDEN_SIZES'][i]\n else:\n h = self.config['HIDDEN_SIZE']\n\n o_vec = tf_util.fullyConnected(o_vec, h,\n leaky_relu, std=INIT, scope='fc_'+str(i))\n\n self.yhat = tf_util.fullyConnected(o_vec, NUM_POINTS,\n tf.identity, std=INIT, scope='fc_final')\n\n self.build_loss()\n\n self.saver = tf.train.Saver()\n\nclass ResNetReg(Model):\n def build_model(self):\n CROP_DIMS = self.config['CROP_DIMS']\n C = self.config['NUM_CHANNELS']\n LEAK = self.config['LEAK']\n LAMBDA = self.config['L2_REG']\n INIT = self.config['INIT']\n\n NLAYERS = int(self.config['NLAYERS']/2)\n NFILTERS_SMALL = self.config['NFILTERS_SMALL']\n NFILTERS_LARGE = self.config['NFILTERS_LARGE']\n\n NUM_POINTS = self.config['NUM_CONTOUR_POINTS']\n\n leaky_relu = tf.contrib.keras.layers.LeakyReLU(LEAK)\n\n self.x = tf.placeholder(shape=[None,CROP_DIMS,CROP_DIMS,C],dtype=tf.float32)\n self.y = tf.placeholder(shape=[None,NUM_POINTS],dtype=tf.float32)\n\n self.yclass,self.yhat,_,_ = tf_util.resNet(self.x,\n nlayers_before=NLAYERS, nlayers_after=NLAYERS,\n nfilters=NFILTERS_SMALL, nfilters_large=NFILTERS_LARGE,\n output_filters=NFILTERS_LARGE, activation=leaky_relu, init=INIT)\n\n o = leaky_relu(self.yhat)\n\n d = self.config['POOL']\n\n o = tf.nn.pool(o, [d,d], \"MAX\", \"VALID\", strides=[d,d])\n\n s = o.get_shape().as_list()\n\n o_vec = tf.reshape(o,shape=[-1,s[1]*s[2]*s[3]])\n\n for i in range(self.config['FC_LAYERS']):\n if \"HIDDEN_SIZES\" in self.config:\n h = self.config['HIDDEN_SIZES'][i]\n else:\n h = self.config['HIDDEN_SIZE']\n\n o_vec = tf_util.fullyConnected(o_vec, h,\n leaky_relu, std=INIT, scope='fc_'+str(i))\n\n self.yhat = tf_util.fullyConnected(o_vec, NUM_POINTS,\n tf.sigmoid, std=INIT, scope='fc_final')\n\n self.build_loss()\n\n self.saver = tf.train.Saver()\n\nclass ResNetRegMultiscale(Model):\n def build_model(self):\n CROP_DIMS = self.config['CROP_DIMS']\n C = self.config['NUM_CHANNELS']\n LEAK = self.config['LEAK']\n LAMBDA = self.config['L2_REG']\n INIT = self.config['INIT']\n\n NLAYERS = int(self.config['NLAYERS']/2)\n NFILTERS_SMALL = self.config['NFILTERS_SMALL']\n NFILTERS_LARGE = self.config['NFILTERS_LARGE']\n\n NUM_POINTS = self.config['NUM_CONTOUR_POINTS']\n\n leaky_relu = tf.contrib.keras.layers.LeakyReLU(LEAK)\n\n self.x = tf.placeholder(shape=[None,CROP_DIMS,CROP_DIMS,C],dtype=tf.float32)\n\n if self.config['MULTI_TYPE'] == \"POOL\":\n self.x_1 = tf.nn.pool(self.x, [2,2], \"MAX\", \"VALID\", strides=[2,2])\n self.x_2 = tf.nn.pool(self.x_1, [2,2], \"MAX\", \"VALID\", strides=[2,2])\n elif self.config['MULTI_TYPE'] == \"CROP\":\n self.x_1 = tf.image.central_crop(self.x, central_fraction=0.5)\n self.x_2 = tf.image.central_crop(self.x_1, central_fraction=0.5)\n else:\n raise RuntimeError(\"Unrecognized multi type\")\n\n self.y = tf.placeholder(shape=[None,NUM_POINTS],dtype=tf.float32)\n\n self.yclass,self.yhat,_,_ = tf_util.resNet(self.x,\n nlayers_before=NLAYERS, nlayers_after=NLAYERS,\n nfilters=NFILTERS_SMALL, nfilters_large=NFILTERS_LARGE,\n output_filters=NFILTERS_LARGE, activation=leaky_relu, init=INIT)\n\n self.yclass_1,self.yhat_1,_,_ = tf_util.resNet(self.x_1,\n nlayers_before=NLAYERS, nlayers_after=NLAYERS,\n nfilters=NFILTERS_SMALL, nfilters_large=NFILTERS_LARGE,\n output_filters=NFILTERS_LARGE, activation=leaky_relu, init=INIT,\n scope=\"resnet_1\")\n\n self.yclass_2,self.yhat_2,_,_ = tf_util.resNet(self.x_2,\n nlayers_before=NLAYERS, nlayers_after=NLAYERS,\n nfilters=NFILTERS_SMALL, nfilters_large=NFILTERS_LARGE,\n output_filters=NFILTERS_LARGE, activation=leaky_relu, init=INIT,\n scope=\"resnet_2\")\n\n\n o = leaky_relu(self.yhat)\n o_1 = leaky_relu(self.yhat_1)\n o_2 = leaky_relu(self.yhat_2)\n\n s = o.get_shape().as_list()\n s_1 = o_1.get_shape().as_list()\n s_2 = o_2.get_shape().as_list()\n\n o_vec = tf.reshape(o,shape=[-1,s[1]*s[2]*s[3]])\n o_vec_1 = tf.reshape(o_1,shape=[-1,s_1[1]*s_1[2]*s_1[3]])\n o_vec_2 = tf.reshape(o_2,shape=[-1,s_2[1]*s_2[2]*s_2[3]])\n\n o = tf.concat([o_vec, o_vec_1, o_vec_2], axis=1)\n\n print(o)\n\n for i in range(self.config['FC_LAYERS']-1):\n if \"HIDDEN_SIZES\" in self.config:\n h = self.config['HIDDEN_SIZES'][i]\n else:\n h = self.config['HIDDEN_SIZE']\n\n o = tf_util.fullyConnected(o, h,\n leaky_relu, std=INIT, scope='fc_'+str(i))\n\n self.yhat = tf_util.fullyConnected(o, NUM_POINTS,\n tf.identity, std=INIT, scope='fc_final')\n\n self.build_loss()\n\n self.saver = tf.train.Saver()\n\nclass ConvNet(Model):\n def build_model(self):\n CROP_DIMS = self.config['CROP_DIMS']\n C = self.config['NUM_CHANNELS']\n LEAK = self.config['LEAK']\n LAMBDA = self.config['L2_REG']\n INIT = self.config['INIT']\n\n NLAYERS = self.config['NLAYERS']\n NFILTERS = self.config['NFILTERS']\n\n NUM_POINTS = self.config['NUM_CONTOUR_POINTS']\n DIMS = [self.config['CONV_DIMS']]*2\n\n leaky_relu = tf.contrib.keras.layers.LeakyReLU(LEAK)\n\n self.x = tf.placeholder(shape=[None,CROP_DIMS,CROP_DIMS,C],dtype=tf.float32)\n self.y = tf.placeholder(shape=[None,NUM_POINTS],dtype=tf.float32)\n\n o = self.x\n\n if \"INPUT_POOL\" in self.config:\n d = self.config['INPUT_POOL']\n\n o = tf.nn.pool(o, [d,d], \"MAX\", \"VALID\", strides=[d,d])\n\n\n for i in range(NLAYERS):\n o = tf_util.conv2D(o,dims=DIMS,nfilters=NFILTERS,\n init=INIT,\n activation=leaky_relu,scope=\"conv_{}\".format(i))\n\n s = o.get_shape().as_list()\n o = tf.reshape(o,shape=[-1,s[1]*s[2]*s[3]])\n\n for i in range(self.config['FC_LAYERS']):\n if \"HIDDEN_SIZES\" in self.config:\n h = self.config['HIDDEN_SIZES'][i]\n else:\n h = self.config['HIDDEN_SIZE']\n\n o = tf_util.fullyConnected(o, h,\n leaky_relu, std=INIT, scope='fc_'+str(i))\n print(o)\n\n if \"DROPOUT\" in self.config:\n o = tf.nn.dropout(o, self.config['DROPOUT'])\n\n\n self.yhat = tf_util.fullyConnected(o, NUM_POINTS,\n tf.sigmoid, std=INIT, scope='fc_final')\n\n self.build_loss()\n\n self.saver = tf.train.Saver()\n\nclass ConvNetMulti(Model):\n def build_model(self):\n CROP_DIMS = self.config['CROP_DIMS']\n C = self.config['NUM_CHANNELS']\n LEAK = self.config['LEAK']\n LAMBDA = self.config['L2_REG']\n INIT = self.config['INIT']\n\n NLAYERS = int(self.config['NLAYERS']/2)\n NFILTERS = self.config['NFILTERS']\n\n NUM_POINTS = self.config['NUM_CONTOUR_POINTS']\n DIMS = [self.config['CONV_DIMS']]*2\n\n leaky_relu = tf.contrib.keras.layers.LeakyReLU(LEAK)\n\n self.x = tf.placeholder(shape=[None,CROP_DIMS,CROP_DIMS,C],dtype=tf.float32)\n self.y = tf.placeholder(shape=[None,NUM_POINTS],dtype=tf.float32)\n\n self.x_1 = tf.nn.pool(self.x, [2,2], \"MAX\", \"VALID\", strides=[2,2])\n self.x_2 = tf.nn.pool(self.x_1, [2,2], \"MAX\", \"VALID\", strides=[2,2])\n\n o = self.x\n\n for i in range(NLAYERS):\n o = tf_util.conv2D(o,dims=DIMS, nfilters=NFILTERS,init=INIT,activation=leaky_relu,\n scope=\"conv_{}\".format(i))\n\n o_1 = self.x_1\n\n for i in range(NLAYERS):\n o_1 = tf_util.conv2D(o_1,dims=DIMS, nfilters=NFILTERS,init=INIT,activation=leaky_relu, scope=\"conv_1_{}\".format(i))\n\n o_2 = self.x_2\n\n for i in range(NLAYERS):\n o_2 = tf_util.conv2D(o_2,dims=DIMS, nfilters=NFILTERS,init=INIT,activation=leaky_relu, scope=\"conv_2_{}\".format(i))\n\n\n s = o.get_shape().as_list()\n s_1 = o_1.get_shape().as_list()\n s_2 = o_2.get_shape().as_list()\n\n o_vec = tf.reshape(o,shape=[-1,s[1]*s[2]*s[3]])\n o_vec_1 = tf.reshape(o_1,shape=[-1,s_1[1]*s_1[2]*s_1[3]])\n o_vec_2 = tf.reshape(o_2,shape=[-1,s_2[1]*s_2[2]*s_2[3]])\n\n o = tf.concat([o_vec, o_vec_1, o_vec_2], axis=1)\n\n for i in range(self.config['FC_LAYERS']-1):\n if \"HIDDEN_SIZES\" in self.config:\n h = self.config['HIDDEN_SIZES'][i]\n else:\n h = self.config['HIDDEN_SIZE']\n\n o = tf_util.fullyConnected(o, h,\n leaky_relu, std=INIT, scope='fc_'+str(i))\n\n self.yhat = tf_util.fullyConnected(o, NUM_POINTS,\n tf.identity, std=INIT, scope='fc_final')\n\n self.build_loss()\n\n self.saver = tf.train.Saver()\n\nclass GoogleNet(Model):\n def build_model(self):\n CROP_DIMS = self.config['CROP_DIMS']\n C = self.config['NUM_CHANNELS']\n LEAK = self.config['LEAK']\n LAMBDA = self.config['L2_REG']\n INIT = self.config['INIT']\n DROPOUT = self.config['DROPOUT']\n NUM_POINTS = self.config['NUM_CONTOUR_POINTS']\n\n leaky_relu = tf.contrib.keras.layers.LeakyReLU(LEAK)\n\n self.x = tf.placeholder(shape=[None,CROP_DIMS,CROP_DIMS,C],dtype=tf.float32)\n self.y = tf.placeholder(shape=[None,NUM_POINTS],dtype=tf.float32)\n\n o,o_side = tf_util.GoogleNet(self.x, activation=leaky_relu, init=INIT,\n scope='googlenet', output_size=NUM_POINTS, dropout=DROPOUT)\n\n print(o)\n print(o_side)\n\n self.yhat = tf.nn.sigmoid(o)\n self.yhat_side = tf.nn.sigmoid(o_side)\n\n self.build_loss()\n\n self.saver = tf.train.Saver()\n\n self.dropout_mask_op = op = tf.get_default_graph().get_tensor_by_name(\n \"googlenet/dropout_1/random_uniform:0\")\n\n self.dropout_mask = None\n self.dropout_fixed = False\n\n def build_loss(self):\n self.loss = tf.reduce_mean(tf.square(self.y-self.yhat))\n self.loss += 0.3*tf.reduce_mean(tf.square(self.y-self.yhat_side))\n\n def sample(self):\n self.dropout_mask = (np.random.uniform(size=(1,9216))<=0.6).astype(int)\n self.dropout_fixed = True\n\n def _predict(self,x):\n if not self.dropout_fixed:\n return self.sess.run(self.yhat,{self.x:x})\n else:\n return self.sess.run(self.yhat,{self.x:x,\n self.dropout_mask_op:self.dropout_mask})\n", "meta": {"hexsha": "bddecdc24d5dda914e8f1e564a28e56753843320", "size": 20733, "ext": "py", "lang": "Python", "max_stars_repo_path": "SimVascular-master/Python/site-packages/sv_ml/components/models/nn.py", "max_stars_repo_name": "mccsssk2/SimVascularPM3_March2020", "max_stars_repo_head_hexsha": "3cce6cc7be66545bea5dc3915a2db50a3892bf04", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "SimVascular-master/Python/site-packages/sv_ml/components/models/nn.py", "max_issues_repo_name": "mccsssk2/SimVascularPM3_March2020", "max_issues_repo_head_hexsha": "3cce6cc7be66545bea5dc3915a2db50a3892bf04", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "SimVascular-master/Python/site-packages/sv_ml/components/models/nn.py", "max_forks_repo_name": "mccsssk2/SimVascularPM3_March2020", "max_forks_repo_head_hexsha": "3cce6cc7be66545bea5dc3915a2db50a3892bf04", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.1565074135, "max_line_length": 127, "alphanum_fraction": 0.5780157237, "include": true, "reason": "import numpy", "num_tokens": 5536, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.519521321952093, "lm_q2_score": 0.36658973632215985, "lm_q1q2_score": 0.1904511844281577}} {"text": "# -*- coding: utf-8 -*-\n# vim: tabstop=4 shiftwidth=4 softtabstop=4\n#\n# Copyright (C) 2014-2018 GEM Foundation\n#\n# OpenQuake is free software: you can redistribute it and/or modify it\n# under the terms of the GNU Affero General Public License as published\n# by the Free Software Foundation, either version 3 of the License, or\n# (at your option) any later version.\n#\n# OpenQuake is distributed in the hope that it will be useful,\n# but WITHOUT ANY WARRANTY; without even the implied warranty of\n# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n# GNU Affero General Public License for more details.\n#\n# You should have received a copy of the GNU Affero General Public License\n# along with OpenQuake. If not, see .\n\n\"\"\"\nModule exports :class:`YuEtAl2013`, :class:`YuEtAl2013Tibet`,\n:class:`YuEtAl2013Eastern`, :class:`YuEtAl2013Stable`\n\n\"\"\"\nimport numpy as np\nfrom scipy.constants import g\n\nfrom openquake.hazardlib.gsim.base import GMPE, CoeffsTable\nfrom openquake.hazardlib import const\nfrom openquake.hazardlib.imt import PGA, PGV, SA\n\n\ndef gc(coeff, mag):\n \"\"\"\n Returns the set of coefficients to be used for the calculation of GM\n as a function of earthquake magnitude\n\n :param coeff:\n A dictionary of parameters for the selected IMT\n :param mag:\n Magnitude value\n :returns:\n The set of coefficients\n \"\"\"\n if mag > 6.5:\n a1ca = coeff['ua']\n a1cb = coeff['ub']\n a1cc = coeff['uc']\n a1cd = coeff['ud']\n a1ce = coeff['ue']\n a2ca = coeff['ia']\n a2cb = coeff['ib']\n a2cc = coeff['ic']\n a2cd = coeff['id']\n a2ce = coeff['ie']\n else:\n a1ca = coeff['a']\n a1cb = coeff['b']\n a1cc = coeff['c']\n a1cd = coeff['d']\n a1ce = coeff['e']\n a2ca = coeff['ma']\n a2cb = coeff['mb']\n a2cc = coeff['mc']\n a2cd = coeff['md']\n a2ce = coeff['me']\n return a1ca, a1cb, a1cc, a1cd, a1ce, a2ca, a2cb, a2cc, a2cd, a2ce\n\n\ndef rbf(ra, coeff, mag):\n \"\"\"\n Calculate the median ground motion for a given magnitude and distance\n\n :param ra:\n Distance value [km]\n :param coeff:\n The set of coefficients\n :param mag:\n Magnitude value\n :returns:\n\n \"\"\"\n a1ca, a1cb, a1cc, a1cd, a1ce, a2ca, a2cb, a2cc, a2cd, a2ce = gc(coeff, mag)\n term1 = a1ca + a1cb * mag + a1cc * np.log(ra + a1cd*np.exp(a1ce*mag))\n term2 = a2ca + a2cb * mag\n term3 = a2cd*np.exp(a2ce*mag)\n return np.exp((term1 - term2) / a2cc) - term3\n\n\ndef fnc(ra, *args):\n \"\"\"\n Function used in the minimisation problem.\n\n :param ra:\n Semi-axis of the ellipses used in the Yu et al.\n :returns:\n The absolute difference between the epicentral distance and the\n adjusted distance\n \"\"\"\n #\n # epicentral distance\n repi = args[0]\n #\n # azimuth\n theta = args[1]\n #\n # magnitude\n mag = args[2]\n #\n # coefficients\n coeff = args[3]\n #\n # compute the difference between epicentral distances\n rb = rbf(ra, coeff, mag)\n t1 = ra**2 * (np.sin(np.radians(theta)))**2\n t2 = rb**2 * (np.cos(np.radians(theta)))**2\n xx = ra * rb / (t1+t2)**0.5\n return xx-repi\n\n\ndef get_ras(repi, theta, mag, coeff):\n \"\"\"\n Computes equivalent distance\n\n :param repi:\n Epicentral distance\n :param theta:\n Azimuth value\n :param mag:\n Magnitude\n :param coeff:\n GMPE coefficients\n \"\"\"\n rx = 150.\n ras = 300.\n dff = 1.e0\n while abs(dff) > 1e-5:\n #\n # calculate the difference between epicentral distances\n dff = fnc(ras, repi, theta, mag, coeff)\n #\n # update the value of distance computed\n ras -= np.sign(dff) * rx\n rx = rx / 2.\n if rx < 1e-3:\n break\n return ras\n\n\nclass YuEtAl2013Ms(GMPE):\n \"\"\"\n Implements the Yu et al. (2013) GMPE used for the calculation of the 2015\n version of the national seismic hazard maps for China. Note that magnitude\n supported is Ms.\n \"\"\"\n\n #: Supported tectonic region type is active shallow crust\n DEFINED_FOR_TECTONIC_REGION_TYPE = const.TRT.ACTIVE_SHALLOW_CRUST\n\n #: Supported intensity measure types are peak ground velocity and\n #: peak ground acceleration\n DEFINED_FOR_INTENSITY_MEASURE_TYPES = set([\n PGA,\n PGV,\n SA\n ])\n\n #: Supported intensity measure component is geometric mean (supposed)\n DEFINED_FOR_INTENSITY_MEASURE_COMPONENT = const.IMC.AVERAGE_HORIZONTAL\n\n #: Supported standard deviation types is total\n DEFINED_FOR_STANDARD_DEVIATION_TYPES = set([\n const.StdDev.TOTAL\n ])\n\n #: No site parameters required\n REQUIRES_SITES_PARAMETERS = set(())\n\n #: Required rupture parameter is magnitude\n REQUIRES_RUPTURE_PARAMETERS = set(('mag',))\n\n #: Required distance measures are epicentral distance and azimuth\n REQUIRES_DISTANCES = set(('repi', 'azimuth'))\n\n def get_mean_and_stddevs(self, sites, rup, dists, imt, stddev_types):\n \"\"\"\n See :meth:`superclass method\n <.base.GroundShakingIntensityModel.get_mean_and_stddevs>`\n for spec of input and result values.\n \"\"\"\n # Check that the requested standard deviation type is available\n assert all(stddev_type in self.DEFINED_FOR_STANDARD_DEVIATION_TYPES\n for stddev_type in stddev_types)\n #\n # Set parameters\n mag = rup.mag\n epi = dists.repi\n theta = dists.azimuth\n #\n # Set coefficients\n coeff = self.COEFFS[imt]\n a1ca, a1cb, a1cc, a1cd, a1ce, a2ca, a2cb, a2cc, a2cd, a2ce = \\\n gc(coeff, mag)\n #\n # Get correction coefficients. Here for each site we find the\n # the geometry of the ellipses\n ras = []\n for epi, theta in zip(dists.repi, dists.azimuth):\n res = get_ras(epi, theta, mag, coeff)\n ras.append(res)\n ras = np.array(ras)\n rbs = rbf(ras, coeff, mag)\n #\n # Compute values of ground motion for the two cases. The value of\n # 225 is hardcoded under the assumption that the hypocentral depth\n # corresponds to 15 km (i.e. 15**2)\n mean1 = (a1ca + a1cb * mag +\n a1cc * np.log((ras**2+225)**0.5 +\n a1cd * np.exp(a1ce * mag)))\n mean2 = (a2ca + a2cb * mag +\n a2cc * np.log((rbs**2+225)**0.5 +\n a2cd * np.exp(a2ce * mag)))\n #\n # Get distances\n x = (mean1 * np.sin(np.radians(dists.azimuth)))**2\n y = (mean2 * np.cos(np.radians(dists.azimuth)))**2\n mean = mean1 * mean2 / np.sqrt(x+y)\n if isinstance(imt, (PGA)):\n mean = np.exp(mean)/g/100\n elif isinstance(imt, (PGV)):\n mean = np.exp(mean)\n else:\n raise ValueError('Unsupported IMT')\n #\n # Get the standard deviation\n stddevs = self._compute_std(coeff, stddev_types, len(dists.repi))\n #\n # Return results\n return np.log(mean), stddevs\n\n def _compute_std(self, C, stddev_types, num_sites):\n return [np.ones(num_sites)*C['sigma']]\n\n #: Coefficient table\n COEFFS = CoeffsTable(sa_damping=5, table=\"\"\"\\\nIMT a b c d e ua ub uc ud ue ma mb mc md me ia ib ic id ie sigma\nPGA 4.1193 1.656 -2.389 1.772 0.424 7.8269 1.0856 -2.389 1.772 0.424 2.2609 1.6399 -2.118 0.825 0.465 6.003 1.0649 -2.118 0.825 0.465 0.5428\nPGV -1.2581 1.932 -2.181 1.772 0.424 3.013 1.2742 -2.181 1.772 0.424 -3.1073 1.9389 -1.945 0.825 0.465 1.3087 1.2627 -1.945 0.825 0.465 0.6233\n \"\"\")\n\n\nclass YuEtAl2013MsTibet(YuEtAl2013Ms):\n #: Supported tectonic region type is Tibetan plateau\n DEFINED_FOR_TECTONIC_REGION_TYPE = const.TRT.ACTIVE_SHALLOW_CRUST\n #: Coefficient table\n COEFFS = CoeffsTable(sa_damping=5, table=\"\"\"\\\nIMT a b c d e ua ub uc ud ue ma mb mc md me ia ib ic id ie sigma\nPGA 5.4901 1.4835 -2.416 2.647 0.366 8.7561 0.9453 -2.416 2.647 0.366 2.3069 1.4007 -1.854 0.612 0.457 5.6511 0.8924 -1.854 0.612 0.457 0.5428\nPGV -0.1472 1.7618 -2.205 2.647 0.366 3.9422 1.1293 -2.205 2.647 0.366 -2.9923 1.7043 -1.696 0.612 0.457 1.0189 1.0902 -1.696 0.612 0.457 0.6233\n \"\"\")\n\n\nclass YuEtAl2013MsEastern(YuEtAl2013Ms):\n #: Supported tectonic region type is eastern part of China\n DEFINED_FOR_TECTONIC_REGION_TYPE = const.TRT.STABLE_CONTINENTAL\n #: Coefficient table\n COEFFS = CoeffsTable(sa_damping=5, table=\"\"\"\\\nIMT a b c d e ua ub uc ud ue ma mb mc md me ia ib ic id ie sigma\nPGA 4.5517 1.5433 -2.315 2.088 0.399 8.1259 0.9936 -2.315 2.088 0.399 2.7048 1.518 -2.004 0.944 0.447 6.3319 0.9614 -2.004 0.944 0.447 0.5428\nPGV -0.8349 1.8193 -2.103 2.088 0.399 3.3051 1.1799 -2.103 2.088 0.399 -2.6381 1.8124 -1.825 0.944 0.447 1.6376 1.1546 -1.825 0.944 0.447 0.6233\n \"\"\")\n\n\nclass YuEtAl2013MsStable(YuEtAl2013Ms):\n #: Supported tectonic region type is stable part of China\n DEFINED_FOR_TECTONIC_REGION_TYPE = const.TRT.STABLE_CONTINENTAL\n #: Coefficient table\n COEFFS = CoeffsTable(sa_damping=5, table=\"\"\"\\\nIMT a b c d e ua ub uc ud ue ma mb mc md me ia ib ic id ie sigma\nPGA 5.5591 1.1454 -2.079 2.802 0.295 8.5238 0.6854 -2.079 2.802 0.295 3.9445 1.0833 -1.723 1.295 0.331 6.187 0.7383 -1.723 1.295 0.331 0.5428\nPGV 0.2139 1.4283 -1.889 2.802 0.295 3.772 0.8786 -1.889 2.802 0.295 -1.3547 1.3823 -1.559 1.295 0.331 1.5433 0.9361 -1.559 1.295 0.331 0.6233\n \"\"\")\n\n\nclass YuEtAl2013Mw(YuEtAl2013Ms):\n \"\"\"\n This is a modified version of the original Yu et al. (2013) that supports\n the use of Mw rather than Ms. The Mw to Ms conversion equation used is the\n one proposed by Cheng et al. (2017). Note that this version does not\n propagate the uncertainty related to the magnitude conversion process.\n \"\"\"\n\n def get_mean_and_stddevs(self, sites, rup, dists, imt, stddev_types):\n \"\"\"\n See :meth:`superclass method\n <.base.GroundShakingIntensityModel.get_mean_and_stddevs>`\n for spec of input and result values.\n \"\"\"\n # Check that the requested standard deviation type is available\n assert all(stddev_type in self.DEFINED_FOR_STANDARD_DEVIATION_TYPES\n for stddev_type in stddev_types)\n #\n # Set parameters\n magn = rup.mag\n epi = dists.repi\n theta = dists.azimuth\n #\n # Convert Mw into Ms\n if magn < 6.58:\n mag = (magn - 0.59) / 0.86\n else:\n mag = (magn + 2.42) / 1.28\n #\n # Set coefficients\n coeff = self.COEFFS[imt]\n a1ca, a1cb, a1cc, a1cd, a1ce, a2ca, a2cb, a2cc, a2cd, a2ce = \\\n gc(coeff, mag)\n #\n # Get correction coefficients. Here for each site we find the\n # the geometry of the ellipses\n ras = []\n for epi, theta in zip(dists.repi, dists.azimuth):\n res = get_ras(epi, theta, mag, coeff)\n ras.append(res)\n ras = np.array(ras)\n rbs = rbf(ras, coeff, mag)\n #\n # Compute values of ground motion for the two cases. The value of\n # 225 is hardcoded under the assumption that the hypocentral depth\n # corresponds to 15 km (i.e. 15**2)\n mean1 = (a1ca + a1cb * mag +\n a1cc * np.log((ras**2+225)**0.5 +\n a1cd * np.exp(a1ce * mag)))\n mean2 = (a2ca + a2cb * mag +\n a2cc * np.log((rbs**2+225)**0.5 +\n a2cd * np.exp(a2ce * mag)))\n #\n # Get distances\n x = (mean1 * np.sin(np.radians(dists.azimuth)))**2\n y = (mean2 * np.cos(np.radians(dists.azimuth)))**2\n mean = mean1 * mean2 / np.sqrt(x+y)\n if isinstance(imt, (PGA)):\n mean = np.exp(mean)/g/100\n elif isinstance(imt, (PGV)):\n mean = np.exp(mean)\n else:\n raise ValueError('Unsupported IMT')\n #\n # Get the standard deviation\n stddevs = self._compute_std(coeff, stddev_types, len(dists.repi))\n #\n # Return results\n return np.log(mean), stddevs\n\n\nclass YuEtAl2013MwTibet(YuEtAl2013Mw):\n #: Supported tectonic region type is Tibetan plateau\n DEFINED_FOR_TECTONIC_REGION_TYPE = const.TRT.ACTIVE_SHALLOW_CRUST\n #: Coefficient table\n COEFFS = CoeffsTable(sa_damping=5, table=\"\"\"\\\nIMT a b c d e ua ub uc ud ue ma mb mc md me ia ib ic id ie sigma\nPGA 5.4901 1.4835 -2.416 2.647 0.366 8.7561 0.9453 -2.416 2.647 0.366 2.3069 1.4007 -1.854 0.612 0.457 5.6511 0.8924 -1.854 0.612 0.457 0.5428\nPGV -0.1472 1.7618 -2.205 2.647 0.366 3.9422 1.1293 -2.205 2.647 0.366 -2.9923 1.7043 -1.696 0.612 0.457 1.0189 1.0902 -1.696 0.612 0.457 0.6233\n \"\"\")\n\n\nclass YuEtAl2013MwEastern(YuEtAl2013Mw):\n #: Supported tectonic region type is eastern part of China\n DEFINED_FOR_TECTONIC_REGION_TYPE = const.TRT.STABLE_CONTINENTAL\n #: Coefficient table\n COEFFS = CoeffsTable(sa_damping=5, table=\"\"\"\\\nIMT a b c d e ua ub uc ud ue ma mb mc md me ia ib ic id ie sigma\nPGA 4.5517 1.5433 -2.315 2.088 0.399 8.1259 0.9936 -2.315 2.088 0.399 2.7048 1.518 -2.004 0.944 0.447 6.3319 0.9614 -2.004 0.944 0.447 0.5428\nPGV -0.8349 1.8193 -2.103 2.088 0.399 3.3051 1.1799 -2.103 2.088 0.399 -2.6381 1.8124 -1.825 0.944 0.447 1.6376 1.1546 -1.825 0.944 0.447 0.6233\n \"\"\")\n\n\nclass YuEtAl2013MwStable(YuEtAl2013Mw):\n #: Supported tectonic region type is stable part of China\n DEFINED_FOR_TECTONIC_REGION_TYPE = const.TRT.STABLE_CONTINENTAL\n #: Coefficient table\n COEFFS = CoeffsTable(sa_damping=5, table=\"\"\"\\\nIMT a b c d e ua ub uc ud ue ma mb mc md me ia ib ic id ie sigma\nPGA 5.5591 1.1454 -2.079 2.802 0.295 8.5238 0.6854 -2.079 2.802 0.295 3.9445 1.0833 -1.723 1.295 0.331 6.187 0.7383 -1.723 1.295 0.331 0.5428\nPGV 0.2139 1.4283 -1.889 2.802 0.295 3.772 0.8786 -1.889 2.802 0.295 -1.3547 1.3823 -1.559 1.295 0.331 1.5433 0.9361 -1.559 1.295 0.331 0.6233\n \"\"\")\n", "meta": {"hexsha": "e6989bd535f400e7cf4ab90273487526a0b7332b", "size": 14004, "ext": "py", "lang": "Python", "max_stars_repo_path": "openquake/hazardlib/gsim/yu_2013.py", "max_stars_repo_name": "gfzriesgos/shakyground-lfs", "max_stars_repo_head_hexsha": "2caf67cc32e6800286eded2df1efb05973ccf41b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-08-01T00:28:24.000Z", "max_stars_repo_stars_event_max_datetime": "2019-08-01T00:28:24.000Z", "max_issues_repo_path": "openquake/hazardlib/gsim/yu_2013.py", "max_issues_repo_name": "gfzriesgos/shakyground-lfs", "max_issues_repo_head_hexsha": "2caf67cc32e6800286eded2df1efb05973ccf41b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2018-08-31T14:14:35.000Z", "max_issues_repo_issues_event_max_datetime": "2021-10-11T12:53:13.000Z", "max_forks_repo_path": "openquake/hazardlib/gsim/yu_2013.py", "max_forks_repo_name": "gfzriesgos/shakyground-lfs", "max_forks_repo_head_hexsha": "2caf67cc32e6800286eded2df1efb05973ccf41b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2018-08-31T14:11:00.000Z", "max_forks_repo_forks_event_max_datetime": "2019-07-17T10:06:02.000Z", "avg_line_length": 36.2797927461, "max_line_length": 144, "alphanum_fraction": 0.6162524993, "include": true, "reason": "import numpy,from scipy", "num_tokens": 4755, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5195213219520929, "lm_q2_score": 0.3665897363221598, "lm_q1q2_score": 0.19045118442815762}} {"text": "\"\"\"\nCustomised implementation of FermiDos. Will Move back to pymatgen at some point.\n\"\"\"\nimport logging\nfrom typing import Dict, Optional, Tuple, Union\n\nimport numpy as np\nfrom monty.json import MSONable\nfrom pymatgen import Spin, Structure\nfrom pymatgen.electronic_structure.dos import Dos\n\nfrom amset.constants import boltzmann_au, ev_to_hartree, hartree_to_ev\nfrom amset.electronic_structure.fd import fd\n\n__author__ = \"Alex Ganose\"\n__maintainer__ = \"Alex Ganose\"\n__email__ = \"aganose@lbl.gov\"\n\nlogger = logging.getLogger(__name__)\n\n\nclass FermiDos(Dos, MSONable):\n \"\"\"\n This wrapper class helps relate the density of states, doping levels\n (i.e. carrier concentrations) and corresponding fermi levels. A negative\n doping concentration indicates the majority carriers are electrons\n (n-type doping); a positive doping concentration indicates holes are the\n majority carriers (p-type doping).\n\n Args:\n efermi: The Fermi level energy in Hartree.\n energies: A sequences of energies in Hartree.\n densities ({Spin: np.array}): representing the density of states\n for each Spin.\n structure: A structure. If not provided, the structure\n of the dos object will be used. If the dos does not have an\n associated structure object, an error will be thrown.\n dos_weight: The weighting for the dos. Defaults to 2 for non-spin\n polarized calculations and 1 for spin-polarized calculations.\n atomic_units: Whether energies are given in eV or Hartree.\n num_electrons: The number of electrons in the system. If None, this will be\n calculated by integrating up to the intrinsic Fermi level.\n \"\"\"\n\n def __init__(\n self,\n efermi: float,\n energies: np.ndarray,\n densities: Dict[Spin, np.ndarray],\n structure: Structure,\n dos_weight: Optional[float] = None,\n atomic_units: bool = True,\n num_electrons: Optional[float] = None,\n ):\n # structure should be atomic structure\n super().__init__(efermi, energies, densities)\n self.structure = structure\n self.atomic_units = atomic_units\n\n if not dos_weight:\n dos_weight = 2 if len(self.densities) == 1 else 1\n\n self.dos_weight = dos_weight\n self.tdos = np.array(self.get_densities()) * self.dos_weight\n self.de = self.energies[1] - self.energies[0]\n self._num_electrons = num_electrons # this is just for msonability\n\n if num_electrons is None:\n # integrate up to Fermi level to get number of electrons\n self.nelect = self.tdos[self.energies <= self.efermi].sum() * self.de\n else:\n self.nelect = num_electrons\n\n logger.info(\n \"Intrinsic DOS Fermi level: {:.4f} eV\".format(\n self.efermi * hartree_to_ev if atomic_units else self.efermi\n )\n )\n logger.info(\"DOS contains {:.3f} electrons\".format(self.nelect))\n\n def get_doping(\n self,\n fermi_level: float,\n temperature: float,\n return_electron_hole_conc: bool = False,\n ) -> Union[float, Tuple[float, float, float]]:\n \"\"\"\n Calculate the doping (majority carrier concentration) at a given\n fermi level and temperature. A simple Left Riemann sum is used for\n integrating the density of states over energy & equilibrium Fermi-Dirac\n distribution.\n\n Args:\n fermi_level: The fermi_level level in Hartree.\n temperature: The temperature in Kelvin.\n return_electron_hole_conc: Whether to also return the separate\n electron and hole concentrations at the doping level.\n\n Returns:\n If return_electron_hole_conc is False: the doping concentration in\n units of 1/Bohr^3. Negative values indicate that the majority carriers\n are electrons (n-type doping) whereas positive values indicates the\n majority carriers are holes (p-type doping).\n\n If return_electron_hole_conc is True: the doping concentration,\n electron concentration and hole concentration as a tuple.\n \"\"\"\n wdos = _get_weighted_dos(\n self.energies,\n self.tdos,\n fermi_level,\n temperature,\n atomic_units=self.atomic_units,\n )\n\n num_electrons = wdos.sum() * self.de\n conc = (self.nelect - num_electrons) / self.structure.volume\n\n if return_electron_hole_conc:\n cb_conc = wdos[self.energies > self.efermi].sum() * self.de\n vb_conc = wdos[self.energies <= self.efermi].sum() * self.de\n cb_conc = cb_conc / self.structure.volume\n vb_conc = (self.nelect - vb_conc) / self.structure.volume\n return conc, cb_conc, vb_conc\n\n else:\n return conc\n\n def get_num_electrons(self, fermi_level: float, temperature: float) -> float:\n \"\"\"\n Calculate the number of electrons at a given fermi level and temperature.\n A simple Left Riemann sum is used for integrating the density of states over\n energy & equilibrium Fermi-Dirac distribution.\n\n Args:\n fermi_level: The fermi_level level in Hartree.\n temperature: The temperature in Kelvin.\n\n Returns:\n The number of electrons.\n \"\"\"\n wdos = _get_weighted_dos(\n self.energies,\n self.tdos,\n fermi_level,\n temperature,\n atomic_units=self.atomic_units,\n )\n\n num_electrons = wdos.sum() * self.de\n return num_electrons\n\n def get_fermi_from_num_electrons(\n self,\n num_electrons: float,\n temperature: float,\n tol: float = 0.01,\n nstep: int = 50,\n step: float = 0.1,\n precision: int = 10,\n ):\n # this is finding the Fermi level of metals\n fermi = self.efermi # initialize target fermi\n relative_error = float(\"inf\")\n for _ in range(precision):\n frange = np.arange(-nstep, nstep + 1) * step + fermi\n calc_nelectrons = [self.get_num_electrons(f, temperature) for f in frange]\n relative_error = abs(np.array(calc_nelectrons) / num_electrons - 1.0)\n fermi = frange[np.argmin(relative_error)]\n step /= 10.0\n\n if min(relative_error) > tol:\n raise ValueError(\n \"Could not find fermi within {}% of num electrons={}\".format(\n tol * 100, num_electrons\n )\n )\n\n return fermi\n\n def get_fermi(\n self,\n concentration: float,\n temperature: float,\n tol: float = 0.01,\n nstep: int = 50,\n step: float = 0.1,\n precision: int = 10,\n return_electron_hole_conc=False,\n ):\n \"\"\"\n Finds the fermi level at which the doping concentration at the given\n temperature (T) is equal to concentration. A greedy algorithm is used\n where the relative error is minimized by calculating the doping at a\n grid which continually becomes finer.\n\n Args:\n concentration: The doping concentration in 1/Bohr^3. Negative values\n represent n-type doping and positive values represent p-type\n doping.\n temperature: The temperature in Kelvin.\n return_electron_hole_conc: Whether to also return the separate\n electron and hole concentrations at the doping level.\n\n Returns:\n If return_electron_hole_conc is False: The Fermi level in eV. Note\n that this is different from the default dos.efermi.\n\n If return_electron_hole_conc is True: the Fermi level, electron\n concentration and hole concentration at the Fermi level as a tuple.\n The electron and hole concentrations are in Bohr^-3.\n \"\"\"\n fermi = self.efermi # initialize target fermi\n relative_error = float(\"inf\")\n for _ in range(precision):\n frange = np.arange(-nstep, nstep + 1) * step + fermi\n calc_doping = np.array([self.get_doping(f, temperature) for f in frange])\n relative_error = abs(calc_doping / concentration - 1.0)\n fermi = frange[np.argmin(relative_error)]\n step /= 10.0\n\n if min(relative_error) > tol:\n raise ValueError(\n \"Could not find fermi within {}% of concentration={}\".format(\n tol * 100, concentration\n )\n )\n\n if return_electron_hole_conc:\n _, n_elec, n_hole = self.get_doping(\n fermi, temperature, return_electron_hole_conc=True\n )\n return fermi, n_elec, n_hole\n else:\n return fermi\n\n\ndef _get_weighted_dos(energies, dos, fermi_level, temperature, atomic_units=True):\n if temperature == 0.0:\n occ = np.where(energies < fermi_level, 1.0, 0.0)\n occ[energies == fermi_level] = 0.5\n else:\n kbt = temperature * boltzmann_au\n if atomic_units:\n occ = fd(energies, fermi_level, kbt)\n else:\n occ = fd(energies * ev_to_hartree, fermi_level * ev_to_hartree, kbt)\n\n wdos = dos * occ\n return wdos\n", "meta": {"hexsha": "4db3afb6cca766b4593c86d8de3afc6f60cfadf8", "size": 9326, "ext": "py", "lang": "Python", "max_stars_repo_path": "amset/electronic_structure/dos.py", "max_stars_repo_name": "kbspooner/amset", "max_stars_repo_head_hexsha": "1e341d68bd03eef47916e680e687fc085966a0c0", "max_stars_repo_licenses": ["BSD-3-Clause-LBNL"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "amset/electronic_structure/dos.py", "max_issues_repo_name": "kbspooner/amset", "max_issues_repo_head_hexsha": "1e341d68bd03eef47916e680e687fc085966a0c0", "max_issues_repo_licenses": ["BSD-3-Clause-LBNL"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "amset/electronic_structure/dos.py", "max_forks_repo_name": "kbspooner/amset", "max_forks_repo_head_hexsha": "1e341d68bd03eef47916e680e687fc085966a0c0", "max_forks_repo_licenses": ["BSD-3-Clause-LBNL"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-12-12T12:00:30.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-12T12:00:30.000Z", "avg_line_length": 37.1553784861, "max_line_length": 86, "alphanum_fraction": 0.6213810851, "include": true, "reason": "import numpy", "num_tokens": 2185, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.519521321952093, "lm_q2_score": 0.36658972248186, "lm_q1q2_score": 0.1904511772378268}} {"text": "import nest\nimport os\nimport subprocess\nimport sys\nimport itertools\nfrom scipy.optimize import minimize\nimport scipy.special as sp_spec\nimport numpy as np\n# from nest_elephant_tvb.simulation.file_tvb.Zerlaut import ZerlautAdaptationSecondOrder as model\nfrom nest_elephant_tvb.Tvb import Matteo_2 as model\nfrom nest_elephant_tvb.Tvb import excitatory\n\n\n# Matteo function\n# # excitatory\n# excitatory={\n# 'C_m':200.0,\n# 't_ref':5.0,\n# 'V_reset':-64.5,\n# 'E_L':-64.5,\n# 'g_L':10.0,\n# 'I_e':0.0,\n# 'a':0.0,\n# 'b':0.0,\n# 'Delta_T':2.0,\n# 'tau_w':500.0,\n# 'V_th':-50.0,\n# 'E_ex':0.0,\n# 'tau_syn_ex':5.0,\n# 'E_in':-80.0,\n# 'tau_syn_in':5.0,\n# 'V_peak': 10.0,\n# 'N_tot':10**4,\n# 'p_connect':0.05,\n# 'g':0.2,\n# 'Q_e':1.0,\n# 'Q_i':2.5,\n# }\n# #inhibitory\n# inhibitory={\n# 'C_m':200.0,\n# 't_ref':5.0,\n# 'V_reset':-65.0,\n# 'E_L':-65.,\n# 'g_L':10.0,\n# 'I_e':0.0,\n# 'a':0.0,\n# 'b':0.0,\n# 'Delta_T':0.5,\n# 'tau_w':1.0,\n# 'V_th':-50.0,\n# 'E_ex':0.0,\n# 'tau_syn_ex':5.0,\n# 'E_in':-80.0,\n# 'tau_syn_in':5.0,\n# 'V_peak': 10.0,\n# 'N_tot':10**4,\n# 'p_connect':0.05,\n# 'g':0.2,\n# 'Q_e':1.0,\n# 'Q_i':2.5\n# }\n\n\ndef compute_rate(data,begin,end,nb):\n \"\"\"\n Compute the firing rate\n :param data: the spike of all neurons between end and begin\n :param begin: the time of the first spike\n :param end: the time of the last spike\n :return: the mean and the standard deviation of firing rate, the maximum and minimum of firing rate\n \"\"\"\n #get data\n n_fil = data[:, 0]\n n_fil = n_fil.astype(int)\n #count the number of the same id\n count_of_n = np.bincount(n_fil)\n #compute the rate\n rate_each_n_incomplet = count_of_n / (end - begin)\n #fill the table with the neurons which are not firing\n rate_each_n = np.concatenate(\n (rate_each_n_incomplet, np.zeros(-np.shape(rate_each_n_incomplet)[0] + nb +1)))\n #save the value\n\n\n return rate_each_n[1:]\n\ndef load_event(events):\n \"\"\"\n Get the id of the neurons which create the spike and time\n :param path: the path to the file\n :return: The spike of all neurons\n \"\"\"\n data_concatenated = np.concatenate(([events['senders']],[events['times']]))\n if data_concatenated.size < 5:\n print('empty file')\n return None\n data_raw = data_concatenated[np.argsort(data_concatenated[:, 1])]\n return np.swapaxes(data_raw,0,1)\n\ndef load_spike(path):\n \"\"\"\n Get the id of the neurons which create the spike and time\n :param path: the path to the file\n :return: The spike of all neurons\n \"\"\"\n if not os.path.exists(path + \"/spike_detector.gdf\"):\n print('no file')\n return None\n data_concatenated = np.loadtxt(path + \"/spike_detector.gdf\")\n if data_concatenated.size < 5:\n print('empty file')\n return None\n data_raw = data_concatenated[np.argsort(data_concatenated[:, 1])]\n return data_raw\n\ndef create_transfer_function(parameter,excitatory):\n model_test = model()\n model_test.g_L = np.array(parameter['g_L'])\n model_test.E_L_e = np.array(parameter['E_L'])\n model_test.E_L_i = np.array(parameter['E_L'])\n model_test.C_m = np.array(parameter['C_m'])\n model_test.b_e = np.array(parameter['b'])\n model_test.a_e = np.array(parameter['a'])\n model_test.b_i = np.array(parameter['b'])\n model_test.a_i = np.array(parameter['a'])\n model_test.tau_w_e = np.array(parameter['tau_w'])\n model_test.tau_w_i = np.array(parameter['tau_w'])\n model_test.E_e = np.array(parameter['E_ex'])\n model_test.E_i = np.array(parameter['E_in'])\n model_test.Q_e = np.array(parameter['Q_e'])\n model_test.Q_i = np.array(parameter['Q_i'])\n model_test.tau_e = np.array(parameter['tau_syn_ex'])\n model_test.tau_i = np.array(parameter['tau_syn_in'])\n model_test.N_tot = np.array(parameter['N_tot'])\n model_test.p_connect = np.array(parameter['p_connect'])\n model_test.g = np.array(parameter['g'])\n model_test.T = np.array(parameter['t_ref'])\n model_test.external_input_in_in = np.array(0.0)\n model_test.external_input_in_ex = np.array(0.0)\n model_test.external_input_ex_in = np.array(0.0)\n model_test.external_input_ex_ex = np.array(0.0)\n model_test.K_ext_e=np.array(1)\n model_test.K_ext_i=np.array(0)\n if excitatory:\n def TF(fe,fi,p,f_ext_e=0.0,f_ext_i=0.0,w=0.0):\n model_test.P_e=p\n return model_test.TF_excitatory(fe,fi,f_ext_e,f_ext_i,w)\n else:\n def TF(fe,fi,p,f_ext_e=0.0,f_ext_i=0.0,w=0.0):\n model_test.P_i=p\n return model_test.TF_inhibitory(fe,fi,f_ext_e,f_ext_i,w)\n return TF\n\ndef effective_Vthre(Y, muV, sV, Tv):\n Vthre_eff = muV+np.sqrt(2)*sV*sp_spec.erfcinv(Y*2.*Tv) # effective threshold\n return Vthre_eff\n\ndef engin(parameters,excitatory,max_frequency=40.0,precision=0.5,frequency=None,rescale=None):\n name_file ='/home/kusch/Documents/project/co_simulation/co-simulation_mouse/test_nest/test_file/fitting/'\n for name,value in parameters.items():\n name_file += name+'_'+str(value)+'/'\n if frequency is None:\n frequency = np.arange(0.0,max_frequency,precision)\n frequencies = np.array(list(itertools.product(frequency,frequency)))\n\n if os.path.exists(name_file+'/P.npy'):\n return np.load(name_file+'/P.npy')\n elif os.path.exists(name_file+'/rate.npy'):\n rate = np.load(name_file+'/rate.npy')\n else:\n if os.path.exists(name_file+'/spike_detector.gdf'):\n print('analysis')\n data = load_spike(name_file)\n\n else:\n if not os.path.exists(name_file):\n os.makedirs(name_file)\n #initialisation of the parameter\n params = { 'g_L':parameters['g_L'],\n 'E_L':parameters['E_L'],\n 'V_reset':parameters['V_reset'],\n 'I_e':parameters['I_e'],\n 'C_m':parameters['C_m'],\n 'V_th':parameters['V_th'],\n 't_ref':parameters['t_ref'],\n 'tau_w':parameters['tau_w'],\n 'Delta_T':parameters['Delta_T'],\n 'b':parameters['b'],\n 'a':parameters['a'],\n 'V_peak':parameters['V_peak'],\n 'E_ex':parameters['E_ex'],\n 'E_in':parameters['E_in'],\n 'tau_syn_ex':parameters['tau_syn_ex'],\n 'tau_syn_in':parameters['tau_syn_in'],\n 'gsl_error_tol':1e-8\n }\n Number_connexion_ex = parameters['N_tot']*parameters['p_connect']*(1-parameters['g'])\n Number_connexion_in = parameters['N_tot']*parameters['p_connect']*parameters['g']\n simtime=100000.0\n master_seed = 5\n local_num_threads = 8\n # simulation\n simulation = False\n error = 1.0e-6\n\n while error > 1.0e-20 and not simulation:\n params['gsl_error_tol'] = error\n # initialisation of nest\n nest.ResetKernel()\n nest.SetKernelStatus({\n # Resolution of the simulation (in ms).\n \"resolution\": 0.05,\n # Print the time progress, this should only be used when the simulation\n # is run on a local machine.\n \"print_time\": True,\n # If True, data will be overwritten,\n # If False, a NESTError is raised if the files already exist.\n \"overwrite_files\": True,\n # Number of threads per MPI process.\n 'local_num_threads': local_num_threads,\n # Path to save the output data\n 'data_path': name_file,\n # Masterseed for NEST and NumPy\n 'grng_seed': master_seed + local_num_threads,\n # Seeds for the individual processes\n 'rng_seeds': range(master_seed + 1 + local_num_threads, master_seed + 1 + (2 * local_num_threads)),\n })\n\n #create the network\n nest.SetDefaults('aeif_cond_exp', params)\n neurons = nest.Create('aeif_cond_exp', frequency.shape[0]**2)\n poisson_generator_ex = nest.Create('poisson_generator', frequency.shape[0])\n poisson_generator_in = nest.Create('poisson_generator', frequency.shape[0])\n nest.SetStatus(poisson_generator_ex,'rate',frequency*Number_connexion_ex)\n nest.SetStatus(poisson_generator_in,'rate',frequency*Number_connexion_in)\n nest.CopyModel(\"static_synapse\", \"excitatory\",\n {\"weight\": parameters['Q_e'], \"delay\": 1.0})\n nest.CopyModel(\"static_synapse\", \"inhibitory\",\n {\"weight\": -parameters['Q_i'], \"delay\": 1.0})\n for inh in range(len(frequency)):\n for ex in range(len(frequency)):\n nest.Connect(poisson_generator_ex[ex],neurons[ex+inh*len(frequency)],syn_spec=\"excitatory\")\n nest.Connect(poisson_generator_in[inh],neurons[ex+inh*len(frequency)],syn_spec=\"inhibitory\")\n\n #create spike detector\n spikes_dec = nest.Create(\"spike_detector\")\n nest.SetStatus(spikes_dec, [{\"label\": \"spike\",\n # \"withtime\": True,\n # \"withgid\": True,\n # \"to_file\": True,\n \"record_to\":\"ascii\",\n }])\n nest.Connect(neurons,spikes_dec)\n try :\n nest.Simulate(simtime)\n simulation = True\n print('end')\n except nest.NESTError as exception:\n template = \"An exception of type {0} occurred. Arguments:\\n{1!r}\"\n message = template.format(type(exception).__name__, exception.args)\n print(message)\n error = error/10.0\n print('analysis')\n\n # Concatenate the different spike files\n if subprocess.call([os.path.join(os.path.dirname(__file__),'script.sh'),name_file]) == 1:\n sys.stderr.write('ERROR bad concatenation of spikes file\\n')\n exit(1)\n\n #Compute rate\n # data = load_event(nest.GetStatus(spikes_dec)[0]['events'] )\n data = load_spike(name_file)\n\n if data is None:\n print('compute rate')\n rate = np.zeros_like(frequencies)\n return [0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.]\n else:\n rate = compute_rate(data,0.0,100000.0,len(frequencies))\n np.save(name_file+'/rate.npy', rate)\n del data\n\n nb_freq = len (frequency)\n if rescale is not None:\n index = np.arange(0,nb_freq,1)\n index = index[np.where(np.logical_not(np.isin(index,rescale)))]\n rate = rate.reshape(nb_freq,nb_freq)\n rate = np.ravel(rate[index,:][:,index])\n frequencies = np.array(list(itertools.product(frequency[index],frequency[index])))\n nb_freq -=len(rescale)\n\n # data = np.load('/home/kusch/Documents/project/Zerlaut/travail/Zerlaut/mean_field_for_multi_input_integration/transfer_functions/data/FS-cell_CONFIG1.npy')\n # data = np.load('/home/kusch/Documents/project/Zerlaut/travail/Zerlaut/mean_field_for_multi_input_integration/transfer_functions/data/RS-cell_CONFIG1.npy')\n # rate = np.ravel(data[0])*1e-3\n # frequencies = np.empty((len(rate),2))\n # frequencies[:,1] = np.ravel(data[2])\n # frequencies[:,0] = np.ravel(np.repeat([data[3]],data[2].shape[1],axis=0))\n\n #Compute mean of value for the model\n # rate+=1e-10\n muV, sV, Tv =model.get_fluct_regime_vars(frequencies[:,1]*1e-3,frequencies[:,0]*1e-3,0.00,0.0,0.0,parameters['Q_e'],parameters['tau_syn_ex'],parameters['E_ex'],parameters['Q_i'],parameters['tau_syn_in'],parameters['E_in'],\n parameters['g_L'],parameters['C_m'],parameters['E_L'],parameters['N_tot'],parameters['p_connect'],parameters['g'],0.0,0.0)\n Tv+= parameters['g_L']/parameters['C_m']\n i_non_zeros = np.where((rate>=1/100000.0) &(rate*Tv<1.0))\n # i_non_zeros=np.arange(0,len(rate),1)\n\n Vthre_eff = effective_Vthre(rate[i_non_zeros], muV[i_non_zeros], sV[i_non_zeros], Tv[i_non_zeros])*1e-3\n TvN = Tv[i_non_zeros]*parameters['g_L']/parameters['C_m']\n\n import matplotlib.pylab as plt\n # all = frequency[index]\n all =frequency\n index = i_non_zeros[0]; not_index = np.where(np.logical_not(np.isin(np.arange(0,nb_freq*nb_freq,1),i_non_zeros)))[0];\n fig = plt.figure();ax = fig.add_subplot(111, projection='3d');ax.scatter(muV, sV, Tv*parameters['g_L']/parameters['C_m'], marker='x',s=0.1);ax.set_xlabel('Vm');ax.set_ylabel('sV');ax.set_zlabel('Tv')\n fig = plt.figure();ax = fig.add_subplot(111, projection='3d');ax.scatter(muV[index], sV[index], Tv[index]*parameters['g_L']/parameters['C_m'], marker='x',s=0.1);ax.set_xlabel('Vm');ax.set_ylabel('sV');ax.set_zlabel('Tv');ax.scatter(muV[not_index], sV[not_index], Tv[not_index]*parameters['g_L']/parameters['C_m'], marker='o',s=0.1);\n plt.figure(); plt.plot(all,muV.reshape(nb_freq,nb_freq),'x',markersize=0.5);\n plt.figure(); plt.plot(all,sV.reshape(nb_freq,nb_freq),'x',markersize=0.5);\n plt.figure(); plt.plot(all,Tv.reshape(nb_freq,nb_freq)*parameters['g_L']/parameters['C_m'],'x',markersize=0.5)\n plt.figure(); plt.plot(index,TvN,'bx',markersize=0.5); plt.plot(not_index,Tv[not_index]*parameters['g_L']/parameters['C_m'],'rx',markersize=0.5)\n plt.figure(); plt.plot(index,muV[index],'bx',markersize=0.5); plt.plot(not_index,muV[not_index],'rx',markersize=0.5)\n plt.figure(); plt.plot(index,sV[index],'bx',markersize=0.5); plt.plot(not_index,sV[not_index],'rx',markersize=0.5)\n plt.figure();plt.plot(Vthre_eff,rate[index],'x',markersize=0.5);\n plt.figure();plt.plot(Vthre_eff,muV[index],'x',markersize=0.5);\n plt.figure();plt.plot(Vthre_eff,sV[index],'x',markersize=0.5);\n plt.figure();plt.plot(Vthre_eff,TvN,'x',markersize=0.5);\n plt.figure(); plt.plot(frequencies[:,1].reshape(nb_freq,nb_freq).transpose(),rate.reshape(nb_freq,nb_freq).transpose()*1e3)\n plt.show()\n\n\n TF = create_transfer_function(parameters,excitatory=excitatory)\n P = np.zeros(20)\n P[:5] = Vthre_eff.mean(), 1e-3, 1e-3, 1e-3, 1e-3\n\n def Res(p):\n pp=p\n vthre = model.threshold_func(muV[i_non_zeros], sV[i_non_zeros], TvN, *pp)\n return np.mean((Vthre_eff-vthre)**2)\n # return np.mean(np.abs(Vthre_eff-vthre)*1e3)\n # return np.mean(np.abs((Vthre_eff - vthre) / Vthre_eff))\n plsq = minimize(Res, P, method='SLSQP',options={'ftol': 1e-15, 'disp': True, 'maxiter':40000})\n # plsq = minimize(Res, P, method='SLSQP',tol=1e-10,\\\n # options={'ftol': 1e-12, 'eps':1e-8,'disp': True, 'maxiter':100000})\n\n P = plsq.x\n def Res_1(p):\n return np.mean((rate[i_non_zeros] - TF(frequencies[i_non_zeros,1]*1e-3,frequencies[i_non_zeros,0]*1e-3,p)) ** 2)\n # return np.mean(np.abs((rate[i_non_zeros] - TF(frequencies[i_non_zeros,1]*1e-3,frequencies[i_non_zeros,0]*1e-3,p)))*1e3)\n # return np.mean(np.abs( (rate[i_non_zeros] - TF(frequencies[i_non_zeros, 1] * 1e-3, frequencies[i_non_zeros, 0] * 1e-3, p)) / rate[i_non_zeros]))\n # plsq = minimize(Res_1, P, method='nelder-mead',options={'xtol': 1e-5, 'disp': True, 'maxiter': 50000})\n # plsq = minimize(Res_1, P, method='nelder-mead',tol=1e-12, \\\n # options={'xtol': 1., 'disp': True, 'maxiter': 100000, 'maxfev':100000})\n # p = plsq.x\n # index = np.argsort(np.abs(((rate - TF(frequencies[:, 1] * 1e-3, frequencies[:, 0] * 1e-3, p)) * 1e3)))[-10:]\n # print('first part ')\n # print(P)\n # print(\"frequency\", frequencies[index])\n # print(\"expected : \", rate[index] * 1e3)\n # print(\"got : \", TF(frequencies[:, 1] * 1e-3, frequencies[:, 0] * 1e-3, p)[index] * 1e3)\n # print(\"error : \", np.abs(((rate - TF(frequencies[:, 1] * 1e-3, frequencies[:, 0] * 1e-3, p)) * 1e3))[index])\n # print(\"max error \", np.abs(((rate - TF(frequencies[:, 1] * 1e-3, frequencies[:, 0] * 1e-3, p)) * 1e3))[index[-1]])\n\n P = plsq.x\n def Res_2(p):\n return np.mean((rate - TF(frequencies[:,1]*1e-3,frequencies[:,0]*1e-3,p)) ** 2)\n # return np.mean(np.abs((rate - TF(frequencies[:,1]*1e-3,frequencies[:,0]*1e-3,p)))*1e3)\n # return np.mean(np.abs((rate - TF(frequencies[:,1]*1e-3,frequencies[:,0]*1e-3,p))/rate))\n plsq = minimize(Res_2, P, method='nelder-mead',options={'xtol': 1e-5, 'disp': True, 'maxiter': 50000})\n # plsq = minimize(Res_2, P, method='nelder-mead',tol=1e-12, \\\n # options={'xtol': 1.0, 'disp': True, 'maxiter': 100000, 'maxfev':100000})\n\n # network = np.empty((651,9))\n # range_rate = np.arange(0.0,105.0,5.0)\n # range_b = np.arange(0.,3.1,0.1)\n # range_test = np.array(list(itertools.product(range_b,range_rate)))\n # for i in range(651):\n # network[i,:7]=np.load(\"/home/kusch/Documents/project/co_simulation/co-simulation_mouse/test_nest/test_file/fitting/network_\"+str(i)+\".npy\")\n # network[:,7:]=range_test\n # network = network[np.where(network[:,6]==0)[0],:]\n # index_network = 2 if excitatory else 0\n # P = plsq.x\n # def Res_3(p):\n # return np.mean((( network[:,index_network]*1e-3- TF(network[:,2]*1e-3,network[:,0]*1e-3,p,network[:,8]*1e-3,0.0,network[:,4]))*1e3) ** 2)\n # return np.mean(np.abs( network[:,index_network]- TF(network[:,2]*1e-3,network[:,0]*1e-3,p,network[:,8]*1e-3,0.0,network[:,4])*1e3))\n # return np.mean(np.abs( (network[:,index_network] - TF(network[:,2]*1e-3,network[:,0]*1e-3,p,network[:,8]*1e-3,0.0,network[:,4])*1e3))/network[:,index_network])\n # plsq = minimize(Res_3, P, method='nelder-mead',tol=1e-12, \\\n # options={'xtol': 1.0, 'disp': True, 'maxiter': 100000, 'maxfev':100000})\n\n p = plsq.x\n index = np.argsort(np.abs(((rate - TF(frequencies[:, 1] * 1e-3, frequencies[:, 0] * 1e-3, p)) * 1e3)))[-10:]\n # print(\"frequency\", frequencies[index])\n # print(\"expected : \", rate[index] * 1e3)\n # print(\"got : \", TF(frequencies[:, 1] * 1e-3, frequencies[:, 0] * 1e-3, p)[index] * 1e3)\n # print(\"error : \", np.abs(((rate - TF(frequencies[:, 1] * 1e-3, frequencies[:, 0] * 1e-3, p)) * 1e3))[index])\n # print(\"max error \", np.abs(((rate - TF(frequencies[:, 1] * 1e-3, frequencies[:, 0] * 1e-3, p)) * 1e3))[index[-1]])\n # np.save(name_file+'/P.npy', plsq.x)\n\n\n\n TF(frequencies[:,1]*1e-3,frequencies[:,0]*1e-3,p)\n plt.figure(); plt.plot(frequencies[:,1].reshape(nb_freq,nb_freq).transpose(),TF(frequencies[:,1]*1e-3,frequencies[:,0]*1e-3,p).reshape(nb_freq,nb_freq).transpose()*1e3)\n plt.figure(); plt.plot(frequencies[:,1].reshape(nb_freq,nb_freq).transpose(),rate.reshape(nb_freq,nb_freq).transpose()*1e3)\n plt.show()\n return plsq.x\n\n\n\n# frequency = np.array([0.0,0.1,0.2,0.3,0.4,0.5,0.6,0.61,0.62,0.63,0.64,0.65,0.66,0.67,0.68,0.69,0.7,0.71,0.72,0.73,0.74,0.75,0.76,0.77,0.78,0.79,0.8,0.81,0.82,0.83,0.84,0.85,0.86,0.87,0.88,0.89,0.9,0.92,0.95,0.97,1.0,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9,2.0,2.2,2.5,2.7,3.0,3.2,3.5,3.7,4.0,4.2,4.5,4.7,5.0,5.2,5.7,6.0,6.5,7.0,7.5,8.0,8.5,9.0,\n# 10.0,11.0,12.0,13.0,14.0,15.0,16.0,17.0,18.0,19.0,20.0,21.0,22.0,23.0,24.0,25.0,26.0,27.0,28.0,29.0,30.0,31.0,32.0,33.0,34.0,35.0,36.0,37.0,38.0,39.0,40.0,\n# 50.0,60.0])\n# 41.0,42.0,43.0,44.0,45.0,46.0,47.0,48.0,49.0,50.0,51.0,52.0,53.0,54.0,55.0,56.0,57.0,58.0,59.0,60.0])\n # 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0, 49.0, 50.0, 51.0, 52.0, 53.0, 54.0, 55.0, 56.0,\n # 57.0, 58.0, 59.0, 60.0,61.0,62.0,63.0,64.0,65.0,66.0,67.0,68.0,69.0,70.0,71.0,72.0,73.0,74.0,75.0,76.0,77.0,78.0,79.0,80.0,\n # 85.0,90.0,100.0,110.0,120.0,130.0,140.0,150.0,160.0,170.0,180.0,200.0])\n\nprint(\"EXCITATORY\")\nprint(\"'P_e':\",np.array2string(engin(parameters=excitatory,excitatory=True,max_frequency=40.0,precision=0.5), separator=', '),\",\",sep='')\n# print(\"'P_e':\",np.array2string(engin(parameters=excitatory,excitatory=True,max_frequency=40.0,precision=0.5,rescale=[32,33,56,57,59,60,62,63]), separator=', '),\",\",sep='')\nprint(\"INHIBITORY\")\n# print(\"'P_i':\",np.array2string(engin(parameters=inhibitory,excitatory=False,max_frequency=40.0,precision=0.5), separator=', '),\",\",sep='')\n# print(\"'P_i':\",np.array2string(engin(parameters=inhibitory,excitatory=False,max_frequency=40.0,precision=0.5,rescale=[5,6]), separator=', '),\",\",sep='')\n# print(engin(parameters=default,frequency=frequency))\n# print(engin(parameters=default,max_frequency=60.0,precision=0.5))\n# print(engin(parameters=default,max_frequency=100.0,precision=0.5))\n# np.set_printoptions(linewidth=500)\n# int_first = 200\nprint(\"EXCITATORY\")\n# print(\"'P_e':\",np.array2string(engin(parameters=excitatory,excitatory=True,max_frequency=100.0,precision=0.5,rescale=[10,12,123,124,174]), separator=', '),\",\",sep='')\n# rescale = np.arange(int_first,200)\n# print(\"'P_e':\",np.array2string(engin(parameters=excitatory,excitatory=True,max_frequency=100.0,precision=0.5,rescale=rescale), separator=', '),\",\",sep='')\n# print(\"'P_e':\",np.array2string(engin(parameters=excitatory,max_frequency=40.0,precision=0.5), separator=', '),\",\",sep='')\nprint(\"INHIBITORY\")\n# print(\"'P_i':\",np.array2string(engin(parameters=inhibitory,excitatory=False,max_frequency=100.0,precision=0.5,rescale=[3,4,44,45,59,60,81,82,105,106,109,110,111,112,113,114,194,195]), separator=', '),\",\",sep='')\n# print(\"'P_i':\",np.array2string(engin(parameters=inhibitory,excitatory=False,max_frequency=100.0,precision=0.5,rescale=[44,45,59,60,81,82,105,106,109,110,111,112,194,195]), separator=', '),\",\",sep='')\n# rescale = np.arange(int_first,200)\n# print(\"'P_i':\",np.array2string(engin(parameters=inhibitory,excitatory=False,max_frequency=100.0,precision=0.5,rescale=rescale), separator=', '),\",\",sep='')\n# print(\"'P_i':\",np.array2string(engin(parameters=inhibitory,max_frequency=40.0,precision=0.5), separator=', '),\",\",sep='')\n\n\ndef model_end (g_L,E_L,V_reset,I_e,C_m,V_th,t_ref,tau_w,Delta_T,b,a,E_ex,E_in,tau_syn_ex,tau_syn_in,Q_e,Q_i,N_tot,p_connect,g):\n parameters= { 'g_L':g_L,\n 'E_L':E_L,\n 'V_reset':V_reset,\n 'I_e':I_e,\n 'C_m':C_m,\n 'V_th':V_th,\n 't_ref':t_ref,\n 'tau_w':tau_w,\n 'Delta_T':Delta_T,\n 'b':b,\n 'a':a,\n 'V_peak':-10.0,\n 'E_ex':E_ex,\n 'E_in':E_in,\n 'tau_syn_ex':tau_syn_ex,\n 'tau_syn_in':tau_syn_in,\n 'Q_e': Q_e,\n 'Q_i' : Q_i,\n 'N_tot' : N_tot,\n 'p_connect' : p_connect,\n 'g': g\n }\n\n return None, engin(parameters=parameters,max_frequency=40.0)", "meta": {"hexsha": "731680adcbe95e2447018ee17a5495206c5daca5", "size": 23603, "ext": "py", "lang": "Python", "max_stars_repo_path": "fitting_TF/history/function_fitting.py", "max_stars_repo_name": "lionelkusch/compare_zerlaut", "max_stars_repo_head_hexsha": "4e22d1fdc5889fb404187bb7a48d7847759443d6", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "fitting_TF/history/function_fitting.py", "max_issues_repo_name": "lionelkusch/compare_zerlaut", "max_issues_repo_head_hexsha": "4e22d1fdc5889fb404187bb7a48d7847759443d6", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "fitting_TF/history/function_fitting.py", "max_forks_repo_name": "lionelkusch/compare_zerlaut", "max_forks_repo_head_hexsha": "4e22d1fdc5889fb404187bb7a48d7847759443d6", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 50.8685344828, "max_line_length": 342, "alphanum_fraction": 0.5872558573, "include": true, "reason": "import numpy,import scipy,from scipy", "num_tokens": 7308, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5350984286266116, "lm_q2_score": 0.35577489351363034, "lm_q1q2_score": 0.19037458646394367}} {"text": "\"\"\" scan info for specific reaction classes\n\"\"\"\n\nimport math\nimport numpy\nimport more_itertools as mit\nfrom phydat import phycon, bnd\nfrom automol.graph import ts\nfrom automol.par import ReactionClass\nimport automol.zmat\nfrom automol.util import dict_\n# from automol.util import numpy_to_float\nfrom automol.reac._util import hydrogen_migration_atom_keys\nfrom automol.reac._util import ring_forming_scission_chain\nfrom automol.reac._util import insertion_forming_bond_keys\nfrom automol.reac._util import elimination_breaking_bond_keys\n\n\n# Wrapper function to obtain all of the scan data for a reaction\ndef build_scan_info(zrxn, zma, var=False):\n \"\"\" Build all of the scan information\n \"\"\"\n\n # Obtain the reactions scan and constraint coordinates\n scan_names = scan_coordinate(zrxn, zma)\n const_names = constraint_coordinates(zrxn, zma)\n\n constraint_dct = automol.zmat.constraint_dct(zma, const_names)\n\n # Build the grid\n grids = scan_grid(zrxn, zma, var=var)\n\n # Set the update guess\n update_guess = scan_update_guess(zrxn, var=var)\n\n return scan_names, constraint_dct, grids, update_guess\n\n\n# SCAN AND CONSTRAINT COORDINATES #\n# Unimolecular reactions\n# 1. Hydrogen migrations\ndef hydrogen_migration_scan_coordinate(rxn, zma):\n \"\"\" Obtain the scan coordinate for a hydrogen migration.\n\n :param rxn: a Reaction object\n :returns: the name of the scan coordinate in the z-matrix\n :rtype: str\n \"\"\"\n frm_bnd_key, = ts.forming_bond_keys(rxn.forward_ts_graph)\n scan_name = automol.zmat.distance_coordinate_name(zma, *frm_bnd_key)\n return (scan_name,)\n\n\ndef hydrogen_migration_constraint_coordinates(rxn, zma):\n \"\"\" Obtain the constraint coordinates for a hydrogen migration\n\n :param rxn: a Reaction object\n :returns: the names of the constraint coordinates in the z-matrix\n :rtype: tuple[str]\n \"\"\"\n att_key, _, _, ngb_key = hydrogen_migration_atom_keys(rxn)\n dist_name = automol.zmat.distance_coordinate_name(zma, att_key, ngb_key)\n return (dist_name,)\n\n\ndef hydrogen_migration_grid(zrxn, zma, npoints=(18,)):\n \"\"\" Build forward 1D grid for addition reaction\n \"\"\"\n\n # Obtain the reactions scan and constraint coordinates\n scan_name, = hydrogen_migration_scan_coordinate(zrxn, zma)\n\n # Build the scan grid\n npoints1 = npoints[0]\n interval = 0.3 * phycon.ANG2BOHR\n\n frm_bnd_len = _ts_bnd_len(zma, scan_name)\n rmin1 = 2.0 * phycon.ANG2BOHR\n rmin2 = frm_bnd_len + (0.05 * phycon.ANG2BOHR)\n rmax = frm_bnd_len\n\n if rmax > rmin1:\n npoints = math.ceil((rmax-rmin1)/interval)\n if npoints < 1:\n grid1 = []\n else:\n grid1 = numpy.linspace(rmax, rmin1, npoints)\n else:\n grid1 = []\n\n grid2 = numpy.linspace(rmin1, rmin2, npoints1)\n grid = numpy.concatenate((grid1, grid2), axis=None)\n\n return (grid,)\n\n\n# 2. Beta scissions\ndef beta_scission_scan_coordinate(rxn, zma):\n \"\"\" Obtain the scan coordinate for a beta scission\n\n :param rxn: a Reaction object\n :returns: the name of the scan coordinate in the z-matrix\n :rtype: str\n \"\"\"\n brk_bnd_key, = ts.breaking_bond_keys(rxn.forward_ts_graph)\n scan_name = automol.zmat.distance_coordinate_name(zma, *brk_bnd_key)\n return (scan_name,)\n\n\ndef beta_scission_grid(zrxn, zma, npoints=(14,)):\n \"\"\" Build forward 1D grid for a beta scission reaction\n \"\"\"\n\n # Obtain the reactions scan and constraint coordinates\n scan_name, = beta_scission_scan_coordinate(zrxn, zma)\n\n # Build the scan grid\n npoints1 = npoints[0]\n\n frm_bnd_len = _ts_bnd_len(zma, scan_name)\n if frm_bnd_len is not None:\n rmin = frm_bnd_len + (0.1 * phycon.ANG2BOHR)\n rmax = frm_bnd_len + (0.8 * phycon.ANG2BOHR)\n else:\n rmin = 1.4 * phycon.ANG2BOHR\n rmax = 2.0 * phycon.ANG2BOHR\n grid = numpy.linspace(rmin, rmax, npoints1)\n\n return (grid,)\n\n\n# 3. Ring-forming scissions\ndef ring_forming_scission_scan_coordinate(rxn, zma):\n \"\"\" Obtain the scan coordinate for a ring-forming scission\n\n :param rxn: a Reaction object\n :returns: the name of the scan coordinate in the z-matrix\n :rtype: str\n \"\"\"\n brk_bnd_key, = ts.breaking_bond_keys(rxn.forward_ts_graph)\n scan_name = automol.zmat.distance_coordinate_name(zma, *brk_bnd_key)\n return (scan_name,)\n\n\ndef ring_forming_scission_constraint_coordinates(rxn, zma):\n \"\"\" Obtain the constraint coordinates for a ring-forming scission\n\n :param rxn: a Reaction object\n :returns: the names of the constraint coordinates in the z-matrix\n :rtype: str\n \"\"\"\n chain_keys = ring_forming_scission_chain(rxn)\n ang_keys_lst = sorted(mit.windowed(chain_keys[1:], 3))\n dih_keys_lst = sorted(mit.windowed(chain_keys, 4))\n ang_names = [automol.zmat.central_angle_coordinate_name(zma, *ks)\n for ks in ang_keys_lst]\n dih_names = [automol.zmat.dihedral_angle_coordinate_name(zma, *ks)\n for ks in dih_keys_lst]\n const_names = tuple(ang_names + dih_names)\n return const_names\n\n\ndef ring_forming_scission_grid(zrxn, zma, npoints=(7,)):\n \"\"\" Build forward WD grid for a ring forming scission reaction\n # the following allows for a 2-d grid search in the initial ts_search\n # for now try 1-d grid and see if it is effective\n \"\"\"\n\n # Obtain the scan coordinate\n scan_name, = ring_forming_scission_scan_coordinate(zrxn, zma)\n\n # Build the grid\n npoints1 = npoints[0]\n\n brk_bnd_len = _ts_bnd_len(zma, scan_name)\n if brk_bnd_len is not None:\n r1min = brk_bnd_len + (0.1 * phycon.ANG2BOHR)\n r1max = brk_bnd_len + (0.7 * phycon.ANG2BOHR)\n else:\n r1min = (1.54 + 0.1) * phycon.ANG2BOHR\n r1max = (1.54 + 0.7) * phycon.ANG2BOHR\n\n grid1 = numpy.linspace(r1min, r1max, npoints1)\n grid = tuple(val.item() for val in grid1)\n\n return (grid,)\n\n\n# 4. Eliminations\ndef elimination_scan_coordinate(rxn, zma):\n \"\"\" Obtain the scan coordinate for an elimination\n\n :param rxn: a Reaction object\n :returns: the name of the scan coordinate in the z-matrix\n :rtype: str\n \"\"\"\n frm_bnd_key, = ts.forming_bond_keys(rxn.forward_ts_graph)\n\n brk_bnd_key1, _ = elimination_breaking_bond_keys(rxn)\n\n frm_name = automol.zmat.distance_coordinate_name(zma, *frm_bnd_key)\n brk_name = automol.zmat.distance_coordinate_name(zma, *brk_bnd_key1)\n\n return (frm_name, brk_name)\n\n\ndef elimination_grid(zrxn, zma, npoints=(7, 5)):\n \"\"\" Build forward 2D grid for elimination reaction\n \"\"\"\n\n # Obtain the scan coordinate\n frm_name, brk_name = elimination_scan_coordinate(zrxn, zma)\n\n # Build the grid\n npoints1, npoints2 = npoints\n\n frm_bnd_len = _ts_bnd_len(zma, frm_name)\n brk_bnd_len = _ts_bnd_len(zma, brk_name)\n if frm_bnd_len is not None:\n r1min = frm_bnd_len + (0.1 * phycon.ANG2BOHR)\n r1max = frm_bnd_len + (0.6 * phycon.ANG2BOHR)\n else:\n r1min = (0.85 + 0.1) * phycon.ANG2BOHR\n r1max = (0.85 + 0.8) * phycon.ANG2BOHR\n if brk_bnd_len is not None:\n r2min = brk_bnd_len + (0.3 * phycon.ANG2BOHR)\n r2max = brk_bnd_len + (1.2 * phycon.ANG2BOHR)\n else:\n r2min = (1.50 + 0.3) * phycon.ANG2BOHR\n r2max = (1.50 + 1.2) * phycon.ANG2BOHR\n\n grid1 = numpy.linspace(r1min, r1max, npoints1) * phycon.ANG2BOHR\n grid2 = numpy.linspace(r2min, r2max, npoints2) * phycon.ANG2BOHR\n\n return (grid1, grid2)\n\n\n# Bimolecular reactions\n# 1. Hydrogen abstractions\ndef hydrogen_abstraction_scan_coordinate(rxn, zma):\n \"\"\" Obtain the scan coordinate for a hydrogen abstraction\n\n :param rxn: a Reaction object\n :returns: the name of the scan coordinate in the z-matrix\n :rtype: str\n \"\"\"\n frm_bnd_key, = ts.forming_bond_keys(rxn.forward_ts_graph)\n scan_name = automol.zmat.distance_coordinate_name(zma, *frm_bnd_key)\n return (scan_name,)\n\n\ndef hydrogen_abstraction_grid(zrxn, zma, npoints=(8,)):\n \"\"\" Build forward 1D grid for hydrogen abstraction reaction\n \"\"\"\n\n # Obtain the scan coordinate\n scan_name, = hydrogen_abstraction_scan_coordinate(zrxn, zma)\n\n # Build the grid\n npoints1 = npoints[0]\n\n frm_bnd_len = _ts_bnd_len(zma, scan_name)\n if frm_bnd_len is not None:\n rmin = frm_bnd_len + (0.1 * phycon.ANG2BOHR)\n rmax = frm_bnd_len + (1.0 * phycon.ANG2BOHR)\n else:\n rmin = 0.7 * phycon.ANG2BOHR\n rmax = 2.2 * phycon.ANG2BOHR\n grid = numpy.linspace(rmin, rmax, npoints1)\n\n return (grid,)\n\n\ndef radrad_hydrogen_abstraction_grid(zrxn, zma, npoints=(8, 4)):\n \"\"\" Build forward 1D grid for elimination reaction\n \"\"\"\n\n # Obtain the scan coordinate\n scan_name, = hydrogen_abstraction_scan_coordinate(zrxn, zma)\n\n # Build the grid\n npoints1, npoints2 = npoints\n\n # Get the first grid from close to the mid\n frm_bnd_len = _ts_bnd_len(zma, scan_name)\n if frm_bnd_len is not None:\n rmin = frm_bnd_len + (0.1 * phycon.ANG2BOHR)\n rmax = frm_bnd_len + (1.0 * phycon.ANG2BOHR)\n else:\n rmin = 0.7 * phycon.ANG2BOHR\n rmax = 2.2 * phycon.ANG2BOHR\n\n grid1 = numpy.linspace(rmin, rmax, npoints1)\n grid1 = numpy.flip(grid1)\n\n # Get the outer grid from mid to long-distance\n rend2 = 4.0 * phycon.ANG2BOHR\n grid2 = numpy.linspace(rmax, rend2, npoints2+1)\n # grid2 = numpy.delete(grid2, 0)\n\n return (grid1, grid2)\n\n\n# 2. Additions\ndef addition_scan_coordinate(rxn, zma):\n \"\"\" Obtain the scan coordinate for an addition\n\n :param rxn: a Reaction object\n :returns: the name of the scan coordinate in the z-matrix\n :rtype: str\n \"\"\"\n frm_bnd_key, = ts.forming_bond_keys(rxn.forward_ts_graph)\n scan_name = automol.zmat.distance_coordinate_name(zma, *frm_bnd_key)\n return (scan_name,)\n\n\ndef addition_grid(zrxn, zma, npoints=(14,)):\n \"\"\" Build forward 1D grid for addition reaction\n \"\"\"\n\n # Obtain the scan coordinate\n scan_name, = addition_scan_coordinate(zrxn, zma)\n\n # Build the grid\n npoints1 = npoints[0]\n\n frm_bnd_len = _ts_bnd_len(zma, scan_name)\n if frm_bnd_len is not None:\n rmin = frm_bnd_len + (0.1 * phycon.ANG2BOHR)\n rmax = frm_bnd_len + (1.2 * phycon.ANG2BOHR)\n else:\n rmin = 1.6 * phycon.ANG2BOHR\n rmax = 2.8 * phycon.ANG2BOHR\n\n grid = _geometric_progression(\n rmin, rmax, npoints1, gfact=1.1, rstp=0.05)\n\n return (grid,)\n\n\ndef radrad_addition_grid(zrxn, zma, npoints=(8, 4)):\n \"\"\" Build forward 1D grid for a beta scission reaction\n \"\"\"\n\n # Obtain the scan coordinate\n scan_name, = addition_scan_coordinate(zrxn, zma)\n\n # Build the grid\n npoints1, npoints2 = npoints\n\n # Get the first grid from close to the mid\n frm_bnd_len = _ts_bnd_len(zma, scan_name)\n if frm_bnd_len is not None:\n rmin = frm_bnd_len + (0.2 * phycon.ANG2BOHR)\n rmax = frm_bnd_len + (1.2 * phycon.ANG2BOHR)\n else:\n rmin = 1.5 * phycon.ANG2BOHR\n rmax = 2.8 * phycon.ANG2BOHR\n\n grid1 = numpy.linspace(rmin, rmax, npoints1)\n grid1 = numpy.flip(grid1)\n # grid1 = _geometric_progression(\n # rmin, rmax, npoints1, gfact=1.1, rstp=0.05)\n\n # Get the outer grid from mid to long-distance\n # Add extra point since initial will be dropped\n rend2 = 4.00 * phycon.ANG2BOHR\n grid2 = numpy.linspace(rmax, rend2, npoints2+1)\n # grid2 = numpy.delete(grid2, 0)\n\n return (grid1, grid2)\n\n\n# 3. Insertions\ndef insertion_scan_coordinate(rxn, zma):\n \"\"\" Obtain the scan coordinate for an insertion\n\n :param rxn: a Reaction object\n :returns: the name of the scan coordinate in the z-matrix\n :rtype: str\n \"\"\"\n frm_bnd_key, _ = insertion_forming_bond_keys(rxn)\n scan_name = automol.zmat.distance_coordinate_name(zma, *frm_bnd_key)\n return (scan_name,)\n\n\ndef insertion_grid(zrxn, zma, npoints=(16,)):\n \"\"\" Build forward 1D grid for insertion reaction\n \"\"\"\n\n # Obtain the scan coordinate\n scan_name, = insertion_scan_coordinate(zrxn, zma)\n\n # Build the grid\n npoints1 = npoints[0]\n\n frm_bnd_len = _ts_bnd_len(zma, scan_name)\n if frm_bnd_len is not None:\n rmin = frm_bnd_len\n rmax = frm_bnd_len + (1.4 * phycon.ANG2BOHR)\n else:\n rmin = 1.4 * phycon.ANG2BOHR\n rmax = 2.4 * phycon.ANG2BOHR\n\n grid = numpy.linspace(rmin, rmax, npoints1)\n\n return (grid,)\n\n\n# 4. Substitution\ndef substitution_scan_coordinate(rxn, zma):\n \"\"\" Obtain the scan coordinate for a substitution\n\n :param rxn: a Reaction object\n :returns: the name of the scan coordinate in the z-matrix\n :rtype: str\n \"\"\"\n frm_bnd_key, = ts.forming_bond_keys(rxn.forward_ts_graph)\n scan_name = automol.zmat.distance_coordinate_name(zma, *frm_bnd_key)\n return (scan_name,)\n\n\ndef substitution_grid(zrxn, zma, npoints=(14,)):\n \"\"\" Build forward 1D grid for substitution reaction\n \"\"\"\n\n # Obtain the scan coordinate\n scan_name, = substitution_scan_coordinate(zrxn, zma)\n\n # Build the grid\n npoints1 = npoints[0]\n\n frm_bnd_len = _ts_bnd_len(zma, scan_name)\n if frm_bnd_len is not None:\n rmin = frm_bnd_len\n rmax = frm_bnd_len + (1.4 * phycon.ANG2BOHR)\n else:\n rmin = 0.7 * phycon.ANG2BOHR\n rmax = 2.4 * phycon.ANG2BOHR\n\n grid = numpy.linspace(rmin, rmax, npoints1)\n\n return (grid,)\n\n\n# Aux function to return empty tuple when info not require for class\ndef _return_empty_tuple(*_):\n \"\"\" Return empty tuple\n \"\"\"\n return ()\n\n\n# Wrapper functions to handle rxn obj and zma for any reaction class\nSCAN_COORD_DCT = {\n # unimolecular\n ReactionClass.Typ.HYDROGEN_MIGRATION:\n hydrogen_migration_scan_coordinate,\n ReactionClass.Typ.BETA_SCISSION: beta_scission_scan_coordinate,\n ReactionClass.Typ.RING_FORM_SCISSION:\n ring_forming_scission_scan_coordinate,\n ReactionClass.Typ.ELIMINATION: elimination_scan_coordinate,\n # bimolecular\n ReactionClass.Typ.HYDROGEN_ABSTRACTION:\n hydrogen_abstraction_scan_coordinate,\n ReactionClass.Typ.ADDITION: addition_scan_coordinate,\n ReactionClass.Typ.INSERTION: insertion_scan_coordinate,\n ReactionClass.Typ.SUBSTITUTION: substitution_scan_coordinate,\n}\n\n\ndef scan_coordinate(rxn, zma):\n \"\"\" Obtain the scan coordinates\n\n :param rxn: a hydrogen migration Reaction object\n \"\"\"\n return SCAN_COORD_DCT[rxn.class_](rxn, zma)\n\n\nCONSTRAINT_COORD_DCT = {\n # unimolecular\n ReactionClass.Typ.HYDROGEN_MIGRATION:\n hydrogen_migration_constraint_coordinates,\n ReactionClass.Typ.BETA_SCISSION: _return_empty_tuple,\n ReactionClass.Typ.RING_FORM_SCISSION:\n ring_forming_scission_constraint_coordinates,\n ReactionClass.Typ.ELIMINATION: _return_empty_tuple,\n # bimolecular\n ReactionClass.Typ.HYDROGEN_ABSTRACTION:\n _return_empty_tuple,\n ReactionClass.Typ.ADDITION: _return_empty_tuple,\n ReactionClass.Typ.INSERTION: _return_empty_tuple,\n ReactionClass.Typ.SUBSTITUTION: _return_empty_tuple,\n}\n\n\ndef constraint_coordinates(rxn, zma):\n \"\"\" Obtain the constraint coordinates\n\n :param rxn: a hydrogen migration Reaction object\n \"\"\"\n return CONSTRAINT_COORD_DCT[rxn.class_](rxn, zma)\n\n\nTIGHT_TS_GRID_DCT = {\n ReactionClass.Typ.BETA_SCISSION: beta_scission_grid,\n ReactionClass.Typ.ADDITION: addition_grid,\n ReactionClass.Typ.HYDROGEN_MIGRATION: hydrogen_migration_grid,\n ReactionClass.Typ.ELIMINATION: elimination_grid,\n ReactionClass.Typ.RING_FORM_SCISSION: ring_forming_scission_grid,\n ReactionClass.Typ.HYDROGEN_ABSTRACTION: hydrogen_abstraction_grid,\n ReactionClass.Typ.SUBSTITUTION: substitution_grid,\n ReactionClass.Typ.INSERTION: insertion_grid\n}\nVAR_TS_GRID_DCT = {\n ReactionClass.Typ.ADDITION: radrad_addition_grid,\n ReactionClass.Typ.HYDROGEN_ABSTRACTION: radrad_hydrogen_abstraction_grid\n}\n\n\ndef scan_grid(zrxn, zma, var=False):\n \"\"\" Set the grid for a transition state search\n \"\"\"\n\n if not var:\n grid = TIGHT_TS_GRID_DCT[zrxn.class_](zrxn, zma)\n else:\n grid = VAR_TS_GRID_DCT[zrxn.class_](zrxn, zma)\n\n return grid\n\n\n# UPDATE GUESS DICTIONARY #\nTIGHT_TS_UPDATE_GUESS_DCT = {\n ReactionClass.Typ.BETA_SCISSION: False,\n ReactionClass.Typ.ADDITION: False,\n ReactionClass.Typ.HYDROGEN_MIGRATION: True,\n ReactionClass.Typ.ELIMINATION: False,\n ReactionClass.Typ.RING_FORM_SCISSION: False,\n ReactionClass.Typ.HYDROGEN_ABSTRACTION: False,\n ReactionClass.Typ.SUBSTITUTION: False,\n ReactionClass.Typ.INSERTION: False\n}\nVAR_TS_UPDATE_GUESS_DCT = {\n ReactionClass.Typ.ADDITION: True,\n ReactionClass.Typ.HYDROGEN_ABSTRACTION: True\n}\n\n\ndef scan_update_guess(zrxn, var=False):\n \"\"\" Set boolean to control whether the initial guess structure for\n optimization updates along scan, i.e., uses optimized geometry\n from previous grid point\n \"\"\"\n\n if not var:\n _update = TIGHT_TS_UPDATE_GUESS_DCT[zrxn.class_]\n else:\n _update = VAR_TS_UPDATE_GUESS_DCT[zrxn.class_]\n\n return _update\n\n\n# Helper functions\ndef _ts_bnd_len(zma, scan_coord):\n \"\"\" Obtain the current value of the bond defined by the scam coordinate\n \"\"\"\n\n symbs = automol.zmat.symbols(zma)\n dist_coo, = automol.zmat.coordinates(zma)[scan_coord]\n ts_bnd_symbs = tuple(sorted(map(symbs.__getitem__, dist_coo)))\n ts_bnd_len = dict_.values_by_unordered_tuple(bnd.LEN_DCT, ts_bnd_symbs)\n\n return ts_bnd_len\n\n\ndef _geometric_progression(rmin, rmax, npoints, gfact=1.1, rstp=0.05):\n \"\"\" Build a grid using a geometric progresion\n \"\"\"\n grid = [rmin]\n rgrid = rmin\n for _ in range(npoints):\n rgrid += rstp\n if rgrid == rmax:\n break\n grid.append(rgrid)\n rstp = rstp * gfact\n grid = numpy.array(grid)\n\n return grid\n", "meta": {"hexsha": "4ac287082dfa978a60928cb34b6bbeb7caa7c9a8", "size": 17675, "ext": "py", "lang": "Python", "max_stars_repo_path": "automol/reac/_scan.py", "max_stars_repo_name": "sjklipp/automol", "max_stars_repo_head_hexsha": "ba87f4443ebe2ceb5929d4269c4be93fd28f68ca", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "automol/reac/_scan.py", "max_issues_repo_name": "sjklipp/automol", "max_issues_repo_head_hexsha": "ba87f4443ebe2ceb5929d4269c4be93fd28f68ca", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "automol/reac/_scan.py", "max_forks_repo_name": "sjklipp/automol", "max_forks_repo_head_hexsha": "ba87f4443ebe2ceb5929d4269c4be93fd28f68ca", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2019-12-18T20:11:06.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-14T08:54:16.000Z", "avg_line_length": 29.9576271186, "max_line_length": 77, "alphanum_fraction": 0.6981612447, "include": true, "reason": "import numpy", "num_tokens": 5263, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5350984286266115, "lm_q2_score": 0.35577489351363034, "lm_q1q2_score": 0.19037458646394362}} {"text": "# Copyright 2016-2021 The Van Valen Lab at the California Institute of\n# Technology (Caltech), with support from the Paul Allen Family Foundation,\n# Google, & National Institutes of Health (NIH) under Grant U24CA224309-01.\n# All rights reserved.\n#\n# Licensed under a modified Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.github.com/vanvalenlab/deepcell-tf/LICENSE\n#\n# The Work provided may be used for non-commercial academic purposes only.\n# For any other use of the Work, including commercial use, please contact:\n# vanvalenlab@gmail.com\n#\n# Neither the name of Caltech nor the names of its contributors may be used\n# to endorse or promote products derived from this software without specific\n# prior written permission.\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Custom metrics for pixel-based and object-based classification accuracy.\n\nThe schema for this analysis was adopted from the description of object-based\nstatistics in Caicedo et al. (2018) Evaluation of Deep Learning Strategies for\nNucleus Segmentation in Fluorescence Images. BioRxiv 335216.\n\nThe SEG metric was adapted from Maska et al. (2014). A benchmark for comparison\nof cell tracking algorithms. Bioinformatics 30, 1609-1617.\n\nThe linear classification schema used to match objects in truth and prediction\nframes was adapted from Jaqaman et al. (2008). Robust single-particle tracking\nin live-cell time-lapse sequences. Nature Methods 5, 695-702.\n\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import print_function\nfrom __future__ import division\n\nimport datetime\nimport json\nimport logging\nimport operator\nimport os\nimport warnings\n\nimport numpy as np\nimport pandas as pd\nimport networkx as nx\n\nfrom scipy.optimize import linear_sum_assignment\nfrom scipy.stats import hmean\nfrom skimage.measure import regionprops\nfrom skimage.segmentation import relabel_sequential\nfrom sklearn.metrics import confusion_matrix\nfrom tqdm import tqdm\n\nfrom deepcell_toolbox import erode_edges\nfrom deepcell_toolbox.compute_overlap import compute_overlap # pylint: disable=E0401\nfrom deepcell_toolbox.compute_overlap import compute_overlap_3D\n\n\ndef _cast_to_tuple(x):\n try:\n tup_x = tuple(x)\n except TypeError:\n tup_x = () if x is None else (x,)\n return tup_x\n\n\nclass Detection(object): # pylint: disable=useless-object-inheritance\n \"\"\"Object to hold relevant information about a given detection.\"\"\"\n\n def __init__(self, true_index=None, pred_index=None):\n # cast the indices as tuples if possible to make them immutable\n try:\n self.true_index = tuple(true_index)\n except TypeError:\n self.true_index = true_index\n try:\n self.pred_index = tuple(pred_index)\n except TypeError:\n self.pred_index = pred_index\n\n def __eq__(self, other):\n \"\"\"Custom comparator. Detections with the same indices are the same.\"\"\"\n try:\n is_true_same = self.true_index == other.true_index\n is_pred_same = self.pred_index == other.pred_index\n return is_true_same and is_pred_same\n except AttributeError:\n return False\n\n def __hash__(self):\n \"\"\"Custom hasher, allow Detections to be hashable.\"\"\"\n return tuple((self.true_index, self.pred_index)).__hash__()\n\n def __repr__(self):\n return 'Detection({}, {})'.format(self.true_index, self.pred_index)\n\n @property\n def is_correct(self):\n is_linked = self.true_index is not None and self.pred_index is not None\n return is_linked and not self.is_split and not self.is_merge\n\n @property\n def is_gained(self):\n return self.true_index is None and self.pred_index is not None\n\n @property\n def is_missed(self):\n return self.true_index is not None and self.pred_index is None\n\n @property\n def is_split(self):\n if self.is_gained or self.is_missed:\n return False\n\n try:\n is_many_pred = len(self.pred_index) > 1\n except TypeError:\n is_many_pred = False\n\n try:\n is_single_true = len(tuple(self.true_index)) == 1\n except TypeError:\n is_single_true = isinstance(self.true_index, int)\n\n return is_single_true and is_many_pred\n\n @property\n def is_merge(self):\n if self.is_gained or self.is_missed:\n return False\n\n try:\n is_many_true = len(self.true_index) > 1\n except TypeError:\n is_many_true = False\n\n try:\n is_single_pred = len(tuple(self.pred_index)) == 1\n except TypeError:\n is_single_pred = isinstance(self.pred_index, int)\n\n return is_single_pred and is_many_true\n\n @property\n def is_catastrophe(self):\n if self.is_gained or self.is_missed:\n return False\n\n try:\n is_many_true = len(self.true_index) > 1\n except TypeError:\n is_many_true = False\n\n try:\n is_many_pred = len(self.pred_index) > 1\n except TypeError:\n is_many_pred = False\n\n return is_many_true and is_many_pred\n\n\nclass BaseMetrics(object): # pylint: disable=useless-object-inheritance\n\n \"\"\"Base class for Metrics classes.\"\"\"\n\n def __init__(self, y_true, y_pred):\n if y_pred.shape != y_true.shape:\n raise ValueError('Input shapes must match. Shape of prediction '\n 'is: {}. Shape of y_true is: {}'.format(\n y_pred.shape, y_true.shape))\n\n if not np.issubdtype(y_true.dtype, np.integer):\n warnings.warn('Casting y_true from {} to int'.format(y_true.dtype))\n y_true = y_true.astype('int32')\n\n if not np.issubdtype(y_pred.dtype, np.integer):\n warnings.warn('Casting y_pred from {} to int'.format(y_pred.dtype))\n y_pred = y_pred.astype('int32')\n\n self.y_true = y_true\n self.y_pred = y_pred\n\n\nclass PixelMetrics(BaseMetrics):\n \"\"\"Calculates pixel-based statistics.\n (Dice, Jaccard, Precision, Recall, F-measure)\n\n Takes in raw prediction and truth data in order to calculate accuracy\n metrics for pixel based classfication. Statistics were chosen according\n to the guidelines presented in Caicedo et al. (2018) Evaluation of Deep\n Learning Strategies for Nucleus Segmentation in Fluorescence Images.\n BioRxiv 335216.\n\n Args:\n y_true (numpy.array): Binary ground truth annotations for a single\n feature, (batch,x,y)\n y_pred (numpy.array): Binary predictions for a single feature,\n (batch,x,y)\n\n Raises:\n ValueError: Shapes of y_true and y_pred do not match.\n\n Warning:\n Comparing labeled to unlabeled data will produce low accuracy scores.\n Make sure to input the same type of data for y_true and y_pred\n \"\"\"\n\n def __init__(self, y_true, y_pred):\n super(PixelMetrics, self).__init__(\n y_true=(y_true != 0).astype('int'),\n y_pred=(y_pred != 0).astype('int'))\n\n self._y_true_sum = np.count_nonzero(self.y_true)\n self._y_pred_sum = np.count_nonzero(self.y_pred)\n\n # Calculations for IOU\n self._intersection = np.count_nonzero(np.logical_and(self.y_true, self.y_pred))\n self._union = np.count_nonzero(np.logical_or(self.y_true, self.y_pred))\n\n @classmethod\n def get_confusion_matrix(cls, y_true, y_pred, axis=-1):\n \"\"\"Calculate confusion matrix for pixel classification data.\n\n Args:\n y_true (numpy.array): Ground truth annotations after any\n necessary transformations\n y_pred (numpy.array): Prediction array\n axis (int): The channel axis of the input arrays.\n\n Returns:\n numpy.array: nxn confusion matrix determined by number of features.\n \"\"\"\n # Argmax collapses on feature dimension to assign class to each pixel\n # Flatten is required for confusion matrix\n y_true = y_true.argmax(axis=axis).flatten()\n y_pred = y_pred.argmax(axis=axis).flatten()\n return confusion_matrix(y_true, y_pred)\n\n @property\n def recall(self):\n try:\n _recall = self._intersection / self._y_true_sum\n except ZeroDivisionError:\n _recall = np.nan\n return _recall\n\n @property\n def precision(self):\n try:\n _precision = self._intersection / self._y_pred_sum\n except ZeroDivisionError:\n _precision = 0\n return _precision\n\n @property\n def f1(self):\n _recall = self.recall\n _precision = self.precision\n\n # f1 is nan if recall is nan and no false negatives\n if np.isnan(_recall) and _precision == 0:\n return np.nan\n\n f_measure = hmean([_recall, _precision])\n # f_measure = (2 * _precision * _recall) / (_precision + _recall)\n return f_measure\n\n @property\n def dice(self):\n y_sum = self._y_true_sum + self._y_pred_sum\n if y_sum == 0:\n warnings.warn('DICE score is technically 1.0, '\n 'but prediction and truth arrays are empty.')\n return 1.0\n\n return 2.0 * self._intersection / y_sum\n\n @property\n def jaccard(self):\n try:\n _jaccard = self._intersection / self._union\n except ZeroDivisionError:\n _jaccard = np.nan\n return _jaccard\n\n def to_dict(self):\n return {\n 'jaccard': self.jaccard,\n 'recall': self.recall,\n 'precision': self.precision,\n 'f1': self.f1,\n 'dice': self.dice,\n }\n\n\ndef get_box_labels(arr):\n \"\"\"Get the bounding box and label for all objects in the image.\n\n Args:\n arr (np.array): integer label array of objects.\n\n Returns:\n tuple(list(np.array), list(int)): A tuple of bounding boxes and\n the corresponding integer labels.\n \"\"\"\n props = regionprops(np.squeeze(arr.astype('int')), cache=False)\n boxes, labels = [], []\n for prop in props:\n boxes.append(np.array(prop.bbox))\n labels.append(int(prop.label))\n boxes = np.array(boxes).astype('double')\n return boxes, labels\n\n\nclass ObjectMetrics(BaseMetrics):\n \"\"\"Classifies object prediction errors as TP, FP, FN, merge or split\n\n The schema for this analysis was adopted from the description of\n object-based statistics in Caicedo et al. (2018) Evaluation of Deep\n Learning Strategies for Nucleus Segmentation in Fluorescence Images.\n BioRxiv 335216.\n The SEG metric was adapted from Maska et al. (2014). A benchmark for\n comparison of cell tracking algorithms.\n Bioinformatics 30, 1609-1617.\n The linear classification schema used to match objects in truth and\n prediction frames was adapted from Jaqaman et al. (2008).\n Robust single-particle tracking in live-cell time-lapse sequences.\n Nature Methods 5, 695-702.\n\n Args:\n y_true (numpy.array): Labeled ground truth annotation\n y_pred (numpy.array): Labled object prediction, same size as y_true\n cutoff1 (:obj:`float`, optional): Threshold for overlap in cost matrix,\n smaller values are more conservative, default 0.4\n cutoff2 (:obj:`float`, optional): Threshold for overlap in unassigned\n cells, smaller values are better, default 0.1\n seg (:obj:`bool`, optional): Calculates SEG score for cell tracking\n competition\n force_event_links(:obj:'bool, optional): Flag that determines whether to modify IOU\n calculation so that merge or split events with cells of very different sizes are\n never misclassified as misses/gains.\n is_3d(:obj:'bool', optional): Flag that determines whether or not the input data\n should be treated as 3-dimensional.\n\n Raises:\n ValueError: If y_true and y_pred are not the same shape\n ValueError: If data_type is 2D, if input shape does not have ndim 2 or 3\n ValueError: If data_type is 3D, if input shape does not have ndim 3\n \"\"\"\n def __init__(self,\n y_true,\n y_pred,\n cutoff1=0.4,\n cutoff2=0.1,\n force_event_links=False,\n is_3d=False):\n\n # If 2D, dimensions can be 3 or 4 (with or without channel dimension)\n if not is_3d and y_true.ndim not in {2, 3}:\n raise ValueError('Expected dimensions for y_true (2D data) are 2 '\n '(x, y) and 3 (x, y, chan). '\n 'Got ndim: {}'.format(y_true.ndim))\n\n elif is_3d and y_true.ndim != 3:\n raise ValueError('Expected dimensions for y_true (3D data) is 3.'\n 'Requires format is: (z, x, y)'\n 'Got ndim: {}'.format(y_true.ndim))\n\n super(ObjectMetrics, self).__init__(y_true=y_true, y_pred=y_pred)\n\n self.cutoff1 = cutoff1\n self.cutoff2 = cutoff2\n self.is_3d = is_3d\n\n self.compute_overlap = compute_overlap_3D if is_3d else compute_overlap\n\n self.n_true = len(np.unique(self.y_true[np.nonzero(self.y_true)]))\n self.n_pred = len(np.unique(self.y_pred[np.nonzero(self.y_pred)]))\n\n # keep track of every pair of objects through the detections dict\n # using tuple(true_index, pred_index): Detection as a key/vaue pair\n self._detections = set()\n\n # store the keys of relevant Detections in a set for easy fetching\n # types of detections\n self._splits = set()\n self._gained = set()\n self._missed = set()\n # types of errors\n self._merges = set()\n self._catastrophes = set()\n self._correct = set()\n\n # IoU: used to determine relative overlap of y_pred and y_true\n self.iou = np.zeros((self.n_true, self.n_pred))\n\n # used to determine seg score\n self.seg_thresh = np.zeros((self.n_true, self.n_pred))\n\n # Check if either frame is empty before proceeding\n if self.n_true == 0:\n logging.info('Ground truth frame is empty')\n\n if self.n_pred == 0:\n logging.info('Prediction frame is empty')\n\n self._calc_iou() # set self.iou and update self.seg_thresh\n\n self.iou_modified = self._get_modified_iou(force_event_links)\n\n matrix = self._linear_assignment()\n\n # Identify direct matches as true positives\n correct_index = np.nonzero(matrix[:self.n_true, :self.n_pred])\n\n for i, j in zip(correct_index[0], correct_index[1]):\n self._add_detection(true_index=int(i), pred_index=int(j))\n\n # Calc seg score for true positives if requested\n iou_mask = np.where(self.seg_thresh == 0, self.iou, np.nan)\n\n with warnings.catch_warnings():\n warnings.simplefilter('ignore', category=RuntimeWarning)\n # correct_index may be empty, suppress mean of empty slice warning\n self.seg_score = np.nanmean(iou_mask[correct_index])\n\n # Classify other errors using a graph\n G = self._array_to_graph(matrix)\n self._classify_graph(G)\n\n # Calculate pixel-level stats\n self.pixel_stats = PixelMetrics(y_true, y_pred)\n\n def _add_detection(self, true_index=None, pred_index=None):\n detection = Detection(true_index=true_index, pred_index=pred_index)\n\n self._detections.add(detection)\n\n # keep track of all error types\n # TODO: better way to do this?\n if detection.is_correct:\n self._correct.add(detection)\n if detection.is_gained:\n self._gained.add(detection)\n if detection.is_missed:\n self._missed.add(detection)\n if detection.is_split:\n self._splits.add(detection)\n if detection.is_merge:\n self._merges.add(detection)\n if detection.is_catastrophe:\n self._catastrophes.add(detection)\n\n def _calc_iou(self):\n \"\"\"Calculates IoU matrix for each pairwise comparison between true and\n predicted. Additionally, if seg is True, records a 1 for each pair of\n objects where $|Tbigcap P| > 0.5 * |T|$\n \"\"\"\n # Use bounding boxes to find masks that are likely to overlap\n y_true_boxes, y_true_labels = get_box_labels(self.y_true)\n y_pred_boxes, y_pred_labels = get_box_labels(self.y_pred)\n\n if not y_true_boxes.shape[0] or not y_pred_boxes.shape[0]:\n return # cannot compute overlaps of nothing\n\n # has the form [gt_bbox, res_bbox]\n overlaps = self.compute_overlap(y_true_boxes, y_pred_boxes)\n\n # Find the bboxes that have any overlap\n # (ind_ corresponds to box number - starting at 0)\n ind_true, ind_pred = np.nonzero(overlaps)\n\n # TODO: this accounts for ~50+% of the time spent on calc_iou\n for index in range(ind_true.shape[0]):\n iou_y_true_idx = y_true_labels[ind_true[index]]\n iou_y_pred_idx = y_pred_labels[ind_pred[index]]\n\n is_true = self.y_true == iou_y_true_idx\n is_pred = self.y_pred == iou_y_pred_idx\n\n intersection = np.count_nonzero(np.logical_and(is_true, is_pred))\n union = np.count_nonzero(np.logical_or(is_true, is_pred))\n\n iou = intersection / union\n\n # Subtract 1 from index to account for skipping 0\n self.iou[iou_y_true_idx - 1, iou_y_pred_idx - 1] = iou\n\n if intersection > 0.5 * np.count_nonzero(self.y_true == index):\n self.seg_thresh[iou_y_true_idx - 1, iou_y_pred_idx - 1] = 1\n\n def _get_modified_iou(self, force_event_links):\n \"\"\"Modifies the IoU matrix to boost the value for small cells.\n\n Args:\n force_event_links (:obj:`bool'): Whether to modify IOU values of\n large objects if they have been split or merged by\n a small object.\n\n Returns:\n np.array: The modified IoU matrix.\n \"\"\"\n # identify cells that have matches in IOU but may be too small\n true_labels, pred_labels = np.nonzero(\n np.logical_and(self.iou > 0, self.iou < 1 - self.cutoff1)\n )\n\n iou_modified = self.iou.copy()\n\n for idx in range(len(true_labels)):\n # add 1 to get back to original label id\n true_idx, pred_idx = true_labels[idx], pred_labels[idx]\n true_label, pred_label = true_idx + 1, pred_idx + 1\n true_mask = self.y_true == true_label\n pred_mask = self.y_pred == pred_label\n\n # fraction of true cell that is contained within pred cell, vice versa\n true_in_pred = np.count_nonzero(\n self.y_true[pred_mask] == true_label) / np.sum(true_mask)\n pred_in_true = np.count_nonzero(\n self.y_pred[true_mask] == pred_label) / np.sum(pred_mask)\n\n iou_val = self.iou[true_idx, pred_idx]\n max_val = np.max([true_in_pred, pred_in_true])\n\n # if this cell has a small IOU due to its small size,\n # but is at least half contained within the big cell,\n # we bump its IOU value up so it doesn't get dropped from the graph\n if iou_val <= self.cutoff1 and max_val > 0.5:\n iou_modified[true_idx, pred_idx] = self.cutoff2\n\n # optionally, we can also decrease the IOU value of the cell\n # that swallowed up the small cell so that it doesn't directly\n # match a different cell\n if force_event_links and true_in_pred > 0.5:\n fix_idx = np.nonzero(self.iou[:, pred_idx] >= 1 - self.cutoff1)\n iou_modified[fix_idx, pred_idx] = 1 - self.cutoff1 - 0.01\n\n if force_event_links and pred_in_true > 0.5:\n fix_idx = np.nonzero(self.iou[true_idx, :] >= 1 - self.cutoff1)\n iou_modified[true_idx, fix_idx] = 1 - self.cutoff1 - 0.01\n\n return iou_modified\n\n def _get_cost_matrix(self):\n \"\"\"Assembles cost matrix using the iou matrix and cutoff1\n\n The previously calculated iou matrix is cast into the top left and\n transposed for the bottom right corner. The diagonals of the two\n remaining corners are populated according to cutoff1. The lower the\n value of cutoff1 the more likely it is for the linear sum assignment\n to pick unmatched assignments for objects.\n \"\"\"\n n_obj = self.n_true + self.n_pred\n matrix = np.ones((n_obj, n_obj))\n\n # Assign 1 - iou to top left and bottom right\n cost = 1 - self.iou_modified\n matrix[:self.n_true, :self.n_pred] = cost\n matrix[n_obj - self.n_pred:, n_obj - self.n_true:] = cost.T\n\n # Calculate diagonal corners\n bl = (self.cutoff1 * np.eye(self.n_pred)\n + np.ones((self.n_pred, self.n_pred))\n - np.eye(self.n_pred))\n tr = (self.cutoff1 * np.eye(self.n_true)\n + np.ones((self.n_true, self.n_true))\n - np.eye(self.n_true))\n\n # Assign diagonals to cm\n matrix[n_obj - self.n_pred:, :self.n_pred] = bl\n matrix[:self.n_true, n_obj - self.n_true:] = tr\n return matrix\n\n def _linear_assignment(self):\n \"\"\"Runs linear sun assignment on cost matrix, identifies true\n positives and unassigned true and predicted cells.\n\n True positives correspond to assignments in the top left or bottom\n right corner. There are two possible unassigned positions: true cell\n unassigned in bottom left or predicted cell unassigned in top right.\n \"\"\"\n cost_matrix = self._get_cost_matrix()\n\n results = linear_sum_assignment(cost_matrix)\n\n # Map results onto cost matrix\n assignment_matrix = np.zeros_like(cost_matrix)\n assignment_matrix[results] = 1\n return assignment_matrix\n\n def _array_to_graph(self, matrix):\n \"\"\"Transform matrix for unassigned cells into a graph object\n\n In order to cast the iou matrix into a graph form, we treat each\n unassigned cell as a node. The iou values for each pair of cells is\n treated as an edge between nodes/cells. Any iou values equal to 0 are\n dropped because they indicate no overlap between cells.\n\n Args:\n matrix (np.array): Assignment matrix.\n \"\"\"\n # Collect unassigned objects\n x, y = matrix.shape\n gained, _ = np.nonzero(matrix[x - self.n_pred:, :self.n_pred])\n missed, _ = np.nonzero(matrix[:self.n_true, y - self.n_true:])\n\n # Use meshgrid to get true and predicted object index for each val\n tt, pp = np.meshgrid(missed, gained, indexing='ij')\n\n true_nodes = tt.flatten()\n pred_nodes = pp.flatten()\n\n # construct list of edges for networkx\n G = nx.Graph()\n\n for t, p in zip(true_nodes, pred_nodes):\n # edges between overlapping objects only\n if self.iou_modified[t, p] >= self.cutoff2:\n G.add_edge('true_{}'.format(t), 'pred_{}'.format(p))\n\n # Add nodes to ensure all cells are included\n G.add_nodes_from(('true_{}'.format(n) for n in missed))\n G.add_nodes_from(('pred_{}'.format(n) for n in gained))\n\n return G\n\n def _classify_graph(self, G):\n \"\"\"Assign each node in graph to an error type\n\n Nodes with a degree (connectivity) of 0 correspond to either false\n positives or false negatives depending on the origin of the node from\n either the predicted objects (false positive) or true objects\n (false negative). Any nodes with a connectivity of 1 are considered to\n be true positives that were missed during linear assignment.\n Finally any nodes with degree >= 2 are indicative of a merge or split\n error. If the top level node is a predicted cell, this indicates a merge\n event. If the top level node is a true cell, this indicates a split event.\n \"\"\"\n # Find subgraphs, e.g. merge/split\n for g in (G.subgraph(c) for c in nx.connected_components(G)):\n # Get the highest degree node\n _, max_d = max(dict(g.degree).items(), key=operator.itemgetter(1))\n\n true_indices, pred_indices = [], []\n\n for node in g.nodes:\n node_type, index = node.split('_')\n index = int(index) + 1\n\n if node_type == 'true':\n if max_d > 1:\n true_indices.append(index)\n else:\n self._add_detection(true_index=index)\n\n if node_type == 'pred':\n if max_d > 1:\n pred_indices.append(index)\n else:\n self._add_detection(pred_index=index)\n\n self._add_detection(\n true_index=tuple(true_indices) if true_indices else None,\n pred_index=tuple(pred_indices) if pred_indices else None,\n )\n\n def _get_props(self, detection_type):\n prediction_types = {\n 'gained',\n }\n is_pred_type = detection_type in prediction_types\n arr = self.y_pred if is_pred_type else self.y_true\n label_image = np.zeros_like(arr)\n attrname = '_{}'.format(detection_type)\n\n try:\n detections = getattr(self, attrname)\n except AttributeError:\n raise ValueError('Invalid detection_type: {}'.format(\n detection_type))\n\n for det in detections:\n idx = det.pred_index if is_pred_type else det.true_index\n idx = idx if isinstance(idx, tuple) else (idx,)\n for i in idx:\n label_image[arr == i] = i\n\n return regionprops(label_image)\n\n def __repr__(self):\n \"\"\"Format the calculated statistics as a ``pd.DataFrame``.\"\"\"\n return json.dumps(self.to_dict())\n\n def to_dict(self):\n \"\"\"Return a dictionary representation of the calclulated metrics.\"\"\"\n return {\n 'n_pred': self.n_pred,\n 'n_true': self.n_true,\n 'correct_detections': self.correct_detections,\n 'missed_detections': self.missed_detections,\n 'gained_detections': self.gained_detections,\n 'missed_det_from_merge': self.missed_det_from_merge,\n 'gained_det_from_split': self.gained_det_from_split,\n 'true_det_in_catastrophe': self.true_det_in_catastrophe,\n 'pred_det_in_catastrophe': self.pred_det_in_catastrophe,\n 'merge': self.merges,\n 'split': self.splits,\n 'catastrophe': self.catastrophes,\n 'precision': self.precision,\n 'recall': self.recall,\n 'f1': self.f1,\n 'seg': self.seg_score,\n 'jaccard': self.jaccard,\n 'dice': self.dice,\n }\n\n @property\n def correct_detections(self):\n return len(self._correct)\n\n @property\n def missed_detections(self):\n return len(self._missed)\n\n @property\n def gained_detections(self):\n return len(self._gained)\n\n @property\n def splits(self):\n return len(self._splits)\n\n @property\n def merges(self):\n return len(self._merges)\n\n @property\n def catastrophes(self):\n return len(self._catastrophes)\n\n @property\n def gained_det_from_split(self):\n gained_dets = 0\n for det in self._splits:\n true_idx = _cast_to_tuple(det.true_index)\n pred_idx = _cast_to_tuple(det.pred_index)\n gained_dets += len(true_idx) + len(pred_idx) - 2\n return gained_dets\n\n @property\n def missed_det_from_merge(self):\n missed_dets = 0\n for det in self._merges:\n true_idx = _cast_to_tuple(det.true_index)\n pred_idx = _cast_to_tuple(det.pred_index)\n missed_dets += len(true_idx) + len(pred_idx) - 2\n return missed_dets\n\n @property\n def true_det_in_catastrophe(self):\n return sum([len(d.true_index) for d in self._catastrophes])\n\n @property\n def pred_det_in_catastrophe(self):\n return sum([len(d.pred_index) for d in self._catastrophes])\n\n @property\n def split_props(self):\n return self._get_props('splits')\n\n @property\n def merge_props(self):\n return self._get_props('merges')\n\n @property\n def missed_props(self):\n return self._get_props('missed')\n\n @property\n def gained_props(self):\n return self._get_props('gained')\n\n @property\n def recall(self):\n try:\n recall = self.correct_detections / self.n_true\n except ZeroDivisionError:\n recall = 0\n return recall\n\n @property\n def precision(self):\n try:\n precision = self.correct_detections / self.n_pred\n except ZeroDivisionError:\n precision = 0\n return precision\n\n @property\n def f1(self):\n return hmean([self.recall, self.precision])\n\n @property\n def jaccard(self):\n return self.pixel_stats.jaccard\n\n @property\n def dice(self):\n return self.pixel_stats.jaccard\n\n def plot_errors(self):\n \"\"\"Plots the errors identified from linear assignment code.\n\n This must be run with sequentially relabeled data.\n\n TODO: this is not working!\n \"\"\"\n\n import matplotlib as mpl\n import matplotlib.pyplot as plt\n\n # erode edges for easier visualization of adjacent cells\n y_true = erode_edges(self.y_true.copy(), 1)\n y_pred = erode_edges(self.y_pred.copy(), 1)\n\n # semantic labels for each error\n categories = ['Background', 'missed', 'splits', 'merges',\n 'gained', 'catastrophes', 'correct']\n\n # Background is set to zero\n plotting_tif = np.zeros_like(y_true)\n\n # missed detections are tracked with true labels\n misses = [d.true_index for d in self._missed]\n plotting_tif[np.isin(y_true, misses)] = 1\n\n # skip background and misses, already done\n for i, category in enumerate(categories[2:]):\n # the rest are all on y_pred\n labels = list(getattr(self, '_{}'.format(category)))\n plotting_tif[np.isin(y_pred, labels)] = i + 2\n\n plotting_colors = ['Black', 'Pink', 'Blue', 'Green',\n 'tan', 'Red', 'Grey']\n\n cmap = mpl.colors.ListedColormap(plotting_colors)\n\n fig, ax = plt.subplots(nrows=1, ncols=1)\n mat = ax.imshow(plotting_tif, cmap=cmap,\n vmin=np.min(plotting_tif) - .5,\n vmax=np.max(plotting_tif) + .5)\n\n # tell the colorbar to tick at integers\n ticks = np.arange(len(categories))\n cbar = fig.colorbar(mat, ticks=ticks)\n cbar.ax.set_yticklabels(categories)\n fig.tight_layout()\n\n\nclass Metrics(object):\n \"\"\"Class to calculate and save various segmentation metrics.\n\n Args:\n model_name (str): Name of the model which determines output file names\n outdir (:obj:`str`, optional): Directory to save json file, default ''\n cutoff1 (:obj:`float`, optional): Threshold for overlap in cost matrix,\n smaller values are more conservative, default 0.4\n cutoff2 (:obj:`float`, optional): Threshold for overlap in unassigned\n cells, smaller values are better, default 0.1\n pixel_threshold (:obj:`float`, optional): Threshold for converting\n predictions to binary\n ndigits (:obj:`int`, optional): Sets number of digits for rounding,\n default 4\n feature_key (:obj:`list`, optional): List of strings, feature names\n json_notes (:obj:`str`, optional): Str providing any additional\n information about the model\n force_event_links(:obj:`bool`, optional): Flag that determines whether to modify IOU\n calculation so that merge or split events with cells of very different sizes are\n never misclassified as misses/gains.\n is_3d(:obj:`bool`, optional): Flag that determines whether or not the input data\n should be treated as 3-dimensional.\n\n Examples:\n >>> from deepcell import metrics\n >>> m = metrics.Metrics('model_name')\n >>> all_metrics = m.run_all(y_true, y_pred)\n >>> m.save_to_json(all_metrics)\n \"\"\"\n def __init__(self, model_name,\n outdir='',\n cutoff1=0.4,\n cutoff2=0.1,\n pixel_threshold=0.5,\n ndigits=4,\n crop_size=None,\n feature_key=[],\n json_notes='',\n force_event_links=False,\n is_3d=False,\n **kwargs):\n self.model_name = model_name\n self.outdir = outdir\n self.cutoff1 = cutoff1\n self.cutoff2 = cutoff2\n self.pixel_threshold = pixel_threshold\n self.ndigits = ndigits\n self.crop_size = crop_size\n self.feature_key = feature_key\n self.json_notes = json_notes\n self.force_event_links = force_event_links\n self.is_3d = is_3d\n\n if 'seg' in kwargs:\n warnings.warn('seg is deprecated and will be removed '\n 'in a future release', DeprecationWarning)\n\n # Initialize output list to collect stats\n self.object_metrics = []\n self.pixel_metrics = []\n\n def df_to_dict(self, df, stat_type='pixel'):\n \"\"\"Output pandas df as a list of dictionary objects\n\n Args:\n df (pandas.DataFrame): Dataframe of statistics for each channel\n stat_type (str): Category of statistic.\n\n Returns:\n list: List of dictionaries\n \"\"\"\n\n # Initialize output dictionary\n L = []\n\n # Write out average statistics\n for k, v in df.mean().iteritems():\n L.append(dict(\n name=k,\n value=v,\n feature='average',\n stat_type=stat_type,\n ))\n\n # Save individual stats to list\n for i, row in df.iterrows():\n for k, v in row.iteritems():\n L.append(dict(\n name=k,\n value=v,\n feature=i,\n stat_type=stat_type,\n ))\n\n return L\n\n def calc_pixel_stats(self, y_true, y_pred, axis=-1):\n \"\"\"Calculate pixel statistics for each feature.\n\n ``y_true`` should have the appropriate transform applied to match\n ``y_pred``. Each channel is converted to binary using the threshold\n ``pixel_threshold`` prior to calculation of accuracy metrics.\n\n Args:\n y_true (numpy.array): Ground truth annotations after transform\n y_pred (numpy.array): Model predictions without labeling\n\n Returns:\n list: list of dictionaries with each stat being a key.\n\n Raises:\n ValueError: If y_true and y_pred are not the same shape\n \"\"\"\n n_features = y_pred.shape[axis]\n\n pixel_metrics = []\n\n slc = [slice(None)] * y_pred.ndim\n for i in range(n_features):\n slc[axis] = slice(i, i + 1)\n yt = y_true[slc] > self.pixel_threshold\n yp = y_pred[slc] > self.pixel_threshold\n pm = PixelMetrics(yt, yp)\n pixel_metrics.append(pm.to_dict())\n\n pixel_df = pd.DataFrame.from_records(pixel_metrics)\n\n # Calculate confusion matrix\n cm = PixelMetrics.get_confusion_matrix(y_true, y_pred, axis=axis)\n\n print('\\n____________Pixel-based statistics____________\\n')\n print(pixel_df)\n print('\\nConfusion Matrix')\n print(cm)\n\n output = self.df_to_dict(pixel_df)\n\n output.append(dict(\n name='confusion_matrix',\n value=cm.tolist(),\n feature='all',\n stat_type='pixel'\n ))\n return output\n\n def calc_pixel_confusion_matrix(self, y_true, y_pred, axis=-1):\n \"\"\"DEPRECATED: Use ``PixelMetrics.get_confusion_matrix``.\n\n Calculate confusion matrix for pixel classification data.\n\n Args:\n y_true (numpy.array): Ground truth annotations after any\n necessary transformations\n y_pred (numpy.array): Prediction array\n axis (int): The channel axis of the input arrays.\n\n Returns:\n numpy.array: nxn confusion matrix determined by number of features.\n \"\"\"\n return PixelMetrics.get_confusion_matrix(y_true, y_pred, axis=axis)\n\n def calc_object_stats(self, y_true, y_pred, progbar=True):\n \"\"\"Calculate object statistics and save to output\n\n Loops over each frame in the zeroth dimension, which should pass in\n a series of 2D arrays for analysis. 'metrics.split_stack' can be\n used to appropriately reshape the input array if necessary\n\n Args:\n y_true (numpy.array): Labeled ground truth annotations\n y_pred (numpy.array): Labeled prediction mask\n progbar (bool): Whether to show the progress tqdm progress bar\n\n Returns:\n list: list of dictionaries with each stat being a key.\n\n Raises:\n ValueError: If y_true and y_pred are not the same shape\n ValueError: If data_type is 2D, if input shape does not have ndim 3 or 4\n ValueError: If data_type is 3D, if input shape does not have ndim 4\n \"\"\"\n if y_pred.shape != y_true.shape:\n raise ValueError('Input shapes need to match. Shape of prediction '\n 'is: {}. Shape of y_true is: {}'.format(\n y_pred.shape, y_true.shape))\n\n # If 2D, dimensions can be 3 or 4 (with or without channel dimension)\n if not self.is_3d:\n if y_true.ndim not in {3, 4}:\n raise ValueError('Expected dimensions for y_true (2D data) are 3 or 4.'\n 'Accepts: (batch, x, y), or (batch, x, y, chan)'\n 'Got ndim: {}'.format(y_true.ndim))\n\n # If 3D, inputs must have 4 dimensions (batch, z, x, y) - cannot have channel dimension or\n # _classify_graph breaks, as it expects input to be 2D or 3D\n # TODO - add compatibility for multi-channel 3D-data\n else:\n if y_true.ndim != 4:\n raise ValueError('Expected dimensions for y_true (3D data) is 4. '\n 'Required format is: (batch, z, x, y) '\n 'Got ndim: {}'.format(y_true.ndim))\n\n all_object_metrics = [] # store all calculated metrics\n is_batch_relabeled = False # used to warn if batches were relabeled\n\n for i in tqdm(range(y_true.shape[0]), disable=not progbar):\n # check if labels aren't sequential, raise warning on first occurence if so\n true_batch, pred_batch = y_true[i], y_pred[i]\n true_batch_relabel, _, _ = relabel_sequential(true_batch)\n pred_batch_relabel, _, _ = relabel_sequential(pred_batch)\n\n # check if segmentations were relabeled\n if not is_batch_relabeled: # only one True is required\n is_batch_relabeled = not (\n np.array_equal(true_batch, true_batch_relabel)\n and np.array_equal(pred_batch, pred_batch_relabel)\n )\n\n o = ObjectMetrics(\n true_batch_relabel,\n pred_batch_relabel,\n cutoff1=self.cutoff1,\n cutoff2=self.cutoff2,\n force_event_links=self.force_event_links,\n is_3d=self.is_3d)\n\n all_object_metrics.append(o)\n\n if is_batch_relabeled:\n warnings.warn(\n 'Provided data is being relabeled. Cell ids from metrics will not match '\n 'cell ids in original data. Relabel your data prior to running the '\n 'metrics package if you wish to maintain cell ids. ')\n\n # print the object report\n object_metrics = pd.DataFrame.from_records([\n o.to_dict() for o in all_object_metrics\n ])\n self.print_object_report(object_metrics)\n return object_metrics\n\n def summarize_object_metrics_df(self, df):\n correct_detections = int(df['correct_detections'].sum())\n n_true = int(df['n_true'].sum())\n n_pred = int(df['n_pred'].sum())\n\n _round = lambda x: round(x, self.ndigits)\n\n seg = df['seg'].mean()\n jaccard = df['jaccard'].mean()\n\n try:\n recall = correct_detections / n_true\n except ZeroDivisionError:\n recall = np.nan\n try:\n precision = correct_detections / n_pred\n except ZeroDivisionError:\n precision = 0\n\n errors = [\n 'gained_detections',\n 'missed_detections',\n 'split',\n 'merge',\n 'catastrophe',\n ]\n\n bad_detections = [\n 'gained_det_from_split',\n 'missed_det_from_merge',\n 'true_det_in_catastrophe',\n 'pred_det_in_catastrophe',\n ]\n\n summary = {\n 'correct_detections': correct_detections,\n 'n_true': n_true,\n 'n_pred': n_pred,\n 'recall': _round(recall),\n 'precision': _round(precision * 100),\n 'seg': _round(seg * 100),\n 'jaccard': _round(jaccard),\n 'total_errors': 0,\n }\n # update bad detections\n for k in bad_detections:\n summary[k] = int(df[k].sum())\n # update error counts\n for k in errors:\n count = int(df[k].sum())\n summary[k] = count\n summary['total_errors'] += count\n return summary\n\n def print_object_report(self, object_metrics):\n \"\"\"Print neat report of object based statistics\n\n Args:\n object_metrics (pd.DataFrame): DataFrame of all calculated metrics\n \"\"\"\n summary = self.summarize_object_metrics_df(object_metrics)\n errors = [\n 'gained_detections',\n 'missed_detections',\n 'split',\n 'merge',\n 'catastrophe'\n ]\n\n bad_detections = [\n 'gained_det_from_split',\n 'missed_det_from_merge',\n 'true_det_in_catastrophe',\n 'pred_det_in_catastrophe',\n ]\n\n print('\\n____________Object-based statistics____________\\n')\n print('Number of true cells:\\t\\t', summary['n_true'])\n print('Number of predicted cells:\\t', summary['n_pred'])\n\n print('\\nCorrect detections: {}\\tRecall: {}%'.format(\n summary['correct_detections'], summary['recall']))\n\n print('Incorrect detections: {}\\tPrecision: {}%'.format(\n summary['n_pred'] - summary['correct_detections'],\n summary['precision']))\n\n print('\\n')\n for k in errors:\n v = summary[k]\n name = k.replace('_', ' ').capitalize()\n if not name.endswith('s'):\n name += 's'\n\n try:\n err_fraction = v / summary['total_errors']\n except ZeroDivisionError:\n err_fraction = 0\n\n print('{name}: {val}{tab}Perc Error {percent}%'.format(\n name=name, val=v,\n percent=round(100 * err_fraction, self.ndigits),\n tab='\\t' * (1 if ' ' in name else 2)))\n\n for k in bad_detections:\n name = k.replace('_', ' ').capitalize().replace(' det ', ' detections')\n print('{name}: {val}'.format(name=name, val=summary[k]))\n\n print('SEG:', round(summary['seg'], self.ndigits), '\\n')\n\n print('Average Pixel IOU (Jaccard Index):',\n round(summary['jaccard'], self.ndigits), '\\n')\n\n def run_all(self, y_true, y_pred, axis=-1):\n object_metrics = self.calc_object_stats(y_true, y_pred)\n pixel_metrics = self.calc_pixel_stats(y_true, y_pred, axis=axis)\n\n object_list = self.df_to_dict(object_metrics, stat_type='object')\n all_output = object_list + pixel_metrics\n self.save_to_json(all_output)\n\n def save_to_json(self, L):\n \"\"\"Save list of dictionaries to json file with file metadata\n\n Args:\n L (list): List of metric dictionaries\n \"\"\"\n todays_date = datetime.datetime.now().strftime('%Y-%m-%d')\n outname = os.path.join(\n self.outdir, '{}_{}.json'.format(self.model_name, todays_date))\n\n # Configure final output\n D = {}\n\n # Record metadata\n D['metadata'] = dict(\n model_name=self.model_name,\n date=todays_date,\n notes=self.json_notes\n )\n\n # Record metrics\n D['metrics'] = L\n\n with open(outname, 'w') as outfile:\n json.dump(D, outfile)\n\n logging.info('Saved to {}'.format(outname))\n\n\ndef split_stack(arr, batch, n_split1, axis1, n_split2, axis2):\n \"\"\"Crops an array in the width and height dimensions to produce\n a stack of smaller arrays\n\n Args:\n arr (numpy.array): Array to be split with at least 2 dimensions\n batch (bool): True if the zeroth dimension of arr is a batch or\n frame dimension\n n_split1 (int): Number of sections to produce from the first split axis\n Must be able to divide arr.shape[axis1] evenly by n_split1\n axis1 (int): Axis on which to perform first split\n n_split2 (int): Number of sections to produce from the second split axis\n Must be able to divide arr.shape[axis2] evenly by n_split2\n axis2 (int): Axis on which to perform first split\n\n Returns:\n numpy.array: Array after dual splitting with frames in the zeroth dimension\n\n Raises:\n ValueError: arr.shape[axis] must be evenly divisible by n_split\n for both the first and second split\n\n Examples:\n >>> from deepcell import metrics\n >>> from numpy import np\n >>> arr = np.ones((10, 100, 100, 1))\n >>> out = metrics.split_stack(arr, True, 10, 1, 10, 2)\n >>> out.shape\n (1000, 10, 10, 1)\n >>> arr = np.ones((100, 100, 1))\n >>> out = metrics.split_stack(arr, False, 10, 1, 10, 2)\n >>> out.shape\n (100, 10, 10, 1)\n \"\"\"\n # Check that n_split will divide equally\n if ((arr.shape[axis1] % n_split1) != 0) | ((arr.shape[axis2] % n_split2) != 0):\n raise ValueError(\n 'arr.shape[axis] must be evenly divisible by n_split'\n 'for both the first and second split')\n\n split1 = np.split(arr, n_split1, axis=axis1)\n\n # If batch dimension doesn't exist, create and adjust axis2\n if batch is False:\n split1con = np.stack(split1)\n axis2 += 1\n else:\n split1con = np.concatenate(split1, axis=0)\n\n split2 = np.split(split1con, n_split2, axis=axis2)\n split2con = np.concatenate(split2, axis=0)\n\n return split2con\n\n\ndef match_nodes(y_true, y_pred):\n \"\"\"Loads all data that matches each pattern and compares the graphs.\n\n Args:\n y_true (numpy.array): ground truth array with all cells labeled uniquely.\n y_pred (numpy.array): data array to match to unique.\n\n Returns:\n numpy.array: IoU of ground truth cells and predicted cells.\n \"\"\"\n num_frames = y_true.shape[0]\n # TODO: does max make the shape bigger than necessary?\n iou = np.zeros((num_frames, np.max(y_true) + 1, np.max(y_pred) + 1))\n\n # Compute IOUs only when neccesary\n # If bboxs for true and pred do not overlap with each other, the assignment\n # is immediate. Otherwise use pixelwise IOU to determine which cell is which\n\n # Regionprops expects one frame at a time\n for frame in range(num_frames):\n gt_frame = y_true[frame]\n res_frame = y_pred[frame]\n\n gt_props = regionprops(np.squeeze(gt_frame.astype('int')))\n gt_boxes = [np.array(gt_prop.bbox) for gt_prop in gt_props]\n gt_boxes = np.array(gt_boxes).astype('double')\n gt_box_labels = [int(gt_prop.label) for gt_prop in gt_props]\n\n res_props = regionprops(np.squeeze(res_frame.astype('int')))\n res_boxes = [np.array(res_prop.bbox) for res_prop in res_props]\n res_boxes = np.array(res_boxes).astype('double')\n res_box_labels = [int(res_prop.label) for res_prop in res_props]\n\n # has the form [gt_bbox, res_bbox]\n overlaps = compute_overlap(gt_boxes, res_boxes)\n\n # Find the bboxes that have overlap at all\n # (ind_ corresponds to box number - starting at 0)\n ind_gt, ind_res = np.nonzero(overlaps)\n\n # frame_ious = np.zeros(overlaps.shape)\n for index in range(ind_gt.shape[0]):\n iou_gt_idx = gt_box_labels[ind_gt[index]]\n iou_res_idx = res_box_labels[ind_res[index]]\n intersection = np.logical_and(\n gt_frame == iou_gt_idx, res_frame == iou_res_idx)\n union = np.logical_or(\n gt_frame == iou_gt_idx, res_frame == iou_res_idx)\n iou[frame, iou_gt_idx, iou_res_idx] = intersection.sum() / union.sum()\n\n return iou\n", "meta": {"hexsha": "a60b458e928a8bf6c5e7bd68d17c573d4dd1cd1a", "size": 49805, "ext": "py", "lang": "Python", "max_stars_repo_path": "deepcell_toolbox/metrics.py", "max_stars_repo_name": "vanvalenlab/deepcell-toolbox", "max_stars_repo_head_hexsha": "7df2e11284147e2afa976584074e02488c26e834", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2019-10-16T21:15:08.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T05:19:50.000Z", "max_issues_repo_path": "deepcell_toolbox/metrics.py", "max_issues_repo_name": "vanvalenlab/deepcell-toolbox", "max_issues_repo_head_hexsha": "7df2e11284147e2afa976584074e02488c26e834", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 81, "max_issues_repo_issues_event_min_datetime": "2019-03-26T18:27:10.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-10T21:41:18.000Z", "max_forks_repo_path": "deepcell_toolbox/metrics.py", "max_forks_repo_name": "vanvalenlab/deepcell-toolbox", "max_forks_repo_head_hexsha": "7df2e11284147e2afa976584074e02488c26e834", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-01-30T12:54:32.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-15T04:05:45.000Z", "avg_line_length": 36.4604685212, "max_line_length": 98, "alphanum_fraction": 0.6126493324, "include": true, "reason": "import numpy,from numpy,from scipy,import networkx", "num_tokens": 11323, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5350984286266116, "lm_q2_score": 0.3557748866829643, "lm_q1q2_score": 0.19037458280886502}} {"text": "# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport itertools\nimport numpy as np\nimport re\n\nfrom .linalg import dot, matmul, transpose\nfrom .manipulation import squeeze, unsqueeze, reshape\nfrom .math import multiply\nfrom .math import sum as paddle_sum\nfrom ..fluid.framework import _in_legacy_dygraph\nfrom paddle import _C_ops\nfrom ..fluid.data_feeder import check_variable_and_dtype, check_type, check_dtype\nfrom ..fluid.layer_helper import LayerHelper\nfrom ..fluid.framework import _non_static_mode, in_dygraph_mode, _in_legacy_dygraph\nimport collections\nimport string\nimport opt_einsum\n\nfrom paddle.common_ops_import import dygraph_only\n\n__all__ = []\n\n\ndef parse_op_labels(labelstr, operand):\n '''\n Parse labels for an input operand.\n\n Parameters\n ----------\n labelstr:\n the input label string\n operand:\n the input operand\n\n Returns\n -------\n the input operand's full label string in which all anonymous dimensions are \n labeled in dots. \n '''\n # Sanity checks\n for c in labelstr.replace('.', ''):\n assert c.isalpha(), (\n f\"Invalid equation: {c} is not a valid label, which should be letters.\"\n )\n\n assert labelstr.replace('...', '', 1).find('.') == -1, (\n f\"Invalid equation: `.` is found outside of an ellipsis.\")\n\n # Check shape. Note, in Paddle a tensor rank is always nonzero\n ndims = len(operand.shape)\n assert ndims > 0\n\n full_labelstr = labelstr.replace('...', '.' * (ndims - len(labelstr) + 3))\n\n assert len(full_labelstr) == ndims, (\n f\"Invalid equation: the label string '{labelstr}' misses dimensions.\")\n\n return full_labelstr\n\n\ndef parse_labels(labelstr, operands):\n '''\n Parse label strings for all input operands.\n \n Parameters\n ----------\n labelstr:\n The equation's label string\n operands:\n The input operands\n \n Returns\n -------\n list of full label strings for all input operands\n '''\n\n nop_labels = labelstr.split(',')\n assert len(nop_labels) == len(operands), (\n f\"Invalid equation: the number of operands is {len(operands)}, \"\n f\"but found {len(nop_labels)} segments in the label equation.\")\n\n return list(map(parse_op_labels, nop_labels, operands))\n\n\ndef validate_rhs(rhs, input_labels, n_bcast_dims):\n '''\n Check whether the equation's right hand side is valid \n '''\n # Sanity check.\n if n_bcast_dims > 0:\n assert '...' in rhs, (\n f\"Invalid equation: missing ellipsis in output labels.\")\n\n rhs = rhs.replace('...', '')\n rhs_set = set(rhs)\n\n # Hidden assumption: availble labels don't include '.'\n assert '.' not in input_labels\n\n # Verify that output labels all come from the set of input labels\n non_input_labels = rhs_set.difference(input_labels)\n assert not non_input_labels, (\n f\"Invalid equation: \"\n f\"output label {sorted(non_input_labels)} not used by any input.\")\n # Verify that output labels are not duplicate\n assert len(rhs) == len(rhs_set), (\n f\"Invalid equation: duplicate output labels are found.\")\n\n\ndef build_view(in_labels, out_labels):\n '''\n Build an inverse map of dimension indices. Three conditions must hold for \n the result to be meaningful. \n First, no duplicate letter labels in each label string.\n Second, the number of dots in dimout_labels >= that in in_labels.\n Third, dots are contiguous in each label string.\n\n Parameters\n ----------\n in_labels:\n The dimension labels to map to\n out_labels:\n The dimension labels to map from\n \n Returns\n -------\n The inverse map from out_labels to in_labels. The length of the inverse map equals that of\n out_labels. -1 is filled if there's no matching intput dimension for a specific label.\n\n Examples\n --------\n in_labels = 'ij..', out_labels = '..ji'\n inv_map = [2, 3, 1, 0]\n in_labels = 'ij..', out_labels = '..kji'\n inv_map = [2, 3, -1, 1, 0]\n '''\n\n inv_map = [-1] * len(out_labels)\n\n # First build the broadcast dimension mapping\n # Find the broadcast index range in out_labels\n r = re.search(r'\\.+', out_labels)\n if r:\n start, end = r.start(), r.end()\n s = re.search(r'\\.+', in_labels)\n # fill the broadcast dimension indices from right to left.\n if s:\n for ax, dim in zip(\n range(start, end)[::-1], range(s.start(), s.end())[::-1]):\n inv_map[ax] = dim\n\n # Now work on non-broadcast dimensions \n if r:\n it = itertools.chain(range(start), range(end, len(out_labels)))\n else:\n it = iter(range(len(out_labels)))\n\n for i in it:\n inv_map[i] = in_labels.find(out_labels[i])\n\n return inv_map\n\n\ndef build_global_view(nop_labels, rhs, n_bcast_dims):\n '''\n Build the global view, which is a layout of all dimension labels\n plus an index table that maps from the layout to the dimensions\n in each operand. In the global view, the dimensions are arranged\n such that output ones are put on the left and contraction ones\n are put on the right. \n\n Parameters\n ----------\n nop_labels:\n The input full label strings of all input operands\n rhs:\n The equation right hand side\n n_bcast_dims:\n The maxium number of broadcast dimensions\n \n Returns\n -------\n A tuple of g_labels, g_view, g_nout, g_count\n g_labels:\n the layout of all labels in a string\n g_view:\n the index table\n g_nout:\n the number of output dimensions\n g_count:\n the counter array for dimension contractions\n '''\n # Put all labels in alphabetical order\n concat = sorted(''.join(nop_labels).replace('.', ''))\n labels, count = [], []\n for a, b in zip(['.'] + concat, concat):\n if a != b:\n labels.append(b)\n count.append(1)\n else:\n count[-1] += 1\n\n if rhs != None:\n validate_rhs(rhs, labels, n_bcast_dims)\n g_labels_out = rhs.replace('...', '.' * n_bcast_dims)\n else:\n g_labels_out = '.' * n_bcast_dims + ''.join(\n l for l, c in zip(labels, count) if c == 1)\n\n for i in range(len(count))[::-1]:\n if labels[i] in g_labels_out:\n labels.pop(i)\n count.pop(i)\n\n g_labels_sum = ''.join(labels)\n g_labels = g_labels_out + g_labels_sum\n g_view = list(map(lambda i: build_view(i, g_labels), nop_labels))\n g_nout = len(g_labels_out)\n g_count = count\n\n return g_labels, g_view, g_nout, g_count\n\n\ndef build_global_shape(g_view, g_labels, op_shapes):\n '''\n The global shape is the shape of all dimensions rearranged and broadcasting \n to the global view. It's a reference data structure for einsum planning.\n\n Parameters\n ----------\n g_view:\n the global view\n op_shapes:\n the shapes of the all operands\n\n Returns\n -------\n g_shape:\n the global shape vector\n g_masks:\n list of shape masks for each operand. A dimension's shape mask is a boolean\n indicating whether its size > 1, in other words, it's not squeezable\n '''\n view_shapes = []\n g_masks = []\n\n for view, op_shape in zip(g_view, op_shapes):\n view_shapes.append([op_shape[dim] if dim > -1 else 1 for dim in view])\n\n g_shape = [set(sizes_per_ax) - {1} for sizes_per_ax in zip(*view_shapes)]\n\n non_bcastable = [ax for ax, sizes in enumerate(g_shape) if len(sizes) > 1]\n\n assert not non_bcastable, (\n f\"Invalid operands: label {g_labels[non_bcastable[0]]} \"\n f\"corresponds to non-broadcastable dimensions.\")\n\n g_shape = [sizes.pop() if len(sizes) > 0 else 1 for sizes in g_shape]\n\n g_masks = [[s > 1 or s == -1 for s in view_shape]\n for view_shape in view_shapes]\n\n return g_shape, g_masks\n\n\ndef has_duplicated_labels(labels):\n '''\n Returns True if there is any duplicate label.\n '''\n labels = labels.replace('.', '')\n return len(labels) > len(set(labels))\n\n\ndef diagonalize(labels, operand):\n '''\n Merges dimensions with duplicate labels. \n \n For those dimensions with duplicate labels, merge them into one dimension\n which represents the diagonal elements. This requires the dimensions with\n duplicate labels are equal sized.\n \n Examples\n -------- \n 'ijj...i' would be merged into 'ij...'\n '''\n assert not has_duplicated_labels(labels), (\n f'Duplicate labels are not supported.')\n\n return labels, operand\n\n\ndef plan_reduce(plan, op, reduce_dims, keepdim):\n '''\n Add reduce to the plan\n '''\n varname = f'op{op}'\n\n f = lambda var, dims: paddle_sum(var, dims, keepdim=keepdim)\n step = f, [varname], varname, reduce_dims\n plan.add_step(step)\n\n\ndef plan_scalar_prod(plan, op1, op2):\n varnames = [f'op{op1}', f'op{op2}']\n f = lambda var1, var2: paddle_sum(var1) * var2\n # f = lambda var1, var2: var1 * var2\n step = f, varnames, varnames[1]\n plan.add_step(step)\n\n\ndef plan_matmul(plan, g_view, op1, op2, g_supports, g_shape, I, J1, J2, K):\n '''\n plan matmul\n '''\n # Transpose and re-shape op1 and op2 in I, J1, K and I, J2, K\n # Then apply matmul(x, y, transpose_x=False, tranpose_y=True)\n var1, var2 = f'op{op1}', f'op{op2}'\n\n op1_view, op2_view = [g_view[op] for op in (op1, op2)]\n\n I1 = [idx for idx in I if op1_view[idx] >= 0]\n I2 = [idx for idx in I if op2_view[idx] >= 0]\n op1_view = np.array(op1_view)\n op1_dims = op1_view[I1 + J1 + K]\n\n op2_view = np.array(op2_view)\n op2_dims = op2_view[I2 + J2 + K]\n\n op1_mask, op2_mask = [g_supports[op] for op in (op1, op2)]\n op1_vshape = np.array([s if m else 1 for s, m in zip(g_shape, op1_mask)])\n op2_vshape = np.array([s if m else 1 for s, m in zip(g_shape, op2_mask)])\n vshape = np.maximum(op1_vshape, op2_vshape)\n\n i1, i2, j1, j2, k = map(len, (I1, I2, J1, J2, K))\n\n if any(op1_dims != np.arange(len(op1_dims))):\n # print(f'perm1: {perm1}')\n step = transpose, [var1], var1, list(op1_dims)\n plan.add_step(step)\n\n if any(op2_dims != np.arange(len(op2_dims))):\n # print(f'perm2: {perm2}')\n step = transpose, [var2], var2, list(op2_dims)\n plan.add_step(step)\n\n # Check if conditions hold for turnning the operation into a matmul\n if j1 + j2 > 0 and k > 0 and -1 not in np.concatenate(\n (op1_vshape, op2_vshape)):\n op1_shape = list(op1_vshape[I]) + [np.prod(op1_vshape[J1])\n ] + [np.prod(op1_vshape[K])]\n op2_shape = list(op2_vshape[I]) + [np.prod(op2_vshape[J2])\n ] + [np.prod(op2_vshape[K])]\n\n # Merge J dims and K dims by reshaping\n step = reshape, [var1], var1, op1_shape\n plan.add_step(step)\n step = reshape, [var2], var2, op2_shape\n plan.add_step(step)\n\n # Matmul\n step = matmul, [var1, var2], var2, False, True\n plan.add_step(step)\n\n # Reshape back\n shape = list(vshape[I + J1 + J2])\n step = reshape, [var2], var2, shape\n plan.add_step(step)\n\n elif j1 == j2 == k == 1:\n # Can still do matmul even unknown shapes are present\n step = matmul, [var1, var2], var2, False, True\n plan.add_step(step)\n\n # In the rest cases we opt for ops other than matmul \n else:\n # unsqueeze operands include J1...J2... dimensions\n if j2:\n fill = list(range(i1 + j1, i1 + j1 + j2))\n step = unsqueeze, [var1], var1, fill\n plan.add_step(step)\n if j1:\n fill = list(range(i2, i2 + j1))\n step = unsqueeze, [var2], var2, fill\n plan.add_step(step)\n # In case of no dimensions to contract, do an elementwise multiply\n if k == 0:\n # make broadcast\n step = multiply, [var1, var2], var2\n plan.add_step(step)\n # Contract and no join, turn into a dot\n elif j1 + j2 == 0 and k == 1:\n step = unsqueeze, [var1], var1, [-2]\n plan.add_step(step)\n step = unsqueeze, [var2], var2, [-1]\n plan.add_step(step)\n step = matmul, [var1, var2], var2\n plan.add_step(step)\n step = squeeze, [var2], var2, [-1, -2]\n plan.add_step(step)\n elif j1 + j2 == 0 and not-1 in np.concatenate(\n (op1_vshape[K], op2_vshape[K])):\n assert all(op1_vshape[K] == op2_vshape[K])\n step = reshape, [var1], var1, list(op1_vshape[\n I]) + [1] + [np.prod(op1_vshape[K])]\n plan.add_step(step)\n step = reshape, [var2], var2, list(op2_vshape[\n I]) + [1] + [np.prod(op2_vshape[K])]\n plan.add_step(step)\n step = matmul, [var1, var2], var2, False, True\n plan.add_step(step)\n step = squeeze, [var2], var2, [-1, -2]\n plan.add_step(step)\n else:\n step = multiply, [var1, var2], var2\n plan.add_step(step)\n reduce_dims = list(range(-k, 0))\n plan_reduce(plan, op2, reduce_dims, keepdim=False)\n\n # Wrap up, updating auxiliary data\n # Updating g_mask for I and J axes\n for ax in I + J1 + J2:\n op2_mask[ax] = vshape[ax] > 1 or vshape[ax] == -1\n\n for ax in K:\n op2_mask[ax] = False\n\n for ax in range(len(op2_view)):\n op2_view[ax] = -1\n dim = 0\n for ax in I + J1 + J2:\n op2_view[ax], dim = dim, dim + 1\n\n g_view[op2] = list(op2_view)\n\n\ndef plan_summation(plan, g_view, op1, op2, g_supports, g_shape, g_count,\n n_bcast):\n '''\n Plan various kinds of summation\n '''\n op1_view, op2_view = g_view[op1], g_view[op2]\n op1_mask, op2_mask = g_supports[op1], g_supports[op2]\n\n ndim = len(op1_view)\n nout = ndim - len(g_count)\n\n count = [0] * nout + g_count\n\n I, K, J1, J2 = list(range(n_bcast)), [], [], []\n\n for ax, dim1, dim2 in zip(\n range(n_bcast, ndim), op1_view[n_bcast:], op2_view[n_bcast:]):\n\n if (dim1 != -1) != (dim2 != -1):\n if dim1 != -1:\n J1.append(ax)\n else:\n J2.append(ax)\n elif dim1 != -1:\n fold = int(op1_mask[ax]) + int(op2_mask[ax])\n if ax >= nout and fold == count[ax]:\n # Ready to fold the dimensions\n K.append(ax)\n count[ax] -= fold\n else:\n I.append(ax)\n count[ax] -= max(fold - 1, 0)\n\n # Update g_count\n g_count[:] = count[nout:]\n\n # Now it's OK to merge the K dims as the same shape holds\n # print(f'I: {I} J1: {J1} J2: {J2} K: {K}')\n plan_matmul(plan, g_view, op1, op2, g_supports, g_shape, I, J1, J2, K)\n\n\ndef rearrange(axes):\n perm, fill = [], []\n for ax, dim in enumerate(axes):\n if dim < 0:\n fill.append(ax)\n else:\n perm.append(dim)\n # Trivial permutation returns []\n if all(i == dim for i, dim in enumerate(perm)):\n perm = []\n\n return perm, fill\n\n\ndef plan_broadcast(plan, operands, nop_axes):\n '''\n Plan broadcast across\n '''\n nop = len(operands)\n varnames = [f'op{i}' for i in range(nop)]\n\n for i, op_axes in zip(range(nop), nop_axes):\n # Re-arrange the dimesions according to the global layout\n perm, fill = rearrange(op_axes)\n var = varnames[i]\n if perm:\n step = transpose, [var], var, perm\n plan.add_step(step)\n if fill:\n step = unsqueeze, [var], var, fill\n plan.add_step(step)\n\n def f(*args):\n expr = ' * '.join(varnames)\n return eval(expr, dict(zip(varnames, args)))\n\n step = f, varnames, None\n plan.add_step(step)\n\n\nclass Plan:\n def __init__(self):\n self.env = {}\n self.steps = []\n\n def add_step(self, step):\n self.steps.append(step)\n\n def get_var(self, varname):\n return self.env[varname] if varname in self.env else None\n\n def set_var(self, varname, var):\n self.env[varname] = var\n\n def show(self):\n res = None\n for f, in_varnames, out_varname, *args in self.steps:\n print(repr((out_varname, f, *in_varnames, *args)))\n return res\n\n def execute(self):\n res = None\n for f, in_varnames, out_varname, *args in self.steps:\n res = f(*map(self.get_var, in_varnames), *args)\n if out_varname:\n self.set_var(out_varname, res)\n return res\n\n\ndef plan_einsum(operands, g_view, g_shape, g_supports, g_count, n_bcast):\n '''\n Plans the actual execution steps.\n Results\n -------\n the execution plan\n '''\n nop = len(operands)\n ndim = len(g_view[0])\n nout = ndim - len(g_count)\n\n # Initialize a plan with an environment\n plan = Plan()\n op_names = [f'op{i}' for i in range(nop)]\n list(map(plan.set_var, op_names, operands))\n\n # In case no dimensions to combine, do broadcast straight across\n if not g_count:\n plan_broadcast(plan, operands, g_view)\n return plan\n\n # Down count degenerate contraction dimensions.\n for view, support in zip(g_view, g_supports):\n # To collect the down count number, we use a type casting trick\n down_count = [\n int((d + 1) and (not s))\n for d, s in zip(view[nout:], support[nout:])\n ]\n for i, count in enumerate(down_count):\n g_count[i] -= count\n\n # Reduce any dimension for which g_support is set and g_count == 1\n for i, view, mask in zip(range(nop), g_view, g_supports):\n to_reduce = []\n for dim, masked, count in zip(view[nout:], mask[nout:], g_count):\n to_reduce.append(dim if (masked and count == 1) else -1)\n\n reduce_dims = list(filter(lambda x: x > -1, to_reduce))\n if reduce_dims:\n plan_reduce(plan, i, reduce_dims, keepdim=True)\n\n # Unset mask and decrease g_count for the reduced dimensions\n for i, d in enumerate(to_reduce):\n ax = i + nout\n mask[ax] = mask[ax] and (d == -1)\n g_count[i] -= 0 if d == -1 else 1\n\n # Plan the summations over the operand sequence\n for i in range(nop):\n # plan a single step\n\n if i == 0:\n continue\n\n # We'd like to arrange the dimensions in the following way:\n # [I... J... K...]\n # [I... J... K...]\n # where \n # I... are aligned and not to be combined immediately \n # J... are not aligned and not to be combined immediately\n # K... are aligned and should be immediately combined\n # At this point the non-trivial broadcast dimensinos in K are already reduced\n # and removed. That means all K dimensions are aligned and their sizes are not 1.\n # We then inspect the layout of I,J,K plus the above observation to make\n # specializatoin decisions. The current strategy is set as follows:\n # (1) if I... J... K... are all empty, it's multiplying a scalar\n # (2) if K... are empty, better use a broadcast\n # (3) if I... J... empty and K... not empty, a vector-vector multiply (or a dot)\n # (4) Elsewise, either I... or J... not empty, and K... not empty, use a general matmul\n\n # Resolve the summation kind: dot, matmul or *\n if not any(g_supports[i - 1]):\n # op1 is a one element tensor.\n plan_scalar_prod(plan, i - 1, i)\n else:\n plan_summation(plan, g_view, i - 1, i, g_supports, g_shape, g_count,\n n_bcast)\n\n # for ax, dim in enumerate(g_view[nop-1][:nout]):\n # assert dim == ax\n assert all(not masked for masked in g_supports[nop - 1][nout:])\n\n view = g_view[-1]\n if any(ax != dim for ax, dim in enumerate(view[:nout])):\n perm = [dim for dim in view if dim >= 0]\n if sorted(perm) != perm:\n varname = f'op{nop-1}'\n step = transpose, [varname], varname, perm\n plan.add_step(step)\n dim = 0\n unsqueeze_dims = []\n for ax, d in enumerate(view):\n if d != -1:\n view[ax], dim = dim, dim + 1\n for ax, d in enumerate(view[:nout]):\n if d == -1:\n unsqueeze_dims.append(ax)\n if unsqueeze_dims:\n varname = f'op{nop-1}'\n step = unsqueeze, [varname], varname, unsqueeze_dims\n plan.add_step(step)\n\n squeeze_dims = [dim for dim in view[nout:] if dim != -1]\n if squeeze_dims:\n # plan_reduce(plan, nop-1, reduce_dims, keepdim=False)\n varname = f'op{nop-1}'\n step = squeeze, [varname], varname, squeeze_dims\n plan.add_step(step)\n\n return plan\n\n\ndef preprocess(equation, *operands):\n \"\"\"\n check equation / raise error, default right labels generation\n \"\"\"\n equation = equation.replace(\" \", \"\")\n nop = len(operands)\n assert nop > 0, \"Required at least one operand in Einsum API, but received %s \" % nop\n\n # Part the equation to left hand side and right hand side\n lhs, *rhs = equation.lower().split('->')\n assert len(rhs) < 2, \"Invalid equation: multiple `->` were found.\"\n\n labels = parse_labels(lhs, operands)\n # Note, we distinguish between 'ij->' and 'ij' by setting rhs to '' and None\n rhs = rhs[0] if rhs else None\n if rhs is None:\n rhs = rhs_inference(lhs)\n\n assert len(lhs.split(',')) == len(operands), (\n f\"Invalid equation: the number of operands is {len(operands)}, \"\n f\"but found {len(lhs.split(','))} segments in the label equation.\")\n\n assert not ('...' in lhs and '...' not in rhs\n ), f'Invalid equation: missing ellipsis in output labels.'\n\n assert not (len(list(filter(has_duplicated_labels, lhs.split(',')))) > 0\n ), f'Duplicate labels are not supported.'\n\n assert not has_duplicated_labels(\n rhs), f'Invalid equation: duplicate output labels are found.'\n\n return lhs, rhs, labels\n\n\ndef parse_fake_shape(equation, operands, labels):\n \"\"\" \n this shape is just used for operands planning. may differ with the original shape.\n for example: \n ... is replaced by 1\n -1 is replaced by 1\n Results\n -------\n list of shape\n \"\"\"\n shaped = collections.namedtuple('shaped', ['shape'])\n\n def fake_shape(label, op):\n assert len(op.shape) == len(\n label\n ), \"length of shape and length of label must be the same, but received %d != %d\" % (\n len(op.shape), len(label))\n fakes = [s for i, (l, s) in enumerate(zip(label, op.shape)) if l != '.']\n fakes = list(map(abs, fakes)) # make -1 -> 1\n if '.' in label:\n fakes.insert(label.index('.'), 1)\n return shaped(fakes)\n\n out = list(map(fake_shape, labels, operands))\n return out\n\n\ndef rhs_inference(lhs):\n def is_free(key):\n return cnt.get(key) == 1 and key not in ['.', ',']\n\n cnt = collections.Counter(lhs)\n rhs = \"...\" if '...' in lhs else \"\"\n rhs = rhs + \"\".join(filter(is_free, sorted(cnt.elements())))\n return rhs\n\n\ndef gen_equation_for_opteinsum(lhs, rhs):\n \"\"\" \n 1. gen rhs if rhs is None\n 2. '...' -> 'A'\n \"\"\"\n\n def get_used_label(counter):\n used = set(counter.elements())\n for c in string.ascii_lowercase:\n if c not in used: return c\n raise ValueError(\n \"You have used all `a` - `z`, there can't find a unused for einsum optimization\"\n )\n\n cnt = collections.Counter(lhs)\n broadcast_label = get_used_label(cnt)\n if rhs is None:\n rhs = rhs_inference(lhs)\n lhs = lhs.replace(\"...\", broadcast_label)\n rhs = rhs.replace(\"...\", broadcast_label)\n return lhs + \"->\" + rhs, broadcast_label\n\n\ndef einsum_v2(equation, *operands):\n \"\"\" \n einsum v2 implementation.\n 1. Implement C++ EinsumOp.\n 2. V2 create the EinsumOp to calculate, so just a little verifty work in python.\n 3. V2 use opt_einsum.contract_path to optimize the multivariable einsum.\n \"\"\"\n n_op = len(operands)\n lhs, rhs, labels = preprocess(equation, *operands)\n\n if n_op <= 2:\n return gen_einsum_op(lhs + '->' + rhs, *operands)\n\n shapes = parse_fake_shape(lhs, operands, labels)\n opt_equation, broadcast_label = gen_equation_for_opteinsum(lhs, rhs)\n _, cons = opt_einsum.contract_path(opt_equation, *shapes, einsum_call=True)\n var_list = list(operands)\n for path in cons:\n (a, b), _, eq, *__ = path\n assert a > b, \"Assume the first var_idx is smaller than the second_idx. opt_einsum can guarantee it.\"\n var_s = [var_list.pop(a), var_list.pop(b)]\n eq = eq.replace(broadcast_label, \"...\")\n var_list.append(gen_einsum_op(eq, *var_s))\n assert len(\n var_list\n ) == 1, \"There must be one elements in list, but received %d.\" % len(\n var_list)\n return var_list[0]\n\n\ndef gen_einsum_op(equation, *operands):\n \"\"\" \n EinsumOp Python Interface: \n \"\"\"\n assert len(operands) <= 2, \"Only support two operands in EinsumOp.\"\n if in_dygraph_mode():\n return _C_ops.final_state_einsum(operands, equation)[0]\n\n if _in_legacy_dygraph():\n # dygraph\n return _C_ops.einsum(operands, len(operands), 'equation', equation)[0]\n\n # static graph \n for inp in operands:\n check_variable_and_dtype(inp, 'dtype', ['float32', 'float64'], 'einsum')\n check_type(equation, 'equation', str, 'einsum')\n helper = LayerHelper('einsum', **locals())\n out = helper.create_variable_for_type_inference(dtype=operands[0].dtype)\n attrs = dict()\n attrs['equation'] = equation\n caches = [\n helper.create_variable_for_type_inference(dtype=operands[0].dtype)\n for i in range(len(operands))\n ]\n helper.append_op(\n type='einsum',\n inputs={'Operands': operands},\n outputs={'Out': out,\n \"InnerCache\": caches},\n attrs=attrs)\n return out\n\n\ndef einsum(equation, *operands):\n r\"\"\"\n einsum(equation, *operands)\n\n The current version of this API should be used in dygraph only mode.\n\n Einsum offers a tensor operation API which allows using the Einstein summation\n convention or Einstain notation. It takes as input one or multiple tensors and\n produces as output one tensor.\n\n Einsum is able to perform a variety of tensor operations. Following lists a few:\n\n - for single operand\n - trace\n - diagonal\n - transpose\n - sum\n - for double operands\n - dot\n - outer\n - broadcasting and elementwise multiply\n - matrix multiply\n - batched matrix multiply\n - for many operads\n - broadcasting multiply\n - chained matrix multiply\n \n **The summation notation**\n\n - The tensor dimensions are labeled using uncased English letters. E.g., `ijk`\n relates to a three dimensional tensor whose dimensions are labeled i, j, and k.\n - The equation is `,` separated into terms, each being a distinct input's\n dimension label string.\n - Ellipsis `...` enables broadcasting by automatically converting the unlabeled\n dimensions into broadcasting dimensions. \n - Singular labels are called free labels, duplicate are dummy labels. Dummy labeled\n dimensions will be reduced and removed in the output.\n - Output labels can be explicitly specified on the right hand side of `->` or omitted.\n In the latter case, the output labels will be inferred from the input labels.\n - Inference of output labels\n - Broadcasting label `...`, if present, is put on the leftmost position.\n - Free labels are reordered alphabetically and put after `...`.\n - On explicit output labels\n - If broadcasting is enabled, then `...` must be present.\n - The output labels can be an empty, an indication to output as a scalar\n the sum over the original output.\n - Non-input labels are invalid.\n - Duplicate labels are invalid.\n - For any dummmy label which is present for the output, it's promoted to\n a free label.\n - For any free label which is not present for the output, it's lowered to\n a dummy label.\n - Examples\n - '...ij, ...jk', where i and k are free labels, j is dummy. The output label\n string is '...ik'\n - 'ij -> i', where i is a free label and j is a dummy label. \n - '...ij, ...jk -> ...ijk', where i, j and k are all free labels.\n - '...ij, ...jk -> ij', an invalid equation since `...` is not present for\n the output.\n\n **The summation rule**\n\n The summation procedure can be outlined as follows, although the actual steps taken\n may vary significantly due to implementation specific optimization.\n\n - Step 1: preparation for broadcasting, that is, transposing and unsqueezing\n the input operands to have each resulting dimension identically labeled across\n all the input operands.\n - Step 2: broadcasting multiply all the resulting operands from step 1.\n - Step 3: reducing dummy labeled dimensions.\n - Step 4: transposing the result tensor to match the output labels.\n\n **On trace and diagonal**\n\n The trace and diagonal are planned yet unimplemented features. \n\n Args:\n equation (`str`):\n The summation terms using the Einstein summation notation.\n operands (`list|Tensor`):\n The input tensors over which to compute the Einstein summation. The number of\n operands should equal the number of input terms in the equation.\n \n Returns:\n result (`Tensor`): the result tensor.\n \n Examples:\n .. code-block:: python\n\n import paddle\n paddle.seed(102)\n x = paddle.rand([4])\n y = paddle.rand([5])\n\n # sum\n print(paddle.einsum('i->', x))\n # Tensor(shape=[], dtype=float32, place=CUDAPlace(0), stop_gradient=True,\n # 1.95791852)\n\n # dot\n print(paddle.einsum('i,i->', x, x))\n # Tensor(shape=[1], dtype=float32, place=CUDAPlace(0), stop_gradient=True,\n # [1.45936954])\n \n # outer\n print(paddle.einsum(\"i,j->ij\", x, y))\n # Tensor(shape=[4, 5], dtype=float32, place=CUDAPlace(0), stop_gradient=True,\n # [[0.00079869, 0.00120950, 0.00136844, 0.00187187, 0.00192194],\n # [0.23455200, 0.35519385, 0.40186870, 0.54970956, 0.56441545],\n # [0.11773264, 0.17828843, 0.20171674, 0.27592498, 0.28330654],\n # [0.32897076, 0.49817693, 0.56364071, 0.77099484, 0.79162055]])\n \n A = paddle.rand([2, 3, 2])\n B = paddle.rand([2, 2, 3])\n \n # transpose\n print(paddle.einsum('ijk->kji', A))\n # Tensor(shape=[2, 3, 2], dtype=float32, place=CUDAPlace(0), stop_gradient=True,\n # [[[0.95649719, 0.49684682],\n # [0.80071914, 0.46258664],\n # [0.49814570, 0.33383518]],\n #\n # [[0.07637714, 0.29374704],\n # [0.51470858, 0.51907635],\n # [0.99066722, 0.55802226]]])\n \n # batch matrix multiplication\n print(paddle.einsum('ijk, ikl->ijl', A,B))\n # Tensor(shape=[2, 3, 3], dtype=float32, place=CUDAPlace(0), stop_gradient=True,\n # [[[0.32172769, 0.50617385, 0.41394392],\n # [0.51736701, 0.49921003, 0.38730967],\n # [0.69078457, 0.42282537, 0.30161136]],\n #\n # [[0.32043904, 0.18164253, 0.27810261],\n # [0.50226176, 0.24512935, 0.39881429],\n # [0.51476848, 0.23367381, 0.39229113]]])\n \n # Ellipsis transpose\n print(paddle.einsum('...jk->...kj', A))\n # Tensor(shape=[2, 2, 3], dtype=float32, place=CUDAPlace(0), stop_gradient=True,\n # [[[0.95649719, 0.80071914, 0.49814570],\n # [0.07637714, 0.51470858, 0.99066722]],\n #\n # [[0.49684682, 0.46258664, 0.33383518],\n # [0.29374704, 0.51907635, 0.55802226]]])\n \n # Ellipsis batch matrix multiplication\n print(paddle.einsum('...jk, ...kl->...jl', A,B))\n # Tensor(shape=[2, 3, 3], dtype=float32, place=CUDAPlace(0), stop_gradient=True,\n # [[[0.32172769, 0.50617385, 0.41394392],\n # [0.51736701, 0.49921003, 0.38730967],\n # [0.69078457, 0.42282537, 0.30161136]],\n #\n # [[0.32043904, 0.18164253, 0.27810261],\n # [0.50226176, 0.24512935, 0.39881429],\n # [0.51476848, 0.23367381, 0.39229113]]])\n \"\"\"\n import os\n if int(os.environ.get('FLAGS_new_einsum', \"1\")):\n return einsum_v2(equation, *operands)\n\n nop = len(operands)\n assert nop > 0, \"At least one operand is expected.\"\n\n # Part the equation to left hand side and right hand side\n lhs, *rhs = equation.lower().replace(' ', '').split('->')\n assert len(rhs) < 2, \"Invalid equation: multiple `->` were found.\"\n\n # Note, we distinguish between 'ij->' and 'ij' by setting rhs to '' and None\n rhs = rhs[0] if rhs else None\n\n # Parse labels for each operand and count the number of occurrences for each alphabet label\n nop_labels = parse_labels(lhs, operands)\n\n # Diagonalize the operands which have duplicate labels\n nop_labels, operands = list(zip(*map(diagonalize, nop_labels, operands)))\n\n # To handle broadcasting, we should first know how many dimensions are there\n # We need to use that number to generate output labels\n # e.g. 1 for ['ij', 'i.', '.k']\n n_bcast_dims = max(map(lambda s: s.count('.'), nop_labels))\n\n # Build the data structures for planning. It's helpful to think of all the operands\n # broadcasting together from a global view. In this view, dimensions from multiple \n # operands are mapped to the same position if they are labeled uniquely. Broadcasting\n # dimensions are mapped to adjacent positions with the right bound fixed. Subject to\n # each operand, the map is injective but for all operands the map is on-to. \n # g_labels:\n # The labels of the global view \n # g_view:\n # Includes a list of maps from each operand's dimensions to the global view's dimensions\n # which we refer to as ax or axes in the code to distinguish from operand's dims\n # g_shape:\n # The shape of the global view. The size of each dimension is what the aligned dimensions\n # should broadcast to\n # g_nout:\n # Number of output axes\n # g_supports\n # Booleans indicating each operand's non-trivial dimensions\n # g_count\n # Counting how many non-trivial dimensions remain for each ax\n\n g_labels, g_view, g_nout, g_count = build_global_view(nop_labels, rhs,\n n_bcast_dims)\n g_shape, g_supports = build_global_shape(g_view, g_labels,\n [op.shape for op in operands])\n\n # Now we're ready to build up an execution plan\n args = operands, g_view, g_shape, g_supports, g_count, n_bcast_dims\n plan = plan_einsum(*args)\n result = plan.execute()\n\n return result\n", "meta": {"hexsha": "49cc426a00fd998c2ed24f94fb0002e4466065af", "size": 35918, "ext": "py", "lang": "Python", "max_stars_repo_path": "python/paddle/tensor/einsum.py", "max_stars_repo_name": "RangeKing/Paddle", "max_stars_repo_head_hexsha": "2d87300809ae75d76f5b0b457d8112cb88dc3e27", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2016-08-15T07:02:27.000Z", "max_stars_repo_stars_event_max_datetime": "2016-08-24T09:34:00.000Z", "max_issues_repo_path": "python/paddle/tensor/einsum.py", "max_issues_repo_name": "RangeKing/Paddle", "max_issues_repo_head_hexsha": "2d87300809ae75d76f5b0b457d8112cb88dc3e27", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "python/paddle/tensor/einsum.py", "max_forks_repo_name": "RangeKing/Paddle", "max_forks_repo_head_hexsha": "2d87300809ae75d76f5b0b457d8112cb88dc3e27", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.5033621518, "max_line_length": 109, "alphanum_fraction": 0.5976112256, "include": true, "reason": "import numpy", "num_tokens": 9542, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5039061705290805, "lm_q2_score": 0.3775406828054583, "lm_q1q2_score": 0.19024507969143278}} {"text": "#!/usr/bin/env python\n# Copyright 2018-2020 The PySCF Developers. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n# Author: Qiming Sun \n#\n\n'''\nPseudo-spectral methods (COSX, PS, SN-K)\n'''\n\nimport copy\nimport numpy\nfrom pyscf import lib\nfrom pyscf import gto\nfrom pyscf import scf\nfrom pyscf import mcscf\nfrom pyscf.scf import _vhf\nfrom pyscf.lib import logger\nfrom pyscf.sgx import sgx_jk\nfrom pyscf.df import df_jk\nfrom pyscf import __config__\n\ndef sgx_fit(mf, auxbasis=None, with_df=None):\n '''For the given SCF object, update the J, K matrix constructor with\n corresponding SGX or density fitting integrals.\n\n Args:\n mf : an SCF object\n\n Kwargs:\n auxbasis : str or basis dict\n Same format to the input attribute mol.basis. If auxbasis is\n None, optimal auxiliary basis based on AO basis (if possible) or\n even-tempered Gaussian basis will be used.\n\n Returns:\n An SCF object with a modified J, K matrix constructor which uses density\n fitting integrals to compute J and K\n\n Examples:\n\n >>> mol = gto.M(atom='H 0 0 0; F 0 0 1', basis='ccpvdz', verbose=0)\n >>> mf = sgx_fit(scf.RHF(mol))\n >>> mf.scf()\n -100.00978770917165\n\n >>> mol.symmetry = 1\n >>> mol.build(0, 0)\n >>> mf = sgx_fit(scf.UHF(mol))\n >>> mf.scf()\n -100.00978770951018\n '''\n assert(isinstance(mf, scf.hf.SCF))\n\n if with_df is None:\n with_df = SGX(mf.mol)\n with_df.max_memory = mf.max_memory\n with_df.stdout = mf.stdout\n with_df.verbose = mf.verbose\n with_df.auxbasis = auxbasis\n\n mf_class = mf.__class__\n\n if isinstance(mf, _SGXHF):\n if mf.with_df is None:\n mf = mf_class(mf, with_df, auxbasis)\n elif mf.with_df.auxbasis != auxbasis:\n #logger.warn(mf, 'DF might have been initialized twice.')\n mf = copy.copy(mf)\n mf.with_df = with_df\n return mf\n\n class SGXHF(_SGXHF, mf_class):\n def __init__(self, mf, df, auxbasis):\n self.__dict__.update(mf.__dict__)\n self._eri = None\n self.auxbasis = auxbasis\n self.with_df = df\n\n # Grids/Integral quality varies during SCF. VHF cannot be\n # constructed incrementally.\n self.direct_scf = False\n\n self._last_dm = 0\n self._in_scf = False\n self._keys = self._keys.union(['auxbasis', 'with_df'])\n\n def build(self, mol=None, **kwargs):\n if self.direct_scf:\n self.with_df.build(level=self.with_df.grids_level_f)\n else:\n self.with_df.build(level=self.with_df.grids_level_i)\n return mf_class.build(self, mol, **kwargs)\n\n def reset(self, mol=None):\n self.with_df.reset(mol)\n return mf_class.reset(self, mol)\n\n def pre_kernel(self, envs):\n self._in_scf = True\n\n def get_jk(self, mol=None, dm=None, hermi=1, with_j=True, with_k=True,\n omega=None):\n if dm is None: dm = self.make_rdm1()\n with_df = self.with_df\n if not with_df:\n return mf_class.get_jk(self, mol, dm, hermi, with_j, with_k, omega)\n\n if self._in_scf and not self.direct_scf:\n if numpy.linalg.norm(dm - self._last_dm) < with_df.grids_switch_thrd:\n logger.debug(self, 'Switching SGX grids')\n with_df.build(level=with_df.grids_level_f)\n self._in_scf = False\n self._last_dm = 0\n else:\n self._last_dm = numpy.asarray(dm)\n\n return with_df.get_jk(dm, hermi, with_j, with_k,\n self.direct_scf_tol, omega)\n\n def post_kernel(self, envs):\n self._in_scf = False\n self._last_dm = 0\n\n def nuc_grad_method(self):\n raise NotImplementedError\n\n return SGXHF(mf, with_df, auxbasis)\n\n# A tag to label the derived SCF class\nclass _SGXHF(object):\n def method_not_implemented(self, *args, **kwargs):\n raise NotImplementedError\n nuc_grad_method = Gradients = method_not_implemented\n Hessian = method_not_implemented\n NMR = method_not_implemented\n NSR = method_not_implemented\n Polarizability = method_not_implemented\n RotationalGTensor = method_not_implemented\n MP2 = method_not_implemented\n CISD = method_not_implemented\n CCSD = method_not_implemented\n CASCI = method_not_implemented\n CASSCF = method_not_implemented\n\nscf.hf.SCF.COSX = sgx_fit\nmcscf.casci.CASCI.COSX = sgx_fit\n\n\ndef _make_opt(mol):\n '''Optimizer to genrate 3-center 2-electron integrals'''\n intor = mol._add_suffix('int3c2e')\n cintopt = gto.moleintor.make_cintopt(mol._atm, mol._bas, mol._env, intor)\n # intor 'int1e_ovlp' is used by the prescreen method\n # 'SGXnr_ovlp_prescreen' only. Not used again in other places.\n # It can be released early\n vhfopt = _vhf.VHFOpt(mol, 'int1e_ovlp', 'SGXnr_ovlp_prescreen',\n 'SGXsetnr_direct_scf')\n vhfopt._intor = intor\n vhfopt._cintopt = cintopt\n return vhfopt\n\n\nclass SGX(lib.StreamObject):\n def __init__(self, mol, auxbasis=None):\n self.mol = mol\n self.stdout = mol.stdout\n self.verbose = mol.verbose\n self.max_memory = mol.max_memory\n self.grids_thrd = 1e-10\n self.grids_level_i = 0 # initial grids level\n self.grids_level_f = 1 # final grids level\n self.grids_switch_thrd = 0.03\n # compute J matrix using DF and K matrix using SGX. It's identical to\n # the RIJCOSX method in ORCA\n self.dfj = False\n self._auxbasis = auxbasis\n\n # debug=True generates a dense tensor of the Coulomb integrals at each\n # grids. debug=False utilizes the sparsity of the integral tensor and\n # contracts the sparse tensor and density matrices on the fly.\n self.debug = False\n\n self.grids = None\n self.blockdim = 1200\n self.auxmol = None\n self._vjopt = None\n self._opt = None\n self._last_dm = 0\n self._rsh_df = {} # Range separated Coulomb DF objects\n self._keys = set(self.__dict__.keys())\n\n @property\n def auxbasis(self):\n return self._auxbasis\n @auxbasis.setter\n def auxbasis(self, x):\n if self._auxbasis != x:\n self._auxbasis = x\n self.auxmol = None\n\n def dump_flags(self, verbose=None):\n log = logger.new_logger(self, verbose)\n log.info('******** %s ********', self.__class__)\n log.info('max_memory = %s', self.max_memory)\n log.info('grids_level_i = %s', self.grids_level_i)\n log.info('grids_level_f = %s', self.grids_level_f)\n log.info('grids_thrd = %s', self.grids_thrd)\n log.info('grids_switch_thrd = %s', self.grids_switch_thrd)\n log.info('df_j = %s', self.df_j)\n log.info('auxbasis = %s', self.auxbasis)\n return self\n\n # To mimic DF object, so that SGX can be used as in DF-SCF method by setting\n # mf.with_df = SGX(mol)\n @property\n def _cderi(self):\n return self.grids\n\n def build(self, level=None):\n if level is None:\n level = self.grids_level_f\n self.grids = sgx_jk.get_gridss(self.mol, level, self.grids_thrd)\n self._opt = _make_opt(self.mol)\n\n # In the RSH-integral temporary treatment, recursively rebuild SGX\n # objects in _rsh_df.\n if self._rsh_df:\n for k, v in self._rsh_df.items():\n v.build(level)\n return self\n\n def kernel(self, *args, **kwargs):\n return self.build(*args, **kwargs)\n\n def reset(self, mol=None):\n '''Reset mol and clean up relevant attributes for scanner mode'''\n if mol is not None:\n self.mol = mol\n self.grids = None\n self.auxmol = None\n self._vjopt = None\n self._opt = None\n self._last_dm = 0\n self._rsh_df = {}\n return self\n\n def get_jk(self, dm, hermi=1, with_j=True, with_k=True,\n direct_scf_tol=getattr(__config__, 'scf_hf_SCF_direct_scf_tol', 1e-13),\n omega=None):\n if omega is not None:\n # A temporary treatment for RSH integrals\n key = '%.6f' % omega\n if key in self._rsh_df:\n rsh_df = self._rsh_df[key]\n else:\n rsh_df = copy.copy(self)\n rsh_df._rsh_df = None # to avoid circular reference\n # Not all attributes need to be reset. Resetting _vjopt\n # because it is used by get_j method of regular DF object.\n rsh_df._vjopt = None\n self._rsh_df[key] = rsh_df\n logger.info(self, 'Create RSH-SGX object %s for omega=%s', rsh_df, omega)\n\n with rsh_df.mol.with_range_coulomb(omega):\n return rsh_df.get_jk(dm, hermi, with_j, with_k,\n direct_scf_tol)\n\n if with_j and self.dfj:\n vj = df_jk.get_j(self, dm, hermi, direct_scf_tol)\n if with_k:\n vk = sgx_jk.get_jk(self, dm, hermi, False, with_k, direct_scf_tol)[1]\n else:\n vk = None\n else:\n vj, vk = sgx_jk.get_jk(self, dm, hermi, with_j, with_k, direct_scf_tol)\n return vj, vk\n\n\nif __name__ == '__main__':\n from pyscf import scf\n mol = gto.Mole()\n mol.build(\n atom = [[\"O\" , (0. , 0. , 0.)],\n [1 , (0. , -0.757 , 0.587)],\n [1 , (0. , 0.757 , 0.587)] ],\n basis = 'ccpvdz',\n )\n method = sgx_fit(scf.RHF(mol), 'weigend')\n energy = method.scf()\n print(energy - -76.02673747045691)\n\n method.with_df.dfj = True\n energy = method.scf()\n print(energy - -76.02686422219752)\n", "meta": {"hexsha": "07944afff49fa24e07a81620b7148f2200f931cc", "size": 10403, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyscf/sgx/sgx.py", "max_stars_repo_name": "mfkasim1/pyscf", "max_stars_repo_head_hexsha": "7be5e015b2b40181755c71d888449db936604660", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-11-12T11:55:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-12T11:55:25.000Z", "max_issues_repo_path": "pyscf/sgx/sgx.py", "max_issues_repo_name": "mfkasim1/pyscf", "max_issues_repo_head_hexsha": "7be5e015b2b40181755c71d888449db936604660", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 36, "max_issues_repo_issues_event_min_datetime": "2018-08-22T19:44:03.000Z", "max_issues_repo_issues_event_max_datetime": "2020-05-09T10:02:36.000Z", "max_forks_repo_path": "pyscf/sgx/sgx.py", "max_forks_repo_name": "mfkasim1/pyscf", "max_forks_repo_head_hexsha": "7be5e015b2b40181755c71d888449db936604660", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2018-02-14T16:28:28.000Z", "max_forks_repo_forks_event_max_datetime": "2019-08-12T16:40:30.000Z", "avg_line_length": 33.775974026, "max_line_length": 89, "alphanum_fraction": 0.6042487744, "include": true, "reason": "import numpy", "num_tokens": 2817, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5039061705290805, "lm_q2_score": 0.37754067580180184, "lm_q1q2_score": 0.19024507616224706}} {"text": "#! /usr/bin/env python3\n\nimport random\nimport copy\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy.signal import find_peaks_cwt\n\n\nLENGTH = 50000000\nN_TRIALS = 350\nselection_strength = 1\n\nreplicates = 3000\nplot_all = False\nwindow = 1000000\nstep = 10000\n\nout_pre = '/Volumes/Jacob_2TB_storage/sim_sec_recombination_mapping/genomics_scripts/analysis/'\n\n\nclass Sample_pool():\n \"\"\"Holds samples, which need to be Sequence objects\"\"\"\n\n def __init__(self):\n self.pool = {}\n self.keys = []\n \n def add_sample(self, sequence):\n if self.keys:\n newkey = max(self.keys) + 1\n else:\n newkey = 0\n self.pool[newkey] = sequence\n self.keys = list(self.pool.keys())\n\n def pick_sample(self):\n \"\"\"Selects a random sample\"\"\"\n sample = random.choice(self.keys)\n return self.pool[sample]\n\n def sample_freq(self, position):\n \"\"\"Gathers a sample allele frequency for a given position\"\"\"\n reps = random.randint(36,40)\n mel = 0\n sim = 0\n sec = 0\n for i in range(reps):\n sample = self.pick_sample()\n if sample[position] == 1:\n mel += 1\n elif sample[position] == 2:\n sim += 1\n elif sample[position] == 3:\n sec += 1\n\n melf = mel / (mel + sim + sec)\n simf = sim / (mel + sim + sec)\n secf = sec / (mel + sim + sec)\n\n return melf, simf, secf\n\ndef bool_chance(num):\n x = random.random()\n if x < num:\n return True\n else:\n return False\n\ndef generate_parents():\n \"\"\"\n Generate a set of 3 parents where all positions are 0, if mel specific 1,\n if sim specific 2, and if sec specific 3.\n Return Dicitonary of parents\n \"\"\"\n\n everyN = 6000\n \n # get a list of the positions that would be differentiating spots\n id_spots = [random.randint(0,LENGTH) for i in range(int(LENGTH/everyN))]\n id_spots.sort()\n\n # make a list of the same length for each species\n mel_seq = [1] * len(id_spots)\n sim_seq = [2] * len(id_spots)\n sec_seq = [3] * len(id_spots)\n\n parents = {\n 'mel' : mel_seq,\n 'sim' : sim_seq,\n 'sec' : sec_seq,\n\n }\n\n return parents, id_spots\n\ndef pick_selected_index(id_spots):\n \"\"\"\n Takes the list of different sites between the three sequences\n Picks a random spot in the middle half of the sequences to be the selected site\n Returns the index of the differentiated spots list that is closest to the \n selected point, and the selected point\n \"\"\"\n\n q1 = int(LENGTH / 8)\n q3 = int(7 * LENGTH / 8)\n sel_spot = random.randint(q1, q3)\n\n hold = 0\n for idx, x in enumerate(id_spots):\n if x < sel_spot:\n hold = x\n else:\n if (sel_spot - hold) <= (x - sel_spot):\n return (idx-1), sel_spot\n else:\n return idx, sel_spot\n\ndef reorder(one, two):\n if one >= two:\n return two, one\n else:\n return one, two\n\ndef gamma_model():\n \"\"\"Compute the gamma distrubtion model for recombination.\n Return a dictionary with 100 steps (should never need that many)\n \"\"\"\n model = {}\n prev = 0\n for i in range(1,101):\n # the computation:\n # (5*1morgan) (sum_to_i)(\n # 1 / (5i-1) * 1M^(5i) * dist^(5i-1) * e^(-(1M)*dist) \n # )\n # where distance is in morgans\n prev += ((1**(5*i)) * ((0.01*i)**((5*i)-1)) * (np.e ** (-(0.01*i)))) / (5*(i) - 1)\n model[i] = 5 * prev\n return model\n\ndef recombine(seq1, seq2, model):\n \"\"\"Make a recombinant sequence from sequence 1 and 2\"\"\"\n\n idxs = [idx for idx, x in enumerate(seq1)]\n\n co1 = random.choice(idxs)\n\n half = int(len(idxs) / 2)\n\n if co1 < half:\n co2 = random.choice(idxs[half:])\n else:\n co2 = random.choice(idxs[:half])\n\n co1, co2 = reorder(co1, co2)\n\n if bool_chance(0.5):\n rec_seq = seq1[:co1] + seq2[co1:co2] + seq1[co2:]\n else:\n rec_seq = seq2[:co1] + seq1[co1:co2] + seq2[co2:]\n\n return rec_seq\n\ndef filter(seq, sel_idx, sel_strength):\n \"\"\"Checks if a sequence contains the selected site\"\"\"\n if seq[sel_idx] == 2:\n return True\n else:\n if bool_chance(1-sel_strength):\n return True\n else:\n return False\n\ndef make_pool(parents, sel_idx, sex, sel_strength, model):\n \"\"\"\n Input: mel, sim, sec parent sequence , site to be selected on\n Returns: sample pool of recombinant sequences and mel sequences\n \"\"\"\n\n pool = Sample_pool()\n for i in range(N_TRIALS):\n survive = False\n while not survive:\n recseq = recombine(parents['sim'], parents['sec'], model)\n survive = filter(recseq, sel_idx, sel_strength)\n if sex == 'female':\n survive = True\n pool.add_sample(recseq)\n # because diploids, we add one mel sequence for each recombinant sequence\n pool.add_sample(parents['mel'])\n\n return pool\n\ndef simulate_sequencing(pool, id_spots):\n table = []\n for idx, x in enumerate(id_spots):\n mel, sim, sec = pool.sample_freq(idx)\n table.append([x,mel,sim,sec])\n return table\n\ndef sex_difference(male_reps, female_reps):\n reps = {}\n\n for i in male_reps:\n reps[i] = []\n for idx, entry in enumerate(male_reps[i]):\n male = male_reps[i][idx]\n female = female_reps[i][idx]\n freq = [(male[0]), (male[1] - female[1]), (male[2] - female[2]), (male[3] - female[3])]\n reps[i].append(freq)\n \n return reps\n\ndef average_replicates(reps):\n table = []\n for pos, lis in enumerate(reps[0]):\n melav = (reps[0][pos][1] + reps[1][pos][1] + reps[2][pos][1]) / 3\n simav = (reps[0][pos][2] + reps[1][pos][2] + reps[2][pos][2]) / 3\n secav = (reps[0][pos][3] + reps[1][pos][3] + reps[2][pos][3]) / 3\n table.append([reps[0][pos][0], melav, simav, secav])\n return table\n\ndef rolling_average(table, window, step):\n \n win2 = window/2\n pos = window/2\n\n window_table = []\n posits = [x[0] for x in table]\n while pos < max(posits):\n melav = []\n simav = []\n secav = []\n for x in table:\n if (x[0] > pos-win2):\n if (x[0] < pos+win2):\n melav.append(x[1])\n simav.append(x[2])\n secav.append(x[3])\n else:\n break\n if melav and simav and secav:\n window_table.append([pos, np.mean(melav), np.mean(simav), np.mean(secav)])\n pos += step\n\n \n newtable = [['position','mel','sim','sec']]\n for x in window_table:\n newtable.append(x)\n\n return newtable\n\ndef estimate_max(table):\n table = table[1:]\n sim_freqs = [(x[0],(x[2]-x[3]))for x in table]\n sim_freqs = sorted(sim_freqs, key=lambda x: x[1])\n\n # find the peaks\n xs = [x[1] for x in sim_freqs]\n peaks = list(find_peaks_cwt(xs, np.arange(50, 200)))\n\n # this produces a list. Find the biggest one in the list\n big = (0,0)\n for peak in peaks:\n if sim_freqs[peak][1] > big[1]:\n big = (sim_freqs[peak][0], sim_freqs[peak][1])\n\n return big[0]\n\ndef write_to_csv(table, filename):\n with open(filename, 'w') as f:\n for line in table:\n line = [str(x) for x in line]\n f.write(','.join(line))\n f.write('\\n')\n\ndef plot_frequencies(filename, sel_spot, esitmate, num):\n df = pd.read_csv(filename)\n fig = plt.figure(figsize=(6, 8))\n plt.plot(df['position'], df['mel'], color = 'blue', label = 'D.mel')\n plt.plot(df['position'], df['sim'], color = 'orange', label = 'D.sim')\n plt.plot(df['position'], df['sec'], color = 'red', label = 'D.sec')\n plt.axvline(x=sel_spot, color='black', label = 'actual site')\n plt.axvline(x=esitmate, color='green', label = 'estimated site')\n plt.ylim(-0.4,0.4)\n plt.legend()\n plt.ylabel('Allele Frequency (Male - Female)')\n plt.xlabel('Genomic position')\n plotname = filename.split('.csv')[0] + str(num) + '.pdf'\n plt.savefig(plotname)\n\n\nparents, id_spots = generate_parents()\nmodel = gamma_model()\ndifferences = []\nfor i2 in range(replicates):\n sel_idx, sel_spot = pick_selected_index(id_spots)\n male_reps = {}\n female_reps = {}\n reps = {}\n # replicate 3 times\n for i in range(3):\n male_pool = make_pool(parents, sel_idx, 'male', selection_strength, model)\n female_pool = make_pool(parents, sel_idx, 'female', selection_strength, model)\n male_reps[i] = simulate_sequencing(male_pool, id_spots)\n female_reps[i] = simulate_sequencing(female_pool, id_spots)\n reps = sex_difference(male_reps, female_reps)\n table = average_replicates(reps)\n table = rolling_average(table, window, step)\n estimated_site = estimate_max(table)\n differences.append(estimated_site-sel_spot)\n if plot_all:\n outtable = out_pre + str(i2) + 'simulation_out.csv'\n write_to_csv(table, outtable)\n plot_frequencies(outtable, sel_spot, estimated_site, i2)\n\n\nprint(differences)\nprint(\"2x std:\", np.std(differences))\nprint(\"Average:\", np.average(differences))\nplt.hist(differences, bins=20)\nplt.savefig(out_pre+'confidence_hist.pdf')\n\nouttable = out_pre + 'final_simulation_out.csv'\nwrite_to_csv(table, outtable)\nplot_frequencies(outtable, sel_spot, estimated_site, 'final')\n", "meta": {"hexsha": "28acbd9212671df05033225818b866597962a501", "size": 9489, "ext": "py", "lang": "Python", "max_stars_repo_path": "simulation/frequency_estimation_mega_script.py", "max_stars_repo_name": "jcooper036/tri_hybid_mapping", "max_stars_repo_head_hexsha": "a4a0aebcf1a1fb3773b1b402a25635b53004856a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "simulation/frequency_estimation_mega_script.py", "max_issues_repo_name": "jcooper036/tri_hybid_mapping", "max_issues_repo_head_hexsha": "a4a0aebcf1a1fb3773b1b402a25635b53004856a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "simulation/frequency_estimation_mega_script.py", "max_forks_repo_name": "jcooper036/tri_hybid_mapping", "max_forks_repo_head_hexsha": "a4a0aebcf1a1fb3773b1b402a25635b53004856a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.9298780488, "max_line_length": 99, "alphanum_fraction": 0.5843608389, "include": true, "reason": "import numpy,from scipy", "num_tokens": 2653, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5039061705290806, "lm_q2_score": 0.3775406687981454, "lm_q1q2_score": 0.1902450726330614}} {"text": "#!/usr/bin/python\n# -*- coding: utf-8 -*-\n\n################################################################################\n#\n# RMG - Reaction Mechanism Generator\n#\n# Copyright (c) 2002-2010 Prof. William H. Green (whgreen@mit.edu) and the\n# RMG Team (rmg_dev@mit.edu)\n#\n# Permission is hereby granted, free of charge, to any person obtaining a\n# copy of this software and associated documentation files (the 'Software'),\n# to deal in the Software without restriction, including without limitation\n# the rights to use, copy, modify, merge, publish, distribute, sublicense,\n# and/or sell copies of the Software, and to permit persons to whom the\n# Software is furnished to do so, subject to the following conditions:\n#\n# The above copyright notice and this permission notice shall be included in\n# all copies or substantial portions of the Software.\n#\n# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n# DEALINGS IN THE SOFTWARE.\n#\n################################################################################\n\n\"\"\"\n\n\"\"\"\n\nimport os\nimport os.path\nimport math\nimport logging\nimport numpy\nfrom copy import copy, deepcopy\n\nfrom base import Database, Entry, makeLogicNode\n\nfrom rmgpy.quantity import constants\nfrom rmgpy.thermo import *\nfrom rmgpy.molecule import Molecule, Atom, Bond, Group\n\n################################################################################\n\ndef saveEntry(f, entry):\n \"\"\"\n Write a Pythonic string representation of the given `entry` in the thermo\n database to the file object `f`.\n \"\"\"\n \n f.write('entry(\\n')\n f.write(' index = {0:d},\\n'.format(entry.index))\n f.write(' label = \"{0}\",\\n'.format(entry.label))\n\n if isinstance(entry.item, Molecule):\n f.write(' molecule = \\n')\n f.write('\"\"\"\\n')\n f.write(entry.item.toAdjacencyList(removeH=True))\n f.write('\"\"\",\\n')\n elif isinstance(entry.item, Group):\n f.write(' group = \\n')\n f.write('\"\"\"\\n')\n f.write(entry.item.toAdjacencyList())\n f.write('\"\"\",\\n')\n else:\n f.write(' group = \"{0}\",\\n'.format(entry.item))\n\n if isinstance(entry.data, ThermoData):\n f.write(' thermo = ThermoData(\\n')\n f.write(' Tdata = {0!r},\\n'.format(entry.data.Tdata))\n f.write(' Cpdata = {0!r},\\n'.format(entry.data.Cpdata))\n f.write(' H298 = {0!r},\\n'.format(entry.data.H298))\n f.write(' S298 = {0!r},\\n'.format(entry.data.S298))\n if entry.data.Tmin is not None: f.write(' Tmin = {0!r},\\n'.format(entry.data.Tmin))\n if entry.data.Tmax is not None: f.write(' Tmax = {0!r},\\n'.format(entry.data.Tmax))\n f.write(' ),\\n')\n elif isinstance(entry.data, Wilhoit):\n f.write(' thermo = Wilhoit(\\n')\n f.write(' cp0 = {0!r},\\n'.format(entry.data.cp0))\n f.write(' cpInf = {0!r},\\n'.format(entry.data.cpInf))\n f.write(' a0 = {0:g},\\n'.format(entry.data.a0))\n f.write(' a1 = {0:g},\\n'.format(entry.data.a1))\n f.write(' a2 = {0:g},\\n'.format(entry.data.a2))\n f.write(' a3 = {0:g},\\n'.format(entry.data.a3))\n f.write(' B = {0!r},\\n'.format(entry.data.B))\n f.write(' H0 = {0!r},\\n'.format(entry.data.H0))\n f.write(' S0 = {0!r},\\n'.format(entry.data.S0))\n if entry.data.Tmin is not None: f.write(' Tmin = {0!r},\\n'.format(entry.data.Tmin))\n if entry.data.Tmax is not None: f.write(' Tmax = {0!r},\\n'.format(entry.data.Tmax))\n f.write(' ),\\n')\n elif isinstance(entry.data, MultiNASA):\n f.write(' thermo = MultiNASA(\\n')\n f.write(' polynomials = [\\n')\n for poly in entry.data.polynomials:\n f.write(' {0!r},\\n'.format(poly))\n f.write(' ],\\n')\n if entry.data.Tmin is not None: f.write(' Tmin = {0!r},\\n'.format(entry.data.Tmin))\n if entry.data.Tmax is not None: f.write(' Tmax = {0!r},\\n'.format(entry.data.Tmax))\n f.write(' ),\\n')\n else:\n f.write(' thermo = {0!r},\\n'.format(entry.data))\n\n if entry.reference is not None: f.write(' reference = {0!r},\\n'.format(entry.reference))\n if entry.referenceType != \"\": f.write(' referenceType = \"{0}\",\\n'.format(entry.referenceType))\n f.write(' shortDesc = u\"\"\"{0}\"\"\",\\n'.format(entry.shortDesc))\n f.write(' longDesc = \\n')\n f.write('u\"\"\"\\n')\n f.write(entry.longDesc.strip() + \"\\n\")\n f.write('\"\"\",\\n')\n\n f.write(' history = [\\n')\n for time, user, action, description in entry.history:\n f.write(' (\"{0}\",\"{1}\",\"{2}\",\"\"\"{3}\"\"\"),\\n'.format(time, user, action, description))\n f.write(' ],\\n')\n\n f.write(')\\n\\n')\n\ndef generateOldLibraryEntry(data):\n \"\"\"\n Return a list of values used to save entries to the old-style RMG\n thermo database based on the thermodynamics object `data`.\n \"\"\"\n if isinstance(data, ThermoData):\n return '{0:9g} {1:9g} {2:9g} {3:9g} {4:9g} {5:9g} {6:9g} {7:9g} {8:9g} {9:9g} {10:9g} {11:9g}'.format(\n data.H298.value/4184.,\n data.S298.value/4.184,\n data.Cpdata.values[0]/4.184,\n data.Cpdata.values[1]/4.184,\n data.Cpdata.values[2]/4.184,\n data.Cpdata.values[3]/4.184,\n data.Cpdata.values[4]/4.184,\n data.Cpdata.values[5]/4.184,\n data.Cpdata.values[6]/4.184,\n data.H298.uncertainty/4184.,\n data.S298.uncertainty/4.184,\n data.Cpdata.uncertainty/4.184,\n )\n else:\n return '{0:9g} {1:9g} {2:9g} {3:9g} {4:9g} {5:9g} {6:9g} {7:9g} {8:9g} {9:9g} {10:9g} {11:9g}'.format(\n data.getEnthalpy(298)/4184.,\n data.getEntropy(298)/4.184,\n data.getHeatCapacity(300)/4.184,\n data.getHeatCapacity(400)/4.184,\n data.getHeatCapacity(500)/4.184,\n data.getHeatCapacity(600)/4.184,\n data.getHeatCapacity(800)/4.184,\n data.getHeatCapacity(1000)/4.184,\n data.getHeatCapacity(1500)/4.184,\n 0,\n 0,\n 0,\n )\n\ndef processOldLibraryEntry(data):\n \"\"\"\n Process a list of parameters `data` as read from an old-style RMG\n thermo database, returning the corresponding thermodynamics object.\n \"\"\"\n return ThermoData(\n Tdata = ([300,400,500,600,800,1000,1500],\"K\"),\n Cpdata = ([float(d) for d in data[2:9]],\"cal/(mol*K)\",\"+|-\",float(data[11])),\n H298 = (float(data[0]),\"kcal/mol\",\"+|-\",float(data[9])),\n S298 = (float(data[1]),\"cal/(mol*K)\",\"+|-\",float(data[10])),\n )\n\n\n################################################################################\n\nclass ThermoDepository(Database):\n \"\"\"\n A class for working with the RMG thermodynamics depository.\n \"\"\"\n\n def __init__(self, label='', name='', shortDesc='', longDesc=''):\n Database.__init__(self, label=label, name=name, shortDesc=shortDesc, longDesc=longDesc)\n\n def loadEntry(self, index, label, molecule, thermo, reference=None, referenceType='', shortDesc='', longDesc='', history=None):\n self.entries[label] = Entry(\n index = index,\n label = label,\n item = Molecule().fromAdjacencyList(molecule),\n data = thermo,\n reference = reference,\n referenceType = referenceType,\n shortDesc = shortDesc,\n longDesc = longDesc.strip(),\n history = history or [],\n )\n\n def saveEntry(self, f, entry):\n \"\"\"\n Write the given `entry` in the thermo database to the file object `f`.\n \"\"\"\n return saveEntry(f, entry)\n\n################################################################################\n\nclass ThermoLibrary(Database):\n \"\"\"\n A class for working with a RMG thermodynamics library.\n \"\"\"\n\n def __init__(self, label='', name='', shortDesc='', longDesc=''):\n Database.__init__(self, label=label, name=name, shortDesc=shortDesc, longDesc=longDesc)\n\n def loadEntry(self,\n index,\n label,\n molecule,\n thermo,\n reference=None,\n referenceType='',\n shortDesc='',\n longDesc='',\n history=None\n ):\n self.entries[label] = Entry(\n index = index,\n label = label,\n item = Molecule().fromAdjacencyList(molecule),\n data = thermo,\n reference = reference,\n referenceType = referenceType,\n shortDesc = shortDesc,\n longDesc = longDesc.strip(),\n history = history or [],\n )\n\n def saveEntry(self, f, entry):\n \"\"\"\n Write the given `entry` in the thermo database to the file object `f`.\n \"\"\"\n return saveEntry(f, entry)\n\n def generateOldLibraryEntry(self, data):\n \"\"\"\n Return a list of values used to save entries to the old-style RMG\n thermo database based on the thermodynamics object `data`.\n \"\"\"\n return generateOldLibraryEntry(data)\n\n def processOldLibraryEntry(self, data):\n \"\"\"\n Process a list of parameters `data` as read from an old-style RMG\n thermo database, returning the corresponding thermodynamics object.\n \"\"\"\n return processOldLibraryEntry(data)\n\n################################################################################\n\nclass ThermoGroups(Database):\n \"\"\"\n A class for working with an RMG thermodynamics group additivity database.\n \"\"\"\n\n def __init__(self, label='', name='', shortDesc='', longDesc=''):\n Database.__init__(self, label=label, name=name, shortDesc=shortDesc, longDesc=longDesc)\n\n def loadEntry(self,\n index,\n label,\n group,\n thermo,\n reference=None,\n referenceType='',\n shortDesc='',\n longDesc='',\n history=None\n ):\n if group[0:3].upper() == 'OR{' or group[0:4].upper() == 'AND{' or group[0:7].upper() == 'NOT OR{' or group[0:8].upper() == 'NOT AND{':\n item = makeLogicNode(group)\n else:\n item = Group().fromAdjacencyList(group)\n self.entries[label] = Entry(\n index = index,\n label = label,\n item = item,\n data = thermo,\n reference = reference,\n referenceType = referenceType,\n shortDesc = shortDesc,\n longDesc = longDesc.strip(),\n history = history or [],\n )\n \n def saveEntry(self, f, entry):\n \"\"\"\n Write the given `entry` in the thermo database to the file object `f`.\n \"\"\"\n return saveEntry(f, entry)\n\n def generateOldLibraryEntry(self, data):\n \"\"\"\n Return a list of values used to save entries to the old-style RMG\n thermo database based on the thermodynamics object `data`.\n \"\"\"\n return generateOldLibraryEntry(data)\n\n def processOldLibraryEntry(self, data):\n \"\"\"\n Process a list of parameters `data` as read from an old-style RMG\n thermo database, returning the corresponding thermodynamics object.\n \"\"\"\n return processOldLibraryEntry(data)\n\n################################################################################\n\nclass ThermoDatabase:\n \"\"\"\n A class for working with the RMG thermodynamics database.\n \"\"\"\n\n def __init__(self):\n self.depository = {}\n self.libraries = {}\n self.groups = {}\n self.libraryOrder = []\n self.local_context = {\n 'ThermoData': ThermoData,\n 'Wilhoit': Wilhoit,\n 'NASA': NASA,\n 'MultiNASA': MultiNASA,\n }\n self.global_context = {}\n\n def load(self, path, libraries=None, depository=True):\n \"\"\"\n Load the thermo database from the given `path` on disk, where `path`\n points to the top-level folder of the thermo database.\n \"\"\"\n if depository:\n self.loadDepository(os.path.join(path, 'depository'))\n else:\n self.depository = {}\n self.loadLibraries(os.path.join(path, 'libraries'), libraries)\n self.loadGroups(os.path.join(path, 'groups'))\n \n def loadDepository(self, path):\n \"\"\"\n Load the thermo database from the given `path` on disk, where `path`\n points to the top-level folder of the thermo database.\n \"\"\"\n self.depository = {}\n self.depository['stable'] = ThermoDepository().load(os.path.join(path, 'stable.py'), self.local_context, self.global_context)\n self.depository['radical'] = ThermoDepository().load(os.path.join(path, 'radical.py'), self.local_context, self.global_context)\n\n def loadLibraries(self, path, libraries=None):\n \"\"\"\n Load the thermo database from the given `path` on disk, where `path`\n points to the top-level folder of the thermo database.\n \"\"\"\n self.libraries = {}; self.libraryOrder = []\n for (root, dirs, files) in os.walk(os.path.join(path)):\n for f in files:\n name, ext = os.path.splitext(f)\n if ext.lower() == '.py' and (libraries is None or name in libraries):\n logging.info('Loading thermodynamics library from {0} in {1}...'.format(f, root))\n library = ThermoLibrary()\n library.load(os.path.join(root, f), self.local_context, self.global_context)\n library.label = os.path.splitext(f)[0]\n self.libraries[library.label] = library\n self.libraryOrder.append(library.label)\n if libraries is not None:\n self.libraryOrder = libraries\n\n def loadGroups(self, path):\n \"\"\"\n Load the thermo database from the given `path` on disk, where `path`\n points to the top-level folder of the thermo database.\n \"\"\"\n logging.info('Loading thermodynamics group database from {0}...'.format(path))\n self.groups = {}\n self.groups['group'] = ThermoGroups(label='group').load(os.path.join(path, 'group.py' ), self.local_context, self.global_context)\n self.groups['gauche'] = ThermoGroups(label='gauche').load(os.path.join(path, 'gauche.py' ), self.local_context, self.global_context)\n self.groups['int15'] = ThermoGroups(label='int15').load(os.path.join(path, 'int15.py' ), self.local_context, self.global_context)\n self.groups['ring'] = ThermoGroups(label='ring').load(os.path.join(path, 'ring.py' ), self.local_context, self.global_context)\n self.groups['radical'] = ThermoGroups(label='radical').load(os.path.join(path, 'radical.py'), self.local_context, self.global_context)\n self.groups['other'] = ThermoGroups(label='other').load(os.path.join(path, 'other.py' ), self.local_context, self.global_context)\n\n def save(self, path):\n \"\"\"\n Save the thermo database to the given `path` on disk, where `path`\n points to the top-level folder of the thermo database.\n \"\"\"\n path = os.path.abspath(path)\n if not os.path.exists(path): os.mkdir(path)\n self.saveDepository(os.path.join(path, 'depository'))\n self.saveLibraries(os.path.join(path, 'libraries'))\n self.saveGroups(os.path.join(path, 'groups'))\n\n def saveDepository(self, path):\n \"\"\"\n Save the thermo depository to the given `path` on disk, where `path`\n points to the top-level folder of the thermo depository.\n \"\"\"\n if not os.path.exists(path): os.mkdir(path)\n self.depository['stable'].save(os.path.join(path, 'stable.py'))\n self.depository['radical'].save(os.path.join(path, 'radical.py'))\n\n def saveLibraries(self, path):\n \"\"\"\n Save the thermo libraries to the given `path` on disk, where `path`\n points to the top-level folder of the thermo libraries.\n \"\"\"\n if not os.path.exists(path): os.mkdir(path)\n for library in self.libraries.values():\n library.save(os.path.join(path, '{0}.py'.format(library.label)))\n\n def saveGroups(self, path):\n \"\"\"\n Save the thermo groups to the given `path` on disk, where `path`\n points to the top-level folder of the thermo groups.\n \"\"\"\n if not os.path.exists(path): os.mkdir(path)\n self.groups['group'].save(os.path.join(path, 'group.py'))\n self.groups['gauche'].save(os.path.join(path, 'gauche.py'))\n self.groups['int15'].save(os.path.join(path, 'int15.py'))\n self.groups['ring'].save(os.path.join(path, 'ring.py'))\n self.groups['radical'].save(os.path.join(path, 'radical.py'))\n self.groups['other'].save(os.path.join(path, 'other.py'))\n\n def loadOld(self, path):\n \"\"\"\n Load the old RMG thermo database from the given `path` on disk, where\n `path` points to the top-level folder of the old RMG database.\n \"\"\"\n # The old database does not have a depository, so create an empty one\n self.depository = {}\n self.depository['stable'] = ThermoDepository(label='stable', name='Stable Molecules')\n self.depository['radical'] = ThermoDepository(label='radical', name='Radical Molecules')\n \n for (root, dirs, files) in os.walk(os.path.join(path, 'thermo_libraries')):\n if os.path.exists(os.path.join(root, 'Dictionary.txt')) and os.path.exists(os.path.join(root, 'Library.txt')):\n library = ThermoLibrary(label=os.path.basename(root), name=os.path.basename(root))\n library.loadOld(\n dictstr = os.path.join(root, 'Dictionary.txt'),\n treestr = '',\n libstr = os.path.join(root, 'Library.txt'),\n numParameters = 12,\n numLabels = 1,\n pattern = False,\n )\n library.label = os.path.basename(root)\n self.libraries[library.label] = library\n\n self.groups = {}\n self.groups['group'] = ThermoGroups(label='group', name='Functional Group Additivity Values').loadOld(\n dictstr = os.path.join(path, 'thermo_groups', 'Group_Dictionary.txt'),\n treestr = os.path.join(path, 'thermo_groups', 'Group_Tree.txt'),\n libstr = os.path.join(path, 'thermo_groups', 'Group_Library.txt'),\n numParameters = 12,\n numLabels = 1,\n pattern = True,\n )\n self.groups['gauche'] = ThermoGroups(label='gauche', name='Gauche Interaction Corrections').loadOld(\n dictstr = os.path.join(path, 'thermo_groups', 'Gauche_Dictionary.txt'),\n treestr = os.path.join(path, 'thermo_groups', 'Gauche_Tree.txt'),\n libstr = os.path.join(path, 'thermo_groups', 'Gauche_Library.txt'),\n numParameters = 12,\n numLabels = 1,\n pattern = True,\n )\n self.groups['int15'] = ThermoGroups(label='int15', name='1,5-Interaction Corrections').loadOld(\n dictstr = os.path.join(path, 'thermo_groups', '15_Dictionary.txt'),\n treestr = os.path.join(path, 'thermo_groups', '15_Tree.txt'),\n libstr = os.path.join(path, 'thermo_groups', '15_Library.txt'),\n numParameters = 12,\n numLabels = 1,\n pattern = True,\n )\n self.groups['radical'] = ThermoGroups(label='radical', name='Radical Corrections').loadOld(\n dictstr = os.path.join(path, 'thermo_groups', 'Radical_Dictionary.txt'),\n treestr = os.path.join(path, 'thermo_groups', 'Radical_Tree.txt'),\n libstr = os.path.join(path, 'thermo_groups', 'Radical_Library.txt'),\n numParameters = 12,\n numLabels = 1,\n pattern = True,\n )\n self.groups['ring'] = ThermoGroups(label='ring', name='Ring Corrections').loadOld(\n dictstr = os.path.join(path, 'thermo_groups', 'Ring_Dictionary.txt'),\n treestr = os.path.join(path, 'thermo_groups', 'Ring_Tree.txt'),\n libstr = os.path.join(path, 'thermo_groups', 'Ring_Library.txt'),\n numParameters = 12,\n numLabels = 1,\n pattern = True,\n )\n self.groups['other'] = ThermoGroups(label='other', name='Other Corrections').loadOld(\n dictstr = os.path.join(path, 'thermo_groups', 'Other_Dictionary.txt'),\n treestr = os.path.join(path, 'thermo_groups', 'Other_Tree.txt'),\n libstr = os.path.join(path, 'thermo_groups', 'Other_Library.txt'),\n numParameters = 12,\n numLabels = 1,\n pattern = True,\n )\n\n def saveOld(self, path):\n \"\"\"\n Save the old RMG thermo database to the given `path` on disk, where\n `path` points to the top-level folder of the old RMG database.\n \"\"\"\n\n # Depository not used in old database, so it is not saved\n\n librariesPath = os.path.join(path, 'thermo_libraries')\n if not os.path.exists(librariesPath): os.mkdir(librariesPath)\n for library in self.libraries.values():\n libraryPath = os.path.join(librariesPath, library.label)\n if not os.path.exists(libraryPath): os.mkdir(libraryPath)\n library.saveOld(\n dictstr = os.path.join(libraryPath, 'Dictionary.txt'),\n treestr = '',\n libstr = os.path.join(libraryPath, 'Library.txt'),\n )\n\n groupsPath = os.path.join(path, 'thermo_groups')\n if not os.path.exists(groupsPath): os.mkdir(groupsPath)\n self.groups['group'].saveOld(\n dictstr = os.path.join(groupsPath, 'Group_Dictionary.txt'),\n treestr = os.path.join(groupsPath, 'Group_Tree.txt'),\n libstr = os.path.join(groupsPath, 'Group_Library.txt'),\n )\n self.groups['gauche'].saveOld(\n dictstr = os.path.join(groupsPath, 'Gauche_Dictionary.txt'),\n treestr = os.path.join(groupsPath, 'Gauche_Tree.txt'),\n libstr = os.path.join(groupsPath, 'Gauche_Library.txt'),\n )\n self.groups['int15'].saveOld(\n dictstr = os.path.join(groupsPath, '15_Dictionary.txt'),\n treestr = os.path.join(groupsPath, '15_Tree.txt'),\n libstr = os.path.join(groupsPath, '15_Library.txt'),\n )\n self.groups['radical'].saveOld(\n dictstr = os.path.join(groupsPath, 'Radical_Dictionary.txt'),\n treestr = os.path.join(groupsPath, 'Radical_Tree.txt'),\n libstr = os.path.join(groupsPath, 'Radical_Library.txt'),\n )\n self.groups['ring'].saveOld(\n dictstr = os.path.join(groupsPath, 'Ring_Dictionary.txt'),\n treestr = os.path.join(groupsPath, 'Ring_Tree.txt'),\n libstr = os.path.join(groupsPath, 'Ring_Library.txt'),\n )\n self.groups['other'].saveOld(\n dictstr = os.path.join(groupsPath, 'Other_Dictionary.txt'),\n treestr = os.path.join(groupsPath, 'Other_Tree.txt'),\n libstr = os.path.join(groupsPath, 'Other_Library.txt'),\n )\n\n def getThermoData(self, species):\n \"\"\"\n Return the thermodynamic parameters for a given :class:`Species`\n object `species`. This function first searches the loaded libraries\n in order, returning the first match found, before falling back to\n estimation via group additivity.\n \"\"\"\n thermoData = None\n # Check the libraries in order first; return the first successful match\n for label in self.libraryOrder:\n thermoData = self.getThermoDataFromLibrary(species, self.libraries[label])\n if thermoData is not None: break\n else:\n # Thermo not found in any loaded libraries, so estimate\n thermoData = self.getThermoDataFromGroups(species)\n return thermoData[0]\n\n def getAllThermoData(self, species):\n \"\"\"\n Return all possible sets of thermodynamic parameters for a given\n :class:`Species` object `species`. The hits from the depository come\n first, then the libraries (in order), and then the group additivity\n estimate. This method is useful for a generic search job.\n \"\"\"\n thermoData = []\n # Data from depository comes first\n thermoData.extend(self.getThermoDataFromDepository(species))\n # Data from libraries comes second\n for label in self.libraryOrder:\n data = self.getThermoDataFromLibrary(species, self.libraries[label])\n if data: \n thermoData.append(data)\n # Last entry is always the estimate from group additivity\n thermoData.append(self.getThermoDataFromGroups(species))\n return thermoData\n\n def getThermoDataFromDepository(self, species):\n \"\"\"\n Return all possible sets of thermodynamic parameters for a given\n :class:`Species` object `species` from the depository. If no\n depository is loaded, a :class:`DatabaseError` is raised.\n \"\"\"\n items = []\n for label, entry in self.depository['stable'].entries.iteritems():\n for molecule in species.molecule:\n if molecule.isIsomorphic(entry.item):\n items.append((deepcopy(entry.data), self.depository['stable'], entry))\n break\n for label, entry in self.depository['radical'].entries.iteritems():\n for molecule in species.molecule:\n if molecule.isIsomorphic(entry.item):\n items.append((deepcopy(entry.data), self.depository['radical'], entry))\n break\n return items\n\n def getThermoDataFromLibrary(self, species, library):\n \"\"\"\n Return the set of thermodynamic parameters corresponding to a given\n :class:`Species` object `species` from the specified thermodynamics\n `library`. If `library` is a string, the list of libraries is searched\n for a library with that name. If no match is found in that library,\n ``None`` is returned. If no corresponding library is found, a\n :class:`DatabaseError` is raised.\n \"\"\"\n for label, entry in library.entries.iteritems():\n for molecule in species.molecule:\n if molecule.isIsomorphic(entry.item) and entry.data is not None:\n return (deepcopy(entry.data), library, entry)\n return None\n\n def getThermoDataFromGroups(self, species):\n \"\"\"\n Return the set of thermodynamic parameters corresponding to a given\n :class:`Species` object `species` by estimation using the group\n additivity values. If no group additivity values are loaded, a\n :class:`DatabaseError` is raised.\n \"\"\" \n thermo = []\n for molecule in species.molecule:\n molecule.clearLabeledAtoms()\n molecule.updateAtomTypes()\n tdata = self.estimateThermoViaGroupAdditivity(molecule)\n thermo.append(tdata)\n\n H298 = numpy.array([t.getEnthalpy(298.) for t in thermo])\n indices = H298.argsort()\n \n species.molecule = [species.molecule[ind] for ind in indices]\n \n return (thermo[indices[0]], None, None)\n \n def estimateThermoViaGroupAdditivity(self, molecule):\n \"\"\"\n Return the set of thermodynamic parameters corresponding to a given\n :class:`Molecule` object `molecule` by estimation using the group\n additivity values. If no group additivity values are loaded, a\n :class:`DatabaseError` is raised.\n \"\"\"\n # For thermo estimation we need the atoms to already be sorted because we\n # iterate over them; if the order changes during the iteration then we\n # will probably not visit the right atoms, and so will get the thermo wrong\n molecule.sortVertices()\n\n thermoData = None\n\n if sum([atom.radicalElectrons for atom in molecule.atoms]) > 0: # radical species\n\n # Make a copy of the structure so we don't change the original\n saturatedStruct = molecule.copy(deep=True)\n\n # Saturate structure by replacing all radicals with bonds to\n # hydrogen atoms\n added = {}\n for atom in saturatedStruct.atoms:\n for i in range(atom.radicalElectrons):\n H = Atom('H')\n bond = Bond(atom, H, 'S')\n saturatedStruct.addAtom(H)\n saturatedStruct.addBond(bond)\n if atom not in added:\n added[atom] = []\n added[atom].append([H, bond])\n atom.decrementRadical()\n\n # Update the atom types of the saturated structure (not sure why\n # this is necessary, because saturating with H shouldn't be\n # changing atom types, but it doesn't hurt anything and is not\n # very expensive, so will do it anyway)\n saturatedStruct.updateConnectivityValues()\n saturatedStruct.sortVertices()\n saturatedStruct.updateAtomTypes()\n\n # Get thermo estimate for saturated form of structure\n thermoData = self.estimateThermoViaGroupAdditivity(saturatedStruct)\n assert thermoData is not None, \"Thermo data of saturated {0} of molecule {1} is None!\".format(saturatedStruct, molecule)\n # Undo symmetry number correction for saturated structure\n thermoData.S298.value += constants.R * math.log(saturatedStruct.symmetryNumber)\n\n # For each radical site, get radical correction\n # Only one radical site should be considered at a time; all others\n # should be saturated with hydrogen atoms\n for atom in added:\n\n # Remove the added hydrogen atoms and bond and restore the radical\n for H, bond in added[atom]:\n saturatedStruct.removeBond(bond)\n saturatedStruct.removeAtom(H)\n atom.incrementRadical()\n\n saturatedStruct.updateConnectivityValues()\n \n try:\n thermoData = self.__addThermoData(thermoData, self.__getGroupThermoData(self.groups['radical'], saturatedStruct, {'*':atom}))\n except KeyError:\n logging.error(\"Couldn't find in radical thermo database:\")\n logging.error(molecule)\n logging.error(molecule.toAdjacencyList())\n raise\n \n # Re-saturate\n for H, bond in added[atom]:\n saturatedStruct.addAtom(H)\n saturatedStruct.addBond(bond)\n atom.decrementRadical()\n\n # Subtract the enthalpy of the added hydrogens\n for H, bond in added[atom]:\n thermoData.H298.value -= 52.103 * 4184\n\n # Correct the entropy for the symmetry number\n\n else: # non-radical species\n # Generate estimate of thermodynamics\n for atom in molecule.atoms:\n # Iterate over heavy (non-hydrogen) atoms\n if atom.isNonHydrogen():\n # Get initial thermo estimate from main group database\n try:\n if thermoData is None:\n thermoData = self.__getGroupThermoData(self.groups['group'], molecule, {'*':atom})\n else:\n thermoData = self.__addThermoData(thermoData, self.__getGroupThermoData(self.groups['group'], molecule, {'*':atom}))\n except KeyError:\n logging.error(\"Couldn't find in main thermo database:\")\n logging.error(molecule)\n logging.error(molecule.toAdjacencyList())\n raise\n # Correct for gauche and 1,5- interactions\n try:\n thermoData = self.__addThermoData(thermoData, self.__getGroupThermoData(self.groups['gauche'], molecule, {'*':atom}))\n except KeyError: pass\n try:\n thermoData = self.__addThermoData(thermoData, self.__getGroupThermoData(self.groups['int15'], molecule, {'*':atom}))\n except KeyError: pass\n try:\n thermoData = self.__addThermoData(thermoData, self.__getGroupThermoData(self.groups['other'], molecule, {'*':atom}))\n except KeyError: pass\n\n # Do ring corrections separately because we only want to match\n # each ring one time; this doesn't work yet\n rings = molecule.getSmallestSetOfSmallestRings()\n for ring in rings:\n # Make a temporary structure containing only the atoms in the ring\n # NB. if any of the ring corrections depend on ligands not in the ring, they will not be found!\n ringStructure = Molecule()\n newAtoms = dict()\n for atom in ring:\n newAtoms[atom] = atom.copy()\n ringStructure.addAtom(newAtoms[atom]) # (addAtom deletes the atom's bonds)\n for atom1 in ring:\n for atom2 in ring:\n if molecule.hasBond(atom1, atom2):\n ringStructure.addBond(Bond(newAtoms[atom1], newAtoms[atom2], atom1.bonds[atom2].order ))\n\n # Get thermo correction for this ring\n try:\n thermoData = self.__addThermoData(thermoData, self.__getGroupThermoData(self.groups['ring'], ringStructure, {}))\n except KeyError:\n logging.error(\"Couldn't find in ring database:\")\n logging.error(ringStructure)\n logging.error(ringStructure.toAdjacencyList())\n raise\n \n # Correct entropy for symmetry number\n molecule.calculateSymmetryNumber()\n thermoData.S298.value -= constants.R * math.log(molecule.symmetryNumber)\n\n return thermoData\n\n def __addThermoData(self, thermoData1, thermoData2):\n \"\"\"\n Add two :class:`ThermoData` objects `thermoData1` and `thermoData2`\n together, returning their sum as a new :class:`ThermoData` object.\n \"\"\"\n if len(thermoData1.Tdata.values) != len(thermoData2.Tdata.values) or any([T1 != T2 for T1, T2 in zip(thermoData1.Tdata.values, thermoData2.Tdata.values)]):\n raise ThermoError('Cannot add these ThermoData objects due to their having different temperature points.')\n new = ThermoData(\n Tdata = (thermoData1.Tdata.values, thermoData1.Tdata.units),\n Cpdata = (thermoData1.Cpdata.values + thermoData2.Cpdata.values, thermoData1.Tdata.units),\n H298 = (thermoData1.H298.value + thermoData2.H298.value, thermoData1.Tdata.units),\n S298 = (thermoData1.S298.value + thermoData2.S298.value, thermoData1.Tdata.units),\n )\n if thermoData1.comment == '': new.comment = thermoData2.comment\n elif thermoData2.comment == '': new.comment = thermoData1.comment\n else: new.comment = thermoData1.comment + ' + ' + thermoData2.comment\n return new\n \n def __getGroupThermoData(self, database, molecule, atom):\n \"\"\"\n Determine the group additivity thermodynamic data for the atom `atom`\n in the structure `structure`.\n \"\"\"\n\n node0 = database.descendTree(molecule, atom, None)\n\n if node0 is None:\n raise KeyError('Node not found in database.')\n\n # It's possible (and allowed) that items in the tree may not be in the\n # library, in which case we need to fall up the tree until we find an\n # ancestor that has an entry in the library\n node = node0\n while node.data is None and node is not None:\n node = node.parent\n if node is None:\n raise InvalidDatabaseError('Unable to determine thermo parameters for {0}: no library entries for {1} or any of its ancestors.'.format(molecule, node0) )\n\n data = node.data; comment = node.label\n while isinstance(data, str) and data is not None:\n for entry in database.entries.values():\n if entry.label == data:\n data = entry.data\n comment = entry.label\n break\n data = deepcopy(data)\n data.comment = '{0}({1})'.format(database.label, comment)\n\n # This code prints the hierarchy of the found node; useful for debugging\n #result = ''\n #while node is not None:\n # result = ' -> ' + node + result\n # node = database.tree.parent[node]\n #print result[4:]\n\n return data\n", "meta": {"hexsha": "cd066bbd73ee983f296e4802479c73b7f8688f99", "size": 37592, "ext": "py", "lang": "Python", "max_stars_repo_path": "rmgpy/data/thermo.py", "max_stars_repo_name": "sean-v8/RMG-Py", "max_stars_repo_head_hexsha": "7cc7c3bfb330786526c56113d98c785bcaaa161a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "rmgpy/data/thermo.py", "max_issues_repo_name": "sean-v8/RMG-Py", "max_issues_repo_head_hexsha": "7cc7c3bfb330786526c56113d98c785bcaaa161a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "rmgpy/data/thermo.py", "max_forks_repo_name": "sean-v8/RMG-Py", "max_forks_repo_head_hexsha": "7cc7c3bfb330786526c56113d98c785bcaaa161a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.8591885442, "max_line_length": 165, "alphanum_fraction": 0.5769046606, "include": true, "reason": "import numpy", "num_tokens": 8456, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5039061705290805, "lm_q2_score": 0.3775406547908327, "lm_q1q2_score": 0.19024506557469006}} {"text": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\nimport os\nimport functools\nimport numpy as np\nimport pycuda.driver as cuda\nfrom graphdot.cuda.array import umempty, umzeros\nfrom graphdot.codegen import Template\nfrom graphdot.codegen.cpptool import decltype\nfrom graphdot.microkernel import TensorProduct, Product\nfrom graphdot.kernel.marginalized._backend_cuda import CUDABackend\nfrom graphdot.kernel.marginalized._octilegraph import OctileGraph\n\n\nclass AltCUDABackend(CUDABackend):\n\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n\n def allocate_pcg_scratch(self, number, max_graph_size, traits):\n length = max_graph_size**2\n n_temporaries = 5\n\n self.scratch_pcg, self.scratch_pcg_d = self._allocate_scratch(\n self.scratch_pcg, self.scratch_pcg_d, number, length,\n n_temporaries\n )\n return self.scratch_pcg_d\n\n @property\n @functools.lru_cache(maxsize=1)\n def template(self):\n return Template(os.path.join(os.path.dirname(__file__), 'template.cu'))\n\n def __call__(self, graphs, node_kernel, edge_kernel, p, q, eps, ftol, gtol,\n jobs, gramian, traits, timer):\n ''' transfer graphs and starting probabilities to GPU '''\n timer.tic('transferring graphs to GPU')\n\n og_last = None\n graphs_d = umempty(len(graphs), dtype=OctileGraph.dtype)\n for i, g in enumerate(graphs):\n og, ogstate = self._register_graph(g)\n if i > 0:\n self._assert_homogeneous(og_last, og)\n og_last = og\n graphs_d[i] = ogstate\n\n weighted = og_last.weighted\n node_t = og_last.node_t\n edge_t = og_last.edge_t\n\n timer.toc('transferring graphs to GPU')\n\n ''' allocate global job counter '''\n timer.tic('allocate global job counter')\n i_job_global = umzeros(1, np.uint32)\n timer.toc('allocate global job counter')\n\n ''' code generation '''\n timer.tic('code generation')\n if weighted:\n edge_kernel = TensorProduct(weight=Product(),\n label=edge_kernel)\n\n node_kernel_src = self.gencode_kernel(node_kernel, 'node_kernel')\n edge_kernel_src = self.gencode_kernel(edge_kernel, 'edge_kernel')\n p_start_src = self.gencode_probability(p, 'p_start')\n\n with self.template.context(traits=traits) as template:\n self.source = template.render(\n node_kernel=node_kernel_src,\n edge_kernel=edge_kernel_src,\n p_start=p_start_src,\n node_t=decltype(node_t),\n edge_t=decltype(edge_t)\n )\n timer.toc('code generation')\n\n ''' JIT '''\n timer.tic('JIT')\n kernel = self.module.get_function('alt_graph_kernel_solver')\n timer.toc('JIT')\n\n ''' calculate launch configuration '''\n timer.tic('calculating launch configuration')\n launch_block_count = (self.device.MULTIPROCESSOR_COUNT\n * self.block_per_sm)\n shmem_bytes_per_warp = self.module.get_global(\n 'shmem_bytes_per_warp'\n )[1]\n shmem_bytes_per_block = (shmem_bytes_per_warp * self.block_size\n // self.device.WARP_SIZE)\n\n ''' allocate scratch buffers '''\n max_graph_size = np.max([len(g.nodes) for g in graphs])\n scratch_pcg = self.allocate_pcg_scratch(\n launch_block_count, max_graph_size, traits\n )\n\n ''' copy micro kernel parameters to GPU '''\n for name, uker in [('node_kernel', node_kernel),\n ('edge_kernel', edge_kernel)]:\n states = np.array(\n self.pack_state(uker, diff_grid=False, diff_eps=eps),\n dtype=uker.dtype\n )\n\n p_uker, _ = self.module.get_global(name)\n cuda.memcpy_htod(p_uker, states[:1])\n\n p_p_start, _ = self.module.get_global('p_start')\n cuda.memcpy_htod(\n p_p_start, np.array([p.state], dtype=p.dtype)\n )\n\n timer.toc('calculating launch configuration')\n\n ''' GPU kernel execution '''\n timer.tic('GPU kernel execution')\n kernel(\n graphs_d,\n scratch_pcg,\n jobs,\n gramian,\n i_job_global,\n np.uint32(len(jobs)),\n np.float32(q),\n np.float32(q), # placeholder for q0\n np.float32(eps),\n np.float32(ftol),\n np.float32(gtol),\n grid=(launch_block_count, 1, 1),\n block=(self.block_size, 1, 1),\n shared=shmem_bytes_per_block,\n )\n self.ctx.synchronize()\n timer.toc('GPU kernel execution')\n", "meta": {"hexsha": "49860676656b2ac7bd18434bb789f2d0cfb04757", "size": 4777, "ext": "py", "lang": "Python", "max_stars_repo_path": "graphdot/experimental/alterantive_mgk/_backend_cuda.py", "max_stars_repo_name": "yhtang/GraphDot", "max_stars_repo_head_hexsha": "3d5ed4fbb2f6912052baa42780b436da76979691", "max_stars_repo_licenses": ["BSD-3-Clause-LBNL"], "max_stars_count": 9, "max_stars_repo_stars_event_min_datetime": "2020-02-14T18:07:39.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-15T12:07:31.000Z", "max_issues_repo_path": "graphdot/experimental/alterantive_mgk/_backend_cuda.py", "max_issues_repo_name": "yhtang/graphdot", "max_issues_repo_head_hexsha": "3d5ed4fbb2f6912052baa42780b436da76979691", "max_issues_repo_licenses": ["BSD-3-Clause-LBNL"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2020-03-19T19:07:26.000Z", "max_issues_repo_issues_event_max_datetime": "2021-02-24T06:08:51.000Z", "max_forks_repo_path": "graphdot/experimental/alterantive_mgk/_backend_cuda.py", "max_forks_repo_name": "yhtang/graphdot", "max_forks_repo_head_hexsha": "3d5ed4fbb2f6912052baa42780b436da76979691", "max_forks_repo_licenses": ["BSD-3-Clause-LBNL"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2019-10-17T06:11:18.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-07T11:56:33.000Z", "avg_line_length": 34.3669064748, "max_line_length": 79, "alphanum_fraction": 0.5978647687, "include": true, "reason": "import numpy,import pycuda", "num_tokens": 1086, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6187804478040616, "lm_q2_score": 0.3073580232098525, "lm_q1q2_score": 0.19018713523796368}} {"text": "# Author: Alexandre Gramfort \n# Daniel Strohmeier \n#\n# License: Simplified BSD\n\nimport numpy as np\nfrom scipy import linalg\n\nfrom ..source_estimate import (SourceEstimate, VolSourceEstimate,\n _BaseSourceEstimate)\nfrom ..minimum_norm.inverse import (combine_xyz, _prepare_forward,\n _check_reference)\nfrom ..forward import is_fixed_orient\nfrom ..io.pick import pick_channels_evoked\nfrom ..io.proj import deactivate_proj\nfrom ..utils import logger, verbose, _check_depth\nfrom ..dipole import Dipole\n\nfrom .mxne_optim import (mixed_norm_solver, iterative_mixed_norm_solver, _Phi,\n norm_l2inf, tf_mixed_norm_solver, norm_epsilon_inf)\n\n\n@verbose\ndef _prepare_weights(forward, gain, source_weighting, weights, weights_min):\n mask = None\n if isinstance(weights, _BaseSourceEstimate):\n weights = np.max(np.abs(weights.data), axis=1)\n weights_max = np.max(weights)\n if weights_min > weights_max:\n raise ValueError('weights_min > weights_max (%s > %s)' %\n (weights_min, weights_max))\n weights_min = weights_min / weights_max\n weights = weights / weights_max\n n_dip_per_pos = 1 if is_fixed_orient(forward) else 3\n weights = np.ravel(np.tile(weights, [n_dip_per_pos, 1]).T)\n if len(weights) != gain.shape[1]:\n raise ValueError('weights do not have the correct dimension '\n ' (%d != %d)' % (len(weights), gain.shape[1]))\n if len(source_weighting.shape) == 1:\n source_weighting *= weights\n else:\n source_weighting *= weights[:, None]\n gain *= weights[None, :]\n\n if weights_min is not None:\n mask = (weights > weights_min)\n gain = gain[:, mask]\n n_sources = np.sum(mask) // n_dip_per_pos\n logger.info(\"Reducing source space to %d sources\" % n_sources)\n\n return gain, source_weighting, mask\n\n\ndef _prepare_gain(forward, info, noise_cov, pca, depth, loose, rank,\n weights=None, weights_min=None):\n depth = _check_depth(depth, 'depth_sparse')\n forward, gain_info, gain, _, _, source_weighting, _, _, whitener = \\\n _prepare_forward(forward, info, noise_cov, 'auto', loose, rank, pca,\n use_cps=True, **depth)\n\n if weights is None:\n mask = None\n else:\n gain, source_weighting, mask = _prepare_weights(\n forward, gain, source_weighting, weights, weights_min)\n\n return forward, gain, gain_info, whitener, source_weighting, mask\n\n\ndef _reapply_source_weighting(X, source_weighting, active_set):\n X *= source_weighting[active_set][:, None]\n return X\n\n\ndef _compute_residual(forward, evoked, X, active_set, info):\n # OK, picking based on row_names is safe\n sel = [forward['sol']['row_names'].index(c) for c in info['ch_names']]\n residual = evoked.copy()\n residual = pick_channels_evoked(residual, include=info['ch_names'])\n r_tmp = residual.copy()\n\n r_tmp.data = np.dot(forward['sol']['data'][sel, :][:, active_set], X)\n\n # Take care of proj\n active_projs = list()\n non_active_projs = list()\n for p in evoked.info['projs']:\n if p['active']:\n active_projs.append(p)\n else:\n non_active_projs.append(p)\n\n if len(active_projs) > 0:\n r_tmp.info['projs'] = deactivate_proj(active_projs, copy=True)\n r_tmp.apply_proj()\n r_tmp.add_proj(non_active_projs, remove_existing=False)\n\n residual.data -= r_tmp.data\n\n return residual\n\n\n@verbose\ndef _make_sparse_stc(X, active_set, forward, tmin, tstep,\n active_is_idx=False, verbose=None):\n if not is_fixed_orient(forward):\n logger.info('combining the current components...')\n X = combine_xyz(X)\n\n if not active_is_idx:\n active_idx = np.where(active_set)[0]\n else:\n active_idx = active_set\n\n n_dip_per_pos = 1 if is_fixed_orient(forward) else 3\n if n_dip_per_pos > 1:\n active_idx = np.unique(active_idx // n_dip_per_pos)\n\n src = forward['src']\n\n if src.kind != 'surface':\n vertices = src[0]['vertno'][active_idx]\n stc = VolSourceEstimate(X, vertices=vertices, tmin=tmin, tstep=tstep)\n else:\n vertices = []\n n_points_so_far = 0\n for this_src in src:\n this_n_points_so_far = n_points_so_far + len(this_src['vertno'])\n this_active_idx = active_idx[(n_points_so_far <= active_idx) &\n (active_idx < this_n_points_so_far)]\n this_active_idx -= n_points_so_far\n this_vertno = this_src['vertno'][this_active_idx]\n n_points_so_far = this_n_points_so_far\n vertices.append(this_vertno)\n\n stc = SourceEstimate(X, vertices=vertices, tmin=tmin, tstep=tstep)\n\n return stc\n\n\n@verbose\ndef _make_dipoles_sparse(X, active_set, forward, tmin, tstep, M, M_est,\n active_is_idx=False, verbose=None):\n times = tmin + tstep * np.arange(X.shape[1])\n\n if not active_is_idx:\n active_idx = np.where(active_set)[0]\n else:\n active_idx = active_set\n\n n_dip_per_pos = 1 if is_fixed_orient(forward) else 3\n if n_dip_per_pos > 1:\n active_idx = np.unique(active_idx // n_dip_per_pos)\n\n gof = np.zeros(M_est.shape[1])\n M_norm2 = np.sum(M ** 2, axis=0)\n R_norm2 = np.sum((M - M_est) ** 2, axis=0)\n gof[M_norm2 > 0.0] = 1. - R_norm2[M_norm2 > 0.0] / M_norm2[M_norm2 > 0.0]\n gof *= 100.\n\n dipoles = []\n for k, i_dip in enumerate(active_idx):\n i_pos = forward['source_rr'][i_dip][np.newaxis, :]\n i_pos = i_pos.repeat(len(times), axis=0)\n X_ = X[k * n_dip_per_pos: (k + 1) * n_dip_per_pos]\n if n_dip_per_pos == 1:\n amplitude = X_[0]\n i_ori = forward['source_nn'][i_dip][np.newaxis, :]\n i_ori = i_ori.repeat(len(times), axis=0)\n else:\n if forward['surf_ori']:\n X_ = np.dot(forward['source_nn'][\n i_dip * n_dip_per_pos:(i_dip + 1) * n_dip_per_pos].T, X_)\n\n amplitude = np.sqrt(np.sum(X_ ** 2, axis=0))\n i_ori = np.zeros((len(times), 3))\n i_ori[amplitude > 0.] = (X_[:, amplitude > 0.] /\n amplitude[amplitude > 0.]).T\n\n dipoles.append(Dipole(times, i_pos, amplitude, i_ori, gof))\n\n return dipoles\n\n\n@verbose\ndef make_stc_from_dipoles(dipoles, src, verbose=None):\n \"\"\"Convert a list of spatio-temporal dipoles into a SourceEstimate.\n\n Parameters\n ----------\n dipoles : Dipole | list of instances of Dipole\n The dipoles to convert.\n src : instance of SourceSpaces\n The source space used to generate the forward operator.\n %(verbose)s\n\n Returns\n -------\n stc : SourceEstimate\n The source estimate.\n \"\"\"\n logger.info('Converting dipoles into a SourceEstimate.')\n if isinstance(dipoles, Dipole):\n dipoles = [dipoles]\n if not isinstance(dipoles, list):\n raise ValueError('Dipoles must be an instance of Dipole or '\n 'a list of instances of Dipole. '\n 'Got %s!' % type(dipoles))\n tmin = dipoles[0].times[0]\n tstep = dipoles[0].times[1] - tmin\n X = np.zeros((len(dipoles), len(dipoles[0].times)))\n source_rr = np.concatenate([_src['rr'][_src['vertno'], :] for _src in src],\n axis=0)\n n_lh_points = len(src[0]['vertno'])\n lh_vertno = list()\n rh_vertno = list()\n for i in range(len(dipoles)):\n if not np.all(dipoles[i].pos == dipoles[i].pos[0]):\n raise ValueError('Only dipoles with fixed position over time '\n 'are supported!')\n X[i] = dipoles[i].amplitude\n idx = np.all(source_rr == dipoles[i].pos[0], axis=1)\n idx = np.where(idx)[0][0]\n if idx < n_lh_points:\n lh_vertno.append(src[0]['vertno'][idx])\n else:\n rh_vertno.append(src[1]['vertno'][idx - n_lh_points])\n vertices = [np.array(lh_vertno).astype(int),\n np.array(rh_vertno).astype(int)]\n stc = SourceEstimate(X, vertices=vertices, tmin=tmin, tstep=tstep,\n subject=src._subject)\n logger.info('[done]')\n return stc\n\n\n@verbose\ndef mixed_norm(evoked, forward, noise_cov, alpha, loose='auto', depth=0.8,\n maxit=3000, tol=1e-4, active_set_size=10,\n debias=True, time_pca=True, weights=None, weights_min=0.,\n solver='auto', n_mxne_iter=1, return_residual=False,\n return_as_dipoles=False, dgap_freq=10, rank=None,\n verbose=None):\n \"\"\"Mixed-norm estimate (MxNE) and iterative reweighted MxNE (irMxNE).\n\n Compute L1/L2 mixed-norm solution [1]_ or L0.5/L2 [2]_ mixed-norm\n solution on evoked data.\n\n Parameters\n ----------\n evoked : instance of Evoked or list of instances of Evoked\n Evoked data to invert.\n forward : dict\n Forward operator.\n noise_cov : instance of Covariance\n Noise covariance to compute whitener.\n alpha : float in range [0, 100)\n Regularization parameter. 0 means no regularization, 100 would give 0\n active dipole.\n loose : float in [0, 1] | 'auto'\n Value that weights the source variances of the dipole components\n that are parallel (tangential) to the cortical surface. If loose\n is 0 then the solution is computed with fixed orientation.\n If loose is 1, it corresponds to free orientations.\n The default value ('auto') is set to 0.2 for surface-oriented source\n space and set to 1.0 for volumic or discrete source space.\n %(depth)s\n maxit : int\n Maximum number of iterations.\n tol : float\n Tolerance parameter.\n active_set_size : int | None\n Size of active set increment. If None, no active set strategy is used.\n debias : bool\n Remove coefficient amplitude bias due to L1 penalty.\n time_pca : bool or int\n If True the rank of the concatenated epochs is reduced to\n its true dimension. If is 'int' the rank is limited to this value.\n weights : None | array | SourceEstimate\n Weight for penalty in mixed_norm. Can be None, a\n 1d array with shape (n_sources,), or a SourceEstimate (e.g. obtained\n with wMNE, dSPM, or fMRI).\n weights_min : float\n Do not consider in the estimation sources for which weights\n is less than weights_min.\n solver : 'prox' | 'cd' | 'bcd' | 'auto'\n The algorithm to use for the optimization. 'prox' stands for\n proximal iterations using the FISTA algorithm, 'cd' uses\n coordinate descent, and 'bcd' applies block coordinate descent.\n 'cd' is only available for fixed orientation.\n n_mxne_iter : int\n The number of MxNE iterations. If > 1, iterative reweighting\n is applied.\n return_residual : bool\n If True, the residual is returned as an Evoked instance.\n return_as_dipoles : bool\n If True, the sources are returned as a list of Dipole instances.\n dgap_freq : int or np.inf\n The duality gap is evaluated every dgap_freq iterations. Ignored if\n solver is 'cd'.\n %(rank_None)s\n\n .. versionadded:: 0.18\n %(verbose)s\n\n Returns\n -------\n stc : SourceEstimate | list of SourceEstimate\n Source time courses for each evoked data passed as input.\n residual : instance of Evoked\n The residual a.k.a. data not explained by the sources.\n Only returned if return_residual is True.\n\n See Also\n --------\n tf_mixed_norm\n\n References\n ----------\n .. [1] A. Gramfort, M. Kowalski, M. Hämäläinen,\n \"Mixed-norm estimates for the M/EEG inverse problem using accelerated\n gradient methods\", Physics in Medicine and Biology, 2012.\n https://doi.org/10.1088/0031-9155/57/7/1937\n\n .. [2] D. Strohmeier, Y. Bekhti, J. Haueisen, A. Gramfort,\n \"The Iterative Reweighted Mixed-Norm Estimate for Spatio-Temporal\n MEG/EEG Source Reconstruction\", IEEE Transactions of Medical Imaging,\n Volume 35 (10), pp. 2218-2228, 2016.\n \"\"\"\n if not (0. <= alpha < 100.):\n raise ValueError('alpha must be in [0, 100). '\n 'Got alpha = %s' % alpha)\n if n_mxne_iter < 1:\n raise ValueError('MxNE has to be computed at least 1 time. '\n 'Requires n_mxne_iter >= 1, got %d' % n_mxne_iter)\n if dgap_freq <= 0.:\n raise ValueError('dgap_freq must be a positive integer.'\n ' Got dgap_freq = %s' % dgap_freq)\n\n pca = True\n if not isinstance(evoked, list):\n evoked = [evoked]\n\n _check_reference(evoked[0])\n\n all_ch_names = evoked[0].ch_names\n if not all(all_ch_names == evoked[i].ch_names\n for i in range(1, len(evoked))):\n raise Exception('All the datasets must have the same good channels.')\n\n forward, gain, gain_info, whitener, source_weighting, mask = _prepare_gain(\n forward, evoked[0].info, noise_cov, pca, depth, loose, rank,\n weights, weights_min)\n\n sel = [all_ch_names.index(name) for name in gain_info['ch_names']]\n M = np.concatenate([e.data[sel] for e in evoked], axis=1)\n\n # Whiten data\n logger.info('Whitening data matrix.')\n M = np.dot(whitener, M)\n\n if time_pca:\n U, s, Vh = linalg.svd(M, full_matrices=False)\n if not isinstance(time_pca, bool) and isinstance(time_pca, int):\n U = U[:, :time_pca]\n s = s[:time_pca]\n Vh = Vh[:time_pca]\n M = U * s\n\n # Scaling to make setting of alpha easy\n n_dip_per_pos = 1 if is_fixed_orient(forward) else 3\n alpha_max = norm_l2inf(np.dot(gain.T, M), n_dip_per_pos, copy=False)\n alpha_max *= 0.01\n gain /= alpha_max\n source_weighting /= alpha_max\n\n if n_mxne_iter == 1:\n X, active_set, E = mixed_norm_solver(\n M, gain, alpha, maxit=maxit, tol=tol,\n active_set_size=active_set_size, n_orient=n_dip_per_pos,\n debias=debias, solver=solver, dgap_freq=dgap_freq, verbose=verbose)\n else:\n X, active_set, E = iterative_mixed_norm_solver(\n M, gain, alpha, n_mxne_iter, maxit=maxit, tol=tol,\n n_orient=n_dip_per_pos, active_set_size=active_set_size,\n debias=debias, solver=solver, dgap_freq=dgap_freq, verbose=verbose)\n\n if time_pca:\n X = np.dot(X, Vh)\n M = np.dot(M, Vh)\n\n # Compute estimated whitened sensor data\n M_estimated = np.dot(gain[:, active_set], X)\n\n if mask is not None:\n active_set_tmp = np.zeros(len(mask), dtype=np.bool)\n active_set_tmp[mask] = active_set\n active_set = active_set_tmp\n del active_set_tmp\n\n if active_set.sum() == 0:\n raise Exception(\"No active dipoles found. alpha is too big.\")\n\n # Reapply weights to have correct unit\n X = _reapply_source_weighting(X, source_weighting, active_set)\n\n outs = list()\n residual = list()\n cnt = 0\n for e in evoked:\n tmin = e.times[0]\n tstep = 1.0 / e.info['sfreq']\n Xe = X[:, cnt:(cnt + len(e.times))]\n if return_as_dipoles:\n out = _make_dipoles_sparse(\n Xe, active_set, forward, tmin, tstep,\n M[:, cnt:(cnt + len(e.times))],\n M_estimated[:, cnt:(cnt + len(e.times))], verbose=None)\n else:\n out = _make_sparse_stc(Xe, active_set, forward, tmin, tstep)\n outs.append(out)\n cnt += len(e.times)\n\n if return_residual:\n residual.append(_compute_residual(forward, e, Xe, active_set,\n gain_info))\n\n logger.info('[done]')\n\n if len(outs) == 1:\n out = outs[0]\n if return_residual:\n residual = residual[0]\n else:\n out = outs\n\n if return_residual:\n out = out, residual\n\n return out\n\n\ndef _window_evoked(evoked, size):\n \"\"\"Window evoked (size in seconds).\"\"\"\n if isinstance(size, (float, int)):\n lsize = rsize = float(size)\n else:\n lsize, rsize = size\n evoked = evoked.copy()\n sfreq = float(evoked.info['sfreq'])\n lsize = int(lsize * sfreq)\n rsize = int(rsize * sfreq)\n lhann = np.hanning(lsize * 2)[:lsize]\n rhann = np.hanning(rsize * 2)[-rsize:]\n window = np.r_[lhann, np.ones(len(evoked.times) - lsize - rsize), rhann]\n evoked.data *= window[None, :]\n return evoked\n\n\n@verbose\ndef tf_mixed_norm(evoked, forward, noise_cov,\n loose='auto', depth=0.8, maxit=3000,\n tol=1e-4, weights=None, weights_min=0., pca=True,\n debias=True, wsize=64, tstep=4, window=0.02,\n return_residual=False, return_as_dipoles=False,\n alpha=None, l1_ratio=None, dgap_freq=10, rank=None,\n verbose=None):\n \"\"\"Time-Frequency Mixed-norm estimate (TF-MxNE).\n\n Compute L1/L2 + L1 mixed-norm solution on time-frequency\n dictionary. Works with evoked data [1]_ [2]_.\n\n Parameters\n ----------\n evoked : instance of Evoked\n Evoked data to invert.\n forward : dict\n Forward operator.\n noise_cov : instance of Covariance\n Noise covariance to compute whitener.\n loose : float in [0, 1] | 'auto'\n Value that weights the source variances of the dipole components\n that are parallel (tangential) to the cortical surface. If loose\n is 0 then the solution is computed with fixed orientation.\n If loose is 1, it corresponds to free orientations.\n The default value ('auto') is set to 0.2 for surface-oriented source\n space and set to 1.0 for volumic or discrete source space.\n %(depth)s\n maxit : int\n Maximum number of iterations.\n tol : float\n Tolerance parameter.\n weights: None | array | SourceEstimate\n Weight for penalty in mixed_norm. Can be None or\n 1d array of length n_sources or a SourceEstimate e.g. obtained\n with wMNE or dSPM or fMRI.\n weights_min: float\n Do not consider in the estimation sources for which weights\n is less than weights_min.\n pca: bool\n If True the rank of the data is reduced to true dimension.\n debias: bool\n Remove coefficient amplitude bias due to L1 penalty.\n wsize: int or array-like\n Length of the STFT window in samples (must be a multiple of 4).\n If an array is passed, multiple TF dictionaries are used (each having\n its own wsize and tstep) and each entry of wsize must be a multiple\n of 4. See [3]_.\n tstep: int or array-like\n Step between successive windows in samples (must be a multiple of 2,\n a divider of wsize and smaller than wsize/2) (default: wsize/2).\n If an array is passed, multiple TF dictionaries are used (each having\n its own wsize and tstep), and each entry of tstep must be a multiple\n of 2 and divide the corresponding entry of wsize. See [3]_.\n window : float or (float, float)\n Length of time window used to take care of edge artifacts in seconds.\n It can be one float or float if the values are different for left\n and right window length.\n return_residual : bool\n If True, the residual is returned as an Evoked instance.\n return_as_dipoles : bool\n If True, the sources are returned as a list of Dipole instances.\n alpha : float in [0, 100) or None\n Overall regularization parameter.\n If alpha and l1_ratio are not None, alpha_space and alpha_time are\n overridden by alpha * alpha_max * (1. - l1_ratio) and alpha * alpha_max\n * l1_ratio. 0 means no regularization, 100 would give 0 active dipole.\n l1_ratio : float in [0, 1] or None\n Proportion of temporal regularization.\n If l1_ratio and alpha are not None, alpha_space and alpha_time are\n overridden by alpha * alpha_max * (1. - l1_ratio) and alpha * alpha_max\n * l1_ratio. 0 means no time regularization aka MxNE.\n dgap_freq : int or np.inf\n The duality gap is evaluated every dgap_freq iterations.\n %(rank_None)s\n\n .. versionadded:: 0.18\n %(verbose)s\n\n\n Returns\n -------\n stc : instance of SourceEstimate\n Source time courses.\n residual : instance of Evoked\n The residual a.k.a. data not explained by the sources.\n Only returned if return_residual is True.\n\n See Also\n --------\n mixed_norm\n\n References\n ----------\n .. [1] A. Gramfort, D. Strohmeier, J. Haueisen, M. Hämäläinen, M. Kowalski\n \"Time-Frequency Mixed-Norm Estimates: Sparse M/EEG imaging with\n non-stationary source activations\",\n Neuroimage, Volume 70, pp. 410-422, 15 April 2013.\n DOI: 10.1016/j.neuroimage.2012.12.051\n\n .. [2] A. Gramfort, D. Strohmeier, J. Haueisen, M. Hämäläinen, M. Kowalski\n \"Functional Brain Imaging with M/EEG Using Structured Sparsity in\n Time-Frequency Dictionaries\",\n Proceedings Information Processing in Medical Imaging\n Lecture Notes in Computer Science, Volume 6801/2011, pp. 600-611, 2011.\n DOI: 10.1007/978-3-642-22092-0_49\n\n .. [3] Y. Bekhti, D. Strohmeier, M. Jas, R. Badeau, A. Gramfort.\n \"M/EEG source localization with multiscale time-frequency dictionaries\",\n 6th International Workshop on Pattern Recognition in Neuroimaging\n (PRNI), 2016.\n DOI: 10.1109/PRNI.2016.7552337\n \"\"\"\n _check_reference(evoked)\n\n all_ch_names = evoked.ch_names\n info = evoked.info\n\n if not (0. <= alpha < 100.):\n raise ValueError('alpha must be in [0, 100). '\n 'Got alpha = %s' % alpha)\n\n if not (0. <= l1_ratio <= 1.):\n raise ValueError('l1_ratio must be in range [0, 1].'\n ' Got l1_ratio = %s' % l1_ratio)\n alpha_space = alpha * (1. - l1_ratio)\n alpha_time = alpha * l1_ratio\n\n if dgap_freq <= 0.:\n raise ValueError('dgap_freq must be a positive integer.'\n ' Got dgap_freq = %s' % dgap_freq)\n\n tstep = np.atleast_1d(tstep)\n wsize = np.atleast_1d(wsize)\n if len(tstep) != len(wsize):\n raise ValueError('The same number of window sizes and steps must be '\n 'passed. Got tstep = %s and wsize = %s' %\n (tstep, wsize))\n\n forward, gain, gain_info, whitener, source_weighting, mask = _prepare_gain(\n forward, evoked.info, noise_cov, pca, depth, loose, rank,\n weights, weights_min)\n n_dip_per_pos = 1 if is_fixed_orient(forward) else 3\n\n if window is not None:\n evoked = _window_evoked(evoked, window)\n\n sel = [all_ch_names.index(name) for name in gain_info[\"ch_names\"]]\n M = evoked.data[sel]\n\n # Whiten data\n logger.info('Whitening data matrix.')\n M = np.dot(whitener, M)\n\n # Scaling to make setting of alpha easy\n n_steps = np.ceil(M.shape[1] / tstep.astype(float)).astype(int)\n n_freqs = wsize // 2 + 1\n n_coefs = n_steps * n_freqs\n phi = _Phi(wsize, tstep, n_coefs)\n\n alpha_max = norm_epsilon_inf(gain, M, phi, l1_ratio, n_dip_per_pos)\n alpha_max *= 0.01\n gain /= alpha_max\n source_weighting /= alpha_max\n\n X, active_set, E = tf_mixed_norm_solver(\n M, gain, alpha_space, alpha_time, wsize=wsize, tstep=tstep,\n maxit=maxit, tol=tol, verbose=verbose, n_orient=n_dip_per_pos,\n dgap_freq=dgap_freq, debias=debias)\n\n if active_set.sum() == 0:\n raise Exception(\"No active dipoles found. \"\n \"alpha_space/alpha_time are too big.\")\n\n # Compute estimated whitened sensor data\n M_estimated = np.dot(gain[:, active_set], X)\n\n if mask is not None:\n active_set_tmp = np.zeros(len(mask), dtype=np.bool)\n active_set_tmp[mask] = active_set\n active_set = active_set_tmp\n del active_set_tmp\n\n X = _reapply_source_weighting(X, source_weighting, active_set)\n\n if return_residual:\n residual = _compute_residual(\n forward, evoked, X, active_set, gain_info)\n\n if return_as_dipoles:\n out = _make_dipoles_sparse(\n X, active_set, forward, evoked.times[0], 1.0 / info['sfreq'],\n M, M_estimated, verbose=None)\n else:\n out = _make_sparse_stc(\n X, active_set, forward, evoked.times[0], 1.0 / info['sfreq'])\n\n logger.info('[done]')\n\n if return_residual:\n out = out, residual\n\n return out\n", "meta": {"hexsha": "76e6706ec0a6ca9b555e5741d2810c2201d352e4", "size": 24544, "ext": "py", "lang": "Python", "max_stars_repo_path": "mne/inverse_sparse/mxne_inverse.py", "max_stars_repo_name": "kostasde/mne-python", "max_stars_repo_head_hexsha": "ac4abee16e1f106055437f5b7feaa99786831a6f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "mne/inverse_sparse/mxne_inverse.py", "max_issues_repo_name": "kostasde/mne-python", "max_issues_repo_head_hexsha": "ac4abee16e1f106055437f5b7feaa99786831a6f", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-06-26T15:50:17.000Z", "max_issues_repo_issues_event_max_datetime": "2019-06-27T07:30:26.000Z", "max_forks_repo_path": "mne/inverse_sparse/mxne_inverse.py", "max_forks_repo_name": "kostasde/mne-python", "max_forks_repo_head_hexsha": "ac4abee16e1f106055437f5b7feaa99786831a6f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-06-15T11:33:50.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-15T11:33:50.000Z", "avg_line_length": 37.0196078431, "max_line_length": 79, "alphanum_fraction": 0.6240221643, "include": true, "reason": "import numpy,from scipy", "num_tokens": 6578, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6187804196836383, "lm_q2_score": 0.30735800417608683, "lm_q1q2_score": 0.19018711481720446}} {"text": "\nimport logging\n\nfrom abc import ABC, abstractmethod\n\nimport numpy as np\n\nfrom typing import Dict, Tuple, Any\n\nfrom scipy.constants import epsilon_0\nfrom scipy.integrate import trapz\n\nfrom amset.misc.constants import k_B, e, hbar\nfrom amset.data import AmsetData\nfrom amset.misc.log import log_list\nfrom amset.misc.util import f0\nfrom pymatgen import Spin\n\n__author__ = \"Alex Ganose\"\n__maintainer__ = \"Alex Ganose\"\n__email__ = \"aganose@lbl.gov\"\n__date__ = \"June 21, 2019\"\n\nlogger = logging.getLogger(__name__)\n\n\nclass AbstractElasticScattering(ABC):\n\n name: str\n required_properties: Tuple[str]\n\n def __init__(self,\n materials_properties: Dict[str, Any],\n amset_data: AmsetData):\n self.properties = {p: materials_properties[p]\n for p in self.required_properties}\n self.doping = amset_data.doping\n self.temperatures = amset_data.temperatures\n self.nbands = {s: len(amset_data.energies[s]) for s in amset_data.spins}\n self.spins = amset_data.spins\n\n @abstractmethod\n def prefactor(self, spin: Spin, b_idx: int):\n pass\n\n @abstractmethod\n def factor(self, k_diff_sq: np.ndarray):\n pass\n\n\nclass AcousticDeformationPotentialScattering(AbstractElasticScattering):\n\n name = \"ACD\"\n required_properties = (\"deformation_potential\", \"elastic_constant\")\n\n def __init__(self,\n materials_properties: Dict[str, Any],\n amset_data: AmsetData):\n super().__init__(materials_properties, amset_data)\n self.vb_idx = amset_data.vb_idx\n self.is_metal = amset_data.is_metal\n self._prefactor = (1e18 * e * k_B / (\n 4.0 * np.pi ** 2 * hbar * self.properties[\"elastic_constant\"]))\n\n self.deformation_potential = self.properties[\"deformation_potential\"]\n if self.is_metal and isinstance(self.deformation_potential, tuple):\n logger.warning(\n \"System is metallic but deformation potentials for both \"\n \"the valence and conduction bands have been set... using the \"\n \"valence band potential for all bands\")\n self.deformation_potential = self.deformation_potential[0]\n\n elif not self.is_metal and not isinstance(\n self.deformation_potential, tuple):\n logger.warning(\n \"System is semiconducting but only one deformation \"\n \"potential has been set... using this potential for all bands.\")\n self.deformation_potential = (self.deformation_potential,\n self.deformation_potential)\n\n def prefactor(self, spin: Spin, b_idx: int):\n prefactor = self._prefactor * self.temperatures[None, :] * np.ones(\n (len(self.doping), len(self.temperatures)))\n\n if self.is_metal:\n prefactor *= self.properties[\"deformation_potential\"] ** 2\n\n else:\n def_idx = 1 if b_idx > self.vb_idx[spin] else 0\n prefactor *= self.properties[\"deformation_potential\"][def_idx] ** 2\n\n return prefactor\n\n def factor(self, k_diff_sq: np.ndarray):\n return np.ones((len(self.doping), len(self.temperatures),\n k_diff_sq.shape[0]))\n\n\nclass IonizedImpurityScattering(AbstractElasticScattering):\n\n name = \"IMP\"\n required_properties = (\"acceptor_charge\", \"donor_charge\",\n \"static_dielectric\")\n\n def __init__(self,\n materials_properties: Dict[str, Any],\n amset_data: AmsetData):\n super().__init__(materials_properties, amset_data)\n logger.debug(\"Initializing IMP scattering\")\n\n self.beta_sq = np.zeros(amset_data.fermi_levels.shape)\n self.impurity_concentration = np.zeros(amset_data.fermi_levels.shape)\n\n tdos = amset_data.dos.tdos\n energies = amset_data.dos.energies\n fermi_levels = amset_data.fermi_levels\n vol = amset_data.structure.volume\n\n imp_info = []\n for n, t in np.ndindex(self.beta_sq.shape):\n ef = fermi_levels[n, t]\n temp = amset_data.temperatures[t]\n f = f0(energies, ef, temp)\n integral = trapz(tdos * f * (1 - f), x=energies)\n self.beta_sq[n, t] = (\n e ** 2 * integral * 1e12 /\n (self.properties[\"static_dielectric\"] * epsilon_0 * k_B *\n temp * e * vol))\n\n n_conc = np.abs(amset_data.electron_conc[n, t])\n p_conc = np.abs(amset_data.hole_conc[n, t])\n\n self.impurity_concentration[n, t] = (\n n_conc * self.properties[\"donor_charge\"] ** 2 +\n p_conc * self.properties[\"acceptor_charge\"] ** 2)\n imp_info.append(\n \"{:.2g} cm⁻³ & {} K: β² = {:.4g}, Nᵢᵢ = {:.4g}\".format(\n amset_data.doping[n], temp, self.beta_sq[n, t],\n self.impurity_concentration[n, t]))\n\n logger.debug(\"Inverse screening length (β) and impurity concentration \"\n \"(Nᵢᵢ):\")\n log_list(imp_info, level=logging.DEBUG)\n\n self._prefactor = (\n (1e-3 / (e ** 2)) * e ** 4 * self.impurity_concentration /\n (4.0 * np.pi ** 2 * epsilon_0 ** 2 * hbar *\n self.properties[\"static_dielectric\"] ** 2))\n\n def prefactor(self, spin: Spin, b_idx: int):\n # need to return prefactor with shape (nspins, ndops, ntemps, nbands)\n return self._prefactor\n\n def factor(self, k_diff_sq: np.ndarray):\n # tile k_diff_sq to make it commensurate with the dimensions of beta\n return 1 / (np.tile(k_diff_sq, (len(self.doping),\n len(self.temperatures), 1)) +\n self.beta_sq[..., None]) ** 2\n\n\nclass PiezoelectricScattering(AbstractElasticScattering):\n\n name = \"PIE\"\n required_properties = (\"piezoelectric_coefficient\", \"static_dielectric\")\n\n def __init__(self,\n materials_properties: Dict[str, Any],\n amset_data: AmsetData):\n super().__init__(materials_properties, amset_data)\n unit_conversion = 1e9 / e\n self._prefactor = (unit_conversion * e ** 2 * k_B *\n self.properties[\"piezoelectric_coefficient\"] ** 2 /\n (4.0 * np.pi ** 2 * hbar * epsilon_0 *\n self.properties[\"static_dielectric\"]))\n\n def prefactor(self, spin: Spin, b_idx: int):\n # need to return prefactor with shape (ndops, ntemps)\n return self._prefactor * self.temperatures[None, :] * np.ones(\n (len(self.doping), len(self.temperatures)))\n\n def factor(self, k_diff_sq: np.ndarray):\n # factor should have shape (ndops, ntemps, nkpts)\n return 1 / np.tile(k_diff_sq, (len(self.doping),\n len(self.temperatures), 1))\n", "meta": {"hexsha": "ab6a414b20a01357b2f7065882b673558c244b47", "size": 6928, "ext": "py", "lang": "Python", "max_stars_repo_path": "amset/scattering/elastic.py", "max_stars_repo_name": "Navolo/amset", "max_stars_repo_head_hexsha": "964cf847d777faba9888e934ffe2ac0813ff9c71", "max_stars_repo_licenses": ["BSD-3-Clause-LBNL"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-12-19T16:27:01.000Z", "max_stars_repo_stars_event_max_datetime": "2019-12-19T16:27:01.000Z", "max_issues_repo_path": "amset/scattering/elastic.py", "max_issues_repo_name": "Navolo/amset", "max_issues_repo_head_hexsha": "964cf847d777faba9888e934ffe2ac0813ff9c71", "max_issues_repo_licenses": ["BSD-3-Clause-LBNL"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "amset/scattering/elastic.py", "max_forks_repo_name": "Navolo/amset", "max_forks_repo_head_hexsha": "964cf847d777faba9888e934ffe2ac0813ff9c71", "max_forks_repo_licenses": ["BSD-3-Clause-LBNL"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.4486486486, "max_line_length": 80, "alphanum_fraction": 0.6020496536, "include": true, "reason": "import numpy,from scipy", "num_tokens": 1668, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6757646140788307, "lm_q2_score": 0.2814056194821861, "lm_q1q2_score": 0.19016395984899379}} {"text": "#!/usr/bin/env python\n# encoding: utf-8\n\"\"\"\nPipelines for fitting PHAT CMDs.\n\"\"\"\nimport os\nfrom glob import glob\nfrom functools import partial\n\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\nimport palettable\n\nimport numpy as np\n# import astropy\nfrom astropy.coordinates import Distance\nimport astropy.units as u\nfrom astropy.table import Table\n\nfrom m31hst import phat_v2_phot_path\nfrom m31hst.phatast import PhatAstTable\n\nfrom padova import AgeGridRequest\nfrom padova.isocdata import join_isochrone_sets, Isochrone\n\nfrom starfisher import Lockfile\nfrom starfisher import ExtantCrowdingTable\nfrom starfisher import MockNullCrowdingTable\nfrom starfisher.dust import ExtinctionDistribution\nfrom starfisher.pipeline import (\n PipelineBase, IsochroneSetBase, DatasetBase, LockBase,\n CrowdingBase, ExtinctionBase)\n\nfrom androcmd.planes import RgbPhatPlanes, CompletePhatPlanes\nfrom androcmd.dust import mw_Av, phat_rel_extinction, LewisDustLaw\n\n\nPHAT_BANDS = ('F475W', 'F814W', 'F275W', 'F336W', 'F110W', 'F160W')\nSTARFISH = os.getenv(\"STARFISH\")\n\n\nclass SolarZIsocs(IsochroneSetBase):\n \"\"\"Solar metallicity isochrone set.\"\"\"\n def __init__(self, **kwargs):\n self.isoc_args = kwargs.pop('isoc_args', dict())\n self.isoc_phases = kwargs.pop('isoc_phases', None)\n self.z_grid = [0.015, 0.019, 0.024]\n print \"SolarZIsocs\", kwargs\n super(SolarZIsocs, self).__init__(**kwargs)\n\n @property\n def bands(self):\n return ('F475W', 'F814W', 'F275W', 'F336W', 'F110W', 'F160W')\n\n @property\n def distance(self):\n return Distance(785. * u.kpc)\n\n def setup_isochrones(self):\n \"\"\"Download Padova isochrones.\"\"\"\n print \"Running SolarZIsocs setup_isochrones\"\n WFC3_BANDS = ['F275W1', 'F336W', 'F110W', 'F160W']\n ACS_BANDS = ['F475W', 'F814W']\n\n if not os.path.exists(os.path.join(STARFISH, self.isoc_dir)):\n make_isocs = True\n elif len(glob(os.path.join(STARFISH, self.isoc_dir, \"*\"))) == 0:\n make_isocs = True\n else:\n make_isocs = False\n\n if self.isoc_args is None:\n self.isoc_args = {}\n if make_isocs:\n for z in self.z_grid:\n r_wfc3 = AgeGridRequest(z,\n min_log_age=6.6,\n max_log_age=10.13,\n delta_log_age=0.02,\n photsys='wfc3_wide', **self.isoc_args)\n r_acs = AgeGridRequest(z,\n min_log_age=6.6,\n max_log_age=10.13,\n delta_log_age=0.02,\n photsys='acs_wfc', **self.isoc_args)\n isoc_set = join_isochrone_sets(r_wfc3.isochrone_set,\n r_acs.isochrone_set,\n left_bands=WFC3_BANDS,\n right_bands=ACS_BANDS)\n for isoc in isoc_set:\n isoc = Isochrone(isoc)\n isoc.rename_column('F275W1', 'F275W')\n if self.isoc_phases is not None:\n sels = []\n for p in self.isoc_phases:\n sels.append(np.where(isoc['stage'] == p)[0])\n s = np.concatenate(sels)\n isoc = isoc[s]\n isoc.export_for_starfish(os.path.join(STARFISH,\n self.isoc_dir),\n bands=list(self.bands))\n super(SolarZIsocs, self).setup_isochrones()\n\n\nclass ExtendedSolarIsocs(IsochroneSetBase):\n \"\"\"Solar metallicity isochrone set.\"\"\"\n def __init__(self, **kwargs):\n self.isoc_args = kwargs.pop('isoc_args', dict())\n self.isoc_phases = kwargs.pop('isoc_phases', None)\n self.z_grid = (0.0096, 0.012, 0.015, 0.019, 0.024, 0.030, 0.04)\n print \"ExtendedSolarZIsocs\", kwargs\n super(ExtendedSolarIsocs, self).__init__(**kwargs)\n\n @property\n def bands(self):\n return ('F475W', 'F814W', 'F275W', 'F336W', 'F110W', 'F160W')\n\n @property\n def distance(self):\n return Distance(785. * u.kpc)\n\n def setup_isochrones(self):\n \"\"\"Download Padova isochrones.\"\"\"\n print \"Running ExtendedSolarIsocs setup_isochrones\"\n WFC3_BANDS = ['F275W1', 'F336W', 'F110W', 'F160W']\n ACS_BANDS = ['F475W', 'F814W']\n\n if not os.path.exists(os.path.join(STARFISH, self.isoc_dir)):\n make_isocs = True\n elif len(glob(os.path.join(STARFISH, self.isoc_dir, \"*\"))) == 0:\n make_isocs = True\n else:\n make_isocs = False\n\n if self.isoc_args is None:\n self.isoc_args = {}\n if make_isocs:\n for z in self.z_grid:\n r_wfc3 = AgeGridRequest(z,\n min_log_age=6.6,\n max_log_age=10.13,\n delta_log_age=0.02,\n photsys='wfc3_wide', **self.isoc_args)\n r_acs = AgeGridRequest(z,\n min_log_age=6.6,\n max_log_age=10.13,\n delta_log_age=0.02,\n photsys='acs_wfc', **self.isoc_args)\n isoc_set = join_isochrone_sets(r_wfc3.isochrone_set,\n r_acs.isochrone_set,\n left_bands=WFC3_BANDS,\n right_bands=ACS_BANDS)\n for isoc in isoc_set:\n isoc = Isochrone(isoc)\n isoc.rename_column('F275W1', 'F275W')\n if self.isoc_phases is not None:\n sels = []\n for p in self.isoc_phases:\n sels.append(np.where(isoc['stage'] == p)[0])\n s = np.concatenate(sels)\n isoc = isoc[s]\n isoc.export_for_starfish(os.path.join(STARFISH,\n self.isoc_dir),\n bands=list(self.bands))\n super(ExtendedSolarIsocs, self).setup_isochrones()\n\n\nclass PhatCatalog(DatasetBase):\n \"\"\"Mixin for PHAT photometry data.\n\n Photometry is lazy loaded to it is efficient to rebuild the pipeline\n object.\n \"\"\"\n def __init__(self, brick, **kwargs):\n self.brick = brick\n self._phat_data = None\n super(PhatCatalog, self).__init__(**kwargs)\n\n def _load_phat_data(self):\n self._phat_data = Table.read(phat_v2_phot_path(self.brick),\n format='fits')\n phat_bands = ('F475W', 'F814W', 'F275W', 'F336W', 'F110W', 'F160W')\n # Normalize bandpass names\n for band in phat_bands:\n old_name = \"_\".join((band.lower(), 'vega'))\n self._phat_data.rename_column(old_name, band)\n\n def get_phot(self, band):\n if self._phat_data is None:\n self._load_phat_data() # lazy loading\n\n if not isinstance(band, basestring):\n band1, band2 = band\n return self._phat_data[band1] - self._phat_data[band2]\n else:\n return self._phat_data[band]\n\n def _select_gst(self, x_band, y_band):\n mags = []\n if not isinstance(x_band, basestring):\n mags.extend(x_band)\n else:\n mags.append(x_band)\n\n if not isinstance(y_band, basestring):\n mags.extend(y_band)\n else:\n mags.append(y_band)\n mags = list(set(mags))\n\n gsts = []\n for band in mags:\n key = '{0}_gst'.format(band.lower())\n gsts.append(self._phat_data[key])\n gsts_array = np.vstack(gsts).T\n gsts = np.all(gsts_array, axis=1)\n return np.where(gsts == True)[0] # NOQA\n\n def write_phot(self, x_band, y_band, data_root, suffix):\n \"\"\"Only good (GST=1 in all relevant bands) photometry is written.\"\"\"\n if self._phat_data is None:\n self._load_phat_data() # lazy loading\n\n x = self.get_phot(x_band)\n y = self.get_phot(y_band)\n gst_sel = self._select_gst(x_band, y_band)\n\n phot_dtype = np.dtype([('x', np.float), ('y', np.float)])\n photdata = np.empty(len(gst_sel), dtype=phot_dtype)\n photdata['x'][:] = x[gst_sel]\n photdata['y'][:] = y[gst_sel]\n\n path = data_root + suffix\n full_path = os.path.join(STARFISH, path)\n fit_dir = os.path.dirname(full_path)\n if not os.path.exists(fit_dir):\n os.makedirs(fit_dir)\n np.savetxt(full_path, photdata, delimiter=' ', fmt='%.4f')\n\n @property\n def polygon(self):\n \"\"\"Polygon bounding box around the dataset.\"\"\"\n if self._phat_data is None:\n self._load_phat_data() # lazy loading\n\n ra = self._phat_data['ra']\n dec = self._phat_data['dec']\n return np.array([[ra.min(), dec.min()],\n [ra.min(), dec.max()],\n [ra.max(), dec.max()],\n [ra.max(), dec.min()]])\n\n\nclass SolarLockfile(LockBase):\n \"\"\"Lockfile mixin to create an iso-metallicity Hess set.\"\"\"\n def __init__(self, **kwargs):\n print \"SolarLockfile\", kwargs\n super(SolarLockfile, self).__init__(**kwargs)\n\n def build_lockfile(self):\n self.lockfile = Lockfile(self.builder.read_isofile(), self.synth_dir,\n unbinned=False)\n\n # Bin young isochrones\n young_grid = np.linspace(6.5, 8.95, 10)\n for i, logage0 in enumerate(young_grid[:-1]):\n logage0 = logage0\n logage1 = young_grid[i + 1]\n z_str = \"0019\"\n mean_age = (logage0 + logage1) / 0.2\n name = \"z{0}_{1:05.2f}\".format(z_str, mean_age)\n self.lockfile.lock_box(name, (logage0, logage1), (0.014, 0.025))\n\n # Bin old isochrones\n old_grid = np.arange(1e9, 14 * 1e9, 1e9)\n for i, age0 in enumerate(old_grid[:-1]):\n logage0 = np.log10(age0 - 0.05 * 1e9)\n logage1 = np.log10(old_grid[i + 1])\n z_str = \"0019\"\n mean_age = (logage0 + logage1) / 0.2\n name = \"z{0}_{1:05.2f}\".format(z_str, mean_age)\n self.lockfile.lock_box(name, (logage0, logage1), (0.014, 0.025))\n\n\nclass ExtendedSolarLockfile(LockBase):\n \"\"\"Lockfile mixin to create an sub-, solar and super solar Z Hess set.\"\"\"\n def __init__(self, **kwargs):\n print \"ExtendedSolarLockfile\", kwargs\n super(ExtendedSolarLockfile, self).__init__(**kwargs)\n\n def build_lockfile(self):\n self.lockfile = Lockfile(self.builder.read_isofile(), self.synth_dir,\n unbinned=False)\n\n z_bins = [(0.009, 0.0135), (0.014, 0.025), (0.027, 0.042)]\n z_strs = ['0010', '0019', '0028']\n\n # Bin young isochrones\n for zbin, z_str in zip(z_bins, z_strs):\n young_grid = np.linspace(6.5, 8.95, 10)\n for i, logage0 in enumerate(young_grid[:-1]):\n logage0 = logage0\n logage1 = young_grid[i + 1]\n mean_age = (logage0 + logage1) / 0.2\n name = \"z{0}_{1:05.2f}\".format(z_str, mean_age)\n self.lockfile.lock_box(name, (logage0, logage1), zbin)\n\n # Bin old isochrones\n old_grid = np.arange(1e9, 14 * 1e9, 1e9)\n for i, age0 in enumerate(old_grid[:-1]):\n logage0 = np.log10(age0 - 0.05 * 1e9)\n logage1 = np.log10(old_grid[i + 1])\n mean_age = (logage0 + logage1) / 0.2\n name = \"z{0}_{1:05.2f}\".format(z_str, mean_age)\n self.lockfile.lock_box(name, (logage0, logage1), zbin)\n\n\nclass PhatCrowding(CrowdingBase):\n \"\"\"Use crowding from the PHAT AST fields.\"\"\"\n def __init__(self, **kwargs):\n self._ast_field = kwargs.pop('ast_field', 0)\n super(PhatCrowding, self).__init__(**kwargs)\n\n def build_crowding(self):\n # Use PHAT AST from the outer field (field 0)\n crowd_path = os.path.join(self.synth_dir, \"crowding.dat\")\n full_crowd_path = os.path.join(STARFISH, crowd_path)\n tbl = PhatAstTable()\n tbl.write_crowdfile_for_field(full_crowd_path,\n self._ast_field,\n bands=self.bands)\n self.crowd = ExtantCrowdingTable(crowd_path)\n\n def mask_planes(self):\n \"\"\"Mask each CMD plane based on the incomplete or empty regions of\n the PHAT artificial star testing projected into the Hess plane.\n\n This hook is called automatically by the base pipeline before\n synth is run.\n \"\"\"\n # FIXME note that AST field 0 *is always* used\n print \"Using PhatCrowding.mask_planes\"\n ast = PhatAstTable()\n for key, plane in self.planes.iteritems():\n band = plane.y_mag # FIXME assumes CMD; only 1 y axis mag.\n hess, x_grid, y_grid = ast.completeness_hess(\n 0, band,\n plane.x_mag, plane.y_mag,\n plane.xlim, plane.ylim, 0.5)\n yidx, xidx = np.where(hess < 0.5) # mask less than 50% complete\n for yi, xi in zip(yidx, xidx):\n plane.mask_region((x_grid[xi], x_grid[xi + 1]),\n (y_grid[yi], y_grid[yi + 1]))\n yidx, xidx = np.where(~np.isfinite(hess)) # mask empty AST\n for yi, xi in zip(yidx, xidx):\n plane.mask_region((x_grid[xi], x_grid[xi + 1]),\n (y_grid[yi], y_grid[yi + 1]))\n\n\nclass NullCrowding(object):\n \"\"\"Crowding pipeline for no photometric errors due to crowidng.\"\"\"\n def __init__(self, **kwargs):\n super(NullCrowding, self).__init__(**kwargs)\n\n def mask_planes(self):\n pass\n\n def build_crowding(self):\n path = os.path.join(self.synth_dir, \"crowding.dat\")\n self.crowd = MockNullCrowdingTable(path, self.n_bands)\n\n\nclass NoDust(ExtinctionBase):\n \"\"\"Mixin for no dust.\"\"\"\n def __init__(self, **kwargs):\n super(NoDust, self).__init__(**kwargs)\n\n def build_extinction(self):\n # Add MW dust screen\n self.young_av = ExtinctionDistribution()\n self.young_av.set_uniform(mw_Av())\n self.old_av = ExtinctionDistribution()\n self.old_av.set_uniform(mw_Av())\n\n self.rel_extinction = phat_rel_extinction()\n\n\nclass PhatGaussianDust(ExtinctionBase):\n \"\"\"Mixin for Gaussian dust distributions for PHAT filters.\"\"\"\n def __init__(self, **kwargs):\n self._young_av = kwargs.pop('young_av', 1.0)\n self._old_av = kwargs.pop('old_av', 0.5)\n self._av_sigma_ratio = kwargs.pop('av_sigma_ratio', 0.5)\n super(PhatGaussianDust, self).__init__(**kwargs)\n\n def build_extinction(self):\n # NOTE includes the E(V\n self.young_av = ExtinctionDistribution()\n if self._young_av > 0.:\n av = np.random.normal(\n loc=self._young_av,\n scale=self._young_av * self._av_sigma_ratio,\n size=1000)\n av[av < 0.] = 0.\n self.young_av.set_samples(av + mw_Av())\n else:\n self.young_av.set_samples(np.zeros(1000) + mw_Av())\n\n self.old_av = ExtinctionDistribution()\n if self._old_av > 0.:\n av = np.random.normal(\n loc=self._old_av,\n scale=self._old_av * self._av_sigma_ratio,\n size=1000)\n av[av < 0.] = 0.\n self.old_av.set_samples(av + mw_Av())\n else:\n self.old_av.set_samples(np.zeros(1000) + mw_Av())\n\n self.rel_extinction = phat_rel_extinction()\n\n\nclass PhatStepDust(ExtinctionBase):\n \"\"\"Mixin for Uniform dust distributions for PHAT filters.\"\"\"\n def __init__(self, **kwargs):\n self._young_av = kwargs.pop('young_av', 0.0) + mw_Av()\n self._old_av = kwargs.pop('old_av', 0.0) + mw_Av()\n self._young_dav = kwargs.pop('young_dav', 1.0)\n self._old_dav = kwargs.pop('old_dav', 1.0)\n super(PhatStepDust, self).__init__(**kwargs)\n\n def build_extinction(self):\n # NOTE includes MW extinction from __init__\n self.young_av = ExtinctionDistribution()\n self.young_av.set_samples(np.random.uniform(\n low=self._young_av,\n high=self._young_av + self._young_dav,\n size=1000))\n\n self.old_av = ExtinctionDistribution()\n self.old_av.set_samples(np.random.uniform(\n low=self._old_av,\n high=self._old_av + self._old_dav,\n size=1000))\n\n self.rel_extinction = phat_rel_extinction()\n\n\nclass LewisBrickDust(ExtinctionBase):\n \"\"\"Mixin for a uniform dust distribution fitted from Lewis et al 15 Fig 17.\n\n The maximum extinction is estimated from a Draine et al 2015 dust map.\n Requires that the brick be known.\n \"\"\"\n def __init__(self, **kwargs):\n self.brick = kwargs.pop('brick', 23)\n super(LewisBrickDust, self).__init__(**kwargs)\n\n def build_extinction(self):\n \"\"\"Young and old dust at equal here.\"\"\"\n # Get the coordinate of the brick\n # brick_fits = phat_brick_path(self.brick, 'F814W')\n # wcs = astropy.io.WCS(brick_fits[0].header)\n # poly = wcs.calc_footprint()\n data = PhatCatalog(self.brick) # FIXME pretty brick-specific\n poly = data.polygon\n\n lewis = LewisDustLaw()\n max_av = lewis.estimate_mean_extinction(poly)\n av = np.random.uniform(low=mw_Av(),\n high=max_av,\n size=1000)\n\n self.young_av = ExtinctionDistribution()\n self.young_av.set_samples(av)\n\n self.old_av = ExtinctionDistribution()\n self.old_av.set_samples(av)\n\n self.rel_extinction = phat_rel_extinction()\n\n\nclass SolarZPhatPipeline(CompletePhatPlanes, SolarZIsocs,\n SolarLockfile, NoDust, PhatCrowding, PipelineBase):\n \"\"\"A pipeline for fitting PHAT bricks with solar metallicity isochrones.\"\"\"\n def __init__(self, **kwargs):\n print \"SolarZPhatPipeline\", kwargs\n super(SolarZPhatPipeline, self).__init__(**kwargs)\n\n\nclass SolarRgbPipeline(RgbPhatPlanes, SolarZIsocs,\n SolarLockfile, NoDust, PhatCrowding, PipelineBase):\n \"\"\"A pipeline for fitting PHAT bricks with solar metallicity isochrones.\"\"\"\n def __init__(self, **kwargs):\n print \"SolarRgbPipeline\", kwargs\n super(SolarRgbPipeline, self).__init__(**kwargs)\n\n\ndef build_phat_filter_set(**kwargs):\n r_wfc3 = AgeGridRequest(photsys='wfc3_wide', **kwargs)\n r_acs = AgeGridRequest(photsys='acs_wfc', **kwargs)\n isoc_set = join_isochrone_sets(r_wfc3.isochrone_set,\n r_acs.isochrone_set,\n left_bands=['F275W1', 'F336W',\n 'F110W', 'F160W'],\n right_bands=['F475W', 'F814W'])\n return isoc_set\n\n\nget_demo_age_grid = partial(build_phat_filter_set,\n z=0.019, min_log_age=6.6, max_log_age=10.13,\n delta_log_age=0.2)\n\n\ndef plot_isochrone_phases(ax, band1, band2, show_cb=False, cb_ax=None):\n isoc_set = get_demo_age_grid(**dict(isoc_kind='parsec_CAF09_v1.2S',\n photsys_version='yang'))\n phase_labels = {0: 'Pre-MS', 1: 'MS', 2: 'SGB', 3: 'RGB',\n 4: 'CHeB(1)', 5: 'CHeB(2)', 6: 'CHeB(3)',\n 7: 'E-AGB', 8: 'TP-AGB'}\n cmap = mpl.colors.ListedColormap(\n palettable.colorbrewer.qualitative.Set1_9.mpl_colors)\n scalar_map = mpl.cm.ScalarMappable(norm=mpl.colors.Normalize(vmin=-0.5,\n vmax=8.5),\n cmap=cmap)\n scalar_map.set_array(np.array(range(0, 9)))\n\n d = Distance(785 * u.kpc)\n for isoc in isoc_set:\n phases = np.unique(isoc['stage'])\n srt = np.argsort(phases)\n phases = phases[srt]\n for p in phases:\n s = np.where(isoc['stage'] == p)[0]\n ax.plot(isoc[band1][s] - isoc[band2][s],\n isoc[band2][s] + d.distmod.value,\n c=scalar_map.to_rgba(p),\n lw=0.8)\n if show_cb:\n cb = plt.colorbar(mappable=scalar_map,\n cax=cb_ax, ax=ax, ticks=range(0, 9))\n cb.ax.set_yticklabels([phase_labels[p] for p in range(0, 9)])\n cb.set_label(r\"Stage\")\n", "meta": {"hexsha": "ba81881272b0bbae1eb8f8ae965a7b4b2d6f490d", "size": 20978, "ext": "py", "lang": "Python", "max_stars_repo_path": "androcmd/phatpipeline.py", "max_stars_repo_name": "jonathansick/androcmd", "max_stars_repo_head_hexsha": "aa01b201b29fde701c07627063f55b67b71fb333", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "androcmd/phatpipeline.py", "max_issues_repo_name": "jonathansick/androcmd", "max_issues_repo_head_hexsha": "aa01b201b29fde701c07627063f55b67b71fb333", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "androcmd/phatpipeline.py", "max_forks_repo_name": "jonathansick/androcmd", "max_forks_repo_head_hexsha": "aa01b201b29fde701c07627063f55b67b71fb333", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.5625, "max_line_length": 79, "alphanum_fraction": 0.5549623415, "include": true, "reason": "import numpy,import astropy,from astropy", "num_tokens": 5440, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5926665999540697, "lm_q2_score": 0.32082130731838393, "lm_q1q2_score": 0.19014007340120628}} {"text": "import os\nimport glob\nimport numpy as np\nimport spiceypy as spice\nfrom astropy.time import Time\n\n\nclass StereoSpice:\n\n def __init__(self):\n \"\"\"\n Load in the general spice kernals and stereo spice keranls\n \"\"\"\n self.__load_general_kernals__()\n\n self.__load_stereo_kernals__()\n return\n \n\n def __get_spice_range__(self, filename):\n \"\"\"\n Function to calculate the range of coverage of a spice file given by filename\n :param filename: String, full path to spice file.\n :return dates_min: Astropy time object giving start of period spanned by spice file\n :return dates_max: Astropy time object giving end of period spanned by spice file\n :return craft_ids: List of craft ids represented by the spice file\n \"\"\"\n\n # Ephemeris files:\n if filename.endswith('bsp'):\n # Get craft id's\n craft_ids = spice.spkobj(filename)\n times = []\n for s in craft_ids:\n cover = spice.utils.support_types.SPICEDOUBLE_CELL(2000)\n spice.spkcov(filename, s, cover)\n times.append([c for c in cover])\n # Pointing files\n elif filename.endswith('bc'):\n # Get craft id's\n craft_ids = spice.ckobj(filename)\n times = []\n for s in craft_ids:\n cover = spice.utils.support_types.SPICEDOUBLE_CELL(2000)\n try:\n print('spice.ckcov: compute segment')\n spice.ckcov(filename, s, False, 'segment', 0.0, 'TDB', cover)\n except:\n print('spice.ckcov: compute interval')\n spice.ckcov(filename, s, False, 'interval', 0.0, 'TDB', cover)\n\n times.append([c for c in cover])\n else:\n print('Unrecognized file extension : ' + filename.split('.')[-1])\n dates_min = np.NaN\n dates_max = np.NaN\n craft_ids = np.NaN\n return dates_min, dates_max, craft_ids\n\n # Format the dates.\n min_time = min([min(t) for t in times])\n dates_min = Time(spice.et2utc(min_time, 'ISOC', 3))\n max_time = max([max(t) for t in times])\n dates_max = Time(spice.et2utc(max_time, 'ISOC', 3))\n return dates_min, dates_max, craft_ids\n \n\n def __get_kernal_files__(self):\n \"\"\"\n Function to load in the paths to the relevant spice kernals and files with lists of spice kernals.\n :return kernals_dict: Dictionary containing the full paths to the kernal files needed.\n \"\"\"\n\n root = os.path.abspath(os.path.dirname(__file__))\n kernal_files = os.path.join(root,'config.dat')\n \n if os.path.exists(kernal_files):\n\n with open(kernal_files, \"r\") as f:\n kernals_dict = {}\n lines = f.read().splitlines()\n for l in lines:\n name, rel_path = l.split(';')\n abs_path = os.path.join(root, rel_path)\n kernals_dict[name] = abs_path\n\n # Check that each file exists.\n for k, f in kernals_dict.items():\n \n if not os.path.exists(f):\n print(\"Error: {} kernal file/file-list not found\".format(k))\n else:\n print(\"Error: Kernal files list not found.\")\n kernals_dict = {}\n\n return kernals_dict\n \n\n def __load_general_kernals__(self):\n \"\"\"\n Function to load in all the general kernals.\n :return:\n \"\"\"\n\n # Load in the necessary Spice kernels\n kernals_dict = self.__get_kernal_files__()\n \n # Load in the leap seconds kernal\n spice.furnsh(kernals_dict['leap_seconds'])\n self.__LeapSec__ = kernals_dict['leap_seconds']\n\n # Load in the solar system kernal\n spice.furnsh(kernals_dict['solar_system'])\n self.__SolarSystem__ = kernals_dict['solar_system']\n\n # Load in the planetary constants kernal\n spice.furnsh(kernals_dict['planet_constants'])\n self.__PlanetConstants__ = kernals_dict['planet_constants']\n\n # Load in the heliospheric frames kernal\n spice.furnsh(kernals_dict['heliospheric_frames'])\n self.__HeliosphericFrames__ = kernals_dict['heliospheric_frames']\n\n # Load in the stereo frames kernal\n spice.furnsh(kernals_dict['stereo_frames'])\n self.__StereoFrames__ = kernals_dict['stereo_frames']\n\n # Load in the stereo a clock kernal\n spice.furnsh(kernals_dict['stereo_frames'])\n self.__staclock__ = kernals_dict['sta_clock']\n\n # Load in the stereo b clock kernal\n spice.furnsh(kernals_dict['stereo_frames'])\n self.__stbclock__ = kernals_dict['stb_clock']\n\n return\n \n\n def __load_stereo_kernals__(self):\n \"\"\"\n Function to load in the STEREO specific kernals\n \"\"\"\n # Load in the necessary Spice kernels\n kernals_dict = self.__get_kernal_files__()\n \n # Load in the predicted ephemeris, and collect all ephem files.\n # >> Initialise record of maximum dates covered by the ephemeris\n self.__PredMaxdates__ = {'sta': Time(0.0, format='jd'),\n 'stb': Time(0.0, format='jd')}\n\n # >> Initialise the conic to cover the predicted ephemeris outside covered range\n self.__PredConic__ = {'sta': None, 'stb': None}\n self.__mu__ = 1.32712440018\n self.__AllPredictedEphem__ = []\n\n for craft in ['sta', 'stb']:\n # Load in the predicted ephemeris files\n key = craft + \"_ephem_filelist\"\n with open(kernals_dict[key]) as f:\n all_ephem_files = f.read().splitlines()\n for ephem_file in all_ephem_files:\n full_ephem_path = os.path.join(kernals_dict['data_root'], ephem_file)\n if os.path.exists(full_ephem_path):\n spice.furnsh(full_ephem_path)\n self.__AllPredictedEphem__.append(full_ephem_path)\n\n # Extract the orbital parameters for conic extrapolation on predicted ephemeris\n dates_min, dates_max, craft_ids = self.__get_spice_range__(full_ephem_path)\n if dates_max > self.__PredMaxdates__[craft]:\n self.__PredMaxdates__[craft] = dates_max\n state = self.get_coord(dates_max, craft, system='HAE')\n et = spice.utc2et(dates_max.isot)\n elts = spice.oscelt(state, et, self.__mu__)\n self.__PredConic__[craft] = elts\n else:\n print(\"Error: File not found - {}\".format(full_ephem_path))\n\n # Load in the definitive ephemeris, and collect all ephem files.\n # >> Initialise record of maximum dates covered by the ephemeris\n self.__DefMaxdates__ = {'sta': Time(0.0, format='jd'),\n 'stb': Time(0.0, format='jd')}\n\n # >> Initialise the conic to cover the predicted ephemeris outside covered range\n self.__DefConic__ = {'sta': None, 'stb': None}\n self.__AllDefEphem__ = []\n\n for craft in ['sta', 'stb']:\n # Load in the predicted ephemeris files\n key = craft + \"_def_ephem_filelist\"\n with open(kernals_dict[key]) as f:\n all_ephem_files = f.read().splitlines()\n for ephem_file in all_ephem_files:\n full_ephem_path = os.path.join(kernals_dict['data_root'], ephem_file)\n if os.path.exists(full_ephem_path):\n spice.furnsh(full_ephem_path)\n self.__AllDefEphem__.append(full_ephem_path)\n\n # Extract the orbital parameters for conic extrapolation on definitive ephemers\n dates_min, dates_max, sid = self.__get_spice_range__(full_ephem_path)\n if dates_max > self.__DefMaxdates__[craft]:\n self.__DefMaxdates__[craft] = dates_max\n state = self.get_coord(dates_max, craft, system='HAE')\n et = spice.utc2et(dates_max.isot)\n elts = spice.oscelt(state, et, self.__mu__)\n self.__DefConic__[craft] = elts\n else:\n print(\"Error: File not found - {}\".format(full_ephem_path))\n\n # TODO: Load in Attitude kernals if want to use CMAT stuff?\n\n return\n \n \n def convert_hpc_to_hpr(self, hpc_lon, hpc_lat, degrees=True):\n \"\"\"\n Function to convert helioprojective cartesian coordinates (longitudes and latitudes) into helioprojective radial\n coordinates (elongations and position angles). Conversion done by Eqn. 19 in Thompson 2006.\n :param hpc_lon: Float or array of longitudes, in degrees.\n :param hpc_lat: Float or array of latitudes, in degrees.\n :param degrees: Boolean, if True (default), angles are parsed and returned in degrees.\n :return hpr_el: Float or array of elongations, in degrees.\n :return hpr_pa: Float or array of position angles, in degrees.\n \"\"\"\n \n if degrees:\n hpc_lon = np.deg2rad(hpc_lon)\n hpc_lat = np.deg2rad(hpc_lat)\n \n # Elongation calc:\n # Get numerator and denomenator for atan2 calculation\n btm = np.cos(hpc_lat) * np.cos(hpc_lon)\n top = np.sqrt((np.cos(hpc_lat) ** 2) * (np.sin(hpc_lon) ** 2) + (np.sin(hpc_lat) ** 2))\n hpr_el = np.arctan2(top, btm)\n # Position angle calc:\n btm = np.sin(hpc_lat)\n top = -np.cos(hpc_lat) * np.sin(hpc_lon)\n hpr_pa = np.arctan2(top, btm)\n # Correct eastern longitudes so pa runs from 0>2pi, rather than 0>pi.\n if isinstance(hpr_pa, np.float):\n if hpc_lon >= 0:\n hpr_pa += 2 * np.pi\n else:\n hpr_pa[hpc_lon >= 0] += 2 * np.pi\n\n if degrees:\n # Put it back into degs\n hpr_el = np.rad2deg(hpr_el)\n hpr_pa = np.rad2deg(hpr_pa)\n \n return hpr_el, hpr_pa\n \n \n def convert_hpr_to_hpc(self, hpr_el, hpr_pa, degrees=True):\n \"\"\"\n Function to convert helioprojective radial coordinates (elongations and position angles) into helioprojective\n cartesian coordinates (longitudes and latitudes) . Conversion done by Eqn. 20 in Thompson 2006.\n :param hpr_el: Array of elongations. Should have astropy unit of degrees.\n :param hpr_pa: Array of position angles. Should have astropy unit of degrees.\n :param degrees: Boolean, if True (default), angles are parsed and returned in degrees.\n :return hpc_lon: Array of longitudes with astropy unit of degrees.\n :return hpc_lat: Array of latitudes angles with astropy unit of degrees.\n \"\"\"\n if degrees:\n hpr_el = np.deg2rad(hpr_el)\n hpr_pa = np.deg2rad(hpr_pa)\n \n # Longitude calc:\n # Get numerator and denomenator for atan2 calculation\n btm = np.cos(hpr_el)\n top = -np.sin(hpr_el) * np.sin(hpr_pa)\n hpc_lon = np.arctan2(top, btm)\n # Latitude calc:\n hpc_lat = np.arcsin(np.sin(hpr_el) * np.cos(hpr_pa))\n \n if degrees:\n hpc_lon = np.rad2deg(hpc_lon)\n hpc_lat = np.rad2deg(hpc_lat)\n \n return hpc_lon, hpc_lat\n\n \n def convert_hpc_to_rtn(self, hpc_lon, hpc_lat, degrees=True):\n \"\"\"\n Function to convert helioprojective cartesian coordinates (longitudes and latitudes) into RTN longitude and latitudes.\n :param hpc_lon: Float or array of HPC longitudes, in degrees.\n :param hpc_lat: Float or array of HPC latitudes, in degrees.\n :param degrees: Boolean, if True (default), angles are parsed and returned in degrees.\n :return rtn_lon: Float or array of RTN longitudes, in degrees.\n :return rtn_lat: Float or array of RTN latitudes, in degrees.\n \"\"\"\n rtn_lat = hpc_lat\n \n if degrees:\n hpc_lon = np.deg2rad(hpc_lon)\n \n rtn_lon = np.pi - hpc_lon\n \n if degrees:\n rtn_lon = np.rad2deg(rtn_lon)\n \n return rtn_lon, rtn_lat\n \n \n def convert_rtn_to_hpc(self, rtn_lon, rtn_lat, degrees=True):\n \"\"\"\n Function to convert helioprojective cartesian coordinates (longitudes and latitudes) into RTN longitude and latitudes.\n :param hpc_lon: Float or array of HPC longitudes, in degrees.\n :param hpc_lat: Float or array of HPC latitudes, in degrees.\n :param degrees: Boolean, if True (default), angles are parsed and returned in degrees.\n :return rtn_lon: Float or array of RTN longitudes, in degrees.\n :return rtn_lat: Float or array of RTN latitudes, in degrees.\n \"\"\"\n hpc_lat = rtn_lat\n \n if degrees:\n rtn_lon = np.deg2rad(rtn_lon)\n \n if isinstance(rtn_lon,float):\n hpc_lon = np.pi - rtn_lon\n if hpc_lon > np.pi:\n hpc_lon -= 2*np.pi\n\n if hpc_lon < -np.pi:\n hpc_lon += 2*np.pi\n else:\n hpc_lon = np.pi - rtn_lon\n id_over = hpc_lon > np.pi\n if any(id_over):\n hpc_lon[id_over] -= 2*np.pi\n\n id_under = hpc_lon < -np.pi\n if any(id_under):\n hpc[id_under] += 2*np.pi\n \n if degrees:\n hpc_lon = np.rad2deg(hpc_lon)\n \n return hpc_lon, hpc_lat\n\n \n def convert_coord(self, dates, coord_src, system_src, system_dst, observe_src=None, observe_dst=None, precess=False):\n \"\"\"\n Function to convert coordinates betwen different reference frames.\n :param dates: Astropy time object of dates(s).\n :param coord_src: Array of coordinates to convert. Should be len(dates)*3 for positions only, or len(dates)*6 for full state\n :param system_src: String name of coordinate system of coord array.\n :param system_dst: String name of coordinate system to transform coord array to.\n :param observe_src: String name of observatory for origin of system from. Only needed for some systems.\n :param observe_dst: String name of observatory for origin of system to. Only needed for some systems.\n :param precess: Boolean. If True accounts for precession in coordinate system.\n :return state: Array, giving state at each dates. Either len(dates)x3 or len(dates)x6, depending on no_velocity\n :return ltime (optional): The light travel time between observatory and target\n \"\"\"\n # If coordinates input as a list, then bung them into an array.\n if isinstance(coord_src, list):\n if all([isinstance(c, (float, int)) for c in coord_src]):\n coord_src = np.array(coord_src)\n coord_src = np.squeeze(coord_src)\n else:\n print(\"ERROR: coord_src should be a numpy array of coordinates or a list of floats/ints.\")\n \n # If coord only has one dimension, set it so that time is zeroth.\n if coord_src.ndim == 1:\n n_coords = 1\n n_components = coord_src.size\n else:\n n_coords = coord_src.shape[0]\n n_components = coord_src.shape[1]\n \n # Check dates and coord sizes match.\n if dates.size != n_coords:\n print(\"Error: Number of dates does not correspond to number of coordinates.\")\n \n # Check coord components are either 3 or 6, for position or state. Set no_velocity flag too.\n if n_components == 3:\n no_velocity = True\n elif n_components == 6:\n no_velocity = False\n else: \n print(\"ERROR: Invalid dimension of position vector or state vector\")\n \n # Get NAIF formated name for src and dst observer and frame.\n # Get SRC frame and osberver\n if observe_src is None:\n # Observer defined by the frame.\n frame_src, observe_src = self.get_system_frame_names(system_src, precess=precess)\n else:\n # Observer must be specified for this frame\n observe_src = self.get_naif_body_code(observe_src)\n # Get naif frame and observer\n frame_src, observe_src = self.get_system_frame_names(system_src, observatory=observe_src, precess=precess)\n \n # Repeat for DST frame and observer\n if observe_dst is None:\n # Observer defined by frame\n frame_dst, observe_dst = self.get_system_frame_names(system_dst, precess=precess)\n else:\n # Observer must be specified for this frame\n observe_dst = self.get_naif_body_code(observe_dst)\n # Get naif frame and observ\n frame_dst, observe_dst = self.get_system_frame_names(system_dst, observatory=observe_dst, precess=precess)\n \n # Convert to ephemeris time\n if dates.isscalar:\n et = spice.str2et(dates.isot)\n else:\n et = spice.str2et(dates.isot.tolist())\n \n # If observer changes, first do origin shift.\n if observe_src != observe_dst:\n \n # Get location of observe_dst relative to observe_src in frame_src\n corr = 'NONE'\n if no_velocity:\n observe_src_state, ltime = spice.spkpos(observe_dst, et, frame_src, corr, observe_src)\n else:\n # Velocity requested. This needs spkezr, which only accepts floats. So loop through et and call spkezr for\n # each et. Preallocate state and ltime, in this case state is a len(et)x6 array.\n if dates.isscalar:\n observe_src_state, ltime = spice.spkezr(observe_dst, et, frame_src, corr, observe_src)\n else:\n observe_src_state = np.zeros(coord_src.shape, dtype=float)\n ltime = np.zeros(dates.size, dtype=float)\n for i in range(dates.size):\n observe_src_state[i, :], ltime[i] = spice.spkezr(observe_dst, et[i], frame_src, corr, observe_src)\n \n # Now shift the origin \n coord_src = coord_src - observe_src_state\n \n # Must loop through dates for the matrix multiplication. Preallocate space for output.\n # Now rotate from src frame to dst frame.\n if dates.isscalar:\n if no_velocity:\n # Get rotation matrix for position only\n transform = spice.pxform(frame_src, frame_dst, et)\n coord_dst = np.matmul(transform, coord_src)\n else:\n # Get rotation matrix for full state\n transform = spice.sxform(frame_src, frame_dst, et)\n coord_dst = np.matmul(transform, coord_src)\n else:\n # Must loop through dates for the matrix multiplication. Preallocate space for output.\n coord_dst = np.zeros(coord_src.shape, dtype=float)\n \n for i in range(dates.size):\n if no_velocity:\n transform = spice.pxform(frame_src, frame_dst, et[i])\n else:\n transform = spice.sxform(frame_src, frame_dst, et[i])\n \n coord_dst[i, :] = np.matmul(transform, coord_src[i,:])\n \n return coord_dst\n \n \n def convert_lonlat(self, dates, coord_src, system_src, system_dst, observe_src=None, observe_dst=None, degrees=True):\n \"\"\"\n Function to convert latitudinal coordinates betwen different reference \n frames.\n :param dates: Astropy time object of dates(s).\n :param coord_src: Array of latitudinal coordinates (rad, lon, lat) to convert. Should \n be either a numpy array of len(dates)*3, or a list of floats.\n :param system_src: String name of coordinate system of coord array.\n :param system_dst: String name of coordinate system to transform coord array to.\n :param observe_src: String name of observatory for origin of system from. Only needed for some systems.\n :param observe_dst: String name of observatory for origin of system to. Only needed for some systems.\n :param degrees: Boolean. If true indicates that units of coord_src, and returned coord_dst, are in degrees.\n :return coord_dst: Array, giving state at each dates. Shape of len(dates)x3.\n \"\"\"\n \n # If coordinates input as a list, then bung them into an array.\n if isinstance(coord_src, list):\n if all([isinstance(c, (float, int)) for c in coord_src]):\n coord_src = np.array(coord_src)\n coord_src = np.squeeze(coord_src)\n else:\n print(\"ERROR: coord_src should be a numpy array of coordinates or a list of floats.\")\n \n # If coord only has one dimension, set it so that time is zeroth.\n if coord_src.ndim == 1:\n n_coords = 1\n n_components = coord_src.size\n else:\n n_coords = coord_src.shape[0]\n n_components = coord_src.shape[1]\n \n # Check dates and coord sizes match.\n if dates.size != n_coords:\n print(\"Error: Number of dates does not correspond to number of coordinates.\")\n \n # Check coords have 3 components.\n if n_components != 3:\n print(\"ERROR: Invalid dimension of position vector or state vector\")\n \n if (system_src in ['HPC', 'hpc', 'HPR', 'hpr', 'RTN', 'rtn']) & (observe_src is None):\n print(\"ERROR: system_src given as {}, but no observe_src specified. Assuming Earth\".format(system_src))\n observer_src = 'earth'\n \n if (system_dst in ['HPC', 'hpc', 'HPR', 'hpr', 'RTN', 'rtn']) & (observe_dst is None):\n print(\"ERROR: system_dst given as {}, but no observe_src specified. Assuming Earth\".format(system_dst))\n observer_dst = 'earth'\n \n # Parse out the coordinates.\n if dates.isscalar:\n rad = coord_src[0]\n lon = coord_src[1]\n lat = coord_src[2]\n else:\n rad = np.squeeze(coord_src[:,0])\n lon = np.squeeze(coord_src[:,1])\n lat = np.squeeze(coord_src[:,2])\n \n # Put angles into radians for spice.\n if degrees:\n lon = np.deg2rad(lon)\n lat = np.deg2rad(lat)\n \n if system_src in ['HPC', 'hpc']:\n # Convert to RTN and updates system_src tag\n lon, lat = self.convert_hpc_to_rtn(lon, lat, degrees=False)\n system_src = 'RTN'\n elif system_src in ['HPR', 'hpr']:\n # Convert to HPC and then to RTN, updates system_src tag\n lon, lat = self.convert_hpr_to_hpc(lon, lat, degrees=False)\n lon, lat = self.convert_hpc_to_rtn(lon, lat, degrees=False)\n system_src = 'RTN'\n \n # Now convert to rectangular coords.\n if dates.isscalar:\n coord_src_rec = spice.latrec(rad, lon, lat)\n else:\n # Loop through state to do conversion (as spice.reclat doesn't handle arrays yet)\n coord_src_rec = np.zeros(coord_src.shape, dtype=float)\n for i in range(dates.size):\n coord_src_rec[i,:] = spice.latrec(rad[i], lon[i], lat[i])\n \n # If system_dst was HPC or HPR, do conversion in RTN and apply correction.\n if system_dst in ['HPC', 'hpc']:\n system_dst = 'RTN'\n calc_hpc = True\n else:\n calc_hpc = False\n \n if system_dst in ['HPR', 'hpr']:\n system_dst = 'RTN'\n calc_hpr = True\n else:\n calc_hpr = False\n \n coord_dst_rec = self.convert_coord(dates, coord_src_rec, system_src, \\\n system_dst, observe_src=observe_src, \\\n observe_dst=observe_dst)\n \n # Convert back to latitude coords.\n if dates.isscalar:\n rad_dst, lon_dst, lat_dst = spice.reclat(coord_dst_rec)\n else:\n # Loop through state to do conversion (as spice.reclat doesn't handle arrays yet)\n rad_dst = np.zeros(dates.size, dtype=float)\n lon_dst = np.zeros(dates.size, dtype=float)\n lat_dst = np.zeros(dates.size, dtype=float)\n for i in range(dates.size):\n rad_dst[i], lon_dst[i], lat_dst[i] = spice.reclat(coord_dst_rec[i,:])\n\n # Correct HPC coords if necessary\n if calc_hpc:\n lon_dst, lat_dst = self.convert_rtn_to_hpc(lon_dst, lat_dst, degrees=False)\n \n # Correct HPR coords if necessary\n if calc_hpr:\n lon_dst, lat_dst = self.convert_rtn_to_hpc(lon_dst, lat_dst, degrees=False)\n lon_dst, lat_dst = self.convert_hpc_to_hpr(lon_dst, lat_dst, degrees=False)\n\n # Correct Carrington longitudes if neccesary\n carrington_names = ['CARR', 'CARRINGTON', 'carr', 'carrington']\n if system_dst in carrington_names:\n if dates.size > 1:\n id_under = lon_dst < 0\n if any(id_under):\n lon_dst[id_under] += 2*np.pi\n\n elif dates.size == 1:\n if lon_dst < 0:\n lon_dst += 2*np.pi\n\n if degrees:\n lon_dst = np.rad2deg(lon_dst)\n lat_dst = np.rad2deg(lat_dst)\n\n # Bundle the output into one array.\n if dates.isscalar:\n coord_dst = np.array([rad_dst, lon_dst, lat_dst])\n else:\n rad_dst = np.expand_dims(rad_dst, axis=1)\n lon_dst = np.expand_dims(lon_dst, axis=1)\n lat_dst = np.expand_dims(lat_dst, axis=1)\n coord_dst = np.hstack((rad_dst, lon_dst, lat_dst))\n\n return coord_dst\n \n \n def convert_lat2rec(self, coord_lat, degrees=True):\n \"\"\"\n Function to convert latitudinal coordinates to rectangular coordinates.\n :param coord_lat: Array of latitudinal coordinates (rad, lon, lat) to convert. Should \n be either a numpy array of len(dates)*3, or a list of floats.\n :param degrees: Boolean, True if units is in degrees.\n :return coord_rec: Array, giving position (km) for each latitudinal coordinate. Shape of coord_lat.\n \"\"\"\n \n # If coordinates input as a list, then bung them into an array.\n if isinstance(coord_lat, list):\n if all([isinstance(c, (float, int)) for c in coord_lat]):\n coord_lat = np.array(coord_lat)\n coord_lat = np.squeeze(coord_lat)\n else:\n print(\"ERROR: coord_src should be a numpy array of coordinates or a list of floats.\")\n \n # If coord only has one dimension, set it so that time is zeroth.\n if coord_lat.ndim == 1:\n n_coords = 1\n n_components = coord_lat.size\n else:\n n_coords = coord_lat.shape[0]\n n_components = coord_lat.shape[1]\n \n # Check coords have 3 components.\n if n_components != 3:\n print(\"ERROR: Invalid dimension of position vector or state vector\")\n \n # Get the coordinates.\n if n_coords == 1:\n rad = coord_lat[0]\n lon = coord_lat[1]\n lat = coord_lat[2]\n else:\n rad = np.squeeze(coord_lat[:,0])\n lon = np.squeeze(coord_lat[:,1])\n lat = np.squeeze(coord_lat[:,2])\n \n # Put angles into radians for spice.\n if degrees:\n lon = np.deg2rad(lon)\n lat = np.deg2rad(lat)\n \n # Now convert to rectangular coords.\n if n_coords == 1:\n coord_rec = spice.latrec(rad, lon, lat)\n else:\n # Loop through state to do conversion (as spice.reclat doesn't handle arrays yet)\n coord_rec = np.zeros(coord_lat.shape, dtype=float)\n for i in range(n_coords):\n coord_rec[i,:] = spice.latrec(rad[i], lon[i], lat[i])\n \n return coord_rec\n \n \n def convert_rec2lat(self, coord_rec, degrees=True):\n \"\"\"\n Function to convert rectangular coordinates to latitudinal coordinates.\n :param coord_rec: Array of rectangular coordinates (in km) to convert. Should \n be either a numpy array of len(dates)*3, or a list of floats.\n :param degrees: Boolean, True if units of latitudinal coords should be in degrees.\n :return coord_lat: Array, giving latitudinal position for each rectangular coord. Shape of coor_rec.\n \"\"\"\n \n # If coordinates input as a list, then bung them into an array.\n if isinstance(coord_rec, list):\n if all([isinstance(c, (float, int)) for c in coord_rec]):\n coord_rec = np.array(coord_rec)\n coord_rec = np.squeeze(coord_rec)\n else:\n print(\"ERROR: coord_src should be a numpy array of coordinates or a list of floats.\")\n \n # If coord only has one dimension, set it so that time is zeroth.\n if coord_rec.ndim == 1:\n n_coords = 1\n n_components = coord_rec.size\n else:\n n_coords = coord_rec.shape[0]\n n_components = coord_rec.shape[1]\n \n # Check coords have 3 components.\n if n_components != 3:\n print(\"ERROR: Invalid dimension of position vector or state vector\")\n \n # Now convert to latitudinal coords\n if n_coords == 1:\n coord_lat = spice.reclat(coord_rec)\n else:\n # Loop through state to do conversion (as spice.reclat doesn't handle arrays yet)\n coord_lat = np.zeros(coord_rec.shape, dtype=float)\n for i in range(n_coords):\n coord_lat[i,:] = spice.reclat(coord_rec[i,:])\n \n if degrees:\n if n_coords == 1:\n coord_lat[1:] = np.rad2deg(coord_lat[1:])\n else:\n coord_lat[:,1:] = np.rad2deg(coord_lat[:,1:])\n \n return coord_lat\n \n \n def get_naif_body_code(self, body):\n \"\"\"\n Function to return the numeric NAIF body code of a spacecraft or solar system body.\n :param body: String name of solar system body or spacecraft\n :return naif_body: String of numeric NAIF body code, fit for use with spiceypy\n \"\"\"\n\n # Get set of pseudonyms for stereo a and stereo b and Earth\n sta_names = {'A', 'sta', 'STA', 'Ahead', 'STEREO Ahead', 'STEREO-Ahead', 'STEREO_Ahead', '-234', -234}\n stb_names = {'B', 'stb', 'STB', 'Behind', 'STEREO Behind', 'STEREO-Behind', 'STEREO_Behind', '-235', -235}\n sun_names = {'S', 'Sun', 'sun', 'SUN', '10', 10}\n mercury_names = {'Mercury', 'mercury', 'MERCURY', '199', 199}\n venus_names = {'Venus', 'venus', 'VENUS', '299', 299}\n earth_names = {'E','Earth', 'earth', 'EARTH', 'ERT', 'ert', '399', 399}\n moon_names = {'Moon', 'moon', 'Moon', '301', 301}\n mars_names = {'Mars', 'mars', 'MARS', '499', 499}\n # Get NAIF code of user input observatory\n if body in sta_names:\n naif_body = '-234'\n elif body in stb_names:\n naif_body = '-235'\n elif body in sun_names:\n naif_body = '10'\n elif body in mercury_names:\n naif_body = '199'\n elif body in venus_names:\n naif_body = '299'\n elif body in earth_names:\n naif_body = '399'\n elif body in moon_names:\n naif_body = '301'\n elif body in mars_names:\n naif_body = '499'\n else:\n print(body)\n print('ERROR: Body name not recognised. Allowed bodies: STA, STB, Sun, Mercury, Venus, Earth, Moon, Mars.\\n\\\n More codes available at Get more codes at http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/FORTRAN/req/naif_ids.html ')\n \n naif_body = 'ERROR'\n\n return naif_body\n \n\n def get_coord(self, dates, target, system, observatory=None, corr='NONE', precess=False, return_ltime=False,\n no_velocity=False):\n \"\"\"\n Function to calculate the coordinates of a spacecraft or solar system body\n :param dates: Astropy time object of dates(s).\n :param target: String name of target body to calculate the position of.\n :param system: String name of coordinate system to calculate position in.\n :param observatory: String name of observatory for origin of coordinate system.\n :param corr: Boolean. If True performs correction for planetary abberation.\n :param precess: Boolean. If True accounts for precession in ..\n :param return_ltime: Boolean. If True also returns light travel time between observatory and target.\n :param no_velocity: Boolean. If True, the velocity components are not returned in the state vector.\n :return state: Array, giving state at each dates. Either len(dates)x3 or len(dates)x6, depending on no_velocity\n :return ltime (optional): The light travel time between observatory and target\n \"\"\"\n # TODO: Add in error checks to make sure target is specified.\n\n # The NAIF codes for stereo a and b are:\n sta_naif_code = '-234'\n stb_naif_code = '-235'\n\n target = self.get_naif_body_code(target)\n\n if observatory is not None:\n observatory = self.get_naif_body_code(observatory)\n\n frame, observatory = self.get_system_frame_names(system, observatory, precess)\n\n # Pull out the max valid ephemeris time for each craft\n if target == sta_naif_code:\n max_dates = self.__PredMaxdates__['sta']\n else:\n max_dates = self.__PredMaxdates__['stb']\n\n # Get ephemeris times for the input dates. If larger than max dates, set to max dates and set correct flag.\n correct_late_times = False\n if dates.isscalar:\n if dates <= max_dates:\n et = [spice.str2et(dates.isot)]\n else:\n et = [spice.str2et(max_dates.isot)]\n correct_late_times = True\n else:\n if all(dates <= max_dates):\n et = spice.str2et(dates.isot.tolist())\n else:\n et = spice.str2et(dates.isot.tolist())\n id_gt_max = dates > max_dates\n et[id_gt_max] = spice.str2et(max_dates.isot)\n correct_late_times = True\n\n # Now add in the calls to spice functions to get the state variables\n # If no velocity, use spkpos.\n if no_velocity:\n state, ltime = spice.spkpos(target, et, frame, corr, observatory)\n # Convert state from list of arrays to numpy array\n state = np.array(state)\n else:\n # Velocity requested. This needs spkezr, which only accepts floats. So loop through et and call spkezr for \n state = np.zeros((dates.size, 6), dtype=float)\n ltime = np.zeros(dates.size, dtype=float)\n for i in range(dates.size):\n state[i, :], ltime[i] = spice.spkezr(target, et[i], frame, corr, observatory)\n\n # Add in correction to get states for times after max ephemeris time using\n # Conics. Loop over entries after maximum time\n if correct_late_times:\n if observatory == sta_naif_code:\n elts = self.__PredConic__['sta']\n elif observatory == stb_naif_code:\n elts = self.__PredConic__['stb']\n\n \n for idt in np.argwhere(id_gt_mxt is True):\n et = spice.str2et(dates.isot[idt])\n temp = spice.conics(elts, et)\n # Updates state with conics estimate.\n if no_velocity:\n state[idt, :] = temp[0:3]\n else:\n state[idt, :] = temp\n\n ltime[idt] = -1\n\n # Now convert updatesd coords from HAE to specified system\n temp = state[:, id_gt_mxt]\n temp = convert_stereo_coord(dates.isot[id_gt_mxt], temp, 'HAE', system)\n state[:, id_gt_mxt] = temp\n \n # If only one date, loose first dimension\n if dates.isscalar:\n state = np.squeeze(state)\n \n if return_ltime:\n return state, ltime\n else:\n return state\n \n\n def get_lonlat(self, dates, target, system, observatory=None, corr='NONE', precess=False, degrees=True):\n \"\"\"\n Function to calculate the radius, longitude and lataitude of a target in coordinate system given by system,\n centered on an observatory. Observatory doesn't always need to be specified, but for some coordinate systems\n needs to be. Doesnt handle velocity components of state vector.\n :param dates: Astropy time object of dates(s) to get\n :param target: String name of target body.\n :param system: String name of coordinate system.\n :param observatory: String name of observatory.\n :param corr: String specifying whether to perform correction for planetary abberation.\n :param precess: Boolean. If true perform a calculation for precession.\n :param degrees: Boolean. If true return latitude and longitude in degrees\n :return coords: Float array of coords.\n \"\"\"\n\n # Add in calculation for Helioprojective Cartesian coordinates.\n if system in ['HPC', 'hpc']:\n system = 'RTN'\n calc_hpc = True\n else:\n calc_hpc = False\n \n if system in ['HPR', 'hpr']:\n system = 'RTN'\n calc_hpr = True\n else:\n calc_hpr = False\n \n # Get the position of the target for this dates/system/observatory\n state = self.get_coord(dates, target, system=system, observatory=observatory, corr=corr, precess=precess,\n no_velocity=True)\n\t\t\n\t\t\n # Use spice to convert to lon/lat\n state = np.array(state)\n \n if state.ndim == 1:\n rad, lon, lat = spice.reclat(state)\n else:\n # Loop through state to do conversion (as spice.reclat doesn't handle arrays yet)\n rad = np.zeros(len(dates), dtype=float)\n lon = np.zeros(len(dates), dtype=float)\n lat = np.zeros(len(dates), dtype=float)\n for i in range(len(dates)):\n rad[i], lon[i], lat[i] = spice.reclat(state[i])\n\n # Correct HPC coords if necessary\n if calc_hpc:\n lon, lat = self.convert_rtn_to_hpc(lon, lat, degrees=False)\n \n if calc_hpr:\n lon, lat = self.convert_rtn_to_hpc(lon, lat, degrees=False)\n lon, lat = self.convert_hpc_to_hpr(lon, lat, degrees=False)\n\n # Correct Carrington longitudes if neccesary\n carrington_names = ['CARR', 'CARRINGTON', 'carr', 'carrington']\n if system in carrington_names:\n if dates.size > 1:\n id_under = lon < 0\n if any(id_under):\n lon[id_under] += 2*np.pi\n\n elif dates.size == 1:\n if lon < 0:\n lon += 2*np.pi\n\n if degrees:\n lon = np.rad2deg(lon)\n lat = np.rad2deg(lat)\n\n # Make state vector with same structure as output by spkpos\n if dates.isscalar:\n coords = np.array([rad,lon,lat]).T\n # If only one date, loose first dimension\n coords = np.squeeze(coords)\n else:\n rad = np.expand_dims(rad, axis=1)\n lon = np.expand_dims(lon, axis=1)\n lat = np.expand_dims(lat, axis=1)\n coords = np.hstack((rad,lon,lat))\n return coords\n \n\n def get_system_frame_names(self, system, observatory=None, precess=False):\n \"\"\"\n Function to return the spice friendly name of the frame relevant for a given coordinate system and observatory.\n For some systems, an observatory must also be specified.\n :param system: String name of the requested coordinate system.\n :param observatory: String name of observatory. Not needed for all systems (e.g HCI or GEO).\n :param precess: Boolean. If true select frame that accounts for precession.\n :return frame: String name of frame in spice friendly format.\n :return observatory: String of observatory in spice friendly format.\n \"\"\"\n \n # Get NAIF codes needed to identify which observatory was parsed.\n sta_naif_code = self.get_naif_body_code('STA')\n stb_naif_code = self.get_naif_body_code('STB')\n sun_naif_code = self.get_naif_body_code('SUN')\n earth_naif_code = self.get_naif_body_code('EARTH')\n \n # If an observatory was parsed, make sure it is in naif format.\n if observatory is not None:\n observatory = self.get_naif_body_code(observatory)\n \n # Get lists of system names and their synonyms\n heeq_names = ['HEQ','HEEQ', 'heq', 'heeq']\n carrington_names = ['CARR', 'CARRINGTON', 'carr', 'carrington']\n hci_names = ['HCI', 'hci']\n hae_names = ['HAE', 'hae']\n hee_names = ['HEE', 'hee']\n hgrtn_names = ['HGRTN', 'hgrtn']\n rtn_names = ['RTN', 'rtn']\n sci_names = ['SCI', 'sci']\n hertn_names = ['HERTN', 'hertn']\n gei_names = ['GEI', 'gei']\n geo_names = ['GEO', 'geo']\n gse_names = ['GSE', 'gse']\n \n # If system is RTN then an observatory should have been specified.\n if (system == 'RTN') & (observatory is None):\n print(\"ERROR: RTN system specified, but no corresponding observatory. Assuming Earth.\")\n observatory = earth_naif_code\n \n # Some systems have defined observatory. Check input observatory doesnt clash with this.\n # Helio systems:\n all_helio = heeq_names + carrington_names + hci_names + hae_names + hee_names + hgrtn_names\n if (system in all_helio) & (observatory not in [None, sun_naif_code]):\n print(\"ERROR: Observatory {0} specified for Sun based system ({1}).\\n\\\n Input observatory will be overridden\".format(observatory, system))\n \n all_geo = gei_names + geo_names + gse_names\n if (system in all_geo) & (observatory not in [None, earth_naif_code]): \n print(\"ERROR: Observatory {0} specified for Earth based system ({1}).\\n\\\n Input observatory will be overridden\".format(observatory, system))\n\n # Find out which coordinate system / frame required\n if system in heeq_names:\n frame = 'HEEQ'\n observatory = 'Sun'\n\n elif system in carrington_names:\n frame = 'IAU_SUN'\n observatory = 'Sun'\n\n elif system in hci_names:\n frame = 'HCI'\n observatory = 'Sun'\n\n elif system in hae_names:\n observatory = 'Sun'\n if precess:\n frame = 'ECLIPdates'\n else:\n frame = 'ECLIPJ2000'\n\n elif system in hee_names:\n frame = 'HEE'\n observatory = 'Sun'\n \n elif system in rtn_names:\n if observatory == sta_naif_code:\n frame = 'STAHGRTN'\n elif observatory == stb_naif_code:\n frame = 'STBHGRTN'\n elif observatory == earth_naif_code:\n frame = 'GEORTN'\n elif observatory == sun_naif_code:\n frame = 'HGRTN'\n \n elif system in hgrtn_names:\n frame = 'HGRTN'\n observatory = 'Sun'\n\n elif system in sci_names:\n # Check observaotry input\n if observatory == sta_naif_code:\n frame = 'STASCPNT'\n elif observatory == stb_naif_code:\n frame = 'STBSCPNT'\n else:\n print('ERROR: INCORRECT SPACECARFT TARGET PARSED')\n\n elif system in hertn_names:\n # Check observatory input\n if observatory == sta_naif_code:\n frame = 'STAHERTN'\n elif observatory == stb_naif_code:\n frame = 'STBHERTN'\n else:\n print('ERROR: INCORRECT SPACECARFT TARGET PARSED')\n\n elif system in gei_names:\n frame = 'J200'\n observatory = 'Earth'\n\n elif system in geo_names:\n frame = 'J200'\n observatory = 'Earth'\n\n elif system in gse_names:\n frame = 'GSE'\n observatory = 'Earth'\n else:\n print(\"ERROR: System not recognised\")\n\n return frame, observatory\n \n\n def clear_kernals(self):\n \"\"\"\n A function to clear out the loaded spice kernals.\n :return:\n \"\"\"\n spice.kclear()\n return\n ", "meta": {"hexsha": "6a9c1f3d2be479da6266046c5f889802f8a15d73", "size": 45572, "ext": "py", "lang": "Python", "max_stars_repo_path": "stereo_spice/coordinates.py", "max_stars_repo_name": "LukeBarnard/stereo_spice", "max_stars_repo_head_hexsha": "6944d2a3225ada4d9c062bdfa048dc3632a81dc6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "stereo_spice/coordinates.py", "max_issues_repo_name": "LukeBarnard/stereo_spice", "max_issues_repo_head_hexsha": "6944d2a3225ada4d9c062bdfa048dc3632a81dc6", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "stereo_spice/coordinates.py", "max_forks_repo_name": "LukeBarnard/stereo_spice", "max_forks_repo_head_hexsha": "6944d2a3225ada4d9c062bdfa048dc3632a81dc6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.9114877589, "max_line_length": 135, "alphanum_fraction": 0.5777670499, "include": true, "reason": "import numpy,from astropy", "num_tokens": 10484, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5926666143433998, "lm_q2_score": 0.32082129433083023, "lm_q1q2_score": 0.19014007032032054}} {"text": "\"\"\"\n\n\"\"\"\n\nimport datetime\nimport numpy as np\nimport scipy.stats as ss\nimport configparser\nimport sys\n\nclass TimingError(Exception):\n def __init__(self, starttime, stoptime, index):\n self.index = index\n self.start = starttime\n self.stop = stoptime\n self.dateformat = \"%Y-%m-%d %H:%M:%S\"\n\n\nclass AEPcounter:\n \"\"\"\n set of functions to calculate AEP losses from structured data\n \"\"\"\n def __init__(self):\n \"\"\"\n Initialize all relevant variables to some values. These need to be set\n based on the structure of the actual data\n\n wind_bins and direction_bins contain the CENTERS of bins\n\n \"\"\"\n self.id = '' # data id used to id the data\n self.ts_index = 0 # column of TIMESTAMP in source data\n self.ws_index = 1 # column of WIND SPEED in source data\n self.wd_index = 2 # column of WIND DIRECTION index in source data\n self.temp_index = 3 # column of TEMPERATURE in source data\n self.pow_index = 4 # column of POWER in source data\n self.state_index = [5] # column of TURBINE STATE INFORMATION\n self.normal_state = [0] # normal/default value of state variable\n self.wind_bins = np.arange(0, 20, 1) # wind speed binning\n self.direction_bins = np.arange(0, 360, 360) # wind direction binning\n self.rated_power = 1.0 # rated power of the turbine (1.0 if power given as relative to rated power)\n self.icing_time = 3 # icing length in samples for now\n self.stop_time = 6 # time filter for stops in number of samples\n self.pc_low_limit = 10 # lower limit for power curve checks\n self.pc_high_limit = 90 # lower limit for power curve checks\n self.stop_level = 0.005 # level used to define stops\n self.state_filter_type = 1 # type 1 inclusive 2 exclusive\n self.power_level_filter_limit = 0.01 # limit for self.power_level_filter\n self.reference_temperature_limit = 3\n self.icing_temperature_limit = 3\n self.pc_binsize = 36 # bin size filter for power curve\n self.pc_dist_filter = True # filter out obviously wrong values from power curves.\n self.site_elevation = 0.0\n self.fault_dict = {} # used in case fault codes need to be replaced very non-elegant solution, but...\n self.result_dir = '.'\n self.starttimestamp = datetime.datetime.min\n self.stoptimestamp = datetime.datetime.max\n self.stopcodes = [] # status codes for icing related stops\n self.stop_filter_type = 0 # 0 for power level based 1 for status code based where stop if true 2 for stop if false\n self.status_stop_index = None\n self.heated_site = False\n self.ice_detection = False\n self.ice_alarm_index = 0\n self.ice_alarm_value = 0\n self.heating_status_index = 0\n self.heating_status_value = 0\n self.heating_status_type = 0\n self.heating_power_index = 0\n self.replace_faults = False\n self.fault_columns = []\n # TODO:\n # fix icing and stoptime to be actual minutes instead of sample count\n\n def get_fallback_value(self, section, config_var):\n \"\"\"\n Helper function used when reading .ini files. Sets non-mandatory values to common fallback settings\n :param section, where config_var is defined\n :param config_var:\n :return: fallback value\n \"\"\"\n # so far all config var names are unique, no need to split this by section yet, do it anyway\n if section == 'Source file':\n sf_fallbacks = {'delimiter': ',',\n 'quotechar': 'NONE',\n 'datetime format': '%Y-%m-%d %H:%M:%S',\n 'datetime extra char': '0',\n 'replace fault codes': 'False'}\n return sf_fallbacks[config_var]\n elif section == 'Output':\n o_fallbacks = {'result directory': '.',\n 'summary': 'True',\n 'plot': 'True',\n 'alarm time series': 'True',\n 'filtered raw data': 'True',\n 'icing events': 'False','power curve': 'True'}\n return o_fallbacks[config_var]\n elif section == 'Data Structure':\n # these are all mandatory, except this one, it needs a fallback to maintain compatibility with old inifiles\n # need to define this anyway\n ds_fallbacks = {\"status code stop value\": '0',\n \"status index\": '-1'}\n return ds_fallbacks[config_var]\n elif section == 'Icing':\n # icing is not mandatory anyway\n i_fallbacks = {}\n return None\n elif section == 'Binning':\n b_fallbacks = {'minimum wind speed': '0',\n 'maximum wind speed': '20',\n 'wind speed bin size': '1',\n 'wind direction bin size': '360'}\n return b_fallbacks[config_var]\n elif section == 'Filtering':\n f_fallbacks = {'power drop limit': '10',\n 'overproduction limit': '90',\n 'power level filter': '0.01',\n 'temperature filter': '1',\n 'reference temperature': '3',\n 'icing time': '3',\n 'stop filter type': '0',\n 'stop limit multiplier': '0.005',\n 'stop time filter': '6',\n 'statefilter type': '1',\n 'min bin size': '36',\n 'distance filter': 'True',\n 'start time': 'None',\n 'stop time': 'None'}\n return f_fallbacks[config_var]\n else:\n print('section \"{0}\" does not exist in config file'.format(section))\n sys.exit(1)\n\n\n def set_data_options_from_file(self,filename):\n \"\"\"\n read in configuration settings from a config file\n \"\"\"\n config = configparser.ConfigParser()\n config.read(filename)\n try:\n self.ts_index = int(config.get('Data Structure','timestamp index'))\n self.ws_index = int(config.get('Data Structure','wind speed index'))\n self.wd_index = int(config.get('Data Structure','wind direction index'))\n self.temp_index = int(config.get('Data Structure','temperature index'))\n self.pow_index = int(config.get('Data Structure','power index'))\n self.rated_power = float(config.get('Data Structure','rated power'))\n state_index_raw = config.get('Data Structure','state index')\n self.state_index = [int(column_index) for column_index in state_index_raw.split(',')]\n self.site_elevation = float(config.get('Data Structure','site elevation'))\n stop_codes_raw = config.get('Data Structure', 'status code stop value', fallback=self.get_fallback_value('Data Structure', 'status code stop value'))\n normal_state_raw = config.get('Data Structure','normal state')\n # normal state can be given as text or as a list of codes, all cases need to be sorted\n self.replace_faults = config.getboolean('Source file','replace fault codes')\n if self.replace_faults: # fault codes as text\n fault_codes = [self.replace_faultcode(codestring) for codestring in normal_state_raw.split(',')]\n stop_code_values = [self.replace_faultcode(stop_code_string) for stop_code_string in stop_codes_raw.split(',')]\n else:\n fault_codes = [int(code) for code in normal_state_raw.split(',')]\n stop_code_values = [int(stop_code) for stop_code in stop_codes_raw.split(',')]\n self.normal_state = fault_codes\n self.stopcodes = stop_code_values\n self.id = config.get('Source file','id')\n self.result_dir = config.get('Output', 'result directory', fallback=self.get_fallback_value('Output','result directory'))\n status_stops_raw = config.get('Data Structure', 'status index', fallback=self.get_fallback_value('Data Structure', 'status index'))\n self.status_stop_index = [int(code) for code in status_stops_raw.split(',')]\n fault_column_string = config.get('Source file','fault columns')\n self.fault_columns = [int(column_index) for column_index in fault_column_string.split(',')]\n except configparser.NoOptionError as missing_value:\n print(\"missing config option in {0}: {1}\".format(filename, missing_value))\n sys.exit(1)\n except configparser.NoSectionError as missing_section:\n print(\"missing config section in {0}: {1}\".format(filename, missing_section))\n sys.exit(1)\n except ValueError as wrong_value:\n print(\"Wrong type of value in {0}: {1}\".format(filename, wrong_value))\n sys.exit(1)\n\n def replace_faultcode(self, code):\n \"\"\"\n Replace textual fault_code with a value from fault_dict. If the wanted faultcode is not in fault_dict,\n add it as a new maximum value into it and then return the new replacement value.\n\n :param code:\n :return the replacement fault code:\n \"\"\"\n\n if code in self.fault_dict:\n return self.fault_dict[code]\n else:\n self.fault_dict[code] = max(self.fault_dict.values()) + 1\n return self.fault_dict[code]\n\n def set_binning_options_from_file(self, filename):\n \"\"\"\n set bin division based on a config file\n \"\"\"\n config = configparser.ConfigParser()\n config.read(filename)\n if config.has_section('Binning'):\n try:\n min_windbin = float(config.get('Binning', 'minimum wind speed', fallback=self.get_fallback_value('Binning', 'minimum wind speed')))\n max_windbin = float(config.get('Binning', 'maximum wind speed', fallback=self.get_fallback_value('Binning', 'maximum wind speed')))\n windbin_width = float(config.get('Binning', 'wind speed bin size', fallback=self.get_fallback_value('Binning', 'wind speed bin size')))\n directionbin_width = float(config.get('Binning', 'wind direction bin size', fallback=self.get_fallback_value('Binning', 'wind direction bin size')))\n self.wind_bins = np.arange(min_windbin, max_windbin, windbin_width)\n self.direction_bins = np.arange(0,360,directionbin_width)\n except configparser.NoOptionError as missing_value:\n print(\"missing config option in {0}: {1}\".format(filename, missing_value))\n sys.exit(1)\n except ValueError as wrong_value:\n print(\"Wrong type of value in {0}: {1}\".format(filename, wrong_value))\n sys.exit(1)\n else:\n print(\"No binning options set, using defaults\")\n\n def set_filtering_options_from_file(self, filename):\n \"\"\"\n set filtering options based on a config file\n \"\"\"\n config = configparser.ConfigParser()\n config.read(filename)\n if config.has_section('Filtering'):\n try:\n self.pc_low_limit = int(config.get('Filtering', 'power drop limit', fallback=self.get_fallback_value('Filtering', 'power drop limit')))\n self.pc_high_limit = int(config.get('Filtering', 'overproduction limit', fallback=self.get_fallback_value('Filtering', 'overproduction limit')))\n self.icing_time = int(config.get('Filtering', 'icing time', fallback=self.get_fallback_value('Filtering', 'icing time')))\n self.stop_level = float(config.get('Filtering', 'stop limit multiplier', fallback=self.get_fallback_value('Filtering', 'stop limit multiplier')))\n self.stop_time = int(config.get('Filtering', 'stop time filter', fallback=self.get_fallback_value('Filtering', 'stop time filter')))\n self.state_filter_type = int(config.get('Filtering', 'statefilter type', fallback=self.get_fallback_value('Filtering', 'statefilter type')))\n self.pc_binsize = int(config.get('Filtering', 'min bin size', fallback=self.get_fallback_value('Filtering', 'min bin size')))\n self.pc_dist_filter = config.getboolean('Filtering', 'distance filter', fallback=self.get_fallback_value('Filtering', 'distance filter'))\n self.power_level_filter_limit = float(config.get('Filtering', 'power level filter', fallback=self.get_fallback_value('Filtering', 'power level filter')))\n self.icing_temperature_limit = float(config.get('Filtering', 'temperature filter', fallback=self.get_fallback_value('Filtering', 'temperature filter')))\n self.reference_temperature_limit = float(config.get('Filtering', 'reference temperature', fallback=self.get_fallback_value('Filtering', 'reference temperature')))\n self.stop_filter_type = int(config.get('Filtering', 'stop filter type', fallback=self.get_fallback_value('Filtering', 'stop filter type')))\n dt_format = config.get('Source file', 'datetime format', raw=True, fallback=self.get_fallback_value('Source file', 'datetime format'))\n starttime_str = config.get('Filtering', 'Start time', fallback=self.get_fallback_value('Filtering', 'start time'))\n if starttime_str.upper() != 'NONE':\n self.starttimestamp = datetime.datetime.strptime(starttime_str, dt_format)\n stoptime_str = config.get('Filtering', 'Stop time', fallback=self.get_fallback_value('Filtering', 'stop time'))\n if stoptime_str.upper() != 'NONE':\n self.stoptimestamp = datetime.datetime.strptime(stoptime_str, dt_format)\n\n except configparser.NoOptionError as missing_value:\n print(\"missing config option in {0}: {1}\".format(filename, missing_value))\n sys.exit(1)\n except ValueError as wrong_value:\n print(\"Wrong type of value in {0}: {1}\".format(filename, wrong_value))\n sys.exit(1)\n\n def set_ips_options_from_file(self, filename):\n \"\"\"\n set config options for a heated site, first check if \"Icing\" section even exists, then set the options\n \"\"\"\n config = configparser.ConfigParser()\n config.read(filename)\n if config.has_section('Icing'):\n try:\n self.heated_site = config.getboolean(\"Icing\",\"heating\")\n self.ice_detection = config.getboolean(\"Icing\",\"ice detection\")\n self.ice_alarm_index = int(config.get(\"Icing\",\"icing alarm index\"))\n if self.replace_faults and (self.ice_alarm_index in self.fault_columns):\n ice_alarm_raw = config.get(\"Icing\", \"icing alarm code\")\n self.ice_alarm_value = self.fault_dict[ice_alarm_raw]\n else:\n self.ice_alarm_value = int(config.get(\"Icing\", \"icing alarm code\"))\n heating_index_raw = config.get(\"Icing\",\"ips status index\")\n heating_value_raw = config.get(\"Icing\",\"ips status code\")\n self.heating_status_index = [int(code) for code in heating_index_raw.split(',')]\n if self.replace_faults and any({*self.heating_status_index} & {*self.fault_columns}): # status codes as text\n self.heating_status_value = [self.fault_dict[codestring] for codestring in heating_value_raw.split(',')]\n else:\n self.heating_status_value = [int(code) for code in heating_value_raw.split(',')]\n\n self.heating_status_type = int(config.get(\"Icing\",\"ips status type\"))\n self.heating_power_index = int(config.get(\"Icing\",\"ips power consumption index\"))\n except configparser.NoOptionError as missing_value:\n print(\"missing config option in {0}: {1}\".format(filename, missing_value))\n sys.exit(1)\n except configparser.NoSectionError as missing_section:\n print(\"missing config section in {0}: {1}\".format(filename, missing_section))\n sys.exit(1)\n except ValueError as wrong_value:\n print(\"Wrong type of value in {0}: {1}\".format(filename, wrong_value))\n sys.exit(1)\n else:\n print(\"no [Icing] section in {0}, ignoring IPS options\".format(filename))\n\n def state_filter_data(self, data):\n \"\"\"\n remove all data where the state variable is something else than normal_state\n correct state variable values depend on turbine type\n if exclude set to true, remove all lines where state==normal_state\n exclude is set in a class variable\n\n if state_filter_type == 3 filter removes data below a certain threshold\n threshold is set in normal_state\n state filter type 3 is used in case there is no explicit turbine state and the\n filtering has to be done using output power or such\n\n\n :param data: data to be filtered\n :return: filtered data with the filterd liens removed\n \"\"\"\n\n if self.state_filter_type == 2:\n exclude = True\n else:\n exclude = False\n\n #if exclude:\n #return data[data[:, self.state_index] != self.normal_state, :]\n #return np.array([line for line in data if line[self.state_index] not in self.normal_state])\n #else:\n #return data[data[:, self.state_index] == self.normal_state, :]\n #return np.array([line for line in data if line[self.state_index] in self.normal_state])\n #TODO:\n # fix this mess, remove exclude from where it iss and have all filter type switches in the same place\n filtered_data = []\n for line in data:\n # state_vals = [line[i] for i in self.state_index]\n # state_val_check = all([j in self.normal_state for j in state_vals]) # if all in state_vals are in normal state evaluates as True\n state_val_check_vars = []\n for normal_state_index,value_index in enumerate(self.state_index):\n if self.state_filter_type == 3:\n state_val_check_vars.append(line[value_index] >= self.normal_state[normal_state_index])\n elif self.state_filter_type == 4:\n state_val_check_vars.append(line[value_index] <= self.normal_state[normal_state_index])\n else:\n state_val_check_vars.append(line[value_index] == self.normal_state[normal_state_index])\n state_val_check = all(state_val_check_vars)\n if exclude:\n if not state_val_check:\n filtered_data.append(line)\n else:\n if state_val_check:\n filtered_data.append(line)\n return np.array(filtered_data)\n\n def temperature_filter_data(self, data):\n \"\"\"\n remove all data points with temperature below set threshold\n\n :param data: input data\n :return: data set containing only the data in previously specified range\n \"\"\"\n # suppress the runtimewarning caused by nans in data\n # the result is what we want: nans case the comparison to evaluate as false\n with np.errstate(invalid = 'ignore'):\n return data[data[:, self.temp_index] >= self.reference_temperature_limit, :]\n\n def power_level_filter(self, data):\n \"\"\"\n remove all data points where power is below the wanted limit level\n\n limit is defined as percentage of rated power\n\n :param data: unfiltered input data\n :param limit_level: filtering level as fraction of rated\n :return: data with the unwanted timestamps removed\n \"\"\"\n # suppress the runtimewarning caused by nans in data\n # the result is what we want: nans case the comparison to evaluate as false\n with np.errstate(invalid = 'ignore'):\n return data[data[:, self.pow_index] >= (self.power_level_filter_limit * self.rated_power), :]\n\n def wind_speed_filter(self,data,limit_level):\n \"\"\"\n remove all data points with wind speed below a preset level\n\n :param data: original data\n :param limit_level: filtering level\n :return: filtered data\n \"\"\"\n # suppress the runtimewarning caused by nans in data\n # the result is what we want: nans case the comparison to evaluate as false\n with np.errstate(invalid = 'ignore'):\n return data[data[:, self.ws_index] >= limit_level, :]\n\n def time_filter_data(self, data):\n \"\"\"\n\n :param data: the data to be filtered\n :param start: start time as datetime.datetime\n :param stop: stop time as datetime.datetime\n :return: filtered dataset\n \"\"\"\n return data[np.logical_and(data[:, self.ts_index] >= self.starttimestamp, data[:, self.ts_index] < self.stoptimestamp), :]\n\n\n def expand_array(self, arr, n):\n \"\"\"\n add n columns to the right-hand side of a numpy ndarray\n used for bin indices when binning data\n\n :param arr: original array\n :param n: number column to be added\n :return: appended array\n \"\"\"\n for i in range(n):\n arr = np.c_[arr, np.zeros(np.shape(arr)[0])]\n return arr\n\n def bin_measurement(self, data, bin_centers, comp_column, bin_index_column, direction=False):\n \"\"\"\n puts a measurement into an appropriate bin\n\n :param data: contains a single line of measurements\n :param bin_centers: a numpy.ndarray containing centerpoints of the bin division\n :param comp_column: column index of the variable used for binning e.g.\n wind speed index when searching for the appropriate wind speed bin\n\n :param bin_index_column: column index where bin indexes are stored\n :return: parameter data with the bin index appended\n\n \"\"\"\n if direction:\n value = data[comp_column]\n x = np.cos(np.radians(value))\n y = np.sin(np.radians(value))\n bin_x = np.cos(np.radians(bin_centers))\n bin_y = np.sin(np.radians(bin_centers))\n bin_index = np.sqrt((x-bin_x)**2+(y-bin_y)**2).argmin()\n data[bin_index_column] = bin_index\n else:\n data[bin_index_column] = abs(float(data[comp_column])-bin_centers).argmin()\n return data\n\n def wind_dir_mean(self,a):\n \"\"\"\n calculates the mean of wind direction measurements contained in array data\n\n :param a: array of wind direction measurements in degrees\n :return: mean of the array\n \"\"\"\n y = []\n x = []\n for item in a:\n if not np.isnan(item):\n y.append(np.sin(np.radians(item)))\n x.append(np.cos(np.radians(item)))\n\n if np.size(y) == 0 or np.size(x) == 0:\n return np.nan\n else:\n my = np.nanmean(y)\n mx = np.nanmean(x)\n angle = np.degrees(np.arctan2(my,mx))\n\n #wd_mean = np.remainder(360.0 + np.degrees(np.arctan2(my,mx)),360.0)\n wd_mean = (angle +360) % 360\n #print((mx,my,wd_mean))\n return wd_mean\n\n def put_data_into_bins(self, data, bins, comp_column,direction=False):\n \"\"\"\n Bins into externally defined set of bins. Adds a column to the data matrix containing a bin index.\n After this contents of any bin can be found using features of a numpy.ndarray\n\n Example:\n we need contents of bin number 7. This is returned by\n data[data[:,-1]==7,:]\n\n\n :param data: original data that needs to be separated in to bins. A numpy.ndarray\n :param bins: center points of the bins\n :param comp_column: column in the data containing the value used for binning\n (wind speed index when binning by wind speed)\n\n :return: expanded array, contains the original data and one additional\n column that contains a bin index for each line\n\n \"\"\"\n binned_data = []\n exp_data = self.expand_array(data, 1)\n for line in exp_data:\n if direction:\n binned_data.append(self.bin_measurement(line, bins, comp_column, -1,True))\n else:\n binned_data.append(self.bin_measurement(line, bins, comp_column, -1))\n return np.array(binned_data)\n\n def fetch_bin_contents_2d(self, data, bin_index1, bin_number1, bin_index2, bin_number2):\n \"\"\"\n returns the contents of a particular bin in case that data is binned according to two different variables\n for example wind speed and direction\n\n :param data: binned data wind bin indexes\n :param bin_index1: column where the first bin index is found\n :param bin_number1: requested bin on the first bin index\n :param bin_index2: column where the second bin index is found\n :param bin_number2: requested bin on the second bin index\n :return: slice of the data containing the contents of the wanted bin\n \"\"\"\n return data[np.logical_and(data[:, bin_index1] == bin_number1, data[:, bin_index2] == bin_number2), :]\n\n def nan_helper(self, y):\n \"\"\"\n Helper to handle indices and logical indices of NaNs.\n\n | Input:\n | - y, 1d numpy array with possible NaNs\n | Output:\n | - nans, logical indices of NaNs\n | - index, a function, with signature indices= index(logical_indices),\n | to convert logical indices of NaNs to 'equivalent' indices\n | Example:\n | # linear interpolation of NaNs\n | nans, x= nan_helper(y)\n | y[nans]= np.interp(x(nans), x(~nans), y[~nans])\n\n :param y: input array\n :return: converted array\n \"\"\"\n\n return np.isnan(y), lambda z: z.nonzero()[0]\n\n def interpolate_over_nans(self, pc):\n \"\"\"\n helper function to interpolate over possible nan values in power curves caused by empty bins\n during binning\n input is a single power curve i.e. 2d matrix of wind speed versus power\n\n :param pc: power curve matrix as returned by self.count_power_curves\n :return: interpolated power curves\n \"\"\"\n nans, x = self.nan_helper(pc)\n pc[nans] = np.interp(x(nans), x(~nans), pc[~nans])\n return pc\n\n def distance_to_neighbours(self, pc, speed_bin, direction_bin, variable_index):\n \"\"\"\n helper function used in power curve post-processing:\n calculates the mean distance of point at index in different curves stored in data\n Operates only on one bin at a time.\n requires power curves divided according to wind speed and direction\n\n :param pc: original dataset containing the power curves as defined by count_power_curves function\n :param speed_bin: index of active wind speed bin\n :param direction_bin: index of active wind direction bin\n :param variable_index: processed variable. usually power\n :return: mean distance to all other power curves in the particular bin\n \"\"\"\n (x, y, z) = np.shape(pc)\n # reduce the dimension\n targets = pc[speed_bin, :, variable_index]\n distances = []\n neighbours = np.ones(y).astype('bool')\n neighbours[direction_bin] = False\n distances.append(np.abs(targets[neighbours]-targets[direction_bin]))\n if len(distances) == 0:\n return 0.0\n else:\n return np.nanmean(np.array(distances))\n\n def distance_filter(self, pc, target_value):\n \"\"\"\n calculate distances between different power curves,\n if value is dramatically different replace with mean of all others\n goes through all curves bin by bin\n can be useful to automatically weed out outliers in the data\n\n :param pc: prefilterd power curves\n :param target_value: index of the value used for filtering e.g. power\n :return: fltered power curve matrix\n\n \"\"\"\n (x, y, z) = np.shape(pc)\n value_filter = 2.5\n for speed_bin in range(x):\n mean_distances = np.zeros(y)\n for direction_bin in range(y):\n mean_distances[direction_bin] = self.distance_to_neighbours(pc, speed_bin, direction_bin, target_value)\n med_dist = np.nanmedian(mean_distances)\n bad_values = []\n for index,value in enumerate(mean_distances):\n if (value/med_dist) > value_filter:\n bad_values.append(index)\n\n neighbours = np.ones(y).astype('bool')\n neighbours[bad_values] = False\n # print(\"{0}: {1}\".format(speed_bin,bad_values))\n mpc = self.mean_power_curve(pc[:, neighbours,:])\n for value in bad_values:\n pc[speed_bin, value, target_value] = mpc[speed_bin, target_value]\n return pc\n\n def diff_filter(self,data,diff_limit=0.001):\n \"\"\"\n appplies a filter to data that discards all values that differ less than diff_limit from the previous one\n :param data:\n :param diff_limit:\n :return:\n \"\"\"\n data_diff = np.diff(data[:,self.pow_index]) # start with power\n data_diff = np.hstack((np.array(0), data_diff))\n mask = data_diff > diff_limit\n return data[mask,:]\n\n def bin_size_filter(self, pc, size_limit):\n \"\"\"\n bin size based filtering for the power curve\n removes all data from the bin if not enough values available\n\n :param pc: power curve matrix\n :param size_limit: number of measurements required for the bin to be used\n :return: a boolean matrix that can be used to mark too small bin as empty\n \"\"\"\n\n (x, y, z) = np.shape(pc)\n too_smalls = np.zeros(np.shape(pc)).astype('bool')\n for speed_bin in range(x):\n for direction_bin in range(y):\n if pc[speed_bin, direction_bin, 7] < size_limit:\n too_smalls[speed_bin, direction_bin, 2] = True\n too_smalls[speed_bin, direction_bin, 3] = True\n too_smalls[speed_bin, direction_bin, 4] = True\n too_smalls[speed_bin, direction_bin, 5] = True\n too_smalls[speed_bin, direction_bin, 6] = True\n too_smalls[speed_bin, direction_bin, 8] = True\n too_smalls[speed_bin, direction_bin, 9] = True\n return too_smalls\n\n def theoretical_output_power(self, data, power_curves):\n \"\"\"\n calculates the theoretical, expected output power based on power curve and measured wind speed\n\n :param data:\n :param power_curve:\n :return: rerference power, in structure [timestamp, interpolated reference power, actual measured output power]\n \"\"\"\n reference = []\n time_limited_data = self.time_filter_data(data)\n for line in time_limited_data:\n dirbin = np.argmin(np.abs(self.direction_bins - line[self.wd_index]))\n int_pow = np.interp(line[self.ws_index], power_curves[:, dirbin, 0], power_curves[:, dirbin, 2])\n int_pow_p10 = np.interp(line[self.ws_index], power_curves[:, dirbin, 0], power_curves[:, dirbin, 3])\n int_pow_p90 = np.interp(line[self.ws_index], power_curves[:, dirbin, 0], power_curves[:, dirbin, 4])\n uncert_lower_lim = np.interp(line[self.ws_index], power_curves[:, dirbin, 0], power_curves[:, dirbin, 8])\n uncert_upper_lim = np.interp(line[self.ws_index], power_curves[:, dirbin, 0], power_curves[:, dirbin, 9])\n reference.append((line[self.ts_index], int_pow, line[self.pow_index], int_pow_p10, int_pow_p90, uncert_lower_lim, uncert_upper_lim))\n return np.array(reference)\n\n def calculate_production(self,data,index,delta=datetime.timedelta(seconds=10*60)):\n \"\"\"\n calculates total production between from previous time stamp to current, assuming the difference is constant\n skips all occurrences where the difference between two adjacent timestamps is not constant\n\n NOTE: assumes timestamp is at index 0\n\n :param data: input data, containing the measured output\n :param index: index of the production measurement\n :param delta: difference between two timestamps defaults to ten minutes\n :return: structure containing [end timestep, production]\n \"\"\"\n output_data = []\n for i in range(len(data)):\n if i != 0:\n # integrity check\n if ((data[i,0] - data[i-1,0]) > delta) or np.isnan(data[i,index]) or np.isnan(data[i-1,index]) or (data[i,index] <=0.0) or (data[i-1,index] <= 0.0):\n prod = 0\n else:\n dur = (data[i,0]-data[i-1,0]).total_seconds()/60.0/60.0 # length in hours\n pow_at_start = data[i-1,index]\n pow_at_stop = data[i,index]\n prod = dur * ((pow_at_start+pow_at_stop) / 2.0)\n output_data.append((data[i,0],prod))\n output_datalen = len(output_data)\n return np.array(output_data)\n\n def count_power_curves(self, data):\n \"\"\"\n Calculates a set of power curves from the input data\n bins the data according to wind speed and direction\n the binning and the column indexes of the data are defined in the class variables\n\n Power curves contain the power curve and the P10 limit for said curve separately\n for each wind direction defined in the wind direction binning.\n\n output is three dimensional array containing:\n\n * median wind speed\n * median wind direction\n * P10 value\n * bin size (number of measurements in this particular bin)\n\n for each speed and direction defined in self.wind_bins and self_direction bins\n\n missing data (empty bins) are marked as nan\n missing values can then be interpolated over so that there are no empty bins.\n\n Also possible to do other kinds of filtering to improve the end result and to reduce the\n impact of outliers in the data\n\n Method automatically filters the data according to elsewhere defined state variable filter\n (is this a good idea???)\n\n Only part of data where temperature is more than 3 degrees is used to make the power curves\n\n :param data: input data time series. can be unfiltered\n :param temperature_filter_level: temperature in degrees, all data with temperatures above this level are used to build the reference dataset\n :param lower_limit: percentile used as limit for power reduction (default 10)\n :param upper_limit: percentile used as limit for overproduction (default 90)\n :return pc: a numpy.ndarray that contains the power curves, warning limits and bin sizes for each bin,\n sorted by wind speed and direction\n\n \"\"\"\n # direction_bins = np.array([0])\n # st_data = self.state_filter_data(data, self.normal_state)\n # ref_data = self.temperature_filter_data(data, temperature_filter_level)\n pc = np.zeros((len(self.wind_bins), len(self.direction_bins), 10))\n dir_data = self.put_data_into_bins(data, self.direction_bins, self.wd_index,direction=True)\n binned_data = self.put_data_into_bins(dir_data, self.wind_bins, self.ws_index)\n wind_speed_index = 0\n wind_dir_index = 1\n power_index = 2\n low_limit_index = 3\n high_limit_index = 4\n bin_standard_dev_index = 5\n bin_uncertainty = 6\n bin_uncertainty_lower_lim_index = 8\n bin_uncertainty_upper_lim_index = 9\n bin_size_index = 7\n #print(binned_data)\n for speed_bin_index in range(len(self.wind_bins)):\n for direction_bin_index in range(len(self.direction_bins)):\n bin_contents = self.fetch_bin_contents_2d(binned_data, -1, speed_bin_index, -2, direction_bin_index)\n if bin_contents.size == 0:\n pc[speed_bin_index, direction_bin_index, wind_speed_index] = self.wind_bins[speed_bin_index]\n pc[speed_bin_index, direction_bin_index, wind_dir_index] = self.direction_bins[direction_bin_index]\n # force power to be 0 at wind speed 0, helps with interpolation\n # and other tricks used to cover missing data\n if speed_bin_index == 0:\n replacement = 0\n else:\n replacement = np.nan\n pc[speed_bin_index, direction_bin_index, power_index] = replacement\n pc[speed_bin_index, direction_bin_index, low_limit_index] = replacement\n pc[speed_bin_index, direction_bin_index, high_limit_index] = replacement\n pc[speed_bin_index, direction_bin_index, bin_standard_dev_index] = replacement\n pc[speed_bin_index, direction_bin_index, bin_uncertainty] = replacement\n pc[speed_bin_index, direction_bin_index, bin_uncertainty_lower_lim_index] = replacement\n pc[speed_bin_index, direction_bin_index, bin_uncertainty_upper_lim_index] = replacement\n pc[speed_bin_index, direction_bin_index, bin_size_index] = bin_contents.size\n else:\n # suppress runtime errors caused by bins with nothing but nans\n if np.isnan(bin_contents[:, self.ws_index].astype('float')).all():\n pc[speed_bin_index, direction_bin_index, wind_speed_index] = np.nan\n else:\n pc[speed_bin_index, direction_bin_index, wind_speed_index] = np.nanmedian(bin_contents[:, self.ws_index].astype('float'))\n if np.isnan(bin_contents[:, self.wd_index].astype('float')).all():\n pc[speed_bin_index, direction_bin_index, wind_dir_index] = np.nan\n else:\n pc[speed_bin_index, direction_bin_index, wind_dir_index] = self.wind_dir_mean(bin_contents[:, self.wd_index].astype('float'))\n if np.isnan(bin_contents[:, self.pow_index].astype('float')).all():\n pc[speed_bin_index, direction_bin_index, power_index] = np.nan\n pc[speed_bin_index, direction_bin_index, low_limit_index] = np.nan\n pc[speed_bin_index, direction_bin_index, high_limit_index] = np.nan\n pc[speed_bin_index, direction_bin_index, bin_standard_dev_index] = np.nan\n pc[speed_bin_index, direction_bin_index, bin_uncertainty] = np.nan\n pc[speed_bin_index, direction_bin_index, bin_uncertainty_lower_lim_index] = np.nan\n pc[speed_bin_index, direction_bin_index, bin_uncertainty_upper_lim_index] = np.nan\n else:\n #pc[speed_bin_index, direction_bin_index, power_index] = np.nanmean(bin_contents[:, self.pow_index].astype('float'))\n mean_power = np.nanmedian(bin_contents[:, self.pow_index].astype('float'))\n power_std_dev = np.nanstd(bin_contents[:, self.pow_index].astype('float'))\n pc[speed_bin_index, direction_bin_index, power_index] = mean_power\n pc[speed_bin_index, direction_bin_index, low_limit_index] = ss.scoreatpercentile(bin_contents[:, self.pow_index], self.pc_low_limit)\n pc[speed_bin_index, direction_bin_index, high_limit_index] = ss.scoreatpercentile(bin_contents[:, self.pow_index], self.pc_high_limit)\n pc[speed_bin_index, direction_bin_index, bin_standard_dev_index] = power_std_dev\n # divide by zero possible\n if pc[speed_bin_index, direction_bin_index, power_index] != 0.0:\n pc[speed_bin_index, direction_bin_index, bin_uncertainty] = power_std_dev / mean_power * 100.0\n else:\n pc[speed_bin_index, direction_bin_index, bin_uncertainty] = 0.0\n # upper and lower limits needed for production uncertainty\n pc[speed_bin_index, direction_bin_index, bin_uncertainty_lower_lim_index] = max(0.0, mean_power - power_std_dev)\n # prevent upper liimt from going below lower limit\n if mean_power > self.rated_power:\n power_upper_limit = mean_power + power_std_dev\n else:\n power_upper_limit = min(mean_power + power_std_dev, self.rated_power)\n pc[speed_bin_index, direction_bin_index, bin_uncertainty_upper_lim_index] = power_upper_limit\n bin_rows, bin_columns = bin_contents.shape\n pc[speed_bin_index, direction_bin_index, bin_size_index] = bin_rows\n\n #TODO:\n # make filtering optional, on by default\n\n too_smalls = self.bin_size_filter(pc, self.pc_binsize)\n pc[too_smalls] = np.nan\n # interpolate over missing data\n for dir_bin_index in range(len(self.direction_bins)):\n try:\n pc[:, dir_bin_index, power_index] = self.interpolate_over_nans(pc[:, dir_bin_index, power_index])\n pc[:, dir_bin_index, low_limit_index] = self.interpolate_over_nans(pc[:, dir_bin_index, low_limit_index])\n pc[:, dir_bin_index, high_limit_index] = self.interpolate_over_nans(pc[:, dir_bin_index, high_limit_index])\n pc[:, dir_bin_index, bin_standard_dev_index] = self.interpolate_over_nans(pc[:,dir_bin_index, bin_standard_dev_index])\n pc[:, dir_bin_index, bin_uncertainty] = self.interpolate_over_nans(pc[:, dir_bin_index, bin_uncertainty])\n pc[:, dir_bin_index, bin_uncertainty_lower_lim_index] = self.interpolate_over_nans(pc[:, dir_bin_index, bin_uncertainty_lower_lim_index])\n pc[:, dir_bin_index, bin_uncertainty_upper_lim_index] = self.interpolate_over_nans(pc[:, dir_bin_index, bin_uncertainty_upper_lim_index])\n except ValueError:\n # import ipdb;ipdb.set_trace()\n print('Error in power curve generation!!')\n print('Dir bin index: {}'.format(dir_bin_index))\n print(pc[:, dir_bin_index, :])\n # filter out obviously wrong values only usable if there is more than one direction bin\n [x,y,z] = np.shape(pc)\n if self.pc_dist_filter and (y > 1):\n pc = self.distance_filter(pc, power_index)\n pc = self.distance_filter(pc, low_limit_index)\n pc = self.distance_filter(pc, high_limit_index)\n return pc\n\n def mean_power_curve(self, pc):\n \"\"\"\n calculates mean (direction independent power curve)\n\n :param pc:\n :return: mean power curve, averagesd accross direction bins\n \"\"\"\n return np.nanmean(pc, 1)\n\n def prettyprint_power_curves(self, pc, index=2, print_result=False):\n \"\"\"\n print matrix representations of different variables inside the power curve data structure\n returns a human readable matrix of wanted quantity\n\n :param pc: power curve array\n :param index: index in the power curve to be printed:\n\n 2 : mean power\n 3 : P90\n 4 : P10\n 5 : bin standard deviation\n 6 : bin uncertainty (std_dev / mean)\n 7 : bin size\n\n :param print_result: if True, prints the resulting array to stdout, defaults to False\n :return: sanitized matrix\n\n \"\"\"\n power_curve_table = pc[:, :, index]\n # add headers\n power_curve_table = np.r_[np.reshape(self.direction_bins, (1, len(self.direction_bins))), power_curve_table]\n ws_column = np.r_[np.nan, self.wind_bins]\n power_curve_table = np.c_[ws_column, power_curve_table]\n field_width = 10\n precision = 1\n separator = '\\t'\n output = []\n for line in power_curve_table:\n outputline = ''\n for index, item in enumerate(line):\n if np.isnan(item):\n token = field_width * ' '\n else:\n token = '{0:>{1}.{2}f}'.format(item, field_width, precision)\n if index == 0:\n outputline += token\n else:\n outputline += separator\n outputline += token\n outputline += '\\n'\n if print_result:\n print(outputline)\n output.append(outputline)\n return output\n\n def power_curve_uncertainty_average(self, pc, low_limit=4, high_limit=15):\n \"\"\"\n Calculate a mean value for power curve uncertainty for the summary file\n use only wind speeds between low_limit and high_limit and return just one value\n\n :param pc: power curve structure\n :param low_limit: lowest applicable wind speed\n :param high_limit: highest applicable wind speed\n :return: one value to represent power curve uncertainty\n \"\"\"\n # take direction bin wise mean of all power curves first\n mpc = self.mean_power_curve(pc)\n mask = (mpc[:,0]>= low_limit) & (mpc[:,0]<=high_limit)\n uncertainties = mpc[mask,6]\n return (np.nanmean(uncertainties))\n\n def timefilter_ice_alarms(self, data, window):\n \"\"\"\n clean outliers from ice alarms, demand, that there is at least window number of consecutive alarms\n begin the icing event from the first switch from 0->1 end at the switch from 1->0\n\n :param data: time series of alarms created by the power_alarms function\n :param window: length of hte filtering window\n :return data: reformatted data, with individual events removed\n \"\"\"\n max_index = len(data)-window\n data_index = 0\n while data_index < max_index:\n consecutive_alarms = 0\n try:\n while data[data_index + consecutive_alarms, 1] != 0:\n consecutive_alarms += 1\n except IndexError: # would raise error if this reaches the final index in the data, we can ignore this\n pass\n if consecutive_alarms > 0:\n if consecutive_alarms < window:\n data[data_index:(data_index + consecutive_alarms), 1] = 0\n data_index += consecutive_alarms\n else:\n data_index += 1\n return data\n\n def power_alarms(self, data, power_curves, time_filter=True, over=False):\n \"\"\"\n flag timestamps that match wanted power alarm criteria.\n\n For each measurement in data, search the proper value from the power curves\n If the power at any moment is below the previously calculated P10 value AND temperature is below a\n threshold, flag the timestamp.\n\n\n after all the data is processed do an additional time-based filtering step where all cases where there are not\n enough consecutive alarms are discarded.\n default idea is to demand that the power should remain below the P10 value for at least half an hour before\n the incident is considered a confirmed icing event\n\n Another considered ice class is cases where iced anemometer results in apparent overproduction.\n These cases are seen in the data as appearing above the P90 line. They are flagged in a similar way and\n same time filtering applies here as well\n\n The specification lists these as ice case A (production loss) and ice case C (overproduction)\n These are marked in the output as 1 for case A and 3 for case C in the alarm variable\n\n TODO:\n assumes ten minute data, should probably be a parameter\n\n\n :param data: input data\n :param power_curves: calculated power curves, binned based on wind speed and direction\n :param time_filter: if True, an additional time filter is applied to the data\n :param time_filter_length: number of consecutive values below the alarm limit required to trigger the icing alarm\n :param over: if True, flags the timestamps where the power is above P90 instead\n :return: an array of the format [timestamp, alarm, wind speed, reference power, temperature, power, limit]\n \"\"\"\n pow_alarms = []\n timed = datetime.timedelta(seconds=601)\n for index,line in enumerate(data):\n # integrity check for the data\n if (index != 0) and (index != len(data)-1):\n continuous = (line[self.ts_index] - data[index-1,self.ts_index]) < timed and (data[index+1,self.ts_index] - line[self.ts_index]) < timed\n else:\n continuous = False\n # pick index of active direction bin\n dirbin = np.argmin(np.abs(line[self.wd_index]-self.direction_bins))\n # pick the active wind speed bin\n windbin = np.argmin(np.abs(line[self.ws_index]-self.wind_bins))\n #wind and power at active bin\n\n # interpolate the value from power and limit (P10) curve to matches the current wind speed\n # np.interp does piecewise linear interpolation that can be assumed to be good enough in this\n # case. The power curve is close to linear between any two bins\n if over:\n int_lim = np.interp(line[self.ws_index], power_curves[:, dirbin, 0], power_curves[:, dirbin, 4])\n else:\n int_lim = np.interp(line[self.ws_index], power_curves[:, dirbin, 0], power_curves[:, dirbin, 3])\n int_pow = np.interp(line[self.ws_index], power_curves[:, dirbin, 0], power_curves[:, dirbin, 2])\n\n if continuous:\n if over:\n if (line[self.pow_index] >= int_lim) and (line[self.temp_index] <= self.icing_temperature_limit):\n pow_alrm = 3.0\n else:\n pow_alrm = 0.0\n else:\n if (line[self.pow_index] <= int_lim) and (line[self.temp_index] <= self.icing_temperature_limit):\n pow_alrm = 1.0\n else:\n pow_alrm = 0.0\n else:\n pow_alrm = 0.0\n pow_alarms.append((line[self.ts_index], pow_alrm, line[self.ws_index], int_pow, line[self.temp_index], line[self.pow_index], int_lim))\n alarms = np.array(pow_alarms)\n if time_filter:\n filtered_alarms = self.timefilter_ice_alarms(alarms, self.icing_time)\n return filtered_alarms\n else:\n return alarms\n\n def power_loss_during_alarm(self, data, ips_alarm=False):\n \"\"\"\n Collect the start and stop times of icing alarms and calculate the total\n power/production loss during the icing event\n\n counts the production loss by calculating the approximate area between\n the estimated production curve and the actual production curve as calculated by power_alarms\n\n :param data: data produced by the power_alarms function\n :param ips_alarm: set to True if alarm was caused by IPS system\n :return: a structure containing the starts and stops and losses formatted as [starttime stoptime powerloss]\n \"\"\"\n\n datalen = np.shape(data)[0]\n alarm_stats = []\n if datalen > 0:\n # calculate the times when the alarm changes on and off\n # numpy.diff calculates array[n+1] - array[n]\n alarm_diff = np.diff(data[:, 1])\n # pad a zero to the beginning, unless data[0] is an alarm\n if data[0,1] != 0.0:\n alarm_diff = np.hstack((np.array(1), alarm_diff))\n else:\n alarm_diff = np.hstack((np.array(0), alarm_diff))\n\n\n # now icing starts at times when diff == 1 and stops when diff == -1\n starts = data[alarm_diff > 0, 0]\n stops = data[alarm_diff < 0, 0]\n\n num_starts = len(starts)\n num_stops = len(stops)\n\n max_index = min((num_starts, num_stops))\n index = 0\n\n # sort starts and stops into an array\n try:\n while (index < max_index) and (datalen > 0):\n try:\n starttime = starts[index]\n stoptime = stops[index]\n if starttime > stoptime:\n raise TimingError(starttime,stoptime,index)\n\n # pull thecorresponding start and stoptimes from real data\n start_index = np.argmin(np.abs(data[:, 0]-starttime))\n stop_index = np.argmin(np.abs(data[:, 0]-stoptime))\n\n loss_sum = 0\n ips_sum = 0\n for i in range(start_index, stop_index, 1):\n # step duration in hours\n step_duration = (data[i+1, 0]-data[i, 0]).total_seconds()/60.0/60.0\n loss_at_start = data[i, 3]-data[i, 5]\n loss_at_stop = data[i+1, 3]-data[i+1, 5]\n # if either of these is np.nan add a zero to the loss sum\n if np.isnan(loss_at_start) or np.isnan(loss_at_stop):\n loss_sum += 0.0\n if ips_alarm:\n ips_sum += 0\n else:\n # integrate the losses using trapezoidal rule\n loss_sum += step_duration * ((loss_at_start + loss_at_stop)/2.0)\n if ips_alarm:\n ips_sum += step_duration * ((data[i,7] + data[i+1,7])/2.0)\n # mean_power_drop = np.nanmean(data[start_index:stop_index,3].astype(np.float32)-data[start_index:stop_index,5].astype(np.float32))\n # mean_power = np.nanmean(data[start_index:stop_index,5].astype(np.float32))\n # mean_reference_power = np.nanmean(data[start_index:stop_index,3].astype(np.float32))\n # mean_wind_speed = np.nanmean(data[start_index:stop_index,2].astype(np.float32))\n # mean_temperature = np.nanmean(data[start_index:stop_index,4].astype(np.float32))\n event_length = (data[stop_index,0]- data[start_index,0]).total_seconds()/60.0/60.0\n #alarm_stats.append((starttime, stoptime, loss_sum, event_length , mean_power_drop, mean_power, mean_reference_power, mean_wind_speed, mean_temperature))\n if ips_alarm:\n if self.heating_power_index < 0:\n alarm_stats.append((starttime, stoptime, loss_sum, event_length,0.0))\n else:\n alarm_stats.append((starttime, stoptime, loss_sum, event_length,ips_sum))\n else:\n alarm_stats.append((starttime, stoptime, loss_sum, event_length))\n except TimingError as e:\n import pdb;pdb.set_trace()\n print(\"Start after stop at index {0} in {1}\".format(e.index, self.id))\n print(\"start: {0}; stop: {1}\".format(e.start.strftime(e.dateformat), e.stop.strftime(e.dateformat)))\n index += 1\n except IndexError:\n print(\"out of bounds at index: {0}\".format(index))\n print(\"num starts: {0}; num stops: {1}\".format(num_starts, num_stops))\n\n\n return np.array(alarm_stats)\n\n def air_density_correction(self, data):\n \"\"\"\n Calculate air density correction for wind speed according to specifications in the IEA document\n returns a new array with corrected wind speed in place of the measured one\n\n Corrected wind speed for the site can be calculated as:\n\n | ws_site = ws_std*((temp_site*P_std)/(temp_std*(101325*(1-2.2557e-5*h)^5.25588)))^(1/3)\n |\n | ws_site is the corrected wind speed for the site\n | ws_std is the measured nacelle wind speed\n | temp_site is the site temperature\n | P_std is the standard air pressure at sea level (101325 Pa)\n | temp_std is the standard temperature of 15 C (288.15 K)\n | h is site height in meters\n\n :param data:\n :return: corrected data\n \"\"\"\n\n p_std = 101325\n temp_std = 288.15\n kelvin = 273.15\n new_data = []\n for i, line in enumerate(data):\n new_line = []\n for j, item in enumerate(line):\n if j != self.ws_index:\n new_line.append(item)\n else:\n # density_correction = ((line[self.temp_index]+kelvin)*p_std)/(temp_std*(p_std*((1-self.site_elevation*2.2557e-5)**5.25588)))\n density_correction = (temp_std/(line[self.temp_index]+kelvin))*((1-self.site_elevation*2.2557e-5)**5.25588)\n if np.isnan(density_correction):\n ws_site = np.nan\n else:\n sign = np.sign(density_correction)\n ws_site = line[self.ws_index] * sign * (np.abs(density_correction))**(1/3)\n new_line.append(ws_site)\n new_data.append(new_line)\n return np.array(new_data)\n\n def count_availability(self, data):\n \"\"\"\n Calculate availability number for data\n\n availability tells in % the amount of possible data available in the dataset\n checks if there is data available for each timestamp between first and last timestamp\n if there is, returns availability of 100 %\n\n does not check data integrity, only if there is some kind of data available. Available data could be garbage.\n\n :param data: data array of the time series\n :return: availability number\n \"\"\"\n start_time = min(data[:, self.ts_index])\n stop_time = max(data[:, self.ts_index])\n # set timestep to smallest value found unless its 0\n timestep = np.min(np.diff(data[:,self.ts_index]))\n if timestep.total_seconds() == 0.0:\n timestep = data[1, self.ts_index] - data[0, self.ts_index]\n timelength = stop_time - start_time\n stepcount = timelength / timestep\n availability = len(data) / stepcount\n\n return availability\n\n\n\n def find_icing_related_stops(self, data, power_curve):\n \"\"\"\n Finds timestamps from the data, when the turbine has stopped for whatever reason\n\n uses filtering requirements defined in the specification document: pwr_mean< 0.005*P_rated\n\n :param data: timeseries data of output\n :param power_curve: power curve array used\n :return: filtered data with stops flagged\n \"\"\"\n filtered_data = []\n stop_limit = self.stop_level * self.rated_power\n # [timestamp, alarm, wind speed, reference power, temperature, power]\n pow_alarms = self.power_alarms(data, power_curve, False) # do time filtering only once\n for index, line in enumerate(pow_alarms):\n # if (line[1] == 1) and (line[5] <= stop_limit) and (line[3] >= stop_limit):\n # line[1] = 2.0\n if line[1] == 1:\n # change this to look forward so tha tif the turbine will stop within a window of mark also the points where we\n # are above the stop limit to belonging into the stop\n stops = 0\n for i in range(index, min(len(pow_alarms), index+self.stop_time)):\n templine = pow_alarms[i, :]\n if (templine[5] <= stop_limit) and (templine[3] >= stop_limit):\n stops += 1\n if stops > 0:\n line[1] = 2.0\n else:\n line[1] = 0\n else:\n line[1] = 0\n filtered_data.append(line)\n\n time_filtered_data = self.timefilter_ice_alarms(np.array(filtered_data), self.stop_time)\n return time_filtered_data\n\n def status_code_stops(self, data, power_curves, filter_type=\"stop\"):\n \"\"\"\n Flag the moments in data where the turbine status code indicates icing\n The statuscode is defined in self.stopcodes\n\n :param data: input data to be processed\n :return [timestamp, alarm, wind speed, reference power, temperature, power, limit]:\n \"\"\"\n output = []\n for line in data:\n flag = False\n # for item in self.ice_stop_index:\n # if line[item] in self.stopcodes:\n # flag = True\n if filter_type == 'stop':\n # if (self.stop_filter_type == 2 and line[self.status_stop_index] not in self.stopcodes) or \\\n # (self.stop_filter_type == 1 and line[self.status_stop_index] in self.stopcodes):\n # flag = True\n if self.stop_filter_type == 2:\n flag = any([line[i] not in self.stopcodes for i in self.status_stop_index])\n elif self.stop_filter_type == 1:\n flag = any([line[i] in self.stopcodes for i in self.status_stop_index])\n else:\n pass\n elif filter_type == 'ips':\n # if (self.heating_status_type == 2 and line[self.heating_status_index] != self.heating_status_value) or \\\n # (self.heating_status_type == 1 and line[self.heating_status_index] == self.heating_status_value):\n # flag=True\n if self.heating_status_type == 2:\n flag = any([line[i] not in self.heating_status_value for i in self.heating_status_index])\n elif self.heating_status_type == 1:\n flag = any([line[i] in self.heating_status_value for i in self.heating_status_index])\n else:\n pass\n elif filter_type == 'icing':\n if line[self.ice_alarm_index] == self.ice_alarm_value:\n flag = True\n output_line =[]\n output_line.append(line[self.ts_index]) # 0\n if flag:\n if filter_type == 'stop':\n output_line.append(4.0)\n elif filter_type == 'ips':\n output_line.append(5.0)\n elif filter_type == 'icing':\n output_line.append(6.0)\n else:\n output_line.append(0.0) # 1\n output_line.append(line[self.ws_index]) # 2\n # pick index of active direction bin\n dirbin = np.argmin(np.abs(line[self.wd_index] - self.direction_bins))\n int_lim = np.interp(line[self.ws_index], power_curves[:, dirbin, 0], power_curves[:, dirbin, 3])\n int_pow = np.interp(line[self.ws_index], power_curves[:, dirbin, 0], power_curves[:, dirbin, 2])\n output_line.append(int_pow) # 3\n output_line.append(line[self.temp_index]) # 4\n output_line.append(line[self.pow_index]) # 5\n output_line.append(int_lim) # 6\n if filter_type == 'ips':\n if self.heating_power_index < 0:\n output_line.append(0.0)\n else:\n output_line.append(line[self.heating_power_index]) # 7\n output.append(output_line)\n return np.array(output)\n\n def combine_timeseries(self, pow_alms1,stops,pow_alms2):\n \"\"\"\n combine all different types of alarms into one big timeseries\n\n Timeseries file combines the alarm files into one timeseries that classifies the ice cases according ot the naming convention in the documentation\n\n 1 = power loss\n 2 = stop\n 3 = overproduction\n\n :param pow_alms1:\n :param stops:\n :param pow_alms2:\n :return:\n \"\"\"\n\n # stops timeseries longer because it uses different source data\n\n common_indexes1 = [index1 for index1, line1 in enumerate(stops) if line1[0] in pow_alms1[:,0]]\n common_indexes2 = [index2 for index2, line2 in enumerate(stops) if line2[0] in pow_alms2[:,0]]\n combined_ts = stops\n combined_ts[common_indexes1,1] += pow_alms1[:,1]\n combined_ts[common_indexes2,1] += pow_alms2[:,1]\n return combined_ts\n\n\n def define_removable_indexes(self,data,timings):\n \"\"\"\n calculate the start and stop indexes in data to remove all data defined in the array timings\n\n :param data: original dataset\n :param timings: array containg the incident starts and stops\n :return: indexes that can be used to filter the original data, a list of ranges\n \"\"\"\n removed_indexes = []\n for event in timings:\n event_start = event[0]\n event_stop = event[1]\n event_start_index = np.fromiter(map(datetime.timedelta.total_seconds,np.abs(data[:,self.ts_index]-event_start)),dtype='float').argmin()\n event_stop_index = np.fromiter(map(datetime.timedelta.total_seconds,np.abs(data[:,self.ts_index]-event_stop)),dtype='float').argmin()\n removed_indexes.extend(list(range(event_start_index,event_stop_index,1)))\n return removed_indexes\n\n def increase_reference_dataset(self, data, stop_timings, alarm_timings, over_timings):\n \"\"\"\n re-increase the size of reference dataset to include all the non-iced datapoints.\n\n :param data: original dataset\n :param stop_timings: stops calculated from the data\n :param alarm_timings: alarm incidents calculated from the data\n :param over_timigns: overproduction incidents from the data\n :return: new reference dataset\n \"\"\"\n stop_removal = self.define_removable_indexes(data,stop_timings)\n alarm_removal = self.define_removable_indexes(data,alarm_timings)\n over_removal = self.define_removable_indexes(data,over_timings)\n removed_indexes = [*stop_removal,*alarm_removal,*over_removal]\n new_ref = []\n for index,line in enumerate(data):\n if index not in removed_indexes:\n new_ref.append(line)\n return np.array(new_ref)\n\n\n\n def one_year_month_sums(self, data, wanted_year, index):\n \"\"\"\n Helper function, calculates the monthly sums of any timeseries data for a given year\n :param data:\n :param wanted_year:\n :param index:\n :return:\n \"\"\"\n months = np.arange(1, 13)\n monthly_sums = np.zeros(12)\n for line in data:\n if line[0].year == wanted_year:\n monthly_sums[line[0].month-1] += line[index]\n dated_sums = []\n for i, s in enumerate(monthly_sums):\n dated_sums.append((datetime.datetime(wanted_year, months[i], 1), s))\n return np.array(dated_sums)\n\n\n def calculate_production_stats(self, data, pc, ice_alarms, ice_stops, status_stops, ips_on, ice_detection):\n \"\"\"\n Calculates month-by-month statistics from the data.\n\n :param data: input data used to asses production\n :param pc: power curve used to calculate theoretical production\n :param ice_alarms: time series of icing alarms\n :param ice_stops: time series of icing induced stops\n :param status_stops: time series of stops as indicated by a statuscode in the scada\n :param ips_on: toggle if IPS is available or not\n :param ice_detection: timeseries of icing events as detected by an ice detector\n :return:\n \"\"\"\n\n power_reference = self.theoretical_output_power(data,pc)\n theoretical_production = self.calculate_production(power_reference,1)\n actual_production = self.calculate_production(power_reference,2)\n #pow_alarms.append((line[0], pow_alrm, line[self.ws_index], int_pow, line[self.temp_index], line[self.pow_index], int_lim))\n iced_power_drop_events = ice_alarms[ice_alarms[:,1] == 1.0, :]\n # iced_power_drops = np.hstack((iced_power_drop_events[:,0], iced_power_drop_events[:,3]-iced_power_drop_events[:,5]))\n iced_power_drops_power = np.c_[iced_power_drop_events[:,0], iced_power_drop_events[:,3]-iced_power_drop_events[:,5]]\n iced_power_drops = self.calculate_production(iced_power_drops_power,1)\n ice_stop_events = ice_stops[ice_stops[:,1] == 2.0]\n # iced_stops = np.hstack((ice_stop_events[:,0], ice_stop_events[:,3]-ice_stop_events[:,5]))\n iced_stops_power = np.c_[ice_stop_events[:,0], ice_stop_events[:,3]-ice_stop_events[:,5]]\n iced_stops = self.calculate_production(iced_stops_power,1)\n # status\n if status_stops is not None:\n status_stop_events = status_stops[status_stops[:, 1] == 4.0]\n # iced_stops = np.hstack((ice_stop_events[:,0], ice_stop_events[:,3]-ice_stop_events[:,5]))\n status_stops_power = np.c_[status_stop_events[:,0], status_stop_events[:,3]-status_stop_events[:,5]]\n status_stops_prod = self.calculate_production(status_stops_power,1)\n else:\n status_stop_events = None\n status_stops_power = None\n status_stops_prod = None\n\n ##############\n # IPS section\n ##############\n if ips_on is not None: # If there is no icing section IPS statistics are not calculated\n ips_stop_events = ips_on[ips_on[:, 1] == 5.0]\n # iced_stops = np.hstack((ice_stop_events[:,0], ice_stop_events[:,3]-ice_stop_events[:,5]))\n ips_on_power = np.c_[ips_stop_events[:,0], ips_stop_events[:,3]-ips_stop_events[:,5]]\n ips_on_prod = self.calculate_production(ips_on_power,1)\n ice_detection_events = ice_detection[ice_detection[:, 1] == 6.0]\n\n #ips consumption\n if self.heating_power_index < 0:\n ips_self_consumption = 0.0\n else:\n ips_self_consumption = self.calculate_production(data,self.heating_power_index)\n\n # iced_stops = np.hstack((ice_stop_events[:,0], ice_stop_events[:,3]-ice_stop_events[:,5]))\n ice_detection_power = np.c_[ice_detection_events[:, 0], ice_detection_events[:, 3] - ice_detection_events[:, 5]]\n ice_detection_prod = self.calculate_production(ice_detection_power, 1)\n\n # print(iced_power_drops)\n years = set([point[0].year for point in data])\n production_statistics = []\n for year in years:\n theoretical_production_sums = self.one_year_month_sums(theoretical_production,year,1)\n actual_production_sums = self.one_year_month_sums(actual_production,year,1)\n iced_power_sums = self.one_year_month_sums(iced_power_drops,year,1)\n ice_stop_sums = self.one_year_month_sums(iced_stops,year,1)\n if status_stops is not None:\n status_stop_sums = self.one_year_month_sums(status_stops_prod,year,1)\n else:\n status_stop_sums = np.copy(theoretical_production_sums)\n status_stop_sums[:, 1] = 0.0\n\n if ips_on is not None:\n ips_on_sums = self.one_year_month_sums(ips_on_prod,year,1)\n ice_detection_sums = self.one_year_month_sums(ice_detection_prod, year,1)\n else:\n print(\"Dummy IPS Values\")\n ips_on_sums = np.copy(theoretical_production_sums)\n ips_on_sums[:,1] = 0.0\n ice_detection_sums = ips_on_sums\n ips_self_consumption = 0.0\n for index, stat_month in enumerate(theoretical_production_sums):\n # if theoretical_production_sums[index,0] == actual_production_sums[index,0]:\n ice_loss = iced_power_sums[index,1] + ice_stop_sums[index,1] + ips_on_sums[index,1] + ice_detection_sums[index,1]\n if theoretical_production_sums[index,1] == 0.0:\n reldiff = 0.0\n total_icediff = 0.0\n icediff = 0.0\n stopdiff = 0.0\n statusdiff = 0.0\n ipsdiff = 0.0\n iddiff = 0.0\n else:\n reldiff = (theoretical_production_sums[index, 1] - actual_production_sums[index,1])/theoretical_production_sums[index, 1]\n icediff = (theoretical_production_sums[index, 1] - iced_power_sums[index,1])/theoretical_production_sums[index, 1]\n stopdiff = (theoretical_production_sums[index, 1] - ice_stop_sums[index,1])/theoretical_production_sums[index, 1]\n statusdiff = (theoretical_production_sums[index, 1] - status_stop_sums[index,1])/theoretical_production_sums[index, 1]\n ipsdiff = (theoretical_production_sums[index, 1] - ips_on_sums[index,1])/theoretical_production_sums[index, 1]\n iddiff = (theoretical_production_sums[index, 1] - ice_detection_sums[index,1])/theoretical_production_sums[index, 1]\n total_icediff = (theoretical_production_sums[index, 1] - ice_loss)/theoretical_production_sums[index, 1]\n production_statistics.append(\n [theoretical_production_sums[index, 0], theoretical_production_sums[index, 1],\n actual_production_sums[index, 1],\n theoretical_production_sums[index, 1] - actual_production_sums[index, 1], reldiff,\n iced_power_sums[index, 1], icediff, ice_stop_sums[index, 1], stopdiff, status_stop_sums[index, 1],\n statusdiff, ips_on_sums[index,1], ipsdiff, ice_detection_sums[index, 1], iddiff,ice_loss, total_icediff, ips_self_consumption])\n return np.array(production_statistics)\n\n", "meta": {"hexsha": "f4a9ed24453fb2cd1217585c105fb07b7be5adf8", "size": 74414, "ext": "py", "lang": "Python", "max_stars_repo_path": "t19_ice_loss/aep_counter.py", "max_stars_repo_name": "IEAWind-Task19/IceLossMethod", "max_stars_repo_head_hexsha": "c7f3c1230952e0b017ca571b03e51b68eb0a4806", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 12, "max_stars_repo_stars_event_min_datetime": "2019-12-07T14:56:10.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-11T08:42:06.000Z", "max_issues_repo_path": "t19_ice_loss/aep_counter.py", "max_issues_repo_name": "IEAWind-Task19/IceLossMethod", "max_issues_repo_head_hexsha": "c7f3c1230952e0b017ca571b03e51b68eb0a4806", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2020-03-23T19:29:41.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-25T07:50:51.000Z", "max_forks_repo_path": "t19_ice_loss/aep_counter.py", "max_forks_repo_name": "IEAWind-Task19/IceLossMethod", "max_forks_repo_head_hexsha": "c7f3c1230952e0b017ca571b03e51b68eb0a4806", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-11-22T04:06:38.000Z", "max_forks_repo_forks_event_max_datetime": "2019-12-04T09:04:11.000Z", "avg_line_length": 51.6763888889, "max_line_length": 179, "alphanum_fraction": 0.6120353697, "include": true, "reason": "import numpy,import scipy", "num_tokens": 16198, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5926665999540698, "lm_q2_score": 0.3208213008246071, "lm_q1q2_score": 0.19014006955256169}} {"text": "#! /usr/bin/python3\n# -*- coding: utf-8 -*-\n\n\n\"\"\" \n TO DO:\n - flagging (en freq et temps)\n - averaging (en temps et freq)\n - split crosscorr matrix between cross and auto --> just a mask ?\n\"\"\"\n\n\n__author__ = 'Alan Loh, Julien Girard'\n__copyright__ = 'Copyright 2019, nenupytv'\n__credits__ = ['Alan Loh', 'Julien Girard']\n__maintainer__ = 'Alan'\n__email__ = 'alan.loh@obspm.fr'\n__status__ = 'Production'\n__all__ = [\n 'Crosslets'\n ]\n\n\nimport numpy as np\nfrom os.path import abspath, isfile\nfrom itertools import islice\nfrom astropy.time import Time\n\n\n# ============================================================= #\n# ------------------------ Crosslets -------------------------- #\n# ============================================================= #\nclass Crosslets(object):\n \"\"\"\n \"\"\"\n\n def __init__(self, xst_bin):\n self.meta = {}\n self.data = None\n self.time = None\n self.xst_bin = xst_bin\n\n\n # --------------------------------------------------------- #\n # --------------------- Getter/Setter --------------------- #\n @property\n def x_vis(self):\n # x, y = np.tril_indices(self.meta['ma'].size, 0)\n # xx = np.hstack((x[x!=y], y[x!=y]))\n # yy = np.hstack((y[x!=y], x[x!=y]))\n # return v[:, :, xx, yy, ...] + v[:, :, yy, xx, ...].conj()\n self.data\n\n\n @property\n def xst_bin(self):\n \"\"\" NenuFAR TV XST snapshot binary file\n \"\"\"\n return self._xst_bin\n @xst_bin.setter\n def xst_bin(self, x):\n if not isinstance(x, str):\n raise TypeError(\n 'String expected.'\n )\n x = abspath(x)\n if not isfile(x):\n raise FileNotFoundError(\n 'Unable to find {}'.format(x)\n )\n self._xst_bin = x\n self._load()\n \n\n # --------------------------------------------------------- #\n # ------------------------ Methods ------------------------ #\n def cross_corr(self, vis=None, polar='xx'):\n \"\"\" Given XST visibilities, returns the cross-correlation\n matrix\n\n Parameters\n ----------\n vis : `np.ndarray`\n Array of visibilities (n_baselines * pol)\n This can be `self.data[time_i, freq_j, :]`\n polar : str\n Polarization requested\n\n Returns\n -------\n cross_correlation : `np.ndarray`\n Matrix of cross-correlations (n_ant, n_ant)\n \"\"\"\n if vis is None:\n vis = self.data[0, 0, :] # time, freq, vis\n\n n_ma = self.meta['ma'].size\n mat_size = n_ma*2\n \n mat_tot = np.zeros(\n (mat_size, mat_size),\n dtype='complex64'\n )\n mat_pol = np.zeros(\n (n_ma, n_ma),\n dtype='complex64'\n )\n \n indices = np.tril_indices(mat_size, 0)\n pol_idx = np.tril_indices(n_ma, 0)\n diag_idx = np.arange(mat_size-1)\n\n mat_tot[indices] = vis\n\n # Reconstruct missing XY\n mat_tot[diag_idx, diag_idx+1] = mat_tot[diag_idx+1, diag_idx].conj()\n\n if polar.lower() == 'xx':\n xx_idx = tuple([\n pol_idx[0]*2,\n pol_idx[1]*2\n ])\n # mat = mat_tot[::2, ::2]\n selected_pol = mat_tot[xx_idx]\n elif polar.lower() == 'xy':\n xy_idx = tuple([\n pol_idx[0]*2,\n pol_idx[1]*2 + 1\n ])\n # mat = mat_tot[::2, 1::2]\n selected_pol = mat_tot[xy_idx]\n elif polar.lower() == 'yx':\n yx_idx = tuple([\n pol_idx[0]*2 + 1,\n pol_idx[1]*2\n ])\n # mat = mat_tot[1::2, ::2]\n selected_pol = mat_tot[yx_idx]\n elif polar.lower() == 'yy':\n yy_idx = tuple([\n pol_idx[0]*2 + 1,\n pol_idx[1]*2 + 1\n ])\n # mat = mat_tot[1::2, 1::2]\n selected_pol = mat_tot[yy_idx]\n else:\n raise ValueError(\n 'Polarization not understood.'\n )\n\n mat_pol[pol_idx] = selected_pol\n\n return mat_pol\n\n\n def gen_cross(self, freq=None, polar='xx'):\n \"\"\" Generator of correlation matrices for each time\n at a particular frequency.\n \"\"\"\n if freq is not None:\n sb_idx = np.argmin(np.abs(freq - self.meta['freq']))\n else:\n sb_idx = np.arange(self.meta['freq'].size)\n \n for it in range(self.time.size):\n matrix = self.cross_corr(\n vis=self.data[it, sb_idx, :],\n polar=polar\n )\n\n yield matrix\n\n\n def reshape(self, tidx=None, fmean=True, tmean=True):\n \"\"\" Reshape the data to match the UVW array\n \"\"\"\n if tidx is not None:\n raise Exception(\n 'tidx not suited for NenuFAR-TV data'\n )\n data = np.zeros(\n (\n self.time.size,\n self.meta['freq'].size,\n self.meta['ma'].size,\n self.meta['ma'].size,\n 4\n ),\n dtype='complex64'\n )\n for i_p, pol in enumerate(['xx', 'xy', 'yx', 'yy']):\n for i_f, freq in enumerate(self.meta['freq']):\n i_t = 0\n for data_block in self.gen_cross(freq=freq, polar=pol):\n data[i_t, i_f, ..., i_p] = data_block\n i_t += 1\n\n if fmean:\n data = np.expand_dims(\n np.mean(data, axis=1),\n axis=1\n )\n if tmean:\n data = np.expand_dims(\n np.mean(data, axis=0),\n axis=0\n )\n return data\n\n\n # --------------------------------------------------------- #\n # ----------------------- Internal ------------------------ #\n def _load(self):\n \"\"\" Read the binary file\n \"\"\"\n # Extract the ASCII header (5 first lines)\n with open(self._xst_bin, 'rb') as f:\n header = list(islice(f, 0, 5))\n assert header[0] == b'HeaderStart\\n',\\\n 'Wrong header start'\n assert header[-1] == b'HeaderStop\\n',\\\n 'Wrong header stop'\n header = [s.decode('utf-8') for s in header]\n hd_size = sum([len(s) for s in header])\n\n # Parse informations into a metadata dictionnary\n keys = ['freq', 'ma', 'accu']\n search = ['Freq.List', 'Mr.List', 'accumulation']\n types = ['float64', 'int', 'int']\n for key, word, typ in zip(keys, search, types):\n for h in header:\n if word in h:\n self.meta[key] = np.array(\n h.split('=')[1].split(','),\n dtype=typ\n )\n\n # Deduce the dtype for decoding\n n_ma = self.meta['ma'].size\n n_sb = self.meta['freq'].size\n dtype = np.dtype(\n [('jd', 'float64'),\n ('data', 'complex64', (n_sb, n_ma*n_ma*2 + n_ma))]\n )\n\n # Decoding the binary file\n tmp = np.memmap(\n filename=self._xst_bin,\n dtype='int8',\n mode='r',\n offset=hd_size\n )\n decoded = tmp.view(dtype)\n\n self.data = decoded['data'] / self.meta['accu']\n self.time = Time(decoded['jd'], format='jd', precision=0)\n\n return\n# ============================================================= #\n\n", "meta": {"hexsha": "ea3ffc9e4b1bb31d297b7163ed912715dec575b2", "size": 7620, "ext": "py", "lang": "Python", "max_stars_repo_path": "nenupytv/read/crosslets.py", "max_stars_repo_name": "AlanLoh/nenupy-tv", "max_stars_repo_head_hexsha": "9c33652521293eaba726f02fdb2331ae32dda6f6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "nenupytv/read/crosslets.py", "max_issues_repo_name": "AlanLoh/nenupy-tv", "max_issues_repo_head_hexsha": "9c33652521293eaba726f02fdb2331ae32dda6f6", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 14, "max_issues_repo_issues_event_min_datetime": "2019-11-12T09:48:00.000Z", "max_issues_repo_issues_event_max_datetime": "2020-02-28T17:02:54.000Z", "max_forks_repo_path": "nenupytv/read/crosslets.py", "max_forks_repo_name": "AlanLoh/nenupy-tv", "max_forks_repo_head_hexsha": "9c33652521293eaba726f02fdb2331ae32dda6f6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-09-09T17:40:58.000Z", "max_forks_repo_forks_event_max_datetime": "2020-09-09T17:40:58.000Z", "avg_line_length": 29.1954022989, "max_line_length": 76, "alphanum_fraction": 0.4307086614, "include": true, "reason": "import numpy,from astropy", "num_tokens": 1782, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5926665855647395, "lm_q2_score": 0.32082129433083023, "lm_q1q2_score": 0.19014006108751347}} {"text": "#!/usr/bin/env python2\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Thu Feb 7 16:55:54 2019\nModule for the SitePair class.\n@author: parrenif\n\"\"\"\n\nimport os\nimport sys\nimport numpy as np\nimport matplotlib.pyplot as mpl\nfrom matplotlib.backends.backend_pdf import PdfPages\nfrom scipy.linalg import lu_factor, lu_solve\nfrom scipy.linalg import cholesky\nimport pccfg\n\nclass SitePair(object):\n \"\"\"Class for a pair of sites.\"\"\"\n\n def __init__(self, site1, site2):\n self.site1 = site1\n self.site2 = site2\n self.label = self.site1.label+'-'+self.site2.label\n\n self.age_age_label = self.site1.age_label+self.site2.age_label\n if len(self.age_age_label)>0:\n self.age_age_label = self.age_age_label + '_'\n self.age_age2_label = self.site1.age_label+self.site2.age2_label + '_'\n self.age2_age_label = self.site1.age2_label+self.site2.age_label + '_'\n self.age2_age2_label = self.site1.age2_label+self.site2.age2_label + '_'\n \n\n#TODO: allow to have either dlabel1+'-'dlabel2 or dlbel2+'-'dlabel1 as directory\n filename = pccfg.datadir+self.site1.label+'-'+self.site2.label+\\\n '/'+self.age_age_label+'synchro_horizons.txt'\n if not os.path.isfile(filename):\n filename = pccfg.datadir+self.site1.label+'-'+self.site2.label+'/ice_depth.txt'\n if os.path.isfile(filename) and open(filename).read():\n readarray = np.loadtxt(filename)\n if np.size(readarray) == np.shape(readarray)[0]:\n readarray.resize(1, np.size(readarray))\n self.iceicehorizons_depth1 = readarray[:, 0]\n self.iceicehorizons_depth2 = readarray[:, 1]\n self.iceicehorizons_sigma = readarray[:, 2]\n else:\n self.iceicehorizons_depth1 = np.array([])\n self.iceicehorizons_depth2 = np.array([])\n self.iceicehorizons_sigma = np.array([])\n self.iceicehorizons_correlation = np.diag(np.ones(np.size(self.iceicehorizons_depth1)))\n\n if self.site1.archive == 'icecore' and self.site2.archive == 'icecore':\n filename = pccfg.datadir+self.site1.label+'-'+self.site2.label+\\\n '/'+self.age2_age2_label+'synchro_horizons.txt'\n if not os.path.isfile(filename):\n filename = pccfg.datadir+self.site1.label+'-'+self.site2.label+'/air_depth.txt'\n if os.path.isfile(filename) and open(filename).read():\n readarray = np.loadtxt(filename)\n if np.size(readarray) == np.shape(readarray)[0]:\n readarray.resize(1, np.size(readarray))\n self.airairhorizons_depth1 = readarray[:, 0]\n self.airairhorizons_depth2 = readarray[:, 1]\n self.airairhorizons_sigma = readarray[:, 2]\n else:\n self.airairhorizons_depth1 = np.array([])\n self.airairhorizons_depth2 = np.array([])\n self.airairhorizons_sigma = np.array([])\n self.airairhorizons_correlation = np.diag(np.ones(np.size(self.airairhorizons_depth1)))\n\n if self.site2.archive == 'icecore':\n filename = pccfg.datadir+self.site1.label+'-'+\\\n self.site2.label+'/'+self.age_age2_label+'synchro_horizons.txt'\n if not os.path.isfile(filename):\n filename = pccfg.datadir+self.site1.label+'-'+self.site2.label+'/iceair_depth.txt'\n if os.path.isfile(filename) and open(filename).read():\n readarray = np.loadtxt(filename)\n if np.size(readarray) == np.shape(readarray)[0]:\n readarray.resize(1, np.size(readarray))\n self.iceairhorizons_depth1 = readarray[:, 0]\n self.iceairhorizons_depth2 = readarray[:, 1]\n self.iceairhorizons_sigma = readarray[:, 2]\n else:\n self.iceairhorizons_depth1 = np.array([])\n self.iceairhorizons_depth2 = np.array([])\n self.iceairhorizons_sigma = np.array([])\n self.iceairhorizons_correlation = np.diag(np.ones(np.size(self.iceairhorizons_depth1)))\n\n if self.site1.archive == 'icecore':\n filename = pccfg.datadir+self.site1.label+'-'+\\\n self.site2.label+'/'+self.age2_age_label+'synchro_horizons.txt'\n if not os.path.isfile(filename):\n filename = pccfg.datadir+self.site1.label+'-'+self.site2.label+'/airice_depth.txt'\n if os.path.isfile(filename) and open(filename).read():\n readarray = np.loadtxt(filename)\n if np.size(readarray) == np.shape(readarray)[0]:\n readarray.resize(1, np.size(readarray))\n self.airicehorizons_depth1 = readarray[:, 0]\n self.airicehorizons_depth2 = readarray[:, 1]\n self.airicehorizons_sigma = readarray[:, 2]\n else:\n self.airicehorizons_depth1 = np.array([])\n self.airicehorizons_depth2 = np.array([])\n self.airicehorizons_sigma = np.array([])\n self.airicehorizons_correlation = np.diag(np.ones(np.size(self.airicehorizons_depth1)))\n\n\n filename1 = pccfg.datadir+'/parameters_covariance_observations_all_site_pairs.py'\n filename2 = pccfg.datadir+'/parameters-CovarianceObservations-AllDrillings.py'\n if os.path.isfile(filename1):\n exec(open(filename1).read())\n elif os.path.isfile(filename2):\n exec(open(filename2).read())\n filename3 = pccfg.datadir+self.label+'/parameters_covariance_observations.py'\n filename4 = pccfg.datadir+self.label+'/parameters-CovarianceObservations.py'\n if os.path.isfile(filename3):\n exec(open(filename3).read())\n elif os.path.isfile(filename4):\n exec(open(filename4).read())\n \n if ((os.path.isfile(filename1) or os.path.isfile(filename2) or os.path.isfile(filename3)\\\n or os.path.isfile(filename4)) and (pccfg.jacobian=='analytical' or \\\n pccfg.jacobian=='semi_adjoint' or pccfg.jacobian=='adjoint')):\n print('Covariance on observations not implemented for analytical Jacobian. Exiting.')\n sys.exit()\n \n if np.any(self.iceicehorizons_correlation != \\\n np.diag(np.ones(np.size(self.iceicehorizons_depth1)))):\n self.iceicehorizons_correlation_bool = True\n self.iceicehorizons_chol = cholesky(self.iceicehorizons_correlation)\n self.iceicehorizons_lu_piv = lu_factor(self.iceicehorizons_chol)\n else:\n self.iceicehorizons_correlation_bool = False\n \n if self.site1.archive == 'icecore' and self.site2.archive == 'icecore':\n if np.any(self.airairhorizons_correlation != \\\n np.diag(np.ones(np.size(self.airairhorizons_depth1)))):\n self.airairhorizons_correlation_bool = True\n self.airairhorizons_chol = cholesky(self.airairhorizons_correlation)\n self.airairhorizons_lu_piv = lu_factor(self.airairhorizons_chol)\n else:\n self.airairhorizons_correlation_bool = False\n \n if self.site2.archive == 'icecore':\n if np.any(self.iceairhorizons_correlation != \\\n np.diag(np.ones(np.size(self.iceairhorizons_depth1)))):\n self.iceairhorizons_correlation_bool = True\n self.iceairhorizons_chol = cholesky(self.iceairhorizons_correlation)\n self.iceairhorizons_lu_piv = lu_factor(self.iceairhorizons_chol)\n else:\n self.iceairhorizons_correlation_bool = False\n \n if self.site1.archive == 'icecore':\n if np.any(self.airicehorizons_correlation != \\\n np.diag(np.ones(np.size(self.airicehorizons_depth1)))):\n self.airicehorizons_correlation_bool = True\n self.airicehorizons_chol = cholesky(self.airicehorizons_correlation)\n self.airicehorizons_lu_piv = lu_factor(self.airicehorizons_chol)\n else:\n self.airicehorizons_correlation_bool = False\n\n def residuals(self):\n \"\"\"Calculate the residual terms of a pair of sites.\"\"\"\n\n if np.size(self.iceicehorizons_depth1) > 0:\n resi_iceice = (self.site1.fct_age(self.iceicehorizons_depth1)-\\\n self.site2.fct_age(self.iceicehorizons_depth2))/self.iceicehorizons_sigma\n if self.iceicehorizons_correlation_bool:\n resi_iceice = lu_solve(self.iceicehorizons_lu_piv, resi_iceice)\n resi = [resi_iceice]\n else:\n resi = [np.array([])]\n\n if self.site1.archive == 'icecore' and self.site2.archive == 'icecore' and \\\n np.size(self.airairhorizons_depth1) > 0:\n resi_airair = (self.site1.fct_airage(self.airairhorizons_depth1)-\\\n self.site2.fct_airage(self.airairhorizons_depth2))/\\\n self.airairhorizons_sigma\n if self.airairhorizons_correlation_bool:\n resi_airair = lu_solve(self.airairhorizons_lu_piv, resi_airair)\n resi.append(resi_airair)\n\n if self.site2.archive == 'icecore' and np.size(self.iceairhorizons_depth1) > 0:\n resi_iceair = (self.site1.fct_age(self.iceairhorizons_depth1)-\\\n self.site2.fct_airage(self.iceairhorizons_depth2))/\\\n self.iceairhorizons_sigma\n if self.iceairhorizons_correlation_bool:\n resi_iceair = lu_solve(self.iceairhorizons_lu_piv, resi_iceair)\n resi.append(resi_iceair)\n\n if self.site1.archive == 'icecore' and np.size(self.airicehorizons_depth1) > 0:\n resi_airice = (self.site1.fct_airage(self.airicehorizons_depth1)-\\\n self.site2.fct_age(self.airicehorizons_depth2))/self.airicehorizons_sigma\n if self.airicehorizons_correlation_bool:\n resi_airice = lu_solve(self.airicehorizons_lu_piv, resi_airice)\n resi.append(resi_airice)\n\n return np.concatenate(resi)\n\n\n def residuals_jacobian1(self):\n# if np.size(self.iceicehorizons_depth1) > 0:\n# print(np.shape(self.site1.fct_age_jac(self.iceicehorizons_depth1)),\n# np.shape(self.site2.fct_age(self.iceicehorizons_depth2)),\n# np.shape(self.iceicehorizons_sigma)\n resi_iceice = self.site1.fct_age_jac(self.iceicehorizons_depth1)/self.iceicehorizons_sigma\n resi = [resi_iceice]\n if self.site1.archive == 'icecore' and self.site2.archive == 'icecore':\n resi_airair = self.site1.fct_airage_jac(self.airairhorizons_depth1)/\\\n self.airairhorizons_sigma\n resi.append(resi_airair)\n if self.site2.archive == 'icecore':\n resi_iceair = self.site1.fct_age_jac(self.iceairhorizons_depth1)/\\\n self.iceairhorizons_sigma\n resi.append(resi_iceair)\n if self.site1.archive == 'icecore':\n resi_airice = self.site1.fct_airage_jac(self.airicehorizons_depth1)/\\\n self.airicehorizons_sigma\n resi.append(resi_airice)\n# else:\n# resi = [np.array([])]\n return np.concatenate(resi, axis=1)\n\n def residuals_jacobian2(self):\n# if np.size(self.iceicehorizons_depth1) > 0:\n resi_iceice = -self.site2.fct_age_jac(self.iceicehorizons_depth2)/self.iceicehorizons_sigma\n resi = [resi_iceice]\n if self.site1.archive == 'icecore' and self.site2.archive == 'icecore':\n resi_airair = -self.site2.fct_airage_jac(self.airairhorizons_depth2)/\\\n self.airairhorizons_sigma\n resi.append(resi_airair)\n if self.site2.archive == 'icecore':\n resi_iceair = -self.site2.fct_airage_jac(self.iceairhorizons_depth2)/\\\n self.iceairhorizons_sigma\n resi.append(resi_iceair)\n if self.site1.archive == 'icecore':\n resi_airice = -self.site2.fct_age_jac(self.airicehorizons_depth2)/\\\n self.airicehorizons_sigma\n resi.append(resi_airice)\n# else:\n# resi = [np.array([])]\n return np.concatenate(resi, axis=1)\n\n def residuals_delta(self):\n resi_iceice = (self.site1.fct_age_delta(self.iceicehorizons_depth1)-\\\n self.site2.fct_age_delta(self.iceicehorizons_depth2))/self.iceicehorizons_sigma\n return resi_iceice\n\n def figures(self):\n \n \"\"\"Build the figures related to a pair of sites.\"\"\"\n if np.size(self.iceicehorizons_depth1)>0:\n fig, ax = mpl.subplots()\n mpl.xlabel(self.site1.label+' '+self.site1.age_labelsp+'age ('+pccfg.age_unit+' '+pccfg.age_unit_ref+')')\n mpl.ylabel(self.site2.label+' '+self.site2.age_labelsp+'age ('+pccfg.age_unit+' '+pccfg.age_unit_ref+')')\n if np.size(self.iceicehorizons_depth1) > 0:\n if pccfg.show_initial:\n mpl.plot(self.site1.fct_age_init(self.iceicehorizons_depth1),\n self.site2.fct_age_init(self.iceicehorizons_depth2),\n color=pccfg.color_init, linestyle='', marker='o', markersize=2,\n label=\"Initial\")\n mpl.plot(self.site1.fct_age_model(self.iceicehorizons_depth1),\n self.site2.fct_age_model(self.iceicehorizons_depth2),\n color=pccfg.color_mod, linestyle='', marker='o', markersize=2,\n label=\"Prior\")\n mpl.errorbar(self.site1.fct_age(self.iceicehorizons_depth1),\n self.site2.fct_age(self.iceicehorizons_depth2), color=pccfg.color_opt,\n ecolor=pccfg.color_ci,\n xerr=np.zeros(np.size(self.iceicehorizons_depth1)),\n linestyle='', marker='o', markersize=2,\n label=\"Posterior $\\pm\\sigma$\")\n xstart = self.site1.fct_age(self.iceicehorizons_depth1)-self.iceicehorizons_sigma/2\n ystart = self.site2.fct_age(self.iceicehorizons_depth2)+self.iceicehorizons_sigma/2\n for i in range(np.size(self.iceicehorizons_depth1)):\n mpl.arrow(xstart[i], ystart[i], self.iceicehorizons_sigma[i],\n -self.iceicehorizons_sigma[i], color=pccfg.color_ci,\n width=0.0, head_length=0.0, head_width=0.0)\n x_low, x_up, y_low, y_up = mpl.axis()\n# x_low = self.site1.age_top\n# y_low = self.site2.age_top\n# mpl.axis((x_low, x_up, y_low, y_up))\n rangefig = np.array([min(x_low, y_low), max(x_up, y_up)])\n mpl.plot(rangefig, rangefig, color=pccfg.color_obs, label='Perfect agreement', zorder=0)\n mpl.legend(loc=\"best\")\n ax.set_aspect('equal')\n printed_page = PdfPages(pccfg.datadir+self.label+'/'+self.age_age_label+'synchro.pdf')\n printed_page.savefig(fig)\n printed_page.close()\n if not pccfg.show_figures:\n mpl.close()\n\n if self.site1.archive == 'icecore' and self.site2.archive == 'icecore':\n if np.size(self.airairhorizons_depth1)>0:\n fig, ax = mpl.subplots()\n mpl.xlabel(self.site1.label+' '+self.site1.age2_labelsp+'age ('+pccfg.age_unit+' '+\n pccfg.age_unit_ref+')')\n mpl.ylabel(self.site2.label+' '+self.site2.age2_labelsp+'age ('+pccfg.age_unit+' '+\n pccfg.age_unit_ref+')')\n if np.size(self.airairhorizons_depth1) > 0:\n if pccfg.show_initial:\n mpl.plot(self.site1.fct_airage_init(self.airairhorizons_depth1),\n self.site2.fct_airage_init(self.airairhorizons_depth2),\n color=pccfg.color_init,\n linestyle='',\n marker='o', markersize=2, label=\"Initial\")\n mpl.plot(self.site1.fct_airage_model(self.airairhorizons_depth1),\n self.site2.fct_airage_model(self.airairhorizons_depth2),\n color=pccfg.color_mod,\n linestyle='', marker='o', markersize=2,\n label=\"Prior\")\n mpl.errorbar(self.site1.fct_airage(self.airairhorizons_depth1),\n self.site2.fct_airage(self.airairhorizons_depth2),\n color=pccfg.color_opt, ecolor=pccfg.color_ci,\n xerr=np.zeros_like(self.airairhorizons_sigma),\n linestyle='', marker='o', markersize=2,\n label=\"Posterior $\\pm\\sigma$\")\n xstart = self.site1.fct_airage(self.airairhorizons_depth1)-\\\n self.airairhorizons_sigma/2\n ystart = self.site2.fct_airage(self.airairhorizons_depth2)+\\\n self.airairhorizons_sigma/2\n for i in range(np.size(self.airairhorizons_depth1)):\n mpl.arrow(xstart[i], ystart[i], self.airairhorizons_sigma[i],\n -self.airairhorizons_sigma[i], color=pccfg.color_ci,\n width=0.0, head_length=0.0, head_width=0.0)\n x_low, x_up, y_low, y_up = mpl.axis()\n# x_low = self.site1.age_top\n# y_low = self.site2.age_top\n# mpl.axis((x_low, x_up, y_low, y_up))\n rangefig = np.array([min(x_low, y_low), max(x_up, y_up)])\n mpl.plot(rangefig, rangefig, color=pccfg.color_obs, label='Perfect agreement',\n zorder=0)\n mpl.legend(loc=\"best\")\n ax.set_aspect('equal')\n printed_page = PdfPages(pccfg.datadir+self.label+'/'+self.age2_age2_label+\n 'synchro.pdf')\n printed_page.savefig(fig)\n printed_page.close()\n if not pccfg.show_figures:\n mpl.close()\n\n if self.site2.archive == 'icecore':\n if np.size(self.iceairhorizons_depth1)>0:\n fig, ax = mpl.subplots()\n mpl.xlabel(self.site1.label+' '+self.site1.age_labelsp+'age ('+pccfg.age_unit+' '+\n pccfg.age_unit_ref+')')\n mpl.ylabel(self.site2.label+' '+self.site2.age2_labelsp+'age ('+pccfg.age_unit+' '+\n pccfg.age_unit_ref+')')\n if np.size(self.iceairhorizons_depth1) > 0:\n if pccfg.show_initial:\n mpl.plot(self.site1.fct_age_init(self.iceairhorizons_depth1),\n self.site2.fct_airage_init(self.iceairhorizons_depth2),\n color=pccfg.color_init,\n linestyle='',\n marker='o', markersize=2, label=\"Initial\")\n mpl.plot(self.site1.fct_age_model(self.iceairhorizons_depth1),\n self.site2.fct_airage_model(self.iceairhorizons_depth2),\n color=pccfg.color_mod,\n linestyle='', marker='o', markersize=2,\n label=\"Prior\")\n mpl.errorbar(self.site1.fct_age(self.iceairhorizons_depth1),\n self.site2.fct_airage(self.iceairhorizons_depth2),\n color=pccfg.color_opt, ecolor=pccfg.color_ci,\n xerr=np.zeros_like(self.iceairhorizons_sigma),\n linestyle='', marker='o', markersize=2,\n label=\"Posterior $\\pm\\sigma$\")\n xstart = self.site1.fct_age(self.iceairhorizons_depth1)-\\\n self.iceairhorizons_sigma/2\n ystart = self.site2.fct_airage(self.iceairhorizons_depth2)+\\\n self.iceairhorizons_sigma/2\n for i in range(np.size(self.iceairhorizons_depth1)):\n mpl.arrow(xstart[i], ystart[i], self.iceairhorizons_sigma[i],\n -self.iceairhorizons_sigma[i], color=pccfg.color_ci,\n width=0.0, head_length=0.0, head_width=0.0) \n x_low, x_up, y_low, y_up = mpl.axis()\n# x_low = self.site1.age_top\n# y_low = self.site2.age_top\n# mpl.axis((x_low, x_up, y_low, y_up))\n rangefig = np.array([min(x_low, y_low), max(x_up, y_up)])\n mpl.plot(rangefig, rangefig, color=pccfg.color_obs, label='Perfect agreement',\n zorder=0)\n mpl.legend(loc=\"best\")\n ax.set_aspect('equal')\n printed_page = PdfPages(pccfg.datadir+self.label+'/'+self.age_age2_label+\n 'synchro.pdf')\n printed_page.savefig(fig)\n printed_page.close()\n if not pccfg.show_figures:\n mpl.close()\n\n if self.site1.archive == 'icecore':\n if np.size(self.airicehorizons_depth1)>0:\n fig, ax = mpl.subplots()\n mpl.xlabel(self.site1.label+' '+self.site1.age2_labelsp+'age ('+pccfg.age_unit+' '+\n pccfg.age_unit_ref+')')\n mpl.ylabel(self.site2.label+' '+self.site2.age_labelsp+'age ('+pccfg.age_unit+' '+\n pccfg.age_unit_ref+')')\n if np.size(self.airicehorizons_depth1) > 0:\n if pccfg.show_initial:\n mpl.plot(self.site1.fct_airage_init(self.airicehorizons_depth1),\n self.site2.fct_age_init(self.airicehorizons_depth2),\n color=pccfg.color_init,\n linestyle='', marker='o', markersize=2, label=\"Initial\")\n mpl.plot(self.site1.fct_airage_model(self.airicehorizons_depth1),\n self.site2.fct_age_model(self.airicehorizons_depth2),\n color=pccfg.color_mod,\n linestyle='', marker='o', markersize=2,\n label=\"Prior\")\n mpl.errorbar(self.site1.fct_airage(self.airicehorizons_depth1),\n self.site2.fct_age(self.airicehorizons_depth2),\n color=pccfg.color_opt, ecolor=pccfg.color_ci,\n xerr=np.zeros_like(self.airicehorizons_sigma),\n linestyle='', marker='o', markersize=2,\n label=\"Posterior $\\pm\\sigma$\")\n xstart = self.site1.fct_airage(self.airicehorizons_depth1)-\\\n self.airicehorizons_sigma/2\n ystart = self.site2.fct_age(self.airicehorizons_depth2)+\\\n self.airicehorizons_sigma/2\n for i in range(np.size(self.airicehorizons_depth1)):\n mpl.arrow(xstart[i], ystart[i], self.airicehorizons_sigma[i],\n -self.airicehorizons_sigma[i], color=pccfg.color_ci,\n width=0.0, head_length=0.0, head_width=0.0)\n x_low, x_up, y_low, y_up = mpl.axis()\n# x_low = self.site1.age_top\n# y_low = self.site2.age_top\n# mpl.axis((x_low, x_up, y_low, y_up))\n rangefig = np.array([min(x_low, y_low), max(x_up, y_up)])\n mpl.plot(rangefig, rangefig, color=pccfg.color_obs, label='Perfect agreement')\n mpl.legend(loc=\"best\")\n ax.set_aspect('equal')\n printed_page = PdfPages(pccfg.datadir+self.label+'/'+self.age2_age_label+\n 'synchro.pdf')\n printed_page.savefig(fig)\n printed_page.close()\n if not pccfg.show_figures:\n mpl.close()\n", "meta": {"hexsha": "ae77cf29c28ee2c0b695a8bcce7005908d8795fd", "size": 24685, "ext": "py", "lang": "Python", "max_stars_repo_path": "pcsitepair.py", "max_stars_repo_name": "parrenin/PaleoChrono", "max_stars_repo_head_hexsha": "90237b551c569e55ee6e6696c4b176234da4d94f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pcsitepair.py", "max_issues_repo_name": "parrenin/PaleoChrono", "max_issues_repo_head_hexsha": "90237b551c569e55ee6e6696c4b176234da4d94f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pcsitepair.py", "max_forks_repo_name": "parrenin/PaleoChrono", "max_forks_repo_head_hexsha": "90237b551c569e55ee6e6696c4b176234da4d94f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 56.7471264368, "max_line_length": 117, "alphanum_fraction": 0.5645938829, "include": true, "reason": "import numpy,from scipy", "num_tokens": 5659, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5926665855647395, "lm_q2_score": 0.32082129433083023, "lm_q1q2_score": 0.19014006108751347}} {"text": "# Licensed with the 3-clause BSD license. See LICENSE for details.\nfrom itertools import groupby\nimport numpy as np\nimport astropy.units as u\nfrom astropy.time import Time\nfrom astropy.table import vstack\nfrom sbpy.data import Ephem, Orbit, Names, QueryError\nfrom sbpy.data.names import TargetNameParseError\nfrom . import util\n\nSTEP_LIMIT = 300\n\n\ndef generate(desg, location, epochs, source='jpl', orbit=None, cache=False):\n \"\"\"Generate ephemeris at specific epochs from external source.\n\n Parameters\n ----------\n desg : string\n Object designation.\n\n location : string\n Observer location.\n\n epochs : array-like, Time, or dict\n Compute ephemeris at these epochs. Arrays must be\n floats (for Julian date) or else parsable by\n `~astropy.time.Time`. Dictionaries are passed to the\n ephemeris source as is. Set ``step=None`` for an\n adaptable time step that mitigates interpolation errors.\n\n source : string, optional\n Source to use: 'mpc', 'jpl', or 'oorb'. 'oorb' requires\n ``orbit`` parameter.\n\n orbit : `~sbpy.data.Orbit`, optional\n Orbital elements for ``source=oorb``.\n\n cache : bool, optional\n Use cached ephemerides; primarily for testing.\n\n Returns\n -------\n eph : `~sbpy.data.ephem.Ephem`\n Ephemeris.\n\n \"\"\"\n\n if source not in ['mpc', 'jpl', 'oorb']:\n raise ValueError('Source must be \"mpc\", \"jpl\", or \"oorb\".')\n\n _epochs = _format_epochs(epochs)\n if isinstance(_epochs, dict):\n if epochs.get('step') is None:\n eph = _get_adaptable_steps(desg, location, _epochs,\n source=source, orbit=orbit,\n cache=cache)\n else:\n eph = _get_fixed_steps(desg, location, _epochs, source=source,\n orbit=orbit, cache=cache)\n return eph\n\n\ndef generate_orbit(desg, epochs, cache=False):\n \"\"\"Generate orbital parameters from JPL Horizons at specific epochs.\n\n Parameters\n ----------\n desg: string\n Object designation.\n\n epochs: array-like or dict\n Compute orbital elements at these epochs. For arrays,\n must be floats(for Julian date) or else parsable by\n `~astropy.time.Time`.\n\n cache: bool, optional\n Use cached ephemerides; primarily for testing.\n\n Returns\n -------\n orb: `~sbpy.data.Orbit`\n Orbital elements.\n\n \"\"\"\n\n _epochs = _format_epochs(epochs)\n if not isinstance(_epochs, dict):\n if len(_epochs) > STEP_LIMIT:\n orb = None\n N = np.ceil(len(_epochs) / STEP_LIMIT)\n for e in np.array_split(_epochs, N):\n _orb = generate_orbit(desg, e, cache=cache)\n if orb:\n orb.add_rows(_orb)\n else:\n orb = _orb\n return orb\n else:\n pass\n # ... and continue\n\n kwargs = dict(epochs=_epochs, cache=cache)\n kwargs['id_type'] = 'smallbody'\n comet = False\n try:\n Names.parse_comet(desg)\n comet = True\n kwargs['id_type'] = 'designation'\n cap_limit = closest_apparition_limit(_epochs)\n kwargs.update(closest_apparition=cap_limit,\n no_fragments=True)\n except TargetNameParseError:\n pass\n\n\n try:\n orb = Orbit.from_horizons(desg, **kwargs)\n except QueryError:\n # Dual-listed objects should be queried without CAP/NOFRAG. If\n # this was a comet query, try again.\n if comet:\n del kwargs['closest_apparition'], kwargs['no_fragments']\n\n # fix for sbpy bug #xxx, remove once v0.2.2 is released\n kwargs['epochs'] = _format_epochs(epochs)\n\n orb = Orbit.from_horizons(desg, **kwargs)\n else:\n raise\n\n return orb\n\n\ndef closest_apparition_limit(epochs):\n if isinstance(epochs, dict):\n start = epochs['start'].jd\n else:\n start = epochs[0].jd\n return '<{}'.format(start)\n\n\ndef _format_epochs(epochs):\n if isinstance(epochs, dict):\n start, stop = util.epochs_to_time((epochs['start'], epochs['stop']))\n step = (None if epochs.get('step') is None\n else u.Quantity(epochs.get('step')))\n e = {\n 'start': start,\n 'stop': stop,\n 'step': step\n }\n else:\n e = util.epochs_to_time(epochs)\n if len(epochs) > 1:\n d = np.diff(e.jd)\n if any(d <= 0):\n raise ValueError('Epoch dates must be increasing and unique.')\n\n return e\n\n\ndef _get_fixed_steps(desg, location, epochs, source='jpl', orbit=None,\n cache=False):\n if not isinstance(epochs, dict):\n # list of specific dates, divide into chunks, as needed\n if len(epochs) > STEP_LIMIT:\n eph = None\n N = np.ceil(len(epochs) / STEP_LIMIT)\n for e in np.array_split(epochs, N):\n _eph = _get_fixed_steps(desg, location, list(e),\n source=source, cache=cache)\n if eph:\n eph.add_rows(_eph)\n else:\n eph = _eph\n return eph\n else:\n pass\n # and proceed...\n\n if source == 'mpc':\n eph = Ephem.from_mpc(desg, epochs=epochs,\n location=location,\n proper_motion='sky',\n proper_motion_unit='rad/s',\n cache=cache)\n\n z = np.zeros(len(eph))\n if 'Uncertainty 3sig' not in eph.table.colnames:\n eph.table.add_column(u.Quantity(z, 'arcsec'),\n name='SMAA_3sigma')\n eph.table.add_column(u.Quantity(z, 'arcsec'),\n name='SMIA_3sigma')\n eph.table.add_column(u.Quantity(z, 'rad'),\n name='Theta_3sigma')\n else:\n # MPC's ephemeris uncertainty is a line, rather than\n # an ellipse\n eph.table.add_column(u.Quantity(z, 'arcsec'),\n name='SMIA_3sigma')\n eph.table.add_column(eph['Uncertainty 3sig'],\n name='SMAA_3sigma')\n eph.table.add_column(eph['Unc. P.A.'],\n name='Theta_3sigma')\n\n # convert date from Time to Julian date, this helps with table\n # manipulation since Time columns cannot be appended to.\n eph['jd'] = eph['date'].jd\n elif source == 'jpl':\n # column 7 (sidereal time) isn't needed, but adding to avoid sbpy-0.2.1 crash\n kwargs = dict(\n epochs=epochs,\n location=location,\n quantities='1,3,8,9,7,19,20,23,24,27,36,37',\n cache=cache\n )\n kwargs['id_type'] = 'smallbody'\n comet = False\n try:\n Names.parse_comet(desg)\n comet = True\n kwargs['id_type'] = 'designation'\n cap_limit = closest_apparition_limit(epochs)\n kwargs.update(\n closest_apparition=cap_limit,\n no_fragments=True\n )\n except TargetNameParseError:\n pass\n\n try:\n eph = Ephem.from_horizons(desg, **kwargs)\n except QueryError:\n # Dual-listed objects should be queried without CAP/NOFRAG. If\n # this was a comet query, try again.\n if comet:\n del kwargs['closest_apparition'], kwargs['no_fragments']\n\n # fix for sbpy bug #xxx, remove once v0.2.2 is released\n kwargs['epochs'] = _format_epochs(epochs)\n\n eph = Ephem.from_horizons(desg, **kwargs)\n else:\n raise\n\n # Horizon's theta is measured N of E. We want E of N.\n eph['Theta_3sigma'] = (np.pi / 2) * u.rad - eph['Theta_3sigma']\n\n # create a plain Julian date column, helps with table\n # manipulation in _get_adaptable_steps\n eph['jd'] = eph['epoch'].jd\n elif source == 'oorb':\n eph = Ephem.from_oo(orbit, epochs=epochs, location=location)\n # no uncertainties from oorb\n z = np.zeros(len(eph))\n eph.table.add_column(u.Quantity(z, 'arcsec'),\n name='SMAA_3sigma')\n eph.table.add_column(u.Quantity(z, 'arcsec'),\n name='SMIA_3sigma')\n eph.table.add_column(u.Quantity(z, 'rad'),\n name='Theta_3sigma')\n eph['jd'] = eph['epoch'].jd # same note as for jpl\n\n return eph\n\n\ndef _get_adaptable_steps(desg, location, epochs, source='jpl', orbit=None,\n cache=False):\n \"\"\"Ephemerides with adaptable time step.\n\n Based on ZChecker analysis, Oct 2018, the interpolation error is\n ~2\" / delta for 6h time step.\n\n \"\"\"\n\n # daily ephemeris for delta > 1\n epochs['step'] = 1 * u.day\n eph = _get_fixed_steps(desg, location, epochs, source=source,\n cache=cache)\n\n for limit, substep in ((1 * u.au, 4 * u.hr), (0.25 * u.au, 1 * u.hr)):\n updated = []\n groups = groupby(zip(eph['delta'], eph['jd']),\n lambda e: e[0] < limit)\n for inside, epochs in groups:\n if not inside:\n continue\n\n jd = [e[1] for e in epochs]\n if len(jd) > 1:\n sub_epochs = _format_epochs({\n 'start': jd[0],\n 'stop': jd[-1],\n 'step': substep\n })\n update = _get_fixed_steps(desg, location, sub_epochs,\n source=source, cache=cache)\n updated.append(update.table)\n\n eph = Ephem.from_table(vstack([eph.table] + updated))\n\n # remove duplicates\n eph.table.sort('jd')\n d = np.diff(eph['jd'])\n duplicates = np.flatnonzero(np.isclose(d, 0)) + 1\n eph.table.remove_rows(duplicates)\n\n return eph\n", "meta": {"hexsha": "7c4ffb0ff59e6c23cbf6bb5eaa62c666559722e4", "size": 10119, "ext": "py", "lang": "Python", "max_stars_repo_path": "sbsearch/ephem.py", "max_stars_repo_name": "Small-Bodies-Node/sbsearch", "max_stars_repo_head_hexsha": "987e8017f62ce2965eff2455b67a40c0f316c58d", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-04-02T17:25:19.000Z", "max_stars_repo_stars_event_max_datetime": "2020-04-02T17:25:19.000Z", "max_issues_repo_path": "sbsearch/ephem.py", "max_issues_repo_name": "Small-Bodies-Node/sbsearch", "max_issues_repo_head_hexsha": "987e8017f62ce2965eff2455b67a40c0f316c58d", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2018-11-29T15:46:33.000Z", "max_issues_repo_issues_event_max_datetime": "2021-02-12T01:43:39.000Z", "max_forks_repo_path": "sbsearch/ephem.py", "max_forks_repo_name": "Small-Bodies-Node/sbsearch", "max_forks_repo_head_hexsha": "987e8017f62ce2965eff2455b67a40c0f316c58d", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.6419354839, "max_line_length": 85, "alphanum_fraction": 0.5392825378, "include": true, "reason": "import numpy,import astropy,from astropy", "num_tokens": 2419, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5621765155565327, "lm_q2_score": 0.3380771374883919, "lm_q1q2_score": 0.190059027142551}} {"text": "#!/usr/bin/env python\n# Copyright 2014-2019 The PySCF Developers. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n# Author: Qiming Sun \n#\n\n'''\nQM part interface\n'''\n\nimport numpy\nimport pyscf\nfrom pyscf import lib\nfrom pyscf import gto\nfrom pyscf import df\nfrom pyscf import scf\nfrom pyscf import mcscf\nfrom pyscf import grad\nfrom pyscf.lib import logger\n\n\ndef mm_charge(scf_method, coords, charges, unit=None):\n '''Modify the QM method using the (non-relativistic) potential generated\n by MM charges. Note the static Coulomb interactions of the background\n charges are not included in the total energy.\n\n Args:\n scf_method : a HF or DFT object\n\n coords : 2D array, shape (N,3)\n MM particle coordinates\n charges : 1D array\n MM particle charges\n Kwargs:\n unit : str\n Bohr, AU, Ang (case insensitive). Default is the same to mol.unit\n\n Returns:\n Same method object as the input scf_method with modified 1e Hamiltonian\n\n Note:\n 1. if MM charge and X2C correction are used together, function mm_charge\n needs to be applied after X2C decoration (.x2c method), eg\n mf = mm_charge(scf.RHF(mol).x2c()), [(0.5,0.6,0.8)], [-0.5]).\n 2. Once mm_charge function is applied on the SCF object, it\n affects all the post-HF calculations eg MP2, CCSD, MCSCF etc\n\n Examples:\n\n >>> mol = gto.M(atom='H 0 0 0; F 0 0 1', basis='ccpvdz', verbose=0)\n >>> mf = mm_charge(dft.RKS(mol), [(0.5,0.6,0.8)], [-0.3])\n >>> mf.kernel()\n -101.940495711284\n '''\n assert(isinstance(scf_method, scf.hf.SCF) or\n isinstance(scf_method, mcscf.casci.CASCI))\n\n if unit is None:\n unit = scf_method.mol.unit\n if unit.startswith(('B','b','au','AU')):\n coords = numpy.asarray(coords, order='C')\n elif unit.startswith(('A','a')):\n coords = numpy.asarray(coords, order='C') / lib.parameters.BOHR\n else:\n coords = numpy.asarray(coords, order='C') / unit\n charges = numpy.asarray(charges)\n method_class = scf_method.__class__\n\n class QMMM(method_class, _QMMM):\n def __init__(self):\n self.__dict__.update(scf_method.__dict__)\n\n def dump_flags(self, verbose=None):\n method_class.dump_flags(self, verbose)\n logger.info(self, '** Add background charges for %s **',\n method_class)\n if self.verbose >= logger.DEBUG:\n logger.debug(self, 'Charge Location')\n for i, z in enumerate(charges):\n logger.debug(self, '%.9g %s', z, coords[i])\n return self\n\n def get_hcore(self, mol=None):\n if mol is None: mol = self.mol\n if getattr(scf_method, 'get_hcore', None):\n h1e = method_class.get_hcore(self, mol)\n else: # DO NOT modify post-HF objects to avoid the MM charges applied twice\n raise RuntimeError('mm_charge function cannot be applied on post-HF methods')\n\n if pyscf.DEBUG:\n v = 0\n for i,q in enumerate(charges):\n mol.set_rinv_origin(coords[i])\n v += mol.intor('int1e_rinv') * -q\n else:\n if mol.cart:\n intor = 'int3c2e_cart'\n else:\n intor = 'int3c2e_sph'\n nao = mol.nao\n max_memory = self.max_memory - lib.current_memory()[0]\n blksize = int(min(max_memory*1e6/8/nao**2, 200))\n cintopt = gto.moleintor.make_cintopt(mol._atm, mol._bas,\n mol._env, intor)\n v = 0\n for i0, i1 in lib.prange(0, charges.size, blksize):\n fakemol = gto.fakemol_for_charges(coords[i0:i1])\n j3c = df.incore.aux_e2(mol, fakemol, intor=intor,\n aosym='s2ij', cintopt=cintopt)\n v += numpy.einsum('xk,k->x', j3c, -charges[i0:i1])\n v = lib.unpack_tril(v)\n return h1e + v\n\n def energy_nuc(self):\n# nuclei lattice interaction\n nuc = self.mol.energy_nuc()\n for j in range(self.mol.natm):\n q2, r2 = self.mol.atom_charge(j), self.mol.atom_coord(j)\n r = lib.norm(r2-coords, axis=1)\n nuc += q2*(charges/r).sum()\n return nuc\n\n def nuc_grad_method(self):\n scf_grad = method_class.nuc_grad_method(self)\n return mm_charge_grad(scf_grad, coords, charges, 'Bohr')\n\n return QMMM()\nadd_mm_charges = mm_charge\n\ndef mm_charge_grad(scf_grad, coords, charges, unit=None):\n '''Apply the MM charges in the QM gradients' method. It affects both the\n electronic and nuclear parts of the QM fragment.\n\n Args:\n scf_grad : a HF or DFT gradient object (grad.HF or grad.RKS etc)\n Once mm_charge_grad function is applied on the SCF object,\n it affects all post-HF calculations eg MP2, CCSD, MCSCF etc\n coords : 2D array, shape (N,3)\n MM particle coordinates\n charges : 1D array\n MM particle charges\n Kwargs:\n unit : str\n Bohr, AU, Ang (case insensitive). Default is the same to mol.unit\n\n Returns:\n Same gradeints method object as the input scf_grad method\n\n Examples:\n\n >>> from pyscf import gto, scf, grad\n >>> mol = gto.M(atom='H 0 0 0; F 0 0 1', basis='ccpvdz', verbose=0)\n >>> mf = mm_charge(scf.RHF(mol), [(0.5,0.6,0.8)], [-0.3])\n >>> mf.kernel()\n -101.940495711284\n >>> hfg = mm_charge_grad(grad.hf.RHF(mf), coords, charges)\n >>> hfg.kernel()\n [[-0.25912357 -0.29235976 -0.38245077]\n [-1.70497052 -1.89423883 1.2794798 ]]\n '''\n assert(isinstance(scf_grad, grad.rhf.Gradients))\n if getattr(scf_grad.base, 'with_x2c', None):\n raise NotImplementedError('X2C with QM/MM charges')\n\n if unit is None:\n unit = scf_grad.mol.unit\n if unit.startswith(('B','b','au','AU')):\n coords = numpy.asarray(coords, order='C')\n elif unit.startswith(('A','a')):\n coords = numpy.asarray(coords, order='C') / lib.parameters.BOHR\n else:\n coords = numpy.asarray(coords, order='C') / unit\n charges = numpy.asarray(charges)\n\n grad_class = scf_grad.__class__\n class QMMM(grad_class, _QMMMGrad):\n def __init__(self, scf_grad):\n self.__dict__.update(scf_grad.__dict__)\n\n def dump_flags(self, verbose=None):\n grad_class.dump_flags(self, verbose)\n logger.info(self, '** Add background charges for %s **', grad_class)\n if self.verbose >= logger.DEBUG1:\n logger.debug1(self, 'Charge Location')\n for i, z in enumerate(charges):\n logger.debug1(self, '%.9g %s', z, coords[i])\n return self\n\n def get_hcore(self, mol=None):\n ''' (QM 1e grad) + <-d/dX i|q_mm/r_mm|j>'''\n if mol is None: mol = self.mol\n g_qm = grad_class.get_hcore(self, mol)\n nao = g_qm.shape[1]\n if pyscf.DEBUG:\n v = 0\n for i,q in enumerate(charges):\n mol.set_rinv_origin(coords[i])\n v += mol.intor('int1e_iprinv', comp=3) * q\n else:\n if mol.cart:\n intor = 'int3c2e_ip1_cart'\n else:\n intor = 'int3c2e_ip1_sph'\n nao = mol.nao\n max_memory = self.max_memory - lib.current_memory()[0]\n blksize = int(min(max_memory*1e6/8/nao**2, 200))\n cintopt = gto.moleintor.make_cintopt(mol._atm, mol._bas,\n mol._env, intor)\n v = 0\n for i0, i1 in lib.prange(0, charges.size, blksize):\n fakemol = gto.fakemol_for_charges(coords[i0:i1])\n j3c = df.incore.aux_e2(mol, fakemol, intor, aosym='s1',\n comp=3, cintopt=cintopt)\n v += numpy.einsum('ipqk,k->ipq', j3c, charges[i0:i1])\n return g_qm + v\n\n def grad_nuc(self, mol=None, atmlst=None):\n if mol is None: mol = self.mol\n g_qm = grad_class.grad_nuc(self, mol, atmlst)\n# nuclei lattice interaction\n g_mm = numpy.empty((mol.natm,3))\n for i in range(mol.natm):\n q1 = mol.atom_charge(i)\n r1 = mol.atom_coord(i)\n r = lib.norm(r1-coords, axis=1)\n g_mm[i] = -q1 * numpy.einsum('i,ix,i->x', charges, r1-coords, 1/r**3)\n if atmlst is not None:\n g_mm = g_mm[atmlst]\n return g_qm + g_mm\n return QMMM(scf_grad)\n\n# A tag to label the derived class\nclass _QMMM:\n pass\nclass _QMMMGrad:\n pass\n\n# Inject QMMM interface wrapper to other modules\nscf.hf.SCF.QMMM = mm_charge\nmcscf.casci.CASCI.QMMM = mm_charge\ngrad.rhf.Gradients.QMMM = mm_charge_grad\n\nif __name__ == '__main__':\n from pyscf import scf, cc, grad\n mol = gto.Mole()\n mol.atom = ''' O 0.00000000 0.00000000 -0.11081188\n H -0.00000000 -0.84695236 0.59109389\n H -0.00000000 0.89830571 0.52404783 '''\n mol.basis = 'cc-pvdz'\n mol.build()\n\n coords = [(0.5,0.6,0.8)]\n #coords = [(0.0,0.0,0.0)]\n charges = [-0.5]\n mf = mm_charge(scf.RHF(mol), coords, charges)\n print(mf.kernel()) # -76.3206550372\n\n g = mf.nuc_grad_method().kernel()\n mfs = mf.as_scanner()\n e1 = mfs(''' O 0.00100000 0.00000000 -0.11081188\n H -0.00000000 -0.84695236 0.59109389\n H -0.00000000 0.89830571 0.52404783 ''')\n e2 = mfs(''' O -0.00100000 0.00000000 -0.11081188\n H -0.00000000 -0.84695236 0.59109389\n H -0.00000000 0.89830571 0.52404783 ''')\n print((e1 - e2)/0.002 * lib.param.BOHR, g[0,0])\n\n mycc = cc.ccsd.CCSD(mf)\n ecc, t1, t2 = mycc.kernel() # ecc = -0.228939687075\n\n g = mycc.nuc_grad_method().kernel()\n ccs = mycc.as_scanner()\n e1 = ccs(''' O 0.00100000 0.00000000 -0.11081188\n H -0.00000000 -0.84695236 0.59109389\n H -0.00000000 0.89830571 0.52404783 ''')\n e2 = ccs(''' O -0.00100000 0.00000000 -0.11081188\n H -0.00000000 -0.84695236 0.59109389\n H -0.00000000 0.89830571 0.52404783 ''')\n print((e1 - e2)/0.002 * lib.param.BOHR, g[0,0])\n\n", "meta": {"hexsha": "a1017ca0f74e847078c154667e7ae14279b868be", "size": 11370, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyscf/qmmm/itrf.py", "max_stars_repo_name": "crisely09/pyscf", "max_stars_repo_head_hexsha": "cb92f7974bd9c87c0ef5b2b52abf5d3219b3d6b6", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-04-07T21:12:08.000Z", "max_stars_repo_stars_event_max_datetime": "2020-04-07T21:12:08.000Z", "max_issues_repo_path": "pyscf/qmmm/itrf.py", "max_issues_repo_name": "crisely09/pyscf", "max_issues_repo_head_hexsha": "cb92f7974bd9c87c0ef5b2b52abf5d3219b3d6b6", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2019-09-16T17:58:31.000Z", "max_issues_repo_issues_event_max_datetime": "2019-09-22T17:26:01.000Z", "max_forks_repo_path": "pyscf/qmmm/itrf.py", "max_forks_repo_name": "crisely09/pyscf", "max_forks_repo_head_hexsha": "cb92f7974bd9c87c0ef5b2b52abf5d3219b3d6b6", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.8054607509, "max_line_length": 93, "alphanum_fraction": 0.554353562, "include": true, "reason": "import numpy", "num_tokens": 3198, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073802837478, "lm_q2_score": 0.34510528442897664, "lm_q1q2_score": 0.1900175165815165}} {"text": "from __future__ import division, absolute_import, print_function\nfrom .. import affinitymat\nfrom .. import nearest_neighbors\nfrom .. import cluster\nfrom .. import aggregator\nfrom .. import core\nfrom .. import util\nfrom .. import seqlet_embedding\nfrom .. import pattern_filterer as pattern_filterer_module\nfrom joblib import Parallel, delayed\nfrom collections import defaultdict, OrderedDict, Counter\nimport numpy as np\nimport time\nimport sys\nimport gc\nimport json\nfrom ..util import print_memory_use\n\n\ndef get_seqlet_neighbors_with_initcluster(\n nearest_neighbors_to_compute,\n coarse_affmat, initclusters): \n if (initclusters is not None):\n assert len(initclusters)==len(coarse_affmat)\n #get the argsort for coarse_affmat\n coarse_affmat_argsort = np.argsort(-coarse_affmat, axis=-1)\n nearest_neighbors = []\n for row_idx,argsort_row in enumerate(coarse_affmat_argsort):\n combined_neighbor_row = []\n neighbor_row_topnn = argsort_row[:nearest_neighbors_to_compute+1]\n neighbor_set_topnn = set(neighbor_row_topnn)\n #combined_neighbor_row ends up being the union of the standard nearest\n # neighbors plus the nearest neighbors if focusing on the initclusters\n combined_neighbor_row.extend(neighbor_row_topnn)\n if (initclusters is not None):\n combined_neighbor_row.extend([\n y for y in ([x for x in argsort_row\n if initclusters[x]==initclusters[row_idx]][\n :nearest_neighbors_to_compute+1])\n if y not in neighbor_set_topnn])\n nearest_neighbors.append(combined_neighbor_row) \n return nearest_neighbors\n\n\ndef fish_out_kwargs(orig_kwargs, to_fish_out):\n fished_out = {}\n for kwarg_name in to_fish_out:\n if kwarg_name in orig_kwargs:\n fished_out[kwarg_name] = orig_kwargs[kwarg_name]\n del orig_kwargs[kwarg_name] \n return fished_out\n\n\n#adds backwargs compatibility re gapped kmer arguments\ndef legacy_tfmodiscoseqletstopatternsfactory(current_constructor):\n\n def new_constructor(*args, **kwargs): \n gapped_kmer_kwargs = fish_out_kwargs(\n orig_kwargs=kwargs,\n to_fish_out=['kmer_len', 'num_gaps',\n 'num_mismatches', 'gpu_batch_size'])\n if (len(gapped_kmer_kwargs) > 0):\n assert 'embedder_factory' not in kwargs,\\\n (\"Cannot both specify embedder_factory and \"\n +str(gapped_kmer_kwargs))\n from modisco.seqlet_embedding import gapped_kmer\n kwargs['embedder_factory'] = (\n seqlet_embedding.gapped_kmer\n .GappedKmerEmbedderFactory(**gapped_kmer_kwargs))\n return current_constructor(*args, **kwargs) \n return new_constructor \n\n\n##legacy\n#alphabet_size=None,\n#kmer_len=None, num_gaps=3, num_mismatches=2,\n#gpu_batch_size=20,\nclass TfModiscoSeqletsToPatternsFactory(object):\n\n @legacy_tfmodiscoseqletstopatternsfactory\n def __init__(self, n_cores=4,\n min_overlap_while_sliding=0.7,\n\n #init clusterer factory\n initclusterer_factory=None, \n\n embedder_factory=(\n seqlet_embedding.advanced_gapped_kmer\n .AdvancedGappedKmerEmbedderFactory()),\n\n nearest_neighbors_to_compute=500,\n use_pynnd=False,\n\n affmat_correlation_threshold=0.15,\n filter_beyond_first_round=False,\n skip_fine_grained=False,\n\n tsne_perplexity=10,\n use_louvain=False,\n louvain_initclusters_weight=1.0,\n n_leiden_iterations_r1=-1,\n n_leiden_iterations_r2=-1,\n louvain_num_runs_and_levels_r1=[(200,-1)],\n louvain_num_runs_and_levels_r2=[(200,-1)], \n contin_runs_r1=50,\n contin_runs_r2=50,\n final_louvain_level_to_return=1,\n\n frac_support_to_trim_to=0.2,\n min_num_to_trim_to=30,\n trim_to_window_size=30,\n initial_flank_to_add=10,\n\n prob_and_pertrack_sim_merge_thresholds=[\n (0.8,0.8), (0.5, 0.85), (0.2, 0.9)],\n\n prob_and_pertrack_sim_dealbreaker_thresholds=[\n (0.4, 0.75), (0.2,0.8), (0.1, 0.85), (0.0,0.9)],\n\n subcluster_perplexity=50,\n merging_max_seqlets_subsample=300,\n #threshold_for_spurious_merge_detection=0.8,\n\n #min_similarity_for_seqlet_assignment=0.2,\n final_min_cluster_size=30,\n min_ic_in_window=0.6,#total IC in some windowsize window \n min_ic_windowsize=6,\n ppm_pseudocount=0.001,\n\n final_flank_to_add=0,\n\n verbose=True, seed=1234):\n\n self.initclusterer_factory = initclusterer_factory\n if (use_louvain==True):\n assert self.initclusterer_factory==None,\\\n (\"Louvain doesn't support cluster initialization;\"\n +\" set use_louvain to False\")\n\n #affinity_mat calculation\n self.n_cores = n_cores\n self.min_overlap_while_sliding = min_overlap_while_sliding\n\n self.embedder_factory = embedder_factory\n\n self.nearest_neighbors_to_compute = nearest_neighbors_to_compute\n self.use_pynnd = use_pynnd\n\n self.affmat_correlation_threshold = affmat_correlation_threshold\n self.filter_beyond_first_round = filter_beyond_first_round\n self.skip_fine_grained = skip_fine_grained\n\n #affinity mat to tsne dist mat setting\n self.tsne_perplexity = tsne_perplexity\n\n #clustering settings\n self.use_louvain = use_louvain\n self.louvain_initclusters_weight = louvain_initclusters_weight\n self.n_leiden_iterations_r1 = n_leiden_iterations_r1\n self.n_leiden_iterations_r2 = n_leiden_iterations_r2\n self.contin_runs_r1 = contin_runs_r1\n self.contin_runs_r2 = contin_runs_r2\n self.louvain_num_runs_and_levels_r1 = louvain_num_runs_and_levels_r1\n self.louvain_num_runs_and_levels_r2 = louvain_num_runs_and_levels_r2\n self.final_louvain_level_to_return = final_louvain_level_to_return\n\n #postprocessor1 settings\n self.frac_support_to_trim_to = frac_support_to_trim_to\n self.min_num_to_trim_to = min_num_to_trim_to\n self.trim_to_window_size = trim_to_window_size\n self.initial_flank_to_add = initial_flank_to_add \n\n #subclustering\n self.subcluster_perplexity=subcluster_perplexity\n\n #merging similar patterns\n self.prob_and_pertrack_sim_merge_thresholds =\\\n prob_and_pertrack_sim_merge_thresholds\n self.prob_and_pertrack_sim_dealbreaker_thresholds =\\\n prob_and_pertrack_sim_dealbreaker_thresholds\n\n self.merging_max_seqlets_subsample = merging_max_seqlets_subsample\n #self.threshold_for_spurious_merge_detection =\\\n # threshold_for_spurious_merge_detection\n\n #reassignment settings\n #self.min_similarity_for_seqlet_assignment =\\\n # min_similarity_for_seqlet_assignment\n self.final_min_cluster_size = final_min_cluster_size\n self.min_ic_in_window = min_ic_in_window\n self.min_ic_windowsize = min_ic_windowsize\n self.ppm_pseudocount = ppm_pseudocount\n\n #final postprocessor settings\n self.final_flank_to_add=final_flank_to_add\n\n #other settings\n self.verbose = verbose\n self.seed = seed\n\n def get_jsonable_config(self):\n to_return = OrderedDict([\n ('class_name', type(self).__name__),\n ('n_cores', self.n_cores),\n ('initclusterer_factory',\n self.initclusterer_factory.get_jsonable_config()),\n ('min_overlap_while_sliding', self.min_overlap_while_sliding),\n ('embedder_factory',\n self.embedder_factory.get_jsonable_config()),\n ('num_mismatches', self.num_mismatches),\n ('nearest_neighbors_to_compute',\n self.nearest_neighbors_to_compute),\n ('affmat_correlation_threshold',\n self.affmat_correlation_threshold),\n ('filter_beyond_first_round', filter_beyond_first_round),\n ('tsne_perplexity', self.tsne_perplexity),\n ('use_louvain', self.use_louvain),\n ('louvain_num_runs_and_levels_r1',\n self.louvain_num_runs_and_levels_r1),\n ('louvain_num_runs_and_levels_r2',\n self.louvain_num_runs_and_levels_r2),\n ('final_louvain_level_to_return',\n self.final_louvain_level_to_return),\n ('contin_runs_r1',\n self.contin_runs_r1),\n ('contin_runs_r2',\n self.contin_runs_r2),\n ('frac_support_to_trim_to', self.frac_support_to_trim_to),\n ('min_num_to_trim_to', self.min_num_to_trim_to),\n ('trim_to_window_size', self.trim_to_window_size),\n ('initial_flank_to_add', self.initial_flank_to_add),\n ('subcluster_perplexity', self.subcluster_perplexity),\n ('prob_and_pertrack_sim_merge_thresholds',\n self.prob_and_pertrack_sim_merge_thresholds),\n ('prob_and_pertrack_sim_dealbreaker_thresholds',\n self.prob_and_pertrack_sim_dealbreaker_thresholds),\n ('merging_max_seqlets_subsample',\n self.merging_max_seqlets_subsample),\n #('threshold_for_spurious_merge_detection',\n # self.threshold_for_spurious_merge_detection),\n ('min_similarity_for_seqlet_assignment',\n self.min_similarity_for_seqlet_assignment),\n ('final_min_cluster_size', self.final_min_cluster_size),\n ('min_ic_in_window', self.min_ic_in_window),\n ('min_ic_windowsize', self.min_ic_windowsize),\n ('ppm_pseudocount', self.ppm_pseudocount),\n ('final_flank_to_add', self.final_flank_to_add),\n ]) \n return to_return\n\n def __call__(self, track_set, onehot_track_name,\n contrib_scores_track_names,\n hypothetical_contribs_track_names,\n track_signs,\n other_comparison_track_names=[]):\n\n bg_freq = np.mean(\n track_set.track_name_to_data_track[onehot_track_name].fwd_tracks,\n axis=(0,1))\n assert len(bg_freq.shape)==1 \n\n assert len(track_signs)==len(hypothetical_contribs_track_names)\n assert len(track_signs)==len(contrib_scores_track_names)\n\n seqlets_sorter = (lambda arr:\n sorted(arr,\n key=lambda x:\n -np.sum([np.sum(np.abs(x[track_name].fwd))\n for track_name\n in contrib_scores_track_names])))\n\n if (self.initclusterer_factory is not None):\n self.initclusterer_factory.set_onehot_track_name(onehot_track_name)\n initclusterer_factory = self.initclusterer_factory\n\n pattern_comparison_settings =\\\n affinitymat.core.PatternComparisonSettings(\n track_names=hypothetical_contribs_track_names\n +contrib_scores_track_names\n +other_comparison_track_names, \n track_transformer=affinitymat.L1Normalizer(), \n min_overlap=self.min_overlap_while_sliding)\n\n #coarse_grained 1d embedder\n seqlets_to_1d_embedder = self.embedder_factory(\n onehot_track_name=onehot_track_name,\n toscore_track_names_and_signs=list(\n zip(hypothetical_contribs_track_names,\n [np.sign(x) for x in track_signs])),\n n_jobs=self.n_cores)\n\n #affinity matrix from embeddings\n if (self.use_pynnd):\n sparse_affmat_from_fwdnrev1dvecs = (\n affinitymat.core.PynndSparseNumpyCosineSimFromFwdAndRevOneDVecs(\n n_neighbors=self.nearest_neighbors_to_compute,\n verbose=self.verbose,\n n_jobs=self.n_cores))\n else:\n sparse_affmat_from_fwdnrev1dvecs =\\\n affinitymat.core.SparseNumpyCosineSimFromFwdAndRevOneDVecs(\n n_neighbors=self.nearest_neighbors_to_compute, \n verbose=self.verbose)\n coarse_affmat_computer =\\\n affinitymat.core.SparseAffmatFromFwdAndRevSeqletEmbeddings(\n seqlets_to_1d_embedder=seqlets_to_1d_embedder,\n sparse_affmat_from_fwdnrev1dvecs=sparse_affmat_from_fwdnrev1dvecs,\n verbose=self.verbose)\n\n affmat_from_seqlets_with_nn_pairs =\\\n affinitymat.core.AffmatFromSeqletsWithNNpairs(\n pattern_comparison_settings=pattern_comparison_settings,\n sim_metric_on_nn_pairs=\\\n affinitymat.core.ParallelCpuCrossMetricOnNNpairs(\n n_cores=self.n_cores,\n cross_metric_single_region=\n affinitymat.core.CrossContinJaccardSingleRegion()))\n\n filter_mask_from_correlation =\\\n affinitymat.core.FilterMaskFromCorrelation(\n correlation_threshold=self.affmat_correlation_threshold,\n verbose=self.verbose)\n\n aff_to_dist_mat = affinitymat.transformers.AffToDistViaInvLogistic() \n #density_adapted_affmat_transformer =\\\n # affinitymat.transformers.NNTsneConditionalProbs(\n # perplexity=self.tsne_perplexity,\n # aff_to_dist_mat=aff_to_dist_mat)\n\n #prepare the clusterers for the different rounds\n # No longer a need for symmetrization because am symmetrizing by\n # taking the geometric mean elsewhere\n affmat_transformer_r1 =\\\n affinitymat.transformers.AdhocAffMatTransformer(lambda x: x)\n #affinitymat.transformers.SymmetrizeByAddition(\n # probability_normalize=True)\n print(\"TfModiscoSeqletsToPatternsFactory: seed=%d\" % self.seed)\n if (self.use_louvain):\n for n_runs, level_to_return in self.louvain_num_runs_and_levels_r1:\n affmat_transformer_r1 = affmat_transformer_r1.chain(\n affinitymat.transformers.LouvainMembershipAverage(\n n_runs=n_runs,\n level_to_return=level_to_return,\n parallel_threads=self.n_cores, seed=self.seed))\n clusterer_r1 = cluster.core.LouvainCluster(\n level_to_return=self.final_louvain_level_to_return,\n affmat_transformer=affmat_transformer_r1,\n contin_runs=self.contin_runs_r1,\n verbose=self.verbose, seed=self.seed)\n else:\n clusterer_r1 = cluster.core.LeidenClusterParallel(\n n_jobs=self.n_cores, \n affmat_transformer=affmat_transformer_r1,\n numseedstotry=self.contin_runs_r1,\n n_leiden_iterations=self.n_leiden_iterations_r1,\n verbose=self.verbose)\n\n #No longer a need for symmetrization because am symmetrizing by\n # taking the geometric mean elsewhere\n affmat_transformer_r2 =\\\n affinitymat.transformers.AdhocAffMatTransformer(lambda x: x)\n #affmat_transformer_r2 = affinitymat.transformers.SymmetrizeByAddition(\n # probability_normalize=True)\n if (self.use_louvain):\n for n_runs, level_to_return in self.louvain_num_runs_and_levels_r2:\n affmat_transformer_r2 = affmat_transformer_r2.chain(\n affinitymat.transformers.LouvainMembershipAverage(\n n_runs=n_runs,\n level_to_return=level_to_return,\n parallel_threads=self.n_cores, seed=self.seed))\n clusterer_r2 = cluster.core.LouvainCluster(\n level_to_return=self.final_louvain_level_to_return,\n affmat_transformer=affmat_transformer_r2,\n contin_runs=self.contin_runs_r2,\n verbose=self.verbose, seed=self.seed,\n initclusters_weight=self.louvain_initclusters_weight)\n else:\n clusterer_r2 = cluster.core.LeidenClusterParallel(\n n_jobs=self.n_cores, \n affmat_transformer=affmat_transformer_r2,\n numseedstotry=self.contin_runs_r2,\n n_leiden_iterations=self.n_leiden_iterations_r2,\n verbose=self.verbose)\n \n clusterer_per_round = [clusterer_r1, clusterer_r2]\n\n #prepare the seqlet aggregator\n expand_trim_expand1 =\\\n aggregator.ExpandSeqletsToFillPattern(\n track_set=track_set,\n flank_to_add=self.initial_flank_to_add).chain(\n aggregator.TrimToBestWindowByIC(\n window_size=self.trim_to_window_size,\n onehot_track_name=onehot_track_name,\n bg_freq=bg_freq)).chain(\n aggregator.ExpandSeqletsToFillPattern(\n track_set=track_set,\n flank_to_add=self.initial_flank_to_add))\n postprocessor1 =\\\n aggregator.TrimToFracSupport(\n min_frac=self.frac_support_to_trim_to,\n min_num=self.min_num_to_trim_to,\n verbose=self.verbose)\\\n .chain(expand_trim_expand1)\n seqlet_aggregator = aggregator.GreedySeqletAggregator(\n pattern_aligner=core.CrossContinJaccardPatternAligner(\n pattern_comparison_settings=pattern_comparison_settings),\n seqlet_sort_metric=\n lambda x: -sum([np.sum(np.abs(x[track_name].fwd)) for\n track_name in contrib_scores_track_names]),\n track_set=track_set, #needed for seqlet expansion\n postprocessor=postprocessor1)\n\n def sign_consistency_func(motif):\n motif_track_signs = [\n np.sign(np.sum(motif[contrib_scores_track_name].fwd)) for\n contrib_scores_track_name in contrib_scores_track_names]\n return all([(x==y) for x,y in zip(motif_track_signs, track_signs)])\n\n #prepare the similar patterns collapser\n pattern_to_seqlet_sim_computer =\\\n affinitymat.core.AffmatFromSeqletsWithNNpairs(\n pattern_comparison_settings=pattern_comparison_settings,\n sim_metric_on_nn_pairs=\\\n affinitymat.core.ParallelCpuCrossMetricOnNNpairs(\n n_cores=self.n_cores,\n cross_metric_single_region=\\\n affinitymat.core.CrossContinJaccardSingleRegion(),\n verbose=False))\n\n #similarity settings for merging\n prob_and_sim_merge_thresholds =\\\n self.prob_and_pertrack_sim_merge_thresholds\n prob_and_sim_dealbreaker_thresholds =\\\n self.prob_and_pertrack_sim_dealbreaker_thresholds\n\n similar_patterns_collapser =\\\n aggregator.DynamicDistanceSimilarPatternsCollapser2(\n pattern_comparison_settings=pattern_comparison_settings,\n track_set=track_set,\n pattern_aligner=core.CrossCorrelationPatternAligner(\n pattern_comparison_settings=\n affinitymat.core.PatternComparisonSettings(\n track_names=(\n contrib_scores_track_names+\n other_comparison_track_names), \n track_transformer=\n affinitymat.MeanNormalizer().chain(\n affinitymat.MagnitudeNormalizer()), \n min_overlap=self.min_overlap_while_sliding)),\n collapse_condition=(lambda prob, aligner_sim:\n any([(prob >= x[0] and aligner_sim >= x[1])\n for x in prob_and_sim_merge_thresholds])),\n dealbreaker_condition=(lambda prob, aligner_sim:\n any([(prob <= x[0] and aligner_sim <= x[1]) \n for x in prob_and_sim_dealbreaker_thresholds])),\n postprocessor=postprocessor1,\n verbose=self.verbose,\n max_seqlets_subsample=self.merging_max_seqlets_subsample,\n n_cores=self.n_cores)\n\n subcluster_settings = {\n \"pattern_comparison_settings\": pattern_comparison_settings,\n \"perplexity\": self.subcluster_perplexity,\n \"n_jobs\": self.n_cores,\n }\n spurious_merge_detector = aggregator.DetectSpuriousMerging2(\n subcluster_settings=subcluster_settings,\n verbose=self.verbose,\n min_in_subcluster=max(self.final_min_cluster_size,\n self.subcluster_perplexity),\n similar_patterns_collapser=similar_patterns_collapser)\n\n #spurious_merge_detector = aggregator.DetectSpuriousMerging(\n # track_names=contrib_scores_track_names,\n # track_transformer=affinitymat.core.L1Normalizer(),\n # affmat_from_1d=affinitymat.core.ContinJaccardSimilarity(\n # make_positive=True, verbose=False),\n # diclusterer=cluster.core.LouvainCluster(\n # level_to_return=1,\n # max_clusters=2, contin_runs=20,\n # verbose=False, seed=self.seed),\n # is_dissimilar_func=aggregator.PearsonCorrIsDissimilarFunc(\n # threshold=self.threshold_for_spurious_merge_detection,\n # verbose=self.verbose),\n # min_in_subcluster=self.final_min_cluster_size)\n\n #similar_patterns_collapser =\\\n # aggregator.DynamicDistanceSimilarPatternsCollapser(\n # pattern_to_pattern_sim_computer=\n # pattern_to_seqlet_sim_computer,\n # aff_to_dist_mat=aff_to_dist_mat,\n # pattern_aligner=core.CrossCorrelationPatternAligner(\n # pattern_comparison_settings=\n # affinitymat.core.PatternComparisonSettings(\n # track_names=(\n # contrib_scores_track_names+\n # other_comparison_track_names), \n # track_transformer=\n # affinitymat.MeanNormalizer().chain(\n # affinitymat.MagnitudeNormalizer()), \n # min_overlap=self.min_overlap_while_sliding)),\n # collapse_condition=(lambda prob, aligner_sim:\n # any([(prob > x[0] and aligner_sim > x[1])\n # for x in prob_and_sim_merge_thresholds])),\n # dealbreaker_condition=(lambda prob, aligner_sim:\n # any([(prob < x[0] and aligner_sim < x[1]) \n # for x in prob_and_sim_dealbreaker_thresholds])),\n # postprocessor=postprocessor1,\n # verbose=self.verbose)\n\n pattern_filterer = pattern_filterer_module.MinSeqletSupportFilterer(\n min_seqlet_support=self.final_min_cluster_size).chain(\n pattern_filterer_module.MinICinWindow(\n window_size=self.min_ic_windowsize,\n min_ic_in_window=self.min_ic_in_window,\n background=bg_freq,\n sequence_track_name=onehot_track_name,\n ppm_pseudocount=self.ppm_pseudocount \n ) \n )\n\n #seqlet_reassigner =\\\n # aggregator.ReassignSeqletsFromSmallClusters(\n # seqlet_assigner=aggregator.AssignSeqletsByBestMetric(\n # pattern_comparison_settings=pattern_comparison_settings,\n # individual_aligner_metric=\n # core.get_best_alignment_crosscontinjaccard,\n # matrix_affinity_metric=\n # affinitymat.core.CrossContinJaccardMultiCoreCPU(\n # verbose=self.verbose, n_cores=self.n_cores),\n # min_similarity=self.min_similarity_for_seqlet_assignment,\n # track_set=track_set),\n # min_cluster_size=self.final_min_cluster_size,\n # postprocessor=expand_trim_expand1,\n # verbose=self.verbose) \n\n final_postprocessor = aggregator.ExpandSeqletsToFillPattern(\n track_set=track_set,\n flank_to_add=self.final_flank_to_add) \n\n return TfModiscoSeqletsToPatterns(\n seqlets_sorter=seqlets_sorter,\n initclusterer_factory=initclusterer_factory,\n coarse_affmat_computer=coarse_affmat_computer,\n nearest_neighbors_to_compute=self.nearest_neighbors_to_compute,\n affmat_from_seqlets_with_nn_pairs=\n affmat_from_seqlets_with_nn_pairs, \n filter_mask_from_correlation=filter_mask_from_correlation,\n filter_beyond_first_round=self.filter_beyond_first_round,\n skip_fine_grained=self.skip_fine_grained,\n aff_to_dist_mat=aff_to_dist_mat,\n tsne_perplexity=self.tsne_perplexity,\n #density_adapted_affmat_transformer=\n # density_adapted_affmat_transformer,\n clusterer_per_round=clusterer_per_round,\n seqlet_aggregator=seqlet_aggregator,\n sign_consistency_func=sign_consistency_func,\n subcluster_settings=subcluster_settings,\n spurious_merge_detector=spurious_merge_detector,\n similar_patterns_collapser=similar_patterns_collapser,\n #seqlet_reassigner=seqlet_reassigner,\n pattern_filterer=pattern_filterer,\n final_postprocessor=final_postprocessor,\n verbose=self.verbose,\n n_cores=self.n_cores,\n other_config={\n 'onehot_track_name': onehot_track_name,\n 'contrib_scores_track_names': contrib_scores_track_names,\n 'hypothetical_contribs_track_names':\n hypothetical_contribs_track_names,\n 'track_signs': track_signs, \n 'other_comparison_track_names': other_comparison_track_names},\n )\n\n def save_hdf5(self, grp):\n grp.attrs['jsonable_config'] =\\\n json.dumps(self.jsonable_config, indent=4, separators=(',', ': ')) \n\n\nclass SeqletsToPatternsResults(object):\n\n def __init__(self,\n each_round_initcluster_motifs, \n patterns, \n remaining_patterns,\n pattern_merge_hierarchy,\n cluster_results,\n total_time_taken,\n other_config={},\n success=True,\n **kwargs):\n self.each_round_initcluster_motifs = each_round_initcluster_motifs\n self.other_config = other_config\n self.success = success\n self.patterns = patterns\n self.remaining_patterns = remaining_patterns\n self.pattern_merge_hierarchy = pattern_merge_hierarchy\n self.cluster_results = cluster_results\n self.total_time_taken = total_time_taken\n self.__dict__.update(**kwargs)\n\n def save_each_round_initcluster_motifs(self, grp):\n all_round_names = []\n for (round_idx,initcluster_motifs)\\\n in enumerate(self.each_round_initcluster_motifs):\n round_name = \"round_\"+str(round_idx)\n util.save_patterns(patterns=initcluster_motifs,\n grp=grp.create_group(round_name)) \n util.save_string_list(\n string_list=all_round_names,\n dset_name=\"all_round_names\", \n grp=grp)\n\n @classmethod\n def load_each_round_initcluster_motifs(cls, grp, track_set):\n all_round_names = util.load_string_list(dset_name=\"all_round_names\",\n grp=grp) \n each_round_initcluster_motifs = [] \n for round_name in all_round_names:\n round_grp = grp[round_name]\n initcluster_motifs = load_patterns(grp=round_grp,\n track_set=track_set)\n each_round_initcluster_motifs.append(initcluster_motifs)\n return each_round_initcluster_motifs\n \n @classmethod\n def from_hdf5(cls, grp, track_set):\n success = grp.attrs.get(\"success\", False)\n if (success):\n if (\"each_round_initcluster_motifs\" not in grp):\n each_round_initcluster_motifs = None \n else:\n each_round_initcluster_motifs =\\\n cls.load_each_round_initcluster_motifs(\n grp=grp[\"each_round_initcluster_motifs\"],\n track_set=track_set)\n patterns = util.load_patterns(grp=grp[\"patterns\"],\n track_set=track_set) \n if \"remaining_patterns\" in grp:\n remaining_patterns = util.load_patterns(\n grp=grp[\"remaining_patterns\"],\n track_set=track_set) \n else: #backwards compatibility\n remaining_patterns = []\n cluster_results = None\n total_time_taken = grp.attrs[\"total_time_taken\"]\n if (\"pattern_merge_hierarchy\" in grp):\n pattern_merge_hierarchy =\\\n aggregator.PatternMergeHierarchy.from_hdf5(\n grp=grp[\"pattern_merge_hierarchy\"],\n track_set=track_set)\n else:\n pattern_merge_hierarchy = None\n return cls(\n each_round_initcluster_motifs=each_round_initcluster_motifs,\n patterns=patterns,\n remaining_patterns=remaining_patterns,\n pattern_merge_hierarchy=pattern_merge_hierarchy,\n cluster_results=cluster_results,\n total_time_taken=total_time_taken)\n else:\n return cls(success=False, patterns=None, cluster_results=None,\n total_time_taken=None,\n each_round_initcluster_motifs=None,\n remaining_patterns=None,\n pattern_merge_hierarchy=None)\n\n def save_hdf5(self, grp):\n grp.attrs[\"success\"] = self.success\n grp.attrs[\"other_config\"] =\\\n json.dumps(self.other_config, indent=4, separators=(',', ': ')) \n if (self.success):\n grp.attrs[\"total_time_taken\"] = self.total_time_taken\n if (self.each_round_initcluster_motifs is not None):\n self.save_each_round_initcluster_motifs(\n grp=grp.create_group(\"each_round_initcluster_motifs\"))\n util.save_patterns(self.patterns,\n grp.create_group(\"patterns\"))\n util.save_patterns(\n self.remaining_patterns,\n grp.create_group(\"remaining_patterns\"))\n self.cluster_results.save_hdf5(grp.create_group(\"cluster_results\")) \n grp.attrs['total_time_taken'] = self.total_time_taken\n self.pattern_merge_hierarchy.save_hdf5(\n grp=grp.create_group(\"pattern_merge_hierarchy\"))\n\n\nclass AbstractSeqletsToPatterns(object):\n\n def __call__(self, seqlets):\n raise NotImplementedError()\n\n\nclass TfModiscoSeqletsToPatterns(AbstractSeqletsToPatterns):\n\n def __init__(self, seqlets_sorter, \n initclusterer_factory,\n coarse_affmat_computer,\n nearest_neighbors_to_compute,\n affmat_from_seqlets_with_nn_pairs, \n filter_mask_from_correlation,\n filter_beyond_first_round,\n skip_fine_grained,\n aff_to_dist_mat,\n tsne_perplexity,\n #density_adapted_affmat_transformer,\n clusterer_per_round,\n seqlet_aggregator,\n sign_consistency_func,\n spurious_merge_detector,\n similar_patterns_collapser,\n pattern_filterer,\n #seqlet_reassigner,\n final_postprocessor,\n subcluster_settings,\n n_cores,\n other_config={},\n verbose=True):\n\n self.seqlets_sorter = seqlets_sorter\n self.initclusterer_factory = initclusterer_factory\n self.coarse_affmat_computer = coarse_affmat_computer\n self.nearest_neighbors_to_compute = nearest_neighbors_to_compute\n self.affmat_from_seqlets_with_nn_pairs =\\\n affmat_from_seqlets_with_nn_pairs\n self.filter_mask_from_correlation = filter_mask_from_correlation\n self.filter_beyond_first_round = filter_beyond_first_round\n self.skip_fine_grained = skip_fine_grained\n self.aff_to_dist_mat = aff_to_dist_mat\n self.tsne_perplexity = tsne_perplexity\n #self.density_adapted_affmat_transformer =\\\n # density_adapted_affmat_transformer\n self.clusterer_per_round = clusterer_per_round \n self.seqlet_aggregator = seqlet_aggregator\n self.sign_consistency_func = sign_consistency_func\n \n self.spurious_merge_detector = spurious_merge_detector\n self.similar_patterns_collapser = similar_patterns_collapser\n #self.seqlet_reassigner = seqlet_reassigner\n self.pattern_filterer = pattern_filterer\n self.final_postprocessor = final_postprocessor\n\n self.verbose = verbose\n self.subcluster_settings = subcluster_settings\n self.n_cores = n_cores\n self.other_config = other_config\n\n def get_cluster_to_aggregate_motif(self, seqlets, cluster_indices,\n sign_consistency_check,\n min_seqlets_in_motif):\n num_clusters = max(cluster_indices+1)\n cluster_to_seqlets = defaultdict(list) \n assert len(seqlets)==len(cluster_indices)\n for seqlet,idx in zip(seqlets, cluster_indices):\n cluster_to_seqlets[idx].append(seqlet)\n\n cluster_to_motif = OrderedDict()\n cluster_to_eliminated_motif = OrderedDict()\n for i in range(num_clusters):\n if (len(cluster_to_seqlets[i]) >= min_seqlets_in_motif):\n if (self.verbose):\n print(\"Aggregating for cluster \"+str(i)+\" with \"\n +str(len(cluster_to_seqlets[i]))+\" seqlets\")\n print_memory_use()\n sys.stdout.flush()\n motifs = self.seqlet_aggregator(cluster_to_seqlets[i])\n assert len(motifs)<=1\n if (len(motifs) > 0):\n motif = motifs[0]\n if (sign_consistency_check==False or\n self.sign_consistency_func(motif)):\n cluster_to_motif[i] = motif\n else:\n if (self.verbose):\n print(\"Dropping cluster \"+str(i)+\n \" with \"+str(motif.num_seqlets)\n +\" seqlets due to sign disagreement\")\n cluster_to_eliminated_motif[i] = motif\n return cluster_to_motif, cluster_to_eliminated_motif\n\n def do_density_adaptation(self, new_rows_distmat_nn, new_rows_nn,\n new_rows_betas, new_rows_normfactors):\n new_rows_densadapted_affmat_nn = []\n for i in range(len(new_rows_distmat_nn)):\n densadapted_row = []\n for j,distance in zip(new_rows_nn[i], new_rows_distmat_nn[i]):\n densadapted_row.append(np.sqrt(\n (np.exp(-distance/new_rows_betas[i])/new_rows_normfactors[i])\n *(np.exp(-distance/new_rows_betas[j])/\n new_rows_normfactors[j]))) \n new_rows_densadapted_affmat_nn.append(densadapted_row)\n return new_rows_densadapted_affmat_nn\n\n def __call__(self, seqlets):\n\n seqlets = self.seqlets_sorter(seqlets)\n if (self.initclusterer_factory is not None):\n initclusterer = self.initclusterer_factory(seqlets=seqlets) \n else:\n initclusterer = None\n\n start = time.time()\n\n #seqlets_sets = []\n #coarse_affmats = []\n #nn_affmats = []\n #filtered_seqlets_sets = []\n #filtered_affmats = []\n #density_adapted_affmats = []\n #cluster_results_sets = []\n #cluster_to_motif_sets = []\n #cluster_to_eliminated_motif_sets = []\n\n if (initclusterer is not None):\n each_round_initcluster_motifs = []\n else:\n each_round_initcluster_motifs = None\n\n for round_idx, clusterer in enumerate(self.clusterer_per_round):\n import gc\n gc.collect()\n\n round_num = round_idx+1\n\n if (initclusterer is not None): \n initclusters = initclusterer(seqlets=seqlets)\n initcluster_motifs =\\\n list(self.get_cluster_to_aggregate_motif(\n seqlets=seqlets,\n cluster_indices=initclusters,\n sign_consistency_check=False,\n min_seqlets_in_motif=2)[0].values())\n each_round_initcluster_motifs.append(initcluster_motifs)\n else:\n initclusters = None\n initcluster_motifs = None\n \n if (len(seqlets)==0):\n if (self.verbose):\n print(\"len(seqlets) is 0 - bailing!\")\n return SeqletsToPatternsResults(\n each_round_initcluster_motifs=None,\n patterns=None,\n remaining_patterns=None,\n pattern_merge_hierarchy=None,\n cluster_results=None, \n total_time_taken=None,\n success=False,\n seqlets=None,\n affmat=None)\n\n if (self.verbose):\n print(\"(Round \"+str(round_num)+\n \") num seqlets: \"+str(len(seqlets)))\n print(\"(Round \"+str(round_num)+\") Computing coarse affmat\")\n print_memory_use()\n sys.stdout.flush()\n #coarse_affmat = self.coarse_affmat_computer(seqlets)\n #coarse_affmats.append(coarse_affmat)\n coarse_affmat_nn, seqlet_neighbors =\\\n self.coarse_affmat_computer(seqlets, initclusters=initclusters)\n gc.collect()\n\n if (self.verbose):\n print(\"(Round \"+str(round_num)+\") Computed coarse affmat\")\n print_memory_use()\n sys.stdout.flush()\n\n if (self.skip_fine_grained==False):\n #nn_start = time.time() \n #if (self.verbose):\n # print(\"(Round \"+str(round_num)+\") Compute nearest neighbors\"\n # +\" from coarse affmat\")\n # print_memory_use()\n # sys.stdout.flush()\n\n #seqlet_neighbors = get_seqlet_neighbors_with_initcluster(\n # nearest_neighbors_to_compute=\n # self.nearest_neighbors_to_compute,\n # coarse_affmat=coarse_affmat,\n # initclusters=initclusters)\n\n #if (self.verbose):\n # print(\"Computed nearest neighbors in\",\n # round(time.time()-nn_start,2),\"s\")\n # print_memory_use()\n # sys.stdout.flush()\n\n nn_affmat_start = time.time() \n if (self.verbose):\n print(\"(Round \"+str(round_num)+\") Computing affinity matrix\"\n +\" on nearest neighbors\")\n print_memory_use()\n sys.stdout.flush()\n #nn_affmat = self.affmat_from_seqlets_with_nn_pairs(\n # seqlet_neighbors=seqlet_neighbors,\n # seqlets=seqlets) \n #nn_affmats.append(nn_affmat)\n\n fine_affmat_nn = self.affmat_from_seqlets_with_nn_pairs(\n seqlet_neighbors=seqlet_neighbors,\n seqlets=seqlets,\n return_sparse=True)\n #get the fine_affmat_nn reorderings\n reorderings = np.array([np.argsort(-finesimsinrow)\n for finesimsinrow in fine_affmat_nn])\n\n #reorder fine_affmat_nn, coarse_affmat_nn and seqlet_neighbors\n # according to reorderings\n fine_affmat_nn = [finesimsinrow[rowreordering]\n for (finesimsinrow, rowreordering)\n in zip(fine_affmat_nn, reorderings)]\n coarse_affmat_nn = [coarsesimsinrow[rowreordering]\n for (coarsesimsinrow, rowreordering)\n in zip(coarse_affmat_nn, reorderings)]\n seqlet_neighbors = [nnrow[rowreordering]\n for (nnrow, rowreordering)\n in zip(seqlet_neighbors, reorderings)]\n\n del reorderings\n gc.collect()\n \n if (self.verbose):\n print(\"(Round \"+str(round_num)+\") Computed affinity matrix\"\n +\" on nearest neighbors in\",\n round(time.time()-nn_affmat_start,2),\"s\")\n print_memory_use()\n sys.stdout.flush()\n\n #filter by correlation\n if (round_idx == 0 or self.filter_beyond_first_round==True):\n #the filter_mask_from_correlation function only operates\n # on columns in which np.abs(main_affmat) > 0\n #filtered_rows_mask = self.filter_mask_from_correlation(\n # main_affmat=nn_affmat,\n # other_affmat=coarse_affmat) \n filtered_rows_mask = self.filter_mask_from_correlation(\n main_affmat=fine_affmat_nn,\n other_affmat=coarse_affmat_nn)\n if (self.verbose):\n print(\"(Round \"+str(round_num)+\") Retained \"\n +str(np.sum(filtered_rows_mask))\n +\" rows out of \"+str(len(filtered_rows_mask))\n +\" after filtering\")\n print_memory_use()\n sys.stdout.flush()\n else:\n filtered_rows_mask = np.array([True for x in seqlets])\n if (self.verbose):\n print(\"Not applying filtering for \"\n +\"rounds above first round\")\n print_memory_use()\n sys.stdout.flush()\n\n del coarse_affmat_nn \n gc.collect()\n\n filtered_seqlets = [x[0] for x in\n zip(seqlets, filtered_rows_mask) if (x[1])]\n if (initclusters is not None):\n filtered_initclusters = initclusters[filtered_rows_mask] \n else:\n filtered_initclusters = None\n #filtered_seqlets_sets.append(filtered_seqlets)\n\n #filtered_affmat =\\\n # nn_affmat[filtered_rows_mask][:,filtered_rows_mask]\n #del coarse_affmat\n #del nn_affmat\n\n #figure out a mapping from pre-filtering to the\n # post-filtering indices\n new_idx_mapping = (\n np.cumsum(1.0*(filtered_rows_mask)).astype(\"int\")-1)\n retained_indices = set(np.arange(len(filtered_rows_mask))[\n filtered_rows_mask])\n del filtered_rows_mask\n filtered_neighbors = []\n filtered_affmat_nn = []\n for old_row_idx, (old_neighbors,affmat_row) in enumerate(\n zip(seqlet_neighbors, fine_affmat_nn)): \n if old_row_idx in retained_indices:\n filtered_old_neighbors = [\n neighbor for neighbor in old_neighbors if neighbor\n in retained_indices]\n filtered_affmat_row = [\n affmatval for affmatval,neighbor\n in zip(affmat_row,old_neighbors)\n if neighbor in retained_indices]\n filtered_neighbors_row = [\n new_idx_mapping[neighbor] for neighbor\n in filtered_old_neighbors]\n filtered_neighbors.append(filtered_neighbors_row)\n filtered_affmat_nn.append(filtered_affmat_row)\n\n #overwrite seqlet_neighbors...should be ok if the rows are\n # not all the same length\n seqlet_neighbors = filtered_neighbors\n del (filtered_neighbors, retained_indices, new_idx_mapping)\n else:\n filtered_affmat = coarse_affmat_nn\n filtered_seqlets = seqlets\n if (initclusters is not None):\n filtered_initclusters = initclusters\n else:\n filtered_initclusters = None\n\n if (self.verbose):\n print(\"(Round \"+str(round_num)+\") Computing density \"\n +\"adapted affmat\")\n print_memory_use()\n sys.stdout.flush() \n\n #density_adapted_affmat =\\\n # self.density_adapted_affmat_transformer(filtered_affmat)\n #del filtered_affmat\n #density_adapted_affmats.append(density_adapted_affmat)\n\n #apply aff_to_dist_mat one row at a time\n distmat_nn = [self.aff_to_dist_mat(affinity_mat=x)\n for x in filtered_affmat_nn] \n del filtered_affmat_nn\n\n if (self.verbose):\n print(\"Symmetrizing nearest neighbors\")\n #Note: the fine-grained similarity metric isn't actually symmetric\n # because a different input will get padded with zeros depending\n # on which seqlets are specified as the filters and which seqlets\n # are specified as the 'thing to scan'. So explicit symmetrization\n # is worthwhile\n sym_seqlet_neighbors, sym_distmat_nn = util.symmetrize_nn_distmat(\n distmat_nn=distmat_nn, nn=seqlet_neighbors,\n average_with_transpose=True)\n del distmat_nn\n del seqlet_neighbors\n\n if (self.verbose):\n print(\"Computing betas for density adaptation\")\n\n #Compute beta values for the density adaptation. *store it*\n betas_and_ps = Parallel(n_jobs=self.n_cores)(\n delayed(util.binary_search_perplexity)(\n self.tsne_perplexity, distances)\n for distances in sym_distmat_nn)\n betas = np.array([x[0] for x in betas_and_ps])\n\n if (self.verbose):\n print(\"Computing normalizing denominators\")\n\n #also compute the normalization factor needed to get probs to sum to 1\n #note: sticking to lists here because different rows of\n # sym_distmat_nn may have different lengths after adding in\n # the symmetric pairs\n densadapted_affmat_nn_unnorm = [np.exp(-np.array(distmat_row)/beta)\n for distmat_row, beta in zip(sym_distmat_nn, betas)]\n normfactors = np.array([max(np.sum(x),1e-8) for x in\n densadapted_affmat_nn_unnorm])\n\n sym_densadapted_affmat_nn = self.do_density_adaptation(\n new_rows_distmat_nn=sym_distmat_nn,\n new_rows_nn=sym_seqlet_neighbors,\n new_rows_betas=betas,\n new_rows_normfactors=normfactors)\n\n util.verify_symmetric_nn_affmat(\n affmat_nn=sym_densadapted_affmat_nn,\n nn=sym_seqlet_neighbors)\n\n #Make csr matrix\n csr_density_adapted_affmat =\\\n util.coo_matrix_from_neighborsformat(\n entries=sym_densadapted_affmat_nn,\n neighbors=sym_seqlet_neighbors,\n ncols=len(sym_densadapted_affmat_nn)).tocsr()\n\n if (self.verbose):\n print(\"(Round \"+str(round_num)+\") Computing clustering\")\n print_memory_use()\n sys.stdout.flush() \n\n #cluster_results = clusterer(density_adapted_affmat,\n # initclusters=filtered_initclusters)\n #del density_adapted_affmat\n #cluster_results_sets.append(cluster_results)\n cluster_results = clusterer(csr_density_adapted_affmat,\n initclusters=filtered_initclusters)\n del csr_density_adapted_affmat\n\n num_clusters = max(cluster_results.cluster_indices+1)\n cluster_idx_counts = Counter(cluster_results.cluster_indices)\n if (self.verbose):\n print(\"Got \"+str(num_clusters)\n +\" clusters after round \"+str(round_num))\n print(\"Counts:\")\n print(dict([x for x in cluster_idx_counts.items()]))\n print_memory_use()\n sys.stdout.flush()\n\n if (self.verbose):\n print(\"(Round \"+str(round_num)+\") Aggregating seqlets\"\n +\" in each cluster\")\n print_memory_use()\n sys.stdout.flush()\n\n cluster_to_motif, cluster_to_eliminated_motif =\\\n self.get_cluster_to_aggregate_motif(\n seqlets=filtered_seqlets,\n cluster_indices=cluster_results.cluster_indices,\n sign_consistency_check=True,\n min_seqlets_in_motif=0)\n\n #obtain unique seqlets from adjusted motifs\n seqlets = list(dict([(y.exidx_start_end_string, y)\n for x in cluster_to_motif.values()\n for y in x.seqlets]).values())\n\n if (self.verbose):\n print(\"Got \"+str(len(cluster_to_motif.values()))+\" clusters\")\n print(\"Splitting into subclusters...\")\n print_memory_use()\n sys.stdout.flush()\n\n split_patterns = self.spurious_merge_detector(\n cluster_to_motif.values())\n\n if (len(split_patterns)==0):\n if (self.verbose):\n print(\"No more surviving patterns - bailing!\")\n return SeqletsToPatternsResults(\n each_round_initcluster_motifs=None,\n patterns=None,\n remaining_patterns=None,\n pattern_merge_hierarchy=None,\n cluster_results=None, \n total_time_taken=None,\n success=False,\n seqlets=None,\n affmat=None)\n\n #Now start merging patterns \n if (self.verbose):\n print(\"Merging on \"+str(len(split_patterns))+\" clusters\")\n print_memory_use()\n sys.stdout.flush()\n merged_patterns, pattern_merge_hierarchy =\\\n self.similar_patterns_collapser( \n patterns=split_patterns) \n merged_patterns = sorted(merged_patterns, key=lambda x: -x.num_seqlets)\n if (self.verbose):\n print(\"Got \"+str(len(merged_patterns))+\" patterns after merging\")\n print_memory_use()\n sys.stdout.flush()\n\n if (self.verbose):\n print(\"Performing filtering\")\n print_memory_use()\n sys.stdout.flush()\n\n final_patterns, remaining_patterns = self.pattern_filterer(\n merged_patterns)\n #reassigned_patterns = self.seqlet_reassigner(merged_patterns)\n final_patterns = self.final_postprocessor(final_patterns)\n remaining_patterns =\\\n self.final_postprocessor(remaining_patterns)\n\n if (self.verbose):\n print(\"Got \"+str(len(final_patterns))\n +\" patterns after filtering\")\n print_memory_use()\n sys.stdout.flush()\n\n total_time_taken = round(time.time()-start,2)\n if (self.verbose):\n print(\"Total time taken is \"\n +str(total_time_taken)+\"s\")\n print_memory_use()\n sys.stdout.flush()\n\n #apply subclustering procedure on the final patterns\n print(\"Applying subclustering to the final motifs\")\n for patternidx, pattern in enumerate(final_patterns):\n print(\"On pattern\",patternidx)\n pattern.compute_subclusters_and_embedding(\n verbose=self.verbose,\n **self.subcluster_settings)\n\n results = SeqletsToPatternsResults(\n each_round_initcluster_motifs=each_round_initcluster_motifs, \n patterns=final_patterns,\n remaining_patterns=remaining_patterns,\n seqlets=filtered_seqlets, #last stage of filtered seqlets\n #affmat=filtered_affmat,\n cluster_results=cluster_results, \n total_time_taken=total_time_taken,\n \n #seqlets_sets=seqlets_sets,\n #coarse_affmats=coarse_affmats,\n #nn_affmats=nn_affmats,\n #filtered_seqlets_sets=filtered_seqlets_sets,\n #filtered_affmats=filtered_affmats,\n #density_adapted_affmats=density_adapted_affmats,\n #cluster_results_sets=cluster_results_sets,\n #cluster_to_motif_sets=cluster_to_motif_sets,\n #cluster_to_eliminated_motif_sets=cluster_to_eliminated_motif_sets,\n\n merged_patterns=merged_patterns,\n pattern_merge_hierarchy=pattern_merge_hierarchy,\n #reassigned_patterns=reassigned_patterns\n )\n\n return results\n", "meta": {"hexsha": "65a2a4a0319cf5fc0d5c564e05aa342c6fb5c5ee", "size": 55786, "ext": "py", "lang": "Python", "max_stars_repo_path": "modisco/tfmodisco_workflow/seqlets_to_patterns.py", "max_stars_repo_name": "kundajelab/tfmodisco", "max_stars_repo_head_hexsha": "cb2ec8ee33cbea1fe00ea41292075c8df4eabf44", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 70, "max_stars_repo_stars_event_min_datetime": "2018-05-21T01:47:12.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-12T04:15:27.000Z", "max_issues_repo_path": "modisco/tfmodisco_workflow/seqlets_to_patterns.py", "max_issues_repo_name": "kundajelab/tfmodisco", "max_issues_repo_head_hexsha": "cb2ec8ee33cbea1fe00ea41292075c8df4eabf44", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 36, "max_issues_repo_issues_event_min_datetime": "2018-06-04T21:39:43.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-15T15:24:11.000Z", "max_forks_repo_path": "modisco/tfmodisco_workflow/seqlets_to_patterns.py", "max_forks_repo_name": "kundajelab/tfmodisco", "max_forks_repo_head_hexsha": "cb2ec8ee33cbea1fe00ea41292075c8df4eabf44", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 22, "max_forks_repo_forks_event_min_datetime": "2018-06-04T19:51:15.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-06T23:27:18.000Z", "avg_line_length": 45.9901071723, "max_line_length": 85, "alphanum_fraction": 0.5851826623, "include": true, "reason": "import numpy", "num_tokens": 10844, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073655352404, "lm_q2_score": 0.3451052776934245, "lm_q1q2_score": 0.190017507783084}} {"text": "# Copyright Contributors to the Pyro project.\n# SPDX-License-Identifier: Apache-2.0\n\nfrom collections import namedtuple\nfrom contextlib import contextmanager\nfrom functools import partial\nfrom typing import Callable, Dict, List, Optional\nimport warnings\n\nimport numpy as np\n\nimport jax\nfrom jax import device_get, jacfwd, lax, random, tree_flatten, value_and_grad\nfrom jax.flatten_util import ravel_pytree\nfrom jax.lax import broadcast_shapes\nimport jax.numpy as jnp\nfrom jax.tree_util import tree_map\n\nimport numpyro\nfrom numpyro.distributions import constraints\nfrom numpyro.distributions.transforms import biject_to\nfrom numpyro.distributions.util import is_identically_one, sum_rightmost\nfrom numpyro.handlers import condition, replay, seed, substitute, trace\nfrom numpyro.infer.initialization import init_to_uniform, init_to_value\nfrom numpyro.util import (\n _validate_model,\n find_stack_level,\n not_jax_tracer,\n soft_vmap,\n while_loop,\n)\n\n__all__ = [\n \"find_valid_initial_params\",\n \"get_potential_fn\",\n \"log_density\",\n \"log_likelihood\",\n \"potential_energy\",\n \"initialize_model\",\n \"Predictive\",\n]\n\nModelInfo = namedtuple(\n \"ModelInfo\", [\"param_info\", \"potential_fn\", \"postprocess_fn\", \"model_trace\"]\n)\nParamInfo = namedtuple(\"ParamInfo\", [\"z\", \"potential_energy\", \"z_grad\"])\n\n\ndef log_density(model, model_args, model_kwargs, params):\n \"\"\"\n (EXPERIMENTAL INTERFACE) Computes log of joint density for the model given\n latent values ``params``.\n\n :param model: Python callable containing NumPyro primitives.\n :param tuple model_args: args provided to the model.\n :param dict model_kwargs: kwargs provided to the model.\n :param dict params: dictionary of current parameter values keyed by site\n name.\n :return: log of joint density and a corresponding model trace\n \"\"\"\n model = substitute(model, data=params)\n model_trace = trace(model).get_trace(*model_args, **model_kwargs)\n log_joint = jnp.zeros(())\n for site in model_trace.values():\n if site[\"type\"] == \"sample\":\n value = site[\"value\"]\n intermediates = site[\"intermediates\"]\n scale = site[\"scale\"]\n if intermediates:\n log_prob = site[\"fn\"].log_prob(value, intermediates)\n else:\n guide_shape = jnp.shape(value)\n model_shape = tuple(\n site[\"fn\"].shape()\n ) # TensorShape from tfp needs casting to tuple\n try:\n broadcast_shapes(guide_shape, model_shape)\n except ValueError:\n raise ValueError(\n \"Model and guide shapes disagree at site: '{}': {} vs {}\".format(\n site[\"name\"], model_shape, guide_shape\n )\n )\n log_prob = site[\"fn\"].log_prob(value)\n\n if (scale is not None) and (not is_identically_one(scale)):\n log_prob = scale * log_prob\n\n log_prob = jnp.sum(log_prob)\n log_joint = log_joint + log_prob\n return log_joint, model_trace\n\n\nclass _without_rsample_stop_gradient(numpyro.primitives.Messenger):\n \"\"\"\n Stop gradient for samples at latent sample sites for which has_rsample=False.\n \"\"\"\n\n def postprocess_message(self, msg):\n if (\n msg[\"type\"] == \"sample\"\n and (not msg[\"is_observed\"])\n and (not msg[\"fn\"].has_rsample)\n ):\n msg[\"value\"] = lax.stop_gradient(msg[\"value\"])\n # TODO: reconsider this logic\n # here we clear all the cached value so that gradients of log_prob(value) w.r.t.\n # all parameters of the transformed distributions match the behavior of\n # TransformedDistribution(d, transform) in Pyro with transform.cache_size == 0\n msg[\"intermediates\"] = None\n\n\ndef get_importance_trace(model, guide, args, kwargs, params):\n \"\"\"\n (EXPERIMENTAL) Returns traces from the guide and the model that is run against it.\n The returned traces also store the log probability at each site.\n\n .. note:: Gradients are blocked at latent sites which do not have reparametrized samplers.\n \"\"\"\n guide = substitute(guide, data=params)\n with _without_rsample_stop_gradient():\n guide_trace = trace(guide).get_trace(*args, **kwargs)\n model = substitute(replay(model, guide_trace), data=params)\n model_trace = trace(model).get_trace(*args, **kwargs)\n for tr in (guide_trace, model_trace):\n for site in tr.values():\n if site[\"type\"] == \"sample\":\n if \"log_prob\" not in site:\n value = site[\"value\"]\n intermediates = site[\"intermediates\"]\n scale = site[\"scale\"]\n if intermediates:\n log_prob = site[\"fn\"].log_prob(value, intermediates)\n else:\n log_prob = site[\"fn\"].log_prob(value)\n\n if (scale is not None) and (not is_identically_one(scale)):\n log_prob = scale * log_prob\n site[\"log_prob\"] = log_prob\n return model_trace, guide_trace\n\n\ndef transform_fn(transforms, params, invert=False):\n \"\"\"\n (EXPERIMENTAL INTERFACE) Callable that applies a transformation from the `transforms`\n dict to values in the `params` dict and returns the transformed values keyed on\n the same names.\n\n :param transforms: Dictionary of transforms keyed by names. Names in\n `transforms` and `params` should align.\n :param params: Dictionary of arrays keyed by names.\n :param invert: Whether to apply the inverse of the transforms.\n :return: `dict` of transformed params.\n \"\"\"\n if invert:\n transforms = {k: v.inv for k, v in transforms.items()}\n return {k: transforms[k](v) if k in transforms else v for k, v in params.items()}\n\n\ndef constrain_fn(model, model_args, model_kwargs, params, return_deterministic=False):\n \"\"\"\n (EXPERIMENTAL INTERFACE) Gets value at each latent site in `model` given\n unconstrained parameters `params`. The `transforms` is used to transform these\n unconstrained parameters to base values of the corresponding priors in `model`.\n If a prior is a transformed distribution, the corresponding base value lies in\n the support of base distribution. Otherwise, the base value lies in the support\n of the distribution.\n\n :param model: a callable containing NumPyro primitives.\n :param tuple model_args: args provided to the model.\n :param dict model_kwargs: kwargs provided to the model.\n :param dict params: dictionary of unconstrained values keyed by site\n names.\n :param bool return_deterministic: whether to return the value of `deterministic`\n sites from the model. Defaults to `False`.\n :return: `dict` of transformed params.\n \"\"\"\n\n def substitute_fn(site):\n if site[\"name\"] in params:\n if site[\"type\"] == \"sample\":\n with helpful_support_errors(site):\n return biject_to(site[\"fn\"].support)(params[site[\"name\"]])\n else:\n return params[site[\"name\"]]\n\n substituted_model = substitute(model, substitute_fn=substitute_fn)\n model_trace = trace(substituted_model).get_trace(*model_args, **model_kwargs)\n return {\n k: v[\"value\"]\n for k, v in model_trace.items()\n if (k in params) or (return_deterministic and (v[\"type\"] == \"deterministic\"))\n }\n\n\ndef _unconstrain_reparam(params, site):\n name = site[\"name\"]\n if name in params:\n p = params[name]\n support = site[\"fn\"].support\n with helpful_support_errors(site):\n t = biject_to(support)\n # in scan, we might only want to substitute an item at index i, rather than the whole sequence\n i = site[\"infer\"].get(\"_scan_current_index\", None)\n if i is not None:\n event_dim_shift = t.codomain.event_dim - t.domain.event_dim\n expected_unconstrained_dim = len(site[\"fn\"].shape()) - event_dim_shift\n # check if p has additional time dimension\n if jnp.ndim(p) > expected_unconstrained_dim:\n p = p[i]\n\n if support in [constraints.real, constraints.real_vector]:\n return p\n value = t(p)\n\n log_det = t.log_abs_det_jacobian(p, value)\n log_det = sum_rightmost(\n log_det, jnp.ndim(log_det) - jnp.ndim(value) + len(site[\"fn\"].event_shape)\n )\n if site[\"scale\"] is not None:\n log_det = site[\"scale\"] * log_det\n numpyro.factor(\"_{}_log_det\".format(name), log_det)\n return value\n\n\ndef potential_energy(model, model_args, model_kwargs, params, enum=False):\n \"\"\"\n (EXPERIMENTAL INTERFACE) Computes potential energy of a model given unconstrained params.\n Under the hood, we will transform these unconstrained parameters to the values\n belong to the supports of the corresponding priors in `model`.\n\n :param model: a callable containing NumPyro primitives.\n :param tuple model_args: args provided to the model.\n :param dict model_kwargs: kwargs provided to the model.\n :param dict params: unconstrained parameters of `model`.\n :param bool enum: whether to enumerate over discrete latent sites.\n :return: potential energy given unconstrained parameters.\n \"\"\"\n if enum:\n from numpyro.contrib.funsor import log_density as log_density_\n else:\n log_density_ = log_density\n\n substituted_model = substitute(\n model, substitute_fn=partial(_unconstrain_reparam, params)\n )\n # no param is needed for log_density computation because we already substitute\n log_joint, model_trace = log_density_(\n substituted_model, model_args, model_kwargs, {}\n )\n return -log_joint\n\n\ndef _init_to_unconstrained_value(site=None, values={}):\n if site is None:\n return partial(_init_to_unconstrained_value, values=values)\n\n\ndef find_valid_initial_params(\n rng_key,\n model,\n *,\n init_strategy=init_to_uniform,\n enum=False,\n model_args=(),\n model_kwargs=None,\n prototype_params=None,\n forward_mode_differentiation=False,\n validate_grad=True,\n):\n \"\"\"\n (EXPERIMENTAL INTERFACE) Given a model with Pyro primitives, returns an initial\n valid unconstrained value for all the parameters. This function also returns\n the corresponding potential energy, the gradients, and an\n `is_valid` flag to say whether the initial parameters are valid. Parameter values\n are considered valid if the values and the gradients for the log density have\n finite values.\n\n :param jax.random.PRNGKey rng_key: random number generator seed to\n sample from the prior. The returned `init_params` will have the\n batch shape ``rng_key.shape[:-1]``.\n :param model: Python callable containing Pyro primitives.\n :param callable init_strategy: a per-site initialization function.\n :param bool enum: whether to enumerate over discrete latent sites.\n :param tuple model_args: args provided to the model.\n :param dict model_kwargs: kwargs provided to the model.\n :param dict prototype_params: an optional prototype parameters, which is used\n to define the shape for initial parameters.\n :param bool forward_mode_differentiation: whether to use forward-mode differentiation\n or reverse-mode differentiation. Defaults to False.\n :param bool validate_grad: whether to validate gradient of the initial params.\n Defaults to True.\n :return: tuple of `init_params_info` and `is_valid`, where `init_params_info` is the tuple\n containing the initial params, their potential energy, and their gradients.\n \"\"\"\n model_kwargs = {} if model_kwargs is None else model_kwargs\n init_strategy = (\n init_strategy if isinstance(init_strategy, partial) else init_strategy()\n )\n # handle those init strategies differently to save computation\n if init_strategy.func is init_to_uniform:\n radius = init_strategy.keywords.get(\"radius\")\n init_values = {}\n elif init_strategy.func is _init_to_unconstrained_value:\n radius = 2\n init_values = init_strategy.keywords.get(\"values\")\n else:\n radius = None\n\n def cond_fn(state):\n i, _, _, is_valid = state\n return (i < 100) & (~is_valid)\n\n def body_fn(state):\n i, key, _, _ = state\n key, subkey = random.split(key)\n\n if radius is None or prototype_params is None:\n # XXX: we don't want to apply enum to draw latent samples\n model_ = model\n if enum:\n from numpyro.contrib.funsor import enum as enum_handler\n\n if isinstance(model, substitute) and isinstance(model.fn, enum_handler):\n model_ = substitute(model.fn.fn, data=model.data)\n elif isinstance(model, enum_handler):\n model_ = model.fn\n\n # Wrap model in a `substitute` handler to initialize from `init_loc_fn`.\n seeded_model = substitute(seed(model_, subkey), substitute_fn=init_strategy)\n model_trace = trace(seeded_model).get_trace(*model_args, **model_kwargs)\n constrained_values, inv_transforms = {}, {}\n for k, v in model_trace.items():\n if (\n v[\"type\"] == \"sample\"\n and not v[\"is_observed\"]\n and not v[\"fn\"].support.is_discrete\n ):\n constrained_values[k] = v[\"value\"]\n with helpful_support_errors(v):\n inv_transforms[k] = biject_to(v[\"fn\"].support)\n params = transform_fn(\n inv_transforms,\n {k: v for k, v in constrained_values.items()},\n invert=True,\n )\n else: # this branch doesn't require tracing the model\n params = {}\n for k, v in prototype_params.items():\n if k in init_values:\n params[k] = init_values[k]\n else:\n params[k] = random.uniform(\n subkey, jnp.shape(v), minval=-radius, maxval=radius\n )\n key, subkey = random.split(key)\n\n potential_fn = partial(\n potential_energy, model, model_args, model_kwargs, enum=enum\n )\n if validate_grad:\n if forward_mode_differentiation:\n pe = potential_fn(params)\n z_grad = jacfwd(potential_fn)(params)\n else:\n pe, z_grad = value_and_grad(potential_fn)(params)\n z_grad_flat = ravel_pytree(z_grad)[0]\n is_valid = jnp.isfinite(pe) & jnp.all(jnp.isfinite(z_grad_flat))\n else:\n pe = potential_fn(params)\n is_valid = jnp.isfinite(pe)\n z_grad = None\n\n return i + 1, key, (params, pe, z_grad), is_valid\n\n def _find_valid_params(rng_key, exit_early=False):\n init_state = (0, rng_key, (prototype_params, 0.0, prototype_params), False)\n if exit_early and not_jax_tracer(rng_key):\n # Early return if valid params found. This is only helpful for single chain,\n # where we can avoid compiling body_fn in while_loop.\n _, _, (init_params, pe, z_grad), is_valid = init_state = body_fn(init_state)\n if not_jax_tracer(is_valid):\n if device_get(is_valid):\n return (init_params, pe, z_grad), is_valid\n\n # XXX: this requires compiling the model, so for multi-chain, we trace the model 2-times\n # even if the init_state is a valid result\n _, _, (init_params, pe, z_grad), is_valid = while_loop(\n cond_fn, body_fn, init_state\n )\n return (init_params, pe, z_grad), is_valid\n\n # Handle possible vectorization\n if rng_key.ndim == 1:\n (init_params, pe, z_grad), is_valid = _find_valid_params(\n rng_key, exit_early=True\n )\n else:\n (init_params, pe, z_grad), is_valid = lax.map(_find_valid_params, rng_key)\n return (init_params, pe, z_grad), is_valid\n\n\ndef _get_model_transforms(model, model_args=(), model_kwargs=None):\n model_kwargs = {} if model_kwargs is None else model_kwargs\n model_trace = trace(model).get_trace(*model_args, **model_kwargs)\n inv_transforms = {}\n # model code may need to be replayed in the presence of deterministic sites\n replay_model = False\n has_enumerate_support = False\n for k, v in model_trace.items():\n if v[\"type\"] == \"sample\" and not v[\"is_observed\"]:\n if v[\"fn\"].support.is_discrete:\n enum_type = v[\"infer\"].get(\"enumerate\")\n if enum_type is not None and (enum_type != \"parallel\"):\n raise RuntimeError(\n \"This algorithm might only work for discrete sites with\"\n f\" enumerate marked 'parallel'. But the site {k} is marked\"\n f\" as '{enum_type}'.\"\n )\n has_enumerate_support = True\n if not v[\"fn\"].has_enumerate_support:\n dist_name = type(v[\"fn\"]).__name__\n raise RuntimeError(\n \"This algorithm might only work for discrete sites with\"\n f\" enumerate support. But the {dist_name} distribution at\"\n f\" site {k} does not have enumerate support.\"\n )\n if enum_type is None:\n warnings.warn(\n \"Some algorithms will automatically enumerate the discrete\"\n f\" latent site {k} of your model. In the future,\"\n \" enumerated sites need to be marked with\"\n \" `infer={'enumerate': 'parallel'}`.\",\n FutureWarning,\n stacklevel=find_stack_level(),\n )\n else:\n support = v[\"fn\"].support\n with helpful_support_errors(v, raise_warnings=True):\n inv_transforms[k] = biject_to(support)\n # XXX: the following code filters out most situations with dynamic supports\n args = ()\n if isinstance(support, constraints._GreaterThan):\n args = (\"lower_bound\",)\n elif isinstance(support, constraints._Interval):\n args = (\"lower_bound\", \"upper_bound\")\n for arg in args:\n if not isinstance(getattr(support, arg), (int, float)):\n replay_model = True\n elif v[\"type\"] == \"deterministic\":\n replay_model = True\n return inv_transforms, replay_model, has_enumerate_support, model_trace\n\n\ndef _partial_args_kwargs(fn, *args, **kwargs):\n \"\"\"Returns a partial function of `fn` and args, kwargs.\"\"\"\n return partial(fn, args, kwargs)\n\n\ndef _drop_args_kwargs(fn, *args, **kwargs):\n \"\"\"Returns the input function `fn`, ignoring args and kwargs.\"\"\"\n return fn\n\n\ndef get_potential_fn(\n model,\n inv_transforms,\n *,\n enum=False,\n replay_model=False,\n dynamic_args=False,\n model_args=(),\n model_kwargs=None,\n):\n \"\"\"\n (EXPERIMENTAL INTERFACE) Given a model with Pyro primitives, returns a\n function which, given unconstrained parameters, evaluates the potential\n energy (negative log joint density). In addition, this returns a\n function to transform unconstrained values at sample sites to constrained\n values within their respective support.\n\n :param model: Python callable containing Pyro primitives.\n :param dict inv_transforms: dictionary of transforms keyed by names.\n :param bool enum: whether to enumerate over discrete latent sites.\n :param bool replay_model: whether we need to replay model in\n `postprocess_fn` to obtain `deterministic` sites.\n :param bool dynamic_args: if `True`, the `potential_fn` and\n `constraints_fn` are themselves dependent on model arguments.\n When provided a `*model_args, **model_kwargs`, they return\n `potential_fn` and `constraints_fn` callables, respectively.\n :param tuple model_args: args provided to the model.\n :param dict model_kwargs: kwargs provided to the model.\n :return: tuple of (`potential_fn`, `postprocess_fn`). The latter is used\n to constrain unconstrained samples (e.g. those returned by HMC)\n to values that lie within the site's support, and return values at\n `deterministic` sites in the model.\n \"\"\"\n if dynamic_args:\n potential_fn = partial(\n _partial_args_kwargs, partial(potential_energy, model, enum=enum)\n )\n if replay_model:\n # XXX: we seed to sample discrete sites (but not collect them)\n model_ = seed(model.fn, 0) if enum else model\n postprocess_fn = partial(\n _partial_args_kwargs,\n partial(constrain_fn, model, return_deterministic=True),\n )\n else:\n postprocess_fn = partial(\n _drop_args_kwargs, partial(transform_fn, inv_transforms)\n )\n else:\n model_kwargs = {} if model_kwargs is None else model_kwargs\n potential_fn = partial(\n potential_energy, model, model_args, model_kwargs, enum=enum\n )\n if replay_model:\n model_ = seed(model.fn, 0) if enum else model\n postprocess_fn = partial(\n constrain_fn,\n model_,\n model_args,\n model_kwargs,\n return_deterministic=True,\n )\n else:\n postprocess_fn = partial(transform_fn, inv_transforms)\n\n return potential_fn, postprocess_fn\n\n\ndef _guess_max_plate_nesting(model_trace):\n \"\"\"\n Guesses max_plate_nesting by using model trace.\n This optimistically assumes static model\n structure.\n \"\"\"\n sites = [site for site in model_trace.values() if site[\"type\"] == \"sample\"]\n\n dims = [\n frame.dim\n for site in sites\n for frame in site[\"cond_indep_stack\"]\n if frame.dim is not None\n ]\n max_plate_nesting = -min(dims) if dims else 0\n return max_plate_nesting\n\n\ndef initialize_model(\n rng_key,\n model,\n *,\n init_strategy=init_to_uniform,\n dynamic_args=False,\n model_args=(),\n model_kwargs=None,\n forward_mode_differentiation=False,\n validate_grad=True,\n):\n \"\"\"\n (EXPERIMENTAL INTERFACE) Helper function that calls :func:`~numpyro.infer.util.get_potential_fn`\n and :func:`~numpyro.infer.util.find_valid_initial_params` under the hood\n to return a tuple of (`init_params_info`, `potential_fn`, `postprocess_fn`, `model_trace`).\n\n :param jax.random.PRNGKey rng_key: random number generator seed to\n sample from the prior. The returned `init_params` will have the\n batch shape ``rng_key.shape[:-1]``.\n :param model: Python callable containing Pyro primitives.\n :param callable init_strategy: a per-site initialization function.\n See :ref:`init_strategy` section for available functions.\n :param bool dynamic_args: if `True`, the `potential_fn` and\n `constraints_fn` are themselves dependent on model arguments.\n When provided a `*model_args, **model_kwargs`, they return\n `potential_fn` and `constraints_fn` callables, respectively.\n :param tuple model_args: args provided to the model.\n :param dict model_kwargs: kwargs provided to the model.\n :param bool forward_mode_differentiation: whether to use forward-mode differentiation\n or reverse-mode differentiation. By default, we use reverse mode but the forward\n mode can be useful in some cases to improve the performance. In addition, some\n control flow utility on JAX such as `jax.lax.while_loop` or `jax.lax.fori_loop`\n only supports forward-mode differentiation. See\n `JAX's The Autodiff Cookbook `_\n for more information.\n :param bool validate_grad: whether to validate gradient of the initial params.\n Defaults to True.\n :return: a namedtupe `ModelInfo` which contains the fields\n (`param_info`, `potential_fn`, `postprocess_fn`, `model_trace`), where\n `param_info` is a namedtuple `ParamInfo` containing values from the prior\n used to initiate MCMC, their corresponding potential energy, and their gradients;\n `postprocess_fn` is a callable that uses inverse transforms\n to convert unconstrained HMC samples to constrained values that\n lie within the site's support, in addition to returning values\n at `deterministic` sites in the model.\n \"\"\"\n model_kwargs = {} if model_kwargs is None else model_kwargs\n substituted_model = substitute(\n seed(model, rng_key if jnp.ndim(rng_key) == 1 else rng_key[0]),\n substitute_fn=init_strategy,\n )\n (\n inv_transforms,\n replay_model,\n has_enumerate_support,\n model_trace,\n ) = _get_model_transforms(substituted_model, model_args, model_kwargs)\n # substitute param sites from model_trace to model so\n # we don't need to generate again parameters of `numpyro.module`\n model = substitute(\n model,\n data={\n k: site[\"value\"]\n for k, site in model_trace.items()\n if site[\"type\"] in [\"param\"]\n },\n )\n constrained_values = {\n k: v[\"value\"]\n for k, v in model_trace.items()\n if v[\"type\"] == \"sample\"\n and not v[\"is_observed\"]\n and not v[\"fn\"].support.is_discrete\n }\n\n if has_enumerate_support:\n from numpyro.contrib.funsor import config_enumerate, enum\n\n if not isinstance(model, enum):\n max_plate_nesting = _guess_max_plate_nesting(model_trace)\n _validate_model(model_trace, plate_warning=\"error\")\n model = enum(config_enumerate(model), -max_plate_nesting - 1)\n else:\n _validate_model(model_trace, plate_warning=\"loose\")\n\n potential_fn, postprocess_fn = get_potential_fn(\n model,\n inv_transforms,\n replay_model=replay_model,\n enum=has_enumerate_support,\n dynamic_args=dynamic_args,\n model_args=model_args,\n model_kwargs=model_kwargs,\n )\n\n init_strategy = (\n init_strategy if isinstance(init_strategy, partial) else init_strategy()\n )\n if (init_strategy.func is init_to_value) and not replay_model:\n init_values = init_strategy.keywords.get(\"values\")\n unconstrained_values = transform_fn(inv_transforms, init_values, invert=True)\n init_strategy = _init_to_unconstrained_value(values=unconstrained_values)\n prototype_params = transform_fn(inv_transforms, constrained_values, invert=True)\n (init_params, pe, grad), is_valid = find_valid_initial_params(\n rng_key,\n substitute(\n model,\n data={\n k: site[\"value\"]\n for k, site in model_trace.items()\n if site[\"type\"] in [\"plate\"]\n },\n ),\n init_strategy=init_strategy,\n enum=has_enumerate_support,\n model_args=model_args,\n model_kwargs=model_kwargs,\n prototype_params=prototype_params,\n forward_mode_differentiation=forward_mode_differentiation,\n validate_grad=validate_grad,\n )\n\n if not_jax_tracer(is_valid):\n if device_get(~jnp.all(is_valid)):\n with numpyro.validation_enabled(), trace() as tr:\n # validate parameters\n substituted_model(*model_args, **model_kwargs)\n # validate values\n for site in tr.values():\n if site[\"type\"] == \"sample\":\n with warnings.catch_warnings(record=True) as ws:\n site[\"fn\"]._validate_sample(site[\"value\"])\n if len(ws) > 0:\n for w in ws:\n # at site information to the warning message\n w.message.args = (\n \"Site {}: {}\".format(\n site[\"name\"], w.message.args[0]\n ),\n ) + w.message.args[1:]\n warnings.showwarning(\n w.message,\n w.category,\n w.filename,\n w.lineno,\n file=w.file,\n line=w.line,\n )\n raise RuntimeError(\n \"Cannot find valid initial parameters. Please check your model again.\"\n )\n return ModelInfo(\n ParamInfo(init_params, pe, grad), potential_fn, postprocess_fn, model_trace\n )\n\n\ndef _predictive(\n rng_key,\n model,\n posterior_samples,\n batch_shape,\n return_sites=None,\n infer_discrete=False,\n parallel=True,\n model_args=(),\n model_kwargs={},\n):\n masked_model = numpyro.handlers.mask(model, mask=False)\n if infer_discrete:\n # inspect the model to get some structure\n rng_key, subkey = random.split(rng_key)\n batch_ndim = len(batch_shape)\n prototype_sample = tree_map(\n lambda x: jnp.reshape(x, (-1,) + jnp.shape(x)[batch_ndim:])[0],\n posterior_samples,\n )\n prototype_trace = trace(\n seed(substitute(masked_model, prototype_sample), subkey)\n ).get_trace(*model_args, **model_kwargs)\n first_available_dim = -_guess_max_plate_nesting(prototype_trace) - 1\n\n def single_prediction(val):\n rng_key, samples = val\n if infer_discrete:\n from numpyro.contrib.funsor import config_enumerate\n from numpyro.contrib.funsor.discrete import _sample_posterior\n\n model_trace = prototype_trace\n temperature = 1\n pred_samples = _sample_posterior(\n config_enumerate(condition(model, samples)),\n first_available_dim,\n temperature,\n rng_key,\n *model_args,\n **model_kwargs,\n )\n else:\n model_trace = trace(\n seed(substitute(masked_model, samples), rng_key)\n ).get_trace(*model_args, **model_kwargs)\n pred_samples = {name: site[\"value\"] for name, site in model_trace.items()}\n\n if return_sites is not None:\n if return_sites == \"\":\n sites = {\n k for k, site in model_trace.items() if site[\"type\"] != \"plate\"\n }\n else:\n sites = return_sites\n else:\n sites = {\n k\n for k, site in model_trace.items()\n if (site[\"type\"] == \"sample\" and k not in samples)\n or (site[\"type\"] == \"deterministic\")\n }\n return {name: value for name, value in pred_samples.items() if name in sites}\n\n num_samples = int(np.prod(batch_shape))\n if num_samples > 1:\n rng_key = random.split(rng_key, num_samples)\n rng_key = rng_key.reshape((*batch_shape, 2))\n chunk_size = num_samples if parallel else 1\n return soft_vmap(\n single_prediction, (rng_key, posterior_samples), len(batch_shape), chunk_size\n )\n\n\nclass Predictive(object):\n \"\"\"\n This class is used to construct predictive distribution. The predictive distribution is obtained\n by running model conditioned on latent samples from `posterior_samples`.\n\n .. warning::\n The interface for the `Predictive` class is experimental, and\n might change in the future.\n\n :param model: Python callable containing Pyro primitives.\n :param dict posterior_samples: dictionary of samples from the posterior.\n :param callable guide: optional guide to get posterior samples of sites not present\n in `posterior_samples`.\n :param dict params: dictionary of values for param sites of model/guide.\n :param int num_samples: number of samples\n :param list return_sites: sites to return; by default only sample sites not present\n in `posterior_samples` are returned.\n :param bool infer_discrete: whether or not to sample discrete sites from the\n posterior, conditioned on observations and other latent values in\n ``posterior_samples``. Under the hood, those sites will be marked with\n ``site[\"infer\"][\"enumerate\"] = \"parallel\"``. See how `infer_discrete` works at\n the `Pyro enumeration tutorial `_.\n Note that this requires ``funsor`` installation.\n :param bool parallel: whether to predict in parallel using JAX vectorized map :func:`jax.vmap`.\n Defaults to False.\n :param batch_ndims: the number of batch dimensions in posterior samples or parameters. If `None` defaults\n to 0 if guide is set (i.e. not `None`) and 1 otherwise. Usages for batched posterior samples:\n\n + set `batch_ndims=0` to get prediction for 1 single sample\n\n + set `batch_ndims=1` to get prediction for `posterior_samples`\n with shapes `(num_samples x ...)` (same as`batch_ndims=None` with `guide=None`)\n\n + set `batch_ndims=2` to get prediction for `posterior_samples`\n with shapes `(num_chains x N x ...)`. Note that if `num_samples`\n argument is not None, its value should be equal to `num_chains x N`.\n\n Usages for batched parameters:\n\n + set `batch_ndims=0` to get 1 sample from the guide and parameters (same as `batch_ndims=None` with guide)\n\n + set `batch_ndims=1` to get predictions from a one dimensional batch of the guide and parameters\n with shapes `(num_samples x batch_size x ...)`\n\n :return: dict of samples from the predictive distribution.\n\n **Example:**\n\n Given a model::\n\n def model(X, y=None):\n ...\n return numpyro.sample(\"obs\", likelihood, obs=y)\n\n you can sample from the prior predictive::\n\n predictive = Predictive(model, num_samples=1000)\n y_pred = predictive(rng_key, X)[\"obs\"]\n\n If you also have posterior samples, you can sample from the posterior predictive::\n\n predictive = Predictive(model, posterior_samples=posterior_samples)\n y_pred = predictive(rng_key, X)[\"obs\"]\n\n See docstrings for :class:`~numpyro.infer.svi.SVI` and :class:`~numpyro.infer.mcmc.MCMCKernel`\n to see example code of this in context.\n \"\"\"\n\n def __init__(\n self,\n model: Callable,\n posterior_samples: Optional[Dict] = None,\n *,\n guide: Optional[Callable] = None,\n params: Optional[Dict] = None,\n num_samples: Optional[int] = None,\n return_sites: Optional[List[str]] = None,\n infer_discrete: bool = False,\n parallel: bool = False,\n batch_ndims: Optional[int] = None,\n ):\n if posterior_samples is None and num_samples is None:\n raise ValueError(\n \"Either posterior_samples or num_samples must be specified.\"\n )\n if posterior_samples is not None and guide is not None:\n raise ValueError(\n \"Only one of guide or posterior_samples can be provided, not both.\"\n )\n\n batch_ndims = (\n batch_ndims if batch_ndims is not None else 1 if guide is None else 0\n )\n\n posterior_samples = {} if posterior_samples is None else posterior_samples\n\n prototype_site = batch_shape = batch_size = None\n for name, sample in posterior_samples.items():\n if batch_shape is not None and sample.shape[:batch_ndims] != batch_shape:\n raise ValueError(\n f\"Batch shapes at site {name} and {prototype_site} \"\n f\"should be the same, but got \"\n f\"{sample.shape[:batch_ndims]} and {batch_shape}\"\n )\n else:\n prototype_site = name\n batch_shape = sample.shape[:batch_ndims]\n batch_size = int(np.prod(batch_shape))\n if (num_samples is not None) and (num_samples != batch_size):\n warnings.warn(\n \"Sample's batch dimension size {} is different from the \"\n \"provided {} num_samples argument. Defaulting to {}.\".format(\n batch_size, num_samples, batch_size\n ),\n UserWarning,\n stacklevel=find_stack_level(),\n )\n num_samples = batch_size\n\n if num_samples is None:\n raise ValueError(\n \"No sample sites in posterior samples to infer `num_samples`.\"\n )\n\n if batch_shape is None:\n batch_shape = (1,) * (batch_ndims - 1) + (num_samples,)\n\n if return_sites is not None:\n assert isinstance(return_sites, (list, tuple, set))\n\n self.model = model\n self.posterior_samples = {} if posterior_samples is None else posterior_samples\n self.num_samples = num_samples\n self.guide = guide\n self.params = {} if params is None else params\n self.infer_discrete = infer_discrete\n self.return_sites = return_sites\n self.parallel = parallel\n self.batch_ndims = batch_ndims\n self._batch_shape = batch_shape\n\n def _call_with_params(self, rng_key, params, args, kwargs):\n posterior_samples = self.posterior_samples\n if self.guide is not None:\n rng_key, guide_rng_key = random.split(rng_key)\n # use return_sites='' as a special signal to return all sites\n guide = substitute(self.guide, params)\n posterior_samples = _predictive(\n guide_rng_key,\n guide,\n posterior_samples,\n self._batch_shape,\n return_sites=\"\",\n parallel=self.parallel,\n model_args=args,\n model_kwargs=kwargs,\n )\n model = substitute(self.model, self.params)\n return _predictive(\n rng_key,\n model,\n posterior_samples,\n self._batch_shape,\n return_sites=self.return_sites,\n infer_discrete=self.infer_discrete,\n parallel=self.parallel,\n model_args=args,\n model_kwargs=kwargs,\n )\n\n def __call__(self, rng_key, *args, **kwargs):\n \"\"\"\n Returns dict of samples from the predictive distribution. By default, only sample sites not\n contained in `posterior_samples` are returned. This can be modified by changing the\n `return_sites` keyword argument of this :class:`Predictive` instance.\n\n :param jax.random.PRNGKey rng_key: random key to draw samples.\n :param args: model arguments.\n :param kwargs: model kwargs.\n \"\"\"\n if self.batch_ndims == 0 or self.params == {} or self.guide is None:\n return self._call_with_params(rng_key, self.params, args, kwargs)\n elif self.batch_ndims == 1: # batch over parameters\n batch_size = jnp.shape(tree_flatten(self.params)[0][0])[0]\n rng_keys = random.split(rng_key, batch_size)\n return jax.vmap(\n partial(self._call_with_params, args=args, kwargs=kwargs),\n in_axes=0,\n out_axes=1,\n )(rng_keys, self.params)\n else:\n raise NotImplementedError\n\n\ndef log_likelihood(\n model, posterior_samples, *args, parallel=False, batch_ndims=1, **kwargs\n):\n \"\"\"\n (EXPERIMENTAL INTERFACE) Returns log likelihood at observation nodes of model,\n given samples of all latent variables.\n\n :param model: Python callable containing Pyro primitives.\n :param dict posterior_samples: dictionary of samples from the posterior.\n :param args: model arguments.\n :param batch_ndims: the number of batch dimensions in posterior samples. Some usages:\n\n + set `batch_ndims=0` to get log likelihoods for 1 single sample\n\n + set `batch_ndims=1` to get log likelihoods for `posterior_samples`\n with shapes `(num_samples x ...)`\n\n + set `batch_ndims=2` to get log likelihoods for `posterior_samples`\n with shapes `(num_chains x num_samples x ...)`\n\n :param kwargs: model kwargs.\n :return: dict of log likelihoods at observation sites.\n \"\"\"\n\n def single_loglik(samples):\n substituted_model = (\n substitute(model, samples) if isinstance(samples, dict) else model\n )\n model_trace = trace(substituted_model).get_trace(*args, **kwargs)\n return {\n name: site[\"fn\"].log_prob(site[\"value\"])\n for name, site in model_trace.items()\n if site[\"type\"] == \"sample\" and site[\"is_observed\"]\n }\n\n prototype_site = batch_shape = None\n for name, sample in posterior_samples.items():\n if batch_shape is not None and jnp.shape(sample)[:batch_ndims] != batch_shape:\n raise ValueError(\n f\"Batch shapes at site {name} and {prototype_site} \"\n f\"should be the same, but got \"\n f\"{sample.shape[:batch_ndims]} and {batch_shape}\"\n )\n else:\n prototype_site = name\n batch_shape = jnp.shape(sample)[:batch_ndims]\n\n if batch_shape is None: # posterior_samples is an empty dict\n batch_shape = (1,) * batch_ndims\n posterior_samples = np.zeros(batch_shape)\n\n batch_size = int(np.prod(batch_shape))\n chunk_size = batch_size if parallel else 1\n return soft_vmap(single_loglik, posterior_samples, len(batch_shape), chunk_size)\n\n\n@contextmanager\ndef helpful_support_errors(site, raise_warnings=False):\n name = site[\"name\"]\n support = getattr(site[\"fn\"], \"support\", None)\n if isinstance(support, constraints.independent):\n support = support.base_constraint\n\n # Warnings\n if raise_warnings:\n if support is constraints.circular:\n msg = (\n f\"Continuous inference poorly handles circular sample site '{name}'. \"\n + \"Consider using VonMises distribution together with \"\n + \"a reparameterizer, e.g. \"\n + f\"numpyro.handlers.reparam(config={{'{name}': CircularReparam()}}).\"\n )\n warnings.warn(msg, UserWarning, stacklevel=find_stack_level())\n\n # Exceptions\n try:\n yield\n except NotImplementedError as e:\n support_name = repr(support).lower()\n if \"integer\" in support_name or \"boolean\" in support_name:\n # TODO: mention enumeration when it is supported in SVI\n raise ValueError(\n f\"Continuous inference cannot handle discrete sample site '{name}'.\"\n )\n if \"sphere\" in support_name:\n raise ValueError(\n f\"Continuous inference cannot handle spherical sample site '{name}'. \"\n \"Consider using ProjectedNormal distribution together with \"\n \"a reparameterizer, e.g. \"\n f\"numpyro.handlers.reparam(config={{'{name}': ProjectedNormalReparam()}}).\"\n )\n raise e from None\n", "meta": {"hexsha": "c4a77889e0614caeb5f5082d856cf6cd6a61ec56", "size": 43600, "ext": "py", "lang": "Python", "max_stars_repo_path": "numpyro/infer/util.py", "max_stars_repo_name": "karm-patel/numpyro", "max_stars_repo_head_hexsha": "34e0cdf4fa0ab9a0300a0d894d6758419fb46f40", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "numpyro/infer/util.py", "max_issues_repo_name": "karm-patel/numpyro", "max_issues_repo_head_hexsha": "34e0cdf4fa0ab9a0300a0d894d6758419fb46f40", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "numpyro/infer/util.py", "max_forks_repo_name": "karm-patel/numpyro", "max_forks_repo_head_hexsha": "34e0cdf4fa0ab9a0300a0d894d6758419fb46f40", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.9005628518, "max_line_length": 115, "alphanum_fraction": 0.6219036697, "include": true, "reason": "import numpy,from numpy,import jax,from jax", "num_tokens": 9267, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073655352404, "lm_q2_score": 0.34510527095787247, "lm_q1q2_score": 0.19001750407443946}} {"text": "#!/usr/bin/env python3\n\"\"\"Calculates the Frechet Inception Distance (FID) to evalulate GANs\nThe FID metric calculates the distance between two distributions of images.\nTypically, we have summary statistics (mean & covariance matrix) of one\nof these distributions, while the 2nd distribution is given by a GAN.\nWhen run as a stand-alone program, it compares the distribution of\nimages that are stored as PNG/JPEG at a specified location with a\ndistribution given by summary statistics (in pickle format).\nThe FID is calculated by assuming that X_1 and X_2 are the activations of\nthe pool_3 layer of the inception net for generated samples and real world\nsamples respectively.\nSee --help to see further details.\nCode apapted from https://github.com/bioinf-jku/TTUR to use PyTorch instead\nof Tensorflow\nCopyright 2018 Institute of Bioinformatics, JKU Linz\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n http://www.apache.org/licenses/LICENSE-2.0\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n\"\"\"\nimport os\nimport pathlib\n\nimport numpy as np\nimport torch\nfrom scipy import linalg\nfrom torch.nn.functional import adaptive_avg_pool2d\nfrom src.utils import read_config\nfrom src.Models.models import ImitateJoint\nimport matplotlib.pyplot as plt\nfrom globals import device\nfrom autoencoder import Autoencoder\nfrom PIL import Image\n\ntry:\n from tqdm import tqdm\nexcept ImportError:\n # If not tqdm is not available, provide a mock version of it\n def tqdm(x): return x\n\nfrom src.Models.models import Encoder\nfrom src.utils.generators.wake_sleep_gen import WakeSleepGen\nfrom src.utils.generators.shapenet_generater import Generator\nfrom globals import device\n\ndef get_activations(generator, model, batch_size=50, dims=32, verbose=False):\n \"\"\"Calculates the activations of the pool_3 layer for all images.\n Params:\n -- files : List of image files paths\n -- model : Instance of inception model\n -- batch_size : Batch size of images for the model to process at once.\n Make sure that the number of samples is a multiple of\n the batch size, otherwise some samples are ignored. This\n behavior is retained to match the original FID score\n implementation.\n -- dims : Dimensionality of features returned by Inception\n -- cuda : If set to True, use GPU\n -- verbose : If set to True and parameter out_step is given, the number\n of calculated batches is reported.\n Returns:\n -- A numpy array of dimension (num images, dims) that contains the\n activations of the given tensor when feeding inception with the\n query tensor.\n \"\"\"\n model.eval()\n\n test_size = 3000\n\n pred_arr = np.empty((test_size, dims))\n\n n_batches = test_size // batch_size\n\n for i in tqdm(range(0, test_size, batch_size)):\n if verbose:\n print('\\rPropagating batch %d/%d' % ((i + 1) // batch_size, n_batches),\n end='', flush=True)\n start = i\n end = i + batch_size\n\n images = next(generator)\n images = torch.from_numpy(images).to(device)\n if len(images.shape) == 3: # generated samples\n # images = torch.from_numpy(np.random.randint(0, 2, (100, 64, 64))).to(device).float()\n pred = model.encode(images.unsqueeze(1).float())\n else: # cad data\n pred = model.encode(images[-1, :, 0:1, :, :])\n\n pred = pred.reshape((batch_size,-1, 1, 1))\n # If model output is not scalar, apply global spatial average pooling.\n # This happens if you choose a dimensionality not equal 2048.\n # if pred.size(2) != 1 or pred.size(3) != 1:\n # pred = adaptive_avg_pool2d(pred, output_size=(1, 1))\n\n pred_arr[start:end] = pred.cpu().data.numpy().reshape(pred.size(0), -1)\n\n if verbose:\n print(' done')\n\n return pred_arr\n\n\ndef calculate_frechet_distance(mu1, sigma1, mu2, sigma2, eps=1e-6):\n \"\"\"Numpy implementation of the Frechet Distance.\n The Frechet distance between two multivariate Gaussians X_1 ~ N(mu_1, C_1)\n and X_2 ~ N(mu_2, C_2) is\n d^2 = ||mu_1 - mu_2||^2 + Tr(C_1 + C_2 - 2*sqrt(C_1*C_2)).\n Stable version by Dougal J. Sutherland.\n Params:\n -- mu1 : Numpy array containing the activations of a layer of the\n inception net (like returned by the function 'get_predictions')\n for generated samples.\n -- mu2 : The sample mean over activations, precalculated on an\n representative data set.\n -- sigma1: The covariance matrix over activations for generated samples.\n -- sigma2: The covariance matrix over activations, precalculated on an\n representative data set.\n Returns:\n -- : The Frechet Distance.\n \"\"\"\n\n mu1 = np.atleast_1d(mu1)\n mu2 = np.atleast_1d(mu2)\n\n sigma1 = np.atleast_2d(sigma1)\n sigma2 = np.atleast_2d(sigma2)\n\n assert mu1.shape == mu2.shape, \\\n 'Training and test mean vectors have different lengths'\n assert sigma1.shape == sigma2.shape, \\\n 'Training and test covariances have different dimensions'\n\n diff = mu1 - mu2\n\n # Product might be almost singular\n covmean, _ = linalg.sqrtm(sigma1.dot(sigma2), disp=False)\n if not np.isfinite(covmean).all():\n msg = ('fid calculation produces singular product; '\n 'adding %s to diagonal of cov estimates') % eps\n print(msg)\n offset = np.eye(sigma1.shape[0]) * eps\n covmean = linalg.sqrtm((sigma1 + offset).dot(sigma2 + offset))\n\n # Numerical error might give slight imaginary component\n if np.iscomplexobj(covmean):\n if not np.allclose(np.diagonal(covmean).imag, 0, atol=1e-3):\n m = np.max(np.abs(covmean.imag))\n raise ValueError('Imaginary component {}'.format(m))\n covmean = covmean.real\n\n tr_covmean = np.trace(covmean)\n\n return (diff.dot(diff) + np.trace(sigma1) +\n np.trace(sigma2) - 2 * tr_covmean)\n\n\ndef calculate_activation_statistics(files, model, batch_size=50,\n dims=32, verbose=False):\n \"\"\"Calculation of the statistics used by the FID.\n Params:\n -- files : List of image files paths\n -- model : Instance of inception model\n -- batch_size : The images numpy array is split into batches with\n batch size batch_size. A reasonable batch size\n depends on the hardware.\n -- dims : Dimensionality of features returned by Inception\n -- cuda : If set to True, use GPU\n -- verbose : If set to True and parameter out_step is given, the\n number of calculated batches is reported.\n Returns:\n -- mu : The mean over samples of the activations of the pool_3 layer of\n the inception model.\n -- sigma : The covariance matrix of the activations of the pool_3 layer of\n the inception model.\n \"\"\"\n act = get_activations(files, model, batch_size, dims, verbose)\n mu = np.mean(act, axis=0)\n sigma = np.cov(act, rowvar=False)\n return mu, sigma\n\n\ndef _compute_statistics_of_path(path, model, batch_size, dims):\n if path.endswith('.npz'):\n f = np.load(path)\n m, s = f['mu'][:], f['sigma'][:]\n f.close()\n else:\n m, s = calculate_activation_statistics(path, model, batch_size,\n dims)\n\n return m, s\n\ndef calculate_fid_given_paths(model, images_path, model_path, batch_size, dims=32):\n \"\"\"Calculates the FID of two paths\"\"\"\n if not os.path.exists(images_path):\n raise RuntimeError('Invalid path: %s' % images_path)\n if not os.path.exists(model_path):\n raise RuntimeError('Invalid path: %s' % model_path)\n\n generator = FidGen(images_path).get_test_data()\n # generator2 = FidGen(model_path).get_test_data()\n cad_generator = Generator().test_gen(batch_size=batch_size,\n path=\"data/cad/cad.h5\",\n if_augment=False)\n # cad_generator2 = Generator().val_gen(batch_size=batch_size,\n # path=\"data/cad/cad.h5\",\n # if_augment=False)\n\n m1, s1 = calculate_activation_statistics(cad_generator, model, batch_size,\n dims)\n m2, s2 = calculate_activation_statistics(generator, model, batch_size,\n dims)\n\n fid_value = calculate_frechet_distance(m1, s1, m2, s2)\n\n return fid_value\n\ndef get_csgnet():\n config = read_config.Config(\"config_synthetic.yml\")\n\n # Encoder\n encoder_net = Encoder(config.encoder_drop)\n encoder_net = encoder_net.to(device)\n\n imitate_net = ImitateJoint(\n hd_sz=config.hidden_size,\n input_size=config.input_size,\n encoder=encoder_net,\n mode=config.mode,\n num_draws=400,\n canvas_shape=config.canvas_shape)\n imitate_net = imitate_net.to(device)\n\n print(\"pre loading model\")\n pretrained_dict = torch.load(config.pretrain_modelpath, map_location=device)\n imitate_net_dict = imitate_net.state_dict()\n pretrained_dict = {\n k: v\n for k, v in pretrained_dict.items() if k in imitate_net_dict\n }\n imitate_net_dict.update(pretrained_dict)\n imitate_net.load_state_dict(imitate_net_dict)\n\n return imitate_net.encoder\n\nclass FidGen:\n def __init__(self, images_path):\n self.images = torch.load(images_path)\n def get_test_data(self):\n while True:\n for i in range(0, 3000, 100):\n batch_images = self.images[i:i+100]\n yield batch_images\n\nif __name__ == '__main__':\n # model = Autoencoder().to(device)\n # model.load_state_dict(torch.load(\"trained_models/fid-model2.pth\"))\n model = get_csgnet()\n fids = []\n fid_value = calculate_fid_given_paths(model,\n f\"fid_images2/base.pt\",\n \"trained_models/mix_len_cr_percent_equal_batch_3_13_prop_100_hdsz_2048_batch_2000_optim_adam_lr_0.001_wd_0.0_enocoderdrop_0.0_drop_0.2_step_mix_mode_12.pth\",\n # \"random_images.pt\",\n 100,\n 2048)\n print(fid_value)\n # for i in range(17):\n # fid_value = calculate_fid_given_paths(model,\n # f\"fid_images2/{i}.pt\",\n # # \"trained_models/mix_len_cr_percent_equal_batch_3_13_prop_100_hdsz_2048_batch_2000_optim_adam_lr_0.001_wd_0.0_enocoderdrop_0.0_drop_0.2_step_mix_mode_12.pth\",\n # \"random_images.pt\",\n # 100,\n # 2048)\n #\n # print('FID: ', fid_value)\n # fids.append(fid_value)\n\n # fig, ax = plt.subplots()\n # ax.plot(fids)\n # plt.savefig(\"fids.png\")\n # with open(\"fids_random.txt\", \"w\") as file:\n # for f in fids:\n", "meta": {"hexsha": "5c2a0abe62d4eb9d0ed464ee7a465755c1dfccc7", "size": 11558, "ext": "py", "lang": "Python", "max_stars_repo_path": "fid_score.py", "max_stars_repo_name": "HomerW/CSGNet", "max_stars_repo_head_hexsha": "4ecc7f3e836867118dba3d5f220ed5e74a536b93", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "fid_score.py", "max_issues_repo_name": "HomerW/CSGNet", "max_issues_repo_head_hexsha": "4ecc7f3e836867118dba3d5f220ed5e74a536b93", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "fid_score.py", "max_forks_repo_name": "HomerW/CSGNet", "max_forks_repo_head_hexsha": "4ecc7f3e836867118dba3d5f220ed5e74a536b93", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.2717770035, "max_line_length": 207, "alphanum_fraction": 0.6329814847, "include": true, "reason": "import numpy,from scipy", "num_tokens": 2710, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5506073655352403, "lm_q2_score": 0.3451052574867685, "lm_q1q2_score": 0.19001749665715037}} {"text": "import os\r\nimport sys\r\nimport numpy as np\r\nfrom math import floor, ceil, sqrt\r\nfrom scipy.signal import convolve\r\n\r\nclass PDB(object):\r\n def __init__(self, pdb_file):\r\n self.pdb_file = pdb_file\r\n self.coords = []\r\n self.info = []\r\n\r\n if not os.path.exists(self.pdb_file):\r\n print(\"PDB> File not found: %s\"%self.pdb_file)\r\n sys.exit(1)\r\n\r\n '''\r\n Load Coordinate sections of a PDB file as of PDB version 3.30\r\n\r\n COLUMNS DATA TYPE FIELD DEFINITION\r\n -------------------------------------------------------------------------------------\r\n 1 - 6 Record name \"ATOM \"\r\n 7 - 11 Integer serial Atom serial number.\r\n 13 - 16 Atom name Atom name.\r\n 17 Character altLoc Alternate location indicator.\r\n 18 - 20 Residue name resName Residue name.\r\n 22 Character chainID Chain identifier.\r\n 23 - 26 Integer resSeq Residue sequence number.\r\n 27 AChar iCode Code for insertion of residues.\r\n 31 - 38 Real(8.3) x Orthogonal coordinates for X in Angstroms.\r\n 39 - 46 Real(8.3) y Orthogonal coordinates for Y in Angstroms.\r\n 47 - 54 Real(8.3) z Orthogonal coordinates for Z in Angstroms.\r\n 55 - 60 Real(6.2) occupancy Occupancy.\r\n 61 - 66 Real(6.2) tempFactor Temperature factor.\r\n 77 - 78 LString(2) element Element symbol, right-justified.\r\n 79 - 80 LString(2) charge Charge on the atom.\r\n '''\r\n self.CA_idx = []\r\n self.BB_idx = []\r\n c = 0\r\n with open(self.pdb_file, 'r') as pdb:\r\n for line in pdb:\r\n line_type = line[0:6].strip()\r\n if line_type in [\"ATOM\", \"HETATM\"]:\r\n try:\r\n at_num = int(line[6:11].strip())\r\n at_name = line[12:16].strip()\r\n res_name = line[17:20]\r\n chain_id = line[21]\r\n res_num = int(line[22:26].strip())\r\n x = float(line[30:38])\r\n y = float(line[38:46])\r\n z = float(line[46:54])\r\n element_symbol = line[76:78].strip()\r\n except Exception:\r\n # print(\"PDB> Error while reading line, skipping it: \\n > %s\"%line)\r\n pass\r\n\r\n self.info.append([at_num, at_name, res_name, chain_id, res_num, element_symbol, line_type])\r\n self.coords.append([x, y, z])\r\n if at_name == \"CA\":\r\n self.CA_idx.append(c)\r\n if at_name in [\"C\", \"CA\", \"N\", \"O\"]:\r\n self.BB_idx.append(c)\r\n c += 1\r\n\r\n self.coords = np.array(self.coords)\r\n self.CA_idx = tuple(self.CA_idx)\r\n self.n_atoms = len(self.coords)\r\n self.n_CA = len(self.CA_idx)\r\n\r\n # Extent of structure\r\n self.minx = np.amin(self.coords[:, 0])\r\n self.maxx = np.amax(self.coords[:, 0])\r\n self.miny = np.amin(self.coords[:, 1])\r\n self.maxy = np.amax(self.coords[:, 1])\r\n self.minz = np.amin(self.coords[:, 2])\r\n self.maxz = np.amax(self.coords[:, 2])\r\n\r\n def write_pdb(self, outname):\r\n occupancy = 1.0\r\n tempFactor = 0.0\r\n fout = open(outname, \"w\")\r\n for i in range(self.n_atoms):\r\n # Check for atom type: if 4 letters long, start in column 13 otherwise no space.\r\n # Else, start in column 14. Differs from format convention v3.30 but always see it this way in files.\r\n if len(self.info[i][1]) == 4:\r\n line_model = \"%-6s%5i %-4s %3s%2s%4s %8.3f%8.3f%8.3f%6.2f%6.2f %-2s\"\r\n else:\r\n line_model = \"%-6s%5i %-3s %3s%2s%4s %8.3f%8.3f%8.3f%6.2f%6.2f %-2s\"\r\n line = line_model%(self.info[i][6], self.info[i][0], self.info[i][1], self.info[i][2], self.info[i][3], self.info[i][4], self.coords[i][0], self.coords[i][1], self.coords[i][2], occupancy, tempFactor, self.info[i][5])\r\n\r\n fout.write(line+\"\\n\")\r\n fout.close()\r\n\r\n def rgyr(self):\r\n rgyr = np.sqrt(np.sum(np.sum((self.coords - self.center())**2, axis=1) / self.coords.shape[0]))\r\n return rgyr\r\n\r\n ####################\r\n # PDB manipulation #\r\n ####################\r\n def get_coords(self):\r\n return self.coords\r\n\r\n def set_coords(self, coords):\r\n self.coords = coords.copy()\r\n\r\n def rotate_atoms(self, rot_mat):\r\n self.coords = np.dot(self.coords, rot_mat)\r\n\r\n def translate_atoms(self, trans_vec):\r\n self.coords += np.array(trans_vec)\r\n\r\n def get_rmsd_with(self, pdb):\r\n dist_sq = np.square(self.coords - pdb.coords)\r\n return np.sqrt(np.sum(dist_sq, axis=(0,1)) / dist_sq.shape[0])\r\n\r\n def get_rmsdCA_with(self, pdb):\r\n if not len(self.CA_idx):\r\n print(\"PDB> No alpha carbons detected; returning all-atom RMSD instead.\")\r\n return self.get_rmsd_with(pdb)\r\n dist_sq = np.square(self.coords[self.CA_idx, :] - pdb.coords[pdb.CA_idx, :])\r\n return np.sqrt(np.sum(dist_sq, axis=(0,1)) / dist_sq.shape[0])\r\n\r\n\r\n ###################\r\n # Density related #\r\n ###################\r\n # Get density grid\r\n def structure_to_density(self, resolution, voxelsp, isovalue=0.0, pad=0, outname=\"\"):\r\n # Interpolate pdb to grid + box size + origin coordinates\r\n grid_prot, pxb, pyb, pzb, minx, miny, minz = self.interpolate_to_grid_massweighted(voxelsp, pad=pad)\r\n\r\n # Margin for convoluted box\r\n margin = 2 + pad\r\n\r\n # Sigma\r\n # > Divide by pi*sqrt(2): it is a factor that affects the voxelsp of the gaussian.\r\n # Same factor as in chimera. Their explanation in documentation:\r\n # Fourier transform (FT) of the distribution fall to 1/e of its maximum value at wavenumber 1/resolution\r\n # > Divide by voxel spacing to make sure kernel relates to structure space\r\n # > Truncate values to 3 sigma\r\n sig = resolution / (np.pi*sqrt(2)) / voxelsp\r\n r = int(ceil(3.0 * sig)) # truncate at 3 sigma\r\n\r\n # Make Gaussian kernel\r\n z,y,x = np.ogrid[-r:r+1, -r:r+1, -r:r+1]\r\n h = np.exp( -(x*x + y*y + z*z) / (2. * sig**2) )\r\n kernel = h / h.sum()\r\n\r\n # Make density map at given resolution from structure grid\r\n grid_prot = np.reshape(grid_prot, (pxb, pyb, pzb), order='F')\r\n grid_dens = convolve(grid_prot, kernel).astype(np.float32)\r\n\r\n # Origin and size of convoluted map\r\n dxi = minx - (r + margin) * voxelsp;\r\n dyi = miny - (r + margin) * voxelsp;\r\n dzi = minz - (r + margin) * voxelsp;\r\n\r\n # Bring map in range [0,1] + apply isovalue threshold\r\n grid_dens = np.divide(grid_dens, np.amax(grid_dens))\r\n grid_dens[np.where(grid_dens < isovalue)] = 0\r\n\r\n if outname != \"\":\r\n extension = os.path.splitext(outname)[-1].lower()\r\n if extension in [\".sit\", \".situs\"]:\r\n dxb, dyb, dzb = grid_dens.shape\r\n f_out = open(outname,\"w\")\r\n f_out.write(\"%f %f %f %f %i %i %i\\n\\n\"%(voxelsp, dxi, dyi, dzi, dxb, dyb, dzb))\r\n voxi = 0\r\n for z in range(dzb):\r\n for y in range(dyb):\r\n for x in range(dxb):\r\n if (voxi+1)%10 == 0 :\r\n f_out.write(\"\\n\")\r\n f_out.write(\" %6.6f \"%grid_dens[x][y][z])\r\n voxi += 1\r\n f_out.close()\r\n else:\r\n # assuming mrc/map\r\n import mrcfile\r\n with mrcfile.new(outname, overwrite=True) as mrc:\r\n mrc.set_data(grid_dens.transpose(2,1,0).astype(np.float32))\r\n xb, yb, zb = grid_dens.shape\r\n\r\n mrc.mode = 2\r\n\r\n mrc.header.mx = xb\r\n mrc.header.my = yb\r\n mrc.header.mz = zb\r\n\r\n mrc.header.nxstart = 0\r\n mrc.header.nystart = 0\r\n mrc.header.nzstart = 0\r\n mrc.header.origin.x = dxi\r\n mrc.header.origin.y = dyi\r\n mrc.header.origin.z = dzi\r\n\r\n mrc.header.cella.x = xb * voxelsp\r\n mrc.header.cella.y = yb * voxelsp\r\n mrc.header.cella.z = zb * voxelsp\r\n\r\n mrc.header.mapc = 1\r\n mrc.header.mapr = 2\r\n mrc.header.maps = 3\r\n\r\n return grid_dens.astype(np.float32), dxi, dyi, dzi\r\n\r\n\r\n #################\r\n # Interpolation #\r\n #################\r\n\r\n def interpolate_to_grid_massweighted(self, voxelsp, pad=0):\r\n # Convert 3D idx to 1D\r\n def idz(kx, ky, k, j, i):\r\n return kx * ky * k + kx * j + i\r\n\r\n mass_dict = {\"H\" : 1.00797, \"BE\": 9.01218, \"C\" : 12.011, \"N\" : 14.0067, \"O\" : 15.9994, \"F\": 18.998403, \"S\" : 32.06, \"P\" : 30.97376,\r\n \"MG\": 24.305, \"CL\": 35.453, \"K\": 39.0983, \"CA\": 40.078, \"MN\": 54.9380, \"FE\": 55.847, \"NI\": 58.70, \"CU\": 63.546, \"ZN\": 65.38, \"SE\": 78.96}\r\n\r\n # To build the density map, we need the XYZ coordinates and mass of for each atom from PDB\r\n info_for_dens = []\r\n element_list = [x[-2].upper() for x in self.info]\r\n for xyz, elem in zip(self.coords, element_list):\r\n x, y, z = xyz\r\n if elem in mass_dict.keys():\r\n mass = mass_dict[elem]\r\n else:\r\n print(\"PDB> (dens) Element %s not in dict. Using mass of carbon.\"%elem)\r\n mass = mass_dict[\"C\"] # default value\r\n info_for_dens.append([x, y, z, mass])\r\n info_for_dens = np.array(info_for_dens)\r\n\r\n # Extent of structure\r\n minx = np.amin(info_for_dens[:, 0])\r\n maxx = np.amax(info_for_dens[:, 0])\r\n miny = np.amin(info_for_dens[:, 1])\r\n maxy = np.amax(info_for_dens[:, 1])\r\n minz = np.amin(info_for_dens[:, 2])\r\n maxz = np.amax(info_for_dens[:, 2])\r\n\r\n # Lattice into register with origin\r\n\r\n minx = voxelsp * floor(minx / voxelsp)\r\n maxx = voxelsp * ceil(maxx / voxelsp)\r\n miny = voxelsp * floor(miny / voxelsp)\r\n maxy = voxelsp * ceil(maxy / voxelsp)\r\n minz = voxelsp * floor(minz / voxelsp)\r\n maxz = voxelsp * ceil(maxz / voxelsp)\r\n\r\n # Size of box in each direction to contain structure\r\n margin = 2 + pad\r\n pxb = ceil((maxx - minx) / voxelsp) + 2 * margin + 1\r\n pyb = ceil((maxy - miny) / voxelsp) + 2 * margin + 1\r\n pzb = ceil((maxz - minz) / voxelsp) + 2 * margin + 1\r\n\r\n nvox_prot = pxb * pyb * pzb\r\n grid_prot = np.zeros((nvox_prot, 1))\r\n\r\n # Trilinear interpolation of structure to box\r\n for i in range(len(info_for_dens)):\r\n # position within grid\r\n gx = margin + (info_for_dens[i][0] - minx) / voxelsp\r\n gy = margin + (info_for_dens[i][1] - miny) / voxelsp\r\n gz = margin + (info_for_dens[i][2] - minz) / voxelsp\r\n\r\n # XYZ coords surrounding atom position\r\n x0 = floor(gx)\r\n y0 = floor(gy)\r\n z0 = floor(gz)\r\n x1 = x0 + 1;\r\n y1 = y0 + 1;\r\n z1 = z0 + 1;\r\n\r\n # interpolate\r\n a = x1 - gx\r\n b = y1 - gy\r\n c = z1 - gz\r\n grid_prot[idz(pxb, pyb, z0, y0, x0)] += info_for_dens[i][3] * a * b * c\r\n grid_prot[idz(pxb, pyb, z1, y0, x0)] += info_for_dens[i][3] * a * b * (1 - c)\r\n grid_prot[idz(pxb, pyb, z0, y1, x0)] += info_for_dens[i][3] * a * (1 - b) * c\r\n grid_prot[idz(pxb, pyb, z0, y0, x1)] += info_for_dens[i][3] * (1 - a) * b * c\r\n grid_prot[idz(pxb, pyb, z1, y1, x0)] += info_for_dens[i][3] * a * (1 - b) * (1 - c)\r\n grid_prot[idz(pxb, pyb, z0, y1, x1)] += info_for_dens[i][3] * (1 - a) * (1 - b) * c\r\n grid_prot[idz(pxb, pyb, z1, y0, x1)] += info_for_dens[i][3] * (1 - a) * b * (1 - c)\r\n grid_prot[idz(pxb, pyb, z1, y1, x1)] += info_for_dens[i][3] * (1 - a) * (1 - b) * (1 - c)\r\n\r\n grid_prot = np.divide(grid_prot, np.amax(grid_prot))\r\n\r\n return grid_prot, pxb, pyb, pzb, minx, miny, minz\r\n", "meta": {"hexsha": "efeb01a3c0ae7b56fc65dbe4689a2d42300094b0", "size": 12776, "ext": "py", "lang": "Python", "max_stars_repo_path": "mad/PDB.py", "max_stars_repo_name": "LBM-EPFL/MaD", "max_stars_repo_head_hexsha": "593d416ea3829bd203383689fa9fd2095d9b88d6", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "mad/PDB.py", "max_issues_repo_name": "LBM-EPFL/MaD", "max_issues_repo_head_hexsha": "593d416ea3829bd203383689fa9fd2095d9b88d6", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "mad/PDB.py", "max_forks_repo_name": "LBM-EPFL/MaD", "max_forks_repo_head_hexsha": "593d416ea3829bd203383689fa9fd2095d9b88d6", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.6040955631, "max_line_length": 230, "alphanum_fraction": 0.4864589856, "include": true, "reason": "import numpy,from scipy", "num_tokens": 3602, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5234203489363239, "lm_q2_score": 0.36296921930155557, "lm_q1q2_score": 0.1899854754199653}} {"text": "\"\"\"\nPrototype of a \"Shakemap-Lite\" system for retreiving expected GMPE\nvalues from an earthquake\n\"\"\"\nimport os\nimport subprocess\nimport h5py\nimport numpy as np\nimport pandas as pd\nfrom openquake.hazardlib.geo import Point, PlanarSurface, MultiSurface, Mesh\nfrom openquake.hazardlib.gsim import get_available_gsims\nfrom openquake.hazardlib.imt import PGA, PGV, SA, from_string\nfrom openquake.hazardlib.contexts import (ContextMaker, get_distances,\n SitesContext, DistancesContext)\nfrom openquake.hazardlib.source.rupture import ParametricProbabilisticRupture\nfrom openquake.hazardlib.site import Site, SiteCollection\nfrom openquake.hazardlib.scalerel.wc1994 import WC1994\nfrom openquake.hazardlib import const\nimport synthetic_rupture_generator as srg\n\n\nGSIM_SET = get_available_gsims()\n\n\ndef create_planar_surface(top_centroid, strike, dip, area, aspect):\n \"\"\"\n Given a central location, create a simple planar rupture\n :param top_centroid:\n Centroid of trace of the rupture, as instance of :class:\n openquake.hazardlib.geo.point.Point\n :param float strike:\n Strike of rupture(Degrees)\n :param float dip:\n Dip of rupture (degrees)\n :param float area:\n Area of rupture (km^2)\n :param float aspect:\n Aspect ratio of rupture\n\n :returns: Rupture as an instance of the :class:\n openquake.hazardlib.geo.surface.planar.PlanarSurface\n \"\"\"\n rad_dip = dip * pi / 180.\n width = sqrt(area / aspect)\n length = aspect * width\n # Get end points by moving the top_centroid along strike\n top_right = top_centroid.point_at(length / 2., 0., strike)\n top_left = top_centroid.point_at(length / 2.,\n 0.,\n (strike + 180.) % 360.)\n # Along surface width\n surface_width = width * cos(rad_dip)\n vertical_depth = width * sin(rad_dip)\n dip_direction = (strike + 90.) % 360.\n\n bottom_right = top_right.point_at(surface_width,\n vertical_depth,\n dip_direction)\n bottom_left = top_left.point_at(surface_width,\n vertical_depth,\n dip_direction)\n\n # Create the rupture\n return PlanarSurface(strike, dip, top_left, top_right,\n bottom_right, bottom_left)\n\n\ndef vs30_to_z1pt0_cy14(vs30, japan=False):\n \"\"\"\n Returns the estimate depth to the 1.0 km/s velocity layer based on Vs30\n from Chiou & Youngs (2014) California model\n\n :param numpy.ndarray vs30:\n Input Vs30 values in m/s\n :param bool japan:\n If true returns the Japan model, otherwise the California model\n :returns:\n Z1.0 in m\n \"\"\"\n if japan:\n c1 = 412. ** 2.\n c2 = 1360.0 ** 2.\n return np.exp((-5.23 / 2.0) *\n np.log((np.power(vs30,2.) + c1) / (c2 + c1)))\n else:\n c1 = 571 ** 4.\n c2 = 1360.0 ** 4.\n return np.exp((-7.15 / 4.0) * np.log((vs30 ** 4. + c1) / (c2 + c1)))\n\n\ndef vs30_to_z2pt5_cb14(vs30, japan=False):\n \"\"\"\n Converts vs30 to depth to 2.5 km/s interface using model proposed by\n Campbell & Bozorgnia (2014)\n\n :param vs30:\n Vs30 values (numpy array or float)\n\n :param bool japan:\n Use Japan formula (True) or California formula (False)\n\n :returns:\n Z2.5 in km\n \"\"\"\n if japan:\n return np.exp(5.359 - 1.102 * np.log(vs30))\n else:\n return np.exp(7.089 - 1.144 * np.log(vs30))\n\n\ndef get_vs30_sites_from_bbox(bbox, isep=\"\\t\"):\n \"\"\"\n Returns a basic site dictionary from a bbox [llon, ulon, llat, ulat]\n \"\"\"\n filepath=os.path.dirname(__file__)\n site_data_path = os.path.join(filepath, \"global_vs30.grd\")\n tempfile = \"tempfile.grd\"\n # Call grdcut\n cutstring = \"/\".join([str(loc) for loc in bbox])\n subprocess.run([\"gmt\", \"grdcut\", site_data_path,\n \"-G{:s}\".format(tempfile),\n \"-R{:s}\".format(cutstring)])\n # Call grd2xyz\n tempxyz = os.path.join(filepath,\"tempfile.xyz\")\n subprocess.run([\"gmt\", \"grd2xyz\", tempfile, \"-sa\", \">\", tempxyz])\n # Use pandas to read in the xyzdata\n site_data = pd.read_csv(tempxyz, sep=isep)\n sites = {\"lon\": site_data.iloc[:, 0].values,\n \"lat\": site_data.iloc[:, 1].values,\n \"vs30\": site_data.iloc[:, 2].values}\n os.remove(tempfile)\n os.remove(tempxyz)\n return sites\n\n\nclass Event(object):\n \"\"\"\n Shakemap event object - requires a minimum of an ID, longitude, latitude,\n depth and magnitude. Other attributes con be input to control the rupture\n orientation and mechanism.\n\n Can input a rupture geometry directly\n \"\"\"\n def __init__(self, i_d, lon, lat, hypo_depth, mag, strike=0.0, dip=90.,\n rake=0.0, aspect=1.0, msr=srg.Stafford2014(), usd=0.0,\n lsd=1000.0, rupture=None):\n\n self.id = i_d\n self.lon = lon\n self.lat = lat\n self.depth = hypo_depth\n self.mag = mag\n self.strike = strike\n self.dip = dip\n self.rake = rake\n self.mechanism = []\n #({\"strike\": strike, \"dip\": dip, \"rake\": rake}, 1.)]\n self.aspect = aspect\n self.msr = msr\n if rupture:\n assert isinstance(rupture, ParametricProbabilisticRupture)\n self.rupture = rupture\n else:\n self.rupture = None\n self.usd = usd\n self.lsd = lsd\n self.generator = srg.FiniteRuptureSampler(msr, self.usd, self.lsd)\n\n\n def __repr__(self):\n return \"{:s}|{:.5f}|{:.5f}|{:.5f}|{:.2f}\".format(self.id,\n self.lon,\n self.lat,\n self.depth,\n self.mag)\n def get_rupture(self):\n \"\"\"\n If a rupture is provided then it is returned, otherwise it will\n use a synthetic rupture generator\n \"\"\"\n if self.rupture:\n return rupture\n else:\n if len(self.mechanism) >= 1:\n # Define a set of rupture mechanisms with weight\n mechanisms = []\n for mech, weight in self.mechanism:\n npd = NodalPlane(self.mechanism[\"strike\"],\n self.mechanism[\"dip\"],\n self.mechanism[\"rake\"])\n mechanisms.append((weight, npd))\n mechanisms = PMF(mechanisms)\n else:\n if self.rake:\n if self.rake >= 45.0 and self.rake <= 135.0:\n mechanisms = \"R\"\n elif self.rake >= -135.0 and self.rake <= -45.:\n mechanisms = \"N\"\n else:\n mechanisms = \"SS\"\n else:\n mechanisms = \"U\"\n # Build planar rupture\n planar_surface = self.generator.sample_ruptures(\n Point(self.lon, self.lat, self.depth),\n self.mag, nsamples=1, mechanisms=mechanisms,\n dimensions=None)[0]\n return ParametricProbabilisticRupture(\n self.mag, self.rake, None,\n Point(self.lon, self.lat, self.depth),\n planar_surface, 1.0, None)\n\n\nclass ShakemapLite(object):\n \"\"\"\n Class to implement a lightweight OpenQuake-based shakemap\n \"\"\"\n def __init__(self, database, gmpes, imts):\n \"\"\"\n Shakemap results are stored to an hdf5 databse\n :param str database:\n Path to database\n :param list gmpes:\n List of gmpes (as strings)\n :param list imts:\n List of IMTs (as strings)\n \"\"\"\n\n self.gmpes = [GSIM_SET[gmpe]() for gmpe in gmpes]\n self.imts = [from_string(imt) for imt in imts]\n self.db_file = database\n self.context = ContextMaker(self.gmpes)\n # Determine the site attributes\n self.site_attribs = []\n for gmpe in self.gmpes:\n for site_attrib in gmpe.REQUIRES_SITES_PARAMETERS:\n if not site_attrib in self.site_attribs:\n self.site_attribs.append(site_attrib)\n\n def __call__(self, event, sites, vs30measured=False, backarc=False):\n \"\"\"\n Execute a shakemap\n \"\"\"\n # Build the contexts\n sctx, dctx = self.build_sites_distances_contexts(event, sites,\n vs30measured,\n backarc)\n # Connect to database\n fle = h5py.File(self.db_file)\n grp = fle.create_group(event.id)\n # Store distance calculations to database\n dists_grp = grp.create_group(\"Distances\")\n for key, distance in list(dctx.__dict__.items()):\n dset = dists_grp.create_dataset(key, distance.shape, dtype=\"f\")\n dset[:] = distance\n # Get the rupture\n rctx = event.get_rupture()\n # Run the calculations\n for gmpe in self.gmpes:\n gmpe_grp = grp.create_group(gmpe.__class__.__name__)\n for imt in self.imts:\n imt_grp = gmpe_grp.create_group(str(imt))\n # Get ground motion values\n mean, [sigma] = gmpe.get_mean_and_stddevs(\n sctx, rctx, dctx, imt, [const.StdDev.TOTAL])\n mean_dset = imt_grp.create_dataset(\"median\",\n mean.shape,\n dtype=\"f\")\n mean_dset[:] = np.exp(mean)\n sigma_dset = imt_grp.create_dataset(\"sigma\",\n sigma.shape,\n dtype=\"f\")\n sigma_dset[:] = sigma\n fle.close()\n\n def reset(self):\n \"\"\"\n Remove the database file then delete the object itself\n \"\"\"\n if os.path.exists(self.db_file):\n os.remove(self.db_file)\n\n def __getitem__(self, i):\n \"\"\"\n Returns a given data set on a path\n \"\"\"\n if not os.path.exists(self.db_file):\n raise AttributeError(\"Database %s does not exist\" % self.db_file)\n # Connect to the database\n fle = h5py.File(self.db_file)\n try:\n data = fle[i][:]\n return data\n except:\n # Data not found\n fle.close()\n raise AttributeError(\"%s not found in database\" % i)\n\n def build_sites_distances_contexts(self, event, sites, vs30measured=False,\n backarc=False):\n \"\"\"\n Builds the contexts from the event and sites\n \"\"\"\n # Get distances\n mesh = Mesh(sites[\"lon\"], sites[\"lat\"])\n mshape = mesh.lons.shape\n dctx = DistancesContext()\n for param in self.context.REQUIRES_DISTANCES:\n setattr(dctx, param, get_distances(event.get_rupture(),\n mesh, param))\n # Get sites context\n sctx = SitesContext()\n for key in self.site_attribs:\n if key.startswith(\"z1pt0\") and not \"z1pt0\" in sites:\n setattr(sctx, \"z1pt0\",\n vs30_to_z1pt0_cy14(sites[\"vs30\"], japan=False))\n\n elif key.startswith(\"z2pt5\") and not \"z5pt5\" in sites:\n setattr(sctx, \"z2pt5\",\n vs30_to_z2pt5_cb14(sites[\"vs30\"], japan=False))\n\n elif key.startswith(\"vs30measured\") and not \"vs30measured\" in sites:\n if vs30measured:\n setattr(sctx, \"vs30measured\", np.ones(mshape, dtype=bool))\n else:\n setattr(sctx, \"vs30measured\", np.zeros(mshape, dtype=bool))\n elif key.startswith(\"vs30measured\") and not \"vs30measured\" in sites:\n if vs30measured:\n setattr(sctx, \"vs30measured\", np.ones(mshape, dtype=bool))\n else:\n setattr(sctx, \"vs30measured\", np.zeros(mshape, dtype=bool))\n elif key.startswith(\"backarc\") and not \"backarc\" in sites:\n if vs30measured:\n setattr(sctx, \"backarc\", np.ones(mshape, dtype=bool))\n else:\n setattr(sctx, \"backarc\", np.zeros(mshape, dtype=bool))\n else:\n setattr(sctx, key, sites[key])\n return sctx, dctx\n\n#\n# def build_site_collection(self, sites, vs30measured=False, backarc=False):\n# \"\"\"\n# Sites should be a dictionary of site parameter\n# {lon, lat, vs30, vs30measured, z1pt0, z2pt5, backarc}\n# \"\"\"\n# for key in [\"lon\", \"lat\", \"vs30\"]:\n# # check in dict\n# assert key in sites\n# nsites = len(sites[\"lon\"])\n# if not \"z1pt0\" in sites or sites[\"z1pt0\"] is None:\n# sites[\"z1pt0\"] = vs30_to_z1pt0_cy14(sites[\"vs30\"], japan=False)\n#\n# if not \"z2pt5\" in sites or sites[\"z2pt5\"] is None:\n# sites[\"z2pt5\"] = vs30_to_z2pt5_cb14(sites[\"vs30\"], japan=False)\n#\n# if not \"vs30measured\" in sites or sites[\"vs30measured\"] is None:\n# if vs30measured:\n# sites[\"vs30measured\"] = np.ones(nsites, dtype=bool)\n# else:\n# sites[\"vs30measured\"] = np.zeros(nsites, dtype=bool)\n#\n# if not \"backarc\" in sites or sites[\"backarc\"] is None:\n# sites[\"backarc\"] = backarc\n# site_col = []\n# for i in range(len(sites[\"lon\"])):\n# site = Site(Point(sites[\"lon\"][i], sites[\"lat\"][i], 0.0),\n# sites[\"vs30\"][i], sites[\"vs30measured\"][i],\n# sites[\"z1pt0\"][i], sites[\"z2pt5\"][i],\n# sites[\"backarc\"][i])\n# site_col.append(site)\n# return SiteCollection(site_col)\n", "meta": {"hexsha": "e84882ff26cc7c7dfd1b344e995cd7d0bead5e8b", "size": 14103, "ext": "py", "lang": "Python", "max_stars_repo_path": "shakemap_lite.py", "max_stars_repo_name": "GFZ-Centre-for-Early-Warning/shakyground", "max_stars_repo_head_hexsha": "0da9ba5a575360081715e8b90c71d4b16c6687c8", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-08-01T00:28:24.000Z", "max_stars_repo_stars_event_max_datetime": "2019-08-01T00:28:24.000Z", "max_issues_repo_path": "shakemap_lite.py", "max_issues_repo_name": "GFZ-Centre-for-Early-Warning/shakyground", "max_issues_repo_head_hexsha": "0da9ba5a575360081715e8b90c71d4b16c6687c8", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2018-08-31T14:14:35.000Z", "max_issues_repo_issues_event_max_datetime": "2021-10-11T12:53:13.000Z", "max_forks_repo_path": "shakemap_lite.py", "max_forks_repo_name": "GFZ-Centre-for-Early-Warning/shakyground", "max_forks_repo_head_hexsha": "0da9ba5a575360081715e8b90c71d4b16c6687c8", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2018-08-31T14:11:00.000Z", "max_forks_repo_forks_event_max_datetime": "2019-07-17T10:06:02.000Z", "avg_line_length": 37.8096514745, "max_line_length": 80, "alphanum_fraction": 0.5398142239, "include": true, "reason": "import numpy", "num_tokens": 3406, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5234203340678567, "lm_q2_score": 0.3629692193015555, "lm_q1q2_score": 0.18998547002316932}} {"text": "#!/usr/bin/env python3\n\n\"\"\"\nThis module provides classes used to\n * define a phonon mode\n * apply symmetry op to a phonon mode\n\"\"\"\n\n\nimport numpy as np\nfrom numpy.linalg import norm\n\nfrom .interface_vasp import Poscar\nfrom .cluster import Cluster\nfrom .coord_utils import ReadPBC2Cart, match_p1p0\nfrom .util.mathtool import relativePosition\nimport logging\nlogger = logging.getLogger(__name__)\n\ndebug_level = 10\n\nclass PhononMode():\n \"\"\"\n\n \"\"\"\n\n def __init__(self, prim, clus, u, clus_dominant):\n \"\"\"\n a proper cluster decorated with displacement u\n \"\"\"\n self.prim = prim\n self.cluster = clus\n self.u = u\n self.dominant_cluster = clus_dominant\n # print(self.cluster)\n # print(self.dominant_cluster)\n\n def operated_by(self, isym):\n return PhononMode(self.prim, Cluster.from_ijkl(self.cluster.operated_by(isym), self.prim),\n np.dot(self.u, self.prim.spacegroup[isym].rot.T),\n Cluster.from_ijkl(self.dominant_cluster.operated_by(isym), self.prim))\n\n\n def __repr__(self):\n# outs = [\"\"]\n# outs.append(self.frac_coords.__str__())\n# outs.append(\"ijk= \"+ self.ijk.__repr__()+ \" l=\"+ self.l.__repr__()+\"]\")\n# outs.append(str(self.ijkl))\n# return \" \".join(outs)\n return str(self.cluster)+ repr(self.u)\n\n @classmethod\n def from_file(cls, prim, p1f, disp_cut, natom_dominant=2, p0f=None, dominant_specie=None, dominant_dr=True):\n \"\"\"\n\n :param p0: read an ideal structure,\n p1: disturbed structure\n disp_cut: retain only atoms with displacement larger than this cutoff\n dominant_specie: which atoms may be the representative\n :paramdominant_dr: Select dominant pairs by largest change in distance\n :return: a phonon mode\n \"\"\"\n if p0f is None:\n x0 = Poscar.from_file(p1f).structure.map_to_prim(prim)\n else:\n assert isinstance(p0f, str), TypeError(\"require p0f filename\")\n x0 = Poscar.from_file(p0f).structure\n scmat = prim.get_scmat(x0.lattice.matrix)\n\n if debug_level > 10:\n print(\"supercell clusters generated\")\n\n u = ReadPBC2Cart(p1f, x0.frac_coords)\n # center of mass\n u -= np.average(u, axis=0)\n unorm = norm(u, axis=1)\n # print(unorm)\n # print(u)\n uidx = np.where(unorm > disp_cut)[0]\n # print(uidx)\n if len(uidx) < natom_dominant:\n print(\"ERROR: found only %d displaced atoms\" % (len(uidx)))\n exit(-1)\n\n clus_xyz = x0.frac_coords[uidx].copy()\n # move cluster atoms close to one atom considering PBC\n imax = np.argmax(unorm)\n pc0 = x0.frac_coords[imax:imax+1].copy()\n for i in range(len(uidx)):\n # print(\"debug\", i, ui, clus_xyz[i], clus_xyz[i:i+1], pc0)\n clus_xyz[i] = match_p1p0(clus_xyz[i:i+1], pc0)[0]\n # print(clus_xyz[i], x0.frac_coords[ui])\n clus_xyz = np.dot(clus_xyz, scmat)\n\n # now find out the dominant cluster\n if dominant_dr and natom_dominant == 2:\n max_dr = -1.\n sel = [True for _ in uidx]\n if isinstance(dominant_specie, list):\n ele = x0.elements\n sel = [ele[i] in dominant_specie for i in uidx]\n# print(sel, ele)\n for i1, i in enumerate(uidx):\n if not sel[i1]:\n continue\n for i2, j in enumerate(uidx):\n if (not sel[i2]) or (i1 >= i2):\n continue\n r0 = prim.lattice.norm(clus_xyz[i2]-clus_xyz[i1])\n r1 = np.linalg.norm(prim.lattice.get_cartesian_coords(clus_xyz[i2]-clus_xyz[i1]) + u[j]-u[i])\n dr = abs(r0-r1)\n if dr > max_dr:\n max_dr = dr\n# print(i, j, max_dr)\n atom_dominant = np.array([i1, i2])\n else:\n if dominant_specie is None:\n udominant = unorm[uidx]\n else:\n ele = x0.elements\n assert isinstance(dominant_specie, list)\n # print(\"debug species=\", dominant_specie, ele, \"for finding dimer |u|=\", [unorm[i] if ele[i] in dominant_specie else -1. for i in uidx])\n udominant = [unorm[i] if ele[i] in dominant_specie else -1. for i in uidx]\n atom_dominant = np.argsort(udominant)[-natom_dominant:]\n# print('dominant=', atom_dominant)\n for i in uidx[atom_dominant]:\n print(\"atom %4d element %3s disp %8.3f\" % (i, x0[i].specie, unorm[i]), x0.frac_coords[i])\n\n\n return cls(prim, Cluster.from_coords(clus_xyz, prim), u[uidx],\n Cluster.from_coords(clus_xyz[atom_dominant], prim))\n\n\n def apply_to(self, dest, dest_clus, inv_sc_mat):\n \"\"\"\n Apply phonon mode to a supercell\n :param dest: destination supercell\n :param dest_clus: dominant cluster by which to identify or match the phonon\n :param inv_sc_mat: inverse sc_mat belonging to the supercell\n :return:\n \"\"\"\n prim = self.prim\n syms = prim.spacegroup\n for isym, sym in enumerate(syms):\n s_pl = self.operated_by(isym)\n is_eq, tr = dest_clus.equivalent_by_lattranslation(s_pl.dominant_cluster.ijkls)\n if is_eq:\n # print(isym, tr, s_pl.dominant_cluster.ijkls, dest_dimer.ijkls)\n # found a sym op to move polaron to desired position\n break\n assert is_eq, ValueError(\"cannot apply phonon mode\")\n pi = relativePosition(dest_clus.ijkls, tr)\n tr_ijk = np.array(dest_clus.ijkls[0]) - np.array(s_pl.dominant_cluster.ijkls[pi[0]])\n s_pl.cluster.move_to_prim(dijk=tr_ijk[:3])\n dest_polaron = [dest.frac2ijkl(np.dot(s_pl.cluster.frac_coords[i], inv_sc_mat))[3] for i in\n range(s_pl.cluster.order)]\n\n out_sc = dest.copy()\n for i, isite in enumerate(dest_polaron):\n out_sc[isite].move_by(s_pl.u[i])\n return out_sc\n", "meta": {"hexsha": "7721dd175eb903d6d8e3902bfef8cdf4cbbf95c8", "size": 6172, "ext": "py", "lang": "Python", "max_stars_repo_path": "csld/phonon_mode.py", "max_stars_repo_name": "jsyony37/csld", "max_stars_repo_head_hexsha": "b0e6d5845d807174f24ca7b591bc164c608c99c8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 16, "max_stars_repo_stars_event_min_datetime": "2019-07-22T18:49:33.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-04T10:22:05.000Z", "max_issues_repo_path": "csld/phonon_mode.py", "max_issues_repo_name": "jsyony37/csld", "max_issues_repo_head_hexsha": "b0e6d5845d807174f24ca7b591bc164c608c99c8", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 8, "max_issues_repo_issues_event_min_datetime": "2019-07-18T20:49:55.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-09T00:47:04.000Z", "max_forks_repo_path": "csld/phonon_mode.py", "max_forks_repo_name": "jsyony37/csld", "max_forks_repo_head_hexsha": "b0e6d5845d807174f24ca7b591bc164c608c99c8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2019-07-18T17:52:44.000Z", "max_forks_repo_forks_event_max_datetime": "2020-09-04T11:35:04.000Z", "avg_line_length": 38.0987654321, "max_line_length": 153, "alphanum_fraction": 0.5814970836, "include": true, "reason": "import numpy,from numpy", "num_tokens": 1620, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.523420348936324, "lm_q2_score": 0.3629692055196168, "lm_q1q2_score": 0.18998546820621814}} {"text": "\"\"\"Economy-level structuring of BLP problem results.\"\"\"\n\nimport time\nfrom typing import Any, Callable, Dict, Hashable, List, Optional, Sequence, TYPE_CHECKING, Tuple\n\nimport numpy as np\nimport scipy.linalg\n\nfrom .results import Results\nfrom .. import exceptions, options\nfrom ..configurations.iteration import Iteration\nfrom ..markets.results_market import ResultsMarket\nfrom ..parameters import Parameters\nfrom ..utilities.algebra import approximately_solve, multiply_matrix_and_tensor, precisely_compute_eigenvalues\nfrom ..utilities.basics import (\n Array, Bounds, Error, TableFormatter, format_number, format_seconds, generate_items, output, output_progress\n)\nfrom ..utilities.statistics import compute_gmm_parameter_covariances, compute_gmm_weights\n\n\n# only import objects that create import cycles when checking types\nif TYPE_CHECKING:\n from .bootstrapped_results import BootstrappedResults # noqa\n from .optimal_instrument_results import OptimalInstrumentResults # noqa\n from ..economies.problem import Progress # noqa\n\n\nclass ProblemResults(Results):\n r\"\"\"Results of a solved BLP problem.\n\n Many results are class attributes. Other post-estimation outputs be computed by calling class methods.\n\n .. note::\n\n All methods in this class support :func:`parallel` processing. If multiprocessing is used, market-by-market\n computation of each post-estimation output will be distributed among the processes.\n\n Attributes\n ----------\n problem : `Problem`\n :class:`Problem` that created these results.\n last_results : `ProblemResults`\n :class:`ProblemResults` from the last GMM step.\n step : `int`\n GMM step that created these results.\n optimization_time : `float`\n Number of seconds it took the optimization routine to finish.\n cumulative_optimization_time : `float`\n Sum of :attr:`ProblemResults.optimization_time` for this step and all prior steps.\n total_time : `float`\n Sum of :attr:`ProblemResults.optimization_time` and the number of seconds it took to set up the GMM step and\n compute results after optimization had finished.\n cumulative_total_time : `float`\n Sum of :attr:`ProblemResults.total_time` for this step and all prior steps.\n optimization_iterations : `int`\n Number of major iterations completed by the optimization routine.\n cumulative_optimization_iterations : `int`\n Sum of :attr:`ProblemResults.optimization_iterations` for this step and all prior steps.\n objective_evaluations : `int`\n Number of GMM objective evaluations.\n cumulative_objective_evaluations : `int`\n Sum of :attr:`ProblemResults.objective_evaluations` for this step and all prior steps.\n fp_converged : `ndarray`\n Flags for convergence of the iteration routine used to compute :math:`\\delta(\\hat{\\theta})` in each market\n during each objective evaluation. Rows are in the same order as :attr:`Problem.unique_market_ids` and column\n indices correspond to objective evaluations.\n cumulative_fp_converged : `ndarray`\n Concatenation of :attr:`ProblemResults.fp_converged` for this step and all prior steps.\n fp_iterations : `ndarray`\n Number of major iterations completed by the iteration routine used to compute :math:`\\delta(\\hat{\\theta})` in\n each market during each objective evaluation. Rows are in the same order as\n :attr:`Problem.unique_market_ids` and column indices correspond to objective evaluations.\n cumulative_fp_iterations : `ndarray`\n Concatenation of :attr:`ProblemResults.fp_iterations` for this step and all prior steps.\n contraction_evaluations : `ndarray`\n Number of times the contraction used to compute :math:`\\delta(\\hat{\\theta})` was evaluated in each market during\n each objective evaluation. Rows are in the same order as :attr:`Problem.unique_market_ids` and column\n indices correspond to objective evaluations.\n cumulative_contraction_evaluations : `ndarray`\n Concatenation of :attr:`ProblemResults.contraction_evaluations` for this step and all prior steps.\n converged : `bool`\n Whether the optimization routine converged.\n cumulative_converged : `bool`\n Whether the optimization routine converged for this step and all prior steps.\n parameters : `ndarray`\n Stacked parameters in the following order: :math:`\\hat{\\theta}`, concentrated out elements of\n :math:`\\hat{\\beta}`, and concentrated out elements of :math:`\\hat{\\gamma}`.\n parameter_covariances : `ndarray`\n Estimated covariance matrix of the stacked parameters, from which standard errors are extracted.\n theta : `ndarray`\n Estimated unfixed parameters, :math:`\\hat{\\theta}` in the following order: :math:`\\hat{\\Sigma}`,\n :math:`\\hat{\\Pi}`, :math:`\\hat{\\rho}`, non-concentrated out elements from :math:`\\hat{\\beta}`, and\n non-concentrated out elements from :math:`\\hat{\\gamma}`.\n sigma : `ndarray`\n Estimated Cholesky decomposition of the covariance matrix that measures agents' random taste distribution,\n :math:`\\hat{\\Sigma}`.\n pi : `ndarray`\n Estimated parameters that measures how agent tastes vary with demographics, :math:`\\hat{\\Pi}`.\n rho : `ndarray`\n Estimated parameters that measure within nesting group correlations, :math:`\\hat{\\rho}`.\n beta : `ndarray`\n Estimated demand-side linear parameters, :math:`\\hat{\\beta}`.\n gamma : `ndarray`\n Estimated supply-side linear parameters, :math:`\\hat{\\gamma}`.\n sigma_se : `ndarray`\n Estimated standard errors for :math:`\\hat{\\Sigma}`.\n pi_se : `ndarray`\n Estimated standard errors for :math:`\\hat{\\Pi}`.\n rho_se : `ndarray`\n Estimated standard errors for :math:`\\hat{\\rho}`.\n beta_se : `ndarray`\n Estimated standard errors for :math:`\\hat{\\beta}`.\n gamma_se : `ndarray`\n Estimated standard errors for :math:`\\hat{\\gamma}`.\n sigma_bounds : `tuple`\n Bounds for :math:`\\Sigma` that were used during optimization, which are of the form ``(lb, ub)``.\n pi_bounds : `tuple`\n Bounds for :math:`\\Pi` that were used during optimization, which are of the form ``(lb, ub)``.\n rho_bounds : `tuple`\n Bounds for :math:`\\rho` that were used during optimization, which are of the form ``(lb, ub)``.\n beta_bounds : `tuple`\n Bounds for :math:`\\beta` that were used during optimization, which are of the form ``(lb, ub)``.\n gamma_bounds : `tuple`\n Bounds for :math:`\\gamma` that were used during optimization, which are of the form ``(lb, ub)``.\n delta : `ndarray`\n Estimated mean utility, :math:`\\delta(\\hat{\\theta})`.\n tilde_costs : `ndarray`\n Estimated transformed marginal costs, :math:`\\tilde{c}(\\hat{\\theta})`. Transformed marginal costs are simply\n :math:`\\tilde{c} = c`, marginal costs, under a linear cost specification, and are :math:`\\tilde{c} = \\log c`\n under a log-linear specification. If ``costs_bounds`` were specified in :meth:`Problem.solve`, :math:`c` may\n have been clipped.\n clipped_costs : `ndarray`\n Vector of booleans indicating whether the associated marginal costs were clipped. All elements will be ``False``\n if ``costs_bounds`` in :meth:`Problem.solve` was not specified.\n xi : `ndarray`\n Estimated unobserved demand-side product characteristics, :math:`\\xi(\\hat{\\theta})`, or equivalently, the\n demand-side structural error term.\n omega : `ndarray`\n Estimated unobserved supply-side product characteristics, :math:`\\omega(\\hat{\\theta})`, or equivalently, the\n supply-side structural error term.\n objective : `float`\n GMM objective value.\n xi_by_theta_jacobian : `ndarray`\n Estimated :math:`\\partial\\xi / \\partial\\theta = \\partial\\delta / \\partial\\theta`.\n omega_by_theta_jacobian : `ndarray`\n Estimated :math:`\\partial\\omega / \\partial\\theta = \\partial\\tilde{c} / \\partial\\theta`.\n gradient : `ndarray`\n Estimated gradient of the GMM objective with respect to :math:`\\theta`, which is computed after the optimization\n routine finishes even if the routine was configured to not use analytic gradients.\n sigma_gradient : `ndarray`\n Estimated gradient of the GMM objective with respect to :math:`\\Sigma` elements in :math:`\\theta`.\n pi_gradient : `ndarray`\n Estimated gradient of the GMM objective with respect to :math:`\\Pi` elements in :math:`\\theta`.\n rho_gradient : `ndarray`\n Estimated gradient of the GMM objective with respect to :math:`\\rho` elements in :math:`\\theta`.\n beta_gradient : `ndarray`\n Estimated gradient of the GMM objective with respect to :math:`\\beta` elements in :math:`\\theta`.\n gamma_gradient : `ndarray`\n Estimated gradient of the GMM objective with respect to :math:`\\gamma` elements in :math:`\\theta`.\n gradient_norm : `ndarray`\n Infinity norm of :attr:`ProblemResults.gradient`.\n hessian : `ndarray`\n Estimated Hessian of the GMM objective with respect to :math:`\\theta`. By default, this is computed with finite\n central differences after the optimization routine finishes.\n hessian_eigenvalues : `ndarray`\n Eigenvalues of :attr:`ProblemResults.hessian`.\n W : `ndarray`\n Weighting matrix, :math:`W`, used to compute these results.\n updated_W : `ndarray`\n Updated weighting matrix.\n\n Examples\n --------\n - :doc:`Tutorial `\n\n \"\"\"\n\n last_results: Optional['ProblemResults']\n step: int\n optimization_time: float\n cumulative_optimization_time: float\n total_time: float\n cumulative_total_time: float\n optimization_iterations: int\n cumulative_optimization_iterations: int\n objective_evaluations: int\n cumulative_objective_evaluations: int\n fp_converged: Array\n cumulative_fp_converged: Array\n fp_iterations: Array\n cumulative_fp_iterations: Array\n contraction_evaluations: Array\n cumulative_contraction_evaluations: Array\n converged: bool\n cumulative_converged: bool\n parameters: Array\n parameter_covariances: Array\n theta: Array\n sigma: Array\n pi: Array\n rho: Array\n beta: Array\n gamma: Array\n sigma_se: Array\n pi_se: Array\n rho_se: Array\n beta_se: Array\n gamma_se: Array\n sigma_bounds: Bounds\n pi_bounds: Bounds\n rho_bounds: Bounds\n beta_bounds: Bounds\n gamma_bounds: Bounds\n delta: Array\n tilde_costs: Array\n clipped_costs: Array\n xi: Array\n omega: Array\n objective: Array\n xi_by_theta_jacobian: Array\n omega_by_theta_jacobian: Array\n gradient: Array\n gradient_norm: Array\n hessian: Array\n hessian_eigenvalues: Array\n sigma_gradient: Array\n pi_gradient: Array\n rho_gradient: Array\n beta_gradient: Array\n gamma_gradient: Array\n W: Array\n updated_W: Array\n _costs_type: str\n _se_type: str\n _errors: List[Error]\n _parameters: Parameters\n\n def __init__(\n self, progress: 'Progress', last_results: Optional['ProblemResults'], step_start_time: float,\n optimization_start_time: float, optimization_end_time: float, iterations: int, evaluations: int,\n converged_mappings: Sequence[Dict[Hashable, bool]], iteration_mappings: Sequence[Dict[Hashable, int]],\n evaluation_mappings: Sequence[Dict[Hashable, int]], converged: bool, costs_type: str, costs_bounds: Bounds,\n center_moments: bool, W_type: str, se_type: str) -> None:\n \"\"\"Compute cumulative progress statistics, update weighting matrices, and estimate standard errors.\"\"\"\n\n # initialize values from the progress structure\n super().__init__(progress.problem)\n self._errors = progress.errors\n self.problem = progress.problem\n self.W = progress.W\n self.theta = progress.theta\n self.delta = progress.delta\n self.tilde_costs = progress.tilde_costs\n self.xi_by_theta_jacobian = progress.xi_jacobian\n self.omega_by_theta_jacobian = progress.omega_jacobian\n self.xi = progress.xi\n self.omega = progress.omega\n self.beta = progress.beta\n self.gamma = progress.gamma\n self.objective = progress.objective\n self.gradient = progress.gradient\n self.gradient_norm = progress.gradient_norm\n self.hessian = progress.hessian\n\n # if the Hessian was computed, compute its eigenvalues and the ratio of the smallest to largest ones\n self.hessian_eigenvalues = np.full(progress.parameters.P, np.nan, options.dtype)\n if progress.parameters.P > 0 and np.isfinite(self.hessian).all():\n self.hessian_eigenvalues, successful = precisely_compute_eigenvalues(self.hessian)\n if not successful:\n self._errors.append(exceptions.HessianEigenvaluesError(self.hessian))\n\n # store information about cost bounds\n self._costs_bounds = costs_bounds\n self.clipped_costs = progress.clipped_costs\n\n # initialize counts, times, and convergence\n self.step = 1\n self.total_time = self.cumulative_total_time = time.time() - step_start_time\n self.optimization_time = self.cumulative_optimization_time = optimization_end_time - optimization_start_time\n self.optimization_iterations = self.cumulative_optimization_iterations = iterations\n self.objective_evaluations = self.cumulative_objective_evaluations = evaluations\n self.fp_converged = self.cumulative_fp_converged = np.array(\n [[m[t] if m else True for m in converged_mappings] for t in self.problem.unique_market_ids],\n dtype=np.int\n )\n self.fp_iterations = self.cumulative_fp_iterations = np.array(\n [[m[t] if m else 0 for m in iteration_mappings] for t in self.problem.unique_market_ids],\n dtype=np.int\n )\n self.contraction_evaluations = self.cumulative_contraction_evaluations = np.array(\n [[m[t] if m else 0 for m in evaluation_mappings] for t in self.problem.unique_market_ids],\n dtype=np.int\n )\n self.converged = self.cumulative_converged = converged\n\n # initialize last results and add to cumulative values\n self.last_results = last_results\n if last_results is not None:\n self.step += last_results.step\n self.cumulative_total_time += last_results.cumulative_total_time\n self.cumulative_optimization_time += last_results.cumulative_optimization_time\n self.cumulative_optimization_iterations += last_results.cumulative_optimization_iterations\n self.cumulative_objective_evaluations += last_results.cumulative_objective_evaluations\n self.cumulative_fp_converged = np.c_[\n last_results.cumulative_fp_converged, self.cumulative_fp_converged\n ]\n self.cumulative_fp_iterations = np.c_[\n last_results.cumulative_fp_iterations, self.cumulative_fp_iterations\n ]\n self.cumulative_contraction_evaluations = np.c_[\n last_results.cumulative_contraction_evaluations, self.cumulative_contraction_evaluations\n ]\n self.cumulative_converged = last_results.converged and converged\n\n # store estimated parameters and information about them (beta and gamma have already been stored above)\n self._parameters = progress.parameters\n self.sigma, self.pi, self.rho, _, _ = self._parameters.expand(self.theta)\n self.parameters = np.c_[np.r_[\n self.theta,\n self.beta[self._parameters.eliminated_beta_index],\n self.gamma[self._parameters.eliminated_gamma_index]\n ]]\n self.sigma_bounds = self._parameters.sigma_bounds\n self.pi_bounds = self._parameters.pi_bounds\n self.rho_bounds = self._parameters.rho_bounds\n self.beta_bounds = self._parameters.beta_bounds\n self.gamma_bounds = self._parameters.gamma_bounds\n\n # collect inputs to weighting matrix and standard error computation\n u_list = [self.xi]\n Z_list = [self.problem.products.ZD]\n jacobian_list = [np.c_[\n self.xi_by_theta_jacobian,\n -self.problem.products.X1[:, self._parameters.eliminated_beta_index.flat],\n np.zeros_like(self.problem.products.X3[:, self._parameters.eliminated_gamma_index.flat])\n ]]\n if self.problem.K3 > 0:\n u_list.append(self.omega)\n Z_list.append(self.problem.products.ZS)\n jacobian_list.append(np.c_[\n self.omega_by_theta_jacobian,\n np.zeros_like(self.problem.products.X1[:, self._parameters.eliminated_beta_index.flat]),\n -self.problem.products.X3[:, self._parameters.eliminated_gamma_index.flat]\n ])\n\n # update the weighting matrix\n with np.errstate(invalid='ignore'):\n self.updated_W, W_errors = compute_gmm_weights(\n u_list, Z_list, W_type, self.problem.products.clustering_ids, center_moments\n )\n self._errors.extend(W_errors)\n\n # compute parameter covariances (if this is the first step, an unadjusted weighting matrix needs to be used so\n # that unadjusted covariances are scaled properly)\n update_W = se_type == 'unadjusted' and self.step == 1\n with np.errstate(all='ignore'):\n self.parameter_covariances, covariance_errors = compute_gmm_parameter_covariances(\n jacobian_list, u_list, Z_list, self.W, se_type, self.problem.products.clustering_ids, update_W\n )\n self._errors.extend(covariance_errors)\n\n # compute standard errors\n with np.errstate(invalid='ignore'):\n se = np.sqrt(np.c_[self.parameter_covariances.diagonal()] / self.problem.N)\n if np.isnan(se).any():\n self._errors.append(exceptions.InvalidParameterCovariancesError())\n\n # expand standard errors\n theta_se, eliminated_beta_se, eliminated_gamma_se = np.split(se, [\n self._parameters.P,\n self._parameters.P + self._parameters.eliminated_beta_index.sum()\n ])\n self.sigma_se, self.pi_se, self.rho_se, self.beta_se, self.gamma_se = (\n self._parameters.expand(theta_se, nullify=True)\n )\n self.beta_se[self._parameters.eliminated_beta_index] = eliminated_beta_se.flatten()\n self.gamma_se[self._parameters.eliminated_gamma_index] = eliminated_gamma_se.flatten()\n\n # expand gradients\n self.sigma_gradient, self.pi_gradient, self.rho_gradient, self.beta_gradient, self.gamma_gradient = (\n self._parameters.expand(self.gradient, nullify=True)\n )\n\n # store types that are used in other methods\n self._costs_type = costs_type\n self._se_type = se_type\n\n def __str__(self) -> str:\n \"\"\"Format problem results (including parameters estimates) as a string.\"\"\"\n\n # construct a standard error description\n if self._se_type == 'unadjusted':\n se_description = \"Unadjusted SEs\"\n elif self._se_type == 'robust':\n se_description = \"Robust SEs\"\n else:\n assert self._se_type == 'clustered'\n se_description = f'Robust SEs Adjusted for {np.unique(self.problem.products.clustering_ids).size} Clusters'\n\n # combine a summary table section and another with formatted estimates into one string\n return \"\\n\\n\".join([\n self._format_summary(),\n self._parameters.format_estimates(\n f\"Estimates ({se_description} in Parentheses)\", self.sigma, self.pi, self.rho, self.beta, self.gamma,\n self.sigma_se, self.pi_se, self.rho_se, self.beta_se, self.gamma_se\n )\n ])\n\n def _format_summary(self) -> str:\n \"\"\"Format a summary table of problem results.\"\"\"\n\n # at a minimum include time and the GMM step\n floats_index = 3\n header = [(\"\", \"Computation\", \"Time\"), (\"\", \"GMM\", \"Step\")]\n values = [format_seconds(self.cumulative_total_time), self.step]\n\n # include any optimization information\n if self._parameters.P > 0:\n floats_index += 1\n header.append((\"\", \"Optimization\", \"Iterations\"))\n values.append(self.cumulative_optimization_iterations)\n\n # include objective evaluation information\n header.append((\"\", \"Objective\", \"Evaluations\"))\n values.append(self.cumulative_objective_evaluations)\n\n # include any fixed point information\n if np.any(self.cumulative_contraction_evaluations > 0):\n floats_index += 2\n header.extend([(\"\", \"Fixed Point\", \"Iterations\"), (\"\", \"Contraction\", \"Evaluations\")])\n values.extend([self.cumulative_fp_iterations.sum(), self.cumulative_contraction_evaluations.sum()])\n\n # include any information about the final objective value\n header.append((\"\", \"Objective\", \"Value\"))\n values.append(format_number(float(self.objective)))\n if np.isfinite(self.gradient_norm):\n header.append((\"\", \"Gradient\", \"Infinity Norm\"))\n values.append(format_number(float(self.gradient_norm)))\n if np.isfinite(self.hessian_eigenvalues).any():\n if self.hessian_eigenvalues.size == 1:\n header.append((\"\", \"Hessian\", \"Eigenvalue\"))\n values.append(format_number(float(self.hessian_eigenvalues)))\n else:\n header.extend([\n (\"Smallest\", \"Hessian\", \"Eigenvalue\"),\n (\"Largest\", \"Hessian\", \"Eigenvalue\")\n ])\n values.extend([\n format_number(float(np.min(self.hessian_eigenvalues))),\n format_number(float(np.max(self.hessian_eigenvalues)))\n ])\n\n # include any information about clipped marginal costs\n if np.isfinite(self._costs_bounds).any():\n header.append((\"Clipped\", \"Marginal\", \"Costs\"))\n values.append(self.clipped_costs.sum())\n\n # format the table\n widths = [max(options.digits + 6 if i >= floats_index else 0, *map(len, k)) for i, k in enumerate(header)]\n formatter = TableFormatter(widths)\n lines = [\n \"Problem Results Summary:\",\n formatter.line()\n ]\n if any(k[0] for k in header):\n lines.append(formatter([k[0] for k in header]))\n lines.extend([\n formatter([k[1] for k in header]),\n formatter([k[2] for k in header], underline=True),\n formatter(values),\n formatter.line()\n ])\n return \"\\n\".join(lines)\n\n def bootstrap(\n self, draws: int = 1000, seed: Optional[int] = None, iteration: Optional[Iteration] = None) -> (\n 'BootstrappedResults'):\n r\"\"\"Use a parametric bootstrap to create an empirical distribution of results.\n\n The constructed :class:`BootstrappedResults` can be used just like :class:`ProblemResults` to compute various\n post-estimation outputs. The only difference is that :class:`BootstrappedResults` methods return arrays with an\n extra first dimension, along which bootstrapped results are stacked. These stacked results can be used to\n construct, for example, confidence intervals for post-estimation outputs.\n\n For each bootstrap draw, parameters are drawn from the estimated multivariate normal distribution of all\n parameters defined by :attr:`ProblemResults.parameters` and :attr:`ProblemResults.parameter_covariances`. Note\n that any bounds configured during the optimization routine will be used to bound parameter draws. These\n parameters are used to compute the implied mean utility, :math:`\\delta`, and shares, :math:`s`. If a supply side\n was estimated, the implied marginal costs, :math:`c`, and prices, :math:`p`, are computed as well. Specifically,\n if a supply side was estimated, equilibrium prices and shares are computed by iterating over the\n :math:`\\zeta`-markup equation from :ref:`references:Morrow and Skerlos (2011)`.\n\n .. note::\n\n By default, the bootstrapping procedure may use a lot of memory. This is because it stores in memory all\n bootstrapped results (for all ``draws``) at the same time. To reduce the memory footprint of the procedure,\n call this method in a loop with ``draws`` set to ``1``. In each iteration of the loop, compute the desired\n post-estimation output with the proper method of the returned :class:`BootstrappedResults` class and store\n these outputs.\n\n Parameters\n ----------\n draws : `int, optional`\n The number of draws that will be taken from the joint distribution of the parameters. The default is\n ``1000``.\n seed : `int, optional`\n Passed to :class:`numpy.random.RandomState` to seed the random number generator before any draws are taken.\n By default, a seed is not passed to the random number generator.\n iteration : `Iteration, optional`\n :class:`Iteration` configuration used to compute bootstrapped prices by iterating over the\n :math:`\\zeta`-markup equation from :ref:`references:Morrow and Skerlos (2011)`. By default, if a supply side\n was estimated, this is ``Iteration('simple', {'tol': 1e-12})``. Analytic Jacobians are not supported for\n this contraction mapping and this configuration is not used if a supply side was not estimated.\n\n Returns\n -------\n `BootstrappedResults`\n Computed :class:`BootstrappedResults`.\n\n Examples\n --------\n - :doc:`Tutorial `\n\n \"\"\"\n errors: List[Error] = []\n\n # keep track of long it takes to bootstrap results\n output(\"Bootstrapping results ...\")\n start_time = time.time()\n\n # validate the number of draws\n if not isinstance(draws, int) or draws < 1:\n raise ValueError(\"draws must be a positive int.\")\n\n # validate the iteration configuration\n if self.problem.K3 == 0:\n iteration = None\n elif iteration is None:\n iteration = Iteration('simple', {'tol': 1e-12})\n elif not isinstance(iteration, Iteration):\n raise TypeError(\"iteration must be None or an iteration instance.\")\n elif iteration._compute_jacobian:\n raise ValueError(\"Analytic Jacobians are not supported for this contraction mapping.\")\n\n # draw from the asymptotic distribution implied by the estimated parameters\n state = np.random.RandomState(seed)\n bootstrapped_parameters = np.atleast_3d(state.multivariate_normal(\n self.parameters.flatten(), self.parameter_covariances, draws\n ))\n\n # extract the parameters\n bootstrapped_sigma = np.zeros((draws, self.sigma.shape[0], self.sigma.shape[1]), options.dtype)\n bootstrapped_pi = np.zeros((draws, self.pi.shape[0], self.pi.shape[1]), options.dtype)\n bootstrapped_rho = np.zeros((draws, self.rho.shape[0], self.rho.shape[1]), options.dtype)\n bootstrapped_beta = np.zeros((draws, self.beta.shape[0], self.beta.shape[1]), options.dtype)\n bootstrapped_gamma = np.zeros((draws, self.gamma.shape[0], self.gamma.shape[1]), options.dtype)\n bootstrapped_theta, bootstrapped_eliminated_beta, bootstrapped_eliminated_gamma = np.split(\n bootstrapped_parameters,\n [self._parameters.P, self._parameters.P + self._parameters.eliminated_beta_index.sum()],\n axis=1\n )\n bootstrapped_beta[:, self._parameters.eliminated_beta_index.flat] = bootstrapped_eliminated_beta\n bootstrapped_gamma[:, self._parameters.eliminated_gamma_index.flat] = bootstrapped_eliminated_gamma\n for d in range(draws):\n bootstrapped_sigma[d], bootstrapped_pi[d], bootstrapped_rho[d], beta_d, gamma_d = self._parameters.expand(\n bootstrapped_theta[d]\n )\n bootstrapped_beta[d] = np.where(self._parameters.eliminated_beta_index, bootstrapped_beta[d], beta_d)\n bootstrapped_gamma[d] = np.where(self._parameters.eliminated_gamma_index, bootstrapped_gamma[d], gamma_d)\n bootstrapped_sigma[d] = np.clip(bootstrapped_sigma[d], *self.sigma_bounds)\n bootstrapped_pi[d] = np.clip(bootstrapped_pi[d], *self.pi_bounds)\n bootstrapped_rho[d] = np.clip(bootstrapped_rho[d], *self.rho_bounds)\n bootstrapped_beta[d] = np.clip(bootstrapped_beta[d], *self.beta_bounds)\n bootstrapped_gamma[d] = np.clip(bootstrapped_gamma[d], *self.gamma_bounds)\n\n # compute bootstrapped prices, shares, delta and marginal costs\n converged_mappings: List[Dict[Hashable, bool]] = []\n iteration_mappings: List[Dict[Hashable, int]] = []\n evaluation_mappings: List[Dict[Hashable, int]] = []\n bootstrapped_prices = np.zeros((draws, self.problem.N, 1), options.dtype)\n bootstrapped_shares = np.zeros((draws, self.problem.N, 1), options.dtype)\n bootstrapped_delta = np.zeros((draws, self.problem.N, 1), options.dtype)\n bootstrapped_costs = np.zeros((draws, self.problem.N, int(self.problem.K3 > 0)), options.dtype)\n for d in output_progress(range(draws), draws, start_time):\n prices_d, shares_d, delta_d, costs_d, converged_d, iterations_d, evaluations_d, errors_d = (\n self._compute_bootstrap(\n iteration, bootstrapped_sigma[d], bootstrapped_pi[d], bootstrapped_rho[d], bootstrapped_beta[d],\n bootstrapped_gamma[d]\n )\n )\n bootstrapped_prices[d] = prices_d\n bootstrapped_shares[d] = shares_d\n bootstrapped_delta[d] = delta_d\n bootstrapped_costs[d] = costs_d\n converged_mappings.append(converged_d)\n iteration_mappings.append(iterations_d)\n evaluation_mappings.append(evaluations_d)\n errors.extend(errors_d)\n\n # structure the results\n from .bootstrapped_results import BootstrappedResults # noqa\n results = BootstrappedResults(\n self, bootstrapped_sigma, bootstrapped_pi, bootstrapped_rho, bootstrapped_beta, bootstrapped_gamma,\n bootstrapped_prices, bootstrapped_shares, bootstrapped_delta, bootstrapped_costs, start_time, time.time(),\n draws, converged_mappings, iteration_mappings, evaluation_mappings\n )\n output(f\"Bootstrapped results after {format_seconds(results.computation_time)}.\")\n output(\"\")\n output(results)\n return results\n\n def _compute_bootstrap(\n self, iteration: Optional[Iteration], sigma: Array, pi: Array, rho: Array, beta: Array, gamma: Array) -> (\n Tuple[\n Array, Array, Array, Array, Dict[Hashable, bool], Dict[Hashable, int], Dict[Hashable, int], List[Error]\n ]):\n \"\"\"Compute the equilibrium prices, shares, marginal costs, and delta associated with bootstrapped parameters\n market-by-market\n \"\"\"\n errors: List[Error] = []\n\n # compute delta (which will change under equilibrium prices) and marginal costs (which won't change)\n delta = self.delta + self.problem._compute_true_X1() @ (beta - self.beta)\n costs = self.tilde_costs + self.problem._compute_true_X3() @ (gamma - self.gamma)\n if self._costs_type == 'log':\n costs = np.exp(costs)\n\n # prices will only change if there is an iteration configuration\n prices = self.problem.products.prices if iteration is None else None\n\n # define a factory for computing bootstrapped prices, shares, and delta in markets\n def market_factory(s: Hashable) -> Tuple[ResultsMarket, Array, Optional[Array], Optional[Iteration]]:\n \"\"\"Build a market along with arguments used to compute equilibrium prices and shares along with delta.\"\"\"\n market_s = ResultsMarket(self.problem, s, sigma, pi, rho, beta, delta)\n costs_s = costs[self.problem._product_market_indices[s]]\n prices_s = prices[self.problem._product_market_indices[s]] if prices is not None else None\n return market_s, costs_s, prices_s, iteration\n\n # compute bootstrapped prices, shares, and delta market-by-market\n converged_mapping: Dict[Hashable, bool] = {}\n iteration_mapping: Dict[Hashable, int] = {}\n evaluation_mapping: Dict[Hashable, int] = {}\n equilibrium_prices = np.zeros_like(self.problem.products.prices)\n equilibrium_shares = np.zeros_like(self.problem.products.shares)\n generator = generate_items(self.problem.unique_market_ids, market_factory, ResultsMarket.solve_equilibrium)\n for t, (prices_t, shares_t, delta_t, errors_t, converged_t, iterations_t, evaluations_t) in generator:\n equilibrium_prices[self.problem._product_market_indices[t]] = prices_t\n equilibrium_shares[self.problem._product_market_indices[t]] = shares_t\n delta[self.problem._product_market_indices[t]] = delta_t\n errors.extend(errors_t)\n converged_mapping[t] = converged_t\n iteration_mapping[t] = iterations_t\n evaluation_mapping[t] = evaluations_t\n\n # return all of the information associated with this bootstrap draw\n return (\n equilibrium_prices, equilibrium_shares, delta, costs, converged_mapping, iteration_mapping,\n evaluation_mapping, errors\n )\n\n def compute_optimal_instruments(\n self, method: str = 'normal', draws: int = 100, seed: Optional[int] = None,\n expected_prices: Optional[Any] = None, iteration: Optional[Iteration] = None) -> 'OptimalInstrumentResults':\n r\"\"\"Estimate optimal or efficient instruments, :math:`\\mathscr{Z}_D` and :math:`\\mathscr{Z}_S`.\n\n Optimal instruments have been shown, for example, by :ref:`references:Reynaert and Verboven (2014)`, to reduce\n bias, improve efficiency, and enhance stability of BLP estimates.\n\n In the spirit of :ref:`references:Chamberlain (1987)`, optimal instruments for :math:`\\theta` are\n\n .. math::\n\n \\begin{bmatrix}\n \\mathscr{Z}_D \\\\\n \\mathscr{Z}_S\n \\end{bmatrix}_{jt}\n = \\text{Var}(\\xi, \\omega)^{-1}\\operatorname{\\mathbb{E}}\\left[\n \\begin{matrix}\n \\frac{\\partial\\xi_{jt}}{\\partial\\theta} \\\\\n \\frac{\\partial\\omega_{jt}}{\\partial\\theta}\n \\end{matrix}\n \\mathrel{\\Bigg|} Z \\right],\n\n The expectation is taken by integrating over the joint density of :math:`\\xi` and :math:`\\omega`. For each error\n term realization, if not already estimated, equilibrium prices are computed via iteration over the\n :math:`\\zeta`-markup equation from :ref:`references:Morrow and Skerlos (2011)`. Associated shares and\n :math:`\\delta` are then computed before each Jacobian is evaluated.\n\n The expected Jacobians are estimated with the average over all computed Jacobian realizations. The normalizing\n matrix :math:`\\text{Var}(\\xi, \\omega)^{-1}` is estimated with the sample covariance matrix of the error terms.\n\n Optimal instruments for linear parameters not included in :math:`\\theta` are simple product characteristics, so\n they are not computed here but are rather included in the set of instruments by\n :meth:`OptimalInstrumentResults.to_problem`.\n\n Parameters\n ----------\n method : `str, optional`\n The method by which the integral over the joint density of :math:`\\xi` and :math:`\\omega` is computed. The\n following methods are supported:\n\n - ``'normal'`` (default) - Draw from the normal approximation to the joint distribution of the error\n terms and take the average over the computed Jacobians (``draws`` determines the number of draws).\n\n - ``'empirical'`` - Draw with replacement from the empirical joint distribution of the error terms and\n take the average over the computed Jacobians (``draws`` determines the number of draws).\n\n - ``'approximate'`` - Evaluate the Jacobians at the expected value of the error terms: zero (``draws``\n will be ignored).\n\n draws : `int, optional`\n The number of draws that will be taken from the joint distribution of the error terms. This is ignored if\n ``method`` is ``'approximate'``. The default is ``100``.\n seed : `int, optional`\n Passed to :class:`numpy.random.RandomState` to seed the random number generator before any draws are taken.\n By default, a seed is not passed to the random number generator.\n expected_prices : `array-like, optional`\n Vector of expected prices conditional on all exogenous variables,\n :math:`\\operatorname{\\mathbb{E}}[p \\mid Z]`. By default, if a supply side was estimated, ``iteration`` is\n used. If only a demand side was estimated, this is by default estimated with the fitted values from a\n reduced form regression of endogenous prices onto :math:`Z_D`: all exogenous variables including excluded\n instruments.\n iteration : `Iteration, optional`\n :class:`Iteration` configuration used to estimate expected prices by iterating over the :math:`\\zeta`-markup\n equation from :ref:`references:Morrow and Skerlos (2011)`. By default, if a supply side was estimated, this\n is ``Iteration('simple', {'tol': 1e-12})``. Analytic Jacobians are not supported for this contraction\n mapping and this configuration is not used if ``expected_prices`` is specified.\n\n Returns\n -------\n `OptimalInstrumentResults`\n Computed :class:`OptimalInstrumentResults`.\n\n Examples\n --------\n - :doc:`Tutorial `\n\n \"\"\"\n errors: List[Error] = []\n\n # keep track of long it takes to compute optimal instruments for theta\n output(\"Computing optimal instruments for theta ...\")\n start_time = time.time()\n\n # validate the method and create a function that samples from the error distribution\n if method == 'approximate':\n sample = lambda: (np.zeros_like(self.xi), np.zeros_like(self.omega))\n else:\n state = np.random.RandomState(seed)\n if method == 'normal':\n if self.problem.K3 == 0:\n variance = np.var(self.xi)\n sample = lambda: (np.c_[state.normal(0, variance, self.problem.N)], self.omega)\n else:\n covariances = np.cov(self.xi, self.omega, rowvar=False)\n sample = lambda: np.hsplit(state.multivariate_normal([0, 0], covariances, self.problem.N), 2)\n elif method == 'empirical':\n if self.problem.K3 == 0:\n sample = lambda: (self.xi[state.choice(self.problem.N, self.problem.N)], self.omega)\n else:\n joint = np.c_[self.xi, self.omega]\n sample = lambda: np.hsplit(joint[state.choice(self.problem.N, self.problem.N)], 2)\n else:\n raise ValueError(\"method must be 'approximate', 'normal', or 'empirical'.\")\n\n # validate the number of draws (there will be only one for the approximate method)\n if method == 'approximate':\n draws = 1\n if not isinstance(draws, int) or draws < 1:\n raise ValueError(\"draws must be a positive int.\")\n\n # validate expected prices or their integration configuration (or compute expected prices with a reduced form\n # regression if unspecified and only a demand side)\n if expected_prices is not None:\n iteration = None\n expected_prices = np.c_[np.asarray(expected_prices, options.dtype)]\n if expected_prices.shape != (self.problem.N, 1):\n raise ValueError(f\"expected_prices must be a {self.problem.N}-vector.\")\n elif self.problem.K3 > 0:\n if iteration is None:\n iteration = Iteration('simple', {'tol': 1e-12})\n elif not isinstance(iteration, Iteration):\n raise TypeError(\"iteration must be None or an Iteration instance.\")\n else:\n prices = self.problem.products.prices\n if self.problem._absorb_demand_ids is not None:\n prices, absorption_errors = self.problem._absorb_demand_ids(prices)\n errors.extend(absorption_errors)\n covariances = self.problem.products.ZD.T @ self.problem.products.ZD\n parameters, replacement = approximately_solve(covariances, self.problem.products.ZD.T @ prices)\n if replacement:\n errors.append(exceptions.FittedValuesInversionError(covariances, replacement))\n expected_prices = self.problem.products.ZD @ parameters + self.problem.products.prices - prices\n\n # validate expected prices or their iteration configuration\n if expected_prices is None:\n if self.problem.K3 == 0:\n raise TypeError(\"A supply side was not estimated, so expected_prices must be specified.\")\n if iteration is None:\n iteration = Iteration('simple', {'tol': 1e-12})\n elif not isinstance(iteration, Iteration):\n raise TypeError(\"iteration must be None or an Iteration instance.\")\n elif iteration._compute_jacobian:\n raise ValueError(\"Analytic Jacobians are not supported for this contraction mapping.\")\n else:\n iteration = None\n expected_prices = np.c_[np.asarray(expected_prices, options.dtype)]\n if expected_prices.shape != (self.problem.N, 1):\n raise ValueError(f\"expected_prices must be a {self.problem.N}-vector.\")\n\n # average over Jacobian realizations\n converged_mappings: List[Dict[Hashable, bool]] = []\n iteration_mappings: List[Dict[Hashable, int]] = []\n evaluation_mappings: List[Dict[Hashable, int]] = []\n expected_xi_jacobian = np.zeros_like(self.xi_by_theta_jacobian)\n expected_omega_jacobian = np.zeros_like(self.omega_by_theta_jacobian)\n for _ in output_progress(range(draws), draws, start_time):\n xi_jacobian_i, omega_jacobian_i, converged_i, iterations_i, evaluations_i, errors_i = (\n self._compute_realizations(expected_prices, iteration, *sample())\n )\n expected_xi_jacobian += xi_jacobian_i / draws\n expected_omega_jacobian += omega_jacobian_i / draws\n converged_mappings.append(converged_i)\n iteration_mappings.append(iterations_i)\n evaluation_mappings.append(evaluations_i)\n errors.extend(errors_i)\n\n # output a warning about any errors\n if errors:\n output(\"\")\n output(exceptions.MultipleErrors(errors))\n output(\"\")\n\n # compute the optimal instruments\n if self.problem.K3 == 0:\n inverse_covariance_matrix = np.c_[1 / np.var(self.xi)]\n demand_instruments = inverse_covariance_matrix * expected_xi_jacobian\n supply_instruments = np.full((self.problem.N, 0), np.nan, options.dtype)\n else:\n inverse_covariance_matrix = np.c_[scipy.linalg.inv(np.cov(self.xi, self.omega, rowvar=False))]\n instruments = multiply_matrix_and_tensor(\n inverse_covariance_matrix,\n np.stack([expected_xi_jacobian, expected_omega_jacobian], axis=1)\n )\n demand_instruments, supply_instruments = np.split(instruments.reshape((self.problem.N, -1)), 2, axis=1)\n\n # structure the results\n from .optimal_instrument_results import OptimalInstrumentResults # noqa\n results = OptimalInstrumentResults(\n self, demand_instruments, supply_instruments, inverse_covariance_matrix, expected_xi_jacobian,\n expected_omega_jacobian, expected_prices, start_time, time.time(), draws, converged_mappings,\n iteration_mappings, evaluation_mappings\n )\n output(f\"Computed optimal instruments after {format_seconds(results.computation_time)}.\")\n output(\"\")\n output(results)\n return results\n\n def _compute_realizations(\n self, expected_prices: Optional[Array], iteration: Optional[Iteration], xi: Array, omega: Array) -> (\n Tuple[Array, Array, Dict[Hashable, bool], Dict[Hashable, int], Dict[Hashable, int], List[Error]]):\n \"\"\"If they have not already been estimated, compute the equilibrium prices, shares, and delta associated with a\n realization of xi and omega market-by-market. Then, compute realizations of Jacobians of xi and omega with\n respect to theta.\n \"\"\"\n errors: List[Error] = []\n\n # compute delta (which will change under equilibrium prices) and marginal costs (which won't change)\n delta = self.delta - self.xi + xi\n costs = tilde_costs = self.tilde_costs - self.omega + omega\n if self._costs_type == 'log':\n costs = np.exp(costs)\n\n # define a factory for computing realizations of prices, shares, and delta in markets\n def market_factory(s: Hashable) -> Tuple[ResultsMarket, Array, Optional[Array], Optional[Iteration]]:\n \"\"\"Build a market along with arguments used to compute equilibrium prices and shares along with delta.\"\"\"\n market_s = ResultsMarket(self.problem, s, self.sigma, self.pi, self.rho, self.beta, delta)\n costs_s = costs[self.problem._product_market_indices[s]]\n prices_s = expected_prices[self.problem._product_market_indices[s]] if expected_prices is not None else None\n return market_s, costs_s, prices_s, iteration\n\n # compute realizations of prices, shares, and delta market-by-market\n converged_mapping: Dict[Hashable, bool] = {}\n iteration_mapping: Dict[Hashable, int] = {}\n evaluation_mapping: Dict[Hashable, int] = {}\n equilibrium_prices = np.zeros_like(self.problem.products.prices)\n equilibrium_shares = np.zeros_like(self.problem.products.shares)\n generator = generate_items(self.problem.unique_market_ids, market_factory, ResultsMarket.solve_equilibrium)\n for t, (prices_t, shares_t, delta_t, errors_t, converged_t, iterations_t, evaluations_t) in generator:\n equilibrium_prices[self.problem._product_market_indices[t]] = prices_t\n equilibrium_shares[self.problem._product_market_indices[t]] = shares_t\n delta[self.problem._product_market_indices[t]] = delta_t\n errors.extend(errors_t)\n converged_mapping[t] = converged_t\n iteration_mapping[t] = iterations_t\n evaluation_mapping[t] = evaluations_t\n\n # compute the Jacobian of xi with respect to theta\n xi_jacobian, demand_errors = self._compute_demand_realization(equilibrium_prices, equilibrium_shares, delta)\n errors.extend(demand_errors)\n\n # compute the Jacobian of omega with respect to theta\n omega_jacobian = np.full((self.problem.N, self._parameters.P), np.nan, options.dtype)\n if self.problem.K3 > 0:\n omega_jacobian, supply_errors = self._compute_supply_realization(\n equilibrium_prices, equilibrium_shares, delta, tilde_costs, xi_jacobian\n )\n errors.extend(supply_errors)\n\n # return all of the information associated with this realization\n return xi_jacobian, omega_jacobian, converged_mapping, iteration_mapping, evaluation_mapping, errors\n\n def _compute_demand_realization(\n self, equilibrium_prices: Array, equilibrium_shares: Array, delta: Array) -> Tuple[Array, List[Error]]:\n \"\"\"Compute a realization of the Jacobian of xi with respect to theta market-by-market. If necessary, revert\n problematic elements to their estimated values.\n \"\"\"\n errors: List[Error] = []\n\n # check if the Jacobian does not need to be computed\n xi_jacobian = np.full((self.problem.N, self._parameters.P), np.nan, options.dtype)\n if self._parameters.P == 0:\n return xi_jacobian, errors\n\n # define a factory for computing the Jacobian of xi with respect to theta in markets\n def market_factory(s: Hashable) -> Tuple[ResultsMarket, Parameters]:\n \"\"\"Build a market with the data realization along with arguments used to compute the Jacobian.\"\"\"\n data_override_s = {\n 'prices': equilibrium_prices[self.problem._product_market_indices[s]],\n 'shares': equilibrium_shares[self.problem._product_market_indices[s]]\n }\n market_s = ResultsMarket(self.problem, s, self.sigma, self.pi, self.rho, self.beta, delta, data_override_s)\n return market_s, self._parameters\n\n # compute the Jacobian market-by-market\n generator = generate_items(\n self.problem.unique_market_ids, market_factory, ResultsMarket.compute_xi_by_theta_jacobian\n )\n for t, (xi_jacobian_t, errors_t) in generator:\n xi_jacobian[self.problem._product_market_indices[t]] = xi_jacobian_t\n errors.extend(errors_t)\n\n # replace invalid elements\n bad_jacobian_index = ~np.isfinite(xi_jacobian)\n if np.any(bad_jacobian_index):\n xi_jacobian[bad_jacobian_index] = self.xi_by_theta_jacobian[bad_jacobian_index]\n errors.append(exceptions.XiByThetaJacobianReversionError(bad_jacobian_index))\n return xi_jacobian, errors\n\n def _compute_supply_realization(\n self, equilibrium_prices: Array, equilibrium_shares: Array, delta: Array, tilde_costs: Array,\n xi_jacobian: Array) -> Tuple[Array, List[Error]]:\n \"\"\"Compute a realization of the Jacobian of omega with respect to theta market-by-market. If necessary, revert\n problematic elements to their estimated values.\n \"\"\"\n errors: List[Error] = []\n\n # define a factory for computing the Jacobian of omega with respect to theta in markets\n def market_factory(s: Hashable) -> Tuple[ResultsMarket, Array, Array, Parameters, str]:\n \"\"\"Build a market with the data realization along with arguments used to compute the Jacobians.\"\"\"\n data_override_s = {\n 'prices': equilibrium_prices[self.problem._product_market_indices[s]],\n 'shares': equilibrium_shares[self.problem._product_market_indices[s]]\n }\n market_s = ResultsMarket(self.problem, s, self.sigma, self.pi, self.rho, self.beta, delta, data_override_s)\n tilde_costs_s = tilde_costs[self.problem._product_market_indices[s]]\n xi_jacobian_s = xi_jacobian[self.problem._product_market_indices[s]]\n return market_s, tilde_costs_s, xi_jacobian_s, self._parameters, self._costs_type\n\n # compute the Jacobian market-by-market\n omega_jacobian = np.full((self.problem.N, self._parameters.P), np.nan, options.dtype)\n generator = generate_items(\n self.problem.unique_market_ids, market_factory, ResultsMarket.compute_omega_by_theta_jacobian\n )\n for t, (omega_jacobian_t, errors_t) in generator:\n omega_jacobian[self.problem._product_market_indices[t]] = omega_jacobian_t\n errors.extend(errors_t)\n\n # the Jacobian should be zero for any clipped marginal costs\n omega_jacobian[self.clipped_costs.flat] = 0\n\n # replace invalid elements\n bad_jacobian_index = ~np.isfinite(omega_jacobian)\n if np.any(bad_jacobian_index):\n omega_jacobian[bad_jacobian_index] = self.omega_by_theta_jacobian[bad_jacobian_index]\n errors.append(exceptions.OmegaByThetaJacobianReversionError(bad_jacobian_index))\n return omega_jacobian, errors\n\n def _coerce_matrices(self, matrices: Any) -> Array:\n \"\"\"Coerce array-like stacked matrices into a stacked matrix and validate it.\"\"\"\n matrices = np.c_[np.asarray(matrices, options.dtype)]\n if matrices.shape != (self.problem.N, self.problem._max_J):\n raise ValueError(f\"matrices must be {self.problem.N} by {self.problem._max_J}.\")\n return matrices\n\n def _coerce_optional_costs(self, costs: Optional[Any]) -> Array:\n \"\"\"Coerce optional array-like costs into a column vector and validate it.\"\"\"\n if costs is not None:\n costs = np.c_[np.asarray(costs, options.dtype)]\n if costs.shape != (self.problem.N, 1):\n raise ValueError(f\"costs must be None or a {self.problem.N}-vector.\")\n return costs\n\n def _coerce_optional_prices(self, prices: Optional[Any]) -> Array:\n \"\"\"Coerce optional array-like prices into a column vector and validate it.\"\"\"\n if prices is not None:\n prices = np.c_[np.asarray(prices, options.dtype)]\n if prices.shape != (self.problem.N, 1):\n raise ValueError(f\"prices must be None or a {self.problem.N}-vector.\")\n return prices\n\n def _coerce_optional_shares(self, shares: Optional[Any]) -> Array:\n \"\"\"Coerce optional array-like shares into a column vector and validate it.\"\"\"\n if shares is not None:\n shares = np.c_[np.asarray(shares, options.dtype)]\n if shares.shape != (self.problem.N, 1):\n raise ValueError(f\"shares must be None or a {self.problem.N}-vector.\")\n return shares\n\n def _combine_arrays(\n self, compute_market_results: Callable, fixed_args: Sequence = (), market_args: Sequence = ()) -> Array:\n \"\"\"Compute an array for each market and stack them into a single matrix. An array for a single market is\n computed by passing fixed_args (identical for all markets) and market_args (matrices with as many rows as there\n are products that are restricted to the market) to compute_market_results, a ResultsMarket method that returns\n the output for the market and a set of any errors encountered during computation.\n \"\"\"\n errors: List[Error] = []\n\n # keep track of how long it takes to compute the arrays\n start_time = time.time()\n\n # define a factory for computing arrays in markets\n def market_factory(s: Hashable) -> tuple:\n \"\"\"Build a market along with arguments used to compute arrays.\"\"\"\n indices_s = self.problem._product_market_indices[s]\n market_s = ResultsMarket(self.problem, s, self.sigma, self.pi, self.rho, self.beta, self.delta)\n args_s = [None if a is None else a[indices_s] for a in market_args]\n return (market_s, *fixed_args, *args_s)\n\n # construct a mapping from market IDs to market-specific arrays\n matrix_mapping: Dict[Hashable, Array] = {}\n generator = output_progress(\n generate_items(self.problem.unique_market_ids, market_factory, compute_market_results), self.problem.T,\n start_time\n )\n for t, (array_t, errors_t) in generator:\n matrix_mapping[t] = np.c_[array_t]\n errors.extend(errors_t)\n\n # output a warning about any errors\n if errors:\n output(\"\")\n output(exceptions.MultipleErrors(errors))\n output(\"\")\n\n # determine the number of rows and columns\n row_count = sum(matrix_mapping[t].shape[0] for t in self.problem.unique_market_ids)\n column_count = max(matrix_mapping[t].shape[1] for t in self.problem.unique_market_ids)\n\n # preserve the original product order or the sorted market order when stacking the arrays\n combined = np.full((row_count, column_count), np.nan, options.dtype)\n for t, matrix_t in matrix_mapping.items():\n if row_count == self.problem.N:\n combined[self.problem._product_market_indices[t], :matrix_t.shape[1]] = matrix_t\n else:\n combined[self.problem.unique_market_ids == t, :matrix_t.shape[1]] = matrix_t\n\n # output how long it took to compute the arrays\n end_time = time.time()\n output(f\"Finished after {format_seconds(end_time - start_time)}.\")\n output(\"\")\n return combined\n", "meta": {"hexsha": "222e8278e81c41ac1dc2eabc5ad020c745a67804", "size": 56667, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyblp/results/problem_results.py", "max_stars_repo_name": "yusukeaoki1223/pyblp", "max_stars_repo_head_hexsha": "71cea45251f3772ef8f3dc62c7e47b9820308396", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-02-10T14:25:08.000Z", "max_stars_repo_stars_event_max_datetime": "2019-02-10T14:25:08.000Z", "max_issues_repo_path": "pyblp/results/problem_results.py", "max_issues_repo_name": "yusukeaoki1223/pyblp", "max_issues_repo_head_hexsha": "71cea45251f3772ef8f3dc62c7e47b9820308396", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pyblp/results/problem_results.py", "max_forks_repo_name": "yusukeaoki1223/pyblp", "max_forks_repo_head_hexsha": "71cea45251f3772ef8f3dc62c7e47b9820308396", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 52.8117427773, "max_line_length": 120, "alphanum_fraction": 0.6668607832, "include": true, "reason": "import numpy,import scipy", "num_tokens": 12301, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.523420348936324, "lm_q2_score": 0.3629692055196168, "lm_q1q2_score": 0.18998546820621814}} {"text": "\nimport os\nimport time\nimport re\nfrom contextlib import contextmanager\nfrom copy import copy\nfrom pathlib import Path\n\nimport numpy as np\nimport math\nimport torch\nimport torch.nn as nn\nfrom helper.torch_utils import is_parallel\n\n@contextmanager\ndef torch_distributed_zero_first(local_rank: int):\n \"\"\"\n Decorator to make all processes in distributed training wait for each local_master to do something.\n \"\"\"\n if local_rank not in [-1, 0]:\n torch.distributed.barrier()\n yield\n if local_rank == 0:\n torch.distributed.barrier()\n\ndef xywh2xyxy(x):\n # Convert nx4 boxes from [x, y, w, h] to [x1, y1, x2, y2] where xy1=top-left, xy2=bottom-right\n y = torch.zeros_like(x) if isinstance(x, torch.Tensor) else np.zeros_like(x)\n y[:, 0] = x[:, 0] - x[:, 2] / 2 # top left x\n y[:, 1] = x[:, 1] - x[:, 3] / 2 # top left y\n y[:, 2] = x[:, 0] + x[:, 2] / 2 # bottom right x\n y[:, 3] = x[:, 1] + x[:, 3] / 2 # bottom right y\n return y\n\ndef xyxy2xywh(x):\n # Convert nx4 boxes from [x1, y1, x2, y2] to [x, y, w, h] where xy1=top-left, xy2=bottom-right\n y = torch.zeros_like(x) if isinstance(x, torch.Tensor) else np.zeros_like(x)\n y[:, 0] = (x[:, 0] + x[:, 2]) / 2 # x center\n y[:, 1] = (x[:, 1] + x[:, 3]) / 2 # y center\n y[:, 2] = x[:, 2] - x[:, 0] # width\n y[:, 3] = x[:, 3] - x[:, 1] # height\n return y\n\ndef smooth_BCE(eps=0.1): # https://github.com/ultralytics/yolov3/issues/238#issuecomment-598028441\n # return positive, negative label smoothing BCE targets\n return 1.0 - 0.5 * eps, 0.5 * eps\n\ndef compute_ap(recall, precision):\n \"\"\" Compute the average precision, given the recall and precision curves.\n Source: https://github.com/rbgirshick/py-faster-rcnn.\n # Arguments\n recall: The recall curve (list).\n precision: The precision curve (list).\n # Returns\n The average precision as computed in py-faster-rcnn.\n \"\"\"\n\n # Append sentinel values to beginning and end\n mrec = np.concatenate(([0.], recall, [min(recall[-1] + 1E-3, 1.)]))\n mpre = np.concatenate(([0.], precision, [0.]))\n\n # Compute the precision envelope\n mpre = np.flip(np.maximum.accumulate(np.flip(mpre)))\n\n # Integrate area under curve\n method = 'interp' # methods: 'continuous', 'interp'\n if method == 'interp':\n x = np.linspace(0, 1, 101) # 101-point interp (COCO)\n ap = np.trapz(np.interp(x, mrec, mpre), x) # integrate\n else: # 'continuous'\n i = np.where(mrec[1:] != mrec[:-1])[0] # points where x axis (recall) changes\n ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1]) # area under curve\n\n return ap\n\nclass FocalLoss(nn.Module):\n # Wraps focal loss around existing loss_fcn(), i.e. criteria = FocalLoss(nn.BCEWithLogitsLoss(), gamma=1.5)\n def __init__(self, loss_fcn, gamma=1.5, alpha=0.25):\n super(FocalLoss, self).__init__()\n self.loss_fcn = loss_fcn # must be nn.BCEWithLogitsLoss()\n self.gamma = gamma\n self.alpha = alpha\n self.reduction = loss_fcn.reduction\n self.loss_fcn.reduction = 'none' # required to apply FL to each element\n\n def forward(self, pred, true):\n loss = self.loss_fcn(pred, true)\n # p_t = torch.exp(-loss)\n # loss *= self.alpha * (1.000001 - p_t) ** self.gamma # non-zero power for gradient stability\n\n # TF implementation https://github.com/tensorflow/addons/blob/v0.7.1/tensorflow_addons/losses/focal_loss.py\n pred_prob = torch.sigmoid(pred) # prob from logits\n p_t = true * pred_prob + (1 - true) * (1 - pred_prob)\n alpha_factor = true * self.alpha + (1 - true) * (1 - self.alpha)\n modulating_factor = (1.0 - p_t) ** self.gamma\n loss *= alpha_factor * modulating_factor\n\n if self.reduction == 'mean':\n return loss.mean()\n elif self.reduction == 'sum':\n return loss.sum()\n else: # 'none'\n return loss\n\ndef build_targets(p, targets, model):\n # Build targets for compute_loss(), input targets(image,class,x,y,w,h)\n det = model.module.model[-1] if is_parallel(model) else model.model[-1] # Detect() module\n na, nt = det.na, targets.shape[0] # number of anchors, targets\n tcls, tbox, indices, anch = [], [], [], []\n gain = torch.ones(7, device=targets.device) # normalized to gridspace gain\n ai = torch.arange(na, device=targets.device).float().view(na, 1).repeat(1, nt) # same as .repeat_interleave(nt)\n targets = torch.cat((targets.repeat(na, 1, 1), ai[:, :, None]), 2) # append anchor indices\n\n g = 0.5 # bias\n off = torch.tensor([[0, 0],\n [1, 0], [0, 1], [-1, 0], [0, -1], # j,k,l,m\n # [1, 1], [1, -1], [-1, 1], [-1, -1], # jk,jm,lk,lm\n ], device=targets.device).float() * g # offsets\n\n for i in range(det.nl):\n anchors = det.anchors[i]\n gain[2:6] = torch.tensor(p[i].shape)[[3, 2, 3, 2]] # xyxy gain\n\n # Match targets to anchors\n t = targets * gain\n if nt:\n # Matches\n r = t[:, :, 4:6] / anchors[:, None] # wh ratio\n j = torch.max(r, 1. / r).max(2)[0] < model.hyp['anchor_t'] # compare\n # j = wh_iou(anchors, t[:, 4:6]) > model.hyp['iou_t'] # iou(3,n)=wh_iou(anchors(3,2), gwh(n,2))\n t = t[j] # filter\n\n # Offsets\n gxy = t[:, 2:4] # grid xy\n gxi = gain[[2, 3]] - gxy # inverse\n j, k = ((gxy % 1. < g) & (gxy > 1.)).T\n l, m = ((gxi % 1. < g) & (gxi > 1.)).T\n j = torch.stack((torch.ones_like(j), j, k, l, m))\n t = t.repeat((5, 1, 1))[j]\n offsets = (torch.zeros_like(gxy)[None] + off[:, None])[j]\n else:\n t = targets[0]\n offsets = 0\n\n # Define\n b, c = t[:, :2].long().T # image, class\n gxy = t[:, 2:4] # grid xy\n gwh = t[:, 4:6] # grid wh\n gij = (gxy - offsets).long()\n gi, gj = gij.T # grid xy indices\n\n # Append\n a = t[:, 6].long() # anchor indices\n indices.append((b, a, gj, gi)) # image, anchor, grid indices\n tbox.append(torch.cat((gxy - gij, gwh), 1)) # box\n anch.append(anchors[a]) # anchors\n tcls.append(c) # class\n\n return tcls, tbox, indices, anch\n\ndef bbox_iou(box1, box2, x1y1x2y2=True, GIoU=False, DIoU=False, CIoU=False, eps=1e-9):\n # Returns the IoU of box1 to box2. box1 is 4, box2 is nx4\n box2 = box2.T\n\n # Get the coordinates of bounding boxes\n if x1y1x2y2: # x1, y1, x2, y2 = box1\n b1_x1, b1_y1, b1_x2, b1_y2 = box1[0], box1[1], box1[2], box1[3]\n b2_x1, b2_y1, b2_x2, b2_y2 = box2[0], box2[1], box2[2], box2[3]\n else: # transform from xywh to xyxy\n b1_x1, b1_x2 = box1[0] - box1[2] / 2, box1[0] + box1[2] / 2\n b1_y1, b1_y2 = box1[1] - box1[3] / 2, box1[1] + box1[3] / 2\n b2_x1, b2_x2 = box2[0] - box2[2] / 2, box2[0] + box2[2] / 2\n b2_y1, b2_y2 = box2[1] - box2[3] / 2, box2[1] + box2[3] / 2\n\n # Intersection area\n inter = (torch.min(b1_x2, b2_x2) - torch.max(b1_x1, b2_x1)).clamp(0) * \\\n (torch.min(b1_y2, b2_y2) - torch.max(b1_y1, b2_y1)).clamp(0)\n\n # Union Area\n w1, h1 = b1_x2 - b1_x1, b1_y2 - b1_y1 + eps\n w2, h2 = b2_x2 - b2_x1, b2_y2 - b2_y1 + eps\n union = w1 * h1 + w2 * h2 - inter + eps\n\n iou = inter / union\n if GIoU or DIoU or CIoU:\n cw = torch.max(b1_x2, b2_x2) - torch.min(b1_x1, b2_x1) # convex (smallest enclosing box) width\n ch = torch.max(b1_y2, b2_y2) - torch.min(b1_y1, b2_y1) # convex height\n if CIoU or DIoU: # Distance or Complete IoU https://arxiv.org/abs/1911.08287v1\n c2 = cw ** 2 + ch ** 2 + eps # convex diagonal squared\n rho2 = ((b2_x1 + b2_x2 - b1_x1 - b1_x2) ** 2 +\n (b2_y1 + b2_y2 - b1_y1 - b1_y2) ** 2) / 4 # center distance squared\n if DIoU:\n return iou - rho2 / c2 # DIoU\n elif CIoU: # https://github.com/Zzh-tju/DIoU-SSD-pytorch/blob/master/utils/box/box_utils.py#L47\n v = (4 / math.pi ** 2) * torch.pow(torch.atan(w2 / h2) - torch.atan(w1 / h1), 2)\n with torch.no_grad():\n alpha = v / ((1 + eps) - iou + v)\n return iou - (rho2 / c2 + v * alpha) # CIoU\n else: # GIoU https://arxiv.org/pdf/1902.09630.pdf\n c_area = cw * ch + eps # convex area\n return iou - (c_area - union) / c_area # GIoU\n else:\n return iou # IoU\n\ndef ap_per_class(tp, conf, pred_cls, target_cls, plot=False, fname='precision-recall_curve.png'):\n \"\"\" Compute the average precision, given the recall and precision curves.\n Source: https://github.com/rafaelpadilla/Object-Detection-Metrics.\n # Arguments\n tp: True positives (nparray, nx1 or nx10).\n conf: Objectness value from 0-1 (nparray).\n pred_cls: Predicted object classes (nparray).\n target_cls: True object classes (nparray).\n plot: Plot precision-recall curve at mAP@0.5\n fname: Plot filename\n # Returns\n The average precision as computed in py-faster-rcnn.\n \"\"\"\n\n # Sort by objectness\n i = np.argsort(-conf)\n tp, conf, pred_cls = tp[i], conf[i], pred_cls[i]\n\n # Find unique classes\n unique_classes = np.unique(target_cls)\n\n # Create Precision-Recall curve and compute AP for each class\n px, py = np.linspace(0, 1, 1000), [] # for plotting\n pr_score = 0.1 # score to evaluate P and R https://github.com/ultralytics/yolov3/issues/898\n s = [unique_classes.shape[0], tp.shape[1]] # number class, number iou thresholds (i.e. 10 for mAP0.5...0.95)\n ap, p, r = np.zeros(s), np.zeros(s), np.zeros(s)\n for ci, c in enumerate(unique_classes):\n i = pred_cls == c\n n_gt = (target_cls == c).sum() # Number of ground truth objects\n n_p = i.sum() # Number of predicted objects\n\n if n_p == 0 or n_gt == 0:\n continue\n else:\n # Accumulate FPs and TPs\n fpc = (1 - tp[i]).cumsum(0)\n tpc = tp[i].cumsum(0)\n\n # Recall\n recall = tpc / (n_gt + 1e-16) # recall curve\n r[ci] = np.interp(-pr_score, -conf[i], recall[:, 0]) # r at pr_score, negative x, xp because xp decreases\n\n # Precision\n precision = tpc / (tpc + fpc) # precision curve\n p[ci] = np.interp(-pr_score, -conf[i], precision[:, 0]) # p at pr_score\n\n # AP from recall-precision curve\n py.append(np.interp(px, recall[:, 0], precision[:, 0])) # precision at mAP@0.5\n for j in range(tp.shape[1]):\n ap[ci, j] = compute_ap(recall[:, j], precision[:, j])\n\n # Compute F1 score (harmonic mean of precision and recall)\n f1 = 2 * p * r / (p + r + 1e-16)\n\n return p, r, ap, f1, unique_classes.astype('int32')\n\ndef box_iou(box1, box2):\n # https://github.com/pytorch/vision/blob/master/torchvision/ops/boxes.py\n \"\"\"\n Return intersection-over-union (Jaccard index) of boxes.\n Both sets of boxes are expected to be in (x1, y1, x2, y2) format.\n Arguments:\n box1 (Tensor[N, 4])\n box2 (Tensor[M, 4])\n Returns:\n iou (Tensor[N, M]): the NxM matrix containing the pairwise\n IoU values for every element in boxes1 and boxes2\n \"\"\"\n\n def box_area(box):\n # box = 4xn\n return (box[2] - box[0]) * (box[3] - box[1])\n\n area1 = box_area(box1.T)\n area2 = box_area(box2.T)\n\n # inter(N,M) = (rb(N,M,2) - lt(N,M,2)).clamp(0).prod(2)\n inter = (torch.min(box1[:, None, 2:], box2[:, 2:]) - torch.max(box1[:, None, :2], box2[:, :2])).clamp(0).prod(2)\n return inter / (area1[:, None] + area2 - inter) # iou = inter / (area1 + area2 - inter)\n\ndef clip_coords(boxes, img_shape):\n # Clip bounding xyxy bounding boxes to image shape (height, width)\n boxes[:, 0].clamp_(0, img_shape[1]) # x1\n boxes[:, 1].clamp_(0, img_shape[0]) # y1\n boxes[:, 2].clamp_(0, img_shape[1]) # x2\n boxes[:, 3].clamp_(0, img_shape[0]) # y2\n\ndef non_max_suppression(prediction, conf_thres=0.1, iou_thres=0.6, merge=False, classes=None, agnostic=False):\n \"\"\"Performs Non-Maximum Suppression (NMS) on inference results\n\n Returns:\n detections with shape: nx6 (x1, y1, x2, y2, conf, cls)\n \"\"\"\n\n nc = prediction[0].shape[1] - 5 # number of classes\n xc = prediction[..., 4] > conf_thres # candidates\n\n # Settings\n min_wh, max_wh = 2, 4096 # (pixels) minimum and maximum box width and height\n max_det = 300 # maximum number of detections per image\n time_limit = 10.0 # seconds to quit after\n redundant = True # require redundant detections\n multi_label = nc > 1 # multiple labels per box (adds 0.5ms/img)\n\n t = time.time()\n output = [None] * prediction.shape[0]\n for xi, x in enumerate(prediction): # image index, image inference\n # Apply constraints\n # x[((x[..., 2:4] < min_wh) | (x[..., 2:4] > max_wh)).any(1), 4] = 0 # width-height\n x = x[xc[xi]] # confidence\n\n # If none remain process next image\n if not x.shape[0]:\n continue\n\n # Compute conf\n x[:, 5:] *= x[:, 4:5] # conf = obj_conf * cls_conf\n\n # Box (center x, center y, width, height) to (x1, y1, x2, y2)\n box = xywh2xyxy(x[:, :4])\n\n # Detections matrix nx6 (xyxy, conf, cls)\n if multi_label:\n i, j = (x[:, 5:] > conf_thres).nonzero(as_tuple=False).T\n x = torch.cat((box[i], x[i, j + 5, None], j[:, None].float()), 1)\n else: # best class only\n conf, j = x[:, 5:].max(1, keepdim=True)\n x = torch.cat((box, conf, j.float()), 1)[conf.view(-1) > conf_thres]\n\n # Filter by class\n if classes:\n x = x[(x[:, 5:6] == torch.tensor(classes, device=x.device)).any(1)]\n\n # Apply finite constraint\n # if not torch.isfinite(x).all():\n # x = x[torch.isfinite(x).all(1)]\n\n # If none remain process next image\n n = x.shape[0] # number of boxes\n if not n:\n continue\n\n # Sort by confidence\n # x = x[x[:, 4].argsort(descending=True)]\n\n # Batched NMS\n c = x[:, 5:6] * (0 if agnostic else max_wh) # classes\n boxes, scores = x[:, :4] + c, x[:, 4] # boxes (offset by class), scores\n i = torch.ops.torchvision.nms(boxes, scores, iou_thres)\n if i.shape[0] > max_det: # limit detections\n i = i[:max_det]\n if merge and (1 < n < 3E3): # Merge NMS (boxes merged using weighted mean)\n try: # update boxes as boxes(i,4) = weights(i,n) * boxes(n,4)\n iou = box_iou(boxes[i], boxes) > iou_thres # iou matrix\n weights = iou * scores[None] # box weights\n x[i, :4] = torch.mm(weights, x[:, :4]).float() / weights.sum(1, keepdim=True) # merged boxes\n if redundant:\n i = i[iou.sum(1) > 1] # require redundancy\n except: # possible CUDA error https://github.com/ultralytics/yolov3/issues/1139\n print(x, i, x.shape, i.shape)\n pass\n\n output[xi] = x[i]\n if (time.time() - t) > time_limit:\n break # time limit exceeded\n\n return output\n\n\ndef compute_loss(p, targets, model): # predictions, targets, model\n device = targets.device\n lcls, lbox, lobj = torch.zeros(1, device=device), torch.zeros(1, device=device), torch.zeros(1, device=device)\n tcls, tbox, indices, anchors = build_targets(p, targets, model) # targets\n h = model.hyp # hyperparameters\n\n # Define criteria\n BCEcls = nn.BCEWithLogitsLoss(pos_weight=torch.Tensor([h['cls_pw']])).to(device)\n BCEobj = nn.BCEWithLogitsLoss(pos_weight=torch.Tensor([h['obj_pw']])).to(device)\n\n # Class label smoothing https://arxiv.org/pdf/1902.04103.pdf eqn 3\n cp, cn = smooth_BCE(eps=0.0)\n\n # Focal loss\n g = h['fl_gamma'] # focal loss gamma\n if g > 0:\n BCEcls, BCEobj = FocalLoss(BCEcls, g), FocalLoss(BCEobj, g)\n\n # Losses\n nt = 0 # number of targets\n np = len(p) # number of outputs\n balance = [4.0, 1.0, 0.4] if np == 3 else [4.0, 1.0, 0.4, 0.1] # P3-5 or P3-6\n for i, pi in enumerate(p): # layer index, layer predictions\n b, a, gj, gi = indices[i] # image, anchor, gridy, gridx\n tobj = torch.zeros_like(pi[..., 0], device=device) # target obj\n\n n = b.shape[0] # number of targets\n if n:\n nt += n # cumulative targets\n ps = pi[b, a, gj, gi] # prediction subset corresponding to targets\n\n # Regression\n pxy = ps[:, :2].sigmoid() * 2. - 0.5\n pwh = (ps[:, 2:4].sigmoid() * 2) ** 2 * anchors[i]\n pbox = torch.cat((pxy, pwh), 1).to(device) # predicted box\n iou = bbox_iou(pbox.T, tbox[i], x1y1x2y2=False, CIoU=True) # iou(prediction, target)\n lbox += (1.0 - iou).mean() # iou loss\n\n # Objectness\n tobj[b, a, gj, gi] = (1.0 - model.gr) + model.gr * iou.detach().clamp(0).type(tobj.dtype) # iou ratio\n\n # Classification\n if model.nc > 1: # cls loss (only if multiple classes)\n t = torch.full_like(ps[:, 5:], cn, device=device) # targets\n t[range(n), tcls[i]] = cp\n lcls += BCEcls(ps[:, 5:], t) # BCE\n\n # Append targets to text file\n # with open('targets.txt', 'a') as file:\n # [file.write('%11.5g ' * 4 % tuple(x) + '\\n') for x in torch.cat((txy[i], twh[i]), 1)]\n\n lobj += BCEobj(pi[..., 4], tobj) * balance[i] # obj loss\n\n s = 3 / np # output count scaling\n lbox *= h['box'] * s\n lobj *= h['obj'] * s * (1.4 if np == 4 else 1.)\n lcls *= h['cls'] * s\n bs = tobj.shape[0] # batch size\n\n loss = lbox + lobj + lcls\n return loss * bs, torch.cat((lbox, lobj, lcls, loss)).detach()", "meta": {"hexsha": "0a961d5780f2816efa5b4cb424c54a4b676c687e", "size": 17935, "ext": "py", "lang": "Python", "max_stars_repo_path": "helper/general.py", "max_stars_repo_name": "imgcook/pipcook-plugin-pytorch-yolov5-evaluator", "max_stars_repo_head_hexsha": "eafac6d84d2e8b910a7600cc41c9045ca870acf9", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-11-04T12:43:51.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-01T13:06:12.000Z", "max_issues_repo_path": "helper/general.py", "max_issues_repo_name": "imgcook/pipcook-plugin-pytorch-yolov5-evaluator", "max_issues_repo_head_hexsha": "eafac6d84d2e8b910a7600cc41c9045ca870acf9", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "helper/general.py", "max_forks_repo_name": "imgcook/pipcook-plugin-pytorch-yolov5-evaluator", "max_forks_repo_head_hexsha": "eafac6d84d2e8b910a7600cc41c9045ca870acf9", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.3248847926, "max_line_length": 118, "alphanum_fraction": 0.5603568442, "include": true, "reason": "import numpy", "num_tokens": 5890, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.523420348936324, "lm_q2_score": 0.3629692055196168, "lm_q1q2_score": 0.18998546820621814}} {"text": "# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Tue May 5 21:08:51 2015\n\n@author: richard\n\nTODO: implemement unit tests with nose\n\"\"\"\n\nimport sys\nimport numpy as np\nimport pandas as pd\nfrom flight import Flight\nfrom decisions import Decisions\nfrom observations import Observations\nfrom random import choice as choose\nfrom roboskeeter.math.math_toolbox import generate_random_unit_vector\n\nclass Simulator:\n \"\"\"Our simulated mosquito.\n \"\"\"\n\n def __init__(self, experiment, agent_kwargs):\n \"\"\" Load params\n \"\"\"\n # dump kwarg dictionary into the agent object\n for key, value in agent_kwargs.iteritems():\n setattr(self, key, value)\n\n self.decisions = Decisions(self.decision_policy, self.stimulus_memory_n_timesteps)\n\n if experiment.is_simulation:\n self._simulated_agent_init(experiment)\n\n def _simulated_agent_init(self, experiment):\n # defaults\n self.mass = 2.88e-6 # avg. mass of our colony (kg) =2.88 mg,\n self.time_max = 15.\n self.dt = 0.01\n self.max_bins = int(np.ceil(self.time_max / self.dt)) # N bins\n\n # from gassian fit to experimental control data\n self.initial_velocity_mu = 0.18\n self.initial_velocity_stdev = 0.08\n\n # useful aliases\n self.experiment = experiment\n self.windtunnel = self.experiment.environment.windtunnel\n self.bounded = self.experiment.experiment_conditions['bounded']\n self.boundary = self.windtunnel.boundary\n self.heat = self.experiment.environment.heat\n\n # useful lists TODO: get rid of?\n self.kinematics_list = ['position', 'velocity', 'acceleration'] # curvature?\n self.forces_list = ['total_f', 'random_f', 'stim_f']\n self.other_list = ['tsi', 'times', 'decision', 'heat_signal', 'in_plume']\n\n # mk forces\n self.flight = Flight(self.random_f_strength,\n self.stim_f_strength,\n self.damping_coeff)\n\n # turn thresh, in units deg s-1.\n # From Sharri:\n # it is the stdev of the broader of two Gaussians that fit the distribution of angular velocity\n\n # # create repulsion landscape\n # self._repulsion_funcs = repulsion_landscape3D.landscape(boundary=self.boundary)\n\n def fly(self, n_trajectories=1):\n \"\"\" runs _generate_flight n_trajectories times\n \"\"\"\n df_list = []\n traj_i = 0\n try:\n if self.verbose:\n print \"\"\"Starting simulations with {} heat model and {} decision policy.\n If you run out of patience, press -C to stop generating simulations and\n cut to the chase scene.\"\"\".format(\n self.heat.heat_model_name, self.decision_policy)\n\n while traj_i < n_trajectories:\n # print updates\n if self.verbose:\n sys.stdout.write(\"\\rTrajectory {}/{}\".format(traj_i + 1, n_trajectories))\n sys.stdout.flush()\n\n array_dict = self._generate_flight()\n\n # if len(array_dict['velocity_x']) < 5: # hack to catch when optimizer makes trajectories explode\n # print \"catching explosion\"\n # break\n\n # add label column to enumerate the trajectories\n array_len = len(array_dict['tsi'])\n array_dict['trajectory_num'] = [traj_i] * array_len\n\n # mk df, add to list of dfs\n df = pd.DataFrame(array_dict)\n # df = df.set_index(['trajectory_num'])\n df_list.append(df)\n\n traj_i += 1\n\n if traj_i == n_trajectories:\n if self.verbose:\n sys.stdout.write(\"\\rSimulations finished. Performing deep magic.\")\n sys.stdout.flush()\n\n except KeyboardInterrupt:\n print \"\\n Simulations interrupted at iteration {}. Moving along...\".format(traj_i)\n pass\n\n observations = Observations()\n observations.kinematics = pd.concat(df_list) # concatenate all the data frames at once for performance boost.\n\n return observations\n\n def _generate_flight(self):\n \"\"\"Generate a single trajectory using our model.\n \n First put everything into np arrays stored inside of a dictionary\n \"\"\"\n dt = self.dt\n m = self.mass\n vector_dict = self._initialize_vector_dict()\n\n # # dynamically create easy-to-read aliases for the contents of vector_dict\n # for key, value in vector_dict.iteritems():\n # exec(key + \" = vector_dict['\" + key + \"']\")\n # unpack vector dict into nicer aliases\n in_plume = vector_dict['in_plume']\n heat_signal = vector_dict['heat_signal']\n position = vector_dict['position']\n velocity = vector_dict['velocity']\n acceleration = vector_dict['acceleration']\n random_f = vector_dict['random_f']\n stim_f = vector_dict['stim_f']\n total_f = vector_dict['total_f']\n decision = vector_dict['decision']\n\n position[0] = self._set_init_position()\n velocity[0] = self._set_init_velocity()\n\n for tsi in vector_dict['tsi']:\n in_plume[tsi] = self.heat.check_in_plume_bounds(position[tsi]) # returns False for non-Bool plume\n\n decision[tsi], heat_signal[tsi] = self.decisions.make_decision(in_plume[tsi], velocity[tsi][1])\n\n if heat_signal[tsi] == 'X': # this is an awful hack telling us to look up the gradient\n heat_signal[tsi] = self.heat.get_nearest_gradient(position[tsi])\n\n stim_f[tsi], random_f[tsi], total_f[tsi] = self.flight.calc_forces(velocity[tsi], decision[tsi], heat_signal[tsi])\n\n # calculate current acceleration\n acceleration[tsi] = total_f[tsi] / m\n\n # check if time is out, end loop before we solve for future velo, position\n if tsi == self.max_bins-1: # -1 because of how range() works\n vector_dict = self._land(tsi, vector_dict)\n break\n\n ################################################\n # Calculate candidate velocity and positions\n ################################################\n candidate_velo = velocity[tsi] + acceleration[tsi] * dt\n\n # make sure velocity doesn't diverge to infinity if system is unstable\n # this stops the optimizer from crashing\n candidate_velo = self._velocity_ceiling(candidate_velo)\n\n candidate_pos = position[tsi] + candidate_velo * dt\n\n ################################################\n # test candidates\n ################################################\n if self.bounded:\n candidate_pos, candidate_velo = self._collide_with_wall(candidate_pos, candidate_velo)\n\n position[tsi + 1] = candidate_pos\n velocity[tsi + 1] = candidate_velo\n\n # once flight is finished, make dictionary ready to be loaded into DF\n vector_dict = self._fix_vector_dict(vector_dict)\n\n return vector_dict\n\n def _land(self, tsi, V):\n ''' trim excess timebins in arrays\n '''\n if tsi == 0: # hack for if we need to chop a trajectory at the very start\n for k, array in V.iteritems():\n V[k] = array[:1]\n else:\n for k, array in V.iteritems():\n V[k] = array[:tsi - 1]\n V[k] = array[:tsi - 1]\n \n return V\n\n def _collide_with_wall(self, candidate_pos, candidate_velo):\n walls = self.windtunnel.walls\n xpos, ypos, zpos = candidate_pos\n xvelo, yvelo, zvelo = candidate_velo\n teleport_distance = 0.005 # this is arbitrary\n crash = False\n\n # print \"test\", candidate_velo\n\n # x dim\n if xpos < walls.downwind: # too far behind\n crash = True\n xpos = walls.downwind + teleport_distance # teleport back inside\n if self.collision_type == 'elastic':\n xvelo *= -1.\n elif self.collision_type == 'part_elastic':\n xvelo *= -self.restitution_coeff\n elif self.collision_type == 'crash':\n xvelo = 0.\n else:\n raise ValueError(\"unknown collision type {}\".format(self.collision_type))\n if xpos > walls.upwind: # reached far (upwind) wall (end)\n crash = True\n xpos = walls.upwind - teleport_distance # teleport back inside\n if self.collision_type == 'elastic':\n xvelo *= -1.\n elif self.collision_type == 'part_elastic':\n xvelo *= -self.restitution_coeff\n elif self.collision_type == 'crash':\n xvelo = 0.\n\n\n # y dim\n if ypos < walls.left: # too left\n crash = True\n ypos = walls.left + teleport_distance\n if self.collision_type == 'elastic':\n yvelo *= -1.\n elif self.collision_type == 'part_elastic':\n yvelo *= -self.restitution_coeff\n elif self.collision_type == \"crash\":\n yvelo = 0.\n\n if ypos > walls.right: # too far right\n crash = True\n ypos = walls.right - teleport_distance\n if self.collision_type == 'elastic':\n yvelo *= -1.\n elif self.collision_type == 'part_elastic':\n yvelo *= -self.restitution_coeff\n elif self.collision_type == 'crash':\n yvelo = 0.\n\n # z dim\n if zpos > walls.ceiling: # too far above\n crash = True\n zpos = walls.ceiling - teleport_distance\n if self.collision_type == 'elastic':\n zvelo *= -1.\n elif self.collision_type == 'part_elastic':\n zvelo *= -self.restitution_coeff\n elif self.collision_type == \"crash\":\n zvelo = 0.\n if zpos < walls.floor: # too far below\n crash = True\n zpos = walls.floor + teleport_distance\n if self.collision_type == 'elastic':\n zvelo *= -1.\n elif self.collision_type == 'part_elastic':\n zvelo *= -self.restitution_coeff\n elif self.collision_type == 'crash':\n zvelo = 0.\n\n try:\n candidate_pos, candidate_velo = np.array([xpos, ypos, zpos]), np.array([xvelo, yvelo, zvelo])\n except:\n print \" cand velo\", [xvelo, yvelo, zvelo], \"before\", candidate_velo\n\n\n return candidate_pos, candidate_velo\n\n def _initialize_vector_dict(self):\n \"\"\"\n initialize np arrays, store in dictionary\n \"\"\"\n V = {}\n\n for name in self.kinematics_list + self.forces_list:\n V[name] = np.full((self.max_bins, 3), np.nan)\n\n V['tsi'] = np.arange(self.max_bins)\n V['times'] = np.linspace(0, self.time_max, self.max_bins)\n V['in_plume'] = np.zeros(self.max_bins, dtype=bool)\n V['heat_signal'] = np.array([None] * self.max_bins)\n V['decision'] = np.array([None] * self.max_bins)\n\n return V\n\n def _set_init_velocity(self):\n initial_velocity_norm = np.random.normal(self.initial_velocity_mu, self.initial_velocity_stdev, 1)\n\n unit_vector = generate_random_unit_vector()\n velocity_vec = initial_velocity_norm * unit_vector\n\n return velocity_vec\n\n def _set_init_position(self):\n ''' puts the agent in an initial position, usually within the bounds of the\n cage\n\n Options: [the cage] door, or anywhere in the plane at x=.1 meters\n\n set initial velocity from fitted distribution\n '''\n\n # generate random intial velocity condition using normal distribution fitted to experimental data\n if self.initial_position_selection == 'realistic':\n \"\"\"these were calculated by taking selecting the initial positions of all observed trajectories in all\n conditions. Then, for each dimension, I calculated the distance of each initial position to the nearest wall\n in that dimension (i.e. for each z I calculated the distance to the floor and ceiling and selected\n the smallest distance. Then, Decisions aand\"\"\"\n downwind, upwind, left, right, floor, ceiling = self.boundary\n x_avg_dist_to_wall = 0.268\n y_avg_dist_to_wall = 0.044\n z_avg_dist_to_wall = 0.049\n x = choose([(downwind + x_avg_dist_to_wall), (upwind - x_avg_dist_to_wall)])\n y = choose([left + y_avg_dist_to_wall, (right - y_avg_dist_to_wall)])\n z = ceiling - z_avg_dist_to_wall\n initial_position = np.array([x,y,z])\n elif self.initial_position_selection == 'downwind_high':\n initial_position = np.array(\n [0.05, np.random.uniform(-0.127, 0.127), 0.2373]) # 0.2373 is mode of z pos distribution\n elif type(self.initial_position_selection) is list:\n initial_position = np.array(self.initial_position_selection)\n elif self.initial_position_selection == \"door\": # start trajectories as they exit the front door\n initial_position = np.array([0.1909, np.random.uniform(-0.0381, 0.0381), np.random.uniform(0., 0.1016)])\n # FIXME cage is actually suspending above floor\n elif self.initial_position_selection == 'downwind_plane':\n initial_position = np.array([0.1, np.random.uniform(-0.127, 0.127), np.random.uniform(0., 0.254)])\n else:\n raise Exception('invalid agent position specified: {}'.format(self.initial_position_selection))\n\n return initial_position\n\n def _velocity_ceiling(self, candidate_velo):\n \"\"\"check if we're seeing enormous velocities, which sometimes happens when running the optimization\n algoirithm. if so, cap the velocity instead of landing. this allows the optimizer to keep running.\n \"\"\"\n for i, velo in enumerate(candidate_velo):\n if velo > 20:\n candidate_velo[i] = 20.\n elif velo < -20:\n candidate_velo[i] = -20.\n\n return candidate_velo\n\n def _fix_vector_dict(self, dct):\n # prepare dict for loading into pandas (dataframe only accepts 1D vectors)\n # split xyz dicts into separate x, y, z vectors for dataframe\n\n fixed_dct = {}\n for kinematic in self.kinematics_list + self.forces_list:\n fixed_dct[kinematic + '_x'], fixed_dct[kinematic + '_y'], fixed_dct[kinematic + '_z'] = np.split(\n dct[kinematic], 3, axis=1)\n\n # migrate rest of dict\n for v in self.other_list:\n fixed_dct[v] = dct[v]\n\n # fix pandas bug when trying to load (R,1) arrays when it expects (R,) arrays\n for key, dct in fixed_dct.iteritems():\n fixed_dct[key] = fixed_dct[key].reshape(len(dct))\n if fixed_dct[key].size == 0:\n fixed_dct[key] = np.array([0.]) # hack so that kde calculation doesn't freeze on empty arrays\n\n return fixed_dct", "meta": {"hexsha": "8dc88ac8614c652f6749f58e54189e67c3ae008a", "size": 15206, "ext": "py", "lang": "Python", "max_stars_repo_path": "roboskeeter/simulator.py", "max_stars_repo_name": "crypdick/RoboSkeeter", "max_stars_repo_head_hexsha": "c905a69c4f7ecf1e1c3e950f36200610a903b6a5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "roboskeeter/simulator.py", "max_issues_repo_name": "crypdick/RoboSkeeter", "max_issues_repo_head_hexsha": "c905a69c4f7ecf1e1c3e950f36200610a903b6a5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "roboskeeter/simulator.py", "max_forks_repo_name": "crypdick/RoboSkeeter", "max_forks_repo_head_hexsha": "c905a69c4f7ecf1e1c3e950f36200610a903b6a5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.4414893617, "max_line_length": 126, "alphanum_fraction": 0.5897671972, "include": true, "reason": "import numpy", "num_tokens": 3454, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.523420348936324, "lm_q2_score": 0.36296919173767833, "lm_q1q2_score": 0.1899854609924711}} {"text": "import pdb # noqa: F401\n\nimport numpy as np\nimport cupy as cp\nimport scipy.signal as scsig\n\nimport os\nfrom os import path\nimport time\nfrom glob import glob\nimport deepdish as dd\n\nfrom typing import Tuple, NamedTuple, TypeVar, List\n\nimport soundfile as sf\n\nimport multiprocessing as mp\nimport logging # noqa: F401\n\nN_CUDA_DEV = 4\nNDArray = TypeVar('NDArray', np.ndarray, cp.ndarray)\n\n\ndef search_all_files(DIR_WAVFILE: str, ID: str) -> List[str]:\n result = []\n for folder, _, _ in os.walk(DIR_WAVFILE):\n files = glob(path.join(folder, ID))\n if not files:\n continue\n result += files\n\n return result\n\n\nclass SFTData(NamedTuple):\n \"\"\"\n Constant Matrices/Vectors for Spherical Fourier Analysis\n \"\"\"\n bEQspec: NDArray\n Yenc: NDArray\n Wnv: NDArray\n Wpv: NDArray\n Vv: NDArray\n\n def get_triags(self) -> Tuple:\n return (self.Wnv, self.Wpv, self.Vv)\n\n\nclass PreProcessor:\n def __init__(self, RIRs: np.ndarray, Ys: np.ndarray, sftdata: SFTData,\n L_WIN_MS=20., RIRs_0: np.ndarray=None):\n # Bug Fix\n np.fft.restore_all()\n # From Parameters\n self.RIRs = RIRs\n self.N_LOC, self.N_MIC, self.L_RIR = RIRs.shape\n self.Ys = Ys\n self.RIRs_0 = RIRs_0\n self.sftdata = sftdata\n\n self.L_WIN_MS = L_WIN_MS\n\n # Determined during process\n self.DIR_IV = ''\n self.all_files = []\n\n # Common for all wave file\n self.Fs = 0\n self.N_wavfile = 0\n self.N_fft = 0\n self.N_freq = 0\n self.L_frame = 0\n self.L_hop = 0\n self.win = None\n\n def process(self, DIR_WAVFILE: str, ID: str, idx_start: int,\n DIR_IV: str, FORM: str, N_CORES=mp.cpu_count()//4):\n if not path.exists(DIR_IV):\n os.makedirs(DIR_IV)\n self.DIR_IV = DIR_IV\n\n if self.N_LOC < mp.cpu_count():\n N_CORES = self.N_LOC\n n_loc_per_core = int(np.ceil(self.N_LOC//N_CORES))\n\n max_n_pool = 1\n while max_n_pool*int(np.ceil(n_loc_per_core*N_CORES/N_CUDA_DEV)) < 30:\n max_n_pool += 1\n max_n_pool -= 1\n\n print(f'Start processing from the {idx_start}-th wave file')\n\n # Search all wave files\n # self.all_files = search_all_files(DIR_WAVFILE, ID)\n self.Fs = 16000\n data = np.random.normal(size=(16000*10))\n self.L_frame = int(self.Fs*self.L_WIN_MS//1000)\n self.N_fft = self.L_frame\n if self.N_fft % 2 == 0:\n self.N_freq = self.N_fft//2 + 1\n else:\n self.N_freq = self.N_fft//2\n self.L_hop = self.L_frame//2\n\n self.win = scsig.hamming(self.L_frame, sym=False)\n\n pdb.set_trace()\n # Main Process\n for i_proc in range(N_CORES):\n if (i_proc + 1) * n_loc_per_core <= self.N_LOC:\n range_loc = range(i_proc * n_loc_per_core,\n (i_proc+1) * n_loc_per_core)\n elif i_proc * n_loc_per_core < self.N_LOC:\n range_loc = range(i_proc * n_loc_per_core, self.N_LOC)\n else:\n break\n self.save_IV(i_proc % N_CUDA_DEV,\n data,\n range_loc,\n FORM, self.N_wavfile+1)\n\n def save_IV(self, i_dev: int, data: NDArray, range_loc: iter,\n FORM: str, *args):\n \"\"\"\n Save IV files.\n\n i_dev: GPU Device No.\n range_loc: RIR Index Range(S/M Location Index Range)\n FORM: format of filename\n args: format string arguments\n\n return: None\n \"\"\"\n # CUDA Ready\n cp.cuda.Device(i_dev).use()\n data = cp.array(data)\n win = cp.array(self.win)\n Ys = cp.array(self.Ys)\n sftdata = SFTData(*[cp.array(item) for item in self.sftdata])\n\n N_frame_free = data.shape[0]//self.L_hop - 1\n N_frame_room = (data.shape[0]+self.L_RIR-1)//self.L_hop - 1\n\n for i_loc in range_loc:\n # RIR Filtering\n data_0 \\\n = cp.array(scsig.fftconvolve(cp.asnumpy(data.reshape(1, -1)),\n self.RIRs_0[i_loc]))\n\n # using 0-th Order RIR\n iv_0 = cp.zeros((self.N_freq, N_frame_room, 16), dtype=complex)\n for i_frame in range(N_frame_room):\n interval = i_frame*self.L_hop + np.arange(self.L_frame)\n fft = cp.fft.fft(data_0[:, interval]*win, n=self.N_fft)\n anm = (sftdata.Yenc @ fft) * sftdata.bEQspec\n\n iv_0[:, i_frame, :] = anm[:, :self.N_freq].T\n\n # Free-field Intensity Vector Image\n iv_free = cp.zeros((self.N_freq, N_frame_free, 16), dtype=complex)\n for i_frame in range(N_frame_free):\n interval = i_frame*self.L_hop + np.arange(self.L_frame)\n fft = cp.fft.fft(data[interval]*win, n=self.N_fft)\n anm = cp.outer(Ys[i_loc].conj(), fft)\n\n iv_free[:, i_frame, :] = anm[:, :self.N_freq].T\n\n # Save\n dict_to_save = {'IV_free': cp.asnumpy(iv_free),\n # 'IV_room': cp.asnumpy(iv_room),\n 'IV_0': cp.asnumpy(iv_0),\n # 'data': cp.asnumpy(data),\n # 'norm_factor_free': norm_factor_free,\n # 'norm_factor_room': norm_factor_room,\n }\n FNAME = FORM % (*args, i_loc)\n dd.io.save(path.join(self.DIR_IV, FNAME),\n dict_to_save,\n compression=None)\n\n print(FORM % (*args, i_loc))\n\n def __str__(self):\n return ('Wave Files Processed/Total: '\n f'{self.N_wavfile}/{len(self.all_files)}\\n'\n f'Sample Rate: {self.Fs}\\n'\n f'Number of source location: {self.N_LOC}\\n'\n )\n\n def print_save_info(self):\n \"\"\"\n Print __str__ and save metadata.\n \"\"\"\n print(self)\n\n metadata = {'N_wavfile': self.N_wavfile,\n 'Fs': self.Fs,\n # 'N_fft': self.N_fft,\n 'N_freq': self.N_freq,\n 'L_frame': self.L_frame,\n 'L_hop': self.L_hop,\n 'N_LOC': self.N_LOC,\n 'path_wavfiles': self.all_files,\n }\n\n dd.io.save(path.join(self.DIR_IV, 'metadata.h5'), metadata)\n\n @staticmethod\n def seltriag(Ain: NDArray, nrord: int, shft: Tuple[int, int]) -> NDArray:\n xp = cp.get_array_module(Ain)\n N_freq = 1 if Ain.ndim == 1 else Ain.shape[1]\n N = int(np.ceil(np.sqrt(Ain.shape[0]))-1)\n idx = 0\n len_new = (N-nrord+1)**2\n\n Aout = xp.zeros((len_new, N_freq), dtype=Ain.dtype)\n for ii in range(N-nrord+1):\n for jj in range(-ii, ii+1):\n n = shft[0] + ii\n m = shft[1] + jj\n idx_from = m + n*(n+1)\n if -n <= m and m <= n and 0 <= n and n <= N \\\n and idx_from < Ain.shape[0]:\n Aout[idx] = Ain[idx_from]\n idx += 1\n return Aout\n\n @classmethod\n def calc_intensity(cls, Asv: NDArray,\n Wnv: NDArray, Wpv: NDArray, Vv: NDArray) -> NDArray:\n \"\"\"\n Asv(anm) -> IV\n \"\"\"\n xp = cp.get_array_module(Asv)\n\n aug1 = cls.seltriag(Asv, 1, (0, 0))\n aug2 = cls.seltriag(Wpv, 1, (1, -1))*cls.seltriag(Asv, 1, (1, -1)) \\\n - cls.seltriag(Wnv, 1, (0, 0))*cls.seltriag(Asv, 1, (-1, -1))\n aug3 = cls.seltriag(Wpv, 1, (0, 0))*cls.seltriag(Asv, 1, (-1, 1)) \\\n - cls.seltriag(Wnv, 1, (1, 1))*cls.seltriag(Asv, 1, (1, 1))\n aug4 = cls.seltriag(Vv, 1, (0, 0))*cls.seltriag(Asv, 1, (-1, 0)) \\\n + cls.seltriag(Vv, 1, (1, 0))*cls.seltriag(Asv, 1, (1, 0))\n\n dx = (aug1.conj()*(aug2+aug3)/2).sum(axis=0)\n dy = (aug1.conj()*(aug2-aug3)/2j).sum(axis=0)\n dz = (aug1.conj()*aug4).sum(axis=0)\n\n return 0.5*xp.real(xp.stack((dx, dy, dz), axis=1))\n\n\nif __name__ == '__main__':\n pass\n", "meta": {"hexsha": "207f3186a394aa5c41bc0599eb6624482a1c8446", "size": 8207, "ext": "py", "lang": "Python", "max_stars_repo_path": "pre_processing_anm_check.py", "max_stars_repo_name": "WXB506/De-reverberation", "max_stars_repo_head_hexsha": "c0913d2a8804aa5176615e61d3b8956456bc51d4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "pre_processing_anm_check.py", "max_issues_repo_name": "WXB506/De-reverberation", "max_issues_repo_head_hexsha": "c0913d2a8804aa5176615e61d3b8956456bc51d4", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pre_processing_anm_check.py", "max_forks_repo_name": "WXB506/De-reverberation", "max_forks_repo_head_hexsha": "c0913d2a8804aa5176615e61d3b8956456bc51d4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-11-27T08:03:56.000Z", "max_forks_repo_forks_event_max_datetime": "2020-11-27T08:03:56.000Z", "avg_line_length": 32.4387351779, "max_line_length": 78, "alphanum_fraction": 0.5201657122, "include": true, "reason": "import numpy,import scipy,import cupy", "num_tokens": 2303, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.523420348936324, "lm_q2_score": 0.3629691917376783, "lm_q1q2_score": 0.18998546099247107}} {"text": "# Licensed under a 3-clause BSD style license - see LICENSE.rst\nimport logging\nimport numpy as np\nfrom itertools import combinations\nfrom astropy.coordinates import Angle, SkyOffsetFrame\nfrom astropy.table import Table\nimport astropy.units as u\nfrom gammapy.irf import EDispMap, PSFMap, FoVAlignment\nfrom gammapy.maps import Map, RegionGeom, RegionNDMap\nfrom gammapy.modeling.models import PowerLawSpectralModel\nfrom gammapy.stats import WStatCountsStatistic\nfrom gammapy.utils.coordinates import sky_to_fov\n\n\n__all__ = [\n \"make_counts_rad_max\",\n \"make_edisp_kernel_map\",\n \"make_edisp_map\",\n \"make_map_background_irf\",\n \"make_map_exposure_true_energy\",\n \"make_psf_map\",\n \"make_theta_squared_table\",\n]\n\nlog = logging.getLogger(__name__)\n\n\ndef make_map_exposure_true_energy(\n pointing, livetime, aeff, geom, use_region_center=True\n):\n \"\"\"Compute exposure map.\n\n This map has a true energy axis, the exposure is not combined\n with energy dispersion.\n\n Parameters\n ----------\n pointing : `~astropy.coordinates.SkyCoord`\n Pointing direction\n livetime : `~astropy.units.Quantity`\n Livetime\n aeff : `~gammapy.irf.EffectiveAreaTable2D`\n Effective area\n geom : `~gammapy.maps.WcsGeom`\n Map geometry (must have an energy axis)\n use_region_center: bool\n If geom is a RegionGeom, whether to just\n consider the values at the region center\n or the instead the average over the whole region\n\n Returns\n -------\n map : `~gammapy.maps.WcsNDMap`\n Exposure map\n \"\"\"\n if not use_region_center:\n coords, weights = geom.get_wcs_coord_and_weights()\n else:\n coords, weights = geom.get_coord(sparse=True), None\n\n offset = coords.skycoord.separation(pointing)\n exposure = aeff.evaluate(offset=offset, energy_true=coords[\"energy_true\"])\n\n data = (exposure * livetime).to(\"m2 s\")\n meta = {\"livetime\": livetime, \"is_pointlike\": aeff.is_pointlike}\n\n if not use_region_center:\n data = np.average(data, axis=1, weights=weights)\n\n return Map.from_geom(geom=geom, data=data.value, unit=data.unit, meta=meta)\n\n\ndef _map_spectrum_weight(map, spectrum=None):\n \"\"\"Weight a map with a spectrum.\n\n This requires map to have an \"energy\" axis.\n The weights are normalised so that they sum to 1.\n The mean and unit of the output image is the same as of the input cube.\n\n At the moment this is used to get a weighted exposure image.\n\n Parameters\n ----------\n map : `~gammapy.maps.Map`\n Input map with an \"energy\" axis.\n spectrum : `~gammapy.modeling.models.SpectralModel`\n Spectral model to compute the weights.\n Default is power-law with spectral index of 2.\n\n Returns\n -------\n map_weighted : `~gammapy.maps.Map`\n Weighted image\n \"\"\"\n if spectrum is None:\n spectrum = PowerLawSpectralModel(index=2.0)\n\n # Compute weights vector\n energy_edges = map.geom.axes[\"energy_true\"].edges\n weights = spectrum.integral(\n energy_min=energy_edges[:-1], energy_max=energy_edges[1:]\n )\n weights /= weights.sum()\n shape = np.ones(len(map.geom.data_shape))\n shape[0] = -1\n return map * weights.reshape(shape.astype(int))\n\n\ndef make_map_background_irf(\n pointing, ontime, bkg, geom, oversampling=None, use_region_center=True\n):\n \"\"\"Compute background map from background IRFs.\n\n Parameters\n ----------\n pointing : `~gammapy.data.FixedPointingInfo` or `~astropy.coordinates.SkyCoord`\n Observation pointing\n\n - If a `~gammapy.data.FixedPointingInfo` is passed, FOV coordinates are properly computed.\n - If a `~astropy.coordinates.SkyCoord` is passed, FOV frame rotation is not taken into account.\n ontime : `~astropy.units.Quantity`\n Observation ontime. i.e. not corrected for deadtime\n see https://gamma-astro-data-formats.readthedocs.io/en/stable/irfs/full_enclosure/bkg/index.html#notes)\n bkg : `~gammapy.irf.Background3D`\n Background rate model\n geom : `~gammapy.maps.WcsGeom`\n Reference geometry\n oversampling: int\n Oversampling factor in energy, used for the background model evaluation.\n use_region_center: bool\n If geom is a RegionGeom, whether to just\n consider the values at the region center\n or the instead the sum over the whole region\n\n Returns\n -------\n background : `~gammapy.maps.WcsNDMap`\n Background predicted counts sky cube in reco energy\n \"\"\"\n # TODO:\n # This implementation can be improved in two ways:\n # 1. Create equal time intervals between TSTART and TSTOP and sum up the\n # background IRF for each interval. This is instead of multiplying by\n # the total ontime. This then handles the rotation of the FoV.\n # 2. Use the pointing table (does not currently exist in CTA files) to\n # obtain the RA DEC and time for each interval. This then considers that\n # the pointing might change slightly over the observation duration\n\n # Get altaz coords for map\n if oversampling is not None:\n geom = geom.upsample(factor=oversampling, axis_name=\"energy\")\n\n coords = {\"energy\": geom.axes[\"energy\"].edges.reshape((-1, 1, 1))}\n\n if not use_region_center:\n image_geom = geom.to_wcs_geom().to_image()\n region_coord, weights = geom.get_wcs_coord_and_weights()\n idx = image_geom.coord_to_idx(region_coord)\n sky_coord = region_coord.skycoord\n d_omega = image_geom.solid_angle().T[idx]\n else:\n image_geom = geom.to_image()\n map_coord = image_geom.get_coord()\n sky_coord = map_coord.skycoord\n d_omega = image_geom.solid_angle()\n\n if bkg.has_offset_axis:\n coords[\"offset\"] = sky_coord.separation(pointing)\n else:\n if bkg.fov_alignment == FoVAlignment.ALTAZ:\n altaz_coord = sky_coord.transform_to(pointing.altaz_frame)\n\n # Compute FOV coordinates of map relative to pointing\n fov_lon, fov_lat = sky_to_fov(\n altaz_coord.az, altaz_coord.alt, pointing.altaz.az, pointing.altaz.alt\n )\n elif bkg.fov_alignment == FoVAlignment.RADEC:\n # Create OffsetFrame\n frame = SkyOffsetFrame(origin=pointing.radec)\n pseudo_fov_coord = sky_coord.transform_to(frame)\n fov_lon = pseudo_fov_coord.lon\n fov_lat = pseudo_fov_coord.lat\n else:\n raise ValueError(\n f\"Unsupported background coordinate system: {bkg.fov_alignment!r}\"\n )\n\n coords[\"fov_lon\"] = fov_lon\n coords[\"fov_lat\"] = fov_lat\n\n bkg_de = bkg.integrate_log_log(**coords, axis_name=\"energy\")\n data = (bkg_de * d_omega * ontime).to_value(\"\")\n\n if not use_region_center:\n data = np.sum(weights * data, axis=2)\n\n bkg_map = Map.from_geom(geom, data=data)\n\n if oversampling is not None:\n bkg_map = bkg_map.downsample(factor=oversampling, axis_name=\"energy\")\n\n return bkg_map\n\n\ndef make_psf_map(psf, pointing, geom, exposure_map=None):\n \"\"\"Make a psf map for a single observation\n\n Expected axes : rad and true energy in this specific order\n The name of the rad MapAxis is expected to be 'rad'\n\n Parameters\n ----------\n psf : `~gammapy.irf.PSF3D`\n the PSF IRF\n pointing : `~astropy.coordinates.SkyCoord`\n the pointing direction\n geom : `~gammapy.maps.Geom`\n the map geom to be used. It provides the target geometry.\n rad and true energy axes should be given in this specific order.\n exposure_map : `~gammapy.maps.Map`, optional\n the associated exposure map.\n default is None\n\n Returns\n -------\n psfmap : `~gammapy.irf.PSFMap`\n the resulting PSF map\n \"\"\"\n coords = geom.get_coord(sparse=True)\n\n # Compute separations with pointing position\n offset = coords.skycoord.separation(pointing)\n\n # Compute PSF values\n data = psf.evaluate(\n energy_true=coords[\"energy_true\"],\n offset=offset,\n rad=coords[\"rad\"],\n )\n\n # Create Map and fill relevant entries\n psf_map = Map.from_geom(geom, data=data.value, unit=data.unit)\n psf_map.normalize(axis_name=\"rad\")\n return PSFMap(psf_map, exposure_map)\n\n\ndef make_edisp_map(edisp, pointing, geom, exposure_map=None, use_region_center=True):\n \"\"\"Make a edisp map for a single observation\n\n Expected axes : migra and true energy in this specific order\n The name of the migra MapAxis is expected to be 'migra'\n\n Parameters\n ----------\n edisp : `~gammapy.irf.EnergyDispersion2D`\n the 2D Energy Dispersion IRF\n pointing : `~astropy.coordinates.SkyCoord`\n the pointing direction\n geom : `~gammapy.maps.Geom`\n the map geom to be used. It provides the target geometry.\n migra and true energy axes should be given in this specific order.\n exposure_map : `~gammapy.maps.Map`, optional\n the associated exposure map.\n default is None\n use_region_center: Bool\n If geom is a RegionGeom, whether to just\n consider the values at the region center\n or the instead the average over the whole region\n\n Returns\n -------\n edispmap : `~gammapy.irf.EDispMap`\n the resulting EDisp map\n \"\"\"\n # Compute separations with pointing position\n if not use_region_center:\n coords, weights = geom.get_wcs_coord_and_weights()\n else:\n coords, weights = geom.get_coord(sparse=True), None\n\n offset = coords.skycoord.separation(pointing)\n\n # Compute EDisp values\n data = edisp.evaluate(\n offset=offset,\n energy_true=coords[\"energy_true\"],\n migra=coords[\"migra\"],\n )\n\n if not use_region_center:\n data = np.average(data, axis=2, weights=weights)\n\n # Create Map and fill relevant entries\n edisp_map = Map.from_geom(geom, data=data.to_value(\"\"), unit=\"\")\n edisp_map.normalize(axis_name=\"migra\")\n return EDispMap(edisp_map, exposure_map)\n\n\ndef make_edisp_kernel_map(\n edisp, pointing, geom, exposure_map=None, use_region_center=True\n):\n \"\"\"Make a edisp kernel map for a single observation\n\n Expected axes : (reco) energy and true energy in this specific order\n The name of the reco energy MapAxis is expected to be 'energy'.\n The name of the true energy MapAxis is expected to be 'energy_true'.\n\n Parameters\n ----------\n edisp : `~gammapy.irf.EnergyDispersion2D`\n the 2D Energy Dispersion IRF\n pointing : `~astropy.coordinates.SkyCoord`\n the pointing direction\n geom : `~gammapy.maps.Geom`\n the map geom to be used. It provides the target geometry.\n energy and true energy axes should be given in this specific order.\n exposure_map : `~gammapy.maps.Map`, optional\n the associated exposure map.\n default is None\n use_region_center: Bool\n If geom is a RegionGeom, whether to just\n consider the values at the region center\n or the instead the average over the whole region\n\n Returns\n -------\n edispmap : `~gammapy.irf.EDispKernelMap`\n the resulting EDispKernel map\n \"\"\"\n # Use EnergyDispersion2D migra axis.\n migra_axis = edisp.axes[\"migra\"]\n\n # Create temporary EDispMap Geom\n new_geom = geom.to_image().to_cube([migra_axis, geom.axes[\"energy_true\"]])\n\n edisp_map = make_edisp_map(\n edisp, pointing, new_geom, exposure_map, use_region_center\n )\n\n return edisp_map.to_edisp_kernel_map(geom.axes[\"energy\"])\n\n\ndef make_theta_squared_table(\n observations, theta_squared_axis, position, position_off=None\n):\n \"\"\"Make theta squared distribution in the same FoV for a list of `Observation`\n objects.\n\n The ON theta2 profile is computed from a given distribution, on_position.\n By default, the OFF theta2 profile is extracted from a mirror position\n radially symmetric in the FOV to pos_on.\n\n The ON and OFF regions are assumed to be of the same size, so the normalisation\n factor between both region alpha = 1.\n\n Parameters\n ----------\n observations: `~gammapy.data.Observations`\n List of observations\n theta_squared_axis : `~gammapy.maps.geom.MapAxis`\n Axis of edges of the theta2 bin used to compute the distribution\n position : `~astropy.coordinates.SkyCoord`\n Position from which the on theta^2 distribution is computed\n position_off : `astropy.coordinates.SkyCoord`\n Position from which the OFF theta^2 distribution is computed.\n Default: reflected position w.r.t. to the pointing position\n\n Returns\n -------\n table : `~astropy.table.Table`\n Table containing the on counts, the off counts, acceptance, off acceptance and alpha\n for each theta squared bin.\n \"\"\"\n if not theta_squared_axis.edges.unit.is_equivalent(\"deg2\"):\n raise ValueError(\"The theta2 axis should be equivalent to deg2\")\n\n table = Table()\n\n table[\"theta2_min\"] = theta_squared_axis.edges[:-1]\n table[\"theta2_max\"] = theta_squared_axis.edges[1:]\n table[\"counts\"] = 0\n table[\"counts_off\"] = 0\n table[\"acceptance\"] = 0.0\n table[\"acceptance_off\"] = 0.0\n\n alpha_tot = np.zeros(len(table))\n livetime_tot = 0\n\n create_off = position_off is None\n for observation in observations:\n separation = position.separation(observation.events.radec)\n counts, _ = np.histogram(separation ** 2, theta_squared_axis.edges)\n table[\"counts\"] += counts\n\n if create_off:\n # Estimate the position of the mirror position\n pos_angle = observation.pointing_radec.position_angle(position)\n sep_angle = observation.pointing_radec.separation(position)\n position_off = observation.pointing_radec.directional_offset_by(\n pos_angle + Angle(np.pi, \"rad\"), sep_angle\n )\n\n # Angular distance of the events from the mirror position\n separation_off = position_off.separation(observation.events.radec)\n\n # Extract the ON and OFF theta2 distribution from the two positions.\n counts_off, _ = np.histogram(separation_off ** 2, theta_squared_axis.edges)\n table[\"counts_off\"] += counts_off\n\n # Normalisation between ON and OFF is one\n acceptance = np.ones(theta_squared_axis.nbin)\n acceptance_off = np.ones(theta_squared_axis.nbin)\n\n table[\"acceptance\"] += acceptance\n table[\"acceptance_off\"] += acceptance_off\n alpha = acceptance / acceptance_off\n alpha_tot += alpha * observation.observation_live_time_duration.to_value(\"s\")\n livetime_tot += observation.observation_live_time_duration.to_value(\"s\")\n\n alpha_tot /= livetime_tot\n table[\"alpha\"] = alpha_tot\n\n stat = WStatCountsStatistic(table[\"counts\"], table[\"counts_off\"], table[\"alpha\"])\n table[\"excess\"] = stat.n_sig\n table[\"sqrt_ts\"] = stat.sqrt_ts\n table[\"excess_errn\"] = stat.compute_errn()\n table[\"excess_errp\"] = stat.compute_errp()\n\n table.meta[\"ON_RA\"] = position.icrs.ra\n table.meta[\"ON_DEC\"] = position.icrs.dec\n return table\n\n\ndef make_counts_rad_max(geom, rad_max, events):\n \"\"\"Extract the counts using for the ON region size the values in the\n `RAD_MAX_2D` table.\n\n Parameters\n ----------\n geom : `~gammapy.maps.RegionGeom`\n reference map geom\n rad_max : `~gammapy.irf.RadMax2D`\n the RAD_MAX_2D table IRF\n events : `~gammapy.data.EventList`\n event list to be used to compute the ON counts\n\n Returns\n -------\n counts : `~gammapy.maps.RegionNDMap`\n Counts vs estimated energy extracted from the ON region.\n \"\"\"\n selected_events = events.select_rad_max(\n rad_max=rad_max, position=geom.region.center\n )\n\n counts = Map.from_geom(geom=geom)\n counts.fill_events(selected_events)\n return counts\n\n\ndef are_regions_overlapping_rad_max(regions, rad_max, offset, e_min, e_max):\n \"\"\"\n Calculate pair-wise separations between all regions and compare with rad_max\n to find overlaps.\n \"\"\"\n separations = u.Quantity([\n a.center.separation(b.center)\n for a, b in combinations(regions, 2)\n ])\n\n rad_max_at_offset = rad_max.evaluate(offset=offset)\n # do not check bins outside of energy range\n edges_min = rad_max.axes['energy'].edges_min\n edges_max = rad_max.axes['energy'].edges_max\n # to be sure all possible values are included, we check\n # for the *upper* energy bin to be larger than e_min and the *lower* edge\n # to be larger than e_max\n mask = (edges_max >= e_min) & (edges_min <= e_max)\n rad_max_at_offset = rad_max_at_offset[mask]\n\n return np.any(separations[np.newaxis, :] < (2 * rad_max_at_offset))\n\n\ndef make_counts_off_rad_max(\n on_geom,\n rad_max,\n events,\n region_finder,\n exclusion_mask=None,\n):\n \"\"\"Extract the OFF counts and the ON / OFF acceptance considering for the\n sizes of the ON and OFF regions the values in the `RAD_MAX_2D` table.\n Per each estimated energy bin a `ReflectedRegionsFinder` is defined to\n search for the OFF regions.\n\n Parameters\n ----------\n geom: `~gammapy.maps.RegionGeom`\n reference map geom for the on region\n rad_max: `~gammapy.irf.RadMax2D`\n the RAD_MAX_2D table IRF\n events: `~gammapy.data.EventList`\n event list to be used to compute the OFF counts\n region_finder: `~gammapy.makers.background.reflected.RegionFinder`\n\n Returns\n -------\n counts_off : `~gammapy.maps.RegionNDMap`\n OFF Counts vs estimated energy extracted from the ON region.\n acceptance_off : `~gammapy.maps.RegionNDMap`\n ratio of the acceptances of the OFF to ON regions.\n \"\"\"\n\n off_regions, wcs = region_finder.run(\n center=events.pointing_radec,\n region=on_geom.region,\n exclusion_mask=exclusion_mask,\n )\n\n if len(off_regions) == 0:\n log.warning(\"RegionsFinder returned no regions\")\n # counts_off=None, acceptance_off=0\n return None, RegionNDMap.from_geom(on_geom, data=0)\n\n\n # check for overlap\n energy_axis = on_geom.axes[\"energy\"]\n offset = on_geom.region.center.separation(events.pointing_radec)\n e_min, e_max = energy_axis.edges[[0, -1]]\n regions = [on_geom.region] + off_regions\n if are_regions_overlapping_rad_max(regions, rad_max, offset, e_min, e_max):\n log.warning(\"Found overlapping on/off regions, choose less off regions\")\n # counts_off=None, acceptance_off=0\n return None, RegionNDMap.from_geom(on_geom, data=0)\n\n off_region_geom = RegionGeom.from_regions(\n regions=off_regions,\n axes=[energy_axis],\n wcs=wcs,\n )\n\n counts_off = RegionNDMap.from_geom(geom=off_region_geom)\n acceptance_off = RegionNDMap.from_geom(\n geom=off_region_geom,\n data=np.full(energy_axis.nbin, len(off_regions))\n )\n\n for off_region in off_regions:\n selected_events = events.select_rad_max(\n rad_max=rad_max, position=off_region.center\n )\n counts_off.fill_events(selected_events)\n\n return counts_off, acceptance_off\n", "meta": {"hexsha": "166847246fa1f3023538d3875d37783a8af77b9a", "size": 19053, "ext": "py", "lang": "Python", "max_stars_repo_path": "gammapy/makers/utils.py", "max_stars_repo_name": "isu-veritas/gammapy", "max_stars_repo_head_hexsha": "715b041d7d3925bd51109dc9534634263a2f2d12", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "gammapy/makers/utils.py", "max_issues_repo_name": "isu-veritas/gammapy", "max_issues_repo_head_hexsha": "715b041d7d3925bd51109dc9534634263a2f2d12", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "gammapy/makers/utils.py", "max_forks_repo_name": "isu-veritas/gammapy", "max_forks_repo_head_hexsha": "715b041d7d3925bd51109dc9534634263a2f2d12", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.3297297297, "max_line_length": 111, "alphanum_fraction": 0.6792631082, "include": true, "reason": "import numpy,import astropy,from astropy", "num_tokens": 4622, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5736784074525096, "lm_q2_score": 0.331119752830196, "lm_q1q2_score": 0.18995625247969547}} {"text": "#!/usr/bin/env python\n\nfrom __future__ import division\nimport numpy as np\nimport scipy.spatial.distance as ssd\nimport h5py, sys\n\nimport pycuda.driver as drv\nimport pycuda.autoinit\nfrom pycuda import gpuarray\nfrom scikits.cuda import linalg\nlinalg.init()\n\nfrom tps import tps_kernel_matrix, tps_eval\nfrom transformations import unit_boxify\nfrom culinalg_exts import dot_batch_nocheck, get_gpu_ptrs, m_dot_batch\nfrom precompute import downsample_cloud, batch_get_sol_params\nfrom cuda_funcs import init_prob_nm, norm_prob_nm, get_targ_pts, check_cuda_err, \\\n fill_mat, reset_cuda, sq_diffs\nfrom registration import registration_cost as cpu_registration_cost\nfrom defaults import N_ITER_CHEAP, EM_ITER_CHEAP, DEFAULT_LAMBDA, MAX_CLD_SIZE, \\\n DATA_DIM, DS_SIZE, N_STREAMS, DEFAULT_NORM_ITERS, BEND_COEF_DIGITS\n\nimport IPython as ipy\nfrom pdb import pm, set_trace\nimport time\n\n\nclass Globals:\n sync = False\n streams = []\n for i in range(N_STREAMS):\n streams.append(drv.Stream())\n\ndef get_stream(i):\n return Globals.streams[i % N_STREAMS]\n\ndef sync(override = False):\n if Globals.sync or override:\n check_cuda_err()\n\ndef loglinspace(a,b,n):\n \"n numbers between a to b (inclusive) with constant ratio between consecutive numbers\"\n return np.exp(np.linspace(np.log(a),np.log(b),n)) \n\ndef gpu_pad(x, shape, dtype=np.float32):\n (m, n) = x.shape\n if m > shape[0] or n > shape[1]:\n raise ValueError(\"Cannot Pad Beyond Normal Dimension\")\n x_new = np.zeros(shape, dtype=dtype) \n x_new[:m, :n] = x\n return gpuarray.to_gpu(x_new)\n\nclass GPUContext(object):\n \"\"\"\n Class to contain GPU arrays\n \"\"\"\n def __init__(self, bend_coefs = None):\n if bend_coefs is None:\n lambda_init, lambda_final = DEFAULT_LAMBDA\n bend_coefs = np.around(loglinspace(lambda_init, lambda_final, N_ITER_CHEAP), \n BEND_COEF_DIGITS)\n self.bend_coefs = bend_coefs\n self.ptrs_valid = False\n self.N = 0\n\n self.tps_params = []\n self.tps_param_ptrs = None\n self.trans_d = []\n self.trans_d_ptrs = None\n self.lin_dd = []\n self.lin_dd_ptrs = None\n self.w_nd = []\n self.w_nd_ptrs = None\n self.ident_mats = [gpuarray.to_gpu(np.eye(MAX_CLD_SIZE, dtype=np.float32))]\n self.ident_ptrs = None\n \n \"\"\"\n TPS PARAM FORMAT\n [ np.zeros(DATA_DIM) ] [ trans_d ] [1 x d]\n [ np.eye(DATA_DIM) ] = [ lin_dd ] = [d x d]\n [np.zeros((np.zeros, DATA_DIM))] [ w_nd ] [n x d]\n \"\"\"\n self.default_tps_params = gpuarray.zeros((DATA_DIM + 1 + MAX_CLD_SIZE, DATA_DIM), np.float32)\n self.default_tps_params[1:DATA_DIM+1, :].set(np.eye(DATA_DIM, dtype=np.float32))\n\n self.proj_mats = dict([(b, []) for b in bend_coefs])\n self.proj_mat_ptrs = dict([(b, None) for b in bend_coefs])\n self.offset_mats = dict([(b, []) for b in bend_coefs])\n self.offset_mat_ptrs = dict([(b, None) for b in bend_coefs])\n\n self.pts = []\n self.pt_ptrs = None\n self.pt_t_pt = []\n self.pt_t_pt_ptrs = None\n self.kernels = []\n self.kernel_ptrs = None\n self.pts_w = []\n self.pt_w_ptrs = None\n self.pts_t = []\n self.pts_t_ptrs = None\n self.dims = []\n self.dims_gpu = None\n\n self.warp_err = None\n self.bend_res = []\n self_bend_res_ptrs = None\n\n self.corr_cm = []\n self.corr_cm_ptrs = None\n self.corr_rm = []\n self.corr_rm_ptrs = None\n self.r_coefs = []\n self.r_coef_ptrs = None\n self.c_coefs_rn = []\n self.c_coef_rn_ptrs = None\n self.c_coefs_cn = []\n self.c_coef_cn_ptrs = None\n self.seg_names = []\n\n def reset_tps_params(self):\n \"\"\"\n sets the tps params to be identity\n \"\"\"\n for p in self.tps_params:\n drv.memcpy_dtod_async(p.gpudata, self.default_tps_params.gpudata, p.nbytes) \n def set_tps_params(self, vals):\n for d, s in zip(self.tps_params, vals):\n drv.memcpy_dtod_async(d.gpudata, s.gpudata, d.nbytes) \n\n def reset_warp_err(self):\n self.warp_err.fill(0)\n\n def check_cld(self, cloud_xyz):\n if cloud_xyz.dtype != np.float32:\n raise TypeError(\"only single precision operations supported\")\n if cloud_xyz.shape[0] > MAX_CLD_SIZE:\n raise ValueError(\"cloud size exceeds {}\".format(MAX_CLD_SIZE))\n if cloud_xyz.shape[1] != DATA_DIM:\n raise ValueError(\"point cloud must have cumn dimension {}\".format(DATA_DIM))\n # @profile\n def get_sol_params(self, cld):\n self.check_cld(cld)\n K = tps_kernel_matrix(cld)\n proj_mats = {}\n offset_mats = {}\n (proj_mats_arr, _), (offset_mats_arr, _) = batch_get_sol_params(cld, K, self.bend_coefs)\n for i, b in enumerate(self.bend_coefs):\n proj_mats[b] = proj_mats_arr[i]\n offset_mats[b] = offset_mats_arr[i]\n return proj_mats, offset_mats, K\n\n def add_cld(self, name, proj_mats, offset_mats, cloud_xyz, kernel, update_ptrs = False):\n \"\"\"\n adds a new cloud to our context for batch processing\n \"\"\"\n self.check_cld(cloud_xyz)\n self.ptrs_valid = False\n self.N += 1\n self.seg_names.append(name)\n self.tps_params.append(self.default_tps_params.copy())\n self.trans_d.append(self.tps_params[-1][0, :])\n self.lin_dd.append(self.tps_params[-1][1:DATA_DIM+1, :])\n self.w_nd.append(self.tps_params[-1][DATA_DIM + 1:, :])\n n = cloud_xyz.shape[0]\n \n for b in self.bend_coefs:\n proj_mat = proj_mats[b]\n offset_mat = offset_mats[b]\n self.proj_mats[b].append(gpu_pad(proj_mat, (MAX_CLD_SIZE + DATA_DIM + 1, MAX_CLD_SIZE)))\n\n if offset_mat.shape != (n + DATA_DIM + 1, DATA_DIM):\n raise ValueError(\"Offset Matrix has incorrect dimension\")\n self.offset_mats[b].append(gpu_pad(offset_mat, (MAX_CLD_SIZE + DATA_DIM + 1, DATA_DIM)))\n\n\n if n > MAX_CLD_SIZE or cloud_xyz.shape[1] != DATA_DIM:\n raise ValueError(\"cloud_xyz has incorrect dimension\")\n self.pts.append(gpu_pad(cloud_xyz, (MAX_CLD_SIZE, DATA_DIM)))\n self.pt_t_pt.append(gpu_pad(cloud_xyz.T.dot(cloud_xyz), (MAX_CLD_SIZE, MAX_CLD_SIZE)))\n if kernel.shape != (n, n):\n raise ValueError(\"dimension mismatch b/t kernel and cloud\")\n self.kernels.append(gpu_pad(kernel, (MAX_CLD_SIZE, MAX_CLD_SIZE)))\n self.dims.append(n)\n\n self.pts_w.append(gpuarray.zeros_like(self.pts[-1]))\n self.pts_t.append(gpuarray.zeros_like(self.pts[-1]))\n self.corr_cm.append(gpuarray.zeros((MAX_CLD_SIZE, MAX_CLD_SIZE), np.float32))\n self.corr_rm.append(gpuarray.zeros((MAX_CLD_SIZE, MAX_CLD_SIZE), np.float32))\n self.r_coefs.append(gpuarray.zeros((MAX_CLD_SIZE, 1), np.float32))\n self.c_coefs_rn.append(gpuarray.zeros((MAX_CLD_SIZE, 1), np.float32))\n self.c_coefs_cn.append(gpuarray.zeros((MAX_CLD_SIZE, 1), np.float32))\n\n if update_ptrs:\n self.update_ptrs()\n\n def update_ptrs(self):\n self.tps_param_ptrs = get_gpu_ptrs(self.tps_params)\n self.trans_d_ptrs = get_gpu_ptrs(self.trans_d)\n self.lin_dd_ptrs = get_gpu_ptrs(self.lin_dd)\n self.w_nd_ptrs = get_gpu_ptrs(self.w_nd)\n \n for b in self.bend_coefs:\n self.proj_mat_ptrs[b] = get_gpu_ptrs(self.proj_mats[b])\n self.offset_mat_ptrs[b] = get_gpu_ptrs(self.offset_mats[b])\n\n self.pt_ptrs = get_gpu_ptrs(self.pts)\n self.pt_t_pt_ptrs = get_gpu_ptrs(self.pt_t_pt)\n self.kernel_ptrs = get_gpu_ptrs(self.kernels)\n self.ident_ptrs = get_gpu_ptrs([self.ident_mats[0] for _ in range(self.N)])\n self.pt_w_ptrs = get_gpu_ptrs(self.pts_w)\n self.pt_t_ptrs = get_gpu_ptrs(self.pts_t)\n self.corr_cm_ptrs = get_gpu_ptrs(self.corr_cm)\n self.corr_rm_ptrs = get_gpu_ptrs(self.corr_rm)\n self.r_coef_ptrs = get_gpu_ptrs(self.r_coefs)\n self.c_coef_rn_ptrs = get_gpu_ptrs(self.c_coefs_rn)\n self.c_coef_cn_ptrs = get_gpu_ptrs(self.c_coefs_cn)\n ## temporary space used for bend/warp cost computations\n self.warp_err = gpuarray.zeros((self.N, MAX_CLD_SIZE), np.float32)\n self.bend_res_mat = gpuarray.zeros((DATA_DIM * self.N, DATA_DIM), np.float32)\n self.bend_res =[self.bend_res_mat[i*DATA_DIM:(i+1)*DATA_DIM] for i in range(self.N)]\n self.bend_res_ptrs = get_gpu_ptrs(self.bend_res)\n \n self.dims_gpu = gpuarray.to_gpu(np.array(self.dims, dtype=np.int32))\n self.ptrs_valid = True\n\n def read_h5(self, fname):\n f = h5py.File(fname, 'r')\n for seg_name, seg_info in f.iteritems():\n if 'inv' not in seg_info:\n raise KeyError(\"H5 File does not have precomputed values\")\n seg_info = seg_info['inv']\n\n proj_mats = {}\n offset_mats = {}\n for b in self.bend_coefs:\n k = str(b)\n if k not in seg_info:\n raise KeyError(\"H5 File {} bend coeficient {}\".format(seg_name, k))\n proj_mats[b] = seg_info[k]['proj_mat'][:]\n offset_mats[b] = seg_info[k]['offset_mat'][:]\n\n ds_key = 'DS_SIZE_{}'.format(DS_SIZE)\n cloud_xyz = seg_info[ds_key]['scaled_cloud_xyz'][:]\n kernel = seg_info[ds_key]['scaled_K_nn'][:]\n self.add_cld(seg_name, proj_mats, offset_mats, cloud_xyz, kernel)\n f.close()\n self.update_ptrs()\n\n # @profile\n def setup_tgt_ctx(self, cloud_xyz):\n \"\"\"\n returns a GPUContext where all the clouds are cloud_xyz\n and matched in length with this contex\n\n assumes cloud_xyz is already downsampled and scaled\n \"\"\" \n tgt_ctx = TgtContext(self)\n tgt_ctx.set_cld(cloud_xyz)\n return tgt_ctx\n\n # @profile\n def transform_points(self):\n \"\"\"\n computes the warp of self.pts under the current tps params\n \"\"\"\n fill_mat(self.pt_w_ptrs, self.trans_d_ptrs, self.dims_gpu, self.N)\n dot_batch_nocheck(self.pts, self.lin_dd, self.pts_w,\n self.pt_ptrs, self.lin_dd_ptrs, self.pt_w_ptrs) \n dot_batch_nocheck(self.kernels, self.w_nd, self.pts_w,\n self.kernel_ptrs, self.w_nd_ptrs, self.pt_w_ptrs) \n sync()\n \n # @profile\n def get_target_points(self, other, outlierprior=1e-1, outlierfrac=1e-2, outliercutoff=1e-2, \n T = 5e-3, norm_iters = DEFAULT_NORM_ITERS):\n \"\"\"\n computes the target points for self and other\n using the current warped points for both \n \"\"\"\n init_prob_nm(self.pt_ptrs, other.pt_ptrs, \n self.pt_w_ptrs, other.pt_w_ptrs, \n self.dims_gpu, other.dims_gpu,\n self.N, outlierprior, outlierfrac, T, \n self.corr_cm_ptrs, self.corr_rm_ptrs)\n sync()\n norm_prob_nm(self.corr_cm_ptrs, self.corr_rm_ptrs, \n self.dims_gpu, other.dims_gpu, self.N, outlierfrac, norm_iters,\n self.r_coef_ptrs, self.c_coef_rn_ptrs, self.c_coef_cn_ptrs) \n sync()\n get_targ_pts(self.pt_ptrs, other.pt_ptrs,\n self.pt_w_ptrs, other.pt_w_ptrs,\n self.corr_cm_ptrs, self.corr_rm_ptrs,\n self.r_coef_ptrs, self.c_coef_rn_ptrs, self.c_coef_cn_ptrs,\n self.dims_gpu, other.dims_gpu, \n outliercutoff, self.N,\n self.pt_t_ptrs, other.pt_t_ptrs)\n sync()\n\n # @profile\n def update_transform(self, b):\n \"\"\"\n computes the TPS associated with the current target pts\n \"\"\"\n self.set_tps_params(self.offset_mats[b])\n dot_batch_nocheck(self.proj_mats[b], self.pts_t, self.tps_params,\n self.proj_mat_ptrs[b], self.pt_t_ptrs, self.tps_param_ptrs)\n sync()\n # @profile\n def mapping_cost(self, other, bend_coef=DEFAULT_LAMBDA[1], outlierprior=1e-1, outlierfrac=1e-2, \n outliercutoff=1e-2, T = 5e-3, norm_iters = DEFAULT_NORM_ITERS):\n \"\"\"\n computes the error in the current mapping\n assumes that the target points have already been filled\n \"\"\"\n self.transform_points()\n other.transform_points()\n sums = []\n sq_diffs(self.pt_w_ptrs, self.pt_t_ptrs, self.warp_err, self.N, True)\n sq_diffs(other.pt_w_ptrs, other.pt_t_ptrs, self.warp_err, self.N, False)\n warp_err = self.warp_err.get()\n return np.sum(warp_err, axis=1)\n # @profile\n def bending_cost(self, b=DEFAULT_LAMBDA[1]):\n ## b * w_nd' * K * w_nd\n ## use pts_w as temporary storage\n dot_batch_nocheck(self.kernels, self.w_nd, self.pts_w,\n self.kernel_ptrs, self.w_nd_ptrs, self.pt_w_ptrs,\n b = 0)\n\n dot_batch_nocheck(self.pts_w, self.w_nd, self.bend_res,\n self.pt_w_ptrs, self.w_nd_ptrs, self.bend_res_ptrs,\n transa='T', b = 0)\n bend_res = self.bend_res_mat.get() \n return b * np.array([np.trace(bend_res[i*DATA_DIM:(i+1)*DATA_DIM]) for i in range(self.N)])\n # @profile\n def bidir_tps_cost(self, other, bend_coef=1, outlierprior=1e-1, outlierfrac=1e-2, \n outliercutoff=1e-2, T = 5e-3, norm_iters = DEFAULT_NORM_ITERS):\n self.reset_warp_err()\n mapping_err = self.mapping_cost(other, outlierprior, outlierfrac, outliercutoff, T, norm_iters)\n bending_cost = self.bending_cost(bend_coef)\n bending_cost += other.bending_cost(bend_coef)\n return mapping_err + bending_cost\n\n \"\"\"\n testing for custom kernels\n \"\"\"\n\n def test_mapping_cost(self, other, bend_coef=DEFAULT_LAMBDA[1], outlierprior=1e-1, outlierfrac=1e-2, \n outliercutoff=1e-2, T = 5e-3, norm_iters = DEFAULT_NORM_ITERS):\n mapping_err = self.mapping_cost(other, outlierprior, outlierfrac, outliercutoff, T, norm_iters)\n for i in range(self.N):\n ## compute error for 0 on cpu\n s_gpu = mapping_err[i]\n s_cpu = np.float32(0)\n xt = self.pts_t[i].get()\n xw = self.pts_w[i].get()\n \n yt = other.pts_t[i].get()\n yw = other.pts_w[i].get()\n \n ##use the trace b/c then numpy will use float32s all the way\n s_cpu += np.trace(xt.T.dot(xt) + xw.T.dot(xw) - 2 * xw.T.dot(xt))\n s_cpu += np.trace(yt.T.dot(yt) + yw.T.dot(yw) - 2 * yw.T.dot(yt))\n \n if not np.isclose(s_cpu, s_gpu, atol=1e-4):\n ## high err tolerance is b/c of difference in cpu and gpu precision?\n print \"cpu and gpu sum sq differences differ!!!\"\n ipy.embed()\n sys.exit(1)\n\n def test_bending_cost(self, other, bend_coef=DEFAULT_LAMBDA[1], outlierprior=1e-1, outlierfrac=1e-2, \n outliercutoff=1e-2, T = 5e-3, norm_iters = DEFAULT_NORM_ITERS):\n self.get_target_points(other, outlierprior, outlierfrac, outliercutoff, T, norm_iters)\n self.update_transform(bend_coef)\n bending_costs = self.bending_cost(bend_coef)\n for i in range(self.N):\n c_gpu = bending_costs[i]\n k_nn = self.kernels[i].get()\n w_nd = self.w_nd[i].get()\n c_cpu = np.float32(0)\n for d in range(DATA_DIM):\n r = np.dot(k_nn, w_nd[:, d]).astype(np.float32)\n r = np.float32(np.dot(w_nd[:, d], r))\n c_cpu += r\n c_cpu *= np.float32(bend_coef)\n if np.abs(c_cpu - c_gpu) > 1e-4:\n ## high err tolerance is b/c of difference in cpu and gpu precision?\n print \"cpu and gpu bend costs differ!!!\"\n ipy.embed()\n sys.exit(1) \n\n def test_init_corr(self, other, T = 5e-3, outlierprior=1e-1, outlierfrac=1e-2, outliercutoff=1e-2, ):\n import scipy.spatial.distance as ssd\n import sys\n self.transform_points()\n other.transform_points()\n init_prob_nm(self.pt_ptrs, other.pt_ptrs, \n self.pt_w_ptrs, other.pt_w_ptrs, \n self.dims_gpu, other.dims_gpu,\n self.N, outlierprior, outlierfrac, T, \n self.corr_cm_ptrs, self.corr_rm_ptrs)\n gpu_corr_rm = self.corr_rm[0].get()\n gpu_corr_rm = gpu_corr_rm.flatten()[:(self.dims[0] + 1) * (other.dims[0] + 1)].reshape(self.dims[0]+1, other.dims[0]+1)\n s_pt_w = self.pts_w[0].get()\n s_pt = self.pts[0].get()\n o_pt_w = other.pts_w[0].get()\n o_pt = other.pts[0].get()\n\n d1 = ssd.cdist(s_pt_w, o_pt, 'euclidean')\n d2 = ssd.cdist(s_pt, o_pt_w, 'euclidean')\n\n p_nm = np.exp( -(d1 + d2) / (2 * T))\n\n for i in range(self.dims[0]):\n for j in range(other.dims[0]):\n if abs(p_nm[i, j] - gpu_corr_rm[i, j]) > 1e-7:\n print \"INIT CORR MATRICES DIFFERENT\"\n print i, j, p_nm[i, j], gpu_corr_rm[i, j]\n ipy.embed()\n sys.exit(1)\n\n def test_norm_corr(self, other, T = 5e-3, outlierprior=1e-1, outlierfrac=1e-2, outliercutoff=1e-2, norm_iters = DEFAULT_NORM_ITERS):\n import sys\n self.transform_points()\n other.transform_points()\n init_prob_nm(self.pt_ptrs, other.pt_ptrs, \n self.pt_w_ptrs, other.pt_w_ptrs, \n self.dims_gpu, other.dims_gpu,\n self.N, outlierprior, outlierfrac, T, \n self.corr_cm_ptrs, self.corr_rm_ptrs)\n n, m = self.dims[0], other.dims[0]\n init_corr = self.corr_rm[0].get() \n init_corr = init_corr.flatten()[:(n + 1) * (m + 1)].reshape(n+1, m+1).astype(np.float32)\n \n a_N = np.ones((n+1),dtype = np.float32)\n a_N[n] = m*outlierfrac\n b_M = np.ones((m+1), dtype = np.float32)\n b_M[m] = n*outlierfrac\n\n old_r_coefs = np.ones(n+1, dtype=np.float32)\n old_c_coefs = np.ones(m+1, dtype=np.float32)\n for n_iter in range(1, norm_iters):\n init_prob_nm(self.pt_ptrs, other.pt_ptrs, \n self.pt_w_ptrs, other.pt_w_ptrs, \n self.dims_gpu, other.dims_gpu,\n self.N, outlierprior, outlierfrac, T, \n self.corr_cm_ptrs, self.corr_rm_ptrs)\n\n norm_prob_nm(self.corr_cm_ptrs, self.corr_rm_ptrs, \n self.dims_gpu, other.dims_gpu, self.N, outlierfrac, n_iter,\n self.r_coef_ptrs, self.c_coef_rn_ptrs, self.c_coef_cn_ptrs) \n new_r_coefs = a_N/init_corr.dot(old_c_coefs[:m+1])\n new_c_coefs = b_M/new_r_coefs[:n+1].dot(init_corr)\n gpu_c_coefs = self.c_coefs_cn[0].get().flatten()[:m + 1].reshape(m+1)\n gpu_r_coefs = self.r_coefs[0].get().flatten()[:n + 1].reshape(n+1)\n if not np.allclose(new_r_coefs, gpu_r_coefs):\n print \"row coeficients don't match\", n_iter\n ipy.embed()\n sys.exit(1)\n if not np.allclose(new_c_coefs, gpu_c_coefs):\n print \"column coeficients don't match\", n_iter\n ipy.embed()\n sys.exit(1)\n # old_r_coefs = gpu_r_coefs\n # old_c_coefs = gpu_c_coefs\n old_r_coefs = new_r_coefs\n old_c_coefs = new_c_coefs\n \n def test_get_targ(self, other, T = 5e-3, outlierprior=1e-1, outlierfrac=1e-2, outliercutoff=1e-2, norm_iters = DEFAULT_NORM_ITERS):\n self.transform_points()\n other.transform_points()\n init_prob_nm(self.pt_ptrs, other.pt_ptrs, \n self.pt_w_ptrs, other.pt_w_ptrs, \n self.dims_gpu, other.dims_gpu,\n self.N, outlierprior, outlierfrac, T, \n self.corr_cm_ptrs, self.corr_rm_ptrs)\n norm_prob_nm(self.corr_cm_ptrs, self.corr_rm_ptrs, \n self.dims_gpu, other.dims_gpu, self.N, outlierfrac, norm_iters,\n self.r_coef_ptrs, self.c_coef_rn_ptrs, self.c_coef_cn_ptrs)\n get_targ_pts(self.pt_ptrs, other.pt_ptrs,\n self.pt_w_ptrs, other.pt_w_ptrs,\n self.corr_cm_ptrs, self.corr_rm_ptrs,\n self.r_coef_ptrs, self.c_coef_rn_ptrs, self.c_coef_cn_ptrs,\n self.dims_gpu, other.dims_gpu, \n outliercutoff, self.N,\n self.pt_t_ptrs, other.pt_t_ptrs)\n n, m = self.dims[0], other.dims[0]\n x = self.pts[0].get()[:n]\n xw = self.pts_w[0].get()[:n]\n xt = self.pts_t[0].get()[:n]\n y = other.pts[0].get()[:m]\n yw = other.pts_w[0].get()[:m]\n yt = other.pts_t[0].get()[:m]\n\n init_corr = self.corr_rm[0].get() \n init_corr = init_corr.flatten()[:(n + 1) * (m + 1)].reshape(n+1, m+1).astype(np.float32)\n gpu_c_cn_coefs = self.c_coefs_cn[0].get().flatten()[:m + 1].reshape(m+1)\n gpu_c_rn_coefs = self.c_coefs_rn[0].get().flatten()[:m + 1].reshape(m+1)\n gpu_r_coefs = self.r_coefs[0].get().flatten()[:n + 1].reshape(n+1)\n\n rn_corr = (init_corr * gpu_c_rn_coefs[None, :]) * gpu_r_coefs[:, None]\n cn_corr = (init_corr * gpu_c_cn_coefs[None, :]) * gpu_r_coefs[:, None] \n rn_corr = rn_corr[:n, :m]\n cn_corr = cn_corr[:n, :m]\n \n wt_n = rn_corr.sum(axis=1)\n inlier = wt_n > outliercutoff\n xtarg = np.empty((n, DATA_DIM))\n xtarg[inlier, :] = rn_corr.dot(y)[inlier, :]\n xtarg[~inlier, :] = xw[~inlier, :]\n\n if not np.allclose(xtarg, xt):\n print \"xt values differ\"\n ipy.embed()\n sys.exit(1)\n\n wt_m = cn_corr.sum(axis=0)\n inliner = wt_m > outliercutoff\n ytarg = np.empty((m, DATA_DIM))\n ytarg[inlier, :] = cn_corr.T.dot(x)[inliner, :]\n ytarg[~inlier, :] = yw[~inlier, :]\n if not np.allclose(ytarg, yt):\n print \"yt values differ\"\n ipy.embed()\n sys.exit(1) \n\n def unit_test(self, other):\n print \"running basic unit tests\"\n self.test_init_corr(other)\n self.test_norm_corr(other)\n self.test_get_targ(other)\n self.test_mapping_cost(other)\n self.test_bending_cost(other)\n print \"UNIT TESTS PASSED\"\n \n\nclass TgtContext(GPUContext):\n \"\"\"\n specialized class to handle the case where we are\n mapping to a single target cloud --> only allocate GPU Memory once\n \"\"\"\n def __init__(self, src_ctx):\n GPUContext.__init__(self, src_ctx.bend_coefs)\n self.src_ctx = src_ctx\n ## just setup with 0's\n tgt_cld = np.zeros((MAX_CLD_SIZE, DATA_DIM), np.float32)\n proj_mats = dict([(b, np.zeros((MAX_CLD_SIZE + DATA_DIM + 1, MAX_CLD_SIZE), np.float32)) \n for b in self.bend_coefs])\n offset_mats = dict([(b, np.zeros((MAX_CLD_SIZE + DATA_DIM + 1, DATA_DIM), np.float32)) \n for b in self.bend_coefs])\n tgt_K = np.zeros((MAX_CLD_SIZE, MAX_CLD_SIZE), np.float32)\n for n in src_ctx.seg_names:\n name = \"{}_tgt\".format(n)\n GPUContext.add_cld(self, name, proj_mats, offset_mats, tgt_cld, tgt_K)\n GPUContext.update_ptrs(self)\n def add_cld(self, name, proj_mats, offset_mats, cloud_xyz, kernel, update_ptrs = False):\n raise NotImplementedError(\"not implemented for TgtConext\")\n def update_ptrs(self):\n raise NotImplementedError(\"not implemented for TgtConext\")\n # @profile\n def set_cld(self, cld):\n \"\"\"\n sets the cloud for this appropriately\n won't allocate any new memory\n \"\"\" \n proj_mats, offset_mats, K = self.get_sol_params(cld)\n K_gpu = gpu_pad(K, (MAX_CLD_SIZE, MAX_CLD_SIZE))\n cld_gpu = gpu_pad(cld, (MAX_CLD_SIZE, DATA_DIM))\n self.pts = [cld_gpu for _ in range(self.N)]\n self.kernels = [K_gpu for _ in range(self.N)]\n proj_mats_gpu = dict([(b, gpu_pad(p.get(), (MAX_CLD_SIZE + DATA_DIM + 1, MAX_CLD_SIZE)))\n for b, p in proj_mats.iteritems()])\n self.proj_mats = dict([(b, [p for _ in range(self.N)])\n for b, p in proj_mats_gpu.iteritems()])\n offset_mats_gpu = dict([(b, gpu_pad(p.get(), (MAX_CLD_SIZE + DATA_DIM + 1, DATA_DIM))) \n for b, p in offset_mats.iteritems()])\n self.offset_mats = dict([(b, [p for _ in range(self.N)])\n for b, p in offset_mats_gpu.iteritems()])\n self.dims = [cld.shape[0]]\n\n self.pt_ptrs.fill(int(self.pts[0].gpudata))\n self.kernel_ptrs.fill(int(self.kernels[0].gpudata))\n self.dims_gpu.fill(self.dims[0])\n for b in self.bend_coefs:\n self.proj_mat_ptrs[b].fill(int(self.proj_mats[b][0].gpudata))\n self.offset_mat_ptrs[b].fill(int(self.offset_mats[b][0].gpudata))\n\ndef check_transform_pts(ctx, i = 0):\n import scikits.cuda.linalg as la\n n = ctx.dims[i]\n w_nd = ctx.w_nd[i].get()[:n]\n lin_dd = ctx.lin_dd[i].get()\n trans_d = ctx.trans_d[i].get()\n k_nn = ctx.kernels[i].get()[:n, :n].reshape(n, n).copy()\n x_nd = ctx.pts[i].get()[:n]\n xw_nd = ctx.pts_w[i].get()[:n]\n\n _k_gpu = gpuarray.to_gpu(k_nn)\n _x_gpu = gpuarray.to_gpu(x_nd)\n _lin_gpu = gpuarray.to_gpu(lin_dd)\n _trans_gpu = gpuarray.to_gpu(trans_d)\n _w_gpu = gpuarray.to_gpu(w_nd)\n \n fill_mat(ctx.pt_w_ptrs, ctx.trans_d_ptrs, ctx.dims_gpu, ctx.N)\n dot_batch_nocheck(ctx.pts, ctx.lin_dd, ctx.pts_w,\n ctx.pt_ptrs, ctx.lin_dd_ptrs, ctx.pt_w_ptrs) \n\n xw_nd = ctx.pts_w[i].get()[:n]\n cpu_xw_nd = np.dot(x_nd, lin_dd) + trans_d[None, :]\n # assert np.allclose(xw_nd, cpu_xw_nd)\n\n dot_batch_nocheck(ctx.kernels, ctx.w_nd, ctx.pts_w,\n ctx.kernel_ptrs, ctx.w_nd_ptrs, ctx.pt_w_ptrs) \n xw_nd = ctx.pts_w[i].get()[:n]\n cpu_xw_nd = cpu_xw_nd + np.dot(k_nn, w_nd)\n # print \"w_nd\\n\", w_nd[:3], np.max(w_nd)\n # print \"lin_dd\\n\", lin_dd[:3]\n # print \"trans_d\\n\", trans_d\n # print \"k_nn\\n\", k_nn[:3, :3]\n # print \"x_nd\\n\", x_nd[:3, :3]\n # print cpu_xw_nd[:3]\n if not(np.allclose(xw_nd, cpu_xw_nd) ):\n print \"k dot w_nd is difference on cpu and gpu\"\n k_dot_w = np.dot(k_nn, w_nd)\n k_gpu = [gpuarray.to_gpu(k_nn)]\n w_gpu = [gpuarray.to_gpu(w_nd)]\n res_gpu = [gpuarray.zeros((n, DATA_DIM), np.float32)] \n k_ptrs = get_gpu_ptrs(k_gpu)\n w_ptrs = get_gpu_ptrs(w_gpu)\n res_ptrs = get_gpu_ptrs(res_gpu)\n dot_batch_nocheck(k_gpu, w_gpu, res_gpu, k_ptrs, w_ptrs, res_ptrs)\n res = res_gpu[0].get()\n single_gpu = la.dot(_k_gpu, _w_gpu)\n print \"retry success {}\".format(np.allclose(res, k_dot_w))\n print \"gpu success {}\".format(np.allclose(single_gpu.get(), res))\n assert np.allclose(single_gpu.get(), res)\n raw_input(\"go?\")\n\ndef check_update(ctx, b):\n ctx.tps_params[0] = ctx.default_tps_params.copy()\n ctx.update_ptrs()\n xt = ctx.pts_t[0].get()\n p_mat = ctx.proj_mats[b][0].get()\n o_mat = ctx.offset_mats[b][0].get()\n true_res = np.dot(p_mat, xt) + o_mat\n ctx.set_tps_params(ctx.offset_mats[b])\n o_gpu = ctx.tps_params[0].get()\n if not np.allclose(o_gpu, o_mat):\n print \"setting tps params failed\"\n diff = np.abs(o_mat - o_gpu)\n nz = np.nonzero(diff)\n print nz\n ipy.embed()\n sys.exit(1)\n ctx.update_transform(b)\n p1 = ctx.tps_params[0].get()\n if not np.allclose(true_res, p1):\n print \"p1 and true res differ\"\n print p1[:3]\n diff = np.abs(p1 - true_res)\n print np.max(diff)\n amax = np.argmax(diff)\n print amax\n nz = np.nonzero(diff)\n print nz[0]\n ipy.embed()\n sys.exit(1)\n\n# @profile\ndef batch_tps_rpm_bij(src_ctx, tgt_ctx, T_init = 1e-1, T_final = 5e-3, \n outlierfrac = 1e-2, outlierprior = 1e-1, outliercutoff = 1e-2, em_iter = EM_ITER_CHEAP):\n \"\"\"\n computes tps rpm for the clouds in src and tgt in batch\n TODO: Fill out comment cleanly\n \"\"\"\n ##TODO: add check to ensure that src_ctx and tgt_ctx are formatted properly\n n_iter = len(src_ctx.bend_coefs)\n T_vals = loglinspace(T_init, T_final, n_iter)\n\n src_ctx.reset_tps_params()\n tgt_ctx.reset_tps_params()\n for i, b in enumerate(src_ctx.bend_coefs):\n T = T_vals[i]\n for _ in range(em_iter):\n src_ctx.transform_points()\n tgt_ctx.transform_points()\n src_ctx.get_target_points(tgt_ctx, outlierprior, outlierfrac, outliercutoff, T)\n src_ctx.update_transform(b)\n # check_update(src_ctx, b)\n tgt_ctx.update_transform(b)\n return src_ctx.bidir_tps_cost(tgt_ctx)\n\ndef test_batch_tps_rpm_bij(src_ctx, tgt_ctx, T_init = 1e-1, T_final = 5e-3, \n outlierfrac = 1e-2, outlierprior = 1e-1, outliercutoff = .5, em_iter = EM_ITER_CHEAP,\n test_ind = 0):\n from transformations import ThinPlateSpline, set_ThinPlateSpline\n import tps\n n_iter = len(src_ctx.bend_coefs)\n T_vals = loglinspace(T_init, T_final, n_iter)\n\n x_nd = src_ctx.pts[test_ind].get()[:src_ctx.dims[test_ind]]\n y_md = tgt_ctx.pts[0].get()[:tgt_ctx.dims[0]]\n (n, d) = x_nd.shape\n (m, _) = y_md.shape\n\n f = ThinPlateSpline(d) \n g = ThinPlateSpline(d) \n\n src_ctx.reset_tps_params()\n tgt_ctx.reset_tps_params()\n for i, b in enumerate(src_ctx.bend_coefs):\n T = T_vals[i]\n for _ in range(em_iter):\n src_ctx.transform_points()\n tgt_ctx.transform_points()\n\n xwarped_nd = f.transform_points(x_nd)\n ywarped_md = g.transform_points(y_md)\n gpu_xw = src_ctx.pts_w[test_ind].get()[:n, :]\n gpu_yw = tgt_ctx.pts_w[test_ind].get()[:m, :]\n assert np.allclose(xwarped_nd, gpu_xw, atol=1e-5)\n assert np.allclose(ywarped_md, gpu_yw, atol=1e-5)\n\n xwarped_nd = gpu_xw\n ywarped_md = gpu_yw\n\n src_ctx.get_target_points(tgt_ctx, outlierprior, outlierfrac, outliercutoff, T)\n \n fwddist_nm = ssd.cdist(xwarped_nd, y_md,'euclidean')\n invdist_nm = ssd.cdist(x_nd, ywarped_md,'euclidean')\n prob_nm = outlierprior * np.ones((n+1, m+1), np.float32)\n prob_nm[:n, :m] = np.exp( -(fwddist_nm + invdist_nm) / float(2*T))\n prob_nm[n, m] = outlierfrac * np.sqrt(n * m)\n\n gpu_corr = src_ctx.corr_rm[test_ind].get()\n gpu_corr = gpu_corr.flatten()\n gpu_corr = gpu_corr[:(n + 1) * (m + 1)].reshape(n+1, m+1).astype(np.float32)\n\n assert np.allclose(prob_nm[:n, :m], gpu_corr[:n, :m], atol=1e-5)\n prob_nm[:n, :m] = gpu_corr[:n, :m]\n\n r_coefs = np.ones(n+1, np.float32)\n c_coefs = np.ones(m+1, np.float32)\n a_N = np.ones((n+1),dtype = np.float32)\n a_N[n] = m*outlierfrac\n b_M = np.ones((m+1), dtype = np.float32)\n b_M[m] = n*outlierfrac\n for _ in range(DEFAULT_NORM_ITERS):\n r_coefs = a_N/prob_nm.dot(c_coefs)\n rn_c_coefs = c_coefs\n c_coefs = b_M/r_coefs.dot(prob_nm)\n gpu_r_coefs = src_ctx.r_coefs[test_ind].get()[:n+1].reshape(n+1)\n gpu_c_coefs_cn = src_ctx.c_coefs_cn[test_ind].get()[:m+1].reshape(m+1)\n gpu_c_coefs_rn = src_ctx.c_coefs_rn[test_ind].get()[:m+1].reshape(m+1)\n assert np.allclose(r_coefs, gpu_r_coefs, atol=1e-5)\n assert np.allclose(c_coefs, gpu_c_coefs_cn, atol=1e-5)\n assert np.allclose(rn_c_coefs, gpu_c_coefs_rn, atol=1e-5)\n \n prob_nm = prob_nm[:n, :m]\n prob_nm *= gpu_r_coefs[:n, None]\n rn_p_nm = prob_nm * gpu_c_coefs_rn[None, :m]\n cn_p_nm = prob_nm * gpu_c_coefs_cn[None, :m]\n\n wt_n = rn_p_nm.sum(axis=1)\n gpu_corr_cm = src_ctx.corr_cm[test_ind].get().flatten()[:(n+1)*(m+1)]\n gpu_corr_cm = gpu_corr_cm.reshape(m+1, n+1)## b/c it is column major\n assert np.allclose(wt_n, gpu_corr_cm[m, :n], atol=1e-4)\n\n \n inlier = wt_n > outliercutoff\n xtarg_nd = np.empty((n, DATA_DIM), np.float32)\n xtarg_nd[inlier, :] = rn_p_nm.dot(y_md)[inlier, :]\n xtarg_nd[~inlier, :] = xwarped_nd[~inlier, :]\n\n wt_m = cn_p_nm.sum(axis=0)\n assert np.allclose(wt_m, gpu_corr[n, :m], atol=1e-4)\n\n inlier = wt_m > outliercutoff\n ytarg_md = np.empty((m, DATA_DIM), np.float32)\n ytarg_md[inlier, :] = cn_p_nm.T.dot(x_nd)[inlier, :]\n ytarg_md[~inlier, :] = ywarped_md[~inlier, :]\n \n xt_gpu = src_ctx.pts_t[test_ind].get()[:n, :]\n yt_gpu = tgt_ctx.pts_t[test_ind].get()[:m, :]\n assert np.allclose(xtarg_nd, xt_gpu, atol=1e-4)\n assert np.allclose(ytarg_md, yt_gpu, atol=1e-4)\n\n src_ctx.update_transform(b)\n tgt_ctx.update_transform(b)\n\n f_p_mat = src_ctx.proj_mats[b][test_ind].get()[:n+d+1, :n]\n f_o_mat = src_ctx.offset_mats[b][test_ind].get()[:n+d+1]\n b_p_mat = tgt_ctx.proj_mats[b][0].get()[:m+d+1, :m]\n b_o_mat = tgt_ctx.offset_mats[b][0].get()[:m+d+1]\n f_params = f_p_mat.dot(xtarg_nd) + f_o_mat\n g_params = b_p_mat.dot(ytarg_md) + b_o_mat\n\n\n gpu_fparams = src_ctx.tps_params[test_ind].get()[:n+d+1]\n gpu_gparams = tgt_ctx.tps_params[test_ind].get()[:m+d+1]\n assert np.allclose(f_params, gpu_fparams, atol=1e-4)\n assert np.allclose(g_params, gpu_gparams, atol=1e-4)\n\n\n set_ThinPlateSpline(f, x_nd, gpu_fparams)\n set_ThinPlateSpline(g, y_md, gpu_gparams)\n\n f._cost = tps.tps_cost(f.lin_ag, f.trans_g, f.w_ng, f.x_na, xtarg_nd, 1)\n g._cost = tps.tps_cost(g.lin_ag, g.trans_g, g.w_ng, g.x_na, ytarg_md, 1)\n\n gpu_cost = src_ctx.bidir_tps_cost(tgt_ctx) \n cpu_cost = f._cost + g._cost\n assert np.isclose(gpu_cost[test_ind], cpu_cost, atol=1e-4)\n \n \n\ndef parse_arguments():\n import argparse\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--input_file\", type=str, default='../data/actions.h5')\n parser.add_argument(\"--sync\", action='store_true')\n parser.add_argument(\"--n_copies\", type=int, default=1)\n parser.add_argument(\"--test\", action='store_true')\n parser.add_argument(\"--test_full\", action='store_true')\n parser.add_argument(\"--timing_runs\", type=int, default=100)\n return parser.parse_args()\n\nif __name__=='__main__':\n reset_cuda()\n args = parse_arguments()\n Globals.sync = args.sync\n src_ctx = GPUContext()\n for _ in range(args.n_copies):\n src_ctx.read_h5(args.input_file)\n f = h5py.File(args.input_file, 'r') \n tgt_cld = downsample_cloud(f['demo1-seg00']['cloud_xyz'][:])\n f.close()\n scaled_tgt_cld, _ = unit_boxify(tgt_cld)\n tgt_ctx = TgtContext(src_ctx)\n tgt_ctx.set_cld(scaled_tgt_cld)\n if args.test_full:\n src_ctx.unit_test(tgt_ctx)\n print \"unit tests passed, doing full check on batch tps rpm\"\n for i in range(src_ctx.N):\n sys.stdout.write(\"\\rtesting source cloud {}\".format(i))\n sys.stdout.flush()\n test_batch_tps_rpm_bij(src_ctx, tgt_ctx, test_ind=i)\n print\"\"\n print \"tests succeeded!\"\n sys.exit()\n if args.test:\n src_ctx.unit_test(tgt_ctx)\n print \"testing batch tps_rps\"\n test_batch_tps_rpm_bij(src_ctx, tgt_ctx)\n print \"test succeeded!!\"\n sys.exit() \n times = []\n print \"batchtps initialized\"\n for i in range(args.timing_runs):\n sys.stdout.write(\"\\rRunning Timing test {}/{}\".format(i, args.timing_runs))\n sys.stdout.flush()\n start = time.time()\n tgt_ctx.set_cld(scaled_tgt_cld)\n c = batch_tps_rpm_bij(src_ctx, tgt_ctx)\n time_taken = time.time() - start\n times.append(time_taken)\n print \"\\nTiming Tests Complete\"\n print \"Batch Size:\\t\\t\\t\", src_ctx.N\n print \"Mean Compute Time per Batch:\\t\", np.mean(times)\n print \"BiDirectional TPS fits/second:\\t\", float(args.timing_runs * src_ctx.N) / np.sum(times)\n", "meta": {"hexsha": "a24ed5ea4f795b3da8248c80c7fffd0bf721431d", "size": 37365, "ext": "py", "lang": "Python", "max_stars_repo_path": "tpsopt/batchtps.py", "max_stars_repo_name": "dhadfieldmenell/tps-opt", "max_stars_repo_head_hexsha": "3f7f468c1580f8fd2a740134b500ef2b226cd45a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2017-03-31T07:27:30.000Z", "max_stars_repo_stars_event_max_datetime": "2020-08-15T03:03:31.000Z", "max_issues_repo_path": "tpsopt/batchtps.py", "max_issues_repo_name": "dhadfieldmenell/tps-opt", "max_issues_repo_head_hexsha": "3f7f468c1580f8fd2a740134b500ef2b226cd45a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "tpsopt/batchtps.py", "max_forks_repo_name": "dhadfieldmenell/tps-opt", "max_forks_repo_head_hexsha": "3f7f468c1580f8fd2a740134b500ef2b226cd45a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.8497706422, "max_line_length": 136, "alphanum_fraction": 0.5866452563, "include": true, "reason": "import numpy,import scipy,import pycuda,from pycuda", "num_tokens": 10306, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5736784074525098, "lm_q2_score": 0.33111974622959367, "lm_q1q2_score": 0.18995624869307245}} {"text": "#!/usr/bin/env python3\nimport sys, getopt, math, os, time, traceback\nimport numpy as np\n\n################################# Arguments ###################################\n# Default parameters\nn_traj = 100\nnum_rep = 10\nmutant_type_list = ['fast', 'slow']\nn_window = 200\nco_msm_data_file = ''\npost_msm_data_file = ''\n\n# read control file\nctrlfile = ''\n\nif len(sys.argv) == 1:\n print(usage)\n sys.exit()\n\ntry:\n opts, args = getopt.getopt(sys.argv[1:],\"hf:\", [\"ctrlfile=\"])\nexcept getopt.GetoptError:\n print(usage)\n sys.exit()\nfor opt, arg in opts:\n if opt == '-h':\n print(usage)\n sys.exit()\n elif opt in (\"-f\", \"--ctrlfile\"):\n ctrlfile = arg\n \nif not os.path.exists(ctrlfile):\n print('Error: cannot find control file ' + ctrlfile + '.')\n sys.exit()\n\nfile_object = open(ctrlfile,'r')\ntry:\n for line in file_object:\n line = line.strip()\n if not line:\n # This is a blank line\n continue\n if line.startswith('#'):\n # This is a comment line\n continue\n if line.startswith('n_traj'):\n words = line.split('=')\n n_traj = int(words[1].strip())\n continue\n if line.startswith('num_rep'):\n words = line.split('=')\n num_rep = int(words[1].strip())\n continue\n if line.startswith('mutant_type_list'):\n words = line.split('=')\n mutant_type_list = words[1].strip().split()\n continue\n if line.startswith('n_window'):\n words = line.split('=')\n n_window = int(words[1].strip())\n continue\n if line.startswith('co_msm_data_file'):\n words = line.split('=')\n co_msm_data_file = words[1].strip()\n continue\n if line.startswith('post_msm_data_file'):\n words = line.split('=')\n post_msm_data_file = words[1].strip()\n continue\nfinally:\n file_object.close()\n\n################################# Functions ###################################\ndef get_pathways(meta_dtrajs, start_states, end_states):\n pathways = {}\n states_on_pathway = []\n start_states = [str(s+1) for s in start_states]\n end_states = [str(s+1) for s in end_states]\n\n for traj_idx, md in enumerate(meta_dtrajs):\n path = []\n for idx, mdi in enumerate(md):\n if str(mdi+1) in start_states:\n path.append(str(mdi+1))\n break\n if idx == len(md)-1:\n continue\n \n for mdi in md[idx+1:]:\n tag_find = False\n for pi in range(len(path)):\n if path[pi] == str(mdi+1):\n path = path[0:pi+1]\n tag_find = True\n break\n if not tag_find:\n path.append(str(mdi+1))\n \n if path[-1] not in end_states:\n continue \n \n for p in path:\n if not int(p) in states_on_pathway:\n states_on_pathway.append(int(p))\n \n path = ' -> '.join(path)\n if not path in pathways.keys():\n pathways[path] = 1\n else:\n pathways[path] += 1\n \n tot_num = 0\n for path in pathways.keys():\n tot_num += pathways[path]\n for path in pathways.keys():\n pathways[path] /= tot_num\n\n sort_pathways = sorted(pathways.items(), key=lambda x: x[1], reverse=True)\n \n states_on_pathway.sort()\n return [sort_pathways, states_on_pathway]\n\n################################## MAIN #######################################\n# Read co-trans metastable dtrajs\nco_meta_dtrajs = np.load(co_msm_data_file, allow_pickle=True)['meta_dtrajs']\nco_n_states = 0\nfor i in range(len(co_meta_dtrajs)):\n if np.max(co_meta_dtrajs[i]) > co_n_states:\n co_n_states = np.max(co_meta_dtrajs[i])\nco_n_states += 1\n# Read post-trans metastable dtrajs\npost_meta_dtrajs = np.load(post_msm_data_file, allow_pickle=True)['meta_dtrajs']\nmax_T_len = 0\npost_n_states = 0\nfor i in range(len(post_meta_dtrajs)):\n if post_meta_dtrajs[i].shape[0] > max_T_len:\n max_T_len = post_meta_dtrajs[i].shape[0]\n if np.max(post_meta_dtrajs[i]) > post_n_states:\n post_n_states = np.max(post_meta_dtrajs[i])\npost_n_states += 1\npost_meta_dtrajs_extended = []\nfor i in range(len(post_meta_dtrajs)):\n (N, be) = np.histogram(post_meta_dtrajs[i][-n_window:], bins=np.arange(-0.5, post_n_states, 1))\n meta_dtraj_last = np.argwhere(N == np.max(N))[0][0]\n mde = []\n for j in range(max_T_len):\n if j >= len(post_meta_dtrajs[i]): \n state_0 = meta_dtraj_last\n else:\n state_0 = post_meta_dtrajs[i][j]\n mde.append(state_0)\n post_meta_dtrajs_extended.append(mde)\n\nprint('Total number of states: %d'%(co_n_states + post_n_states))\n\n# combine dtrajs\nmeta_dtrajs = []\nfor i in range(len(co_meta_dtrajs)):\n for j in range(num_rep):\n md = np.hstack((co_meta_dtrajs[i], post_meta_dtrajs_extended[i*num_rep+j] + co_n_states))\n meta_dtrajs.append(md)\nmeta_dtrajs = np.array(meta_dtrajs, dtype=object)\n\nmtype2trajid = [np.arange(n_traj*num_rep*i_ax, n_traj*num_rep*(i_ax+1)).astype(int) for i_ax, mutant_type in enumerate(mutant_type_list)]\n\n# analysis MSM for each mutant\nfo = open('pathways.dat', 'w')\nfor i_ax, mutant_type in enumerate(mutant_type_list): \n # flux analysis\n A = [0]\n B = [md[-1] for md in meta_dtrajs[mtype2trajid[i_ax]]]\n B = np.unique(B)\n \n [pathways, state_on_pathway] = get_pathways(meta_dtrajs[mtype2trajid[i_ax]], A, B)\n \n fo.write('%s pathways:\\n'%mutant_type)\n fo.write('%-12s %s\\n'%('percentage','path'))\n fo.write('-------------------------------------\\n')\n for path in pathways:\n fo.write('%-12s %-s\\n'%('%.2f %%'%(path[1] * 100), path[0]))\n fo.write('\\n')\n", "meta": {"hexsha": "22a7fec19bc706f69b378fd9a7cb9c07e782e8d7", "size": 5861, "ext": "py", "lang": "Python", "max_stars_repo_path": "Analysis_protocol/get_co_post_folding_pathways.py", "max_stars_repo_name": "obrien-lab/cg_simtk_protain_folding", "max_stars_repo_head_hexsha": "c64aa49696afe6fc1680c083cda556697d937f52", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Analysis_protocol/get_co_post_folding_pathways.py", "max_issues_repo_name": "obrien-lab/cg_simtk_protain_folding", "max_issues_repo_head_hexsha": "c64aa49696afe6fc1680c083cda556697d937f52", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Analysis_protocol/get_co_post_folding_pathways.py", "max_forks_repo_name": "obrien-lab/cg_simtk_protain_folding", "max_forks_repo_head_hexsha": "c64aa49696afe6fc1680c083cda556697d937f52", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.0273224044, "max_line_length": 137, "alphanum_fraction": 0.564920662, "include": true, "reason": "import numpy", "num_tokens": 1516, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5736784074525096, "lm_q2_score": 0.33111973962899144, "lm_q1q2_score": 0.18995624490644947}} {"text": "# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Tue Jun 29 09:38:12 2021\n\n@author: ruy\n\"\"\"\nfrom __future__ import annotations\nfrom abc import ABC\nfrom dataclasses import dataclass, field\nfrom enum import Enum\nfrom functools import cached_property as property\nimport numpy as np\nfrom dataclass_tools.tools import (\n DESERIALIZER_OPTIONS,\n DeSerializerOptions,\n NamePrint,\n PrintMetadata,\n serialize_dataclass,\n)\n\nfrom pylatex import NoEscape, Quantity\n\nfrom .abrevitation_registry import abv_registry\nfrom .common_field_options import NAME_OPTIONS\nfrom .constants import GRAVITY\n\n\nclass TypeOfService(str, Enum):\n \"\"\"Vessels service type in accordance to GL HSC 2012 rules.\"\"\"\n\n PASSENGER = \"PASSENGER\"\n FERRY = \"FERRY\"\n CARGO = \"CARGO\"\n SUPPLY = \"SUPPLY\"\n PILOT = \"PILOT\"\n RESCUE = \"RESCUE\"\n\n\nclass ServiceRange(str, Enum):\n \"\"\"\n Vessels service range in accordance to GL HSC 2012 rules.\n USR - Unrestricted service range\n RSA_200 - 200 nm range\n RSA_50 - 50 nm range\n RSA_20 - 20 nm range\n RSA_SW - sheltered waters\n \"\"\"\n\n USR = \"USR\"\n RSA_200 = \"RSA (200)\"\n RSA_50 = \"RSA (50)\"\n RSA_20 = \"RSA (20)\"\n RSA_SW = \"RSA (SW)\"\n\n\nSPEED_OPTIONS = DeSerializerOptions(\n metadata=PrintMetadata(long_name=\"Speed\", abreviation=\"S\", units=\"kt\")\n)\nabv_registry.append(SPEED_OPTIONS)\nDISPLACEMENT_OPTIONS = DeSerializerOptions(\n metadata=PrintMetadata(\n long_name=\"Displacement\", abreviation=NoEscape(r\"$\\Delta$\"), units=\"t\"\n )\n)\nabv_registry.append(DISPLACEMENT_OPTIONS)\nLENGTH_OPTIONS = DeSerializerOptions(\n metadata=PrintMetadata(long_name=\"Length\", abreviation=\"L\", units=\"m\")\n)\nabv_registry.append(LENGTH_OPTIONS)\nBEAM_OPTIONS = DeSerializerOptions(\n metadata=PrintMetadata(long_name=\"Beam\", abreviation=\"B\", units=\"m\")\n)\nabv_registry.append(BEAM_OPTIONS)\nFWD_PERP_OPTIONS = DeSerializerOptions(\n metadata=PrintMetadata(\n long_name=\"Foward Perpendicular\",\n abreviation=NoEscape(r\"F\\textsubscript{P}\"),\n units=\"m\",\n )\n)\nabv_registry.append(FWD_PERP_OPTIONS)\nAFT_PERP_OPTIONS = DeSerializerOptions(\n metadata=PrintMetadata(\n long_name=\"Aft Perpendicular\",\n abreviation=NoEscape(r\"A\\textsubscript{P}\"),\n units=\"m\",\n )\n)\nabv_registry.append(AFT_PERP_OPTIONS)\nDRAFT_OPTIONS = DeSerializerOptions(\n metadata=PrintMetadata(\n long_name=\"Draft\",\n abreviation=\"H\",\n units=\"m\",\n )\n)\nabv_registry.append(DRAFT_OPTIONS)\nZ_BASELINE_OPTIONS = DeSerializerOptions(\n metadata=PrintMetadata(\n long_name=\"Z from base line\",\n abreviation=NoEscape(r\"z\\textsubscript{BL}\"),\n units=\"m\",\n )\n)\nabv_registry.append(Z_BASELINE_OPTIONS)\nBLOCK_COEF_OPTIONS = DeSerializerOptions(\n metadata=PrintMetadata(\n long_name=\"Block coefficient\",\n abreviation=NoEscape(r\"C\\textsubscript{B}\"),\n units=\"\",\n )\n)\nabv_registry.append(BLOCK_COEF_OPTIONS)\nWATER_PLANE_AREA_OPTIONS = DeSerializerOptions(\n metadata=PrintMetadata(\n long_name=\"Water plane area\",\n abreviation=NoEscape(r\"WP\\textsubscript{A}\"),\n units=\"m**2\",\n )\n)\nabv_registry.append(WATER_PLANE_AREA_OPTIONS)\nLCG_OPTIONS = DeSerializerOptions(\n metadata=PrintMetadata(\n long_name=\"Longitudinal center of gravity\",\n abreviation=NoEscape(r\"L\\textsubscript{cg}\"),\n units=\"m\",\n )\n)\nabv_registry.append(LCG_OPTIONS)\nDEADRISE_LCG_OPTIONS = DeSerializerOptions(\n metadata=PrintMetadata(\n long_name=\"Deadrise at longitudinal center of gravity\",\n abreviation=NoEscape(r\"$\\alpha$\\textsubscript{d}\"),\n units=\"degree\",\n )\n)\nabv_registry.append(DEADRISE_LCG_OPTIONS)\nDIST_HULL_CL_OPTIONS = DeSerializerOptions(\n metadata=PrintMetadata(\n long_name=\"Distance between hulls centerline\",\n abreviation=NoEscape(r\"B\\textsubscript{CL}\"),\n units=\"m\",\n )\n)\nabv_registry.append(DIST_HULL_CL_OPTIONS)\nTYPE_OF_SERVICE_OPTIONS = DeSerializerOptions(\n metadata=PrintMetadata(\n long_name=\"Type of service\",\n abreviation=\"ToS\",\n )\n)\nabv_registry.append(TYPE_OF_SERVICE_OPTIONS)\nSERVICE_RANGE_OPTIONS = DeSerializerOptions(\n metadata=PrintMetadata(\n long_name=\"Service range\",\n abreviation=\"SR\",\n )\n)\nabv_registry.append(SERVICE_RANGE_OPTIONS)\nVERT_ACG_OPTIONS = DeSerializerOptions(\n metadata=PrintMetadata(\n long_name=\"Center of gravity's vertical acceleration\",\n abreviation=NoEscape(r\"a\\textsubscript{CG}\"),\n units=\"g\",\n )\n)\nabv_registry.append(VERT_ACG_OPTIONS)\nSHEAR_FORCE_OPTIONS = DeSerializerOptions(\n metadata=PrintMetadata(\n long_name=\"Transverse shear force\",\n abreviation=NoEscape(r\"T\\textsubscript{bt}\"),\n units=\"kN\",\n )\n)\nabv_registry.append(SHEAR_FORCE_OPTIONS)\nTRANSVERSE_BENDING_MOMENT_OPTIONS = DeSerializerOptions(\n metadata=PrintMetadata(\n long_name=\"Transverse bending moment\",\n abreviation=NoEscape(r\"M\\textsubscript{bt}\"),\n units=\"kN*m\",\n )\n)\nabv_registry.append(TRANSVERSE_BENDING_MOMENT_OPTIONS)\nTRANSVERSE_TORSIONAL_MOMENT_OPTIONS = DeSerializerOptions(\n metadata=PrintMetadata(\n long_name=\"Transverse torsional moment\",\n abreviation=NoEscape(r\"M\\textsubscript{tt}\"),\n units=\"kN*m\",\n )\n)\nabv_registry.append(TRANSVERSE_TORSIONAL_MOMENT_OPTIONS)\n\n\n@dataclass\nclass VesselLoads:\n vert_acg: float = field(metadata={DESERIALIZER_OPTIONS: VERT_ACG_OPTIONS})\n shear_force: float = field(metadata={DESERIALIZER_OPTIONS: SHEAR_FORCE_OPTIONS})\n trans_bend_moment: float = field(\n metadata={DESERIALIZER_OPTIONS: TRANSVERSE_BENDING_MOMENT_OPTIONS}\n )\n trans_tors_moment: float = field(\n metadata={DESERIALIZER_OPTIONS: TRANSVERSE_TORSIONAL_MOMENT_OPTIONS}\n )\n\n\n@dataclass\nclass Monohull:\n \"\"\"Vessel for the 2012 German Lloyds High Speed Craft\n scantling rules.\n \"\"\"\n\n name: str = field(metadata={DESERIALIZER_OPTIONS: NAME_OPTIONS})\n speed: float = field(metadata={DESERIALIZER_OPTIONS: SPEED_OPTIONS})\n displacement: float = field(metadata={DESERIALIZER_OPTIONS: DISPLACEMENT_OPTIONS})\n length: float = field(metadata={DESERIALIZER_OPTIONS: LENGTH_OPTIONS})\n beam: float = field(metadata={DESERIALIZER_OPTIONS: BEAM_OPTIONS})\n fwd_perp: float = field(metadata={DESERIALIZER_OPTIONS: FWD_PERP_OPTIONS})\n aft_perp: float = field(metadata={DESERIALIZER_OPTIONS: AFT_PERP_OPTIONS})\n draft: float = field(metadata={DESERIALIZER_OPTIONS: DRAFT_OPTIONS})\n z_baseline: float = field(metadata={DESERIALIZER_OPTIONS: Z_BASELINE_OPTIONS})\n block_coef: float = field(metadata={DESERIALIZER_OPTIONS: BLOCK_COEF_OPTIONS})\n water_plane_area: float = field(\n metadata={DESERIALIZER_OPTIONS: WATER_PLANE_AREA_OPTIONS}\n )\n lcg: float = field(metadata={DESERIALIZER_OPTIONS: LCG_OPTIONS})\n deadrise_lcg: float = field(metadata={DESERIALIZER_OPTIONS: DEADRISE_LCG_OPTIONS})\n\n type_of_service: TypeOfService = field(\n metadata={DESERIALIZER_OPTIONS: TYPE_OF_SERVICE_OPTIONS},\n default=TypeOfService.PASSENGER,\n )\n service_range: ServiceRange = field(\n metadata={DESERIALIZER_OPTIONS: SERVICE_RANGE_OPTIONS},\n default=ServiceRange.USR,\n )\n\n # Table C3.3.1\n @property\n def serv_type_coef(self):\n table = {\n TypeOfService.PASSENGER: 0.24,\n TypeOfService.FERRY: 0.24,\n TypeOfService.CARGO: 0.24,\n TypeOfService.SUPPLY: 0.36,\n TypeOfService.PILOT: 0.5,\n TypeOfService.RESCUE: 0.6,\n }\n return table[self.type_of_service]\n\n # Table C3.3.1\n @property\n def serv_range_coef(self):\n table = {\n ServiceRange.USR: 1.0,\n ServiceRange.RSA_200: 0.9,\n ServiceRange.RSA_50: 0.75,\n ServiceRange.RSA_20: 0.66,\n ServiceRange.RSA_SW: 0.6,\n }\n return table[self.service_range]\n\n @property\n def z_waterline(self):\n return self.z_baseline + self.draft\n\n @property\n def midship(self):\n return (self.fwd_perp + self.aft_perp) / 2\n\n @property\n def x_pos_cg(self):\n return (self.lcg - self.aft_perp) / (self.fwd_perp - self.aft_perp)\n\n @property\n def sp_len_ratio(self) -> float:\n return self.speed / self.length**0.5\n\n # C3.3.1\n @property\n def vert_acg(self):\n \"\"\"Vertical acceletation at LCGm, output in g (9.81 m/s2)\"\"\"\n acg = self.serv_type_coef * self.serv_range_coef * self.sp_len_ratio\n if self.type_of_service == TypeOfService.PASSENGER:\n return min([1.0, acg])\n return acg\n\n @property\n def max_wave_height(self):\n \"\"\"C3.3.3 Assessment of limit operating conditions\"\"\"\n return (\n 5\n * np.max([self.vert_acg, 1])\n / self.speed\n * self.length**1.5\n / (6 + 0.14 * self.length)\n )\n\n @property\n def sig_wave_height(self):\n \"\"\"C3.3.3.2 Limitation imposed by vertical acceleration at LCG\"\"\"\n return 10.9 * self.vert_acg * self.coef_kcat * self.coef_kh / self.coef_kf**2\n\n # C3.3.3.2\n @property\n def coef_kcat(self):\n return 1.0\n\n # C3.3.3.2\n @property\n def coef_kf(self):\n return 3.23 / self.length * (2.43 * self.length**0.5 + self.speed)\n\n # C3.3.3.2\n @property\n def coef_kt(self):\n return (\n 4.6 * self.water_plane_area / self.displacement * (self.x_pos_cg) ** 0.5\n ) ** 0.5\n\n # C3.3.3.2\n @property\n def coef_k(self):\n return self.coef_kf / self.coef_kt\n\n # C3.3.3.2\n @property\n def coef_kh(self):\n return self.coef_k**0.35 * ((1 / self.coef_k**2 - 0.11) ** 2 + 1) ** 0.5\n\n\n@dataclass\nclass Catamaran(Monohull):\n dist_hull_cl: float = field(\n metadata={DESERIALIZER_OPTIONS: DIST_HULL_CL_OPTIONS}, default=0\n )\n\n # C3.3.3.2\n @property\n def coef_kcat(self):\n return np.max(\n [1 + (self.dist_hull_cl - self.max_wave_height) / self.length, 1.0]\n )\n\n # C3.4.2.3\n @property\n def transverse_bending_moment(self):\n \"\"\"Transverse bending moment in kN*m.\"\"\"\n return self.displacement * self.dist_hull_cl * self.vert_acg * GRAVITY / 5\n\n # C3.4.2.3\n @property\n def transverse_shear_force(self):\n \"\"\"Transverse shear force in kN.\"\"\"\n return self.displacement * self.vert_acg * GRAVITY / 4\n\n # C3.4.2.4\n @property\n def transverse_torsional_moment(self):\n \"\"\"Transverse torsional moment in kN*m.\"\"\"\n return 0.125 * self.displacement * self.length * self.vert_acg * GRAVITY\n\n @property\n def loads_names(self):\n return [\n \"vert_acg\",\n \"shear_force\",\n \"transverse_bending_moment\",\n \"transverse_torsional_moment\",\n ]\n\n @property\n def loads_asdict(self):\n loads = VesselLoads(\n vert_acg=self.vert_acg,\n shear_force=self.transverse_shear_force,\n trans_bend_moment=self.transverse_bending_moment,\n trans_tors_moment=self.transverse_torsional_moment,\n )\n return serialize_dataclass(loads, printing_format=True, include_names=True)\n", "meta": {"hexsha": "d0a5624aaad5851f34f03539dafecbe8ec681e77", "size": 11202, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/gl_hsc_scantling/vessel.py", "max_stars_repo_name": "ruy-sevalho/german_lloyds_hsc_rules", "max_stars_repo_head_hexsha": "ac65158ddfeca0b96487c4959476256e83981d3f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/gl_hsc_scantling/vessel.py", "max_issues_repo_name": "ruy-sevalho/german_lloyds_hsc_rules", "max_issues_repo_head_hexsha": "ac65158ddfeca0b96487c4959476256e83981d3f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/gl_hsc_scantling/vessel.py", "max_forks_repo_name": "ruy-sevalho/german_lloyds_hsc_rules", "max_forks_repo_head_hexsha": "ac65158ddfeca0b96487c4959476256e83981d3f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.4789473684, "max_line_length": 86, "alphanum_fraction": 0.6727370112, "include": true, "reason": "import numpy", "num_tokens": 3054, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792043, "lm_q2_score": 0.3738758367247085, "lm_q1q2_score": 0.18985858565612163}} {"text": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n################################################################################\n#\n# RMG - Reaction Mechanism Generator\n#\n# Copyright (c) 2002-2009 Prof. William H. Green (whgreen@mit.edu) and the\n# RMG Team (rmg_dev@mit.edu)\n#\n# Permission is hereby granted, free of charge, to any person obtaining a\n# copy of this software and associated documentation files (the \"Software\"),\n# to deal in the Software without restriction, including without limitation\n# the rights to use, copy, modify, merge, publish, distribute, sublicense,\n# and/or sell copies of the Software, and to permit persons to whom the\n# Software is furnished to do so, subject to the following conditions:\n#\n# The above copyright notice and this permission notice shall be included in\n# all copies or substantial portions of the Software.\n#\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL\n# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n# DEALINGS IN THE SOFTWARE.\n#\n################################################################################\n\n\"\"\"\nThis module provides the :class:`StatMechJob` class, which represents a\nstatistical mechanics job used to compute and save the statistical mechanics\ninformation for a single species or transition state.\n\"\"\"\n\nimport os.path\nimport math\nimport numpy\nimport logging\n\nimport rmgpy.constants as constants\nfrom rmgpy.cantherm.output import prettify\nfrom rmgpy.cantherm.gaussian import GaussianLog\nfrom rmgpy.cantherm.molepro import MoleProLog\nfrom rmgpy.species import TransitionState\nfrom rmgpy.statmech import *\n\n################################################################################\n\nclass InputError(Exception):\n \"\"\"\n An exception raised when parsing an input file for a conformer. Pass a\n string describing the error.\n \"\"\"\n pass\n\n################################################################################\n\nclass ScanLog:\n \"\"\"\n Represent a text file containing a table of angles and corresponding\n scan energies.\n \"\"\"\n\n angleFactors = {\n 'radians': 1.0,\n 'rad': 1.0,\n 'degrees': 180.0 / math.pi,\n 'deg': 180.0 / math.pi,\n }\n energyFactors = {\n 'J/mol': 1.0,\n 'kJ/mol': 1.0/1000.,\n 'cal/mol': 1.0/4.184,\n 'kcal/mol': 1.0/4184.,\n 'cm^-1': 1.0/(constants.h * constants.c * 100. * constants.Na),\n 'hartree': 1.0/(constants.E_h * constants.Na),\n }\n \n def __init__(self, path):\n self.path = path\n\n def load(self):\n \"\"\"\n Load the scan energies from the file. Returns arrays containing the\n angles (in radians) and energies (in J/mol).\n \"\"\"\n angles = []; energies = []\n angleUnits = None; energyUnits = None\n angleFactor = None; energyFactor = None\n \n with open(self.path, 'r') as stream:\n for line in stream:\n line = line.strip()\n if line == '': continue\n \n tokens = line.split()\n if angleUnits is None or energyUnits is None:\n angleUnits = tokens[1][1:-1]\n energyUnits = tokens[3][1:-1]\n \n try:\n angleFactor = ScanLog.angleFactors[angleUnits]\n except KeyError:\n raise ValueError('Invalid angle units {0!r}.'.format(angleUnits))\n try:\n energyFactor = ScanLog.energyFactors[energyUnits]\n except KeyError:\n raise ValueError('Invalid energy units {0!r}.'.format(energyUnits))\n \n else:\n angles.append(float(tokens[0]) / angleFactor)\n energies.append(float(tokens[1]) / energyFactor)\n \n angles = numpy.array(angles)\n energies = numpy.array(energies)\n energies -= energies[0]\n \n return angles, energies\n \n def save(self, angles, energies, angleUnits='radians', energyUnits='kJ/mol'):\n \"\"\"\n Save the scan energies to the file using the given `angles` in radians\n and corresponding energies `energies` in J/mol. The file is created to\n use the given `angleUnits` for angles and `energyUnits` for energies.\n \"\"\"\n assert len(angles) == len(energies)\n \n try:\n angleFactor = ScanLog.angleFactors[angleUnits]\n except KeyError:\n raise ValueError('Invalid angle units {0!r}.'.format(angleUnits))\n try:\n energyFactor = ScanLog.energyFactors[energyUnits]\n except KeyError:\n raise ValueError('Invalid energy units {0!r}.'.format(energyUnits))\n \n with open(self.path, 'w') as stream:\n stream.write('{0:>24} {1:>24}\\n'.format(\n 'Angle ({0})'.format(angleUnits),\n 'Energy ({0})'.format(energyUnits),\n ))\n for angle, energy in zip(angles, energies):\n stream.write('{0:23.10f} {1:23.10f}\\n'.format(angle * angleFactor, energy * energyFactor))\n\n################################################################################\n\ndef hinderedRotor(scanLog, pivots, top, symmetry, fit='best'):\n return [scanLog, pivots, top, symmetry, fit]\n\nclass StatMechJob:\n \"\"\"\n A representation of a CanTherm statistical mechanics job. This job is used\n to compute and save the statistical mechanics information for a single\n species or transition state.\n \"\"\"\n \n def __init__(self, species, path):\n self.species = species\n self.path = path\n self.modelChemistry = ''\n self.frequencyScaleFactor = 1.0\n self.includeHinderedRotors = True\n self.applyBondEnergyCorrections = True\n \n def execute(self, outputFile=None, plot=False):\n \"\"\"\n Execute the statistical mechanics job, saving the results to the\n given `outputFile` on disk.\n \"\"\"\n self.load()\n if outputFile is not None:\n self.save(outputFile)\n \n def load(self):\n \"\"\"\n Load the statistical mechanics parameters for each conformer from\n the associated files on disk. Creates :class:`Conformer` objects for\n each conformer and appends them to the list of confomers on the\n species object.\n \"\"\"\n logging.info('Loading statistical mechanics parameters for {0}...'.format(self.species.label))\n \n path = self.path\n \n TS = isinstance(self.species, TransitionState)\n \n global_context = {\n '__builtins__': None,\n }\n local_context = {\n '__builtins__': None,\n 'True': True,\n 'False': False,\n 'HinderedRotor': hinderedRotor,\n # File formats\n 'GaussianLog': GaussianLog,\n 'MoleProLog': MoleProLog,\n 'ScanLog': ScanLog,\n }\n \n directory = os.path.abspath(os.path.dirname(path))\n \n with open(path, 'r') as f:\n try:\n exec f in global_context, local_context\n except (NameError, TypeError, SyntaxError), e:\n logging.error('The species file {0} was invalid:'.format(path))\n raise\n \n try:\n atoms = local_context['atoms']\n except KeyError:\n raise InputError('Required attribute \"atoms\" not found in species file {0!r}.'.format(path))\n \n try:\n bonds = local_context['bonds']\n except KeyError:\n bonds = {}\n \n try:\n linear = local_context['linear']\n except KeyError:\n raise InputError('Required attribute \"linear\" not found in species file {0!r}.'.format(path))\n \n try:\n externalSymmetry = local_context['externalSymmetry']\n except KeyError:\n raise InputError('Required attribute \"externalSymmetry\" not found in species file {0!r}.'.format(path))\n \n try:\n spinMultiplicity = local_context['spinMultiplicity']\n except KeyError:\n raise InputError('Required attribute \"spinMultiplicity\" not found in species file {0!r}.'.format(path))\n \n try:\n opticalIsomers = local_context['opticalIsomers']\n except KeyError:\n raise InputError('Required attribute \"opticalIsomers\" not found in species file {0!r}.'.format(path))\n \n try:\n energy = local_context['energy']\n except KeyError:\n raise InputError('Required attribute \"energy\" not found in species file {0!r}.'.format(path))\n if isinstance(energy, dict):\n try:\n energy = energy[self.modelChemistry]\n except KeyError:\n raise InputError('Model chemistry {0!r} not found in from dictionary of energy values in species file {1!r}.'.format(self.modelChemistry, path))\n if isinstance(energy, GaussianLog):\n energyLog = energy; E0 = 'Gaussian'\n energyLog.path = os.path.join(directory, energyLog.path)\n if isinstance(energy, MoleProLog):\n energyLog = energy; E0 = 'MolePro'\n energyLog.path = os.path.join(directory, energyLog.path)\n elif isinstance(energy, float):\n energyLog = None; E0 = energy\n \n try:\n geomLog = local_context['geometry']\n except KeyError:\n raise InputError('Required attribute \"geometry\" not found in species file {0!r}.'.format(path))\n geomLog.path = os.path.join(directory, geomLog.path)\n \n try:\n statmechLog = local_context['frequencies']\n except KeyError:\n raise InputError('Required attribute \"frequencies\" not found in species file {0!r}.'.format(path))\n statmechLog.path = os.path.join(directory, statmechLog.path)\n \n if 'frequencyScaleFactor' in local_context:\n logging.warning('Ignoring frequency scale factor in species file {0!r}.'.format(path))\n \n try:\n rotors = local_context['rotors']\n except KeyError:\n rotors = []\n \n # But don't consider hindered rotors if flag is not set\n if not self.includeHinderedRotors:\n rotors = []\n \n logging.debug(' Reading molecular degrees of freedom...')\n conformer = statmechLog.loadConformer(symmetry=externalSymmetry, spinMultiplicity=spinMultiplicity, opticalIsomers=opticalIsomers)\n \n logging.debug(' Reading optimized geometry...')\n coordinates, number, mass = geomLog.loadGeometry()\n conformer.coordinates = (coordinates,\"angstroms\") \n conformer.number = number\n conformer.mass = (mass,\"amu\")\n \n logging.debug(' Reading energy...')\n # The E0 that is read from the log file is without the ZPE and corresponds to E_elec\n if E0 is 'Gaussian':\n E0 = energyLog.loadEnergy(self.frequencyScaleFactor)\n elif E0 is 'MolePro':\n E0 = energyLog.loadCCSDEnergy()\n else:\n E0 = E0 * constants.E_h * constants.Na # Hartree/particle to J/mol\n E0 = applyEnergyCorrections(E0, self.modelChemistry, atoms, bonds if self.applyBondEnergyCorrections else {})\n ZPE = statmechLog.loadZeroPointEnergy() * self.frequencyScaleFactor\n \n # The E0_withZPE at this stage contains the ZPE\n E0_withZPE = E0 + ZPE\n \n logging.debug(' Scaling factor used = {0:g}'.format(self.frequencyScaleFactor))\n logging.debug(' ZPE (0 K) = {0:g} kcal/mol'.format(ZPE / 4184.))\n logging.debug(' E0 (0 K) = {0:g} kcal/mol'.format(E0_withZPE / 4184.))\n \n conformer.E0 = (E0_withZPE*0.001,\"kJ/mol\")\n \n # If loading a transition state, also read the imaginary frequency\n if TS:\n self.species.frequency = (statmechLog.loadNegativeFrequency() * self.frequencyScaleFactor, \"cm^-1\")\n\n # Read and fit the 1D hindered rotors if applicable\n # If rotors are found, the vibrational frequencies are also\n # recomputed with the torsional modes removed\n F = statmechLog.loadForceConstantMatrix()\n if F is not None and len(mass) > 1 and len(rotors) > 0:\n \n logging.debug(' Fitting {0} hindered rotors...'.format(len(rotors)))\n rotorCount = 0\n for scanLog, pivots, top, symmetry, fit in rotors:\n \n # Load the hindered rotor scan energies\n if isinstance(scanLog, GaussianLog):\n scanLog.path = os.path.join(directory, scanLog.path)\n Vlist, angle = scanLog.loadScanEnergies()\n scanLogOutput = ScanLog(os.path.join(directory, '{0}_rotor_{1}.txt'.format(self.species.label, rotorCount+1)))\n scanLogOutput.save(angle, Vlist)\n elif isinstance(scanLog, ScanLog):\n scanLog.path = os.path.join(directory, scanLog.path)\n angle, Vlist = scanLog.load()\n else:\n raise Exception('Invalid log file type {0} for scan log.'.format(scanLog.__class__))\n \n inertia = conformer.getInternalReducedMomentOfInertia(pivots, top) * constants.Na * 1e23\n \n cosineRotor = HinderedRotor(inertia=(inertia,\"amu*angstrom^2\"), symmetry=symmetry)\n cosineRotor.fitCosinePotentialToData(angle, Vlist)\n fourierRotor = HinderedRotor(inertia=(inertia,\"amu*angstrom^2\"), symmetry=symmetry)\n fourierRotor.fitFourierPotentialToData(angle, Vlist)\n \n Vlist_cosine = numpy.zeros_like(angle)\n Vlist_fourier = numpy.zeros_like(angle)\n for i in range(angle.shape[0]):\n Vlist_cosine[i] = cosineRotor.getPotential(angle[i])\n Vlist_fourier[i] = fourierRotor.getPotential(angle[i])\n \n if fit=='cosine':\n rotor=cosineRotor\n elif fit =='fourier':\n rotor=fourierRotor\n elif fit =='best':\n \n rms_cosine = numpy.sqrt(numpy.sum((Vlist_cosine - Vlist) * (Vlist_cosine - Vlist)) / (len(Vlist) - 1)) / 4184.\n rms_fourier = numpy.sqrt(numpy.sum((Vlist_fourier - Vlist) * (Vlist_fourier - Vlist))/ (len(Vlist) - 1)) / 4184.\n \n # Keep the rotor with the most accurate potential\n rotor = cosineRotor if rms_cosine < rms_fourier else fourierRotor\n # However, keep the cosine rotor if it is accurate enough, the\n # fourier rotor is not significantly more accurate, and the cosine\n # rotor has the correct symmetry \n if rms_cosine < 0.05 and rms_cosine / rms_fourier < 2.0 and rms_cosine / rms_fourier < 4.0 and symmetry == cosineRotor.symmetry:\n rotor = cosineRotor\n \n conformer.modes.append(rotor)\n \n self.plotHinderedRotor(angle, Vlist, cosineRotor, fourierRotor, rotor, rotorCount, directory)\n \n rotorCount += 1\n \n logging.debug(' Determining frequencies from reduced force constant matrix...')\n frequencies = numpy.array(projectRotors(conformer, F, rotors, linear, TS))\n \n elif len(conformer.modes) > 2:\n frequencies = conformer.modes[2].frequencies.value_si\n rotors = numpy.array([])\n else:\n frequencies = numpy.array([])\n rotors = numpy.array([])\n \n for mode in conformer.modes:\n if isinstance(mode, HarmonicOscillator):\n mode.frequencies = (frequencies * self.frequencyScaleFactor,\"cm^-1\")\n \n self.species.conformer = conformer\n \n def save(self, outputFile):\n \"\"\"\n Save the results of the statistical mechanics job to the file located\n at `path` on disk.\n \"\"\"\n \n logging.info('Saving statistical mechanics parameters for {0}...'.format(self.species.label))\n f = open(outputFile, 'a')\n \n numbers = {1: 'H', 6: 'C', 7: 'N', 8: 'O', 14: 'Si', 15: 'P', 16: 'S', 17: 'Cl'}\n \n conformer = self.species.conformer\n \n coordinates = conformer.coordinates.value_si * 1e10\n number = conformer.number.value_si\n \n f.write('# Coordinates for {0} (angstroms):\\n'.format(self.species.label))\n for i in range(coordinates.shape[0]):\n x = coordinates[i,0] - coordinates[0,0]\n y = coordinates[i,1] - coordinates[0,1]\n z = coordinates[i,2] - coordinates[0,2]\n f.write('# {0} {1:9.4f} {2:9.4f} {3:9.4f}\\n'.format(numbers[number[i]], x, y, z))\n \n string = 'conformer(label={0!r}, E0={1!r}, modes={2!r}, spinMultiplicity={3:d}, opticalIsomers={4:d}'.format(\n self.species.label, \n conformer.E0,\n conformer.modes,\n conformer.spinMultiplicity,\n conformer.opticalIsomers,\n )\n try:\n string += ', frequency={0!r}'.format(self.species.frequency)\n except AttributeError: pass\n string += ')'\n \n f.write('{0}\\n\\n'.format(prettify(string)))\n \n f.close()\n\n def plotHinderedRotor(self, angle, Vlist, cosineRotor, fourierRotor, rotor, rotorIndex, directory):\n \"\"\"\n Plot the potential for the rotor, along with its cosine and Fourier\n series potential fits. The plot is saved to a set of files of the form\n ``hindered_rotor_1.pdf``.\n \"\"\"\n try:\n import pylab\n except ImportError:\n return\n \n phi = numpy.arange(0, 6.3, 0.02, numpy.float64)\n Vlist_cosine = numpy.zeros_like(phi)\n Vlist_fourier = numpy.zeros_like(phi)\n for i in range(phi.shape[0]):\n Vlist_cosine[i] = cosineRotor.getPotential(phi[i])\n Vlist_fourier[i] = fourierRotor.getPotential(phi[i])\n \n fig = pylab.figure(figsize=(6,5))\n pylab.plot(angle, Vlist / 4184., 'ok')\n linespec = '-r' if rotor is cosineRotor else '--r'\n pylab.plot(phi, Vlist_cosine / 4184., linespec)\n linespec = '-b' if rotor is fourierRotor else '--b'\n pylab.plot(phi, Vlist_fourier / 4184., linespec)\n pylab.legend(['scan', 'cosine', 'fourier'], loc=1)\n pylab.xlim(0, 2*constants.pi)\n pylab.xlabel('Angle')\n pylab.ylabel('Potential (kcal/mol)')\n pylab.title('{0} hindered rotor #{1:d}'.format(self.species.label, rotorIndex+1))\n \n axes = fig.get_axes()[0]\n axes.set_xticks([float(j*constants.pi/4) for j in range(0,9)])\n axes.set_xticks([float(j*constants.pi/8) for j in range(0,17)], minor=True)\n axes.set_xticklabels(['$0$', '$\\pi/4$', '$\\pi/2$', '$3\\pi/4$', '$\\pi$', '$5\\pi/4$', '$3\\pi/2$', '$7\\pi/4$', '$2\\pi$'])\n \n pylab.savefig(os.path.join(directory, '{0}_rotor_{1:d}.pdf'.format(self.species.label, rotorIndex+1)))\n pylab.close()\n\n################################################################################\n\ndef applyEnergyCorrections(E0, modelChemistry, atoms, bonds):\n \"\"\"\n Given an energy `E0` in J/mol as read from the output of a quantum chemistry\n calculation at a given `modelChemistry`, adjust the energy such that it\n is consistent with the normal gas-phase reference states. `atoms` is a\n dictionary associating element symbols with the number of that element in\n the molecule. `bonds` is a dictionary associating bond types with the number\n of that bond in the molecule.\n \"\"\"\n \n # Spin orbit correction (SOC) in Hartrees\n # Values taken from note 22 of http://jcp.aip.org/resource/1/jcpsa6/v109/i24/p10570_s1 and converted to hartrees\n # Values in millihartree are also available (with fewer significant figures) from http://jcp.aip.org/resource/1/jcpsa6/v106/i3/p1063_s1\n SOC = {'H':0.0, 'N':0.0, 'O': -0.000355, 'C': -0.000135, 'S': -0.000893, 'P': 0.0, 'Cl': -0.001338} \n \n # Step 1: Reference all energies to a model chemistry-independent basis\n # by subtracting out that model chemistry's atomic energies\n # Note: If your model chemistry does not include spin orbit coupling, you should add the corrections to the energies here\n if modelChemistry == 'CBS-QB3':\n # 0K Energy\n atomEnergies = {'H':-0.499818 , 'N':-54.520543, 'O':-74.987624, 'C':-37.785385, 'P':-340.817186, 'S': -397.657360, 'Cl': -459.683605}\n elif modelChemistry == 'G3':\n atomEnergies = {'H':-0.5010030, 'N':-54.564343, 'O':-75.030991, 'C':-37.827717, 'P':-341.116432, 'S': -397.961110}\n\n elif modelChemistry == 'Klip_1':\n atomEnergies = {'H':-0.50003976 + SOC['H'], 'N':-54.53383153 + SOC['N'], 'O':-75.00935474 + SOC['O'], 'C':-37.79266591 + SOC['C']}\n elif modelChemistry == 'Klip_2':\n #Klip QCI(tz,qz)\n atomEnergies = {'H':-0.50003976 + SOC['H'], 'N':-54.53169400 + SOC['N'], 'O':-75.00714902 + SOC['O'], 'C':-37.79060419 + SOC['C']}\n elif modelChemistry == 'Klip_3':\n #Klip QCI(dz,tz)\n atomEnergies = {'H':-0.50005578 + SOC['H'], 'N':-54.53128140 + SOC['N'], 'O':-75.00356581 + SOC['O'], 'C':-37.79025175 + SOC['C']}\n\n elif modelChemistry == 'Klip_2_cc':\n #Klip CCSD(T)(tz,qz)\n atomEnergies = {'H':-0.50003976 + SOC['H'], 'O':-75.00681155 + SOC['O'], 'C':-37.79029443 + SOC['C']}\n\n elif modelChemistry == 'CCSD(T)-F12/cc-pVDZ-F12_H-TZ':\n atomEnergies = {'H':-0.499946213243 + SOC['H'], 'N':-54.526406291655 + SOC['N'], 'O':-74.995458316117 + SOC['O'], 'C':-37.788203485235 + SOC['C']}\n elif modelChemistry == 'CCSD(T)-F12/cc-pVDZ-F12_H-QZ':\n atomEnergies = {'H':-0.499994558325 + SOC['H'], 'N':-54.526406291655 + SOC['N'], 'O':-74.995458316117 + SOC['O'], 'C':-37.788203485235 + SOC['C']}\n\n elif modelChemistry == 'CCSD(T)-F12/cc-pVDZ-F12':\n atomEnergies = {'H':-0.499811124128 + SOC['H'], 'N':-54.526406291655 + SOC['N'], 'O':-74.995458316117 + SOC['O'], 'C':-37.788203485235 + SOC['C']}\n elif modelChemistry == 'CCSD(T)-F12/cc-pVTZ-F12':\n atomEnergies = {'H':-0.499946213243 + SOC['H'], 'N':-54.53000909621 + SOC['N'], 'O':-75.004127673424 + SOC['O'], 'C':-37.789862146471 + SOC['C']}\n elif modelChemistry == 'CCSD(T)-F12/cc-pVQZ-F12':\n atomEnergies = {'H':-0.499994558325 + SOC['H'], 'N':-54.530515226371 + SOC['N'], 'O':-75.005600062003 + SOC['O'], 'C':-37.789961656228 + SOC['C']}\n \n elif modelChemistry == 'CCSD(T)-F12/cc-pCVDZ-F12':\n atomEnergies = {'H':-0.499811124128 + SOC['H'], 'N':-54.582137180344 + SOC['N'], 'O':-75.053045547421 + SOC['O'], 'C':-37.840869118707 + SOC['C']}\n elif modelChemistry == 'CCSD(T)-F12/cc-pCVTZ-F12':\n atomEnergies = {'H':-0.499946213243 + SOC['H'], 'N':-54.588545831900 + SOC['N'], 'O':-75.065995072347 + SOC['O'], 'C':-37.844662139972 + SOC['C']}\n elif modelChemistry == 'CCSD(T)-F12/cc-pCVQZ-F12':\n atomEnergies = {'H':-0.499994558325 + SOC['H'], 'N':-54.589137594139 + SOC['N'], 'O':-75.067412234737 + SOC['O'], 'C':-37.844893820561 + SOC['C']}\n\n elif modelChemistry == 'CCSD(T)-F12/aug-cc-pVDZ':\n atomEnergies = {'H':-0.499459066131 + SOC['H'], 'N':-54.524279516472 + SOC['N'], 'O':-74.992097308083 + SOC['O'], 'C':-37.786694171716 + SOC['C']}\n elif modelChemistry == 'CCSD(T)-F12/aug-cc-pVTZ':\n atomEnergies = {'H':-0.499844820798 + SOC['H'], 'N':-54.527419359906 + SOC['N'], 'O':-75.000001429806 + SOC['O'], 'C':-37.788504810868 + SOC['C']}\n elif modelChemistry == 'CCSD(T)-F12/aug-cc-pVQZ':\n atomEnergies = {'H':-0.499949526073 + SOC['H'], 'N':-54.529569719016 + SOC['N'], 'O':-75.004026586610 + SOC['O'], 'C':-37.789387892348 + SOC['C']}\n\n\n elif modelChemistry == 'B-CCSD(T)-F12/cc-pVDZ-F12':\n atomEnergies = {'H':-0.499811124128 + SOC['H'], 'N':-54.523269942190 + SOC['N'], 'O':-74.990725918500 + SOC['O'], 'C':-37.785409916465 + SOC['C']}\n elif modelChemistry == 'B-CCSD(T)-F12/cc-pVTZ-F12':\n atomEnergies = {'H':-0.499946213243 + SOC['H'], 'N':-54.528135889213 + SOC['N'], 'O':-75.001094055506 + SOC['O'], 'C':-37.788233578503 + SOC['C']}\n elif modelChemistry == 'B-CCSD(T)-F12/cc-pVQZ-F12':\n atomEnergies = {'H':-0.499994558325 + SOC['H'], 'N':-54.529425753163 + SOC['N'], 'O':-75.003820485005 + SOC['O'], 'C':-37.789006506290 + SOC['C']}\n \n elif modelChemistry == 'B-CCSD(T)-F12/cc-pCVDZ-F12':\n atomEnergies = {'H':-0.499811124128 + SOC['H'], 'N':-54.578602780288 + SOC['N'], 'O':-75.048064317367 + SOC['O'], 'C':-37.837592033417 + SOC['C']}\n elif modelChemistry == 'B-CCSD(T)-F12/cc-pCVTZ-F12':\n atomEnergies = {'H':-0.499946213243 + SOC['H'], 'N':-54.586402551258 + SOC['N'], 'O':-75.062767632757 + SOC['O'], 'C':-37.842729156944 + SOC['C']}\n elif modelChemistry == 'B-CCSD(T)-F12/cc-pCVQZ-F12':\n atomEnergies = {'H':-0.49999456 + SOC['H'], 'N':-54.587781507581 + SOC['N'], 'O':-75.065397706471 + SOC['O'], 'C':-37.843634971592 + SOC['C']}\n\n elif modelChemistry == 'B-CCSD(T)-F12/aug-cc-pVDZ':\n atomEnergies = {'H':-0.499459066131 + SOC['H'], 'N':-54.520475581942 + SOC['N'], 'O':-74.986992215049 + SOC['O'], 'C':-37.783294495799 + SOC['C']}\n elif modelChemistry == 'B-CCSD(T)-F12/aug-cc-pVTZ':\n atomEnergies = {'H':-0.499844820798 + SOC['H'], 'N':-54.524927371700 + SOC['N'], 'O':-74.996328829705 + SOC['O'], 'C':-37.786320700792 + SOC['C']}\n elif modelChemistry == 'B-CCSD(T)-F12/aug-cc-pVQZ':\n atomEnergies = {'H':-0.499949526073 + SOC['H'], 'N':-54.528189769291 + SOC['N'], 'O':-75.001879610563 + SOC['O'], 'C':-37.788165047059 + SOC['C']}\n\n\n elif modelChemistry == 'DFT_ks_b3lyp':\n atomEnergies = {'H':-0.49785866 + SOC['H'], 'N':-54.45608798 + SOC['N'], 'O':-74.93566254 + SOC['O'], 'C':-37.76119132 + SOC['C']}\n elif modelChemistry == 'DFT_uks_b3lyp':\n atomEnergies = {'H':-0.49785866 + SOC['H'], 'N':-54.45729113 + SOC['N'], 'O':-74.93566254 + SOC['O'], 'C':-37.76119132 + SOC['C']}\n\n elif modelChemistry == 'MP2_rmp2_pVDZ':\n atomEnergies = {'H':-0.49927840 + SOC['H'], 'N':-54.46141996 + SOC['N'], 'O':-74.89408254 + SOC['O'], 'C':-37.73792713 + SOC['C']}\n elif modelChemistry == 'MP2_rmp2_pVTZ':\n atomEnergies = {'H':-0.49980981 + SOC['H'], 'N':-54.49615972 + SOC['N'], 'O':-74.95506980 + SOC['O'], 'C':-37.75833104 + SOC['C']}\n elif modelChemistry == 'MP2_rmp2_pVQZ':\n atomEnergies = {'H':-0.49994557 + SOC['H'], 'N':-54.50715868 + SOC['N'], 'O':-74.97515364 + SOC['O'], 'C':-37.76533215 + SOC['C']}\n\n elif modelChemistry == 'CCSD_DZ':\n atomEnergies = {'H':-0.499811124 + SOC['H'], 'N':-54.52640629 + SOC['N'], 'O':-74.99545832 + SOC['O'], 'C':-37.78820349 + SOC['C']}\n elif modelChemistry == 'CCSD_TZ':\n atomEnergies = {'H':-0.499946213 + SOC['H'], 'N':-54.5300091 + SOC['N'], 'O':-75.00412767 + SOC['O'], 'C':-37.78986215 + SOC['C']}\n elif modelChemistry == 'CCSD_QZ':\n atomEnergies = {'H':-0.499994558 + SOC['H'], 'N':-54.53051523 + SOC['N'], 'O':-75.00560006 + SOC['O'], 'C':-37.78996166 + SOC['C']}\n elif modelChemistry == 'CCSD_core_DZ':\n atomEnergies = {'H':-0.499811124 + SOC['H'], 'N':-54.58213718 + SOC['N'], 'O':-75.05304555 + SOC['O'], 'C':-37.84086912 + SOC['C']}\n elif modelChemistry == 'BMK/cbsb7':\n atomEnergies = {'H':-0.498618853119+ SOC['H'], 'N':-54.5697851544+ SOC['N'], 'O':-75.0515210278+ SOC['O'], 'C':-37.8287310027+ SOC['C'], 'P':-341.167615941+ SOC['P'], 'S': -398.001619915+ SOC['S']}\n \n \n else:\n logging.warning('Unknown model chemistry \"{0}\"; not applying energy corrections.'.format(modelChemistry))\n return E0\n for symbol, count in atoms.items():\n if symbol in atomEnergies: E0 -= count * atomEnergies[symbol] * constants.E_h * constants.Na\n else:\n logging.warning('Ignored unknown atom type \"{0}\".'.format(symbol))\n \n # Step 2: Atom energy corrections to reach gas-phase reference state\n # Experimental enthalpy of formation at 0 K \n # See Gaussian thermo whitepaper at http://www.gaussian.com/g_whitepap/thermo.htm)\n # Note: these values are relatively old and some improvement may be possible by using newer values, particularly for carbon\n # However, care should be taken to ensure that they are compatible with the BAC values (if BACs are used)\n atomHf = {'H': 51.63 , 'N': 112.53 ,'O': 58.99 ,'C': 169.98, 'S': 65.66, 'Cl': 28.59 }\n # Thermal contribution to enthalpy Hss(298 K) - Hss(0 K) reported by Gaussian thermo whitepaper\n # This will be subtracted from the corresponding value in atomHf to produce an enthalpy used in calculating the enthalpy of formation at 298 K\n atomThermal = {'H': 1.01 , 'N': 1.04, 'O': 1.04 ,'C': 0.25, 'S': 1.05, 'Cl': 1.10 }\n # Total energy correction used to reach gas-phase reference state\n # Note: Spin orbit coupling no longer included in these energies, since some model chemistries include it automatically\n atomEnergies = {}\n for element in atomHf:\n atomEnergies[element] = atomHf[element] - atomThermal[element]\n for symbol, count in atoms.items():\n if symbol in atomEnergies: E0 += count * atomEnergies[symbol] * 4184.\n \n # Step 3: Bond additivity corrections\n if modelChemistry == 'CCSD(T)-F12/cc-pVDZ-F12':\n bondEnergies = { 'C-H': -0.56, 'C-C': -0.53, 'C=C': -1.90, 'C#C': -0.64,\n 'O-H': -0.34, 'C-O': -0.30, 'C=O': -0.92, 'O-O': 0.03, 'N-C': -0.49,\n 'N=C': -1.50, 'N#C': -3.54, 'N-O': 0.60, 'N_O': -0.17, 'N=O': -0.72,\n 'N-H': -0.75, 'N-N': -1.45, 'N=N': -1.98, 'N#N': -2.05,}\n else:\n # BAC corrections from Table IX in http://jcp.aip.org/resource/1/jcpsa6/v109/i24/p10570_s1 for CBS-Q method\n # H-Cl correction from CBS-QB3 enthalpy difference with Gurvich 1989, HF298=-92.31 kJ\n bondEnergies = { 'C-H': -0.11, 'C-C': -0.3, 'C=C': -0.08, 'C#C': -0.64,\n 'O-H': 0.02, 'C-O': 0.33, 'C=O': 0.55, 'N#N': -2.0, 'O=O': -0.2, \n 'H-H': 1.1, 'C#N': -0.89, 'C-S': 0.43, 'S=O': -0.78, 'C-Cl': 1.29,\n 'N-H': -0.42, 'C-N': -0.13, 'S-H': 0.00, 'H-Cl': 1.16 }\n\n for symbol, count in bonds.items():\n if symbol in bondEnergies: E0 += count * bondEnergies[symbol] * 4184.\n else:\n logging.warning('Ignored unknown bond type {0!r}.'.format(symbol))\n \n return E0\n\ndef projectRotors(conformer, F, rotors, linear, TS):\n \"\"\"\n For a given `conformer` with associated force constant matrix `F`, lists of\n rotor information `rotors`, `pivots`, and `top1`, and the linearity of the\n molecule `linear`, project out the nonvibrational modes from the force\n constant matrix and use this to determine the vibrational frequencies. The\n list of vibrational frequencies is returned in cm^-1.\n \"\"\"\n \n Nrotors = len(rotors)\n Natoms = len(conformer.mass.value)\n Nvib = 3 * Natoms - (5 if linear else 6) - Nrotors - (1 if (TS) else 0)\n mass = conformer.mass.value_si\n coordinates = conformer.coordinates.value_si\n \n if linear:\n D = numpy.zeros((Natoms*3,5+Nrotors), numpy.float64)\n else:\n D = numpy.zeros((Natoms*3,6+Nrotors), numpy.float64)\n\n for i in range(Natoms):\n # Projection vectors for translation\n D[3*i+0,0] = 1.0\n D[3*i+1,1] = 1.0\n D[3*i+2,2] = 1.0\n # Projection vectors for [external] rotation\n D[3*i:3*i+3,3] = numpy.array([0, -coordinates[i,2], coordinates[i,1]], numpy.float64)\n D[3*i:3*i+3,4] = numpy.array([coordinates[i,2], 0, -coordinates[i,0]], numpy.float64)\n if not linear:\n D[3*i:3*i+3,5] = numpy.array([-coordinates[i,1], coordinates[i,0], 0], numpy.float64)\n for i, rotor in enumerate(rotors):\n scanLog, pivots, top, symmetry, fit = rotor\n # Determine pivot atom\n if pivots[0] in top: pivot = pivots[0]\n elif pivots[1] in top: pivot = pivots[1]\n else: raise Exception('Could not determine pivot atom.')\n # Projection vectors for internal rotation\n e12 = coordinates[pivots[0]-1,:] - coordinates[pivots[1]-1,:]\n e12 /= numpy.linalg.norm(e12)\n for atom in top:\n e31 = coordinates[atom-1,:] - coordinates[pivot-1,:]\n D[3*(atom-1):3*(atom-1)+3,-Nrotors+i] = numpy.cross(e31, e12)\n\n # Make sure projection matrix is orthonormal\n import scipy.linalg\n D = scipy.linalg.orth(D)\n\n # Project out the non-vibrational modes from the force constant matrix\n P = numpy.dot(D, D.transpose())\n I = numpy.identity(Natoms*3, numpy.float64)\n F = numpy.dot(I - P, numpy.dot(F, I - P))\n\n # Generate mass-weighted force constant matrix\n # This converts the axes to mass-weighted Cartesian axes\n # Units of Fm are J/m^2*kg = 1/s^2\n Fm = F.copy()\n for i in range(Natoms):\n for j in range(Natoms):\n for u in range(3):\n for v in range(3):\n Fm[3*i+u,3*j+v] /= math.sqrt(mass[i] * mass[j])\n\n # Get eigenvalues of mass-weighted force constant matrix\n eig, V = numpy.linalg.eigh(Fm)\n eig.sort()\n\n # Convert eigenvalues to vibrational frequencies in cm^-1\n # Only keep the modes that don't correspond to translation, rotation, or internal rotation\n return numpy.sqrt(eig[-Nvib:]) / (2 * math.pi * constants.c * 100)\n", "meta": {"hexsha": "7cc125f20b2ff504d3bcd8637a84a57f9b16bda4", "size": 34119, "ext": "py", "lang": "Python", "max_stars_repo_path": "rmgpy/cantherm/statmech.py", "max_stars_repo_name": "vrlambert/RMG-Py", "max_stars_repo_head_hexsha": "0937b2e0a955dcf21b79674a4e89f43941c0dd85", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-11-15T10:30:48.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-15T10:30:48.000Z", "max_issues_repo_path": "rmgpy/cantherm/statmech.py", "max_issues_repo_name": "vrlambert/RMG-Py", "max_issues_repo_head_hexsha": "0937b2e0a955dcf21b79674a4e89f43941c0dd85", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "rmgpy/cantherm/statmech.py", "max_forks_repo_name": "vrlambert/RMG-Py", "max_forks_repo_head_hexsha": "0937b2e0a955dcf21b79674a4e89f43941c0dd85", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-02-22T01:16:13.000Z", "max_forks_repo_forks_event_max_datetime": "2019-02-22T01:16:13.000Z", "avg_line_length": 49.0920863309, "max_line_length": 205, "alphanum_fraction": 0.5805855975, "include": true, "reason": "import numpy,import scipy", "num_tokens": 9646, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792044, "lm_q2_score": 0.3738758227716966, "lm_q1q2_score": 0.1898585785706167}} {"text": "#!/usr/bin/env python\n#\n\n\"\"\" Library containing field information \"\"\"\nimport os, sys\nimport pandas\nimport numpy as np\nimport warnings\nfrom pandas import read_csv\nfrom astropy import units, coordinates, time\nimport matplotlib.pyplot as mpl\nfrom matplotlib.patches import Polygon\n\n\n\n\n_FIELD_SOURCE = os.path.dirname(os.path.realpath(__file__))+\"/data/ztf_fields.txt\"\nFIELD_DATAFRAME = read_csv(_FIELD_SOURCE, index_col=\"ID\")\nFIELDSNAMES = FIELD_DATAFRAME.index.values\n\n_CCD_COORDS = read_csv(os.path.dirname(os.path.realpath(__file__))+\"/data/ztf_ccd_layout.tbl\").rename(columns={\"CCD \":\"CCD\"}) # corner of each CCDS\n\nFIELD_COLOR = {1: \"C2\", 2: \"C3\", 3:\"C1\"}\nFIELD_CMAP = {1: mpl.cm.Greens, 2:mpl.cm.Reds, 3:mpl.cm.Oranges}\nFIELDNAME_COLOR = {\"zg\": \"C2\", \"zr\":\"C3\", \"zi\":\"C1\"}\n\n_PLOTORIGIN = 180\n\ndef _load_fields_geoserie_(inclccd=False):\n \"\"\" Loads the FIELDS_GEOSERIE global variable \n = Internal Tools =\n \"\"\"\n if not inclccd:\n global FIELDS_GEOSERIE\n else:\n global FIELD_CCDS_GEOSERIE\n \n try:\n from geopandas import geoseries\n except ImportError:\n warnings.warn(\"You do not have geopandas, Please run pip install geopandas.\")\n if not inclccd:\n FIELDS_GEOSERIE = None\n else:\n FIELD_CCDS_GEOSERIE = None \n return\n \n field_verts = get_field_vertices(fieldid=FIELDSNAMES, inclccd=inclccd, asdict=True, aspolygon=True)\n if not inclccd:\n FIELDS_GEOSERIE = geoseries.GeoSeries(field_verts)\n else:\n FIELD_CCDS_GEOSERIE = geoseries.GeoSeries(field_verts)\n\n \ndef get_fields_geoserie(inclccd=False):\n \"\"\" returns the global variable FIELDS_GEOSERIE, creates it if necessary \"\"\"\n if not inclccd:\n if not hasattr(sys.modules[__name__], 'FIELDS_GEOSERIE'):\n _load_fields_geoserie_(inclccd=False)\n \n return FIELDS_GEOSERIE\n else:\n if not hasattr(sys.modules[__name__], 'FIELD_CCDS_GEOSERIE'):\n _load_fields_geoserie_(inclccd=True)\n \n return FIELD_CCDS_GEOSERIE\n\n# ------------------ #\n# #\n# Generic Tools #\n# #\n# ------------------ #\ndef get_fieldid(grid=None, decrange=None, rarange=None, \n gallrange=None, galbrange=None, \n ecllrange=None, eclbrange=None, \n ebvrange=None, verbose=False):\n \n \"\"\" \n\n Parameters\n ----------\n grid: [None/str] -optional-\n Select the grid you want. If None the both will be considered.\n 'main' or 'secondary' expected otherwise.\n\n decrange, rarange, galbrange, gallrange, ecllgrange, eclbrange: [2-array or None] -optional-\n dec, ra, galactic l, galactic b, ecliptic long and ecliptic lat to be considered [inclusive]. \n In degree.\n 3 formats available:\n - None: means no selection\n - [min,max]: means range to be considered, None means no limit. \n example: decrange=[-10,None] means dec>-10.\n - [[min1,max1],[min2,max2], ...]: means zones to be considered.\n example: decrange=[[None, -10],[5,None]] will simply exclude the [-10,5] dec range.\n - None means no selection.\n\n ebvrange: [2-array or None] -optional-\n same format as 'decrange' but for Mily way E(B-V) extinction.\n \n \"\"\"\n def get_query(key, krange=None, merging_logic=\"or\"):\n \"\"\" \"\"\"\n def _build_2d_(kmin,kmax):\n \"\"\" \"\"\"\n if kmin is None and kmax is None:\n return []\n if kmin is None:\n return [f\"{key}<={kmax}\"]\n elif kmax is None:\n return [f\"{key}>={kmin}\"]\n else:\n return [f\"{kmin}<={key}<={kmax}\"]\n \n if krange is None:\n return []\n if np.shape(krange) == (2,):\n return _build_2d_(*krange)\n if np.shape(krange) == (2,2):\n query = [_build_2d_(*krange_) for krange_ in krange]\n return [\"(\"+f\" {merging_logic} \".join(np.squeeze(query))+\")\"]\n \n raise ValueError(f\"Cannot for the format of the input krange: {krange}\")\n\n query = []\n # Grid\n gridid = None if (grid is None or grid in [\"*\",\"all\"]) else get_grid_field(grid)\n query.append([] if gridid is None else [\"ID in @gridid\"])\n # Ra\n \n query.append(get_query(\"RA\", rarange))\n # Dec\n query.append(get_query(\"Dec\", decrange))\n # gall\n query.append(get_query(\"GalLong\", gallrange))\n # galb\n query.append(get_query(\"GalLat\", galbrange))\n # ecll\n query.append(get_query(\"EclLong\", ecllrange))\n # eclb\n query.append(get_query(\"EclLat\", eclbrange))\n # MW ebmv\n query.append(get_query(\"Ebv\", ebvrange))\n \n \n queries = np.concatenate(query)\n if verbose:\n print(queries)\n if len(queries) == 0:\n return FIELD_DATAFRAME.index\n if verbose:\n print(\" & \".join(queries) ) \n return FIELD_DATAFRAME.query( \" & \".join(queries) ).index\n\n\ndef get_field_ccd_qid(ra, dec):\n \"\"\" \"\"\"\n d_ = {}\n field_ccds = get_fields_containing_target(ra,dec, inclccd=True)\n for field_ccd in field_ccds:\n (ramin,decmin),(ramax,decmax) = np.percentile(np.asarray(FIELD_CCDS_GEOSERIE[field_ccd].exterior.xy).T, [0,100], axis=0)\n ccdpos=np.asarray([(ra-ramin)/(ramax-ramin)*6144,(dec-decmin)/(decmax-decmin)*6160])\n qid = ccdpos_to_qid(*ccdpos)\n field, ccd = field_ccd.split(\"_\")\n d_[int(field)] = {\"ccd\":int(ccd), \"qid\":int(qid), \"rcid\":ccdid_qid_to_rcid(int(ccd), int(qid))}\n \n return d_\n \ndef get_fields_containing_target(ra, dec, inclccd=False, buffer=None):\n \"\"\" return the list of fields into which the position ra, dec is. \n Remark that this is based on predefined field positions. \n Hence, small attrition could affect this.\n\n Parameters\n ----------\n ra,dec: [float,float]\n coordinates in degree. \n \n inclccd: [bool] -optional-\n do you want the details of the CCD id on top of the field\n format: \"field_ccdid\"\n\n buffer: [float] -optional-\n buffer the polygon (fields or ccds). \n In degree (unit of the polygons). The inter-ccd gap typically is 0.3 deg\n\n Returns\n -------\n list (all the field ID that contain the given ra,dec coordinates)\n \"\"\"\n try:\n from shapely import geometry\n except ImportError:\n raise ImportError(\"You need shapely to use this function. pip install shapely\")\n \n \n coordpoint = geometry.Point(ra, dec)\n fields_geoserie = get_fields_geoserie(inclccd=inclccd)\n if fields_geoserie is None:\n warnings.warn(\"get_fields_containing_target would be much faster if you install geopandas (pip install geopandas)\")\n return [f for f in FIELDSNAMES\n if geometry.Polygon( get_field_vertices(f)[0]).contains(coordpoint)]\n if buffer is None:\n return fields_geoserie.index[ fields_geoserie.contains(coordpoint) ]\n return fields_geoserie.index[ fields_geoserie.buffer(buffer).contains(coordpoint) ]\n\n\ndef get_field_vertices(fieldid=None, inclccd=False, ccd=None, asdict=False, aspolygon=False,\n squeeze=True):\n \"\"\" Get the fields countours \n \n Parameters\n ----------\n fieldid: [string or list of] -optional-\n Field (or list of) names as int. \n If None, all the fields will be used.\n\n // output format\n\n asdict: [bool] -optional-\n Do you want to result as a list (asdict=False) following the input's fieldid sorting\n or do you want a dict ({fieldid_: verts_ ... })\n\n aspolygon: [bool] -optional-\n Do you want the vertices as 2d-array (aspolygon=False) or as shapely Geometries (True)\n\n squeeze: [bool] -optional-\n Should unnecessary dimension be removed ?\n if asdict is True:\n if squeeze: {fid_ccdid: }\n if not squeeze: {fid:{ccdid: }}\n = if not inclccd, squeez ignored =\n if not asdict:\n using np.squeeze, basically doing [[]]->[]\n Returns\n -------\n list of dict (see asdict)\n \"\"\"\n if fieldid is None:\n fieldid = FIELDSNAMES\n \n if inclccd and ccd is None:\n ccd = np.arange(1,17)\n\n # - Actual calculation\n rafields, decfields = get_field_centroid( np.asarray(np.atleast_1d(fieldid), dtype=\"int\") ).T\n fields_verts = get_corners(rafields, decfields, inclccd=inclccd, ccd=ccd,\n inrad=False, squeeze=False)\n\n # ----------- #\n # Format #\n # ----------- # \n if aspolygon:\n try:\n from shapely import geometry\n fields_countours = [[geometry.Polygon(fields_verts[f_][c_])\n for c_,ccd_ in enumerate(np.atleast_1d(ccd))]\n for f_,field_ in enumerate(np.atleast_1d(fieldid))]\n except ImportError:\n warnings.warn(\"You do not have shapely, Please run pip install shapely. 'aspolygon' set to False\")\n else:\n fields_countours = fields_verts\n\n # ----------- #\n # Output #\n # ----------- # \n if not asdict:\n return fields_countours if not squeeze else np.squeeze(fields_countours)\n\n # full camera dict\n if not inclccd:\n return {i:k[0] for i,k in zip(fieldid,fields_countours)}\n \n # ccd dict\n if squeeze:\n return {f\"{field_}_{ccd_}\":fields_countours[f_][c_]\n for c_,ccd_ in enumerate(np.atleast_1d(ccd)) for f_,field_ in enumerate(np.atleast_1d(fieldid))}\n else:\n return {field_:{ccd_:fields_countours[f_][c_] for c_,ccd_ in enumerate(np.atleast_1d(ccd))}\n for f_,field_ in enumerate(np.atleast_1d(fieldid))}\n\ndef get_field_centroid(fieldid, system=\"radec\"):\n \"\"\" Returns the central coordinate [RA,Dec] or of the given field \n\n Parameters\n ----------\n fieldid: [int]\n single field ID\n\n system: [string] -optional-\n which coordinate system ?\n radec / galactic / ecliptic (default radec)\n\n Returns\n -------\n [[x_i, y_i],[]]... (depending on your coordinate system)\n Remark if only 1 fieldid given, you have [[x,y]] (not [x,y])\n \"\"\"\n if system in [\"radec\", \"RADec\",\"RA,Dec\", \"ra,dec\"]:\n syst = [\"RA\", \"Dec\"]\n elif system.lower() in [\"gal\",\"galactic\"]:\n syst = [\"Gal Long\",\"Gal Lat\"]\n elif system.lower() in [\"ecl\",\"ecliptic\"]:\n syst = [\"Ecl Long\",\"Ecl Lat\"]\n else:\n raise ValueError(\"unknown coordinate system %s select among: [radec / galactic / ecliptic]\"%system)\n fieldid = np.atleast_1d(fieldid)\n radec = np.asarray(FIELD_DATAFRAME[np.in1d(FIELD_DATAFRAME.index, fieldid)][syst].values)\n \n return radec\n\ndef get_corners(ra_field, dec_field, inclccd=False, ccd=None, steps=5, squeeze=True, inrad=False):\n \"\"\" \"\"\"\n from .utils.tools import rot_xz_sph, _DEG2RA\n \n if not inclccd:\n upper_left_corner = _CCD_COORDS.max()\n lower_right_corner = _CCD_COORDS.min()\n elif ccd is None:\n upper_left_corner = _CCD_COORDS.groupby(\"CCD\").max()\n lower_right_corner = _CCD_COORDS.groupby(\"CCD\").min()\n else:\n upper_left_corner = _CCD_COORDS.groupby(\"CCD\").max().loc[ccd]\n lower_right_corner = _CCD_COORDS.groupby(\"CCD\").min().loc[ccd]\n \n ewmin = -np.atleast_1d(upper_left_corner[\"EW\"])\n nsmax = np.atleast_1d(upper_left_corner[\"NS\"])\n ewmax = -np.atleast_1d(lower_right_corner[\"EW\"])\n nsmin = np.atleast_1d(lower_right_corner[\"NS\"])\n\n ra1 = (np.linspace(ewmax, ewmin, steps)/np.cos(nsmax*_DEG2RA)).T\n dec1 = (np.ones((steps,1))*nsmax).T\n #\n dec2 = np.linspace(nsmax,nsmin, steps).T\n ra2 = ewmin[:,None]/np.cos(dec2*_DEG2RA)\n #\n ra3 = (np.linspace(ewmin,ewmax, steps)/np.cos(nsmin*_DEG2RA)).T\n dec3 = (np.ones((steps,1))*nsmin).T\n #\n dec4 = np.linspace(nsmin,nsmax, steps).T\n ra4 = ewmax[:,None]/np.cos(dec4*_DEG2RA)\n\n ra_bd = np.concatenate((ra1, ra2, ra3, ra4 ), axis=1) \n dec_bd = np.concatenate((dec1, dec2, dec3,dec4 ), axis=1)\n \n ra,dec = rot_xz_sph(np.moveaxis(ra_bd,0,1), np.moveaxis(dec_bd,0,1), np.moveaxis(np.atleast_3d(dec_field),0,1))\n ra += np.moveaxis(np.atleast_3d(ra_field),0,1)\n\n if inrad:\n ra *= _DEG2RA\n dec *= _DEG2RA\n \n radec = np.moveaxis([ra,dec],(0,1,2,3),(3,0,2,1))\n return radec if not squeeze else np.squeeze(radec)\n\ndef get_grid_field(which):\n \"\"\" \"\"\"\n if which in [\"main\",\"Main\",\"primary\"]:\n return FIELDSNAMES[FIELDSNAMES<880]\n if which in [\"aux\",\"secondary\", \"auxiliary\"]:\n return FIELDSNAMES[FIELDSNAMES>999]\n if which in [\"all\",\"*\",\"both\"]:\n return FIELDSNAMES\n \n raise ValueError(f\"Cannot parse which field grid you want {which}\")\n\n\ndef get_rcid_centroid(rcid, fieldid):\n \"\"\" \"\"\"\n ccdid, q1d = rcid_to_ccdid_qid(rcid)\n return get_qids_centroid(fieldid, ccdid)[f\"q{q1d}\"]\n\ndef get_qids_centroid(fieldid=None, ccdid=None, ccd_vertices=None):\n if ccd_vertices is None:\n if fieldid is None or ccdid is None:\n raise ValueError(\"either fieldid and ccdid or ccd_vertices should be given\")\n \n ccd_vertices = get_field_vertices(fieldid=fieldid, inclccd=True, ccd=ccdid)\n \n min_,mean_,max_ = np.percentile(ccd_vertices, [0,50,100], axis=0)\n return {\"q1\":np.mean([mean_, max_], axis=0),\n \"q2\":[np.mean([mean_[0], min_[0]]),np.mean([mean_[1], max_[1]])],\n \"q3\":np.mean([mean_, min_], axis=0),\n \"q4\":[np.mean([mean_[0], max_[0]]),np.mean([mean_[1], min_[1]])]\n }\n \n\n\n\ndef ccdpos_to_qid(ccdx, ccdy):\n \"\"\" returns the qid for the given ccd position \"\"\"\n flagqid = np.asarray(np.asarray([ccdx<3072, ccdy<3080]), dtype=int) \n return np.asarray([[1,4],[2,3]])[flagqid[0]][flagqid[1]]\n\ndef ccdid_qid_to_rcid(ccdid, qid):\n \"\"\" computes the rcid \"\"\"\n return 4*(ccdid - 1) + qid - 1\n\ndef rcid_to_ccdid_qid(rcid):\n \"\"\" computes the rcid \"\"\"\n qid = (rcid%4)+1\n ccdid = int((rcid-(qid - 1))/4 +1)\n return ccdid,qid\n\n##############################\n# #\n# Fields and References #\n# #\n##############################\ndef has_field_reference(fieldid, rcid_details=False, **kwargs):\n \"\"\" get the following dictionary {zg:bool, zr:bool, zi:bool}\n where bool is True if the field has a reference image and false otherwise\n \n **kwargs goes to load_metadata(), for instance auth=[username, password]\n Returns\n -------\n {zg:bool, zr:bool, zi:bool}\n \"\"\"\n from .query import ZTFQuery\n zquery_ = ZTFQuery()\n zquery_.load_metadata(kind=\"ref\", sql_query=f\"field={fieldid}\", **kwargs)\n if rcid_details:\n return {k:zquery_.metatable.query(f\"filtercode in ['{k}']\")[\"rcid\"].value_counts(sort=False).to_dict() for k in [\"zg\", \"zr\",\"zi\"]}\n return {k: k in zquery_.metatable[\"filtercode\"].values for k in [\"zg\", \"zr\",\"zi\"]}\n\ndef get_fields_with_band_reference(filter_, ccdid=1, qid=1, **kwargs):\n \"\"\" returns the list of fieldid that have a reference image in the `filter_` band.\n filter_ is a filtercode entry [zg, zr or zg]\n \n **kwargs goes to load_metadata(), for instance auth=[username, password]\n Returns\n -------\n list of fieldid\n \"\"\"\n from .query import ZTFQuery\n zquery_ = ZTFQuery()\n zquery_.load_metadata(kind=\"ref\",\n sql_query=\"filtercode='%s' and ccdid=%s and qid=%s\"%(filter_,ccdid,qid), **kwargs)\n return zquery_.metatable[\"field\"].values\n\ndef show_reference_map(band, **kwargs):\n \"\"\" Display the 'field plot' in which field with image reference in the given band are colored. \"\"\"\n title = \"Fields with reference in the %s-band\"%band[1]\n field_i = get_fields_with_band_reference(band)\n return show_fields(field_i, facecolor=FIELDNAME_COLOR[band], alpha=0.3, title=title, **kwargs)\n \n# ===================== #\n# #\n# SHOW FIELD #\n# #\n# ===================== #\ndef show_fields(fields, vmin=None, vmax=None,\n ax=None, cmap=\"viridis\", title=None,\n colorbar=True, cax=None, hcax=None, clabel=\" \", inclhist=True, \n show_ztf_fields=True, grid=\"main\", grid_prop={},\n bkgd_fields=None, bkgd_prop={},\n show_mw=True, mw_b=None, mw_prop={},\n savefile=None, figsize=None,\n axparam={}, get_fplot=False,\n **kwargs):\n \"\"\" \n Parameters\n ----------\n colored_by: \n \"\"\"\n fplot = FieldPlotter(ax=ax, cax=cax, hcax=hcax, figsize=figsize, inclcax=colorbar,\n inclhist=inclhist, **axparam)\n # - Plotting\n if show_ztf_fields:\n fplot.show_ztf_grid(which=grid, **grid_prop)\n \n if bkgd_fields is not None:\n def_prop = dict(facecolor=\"0.7\", edgecolor=\"0.5\", alpha=0.2, zorder=2)\n fplot.show_fields(bkgd_fields,**{**def_prop,**bkgd_prop})\n \n if show_mw:\n fplot.show_milkyway(b=mw_b, **mw_prop)\n\n # Removing the NaNs\n fplot.show_fields(fields,\n colorbar=colorbar,\n clabel=clabel,cmap=cmap,\n vmin=vmin, vmax=vmax,**kwargs)\n \n if title is not None:\n fplot.fig.text(0.5,0.9, title,\n va=\"top\", ha=\"center\", fontsize=\"large\")\n # Output\n if savefile is not None:\n fplot.fig.savefig(savefile, dpi=150)\n if get_fplot:\n return fplot\n return fplot.fig\n\ndef show_field_ccds(fieldid, ax=None, ccd=None, textcolor=\"k\", facecolor=\"0.9\", edgecolor=\"k\",\n autoscale=True, **kwargs):\n \"\"\" \"\"\"\n if ax is None:\n fig = mpl.figure(figsize=[8,6])\n ax = fig.add_subplot(111)\n else:\n fig = ax.figure\n\n if ccd is None:\n ccd = range(1,17)\n ff = get_fields_geoserie(inclccd=True)\n fccd = {i:ff[f\"{fieldid}_{i}\"] for i in ccd}\n for i,s_ in fccd.items():\n verts = np.asarray(s_.exterior.xy).T\n ax.add_patch( Polygon(verts, facecolor=facecolor, edgecolor=edgecolor, **kwargs))\n ax.text(*np.mean(verts,axis=0),i, color=textcolor, va=\"center\", ha=\"center\")\n\n if autoscale:\n ax.autoscale()\n \n return fig\n\ndef show_gri_fields(fieldsg=None, fieldsr=None, fieldsi=None,\n fig=None,\n title=\" \", alignment=\"horizontal\",\n show_ztf_fields=True, colorbar=True,\n show_mw=True, mw_b=None, mw_prop={},\n projection=\"hammer\", moveup=0.05, vscale=1, hscale=1,\n **kwargs):\n \"\"\" \"\"\"\n prop = {**dict(colorbar=colorbar, edgecolor=\"0.5\", linewidth=0.5),**kwargs}\n \n used_fields = {i+1:f for i,f in enumerate([fieldsg,fieldsr,fieldsi]) if f is not None and len(f)>0}\n \n # None\n if len(used_fields) == 0:\n raise ValueError(\"No fields given\")\n \n # Only one\n if len(used_fields) == 1:\n warnings.warn(\"Only one color given, favor using show_fields() directly\")\n which = list(used_fields.keys())[0]\n return show_fields(used_fields[which], cmap=FIELD_CMAP[which],\n show_ztf_fields=show_ztf_fields,\n show_mw=show_mw, mw_b=mw_b, mw_prop=mw_prop,\n **prop)\n \n # 2 or More\n onlytwo = len(used_fields)==2\n ax, cax = _get_gri_axes_(alignment=alignment, title=title, projection=projection,\n moveup=moveup, onlytwo=onlytwo, fig=fig, vscale=vscale, hscale=hscale)\n \n fbands = list(used_fields.keys())\n afields_ = list(used_fields.values())\n for i,ax_,cax_,fields_ in zip(fbands, ax, cax, afields_):\n \n if fields_ is not None:\n patch = {}\n if len(np.unique(fields_))==1:\n patch[\"inclhist\"] = False\n if np.unique(fields_)[0]==1:\n patch[\"colorbar\"] = False\n \n _ = show_fields(fields_, ax=ax_, cax=cax_, cmap=FIELD_CMAP[i],\n show_ztf_fields=show_ztf_fields,\n show_mw=show_mw, mw_b=mw_b, mw_prop=mw_prop,\n **{**prop,**patch})\n return ax[0].figure\n\ndef _get_gri_axes_(alignment=\"classic\", title=None, titlefontsize=\"large\", projection=\"hammer\",\n labelsize=\"x-small\", labelcolor=\"0.7\", clabelsize=\"x-small\", clabelcolor=\"k\",\n moveup=None, fig=None, vscale=1, hscale=1, onlytwo=False):\n \"\"\" \"\"\"\n if alignment is None or onlytwo:\n alignment = \"flat\"\n\n if moveup is None:\n moveup=0 \n \n if alignment in [\"classic\"]:\n if fig is None:\n fig = mpl.figure(figsize=[9,6])\n # G\n axg = fig.add_axes([0.03,0.52+moveup,0.43,0.48], projection=projection)\n caxg = fig.add_axes([0.03,0.54+moveup,0.43,0.015])\n # R\n axr = fig.add_axes([0.54,0.52+moveup,0.43,0.48], projection=projection)\n caxr = fig.add_axes([0.54,0.54+moveup,0.43,0.015])\n # I\n axi = fig.add_axes([0.27,0.04+moveup,0.43,0.48], projection=projection)\n caxi = fig.add_axes([0.27,0.05+moveup,0.43,0.015])\n ax = [axg,axr,axi]\n cax = [caxg,caxr,caxi]\n elif alignment in [\"flat\",\"aligned\", \"horizontal\"]:\n naxes = 3 if not onlytwo else 2\n if fig is None:\n fig = mpl.figure(figsize=[3.2*naxes,2.5])\n # G\n spanx, spanm = 0.05,0.05\n width = (1-(2*spanx+2*spanm))/naxes\n ax = [fig.add_axes([ spanm+(i*(width*hscale+spanx)), (0.20+moveup)*vscale, width*hscale, 0.700*vscale],\n projection=projection) for i in range(naxes)]\n cax = [fig.add_axes([ spanm+(i*(width*hscale+spanx)), (0.12+moveup)*vscale, width*hscale, 0.025*vscale])\n for i in range(naxes)]\n else:\n raise ValueError(f\"cannot parse the given show_gri alignment {alignment}, classic or horizontal\")\n\n if title is not None:\n fig.suptitle(title, fontsize=titlefontsize)\n # labels\n for ax_ in ax:\n ax_.tick_params(labelsize=labelsize, labelcolor=labelcolor)\n for ax_ in cax: \n ax_.tick_params(labelsize=clabelsize, labelcolor=clabelcolor)\n \n return ax,cax\n\n\ndef show_ztf_fieldvalues(key=\"Ebv\", fieldid=\"main\", mindec=-30,\n vmin=None, vmax=None,\n ax=None, cmap=\"viridis\", title=None,\n colorbar=True, cax=None, clabel=\" \",\n show_ztf_fields=True, grid=\"main\", grid_prop={},\n show_mw=True, mw_b=None, mw_prop={},\n savefile=None, **kwargs):\n \"\"\" \"\"\"\n if key not in FIELD_DATAFRAME.columns:\n raise ValueError(f\"cannot parse the given key {key}, only columns from FIELD_DATAFRAME available\")\n \n \n if type(fieldid) is str or fieldid is None:\n fieldid = get_grid_field(fieldid)\n query_ = \"index in @fieldid\"\n if mindec is not None:\n query_ +=\" and Dec > @mindec\"\n # Serie to plot \n serie = FIELD_DATAFRAME.query(query_)[key]\n return show_fields(fields=serie, vmin=vmin, vmax=vmax,\n ax=ax, cmap=cmap, title=title,\n colorbar=colorbar, cax=cax, clabel=clabel,\n show_ztf_fields=show_ztf_fields, grid=grid, grid_prop=grid_prop,\n show_mw=show_mw, mw_b=mw_b, mw_prop=mw_prop,\n savefile=savefile, **kwargs)\n \n \ndef display_field(ax, fieldid, origin=None, facecolor=\"0.8\", lower_dec=None, edgecolor=None, **kwargs):\n \"\"\" \"\"\"\n print(\"display_field is DEPRECATED\")\n\ndef _radec_to_plot_(self, ra, dec):\n \"\"\" \"\"\"\n return np.asarray([-(np.asarray(ra)-self.origin)*np.pi/180, np.asarray(dec)*np.pi/180])\n\n \n##############################\n# #\n# Individual Field Class #\n# #\n##############################\nclass FieldPlotter( object ):\n \"\"\" \"\"\"\n def __init__(self, ax=None, origin=180, inclcax=True, inclhist=False, cax=None, hcax=None, **kwargs):\n \"\"\" \"\"\"\n self.origin = origin \n self.load_ax(ax, inclcax=inclcax, cax=cax, inclhist=inclhist, **kwargs)\n\n \n def load_ax(self, ax=None, update_ticks=True, cax=None, hcax=None, inclcax=True, inclhist=False, figsize=None,\n **kwargs):\n \"\"\" \"\"\"\n if ax is None or len(np.atleast_1d(ax))==4:\n self.fig = mpl.figure(figsize=(8,5) if figsize is None else figsize)\n self.ax = self.fig.add_axes([0.15,0.2,0.75,0.75] if ax is None else ax, projection=\"hammer\")\n else:\n self.ax = ax\n self.fig = self.ax\n \n if inclcax:\n from .utils.plots import HistColorbar\n if cax is None and hcax is None:\n from .utils.plots import insert_ax\n cax = insert_ax(self.ax, \"bottom\",\n shrunk=0.98, space=-0.15, axspace=0.13)\n if inclhist and hcax is None:\n if len(np.atleast_1d(cax)) == 4:\n xmin, ymin, width, height= cax\n hcax = [xmin, ymin+np.min([height*1.5,height+0.005]), width, height*1.8]\n else: \n bcax = cax.get_position()\n xmin, ymin, width, height= bcax.xmin, bcax.ymin, bcax.width, bcax.height\n hcax = cax.figure.add_axes([xmin, ymin+np.min([height*1.5,height+0.005]) , width, height*1.8])\n \n self.histcbar = HistColorbar(ax=hcax, cax=cax, fig=self.fig, draw=False)\n else:\n self.histcbar = None\n \n if update_ticks:\n tick_labels = np.array([150, 120, 90, 60, 30, 0, 330, 300, 270, 240, 210])\n tick_labels = np.remainder(tick_labels+360+self.origin,360)\n self.ax.set_xticklabels(tick_labels) # we add the scale on the x axis\n\n # Label param\n if len(kwargs)>0:\n self.ax.tick_params(**kwargs)\n \n # ---------- #\n # PLOTTER #\n # ---------- #\n def show_ztf_grid(self, which=\"main\", \n facecolor=\"None\", edgecolor=\"0.7\", alpha=0.1, zorder=1, **kwargs):\n \"\"\" \"\"\"\n fields_ = get_grid_field(which)\n self._ztfgrid = self.show_fields(fields_, \n facecolor=facecolor, edgecolor=edgecolor, \n alpha=alpha, zorder=zorder, **kwargs)\n\n def show_milkyway(self, b=None, nbins=100, l_start=-241, l_stop=116,**kwargs):\n \"\"\" \"\"\"\n \n nbins=100\n if b is None:\n gal = coordinates.Galactic(np.linspace(l_start,l_stop,nbins)*units.deg, np.zeros(nbins)*units.deg\n ).transform_to(coordinates.ICRS)\n prop = dict(ls=\"-\", color=\"0.7\", alpha=0.5)\n self.ax.plot(*self.radec_to_plot(gal.ra, gal.dec), **{**prop, **kwargs})\n else:\n gal_dw = coordinates.Galactic(np.linspace(l_start,l_stop,100)*units.deg, +b*np.ones(nbins)*units.deg\n ).transform_to(coordinates.ICRS)\n gal_up = coordinates.Galactic(np.linspace(l_start,l_stop,100)*units.deg, -b*np.ones(nbins)*units.deg\n ).transform_to(coordinates.ICRS)\n ra_dw,dec_dw = self.radec_to_plot(gal_dw.ra, gal_dw.dec)\n ra_up,dec_up = self.radec_to_plot(gal_up.ra, gal_up.dec)\n\n prop = dict(facecolor=\"0.7\", alpha=0.2)\n self.ax.fill_between(ra_dw, dec_dw, dec_up, **{**prop, **kwargs})\n \n def add_fields(self, fields, facecolor=\"0.7\", edgecolor=\"k\", lw=0.5, **kwargs):\n \"\"\" \"\"\"\n fields_verts = self.get_field_vertices(fields)\n self.poly_ = [self.ax.add_patch(Polygon(p_, facecolor=facecolor, \n edgecolor=edgecolor, lw=lw, **kwargs))\n for p_ in fields_verts]\n\n def show_fields(self, fields, cmap=None,\n colorbar=True, clabel=None, cfontsize=None,\n vmin=None, vmax=None, bins=\"auto\", **kwargs):\n \"\"\" fields could be a list of field or a dictionary with single values \"\"\"\n \n # For now, then will move to pandas.Series as native\n if type(fields) is pandas.Series:\n fields = fields.to_dict()\n \n if type(fields)==dict:\n # popint out nans\n fields = {f:v for f,v in fields.items() if not np.isnan(v)} \n values = list(fields.values())\n if len(values)==0 or not np.any(values):\n if self.histcbar is not None:\n self.histcbar.set_visible(False)\n return\n \n if vmin is None: vmin = \"0\"\n if type(vmin) == str:\n vmin=np.percentile(values, float(vmin))\n if vmax is None: vmax = \"100\"\n if type(vmax) == str:\n vmax=np.percentile(values, float(vmax))\n\n values = np.asarray(values)\n if self.histcbar is not None:\n if bins is None or bins in ['auto']:\n if values.dtype == int:\n bins = int((vmax-vmin))+1\n vmax +=1\n self.histcbar.build_histrogram(data=values, vmin=vmin, vmax=vmax, bins=bins)\n \n # - CBAR\n if cmap is None and self.histcbar is not None:\n cmap = self.histcbar.cmap\n \n elif type(cmap) == str:\n if self.histcbar is not None:\n self.histcbar.load_cmap(cmap)\n cmap = self.histcbar.cmap\n else:\n cmap = mpl.get_cmap(cmap)\n else:\n self.histcbar.load_cmap(cmap.name)\n \n \n# _ = kwargs.pop(\"facecolor\",None) #remove facecolor is any\n for f,v in fields.items():\n self.add_fields(f, **{**dict(facecolor=cmap((v-vmin)/(vmax-vmin)) if vmax-vmin !=0 else cmap(0)), **kwargs})\n\n # - Cbar\n if colorbar:\n self.show_colorbar(clabel=clabel, cfontsize=cfontsize)\n elif self.histcbar is not None:\n self.histcbar.set_visible(False)\n \n else:\n self.add_fields(fields, **kwargs)\n \n def show_point(self, radec, **kwargs):\n \"\"\" \"\"\"\n xy = self.radec_to_plot(*radec)\n self.ax.scatter(*xy, **kwargs)\n\n def show_colorbar(self, clabel=None, cfontsize=None):\n \"\"\" \"\"\"\n if self.histcbar is None:\n return\n\n self.histcbar.draw()\n self.histcbar.set_label(clabel, fontsize=cfontsize)\n \n def get_field_vertices(self, fields_):\n \"\"\" Get the field vertices in plotting coordinates. \"\"\"\n fields_ = np.squeeze(get_field_vertices(fields_, squeeze=False), axis=1) # remove CCDs\n return [self.radec_to_plot(*f_.T).T for f_ in fields_] \n \n def radec_to_plot(self, ra, dec):\n \"\"\" \"\"\"\n return np.asarray([-(np.asarray(ra)-self.origin)*np.pi/180, np.asarray(dec)*np.pi/180])\n\n\n \n##############################\n# #\n# ZTF Fields Class #\n# #\n##############################\n\nclass FieldAnimation( FieldPlotter ):\n \n def __init__(self, fields, ax=None,dates=None, facecolors=None, alphas=None, edgecolors=None, inclcax=False):\n \"\"\" \"\"\"\n super().__init__(ax=ax, inclcax=inclcax)\n \n self.set_fields(fields)\n self.set_dates(dates)\n self.set_properties(facecolors=facecolors, alphas=alphas, edgecolors=edgecolors)\n \n # ================= #\n # Methods #\n # ================= #\n def set_dates(self, dates):\n \"\"\" \"\"\"\n self._dates = np.atleast_1d(dates) if dates is not None else None\n\n def set_fields(self, fields):\n \"\"\" \"\"\"\n self._fields = fields\n self._unique_fields = np.unique(self._fields)\n self._field_vertices = {i:v for i,v in zip(self._unique_fields,self.get_field_vertices(self._unique_fields))}\n \n def set_properties(self, facecolors=None, edgecolors=None, alphas=None):\n \"\"\" \"\"\"\n self._display_prop = {}\n self._set_prop_(\"facecolor\", facecolors, \"0.7\")\n self._set_prop_(\"edgecolor\", edgecolors, \"None\")\n self._set_prop_(\"alpha\", alphas, 1)\n\n def _set_prop_(self, key, value, default=None):\n \"\"\" \"\"\"\n if not hasattr(self,\"_display_prop\"):\n self._display_prop = {}\n \n if value is None:\n value = default\n \n if len(np.atleast_1d(value)) == 1:\n self.display_prop[key] = np.atleast_1d(value)\n self.display_prop[f\"unique_{key}\"] = True\n else:\n self.display_prop[key] = value\n self.display_prop[f\"unique_{key}\"] = False\n \n # ---------- #\n # SETUP #\n # ---------- #\n def reset(self):\n \"\"\" \"\"\"\n self.intpoly_ = Polygon(self.field_vertices[self.fields[0]],\n facecolor=self.display_prop[\"facecolor\"][0],\n edgecolor=self.display_prop[\"edgecolor\"][0],\n alpha=self.display_prop[\"alpha\"][0])\n \n if self._dates is not None:\n self.inttext_ = self.fig.text(0.01,0.99, self._dates[0],\n va=\"top\", ha=\"left\", weight=\"bold\")\n \n p_ = self.ax.add_patch(self.intpoly_)\n return self.intpoly_\n \n\n # ---------- #\n # Animate #\n # ---------- # \n def update_field_to(self, i):\n \"\"\" \"\"\"\n try:\n self.intpoly_.set_xy(self.field_vertices[ self.fields[i] ])\n if self.dates is not None and len(self.dates)>1:\n self.inttext_.set_text(self.dates[i])\n except:\n print(f\"FAILES for i={i}\")\n \n for key in [\"facecolor\",\"edgecolor\",\"alpha\"]:\n if not self.display_prop[f\"unique_{key}\"]:\n getattr(self.intpoly_,f\"set_{key}\")(self.display_prop[key][i])\n \n return self.intpoly_\n\n def launch(self, interval=5, repeat=False, blit=True, savefile=None):\n \"\"\" \"\"\"\n from matplotlib import animation\n self.anim = animation.FuncAnimation(self.fig, self.update_field_to,\n init_func=self.reset,\n frames=self.nfields, interval=interval, repeat=repeat, blit=blit)\n \n # ================= #\n # Properties #\n # ================= #\n @property\n def fields(self):\n \"\"\" Fields that should be shown \"\"\"\n return self._fields\n\n @property\n def dates(self):\n \"\"\" Observation dates if any \"\"\"\n return self._dates\n @property\n def nfields(self):\n \"\"\" size of self.fields \"\"\"\n return len(self.fields)\n\n @property\n def field_vertices(self):\n \"\"\" vertices of the fields \"\"\"\n return self._field_vertices\n\n @property\n def display_prop(self):\n \"\"\" \"\"\"\n return self._display_prop\n\n\n \n##############################\n# #\n# Planner Class #\n# #\n##############################\n\nclass PalomarPlanning( object):\n \"\"\" \"\"\"\n def __init__(self, date=None, **kwargs):\n \"\"\" \"\"\"\n self._site = coordinates.EarthLocation.of_site(\"palomar\")\n self._utcshift = -8*units.h\n if date is not None:\n self.set_date(date, **kwargs)\n\n # --------- #\n # SETTER #\n # --------- #\n def set_date(self, date, timerange=[-7,7], to_utc=True, **kwargs):\n \"\"\" \"\"\"\n self._date = date\n self.set_night(date,timerange=[-7,7], to_utc=True, **kwargs)\n \n def set_night(self, night, timerange=[-7,7], to_utc=True, **kwargs):\n \"\"\" \"\"\" \n self._night = self.get_night(night, timerange=timerange, to_utc=to_utc, **kwargs)\n self._nightaltaz = self._get_night_altaz_(self.night)\n \n # --------- #\n # GETTER #\n # --------- #\n @classmethod\n def get_date_night_duration(cls, date, twilight=-12*units.deg, **kwargs):\n \"\"\" ClassMethod to directly get the night duration at a given date or list of dates. \"\"\"\n return cls().get_night_duration(date, twilight=twilight, **kwargs)\n\n \n def get_night(self, date, timerange=[-7,7], to_utc=True, range_units=units.h, bins=100, **kwargs):\n \"\"\" \"\"\"\n if type(date) is not time.Time:\n date = time.Time(date, **kwargs)\n if to_utc:\n date -= self.utcshift\n \n if timerange is None:\n return date\n if len(np.atleast_1d(date))==1:\n return date + np.linspace(*timerange, bins)*range_units\n return date + np.linspace(*timerange, bins)[:,None]*range_units\n\n def get_night_duration(self, date=None, twilight=-12*units.deg, bins=500):\n \"\"\" in hours \"\"\"\n if date is None:\n date =self.date\n \n time_, sunaltaz = self.get_body_altaz(\"sun\", date, bins=bins)\n flagnight = sunaltaz.alt=airmasslimit[0]) * (airmasses=min_night_frac)\n flag_good *= flag_nightfrac[None,:]\n\n\n stime, ffrac = [pandas.Series(np.sum(flag_good, axis=1), index=pandas.DatetimeIndex(nighttime.datetime)),\n pandas.Series(np.sum(flag_good, axis=0)/len(nighttime[~flagtwilight]), index=fieldid)]\n \n if still_observablein is not None:\n print(\"using still_observablein options\") \n if date is None:\n date = self.date\n \n delay_date = (time.Time(date) + still_observablein).iso.split(\" \")[0]\n delay_stime, delay_ffrac = self.get_fields_observability(fieldid, date=delay_date,\n airmasslimit=airmasslimit, minobservability=minobservability,\n twilight=twilight, still_observablein=None)\n fieldidstillin = ffrac[ffrac>0].index[np.in1d(ffrac[ffrac>0].index,delay_ffrac[delay_ffrac>0].index)]\n flagstillin = np.in1d(ffrac.index,fieldidstillin)\n flag_good *= flagstillin[None,:]\n \n return [pandas.Series(np.sum(flag_good, axis=1), index=pandas.DatetimeIndex(nighttime.datetime)),\n pandas.Series(np.sum(flag_good, axis=0)/len(nighttime[~flagtwilight]), index=fieldid)]\n \n \n def get_observable_fields(self, fieldids, date=None, airmasslimit=[1,1.5],\n minobservability=90*units.min, twilight=-18*units.deg,\n **kwargs):\n \"\"\" \"\"\"\n stime, ffrac = self.get_fields_observability(fieldids, date=date, airmasslimit=airmasslimit,\n twilight=twilight, minobservability=minobservability,\n **kwargs)\n return ffrac[ffrac>0].index\n \n \n def is_twilight(self, date=None, sunlimit=-18*units.deg, squeeze=True):\n \"\"\" \"\"\"\n time_, sunaltaz = self.get_body_altaz(\"sun\", date)\n sunlimit = np.atleast_1d(sunlimit)\n \n flags = [sunaltaz.alt>slimit for slimit in sunlimit]\n \n if len(sunlimit) ==1 and squeeze:\n return flags[0]\n return flags\n \n def is_day(self, date, sunlimit=0*units.deg, squeeze=True, **kwargs):\n \"\"\" \"\"\"\n return self.is_twilight(sunlimit=0*units.deg, squeeze=squeeze, **kwargs)\n\n def _get_night_altaz_(self, night, **kwargs):\n \"\"\" \n **kwargs goes to astropy.time.Time if date is not one already.\n \"\"\"\n return coordinates.AltAz(obstime=night, location=self.site)\n \n def _read_date_input_(self, date, **kwargs):\n \"\"\" \"\"\"\n if date is not None:\n if type(date) is not time.Time:\n date = self.get_night(date, **kwargs)\n datealtaz = self._get_night_altaz_(date)\n elif self.has_night():\n date = self.night\n datealtaz = self.nightaltaz\n else:\n raise ValueError(\"No night set (self.set_night), no date given (see date option).\")\n \n return date, datealtaz\n # -------- #\n # PLOTTER #\n # -------- #\n def show(self, date=None, fields=None, radec=None, body=None, propdate={},\n show_twilight=True, as_airmass=False, ctwilight=\"0.7\"):\n \"\"\" \"\"\"\n import matplotlib.pyplot as mpl\n from matplotlib import dates as mdates\n \n fig = mpl.figure(figsize=[7,4])\n ax = fig.add_subplot(111)\n\n if date is not None:\n if type(date) is not time.Time:\n date = self.get_night(date, **propdate)\n else:\n date = self.night\n \n # \n # - start: Plotting\n for type_ in [\"fields\", \"radec\", \"body\"]:\n t_ = eval(type_)\n if t_ is not None:\n _, v_ = getattr(self,f\"get_{type_}_altaz\")(t_, date)\n ax.plot(date.datetime, v_.alt if not as_airmass else v_.secz)\n # - end: Plotting\n # \n \n # \n # - start: Twilight bands\n if show_twilight:\n self.show_twilight(ax=ax, date=date)\n \n # - start: End bands\n # \n \n # - \n ax.set_ylabel(\"Altitude [deg]\" if not as_airmass else \"Airmass\")\n # - cleaning\n locator = mdates.AutoDateLocator()\n formatter = mdates.ConciseDateFormatter(locator)\n ax.xaxis.set_major_locator(locator)\n ax.xaxis.set_major_formatter(formatter)\n # - Limites\n ax.set_xlim(date.datetime[0],date.datetime[-1])\n \n ax.set_ylim(-1,3) if as_airmass else ax.set_ylim(-10,95)\n \n def show_twilight(self, date=None, ax=None, sunlimit=[0,-12,-18]*units.deg,\n ctwilights=\"0.7\", alphas=[0.8,0.3,0.1], propdate={}):\n \"\"\" \"\"\"\n import matplotlib.pyplot as mpl\n \n ctwilights = np.atleast_1d(ctwilights)\n alphas = np.atleast_1d(alphas)\n \n if len(ctwilights)==1:\n ctwilights = list(ctwilights)*len(sunlimit)\n if len(alphas)==1:\n alphas = list(alphas)*len(alphas)\n \n if ax is None:\n fig = mpl.figure(figsize=[7,4])\n ax = fig.add_subplot(111)\n else:\n fig = ax.figure\n \n \n if date is not None:\n if type(date) is not time.Time:\n date = self.get_night(date, **propdate)\n else:\n date = self.night\n \n for i, tflag in enumerate(self.is_twilight(date=date, sunlimit=sunlimit, squeeze=False)):\n ax.fill_between(date.datetime, 0,1, where=tflag, \n transform=ax.get_xaxis_transform(), \n color=ctwilights[i], alpha=alphas[i])\n \n \n def show_fields_observability(self, fieldids, show_twilight=True, cmap=\"viridis\",\n airmasslimit=[1,1.5], twilight=-18*units.deg, minobservability=90*units.min,\n show_notobs=True, cmapv=0.1,\n fcno=\"0.7\",ecno=\"0.7\", alphano=0.15, nolw=0, noprop={},\n **kwargs):\n \"\"\" \n **kwargs foes to get_fields_observability() \n \"\"\"\n import matplotlib.pyplot as mpl \n from matplotlib import dates as mdates\n\n figsize = [9,3.5]\n axmap = [0.05,0.21,0.45,0.7]\n caxmap = [0.05,0.18,0.45,0.02]\n\n stime, ffrac = self.get_fields_observability(fieldids, airmasslimit=airmasslimit, twilight=twilight, minobservability=minobservability)\n \n fig = show_fields( ffrac[ffrac.values>0],\n bkgd_fields=fieldids[ffrac.values==0] if show_notobs else None,\n bkgd_prop={**dict(facecolor=fcno, edgecolor=ecno, alpha=alphano, lw=nolw),**noprop},\n ax=axmap, cax=caxmap, figsize=figsize, cmap=cmap,\n axparam={\"labelsize\":\"x-small\",\"color\":\"0.7\", \"labelcolor\":\"0.7\"},\n clabel=\"Fraction of night observable\", cfontsize=\"medium\")\n\n axh = fig.add_axes([0.6,0.17,0.35,0.68])\n axh.fill_between(stime.index, stime.values, \n facecolor=mpl.cm.get_cmap(cmap)(cmapv,0.2), \n edgecolor=mpl.cm.get_cmap(cmap)(cmapv,0.9), lw=2, **kwargs)\n\n\n locator = mdates.AutoDateLocator(minticks=4, maxticks=6)\n formatter = mdates.ConciseDateFormatter(locator)\n axh.xaxis.set_major_locator(locator)\n axh.xaxis.set_major_formatter(formatter)\n axh.set_ylim(bottom=0)\n axh.set_xlim(*self.night.datetime[[0,-1]])\n axh.set_ylabel(\"Number of fields observable\")\n if show_twilight:\n self.show_twilight(ax=axh, date=self.night, ctwilights=\"0.9\")\n \n fig.text(0.02,0.98, f\"Field Observability | {len(ffrac[ffrac>0])} fields\", color=\"0.7\", fontsize=\"medium\", va=\"top\",ha=\"left\")\n \n return fig\n \n # ============= #\n # Properties #\n # ============= #\n @property\n def site(self):\n \"\"\" \"\"\"\n return self._site\n @property\n def utcshift(self):\n \"\"\" \"\"\"\n return self._utcshift\n\n @property\n def date(self):\n \"\"\" \"\"\"\n return None if not hasattr(self,\"_date\") else self._date\n \n @property\n def night(self):\n \"\"\" \"\"\"\n if not self.has_night():\n return None\n return self._night\n \n def has_night(self):\n \"\"\" \"\"\"\n return getattr(self,\"_night\") and self._night is not None\n \n @property\n def nightaltaz(self):\n \"\"\" \"\"\"\n if not self.has_night():\n raise AttributeError(\"No night set.\")\n \n return self._nightaltaz\n", "meta": {"hexsha": "38e626ffc401975468705df65cb5b647f4c3c423", "size": 48643, "ext": "py", "lang": "Python", "max_stars_repo_path": "ztfquery/fields.py", "max_stars_repo_name": "pierfra-ro/ztfquery", "max_stars_repo_head_hexsha": "8e0389719be3127887655f147f69350d316d8fd0", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 16, "max_stars_repo_stars_event_min_datetime": "2019-03-08T17:01:19.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-19T15:57:49.000Z", "max_issues_repo_path": "ztfquery/fields.py", "max_issues_repo_name": "pierfra-ro/ztfquery", "max_issues_repo_head_hexsha": "8e0389719be3127887655f147f69350d316d8fd0", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 25, "max_issues_repo_issues_event_min_datetime": "2018-08-20T13:33:40.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-23T09:20:54.000Z", "max_forks_repo_path": "ztfquery/fields.py", "max_forks_repo_name": "pierfra-ro/ztfquery", "max_forks_repo_head_hexsha": "8e0389719be3127887655f147f69350d316d8fd0", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 11, "max_forks_repo_forks_event_min_datetime": "2018-11-26T22:41:43.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-27T13:21:08.000Z", "avg_line_length": 38.151372549, "max_line_length": 148, "alphanum_fraction": 0.5568735481, "include": true, "reason": "import numpy,from astropy", "num_tokens": 12535, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5078118642792044, "lm_q2_score": 0.373875808818685, "lm_q1q2_score": 0.18985857148511184}} {"text": "import abc\nfrom collections import defaultdict\nfrom typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union, overload\n\nimport numpy\nfrom openff.utilities import requires_package\nfrom pydantic import BaseModel, Field, constr\nfrom typing_extensions import Literal\n\nfrom openff.recharge.aromaticity import AromaticityModel, AromaticityModels\nfrom openff.recharge.charges.exceptions import UnableToAssignChargeError\nfrom openff.recharge.utilities.openeye import import_oechem\n\nif TYPE_CHECKING:\n\n try:\n import torch\n except ImportError:\n torch = None\n\n from openeye.oechem import OEMol\n from openff.toolkit.topology import Molecule\n from openff.toolkit.typing.engines.smirnoff import VirtualSiteHandler\n\nExclusionPolicy = Literal[\"none\", \"parents\"]\n\nVirtualSiteKey = Tuple[str, str, str]\nVirtualSiteChargeKey = Tuple[str, str, str, int]\nVirtualSiteGeometryKey = Tuple[\n str, str, str, Literal[\"distance\", \"in_plane_angle\", \"out_of_plane_angle\"]\n]\n\n_DEGREES_TO_RADIANS = numpy.pi / 180.0\n\n\nclass _VirtualSiteParameter(BaseModel, abc.ABC):\n \"\"\"The base class for virtual site parameters.\"\"\"\n\n type: Literal[\"base-virtual-site\"]\n\n smirks: constr(min_length=1) = Field(\n ...,\n description=\"A SMIRKS pattern that encodes the chemical environment that \"\n \"this parameter should be applied to.\",\n )\n name: Optional[str] = Field(\n None, description=\"An optional name associated with this virtual site.\"\n )\n\n distance: float = Field(\n ...,\n description=\"The distance to place the virtual site along its associated basis.\",\n )\n charge_increments: Tuple[float, ...] = Field(\n ...,\n description=\"The amount of charge [e] to be transferred from the virtual site \"\n \"to each tagged atom that forms the basis for the virtual site.\",\n )\n\n sigma: float = Field(\n ..., description=\"The LJ sigma parameter [A] associated with the virtual site.\"\n )\n epsilon: float = Field(\n ...,\n description=\"The LJ espilon [kJ / mol] parameter associated with the virtual \"\n \"site.\",\n )\n\n match: Literal[\"once\", \"all-permutations\"] = Field(..., description=\"...\")\n\n @classmethod\n @abc.abstractmethod\n def local_frame_weights(cls) -> numpy.ndarray:\n \"\"\"Returns a matrix of the weights to apply to a matrix of the coordinates of\n the virtual sites' parent atoms to yield the origin, x and y vectors of the\n virtual sites local frame with shape=(3, n_parent_atoms).\"\"\"\n raise NotImplementedError()\n\n @property\n @abc.abstractmethod\n def local_frame_coordinates(self) -> numpy.ndarray:\n \"\"\"Returns a 1 X 3 array of the spherical coordinates (``[d, theta, phi]``) of\n this virtual site with respect to its local frame.\n \"\"\"\n raise NotImplementedError()\n\n\nclass BondChargeSiteParameter(_VirtualSiteParameter):\n\n type: Literal[\"BondCharge\"] = \"BondCharge\"\n\n @classmethod\n def local_frame_weights(cls) -> numpy.ndarray:\n return numpy.array([[1.0, 0.0], [-1.0, 1.0], [-1.0, 1.0]])\n\n @property\n def local_frame_coordinates(self) -> numpy.ndarray:\n # distance, theta, phi\n return numpy.array([[self.distance, 180.0, 0.0]])\n\n\nclass MonovalentLonePairParameter(_VirtualSiteParameter):\n\n type: Literal[\"MonovalentLonePair\"] = \"MonovalentLonePair\"\n\n in_plane_angle: float = Field(\n ...,\n description=\"The angle [deg] to move the virtual site in the plane defined \"\n \"by the tagged atoms by.\",\n )\n out_of_plane_angle: float = Field(\n ...,\n description=\"The angle [deg] to move the virtual site out of the plane \"\n \"defined by the tagged atoms by.\",\n )\n\n @classmethod\n def local_frame_weights(cls) -> numpy.ndarray:\n return numpy.array([[1.0, 0.0, 0.0], [-1.0, 1.0, 0.0], [-1.0, 0.0, 1.0]])\n\n @property\n def local_frame_coordinates(self) -> numpy.ndarray:\n # distance, theta, phi\n return numpy.array(\n [[self.distance, self.in_plane_angle, self.out_of_plane_angle]]\n )\n\n\nclass DivalentLonePairParameter(_VirtualSiteParameter):\n\n type: Literal[\"DivalentLonePair\"] = \"DivalentLonePair\"\n\n out_of_plane_angle: float = Field(\n ...,\n description=\"The angle [deg] to move the virtual site out of the plane \"\n \"defined by the tagged atoms by.\",\n )\n\n @classmethod\n def local_frame_weights(cls) -> numpy.ndarray:\n return numpy.array([[0.0, 1.0, 0.0], [0.5, -1.0, 0.5], [1.0, -1.0, 0.0]])\n\n @property\n def local_frame_coordinates(self) -> numpy.ndarray:\n # distance, theta, phi\n return numpy.array([[self.distance, 180.0, self.out_of_plane_angle]])\n\n\nclass TrivalentLonePairParameter(_VirtualSiteParameter):\n\n type: Literal[\"TrivalentLonePair\"] = \"TrivalentLonePair\"\n\n @classmethod\n def local_frame_weights(cls) -> numpy.ndarray:\n return numpy.array(\n [\n [0.0, 1.0, 0.0, 0.0],\n [1.0 / 3.0, -1.0, 1.0 / 3.0, 1.0 / 3.0],\n [1.0, -1.0, 0.0, 0.0],\n ]\n )\n\n @property\n def local_frame_coordinates(self) -> numpy.ndarray:\n # distance, theta, phi\n return numpy.array([[self.distance, 180.0, 0.0]])\n\n\nVirtualSiteParameterType = Union[\n BondChargeSiteParameter,\n MonovalentLonePairParameter,\n DivalentLonePairParameter,\n TrivalentLonePairParameter,\n]\n\n\nclass VirtualSiteCollection(BaseModel):\n \"\"\"A collection of virtual site parameters that are based off of the SMIRNOFF\n specification.\"\"\"\n\n parameters: List[VirtualSiteParameterType] = Field(\n ...,\n description=\"The virtual site parameters to apply.\",\n )\n aromaticity_model: AromaticityModels = Field(\n AromaticityModels.MDL,\n description=\"The model to use when assigning aromaticity.\",\n )\n\n exclusion_policy: ExclusionPolicy = Field(\"parents\", description=\"...\")\n\n @requires_package(\"openff.toolkit\")\n @requires_package(\"simtk\")\n def to_smirnoff(self) -> \"VirtualSiteHandler\":\n \"\"\"Converts this collection of virtual site parameters to a SMIRNOFF virtual\n site parameter handler.\n\n Returns\n -------\n The constructed parameter handler.\n \"\"\"\n\n from openff.toolkit.typing.engines.smirnoff import VirtualSiteHandler\n from simtk import unit\n\n # noinspection PyTypeChecker\n parameter_handler = VirtualSiteHandler(\n version=\"0.3\", exclusion_policy=self.exclusion_policy\n )\n\n for parameter in reversed(self.parameters):\n\n parameter_kwargs = dict(\n smirks=parameter.smirks,\n type=parameter.type,\n name=parameter.name,\n distance=parameter.distance * unit.angstrom,\n charge_increment=[\n charge * unit.elementary_charge\n for charge in parameter.charge_increments\n ],\n sigma=parameter.sigma * unit.angstrom,\n epsilon=parameter.epsilon * unit.kilojoules_per_mole,\n match=parameter.match.replace(\"-\", \"_\").lower(),\n )\n\n if parameter.type == \"MonovalentLonePair\":\n\n parameter_kwargs[\"outOfPlaneAngle\"] = (\n parameter.out_of_plane_angle * unit.degrees\n )\n parameter_kwargs[\"inPlaneAngle\"] = (\n parameter.in_plane_angle * unit.degrees\n )\n\n elif parameter.type == \"DivalentLonePair\":\n\n parameter_kwargs[\"outOfPlaneAngle\"] = (\n parameter.out_of_plane_angle * unit.degrees\n )\n\n parameter_handler.add_parameter(parameter_kwargs=parameter_kwargs)\n\n return parameter_handler\n\n @classmethod\n @requires_package(\"simtk\")\n def from_smirnoff(\n cls,\n parameter_handler: \"VirtualSiteHandler\",\n aromaticity_model=AromaticityModels.MDL,\n ) -> \"VirtualSiteCollection\":\n \"\"\"Attempts to convert a SMIRNOFF virtual site parameter handler to a virtual\n site parameter collection.\n\n Parameters\n ----------\n parameter_handler\n The parameter handler to convert.\n aromaticity_model\n The model which describes how aromaticity should be assigned\n when applying the virtual site correction parameters.\n\n Returns\n -------\n The converted virtual site collection.\n \"\"\"\n\n from simtk import unit\n\n parameters = []\n\n for smirnoff_parameter in reversed(parameter_handler.parameters):\n\n base_kwargs = dict(\n smirks=smirnoff_parameter.smirks,\n name=smirnoff_parameter.name,\n distance=smirnoff_parameter.distance.value_in_unit(unit.angstrom),\n charge_increments=tuple(\n charge.value_in_unit(unit.elementary_charge)\n for charge in smirnoff_parameter.charge_increment\n ),\n sigma=smirnoff_parameter.sigma.value_in_unit(unit.angstrom),\n epsilon=smirnoff_parameter.epsilon.value_in_unit(\n unit.kilojoules_per_mole\n ),\n match=smirnoff_parameter.match.replace(\"_\", \"-\").lower(),\n )\n\n if smirnoff_parameter.type == \"BondCharge\":\n parameter = BondChargeSiteParameter(**base_kwargs)\n\n elif smirnoff_parameter.type == \"MonovalentLonePair\":\n\n parameter = MonovalentLonePairParameter(\n **base_kwargs,\n out_of_plane_angle=smirnoff_parameter.outOfPlaneAngle.value_in_unit(\n unit.degrees\n ),\n in_plane_angle=smirnoff_parameter.inPlaneAngle.value_in_unit(\n unit.degrees\n ),\n )\n\n elif smirnoff_parameter.type == \"DivalentLonePair\":\n\n parameter = DivalentLonePairParameter(\n **base_kwargs,\n out_of_plane_angle=smirnoff_parameter.outOfPlaneAngle.value_in_unit(\n unit.degrees\n ),\n )\n\n elif smirnoff_parameter.type == \"TrivalentLonePair\":\n parameter = TrivalentLonePairParameter(**base_kwargs)\n\n else:\n raise NotImplementedError()\n\n parameters.append(parameter)\n\n return VirtualSiteCollection(\n parameters=parameters,\n aromaticity_model=aromaticity_model,\n exclusion_policy=parameter_handler.exclusion_policy.lower(),\n )\n\n def vectorize_coordinates(\n self, parameter_keys: List[VirtualSiteGeometryKey]\n ) -> numpy.ndarray:\n \"\"\"Returns a flat vector of the local frame coordinate values associated with a\n specified set of 'keys'.\n\n Parameters\n ----------\n parameter_keys\n A list of parameter 'keys' of the form ``(smirks, type, name, attr)`` that\n specify which local frame coordinate to include in the returned vector.\n\n The allowed attributes are ``distance``, ``in_plane_angle``,\n ``out_of_plane_angle``\n\n Returns\n -------\n A vector of local frame coordinate with shape=(n_keys, 1)\n \"\"\"\n\n parameters_by_key = {\n (parameter.smirks, parameter.type, parameter.name): parameter\n for parameter in self.parameters\n }\n\n parameter_values = numpy.array(\n [\n [getattr(parameters_by_key[tuple(parameter_key)], attribute)]\n for *parameter_key, attribute in parameter_keys\n ]\n )\n\n return parameter_values\n\n def vectorize_charge_increments(\n self, parameter_keys: List[VirtualSiteChargeKey]\n ) -> numpy.ndarray:\n \"\"\"Returns a flat vector of the charge increment values associated with a\n specified set of 'keys'.\n\n Parameters\n ----------\n parameter_keys\n A list of parameter 'keys' of the form ``(smirks, type, name, idx)`` that\n specify which charge increments to include in the returned vector, where\n `idx` is an integer index into a parameters' ``charge_increments`` tuple.\n\n Returns\n -------\n A vector of charge increments with shape=(n_keys, 1)\n \"\"\"\n\n parameters_by_key = {\n (parameter.smirks, parameter.type, parameter.name): parameter\n for parameter in self.parameters\n }\n\n return numpy.array(\n [\n [\n parameters_by_key[tuple(parameter_key)].charge_increments[\n charge_index\n ]\n ]\n for *parameter_key, charge_index in parameter_keys\n ]\n )\n\n\nclass VirtualSiteGenerator:\n @classmethod\n def _apply_virtual_sites(\n cls, oe_molecule: \"OEMol\", vsite_collection: VirtualSiteCollection\n ) -> Tuple[\"Molecule\", Dict[Tuple[int, ...], List[VirtualSiteKey]]]:\n \"\"\"Applies a virtual site collection to a molecule.\n\n Parameters\n ----------\n oe_molecule\n The molecule to build the virtual sites for.\n vsite_collection\n The v-site collection to use to create the virtual sites.\n\n Returns\n -------\n An OpenFF molecule with virtual sites as well as a dictionary that maps each\n virtual site back to the parameter that yielded it.\n \"\"\"\n\n from openff.toolkit.topology import Molecule\n\n parameter_handler = vsite_collection.to_smirnoff()\n\n off_topology = parameter_handler.create_openff_virtual_sites(\n Molecule.from_openeye(oe_molecule).to_topology()\n )\n off_molecule = next(off_topology.reference_molecules)\n\n term_topology = parameter_handler._term_map_topology(off_topology)\n\n assigned_vsite_keys = defaultdict(set)\n\n for (_, atom_indices), vsite_keys in term_topology.items():\n\n for vsite_key in vsite_keys:\n\n (_, (smirks, (vsite_type, (vsite_name, _)))) = vsite_key\n assigned_vsite_keys[atom_indices].add((smirks, vsite_type, vsite_name))\n\n return off_molecule, {\n atom_indices: [*keys] for atom_indices, keys in assigned_vsite_keys.items()\n }\n\n @classmethod\n def _build_charge_increment_array(\n cls, vsite_collection: VirtualSiteCollection\n ) -> Tuple[numpy.ndarray, List[VirtualSiteChargeKey]]:\n \"\"\"Returns a flat vector of the charge increments contained within a virtual site\n collection as well as a list of keys that map each value back to its original\n parameter.\n\n Parameters\n ----------\n vsite_collection\n The collection containing the v-site parameters.\n\n Returns\n -------\n ...\n \"\"\"\n\n charge_values = []\n charge_keys = []\n\n for parameter in vsite_collection.parameters:\n\n for i, charge_increment in enumerate(parameter.charge_increments):\n\n charge_values.append(charge_increment)\n\n charge_keys.append(\n (parameter.smirks, parameter.type, parameter.name, i)\n )\n\n return numpy.array(charge_values), charge_keys\n\n @classmethod\n def _validate_charge_assignment_matrix(\n cls,\n assignment_matrix: numpy.ndarray,\n ):\n \"\"\"Validates the charge increment assignment matrix.\n\n Parameters\n ----------\n assignment_matrix\n The assignment matrix to validate with\n shape=(n_atoms + n_vsites, n_charge_increments)\n \"\"\"\n\n non_zero_assignments = assignment_matrix.sum(axis=0).astype(bool)\n\n if non_zero_assignments.any():\n\n raise UnableToAssignChargeError(\n \"An internal error occurred. The v-site charge increments alter the \"\n \"total charge of the molecule\"\n )\n\n @classmethod\n def build_charge_assignment_matrix(\n cls,\n oe_molecule: \"OEMol\",\n vsite_collection: VirtualSiteCollection,\n ) -> numpy.ndarray:\n \"\"\"Generates a matrix that specifies which v-site charge increments have been\n applied to which atoms in the molecule.\n\n The matrix takes the form ...\n\n Parameters\n ----------\n oe_molecule\n The molecule to assign the v-site charge increments to.\n vsite_collection\n The v-site parameters that may be assigned.\n\n Returns\n -------\n The assignment matrix with shape=(n_atoms + n_vsites, n_charge_increments)\n where ...\n \"\"\"\n\n oechem = import_oechem()\n\n # Make a copy of the molecule to assign the aromatic flags to.\n oe_molecule = oechem.OEMol(oe_molecule)\n # Assign aromaticity flags to ensure correct smirks matches.\n AromaticityModel.assign(oe_molecule, vsite_collection.aromaticity_model)\n\n off_molecule, assigned_vsite_keys = cls._apply_virtual_sites(\n oe_molecule, vsite_collection\n )\n\n _, all_vsite_keys = cls._build_charge_increment_array(vsite_collection)\n\n n_particles = off_molecule.n_particles\n n_corrections = len(all_vsite_keys)\n\n assignment_matrix = numpy.zeros((n_particles, n_corrections))\n\n for vsite_particle in [\n vsite_particle\n for vsite in off_molecule.virtual_sites\n for vsite_particle in vsite.particles\n ]:\n\n vsite_index = vsite_particle.molecule_particle_index\n vsite_parameter_keys = assigned_vsite_keys[vsite_particle.orientation]\n\n for vsite_parameter_key in vsite_parameter_keys:\n\n for i, atom_index in enumerate(vsite_particle.orientation):\n\n # noinspection PyTypeChecker\n vsite_parameter_index = all_vsite_keys.index(\n (*vsite_parameter_key, i)\n )\n\n assignment_matrix[atom_index, vsite_parameter_index] += 1\n assignment_matrix[vsite_index, vsite_parameter_index] -= 1\n\n cls._validate_charge_assignment_matrix(assignment_matrix)\n return assignment_matrix\n\n @classmethod\n def apply_charge_assignment_matrix(\n cls,\n assignment_matrix: numpy.ndarray,\n vsite_collection: VirtualSiteCollection,\n ) -> numpy.ndarray:\n \"\"\"Applies an assignment matrix to a list of virtual site parameters to yield the\n final charges increments due to the virtual sites for a molecule.\n\n Parameters\n ----------\n assignment_matrix\n The virtual site charge increment assignment matrix constructed using\n ``build_charge_assignment_matrix`` that describes how the virtual site\n charge increments should be applied. This should have\n shape=(n_atoms + n_vsites, n_charge_increments)\n vsite_collection\n The virtual site parameters that may be assigned.\n\n Returns\n -------\n The charge increments with shape=(n_atoms + n_vsites, 1).\n \"\"\"\n\n correction_values, _ = cls._build_charge_increment_array(vsite_collection)\n charge_corrections = assignment_matrix @ correction_values\n\n if not numpy.isclose(charge_corrections.sum(), 0.0):\n\n raise UnableToAssignChargeError(\n \"An internal error occurred. The bond charge corrections were applied \"\n \"in such a way so that the total charge of the molecule will be \"\n \"altered.\"\n )\n\n return charge_corrections.reshape(-1, 1)\n\n @classmethod\n def generate_charge_increments(\n cls,\n oe_molecule: \"OEMol\",\n vsite_collection: VirtualSiteCollection,\n ) -> numpy.ndarray:\n \"\"\"Generate a set of charge increments due to virtual sites for a molecule.\n\n Parameters\n ----------\n oe_molecule\n The molecule to generate the charge increments for.\n vsite_collection\n The virtual site parameters that may be assigned.\n\n Returns\n -------\n The charge increments with shape=(n_atoms + n_vsites, 1) that should be\n applied to the molecule.\n \"\"\"\n\n assignment_matrix = cls.build_charge_assignment_matrix(\n oe_molecule, vsite_collection\n )\n\n generated_corrections = cls.apply_charge_assignment_matrix(\n assignment_matrix, vsite_collection\n )\n\n return generated_corrections\n\n @classmethod\n def build_local_coordinate_frames(\n cls,\n conformer: numpy.ndarray,\n assigned_parameters: Dict[Tuple[int, ...], List[VirtualSiteParameterType]],\n ) -> numpy.ndarray:\n \"\"\"Builds an orthonormal coordinate frame for each virtual particle\n based on the type of virtual site and the coordinates of the parent atoms.\n\n Notes\n -----\n * See `the OpenMM documentation for further information\n `_.\n\n Parameters\n ----------\n conformer\n The conformer of the molecule that the virtual sites are being added to\n with shape=(n_atoms, 3) and units of [A].\n assigned_parameters\n A dictionary of the form ``assigned_parameters[atom_indices] = parameters``\n where ``atom_indices`` is a tuple of indices corresponding to the atoms\n that the virtual site is connected to, and ``parameters`` is a list of the\n parameters that describe the virtual sites.\n\n Returns\n -------\n An array storing the local frames of all virtual sites with\n shape=(4, n_vsites, 3) whereby ``local_frames[0]`` is an array of the\n origins of each frame, ``local_frames[1]`` the x-directions,\n ``local_frames[2]`` the y-directions, and ``local_frames[2]`` the\n z-directions.\n \"\"\"\n\n stacked_frames = [[], [], [], []]\n\n for parent_indices, vsite_parameter in (\n (parent_indices, vsite_parameter)\n for parent_indices, vsite_parameters in assigned_parameters.items()\n for vsite_parameter in vsite_parameters\n ):\n parent_coordinates = conformer[parent_indices, :]\n\n weighted_coordinates = (\n vsite_parameter.local_frame_weights() @ parent_coordinates\n )\n\n origin = weighted_coordinates[0, :]\n\n xy_plane = weighted_coordinates[1:, :]\n xy_plane_norm = xy_plane / numpy.sqrt(\n (xy_plane * xy_plane).sum(-1)\n ).reshape(-1, 1)\n\n x_hat = xy_plane_norm[0, :]\n z_hat = numpy.cross(x_hat, xy_plane[1, :])\n y_hat = numpy.cross(z_hat, x_hat)\n\n stacked_frames[0].append(origin.reshape(1, -1))\n stacked_frames[1].append(x_hat.reshape(1, -1))\n stacked_frames[2].append(y_hat.reshape(1, -1))\n stacked_frames[3].append(z_hat.reshape(1, -1))\n\n local_frames = numpy.stack([numpy.vstack(frames) for frames in stacked_frames])\n return local_frames\n\n @classmethod\n @overload\n def convert_local_coordinates(\n cls,\n local_frame_coordinates: numpy.ndarray,\n local_coordinate_frames: numpy.ndarray,\n backend: Literal[\"numpy\"],\n ) -> numpy.ndarray:\n ...\n\n @classmethod\n @overload\n def convert_local_coordinates(\n cls,\n local_frame_coordinates: \"torch.Tensor\",\n local_coordinate_frames: \"torch.Tensor\",\n backend: Literal[\"torch\"],\n ) -> \"torch.Tensor\":\n ...\n\n @classmethod\n def convert_local_coordinates(\n cls,\n local_frame_coordinates,\n local_coordinate_frames,\n backend: Literal[\"numpy\", \"torch\"] = \"numpy\",\n ) -> numpy.ndarray:\n \"\"\"Converts a set of local virtual site coordinates defined in a spherical\n coordinate system into a full set of cartesian coordinates.\n\n Parameters\n ----------\n local_frame_coordinates\n An array containing the local coordinates with shape=(n_vsites, 3) and with\n columns of distance [A], 'in plane angle' [deg] and 'out of plane'\n angle [deg].\n local_coordinate_frames\n The orthonormal basis associated with each of the virtual sites with\n shape=(4, n_vsites, 3). See the ``build_local_coordinate_frames`` function\n for more details.\n backend\n The framework to use when performing mathematical operations.\n\n Returns\n -------\n An array of the cartesian coordinates of the virtual sites with\n shape=(n_vsites, 3) and units of [A].\n \"\"\"\n\n if backend == \"numpy\":\n np = numpy\n elif backend == \"torch\":\n import torch\n\n np = torch\n else:\n raise NotImplementedError()\n\n d = local_frame_coordinates[:, 0].reshape(-1, 1)\n\n theta = (local_frame_coordinates[:, 1] * _DEGREES_TO_RADIANS).reshape(-1, 1)\n phi = (local_frame_coordinates[:, 2] * _DEGREES_TO_RADIANS).reshape(-1, 1)\n\n cos_theta = np.cos(theta)\n sin_theta = np.sin(theta)\n\n cos_phi = np.cos(phi)\n sin_phi = np.sin(phi)\n\n # Here we use cos(phi) in place of sin(phi) and sin(phi) in place of cos(phi)\n # this is because we want phi=0 to represent a 0 degree angle from the x-y plane\n # rather than 0 degrees from the z-axis.\n vsite_positions = (\n local_coordinate_frames[0]\n + d * cos_theta * cos_phi * local_coordinate_frames[1]\n + d * sin_theta * cos_phi * local_coordinate_frames[2]\n + d * sin_phi * local_coordinate_frames[3]\n )\n\n return vsite_positions\n\n @classmethod\n def generate_positions(\n cls,\n oe_molecule: \"OEMol\",\n vsite_collection: VirtualSiteCollection,\n conformer: numpy.ndarray,\n ):\n \"\"\"Computes the positions of a set of virtual sites relative to a provided\n molecule in a given conformer.\n\n Parameters\n ----------\n oe_molecule\n The molecule to apply virtual sites to.\n vsite_collection\n The virtual site parameters to apply to the molecule\n conformer\n The conformer [A] of the molecule with shape=(n_atoms, 3) that the virtual\n sites should be placed relative to.\n\n Returns\n -------\n An array of virtual site positions [A] with shape=(n_vsites, 3).\n \"\"\"\n\n vsite_parameters_by_key = {\n (parameter.smirks, parameter.type, parameter.name): parameter\n for parameter in vsite_collection.parameters\n }\n\n # Extract the values of the assigned parameters.\n _, assigned_parameter_map = cls._apply_virtual_sites(\n oe_molecule, vsite_collection\n )\n assigned_parameters = {\n atom_indices: [vsite_parameters_by_key[key] for key in parameter_keys]\n for atom_indices, parameter_keys in assigned_parameter_map.items()\n }\n\n local_frame_coordinates = numpy.vstack(\n [\n parameter.local_frame_coordinates\n for parent_indices, parameters in assigned_parameters.items()\n for parameter in parameters\n ]\n )\n\n # Construct the global cartesian coordinates of the v-sites.\n local_coordinate_frames = cls.build_local_coordinate_frames(\n conformer, assigned_parameters\n )\n vsite_positions = VirtualSiteGenerator.convert_local_coordinates(\n local_frame_coordinates, local_coordinate_frames, backend=\"numpy\"\n )\n\n return vsite_positions\n", "meta": {"hexsha": "95f4edf1428834604ad8848f2194ec5442b01b6c", "size": 28128, "ext": "py", "lang": "Python", "max_stars_repo_path": "openff/recharge/charges/vsite.py", "max_stars_repo_name": "openforcefield/openff-recharge", "max_stars_repo_head_hexsha": "0ea3ef986e33c3ecf05924e64fb2e1872913b093", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7, "max_stars_repo_stars_event_min_datetime": "2020-07-20T02:56:48.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-22T18:09:00.000Z", "max_issues_repo_path": "openff/recharge/charges/vsite.py", "max_issues_repo_name": "openforcefield/openff-recharge", "max_issues_repo_head_hexsha": "0ea3ef986e33c3ecf05924e64fb2e1872913b093", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 94, "max_issues_repo_issues_event_min_datetime": "2020-07-07T23:59:40.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T09:03:22.000Z", "max_forks_repo_path": "openff/recharge/charges/vsite.py", "max_forks_repo_name": "openforcefield/openff-recharge", "max_forks_repo_head_hexsha": "0ea3ef986e33c3ecf05924e64fb2e1872913b093", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.726618705, "max_line_length": 89, "alphanum_fraction": 0.6161831627, "include": true, "reason": "import numpy", "num_tokens": 5872, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.538983220687684, "lm_q2_score": 0.35220179564702847, "lm_q1q2_score": 0.18983085814982092}} {"text": "\"\"\"\nCopyright 2021 The CVXPY Developers\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n\"\"\"\n\n\nimport warnings\n\nimport scipy # For version checks\n\nimport cvxpy.settings as s\nfrom cvxpy.constraints import NonNeg, Zero\nfrom cvxpy.reductions.solution import Solution, failure_solution\nfrom cvxpy.reductions.solvers import utilities\nfrom cvxpy.reductions.solvers.conic_solvers.conic_solver import ConicSolver\nfrom cvxpy.utilities.versioning import Version\n\n\nclass SCIPY(ConicSolver):\n \"\"\"An interface for the SciPy linprog function.\n Note: This requires a version of SciPy which is >= 1.6.1\n \"\"\"\n\n # Solver capabilities.\n MIP_CAPABLE = False\n SUPPORTED_CONSTRAINTS = ConicSolver.SUPPORTED_CONSTRAINTS\n\n # Map of SciPy linprog status\n STATUS_MAP = {0: s.OPTIMAL, # Optimal\n 1: s.SOLVER_ERROR, # Iteration limit reached\n 2: s.INFEASIBLE, # Infeasible\n 3: s.UNBOUNDED, # Unbounded\n 4: s.SOLVER_ERROR # Numerical difficulties encountered\n }\n\n def import_solver(self) -> None:\n \"\"\"Imports the solver.\n \"\"\"\n from scipy import optimize as opt\n opt # For flake8\n\n def name(self):\n \"\"\"The name of the solver.\n \"\"\"\n return s.SCIPY\n\n def apply(self, problem):\n \"\"\"Returns a new problem and data for inverting the new solution.\n\n Returns\n -------\n tuple\n (dict of arguments needed for the solver, inverse data)\n \"\"\"\n data = {}\n inv_data = {self.VAR_ID: problem.x.id}\n\n if not problem.formatted:\n problem = self.format_constraints(problem, None)\n data[s.PARAM_PROB] = problem\n data[self.DIMS] = problem.cone_dims\n inv_data[self.DIMS] = problem.cone_dims\n\n constr_map = problem.constr_map\n inv_data[self.EQ_CONSTR] = constr_map[Zero]\n inv_data[self.NEQ_CONSTR] = constr_map[NonNeg]\n len_eq = problem.cone_dims.zero\n\n c, d, A, b = problem.apply_parameters()\n data[s.C] = c\n inv_data[s.OFFSET] = d\n data[s.A] = -A[:len_eq]\n if data[s.A].shape[0] == 0:\n data[s.A] = None\n data[s.B] = b[:len_eq].flatten()\n if data[s.B].shape[0] == 0:\n data[s.B] = None\n data[s.G] = -A[len_eq:]\n if 0 in data[s.G].shape:\n data[s.G] = None\n data[s.H] = b[len_eq:].flatten()\n if 0 in data[s.H].shape:\n data[s.H] = None\n return data, inv_data\n\n def solve_via_data(self, data, warm_start: bool, verbose: bool, solver_opts, solver_cache=None):\n from scipy import optimize as opt\n\n # Set default method which can be overriden by user inputs\n if (Version(scipy.__version__) < Version('1.6.1')):\n meth = \"interior-point\"\n else:\n meth = \"highs\"\n\n # Extract solver options which are not part of the options dictionary\n if solver_opts:\n\n # Raise error message if the parameters are not passed in\n # a dictionary called 'scipy_options'.\n if \"scipy_options\" not in solver_opts:\n raise ValueError(\"All parameters for the SCIPY solver should \"\n \"be incased within a dictionary called \"\n \"scipy_options e.g. \\n\"\n \"prob.solve(solver='SCIPY', verbose=True,\"\n \" scipy_options={'method':'highs-ds', 'maxiter':10000})\")\n\n # Raise warning if the 'method' parameter is not specified\n if \"method\" not in solver_opts['scipy_options']:\n warnings.warn(\"It is best to specify the 'method' parameter \"\n \"within scipy_options. The main advantage \"\n \"of this solver, is its ability to use the \"\n \"HiGHS LP solvers via scipy.optimize.linprog() \"\n \"which require a SciPy version >= 1.6.1 .\"\n \"\\n\\nThe default method '{}' will be\"\n \" used in this case.\\n\".format(meth))\n\n else:\n meth = solver_opts['scipy_options'].pop(\"method\")\n\n # Check to see if scipy version larger than 1.6.1 is installed\n # if method chosen is one of the highs methods.\n ver = (Version(scipy.__version__) < Version('1.6.1'))\n if ((meth in ['highs-ds', 'highs-ipm', 'highs']) & ver):\n raise ValueError(\"The HiGHS solvers require a SciPy version >= 1.6.1\")\n\n # Disable the 'bounds' parameter to avoid problems with\n # canonicalised problems.\n if \"bounds\" in solver_opts['scipy_options']:\n raise ValueError(\"Please do not specify bounds through \"\n \"scipy_options. Please specify bounds \"\n \"through CVXPY.\")\n\n # Not supported by HiGHS solvers:\n # callback = solver_opts['scipy_options'].pop(\"callback\", None)\n # x0 = solver_opts['scipy_options'].pop(\"x0\", None)\n\n # Run the optimisation using scipy.optimize.linprog\n solution = opt.linprog(data[s.C], A_ub=data[s.G], b_ub=data[s.H],\n A_eq=data[s.A], b_eq=data[s.B], method=meth,\n bounds=(None, None), options=solver_opts['scipy_options'])\n else:\n\n warnings.warn(\"It is best to specify the 'method' parameter \"\n \"within scipy_options. The main advantage \"\n \"of this solver, is its ability to use the \"\n \"HiGHS LP solvers via scipy.optimize.linprog() \"\n \"which require a SciPy version >= 1.6.1 .\"\n \"\\n\\nThe default method '{}' will be\"\n \" used in this case.\\n\".format(meth))\n\n # Run the optimisation using scipy.optimize.linprog\n solution = opt.linprog(data[s.C], A_ub=data[s.G], b_ub=data[s.H],\n A_eq=data[s.A], b_eq=data[s.B], method=meth,\n bounds=(None, None))\n\n if verbose is True:\n print(\"Solver terminated with message: \" + solution.message)\n\n return solution\n\n def invert(self, solution, inverse_data):\n \"\"\"Returns the solution to the original problem given the inverse_data.\n \"\"\"\n status = self.STATUS_MAP[solution['status']]\n\n primal_vars = None\n dual_vars = None\n if status in s.SOLUTION_PRESENT:\n primal_val = solution['fun']\n opt_val = primal_val + inverse_data[s.OFFSET]\n primal_vars = {inverse_data[self.VAR_ID]: solution['x']}\n\n # SciPy linprog only returns duals for version >= 1.7.0\n # and method is one of 'highs', 'highs-ds' or 'highs-ipm'\n if ('ineqlin' in solution.keys()):\n eq_dual = utilities.get_dual_values(\n -solution['eqlin']['marginals'],\n utilities.extract_dual_value,\n inverse_data[self.EQ_CONSTR])\n leq_dual = utilities.get_dual_values(\n -solution['ineqlin']['marginals'],\n utilities.extract_dual_value,\n inverse_data[self.NEQ_CONSTR])\n eq_dual.update(leq_dual)\n dual_vars = eq_dual\n\n return Solution(status, opt_val, primal_vars, dual_vars, {})\n else:\n return failure_solution(status)\n", "meta": {"hexsha": "4ada088bd56770082f57d98de21cbd1538f85ab9", "size": 8157, "ext": "py", "lang": "Python", "max_stars_repo_path": "cvxpy/reductions/solvers/conic_solvers/scipy_conif.py", "max_stars_repo_name": "QiuWJX/cvxpy", "max_stars_repo_head_hexsha": "fd1c225b0cdf541618e292cae1a4c7ea25ddc934", "max_stars_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "cvxpy/reductions/solvers/conic_solvers/scipy_conif.py", "max_issues_repo_name": "QiuWJX/cvxpy", "max_issues_repo_head_hexsha": "fd1c225b0cdf541618e292cae1a4c7ea25ddc934", "max_issues_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "cvxpy/reductions/solvers/conic_solvers/scipy_conif.py", "max_forks_repo_name": "QiuWJX/cvxpy", "max_forks_repo_head_hexsha": "fd1c225b0cdf541618e292cae1a4c7ea25ddc934", "max_forks_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.5820895522, "max_line_length": 100, "alphanum_fraction": 0.5666298884, "include": true, "reason": "import scipy,from scipy,import cvxpy,from cvxpy", "num_tokens": 1820, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5389832206876841, "lm_q2_score": 0.35220178204788966, "lm_q1q2_score": 0.18983085082011333}} {"text": "# THIS IS AN OLD FILE TO REIMPLEMENT, NOT MEANT TO BE IMPORTED\nraise ImportError()\n\n\n\"\"\"Deep Belief Netork as Bandit\n\"\"\"\nimport copy\nimport cPickle\nimport logging\nimport os\nimport subprocess\nimport sys\nimport time\nlogger = logging.getLogger(__name__)\n\nimport numpy\nfrom bson import SON, BSON\n\nimport theano\nfrom theano import tensor\n\n# scikit-data\nfrom skdata.tasks import classification_train_valid_test\n\n# XXX use scikits-learn for PCA\nimport pylearn_pca\n\nfrom base import Bandit\nfrom utils import json_call\n\ntry:\n RandomStreams = theano.sandbox.cuda.CURAND_RandomStreams\nexcept:\n RandomStreams = tensor.shared_randomstreams.RandomStreams\n\nfrom ht_dist2 import rSON2, one_of, rlist, uniform, lognormal, ceil_lognormal\n\n\nclass LogisticRegression(object):\n def __init__(self, x, w, b, params=None):\n if params is None:\n params = []\n self.input = x\n self.output = tensor.nnet.softmax(tensor.dot(x, w) + b)\n self.l1 = abs(w).sum()\n self.l2_sqr = (w**2).sum()\n self.argmax = tensor.argmax(\n tensor.dot(x, w) + b,\n axis=x.ndim - 1)\n self.w = w\n self.b = b\n self.params = params\n\n @classmethod\n def new(cls, input, n_in, n_out, dtype=None, name=None):\n if dtype is None:\n dtype = input.dtype\n if name is None:\n name = cls.__name__\n logger.debug('allocating params w, b: %s' % str((n_in, n_out, dtype)))\n w = theano.shared(\n numpy.zeros((n_in, n_out), dtype=dtype),\n name='%s.w' % name)\n b = theano.shared(\n numpy.zeros((n_out,), dtype=dtype),\n name='%s.b' % name)\n return cls(input, w, b, params=[w, b])\n\n\n def nll(self, target):\n \"\"\"Return the negative log-likelihood of the prediction of this model under a given\n target distribution. Passing symbolic integers here means 1-hot.\n WRITEME\n \"\"\"\n return tensor.nnet.categorical_crossentropy(self.output, target)\n\n def errors(self, target):\n \"\"\"Return a vector of 0s and 1s, with 1s on every line that was mis-classified.\n \"\"\"\n if target.ndim != self.argmax.ndim:\n raise TypeError('target should have the same shape as self.argmax',\n ('target', target.type, 'argmax', self.argmax.type))\n if target.dtype.startswith('int'):\n return theano.tensor.neq(self.argmax, target)\n else:\n raise NotImplementedError()\n\n\ndef sgd_updates(params, grads, stepsizes):\n \"\"\"Return a list of (pairs) that can be used as updates in theano.function to implement\n stochastic gradient descent.\n\n :param params: variables to adjust in order to minimize some cost\n :type params: a list of variables (theano.function will require shared variables)\n :param grads: the gradient on each param (with respect to some cost)\n :type grads: list of theano expressions\n :param stepsizes: step by this amount times the negative gradient on each iteration\n :type stepsizes: [symbolic] scalar or list of one [symbolic] scalar per param\n \"\"\"\n try:\n iter(stepsizes)\n except Exception:\n stepsizes = [stepsizes for p in params]\n if len(params) != len(grads):\n raise ValueError('params and grads have different lens')\n updates = [(p, p - step * gp) for (step, p, gp) in zip(stepsizes, params, grads)]\n return updates\n\n\ndef geom(lower, upper, round=1):\n ll = numpy.log(lower)\n lu = numpy.log(upper)\n return ceil_lognormal(.5 * (ll + lu), .4 * (lu - ll), round)\n\n\ndef dbn_template(dataset_name='skdata.larochelle_etal_2007.Rectangles',\n sup_min_epochs=300,\n sup_max_epochs=4000):\n template = rSON2(\n 'preprocessing', one_of(\n rSON2(\n 'kind', 'raw'),\n rSON2(\n 'kind', 'zca',\n 'energy', uniform(0.5, 1.0))),\n 'dataset_name', dataset_name,\n 'sup_max_epochs', sup_max_epochs,\n 'sup_min_epochs', sup_min_epochs,\n 'iseed', one_of(5, 6, 7, 8),\n 'batchsize', one_of(20, 100),\n 'lr', lognormal(numpy.log(.01), 3),\n 'lr_anneal_start', geom(100, 10000),\n 'l2_penalty', one_of(0, lognormal(numpy.log(1.0e-6), 2)),\n 'next_layer', one_of(None,\n rSON2(\n 'n_hid', geom(2**7, 2**12, round=16),\n 'W_init_dist', one_of('uniform', 'normal'),\n 'W_init_algo', one_of('old', 'Xavier'),\n 'W_init_algo_old_multiplier', lognormal(0.0, 1.0),\n 'cd_epochs', geom(1, 3000),\n 'cd_batchsize', 100,\n 'cd_sample_v0s', one_of(False, True),\n 'cd_lr', lognormal(numpy.log(.01), 2),\n 'cd_lr_anneal_start', geom(10, 10000),\n 'next_layer', one_of(None,\n rSON2(\n 'n_hid', geom(2**7, 2**12, round=16),\n 'W_init_dist', one_of('uniform', 'normal'),\n 'W_init_algo', one_of('old', 'Xavier'),\n 'W_init_algo_old_multiplier', lognormal(0.0, 1.0),\n 'cd_epochs', geom(1, 2000),\n 'cd_batchsize', 100,\n 'cd_sample_v0s', one_of(False, True),\n 'cd_lr', lognormal(numpy.log(.01), 2),\n 'cd_lr_anneal_start', geom(10, 10000),\n 'next_layer', one_of(None,\n rSON2(\n 'n_hid', geom(2**7, 2**12, round=16),\n 'W_init_dist', one_of('uniform', 'normal'),\n 'W_init_algo', one_of('old', 'Xavier'),\n 'W_init_algo_old_multiplier', lognormal(0., 1.),\n 'cd_epochs', geom(1, 1500),\n 'cd_batchsize', 100,\n 'cd_sample_v0s', one_of(False, True),\n 'cd_lr', lognormal(numpy.log(.01), 2),\n 'cd_lr_anneal_start', geom(10, 10000),\n 'next_layer', None,\n )))))))\n return template\n\n\ndef nnet1_template(dataset_name='skdata.larochelle_etal_2007.Rectangles',\n sup_min_epochs=30, # THESE ARE KINDA SMALL FOR SERIOUS RESULTS\n sup_max_epochs=400):\n template = rSON2(\n 'preprocessing', one_of(\n rSON2(\n 'kind', 'raw'),\n rSON2(\n 'kind', 'zca',\n 'energy', uniform(0.5, 1.0))),\n 'dataset_name', dataset_name,\n 'sup_max_epochs', sup_max_epochs,\n 'sup_min_epochs', sup_min_epochs,\n 'iseed', one_of(5, 6, 7, 8),\n 'batchsize', one_of(20, 100),\n 'lr', lognormal(numpy.log(.01), 3),\n 'lr_anneal_start', geom(100, 10000),\n 'l2_penalty', one_of(0, lognormal(numpy.log(1.0e-6), 3)),\n 'next_layer', rSON2(\n 'n_hid', geom(2**4, 2**10, round=16),\n 'W_init_dist', one_of('uniform', 'normal'),\n 'W_init_algo', one_of('old', 'Xavier'),\n 'W_init_algo_old_multiplier', uniform(.2, 2),\n 'cd_epochs', 0,\n 'cd_batchsize', 100,\n 'cd_sample_v0s', one_of(False, True),\n 'cd_lr', lognormal(numpy.log(.01), 3),\n 'cd_lr_anneal_start', geom(10, 10000),\n 'next_layer', None))\n return template\n\n\ndef preprocess_data(config, ctrl):\n dataset = json_call(config['dataset_name'])\n train, valid, test = classification_train_valid_test(dataset)\n X_train, y_train = numpy.asarray(train[0]), numpy.asarray(train[1])\n X_valid, y_valid = numpy.asarray(valid[0]), numpy.asarray(valid[1])\n X_test, y_test = numpy.asarray(test[0]), numpy.asarray(test[1])\n\n if config['preprocessing']['kind'] == 'pca':\n # compute pca of input (TODO: retrieve only pca_whitened input)\n raise NotImplementedError('rewrite since cut and paste')\n (eigvals,eigvecs), centered_trainset = pylearn_pca.pca_from_examples(\n X=dataset['inputs'][:dataset['n_train']],\n max_energy_fraction=config['pca_energy'])\n eigmean = dataset['inputs'][0] - centered_trainset[0]\n\n whitened_inputs = pylearn_pca.pca_whiten((eigvals,eigvecs),\n dataset['inputs']-eigmean)\n ctrl.info('PCA kept %i of %i components'%(whitened_inputs.shape[1],\n dataset['n_inputs']))\n elif config['preprocessing']['kind'] == 'zca':\n (eigvals,eigvecs), centered_trainset = pylearn_pca.pca_from_examples(\n X=X_train,\n max_energy_fraction=config['preprocessing']['energy'])\n eigmean = X_train[0] - centered_trainset[0]\n\n def whiten(X):\n X = pylearn_pca.pca_whiten((eigvals,eigvecs),\n X - eigmean)\n X = pylearn_pca.pca_whiten_inverse((eigvals, eigvecs),\n X) + eigmean\n X = X.astype('float32')\n X_min = X.min()\n X_max = X.max()\n ctrl.info('ZCA min:%f max:%f' % (X_min, X_max))\n if X_min < 0 or X_max > 1.0:\n ctrl.info('ZCA clamping return value to (0, 1) interval')\n X = numpy.clip(X, 0, 1, out=X)\n return X\n\n X_train, X_valid, X_test = [whiten(X)\n for X in [X_train, X_valid, X_test]]\n\n elif config['preprocessing']['kind'] == 'normalize':\n raise NotImplementedError('rewrite since cut and paste')\n n_train=dataset['n_train']\n whitened_inputs = dataset['inputs']\n whitened_inputs = whitened_inputs - whitened_inputs[:n_train].mean(axis=0)\n whitened_inputs /= whitened_inputs[:n_train].std(axis=0)+1e-7\n elif config['preprocessing']['kind'] == 'raw':\n pass\n else:\n raise ValueError(\n 'unrecognized preprocessing',\n config['preprocessing']['kind'])\n\n for Xy in 'X', 'y':\n for suffix in 'train', 'valid', 'test':\n varname = '%s_%s'%(Xy, suffix)\n var = locals()[varname]\n ctrl.info('%s shape=%s max=%f min=%f' % (\n varname,\n var.shape,\n var.max(),\n var.min()))\n\n s_X_train = theano.shared(X_train)\n s_y_train = theano.shared(y_train)\n s_X_valid = theano.shared(X_valid)\n s_y_valid = theano.shared(y_valid)\n s_X_test = theano.shared(X_test)\n s_y_test = theano.shared(y_test)\n\n return (dataset,\n (s_X_train, s_y_train),\n (s_X_valid, s_y_valid),\n (s_X_test, s_y_test))\n\n\ndef train_rbm(s_rng, s_idx, s_batchsize, s_features, W, vbias, hbias, n_in,\n n_hid, batchsize, sample_v0s,\n cdlr, n_epochs, n_batches_per_epoch, lr_anneal_start,\n givens={},\n time_limit=None):\n logger.info('rbm training n_in=%i n_hid=%i batchsize=%i' % (\n n_in, n_hid, batchsize))\n v0m = s_features\n if sample_v0s:\n v0s = tensor.cast(\n s_rng.uniform(size=(batchsize, n_in)) < v0m,\n 'float32')\n else:\n v0s = v0m\n\n h0m = tensor.nnet.sigmoid(tensor.dot(v0s, W) + hbias)\n h0s = tensor.cast(s_rng.uniform(size=(batchsize, n_hid)) < h0m, 'float32')\n v1m = tensor.nnet.sigmoid(tensor.dot(h0s, W.T)+vbias)\n v1s = tensor.cast(s_rng.uniform(size=(batchsize, n_in)) < v1m, 'float32')\n h1m = tensor.nnet.sigmoid(tensor.dot(v1s, W) + hbias)\n\n s_lr = tensor.scalar(dtype='float32')\n\n logger.debug('compiling cd1_fn')\n cd1_fn = theano.function([s_idx, s_batchsize, s_lr],\n [abs(v0m-v1m).mean()],\n updates={\n W: W + s_lr * (\n tensor.dot(v0s.T, h0m) - tensor.dot(v1s.T, h1m)),\n vbias: vbias + s_lr * (\n (v0s - v1s).sum(axis=0)),\n hbias: hbias + s_lr * (\n (h0m - h1m).sum(axis=0)),\n },\n givens=givens)\n for epoch in xrange(n_epochs):\n costs = []\n if time_limit and time.time() > time_limit:\n break\n e_lr = cdlr * min(1, (float(lr_anneal_start)/(epoch+1)))\n for batch_idx in xrange(n_batches_per_epoch):\n costs.append(cd1_fn(batch_idx, batchsize, e_lr))\n if not epoch % 10:\n logger.info('CD1 epoch:%i avg L1: %f'% (epoch, numpy.mean(costs)))\n if costs:\n return dict(final_recon_l1=float(numpy.mean(costs)),)\n else:\n return dict(final_recon_l1=float('nan'))\n\n_dataset_cache = {}\n\nclass DBN_Base(Bandit):\n def dryrun_config(self, *args, **kwargs):\n return dict(\n lr=.01,\n sup_max_epochs=500,\n sup_min_epochs=50,\n batchsize=10,\n preprocessing=dict(kind='zca', energy=0.8),\n iseed=5,\n n_layers=1,\n next_layer = dict(\n n_hid=50,\n W_init_dist='uniform',\n W_init_algo='Xavier',\n cd_epochs=100,\n cd_batchsize=50,\n cd_sample_v0s=True,\n cd_lr=0.1,\n cd_lr_anneal_start=3,\n next_layer = dict(\n n_hid=75,\n W_init_dist='uniform',\n W_init_algo='old',\n W_init_algo_old_multiplier=2.2,\n cd_epochs=70,\n cd_batchsize=10,\n cd_sample_v0s=False,\n cd_lr=0.01,\n cd_lr_anneal_start=30\n ),\n ),\n l2_penalty=0.1,\n lr_anneal_start=20,\n dataset_name='skdata.larochelle_etal_2007.Rectangles',\n )\n\n @classmethod\n def evaluate(cls, config, ctrl):\n time_limit = time.time() + 60 * 60 # 1hr from now\n rval = SON(dbn_train_fn_version=1)\n\n ctrl.info('starting dbn_train_fn')\n kv = config.items()\n kv.sort()\n for k,v in kv:\n ctrl.info('key=%s\\t%s' %(k,str(v)))\n\n rng = numpy.random.RandomState(config['iseed'])\n s_rng = RandomStreams(int(rng.randint(2**30)))\n\n dataset, train_Xy, valid_Xy, test_Xy = preprocess_data(config, ctrl)\n\n # allocate learning function parameters\n s_inputs_all = tensor.fmatrix('inputs')\n s_labels_all = tensor.ivector('labels')\n s_idx = tensor.lscalar('batch_idx')\n s_batchsize=tensor.lscalar('batch_size')\n s_low = s_idx * s_batchsize\n s_high = s_low + s_batchsize\n s_inputs = s_inputs_all[s_low:s_high]\n s_labels = s_labels_all[s_low:s_high]\n s_lr = tensor.scalar('lr')\n s_features = s_inputs # s_features will be modified in the model-building loop\n\n weights = []\n vbiases = []\n hbiases = []\n\n n_inputs_i = valid_Xy[0].get_value(borrow=True).shape[1]\n\n rval['cd_reports'] = []\n\n try:\n layer_config = config['next_layer']\n # allocate model parameters\n while layer_config:\n i = len(rval['cd_reports'])\n n_hid_i = layer_config['n_hid']\n if layer_config['W_init_dist']=='uniform':\n W = rng.uniform(low=-1,high=1,size=(n_hid_i, n_inputs_i)).T.astype('float32')\n elif layer_config['W_init_dist'] == 'normal':\n W = rng.randn(n_hid_i, n_inputs_i).T.astype('float32')\n else:\n raise ValueError('W_init_dist', layer_config['W_init_dist'])\n\n if layer_config['W_init_algo'] == 'old':\n #N.B. the weights are transposed so that as the number of hidden units changes,\n # the first hidden units are always the same vectors.\n # this makes it easier to isolate the effect of random initialization\n # from the other hyper-parameters under review\n W *= layer_config['W_init_algo_old_multiplier'] / numpy.sqrt(n_inputs_i)\n elif layer_config['W_init_algo'] == 'Xavier':\n W *= numpy.sqrt(6.0 / (n_inputs_i + n_hid_i))\n else:\n raise ValueError(layer_config['W_init_algo'])\n\n layer_idx = len(rval['cd_reports'])\n weights.append(theano.shared(W, 'W_%i' % layer_idx))\n hbiases.append(theano.shared(numpy.zeros(n_hid_i, dtype='float32'),\n 'h_%i' % layer_idx))\n vbiases.append(theano.shared(numpy.zeros(n_inputs_i, dtype='float32'),\n 'v_%i' % layer_idx))\n del W\n\n # allocate RBM training function for this layer\n # this version re-calculates the training set every time\n # TODO: cache the training set for each layer\n # TODO: consider sparsity?\n # TODO: consider momentum?\n if layer_config['cd_epochs']:\n cd_report = train_rbm(\n s_rng, s_idx, s_batchsize, s_features,\n W=weights[-1],\n vbias=vbiases[-1],\n hbias=hbiases[-1],\n n_in=n_inputs_i,\n n_hid=n_hid_i,\n batchsize=layer_config['cd_batchsize'],\n sample_v0s=layer_config['cd_sample_v0s'],\n cdlr=layer_config['cd_lr'] / float(layer_config['cd_batchsize']),\n n_epochs=layer_config['cd_epochs'],\n n_batches_per_epoch=dataset.descr['n_train'] // layer_config['cd_batchsize'],\n lr_anneal_start=layer_config['cd_lr_anneal_start'],\n givens = {\n s_inputs_all: tensor.as_tensor_variable(train_Xy[0])\n },\n time_limit=time_limit\n )\n else:\n cd_report = None\n rval['cd_reports'].append(cd_report)\n\n # update s_features to point to top layer\n s_features = tensor.nnet.sigmoid(\n tensor.dot(s_features, weights[-1]) + hbiases[-1])\n n_inputs_i = n_hid_i\n layer_config = layer_config.get('next_layer', None)\n\n except (MemoryError,):\n rval['abort'] = 'MemoryError'\n rval['status'] = 'ok'\n rval['loss'] = 1.0\n rval['best_epoch_valid'] = 0.0\n return rval\n\n # allocate model\n\n logreg = LogisticRegression.new(s_features, n_in=n_inputs_i,\n n_out=dataset.descr['n_classes'])\n traincost = logreg.nll(s_labels).mean()\n def ssq(X):\n return (X**2).sum()\n traincost = traincost + config['l2_penalty'] * (\n sum([ssq(w_i) for w_i in weights]) + ssq(logreg.w))\n # params = weights+hbiases+vbiases+logreg.params\n # vbiases are not involved in the supervised network\n params = weights + hbiases + logreg.params\n train_logreg_fn = theano.function([s_idx, s_lr],\n [logreg.nll(s_labels).mean()],\n updates=sgd_updates(\n params=params,\n grads=tensor.grad(traincost, params),\n stepsizes=[s_lr] * len(params)),\n givens={s_batchsize:config['batchsize'],\n s_inputs_all: tensor.as_tensor_variable(train_Xy[0]),\n s_labels_all: train_Xy[1]})\n valid_logreg_fn = theano.function([s_idx],\n logreg.errors(s_labels).mean(),\n givens={s_batchsize:config['batchsize'],\n s_inputs_all: tensor.as_tensor_variable(valid_Xy[0]),\n s_labels_all: valid_Xy[1]})\n test_logreg_fn = theano.function([s_idx],\n logreg.errors(s_labels).mean(),\n givens={s_batchsize:config['batchsize'],\n s_inputs_all: tensor.as_tensor_variable(test_Xy[0]),\n s_labels_all: test_Xy[1]})\n\n rval['best_epoch'] = -1\n rval['best_epoch_valid'] = -1\n rval['best_epoch_train'] = -1\n rval['best_epoch_test'] = -1\n rval['status'] = 'ok'\n valid_rate=-1\n test_rate=-1\n train_rate=-1\n\n n_train_batches = dataset.descr['n_train'] // config['batchsize']\n n_valid_batches = dataset.descr['n_valid'] // config['batchsize']\n n_test_batches = dataset.descr['n_test'] // config['batchsize']\n\n n_iters = 0\n for epoch in xrange(config['sup_max_epochs']):\n e_lr = config['lr']\n e_lr *= min(1, config['lr_anneal_start'] / float(n_iters+1)) #anneal learning rate\n valid_rate = float(1 - numpy.mean([valid_logreg_fn(i)\n for i in range(n_valid_batches)]))\n valid_rate_std_thresh = 0.5 * numpy.sqrt(valid_rate *\n (1 - valid_rate) / (n_valid_batches * config['batchsize']))\n\n if valid_rate > (rval['best_epoch_valid']+valid_rate_std_thresh):\n rval['best_epoch'] = epoch\n rval['best_epoch_test'] = test_rate\n rval['best_epoch_valid'] = valid_rate\n rval['best_epoch_train'] = train_rate\n best_params = copy.deepcopy(params)\n logger.info('Epoch=%i best epoch %i valid %f test %f best_epoch_train %f prev_train %f'%(\n epoch, rval['best_epoch'], rval['best_epoch_valid'], rval['best_epoch_test'],\n rval['best_epoch_train'], train_rate))\n #ctrl.info('Epoch %i train nll: %f'%(epoch, train_rate))\n ctrl.checkpoint(rval)\n\n if epoch > config['sup_min_epochs'] and epoch > 2*rval['best_epoch']:\n break\n if time.time() > time_limit:\n break\n train_rate = float(numpy.mean([train_logreg_fn(i,e_lr) for i in\n range(n_train_batches)]))\n if not numpy.isfinite(train_rate):\n do_test = False\n rval['status'] = 'fail'\n rval['status_info'] = 'train_rate %f' % train_rate\n break\n ++n_iters\n\n do_test = 1\n if do_test and rval['status'] == 'ok':\n # copy best params back into place\n for p, bp in zip(params, best_params):\n p.set_value(bp.get_value())\n rval['best_epoch_test'] = 1 - float(\n numpy.mean(\n [test_logreg_fn(i) for i in range(n_test_batches)]))\n rval['loss'] = 1.0 - rval['best_epoch_valid']\n ctrl.info('rval: %s' % str(rval))\n return rval\n\n @classmethod\n def loss(cls, result, config=None):\n \"\"\"Extract the scalar-valued loss from a result document\n \"\"\"\n try:\n if numpy.isnan(float(result['loss'])):\n return None\n else:\n return float(result['loss'])\n except KeyError, TypeError:\n return None\n\n @classmethod\n def loss_variance(cls, result, config=None):\n if config['dataset_name'] not in _dataset_cache:\n _dataset_cache[config['dataset_name']] = json_call(\n config['dataset_name'])\n dataset = _dataset_cache[config['dataset_name']]\n n_valid = dataset.descr['n_valid']\n p = cls.loss(result, config)\n if p is None:\n return None\n return p * (1.0 - p) / (n_valid - 1)\n\n @classmethod\n def true_loss(cls, result, config=None):\n try:\n rval = float(1 - result['best_epoch_test'])\n if 0 <= rval <= 1:\n return rval\n except (KeyError, TypeError):\n return None\n\n @classmethod\n def status(cls, result, config=None):\n \"\"\"Extract the job status from a result document\n \"\"\"\n if (result['status'] == 'ok' and\n (cls.loss(result) is None\n or cls.true_loss(result) is None)):\n return 'fail'\n else:\n return result['status']\n\n\ndef DBN_Convex():\n return DBN_Base(\n dbn_template(\n dataset_name='skdata.larochelle_etal_2007.Convex'))\n\n\ndef DBN_MRBI():\n ds = 'skdata.larochelle_etal_2007.MNIST_RotatedBackgroundImages'\n return DBN_Base(dbn_template(dataset_name=ds))\n\n\nclass Dummy_DBN_Base(Bandit):\n \"\"\"\n A DBN_Base stub.\n\n This class is used in unittests of optimization algorithms to ensure they\n can deal with large nested specifications that include lots of distribution\n types.\n\n The evaluate function simply returns a random score.\n \"\"\"\n def __init__(self):\n Bandit.__init__(self, template=dbn_template())\n self.rng = numpy.random.RandomState(234)\n\n def evaluate(self, argd, ctrl):\n rval = dict(dbn_train_fn_version=-1)\n # XXX: TODO: make up a loss function that depends on argd.\n rval['status'] = 'ok'\n rval['best_epoch_valid'] = float(self.rng.rand())\n rval['loss'] = 1.0 - rval['best_epoch_valid']\n return rval\n\n def loss_variance(self, result, config=None):\n return 0.01**2\n", "meta": {"hexsha": "97f8eee7024ead5b53f7b563a9ad8591cff1d03f", "size": 25454, "ext": "py", "lang": "Python", "max_stars_repo_path": "hpnnet/orig_dbn.py", "max_stars_repo_name": "hyperopt/hyperopt-nnet", "max_stars_repo_head_hexsha": "766811d1128cda02d41c95ae118fd938e023c605", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 38, "max_stars_repo_stars_event_min_datetime": "2015-02-06T03:54:59.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-04T16:49:11.000Z", "max_issues_repo_path": "hpnnet/orig_dbn.py", "max_issues_repo_name": "hyperopt/hyperopt-nnet", "max_issues_repo_head_hexsha": "766811d1128cda02d41c95ae118fd938e023c605", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "hpnnet/orig_dbn.py", "max_forks_repo_name": "hyperopt/hyperopt-nnet", "max_forks_repo_head_hexsha": "766811d1128cda02d41c95ae118fd938e023c605", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 12, "max_forks_repo_forks_event_min_datetime": "2016-01-09T21:54:51.000Z", "max_forks_repo_forks_event_max_datetime": "2020-06-17T16:41:19.000Z", "avg_line_length": 39.2203389831, "max_line_length": 105, "alphanum_fraction": 0.5452581127, "include": true, "reason": "import numpy,import theano,from theano", "num_tokens": 6145, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5851011686727231, "lm_q2_score": 0.3242354055108441, "lm_q1q2_score": 0.18971051468946917}} {"text": "from __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport re\nimport numpy as np\n\nfrom .dbmgr import get_cursor\n\nclass Element(object):\n\t\"\"\"Elemental data\n\n\t...\n\t\n\tParameters\n\t----------\n\tx : type\n\t\tDescription of parameter `x`.\n\n\tAttributes\n\t----------\n\n\tMethods\n\t-------\n\n\tNotes\n\t-----\n\n\tReferences\n\t----------\n\n\tExamples\n\t--------\n\n\t\"\"\"\n\n\tdef __init__(self, element):\n\t\tself.element = element.title()\n\t\tself._meta = None\n\n\t@property\n\tdef meta(self):\n\t\tif self._meta is None:\n\t\t\tfrom scipy.interpolate import interp1d\n\n\t\t\tself._meta = {}\n\t\t\tzg = get_cursor('ziegler')\n\t\t\tself._meta['Z'] = [str(i[2]).split(':')[0] for i in zg.execute('SELECT * FROM compounds WHERE compound=?',(self.element,))][0]\n\t\t\tself._meta['mass'], self._meta['density'] = [(i[1],i[2]) for i in zg.execute('SELECT * FROM weights WHERE Z=?',(self._meta['Z'],))][0]\n\t\t\tcoeff = np.array([i[1:] for i in zg.execute('SELECT * FROM mass_coeff WHERE Z=? ORDER BY energy',(self._meta['Z'],))])\n\t\t\tself._meta['mass_coeff'] = interp1d(coeff[:,0], coeff[:,1], bounds_error=False, fill_value=0.0)\n\t\t\tself._meta['mass_coeff_en'] = interp1d(coeff[:,0], coeff[:,2], bounds_error=False, fill_value=0.0)\n\t\t\tdb = get_cursor('decay')\n\t\t\tself._meta['abundances'] = {str(i[1]):i[12] for i in db.execute('SELECT * FROM chart WHERE element=? AND abundance>0.0',(self.element,))}\n\t\t\tself._meta['isotopes'] = sorted([i for i in self._meta['abundances']])\n\n\t\treturn self._meta\n\n\t@property\n\tdef Z(self):\n\t\treturn self.meta['Z']\n\n\t@property\n\tdef mass(self):\n\t\treturn self.meta['mass']\n\n\t@property\n\tdef isotopes(self):\n\t\treturn self.meta['isotopes']\n\n\t@property\n\tdef abundances(self):\n\t\treturn self.meta['abundances']\n\n\t@property\n\tdef mass_coeff(self):\n\t\treturn self.meta['mass_coeff']\n\n\t@property\n\tdef mass_coeff_en(self):\n\t\treturn self.meta['mass_coeff_en']\n\n\tdef attenuation(self, E, x=1.0):\n\t\treturn np.exp(-self.mass_coeff(E)*self.density*x)\n\n\tdef transmission(self, E, x=1.0):\n\t\treturn 1.0-np.exp(-self.mass_coeff(E)*self.density*x)\n\t\n\t@property\n\tdef density(self):\n\t\treturn self.meta['density']\n\t\n\t\n\t\n\n\nclass Isotope(object):\n\t\"\"\"Isotopic data\n\n\t...\n\t\n\tParameters\n\t----------\n\tx : type\n\t\tDescription of parameter `x`.\n\n\tAttributes\n\t----------\n\n\tMethods\n\t-------\n\n\tNotes\n\t-----\n\n\tReferences\n\t----------\n\n\tExamples\n\t--------\n\n\t\"\"\"\n\n\tdef __init__(self, istp):\n\t\tif istp=='1n' or istp=='1ng':\n\t\t\tself.element, self.A, self.isomer = 'n', 1, 'g'\n\t\telse:\n\t\t\tself.element = ''.join(re.findall('[A-Z]+',istp))\n\t\t\tif istp.startswith('nat'):\n\t\t\t\tself.A = 'nat'\n\t\t\telse:\n\t\t\t\tself.A = int(istp.split(self.element)[0])\n\t\t\tself.isomer = istp.split(self.element)[1]\n\t\tself.isotope = str(self.A)+self.element\n\t\tif self.isomer=='' and type(self.A)==int:\n\t\t\tself.isomer = 'g'\n\t\tif self.isomer=='m':\n\t\t\tself.isomer = 'm1'\n\t\tself.name = self.isotope+self.isomer\n\t\tself._meta = None\n\t\t\t\n\t@property\n\tdef meta(self):\n\t\tif self._meta is None:\n\t\t\tself._meta = {}\n\t\t\tself.db = get_cursor('decay')\n\t\t\tfor i in ['SFY','gm','el','bm','bp','al']:\n\t\t\t\tself._meta[i] = None\n\t\t\tQ = list(self.db.execute('SELECT * FROM chart WHERE isotope=?',(self.isotope,)))\n\t\t\tq = [i for i in Q if i[3]==self.isomer]\n\t\t\tif len(q):\n\t\t\t\tq = q[0]\n\t\t\telif len(Q):\n\t\t\t\tq = Q[0]\n\t\t\telse:\n\t\t\t\tq = [0,0,0,0,'',0,None,None,None,None,None,None,None,None,None,None,'']\n\t\t\tself._meta['E_level'] = q[2]\n\t\t\tself._meta['J_pi'] = str(q[4]) if q[4] else '?'\n\t\t\tself._meta['Z'] = q[6]\n\t\t\tself._meta['N'] = q[7]\n\t\t\tself._meta['stable'] = bool(q[9])\n\t\t\tself._meta['t_half'] = q[10]\n\t\t\tself._meta['unc_t_half'] = q[11]\n\t\t\tself._meta['abundance'] = q[12]\n\t\t\tself._meta['unc_abundance'] = q[13]\n\t\t\tif self._meta['stable'] and self._meta['abundance'] is None:\n\t\t\t\tself._meta['abundance'] = 100.0\n\t\t\t\tself._meta['unc_abundance'] = 0.0\n\t\t\tself._meta['mass'] = q[14]\n\t\t\tself._meta['Delta'] = q[15]\n\t\t\tself._meta['decay_mode'] = list(map(lambda i:[float(p) if n==2 else p for n,p in enumerate(i.split(':'))], str(q[16]).split(',')))\n\t\t\tstate = '' if len(Q)==1 else (self.isomer[0] if len(Q)==2 else self.isomer)\n\t\t\tself._meta['TeX'] = r'$^{'+str(self.A)+state+r'}$'+self.element.title()\n\t\treturn self._meta\n\t\n\t@property\n\tdef E_level(self):\n\t\treturn self.meta['E_level']\n\n\t@property\n\tdef J_pi(self):\n\t\treturn self.meta['J_pi']\n\n\t@property\n\tdef Z(self):\n\t\treturn self.meta['Z']\n\n\t@property\n\tdef N(self):\n\t\treturn self.meta['N']\n\n\t@property\n\tdef stable(self):\n\t\treturn self.meta['stable']\n\n\t@property\n\tdef mass(self):\n\t\treturn self.meta['mass']\n\n\t@property\n\tdef Delta(self):\n\t\treturn self.meta['Delta']\n\n\t@property\n\tdef TeX(self):\n\t\treturn self.meta['TeX']\n\n\tdef __str__(self):\n\t\treturn self.name\n\n\tdef half_life(self, units='s', unc=False):\n\t\t\"\"\"Description\n\n\t\t...\n\n\t\tParameters\n\t\t----------\n\t\tx : type\n\t\t\tDescription of parameter `x`.\n\n\t\tReturns\n\t\t-------\n\n\t\tNotes\n\t\t-----\n\n\t\tReferences\n\t\t----------\n\n\t\tExamples\n\t\t--------\n\n\t\t\"\"\"\n\n\t\tif self.stable:\n\t\t\treturn (np.inf,0.0) if unc else np.inf\n\t\thalf_conv = {'ns':1e-9,'us':1e-6,'ms':1e-3,'s':1.0,'m':60.0,'h':3600.0,'d':86400.0,'y':31557.6E3,'ky':31557.6E6}[units]\n\t\tif unc:\n\t\t\treturn self.meta['t_half']/half_conv,self.meta['unc_t_half']/half_conv\n\t\treturn self.meta['t_half']/half_conv\n\n\tdef decay_const(self, units='s', unc=False):\n\t\t\"\"\"Description\n\n\t\t...\n\n\t\tParameters\n\t\t----------\n\t\tx : type\n\t\t\tDescription of parameter `x`.\n\n\t\tReturns\n\t\t-------\n\n\t\tNotes\n\t\t-----\n\n\t\tReferences\n\t\t----------\n\n\t\tExamples\n\t\t--------\n\n\t\t\"\"\"\n\n\t\tif self.stable:\n\t\t\treturn (0.0,0.0) if unc else 0.0\n\t\tif unc:\n\t\t\tT2,uT2 = self.half_life(units, True)\n\t\t\treturn np.log(2.0)/T2,np.log(2.0)*uT2/T2**2\n\t\treturn np.log(2.0)/self.half_life(units)\n\n\tdef optimum_units(self):\n\t\t\"\"\"Description\n\n\t\t...\n\n\t\tParameters\n\t\t----------\n\t\tx : type\n\t\t\tDescription of parameter `x`.\n\n\t\tReturns\n\t\t-------\n\n\t\tNotes\n\t\t-----\n\n\t\tReferences\n\t\t----------\n\n\t\tExamples\n\t\t--------\n\n\t\t\"\"\"\n\n\t\topt = ['ns']\n\t\tfor units in ['us','ms','s','m','h','d','y']:\n\t\t\tif self.half_life(units)>1.0:\n\t\t\t\topt.append(units)\n\t\treturn opt[-1]\n\n\tdef abundance(self, unc=False):\n\t\t\"\"\"Description\n\n\t\t...\n\n\t\tParameters\n\t\t----------\n\t\tx : type\n\t\t\tDescription of parameter `x`.\n\n\t\tReturns\n\t\t-------\n\n\t\tNotes\n\t\t-----\n\n\t\tReferences\n\t\t----------\n\n\t\tExamples\n\t\t--------\n\n\t\t\"\"\"\n\n\t\tif unc:\n\t\t\treturn self.meta['abundance'], self.meta['unc_abundance']\n\t\treturn self.meta['abundance']\n\n\tdef get_SFY(self, unc=False, closest_SFY=False):\n\t\t\"\"\"Description\n\n\t\t...\n\n\t\tParameters\n\t\t----------\n\t\tx : type\n\t\t\tDescription of parameter `x`.\n\n\t\tReturns\n\t\t-------\n\n\t\tNotes\n\t\t-----\n\n\t\tReferences\n\t\t----------\n\n\t\tExamples\n\t\t--------\n\n\t\t\"\"\"\n\n\t\tif self.meta['SFY'] is None:\n\t\t\tself.meta['SFY'] = [(str(i[1]),i[2],i[3]) for i in self.db.execute('SELECT * FROM SFY WHERE parent=?',(self.name,))]\n\t\tSFY = list(self.meta['SFY'])\n\t\tif len(SFY)==0 and closest_SFY:\n\t\t\titps = list(set([str(i[0]) for i in self.db.execute('SELECT parent FROM SFY')]))\n\t\t\tdA = [abs(self.A-int(i[:3])) for i in itps]\n\t\t\tSFY = [(str(i[1]),i[2],i[3]) for i in self.db.execute('SELECT * FROM SFY WHERE parent=?',(itps[dA.index(min(dA))],))]\n\t\tif unc:\n\t\t\treturn [[i[0], i[1], i[2]] for i in SFY]\n\t\treturn [[i[0], i[1]] for i in SFY]\n\n\tdef decay_products(self, closest_SFY=False):\n\t\t\"\"\"Description\n\n\t\t...\n\n\t\tParameters\n\t\t----------\n\t\tx : type\n\t\t\tDescription of parameter `x`.\n\n\t\tReturns\n\t\t-------\n\n\t\tNotes\n\t\t-----\n\n\t\tReferences\n\t\t----------\n\n\t\tExamples\n\t\t--------\n\n\t\t\"\"\"\n\n\t\tprods = []\n\t\tfor (mode, product, br) in self.meta['decay_mode']:\n\t\t\tif product=='SFY':\n\t\t\t\tprods += [[i, br*y] for i,y in self.get_SFY(False, closest_SFY)]\n\t\t\telse:\n\t\t\t\tprods.append([product, br])\n\t\treturn [[i, br] for i,br in prods if br>1E-8]\n\n\tdef gammas(self, I_lim=[None,None], E_lim=[None,None], xrays=False, dE_511=3.5):\n\t\t\"\"\"Description\n\n\t\t...\n\n\t\tParameters\n\t\t----------\n\t\tx : type\n\t\t\tDescription of parameter `x`.\n\n\t\tReturns\n\t\t-------\n\n\t\tNotes\n\t\t-----\n\n\t\tReferences\n\t\t----------\n\n\t\tExamples\n\t\t--------\n\n\t\t\"\"\"\n\n\t\tif self.meta['gm'] is None:\n\t\t\tself.meta['gm'] = [[float(i[3]),float(i[4]),float(i[5]),str(i[6])] for i in self.db.execute('SELECT * FROM gammas WHERE isotope=? AND isomer=?',(self.isotope,self.isomer))]\n\t\tgammas = list(self.meta['gm'])\n\t\tfor n,L in enumerate([E_lim,I_lim]):\n\t\t\tif L[0] is not None:\n\t\t\t\tgammas = [g for g in gammas if g[n]>=L[0]]\n\t\t\tif L[1] is not None:\n\t\t\t\tgammas = [g for g in gammas if g[n]<=L[1]]\n\t\tif not xrays:\n\t\t\tgammas = [g for g in gammas if g[3]=='']\n\t\treturn {l:[g[n] for g in gammas if abs(g[0]-511.0)>=dE_511] for n,l in enumerate(['E','I','dI','notes'])}\n\n\tdef electrons(self,I_lim=(None,None),E_lim=(None,None),CE_only=False,Auger_only=False):\n\t\t\"\"\"Description\n\n\t\t...\n\n\t\tParameters\n\t\t----------\n\t\tx : type\n\t\t\tDescription of parameter `x`.\n\n\t\tReturns\n\t\t-------\n\n\t\tNotes\n\t\t-----\n\n\t\tReferences\n\t\t----------\n\n\t\tExamples\n\t\t--------\n\n\t\t\"\"\"\n\n\t\tif self.meta['el'] is None:\n\t\t\tself.meta['el'] = [[float(i[3]),float(i[4]),float(i[5]),str(i[6])] for i in self.db.execute('SELECT * FROM electrons WHERE isotope=? AND isomer=?',(self.isotope,self.isomer))]\n\t\telectrons = list(self.meta['el'])\n\t\tfor n,L in enumerate([E_lim,I_lim]):\n\t\t\tif L[0] is not None:\n\t\t\t\telectrons = [e for e in electrons if e[n]>=L[0]]\n\t\t\tif L[1] is not None:\n\t\t\t\telectrons = [e for e in electrons if e[n]<=L[1]]\n\t\tif CE_only:\n\t\t\telectrons = [e for e in electrons if e[3].startswith('CE')]\n\t\tif Auger_only:\n\t\t\telectrons = [e for e in electrons if e[3].startswith('Aug')]\n\t\treturn {l:[e[n]for e in electrons] for n,l in enumerate(['E','I','dI','notes'])}\n\n\tdef beta_minus(self,I_lim=(None,None),Endpoint_lim=(None,None)):\n\t\t\"\"\"Description\n\n\t\t...\n\n\t\tParameters\n\t\t----------\n\t\tx : type\n\t\t\tDescription of parameter `x`.\n\n\t\tReturns\n\t\t-------\n\n\t\tNotes\n\t\t-----\n\n\t\tReferences\n\t\t----------\n\n\t\tExamples\n\t\t--------\n\n\t\t\"\"\"\n\n\t\tif self.meta['bm'] is None:\n\t\t\tself.meta['bm'] = [[float(i[3]),float(i[4]),float(i[5]),float(i[6])] for i in self.db.execute('SELECT * FROM beta_minus WHERE isotope=? AND isomer=?',(self.isotope,self.isomer))]\n\t\tbetas = list(self.meta['bm'])\n\t\tfor n,L in zip([3,1],[Endpoint_lim,I_lim]):\n\t\t\tif L[0] is not None:\n\t\t\t\tbetas = [b for b in betas if b[n]>=L[0]]\n\t\t\tif L[1] is not None:\n\t\t\t\tbetas = [b for b in betas if b[n]<=L[1]]\n\t\treturn {l:[b[n] for b in betas] for n,l in enumerate(['muE','I','dI','endE'])}\n\n\tdef beta_plus(self, I_lim=(None,None), Endpoint_lim=(None,None)):\n\t\t\"\"\"Description\n\n\t\t...\n\n\t\tParameters\n\t\t----------\n\t\tx : type\n\t\t\tDescription of parameter `x`.\n\n\t\tReturns\n\t\t-------\n\n\t\tNotes\n\t\t-----\n\n\t\tReferences\n\t\t----------\n\n\t\tExamples\n\t\t--------\n\n\t\t\"\"\"\n\n\t\tif self.meta['bp'] is None:\n\t\t\tself.meta['bp'] = [[float(i[3]),float(i[4]),float(i[5]),float(i[6])] for i in self.db.execute('SELECT * FROM beta_plus WHERE isotope=? AND isomer=?',(self.isotope,self.isomer))]\n\t\tbetas = list(self.meta['bp'])\n\t\tfor n,L in zip([3,1],[Endpoint_lim,I_lim]):\n\t\t\tif L[0] is not None:\n\t\t\t\tbetas = [b for b in betas if b[n]>=L[0]]\n\t\t\tif L[1] is not None:\n\t\t\t\tbetas = [b for b in betas if b[n]<=L[1]]\n\t\treturn {l:[b[n] for b in betas] for n,l in enumerate(['muE','I','dI','endE'])}\n\n\tdef alphas(self, I_lim=(None,None), E_lim=(None,None)):\n\t\t\"\"\"Description\n\n\t\t...\n\n\t\tParameters\n\t\t----------\n\t\tx : type\n\t\t\tDescription of parameter `x`.\n\n\t\tReturns\n\t\t-------\n\n\t\tNotes\n\t\t-----\n\n\t\tReferences\n\t\t----------\n\n\t\tExamples\n\t\t--------\n\n\t\t\"\"\"\n\n\t\tif self.meta['al'] is None:\n\t\t\tself.meta['al'] = [[float(i[3]),float(i[4]),float(i[5])] for i in self.db.execute('SELECT * FROM alphas WHERE isotope=? AND isomer=?',(self.isotope,self.isomer))]\n\t\talphas = list(self.meta['al'])\n\t\tfor n,L in enumerate([E_lim,I_lim]):\n\t\t\tif L[0] is not None:\n\t\t\t\talphas = [a for a in alphas if a[n]>=L[0]]\n\t\t\tif L[1] is not None:\n\t\t\t\talphas = [a for a in alphas if a[n]<=L[1]]\n\t\treturn {l:[a[n] for a in alphas] for n,l in enumerate(['E','I','dI'])}\n\n\tdef dose_rate(self, activity=1.0, distance=30.0, units='R/hr'):\n\t\t\"\"\"Description\n\n\t\t...\n\n\t\tParameters\n\t\t----------\n\t\tx : type\n\t\t\tDescription of parameter `x`.\n\n\t\tReturns\n\t\t-------\n\n\t\tNotes\n\t\t-----\n\n\t\tReferences\n\t\t----------\n\n\t\tExamples\n\t\t--------\n\n\t\t\"\"\"\n\n\t\tdef beta2(E_MeV, m_amu):\n\t\t\treturn 1.0-(1.0/(1.0+(E_MeV/m_amu))**2)\n\n\t\tdef e_range(E_keV):\n\t\t\tdEdx = lambda b2, t: 0.17*((np.log(3.61E5*t*np.sqrt(t+2)))+(0.5*(1-b2)*(1+t**2/8-(2*t+1)*np.log(2)))-4.312)/b2\n\t\t\tE = np.linspace(1E-12, E_keV*1E-3, 100)\n\t\t\treturn np.trapz(1.0/((1.0+(E*7.22/800.0))*dEdx(beta2(E, 0.5109), E/0.5109)), E)\n\n\t\tdef pos_range(E_keV):\n\t\t\tdEdx = lambda b2, t: 0.17*((np.log(3.61E5*t*np.sqrt(t+2)))+(np.log(2)-(b2/24)*(23+14/(t+2)+10/(t+2)**2+4/(t+2)**3))-4.312)/b2\n\t\t\tE = np.linspace(1E-12, E_keV*1E-3, 100)\n\t\t\treturn np.trapz(1.0/((1.0+(E*7.22/800.0))*dEdx(beta2(E, 0.5109), E/0.5109)), E)\n\n\t\tdef alpha_range(E_keV):\n\t\t\tdEdx = lambda b2: 0.17*4.0*((np.log(1.02E6*b2/(1.0-b2))-b2)-4.312)/b2\n\t\t\treturn np.trapz(1.0/dEdx(beta2(np.linspace(1E-9, E_keV*1E-3, 100), 3.7284E3)), np.linspace(1E-9, E_keV*1E-3, 100))\n\n\t\tdose = {}\n\t\tgm = self.gammas(xrays=True, dE_511=0.0)\n\t\tal = self.alphas()\n\t\tbm = self.beta_minus()\n\t\tbp = self.beta_plus()\n\t\tel = self.electrons()\n\n\t\tdose['gammas'] = 1.4042E-12*np.sum(np.array(gm['E'])*np.array(gm['I']))*activity/distance**2\n\t\tdose['alphas'] = 5.2087E-14*np.sum([al['I'][n]*e/alpha_range(e) for n,e in enumerate(al['E'])])*activity/distance**2\n\t\tdose['beta_minus'] = 5.2087E-14*np.sum([bm['I'][n]*e/e_range(e) for n,e in enumerate(bm['muE'])])*activity/distance**2\n\t\tdose['beta_plus'] = 5.2087E-14*np.sum([bp['I'][n]*e/pos_range(e) for n,e in enumerate(bp['muE'])])*activity/distance**2\n\t\tdose['electrons'] = 5.2087E-14*np.sum([el['I'][n]*e/e_range(e) for n,e in enumerate(el['E'])])*activity/distance**2\n\t\treturn dose\n\n\n", "meta": {"hexsha": "9a9503a1fc2ee81a3e03f84c743956c27b8ca158", "size": 13485, "ext": "py", "lang": "Python", "max_stars_repo_path": "npat/isotope.py", "max_stars_repo_name": "CallumCordwell/npat", "max_stars_repo_head_hexsha": "9990ed982948389af78cc456fd579b98732b6490", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-03-27T15:00:30.000Z", "max_stars_repo_stars_event_max_datetime": "2020-03-27T15:00:30.000Z", "max_issues_repo_path": "npat/isotope.py", "max_issues_repo_name": "CallumCordwell/npat", "max_issues_repo_head_hexsha": "9990ed982948389af78cc456fd579b98732b6490", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "npat/isotope.py", "max_forks_repo_name": "CallumCordwell/npat", "max_forks_repo_head_hexsha": "9990ed982948389af78cc456fd579b98732b6490", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2018-06-27T17:29:45.000Z", "max_forks_repo_forks_event_max_datetime": "2020-04-15T10:42:23.000Z", "avg_line_length": 21.4047619048, "max_line_length": 181, "alphanum_fraction": 0.5842788283, "include": true, "reason": "import numpy,from scipy", "num_tokens": 4585, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5851011686727231, "lm_q2_score": 0.32423540551084407, "lm_q1q2_score": 0.18971051468946915}} {"text": "# Copyright (c) FULIUCANSHENG.\n# Licensed under the MIT License.\n\nimport logging\nimport math\nimport time\nimport numpy as np\nimport torch\nimport torchvision\nfrom torch import nn, Tensor\nfrom typing import List, Dict, Tuple\n\nfrom detectron2.config import configurable\nfrom detectron2.layers import ShapeSpec, Conv2d\nfrom detectron2.modeling.meta_arch.build import META_ARCH_REGISTRY\nfrom detectron2.modeling.backbone import Backbone\nfrom detectron2.structures import ImageList, Instances, Boxes\nfrom detectron2.utils.events import get_event_storage\nfrom detectron2.data.detection_utils import convert_image_to_rgb\nfrom detectron2.modeling.postprocessing import detector_postprocess\nfrom detectron2.modeling import build_backbone\n\n\nclass YoloV5Head(nn.Module):\n @configurable\n def __init__(\n self,\n *,\n input_shape: List[ShapeSpec],\n nc,\n anchors,\n ):\n\n super().__init__()\n self.nc = nc # number of classes\n self.no = nc + 5 # number of outputs per anchor\n self.nl = len(anchors) # number of detection layers\n assert self.nl == len(input_shape)\n self.na = len(anchors[0]) // 2 # number of anchors\n self.grid = [torch.zeros(1)] * self.nl # init grid\n a = torch.tensor(anchors).float().view(self.nl, -1, 2)\n self.register_buffer(\"anchors\", a) # shape(nl,na,2)\n self.register_buffer(\"anchor_grid\", a.clone().view(self.nl, 1, -1, 1, 1, 2)) # shape(nl,1,na,1,1,2)\n ch = [x.channels for x in input_shape]\n self.m = nn.ModuleList(Conv2d(x, self.no * self.na, 1) for x in ch)\n\n @classmethod\n def from_config(cls, cfg, input_shape: List[ShapeSpec]):\n nc = cfg.MODEL.YOLOV5.NUM_CLASSES\n anchors = cfg.MODEL.YOLOV5.ANCHORS\n return {\n \"input_shape\": input_shape,\n \"nc\": nc,\n \"anchors\": anchors,\n }\n\n def forward(self, x: List[Tensor]):\n \"\"\"\n Arguments:\n features (list[Tensor]): FPN feature map tensors in high to low resolution.\n Each tensor in the list correspond to different feature levels.\n Returns:\n x (list[Tensor]): #nl tensors,\n each having shape [N, na, Hi, Wi, nc + 5]\n z (Tensor) : [N, nl*na*(sum of grid sizes) , no] indictaing\n 1. Box position z[..., 0:2]\n 2. Box width and height z[..., 2:4]\n 3. Objectness z[..., 5]\n 4. Class probabilities z[..., 6:]\n \"\"\"\n for i in range(self.nl):\n x[i] = self.m[i](x[i]) # conv\n bs, _, ny, nx = x[i].shape # x(bs,255,20,20) to x(bs,3,20,20,85)\n x[i] = x[i].view(bs, self.na, self.no, ny, nx).permute(0, 1, 3, 4, 2).contiguous()\n return x\n\n @staticmethod\n def _make_grid(nx=20, ny=20):\n yv, xv = torch.meshgrid([torch.arange(ny), torch.arange(nx)])\n return torch.stack((xv, yv), 2).view((1, 1, ny, nx, 2)).float()\n\n def _initialize_biases(self, cf=None): # initialize biases into Detect(), cf is class frequency\n # https://arxiv.org/abs/1708.02002 section 3.3\n # cf = torch.bincount(torch.tensor(np.concatenate(dataset.labels, 0)[:, 0]).long(), minlength=nc) + 1.\n for mi, s in zip(self.m, self.stride): # from\n b = mi.bias.view(self.na, -1) # conv.bias(255) to (3,85)\n b.data[:, 4] += math.log(8 / (640 / s) ** 2) # obj (8 objects per 640 image)\n b.data[:, 5:] += math.log(0.6 / (self.nc - 0.99)) if cf is None else torch.log(cf / cf.sum()) # cls\n mi.bias = torch.nn.Parameter(b.view(-1), requires_grad=True)\n\n\ndef xywh2xyxy(x):\n # Convert nx4 boxes from [x, y, w, h] to [x1, y1, x2, y2] where xy1=top-left, xy2=bottom-right\n y = x.clone() if isinstance(x, torch.Tensor) else np.copy(x)\n y[:, 0] = x[:, 0] - x[:, 2] / 2 # top left x\n y[:, 1] = x[:, 1] - x[:, 3] / 2 # top left y\n y[:, 2] = x[:, 0] + x[:, 2] / 2 # bottom right x\n y[:, 3] = x[:, 1] + x[:, 3] / 2 # bottom right y\n return y\n\n\ndef non_max_suppression(\n prediction,\n conf_thres=0.25,\n iou_thres=0.45,\n classes=None,\n agnostic=False,\n multi_label=False,\n labels=(),\n max_det=300,\n):\n \"\"\"Runs Non-Maximum Suppression (NMS) on inference results\n conf_thresh - 0.1 (for yolov4)\n iou_thresh - 0.6 (for yolov4)\n multi_label - not in yolov4\n merge = False - in yolov4 not in yolov3\n Labesl = () not in yolov4\n Returns:\n list of detections, on (n,6) tensor per image [xyxy, conf, cls]\n \"\"\"\n # if yolov3 or yolov5:\n nc = prediction.shape[2] - 5 # number of classes\n # else\n nc = prediction[0].shape[1] - 5 # Number of classes\n xc = prediction[..., 4] > conf_thres # candidates\n\n # Checks\n assert 0 <= conf_thres <= 1, f\"Invalid Confidence threshold {conf_thres}, valid values are between 0.0 and 1.0\"\n assert 0 <= iou_thres <= 1, f\"Invalid IoU {iou_thres}, valid values are between 0.0 and 1.0\"\n\n # Settings\n # (pixels) minimum and maximum box width and height\n _, max_wh = 2, 4096\n max_nms = 30000 # maximum number of boxes into torchvision.ops.nms()\n time_limit = 10.0 # seconds to quit after\n redundant = True # require redundant detections\n multi_label &= nc > 1 # multiple labels per box (adds 0.5ms/img)\n merge = False # use merge-NMS\n\n t = time.time()\n output = [torch.zeros((0, 6), device=prediction.device)] * prediction.shape[0]\n for xi, x in enumerate(prediction): # image index, image inference\n # Apply constraints\n # x[((x[..., 2:4] < min_wh) | (x[..., 2:4] > max_wh)).any(1), 4] = 0 # width-height\n x = x[xc[xi]] # confidence\n\n # Cat apriori labels if autolabelling - Not used in the YOLOV4\n if labels and len(labels[xi]):\n l_ = labels[xi]\n v = torch.zeros((len(l_), nc + 5), device=x.device)\n v[:, :4] = l_[:, 1:5] # box\n v[:, 4] = 1.0 # conf\n v[range(len(l_)), l_[:, 0].long() + 5] = 1.0 # cls\n x = torch.cat((x, v), 0)\n #################################################################\n # If none remain process next image\n if not x.shape[0]:\n continue\n\n # Compute conf\n x[:, 5:] *= x[:, 4:5] # conf = obj_conf * cls_conf\n\n # Box (center x, center y, width, height) to (x1, y1, x2, y2)\n box = xywh2xyxy(x[:, :4])\n\n # Detections matrix nx6 (xyxy, conf, cls)\n if multi_label:\n i, j = (x[:, 5:] > conf_thres).nonzero(as_tuple=False).T\n x = torch.cat((box[i], x[i, j + 5, None], j[:, None].float()), 1)\n else: # best class only\n conf, j = x[:, 5:].max(1, keepdim=True)\n x = torch.cat((box, conf, j.float()), 1)[conf.view(-1) > conf_thres]\n\n # Filter by class\n if classes is not None:\n x = x[(x[:, 5:6] == torch.tensor(classes, device=x.device)).any(1)]\n\n # Apply finite constraint\n # if not torch.isfinite(x).all():\n # x = x[torch.isfinite(x).all(1)]\n\n # Check shape\n n = x.shape[0] # number of boxes\n if not n: # no boxes\n continue\n # #### Not in Yolov4 ######################\n elif n > max_nms: # excess boxes\n # sort by confidence\n x = x[x[:, 4].argsort(descending=True)[:max_nms]]\n ###############################################\n # Batched NMS\n c = x[:, 5:6] * (0 if agnostic else max_wh) # classes\n # boxes (offset by class), scores\n boxes, scores = x[:, :4] + c, x[:, 4]\n i = torchvision.ops.nms(boxes, scores, iou_thres) # NMS\n if i.shape[0] > max_det: # limit detections\n i = i[:max_det]\n if merge and (1 < n < 3e3): # Merge NMS (boxes merged using weighted mean)\n # update boxes as boxes(i,4) = weights(i,n) * boxes(n,4)\n iou = box_iou(boxes[i], boxes) > iou_thres # iou matrix\n weights = iou * scores[None] # box weights\n x[i, :4] = torch.mm(weights, x[:, :4]).float() / weights.sum(1, keepdim=True) # merged boxes\n if redundant:\n i = i[iou.sum(1) > 1] # require redundancy\n\n output[xi] = x[i]\n if (time.time() - t) > time_limit:\n print(f\"WARNING: NMS time limit {time_limit}s exceeded\")\n break # time limit exceeded\n\n return output\n\n\ndef bbox_iou(\n box1,\n box2,\n x1y1x2y2=True,\n GIoU=False,\n DIoU=False,\n CIoU=False,\n EIoU=False,\n ECIoU=False,\n eps=1e-7,\n):\n # eps default value used in yolov4 is 1e-9\n # Returns the IoU of box1 to box2. box1 is 4, box2 is nx4\n box2 = box2.T\n\n # Get the coordinates of bounding boxes\n if x1y1x2y2: # x1, y1, x2, y2 = box1\n b1_x1, b1_y1, b1_x2, b1_y2 = box1[0], box1[1], box1[2], box1[3]\n b2_x1, b2_y1, b2_x2, b2_y2 = box2[0], box2[1], box2[2], box2[3]\n else: # transform from xywh to xyxy\n b1_x1, b1_x2 = box1[0] - box1[2] / 2, box1[0] + box1[2] / 2\n b1_y1, b1_y2 = box1[1] - box1[3] / 2, box1[1] + box1[3] / 2\n b2_x1, b2_x2 = box2[0] - box2[2] / 2, box2[0] + box2[2] / 2\n b2_y1, b2_y2 = box2[1] - box2[3] / 2, box2[1] + box2[3] / 2\n\n # Intersection area\n inter = (torch.min(b1_x2, b2_x2) - torch.max(b1_x1, b2_x1)).clamp(0) * (\n torch.min(b1_y2, b2_y2) - torch.max(b1_y1, b2_y1)\n ).clamp(0)\n\n # Union Area\n w1, h1 = b1_x2 - b1_x1, b1_y2 - b1_y1 + eps\n w2, h2 = b2_x2 - b2_x1, b2_y2 - b2_y1 + eps\n union = w1 * h1 + w2 * h2 - inter + eps\n\n iou = inter / union\n if GIoU or DIoU or CIoU or EIoU or ECIoU:\n # convex (smallest enclosing box) width\n cw = torch.max(b1_x2, b2_x2) - torch.min(b1_x1, b2_x1)\n ch = torch.max(b1_y2, b2_y2) - torch.min(b1_y1, b2_y1) # convex height\n if CIoU or DIoU or EIoU or ECIoU: # Distance or Complete IoU https://arxiv.org/abs/1911.08287v1\n c2 = cw ** 2 + ch ** 2 + eps # convex diagonal squared\n rho2 = (\n (b2_x1 + b2_x2 - b1_x1 - b1_x2) ** 2 + (b2_y1 + b2_y2 - b1_y1 - b1_y2) ** 2\n ) / 4 # center distance squared\n if DIoU:\n return iou - rho2 / c2 # DIoU\n elif CIoU: # https://github.com/Zzh-tju/DIoU-SSD-pytorch/blob/master/utils/box/box_utils.py#L47\n v = (4 / math.pi ** 2) * torch.pow(torch.atan(w2 / h2) - torch.atan(w1 / h1), 2)\n with torch.no_grad():\n alpha = v / (v - iou + (1 + eps))\n return iou - (rho2 / c2 + v * alpha) # CIoU\n\n # ################### Function from Yolov4 ###########################################\n elif EIoU: # Efficient IoU https://arxiv.org/abs/2101.08158\n rho3 = (w1 - w2) ** 2\n c3 = cw ** 2 + eps\n rho4 = (h1 - h2) ** 2\n c4 = ch ** 2 + eps\n return iou - rho2 / c2 - rho3 / c3 - rho4 / c4 # EIoU\n elif ECIoU:\n v = (4 / math.pi ** 2) * torch.pow(torch.atan(w2 / h2) - torch.atan(w1 / h1), 2)\n with torch.no_grad():\n alpha = v / ((1 + eps) - iou + v)\n rho3 = (w1 - w2) ** 2\n c3 = cw ** 2 + eps\n rho4 = (h1 - h2) ** 2\n c4 = ch ** 2 + eps\n return iou - v * alpha - rho2 / c2 - rho3 / c3 - rho4 / c4 # ECIoU\n ############################################################################################\n else: # GIoU https://arxiv.org/pdf/1902.09630.pdf\n c_area = cw * ch + eps # convex area\n return iou - (c_area - union) / c_area # GIoU\n else:\n return iou # IoU\n\n\ndef smooth_BCE(\n eps=0.1,\n): # https://github.com/ultralytics/yolov3/issues/238#issuecomment-598028441\n # return positive, negative label smoothing BCE targets\n return 1.0 - 0.5 * eps, 0.5 * eps\n\n\nclass FocalLoss(nn.Module):\n # Wraps focal loss around existing loss_fcn(), i.e. criteria =\n # FocalLoss(nn.BCEWithLogitsLoss(), gamma=1.5)\n def __init__(self, loss_fcn, gamma=1.5, alpha=0.25):\n super().__init__()\n self.loss_fcn = loss_fcn # must be nn.BCEWithLogitsLoss()\n self.gamma = gamma\n self.alpha = alpha\n self.reduction = loss_fcn.reduction\n self.loss_fcn.reduction = \"none\" # required to apply FL to each element\n\n def forward(self, pred, true):\n loss = self.loss_fcn(pred, true)\n # p_t = torch.exp(-loss)\n # loss *= self.alpha * (1.000001 - p_t) ** self.gamma # non-zero power\n # for gradient stability\n\n # TF implementation\n # https://github.com/tensorflow/addons/blob/v0.7.1/tensorflow_addons/losses/focal_loss.py\n pred_prob = torch.sigmoid(pred) # prob from logits\n p_t = true * pred_prob + (1 - true) * (1 - pred_prob)\n alpha_factor = true * self.alpha + (1 - true) * (1 - self.alpha)\n modulating_factor = (1.0 - p_t) ** self.gamma\n loss *= alpha_factor * modulating_factor\n\n if self.reduction == \"mean\":\n return loss.mean()\n elif self.reduction == \"sum\":\n return loss.sum()\n else: # 'none'\n return loss\n\n\nclass ComputeLoss(object):\n # Compute losses\n\n @configurable\n def __init__(\n self,\n *,\n focal_loss_gamma,\n box_loss_gain,\n cls_loss_gain,\n cls_positive_weight,\n obj_loss_gain,\n obj_positive_weight,\n label_smoothing=0.0,\n gr,\n na,\n nc,\n nl,\n anchors,\n anchor_t,\n autobalance=False,\n ):\n super().__init__()\n self.sort_obj_iou = False\n self.na = na\n self.nc = nc\n self.nl = nl\n self.anchors = anchors\n self.box_loss_gain = box_loss_gain\n self.cls_loss_gain = cls_loss_gain\n self.obj_loss_gain = obj_loss_gain\n self.anchor_t = anchor_t\n\n # Define criteria\n BCEcls = nn.BCEWithLogitsLoss(pos_weight=torch.tensor([cls_positive_weight]))\n BCEobj = nn.BCEWithLogitsLoss(pos_weight=torch.tensor([obj_positive_weight]))\n\n # Class label smoothing https://arxiv.org/pdf/1902.04103.pdf eqn 3\n # positive, negative BCE targets\n self.cp, self.cn = smooth_BCE(eps=label_smoothing)\n\n # Focal loss\n if focal_loss_gamma > 0:\n BCEcls = FocalLoss(BCEcls, focal_loss_gamma)\n BCEobj = FocalLoss(BCEobj, focal_loss_gamma)\n\n # Detect() module\n self.balance = {3: [4.0, 1.0, 0.4]}.get(nl, [4.0, 1.0, 0.25, 0.06, 0.02]) # P3-P7\n self.ssi = 0 # stride 16 index\n self.BCEcls, self.BCEobj, self.gr, self.autobalance = (\n BCEcls,\n BCEobj,\n gr,\n autobalance,\n )\n\n @classmethod\n def from_config(cls, cfg, head):\n return {\n \"focal_loss_gamma\": cfg.MODEL.YOLOV5.FOCAL_LOSS_GAMMA,\n \"box_loss_gain\": cfg.MODEL.YOLOV5.BOX_LOSS_GAIN,\n \"cls_loss_gain\": cfg.MODEL.YOLOV5.CLS_LOSS_GAIN,\n \"cls_positive_weight\": cfg.MODEL.YOLOV5.CLS_POSITIVE_WEIGHT,\n \"obj_loss_gain\": cfg.MODEL.YOLOV5.OBJ_LOSS_GAIN,\n \"obj_positive_weight\": cfg.MODEL.YOLOV5.OBJ_POSITIVE_WEIGHT,\n \"label_smoothing\": cfg.MODEL.YOLOV5.LABEL_SMOOTHING,\n \"gr\": 1.0,\n \"na\": head.na,\n \"nc\": head.nc,\n \"nl\": head.nl,\n \"anchors\": head.anchors,\n \"anchor_t\": cfg.MODEL.YOLOV5.ANCHOR_T,\n \"autobalance\": False,\n }\n\n def _initialize_ssi(self, stride):\n if self.autobalance:\n self.ssi = list(stride).index(16)\n\n def __call__(self, p, instances): # predictions, targets, model is ignored\n device = instances[0].gt_boxes.device\n self.to(device)\n lcls, lbox, lobj = (\n torch.zeros(1, device=device),\n torch.zeros(1, device=device),\n torch.zeros(1, device=device),\n )\n tcls, tbox, indices, anchors = self.build_targets(p, instances) # targets\n\n # Losses\n for i, pi in enumerate(p): # layer index, layer predictions\n b, a, gj, gi = indices[i] # image, anchor, gridy, gridx\n tobj = torch.zeros_like(pi[..., 0], device=device) # target obj\n\n n = b.shape[0] # number of targets\n if n:\n # prediction subset corresponding to targets\n ps = pi[b, a, gj, gi]\n\n # Regression\n pxy = ps[:, :2].sigmoid() * 2.0 - 0.5\n pwh = (ps[:, 2:4].sigmoid() * 2) ** 2 * anchors[i]\n pbox = torch.cat((pxy, pwh), 1) # predicted box\n # iou(prediction, target)\n iou = bbox_iou(pbox.T, tbox[i], x1y1x2y2=False, CIoU=True)\n lbox += (1.0 - iou).mean() # iou loss\n\n # Objectness\n score_iou = iou.detach().clamp(0).type(tobj.dtype)\n if self.sort_obj_iou:\n sort_id = torch.argsort(score_iou)\n b, a, gj, gi, score_iou = (\n b[sort_id],\n a[sort_id],\n gj[sort_id],\n gi[sort_id],\n score_iou[sort_id],\n )\n tobj[b, a, gj, gi] = (1.0 - self.gr) + self.gr * score_iou # iou ratio\n\n # Classification\n if self.nc > 1: # cls loss (only if multiple classes)\n t = torch.full_like(ps[:, 5:], self.cn, device=device) # targets\n t[range(n), tcls[i]] = self.cp\n lcls += self.BCEcls(ps[:, 5:], t) # BCE\n\n # Append targets to text file\n # with open('targets.txt', 'a') as file:\n # [file.write('%11.5g ' * 4 % tuple(x) + '\\n') for x in torch.cat((txy[i], twh[i]), 1)]\n\n obji = self.BCEobj(pi[..., 4], tobj)\n lobj += obji * self.balance[i] # obj loss\n if self.autobalance:\n self.balance[i] = self.balance[i] * 0.9999 + 0.0001 / obji.detach().item()\n\n if self.autobalance:\n self.balance = [x / self.balance[self.ssi] for x in self.balance]\n lbox *= self.box_loss_gain\n lobj *= self.obj_loss_gain\n lcls *= self.cls_loss_gain\n # bs = tobj.shape[0] # batch size\n\n # loss = lbox + lobj + lcls\n # return loss * bs, torch.cat((lbox, lobj, lcls, loss)).detach()\n return {\n \"loss_box\": lbox,\n \"loss_obj\": lobj,\n \"loss_cls\": lcls,\n }\n\n def build_targets(self, p, gt_instances):\n \"\"\"\n Args:\n p (list[Tensors]): A list of #feature level predictions\n gt_instances (list[Instances]): a list of N `Instances`s. The i-th\n `Instances` contains the ground-truth per-instance annotations\n for the i-th input image.\n \"\"\"\n # Build targets for compute_loss(), input targets(image,class,x,y,w,h)\n targets = []\n for i, gt_per_image in enumerate(gt_instances):\n # Convert the boxes to target format of shape [sum(nL per image), 6]\n # where each target entry is [img_index, class, x, y, w, h],\n # x, y, w, h - relative and x, y are centers\n if len(gt_per_image) > 0:\n boxes = gt_per_image.gt_boxes.tensor.clone()\n h, w = gt_per_image.image_size\n boxes[:, 0:2] = (boxes[:, 0:2] + boxes[:, 2:4]) / 2\n boxes[:, 2:4] = (boxes[:, 2:4] - boxes[:, 0:2]) * 2\n boxes[:, ::2] /= float(w)\n boxes[:, 1::2] /= float(h)\n classes = torch.unsqueeze(gt_per_image.gt_classes.clone(), dim=1)\n t = torch.cat([torch.ones_like(classes) * i, classes, boxes], dim=1)\n targets.append(t)\n targets = torch.cat(targets, 0)\n\n na, nt = self.na, targets.shape[0] # number of anchors, targets\n tcls, tbox, indices, anch = [], [], [], []\n # normalized to gridspace gain\n gain = torch.ones(7, device=targets.device)\n ai = (\n torch.arange(na, device=targets.device).float().view(na, 1).repeat(1, nt)\n ) # same as .repeat_interleave(nt)\n # append anchor indices\n targets = torch.cat((targets.repeat(na, 1, 1), ai[:, :, None]), 2)\n\n g = 0.5 # bias\n off = (\n torch.tensor(\n [\n [0, 0],\n [1, 0],\n [0, 1],\n [-1, 0],\n [0, -1], # j,k,l,m\n # [1, 1], [1, -1], [-1, 1], [-1, -1], # jk,jm,lk,lm\n ],\n device=targets.device,\n ).float()\n * g\n ) # offsets\n\n for i in range(self.nl):\n anchors = self.anchors[i]\n gain[2:6] = torch.tensor(p[i].shape)[[3, 2, 3, 2]] # xyxy gain\n\n # Match targets to anchors\n t = targets * gain\n if nt:\n # Matches\n r = t[:, :, 4:6] / anchors[:, None] # wh ratio\n j = torch.max(r, 1.0 / r).max(2)[0] < self.anchor_t # compare\n # j = wh_iou(anchors, t[:, 4:6]) > model.hyp['iou_t'] #\n # iou(3,n)=wh_iou(anchors(3,2), gwh(n,2))\n t = t[j] # filter\n\n # Offsets\n gxy = t[:, 2:4] # grid xy\n gxi = gain[[2, 3]] - gxy # inverse\n j, k = ((gxy % 1.0 < g) & (gxy > 1.0)).T\n l, m = ((gxi % 1.0 < g) & (gxi > 1.0)).T\n j = torch.stack((torch.ones_like(j), j, k, l, m))\n t = t.repeat((5, 1, 1))[j]\n offsets = (torch.zeros_like(gxy)[None] + off[:, None])[j]\n else:\n t = targets[0]\n offsets = 0\n\n # Define\n b, c = t[:, :2].long().T # image, class\n gxy = t[:, 2:4] # grid xy\n gwh = t[:, 4:6] # grid wh\n gij = (gxy - offsets).long()\n gi, gj = gij.T # grid xy indices\n\n # Append\n a = t[:, 6].long() # anchor indices\n # image, anchor, grid indices\n indices.append((b, a, gj.clamp_(0, gain[3] - 1), gi.clamp_(0, gain[2] - 1)))\n tbox.append(torch.cat((gxy - gij, gwh), 1)) # box\n anch.append(anchors[a]) # anchors\n tcls.append(c) # class\n\n return tcls, tbox, indices, anch\n\n def to(self, device):\n self.anchors = self.anchors.to(device)\n self.BCEcls.pos_weight = self.BCEcls.pos_weight.to(device)\n self.BCEobj.pos_weight = self.BCEobj.pos_weight.to(device)\n\n\n@META_ARCH_REGISTRY.register()\nclass YoloV5(nn.Module):\n \"\"\"\n Implement YoloV5\n \"\"\"\n\n @configurable\n def __init__(\n self,\n *,\n backbone: Backbone,\n head: nn.Module,\n loss,\n num_classes,\n conf_thres,\n iou_thres,\n pixel_mean,\n pixel_std,\n vis_period=0,\n input_format=\"BGR\",\n ):\n super().__init__()\n\n self.backbone = backbone\n self.head = head\n\n self.num_classes = num_classes\n self.single_cls = num_classes == 1\n # Inference Parameters\n self.conf_thres = conf_thres\n self.iou_thres = iou_thres\n # Vis parameters\n self.vis_period = vis_period\n self.input_format = input_format\n\n self.register_buffer(\"pixel_mean\", torch.tensor(pixel_mean).view(-1, 1, 1), False)\n self.register_buffer(\"pixel_std\", torch.tensor(pixel_std).view(-1, 1, 1), False)\n\n \"\"\"\n In Detectron1, loss is normalized by number of foreground samples in the batch.\n When batch size is 1 per GPU, #foreground has a large variance and\n using it lead to lower performance. Here we maintain an EMA of #foreground to\n stabilize the normalizer.\n \"\"\"\n self.loss = loss\n # self.loss_normalizer = 100 # initialize with any reasonable #fg that's not too small\n # self.loss_normalizer_momentum = 0.9\n self.init_stride()\n self.apply(self._init_weights)\n\n def _init_weights(self, module):\n \"\"\"Initialize the weights\"\"\"\n if isinstance(module, nn.BatchNorm2d):\n module.eps = 1e-3\n module.momentum = 0.03\n\n @classmethod\n def from_config(cls, cfg):\n backbone = build_backbone(cfg)\n backbone_shape = backbone.output_shape()\n feature_shapes = list(backbone_shape.values())\n head = YoloV5Head(cfg, feature_shapes)\n loss = ComputeLoss(cfg, head)\n return {\n \"backbone\": backbone,\n \"head\": head,\n \"loss\": loss,\n \"num_classes\": head.nc,\n \"conf_thres\": cfg.MODEL.YOLOV5.CONF_THRESH,\n \"iou_thres\": cfg.MODEL.YOLOV5.IOU_THRES,\n \"pixel_mean\": cfg.MODEL.PIXEL_MEAN,\n \"pixel_std\": cfg.MODEL.PIXEL_STD,\n \"vis_period\": cfg.VIS_PERIOD,\n \"input_format\": cfg.INPUT.FORMAT,\n }\n\n @property\n def device(self):\n return self.pixel_mean.device\n\n def visualize_training(self, batched_inputs, results):\n \"\"\"\n A function used to visualize ground truth images and final network predictions.\n It shows ground truth bounding boxes on the original image and up to 20\n predicted object bounding boxes on the original image.\n Args:\n batched_inputs (list): a list that contains input to the model.\n results (List[Instances]): a list of #images elements.\n \"\"\"\n from detectron2.utils.visualizer import Visualizer\n\n assert len(batched_inputs) == len(results), \"Cannot visualize inputs and results of different sizes\"\n storage = get_event_storage()\n max_boxes = 20\n\n image_index = 0 # only visualize a single image\n img = batched_inputs[image_index][\"image\"]\n img = convert_image_to_rgb(img.permute(1, 2, 0), self.input_format)\n v_gt = Visualizer(img, None)\n v_gt = v_gt.overlay_instances(boxes=batched_inputs[image_index][\"instances\"].gt_boxes)\n anno_img = v_gt.get_image()\n processed_results = detector_postprocess(results[image_index], img.shape[0], img.shape[1])\n predicted_boxes = processed_results.pred_boxes.tensor.detach().cpu().numpy()\n\n v_pred = Visualizer(img, None)\n v_pred = v_pred.overlay_instances(boxes=predicted_boxes[0:max_boxes])\n prop_img = v_pred.get_image()\n vis_img = np.vstack((anno_img, prop_img))\n vis_img = vis_img.transpose(2, 0, 1)\n vis_name = f\"Top: GT bounding boxes; Bottom: {max_boxes} Highest Scoring Results\"\n storage.put_image(vis_name, vis_img)\n\n def init_stride(self):\n s = 256 # 2x min stride\n dummy_input = torch.zeros(1, len(self.pixel_mean), s, s)\n features = self.backbone(dummy_input)\n features = list(features.values())\n pred = self.head(features)\n self.head.stride = torch.tensor([s / x.shape[-2] for x in pred]) # forward\n self.head.anchors /= self.head.stride.view(-1, 1, 1)\n self.stride = self.head.stride\n self.head._initialize_biases() # only run once\n self.loss._initialize_ssi(self.stride)\n\n def forward(self, batched_inputs: Tuple[Dict[str, Tensor]]):\n \"\"\"\n Args:\n batched_inputs: a list, batched outputs of :class:`DatasetMapper` .\n Each item in the list contains the inputs for one image.\n For now, each item in the list is a dict that contains:\n * image: Tensor, image in (C, H, W) format.\n * instances: Instances\n Other information that's included in the original dicts, such as:\n * \"height\", \"width\" (int): the output resolution of the model, used in inference.\n See :meth:`postprocess` for details.\n Returns:\n In training, dict[str, Tensor]: mapping from a named loss to a tensor storing the\n loss. Used during training only. In inference, the standard output format, described\n in :doc:`/tutorials/models`.\n \"\"\"\n images = self.preprocess_image(batched_inputs)\n features = self.backbone(images.tensor)\n features = list(features.values())\n\n pred = self.head(features)\n\n if self.training:\n assert not torch.jit.is_scripting(), \"Not supported\"\n assert \"instances\" in batched_inputs[0], \"Instance annotations are missing in training!\"\n gt_instances = [x[\"instances\"].to(self.device) for x in batched_inputs]\n\n losses = self.loss(pred, gt_instances)\n\n if self.vis_period > 0:\n storage = get_event_storage()\n if storage.iter % self.vis_period == 0:\n results = self.inference(pred, images.image_sizes)\n self.visualize_training(batched_inputs, results)\n\n return losses\n else:\n results = self.inference(pred, images.image_sizes)\n if torch.jit.is_scripting():\n return results\n processed_results = []\n for results_per_image, input_per_image, image_size in zip(results, batched_inputs, images.image_sizes):\n height = input_per_image.get(\"height\", image_size[0])\n width = input_per_image.get(\"width\", image_size[1])\n r = detector_postprocess(results_per_image, height, width)\n processed_results.append({\"instances\": r})\n return processed_results\n\n def inference(self, x, image_sizes):\n \"\"\"\n Returns:\n z (Tensor) : [N, nl*na*(sum of grid sizes) , no] indictaing\n 1. Box position z[..., 0:2]\n 2. Box width and height z[..., 2:4]\n 3. Objectness z[..., 5]\n 4. Class probabilities z[..., 6:]\n \"\"\"\n z = []\n for i in range(self.head.nl):\n # x(bs,na,ny,nx,no)\n bs, _, ny, nx, _ = x[i].shape\n if self.head.grid[i].shape[2:4] != x[i].shape[2:4]:\n self.head.grid[i] = self.head._make_grid(nx, ny).to(x[i].device)\n\n y = x[i].sigmoid()\n # if self.head.inplace:\n y[..., 0:2] = (y[..., 0:2] * 2.0 - 0.5 + self.head.grid[i]) * self.head.stride[i] # xy\n y[..., 2:4] = (y[..., 2:4] * 2) ** 2 * self.head.anchor_grid[i] # wh\n # else: # for YOLOv5 on AWS Inferentia https://github.com/ultralytics/yolov5/pull/2953\n # xy = (y[..., 0:2] * 2. - 0.5 + self.head.grid[i]) * self.head.stride[i] # xy\n # wh = (y[..., 2:4] * 2) ** 2 * self.head.anchor_grid[i].view(1, self.head.na, 1, 1, 2) # wh\n # y = torch.cat((xy, wh, y[..., 4:]), -1)\n z.append(y.view(bs, -1, self.head.no))\n return self.process_inference(torch.cat(z, 1), image_sizes)\n\n def process_inference(self, out, image_sizes):\n out = non_max_suppression(\n out,\n self.conf_thres,\n self.iou_thres,\n multi_label=True,\n agnostic=self.single_cls,\n )\n assert len(out) == len(image_sizes)\n results_all: List[Instances] = []\n # Statistics per image\n for si, (pred, img_size) in enumerate(zip(out, image_sizes)):\n\n if len(pred) == 0:\n result = Instances(img_size)\n result.pred_boxes = Boxes(torch.tensor([]))\n result.scores = torch.tensor([])\n result.pred_classes = torch.tensor([])\n else:\n # Predictions\n if self.single_cls:\n pred[:, 5] = 0\n predn = pred.clone()\n # Predn shape [ndets, 6] of format [xyxy, conf, cls] relative to the input image size\n result = Instances(img_size)\n result.pred_boxes = Boxes(predn[:, :4]) # TODO: Check if resizing needed\n result.scores = predn[:, 4]\n result.pred_classes = predn[:, 5].int() # TODO: Check the classes\n results_all.append(result)\n return results_all\n\n def preprocess_image(self, batched_inputs: Tuple[Dict[str, Tensor]]):\n \"\"\"\n Normalize, pad and batch the input images.\n \"\"\"\n images = [x[\"image\"].to(self.device) for x in batched_inputs]\n images = [(x - self.pixel_mean) / self.pixel_std for x in images]\n images = ImageList.from_tensors(images, self.backbone.size_divisibility)\n return images\n", "meta": {"hexsha": "c071b66bd691c5570255d730ff26a600cdb6ff5a", "size": 32839, "ext": "py", "lang": "Python", "max_stars_repo_path": "unitorch/models/detectron2/meta_arch/yolo5.py", "max_stars_repo_name": "fuliucansheng/UniTorch", "max_stars_repo_head_hexsha": "47038321593ce4e7eabda555bd58c0cf89482146", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2022-02-05T08:52:00.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-27T07:01:34.000Z", "max_issues_repo_path": "unitorch/models/detectron2/meta_arch/yolo5.py", "max_issues_repo_name": "Lixin-Qian/unitorch", "max_issues_repo_head_hexsha": "47038321593ce4e7eabda555bd58c0cf89482146", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "unitorch/models/detectron2/meta_arch/yolo5.py", "max_forks_repo_name": "Lixin-Qian/unitorch", "max_forks_repo_head_hexsha": "47038321593ce4e7eabda555bd58c0cf89482146", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-27T07:01:13.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-27T07:01:13.000Z", "avg_line_length": 40.0475609756, "max_line_length": 115, "alphanum_fraction": 0.5374706903, "include": true, "reason": "import numpy", "num_tokens": 9236, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5851011542032313, "lm_q2_score": 0.3242354120407358, "lm_q1q2_score": 0.1897105138185948}} {"text": "\"\"\"API for joint-density-of-states calculation.\"\"\"\n# Copyright (C) 2019 Atsushi Togo\n# All rights reserved.\n#\n# This file is part of phono3py.\n#\n# Redistribution and use in source and binary forms, with or without\n# modification, are permitted provided that the following conditions\n# are met:\n#\n# * Redistributions of source code must retain the above copyright\n# notice, this list of conditions and the following disclaimer.\n#\n# * Redistributions in binary form must reproduce the above copyright\n# notice, this list of conditions and the following disclaimer in\n# the documentation and/or other materials provided with the\n# distribution.\n#\n# * Neither the name of the phonopy project nor the names of its\n# contributors may be used to endorse or promote products derived\n# from this software without specific prior written permission.\n#\n# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n# \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS\n# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE\n# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,\n# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,\n# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\n# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN\n# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n# POSSIBILITY OF SUCH DAMAGE.\n\nimport numpy as np\nfrom phonopy.structure.cells import Primitive, Supercell\nfrom phonopy.structure.symmetry import Symmetry\nfrom phonopy.units import VaspToTHz\n\nfrom phono3py.file_IO import write_joint_dos\nfrom phono3py.phonon3.imag_self_energy import (\n get_freq_points_batches,\n get_frequency_points,\n)\nfrom phono3py.phonon3.joint_dos import JointDos\nfrom phono3py.phonon.grid import BZGrid\n\n\nclass Phono3pyJointDos:\n \"\"\"Class to calculate joint-density-of-states.\"\"\"\n\n def __init__(\n self,\n supercell: Supercell,\n primitive: Primitive,\n fc2,\n mesh=None,\n nac_params=None,\n nac_q_direction=None,\n sigmas=None,\n cutoff_frequency=1e-4,\n frequency_step=None,\n num_frequency_points=None,\n num_points_in_batch=None,\n temperatures=None,\n frequency_factor_to_THz=VaspToTHz,\n frequency_scale_factor=None,\n use_grg=False,\n SNF_coordinates=\"reciprocal\",\n is_mesh_symmetry=True,\n is_symmetry=True,\n store_dense_gp_map=False,\n symprec=1e-5,\n output_filename=None,\n log_level=0,\n ):\n \"\"\"Init method.\"\"\"\n self._primitive = primitive\n self._supercell = supercell\n self._fc2 = fc2\n self._temperatures = temperatures\n self._nac_params = nac_params\n self._nac_q_direction = nac_q_direction\n if sigmas is None:\n self._sigmas = [None]\n else:\n self._sigmas = sigmas\n self._cutoff_frequency = cutoff_frequency\n self._frequency_factor_to_THz = frequency_factor_to_THz\n self._frequency_scale_factor = frequency_scale_factor\n self._is_mesh_symmetry = is_mesh_symmetry\n self._is_symmetry = is_symmetry\n self._store_dense_gp_map = store_dense_gp_map\n self._use_grg = use_grg\n self._SNF_coordinates = SNF_coordinates\n self._symprec = symprec\n self._filename = output_filename\n self._log_level = log_level\n\n self._bz_grid = None\n self._joint_dos = None\n self._num_frequency_points_in_batch = num_points_in_batch\n self._frequency_step = frequency_step\n self._num_frequency_points = num_frequency_points\n\n self._primitive_symmetry = Symmetry(\n self._primitive, self._symprec, self._is_symmetry\n )\n\n if mesh is not None:\n self.mesh_numbers = mesh\n self.initialize(mesh)\n\n @property\n def grid(self):\n \"\"\"Return BZGrid class instance.\"\"\"\n return self._bz_grid\n\n @property\n def nac_params(self):\n \"\"\"Setter and getter of parameters for non-analytical term correction.\"\"\"\n return self._nac_params\n\n @property\n def num_frequency_points_in_batch(self):\n \"\"\"Getter and setter of num_frequency_points_in_batch.\n\n Number of sampling frequency points per batch.\n Larger value gives better concurrency in tetrahedron method,\n but requires more memory.\n\n \"\"\"\n return self._num_frequency_points_in_batch\n\n @num_frequency_points_in_batch.setter\n def num_frequency_points_in_batch(self, nelems_in_batch):\n self._num_frequency_points_in_batch = nelems_in_batch\n\n @property\n def mesh_numbers(self):\n \"\"\"Setter and getter of sampling mesh numbers in reciprocal space.\"\"\"\n if self._bz_grid is None:\n return None\n else:\n return self._bz_grid.D_diag\n\n @mesh_numbers.setter\n def mesh_numbers(self, mesh_numbers):\n self._bz_grid = BZGrid(\n mesh_numbers,\n lattice=self._primitive.cell,\n symmetry_dataset=self._primitive_symmetry.dataset,\n is_time_reversal=self._is_symmetry,\n use_grg=self._use_grg,\n force_SNF=False,\n SNF_coordinates=self._SNF_coordinates,\n store_dense_gp_map=self._store_dense_gp_map,\n )\n\n def initialize(self, mesh_numbers):\n \"\"\"Initialize JointDos.\"\"\"\n self._jdos = JointDos(\n self._primitive,\n self._supercell,\n self._bz_grid,\n self._fc2,\n nac_params=self._nac_params,\n cutoff_frequency=self._cutoff_frequency,\n frequency_factor_to_THz=self._frequency_factor_to_THz,\n frequency_scale_factor=self._frequency_scale_factor,\n is_mesh_symmetry=self._is_mesh_symmetry,\n store_dense_gp_map=self._store_dense_gp_map,\n symprec=self._symprec,\n filename=self._filename,\n log_level=self._log_level,\n )\n if self._log_level:\n print(\"Generating grid system ... \", end=\"\", flush=True)\n\n self.mesh_numbers = mesh_numbers\n\n if self._log_level:\n if self._bz_grid.grid_matrix is None:\n print(\"[ %d %d %d ]\" % tuple(self._bz_grid.D_diag))\n else:\n print(\"\")\n print(\n \"Generalized regular grid: [ %d %d %d ]\"\n % tuple(self._bz_grid.D_diag)\n )\n print(\"Grid generation matrix:\")\n print(\" [ %d %d %d ]\" % tuple(self._bz_grid.grid_matrix[0]))\n print(\" [ %d %d %d ]\" % tuple(self._bz_grid.grid_matrix[1]))\n print(\" [ %d %d %d ]\" % tuple(self._bz_grid.grid_matrix[2]))\n\n def run(self, grid_points, write_jdos=False):\n \"\"\"Calculate joint-density-of-states.\"\"\"\n if self._log_level:\n print(\n \"--------------------------------- Joint DOS \"\n \"---------------------------------\"\n )\n print(\"Running harmonic phonon calculations...\", flush=True)\n\n self._jdos.run_phonon_solver()\n frequencies, _, _ = self._jdos.get_phonons()\n self._jdos.run_phonon_solver_at_gamma()\n max_phonon_freq = np.max(frequencies)\n self._jdos.run_phonon_solver_at_gamma(is_nac=True)\n\n self._frequency_points = get_frequency_points(\n max_phonon_freq=max_phonon_freq,\n sigmas=self._sigmas,\n frequency_points=None,\n frequency_step=self._frequency_step,\n num_frequency_points=self._num_frequency_points,\n )\n batches = get_freq_points_batches(\n len(self._frequency_points), nelems=self._num_frequency_points_in_batch\n )\n if self._temperatures is None:\n temperatures = [None]\n else:\n temperatures = self._temperatures\n self._joint_dos = np.zeros(\n (\n len(self._sigmas),\n len(temperatures),\n len(self._frequency_points),\n 2,\n ),\n dtype=\"double\",\n order=\"C\",\n )\n\n for i, gp in enumerate(grid_points):\n if (self._bz_grid.addresses[gp] == 0).all():\n self._jdos.nac_q_direction = self._nac_q_direction\n else:\n self._jdos.nac_q_direction = None\n self._jdos.set_grid_point(gp)\n\n if self._log_level:\n weights = self._jdos.get_triplets_at_q()[1]\n print(\n \"======================= \"\n \"Grid point %d (%d/%d) \"\n \"=======================\" % (gp, i + 1, len(grid_points))\n )\n adrs = self._jdos.bz_grid.addresses[gp]\n q = np.dot(adrs, self._bz_grid.QDinv.T)\n print(\"q-point: (%5.2f %5.2f %5.2f)\" % tuple(q))\n print(\"Number of triplets: %d\" % len(weights))\n print(\"Frequency\")\n for f in self._jdos.get_phonons()[0][gp]:\n print(\"%8.3f\" % f)\n\n if not self._sigmas:\n raise RuntimeError(\"sigma or tetrahedron method has to be set.\")\n\n for i_s, sigma in enumerate(self._sigmas):\n self._jdos.sigma = sigma\n if self._log_level:\n if sigma is None:\n print(\"Tetrahedron method is used.\")\n else:\n print(\"Smearing method with sigma=%s is used.\" % sigma)\n print(\n f\"Calculations at {len(self._frequency_points)} \"\n f\"frequency points are devided into {len(batches)} batches.\"\n )\n for i_t, temperature in enumerate(temperatures):\n self._jdos.temperature = temperature\n\n for ib, freq_indices in enumerate(batches):\n if self._log_level:\n print(\n f\"{ib + 1}/{len(batches)}: {freq_indices + 1}\",\n flush=True,\n )\n self._jdos.frequency_points = self._frequency_points[\n freq_indices\n ]\n self._jdos.run()\n self._joint_dos[i_s, i_t, freq_indices] = self._jdos.joint_dos\n\n if write_jdos:\n filename = self._write(gp, i_sigma=i_s)\n if self._log_level:\n print('JDOS is written into \"%s\".' % filename)\n\n @property\n def dynamical_matrix(self):\n \"\"\"Return DynamicalMatrix class instance.\"\"\"\n return self._jdos.dynamical_matrix\n\n @property\n def frequency_points(self):\n \"\"\"Return frequency points.\"\"\"\n return self._frequency_points\n\n @property\n def joint_dos(self):\n \"\"\"Return calculated joint-density-of-states.\"\"\"\n return self._joint_dos\n\n def _write(self, gp, i_sigma=0):\n return write_joint_dos(\n gp,\n self._bz_grid.D_diag,\n self._frequency_points,\n self._joint_dos[i_sigma],\n sigma=self._sigmas[i_sigma],\n temperatures=self._temperatures,\n filename=self._filename,\n is_mesh_symmetry=self._is_mesh_symmetry,\n )\n", "meta": {"hexsha": "cd240405c31cc95803cd5acdf4f3e7d235fdf75e", "size": 11726, "ext": "py", "lang": "Python", "max_stars_repo_path": "phono3py/api_jointdos.py", "max_stars_repo_name": "MSimoncelli/phono3py", "max_stars_repo_head_hexsha": "b28b45a025c279833e9269e5d91330c75d3f6ae0", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 38, "max_stars_repo_stars_event_min_datetime": "2016-04-27T04:43:25.000Z", "max_stars_repo_stars_event_max_datetime": "2020-05-01T07:46:56.000Z", "max_issues_repo_path": "phono3py/api_jointdos.py", "max_issues_repo_name": "MSimoncelli/phono3py", "max_issues_repo_head_hexsha": "b28b45a025c279833e9269e5d91330c75d3f6ae0", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 36, "max_issues_repo_issues_event_min_datetime": "2016-12-22T12:42:54.000Z", "max_issues_repo_issues_event_max_datetime": "2020-05-02T07:31:53.000Z", "max_forks_repo_path": "phono3py/api_jointdos.py", "max_forks_repo_name": "MSimoncelli/phono3py", "max_forks_repo_head_hexsha": "b28b45a025c279833e9269e5d91330c75d3f6ae0", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 30, "max_forks_repo_forks_event_min_datetime": "2016-02-11T13:33:56.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-01T21:36:50.000Z", "avg_line_length": 36.7586206897, "max_line_length": 86, "alphanum_fraction": 0.5960259253, "include": true, "reason": "import numpy", "num_tokens": 2539, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6039318479832804, "lm_q2_score": 0.3140505578320071, "lm_q1q2_score": 0.1896651337516641}} {"text": "from abc import ABC\nfrom typing import Union\n\nimport numpy as np\nfrom qcore import geo\nfrom qcore.nhm import NHMFault\n\nfrom srf_generation.source_parameter_generation.uncertainties.mag_scaling import (\n MagnitudeScalingRelations,\n get_area,\n get_length,\n get_width,\n mag2mom,\n round_subfault_size,\n lw_to_mw_scaling_relation,\n)\n\nLEONARD_SEISMOGENIC_DEPTH_DIFFERENCE = 3\nNHM_SEISMOGENIC_DEPTH = 12\n\n\ndef fault_factory(fault_type: int):\n return [Type1, Type2, Type3, Type4][fault_type - 1]\n\n\nclass Fault(ABC):\n subfault_spacing = 0.1\n type = 0\n _mag = None\n _moment = None\n name = None\n _latitude = None\n _longitude = None\n _strike = None\n _rake = None\n _dip = None\n _depth = None\n _width = None\n _length = None\n _shypo = None\n _dhypo = None\n\n @property\n def pid(self):\n return self.name\n\n @pid.setter\n def pid(self, value):\n self.name = value\n\n @property\n def mom(self):\n if self._moment is None:\n self._moment = mag2mom(self._mag)\n return self._moment\n\n @property\n def latitude(self):\n return self._latitude\n\n @latitude.setter\n def latitude(self, value):\n self._latitude = value\n\n @property\n def longitude(self):\n return self._longitude\n\n @longitude.setter\n def longitude(self, value):\n self._longitude = value\n\n @property\n def magnitude(self):\n return self._mag\n\n @magnitude.setter\n def magnitude(self, mag):\n if mag > 11:\n raise ValueError(\n f\"Given mag {mag} is greater than theoretically possible 11\"\n )\n self._mag = mag\n\n @property\n def length(self):\n return self._length\n\n @property\n def width(self):\n return self._width\n\n def to_dict(self):\n return {\n \"type\": self.type,\n \"magnitude\": self._mag,\n \"moment\": self.mom,\n \"name\": self.name,\n \"longitude\": self.longitude,\n \"latitude\": self.latitude,\n \"strike\": self._strike,\n \"rake\": self._rake,\n \"dip\": self._dip,\n \"depth\": self._depth,\n }\n\n @property\n def rake(self):\n return self._rake\n\n @rake.setter\n def rake(self, value):\n value = ((value + 180) % 360) - 180\n self._set_rake(value)\n\n def _set_rake(self, value):\n self._rake = value\n\n @property\n def dip(self):\n return self._dip\n\n @dip.setter\n def dip(self, value):\n if 90 < value < 180:\n self.strike = self.strike + 180\n self.rake = -self.rake\n value = 180 - value\n elif value < 0 or value > 180:\n # The fault is now above ground\n raise ValueError(f\"Invalid dip value: {value}\")\n\n self._set_dip(value)\n\n def _set_dip(self, value):\n self._dip = value\n\n\nclass SinglePlaneFault(Fault):\n def __init__(self, name, magnitude, strike, rake, dip):\n self.name = name\n self._mag = magnitude\n self._strike = strike\n self._rake = rake\n self._dip = dip\n\n _length: float = None\n _width: float = None\n _dtop: float = None\n _dbottom: float = None\n\n @property\n def strike(self):\n return self._strike\n\n @strike.setter\n def strike(self, value):\n self._strike = value % 360\n\n @property\n def dhypo(self):\n return self.width / 2\n\n @property\n def dbottom(self):\n return self._dbottom\n\n @property\n def dtop(self):\n return self._dtop\n\n @property\n def hypocentre_lonlat(self):\n return self._longitude, self._latitude\n\n\nclass MultiPlaneFault(Fault):\n pass\n\n\nclass PointSourceFault(SinglePlaneFault):\n\n type = 1\n\n # vs = 3.2\n # rh0 = 2.44\n # risetime = 0.5\n # stype = \"cos\"\n # inittime = 0.0\n vs = None\n rh0 = None\n risetime = None\n stype = None\n inittime = None\n\n def __init__(self, name, latitude, longitude, magnitude, strike, rake, dip, depth):\n self._depth = depth\n self._latitude = latitude\n self._longitude = longitude\n super().__init__(name, magnitude, strike, rake, dip)\n\n @property\n def dbottom(self):\n return self._depth\n\n def to_dict(self):\n base_dict = super().to_dict()\n base_dict.update({\"type\": 1})\n if self.vs is not None:\n base_dict[\"vs\"] = self.vs\n if self.rh0 is not None:\n base_dict[\"rho\"] = self.rh0\n if self.risetime is not None:\n base_dict[\"risetime\"] = self.risetime\n if self.stype is not None:\n base_dict[\"stype\"] = self.stype\n if self.inittime is not None:\n base_dict[\"inittime\"] = self.inittime\n return base_dict\n\n\nType1 = PointSourceFault\n\n\nclass FiniteFault(SinglePlaneFault):\n\n dlen = 0.1\n dwid = 0.1\n shypo = 0.00\n depths = None\n\n def to_dict(self):\n base_dict: dict = super().to_dict()\n base_dict.update(\n {\n \"flen\": self.length,\n \"dlen\": self.dlen,\n \"fwid\": self.width,\n \"dwid\": self.dwid,\n \"dtop\": self.dtop,\n \"shypo\": self.shypo,\n \"dhypo\": self.dhypo,\n }\n )\n return base_dict\n\n\nclass Type2(FiniteFault):\n\n type = 2\n\n _ratio_override: Union[float, None] = None\n _magnitude_scaling_relation: MagnitudeScalingRelations = None\n\n def __init__(self, name, latitude, longitude, magnitude, strike, rake, dip, depth):\n self._depth = depth\n self._latitude = latitude\n self._longitude = longitude\n super().__init__(name, magnitude, strike, rake, dip)\n\n def to_dict(self):\n base_dict: dict = super().to_dict()\n base_dict.update(\n {\n \"type\": 2,\n \"longitude\": self._lon_hyp,\n \"latitude\": self._lat_hyp,\n \"mwsr\": self._magnitude_scaling_relation.name,\n \"dbottom\": self.dbottom,\n }\n )\n return base_dict\n\n def _set_rake(self, value):\n self._rake = value\n if self._magnitude_scaling_relation is not None:\n self._calculate_dimensions()\n\n def set_ratio_override(self, ratio):\n self._ratio_override = ratio\n\n def reset_ratio_override(self):\n self._ratio_override = None\n\n @property\n def magnitude_scaling_relation(self):\n return self._magnitude_scaling_relation\n\n @magnitude_scaling_relation.setter\n def magnitude_scaling_relation(self, value: MagnitudeScalingRelations):\n self._magnitude_scaling_relation = value\n self._calculate_dimensions()\n\n @property\n def length(self):\n if self.magnitude_scaling_relation is None:\n raise ValueError(\"No magnitude scaling relation given\")\n\n return self._length\n\n @property\n def width(self):\n if self.magnitude_scaling_relation is None:\n raise ValueError(\"No magnitude scaling relation given\")\n\n return self._width\n\n @property\n def dhypo(self):\n return self.width / 2\n\n @property\n def dbottom(self):\n if self.magnitude_scaling_relation is None:\n raise ValueError(\"No magnitude scaling relation given\")\n return self._dbottom\n\n @property\n def dtop(self):\n if self.magnitude_scaling_relation is None:\n raise ValueError(\"No magnitude scaling relation given\")\n return self._dtop\n\n @property\n def hypocentre_lonlat(self):\n if self.magnitude_scaling_relation is None:\n raise ValueError(\"No magnitude scaling relation given\")\n return self._lon_hyp, self._lat_hyp\n\n def _calculate_dimensions(self):\n if self.magnitude_scaling_relation is None:\n raise ValueError(\"No magnitude scaling relation given\")\n\n area = get_area(self)\n length = get_length(self)\n width = get_width(self)\n\n if self._ratio_override is not None:\n r = self._ratio_override\n else:\n r = max(length / width, 1)\n\n self._width = np.sqrt(area / r)\n self._length = r * np.sqrt(area / r)\n\n self._dtop = self._depth - np.sin(np.radians(self._dip)) * self.width / 2\n shift = min(self._dtop, 0)\n if shift != 0:\n self._dtop = 0\n self._dbottom = (\n self._depth + np.sin(np.radians(self._dip)) * self.width / 2 + shift\n )\n if (\n self.magnitude_scaling_relation == MagnitudeScalingRelations.LEONARD2014\n and self._dbottom > NHM_SEISMOGENIC_DEPTH\n ):\n self._dbottom += LEONARD_SEISMOGENIC_DEPTH_DIFFERENCE\n\n self.ny = int(round(self.width / self.dwid))\n self.nx = int(round(self.length / self.dlen))\n self.dlen = self.length / float(self.nx)\n self.dwid = self.width / float(self.ny)\n\n # self._calculate_finite_fault_properties()\n # self._calculate_corners()\n self._get_hypocentre(0, -self.dhypo)\n\n def _get_hypocentre(self, shypo, dhypo):\n \"\"\"\n Same logic as corners, for a single point.\n \"\"\"\n if self.magnitude_scaling_relation is None:\n raise ValueError(\"No magnitude scaling relation given\")\n ONE_DEG_LAT = np.radians(6371.0072)\n azimuth = np.radians(self.strike - 90)\n rot_matrix = np.array(\n [[np.cos(azimuth), np.sin(azimuth)], [-np.sin(azimuth), np.cos(azimuth)]]\n )\n\n y_pos_surf_proj_hyp = -dhypo * np.cos(np.radians(self._dip))\n hypocentre_points = np.dot(rot_matrix, [[shypo], [y_pos_surf_proj_hyp]])\n\n self._lat_hyp = self.latitude + hypocentre_points[1][0] / ONE_DEG_LAT\n self._lon_hyp = self.longitude + (\n hypocentre_points[0][0] / ONE_DEG_LAT\n ) / np.cos(np.radians(self.latitude))\n\n def _calculate_corners(self):\n # use cartesian coordinate system to define the along strike and downdip\n # locations taking the center of the fault plane as (x,y)=(0,0)\n if self.magnitude_scaling_relation is None:\n raise ValueError(\"No magnitude scaling relation given\")\n ONE_DEG_LAT = np.radians(6371.0072)\n\n x_pos = np.arange(self.dlen / 2.0, self.length, self.dlen) - self.length / 2.0\n y_pos = (\n np.arange(self.dwid / 2.0, self.width, self.dwid)[::-1] - self.width / 2.0\n )\n\n # now use a coordinate transformation to go from fault plane to North and\n # East cartesian plane (again with (0,0) ==(0,0) )\n y_pos_surf_proj = y_pos * np.cos(np.radians(self._dip))\n azimuth = np.radians(self.strike - 90)\n rot_matrix = np.array(\n [[np.cos(azimuth), np.sin(azimuth)], [-np.sin(azimuth), np.cos(azimuth)]]\n )\n east_loc_relative, north_loc_relative = np.dot(\n rot_matrix, [np.tile(x_pos, self.ny), y_pos_surf_proj.repeat(self.nx)]\n ).reshape((2, self.nx, self.ny))\n # now use a coordinate transformation to go from the North East cartesian\n # plane to the spherical earth WGS84 coordinate system\n self.lats = self.latitude + north_loc_relative / ONE_DEG_LAT\n self.lons = self.longitude + (east_loc_relative / ONE_DEG_LAT) * 1 / np.cos(\n np.radians(self.latitude)\n )\n\n def _calculate_finite_fault_properties(self):\n \"\"\"\n Purpose: To create a finite fault geometry based on centroid moment tensor\n solution information and magnitude scaling relationships.\n The use of such finite fault geometry is for first order computation of\n source-to-site distances.\n\n revisions\n v2 - reoriented fault plane to be consistent with along strike direction\n v3 - added 'argout_emod3d' output and associated commands to output details\n which are input in the finite fault model generation for EMOD3D graves methodology\n\n assumptions:\n 1) The centroid moment tensor represents the centroid of the fault plane,\n located half way along strike and downdip\n 2) The fault area is computed from the median of a Moment scaling\n relationship and thus is assumed to be a 'typical' stress drop event for\n the Mw-relationship used.\n Should only be used for small events where the downdip width is smaller\n than the seismogenic depth (i.e. so the assumption of a square fault plane\n is reasonable); depth is reset to zero if above ground values determined\n 3) srike in deg measured clockwise from N; rake in deg measured\n anti-clockwise from the strike direction (and in the range\n -180 self.depths):\n raise ValueError(\n \"Some points are above the ground. This represents a logic problem and should be referred to the \"\n \"developers.\"\n )\n\n\nclass Type3(FiniteFault):\n def __init__(\n self,\n name,\n magnitude,\n lon1,\n lat1,\n lon2,\n lat2,\n dip,\n rake,\n dtop,\n dbottom,\n dip_dir,\n tectonic_type,\n ):\n self._trace = ((lon1, lat1), (lon2, lat2))\n self._dtop = dtop\n self._dbottom = dbottom\n self._dip_dir = dip_dir\n\n self._length = round_subfault_size(\n geo.ll_dist(lon1, lat1, lon2, lat2), magnitude\n )\n\n if tectonic_type == \"SUBDUCTION_INTERFACE\":\n self.mwsr = MagnitudeScalingRelations.SKARLATOUDIS2016\n\n else:\n self.mwsr = MagnitudeScalingRelations.LEONARD2014\n self._dbottom += 3\n\n raw_fwid = (self._dbottom - dtop) / np.sin(np.radians(dip))\n self._width = round_subfault_size(raw_fwid, magnitude)\n\n strike = geo.ll_bearing(lon1, lat1, lon2, lat2)\n\n if (self._dip_dir - strike + 360) % 360 > 180:\n # Reverse the order of the points so the dipdir is to the right of the strike\n self._trace = self._trace[::-1]\n strike = geo.ll_bearing(lon2, lat2, lon1, lat1)\n\n super().__init__(name, magnitude, strike, rake, dip)\n\n def to_dict(self):\n base_dict = {\n \"clon\": geo.ll_mid(*self._trace[0], *self._trace[1])[0],\n \"clat\": geo.ll_mid(*self._trace[0], *self._trace[1])[1],\n \"type\": self.type,\n \"magnitude\": self._mag,\n \"moment\": self.mom,\n \"name\": self.name,\n \"strike\": self._strike,\n \"rake\": self._rake,\n \"dip\": self._dip,\n \"dtop\": self._dtop,\n \"dbottom\": self._dbottom,\n \"length\": self._length,\n \"width\": self._width,\n \"dip_dir\": self._dip_dir,\n }\n return base_dict\n\n\nclass Type4(MultiPlaneFault):\n\n type = 4\n\n def __init__(self, nhm_data: NHMFault):\n self.name = nhm_data.name\n self._dbottom = nhm_data.dbottom\n self.fault_type = nhm_data.fault_type\n self.tectonic_type = nhm_data.tectonic_type\n self._dip = nhm_data.dip\n self._rake = nhm_data.rake\n self._dtop = nhm_data.dtop\n self._slip_rate = nhm_data.slip_rate\n self._dip_dir = nhm_data.dip_dir\n\n self._n_planes = len(nhm_data.trace) - 1\n\n if nhm_data.tectonic_type == \"SUBDUCTION_INTERFACE\":\n self.mwsr = MagnitudeScalingRelations.SKARLATOUDIS2016\n\n else:\n self.mwsr = MagnitudeScalingRelations.LEONARD2014\n self._dbottom += 3\n\n dummy_plane = Type3(\n nhm_data.name,\n nhm_data.mw,\n *nhm_data.trace[0],\n *nhm_data.trace[1],\n nhm_data.dip,\n nhm_data.rake,\n nhm_data.dtop,\n nhm_data.dbottom,\n nhm_data.dip_dir,\n nhm_data.tectonic_type,\n )\n\n length = sum(\n [\n geo.ll_dist(*nhm_data.trace[i], *nhm_data.trace[i + 1])\n for i in range(self._n_planes)\n ]\n )\n\n self._mag = lw_to_mw_scaling_relation(\n length, dummy_plane.width, self.mwsr, nhm_data.rake\n )\n\n if dummy_plane.strike != geo.ll_bearing(*nhm_data.trace[0], *nhm_data.trace[1]):\n nhm_data.trace = nhm_data.trace[::-1]\n\n self._planes = []\n for i in range(self._n_planes):\n self._planes.append(\n Type3(\n nhm_data.name,\n self._mag,\n *nhm_data.trace[i],\n *nhm_data.trace[i + 1],\n nhm_data.dip,\n nhm_data.rake,\n nhm_data.dtop,\n nhm_data.dbottom,\n nhm_data.dip_dir,\n nhm_data.tectonic_type,\n )\n )\n\n @property\n def length(self):\n return sum([f.length for f in self._planes])\n\n @property\n def width(self):\n return self._planes[0].width\n\n @property\n def dhypo(self):\n return self._dhypo\n\n @dhypo.setter\n def dhypo(self, dhypo):\n if dhypo > self.width:\n raise ValueError(\n f\"Cannot place hypocentre outside fault plane. dhpyo: {dhypo}, fault width: {self.width}\"\n )\n self._dhypo = dhypo\n for sub_plane in self._planes:\n sub_plane._dhypo = dhypo\n\n @property\n def shypo(self):\n return self._shypo\n\n @shypo.setter\n def shypo(self, shypo):\n if shypo > self.length:\n raise ValueError(\n f\"Cannot place hypocentre outside fault plane. shpyo: {shypo}, fault length: {self.length}\"\n )\n self._shypo = shypo\n for sub_plane in self._planes:\n sub_plane._shypo = shypo\n\n def to_dict(self):\n\n base_dict = {\n \"type\": self.type,\n \"magnitude\": self._mag,\n \"moment\": self.mom,\n \"name\": self.name,\n \"fault_type\": self.fault_type,\n \"tect_type\": self.tectonic_type,\n \"rake\": self._rake,\n \"dip\": self._dip,\n \"dtop\": self._dtop,\n \"dbottom\": self._dbottom,\n \"length\": self.length,\n \"plane_count\": self._n_planes,\n \"slip_rate\": self._slip_rate,\n \"dip_dir\": self._dip_dir,\n \"shypo\": self.shypo,\n \"dhypo\": self.dhypo,\n }\n for i, sub_fault in enumerate(self._planes):\n for key, item in sub_fault.to_dict().items():\n base_dict[f\"{key}_subfault_{i}\"] = item\n return base_dict\n\n @property\n def trace(self):\n points = [x._trace[0] for x in self._planes]\n points.append(self._planes[-1]._trace[1])\n return np.asarray(points)\n\n @trace.setter\n def trace(self, values):\n for i in range(self._n_planes):\n sub_plane = self._planes[i]\n sub_plane._trace = (tuple(values[i]), tuple(values[i + 1]))\n\n @property\n def dtop(self):\n return self._dtop\n\n @dtop.setter\n def dtop(self, value):\n if value < 0:\n raise ValueError(\"dtop must be below ground level\")\n self._dtop = value\n\n @property\n def dbottom(self):\n return self._dbottom\n\n @dbottom.setter\n def dbottom(self, value):\n if value < 0:\n raise ValueError(\"dtop must be below ground level\")\n self._dbottom = value\n\n @property\n def dip_dir(self):\n return self._dip_dir\n\n @dip_dir.setter\n def dip_dir(self, value):\n self._dip_dir = value\n\n def _set_dip(self, value):\n for sub_fault in self._planes:\n sub_fault.dip = value\n self._dip = value\n\n @property\n def strike(self):\n return np.asarray([x.strike for x in self._planes])\n\n @strike.setter\n def strike(self, values):\n for i in range(self._n_planes):\n self._planes[i].strike = values[i]\n", "meta": {"hexsha": "a1535ba59581f83b8c60257888a2db33c4222cc5", "size": 21376, "ext": "py", "lang": "Python", "max_stars_repo_path": "srf_generation/Fault.py", "max_stars_repo_name": "ucgmsim/Pre-processing", "max_stars_repo_head_hexsha": "c4b9ae20a9e5e4f96f930bde29aa15176d9c8b64", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-10-01T10:36:09.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-01T10:36:09.000Z", "max_issues_repo_path": "srf_generation/Fault.py", "max_issues_repo_name": "ucgmsim/Pre-processing", "max_issues_repo_head_hexsha": "c4b9ae20a9e5e4f96f930bde29aa15176d9c8b64", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 38, "max_issues_repo_issues_event_min_datetime": "2018-08-01T04:25:24.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-08T23:37:53.000Z", "max_forks_repo_path": "srf_generation/Fault.py", "max_forks_repo_name": "ucgmsim/Pre-processing", "max_forks_repo_head_hexsha": "c4b9ae20a9e5e4f96f930bde29aa15176d9c8b64", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-10-17T21:44:14.000Z", "max_forks_repo_forks_event_max_datetime": "2019-10-17T21:44:14.000Z", "avg_line_length": 29.4030261348, "max_line_length": 114, "alphanum_fraction": 0.5840194611, "include": true, "reason": "import numpy", "num_tokens": 5338, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.603931819468636, "lm_q2_score": 0.3140505514119072, "lm_q1q2_score": 0.18966512091932153}} {"text": "#!/usr/bin/python3\n#\n##########################################################################################################################\n# #\n# What follows are options of the PP-STM code for calculating inner PDOS #\n# #\n##########################################################################################################################\n#\n# Note : This type of simulations works for solid slabs or molecules on slabs (substrate) ; for freestanding molecule it can give you nonsences\n#\n# ***** System information: *****\n#\nppstm_path = './PPSTM/' # path (absolute or relative) to your PPSTM code #\n#\n# ***** Main informations ******\n#\nV_min = -2.0 # V_min for plotting \nV_max = +2.0 # V_max for plotting #\neta = 0.1 # Lorentzian width of states in energy scale: typically 0.1; can be in range of 0.3-0.05 eV in some cases (low amount of layers ...) even up to 1.0 eV #\ndV = eta/5.0 # voltage/energy step , default : eta/5.0 #\nsample_orbs = 'spd' # orbitals of the sample 'sp' (light atoms only, faster) or 'spd' (all atoms) #\ndft_code = 'AIMS' # 'fireball'='Fireball'='FIREBALL' ; 'aims'='AIMS'='FHI-AIMS' ; 'cp2k'='CP2K' ; 'gpaw'='GPAW' #\ngeometry_file = 'geom-cube.in' # E.G. 'input.xyz' , 'input.bas' , 'geometry.in'; None for GPAW #\nspin = 'both' # None=False ; for FHI-AIMS & CP2K: None -- spin-unpolarized/spin-restricted calc. ; 'both'-- up will be plotted as + and down as - , 'up'='alpha' or 'down\"='beta' (last 3 are for spin-polarizes or spin-unrestricted calculations) #\ncp2k_name = 'FePc' # Name used in CP2K calculations or GPAW calc #\n#\n# *****Plotting options ******\n#\nred_line_atoms = [0] # atoms to plot: !!! DO NOT FORGET PYTHON NUMBERING starts from 0 !!!, always use list-like structure; 'all' = -1 -- all atoms; [0] -- means 1st atom #\nred_line_shell = 'dz2' # which chells to plot: 'all' = all sample orbitals, 's', 'p', 'd', 'px', 'py', 'pz', 'dxy', 'dyz', 'dyz', 'dz2', 'dxz', 'dx2y2' #\n#\nblue_line_atoms = [0,1] # atoms to plot: !!! DO NOT FORGET PYTHON NUMBERING starts from 0 !!!, always use list-like structure; 'all' = -1 -- all atoms; [1] -- means 2nd atom #\nblue_line_shell = 'all' # which chells to plot: 'all' = all sample orbitals, 's', 'p', 'd', 'px', 'py', 'pz', 'dxy', 'dyz', 'dyz', 'dz2', 'dxz', 'dx2y2' #\n#\ngreen_line_atoms = [0] # atoms to plot: !!! DO NOT FORGET PYTHON NUMBERING starts from 0 !!!, always use list-like structure; 'all' = -1 -- all atoms; range(2,8) = [2,3,4,5,6,7]-- means atoms: 3,4,5,6,7 and 8 #\ngreen_line_shell = 'all' # which chells to plot: 'all' = all sample orbitals, 's', 'p', 'd', 'px', 'py', 'pz', 'dxy', 'dyz', 'dyz', 'dz2', 'dxz', 'dx2y2' #\n#\norange_line_atoms = list(range(1,57)) # atoms to plot: !!! DO NOT FORGET PYTHON NUMBERING starts from 0 !!!, always use list-like structure; 'all' = -1 -- all atoms; [8,9] -- means 9th and 10th atom #\norange_line_shell = 'pz' # which chells to plot: 'all' = all sample orbitals, 's', 'p', 'd', 'px', 'py', 'pz', 'dxy', 'dyz', 'dyz', 'dz2', 'dxz', 'dx2y2' #\n#\nblack_line_atoms = list(range(1,57)) # atoms to plot: !!! DO NOT FORGET PYTHON NUMBERING starts from 0 !!!, always use list-like structure; 'all' = -1 -- all atoms; None -- no line #\nblack_line_shell = 'all' # which chells to plot: 'all' = all sample orbitals, 's', 'p', 'd', 'px', 'py', 'pz', 'dxy', 'dyz', 'dyz', 'dz2', 'dxz', 'dx2y2' #\n#\nyellow_line_atoms = None # atoms to plot: !!! DO NOT FORGET PYTHON NUMBERING starts from 0 !!!, always use list-like structure; 'all' = -1 -- all atoms; None -- no line #\nyellow_line_shell = 'all' # which chells to plot: 'all' = all sample orbitals, 's', 'p', 'd', 'px', 'py', 'pz', 'dxy', 'dyz', 'dyz', 'dz2', 'dxz', 'dx2y2' #\n#\ngray_line_atoms = None # atoms to plot: !!! DO NOT FORGET PYTHON NUMBERING starts from 0 !!!, always use list-like structure; 'all' = -1 -- all atoms; None -- no line #\ngray_line_shell = 'all' # which chells to plot: 'all' = all sample orbitals, 's', 'p', 'd', 'px', 'py', 'pz', 'dxy', 'dyz', 'dyz', 'dz2', 'dxz', 'dx2y2' #\n#\n# *****Output options ******\n#\nPNG = True # True / False -- plot \"png\" images (2D graph height) #\nTXT = False # **** Not working yet *** True / False -- write \".txt\" files with 1st column energy, other columns PDOS#\n#\n# ***** Advanced options ******\n#\ncut_atoms = None # Not really neccessary for these calculations, unless really big files and memory; None = -1 -- All atoms of the sample contributes to tunelling ; 1 -- only 1st atom of the sample contributes to the tunelling ; 57 -- first 57 atoms of the sample contributes to the tunelling ; ... #\n#\n# ***** More advanced options ******\n#\nfermi = None # None=0.0 -- no change to the Fermi Level ; -0.1 -- shifts the Fermi Level by 0.1 eV lower ... #\ncut_min = V_min-3*eta # cut out all orbitals lower than -default: V_min-3*eta bellow Fermi (should be: cut_min <= Vmin-2*eta) . taken to the Fermi Level #\ncut_max = V_max+3*eta # cut out all orbitals higher than -default: V_max+3*eta above Fermi (should be: cut_max >= Vmax+2*eta) . taken to the Fermi Level #\nfiles_path = '' # where are files fron DFT code ; rather do not use this #\nlower_atoms = 'no-d-rescalling' # normally d-orbs are rescalled by factor of 0.2 #\n#\n#\n##########################################################################################################################\n# #\n# DO NOT TOUCH LATER CODE (unless you know what you are doing) #\n# #\n##########################################################################################################################\n\nprint(\"Importing libraries\")\n\nimport os\nimport sys\nsys.path.append(ppstm_path) \n\nimport numpy as np\n#import pyPPSTM as PS\nimport pyPPSTM.ReadSTM as RS\nimport pyPPSTM.PreSTMutils as SU\nimport matplotlib\nmatplotlib.use('Agg') # Force matplotlib to not use any Xwindows backend. ## !!! important for working on clusters !!!!\nimport matplotlib.pyplot as plt\nfrom matplotlib.font_manager import FontProperties\n#if (plot_atoms):\n# import pyPPSTM.basUtils as Bu\n# import pyPPSTM.elements as elements\n\n\nprint(\"Libraries imported\")\n\n# --- some function definition --- #\n\ndef printf(*args):\n together = ''.join(map(str, args)) # avoid the arg is not str\n #print together\n return together\n\n# --- Initial check --- #\n\nassert( PNG or TXT ), \"No output set to be True; I'm not going to do anything if there is no output. I'm too lazy like a Gartfield. \"\n\n# --- reading of the eigen-energies, the LCAO coefficients and geometry --- #\n\nprint(\"Reading electronic & geometry structure files\")\n\ncell=[[0,0],[0,0]];pbc=(0,0);lower_coefs=[];\n\nif ((dft_code == 'fireball') or(dft_code == 'Fireball') or (dft_code == 'FIREBALL')):\n eigEn, coefs, Ratin = RS.read_FIREBALL_all(name = files_path + 'phik_0001_', geom=files_path+geometry_file, lvs = cell, fermi=fermi, orbs = sample_orbs, pbc=pbc, cut_min=cut_min, cut_max=cut_max,cut_at=cut_atoms, lower_atoms=lower_atoms, lower_coefs=lower_coefs);\n\nelif ((dft_code == 'gpaw') or(dft_code == 'GPAW')):\n eigEn, coefs, Ratin = RS.read_GPAW_all( name = files_path + cp2k_name + '.gpw', fermi=fermi, orbs = sample_orbs, pbc=pbc, cut_min=cut_min, cut_max=cut_max, cut_at=cut_atoms, lower_atoms=lower_atoms, lower_coefs=lower_coefs);\n\nelif ((dft_code == 'aims') or(dft_code == 'AIMS') or (dft_code == 'FHI-AIMS')):\n if ((spin == None) or (spin == False)):\n name = 'KS_eigenvectors.band_1.kpt_1.out'\n elif ((spin == 'up')or(spin == 'alpha')or(spin == 'both')):\n name = 'KS_eigenvectors_up.band_1.kpt_1.out'\n elif ((spin == 'down')or(spin == 'beta')or(spin == 'dn')):\n name = 'KS_eigenvectors_dn.band_1.kpt_1.out'\n else :\n print(\"unknown spin, I'm going to sleep. Good Night\"); exit()\n eigEn, coefs, Ratin = RS.read_AIMS_all(name = files_path + name , geom= files_path + geometry_file, fermi=fermi, orbs = sample_orbs, pbc=pbc, cut_min=cut_min, cut_max=cut_max, cut_at=cut_atoms, lower_atoms=lower_atoms, lower_coefs=lower_coefs);\n if (spin == 'both'):\n name = 'KS_eigenvectors_dn.band_1.kpt_1.out'\n eigEn2, coefs2, Ratin = RS.read_AIMS_all(name = files_path + name , geom= files_path + geometry_file, fermi=fermi, orbs = sample_orbs, pbc=pbc, cut_min=cut_min, cut_max=cut_max, cut_at=cut_atoms, lower_atoms=lower_atoms, lower_coefs=lower_coefs);\n #coefs2 *= -1;\n\nelif ((dft_code == 'cp2k') or(dft_code == 'CP2K')):\n if ((spin == None)or(spin == False)):\n eigEn, coefs, Ratin = RS.read_CP2K_all(name = files_path + cp2k_name , lvs=cell, fermi=fermi, orbs = sample_orbs, pbc=pbc, cut_min=cut_min, cut_max=cut_max, cut_at=cut_atoms, lower_atoms=lower_atoms, lower_coefs=lower_coefs);\n elif ((spin == 'up')or(spin == 'alpha')):\n eigEn, coefs, Ratin = RS.read_CP2K_all(name = files_path + cp2k_name , lvs=cell, fermi=fermi, orbs = sample_orbs, pbc=pbc, cut_min=cut_min, cut_max=cut_max, cut_at=cut_atoms, lower_atoms=lower_atoms, lower_coefs=lower_coefs, spin='alpha');\n elif (spin == 'both'):\n eigEn, coefs, Ratin = RS.read_CP2K_all(name = files_path + cp2k_name , lvs=cell, fermi=fermi, orbs = sample_orbs, pbc=pbc, cut_min=cut_min, cut_max=cut_max, cut_at=cut_atoms, lower_atoms=lower_atoms, lower_coefs=lower_coefs, spin='alpha');\n eigEn2, coefs2, Ratin = RS.read_CP2K_all(name = files_path + cp2k_name , lvs=cell, fermi=fermi, orbs = sample_orbs, pbc=pbc, cut_min=cut_min, cut_max=cut_max, cut_at=cut_atoms, lower_atoms=lower_atoms, lower_coefs=lower_coefs, spin='beta');\n #coefs2 *= -1;\n elif ((spin == 'down')or(spin == 'beta')or(spin == 'dn')):\n eigEn, coefs, Ratin = RS.read_CP2K_all(name = files_path + cp2k_name , lvs=cell, fermi=fermi, orbs = sample_orbs, pbc=pbc, cut_min=cut_min, cut_max=cut_max, cut_at=cut_atoms, lower_atoms=lower_atoms, lower_coefs=lower_coefs, spin='beta');\n else :\n print(\"unknown spin, I'm going to sleep. Good Night\"); exit()\n\n#print \"DEBUG: eigEn.shape \", eigEn.shape\n#print \"DEBUG: coefs.shape \", coefs.shape\n#print \"DEBUG: Ratin.shape \", Ratin.shape\n\nenergies = np.arange(V_min,V_max,dV)\n\nprint(\"energies prepared, coeffecients read\")\n\n# --- the PDOS calculations --- #\n\nplot = True if ( (red_line_atoms != None)or(blue_line_atoms != None)or(green_line_atoms != None)or(orange_line_atoms != None)or(black_line_atoms != None)or(yellow_line_atoms != None)or (gray_line_atoms != None) ) else False\n\nprint(\"DEBUG: plot\", plot)\n\nassert plot!=False, \"No lines to plot\"\n\nlatomslegend = 4\n\nif (red_line_atoms != None) :\n atoms=red_line_atoms\n PDOS1 = SU.pPDOS(eigEn,coefs, energies, eta=eta, orbs= sample_orbs, atoms=atoms , spherical=red_line_shell )\n red_line_legend = ','.join(map(str, atoms)) if len(atoms) < latomslegend else str(atoms[0])+\"..\"+str(atoms[-1])\n print(\"DEBUG: red_line_legend\", red_line_legend)\nelse:\t#(red_line_atoms != None) :\n PDOS1 = None\n\nif (blue_line_atoms != None) :\n atoms=blue_line_atoms\n PDOS2 = SU.pPDOS(eigEn,coefs, energies, eta=eta, orbs= sample_orbs, atoms=atoms , spherical=blue_line_shell )\n blue_line_legend = ','.join(map(str, atoms)) if len(atoms) < latomslegend else str(atoms[0])+\"..\"+str(atoms[-1])\nelse:\t#(blue_line_atoms != None) :\n PDOS2 = None\n\nif (green_line_atoms != None) :\n atoms=green_line_atoms\n PDOS3 = SU.pPDOS(eigEn,coefs, energies, eta=eta, orbs= sample_orbs, atoms=atoms , spherical=green_line_shell )\n green_line_legend = ','.join(map(str, atoms)) if len(atoms) < latomslegend else str(atoms[0])+\"..\"+str(atoms[-1])\nelse:\t#(green_line_atoms != None) :\n PDOS3 = None\n\nif (orange_line_atoms != None) :\n atoms=orange_line_atoms\n PDOS4 = SU.pPDOS(eigEn,coefs, energies, eta=eta, orbs= sample_orbs, atoms=atoms, spherical=orange_line_shell)\n orange_line_legend = ','.join(map(str, atoms)) if len(atoms) < latomslegend else str(atoms[0])+\"..\"+str(atoms[-1])\nelse:\t#(orange_line_atoms != None) :\n PDOS4 = None\n\nif (black_line_atoms != None) :\n atoms=black_line_atoms\n PDOS5 = SU.pPDOS(eigEn,coefs, energies, eta=eta, orbs= sample_orbs, atoms=atoms , spherical=black_line_shell )\n black_line_legend = ','.join(map(str, atoms)) if len(atoms) < latomslegend else str(atoms[0])+\"..\"+str(atoms[-1])\nelse:\t#(black_line_atoms != None) :\n PDOS5 = None\n\nif (yellow_line_atoms != None) :\n atoms=yellow_line_atoms\n PDOS6 = SU.pPDOS(eigEn,coefs, energies, eta=eta, orbs= sample_orbs, atoms=atoms, spherical=yellow_line_shell)\n yellow_line_legend = ','.join(map(str, atoms)) if len(atoms) < latomslegend else str(atoms[0])+\"..\"+str(atoms[-1])\nelse:\t#(yellow_line_atoms != None) :\n PDOS6 = None\n\nif (gray_line_atoms != None) :\n atoms=gray_line_atoms\n PDOS7 = SU.pPDOS(eigEn,coefs, energies, eta=eta, orbs= sample_orbs, atoms=atoms , spherical=gray_line_shell )\n gray_line_legend = ','.join(map(str, atoms)) if len(atoms) > latomslegend else str(atoms[0])+\"..\"+str(atoms[-1])\nelse:\t#(gray_line_atoms != None) :\n PDOS7 = None\n\nif spin=='both' :\n print(\"DEBUG: printing spin down in both spins\")\n\n PDOS1d = -1*SU.pPDOS(eigEn2,coefs2, energies, eta=eta, orbs= sample_orbs, atoms=red_line_atoms , spherical=red_line_shell ) if (red_line_atoms != None) else None\n PDOS2d = -1*SU.pPDOS(eigEn2,coefs2, energies, eta=eta, orbs= sample_orbs, atoms=blue_line_atoms , spherical=blue_line_shell ) if (blue_line_atoms != None) else None\n PDOS3d = -1*SU.pPDOS(eigEn2,coefs2, energies, eta=eta, orbs= sample_orbs, atoms=green_line_atoms , spherical=green_line_shell ) if (green_line_atoms != None) else None\n PDOS4d = -1*SU.pPDOS(eigEn2,coefs2, energies, eta=eta, orbs= sample_orbs, atoms=orange_line_atoms, spherical=orange_line_shell) if (orange_line_atoms != None) else None\n PDOS5d = -1*SU.pPDOS(eigEn2,coefs2, energies, eta=eta, orbs= sample_orbs, atoms=black_line_atoms , spherical=black_line_shell ) if (black_line_atoms != None) else None\n PDOS6d = -1*SU.pPDOS(eigEn2,coefs2, energies, eta=eta, orbs= sample_orbs, atoms=yellow_line_atoms, spherical=yellow_line_shell) if (yellow_line_atoms != None) else None\n PDOS7d = -1*SU.pPDOS(eigEn2,coefs2, energies, eta=eta, orbs= sample_orbs, atoms=gray_line_atoms , spherical=gray_line_shell ) if (gray_line_atoms != None) else None\n\nelse: \n print(\"DEBUG: both spins are not used\")\n PDOS1d = PDOS2d = PDOS3d = PDOS4d = PDOS5d = PDOS6d = PDOS7d = None\n\n# --- plotting part here, plots all calculated signals --- #\n\nif PDOS1 is not None:\n plt.plot(energies, PDOS1, ls='-',c='r' ,label= 'PDOS atoms:'+red_line_legend+\";\"+red_line_shell+\"-shell\")\nif PDOS2 is not None:\n plt.plot(energies, PDOS2, ls='-',c='g' ,label= 'PDOS atoms:'+blue_line_legend+\";\"+blue_line_shell+\"-shell\")\nif PDOS3 is not None:\n plt.plot(energies, PDOS3, ls='-',c='b' ,label= 'PDOS atoms:'+green_line_legend+\";\"+green_line_shell+\"-shell\")\nif PDOS4 is not None:\n plt.plot(energies, PDOS4, ls='-',c='#FFA500',label= 'PDOS atoms:'+orange_line_legend+\";\"+orange_line_shell+\"-shell\")\nif PDOS5 is not None:\n plt.plot(energies, PDOS5, ls='-',c='k' ,label= 'PDOS atoms:'+black_line_legend+\";\"+black_line_shell+\"-shell\")\nif PDOS6 is not None:\n plt.plot(energies, PDOS6, ls='-',c='y' ,label= 'PDOS atoms:'+yellow_line_legend+\";\"+yellow_line_shell+\"-shell\")\nif PDOS7 is not None:\n plt.plot(energies, PDOS7, ls='-',c='g' ,label= 'PDOS atoms:'+gray_line_legend+\";\"+gray_line_shell+\"-shell\")\n\n# spin down if \"both\"\nif PDOS1d is not None:\n plt.plot(energies, PDOS1d, ls='--',c='r')#,label= 'PDOS atoms:'+str(red_line_atoms)+\";\"+red_line_shell+\"shell\")\nif PDOS2d is not None:\n plt.plot(energies, PDOS2d, ls='--',c='g')#,label= 'PDOS atoms:'+str(blue_line_atoms)+\";\"+red_line_shell+\"shell\")\nif PDOS3d is not None:\n plt.plot(energies, PDOS3d, ls='--',c='b')#,label= 'PDOS atoms:'+str(green_line_atoms)+\";\"+red_line_shell+\"shell\")\nif PDOS4d is not None:\n plt.plot(energies, PDOS4d, ls='--',c='#FFA500')#,label= 'PDOS atoms:'+str(orange_line_atoms)+\";\"+red_line_shell+\"shell\")\nif PDOS5d is not None:\n plt.plot(energies, PDOS5d, ls='--',c='k')#,label= 'PDOS atoms:'+str(red_line_atoms)+\";\"+red_line_shell+\"shell\")\nif PDOS6d is not None:\n plt.plot(energies, PDOS6d, ls='--',c='y')#,label= 'PDOS atoms:'+str(red_line_atoms)+\";\"+red_line_shell+\"shell\")\nif PDOS7d is not None:\n plt.plot(energies, PDOS7d, ls='--',c='g')#,label= 'PDOS atoms:'+str(red_line_atoms)+\";\"+red_line_shell+\"shell\")\n\nif (plot and PNG) :\n plt.title(\"PDOS eta: \"+str(eta)+' eV')\n plt.xlabel(\"E-Efermi [eV]\")\n plt.ylabel(\"DOS [arb.un]\")\n plt.legend(loc='center left',bbox_to_anchor=(1,0.5))\n plt.savefig('PDOS_eta_'+str(eta)+'eV_orbs_'+sample_orbs+'.png', bbox_inches='tight')\n\n\n# --- the end --- #\n\nprint() \nprint()\nprint(\"Done\")\nprint()\n\n", "meta": {"hexsha": "0a6025bc2d43b29d7e05b9943c7026ad941e00e7", "size": 17539, "ext": "py", "lang": "Python", "max_stars_repo_path": "tests/FePc_Au/PPdos_simple.py", "max_stars_repo_name": "Probe-Particle/PPSTM", "max_stars_repo_head_hexsha": "4434739bd737e58a2fc556dff24e8e7d6eab084e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "tests/FePc_Au/PPdos_simple.py", "max_issues_repo_name": "Probe-Particle/PPSTM", "max_issues_repo_head_hexsha": "4434739bd737e58a2fc556dff24e8e7d6eab084e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "tests/FePc_Au/PPdos_simple.py", "max_forks_repo_name": "Probe-Particle/PPSTM", "max_forks_repo_head_hexsha": "4434739bd737e58a2fc556dff24e8e7d6eab084e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 63.0899280576, "max_line_length": 312, "alphanum_fraction": 0.6220993215, "include": true, "reason": "import numpy", "num_tokens": 5348, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6513548646660542, "lm_q2_score": 0.2909808785120009, "lm_q1q2_score": 0.1895318107435939}} {"text": "\nimport numpy as np\nimport numpy.random as npr\nimport time#, timer\nfrom . import gelmanrubin as gr\n#reload(gr)\n#import python_models as mc\n#import models_c as mc\nimport multiprocessing as mp\n\n\ndef calcModel(nchains, functype, myfuncs, pedit, nextp, iortholist, funcx, cummodels, numparams, j, iblock=None, chains=None):\n '''\n Compute model light curve by combining model components. Also returns correlated noise parameters.\n '''\n #Build final model from model components\n ymodels = np.ones((nchains, fit[j].nobj))\n noisepars = [[] for i in range(nchains)]\n k = 0\n if chains == None:\n chains = range(nchains)\n if iblock == None:\n iblock = range(cummodels[j],cummodels[j+1])\n for i in range(cummodels[j],cummodels[j+1]):\n if iblock.__contains__(i):\n for n in chains:\n if functype[i] == 'ortho':\n #MODIFY COPY OF nextp ONLY\n pedit[n,iortholist] = myfuncs[i](pedit[n,iortholist], funcx[i], fit[j].etc[k])\n elif (functype[i] == 'ipmap') or (functype[i] == 'spline'):\n ymodels[n] *= myfuncs[i](pedit[n,numparams[i]:numparams[i+1]], funcx[i], ymodels[n])\n elif functype[i] == 'posoffset':\n # Record change in Position 0 => cannot orthogonalize position parameters\n ymodels[n] *= myfuncs[i](nextp[n,numparams[i]:numparams[i+1]], funcx[i], fit[j].etc[k])\n elif hasattr(fit[j], 'timebins') and (functype[i] == 'ecl/tr'\n or functype[i] == 'ramp'\n or functype[i] == 'sinusoidal'):\n # Average over high-resolution model\n hiresmodel = myfuncs[i](pedit[n,numparams[i]:numparams[i+1]], funcx[i], fit[j].etc[k])\n if len(fit[j].timebins) == fit[j].nobj:\n for tb in range(len(fit[j].timebins)):\n ymodels[n,tb] *= np.mean(hiresmodel[fit[j].timebins[tb]])\n else:\n for tb in range(len(fit[j].timebinsuc)):\n ymodels[n,tb] *= np.mean(hiresmodel[fit[j].timebinsuc[tb]])\n elif functype[i] == 'noise':\n noisepars[n] = pedit[n,numparams[i]:numparams[i+1]]\n else:\n ymodels[n] *= myfuncs[i](pedit[n,numparams[i]:numparams[i+1]], funcx[i], fit[j].etc[k])\n k += 1\n return ymodels, noisepars\n\n# Calculate chi^2\ndef calcChisq(y, sigma, ymodels, nchains, nextp, j, noisepars, isrednoise, wavelet, noisefunc, chains=None):\n '''\n Compute chi-squared with priors.\n '''\n if chains == None:\n chains = range(nchains)\n chi2 = np.zeros(nchains)\n for n in chains:\n if isrednoise == False:\n #chi2[n] = mc.chisq(ymodels[n], y, sigma)\n chi2[n] += np.sum((ymodels[n] - y)**2 / sigma**2)\n else:\n chi2[n] = noisefunc(noisepars[n], ymodels[n]-y, wavelet)\n # Apply prior, if one exists\n if len(fit[j].ipriors) > 0:\n pbar = fit[j].priorvals[:,0] #prior mean\n psigma = np.zeros(len(pbar)) #prior standard deviation\n # Determine psigma based on which side of asymmetric Gaussian nextp is on\n for i in range(len(fit[j].ipriors)):\n if nextp[n,fit[j].ipriors[i]] < pbar[i]:\n psigma[i] = fit[j].priorvals[i,1]\n else:\n psigma[i] = fit[j].priorvals[i,2]\n #chi2[n] += fit[j].nobj*((nextp[n,fit[j].ipriors[i]] - pbar[i])/psigma[i])**2\n chi2[n] += ((nextp[n,fit[j].ipriors[i]] - pbar[i])/psigma[i])**2\n\n return chi2\n\ndef demc_block(y, pars, pmin, pmax, stepsize, numit, sigma, numparams, cummodels, functype, myfuncs, funcx, iortholist, fits, gamma=None, isGR=True, ncpu=1):\n \"\"\"\n This function uses a differential evolution Markov chain with block updating to assess uncertainties.\n\n PARAMETERS\n ----------\n y: Array containing dependent data\n Params: Array of initial guess for parameters\n #Pmin: Array of parameter minimum values\n #Pmax: Array of parameter maximum values\n stepsize: Array of 1-sigma change in parameter per iteration\n Numit:\t Number of iterations to perform\n Sigma:\t Standard deviation of data noise in y\n Numparams: Number of parameters for each model\n Cummodels: Cumulative number of models used\n Functype: Define function type (eclipse, ramp, ip, etc), see models.py\n Myfuncs: Pointers to model functions\n Funcx:\t Array of x-axis values for myfuncs\n fit: List of fit objects\n gamma: Multiplcation factor in parameter differential, establishes acceptance rate\n\n OUTPUTS\n -------\n This function returns an array of the best fitting parameters,\n an array of all parameters over all iterations, and numaccept.\n\n REFERENCES\n ----------\n Cajo J. F. Ter Braak, \"Genetic algorithms and Markov Chain Monte Carlo: Differential Evolution Markov Chain makes Bayesian computing easy,\" Biometrics, 2006.\n\n HISTORY\n -------\n Adapted from mcmc.py\n Kevin Stevenson, UChicago August 2012\n \"\"\"\n global fit\n fit = fits\n\n params = np.copy(pars)\n nchains, nump = params.shape\n nextp = np.copy(params) #Proposed parameters\n bestp = np.copy(params[0]) #Best-fit parameters\n pedit = np.copy(params) #Editable parameters\n\n numaccept = 0\n allparams = np.zeros((nump, nchains, numit))\n inotfixed = np.where(stepsize != 0)[0]\n ishare = np.where(stepsize < 0)[0]\n #ifree = np.where(stepsize > 0)[0]\n outside = np.zeros((nchains, nump))\n numevents = len(fit)\n intsteps = np.min((numit/5,1e5))\n isrednoise = False\n wavelet = None\n noisefunc = None\n\n #UPDATE PARAMTER(S) EQUAL TO OTHER PARAMETER(S)\n if (ishare.size > 0):\n for s in range(ishare.size):\n params[:,ishare[s]] = params[:,int(abs(stepsize[ishare[s]])-1)]\n\n #Define blocks\n blocks = []\n for j in range(numevents):\n #Build list of blocks\n blocks = np.concatenate((blocks, fit[j].blocks))\n for i in range(cummodels[j],cummodels[j+1]):\n if functype[i] == 'noise':\n # Set up for modified chi-squared calculation using correlated noise\n isrednoise = True\n wavelet = fit[j].etc[k]\n noisefunc = myfuncs[i]\n\n blocks = blocks.astype(int)\n iblocks = []\n eps = []\n numblocks = blocks.max() + 1\n numbp = np.zeros(numblocks)\n ifree = [[] for i in range(numblocks)]\n for b in range(numblocks):\n #Map block indices\n whereb = np.where(blocks == b)[0]\n iblocks.append(whereb)\n #Locate indices of free parameters in each block\n for w in whereb:\n ifree[b] = np.concatenate((ifree[b],numparams[w]+np.where(stepsize[numparams[w]:numparams[w+1]] > 0)[0])).astype(int)\n #Calculate number of free parameters per block\n numbp[b] += len(ifree[b])\n eps.append(npr.normal(0, stepsize[ifree[b]]/100., [numit,numbp[b]]))\n\n print(\"Number of free parameters per block:\")\n print(numbp)\n numa = np.zeros(numblocks)\n if gamma == None:\n gamma = 2.38/np.sqrt(2.*numbp)\n print(\"gamma:\")\n print(gamma)\n\n #Calc chi-squared for model type using current params\n currchisq = np.zeros(nchains)\n currmodel = [[] for i in range(numevents)]\n for j in range(numevents):\n currmodel[j], noisepars = calcModel(nchains, functype, myfuncs, pedit, params, iortholist[j],\n funcx, cummodels, numparams, j)\n currchisq += calcChisq(y[j], sigma[j], currmodel[j], nchains, params, j, noisepars, isrednoise, wavelet, noisefunc)\n\n bestchisq = currchisq[0]\n\n #GENERATE RANDOM NUMBERS FOR MCMC\n numnotfixed = len(inotfixed)\n unif = npr.rand(numit,nchains)\n randchains = npr.randint(0,nchains,[numit,nchains,2])\n\n #START TIMER\n clock = timer.Timer(numit,progress = np.arange(0.05,1.01,0.05))\n\n #Run Differential Evolution Monte Carlo algorithm 'numit' times\n for m in range(numit):\n #Select next event (block) to update\n b = m % numblocks\n #Remove model component(s) that are taking a step\n pedit = np.copy(params)\n nextmodel = currmodel[:]\n for j in range(numevents):\n ymodels, noisepars = calcModel(nchains, functype, myfuncs, pedit, params, iortholist[j],\n funcx, cummodels, numparams, j, iblocks[b])\n nextmodel[j] = np.divide(currmodel[j],ymodels)\n #Generate next step using differential evolution\n for n in range(nchains):\n rand1, rand2 = randchains[m,n]\n while rand1 == n or rand2 == n or rand1 == rand2:\n rand1, rand2 = npr.randint(0,nchains,2)\n nextp[n,ifree[b]] = params[n,ifree[b]] + gamma[b]*(params[rand1,ifree[b]]-params[rand2,ifree[b]]) + eps[b][m]\n #CHECK FOR NEW STEPS OUTSIDE BOUNDARIES\n ioutside = np.where(np.bitwise_or(nextp[n] < pmin, nextp[n] > pmax))[0]\n if (len(ioutside) > 0):\n nextp[n,ioutside] = np.copy(params[n,ioutside])\n outside[n,ioutside] += 1\n #UPDATE PARAMTER(S) EQUAL TO OTHER PARAMETER(S)\n if (ishare.size > 0):\n for s in range(ishare.size):\n nextp[:,ishare[s]] = nextp[:,int(abs(stepsize[ishare[s]])-1)]\n #COMPUTE NEXT CHI SQUARED AND ACCEPTANCE VALUES\n pedit = np.copy(nextp)\n nextchisq = np.zeros(nchains)\n for j in range(numevents):\n ymodels, noisepars = calcModel(nchains, functype, myfuncs, pedit, params, iortholist[j], funcx, cummodels, numparams, j, iblocks[b])\n nextmodel[j] = np.multiply(nextmodel[j],ymodels)\n nextchisq += calcChisq(y[j], sigma[j], nextmodel[j], nchains, params, j, noisepars, isrednoise, wavelet, noisefunc)\n #CALCULATE ACCEPTANCE PROBABILITY\n accept = np.exp(0.5 * (currchisq - nextchisq))\n #print(b,currchisq[0], nextchisq[0], accept[0])\n for n in range(nchains):\n if accept[n] >= 1:\n #ACCEPT BETTER STEP\n numaccept += 1\n numa[b] += 1\n params[n] = np.copy(nextp[n])\n currchisq[n] = np.copy(nextchisq[n])\n if (currchisq[n] < bestchisq):\n bestp = np.copy(params[n])\n bestchisq = np.copy(currchisq[n])\n elif unif[m,n] <= accept[n]:\n #ACCEPT WORSE STEP\n numaccept += 1\n numa[b] += 1\n params[n] = np.copy(nextp[n])\n currchisq[n] = np.copy(nextchisq[n])\n\n allparams[:,:,m] = params.T\n #PRINT INTERMEDIATE INFO\n if ((m+1) % intsteps == 0) and (m > 0):\n print(\"\\n\" + time.ctime())\n #print(\"Number of times parameter tries to step outside its prior:\")\n #print(outside)\n print(\"Current Best Parameters: \")\n print(bestp)\n\n #Apply Gelman-Rubin statistic\n if isGR:\n #Check for no accepted steps in each chain\n #stdev = np.std(allparams[inotfixed],axis=1)\n #ichain = np.where(stdev > 0.)[0]\n #Call test\n #psrf, meanpsrf = gr.convergetest(allparams[inotfixed,ichain,:m+1], len(ichain))\n psrf, meanpsrf = gr.convergetest(allparams[inotfixed,:,:m+1], nchains)\n numconv = np.sum(np.bitwise_and(psrf < 1.01, psrf >= 1.00))\n print(\"Gelman-Rubin statistic for free parameters:\")\n print(psrf)\n if numconv == numnotfixed: #and m >= 1e4:\n print(\"All parameters have converged to within 1% of unity. Halting MCMC.\")\n allparams = allparams[:,:,:m+1]\n break\n clock.check(m+1)\n\n print(\"Acceptance rate per block (%):\")\n print(100.*numa*numblocks/numit/nchains)\n allparams = np.reshape(allparams,(nump, (m+1)*nchains))\n return allparams, bestp, numaccept, (m+1)*nchains\n\n#****************************************************************\n\ndef calcChi2(nchains, functype, myfuncs, pedit, nextp, iortholist, funcx, cummodels, numparams, j, isrednoise, wavelet, noisefunc, systematics, chains=None):\n '''\n Compute model light curve by combining model components.\n '''\n #Build final model from model components\n ymodels = np.ones((nchains, fit[j].nobj))\n noisepars = [[] for i in range(nchains)]\n k = 0\n if chains == None:\n chains = range(nchains)\n for i in range(cummodels[j],cummodels[j+1]):\n for n in chains:\n if functype[i] == 'ortho':\n #MODIFY COPY OF nextp ONLY\n pedit[n,iortholist] = myfuncs[i](pedit[n,iortholist], funcx[i], fit[j].etc[k])\n elif (functype[i] == 'ipmap') or (functype[i] == 'spline'):\n ymodels[n] *= myfuncs[i](pedit[n,numparams[i]:numparams[i+1]], funcx[i], ymodels[n])\n elif functype[i] == 'posoffset':\n # Record change in Position 0 => cannot orthogonalize position parameters\n ymodels[n] *= myfuncs[i](nextp[n,numparams[i]:numparams[i+1]], funcx[i], fit[j].etc[k])\n elif hasattr(fit[j], 'timebins') and (functype[i] == 'ecl/tr'\n or functype[i] == 'ramp'\n or functype[i] == 'sinusoidal'):\n # Average over high-resolution model\n hiresmodel = myfuncs[i](pedit[n,numparams[i]:numparams[i+1]], funcx[i], fit[j].etc[k])\n if len(fit[j].timebins) == fit[j].nobj:\n for tb in range(len(fit[j].timebins)):\n ymodels[n,tb] *= np.mean(hiresmodel[fit[j].timebins[tb]])\n else:\n for tb in range(len(fit[j].timebinsuc)):\n ymodels[n,tb] *= np.mean(hiresmodel[fit[j].timebinsuc[tb]])\n elif functype[i] == 'noise':\n noisepars[n] = pedit[n,numparams[i]:numparams[i+1]]\n else:\n ymodels[n] *= myfuncs[i](pedit[n,numparams[i]:numparams[i+1]], funcx[i], fit[j].etc[k])\n k += 1\n\n # Calculate chi^2\n chi2 = np.zeros(nchains)\n for n in chains:\n if isrednoise == False:\n #chi2[n] = mc.chisq(ymodels[n]*systematics[n][j], data[j], unc[j])\n chi2[n] = np.sum((ymodels[n]*systematics[n][j] - data[j])**2 / unc[j]**2)\n else:\n chi2[n] = noisefunc(noisepars[n], ymodels[n]*systematics[n][j]-data[j], wavelet)\n # Apply prior, if one exists\n if len(fit[j].ipriors) > 0:\n pbar = fit[j].priorvals[:,0] #prior mean\n psigma = np.zeros(len(pbar)) #prior standard deviation\n # Determine psigma based on which side of asymmetric Gaussian nextp is on\n for i in range(len(fit[j].ipriors)):\n if nextp[n,fit[j].ipriors[i]] < pbar[i]:\n psigma[i] = fit[j].priorvals[i,1]\n else:\n psigma[i] = fit[j].priorvals[i,2]\n #chi2[n] += fit[j].nobj*((nextp[n,fit[j].ipriors[i]] - pbar[i])/psigma[i])**2\n chi2[n] += ((nextp[n,fit[j].ipriors[i]] - pbar[i])/psigma[i])**2\n\n return chi2\n\n#\ndef writeChi2(chi2):\n '''\n Write models after multiprocessing.\n '''\n global nextchisq\n nextchisq += chi2\n return\n\ndef demc(y, pars, pmin, pmax, stepsize, numit, sigma, numparams, cummodels, functype, myfuncs, funcx, iortholist, nights, fits, gamma=None, isGR=True, ncpu=1):\n \"\"\"\n This function uses a differential evolution Markov chain to assess uncertainties.\n\n PARAMETERS\n ----------\n y: Array containing dependent data\n Params: Array of initial guess for parameters\n #Pmin: Array of parameter minimum values\n #Pmax: Array of parameter maximum values\n stepsize: Array of 1-sigma change in parameter per iteration\n Numit:\t Number of iterations to perform\n Sigma:\t Standard deviation of data noise in y\n Numparams: Number of parameters for each model\n Cummodels: Cumulative number of models used\n Functype: Define function type (eclipse, ramp, ip, etc), see models.py\n Myfuncs: Pointers to model functions\n Funcx:\t Array of x-axis values for myfuncs\n fit: List of fit objects\n gamma: Multiplcation factor in parameter differential, establishes acceptance rate\n\n OUTPUTS\n -------\n This function returns an array of the best fitting parameters,\n an array of all parameters over all iterations, and numaccept.\n\n REFERENCES\n ----------\n Cajo J. F. Ter Braak, \"Genetic algorithms and Markov Chain Monte Carlo: Differential Evolution Markov Chain makes Bayesian computing easy,\" Biometrics, 2006.\n\n HISTORY\n -------\n Adapted from mcmc.py\n Kevin Stevenson, UChicago August 2012\n Multiplied prior by number of points in fit\n January 2014\n \"\"\"\n global nextchisq, fit, data, unc\n fit = fits\n data = y\n unc = sigma\n\n params = np.copy(pars)\n nchains, nump = params.shape\n nextp = np.copy(params) #Proposed parameters\n bestp = np.copy(params[0]) #Best-fit parameters\n pedit = np.copy(params) #Editable parameters\n\n numaccept = 0\n #allparams must be 64-bit!\n allparams = np.zeros((nump, nchains, numit))\n inotfixed = np.where(stepsize != 0)[0]\n ishare = np.where(stepsize < 0)[0]\n ifree = np.where(stepsize > 0)[0]\n outside = np.zeros((nchains, nump))\n numevents = len(fit)\n intsteps = np.min((numit/5,1e5))\n isrednoise = False\n wavelet = None\n noisefunc = None\n numfree = len(ifree)\n print(\"Number of free parameters:\")\n print(len(ifree))\n if gamma == None:\n gamma = 2.38/np.sqrt(2*numfree)\n print('Gamma = ' + str(gamma))\n\n #UPDATE PARAMTER(S) EQUAL TO OTHER PARAMETER(S)\n if (ishare.size > 0):\n for s in range(ishare.size):\n params[:,ishare[s]] = params[:,int(abs(stepsize[ishare[s]])-1)]\n\n # Construct non-analytic systematic model\n for nn in np.unique(nights):\n tonight = np.where(nights == nn)[0]\n if hasattr(fit[tonight[0]], 'whiteparams') and fit[tonight[0]].whiteparams != None:\n if type(fit[tonight[0]].whiteparams) == type(np.array([])):\n #Only 1 model in model for white LC, grandfathered code\n #print(\"WARNING: You are using grandfathered code. Update whiteparams to handle multiple models.\")\n #whitemodel = np.zeros((nchains,len(fit[tonight[0]].good)))\n i = int(fit[tonight[0]].whiteparams[0])\n whitemodel = myfuncs[i](fit[tonight[0]].whiteparams[1:], fit[tonight[0]].tuall, None)\n else:\n #Any number of models can be used to build white LC\n whitemodel = np.ones((nchains,len(fit[tonight[0]].good)))\n for k in range(len(fit[tonight[0]].whiteparams)):\n i = int(fit[tonight[0]].whiteparams[k][0])\n whitemodel *= myfuncs[i](fit[tonight[0]].whiteparams[k][1:], fit[tonight[0]].tuall, None)\n #whitemodel *= myfuncs[i](fit[tonight[0]].whiteparams[k][1:], funcxuc[i], None)\n for j in tonight:\n fit[j].whitemodel = whitemodel\n elif hasattr(fit[tonight[0]], 'iswhitelc') and fit[tonight[0]].iswhitelc != False:\n whitemodel = np.zeros((nchains,len(fit[tonight[0]].good)))\n weight = np.zeros((nchains,len(fit[tonight[0]].good)))\n for n in range(nchains):\n for j in tonight:\n k = 0\n for i in range(cummodels[j],cummodels[j+1]):\n if functype[i] == 'ecl/tr':\n specmodel = myfuncs[i](pedit[n,numparams[i]:numparams[i+1]], funcx[i], fit[j].etc[k])\n specmodeluc = np.zeros(len(fit[j].clipmask))\n specmodeluc[fit[j].isclipmask] = specmodel\n whitemodel[n,fit[j].isgood] += specmodeluc\n weight [n,fit[j].isgood] += specmodel[0]\n k += 1\n whitemodel[n] /= weight[n]\n #FINDME: Need to determine exact anchor point\n #slope = fit[0].iswhitelc / (1-whitemodel[n].min())\n #offset = 1 - slope\n #whitemodel[n] = slope*whitemodel[n] + offset\n for j in tonight:\n fit[j].whitemodel = whitemodel\n else:\n for j in tonight:\n fit[j].whitemodel = np.ones((nchains,len(fit[j].good)))\n\n #Calc chi-squared for model type using current params\n currchisq = np.zeros(nchains)\n noisepars = [[] for i in range(nchains)]\n for j in range(numevents):\n #Build final model from model components\n ymodels = np.ones((nchains, fit[j].nobj))\n k = 0\n for i in range(cummodels[j],cummodels[j+1]):\n for n in range(nchains):\n if functype[i] == 'ortho':\n #MODIFY COPY OF nextp ONLY\n pedit[n,iortholist[j]] = myfuncs[i](pedit[n,iortholist[j]], funcx[i], fit[j].etc[k])\n elif (functype[i] == 'ipmap') or (functype[i] == 'spline'):\n ymodels[n] *= myfuncs[i](pedit[n,numparams[i]:numparams[i+1]], funcx[i], ymodels[n])\n elif functype[i] == 'posoffset':\n # Record change in Position 0 => cannot orthogonalize position parameters\n ymodels[n] *= myfuncs[i](nextp[n,numparams[i]:numparams[i+1]], funcx[i], fit[j].etc[k])\n elif hasattr(fit[j], 'timebins') and (functype[i] == 'ecl/tr'\n or functype[i] == 'ramp'\n or functype[i] == 'sinusoidal'):\n # Average over high-resolution model\n hiresmodel = myfuncs[i](pedit[n,numparams[i]:numparams[i+1]], funcx[i], fit[j].etc[k])\n if len(fit[j].timebins) == fit[j].nobj:\n for tb in range(len(fit[j].timebins)):\n ymodels[n,tb] *= np.mean(hiresmodel[fit[j].timebins[tb]])\n else:\n for tb in range(len(fit[j].timebinsuc)):\n ymodels[n,tb] *= np.mean(hiresmodel[fit[j].timebinsuc[tb]])\n elif functype[i] == 'noise':\n # Set up for modified chi-squared calculation using correlated noise\n isrednoise = True\n wavelet = fit[j].etc[k]\n noisefunc = myfuncs[i]\n noisepars[n] = pedit[n,numparams[i]:numparams[i+1]]\n else:\n ymodels[n] *= myfuncs[i](pedit[n,numparams[i]:numparams[i+1]], funcx[i], fit[j].etc[k])\n k += 1\n #Multiply analytic model by non-analytic systematics model\n systematics = fit[j].whitelc*fit[j].refspeclc/(fit[j].whitemodel[n][fit[j].isgood].flatten())[fit[j].isclipmask]\n ymodels[n] *= systematics\n # Calculate chi^2\n for n in range(nchains):\n if isrednoise == False:\n currchisq[n] += np.sum((ymodels[n] - y[j])**2 / sigma[j]**2)\n #currchisq[n] += mc.chisq(ymodels[n], y[j], sigma[j])\n else:\n currchisq[n] += noisefunc(noisepars[n], ymodels[n]-y[j], wavelet)\n # Apply prior, if one exists\n if len(fit[j].ipriors) > 0:\n pbar = fit[j].priorvals[:,0] #prior mean\n psigma = np.zeros(len(pbar)) #prior standard deviation\n # Determine psigma based on which side of asymmetric Gaussian nextp is on\n for i in range(len(fit[j].ipriors)):\n if nextp[n,fit[j].ipriors[i]] < pbar[i]:\n psigma[i] = fit[j].priorvals[i,1]\n else:\n psigma[i] = fit[j].priorvals[i,2]\n #currchisq[n] += fit[j].nobj*((nextp[n,fit[j].ipriors[i]] - pbar[i])/psigma[i])**2\n currchisq[n] += ((nextp[n,fit[j].ipriors[i]] - pbar[i])/psigma[i])**2\n\n bestchisq = currchisq[0]\n\n #GENERATE RANDOM NUMBERS FOR MCMC\n numnotfixed = len(inotfixed)\n unif = npr.rand(numit,nchains)\n\n #START TIMER\n clock = timer.Timer(numit,progress = np.arange(0.05,1.01,0.05))\n\n #Run Differential Evolution Monte Carlo algorithm 'numit' times\n b = gamma*stepsize[ifree]/100.\n for m in range(numit):\n for n in range(nchains):\n #Generate next step using differential evolution\n rand1, rand2 = npr.randint(0,nchains,2)\n while rand1 == n or rand2 == n or rand1 == rand2:\n rand1, rand2 = npr.randint(0,nchains,2)\n nextp[n,ifree] = params[n,ifree] + gamma*(params[rand1,ifree]-params[rand2,ifree]) \\\n + npr.normal(0, b, numfree)\n #CHECK FOR NEW STEPS OUTSIDE BOUNDARIES\n ioutside = np.where(np.bitwise_or(nextp[n] < pmin, nextp[n] > pmax))[0]\n if (len(ioutside) > 0):\n nextp[n,ioutside] = np.copy(params[n,ioutside])\n outside[n,ioutside] += 1\n #UPDATE PARAMTER(S) EQUAL TO OTHER PARAMETER(S)\n if (ishare.size > 0):\n for s in range(ishare.size):\n nextp[:,ishare[s]] = nextp[:,int(abs(stepsize[ishare[s]])-1)]\n # Construct non-analytic systematic model\n for nn in np.unique(nights):\n tonight = np.where(nights == nn)[0]\n if hasattr(fit[tonight[0]], 'whiteparams') and fit[tonight[0]].whiteparams != None:\n pass\n elif hasattr(fit[tonight[0]], 'iswhitelc') and fit[tonight[0]].iswhitelc != False:\n whitemodel = np.zeros((nchains,len(fit[tonight[0]].good)))\n weight = np.zeros((nchains,len(fit[tonight[0]].good)))\n for n in range(nchains):\n for j in tonight:\n k = 0\n for i in range(cummodels[j],cummodels[j+1]):\n if functype[i] == 'ecl/tr':\n specmodel = myfuncs[i](nextp[n,numparams[i]:numparams[i+1]], funcx[i], fit[j].etc[k])\n specmodeluc = np.zeros(len(fit[j].clipmask))\n specmodeluc[fit[j].isclipmask] = specmodel\n whitemodel[n,fit[j].isgood] += specmodeluc\n weight [n,fit[j].isgood] += specmodel[0]\n k += 1\n whitemodel[n] /= weight[n]\n #FINDME: Need to determine exact anchor point\n #Also modify statement in w6model.py\n #slope = fit[0].iswhitelc / (1-whitemodel[n].min())\n #offset = 1 - slope\n #whitemodel[n] = slope*whitemodel[n] + offset\n for j in tonight:\n fit[j].whitemodel = whitemodel\n else:\n for j in tonight:\n fit[j].whitemodel = np.ones((nchains,len(fit[j].good)))\n # Assemble systematics models\n systematics = [[] for n in range(nchains)]\n for n in range(nchains):\n for j in range(numevents):\n systematics[n].append(fit[j].whitelc*fit[j].refspeclc/(fit[j].whitemodel[n][fit[j].isgood].flatten())[fit[j].isclipmask])\n #systematics[n].append(((fit[j].whitelc/whitemodel[n])[fit[j].isgood].flatten())[fit[j].isclipmask])\n #COMPUTE NEXT CHI SQUARED AND ACCEPTANCE VALUES\n pedit = np.copy(nextp)\n nextchisq = np.zeros(nchains)\n if ncpu == 1:\n # Only 1 CPU\n for j in range(numevents):\n nextchisq += calcChi2(nchains, functype, myfuncs, pedit, nextp, iortholist[j], funcx, cummodels, numparams, j, isrednoise=isrednoise, wavelet=wavelet, noisefunc=noisefunc, systematics=systematics)\n else:\n # Multiple CPUs\n # Code works but is less efficient\n pool = mp.Pool(ncpu)\n for j in range(numevents):\n res = pool.apply_async(calcChi2, args=(nchains, functype, myfuncs, pedit, nextp, iortholist[j], funcx, cummodels, numparams, j, isrednoise, wavelet, noisefunc, systematics), callback=writeChi2)\n\n pool.close()\n pool.join()\n res.wait()\n\n #CALCULATE ACCEPTANCE PROBABILITY\n accept = np.exp(0.5 * (currchisq - nextchisq))\n for n in range(nchains):\n if (accept[n] >= 1) or (unif[m,n] <= accept[n]):\n #ACCEPT STEP\n numaccept += 1\n params[n] = np.copy(nextp[n])\n currchisq[n] = nextchisq[n]\n if (currchisq[n] < bestchisq):\n bestp = np.copy(params[n])\n bestchisq = np.copy(currchisq[n])\n\n allparams[:,:,m] = params.T\n #PRINT INTERMEDIATE INFO\n if ((m+1) % intsteps == 0) and (m > 0):\n print(\"\\n\" + time.ctime())\n #print(\"Number of times parameter tries to step outside its prior:\")\n #print(outside)\n print(\"Current Best Parameters: \")\n print(bestp)\n\n #Apply Gelman-Rubin statistic\n if isGR:\n #Check for no accepted steps in each chain\n stdev = np.std(allparams[inotfixed[0],:,:m+1],axis=1)\n ichain = np.where(stdev > 1e-8)[0]\n #Call test\n foo = allparams[inotfixed]\n psrf, meanpsrf = gr.convergetest(foo[:,ichain,:m+1], len(ichain))\n #psrf, meanpsrf = gr.convergetest(allparams[inotfixed,:,:m+1], nchains)\n numconv = np.sum(np.bitwise_and(psrf < 1.01, psrf >= 1.00))\n print(\"Gelman-Rubin statistic for free parameters:\")\n print(psrf)\n if numconv == numnotfixed: #and j >= 1e4:\n print(\"All parameters have converged to within 1% of unity. Halting MCMC.\")\n allparams = allparams[:,:,:m+1]\n break\n clock.check(m+1)\n\n #Check for no accepted steps in each chain\n stdev = np.std(allparams[inotfixed[0]],axis=1)\n ichain = np.where(stdev > 1e-8)[0]\n print(\"Number of good chains: \" + str(len(ichain)))\n #print(len(ichain), ichain)\n #print(stdev)\n allparams = allparams[:,ichain]\n allparams = np.reshape(allparams,(nump, (m+1)*len(ichain)))\n return allparams, bestp, numaccept, (m+1)*len(ichain)\n\n\n\ndef demcz(y, pars, stdpburnin, pmin, pmax, stepsize, numit, sigma, numparams, cummodels, functype, myfuncs, funcx, iortholist, nights, fits, gamma=None, isGR=True, ncpu=1):\n \"\"\"\n This function uses a differential evolution Markov chain with fewer chains to assess uncertainties.\n\n PARAMETERS\n ----------\n y: Array containing dependent data\n Params: Array of initial guess for parameters\n stdpburnin:Standard deviation of allparams from burn-in\n Pmin: Array of parameter minimum values\n Pmax: Array of parameter maximum values\n stepsize: Array of 1-sigma change in parameter per iteration\n Numit:\t Number of iterations to perform\n Sigma:\t Standard deviation of data noise in y\n Numparams: Number of parameters for each model\n Cummodels: Cumulative number of models used\n Functype: Define function type (eclipse, ramp, ip, etc), see models.py\n Myfuncs: Pointers to model functions\n Funcx:\t Array of x-axis values for myfuncs\n fit: List of fit objects\n gamma: Multiplication factor in parameter differential, establishes acceptance rate\n\n OUTPUTS\n -------\n This function returns an array of the best fitting parameters,\n an array of all parameters over all iterations, and numaccept.\n\n REFERENCES\n ----------\n Cajo J. F. Ter Braak, \"Differential Evolution Markov Chain with snooker updater and fewer chains\" Stat Comput, 2008.\n\n HISTORY\n -------\n Adapted from mcmc.py August 2012\n Kevin Stevenson, UChicago\n Multiplied prior by number of points in fit January 2014\n Adapted from demc() August 2014\n\n \"\"\"\n global nextchisq, fit, data, unc\n fit = fits\n data = y\n unc = sigma\n\n params = np.copy(pars)\n nchains, nump = params.shape\n nextp = np.copy(params) #Proposed parameters\n bestp = np.copy(params[0]) #Best-fit parameters\n pedit = np.copy(params) #Editable parameters\n\n numaccept = 0\n ifixed = np.where(stepsize == 0)[0] #Indices of fixed parameters\n inotfixed = np.where(stepsize != 0)[0] #Indices of non-fixed parameters\n ishare = np.where(stepsize < 0)[0] #Indices of shared parameters\n ifree = np.where(stepsize > 0)[0] #Indices of free parameters\n #outside = np.zeros((nchains, nump))\n numevents = len(fit)\n intsteps = np.min((numit/5,1e5)) #Number of steps before checking G-R statistic\n isrednoise = False\n wavelet = None\n noisefunc = None\n numfree = len(ifree)\n print(\"Number of free parameters: \" + str(len(ifree)))\n if gamma == None:\n gamma = 2.38/np.sqrt(2*numfree)\n print('Gamma = ' + str(gamma))\n\n #UPDATE PARAMETER(S) EQUAL TO OTHER PARAMETER(S)\n if (ishare.size > 0):\n ishareptr = []\n for s in range(ishare.size):\n ishareptr.append(int(abs(stepsize[ishare[s]])-1)) #Pointer to where parameter is shared from\n params[:,ishare[s]] = params[:,ishareptr[s]]\n\n #INITIALIZE FIRST 10*numfree PARAMETERS IN allparams\n ninit = 10*numfree\n numit += ninit\n #if numit < (ninit + 10):\n # numit == 1ninit + 10\n allparams = np.zeros((nump, nchains, numit)) #allparams must be 64-bit!\n #Populate fixed parameters\n allparams[ifixed,:,:ninit] = params[:,ifixed].T[:,:,np.newaxis]\n #Populate free parameters\n for p in ifree:\n allparams[p,:,:ninit] = np.random.normal(params[0,p],stdpburnin[p],[nchains,ninit])\n #Update shared parameters\n if (ishare.size > 0):\n allparams[ishare,:,:ninit] = allparams[ishareptr,:,:ninit]\n\n # Construct non-analytic systematic model\n for nn in np.unique(nights):\n tonight = np.where(nights == nn)[0]\n if hasattr(fit[tonight[0]], 'whiteparams') and fit[tonight[0]].whiteparams != None:\n if type(fit[tonight[0]].whiteparams) == type(np.array([])):\n #Only 1 model in model for white LC, grandfathered code\n #print(\"WARNING: You are using grandfathered code. Update whiteparams to handle multiple models.\")\n #whitemodel = np.zeros((nchains,len(fit[tonight[0]].good)))\n i = int(fit[tonight[0]].whiteparams[0])\n whitemodel = myfuncs[i](fit[tonight[0]].whiteparams[1:], fit[tonight[0]].tuall, None)\n else:\n #Any number of models can be used to build white LC\n whitemodel = np.ones((nchains,len(fit[tonight[0]].good)))\n for k in range(len(fit[tonight[0]].whiteparams)):\n i = int(fit[tonight[0]].whiteparams[k][0])\n whitemodel *= myfuncs[i](fit[tonight[0]].whiteparams[k][1:], fit[tonight[0]].tuall, None)\n #whitemodel *= myfuncs[i](fit[tonight[0]].whiteparams[k][1:], funcxuc[i], None)\n for j in tonight:\n fit[j].whitemodel = whitemodel\n elif hasattr(fit[tonight[0]], 'iswhitelc') and fit[tonight[0]].iswhitelc != False:\n whitemodel = np.zeros((nchains,len(fit[tonight[0]].good)))\n weight = np.zeros((nchains,len(fit[tonight[0]].good)))\n for n in range(nchains):\n for j in tonight:\n k = 0\n for i in range(cummodels[j],cummodels[j+1]):\n if functype[i] == 'ecl/tr':\n specmodel = myfuncs[i](pedit[n,numparams[i]:numparams[i+1]], funcx[i], fit[j].etc[k])\n specmodeluc = np.zeros(len(fit[j].clipmask))\n specmodeluc[fit[j].isclipmask] = specmodel\n whitemodel[n,fit[j].isgood] += specmodeluc\n weight [n,fit[j].isgood] += specmodel[0]\n k += 1\n whitemodel[n] /= weight[n]\n #FINDME: Need to determine exact anchor point\n #slope = fit[0].iswhitelc / (1-whitemodel[n].min())\n #offset = 1 - slope\n #whitemodel[n] = slope*whitemodel[n] + offset\n for j in tonight:\n fit[j].whitemodel = whitemodel\n else:\n for j in tonight:\n fit[j].whitemodel = np.ones((nchains,len(fit[j].good)))\n\n #Calc chi-squared for model type using current params\n currchisq = np.zeros(nchains)\n noisepars = [[] for i in range(nchains)]\n for j in range(numevents):\n #Build final model from model components\n ymodels = np.ones((nchains, fit[j].nobj))\n k = 0\n for i in range(cummodels[j],cummodels[j+1]):\n for n in range(nchains):\n if functype[i] == 'ortho':\n #MODIFY COPY OF nextp ONLY\n pedit[n,iortholist[j]] = myfuncs[i](pedit[n,iortholist[j]], funcx[i], fit[j].etc[k])\n elif (functype[i] == 'ipmap') or (functype[i] == 'spline'):\n ymodels[n] *= myfuncs[i](pedit[n,numparams[i]:numparams[i+1]], funcx[i], ymodels[n])\n elif functype[i] == 'posoffset':\n # Record change in Position 0 => cannot orthogonalize position parameters\n ymodels[n] *= myfuncs[i](nextp[n,numparams[i]:numparams[i+1]], funcx[i], fit[j].etc[k])\n elif hasattr(fit[j], 'timebins') and (functype[i] == 'ecl/tr'\n or functype[i] == 'ramp'\n or functype[i] == 'sinusoidal'):\n # Average over high-resolution model\n hiresmodel = myfuncs[i](pedit[n,numparams[i]:numparams[i+1]], funcx[i], fit[j].etc[k])\n if len(fit[j].timebins) == fit[j].nobj:\n for tb in range(len(fit[j].timebins)):\n ymodels[n,tb] *= np.mean(hiresmodel[fit[j].timebins[tb]])\n else:\n for tb in range(len(fit[j].timebinsuc)):\n ymodels[n,tb] *= np.mean(hiresmodel[fit[j].timebinsuc[tb]])\n elif functype[i] == 'noise':\n # Set up for modified chi-squared calculation using correlated noise\n isrednoise = True\n wavelet = fit[j].etc[k]\n noisefunc = myfuncs[i]\n noisepars[n] = pedit[n,numparams[i]:numparams[i+1]]\n else:\n ymodels[n] *= myfuncs[i](pedit[n,numparams[i]:numparams[i+1]], funcx[i], fit[j].etc[k])\n k += 1\n #Multiply analytic model by non-analytic systematics model\n systematics = fit[j].whitelc*fit[j].refspeclc/(fit[j].whitemodel[n][fit[j].isgood].flatten())[fit[j].isclipmask]\n ymodels[n] *= systematics\n # Calculate chi^2\n for n in range(nchains):\n if isrednoise == False:\n #currchisq[n] += mc.chisq(ymodels[n], y[j], sigma[j])\n currchisq[n] += np.sum((ymodels[n] - y[j])**2 / sigma[j]**2)\n else:\n currchisq[n] += noisefunc(noisepars[n], ymodels[n]-y[j], wavelet)\n # Apply prior, if one exists\n if len(fit[j].ipriors) > 0:\n pbar = fit[j].priorvals[:,0] #prior mean\n psigma = np.zeros(len(pbar)) #prior standard deviation\n # Determine psigma based on which side of asymmetric Gaussian nextp is on\n for i in range(len(fit[j].ipriors)):\n if nextp[n,fit[j].ipriors[i]] < pbar[i]:\n psigma[i] = fit[j].priorvals[i,1]\n else:\n psigma[i] = fit[j].priorvals[i,2]\n #currchisq[n] += fit[j].nobj*((nextp[n,fit[j].ipriors[i]] - pbar[i])/psigma[i])**2\n currchisq[n] += ((nextp[n,fit[j].ipriors[i]] - pbar[i])/psigma[i])**2\n\n bestchisq = currchisq[0]\n\n #GENERATE RANDOM NUMBERS FOR MCMC\n unif = npr.rand(numit,nchains) #Acceptance\n snooker = npr.rand(numit,nchains) #If <0.1, set gamma = 1 during step\n randchain = npr.randint(0,nchains,[2,numit,nchains]) #Pairs of chains\n b = gamma*stepsize[ifree]/100.\n epsilon = npr.normal(0, b, [numit,nchains,numfree])\n\n #START TIMER\n clock = timer.Timer(numit-ninit,progress = np.arange(0.05,1.01,0.05))\n\n #Run Differential Evolution Monte Carlo algorithm 'numit' times\n numnotfixed = len(inotfixed)\n for m in range(ninit,numit):\n '''\n #Code below is slower, possibly because array copies are made???\n #Generate next step using differential evolution\n randstep = npr.randint(0,m,[2,nchains])\n nextp[:,ifree] = params[:,ifree] + gamma*(allparams[ifree][:,randchain[0,m],randstep[0]] \\\n - allparams[ifree][:,randchain[1,m],randstep[1]]).T \\\n + epsilon[m]\n '''\n randstep = npr.randint(0,m,[2,nchains])\n for n in range(nchains):\n #Generate next step using differential evolution\n if snooker[m,n] < 0.1:\n #Set gamma = 1 to jump between modes (bimodal distribution)\n nextp[n,ifree] = params[n,ifree] + (allparams[ifree,randchain[0,m,n],randstep[0,n]] \\\n - allparams[ifree,randchain[1,m,n],randstep[1,n]]) \\\n + epsilon[m,n]\n else:\n nextp[n,ifree] = params[n,ifree] + gamma*(allparams[ifree,randchain[0,m,n],randstep[0,n]] \\\n - allparams[ifree,randchain[1,m,n],randstep[1,n]]) \\\n + epsilon[m,n]\n #CHECK FOR NEW STEPS OUTSIDE BOUNDARIES\n ioutside = np.where(np.bitwise_or(nextp < pmin, nextp > pmax))\n if (len(ioutside) > 0):\n nextp[ioutside] = np.copy(params[ioutside])\n #UPDATE PARAMTER(S) EQUAL TO OTHER PARAMETER(S)\n if (ishare.size > 0):\n nextp[:,ishare] = nextp[:,ishareptr]\n # Construct non-analytic systematic model\n for nn in np.unique(nights):\n tonight = np.where(nights == nn)[0]\n if hasattr(fit[tonight[0]], 'whiteparams') and fit[tonight[0]].whiteparams != None:\n pass\n elif hasattr(fit[tonight[0]], 'iswhitelc') and fit[tonight[0]].iswhitelc != False:\n print(\"***WARNING: whiteparams not defined.***\")\n whitemodel = np.zeros((nchains,len(fit[tonight[0]].good)))\n weight = np.zeros((nchains,len(fit[tonight[0]].good)))\n for n in range(nchains):\n for j in tonight:\n k = 0\n for i in range(cummodels[j],cummodels[j+1]):\n if functype[i] == 'ecl/tr':\n specmodel = myfuncs[i](nextp[n,numparams[i]:numparams[i+1]], funcx[i], fit[j].etc[k])\n specmodeluc = np.zeros(len(fit[j].clipmask))\n specmodeluc[fit[j].isclipmask] = specmodel\n whitemodel[n,fit[j].isgood] += specmodeluc\n weight [n,fit[j].isgood] += specmodel[0]\n k += 1\n whitemodel[n] /= weight[n]\n #FINDME: Need to determine exact anchor point\n #Also modify statement in w6model.py\n #slope = fit[0].iswhitelc / (1-whitemodel[n].min())\n #offset = 1 - slope\n #whitemodel[n] = slope*whitemodel[n] + offset\n for j in tonight:\n fit[j].whitemodel = whitemodel\n else:\n for j in tonight:\n fit[j].whitemodel = np.ones((nchains,len(fit[j].good)))\n # Assemble systematics models\n systematics = [[] for n in range(nchains)]\n for n in range(nchains):\n for j in range(numevents):\n systematics[n].append(fit[j].whitelc*fit[j].refspeclc/(fit[j].whitemodel[n][fit[j].isgood].flatten())[fit[j].isclipmask])\n #systematics[n].append(((fit[j].whitelc/whitemodel[n])[fit[j].isgood].flatten())[fit[j].isclipmask])\n #COMPUTE NEXT CHI SQUARED AND ACCEPTANCE VALUES\n pedit = np.copy(nextp)\n nextchisq = np.zeros(nchains)\n if ncpu == 1:\n # Only 1 CPU\n for j in range(numevents):\n nextchisq += calcChi2(nchains, functype, myfuncs, pedit, nextp, iortholist[j], funcx, cummodels, numparams, j, isrednoise=isrednoise, wavelet=wavelet, noisefunc=noisefunc, systematics=systematics)\n else:\n # Multiple CPUs\n # Code works but is less efficient\n pool = mp.Pool(ncpu)\n for j in range(numevents):\n res = pool.apply_async(calcChi2, args=(nchains, functype, myfuncs, pedit, nextp, iortholist[j], funcx, cummodels, numparams, j, isrednoise, wavelet, noisefunc, systematics), callback=writeChi2)\n\n pool.close()\n pool.join()\n res.wait()\n\n #CALCULATE ACCEPTANCE PROBABILITY\n accept = np.exp(0.5 * (currchisq - nextchisq))\n for n in range(nchains):\n if (accept[n] >= 1) or (unif[m,n] <= accept[n]):\n #ACCEPT STEP\n numaccept += 1\n params[n] = np.copy(nextp[n])\n currchisq[n] = nextchisq[n]\n if (currchisq[n] < bestchisq):\n bestp = np.copy(params[n])\n bestchisq = np.copy(currchisq[n])\n\n allparams[:,:,m] = params.T\n #PRINT INTERMEDIATE INFO\n if ((m+1-ninit) % intsteps == 0) and (m > ninit):\n print(\"\\n\" + time.ctime())\n #print(\"Number of times parameter tries to step outside its prior:\")\n #print(outside)\n print(\"Current Best Parameters: \")\n print(bestp)\n\n #Apply Gelman-Rubin statistic\n if isGR:\n #Check for no accepted steps in each chain\n stdev = np.std(allparams[inotfixed[0],:,ninit:m+1],axis=1)\n ichain = np.where(stdev > 1e-8)[0]\n if len(ichain) > 1:\n #Call test\n foo = allparams[inotfixed]\n psrf, meanpsrf = gr.convergetest(foo[:,ichain,ninit:m+1], len(ichain))\n #psrf, meanpsrf = gr.convergetest(allparams[inotfixed,:,:m+1], nchains)\n numconv = np.sum(np.bitwise_and(psrf < 1.01, psrf >= 1.00))\n print(\"Gelman-Rubin statistic for free parameters:\")\n print(psrf)\n if numconv == numnotfixed: #and j >= 1e4:\n print(\"All parameters have converged to within 1% of unity. Halting MCMC.\")\n allparams = allparams[:,:,:m+1]\n break\n clock.check(m+1-ninit)\n\n #Check for no accepted steps in each chain\n stdev = np.std(allparams[inotfixed[0]],axis=1)\n ichain = np.where(stdev > 1e-8)[0]\n print(\"Number of good chains: \" + str(len(ichain)))\n #FINDME\n allparams = allparams[:,ichain,ninit:]\n allparams = np.reshape(allparams,(nump, (m+1-ninit)*len(ichain)))\n #allparams = allparams[:,ichain]\n #allparams = np.reshape(allparams,(nump, (m+1)*len(ichain)))\n return allparams, bestp, numaccept, (m+1-ninit)*len(ichain)\n", "meta": {"hexsha": "0330189515983ac5d7b75493a1a3b33135772c0a", "size": 49328, "ext": "py", "lang": "Python", "max_stars_repo_path": "eureka/lib/demc.py", "max_stars_repo_name": "iancrossfield/Eureka", "max_stars_repo_head_hexsha": "88b178d1b830c16915045b6387cf91955e0071e2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 15, "max_stars_repo_stars_event_min_datetime": "2020-08-07T12:12:17.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T10:20:38.000Z", "max_issues_repo_path": "eureka/lib/demc.py", "max_issues_repo_name": "iancrossfield/Eureka", "max_issues_repo_head_hexsha": "88b178d1b830c16915045b6387cf91955e0071e2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 159, "max_issues_repo_issues_event_min_datetime": "2020-08-05T14:34:59.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T21:02:10.000Z", "max_forks_repo_path": "eureka/lib/demc.py", "max_forks_repo_name": "iancrossfield/Eureka", "max_forks_repo_head_hexsha": "88b178d1b830c16915045b6387cf91955e0071e2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 17, "max_forks_repo_forks_event_min_datetime": "2021-06-16T09:40:41.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-22T18:28:07.000Z", "avg_line_length": 49.2295409182, "max_line_length": 212, "alphanum_fraction": 0.5387812196, "include": true, "reason": "import numpy", "num_tokens": 13107, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6513548646660542, "lm_q2_score": 0.2909808723634538, "lm_q1q2_score": 0.18953180673870784}} {"text": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n\"\"\"\nPython wrapper around the C extension for the counts-in-cells\nfor positions on the sky. Corresponding C codes are in ``mocks/vpf_mocks/``\nwhile the python wrapper is in :py:mod:`Corrfunc.mocks.vpf_mocks`\n\"\"\"\n\nfrom __future__ import (division, print_function, absolute_import,\n unicode_literals)\n\n__author__ = ('Manodeep Sinha')\n__all__ = ('vpf_mocks', )\n\n\ndef vpf_mocks(rmax, nbins, nspheres, numpN,\n threshold_ngb, centers_file, cosmology,\n RA, DEC, CZ,\n RAND_RA, RAND_DEC, RAND_CZ,\n verbose=False, is_comoving_dist=False,\n xbin_refine_factor=1, ybin_refine_factor=1,\n zbin_refine_factor=1, max_cells_per_dim=100,\n c_api_timer=False, isa=r'fastest'):\n \"\"\"\n Function to compute the counts-in-cells on points on the sky. Suitable\n for mock catalogs and observed galaxies.\n\n Returns a numpy structured array containing the probability of a\n sphere of radius up to ``rmax`` containing ``0--numpN-1`` galaxies.\n\n Parameters\n ----------\n\n rmax : double\n Maximum radius of the sphere to place on the particles\n\n nbins : integer\n Number of bins in the counts-in-cells. Radius of first shell\n is rmax/nbins\n\n nspheres : integer (>= 0)\n Number of random spheres to place within the particle distribution.\n For a small number of spheres, the error is larger in the measured\n pN's.\n\n numpN : integer (>= 1)\n Governs how many unique pN's are to returned. If ``numpN`` is set to 1,\n then only the vpf (p0) is returned. For ``numpN=2``, p0 and p1 are\n returned.\n\n More explicitly, the columns in the results look like the following:\n\n ====== ==========================\n numpN Columns in output\n ====== ==========================\n 1 p0\n 2 p0 p1\n 3 p0 p1 p2\n 4 p0 p1 p2 p3\n ====== ==========================\n\n and so on...\n\n Note: ``p0`` is the vpf\n\n threshold_ngb : integer\n Minimum number of random points needed in a ``rmax`` sphere such that it\n is considered to be entirely within the mock footprint. The\n command-line version, ``mocks/vpf/vpf_mocks.c``, assumes that the\n minimum number of randoms can be at most a 1-sigma deviation from\n the expected random number density.\n\n centers_file : string, filename\n A file containing random sphere centers. If the file does not exist,\n then a list of random centers will be written out. In that case, the\n randoms arrays, ``RAND_RA``, ``RAND_DEC`` and ``RAND_CZ`` are used to\n check that the sphere is entirely within the footprint. If the file does\n exist but either ``rmax`` is too small or there are not enough centers\n then the file will be overwritten.\n\n Note: If the centers file has to be written, the code will take\n significantly longer to finish. However, subsequent runs can re-use\n that centers file and will be faster.\n\n cosmology : integer, required\n Integer choice for setting cosmology. Valid values are 1->LasDamas\n cosmology and 2->Planck cosmology. If you need arbitrary cosmology,\n easiest way is to convert the ``CZ`` values into co-moving distance,\n based on your preferred cosmology. Set ``is_comoving_dist=True``, to\n indicate that the co-moving distance conversion has already been done.\n\n Choices:\n 1. LasDamas cosmology. :math:`\\\\Omega_m=0.25`, :math:`\\\\Omega_\\Lambda=0.75`\n 2. Planck cosmology. :math:`\\\\Omega_m=0.302`, :math:`\\\\Omega_\\Lambda=0.698`\n\n To setup a new cosmology, add an entry to the function,\n ``init_cosmology`` in ``ROOT/utils/cosmology_params.c`` and re-install\n the entire package.\n\n RA : array-like, real (float/double)\n The array of Right Ascensions for the first set of points. RA's\n are expected to be in [0.0, 360.0], but the code will try to fix cases\n where the RA's are in [-180, 180.0]. For peace of mind, always supply\n RA's in [0.0, 360.0].\n\n Calculations are done in the precision of the supplied arrays.\n\n DEC : array-like, real (float/double)\n Array of Declinations for the first set of points. DEC's are expected\n to be in the [-90.0, 90.0], but the code will try to fix cases where\n the DEC's are in [0.0, 180.0]. Again, for peace of mind, always supply\n DEC's in [-90.0, 90.0].\n\n Must be of same precision type as RA.\n\n CZ : array-like, real (float/double)\n Array of (Speed Of Light * Redshift) values for the first set of\n points. Code will try to detect cases where ``redshifts`` have been\n passed and multiply the entire array with the ``speed of light``.\n\n If ``is_comoving_dist`` is set, then ``CZ`` is interpreted as the\n co-moving distance, rather than (Speed Of Light * Redshift).\n\n RAND_RA : array-like, real (float/double)\n The array of Right Ascensions for the randoms. RA's are expected to be\n in [0.0, 360.0], but the code will try to fix cases where the RA's are\n in [-180, 180.0]. For peace of mind, always supply RA's in\n [0.0, 360.0].\n\n Must be of same precision type as RA/DEC/CZ.\n\n RAND_DEC : array-like, real (float/double)\n Array of Declinations for the randoms. DEC's are expected to be in the\n [-90.0, 90.0], but the code will try to fix cases where the DEC's are\n in [0.0, 180.0]. Again, for peace of mind, always supply DEC's in\n [-90.0, 90.0].\n\n Must be of same precision type as RA/DEC/CZ.\n\n RAND_CZ : array-like, real (float/double)\n Array of (Speed Of Light * Redshift) values for the randoms. Code\n will try to detect cases where ``redshifts`` have been\n passed and multiply the entire array with the ``speed of light``.\n\n If ``is_comoving_dist`` is set, then ``CZ2`` is interpreted as the\n co-moving distance, rather than ``(Speed Of Light * Redshift)``.\n\n Note: RAND_RA, RAND_DEC and RAND_CZ are only used when the\n ``centers_file`` needs to be written out. In that case, the\n RAND_RA, RAND_DEC, and RAND_CZ are used as random centers.\n\n verbose : boolean (default false)\n Boolean flag to control output of informational messages\n\n is_comoving_dist : boolean (default false)\n Boolean flag to indicate that ``cz`` values have already been\n converted into co-moving distances. This flag allows arbitrary\n cosmologies to be used in ``Corrfunc``.\n\n (xyz)bin_refine_factor : integer, default is (1,1,1); typically within [1-3]\n Controls the refinement on the cell sizes. Can have up to a 20% impact\n on runtime. \n\n Note: Since the counts in spheres calculation is symmetric\n in all 3 dimensions, the defaults are different from the clustering\n routines.\n\n max_cells_per_dim : integer, default is 100, typical values in [50-300]\n Controls the maximum number of cells per dimension. Total number of\n cells can be up to (max_cells_per_dim)^3. Only increase if ``rmax`` is\n too small relative to the boxsize (and increasing helps the runtime).\n\n c_api_timer : boolean (default false)\n Boolean flag to measure actual time spent in the C libraries. Here\n to allow for benchmarking and scaling studies.\n\n isa : string (default ``fastest``)\n Controls the runtime dispatch for the instruction set to use. Possible\n options are: [``fastest``, ``avx``, ``sse42``, ``fallback``]\n\n Setting isa to ``fastest`` will pick the fastest available instruction\n set on the current computer. However, if you set ``isa`` to, say,\n ``avx`` and ``avx`` is not available on the computer, then the code will\n revert to using ``fallback`` (even though ``sse42`` might be available).\n\n Unless you are benchmarking the different instruction sets, you should\n always leave ``isa`` to the default value. And if you *are*\n benchmarking, then the string supplied here gets translated into an\n ``enum`` for the instruction set defined in ``utils/defs.h``.\n\n\n Returns\n --------\n\n results : Numpy structured array\n A numpy structured array containing [rmax, pN[numpN]] with ``nbins``\n elements. Each row contains the maximum radius of the sphere and the\n ``numpN`` elements in the ``pN`` array. Each element of this array\n contains the probability that a sphere of radius ``rmax`` contains\n *exactly* ``N`` galaxies. For example, pN[0] (p0, the void probibility\n function) is the probability that a sphere of radius ``rmax`` contains 0\n galaxies.\n\n api_time : float, optional\n Only returned if ``c_api_timer`` is set. ``api_time`` measures only the time\n spent within the C library and ignores all python overhead.\n\n\n Example\n --------\n\n >>> from __future__ import print_function\n >>> import math\n >>> from os.path import dirname, abspath, join as pjoin\n >>> import numpy as np\n >>> import Corrfunc\n >>> from Corrfunc.mocks.vpf_mocks import vpf_mocks\n >>> rmax = 10.0\n >>> nbins = 10\n >>> numbins_to_print = nbins\n >>> nspheres = 10000\n >>> numpN = 6\n >>> threshold_ngb = 1 # does not matter since we have the centers\n >>> cosmology = 1 # LasDamas cosmology\n >>> centers_file = pjoin(dirname(abspath(Corrfunc.__file__)),\n ... \"../mocks/tests/data/\",\n ... \"Mr19_centers_xyz_forVPF_rmax_10Mpc.txt\")\n >>> N = 1000000\n >>> boxsize = 420.0\n >>> seed = 42\n >>> np.random.seed(seed)\n >>> X = np.random.uniform(-0.5*boxsize, 0.5*boxsize, N)\n >>> Y = np.random.uniform(-0.5*boxsize, 0.5*boxsize, N)\n >>> Z = np.random.uniform(-0.5*boxsize, 0.5*boxsize, N)\n >>> CZ = np.sqrt(X*X + Y*Y + Z*Z)\n >>> inv_cz = 1.0/CZ\n >>> X *= inv_cz\n >>> Y *= inv_cz\n >>> Z *= inv_cz\n >>> DEC = 90.0 - np.arccos(Z)*180.0/math.pi\n >>> RA = (np.arctan2(Y, X)*180.0/math.pi) + 180.0\n >>> results = vpf_mocks(rmax, nbins, nspheres, numpN, threshold_ngb,\n ... centers_file, cosmology,\n ... RA, DEC, CZ,\n ... RA, DEC, CZ,\n ... is_comoving_dist=True)\n >>> for r in results:\n ... print(\"{0:10.1f} \".format(r[0]), end=\"\")\n ... # doctest: +NORMALIZE_WHITESPACE\n ... for pn in r[1]:\n ... print(\"{0:10.3f} \".format(pn), end=\"\")\n ... # doctest: +NORMALIZE_WHITESPACE\n ... print(\"\") # doctest: +NORMALIZE_WHITESPACE\n 1.0 0.999 0.001 0.000 0.000 0.000 0.000\n 2.0 0.992 0.007 0.001 0.000 0.000 0.000\n 3.0 0.982 0.009 0.005 0.002 0.001 0.000\n 4.0 0.975 0.006 0.006 0.005 0.003 0.003\n 5.0 0.971 0.004 0.003 0.003 0.004 0.003\n 6.0 0.967 0.003 0.003 0.001 0.003 0.002\n 7.0 0.962 0.004 0.002 0.003 0.002 0.001\n 8.0 0.958 0.004 0.002 0.003 0.001 0.002\n 9.0 0.953 0.003 0.003 0.002 0.003 0.001\n 10.0 0.950 0.003 0.002 0.002 0.001 0.002\n\n \"\"\"\n\n try:\n from Corrfunc._countpairs_mocks import countspheres_vpf_mocks\\\n as vpf_extn\n except ImportError:\n msg = \"Could not import the C extension for the Counts-in-Cells \"\\\n \" (vpf)\"\n raise ImportError(msg)\n\n import numpy as np\n from warnings import warn\n from future.utils import bytes_to_native_str\n from Corrfunc.utils import translate_isa_string_to_enum,\\\n return_file_with_rbins, convert_to_native_endian,\\\n is_native_endian\n \n # Warn about non-native endian arrays\n if not all(is_native_endian(arr) for arr in [RA, DEC, CZ, RAND_RA, RAND_DEC, RAND_CZ]):\n warn('One or more input array has non-native endianness! A copy will be made with the correct endianness.')\n RA, DEC, CZ, RAND_RA, RAND_DEC, RAND_CZ = [convert_to_native_endian(arr) for arr in [RA, DEC, CZ, RAND_RA, RAND_DEC, RAND_CZ]]\n\n\n integer_isa = translate_isa_string_to_enum(isa)\n extn_results, api_time = vpf_extn(rmax, nbins, nspheres, numpN,\n threshold_ngb, centers_file,\n cosmology,\n RA, DEC, CZ,\n RAND_RA, RAND_DEC, RAND_CZ,\n verbose=verbose,\n is_comoving_dist=is_comoving_dist,\n xbin_refine_factor=xbin_refine_factor,\n ybin_refine_factor=ybin_refine_factor,\n zbin_refine_factor=zbin_refine_factor,\n max_cells_per_dim=max_cells_per_dim,\n c_api_timer=c_api_timer,\n isa=integer_isa)\n\n if extn_results is None:\n msg = \"RuntimeError occurred\"\n raise RuntimeError(msg)\n\n results_dtype = np.dtype([(bytes_to_native_str(b'rmax'), np.float),\n (bytes_to_native_str(b'pN'),\n (np.float, numpN))])\n nbin = len(extn_results)\n results = np.zeros(nbin, dtype=results_dtype)\n\n for ii, r in enumerate(extn_results):\n results['rmax'][ii] = r[0]\n if numpN == 1:\n results['pN'] = r[1]\n else:\n for j in range(numpN):\n results['pN'][ii][j] = r[1 + j]\n\n if not c_api_timer:\n return results\n else:\n return results, api_time\n\n\nif __name__ == '__main__':\n import doctest\n doctest.testmod()\n", "meta": {"hexsha": "5872de4bb2e7795e9d2ad42ad5718d038724f711", "size": 14131, "ext": "py", "lang": "Python", "max_stars_repo_path": "Corrfunc/mocks/vpf_mocks.py", "max_stars_repo_name": "rainwoodman/Corrfunc", "max_stars_repo_head_hexsha": "0474ae79cffe55463bd82708f9235cf03266672e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Corrfunc/mocks/vpf_mocks.py", "max_issues_repo_name": "rainwoodman/Corrfunc", "max_issues_repo_head_hexsha": "0474ae79cffe55463bd82708f9235cf03266672e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Corrfunc/mocks/vpf_mocks.py", "max_forks_repo_name": "rainwoodman/Corrfunc", "max_forks_repo_head_hexsha": "0474ae79cffe55463bd82708f9235cf03266672e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-11-21T06:36:14.000Z", "max_forks_repo_forks_event_max_datetime": "2019-11-21T06:36:14.000Z", "avg_line_length": 42.6918429003, "max_line_length": 130, "alphanum_fraction": 0.5945085274, "include": true, "reason": "import numpy", "num_tokens": 3754, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5273165233795671, "lm_q2_score": 0.35936414516010196, "lm_q1q2_score": 0.18949865165309507}} {"text": "from __future__ import division\nfrom __future__ import print_function\nfrom __future__ import absolute_import\n\nfrom future import standard_library\nstandard_library.install_aliases()\nfrom builtins import str\nfrom builtins import range\nfrom builtins import object\nfrom past.utils import old_div\nimport contextlib\nfrom datetime import date, timedelta\nimport glob\nimport numpy as np\nimport os\nimport shutil\nimport sys\nimport warnings\nimport urllib.request, urllib.error, urllib.parse\n\nfrom . import coord\nfrom .get_kpap import get_kpap\nfrom .get_apmsis import get_apmsis\nfrom hwm93py import gws5 as hwm93\nfrom hwm07py import hwmqt as hwm07\nfrom hwm14py import hwm14\nfrom igrf11py import igrf11syn as igrf11\nfrom igrf12py import igrf12syn as igrf12\nfrom iri12py import iri_sub as iri12\nfrom iri16py import iri_sub as iri16\nfrom iri16py import read_ig_rz, readapf107\nfrom msis00py import gtd7 as msis00\n\n# Pyglow version:\nVERSION = '1.4'\n\n# Global variable indicating if IRI 2016 has been initialized with the contents\n# of the ionosphere global index (ig_rz.dat) and Ap/F10.7 index (apf107.dat)\n# files. IRI 2016 initialization is required only once per session.\n__INIT_IRI16 = False\n\n# Directory of pyglow files:\nDIR_FILE = os.path.dirname(__file__)\n\n__version__ = VERSION\n\n\nclass Point(object):\n\n def __init__(\n self,\n dn,\n lat,\n lon,\n alt,\n user_ind=False,\n ):\n \"\"\"\n An instance of Point is the fundamental data object\n for running each climatological model.\n\n Instantation of a Point initializes member variables,\n and also grabs the corresponding geophysical indices.\n\n :param dn: datetime.datetime object\n :param lat: Latitude [degrees]\n :param lon: Longitude [degrees]\n :param alt: Altitude [km]\n :param user_ind: (optional) Boolean switch to calculate\n geophysical indices. If True, then it\n is up to the user to assign geophysical\n indices to the Point\n \"\"\"\n\n nan = float('nan')\n\n # Record input:\n self.dn = dn\n self.lat = lat\n self.lon = lon\n self.alt = alt\n\n # Error if date is too early\n if self.dn.year < 1932:\n raise ValueError('Date cannot be before 1932!')\n\n # Time variables:\n self.doy = self.dn.timetuple().tm_yday\n self.utc_sec = self.dn.hour*3600. + self.dn.minute*60.\n self.utc_hour = self.dn.hour\n self.slt_hour = np.mod(self.utc_sec/3600. + self.lon/15., 24)\n self.iyd = np.mod(self.dn.year, 100)*1000 + self.doy\n\n # For kp, ap function\n self.kp = nan\n self.ap = nan\n self.f107 = nan\n self.f107a = nan\n self.f107p = nan # previous day's F10.7\n self.kp_daily = nan\n self.ap_daily = nan\n self.apmsis = [nan, ] * 7\n self.dst = nan\n self.ae = nan\n\n # For iri:\n self.ne = nan\n ions = ['O+', 'H+', 'HE+', 'O2+', 'NO+']\n self.ni = {}\n for ion in ions:\n self.ni[ion] = nan\n\n self.Ti = nan\n self.Te = nan\n self.Tn_iri = nan\n\n self.NmF2 = nan\n self.hmF2 = nan\n\n # For msis:\n self.Tn_msis = nan\n self.nn = {}\n for neutral in ['HE', 'O', 'N2', 'O2', 'AR', 'H', 'N', 'O_anomalous']:\n self.nn[neutral] = nan\n self.rho = nan\n\n # For hwm 93/07:\n self.u = nan\n self.v = nan\n self.hwm_version = nan\n\n # For igrf:\n self.Bx = nan\n self.By = nan\n self.Bz = nan\n self.B = nan\n self.dip = nan\n self.dec = nan\n\n # For run_airglow:\n self.ag6300 = nan\n self.ag7774 = nan\n\n # Flag for user indices:\n self.user_ind = user_ind\n\n if not self.user_ind:\n # Call the indice models:\n self.get_indices()\n self.apmsis = get_apmsis(self.dn)\n\n def __str__(self):\n \"\"\" String representation of pyglow class \"\"\"\n\n pyglow_str = \"pyglow.Point: dn = {dn}, lat = {lat:3.2f} [deg], \"\\\n \"lon = {lon:3.2f} [deg], alt = {alt:3.2f} [km]\".format(\n dn=self.dn.strftime(\"%Y-%m-%d %H:%M:%S\"),\n lat=self.lat,\n lon=self.lon,\n alt=self.alt,\n )\n\n return pyglow_str\n\n def __repr__(self):\n \"\"\" Representation value of pyglow class \"\"\"\n\n pyglow_repr = \"pyglow.Point({dn}, {lat}, {lon}, {alt})\".format(\n dn=self.dn.__repr__(),\n lat=self.lat,\n lon=self.lon,\n alt=self.alt,\n )\n\n return pyglow_repr\n\n def get_indices(self):\n \"\"\"\n Retreives geophysical indices.\n \"\"\"\n self.kp, self.ap, self.f107, self.f107a, self.f107p, \\\n self.kp_daily, self.ap_daily, self.dst, self.ae \\\n = get_kpap(self.dn)\n return self\n\n @staticmethod\n def init_iri16():\n \"\"\"\n If required (depending on the global variable *__INIT_IRI16*),\n initialize IRI 2016. Return `True` if the model was\n initialized and `False` otherwise.\n \"\"\"\n if not globals()['__INIT_IRI16']:\n read_ig_rz()\n readapf107()\n globals()['__INIT_IRI16'] = True\n return True\n else:\n return False\n\n def run_iri(\n self,\n NmF2=None,\n hmF2=None,\n version=2016,\n compute_Ne=True,\n compute_Te_Ti=True,\n compute_Ni=True,\n debug=False,\n ):\n \"\"\"\n Run IRI model at point time/location and update the object state\n accordingly. If *NmF2* (in [cm^{-3}}]) or *hmF2* (in [km]) are\n specified, input them to the model (see documentation for\n IRI_SUB)). Override the model with *version* --- valid options\n are currently 2016 or 2012. Output debugging information if\n *debug* is true. The toggles *compute_Ne*, *compute_Te_Ti*,\n and *compute_Ni* control, respectively, whether electron\n density, electron and ion temperatures, and ion density are\n computed (restricting the model to only what is required can\n reduce run time) or set to `NaN`.\n \"\"\"\n\n if version == 2016:\n iri_data_stub = 'iri16_data/'\n iri = iri16\n init_iri = Point.init_iri16\n elif version == 2012:\n iri_data_stub = 'iri12_data/'\n iri = iri12\n init_iri = lambda: False\n else:\n raise ValueError(\n \"Invalid version of {} for IRI.\\n\".format(version) +\n \"Either 2016 (default) or 2012 is valid.\"\n )\n\n if debug:\n print(\"Version = {}\".format(version))\n\n jf = np.ones((50,)) # JF switches\n # Standard IRI model flags\n # | FORTRAN Index\n # |\n # V\n jf[3] = 0 # 4 B0,B1 other model-31\n jf[4] = 0 # 5 foF2 - URSI\n jf[5] = 0 # 6 Ni - RBV-10 & TTS-03\n jf[20] = 0 # 21 ion drift not computed\n jf[22] = 0 # 23 Te_topside (TBT-2011)\n jf[27] = 0 # 28 spreadF prob not computed\n jf[28] = 0 # 29 (29,30) => NeQuick\n jf[29] = 0 # 30\n # (Brian found a case that stalled IRI when on):\n jf[32] = 0 # 33 Auroral boundary model off\n jf[34] = 0 # 35 no foE storm update\n\n # Not standard, but outputs same as values as standard so not an issue\n jf[21] = 0 # 22 ion densities in m^-3 (not %)\n jf[33] = 0 # 34 turn messages off\n\n if not compute_Ne:\n jf[0] = 0\n\n if not compute_Te_Ti:\n jf[1] = 0\n\n if not compute_Ni:\n jf[2] = 0\n\n oarr = np.zeros((100,))\n\n if NmF2 is not None:\n # use specified F2 peak density\n jf[7] = 0\n oarr[0] = NmF2 * 100.**3 # IRI expects [m^{-3}]\n\n if hmF2 is not None:\n # use specified F2 peak height\n jf[8] = 0\n oarr[1] = hmF2\n\n if self.user_ind:\n # Set jf(25) switch to false (in Fortran)\n # which is jf[24] in Python\n jf[24] = 0\n\n # Set jf(32) switch to false (in Fortran)\n # which is jf[31] in Python\n jf[31] = 0\n\n # Store user indice for F10.7 in oarr:\n oarr[40] = self.f107\n\n # Store user index for F10.7 81 day average in oarr:\n oarr[45] = self.f107a\n\n # Reference:\n # https://github.com/timduly4/pyglow/issues/34#issuecomment-340645358\n\n # Get current directory:\n my_pwd = os.getcwd()\n\n # IRI data path. We need to change directories\n # into where the IRI data are located in order\n # to run IRI:\n iri_data_path = os.path.join(\n DIR_FILE,\n iri_data_stub,\n )\n if debug:\n print(\"Changing directory to {}\".format(iri_data_path))\n\n os.chdir(iri_data_path)\n init_iri()\n outf = iri(\n jf,\n 0,\n self.lat,\n self.lon,\n int(self.dn.year),\n -self.doy,\n (self.utc_sec/3600.+25.),\n self.alt,\n self.alt+1,\n 1,\n oarr,\n )\n os.chdir(my_pwd)\n\n if compute_Te_Ti:\n self.Te = outf[3, 0] # Electron temperature from IRI (K)\n self.Ti = outf[2, 0] # Ion temperature from IRI (K)\n else:\n self.Te = float('NaN')\n self.Ti = float('NaN')\n\n self.Tn_iri = outf[1, 0] # Neutral temperature from IRI (K)\n\n self.ne = outf[0, 0] # Electron density (m^-3)\n self.ni['O+'] = outf[4, 0] # O+ Density (%, or m^-3 with JF(22) = 0)\n self.ni['H+'] = outf[5, 0] # H+ Density (%, or m^-3 with JF(22) = 0)\n self.ni['HE+'] = outf[6, 0] # HE+ Density (%, or m^-3 with JF(22) = 0)\n self.ni['O2+'] = outf[7, 0] # O2+ Density (%, or m^-3 with JF(22) = 0)\n self.ni['NO+'] = outf[8, 0] # NO+ Density (%, or m^-3 with JF(22) = 0)\n\n self.NmF2 = oarr[0]\n self.hmF2 = oarr[1]\n\n if compute_Ne:\n self.ne = outf[0, 0] # Electron density (m^-3)\n else:\n self.ne = float('NaN')\n\n # Densities are now in cm^-3:\n self.ne = self.ne / 100.**3 # [items/cm^3]\n self.ni['O+'] = self.ni['O+'] / 100.**3 # [items/cm^3]\n self.ni['H+'] = self.ni['H+'] / 100.**3 # [items/cm^3]\n self.ni['HE+'] = self.ni['HE+'] / 100.**3 # [items/cm^3]\n self.ni['O2+'] = self.ni['O2+'] / 100.**3 # [items/cm^3]\n self.ni['NO+'] = self.ni['NO+'] / 100.**3 # [items/cm^3]\n self.NmF2 = self.NmF2 / 100.**3 # [items/cm^3]\n\n return self\n\n def run_msis(self, version=2000):\n \"\"\"\n Method to call MSIS model\n \"\"\"\n\n if version == 2000:\n msis = msis00\n else:\n raise ValueError(\n \"Invalid version of '{}' for MSIS.\\n\".format(version) +\n \"2000 (default) is valid.\"\n )\n\n [d, t] = msis(\n self.doy,\n self.utc_sec,\n self.alt,\n self.lat,\n np.mod(self.lon, 360),\n self.slt_hour,\n self.f107a,\n self.f107p,\n self.apmsis,\n 48,\n )\n self.Tn_msis = t[1] # neutral temperature from MSIS (K)\n\n self.nn = {}\n self.nn['HE'] = d[0] # [items/cm^3]\n self.nn['O'] = d[1] # [items/cm^3]\n self.nn['N2'] = d[2] # [items/cm^3]\n self.nn['O2'] = d[3] # [items/cm^3]\n self.nn['AR'] = d[4] # [items/cm^3]\n # [5] is below\n self.nn['H'] = d[6] # [items/cm^3]\n self.nn['N'] = d[7] # [items/cm^3]\n self.nn['O_anomalous'] = d[8] # [items/cm^3]\n\n self.rho = d[5] # total mass density [grams/cm^3]\n\n return self\n\n def run_hwm(self, version=2014):\n \"\"\"\n Wrapper to call various HWM models\n \"\"\"\n if version == 2014:\n self._run_hwm14()\n elif version == 2007:\n self._run_hwm07()\n elif version == 1993:\n self._run_hwm93()\n else:\n raise ValueError(\n \"Invalid version of {} for HWM.\\n\".format(version) +\n \"Either 2014 (default), 2007, or 1993 is valid.\"\n )\n\n return self\n\n def _run_hwm93(self):\n \"\"\"\n HWM 1993 Climatological model.\n\n \"\"\"\n\n w = hwm93(\n self.iyd,\n self.utc_sec,\n self.alt,\n self.lat,\n np.mod(self.lon, 360),\n self.slt_hour,\n self.f107a,\n self.f107,\n self.ap_daily,\n )\n self.v = w[0]\n self.u = w[1]\n self.hwm_version = '93'\n\n return self\n\n def _run_hwm07(self):\n \"\"\"\n HWM 2007 Climatological model.\n\n \"\"\"\n\n my_pwd = os.getcwd()\n\n hwm07_data_path = os.path.join(DIR_FILE, \"hwm07_data/\")\n\n os.chdir(hwm07_data_path)\n aphwm07 = [float('NaN'), self.ap]\n w = hwm07(\n self.iyd,\n self.utc_sec,\n self.alt,\n self.lat,\n np.mod(self.lon, 360),\n self.slt_hour,\n self.f107a,\n self.f107,\n aphwm07,\n )\n\n # Change back to original directory:\n os.chdir(my_pwd)\n self.v = w[0]\n self.u = w[1]\n self.hwm_version = '07'\n\n return self\n\n def _run_hwm14(self):\n \"\"\"\n HWM 2014 Climatological model.\n\n \"\"\"\n\n my_pwd = os.getcwd()\n\n hwm14_data_path = os.path.join(DIR_FILE, \"hwm14_data/\")\n\n os.chdir(hwm14_data_path)\n\n v, u = hwm14(\n self.iyd,\n self.utc_sec,\n self.alt,\n self.lat,\n np.mod(self.lon, 360),\n np.nan,\n np.nan,\n np.nan,\n [np.nan, self.ap],\n )\n\n # Change back to original directory:\n os.chdir(my_pwd)\n self.v = v\n self.u = u\n self.hwm_version = '14'\n\n return self\n\n def run_igrf(self, version=12):\n \"\"\"\n Run the IGRF climatological model\n \"\"\"\n\n if version == 12:\n igrf = igrf12\n elif version == 11:\n igrf = igrf11\n else:\n raise ValueError(\n \"Invalid version of {} for IGRF.\\n\".format(version) +\n \"Version 12 (default) and 11 are valid.\"\n )\n\n x, y, z, f = igrf(\n 0,\n self.dn.year,\n 1,\n self.alt,\n 90.-self.lat,\n np.mod(self.lon, 360),\n )\n\n h = np.sqrt(x**2 + y**2)\n dip = 180./np.pi * np.arctan2(z ,h)\n dec = 180./np.pi * np.arctan2(y, x)\n\n # Note that the changes here match\n # coordinate convention with other models\n # (i.e., HWM), that is:\n # (x -> east, y -> north, z -> up)\n #\n # IGRF gives (x -> north, y -> east, z -> down)\n warnings.warn(\n \"Caution: IGRF coordinates have been recently changed to\\n\" +\n \"Bx -> positive eastward\\n\" +\n \"By -> positive northward\\n\" +\n \" Bz -> positive upward\\n\"\n )\n self.Bx = y/1e9 # [T] (positive eastward) (note x/y switch here)\n self.By = x/1e9 # [T] (positive northward) (note x/y switch here)\n self.Bz = -z/1e9 # [T] (positive upward) (note negation here)\n self.B = f/1e9 # [T]\n\n self.dip = dip\n self.dec = dec\n\n return self\n\n def run_airglow(self):\n \"\"\"\n Computes airglow intensities\n\n\n After running, self.ag6300 has the 630.0-nm volume emission\n rate (ph/cm^3/s) and self.ag7774 has the 777.4-nm volume\n emission rate.\n\n\n History\n ------\n 9/9/13 -- implemented into pyglow\n based on Jonathan J. Makela's MATLAB\n and subsequent python code\n 9/13/16 -- added 7774 calculation\n \"\"\"\n\n # Let's see if IRI and MSIS have been executed.\n # If not, run the appropriate models:\n if np.isnan(self.ne):\n self.run_iri()\n if np.isnan(self.nn['O2']):\n self.run_msis()\n\n # Perform 630.0-nm calculation\n Ne = self.ne # electron density [cm^-3]\n Tn = self.Tn_msis # neutral temperature [K]\n Ti = self.Ti # ion temperature [K]\n Te = self.Te # electron temperature [K]\n O2 = self.nn['O2'] # O2 density [cm^-3]\n N2 = self.nn['N2'] # N2 density [cm^-3]\n O = self.nn['O'] # O density [cm^-3]\n\n te = Te/300.\n ti = Ti/300.\n\n # These coefs are from Link and Cogger, JGR 93(A9), 988309892, 1988\n K1_6300 = 3.23e-12*np.exp(3.72/ti - 1.87/ti**2)\n K2_6300 = 2.78e-13*np.exp(2.07/ti - 0.61/ti**2)\n K3_6300 = 2.0e-11*np.exp(111.8/Tn)\n K4_6300 = 2.9e-11*np.exp(67.5/Tn)\n K5_6300 = 1.6e-12*Te**0.91\n b6300 = 1.1\n a1D = 7.45e-3 # Corr. value from Link and Cogger, JGR, 94(A2), 1989\n a6300 = 5.63e-3 # Corr. value form Link and Cogger, JGR, 94(A2), 1989\n\n # Calculate O+ assuming mixture of ions\n # (also from Link and Cogger, 1988):\n a1 = 1.95e-7*te**-0.7\n a2 = 4.00e-7*te**-0.9\n Oplus = Ne/(1.+K2_6300*N2/a2/Ne + K1_6300*O2/a1/Ne)\n\n AGNumerator = a6300/a1D*b6300*K1_6300*Oplus*O2\n AGDenominator = 1.+(K3_6300*N2+K4_6300*O2+K5_6300*Ne)/a1D\n self.ag6300 = AGNumerator / AGDenominator\n\n # Perform the 777.4-nm calculation\n\n # These coefs are from a number of sources (see Makela's\n # dissertation Table 2.3 or Makela et al., \"Ionospheric\n # topography maps using multiple-wavelength all-sky images\",\n # JGR, 106, 29161--29174, 2001.)\n alpha1_7774 = 7.8e-13\n beta_7774 = 0.42\n K1_7774 = 1.3e-15\n K2_7774 = 1.5e-7\n K3_7774 = 1.4e-10\n\n # Makela shows that Oplus may be replaced by Ne below in his\n # dissertation (see p. 25) with only a 0.5% impact. Since we\n # have Oplus at hand, we use it in the calculation.\n V7774_rr = alpha1_7774 * Oplus * Ne\n\n V7774_ii_num = beta_7774 * K1_7774 * K2_7774 * O * Oplus * Ne\n V7774_ii_den = K2_7774 * Oplus + K3_7774 * O\n\n self.ag7774 = V7774_rr + V7774_ii_num / float(V7774_ii_den)\n\n return self\n\n\ndef _igrf_tracefield(dn, lat, lon, alt, target_ht, step):\n \"\"\"\n Helper function to trace along a magnetic field line using IGRF\n\n :param dn: datetime.datetime object of requested trace\n :param lat: Latitude [degrees]\n :param lon: Longitude [degrees]\n :param alt: Altitude [km]\n :param target_ht: Altitude to stop trace [km]\n :param step: Step size of trace [km]\n\n :return lla: (latitude, longitude, altitude) data structure of trace\n with dimentions [Nsteps x 3]\n\n \"\"\"\n\n # Go North:\n lla_north = _igrf_tracefield_hemis(\n dn,\n lat,\n lon,\n alt,\n target_ht,\n step,\n )\n\n # Go South:\n lla_south = _igrf_tracefield_hemis(\n dn,\n lat,\n lon,\n alt,\n target_ht,\n -step,\n )\n\n # Stack them together:\n lla = np.vstack(\n [\n np.flipud(lla_north)[:-1, :],\n lla_south,\n ]\n )\n\n return lla\n\n\ndef _igrf_tracefield_hemis(dn, lat, lon, alt, target_ht, step):\n \"\"\"\n Helper function to trace along a magnetic field line using IGRF\n for only one hemisphere\n\n :param dn: datetime.datetime object of requested trace\n :param lat: Latitude [degrees]\n :param lon: Longitude [degrees]\n :param alt: Altitude [km]\n :param target_ht: Altitude to stop trace [km]\n :param step: Step size of trace [km]\n\n :return lla: (latitude, longitude, altitude) data structure of trace\n with dimentions [Nsteps x 3]\n\n \"\"\"\n\n lat = float(lat)\n lon = float(lon)\n alt = float(alt)\n target_ht = float(target_ht)\n step = float(step)\n\n target_ht = target_ht*1e3\n step = step*1e3\n\n lla = np.array([lat, lon, alt*1e3])\n\n lla_field = lla\n\n \"\"\" Step 1: trace the field along a given direction \"\"\"\n TOLERANCE = 10 # [m]\n i = 0\n while (lla[2] > target_ht):\n # convert to ECEF:\n ecef = coord.lla2ecef(lla)\n\n # Grab field line information:\n p = Point(dn, lla[0], lla[1], lla[2]/1e3)\n p.run_igrf()\n\n # coordinates follow pyglow's convention:\n # (x -> east, y -> north, z -> up)\n\n N = p.By # North\n E = p.Bx # East\n D = -p.Bz # Down\n A = p.B # Total\n\n # Step along the field line\n ecef_new = ecef + coord.ven2ecef(\n lla,\n [-D/A*step, E/A*step, N/A*step],\n )\n\n # Convert to lla coordinates:\n lla = coord.ecef2lla(ecef_new)\n\n # add the field line to our collection:\n lla_field = np.vstack([lla_field, lla])\n i = i + 1\n\n \"\"\" Step 2: Make the last point close to target_ht \"\"\"\n while (abs(lla[2]-target_ht) > TOLERANCE):\n\n # Find out how much we need to step by:\n step = -np.sign(step)*abs(lla[2]-target_ht)\n\n ecef = coord.lla2ecef(lla)\n\n p = Point(dn, lla[0], lla[1], lla[2]/1e3)\n p.run_igrf()\n\n N = p.Bx # North\n E = p.By # East\n D = p.Bz # Down\n A = p.B # Total\n\n # Trace the field, but use the modified step:\n ecef_new = ecef + coord.ven2ecef(\n lla,\n np.array([-D/A, E/A, N/A]) * step/(-D/A),\n )\n\n # TODO : I changed this, is this correct?\n lla = coord.ecef2lla(ecef_new)\n\n # replace last entry with the point close to target_ht:\n lla_field[-1, :] = lla\n\n return lla_field\n\n\ndef Line(dn, lat, lon, alt, target_ht=90., step=15.):\n \"\"\"\n Return a list of instances of Point by\n tracing along the geomagnetic field line.\n\n pts = Line(dn, lat, lon, alt, target_ht=90., step=15.)\n\n :param dn: datetime.datetime object of requested trace\n :param lat: Latitude [degrees]\n :param lon: Longitude [degrees]\n :param alt: Altitude [km]\n :param target_ht: (optional) Altitude to stop trace [km]\n :param step: (optional) Step size of trace [km]\n\n \"\"\"\n llas = _igrf_tracefield(dn, lat, lon, alt, target_ht, step)\n pts = []\n\n for lla in llas:\n pts.append(\n Point(dn, lla[0], lla[1], lla[2]/1e3)\n )\n\n return pts\n\n\ndef update_kpap(years=None):\n '''\n Update the Kp and Ap indices used in pyglow.\n The files will be downloaded from noaa to your pyglow\n installation directory.\n\n update_kpap(years=None)\n\n :param years: (optional) a list of years to download.\n If this input is not provided, the full\n range of years starting from 1932 to the\n current year will be downloaded.\n '''\n\n # Load all data up until today\n if years is None:\n years = range(1932, date.today().year + 1)[::-1] # reverse\n\n pyglow_dir = os.path.join(DIR_FILE, \"kpap/\")\n\n for year in years:\n src = 'ftp://ftp.ngdc.noaa.gov/'\\\n + 'STP/GEOMAGNETIC_DATA/INDICES/KP_AP/%4i'\\\n % (year,)\n des = pyglow_dir + \"%4i\" % (year,)\n print(\"\\nDownloading\\n{src}\\nto\\n{des}\".format(src=src, des=des))\n try:\n with contextlib.closing(urllib.request.urlopen(src)) as r:\n with open(des, 'wb') as f:\n shutil.copyfileobj(r, f)\n except IOError as e:\n print(\n \"Failed downloading data for year {}.\"\n \"File does not exist ({})\".format(\n year,\n str(e),\n ),\n )\n\n\ndef update_dst(years=None):\n \"\"\"\n Update the Dst index files used in pyglow.\n The files will be downloaded from WDC Kyoto\n to your pyglow installation directory.\n\n update_dst(years=None)\n\n :param years: (optional) a list of years to download.\n If this input is not provided, the full\n range of years starting from 2005 to the\n current year will be downloaded. Pre-2005\n files are shipped with pyglow.\n \"\"\"\n\n def download_dst(year, month, des):\n \"\"\"\n Helper function to earch for the appropriate location\n and download the DST index file from WDC Kyoto for the\n given month and year. Save it to the specified file \"des\".\n Return True if successful, False if not.\n \"\"\"\n # There are three possible sources of data. Search for\n # them in the following order:\n # 1) Final\n # 2) Provisional\n # 3) Realtime\n year_month = '%i%02i' % (year, month)\n wgdc_fn = 'dst%s%02i.for.request' % (str(year)[2:], month)\n src_final = 'http://wdc.kugi.kyoto-u.ac.jp/dst_final/%s/%s' % \\\n (year_month, wgdc_fn)\n src_provisional = \\\n 'http://wdc.kugi.kyoto-u.ac.jp/dst_provisional/%s/%s' % \\\n (year_month, wgdc_fn)\n src_realtime = 'http://wdc.kugi.kyoto-u.ac.jp/dst_realtime/%s/%s' % \\\n (year_month, wgdc_fn)\n\n success = False\n for src in [src_final, src_provisional, src_realtime]:\n try:\n with contextlib.closing(urllib.request.urlopen(src)) as r:\n contents = r.read().decode('utf8')\n # If that succeeded, then the file exists\n print(\n \"\\nDownloading\\n{src}\\nto\\n{des}\".format(\n src=src,\n des=des\n )\n )\n with open(des, 'w') as f:\n f.write(contents)\n success = True\n break\n except urllib.error.HTTPError:\n pass\n return success\n\n # Read files from 2005 until today. Pre-2005\n # files are shipped with pyglow.\n if years is None:\n years = list(range(2005, date.today().year + 1))[::-1] # reversed\n pyglow_dir = os.path.join(DIR_FILE, \"dst/\")\n\n for year in years:\n for month in range(1, 13):\n des = '%s%i%02i' % (pyglow_dir, year, month)\n download_dst(year, month, des)\n\n return\n\n\ndef update_ae(years=None):\n '''\n Update the AE index files used in pyglow.\n The files will be downloaded from WDC Kyoto\n to your pyglow installation directory.\n\n update_ae(years=None)\n\n :param years: (optional) a list of years to download.\n If this input is not provided, the full\n range of years starting from 2005 to the\n current year will be downloaded. Pre-2005\n files are shipped with pyglow.\n '''\n\n def download_ae(year, month, des):\n '''\n Helper function to earch for the appropriate location\n and download the AE index file from WDC Kyoto for the\n given month and year. Save it to the specified file \"des\".\n Return True if successful, False if not.\n '''\n # There are three possible sources of data. Search for\n # them in the following order:\n # 1) Final\n # 2) Provisional\n # 3) Realtime\n year_month = '%i%02i' % (year, month)\n wgdc_fn = 'ae%s%02i.for.request' % (str(year)[2:], month)\n src_provisional = \\\n 'http://wdc.kugi.kyoto-u.ac.jp/ae_provisional/%s/%s' % \\\n (year_month, wgdc_fn)\n src_realtime = 'http://wdc.kugi.kyoto-u.ac.jp/ae_realtime/%s/%s' % \\\n (year_month, wgdc_fn)\n\n success = False\n for src in [src_provisional, src_realtime]:\n try:\n with contextlib.closing(urllib.request.urlopen(src)) as r:\n contents = r.readlines()\n # If that succeeded, then the file exists\n print(\n \"\\nDownloading\\n{src}\\nto\\n{des}\".format(\n src=src,\n des=des,\n )\n )\n with open(des, 'w') as f:\n # this shrinks the filesize to hourly\n for c in contents:\n c = c.decode('utf8')\n f.write(\n \"%s%s%s\\n\" % (c[12:18], c[19:21], c[394:400])\n )\n success = True\n break\n except urllib.error.HTTPError:\n pass\n return success\n\n # Read files from 2000 until today. Pre-2000\n # files are shipped with pyglow.\n if years is None:\n years = list(range(2000, date.today().year + 1))[::-1] # reversed\n pyglow_dir = os.path.join(DIR_FILE, \"ae/\")\n\n for year in years:\n for month in range(1, 13):\n des = '%s%i%02i' % (pyglow_dir, year, month)\n download_ae(year, month, des)\n\n\ndef update_indices(years=None):\n '''\n Update all geophysical indices (e.g., KP, DST, AE).\n\n update_indices(years=None)\n\n :param years: (optional) a list of years to download.\n If this input is not provided, default\n values will be used.\n '''\n\n update_kpap(years=years)\n update_dst(years=years)\n update_ae(years=years)\n\n return\n", "meta": {"hexsha": "30f90defea366450f18f134a6c378f7ef8fb6a36", "size": 29705, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/pyglow/pyglow.py", "max_stars_repo_name": "JinYunfei/pyglow", "max_stars_repo_head_hexsha": "9829acc82d69ce5d9049b3c85286b4e51201d6c7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-12-23T15:41:07.000Z", "max_stars_repo_stars_event_max_datetime": "2018-12-23T15:41:07.000Z", "max_issues_repo_path": "src/pyglow/pyglow.py", "max_issues_repo_name": "JinYunfei/pyglow", "max_issues_repo_head_hexsha": "9829acc82d69ce5d9049b3c85286b4e51201d6c7", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/pyglow/pyglow.py", "max_forks_repo_name": "JinYunfei/pyglow", "max_forks_repo_head_hexsha": "9829acc82d69ce5d9049b3c85286b4e51201d6c7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.4108910891, "max_line_length": 81, "alphanum_fraction": 0.5218650059, "include": true, "reason": "import numpy", "num_tokens": 8484, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5273165085228825, "lm_q2_score": 0.35936414516010196, "lm_q1q2_score": 0.18949864631413527}} {"text": "import re\nimport os\nimport sys\nimport RNA\nimport gzip\nimport pickle\nimport random\nimport subprocess\nimport numpy as np\nimport scipy.sparse as sp\nfrom functools import partial\nimport forgi.graph.bulge_graph as fgb\n\nbasedir = os.path.split(os.path.dirname(os.path.abspath(__file__)))[0]\nsys.path.append(basedir)\nsys.path.append(os.path.dirname(os.path.abspath(__file__)))\n\nfrom lib.general_utils import Pool\n\n\ndef adj_to_bias(adj, nhood=1):\n # [batch_size, nb_nodes, nb_nodes]\n mt = np.stack([np.eye(adj.shape[1])] * adj.shape[0], axis=0) # self-connection\n for _ in range(nhood):\n mt = np.matmul(mt, (adj + np.stack([np.eye(adj.shape[1])] * adj.shape[0], axis=0)))\n mt = np.greater(mt, 0.).astype(np.float32)\n return -1e9 * (1.0 - mt)\n\n\n# >>>> equilibrium probability using RNAplfold >>>>>>>\n\ndef fold_seq_rnashapes(seq, winsize, iterations=100):\n stride = winsize // 4\n cmd = 'echo %s | RNAshapes -w %d -W %d -i %d -A -t 1 -c %d -M 0 -o 1' % (seq, winsize, stride, iterations, 10)\n ret = subprocess.check_output(cmd, shell=True)\n lines = re.sub(' +', ' ', ret.decode('utf-8')).rstrip().split('\\n')\n\n # assemble adjacency matrix\n row_col, link, prob, norm = [], [], [], []\n length = len(seq)\n for i in range(length):\n if i != length - 1:\n row_col.append((i, i + 1))\n link.append(1)\n prob.append(1.)\n norm.append(1)\n if i != 0:\n row_col.append((i, i - 1))\n link.append(2)\n prob.append(1.)\n norm.append(1)\n for line in lines:\n if len(line) > 0:\n if line[0] >= '0' and line[0] <= '9':\n # indices\n start_idx = int(line.split(' ')[0]) - 1\n local_idx = []\n elif line[0] in ['(', '.', ')']:\n # secondary structures\n tokens = line.split(' ')\n struct = tokens[0]\n probability = float(tokens[2])\n\n bg = fgb.BulgeGraph.from_dotbracket(struct)\n for i, ele in enumerate(struct):\n if ele == '(':\n pair_from = i + start_idx\n pair_to = bg.pairing_partner(i + 1) - 1 + start_idx\n if not (pair_from, pair_to) in row_col:\n row_col.append((pair_from, pair_to))\n link.append(3)\n prob.append(probability)\n norm.append(1)\n local_idx.append((pair_from, pair_to))\n # symmetric\n row_col.append((pair_to, pair_from))\n link.append(4)\n prob.append(probability)\n norm.append(1)\n else:\n idx = row_col.index((pair_from, pair_to))\n prob[idx] += probability\n prob[idx + 1] += probability\n if not (pair_from, pair_to) in local_idx:\n local_idx.append((pair_from, pair_to))\n norm[idx] += 1\n norm[idx + 1] += 1\n\n prob = np.array(prob) / np.array(norm)\n print(norm)\n return (sp.csr_matrix((link, (np.array(row_col)[:, 0], np.array(row_col)[:, 1])), shape=(length, length)),\n sp.csr_matrix((prob, (np.array(row_col)[:, 0], np.array(row_col)[:, 1])), shape=(length, length)),)\n\n\n# >>>> equilibrium probability using RNAplfold >>>>>>>\n# when on compute canada, make sure this is happening on the compute nodes\n\ndef fold_seq_rnaplfold(seq, w, l, cutoff, no_lonely_bps):\n np.random.seed(random.seed())\n name = str(np.random.rand())\n # Call RNAplfold on command line.\n no_lonely_bps_str = \"\"\n if no_lonely_bps:\n no_lonely_bps_str = \"--noLP\"\n cmd = 'echo %s | RNAplfold -W %d -L %d -c %.4f --id-prefix %s %s' % (seq, w, l, cutoff, name, no_lonely_bps_str)\n ret = subprocess.call(cmd, shell=True)\n\n # assemble adjacency matrix\n row_col, link, prob = [], [], []\n length = len(seq)\n for i in range(length):\n if i != length - 1:\n row_col.append((i, i + 1))\n link.append(1)\n prob.append(1.)\n if i != 0:\n row_col.append((i, i - 1))\n link.append(2)\n prob.append(1.)\n # Extract base pair information.\n name += '_0001_dp.ps'\n start_flag = False\n with open(name) as f:\n for line in f:\n if start_flag:\n values = line.split()\n if len(values) == 4:\n source_id = int(values[0]) - 1\n dest_id = int(values[1]) - 1\n avg_prob = float(values[2])\n # source_id < dest_id\n row_col.append((source_id, dest_id))\n link.append(3)\n prob.append(avg_prob ** 2)\n row_col.append((dest_id, source_id))\n link.append(4)\n prob.append(avg_prob ** 2)\n if 'start of base pair probability data' in line:\n start_flag = True\n # delete RNAplfold output file.\n os.remove(name)\n # placeholder for dot-bracket structure\n return (sp.csr_matrix((link, (np.array(row_col)[:, 0], np.array(row_col)[:, 1])), shape=(length, length)),\n sp.csr_matrix((prob, (np.array(row_col)[:, 0], np.array(row_col)[:, 1])), shape=(length, length)),)\n\n\n# >>>> Boltzmann sampling using RNAsubopt >>>>>>>\n\ndef sample_one_seq(seq, passes=10):\n max_len = len(seq)\n adj_mat_tmp = np.zeros((max_len, max_len), dtype=np.int32)\n for i in range(max_len):\n if i != max_len - 1:\n adj_mat_tmp[i, i + 1] = 1\n if i != 0:\n adj_mat_tmp[i, i - 1] = 2\n cmd = 'echo \"%s\" | RNAsubopt --stochBT=%d' % (seq, passes)\n all_struct = subprocess.check_output(cmd, shell=True). \\\n decode('utf-8').rstrip().split('\\n')[1:]\n all_adj_mat = []\n for struct in all_struct:\n adj_mat = adj_mat_tmp.copy()\n bg = fgb.BulgeGraph.from_dotbracket(struct)\n for i, ele in enumerate(struct):\n if ele == '(':\n adj_mat[i, bg.pairing_partner(i + 1) - 1] = 3\n elif ele == ')':\n adj_mat[i, bg.pairing_partner(i + 1) - 1] = 4\n all_adj_mat.append(adj_mat)\n all_adj_mat = np.stack(all_adj_mat, axis=0)\n return all_adj_mat\n\n\ndef fold_seq_subopt(seq, probabilistic=False, sampling_amount=1000):\n # RNAfold is only suitable for short RNA sequences within 100 nucleotides\n if probabilistic:\n # sampling from a boltzmann ensemble\n cmd = 'echo \"%s\" | RNAsubopt --stochBT=%d' % (seq, sampling_amount)\n struct_list = subprocess.check_output(cmd, shell=True). \\\n decode('utf-8').rstrip().split('\\n')[1:]\n else:\n struct_list, energy_list = [], []\n\n def collect_subopt_result(structure, energy, *args):\n if not structure == None:\n struct_list.append(structure)\n energy_list.append(energy)\n\n # Enumerate all structures 100 dacal/mol = 1 kcal/mol around\n # default deltaEnergy is the MFE\n RNA.fold_compound(seq).subopt_cb(100, collect_subopt_result, None)\n\n # sort\n struct_list = list(np.array(struct_list)[np.argsort(energy_list)])\n\n # merging all structures into a single adjacency matrix\n # probability returning two matrices\n matrix = adj_mat_subopt(struct_list, probabilistic)\n # process the structures\n return structural_content(struct_list), matrix\n\n\ndef structural_content(struct_list):\n size = len(struct_list)\n length = len(struct_list[0])\n content = np.zeros((length, 3), dtype=np.int32)\n for i in range(length):\n for j in range(size):\n idx = '.()'.index(struct_list[j][i])\n content[i][idx] += 1\n return content.astype(np.float32) / size\n\n\ndef adj_mat_subopt(struct_list, probabilistic):\n # create sparse matrix\n row_col, data = [], []\n length = len(struct_list[0])\n counts = []\n for i in range(length):\n if i != length - 1:\n row_col.append((i, i + 1))\n data.append(1)\n counts.append(0)\n if i != 0:\n row_col.append((i, i - 1))\n data.append(2)\n counts.append(0)\n if probabilistic:\n for struct in struct_list:\n bg = fgb.BulgeGraph.from_dotbracket(struct)\n for i, ele in enumerate(struct):\n if ele == '(':\n if not (i, bg.pairing_partner(i + 1) - 1) in row_col:\n row_col.append((i, bg.pairing_partner(i + 1) - 1))\n data.append(3)\n counts.append(1)\n else:\n idx = row_col.index((i, bg.pairing_partner(i + 1) - 1))\n counts[idx] += 1\n elif ele == ')':\n if not (i, bg.pairing_partner(i + 1) - 1) in row_col:\n row_col.append((i, bg.pairing_partner(i + 1) - 1))\n data.append(4)\n counts.append(1)\n else:\n idx = row_col.index((i, bg.pairing_partner(i + 1) - 1))\n counts[idx] += 1\n # normalize each row into probabilities\n for i in range(len(row_col)):\n if counts[i] > 0:\n # have to be a hydrogen bond\n counts[i] /= len(struct_list)\n else:\n # covalent bond that forms the stem\n counts[i] = 1.\n return (sp.csr_matrix((data, (np.array(row_col)[:, 0], np.array(row_col)[:, 1])), shape=(length, length)),\n sp.csr_matrix((counts, (np.array(row_col)[:, 0], np.array(row_col)[:, 1])), shape=(length, length)),)\n else:\n for struct in struct_list:\n bg = fgb.BulgeGraph.from_dotbracket(struct)\n for i, ele in enumerate(struct):\n if ele == '(':\n if not (i, bg.pairing_partner(i + 1) - 1) in row_col:\n row_col.append((i, bg.pairing_partner(i + 1) - 1))\n data.append(3)\n elif ele == ')':\n if not (i, bg.pairing_partner(i + 1) - 1) in row_col:\n row_col.append((i, bg.pairing_partner(i + 1) - 1))\n data.append(4)\n return sp.csr_matrix((data, (np.array(row_col)[:, 0], np.array(row_col)[:, 1])),\n shape=(length, length))\n\n\n# >>>> MFE structure using RNAfold >>>>>>>\n\ndef fold_seq_rnafold(seq):\n '''fold sequence using RNAfold'''\n struct = RNA.fold(seq)[0]\n matrix = adj_mat(struct)\n return structural_content([struct]), matrix\n\n\ndef adj_mat(struct):\n # create sparse matrix\n row_col, data = [], []\n length = len(struct)\n for i in range(length):\n if i != length - 1:\n row_col.append((i, i + 1))\n data.append(1)\n if i != 0:\n row_col.append((i, i - 1))\n data.append(2)\n bg = fgb.BulgeGraph.from_dotbracket(struct)\n for i, ele in enumerate(struct):\n if ele == '(':\n row_col.append((i, bg.pairing_partner(i + 1) - 1))\n data.append(3)\n elif ele == ')':\n row_col.append((i, bg.pairing_partner(i + 1) - 1))\n data.append(4)\n return sp.csr_matrix((data, (np.array(row_col)[:, 0], np.array(row_col)[:, 1])),\n shape=(length, length))\n\n\ndef augment_features(path):\n '''\n try to avoid this as much as possible.\n we are mostly interested in an end-to-end learning scenario\n '''\n # region type: 101 x 5\n region_types = np.loadtxt(gzip.open(os.path.join(path, \"matrix_RegionType.tab.gz\")), skiprows=1)\n assert (region_types.shape[1] == 505) # 4 region types\n region_types = np.transpose(region_types.reshape((region_types.shape[0], 5, 101)), [0, 2, 1])\n\n coclip = np.loadtxt(gzip.open(os.path.join(path, \"matrix_Cobinding.tab.gz\")), skiprows=1)\n assert (coclip.shape[1] % 101 == 0)\n nb_exprs = coclip.shape[1] // 101\n coclip = np.transpose(coclip.reshape((coclip.shape[0], nb_exprs, 101)), [0, 2, 1])\n\n return np.concatenate([region_types, coclip], axis=-1)\n\n\ndef load_fasta_format(file):\n all_id = []\n all_seq = []\n seq = ''\n for row in file:\n if type(row) is bytes:\n row = row.decode('utf-8')\n row = row.rstrip()\n if row.startswith('>'):\n all_id.append(row)\n if seq != '':\n all_seq.append(seq)\n seq = ''\n else:\n seq += row\n all_seq.append(seq)\n return all_id, all_seq\n\n\ndef load_dotbracket(filepath, pool=None, fold_algo='rnafold', probabilistic=False, **kwargs):\n prefix = '%s_%s_' % (fold_algo, probabilistic)\n if fold_algo == 'rnaplfold' or fold_algo == 'rnashapes':\n prefix += '%d_' % (kwargs.get('w', 150))\n full_path = os.path.join(os.path.dirname(filepath), '{}structures.npy'.format(prefix))\n if not os.path.exists(full_path):\n print(full_path, 'is missing. Begin folding from scratch.')\n fold_rna_from_file(filepath, pool, fold_algo, probabilistic, **kwargs)\n # load secondary structures\n all_struct = np.load(\n os.path.join(os.path.dirname(filepath), '{}structures.npy'.format(prefix)))\n return all_struct\n\n\ndef load_mat(filepath, pool=None, fold_algo='rnafold', probabilistic=False, **kwargs):\n prefix = '%s_%s_' % (fold_algo, probabilistic)\n # folding length is crucial hyperparam for local RNA folding, therefore should be marked\n if fold_algo == 'rnaplfold' or fold_algo == 'rnashapes':\n prefix += '%d_' % (kwargs.get('w', 150))\n if kwargs.get('modify_leaks', False):\n # this will make sure we load the modified sequences\n # incorrect secondary structure may still give away information / data statistics\n prefix = 'modified_' + prefix\n\n if not os.path.exists(\n os.path.join(os.path.dirname(filepath), '{}rel_mat.obj'.format(prefix))) or probabilistic and \\\n not os.path.exists(os.path.join(os.path.dirname(filepath), '{}prob_mat.obj'.format(prefix))):\n print('adj mat or prob mat is missing. Begin folding from scratch.')\n fold_rna_from_file(filepath, pool, fold_algo, probabilistic, **kwargs)\n\n load_dense = kwargs.get('load_dense', True)\n sp_rel_matrix = pickle.load(open(os.path.join(os.path.dirname(filepath), '{}rel_mat.obj'.format(prefix)), 'rb'))\n if load_dense:\n adjacency_matrix = np.array([mat.toarray() for mat in sp_rel_matrix])\n else:\n adjacency_matrix = np.array(sp_rel_matrix)\n\n if probabilistic:\n sp_prob_matrix = pickle.load(\n open(os.path.join(os.path.dirname(filepath), '{}prob_mat.obj'.format(prefix)), 'rb'))\n if load_dense:\n probability_matrix = np.array([mat.toarray() for mat in sp_prob_matrix])\n else:\n probability_matrix = np.array(sp_prob_matrix)\n matrix = (adjacency_matrix, probability_matrix)\n else:\n matrix = adjacency_matrix\n\n return matrix\n\n\ndef load_seq(filepath):\n if filepath.endswith('.fa'):\n file = open(filepath, 'r')\n else:\n file = gzip.open(filepath, 'rb')\n\n all_id, all_seq = load_fasta_format(file)\n return all_id, all_seq\n\n\ndef fold_rna_from_file(filepath, p=None, fold_algo='rnafold', probabilistic=False, **kwargs):\n assert (fold_algo in ['rnafold', 'rnasubopt', 'rnaplfold'])\n if fold_algo == 'rnafold':\n assert (probabilistic is False)\n if fold_algo == 'rnaplfold':\n assert (probabilistic is True)\n print('Parsing', filepath)\n _, all_seq = load_seq(filepath)\n\n # compatible with already computed structures with RNAfold\n prefix = '%s_%s_' % (fold_algo, probabilistic)\n if fold_algo == 'rnaplfold' or fold_algo == 'rnashapes':\n prefix += '%d_' % (kwargs.get('w', 150))\n if kwargs.get('modify_leaks', False):\n prefix = 'modified_' + prefix\n\n if p is None:\n pool = Pool(int(os.cpu_count() * 2 / 3))\n else:\n pool = p\n\n if fold_algo == 'rnafold':\n fold_func = fold_seq_rnafold\n res = list(pool.imap(fold_func, all_seq))\n sp_rel_matrix = []\n structural_content = []\n for struct, matrix in res:\n structural_content.append(struct)\n sp_rel_matrix.append(matrix)\n np.save(os.path.join(os.path.dirname(filepath), '{}structures.npy'.format(prefix)),\n np.array(structural_content)) # [size, length, 3]\n pickle.dump(sp_rel_matrix,\n open(os.path.join(os.path.dirname(filepath), '{}rel_mat.obj'.format(prefix)), 'wb'))\n elif fold_algo == 'rnasubopt':\n fold_func = partial(fold_seq_subopt, fold_algo=fold_algo, probabilistic=probabilistic)\n res = list(pool.imap(fold_func, all_seq))\n sp_rel_matrix = []\n sp_prob_matrix = []\n structural_content = []\n for struct, matrix in res:\n structural_content.append(struct)\n if probabilistic:\n rel_mat, prob_mat = matrix\n sp_prob_matrix.append(prob_mat)\n else:\n rel_mat = matrix\n sp_rel_matrix.append(rel_mat)\n np.save(os.path.join(os.path.dirname(filepath), '{}structures.npy'.format(prefix)),\n np.array(structural_content)) # [size, length, 3]\n pickle.dump(sp_rel_matrix,\n open(os.path.join(os.path.dirname(filepath), '{}rel_mat.obj'.format(prefix)), 'wb'))\n if probabilistic:\n pickle.dump(sp_prob_matrix,\n open(os.path.join(os.path.dirname(filepath), '{}prob_mat.obj'.format(prefix)), 'wb'))\n elif fold_algo == 'rnaplfold':\n winsize = kwargs.get('w', 150)\n print('running rnaplfold with winsize %d' % (winsize))\n fold_func = partial(fold_seq_rnaplfold, w=winsize, l=min(winsize, 150), cutoff=1e-4, no_lonely_bps=True)\n res = list(pool.imap(fold_func, all_seq))\n sp_rel_matrix = []\n sp_prob_matrix = []\n for rel_mat, prob_mat in res:\n sp_rel_matrix.append(rel_mat)\n sp_prob_matrix.append(prob_mat)\n pickle.dump(sp_rel_matrix,\n open(os.path.join(os.path.dirname(filepath), '{}rel_mat.obj'.format(prefix)), 'wb'))\n pickle.dump(sp_prob_matrix,\n open(os.path.join(os.path.dirname(filepath), '{}prob_mat.obj'.format(prefix)), 'wb'))\n else:\n raise ValueError('Supported folding algorithms are ' + ', '.join(['rnafold', 'rnasubopt', 'rnaplfold']))\n\n if p is None:\n pool.close()\n pool.join()\n\n print('Parsing', filepath, 'finished')\n\n\ndef fold_and_check_hairpin(seq, return_label=True):\n regex = r'^\\(\\(\\(\\.\\.\\.\\)\\)\\)[\\.\\(]|[\\.\\)]\\(\\(\\(\\.\\.\\.\\)\\)\\)$|[\\.\\)]\\(\\(\\(\\.\\.\\.\\)\\)\\)|\\(\\(\\(\\.\\.\\.\\)\\)\\)[\\.\\(]'\n '''return label, or an annotation over the entire seq'''\n '''fold rna and check if the structure contains a hairpin of 3 loose nucleotide connected by a stem of 3 basepairs'''\n struct = RNA.fold(seq)[0]\n mat = adj_mat(struct)\n if return_label:\n match = re.search(regex, struct)\n return struct, mat, int(match is not None)\n else:\n annotation = [0] * len(seq)\n for match in re.finditer(regex, struct):\n start_idx = struct[match.start(): match.end()].index('(((...)))') + match.start()\n annotation[start_idx:start_idx + 9] = [1] * 9\n return struct, mat, annotation\n\n\ndef fold_and_check_element(seq, element_symbol, return_label=True):\n '''simply use forgi to annotate the whole string and check if it contains the element'''\n '''return label, or an annotation over the entire seq'''\n '''fold rna and check if the structure contains a hairpin of 3 loose nucleotide connected by a stem of 3 basepairs'''\n struct = RNA.fold(seq)[0]\n mat = adj_mat(struct)\n bg = fgb.BulgeGraph.from_dotbracket(struct)\n annotation = bg.to_element_string(())\n if return_label:\n return struct, mat, int(element_symbol in annotation)\n else:\n return struct, mat, [int(element_symbol == c) for c in annotation]\n\n\ndef generate_hairpin_dataset(n, length, p=None, return_label=True):\n '''\n generate toy dataset\n positive examples: RNA sequences that contain specific structural motifs:\n 1. a hairpin of three nucleotides connected by a stem of 3 base-pairs\n 2. nucleotidal composition does not matter.\n negative examples: RNA sequences that do not contain this specific motifs\n '''\n data_path = os.path.join(basedir, 'Data/toy-data/hairpin/%s' % ('label' if return_label else 'annotation'))\n if not os.path.exists(data_path):\n os.makedirs(data_path)\n\n if os.path.exists(os.path.join(data_path, 'seq-and-struct.fa')) and \\\n os.path.exists(os.path.join(data_path, 'adj_mat.obj')):\n all_labels = []\n all_seqs = []\n all_struct = []\n with open(os.path.join(data_path, 'seq-and-struct.fa'), 'r') as file:\n for line in file:\n if line[0] == '>':\n label = line.rstrip().split(' ')[-1].split(':')[-1]\n if return_label:\n all_labels.append(int(label))\n else:\n all_labels.append([int(c) for c in label.split(',')])\n elif line[0] in 'ACGT':\n all_seqs.append(['ACGT'.index(c) for c in line.rstrip()])\n elif line[0] in '.()':\n all_struct.append(['.()'.index(c) for c in line.rstrip()])\n\n all_seqs = np.array(all_seqs)\n sp_adj_matrix = pickle.load(open(os.path.join(data_path, 'adj_mat.obj'), 'rb'))\n else:\n all_seqs = np.zeros((n, length), dtype=int)\n for j in range(length):\n all_seqs[:, j] = np.random.choice([0, 1, 2, 3], n, p=[0.25, 0.25, 0.25, 0.25])\n seqs_str = [''.join(['ACGT'[c] for c in seq]) for seq in all_seqs]\n\n if p is None:\n pool = Pool(8)\n else:\n pool = p\n\n res = list(pool.imap(partial(fold_and_check_hairpin, return_label=return_label), seqs_str))\n\n sp_adj_matrix = []\n all_labels = []\n all_struct = []\n with open(os.path.join(data_path, 'seq-and-struct.fa'), 'w') as file:\n for seq, (struct, mat, label) in zip(seqs_str, res):\n file.writelines('> label:%s\\n%s\\n%s\\n' %\n (label if return_label else ','.join([str(c) for c in label]), seq, struct))\n sp_adj_matrix.append(mat)\n all_labels.append(label)\n all_struct.append(['.()'.index(c) for c in struct])\n\n pickle.dump(sp_adj_matrix, open(os.path.join(data_path, 'adj_mat.obj'), 'wb'))\n if p is None:\n pool.close()\n pool.join()\n\n all_labels = np.array(all_labels)\n adjacency_matrix = np.stack([mat.toarray() for mat in sp_adj_matrix], axis=0)\n all_struct = np.array(all_struct)\n return all_seqs, adjacency_matrix, all_labels, all_struct\n\n\ndef generate_element_dataset(n, length, element_symbol, p=None, return_label=True):\n '''\n generate toy dataset\n positive examples: RNA sequences that contain specific structural motifs:\n 1. a hairpin of three nucleotides connected by a stem of 3 base-pairs\n 2. nucleotidal composition does not matter.\n negative examples: RNA sequences that do not contain this specific motifs\n '''\n assert (len(element_symbol) == 1 and str.isalpha(element_symbol))\n data_path = os.path.join(basedir,\n 'Data/toy-data/%s/%s' % (element_symbol, 'label' if return_label else 'annotation'))\n if not os.path.exists(data_path):\n os.makedirs(data_path)\n\n if os.path.exists(os.path.join(data_path, 'seq-and-struct.fa')) and \\\n os.path.exists(os.path.join(data_path, 'adj_mat.obj')):\n all_labels = []\n all_seqs = []\n all_struct = []\n with open(os.path.join(data_path, 'seq-and-struct.fa'), 'r') as file:\n for line in file:\n if line[0] == '>':\n label = line.rstrip().split(' ')[-1].split(':')[-1]\n if return_label:\n all_labels.append(int(label))\n else:\n all_labels.append([int(c) for c in label.split(',')])\n elif line[0] in 'ACGT':\n all_seqs.append(['ACGT'.index(c) for c in line.rstrip()])\n elif line[0] in '.()':\n all_struct.append(['.()'.index(c) for c in line.rstrip()])\n\n all_seqs = np.array(all_seqs)\n sp_adj_matrix = pickle.load(open(os.path.join(data_path, 'adj_mat.obj'), 'rb'))\n else:\n all_seqs = np.zeros((n, length), dtype=int)\n for j in range(length):\n all_seqs[:, j] = np.random.choice([0, 1, 2, 3], n, p=[0.25, 0.25, 0.25, 0.25])\n seqs_str = [''.join(['ACGT'[c] for c in seq]) for seq in all_seqs]\n\n if p is None:\n pool = Pool(8)\n else:\n pool = p\n\n res = list(pool.imap(partial(fold_and_check_element,\n element_symbol=element_symbol,\n return_label=return_label), seqs_str))\n\n sp_adj_matrix = []\n all_labels = []\n all_struct = []\n with open(os.path.join(data_path, 'seq-and-struct.fa'), 'w') as file:\n for seq, (struct, mat, label) in zip(seqs_str, res):\n file.writelines('> label:%s\\n%s\\n%s\\n' %\n (label if return_label else ','.join([str(c) for c in label]), seq, struct))\n sp_adj_matrix.append(mat)\n all_labels.append(label)\n all_struct.append(['.()'.index(c) for c in struct])\n\n pickle.dump(sp_adj_matrix, open(os.path.join(data_path, 'adj_mat.obj'), 'wb'))\n if p is None:\n pool.close()\n pool.join()\n\n all_labels = np.array(all_labels)\n adjacency_matrix = np.stack([mat.toarray() for mat in sp_adj_matrix], axis=0)\n all_struct = np.array(all_struct)\n return all_seqs, adjacency_matrix, all_labels, all_struct\n\n\nif __name__ == \"__main__\":\n np.set_printoptions(threshold=np.inf, edgeitems=30, linewidth=100000, )\n\n # res = fold_seq_rnaplfold(\n # 'cgcgggacgcggcccgaggccgtgcgcgagccggggcaccgggcggcggcggcggcggcgcgcgccatgtcgttcagtgaaatgaaccgcaggacgctggcgttccgaggaggcgggttggtcaccgctagcggcggcggctccacgaacAATAACGCTGGCGGGGAGGCCTCAGcttggcctccgcagccccagccgagacagcccccgccgccagcgccgcccgcgcttcagccgcctaatgggcggggggccgacgaggaagtggaattggagggcctggagccccaagacctggaggcctccgccgggccggccgccggcg',\n # 150, 150, 0.0001, True)\n # print(res[1].todense().sum(axis=-1))\n res = fold_seq_rnashapes(\n 'cgcgggacgcggcccgaggccgtgcgcgagccggggcaccgggcggcggcggcggcggcgcgcgccatgtcgttcagtgaaatgaaccgcaggacgctggcgttccgaggaggcgggttggtcaccgctagcggcggcggctccacgaacAATAACGCTGGCGGGGAGGCCTCAGcttggcctccgcagccccagccgagacagcccccgccgccagcgccgcccgcgcttcagccgcctaatgggcggggggccgacgaggaagtggaattggagggcctggagccccaagacctggaggcctccgccgggccggccgccggcg',\n 150, iterations=100)\n # print(res[0].todense())\n print(res[1].todense().sum(axis=-1))\n\n # with open('boltzmann-sampling-acc.txt', 'w') as file:\n # for amount in [5, 10, 100, 1000, 5000, 10000]:\n # rel_diff, prob_diff = [], []\n # for replcate in range(100):\n # _, res = fold_seq_subopt(\n # 'TGTGAAGCGCGGCTAGCTGCCGGGGTTCGAGGTGGGTCCCAGGGTTAAAATCCCTTGTTGTCTTACTGGTGGCAGCAAGCTAGGACTATACTCCTCGGTCG',\n # 'rnafold', True, amount)\n # _, new_res = fold_seq_subopt(\n # 'TGTGAAGCGCGGCTAGCTGCCGGGGTTCGAGGTGGGTCCCAGGGTTAAAATCCCTTGTTGTCTTACTGGTGGCAGCAAGCTAGGACTATACTCCTCGGTCG',\n # 'rnafold', True, amount)\n #\n # diff = (res[0].todense() != new_res[0].todense()).astype(np.int32)\n # rel_diff.append(np.sum(diff))\n #\n # diff = np.abs(res[1].todense() - new_res[1].todense())\n # prob_diff.append(np.mean(np.max(diff, axis=-1)))\n # file.writelines('sampling amount %d, relation difference: %.4f\\u00b1%.4f, probability difference: %.4f\\u00b1%.4f' %\n # (amount, np.mean(rel_diff), np.std(rel_diff), np.mean(prob_diff), np.std(prob_diff)))\n # print('sampling amount %d, relation difference: %.4f\\u00b1%.4f, probability difference: %.4f\\u00b1%.4f' %\n # (amount, np.mean(rel_diff), np.std(rel_diff), np.mean(prob_diff), np.std(prob_diff)))\n\n # annotation for the multiloop elements\n # all_seqs, adjacency_matrix, all_labels, _ = generate_element_dataset(80000, 101, 'i', return_label=False)\n # print(all_labels.shape)\n # print(np.where(np.count_nonzero(all_labels, axis=-1) > 0)[0].__len__())\n #\n # all_seqs, adjacency_matrix, all_labels, _ = generate_hairpin_dataset(80000, 101, 'm', return_label=False)\n # print(all_labels.shape)\n # print(np.where(np.count_nonzero(all_labels, axis=-1) > 0)[0].__len__())\n", "meta": {"hexsha": "9ad46591b466e19699f398dd45535fc5fc4d7ba6", "size": 29418, "ext": "py", "lang": "Python", "max_stars_repo_path": "lib/rna_utils.py", "max_stars_repo_name": "HarveyYan/RNAonGraph", "max_stars_repo_head_hexsha": "0056cc465f7bc4a89c4955d2cee88d6a858cef71", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 15, "max_stars_repo_stars_event_min_datetime": "2020-06-27T08:08:20.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-22T03:29:45.000Z", "max_issues_repo_path": "lib/rna_utils.py", "max_issues_repo_name": "HarveyYan/RNAonGraph", "max_issues_repo_head_hexsha": "0056cc465f7bc4a89c4955d2cee88d6a858cef71", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2020-08-10T00:46:06.000Z", "max_issues_repo_issues_event_max_datetime": "2020-11-20T21:25:27.000Z", "max_forks_repo_path": "lib/rna_utils.py", "max_forks_repo_name": "HarveyYan/RNAonGraph", "max_forks_repo_head_hexsha": "0056cc465f7bc4a89c4955d2cee88d6a858cef71", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2020-02-19T16:04:00.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-09T22:32:23.000Z", "avg_line_length": 42.4502164502, "max_line_length": 338, "alphanum_fraction": 0.5751580665, "include": true, "reason": "import numpy,import scipy", "num_tokens": 7555, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5273165233795672, "lm_q2_score": 0.3593641314378279, "lm_q1q2_score": 0.18949864441711325}} {"text": "import numpy as np\nfrom skimage.future.graph import RAG\nimport heapq\nfrom skimage.segmentation import find_boundaries\nfrom skimage.morphology import skeletonize\nfrom sklearn.linear_model import LogisticRegression\nfrom lib.utils import get_xymaps, shuffler\nfrom .nmf import NMFDataCompressor\n\n\ndef run_lrc_mrm(dataset_slice, cps, sample_size):\n compressor = NMFDataCompressor(cps)\n compressor.fit(dataset_slice, sample_size)\n compressed_dataset = compressor.transform(dataset_slice['data'])\n dataset_slice['data'] = compressed_dataset\n dataset_slice = _fit_lrc_model(\n dataset_slice,\n model=LogisticRegression(penalty='none'),\n training_set_size=sample_size,\n )\n dataset_slice = _lrc_mrm_segmentation(dataset_slice)\n return dataset_slice\n\n\ndef _lrc_mrm_segmentation(dataset):\n \"\"\"\n Implementation of the multi-region merging segmentation controlled by\n a trained classifier model. Design of the function was originally inspired\n by the merge_hierarchical function of Skimage:\n (https://github.com/scikit-image/scikit-image/blob/master/skimage/)\n \"\"\"\n # Collect spatial resolution and data from dataset\n rx, ry = dataset.get('spatial_resol')\n data = dataset.get('data')\n model = dataset.get('lrc_model')\n\n # Define merging decision function\n def mdf(v):\n return model.predict_proba(np.atleast_2d(v))[0, 1]\n\n # Initialize region adjacency graph (RAG)\n rag, edge_heap, segments = _initialize_graph(rx, ry, data, model)\n\n # Start the region-merging algorithm\n while (len(edge_heap) > 0) and (edge_heap[0][0] < 0.5):\n # Pop the smallest edge from the heap if weight < 0.5\n smallest_weight, n1, n2, valid = heapq.heappop(edge_heap)\n\n # Check that the edge is valid\n if valid:\n # Make sure that n1 is the smallest regiom\n if rag.nodes[n1]['count'] > rag.nodes[n2]['count']:\n n1, n2 = n2, n1\n\n # Update properties of n2\n rag.nodes[n2]['labels'] = (rag.nodes[n1]['labels']\n + rag.nodes[n2]['labels'])\n rag.nodes[n2]['count'] = (rag.nodes[n1]['count']\n + rag.nodes[n2]['count'])\n\n # Get new neighbors of n2\n n1_numbers = set(rag.neighbors(n1))\n n2_numbers = set(rag.neighbors(n2))\n new_neighbors = (n1_numbers | n2_numbers) - n2_numbers - {n1, n2}\n\n # Disable edges of n1 in the heap list\n for nbr in rag.neighbors(n1):\n edge = rag[n1][nbr]\n edge['heap item'][3] = False\n\n # Remove n1 from the graph (edges are still in the heap list)\n rag.remove_node(n1)\n\n # Update new edges of n2\n for nbr in new_neighbors:\n rag.add_edge(n2, nbr)\n edge = rag[n2][nbr]\n master_n2 = rag.nodes[n2]['master']\n master_nbr = rag.nodes[nbr]['master']\n weight = mdf(_vector_similarity(master_n2, master_nbr))\n heap_item = [weight, n2, nbr, (weight < 0.5)]\n edge['heap item'] = heap_item\n # Push edges to the heap\n heapq.heappush(edge_heap, heap_item)\n\n # Compute grain segmentation map\n label_map = np.arange(segments.max() + 1)\n for ix, (n, d) in enumerate(rag.nodes(data=True)):\n for lab in d['labels']:\n label_map[lab] = ix\n segmentation = label_map[segments]\n\n # Compute grain boundary map\n gbs = skeletonize(find_boundaries(segmentation, mode='inner'))\n\n # Return updated dataset\n dataset['segmentation'] = segmentation.ravel()\n dataset['boundaries'] = gbs.ravel()\n\n return dataset\n\n\ndef _fit_lrc_model(dataset, model, training_set_size):\n \"\"\"Fits a model, computes precision, recall and accuracy\"\"\"\n training_set = _get_sample_set(dataset, training_set_size)\n model.fit(training_set['x'], training_set['y'])\n dataset['lrc_model'] = model\n return dataset\n\n\ndef _initialize_graph(rx, ry, data, model):\n \"\"\"Initializes the Region Adjacency Graph (RAG).\"\"\"\n\n # Define merging decision function\n def mdf(v):\n return model.predict_proba(np.atleast_2d(v))[0, 1]\n\n # Initialize RAG\n x_map, y_map = get_xymaps(rx, ry)\n segments = np.arange(rx * ry).reshape((rx, ry))\n rag = RAG(segments)\n\n # Initialize nodes\n data_reshaped = data.reshape((rx, ry, data.shape[1]))\n for n in rag:\n rag.nodes[n].update({'labels': [n]})\n for index in np.ndindex(segments.shape):\n current = segments[index]\n rag.nodes[current]['count'] = 1\n rag.nodes[current]['master'] = data_reshaped[index]\n rag.nodes[current]['xpos'] = x_map[current]\n rag.nodes[current]['ypos'] = y_map[current]\n\n # Initialize edges\n edge_heap = []\n for n1, n2, d in rag.edges(data=True):\n master_x = rag.nodes[n1]['master']\n master_y = rag.nodes[n2]['master']\n weight = mdf(_vector_similarity(master_x, master_y))\n # Push the edge into the heap\n heap_item = [weight, n1, n2, (weight < 0.5)]\n d['heap item'] = heap_item\n heapq.heappush(edge_heap, heap_item)\n\n return rag, edge_heap, segments\n\n\ndef _get_sample_set(dataset, sample_size):\n \"\"\"\n Randomly extracts a training or test set from the dataset.\n - Class 0: pairs of adjacent voxels\n - Class 1: pairs of non-adjacent voxels\n \"\"\"\n # Collect data from the dataset\n rx, ry = dataset.get('spatial_resol')\n data = dataset.get('data')\n x_map, y_map = get_xymaps(rx, ry)\n\n # Extract adjacent sample\n x_close, y_close = _get_adjacent_sample(\n rx, ry, data, sample_size, x_map, y_map)\n\n # Extract non-adjacent sample\n x_far, y_far = _get_non_adjacent_sample(data, sample_size, x_map, y_map)\n\n # Stack both samples\n x = np.vstack((x_close, x_far))\n y = np.hstack((y_close, y_far))\n\n # Shuffle extracted set\n idx = np.arange(0, x.shape[0])\n np.random.shuffle(idx)\n x = x[idx]\n y = y[idx]\n\n sample_set = {'x': x, 'y': y}\n\n return sample_set\n\n\ndef _get_adjacent_sample(rx, ry, data, sample_size, xmap, ymap):\n \"\"\"Samples Sbar, the distribution of adjacent pixel feature vectors.\"\"\"\n\n # Get set of random data\n x0, idx = shuffler(data, sample_size)\n\n # Modify location by 1 pixel\n modified_x = xmap[idx] + (np.random.randint(0, 2, sample_size) * 2 - 1)\n modified_x = np.clip(modified_x.astype('int'), 0, rx - 1)\n modified_y = ymap[idx] + (np.random.randint(0, 2, sample_size) * 2 - 1)\n modified_y = np.clip(modified_y.astype('int'), 0, ry - 1)\n\n # Find corresponding signal\n x1 = np.empty_like(x0)\n c = 0\n i = np.arange(rx * ry)\n for xc, yc in zip(modified_x, modified_y):\n u = np.zeros((rx, ry))\n u[xc, yc] = 1\n num = i[(u.ravel() == 1)]\n x1[c] = data[num]\n c += 1\n\n # Compute distance vectors\n x_close = _vector_similarity(x1, x0)\n\n # Label as 0\n y_close = np.zeros(x_close.shape[0], dtype=np.uint8)\n\n return x_close, y_close\n\n\ndef _get_non_adjacent_sample(data, sample_size, xmap, ymap):\n \"\"\"Samples the distribution of non-adjacent pixels.\"\"\"\n\n # Get random set of data and location of selected pixel pairs, twice\n x0, idx = shuffler(data, sample_size)\n loc_x_0, loc_y_0 = xmap[idx], ymap[idx]\n x1, idx = shuffler(data, sample_size)\n loc_x_1, loc_y_1 = xmap[idx], ymap[idx]\n\n # Compute distance vectors\n x_far = _vector_similarity(x1, x0)\n\n # Filter out adjacent examples\n adjacent_filter = np.abs(loc_x_0 - loc_x_1) + np.abs(loc_y_0 - loc_y_1) < 2\n x_far = x_far[~adjacent_filter]\n\n # Label as 1\n y_far = np.ones(x_far.shape[0], dtype=np.uint8)\n\n return x_far, y_far\n\n\ndef _vector_similarity(a, b):\n \"\"\"Returns distance vector of two input feature vectors\"\"\"\n return np.square(np.subtract(a, b))\n", "meta": {"hexsha": "89a4d97a94a6d612d8c142620e4dee56b65c7bab", "size": 7924, "ext": "py", "lang": "Python", "max_stars_repo_path": "lib/segmentation/segmentation.py", "max_stars_repo_name": "MalloryWittwer/drm_ml_demo", "max_stars_repo_head_hexsha": "03ec73bc6c5b8807767d4c38ac8649ec4ffbea37", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-01-24T03:19:28.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-24T03:19:28.000Z", "max_issues_repo_path": "lib/segmentation/segmentation.py", "max_issues_repo_name": "MalloryWittwer/drm_ml_demo", "max_issues_repo_head_hexsha": "03ec73bc6c5b8807767d4c38ac8649ec4ffbea37", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lib/segmentation/segmentation.py", "max_forks_repo_name": "MalloryWittwer/drm_ml_demo", "max_forks_repo_head_hexsha": "03ec73bc6c5b8807767d4c38ac8649ec4ffbea37", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.2941176471, "max_line_length": 79, "alphanum_fraction": 0.6317516406, "include": true, "reason": "import numpy", "num_tokens": 2099, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6584175139669997, "lm_q2_score": 0.28776782186926264, "lm_q1q2_score": 0.1894713738748583}} {"text": "# -*- coding: utf-8 -*-\r\n\r\n\"\"\"\r\nscikit-rebate was primarily developed at the University of Pennsylvania by:\r\n - Randal S. Olson (rso@randalolson.com)\r\n - Pete Schmitt (pschmitt@upenn.edu)\r\n - Ryan J. Urbanowicz (ryanurb@upenn.edu)\r\n - Weixuan Fu (weixuanf@upenn.edu)\r\n - and many more generous open source contributors\r\n\r\nPermission is hereby granted, free of charge, to any person obtaining a copy of this software\r\nand associated documentation files (the \"Software\"), to deal in the Software without restriction,\r\nincluding without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,\r\nand/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,\r\nsubject to the following conditions:\r\n\r\nThe above copyright notice and this permission notice shall be included in all copies or substantial\r\nportions of the Software.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT\r\nLIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\r\nIN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,\r\nWHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\r\nSOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r\n\"\"\"\r\n\r\nimport numpy as np\r\n\r\n\r\n# (Subset of continuous-valued feature data, Subset of discrete-valued feature data, max/min difference, instance index, boolean mask for continuous, boolean mask for discrete)\r\ndef get_row_missing(xc, xd, cdiffs, index, cindices, dindices):\r\n \"\"\" Calculate distance between index instance and all other instances. \"\"\"\r\n row = np.empty(0, dtype=np.double) # initialize empty row\r\n cinst1 = xc[index] # continuous-valued features for index instance\r\n dinst1 = xd[index] # discrete-valued features for index instance\r\n # Boolean mask locating missing values for continuous features for index instance\r\n can = cindices[index]\r\n # Boolean mask locating missing values for discrete features for index instance\r\n dan = dindices[index]\r\n tf = len(cinst1) + len(dinst1) # total number of features.\r\n\r\n # Progressively compare current instance to all others. Excludes comparison with self indexed instance. (Building the distance matrix triangle).\r\n for j in range(index):\r\n dist = 0\r\n dinst2 = xd[j] # discrete-valued features for compared instance\r\n cinst2 = xc[j] # continuous-valued features for compared instance\r\n\r\n # Manage missing values in discrete features\r\n # Boolean mask locating missing values for discrete features for compared instance\r\n dbn = dindices[j]\r\n # indexes where there is at least one missing value in the feature between an instance pair.\r\n idx = np.unique(np.append(dan, dbn))\r\n # Number of features excluded from distance calculation due to one or two missing values within instance pair. Used to normalize distance values for comparison.\r\n dmc = len(idx)\r\n d1 = np.delete(dinst1, idx) # delete unique missing features from index instance\r\n d2 = np.delete(dinst2, idx) # delete unique missing features from compared instance\r\n\r\n # Manage missing values in continuous features\r\n # Boolean mask locating missing values for continuous features for compared instance\r\n cbn = cindices[j]\r\n # indexes where there is at least one missing value in the feature between an instance pair.\r\n idx = np.unique(np.append(can, cbn))\r\n # Number of features excluded from distance calculation due to one or two missing values within instance pair. Used to normalize distance values for comparison.\r\n cmc = len(idx)\r\n c1 = np.delete(cinst1, idx) # delete unique missing features from index instance\r\n c2 = np.delete(cinst2, idx) # delete unique missing features from compared instance\r\n # delete unique missing features from continuous value difference scores\r\n cdf = np.delete(cdiffs, idx)\r\n\r\n # Add discrete feature distance contributions (missing values excluded) - Hamming distance\r\n dist += len(d1[d1 != d2])\r\n\r\n # Add continuous feature distance contributions (missing values excluded) - Manhattan distance (Note that 0-1 continuous value normalization is included ~ subtraction of minimums cancel out)\r\n dist += np.sum(np.absolute(np.subtract(c1, c2)) / cdf)\r\n\r\n # Normalize distance calculation based on total number of missing values bypassed in either discrete or continuous features.\r\n tnmc = tf - dmc - cmc # Total number of unique missing counted\r\n # Distance normalized by number of features included in distance sum (this seeks to handle missing values neutrally in distance calculation)\r\n dist = dist/float(tnmc)\r\n\r\n row = np.append(row, dist)\r\n\r\n return row\r\n\r\n\r\n# For iter relief\r\ndef get_row_missing_iter(xc, xd, cdiffs, index, cindices, dindices, weights):\r\n \"\"\" Calculate distance between index instance and all other instances. \"\"\"\r\n row = np.empty(0, dtype=np.double) # initialize empty row\r\n cinst1 = xc[index] # continuous-valued features for index instance\r\n dinst1 = xd[index] # discrete-valued features for index instance\r\n # Boolean mask locating missing values for continuous features for index instance\r\n can = cindices[index]\r\n # Boolean mask locating missing values for discrete features for index instance\r\n dan = dindices[index]\r\n tf = len(cinst1) + len(dinst1) # total number of features.\r\n # Progressively compare current instance to all others. Excludes comparison with self indexed instance. (Building the distance matrix triangle).\r\n for j in range(index):\r\n dist = 0\r\n dinst2 = xd[j] # discrete-valued features for compared instance\r\n cinst2 = xc[j] # continuous-valued features for compared instance\r\n\r\n # Manage missing values in discrete features\r\n # Boolean mask locating missing values for discrete features for compared instance\r\n dbn = dindices[j]\r\n # indexes where there is at least one missing value in the feature between an instance pair.\r\n idx = np.unique(np.append(dan, dbn))\r\n # Number of features excluded from distance calculation due to one or two missing values within instance pair. Used to normalize distance values for comparison.\r\n dmc = len(idx)\r\n d1 = np.delete(dinst1, idx) # delete unique missing features from index instance\r\n d2 = np.delete(dinst2, idx) # delete unique missing features from compared instance\r\n\r\n wd = np.delete(weights, idx) # delete weights corresponding to missing discrete features\r\n # Manage missing values in continuous features\r\n # Boolean mask locating missing values for continuous features for compared instance\r\n cbn = cindices[j]\r\n # indexes where there is at least one missing value in the feature between an instance pair.\r\n idx = np.unique(np.append(can, cbn))\r\n # Number of features excluded from distance calculation due to one or two missing values within instance pair. Used to normalize distance values for comparison.\r\n cmc = len(idx)\r\n c1 = np.delete(cinst1, idx) # delete unique missing features from index instance\r\n c2 = np.delete(cinst2, idx) # delete unique missing features from compared instance\r\n # delete unique missing features from continuous value difference scores\r\n cdf = np.delete(cdiffs, idx)\r\n wc = np.delete(weights, idx) # delete weights corresponding to missing continuous features\r\n\r\n # Add discrete feature distance contributions (missing values excluded) - Hamming distance\r\n if len(d1)!=0: #To ensure there is atleast one discrete variable\r\n hamming_dist = np.not_equal(d1, d2).astype(float)\r\n weight_hamming_dist = np.dot(hamming_dist, wd)/np.sum(wd)\r\n dist += weight_hamming_dist\r\n\r\n # Add continuous feature distance contributions (missing values excluded) - Manhattan distance (Note that 0-1 continuous value normalization is included ~ subtraction of minimums cancel out)\r\n if len(c1)!=0: #To ensure there is atleast one continuous variable\r\n dist += np.dot((np.absolute(np.subtract(c1, c2)) / cdf), wc)/np.sum(wc)\r\n\r\n # Normalize distance calculation based on total number of missing values bypassed in either discrete or continuous features.\r\n tnmc = tf - dmc - cmc # Total number of unique missing counted\r\n # Distance normalized by number of features included in distance sum (this seeks to handle missing values neutrally in distance calculation)\r\n dist = dist/float(tnmc)\r\n\r\n row = np.append(row, dist)\r\n\r\n return row\r\n\r\n\r\ndef ramp_function(data_type, attr, fname, xinstfeature, xNNifeature):\r\n \"\"\" Our own user simplified variation of the ramp function suggested by Hong 1994, 1997. Hong's method requires the user to specifiy two thresholds\r\n that indicate the max difference before a score of 1 is given, as well a min difference before a score of 0 is given, and any in the middle get a\r\n score that is the normalized difference between the two continuous feature values. This was done because when discrete and continuous features were mixed,\r\n continuous feature scores were underestimated. Towards simplicity, automation, and a dataset adaptable approach,\r\n here we simply check whether the difference is greater than the standard deviation for the given feature; if so we assign a score of 1, otherwise we\r\n assign the normalized feature score difference. This should help compensate for the underestimation. \"\"\"\r\n diff = 0\r\n mmdiff = attr[fname][3] # Max/Min range of values for target feature\r\n rawfd = abs(xinstfeature - xNNifeature) # prenormalized feature value difference\r\n\r\n if data_type == 'mixed': # Ramp function utilized\r\n # Check whether feature value difference is greater than the standard deviation\r\n standDev = attr[fname][4]\r\n if rawfd > standDev: # feature value difference is is wider than a standard deviation\r\n diff = 1\r\n else:\r\n diff = abs(xinstfeature - xNNifeature) / mmdiff\r\n\r\n else: # Normal continuous feature scoring\r\n diff = abs(xinstfeature - xNNifeature) / mmdiff\r\n\r\n return diff\r\n\r\n\r\ndef compute_score(attr, mcmap, NN, feature, inst, nan_entries, headers, class_type, X, y, labels_std, data_type, near=True):\r\n \"\"\"Flexible feature scoring method that can be used with any core Relief-based method. Scoring proceeds differently\r\n based on whether endpoint is binary, multiclass, or continuous. This method is called for a single target instance\r\n + feature combination and runs over all items in NN. \"\"\"\r\n\r\n fname = headers[feature] # feature identifier\r\n ftype = attr[fname][0] # feature type\r\n ctype = class_type # class type (binary, multiclass, continuous)\r\n diff_hit = diff_miss = 0.0 # Tracks the score contribution\r\n # Tracks the number of hits/misses. Used in normalizing scores by 'k' in ReliefF, and by m or h in SURF, SURF*, MultiSURF*, and MultiSURF\r\n count_hit = count_miss = 0.0\r\n # Initialize 'diff' (The score contribution for this target instance and feature over all NN)\r\n diff = 0\r\n # mmdiff = attr[fname][3] # Max/Min range of values for target feature\r\n\r\n datalen = float(len(X))\r\n\r\n # If target instance is missing, then a 'neutral' score contribution of 0 is returned immediately since all NN comparisons will be against this missing value.\r\n if nan_entries[inst][feature]:\r\n return 0.\r\n # Note missing data normalization below regarding missing NN feature values is accomplished by counting hits and misses (missing values are not counted) (happens in parallel with hit/miss imbalance normalization)\r\n\r\n xinstfeature = X[inst][feature] # value of target instances target feature.\r\n\r\n #--------------------------------------------------------------------------\r\n if ctype == 'binary':\r\n for i in range(len(NN)):\r\n if nan_entries[NN[i]][feature]: # skip any NN with a missing value for this feature.\r\n continue\r\n\r\n xNNifeature = X[NN[i]][feature]\r\n\r\n if near: # SCORING FOR NEAR INSTANCES\r\n if y[inst] == y[NN[i]]: # HIT\r\n count_hit += 1\r\n if ftype == 'continuous':\r\n # diff_hit -= abs(xinstfeature - xNNifeature) / mmdiff #Normalize absolute value of feature value difference by max-min value range for feature (so score update lies between 0 and 1)\r\n diff_hit -= ramp_function(data_type, attr, fname, xinstfeature, xNNifeature)\r\n else: # discrete feature\r\n if xinstfeature != xNNifeature: # A difference in feature value is observed\r\n # Feature score is reduced when we observe feature difference between 'near' instances with the same class.\r\n diff_hit -= 1\r\n else: # MISS\r\n count_miss += 1\r\n if ftype == 'continuous':\r\n # diff_miss += abs(xinstfeature - xNNifeature) / mmdiff\r\n diff_miss += ramp_function(data_type, attr, fname,\r\n xinstfeature, xNNifeature)\r\n else: # discrete feature\r\n if xinstfeature != xNNifeature: # A difference in feature value is observed\r\n # Feature score is increase when we observe feature difference between 'near' instances with different class values.\r\n diff_miss += 1\r\n\r\n else: # SCORING FOR FAR INSTANCES (ONLY USED BY MULTISURF* BASED ON HOW CODED)\r\n if y[inst] == y[NN[i]]: # HIT\r\n count_hit += 1\r\n if ftype == 'continuous':\r\n\r\n # diff_hit -= abs(xinstfeature - xNNifeature) / mmdiff #Hits differently add continuous value differences rather than subtract them\r\n # Sameness should yield most negative score\r\n diff_hit -= (1-ramp_function(data_type, attr,\r\n fname, xinstfeature, xNNifeature))\r\n else: # discrete feature\r\n # The same feature value is observed (Used for more efficient 'far' scoring, since there should be fewer same values for 'far' instances)\r\n if xinstfeature == xNNifeature:\r\n # Feature score is reduced when we observe the same feature value between 'far' instances with the same class.\r\n diff_hit -= 1\r\n else: # MISS\r\n count_miss += 1\r\n if ftype == 'continuous':\r\n # diff_miss += abs(xinstfeature - xNNifeature) / mmdiff #Misses differntly subtract continuous value differences rather than add them\r\n # Sameness should yield most negative score\r\n diff_miss += (1-ramp_function(data_type, attr,\r\n fname, xinstfeature, xNNifeature))\r\n else: # discrete feature\r\n # The same feature value is observed (Used for more efficient 'far' scoring, since there should be fewer same values for 'far' instances)\r\n if xinstfeature == xNNifeature:\r\n # Feature score is increased when we observe the same feature value between 'far' instances with different class values.\r\n diff_miss += 1\r\n\r\n \"\"\" Score Normalizations:\r\n *'n' normalization dividing by the number of training instances (this helps ensure that all final scores end up in the -1 to 1 range\r\n *'k','h','m' normalization dividing by the respective number of hits and misses in NN (after ignoring missing values), also helps account for class imbalance within nearest neighbor radius)\"\"\"\r\n if count_hit == 0.0 or count_miss == 0.0: # Special case, avoid division error\r\n if count_hit == 0.0 and count_miss == 0.0:\r\n return 0.0\r\n elif count_hit == 0.0:\r\n diff = (diff_miss / count_miss) / datalen\r\n else: # count_miss == 0.0\r\n diff = (diff_hit / count_hit) / datalen\r\n else: # Normal diff normalization\r\n diff = ((diff_hit / count_hit) + (diff_miss / count_miss)) / datalen\r\n\r\n #--------------------------------------------------------------------------\r\n elif ctype == 'multiclass':\r\n class_store = dict() # only 'miss' classes will be stored\r\n # missClassPSum = 0\r\n\r\n for each in mcmap:\r\n if(each != y[inst]): # Identify miss classes for current target instance.\r\n class_store[each] = [0, 0]\r\n # missClassPSum += mcmap[each]\r\n\r\n for i in range(len(NN)):\r\n if nan_entries[NN[i]][feature]: # skip any NN with a missing value for this feature.\r\n continue\r\n\r\n xNNifeature = X[NN[i]][feature]\r\n\r\n if near: # SCORING FOR NEAR INSTANCES\r\n if(y[inst] == y[NN[i]]): # HIT\r\n count_hit += 1\r\n if ftype == 'continuous':\r\n # diff_hit -= abs(xinstfeature - xNNifeature) / mmdiff\r\n diff_hit -= ramp_function(data_type, attr, fname, xinstfeature, xNNifeature)\r\n else: # discrete feature\r\n if xinstfeature != xNNifeature:\r\n # Feature score is reduced when we observe feature difference between 'near' instances with the same class.\r\n diff_hit -= 1\r\n else: # MISS\r\n for missClass in class_store:\r\n if(y[NN[i]] == missClass): # Identify which miss class is present\r\n class_store[missClass][0] += 1\r\n if ftype == 'continuous':\r\n # class_store[missClass][1] += abs(xinstfeature - xNNifeature) / mmdiff\r\n class_store[missClass][1] += ramp_function(\r\n data_type, attr, fname, xinstfeature, xNNifeature)\r\n else: # discrete feature\r\n if xinstfeature != xNNifeature:\r\n # Feature score is increase when we observe feature difference between 'near' instances with different class values.\r\n class_store[missClass][1] += 1\r\n\r\n else: # SCORING FOR FAR INSTANCES (ONLY USED BY MULTISURF* BASED ON HOW CODED)\r\n if(y[inst] == y[NN[i]]): # HIT\r\n count_hit += 1\r\n if ftype == 'continuous':\r\n # diff_hit -= abs(xinstfeature - xNNifeature) / mmdiff #Hits differently add continuous value differences rather than subtract them\r\n # Sameness should yield most negative score\r\n diff_hit -= (1-ramp_function(data_type, attr,\r\n fname, xinstfeature, xNNifeature))\r\n else: # discrete features\r\n if xinstfeature == xNNifeature:\r\n # Feature score is reduced when we observe the same feature value between 'far' instances with the same class.\r\n diff_hit -= 1\r\n else: # MISS\r\n for missClass in class_store:\r\n if(y[NN[i]] == missClass):\r\n class_store[missClass][0] += 1\r\n if ftype == 'continuous':\r\n # class_store[missClass][1] += abs(xinstfeature - xNNifeature) / mmdiff\r\n # Sameness should yield most negative score\r\n class_store[missClass][1] += (1-ramp_function(data_type,\r\n attr, fname, xinstfeature, xNNifeature))\r\n else: # discrete feature\r\n if xinstfeature == xNNifeature:\r\n # Feature score is increased when we observe the same feature value between 'far' instances with different class values.\r\n class_store[missClass][1] += 1\r\n\r\n \"\"\" Score Normalizations:\r\n *'n' normalization dividing by the number of training instances (this helps ensure that all final scores end up in the -1 to 1 range\r\n *'k','h','m' normalization dividing by the respective number of hits and misses in NN (after ignoring missing values), also helps account for class imbalance within nearest neighbor radius)\r\n * multiclass normalization - accounts for scoring by multiple miss class, so miss scores don't have too much weight in contrast with hit scoring. If a given miss class isn't included in NN\r\n then this normalization will account for that possibility. \"\"\"\r\n # Miss component\r\n for each in class_store:\r\n count_miss += class_store[each][0]\r\n\r\n if count_hit == 0.0 and count_miss == 0.0:\r\n return 0.0\r\n else:\r\n if count_miss == 0:\r\n pass\r\n else: # Normal diff normalization\r\n for each in class_store: # multiclass normalization\r\n # Contribution of given miss class weighted by it's observed frequency within NN set.\r\n diff += class_store[each][1] * \\\r\n (class_store[each][0] / count_miss) * len(class_store)\r\n diff = diff / count_miss # 'm' normalization\r\n\r\n # Hit component: with 'h' normalization\r\n if count_hit == 0:\r\n pass\r\n else:\r\n diff += (diff_hit / count_hit)\r\n\r\n diff = diff / datalen # 'n' normalization\r\n\r\n #--------------------------------------------------------------------------\r\n else: # CONTINUOUS endpoint\r\n same_class_bound = labels_std\r\n\r\n for i in range(len(NN)):\r\n if nan_entries[NN[i]][feature]: # skip any NN with a missing value for this feature.\r\n continue\r\n\r\n xNNifeature = X[NN[i]][feature]\r\n\r\n if near: # SCORING FOR NEAR INSTANCES\r\n if abs(y[inst] - y[NN[i]]) < same_class_bound: # HIT approximation\r\n count_hit += 1\r\n if ftype == 'continuous':\r\n # diff_hit -= abs(xinstfeature - xNNifeature) / mmdiff\r\n diff_hit -= ramp_function(data_type, attr, fname, xinstfeature, xNNifeature)\r\n else: # discrete feature\r\n if xinstfeature != xNNifeature:\r\n # Feature score is reduced when we observe feature difference between 'near' instances with the same 'class'.\r\n diff_hit -= 1\r\n else: # MISS approximation\r\n count_miss += 1\r\n if ftype == 'continuous':\r\n # diff_miss += abs(xinstfeature - xNNifeature) / mmdiff\r\n diff_miss += ramp_function(data_type, attr, fname,\r\n xinstfeature, xNNifeature)\r\n else: # discrete feature\r\n if xinstfeature != xNNifeature:\r\n # Feature score is increase when we observe feature difference between 'near' instances with different class value.\r\n diff_miss += 1\r\n\r\n else: # SCORING FOR FAR INSTANCES (ONLY USED BY MULTISURF* BASED ON HOW CODED)\r\n if abs(y[inst] - y[NN[i]]) < same_class_bound: # HIT approximation\r\n count_hit += 1\r\n if ftype == 'continuous':\r\n # diff_hit += abs(xinstfeature - xNNifeature) / mmdiff\r\n # Sameness should yield most negative score\r\n diff_hit -= (1-ramp_function(data_type, attr,\r\n fname, xinstfeature, xNNifeature))\r\n else: # discrete feature\r\n if xinstfeature == xNNifeature:\r\n # Feature score is reduced when we observe the same feature value between 'far' instances with the same class.\r\n diff_hit -= 1\r\n else: # MISS approximation\r\n count_miss += 1\r\n if ftype == 'continuous':\r\n # diff_miss -= abs(xinstfeature - xNNifeature) / mmdiff\r\n # Sameness should yield most negative score\r\n diff_miss += (1-ramp_function(data_type, attr,\r\n fname, xinstfeature, xNNifeature))\r\n else: # discrete feature\r\n if xinstfeature == xNNifeature:\r\n # Feature score is increased when we observe the same feature value between 'far' instances with different class values.\r\n diff_miss += 1\r\n\r\n \"\"\" Score Normalizations:\r\n *'n' normalization dividing by the number of training instances (this helps ensure that all final scores end up in the -1 to 1 range\r\n *'k','h','m' normalization dividing by the respective number of hits and misses in NN (after ignoring missing values), also helps account for class imbalance within nearest neighbor radius)\"\"\"\r\n\r\n if count_hit == 0.0 or count_miss == 0.0: # Special case, avoid division error\r\n if count_hit == 0.0 and count_miss == 0.0:\r\n return 0.0\r\n elif count_hit == 0.0:\r\n diff = (diff_miss / count_miss) / datalen\r\n else: # count_miss == 0.0\r\n diff = (diff_hit / count_hit) / datalen\r\n else: # Normal diff normalization\r\n diff = ((diff_hit / count_hit) + (diff_miss / count_miss)) / datalen\r\n\r\n return diff\r\n\r\n\r\ndef ReliefF_compute_scores(inst, attr, nan_entries, num_attributes, mcmap, NN, headers, class_type, X, y, labels_std, data_type, weight_flag=0, weights=None):\r\n \"\"\" Unique scoring procedure for ReliefF algorithm. Scoring based on k nearest hits and misses of current target instance. \"\"\"\r\n scores = np.zeros(num_attributes)\r\n if weight_flag == 2:\r\n for feature_num in range(num_attributes):\r\n scores[feature_num] += weights[feature_num]*compute_score(attr, mcmap, NN, feature_num, inst,\r\n nan_entries, headers, class_type, X, y, labels_std, data_type)\r\n else:\r\n for feature_num in range(num_attributes):\r\n scores[feature_num] += compute_score(attr, mcmap, NN, feature_num, inst,\r\n nan_entries, headers, class_type, X, y, labels_std, data_type)\r\n return scores\r\n\r\n\r\ndef SURF_compute_scores(inst, attr, nan_entries, num_attributes, mcmap, NN, headers, class_type, X, y, labels_std, data_type, weight_flag=0, weights=None):\r\n \"\"\" Unique scoring procedure for SURF algorithm. Scoring based on nearest neighbors within defined radius of current target instance. \"\"\"\r\n scores = np.zeros(num_attributes)\r\n if weight_flag == 2:\r\n if len(NN) <= 0:\r\n return scores\r\n for feature_num in range(num_attributes):\r\n scores[feature_num] += weights[feature_num]*compute_score(attr, mcmap, NN, feature_num, inst,\r\n nan_entries, headers, class_type, X, y, labels_std, data_type)\r\n else:\r\n if len(NN) <= 0:\r\n return scores\r\n for feature_num in range(num_attributes):\r\n scores[feature_num] += compute_score(attr, mcmap, NN, feature_num, inst,\r\n nan_entries, headers, class_type, X, y, labels_std, data_type)\r\n return scores\r\n\r\n\r\ndef SURFstar_compute_scores(inst, attr, nan_entries, num_attributes, mcmap, NN_near, NN_far, headers, class_type, X, y, labels_std, data_type, weight_flag=0, weights=None):\r\n \"\"\" Unique scoring procedure for SURFstar algorithm. Scoring based on nearest neighbors within defined radius, as well as\r\n 'anti-scoring' of far instances outside of radius of current target instance\"\"\"\r\n scores = np.zeros(num_attributes)\r\n if weight_flag == 2:\r\n for feature_num in range(num_attributes):\r\n if len(NN_near) > 0:\r\n scores[feature_num] += weights[feature_num]*compute_score(attr, mcmap, NN_near, feature_num, inst,\r\n nan_entries, headers, class_type, X, y, labels_std, data_type)\r\n # Note that we are using the near scoring loop in 'compute_score' and then just subtracting it here, in line with original SURF* paper.\r\n if len(NN_far) > 0:\r\n scores[feature_num] -= weights[feature_num]*compute_score(attr, mcmap, NN_far, feature_num, inst,\r\n nan_entries, headers, class_type, X, y, labels_std, data_type)\r\n else:\r\n for feature_num in range(num_attributes):\r\n if len(NN_near) > 0:\r\n scores[feature_num] += compute_score(attr, mcmap, NN_near, feature_num, inst,\r\n nan_entries, headers, class_type, X, y, labels_std, data_type)\r\n # Note that we are using the near scoring loop in 'compute_score' and then just subtracting it here, in line with original SURF* paper.\r\n if len(NN_far) > 0:\r\n scores[feature_num] -= compute_score(attr, mcmap, NN_far, feature_num, inst,\r\n nan_entries, headers, class_type, X, y, labels_std, data_type)\r\n return scores\r\n\r\n\r\ndef MultiSURF_compute_scores(inst, attr, nan_entries, num_attributes, mcmap, NN_near, headers, class_type, X, y, labels_std, data_type, weight_flag=0, weights=None):\r\n \"\"\" Unique scoring procedure for MultiSURF algorithm. Scoring based on 'extreme' nearest neighbors within defined radius of current target instance. \"\"\"\r\n scores = np.zeros(num_attributes)\r\n if weight_flag == 2:\r\n for feature_num in range(num_attributes):\r\n if len(NN_near) > 0:\r\n scores[feature_num] += weights[feature_num]*compute_score(attr, mcmap, NN_near, feature_num, inst,\r\n nan_entries, headers, class_type, X, y, labels_std, data_type)\r\n else:\r\n for feature_num in range(num_attributes):\r\n if len(NN_near) > 0:\r\n scores[feature_num] += compute_score(attr, mcmap, NN_near, feature_num, inst,\r\n nan_entries, headers, class_type, X, y, labels_std, data_type)\r\n\r\n return scores\r\n\r\n\r\ndef MultiSURFstar_compute_scores(inst, attr, nan_entries, num_attributes, mcmap, NN_near, NN_far, headers, class_type, X, y, labels_std, data_type, weight_flag=0, weights=None):\r\n \"\"\" Unique scoring procedure for MultiSURFstar algorithm. Scoring based on 'extreme' nearest neighbors within defined radius, as\r\n well as 'anti-scoring' of extreme far instances defined by outer radius of current target instance. \"\"\"\r\n scores = np.zeros(num_attributes)\r\n if weight_flag == 2:\r\n for feature_num in range(num_attributes):\r\n if len(NN_near) > 0:\r\n scores[feature_num] += weights[feature_num]*compute_score(attr, mcmap, NN_near, feature_num, inst,\r\n nan_entries, headers, class_type, X, y, labels_std, data_type)\r\n # Note that we add this term because we used the far scoring above by setting 'near' to False. This is in line with original MultiSURF* paper.\r\n if len(NN_far) > 0:\r\n scores[feature_num] += weights[feature_num]*compute_score(attr, mcmap, NN_far, feature_num, inst,\r\n nan_entries, headers, class_type, X, y, labels_std, data_type, near=False)\r\n else:\r\n for feature_num in range(num_attributes):\r\n if len(NN_near) > 0:\r\n scores[feature_num] += compute_score(attr, mcmap, NN_near, feature_num, inst,\r\n nan_entries, headers, class_type, X, y, labels_std, data_type)\r\n # Note that we add this term because we used the far scoring above by setting 'near' to False. This is in line with original MultiSURF* paper.\r\n if len(NN_far) > 0:\r\n scores[feature_num] += compute_score(attr, mcmap, NN_far, feature_num, inst,\r\n nan_entries, headers, class_type, X, y, labels_std, data_type, near=False)\r\n\r\n return scores\r\n", "meta": {"hexsha": "b85cccd32bed48c022fab840698e08e6e1313230", "size": 33644, "ext": "py", "lang": "Python", "max_stars_repo_path": "skrebatedev/scoring_utils.py", "max_stars_repo_name": "athril/scikit-rebate", "max_stars_repo_head_hexsha": "bfc8dd6aab9ea7b5a196e318322a938d36723955", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "skrebatedev/scoring_utils.py", "max_issues_repo_name": "athril/scikit-rebate", "max_issues_repo_head_hexsha": "bfc8dd6aab9ea7b5a196e318322a938d36723955", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "skrebatedev/scoring_utils.py", "max_forks_repo_name": "athril/scikit-rebate", "max_forks_repo_head_hexsha": "bfc8dd6aab9ea7b5a196e318322a938d36723955", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 63.5992438563, "max_line_length": 217, "alphanum_fraction": 0.6007311854, "include": true, "reason": "import numpy", "num_tokens": 6987, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041655, "lm_q2_score": 0.37022540649291935, "lm_q1q2_score": 0.18945048798577618}} {"text": "#!/usr/bin/env python3\n\n\n\"\"\"\nMIT License\n\nCopyright (c) 2018 Jiun Yen\n\"\"\"\n\n\n# Imports\nimport os\nimport argparse\nimport numpy as np\nfrom datetime import datetime\nfrom random import sample\nfrom multiprocessing import Pool, cpu_count\nfrom functools import partial\nfrom time import time\n\n# Constants\n_amino_acids_ = 'ARNDCQEGHILKMFPSTWYVXBZUO'\n_aa_set_ = set(_amino_acids_)\n_blank_ = [0 for _ in range(len(_amino_acids_) + 1)]\n_verbose_ = False\n_p_test_ = '../test/'\n_p_data_ = '../data/'\n_cpu_ = cpu_count()\n\n# Functions\ndef composition(sequence):\n\n # Compute properties\n sequence = sequence.upper()\n query_length = len(sequence)\n mass = 1 / query_length\n\n query_unique = list(set(sequence) - _aa_set_)\n if query_unique:\n print('There are special residues in sequence: %s (ignored during comparison)' % ','.join(query_unique))\n sequence = ''.join([i for i in sequence if i not in query_unique])\n\n # Compute composition\n comp = _blank_.copy()\n comp[0] = query_length\n for e in sequence:\n comp[1 + _amino_acids_.index(e)] += mass\n\n return comp\n\ndef build_db(p_fasta, p_db=''):\n\n t0 = time()\n\n if not p_db:\n p_db = p_fasta + '.disorderdb'\n\n if _verbose_:\n print('Building database from FASTA: %s ...' % p_fasta)\n\n n_seqs = 0\n db_comps = []\n with open(p_fasta, 'r') as fi, open(p_db, 'w+') as fo:\n seq = ''\n header = ''\n for l in fi:\n if l.startswith('>'):\n if seq:\n comp = composition(seq)\n _ = fo.write('%s\\t%d\\t%s\\n' % (header, comp[0], '\\t'.join(['%.6f' % i for i in comp[1:]])))\n db_comps.append([header] + comp)\n n_seqs += 1\n\n seq = ''\n header = l[1:].strip().replace('\\t', ' ')\n\n else:\n seq += l.strip()\n\n if n_seqs % 100 == 0:\n fo.flush()\n\n if seq:\n comp = composition(seq)\n _ = fo.write('%s\\t%d\\t%s\\n' % (header, comp[0], '\\t'.join(['%.6f' % i for i in comp[1:]])))\n db_comps.append([header] + comp)\n n_seqs += 1\n\n if _verbose_:\n print('\\tCompleted in %.1f minutes' % ((time() - t0)/60))\n print('Generated database for %d sequences at %s' % (n_seqs, p_db))\n\n return p_db, db_comps\n\ndef read_db(p_db):\n\n db_comps = []\n with open(p_db, 'r') as f:\n for l in f:\n tmp = l.split('\\t')\n comp = [tmp[0]]\n comp.append(int(tmp[1]))\n comp += [float(i) for i in tmp[2:]]\n db_comps.append(comp)\n\n return db_comps\n\ndef search(p_query, db_comps, p_out=''):\n\n t0 = time()\n\n if not p_out:\n stamp = 'search-%s-%s.csv' % (datetime.now().strftime('%Y%m%d%H%M%S'), ''.join(sample('ABCDEF', 4)))\n p_file, _ = os.path.splitext(p_query)\n p_out = p_file + '_' + stamp\n\n with open(p_out, 'w+') as f:\n _ = f.write('Queries,Hits,Distances\\n')\n\n query_seqs = read_fasta(p_query)\n\n if _verbose_:\n print('Searching on %d CPUs ...' % _cpu_)\n\n for q_header, q_seq in query_seqs.items():\n\n print('\\tQuery: %s' % q_header)\n\n query_comp = composition(q_seq)\n\n with Pool(processes=_cpu_) as pool:\n res = pool.map(partial(_compare_, q_comp=query_comp), db_comps)\n\n candidates = {h:d for h,d in res if h}\n\n candidates_sorted = sorted(candidates.items(), key=lambda x: x[1])\n\n with open(p_out, 'a') as f:\n\n for h,d in candidates_sorted:\n _ = f.write('%s,%s,%.4f\\n' % (q_header, h, d))\n\n if _verbose_:\n print('\\tCompleted in %.1f minutes' % ((time() - t0) / 60))\n print('Search complete, results saved as %s' % p_out)\n\n return p_out\n\ndef _compare_(t_db_comp, q_comp):\n\n header = ''\n dist = 1000.\n\n if q_comp[0] == t_db_comp[1]:\n header = t_db_comp[0]\n\n # Compute Euclidean distance\n dist = np.linalg.norm(np.array(q_comp[1:]) - np.array(t_db_comp[2:]))\n\n return header, dist\n\ndef read_fasta(p_fasta):\n\n sequences = {}\n\n n_seqs = 0\n with open(p_fasta, 'r') as f:\n seq = ''\n header = ''\n for l in f:\n if l.startswith('>'):\n if seq:\n sequences[header] = seq\n n_seqs += 1\n\n seq = ''\n header = l[1:].strip().replace('\\t',' ')\n\n else:\n seq += l.strip()\n\n if seq:\n sequences[header] = seq\n n_seqs += 1\n\n if _verbose_:\n print('Found %d sequences in %s' % (n_seqs, p_fasta))\n\n return sequences\n\n# Run\nif __name__ == '__main__':\n\n parser = argparse.ArgumentParser(description='Search similar proteins by composition.')\n parser.add_argument('-i', dest='p_query', default='', help='Query FASTA')\n parser.add_argument('-fb', dest='p_db_fasta', default='', help='FASTA of database')\n parser.add_argument('-o', dest='p_out', default='', help='Output file name/path')\n parser.add_argument('-db', dest='p_db', default='', help='Database name/path')\n parser.add_argument('-v', dest='verbose', action='store_true', help='To verbose')\n\n args = parser.parse_args()\n\n _verbose_ = args.verbose\n\n if args.p_db_fasta:\n _, db_comps = build_db(args.p_db_fasta, args.p_db)\n else:\n db_comps = read_db(args.p_db)\n\n if args.p_query:\n search(args.p_query, db_comps, args.p_out)\n", "meta": {"hexsha": "1be9613eea99e33fca56db418543b64793ac752a", "size": 5472, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/disorderly.py", "max_stars_repo_name": "qks1lver/disorderly", "max_stars_repo_head_hexsha": "bfe462676bd0c0d95e88a10fcd1f47dd7da07381", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/disorderly.py", "max_issues_repo_name": "qks1lver/disorderly", "max_issues_repo_head_hexsha": "bfe462676bd0c0d95e88a10fcd1f47dd7da07381", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/disorderly.py", "max_forks_repo_name": "qks1lver/disorderly", "max_forks_repo_head_hexsha": "bfe462676bd0c0d95e88a10fcd1f47dd7da07381", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 25.8113207547, "max_line_length": 112, "alphanum_fraction": 0.5561038012, "include": true, "reason": "import numpy", "num_tokens": 1489, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.37022540649291935, "lm_q1q2_score": 0.18945048798577616}} {"text": "#!/usr/bin/env python\n#\n# A script topographically correct SAR data using RIOS applier.\n#\n# Dan Clewley (clewley@usc.edu) - 05/02/2013\n#\n# The correction uses:\n#\n# sigma0_norm = sigma0 * (A_flat / A_slope) * (cos(theta_ref) / cos(theta_loc))^n\n#\n# Where n is a parameter related to optical thicknes. Defaults to 1.\n#\n# Castel et al. 2001. Sensitivity of space-borne SAR data to forest parameters over sloping terrain. \n# Theory and experiment. International journal of remote sensing. 22(12) pp. 2351-2376\n#\n# Designed to take outputs of GAMMA:\n# - Sigma0\n# - Normalised pixel area (A_flat / A_slope) '.pix'\n# - Local incidence angle '.inc'\n#\n# Can be run as a stand alone script or from within BatchGamma.py to process\n# multiple files (different polarizations).\n#\n# Copyright 2014 Daniel Clewley. All rights reserved.\n#\n# Permission is hereby granted, free of charge, to any person \n# obtaining a copy of this software and associated documentation \n# files (the \"Software\"), to deal in the Software without restriction, \n# including without limitation the rights to use, copy, modify, \n# merge, publish, distribute, sublicense, and/or sell copies of the \n# Software, and to permit persons to whom the Software is furnished \n# to do so, subject to the following conditions:\n#\n# The above copyright notice and this permission notice shall be \n# included in all copies or substantial portions of the Software.\n#\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, \n# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES \n# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. \n# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR \n# ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF \n# CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION \n# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n#\n#\n\nimport sys\nimport argparse\nfrom rios import applier\nfrom rios import cuiprogress\nimport numpy as np\nimport os, glob\n\nhavescipy = True\n\ntry:\n from scipy import ndimage\nexcept ImportError:\n havescipy = False\n\ndef getOutDriver(outFileName):\n \n \"\"\" Set output driver type and creation options\n based on file extension.\n\n Returns driver name and list of creation options\n as dictionary.\n \"\"\"\n\n outControls = {}\n\n gdalFormat = 'ENVI'\n gdalCOOptions = []\n calcStats = False\n\n extension = os.path.splitext(outFileName)[-1] \n if extension == '.kea':\n gdalFormat = 'KEA'\n calcStats = True\n elif extension == '.tif':\n gdalFormat = 'GTiff'\n gdalCOOptions = ['COMPRESS=DEFLATE']\n calcStats = True\n elif extension == '.img':\n gdalFormat = 'HFA'\n gdalCOOptions = ['COMPRESSED=YES']\n calcStats = True\n elif extension == '.pix':\n gdalFormat = 'PCIDSK'\n gdalCOOptions = ['COMPRESSION=RLE']\n calcStats = True\n\n outControls['gdalFormat'] = gdalFormat\n outControls['gdalCOOptions'] = gdalCOOptions\n outControls['calcStats'] = gdalCOOptions\n\n return outControls\n \n\ndef castelCorrection(info, inputs, outputs, otherargs):\n \"\"\"\n Apply topographic correction of Castel et al (2001)\n \"\"\"\n theta_ref_deg = otherargs.thetaref\n nFactor = otherargs.nFactor\n filterSize = otherargs.filterSize\n theta_ref = np.deg2rad(theta_ref_deg)\n insigma=inputs.insigma.astype(np.float32)\n inpix=inputs.inpix.astype(np.float32)\n inlinc=inputs.inlinc.astype(np.float32)\n \n if havescipy and filterSize is not None:\n inpix = ndimage.uniform_filter(inpix,size=filterSize)\n inlinc = ndimage.uniform_filter(inlinc,size=filterSize)\n\n outputs.outimage = insigma * inpix * (np.cos(theta_ref) / np.cos(inlinc))\n\ndef runCorrection(insigma, inlinc, inpix, outsigma, thetaref=39.0, nFactor=1.0, filterSize=None):\n\n controls = applier.ApplierControls()\n \n # Set up input images\n infiles = applier.FilenameAssociations()\n infiles.insigma = insigma\n infiles.inlinc = inlinc\n infiles.inpix = inpix\n \n # Set up output image\n outfiles = applier.FilenameAssociations()\n outfiles.outimage = outsigma\n\n # Set format for output image\n outControls = getOutDriver(outsigma)\n\n # Set options\n controls.setOutputDriverName(outControls['gdalFormat'])\n controls.setCreationOptions(outControls['gdalCOOptions'])\n controls.setCalcStats(outControls['calcStats'])\n\n # Set up parameters\n otherargs = applier.OtherInputs()\n otherargs.thetaref = thetaref\n otherargs.nFactor = nFactor\n otherargs.filterSize = filterSize\n \n # Run correction\n controls.progress = cuiprogress.CUIProgressBar()\n applier.apply(castelCorrection, infiles, outfiles, otherargs, controls=controls)\n\ndef runCorrectionDIR(inDIR, sigmaExt='utm', lincExt='inc', pixExt='pix', outExt='kea', thetaref=39.0, nFactor=1, filterSize=None):\n \"\"\" Run correction for directory.\n Finds files based on supplied extension.\n \"\"\"\n try:\n inlinc = glob.glob(inDIR + '/*' + lincExt)[0]\n inpix = glob.glob(inDIR + '/*' + pixExt)[0]\n except Exception as err:\n print(\"Couldn't find local incidence angle or pixel area images, is the extension correct?\")\n print(err)\n \n inSigmaList = glob.glob(inDIR + '/*' + sigmaExt)\n \n for insigma in inSigmaList:\n insigmaBase = os.path.splitext(insigma)[0]\n outsigma = insigmaBase + '_topo.' + outExt\n runCorrection(insigma, inlinc, inpix, outsigma, thetaref, nFactor, filterSize)\n\nif __name__ == '__main__':\n\n # Read in parameters\n \n parser = argparse.ArgumentParser()\n parser.add_argument(\"-i\", \"--insigma\", type=str, required=True, help=\"Input sigma0 file\")\n parser.add_argument(\"-p\", \"--inpix\", type=str, required=True, help=\"Input pixel area\")\n parser.add_argument(\"-l\", \"--inlinc\", type=str, required=True, help=\"Input local incidence angle\")\n parser.add_argument(\"-o\", \"--outsigma\", type=str, required=True, help=\"Output topographically corrected sigma0\")\n parser.add_argument(\"--thetaref\", type=float, required=False, default=39.0, help=\"Reference incidence angle (default 39)\")\n parser.add_argument(\"--n\", type=float, required=False, default=1.0, help=\"n parameter (default 1)\")\n parser.add_argument(\"--filterSize\", type=int, required=False, default=None, help=\"Size of filter to apply to linc and pix data\")\n args = parser.parse_args() \n\n # Run\n runCorrection(args.insigma, args.inlinc, args.inpix, args.outsigma, args.thetaref, args.n, args.filterSize)\n \n\n", "meta": {"hexsha": "d9d01ceb1fc503f079fd242bfa6f643d23dad04b", "size": 6579, "ext": "py", "lang": "Python", "max_stars_repo_path": "Gamma/Python/TopoCorrect/topoCorrection.py", "max_stars_repo_name": "petebunting/rsgis_scripts", "max_stars_repo_head_hexsha": "b35b0403cdfad6c63824d4f8c038f190cdb5978d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2020-09-16T10:45:15.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-06T04:34:32.000Z", "max_issues_repo_path": "Gamma/Python/TopoCorrect/topoCorrection.py", "max_issues_repo_name": "petebunting/rsgis_scripts", "max_issues_repo_head_hexsha": "b35b0403cdfad6c63824d4f8c038f190cdb5978d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Gamma/Python/TopoCorrect/topoCorrection.py", "max_forks_repo_name": "petebunting/rsgis_scripts", "max_forks_repo_head_hexsha": "b35b0403cdfad6c63824d4f8c038f190cdb5978d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-07-06T18:03:40.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-15T12:45:34.000Z", "avg_line_length": 35.3709677419, "max_line_length": 132, "alphanum_fraction": 0.699498404, "include": true, "reason": "import numpy,from scipy", "num_tokens": 1682, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166195971441, "lm_q2_score": 0.37022539259558657, "lm_q1q2_score": 0.1894504863880391}} {"text": "#from phil import *\nfrom sys import exit\nimport math\nfrom os.path import exists\nfrom pathlib import Path\nimport pandas as pd\nimport numpy as np\nfrom . import util\nfrom . import preprocess\nfrom . import imhc_scoring\nfrom . import cd8_scoring\nfrom .tcrdist.all_genes import all_genes\n\n\ncdr3_score_FG = 'fg'\ncdr3_score_CENTER = 'cen'\n\ncdr3_score_modes = [ cdr3_score_FG, cdr3_score_CENTER ]\ndefault_cdr3_score_mode = cdr3_score_FG\n\nfg_trim = 4\ncenter_len = 5\n\naa_props_file = Path.joinpath( Path(util.path_to_data), 'aa_props.tsv')\nassert exists(aa_props_file)\naa_props_df = pd.read_csv(aa_props_file, sep='\\t')\naa_props_df.set_index('aa', inplace=True)\n\n# all_tcr_scorenames = ['alphadist', 'cd8', 'cdr3len', 'imhc', 'mait', 'inkt'] +\\\n# [ '{}_{}'.format(x,y) for x in aa_props_df.columns for y in cdr3_score_modes ]\n\n#tmp hacking SIMPLIFY -- dont include info on which version of the loop is used for scoring\nall_tcr_scorenames = ['alphadist', 'cd8', 'cdr3len', 'imhc', 'mait', 'inkt', 'nndists_tcr'] + list(aa_props_df.columns)\n\namino_acids = ['A', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K', 'L', \\\n 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'Y']\n\ndef read_cd8_score_params():\n # setup the scoring params\n # made by read_flunica_gene_usage_clustermaps*py\n infofile = Path.joinpath( Path(util.path_to_data), 'cd48_score_params_nomait.txt')\n\n scoretags = 'cdr3_len cdr3_aa gene'.split()\n\n all_scorevals = {'A':{}, 'B':{} }\n for tag in scoretags:\n all_scorevals['A'][tag] = {}\n all_scorevals['B'][tag] = {}\n\n\n min_l2e = -0.6\n max_l2e = 0.6\n\n # scores reflect cd8 versus cd4 preference\n\n for line in open(infofile,'r'):\n l = line.split()\n tag = l[0]\n assert tag.endswith('_cdx_pval:')\n tag = tag[:-10]\n key = l[10]\n if tag[:4] == 'cdr3':\n ab = tag[4]\n tag = tag[:4]+tag[5:]\n else:\n assert key[:2] == 'TR'\n ab = key[2]\n assert tag in scoretags\n assert l[6] == 'cd4:'\n cd4_mean = float(l[7])\n cd8_mean = float(l[9])\n tot = 0.5*(cd4_mean + cd8_mean)\n if not tot:\n l2e = 0.0\n elif cd8_mean==0:\n l2e = min_l2e\n else:\n l2e = max( min_l2e, min( max_l2e, math.log( cd8_mean / tot, 2.0 ) ) )\n\n all_scorevals[ab][tag][key] = l2e\n #print '{:7.3f} {} {} {}'.format(l2e,ab,tag,key)\n return all_scorevals\n\nall_scorevals = read_cd8_score_params()\n\ndef cd8_score_tcr_chain( ab, v, j, cdr3 ):\n global all_scorevals\n\n cdr3_len_ranges = { 'A': ( min( int(x) for x in all_scorevals['A']['cdr3_len'] ),\n max( int(x) for x in all_scorevals['A']['cdr3_len'] ) ),\n 'B': ( min( int(x) for x in all_scorevals['B']['cdr3_len'] ),\n max( int(x) for x in all_scorevals['B']['cdr3_len'] ) ) }\n\n assert ab in 'AB'\n if '-' in v:\n v = v[:v.index('-')]\n if '-' in j:\n j = j[:j.index('-')]\n v_score = all_scorevals[ab]['gene'].get(v,0.0)\n j_score = all_scorevals[ab]['gene'].get(j,0.0)\n mn,mx = cdr3_len_ranges[ab]\n L = max( mn, min( mx, len(cdr3) ) )\n cdr3_len_score = all_scorevals[ab]['cdr3_len'][str(L)]\n cdr3_aa_score = 0.0\n if L>8:\n for aa in cdr3[4:-4]:\n cdr3_aa_score += all_scorevals[ab]['cdr3_aa'][aa]\n score = v_score + j_score + cdr3_len_score + cdr3_aa_score\n\n return ( score, v_score, j_score, cdr3_len_score, cdr3_aa_score )\n\ndef old_imhc_score_cdr3( cdr3 ): # cdr3 is untrimmed!\n '''This is the old version of the score, \"fit\" by staring at the sequences a little bit\n '''\n if len(cdr3) <= 8:\n return 0\n fgloop = cdr3[4:-4]\n return ( len(fgloop) + 3.0 * fgloop.count('C') + 2.0 * fgloop.count('W') + fgloop.count('R') + fgloop.count('K')\n + 0.5*fgloop.count('H') - fgloop.count('D') - fgloop.count('E') )\n\ndef old_imhc_score_tcr( tcr ):\n '''This is the old version of the score, \"fit\" by staring at the sequences a little bit\n '''\n return old_imhc_score_cdr3( tcr[0][2] ) + 2*old_imhc_score_cdr3( tcr[1][2] ) # double-weight the beta CDR3\n\n\ndef cd8_score_tcr( tcr ):\n atcr, btcr = tcr\n return ( cd8_score_tcr_chain( 'A', atcr[0], atcr[1], atcr[2] )[0] +\n cd8_score_tcr_chain( 'B', btcr[0], btcr[1], btcr[2] )[0] )\n\ndef is_human_mait_alpha_chain(atcr):\n return ( atcr[0].startswith('TRAV1-2') and\n ( atcr[1].startswith('TRAJ33') or\n atcr[1].startswith('TRAJ20') or\n atcr[1].startswith('TRAJ12') ) and\n len(atcr[2]) == 12 )\n\ndef is_mouse_mait_alpha_chain(atcr):\n return ( atcr[0].startswith('TRAV1-') and atcr[1].startswith('TRAJ33') and len(atcr[2]) == 12 )\n\ndef is_mouse_inkt_alpha_chain(atcr):\n return ( atcr[0].startswith('TRAV11') and atcr[1].startswith('TRAJ18') and len(atcr[2]) == 15 )\n\ndef is_human_inkt_tcr(tcr):\n # could also put some limits on cdr3s?\n return ( tcr[0][0].startswith('TRAV10') and\n tcr[0][1].startswith('TRAJ18') and\n len(tcr[0][2]) in [14,15,16] and # 15 seems to be the consensus\n tcr[1][0].startswith('TRBV25') )\n\n\ndef mait_score_tcr(tcr, organism):\n if 'human' in organism:\n return float(is_human_mait_alpha_chain(tcr[0]))\n\n elif 'mouse' in organism:\n return float(is_mouse_mait_alpha_chain(tcr[0]))\n\n else:\n print('unrecognized organism:', organism)\n exit()\n return 0.\n\n\ndef inkt_score_tcr(tcr, organism):\n if 'human' in organism:\n return float(is_human_inkt_tcr(tcr))\n\n elif 'mouse' in organism:\n return float(is_mouse_inkt_alpha_chain(tcr[0]))\n\n else:\n print('unrecognized organism:', organism)\n exit()\n return 0.\n\n\ndef read_locus_order( remove_slashes_from_gene_names= False ):\n ''' returns all_locus_order: all_locus_order[ab][gene] = int(l[1])\n '''\n # read the gene order from imgt\n all_locus_order = {'A':{}, 'B':{}}\n for ab in 'AB':\n fn = f'imgt_tr{ab.lower()}_locus_order.txt'\n filename = Path.joinpath( Path( util.path_to_data ), fn)\n assert exists(filename)\n for line in open(filename,'r'):\n l = line.split()\n if l[0] == 'IMGT':continue\n assert len(l) in [2,3]\n gene = l[0]\n if '/' in gene and remove_slashes_from_gene_names:\n print( 'remove /',gene)\n gene = gene.replace('/','')\n all_locus_order[ab][gene] = int(l[1])\n return all_locus_order\n\nall_locus_order = read_locus_order()\n\ntrav_list = [ x[1] for x in sorted( (y,x) for x,y in all_locus_order['A'].items() if x[:4] == 'TRAV' ) ]\ntraj_list = [ x[1] for x in sorted( (y,x) for x,y in all_locus_order['A'].items() if x[:4] == 'TRAJ' ) ]\n\n\ndef alphadist_score_tcr( tcr ):\n global trav_list\n global traj_list\n va, ja = tcr[0][:2]\n # print(va)\n # print(ja)\n if \"-\" in va :\n va = va[:va.index('-')]\n if \"-\" in ja :\n ja = ja[:ja.index('-')]\n if va in trav_list:\n va_dist = len(trav_list)-1 -trav_list.index(va)\n else:\n #print('alphadist_score_tcr: unrecognized va:', va)\n va_dist = 0.5*(len(trav_list)-1)\n\n if ja in traj_list:\n ja_dist = traj_list.index(ja)\n else:\n #print('alphadist_score_tcr: unrecognized ja:', ja)\n ja_dist = 0.5*(len(traj_list)-1)\n return va_dist + ja_dist\n\ndef cdr3len_score_tcr(tcr):\n ''' double-weight the beta chain\n '''\n return len(tcr[0][2]) + 2*len(tcr[1][2])\n\n\n\ndef property_score_cdr3(cdr3, score_name, score_mode):\n ''' Currently averages the score over the number of aas scores\n '''\n global aa_props_df\n global cdr3_score_CENTER\n global cdr3_score_FG\n global fg_trim\n global center_len\n\n col = aa_props_df[score_name]\n\n if score_mode == cdr3_score_CENTER:\n cdr3 = cdr3[1:] # trim off the first 'C', makes structurally symmetric\n if len(cdr3) self.loss: \n print (\" >> nLabels:\", nLabels, \" reached minLabels:\", self.params.minLabels, \" with loss: %.2f.\"%self.loss.item())\n break\n return self\n \n def save_outputs(self):\n if not os.path.exists(self.folder + self.fname.replace(self.extn, \"_seg\" + self.extn)):\n output = self.model(self.data)[0]\n output = output.permute(1, 2, 0).contiguous().view(-1, self.params.nChannel)\n ignore, target = torch.max(output, 1)\n self.im_target = target.data.cpu().numpy()\n self.unique_targets = np.array([self.label_colours[c % 100] for c in np.unique(self.im_target)])\n self.im_target_rgb = np.array([self.label_colours[c % 100] for c in self.im_target])\n self.im_target_rgb = self.im_target_rgb.reshape(self.im.shape).astype(np.uint8)\n cv2.imwrite(self.folder + self.fname.replace(self.extn, \"_seg\" + self.extn), self.im_target_rgb)\n return self\n \n def check_intensity(self, mask):\n # Check the intensity bound on the output\n ints = False\n gray = np.copy(self.images[\"gray\"])\n gray = cv2.bitwise_and(gray, gray, mask=mask)\n if np.quantile(gray.ravel(), 0.05) >= 0 and np.quantile(gray.ravel(), 0.95) <= 100: ints = True\n return ints\n \n def estimate_CHB(self):\n if not os.path.exists(self.folder + self.fname.replace(self.extn, \"_msk\" + self.extn)):\n maskList = []\n for targ in self.unique_targets:\n mask = cv2.inRange(self.im_target_rgb, targ-1, targ+1)\n mask = cv2.bitwise_and(mask, mask, mask=self.images[\"hc_mask\"])\n if np.count_nonzero(mask) < 0.1*self.NzC and self.check_intensity(mask):\n maskList.append(mask)\n self.totalmask = np.array(maskList).sum(axis=0)\n cv2.imwrite(self.folder + self.fname.replace(self.extn, \"_msk\" + self.extn), self.totalmask)\n else:\n fname = self.folder + self.fname.replace(self.extn, \"_msk\" + self.extn)\n self.totalmask = cv2.cvtColor(cv2.imread(fname, cv2.IMREAD_COLOR), cv2.COLOR_BGR2GRAY)\n return self\n \n def rescale_prob(self, prob, l=0., u=0.5):\n prob = prob*(u-l) + l\n return prob\n \n def calculate_probabilistic_boundaries(self):\n self.contours, self.hierarchy = cv2.findContours((255-self.totalmask).astype(np.uint8), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n for ix in range(len(self.contours)):\n if ix > 0: self.draw_contour(self.contours[int(ix)], self.images[\"prob_masked_image\"])\n cv2.imwrite(self.folder + self.fname.replace(self.extn, \"_stg0.0_out\" + self.extn), self.images[\"prob_masked_image\"])\n gray, mask = np.copy(self.images[\"gray\"]), np.zeros_like(self.images[\"gray\"])\n contours = self.contours[1:]\n cv2.drawContours(mask, contours, -1, 255, -1); mask = cv2.bitwise_and(gray, gray, mask=mask)\n maskplot = np.copy(mask)\n cv2.imwrite(self.folder + self.fname.replace(self.extn, \"_stg0.1_out\" + self.extn), mask)\n thds = [16, 24, 32, 48, 64, 96, 128, 255]\n linked_list = []\n for td in thds:\n masked = np.zeros_like(mask)\n masked[mask <= td] = 255\n masked = cv2.bitwise_and(masked, masked, mask=mask)\n blurs = cv2.blur((255 - masked).astype(np.uint8), (3, 3))\n contours, hierarchy = cv2.findContours(blurs, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n for ix in range(len(contours)):\n if ix > 0 and hierarchy[0,ix,3] == 0:\n cimg = np.zeros_like(gray)\n cv2.drawContours(cimg, contours, int(ix), color=255, thickness=-1)\n pts = np.where(cimg == 255)\n intensity = self.intensity_threshold-gray[pts[0], pts[1]].ravel().astype(int)\n prob = 1-np.mean(1./(1.+np.exp(intensity)))\n colw = np.array([255,255,255])\n #print(td, \"->\", prob)\n linked_list.append({\"prob\":prob, \"color\":255*prob, \"contour\":contours[int(ix)]})\n cv2.drawContours(maskplot, contours, int(ix), color=255*prob, thickness=1)\n self.draw_contour(contours[int(ix)], self.images[\"prob_masked_image_ol\"], col=tuple(colw*prob), line_thick=1)\n cv2.imwrite(self.folder + self.fname.replace(self.extn, \"_stg0.2.%03d_out\" + self.extn)%td, masked)\n cv2.imwrite(self.folder + self.fname.replace(self.extn, \"_stg1.0_out\" + self.extn), self.images[\"prob_masked_image_ol\"])\n maskplot = cv2.cvtColor(maskplot, cv2.COLOR_GRAY2RGB)\n maskplot = cv2.applyColorMap(maskplot, cv2.COLORMAP_JET)\n cv2.imwrite(self.folder + self.fname.replace(self.extn, \"_stg1.1_out\" + self.extn), maskplot)\n self.plot_image_dev(self.images[\"prob_masked_image_ol\"], linked_list)\n self.plot_image_dev(maskplot, linked_list, cmap=mpl.cm.jet, ext=\"_cb_jet\")\n return self\n \n def plot_image_dev(self, image, objs, shape=(15,14), cmap=mpl.cm.gray, ext=\"_cb_gray\"):\n df = pd.DataFrame.from_records(objs)[[\"prob\",\"color\"]]\n fig = plt.figure(figsize=(4, 4), dpi=180)\n ax = plt.subplot2grid(shape, (0,0), rowspan=shape[0]-2, colspan=shape[0]-2)\n ax.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))\n ax.set_xticks([])\n ax.set_yticks([])\n norm = mpl.colors.Normalize(vmin=0, vmax=1)\n ax = plt.subplot2grid(shape, (2,shape[0]-2), rowspan=9, colspan=1)\n cb1 = mpl.colorbar.ColorbarBase(ax, cmap=cmap,\n norm=norm,\n orientation=\"vertical\")\n cb1.set_label(\"Pr(CH)\")\n fig.savefig(self.folder + self.fname.replace(self.extn, ext + self.extn), bbox_inches=\"tight\")\n return\n \n def draw_contour(self, contour, img, gray=False, col=None, line_thick=None):\n if line_thick is None: line_thick = self.draw_param[\"contur\"][\"thick\"]\n if col is None: col=tuple(self.draw_param[\"contur\"][\"color\"])\n for _x in range(contour.shape[0]-1):\n if gray: cv2.line(img, (contour[_x,0,0], contour[_x,0,1]), (contour[_x+1,0,0], contour[_x+1,0,1]), (255,255,255), line_thick)\n else: cv2.line(img, (contour[_x,0,0], contour[_x,0,1]), (contour[_x+1,0,0], contour[_x+1,0,1]), col, line_thick)\n if gray: cv2.line(img, (contour[0,0,0], contour[0,0,1]), (contour[-1,0,0], contour[-1,0,1]), (255,255,255), line_thick)\n else: cv2.line(img, (contour[0,0,0], contour[0,0,1]), (contour[-1,0,0], contour[-1,0,1]), col, line_thick)\n return\n \n def save_files_outputs(self):\n return self\n\ndef run_skynet(args, save=True):\n aia = RegisterAIA(args.date, args.wavelength, args.resolution, vmin=10)\n load = Loader(aia.fname, aia.folder, args.date, args, save)\n load.load_model().run_forwarding().save_outputs().estimate_CHB()\n load.calculate_probabilistic_boundaries()\n if save: load.save_files_outputs()\n return\n\nif __name__ == \"__main__\":\n parser = argparse.ArgumentParser(description=\"PyTorch Unsupervised Segmentation\")\n parser.add_argument(\"-dn\", \"--date\", default=dt.datetime(2018,5,30,12), help=\"Date [2018,5,30,12]\", type=prs.parse)\n parser.add_argument(\"-r\", \"--resolution\", default=1024, help=\"Resolution of the files [1024]\", type=int)\n parser.add_argument(\"-w\", \"--wavelength\", default=193, help=\"Wavelength of the files [193]\", type=int)\n parser.add_argument(\"--nChannel\", metavar=\"N\", default=50, type=int, help=\"number of channels\")\n parser.add_argument(\"--maxIter\", metavar=\"T\", default=100, type=int, help=\"number of maximum iterations\")\n parser.add_argument(\"--minLabels\", metavar=\"minL\", default=3, type=int, help=\"minimum number of labels\")\n parser.add_argument(\"--lr\", metavar=\"LR\", default=0.3, type=float, help=\"learning rate\")\n parser.add_argument(\"--nConv\", metavar=\"M\", default=2, type=int, help=\"number of convolutional layers\")\n parser.add_argument(\"--stepsize_sim\", metavar=\"SIM\", default=1, type=float, help=\"step size for similarity loss\", required=False)\n parser.add_argument(\"--stepsize_con\", metavar=\"CON\", default=1, type=float, help=\"step size for continuity loss\")\n parser.add_argument(\"--los\", metavar=\"LOS\", default=.1, type=float, help=\"Final loss value\")\n args = parser.parse_args()\n print(\"\\n Parameter list for SkyNet simulation \")\n for k in vars(args).keys():\n print(\" \" + k + \"->\" + str(vars(args)[k]))\n run_skynet(args)\n", "meta": {"hexsha": "0dcb4b1ac0e12b9497901e7590f0fcb1cf68ac17", "size": 19146, "ext": "py", "lang": "Python", "max_stars_repo_path": "core/skynet.py", "max_stars_repo_name": "shibaji7/ISWAT_CV", "max_stars_repo_head_hexsha": "6239f021b597b66bca213cbc28ad7185f566c0f9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-06-30T14:18:49.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-30T14:18:49.000Z", "max_issues_repo_path": "core/skynet.py", "max_issues_repo_name": "shibaji7/ISWAT_CV", "max_issues_repo_head_hexsha": "6239f021b597b66bca213cbc28ad7185f566c0f9", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "core/skynet.py", "max_forks_repo_name": "shibaji7/ISWAT_CV", "max_forks_repo_head_hexsha": "6239f021b597b66bca213cbc28ad7185f566c0f9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 49.4728682171, "max_line_length": 141, "alphanum_fraction": 0.6054528361, "include": true, "reason": "import numpy,import astropy", "num_tokens": 4936, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.370225399544253, "lm_q1q2_score": 0.18945048443002818}} {"text": "\"\"\"\ngc.head() offers functions for calling specific simulation scenarios and\nproducing plots and processed data files from the simulation results. Contains\nfunctionality better suited for smaller as well as larger simulations as well\nas evaluations of specific parameter changes or vaccination scenarios.\n\"\"\"\n\nfrom __future__ import division\nfrom builtins import range\nimport math\nimport numpy as np\nimport pandas as pd\nimport scipy.stats\nimport time\nimport seaborn\nfrom collections import Counter\nfrom importlib import *\n\nimport cf\nimport gc_memo\nimport gc_plots\n\nreload(cf)\nreload(gc_memo)\nreload(gc_plots)\n\nfrom gc_memo import main\nfrom gc_plots import *\n\n\ndef small_scale(store_export='dictionary'):\n \"\"\" Performs a single simulation of the given system, creates\n the following plots:\n - population dynamics overview (free naive cells, free memory cells\n and GC populations over time)\n - for each GC, a clonal composition plot together with its memory\n output in a separate panel\n - for each GC, the evolution of its largest clone's affinities over\n mutation count (this plot contains aritificial noise to increase\n visibility!).\n\n If store_export is set 'datafile', the simulation data is stored in a\n hdf5 file for future purposes, for 'dictionary' the data is passed\n internally and discarded after the run.\n\n Recommended only for small simulation sizes with up to ~5 GCs and ~5k\n cells, as otherwise things get crowded and plots get large.\n \"\"\"\n # get runID from current system time\n runID = int(time.time())\n # run simulation and get filepath or dict\n simdata = main(runID, store_export=store_export, evalperday=12)\n # import required information for small scale plots\n l_times, l_fn, l_fm, l_GCs, LFcurve, Agcurve, evaltimes, freePan, GCPans, \\\n ms_times, ms_vals, ms_fams, ms_muts, mut_list, \\\n E_list = import_file(simdata)\n # plot population behaviour\n population_plot(l_times, l_fn, l_fm, l_GCs, runID)\n # plot GC contents and memory output for every GC\n for i in range(len(l_GCs)):\n GC_dynamics_plot(GCPans[i], ms_times[i], ms_fams[i], ms_vals[i],\n ms_muts[i], runID, i)\n\n return(simdata)\n\n\ndef TUCHMI_sampling(store_export='datafile', d_export=True, subsample=12):\n \"\"\" Performs a single simulation of a given size using the TUCHMI vaccination\n protocol, samples memory from the simulated pool and creates several plots\n summarising the information. User settings regarding the protocol are\n overwritten.\n\n Plots produced include:\n - mean SHMs and clonal expansion (fraction of cells sampled from\n clones that appeared more than once within the sample) in samples of\n size subsample\n - scatter plot of affinity over mutational status in polyclonal samples\n at TUCHMI time points I, II and III\n - scatter plot of affinity over mutational status at a clonal level,\n cells sampled from three TUCHMI time points merged into single plots\n (but sampling time point encoded in colouring)\n\n If store_export is set 'datafile', the simulation data is stored in a\n hdf5 file for future purposes, for 'dictionary' the data is passed\n internally and lost after the run.\n\n If d_export is set True, textfiles containing the sampled data (used for\n plotting) are exported for each plot individually.\n\n Subsample gives the number of cells to be sampled at each timepoint in\n oder to calculate entropy and unique fraction.\n\n Can be used for all simulation sizes, but is especially useful for larger\n simulations (e.g. >=50 GCs, 50k cells).\n \"\"\"\n # give protocol\n cf.endtime = 126*12\n cf.tinf = [0*12, 28*12, 56*12]\n cf.dose = [1, 1, 1]\n\n # get runID from current system time\n runID = int(time.time())\n\n # run simulation and get filepath or dict\n simdata = main(runID, store_export=store_export, evalperday=1)\n\n # import required information\n l_times, l_fn, l_fm, l_GCs, LFcurve, Agcurve, evaltimes, freePan, GCPans, \\\n ms_times, ms_vals, ms_fams, ms_muts, mut_list, E_list = \\\n import_file(simdata)\n\n # for affinity-mutation scatter plot, downsample for visibility\n pick_tp = 35*12\n samplefrac = 100./len(freePan.sel(timepoint = pick_tp).dropna(\"dim_0\"))\n\n # get list of lists to catch values at every timepoint\n tList = list(freePan[\"timepoint\"].values)\n TT = len(tList)\n SHM_means = [[] for t in range(TT)]\n Entropies = [[] for t in range(TT)]\n clusterfracs = [[] for t in range(TT)]\n\n \"\"\" Cell pool affinity over time \"\"\"\n # get mean affinity at all time points\n Elist = []\n for tp in range(len(tList)):\n C = freePan.sel(timepoint = tList[tp]).loc[dict(dim_1=\"affinity\")].dropna(\"dim_0\").values.mean()\n Elist.append(C)\n # pass energies to plot function\n pool_affinity_plot(tList, Elist)\n\n \"\"\" Mean SHM and clonal expansion within sample of size subsample \"\"\"\n # sample 100 times to calculate standard deviations\n for nn in range(100):\n for tp in range(TT):\n ttp = 12*tp\n # cellnumber to be sampled is either subsample or, if less cells\n # are available (more of a hypothetic case really), all cells\n freePan_no_na = freePan.sel(timepoint = ttp).dropna(\"dim_0\")\n cellnum = min(subsample, len(freePan_no_na))\n if cellnum > 0:\n cell_id = np.random.choice(len(freePan_no_na), cellnum)\n cells = freePan_no_na[cell_id, :]\n c_muts = list(cells.loc[dict(dim_1=\"mutations\")].values)\n SHM_means[tp].append(np.nanmean(c_muts))\n # evaluate entropies and clusterfractions\n CC = Counter(list(cells.loc[dict(dim_1=\"family\")].values))\n Entropies[tp].append(scipy.stats.entropy(list(CC.values()), base=2)\n / math.log(cellnum, 2))\n # count again to find how many clones have one member only,\n # calculate clusterfrac from this\n sizedist = list(CC.values())\n C2 = Counter(sizedist)\n uniquefrac = float(C2[1])/cellnum\n clusterfracs[tp].append(1-uniquefrac)\n else:\n SHM_means[tp].append(np.nan)\n Entropies[tp].append(np.nan)\n uniquefrac[tp].append(np.nan)\n clusterfracs[tp].append(np.nan)\n\n # pass information to plotting function\n MSHM = np.nanmean(SHM_means, axis=1)\n SSHM = np.nanstd(SHM_means, axis=1)\n MEntropies = np.nanmean(Entropies, axis=1)\n SEntropies = np.nanstd(Entropies, axis=1)\n Mclusterfracs = np.nanmean(clusterfracs, axis=1)\n Sclusterfracs = np.nanstd(clusterfracs, axis=1)\n\n sample_statistics_plot(subsample, tList, MSHM, SSHM,\n MEntropies, SEntropies, Mclusterfracs,\n Sclusterfracs)\n\n \"\"\" Plot of affinity/mutations on tps I, II and III \"\"\"\n # sample cells 7 days post each infection, record SHM, KD and origin\n # (memory versus naive first activated ancestor)\n timecourse = [7*12, 35*12, 63*12]\n SHM_list = [[] for t in timecourse]\n KD_list = [[] for t in timecourse]\n orglist = [[] for t in timecourse]\n\n for d in range(len(timecourse)):\n tp = timecourse[d]\n freePan_no_na = freePan.sel(timepoint = tp).dropna(\"dim_0\")\n cellnum = int(np.round(len(freePan_no_na)*samplefrac))\n if cellnum > 0:\n cell_id = np.random.choice(len(freePan_no_na), cellnum)\n cells = freePan_no_na[cell_id, :]\n kdl = list(cells.loc[dict(dim_1=\"affinity\")].values)\n # transform norm E to KD\n kdll = np.exp(cf.y0+np.array(kdl)*cf.m)\n KD_list[d] = list(kdll)\n # get mutation counts, correct them and origin\n SHM_list[d] = list(cells.loc[dict(dim_1=\"mutations\")].values)\n orglist[d] = list(cells.loc[dict(dim_1=\"origin\")].values)\n\n # pass information to plot function\n sample_scatter_plot(KD_list, SHM_list, orglist)\n\n \"\"\" Affinity/mutation plots for individual clusters \"\"\"\n # samples from the memory pool at the given timepoints, split information\n # into clusters and plot SHM/KD scatter plots for some of these clusters.\n\n # lists to collect SHM, KD values, families and timepoints for all panels\n SHM_list = []\n KD_list = []\n fam_list = []\n tp_list = []\n\n for d in range(len(timecourse)):\n tp = timecourse[d]\n freePan_no_na = freePan.sel(timepoint = tp).dropna(\"dim_0\")\n cellnum = int(len(freePan_no_na)*samplefrac)\n if cellnum > 0:\n cell_id = np.random.choice(len(freePan_no_na), cellnum)\n cells = freePan_no_na[cell_id, :]\n kdl = list(cells.loc[dict(dim_1=\"affinity\")].values)\n # transform norm E to KD\n kdll = np.exp(cf.y0+np.array(kdl)*cf.m)\n KD_list += list(kdll)\n SHM_list += list(list(cells.loc[dict(dim_1=\"mutations\")].values))\n fam_list += list(cells.loc[dict(dim_1=\"family\")].values)\n tp_list += [tp for k in range(cellnum)]\n\n # count into families and find clusters with more than xx members\n famcounter = Counter(fam_list)\n fams = list(famcounter.keys())\n clusters = []\n for fam in fams:\n if famcounter[fam] > 1:\n clusters.append(fam)\n\n # make separate lists for SHM, KD and TP (defining color) within clusters\n # and add information to list\n iSHMs = [[] for i in clusters]\n iKDs = [[] for i in clusters]\n iTPs = [[] for i in clusters]\n\n for ff in range(len(fam_list)):\n if fam_list[ff] in clusters:\n ii = clusters.index(fam_list[ff])\n iSHMs[ii].append(SHM_list[ff])\n iKDs[ii].append(KD_list[ff])\n # give different colors for different timepoints\n if tp_list[ff] == timecourse[0]:\n iTPs[ii].append('lightcoral')\n elif tp_list[ff] == timecourse[1]:\n iTPs[ii].append('indianred')\n else:\n iTPs[ii].append('firebrick')\n # pass information to plot function\n clonal_scatter_plot(iSHMs, iKDs, iTPs)\n\n # write information to file\n if d_export:\n datafile = open('processed_data/TUCHMI_sampling_data', 'w')\n\n datafile.write('1) SAMPLE STATISTICS \\n \\n')\n datafile.write('sampled fraction = {} \\n \\n'.format(samplefrac))\n datafile.write('timecourse (days) \\n {} \\n \\n'.format(np.array(tList)/12.))\n datafile.write('SHMs of cells in sample, mean and std \\n {} \\n {} \\n \\n'.format(MSHM, SSHM))\n datafile.write('normalised Shannon entropy of cells in sample, mean and std \\n {} \\n {} \\n \\n'.format(MEntropies, SEntropies))\n datafile.write('fraction of non-unique cells in sample, mean and std \\n {} \\n {} \\n \\n'.format(Mclusterfracs, Sclusterfracs))\n\n datafile.close()\n\n return(simdata)\n\n\ndef selection_vs_mutation(store_export='dictionary', d_export=True):\n \"\"\" Performs a single simulation of a given size using a specified protocol\n of vaccination boosters. At specified timepoints, a specified number of\n memory cells is sampled and the affinities of their ancestors as well as\n their current affinities are written to a list. Also written to list\n are the binding energies of the naive cells. These three lists are then\n passed on to be plotted as distribution histograms.\n\n Plots produced include a collection of three histograms (unselected,\n selected germline energies, actual energies after mutations) for each\n queried timepoint and a more complex scatter plot with marginal histograms\n for each queried timepoint.\n\n For each timepoint, the fraction of cells with unaltered/improved/impaired\n affinity is printed to screen.\n\n If store_export is set 'datafile', the simulation data is stored in a\n hdf5 file for future purposes, for 'dictionary' the data is passed\n internally and lost after the run.\n\n If d_export is set True, textfiles containing the sampled data (used for\n plotting) are exported for each plot individually.\n \"\"\"\n # parameters relevant to this analysis\n # evaluation timepoint in days\n analysis_times = [29]\n # prepare lists\n ancestor_dists = []\n final_dists = []\n # get runID from current system time\n runID = int(time.time())\n # run simulation and get filepath or dict\n simdata = main(runID, store_export=store_export, evalperday=1)\n # import required information for small scale plots\n l_times, l_fn, l_fm, l_GCs, LFcurve, Agcurve, evaltimes, freePan, GCPans, \\\n ms_times, ms_vals, ms_fams, ms_muts, mut_list, E_list = \\\n import_file(simdata)\n # extract the affinities and ancestor affinities at the analysis points\n tList = list(freePan[\"timepoint\"].values)\n for i in range(len(analysis_times)):\n # limit cell number to be drawn in order not to clatter the plot\n tp = analysis_times[i]\n freePan_no_na = freePan.sel(timepoint = tList[tp]).dropna(\"dim_0\")\n cellnum = min(2000, len(freePan_no_na))\n cellnum = len(freePan_no_na)\n cell_id = np.random.choice(len(freePan_no_na), cellnum)\n cells = freePan_no_na[cell_id, :]\n afflist = list(cells.loc[dict(dim_1=\"affinity\")].values)\n final_dists.append(afflist)\n aff0list = list(cells.loc[dict(dim_1=\"affinity0\")].values)\n ancestor_dists.append(aff0list)\n # send energy lists to histogram plot\n for i in range(len(analysis_times)):\n energy_distributions_plot(E_list, ancestor_dists[i], final_dists[i],\n analysis_times[i])\n energy_scatter_plot(ancestor_dists[i], final_dists[i],\n analysis_times[i])\n\n if d_export:\n datafile = open('processed_data/energy_distribution_data', 'w')\n\n datafile.write('1) naive distribution \\n \\n')\n datafile.write('{} \\n \\n'.format(E_list))\n\n datafile.write('2) analysis days \\n \\n')\n datafile.write('{} \\n \\n'.format(analysis_times))\n\n datafile.write('3) ancestor distributions per time point \\n \\n')\n datafile.write('{} \\n \\n'.format(ancestor_dists))\n\n datafile.write('4) memory distributions per time point \\n \\n')\n datafile.write('{} \\n \\n'.format(final_dists))\n\n datafile.close()\n\n return(simdata)\n\n\ndef stacked_mutations(store_export='dictionary', d_export=True,\n repeats=10):\n \"\"\" Performs a number of simulation runs, computes histograms for\n improved, impaired and unchanged binders at a single given timepoint\n and saves the individual as well as the summed values to file. For several\n repeats, data is accumulated in the histograms as well.\n\n If store_export is set 'datafile', the simulation data is stored in a\n hdf5 file for future purposes, for 'dictionary' the data is passed\n internally and lost after the run.\n\n If d_export is set True, textfiles containing the sampled data (used for\n plotting) are exported for each plot individually.\"\"\"\n # parameters relevant to this analysis\n # evaluation timepoint in days\n analysis_time = 29\n bins = np.linspace(0.6, 1, 17)\n # collect results\n sum_zero = np.zeros(len(bins)-1)\n sum_plus = np.zeros(len(bins)-1)\n sum_minus = np.zeros(len(bins)-1)\n list_zero = []\n list_plus = []\n list_minus = []\n\n for i in range(repeats):\n # get runID from current system time\n runID = int(time.time())\n # run simulation and get filepath or dict\n simdata = main(runID, store_export=store_export, evalperday=1)\n # import required information for small scale plots\n l_times, l_fn, l_fm, l_GCs, LFcurve, Agcurve, evaltimes, freePan, \\\n GCPans, ms_times, ms_vals, ms_fams, ms_muts, mut_list, E_list = \\\n import_file(simdata)\n # extract the affinities and ancestor affinities at the analysis points\n tList = list(freePan[\"timepoint\"].values)\n # limit cell number to be drawn in order not to clatter the plot\n # possibility of subsampling here\n tp = analysis_time\n\n freePan_no_na = freePan.sel(timepoint = tList[tp]).dropna(\"dim_0\")\n cellnum = len(freePan_no_na)\n cell_id = np.random.choice(len(freePan_no_na), cellnum)\n cells = freePan_no_na[cell_id, :]\n\n final_dist = list(cells.loc[dict(dim_1=\"affinity\")].dropna(\"dim_0\").values)\n ancestor_dist = list(cells.loc[dict(dim_1=\"affinity0\")].dropna(\"dim_0\").values)\n\n # extract counts of unchanged, improved and impaired cells\n unchanged_list = np.array(final_dist)[np.where(np.array(\n ancestor_dist) == np.array(final_dist))[0]]\n improved_list = np.array(final_dist)[np.where(np.array(\n ancestor_dist) < np.array(final_dist))[0]]\n impaired_list = np.array(final_dist)[np.where(np.array(\n ancestor_dist) > np.array(final_dist))[0]]\n\n # make histograms, store information both in list and in sum.\n U_counts, _ = np.histogram(unchanged_list, bins=bins)\n plus_counts, _ = np.histogram(improved_list, bins=bins)\n minus_counts, _ = np.histogram(impaired_list, bins=bins)\n\n # collect results\n sum_zero += U_counts\n sum_plus += plus_counts\n sum_minus += minus_counts\n list_zero.append(U_counts)\n list_plus.append(plus_counts)\n list_minus.append(minus_counts)\n cellsum = np.sum(sum_zero)+np.sum(sum_plus)+np.sum(sum_minus)\n\n # plot\n stacked_energy_plot(bins, sum_plus, sum_minus, sum_zero, analysis_time)\n\n if d_export:\n datafile = open('processed_data/stacked_histogram_data', 'w')\n\n datafile.write('1) day \\n \\n')\n datafile.write('{} \\n \\n'.format(analysis_time))\n\n datafile.write('2) bins \\n \\n')\n datafile.write('{} \\n \\n'.format(bins))\n\n datafile.write('3) runs \\n \\n')\n datafile.write('{} \\n \\n'.format(repeats))\n\n datafile.write('4) sum of counts with unchanged energies\\n \\n')\n datafile.write('{} \\n \\n'.format(sum_zero))\n\n datafile.write('5) sum of counts with improved energies\\n \\n')\n datafile.write('{} \\n \\n'.format(sum_plus))\n\n datafile.write('6) sum of counts with impaired energies\\n \\n')\n datafile.write('{} \\n \\n'.format(sum_minus))\n\n datafile.write('7) list of counts with unchanged energies\\n \\n')\n datafile.write('{} \\n \\n'.format(list_zero))\n\n datafile.write('8) list of counts with improved energies\\n \\n')\n datafile.write('{} \\n \\n'.format(list_plus))\n\n datafile.write('9) list of counts with impaired energies\\n \\n')\n datafile.write('{} \\n \\n'.format(list_minus))\n\n datafile.write('10) percentage of umutated, improved, impaired \\n \\n')\n datafile.write('{}, {}, {}'.format(np.sum(sum_zero)/cellsum,\n np.sum(sum_plus)/cellsum, np.sum(sum_minus)/cellsum))\n datafile.close()\n\n\ndef AM_effect_nkey(nkeys=[1, 5, 10, 15], repeats=100, d_export=True):\n \"\"\" Given a list of values for nkey and a number of individual GC reactions\n to be averaged over for each of them, computes and plots the improvement\n within single GCs for one infection. Thus, overwrites parameters giving\n the infection protocol and duration of the simulation as well as setting\n the nubmer of GCs to 1. Other parameters remain untouched. A textfile with\n the computed mean results is exported if d_export==True.\n \"\"\"\n\n # set single infection and single GC for this analysis\n cf.endtime = 30*12\n cf.tinf = [0*12]\n cf.dose = [1]\n cf.nGCs = 1\n cf.naive_pool = 1000*1 # size of the naive precursor pool\n cf.memory_pool = 100*1 # size of the initial unspecific memory pool\n # function for calculating mean E_norm from GC panel\n\n def GC_affinity(GCPan):\n \"\"\" Given a GC panel, gets the mean E_norm for each timepoint.\"\"\"\n energies = []\n tList = list(GCPan[\"timepoint\"].values)\n\n for tp in range(len(tList)):\n energy = GCPan.sel(timepoint = tList[tp]).loc[dict(dim_1=\"affinity\")].dropna(\"dim_0\").values.mean()\n energies.append(energy)\n\n return tList, energies\n\n topElist = []\n for hs in nkeys:\n # set binding model parameters accordingly\n cf.nkey = hs\n cf.lAg = hs\n cf.lAb = 220 - hs\n eL = [] # list for collecting energies timecurses of all runs\n for r in range(repeats):\n simdata = main(store_export='dictionary', evalperday=12)\n l_times, l_fn, l_fm, l_GCs, LFcurve, Agcurve, evaltimes, freePan, \\\n GCPans, ms_times, ms_vals, ms_fams, ms_muts, mut_list, E_list\\\n = import_file(simdata)\n tList, energies = GC_affinity(GCPans[0])\n eL.append(energies)\n\n # calculate mean and std of all runs and plot\n eM = np.nanmean(np.array(eL), axis=0)\n eStd = np.nanstd(np.array(eL), axis=0)\n topElist.append((hs, tList, eM, eStd))\n\n # write information to file\n if d_export:\n datafile = open('processed_data/AM_effect_data', 'w')\n datafile.write('number of simulation runs per n_key = {} \\n'.format(repeats))\n datafile.write('n_key, time (days), mean(normalised energies), std(normalised energies) \\n')\n for i in range(len(nkeys)):\n datafile.write('{0}, {1}, {2}, {3}\\n \\n'.format(topElist[i][0], np.array(topElist[i][1])/12., topElist[i][2], topElist[i][3]))\n datafile.close()\n # plot\n AM_effect_plot(topElist)\n", "meta": {"hexsha": "b7cd536f816c12a4262bd6234bb738e80b62beab", "size": 21753, "ext": "py", "lang": "Python", "max_stars_repo_path": "gc_memo/gc_head.py", "max_stars_repo_name": "obrzts/gc_memo", "max_stars_repo_head_hexsha": "334a11765cc257848c6c4da1f99fa5559c10f2c6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "gc_memo/gc_head.py", "max_issues_repo_name": "obrzts/gc_memo", "max_issues_repo_head_hexsha": "334a11765cc257848c6c4da1f99fa5559c10f2c6", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "gc_memo/gc_head.py", "max_forks_repo_name": "obrzts/gc_memo", "max_forks_repo_head_hexsha": "334a11765cc257848c6c4da1f99fa5559c10f2c6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.1569767442, "max_line_length": 138, "alphanum_fraction": 0.6521399347, "include": true, "reason": "import numpy,import scipy", "num_tokens": 5489, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.3702253925955866, "lm_q1q2_score": 0.18945048087428024}} {"text": "\"\"\"\nBy Dr Jie Zheng -Q, NAOC\nv1 2019-04-27\n\"\"\"\n\n\nimport numpy as np\nfrom..util import *\n\n\ndef date_conv():\n pass\n\n\n #function date_conv,date,type, BAD_DATE = bad_date\n #;+\n #; NAME:\n #; DATE_CONV\n #; PURPOSE:\n #; Procedure to perform conversion of dates to one of three possible formats.\n #;\n #; EXPLANATION:\n #; The following date formats are allowed\n #;\n #; format 1: real*8 scalar encoded as:\n #; year*1000 + day + hour/24. + min/24./60 + sec/24./60/60\n #; where day is the day of year (1 to 366)\n #; format 2: Vector encoded as:\n #; date[0] = year (eg. 2005)\n #; date[1] = day of year (1 to 366)\n #; date[2] = hour\n #; date[3] = minute\n #; date[4] = second\n #; To indicate a date only, set a negative hour.\n #; format 3: string (ascii text) encoded as\n #; DD-MON-YEAR HH:MM:SS.SS\n #; (eg. 14-JUL-2005 15:25:44.23)\n #; OR\n #; YYYY-MM-DD HH:MM:SS.SS (ISO standard)\n #; (eg. 1987-07-14 15:25:44.23 or 1987-07-14T15:25:44.23)\n #;\n #; OR \n #; DD/MM/YY (pre-2000 option for FITS DATE keywords)\n #; Time of day segment is optional in all of these.\n #; \n #; format 4: three element vector giving spacecraft time words\n #; from a Hubble Space Telescope (HST) telemetry packet. Based on\n #; total number of secs since midnight, JAN. 1, 1979\n #;\n #; format 5: Julian day. As this is also a scalar, like format 1, \n #; \tthe distinction between the two on input is made based on their\n #; \tvalue. Numbers > 2300000 are interpreted as Julian days.\n #;\n #; CALLING SEQUENCE\n #; results = DATE_CONV( DATE, TYPE )\n #;\n #; INPUTS:\n #; DATE - input date in one of the possible formats. Must be scalar.\n #; TYPE - type of output format desired. If not supplied then\n #; format 3 (real*8 scalar) is used.\n #; valid values:\n #; 'REAL' - format 1\n #; 'VECTOR' - format 2\n #; 'STRING' - format 3\n #; 'FITS' - YYYY-MM-DDTHH:MM:SS.SS'\n #; 'JULIAN' - Julian date\n #; 'MODIFIED' - Modified Julian date (JD-2400000.5)\n #; TYPE can be abbreviated to the single character strings 'R',\n #; 'V', 'S', 'F', 'J', and 'M'.\n #; Nobody wants to convert TO spacecraft time (I hope!)\n #; OUTPUTS:\n #; The converted date is returned as the function value.\n #; Output is -1 if date is unrecognisable. \n #;\n #; If the time of day is omitted from the input, it will also\n #; be omitted from any output string (format STRING or FITS). \n #; Note that date-only strings are allowed by the FITS standard. \n #; For other output formats any missing time of day is set to \n #; 00:00:00.0\n #;\n #; KEYWORD OUTPUTS\n #;\n #; BAD_DATE set to 1B if date is unrecognisable\n #;\n #; EXAMPLES:\n #; IDL> print,date_conv('2006-03-13 19:58:00.00'),f='(f15.5)' \n #; 2006072.83194 \n #; IDL> print,date_conv( 2006072.8319444d,'F')\n #; 2006-03-13T19:58:00.00\n #; IDL> print,date_conv( 2006072.8319444d,'V')\n #; 2006.00 72.0000 19.0000 57.0000 59.9962\n #; IDL> print,date_conv( 2006072.8319444d,'J'), f='(f15.5)'\n #; 2453808.33194\n #;\n #;\n #; HISTORY:\n #; version 1 D. Lindler July, 1987\n #; adapted for IDL version 2 J. Isensee May, 1990\n #; Made year 2000 compliant; allow ISO format input jls/acc Oct 1998\n #; DJL/ACC Jan 1998, Modified to work with dates such as 6-JAN-1996 where\n #; day of month has only one digit.\n #; DJL, Nov. 2000, Added input/output format YYYY-MM-DDTHH:MM:SS.SS\n #; Replace spaces with '0' in output FITS format W.Landsman April 2006\n #; Added Julian date capabilities on input and output. M.Perrin, July 2007\n #; Removed spurious /WARN keyword to MESSAGE W.L. Feb 2012\n #; ...and another /WARN; added BAD_DATE, drop spurious time-of-day\n #; output from strings. J. P. Leahy July 2013\n #; changed all /CONTINUE warning messages to /INFO: can be suppressed \n #; by setting !QUIET = 1. J. P. Leahy July 2013\n #;-\n #;-------------------------------------------------------------\n #;\n #compile_opt idl2\n #; data declaration\n #;\n #days = [0,31,28,31,30,31,30,31,31,30,31,30,31]\n #months = [' ','JAN','FEB','MAR','APR','MAY','JUN','JUL','AUG','SEP','OCT',$\n # 'NOV','DEC']\n #;\n #; set default type if not supplied\n #;\n #if N_params() lt 2 then type = 'REAL'\n #;\n #; Determine type of input supplied\n #;\n #s = size(date) & ndim = s[0] & datatype = s[ndim+1]\n #if ndim gt 0 then begin ;vector?\n # if ndim gt 1 then goto,notvalid\n # if (s[1] ne 5) && (s[1] ne 3) then goto,notvalid\n # if (s[1] eq 5) then form = 2 else form = 4\n # end else begin ;scalar input\n # if datatype eq 0 then goto,notvalid\n # if datatype eq 7 then form = 3 $ ;string\n # else form = 1 ;numeric scalar\n #end\n #;\n #; -----------------------------------\n #;\n #;*** convert input to year,day,hour,minute,second\n #;\n #; -----------------------------------\n #case form of\n #\n # 1: begin ;real scalar\n #\t\t\t; The 'real' input format may be interpreted EITHER\n #\t\t\t; a) if < 2300000\n #\t\t\t; as the traditional 'real*8 encoded' format used by date_conv\n #\t\t\t; b) if > 2300000\n #\t\t\t; as a Julian Day Number\n # idate = long(date)\n # year = long(idate/1000)\n #\n #\t\t\t\tif year lt 2300 then begin\n #\t\t\t\t\t\n #\t\t\t\t\t; if year is only 2 digits, assume 1900\n #\t if year lt 100 then begin\n #\t message,/INF, $\n #\t 'Warning: Year specified is only 2 digits, assuming 19xx'\n #\t year=1900+year\n #\t idate=1900000+idate\n #\t date=1900000.+date\n #\t end\n #\t day = idate - year*1000\n #\t fdate = date-idate\n #\t fdate = fdate*24.\n #\t hour = fix(fdate)\n #\t fdate = (fdate-hour)*60.0\n #\t minute = fix(fdate)\n #\t sec = float((fdate-minute)*60.0)\n #\n #\t\t\t\tendif else begin\n #\t\t\t\t\tdaycnv, date, year, mn, mndy, hr\n #\t\t\t\t\t; convert from month/day to day of year\n #\t\t\t\t\t; how many days PRECEED the start of each month?\n #\t\t\t\t\tYDAYS = [0,31,59,90,120,151,181,212,243,273,304,334,366] \n #\t\t\t\t\tLEAP = (((YeaR MOD 4) EQ 0) AND ((YeaR MOD 100) NE 0)) OR $\n #\t\t\t\t\t ((YeaR MOD 400) EQ 0)\n #\t\t\t IF LEAP THEN YDAYS[2:*] = YDAYS[2:*] + 1\n #\t\t\t\t\tday = ydays[mn-1]+mndy\n #\t\t\t\t\t\n #\t\t\t\t\thour = fix(hr)\n #\t\t\t\t\tfmin = (hr-hour)*60\n #\t\t\t\t\tminute = fix(fmin)\n #\t\t\t\t\tsec = float((fmin-minute)*60)\n #\t\t\t\tendelse\n # end\n #\n # 2: begin ;vector\n # year = fix(date[0])\n #;\n #; if year is only 2 digits, assume 1900\n #;\n # if year lt 100 then begin\n # message,/INF, $\n # 'Warning: Year specified is only 2 digits, assuming 19xx'\n # year=1900+year\n # end\n #;\n # day = fix(date[1])\n # hour = fix(date[2])\n # minute = fix(date[3])\n # sec = float(date[4])\n # end\n #\n # 3: begin ;string\n # temp = date\n #;\n #; check for old type of date, DD-MMM-YYYY\n #;\n # test = STRPOS(temp,'-') \n # if test ge 0 && test le 2 then begin\n # day_of_month = fix(gettok(temp,'-'))\n # month_name = gettok(temp,'-')\n # year = fix(gettok(temp,' '))\n #;\n #; determine month number from month name\n #;\n # month_name = strupcase(month_name)\n # for mon = 1,12 do begin\n # if month_name eq months[mon] then goto,found\n # end\n # message,/INFORMATIONAL, 'Invalid month name specified'\n # goto, notvalid\n #;\n #; check for new type of date, ISO: YYYY-MM-DD\n #;\n # end else if strpos(temp,'-') eq 4 then begin\n # year = fix(gettok(temp,'-'))\n # month_name = gettok(temp,'-')\n # mon= FIX(month_name)\n # day_of_month=gettok(temp,' ')\n # if strlen(temp) eq 0 then begin\n # dtmp=gettok(day_of_month,'T')\n # temp=day_of_month\n # day_of_month=dtmp\n # end\n # day_of_month=fix(day_of_month)\n #;\n #; check for DD/MM/YY\n #;\n # end else if STRPOS(temp,'/') eq 2 then begin\n # day_of_month = FIX(gettok(temp,'/'))\n # mon = FIX(gettok(temp,'/'))\n # year = 1900 + FIX(STRMID(temp,0,2))\n # end else goto, notvalid\n # \n # found:\n # hour = gettok(temp,':')\n # hour = hour NE '' ? FIX(hour) : -1\n # minute = fix(gettok(temp,':'))\n # sec = float(strtrim(strmid(temp,0,5)))\n # \n # IF (mon LT 1 || mon GT 12) THEN BEGIN\n # MESSAGE, /INFORMATIONAL, 'Invalid month specified'\n # goto, notvalid\n # ENDIF\n #;\n #; if year is only 2 digits, assume 1900\n #;\n # if year lt 100 then begin\n # message,/INFORMATIONAL, $ \n # 'Warning: Year specified is only 2 digits, assuming 19xx'\n # year=1900+year\n # end\n #;\n #;\n #; convert to day of year from month/day_of_month\n #;\n #; correction for leap years\n #;\n #; if (fix(year) mod 4) eq 0 then days(2) = 29 ;add one to february\n # lpyr = ((year mod 4) eq 0) and ((year mod 100) ne 0) $\n # or ((year mod 400) eq 0)\n # if lpyr eq 1 then days[2] = 29 ; if leap year, add day to Feb.\n #;\n #;\n #; compute day of year\n #;\n # day = fix(total(days[0:mon-1])+day_of_month)\n # end\n #\n # 4 : begin ;spacecraft time\n # SC = DOUBLE(date)\n # SC = SC + (SC LT 0.0)*65536. ;Get rid of neg. numbers \n #;\n #; Determine total number of secs since midnight, JAN. 1, 1979\n #;\n # SECS = SC[2]/64 + SC[1]*1024 + SC[0]*1024*65536.\n # SECS = SECS/8192.0D0 ;Convert from spacecraft units \n #;\n #; Determine number of years \n #;\n # MINS = SECS/60.\n # HOURS = MINS/60.\n # TOTDAYS = HOURS/24.\n # YEARS = TOTDAYS/365.\n # YEARS = FIX(YEARS)\n #;\n #; Compute number of leap years past \n #;\n # LEAPYEARS = (YEARS+2)/4\n #;\n #; Compute day of year \n #;\n # DAY = FIX(TOTDAYS-YEARS*365.-LEAPYEARS)\n #;\n #; Correct for case of being right at end of leapyear\n #;\n # IF DAY LT 0 THEN BEGIN\n # DAY = DAY+366\n # LEAPYEARS = LEAPYEARS-1\n # YEARS = YEARS-1\n # END\n #;\n #; COMPUTE HOUR OF DAY\n #;\n # TOTDAYS = YEARS*365.+DAY+LEAPYEARS\n # HOUR = FIX(HOURS - 24*TOTDAYS)\n # TOTHOURS = TOTDAYS*24+HOUR\n #;\n #; COMPUTE MINUTE\n #;\n # MINUTE = FIX(MINS-TOTHOURS*60)\n # TOTMIN = TOTHOURS*60+MINUTE\n #;\n #; COMPUTE SEC\n #;\n # SEC = SECS-TOTMIN*60\n #;\n #; COMPUTE ACTUAL YEAR\n #;\n # YEAR = YEARS+79\n #;\n #; if year is only 2 digits, assume 1900\n #;\n # if year lt 100 then begin\n # message, /INF, $ \n # 'Warning: Year specified is only 2 digits, assuming 19xx'\n # year=1900+year\n # end\n #;\n #;\n #; START DAY AT ONE AND NOT ZERO\n #;\n # DAY++\n # END\n #ENDCASE\n #;\n #; correction for leap years\n #;\n # if form ne 3 then begin ;Was it already done?\n # lpyr = ((year mod 4) eq 0) && ((year mod 100) ne 0) $\n # || ((year mod 400) eq 0)\n # if lpyr eq 1 then days[2] = 29 ; if leap year, add day to Feb.\n # end\n #;\n #; check for valid day\n #;\n # if (day lt 1) || (day gt total(days)) then begin\n # message, /INFORMATIONAL, $\n # 'ERROR -- There are only ' + strtrim(fix(total(days)),2) + $\n #\t ' days in year '+strtrim(year,2)\n # goto, notvalid\n # endif \n #;\n #; find month which day occurs\n #;\n # day_of_month = day\n # month_num = 1\n # while day_of_month gt days[month_num] do begin\n # day_of_month = day_of_month - days[month_num]\n # month_num = month_num+1\n # end\n #; ---------------------------------------\n #;\n #; ***** Now convert to output format\n #;\n #; ---------------------------------------\n #;\n #; is type a string\n #;\n #s = size(type)\n #if (s[0] ne 0) or (s[1] ne 7) then $\n # message,'ERROR - Output type specification must be a string'\n #;\n #outcode = STRMID(STRUPCASE(type),0,1)\n #IF (outcode EQ 'S' || outcode EQ 'F') && hour GE 0 THEN BEGIN\n # xsec = strmid(string(sec+100,'(f6.2)'),1,5)\n # if xsec EQ '60.00' then begin\n # minute = minute+1\n # xsec = '00.00'\n # endif\n # xminute = string(minute,'(i2.2)')\n # if xminute EQ '60' then begin\n # hour = hour+1\n # xminute = '00' \n # endif \n # tod = string(hour,'(i2.2)') + ':' +xminute + ':'+ xsec\n #ENDIF\n # \n #case outcode of\n #\n # 'V' : begin ;vector output\n # out = fltarr(5)\n # out[0] = year\n # out[1] = day\n # out[2] = hour > 0\n # out[3] = minute\n # out[4] = sec\n # end\n # \n # 'R' : begin ;floating point scalar\n #; if year gt 1900 then year = year-1900\n # out = sec/24.0d0/60./60. + minute/24.0d0/60. $\n # + (hour > 0)/24.0d0 + day + year*1000d0\n # end\n #\n # 'S' : begin ;string output \n #\n # month_name = months[month_num]\n #;\n #; encode into ascii_date\n #;\n # out = string(day_of_month,'(i2)') +'-'+ month_name +'-' + $\n # string(year,'(i4)')\n # \n # ; Omit time of day from output string if not specified on input\n # IF hour GE 0 THEN out += ' '+tod\n # end\n # 'F' : begin\n # out = string(year,'(i4)')+'-'+string(month_num,'(I2.2)') $\n # + '-' + string(day_of_month,'(i2.2)')\n # IF hour GE 0 THEN out += 'T' + tod \n # end\n #\n #\t\t'J' : begin\t; Julian Date\n #\t\t\t\tydn2md, year, day, mn, dy\n #\t\t\t\tjuldate, [year, mn, dy, hour, minute, sec], rjd\n #\t\t\t\tout = rjd+2400000 ; convert from reduced to regular JD\n #\t\t\t end\n #\t\t'M' : begin ; Modified Julian Date = JD - 2400000.5\n #\t\t\t\tydn2md, year, day, mn, dy\n #\t\t\t\tjuldate, [year, mn, dy, hour, minute, sec], rjd\n #\t\t\t\tout = rjd-0.5 ; convert from reduced to modified JD\n #\t\t\t end\n #\n # else: begin ;invalid type specified\n # print,'DATE_CONV-- Invalid output type specified'\n # print,' It must be ''REAL'', ''STRING'', ''VECTOR'', ''JULIAN'', ''MODIFIED'', or ''FITS''.'\n # return,-1\n # end\n #endcase\n #\n #bad_date = 0B\n #return,out\n #;\n #; invalid input date error section\n #;\n #NOTVALID:\n #bad_date = 1B\n #message, 'Invalid input date specified', /INFORMATIONAL\n #return, -1\n #end\n", "meta": {"hexsha": "7d3668bc20cc41c77a492037b38636ea05eaf9d5", "size": 16861, "ext": "py", "lang": "Python", "max_stars_repo_path": "idl2py/jd/date_conv.py", "max_stars_repo_name": "RapidLzj/idl2py", "max_stars_repo_head_hexsha": "193051cd8d01db0d125b8975713b885ad521a992", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "idl2py/jd/date_conv.py", "max_issues_repo_name": "RapidLzj/idl2py", "max_issues_repo_head_hexsha": "193051cd8d01db0d125b8975713b885ad521a992", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "idl2py/jd/date_conv.py", "max_forks_repo_name": "RapidLzj/idl2py", "max_forks_repo_head_hexsha": "193051cd8d01db0d125b8975713b885ad521a992", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.338362069, "max_line_length": 111, "alphanum_fraction": 0.4513967143, "include": true, "reason": "import numpy", "num_tokens": 5203, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.37022538564692037, "lm_q1q2_score": 0.18945047731853232}} {"text": "# Copyright 2022 Huawei Technologies Co., Ltd\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ============================================================================\n\"\"\"target assigner\"\"\"\nimport logging\n\nimport numpy as np\nimport numpy.random as npr\n\nlogger = logging.getLogger(__name__)\n\n\ndef unmap(data, count, inds, fill=0):\n \"\"\"\n Unmap a subset of item (data) back to the original set of items\n (of size count)\n \"\"\"\n if count == len(inds):\n return data\n\n if len(data.shape) == 1:\n ret = np.empty((count,), dtype=data.dtype)\n ret.fill(fill)\n ret[inds] = data\n else:\n ret = np.empty((count,) + data.shape[1:], dtype=data.dtype)\n ret.fill(fill)\n ret[inds, :] = data\n return ret\n\n\ndef create_target_np(all_anchors,\n gt_boxes,\n similarity_fn,\n box_encoding_fn,\n prune_anchor_fn=None,\n gt_classes=None,\n matched_threshold=0.6,\n unmatched_threshold=0.45,\n positive_fraction=None,\n rpn_batch_size=300,\n norm_by_num_examples=False,\n box_code_size=7):\n \"\"\"Modified from FAIR detectron.\n Args:\n all_anchors: [num_of_anchors, box_ndim] float tensor.\n gt_boxes: [num_gt_boxes, box_ndim] float tensor.\n similarity_fn: a function, accept anchors and gt_boxes, return\n similarity matrix(such as IoU).\n box_encoding_fn: a function, accept gt_boxes and anchors, return\n box encodings(offsets).\n prune_anchor_fn: a function, accept anchors, return indices that\n indicate valid anchors.\n gt_classes: [num_gt_boxes] int tensor. indicate gt classes, must\n start with 1.\n matched_threshold: float, iou greater than matched_threshold will\n be treated as positives.\n unmatched_threshold: float, iou smaller than unmatched_threshold will\n be treated as negatives.\n positive_fraction: [0-1] float or None. if not None, we will try to\n keep ratio of pos/neg equal to positive_fraction when sample.\n if there is not enough positives, it fills the rest with negatives\n rpn_batch_size: int. sample size\n norm_by_num_examples: bool. norm box_weight by number of examples, but\n I recommend to do this outside.\n box_code_size: int. box coder size\n Returns:\n labels, bbox_targets, bbox_outside_weights\n \"\"\"\n total_anchors = all_anchors.shape[0]\n if prune_anchor_fn is not None:\n inds_inside = prune_anchor_fn(all_anchors)\n anchors = all_anchors[inds_inside, :]\n if not isinstance(matched_threshold, float):\n matched_threshold = matched_threshold[inds_inside]\n if not isinstance(unmatched_threshold, float):\n unmatched_threshold = unmatched_threshold[inds_inside]\n else:\n anchors = all_anchors\n inds_inside = None\n num_inside = len(inds_inside) if inds_inside is not None else total_anchors\n\n if gt_classes is None:\n gt_classes = np.ones([gt_boxes.shape[0]], dtype=np.int32)\n labels = np.empty((num_inside,), dtype=np.int32)\n gt_ids = np.empty((num_inside,), dtype=np.int32)\n labels.fill(-1)\n gt_ids.fill(-1)\n if np.array(gt_boxes).shape[0] > 0 and anchors.shape[0] > 0:\n anchor_by_gt_overlap = similarity_fn(anchors, gt_boxes)\n anchor_to_gt_argmax = anchor_by_gt_overlap.argmax(axis=1)\n anchor_to_gt_max = anchor_by_gt_overlap[np.arange(num_inside), anchor_to_gt_argmax]\n gt_to_anchor_argmax = anchor_by_gt_overlap.argmax(axis=0)\n gt_to_anchor_max = anchor_by_gt_overlap[gt_to_anchor_argmax,\n np.arange(anchor_by_gt_overlap.shape[1])]\n empty_gt_mask = gt_to_anchor_max == 0\n gt_to_anchor_max[empty_gt_mask] = -1\n anchors_with_max_overlap = np.where(anchor_by_gt_overlap == gt_to_anchor_max)[0]\n gt_inds_force = anchor_to_gt_argmax[anchors_with_max_overlap]\n labels[anchors_with_max_overlap] = gt_classes[gt_inds_force]\n gt_ids[anchors_with_max_overlap] = gt_inds_force\n pos_inds = anchor_to_gt_max >= matched_threshold\n gt_inds = anchor_to_gt_argmax[pos_inds]\n labels[pos_inds] = gt_classes[gt_inds]\n gt_ids[pos_inds] = gt_inds\n bg_inds = np.where(anchor_to_gt_max < unmatched_threshold)[0]\n else:\n bg_inds = np.arange(num_inside)\n fg_inds = np.where(labels > 0)[0]\n fg_max_overlap = None\n if np.array(gt_boxes).shape[0] > 0 and anchors.shape[0] > 0:\n fg_max_overlap = anchor_to_gt_max[fg_inds]\n gt_pos_ids = gt_ids[fg_inds]\n if positive_fraction is not None:\n num_fg = int(positive_fraction * rpn_batch_size)\n if len(fg_inds) > num_fg:\n disable_inds = npr.choice(fg_inds, size=(len(fg_inds) - num_fg), replace=False)\n labels[disable_inds] = -1\n fg_inds = np.where(labels > 0)[0]\n\n num_bg = rpn_batch_size - np.sum(labels > 0)\n if len(bg_inds) > num_bg:\n enable_inds = bg_inds[npr.randint(len(bg_inds), size=num_bg)]\n labels[enable_inds] = 0\n else:\n if np.array(gt_boxes).shape[0] == 0 or anchors.shape[0] == 0:\n labels[:] = 0\n else:\n labels[bg_inds] = 0\n labels[anchors_with_max_overlap] = gt_classes[gt_inds_force]\n bbox_targets = np.zeros((num_inside, box_code_size), dtype=all_anchors.dtype)\n if np.array(gt_boxes).shape[0] > 0 and anchors.shape[0] > 0:\n bbox_targets[fg_inds, :] = box_encoding_fn(gt_boxes[anchor_to_gt_argmax[fg_inds], :],\n anchors[fg_inds, :])\n\n bbox_outside_weights = np.zeros((num_inside,), dtype=all_anchors.dtype)\n if norm_by_num_examples:\n num_examples = np.sum(labels >= 0) # neg + pos\n num_examples = np.maximum(1.0, num_examples)\n bbox_outside_weights[labels > 0] = 1.0 / num_examples\n else:\n bbox_outside_weights[labels > 0] = 1.0\n\n if inds_inside is not None:\n labels = unmap(labels, total_anchors, inds_inside, fill=-1)\n bbox_targets = unmap(bbox_targets, total_anchors, inds_inside, fill=0)\n bbox_outside_weights = unmap(bbox_outside_weights, total_anchors, inds_inside, fill=0)\n ret = {\n \"labels\": labels,\n \"bbox_targets\": bbox_targets,\n \"bbox_outside_weights\": bbox_outside_weights,\n \"assigned_anchors_overlap\": fg_max_overlap,\n \"positive_gt_id\": gt_pos_ids,\n }\n if inds_inside is not None:\n ret[\"assigned_anchors_inds\"] = inds_inside[fg_inds]\n else:\n ret[\"assigned_anchors_inds\"] = fg_inds\n return ret\n\n\nclass TargetAssigner:\n \"\"\"target assigner\"\"\"\n\n def __init__(self,\n box_coder,\n anchor_generators,\n region_similarity_calculator=None,\n positive_fraction=None,\n sample_size=512):\n self._region_similarity_calculator = region_similarity_calculator\n self._box_coder = box_coder\n self._anchor_generators = anchor_generators\n self._positive_fraction = positive_fraction\n self._sample_size = sample_size\n\n @property\n def box_coder(self):\n \"\"\"box coder\"\"\"\n return self._box_coder\n\n def assign(self,\n anchors,\n gt_boxes,\n anchors_mask=None,\n gt_classes=None,\n matched_thresholds=None,\n unmatched_thresholds=None):\n \"\"\"assign\"\"\"\n\n def similarity_fn(anchors, gt_boxes):\n \"\"\"similarity fn\"\"\"\n anchors_rbv = anchors[:, [0, 1, 3, 4, 6]]\n gt_boxes_rbv = gt_boxes[:, [0, 1, 3, 4, 6]]\n return self._region_similarity_calculator.compare(anchors_rbv, gt_boxes_rbv)\n\n def box_encoding_fn(boxes, anchors):\n \"\"\"box encoding fn\"\"\"\n return self._box_coder.encode(boxes, anchors)\n\n if anchors_mask is not None:\n prune_anchor_fn = lambda _: np.where(anchors_mask)[0]\n else:\n prune_anchor_fn = None\n\n return create_target_np(anchors,\n gt_boxes,\n similarity_fn,\n box_encoding_fn,\n prune_anchor_fn=prune_anchor_fn,\n gt_classes=gt_classes,\n matched_threshold=matched_thresholds,\n unmatched_threshold=unmatched_thresholds,\n positive_fraction=self._positive_fraction,\n rpn_batch_size=self._sample_size,\n norm_by_num_examples=False,\n box_code_size=self.box_coder.code_size)\n\n def generate_anchors(self, feature_map_size):\n \"\"\"generate anchors\"\"\"\n anchors_list = []\n matched_thresholds = [\n a.match_threshold for a in self._anchor_generators\n ]\n unmatched_thresholds = [\n a.unmatch_threshold for a in self._anchor_generators\n ]\n match_list, unmatch_list = [], []\n for anchor_generator, match_thresh, unmatch_thresh in zip(self._anchor_generators,\n matched_thresholds,\n unmatched_thresholds):\n anchors = anchor_generator.generate(feature_map_size)\n anchors = anchors.reshape([*anchors.shape[:3], -1, 7])\n anchors_list.append(anchors)\n num_anchors = np.prod(anchors.shape[:-1])\n match_list.append(np.full([num_anchors], match_thresh, anchors.dtype))\n unmatch_list.append(np.full([num_anchors], unmatch_thresh, anchors.dtype))\n anchors = np.concatenate(anchors_list, axis=-2)\n matched_thresholds = np.concatenate(match_list, axis=0)\n unmatched_thresholds = np.concatenate(unmatch_list, axis=0)\n return {\n \"anchors\": anchors,\n \"matched_thresholds\": matched_thresholds,\n \"unmatched_thresholds\": unmatched_thresholds\n }\n\n @property\n def num_anchors_per_location(self):\n \"\"\"num anchors per location\"\"\"\n num = 0\n for a_generator in self._anchor_generators:\n num += a_generator.num_anchors_per_localization\n return num\n", "meta": {"hexsha": "65d34a9a4c00f1aa16a68872252948dfda52e53a", "size": 11086, "ext": "py", "lang": "Python", "max_stars_repo_path": "research/cv/pointpillars/src/core/target_assigner.py", "max_stars_repo_name": "mindspore-ai/models", "max_stars_repo_head_hexsha": "9127b128e2961fd698977e918861dadfad00a44c", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 77, "max_stars_repo_stars_event_min_datetime": "2021-10-15T08:32:37.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T13:09:11.000Z", "max_issues_repo_path": "research/cv/pointpillars/src/core/target_assigner.py", "max_issues_repo_name": "mindspore-ai/models", "max_issues_repo_head_hexsha": "9127b128e2961fd698977e918861dadfad00a44c", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2021-10-30T14:44:57.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-14T06:57:57.000Z", "max_forks_repo_path": "research/cv/pointpillars/src/core/target_assigner.py", "max_forks_repo_name": "mindspore-ai/models", "max_forks_repo_head_hexsha": "9127b128e2961fd698977e918861dadfad00a44c", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 24, "max_forks_repo_forks_event_min_datetime": "2021-10-15T08:32:45.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-24T18:45:20.000Z", "avg_line_length": 41.8339622642, "max_line_length": 94, "alphanum_fraction": 0.6144686993, "include": true, "reason": "import numpy", "num_tokens": 2438, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041654, "lm_q2_score": 0.3702253856469203, "lm_q1q2_score": 0.1894504773185323}} {"text": "import numpy as np\nimport matplotlib\nmatplotlib.use('Agg')\nimport matplotlib.pyplot as plt\n\nimport tensorflow as tf\nconfig = tf.compat.v1.ConfigProto()\nconfig.gpu_options.allow_growth = True\nsession = tf.compat.v1.Session(config=config)\nimport matplotlib.pyplot as plt\nimport tensorflow_probability as tfp\ntfd = tfp.distributions\n\nfrom mpi4py import MPI\ncomm = MPI.COMM_WORLD\nrank = comm.Get_rank()\nsize = comm.Get_size()\n\n\nimport argparse\n\nparser = argparse.ArgumentParser(description='Process some integers.')\nparser.add_argument('--jobid', type=int, default=0, help='an integer for the accumulator')\nparser.add_argument('--eps', type=float, default=0.001, help='step size')\nparser.add_argument('--seed', type=int, default=100, help='random seed')\nparser.add_argument('--nc', type=int, default=32, help='mesh size')\nparser.add_argument('--bs', type=float, default=200, help='box size')\nparser.add_argument('--suffix', type=str, default=\"\", help='suffix to fpath')\nparser.add_argument('--nR', type=int, default=0, help=\"number of smoothings\")\nparser.add_argument('--scaleprior', type=int, default=1, help=\"add power to scale to prior\")\nparser.add_argument('--nchains', type=int, default=1, help=\"number of chains\")\nparser.add_argument('--debug', type=int, default=0, help=\"debug run\")\nparser.add_argument('--reconiter', type=int, default=100, help=\"number of iterations for reconstruction\")\nparser.add_argument('--burnin', type=int, default=200, help=\"number of iterations for burnin\")\nparser.add_argument('--tadapt', type=int, default=50, help=\"number of iterations for eps adaptation\")\nparser.add_argument('--ntrain', type=int, default=10, help=\"number of training iterations\")\nparser.add_argument('--prentrain', type=int, default=200, help=\"number of training iterations\")\nparser.add_argument('--thinning', type=int, default=10, help=\"thinning\")\nparser.add_argument('--kwts', type=int, default=4, help='number of trenf layers')\nparser.add_argument('--lpsteps1', type=int, default=25, help=\"min leapfrog steps\")\nparser.add_argument('--lpsteps2', type=int, default=50, help=\"max leapfrog steps\")\nparser.add_argument('--mcmciter', type=int, default=5, help=\"number of only mcmc iterations\")\nparser.add_argument('--order', type=int, default=1, help=\"ZA or LPT\")\n#\nparser.add_argument('--mode', type=str, default=\"classic\", help='mode for trenf')\nparser.add_argument('--nlayers', type=int, default=3, help='number of trenf layers')\nparser.add_argument('--nbins', type=int, default=32, help=\"number of bins in trenf spline\")\nparser.add_argument('--fitnoise', type=int, default=1, help='fitnoise')\nparser.add_argument('--fitscale', type=int, default=1, help='fitscale')\nparser.add_argument('--fitmean', type=int, default=1, help='fitmean')\nparser.add_argument('--meanfield', type=int, default=1, help='meanfield for affine')\nparser.add_argument('--nknots', type=int, default=100, help='number of trenf layers')\nparser.add_argument('--linknots', type=int, default=0, help='linear spacing for knots')\n#\nparser.add_argument('--probjump', type=float, default=0.3, help='probability of jump')\nparser.add_argument('--regwt0', type=float, default=0., help='regularization weight')\n\nargs = parser.parse_args()\ndevice = args.jobid\nsuffix = args.suffix\n\nfrom tensorflow.python.client import device_lib\n\ndef get_available_gpus():\n local_device_protos = device_lib.list_local_devices()\n return [x.name for x in local_device_protos if x.device_type == 'GPU']\n#print(\"\\nDevice name\\n\", tf.test.gpu_device_name(), \"\\n\")\nprint(\"\\nDevices\\n\", get_available_gpus())\n\n\nimport sys, os, time\nimport flowpm\nsys.path.append('../../galference/utils/')\nimport tools\nimport diagnostics as dg\n\nsys.path.append('../src/')\nfrom pmfuncs import Evolve\nfrom pyhmc import PyHMC, PyHMC_batch, DualAveragingStepSize\nfrom trenfmodel import VItrenf\nfrom hmcfuncs import DM_config, DM_fourier, Kwts\nimport recon, trenfmodel\nfrom callback import callback, datafig, callback_fvi, callback_sampling\n\n##########\nnchains = args.nchains\nreconiter = args.reconiter\nburnin = args.burnin\nmcmciter = args.mcmciter\nntrain = args.ntrain\ntadapt = args.tadapt\nthinning = args.thinning\nlpsteps1, lpsteps2 = args.lpsteps1, args.lpsteps2\nnsamples = 1\nprentrain = args.prentrain\nnR = args.nR\nregwt0 = args.regwt0\nrecalib = 1\n#\nif args.debug:\n reconiter = 5\n burnin = 5\n mcmciter = 5\n tadapt = 5\n thinning = 2 \n lpsteps1, lpsteps2 = 3, 5\n nsamples = 1\n prentrain = 10\n nR = 0 \nprobjump = args.probjump\nallRs = [0., 1., 2., 4.]\nallR = allRs[:nR + 1][::-1]\n\n#\nbs, nc = args.bs, args.nc\nnsteps = 3\na0, af, nsteps = 0.1, 1.0, nsteps\nstages = np.linspace(a0, af, nsteps, endpoint=True)\nnsims = 200\ndonbody = False\norder = args.order\nshotnoise = bs**3/nc**3\ndnoise = 1. #shotnoise/nc**1.5 \nif donbody: fpath = '/mnt/ceph/users/cmodi/galference/dm_fvi/L%04d_N%04d_T%02d'%(bs, nc, nsteps)\nelif order == 2: fpath = '/mnt/ceph/users/cmodi/galference/dm_fvi/L%04d_N%04d_LPT'%(bs, nc)\nelif order == 1: fpath = '/mnt/ceph/users/cmodi/galference/dm_fvi/L%04d_N%04d_ZA'%(bs, nc)\nif suffix == \"\": fpath = fpath + '/'\nelse: fpath = fpath + \"-\" + suffix + '/'\nos.makedirs('%s'%fpath, exist_ok=True)\nos.makedirs('%s'%fpath + '/figs/', exist_ok=True)\nos.makedirs('%s'%fpath + '/opt/', exist_ok=True)\nos.makedirs('%s'%fpath + '/weights/', exist_ok=True)\nos.makedirs('%s'%fpath + '/burnin/', exist_ok=True)\n\n\nevolve = Evolve(nc, bs, a0=a0, af=af, nsteps = nsteps, donbody=donbody, order=order) \n\n##############################################\n##Generate DATA\nprint(\"\\nFor seed : \", args.seed)\nnp.random.seed(args.seed)\nzic = np.random.normal(0, 1, nc**3).reshape(1, nc, nc, nc).astype(np.float32)\nnoise = np.random.normal(0, dnoise, nc**3).reshape(1, nc, nc, nc).astype(np.float32)\nic = evolve.z_to_lin(zic).numpy()\nfin = evolve.pm(tf.constant(ic)).numpy()\ndata = fin + noise\ndata = data.astype(np.float32)\ntfdata = tf.constant(data)\ntfnoise = tf.constant(dnoise)\nnp.save(fpath + 'ic', ic)\nnp.save(fpath + 'fin', fin)\nnp.save(fpath + 'data', data)\nfig = datafig(ic, fin, data, bs, dnoise)\nplt.savefig(fpath + 'data')\nplt.close()\nk, pic = tools.power(ic[0], boxsize=bs)\nk, pf = tools.power(fin[0], boxsize=bs)\nk, pd = tools.power(data[0], boxsize=bs)\nk, pn = tools.power(1+noise[0], boxsize=bs)\nknoise = evolve.kmesh[evolve.kmesh > k[(pn > pf)][0]].min()\nprint(\"Noise dominated after : \", knoise, (evolve.kmesh > knoise).sum()/nc**3)\n\n \ndmfuncs = DM_fourier(evolve, tfdata, dnoise=dnoise)\nkwts = Kwts(evolve, mode=args.kwts, knoise=knoise)\npy_log_prob = lambda x: dmfuncs.unnormalized_log_prob(tf.constant(x, dtype=tf.float32), tf.constant(1.)).numpy().astype(np.float32)\npy_grad_log_prob = lambda x: dmfuncs.grad_log_prob(tf.constant(x, dtype=tf.float32), tf.constant(1.)).numpy().astype(np.float32)\nhmckernel = PyHMC_batch(py_log_prob, py_grad_log_prob, invmetric_diag=kwts.kwts, returnV=True)\nepsadapt = DualAveragingStepSize(args.eps)\nstepsize = args.eps\nsamples, pyacc = [], []\n\nprint(\"HMC kernels setup\")\n##############################################\n\n\n\n\ndef flow_step(model, x, lpx):\n nsamples = x.shape[0]\n xk = tf.identity(x)\n x = evolve.zk_to_z(x)\n lqx = model.q.log_prob(x)\n \n y = model.q.sample(nsamples)*1.\n yk = evolve.z_to_zk(y)\n lpy = dmfuncs.unnormalized_log_prob(yk)\n lqy = model.q.log_prob(y)\n print(tf.stack([lpx, lpy, lqx, lqy], axis=0).numpy())\n prob = tf.exp((lpy - lpx)/nc**3 + lqx - lqy)\n #prob = tf.exp((lpy - lpx + lqx - lqy))\n\n accept = tf.where(tf.random.uniform([1]) <= tf.minimum(1., prob))\n reject = tf.where(tf.random.uniform([1]) > tf.minimum(1., prob))\n z = tf.scatter_nd(accept, tf.gather_nd(yk, accept), yk.shape) + \\\n tf.scatter_nd(reject, tf.gather_nd(xk, reject), yk.shape)\n\n lpz = tf.where(tf.random.uniform([1]) <= tf.minimum(1., prob), lpy, lpx)\n acc = tf.where(tf.random.uniform([1]) <= tf.minimum(1., prob), tf.ones(lpx.shape)*11, tf.ones(lpx.shape)*10.)\n return z, lpz, prob, acc, tf.constant(1.)\n\n\ndef mcmc_step(q, stepsize):\n #stepsize = np.random.uniform(0.01, 0.02, 1)\n lpsteps = np.random.randint(lpsteps1, lpsteps2, 1)[0]\n print(\"mcmc : \", q.shape)\n q, _, acc, prob, _ = hmckernel.hmc_step(q.numpy(), lpsteps, stepsize)\n lpq = tf.constant(prob[2]*-1.)\n prob = np.exp(prob[0] - prob[1])\n q = tf.constant(q, dtype=tf.float32)\n return q, lpq, tf.constant(prob), tf.constant(acc*1.), tf.constant(0.)\n\n\n#@tf.function\ndef fvi(model, q, logpq, i, stepsize): \n \n elbos = []\n start = time.time()\n if i < mcmciter:\n print(\"MCMC only\")\n q, logpq, prob, acc, jump = mcmc_step(q, stepsize)\n else: \n q, logpq, prob, acc, jump = tf.cond(tf.random.uniform([1]) > probjump, \\\n lambda : mcmc_step(q, stepsize), \\\n lambda : flow_step(model, q, logpq))\n if jump == 1:\n for _ in range(recalib):\n print(\"Jump, recaliberate\")\n q, logpq, prob2, acc2, jump2 = mcmc_step(q, stepsize)\n \n \n print(\"prob \", prob.numpy(), \"to accept/reject with \", acc.numpy(), \" in time %0.3f\"%(time.time() - start))\n return q, logpq, acc, jump\n\n\n@tf.function\ndef fvi_grads(model, samples, opt, samples2, regwt):\n samples = evolve.zk_to_z(samples) \n with tf.GradientTape(persistent=True) as tape:\n tape.watch(model.trainable_variables)\n #q, logpq, acc = fvi_step(model, q, logpq)\n neglogq = - tf.reduce_mean(model.q.log_prob(samples))\n if regwt0 == 0:\n loss = neglogq*1.\n else:\n logq2 = - tf.reduce_mean(model.q.log_prob(evolve.zk_to_z(samples2)))\n samplevi = model.sample(samples.shape[0])*1.\n logqvi = - tf.reduce_mean(model.q.log_prob(samplevi))\n reg = regwt * tf.reduce_mean((logq2 - logqvi)**2.)\n loss = neglogq + reg\n \n gradients = tape.gradient(loss, model.trainable_variables)\n return neglogq, gradients\n\n\n\ndef fvi_train(model, samples, opt, batch2, regwt):\n neglogq, gradients = fvi_grads(model, samples, opt, batch2, regwt)\n opt.apply_gradients(zip(gradients, model.trainable_variables))\n return neglogq\n\n\n\n\ndef optimizetrenf(model, data, opt, Rsm, niter=100, callback=callback, citer=50, nsamples=1, saveiter=20, sample=None, batch_size=1, stepsize=0.01, samples=[]):\n \n pss, psslin, pssx = [], [], []\n if sample is None: \n sample = tf.random.normal([nsamples, nc, nc, nc])\n logpsample = dmfuncs.unnormalized_log_prob(sample)\n \n accs, losses = [], []\n samples.append(sample)\n idxtrain = list(np.arange(len(samples)))\n #\n start = time.time()\n #dry run\n sample, logpsample, acc, jump = fvi(model, sample, logpsample, 0, stepsize)\n print(sample.shape, samples[0].shape, samples[-1].shape)\n accs.append(acc)\n #samples.append(sample)\n #idxtrain = idxtrain + [len(samples)-1]\n trainsize = len(samples)\n print(\"Training size of %d is maintained\"%trainsize)\n for epoch in range(niter+1):\n print(epoch)\n sample, logpsample, acc, jump = fvi(model, sample, logpsample, epoch, stepsize)\n accs.append(acc)\n #save power spectrum\n if sample.shape[-1] == 2:\n ssz = evolve.zk_to_z(sample).numpy()\n else: ssz = tf.identity(sample)\n sslin = evolve.z_to_lin(tf.constant(ssz)).numpy()\n pss.append([tools.power(j+1, boxsize=evolve.bs)[1] for j in ssz])\n psslin.append([tools.power(j+1, boxsize=evolve.bs)[1] for j in sslin])\n pssx.append([tools.power(j+1, ic[0] + 1, boxsize=evolve.bs)[1] for j in sslin])\n samples.append(sample)\n idxtrain = idxtrain + [len(samples)-1]\n print(max(idxtrain), len(idxtrain), len(samples))\n if (epoch > 0) & (epoch %100 == 0): \n ntrain = 500\n print(\"Train %d times to recaliberate\"%ntrain)\n else: ntrain = args.ntrain\n for itrain in range(ntrain):\n if jump == 1: \n print(\"Jump, no train\")\n break\n if itrain == 0: idxsample = idxtrain[-batch_size:]\n else: idxsample = np.random.choice(idxtrain, batch_size, replace=False)\n #$# idxsample = np.random.choice(idx, batch_size, p=idx/idx.sum(), replace=False)\n idlast = min(-1 * np.random.choice(10), -1)\n idxsample = [idlast] + list(idxsample)\n print(itrain, \", idx :\", idxsample)\n batch = tf.concat([samples[i] for i in idxsample], axis=0)\n batch2, regwt = None, tf.constant(regwt0)\n if regwt0 != 0.:\n if itrain == 0: idxsample = idxtrain[-batch_size:]\n else: idxsample = np.random.choice(idxtrain, batch_size, replace=False)\n #idxsample = idxtrain[np.random.choice(np.arange(trainsize), batch_size, replace=False)]\n idxsample = list(idxsample)\n print(\"idx2 :\", idxsample)\n batch2 = tf.concat([samples[i] for i in idxsample], axis=0)\n loss = fvi_train(model, batch, opt, batch2, regwt)\n losses.append(loss/nc**3)\n print(\"Logq at epoch %d is: \"%epoch, loss.numpy())\n #iddel = np.random.randint(trainsize)\n #print(\"Remove index from train : %d \"%idxtrain[iddel])\n #del idxtrain[iddel]\n\n if epoch%citer == 0: \n print(\"pss shape \", pss[-1][0].shape, len(pss[-1]))\n print(\"Time taken for %d iterations : \"%citer, time.time() - start)\n print(\"Accept counts : \", np.unique(accs, return_counts=True))\n #\n fig = callback_fvi(model, ic, bs, losses)\n plt.savefig(fpath + '/figs/iter%05d'%epoch)\n plt.close()\n\n #\n fig = callback_sampling([evolve.zk_to_lin(i) for i in samples[-2:]], ic, bs)\n plt.savefig(fpath + '/figs/samples%05d'%epoch)\n plt.close()\n np.save(fpath + 'loss', np.array(losses))\n np.save(fpath + 'samples', np.array(samples))\n np.save(fpath + '/psz', pss)\n np.save(fpath + '/pslin', psslin) #\n np.save(fpath + '/pslinx', pssx) #\n np.save(fpath + 'samplesthin%d'%thinning, np.array(samples)[::thinning])\n np.save(fpath + 'accepts', np.array(accs))\n start = time.time()\n if epoch%saveiter == 0: \n model.save_weights(fpath + '/weights/iter%04d'%(epoch//saveiter))\n #np.save(fpath + '/opt/iter%04d'%(epoch//saveiter), opt.get_weights(), allow_pickle=True)\n #print('Weights saved')\n \n return losses \n\n\n\n\n#$####################################################################################\n#$################################################################\n###################VI\nprint(\"\\nStart VI\\n\")\n#vitrenf = trenfmodel.VItrenf(nc, nlayers=args.nlayers, evolve=evolve, nbins=32, mode=args.mode)\nvitrenf = trenfmodel.VItrenf(nc, nlayers=args.nlayers, evolve=evolve, nbins=args.nbins, nknots=args.nknots, mode=args.mode, \\\n linknots=bool(args.linknots), fitnoise=bool(args.fitnoise), fitscale=bool(args.fitscale), \\\n fitmean=bool(args.fitmean), meanfield=bool(args.meanfield))\nfor i in vitrenf.variables:\n print(i.name, i.shape)\n\n\nlr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(\n 5e-3,\n decay_steps=200,\n decay_rate=0.95,\n staircase=True)\n\n#Train FLOW using previos samples assuming we have them\nprint(\"Load old samples\")\nsamplepath = '/mnt/ceph/users/cmodi/galference/dm_hmc/L1000_N0128_ZA-kwts4-fourier-corr/'\n#samplepath = '/mnt/ceph/users/cmodi/galference/dm_hmc/L0200_N0064_ZA-fourier-minlininit2/'\nallsamples = []\nperchain = 201\nfor i in range(nchains):\n f = np.load(samplepath + '/samples%d-00.npy'%i)[:perchain, 0]\n allsamples.append(f)\nallsamples = np.stack(allsamples, axis=1).astype(np.float32)\nprint(allsamples.shape)\nstepsize = np.array([np.load(samplepath + '/stepsizes%d-00.npy'%i) for i in range(nchains)]).flatten()\nprint(\"stepsize : \", stepsize)\n\nlosses = []\n\nopt = tf.keras.optimizers.Adam(learning_rate= lr_schedule)\n#opt = tf.keras.optimizers.RMSprop(learning_rate= 1e-3)\nsaveiter = 100\n\nprint(\"Train on old samples\")\nfor i in range(prentrain+1):\n \n for itrain in range(min(ntrain, int(ntrain*(2*i/prentrain)))):\n \n #idx = np.random.choice(i + 1, size=nsamples+1)\n idx = np.random.choice(allsamples.shape[0], size=nsamples+1)\n #idx = [-1] + list(idx)\n batch = tf.concat([allsamples[i] for i in idx], axis=0)\n #batch = tf.concat(allsamples[idx], axis=0)\n batch2, regwt = None, None\n if regwt0 !=0 :\n batch2 = tf.concat(allsamples[np.random.choice(allsamples.shape[0], nsamples)], axis=0)\n regwt = tf.constant(args.regwt0*i/prentrain)\n losses.append(fvi_train(vitrenf, batch, opt, batch2, regwt))\n #if itrain == 0: print(idx, batch.shape)\n if i%10 == 0: \n print(\"Iter : \", i)\n fig = callback_fvi(vitrenf, ic, bs, losses)\n plt.savefig(fpath + 'figs/trainr%05d'%i)\n plt.close()\n\n#$# lqs = []\n#$# for j in range(allsamples.shape[0]//10):\n#$# batch = tf.concat(evolve.zk_to_z(allsamples[j:j+2]), axis=0)\n#$# lq = vitrenf.q.log_prob(batch).numpy()\n#$# lqs = lqs + list(lq.flatten())\n#$# plt.plot(lqs, '.', label='train samples', lw=2)\n#$#\n#$# lqs = []\n#$# for j in range(allsamples.shape[0]//10):\n#$# batch = vitrenf.sample(nchains)\n#$# lq = vitrenf.q.log_prob(batch).numpy()\n#$# lqs = lqs + list(lq.flatten())\n#$# plt.plot(lqs, '.', label='flow samples', lw=2)\n#$# plt.legend()\n#$# plt.savefig(fpath + '/figs/lgoqtrain%05d'%i)\n#$# plt.close()\n#$#\n if (i > 0) & (i%saveiter == 0): \n vitrenf.save_weights(fpath + '/weights/preiter%04d'%(i//saveiter))\n\n\n\nplt.imshow(vitrenf.sample(1)[0].numpy().sum(axis=0))\nplt.colorbar()\nplt.savefig(fpath + 'initsample')\nplt.colorbar()\nplt.close()\n\nsample = tf.constant(allsamples[-1])\nprint(sample.shape)\nR = 0.\n\nopt2 = tf.keras.optimizers.Adam(learning_rate= 1e-3)\nbatch = tf.concat([allsamples[i] for i in idx], axis=0)\n_ = fvi_train(vitrenf, batch, opt2, batch2, regwt)\nopt2.set_weights(opt.get_weights())\n\nlosses = optimizetrenf(vitrenf, tf.constant(data), opt2, tf.constant(R), 5001, callback, citer=10, sample=sample, stepsize=stepsize, samples=list(allsamples[::thinning]))\n\n\n\n\n\n\n#$# #\n#$# lqs = []\n#$# for j in range(10):\n#$# idxsample = np.random.choice(idxtrain, batch_size, replace=False)\n#$# idxsample = list(idxsample)\n#$# try:\n#$# print(idxsample)\n#$# batch = tf.concat([samples[i:i+2] for i in list(idxsample)], axis=0)\n#$# batch = evolve.zk_to_z(batch)\n#$# lq = model.q.log_prob(batch).numpy()\n#$# plt.plot(lq.flatten(), 'C0.')\n#$# lqs = lqs + list(lq.flatten())\n#$# #plt.plot(lqs, '.', label='train samples', lw=2)\n#$# except Exception as e:\n#$# print(e)\n#$# lqs = []\n#$# for j in range(10):\n#$# try:\n#$# batch = model.sample(nchains)\n#$# lq = model.q.log_prob(batch).numpy()\n#$# lqs = lqs + list(lq.flatten())\n#$# plt.plot(lq.flatten(), 'C1.', lw=2)\n#$# except Exception as e:\n#$# print(e)\n#$# plt.savefig(fpath + '/figs/lgoqiter%05d'%epoch)\n#$# plt.close()\n#$#\n", "meta": {"hexsha": "c34c52810755fde07640ff3940cd7e85f99db527", "size": 19705, "ext": "py", "lang": "Python", "max_stars_repo_path": "scripts/fvi_trenf_phase3128.py", "max_stars_repo_name": "modichirag/VI_reconstruction", "max_stars_repo_head_hexsha": "64def5226a5723877a60943c29f592319bbe8e95", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "scripts/fvi_trenf_phase3128.py", "max_issues_repo_name": "modichirag/VI_reconstruction", "max_issues_repo_head_hexsha": "64def5226a5723877a60943c29f592319bbe8e95", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "scripts/fvi_trenf_phase3128.py", "max_forks_repo_name": "modichirag/VI_reconstruction", "max_forks_repo_head_hexsha": "64def5226a5723877a60943c29f592319bbe8e95", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.0508130081, "max_line_length": 170, "alphanum_fraction": 0.619791931, "include": true, "reason": "import numpy", "num_tokens": 5623, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5117166047041652, "lm_q2_score": 0.3702253856469203, "lm_q1q2_score": 0.18945047731853226}} {"text": "# Very slightly adapted from perses https://github.com/choderalab/perses\n# License: MIT\n# OpenFE note: eventually we aim to move this to openmmtools where possible\n\nimport numpy as np\nimport warnings\nimport copy\nfrom openmmtools.alchemy import AlchemicalState\n\n\nclass LambdaProtocol(object):\n \"\"\"Protocols for perturbing each of the compent energy terms in alchemical\n free energy simulations.\n\n TODO\n ----\n * Class needs cleaning up and made more consistent\n \"\"\"\n\n default_functions = {'lambda_sterics_core':\n lambda x: x,\n 'lambda_electrostatics_core':\n lambda x: x,\n 'lambda_sterics_insert':\n lambda x: 2.0 * x if x < 0.5 else 1.0,\n 'lambda_sterics_delete':\n lambda x: 0.0 if x < 0.5 else 2.0 * (x - 0.5),\n 'lambda_electrostatics_insert':\n lambda x: 0.0 if x < 0.5 else 2.0 * (x - 0.5),\n 'lambda_electrostatics_delete':\n lambda x: 2.0 * x if x < 0.5 else 1.0,\n 'lambda_bonds':\n lambda x: x,\n 'lambda_angles':\n lambda x: x,\n 'lambda_torsions':\n lambda x: x\n }\n\n # lambda components for each component,\n # all run from 0 -> 1 following master lambda\n def __init__(self, functions='default', windows=10, lambda_schedule=None):\n \"\"\"Instantiates lambda protocol to be used in a free energy\n calculation. Can either be user defined, by passing in a dict, or using\n one of the pregenerated sets by passing in a string 'default', 'namd'\n or 'quarters'\n\n All protocols must begin and end at 0 and 1 respectively. Any energy\n term not defined in `functions` dict will be set to the function in\n `default_functions`\n\n Pre-coded options:\n default : ele and LJ terms of the old system are turned off between\n 0.0 -> 0.5 ele and LJ terms of the new system are turned on between\n 0.5 -> 1.0 core terms treated linearly\n\n quarters : 0.25 of the protocol is used in turn to individually change\n the (a) off old ele, (b) off old sterics, (c) on new sterics (d) on new\n ele core terms treated linearly\n\n namd : follows the protocol outlined here:\n https://pubs.acs.org/doi/full/10.1021/acs.jcim.9b00362#\n Jiang, Wei, Christophe Chipot, and Benoît Roux. \"Computing Relative\n Binding Affinity of Ligands to Receptor: An Effective Hybrid\n Single-Dual-Topology Free-Energy Perturbation Approach in NAMD.\"\n Journal of chemical information and modeling 59.9 (2019): 3794-3802.\n\n ele-scaled : all terms are treated as in default, except for the old\n and new ele these are scaled with lambda^0.5, so as to be linear in\n energy, rather than lambda\n\n Parameters\n ----------\n functions : str or dict\n One of the predefined lambda protocols\n ['default','namd','quarters'] or a dictionary. Default \"default\".\n windows : int\n Number of windows which this lambda schedule is intended to be used\n with. This value is used to validate the lambda function.\n lambda_schedule : list of floats\n Schedule of lambda windows to be sampled. If ``None`` will default\n to a linear spacing of windows as defined by\n ``np.linspace(0. ,1. ,windows)``. Default ``None``.\n\n Attributes\n ----------\n functions : dict\n Lambda protocol to be used.\n lambda_schedule : list\n Schedule of windows to be sampled.\n \"\"\"\n self.functions = copy.deepcopy(functions)\n\n # set the lambda schedule\n self.lambda_schedule = self._validate_schedule(lambda_schedule,\n windows)\n if lambda_schedule:\n self.lambda_schedule = lambda_schedule\n else:\n self.lambda_schedule = np.linspace(0., 1., windows)\n\n if type(self.functions) == dict:\n self.type = 'user-defined'\n elif type(self.functions) == str:\n self.functions = None # will be set later\n self.type = functions\n\n if self.functions is None:\n if self.type == 'default':\n self.functions = copy.deepcopy(\n LambdaProtocol.default_functions)\n elif self.type == 'namd':\n self.functions = {\n 'lambda_sterics_core': lambda x: x,\n 'lambda_electrostatics_core': lambda x: x,\n 'lambda_sterics_insert': lambda x: (3. / 2.) * x if x < (2. / 3.) else 1.0,\n 'lambda_sterics_delete': lambda x: 0.0 if x < (1. / 3.) else (x - (1. / 3.)) * (3. / 2.),\n 'lambda_electrostatics_insert': lambda x: 0.0 if x < 0.5 else 2.0 * (x - 0.5),\n 'lambda_electrostatics_delete': lambda x: 2.0 * x if x < 0.5 else 1.0,\n 'lambda_bonds': lambda x: x,\n 'lambda_angles': lambda x: x,\n 'lambda_torsions': lambda x: x\n }\n elif self.type == 'quarters':\n self.functions = {\n 'lambda_sterics_core': lambda x: x,\n 'lambda_electrostatics_core': lambda x: x,\n 'lambda_sterics_insert': lambda x: 0. if x < 0.5 else 1 if x > 0.75 else 4 * (x - 0.5),\n 'lambda_sterics_delete': lambda x: 0. if x < 0.25 else 1 if x > 0.5 else 4 * (x - 0.25),\n 'lambda_electrostatics_insert': lambda x: 0. if x < 0.75 else 4 * (x - 0.75),\n 'lambda_electrostatics_delete': lambda x: 4.0 * x if x < 0.25 else 1.0,\n 'lambda_bonds': lambda x: x,\n 'lambda_angles': lambda x: x,\n 'lambda_torsions': lambda x: x\n }\n elif self.type == 'ele-scaled':\n self.functions = {\n 'lambda_electrostatics_insert': lambda x: 0.0 if x < 0.5 else ((2*(x-0.5))**0.5),\n 'lambda_electrostatics_delete': lambda x: (2*x)**2 if x < 0.5 else 1.0\n }\n elif self.type == 'user-defined':\n self.functions = functions\n else:\n errmsg = f\"LambdaProtocol type : {self.type} not recognised \"\n raise ValueError(errmsg)\n\n self._validate_functions(n=windows)\n self._check_for_naked_charges()\n\n @staticmethod\n def _validate_schedule(schedule, windows):\n \"\"\"\n Checks that the input lambda schedule is valid.\n\n Rules are:\n - Must begin at 0 and end at 1\n - Must be monotonically increasing\n\n Parameters\n ----------\n schedule : list of floats\n The lambda schedule. If ``None`` the method returns\n ``np.linspace(0. ,1. ,windows)``.\n windows : int\n Number of windows to be sampled.\n\n Returns\n -------\n schedule : list of floats\n A valid lambda schedule.\n \"\"\"\n if schedule is None:\n return np.linspace(0., 1., windows)\n\n # Check end states\n if schedule[0] != 0 or schedule[-1] != 1:\n errmsg = (\"end and start lambda windows must be lambda 0 and 1 \"\n \"respectively\")\n raise ValueError(errmsg)\n\n # Check monotonically increasing\n difference = np.diff(schedule)\n\n if not all(i >= 0. for i in difference):\n errmsg = \"The lambda schedule is not monotonic\"\n raise ValueError(errmsg)\n\n return schedule\n\n def _validate_functions(self, n=10):\n \"\"\"Ensures that all the lambda functions adhere to the rules:\n - must begin at 0.\n - must finish at 1.\n - must be monotonically increasing\n\n Parameters\n ----------\n n : int, default 10\n number of grid points used to check monotonicity\n \"\"\"\n # the individual lambda functions that must be defined for\n required_functions = list(LambdaProtocol.default_functions.keys())\n\n for function in required_functions:\n if function not in self.functions:\n # IA switched from warn to error here\n errmsg = (f\"function {function} is missing from \"\n \"self.lambda_functions.\")\n raise ValueError(errmsg)\n\n # Check that the function starts and ends at 0 and 1 respectively\n if self.functions[function](0) != 0:\n raise ValueError(\"lambda functions must start at 0\")\n if self.functions[function](1) != 1:\n raise ValueError(\"lambda fucntions must end at 1\")\n\n # now validatate that it's monotonic\n global_lambda = np.linspace(0., 1., n)\n sub_lambda = [self.functions[function](lam) for\n lam in global_lambda]\n difference = np.diff(sub_lambda)\n\n if not all(i >= 0. for i in difference):\n wmsg = (f\"The function {function} is not monotonic as \"\n \"typically expected.\")\n warnings.warn(wmsg)\n\n def _check_for_naked_charges(self):\n \"\"\"\n Checks that there are no cases where atoms have charge but no sterics.\n\n This avoids issues with singularities and/or excessive forces near\n the end states (even when using softcore electrostatics).\n \"\"\"\n global_lambda = self.lambda_schedule\n\n def check_overlap(ele, sterics, global_lambda, functions, endstate):\n for lam in global_lambda:\n ele_val = functions[ele](lam)\n ster_val = functions[sterics](lam)\n # if charge > 0 and sterics == 0 raise error\n if ele_val != endstate and ster_val == endstate:\n errmsg = (\"There are states along this lambda schedule \"\n \"where there are atoms with charges but no LJ \"\n f\"interactions: {lam} {ele_val} {ster_val}\")\n raise ValueError(errmsg)\n\n # checking unique new terms first\n ele = 'lambda_electrostatics_insert'\n sterics = 'lambda_sterics_insert'\n check_overlap(ele, sterics, global_lambda, self.functions, endstate=0)\n\n # checking unique old terms now\n ele = 'lambda_electrostatics_delete'\n sterics = 'lambda_sterics_delete'\n check_overlap(ele, sterics, global_lambda, self.functions, endstate=1)\n\n def get_functions(self):\n return self.functions\n\n def plot_functions(self, lambda_schedule=None):\n \"\"\"\n Plot the function for ease of visualisation.\n\n Parameters\n ----------\n shedule : np.ndarray\n The lambda schedule to plot the function along. If ``None`` plot\n the one stored within this class. Default ``None``.\n \"\"\"\n import matplotlib.pyplot as plt\n\n fig = plt.figure(figsize=(10, 5))\n\n global_lambda = lambda_schedule if lambda_schedule else self.lambda_schedule\n\n for f in self.functions:\n plt.plot(global_lambda,\n [self.functions[f](lam) for lam in global_lambda],\n alpha=0.5, label=f)\n\n plt.xlabel('global lambda')\n plt.ylabel('sub-lambda')\n plt.legend()\n plt.show()\n\n\nclass RelativeAlchemicalState(AlchemicalState):\n \"\"\"\n Relative AlchemicalState to handle all lambda parameters required for\n relative perturbations\n lambda = 1 refers to ON, i.e. fully interacting while\n lambda = 0 refers to OFF, i.e. non-interacting with the system\n all lambda functions will follow from 0 -> 1 following the master lambda\n lambda*core parameters perturb linearly\n lambda_sterics_insert and lambda_electrostatics_delete perturb in the\n first half of the protocol 0 -> 0.5\n lambda_sterics_delete and lambda_electrostatics_insert perturb in the\n second half of the protocol 0.5 -> 1\n\n Attributes\n ----------\n lambda_sterics_core\n lambda_electrostatics_core\n lambda_sterics_insert\n lambda_sterics_delete\n lambda_electrostatics_insert\n lambda_electrostatics_delete\n \"\"\"\n\n class _LambdaParameter(AlchemicalState._LambdaParameter):\n pass\n\n lambda_sterics_core = _LambdaParameter('lambda_sterics_core')\n lambda_electrostatics_core = _LambdaParameter('lambda_electrostatics_core')\n lambda_sterics_insert = _LambdaParameter('lambda_sterics_insert')\n lambda_sterics_delete = _LambdaParameter('lambda_sterics_delete')\n lambda_electrostatics_insert = _LambdaParameter(\n 'lambda_electrostatics_insert')\n lambda_electrostatics_delete = _LambdaParameter(\n 'lambda_electrostatics_delete')\n\n def set_alchemical_parameters(self, global_lambda,\n lambda_protocol=LambdaProtocol()):\n \"\"\"Set each lambda value according to the lambda_functions protocol.\n The undefined parameters (i.e. those being set to None) remain\n undefined.\n Parameters\n ----------\n lambda_value : float\n The new value for all defined parameters.\n \"\"\"\n self.global_lambda = global_lambda\n for parameter_name in lambda_protocol.functions:\n lambda_value = lambda_protocol.functions[parameter_name](global_lambda)\n setattr(self, parameter_name, lambda_value)\n", "meta": {"hexsha": "71ba312858d2e3a42588030576ee971e1c062377", "size": 13859, "ext": "py", "lang": "Python", "max_stars_repo_path": "openfe/setup/_rbfe_utils/lambdaprotocol.py", "max_stars_repo_name": "mikemhenry/openfe", "max_stars_repo_head_hexsha": "d4c78af62a7ae05b99eb95d173661ac134b7e7b9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14, "max_stars_repo_stars_event_min_datetime": "2022-01-24T22:01:19.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T04:58:35.000Z", "max_issues_repo_path": "openfe/setup/_rbfe_utils/lambdaprotocol.py", "max_issues_repo_name": "mikemhenry/openfe", "max_issues_repo_head_hexsha": "d4c78af62a7ae05b99eb95d173661ac134b7e7b9", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 109, "max_issues_repo_issues_event_min_datetime": "2022-01-24T18:57:05.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T20:13:07.000Z", "max_forks_repo_path": "openfe/setup/_rbfe_utils/lambdaprotocol.py", "max_forks_repo_name": "mikemhenry/openfe", "max_forks_repo_head_hexsha": "d4c78af62a7ae05b99eb95d173661ac134b7e7b9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2022-01-24T18:45:54.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-21T06:28:24.000Z", "avg_line_length": 41.1246290801, "max_line_length": 109, "alphanum_fraction": 0.5783245544, "include": true, "reason": "import numpy", "num_tokens": 3112, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6297745935070806, "lm_q2_score": 0.3007455914759599, "lm_q1q2_score": 0.1894019326208192}} {"text": "#!/usr/bin/env python\n# Copyright 2014-2019 The PySCF Developers. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n# Author: Qiming Sun \n#\n\nimport os, sys\nimport imp\nimport numpy\nimport pyscf.ao2mo\n\ntry:\n from pyscf.dmrgscf import settings\n PyCheMPS2 = None\nexcept ImportError:\n try:\n import PyCheMPS2\n except ImportError:\n msg = ('settings.py not found. Please create %s\\n' %\n os.path.join(os.path.dirname(__file__), 'settings.py'))\n sys.stderr.write(msg)\n\n# point group ID defined in CheMPS2, see\n# http://sebwouters.github.io/CheMPS2/classCheMPS2_1_1Irreps.html\nGROUPNAME_ID = {\n 'C1' : 0,\n 'Ci' : 1,\n 'C2' : 2,\n 'Cs' : 3,\n 'D2' : 4,\n 'C2v': 5,\n 'C2h': 6,\n 'D2h': 7,\n}\n\nclass CheMPS2(object):\n def __init__(self, mol, **kwargs):\n self.mol = mol\n self.verbose = mol.verbose\n self.stdout = mol.stdout\n if self.mol.symmetry:\n self.groupname = mol.groupname\n else:\n self.groupname = None\n self.orbsym = []\n\n# ref.\n# https://github.com/SebWouters/CheMPS2/blob/master/psi4plugins/dmrgci.cc\n self.wfn_irrep = 0\n #self.spin_2s = 0 # spin = 2*s, 0 means singlet\n self.dmrg_states = [ 200 , 500 , 1000 , 1000 ]\n self.dmrg_noise = [ 1 , 1 , 1 , 0 ]\n self.dmrg_e_convergence = 1e-8\n self.dmrg_noise_factor = 0.03\n self.dmrg_maxiter_noise = 5\n self.dmrg_maxiter_silent = 100\n\n self._keys = set(self.__dict__.keys())\n\n def dump_flags(self, verbose=None):\n log = pyscf.lib.logger.new_logger(self, verbose)\n log.info('******** CheMPS2 flags ********')\n log.info('dmrg_states = %s', str(self.dmrg_states))\n log.info('dmrg_noise = %s', str(self.dmrg_noise))\n log.info('dmrg_e_convergence = %g', self.dmrg_e_convergence)\n log.info('dmrg_noise_factor = %g', self.dmrg_noise_factor)\n log.info('dmrg_maxiter_noise = %d', self.dmrg_maxiter_noise)\n log.info('dmrg_maxiter_silent = %d', self.dmrg_maxiter_silent)\n\n def kernel(self, h1e, eri, norb, nelec, ci0=None, ecore=0, **kwargs):\n global PyCheMPS2\n if PyCheMPS2 is None:\n PyCheMPS2 = imp.load_dynamic('PyCheMPS2', settings.PYCHEMPS2BIN)\n\n Initializer = PyCheMPS2.PyInitialize()\n Initializer.Init()\n\n if self.groupname is not None:\n groupNumber = GROUPNAME_ID[self.groupname]\n else:\n groupNumber = 0\n self.orbsym = numpy.zeros(norb, numpy.int32)\n Ham = PyCheMPS2.PyHamiltonian(norb, groupNumber,\n numpy.asarray(self.orbsym, dtype=numpy.int32))\n eri = pyscf.ao2mo.restore(1, eri, norb)\n for i in range(norb):\n for j in range(norb):\n totsym = self.orbsym[i] ^ self.orbsym[j]\n if 0 == totsym:\n Ham.setTmat(i, j, h1e[i,j])\n for k in range(norb):\n for l in range(norb):\n totsym = self.orbsym[i] \\\n ^ self.orbsym[j] \\\n ^ self.orbsym[k] \\\n ^ self.orbsym[l]\n if 0 == totsym:\n Ham.setVmat(i, k, j, l, eri[i,j,k,l])\n Ham.setEconst(0)\n\n if isinstance(nelec, (int, numpy.integer)):\n spin2 = 0\n else:\n spin2 = (nelec[0]-nelec[1])\n nelec = sum(nelec)\n\n Prob = PyCheMPS2.PyProblem(Ham, spin2, nelec, self.wfn_irrep)\n Prob.SetupReorderD2h()\n\n OptScheme = PyCheMPS2.PyConvergenceScheme(len(self.dmrg_states))\n for cnt,m in enumerate(self.dmrg_states):\n if self.dmrg_noise[cnt]:\n OptScheme.setInstruction(cnt, m, self.dmrg_e_convergence,\n self.dmrg_maxiter_noise,\n self.dmrg_noise_factor)\n else:\n OptScheme.setInstruction(cnt, m, self.dmrg_e_convergence,\n self.dmrg_maxiter_silent, 0.0)\n\n with pyscf.lib.capture_stdout() as stdout:\n theDMRG = PyCheMPS2.PyDMRG(Prob, OptScheme)\n Energy = theDMRG.Solve() + ecore\n theDMRG.calc2DMandCorrelations()\n pyscf.lib.logger.debug1(self.mol, stdout.read())\n\n rdm2 = numpy.empty((norb,)*4)\n for i in range(norb):\n for j in range(norb):\n for k in range(norb):\n for l in range(norb):\n rdm2[i,j,k,l] = theDMRG.get2DMA(i, j, k, l)\n\n with pyscf.lib.capture_stdout() as stdout:\n theDMRG.deleteStoredOperators()\n pyscf.lib.logger.debug1(self.mol, stdout.read())\n\n# The order of deallocation matters!\n del(theDMRG)\n del(OptScheme)\n del(Prob)\n del(Ham)\n del(Initializer)\n\n fakewfn_by_rdm2 = rdm2\n return Energy, fakewfn_by_rdm2\n\n def make_rdm12(self, fakewfn_by_rdm2, ncas, nelec, **kwargs):\n if not isinstance(nelec, (int, numpy.integer)):\n nelec = sum(nelec)\n# CheMPS2 uses physics notation\n rdm2 = fakewfn_by_rdm2.transpose(0,2,1,3)\n rdm1 = numpy.einsum('ijkk->ij', rdm2) / (nelec-1)\n return rdm1, rdm2\n\n def make_rdm1(self, fcivec, norb, nelec, link_index=None, **kwargs):\n return self.make_rdm12(fcivec, norb, nelec, **kwargs)[0]\n\n\n\nif __name__ == '__main__':\n from pyscf import gto\n from pyscf import scf\n from pyscf import mcscf\n\n b = 1.4\n mol = gto.Mole()\n mol.build(\n verbose = 5,\n output = 'out-chemps2',\n atom = [['H', (0.,0.,i)] for i in range(8)],\n basis = {'H': 'sto-3g'},\n symmetry = True,\n symmetry_subgroup = 'D2h',\n )\n m = scf.RHF(mol)\n m.scf()\n\n mc = mcscf.CASSCF(m, 4, 4)\n mc.fcisolver = CheMPS2(mol)\n mc.fcisolver.dmrg_e_convergence = 1e-8\n emc_1 = mc.mc2step()[0]\n\n mc = mcscf.CASCI(m, 4, 4)\n mc.fcisolver = CheMPS2(mol)\n emc_0 = mc.casci()[0]\n\n b = 1.4\n mol = gto.Mole()\n mol.build(\n verbose = 5,\n output = 'out-casscf',\n atom = [['H', (0.,0.,i)] for i in range(8)],\n basis = {'H': 'sto-3g'},\n symmetry = True,\n )\n m = scf.RHF(mol)\n m.scf()\n\n mc = mcscf.CASSCF(m, 4, 4)\n emc_1ref = mc.mc2step()[0]\n\n mc = mcscf.CASCI(m, 4, 4)\n emc_0ref = mc.casci()[0]\n\n print('CheMPS2-CI = %.15g CASCI = %.15g' % (emc_0, emc_0ref))\n print('CheMPS2-SCF = %.15g CASSCF = %.15g' % (emc_1, emc_1ref))\n", "meta": {"hexsha": "fc6b4cd1c42d874d22d2cb62d246dd3ca143a927", "size": 7134, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyscf/dmrgscf/chemps2.py", "max_stars_repo_name": "crisely09/pyscf", "max_stars_repo_head_hexsha": "cb92f7974bd9c87c0ef5b2b52abf5d3219b3d6b6", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-06-30T22:33:35.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-22T18:02:36.000Z", "max_issues_repo_path": "pyscf/dmrgscf/chemps2.py", "max_issues_repo_name": "crisely09/pyscf", "max_issues_repo_head_hexsha": "cb92f7974bd9c87c0ef5b2b52abf5d3219b3d6b6", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 36, "max_issues_repo_issues_event_min_datetime": "2018-08-22T19:44:03.000Z", "max_issues_repo_issues_event_max_datetime": "2020-05-09T10:02:36.000Z", "max_forks_repo_path": "pyscf/dmrgscf/chemps2.py", "max_forks_repo_name": "crisely09/pyscf", "max_forks_repo_head_hexsha": "cb92f7974bd9c87c0ef5b2b52abf5d3219b3d6b6", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2018-02-14T16:28:28.000Z", "max_forks_repo_forks_event_max_datetime": "2019-08-12T16:40:30.000Z", "avg_line_length": 32.5753424658, "max_line_length": 84, "alphanum_fraction": 0.5663022147, "include": true, "reason": "import numpy", "num_tokens": 2127, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5544704796847396, "lm_q2_score": 0.3415825061409754, "lm_q1q2_score": 0.18939741603190216}} {"text": "\"\"\"\nIMPORTANT : I have not written any exception handling here since this is just a prototype module.\n But exceptions can be logged into database with \"traceback.format_exec()\"\n\"\"\"\n\nimport os\nimport numpy as np\nfrom PIL import Image\nimport torch\nimport torch.nn as nn\nimport torchvision.models as models\nfrom torchvision import transforms\nfrom vocabulary import Vocabulary\n\n\n# This python script will be called by Node.js as child process into project root directory, hence file paths will be from one level up.\n\nENCODER_CNN_CHECKPOINT = \"python_models/saved_models/encoderEpoch_2.pth\"\nDECODER_LSTM_RNN_CHECKPOINT = \"python_models/saved_models/decoderEpoch_2.pth\"\nVOCAB_FILE = \"python_models/saved_models/vocab.pkl\"\n\n# Globally Set device to CPU since GPU won't be necessary for making just one prediction at a time\ndevice = \"cpu\"\n\n\n#=========================================================================\n# Encoder - Decoder Model Class to be used for Generating Caption\n#=========================================================================\n\nclass EncoderCNN(nn.Module):\n def __init__(self, embed_size):\n super(EncoderCNN, self).__init__()\n resnet = models.resnet50(pretrained=True)\n for param in resnet.parameters():\n param.requires_grad_(False)\n\n modules = list(resnet.children())[:-1]\n self.resnet = nn.Sequential(*modules)\n self.embed = nn.Linear(resnet.fc.in_features, embed_size)\n\n def forward(self, images):\n features = self.resnet(images)\n features = features.view(features.size(0), -1)\n features = self.embed(features)\n return features\n\n\nclass DecoderRNN(nn.Module):\n def __init__(self, embed_size, hidden_size, vocab_size, num_layers=1):\n super(DecoderRNN, self).__init__()\n self.embed_size = embed_size\n self.hidden_size = hidden_size\n self.vocab_size = vocab_size\n self.num_layers = num_layers\n\n self.embed = nn.Embedding(num_embeddings = self.vocab_size,\n embedding_dim = self.embed_size)\n self.lstm = nn.LSTM(input_size = self.embed_size,\n hidden_size = self.hidden_size,\n num_layers = self.num_layers,\n batch_first = True)\n self.fc1 = nn.Linear(in_features = self.hidden_size,\n out_features = self.vocab_size)\n\n\n def forward(self, features, captions):\n captions = captions[:,:-1]\n embeddings = self.embed(captions)\n embeddings = torch.cat((features.unsqueeze(1), embeddings),dim=1)\n batch_size = features.shape[0]\n\n self.hidden = (torch.zeros((self.num_layers, batch_size, self.hidden_size), device=device),torch.zeros((self.num_layers, batch_size, self.hidden_size), device=device))\n\n lstm_out, self.hidden = self.lstm(embeddings, self.hidden)\n output = self.fc1(lstm_out)\n return output\n\n def sample(self, inputs, states=None, max_len=20):\n \" accepts pre-processed image tensor (inputs) and returns predicted sentence (list of tensor ids of length max_len) \"\n\n output = []\n batch_size = inputs.shape[0]\n\n self.hidden = (torch.zeros((self.num_layers, batch_size, self.hidden_size), device=device),torch.zeros((self.num_layers, batch_size, self.hidden_size), device=device))\n\n while True:\n lstm_out, self.hidden = self.lstm(inputs, self.hidden)\n linear_out = self.fc1(lstm_out.squeeze(1))\n top_score = linear_out.max(1)[1]\n output.append(top_score.cpu().numpy()[0].item())\n if top_score == 1:\n break\n inputs = self.embed(top_score)\n inputs = inputs.unsqueeze(1)\n return output\n\n\n\n\n\ndef clean_sentence(output,vocab):\n cleaned = []\n for index in output:\n cleaned.append(vocab.idx2word[index])\n cleaned = cleaned[1:-1]\n sentence = ' '.join(cleaned)\n return sentence\n\ndef generateCaptions(image_path):\n vocab = Vocabulary(vocab_file=VOCAB_FILE,vocab_from_file=True,vocab_threshold=None)\n\n # Model parameters\n embed_size = 512\n hidden_size = 512\n vocab_size = len(vocab)\n\n # Initialize the encoder and decoder, and set each to inference mode.\n encoder = EncoderCNN(embed_size)\n decoder = DecoderRNN(embed_size, hidden_size, vocab_size, num_layers=2)\n\n # Load the trained weights.\n encoder.load_state_dict(torch.load(ENCODER_CNN_CHECKPOINT))\n decoder.load_state_dict(torch.load(DECODER_LSTM_RNN_CHECKPOINT))\n\n # Put model to evaluation mode\n encoder.eval()\n decoder.eval()\n\n # Move models to GPU if CUDA is available.\n encoder.to(device)\n decoder.to(device)\n\n transform_predict = transforms.Compose([\n transforms.Resize(256), # smaller edge of image resized to 256\n transforms.RandomCrop(224), # get 224x224 crop from random location\n transforms.RandomHorizontalFlip(), # horizontally flip image with probability=0.5\n transforms.ToTensor(), # convert the PIL Image to a tensor\n transforms.Normalize((0.485, 0.456, 0.406), # normalize image for pre-trained model\n (0.229, 0.224, 0.225))])\n\n\n image = Image.open(image_path).convert('RGB') # Convert to RGB in case additonal channel is there in image\n original_image = np.copy(image)\n image = torch.unsqueeze(transform_predict(image), 0).to(device)\n features = encoder(image).unsqueeze(1)\n output = decoder.sample(features)\n sentence = clean_sentence(output, vocab)\n return {\"sentence\":sentence}\n\n\n\n\n\n", "meta": {"hexsha": "d16d45066a52cbe842e7a305abbb5d10c2afb671", "size": 5686, "ext": "py", "lang": "Python", "max_stars_repo_path": "Node.js_Server/python_models/model.py", "max_stars_repo_name": "3ZadeSSG/Automatic-Image-Captioning", "max_stars_repo_head_hexsha": "5d58ba9bea972999317d4620b2780298562d2aa1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-05T20:18:48.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-05T20:18:48.000Z", "max_issues_repo_path": "Node.js_Server/python_models/model.py", "max_issues_repo_name": "3ZadeSSG/Automatic-Image-Captioning", "max_issues_repo_head_hexsha": "5d58ba9bea972999317d4620b2780298562d2aa1", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Node.js_Server/python_models/model.py", "max_forks_repo_name": "3ZadeSSG/Automatic-Image-Captioning", "max_forks_repo_head_hexsha": "5d58ba9bea972999317d4620b2780298562d2aa1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-04-30T19:43:58.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-30T19:43:58.000Z", "avg_line_length": 36.9220779221, "max_line_length": 175, "alphanum_fraction": 0.6482588815, "include": true, "reason": "import numpy", "num_tokens": 1218, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5544704649604273, "lm_q2_score": 0.3415824860330003, "lm_q1q2_score": 0.18939739985305634}} {"text": "\"\"\"\n=======\nfourier\n=======\n\nThis module define the Fourier class and other functions related to\nthe fourier transformation.\n\"\"\"\nimport numpy as np\nimport pandas as pd\nfrom javelin.grid import Grid\nfrom javelin.utils import get_unitcell, get_positions, get_atomic_numbers\nfrom javelin.fourier_cython import calculate_cython, approx_calculate_cython\n\n\nclass Fourier:\n \"\"\"The Fourier class contains everything required to calculate the\n diffuse scattering. The only required thing to be set is\n :obj:`javelin.fourier.Fourier.structure`. There are defaults for\n all other options including **grid**, **radiation**, **average**\n structure subtraction and **lots** options.\n\n :examples:\n\n >>> from javelin.structure import Structure\n >>> fourier = Fourier()\n >>> print(fourier)\n Radiation : neutron\n Fourier volume : complete crystal\n Aver. subtraction : False\n \n Reciprocal layer :\n lower left corner : [ 0. 0. 0.]\n lower right corner : [ 1. 0. 0.]\n upper left corner : [ 0. 1. 0.]\n top left corner : [ 0. 0. 1.]\n \n hor. increment : [ 0.01 0. 0. ]\n vert. increment : [ 0. 0.01 0. ]\n top increment : [ 0. 0. 1.]\n \n # of points : 101 x 101 x 1\n >>> results = fourier.calc(Structure())\n >>> print(results) # doctest: +SKIP\n \n array([[[ 0.],\n [ 0.],\n ...,\n [ 0.],\n [ 0.]],\n \n [[ 0.],\n [ 0.],\n ...,\n [ 0.],\n [ 0.]],\n \n ...,\n [[ 0.],\n [ 0.],\n ...,\n [ 0.],\n [ 0.]],\n \n [[ 0.],\n [ 0.],\n ...,\n [ 0.],\n [ 0.]]])\n Coordinates:\n * [ 1. 0. 0.] ([ 1. 0. 0.]) float64 0.0 0.01 0.02 0.03 0.04 0.05 0.06 ...\n * [ 0. 1. 0.] ([ 0. 1. 0.]) float64 0.0 0.01 0.02 0.03 0.04 0.05 0.06 ...\n * [ 0. 0. 1.] ([ 0. 0. 1.]) float64 0.0\n Attributes:\n units: r.l.u\n\n \"\"\"\n def __init__(self):\n self._radiation = 'neutron'\n self._lots = None\n self._number_of_lots = None\n self._average = False\n self._magnetic = False\n self._cython = True\n self._approximate = True\n self._fast = True\n\n #: The **grid** attribute defines the reciprocal volume from\n #: which the scattering will be calculated. Must of type\n #: :class:`javelin.grid.Grid` And check\n #: :class:`javelin.grid.Grid` for details on how to change the\n #: grid.\n self.grid = Grid()\n\n def __str__(self):\n return \"\"\"Radiation : {}\nFourier volume : {}\nAver. subtraction : {}\n\nReciprocal layer :\n{}\"\"\".format(self.radiation,\n \"complete crystal\" if self.lots is None else \"{} lots of {} x {} x {} unit cells\"\n .format(self.number_of_lots, *self.lots),\n self.average,\n self.grid)\n\n @property\n def radiation(self):\n \"\"\"The radiation used\n\n :getter: Returns the radiation selected\n :setter: Sets the radiation\n :type: str ('xray' or 'neutron')\n \"\"\"\n return self._radiation\n\n @radiation.setter\n def radiation(self, rad):\n if rad not in ('neutron', 'xray'):\n raise ValueError(\"radiation must be one of 'neutron' or 'xray'\")\n self._radiation = rad\n\n @property\n def lots(self):\n \"\"\"The size of lots\n\n :getter: Returns the lots size\n :setter: Sets the lots size\n :type: list of 3 integers or None\n \"\"\"\n return self._lots\n\n @lots.setter\n def lots(self, lots):\n if lots is None:\n self._lots = None\n else:\n lots = np.asarray(lots)\n if len(lots) == 3:\n self._lots = lots\n else:\n raise ValueError(\"Must provied 3 values for lots\")\n\n @property\n def number_of_lots(self):\n \"\"\"The number of lots to use\n\n :getter: Returns the number of lots\n :setter: Sets the number of lots\n :type: int\n \"\"\"\n return self._number_of_lots\n\n @number_of_lots.setter\n def number_of_lots(self, value):\n self._number_of_lots = value\n\n @property\n def average(self):\n \"\"\"This sets the options of calculating average structure and\n subtracted it from the simulated scattering\n\n :getter: Returns bool of average structure subtraction option\n :setter: Sets whether average structure is subtracted\n :type: bool\n \"\"\"\n return self._average\n\n @average.setter\n def average(self, value):\n if isinstance(value, bool):\n self._average = value\n else:\n raise TypeError(\"Expected a bool, True or False\")\n\n @property\n def magnetic(self):\n \"\"\"This sets the options of calculating the magnetic scattering\n instead of nuclear. This assume neutrons are being used.\n\n :getter: Returns bool of magnetic scattering option\n :setter: Sets whether magnetic sacttering is calculated\n :type: bool\n\n \"\"\"\n return self._magnetic\n\n @magnetic.setter\n def magnetic(self, value):\n if isinstance(value, bool):\n self._magnetic = value\n else:\n raise TypeError(\"Expected a bool, True or False\")\n\n @property\n def approximate(self):\n \"\"\"This sets the options of calculating the approximate scattering\n instead of exact. This is much quicker and is likely good enough for\n most cases.\n\n :getter: Returns bool of approximate scattering option\n :setter: Sets whether approximate sacttering is calculated\n :type: bool\n\n \"\"\"\n return self._approximate\n\n @approximate.setter\n def approximate(self, value):\n if isinstance(value, bool):\n self._approximate = value\n else:\n raise TypeError(\"Expected a bool, True or False\")\n\n def __get_q(self, unitcell):\n qx, qy, qz = self.grid.get_q_meshgrid()\n q = np.linalg.norm(np.array([qx.ravel(),\n qy.ravel(),\n qz.ravel()]).T @ unitcell.B, axis=1)\n q.shape = qx.shape\n return q*2*np.pi\n\n def calc(self, structure):\n \"\"\"Calculates the fourier transform\n\n :param structure: The structure from which fourier transform\n is calculated. The calculation work with any of the following\n types of structures :class:`javelin.structure.Structure`,\n :class:`ase.Atoms` or\n :class:`diffpy.Structure.structure.Structure` but if you are\n using average structure subtraction or the lots option it\n needs to be :class:`javelin.structure.Structure` type.\n\n :return: DataArray containing calculated diffuse scattering\n :rtype: :class:`xarray.DataArray`\n\n \"\"\"\n\n if structure is None:\n raise ValueError(\"You have not set a structure for this calculation\")\n\n if self.average:\n aver = self._calculate_average(structure)\n\n unitcell = get_unitcell(structure)\n\n if self.lots is None:\n atomic_numbers = get_atomic_numbers(structure)\n positions = get_positions(structure)\n if self.magnetic:\n magmons = structure.get_magnetic_moments()\n return create_xarray_dataarray(self._calculate_magnetic(atomic_numbers,\n positions,\n unitcell,\n magmons), self.grid)\n else:\n results = self._calculate(atomic_numbers, positions, unitcell)\n if self.average:\n results -= aver\n\n return create_xarray_dataarray(np.real(results*np.conj(results)), self.grid)\n\n else: # needs to be Javelin structure, lots by unit cell\n total = np.zeros(self.grid.bins)\n levels = structure.atoms.index.levels\n for lot in range(self.number_of_lots):\n print(lot+1, 'out of', self.number_of_lots)\n starti = np.random.randint(len(levels[0]))\n startj = np.random.randint(len(levels[1]))\n startk = np.random.randint(len(levels[2]))\n ri = np.roll(levels[0], -starti)[:self.lots[0]]\n rj = np.roll(levels[1], -startj)[:self.lots[1]]\n rk = np.roll(levels[2], -startk)[:self.lots[2]]\n atoms = structure.atoms.loc[ri, rj, rk, :]\n atomic_numbers = atoms.Z.values\n positions = (atoms[['x', 'y', 'z']].values +\n np.asarray([np.mod(atoms.index.get_level_values(0).values-starti,\n len(levels[0])),\n np.mod(atoms.index.get_level_values(1).values-startj,\n len(levels[1])),\n np.mod(atoms.index.get_level_values(2).values-startk,\n len(levels[2]))]).T)\n if self.magnetic:\n magmons = structure.magmons.loc[ri, rj, rk, :].values\n total += self._calculate_magnetic(atomic_numbers, positions, unitcell, magmons)\n else:\n results = self._calculate(atomic_numbers, positions, unitcell)\n if self.average:\n results -= aver\n total += np.real(results*np.conj(results))\n\n scale = (structure.atoms.index.droplevel(3).drop_duplicates().size /\n (self.number_of_lots*self.lots.prod()))\n\n return create_xarray_dataarray(total*scale, self.grid)\n\n def calc_average(self, structure):\n \"\"\"Calculates the scattering from the avarage structure\n\n :param structure: The structure from which fourier transform\n is calculated. The calculation work with any of the following\n types of structures :class:`javelin.structure.Structure`,\n :class:`ase.Atoms` or\n :class:`diffpy.Structure.structure.Structure` but if you are\n using average structure subtraction or the lots option it\n needs to be :class:`javelin.structure.Structure` type.\n\n :return: DataArray containing calculated average scattering\n :rtype: :class:`xarray.DataArray`\n \"\"\"\n\n if structure is None:\n raise ValueError(\"You have not set a structure for this calculation\")\n\n aver = self._calculate_average(structure)\n return create_xarray_dataarray(np.real(aver*np.conj(aver)), self.grid)\n\n def _calculate_average(self, structure):\n aver = self._calculate(get_atomic_numbers(structure),\n structure.xyz, get_unitcell(structure))\n\n aver /= structure.atoms.index.droplevel(3).drop_duplicates().size\n\n # compute the interference function of the lot shape\n\n if self.lots is None:\n index = structure.atoms.index.droplevel(3).drop_duplicates()\n else:\n index = structure.atoms.loc[pd.RangeIndex(self.lots[0]),\n pd.RangeIndex(self.lots[1]),\n pd.RangeIndex(self.lots[2]),\n :].index.droplevel(3).drop_duplicates()\n\n aver *= self._calculate(np.zeros(len(index), dtype=np.int),\n np.asarray([index.get_level_values(0).astype('double').values,\n index.get_level_values(1).astype('double').values,\n index.get_level_values(2).astype('double').values]).T,\n use_ff=False)\n\n return aver\n\n def _calculate(self, atomic_numbers, positions, unitcell=None, use_ff=True):\n if self._fast and not self._cython:\n qx, qy, qz = self.grid.get_squashed_q_meshgrid()\n else:\n qx, qy, qz = self.grid.get_q_meshgrid()\n qx *= (2*np.pi)\n qy *= (2*np.pi)\n qz *= (2*np.pi)\n\n # Get unique list of atomic numbers\n unique_atomic_numbers = np.unique(atomic_numbers)\n\n results = np.zeros(self.grid.bins, dtype=np.complex)\n # Loop of atom types\n for atomic_number in unique_atomic_numbers:\n try:\n ff = get_ff(atomic_number, self.radiation, self.__get_q(unitcell)) if use_ff else 1\n except KeyError as e:\n print(\"Skipping fourier calculation for atom \" + str(e) +\n \", unable to get scattering factors.\")\n continue\n\n atom_positions = positions[np.where(atomic_numbers == atomic_number)]\n temp_array = np.zeros(self.grid.bins, dtype=np.complex)\n print(\"Working on atom number\", atomic_number, \"Total atoms:\", len(atom_positions))\n\n # Loop over atom positions of type atomic_number\n if self._cython:\n if self.approximate:\n cex = np.exp(np.linspace(0, 2j*np.pi*(1-2**-16), 2**16))\n approx_calculate_cython(self.grid.ll, self.grid.v1_delta,\n self.grid.v2_delta, self.grid.v3_delta,\n atom_positions, temp_array.real,\n temp_array.imag, cex.real, cex.imag)\n else:\n calculate_cython(qx, qy, qz, atom_positions, temp_array.real, temp_array.imag)\n else:\n if self._fast:\n for atom in atom_positions:\n dotx = np.exp(qx*atom[0]*1j)\n doty = np.exp(qy*atom[1]*1j)\n dotz = np.exp(qz*atom[2]*1j)\n temp_array += dotx * doty * dotz\n else:\n for atom in atom_positions:\n dot = qx*atom[0] + qy*atom[1] + qz*atom[2]\n temp_array += np.exp(dot*1j)\n\n results += temp_array * ff # scale by form factor\n\n return results\n\n def _calculate_magnetic(self, atomic_numbers, positions, unitcell, magmons):\n if self._fast:\n qx, qy, qz = self.grid.get_squashed_q_meshgrid()\n else:\n qx, qy, qz = self.grid.get_q_meshgrid()\n qx *= (2*np.pi)\n qy *= (2*np.pi)\n qz *= (2*np.pi)\n q2 = self.__get_q(unitcell)**2\n\n # Get unique list of atomic numbers\n unique_atomic_numbers = np.unique(atomic_numbers)\n\n # Loop of atom types\n spinx = np.zeros(self.grid.bins, dtype=np.complex)\n spiny = np.zeros(self.grid.bins, dtype=np.complex)\n spinz = np.zeros(self.grid.bins, dtype=np.complex)\n for atomic_number in unique_atomic_numbers:\n try:\n ff = get_mag_ff(atomic_number, self.__get_q(unitcell), ion=3)\n except (AttributeError, KeyError) as e:\n print(\"Skipping fourier calculation for atom \" + str(e) +\n \", unable to get magnetic scattering factors.\")\n continue\n\n atom_positions = positions[np.where(atomic_numbers == atomic_number)]\n temp_spinx = np.zeros(self.grid.bins, dtype=np.complex)\n temp_spiny = np.zeros(self.grid.bins, dtype=np.complex)\n temp_spinz = np.zeros(self.grid.bins, dtype=np.complex)\n print(\"Working on atom number\", atomic_number, \"Total atoms:\", len(atom_positions))\n # Loop over atom positions of type atomic_number\n if self._fast:\n for atom, spin in zip(atom_positions, magmons):\n dotx = np.exp(qx*atom[0]*1j)\n doty = np.exp(qy*atom[1]*1j)\n dotz = np.exp(qz*atom[2]*1j)\n exp_temp = dotx * doty * dotz\n temp_spinx += exp_temp*spin[0]\n temp_spiny += exp_temp*spin[1]\n temp_spinz += exp_temp*spin[2]\n else:\n for atom, spin in zip(atom_positions, magmons):\n dot = qx*atom[0] + qy*atom[1] + qz*atom[2]\n exp_temp = np.exp(dot*1j)\n temp_spinx += exp_temp*spin[0]\n temp_spiny += exp_temp*spin[1]\n temp_spinz += exp_temp*spin[2]\n spinx += temp_spinx * ff\n spiny += temp_spiny * ff\n spinz += temp_spinz * ff\n # Calculate vector rejection of spin onto q\n # M - M.Q/|Q|^2 Q\n scale = (spinx*qx + spiny*qy + spinz*qz)/q2\n spinx = spinx - scale * qx\n spiny = spiny - scale * qy\n spinz = spinz - scale * qz\n return np.real(spinx*np.conj(spinx) + spiny*np.conj(spiny) + spinz*np.conj(spinz))\n\n\ndef create_xarray_dataarray(values, grid):\n \"\"\"Create a xarry DataArray from the input numpy array and grid\n object.\n\n :param values: Input array containing the scattering intensities\n :type values: :class:`numpy.ndarray`\n :param numbers: Grid object describing the array properties\n :type numbers: :class:`javelin.grid.Grid`\n :return: DataArray produced from the values and grid object\n :rtype: :class:`xarray.DataArray`\n \"\"\"\n import xarray as xr\n return xr.DataArray(data=values,\n name=\"Intensity\",\n dims=(grid.get_axes_names()),\n coords=(grid.r1, grid.r2, grid.r3),\n attrs=((\"units\", grid.units),))\n\n\ndef get_ff(atomic_number, radiation, q=None):\n \"\"\"Returns the form factor for a given atomic number, radiation and q\n values\n\n :param atomic_number: atomic number\n :type atomic_number: int\n :param radiation: type of radiation ('xray' or 'neutron')\n :type radiation: str\n :param q: value or values of q for which to get form factors\n :type q: float, list, :class:`numpy.ndarray`\n :return: form factors for given q\n :rtype: float, :class:`numpy.ndarray`\n\n :Examples:\n\n >>> get_ff(8, 'neutron')\n 5.805\n\n >>> get_ff(8, 'xray', q=2.0)\n 6.31826029176493\n\n >>> get_ff(8, 'xray', q=[0.0, 3.5, 7.0])\n array([ 7.999706 , 4.38417867, 2.08928068])\n \"\"\"\n import periodictable\n\n if atomic_number < 1:\n raise KeyError(atomic_number)\n\n if radiation == 'neutron':\n return periodictable.elements[atomic_number].neutron.b_c\n elif radiation == 'xray':\n return periodictable.elements[atomic_number].xray.f0(q)\n else:\n raise ValueError(\"Unknown radition: \" + radiation)\n\n\ndef get_mag_ff(atomic_number, q, ion=0, j=0):\n \"\"\"Returns the j0 magnetic form factor for a given atomic number,\n radiation and q values\n\n :param atomic_number: atomic number\n :type atomic_number: int\n :param q: value or values of q for which to get form factors\n :type q: float, list, :class:`numpy.ndarray`\n :param ion: charge of selected atom\n :type ion: int\n :param j: order of spherical Bessel function (0, 2, 4 or 6)\n :type j: int\n :return: magnetic form factor for given q\n :rtype: float, :class:`numpy.ndarray`\n\n :Examples:\n\n >>> get_mag_ff(8, q=2, ion=1)\n 0.58510426376585045\n\n >>> get_mag_ff(26, q=[0.0, 3.5, 7.0], ion=2)\n array([ 1. , 0.49729671, 0.09979243])\n\n >>> get_mag_ff(26, q=[0.0, 3.5, 7.0], ion=4)\n array([ 0.9997 , 0.58273549, 0.13948496])\n\n >>> get_mag_ff(26, q=[0.0, 3.5, 7.0], ion=4, j=4)\n array([ 0. , 0.0149604, 0.0759222])\n \"\"\"\n import periodictable\n return getattr(periodictable.elements[atomic_number].magnetic_ff[ion], 'j'+str(j)+'_Q')(q)\n", "meta": {"hexsha": "b62820a67531659ac303aa167f5906d8d4a18c5c", "size": 20115, "ext": "py", "lang": "Python", "max_stars_repo_path": "javelin/fourier.py", "max_stars_repo_name": "rosswhitfield/Javelin", "max_stars_repo_head_hexsha": "a3538193343b5e086c8f4557d1890bac93dfddb8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2018-01-30T21:43:30.000Z", "max_stars_repo_stars_event_max_datetime": "2020-06-02T12:24:51.000Z", "max_issues_repo_path": "javelin/fourier.py", "max_issues_repo_name": "rosswhitfield/Javelin", "max_issues_repo_head_hexsha": "a3538193343b5e086c8f4557d1890bac93dfddb8", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2018-05-01T18:45:43.000Z", "max_issues_repo_issues_event_max_datetime": "2018-05-01T18:45:43.000Z", "max_forks_repo_path": "javelin/fourier.py", "max_forks_repo_name": "rosswhitfield/Javelin", "max_forks_repo_head_hexsha": "a3538193343b5e086c8f4557d1890bac93dfddb8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2016-11-16T18:48:55.000Z", "max_forks_repo_forks_event_max_datetime": "2020-02-19T03:55:41.000Z", "avg_line_length": 37.25, "max_line_length": 99, "alphanum_fraction": 0.5526721352, "include": true, "reason": "import numpy", "num_tokens": 4907, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5660185351961015, "lm_q2_score": 0.3345894478883556, "lm_q1q2_score": 0.18938382918583935}} {"text": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n##############\n# GaudiMM: Genetic Algorithms with Unrestricted\n# Descriptors for Intuitive Molecular Modeling\n# \n# https://github.com/insilichem/gaudi\n#\n# Copyright 2017 Jaime Rodriguez-Guerra, Jean-Didier Marechal\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n# \n# http://www.apache.org/licenses/LICENSE-2.0\n# \n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n##############\n\n\"\"\"\nThis objective performs rough estimations\nof good orientations of ligating residues in a protein to\ncoordinate a given metal or small molecule. The geometry is approximated\nby computing average distances from ligating atoms the metal centre (``self.probe``)\nas well as the angles formed by the probe, the ligating atom and its immediate neighbor.\nGood planarity is assured by a dihedral check.\n\n\"\"\"\n\n# Python\nfrom __future__ import print_function, division\nimport math\nimport logging\nimport numpy as np\n# Chimera\nimport chimera\n# GAUDI\nfrom gaudi.objectives import ObjectiveProvider\nfrom gaudi.exceptions import AtomsNotFound, ResiduesNotFound, MoleculesNotFound\nfrom gaudi import parse\nfrom gaudi._cpdrift import coherent_point_drift\n\n\nlogger = logging.getLogger(__name__)\n\n\nGEOMETRIES = {\n 'cube': np.array([(1.0, 1.0, 1.0), (1.0, 1.0, -1.0), (1.0, -1.0, 1.0), (1.0, -1.0, -1.0), (-1.0, 1.0, 1.0), (-1.0, 1.0, -1.0), (-1.0, -1.0, 1.0), (-1.0, -1.0, -1.0), (0.0, 0.0, 0.0)]),\n 'hexagonal bipyramid': np.array([(0.0, 1.0, 0.0), (0.0, -1.0, 0.0), (0.0, 0.0, 1.0), (0.0, 0.0, -1.0), (0.8660, 0.0, 0.5), (0.8660, 0.0, -0.5), (-0.8660, 0.0, 0.5), (-0.8660, 0.0, -0.5), (0.0, 0.0, 0.0)]),\n 'linear': np.array([(0.0, 1.0, 0.0), (0.0, -1.0, 0.0), (0.0, 0.0, 0.0)]),\n 'octahedron': np.array([(1.0, 0.0, 0.0), (-1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, -1.0, 0.0), (0.0, 0.0, 1.0), (0.0, 0.0, -1.0), (0.0, 0.0, 0.0)]),\n 'pentagonal bipyramid': np.array([(0.0, 1.0, 0.0), (0.0, -1.0, 0.0), (0.0, 0.0, 1.0), (0.9511, 0.0, 0.30901), (0.5878, 0.0, -0.8090), (-0.5878, 0.0, -0.8090), (-0.9511, 0.0, 0.3090), (0.0, 0.0, 0.0)]),\n 'square planar': np.array([(1.0, 0.0, 0.0), (-1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, -1.0, 0.0), (0.0, 0.0, 0.0)]),\n 'square pyramid': np.array([(0.0, 1.0, 0.0), (-0.6123, -0.5, 0.6123), (0.6123, -0.5, 0.6123), (-0.6123, -0.5, -0.6123), (0.6123, -0.5, -0.6123), (0.0, 0.0, 0.0)]),\n 'tetrahedral': np.array([(1.0, 1.0, 1.0), (-1.0, -1.0, 1.0), (-1.0, 1.0, -1.0), (1.0, -1.0, -1.0), (0.0, 0.0, 0.0)]),\n 'trigonal planar': np.array([(1.0, 0.0, 0.0), (-0.5, 0.0, 0.8660), (-0.5, 0.0,-0.8660), (0.0, 0.0, 0.0)]),\n 'trigonal bipyramid': np.array([(0.0, 1.0, 0.0), (0.0, -1.0, 0.0), (1.0, 0.0, 0.0), (-0.5, 0.0, 0.8660), (-0.5, 0.0, -0.8660), (0.0, 0.0, 0.0)]),\n 'trigonal prism': np.array([(-0.6547, 0.6547, 0.3779), (0.6547, 0.6547, 0.3779), (0.0, 0.6547, -0.7559), (-0.6547, -0.6547, 0.3779), (0.6547, -0.6547, 0.3779), (0.0, -0.6547, -0.7559), (0.0, 0.0, 0.0)])}\n\ndef enable(**kwargs):\n kwargs = Coordination.validate(kwargs)\n return Coordination(**kwargs)\n\n\nclass Coordination(ObjectiveProvider):\n\n \"\"\"\n Coordination class\n\n Parameters\n ----------\n probe : tuple\n The atom that acts as the metal center, expressed as\n /. This will be parsed later on.\n residues : list of str\n Residues that must coordinate to `probe`, expressed as\n /. Position can be `*`.\n radius : float, optional, default=3.0\n Distance from `probe` where ligating atoms must be found\n atom_types : list of str, optional\n Types of atoms that are considered ligands to `probe`\n atom_names : list of str, optional\n Names of atoms that are considered ligands to `probe`\n atom_elements : list of str, optional\n Elements of atoms that are considered ligands to `probe` \n distance : float, optional\n Perfect distance a ligand atom should be from target.\n geometry : str or list of 3-tuple floats, optional\n Which geometry should be fitted. Choose from `GEOMETRIES` dict or\n specify a set of vectors.\n enforce_all_residues: bool, optional\n Whether to force or not if all specified residues should coordinate.\n only_one_ligand_per_residue : bool, optional\n Enforce that only one ligand for each residue should coordinate.\n prevent_intruders : bool, optional\n Don't let non-ligand atoms to be closer to the target than the \n selected ligand atoms.\n center_of_mass_correction : bool, optional\n If True, calculate the distance between the metal center \n and the center of mass of the ligand atoms, and sum that\n to the final score.\n distance_correction : bool, optional\n If True, report the deviation of the experimental coordination\n bond length and the ideal one, as tabulated by ``chimera.Element``,\n and sum that to the final score.\n\n Returns\n -------\n float\n Sum of RMSD of vertices from ideal RMSD and average cosine of\n angle deviation from ideal orientation of ligand neighbors.\n A perfect match should report 0.0.\n \"\"\"\n _validate = {\n parse.Required('probe'): parse.Named_spec(\"molecule\", \"atom\"),\n parse.Required('residues'): [parse.Named_spec(\"molecule\", \"residue\")],\n 'radius': parse.Coerce(float),\n 'atom_types': [basestring],\n 'atom_names': [basestring],\n 'atom_elements': [basestring],\n 'distance': parse.All(parse.Coerce(float), parse.Range(min=0)),\n 'min_atoms': parse.All(parse.Coerce(int), parse.Range(min=2)),\n 'geometry': parse.Any(parse.In(GEOMETRIES.keys()), [parse.Coordinates]),\n 'enforce_all_residues': parse.Coerce(bool),\n 'only_one_ligand_per_residue': parse.Coerce(bool),\n 'prevent_intruders': parse.Coerce(bool),\n 'center_of_mass_correction': parse.Coerce(bool),\n 'distance_correction': parse.Coerce(bool)\n }\n \n def __init__(self, probe=None, radius=3.0, atom_types=(), atom_elements=(), \n atom_names=(), residues=(), geometry='tetrahedral', distance=0, \n min_atoms=1, prevent_intruders=True, enforce_all_residues=False, \n only_one_ligand_per_residue=False, center_of_mass_correction=False,\n distance_correction=False, *args, **kwargs):\n ObjectiveProvider.__init__(self, **kwargs)\n self._probe = probe\n self._residues = residues\n self.radius = radius\n self.atom_types = atom_types\n self.atom_names = atom_names\n self.atom_elements = atom_elements\n self.distance = distance\n self.min_atoms = min_atoms\n self.only_one_ligand_per_residue = only_one_ligand_per_residue\n self.enforce_all_residues = enforce_all_residues\n self.prevent_intruders = prevent_intruders\n self.center_of_mass_correction = center_of_mass_correction\n self.distance_correction = distance_correction\n if isinstance(geometry, basestring):\n self.geometry = np.copy(GEOMETRIES[geometry])\n else:\n self.geometry = np.array(geometry)\n self.n_vertices = self.geometry.shape[0] - 1\n if self.n_vertices < self.min_atoms:\n self.min_ligands = self.n_vertices\n logger.warn('# Vertices in selected geometry < min_ligands! Overriding '\n 'min_ligands with {}'.format(self.n_vertices))\n if not sum(map(bool, [atom_types, atom_elements, atom_names])):\n raise ValueError('At least one of atom_types, atom_elements, atom_names '\n 'must be specified')\n\n def molecules(self, ind):\n return [m.compound.mol for m in ind._molecules.values()]\n\n def probe(self, ind):\n mol, serial = self._probe\n return ind.find_molecule(mol).find_atom(serial)\n\n def residues(self, ind):\n for mol, pos in self._residues:\n for residue in ind.find_molecule(mol).find_residues(pos):\n yield residue\n\n def evaluate(self, ind):\n \"\"\"\n 1. Get requested atoms sorted by distance\n 2. If they meet the minimum quantity, return the rmsd for\n that geometry\n 3. If that's not possible of they are not enough, return penalty\n \"\"\"\n try:\n test_atoms = [a for d, a in self.coordination_sphere(ind)]\n except ResiduesNotFound:\n logger.warning(\"Not enough atoms or some residues missing\")\n return -1000 * self.weight\n \n missing_atoms = self.min_atoms - len(test_atoms)\n if missing_atoms > 0:\n logger.warning(\"Could not find enough ligand atoms in probe environment. \"\n \"{} missing\".format(missing_atoms))\n return -100 * missing_atoms * self.weight\n\n geometry = np.copy(self.geometry)\n ligands = test_atoms[:self.n_vertices]\n metal = self.probe(ind)\n atom_points = [a.xformCoord() for a in ligands + [metal]]\n atom_points_array = np.array(atom_points)\n # rmsd\n try:\n _, _, rmsd = coherent_point_drift(atom_points_array, geometry, method='rigid',\n guess_steps=2, max_iterations=10)\n except Exception as e:\n logger.exception(e) #\n logger.warning(\"Geometry not feasible in current conditions\")\n return -1000 * self.weight\n # directionality\n directionality = sum(ideal_bond_deviation(metal, ligand, ligands) for ligand in ligands)\n \n com_deviation = 0\n if self.center_of_mass_correction:\n ligands_com = np.average(atom_points_array[:-1], axis=0)\n com_deviation = atom_points[-1].distance(chimera.Point(*ligands_com))\n \n dist_deviation = 0\n if self.distance_correction:\n for ligand in ligands:\n experimental_bond_length = ligand.xformCoord().distance(atom_points[-1])\n ideal_bond_length = chimera.Element.bondLength(ligand.element, metal.element)\n dist_deviation += abs(experimental_bond_length - ideal_bond_length)\n \n return rmsd + directionality + com_deviation + dist_deviation\n\n def coordination_sphere(self, ind):\n \"\"\"\n 1. Get atoms and residues found within ``self.radius`` \n angstroms from ``self.probe``. Found residues MUST \n include ``self.residues``. Otherwise, apply penalty.\n\n 2. Sort atoms by absolute difference of ``self.distance``\n and distance to ``self.probe``. That way, nearest atoms are computed first.\n If found atoms do not include some of the requested types, apply penalty.\n \"\"\"\n # Helpers\n def abs_distance(a):\n return abs(self.distance - metal.xformCoord().distance(a.xformCoord()))\n if self.atom_types:\n def atom_is_valid(a): return a.idatmType in self.atom_types\n elif self.atom_elements:\n def atom_is_valid(a): return a.element.name in self.atom_elements\n elif self.atom_names:\n def atom_is_valid(a): return a.name in self.atom_names\n else:\n def atom_is_valid(a): return True\n\n self._update_zone(ind)\n metal = self.probe(ind)\n residues = list(self.residues(ind))\n atoms = [a for a in self.zone.atoms() if a is not metal]\n \n atoms_by_distance = []\n found_residues = set()\n distance_and_atoms = sorted((abs_distance(a), a) for a in atoms)\n for d, a in distance_and_atoms:\n if atom_is_valid(a) and a.residue in residues and d > 1.0:\n atoms_by_distance.append((d, a))\n found_residues.add(a.residue)\n elif self.prevent_intruders:\n break\n\n if self.enforce_all_residues and found_residues != residues:\n logger.warning(\"Some atoms found, but some residues are missing\")\n raise ResiduesNotFound\n\n return atoms_by_distance\n\n def _update_zone(self, ind):\n \"\"\"\n Clear existing selection and add atoms within `self.radius` from\n `self.probe`, as long as they belong to one of `self.molecules`\n \"\"\"\n self.zone.clear()\n self.zone.add(self.probe(ind))\n self.zone.merge(chimera.selection.REPLACE,\n chimera.specifier.zone(\n self.zone, 'atom', None, self.radius, self.molecules(ind)))\n return self.zone\n\n\ndef ideal_bond_deviation(metal, ligand, other_ligands=()):\n\n \"\"\"\n Assess if the current bond vector is well oriented with\n respect to the ideal bond vector.\n\n Parameters\n ----------\n metal : chimera.Atom\n The ion `ligands` are coordinating to\n ligand : chimera.Atom\n Potential ligand atoms to `metal`\n\n Returns\n -------\n float\n Absolute sine of the angle between the ideal vector and\n the ligand-metal one.\n \"\"\"\n ligand_idatm = chimera.idatm.typeInfo.get(ligand.idatmType)\n ligand_geometry = ligand_idatm.geometry if ligand_idatm else 3\n ideal_positions = ideal_bonded_positions(ligand, metal.element, geometry=ligand_geometry)\n if not ideal_positions:\n logger.warning(\"Ligand %s reports no available bonding positions. Check your atom_types!\", ligand)\n return 1.0\n # else we can go on\n # Conditions and booleans\n rotates = ligand_geometry == 4 and len(ligand.neighbors) == 1\n bidentate = False\n for bidentate_mate in other_ligands:\n if bidentate_mate is not ligand:\n shared_neighbors = set(ligand.neighbors) & set(bidentate_mate.neighbors)\n if shared_neighbors:\n bidentate = True\n break\n\n # Coordinates and positions\n ligand_coord = ligand.xformCoord()\n metal_coord = metal.xformCoord()\n if not ligand.neighbors:\n # If ligand has no neighbors, it's an isolated atom. This means it will always \n # be well oriented towards the metal. Then we can just return 0.0\n return 0.0\n # else we can go on\n neighbor = ligand.neighbors[0]\n neighbor_coord = neighbor.xformCoord()\n try:\n n_neighbor = next(a for a in neighbor.neighbors if a is not ligand)\n n_neighbor_coord = n_neighbor.xformCoord()\n except StopIteration:\n logger.warning('Ligand %s has no 2nd level neighbors. Dihedrals cannot be evaluated', ligand)\n rotates = True # This will force to ignore dihedral calculation ;)\n \n ideal_pos = ideal_positions[0]\n actual_angle = chimera.angle(neighbor_coord, ligand_coord, metal_coord)\n ideal_angles = [chimera.angle(neighbor_coord, ligand_coord, ideal_pos)]\n ideal_dihedrals = []\n if bidentate and not rotates:\n a = ligand_coord\n b = bidentate_mate.xformCoord() \n c = shared_neighbors.pop().xformCoord()\n bidentate_ideal_pos = c + 1.5 * ((a-c) + (b-c))\n bidentate_ideal_angle = chimera.angle(neighbor_coord, ligand_coord, bidentate_ideal_pos)\n bidentate_ideal_dihedral = chimera.dihedral(n_neighbor_coord, neighbor_coord, \n ligand_coord, bidentate_ideal_pos)\n ideal_angles.append(bidentate_ideal_angle)\n ideal_dihedrals.append(bidentate_ideal_dihedral)\n \n angle_diff = min(delta - actual_angle for delta in ideal_angles)\n abs_sin_angle = abs(math.sin(math.radians(angle_diff)))\n if rotates: # we don't care about the dihedral in this case\n return abs_sin_angle\n # else:\n actual_dihedral = chimera.dihedral(n_neighbor_coord, neighbor_coord, ligand_coord, metal_coord)\n ideal_dihedral = chimera.dihedral(n_neighbor_coord, neighbor_coord, ligand_coord, ideal_pos)\n ideal_dihedrals.append(ideal_dihedral)\n dihedral_diff = min(delta - actual_dihedral for delta in ideal_dihedrals)\n abs_sin_dihedral = abs(math.sin(math.radians(dihedral_diff)))\n return abs_sin_angle + abs_sin_dihedral\n\n\ndef ideal_bonded_positions(atom, element, geometry=None):\n if geometry is None:\n try:\n geometry = chimera.idatm.typeInfo[atom.idatmType].geometry\n except KeyError:\n geometry = 3\n\n bond_length = chimera.Element.bondLength(atom.element, element)\n neighbors_crd = [a.xformCoord() for a in atom.neighbors]\n return chimera.bondGeom.bondPositions(atom.xformCoord(), geometry, bond_length, neighbors_crd)\n", "meta": {"hexsha": "e5e3582c189d1784af2db87885d216a7a5be2cce", "size": 16886, "ext": "py", "lang": "Python", "max_stars_repo_path": "gaudi/objectives/coordination.py", "max_stars_repo_name": "jaimergp/gaudi", "max_stars_repo_head_hexsha": "8cb3ed9940e00c3d854c5c747b56a7a713ed7738", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 21, "max_stars_repo_stars_event_min_datetime": "2017-07-28T01:27:20.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-04T10:20:33.000Z", "max_issues_repo_path": "gaudi/objectives/coordination.py", "max_issues_repo_name": "jaimergp/gaudi", "max_issues_repo_head_hexsha": "8cb3ed9940e00c3d854c5c747b56a7a713ed7738", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 13, "max_issues_repo_issues_event_min_datetime": "2017-07-28T01:30:59.000Z", "max_issues_repo_issues_event_max_datetime": "2020-09-02T08:47:47.000Z", "max_forks_repo_path": "gaudi/objectives/coordination.py", "max_forks_repo_name": "jaimergp/gaudi", "max_forks_repo_head_hexsha": "8cb3ed9940e00c3d854c5c747b56a7a713ed7738", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 25, "max_forks_repo_forks_event_min_datetime": "2017-05-05T09:01:28.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-04T05:05:41.000Z", "avg_line_length": 44.9095744681, "max_line_length": 209, "alphanum_fraction": 0.6395830866, "include": true, "reason": "import numpy", "num_tokens": 4671, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5660185351961015, "lm_q2_score": 0.3345894478883556, "lm_q1q2_score": 0.18938382918583935}} {"text": "# Copyright 2022 The TEMPO Collaboration\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"\nModule for system 'control operations' as discussed in [Pollock2018].\n\n**[Pollock2018]**\nF. A. Pollock, C. Rodriguez-Rosario, T. Frauenheim,\nM. Paternostro, and K. Modi, *Non-Markovian quantumprocesses: Complete\nframework and efficient characterization*, Phys. Rev. A 97, 012127 (2018).\n\"\"\"\n\nfrom typing import Callable, List, Optional, Text, Tuple, Union\nfrom copy import deepcopy\n\nimport numpy as np\nfrom numpy import ndarray\n\nfrom oqupy.base_api import BaseAPIClass\nfrom oqupy.config import NpDtype\n\nclass Control(BaseAPIClass):\n \"\"\"\n Represents a set of system control operations.\n\n A control operation is a superoperator that acts on the system\n instantaneously at a particular time, as described in [Pollock2018].\n\n Parameters\n ----------\n dimension: int\n The Hilbert space dimension of the system.\n name: str\n An optional name for the set of control operations.\n description: str\n An optional description of the set of control operations.\n \"\"\"\n def __init__(\n self,\n dimension: int,\n name: Optional[Text] = None,\n description: Optional[Text] = None) -> None:\n \"\"\"Creates a Control object. \"\"\"\n self._dimension = dimension\n self._step_controls = {'pre':{}, 'post':{}}\n self._time_controls = {'pre':{}, 'post':{}}\n self._control_times = {'pre':np.array([]), 'post':np.array([])}\n super().__init__(name, description)\n\n @property\n def dimension(self):\n \"\"\"Hilbert space dimension of the controlled system. \"\"\"\n return self._dimension\n\n def add_single(\n self,\n time: Union[int, float],\n control_operation: ndarray,\n post: Optional[bool] = False) -> None:\n r\"\"\"\n Adds a single control operation at time `time`.\n\n Parameters\n ----------\n time: Union[int, float]\n The time at which the operation should be applied. If `type(time)`\n is `int` then `time` is understood as the *timestep* to which it\n shall be applied.\n control_operation: ndarray\n The control operation super operator of shape\n :math:`d^2 \\times d^2`, where :math:`d` is the system Hilbert space\n dimension.\n post: bool\n If `True` (`False`) the operator is applied at the corresponding\n time step *after* (*before*) a possible measurement of the state.\n \"\"\"\n if post:\n pre_post = 'post'\n else:\n pre_post = 'pre'\n\n if isinstance(time, int):\n steps = self._step_controls[pre_post].keys()\n if time in steps:\n self._step_controls[pre_post][time] = \\\n control_operation @ self._step_controls[pre_post][time]\n else:\n self._step_controls[pre_post][time] = control_operation\n elif isinstance(time, float):\n if time in self._control_times[pre_post]:\n self._time_controls[pre_post][time] = \\\n control_operation @ self._time_controls[pre_post][time]\n else:\n self._time_controls[pre_post][time] = control_operation\n times = np.append(self._control_times[pre_post], time)\n times.sort()\n self._control_times[pre_post] = times\n else:\n raise TypeError(\"Parameter `time` must be either int or float.\")\n\n\n def add_continuous(\n self,\n control_fct: Callable[[ndarray, float], ndarray],\n post: Optional[bool] = False) -> None:\n \"\"\"\n ToDo\n \"\"\"\n raise NotImplementedError()\n\n def get_controls(\n self,\n step: int,\n dt: Optional[float] = None,\n start_time: Optional[float] = 0.0,\n ) -> Tuple[ndarray, ndarray]:\n \"\"\"\n Get the pre and post measurement control operation for a specific\n time step.\n\n Parameters\n ----------\n step: int\n The time step.\n dt: float\n The time step length.\n start_time: float\n The initial time step off-set.\n\n Returns\n -------\n pre: ndarray\n The control superoperator that should be applied before a state\n measurement.\n post: ndarray\n The control superoperator that should be applied after a state\n measurement.\n \"\"\"\n pre_control_bool = False\n post_control_bool = False\n pre_control = np.identity(self.dimension**2)\n post_control = np.identity(self.dimension**2)\n\n # -- pre time-stamp controls --\n a = np.round((self._control_times['pre'] - start_time) / dt)\n times = np.array(self._control_times['pre'])[np.nonzero(a==step)]\n if len(times) > 0:\n print(times)\n pre_control_bool = True\n pre_control = self._time_controls['pre'][times[0]] @ pre_control\n for t in times[1:]:\n pre_control = self._time_controls['pre'][t] @ pre_control\n\n # -- pre step controls --\n steps = self._step_controls['pre'].keys()\n if step in steps:\n pre_control_bool = True\n pre_control = self._step_controls['pre'][step] @ pre_control\n\n # -- post step controls --\n steps = self._step_controls['post'].keys()\n if step in steps:\n post_control_bool = True\n post_control = self._step_controls['post'][step] @ post_control\n\n # -- post time-stamp controls --\n a = np.round((self._control_times['post'] - start_time) / dt)\n times = np.array(self._control_times['post'])[np.nonzero(a==step)]\n if len(times) > 0:\n post_control_bool = True\n post_control = self._time_controls['post'][times[0]] @ post_control\n for t in times[1:]:\n post_control = self._time_controls['post'][t] @ post_control\n\n if not pre_control_bool:\n pre_control = None\n if not post_control_bool:\n post_control = None\n return pre_control, post_control\n\nclass ChainControl(BaseAPIClass):\n \"\"\"\n Control operations on a linear system chain.\n\n Parameters\n ----------\n hilbert_space_dimensions: List[int]\n Hilbert space dimension for each chain site.\n name: str\n An optional name for the chain controls.\n description: str\n An optional description of the chain controls.\n \"\"\"\n def __init__(\n self,\n hilbert_space_dimensions: List[int],\n name: Optional[Text] = None,\n description: Optional[Text] = None) -> None:\n \"\"\"Create a ChainControl object. \"\"\"\n tmp_hs_dims = np.array(hilbert_space_dimensions, int)\n assert len(tmp_hs_dims.shape) == 1\n assert len(tmp_hs_dims) >= 1\n assert np.all(tmp_hs_dims > 0)\n self._hs_dims = tmp_hs_dims\n\n self._single_site_controls_pre = []\n self._single_site_controls_post = []\n\n super().__init__(name, description)\n\n def __len__(self):\n \"\"\"Length of the chain. \"\"\"\n return len(self._hs_dims)\n\n @property\n def hs_dims(self):\n \"\"\"Hilbert space dimensions. \"\"\"\n return self._hs_dims\n\n def add_single_site_control(\n self,\n control: ndarray,\n site: int,\n step: int,\n post: Optional[bool] = False,\n name: Optional[Text] = None) -> None:\n \"\"\"\n Add a control operation at site `site` and time step `step`.\n\n Parameters\n ----------\n control: ndarray\n Control operation in Liouville space.\n site: int\n Site index.\n step: int\n Timestep to which the control should be applied.\n post: bool\n True if the control should be applied *after* the measurement of\n this time step.\n name: Text\n An optional name to recognize a control operation.\n \"\"\"\n assert isinstance(site, int)\n assert site < len(self)\n assert isinstance(step, int)\n contr = np.array(control, dtype=NpDtype)\n assert contr.shape == (self._hs_dims[site]**2, self._hs_dims[site]**2)\n if not post:\n self._single_site_controls_pre.append({\n \"contr\":contr,\n \"site\":site,\n \"step\":step,\n \"name\":name})\n else:\n self._single_site_controls_post.append({\n \"contr\":contr,\n \"site\":site,\n \"step\":step,\n \"name\":name})\n\n def get_single_site_controls(\n self,\n step: int,\n post: bool) -> List[ndarray]:\n \"\"\"\n Get a list of single site controls for the time step `step`.\n\n Parameters\n ----------\n step: int\n The time step.\n post: bool\n If `True` (`False`) the set of control superoperators that should be\n applied *after* (*before*) the measurement is returned.\n\n Returns\n -------\n superoperators_list: list[ndarray]\n List of single site control superoperators.\n \"\"\"\n empty = True\n controls = [None] * len(self)\n\n if not post:\n ss_controls = self._single_site_controls_pre\n else:\n ss_controls = self._single_site_controls_post\n\n for ssc in ss_controls:\n if ssc[\"step\"] == step:\n empty = False\n if controls[ssc[\"site\"]] is None:\n controls[ssc[\"site\"]] = ssc[\"contr\"]\n else:\n controls[ssc[\"site\"]] = \\\n controls[ssc[\"site\"]] @ ssc[\"contr\"]\n\n if empty:\n return None\n return deepcopy(controls)\n", "meta": {"hexsha": "0908b6d5fa5802504625cb06b453e384d38a50c7", "size": 10501, "ext": "py", "lang": "Python", "max_stars_repo_path": "oqupy/control.py", "max_stars_repo_name": "gefux/OQuPy", "max_stars_repo_head_hexsha": "764528fb6181ea62f8829a9e0a9e3faa2af71e1f", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 13, "max_stars_repo_stars_event_min_datetime": "2022-02-15T12:33:17.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T10:01:57.000Z", "max_issues_repo_path": "oqupy/control.py", "max_issues_repo_name": "gefux/OQuPy", "max_issues_repo_head_hexsha": "764528fb6181ea62f8829a9e0a9e3faa2af71e1f", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 11, "max_issues_repo_issues_event_min_datetime": "2022-02-16T07:35:46.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-24T18:22:12.000Z", "max_forks_repo_path": "oqupy/control.py", "max_forks_repo_name": "gefux/OQuPy", "max_forks_repo_head_hexsha": "764528fb6181ea62f8829a9e0a9e3faa2af71e1f", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2022-02-17T01:23:55.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-17T08:51:57.000Z", "avg_line_length": 33.6570512821, "max_line_length": 80, "alphanum_fraction": 0.5722312161, "include": true, "reason": "import numpy,from numpy", "num_tokens": 2292, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5660185351961015, "lm_q2_score": 0.334589441253186, "lm_q1q2_score": 0.1893838254302104}} {"text": "# pylint: skip-file\nimport os\nimport re\nimport sys\nimport warnings\n\nxla_flags = os.getenv(\"XLA_FLAGS\", \"\").lstrip(\"--\")\nxla_flags = re.sub(r\"xla_force_host_platform_device_count=.+\\s\", \"\", xla_flags).split()\nos.environ[\"XLA_FLAGS\"] = \" \".join([f\"--xla_force_host_platform_device_count={100}\"])\n\nimport aesara.tensor as at\nimport arviz as az\nimport jax\nimport numpy as np\nimport pandas as pd\n\nfrom aesara.compile import SharedVariable\nfrom aesara.graph.basic import Apply, Constant, clone, graph_inputs\nfrom aesara.graph.fg import FunctionGraph\nfrom aesara.graph.op import Op\nfrom aesara.graph.opt import MergeOptimizer\nfrom aesara.link.jax.dispatch import jax_funcify\nfrom aesara.tensor.type import TensorType\n\nfrom pymc3 import modelcontext\nfrom pymc3.aesaraf import compile_rv_inplace\n\nwarnings.warn(\"This module is experimental.\")\n\n\nclass NumPyroNUTS(Op):\n def __init__(\n self,\n inputs,\n outputs,\n target_accept=0.8,\n draws=1000,\n tune=1000,\n chains=4,\n seed=None,\n progress_bar=True,\n ):\n self.draws = draws\n self.tune = tune\n self.chains = chains\n self.target_accept = target_accept\n self.progress_bar = progress_bar\n self.seed = seed\n\n self.inputs, self.outputs = clone(inputs, outputs, copy_inputs=False)\n self.inputs_type = tuple(input.type for input in inputs)\n self.outputs_type = tuple(output.type for output in outputs)\n self.nin = len(inputs)\n self.nout = len(outputs)\n self.nshared = len([v for v in inputs if isinstance(v, SharedVariable)])\n self.samples_bcast = [self.chains == 1, self.draws == 1]\n\n self.fgraph = FunctionGraph(self.inputs, self.outputs, clone=False)\n MergeOptimizer().optimize(self.fgraph)\n\n super().__init__()\n\n def make_node(self, *inputs):\n\n # The samples for each variable\n outputs = [\n TensorType(v.dtype, self.samples_bcast + list(v.broadcastable))() for v in inputs\n ]\n\n # The leapfrog statistics\n outputs += [TensorType(\"int64\", self.samples_bcast)()]\n\n all_inputs = list(inputs)\n if self.nshared > 0:\n all_inputs += self.inputs[-self.nshared :]\n\n return Apply(self, all_inputs, outputs)\n\n def do_constant_folding(self, *args):\n return False\n\n def perform(self, node, inputs, outputs):\n raise NotImplementedError()\n\n\n@jax_funcify.register(NumPyroNUTS)\ndef jax_funcify_NumPyroNUTS(op, node, **kwargs):\n from numpyro.infer import MCMC, NUTS\n\n draws = op.draws\n tune = op.tune\n chains = op.chains\n target_accept = op.target_accept\n progress_bar = op.progress_bar\n seed = op.seed\n\n # Compile the \"inner\" log-likelihood function. This will have extra shared\n # variable inputs as the last arguments\n logp_fn = jax_funcify(op.fgraph, **kwargs)\n\n if isinstance(logp_fn, (list, tuple)):\n # This handles the new JAX backend, which always returns a tuple\n logp_fn = logp_fn[0]\n\n def _sample(*inputs):\n\n if op.nshared > 0:\n current_state = inputs[: -op.nshared]\n shared_inputs = tuple(op.fgraph.inputs[-op.nshared :])\n else:\n current_state = inputs\n shared_inputs = ()\n\n def log_fn_wrap(x):\n res = logp_fn(\n *(\n x\n # We manually obtain the shared values and added them\n # as arguments to our compiled \"inner\" function\n + tuple(\n v.get_value(borrow=True, return_internal_type=True) for v in shared_inputs\n )\n )\n )\n\n if isinstance(res, (list, tuple)):\n # This handles the new JAX backend, which always returns a tuple\n res = res[0]\n\n return -res\n\n nuts_kernel = NUTS(\n potential_fn=log_fn_wrap,\n target_accept_prob=target_accept,\n adapt_step_size=True,\n adapt_mass_matrix=True,\n dense_mass=False,\n )\n\n pmap_numpyro = MCMC(\n nuts_kernel,\n num_warmup=tune,\n num_samples=draws,\n num_chains=chains,\n postprocess_fn=None,\n chain_method=\"parallel\",\n progress_bar=progress_bar,\n )\n\n pmap_numpyro.run(seed, init_params=current_state, extra_fields=(\"num_steps\",))\n samples = pmap_numpyro.get_samples(group_by_chain=True)\n leapfrogs_taken = pmap_numpyro.get_extra_fields(group_by_chain=True)[\"num_steps\"]\n return tuple(samples) + (leapfrogs_taken,)\n\n return _sample\n\n\ndef sample_numpyro_nuts(\n draws=1000,\n tune=1000,\n chains=4,\n target_accept=0.8,\n random_seed=10,\n model=None,\n progress_bar=True,\n keep_untransformed=False,\n):\n model = modelcontext(model)\n\n seed = jax.random.PRNGKey(random_seed)\n\n rv_names = [rv.name for rv in model.value_vars]\n init_state = [model.initial_point[rv_name] for rv_name in rv_names]\n init_state_batched = jax.tree_map(lambda x: np.repeat(x[None, ...], chains, axis=0), init_state)\n init_state_batched_at = [at.as_tensor(v) for v in init_state_batched]\n\n nuts_inputs = sorted(\n (v for v in graph_inputs([model.logpt]) if not isinstance(v, Constant)),\n key=lambda x: isinstance(x, SharedVariable),\n )\n map_seed = jax.random.split(seed, chains)\n numpyro_samples = NumPyroNUTS(\n nuts_inputs,\n [model.logpt],\n target_accept=target_accept,\n draws=draws,\n tune=tune,\n chains=chains,\n seed=map_seed,\n progress_bar=progress_bar,\n )(*init_state_batched_at)\n\n # Un-transform the transformed variables in JAX\n sample_outputs = []\n for i, (value_var, rv_samples) in enumerate(zip(model.value_vars, numpyro_samples[:-1])):\n rv = model.values_to_rvs[value_var]\n transform = getattr(value_var.tag, \"transform\", None)\n if transform is not None:\n untrans_value_var = transform.backward(rv, rv_samples)\n untrans_value_var.name = rv.name\n sample_outputs.append(untrans_value_var)\n\n if keep_untransformed:\n rv_samples.name = value_var.name\n sample_outputs.append(rv_samples)\n else:\n rv_samples.name = rv.name\n sample_outputs.append(rv_samples)\n\n print(\"Compiling...\", file=sys.stdout)\n\n tic1 = pd.Timestamp.now()\n _sample = compile_rv_inplace(\n [],\n sample_outputs + [numpyro_samples[-1]],\n allow_input_downcast=True,\n on_unused_input=\"ignore\",\n accept_inplace=True,\n mode=\"JAX\",\n )\n tic2 = pd.Timestamp.now()\n\n print(\"Compilation time = \", tic2 - tic1, file=sys.stdout)\n\n print(\"Sampling...\", file=sys.stdout)\n\n *mcmc_samples, leapfrogs_taken = _sample()\n tic3 = pd.Timestamp.now()\n\n print(\"Sampling time = \", tic3 - tic2, file=sys.stdout)\n\n posterior = {k.name: v for k, v in zip(sample_outputs, mcmc_samples)}\n\n az_trace = az.from_dict(posterior=posterior)\n\n return az_trace\n", "meta": {"hexsha": "b4113ef2b0a2190b29fb92b96f527b0e86891582", "size": 7163, "ext": "py", "lang": "Python", "max_stars_repo_path": "pymc3/sampling_jax.py", "max_stars_repo_name": "helmutsimon/pymc3", "max_stars_repo_head_hexsha": "ea263f6caaf81960792eb664fc5494659524b451", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-12-30T00:43:47.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-30T00:43:47.000Z", "max_issues_repo_path": "pymc3/sampling_jax.py", "max_issues_repo_name": "helmutsimon/pymc3", "max_issues_repo_head_hexsha": "ea263f6caaf81960792eb664fc5494659524b451", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pymc3/sampling_jax.py", "max_forks_repo_name": "helmutsimon/pymc3", "max_forks_repo_head_hexsha": "ea263f6caaf81960792eb664fc5494659524b451", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.223628692, "max_line_length": 100, "alphanum_fraction": 0.6306017032, "include": true, "reason": "import numpy,from numpy,from pymc3,import jax", "num_tokens": 1694, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5660185351961015, "lm_q2_score": 0.33458943461801643, "lm_q1q2_score": 0.18938382167458143}} {"text": "from __future__ import annotations\nimport qimpy as qp\nimport numpy as np\nimport torch\nimport pathlib\nimport re\nfrom ._ions_projectors import _get_projectors\nfrom ._ions_atomic import get_atomic_orbitals, get_atomic_density\nfrom ._ions_update import update, _collect_ps_matrix\nfrom typing import Optional, Union, List\n\n\nclass Ions(qp.TreeNode):\n \"\"\"Ionic system: ionic geometry and pseudopotentials.\"\"\"\n\n __slots__ = (\n \"n_ions\",\n \"n_types\",\n \"symbols\",\n \"n_ions_type\",\n \"slices\",\n \"pseudopotentials\",\n \"positions\",\n \"types\",\n \"M_initial\",\n \"Z\",\n \"Z_tot\",\n \"rho_tilde\",\n \"Vloc_tilde\",\n \"n_core_tilde\",\n \"beta\",\n \"beta_full\",\n \"beta_version\",\n \"D_all\",\n )\n n_ions: int #: number of ions\n n_types: int #: number of distinct ion types\n n_ions_type: List[int] #: number of ions of each type\n symbols: List[str] #: symbol for each ion type\n slices: List[slice] #: slice to get each ion type\n pseudopotentials: List[qp.ions.Pseudopotential] #: pseudopotential for each type\n positions: torch.Tensor #: fractional positions of each ion (n_ions x 3)\n types: torch.Tensor #: type of each ion (n_ions, int)\n M_initial: Optional[torch.Tensor] #: initial magnetic moment for each ion\n Z: torch.Tensor #: charge of each ion type (n_types, float)\n Z_tot: float #: total ionic charge\n rho_tilde: qp.grid.FieldH #: ionic charge density (uses coulomb.ion_width)\n Vloc_tilde: qp.grid.FieldH #: local potential due to ions (including from rho)\n n_core_tilde: qp.grid.FieldH #: partial core electronic density (for XC)\n beta: qp.electrons.Wavefunction #: pseudopotential projectors (split-basis only)\n beta_full: Optional[qp.electrons.Wavefunction] #: full-basis version of `beta`\n beta_version: int #: version of `beta` to invalidate cached projections\n D_all: torch.Tensor #: nonlocal pseudopotential matrix (all atoms)\n\n _get_projectors = _get_projectors\n get_atomic_orbitals = get_atomic_orbitals\n get_atomic_density = get_atomic_density\n update = update\n _collect_ps_matrix = _collect_ps_matrix\n\n def __init__(\n self,\n *,\n process_grid: qp.utils.ProcessGrid,\n checkpoint_in: qp.utils.CpPath = qp.utils.CpPath(),\n coordinates: Optional[List] = None,\n pseudopotentials: Optional[Union[str, List[str]]] = None,\n ) -> None:\n \"\"\"Initialize geometry and pseudopotentials.\n\n Parameters\n ----------\n coordinates\n :yaml:`List of [symbol, x, y, z, args] for each ion in unit cell.`\n Here, symbol is the chemical symbol of the element,\n x, y and z are in the selected coordinate system.\n Optional args is a dictionary of additional per-ion\n parameters that may include:\n\n * `M`: initial magnetic moment for the ion, which would be a\n single Mz or [Mx, My, Mz] depending on if the calculation\n is spinorial. Only specify in spin-polarized calculations.\n * Relaxation constraints: TODO\n\n Ions of the same type (symbol) must be specified consecutively.\n pseudopotentials\n :yaml:`Pseudopotential filenames or filename templates.`\n Templates for families of pseudopotentials are specified by\n including a $ID in the name which is replaced by the chemical\n symbol of the element. The list of specified file names and\n templates is processed in order, and the first match for\n each element takes precedence.\n \"\"\"\n super().__init__()\n qp.log.info(\"\\n--- Initializing Ions ---\")\n\n # Read ionic coordinates:\n if coordinates is None:\n coordinates = []\n assert isinstance(coordinates, list)\n self.n_ions = 0 # number of ions\n self.n_types = 0 # number of distinct ion types\n self.symbols = [] # symbol for each ion type\n self.n_ions_type = [] # numebr of ions of each type\n self.slices = [] # slice to get each ion type\n positions = [] # position of each ion\n types = [] # type of each ion (index into symbols)\n M_initial = [] # initial magnetic moments\n type_start = 0\n for coord in coordinates:\n # Check for optional attributes:\n if len(coord) == 4:\n attrib = {}\n elif len(coord) == 5:\n attrib = coord[4]\n if not isinstance(attrib, dict):\n raise ValueError(\"ion attributes must be a dict\")\n else:\n raise ValueError(\"each ion must be 4 entries + optional dict\")\n # Add new symbol or append to existing:\n symbol = str(coord[0])\n if (not self.symbols) or (symbol != self.symbols[-1]):\n self.symbols.append(symbol)\n self.n_types += 1\n if type_start != self.n_ions:\n self.slices.append(slice(type_start, self.n_ions))\n self.n_ions_type.append(self.n_ions - type_start)\n type_start = self.n_ions\n # Add type and position of current ion:\n types.append(self.n_types - 1)\n positions.append([float(x) for x in coord[1:4]])\n M_initial.append(attrib.get(\"M\", None))\n self.n_ions += 1\n if type_start != self.n_ions:\n self.slices.append(slice(type_start, self.n_ions)) # for last type\n self.n_ions_type.append(self.n_ions - type_start)\n\n # Check order:\n if len(set(self.symbols)) < self.n_types:\n raise ValueError(\"coordinates must group ions of same type together\")\n\n # Convert to tensors before storing in class object:\n self.positions = torch.tensor(positions, device=qp.rc.device)\n self.types = torch.tensor(types, device=qp.rc.device, dtype=torch.long)\n # --- Fill in missing magnetizations (if any specified):\n M_lengths = set(\n [(len(M) if isinstance(M, list) else 1) for M in M_initial if M]\n )\n if len(M_lengths) > 1:\n raise ValueError(\"All M must be same type: 3-vector or scalar\")\n elif len(M_lengths) == 1:\n M_length = next(iter(M_lengths))\n assert (M_length == 1) or (M_length == 3)\n M_default = [0.0, 0.0, 0.0] if (M_length == 3) else 0.0\n self.M_initial = torch.tensor(\n [(M if M else M_default) for M in M_initial],\n device=qp.rc.device,\n dtype=torch.double,\n )\n else:\n self.M_initial = None\n self.report()\n\n # Initialize pseudopotentials:\n self.pseudopotentials = []\n if pseudopotentials is None:\n pseudopotentials = []\n if isinstance(pseudopotentials, str):\n pseudopotentials = [pseudopotentials]\n for i_type, symbol in enumerate(self.symbols):\n fname = None # full filename for this ion type\n symbol_variants = [symbol.lower(), symbol.upper(), symbol.capitalize()]\n # Check each filename provided in order:\n for ps_name in pseudopotentials:\n if ps_name.count(\"$ID\"):\n # wildcard syntax\n for symbol_variant in symbol_variants:\n fname_test = ps_name.replace(\"$ID\", symbol_variant)\n if pathlib.Path(fname_test).exists():\n fname = fname_test # found\n break\n else:\n # specific filename\n basename = pathlib.PurePath(ps_name).stem\n ps_symbol = re.split(r\"[_\\-\\.]+\", basename)[0]\n if ps_symbol in symbol_variants:\n fname = ps_name\n if not pathlib.Path(fname).exists():\n raise FileNotFoundError(fname)\n break\n if fname:\n break\n # Read pseudopotential file:\n if fname:\n self.pseudopotentials.append(qp.ions.Pseudopotential(fname))\n else:\n raise ValueError(f\"no pseudopotential found for {symbol}\")\n self.beta_version = 0\n\n # Calculate total ionic charge (needed for number of electrons):\n self.Z = torch.tensor(\n [ps.Z for ps in self.pseudopotentials], device=qp.rc.device\n )\n self.Z_tot = self.Z[self.types].sum().item()\n qp.log.info(f\"\\nTotal ion charge, Z_tot: {self.Z_tot:g}\")\n\n # Initialize / check replica process grid dimension:\n n_replicas = 1 # this will eventually change for NEB / phonon DFPT\n process_grid.provide_n_tasks(\"r\", n_replicas)\n\n def report(self) -> None:\n \"\"\"Report ionic positions and attributes\"\"\"\n qp.log.info(f\"{self.n_ions} total ions of {self.n_types} types;\" \" positions:\")\n # Fetch to CPU for reporting:\n positions = self.positions.to(qp.rc.cpu).numpy()\n types = self.types.to(qp.rc.cpu).numpy()\n M_initial = (\n None if (self.M_initial is None) else self.M_initial.to(qp.rc.cpu).numpy()\n )\n for i_ion, position in enumerate(positions):\n # Generate attribute string:\n attrib_str = \"\"\n attribs = {}\n if M_initial is not None:\n M_i = M_initial[i_ion]\n if np.linalg.norm(M_i):\n attribs[\"M\"] = M_i\n if attribs:\n attrib_str = \", \" + str(attribs).replace(\"'\", \"\").replace(\n \"array(\", \"\"\n ).replace(\")\", \"\")\n # Report:\n qp.log.info(\n f\"- [{self.symbols[types[i_ion]]}, {position[0]:11.8f},\"\n f\" {position[1]:11.8f}, {position[2]:11.8f}{attrib_str}]\"\n )\n\n def translation_phase(\n self, iG: torch.Tensor, atom_slice: slice = slice(None)\n ) -> torch.Tensor:\n \"\"\"Get translation phases at `iG` for a slice of atoms.\n The result has atoms as the final dimension; summing over that\n dimension yields the structure factor corresponding to these atoms.\n \"\"\"\n return qp.utils.cis((-2 * np.pi) * (iG @ self.positions[atom_slice].T))\n\n @property\n def n_projectors(self) -> int:\n \"\"\"Total number of pseudopotential projectors.\"\"\"\n return sum(\n (ps.n_projectors * self.n_ions_type[i_ps])\n for i_ps, ps in enumerate(self.pseudopotentials)\n )\n\n @property\n def n_orbital_projectors(self) -> int:\n \"\"\"Total number of projectors used to generate atomic orbitals.\"\"\"\n return sum(\n (ps.n_orbital_projectors * self.n_ions_type[i_ps])\n for i_ps, ps in enumerate(self.pseudopotentials)\n )\n\n def n_atomic_orbitals(self, n_spinor: int) -> int:\n \"\"\"Total number of atomic orbitals. This depends on the number\n of spinorial components `n_spinor`.\"\"\"\n return sum(\n (ps.n_atomic_orbitals(n_spinor) * self.n_ions_type[i_ps])\n for i_ps, ps in enumerate(self.pseudopotentials)\n )\n", "meta": {"hexsha": "48ac7d9f9f69e13bbf19502702c8a5e6c8b42a00", "size": 11333, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/qimpy/ions/_ions.py", "max_stars_repo_name": "shankar1729/qimpy", "max_stars_repo_head_hexsha": "5a4c1ea1fedc88909d426ce54101d6d07fa82e8c", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-05-25T00:11:50.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-30T21:49:00.000Z", "max_issues_repo_path": "src/qimpy/ions/_ions.py", "max_issues_repo_name": "shankar1729/qimpy", "max_issues_repo_head_hexsha": "5a4c1ea1fedc88909d426ce54101d6d07fa82e8c", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-09-28T19:18:38.000Z", "max_issues_repo_issues_event_max_datetime": "2021-11-23T13:23:17.000Z", "max_forks_repo_path": "src/qimpy/ions/_ions.py", "max_forks_repo_name": "shankar1729/qimpy", "max_forks_repo_head_hexsha": "5a4c1ea1fedc88909d426ce54101d6d07fa82e8c", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.9740740741, "max_line_length": 87, "alphanum_fraction": 0.5817524045, "include": true, "reason": "import numpy", "num_tokens": 2586, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5660185351961015, "lm_q2_score": 0.33458942798284697, "lm_q1q2_score": 0.1893838179189525}} {"text": "import os\nimport numpy as np\nfrom glob import iglob\nimport shutil\nimport os\nimport readline\nimport pprint\nimport sys\nfrom sys import argv\n#from NN_phasecorrection import check_phases\n\n'''This file should interpolate between a starting geometry taken from a QM.in file and an end-geometry (at which NNs broke down), also taken from a QM.in file_end\n - The files should be transfered into zmat-files and linear interpolation between the start- and end-geometry will be carried out\n - Later, the geometries will be written into the form of a QM.in file, the interface will then generate QM.out files - those will be written into an output.dat format and the output_all.dat can be appended later\n - In the end, the phases should be compared between geometries and corrected in the output.dat files. After the last geometry is corrected, the \n calculation using a QM-interface, should be carried out with corrected phases\n'''\n\n\n\n#============================================================================================================================================================#\n#======================================================================QM.out 2 output.dat===================================================================#\n#============================================================================================================================================================#\ndef qm2outputdat(Properties,outputdatfile):\n #in order to use the generated data, the important quantities for running NNs (Energy, SOC, Dipole, NAC) will be written into an output.dat format\n #therefore, the header of the output_all.dat file will be taken - every matrix (e.g. U matrix, property matrix) will be filled with zeros\n #iterate over QM.out files\n #TODO maybe change Overlap to True again - but right now although overlap and write_overlap is given, no overlaps are written by molpro\n OUTPUT['Overlap']=False\n file=open(\"output_new.dat\", 'w')\n nmstates = OUTPUT['nmstates']\n natoms = OUTPUT['natoms']\n string_output=header\n string_output+='! 0 Step\\n 0\\n'\n string_hamilton='! 1 Hamiltonian (MCH) in a.u.\\n'\n string_umatrix='! 2 U matrix\\n'\n string_dipole_x='! 3 Dipole moments X (MCH) in a.u.\\n'\n string_dipole_y='! 3 Dipole moments Y (MCH) in a.u.\\n'\n string_dipole_z='! 3 Dipole moments Z (MCH) in a.u.\\n'\n string_overlap=''\n string_coefficient='! 5 Coefficients (diag)\\n'\n string_hopping='! 6 Hopping Probabilities\\n'\n string_ekin='! 7 Ekin (a.u.)\\n0.000000000\\n'\n string_states='! 8 states (diag, MCH)\\n0.000000000 0.000000000\\n'\n string_random='! 9 Random number\\n0.000000000\\n'\n string_runtime='! 10 Runtime (sec)\\n0.000000000\\n'\n #this is done because the file has problems to do the last step - thus one step more is done and an empty file will be written and removed later\n #if index<= nsteps-1:\n string_geom='! 11 Geometry in a.u.\\n'\n string_velocities='! 12 Velocities in a.u.\\n'\n string_property2d=''\n string_property1d=''\n string_gradient=''\n string_nac=''\n\n #write string for geometires\n for atomnr in range(natoms):\n string_geom+='%20.12f %20.12f %20.12f\\n' %(Properties['Geometries'][atomnr][0],Properties['Geometries'][atomnr][1],Properties['Geometries'][atomnr][2])\n\n if OUTPUT['Overlap']==True:\n string_overlap+='! 4 Overlap matrix (MCH)\\n'\n for numberofstates in range(nmstates):\n for real_imag in range(nmstates*2):\n string_overlap+='0.000000000 '\n string_overlap+='\\n'\n\n for numberofstates in range(nmstates):\n string_coefficient+='0.0000000000 0.0000000000\\n'\n string_hopping+='0.000000000 0.000000000\\n'\n for real_imag in range(nmstates*2):\n #if phase correction applied: Properties should be replaced with phasecorrected properties. Hamiltonian --> Hamiltonian_phasecorrected \n if (2*numberofstates)==real_imag:\n string_hamilton+='%20.12f ' %(Properties['Hamiltonian'][numberofstates][real_imag]-OUTPUT['ezero'])\n else:\n string_hamilton+='%20.12f ' %(Properties['Hamiltonian'][numberofstates][real_imag])\n string_umatrix+='0.000000000 '\n string_dipole_x+='%20.12f ' %Properties['Dipole_x'][numberofstates][real_imag]\n string_dipole_y+='%20.12f ' %Properties['Dipole_y'][numberofstates][real_imag]\n string_dipole_z+='%20.12f ' %Properties['Dipole_z'][numberofstates][real_imag]\n string_umatrix+='\\n'\n string_hamilton+='\\n'\n string_dipole_x+='\\n'\n string_dipole_y+='\\n'\n string_dipole_z+='\\n'\n for numberofatoms in range(natoms):\n string_velocities+='0.000000000 0.000000000 0.000000000\\n'\n\n if OUTPUT['Gradient']==True:\n for numberofstates in range(nmstates):\n string_gradient+='! 15 Gradients (MCH) State %i\\n' %(int(numberofstates)+1)\n xyz=0\n for numberofatoms in range(natoms*3):\n xyz+=1\n string_gradient+='%20.12f ' %Properties['Gradient'][numberofstates][numberofatoms]\n if xyz>=3:\n xyz=0\n string_gradient+='\\n'\n\n if int(OUTPUT['Property2d'])==1:\n n_property2d=int(OUTPUT['n_property2d'])\n for number in range(n_property2d):\n string_property2d+='! 13 Property matrix (MCH) %i : N/A\\n' %(int(number)+1)\n for numberofstates in range(nmstates):\n for real_imag in range(nmstates*2):\n string_property2d+='0.000000000 '\n string_property2d+='\\n'\n\n if int(OUTPUT['Property1d'])==1:\n n_property1d=int(OUTPUT['n_property1d'])\n for number in range(n_property1d):\n string_property1d+='! 14 Property vector (MCH) %i : N/A\\n' %(int(number)+1)\n for numberofstates in range(nmstates):\n string_property1d+='0.000000000\\n'\n\n if OUTPUT['NACdr']==True:\n state=0\n firststate=1\n for nacindex in range(nmstates*nmstates):\n state+=1\n string_nac+='! 16 NACdr matrix element (MCH) %i %i\\n' %(firststate, state)\n if state >= nmstates:\n state=0\n firststate+=1\n xyz=0\n for numberofatoms_xyz in range(natoms*3):\n xyz+=1\n string_nac+='%20.12f ' %(Properties['NonAdiabaticCouplings'][nacindex][numberofatoms_xyz])\n if xyz>=3:\n xyz=0\n string_nac+='\\n'\n\n string_output+=string_hamilton+string_umatrix+string_dipole_x+string_dipole_y+string_dipole_z+string_overlap+string_coefficient+string_hopping+string_ekin+string_states+string_random+string_runtime+string_geom+string_velocities+string_property2d+string_property1d+string_gradient+string_nac\n file.write(string_output)\n file.close()\n\n return OUTPUT\n\n\"\"\"def generate_outputdat(scanpath, nsteps):\n #merge all output.dat files to one file called output.dat\n outputfile = open(scanpath+\"/output.dat\", \"w\")\n header_exists=False\n nsteps=int(nsteps)\n for index in range(1,nsteps):\n infile=open(scanpath+'/output'+str(index)+'.dat', 'r').readlines()\n is_header=True\n for line in infile:\n if not header_exists:\n outputfile.write(line)\n if 'End of header' in line:\n is_header=False\n header_exists=True\n continue\n if not is_header:\n outputfile.write(line)\n outputfile.close()\n for i in range(1,nsteps):\n os.system('rm %s/output%i.dat' %(scanpath,i))\"\"\"\n\n\n#=================================================================GET HEADER OF OUTPUT.DAT===================================================================#\ndef get_header(outputdatfile):\n\n OUTPUT={ 'Overlap': False,\n 'Gradient': False,\n 'NACdr': False,\n 'Property1d': 0,\n 'Property2d': 0,\n 'n_property1d': 1,\n 'n_property2d': 1}\n\n data=open(outputdatfile,'r').readlines()\n iline=-1\n header=''\n for line in data:\n iline+=1\n line_string=data[iline]\n line=line.strip()\n header+='%s' %line_string\n if line.startswith('nstates_m'):\n line = line.split()\n n_singlets=int(line[1])\n n_triplets=int(line[3])\n n_dubletts=int(line[2])\n nmstates=1*int(line[1])+2*int(line[2])+3*int(line[3])\n OUTPUT['nmstates']=int(nmstates)\n OUTPUT['n_singlets']=int(n_singlets)\n OUTPUT['n_triplets']=int(n_triplets)\n elif line.startswith('natom'):\n line = line.split()\n natoms=line[1]\n OUTPUT['natoms']=int(natoms)\n elif line.startswith('write_overlap'):\n line=line.split()\n if int(line[1])==1:\n OUTPUT['Overlap']=True\n elif line.startswith('write_grad'):\n line=line.split()\n if int(line[1])==1:\n OUTPUT['Gradient']=True\n elif line.startswith('write_nacdr'):\n line=line.split()\n if int(line[1])==1:\n OUTPUT['NACdr']=True\n elif line.startswith('write_property1d'):\n line=line.split()\n if int(line[1])==1:\n OUTPUT['Property1d']=1\n elif line.startswith('write_property2d'):\n line=line.split()\n if int(line[1])==1:\n OUTPUT['Property2d']=1\n elif line.startswith('n_property1d'):\n line = line.split()\n OUTPUT['n_property1d']=int(line[1])\n elif line.startswith('n_property2d'):\n line = line.split()\n OUTPUT['n_property2d']=int(line[1])\n elif line.startswith( 'ezero' ):\n line = line.split()\n ezero = float(line[1])\n OUTPUT['ezero']= ezero\n else:\n if 'End of header' in line:\n break\n else:\n continue\n\n return header, OUTPUT\n\n#==============================================================GET GEOMETRY FROM QM.in FILE===================================================================#\ndef get_geom(natoms,QMin,Properties):\n #get information of the geometry from the interpolated and aligned xyz-files\n data=open(QMin, 'r').readlines()\n iline=0\n \"\"\"string_geom='! 11 Geometry in a.u.\\n'\n for line in data:\n line.strip()\n iline+=1\n if iline==len(data):\n break\n if line.startswith('tmp.pdb'):\n for atom in range(natoms):\n iline+=1\n line = data[iline]\n line = line.split()\n string_geom+='%20.12f %20.12f %20.12f \\n' %(float(line[1]),float(line[2]),float(line[3]))\"\"\"\t\n Geometries=np.zeros((natoms,3))\n for line in data:\n line.strip()\n iline+=1\n if iline==len(data):\n break\n for atom in range(natoms):\n iline+=1\n line=data[iline]\n #print line\n line=line.split()\n #convert from Angstrom to Bohr\n Geometries[atom][0]=float(line[1])/0.529177\n Geometries[atom][1]=float(line[2])/0.529177\n Geometries[atom][2]=float(line[3])/0.529177\n break\n Properties['Geometries'] = Geometries\n return Properties\n\n\n\n#============================================================================================================================================================#\n#======================================================================PHASECORRECTION=======================================================================#\n#============================================================================================================================================================#\ndef phasecorrection(Properties,oldfilename,filename,newfilename,outputdatfile,inputfile,QMin):\n #corrects the phases of the Hamiltonian (SOCs), NACs and Dipole Moments (and additionally of Overlaps)\n header,OUTPUT=get_header(outputdatfile)\n nmstates=OUTPUT['nmstates']\n natoms = OUTPUT['natoms']\n n_singlets = OUTPUT['n_singlets']\n n_triplets = OUTPUT['n_triplets']\n #print(n_singlets,n_triplets)\n #if n_triplets==None:\n # n_triplets = int(0)\n Properties,data=read_QMout(Properties,nmstates,n_singlets,n_triplets,filename)\n #get ezero\n Properties=read_input(Properties,inputfile)\n #multiply the phasevector with the previous phasevector\n phasevector_old = Properties['phasevector_original']\n phasevector = Properties['phasevector']\n phasevector = phasevector_old*phasevector\n #print phasevector_old\n #print Properties['phasevector']\n #print phasevector\n Properties.update({'phasevector': phasevector})\n phasevector2=np.zeros((nmstates*2))\n #double each entry of the phasevector to make calculation of real and imaginary values easier\n for numberofstates in range(nmstates):\n phasevector2[numberofstates*2]=phasevector[numberofstates]\n phasevector2[numberofstates*2+1]=phasevector[numberofstates]\n\n #DO PHASECORRECTION\n QMout=open(newfilename, \"w\")\n iline=-1\n line_index=-1\n for line in data:\n line = line.strip()\n iline+=1\n line_index+=1\n if iline==len(data):\n break\n\n elif line.startswith('! 1 Hamiltonian Matrix'):\n #write the next two lines to file\n jline=line_index\n for i in range(2):\n line = data[jline]\n QMout.write(line)\n jline+=1\n #instead of writing the original Hamiltonian, do phasecorrection and write the new Hamiltonian \n Hamiltonian=Properties['Hamiltonian']\n #do calculation of rows with vector\n Hamiltonian_phasecorrected = Hamiltonian * phasevector2\n #do calculation of columns with vector by calculation of each row with the first entry of the vector\n for column in range(nmstates):\n for row_element in range(nmstates*2):\n Hamiltonian_phasecorrected[column][row_element]=Hamiltonian_phasecorrected[column][row_element]*phasevector[column]\n Properties.update({'Hamiltonian_phasecorrected': Hamiltonian_phasecorrected})\n #write the Hamiltonian to QM.out (next 8 lines)\n string_hamiltonian=''\n for hamilton in range(nmstates):\n for row_elements in range(nmstates*2):\n string_hamiltonian+='%20.12f '%Hamiltonian_phasecorrected[hamilton][row_elements]\n string_hamiltonian+='\\n'\n string_hamiltonian+='\\n'\n QMout.write(string_hamiltonian)\n #substract ezero from energy values of Hamiltonian for output.dat\n ezero = Properties['ezero']\n Hamiltonian_phasecorrected_ezero=Hamiltonian_phasecorrected\n for numberofstates in range(nmstates):\n for energyvalues in range(nmstates):\n if numberofstates == energyvalues:\n Hamiltonian_phasecorrected_ezero[numberofstates][energyvalues*2]=Hamiltonian_phasecorrected[numberofstates][energyvalues*2]-ezero\n Properties.update({'Hamiltonian_phasecorrected_ezero': Hamiltonian_phasecorrected_ezero})\n\n elif line.startswith('! 2 Dipole Moment'):\n #write the next line to the file\n jline = line_index\n line=data[jline]\n QMout.write(line)\n #do phasecorrection\n Dipole_x=Properties['Dipole_x']\n Dipole_y=Properties['Dipole_y']\n Dipole_z=Properties['Dipole_z']\n #\n Dipole_x_phasecorrected = []\n Dipole_y_phasecorrected = []\n Dipole_z_phasecorrected = []\n #\n Dipole_x_phasecorrected = Dipole_x * phasevector2\n Dipole_y_phasecorrected = Dipole_y * phasevector2\n Dipole_z_phasecorrected = Dipole_z * phasevector2\n #\n for column in range(nmstates):\n for row_element in range(nmstates*2):\n Dipole_x_phasecorrected[column][row_element]=Dipole_x_phasecorrected[column][row_element]*phasevector[column]\n Dipole_y_phasecorrected[column][row_element]=Dipole_y_phasecorrected[column][row_element]*phasevector[column]\n Dipole_z_phasecorrected[column][row_element]=Dipole_z_phasecorrected[column][row_element]*phasevector[column]\n #\n Properties.update({'Dipole_x_phasecorrected': Dipole_x_phasecorrected})\n Properties.update({'Dipole_y_phasecorrected': Dipole_y_phasecorrected})\n Properties.update({'Dipole_z_phasecorrected': Dipole_z_phasecorrected})\n #\n string_dipole=''\n jline+=1\n line=data[jline]\n string_dipole+='%s' %line\n for dipole in range(nmstates):\n for row_elements in range(nmstates*2):\n string_dipole+='%20.12f '%Dipole_x_phasecorrected[dipole][row_elements]\n string_dipole+='\\n'\n jline+=1\n jline+=1\n line = data[jline]\n string_dipole+='%s' %line\n for dipole in range(nmstates):\n for row_elements in range(nmstates*2):\n string_dipole+='%20.12f '%Dipole_y_phasecorrected[dipole][row_elements]\n string_dipole+='\\n'\n jline+=1\n jline+=1\n line = data[jline]\n string_dipole+='%s'%line\n for dipole in range(nmstates):\n for row_elements in range(nmstates*2):\n string_dipole+='%20.12f '%Dipole_z_phasecorrected[dipole][row_elements]\n string_dipole+='\\n'\n jline+=1\n #print string_dipole\n QMout.write(string_dipole)\n\n elif line.startswith('! 3 Gradient Vectors'):\n #only write lines - no phasecorrection for gradients\n #write the next lines containing gradient information to the file to the file\n jline = line_index\n for gradient_index in range((natoms+1)*nmstates+1):\n line=data[jline]\n QMout.write(line)\n jline+=1\n\n elif line.startswith('! 5 Non-adiabatic couplings'):\n #write first line to the QM.out file\n jline = line_index\n line = data[jline]\n QMout.write(line)\n\n #do phasecorrection\n NAC=Properties['NonAdiabaticCouplings']\n #the NAC matrix is saved as a matrix containing natoms*3 entries per line (so one line contains the nacs between a specific state and another specific one)\n #each line will be corrected with the phase - first, every line has to be corrected with the first entry of the phasecorrection vector, the second line with the second,...\n NAC_phasecorrected = np.zeros((nmstates*nmstates,natoms*3))\n\n #correct by multiplication with phasecorrection_vector line by line\n phasecorrection_index_line=0 \n for nacindex_line in range(nmstates*nmstates):\n for nac_state_line in range(natoms*3):\n NAC_phasecorrected[nacindex_line][nac_state_line] = NAC[nacindex_line][nac_state_line] * phasevector[phasecorrection_index_line]\n phasecorrection_index_line+=1\n if phasecorrection_index_line >= nmstates:\n phasecorrection_index_line=0\n\n #do phasecorrection column by column\n #this means, the first nmstates*line entries have to be multiplicated by the first entry of the phasecorrection vector\n phasecorrection_index_column=0\n iterator=0\n for nacindex_column in range(nmstates*nmstates):\n for nac_state_column in range(natoms*3):\n NAC_phasecorrected[nacindex_column][nac_state_column] = NAC_phasecorrected[nacindex_column][nac_state_column] * phasevector[phasecorrection_index_column]\n iterator+=1\n if iterator >= nmstates:\n iterator=0\n phasecorrection_index_column+=1\n Properties.update({'NAC_phasecorrected': NAC_phasecorrected})\n\n #make string for writing to QM.out file\n string_nac=''\n for nacstring in range(nmstates*nmstates):\n #contains information about the states of the NACs\n jline+=1\n line=data[jline]\n string_nac+='%s' %line\n jline+=natoms\n xyz_index=0\n for nacline in range(natoms*3):\n xyz_index+=1\n string_nac+='%20.12f ' %NAC_phasecorrected[nacstring][nacline]\n if xyz_index>=3:\n xyz_index=0\n string_nac+='\\n'\n QMout.write(string_nac)\n\n elif line.startswith('! 6 Overlap matrix'):\n #write the next 2 lines to the QM.out file\n jline = line_index\n for index in range(2):\n line = data[jline]\n QMout.write(line)\n jline+=1\n\n Overlap=Properties['Overlap']\n #get the old phasevector since the overlaps are mutiplied line by line with the current phasevector and column by column with the one of the previous timestep ()\n phasevector_old=Properties['phasevector_original']\n #first phasecorrection line by line\n Overlap_phasecorrected = Overlap * phasevector2\n #second phasecorrection column by column\n for lineindex in range(nmstates):\n for overlap_index in range(nmstates*2):\n Overlap_phasecorrected[lineindex][overlap_index] = Overlap_phasecorrected[lineindex][overlap_index] * phasevector_old[lineindex] \n #prepare String\n string_overlap=''\n for overlap in range(nmstates):\n for line_value in range(nmstates*2):\n string_overlap+='%20.12f ' %Overlap_phasecorrected[overlap][line_value]\n string_overlap+='\\n'\n string_overlap+='\\n'\n QMout.write(string_overlap)\n\n elif line.startswith('! 7 Phases'):\n #writes the phase vector\n jline = line_index\n for phasestring in range(2):\n line = data[jline]\n QMout.write(line)\n jline+=1\n string_phase=''\n for phases in range(nmstates):\n string_phase+='%20.12f 0.000000000\\n' %phasevector[phases]\n QMout.write(string_phase)\n\n else:\n pass\n\n QMout.close()\n\n Properties=get_geom(natoms,QMin,Properties)\n\n return Properties, OUTPUT\n\n\n#======================================================================READ QM.out===================================================================#\n#complementary to function \"check_phases\" from \"NN_phasecorrection.py\"\n\ndef read_QMinit_out(oldfilename,QMin,OUTPUT):\n Properties={}\n #get the phasevector\n readQMout=open(oldfilename,'r')\n data=readQMout.readlines()\n iline=-1\n for line in data:\n iline+=1\n line = line.strip()\n if iline==len(data):\n break\n line=data[1]\n t = line.split()\n nmstates=t[0]\n nmstates=int(nmstates)\n Properties['nmstates']=nmstates\n break\n iline = -1\n for line in data:\n iline += 1\n line = data[iline]\n line = line.strip()\n if iline == len(data):\n break\n elif line.startswith('! 7 Phases'):\n iline+=1\n line=data[iline]\n line=line.split()\n phasevector=np.zeros((nmstates))\n for numberofstates in range(nmstates):\n line = data[iline+1+numberofstates]\n line = line.split()\n #print line\n phasevector[numberofstates]=line[0]\n Properties['phasevector_original']=phasevector\n #print Properties['phasevector_original']\n break\n else:\n #set the phasevector to +1\n phasevector=np.ones((nmstates))\n Properties['phasevector_original']=phasevector\n Properties,data=read_QMout(Properties,nmstates,OUTPUT['n_singlets'], OUTPUT['n_triplets'],oldfilename)\n Properties=get_geom(OUTPUT['natoms'],QMin,Properties)\n return Properties\n\ndef read_QMout(Properties,nmstates,n_singlets,n_triplets,filename):\n #iterate over QM.out files\n Properties.update({'phasevector':\t\tFalse,\n\t\t\t 'Hamiltonian':\t\tFalse,\n\t\t\t 'Dipole_x': \t\tFalse,\n\t\t\t 'Dipole_y': \t\tFalse,\n\t\t\t 'Dipole_z': \t\tFalse,\n\t\t\t 'Gradient': \t\t\tFalse,\n\t\t\t 'NonAdibaticCouplings':\tFalse,\n\t\t\t 'Overlap':\t\t\tFalse})\n #start from 1 because the inital file does not have to be included \n readQMout=open(filename, \"r\")\n data=readQMout.readlines()\n readQMout.close()\n overlap_vector_correct=np.zeros((nmstates))\n threshold = float(0.5)\n iline=-1\n #print( n_singlets, n_triplets)\n for line in data:\n line=line.strip()\n iline+=1\n if line.startswith(\"! 6 Overlap matrix\" ):\n iline+=1\n #check phases of singlets only\n for overlaps_singlets in range(n_singlets):\n iline+=1\n line = data[iline]\n line = line.split()\n overlap_singlets = float(line[2*overlaps_singlets])\n #print( overlap)\n if abs(overlap_singlets) < threshold:\n for overlaps_stateswitch in range(n_singlets):\n overlap_switched_state = float(line[2*overlaps_stateswitch])\n #print (overlap_switched_state)\n if abs(overlap_switched_state) > threshold:\n #print(\"states switched\")\n overlap_singlets = overlap_switched_state\n if overlap_singlets < int(0):\n overlap_singlets = int(-1)\n else:\n overlap_singlets = int(1)\n else:\n if overlap_singlets < int(0):\n overlap_singlets = int(-1)\n else:\n overlap_singlets = int(1)\n overlap_vector_correct[overlaps_singlets]=overlap_singlets\n #check phases of triplets - do this three times since triplets are three times degenerated\n triplet_nmstate_0=int(0)\n triplet_nmstate_1=int(0)\n if n_triplets==0:\n pass\n else:\n for triplet_number in range(1):\n triplet_nmstate_0=triplet_nmstate_1\n triplet_nmstate_1=triplet_nmstate_0+1\n #print(triplet_magnetic, \"should start with 1\")\n for overlaps_triplets in range(n_singlets*triplet_nmstate_0,n_singlets+triplet_nmstate_1*n_triplets):\n iline+=1 \n line = data[iline]\n line = line.split()\n overlap_triplets = float(line[2*overlaps_triplets])\n if abs(overlap_triplets) < threshold:\n for overlaps_stateswitch_triplets in range(n_singlets*triplet_nmstate_0,n_singlets+triplet_nmstate_1*n_triplets):\n overlap_switched_state_triplet = float(line[2*overlaps_stateswitch_triplets])\n if abs(overlap_switched_state_triplet) > threshold:\n overlap_triplets = overlap_switched_state_triplet\n if overlap_triplets < int(0):\n overlap_triplets = int(-1)\n else:\n overlap_triplets = int(1)\n else:\n if overlap_triplets < int(0):\n overlap_triplets = int(-1)\n else:\n overlap_triplets = int(1)\n overlap_vector_correct[overlaps_triplets]=overlap_triplets\n #get number of states and write out vector with phases\n \"\"\"if line.startswith(\"! 7 Phases\"):\n phasevector=np.zeros((nmstates))\n for numberofstates in range(nmstates):\n line=data[iline+2+numberofstates]\n line=line.split()\n phasevector[numberofstates]=line[0]\t\n Properties['phasevector']=phasevector\n break\"\"\"\n iline=-1\n #print(overlap_vector_correct)\n Properties['phasevector']=overlap_vector_correct\n for line in data:\n line=line.strip()\n iline+=1\n if line.startswith('! 1 Hamiltonian Matrix'):\n Hamiltonian=np.zeros((nmstates,nmstates*2))\n for numberofstates in range(nmstates):\n line=data[iline+2+numberofstates]\n line=line.split()\n for real_imag in range(nmstates*2):\n Hamiltonian[numberofstates][real_imag]=line[real_imag]\n Properties['Hamiltonian']=Hamiltonian\n elif line.startswith('! 2 Dipole Moment Matrices'):\n Dipole_x=np.zeros((nmstates,nmstates*2))\n Dipole_y=np.zeros((nmstates,nmstates*2))\n Dipole_z=np.zeros((nmstates,nmstates*2))\n for numberofstates in range(nmstates):\n line_x=data[iline+2+numberofstates]\n line_x=line_x.split()\n line_y=data[iline+3+nmstates+numberofstates]\n line_y=line_y.split()\n line_z=data[iline+4+nmstates*2+numberofstates]\n line_z=line_z.split()\n for real_imag in range(nmstates*2): \n Dipole_x[numberofstates][real_imag]=line_x[real_imag]\n Dipole_y[numberofstates][real_imag]=line_y[real_imag]\n Dipole_z[numberofstates][real_imag]=line_z[real_imag]\n Properties['Dipole_x']=Dipole_x\n Properties['Dipole_y']=Dipole_y\n Properties['Dipole_z']=Dipole_z\n elif line.startswith('! 3 Gradient Vectors'):\n line=data[iline+1]\n line=line.split()\n natoms=int(line[0])\n Properties.update({'natoms': natoms})\n #writes the gradient tensor in form of a matrix - every natomsx(x,y,z) matrix is written as one vector\n Gradient=np.zeros((nmstates,natoms*3))\n index=0\n for numberofstates in range(nmstates):\n index+=1\n gradientindex=0\n for atom_index in range(natoms):\n index+=1\n line=data[iline+index]\n line=line.split()\n for xyz in range(3):\n Gradient[numberofstates][gradientindex]=line[xyz]\n gradientindex+=1\n Properties['Gradient']=Gradient\n elif line.startswith('! 5 Non-adiabatic couplings'):\n #the nacs will be written as a matrix with the size: (numberofstatesxnumberofstates)x(natoms*3(xyz))\n NAC=np.zeros((nmstates*nmstates,natoms*3))\n index=0\n for numberofstates in range(nmstates*nmstates):\n index+=1\n nacindex=0\n for atom_index in range(natoms):\n index+=1\n line=data[iline+index]\n line=line.split()\n for xyz in range(3):\n NAC[numberofstates][nacindex]=line[xyz]\n nacindex+=1\n Properties['NonAdiabaticCouplings']=NAC\n elif line.startswith('! 6 Overlap matrix'):\n overlap=np.zeros((nmstates,nmstates*2))\n for numberofstates in range(nmstates):\n line=data[iline+2+numberofstates]\n line=line.split()\n for real_imag in range(nmstates*2):\n overlap[numberofstates][real_imag]=line[real_imag]\n Properties['Overlap']=overlap\n\n return Properties, data\n\n\n\ndef read_input(Properties, inputfile):\n inputf=open(inputfile, 'r').readlines()\n for line in inputf:\n line=line.strip()\n if line.startswith( 'ezero' ):\n line = line.split()\n ezero = float(line[1])\n Properties.update({'ezero': ezero})\n return Properties\n\n\n\nif __name__ == \"__main__\":\n try:\n name,outputdatforheader, QMin = argv\n except ValueError:\n print( \"Usage: script \")\n exit()\n outputdatfile = argv[1]\n filename=str(\"QM.out\")\n inputfile=argv[2]\n header,OUTPUT=get_header(outputdatfile)\n Properties=read_QMinit_out(filename,QMin,OUTPUT)\n #Properties,OUTPUT=phasecorrection(Properties,filename,outputdatfile,inputfile)\n qm2outputdat(Properties,outputdatfile)\n", "meta": {"hexsha": "1ec3b605d8f8874737d51980730696b0c0a150c4", "size": 29526, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/scripts/QM2output.py", "max_stars_repo_name": "smausenberger/SchNarc", "max_stars_repo_head_hexsha": "727dedf300aa79c01217822c3a9a4f4ae96ede60", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7, "max_stars_repo_stars_event_min_datetime": "2020-05-07T19:45:17.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-13T22:22:18.000Z", "max_issues_repo_path": "src/scripts/QM2output.py", "max_issues_repo_name": "smausenberger/SchNarc", "max_issues_repo_head_hexsha": "727dedf300aa79c01217822c3a9a4f4ae96ede60", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-03-25T10:39:16.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-25T10:39:16.000Z", "max_forks_repo_path": "src/scripts/QM2output.py", "max_forks_repo_name": "smausenberger/SchNarc", "max_forks_repo_head_hexsha": "727dedf300aa79c01217822c3a9a4f4ae96ede60", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2020-08-13T19:57:06.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-25T10:37:04.000Z", "avg_line_length": 39.685483871, "max_line_length": 292, "alphanum_fraction": 0.6437377227, "include": true, "reason": "import numpy", "num_tokens": 7607, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5660185351961015, "lm_q2_score": 0.3345894279828469, "lm_q1q2_score": 0.18938381791895248}} {"text": "\"\"\"\nClass interface to the model calculator.\n\nCalling a model is somewhat non-trivial since the functions called depend\non the data type. For 1D data the *Iq* kernel needs to be called, for\n2D data the *Iqxy* kernel needs to be called, and for SESANS data the\n*Iq* kernel needs to be called followed by a Hankel transform. Before\nthe kernel is called an appropriate *q* calculation vector needs to be\nconstructed. This is not the simple *q* vector where you have measured\nthe data since the resolution calculation will require values beyond the\nrange of the measured data. After the calculation the resolution calculator\nmust be called to return the predicted value for each measured data point.\n\n:class:`DirectModel` is a callable object that takes *parameter=value*\nkeyword arguments and returns the appropriate theory values for the data.\n\n:class:`DataMixin` does the real work of interpreting the data and calling\nthe model calculator. This is used by :class:`DirectModel`, which uses\ndirect parameter values and by :class:`bumps_model.Experiment` which wraps\nthe parameter values in boxes so that the user can set fitting ranges, etc.\non the individual parameters and send the model to the Bumps optimizers.\n\"\"\"\nfrom __future__ import print_function\n\nimport numpy as np # type: ignore\n\n# TODO: fix sesans module\nfrom . import sesans # type: ignore\nfrom . import weights\nfrom . import resolution\nfrom . import resolution2d\nfrom .details import make_kernel_args, dispersion_mesh\n\ntry:\n from typing import Optional, Dict, Tuple\nexcept ImportError:\n pass\nelse:\n from .data import Data\n from .kernel import Kernel, KernelModel\n from .modelinfo import Parameter, ParameterSet\n\ndef call_kernel(calculator, pars, cutoff=0., mono=False):\n # type: (Kernel, ParameterSet, float, bool) -> np.ndarray\n \"\"\"\n Call *kernel* returned from *model.make_kernel* with parameters *pars*.\n\n *cutoff* is the limiting value for the product of dispersion weights used\n to perform the multidimensional dispersion calculation more quickly at a\n slight cost to accuracy. The default value of *cutoff=0* integrates over\n the entire dispersion cube. Using *cutoff=1e-5* can be 50% faster, but\n with an error of about 1%, which is usually less than the measurement\n uncertainty.\n\n *mono* is True if polydispersity should be set to none on all parameters.\n \"\"\"\n parameters = calculator.info.parameters\n if mono:\n active = lambda name: False\n elif calculator.dim == '1d':\n active = lambda name: name in parameters.pd_1d\n elif calculator.dim == '2d':\n active = lambda name: name in parameters.pd_2d\n else:\n active = lambda name: True\n\n #print(\"pars\",[p.id for p in parameters.call_parameters])\n vw_pairs = [(get_weights(p, pars) if active(p.name)\n else ([pars.get(p.name, p.default)], [1.0]))\n for p in parameters.call_parameters]\n\n call_details, values, is_magnetic = make_kernel_args(calculator, vw_pairs)\n #print(\"values:\", values)\n return calculator(call_details, values, cutoff, is_magnetic)\n\n\ndef call_ER(model_info, pars):\n # type: (ModelInfo, ParameterSet) -> float\n \"\"\"\n Call the model ER function using *values*.\n\n *model_info* is either *model.info* if you have a loaded model,\n or *kernel.info* if you have a model kernel prepared for evaluation.\n \"\"\"\n if model_info.ER is None:\n return 1.0\n elif not model_info.parameters.form_volume_parameters:\n # handle the case where ER is provided but model is not polydisperse\n return model_info.ER()\n else:\n value, weight = _vol_pars(model_info, pars)\n individual_radii = model_info.ER(*value)\n return np.sum(weight*individual_radii) / np.sum(weight)\n\n\ndef call_VR(model_info, pars):\n # type: (ModelInfo, ParameterSet) -> float\n \"\"\"\n Call the model VR function using *pars*.\n\n *model_info* is either *model.info* if you have a loaded model,\n or *kernel.info* if you have a model kernel prepared for evaluation.\n \"\"\"\n if model_info.VR is None:\n return 1.0\n elif not model_info.parameters.form_volume_parameters:\n # handle the case where ER is provided but model is not polydisperse\n return model_info.VR()\n else:\n value, weight = _vol_pars(model_info, pars)\n whole, part = model_info.VR(*value)\n return np.sum(weight*part)/np.sum(weight*whole)\n\n\ndef call_profile(model_info, **pars):\n # type: (ModelInfo, ...) -> Tuple[np.ndarray, np.ndarray, Tuple[str, str]]\n \"\"\"\n Returns the profile *x, y, (xlabel, ylabel)* representing the model.\n \"\"\"\n args = {}\n for p in model_info.parameters.kernel_parameters:\n if p.length > 1:\n value = np.array([pars.get(p.id+str(j), p.default)\n for j in range(1, p.length+1)])\n else:\n value = pars.get(p.id, p.default)\n args[p.id] = value\n x, y = model_info.profile(**args)\n return x, y, model_info.profile_axes\n\n\ndef get_weights(parameter, values):\n # type: (Parameter, Dict[str, float]) -> Tuple[np.ndarray, np.ndarray]\n \"\"\"\n Generate the distribution for parameter *name* given the parameter values\n in *pars*.\n\n Uses \"name\", \"name_pd\", \"name_pd_type\", \"name_pd_n\", \"name_pd_sigma\"\n from the *pars* dictionary for parameter value and parameter dispersion.\n \"\"\"\n value = float(values.get(parameter.name, parameter.default))\n relative = parameter.relative_pd\n limits = parameter.limits\n disperser = values.get(parameter.name+'_pd_type', 'gaussian')\n npts = values.get(parameter.name+'_pd_n', 0)\n width = values.get(parameter.name+'_pd', 0.0)\n nsigma = values.get(parameter.name+'_pd_nsigma', 3.0)\n if npts == 0 or width == 0:\n return [value], [1.0]\n value, weight = weights.get_weights(\n disperser, npts, width, nsigma, value, limits, relative)\n return value, weight / np.sum(weight)\n\n\ndef _vol_pars(model_info, pars):\n # type: (ModelInfo, ParameterSet) -> Tuple[np.ndarray, np.ndarray]\n vol_pars = [get_weights(p, pars)\n for p in model_info.parameters.call_parameters\n if p.type == 'volume']\n #import pylab; pylab.plot(vol_pars[0][0],vol_pars[0][1]); pylab.show()\n value, weight = dispersion_mesh(model_info, vol_pars)\n return value, weight\n\n\nclass DataMixin(object):\n \"\"\"\n DataMixin captures the common aspects of evaluating a SAS model for a\n particular data set, including calculating Iq and evaluating the\n resolution function. It is used in particular by :class:`DirectModel`,\n which evaluates a SAS model parameters as key word arguments to the\n calculator method, and by :class:`bumps_model.Experiment`, which wraps the\n model and data for use with the Bumps fitting engine. It is not\n currently used by :class:`sasview_model.SasviewModel` since this will\n require a number of changes to SasView before we can do it.\n\n :meth:`_interpret_data` initializes the data structures necessary\n to manage the calculations. This sets attributes in the child class\n such as *data_type* and *resolution*.\n\n :meth:`_calc_theory` evaluates the model at the given control values.\n\n :meth:`_set_data` sets the intensity data in the data object,\n possibly with random noise added. This is useful for simulating a\n dataset with the results from :meth:`_calc_theory`.\n \"\"\"\n def _interpret_data(self, data, model):\n # type: (Data, KernelModel) -> None\n # pylint: disable=attribute-defined-outside-init\n\n self._data = data\n self._model = model\n\n # interpret data\n if hasattr(data, 'isSesans') and data.isSesans:\n self.data_type = 'sesans'\n elif hasattr(data, 'qx_data'):\n self.data_type = 'Iqxy'\n elif getattr(data, 'oriented', False):\n self.data_type = 'Iq-oriented'\n else:\n self.data_type = 'Iq'\n\n if self.data_type == 'sesans':\n q = sesans.make_q(data.sample.zacceptance, data.Rmax)\n index = slice(None, None)\n res = None\n if data.y is not None:\n Iq, dIq = data.y, data.dy\n else:\n Iq, dIq = None, None\n #self._theory = np.zeros_like(q)\n q_vectors = [q]\n q_mono = sesans.make_all_q(data)\n elif self.data_type == 'Iqxy':\n #if not model.info.parameters.has_2d:\n # raise ValueError(\"not 2D without orientation or magnetic parameters\")\n q = np.sqrt(data.qx_data**2 + data.qy_data**2)\n qmin = getattr(data, 'qmin', 1e-16)\n qmax = getattr(data, 'qmax', np.inf)\n accuracy = getattr(data, 'accuracy', 'Low')\n index = ~data.mask & (q >= qmin) & (q <= qmax)\n if data.data is not None:\n index &= ~np.isnan(data.data)\n Iq = data.data[index]\n dIq = data.err_data[index]\n else:\n Iq, dIq = None, None\n res = resolution2d.Pinhole2D(data=data, index=index,\n nsigma=3.0, accuracy=accuracy)\n #self._theory = np.zeros_like(self.Iq)\n q_vectors = res.q_calc\n q_mono = []\n elif self.data_type == 'Iq':\n index = (data.x >= data.qmin) & (data.x <= data.qmax)\n if data.y is not None:\n index &= ~np.isnan(data.y)\n Iq = data.y[index]\n dIq = data.dy[index]\n else:\n Iq, dIq = None, None\n if getattr(data, 'dx', None) is not None:\n q, dq = data.x[index], data.dx[index]\n if (dq > 0).any():\n res = resolution.Pinhole1D(q, dq)\n else:\n res = resolution.Perfect1D(q)\n elif (getattr(data, 'dxl', None) is not None\n and getattr(data, 'dxw', None) is not None):\n res = resolution.Slit1D(data.x[index],\n qx_width=data.dxl[index],\n qy_width=data.dxw[index])\n else:\n res = resolution.Perfect1D(data.x[index])\n\n #self._theory = np.zeros_like(self.Iq)\n q_vectors = [res.q_calc]\n q_mono = []\n elif self.data_type == 'Iq-oriented':\n index = (data.x >= data.qmin) & (data.x <= data.qmax)\n if data.y is not None:\n index &= ~np.isnan(data.y)\n Iq = data.y[index]\n dIq = data.dy[index]\n else:\n Iq, dIq = None, None\n if (getattr(data, 'dxl', None) is None\n or getattr(data, 'dxw', None) is None):\n raise ValueError(\"oriented sample with 1D data needs slit resolution\")\n\n res = resolution2d.Slit2D(data.x[index],\n qx_width=data.dxw[index],\n qy_width=data.dxl[index])\n q_vectors = res.q_calc\n q_mono = []\n else:\n raise ValueError(\"Unknown data type\") # never gets here\n\n # Remember function inputs so we can delay loading the function and\n # so we can save/restore state\n self._kernel_inputs = q_vectors\n self._kernel_mono_inputs = q_mono\n self._kernel = None\n self.Iq, self.dIq, self.index = Iq, dIq, index\n self.resolution = res\n\n def _set_data(self, Iq, noise=None):\n # type: (np.ndarray, Optional[float]) -> None\n # pylint: disable=attribute-defined-outside-init\n if noise is not None:\n self.dIq = Iq*noise*0.01\n dy = self.dIq\n y = Iq + np.random.randn(*dy.shape) * dy\n self.Iq = y\n if self.data_type in ('Iq', 'Iq-oriented'):\n self._data.dy[self.index] = dy\n self._data.y[self.index] = y\n elif self.data_type == 'Iqxy':\n self._data.data[self.index] = y\n elif self.data_type == 'sesans':\n self._data.y[self.index] = y\n else:\n raise ValueError(\"Unknown model\")\n\n def _calc_theory(self, pars, cutoff=0.0):\n # type: (ParameterSet, float) -> np.ndarray\n if self._kernel is None:\n self._kernel = self._model.make_kernel(self._kernel_inputs)\n self._kernel_mono = (\n self._model.make_kernel(self._kernel_mono_inputs)\n if self._kernel_mono_inputs else None)\n\n Iq_calc = call_kernel(self._kernel, pars, cutoff=cutoff)\n # Storing the calculated Iq values so that they can be plotted.\n # Only applies to oriented USANS data for now.\n # TODO: extend plotting of calculate Iq to other measurement types\n # TODO: refactor so we don't store the result in the model\n self.Iq_calc = None\n if self.data_type == 'sesans':\n Iq_mono = (call_kernel(self._kernel_mono, pars, mono=True)\n if self._kernel_mono_inputs else None)\n result = sesans.transform(self._data,\n self._kernel_inputs[0], Iq_calc,\n self._kernel_mono_inputs, Iq_mono)\n else:\n result = self.resolution.apply(Iq_calc)\n if hasattr(self.resolution, 'nx'):\n self.Iq_calc = (\n self.resolution.qx_calc, self.resolution.qy_calc,\n np.reshape(Iq_calc, (self.resolution.ny, self.resolution.nx))\n )\n return result\n\n\nclass DirectModel(DataMixin):\n \"\"\"\n Create a calculator object for a model.\n\n *data* is 1D SAS, 2D SAS or SESANS data\n\n *model* is a model calculator return from :func:`generate.load_model`\n\n *cutoff* is the polydispersity weight cutoff.\n \"\"\"\n def __init__(self, data, model, cutoff=1e-5):\n # type: (Data, KernelModel, float) -> None\n self.model = model\n self.cutoff = cutoff\n # Note: _interpret_data defines the model attributes\n self._interpret_data(data, model)\n\n def __call__(self, **pars):\n # type: (**float) -> np.ndarray\n return self._calc_theory(pars, cutoff=self.cutoff)\n\n def simulate_data(self, noise=None, **pars):\n # type: (Optional[float], **float) -> None\n \"\"\"\n Generate simulated data for the model.\n \"\"\"\n Iq = self.__call__(**pars)\n self._set_data(Iq, noise=noise)\n\n def profile(self, **pars):\n # type: (**float) -> None\n \"\"\"\n Generate a plottable profile.\n \"\"\"\n return call_profile(self.model.info, **pars)\n\ndef main():\n # type: () -> None\n \"\"\"\n Program to evaluate a particular model at a set of q values.\n \"\"\"\n import sys\n from .data import empty_data1D, empty_data2D\n from .core import load_model_info, build_model\n\n if len(sys.argv) < 3:\n print(\"usage: python -m sasmodels.direct_model modelname (q|qx,qy) par=val ...\")\n sys.exit(1)\n model_name = sys.argv[1]\n call = sys.argv[2].upper()\n if call != \"ER_VR\":\n try:\n values = [float(v) for v in call.split(',')]\n except Exception:\n values = []\n if len(values) == 1:\n q, = values\n data = empty_data1D([q])\n elif len(values) == 2:\n qx, qy = values\n data = empty_data2D([qx], [qy])\n else:\n print(\"use q or qx,qy or ER or VR\")\n sys.exit(1)\n else:\n data = empty_data1D([0.001]) # Data not used in ER/VR\n\n model_info = load_model_info(model_name)\n model = build_model(model_info)\n calculator = DirectModel(data, model)\n pars = dict((k, (float(v) if not k.endswith(\"_pd_type\") else v))\n for pair in sys.argv[3:]\n for k, v in [pair.split('=')])\n if call == \"ER_VR\":\n ER = call_ER(model_info, pars)\n VR = call_VR(model_info, pars)\n print(ER, VR)\n else:\n Iq = calculator(**pars)\n print(Iq[0])\n\nif __name__ == \"__main__\":\n main()\n", "meta": {"hexsha": "386e852f93c55ade7ad9e6563bf61d2a49ca80b8", "size": 16155, "ext": "py", "lang": "Python", "max_stars_repo_path": "sasmodels/direct_model.py", "max_stars_repo_name": "jmborr/sasmodels", "max_stars_repo_head_hexsha": "bedb9b0fed4f3f4bc2bbfa5878de6f2b6fdfbcc9", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "sasmodels/direct_model.py", "max_issues_repo_name": "jmborr/sasmodels", "max_issues_repo_head_hexsha": "bedb9b0fed4f3f4bc2bbfa5878de6f2b6fdfbcc9", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "sasmodels/direct_model.py", "max_forks_repo_name": "jmborr/sasmodels", "max_forks_repo_head_hexsha": "bedb9b0fed4f3f4bc2bbfa5878de6f2b6fdfbcc9", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-04-28T14:21:17.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-28T14:21:17.000Z", "avg_line_length": 38.7410071942, "max_line_length": 88, "alphanum_fraction": 0.6060662334, "include": true, "reason": "import numpy", "num_tokens": 3909, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5964331462646255, "lm_q2_score": 0.31742626558767584, "lm_q1q2_score": 0.18932354629148812}} {"text": "# -*- coding: utf-8 -*-\n\n# This code is part of Qiskit.\n#\n# (C) Copyright IBM 2020.\n#\n# This code is licensed under the Apache License, Version 2.0. You may\n# obtain a copy of this license in the LICENSE.txt file in the root directory\n# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.\n#\n# Any modifications or derivative works of this code must retain this\n# copyright notice, and modified files need to carry a notice indicating\n# that they have been altered from the originals.\n\n\"\"\"Parametric waveforms module. These are pulses which are described by a specified\nparameterization.\n\nIf a backend supports parametric pulses, it will have the attribute\n`backend.configuration().parametric_pulses`, which is a list of supported pulse shapes, such as\n`['gaussian', 'gaussian_square', 'drag']`. A Pulse Schedule, using parametric pulses, which is\nassembled for a backend which supports those pulses, will result in a Qobj which is dramatically\nsmaller than one which uses Waveforms.\n\nThis module can easily be extended to describe more pulse shapes. The new class should:\n - have a descriptive name\n - be a well known and/or well described formula (include the formula in the class docstring)\n - take some parameters (at least `duration`) and validate them, if necessary\n - implement a `get_waveform` method which returns a corresponding Waveform in the\n case that it is assembled for a backend which does not support it.\n\nThe new pulse must then be registered by the assembler in\n`qiskit/qobj/converters/pulse_instruction.py:ParametricPulseShapes`\nby following the existing pattern:\n\n class ParametricPulseShapes(Enum):\n gaussian = pulse_lib.Gaussian\n ...\n new_supported_pulse_name = pulse_lib.YourPulseWaveformClass\n\"\"\"\nimport warnings\nfrom abc import abstractmethod\nfrom typing import Any, Callable, Dict, Optional\nimport math\nimport numpy as np\n\nfrom . import continuous\nfrom .discrete import gaussian, gaussian_square, drag, constant\nfrom .pulse import Pulse\nfrom .waveform import Waveform\nfrom ..exceptions import PulseError\n\n\nclass ParametricPulse(Pulse):\n \"\"\"The abstract superclass for parametric pulses.\"\"\"\n\n @abstractmethod\n def __init__(self, duration: int, name: Optional[str] = None):\n \"\"\"Create a parametric pulse and validate the input parameters.\n\n Args:\n duration: Pulse length in terms of the the sampling period `dt`.\n name: Display name for this pulse envelope.\n \"\"\"\n super().__init__(duration=duration, name=name)\n self.validate_parameters()\n\n @abstractmethod\n def get_waveform(self) -> Waveform:\n \"\"\"Return a Waveform with samples filled according to the formula that the pulse\n represents and the parameter values it contains.\n \"\"\"\n raise NotImplementedError\n\n def get_sample_pulse(self) -> Waveform:\n \"\"\"Deprecated.\"\"\"\n warnings.warn('`get_sample_pulse` has been deprecated. '\n ' Use `get_waveform` instead.', DeprecationWarning)\n return self.get_waveform()\n\n @abstractmethod\n def validate_parameters(self) -> None:\n \"\"\"\n Validate parameters.\n\n Raises:\n PulseError: If the parameters passed are not valid.\n \"\"\"\n raise NotImplementedError\n\n @property\n @abstractmethod\n def parameters(self) -> Dict[str, Any]:\n \"\"\"Return a dictionary containing the pulse's parameters.\"\"\"\n pass\n\n def draw(self, dt: float = 1,\n style=None,\n filename: Optional[str] = None,\n interp_method: Optional[Callable] = None,\n scale: float = 1, interactive: bool = False):\n \"\"\"Plot the pulse.\n\n Args:\n dt: Time interval of samples.\n style (Optional[PulseStyle]): A style sheet to configure plot appearance\n filename: Name required to save pulse image\n interp_method: A function for interpolation\n scale: Relative visual scaling of waveform amplitudes\n interactive: When set true show the circuit in a new window\n (this depends on the matplotlib backend being used supporting this)\n\n Returns:\n matplotlib.figure: A matplotlib figure object of the pulse envelope\n \"\"\"\n return self.get_waveform().draw(dt=dt, style=style, filename=filename,\n interp_method=interp_method, scale=scale,\n interactive=interactive)\n\n def __eq__(self, other: Pulse) -> bool:\n return super().__eq__(other) and self.parameters == other.parameters\n\n def __hash__(self) -> int:\n return hash(self.parameters[k] for k in sorted(self.parameters))\n\n\nclass Gaussian(ParametricPulse):\n \"\"\"A truncated pulse envelope shaped according to the Gaussian function whose mean is centered\n at the center of the pulse (duration / 2):\n\n .. math::\n\n f(x) = amp * exp( -(1/2) * (x - duration/2)^2 / sigma^2) ) , 0 <= x < duration\n \"\"\"\n\n def __init__(self,\n duration: int,\n amp: complex,\n sigma: float,\n name: Optional[str] = None):\n \"\"\"Initialize the gaussian pulse.\n\n Args:\n duration: Pulse length in terms of the the sampling period `dt`.\n amp: The amplitude of the Gaussian envelope.\n sigma: A measure of how wide or narrow the Gaussian peak is; described mathematically\n in the class docstring.\n name: Display name for this pulse envelope.\n \"\"\"\n self._amp = complex(amp)\n self._sigma = sigma\n super().__init__(duration=duration, name=name)\n\n @property\n def amp(self) -> complex:\n \"\"\"The Gaussian amplitude.\"\"\"\n return self._amp\n\n @property\n def sigma(self) -> float:\n \"\"\"The Gaussian standard deviation of the pulse width.\"\"\"\n return self._sigma\n\n def get_waveform(self) -> Waveform:\n return gaussian(duration=self.duration, amp=self.amp,\n sigma=self.sigma, zero_ends=False)\n\n def validate_parameters(self) -> None:\n if abs(self.amp) > 1.:\n raise PulseError(\"The amplitude norm must be <= 1, \"\n \"found: {}\".format(abs(self.amp)))\n if self.sigma <= 0:\n raise PulseError(\"Sigma must be greater than 0.\")\n\n @property\n def parameters(self) -> Dict[str, Any]:\n return {\"duration\": self.duration, \"amp\": self.amp, \"sigma\": self.sigma}\n\n def __repr__(self) -> str:\n return \"{}(duration={}, amp={}, sigma={}{})\" \\\n \"\".format(self.__class__.__name__, self.duration, self.amp, self.sigma,\n \", name='{}'\".format(self.name) if self.name is not None else \"\")\n\n\nclass GaussianSquare(ParametricPulse):\n \"\"\"A square pulse with a Gaussian shaped risefall on either side:\n\n .. math::\n\n risefall = (duration - width) / 2\n\n 0 <= x < risefall\n\n f(x) = amp * exp( -(1/2) * (x - risefall/2)^2 / sigma^2) )\n\n risefall <= x < risefall + width\n\n f(x) = amp\n\n risefall + width <= x < duration\n\n f(x) = amp * exp( -(1/2) * (x - (risefall + width)/2)^2 / sigma^2) )\n \"\"\"\n\n def __init__(self,\n duration: int,\n amp: complex,\n sigma: float,\n width: float,\n name: Optional[str] = None):\n \"\"\"Initialize the gaussian square pulse.\n\n Args:\n duration: Pulse length in terms of the the sampling period `dt`.\n amp: The amplitude of the Gaussian and of the square pulse.\n sigma: A measure of how wide or narrow the Gaussian risefall is; see the class\n docstring for more details.\n width: The duration of the embedded square pulse.\n name: Display name for this pulse envelope.\n \"\"\"\n self._amp = complex(amp)\n self._sigma = sigma\n self._width = width\n super().__init__(duration=duration, name=name)\n\n @property\n def amp(self) -> complex:\n \"\"\"The Gaussian amplitude.\"\"\"\n return self._amp\n\n @property\n def sigma(self) -> float:\n \"\"\"The Gaussian standard deviation of the pulse width.\"\"\"\n return self._sigma\n\n @property\n def width(self) -> float:\n \"\"\"The width of the square portion of the pulse.\"\"\"\n return self._width\n\n def get_waveform(self) -> Waveform:\n return gaussian_square(duration=self.duration, amp=self.amp,\n width=self.width, sigma=self.sigma,\n zero_ends=False)\n\n def validate_parameters(self) -> None:\n if abs(self.amp) > 1.:\n raise PulseError(\"The amplitude norm must be <= 1, \"\n \"found: {}\".format(abs(self.amp)))\n if self.sigma <= 0:\n raise PulseError(\"Sigma must be greater than 0.\")\n if self.width < 0 or self.width >= self.duration:\n raise PulseError(\"The pulse width must be at least 0 and less than its duration.\")\n\n @property\n def parameters(self) -> Dict[str, Any]:\n return {\"duration\": self.duration, \"amp\": self.amp, \"sigma\": self.sigma,\n \"width\": self.width}\n\n def __repr__(self) -> str:\n return \"{}(duration={}, amp={}, sigma={}, width={}{})\" \\\n \"\".format(self.__class__.__name__, self.duration, self.amp, self.sigma, self.width,\n \", name='{}'\".format(self.name) if self.name is not None else \"\")\n\n\nclass Drag(ParametricPulse):\n r\"\"\"The Derivative Removal by Adiabatic Gate (DRAG) pulse is a standard Gaussian pulse\n with an additional Gaussian derivative component. It is designed to reduce the frequency\n spectrum of a normal gaussian pulse near the :math:`|1\\rangle` - :math:`|2\\rangle` transition,\n reducing the chance of leakage to the :math:`|2\\rangle` state.\n\n .. math::\n\n f(x) = Gaussian + 1j * beta * d/dx [Gaussian]\n = Gaussian + 1j * beta * (-(x - duration/2) / sigma^2) [Gaussian]\n\n where 'Gaussian' is:\n\n .. math::\n\n Gaussian(x, amp, sigma) = amp * exp( -(1/2) * (x - duration/2)^2 / sigma^2) )\n\n References:\n 1. |citation1|_\n\n .. _citation1: https://link.aps.org/doi/10.1103/PhysRevA.83.012308\n\n .. |citation1| replace:: *Gambetta, J. M., Motzoi, F., Merkel, S. T. & Wilhelm, F. K.\n Analytic control methods for high-fidelity unitary operations\n in a weakly nonlinear oscillator. Phys. Rev. A 83, 012308 (2011).*\n\n 2. |citation2|_\n\n .. _citation2: https://link.aps.org/doi/10.1103/PhysRevLett.103.110501\n\n .. |citation2| replace:: *F. Motzoi, J. M. Gambetta, P. Rebentrost, and F. K. Wilhelm\n Phys. Rev. Lett. 103, 110501 – Published 8 September 2009.*\n \"\"\"\n\n def __init__(self,\n duration: int,\n amp: complex,\n sigma: float,\n beta: float,\n name: Optional[str] = None):\n \"\"\"Initialize the drag pulse.\n\n Args:\n duration: Pulse length in terms of the the sampling period `dt`.\n amp: The amplitude of the Drag envelope.\n sigma: A measure of how wide or narrow the Gaussian peak is; described mathematically\n in the class docstring.\n beta: The correction amplitude.\n name: Display name for this pulse envelope.\n \"\"\"\n self._amp = complex(amp)\n self._sigma = sigma\n self._beta = beta\n super().__init__(duration=duration, name=name)\n\n @property\n def amp(self) -> complex:\n \"\"\"The Gaussian amplitude.\"\"\"\n return self._amp\n\n @property\n def sigma(self) -> float:\n \"\"\"The Gaussian standard deviation of the pulse width.\"\"\"\n return self._sigma\n\n @property\n def beta(self) -> float:\n \"\"\"The weighing factor for the Gaussian derivative component of the waveform.\"\"\"\n return self._beta\n\n def get_waveform(self) -> Waveform:\n return drag(duration=self.duration, amp=self.amp, sigma=self.sigma,\n beta=self.beta, zero_ends=False)\n\n def validate_parameters(self) -> None:\n if abs(self.amp) > 1.:\n raise PulseError(\"The amplitude norm must be <= 1, \"\n \"found: {}\".format(abs(self.amp)))\n if self.sigma <= 0:\n raise PulseError(\"Sigma must be greater than 0.\")\n if isinstance(self.beta, complex):\n raise PulseError(\"Beta must be real.\")\n # Check if beta is too large: the amplitude norm must be <=1 for all points\n if self.beta > self.sigma:\n # If beta <= sigma, then the maximum amplitude is at duration / 2, which is\n # already constrainted by self.amp <= 1\n\n # 1. Find the first maxima associated with the beta * d/dx gaussian term\n # This eq is derived from solving for the roots of the norm of the drag function.\n # There is a second maxima mirrored around the center of the pulse with the same\n # norm as the first, so checking the value at the first x maxima is sufficient.\n argmax_x = (self.duration / 2\n - (self.sigma / self.beta) * math.sqrt(self.beta ** 2 - self.sigma ** 2))\n if argmax_x < 0:\n # If the max point is out of range, either end of the pulse will do\n argmax_x = 0\n\n # 2. Find the value at that maximum\n max_val = continuous.drag(np.array(argmax_x), sigma=self.sigma,\n beta=self.beta, amp=self.amp, center=self.duration / 2)\n if abs(max_val) > 1.:\n raise PulseError(\"Beta is too large; pulse amplitude norm exceeds 1.\")\n\n @property\n def parameters(self) -> Dict[str, Any]:\n return {\"duration\": self.duration, \"amp\": self.amp, \"sigma\": self.sigma,\n \"beta\": self.beta}\n\n def __repr__(self) -> str:\n return \"{}(duration={}, amp={}, sigma={}, beta={}{})\" \\\n \"\".format(self.__class__.__name__, self.duration, self.amp, self.sigma, self.beta,\n \", name='{}'\".format(self.name) if self.name is not None else \"\")\n\n\nclass Constant(ParametricPulse):\n \"\"\"\n A simple constant pulse, with an amplitude value and a duration:\n\n .. math::\n\n f(x) = amp , 0 <= x < duration\n f(x) = 0 , elsewhere\n \"\"\"\n\n def __init__(self,\n duration: int,\n amp: complex,\n name: Optional[str] = None):\n \"\"\"\n Initialize the constant-valued pulse.\n\n Args:\n duration: Pulse length in terms of the the sampling period `dt`.\n amp: The amplitude of the constant square pulse.\n name: Display name for this pulse envelope.\n \"\"\"\n self._amp = complex(amp)\n super().__init__(duration=duration, name=name)\n\n @property\n def amp(self) -> complex:\n \"\"\"The constant value amplitude.\"\"\"\n return self._amp\n\n def get_waveform(self) -> Waveform:\n return constant(duration=self.duration, amp=self.amp)\n\n def validate_parameters(self) -> None:\n if abs(self.amp) > 1.:\n raise PulseError(\"The amplitude norm must be <= 1, \"\n \"found: {}\".format(abs(self.amp)))\n\n @property\n def parameters(self) -> Dict[str, Any]:\n return {\"duration\": self.duration, \"amp\": self.amp}\n\n def __repr__(self) -> str:\n return \"{}(duration={}, amp={}{})\" \\\n \"\".format(self.__class__.__name__, self.duration, self.amp,\n \", name='{}'\".format(self.name) if self.name is not None else \"\")\n\n\nclass ConstantPulse(Constant):\n \"\"\"\n Deprecated. A simple constant pulse, with an amplitude value and a duration:\n\n .. math::\n\n f(x) = amp , 0 <= x < duration\n f(x) = 0 , elsewhere\n \"\"\"\n\n def __init__(self,\n duration: int,\n amp: complex,\n name: Optional[str] = None):\n \"\"\"\n Initialize the constant-valued pulse.\n\n Args:\n duration: Pulse length in terms of the the sampling period `dt`.\n amp: The amplitude of the constant square pulse.\n name: Display name for this pulse envelope.\n \"\"\"\n super(ConstantPulse, self).__init__(duration, amp, name)\n warnings.warn(\"The ConstantPulse is deprecated. Use Constant instead\", DeprecationWarning)\n", "meta": {"hexsha": "d9c9e136cb13dccef6417ae3fa420c6efe87dc50", "size": 16671, "ext": "py", "lang": "Python", "max_stars_repo_path": "qiskit/pulse/library/parametric_pulses.py", "max_stars_repo_name": "romainfd/qiskit-terra", "max_stars_repo_head_hexsha": "b5285ccc5cb1d17b7c73402833f2750b93652426", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "qiskit/pulse/library/parametric_pulses.py", "max_issues_repo_name": "romainfd/qiskit-terra", "max_issues_repo_head_hexsha": "b5285ccc5cb1d17b7c73402833f2750b93652426", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "qiskit/pulse/library/parametric_pulses.py", "max_forks_repo_name": "romainfd/qiskit-terra", "max_forks_repo_head_hexsha": "b5285ccc5cb1d17b7c73402833f2750b93652426", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.9645232816, "max_line_length": 98, "alphanum_fraction": 0.5969048048, "include": true, "reason": "import numpy", "num_tokens": 3779, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5428632831725052, "lm_q2_score": 0.3486451353339458, "lm_q1q2_score": 0.18926664282950822}} {"text": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\"\"\"\nTHOR detects differential peaks in multiple ChIP-seq profiles associated\nwith two distinct biological conditions.\n\nCopyright (C) 2014-2016 Manuel Allhoff (allhoff@aices.rwth-aachen.de)\n\nThis program is free software: you can redistribute it and/or modify\nit under the terms of the GNU General Public License as published by\nthe Free Software Foundation, either version 3 of the License, or\n(at your option) any later version.\n\nThis program is distributed in the hope that it will be useful,\nbut WITHOUT ANY WARRANTY; without even the implied warranty of\nMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\nGNU General Public License for more details.\n\nYou should have received a copy of the GNU General Public License\nalong with this program. If not, see .\n\n@author: Manuel Allhoff\n\"\"\"\n\nfrom __future__ import print_function\nimport string\nfrom hmmlearn.hmm import _BaseHMM\n\nimport sys\nfrom math import fabs\nfrom scipy.special import logsumexp\n\nimport numpy as np\nfrom .neg_bin import NegBin\n\nimport warnings\n\n\ndef _get_pvalue_distr(mu, alpha, tracker):\n \"\"\"Derive NB1 parameters for p-value calculation\"\"\"\n mu = mu[0,0]\n alpha = alpha[0,0] / 10000.\n tracker.write(text=str(mu), header=\"Neg. Bin. distribution for p-value estimates (mu)\")\n tracker.write(text=str(alpha), header=\"Neg. Bin. distribution for p-value estimates (alpha)\")\n \n nb = NegBin(mu, alpha)\n return {'distr_name': 'nb', 'distr': nb}\n\ndef get_init_parameters(s0, s1, s2, **info):\n \"\"\"For given training set (s0: Background, s1: Gaining, s2: loseing) get inital mu, alpha for NB1.\"\"\"\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\", category=RuntimeWarning)\n mu = np.matrix([np.mean(map(lambda x: x[i], s)) for i in range(2) for s in [s0, s1, s2]]).reshape(2, 3)\n var = np.matrix([np.var(map(lambda x: x[i], s)) for i in range(2) for s in [s0, s1, s2]]).reshape(2, 3)\n\n alpha = (var - mu) / np.square(mu)\n\n # alpha[np.isnan(alpha)] = 0.001\n\n alpha[alpha < 0] = 0.001\n\n for el in [mu, alpha]:\n high = min(el[0,1], el[1,2]) + 0.5 * fabs(el[0,1] - el[1,2])\n low = min(el[1,1], el[0,2]) + 0.5 * fabs(el[1,1] - el[0,2])\n med = np.mean([el[0,0], el[1,0]])\n el[0,1] = high\n el[1,2] = high\n el[1,1] = low\n el[0,2] = low\n el[0,0] = med\n el[1,0] = med\n\n return alpha, mu\n \nclass NegBinRepHMM(_BaseHMM):\n def __init__(self, alpha, mu, dim_cond_1, dim_cond_2, init_state_seq=None, n_components=3, covariance_type='diag',\n startprob_prior=1.0, transmat_prior=1.0, func=None,\n algorithm=\"viterbi\", means_prior=None, means_weight=0,\n covars_prior=1e-2, covars_weight=1,\n random_state=None, n_iter=30, thresh=1e-2,\n params=string.ascii_letters,\n init_params=string.ascii_letters):\n \n _BaseHMM.__init__(self, n_components,\n startprob_prior=startprob_prior,\n transmat_prior=transmat_prior, algorithm=algorithm,\n random_state=random_state, n_iter=n_iter,\n tol=thresh, params=params,\n init_params=init_params)\n \n self.dim = [dim_cond_1, dim_cond_2] #dimension of one emission\n self.n_features = 2 #sum(self.dim) #emission dimension\n self.alpha = alpha\n self.mu = mu\n self._update_distr(self.mu, self.alpha)\n self.func = func\n self.em_prob = 0\n \n \n def fit(self, obs, three_para):\n \"\"\"Estimate model parameters.\n\n An initialization step is performed before entering the EM\n algorithm. If you want to avoid this step, pass proper\n ``init_params`` keyword argument to estimator's constructor.\n\n Parameters\n ----------\n obs : list\n List of array-like observation sequences, each of which\n has shape (n_i, n_features), where n_i is the length of\n the i_th observation.\n\n Notes\n -----\n In general, `logprob` should be non-decreasing unless\n aggressive pruning is used. Decreasing `logprob` is generally\n a sign of overfitting (e.g. a covariance parameter getting too\n small). You can fix this by getting more training data,\n or strengthening the appropriate subclass-specific regularization\n parameter.\n \"\"\"\n\n # what does this mean??\n self._init(obs, self.init_params)\n\n logprob = []\n for i in range(self.n_iter):\n # Expectation step\n stats = self._initialize_sufficient_statistics()\n curr_logprob = 0\n for seq in obs:\n framelogprob = self._compute_log_likelihood(seq)\n lpr, fwdlattice = self._do_forward_pass(framelogprob)\n bwdlattice = self._do_backward_pass(framelogprob)\n gamma = fwdlattice + bwdlattice\n posteriors = np.exp(gamma.T - logsumexp(gamma, axis=1)).T\n curr_logprob += lpr\n self._accumulate_sufficient_statistics(\n stats, seq, framelogprob, posteriors, fwdlattice,\n bwdlattice)\n logprob.append(curr_logprob)\n\n # Check for convergence.\n if i > 0 and logprob[-1] - logprob[-2] < self.tol:\n break\n\n # Maximization step\n self._do_mstep(stats, three_para)\n #print(\"Logprob of all M-steps: %s\" %logprob, file=sys.stderr)\n self.em_prob = logprob[-1]\n return self\n \n def _update_distr(self, mu, alpha):\n \"\"\"Update distributions assigned to each state with new mu and alpha\"\"\"\n raw1 = [NegBin(mu[0, 0], alpha[0, 0]), NegBin(mu[0, 1], alpha[0, 1]), NegBin(mu[0, 2], alpha[0, 2])]\n raw2 = [NegBin(mu[1, 0], alpha[1, 0]), NegBin(mu[1, 1], alpha[1, 1]), NegBin(mu[1, 2], alpha[1, 2])]\n \n self.neg_distr = np.matrix([raw1, raw2]) #matrix of all Neg. Bin. Distributions, columns=HMM's state (3), row=#samples (2)\n \n def get_alpha(self, m):\n \"\"\"Return alpha for a given mu based on empirical variance\"\"\"\n var = self.func(m)\n try:\n return max((var - m) / m**2, 1e-300)\n except Warning:\n if m**2 > 1e-300:\n return max((var - m) / m**2, 1e-300)\n else:\n return 1e-300\n \n def _compute_log_likelihood(self, X):\n matrix = []\n lookup = {}\n for x in X: #over all observations\n row = []\n for i in range(self.n_components): #over number of HMM's state\n r_sum = 0\n for j in range(self.n_features): #over dim\n it = range(self.dim[0]) if j == 0 else range(self.dim[0], self.dim[0] + self.dim[1]) #grab proper ob\n for k in it:\n index = (int(x[k]), i, j)\n if lookup.has_key( index ):\n r_sum += lookup[index]\n else:\n y = float(self.neg_distr[j,i].logpdf(x[k]))\n lookup[index] = y\n r_sum += y\n row.append(r_sum)\n \n matrix.append(row)\n return np.asarray(matrix)\n \n \n def _generate_sample_from_state(self, state, random_state=None):\n output = []\n for i, d in enumerate(self.dim):\n for _ in range(d):\n output.append( self.neg_distr[i,state].rvs() )\n \n return np.array(output)\n \n def _initialize_sufficient_statistics(self):\n stats = super(NegBinRepHMM, self)._initialize_sufficient_statistics()\n stats['post'] = np.zeros([self.n_features, self.n_components])\n stats['post_emission'] = np.zeros([self.n_features, self.n_components]) #dim X states\n \n return stats\n \n def _help_accumulate_sufficient_statistics(self, obs, stats, posteriors):\n for t, symbol in enumerate(obs):\n stats['post'][0] += posteriors[t]\n stats['post'][1] += posteriors[t]\n \n pot_it = [range(self.dim[0]), range(self.dim[0], self.dim[0] + self.dim[1])] #consider both classes\n for j, it in enumerate(pot_it):\n for i in it:\n stats['post_emission'][j] += posteriors[t] * symbol[i]\n \n stats['post'][0] = stats['post'][0] * self.dim[0]\n stats['post'][1] = stats['post'][1] * self.dim[1]\n \n stats['posterior'] = np.copy(posteriors)\n \n def _valid_posteriors(self, posteriors, obs):\n \n warnings.filterwarnings('error')\n \n for i in range(len(obs)):\n state_1 = False\n c1, c2 = np.mean(obs[i][:self.dim[0]]), np.mean(obs[i][self.dim[0]:]) #counts of samples\n \n if posteriors[i][0] > 0.5: \n state_1 = True\n \n if c1 > c2: #state 1\n if fabs(posteriors[i][2] - 1) < 1e-200:\n posteriors[i] = np.array([1, 0, 0])\n else:\n if not state_1 and posteriors[i][2] > posteriors[i][1]:\n try: \n post_s2 = 0\n post_s0 = posteriors[i][0] / (posteriors[i][0] + posteriors[i][1])\n post_s1 = posteriors[i][1] / (posteriors[i][0] + posteriors[i][1])\n posteriors[i] = np.array([post_s0, post_s1, post_s2])\n except RuntimeWarning:\n print(posteriors[i], c1, c2, file=sys.stderr)\n \n if c2 > c1: #state 2\n if fabs(posteriors[i][1] - 1) < 1e-200:\n posteriors[i] = np.array([1, 0, 0])\n else:\n if not state_1 and posteriors[i][1] > posteriors[i][2]:\n try:\n post_s1 = 0\n post_s0 = posteriors[i][0] / (posteriors[i][0] + posteriors[i][2])\n post_s2 = posteriors[i][2] / (posteriors[i][0] + posteriors[i][2])\n posteriors[i] = np.array([post_s0, post_s1, post_s2])\n except RuntimeWarning:\n print(posteriors[i], c1, c2, file=sys.stderr)\n\n warnings.resetwarnings()\n\n return posteriors\n\n def _accumulate_sufficient_statistics(self, stats, obs, framelogprob,\n posteriors, fwdlattice, bwdlattice\n ):\n super(NegBinRepHMM, self)._accumulate_sufficient_statistics(\n stats, obs, framelogprob, posteriors, fwdlattice, bwdlattice,\n )\n posteriors = self._valid_posteriors(posteriors, obs)\n self._help_accumulate_sufficient_statistics(obs, stats, posteriors) \n \n def _do_mstep(self, stats, three_para):\n super(NegBinRepHMM, self)._do_mstep(stats)\n \n if three_para:\n self.mu[0,1] = (stats['post_emission'][0][1] + stats['post_emission'][1][2]) / (stats['post'][0][1] + stats['post'][1][2])\n self.mu[1,1] = (stats['post_emission'][1][1] + stats['post_emission'][0][2]) / (stats['post'][1][1] + stats['post'][0][2])\n self.mu[0,0] = (stats['post_emission'][0][0] + stats['post_emission'][1][0]) / (stats['post'][0][0] + stats['post'][1][0])\n \n self.mu[1,2] = self.mu[0,1]\n self.mu[0,2] = self.mu[1,1]\n self.mu[1,0] = self.mu[0,0]\n else:\n self.mu[0,1] = (stats['post_emission'][0][1] + stats['post_emission'][1][2]) / (stats['post'][0][1] + stats['post'][1][2])\n self.mu[1,1] = (stats['post_emission'][1][1] + stats['post_emission'][0][2] + stats['post_emission'][0][0] + stats['post_emission'][0][1]) / (stats['post'][1][1] + stats['post'][0][2] + stats['post'][0][0] + stats['post'][0][1])\n \n self.mu[0,0] = self.mu[1,1]\n self.mu[1,2] = self.mu[0,1]\n self.mu[0,2] = self.mu[1,1]\n self.mu[1,0] = self.mu[0,0]\n \n self.alpha = np.matrix([map(lambda m: self.get_alpha(m), np.asarray(self.mu[i])[0]) for i in range(self.n_features)])\n self._update_distr(self.mu, self.alpha)\n \n def merge_distr(self):\n f = self.count_s2 / float(self.count_s1 + self.count_s2) #TODO exp_data.\n \n for el in [self.mu, self.alpha]:\n high = min(el[0,1], el[1,2]) + f * fabs(el[0,1] - el[1,2])\n low = min(el[1,1], el[0,2]) + f * fabs(el[1,1] - el[0,2])\n med = np.mean([el[0,0], el[1,0]])\n el[0,1] = high\n el[1,2] = high\n el[1,1] = low\n el[0,2] = low\n el[0,0] = low #min(med, low)\n el[1,0] = low #min(med, low)\n \n self._update_distr(self.mu, self.alpha)\n\n \nif __name__ == '__main__':\n alpha = np.matrix([[0.2, 0.2, 0.2], [0.2, 0.2, 0.2]])\n mu = np.matrix([[15.,100.,10.], [10.,10.,100.]])\n f = lambda x: 0.4*x**2 + 1\n \n dim_cond_1 = 2\n dim_cond_2 = 3\n mean = [0, 0]\n cov = [[1, 0], [0, 100]]\n X= np.random.multivariate_normal(mean, cov, size=5)\n\n m2 = NegBinRepHMM(alpha = alpha, mu = np.matrix([[50.,130.,110.], [60.,100.,120.]]), dim_cond_1 = dim_cond_1, dim_cond_2 = dim_cond_2, func=f)\n m2.fit([X], three_para=False)\n \n posteriors = m2.predict_proba(X)\n e = m2.predict(X)\n for i, el in enumerate(X):\n print(el, e[i], sep='\\t', file=sys.stderr)\n #print(np.max(posteriors, axis=1))\n print(m2.mu)\n", "meta": {"hexsha": "c515c6d554bd01281d15c6a4ced444c5b830d20d", "size": 13809, "ext": "py", "lang": "Python", "max_stars_repo_path": "src/rgt/THOR/neg_bin_rep_hmm.py", "max_stars_repo_name": "mguo123/pan_omics", "max_stars_repo_head_hexsha": "e1cacd543635b398fb08c0b31d08fa6b7c389658", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/rgt/THOR/neg_bin_rep_hmm.py", "max_issues_repo_name": "mguo123/pan_omics", "max_issues_repo_head_hexsha": "e1cacd543635b398fb08c0b31d08fa6b7c389658", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/rgt/THOR/neg_bin_rep_hmm.py", "max_forks_repo_name": "mguo123/pan_omics", "max_forks_repo_head_hexsha": "e1cacd543635b398fb08c0b31d08fa6b7c389658", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.2208955224, "max_line_length": 240, "alphanum_fraction": 0.5448620465, "include": true, "reason": "import numpy,from scipy", "num_tokens": 3765, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5774953797290152, "lm_q2_score": 0.3276683008207139, "lm_q1q2_score": 0.18922692980761938}} {"text": "\"\"\"\nMotif discovery, incorporating position sensitivity and motif degeneracy.\nThe basic model is similar to the original BIRT: for a given (degenerate) motif,\nfind the window of positions that maximize the significance by the binomial test.\n\nHere, the degeneracy is modeled as one canonical k-mer, and some or all of the 3k+9\n\"neighboring\" k-mers that differ from it by just one base.\nThe intuition is that each substitution carries an increasing cost; being one mutation\nfrom consensus isn't as bad as being 3 or 4 mutations away from the consensus sequence.\n\nThis machinery is derived from my original \"Vermit\" implementation of the cERMIT algorithm,\nwhich focused on log-odds \"evidence\" for each gene, with the in-group/out-group version\nas a special case.\n\nHowever, in this code I'm using binomial distribution p-values, which come only from in-group/\nout-group count data (evidence = 0 or 1). So I kept the machinery, but the nominclature is\nnot what I would have done if I started with this approach!\n\"\"\"\nimport copy\nimport numpy as np\nfrom scipy import weave\n\nfrom pygr import util, dnaseq, rmath\n\ndef kmer_matches(kmer, suf, seq_offsets, midgap):\n \"\"\"\n locs 0-based start position of matches to `kmer` within the concatenated sequences.\n matches 0-based index of corresponding sequence for each entry in `locs`.\n midgap Number of bases between the first and second half of `kmer`\n \"\"\"\n # Caching speeds the single-processor algorithm by ~7%,\n # but eliminating it frees up a LOT of memory to allow multithreading.\n if midgap == 0:\n locs = suf.find_positions(kmer) # offsets from beginning of file\n matches = np.searchsorted(seq_offsets, locs) # sequence index for each match\n else:\n half = len(kmer) // 2\n locs_left = suf.find_positions(kmer[:half])\n locs_right = suf.find_positions(kmer[half:]) - (half+midgap)\n locs = np.intersect1d(locs_left, locs_right, assume_unique=True)\n matches = np.searchsorted(seq_offsets, locs)\n matches_right = np.searchsorted(seq_offsets, locs + (half+midgap))\n same_seq = (matches == matches_right) # only valid when two halves of the match are in the same sequence!\n locs = locs[same_seq]\n matches = matches[same_seq]\n return (locs, matches)\n\ndef kmers_matches(kmers, suf, seq_offsets, midgap):\n # Gather together all matches/locations for all kmers.\n # Sort them, first by sequence ID (implicitly), then by position within the sequence.\n matches = [] # [np.array], will be joined all at once\n locs = [] # [np.array], will be joined all at once\n for kmer in kmers:\n ls, ms = kmer_matches(kmer, suf, seq_offsets, midgap)\n matches.append(ms)\n locs.append(ls)\n matches = np.concatenate(matches)\n locs = np.concatenate(locs)\n # There cannot be any duplicates in locs (assuming all kmers are unique, which they should be)\n # because there is exactly one distinct kmer at each location in the original sequences.\n o = np.argsort(locs)\n return locs[o], matches[o]\n\ndef filelocs_to_seqlocs(locs, matches, seq_lens, seq_offsets, align_5p):\n \"\"\"\n Converts file-based kmer locations to sequence-based kmer locations.\n `locs` is altered *IN PLACE*, so there is no return value.\n \"\"\"\n max_seq_len = seq_lens.max() - 1 # b/c they're really seq. len. + 1 for the newline\n # seq_offsets[matches] - locs == distance from right edge, <= 0\n locs -= seq_offsets[matches]\n if align_5p:\n # sequences are left-justified and 0 is the leftmost base:\n locs += seq_lens[matches]\n locs -= 1 # b/c they're really seq. len. + 1 for the newline\n else:\n # sequences are right-justified and 0 is the leftmost base:\n #locs = max_seq_len - (seq_offsets[matches] - locs)\n locs += max_seq_len\n #if not (locs.max() < max_seq_len):\n # import pdb\n # pdb.set_trace()\n assert locs.max() < max_seq_len\n assert locs.min() >= 0\n return max_seq_len\n\nclass SeqBins(object):\n def __init__(self, fasta, evidence, ev_wts, n_bins=1):\n self.n_bins = n_bins\n if self.n_bins <= 1:\n self.bin_ids = np.array([0]*len(evidence))\n else:\n self.bin_ids = self._cluster(fasta, n_bins)\n # The genes are divided into n bins. Let Bi and Ti be the BG and target set genes, respectively,\n # in the ith bin, and denote by bi the subset of genes from Bi whose sequence contains a hit. The\n # goal of this score is to account for cases where the fraction of targets is uneven across bins.\n # Suppose that targets within each bin are selected uniformly. Then, in bin i the probability that\n # a selected gene will contain a hit (i.e., belong to bi) is |bi|/|Bi|. Since the fraction of\n # targets in bin i is |Ti|/|T|, it follows that the probability that a selected gene will contain\n # a hit is p_m = sum_over_i[ (Ti/T) * (bi/Bi) ]\n Bi = np.array([ev_wts[self.bin_ids == cid].sum() for cid in xrange(self.n_bins)]) # total genes in each bin\n Ti = np.array([evidence[self.bin_ids == cid].sum() for cid in xrange(self.n_bins)]) # in-group genes in each bin\n T = evidence.sum() # total in-group genes across all bins\n Bi[Bi == 0] == 1 # to avoid divide-by-zero errors when Ti == Bi == 0 (no genes in bin)\n self.multiplier = (Ti / T / Bi)[None,None,:] # to be multiplied by bi, which is called wt_table in improve_window\n def _get_features(self, seq):\n features = []\n features.append(len(seq))\n bases = util.make_bag(seq)\n L = float(max(1, len(seq)))\n features.extend([bases[b]/L for b in 'ACGT'])\n return features\n def _cluster(self, fasta, n_bins):\n print \"Clustering sequences by composition and length...\"\n # Compute numeric features for each sequence.\n features = [self._get_features(s) for i,n,s in fasta]\n # Normalize distances by dividing by std. deviation.\n features = np.array(features, np.float)\n stddev = np.apply_along_axis(np.std, 0, features)\n print \"S.d. of features:\", stddev\n features /= stddev\n # For now, we just run the clustering once, even though it may be sub-optimal\n clusters, cost = util.kmeans(features, n_bins, maxiter=10)\n return np.asarray(clusters)\n\ndef improve_window(kmers, bins, evidence, ev_wts, G, mu, suf, seq_lens, seq_offsets, options, mask=None):\n \"\"\"\n Evaluate the score for a set of k-mers, restricted to various possible sequence windows.\n Choose the window giving the highest Z score for these k-mers.\n\n kmers Iterable of 1+ k-mers to find the optimal cERMIT-score window for\n bins a SeqBins object defining how sequences are grouped into bins/clusters\n evidence NumPy array of log-odds or log-enrichment scores for each gene in the pool (floats)\n ev_wts NumPy array of weights on (0,1] for each piece of evidence, 1/(# gene models)\n G total \"number\" of genes, ev_wts.sum() [to avoid recomputing every time]\n mu average evidence, evidence.sum()/G [to avoid recomputing every time]\n suf the suffix array searcher object\n seq_lens length of each sequence in characters, including the newline separator\n seq_offsets position in the concatenated sequence file at which each sequence ends\n options command line options object\n mask Numpy array with length >= max location index; counts the number of times each bp is \"used\" in a motif.\n This is optional, for masking out kmers used in one motif so another motif can't claim them.\n If present, it will be updated to mask out the evidence used for these kmers.\n \n Raw evidence numbers should have been pre-multiplied by the provided weights (for efficiency).\n Scoring follows M.A.Newton et al, Annals of Applied Statistics 2007, 1:85-106\n rather than Georgiev et al. because the latter appears to have some typos in the formulae.\n Higher scores are better.\n \"\"\"\n # Hard to find a good word for the SeqBins, where sequences have been grouped/clustered/binned\n # by sequence composition (percent A/C/G/T). In this function \"bin\" is already used for\n # the sequence position windows (typically of ~25bp length).\n # Elsewhere in POWRS, there is some post-process \"clustering\" that already uses that name.\n # But within this function, I'll call the SeqBins \"clusters\" to distinguish them from\n # the positional bins.\n cluster_ids = bins.bin_ids # for access by Weave\n n_clust = bins.n_bins\n # Gather together all matches/locations for all kmers.\n # Sort them, first by sequence ID (implicitly), then by position within the sequence.\n # The algorithm below expects that locations occur in sorted order.\n #T = time.time()\n locs, matches = kmers_matches(kmers, suf, seq_offsets, options.midgap)\n # \"Masking\" to reduce the score of alternative motifs that closely match a previously evaluated motif.\n if mask is not None:\n motif_len = max(len(kmer) for kmer in kmers) # should all be the same length, but just in case...\n assert len(mask) >= locs[-1] + motif_len # locs are sorted, so -1 is max element\n loc_mask = np.zeros(locs.shape, dtype=np.int) # each pos. varies from 0 (totally free) to motif_len (totally masked)\n mask_limit = options.mask_limit\n weave.inline(r\"\"\"\n int n = Nlocs[0]; // see Numpy book; == locs.shape in Python\n int klen = motif_len;\n int maskmax = mask_limit;\n int ii, jj, kk, loc;\n for(ii = 0; ii < n; ii++) { // for each location...\n loc = locs[ii];\n for(jj = 0; jj < klen; jj++) {\n if(mask[loc+jj] >= maskmax) loc_mask[ii]++; // if it's already maxed out, we can't use it (maybe)\n else mask[loc+jj]++; // otherwise, note that we've used one count worth\n }\n }\n \"\"\", ['locs','mask','motif_len','loc_mask','mask_limit'])\n loc_mask = (loc_mask <= motif_len//2) # mask out locations that are more than half used by someone else\n locs = locs[loc_mask]\n matches = matches[loc_mask]\n # locs/matches could be empty, possibly due to masking\n if len(locs) == 0: return 0, 0, -util.Inf, 0\n # This sort of complicated indexing creates copies (unlike simple slices):\n # We need a copy (of locs, at least) because we're going to modify it in place, and it's cached. [not true anymore]\n assert locs.base == matches.base == None\n # convert file-based offsets into sequence-based offsets\n max_seq_len = filelocs_to_seqlocs(locs, matches, seq_lens, seq_offsets, options.align_5p) # locs altered in place!\n #print \"Finding %i matches: %f\" % (len(locs), time.time()-T); T = time.time()\n # Tally kmer locations in fixed-width bins, then build a table\n # of start,end windows showing the total (weighted) evidence\n # of genes with 1+ copies of the kmer located within that window.\n W = options.window_width\n max_W = max(1, max_seq_len // W) # in case W > max_seq_len, so we don't get a 0x0 table\n ev_table = np.zeros((max_W,max_W), dtype=np.float) # sum evidence for selected genes\n wt_table = np.zeros((max_W,max_W,n_clust), dtype=np.float) # \"number\" of selected genes, a.k.a. \"m\"\n locs //= W # convert base-pair locations into binned locations\n # now we'll subtract out evidence for genes that don't have a kmer in that window:\n ## This loop is by far the slowest part of this algorithm, so...\n #last_loc, last_seqid = None, None\n #for locbin, seqid in zip(locs, matches):\n # if seqid != last_seqid: # first kmer of a new sequence\n # ev_table += evidence[seqid]\n # wt_table += ev_wts[seqid]\n # if last_seqid is not None: # last kmer of the old sequence\n # ev_table[last_loc:max_W,last_loc:max_W] -= evidence[last_seqid]\n # wt_table[last_loc:max_W,last_loc:max_W] -= ev_wts[last_seqid]\n # ev_table[0:locbin,0:locbin] -= evidence[seqid]\n # wt_table[0:locbin,0:locbin] -= ev_wts[seqid]\n # last_seqid = seqid\n # else: # non-first kmer\n # ev_table[last_loc:locbin,last_loc:locbin] -= evidence[seqid]\n # wt_table[last_loc:locbin,last_loc:locbin] -= ev_wts[seqid]\n # # We add one so that only bins *between* kmers will be penalized,\n # # not bins *containing* kmers. In NumPy if start > end, it's just an empty array.\n # last_loc = locbin + 1\n #if last_seqid is not None: # last kmer of the last sequence\n # ev_table[last_loc:max_W,last_loc:max_W] -= evidence[last_seqid]\n # wt_table[last_loc:max_W,last_loc:max_W] -= ev_wts[last_seqid]\n ## After re-writing in C++, the time to actually find the k-mers dominates!\n weave.inline(r\"\"\"\n int maxw = max_W; // need this to avoid int/float ambiguity error\n int nclust = n_clust;\n int last_loc = -1, last_seqid = -1, last_clust = -1;\n int n = Nlocs[0]; // see Numpy book; == locs.shape in Python\n int locbin, seqid, clust;\n float evid, evwt, last_evid, last_evwt;\n int ii, jj, kk;\n for(ii = 0; ii < n; ii++) {\n locbin = locs[ii];\n seqid = matches[ii];\n clust = cluster_ids[seqid];\n evid = evidence[seqid];\n evwt = ev_wts[seqid];\n if(seqid != last_seqid) {\n // Only need to do the diagonal and above...\n // Finish up last sequence:\n if(last_seqid != -1) {\n for(jj = last_loc; jj < maxw; jj++) { for(kk = jj; kk < maxw; kk++) {\n ev_table[jj*maxw + kk] -= last_evid;\n wt_table[(jj*maxw + kk)*nclust + last_clust] -= last_evwt;\n }}\n }\n // Now start this new sequence:\n // Add in evidence everywhere (happens ONCE per SEQUENCE)\n for(jj = 0; jj < maxw; jj++) { for(kk = jj; kk < maxw; kk++) {\n ev_table[jj*maxw + kk] += evid;\n wt_table[(jj*maxw + kk)*nclust + clust] += evwt;\n }}\n // Remove evidence between left edge and this occurrence\n for(jj = 0; jj < locbin; jj++) { for(kk = jj; kk < locbin; kk++) {\n ev_table[jj*maxw + kk] -= evid;\n wt_table[(jj*maxw + kk)*nclust + clust] -= evwt;\n }}\n last_seqid = seqid;\n } else {\n // Continuation of previous sequence; evidence has already been added.\n // Just remove evidence between last occurrence and this occurrence.\n for(jj = last_loc; jj < locbin; jj++) { for(kk = jj; kk < locbin; kk++) {\n ev_table[jj*maxw + kk] -= evid;\n wt_table[(jj*maxw + kk)*nclust + clust] -= evwt;\n }}\n }\n last_loc = locbin + 1;\n last_clust = clust;\n last_evid = evid;\n last_evwt = evwt;\n }\n if(last_seqid != -1) {\n clust = cluster_ids[last_seqid];\n evid = evidence[last_seqid];\n evwt = ev_wts[last_seqid];\n for(jj = last_loc; jj < maxw; jj++) { for(kk = jj; kk < maxw; kk++) {\n ev_table[jj*maxw + kk] -= evid;\n wt_table[(jj*maxw + kk)*nclust + clust] -= evwt;\n }}\n }\n \"\"\", ['locs', 'matches', 'cluster_ids', 'evidence', 'ev_wts', 'max_W', 'n_clust', 'ev_table', 'wt_table'])\n #print \"For loop over %i matches: %f\" % (len(locs), time.time()-T); T = time.time()\n # Instead of the cERMIT Z-score, we can compute the binomial p-value (using in-group/out-group evidence only):\n # Trying to use non-integer valued floats in pbinom() produces NaNs\n score_table = np.around(ev_table)\n prob_table = (wt_table * bins.multiplier).sum(axis=2) # probability weighted by bin membership\n wt_table = wt_table.sum(axis=2) # condense clusters, for normal use by later code\n wt_table = np.around(wt_table)\n # This code used to compute pbinom(Ak, Nk, A/N)\n # In Amadeus and historically (tally_all), we use pbinom(Ak, A, Nk/N) instead.\n # It would be easy to use either one here, really, without changing much (see commented-out lines below).\n # P-values are quite similar, although pbinom(Ak, A, Nk/N) seems to be a little stronger in each case.\n # I'm not sure which one is better justified statistically, but top hits are nearly identical empirically.\n # We use the Amadeus version now so that we can use their binned enrichment correction.\n weave.inline(r\"\"\"\n int maxw = max_W; // need this to avoid int/float ambiguity error\n int ii, jj, kk;\n double prob = mu;\n double N = G;\n double A = (int)(prob * N);\n for(jj = 0; jj < maxw; jj++) { for(kk = jj; kk < maxw; kk++) {\n ii = jj*maxw + kk; // linear index into score_table / wt_table\n // pbinom(Ak, Nk, A/N):\n //score_table[ii] = -0.4342945 * pbinom(score_table[ii]-1, wt_table[ii], prob, 0, 1); // -log_10(P): bigger is better\n // pbinom(Ak, A, Nk/N):\n score_table[ii] = -0.4342945 * pbinom(score_table[ii]-1, A, prob_table[ii], 0, 1); // -log_10(P): bigger is better\n }}\n \"\"\", ['mu', 'max_W', 'score_table', 'prob_table', 'G'],\n **rmath.weave_inline_kwargs)\n # Disqualify bins with too few / too many hits:\n min_genes = options.min_genes\n max_genes = options.max_genes_frac * G\n score_table[wt_table < min_genes] = -util.Inf\n score_table[wt_table > max_genes] = -util.Inf\n # Almost there. Find the highest scoring, longest, rightmost window in which start <= end.\n # (Start and end are both inclusive when we read them out from the evidence table).\n olderr = np.seterr(all='ignore') # I think triu() is implemented with a multiplication...\n score_table = np.triu(score_table, k=0) # zero out everything below the diagonal (ensures start <= end) (except NaNs!)\n np.seterr(**olderr)\n max_Z = np.nanmax(score_table)\n # This was caused originally by non-integer weightings on genes -- leaving it here just in case.\n if np.isnan(max_Z):\n print \"Failed with %i locs for %i kmers with -- %s\" % (len(locs), len(kmers), kmers)\n return 0, 0, -util.Inf, 0\n peaks = [(end-start, end, start) for start, end in zip(*np.nonzero(score_table == max_Z))]\n peaks.sort(reverse=True)\n first_bin, last_bin = peaks[0][2], peaks[0][1]\n #score_table[~np.isfinite(score_table)] = 0 # to make plotting nicer\n #print \"Post processing: %f\" % (time.time()-T); T = time.time()\n # Return [inclusive, exclusive) base pair indices starting from 0 == left edge\n return first_bin*W, (last_bin+1)*W, max_Z, ev_table[first_bin,last_bin]\n\nclass Motif(object):\n def __init__(self, kmer, both_strands, data, parent=None):\n \"\"\"\n `data` is a dictionary containing the following keys:\n evidence NumPy array of 1's and 0's marking in-group and out-group, respectively (floats)\n ev_wts NumPy array of weights on (0,1] for each piece of evidence, 1/(# gene models)\n G total \"number\" of genes, ev_wts.sum() [to avoid recomputing every time]\n mu average evidence, evidence.sum()/G [to avoid recomputing every time]\n suf the suffix array searcher object\n seq_lens length of each sequence in characters, including the newline separator\n seq_offsets position in the concatenated sequence file at which each sequence ends\n options command line options object\n \"\"\"\n if parent:\n self.center = parent.center # the central kmer\n self.friends = parent.friends | set([kmer]) # other included neighboring kmers\n self.other_nbrs = parent.other_nbrs - set([kmer]) # neighboring kmers not yet included\n else:\n self.center = kmer\n self.friends = set()\n self.other_nbrs = generate_neighbors(kmer)\n self.both_strands = both_strands\n # Don't want to save whole data object or pickled Motifs will be huge...\n self.options_length = data['options'].length\n self._pattern = None\n # Scoring\n self.all_kmers = set([self.center]) | self.friends\n if self.both_strands: self.all_kmers |= set(dnaseq.reverse_complement(m) for m in self.all_kmers)\n self.start, self.end, self.score, self.evidence = improve_window(kmers=self.all_kmers, **data)\n # Using center_score means that the preferred strand version will sort to the top at the end!\n if parent: self.center_score = parent.center_score\n else: self.center_score = self.score\n # When sorting, prefer both-strands version when scores are equal (e.g. palindromic k-mers)\n self.sortkey = (self.score, self.both_strands, self.center_score, self.end, self.start, self.pattern)\n @property\n def start_user(self): return self.start - self.options_length\n @property\n def end_user(self): return self.end - self.options_length\n def __hash__(self): # Motifs are uniquely identified by their string pattern, but may get different scores due to re-scoring\n return hash(self.sortkey)\n def __cmp__(self, other):\n return cmp(self.sortkey, other.sortkey)\n def __str__(self):\n return self.as_str()\n def as_str(self, shift=0, max_shift=0):\n s1 = \" \"*shift\n s2 = \" \"*(max_shift - shift)\n if self.both_strands: rc_seed = dnaseq.reverse_complement(self.center)\n else: rc_seed = \"-\" * len(self.center)\n return \"%8.2f [%6.1f] %s%s%s / %s%s%s %6i %6i %50s\" % (\n self.score, self.evidence,\n s1, self.center, s2, s2, rc_seed, s1, self.start_user, self.end_user, self.pattern)\n @property\n def revcomp(self):\n \"\"\"Returns the reverse complement of this motif (or None if not on both strands).\"\"\"\n if not self.both_strands: return None\n elif self.center == dnaseq.reverse_complement(self.center): return self # palindrome\n elif not hasattr(self, \"_revcomp\"):\n rc = self._revcomp = copy.copy(self)\n rc.center = dnaseq.reverse_complement(self.center)\n rc.friends = set(dnaseq.reverse_complement(f) for f in self.friends)\n rc.other_nbrs = set(dnaseq.reverse_complement(o) for o in self.other_nbrs)\n rc._pattern = None\n rc.sortkey = (rc.score, rc.both_strands, rc.center_score, rc.end, rc.start, rc.pattern)\n return self._revcomp\n @property\n def pattern(self):\n if self._pattern is None:\n self._pattern = \"\"\n for pos, base in enumerate(self.center):\n alts = set(f[pos] for f in self.friends)\n alts.discard(base)\n if not alts:\n self._pattern += base\n else:\n self._pattern += \"[\" + base + \"\".join(sorted(a.lower() for a in alts)) + \"]\"\n return self._pattern\n\ndef generate_neighbors(kmer):\n nbrs = set()\n for pos, base in enumerate(kmer):\n for alt in \"ACGT\":\n if alt != base:\n assert base != \"N\"\n nbrs.add(kmer[:pos] + alt + kmer[pos+1:])\n return nbrs\n\nclass Cluster(object):\n \"\"\"A group of similar Motif objects.\"\"\"\n def __init__(self, motif, data):\n self.motifs = [motif]\n self.lost_motifs = [] # used only in reverse complement operations...\n self.offsets = [0]\n self.all_kmers = motif.all_kmers\n self.start = motif.start\n self.end = motif.end\n self.score = motif.score\n self.evidence = motif.evidence\n # Need to keep `data` for merge scoring and revcomp scoring,\n # but it could make pickles holding Clusters quite large...\n self.data = data\n @property\n def start_user(self): return self.start - self.data['options'].length\n @property\n def end_user(self): return self.end - self.data['options'].length\n def try_merge(self, other):\n \"\"\"Returns either a new Cluster or None.\"\"\"\n if not overlaps(self, other): return None\n kmers_linked = False\n # First try exact alignment\n for m1, o1 in zip(self.motifs, self.offsets):\n if kmers_linked: break\n for m2, o2 in zip(other.motifs, other.offsets):\n # `or` is too permissive; `and` is better\n if m1.center in m2.friends and m2.center in m1.friends:\n kmers_linked = True\n offset = (o1 - o2)\n break\n # Second try shifted left and shifted right\n # Most conservative version: seeds overlap by N-1 bases\n # Overlapping seeds with variants turns out to be too permissive.\n for m1, o1 in zip(self.motifs, self.offsets):\n if kmers_linked: break\n for m2, o2 in zip(other.motifs, other.offsets):\n if m1.center[1:] == m2.center[:-1]:\n kmers_linked = True\n offset = (o1 - o2) + 1\n break\n elif m2.center[1:] == m1.center[:-1]:\n kmers_linked = True\n offset = (o1 - o2) - 1\n break\n if not kmers_linked: return None\n new = copy.copy(self)\n new.motifs = self.motifs + other.motifs\n new.offsets = self.offsets + [o+offset for o in other.offsets]\n offset = min(new.offsets)\n new.offsets = [o-offset for o in new.offsets] # set min offset to 0\n new.all_kmers = self.all_kmers | other.all_kmers\n new.start, new.end, new.score, new.evidence = improve_window(kmers=new.all_kmers, **new.data)\n if new.score > max(self.score, other.score) and overlaps(self, new) and overlaps(other, new):\n return new\n else: return None\n @property\n def revcomp(self):\n if not hasattr(self, \"_revcomp\"):\n # Motifs that are single stranded will return None.\n # If all our motifs are single stranded, we'll return None also.\n rc = self._revcomp = copy.copy(self)\n rc.motifs = []\n rc.lost_motifs = [] # single stranded motifs that can't be used in the revcomp\n rc.offsets = []\n rc.all_kmers = set()\n for motif, offset in zip(self.motifs, self.offsets):\n if motif.revcomp:\n rc.motifs.append(motif.revcomp)\n rc.offsets.append(offset) # will be reversed shortly\n rc.all_kmers.update(motif.revcomp.all_kmers)\n else:\n rc.lost_motifs.append(motif)\n if rc.motifs:\n max_off = max(rc.offsets)\n rc.offsets = [max_off - o for o in rc.offsets] # have to reverse direction of offsets\n rc.start, rc.end, rc.score, rc.evidence = improve_window(kmers=rc.all_kmers, **rc.data)\n rc._revcomp = self\n else:\n self._revcomp = None\n return self._revcomp\n def __cmp__(self, other):\n return cmp(self.score, other.score)\n def __len__(self):\n return len(self.motifs)\n def __str__(self):\n return \"<%.2f, %i to %i, %i motifs: %s ...>\" % (self.score, self.start_user, self.end_user, len(self.motifs), self.motifs[0].center)\n\ndef overlaps(mc1, mc2):\n \"\"\"Compare two motifs and/or clusters to see if their location ranges overlap.\"\"\"\n return (mc1.start < mc2.end) and (mc1.end > mc2.start)\n\ndef extract_positive_seqs(cluster, evidence, suf, seq_lens, seq_offsets, align_5p, midgap):\n \"\"\"\n For the \"positive\" (in-group) sequences, extract all the unique regions\n that contain 1+ of the kmers in cluster.\n We do this to avoid the multiple-counting problem of tallying kmers individually.\n \"\"\"\n regions = set() # set([(start,end,revcomp)]) within suf.corpus (the concatenated sequences)\n max_offset = max(cluster.offsets)\n kmer_len = len(cluster.motifs[0].center) + midgap # k-mer length, including \"gap\" residues in the middle\n region_len = max_offset + kmer_len\n for motif, offset in zip(cluster.motifs, cluster.offsets):\n # First, the positive strand:\n fwd_kmers = set([motif.center]) | motif.friends\n locs, matches = kmers_matches(fwd_kmers, suf, seq_offsets, midgap)\n seq_locs = locs.copy()\n max_seq_len = filelocs_to_seqlocs(seq_locs, matches, seq_lens, seq_offsets, align_5p)\n # matches within the positive set of sequences and the allowed region\n keep = (evidence[matches] > 0) & (cluster.start <= seq_locs) & (seq_locs < cluster.end)\n starts = locs[keep] - offset\n regions.update((start, start+region_len, False) for start in starts)\n # Then, the reverse strand\n rev_kmers = motif.all_kmers - fwd_kmers # avoid double-counting palindromes\n if rev_kmers:\n locs, matches = kmers_matches(rev_kmers, suf, seq_offsets, midgap)\n seq_locs = locs.copy()\n max_seq_len = filelocs_to_seqlocs(seq_locs, matches, seq_lens, seq_offsets, align_5p)\n # matches within the positive set of sequences and the allowed region\n keep = (evidence[matches] > 0) & (cluster.start <= seq_locs) & (seq_locs < cluster.end)\n starts = locs[keep] - (max_offset - offset)\n regions.update((start, start+region_len, True) for start in starts)\n seqs = []\n for start, end, revcomp in regions:\n subseq = suf.corpus[start:end]\n # Because of the padding at the start and/or end due to max_offset,\n # subseq may inadvertently span two different genomic sequences!\n nl = subseq.find(\"\\n\")\n if nl >= 0:\n if nl < kmer_len: subseq = subseq[nl+1:].rjust(region_len, \"N\") # left side shorter than k\n elif nl >= max_offset: subseq = subseq[:nl].ljust(region_len, \"N\") # right side shorter than k\n else: continue # could have been either side, too much trouble to figure out, skip it\n if revcomp: seqs.append(dnaseq.reverse_complement(subseq))\n else: seqs.append(subseq)\n return seqs\n\n", "meta": {"hexsha": "abe7ddf64328894c48afc56ec033f7294ebdbc01", "size": 30475, "ext": "py", "lang": "Python", "max_stars_repo_path": "pygr/powrs.py", "max_stars_repo_name": "iwd32900/powrs", "max_stars_repo_head_hexsha": "bd4927f0cb6ab1aa6b77b5adc3cc846dbd064045", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2018-05-02T09:30:23.000Z", "max_stars_repo_stars_event_max_datetime": "2018-11-05T22:37:40.000Z", "max_issues_repo_path": "pygr/powrs.py", "max_issues_repo_name": "iwd32900/powrs", "max_issues_repo_head_hexsha": "bd4927f0cb6ab1aa6b77b5adc3cc846dbd064045", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pygr/powrs.py", "max_forks_repo_name": "iwd32900/powrs", "max_forks_repo_head_hexsha": "bd4927f0cb6ab1aa6b77b5adc3cc846dbd064045", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2018-11-05T22:37:45.000Z", "max_forks_repo_forks_event_max_datetime": "2019-05-03T11:30:48.000Z", "avg_line_length": 54.8111510791, "max_line_length": 140, "alphanum_fraction": 0.6256275636, "include": true, "reason": "import numpy,from scipy", "num_tokens": 7811, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5774953797290153, "lm_q2_score": 0.3276682942552091, "lm_q1q2_score": 0.18922692601607072}} {"text": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\n@author: shahab Sotudian\n\"\"\"\n\nimport numpy as np\nimport pandas as pd\nimport math\nimport six\nfrom six.moves import range\nfrom scipy.stats import rankdata\nimport sys\nimport time\nfrom sklearn import preprocessing\nfrom scipy.stats import spearmanr\nimport random\nstart_time = time.time()\n\n\n# @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n# @@@@ Functions\n# @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\nWhich_Type='ANTIBODY' # 'ANTIBODY' 'ENZYME' 'OTHERS'\nNum_Features= 30 # Total number of features\n\nif Which_Type == 'ANTIBODY':\n Test_Proteins= ['3rvw','4dn4','4g6j','3hi6','3l5w','2vxt','2w9e','4g6m','3g6d','3eo1','3v6z','3hmx','3eoa','3mxw']\n \n Train_Proteins=['1mlc','1iqd','2jel','1nca','1ahw','1e6j','1kxq','1wej','1dqj','2fd6','2i25','1jps','2hmi','1k4c',\n '1i9r','1bj1','1bgx','1qfw','2vis','1nsn','1bvk','1fsk','1vfb']\n \n \n Features_Ordered= ['mincomp_fa_rep','mincomp_score','mincomp_total_score','piper_fa_rep','piper_score','piper_total_score',\n 'movedcomp_total_score','movedcomp_score','var_mem_Elec','var_mem_Born','kurt_mem_Avdw','SPPS','skew_mem_Rvdw',\n 'kurt_mem_Born','avg_mem_Elec','mincomp_fa_dun','PREMIN_COMP_Torsions','movedcomp_fa_dun','POSTMIN_COMP_Torsions',\n 'PREMIN_SING_Torsions','POSTMIN_SING_Torsions','mincomp_rama_prepro','cen_Elec','movedcomp_rama_prepro','size',\n 'piper_fa_dun','mincomp_fa_atr','cen_Born','avg_mem_Born','piper_rama_prepro','mincomp_fa_sol',\n 'piper_fa_intra_sol_xover4','mincomp_omega','POSTMIN_SING_Impropers','piper_yhh_planarity','movedcomp_omega',\n 'movedcomp_fa_intra_rep','mincomp_pro_close','var_mem_Avdw','POSTMIN_SING_Bonded','piper_omega',\n 'movedcomp_pro_close','PREMIN_COMP_Impropers','mincomp_fa_intra_rep','PREMIN_SING_Impropers','POSTMIN_COMP_Impropers',\n 'PREMIN_COMP_Bonded','PREMIN_SING_Bonded','POSTMIN_COMP_Bonded','PREMIN_COMP_Angles','piper_pro_close',\n 'POSTMIN_SING_Angles','movedcomp_fa_intra_sol_xover4','PREMIN_SING_Angles','POSTMIN_COMP_Angles',\n 'mincomp_fa_intra_sol_xover4','skew_mem_Born','avg_mem_dist','movedcomp_yhh_planarity','cen_Avdw',\n 'mincomp_yhh_planarity','avg_mem_Avdw','var_mem_dist','movedcomp_ref','mincomp_ref','piper_fa_atr',\n 'movedcomp_fa_atr','var_mem_DARS','movedcomp_fa_sol','avg_mem_DARS','piper_fa_sol','var_mem_Rvdw','cen_DARS',\n 'piper_dslf_fa13','piper_ref','SPAR','var_mem_Teng','movedcomp_dslf_fa13','cen_Rvdw','movedcomp_hbond_lr_bb',\n 'mincomp_hbond_lr_bb','movedcomp_hbond_bb_sc','piper_hbond_bb_sc','movedcomp_hbond_sr_bb','mincomp_hbond_sr_bb',\n 'avg_mem_Rvdw','mincomp_hbond_bb_sc','piper_hbond_sr_bb','movedcomp_hbond_sc','mincomp_fa_elec','piper_hbond_sc',\n 'movedcomp_fa_elec','SPAS','mincomp_hbond_sc','cen_Teng','piper_fa_elec','avg_mem_Teng','piper_hbond_lr_bb','piper_time']\n \n DATA_ALL = pd.read_csv('/home/Final_DATA_Antibody.csv')\n\nelif Which_Type == 'ENZYME':\n Test_Proteins= ['2gaf','4hx3','3a4s','2yvj','4fza','3fn1','3pc8','3lvk','3k75','4iz7','3vlb','4h03','3h11','1jtd','4lw4','2a1a']\n \n Train_Proteins=['3sgq','1fq1','2o3b','1d6r','2pcc','2mta','1kkl','1oc0','1mah','1m10','1jzd','1cgi','1ijk','1f51','2ayo','7cei',\n '1jiw','2uuy','2oul','1us7','1jk9','1tmq','2sni','1avx','1gxd','2oob','1hia','1dfj','2nz8','2j0t','2z0e','1nw9',\n '1ay7','1jtg','2oor','2ot3','1jwh','1bvn','1oph','1ezu','1e6e','1acb','1f6m','2abz','1f34','1jmo','1gl1','1udi',\n '1r6q','1zm4','1eaw','1ewy','2b42','1buh','1pxv','2sic','2a9k','4cpa','1z5y','1gla','2o8v','1zli','1r0r','1fle',\n '1oyv','1ppe','1wdw','1yvb','1clv','2ido']\n \n Features_Ordered= ['movedcomp_fa_rep','movedcomp_score','movedcomp_total_score','piper_lk_ball_wtd','POSTMIN_COMP_VWD03',\n 'POSTMIN_SING_VWD03','mincomp_lk_ball_wtd','var_mem_Born','mincomp_hbond_lr_bb','piper_pro_close',\n 'movedcomp_hbond_lr_bb','movedcomp_lk_ball_wtd','movedcomp_pro_close','piper_hbond_lr_bb','var_mem_Elec',\n 'POSTMIN_COMP_Angles','POSTMIN_COMP_Impropers','piper_dslf_fa13','movedcomp_dslf_fa13','mincomp_pro_close',\n 'POSTMIN_SING_Bonded','movedcomp_omega','piper_fa_rep','size','PREMIN_SING_Bonded','PREMIN_COMP_Bonded',\n 'POSTMIN_SING_Impropers','POSTMIN_COMP_Bonded','mincomp_fa_rep','mincomp_hbond_sr_bb','piper_hbond_sr_bb',\n 'piper_total_score','piper_score','piper_omega','POSTMIN_SING_Angles','avg_mem_DARS','cen_DARS',\n 'movedcomp_hbond_sr_bb','PREMIN_SING_Impropers','PREMIN_COMP_Impropers','PREMIN_SING_Angles','mincomp_omega',\n 'PREMIN_COMP_Angles','movedcomp_fa_dun','SPPS','mincomp_fa_dun','mincomp_total_score','mincomp_score',\n 'mincomp_fa_intra_rep','movedcomp_yhh_planarity','piper_rama_prepro','mincomp_rama_prepro',\n 'movedcomp_rama_prepro','piper_yhh_planarity','kurt_mem_dist','movedcomp_hbond_sc','cen_Elec',\n 'mincomp_yhh_planarity','mincomp_hbond_sc','mincomp_dslf_fa13','var_mem_dist','movedcomp_fa_intra_rep',\n 'movedcomp_hbond_bb_sc','mincomp_hbond_bb_sc','kurt_mem_Born','avg_mem_dist','avg_mem_Elec','PREMIN_SING_VWD03',\n 'PREMIN_COMP_VWD03','SPAR','PREMIN_COMP_Torsions','PREMIN_SING_Torsions','piper_fa_dun','mincomp_p_aa_pp',\n 'movedcomp_p_aa_pp','POSTMIN_COMP_Torsions','mincomp_fa_elec','piper_hbond_bb_sc','POSTMIN_SING_Torsions',\n 'var_mem_DARS','movedcomp_fa_sol','movedcomp_fa_elec','piper_fa_atr','piper_fa_elec','mincomp_fa_atr',\n 'piper_fa_sol','mincomp_fa_sol','movedcomp_fa_atr','SPAS','piper_hbond_sc','piper_fa_intra_sol_xover4',\n 'movedcomp_time','movedcomp_fa_intra_sol_xover4','mincomp_fa_intra_sol_xover4','piper_fa_intra_rep',\n 'piper_ref','movedcomp_ref','mincomp_ref','skew_mem_Born','kurt_mem_Teng','skew_mem_Teng','skew_mem_DARS',\n 'skew_mem_dist','cen_Teng','mincomp_time','cen_Rvdw','var_mem_Teng','var_mem_Rvdw','avg_mem_Avdw','avg_mem_Rvdw']\n \n DATA_ALL = pd.read_csv('/home//Final_DATA_Enzyme.csv') \n\nelif Which_Type == 'OTHERS':\n Test_Proteins=['3szk','1m27','2x9a','baad','3aad','3s9d','3daw','cp57','3h2v','3bx7',\n '3biw','3p57','4m76','3aaa','3f1p','bp57','2gtp','1rke','3r9a','3l89',\n '1exb','4jcv']\n \n Train_Proteins=['1rv6','1eer','1e4k','2fju','1z0k','1ofu','1a2k','3cph','1ibr','1ib1',\n '1k5d','1k74','1syx','3d5s','1i4d','1rlb','1he8','1r8s','1pvh','1fcc',\n '3bp8','1azs','2hqs','1gpw','2c0l','2i9b','2hle','1de4','1qa9','1fqj',\n '1h1v','1e96','1j2j','1n2c','1t6b','2hrk','1kac','1y64','2b4j','1ghq',\n '2g77','1ml0','1gcq','1efn','1ffw','1bkd','1zhi','1klu','1xd3','2j7p',\n '2cfh','1hcf','2vdb','1atn','1grn','1lfd','1b6c','1ak4','1wq1','1ira',\n '2btf','1sbb','1xqs','1mq8','1xu1','1i2m','1he1','1s1q','2oza','1zhh',\n '1ktz','1fak','1fc2','1kxp','1gp2','2ajf','1akj','1h9d','2a5t']\n \n Features_Ordered=['mincomp_score','mincomp_total_score','mincomp_fa_rep','piper_total_score',\n 'piper_score','piper_fa_rep','cen_Avdw','avg_mem_Avdw','var_mem_Teng',\n 'var_mem_Avdw','avg_mem_Teng','mincomp_lk_ball_wtd','POSTMIN_COMP_Impropers',\n 'size','POSTMIN_SING_Impropers','piper_p_aa_pp','mincomp_p_aa_pp',\n 'movedcomp_lk_ball_wtd','mincomp_pro_close','movedcomp_p_aa_pp','piper_rama_prepro',\n 'mincomp_rama_prepro','movedcomp_rama_prepro','PREMIN_COMP_Angles','PREMIN_SING_Angles',\n 'piper_yhh_planarity','cen_DARS','movedcomp_hbond_bb_sc','avg_mem_DARS','POSTMIN_COMP_VWD03',\n 'POSTMIN_COMP_Angles','POSTMIN_SING_Angles','SPPS','mincomp_hbond_bb_sc','piper_hbond_bb_sc',\n 'movedcomp_hbond_sc','mincomp_yhh_planarity','mincomp_fa_dun','mincomp_hbond_sc','movedcomp_pro_close',\n 'piper_pro_close','movedcomp_ref','mincomp_ref','piper_ref','movedcomp_yhh_planarity','SPAR',\n 'movedcomp_fa_dun','piper_fa_elec','movedcomp_fa_elec','piper_hbond_sc','movedcomp_fa_atr',\n 'piper_fa_intra_sol_xover4','movedcomp_fa_sol','mincomp_fa_elec','movedcomp_omega','piper_fa_atr',\n 'piper_fa_sol','mincomp_fa_intra_sol_xover4','SPAS','movedcomp_fa_intra_sol_xover4','mincomp_fa_atr',\n 'mincomp_fa_intra_rep','movedcomp_dslf_fa13','piper_fa_intra_rep','POSTMIN_SING_VWD03','PREMIN_COMP_VWD03',\n 'mincomp_fa_sol','PREMIN_SING_VWD03','piper_dslf_fa13','POSTMIN_SING_Torsions','PREMIN_SING_Torsions',\n 'PREMIN_COMP_Torsions','POSTMIN_COMP_Torsions','piper_fa_dun','movedcomp_fa_intra_rep','piper_hbond_sr_bb',\n 'movedcomp_hbond_sr_bb','mincomp_hbond_sr_bb','mincomp_dslf_fa13','mincomp_omega','PREMIN_COMP_Impropers',\n 'piper_omega','movedcomp_hbond_lr_bb','PREMIN_SING_Impropers','mincomp_hbond_lr_bb','piper_hbond_lr_bb',\n 'skew_mem_DARS','cen_Elec','avg_mem_Elec','avg_mem_Born','cen_Born','piper_time','kurt_mem_Teng','skew_mem_Teng',\n 'mincomp_time','movedcomp_time']\n \n DATA_ALL = pd.read_csv('/home/Others_Protein_DATA.csv')\n\n\n\n\nX=DATA_ALL.iloc[:][Features_Ordered[0:Num_Features]]\nY=pd.DataFrame(DATA_ALL.iloc[:]['dockq']) # ['dockq','fnat','lrms','irms']\n\n\n\n# Normalazation\nNormalization_scaler = preprocessing.MinMaxScaler()#MinMaxScaler StandardScaler\nNormalized_X=pd.DataFrame( Normalization_scaler.fit_transform(X.values) )\nNormalized_X.columns=X.columns\n\n\n\n\n# @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n# @@@@ Functions\n# @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\ndef dcg_at_k(r, k):\n \"\"\"\n Args:\n r: Relevance scores (list or numpy) in rank order\n (first element is the first item)\n k: Number of results to consider\n\n Returns:\n Discounted cumulative gain\n \"\"\"\n r = np.asfarray(r)[:k]\n return np.sum(r / np.log2(np.arange(2, r.size + 2)))\n\n\ndef ndcg_at_k(r, k):\n\n dcg_max = dcg_at_k(sorted(r, reverse=True), k)\n if not dcg_max:\n return 0.\n return dcg_at_k(r, k) / dcg_max\n\n\ndef Pi_Hat(Big_X_features,x,Theta, Alpha):\n PI=1\n PI_Hat=1\n for i in range(len(Big_X_features)):\n S_x_y= np.inner( Theta, x ) - np.inner( Theta, Big_X_features[i,:] )\n # print(S_x_y)\n if S_x_y != 0:\n PI_Hat= PI_Hat + np.exp(-Alpha*S_x_y)/(1+np.exp(-Alpha*S_x_y))\n # if S_x_y<0:\n # PI=PI+1\n return PI_Hat\n \n\ndef Gradient_Update(Big_X_Relevance,Big_X_features,Theta, Alpha):\n # Part1 \n N_n= 1/dcg_at_k(sorted(Big_X_Relevance, reverse=True), len(Big_X_Relevance))\n if N_n == float('inf'): # Revise N_n=0\n N_n=1\n Eq_41_Sumation= np.zeros(len(Big_X_features[1,:]))\n\n\n\n for Ind_x in range(len(Big_X_features)):\n global S_x_y\n x= Big_X_features[Ind_x,:]\n rx=Big_X_Relevance[Ind_x]\n\n # Part2 Eq_42\n Eq_42= np.zeros(len(Big_X_features[1,:]))\n for i in range(len(Big_X_features)):\n S_x_y= np.inner( Theta, x ) - np.inner( Theta, Big_X_features[i,:] )\n if S_x_y != np.array([0.]):\n \n Grad_Diff= x - Big_X_features[i,:] # This is for linear score functions\n P1=np.exp(Alpha*S_x_y)/((1+np.exp(Alpha*S_x_y))**2)\n Eq_42=Eq_42+ (P1*Grad_Diff)\n\n Eq_42=-Alpha*Eq_42 \n \n # Part3 Eq_43 \n PP1= -(((2**rx)-1)/(math.log2(1+Pi_Hat(Big_X_features,x,Theta, Alpha)))**2)\n PP2= 1/((1+Pi_Hat(Big_X_features,x,Theta, Alpha))*np.log(2))\n Eq_43=PP1*PP2\n \n \n # Part 4 Eq_42_43\n\n Eq_41_Sumation= Eq_41_Sumation + (Eq_43 * Eq_42)\n \n # Final gradient\n return N_n*Eq_41_Sumation \n \n\ndef iter_lines(lines, has_targets=True, one_indexed=True, missing=0.0):\n \"\"\"Transforms an iterator of lines to an iterator of LETOR rows.\n Each row is represented by a (x, y, qid, comment) tuple.\n Parameters\n ----------\n lines : iterable of lines\n Lines to parse.\n has_targets : bool, optional\n Whether the file contains targets. If True, will expect the first token\n of every line to be a real representing the sample's target (i.e.\n score). If False, will use -1 as a placeholder for all targets.\n one_indexed : bool, optional\n Whether feature ids are one-indexed. If True, will subtract 1 from each\n feature id.\n missing : float, optional\n Placeholder to use if a feature value is not provided for a sample.\n Yields\n ------\n x : array of floats\n Feature vector of the sample.\n y : float\n Target value (score) of the sample, or -1 if no target was parsed.\n qid : object\n Query id of the sample. This is currently guaranteed to be a string.\n comment : str\n Comment accompanying the sample.\n \"\"\"\n for line in lines:\n \n data, _, comment = line.rstrip().partition('#')\n toks = data.split()\n\n num_features = 0\n x = np.repeat(missing, 8)\n y = -1.0\n if has_targets:\n # print(toks)\n # print(\"#########################\")\n y = float(toks[0])\n toks = toks[1:]\n\n qid = _parse_qid_tok(toks[0])\n\n for tok in toks[1:]:\n fid, _, val = tok.partition(':')\n fid = int(fid)\n val = float(val)\n if one_indexed:\n fid -= 1\n assert fid >= 0\n while len(x) <= fid:\n orig = len(x)\n x.resize(len(x) * 2)\n x[orig:orig * 2] = missing\n\n x[fid] = val\n num_features = max(fid + 1, num_features)\n\n assert num_features > 0\n x.resize(num_features)\n\n yield (x, y, qid, comment)\n\n\n \ndef read_dataset(source, has_targets=True, one_indexed=True, missing=0.0):\n \"\"\"Parses a LETOR dataset from `source`.\n Parameters\n ----------\n source : string or iterable of lines\n String, file, or other file-like object to parse.\n has_targets : bool, optional\n See `iter_lines`.\n one_indexed : bool, optional\n See `iter_lines`.\n missing : float, optional\n See `iter_lines`.\n Returns\n -------\n X : array of arrays of floats\n Feature matrix (see `iter_lines`).\n y : array of floats\n Target vector (see `iter_lines`).\n qids : array of objects\n Query id vector (see `iter_lines`).\n comments : array of strs\n Comment vector (see `iter_lines`).\n \"\"\"\n if isinstance(source, six.string_types):\n source = source.splitlines()\n\n max_width = 0\n xs, ys, qids, comments = [], [], [], []\n it = iter_lines(source, has_targets=has_targets,\n one_indexed=one_indexed, missing=missing)\n for x, y, qid, comment in it:\n xs.append(x)\n ys.append(y)\n qids.append(qid)\n comments.append(comment)\n max_width = max(max_width, len(x))\n\n assert max_width > 0\n X = np.ndarray((len(xs), max_width), dtype=np.float64)\n X.fill(missing)\n for i, x in enumerate(xs):\n X[i, :len(x)] = x\n ys = np.array(ys) if has_targets else None\n qids = np.array(qids)\n comments = np.array(comments)\n\n return (X, ys, qids, comments)\n \n\ndef _parse_qid_tok(tok):\n assert tok.startswith('qid:')\n return tok[4:]\n\ndef Performance_Metrics(S_in):\n RANKS=S_in[S_in['RANK_True']==1]\n ACC_All=S_in[S_in['dockq']>0.23]\n Med_All=S_in[S_in['dockq']>0.49]\n # Spearman\n Spearman=spearmanr(S_in['RANK_Pred'], S_in['RANK_True'])[0]\n Spearman_C=spearmanr(S_in['RANK_ClusPro'], S_in['RANK_True'])[0]\n\n # Highest Quality\n T_1_star= int(RANKS['RANK_Pred']<=1)\n T_5_star= int(RANKS['RANK_Pred']<=5)\n T_10_star= int(RANKS['RANK_Pred']<=10)\n \n CT_1_star= int(RANKS['RANK_ClusPro']<=1)\n CT_5_star= int(RANKS['RANK_ClusPro']<=5)\n CT_10_star= int(RANKS['RANK_ClusPro']<=10)\n\n # ACC\n if ACC_All.empty:\n ACCT_1=ACCT_5=ACCT_10=ACCCT_1=ACCCT_5=ACCCT_10=0\n Have_Acc=0\n else:\n Have_Acc=1\n ACCT_1=int(np.where( sum(x<=1 for x in ACC_All['RANK_Pred']) > 0.5 , 1, 0))\n ACCT_5=int(np.where( sum(x<=5 for x in ACC_All['RANK_Pred']) > 0.5 , 1, 0))\n ACCT_10= int(np.where( sum(x<=10 for x in ACC_All['RANK_Pred']) > 0.5 , 1, 0))\n \n ACCCT_1=int(np.where( sum(x<=1 for x in ACC_All['RANK_ClusPro']) > 0.5 , 1, 0))\n ACCCT_5=int(np.where( sum(x<=5 for x in ACC_All['RANK_ClusPro']) > 0.5 , 1, 0))\n ACCCT_10=int(np.where( sum(x<=10 for x in ACC_All['RANK_ClusPro']) > 0.5 , 1, 0))\n \n \n # Med\n if Med_All.empty:\n MedT_1=MedT_5=MedT_10=MedCT_1=MedCT_5=MedCT_10=0\n Have_Med=0\n else:\n Have_Med=1\n MedT_1=int(np.where( sum(x<=1 for x in Med_All['RANK_Pred']) > 0.5 , 1, 0))\n MedT_5=int(np.where( sum(x<=5 for x in Med_All['RANK_Pred']) > 0.5 , 1, 0))\n MedT_10=int(np.where( sum(x<=10 for x in Med_All['RANK_Pred']) > 0.5 , 1, 0))\n \n MedCT_1=int(np.where( sum(x<=1 for x in Med_All['RANK_ClusPro']) > 0.5 , 1, 0))\n MedCT_5=int(np.where( sum(x<=5 for x in Med_All['RANK_ClusPro']) > 0.5 , 1, 0))\n MedCT_10=int(np.where( sum(x<=10 for x in Med_All['RANK_ClusPro']) > 0.5 , 1, 0))\n\n return [Spearman,Spearman_C,T_1_star,CT_1_star,T_5_star,CT_5_star,T_10_star,CT_10_star,ACCT_1,ACCCT_1,ACCT_5,ACCCT_5,ACCT_10,ACCCT_10,Have_Acc,MedT_1,MedCT_1,MedT_5,MedCT_5,MedT_10,MedCT_10,Have_Med]\n\n\n# @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n# @@@@ Main Algorithm ApproxNDCG\n# @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\n\n# =========-------------------------------------------------------------------\n# Data Preprocessing - Train\n# =========------------------------------------------------------------------- \n \n# Load data \n\n# X_Train=Normalized_X[DATA_ALL['pdbid'].isin(Train_Proteins)]\n# Y_Train=Y[DATA_ALL['pdbid'].isin(Train_Proteins)]\n\n# X_Train=X_Train.reset_index(drop=True)\n# Y_Train=Y_Train.reset_index(drop=True)\n\n\n\n\nNum_Queries=len(Train_Proteins)\nNum_Features= Normalized_X.shape[1]\n\n\n\nWeight_Y=1\nY=Y*Weight_Y \nNum_itr=20\nLearning_Rate = 0.1\nAlpha=10\n\n# Initialize Theta \nTheta_t_1 = np.zeros([(Num_itr+1),Num_Features])\n#Theta_t_1[0,:]=np.random.random([1,Num_Features])\nTheta_t_1[0,:]=np.ones([1,Num_Features])\n\n\nfor t in range(Num_itr): \n print('**** Iteration ', t+1, ' *******************************')\n THETA= Theta_t_1[t,:]\n for i in range(Num_Queries):\n Big_X_features= Normalized_X[DATA_ALL['pdbid'].isin([Train_Proteins[i]])]\n Big_X_Relevance= Y[DATA_ALL['pdbid'].isin([Train_Proteins[i]])]\n\n # Compute gradient for i-th query\n Delta_Theta= Gradient_Update(np.array(Big_X_Relevance),np.array(Big_X_features),THETA, Alpha)\n \n THETA = THETA + (Learning_Rate * Delta_Theta)\n\n Theta_t_1[(t+1),:]= THETA\n # Shuffle queries\n random.seed(t)\n random.shuffle(Train_Proteins) \n \n\n\n\n# =========-------------------------------------------------------------------\n# Data Preprocessing - Validation\n# =========------------------------------------------------------------------- \n\n# with open(\"/home/vali.txt\") as validationfile:\n# VX, Vy, Vqids, Vc = read_dataset(validationfile, has_targets=True , one_indexed=True)\n \n\n\n# =========-------------------------------------------------------------------\n# Data Preprocessing - Test\n# =========------------------------------------------------------------------- \n \n# X_Test=Normalized_X[DATA_ALL['pdbid'].isin(Test_Proteins)]\n# Y_Test=Y[DATA_ALL['pdbid'].isin(Test_Proteins)]\n# X_Test=X_Test.reset_index(drop=True)\n# Y_Test=Y_Test.reset_index(drop=True)\n\n\nNum_Test_Queries=len(Test_Proteins)\n\n \nPredicted_NDCGatk = np.array([0,1, 2, 3, 4, 5, 6, 7, 8, 9, 10])\nfor pp in range(Num_itr): \n NDCG_all=[0,0,0,0,0,0,0,0,0,0,0] \n for tt in range(Num_Test_Queries):\n Test_X_features= Normalized_X[DATA_ALL['pdbid'].isin([Test_Proteins[tt]])]\n Pred_Q= np.matmul(np.array(Test_X_features) , Theta_t_1[pp] ) # Prediction in iteration pp-th\n Ground_Q = np.array( Y[DATA_ALL['pdbid'].isin([Test_Proteins[tt]])] )\n Pred_Ranks=(rankdata(-Pred_Q, method='ordinal')) # Decreasing order\n Pred_Ranks = np.expand_dims(Pred_Ranks, axis=1)\n Concat= np.concatenate((Ground_Q,Pred_Ranks), axis=1)\n sorted_array = Concat[np.argsort(Concat[:, 1])]\n RGT= sorted_array[:,0]\n # NDCG @ k\n NDCG_all = np.add(NDCG_all, [pp, ndcg_at_k(RGT, 1),ndcg_at_k(RGT, 2),ndcg_at_k(RGT, 3),ndcg_at_k(RGT, 4),ndcg_at_k(RGT, 5),ndcg_at_k(RGT, 6),ndcg_at_k(RGT, 7),ndcg_at_k(RGT, 8),ndcg_at_k(RGT, 9),ndcg_at_k(RGT, 10)]) \n \n\n Predicted_NDCG=NDCG_all/Num_Test_Queries\n print(Predicted_NDCG)\n Predicted_NDCGatk=np.vstack([Predicted_NDCGatk,Predicted_NDCG])\n\n\nprint(\"--- %s seconds ---\" % (time.time() - start_time))\n\n# save numpy array as csv file\nfrom numpy import asarray\nfrom numpy import savetxt\n\n\n# save to csv file\n\n\n\nSAVE_Name_Theta= Which_Type + '_NFeature_' + str(Num_Features) +'_Learned_Thetas_itr'+str(Num_itr)+'_Alpha'+str(Alpha)+'.csv'\n\nSAVE_Name_Results= Which_Type + '_NFeature_' + str(Num_Features) + '_Results_itr'+str(Num_itr)+'_Alpha'+str(Alpha)+'.csv'\n\n# save to csv file\nsavetxt(SAVE_Name_Theta, Theta_t_1, delimiter=',')\n\nsavetxt(SAVE_Name_Results, Predicted_NDCGatk, delimiter=',')\n", "meta": {"hexsha": "c9b002e8402a1c9607f8bf019f9a5899d888d0be", "size": 22457, "ext": "py", "lang": "Python", "max_stars_repo_path": "ApproxNDCG/ApproxNDCG_Model_Protein.py", "max_stars_repo_name": "sotudian/Cluster-Ranking-in-Protein-Protein-Docking", "max_stars_repo_head_hexsha": "8272d4630649e05a06cdbf3bfae7b2fe30da670a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "ApproxNDCG/ApproxNDCG_Model_Protein.py", "max_issues_repo_name": "sotudian/Cluster-Ranking-in-Protein-Protein-Docking", "max_issues_repo_head_hexsha": "8272d4630649e05a06cdbf3bfae7b2fe30da670a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ApproxNDCG/ApproxNDCG_Model_Protein.py", "max_forks_repo_name": "sotudian/Cluster-Ranking-in-Protein-Protein-Docking", "max_forks_repo_head_hexsha": "8272d4630649e05a06cdbf3bfae7b2fe30da670a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.4693069307, "max_line_length": 225, "alphanum_fraction": 0.5987442668, "include": true, "reason": "import numpy,from numpy,from scipy", "num_tokens": 7057, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5774953651858118, "lm_q2_score": 0.3276682876897044, "lm_q1q2_score": 0.1892269174591755}} {"text": "#!/usr/bin/env python\n# Copyright 2014-2018 The PySCF Developers. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n# Author: Qiming Sun \n#\n\nimport numpy\nfrom pyscf import lib\nfrom pyscf.ao2mo import _ao2mo\nfrom pyscf.ao2mo.incore import iden_coeffs, _conc_mos\nfrom pyscf.pbc.df.fft_ao2mo import _format_kpts\nfrom pyscf.pbc.df import df_ao2mo\nfrom pyscf.pbc.df import aft_ao2mo\nfrom pyscf.pbc.lib import kpts_helper\nfrom pyscf.pbc.lib.kpts_helper import is_zero, gamma_point, member, unique\nfrom pyscf import __config__\n\n\ndef get_eri(mydf, kpts=None,\n compact=getattr(__config__, 'pbc_df_ao2mo_get_eri_compact', True)):\n if mydf._cderi is None:\n mydf.build()\n\n kptijkl = _format_kpts(kpts)\n eri = aft_ao2mo.get_eri(mydf, kptijkl, compact=compact)\n eri += df_ao2mo.get_eri(mydf, kptijkl, compact=compact)\n return eri\n\n\ndef general(mydf, mo_coeffs, kpts=None,\n compact=getattr(__config__, 'pbc_df_ao2mo_general_compact', True)):\n if mydf._cderi is None:\n mydf.build()\n\n kptijkl = _format_kpts(kpts)\n if isinstance(mo_coeffs, numpy.ndarray) and mo_coeffs.ndim == 2:\n mo_coeffs = (mo_coeffs,) * 4\n eri_mo = aft_ao2mo.general(mydf, mo_coeffs, kptijkl, compact=compact)\n eri_mo += df_ao2mo.general(mydf, mo_coeffs, kptijkl, compact=compact)\n return eri_mo\n\ndef ao2mo_7d(mydf, mo_coeff_kpts, kpts=None, factor=1, out=None):\n cell = mydf.cell\n if kpts is None:\n kpts = mydf.kpts\n nkpts = len(kpts)\n\n if isinstance(mo_coeff_kpts, numpy.ndarray) and mo_coeff_kpts.ndim == 3:\n mo_coeff_kpts = [mo_coeff_kpts] * 4\n else:\n mo_coeff_kpts = list(mo_coeff_kpts)\n\n # Shape of the orbitals can be different on different k-points. The\n # orbital coefficients must be formatted (padded by zeros) so that the\n # shape of the orbital coefficients are the same on all k-points. This can\n # be achieved by calling pbc.mp.kmp2.padded_mo_coeff function\n nmoi, nmoj, nmok, nmol = [x.shape[2] for x in mo_coeff_kpts]\n eri_shape = (nkpts, nkpts, nkpts, nmoi, nmoj, nmok, nmol)\n if gamma_point(kpts):\n dtype = numpy.result_type(*mo_coeff_kpts)\n else:\n dtype = numpy.complex128\n\n if out is None:\n out = numpy.empty(eri_shape, dtype=dtype)\n else:\n assert(out.shape == eri_shape)\n\n kptij_lst = numpy.array([(ki, kj) for ki in kpts for kj in kpts])\n kptis_lst = kptij_lst[:,0]\n kptjs_lst = kptij_lst[:,1]\n kpt_ji = kptjs_lst - kptis_lst\n uniq_kpts, uniq_index, uniq_inverse = unique(kpt_ji)\n ngrids = numpy.prod(mydf.mesh)\n nao = cell.nao_nr()\n max_memory = max(2000, mydf.max_memory-lib.current_memory()[0]-nao**4*16/1e6) * .5\n\n fswap = lib.H5TmpFile()\n tao = []\n ao_loc = None\n kconserv = kpts_helper.get_kconserv(cell, kpts)\n for uniq_id, kpt in enumerate(uniq_kpts):\n q = uniq_kpts[uniq_id]\n adapted_ji_idx = numpy.where(uniq_inverse == uniq_id)[0]\n\n kptjs = kptjs_lst[adapted_ji_idx]\n coulG = mydf.weighted_coulG(q, False, mydf.mesh)\n coulG *= factor\n\n moij_list = []\n ijslice_list = []\n for ji, ji_idx in enumerate(adapted_ji_idx):\n ki = ji_idx // nkpts\n kj = ji_idx % nkpts\n moij, ijslice = _conc_mos(mo_coeff_kpts[0][ki], mo_coeff_kpts[1][kj])[2:]\n moij_list.append(moij)\n ijslice_list.append(ijslice)\n fswap.create_dataset('zij/'+str(ji), (ngrids,nmoi*nmoj), 'D')\n\n for aoaoks, p0, p1 in mydf.ft_loop(mydf.mesh, q, kptjs,\n max_memory=max_memory):\n for ji, aoao in enumerate(aoaoks):\n ki = adapted_ji_idx[ji] // nkpts\n kj = adapted_ji_idx[ji] % nkpts\n buf = aoao.transpose(1,2,0).reshape(nao**2,p1-p0)\n zij = _ao2mo.r_e2(lib.transpose(buf), moij_list[ji],\n ijslice_list[ji], tao, ao_loc)\n zij *= coulG[p0:p1,None]\n fswap['zij/'+str(ji)][p0:p1] = zij\n\n mokl_list = []\n klslice_list = []\n for kk in range(nkpts):\n kl = kconserv[ki, kj, kk]\n mokl, klslice = _conc_mos(mo_coeff_kpts[2][kk], mo_coeff_kpts[3][kl])[2:]\n mokl_list.append(mokl)\n klslice_list.append(klslice)\n fswap.create_dataset('zkl/'+str(kk), (ngrids,nmok*nmol), 'D')\n\n ki = adapted_ji_idx[0] // nkpts\n kj = adapted_ji_idx[0] % nkpts\n kptls = kpts[kconserv[ki, kj, :]]\n for aoaoks, p0, p1 in mydf.ft_loop(mydf.mesh, q, -kptls,\n max_memory=max_memory):\n for kk, aoao in enumerate(aoaoks):\n buf = aoao.conj().transpose(1,2,0).reshape(nao**2,p1-p0)\n zkl = _ao2mo.r_e2(lib.transpose(buf), mokl_list[kk],\n klslice_list[kk], tao, ao_loc)\n fswap['zkl/'+str(kk)][p0:p1] = zkl\n\n for ji, ji_idx in enumerate(adapted_ji_idx):\n ki = ji_idx // nkpts\n kj = ji_idx % nkpts\n\n moij, ijslice = _conc_mos(mo_coeff_kpts[0][ki], mo_coeff_kpts[1][kj])[2:]\n zij = []\n for LpqR, LpqI, sign in mydf.sr_loop(kpts[[ki,kj]], max_memory, False, mydf.blockdim):\n zij.append(_ao2mo.r_e2(LpqR+LpqI*1j, moij, ijslice, tao, ao_loc))\n\n for kk in range(nkpts):\n kl = kconserv[ki, kj, kk]\n eri_mo = lib.dot(numpy.asarray(fswap['zij/'+str(ji)]).T,\n numpy.asarray(fswap['zkl/'+str(kk)]))\n\n for i, (LrsR, LrsI, sign) in \\\n enumerate(mydf.sr_loop(kpts[[kk,kl]], max_memory, False, mydf.blockdim)):\n zkl = _ao2mo.r_e2(LrsR+LrsI*1j, mokl_list[kk],\n klslice_list[kk], tao, ao_loc)\n lib.dot(zij[i].T, zkl, sign*factor, eri_mo, 1)\n\n if dtype == numpy.double:\n eri_mo = eri_mo.real\n out[ki,kj,kk] = eri_mo.reshape(eri_shape[3:])\n del(fswap['zij'])\n del(fswap['zkl'])\n\n return out\n\n", "meta": {"hexsha": "22de3ec123184f3ddcd82e4758cf178ee637c9a2", "size": 6690, "ext": "py", "lang": "Python", "max_stars_repo_path": "pyscf/pbc/df/mdf_ao2mo.py", "max_stars_repo_name": "crisely09/pyscf", "max_stars_repo_head_hexsha": "cb92f7974bd9c87c0ef5b2b52abf5d3219b3d6b6", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-06-30T22:33:35.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-22T18:02:36.000Z", "max_issues_repo_path": "pyscf/pbc/df/mdf_ao2mo.py", "max_issues_repo_name": "crisely09/pyscf", "max_issues_repo_head_hexsha": "cb92f7974bd9c87c0ef5b2b52abf5d3219b3d6b6", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pyscf/pbc/df/mdf_ao2mo.py", "max_forks_repo_name": "crisely09/pyscf", "max_forks_repo_head_hexsha": "cb92f7974bd9c87c0ef5b2b52abf5d3219b3d6b6", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-09-16T23:37:42.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-14T23:00:39.000Z", "avg_line_length": 39.1228070175, "max_line_length": 98, "alphanum_fraction": 0.6077727952, "include": true, "reason": "import numpy", "num_tokens": 2034, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6150878555160665, "lm_q2_score": 0.30735800417608683, "lm_q1q2_score": 0.18905217566436747}} {"text": "# Copyright 2021 AlQuraishi Laboratory\n# Copyright 2021 DeepMind Technologies Limited\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\"\"\"Constants used in AlphaFold.\"\"\"\n\nimport collections\nimport functools\nfrom typing import Mapping, List, Tuple\n\nimport numpy as np\nimport tree\n\n# Internal import (35fd).\n\n\n# Distance from one CA to next CA [trans configuration: omega = 180].\nca_ca = 3.80209737096\n\n# Format: The list for each AA type contains chi1, chi2, chi3, chi4 in\n# this order (or a relevant subset from chi1 onwards). ALA and GLY don't have\n# chi angles so their chi angle lists are empty.\nchi_angles_atoms = {\n \"ALA\": [],\n # Chi5 in arginine is always 0 +- 5 degrees, so ignore it.\n \"ARG\": [\n [\"N\", \"CA\", \"CB\", \"CG\"],\n [\"CA\", \"CB\", \"CG\", \"CD\"],\n [\"CB\", \"CG\", \"CD\", \"NE\"],\n [\"CG\", \"CD\", \"NE\", \"CZ\"],\n ],\n \"ASN\": [[\"N\", \"CA\", \"CB\", \"CG\"], [\"CA\", \"CB\", \"CG\", \"OD1\"]],\n \"ASP\": [[\"N\", \"CA\", \"CB\", \"CG\"], [\"CA\", \"CB\", \"CG\", \"OD1\"]],\n \"CYS\": [[\"N\", \"CA\", \"CB\", \"SG\"]],\n \"GLN\": [\n [\"N\", \"CA\", \"CB\", \"CG\"],\n [\"CA\", \"CB\", \"CG\", \"CD\"],\n [\"CB\", \"CG\", \"CD\", \"OE1\"],\n ],\n \"GLU\": [\n [\"N\", \"CA\", \"CB\", \"CG\"],\n [\"CA\", \"CB\", \"CG\", \"CD\"],\n [\"CB\", \"CG\", \"CD\", \"OE1\"],\n ],\n \"GLY\": [],\n \"HIS\": [[\"N\", \"CA\", \"CB\", \"CG\"], [\"CA\", \"CB\", \"CG\", \"ND1\"]],\n \"ILE\": [[\"N\", \"CA\", \"CB\", \"CG1\"], [\"CA\", \"CB\", \"CG1\", \"CD1\"]],\n \"LEU\": [[\"N\", \"CA\", \"CB\", \"CG\"], [\"CA\", \"CB\", \"CG\", \"CD1\"]],\n \"LYS\": [\n [\"N\", \"CA\", \"CB\", \"CG\"],\n [\"CA\", \"CB\", \"CG\", \"CD\"],\n [\"CB\", \"CG\", \"CD\", \"CE\"],\n [\"CG\", \"CD\", \"CE\", \"NZ\"],\n ],\n \"MET\": [\n [\"N\", \"CA\", \"CB\", \"CG\"],\n [\"CA\", \"CB\", \"CG\", \"SD\"],\n [\"CB\", \"CG\", \"SD\", \"CE\"],\n ],\n \"PHE\": [[\"N\", \"CA\", \"CB\", \"CG\"], [\"CA\", \"CB\", \"CG\", \"CD1\"]],\n \"PRO\": [[\"N\", \"CA\", \"CB\", \"CG\"], [\"CA\", \"CB\", \"CG\", \"CD\"]],\n \"SER\": [[\"N\", \"CA\", \"CB\", \"OG\"]],\n \"THR\": [[\"N\", \"CA\", \"CB\", \"OG1\"]],\n \"TRP\": [[\"N\", \"CA\", \"CB\", \"CG\"], [\"CA\", \"CB\", \"CG\", \"CD1\"]],\n \"TYR\": [[\"N\", \"CA\", \"CB\", \"CG\"], [\"CA\", \"CB\", \"CG\", \"CD1\"]],\n \"VAL\": [[\"N\", \"CA\", \"CB\", \"CG1\"]],\n}\n\n# If chi angles given in fixed-length array, this matrix determines how to mask\n# them for each AA type. The order is as per restype_order (see below).\nchi_angles_mask = [\n [0.0, 0.0, 0.0, 0.0], # ALA\n [1.0, 1.0, 1.0, 1.0], # ARG\n [1.0, 1.0, 0.0, 0.0], # ASN\n [1.0, 1.0, 0.0, 0.0], # ASP\n [1.0, 0.0, 0.0, 0.0], # CYS\n [1.0, 1.0, 1.0, 0.0], # GLN\n [1.0, 1.0, 1.0, 0.0], # GLU\n [0.0, 0.0, 0.0, 0.0], # GLY\n [1.0, 1.0, 0.0, 0.0], # HIS\n [1.0, 1.0, 0.0, 0.0], # ILE\n [1.0, 1.0, 0.0, 0.0], # LEU\n [1.0, 1.0, 1.0, 1.0], # LYS\n [1.0, 1.0, 1.0, 0.0], # MET\n [1.0, 1.0, 0.0, 0.0], # PHE\n [1.0, 1.0, 0.0, 0.0], # PRO\n [1.0, 0.0, 0.0, 0.0], # SER\n [1.0, 0.0, 0.0, 0.0], # THR\n [1.0, 1.0, 0.0, 0.0], # TRP\n [1.0, 1.0, 0.0, 0.0], # TYR\n [1.0, 0.0, 0.0, 0.0], # VAL\n]\n\n# The following chi angles are pi periodic: they can be rotated by a multiple\n# of pi without affecting the structure.\nchi_pi_periodic = [\n [0.0, 0.0, 0.0, 0.0], # ALA\n [0.0, 0.0, 0.0, 0.0], # ARG\n [0.0, 0.0, 0.0, 0.0], # ASN\n [0.0, 1.0, 0.0, 0.0], # ASP\n [0.0, 0.0, 0.0, 0.0], # CYS\n [0.0, 0.0, 0.0, 0.0], # GLN\n [0.0, 0.0, 1.0, 0.0], # GLU\n [0.0, 0.0, 0.0, 0.0], # GLY\n [0.0, 0.0, 0.0, 0.0], # HIS\n [0.0, 0.0, 0.0, 0.0], # ILE\n [0.0, 0.0, 0.0, 0.0], # LEU\n [0.0, 0.0, 0.0, 0.0], # LYS\n [0.0, 0.0, 0.0, 0.0], # MET\n [0.0, 1.0, 0.0, 0.0], # PHE\n [0.0, 0.0, 0.0, 0.0], # PRO\n [0.0, 0.0, 0.0, 0.0], # SER\n [0.0, 0.0, 0.0, 0.0], # THR\n [0.0, 0.0, 0.0, 0.0], # TRP\n [0.0, 1.0, 0.0, 0.0], # TYR\n [0.0, 0.0, 0.0, 0.0], # VAL\n [0.0, 0.0, 0.0, 0.0], # UNK\n]\n\n# Atoms positions relative to the 8 rigid groups, defined by the pre-omega, phi,\n# psi and chi angles:\n# 0: 'backbone group',\n# 1: 'pre-omega-group', (empty)\n# 2: 'phi-group', (currently empty, because it defines only hydrogens)\n# 3: 'psi-group',\n# 4,5,6,7: 'chi1,2,3,4-group'\n# The atom positions are relative to the axis-end-atom of the corresponding\n# rotation axis. The x-axis is in direction of the rotation axis, and the y-axis\n# is defined such that the dihedral-angle-definiting atom (the last entry in\n# chi_angles_atoms above) is in the xy-plane (with a positive y-coordinate).\n# format: [atomname, group_idx, rel_position]\nrigid_group_atom_positions = {\n \"ALA\": [\n [\"N\", 0, (-0.525, 1.363, 0.000)],\n [\"CA\", 0, (0.000, 0.000, 0.000)],\n [\"C\", 0, (1.526, -0.000, -0.000)],\n [\"CB\", 0, (-0.529, -0.774, -1.205)],\n [\"O\", 3, (0.627, 1.062, 0.000)],\n ],\n \"ARG\": [\n [\"N\", 0, (-0.524, 1.362, -0.000)],\n [\"CA\", 0, (0.000, 0.000, 0.000)],\n [\"C\", 0, (1.525, -0.000, -0.000)],\n [\"CB\", 0, (-0.524, -0.778, -1.209)],\n [\"O\", 3, (0.626, 1.062, 0.000)],\n [\"CG\", 4, (0.616, 1.390, -0.000)],\n [\"CD\", 5, (0.564, 1.414, 0.000)],\n [\"NE\", 6, (0.539, 1.357, -0.000)],\n [\"NH1\", 7, (0.206, 2.301, 0.000)],\n [\"NH2\", 7, (2.078, 0.978, -0.000)],\n [\"CZ\", 7, (0.758, 1.093, -0.000)],\n ],\n \"ASN\": [\n [\"N\", 0, (-0.536, 1.357, 0.000)],\n [\"CA\", 0, (0.000, 0.000, 0.000)],\n [\"C\", 0, (1.526, -0.000, -0.000)],\n [\"CB\", 0, (-0.531, -0.787, -1.200)],\n [\"O\", 3, (0.625, 1.062, 0.000)],\n [\"CG\", 4, (0.584, 1.399, 0.000)],\n [\"ND2\", 5, (0.593, -1.188, 0.001)],\n [\"OD1\", 5, (0.633, 1.059, 0.000)],\n ],\n \"ASP\": [\n [\"N\", 0, (-0.525, 1.362, -0.000)],\n [\"CA\", 0, (0.000, 0.000, 0.000)],\n [\"C\", 0, (1.527, 0.000, -0.000)],\n [\"CB\", 0, (-0.526, -0.778, -1.208)],\n [\"O\", 3, (0.626, 1.062, -0.000)],\n [\"CG\", 4, (0.593, 1.398, -0.000)],\n [\"OD1\", 5, (0.610, 1.091, 0.000)],\n [\"OD2\", 5, (0.592, -1.101, -0.003)],\n ],\n \"CYS\": [\n [\"N\", 0, (-0.522, 1.362, -0.000)],\n [\"CA\", 0, (0.000, 0.000, 0.000)],\n [\"C\", 0, (1.524, 0.000, 0.000)],\n [\"CB\", 0, (-0.519, -0.773, -1.212)],\n [\"O\", 3, (0.625, 1.062, -0.000)],\n [\"SG\", 4, (0.728, 1.653, 0.000)],\n ],\n \"GLN\": [\n [\"N\", 0, (-0.526, 1.361, -0.000)],\n [\"CA\", 0, (0.000, 0.000, 0.000)],\n [\"C\", 0, (1.526, 0.000, 0.000)],\n [\"CB\", 0, (-0.525, -0.779, -1.207)],\n [\"O\", 3, (0.626, 1.062, -0.000)],\n [\"CG\", 4, (0.615, 1.393, 0.000)],\n [\"CD\", 5, (0.587, 1.399, -0.000)],\n [\"NE2\", 6, (0.593, -1.189, -0.001)],\n [\"OE1\", 6, (0.634, 1.060, 0.000)],\n ],\n \"GLU\": [\n [\"N\", 0, (-0.528, 1.361, 0.000)],\n [\"CA\", 0, (0.000, 0.000, 0.000)],\n [\"C\", 0, (1.526, -0.000, -0.000)],\n [\"CB\", 0, (-0.526, -0.781, -1.207)],\n [\"O\", 3, (0.626, 1.062, 0.000)],\n [\"CG\", 4, (0.615, 1.392, 0.000)],\n [\"CD\", 5, (0.600, 1.397, 0.000)],\n [\"OE1\", 6, (0.607, 1.095, -0.000)],\n [\"OE2\", 6, (0.589, -1.104, -0.001)],\n ],\n \"GLY\": [\n [\"N\", 0, (-0.572, 1.337, 0.000)],\n [\"CA\", 0, (0.000, 0.000, 0.000)],\n [\"C\", 0, (1.517, -0.000, -0.000)],\n [\"O\", 3, (0.626, 1.062, -0.000)],\n ],\n \"HIS\": [\n [\"N\", 0, (-0.527, 1.360, 0.000)],\n [\"CA\", 0, (0.000, 0.000, 0.000)],\n [\"C\", 0, (1.525, 0.000, 0.000)],\n [\"CB\", 0, (-0.525, -0.778, -1.208)],\n [\"O\", 3, (0.625, 1.063, 0.000)],\n [\"CG\", 4, (0.600, 1.370, -0.000)],\n [\"CD2\", 5, (0.889, -1.021, 0.003)],\n [\"ND1\", 5, (0.744, 1.160, -0.000)],\n [\"CE1\", 5, (2.030, 0.851, 0.002)],\n [\"NE2\", 5, (2.145, -0.466, 0.004)],\n ],\n \"ILE\": [\n [\"N\", 0, (-0.493, 1.373, -0.000)],\n [\"CA\", 0, (0.000, 0.000, 0.000)],\n [\"C\", 0, (1.527, -0.000, -0.000)],\n [\"CB\", 0, (-0.536, -0.793, -1.213)],\n [\"O\", 3, (0.627, 1.062, -0.000)],\n [\"CG1\", 4, (0.534, 1.437, -0.000)],\n [\"CG2\", 4, (0.540, -0.785, -1.199)],\n [\"CD1\", 5, (0.619, 1.391, 0.000)],\n ],\n \"LEU\": [\n [\"N\", 0, (-0.520, 1.363, 0.000)],\n [\"CA\", 0, (0.000, 0.000, 0.000)],\n [\"C\", 0, (1.525, -0.000, -0.000)],\n [\"CB\", 0, (-0.522, -0.773, -1.214)],\n [\"O\", 3, (0.625, 1.063, -0.000)],\n [\"CG\", 4, (0.678, 1.371, 0.000)],\n [\"CD1\", 5, (0.530, 1.430, -0.000)],\n [\"CD2\", 5, (0.535, -0.774, 1.200)],\n ],\n \"LYS\": [\n [\"N\", 0, (-0.526, 1.362, -0.000)],\n [\"CA\", 0, (0.000, 0.000, 0.000)],\n [\"C\", 0, (1.526, 0.000, 0.000)],\n [\"CB\", 0, (-0.524, -0.778, -1.208)],\n [\"O\", 3, (0.626, 1.062, -0.000)],\n [\"CG\", 4, (0.619, 1.390, 0.000)],\n [\"CD\", 5, (0.559, 1.417, 0.000)],\n [\"CE\", 6, (0.560, 1.416, 0.000)],\n [\"NZ\", 7, (0.554, 1.387, 0.000)],\n ],\n \"MET\": [\n [\"N\", 0, (-0.521, 1.364, -0.000)],\n [\"CA\", 0, (0.000, 0.000, 0.000)],\n [\"C\", 0, (1.525, 0.000, 0.000)],\n [\"CB\", 0, (-0.523, -0.776, -1.210)],\n [\"O\", 3, (0.625, 1.062, -0.000)],\n [\"CG\", 4, (0.613, 1.391, -0.000)],\n [\"SD\", 5, (0.703, 1.695, 0.000)],\n [\"CE\", 6, (0.320, 1.786, -0.000)],\n ],\n \"PHE\": [\n [\"N\", 0, (-0.518, 1.363, 0.000)],\n [\"CA\", 0, (0.000, 0.000, 0.000)],\n [\"C\", 0, (1.524, 0.000, -0.000)],\n [\"CB\", 0, (-0.525, -0.776, -1.212)],\n [\"O\", 3, (0.626, 1.062, -0.000)],\n [\"CG\", 4, (0.607, 1.377, 0.000)],\n [\"CD1\", 5, (0.709, 1.195, -0.000)],\n [\"CD2\", 5, (0.706, -1.196, 0.000)],\n [\"CE1\", 5, (2.102, 1.198, -0.000)],\n [\"CE2\", 5, (2.098, -1.201, -0.000)],\n [\"CZ\", 5, (2.794, -0.003, -0.001)],\n ],\n \"PRO\": [\n [\"N\", 0, (-0.566, 1.351, -0.000)],\n [\"CA\", 0, (0.000, 0.000, 0.000)],\n [\"C\", 0, (1.527, -0.000, 0.000)],\n [\"CB\", 0, (-0.546, -0.611, -1.293)],\n [\"O\", 3, (0.621, 1.066, 0.000)],\n [\"CG\", 4, (0.382, 1.445, 0.0)],\n # ['CD', 5, (0.427, 1.440, 0.0)],\n [\"CD\", 5, (0.477, 1.424, 0.0)], # manually made angle 2 degrees larger\n ],\n \"SER\": [\n [\"N\", 0, (-0.529, 1.360, -0.000)],\n [\"CA\", 0, (0.000, 0.000, 0.000)],\n [\"C\", 0, (1.525, -0.000, -0.000)],\n [\"CB\", 0, (-0.518, -0.777, -1.211)],\n [\"O\", 3, (0.626, 1.062, -0.000)],\n [\"OG\", 4, (0.503, 1.325, 0.000)],\n ],\n \"THR\": [\n [\"N\", 0, (-0.517, 1.364, 0.000)],\n [\"CA\", 0, (0.000, 0.000, 0.000)],\n [\"C\", 0, (1.526, 0.000, -0.000)],\n [\"CB\", 0, (-0.516, -0.793, -1.215)],\n [\"O\", 3, (0.626, 1.062, 0.000)],\n [\"CG2\", 4, (0.550, -0.718, -1.228)],\n [\"OG1\", 4, (0.472, 1.353, 0.000)],\n ],\n \"TRP\": [\n [\"N\", 0, (-0.521, 1.363, 0.000)],\n [\"CA\", 0, (0.000, 0.000, 0.000)],\n [\"C\", 0, (1.525, -0.000, 0.000)],\n [\"CB\", 0, (-0.523, -0.776, -1.212)],\n [\"O\", 3, (0.627, 1.062, 0.000)],\n [\"CG\", 4, (0.609, 1.370, -0.000)],\n [\"CD1\", 5, (0.824, 1.091, 0.000)],\n [\"CD2\", 5, (0.854, -1.148, -0.005)],\n [\"CE2\", 5, (2.186, -0.678, -0.007)],\n [\"CE3\", 5, (0.622, -2.530, -0.007)],\n [\"NE1\", 5, (2.140, 0.690, -0.004)],\n [\"CH2\", 5, (3.028, -2.890, -0.013)],\n [\"CZ2\", 5, (3.283, -1.543, -0.011)],\n [\"CZ3\", 5, (1.715, -3.389, -0.011)],\n ],\n \"TYR\": [\n [\"N\", 0, (-0.522, 1.362, 0.000)],\n [\"CA\", 0, (0.000, 0.000, 0.000)],\n [\"C\", 0, (1.524, -0.000, -0.000)],\n [\"CB\", 0, (-0.522, -0.776, -1.213)],\n [\"O\", 3, (0.627, 1.062, -0.000)],\n [\"CG\", 4, (0.607, 1.382, -0.000)],\n [\"CD1\", 5, (0.716, 1.195, -0.000)],\n [\"CD2\", 5, (0.713, -1.194, -0.001)],\n [\"CE1\", 5, (2.107, 1.200, -0.002)],\n [\"CE2\", 5, (2.104, -1.201, -0.003)],\n [\"OH\", 5, (4.168, -0.002, -0.005)],\n [\"CZ\", 5, (2.791, -0.001, -0.003)],\n ],\n \"VAL\": [\n [\"N\", 0, (-0.494, 1.373, -0.000)],\n [\"CA\", 0, (0.000, 0.000, 0.000)],\n [\"C\", 0, (1.527, -0.000, -0.000)],\n [\"CB\", 0, (-0.533, -0.795, -1.213)],\n [\"O\", 3, (0.627, 1.062, -0.000)],\n [\"CG1\", 4, (0.540, 1.429, -0.000)],\n [\"CG2\", 4, (0.533, -0.776, 1.203)],\n ],\n}\n\n# A list of atoms (excluding hydrogen) for each AA type. PDB naming convention.\nresidue_atoms = {\n \"ALA\": [\"C\", \"CA\", \"CB\", \"N\", \"O\"],\n \"ARG\": [\"C\", \"CA\", \"CB\", \"CG\", \"CD\", \"CZ\", \"N\", \"NE\", \"O\", \"NH1\", \"NH2\"],\n \"ASP\": [\"C\", \"CA\", \"CB\", \"CG\", \"N\", \"O\", \"OD1\", \"OD2\"],\n \"ASN\": [\"C\", \"CA\", \"CB\", \"CG\", \"N\", \"ND2\", \"O\", \"OD1\"],\n \"CYS\": [\"C\", \"CA\", \"CB\", \"N\", \"O\", \"SG\"],\n \"GLU\": [\"C\", \"CA\", \"CB\", \"CG\", \"CD\", \"N\", \"O\", \"OE1\", \"OE2\"],\n \"GLN\": [\"C\", \"CA\", \"CB\", \"CG\", \"CD\", \"N\", \"NE2\", \"O\", \"OE1\"],\n \"GLY\": [\"C\", \"CA\", \"N\", \"O\"],\n \"HIS\": [\"C\", \"CA\", \"CB\", \"CG\", \"CD2\", \"CE1\", \"N\", \"ND1\", \"NE2\", \"O\"],\n \"ILE\": [\"C\", \"CA\", \"CB\", \"CG1\", \"CG2\", \"CD1\", \"N\", \"O\"],\n \"LEU\": [\"C\", \"CA\", \"CB\", \"CG\", \"CD1\", \"CD2\", \"N\", \"O\"],\n \"LYS\": [\"C\", \"CA\", \"CB\", \"CG\", \"CD\", \"CE\", \"N\", \"NZ\", \"O\"],\n \"MET\": [\"C\", \"CA\", \"CB\", \"CG\", \"CE\", \"N\", \"O\", \"SD\"],\n \"PHE\": [\"C\", \"CA\", \"CB\", \"CG\", \"CD1\", \"CD2\", \"CE1\", \"CE2\", \"CZ\", \"N\", \"O\"],\n \"PRO\": [\"C\", \"CA\", \"CB\", \"CG\", \"CD\", \"N\", \"O\"],\n \"SER\": [\"C\", \"CA\", \"CB\", \"N\", \"O\", \"OG\"],\n \"THR\": [\"C\", \"CA\", \"CB\", \"CG2\", \"N\", \"O\", \"OG1\"],\n \"TRP\": [\n \"C\",\n \"CA\",\n \"CB\",\n \"CG\",\n \"CD1\",\n \"CD2\",\n \"CE2\",\n \"CE3\",\n \"CZ2\",\n \"CZ3\",\n \"CH2\",\n \"N\",\n \"NE1\",\n \"O\",\n ],\n \"TYR\": [\n \"C\",\n \"CA\",\n \"CB\",\n \"CG\",\n \"CD1\",\n \"CD2\",\n \"CE1\",\n \"CE2\",\n \"CZ\",\n \"N\",\n \"O\",\n \"OH\",\n ],\n \"VAL\": [\"C\", \"CA\", \"CB\", \"CG1\", \"CG2\", \"N\", \"O\"],\n}\n\n# Naming swaps for ambiguous atom names.\n# Due to symmetries in the amino acids the naming of atoms is ambiguous in\n# 4 of the 20 amino acids.\n# (The LDDT paper lists 7 amino acids as ambiguous, but the naming ambiguities\n# in LEU, VAL and ARG can be resolved by using the 3d constellations of\n# the 'ambiguous' atoms and their neighbours)\n# TODO: ^ interpret this\nresidue_atom_renaming_swaps = {\n \"ASP\": {\"OD1\": \"OD2\"},\n \"GLU\": {\"OE1\": \"OE2\"},\n \"PHE\": {\"CD1\": \"CD2\", \"CE1\": \"CE2\"},\n \"TYR\": {\"CD1\": \"CD2\", \"CE1\": \"CE2\"},\n}\n\n# Van der Waals radii [Angstroem] of the atoms (from Wikipedia)\nvan_der_waals_radius = {\n \"C\": 1.7,\n \"N\": 1.55,\n \"O\": 1.52,\n \"S\": 1.8,\n}\n\nBond = collections.namedtuple(\n \"Bond\", [\"atom1_name\", \"atom2_name\", \"length\", \"stddev\"]\n)\nBondAngle = collections.namedtuple(\n \"BondAngle\",\n [\"atom1_name\", \"atom2_name\", \"atom3name\", \"angle_rad\", \"stddev\"],\n)\n\n\n@functools.lru_cache(maxsize=None)\ndef load_stereo_chemical_props() -> Tuple[\n Mapping[str, List[Bond]],\n Mapping[str, List[Bond]],\n Mapping[str, List[BondAngle]],\n]:\n \"\"\"Load stereo_chemical_props.txt into a nice structure.\n\n Load literature values for bond lengths and bond angles and translate\n bond angles into the length of the opposite edge of the triangle\n (\"residue_virtual_bonds\").\n\n Returns:\n residue_bonds: dict that maps resname --> list of Bond tuples\n residue_virtual_bonds: dict that maps resname --> list of Bond tuples\n residue_bond_angles: dict that maps resname --> list of BondAngle tuples\n \"\"\"\n # TODO: this file should be downloaded in a setup script\n stereo_chemical_props_path = \"openfold/resources/stereo_chemical_props.txt\"\n with open(stereo_chemical_props_path, \"rt\") as f:\n stereo_chemical_props = f.read()\n lines_iter = iter(stereo_chemical_props.splitlines())\n # Load bond lengths.\n residue_bonds = {}\n next(lines_iter) # Skip header line.\n for line in lines_iter:\n if line.strip() == \"-\":\n break\n bond, resname, length, stddev = line.split()\n atom1, atom2 = bond.split(\"-\")\n if resname not in residue_bonds:\n residue_bonds[resname] = []\n residue_bonds[resname].append(\n Bond(atom1, atom2, float(length), float(stddev))\n )\n residue_bonds[\"UNK\"] = []\n\n # Load bond angles.\n residue_bond_angles = {}\n next(lines_iter) # Skip empty line.\n next(lines_iter) # Skip header line.\n for line in lines_iter:\n if line.strip() == \"-\":\n break\n bond, resname, angle_degree, stddev_degree = line.split()\n atom1, atom2, atom3 = bond.split(\"-\")\n if resname not in residue_bond_angles:\n residue_bond_angles[resname] = []\n residue_bond_angles[resname].append(\n BondAngle(\n atom1,\n atom2,\n atom3,\n float(angle_degree) / 180.0 * np.pi,\n float(stddev_degree) / 180.0 * np.pi,\n )\n )\n residue_bond_angles[\"UNK\"] = []\n\n def make_bond_key(atom1_name, atom2_name):\n \"\"\"Unique key to lookup bonds.\"\"\"\n return \"-\".join(sorted([atom1_name, atom2_name]))\n\n # Translate bond angles into distances (\"virtual bonds\").\n residue_virtual_bonds = {}\n for resname, bond_angles in residue_bond_angles.items():\n # Create a fast lookup dict for bond lengths.\n bond_cache = {}\n for b in residue_bonds[resname]:\n bond_cache[make_bond_key(b.atom1_name, b.atom2_name)] = b\n residue_virtual_bonds[resname] = []\n for ba in bond_angles:\n bond1 = bond_cache[make_bond_key(ba.atom1_name, ba.atom2_name)]\n bond2 = bond_cache[make_bond_key(ba.atom2_name, ba.atom3name)]\n\n # Compute distance between atom1 and atom3 using the law of cosines\n # c^2 = a^2 + b^2 - 2ab*cos(gamma).\n gamma = ba.angle_rad\n length = np.sqrt(\n bond1.length ** 2\n + bond2.length ** 2\n - 2 * bond1.length * bond2.length * np.cos(gamma)\n )\n\n # Propagation of uncertainty assuming uncorrelated errors.\n dl_outer = 0.5 / length\n dl_dgamma = (\n 2 * bond1.length * bond2.length * np.sin(gamma)\n ) * dl_outer\n dl_db1 = (\n 2 * bond1.length - 2 * bond2.length * np.cos(gamma)\n ) * dl_outer\n dl_db2 = (\n 2 * bond2.length - 2 * bond1.length * np.cos(gamma)\n ) * dl_outer\n stddev = np.sqrt(\n (dl_dgamma * ba.stddev) ** 2\n + (dl_db1 * bond1.stddev) ** 2\n + (dl_db2 * bond2.stddev) ** 2\n )\n residue_virtual_bonds[resname].append(\n Bond(ba.atom1_name, ba.atom3name, length, stddev)\n )\n\n return (residue_bonds, residue_virtual_bonds, residue_bond_angles)\n\n\n# Between-residue bond lengths for general bonds (first element) and for Proline\n# (second element).\nbetween_res_bond_length_c_n = [1.329, 1.341]\nbetween_res_bond_length_stddev_c_n = [0.014, 0.016]\n\n# Between-residue cos_angles.\nbetween_res_cos_angles_c_n_ca = [-0.5203, 0.0353] # degrees: 121.352 +- 2.315\nbetween_res_cos_angles_ca_c_n = [-0.4473, 0.0311] # degrees: 116.568 +- 1.995\n\n# This mapping is used when we need to store atom data in a format that requires\n# fixed atom data size for every residue (e.g. a numpy array).\natom_types = [\n \"N\",\n \"CA\",\n \"C\",\n \"CB\",\n \"O\",\n \"CG\",\n \"CG1\",\n \"CG2\",\n \"OG\",\n \"OG1\",\n \"SG\",\n \"CD\",\n \"CD1\",\n \"CD2\",\n \"ND1\",\n \"ND2\",\n \"OD1\",\n \"OD2\",\n \"SD\",\n \"CE\",\n \"CE1\",\n \"CE2\",\n \"CE3\",\n \"NE\",\n \"NE1\",\n \"NE2\",\n \"OE1\",\n \"OE2\",\n \"CH2\",\n \"NH1\",\n \"NH2\",\n \"OH\",\n \"CZ\",\n \"CZ2\",\n \"CZ3\",\n \"NZ\",\n \"OXT\",\n]\natom_order = {atom_type: i for i, atom_type in enumerate(atom_types)}\natom_type_num = len(atom_types) # := 37.\n\n# A compact atom encoding with 14 columns\n# pylint: disable=line-too-long\n# pylint: disable=bad-whitespace\nrestype_name_to_atom14_names = {\n \"ALA\": [\"N\", \"CA\", \"C\", \"O\", \"CB\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\"],\n \"ARG\": [\n \"N\",\n \"CA\",\n \"C\",\n \"O\",\n \"CB\",\n \"CG\",\n \"CD\",\n \"NE\",\n \"CZ\",\n \"NH1\",\n \"NH2\",\n \"\",\n \"\",\n \"\",\n ],\n \"ASN\": [\n \"N\",\n \"CA\",\n \"C\",\n \"O\",\n \"CB\",\n \"CG\",\n \"OD1\",\n \"ND2\",\n \"\",\n \"\",\n \"\",\n \"\",\n \"\",\n \"\",\n ],\n \"ASP\": [\n \"N\",\n \"CA\",\n \"C\",\n \"O\",\n \"CB\",\n \"CG\",\n \"OD1\",\n \"OD2\",\n \"\",\n \"\",\n \"\",\n \"\",\n \"\",\n \"\",\n ],\n \"CYS\": [\"N\", \"CA\", \"C\", \"O\", \"CB\", \"SG\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\"],\n \"GLN\": [\n \"N\",\n \"CA\",\n \"C\",\n \"O\",\n \"CB\",\n \"CG\",\n \"CD\",\n \"OE1\",\n \"NE2\",\n \"\",\n \"\",\n \"\",\n \"\",\n \"\",\n ],\n \"GLU\": [\n \"N\",\n \"CA\",\n \"C\",\n \"O\",\n \"CB\",\n \"CG\",\n \"CD\",\n \"OE1\",\n \"OE2\",\n \"\",\n \"\",\n \"\",\n \"\",\n \"\",\n ],\n \"GLY\": [\"N\", \"CA\", \"C\", \"O\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\"],\n \"HIS\": [\n \"N\",\n \"CA\",\n \"C\",\n \"O\",\n \"CB\",\n \"CG\",\n \"ND1\",\n \"CD2\",\n \"CE1\",\n \"NE2\",\n \"\",\n \"\",\n \"\",\n \"\",\n ],\n \"ILE\": [\n \"N\",\n \"CA\",\n \"C\",\n \"O\",\n \"CB\",\n \"CG1\",\n \"CG2\",\n \"CD1\",\n \"\",\n \"\",\n \"\",\n \"\",\n \"\",\n \"\",\n ],\n \"LEU\": [\n \"N\",\n \"CA\",\n \"C\",\n \"O\",\n \"CB\",\n \"CG\",\n \"CD1\",\n \"CD2\",\n \"\",\n \"\",\n \"\",\n \"\",\n \"\",\n \"\",\n ],\n \"LYS\": [\n \"N\",\n \"CA\",\n \"C\",\n \"O\",\n \"CB\",\n \"CG\",\n \"CD\",\n \"CE\",\n \"NZ\",\n \"\",\n \"\",\n \"\",\n \"\",\n \"\",\n ],\n \"MET\": [\n \"N\",\n \"CA\",\n \"C\",\n \"O\",\n \"CB\",\n \"CG\",\n \"SD\",\n \"CE\",\n \"\",\n \"\",\n \"\",\n \"\",\n \"\",\n \"\",\n ],\n \"PHE\": [\n \"N\",\n \"CA\",\n \"C\",\n \"O\",\n \"CB\",\n \"CG\",\n \"CD1\",\n \"CD2\",\n \"CE1\",\n \"CE2\",\n \"CZ\",\n \"\",\n \"\",\n \"\",\n ],\n \"PRO\": [\"N\", \"CA\", \"C\", \"O\", \"CB\", \"CG\", \"CD\", \"\", \"\", \"\", \"\", \"\", \"\", \"\"],\n \"SER\": [\"N\", \"CA\", \"C\", \"O\", \"CB\", \"OG\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\"],\n \"THR\": [\n \"N\",\n \"CA\",\n \"C\",\n \"O\",\n \"CB\",\n \"OG1\",\n \"CG2\",\n \"\",\n \"\",\n \"\",\n \"\",\n \"\",\n \"\",\n \"\",\n ],\n \"TRP\": [\n \"N\",\n \"CA\",\n \"C\",\n \"O\",\n \"CB\",\n \"CG\",\n \"CD1\",\n \"CD2\",\n \"NE1\",\n \"CE2\",\n \"CE3\",\n \"CZ2\",\n \"CZ3\",\n \"CH2\",\n ],\n \"TYR\": [\n \"N\",\n \"CA\",\n \"C\",\n \"O\",\n \"CB\",\n \"CG\",\n \"CD1\",\n \"CD2\",\n \"CE1\",\n \"CE2\",\n \"CZ\",\n \"OH\",\n \"\",\n \"\",\n ],\n \"VAL\": [\n \"N\",\n \"CA\",\n \"C\",\n \"O\",\n \"CB\",\n \"CG1\",\n \"CG2\",\n \"\",\n \"\",\n \"\",\n \"\",\n \"\",\n \"\",\n \"\",\n ],\n \"UNK\": [\"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\"],\n}\n# pylint: enable=line-too-long\n# pylint: enable=bad-whitespace\n\n\n# This is the standard residue order when coding AA type as a number.\n# Reproduce it by taking 3-letter AA codes and sorting them alphabetically.\nrestypes = [\n \"A\",\n \"R\",\n \"N\",\n \"D\",\n \"C\",\n \"Q\",\n \"E\",\n \"G\",\n \"H\",\n \"I\",\n \"L\",\n \"K\",\n \"M\",\n \"F\",\n \"P\",\n \"S\",\n \"T\",\n \"W\",\n \"Y\",\n \"V\",\n]\nrestype_order = {restype: i for i, restype in enumerate(restypes)}\nrestype_num = len(restypes) # := 20.\nunk_restype_index = restype_num # Catch-all index for unknown restypes.\n\nrestypes_with_x = restypes + [\"X\"]\nrestype_order_with_x = {restype: i for i, restype in enumerate(restypes_with_x)}\n\n\ndef sequence_to_onehot(\n sequence: str, mapping: Mapping[str, int], map_unknown_to_x: bool = False\n) -> np.ndarray:\n \"\"\"Maps the given sequence into a one-hot encoded matrix.\n\n Args:\n sequence: An amino acid sequence.\n mapping: A dictionary mapping amino acids to integers.\n map_unknown_to_x: If True, any amino acid that is not in the mapping will be\n mapped to the unknown amino acid 'X'. If the mapping doesn't contain\n amino acid 'X', an error will be thrown. If False, any amino acid not in\n the mapping will throw an error.\n\n Returns:\n A numpy array of shape (seq_len, num_unique_aas) with one-hot encoding of\n the sequence.\n\n Raises:\n ValueError: If the mapping doesn't contain values from 0 to\n num_unique_aas - 1 without any gaps.\n \"\"\"\n num_entries = max(mapping.values()) + 1\n\n if sorted(set(mapping.values())) != list(range(num_entries)):\n raise ValueError(\n \"The mapping must have values from 0 to num_unique_aas-1 \"\n \"without any gaps. Got: %s\" % sorted(mapping.values())\n )\n\n one_hot_arr = np.zeros((len(sequence), num_entries), dtype=np.int32)\n\n for aa_index, aa_type in enumerate(sequence):\n if map_unknown_to_x:\n if aa_type.isalpha() and aa_type.isupper():\n aa_id = mapping.get(aa_type, mapping[\"X\"])\n else:\n raise ValueError(\n f\"Invalid character in the sequence: {aa_type}\"\n )\n else:\n aa_id = mapping[aa_type]\n one_hot_arr[aa_index, aa_id] = 1\n\n return one_hot_arr\n\n\nrestype_1to3 = {\n \"A\": \"ALA\",\n \"R\": \"ARG\",\n \"N\": \"ASN\",\n \"D\": \"ASP\",\n \"C\": \"CYS\",\n \"Q\": \"GLN\",\n \"E\": \"GLU\",\n \"G\": \"GLY\",\n \"H\": \"HIS\",\n \"I\": \"ILE\",\n \"L\": \"LEU\",\n \"K\": \"LYS\",\n \"M\": \"MET\",\n \"F\": \"PHE\",\n \"P\": \"PRO\",\n \"S\": \"SER\",\n \"T\": \"THR\",\n \"W\": \"TRP\",\n \"Y\": \"TYR\",\n \"V\": \"VAL\",\n}\n\n\n# NB: restype_3to1 differs from Bio.PDB.protein_letters_3to1 by being a simple\n# 1-to-1 mapping of 3 letter names to one letter names. The latter contains\n# many more, and less common, three letter names as keys and maps many of these\n# to the same one letter name (including 'X' and 'U' which we don't use here).\nrestype_3to1 = {v: k for k, v in restype_1to3.items()}\n\n# Define a restype name for all unknown residues.\nunk_restype = \"UNK\"\n\nresnames = [restype_1to3[r] for r in restypes] + [unk_restype]\nresname_to_idx = {resname: i for i, resname in enumerate(resnames)}\n\n\n# The mapping here uses hhblits convention, so that B is mapped to D, J and O\n# are mapped to X, U is mapped to C, and Z is mapped to E. Other than that the\n# remaining 20 amino acids are kept in alphabetical order.\n# There are 2 non-amino acid codes, X (representing any amino acid) and\n# \"-\" representing a missing amino acid in an alignment. The id for these\n# codes is put at the end (20 and 21) so that they can easily be ignored if\n# desired.\nHHBLITS_AA_TO_ID = {\n \"A\": 0,\n \"B\": 2,\n \"C\": 1,\n \"D\": 2,\n \"E\": 3,\n \"F\": 4,\n \"G\": 5,\n \"H\": 6,\n \"I\": 7,\n \"J\": 20,\n \"K\": 8,\n \"L\": 9,\n \"M\": 10,\n \"N\": 11,\n \"O\": 20,\n \"P\": 12,\n \"Q\": 13,\n \"R\": 14,\n \"S\": 15,\n \"T\": 16,\n \"U\": 1,\n \"V\": 17,\n \"W\": 18,\n \"X\": 20,\n \"Y\": 19,\n \"Z\": 3,\n \"-\": 21,\n}\n\n# Partial inversion of HHBLITS_AA_TO_ID.\nID_TO_HHBLITS_AA = {\n 0: \"A\",\n 1: \"C\", # Also U.\n 2: \"D\", # Also B.\n 3: \"E\", # Also Z.\n 4: \"F\",\n 5: \"G\",\n 6: \"H\",\n 7: \"I\",\n 8: \"K\",\n 9: \"L\",\n 10: \"M\",\n 11: \"N\",\n 12: \"P\",\n 13: \"Q\",\n 14: \"R\",\n 15: \"S\",\n 16: \"T\",\n 17: \"V\",\n 18: \"W\",\n 19: \"Y\",\n 20: \"X\", # Includes J and O.\n 21: \"-\",\n}\n\nrestypes_with_x_and_gap = restypes + [\"X\", \"-\"]\nMAP_HHBLITS_AATYPE_TO_OUR_AATYPE = tuple(\n restypes_with_x_and_gap.index(ID_TO_HHBLITS_AA[i])\n for i in range(len(restypes_with_x_and_gap))\n)\n\n\ndef _make_standard_atom_mask() -> np.ndarray:\n \"\"\"Returns [num_res_types, num_atom_types] mask array.\"\"\"\n # +1 to account for unknown (all 0s).\n mask = np.zeros([restype_num + 1, atom_type_num], dtype=np.int32)\n for restype, restype_letter in enumerate(restypes):\n restype_name = restype_1to3[restype_letter]\n atom_names = residue_atoms[restype_name]\n for atom_name in atom_names:\n atom_type = atom_order[atom_name]\n mask[restype, atom_type] = 1\n return mask\n\n\nSTANDARD_ATOM_MASK = _make_standard_atom_mask()\n\n\n# A one hot representation for the first and second atoms defining the axis\n# of rotation for each chi-angle in each residue.\ndef chi_angle_atom(atom_index: int) -> np.ndarray:\n \"\"\"Define chi-angle rigid groups via one-hot representations.\"\"\"\n chi_angles_index = {}\n one_hots = []\n\n for k, v in chi_angles_atoms.items():\n indices = [atom_types.index(s[atom_index]) for s in v]\n indices.extend([-1] * (4 - len(indices)))\n chi_angles_index[k] = indices\n\n for r in restypes:\n res3 = restype_1to3[r]\n one_hot = np.eye(atom_type_num)[chi_angles_index[res3]]\n one_hots.append(one_hot)\n\n one_hots.append(np.zeros([4, atom_type_num])) # Add zeros for residue `X`.\n one_hot = np.stack(one_hots, axis=0)\n one_hot = np.transpose(one_hot, [0, 2, 1])\n\n return one_hot\n\n\nchi_atom_1_one_hot = chi_angle_atom(1)\nchi_atom_2_one_hot = chi_angle_atom(2)\n\n# An array like chi_angles_atoms but using indices rather than names.\nchi_angles_atom_indices = [chi_angles_atoms[restype_1to3[r]] for r in restypes]\nchi_angles_atom_indices = tree.map_structure(\n lambda atom_name: atom_order[atom_name], chi_angles_atom_indices\n)\nchi_angles_atom_indices = np.array(\n [\n chi_atoms + ([[0, 0, 0, 0]] * (4 - len(chi_atoms)))\n for chi_atoms in chi_angles_atom_indices\n ]\n)\n\n# Mapping from (res_name, atom_name) pairs to the atom's chi group index\n# and atom index within that group.\nchi_groups_for_atom = collections.defaultdict(list)\nfor res_name, chi_angle_atoms_for_res in chi_angles_atoms.items():\n for chi_group_i, chi_group in enumerate(chi_angle_atoms_for_res):\n for atom_i, atom in enumerate(chi_group):\n chi_groups_for_atom[(res_name, atom)].append((chi_group_i, atom_i))\nchi_groups_for_atom = dict(chi_groups_for_atom)\n\n\ndef _make_rigid_transformation_4x4(ex, ey, translation):\n \"\"\"Create a rigid 4x4 transformation matrix from two axes and transl.\"\"\"\n # Normalize ex.\n ex_normalized = ex / np.linalg.norm(ex)\n\n # make ey perpendicular to ex\n ey_normalized = ey - np.dot(ey, ex_normalized) * ex_normalized\n ey_normalized /= np.linalg.norm(ey_normalized)\n\n # compute ez as cross product\n eznorm = np.cross(ex_normalized, ey_normalized)\n m = np.stack(\n [ex_normalized, ey_normalized, eznorm, translation]\n ).transpose()\n m = np.concatenate([m, [[0.0, 0.0, 0.0, 1.0]]], axis=0)\n return m\n\n\n# create an array with (restype, atomtype) --> rigid_group_idx\n# and an array with (restype, atomtype, coord) for the atom positions\n# and compute affine transformation matrices (4,4) from one rigid group to the\n# previous group\nrestype_atom37_to_rigid_group = np.zeros([21, 37], dtype=np.int)\nrestype_atom37_mask = np.zeros([21, 37], dtype=np.float32)\nrestype_atom37_rigid_group_positions = np.zeros([21, 37, 3], dtype=np.float32)\nrestype_atom14_to_rigid_group = np.zeros([21, 14], dtype=np.int)\nrestype_atom14_mask = np.zeros([21, 14], dtype=np.float32)\nrestype_atom14_rigid_group_positions = np.zeros([21, 14, 3], dtype=np.float32)\nrestype_rigid_group_default_frame = np.zeros([21, 8, 4, 4], dtype=np.float32)\n\n\ndef _make_rigid_group_constants():\n \"\"\"Fill the arrays above.\"\"\"\n for restype, restype_letter in enumerate(restypes):\n resname = restype_1to3[restype_letter]\n for atomname, group_idx, atom_position in rigid_group_atom_positions[\n resname\n ]:\n atomtype = atom_order[atomname]\n restype_atom37_to_rigid_group[restype, atomtype] = group_idx\n restype_atom37_mask[restype, atomtype] = 1\n restype_atom37_rigid_group_positions[\n restype, atomtype, :\n ] = atom_position\n\n atom14idx = restype_name_to_atom14_names[resname].index(atomname)\n restype_atom14_to_rigid_group[restype, atom14idx] = group_idx\n restype_atom14_mask[restype, atom14idx] = 1\n restype_atom14_rigid_group_positions[\n restype, atom14idx, :\n ] = atom_position\n\n for restype, restype_letter in enumerate(restypes):\n resname = restype_1to3[restype_letter]\n atom_positions = {\n name: np.array(pos)\n for name, _, pos in rigid_group_atom_positions[resname]\n }\n\n # backbone to backbone is the identity transform\n restype_rigid_group_default_frame[restype, 0, :, :] = np.eye(4)\n\n # pre-omega-frame to backbone (currently dummy identity matrix)\n restype_rigid_group_default_frame[restype, 1, :, :] = np.eye(4)\n\n # phi-frame to backbone\n mat = _make_rigid_transformation_4x4(\n ex=atom_positions[\"N\"] - atom_positions[\"CA\"],\n ey=np.array([1.0, 0.0, 0.0]),\n translation=atom_positions[\"N\"],\n )\n restype_rigid_group_default_frame[restype, 2, :, :] = mat\n\n # psi-frame to backbone\n mat = _make_rigid_transformation_4x4(\n ex=atom_positions[\"C\"] - atom_positions[\"CA\"],\n ey=atom_positions[\"CA\"] - atom_positions[\"N\"],\n translation=atom_positions[\"C\"],\n )\n restype_rigid_group_default_frame[restype, 3, :, :] = mat\n\n # chi1-frame to backbone\n if chi_angles_mask[restype][0]:\n base_atom_names = chi_angles_atoms[resname][0]\n base_atom_positions = [\n atom_positions[name] for name in base_atom_names\n ]\n mat = _make_rigid_transformation_4x4(\n ex=base_atom_positions[2] - base_atom_positions[1],\n ey=base_atom_positions[0] - base_atom_positions[1],\n translation=base_atom_positions[2],\n )\n restype_rigid_group_default_frame[restype, 4, :, :] = mat\n\n # chi2-frame to chi1-frame\n # chi3-frame to chi2-frame\n # chi4-frame to chi3-frame\n # luckily all rotation axes for the next frame start at (0,0,0) of the\n # previous frame\n for chi_idx in range(1, 4):\n if chi_angles_mask[restype][chi_idx]:\n axis_end_atom_name = chi_angles_atoms[resname][chi_idx][2]\n axis_end_atom_position = atom_positions[axis_end_atom_name]\n mat = _make_rigid_transformation_4x4(\n ex=axis_end_atom_position,\n ey=np.array([-1.0, 0.0, 0.0]),\n translation=axis_end_atom_position,\n )\n restype_rigid_group_default_frame[\n restype, 4 + chi_idx, :, :\n ] = mat\n\n\n_make_rigid_group_constants()\n\n\ndef make_atom14_dists_bounds(\n overlap_tolerance=1.5, bond_length_tolerance_factor=15\n):\n \"\"\"compute upper and lower bounds for bonds to assess violations.\"\"\"\n restype_atom14_bond_lower_bound = np.zeros([21, 14, 14], np.float32)\n restype_atom14_bond_upper_bound = np.zeros([21, 14, 14], np.float32)\n restype_atom14_bond_stddev = np.zeros([21, 14, 14], np.float32)\n residue_bonds, residue_virtual_bonds, _ = load_stereo_chemical_props()\n for restype, restype_letter in enumerate(restypes):\n resname = restype_1to3[restype_letter]\n atom_list = restype_name_to_atom14_names[resname]\n\n # create lower and upper bounds for clashes\n for atom1_idx, atom1_name in enumerate(atom_list):\n if not atom1_name:\n continue\n atom1_radius = van_der_waals_radius[atom1_name[0]]\n for atom2_idx, atom2_name in enumerate(atom_list):\n if (not atom2_name) or atom1_idx == atom2_idx:\n continue\n atom2_radius = van_der_waals_radius[atom2_name[0]]\n lower = atom1_radius + atom2_radius - overlap_tolerance\n upper = 1e10\n restype_atom14_bond_lower_bound[\n restype, atom1_idx, atom2_idx\n ] = lower\n restype_atom14_bond_lower_bound[\n restype, atom2_idx, atom1_idx\n ] = lower\n restype_atom14_bond_upper_bound[\n restype, atom1_idx, atom2_idx\n ] = upper\n restype_atom14_bond_upper_bound[\n restype, atom2_idx, atom1_idx\n ] = upper\n\n # overwrite lower and upper bounds for bonds and angles\n for b in residue_bonds[resname] + residue_virtual_bonds[resname]:\n atom1_idx = atom_list.index(b.atom1_name)\n atom2_idx = atom_list.index(b.atom2_name)\n lower = b.length - bond_length_tolerance_factor * b.stddev\n upper = b.length + bond_length_tolerance_factor * b.stddev\n restype_atom14_bond_lower_bound[\n restype, atom1_idx, atom2_idx\n ] = lower\n restype_atom14_bond_lower_bound[\n restype, atom2_idx, atom1_idx\n ] = lower\n restype_atom14_bond_upper_bound[\n restype, atom1_idx, atom2_idx\n ] = upper\n restype_atom14_bond_upper_bound[\n restype, atom2_idx, atom1_idx\n ] = upper\n restype_atom14_bond_stddev[restype, atom1_idx, atom2_idx] = b.stddev\n restype_atom14_bond_stddev[restype, atom2_idx, atom1_idx] = b.stddev\n return {\n \"lower_bound\": restype_atom14_bond_lower_bound, # shape (21,14,14)\n \"upper_bound\": restype_atom14_bond_upper_bound, # shape (21,14,14)\n \"stddev\": restype_atom14_bond_stddev, # shape (21,14,14)\n }\n\n\nrestype_atom14_ambiguous_atoms = np.zeros((21, 14), dtype=np.float32)\nrestype_atom14_ambiguous_atoms_swap_idx = np.tile(\n np.arange(14, dtype=np.int), (21, 1)\n)\n\n\ndef _make_atom14_ambiguity_feats():\n for res, pairs in residue_atom_renaming_swaps.items():\n res_idx = restype_order[restype_3to1[res]]\n for atom1, atom2 in pairs.items():\n atom1_idx = restype_name_to_atom14_names[res].index(atom1)\n atom2_idx = restype_name_to_atom14_names[res].index(atom2)\n restype_atom14_ambiguous_atoms[res_idx, atom1_idx] = 1\n restype_atom14_ambiguous_atoms[res_idx, atom2_idx] = 1\n restype_atom14_ambiguous_atoms_swap_idx[\n res_idx, atom1_idx\n ] = atom2_idx\n restype_atom14_ambiguous_atoms_swap_idx[\n res_idx, atom2_idx\n ] = atom1_idx\n\n\n_make_atom14_ambiguity_feats()\n", "meta": {"hexsha": "0a289d27b6f28daccbed1ba4c791c79462f64218", "size": 39486, "ext": "py", "lang": "Python", "max_stars_repo_path": "openfold/np/residue_constants.py", "max_stars_repo_name": "yuzhiguo07/openfold", "max_stars_repo_head_hexsha": "5fb0f074066387b9969578b8bf68f7e046c778af", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-12-16T17:02:10.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-16T17:02:10.000Z", "max_issues_repo_path": "openfold/np/residue_constants.py", "max_issues_repo_name": "yuzhiguo07/openfold", "max_issues_repo_head_hexsha": "5fb0f074066387b9969578b8bf68f7e046c778af", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "openfold/np/residue_constants.py", "max_forks_repo_name": "yuzhiguo07/openfold", "max_forks_repo_head_hexsha": "5fb0f074066387b9969578b8bf68f7e046c778af", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.2806748466, "max_line_length": 82, "alphanum_fraction": 0.4883503014, "include": true, "reason": "import numpy", "num_tokens": 13852, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230157, "lm_q2_score": 0.3665897501624599, "lm_q1q2_score": 0.18902097608368895}} {"text": "\"\"\"\n\n:mod:`meshes` -- Discretization\n===============================\n\nEverything related to meshes appropriate for the multigrid solver.\n\n\"\"\"\n# Copyright 2018-2020 The emg3d Developers.\n#\n# This file is part of emg3d.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\"); you may not\n# use this file except in compliance with the License. You may obtain a copy\n# of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\n# License for the specific language governing permissions and limitations under\n# the License.\n\n\nimport numpy as np\nfrom copy import deepcopy\nfrom scipy import optimize\n\n__all__ = ['TensorMesh', 'get_hx_h0', 'get_cell_numbers', 'get_stretched_h',\n 'get_domain', 'get_hx']\n\n\nclass TensorMesh:\n \"\"\"Rudimentary mesh for multigrid calculation.\n\n The tensor-mesh :class:`discretize.TensorMesh` is a powerful tool,\n including sophisticated mesh-generation possibilities in 1D, 2D, and 3D,\n plotting routines, and much more. However, in the multigrid solver we have\n to generate a mesh at each level, many times over and over again, and we\n only need a very limited set of attributes. This tensor-mesh class provides\n all required attributes. All attributes here are the same as their\n counterparts in :class:`discretize.TensorMesh` (both in name and value).\n\n .. warning::\n This is a slimmed-down version of :class:`discretize.TensorMesh`, meant\n principally for internal use by the multigrid modeller. It is highly\n recommended to use :class:`discretize.TensorMesh` to create the input\n meshes instead of this class. There are no input-checks carried out\n here, and there is only one accepted input format for `h` and `x0`.\n\n\n Parameters\n ----------\n h : list of three ndarrays\n Cell widths in [x, y, z] directions.\n\n x0 : ndarray of dimension (3, )\n Origin (x, y, z).\n\n \"\"\"\n\n def __init__(self, h, x0):\n \"\"\"Initialize the mesh.\"\"\"\n self.x0 = x0\n\n # Width of cells.\n self.hx = h[0]\n self.hy = h[1]\n self.hz = h[2]\n\n # Cell related properties.\n self.nCx = int(self.hx.size)\n self.nCy = int(self.hy.size)\n self.nCz = int(self.hz.size)\n self.vnC = np.array([self.hx.size, self.hy.size, self.hz.size])\n self.nC = int(self.vnC.prod())\n self.vectorCCx = np.r_[0, self.hx[:-1].cumsum()]+self.hx*0.5+self.x0[0]\n self.vectorCCy = np.r_[0, self.hy[:-1].cumsum()]+self.hy*0.5+self.x0[1]\n self.vectorCCz = np.r_[0, self.hz[:-1].cumsum()]+self.hz*0.5+self.x0[2]\n\n # Node related properties.\n self.nNx = self.nCx + 1\n self.nNy = self.nCy + 1\n self.nNz = self.nCz + 1\n self.vnN = np.array([self.nNx, self.nNy, self.nNz], dtype=int)\n self.nN = int(self.vnN.prod())\n self.vectorNx = np.r_[0., self.hx.cumsum()] + self.x0[0]\n self.vectorNy = np.r_[0., self.hy.cumsum()] + self.x0[1]\n self.vectorNz = np.r_[0., self.hz.cumsum()] + self.x0[2]\n\n # Edge related properties.\n self.vnEx = np.array([self.nCx, self.nNy, self.nNz], dtype=int)\n self.vnEy = np.array([self.nNx, self.nCy, self.nNz], dtype=int)\n self.vnEz = np.array([self.nNx, self.nNy, self.nCz], dtype=int)\n self.nEx = int(self.vnEx.prod())\n self.nEy = int(self.vnEy.prod())\n self.nEz = int(self.vnEz.prod())\n self.vnE = np.array([self.nEx, self.nEy, self.nEz], dtype=int)\n self.nE = int(self.vnE.sum())\n\n def __repr__(self):\n \"\"\"Simple representation.\"\"\"\n return (f\"TensorMesh: {self.nCx} x {self.nCy} x {self.nCz} \"\n f\"({self.nC:,})\")\n\n def copy(self):\n \"\"\"Return a copy of the TensorMesh.\"\"\"\n return TensorMesh.from_dict(self.to_dict(True))\n\n def to_dict(self, copy=False):\n \"\"\"Store the necessary information of the TensorMesh in a dict.\"\"\"\n out = {'hx': self.hx, 'hy': self.hy, 'hz': self.hz, 'x0': self.x0,\n '__class__': self.__class__.__name__}\n if copy:\n return deepcopy(out)\n else:\n return out\n\n @classmethod\n def from_dict(cls, inp):\n \"\"\"Convert dictionary into :class:`TensorMesh` instance.\n\n Parameters\n ----------\n inp : dict\n Dictionary as obtained from :func:`TensorMesh.to_dict`.\n The dictionary needs the keys `hx`, `hy`, `hz`, and `x0`.\n\n Returns\n -------\n obj : :class:`TensorMesh` instance\n\n \"\"\"\n try:\n return cls(h=[inp['hx'], inp['hy'], inp['hz']], x0=inp['x0'])\n except KeyError as e:\n print(f\"* ERROR :: Variable {e} missing in `inp`.\")\n raise\n\n @property\n def vol(self):\n \"\"\"Construct cell volumes of the 3D model as 1D array.\"\"\"\n if getattr(self, '_vol', None) is None:\n self._vol = (self.hx[None, None, :]*self.hy[None, :, None] *\n self.hz[:, None, None]).ravel()\n return self._vol\n\n\ndef get_hx_h0(freq, res, domain, fixed=0., possible_nx=None, min_width=None,\n pps=3, alpha=None, max_domain=100000., raise_error=True, verb=1,\n return_info=False):\n r\"\"\"Return cell widths and origin for given parameters.\n\n Returns cell widths for the provided frequency, resistivity, domain extent,\n and other parameters using a flexible amount of cells. See input parameters\n for more details. A maximum of three hard/fixed boundaries can be provided\n (one of which is the grid center).\n\n The minimum cell width is calculated through :math:`\\delta/\\rm{pps}`, where\n the skin depth is given by :math:`\\delta = 503.3 \\sqrt{\\rho/f}`, and the\n parameter `pps` stands for 'points-per-skindepth'. The minimum cell width\n can be restricted with the parameter `min_width`.\n\n The actual calculation domain adds a buffer zone around the (survey)\n domain. The thickness of the buffer is six times the skin depth. The field\n is basically zero after two wavelengths. A wavelength is\n :math:`2\\pi\\delta`, hence roughly 6 times the skin depth. Taking a factor 6\n gives therefore almost two wavelengths, as the field travels to the\n boundary and back. The actual buffer thickness can be steered with the\n `res` parameter.\n\n One has to take into account that the air is very resistive, which has to\n be considered not just in the vertical direction, but also in the\n horizontal directions, as the airwave will bounce back from the sides\n otherwise. In the marine case this issue reduces with increasing water\n depth.\n\n\n See Also\n --------\n get_stretched_h : Get `hx` for a fixed number `nx` and within a fixed\n domain.\n\n\n Parameters\n ----------\n\n freq : float\n Frequency (Hz) to calculate the skin depth. The skin depth is a concept\n defined in the frequency domain. If a negative frequency is provided,\n it is assumed that the calculation is carried out in the Laplace\n domain. To calculate the skin depth, the value of `freq` is then\n multiplied by :math:`-2\\pi`, to simulate the closest\n frequency-equivalent.\n\n res : float or list\n Resistivity (Ohm m) to calculate the skin depth. The skin depth is\n used to calculate the minimum cell width and the boundary thicknesses.\n Up to three resistivities can be provided:\n\n - float: Same resistivity for everything;\n - [min_width, boundaries];\n - [min_width, left boundary, right boundary].\n\n domain : list\n Contains the survey-domain limits [min, max]. The actual calculation\n domain consists of this domain plus a buffer zone around it, which\n depends on frequency and resistivity.\n\n fixed : list, optional\n Fixed boundaries, one, two, or maximum three values. The grid is\n centered around the first value. Hence it is the center location with\n the smallest cell. Two more fixed boundaries can be added, at most one\n on each side of the first one.\n Default is 0.\n\n possible_nx : list, optional\n List of possible numbers of cells. See :func:`get_cell_numbers`.\n Default is ``get_cell_numbers(500, 5, 3)``, which corresponds to\n [16, 24, 32, 40, 48, 64, 80, 96, 128, 160, 192, 256, 320, 384].\n\n min_width : float, list or None, optional\n Minimum cell width restriction:\n\n - None : No restriction;\n - float : Fixed to this value, ignoring skin depth and `pps`.\n - list [min, max] : Lower and upper bounds.\n\n Default is None.\n\n pps : int, optional\n Points per skindepth; minimum cell width is calculated via\n `dmin = skindepth/pps`.\n Default = 3.\n\n alpha : list, optional\n Maximum alpha and step size to find a good alpha. The first value is\n the maximum alpha of the survey domain, the second value is the maximum\n alpha for the buffer zone, and the third value is the step size.\n Default = [1, 1.5, .01], hence no stretching within the survey domain\n and a maximum stretching of 1.5 in the buffer zone; step size is 0.01.\n\n max_domain : float, optional\n Maximum calculation domain from fixed[0] (usually source position).\n Default is 100,000.\n\n raise_error : bool, optional\n If True, an error is raised if no suitable grid is found. Otherwise it\n just prints a message and returns None's.\n Default is True.\n\n verb : int, optional\n Verbosity, 0 or 1.\n Default = 1.\n\n return_info : bool\n If True, a dictionary is returned with some grid info (min and max\n cell width and alpha).\n\n\n Returns\n -------\n hx : ndarray\n Cell widths of mesh.\n\n x0 : float\n Origin of the mesh.\n\n info : dict\n Dictionary with mesh info; only if ``return_info=True``.\n\n Keys:\n\n - `dmin`: Minimum cell width;\n - `dmax`: Maximum cell width;\n - `amin`: Minimum alpha;\n - `amax`: Maximum alpha.\n\n \"\"\"\n # Get variables with default lists:\n if alpha is None:\n alpha = [1, 1.5, 0.01]\n if possible_nx is None:\n possible_nx = get_cell_numbers(500, 5, 3)\n\n # Cast resistivity value(s).\n res = np.array(res, ndmin=1)\n if res.size == 1:\n res_arr = np.array([res[0], res[0], res[0]])\n elif res.size == 2:\n res_arr = np.array([res[0], res[1], res[1]])\n else:\n res_arr = np.array([res[0], res[1], res[2]])\n\n # Cast and check fixed.\n fixed = np.array(fixed, ndmin=1)\n if fixed.size > 2:\n\n # Check length.\n if fixed.size > 3:\n print(\"\\n* ERROR :: Maximum three fixed boundaries permitted.\\n\"\n f\" Provided: {fixed.size}.\")\n raise ValueError(\"Wrong input for fixed\")\n\n # Sort second and third, so it doesn't matter how it was provided.\n fixed = np.array([fixed[0], max(fixed[1:]), min(fixed[1:])])\n\n # Check side.\n if np.sign(np.diff(fixed[:2])) == np.sign(np.diff(fixed[::2])):\n print(\"\\n* ERROR :: 2nd and 3rd fixed boundaries have to be \"\n \"left and right of the first one.\\n \"\n f\"Provided: [{fixed[0]}, {fixed[1]}, {fixed[2]}]\")\n raise ValueError(\"Wrong input for fixed\")\n\n # Calculate skin depth.\n skind = 503.3*np.sqrt(res_arr/abs(freq))\n if freq < 0: # For Laplace-domain calculations.\n skind /= np.sqrt(2*np.pi)\n\n # Minimum cell width.\n dmin = skind[0]/pps\n if min_width is not None: # Respect user input.\n min_width = np.array(min_width, ndmin=1)\n if min_width.size == 1:\n dmin = min_width\n else:\n dmin = np.clip(dmin, *min_width)\n\n # Survey domain; contains all sources and receivers.\n domain = np.array(domain, dtype=float)\n\n # Calculation domain; big enough to avoid boundary effects.\n # To avoid boundary effects we want the signal to travel two wavelengths\n # from the source to the boundary and back to the receiver.\n # => 2*pi*sd ~ 6.3*sd = one wavelength => signal is ~ 0.2 %.\n # Two wavelengths we can safely assume it is zero.\n #\n # The air does not follow the concept of skin depth, as it is a wave rather\n # than diffusion. For this is the factor `max_domain`, which restricts\n # the domain in each direction to this value from the center.\n\n # (a) Source to edges of domain.\n dist_in_domain = abs(domain - fixed[0])\n\n # (b) Two wavelengths.\n two_lambda = skind[1:]*4*np.pi\n\n # (c) Required buffer, additional to domain.\n dist_buff = np.max([np.zeros(2), (two_lambda - dist_in_domain)/2], axis=0)\n\n # (d) Add buffer to domain.\n calc_domain = np.array([domain[0]-dist_buff[0], domain[1]+dist_buff[1]])\n\n # (e) Restrict total domain to max_domain.\n calc_domain[0] = max(calc_domain[0], fixed[0]-max_domain)\n calc_domain[1] = min(calc_domain[1], fixed[0]+max_domain)\n\n # Initiate flag if terminated.\n finished = False\n\n # Initiate alpha variables for survey and calculation domains.\n sa, ca = 1.0, 1.0\n\n # Loop over possible cell numbers from small to big.\n for nx in np.unique(possible_nx):\n\n # Loop over possible alphas for domain.\n for sa in np.arange(1.0, alpha[0]+alpha[2]/2, alpha[2]):\n\n # Get current stretched grid cell sizes.\n thxl = dmin*sa**np.arange(nx) # Left of origin.\n thxr = dmin*sa**np.arange(nx) # Right of origin.\n\n # 0. Adjust stretching for fixed boundaries.\n if fixed.size > 1: # Move mesh to first fixed boundary.\n t_nx = np.r_[fixed[0], fixed[0]+np.cumsum(thxr)]\n ii = np.argmin(abs(t_nx-fixed[1]))\n thxr *= abs(fixed[1]-fixed[0])/np.sum(thxr[:ii])\n\n if fixed.size > 2: # Move mesh to second fixed boundary.\n t_nx = np.r_[fixed[0], fixed[0]-np.cumsum(thxl)]\n ii = np.argmin(abs(t_nx-fixed[2]))\n thxl *= abs(fixed[2]-fixed[0])/np.sum(thxl[:ii])\n\n # 1. Fill from center to left domain.\n nl = np.sum((fixed[0]-np.cumsum(thxl)) > domain[0])+1\n\n # 2. Fill from center to right domain.\n nr = np.sum((fixed[0]+np.cumsum(thxr)) < domain[1])+1\n\n # 3. Get remaining number of cells and check termination criteria.\n nsdc = nl+nr # Number of domain cells.\n nx_remain = nx-nsdc\n\n # Not good, try next.\n if nx_remain <= 0:\n continue\n\n # Create the current hx-array.\n hx = np.r_[thxl[:nl][::-1], thxr[:nr]]\n hxo = np.r_[thxl[:nl][::-1], thxr[:nr]]\n\n # Get actual domain:\n asurv_domain = [fixed[0]-np.sum(thxl[:nl]),\n fixed[0]+np.sum(thxr[:nr])]\n x0 = float(fixed[0]-np.sum(thxl[:nl]))\n\n # Get actual stretching (differs in case of fixed layers).\n sa_adj = np.max([hx[1:]/hx[:-1], hx[:-1]/hx[1:]])\n\n # Loop over possible alphas for calc_domain.\n for ca in np.arange(sa, alpha[1]+alpha[2]/2, alpha[2]):\n\n # 4. Fill to left calc_domain.\n thxl = hx[0]*ca**np.arange(1, nx_remain+1)\n nl = np.sum((asurv_domain[0]-np.cumsum(thxl)) >\n calc_domain[0])+1\n\n # 5. Fill to right calc_domain.\n thxr = hx[-1]*ca**np.arange(1, nx_remain+1)\n nr = np.sum((asurv_domain[1]+np.cumsum(thxr)) <\n calc_domain[1])+1\n\n # 6. Get remaining number of cells and check termination\n # criteria.\n ncdc = nl+nr # Number of calc_domain cells.\n nx_remain2 = nx-nsdc-ncdc\n\n if nx_remain2 < 0: # Not good, try next.\n continue\n\n # Create hx-array.\n nl += int(np.floor(nx_remain2/2)) # If uneven, add one cell\n nr += int(np.ceil(nx_remain2/2)) # more on the right.\n hx = np.r_[thxl[:nl][::-1], hx, thxr[:nr]]\n\n # Calculate origin.\n x0 = float(asurv_domain[0]-np.sum(thxl[:nl]))\n\n # Mark it as finished and break out of the loop.\n finished = True\n break\n\n if finished:\n break\n\n if finished:\n break\n\n # Check finished and print info about found grid.\n if not finished:\n # Throw message if no solution was found.\n print(\"\\n* ERROR :: No suitable grid found; relax your criteria.\\n\")\n if raise_error:\n raise ArithmeticError(\"No grid found!\")\n else:\n hx, x0 = None, None\n\n elif verb > 0:\n print(f\" Skin depth \", end=\"\")\n if res.size == 1:\n print(f\" [m] : {skind[0]:.0f}\")\n elif res.size == 2:\n print(f\"(m/l-r) [m] : {skind[0]:.0f} / {skind[1]:.0f}\")\n else:\n print(f\"(m/l/r) [m] : {skind[0]:.0f} / {skind[1]:.0f} / \"\n f\"{skind[2]:.0f}\")\n print(f\" Survey domain [m] : {domain[0]:.0f} - \"\n f\"{domain[1]:.0f}\")\n print(f\" Calculation domain [m] : {calc_domain[0]:.0f} - \"\n f\"{calc_domain[1]:.0f}\")\n print(f\" Final extent [m] : {x0:.0f} - \"\n f\"{x0+np.sum(hx):.0f}\")\n extstr = f\" Min/max cell width [m] : {min(hx):.0f} / \"\n alstr = f\" Alpha survey\"\n nrstr = \" Number of cells \"\n if not np.isclose(sa, sa_adj):\n sastr = f\"{sa:.3f} ({sa_adj:.3f})\"\n else:\n sastr = f\"{sa:.3f}\"\n print(extstr+f\"{max(hxo):.0f} / {max(hx):.0f}\")\n print(alstr+f\"/calc : {sastr} / {ca:.3f}\")\n print(nrstr+f\"(s/c/r) : {nx} ({nsdc}/{ncdc}/{nx_remain2})\")\n print()\n\n if return_info:\n if not fixed.size > 1:\n sa_adj = sa\n\n info = {'dmin': dmin,\n 'dmax': np.nanmax(hx),\n 'amin': np.nanmin([ca, sa, sa_adj]),\n 'amax': np.nanmax([ca, sa, sa_adj])}\n\n return hx, x0, info\n else:\n return hx, x0\n\n\ndef get_cell_numbers(max_nr, max_prime=5, min_div=3):\n r\"\"\"Returns 'good' cell numbers for the multigrid method.\n\n 'Good' cell numbers are numbers which can be divided by 2 as many times as\n possible. At the end there will be a low prime number.\n\n The function adds all numbers :math:`p 2^n \\leq M` for :math:`p={2, 3, ...,\n p_\\text{max}}` and :math:`n={n_\\text{min}, n_\\text{min}+1, ..., \\infty}`;\n :math:`M, p_\\text{max}, n_\\text{min}` correspond to `max_nr`, `max_prime`,\n and `min_div`, respectively.\n\n\n Parameters\n ----------\n max_nr : int\n Maximum number of cells.\n\n max_prime : int\n Highest permitted prime number p for p*2^n. {2, 3, 5, 7} are good upper\n limits in order to avoid too big lowest grids in the multigrid method.\n Default is 5.\n\n min_div : int\n Minimum times the number can be divided by two.\n Default is 3.\n\n\n Returns\n -------\n numbers : array\n Array containing all possible cell numbers from lowest to highest.\n\n \"\"\"\n # Primes till 20.\n primes = np.array([2, 3, 5, 7, 11, 13, 17, 19])\n\n # Sanity check; 19 is already ridiculously high.\n if max_prime > primes[-1]:\n print(f\"* ERROR :: Highest prime is {max_prime}, \"\n \"please use a value < 20.\")\n raise ValueError(\"Highest prime too high\")\n\n # Restrict to max_prime.\n primes = primes[primes <= max_prime]\n\n # Get possible values.\n # Currently restricted to prime*2**30 (for prime=2 => 1,073,741,824 cells).\n numbers = primes[:, None]*2**np.arange(min_div, 30)\n\n # Get unique values.\n numbers = np.unique(numbers)\n\n # Restrict to max_nr and return.\n return numbers[numbers <= max_nr]\n\n\ndef get_stretched_h(min_width, domain, nx, x0=0, x1=None, resp_domain=False):\n \"\"\"Return cell widths for a stretched grid within the domain.\n\n Returns `nx` cell widths within `domain`, where the minimum cell width is\n `min_width`. The cells are not stretched within `x0` and `x1`, and outside\n uses a power-law stretching. The actual stretching factor and the number of\n cells left and right of `x0` and `x1` are find in a minimization process.\n\n The domain is not completely respected. The starting point of the domain\n is, but the endpoint of the domain might slightly shift (this is more\n likely the case for small `nx`, for big `nx` the shift should be small).\n The new endpoint can be obtained with ``domain[0]+np.sum(hx)``. If you want\n the domain to be respected absolutely, set ``resp_domain=True``. However,\n be aware that this will introduce one stretch-factor which is different\n from the other stretch factors, to accommodate the restriction. This\n one-off factor is between the left- and right-side of `x0`, or, if `x1` is\n provided, just after `x1`.\n\n\n See Also\n --------\n get_hx_x0 : Get `hx` and `x0` for a flexible number of `nx` with\n given bounds.\n\n\n Parameters\n ----------\n\n min_width : float\n Minimum cell width. If x1 is provided, the actual minimum cell width\n might be smaller than min_width.\n\n domain : list\n [start, end] of model domain.\n\n nx : int\n Number of cells.\n\n x0 : float\n Center of the grid. `x0` is restricted to `domain`.\n Default is 0.\n\n x1 : float\n If provided, then no stretching is applied between `x0` and `x1`. The\n non-stretched part starts at `x0` and stops at the first possible\n location at or after `x1`. `x1` is restricted to `domain`. This will\n min_width so that an integer number of cells fit within x0 and x1.\n\n resp_domain : bool\n If False (default), then the domain-end might shift slightly to assure\n that the same stretching factor is applied throughout. If set to True,\n however, the domain is respected absolutely. This will introduce one\n stretch-factor which is different from the other stretch factors, to\n accommodate the restriction. This one-off factor is between the left-\n and right-side of `x0`, or, if `x1` is provided, just after `x1`.\n\n\n Returns\n -------\n hx : ndarray\n Cell widths of mesh.\n\n \"\"\"\n\n # Cast to arrays\n domain = np.array(domain, dtype=float)\n x0 = np.array(x0, dtype=float)\n x0 = np.clip(x0, *domain) # Restrict to model domain\n min_width = np.array(min_width, dtype=float)\n if x1 is not None:\n x1 = np.array(x1, dtype=float)\n x1 = np.clip(x1, *domain) # Restrict to model domain\n\n # If x1 is provided (a part is not stretched)\n if x1 is not None:\n\n # Store original values\n xlim_orig = domain.copy()\n nx_orig = int(nx)\n x0_orig = x0.copy()\n h_min_orig = min_width.copy()\n\n # Get number of non-stretched cells\n n_nos = int(np.ceil((x1-x0)/min_width))\n\n # Re-calculate min_width to fit with x0-x1-limits:\n min_width = (x1-x0)/n_nos\n\n # Subtract one cell, because the standard scheme provides one\n # min_width-cell.\n n_nos -= 1\n\n # Reset x0, because the first min_width comes from normal scheme\n x0 += min_width\n\n # Reset xmax for normal scheme\n domain[1] -= n_nos*min_width\n\n # Reset nx for normal scheme\n nx -= n_nos\n\n # If there are not enough points reset to standard procedure. The limit\n # of five is arbitrary. However, nx should be much bigger than five\n # anyways, otherwise stretched grid doesn't make sense.\n if nx <= 5:\n print(\"Warning :: Not enough points for non-stretched part,\"\n \"ignoring therefore `x1`.\")\n domain = xlim_orig\n nx = nx_orig\n x0 = x0_orig\n x1 = None\n min_width = h_min_orig\n\n # Get stretching factor (a = 1+alpha).\n if min_width == 0 or min_width > np.diff(domain)/nx:\n # If min_width is bigger than the domain-extent divided by nx, no\n # stretching is required at all.\n alpha = 0\n else:\n\n # Wrap _get_dx into a minimization function to call with fsolve.\n def find_alpha(alpha, min_width, args):\n \"\"\"Find alpha such that min(hx) = min_width.\"\"\"\n return min(get_hx(alpha, *args))/min_width-1\n\n # Search for best alpha, must be at least 0\n args = (domain, nx, x0)\n alpha = max(0, optimize.fsolve(find_alpha, 0.02, (min_width, args)))\n\n # With alpha get actual cell spacing with `resp_domain` to respect the\n # users decision.\n hx = get_hx(alpha, domain, nx, x0, resp_domain)\n\n # Add the non-stretched center if x1 is provided\n if x1 is not None:\n hx = np.r_[hx[: np.argmin(hx)], np.ones(n_nos)*min_width,\n hx[np.argmin(hx):]]\n\n # Print warning min_width could not be respected.\n if abs(hx.min() - min_width) > 0.1:\n print(f\"Warning :: Minimum cell width ({np.round(hx.min(), 2)} m) is \"\n \"below `min_width`, because `nx` is too big for `domain`.\")\n\n return hx\n\n\ndef get_domain(x0=0, freq=1, res=0.3, limits=None, min_width=None,\n fact_min=0.2, fact_neg=5, fact_pos=None):\n r\"\"\"Get domain extent and minimum cell width as a function of skin depth.\n\n Returns the extent of the calculation domain and the minimum cell width as\n a multiple of the skin depth, with possible user restrictions on minimum\n calculation domain and range of possible minimum cell widths.\n\n .. math::\n\n \\delta &= 503.3 \\sqrt{\\frac{\\rho}{f}} , \\\\\n x_\\text{start} &= x_0-k_\\text{neg}\\delta , \\\\\n x_\\text{end} &= x_0+k_\\text{pos}\\delta , \\\\\n h_\\text{min} &= k_\\text{min} \\delta .\n\n\n Parameters\n ----------\n\n x0 : float\n Center of the calculation domain. Normally the source location.\n Default is 0.\n\n freq : float\n Frequency (Hz) to calculate the skin depth. The skin depth is a concept\n defined in the frequency domain. If a negative frequency is provided,\n it is assumed that the calculation is carried out in the Laplace\n domain. To calculate the skin depth, the value of `freq` is then\n multiplied by :math:`-2\\pi`, to simulate the closest\n frequency-equivalent.\n\n Default is 1 Hz.\n\n res : float, optional\n Resistivity (Ohm m) to calculate skin depth.\n Default is 0.3 Ohm m (sea water).\n\n limits : None or list\n [start, end] of model domain. This extent represents the minimum extent\n of the domain. The domain is therefore only adjusted if it has to reach\n outside of [start, end].\n Default is None.\n\n min_width : None, float, or list of two floats\n Minimum cell width is calculated as a function of skin depth:\n fact_min*sd. If `min_width` is a float, this is used. If a list of\n two values [min, max] are provided, they are used to restrain\n min_width. Default is None.\n\n fact_min, fact_neg, fact_pos : floats\n The skin depth is multiplied with these factors to estimate:\n\n - Minimum cell width (`fact_min`, default 0.2)\n - Domain-start (`fact_neg`, default 5), and\n - Domain-end (`fact_pos`, defaults to `fact_neg`).\n\n\n Returns\n -------\n\n h_min : float\n Minimum cell width.\n\n domain : list\n Start- and end-points of calculation domain.\n\n \"\"\"\n\n # Set fact_pos to fact_neg if not provided.\n if fact_pos is None:\n fact_pos = fact_neg\n\n # Calculate the skin depth.\n skind = 503.3*np.sqrt(res/abs(freq))\n if freq < 0: # For Laplace-domain calculations.\n skind /= np.sqrt(2*np.pi)\n\n # Estimate minimum cell width.\n h_min = fact_min*skind\n if min_width is not None: # Respect user input.\n if np.array(min_width).size == 1:\n h_min = min_width\n else:\n h_min = np.clip(h_min, *min_width)\n\n # Estimate calculation domain.\n domain = [x0-fact_neg*skind, x0+fact_pos*skind]\n if limits is not None: # Respect user input.\n domain = [min(limits[0], domain[0]), max(limits[1], domain[1])]\n\n return h_min, domain\n\n\ndef get_hx(alpha, domain, nx, x0, resp_domain=True):\n r\"\"\"Return cell widths for given input.\n\n Find the number of cells left and right of `x0`, `nl` and `nr`\n respectively, for the provided alpha. For this, we solve\n\n .. math:: \\frac{x_\\text{max}-x_0}{x_0-x_\\text{min}} =\n \\frac{a^{nr}-1}{a^{nl}-1}\n\n where :math:`a = 1+\\alpha`.\n\n\n Parameters\n ----------\n\n alpha : float\n Stretching factor `a` is given by ``a=1+alpha``.\n\n domain : list\n [start, end] of model domain.\n\n nx : int\n Number of cells.\n\n x0 : float\n Center of the grid. `x0` is restricted to `domain`.\n\n resp_domain : bool\n If False (default), then the domain-end might shift slightly to assure\n that the same stretching factor is applied throughout. If set to True,\n however, the domain is respected absolutely. This will introduce one\n stretch-factor which is different from the other stretch factors, to\n accommodate the restriction. This one-off factor is between the left-\n and right-side of `x0`, or, if `x1` is provided, just after `x1`.\n\n\n Returns\n -------\n hx : ndarray\n Cell widths of mesh.\n\n \"\"\"\n if alpha <= 0.: # If alpha <= 0: equal spacing (no stretching at all)\n hx = np.ones(nx)*np.diff(np.squeeze(domain))/nx\n\n else: # Get stretched hx\n a = alpha+1\n\n # Get hx depending if x0 is on the domain boundary or not.\n if np.isclose(x0, domain[0]) or np.isclose(x0, domain[1]):\n # Get al a's\n alr = np.diff(domain)*alpha/(a**nx-1)*a**np.arange(nx)\n if x0 == domain[1]:\n alr = alr[::-1]\n\n # Calculate differences\n hx = alr*np.diff(domain)/sum(alr)\n\n else:\n # Find number of elements left and right by solving:\n # (xmax-x0)/(x0-xmin) = a**nr-1/(a**nl-1)\n nr = np.arange(2, nx+1)\n er = (domain[1]-x0)/(x0-domain[0]) - (a**nr[::-1]-1)/(a**nr-1)\n nl = np.argmin(abs(np.floor(er)))+1\n nr = nx-nl\n\n # Get all a's\n al = a**np.arange(nl-1, -1, -1)\n ar = a**np.arange(1, nr+1)\n\n # Calculate differences\n if resp_domain:\n # This version honours domain[0] and domain[1], but to achieve\n # this it introduces one stretch-factor which is different from\n # all the others between al to ar.\n hx = np.r_[al*(x0-domain[0])/sum(al),\n ar*(domain[1]-x0)/sum(ar)]\n else:\n # This version moves domain[1], but each stretch-factor is\n # exactly the same.\n fact = (x0-domain[0])/sum(al) # Take distance from al.\n hx = np.r_[al, ar]*fact\n\n # Note: this hx is equivalent as providing the following h\n # to TensorMesh:\n # h = [(min_width, nl-1, -a), (min_width, n_nos+1),\n # (min_width, nr, a)]\n\n return hx\n", "meta": {"hexsha": "1c850ddd900887b33d213aba43297d734592063b", "size": 31713, "ext": "py", "lang": "Python", "max_stars_repo_path": "geofem/emg3d/meshes.py", "max_stars_repo_name": "iisadoramacedo/geofem-master", "max_stars_repo_head_hexsha": "cc5cf4ae660480dd4dc3d805310f7207fb28230e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "geofem/emg3d/meshes.py", "max_issues_repo_name": "iisadoramacedo/geofem-master", "max_issues_repo_head_hexsha": "cc5cf4ae660480dd4dc3d805310f7207fb28230e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-10-29T11:42:21.000Z", "max_issues_repo_issues_event_max_datetime": "2020-10-29T11:42:21.000Z", "max_forks_repo_path": "build/lib/geofem/emg3d/meshes.py", "max_forks_repo_name": "iisadoramacedo/geofem-master", "max_forks_repo_head_hexsha": "cc5cf4ae660480dd4dc3d805310f7207fb28230e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-07-09T18:15:10.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-09T18:15:10.000Z", "avg_line_length": 35.8338983051, "max_line_length": 79, "alphanum_fraction": 0.5905779964, "include": true, "reason": "import numpy,from scipy", "num_tokens": 8359, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230156, "lm_q2_score": 0.36658975016245987, "lm_q1q2_score": 0.1890209760836889}} {"text": "from __future__ import absolute_import, division, print_function, unicode_literals\nfrom typing import Optional\n\nimport numpy as np\nimport os\n\nfrom astropy.io import fits\nfrom astropy.table import Table\n\nfrom .. import this_project as P\nfrom .. import utils as ut\n\n__all__ = [\"Planck14Data\", \"Planck14DataAlt\", \"Planck14Model\", \"Maniyar18Model\"]\n\n\nclass CIBxCIB:\n\n _l = None # multipole\n _Cl = None # angular power\n _dCl = None # uncertainty on the angular power\n _Dl = None # l(l+1)/2pi * Cl\n _dDl = None # uncertainty on the angular power\n _l3Cl = None # l**3 * Cl\n\n _S = None # shot noise level\n _dS = None # uncertainty on the shot noise\n\n _raw_table = None # raw table, taken from publications, emails, etc\n\n def __init__(self, freq1, freq2=None, unit=\"Jy^2/sr\"):\n if unit not in [\"Jy^2/sr\", \"MJy^2/sr\", \"K^2.sr\", \"uK^2.sr\"]:\n raise ValueError(\n 'Unit must be either \"Jy^2/sr\", ' '\"MJy^2/sr\", \"uK^2.sr\" or \"K^2.sr\"'\n )\n self.unit = unit\n\n self.freq1 = self.freq2int(freq1)\n if freq2 is None:\n self.freq2 = freq1\n else:\n self.freq2 = self.freq2int(freq2)\n\n # Methods\n #########\n def freq2int(self, freq):\n if isinstance(freq, str):\n return int(freq)\n else:\n if isinstance(freq, int):\n return freq\n else:\n raise TypeError(\"freq must be int or str\")\n\n # Properties\n ############\n @property\n def freqstr(self):\n self._freqstr = \"x\".join(\n (\n str(max([int(self.freq1), int(self.freq2)])),\n str(min([int(self.freq1), int(self.freq2)])),\n )\n )\n return self._freqstr\n\n @property\n def l(self):\n if self._l is None:\n self._l = self.raw_table[:, 0]\n return self._l\n\n @property\n def Cl(self):\n return None\n\n @property\n def dCl(self):\n return None\n\n @property\n def Dl(self):\n if self._Dl is None:\n self._Dl = self.l * (self.l + 1.0) / 2.0 / np.pi * self.Cl\n return self._Dl\n\n @property\n def l3Cl(self):\n if self._l3Cl is None:\n self._l3Cl = self.l ** 3 * self.Cl\n return self._l3Cl\n\n @property\n def Jy2K(self):\n self._Jy2K = P.Jy2K\n return self._Jy2K\n\n @property\n def K2Jy(self):\n self._K2Jy = P.K2Jy\n return self._K2Jy\n\n\nclass Planck14DataAlt(CIBxCIB):\n def __init__(self, freq1, freq2=None, unit=\"Jy^2/sr\"):\n super(Planck14Data, self).__init__(freq1, freq2=freq2, unit=unit)\n\n self.Cl_contains_SN = True\n\n # Properties\n ############\n @property\n def raw_table(self):\n if self._raw_table is None:\n self._raw_table = np.loadtxt(\n os.path.join(P.PACKAGE_DIR, \"resources/cibxcib/Planck14_data.txt\")\n )\n return self._raw_table\n\n @property\n def Cl(self):\n if self._Cl is None:\n # Native unit is Jy^2/sr\n self._Cl = self.raw_table[:, self._freq2col(self.freqstr)].copy()\n\n # We add the shot noise, which is also in Jy^2/sr\n self._Cl += self.S\n\n if self.unit in [\"K^2.sr\", \"uK^2.sr\"]:\n self._Cl *= self.Jy2K[str(self.freq1)] * self.Jy2K[str(self.freq2)]\n\n if self.unit == \"uK^2.sr\":\n self._Cl *= 1.0e12\n\n if self.unit == \"MJy^2/sr\":\n self._Cl /= 1.0e12\n\n return self._Cl\n\n @property\n def S(self):\n \"\"\"\n Shot noise, units are Jy^2/sr. Taken from\n Planck (2014 XXX)\n \"\"\"\n if self._S is None:\n self._S = {\n \"857x857\": 5364,\n \"545x545\": 1690,\n \"353x353\": 262,\n \"217x217\": 21,\n \"3000x3000\": 9585,\n \"857x545\": 2702,\n \"857x353\": 953,\n \"857x217\": 181,\n \"545x353\": 626,\n \"545x217\": 121,\n \"353x217\": 54,\n \"3000x857\": 4158,\n \"3000x545\": 1449,\n \"3000x353\": 411,\n \"3000x217\": 95,\n }\n\n if self.unit in [\"K^2.sr\", \"uK^2.sr\"]:\n self._S *= self.Jy2K[str(self.freq1)] * self.Jy2K[str(self.freq2)]\n\n if self.unit == \"uK^2.sr\":\n self._S *= 1.0e12\n\n if self.unit == \"MJy^2/sr\":\n self._S /= 1.0e12\n\n return self._S[self.freqstr]\n\n @property\n def dS(self):\n \"\"\"\n Shot noise\n \"\"\"\n if self._dS is None:\n self._dS = {\n \"857x857\": 343,\n \"545x545\": 45,\n \"353x353\": 8,\n \"217x217\": 2,\n \"3000x3000\": 1090,\n \"857x545\": 124,\n \"857x353\": 54,\n \"857x217\": 6,\n \"545x353\": 19,\n \"545x217\": 6,\n \"353x217\": 3,\n \"3000x857\": 443,\n \"3000x545\": 176,\n \"3000x353\": 48,\n \"3000x217\": 11,\n }\n if self.unit in [\"K^2.sr\", \"uK^2.sr\"]:\n self._dS *= self.Jy2K[str(self.freq1)] * self.Jy2K[str(self.freq2)]\n if self.unit == \"uK^2.sr\":\n self._dS *= 1.0e12\n\n if self.unit == \"MJy^2/sr\":\n self._dS /= 1.0e12\n\n return self._dS[self.freqstr]\n\n # Methods\n #########\n def _freq2col(self, freqstr):\n mapping = {\n \"857x857\": 1,\n \"545x545\": 2,\n \"353x353\": 3,\n \"217x217\": 4,\n \"3000x3000\": 5,\n \"857x545\": 6,\n \"857x353\": 7,\n \"857x217\": 8,\n \"545x353\": 9,\n \"545x217\": 10,\n \"353x217\": 11,\n \"3000x857\": 12,\n \"3000x545\": 13,\n \"3000x353\": 14,\n \"3000x217\": 15,\n \"100x100\": 16,\n \"857x100\": 17,\n \"545x100\": 18,\n \"353x100\": 19,\n \"217x100\": 20,\n \"143x143\": 21,\n \"857x143\": 22,\n \"545x143\": 23,\n \"353x143\": 24,\n \"217x143\": 25,\n \"143x100\": 26,\n }\n\n return mapping[self.freqstr]\n\n\nclass Planck14Model(CIBxCIB):\n def __init__(self, freq1, freq2=None, unit=\"Jy^2/sr\"):\n super(Planck14Model, self).__init__(freq1, freq2=freq2, unit=unit)\n\n self.Cl_contains_SN = True\n\n # Properties\n ############\n @property\n def raw_table(self):\n if self._raw_table is None:\n self._raw_table = np.loadtxt(\n os.path.join(P.PACKAGE_DIR, \"resources/cibxcib/Planck14_model.txt\")\n )\n return self._raw_table\n\n @property\n def Cl(self):\n if self._Cl is None:\n # native unit is be Jy^2/sr\n self._Cl = self.raw_table[:, self._freq2col(self.freqstr)].copy()\n\n # Possibly convert the units\n if self.unit in [\"K^2.sr\", \"uK^2.sr\"]:\n self._Cl *= self.Jy2K[str(self.freq1)] * self.Jy2K[str(self.freq2)]\n if self.unit == \"uK^2.sr\":\n self._Cl *= 1.0e12\n\n if self.unit == \"MJy^2/sr\":\n self._Cl /= 1.0e12\n\n # Apply the correction factor to the PR1 calibration\n # self._Cl /= (\n # ut.PLANCK_PR1PR3_CALCORR[str(self.freq1)]\n # * ut.PLANCK_PR1PR3_CALCORR[str(self.freq2)]\n # )\n return self._Cl\n\n # Methods\n #########\n def _freq2col(self, freqstr):\n # l, 353x353, 353x545, 353x857, 545x545, 545x857, 857x857\n mapping = {\n \"353x353\": 1,\n \"545x353\": 2,\n \"857x353\": 3,\n \"545x545\": 4,\n \"857x545\": 5,\n \"857x857\": 6,\n }\n\n return mapping[self.freqstr]\n\n\nclass Maniyar18Model(CIBxCIB):\n def __init__(self, freq1, freq2=None, unit=\"Jy^2/sr\"):\n super(Maniyar18Model, self).__init__(freq1, freq2=freq2, unit=unit)\n\n self.Cl_contains_SN = True\n self.Cl_contains_1halo = True\n\n # Properties\n ############\n @property\n def raw_table(self):\n if self._raw_table is None:\n self._raw_table = fits.open(\n os.path.join(\n P.PACKAGE_DIR, \"resources/cibxcib/Maniyar18_model_crosspowers.dat\"\n )\n )\n return self._raw_table\n\n @property\n def l(self):\n if self._l is None:\n self._l = self.raw_table[1].data\n return self._l\n\n @property\n def Cl(self):\n if self._Cl is None:\n # native unit is Jy^2/sr\n self._Cl = self.raw_table[0].data[\n self._freq2col(str(self.freq1)), self._freq2col(str(self.freq2))\n ]\n\n # Possibly convert the units\n if self.unit in [\"K^2.sr\", \"uK^2.sr\"]:\n self._Cl *= self.Jy2K[str(self.freq1)] * self.Jy2K[str(self.freq2)]\n if self.unit == \"uK^2.sr\":\n self._Cl *= 1.0e12\n\n if self.unit == \"MJy^2/sr\":\n self._Cl /= 1.0e12\n\n return self._Cl\n\n # Methods\n #########\n def _freq2col(self, freq):\n # 217x217, 353x353, 545x545, 857x857, 3000x3000\n mapping = {\n \"100\": 0,\n \"143\": 1,\n \"217\": 2,\n \"353\": 3,\n \"545\": 4,\n \"857\": 5,\n \"3000\": 6,\n }\n\n return mapping[freq]\n\n\nclass Planck14Data(CIBxCIB):\n def __init__(self, freq1, freq2=None, unit=\"Jy^2/sr\"):\n super(Planck14Data, self).__init__(freq1, freq2=freq2, unit=unit)\n self.Cl_contains_SN = True\n\n # Properties\n ############\n @property\n def raw_table(self):\n if self._raw_table is None:\n self._raw_table = Table.read(\n os.path.join(\n P.PACKAGE_DIR, \"resources/cibxcib/Planck14_data_frompaper.txt\"\n ),\n format=\"csv\",\n delimiter=\";\",\n )\n return self._raw_table\n\n @property\n def l(self):\n if self._l is None:\n self._l = self.raw_table[\"ell\"].data.data\n\n return self._l\n\n @property\n def Cl(self):\n if self._Cl is None:\n # Native unit is Jy^2/sr\n self._Cl = self.raw_table[f\"{self.freq1}x{self.freq2}\"].data.data\n\n # We add the shot noise, which is also in Jy^2/sr\n # self._Cl += self.S\n\n if self.unit in [\"K^2.sr\", \"uK^2.sr\"]:\n self._Cl *= self.Jy2K[str(self.freq1)] * self.Jy2K[str(self.freq2)]\n\n if self.unit == \"uK^2.sr\":\n self._Cl *= 1.0e12\n\n if self.unit == \"MJy^2/sr\":\n self._Cl /= 1.0e12\n\n # Apply the correction factor to the PR1 calibration\n # self._Cl /= (\n # ut.PLANCK_PR1PR3_CALCORR[str(self.freq1)]\n # * ut.PLANCK_PR1PR3_CALCORR[str(self.freq2)]\n # )\n\n return self._Cl\n\n @property\n def dCl(self):\n if self._dCl is None:\n # Native unit is Jy^2/sr\n self._dCl = self.raw_table[f\"d{self.freq1}x{self.freq2}\"].data.data\n\n if self.unit in [\"K^2.sr\", \"uK^2.sr\"]:\n self._dCl *= self.Jy2K[str(self.freq1)] * self.Jy2K[str(self.freq2)]\n\n if self.unit == \"uK^2.sr\":\n self._dCl *= 1.0e12\n\n if self.unit == \"MJy^2/sr\":\n self._dCl /= 1.0e12\n\n # Apply the correction factor to the PR1 calibration\n # self._dCl /= (\n # ut.PLANCK_PR1PR3_CALCORR[str(self.freq1)]\n # * ut.PLANCK_PR1PR3_CALCORR[str(self.freq2)]\n # )\n\n return self._dCl\n\n @property\n def dDl(self):\n if self._dDl is None:\n self._dDl = self.l * (self.l + 1.0) / 2.0 / np.pi * self.dCl\n return self._dDl\n\n\nclass Mak17Model(CIBxCIB):\n def __init__(\n self,\n freq1: str,\n freq2: Optional[str] = None,\n lmax: Optional[int] = None,\n unit: str = \"uK2.sr\",\n mask=\"mask40\",\n ):\n super().__init__(freq1, freq2=freq2, unit=unit)\n\n if lmax is None:\n self.lmax = 3000\n else:\n self.lmax = lmax\n\n # self.freq1 = freq1\n # if freq2 is None:\n # self.freq2 = freq1\n # else:\n # self.freq2 = freq2\n #\n self.mask = mask\n\n @property\n def l(self):\n if self._l is None:\n self._l = np.arange(self.lmax)\n return self._l\n\n @staticmethod\n def model(ells, A_cib, A_ps, gamma):\n \"\"\"\n Returns Dl^total = Dl^CIB + Dl^PS\n The Dl^PS are given as value at ell=2000, hence we need to convert this back to Cls\n and then apply the appropriate scaling.\n \"\"\"\n return (\n A_cib * np.power(ells / 2000.0, gamma)\n + A_ps / 2000 / 2001 * ells * ells\n + 1.0\n )\n\n @property\n def mask(self):\n return self._mask\n\n @mask.setter\n def mask(self, val):\n if not hasattr(self, \"_mask\"):\n allowed = [\"mask30\", \"mask40\", \"mask50\"]\n if val not in allowed:\n raise ValueError(f\"mask must be in {allowed}\")\n self._mask = val\n else:\n raise RuntimeError(\"mask can only be set once during initialization.\")\n\n @staticmethod\n def get_rho_cib(freq1, freq2):\n d = {\n \"353x353\": 1.0,\n \"545x545\": 1.0,\n \"857x857\": 1.0,\n \"353x545\": 0.975,\n \"353x857\": 0.892,\n \"545x857\": 0.949,\n }\n\n return d[f\"{freq1}x{freq2}\"]\n\n @staticmethod\n def get_rho_ps(freq1, freq2):\n d = {\n \"353x353\": 1.0,\n \"545x545\": 1.0,\n \"857x857\": 1.0,\n \"353x545\": 0.98,\n \"353x857\": 0.86,\n \"545x857\": 0.97,\n }\n\n return d[f\"{freq1}x{freq2}\"]\n\n @property\n def _raw_data(self):\n # Define mask30\n mask30 = {\n \"gamma\": 0.51,\n \"cib\": {\"353\": 2.5e3, \"545\": 4.5e5, \"857\": 1.09e9},\n \"ps\": {\"353\": 2.15e3, \"545\": 3.54e5, \"857\": 7.2e8},\n \"cal\": {\"353\": 1.0, \"545\": 1.05, \"857\": 1.01},\n }\n\n # Define mask40\n mask40 = {\n \"gamma\": 0.53,\n \"cib\": {\"353\": 2.56e3, \"545\": 4.47e5, \"857\": 1.09e9},\n \"ps\": {\"353\": 2.1e3, \"545\": 3.42e5, \"857\": 7.34e8},\n \"cal\": {\"353\": 1.0, \"545\": 1.03, \"857\": 1.01},\n }\n\n d = dict(\n mask30=mask30,\n mask40=mask40,\n # mask50=mask50,\n )\n\n return d\n\n def calibration(self, freq1: int, freq2: int):\n raw_data = self._raw_data[self.mask]\n cal1, cal2 = raw_data[\"cal\"][str(freq1)], raw_data[\"cal\"][str(freq2)]\n\n return cal1 * cal2\n\n def get_model_parameters(self):\n raw_data = self._raw_data[self.mask]\n\n # Correlation coefficients\n rho_cib = self.get_rho_cib(self.freq1, self.freq2)\n rho_ps = self.get_rho_ps(self.freq1, self.freq2)\n\n # Amplitudes\n gamma = raw_data[\"gamma\"]\n\n A_cib = rho_cib * np.sqrt(\n raw_data[\"cib\"][str(self.freq1)] * raw_data[\"cib\"][str(self.freq2)]\n )\n\n A_ps = rho_ps * np.sqrt(\n raw_data[\"ps\"][str(self.freq1)] * raw_data[\"ps\"][str(self.freq2)]\n )\n\n return gamma, A_cib, A_ps\n\n @property\n def Cl(self):\n \"\"\"\n We copy the dipole for the monopole, because it would naturally be inf due to\n the division by zero.\n \"\"\"\n _Cl = self.Dl / (self.l * (self.l + 1)) * 2.0 * np.pi\n _Cl = np.concatenate([_Cl[1:2], _Cl[1:]])\n\n return _Cl\n\n @property\n def Dl(self):\n if self._Dl is None:\n gamma, A_cib, A_ps = self.get_model_parameters()\n self._Dl = self.model(self.l, A_cib, A_ps, gamma)\n self._Dl /= self.calibration(self.freq1, self.freq2)\n\n if self.unit == \"K^2.sr\":\n self._Dl /= 1.0e12\n if self.unit == \"Jy^2/sr\":\n self._Dl *= 1.0e-12 * (\n self.K2Jy[str(self.freq1)] * self.K2Jy[str(self.freq2)]\n )\n if self.unit == \"MJy^2/sr\":\n self._Dl *= self.K2Jy[str(self.freq1)] * self.K2Jy[str(self.freq2)]\n return self._Dl\n\n\nclass Mak17(Mak17Model):\n \"\"\"We keep this copy of the Mak17Model to ensure downward compatibility.\"\"\"\n pass\n", "meta": {"hexsha": "ca66a70f14ae3e1321b532c0950be8ef8f0cbb36", "size": 16713, "ext": "py", "lang": "Python", "max_stars_repo_path": "cibinfo/powerspectra/cibxcib.py", "max_stars_repo_name": "DanielLenz/CIBinfo", "max_stars_repo_head_hexsha": "45f12f3d459c17abedc4e5c75ef1422e99e20f20", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "cibinfo/powerspectra/cibxcib.py", "max_issues_repo_name": "DanielLenz/CIBinfo", "max_issues_repo_head_hexsha": "45f12f3d459c17abedc4e5c75ef1422e99e20f20", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "cibinfo/powerspectra/cibxcib.py", "max_forks_repo_name": "DanielLenz/CIBinfo", "max_forks_repo_head_hexsha": "45f12f3d459c17abedc4e5c75ef1422e99e20f20", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.5337726524, "max_line_length": 91, "alphanum_fraction": 0.4814814815, "include": true, "reason": "import numpy,from astropy", "num_tokens": 4993, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5156199157230157, "lm_q2_score": 0.36658973632215985, "lm_q1q2_score": 0.1890209689473546}} {"text": "#!/bin/python3.6\n\nimport subprocess\nimport os\nimport networkx as nx\nimport random\nfrom typing import Optional, Callable, Dict, List\nimport re\nimport signal\nfrom glob import glob\nfrom time import sleep\n\nfrom utils import filled_in, TreeDecomposition, pairs, stream_bn, get_bn_stats, \\\n filter_read_bn, compute_complexity_width, read_jkl, write_jkl, get_domain_sizes, \\\n CWDecomposition\n\nimport matplotlib.pyplot as plt\nfrom networkx.drawing.nx_agraph import pygraphviz_layout\n\nSOLVER_DIR = \"../solvers\"\nSCORE_PATN = re.compile(r\"New improvement! (?P[\\d.-]+) \\(after (?P